From 718eaab1236352d0cb1c1eef26ea6cf29a8f725b Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Sun, 25 Dec 2022 16:29:10 -0800 Subject: [PATCH 001/709] added func for watchdog name, created watchdog instance class --- org.lflang/src/org/lflang/LinguaFranca.xtext | 8 ++- .../lflang/generator/ReactionInstance.java | 6 ++ .../lflang/generator/WatchdogInstance.java | 59 +++++++++++++++++++ .../generator/c/CReactionGenerator.java | 11 ++++ 4 files changed, 82 insertions(+), 2 deletions(-) create mode 100644 org.lflang/src/org/lflang/generator/WatchdogInstance.java diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index 38dc520c0b..c28f35065e 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -201,7 +201,8 @@ Reaction: ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? code=Code (stp=STP)? - (deadline=Deadline)?; + (deadline=Deadline)? + (watchdog=Watchdog)?; TriggerRef: BuiltinTriggerRef | VarRef; @@ -211,6 +212,9 @@ BuiltinTriggerRef: Deadline: 'deadline' '(' delay=Expression ')' code=Code; + +Watchdog: + 'watchdog' nameID=Expression '(' delay=Expression ')' code=Code; STP: 'STP' '(' value=Expression ')' code=Code; @@ -486,7 +490,7 @@ Token: 'mutable' | 'input' | 'output' | 'timer' | 'action' | 'reaction' | 'startup' | 'shutdown' | 'after' | 'deadline' | 'mutation' | 'preamble' | 'new' | 'federated' | 'at' | 'as' | 'from' | 'widthof' | 'const' | 'method' | - 'interleaved' | 'mode' | 'initial' | 'reset' | 'history' | + 'interleaved' | 'mode' | 'initial' | 'reset' | 'history' | 'watchdog' // Other terminals NEGINT | TRUE | FALSE | // Action origins diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/src/org/lflang/generator/ReactionInstance.java index f20962d70d..737d814049 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstance.java @@ -223,6 +223,12 @@ public ReactionInstance( */ public DeadlineInstance declaredDeadline; + //FIXME: modif4watchdog + /** + * Watchdog for this reaction instance, if declared. + */ + public WatchdogInstance declaredWatchdog; + /** * Inferred deadline. Defaults to the maximum long value. */ diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java new file mode 100644 index 0000000000..40b02edd66 --- /dev/null +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -0,0 +1,59 @@ +package org.lflang.generator; + +import org.lflang.TimeValue; +import org.lflang.lf.Watchdog; + +/** + * Instance of a watchdog. Upon creation the actual delay is converted into + * a proper time value. If a parameter is referenced, it is looked up in the + * given (grand)parent reactor instance. + * + * @author{Benjamin Asch } + */ +//FIXME: modif4watchdogs +public class WatchdogInstance { + + /** + * Create a new watchdog instance associated with the given reaction + * instance. + */ + public WatchdogInstance(Watchdog definition, ReactionInstance reaction) { + if (definition.getTimeout() != null) { + this.timeout = reaction.parent.getTimeValue(definition.getTimeout()); + } else { + this.timeout = TimeValue.ZERO; + } + + if (definition.getCode() != null) { + this.watchdogHandler = definition.getCode(); + } else { + this.watchdogHandler = new CodeBuilder(); + } + } + + ////////////////////////////////////////////////////// + //// Public fields. + + /** + * The timeout, L, associated with this deadline. The physical timer gets set + * to expire at physical time, P, equal to the current logical time, t, plus the timeout. + * + * In other words, the watchdog condition is met iff P < t + L while the watchdog has not + * been stopped or reset. + */ + public final TimeValue timeout; + + /** + * The code body for the function that is executed upon calling the watchdog. + */ + public final CodeBuilder watchdogHandler; + + ////////////////////////////////////////////////////// + //// Public methods. + + //FIXME: unsure of use or need for watchdogs + @Override + public String toString() { + return "WatchdogInstance " + timeout.toString(); + } +} diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index cac6594edc..3fa09cb494 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -1132,6 +1132,17 @@ public static String generateFunction(String header, String init, Code code) { return function.toString(); } + // FIXME: modif4watchdogs + /** + * Returns the name of the watchdog function for reaction. + * @param decl The reactor with the watchdog + * @param reactionIndex The number assigned to this reaction watchdog + * @return Name of the watchdog function for reaction + */ + public static String generateWatchdogFunctionName(ReactorDecl decl, int reactionIndex) { + return decl.getName().toLowerCase() + "_watchdog_function" + reactionIndex; + } + /** * Returns the name of the deadline function for reaction. * @param decl The reactor with the deadline From 43bb491830d62be9c3747aafc17a219a4f1d3fed Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 5 Jan 2023 00:01:10 -0800 Subject: [PATCH 002/709] made some progress on code generation --- .../src/org/lflang/generator/WatchdogInstance.java | 3 +++ org.lflang/src/org/lflang/generator/c/CGenerator.java | 5 +++++ .../src/org/lflang/generator/c/CReactionGenerator.java | 9 +++++++++ 3 files changed, 17 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index 40b02edd66..290c7144a9 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -11,6 +11,7 @@ * @author{Benjamin Asch } */ //FIXME: modif4watchdogs +//FIXME: functions in constructor not defined public class WatchdogInstance { /** @@ -29,6 +30,8 @@ public WatchdogInstance(Watchdog definition, ReactionInstance reaction) { } else { this.watchdogHandler = new CodeBuilder(); } + + this.name = definition.getName(); } ////////////////////////////////////////////////////// diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index ec2b7986c3..6913d7bed7 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -929,6 +929,11 @@ private boolean hasDeadlines(List reactors) { return false; } + //FIXME: modif4watchdogs + private boolean hasWatchdogs(List reactors) { + + } + /** * Look at the 'reactor' eResource. * If it is an imported .lf file, incorporate it into the current diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 3fa09cb494..5f017e89a2 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -759,6 +759,14 @@ public static void generateReactionAndTriggerStructs( deadlineFunctionPointer = "&" + deadlineFunctionName; } + // FIXME: modif4watchdogs + // FIXME: '.getWatchdog()' not implemented + var watchdogFunctionPointer = "NULL"; + if (reaction.getWatchdog() != null) { + var watchdogFunctionName = generateWatchdogFunctionName(decl, reactionCount); + watchdogFunctionPointer = "&" + watchdogFunctionName; + } + // Assign the STP handler var STPFunctionPointer = "NULL"; if (reaction.getStp() != null) { @@ -780,6 +788,7 @@ public static void generateReactionAndTriggerStructs( "self->_lf__reaction_"+reactionCount+".function = "+ CReactionGenerator.generateReactionFunctionName(decl, reactionCount)+";", "self->_lf__reaction_"+reactionCount+".self = self;", "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", + "self->_lf__reaction_"+reactionCount+".watchdog_handler = "+watchdogFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", (reaction.eContainer() instanceof Mode ? From 20531f07fd21ebbfbf4fa904d347b1858d54e983 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 5 Jan 2023 12:48:54 -0800 Subject: [PATCH 003/709] more functions added for code generation --- org.lflang/src/org/lflang/ASTUtils.java | 13 ++++++++ .../lflang/generator/ReactionInstance.java | 8 +++++ .../org/lflang/generator/c/CGenerator.java | 10 ++++-- .../generator/c/CReactionGenerator.java | 31 +++++++++++++++++++ 4 files changed, 60 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index dc15877879..181eb5c81a 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -144,6 +144,19 @@ public static Iterable getAllReactors(Resource resource) { .collect(Collectors.toList()); } + /** + * Get all watchdogs defined in the given resource. + * @param resource the resource to extract watchdogs from + * @return An iterable over all watchdogs found in the resource + */ + //FIXME: modif4watchdogs + public static Iterable getAllWatchdogs(Resource resource) { + return StreamSupport.stream(IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) + .filter(Watchdog.class::isInstance) + .map(Watchdog.class::cast) + .collect(Collectors.toList()); + } + /** * Find connections in the given resource that have a delay associated with them, * and reroute them via a generated delay reactor. diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/src/org/lflang/generator/ReactionInstance.java index 737d814049..b7fffe132f 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstance.java @@ -187,6 +187,14 @@ public ReactionInstance( this.declaredDeadline = new DeadlineInstance( this.definition.getDeadline(), this); } + + //FIXME: modif4watchdogs + // getWatchdog not implemented + // need to implement matching reaction output with watchdog + if (this.definition.getWatchdog() != null) { + this.declaredWatchdog = new WatchdogInstance( + this.definition.getWatchdog(), this); + } } ////////////////////////////////////////////////////// diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 6913d7bed7..d022942dce 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -930,8 +930,14 @@ private boolean hasDeadlines(List reactors) { } //FIXME: modif4watchdogs - private boolean hasWatchdogs(List reactors) { - + //FIXME: getWatchdog() has not been implemented + private boolean hasWatchdogs(Reactor reactor) { + for (Reaction reaction : allReactions(reactor)) { + if (reaction.getWatchdog() != null) { + return true; + } + } + return false; } /** diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 5f017e89a2..97f69baeae 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -1005,6 +1005,16 @@ public static String generateLfTriggerStartupReactions(int startupReactionCount, return s.toString(); } + /** + * Generate _lf_initialize_watchdog_mutexes function. + */ + //FIXME: modif4watchdogs + //FIXME: finish implementing + public static String generateLfInitializeWatchdogMutexes(List reactors) { + // need to find way to assign get watchdog from AST + // need to assign watchdog to correct reaction + } + /** * Generate the _lf_trigger_shutdown_reactions function. */ @@ -1122,6 +1132,15 @@ public static String generateReaction( generateDeadlineFunctionHeader(decl, reactionIndex), init, reaction.getDeadline().getCode())); } + + // FIXME:modif4watchdogs + // Now generate code for the watchdog handler function, if there is one. + if (reaction.getWatchdog() != null) { + code.pr(generateFunction( + generateWatchdogFunctionHeader(decl, reactionIndex), + init, reaction.getWatchdog().getCode())); + } + CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(decl), code); code.pr( "#include " + StringUtil.addDoubleQuotes( @@ -1192,6 +1211,18 @@ public static String generateDeadlineFunctionHeader(ReactorDecl decl, return generateFunctionHeader(functionName); } + /** Return the top level C function header for the watchdog function numbered "reactionIndex" in "decl" + * @param decl The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the watchdog function. + */ + //FIXME: modif4watchdogs + public static String generateWatchdogFunctionHeader(ReactorDecl decl, + int reactionIndex) { + String functionName = generateWatchdogFunctionName(decl, reactionIndex); + return generateFunctionHeader(functionName); + } + /** Return the top level C function header for the reaction numbered "reactionIndex" in "decl" * @param decl The reactor declaration * @param reactionIndex The reaction index. From 371385e003015e3670546e23f6ebf3d469d53ffb Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Sun, 8 Jan 2023 11:28:32 -0800 Subject: [PATCH 004/709] saving progress before pushing --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 4 ++++ org.lflang/src/org/lflang/generator/c/CReactionGenerator.java | 3 +++ 2 files changed, 7 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index d022942dce..af62bd8b8f 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -840,6 +840,10 @@ private void generateCodeForCurrentFederate( // Generate function to schedule timers for all reactors. code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); + //FIXME:modif4watchdogs + // Generate function to initialize mutexes for all reactors with watchdogs. + code.pr(CReactionGenerator.generateLfInitializeWatchdogMutexes()); + // Generate a function that will either do nothing // (if there is only one federate or the coordination // is set to decentralized) or, if there are diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 97f69baeae..06bbaf853c 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -1013,6 +1013,9 @@ public static String generateLfTriggerStartupReactions(int startupReactionCount, public static String generateLfInitializeWatchdogMutexes(List reactors) { // need to find way to assign get watchdog from AST // need to assign watchdog to correct reaction + var s = new StringBuilder(); + s.append("void _lf_initialize_watchdog_mutexes() {\n"); + } /** From 86c369d36b0736223789544361fa751d4cabe1bb Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Sun, 8 Jan 2023 14:55:02 -0800 Subject: [PATCH 005/709] fixed grammar(added watchdog to 'varreformodetransition', removed watchdog from reaction) --- org.lflang/src/org/lflang/LinguaFranca.xtext | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index c28f35065e..f39eb724cb 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -201,8 +201,7 @@ Reaction: ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? code=Code (stp=STP)? - (deadline=Deadline)? - (watchdog=Watchdog)?; + (deadline=Deadline)?; TriggerRef: BuiltinTriggerRef | VarRef; @@ -214,7 +213,7 @@ Deadline: 'deadline' '(' delay=Expression ')' code=Code; Watchdog: - 'watchdog' nameID=Expression '(' delay=Expression ')' code=Code; + 'watchdog' name=Expression '(' timeout=Expression ')' code=Code; STP: 'STP' '(' value=Expression ')' code=Code; @@ -283,7 +282,7 @@ VarRef: | interleaved?='interleaved' '(' (variable=[Variable] | container=[Instantiation] '.' variable=[Variable]) ')' ; VarRefOrModeTransition returns VarRef: - VarRef | transition=ModeTransition '(' variable=[Mode] ')'; + VarRef | Watchdog | transition=ModeTransition '(' variable=[Mode] ')'; Assignment: (lhs=[Parameter] ( From 15fc495b762139bbf327b2ba1698a695a0b5a453 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Sun, 8 Jan 2023 14:58:40 -0800 Subject: [PATCH 006/709] added watchdog grammar to reactor --- org.lflang/src/org/lflang/LinguaFranca.xtext | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index f39eb724cb..718382335d 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -91,6 +91,7 @@ Reactor: | (connections+=Connection) | (reactions+=Reaction) | (modes+=Mode) + (watchdogs+=Watchdog) )* '}'; From 6124cae9328288ce6bf8ee387997b44087681c86 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 12 Jan 2023 15:29:17 -0800 Subject: [PATCH 007/709] making sure updated before push --- org.lflang/src/org/lflang/ASTUtils.java | 28 ++-- org.lflang/src/org/lflang/LinguaFranca.xtext | 4 +- .../lflang/generator/ReactionInstance.java | 16 +- .../org/lflang/generator/ReactorInstance.java | 4 + .../org/lflang/generator/c/CGenerator.java | 19 ++- .../generator/c/CReactionGenerator.java | 89 +++++------ .../generator/c/CWatchdogGenerator.java | 140 ++++++++++++++++++ 7 files changed, 212 insertions(+), 88 deletions(-) create mode 100644 org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 181eb5c81a..b87dc94479 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -122,13 +122,16 @@ public class ASTUtils { /** * A mapping from Reactor features to corresponding Mode features for collecting contained elements. */ + //FIXME: modif4watchdogs + // added 'featurePackage.getReactor_Watchdogs' private static final Map reactorModeFeatureMap = Map.of( featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), - featurePackage.getReactor_Timers(), featurePackage.getMode_Timers() + featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), + featurePackage.getReactor_Watchdogs() ); @@ -144,19 +147,6 @@ public static Iterable getAllReactors(Resource resource) { .collect(Collectors.toList()); } - /** - * Get all watchdogs defined in the given resource. - * @param resource the resource to extract watchdogs from - * @return An iterable over all watchdogs found in the resource - */ - //FIXME: modif4watchdogs - public static Iterable getAllWatchdogs(Resource resource) { - return StreamSupport.stream(IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) - .filter(Watchdog.class::isInstance) - .map(Watchdog.class::cast) - .collect(Collectors.toList()); - } - /** * Find connections in the given resource that have a delay associated with them, * and reroute them via a generated delay reactor. @@ -686,6 +676,16 @@ public static List allParameters(Reactor definition) { public static List allReactions(Reactor definition) { return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); } + + /** + * Given a reactor class, return a list of all its watchdogs. + * @param definition Reactor class definition + * @return List + */ + // FIXME: modif4watchdogs + public static List allWatchdogs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); + } /** * Given a reactor class, return a list of all its state variables, diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index 718382335d..e624e61c53 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -214,7 +214,9 @@ Deadline: 'deadline' '(' delay=Expression ')' code=Code; Watchdog: - 'watchdog' name=Expression '(' timeout=Expression ')' code=Code; + 'watchdog' name=Expression '(' timeout=Expression ')' + ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? + code=Code; STP: 'STP' '(' value=Expression ')' code=Code; diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/src/org/lflang/generator/ReactionInstance.java index b7fffe132f..13dc1e1c52 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstance.java @@ -187,14 +187,6 @@ public ReactionInstance( this.declaredDeadline = new DeadlineInstance( this.definition.getDeadline(), this); } - - //FIXME: modif4watchdogs - // getWatchdog not implemented - // need to implement matching reaction output with watchdog - if (this.definition.getWatchdog() != null) { - this.declaredWatchdog = new WatchdogInstance( - this.definition.getWatchdog(), this); - } } ////////////////////////////////////////////////////// @@ -230,13 +222,7 @@ public ReactionInstance( * Deadline for this reaction instance, if declared. */ public DeadlineInstance declaredDeadline; - - //FIXME: modif4watchdog - /** - * Watchdog for this reaction instance, if declared. - */ - public WatchdogInstance declaredWatchdog; - + /** * Inferred deadline. Defaults to the maximum long value. */ diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index ae953e9370..dbed569762 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -150,6 +150,10 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re /** List of reaction instances for this reactor instance. */ public final List reactions = new ArrayList<>(); + /** List of watchdog instances for this reactor instance. */ + //FIXME: modif4watchdogs + public final List watchdogs = new ArrayList<>(); + /** The timer instances belonging to this reactor instance. */ public final List timers = new ArrayList<>(); diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index af62bd8b8f..4579e32534 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -934,12 +934,9 @@ private boolean hasDeadlines(List reactors) { } //FIXME: modif4watchdogs - //FIXME: getWatchdog() has not been implemented private boolean hasWatchdogs(Reactor reactor) { - for (Reaction reaction : allReactions(reactor)) { - if (reaction.getWatchdog() != null) { - return true; - } + if (ASTUtils.allWatchdogs(reactor) != null) { + return true; } return false; } @@ -1532,6 +1529,18 @@ protected void generateSelfStructExtension( // Do nothing } + /** + * Generate watchdog functions definition for a reactor. + * @param decl The reactor + * @param federate The federate, or null if this is not + * federated or not the main reactor and watchdogs should be + * unconditionally generated. + */ + //FIXME: modif4watchdogs + public void generateWatchdogFunctions(ReactorDecl decl, FederateInstance federate) { + + } + /** Generate reaction functions definition for a reactor. * These functions have a single argument that is a void* pointing to * a struct that contains parameters, state variables, inputs (triggering or not), diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 06bbaf853c..f5aff5d55e 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -195,6 +195,15 @@ public static String generateInitializationForReaction(String body, effect.getContainer(), (Input) variable ); + } else if (variable instanceof Watchdog) { + //FIXME: modif4watchdogs + // How does it know if instance of watchdog? + reactionInitialization.pr(generateWatchdogVariablesInReaction( + effect, + decl, + errorReporter, + requiresTypes + )); } else { errorReporter.reportError( reaction, @@ -679,6 +688,31 @@ public static String generateOutputVariablesInReaction( } } + /** + * Generate into the specified string builder the code to + * initialize local variables for watchdogs in a reaction function + * from the "self" struct. + * @param effect The effect declared by the reaction. This must refer to a watchdog. + * @param decl The reactor containing the reaction or the import statement. + */ + //FIXME: modif4watchdogs + // Fine to have watchdog be in reactor self struct? + public static String generateWatchdogVariablesInReaction( + VarRef effect, + ReactorDecl decl, + ErrorReporter errorReporter, + boolean requiresTypes + ) { + Watchdog watchdog = (Watchdog) effect.getVariable(); + String watchdogName = watchdog.getName(); + if (watchdog.getType() == null && requiresTypes) { + errorReporter.reportError(watchdog, "Watchdog is required to have a type: " + watchdogName); + return ""; + } else { + return "watchdog_t* "+watchdogName+" = &self->_lf_watchdog_"+watchdogName+";"; + } + } + /** * Generate the fields of the self struct and statements for the constructor * to create and initialize a reaction_t struct for each reaction in the @@ -759,14 +793,6 @@ public static void generateReactionAndTriggerStructs( deadlineFunctionPointer = "&" + deadlineFunctionName; } - // FIXME: modif4watchdogs - // FIXME: '.getWatchdog()' not implemented - var watchdogFunctionPointer = "NULL"; - if (reaction.getWatchdog() != null) { - var watchdogFunctionName = generateWatchdogFunctionName(decl, reactionCount); - watchdogFunctionPointer = "&" + watchdogFunctionName; - } - // Assign the STP handler var STPFunctionPointer = "NULL"; if (reaction.getStp() != null) { @@ -1005,19 +1031,6 @@ public static String generateLfTriggerStartupReactions(int startupReactionCount, return s.toString(); } - /** - * Generate _lf_initialize_watchdog_mutexes function. - */ - //FIXME: modif4watchdogs - //FIXME: finish implementing - public static String generateLfInitializeWatchdogMutexes(List reactors) { - // need to find way to assign get watchdog from AST - // need to assign watchdog to correct reaction - var s = new StringBuilder(); - s.append("void _lf_initialize_watchdog_mutexes() {\n"); - - } - /** * Generate the _lf_trigger_shutdown_reactions function. */ @@ -1136,14 +1149,6 @@ public static String generateReaction( init, reaction.getDeadline().getCode())); } - // FIXME:modif4watchdogs - // Now generate code for the watchdog handler function, if there is one. - if (reaction.getWatchdog() != null) { - code.pr(generateFunction( - generateWatchdogFunctionHeader(decl, reactionIndex), - init, reaction.getWatchdog().getCode())); - } - CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(decl), code); code.pr( "#include " + StringUtil.addDoubleQuotes( @@ -1163,17 +1168,6 @@ public static String generateFunction(String header, String init, Code code) { return function.toString(); } - // FIXME: modif4watchdogs - /** - * Returns the name of the watchdog function for reaction. - * @param decl The reactor with the watchdog - * @param reactionIndex The number assigned to this reaction watchdog - * @return Name of the watchdog function for reaction - */ - public static String generateWatchdogFunctionName(ReactorDecl decl, int reactionIndex) { - return decl.getName().toLowerCase() + "_watchdog_function" + reactionIndex; - } - /** * Returns the name of the deadline function for reaction. * @param decl The reactor with the deadline @@ -1214,18 +1208,6 @@ public static String generateDeadlineFunctionHeader(ReactorDecl decl, return generateFunctionHeader(functionName); } - /** Return the top level C function header for the watchdog function numbered "reactionIndex" in "decl" - * @param decl The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the watchdog function. - */ - //FIXME: modif4watchdogs - public static String generateWatchdogFunctionHeader(ReactorDecl decl, - int reactionIndex) { - String functionName = generateWatchdogFunctionName(decl, reactionIndex); - return generateFunctionHeader(functionName); - } - /** Return the top level C function header for the reaction numbered "reactionIndex" in "decl" * @param decl The reactor declaration * @param reactionIndex The reaction index. @@ -1243,7 +1225,8 @@ public static String generateStpFunctionHeader(ReactorDecl decl, return generateFunctionHeader(functionName); } - private static String generateFunctionHeader(String functionName) { + //FIXME: modif4watchdogs (changed from private to public to access in CWatchdogGenerator) + public static String generateFunctionHeader(String functionName) { return "void " + functionName + "(void* instance_args)"; } } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java new file mode 100644 index 0000000000..1c31ee5779 --- /dev/null +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -0,0 +1,140 @@ +package org.lflang.generator.c; + +import org.lflang.federated.FederateInstance; +import org.lflang.generator.CodeBuilder; +import org.lflang.lf.ReactorDecl; +import org.lflang.lf.CReactionGenerator; + +/** + * Generates necessary C code for watchdogs. + * + * @author{Benjamin Asch } + */ +//FIXME: modif4watchdogs +public class CWatchdogGenerator { + + /** + * Generate necessary initialization code inside the body of the watchdog that belongs to reactor decl. + * @param decl The reactor that has the watchdog + */ + public static String generateInitializationForWatchdog(Watchdog watchdog, + ReactorDecl decl) { + Reactor reactor = ASTUtils.toDefinition(decl); + + // Construct the reactionInitialization code to go into + // the body of the function before the verbatim code. + CodeBuilder watchdogInitialization = new CodeBuilder(); + + CodeBuilder code = new CodeBuilder(); + + // Define the "self" struct. + String structType = CUtil.selfType(decl); + // A null structType means there are no inputs, state, + // or anything else. No need to declare it. + if (structType != null) { + code.pr(String.join("\n", + structType+"* self = ("+structType+"*)instance_args; SUPPRESS_UNUSED_WARNING(self);" + )); + } + + // Declare mode if in effects field of watchdog + if (watchdog.getEffects() != null) { + for (VarRef effect : watchdog.getEffects()) { + Variable variable = effect.getVariable(); + if (variable instanceof Mode) { + // Mode change effect + int idx = ASTUtils.allModes(reactor).indexOf((Mode)effect.getVariable()); + String name = effect.getVariable().getName(); + if (idx >= 0) { + watchdogInitialization.pr( + "reactor_mode_t* " + name + " = &self->_lf__modes[" + idx + "];\n" + + "lf_mode_change_type_t _lf_" + name + "_change_type = " + + (effect.getTransition() == ModeTransition.HISTORY ? + "history_transition" : "reset_transition") + + ";" + ); + } + // FIXME: include error reporter + // else { + // errorReporter.reportError( + // watchdog, + // "In generateWatchdog(): " + name + " not a valid mode of this reactor." + // ); + // } + } + } + } + + // Next generate all the collected setup code. + code.pr(watchdogInitialization.toString()); + return code.toString(); + } + + /** + * Returns the name of the watchdog function for reaction. + * @param decl The reactor with the watchdog + * @param watchdog The watchdog + * @return Name of the watchdog function for reaction + */ + public static String generateWatchdogFunctionName(Watchdog watchdog, ReactorDecl decl) { + return decl.getName().toLowerCase() + "_" + watchdog.getName().toLowerCase() + "_watchdog_function"; + } + + /** Return the top level C function header for the watchdog function in "decl" + * @param decl The reactor declaration + * @param watchdog The watchdog. + * @return The function name for the watchdog function. + */ + public static String generateWatchdogFunctionHeader(Watchdog watchdog, + ReactorDecl decl) { + String functionName = generateWatchdogFunctionName(watchdog, decl); + return CReactionGenerator.generateFunctionHeader(functionName); + } + + /** + * Generate the watchdog function. + */ + public static String generateWatchdogFunction(Watchdog watchdog, + ReactorDecl decl) { + return CReactionGenerator.generateFunction(generateWatchdogFunctionHeader(watchdog, decl), + generateInitializationForWatchdog(watchdog, decl), + watchdog.getCode()); + } + + /** + * Generate a constructor for the specified reactor in the specified federate. + * @param reactor The parsed reactor data structure. + * @param federate A federate name, or null to unconditionally generate. + * @param constructorCode Lines of code previously generated that need to + * go into the constructor. + */ + //FIXME: this is just the old constructor meant for reactors + public static String generateWatchdogConstructor( + ReactorDecl reactor, + FederateInstance federate, + String constructorCode + ) { + var structType = CUtil.selfType(reactor); + var code = new CodeBuilder(); + code.pr(structType+"* new_"+reactor.getName()+"() {"); + code.indent(); + code.pr(structType+"* self = ("+structType+"*)_lf_new_reactor(sizeof("+structType+"));"); + code.pr(constructorCode); + code.pr("return self;"); + code.unindent(); + code.pr("}"); + return code.toString(); + } + + /** + * Generate _lf_initialize_watchdog_mutexes function. + */ + //FIXME: finish implementing + public static String generateLfInitializeWatchdogMutexes(List reactors) { + // need to find way to assign get watchdog from AST + // need to assign watchdog to correct reaction + var s = new StringBuilder(); + s.append("void _lf_initialize_watchdog_mutexes() {\n"); + + } +} From 3798f3a62f73be544e9c82d6a721c74f56a677c8 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 18 Jan 2023 14:20:03 -0800 Subject: [PATCH 008/709] code generation steps (excluding mutex initialization) should be done, I think --- .../org/lflang/generator/ReactorInstance.java | 22 +++++ .../lflang/generator/WatchdogInstance.java | 23 ++--- .../org/lflang/generator/c/CGenerator.java | 40 +++++++++ .../generator/c/CReactionGenerator.java | 5 +- .../generator/c/CWatchdogGenerator.java | 85 +++++++++++++++---- 5 files changed, 144 insertions(+), 31 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index dbed569762..46b34c662f 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -720,6 +720,24 @@ protected void createReactionInstances() { } } + /** + * Create all the watchdog instances of this reactor instance. + */ + // FIXME: modif4watchdogs + protected void createWatchdogInstances() { + List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); + if (watchdogs != null) { + for (Watchdog watchdog : watchdogs) { + // Create the watchdog instance. + var watchdogInstance = new WatchdogInstance(watchdog, this); + + // Add the watchdog instance to the list of watchdogs for this + // reactor. + this.watchdogs.add(watchdogInstance); + } + } + } + /** * Returns the built-in trigger or create a new one if none exists. */ @@ -834,6 +852,10 @@ private ReactorInstance( // Note that this can only happen _after_ the children, // port, action, and timer instances have been created. createReactionInstances(); + + // Create the reaction instances in this reactor instance. + // FIXME: modif4watchdogs + createWatchdogInstances(); // Instantiate modes for this reactor instance // This must come after the child elements (reactions, etc) of this reactor diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index 290c7144a9..ff9bc139df 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -18,22 +18,23 @@ public class WatchdogInstance { * Create a new watchdog instance associated with the given reaction * instance. */ - public WatchdogInstance(Watchdog definition, ReactionInstance reaction) { + public WatchdogInstance(Watchdog definition, ReactorInstance reactor) { if (definition.getTimeout() != null) { - this.timeout = reaction.parent.getTimeValue(definition.getTimeout()); + // WATCHDOG QUESTION + // How does this .getTimeValue work? Where is expression coming from + // versus other time parameters? + this.timeout = reactor.getTimeValue(definition.getTimeout()); } else { this.timeout = TimeValue.ZERO; } - if (definition.getCode() != null) { - this.watchdogHandler = definition.getCode(); - } else { - this.watchdogHandler = new CodeBuilder(); - } - this.name = definition.getName(); } + public String getName() { + return this.name; + } + ////////////////////////////////////////////////////// //// Public fields. @@ -46,10 +47,10 @@ public WatchdogInstance(Watchdog definition, ReactionInstance reaction) { */ public final TimeValue timeout; - /** - * The code body for the function that is executed upon calling the watchdog. + /** + * The watchdog name. */ - public final CodeBuilder watchdogHandler; + public final String name; ////////////////////////////////////////////////////// //// Public methods. diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 4579e32534..f27c16ecc1 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1213,6 +1213,8 @@ private void generateReactorClass(ReactorDecl reactor) { generateAuxiliaryStructs(reactor); generateSelfStruct(reactor, constructorCode); generateMethods(reactor); + // FIXME: modif4watchdogs + generateWatchdogs(reactor, currentFederate); generateReactions(reactor, currentFederate); generateConstructor(reactor, currentFederate, constructorCode); @@ -1584,6 +1586,42 @@ protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactio )); } + // FIXME: modif4watchdogs + /** Generate watchdog functions definition for a reactor. + * These functions have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param decl The reactor. + * @param federate The federate, or null if this is not + * federated or not the main reactor and reactions should be + * unconditionally generated. + */ + public void generateWatchdogs(ReactorDecl decl, FederateInstance federate) { + // WATCHDOG QUESTION: A similar question is asked somewhere else for a + // different function - Do we need to check if this federate contains the + // watchdog? This is done in the code generation for reactions. + var reactor = ASTUtils.toDefinition(decl); + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + if (federate == null || federate.contains(watchdog)) { + generateWatchdog(watchdog, decl); + } + } + } + + /** Generate a watchdog function definition for a reactor. + * This function will have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param watchdog The watchdog. + * @param decl The reactor. + */ + protected void generateWatchdog(Watchdog watchdog, ReactorDecl decl) { + code.pr(CWatchdogGenerator.generateWatchdog( + watchdog, + decl + )); + } + /** * Record startup, shutdown, and reset reactions. * @param instance A reactor instance. @@ -2077,6 +2115,8 @@ protected void generateStateVariableInitializations(ReactorInstance instance) { * specified reactor instance. * @param instance The reactor instance. */ + // WATCHDOG QUESTION: Why do we wait to set the deadline instead of defining + // it in the constructor of the reactor? private void generateSetDeadline(ReactorInstance instance) { for (ReactionInstance reaction : instance.reactions) { if (currentFederate.contains(reaction.getDefinition())) { diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index f5aff5d55e..0f1d0ee2fb 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -197,7 +197,6 @@ public static String generateInitializationForReaction(String body, ); } else if (variable instanceof Watchdog) { //FIXME: modif4watchdogs - // How does it know if instance of watchdog? reactionInitialization.pr(generateWatchdogVariablesInReaction( effect, decl, @@ -745,6 +744,9 @@ public static void generateReactionAndTriggerStructs( var startupReactions = new LinkedHashSet(); var shutdownReactions = new LinkedHashSet(); var resetReactions = new LinkedHashSet(); + // WATCHDOG QUESTION: Why need to grab all reactions from reactor only to check + // if it exists in currentFederate? Maybe real question is what is difference between + // currentfederate and reactor? for (Reaction reaction : ASTUtils.allReactions(reactor)) { if (currentFederate.contains(reaction)) { // Create the reaction_t struct. @@ -814,7 +816,6 @@ public static void generateReactionAndTriggerStructs( "self->_lf__reaction_"+reactionCount+".function = "+ CReactionGenerator.generateReactionFunctionName(decl, reactionCount)+";", "self->_lf__reaction_"+reactionCount+".self = self;", "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", - "self->_lf__reaction_"+reactionCount+".watchdog_handler = "+watchdogFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", (reaction.eContainer() instanceof Mode ? diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 1c31ee5779..578e6bc7a5 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -1,5 +1,6 @@ package org.lflang.generator.c; +import org.lflang.ASTUtils; import org.lflang.federated.FederateInstance; import org.lflang.generator.CodeBuilder; import org.lflang.lf.ReactorDecl; @@ -102,27 +103,75 @@ public static String generateWatchdogFunction(Watchdog watchdog, } /** - * Generate a constructor for the specified reactor in the specified federate. - * @param reactor The parsed reactor data structure. - * @param federate A federate name, or null to unconditionally generate. - * @param constructorCode Lines of code previously generated that need to - * go into the constructor. + * Generate watchdog definition in parent struct. */ - //FIXME: this is just the old constructor meant for reactors - public static String generateWatchdogConstructor( - ReactorDecl reactor, - FederateInstance federate, - String constructorCode + public static void generateWatchdogStruct( + FederateInstance currentFederate, + CodeBuilder body, + ReactorDecl decl, + CodeBuilder constructorCode + ) { + var reactor = ASTUtils.toDefinition(decl); + + // WATCHDOG QUESTION 1: I followed similar format to + // `CReactionGenerator.generateReactionAndTriggerStructs` + // but am not sure why we need to check if watchdog exists in the + // current federate. + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + if (currentFederate.contains(watchdog)) { + + String watchdogName = watchdog.getName(); + // Create pointer to the watchdog_t struct + // WATCHDOG QUESTION 2: Why need to put object at beginning of + // `.pr` func call? + + // WATCHDOG QUESTION 3: Is the space for this struct automatically allocated + // through `_lf_new_reactor`? `_lf__startup_reaction` is also a pointer in self struct + // but does not seem to have a separate allocation call. + body.pr(watchdog, "watchdog_t* _lf_watchdog_"+watchdogName+";"); + + // WATCHDOG QUESTION 4: Not sure if this is correct, may need to use + // 'getTargetTime' instead. watchdog timeout is listed as "Expression" + // in the grammar, so I'm not sure if it is reading the timeout as + // a Time class or TimeValue class. + var min_expiration = GeneratorBase.timeInTargetLanguage(watchdog.getTimeout()); + + // watchdog function name + var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); + // Set values of watchdog_t struct in the reactor's constructor + // WATCHDOG QUESTION 5: should I be defining these in the constructor of the reactor? + constructorCode.pr(watchdog, String.join("\n", + "self->_lf_watchdog_"+watchdogName+".self = self;", + "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", + "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", + "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";" + )); + + // WATCHDOG QUESTION 6: should I be initializing mutex in this constructor? + } + } + } + + /** Generate a watchdog function definition for a reactor. + * This function will have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param watchdog The watchdog. + * @param decl The reactor. + */ + public static String generateWatchdog( + Watchdog watchdog, + ReactorDecl decl ) { - var structType = CUtil.selfType(reactor); var code = new CodeBuilder(); - code.pr(structType+"* new_"+reactor.getName()+"() {"); - code.indent(); - code.pr(structType+"* self = ("+structType+"*)_lf_new_reactor(sizeof("+structType+"));"); - code.pr(constructorCode); - code.pr("return self;"); - code.unindent(); - code.pr("}"); + + // WATCHDOG QUESTION: Do I need this header? What it for? + code.pr( + "#include " + StringUtil.addDoubleQuotes( + CCoreFilesUtils.getCTargetSetHeader())); + + code.pr(generateWatchdogFunction(watchdog, decl)); + return code.toString(); } From bf4fd4cfd5af0e084cc267efa99cdc54f82bdcc1 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 18 Jan 2023 14:54:07 -0800 Subject: [PATCH 009/709] generatewatchdogstruct in generateselfstruct --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 8 ++++++++ .../src/org/lflang/generator/c/CReactionGenerator.java | 3 +-- .../src/org/lflang/generator/c/CWatchdogGenerator.java | 2 +- 3 files changed, 10 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index f27c16ecc1..9dfffdd039 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1369,6 +1369,14 @@ private void generateSelfStruct(ReactorDecl decl, CodeBuilder constructorCode) { isFederatedAndDecentralized() ); + // Generate the fields needed for each watchdog. + CWatchdogGenerator.generateWatchdogStruct( + currentFederate, + body, + decl, + constructorCode + ); + // Next, generate fields for modes CModesGenerator.generateDeclarations(reactor, body, constructorCode); diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 0f1d0ee2fb..4cebf42a8f 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -745,8 +745,7 @@ public static void generateReactionAndTriggerStructs( var shutdownReactions = new LinkedHashSet(); var resetReactions = new LinkedHashSet(); // WATCHDOG QUESTION: Why need to grab all reactions from reactor only to check - // if it exists in currentFederate? Maybe real question is what is difference between - // currentfederate and reactor? + // if it exists in currentFederate? for (Reaction reaction : ASTUtils.allReactions(reactor)) { if (currentFederate.contains(reaction)) { // Create the reaction_t struct. diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 578e6bc7a5..b8b78803c3 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -113,7 +113,7 @@ public static void generateWatchdogStruct( ) { var reactor = ASTUtils.toDefinition(decl); - // WATCHDOG QUESTION 1: I followed similar format to + // WATCHDOG QUESTION 1: I followed similar structure to // `CReactionGenerator.generateReactionAndTriggerStructs` // but am not sure why we need to check if watchdog exists in the // current federate. From b87327f2c786d112b34951ab8ad006c14f3f0d48 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 1 Feb 2023 10:00:02 -0800 Subject: [PATCH 010/709] save changes to watchdog --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/ASTUtils.java | 4 +- org.lflang/src/org/lflang/LinguaFranca.xtext | 4 +- .../lflang/federated/FederateInstance.java | 18 +++++++ .../org/lflang/generator/ReactorInstance.java | 2 + .../lflang/generator/WatchdogInstance.java | 28 +++++++--- .../org/lflang/generator/c/CGenerator.java | 51 ++++++++++++++----- .../generator/c/CReactionGenerator.java | 4 +- .../generator/c/CWatchdogGenerator.java | 51 ++++++++++++++----- 9 files changed, 124 insertions(+), 40 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 5b772a5322..050abfa4fa 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 5b772a5322b46b0738fcbd31e33f1175fde3c236 +Subproject commit 050abfa4fa2dab3cc7bc078be3556a239312ac16 diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index b87dc94479..eb0ca085cb 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -90,6 +90,8 @@ import org.lflang.lf.TypeParm; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; +//FIXME: modif4watchdogs +import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; import org.lflang.util.StringUtil; @@ -131,7 +133,7 @@ public class ASTUtils { featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), - featurePackage.getReactor_Watchdogs() + featurePackage.getReactor_Watchdogs(), featurePackage.getMode_Watchdogs() ); diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index e624e61c53..7325401322 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -278,14 +278,14 @@ TypedVariable: ; Variable: - TypedVariable | Timer | Mode; + TypedVariable | Timer | Mode | Watchdog; VarRef: variable=[Variable] | container=[Instantiation] '.' variable=[Variable] | interleaved?='interleaved' '(' (variable=[Variable] | container=[Instantiation] '.' variable=[Variable]) ')' ; VarRefOrModeTransition returns VarRef: - VarRef | Watchdog | transition=ModeTransition '(' variable=[Mode] ')'; + VarRef | transition=ModeTransition '(' variable=[Mode] ')'; Assignment: (lhs=[Parameter] ( diff --git a/org.lflang/src/org/lflang/federated/FederateInstance.java b/org.lflang/src/org/lflang/federated/FederateInstance.java index c32095acfb..cb29977d01 100644 --- a/org.lflang/src/org/lflang/federated/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/FederateInstance.java @@ -327,6 +327,24 @@ public boolean contains(Reaction reaction) { return !excludeReactions.contains(reaction); } + + //FIXME: modif4watchdogs + public boolean contains(Watchdog watchdog) { + Reactor reactor = ASTUtils.getEnclosingReactor(watchdog); + if (!reactor.isFederated() || this.isSingleton()) { + return true; + } + + if (!reactor.getWatchdogs().contains(watchdog)) { + return false; + } + + if (networkReactions.contains(watchdog)) { + return true; + } + + return false; + } /** * Return true if the specified reactor instance or any parent diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 46b34c662f..3df4517d55 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -58,6 +58,8 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.lf.WidthSpec; +//FIXME: modif4watchdogs +import org.lflang.lf.Watchdog; /** diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index ff9bc139df..0fb3701ecc 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -28,23 +28,31 @@ public WatchdogInstance(Watchdog definition, ReactorInstance reactor) { this.timeout = TimeValue.ZERO; } - this.name = definition.getName(); + this.name = definition.getName().toString(); + this.definition = definition; + this.reactor = reactor; } public String getName() { return this.name; } + public Watchdog getDefinition() { + return this.definition; + } + + public TimeValue getTimeout() { + return this.timeout; + } + + public ReactorInstance getReactor() { + return this.reactor; + } + ////////////////////////////////////////////////////// //// Public fields. - /** - * The timeout, L, associated with this deadline. The physical timer gets set - * to expire at physical time, P, equal to the current logical time, t, plus the timeout. - * - * In other words, the watchdog condition is met iff P < t + L while the watchdog has not - * been stopped or reset. - */ + public final TimeValue timeout; /** @@ -52,6 +60,10 @@ public String getName() { */ public final String name; + public final Watchdog definition; + + public final ReactorInstance reactor; + ////////////////////////////////////////////////////// //// Public methods. diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 9dfffdd039..45657c6e38 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -80,6 +80,8 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; +// FIXME: modif4watchdogs +import org.lflang.generator.WatchdogInstance; import org.lflang.generator.SubContext; import org.lflang.generator.TargetTypes; import org.lflang.generator.TimerInstance; @@ -101,6 +103,8 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.util.FileUtil; +// FIXME: modif4watchdogs +import org.lflang.lf.Watchdog; import com.google.common.base.Objects; import com.google.common.collect.Iterables; @@ -376,6 +380,8 @@ public class CGenerator extends GeneratorBase { private int resetReactionCount = 0; private int modalReactorCount = 0; private int modalStateResetCount = 0; + // FIXME: modif4watchdogs + private int watchdogCount = 0; // Indicate whether the generator is in Cpp mode or not private final boolean CCppMode; @@ -748,7 +754,9 @@ private void generateCodeForCurrentFederate( "int _lf_tokens_with_ref_count_count = 0;", "SUPPRESS_UNUSED_WARNING(_lf_tokens_with_ref_count_count);", "int bank_index;", - "SUPPRESS_UNUSED_WARNING(bank_index);" + "SUPPRESS_UNUSED_WARNING(bank_index);", + "int _lf_watchdog_number_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_watchdog_number_count);" )); // Add counters for modal initialization initializeTriggerObjects.pr(CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); @@ -773,6 +781,10 @@ private void generateCodeForCurrentFederate( // If there are reset reactions, create a table of triggers. code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); + //FIXME: modif4watchdogs + // If there are watchdogs, create a table of triggers. + code.pr(CWatchdogGenerator.generateBuiltinTriggersTable(watchdogCount, "watchdog")); + // If there are modes, create a table of mode state to be checked for transitions. code.pr(CModesGenerator.generateModeStatesTable( hasModalReactors, @@ -842,7 +854,8 @@ private void generateCodeForCurrentFederate( //FIXME:modif4watchdogs // Generate function to initialize mutexes for all reactors with watchdogs. - code.pr(CReactionGenerator.generateLfInitializeWatchdogMutexes()); + // needs to be implemented still + code.pr(CWatchdogGenerator.generateLfInitializeWatchdogMutexes(watchdogCount)); // Generate a function that will either do nothing // (if there is only one federate or the coordination @@ -1370,6 +1383,7 @@ private void generateSelfStruct(ReactorDecl decl, CodeBuilder constructorCode) { ); // Generate the fields needed for each watchdog. + // FIXME: modif4watchdogs CWatchdogGenerator.generateWatchdogStruct( currentFederate, body, @@ -1539,18 +1553,6 @@ protected void generateSelfStructExtension( // Do nothing } - /** - * Generate watchdog functions definition for a reactor. - * @param decl The reactor - * @param federate The federate, or null if this is not - * federated or not the main reactor and watchdogs should be - * unconditionally generated. - */ - //FIXME: modif4watchdogs - public void generateWatchdogFunctions(ReactorDecl decl, FederateInstance federate) { - - } - /** Generate reaction functions definition for a reactor. * These functions have a single argument that is a void* pointing to * a struct that contains parameters, state variables, inputs (triggering or not), @@ -1676,6 +1678,25 @@ private void recordBuiltinTriggers(ReactorInstance instance) { } } + // FIXME: modif4watchdogs + private void recordWatchdogs(ReactorInstance instance) { + var foundOne = false; + var temp = new CodeBuilder(); + var reactorRef = CUtil.reactorRef(instance); + + for (WatchdogInstance watchdog : instance.watchdogs) { + if (currentFederate.contains(watchdog.getDefinition())) { + temp.pr("_lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); + temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); + temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); + watchdogCount += currentFederate.numRuntimeInstances(reactor); + foundOne = true; + } + } + if (foundOne) { + initializeTriggerObjects.pr(temp.toString()); + } + } /** @@ -1968,6 +1989,8 @@ public void generateReactorInstance(ReactorInstance instance) { initializeOutputMultiports(instance); initializeInputMultiports(instance); recordBuiltinTriggers(instance); + // FIXME: modif4watchdogs + recordWatchdogs(instance); // Next, initialize the "self" struct with state variables. // These values may be expressions that refer to the parameter values defined above. diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 4cebf42a8f..5b765483e0 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -34,6 +34,8 @@ import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.util.StringUtil; +// FIXME: modif4watchdogs +import org.lflang.lf.Watchdog; public class CReactionGenerator { protected static String DISABLE_REACTION_INITIALIZATION_MARKER @@ -708,7 +710,7 @@ public static String generateWatchdogVariablesInReaction( errorReporter.reportError(watchdog, "Watchdog is required to have a type: " + watchdogName); return ""; } else { - return "watchdog_t* "+watchdogName+" = &self->_lf_watchdog_"+watchdogName+";"; + return "watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");"; } } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index b8b78803c3..41d8d3addc 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -4,7 +4,15 @@ import org.lflang.federated.FederateInstance; import org.lflang.generator.CodeBuilder; import org.lflang.lf.ReactorDecl; -import org.lflang.lf.CReactionGenerator; +import org.lflang.lf.Reactor; +import org.lflang.lf.VarRef; +import org.lflang.lf.Variable; +import org.lflang.lf.Mode; +import org.lflang.lf.ModeTransition; +import org.lflang.lf.Watchdog; +import org.lflang.generator.GeneratorBase; +import org.lflang.generator.c.CReactionGenerator; +import java.util.List; /** * Generates necessary C code for watchdogs. @@ -140,10 +148,12 @@ public static void generateWatchdogStruct( var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); // Set values of watchdog_t struct in the reactor's constructor // WATCHDOG QUESTION 5: should I be defining these in the constructor of the reactor? + //FIXME: update parameters constructorCode.pr(watchdog, String.join("\n", - "self->_lf_watchdog_"+watchdogName+".self = self;", + "self->_lf_watchdog_"+watchdogName+".base = &(self->base);", "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", - "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", + "self->_lf_watchdog_"+watchdogName+".thread_active = false;", + // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";" )); @@ -165,25 +175,40 @@ public static String generateWatchdog( ) { var code = new CodeBuilder(); - // WATCHDOG QUESTION: Do I need this header? What it for? - code.pr( - "#include " + StringUtil.addDoubleQuotes( - CCoreFilesUtils.getCTargetSetHeader())); - code.pr(generateWatchdogFunction(watchdog, decl)); return code.toString(); } + public static String generateBuiltinTriggersTable(int count, String name) { + return String.join("\n", List.of( + "// Array of pointers to "+name+" triggers.", + (count > 0 ? + "watchdog_t* _lf_"+name+"s["+count+"]" : + "int _lf_"+name+"_number = "+count+";" + ))); + } + /** * Generate _lf_initialize_watchdog_mutexes function. */ //FIXME: finish implementing - public static String generateLfInitializeWatchdogMutexes(List reactors) { - // need to find way to assign get watchdog from AST - // need to assign watchdog to correct reaction + public static String generateLfInitializeWatchdogMutexes(int watchdogCount) { var s = new StringBuilder(); - s.append("void _lf_initialize_watchdog_mutexes() {\n"); - + s.append("void _lf_initialize_watchdog_mutexes() {"); + if (watchdogCount > 0) { + s.append("\n"); + s.append(String.join("\n", + " for (int i = 0; i < _lf_watchdog_numer; i++) {", + " self_base_t* current_base = _lf_watchdogs[i]->base;", + " if (&(current_base->watchdog_mutex) == NULL) {", + " lf_mutex_init(&(current_base->watchdog_mutex));", + " }", + " }" + )); + } + s.append("\n"); + s.append("}\n"); + return s.toString(); } } From c8c569c596212e1c66d12ee8a8d2f17b42becbfa Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 7 Feb 2023 23:45:57 -0800 Subject: [PATCH 011/709] Added a few missing imports, but plenty compile errors remain --- org.lflang/src/org/lflang/ASTUtils.java | 1 + org.lflang/src/org/lflang/generator/ReactorInstance.java | 1 + org.lflang/src/org/lflang/generator/c/CGenerator.java | 1 + org.lflang/src/org/lflang/generator/c/CReactionGenerator.java | 1 + org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java | 2 ++ 5 files changed, 6 insertions(+) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index b87dc94479..b281ac1802 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -90,6 +90,7 @@ import org.lflang.lf.TypeParm; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; +import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; import org.lflang.util.StringUtil; diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 46b34c662f..d7589910d2 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -57,6 +57,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Timer; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; +import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 9dfffdd039..46271e96bf 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -100,6 +100,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.StateVar; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; +import org.lflang.lf.Watchdog; import org.lflang.util.FileUtil; import com.google.common.base.Objects; diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 4cebf42a8f..9c9ff93d96 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -33,6 +33,7 @@ import org.lflang.lf.TriggerRef; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; +import org.lflang.lf.Watchdog; import org.lflang.util.StringUtil; public class CReactionGenerator { diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index b8b78803c3..ec67a8bed7 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -3,8 +3,10 @@ import org.lflang.ASTUtils; import org.lflang.federated.FederateInstance; import org.lflang.generator.CodeBuilder; +import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.CReactionGenerator; +import org.lflang.lf.Watchdog; /** * Generates necessary C code for watchdogs. From 10cf7411201e75fe601a5b194b0ca5a7c223cbfd Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 8 Feb 2023 12:28:59 -0800 Subject: [PATCH 012/709] saving before merging --- org.lflang/src/org/lflang/LinguaFranca.xtext | 2 +- .../src/org/lflang/federated/generator/FederateInstance.java | 1 + org.lflang/src/org/lflang/generator/c/CGenerator.java | 1 - 3 files changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index e9af0b7805..9615b538eb 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -280,7 +280,7 @@ TypedVariable: ; Variable: - TypedVariable | Timer | Mode | Watchdog; + TypedVariable | Timer | Mode; VarRef: variable=[Variable] | container=[Instantiation] '.' variable=[Variable] diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index 805643b5cb..bf3b144b2b 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -67,6 +67,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.TriggerRef; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; +import org.lflang.lf.Watchdog; import com.google.common.base.Objects; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index ff40f79786..c622ba64a1 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -71,7 +71,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.generator.GeneratorBase; import org.lflang.generator.GeneratorResult; import org.lflang.generator.GeneratorUtils; - import org.lflang.generator.DelayBodyGenerator; import org.lflang.generator.LFGeneratorContext; From 90d002fb9ae09bafd05795beb2f4aa5aa2418e47 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 8 Feb 2023 14:28:29 -0800 Subject: [PATCH 013/709] at least it compiles now --- org.lflang/src/org/lflang/LinguaFranca.xtext | 9 +-- .../federated/generator/FederateInstance.java | 32 ++++----- .../lflang/generator/WatchdogInstance.java | 2 +- .../org/lflang/generator/c/CGenerator.java | 21 +++--- .../generator/c/CReactionGenerator.java | 15 +---- .../generator/c/CWatchdogGenerator.java | 67 +++++++++---------- 6 files changed, 64 insertions(+), 82 deletions(-) diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index 9615b538eb..c0bfa322d8 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -91,7 +91,7 @@ Reactor: | (connections+=Connection) | (reactions+=Reaction) | (modes+=Mode) - (watchdogs+=Watchdog) + | (watchdogs+=Watchdog) )* '}'; @@ -177,7 +177,8 @@ Mode: (actions+=Action) | (instantiations+=Instantiation) | (connections+=Connection) | - (reactions+=Reaction) + (reactions+=Reaction) | + (watchdogs+=Watchdog) )* '}'; // Action that has either a physical or logical origin. @@ -216,7 +217,7 @@ Deadline: 'deadline' '(' delay=Expression ')' code=Code; Watchdog: - 'watchdog' name=Expression '(' timeout=Expression ')' + 'watchdog' name=ID '(' timeout=Expression ')' ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? code=Code; @@ -280,7 +281,7 @@ TypedVariable: ; Variable: - TypedVariable | Timer | Mode; + TypedVariable | Timer | Mode | Watchdog; VarRef: variable=[Variable] | container=[Instantiation] '.' variable=[Variable] diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index bf3b144b2b..f13313b033 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -467,22 +467,22 @@ private boolean contains(Timer timer) { //FIXME:modif4watchdogs - public boolean contains(Watchdog watchdog) { - Reactor reactor = ASTUtils.getEnclosingReactor(watchdog); - if (!reactor.isFederated() || this.isSingleton()) { - return true; - } - - if (!reactor.getWatchdogs().contains(watchdog)) { - return false; - } - - if (networkReactions.contains(watchdog)) { - return true; - } - - return false; - } + // public boolean contains(Watchdog watchdog) { + // Reactor reactor = ASTUtils.getEnclosingReactor(watchdog); + // if (!reactor.isFederated() || this.isSingleton()) { + // return true; + // } + + // if (!reactor.getWatchdogs().contains(watchdog)) { + // return false; + // } + + // if (networkReactions.contains(watchdog)) { + // return true; + // } + + // return false; + // } /** * Return true if the specified reactor instance or any parent diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index 0fb3701ecc..780113a80f 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -42,7 +42,7 @@ public Watchdog getDefinition() { } public TimeValue getTimeout() { - return this.timeout; + return (TimeValue) this.timeout; } public ReactorInstance getReactor() { diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index d7268b0ab7..e9cb80c095 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1072,7 +1072,7 @@ private void generateReactorClass(ReactorDecl reactor) { generateMethods(reactor); // FIXME: modif4watchdogs - generateWatchdogs(reactor, currentFederate); + generateWatchdogs(reactor); generateReactions(reactor); generateConstructor(reactor, constructorCode); @@ -1226,7 +1226,6 @@ private void generateSelfStruct(ReactorDecl decl, CodeBuilder constructorCode) { // Generate the fields needed for each watchdog. // FIXME: modif4watchdogs CWatchdogGenerator.generateWatchdogStruct( - currentFederate, body, decl, constructorCode @@ -1445,15 +1444,13 @@ protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactio * federated or not the main reactor and reactions should be * unconditionally generated. */ - public void generateWatchdogs(ReactorDecl decl, FederateInstance federate) { + public void generateWatchdogs(ReactorDecl decl) { // WATCHDOG QUESTION: A similar question is asked somewhere else for a // different function - Do we need to check if this federate contains the // watchdog? This is done in the code generation for reactions. var reactor = ASTUtils.toDefinition(decl); for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - if (federate == null || federate.contains(watchdog)) { - generateWatchdog(watchdog, decl); - } + generateWatchdog(watchdog, decl); } } @@ -1522,13 +1519,11 @@ private void recordWatchdogs(ReactorInstance instance) { var reactorRef = CUtil.reactorRef(instance); for (WatchdogInstance watchdog : instance.watchdogs) { - if (currentFederate.contains(watchdog.getDefinition())) { - temp.pr("_lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); - temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); - temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); - watchdogCount += currentFederate.numRuntimeInstances(reactor); - foundOne = true; - } + temp.pr("_lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); + temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); + temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); + watchdogCount += 1; + foundOne = true; } if (foundOne) { initializeTriggerObjects.pr(temp.toString()); diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index b27f2e7594..6eaa7506b1 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -202,9 +202,7 @@ public static String generateInitializationForReaction(String body, //FIXME: modif4watchdogs reactionInitialization.pr(generateWatchdogVariablesInReaction( effect, - decl, - errorReporter, - requiresTypes + decl )); } else { errorReporter.reportError( @@ -684,18 +682,11 @@ public static String generateOutputVariablesInReaction( // Fine to have watchdog be in reactor self struct? public static String generateWatchdogVariablesInReaction( VarRef effect, - ReactorDecl decl, - ErrorReporter errorReporter, - boolean requiresTypes + ReactorDecl decl ) { Watchdog watchdog = (Watchdog) effect.getVariable(); String watchdogName = watchdog.getName(); - if (watchdog.getType() == null && requiresTypes) { - errorReporter.reportError(watchdog, "Watchdog is required to have a type: " + watchdogName); - return ""; - } else { - return "watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");"; - } + return "watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");"; } /** diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 842c145a61..8bdf90b3fe 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -1,7 +1,6 @@ package org.lflang.generator.c; import org.lflang.ASTUtils; -import org.lflang.federated.FederateInstance; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; @@ -15,7 +14,6 @@ import org.lflang.generator.GeneratorBase; import org.lflang.generator.c.CReactionGenerator; import java.util.List; -import org.lflang.lf.CReactionGenerator; import org.lflang.lf.Watchdog; /** @@ -118,7 +116,6 @@ public static String generateWatchdogFunction(Watchdog watchdog, * Generate watchdog definition in parent struct. */ public static void generateWatchdogStruct( - FederateInstance currentFederate, CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode @@ -130,39 +127,37 @@ public static void generateWatchdogStruct( // but am not sure why we need to check if watchdog exists in the // current federate. for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - if (currentFederate.contains(watchdog)) { - - String watchdogName = watchdog.getName(); - // Create pointer to the watchdog_t struct - // WATCHDOG QUESTION 2: Why need to put object at beginning of - // `.pr` func call? - - // WATCHDOG QUESTION 3: Is the space for this struct automatically allocated - // through `_lf_new_reactor`? `_lf__startup_reaction` is also a pointer in self struct - // but does not seem to have a separate allocation call. - body.pr(watchdog, "watchdog_t* _lf_watchdog_"+watchdogName+";"); - - // WATCHDOG QUESTION 4: Not sure if this is correct, may need to use - // 'getTargetTime' instead. watchdog timeout is listed as "Expression" - // in the grammar, so I'm not sure if it is reading the timeout as - // a Time class or TimeValue class. - var min_expiration = GeneratorBase.timeInTargetLanguage(watchdog.getTimeout()); - - // watchdog function name - var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); - // Set values of watchdog_t struct in the reactor's constructor - // WATCHDOG QUESTION 5: should I be defining these in the constructor of the reactor? - //FIXME: update parameters - constructorCode.pr(watchdog, String.join("\n", - "self->_lf_watchdog_"+watchdogName+".base = &(self->base);", - "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", - "self->_lf_watchdog_"+watchdogName+".thread_active = false;", - // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", - "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";" - )); - - // WATCHDOG QUESTION 6: should I be initializing mutex in this constructor? - } + String watchdogName = watchdog.getName(); + // Create pointer to the watchdog_t struct + // WATCHDOG QUESTION 2: Why need to put object at beginning of + // `.pr` func call? + + // WATCHDOG QUESTION 3: Is the space for this struct automatically allocated + // through `_lf_new_reactor`? `_lf__startup_reaction` is also a pointer in self struct + // but does not seem to have a separate allocation call. + body.pr(watchdog, "watchdog_t* _lf_watchdog_"+watchdogName+";"); + + // WATCHDOG QUESTION 4: Not sure if this is correct, may need to use + // 'getTargetTime' instead. watchdog timeout is listed as "Expression" + // in the grammar, so I'm not sure if it is reading the timeout as + // a Time class or TimeValue class. + // var min_expiration = GeneratorBase.timeInTargetLanguage(watchdog.getTimeout()); + + // watchdog function name + var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); + // Set values of watchdog_t struct in the reactor's constructor + // WATCHDOG QUESTION 5: should I be defining these in the constructor of the reactor? + //FIXME: update parameters + constructorCode.pr(watchdog, String.join("\n", + "self->_lf_watchdog_"+watchdogName+".base = &(self->base);", + "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", + "self->_lf_watchdog_"+watchdogName+".thread_active = false;", + // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", + "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";" + )); + + // WATCHDOG QUESTION 6: should I be initializing mutex in this constructor? + } } From 4db9e0f78db724dc8106658ea225f1c0d187d532 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 13 Feb 2023 11:49:38 -0800 Subject: [PATCH 014/709] fixed build problems --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 92160a8c22..7fd67a5e59 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 92160a8c22d543eb78f7e9815041606a0aef4e23 +Subproject commit 7fd67a5e599f36d65ab21600e228af7c8217ac98 diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 3a38f9c65f..fc4f38c4e3 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 3a38f9c65fafd2d2f11416fef0ddc69c1a16aa77 +Subproject commit fc4f38c4e3988145d2d3b775b79e436f9f7339ec From f7b177e10bb175e97adec3f9a2f7b7b98c3cf63a Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 13 Feb 2023 12:41:19 -0800 Subject: [PATCH 015/709] tried, unsuccessfully, to fix variable grammar error --- org.lflang/src/org/lflang/LinguaFranca.xtext | 6 +++--- org.lflang/src/org/lflang/ast/IsEqual.java | 5 ++++- org.lflang/src/org/lflang/validation/LFValidator.java | 2 ++ 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index c0bfa322d8..8b44ac6e1c 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -217,7 +217,7 @@ Deadline: 'deadline' '(' delay=Expression ')' code=Code; Watchdog: - 'watchdog' name=ID '(' timeout=Expression ')' + 'watchdog ' name=ID '(' timeout=Expression ')' ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? code=Code; @@ -456,7 +456,7 @@ SignedFloat: // Just escaping with \ is not a good idea because then every \ has to be escaped \\. // Perhaps the string EQUALS_BRACE could become '=}'? Code: - //{Code} '{=' (tokens+=Token)* '=}' + // {Code} '{=' (tokens+=Token)* '=}' {Code} '{=' body=Body '=}' ; @@ -503,7 +503,7 @@ Token: 'mutable' | 'input' | 'output' | 'timer' | 'action' | 'reaction' | 'startup' | 'shutdown' | 'after' | 'deadline' | 'mutation' | 'preamble' | 'new' | 'federated' | 'at' | 'as' | 'from' | 'widthof' | 'const' | 'method' | - 'interleaved' | 'mode' | 'initial' | 'reset' | 'history' | 'watchdog' + 'interleaved' | 'mode' | 'initial' | 'reset' | 'history' | 'watchdog' | // Other terminals NEGINT | TRUE | FALSE | // Action origins diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index b4614edcf0..bd1b55026e 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -61,6 +61,8 @@ import org.lflang.lf.Variable; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; +//FIXME: modif4watchdogs +import org.lflang.lf.Watchdog; import org.lflang.lf.util.LfSwitch; /** @@ -397,7 +399,8 @@ public Boolean caseTypedVariable(TypedVariable object) { @Override public Boolean caseVariable(Variable object) { - throw thereIsAMoreSpecificCase(Variable.class, TypedVariable.class, Timer.class, Mode.class); + //FIXME: modif4watchdogs + throw thereIsAMoreSpecificCase(Variable.class, TypedVariable.class, Timer.class, Mode.class, Watchdog.class); } @Override diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index f53987e2b5..847bd7320d 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -113,6 +113,8 @@ import org.lflang.lf.Visibility; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; +//FIXME: modif4watchdogs +import org.lflang.lf.Watchdog; import org.lflang.util.FileUtil; import com.google.inject.Inject; From 0487e8e4df285f08c731649440cfd18189146aa4 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Fri, 17 Feb 2023 12:19:17 -0800 Subject: [PATCH 016/709] watchdog example test --- test/C/src/Watchdog.lf | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 test/C/src/Watchdog.lf diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf new file mode 100644 index 0000000000..9bdec7f63b --- /dev/null +++ b/test/C/src/Watchdog.lf @@ -0,0 +1,32 @@ +target C; + +reactor Watcher { + input x:int; + output d:int; // Produced if the deadline is violated. + + watchdog poodle(10 msec) {= + instant_t p = lf_time_physical_elapsed() - lf_time_logical_elapsed(); + printf("Deadline missed! Lag: %lld (too late by %lld nsecs)\n", p, p-500000); + =} + + reaction(x) -> d, poodle {= + lf_watchdog_start(poodle, 0); + printf("Normal reaction.\n"); + =} +} + +main reactor { + logical action a; + w = new Watcher(); + reaction(startup) -> w.x, a {= + lf_set(w.x, 0); + lf_schedule(a, 0); + =} + reaction(a) -> w.x {= + lf_set(w.x, 0); + lf_nanosleep(MSEC(40)); + =} + reaction(w.d) {= + printf("Deadline reactor produced an output.\n"); + =} +} From ca781252c166c17cf3af09b915c268731a5cb592 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Fri, 17 Feb 2023 13:38:17 -0800 Subject: [PATCH 017/709] saving reactorc and changes to scopeprovider --- org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java index ae268a9327..745345fc52 100644 --- a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java +++ b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java @@ -78,6 +78,7 @@ enum RefType { TRIGGER, SOURCE, EFFECT, + WATCHDOG, DEADLINE, CLEFT, CRIGHT @@ -240,6 +241,8 @@ protected IScope getScopeForVarRef(VarRef variable, EReference reference) { candidates.addAll(allActions(reactor)); return Scopes.scopeFor(candidates); } + case WATCHDOG: + return Scopes.scopeFor(allWatchdogs(reactor)); case DEADLINE: case CLEFT: return Scopes.scopeFor(allInputs(reactor)); From c36cc80b711ea6040fd1e9051a3d7e5d318e8759 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Fri, 17 Feb 2023 15:13:07 -0800 Subject: [PATCH 018/709] saving changes to scope provider --- org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java index ae268a9327..745345fc52 100644 --- a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java +++ b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java @@ -78,6 +78,7 @@ enum RefType { TRIGGER, SOURCE, EFFECT, + WATCHDOG, DEADLINE, CLEFT, CRIGHT @@ -240,6 +241,8 @@ protected IScope getScopeForVarRef(VarRef variable, EReference reference) { candidates.addAll(allActions(reactor)); return Scopes.scopeFor(candidates); } + case WATCHDOG: + return Scopes.scopeFor(allWatchdogs(reactor)); case DEADLINE: case CLEFT: return Scopes.scopeFor(allInputs(reactor)); From 94185e7bf134ee747cbb9e52557daa598c20c5b8 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 17 Feb 2023 16:04:53 -0800 Subject: [PATCH 019/709] Fixed the scope provider --- org.lflang/src/org/lflang/LinguaFranca.xtext | 2 +- org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index 8b44ac6e1c..55f5fb0a97 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -217,7 +217,7 @@ Deadline: 'deadline' '(' delay=Expression ')' code=Code; Watchdog: - 'watchdog ' name=ID '(' timeout=Expression ')' + 'watchdog' name=ID '(' timeout=Expression ')' ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? code=Code; diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java index 745345fc52..c6bd97a622 100644 --- a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java +++ b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java @@ -227,6 +227,7 @@ protected IScope getScopeForVarRef(VarRef variable, EReference reference) { candidates.addAll(allInputs(reactor)); candidates.addAll(allActions(reactor)); candidates.addAll(allTimers(reactor)); + candidates.addAll(allWatchdogs(reactor)); return Scopes.scopeFor(candidates); } case SOURCE: @@ -239,10 +240,9 @@ protected IScope getScopeForVarRef(VarRef variable, EReference reference) { } candidates.addAll(allOutputs(reactor)); candidates.addAll(allActions(reactor)); + candidates.addAll(allWatchdogs(reactor)); return Scopes.scopeFor(candidates); } - case WATCHDOG: - return Scopes.scopeFor(allWatchdogs(reactor)); case DEADLINE: case CLEFT: return Scopes.scopeFor(allInputs(reactor)); From 17261240f413f68e1d34b9ee40f46564bb60c0d7 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 20 Feb 2023 15:41:14 -0800 Subject: [PATCH 020/709] fixed trigger table --- .../src/org/lflang/generator/c/CWatchdogGenerator.java | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 8bdf90b3fe..0ab08229c4 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -135,7 +135,7 @@ public static void generateWatchdogStruct( // WATCHDOG QUESTION 3: Is the space for this struct automatically allocated // through `_lf_new_reactor`? `_lf__startup_reaction` is also a pointer in self struct // but does not seem to have a separate allocation call. - body.pr(watchdog, "watchdog_t* _lf_watchdog_"+watchdogName+";"); + body.pr(watchdog, "watchdog_t _lf_watchdog_"+watchdogName+";"); // WATCHDOG QUESTION 4: Not sure if this is correct, may need to use // 'getTargetTime' instead. watchdog timeout is listed as "Expression" @@ -184,8 +184,9 @@ public static String generateBuiltinTriggersTable(int count, String name) { "// Array of pointers to "+name+" triggers.", (count > 0 ? "watchdog_t* _lf_"+name+"s["+count+"]" : + "watchdog_t* _lf_"+name+"s = NULL") + ";", "int _lf_"+name+"_number = "+count+";" - ))); + )); } /** @@ -198,7 +199,7 @@ public static String generateLfInitializeWatchdogMutexes(int watchdogCount) { if (watchdogCount > 0) { s.append("\n"); s.append(String.join("\n", - " for (int i = 0; i < _lf_watchdog_numer; i++) {", + " for (int i = 0; i < _lf_watchdog_number; i++) {", " self_base_t* current_base = _lf_watchdogs[i]->base;", " if (&(current_base->watchdog_mutex) == NULL) {", " lf_mutex_init(&(current_base->watchdog_mutex));", From 6994d4633605b8b29448c832721ac24475670bb2 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Sun, 26 Feb 2023 15:05:32 -0800 Subject: [PATCH 021/709] saved? --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 7fd67a5e59..b97d084109 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 7fd67a5e599f36d65ab21600e228af7c8217ac98 +Subproject commit b97d08410979bdb2466d6714743bca8d1dc24c76 From f74bbb1a75842c29fd9ec95ed527a7551545d9cd Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 28 Feb 2023 13:41:45 -0800 Subject: [PATCH 022/709] Remove unused deps from default package.json --- org.lflang/src/lib/ts/package.json | 21 +++------------------ 1 file changed, 3 insertions(+), 18 deletions(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index 3c368c9481..5636d6d6fd 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -2,33 +2,18 @@ "name": "LinguaFrancaDefault", "type": "commonjs", "dependencies": { - "@lf-lang/reactor-ts": "0.3.2", - "@babel/cli": "^7.8.4", - "@babel/core": "^7.8.7", - "@babel/node": "^7.8.7", - "@babel/plugin-proposal-class-properties": "^7.8.3", - "@babel/plugin-proposal-object-rest-spread": "^7.8.3", - "@babel/plugin-proposal-optional-chaining": "^7.8.3", - "@babel/plugin-transform-modules-commonjs": "^7.8.3", - "@babel/preset-env": "^7.8.7", - "@babel/preset-typescript": "^7.8.3", - "command-line-usage": "^6.1.0", - "command-line-args": "^5.1.1", - "rimraf": "^3.0.2" + "@lf-lang/reactor-ts": "^0.3.2" }, "devDependencies": { "@types/command-line-args": "^5.2.0", "@types/command-line-usage": "^5.0.2", - "@types/jest": "^27.0.0", - "@types/microtime": "^2.1.0", - "@types/node": "^16.3.3", "@types/google-protobuf": "^3.7.4", - "@types/uuid": "^8.3.4", "@typescript-eslint/eslint-plugin": "5.33.0", "@typescript-eslint/parser": "^5.8.1", "eslint": "^8.5.0", "typescript": "~4.8.2", - "ts-protoc-gen": "^0.12.0" + "ts-protoc-gen": "^0.12.0", + "rimraf": "^3.0.2" }, "scripts": { "check-types": "tsc", From d519b41225c2acd00a43575224cf4caefbd2aedc Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 28 Feb 2023 14:08:38 -0800 Subject: [PATCH 023/709] Add back necessary deps --- org.lflang/src/lib/ts/package.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index 5636d6d6fd..f58ab069e5 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -2,11 +2,11 @@ "name": "LinguaFrancaDefault", "type": "commonjs", "dependencies": { - "@lf-lang/reactor-ts": "^0.3.2" + "@lf-lang/reactor-ts": "^0.3.2", + "@babel/cli": "^7.21.0", + "@babel/core": "^7.4.3" }, "devDependencies": { - "@types/command-line-args": "^5.2.0", - "@types/command-line-usage": "^5.0.2", "@types/google-protobuf": "^3.7.4", "@typescript-eslint/eslint-plugin": "5.33.0", "@typescript-eslint/parser": "^5.8.1", From 43a11d7f80c34ed38e95dbfcd30cfcd158ecf74d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 28 Feb 2023 15:21:03 -0800 Subject: [PATCH 024/709] Add back command-line-usage and command-line-args --- org.lflang/src/lib/ts/package.json | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index f58ab069e5..bd5f499bdb 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -4,9 +4,13 @@ "dependencies": { "@lf-lang/reactor-ts": "^0.3.2", "@babel/cli": "^7.21.0", - "@babel/core": "^7.4.3" + "@babel/core": "^7.4.3", + "command-line-args": "^5.1.1", + "command-line-usage": "^6.1.3" }, "devDependencies": { + "@types/command-line-args": "^5.2.0", + "@types/command-line-usage": "^5.0.2", "@types/google-protobuf": "^3.7.4", "@typescript-eslint/eslint-plugin": "5.33.0", "@typescript-eslint/parser": "^5.8.1", From 663d8c618d949da058ce870b27f38ac68bbf6677 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 28 Feb 2023 16:33:11 -0800 Subject: [PATCH 025/709] Use tsc to generate js --- org.lflang/src/lib/ts/package.json | 8 ++++---- org.lflang/src/lib/ts/tsconfig.json | 1 - 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index bd5f499bdb..3424345a8d 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -1,10 +1,8 @@ { "name": "LinguaFrancaDefault", - "type": "commonjs", + "type": "module", "dependencies": { "@lf-lang/reactor-ts": "^0.3.2", - "@babel/cli": "^7.21.0", - "@babel/core": "^7.4.3", "command-line-args": "^5.1.1", "command-line-usage": "^6.1.3" }, @@ -12,6 +10,8 @@ "@types/command-line-args": "^5.2.0", "@types/command-line-usage": "^5.0.2", "@types/google-protobuf": "^3.7.4", + "@types/microtime": "^2.1.0", + "@types/node": "^18.14.2", "@typescript-eslint/eslint-plugin": "5.33.0", "@typescript-eslint/parser": "^5.8.1", "eslint": "^8.5.0", @@ -21,6 +21,6 @@ }, "scripts": { "check-types": "tsc", - "build": "npx rimraf dist && npx babel src --out-dir dist --extensions .ts,.js" + "build": "npx rimraf dist && npx tsc --outDir dist" } } diff --git a/org.lflang/src/lib/ts/tsconfig.json b/org.lflang/src/lib/ts/tsconfig.json index b771b75281..71bc2e9f3c 100644 --- a/org.lflang/src/lib/ts/tsconfig.json +++ b/org.lflang/src/lib/ts/tsconfig.json @@ -1,7 +1,6 @@ { "compilerOptions": { "allowJs": true, - "noEmit": true, "target": "esnext", "types": ["node", "@lf-lang/reactor-ts", "ulog", "microtime", "command-line-args", "command-line-usage"], "esModuleInterop": true, From 3393c588b42e34b9c5ddc193c2d558262c1aba80 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Fri, 3 Mar 2023 15:40:46 -0800 Subject: [PATCH 026/709] fixed compile issues --- base | 0 org.lflang.tests/.classpath | 19 ++++++------------- org.lflang.tests/.project | 19 ++++++++++++++++++- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/lib/rs/reactor-rs | 2 +- .../src/lib/rs/runtime-version.properties | 2 +- .../org/lflang/generator/c/CGenerator.java | 7 +++---- .../generator/c/CWatchdogGenerator.java | 8 +++++--- thread_active | 0 watchdog_function | 0 10 files changed, 35 insertions(+), 24 deletions(-) create mode 100644 base create mode 100644 thread_active create mode 100644 watchdog_function diff --git a/base b/base new file mode 100644 index 0000000000..e69de29bb2 diff --git a/org.lflang.tests/.classpath b/org.lflang.tests/.classpath index e46db665de..e025b430eb 100644 --- a/org.lflang.tests/.classpath +++ b/org.lflang.tests/.classpath @@ -1,20 +1,13 @@ - - - - - - - - - - - - + + + - + + + diff --git a/org.lflang.tests/.project b/org.lflang.tests/.project index f17ca7cd7c..7acfd6f031 100644 --- a/org.lflang.tests/.project +++ b/org.lflang.tests/.project @@ -5,13 +5,18 @@ + + org.eclipse.jdt.core.javabuilder + + + org.eclipse.xtext.ui.shared.xtextBuilder - org.eclipse.jdt.core.javabuilder + org.eclipse.buildship.core.gradleprojectbuilder @@ -30,5 +35,17 @@ org.eclipse.xtext.ui.shared.xtextNature org.eclipse.jdt.core.javanature org.eclipse.pde.PluginNature + org.eclipse.buildship.core.gradleprojectnature + + + 1677834823336 + + 30 + + org.eclipse.core.resources.regexFilterMatcher + node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ + + + diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index c00691a80a..8a8827fa77 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit c00691a80a20ff48486bc0c42d5da6ea175c1eed +Subproject commit 8a8827fa77dc935676fbc148ecd83fffd3feb151 diff --git a/org.lflang/src/lib/rs/reactor-rs b/org.lflang/src/lib/rs/reactor-rs index 28f9460724..7685764194 160000 --- a/org.lflang/src/lib/rs/reactor-rs +++ b/org.lflang/src/lib/rs/reactor-rs @@ -1 +1 @@ -Subproject commit 28f9460724b266c263f4fdf8146b2029f4ff9d30 +Subproject commit 76857641941aa49c766ba23da63db4f7650a4c77 diff --git a/org.lflang/src/lib/rs/runtime-version.properties b/org.lflang/src/lib/rs/runtime-version.properties index 35b335b731..4449aaf2fd 100644 --- a/org.lflang/src/lib/rs/runtime-version.properties +++ b/org.lflang/src/lib/rs/runtime-version.properties @@ -1 +1 @@ -rs = 28f9460724b266c263f4fdf8146b2029f4ff9d30 +rs = 76857641941aa49c766ba23da63db4f7650a4c77 diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index f2a74c3b5b..3e0cbdb590 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1518,11 +1518,10 @@ private void recordWatchdogs(ReactorInstance instance) { var foundOne = false; var temp = new CodeBuilder(); var reactorRef = CUtil.reactorRef(instance); - for (WatchdogInstance watchdog : instance.watchdogs) { - temp.pr("_lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); - temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); - temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); + temp.pr(" _lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); + temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); + temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); watchdogCount += 1; foundOne = true; } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 0ab08229c4..5b0343ecc7 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -182,10 +182,12 @@ public static String generateWatchdog( public static String generateBuiltinTriggersTable(int count, String name) { return String.join("\n", List.of( "// Array of pointers to "+name+" triggers.", + "#ifdef LF_THREADED", (count > 0 ? - "watchdog_t* _lf_"+name+"s["+count+"]" : - "watchdog_t* _lf_"+name+"s = NULL") + ";", - "int _lf_"+name+"_number = "+count+";" + " watchdog_t* _lf_"+name+"s["+count+"]" : + " watchdog_t* _lf_"+name+"s = NULL") + ";", + " int _lf_"+name+"_number = "+count+";", + "#endif" )); } diff --git a/thread_active b/thread_active new file mode 100644 index 0000000000..e69de29bb2 diff --git a/watchdog_function b/watchdog_function new file mode 100644 index 0000000000..e69de29bb2 From d5ed9745f16ff962c6eb3d5817b3a71c555f2bb5 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 00:10:27 -0800 Subject: [PATCH 027/709] Declare output dir --- org.lflang/src/lib/ts/tsconfig.json | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/lib/ts/tsconfig.json b/org.lflang/src/lib/ts/tsconfig.json index 71bc2e9f3c..c85f98300f 100644 --- a/org.lflang/src/lib/ts/tsconfig.json +++ b/org.lflang/src/lib/ts/tsconfig.json @@ -3,16 +3,19 @@ "allowJs": true, "target": "esnext", "types": ["node", "@lf-lang/reactor-ts", "ulog", "microtime", "command-line-args", "command-line-usage"], + "typeRoots": ["./node_modules/@types/", "./node_modules/@lf-lang/reactor-ts/src/core/@types/"], "esModuleInterop": true, "isolatedModules": true, "lib": ["esnext", "dom"], "sourceMap": true, "strict": true, "moduleResolution": "node", + "skipLibCheck": true, "strictBindCallApply": true, "strictNullChecks": true, "strictFunctionTypes": true, - "typeRoots": ["./node_modules/@types/", "./node_modules/@lf-lang/reactor-ts/src/core/@types/"] + "noImplicitThis": true, + "outDir": "dist" }, "include": [ "src/**/*" From d0aebb00c1e75e9f36e84daa01393b03bd77fdca Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 11:07:37 -0800 Subject: [PATCH 028/709] Do not copy babel conf --- org.lflang/src/org/lflang/generator/ts/TSGenerator.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 21ea083e49..98544a4c49 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -70,7 +70,7 @@ class TSGenerator( * Names of the configuration files to check for and copy to the generated * source package root if they cannot be found in the source directory. */ - val CONFIG_FILES = arrayOf("package.json", "tsconfig.json", "babel.config.js", ".eslintrc.json") + val CONFIG_FILES = arrayOf("package.json", "tsconfig.json", ".eslintrc.json") fun timeInTargetLanguage(value: TimeValue): String { return if (value.unit != null) { From 9a9b73949fe948407a89a72c6e92097483be7722 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 11:21:32 -0800 Subject: [PATCH 029/709] Parameterize build env action to let it find the lingua-franca checkout --- .github/actions/prepare-build-env/action.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/actions/prepare-build-env/action.yml b/.github/actions/prepare-build-env/action.yml index 4378bd439e..e61c7b883d 100644 --- a/.github/actions/prepare-build-env/action.yml +++ b/.github/actions/prepare-build-env/action.yml @@ -1,5 +1,10 @@ name: Prepare build environment (Linux only) description: Set up Java, Maven, Gradle, etc. +inputs: + lf-dir: + description: 'Relative path from $GITHUB_WORKSPACE to lingua-franca checkout' + required: false + default: '' runs: using: "composite" steps: @@ -17,3 +22,4 @@ runs: shell: bash - name: Gradle Cache uses: burrunan/gradle-cache-action@v1 + build-root-directory: ${{ inputs.lf-dir }} From 3cb96e3f552d365059a21e99efa74d1d901d0c68 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 11:23:59 -0800 Subject: [PATCH 030/709] Indentation --- .github/actions/prepare-build-env/action.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/actions/prepare-build-env/action.yml b/.github/actions/prepare-build-env/action.yml index e61c7b883d..1bc0bb97fe 100644 --- a/.github/actions/prepare-build-env/action.yml +++ b/.github/actions/prepare-build-env/action.yml @@ -22,4 +22,5 @@ runs: shell: bash - name: Gradle Cache uses: burrunan/gradle-cache-action@v1 - build-root-directory: ${{ inputs.lf-dir }} + with: + build-root-directory: ${{ inputs.lf-dir }} From b3f42f90883d2547f967fa7c43a01baec7600609 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 8 Mar 2023 11:30:13 -0800 Subject: [PATCH 031/709] Use CommonJS, not ES Modules. --- org.lflang/src/lib/ts/package.json | 2 +- org.lflang/src/lib/ts/tsconfig.json | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index 3424345a8d..346c582e36 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -1,6 +1,6 @@ { "name": "LinguaFrancaDefault", - "type": "module", + "type": "commonjs", "dependencies": { "@lf-lang/reactor-ts": "^0.3.2", "command-line-args": "^5.1.1", diff --git a/org.lflang/src/lib/ts/tsconfig.json b/org.lflang/src/lib/ts/tsconfig.json index c85f98300f..3d51d35052 100644 --- a/org.lflang/src/lib/ts/tsconfig.json +++ b/org.lflang/src/lib/ts/tsconfig.json @@ -2,6 +2,7 @@ "compilerOptions": { "allowJs": true, "target": "esnext", + "module": "CommonJS", "types": ["node", "@lf-lang/reactor-ts", "ulog", "microtime", "command-line-args", "command-line-usage"], "typeRoots": ["./node_modules/@types/", "./node_modules/@lf-lang/reactor-ts/src/core/@types/"], "esModuleInterop": true, From 86d609dd68e1cda99a817bcb311ac3fb0e40e9ea Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 8 Mar 2023 11:46:08 -0800 Subject: [PATCH 032/709] Do not run checks when doing full compile. Instead, pass the output of the install command through the TSValidator, which parses it. --- .../org/lflang/generator/ts/TSGenerator.kt | 26 ++++++++++--------- 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 98544a4c49..dda883d25c 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -145,14 +145,16 @@ class TSGenerator( println("No .proto files have been imported. Skipping protocol buffer compilation.") } val parsingContext = SubContext(context, COLLECTED_DEPENDENCIES_PERCENT_PROGRESS, 100) - if ( - !context.cancelIndicator.isCanceled - && passesChecks(TSValidator(fileConfig, errorReporter, codeMaps), parsingContext) - ) { + val validator = TSValidator(fileConfig, errorReporter, codeMaps) + if (!context.cancelIndicator.isCanceled) { if (context.mode == LFGeneratorContext.Mode.LSP_MEDIUM) { + if (!passesChecks(validator, parsingContext)) { + context.unsuccessfulFinish(); + return; + } context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, codeMaps)) } else { - compile(resource, parsingContext) + compile(validator, resource, parsingContext) concludeCompilation(context, codeMaps) } } else { @@ -263,13 +265,13 @@ class TSGenerator( } - private fun compile(resource: Resource, parsingContext: LFGeneratorContext) { + private fun compile(validator: TSValidator, resource: Resource, parsingContext: LFGeneratorContext) { GeneratorUtils.refreshProject(resource, parsingContext.mode) if (parsingContext.cancelIndicator.isCanceled) return parsingContext.reportProgress("Transpiling to JavaScript...", 70) - transpile(parsingContext.cancelIndicator) + transpile(validator, parsingContext.cancelIndicator) if (parsingContext.cancelIndicator.isCanceled) return } @@ -397,19 +399,19 @@ class TSGenerator( /** * Transpile TypeScript to JavaScript. */ - private fun transpile(cancelIndicator: CancelIndicator) { + private fun transpile(validator: TSValidator, cancelIndicator: CancelIndicator) { println("Compiling") - val babel = commandFactory.createCommand("npm", listOf("run", "build"), fileConfig.srcGenPkgPath) + val tsc = commandFactory.createCommand("npm", listOf("run", "build"), fileConfig.srcGenPkgPath) - if (babel == null) { + if (tsc == null) { errorReporter.reportError(NO_NPM_MESSAGE) return } - if (babel.run(cancelIndicator) == 0) { + if (validator.run(tsc, cancelIndicator) == 0) { println("SUCCESS (compiling generated TypeScript code)") } else { - errorReporter.reportError("Compiler failed with the following errors:\n${babel.errors}") + errorReporter.reportError("Compiler failed with the following errors:\n${tsc.errors}") } } From 976b1026641b525db07b23143f16fb8a4826a0f6 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 8 Mar 2023 16:57:48 -0800 Subject: [PATCH 033/709] added casewatchdogs, still not fixed --- org.lflang/src/org/lflang/ASTUtils.java | 5 +++ org.lflang/src/org/lflang/ast/IsEqual.java | 12 ++++++++ org.lflang/src/org/lflang/ast/ToLf.java | 36 ++++++++++++++++++++++ test/C/src/Watchdog.lf | 2 +- 4 files changed, 54 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index fe1ba25536..896765f459 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -1075,6 +1075,11 @@ public static InferredType getInferredType(Port p) { return getInferredType(p.getType(), null); } + //FIXME: modif4watchdogs + // public static InferredType getInferredType(Watchdog w) { + // return getInferredType(w.getType(), null); + // } + /** diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index bd1b55026e..1af1eed81a 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -394,6 +394,7 @@ public Boolean caseElement(Element object) { @Override public Boolean caseTypedVariable(TypedVariable object) { + //FIXME: modif4watchdogs throw thereIsAMoreSpecificCase(TypedVariable.class, Port.class, Action.class); } @@ -490,6 +491,17 @@ public Boolean caseArraySpec(ArraySpec object) { .conclusion; } + //FIXME: modif4watchdogs + @Override + public Boolean caseWatchdog(Watchdog object) { + return new ComparisonMachine<>(object, Watchdog.class) + .equalAsObjects(Watchdog::getName) + .equivalent(Watchdog::getTimeout) + .listsEquivalent(Watchdog::getEffects) + .equivalent(Watchdog::getCode) + .conclusion; + } + @Override public Boolean caseWidthSpec(WidthSpec object) { return new ComparisonMachine<>(object, WidthSpec.class) diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index 7582ee3a59..03a08ec4b8 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -73,6 +73,7 @@ import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.lf.Visibility; +import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; import org.lflang.lf.util.LfSwitch; @@ -653,6 +654,41 @@ public MalleableString caseDeadline(Deadline object) { return handler(object, "deadline", Deadline::getDelay, Deadline::getCode); } + //FIXME: modif4watchdogs + @Override + public MalleableString caseWatchdog(Watchdog object) { + // 'watchdog' name=ID '(' timeout=Expression ')' + // ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? + // code=Code; + + Builder msb = new Builder(); + msb.append("watchdog "); + msb.append(object.getName()); + msb.append(list(true, object.getTimeout())); + + if (!object.getEffects().isEmpty()) { + List allModes = ASTUtils.allModes(ASTUtils.getEnclosingReactor(object)); + msb.append(" -> ", " ->\n") + .append( + object.getEffects().stream() + .map( + varRef -> + (allModes.stream() + .anyMatch( + m -> m.getName().equals(varRef.getVariable().getName()))) + ? new Builder() + .append(varRef.getTransition()) + .append("(") + .append(doSwitch(varRef)) + .append(")") + .get() + : doSwitch(varRef)) + .collect(new Joiner(", "))); + } + msb.append(" ").append(doSwitch(object.getCode())); + return msb.get(); + } + @Override public MalleableString caseSTP(STP object) { // 'STP' '(' value=Expression ')' code=Code diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index 9bdec7f63b..3ae61579f8 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -9,7 +9,7 @@ reactor Watcher { printf("Deadline missed! Lag: %lld (too late by %lld nsecs)\n", p, p-500000); =} - reaction(x) -> d, poodle {= + reaction(x) -> poodle, d {= lf_watchdog_start(poodle, 0); printf("Normal reaction.\n"); =} From 0d31103fbe5d0c342b2263a5a02de781fb9837f9 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 18:22:49 -0800 Subject: [PATCH 034/709] Also produce code for watchdogs in reactor definition --- org.lflang/src/org/lflang/ast/ToLf.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index 03a08ec4b8..6f9d369dcc 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -391,6 +391,7 @@ public MalleableString caseReactor(Reactor object) { // | (outputs+=Output) // | (timers+=Timer) // | (actions+=Action) + // | (watchdogs+=Watchdog) // | (instantiations+=Instantiation) // | (connections+=Connection) // | (reactions+=Reaction) @@ -408,6 +409,7 @@ public MalleableString caseReactor(Reactor object) { object.getOutputs(), object.getTimers(), object.getActions(), + object.getWatchdogs(), object.getInstantiations(), object.getConnections(), object.getStateVars()), From 59b3737d10fa7353d95a4a577bf6d9e0b8be2856 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 18:29:30 -0800 Subject: [PATCH 035/709] Apply formatter to test --- test/C/src/Watchdog.lf | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index 3ae61579f8..0dd2436478 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -1,8 +1,8 @@ -target C; +target C reactor Watcher { - input x:int; - output d:int; // Produced if the deadline is violated. + input x: int + output d: int // Produced if the deadline is violated. watchdog poodle(10 msec) {= instant_t p = lf_time_physical_elapsed() - lf_time_logical_elapsed(); @@ -12,21 +12,22 @@ reactor Watcher { reaction(x) -> poodle, d {= lf_watchdog_start(poodle, 0); printf("Normal reaction.\n"); - =} + =} } main reactor { - logical action a; - w = new Watcher(); + logical action a + w = new Watcher() + reaction(startup) -> w.x, a {= lf_set(w.x, 0); lf_schedule(a, 0); =} + reaction(a) -> w.x {= lf_set(w.x, 0); lf_nanosleep(MSEC(40)); =} - reaction(w.d) {= - printf("Deadline reactor produced an output.\n"); - =} + + reaction(w.d) {= printf("Deadline reactor produced an output.\n"); =} } From 9d83f55b725cedec83e92231eb753e5cec5b5bf7 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 20:46:56 -0800 Subject: [PATCH 036/709] Fix submodule issues and remove files that should not be checked in --- .gitmodules | 3 ++ org.lflang.tests/.classpath | 13 ----- org.lflang.tests/.project | 51 ------------------- org.lflang/src/lib/cpp/reactor-cpp | 1 + org.lflang/src/lib/rs/reactor-rs | 2 +- .../src/lib/rs/runtime-version.properties | 2 +- 6 files changed, 6 insertions(+), 66 deletions(-) delete mode 100644 org.lflang.tests/.classpath delete mode 100644 org.lflang.tests/.project create mode 160000 org.lflang/src/lib/cpp/reactor-cpp diff --git a/.gitmodules b/.gitmodules index fdbf50ba8d..2231bc265a 100644 --- a/.gitmodules +++ b/.gitmodules @@ -7,3 +7,6 @@ [submodule "org.lflang/src/lib/rs/reactor-rs"] path = org.lflang/src/lib/rs/reactor-rs url = https://github.com/lf-lang/reactor-rs +[submodule "org.lflang/src/lib/cpp/reactor-cpp"] + path = org.lflang/src/lib/cpp/reactor-cpp + url = https://github.com/lf-lang/reactor-cpp.git diff --git a/org.lflang.tests/.classpath b/org.lflang.tests/.classpath deleted file mode 100644 index e025b430eb..0000000000 --- a/org.lflang.tests/.classpath +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - - - - - - - - diff --git a/org.lflang.tests/.project b/org.lflang.tests/.project deleted file mode 100644 index 7acfd6f031..0000000000 --- a/org.lflang.tests/.project +++ /dev/null @@ -1,51 +0,0 @@ - - - org.lflang.tests - - - - - - org.eclipse.jdt.core.javabuilder - - - - - org.eclipse.xtext.ui.shared.xtextBuilder - - - - - org.eclipse.buildship.core.gradleprojectbuilder - - - - - org.eclipse.pde.ManifestBuilder - - - - - org.eclipse.pde.SchemaBuilder - - - - - - org.eclipse.xtext.ui.shared.xtextNature - org.eclipse.jdt.core.javanature - org.eclipse.pde.PluginNature - org.eclipse.buildship.core.gradleprojectnature - - - - 1677834823336 - - 30 - - org.eclipse.core.resources.regexFilterMatcher - node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__ - - - - diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp new file mode 160000 index 0000000000..e5d7cfd1f8 --- /dev/null +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -0,0 +1 @@ +Subproject commit e5d7cfd1f89846bc928da86c38a33bb17e1c049b diff --git a/org.lflang/src/lib/rs/reactor-rs b/org.lflang/src/lib/rs/reactor-rs index 7685764194..28f9460724 160000 --- a/org.lflang/src/lib/rs/reactor-rs +++ b/org.lflang/src/lib/rs/reactor-rs @@ -1 +1 @@ -Subproject commit 76857641941aa49c766ba23da63db4f7650a4c77 +Subproject commit 28f9460724b266c263f4fdf8146b2029f4ff9d30 diff --git a/org.lflang/src/lib/rs/runtime-version.properties b/org.lflang/src/lib/rs/runtime-version.properties index 4449aaf2fd..35b335b731 100644 --- a/org.lflang/src/lib/rs/runtime-version.properties +++ b/org.lflang/src/lib/rs/runtime-version.properties @@ -1 +1 @@ -rs = 76857641941aa49c766ba23da63db4f7650a4c77 +rs = 28f9460724b266c263f4fdf8146b2029f4ff9d30 From ec8afa7cf2f1ecab29b678f15e4263b1003f04c5 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 20:48:07 -0800 Subject: [PATCH 037/709] Remove spurious file --- base | 0 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 base diff --git a/base b/base deleted file mode 100644 index e69de29bb2..0000000000 From da5b43a1182f678e7ed6f52f277592d6b63a6e27 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 20:48:54 -0800 Subject: [PATCH 038/709] Change order of submodules --- .gitmodules | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.gitmodules b/.gitmodules index 2231bc265a..efb73c9f3d 100644 --- a/.gitmodules +++ b/.gitmodules @@ -4,9 +4,9 @@ [submodule "org.lflang/src/lib/py/reactor-c-py"] path = org.lflang/src/lib/py/reactor-c-py url = https://github.com/lf-lang/reactor-c-py.git -[submodule "org.lflang/src/lib/rs/reactor-rs"] - path = org.lflang/src/lib/rs/reactor-rs - url = https://github.com/lf-lang/reactor-rs [submodule "org.lflang/src/lib/cpp/reactor-cpp"] path = org.lflang/src/lib/cpp/reactor-cpp url = https://github.com/lf-lang/reactor-cpp.git +[submodule "org.lflang/src/lib/rs/reactor-rs"] + path = org.lflang/src/lib/rs/reactor-rs + url = https://github.com/lf-lang/reactor-rs From 9460c1a990724fb2d0a35886da65a7643b66cee3 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 20:51:14 -0800 Subject: [PATCH 039/709] Let version of reactor-cpp be the same as in master --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index e5d7cfd1f8..a37f0ade9e 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit e5d7cfd1f89846bc928da86c38a33bb17e1c049b +Subproject commit a37f0ade9ee0f97606528fd7ba67712495948373 From 043cfbcbe06d54b9de0fbd189339ed630913089d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 8 Mar 2023 20:56:48 -0800 Subject: [PATCH 040/709] Make submodule entries uniform --- .gitmodules | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitmodules b/.gitmodules index efb73c9f3d..274bffab2c 100644 --- a/.gitmodules +++ b/.gitmodules @@ -9,4 +9,4 @@ url = https://github.com/lf-lang/reactor-cpp.git [submodule "org.lflang/src/lib/rs/reactor-rs"] path = org.lflang/src/lib/rs/reactor-rs - url = https://github.com/lf-lang/reactor-rs + url = https://github.com/lf-lang/reactor-rs.git From 41c543065055e98b36f5b720d8faa4302dc5c678 Mon Sep 17 00:00:00 2001 From: Ben Date: Wed, 8 Mar 2023 23:03:10 -0800 Subject: [PATCH 041/709] Update org.lflang/src/org/lflang/ast/ToLf.java Co-authored-by: Marten Lohstroh --- org.lflang/src/org/lflang/ast/ToLf.java | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index 6f9d369dcc..637a555a24 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -656,7 +656,6 @@ public MalleableString caseDeadline(Deadline object) { return handler(object, "deadline", Deadline::getDelay, Deadline::getCode); } - //FIXME: modif4watchdogs @Override public MalleableString caseWatchdog(Watchdog object) { // 'watchdog' name=ID '(' timeout=Expression ')' From 89abf744dc967a9ad56098e2deecd6269276063e Mon Sep 17 00:00:00 2001 From: Ben Date: Wed, 8 Mar 2023 23:03:24 -0800 Subject: [PATCH 042/709] Update org.lflang/src/org/lflang/ast/IsEqual.java Co-authored-by: Marten Lohstroh --- org.lflang/src/org/lflang/ast/IsEqual.java | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index 1af1eed81a..0d2eab148e 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -400,7 +400,6 @@ public Boolean caseTypedVariable(TypedVariable object) { @Override public Boolean caseVariable(Variable object) { - //FIXME: modif4watchdogs throw thereIsAMoreSpecificCase(Variable.class, TypedVariable.class, Timer.class, Mode.class, Watchdog.class); } From e4be4d56a8bfe28095d0d2dd49f8ad390c93533a Mon Sep 17 00:00:00 2001 From: Ben Date: Wed, 8 Mar 2023 23:03:30 -0800 Subject: [PATCH 043/709] Update org.lflang/src/org/lflang/ast/IsEqual.java Co-authored-by: Marten Lohstroh --- org.lflang/src/org/lflang/ast/IsEqual.java | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index 0d2eab148e..16312eb73a 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -490,7 +490,6 @@ public Boolean caseArraySpec(ArraySpec object) { .conclusion; } - //FIXME: modif4watchdogs @Override public Boolean caseWatchdog(Watchdog object) { return new ComparisonMachine<>(object, Watchdog.class) From a81d25b66e9649172e1c2042afea9c0bdc974976 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 8 Mar 2023 23:19:42 -0800 Subject: [PATCH 044/709] removed fixmes, updated grammar --- org.lflang/src/org/lflang/ASTUtils.java | 11 ----------- org.lflang/src/org/lflang/LinguaFranca.xtext | 2 +- org.lflang/src/org/lflang/ast/IsEqual.java | 4 ---- org.lflang/src/org/lflang/ast/ToLf.java | 1 - .../federated/generator/FederateInstance.java | 19 ------------------- .../org/lflang/generator/ReactorInstance.java | 4 ---- .../lflang/generator/WatchdogInstance.java | 2 -- .../org/lflang/generator/c/CGenerator.java | 11 ----------- .../generator/c/CReactionGenerator.java | 4 ---- .../generator/c/CWatchdogGenerator.java | 2 +- .../org/lflang/validation/LFValidator.java | 1 - 11 files changed, 2 insertions(+), 59 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 896765f459..e027ad41dc 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -91,7 +91,6 @@ import org.lflang.lf.VarRef; import org.lflang.lf.Variable; -//FIXME: modif4watchdogs import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; @@ -125,8 +124,6 @@ public class ASTUtils { /** * A mapping from Reactor features to corresponding Mode features for collecting contained elements. */ - //FIXME: modif4watchdogs - // added 'featurePackage.getReactor_Watchdogs' private static final Map reactorModeFeatureMap = Map.of( featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), @@ -423,7 +420,6 @@ public static List allReactions(Reactor definition) { * @param definition Reactor class definition * @return List */ - // FIXME: modif4watchdogs public static List allWatchdogs(Reactor definition) { return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); } @@ -1075,13 +1071,6 @@ public static InferredType getInferredType(Port p) { return getInferredType(p.getType(), null); } - //FIXME: modif4watchdogs - // public static InferredType getInferredType(Watchdog w) { - // return getInferredType(w.getType(), null); - // } - - - /** * If the given string can be recognized as a floating-point number that has a leading decimal point, * prepend the string with a zero and return it. Otherwise, return the original string. diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index 55f5fb0a97..98dbb77e1e 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -87,11 +87,11 @@ Reactor: | (outputs+=Output) | (timers+=Timer) | (actions+=Action) + | (watchdogs+=Watchdog) | (instantiations+=Instantiation) | (connections+=Connection) | (reactions+=Reaction) | (modes+=Mode) - | (watchdogs+=Watchdog) )* '}'; diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index 1af1eed81a..08c54a999b 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -61,7 +61,6 @@ import org.lflang.lf.Variable; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; -//FIXME: modif4watchdogs import org.lflang.lf.Watchdog; import org.lflang.lf.util.LfSwitch; @@ -394,13 +393,11 @@ public Boolean caseElement(Element object) { @Override public Boolean caseTypedVariable(TypedVariable object) { - //FIXME: modif4watchdogs throw thereIsAMoreSpecificCase(TypedVariable.class, Port.class, Action.class); } @Override public Boolean caseVariable(Variable object) { - //FIXME: modif4watchdogs throw thereIsAMoreSpecificCase(Variable.class, TypedVariable.class, Timer.class, Mode.class, Watchdog.class); } @@ -491,7 +488,6 @@ public Boolean caseArraySpec(ArraySpec object) { .conclusion; } - //FIXME: modif4watchdogs @Override public Boolean caseWatchdog(Watchdog object) { return new ComparisonMachine<>(object, Watchdog.class) diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index 6f9d369dcc..637a555a24 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -656,7 +656,6 @@ public MalleableString caseDeadline(Deadline object) { return handler(object, "deadline", Deadline::getDelay, Deadline::getCode); } - //FIXME: modif4watchdogs @Override public MalleableString caseWatchdog(Watchdog object) { // 'watchdog' name=ID '(' timeout=Expression ')' diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index f13313b033..af581cc74d 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -464,25 +464,6 @@ private boolean contains(Timer timer) { } return false; } - - //FIXME:modif4watchdogs - - // public boolean contains(Watchdog watchdog) { - // Reactor reactor = ASTUtils.getEnclosingReactor(watchdog); - // if (!reactor.isFederated() || this.isSingleton()) { - // return true; - // } - - // if (!reactor.getWatchdogs().contains(watchdog)) { - // return false; - // } - - // if (networkReactions.contains(watchdog)) { - // return true; - // } - - // return false; - // } /** * Return true if the specified reactor instance or any parent diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 06acad45dc..19859cb8a0 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -63,7 +63,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Variable; import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; -//FIXME: modif4watchdogs import org.lflang.lf.Watchdog; @@ -148,7 +147,6 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re public final List reactions = new ArrayList<>(); /** List of watchdog instances for this reactor instance. */ - //FIXME: modif4watchdogs public final List watchdogs = new ArrayList<>(); /** The timer instances belonging to this reactor instance. */ @@ -753,7 +751,6 @@ protected void createReactionInstances() { /** * Create all the watchdog instances of this reactor instance. */ - // FIXME: modif4watchdogs protected void createWatchdogInstances() { List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); if (watchdogs != null) { @@ -876,7 +873,6 @@ private ReactorInstance( createReactionInstances(); // Create the reaction instances in this reactor instance. - // FIXME: modif4watchdogs createWatchdogInstances(); // Instantiate modes for this reactor instance diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index 780113a80f..2a2e11a3ad 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -10,8 +10,6 @@ * * @author{Benjamin Asch } */ -//FIXME: modif4watchdogs -//FIXME: functions in constructor not defined public class WatchdogInstance { /** diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index aa64cd5fba..d34e58ebfc 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -80,7 +80,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; -// FIXME: modif4watchdogs import org.lflang.generator.WatchdogInstance; import org.lflang.generator.SubContext; @@ -105,7 +104,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Watchdog; import org.lflang.util.FileUtil; -// FIXME: modif4watchdogs import org.lflang.lf.Watchdog; import org.lflang.util.LFCommand; @@ -365,7 +363,6 @@ public class CGenerator extends GeneratorBase { private int resetReactionCount = 0; private int modalReactorCount = 0; private int modalStateResetCount = 0; - // FIXME: modif4watchdogs private int watchdogCount = 0; // Indicate whether the generator is in Cpp mode or not @@ -709,7 +706,6 @@ private void generateCodeFor( // If there are reset reactions, create a table of triggers. code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); - //FIXME: modif4watchdogs // If there are watchdogs, create a table of triggers. code.pr(CWatchdogGenerator.generateBuiltinTriggersTable(watchdogCount, "watchdog")); @@ -737,7 +733,6 @@ private void generateCodeFor( // Generate function to schedule timers for all reactors. code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); - //FIXME:modif4watchdogs // Generate function to initialize mutexes for all reactors with watchdogs. // needs to be implemented still code.pr(CWatchdogGenerator.generateLfInitializeWatchdogMutexes(watchdogCount)); @@ -827,7 +822,6 @@ private boolean hasDeadlines(List reactors) { return false; } - //FIXME: modif4watchdogs private boolean hasWatchdogs(Reactor reactor) { if (ASTUtils.allWatchdogs(reactor) != null) { return true; @@ -1072,7 +1066,6 @@ private void generateReactorClass(ReactorDecl reactor) { generateSelfStruct(reactor, constructorCode); generateMethods(reactor); - // FIXME: modif4watchdogs generateWatchdogs(reactor); generateReactions(reactor); generateConstructor(reactor, constructorCode); @@ -1225,7 +1218,6 @@ private void generateSelfStruct(ReactorDecl decl, CodeBuilder constructorCode) { ); // Generate the fields needed for each watchdog. - // FIXME: modif4watchdogs CWatchdogGenerator.generateWatchdogStruct( body, decl, @@ -1435,7 +1427,6 @@ protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactio )); } - // FIXME: modif4watchdogs /** Generate watchdog functions definition for a reactor. * These functions have a single argument that is a void* pointing to * a struct that contains parameters, state variables, inputs (triggering or not), @@ -1513,7 +1504,6 @@ private void recordBuiltinTriggers(ReactorInstance instance) { } } - // FIXME: modif4watchdogs private void recordWatchdogs(ReactorInstance instance) { var foundOne = false; var temp = new CodeBuilder(); @@ -1774,7 +1764,6 @@ public void generateReactorInstance(ReactorInstance instance) { initializeOutputMultiports(instance); initializeInputMultiports(instance); recordBuiltinTriggers(instance); - // FIXME: modif4watchdogs recordWatchdogs(instance); // Next, initialize the "self" struct with state variables. diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 6eaa7506b1..6959d52937 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -36,7 +36,6 @@ import org.lflang.lf.Variable; import org.lflang.lf.Watchdog; import org.lflang.util.StringUtil; -// FIXME: modif4watchdogs import org.lflang.lf.Watchdog; public class CReactionGenerator { @@ -199,7 +198,6 @@ public static String generateInitializationForReaction(String body, (Input) variable ); } else if (variable instanceof Watchdog) { - //FIXME: modif4watchdogs reactionInitialization.pr(generateWatchdogVariablesInReaction( effect, decl @@ -678,7 +676,6 @@ public static String generateOutputVariablesInReaction( * @param effect The effect declared by the reaction. This must refer to a watchdog. * @param decl The reactor containing the reaction or the import statement. */ - //FIXME: modif4watchdogs // Fine to have watchdog be in reactor self struct? public static String generateWatchdogVariablesInReaction( VarRef effect, @@ -1185,7 +1182,6 @@ public static String generateStpFunctionHeader(ReactorDecl decl, return generateFunctionHeader(functionName); } - //FIXME: modif4watchdogs (changed from private to public to access in CWatchdogGenerator) public static String generateFunctionHeader(String functionName) { return "void " + functionName + "(void* instance_args)"; } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 5b0343ecc7..4078a98688 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -21,7 +21,7 @@ * * @author{Benjamin Asch } */ -//FIXME: modif4watchdogs + public class CWatchdogGenerator { /** diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 847bd7320d..fa6d8b06fc 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -113,7 +113,6 @@ import org.lflang.lf.Visibility; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; -//FIXME: modif4watchdogs import org.lflang.lf.Watchdog; import org.lflang.util.FileUtil; From 88dbef7eed634fd02e8a8f0ecd451e91a689a36d Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 8 Mar 2023 23:57:29 -0800 Subject: [PATCH 045/709] fixed ccpp test issue? --- org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 4078a98688..8b536a9ef8 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -153,7 +153,7 @@ public static void generateWatchdogStruct( "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", "self->_lf_watchdog_"+watchdogName+".thread_active = false;", // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", - "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";" + "self->_lf_watchdog_"+watchdogName+".watchdog_function = &("+watchdogFunctionName+");" )); // WATCHDOG QUESTION 6: should I be initializing mutex in this constructor? From ef489d3cf5ece299019099e3d5c7f8fc378dea6e Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 28 Feb 2023 15:41:47 +0100 Subject: [PATCH 046/709] generate a wrapper reactor for enclave --- .../generator/cpp/CppInstanceGenerator.kt | 81 ++++++++++--------- .../generator/cpp/CppReactionGenerator.kt | 3 +- 2 files changed, 46 insertions(+), 38 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt index 4aee21202f..5f92d528b8 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt @@ -36,29 +36,54 @@ class CppInstanceGenerator( private val fileConfig: CppFileConfig, private val errorReporter: ErrorReporter ) { - private val Instantiation.isEnclave: Boolean get() = AttributeUtils.isEnclave(this) + companion object { + val Instantiation.isEnclave: Boolean get() = AttributeUtils.isEnclave(this) - private val Instantiation.hasEachParameter: Boolean - get() = AttributeUtils.getBooleanAttributeParameter( - AttributeUtils.getEnclaveAttribute(this), AttributeSpec.EACH_ATTR - ) ?: false + val Instantiation.hasEachParameter: Boolean + get() = AttributeUtils.getBooleanAttributeParameter( + AttributeUtils.getEnclaveAttribute(this), AttributeSpec.EACH_ATTR + ) ?: false - val Instantiation.cppType: String - get() { - return if (reactor.isGeneric) + private val Instantiation.reactorType: String + get() = if (reactor.isGeneric) """${reactor.name}<${typeParms.joinToString(", ") { it.toText() }}>""" else reactor.name - } + + val Instantiation.cppClass: String + get() = if (isEnclave) enclaveWrapperClassName else reactorType + + val Instantiation.enclaveWrapperClassName get() = "EnclaveWrapper_$name" + } + + private fun Instantiation.generateWrapper(): String = """ + |class $enclaveWrapperClassName : public reactor::Reactor { + | private: + | ${if (!hasEachParameter) "inline static " else ""}std::unique_ptr __lf_env{nullptr}; + | std::unique_ptr<$reactorType> __lf_instance{nullptr}; + | + | public: + | EnclaveWrapper_$name(const std::string& name, reactor::Reactor* container, $reactorType::Parameters&& params) + | : Reactor("enclave_wrapper_" + name, container) { + | if (__lf_env == nullptr) { + | __lf_env = std::make_unique(container->fqn() + name, container->environment()); + | } + | __lf_instance = std::make_unique<$reactorType>(name, __lf_env.get(), std::forward<$reactorType::Parameters>(params)); + | } + | + | void assemble() override {} + |}; + """.trimMargin() private fun generateDeclaration(inst: Instantiation): String = with(inst) { - val instance = if (isBank) "std::vector>" else "std::unique_ptr<$cppType>" + val instance = if (isBank) "std::vector>" else "std::unique_ptr<$cppClass>" if (isEnclave) { - val env = if (hasEachParameter) "std::vector>" else "reactor::Environment" - return """ - $env __lf_env_$name; - $instance $name; - """.trimIndent() + return with(PrependOperator) { + """ + ${" |"..inst.generateWrapper()} + |$instance $name; + """.trimMargin() + } } return "$instance $name;" } @@ -91,43 +116,25 @@ class CppInstanceGenerator( // by iterating over the reactor parameters we make sure that the parameters are assigned in declaration order return reactor.parameters.mapNotNull { if (it.name in assignments) ".${it.name} = ${assignments[it.name]}" else null - }.joinToString(", ", "$cppType::Parameters{", "}") + }.joinToString(", ", "$reactorType::Parameters{", "}") } private fun generateInitializer(inst: Instantiation): String? = with(inst) { - when { - !isBank && !isEnclave -> """, $name(std::make_unique<$cppType>("$name", this, ${getParameterStruct()}))""" - !isBank && isEnclave -> """ - , __lf_env_$name(this->fqn() + ".$name", this->environment()) - , $name(std::make_unique<$cppType>("$name", &__lf_env_$name, ${getParameterStruct()})) - """.trimIndent() - - isBank && isEnclave && !hasEachParameter -> """, __lf_env_$name(this->fqn() + ".$name", this->environment())""" - else -> null - } + if (isBank) null else """, $name(std::make_unique<$cppClass>("$name", this, ${getParameterStruct()}))""" } private fun generateConstructorInitializer(inst: Instantiation): String { with(inst) { assert(isBank) - val containerRef = when { - hasEachParameter -> "__lf_env_$name[__lf_idx].get()" - isEnclave -> "&__lf_env_$name" - else -> "this" - } - val width = inst.widthSpec.toCppCode() - return with(PrependOperator) { - """ + return """ |// initialize instance $name |$name.reserve($width); |for (size_t __lf_idx = 0; __lf_idx < $width; __lf_idx++) { | std::string __lf_inst_name = "${name}_" + std::to_string(__lf_idx); - ${"| "..if (hasEachParameter) """__lf_env_$name.emplace_back(std::make_unique(this->fqn() + "." + __lf_inst_name, this->environment()));""" else ""} - | $name.emplace_back(std::make_unique<$cppType>(__lf_inst_name, $containerRef, ${inst.getParameterStruct()})); + | $name.emplace_back(std::make_unique<$cppClass>(__lf_inst_name, this, ${inst.getParameterStruct()})); |} """.trimMargin() - } } } diff --git a/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt index c1e66f3632..5baa075fe6 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt @@ -25,6 +25,7 @@ package org.lflang.generator.cpp import org.lflang.generator.PrependOperator +import org.lflang.generator.cpp.CppInstanceGenerator.Companion.cppClass import org.lflang.isBank import org.lflang.joinWithLn import org.lflang.label @@ -172,7 +173,7 @@ class CppReactionGenerator( } private fun generateViewForContainer(r: Reaction, container: Instantiation): String { - val reactorClass = with(instanceGenerator) { container.cppType } + val reactorClass = container.cppClass val viewClass = r.getViewClassName(container) val viewInstance = r.getViewInstanceName(container) From 3eeaf50a36af2f4d45bf8c971968aa1feebd7533 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 9 Mar 2023 14:43:19 +0100 Subject: [PATCH 047/709] use a struct instead of a reactor to wrap enclaves --- .../src/org/lflang/generator/cpp/CppInstanceGenerator.kt | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt index 5f92d528b8..98b7a0f2c5 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt @@ -57,21 +57,16 @@ class CppInstanceGenerator( } private fun Instantiation.generateWrapper(): String = """ - |class $enclaveWrapperClassName : public reactor::Reactor { - | private: + |struct $enclaveWrapperClassName { | ${if (!hasEachParameter) "inline static " else ""}std::unique_ptr __lf_env{nullptr}; | std::unique_ptr<$reactorType> __lf_instance{nullptr}; | - | public: - | EnclaveWrapper_$name(const std::string& name, reactor::Reactor* container, $reactorType::Parameters&& params) - | : Reactor("enclave_wrapper_" + name, container) { + | $enclaveWrapperClassName(const std::string& name, reactor::Reactor* container, $reactorType::Parameters&& params) { | if (__lf_env == nullptr) { | __lf_env = std::make_unique(container->fqn() + name, container->environment()); | } | __lf_instance = std::make_unique<$reactorType>(name, __lf_env.get(), std::forward<$reactorType::Parameters>(params)); | } - | - | void assemble() override {} |}; """.trimMargin() From 619a7663e79a3ed6ce761e4397a61328900bd10b Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 9 Mar 2023 19:41:41 +0100 Subject: [PATCH 048/709] first support for simple enclave communication --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- .../generator/cpp/CppConnectionGenerator.kt | 37 ++++++++++++++++--- .../org/lflang/generator/cpp/CppExtensions.kt | 8 +++- .../lflang/generator/cpp/CppPortGenerator.kt | 19 ++++++---- 4 files changed, 50 insertions(+), 16 deletions(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index a63a870180..9e11793a8f 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit a63a870180137a023b7faf875271775787a56c03 +Subproject commit 9e11793a8f7ed2ff98eff840dd6e6b8d424dca2d diff --git a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt index 2ff818b517..3ec27fc571 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt @@ -2,6 +2,8 @@ package org.lflang.generator.cpp import org.lflang.* import org.lflang.generator.cpp.CppConnectionGenerator.Companion.cppType +import org.lflang.generator.cpp.CppConnectionGenerator.Companion.isEnclaveConnection +import org.lflang.generator.cpp.CppInstanceGenerator.Companion.isEnclave import org.lflang.generator.cpp.CppPortGenerator.Companion.dataType import org.lflang.lf.Connection import org.lflang.lf.Port @@ -25,13 +27,33 @@ class CppConnectionGenerator(private val reactor: Reactor) { get() { val leftPort = leftPorts.first() return when { - isPhysical -> "reactor::PhysicalConnection<${leftPort.dataType}>" - delay != null -> "reactor::DelayedConnection<${leftPort.dataType}>" - else -> throw IllegalArgumentException("Connection is neither physical nor delayed") + isEnclaveConnection && !isPhysical && delay == null -> "reactor::EnclaveConnection<${leftPort.dataType}>" + isPhysical -> "reactor::PhysicalConnection<${leftPort.dataType}>" + delay != null -> "reactor::DelayedConnection<${leftPort.dataType}>" + else -> throw IllegalArgumentException("Unsupported connection type") } } - val Connection.requiresConnectionClass: Boolean get() = isPhysical || delay != null + val Connection.isEnclaveConnection: Boolean + get() { + if (leftPorts.size == 1 && rightPorts.size == 1) { + val leftIsEnclave = leftPorts[0].container?.isEnclave == true + val rightIsEnclave = rightPorts[0].container?.isEnclave == true + return when { + leftIsEnclave && rightIsEnclave -> true + !leftIsEnclave && !rightIsEnclave -> false + else -> TODO("Connections between enclaves and normal reactors are not supported") + } + } + for (port in leftPorts + rightPorts) { + if (port.container?.isEnclave == true) { + TODO("Enclaves can only be used in simple connections") + } + } + return false + } + + val Connection.requiresConnectionClass: Boolean get() = isPhysical || delay != null || isEnclaveConnection; } fun generateDeclarations() = @@ -52,8 +74,11 @@ class CppConnectionGenerator(private val reactor: Reactor) { private fun generateConstructorInitializer(connection: Connection): String? = if (connection.requiresConnectionClass && !connection.hasMultipleConnections) { - val delay = connection.delay.toCppTime() val name = connection.name - """, $name{"$name", this, $delay}""" + val delay = connection.delay?.toCppTime() + if (connection.isEnclaveConnection) + """, $name{"$name", ${connection.rightPorts[0].container.name}->__lf_env.get()}""" + else + """, $name{"$name", this, $delay}""" } else null } diff --git a/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt b/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt index f2386bf96a..a081bdd551 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt @@ -2,6 +2,7 @@ package org.lflang.generator.cpp import org.eclipse.emf.ecore.resource.Resource import org.lflang.* +import org.lflang.generator.cpp.CppInstanceGenerator.Companion.isEnclave import org.lflang.lf.BuiltinTriggerRef import org.lflang.lf.Expression import org.lflang.lf.Port @@ -111,8 +112,11 @@ val Reactor.templateName: String get() = if (isGeneric) "$name<${typeParms.joinT /** Get a C++ code representation of the given variable */ val VarRef.name: String - get() = if (this.container == null) this.variable.name - else "${this.container.name}->${this.variable.name}" + get() = when { + container == null -> variable.name + container.isEnclave -> "${container.name}->__lf_instance->${variable.name}" + else -> "${container.name}->${variable.name}" + } /** Get a C++ code representation of the given trigger */ val TriggerRef.name: String diff --git a/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt index 69ca1d27f6..79dd4ad93a 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt @@ -24,6 +24,8 @@ package org.lflang.generator.cpp +import org.lflang.generator.cpp.CppInstanceGenerator.Companion.enclaveWrapperClassName +import org.lflang.generator.cpp.CppInstanceGenerator.Companion.isEnclave import org.lflang.inferredType import org.lflang.isBank import org.lflang.isMultiport @@ -34,7 +36,6 @@ class CppPortGenerator(private val reactor: Reactor) { companion object { private val VarRef.isMultiport get() = (variable as? Port)?.isMultiport == true - private val VarRef.isInBank get() = container?.isBank == true /** * Return the C++ type of a port reference. @@ -44,11 +45,15 @@ class CppPortGenerator(private val reactor: Reactor) { * statement and let the C++ compiler do the job. */ val VarRef.dataType: String - get() = when { - isInBank && isMultiport -> "std::remove_reference${variable.name}[0])>::type::value_type" - isInBank && !isMultiport -> "std::remove_reference${variable.name})>::type::value_type" - !isInBank && isMultiport -> "std::remove_reference::type::value_type" - else -> "std::remove_reference::type::value_type" + get() { + val variableRef = when { + this == null -> "" + container.isBank && container.isEnclave -> "${container.name}[0]->__lf_instance->${variable.name}" + container.isBank && !container.isEnclave -> "${container.name}[0]->${variable.name}" + else -> this.name + } + val multiportRef = if (isMultiport) "$variableRef[0]" else variableRef + return "std::remove_reference::type::value_type" } } @@ -62,7 +67,7 @@ class CppPortGenerator(private val reactor: Reactor) { } /** Get the C++ type for the receiving port. */ - val Port.cppType: String + private val Port.cppType: String get() { val portType = when (this) { is Input -> "reactor::Input" From b1d6dcaeb628abb8afb22f0a6d39db64dda68fdf Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 9 Mar 2023 19:43:16 +0100 Subject: [PATCH 049/709] add test case --- test/Cpp/src/enclave/EnclaveCommunication.lf | 29 ++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 test/Cpp/src/enclave/EnclaveCommunication.lf diff --git a/test/Cpp/src/enclave/EnclaveCommunication.lf b/test/Cpp/src/enclave/EnclaveCommunication.lf new file mode 100644 index 0000000000..00cd314e50 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunication.lf @@ -0,0 +1,29 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output out: int + state counter: int(0); + reaction(t) -> out {= + out.set(counter++); + =} +} + +reactor Sink { + input in: int + reaction(in) {= + reactor::log::Info() << "Received " << *in.get(); + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in +} \ No newline at end of file From 62ee371167c01c3d19a92ba40b19972e710ffa1a Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 9 Mar 2023 23:09:09 -0800 Subject: [PATCH 050/709] Pull reactor-ts from GitHub, not NPM --- .github/workflows/ts-tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 24e40b7eef..7c617237b5 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -28,7 +28,7 @@ jobs: if: ${{ runner.os == 'macOS' }} - name: Perform TypeScript tests run: | - ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* + ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#cleanup-deps - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: From e9c76a8eee6dfd5da5edd94eb43a2d18d4872cc8 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 9 Mar 2023 23:51:31 -0800 Subject: [PATCH 051/709] Add closing quote --- .github/workflows/ts-tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 7c617237b5..79c972d744 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -28,7 +28,7 @@ jobs: if: ${{ runner.os == 'macOS' }} - name: Perform TypeScript tests run: | - ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#cleanup-deps + ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#cleanup-deps" - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: From 5670e27cc3051381b0becd2f1ec2c3c39b2a81a9 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 13 Mar 2023 11:46:09 -0700 Subject: [PATCH 052/709] saving before pull again --- .github/actions/prepare-build-env/action.yml | 6 +- .github/scripts/test-lfc.sh | 2 +- .github/workflows/c-zephyr-tests.yml | 2 +- org.lflang/src/org/lflang/cli/CliBase.java | 23 +---- org.lflang/src/org/lflang/cli/Lfc.java | 98 ++++++++----------- org.lflang/src/org/lflang/cli/Lff.java | 12 --- .../org/lflang/generator/GeneratorBase.java | 1 - .../org/lflang/generator/GeneratorUtils.java | 68 +------------ .../lflang/generator/c/CCmakeGenerator.java | 5 - .../generator/cpp/CppRos2NodeGenerator.kt | 3 +- .../cpp/CppStandaloneMainGenerator.kt | 4 +- .../org/lflang/validation/LFValidator.java | 15 ++- test/Cpp/src/concurrent/AsyncCallback.lf | 1 - test/Cpp/src/concurrent/AsyncCallback2.lf | 1 - 14 files changed, 66 insertions(+), 175 deletions(-) diff --git a/.github/actions/prepare-build-env/action.yml b/.github/actions/prepare-build-env/action.yml index e0b8f8bfb0..16cfc3c410 100644 --- a/.github/actions/prepare-build-env/action.yml +++ b/.github/actions/prepare-build-env/action.yml @@ -15,12 +15,16 @@ runs: cat gradle.properties echo $JAVA_HOME shell: bash + - name: Create hash of Gradle configuration + run: | + echo "gradle-hash"="$(find . -type f \( -name "gradle.properties" -o -name "gradle-wrapper.properties" \) -exec cat {} + | sha256sum | cut -d ' ' -f 1)" >> $GITHUB_ENV + shell: bash - name: Cache uses: actions/cache@v3 with: path: | ~/.gradle/caches ~/.gradle/wrapper - key: gradle-${{ runner.os }}-${{ hashFiles('**/gradle-wrapper.properties') }} + key: gradle-${{ runner.os }}-${{ env.gradle-hash }} # restore-keys: | # ${{ runner.os }}-gradle- diff --git a/.github/scripts/test-lfc.sh b/.github/scripts/test-lfc.sh index 20c087db81..a59d4acd3b 100755 --- a/.github/scripts/test-lfc.sh +++ b/.github/scripts/test-lfc.sh @@ -50,7 +50,7 @@ bin/lfc --output-path . test/C/src/Minimal.lf # --runtime-version Specify the version of the runtime # library used for compiling LF # programs. -bin/lfc --runtime-version f157be30bbeab0e2a991f29f9c7f388ca39681a7 test/Cpp/src/Minimal.lf +bin/lfc --runtime-version e80cd36ce5bd625a7b167e7dfd65d25f78b0dd01 test/Cpp/src/Minimal.lf # -w,--workers Specify the default number of worker threads. bin/lfc -w 2 test/C/src/Minimal.lf diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index cb3b3a4657..21fe4db2c4 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -21,7 +21,7 @@ jobs: run: runs-on: ubuntu-latest container: - image: zephyrprojectrtos/zephyr-build:latest + image: zephyrprojectrtos/zephyr-build:v0.24.13 options: -u root --entrypoint /bin/sh steps: - name: Install Java 17, Maven and set JAVA_HOME diff --git a/org.lflang/src/org/lflang/cli/CliBase.java b/org.lflang/src/org/lflang/cli/CliBase.java index 1a8a26b8c6..77581a6410 100644 --- a/org.lflang/src/org/lflang/cli/CliBase.java +++ b/org.lflang/src/org/lflang/cli/CliBase.java @@ -1,22 +1,15 @@ package org.lflang.cli; import java.io.IOException; -import java.io.PrintStream; import java.io.PrintWriter; import java.nio.file.Files; import java.nio.file.Path; -import java.util.Arrays; import java.util.List; -import java.util.Properties; import java.util.stream.Collectors; import picocli.CommandLine; -import picocli.CommandLine.Command; -import picocli.CommandLine.Model.CommandSpec; import picocli.CommandLine.Option; import picocli.CommandLine.Parameters; -import picocli.CommandLine.ParseResult; -import picocli.CommandLine.Spec; import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; @@ -29,8 +22,6 @@ import org.lflang.ErrorReporter; import org.lflang.LFRuntimeModule; import org.lflang.LFStandaloneSetup; -import org.lflang.LocalStrings; -import org.lflang.generator.LFGeneratorContext.BuildParm; import org.lflang.util.FileUtil; import com.google.inject.Inject; import com.google.inject.Injector; @@ -45,11 +36,6 @@ * @author Atharva Patil */ public abstract class CliBase implements Runnable { - /** - * Models a command specification, including the options, positional - * parameters and subcommands supported by the command. - */ - @Spec CommandSpec spec; /** * Options and parameters present in both Lfc and Lff. @@ -65,8 +51,8 @@ public abstract class CliBase implements Runnable { defaultValue = "", fallbackValue = "", description = "Specify the root output directory.") - private Path outputPath; + /** * Used to collect all errors that happen during validation/generation. */ @@ -103,13 +89,6 @@ public abstract class CliBase implements Runnable { @Inject private IResourceValidator validator; - /** Name of the program, eg "lfc". */ - private final String toolName; - - protected CliBase(String toolName) { - this.toolName = toolName; - } - protected static void cliMain( String toolName, Class toolClass, Io io, String[] args) { diff --git a/org.lflang/src/org/lflang/cli/Lfc.java b/org.lflang/src/org/lflang/cli/Lfc.java index ffafb9d824..489e9cd2f4 100644 --- a/org.lflang/src/org/lflang/cli/Lfc.java +++ b/org.lflang/src/org/lflang/cli/Lfc.java @@ -1,20 +1,12 @@ package org.lflang.cli; -import java.nio.file.Files; import java.nio.file.Path; -import java.util.Arrays; import java.util.List; import java.util.Properties; -import java.util.Set; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import picocli.CommandLine; import picocli.CommandLine.Command; -import picocli.CommandLine.Model.OptionSpec; import picocli.CommandLine.Option; -import picocli.CommandLine.Parameters; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.GeneratorDelegate; import org.eclipse.xtext.generator.JavaIoFileSystemAccess; @@ -54,15 +46,8 @@ public class Lfc extends CliBase { @Inject private JavaIoFileSystemAccess fileAccess; - public Lfc() { - super("lfc"); - } - - /** + /* * Supported CLI options. - * - * @author Marten Lohstroh - * @author Atharva Patil */ @Option( @@ -101,7 +86,7 @@ public Lfc() { @Option( names = {"-l", "--lint"}, arity = "0", - description = "Enable or disable linting of generated code.") + description = "Enable linting of generated code.") private boolean lint; @Option( @@ -143,7 +128,7 @@ public Lfc() { @Option( names = {"-w", "--workers"}, description = "Specify the default number of worker threads.") - private int workers; + private Integer workers; /** * Main function of the stand-alone compiler. @@ -245,47 +230,48 @@ private Path getActualOutputPath(Path root, Path path) { * @return Properties for the code generator. */ protected Properties filterPassOnProps() { - // Parameters corresponding to the options that need to be passed on to - // the generator as properties. - final Set passOnParams = Stream.of( - BuildParm.BUILD_TYPE, - BuildParm.CLEAN, - BuildParm.TARGET_COMPILER, - BuildParm.EXTERNAL_RUNTIME_PATH, - BuildParm.LOGGING, - BuildParm.LINT, - BuildParm.NO_COMPILE, - BuildParm.QUIET, - BuildParm.RTI, - BuildParm.RUNTIME_VERSION, - BuildParm.SCHEDULER, - BuildParm.THREADING, - BuildParm.WORKERS) - .map(param -> param.getKey()) - .collect(Collectors.toUnmodifiableSet()); - Properties props = new Properties(); - for (OptionSpec option : spec.options()) { - String optionName = option.longestName(); - // Check whether this option needs to be passed on to the code - // generator as a property. - if (passOnParams.contains(optionName)) { - String value = ""; - // Boolean or Integer option. - if (option.getValue() instanceof Boolean || - option.getValue() instanceof Integer) { - value = String.valueOf(option.getValue()); - // String option. - } else if (option.getValue() instanceof String) { - value = option.getValue(); - // Path option. - } else if (option.getValue() instanceof Path) { - value = option.getValue().toString(); - } - props.setProperty(optionName, value); - } + if (buildType != null) { + props.setProperty(BuildParm.BUILD_TYPE.getKey(), buildType); + } + if (clean) { + props.setProperty(BuildParm.CLEAN.getKey(), "true"); + } + if (externalRuntimePath != null) { + props.setProperty(BuildParm.EXTERNAL_RUNTIME_PATH.getKey(), externalRuntimePath.toString()); + } + if (lint) { + props.setProperty(BuildParm.LINT.getKey(), "true"); + } + if (logging != null) { + props.setProperty(BuildParm.LOGGING.getKey(), logging); + } + if (noCompile) { + props.setProperty(BuildParm.NO_COMPILE.getKey(), "true"); + } + if (targetCompiler != null) { + props.setProperty(BuildParm.TARGET_COMPILER.getKey(), targetCompiler); + } + if (quiet) { + props.setProperty(BuildParm.QUIET.getKey(), "true"); + } + if (rti != null) { + props.setProperty(BuildParm.RTI.getKey(), rti); + } + if (runtimeVersion != null) { + props.setProperty(BuildParm.RUNTIME_VERSION.getKey(), runtimeVersion); + } + if (scheduler != null) { + props.setProperty(BuildParm.SCHEDULER.getKey(), scheduler); + } + if (threading != null) { + props.setProperty(BuildParm.THREADING.getKey(), threading); + } + if (workers != null) { + props.setProperty(BuildParm.WORKERS.getKey(), workers.toString()); } + return props; } } diff --git a/org.lflang/src/org/lflang/cli/Lff.java b/org.lflang/src/org/lflang/cli/Lff.java index 1c93c39d8a..0eeeea6785 100644 --- a/org.lflang/src/org/lflang/cli/Lff.java +++ b/org.lflang/src/org/lflang/cli/Lff.java @@ -3,25 +3,17 @@ import java.io.IOException; import java.nio.file.FileAlreadyExistsException; import java.nio.file.FileVisitResult; -import java.nio.file.FileVisitor; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.SimpleFileVisitor; import java.nio.file.attribute.BasicFileAttributes; -import java.util.Arrays; import java.util.List; -import java.util.Properties; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import picocli.CommandLine; import picocli.CommandLine.Command; import picocli.CommandLine.Option; -import picocli.CommandLine.Parameters; import org.eclipse.emf.ecore.resource.Resource; import org.lflang.ast.FormattingUtils; -import org.lflang.LocalStrings; import org.lflang.util.FileUtil; /** @@ -67,10 +59,6 @@ public class Lff extends CliBase { description = "Print more details on files affected.") private boolean verbose = false; - public Lff() { - super("lff"); - } - /** * Main function of the formatter. * Caution: this will invoke System.exit. diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 95427b1175..0a9c2064d7 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -267,7 +267,6 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { // to validate, which happens in setResources(). setReactorsAndInstantiationGraph(context.getMode()); - GeneratorUtils.validate(context, context.getFileConfig(), instantiationGraph, errorReporter); List allResources = GeneratorUtils.getResources(reactors); resources.addAll(allResources.stream() // FIXME: This filter reproduces the behavior of the method it replaces. But why must it be so complicated? Why are we worried about weird corner cases like this? .filter(it -> !Objects.equal(it, context.getFileConfig().resource) || mainDef != null && it == mainDef.getReactorClass().eResource()) diff --git a/org.lflang/src/org/lflang/generator/GeneratorUtils.java b/org.lflang/src/org/lflang/generator/GeneratorUtils.java index f51439c390..ec6e167ef2 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorUtils.java +++ b/org.lflang/src/org/lflang/generator/GeneratorUtils.java @@ -156,9 +156,9 @@ public static void accommodatePhysicalActionsIfPresent( } for (Resource resource : resources) { for (Action action : findAll(resource, Action.class)) { - if (action.getOrigin() == ActionOrigin.PHYSICAL && + if (action.getOrigin() == ActionOrigin.PHYSICAL && // Check if the user has explicitly set keepalive to false - !targetConfig.setByUser.contains(TargetProperty.KEEPALIVE) && + !targetConfig.setByUser.contains(TargetProperty.KEEPALIVE) && !targetConfig.keepalive ) { // If not, set it to true @@ -214,70 +214,6 @@ public T next() { }; } - /** - * Validate the files containing reactors in the given - * {@code instantiationGraph}. If a file is imported by - * another file in the instantiation graph, propagate the - * resulting errors to the importing file. - * @param context The context providing the cancel - * indicator used by the validator. - * @param fileConfig The file system configuration. - * @param instantiationGraph A DAG containing all - * reactors of interest. - * @param errorReporter An error acceptor. - */ - public static void validate( - IGeneratorContext context, - FileConfig fileConfig, - InstantiationGraph instantiationGraph, - ErrorReporter errorReporter - ) { - // NOTE: This method was previously misnamed validateImports. - // It validates all files, including the main file that does the importing. - // Also, it is now the only invocation of validation during code generation, - // and yet it used to only report errors in the files doing the importing. - IResourceValidator validator = ((XtextResource) fileConfig.resource).getResourceServiceProvider() - .getResourceValidator(); - HashSet bad = new HashSet<>(); - HashSet visited = new HashSet<>(); - // The graph must be traversed in topological order so that errors will propagate through arbitrarily many - // levels. - for (Reactor reactor : instantiationGraph.nodesInTopologicalOrder()) { - Resource resource = reactor.eResource(); - if (visited.contains(resource)) continue; - visited.add(resource); - List issues = validator.validate(resource, CheckMode.ALL, context.getCancelIndicator()); - if ( - bad.contains(resource) || issues.size() > 0 - ) { - // Report the error on this resource. - Path path = null; - try { - path = FileUtil.toPath(resource); - } catch (IOException e) { - path = Paths.get("Unknown file"); // Not sure if this is what we want. - } - for (Issue issue : issues) { - errorReporter.reportError(path, issue.getLineNumber(), issue.getMessage()); - } - - // Report errors on resources that import this one. - for (Reactor downstreamReactor : instantiationGraph.getDownstreamAdjacentNodes(reactor)) { - for (Import importStatement : ((Model) downstreamReactor.eContainer()).getImports()) { - // FIXME: This will report the error on ALL import statements in - // file doing the importing, not just the one importing this resource. - // I have no idea how to determine which import statement is the right one. - errorReporter.reportError(importStatement, String.format( - "Unresolved compilation issues in '%s': " - + issues.toString(), importStatement.getImportURI() - )); - bad.add(downstreamReactor.eResource()); - } - } - } - } - } - /** * Return the resources that provide the given * reactors. diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 3e220e5ad6..f5e7187233 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -194,11 +194,6 @@ CodeBuilder generateCMakeCode( if (targetConfig.platformOptions.platform != Platform.AUTO) { cMakeCode.pr("set(CMAKE_SYSTEM_NAME "+targetConfig.platformOptions.platform.getcMakeName()+")"); } - - cMakeCode.pr("# Target definitions\n"); - targetConfig.compileDefinitions.forEach((key, value) -> cMakeCode.pr( - "add_compile_definitions("+key+"="+value+")\n" - )); cMakeCode.newLine(); if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { diff --git a/org.lflang/src/org/lflang/generator/cpp/CppRos2NodeGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppRos2NodeGenerator.kt index 064f6758f8..22e3c3045a 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppRos2NodeGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppRos2NodeGenerator.kt @@ -59,14 +59,13 @@ class CppRos2NodeGenerator( | : Node("$nodeName", node_options) { | unsigned workers = ${if (targetConfig.workers != 0) targetConfig.workers else "std::thread::hardware_concurrency()"}; | bool fast{${targetConfig.fastMode}}; - | bool keepalive{${targetConfig.keepalive}}; | reactor::Duration lf_timeout{${targetConfig.timeout?.toCppCode() ?: "reactor::Duration::max()"}}; | | // provide a globally accessible reference to this node | // FIXME: this is pretty hacky... | lf_node = this; | - | lf_env = std::make_unique(workers, keepalive, fast, lf_timeout); + | lf_env = std::make_unique(workers, fast, lf_timeout); | | // instantiate the main reactor | lf_main_reactor = std::make_unique<${main.name}> ("${main.name}", lf_env.get(), ${main.name}::Parameters{}); diff --git a/org.lflang/src/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt index 171b59c485..07cd3f8ba2 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt @@ -60,7 +60,6 @@ class CppStandaloneMainGenerator( | | unsigned workers = ${if (targetConfig.workers != 0) targetConfig.workers else "std::thread::hardware_concurrency()"}; | bool fast{${targetConfig.fastMode}}; - | bool keepalive{${targetConfig.keepalive}}; | reactor::Duration timeout = ${targetConfig.timeout?.toCppCode() ?: "reactor::Duration::max()"}; | | // the timeout variable needs to be tested beyond fitting the Duration-type @@ -69,7 +68,6 @@ class CppStandaloneMainGenerator( | .add_options() | ("w,workers", "the number of worker threads used by the scheduler", cxxopts::value(workers)->default_value(std::to_string(workers)), "'unsigned'") | ("o,timeout", "Time after which the execution is aborted.", cxxopts::value(timeout)->default_value(time_to_string(timeout)), "'FLOAT UNIT'") - | ("k,keepalive", "Continue execution even when there are no events to process.", cxxopts::value(keepalive)->default_value("${targetConfig.keepalive}")) | ("f,fast", "Allow logical time to run faster than physical time.", cxxopts::value(fast)->default_value("${targetConfig.fastMode}")) | ("help", "Print help"); | @@ -91,7 +89,7 @@ class CppStandaloneMainGenerator( | return parse_error ? -1 : 0; | } | - | reactor::Environment e{workers, keepalive, fast, timeout}; + | reactor::Environment e{workers, fast, timeout}; | | // instantiate the main reactor | ${generateMainReactorInstantiation()} diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index fa6d8b06fc..3f1fbef2fc 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -624,7 +624,7 @@ public void checkParameter(Parameter param) { Reactor reactor = (Reactor) container; if (reactor.isMain()) { // we need to check for the cli parameters that are always taken - List cliParams = List.of("t", "threads", "o", "timeout", "k", "keepalive", "f", "fast", "help"); + List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); if (cliParams.contains(param.getName())) { error("Parameter '" + param.getName() + "' is already in use as command line argument by Lingua Franca,", @@ -1031,11 +1031,12 @@ public void checkTargetProperties(KeyValuePairs targetProperties) { validateClockSyncTargetProperties(targetProperties); validateSchedulerTargetProperties(targetProperties); validateRos2TargetProperties(targetProperties); + validateKeepalive(targetProperties); } private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { List properties = targetProperties.getPairs().stream() - .filter(pair -> pair.getName() == property.description) + .filter(pair -> pair.getName().equals(property.description)) .toList(); assert (properties.size() <= 1); return properties.size() > 0 ? properties.get(0) : null; @@ -1126,10 +1127,18 @@ private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { } } + private void validateKeepalive(KeyValuePairs targetProperties) { + KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); + if (keepalive != null && target == Target.CPP) { + warning("The keepalive property is inferred automatically by the C++ " + + "runtime and the value given here is ignored", keepalive, Literals.KEY_VALUE_PAIR__NAME); + } + } + private void validateRos2TargetProperties(KeyValuePairs targetProperties) { KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); KeyValuePair ros2Dependencies = getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); - if (!ASTUtils.toBoolean(ros2.getValue()) && ros2Dependencies != null) { + if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { warning( "Ignoring ros2-dependencies as ros2 compilation is disabled", ros2Dependencies, diff --git a/test/Cpp/src/concurrent/AsyncCallback.lf b/test/Cpp/src/concurrent/AsyncCallback.lf index 29fedc41e8..984132f133 100644 --- a/test/Cpp/src/concurrent/AsyncCallback.lf +++ b/test/Cpp/src/concurrent/AsyncCallback.lf @@ -1,7 +1,6 @@ // Test asynchronous callbacks that trigger a physical action. target Cpp { timeout: 2 sec, - keepalive: true, cmake-include: "AsyncCallback.cmake" } diff --git a/test/Cpp/src/concurrent/AsyncCallback2.lf b/test/Cpp/src/concurrent/AsyncCallback2.lf index ea493a32cd..322413617b 100644 --- a/test/Cpp/src/concurrent/AsyncCallback2.lf +++ b/test/Cpp/src/concurrent/AsyncCallback2.lf @@ -1,7 +1,6 @@ // Test asynchronous callbacks that trigger a non-physical action. target Cpp { timeout: 2 sec, - keepalive: true, cmake-include: "AsyncCallback.cmake" } From 0b27dd08cdd6aeaa4d0269fd46a5ca1a50392025 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 13 Mar 2023 12:02:19 -0700 Subject: [PATCH 053/709] save before second pull --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/lib/cpp/reactor-cpp | 2 +- test/Cpp/src/properties/Keepalive.lf | 43 ---------------------------- 3 files changed, 2 insertions(+), 45 deletions(-) delete mode 100644 test/Cpp/src/properties/Keepalive.lf diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 8a8827fa77..82afe9b180 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 8a8827fa77dc935676fbc148ecd83fffd3feb151 +Subproject commit 82afe9b180b3537c03284ba7d9ae7073982c5993 diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index a37f0ade9e..e80cd36ce5 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit a37f0ade9ee0f97606528fd7ba67712495948373 +Subproject commit e80cd36ce5bd625a7b167e7dfd65d25f78b0dd01 diff --git a/test/Cpp/src/properties/Keepalive.lf b/test/Cpp/src/properties/Keepalive.lf deleted file mode 100644 index 1fe6c5e1bc..0000000000 --- a/test/Cpp/src/properties/Keepalive.lf +++ /dev/null @@ -1,43 +0,0 @@ -target Cpp { - keepalive: true, - cmake-include: "../concurrent/AsyncCallback.cmake" -} - -main reactor { - public preamble {= - #include - =} - - state thread: std::thread - - physical action a - state success: bool{false} - - reaction(startup) -> a {= - // start new thread - this->thread = std::thread([&] () { - // Simulate time passing before a callback occurs - std::this_thread::sleep_for(1s); - a.schedule(); - }); - =} - - reaction(a) {= - success = true; - environment()->sync_shutdown(); - =} - - reaction(shutdown) {= - if (success) { - std::cout << "SUCCESS!\n"; - } else { - std::cout << "ERROR: reaction was not invoked!\n"; - exit(1); - } - - // make sure to join the thread before shutting down - if(thread.joinable()) { - thread.join(); - } - =} -} From b7f2d008db2c76294bf29315a44cbbaf1d4d64c6 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 14 Mar 2023 14:51:29 +0100 Subject: [PATCH 054/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index e80cd36ce5..08310933bb 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit e80cd36ce5bd625a7b167e7dfd65d25f78b0dd01 +Subproject commit 08310933bbf03b3c2b678f7da2d0a69d73384353 From 945bffe3988259961659f3dffd2fe2621b74894c Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 15 Mar 2023 13:43:52 -0700 Subject: [PATCH 055/709] added error reporting for unthreaded w watchdog --- .../org/lflang/generator/c/CGenerator.java | 26 ++++++++++++++++--- .../generator/c/CReactionGenerator.java | 7 ++++- .../generator/c/CWatchdogGenerator.java | 7 ++--- 3 files changed, 30 insertions(+), 10 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index d34e58ebfc..2ef5074455 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -445,6 +445,20 @@ protected boolean isOSCompatible() { return true; } + /** Returns false if watchdogs exist and are + * unsupported in this context. + * Otherwise, return true. + */ + protected boolean isWatchdogCompatible() { + if (hasWatchdogs() && !targetConfig.threading) { + errorReporter.reportError( + "Watchdogs are not supported for unthreaded programs." + ); + return false; + } + return true; + } + /** * Generate C code from the Lingua Franca model contained by the * specified resource. This is the main entry point for code @@ -459,6 +473,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { super.doGenerate(resource, context); if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; if (!isOSCompatible()) return; // Incompatible OS and configuration + if (!isWatchdogCompatible()) return; // Perform set up that does not generate code setUpGeneralParameters(); @@ -822,9 +837,11 @@ private boolean hasDeadlines(List reactors) { return false; } - private boolean hasWatchdogs(Reactor reactor) { - if (ASTUtils.allWatchdogs(reactor) != null) { - return true; + private boolean hasWatchdogs() { + for (Reactor reactor : reactors) { + if (ASTUtils.allWatchdogs(reactor) != null) { + return true; + } } return false; } @@ -1432,7 +1449,6 @@ protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactio * a struct that contains parameters, state variables, inputs (triggering or not), * actions (triggering or produced), and outputs. * @param decl The reactor. - * @param federate The federate, or null if this is not * federated or not the main reactor and reactions should be * unconditionally generated. */ @@ -1508,6 +1524,7 @@ private void recordWatchdogs(ReactorInstance instance) { var foundOne = false; var temp = new CodeBuilder(); var reactorRef = CUtil.reactorRef(instance); + // temp.pr("#ifdef LF_THREADED"); for (WatchdogInstance watchdog : instance.watchdogs) { temp.pr(" _lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); @@ -1515,6 +1532,7 @@ private void recordWatchdogs(ReactorInstance instance) { watchdogCount += 1; foundOne = true; } + // temp.pr("#endif"); if (foundOne) { initializeTriggerObjects.pr(temp.toString()); } diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 6959d52937..152413f10c 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -683,7 +683,12 @@ public static String generateWatchdogVariablesInReaction( ) { Watchdog watchdog = (Watchdog) effect.getVariable(); String watchdogName = watchdog.getName(); - return "watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");"; + + return String.join("\n", List.of( + "#ifdef LF_THREADED", + " watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");", + "#endif" + )); } /** diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 8b536a9ef8..72892e8e6b 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -122,10 +122,6 @@ public static void generateWatchdogStruct( ) { var reactor = ASTUtils.toDefinition(decl); - // WATCHDOG QUESTION 1: I followed similar structure to - // `CReactionGenerator.generateReactionAndTriggerStructs` - // but am not sure why we need to check if watchdog exists in the - // current federate. for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { String watchdogName = watchdog.getName(); // Create pointer to the watchdog_t struct @@ -148,6 +144,7 @@ public static void generateWatchdogStruct( // Set values of watchdog_t struct in the reactor's constructor // WATCHDOG QUESTION 5: should I be defining these in the constructor of the reactor? //FIXME: update parameters + // constructorCode.pr("#ifdef LF_THREADED"); constructorCode.pr(watchdog, String.join("\n", "self->_lf_watchdog_"+watchdogName+".base = &(self->base);", "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", @@ -155,7 +152,7 @@ public static void generateWatchdogStruct( // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", "self->_lf_watchdog_"+watchdogName+".watchdog_function = &("+watchdogFunctionName+");" )); - + // constructorCode.pr("#endif"); // WATCHDOG QUESTION 6: should I be initializing mutex in this constructor? } From 07adeac12214c73c80265b57e08abf952346ab35 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 09:28:00 +0100 Subject: [PATCH 056/709] add simple enclave communication test --- test/Cpp/src/enclave/EnclaveCommunication.lf | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/test/Cpp/src/enclave/EnclaveCommunication.lf b/test/Cpp/src/enclave/EnclaveCommunication.lf index 00cd314e50..c8d0c50c1c 100644 --- a/test/Cpp/src/enclave/EnclaveCommunication.lf +++ b/test/Cpp/src/enclave/EnclaveCommunication.lf @@ -6,7 +6,7 @@ target Cpp { reactor Src { timer t(0, 100ms) output out: int - state counter: int(0); + state counter: int = 0 reaction(t) -> out {= out.set(counter++); =} @@ -14,8 +14,21 @@ reactor Src { reactor Sink { input in: int + state received: bool = false reaction(in) {= - reactor::log::Info() << "Received " << *in.get(); + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } =} } From 9aaa80e99b40014de1ffc6d137ae7528f2acc3e4 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 09:29:58 +0100 Subject: [PATCH 057/709] add test combining simple enclave communication with other events --- .../EnclaveCommunicationLocalEvents.lf | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf diff --git a/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf new file mode 100644 index 0000000000..b5b8f43a63 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf @@ -0,0 +1,46 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output out: int + state counter: int = 0 + reaction(t) -> out {= + out.set(counter++); + =} +} + +reactor Sink { + timer t(0, 50ms) + input in: int + state received: bool = false + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in +} \ No newline at end of file From 36fc3612202b71acd0a2e0b6fe5bbd33631bda61 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 10:05:38 +0100 Subject: [PATCH 058/709] updater reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 08310933bb..5e51fc684c 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 08310933bbf03b3c2b678f7da2d0a69d73384353 +Subproject commit 5e51fc684c6c4475b557b36a3d6118ea76ecba8e From 46db0528e40fc37053c6f6f4783584a5b2161f5f Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 10:06:05 +0100 Subject: [PATCH 059/709] code generation for delayed and physical enclave connections --- .../generator/cpp/CppConnectionGenerator.kt | 30 +++++++++++-------- 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt index 3ec27fc571..2379a4c08d 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt @@ -27,10 +27,15 @@ class CppConnectionGenerator(private val reactor: Reactor) { get() { val leftPort = leftPorts.first() return when { - isEnclaveConnection && !isPhysical && delay == null -> "reactor::EnclaveConnection<${leftPort.dataType}>" - isPhysical -> "reactor::PhysicalConnection<${leftPort.dataType}>" - delay != null -> "reactor::DelayedConnection<${leftPort.dataType}>" - else -> throw IllegalArgumentException("Unsupported connection type") + isEnclaveConnection -> when { + isPhysical -> "reactor::PhysicalEnclaveConnection<${leftPort.dataType}>" + delay != null -> "reactor::DelayedEnclaveConnection<${leftPort.dataType}>" + else -> "reactor::EnclaveConnection<${leftPort.dataType}>" + } + + isPhysical -> "reactor::PhysicalConnection<${leftPort.dataType}>" + delay != null -> "reactor::DelayedConnection<${leftPort.dataType}>" + else -> throw IllegalArgumentException("Unsupported connection type") } } @@ -72,13 +77,14 @@ class CppConnectionGenerator(private val reactor: Reactor) { } } else null - private fun generateConstructorInitializer(connection: Connection): String? = - if (connection.requiresConnectionClass && !connection.hasMultipleConnections) { - val name = connection.name - val delay = connection.delay?.toCppTime() - if (connection.isEnclaveConnection) - """, $name{"$name", ${connection.rightPorts[0].container.name}->__lf_env.get()}""" - else - """, $name{"$name", this, $delay}""" + private fun generateConstructorInitializer(connection: Connection): String? = with(connection) { + if (requiresConnectionClass && !hasMultipleConnections) { + when { + isEnclaveConnection && delay == null -> """, $name{"$name", ${rightPorts[0].container.name}->__lf_env.get()}""" + isEnclaveConnection && delay != null -> """, $name{"$name", ${rightPorts[0].container.name}->__lf_env.get(), ${delay.toCppTime()}}""" + else -> """, $name{"$name", this, ${delay.toCppTime()}}""" + } } else null + } + } From 06f36fd0f0e61fd1200c6efd0389155af377ffe9 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 10:07:06 +0100 Subject: [PATCH 060/709] add tests for physical and delayed enclave connections --- test/Cpp/src/enclave/EnclaveCommunication.lf | 1 + .../enclave/EnclaveCommunicationDelayed.lf | 43 +++++++++++++++++ .../EnclaveCommunicationDelayedLocalEvents.lf | 47 +++++++++++++++++++ .../EnclaveCommunicationLocalEvents.lf | 1 + .../enclave/EnclaveCommunicationPhysical.lf | 42 +++++++++++++++++ ...EnclaveCommunicationPhysicalLocalEvents.lf | 47 +++++++++++++++++++ 6 files changed, 181 insertions(+) create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf diff --git a/test/Cpp/src/enclave/EnclaveCommunication.lf b/test/Cpp/src/enclave/EnclaveCommunication.lf index c8d0c50c1c..81430ea4ac 100644 --- a/test/Cpp/src/enclave/EnclaveCommunication.lf +++ b/test/Cpp/src/enclave/EnclaveCommunication.lf @@ -22,6 +22,7 @@ reactor Sink { auto expected = 100ms * value; if (get_elapsed_logical_time() != expected) { reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); } =} reaction(shutdown) {= diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf new file mode 100644 index 0000000000..eee3ea979e --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf @@ -0,0 +1,43 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output out: int + state counter: int = 0 + reaction(t) -> out {= + out.set(counter++); + =} +} + +reactor Sink { + input in: int + state received: bool = false + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value + 50ms; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in after 50ms +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf new file mode 100644 index 0000000000..966608f390 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf @@ -0,0 +1,47 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output out: int + state counter: int = 0 + reaction(t) -> out {= + out.set(counter++); + =} +} + +reactor Sink { + timer t(0, 50ms) + input in: int + state received: bool = false + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value + 50ms; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in after 50ms +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf index b5b8f43a63..236f262303 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf @@ -23,6 +23,7 @@ reactor Sink { auto expected = 100ms * value; if (get_elapsed_logical_time() != expected) { reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); } =} reaction(shutdown) {= diff --git a/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf new file mode 100644 index 0000000000..4ba19a68cb --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf @@ -0,0 +1,42 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output out: int + state counter: int = 0 + reaction(t) -> out {= + out.set(counter++); + =} +} + +reactor Sink { + input in: int + state received: bool = false + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expecded value not before " << expected; + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out ~> sink.in +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf new file mode 100644 index 0000000000..00ba3dc720 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf @@ -0,0 +1,47 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output out: int + state counter: int = 0 + reaction(t) -> out {= + out.set(counter++); + =} +} + +reactor Sink { + timer t(0, 50ms) + input in: int + state received: bool = false + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expecded value not before " << expected; + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out ~> sink.in +} \ No newline at end of file From 3fb05f5fc07d91e3ce0e1ae81a84197b2a7654f7 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 12:09:07 +0100 Subject: [PATCH 061/709] first (incomplete) implementation of enclave multiport connections --- org.lflang/src/lib/cpp/lfutil.hh | 2 ++ .../cpp/CppAssembleMethodGenerator.kt | 21 ++++++++++++++++--- .../generator/cpp/CppConnectionGenerator.kt | 16 +++++++------- .../generator/cpp/CppReactorGenerator.kt | 2 +- 4 files changed, 30 insertions(+), 11 deletions(-) diff --git a/org.lflang/src/lib/cpp/lfutil.hh b/org.lflang/src/lib/cpp/lfutil.hh index e95a99f62b..4ed850e571 100644 --- a/org.lflang/src/lib/cpp/lfutil.hh +++ b/org.lflang/src/lib/cpp/lfutil.hh @@ -27,6 +27,8 @@ #include #include +#include + namespace lfutil { template diff --git a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt index 45f6f10b0a..9ef5aa10ef 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt @@ -26,8 +26,10 @@ package org.lflang.generator.cpp import org.lflang.* import org.lflang.generator.PrependOperator +import org.lflang.generator.cpp.CppConnectionGenerator.Companion.isEnclaveConnection import org.lflang.generator.cpp.CppConnectionGenerator.Companion.name import org.lflang.generator.cpp.CppConnectionGenerator.Companion.requiresConnectionClass +import org.lflang.generator.cpp.CppInstanceGenerator.Companion.isEnclave import org.lflang.generator.cpp.CppPortGenerator.Companion.dataType import org.lflang.lf.Action import org.lflang.lf.Connection @@ -86,7 +88,7 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { // is in a bank, but not a multiport """ |for (auto& __lf_instance : ${container.name}) { - ${" | "..generateCode("__lf_instance->${port.name}")} + ${" | "..generateCode("__lf_instance->${if(container.isEnclave) "__lf_instance->" else ""}${port.name}")} |} """.trimMargin() } else { @@ -182,7 +184,7 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { // Generate code which adds all left hand ports and all right hand ports to a vector each. If we are handling multiports // within a bank, then we normally iterate over all banks in an outer loop and over all ports in an inner loop. However, - // if the connection is a cross connection, than we change the order on the right side and iterate over ports before banks. + // if the connection is an interleaved connection, than we change the order on the right side and iterate over ports before banks. return with(PrependOperator) { if (!c.requiresConnectionClass) { """ @@ -193,7 +195,7 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} |lfutil::bind_multiple_ports(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated}); """.trimMargin() - } else { + } else if (!c.isEnclaveConnection) { """ |// connection $idx |std::vector<$portType> __lf_left_ports_$idx; @@ -211,6 +213,19 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} |lfutil::bind_multiple_connections_with_ports(__lf_connection_pointers_$idx, __lf_right_ports_$idx, ${c.isIterated}); """.trimMargin() + } else { + """ + |// connection $idx + |std::vector<$portType> __lf_left_ports_$idx; + ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }} + |std::vector<$portType> __lf_right_ports_$idx; + ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} + |for(size_t __lf_idx{0}; __lf_idx < std::min(__lf_right_ports_$idx.size(), __lf_left_ports_$idx.size()); __lf_idx++) { + | ${c.name}.emplace_back("${c.name}" + std::to_string(__lf_idx), __lf_right_ports_$idx[__lf_idx]->environment()${if(c.delay != null) ", ${c.delay.toCppTime()}" else ""}); + | ${c.name}.back().bind_upstream_port(__lf_left_ports_$idx[__lf_idx]); + | ${c.name}.back().bind_downstream_port(__lf_right_ports_$idx[__lf_idx]); + |} + """.trimMargin() } } } diff --git a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt index 2379a4c08d..897fe01202 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt @@ -69,13 +69,15 @@ class CppConnectionGenerator(private val reactor: Reactor) { reactor.connections.mapNotNull { generateConstructorInitializer(it) }.joinLn() private fun generateDecleration(connection: Connection): String? = - if (connection.requiresConnectionClass) { - if (connection.hasMultipleConnections) { - "std::vector<${connection.cppType}> ${connection.name};" - } else { - "${connection.cppType} ${connection.name};" - } - } else null + with(connection) { + if (requiresConnectionClass) { + when { + hasMultipleConnections && isEnclaveConnection -> "std::list<${connection.cppType}> ${connection.name};" + hasMultipleConnections && !isEnclaveConnection -> "std::vector<${connection.cppType}> ${connection.name};" + else -> "${connection.cppType} ${connection.name};" + } + } else null + } private fun generateConstructorInitializer(connection: Connection): String? = with(connection) { if (requiresConnectionClass && !hasMultipleConnections) { diff --git a/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt index 50fff0bdb5..78df4519f2 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt @@ -187,8 +187,8 @@ class CppReactorGenerator(private val reactor: Reactor, fileConfig: CppFileConfi ${" | "..instances.generateInitializers()} ${" | "..timers.generateInitializers()} ${" | "..actions.generateInitializers()} - ${" | "..connections.generateInitializers()} ${" | "..reactions.generateReactionViewInitializers()} + ${" | "..connections.generateInitializers()} |{ ${" | "..ports.generateConstructorInitializers()} ${" | "..instances.generateConstructorInitializers()} From d5f90f2918c6279b2d13e2c90d3d69d7c38771ee Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 12:10:12 +0100 Subject: [PATCH 062/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 5e51fc684c..07e74c307e 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 5e51fc684c6c4475b557b36a3d6118ea76ecba8e +Subproject commit 07e74c307ef4378846265c1490ac8144227c5a4d From 66129104069a06cf8a20626f89decc1eca1858f7 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 12:16:42 +0100 Subject: [PATCH 063/709] add various multiport tests --- .../EnclaveCommunicationMultiportToBank.lf | 55 +++++++++++++++++++ ...laveCommunicationMultiportToBankDelayed.lf | 55 +++++++++++++++++++ ...EnclaveCommunicationMultiportToBankEach.lf | 55 +++++++++++++++++++ ...CommunicationMultiportToBankEachDelayed.lf | 55 +++++++++++++++++++ ...ommunicationMultiportToBankEachPhysical.lf | 55 +++++++++++++++++++ ...aveCommunicationMultiportToBankPhysical.lf | 55 +++++++++++++++++++ .../enclave/EnclaveCommunicationPhysical.lf | 1 + 7 files changed, 331 insertions(+) create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf new file mode 100644 index 0000000000..d69d0042db --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf @@ -0,0 +1,55 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output[4] out: int + state counter: int = 0 + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} +} + +reactor Sink(bank_index: std::size_t = 0) { + timer t(0, 50ms) + input in: int + state received: bool = false + state iteration: int = 0 + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected; + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new[4] Sink() + + src.out -> sink.in +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf new file mode 100644 index 0000000000..86f7c07aa0 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf @@ -0,0 +1,55 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output[4] out: int + state counter: int = 0 + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} +} + +reactor Sink(bank_index: std::size_t = 0) { + timer t(0, 50ms) + input in: int + state received: bool = false + state iteration: int = 0 + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration + 50ms; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected; + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new[4] Sink() + + src.out -> sink.in after 50ms +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf new file mode 100644 index 0000000000..a67f25a384 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf @@ -0,0 +1,55 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output[4] out: int + state counter: int = 0 + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} +} + +reactor Sink(bank_index: std::size_t = 0) { + timer t(0, 50ms) + input in: int + state received: bool = false + state iteration: int = 0 + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected; + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave(each=true) + sink = new[4] Sink() + + src.out -> sink.in +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf new file mode 100644 index 0000000000..77569285f2 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf @@ -0,0 +1,55 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output[4] out: int + state counter: int = 0 + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} +} + +reactor Sink(bank_index: std::size_t = 0) { + timer t(0, 50ms) + input in: int + state received: bool = false + state iteration: int = 0 + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration + 50ms; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected; + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave(each=true) + sink = new[4] Sink() + + src.out -> sink.in after 50ms +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf new file mode 100644 index 0000000000..d0ab0218ad --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf @@ -0,0 +1,55 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output[4] out: int + state counter: int = 0 + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} +} + +reactor Sink(bank_index: std::size_t = 0) { + timer t(0, 50ms) + input in: int + state received: bool = false + state iteration: int = 0 + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected; + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave(each=true) + sink = new[4] Sink() + + src.out ~> sink.in +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf new file mode 100644 index 0000000000..9aa88eb248 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf @@ -0,0 +1,55 @@ +target Cpp { + timeout: 1s, + workers: 1 +} + +reactor Src { + timer t(0, 100ms) + output[4] out: int + state counter: int = 0 + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} +} + +reactor Sink(bank_index: std::size_t = 0) { + timer t(0, 50ms) + input in: int + state received: bool = false + state iteration: int = 0 + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected; + exit(1); + } + =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + reaction(t) {= + reactor::log::Info() << "Tick"; + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new[4] Sink() + + src.out ~> sink.in +} \ No newline at end of file diff --git a/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf index 4ba19a68cb..539a3c34b7 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf @@ -22,6 +22,7 @@ reactor Sink { auto expected = 100ms * value; if (get_elapsed_logical_time() < expected) { reactor::log::Error() << "Expecded value not before " << expected; + exit(1); } =} reaction(shutdown) {= From bd27e1f917a21d49778387c2c909be49d32a8190 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sat, 18 Mar 2023 12:17:46 +0100 Subject: [PATCH 064/709] formatting --- test/Cpp/src/enclave/EnclaveCommunication.lf | 13 ++++++----- .../enclave/EnclaveCommunicationDelayed.lf | 15 +++++++------ .../EnclaveCommunicationDelayedLocalEvents.lf | 22 +++++++++---------- .../EnclaveCommunicationLocalEvents.lf | 20 ++++++++--------- .../EnclaveCommunicationMultiportToBank.lf | 16 ++++++++------ ...laveCommunicationMultiportToBankDelayed.lf | 18 ++++++++------- ...EnclaveCommunicationMultiportToBankEach.lf | 18 ++++++++------- ...CommunicationMultiportToBankEachDelayed.lf | 20 +++++++++-------- ...ommunicationMultiportToBankEachPhysical.lf | 18 ++++++++------- ...aveCommunicationMultiportToBankPhysical.lf | 16 ++++++++------ .../enclave/EnclaveCommunicationPhysical.lf | 13 ++++++----- ...EnclaveCommunicationPhysicalLocalEvents.lf | 20 ++++++++--------- 12 files changed, 112 insertions(+), 97 deletions(-) diff --git a/test/Cpp/src/enclave/EnclaveCommunication.lf b/test/Cpp/src/enclave/EnclaveCommunication.lf index 81430ea4ac..b780dad109 100644 --- a/test/Cpp/src/enclave/EnclaveCommunication.lf +++ b/test/Cpp/src/enclave/EnclaveCommunication.lf @@ -1,20 +1,20 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output out: int state counter: int = 0 - reaction(t) -> out {= - out.set(counter++); - =} + + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { input in: int state received: bool = false + reaction(in) {= received = true; auto value = *in.get(); @@ -25,6 +25,7 @@ reactor Sink { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; @@ -40,4 +41,4 @@ main reactor { sink = new Sink() src.out -> sink.in -} \ No newline at end of file +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf index eee3ea979e..6bbab0a700 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf @@ -1,20 +1,20 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output out: int state counter: int = 0 - reaction(t) -> out {= - out.set(counter++); - =} + + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { input in: int state received: bool = false + reaction(in) {= received = true; auto value = *in.get(); @@ -25,6 +25,7 @@ reactor Sink { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; @@ -39,5 +40,5 @@ main reactor { @enclave sink = new Sink() - src.out -> sink.in after 50ms -} \ No newline at end of file + src.out -> sink.in after 50 ms +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf index 966608f390..fa9c7b25e4 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf @@ -1,21 +1,21 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output out: int state counter: int = 0 - reaction(t) -> out {= - out.set(counter++); - =} + + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false + reaction(in) {= received = true; auto value = *in.get(); @@ -26,15 +26,15 @@ reactor Sink { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @@ -43,5 +43,5 @@ main reactor { @enclave sink = new Sink() - src.out -> sink.in after 50ms -} \ No newline at end of file + src.out -> sink.in after 50 ms +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf index 236f262303..3a0edfd7e5 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf @@ -1,21 +1,21 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output out: int state counter: int = 0 - reaction(t) -> out {= - out.set(counter++); - =} + + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false + reaction(in) {= received = true; auto value = *in.get(); @@ -26,15 +26,15 @@ reactor Sink { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @@ -44,4 +44,4 @@ main reactor { sink = new Sink() src.out -> sink.in -} \ No newline at end of file +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf index d69d0042db..4a74085dbc 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf @@ -1,12 +1,13 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output[4] out: int state counter: int = 0 + reaction(t) -> out {= for (auto& port : out) { port.set(counter++); @@ -15,10 +16,11 @@ reactor Src { } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false state iteration: int = 0 + reaction(in) {= received = true; auto value = *in.get(); @@ -34,15 +36,15 @@ reactor Sink(bank_index: std::size_t = 0) { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @@ -52,4 +54,4 @@ main reactor { sink = new[4] Sink() src.out -> sink.in -} \ No newline at end of file +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf index 86f7c07aa0..682b812d4a 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf @@ -1,12 +1,13 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output[4] out: int state counter: int = 0 + reaction(t) -> out {= for (auto& port : out) { port.set(counter++); @@ -15,10 +16,11 @@ reactor Src { } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false state iteration: int = 0 + reaction(in) {= received = true; auto value = *in.get(); @@ -34,15 +36,15 @@ reactor Sink(bank_index: std::size_t = 0) { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @@ -51,5 +53,5 @@ main reactor { @enclave sink = new[4] Sink() - src.out -> sink.in after 50ms -} \ No newline at end of file + src.out -> sink.in after 50 ms +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf index a67f25a384..e926019572 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf @@ -1,12 +1,13 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output[4] out: int state counter: int = 0 + reaction(t) -> out {= for (auto& port : out) { port.set(counter++); @@ -15,10 +16,11 @@ reactor Src { } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false state iteration: int = 0 + reaction(in) {= received = true; auto value = *in.get(); @@ -34,22 +36,22 @@ reactor Sink(bank_index: std::size_t = 0) { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @enclave src = new Src() - @enclave(each=true) + @enclave(each = true) sink = new[4] Sink() src.out -> sink.in -} \ No newline at end of file +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf index 77569285f2..238edf7bfc 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf @@ -1,12 +1,13 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output[4] out: int state counter: int = 0 + reaction(t) -> out {= for (auto& port : out) { port.set(counter++); @@ -15,10 +16,11 @@ reactor Src { } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false state iteration: int = 0 + reaction(in) {= received = true; auto value = *in.get(); @@ -34,22 +36,22 @@ reactor Sink(bank_index: std::size_t = 0) { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @enclave src = new Src() - @enclave(each=true) + @enclave(each = true) sink = new[4] Sink() - src.out -> sink.in after 50ms -} \ No newline at end of file + src.out -> sink.in after 50 ms +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf index d0ab0218ad..15eb6faf68 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf @@ -1,12 +1,13 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output[4] out: int state counter: int = 0 + reaction(t) -> out {= for (auto& port : out) { port.set(counter++); @@ -15,10 +16,11 @@ reactor Src { } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false state iteration: int = 0 + reaction(in) {= received = true; auto value = *in.get(); @@ -34,22 +36,22 @@ reactor Sink(bank_index: std::size_t = 0) { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @enclave src = new Src() - @enclave(each=true) + @enclave(each = true) sink = new[4] Sink() src.out ~> sink.in -} \ No newline at end of file +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf index 9aa88eb248..3867a7a627 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf @@ -1,12 +1,13 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output[4] out: int state counter: int = 0 + reaction(t) -> out {= for (auto& port : out) { port.set(counter++); @@ -15,10 +16,11 @@ reactor Src { } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false state iteration: int = 0 + reaction(in) {= received = true; auto value = *in.get(); @@ -34,15 +36,15 @@ reactor Sink(bank_index: std::size_t = 0) { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @@ -52,4 +54,4 @@ main reactor { sink = new[4] Sink() src.out ~> sink.in -} \ No newline at end of file +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf index 539a3c34b7..ee3ab7f80b 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf @@ -1,20 +1,20 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output out: int state counter: int = 0 - reaction(t) -> out {= - out.set(counter++); - =} + + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { input in: int state received: bool = false + reaction(in) {= received = true; auto value = *in.get(); @@ -25,6 +25,7 @@ reactor Sink { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; @@ -40,4 +41,4 @@ main reactor { sink = new Sink() src.out ~> sink.in -} \ No newline at end of file +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf index 00ba3dc720..aa9c042502 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf @@ -1,21 +1,21 @@ target Cpp { - timeout: 1s, + timeout: 1 s, workers: 1 } reactor Src { - timer t(0, 100ms) + timer t(0, 100 ms) output out: int state counter: int = 0 - reaction(t) -> out {= - out.set(counter++); - =} + + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 50ms) + timer t(0, 50 ms) input in: int state received: bool = false + reaction(in) {= received = true; auto value = *in.get(); @@ -26,15 +26,15 @@ reactor Sink { exit(1); } =} + reaction(shutdown) {= if(!received) { reactor::log::Error() << "Nothing received."; exit(1); } =} - reaction(t) {= - reactor::log::Info() << "Tick"; - =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { @@ -44,4 +44,4 @@ main reactor { sink = new Sink() src.out ~> sink.in -} \ No newline at end of file +} From 8228827769fe9d84916e73c3271720b276c0bf08 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Sun, 19 Mar 2023 19:33:14 -0700 Subject: [PATCH 065/709] saving before checkout out klighd-workaround --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 +- org.lflang/src/org/lflang/generator/c/CReactionGenerator.java | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 2ef5074455..e7ce2439f8 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -473,7 +473,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { super.doGenerate(resource, context); if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; if (!isOSCompatible()) return; // Incompatible OS and configuration - if (!isWatchdogCompatible()) return; + // if (!isWatchdogCompatible()) return; // Perform set up that does not generate code setUpGeneralParameters(); diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 152413f10c..5af962c9d9 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -36,7 +36,6 @@ import org.lflang.lf.Variable; import org.lflang.lf.Watchdog; import org.lflang.util.StringUtil; -import org.lflang.lf.Watchdog; public class CReactionGenerator { protected static String DISABLE_REACTION_INITIALIZATION_MARKER From 2af0fa75dcbd61842f58e4bf330c47a67d624545 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Sun, 19 Mar 2023 19:33:38 -0700 Subject: [PATCH 066/709] saving before klighd workaround --- test/C/src/Watchdog.lf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index 0dd2436478..e3d7f6cb41 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -26,7 +26,7 @@ main reactor { reaction(a) -> w.x {= lf_set(w.x, 0); - lf_nanosleep(MSEC(40)); + lf_nanosleep(MSEC(90)); =} reaction(w.d) {= printf("Deadline reactor produced an output.\n"); =} From 9c114c347424ad0741c88c2487dae85299a30669 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 20 Mar 2023 09:29:03 +0100 Subject: [PATCH 067/709] fix NPE --- .../src/org/lflang/generator/cpp/CppPortGenerator.kt | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt index 79dd4ad93a..990ede56c6 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt @@ -47,10 +47,11 @@ class CppPortGenerator(private val reactor: Reactor) { val VarRef.dataType: String get() { val variableRef = when { - this == null -> "" - container.isBank && container.isEnclave -> "${container.name}[0]->__lf_instance->${variable.name}" - container.isBank && !container.isEnclave -> "${container.name}[0]->${variable.name}" - else -> this.name + this == null -> "" + container == null -> this.name + container.isBank && container.isEnclave -> "${container.name}[0]->__lf_instance->${variable.name}" + container.isBank && !container.isEnclave -> "${container.name}[0]->${variable.name}" + else -> this.name } val multiportRef = if (isMultiport) "$variableRef[0]" else variableRef return "std::remove_reference::type::value_type" From be2a4c9fcd6adf00ff28735b1d08d0411c95ab33 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 20 Mar 2023 13:12:54 -0700 Subject: [PATCH 068/709] some changes to code review --- org.lflang/src/org/lflang/generator/c/CReactionGenerator.java | 4 +--- org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java | 1 + 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 5af962c9d9..e7e43a903c 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -684,9 +684,7 @@ public static String generateWatchdogVariablesInReaction( String watchdogName = watchdog.getName(); return String.join("\n", List.of( - "#ifdef LF_THREADED", - " watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");", - "#endif" + "watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");" )); } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 72892e8e6b..344209c3b8 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -202,6 +202,7 @@ public static String generateLfInitializeWatchdogMutexes(int watchdogCount) { " self_base_t* current_base = _lf_watchdogs[i]->base;", " if (&(current_base->watchdog_mutex) == NULL) {", " lf_mutex_init(&(current_base->watchdog_mutex));", + " current_base->has_watchdog = true;", " }", " }" )); From 85a21efa41692e3d97a1d08b1d085a3d44051c1f Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 21 Mar 2023 10:05:51 +0100 Subject: [PATCH 069/709] disable keepalive warning in C++ --- org.lflang/src/org/lflang/Target.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/Target.java b/org.lflang/src/org/lflang/Target.java index c3bfda067a..59398963cd 100644 --- a/org.lflang/src/org/lflang/Target.java +++ b/org.lflang/src/org/lflang/Target.java @@ -527,7 +527,7 @@ public String getSingleLineCommentPrefix() { * program (and keepalive was not explicitly unset by the user). */ public boolean setsKeepAliveOptionAutomatically() { - return this != Rust; + return this != Rust && this != CPP; } /** From e17852da6683fe140480c6b2d2b416daf2719d22 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 21 Mar 2023 11:53:42 +0100 Subject: [PATCH 070/709] update reactor-cpp and add new tests --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- .../EnclaveSparseUpstreamEventsDelayed.lf | 52 +++++++++++++++++++ .../EnclaveSparseUpstreamEventsPhysical.lf | 52 +++++++++++++++++++ 3 files changed, 105 insertions(+), 1 deletion(-) create mode 100644 test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf create mode 100644 test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 07e74c307e..eecfdd22e7 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 07e74c307ef4378846265c1490ac8144227c5a4d +Subproject commit eecfdd22e71f1f6738403fd6c0bbdd6e137e54d4 diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf new file mode 100644 index 0000000000..341b91dfbe --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf @@ -0,0 +1,52 @@ +// The purpose of this test is to check that the downstream enclave respects the +// after delay when aquiring tags from its upstream. +target Cpp { + timeout: 10 s, + workers: 1 +} + +reactor Src { + timer t(0, 2 s) + output out: int + state counter: int = 0 + + reaction(t) -> out {= out.set(counter++); =} +} + +reactor Sink { + timer t(0, 100 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 2s + 2s * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(1 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in after 2 s +} diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf new file mode 100644 index 0000000000..f48445f369 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf @@ -0,0 +1,52 @@ +// The purpose of this test is to check that the downstream enclave advances +// time independenty of the upstraem if the connection is physical. +target Cpp { + timeout: 10 s, + workers: 1 +} + +reactor Src { + timer t(0, 2 s) + output out: int + state counter: int = 0 + + reaction(t) -> out {= out.set(counter++); =} +} + +reactor Sink { + timer t(0, 100 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 2s * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(1 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out ~> sink.in +} From 97632d816cfe0afca7917761166185d4d99a07f2 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 21 Mar 2023 14:18:48 +0100 Subject: [PATCH 071/709] update reactor-cpp and at tests covering sparse upstream events --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- .../enclave/EnclaveSparseUpstreamEvents.lf | 52 +++++++++++++ .../EnclaveSparseUpstreamEventsDelayed.lf | 2 +- .../EnclaveSparseUpstreamEventsPhysical.lf | 2 +- .../enclave/EnclaveUpstreamPhysicalAction.lf | 76 +++++++++++++++++++ 5 files changed, 131 insertions(+), 3 deletions(-) create mode 100644 test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf create mode 100644 test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index eecfdd22e7..b260ebc83c 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit eecfdd22e71f1f6738403fd6c0bbdd6e137e54d4 +Subproject commit b260ebc83cea97335e984d1eb26d6b581e900280 diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf new file mode 100644 index 0000000000..a65abc3533 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf @@ -0,0 +1,52 @@ +// The purpose of this test is to check that the downstream enclave can progress, even if there +// are only sparse upstream events. +target Cpp { + timeout: 6 s, + workers: 1 +} + +reactor Src { + timer t(0, 2 s) + output out: int + state counter: int = 0 + + reaction(t) -> out {= out.set(counter++); =} +} + +reactor Sink { + timer t(0, 100 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 2s * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(1 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in +} diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf index 341b91dfbe..e299f921ad 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf @@ -1,7 +1,7 @@ // The purpose of this test is to check that the downstream enclave respects the // after delay when aquiring tags from its upstream. target Cpp { - timeout: 10 s, + timeout: 6 s, workers: 1 } diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf index f48445f369..6e1e579bd0 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf @@ -1,7 +1,7 @@ // The purpose of this test is to check that the downstream enclave advances // time independenty of the upstraem if the connection is physical. target Cpp { - timeout: 10 s, + timeout: 6 s, workers: 1 } diff --git a/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf new file mode 100644 index 0000000000..2da36c03b6 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf @@ -0,0 +1,76 @@ +// The purpose of this test is to check that the downstream enclave can progress, even if there +// are only sparse upstream events. +target Cpp { + timeout: 10 s, + workers: 1 +} + +reactor Src { + public preamble {= + #include + =} + + state thread: std::thread{} + + physical action a: int + output out: int + + reaction(startup) -> a {= + // start new thread + this->thread = std::thread([&] () { + for (int i{0}; i < 3; i++) { + a.schedule(i); + std::this_thread::sleep_for(2s); + } + }); + =} + + reaction(a) -> out {= + out.set(a.get()); + =} + + reaction(shutdown) {= + // make sure to join the thread before shutting down + if(thread.joinable()) { + thread.join(); + } + =} +} + +reactor Sink { + timer t(0, 100 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 2s * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(1 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in +} From 364230e4ffcbebdf0efae18b0f12a9cd09b63c8f Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 20 Mar 2023 18:52:44 -0700 Subject: [PATCH 072/709] Start adding templates to C target. WIP. --- org.lflang/src/org/lflang/ASTUtils.java | 15 ++- .../org/lflang/generator/ReactorInstance.java | 7 ++ .../lflang/generator/c/CActionGenerator.java | 13 +-- .../org/lflang/generator/c/CGenerator.java | 105 +++++++----------- .../lflang/generator/c/CPortGenerator.java | 45 +++----- .../src/org/lflang/generator/c/CUtil.java | 10 +- .../generator/c/TypeParameterizedReactor.java | 41 +++++++ .../generator/python/PythonGenerator.java | 3 +- test/C/src/generics/Template.lf | 13 +++ 9 files changed, 145 insertions(+), 107 deletions(-) create mode 100644 org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java create mode 100644 test/C/src/generics/Template.lf diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 16f3182056..ed9daf5def 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -379,6 +379,15 @@ public static List allInstantiations(Reactor definition) { return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); } + public static List allChildInstances(Reactor definition, ErrorReporter reporter) { + return allInstantiations(definition).stream().map(it -> new ReactorInstance( + it, + null, + reporter, + 0 + )).collect(Collectors.toList()); + } + /** * Given a reactor class, return a list of all its methods, * which includes methods of base classes that it extends. @@ -448,9 +457,9 @@ public static List allModes(Reactor definition) { return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); } - public static List recursiveChildren(ReactorInstance r) { - List ret = new ArrayList<>(); - ret.add(r.reactorDefinition); + public static List recursiveChildren(ReactorInstance r) { + List ret = new ArrayList<>(); + ret.add(r); for (var child: r.children) { ret.addAll(recursiveChildren(child)); } diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index a45fb1d1fb..af295818b3 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -42,6 +42,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.ErrorReporter; import org.lflang.TimeValue; import org.lflang.generator.TriggerInstance.BuiltinTriggerVariable; +import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; import org.lflang.lf.BuiltinTrigger; import org.lflang.lf.BuiltinTriggerRef; @@ -59,10 +60,13 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.Timer; +import org.lflang.lf.Type; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.lf.WidthSpec; +import com.google.common.collect.ImmutableMap; + /** * Representation of a compile-time instance of a reactor. @@ -159,6 +163,8 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re /** Indicator that this reactor has itself as a parent, an error condition. */ public final boolean recursive; + public final TypeParameterizedReactor tpr; + ////////////////////////////////////////////////////// //// Public methods. @@ -770,6 +776,7 @@ private ReactorInstance( this.reporter = reporter; this.reactorDeclaration = definition.getReactorClass(); this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); + this.tpr = new TypeParameterizedReactor(definition); // check for recursive instantiation var currentParent = parent; diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index dee3576d03..e381ad9bae 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -91,19 +91,17 @@ public static String generateTokenInitializer( /** * Generate the declarations of actions in the self struct * - * @param reactor The reactor to generate declarations for - * @param decl The reactor's declaration * @param body The content of the self struct * @param constructorCode The constructor code of the reactor */ public static void generateDeclarations( - Reactor reactor, + TypeParameterizedReactor tpr, CodeBuilder body, CodeBuilder constructorCode ) { - for (Action action : ASTUtils.allActions(reactor)) { + for (Action action : ASTUtils.allActions(tpr.r())) { var actionName = action.getName(); - body.pr(action, CGenerator.variableStructType(action, reactor, false)+" _lf_"+actionName+";"); + body.pr(action, CGenerator.variableStructType(action, tpr, false)+" _lf_"+actionName+";"); // Initialize the trigger pointer in the action. constructorCode.pr(action, "self->_lf_"+actionName+".trigger = &self->_lf__"+actionName+";"); } @@ -113,7 +111,6 @@ public static void generateDeclarations( * Generate the struct type definitions for the action of the * reactor * - * @param decl The reactor declaration * @param action The action to generate the struct for * @param target The target of the code generation (C, CCpp or Python) * @param types The helper object for types related stuff @@ -121,7 +118,7 @@ public static void generateDeclarations( * @return The auxiliary struct for the port as a string */ public static String generateAuxiliaryStruct( - Reactor r, + TypeParameterizedReactor tpr, Action action, Target target, CTypes types, @@ -146,7 +143,7 @@ public static String generateAuxiliaryStruct( code.pr(valueDeclaration(action, target, types)); code.pr(federatedExtension.toString()); code.unindent(); - code.pr("} " + variableStructType(action, r, userFacing) + ";"); + code.pr("} " + variableStructType(action, tpr, userFacing) + ";"); return code.toString(); } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b45779b7a7..0b5602d9d9 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -43,6 +43,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.LinkedHashSet; import java.util.List; import java.util.Locale; +import java.util.Map; import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -96,6 +97,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; +import org.lflang.lf.Type; import org.lflang.lf.Variable; import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; @@ -523,6 +525,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { if (targetConfig.platformOptions.platform != Platform.ARDUINO) { var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; var sources = new HashSet<>(ASTUtils.recursiveChildren(main)).stream() + .map(ReactorInstance::getTypeParameterizedReactor) .map(CUtil::getName).map(it -> it + (CCppMode ? ".cpp" : ".c")) .collect(Collectors.toList()); sources.add(cFilename); @@ -912,9 +915,7 @@ public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { } /** - * Generate code for defining all reactors that belong to the federate, - * including all the child reactors down the hierarchy. Duplicate - * Duplicates are avoided. + * Generate code for defining all instantiated reactors. * * Imported reactors' original .lf file is * incorporated in the following manner: @@ -923,29 +924,12 @@ public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { * - If there are any preambles, add them to the preambles of the reactor. */ private void generateReactorDefinitions() throws IOException { - var generatedReactors = new LinkedHashSet(); + var generatedReactors = new LinkedHashSet(); if (this.main != null) { generateReactorChildren(this.main, generatedReactors); + generateReactorClass(this.main.getTypeParameterizedReactor()); } - - if (this.mainDef != null) { - generateReactorClass(ASTUtils.toDefinition(this.mainDef.getReactorClass())); - } - - if (mainDef == null) { - // Generate code for each reactor that was not instantiated in main or its children. - for (Reactor r : reactors) { - // Get the declarations for reactors that are instantiated somewhere. - // A declaration is either a reactor definition or an import statement.; - var declarations = this.instantiationGraph.getDeclarations(r); - // If the reactor has no instantiations and there is no main reactor, then - // generate code for it anyway (at a minimum, this means that the compiler is invoked - // so that reaction bodies are checked). - if (declarations.isEmpty()) { - generateReactorClass(r); - } - } - } + // do not generate code for reactors that are not instantiated } private void generateHeaders() throws IOException { @@ -975,15 +959,16 @@ private void generateHeaders() throws IOException { */ private void generateReactorChildren( ReactorInstance reactor, - LinkedHashSet generatedReactors + LinkedHashSet generatedReactors ) throws IOException { for (ReactorInstance r : reactor.children) { + var newTpr = r.tpr; if (r.reactorDeclaration != null && - !generatedReactors.contains(r.reactorDefinition)) { - generatedReactors.add(r.reactorDefinition); + !generatedReactors.contains(newTpr)) { + generatedReactors.add(newTpr); generateReactorChildren(r, generatedReactors); inspectReactorEResource(r.reactorDeclaration); - generateReactorClass(r.reactorDefinition); + generateReactorClass(newTpr); } } } @@ -1036,53 +1021,50 @@ protected void copyTargetFiles() throws IOException { * if the main reactor has reactions, these reactions * will not be generated if they are triggered by or send * data to contained reactors that are not in the federate. - * @param reactor The parsed reactor data structure. */ - private void generateReactorClass(Reactor reactor) throws IOException { + private void generateReactorClass(TypeParameterizedReactor tpr) throws IOException { // FIXME: Currently we're not reusing definitions for declarations that point to the same definition. CodeBuilder header = new CodeBuilder(); CodeBuilder src = new CodeBuilder(); - final String headerName = CUtil.getName(reactor) + ".h"; + final String headerName = CUtil.getName(tpr) + ".h"; var guardMacro = headerName.toUpperCase().replace(".", "_"); header.pr("#ifndef " + guardMacro); header.pr("#define " + guardMacro); - generateReactorClassHeaders(reactor, headerName, header, src); - header.pr(generateTopLevelPreambles(reactor)); - generateUserPreamblesForReactor(reactor, src); - generateReactorClassBody(reactor, header, src); + generateReactorClassHeaders(tpr, headerName, header, src); + header.pr(generateTopLevelPreambles(tpr.r())); + generateUserPreamblesForReactor(tpr.r(), src); + generateReactorClassBody(tpr, header, src); header.pr("#endif // " + guardMacro); FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); - var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" : (CCppMode ? ".cpp" : ".c"); - FileUtil.writeToFile(src.toString(), fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), true); + var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" + : (CCppMode ? ".cpp" : ".c"); + FileUtil.writeToFile(src.toString(), fileConfig.getSrcGenPath().resolve( + CUtil.getName(reactor) + extension), true); } - protected void generateReactorClassHeaders(Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { + protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String headerName, CodeBuilder header, CodeBuilder src) { if (CCppMode) { src.pr("extern \"C\" {"); header.pr("extern \"C\" {"); } + tpr.typeArgs().entrySet().forEach(it -> src.pr("#define " + it.getKey() + " " + ASTUtils.toText(it.getValue()))); header.pr("#include \"include/core/reactor.h\""); src.pr("#include \"include/api/api.h\""); src.pr("#include \"include/api/set.h\""); - generateIncludes(reactor); + generateIncludes(tpr.r()); if (CCppMode) { src.pr("}"); header.pr("}"); } - src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(fileConfig, reactor) + "\""); + src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(fileConfig, tpr.r()) + "\""); src.pr("#include \"" + headerName + "\""); - Stream.concat( - reactor.getInstantiations().stream(), - reactor.getModes().stream().flatMap(it -> it.getInstantiations().stream()) - ) - .collect(Collectors.toSet()).stream() - .map(Instantiation::getReactorClass) - .map(ASTUtils::toDefinition).map(CUtil::getName) + new HashSet<>(ASTUtils.allInstantiations(tpr.r())).stream() + .map(TypeParameterizedReactor::new).map(CUtil::getName) .map(name -> "#include \"" + name + ".h\"") .forEach(header::pr); } - private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeBuilder src) { + private void generateReactorClassBody(TypeParameterizedReactor tpr, CodeBuilder header, CodeBuilder src) { // Some of the following methods create lines of code that need to // go into the constructor. Collect those lines of code here: var constructorCode = new CodeBuilder(); @@ -1137,7 +1119,7 @@ protected void generateIncludes(Reactor r) { * Generate the struct type definitions for inputs, outputs, and * actions of the specified reactor. */ - protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { + protected void generateAuxiliaryStructs(CodeBuilder builder, TypeParameterizedReactor tpr, boolean userFacing) { // In the case where there are incoming // p2p logical connections in decentralized // federated execution, there will be an @@ -1155,9 +1137,9 @@ protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean #endif """.formatted(types.getTargetTagType(), types.getTargetTimeType()) ); - for (Port p : allPorts(r)) { + for (Port p : allPorts(tpr.r())) { builder.pr(CPortGenerator.generateAuxiliaryStruct( - r, + tpr, p, getTarget(), errorReporter, @@ -1169,9 +1151,9 @@ protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean // The very first item on this struct needs to be // a trigger_t* because the struct will be cast to (trigger_t*) // by the lf_schedule() functions to get to the trigger. - for (Action action : allActions(r)) { + for (Action action : allActions(tpr.r())) { builder.pr(CActionGenerator.generateAuxiliaryStruct( - r, + tpr, action, getTarget(), types, @@ -1184,20 +1166,19 @@ protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean /** * Generate the self struct type definition for the specified reactor * in the specified federate. - * @param decl The parsed reactor data structure. * @param constructorCode Place to put lines of code that need to * go into the constructor. */ - private void generateSelfStruct(CodeBuilder builder, ReactorDecl decl, CodeBuilder constructorCode) { - var reactor = toDefinition(decl); - var selfType = CUtil.selfType(ASTUtils.toDefinition(decl)); + private void generateSelfStruct(CodeBuilder builder, TypeParameterizedReactor tpr, CodeBuilder constructorCode) { + var reactor = toDefinition(tpr.r()); + var selfType = CUtil.selfType(tpr); // Construct the typedef for the "self" struct. // Create a type name for the self struct. var body = new CodeBuilder(); // Extensions can add functionality to the CGenerator - generateSelfStructExtension(body, decl, constructorCode); + generateSelfStructExtension(body, reactor, constructorCode); // Next handle parameters. body.pr(CParameterGenerator.generateDeclarations(reactor, types)); @@ -1206,10 +1187,10 @@ private void generateSelfStruct(CodeBuilder builder, ReactorDecl decl, CodeBuild body.pr(CStateGenerator.generateDeclarations(reactor, types)); // Next handle actions. - CActionGenerator.generateDeclarations(reactor, body, constructorCode); + CActionGenerator.generateDeclarations(tpr, body, constructorCode); // Next handle inputs and outputs. - CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); + CPortGenerator.generateDeclarations(tpr, reactor, body, constructorCode); // If there are contained reactors that either receive inputs // from reactions of this reactor or produce outputs that trigger @@ -1387,7 +1368,7 @@ private void generateInteractingContainedReactors( */ protected void generateSelfStructExtension( CodeBuilder body, - ReactorDecl decl, + Reactor reactor, CodeBuilder constructorCode ) { // Do nothing @@ -1666,8 +1647,8 @@ public void processProtoFile(String filename) { * This is required to be the same as the type name returned by * {@link #variableStructType(TriggerInstance)}. */ - public static String variableStructType(Variable variable, Reactor reactor, boolean userFacing) { - return (userFacing ? reactor.getName().toLowerCase() : CUtil.getName(reactor)) +"_"+variable.getName()+"_t"; + public static String variableStructType(Variable variable, TypeParameterizedReactor tpr, boolean userFacing) { + return (userFacing ? tpr.getName().toLowerCase() : CUtil.getName(tpr)) +"_"+variable.getName()+"_t"; } /** diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index cf6ea06b64..accda01fb1 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -11,6 +11,8 @@ import org.lflang.lf.Port; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; +import org.lflang.lf.Type; + import static org.lflang.generator.c.CGenerator.variableStructType; @@ -24,27 +26,21 @@ public class CPortGenerator { /** * Generate fields in the self struct for input and output ports - * - * @param reactor - * @param decl - * @param body - * @param constructorCode */ public static void generateDeclarations( - Reactor reactor, + TypeParameterizedReactor tpr, ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode ) { - generateInputDeclarations(reactor, decl, body, constructorCode); - generateOutputDeclarations(reactor, decl, body, constructorCode); + generateInputDeclarations(tpr, decl, body, constructorCode); + generateOutputDeclarations(tpr, decl, body, constructorCode); } /** * Generate the struct type definitions for the port of the * reactor * - * @param decl The reactor declaration * @param port The port to generate the struct * @param target The target of the code generation (C, CCpp or Python) * @param errorReporter The error reporter @@ -53,7 +49,7 @@ public static void generateDeclarations( * @return The auxiliary struct for the port as a string */ public static String generateAuxiliaryStruct( - Reactor decl, + TypeParameterizedReactor tpr, Port port, Target target, ErrorReporter errorReporter, @@ -80,7 +76,7 @@ public static String generateAuxiliaryStruct( code.pr(valueDeclaration(port, target, errorReporter, types)); code.pr(federatedExtension.toString()); code.unindent(); - code.pr("} "+variableStructType(port, decl, userFacing)+";"); + code.pr("} "+variableStructType(port, tpr, userFacing)+";"); return code.toString(); } @@ -201,31 +197,31 @@ private static String valueDeclaration( * */ private static void generateInputDeclarations( - Reactor reactor, + TypeParameterizedReactor tpr, ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode ) { - for (Input input : ASTUtils.allInputs(reactor)) { + for (Input input : ASTUtils.allInputs(tpr.r())) { var inputName = input.getName(); if (ASTUtils.isMultiport(input)) { body.pr(input, String.join("\n", "// Multiport input array will be malloc'd later.", - variableStructType(input, reactor, false)+"** _lf_"+inputName+";", + variableStructType(input, tpr, false)+"** _lf_"+inputName+";", "int _lf_"+inputName+"_width;", "// Default input (in case it does not get connected)", - variableStructType(input, reactor, false)+" _lf_default__"+inputName+";", + variableStructType(input, tpr, false)+" _lf_default__"+inputName+";", "// Struct to support efficiently reading sparse inputs.", "lf_sparse_io_record_t* _lf_"+inputName+"__sparse;" )); } else { // input is not a multiport. body.pr(input, String.join("\n", - variableStructType(input, reactor, false)+"* _lf_"+inputName+";", + variableStructType(input, tpr, false)+"* _lf_"+inputName+";", "// width of -2 indicates that it is not a multiport.", "int _lf_"+inputName+"_width;", "// Default input (in case it does not get connected)", - variableStructType(input, reactor, false)+" _lf_default__"+inputName+";" + variableStructType(input, tpr, false)+" _lf_default__"+inputName+";" )); constructorCode.pr(input, String.join("\n", @@ -238,26 +234,21 @@ private static void generateInputDeclarations( /** * Generate fields in the self struct for output ports - * - * @param reactor - * @param decl - * @param body - * @param constructorCode */ private static void generateOutputDeclarations( - Reactor reactor, + TypeParameterizedReactor tpr, ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode ) { - for (Output output : ASTUtils.allOutputs(reactor)) { + for (Output output : ASTUtils.allOutputs(tpr.r())) { // If the port is a multiport, create an array to be allocated // at instantiation. var outputName = output.getName(); if (ASTUtils.isMultiport(output)) { body.pr(output, String.join("\n", "// Array of output ports.", - variableStructType(output, reactor, false)+"* _lf_"+outputName+";", + variableStructType(output, tpr, false)+"* _lf_"+outputName+";", "int _lf_"+outputName+"_width;", "// An array of pointers to the individual ports. Useful", "// for the lf_set macros to work out-of-the-box for", @@ -265,11 +256,11 @@ private static void generateOutputDeclarations( "// value can be accessed via a -> operator (e.g.,foo[i]->value).", "// So we have to handle multiports specially here a construct that", "// array of pointers.", - variableStructType(output, reactor, false)+"** _lf_"+outputName+"_pointers;" + variableStructType(output, tpr, false)+"** _lf_"+outputName+"_pointers;" )); } else { body.pr(output, String.join("\n", - variableStructType(output, reactor, false)+" _lf_"+outputName+";", + variableStructType(output, tpr, false)+" _lf_"+outputName+";", "int _lf_"+outputName+"_width;" )); } diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 69e9ec30ae..b92f93023d 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -147,9 +147,9 @@ public static String channelIndexName(PortInstance port) { * reactor is main (to allow for instantiations that have the same name as * the main reactor or the .lf file). */ - public static String getName(Reactor reactor) { - String name = reactor.getName().toLowerCase() + reactor.hashCode(); - if (reactor.isMain()) { + public static String getName(TypeParameterizedReactor reactor) { + String name = reactor.r().getName().toLowerCase() + reactor.hashCode(); + if (reactor.r().isMain()) { return name + "_main"; } return name; @@ -516,8 +516,8 @@ public static String runtimeIndex(ReactorInstance reactor) { * @param reactor The reactor class. * @return The type of a self struct for the specified reactor class. */ - public static String selfType(Reactor reactor) { - if (reactor.isMain()) { + public static String selfType(TypeParameterizedReactor reactor) { + if (reactor.r().isMain()) { return "_" + CUtil.getName(reactor) + "_main_self_t"; } return "_" + CUtil.getName(reactor) + "_self_t"; diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java new file mode 100644 index 0000000000..9e79a65728 --- /dev/null +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -0,0 +1,41 @@ +package org.lflang.generator.c; + + +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; +import java.util.stream.Collectors; + +import org.lflang.ASTUtils; +import org.lflang.lf.Instantiation; +import org.lflang.lf.Reactor; +import org.lflang.lf.Type; + +import com.google.common.collect.ImmutableMap; + +public record TypeParameterizedReactor(Reactor r, Map typeArgs) { + + public TypeParameterizedReactor(Instantiation i) { + this(ASTUtils.toDefinition(i.getReactorClass()), addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()))); + } + + private static ImmutableMap addTypeArgs(Instantiation instantiation, Reactor r) { + HashMap ret = new HashMap<>(); + if (instantiation.getTypeArgs() != null) { + for (int i = 0; i < r.getTypeParms().size(); i++) { + ret.put(r.getTypeParms().get(i).getLiteral(), instantiation.getTypeArgs().get(i)); + } + } + return ImmutableMap.copyOf(ret); + } + + public String getName() { + // FIXME: Types that are not just a single token need to be escaped or hashed + return r.getName() + typeArgs.values().stream().map(ASTUtils::toText).collect(Collectors.joining("_")); + } + + @Override + public int hashCode() { + return r.hashCode() * 31 + typeArgs.hashCode(); + } +} diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 7a23b79b21..b20a5d9de2 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -544,10 +544,9 @@ protected void generateReactorInstanceExtension( @Override protected void generateSelfStructExtension( CodeBuilder selfStructBody, - ReactorDecl decl, + Reactor reactor, CodeBuilder constructorCode ) { - Reactor reactor = ASTUtils.toDefinition(decl); // Add the name field selfStructBody.pr("char *_lf_name;"); int reactionIndex = 0; diff --git a/test/C/src/generics/Template.lf b/test/C/src/generics/Template.lf new file mode 100644 index 0000000000..3d483098b9 --- /dev/null +++ b/test/C/src/generics/Template.lf @@ -0,0 +1,13 @@ +target C + +reactor Hello { + state count: T(0) + reaction(startup) {= + self->count = self->count + 1; + printf("Hello World %d\n", (int) self->count); + =} +} + +main reactor Template { + hello = new Hello(); +} From 4d8bf85169673094289ea34340e02ad0035c3d1b Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 24 Mar 2023 12:08:03 +0100 Subject: [PATCH 073/709] format tests --- .../src/enclave/EnclaveSparseUpstreamEvents.lf | 4 ++-- .../enclave/EnclaveUpstreamPhysicalAction.lf | 17 +++++++++-------- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf index a65abc3533..3bade0f63e 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf @@ -1,5 +1,5 @@ -// The purpose of this test is to check that the downstream enclave can progress, even if there -// are only sparse upstream events. +// The purpose of this test is to check that the downstream enclave can +// progress, even if there are only sparse upstream events. target Cpp { timeout: 6 s, workers: 1 diff --git a/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf index 2da36c03b6..18ac74b091 100644 --- a/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf +++ b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf @@ -1,5 +1,5 @@ -// The purpose of this test is to check that the downstream enclave can progress, even if there -// are only sparse upstream events. +// The purpose of this test is to check that the downstream enclave can +// progress, even if there are only sparse upstream events. target Cpp { timeout: 10 s, workers: 1 @@ -11,11 +11,11 @@ reactor Src { =} state thread: std::thread{} - + physical action a: int output out: int - reaction(startup) -> a {= + reaction(startup) -> a {= // start new thread this->thread = std::thread([&] () { for (int i{0}; i < 3; i++) { @@ -25,9 +25,7 @@ reactor Src { }); =} - reaction(a) -> out {= - out.set(a.get()); - =} + reaction(a) -> out {= out.set(a.get()); =} reaction(shutdown) {= // make sure to join the thread before shutting down @@ -60,7 +58,10 @@ reactor Sink { } =} - reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(1 s) {= + reaction(t) {= + reactor::log::Info() << "Tick - " << "logical time: " << get_elapsed_logical_time() + << "; physical time: " << get_elapsed_physical_time(); + =} deadline(1 s) {= reactor::log::Error() << "Deadline violated."; exit(2); =} From d87274fa43e9efd40636714e4599e5946df066b5 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 10:53:09 +0100 Subject: [PATCH 074/709] Align lingua-franca/watchdogs with reactor-c/watchdogs --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index ff3c84c36b..8ca094f356 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit ff3c84c36b2d7fbcbe09fafa577ec94f75194e83 +Subproject commit 8ca094f35616f0024534ff9a2d46e6c03440a8ef From aaa73689f641a3fd1ddf9b5a4ab45dc543aa27cc Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 11:05:24 +0100 Subject: [PATCH 075/709] Merged master in watchdogs --- .github/actions/setup-ros2/action.yml | 2 +- .github/workflows/ts-tests.yml | 2 +- gradle/source-layout.gradle | 20 +- lib/scripts/launch-fedsd.sh | 103 ++++++ org.lflang.tests/build.gradle | 6 +- .../tests/compiler/TargetConfigTests.java | 102 ++++++ org.lflang/build.gradle | 22 +- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/lib/ts/package.json | 2 +- org.lflang/src/org/lflang/TargetConfig.java | 90 ++++- org.lflang/src/org/lflang/TargetProperty.java | 5 +- .../src/org/lflang/ast/FormattingUtils.java | 4 +- .../federated/extensions/CExtension.java | 33 +- .../federated/extensions/CExtensionUtils.java | 14 +- .../extensions/FedTargetExtension.java | 14 +- .../extensions/FedTargetExtensionFactory.java | 4 +- .../federated/extensions/TSExtension.java | 47 ++- .../federated/generator/FedASTUtils.java | 18 +- .../federated/generator/FedEmitter.java | 11 +- .../federated/generator/FedFileConfig.java | 45 ++- .../federated/generator/FedGenerator.java | 267 +++++++-------- .../federated/generator/FedImportEmitter.java | 2 +- .../federated/generator/FedMainEmitter.java | 2 +- .../generator/FedPreambleEmitter.java | 7 +- .../generator/FedReactorEmitter.java | 2 +- .../federated/generator/FedTargetConfig.java | 78 +++++ .../federated/generator/FedTargetEmitter.java | 85 +---- .../federated/generator/FederateInstance.java | 17 +- .../federated/launcher/BuildConfig.java | 60 ++++ .../{FedCLauncher.java => CBuildConfig.java} | 57 +--- .../launcher/FedLauncherFactory.java | 64 ---- ...auncher.java => FedLauncherGenerator.java} | 130 ++++---- .../federated/launcher/FedPyLauncher.java | 83 ----- .../federated/launcher/PyBuildConfig.java | 22 ++ .../lflang/federated/launcher/RtiConfig.java | 92 +++++ ...{FedTSLauncher.java => TsBuildConfig.java} | 37 +-- .../org/lflang/generator/GeneratorUtils.java | 95 +----- .../src/org/lflang/generator/MainContext.java | 4 +- .../org/lflang/generator/ts/TSGenerator.kt | 6 +- org.lflang/src/org/lflang/util/Averager.java | 27 ++ .../SimpleFederatedAuthenticated.lf | 0 util/tracing/README.md | 6 + util/tracing/makefile | 2 + util/tracing/trace_to_chrome.c | 52 ++- util/tracing/trace_to_csv.c | 115 +++++-- util/tracing/trace_to_influxdb.c | 16 +- util/tracing/trace_util.c | 127 +++---- util/tracing/trace_util.h | 31 +- util/tracing/visualization/.gitignore | 1 + util/tracing/visualization/README.md | 25 ++ util/tracing/visualization/fedsd.py | 314 ++++++++++++++++++ util/tracing/visualization/fedsd_helper.py | 241 ++++++++++++++ 52 files changed, 1758 insertions(+), 855 deletions(-) create mode 100755 lib/scripts/launch-fedsd.sh create mode 100644 org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java create mode 100644 org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java create mode 100644 org.lflang/src/org/lflang/federated/launcher/BuildConfig.java rename org.lflang/src/org/lflang/federated/launcher/{FedCLauncher.java => CBuildConfig.java} (56%) delete mode 100644 org.lflang/src/org/lflang/federated/launcher/FedLauncherFactory.java rename org.lflang/src/org/lflang/federated/launcher/{FedLauncher.java => FedLauncherGenerator.java} (86%) delete mode 100644 org.lflang/src/org/lflang/federated/launcher/FedPyLauncher.java create mode 100644 org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java create mode 100644 org.lflang/src/org/lflang/federated/launcher/RtiConfig.java rename org.lflang/src/org/lflang/federated/launcher/{FedTSLauncher.java => TsBuildConfig.java} (68%) create mode 100644 org.lflang/src/org/lflang/util/Averager.java rename test/C/src/federated/{ => failing}/SimpleFederatedAuthenticated.lf (100%) create mode 100644 util/tracing/visualization/.gitignore create mode 100644 util/tracing/visualization/README.md create mode 100644 util/tracing/visualization/fedsd.py create mode 100644 util/tracing/visualization/fedsd_helper.py diff --git a/.github/actions/setup-ros2/action.yml b/.github/actions/setup-ros2/action.yml index ac2a0b0d15..54b77b841a 100644 --- a/.github/actions/setup-ros2/action.yml +++ b/.github/actions/setup-ros2/action.yml @@ -9,6 +9,6 @@ runs: # see https://github.com/ros-tooling/setup-ros/issues/80 and https://github.com/ros2/rmw_cyclonedds/pull/134 run: sed -e 's/azure.archive.ubuntu.com/us.archive.ubuntu.com/g' -e t -e d /etc/apt/sources.list | sudo tee /etc/apt/sources.list.d/nonazure.list - name: Setup ROS2 - uses: lhstrh/setup-ros@master + uses: ros-tooling/setup-ros@0.6.1 with: required-ros-distributions: rolling diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 24e40b7eef..83c04d8cf7 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -28,7 +28,7 @@ jobs: if: ${{ runner.os == 'macOS' }} - name: Perform TypeScript tests run: | - ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* + ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#master" - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: diff --git a/gradle/source-layout.gradle b/gradle/source-layout.gradle index 2aab84e0eb..9bbe4b3944 100644 --- a/gradle/source-layout.gradle +++ b/gradle/source-layout.gradle @@ -6,14 +6,8 @@ if (name.endsWith(".tests")) { resources.srcDirs = [] } test { - java { - srcDirs = ['src', 'src-gen'] - exclude "org/lflang/diagram/**" - } - kotlin { - srcDirs = ['src', 'src-gen'] - exclude "org/lflang/diagram/**" - } + java.srcDirs = ['src', 'src-gen'] + kotlin.srcDirs = ['src', 'src-gen'] resources.srcDirs = ['src', 'src-gen'] xtendOutputDir = 'xtend-gen' } @@ -21,14 +15,8 @@ if (name.endsWith(".tests")) { } else { sourceSets { main { - java { - srcDirs = ['src', 'src-gen'] - exclude "org/lflang/diagram/**" - } - kotlin { - srcDirs = ['src', 'src-gen'] - exclude "org/lflang/diagram/**" - } + java.srcDirs = ['src', 'src-gen'] + kotlin.srcDirs = ['src', 'src-gen'] xtendOutputDir = 'xtend-gen' resources { srcDirs = ['src', 'src-gen'] diff --git a/lib/scripts/launch-fedsd.sh b/lib/scripts/launch-fedsd.sh new file mode 100755 index 0000000000..e09c60fc1e --- /dev/null +++ b/lib/scripts/launch-fedsd.sh @@ -0,0 +1,103 @@ +#!/bin/bash + +#============================================================================ +# Description: Visualize federated trace data for RTI-federate interactions. +# Authors: Chadlia Jerad +# Edward A. Lee +# Usage: Usage: fedsd -r [rti.csv] -f [fed.csv ...] +#============================================================================ + +#============================================================================ +# Preamble +#============================================================================ + +# Copied from build.sh FIXME: How to avoid copying + +# Find the directory in which this script resides in a way that is compatible +# with MacOS, which has a `readlink` implementation that does not support the +# necessary `-f` flag to canonicalize by following every symlink in every +# component of the given name recursively. +# This solution, adapted from an example written by Geoff Nixon, is POSIX- +# compliant and robust to symbolic links. If a chain of more than 1000 links +# is encountered, we return. +find_dir() ( + start_dir=$PWD + cd "$(dirname "$1")" + link=$(readlink "$(basename "$1")") + count=0 + while [ "${link}" ]; do + if [[ "${count}" -lt 1000 ]]; then + cd "$(dirname "${link}")" + link=$(readlink "$(basename "$1")") + ((count++)) + else + return + fi + done + real_path="$PWD/$(basename "$1")" + cd "${start_dir}" + echo `dirname "${real_path}"` +) + +# Report fatal error and exit. +function fatal_error() { + 1>&2 echo -e "\e[1mfedsd: \e[31mfatal error: \e[0m$1" + exit 1 +} + +abs_path="$(find_dir "$0")" + +if [[ "${abs_path}" ]]; then + base=`dirname $(dirname ${abs_path})` +else + fatal_error "Unable to determine absolute path to $0." +fi + +# Get the lft files +lft_files_list=$@ + +if [ -z "$lft_files_list" ] +then + echo "Usage: fedsd [lft files]" + exit 1 +fi + +# Initialize variables +csv_files_list='' +extension='.csv' +rti_csv_file='' + +# Iterate over the lft file list to: +# - First, transform into csv +# - Second, construct the csv fiel name +# - Then construct the csv file list +# The csv file list does include the rti, it is put in a separate variable +for each_lft_file in $lft_files_list + do + # Tranform to csv + trace_to_csv $each_lft_file + # Get the file name + csv=${each_lft_file%.*} + if [ $csv == 'rti' ] + then + # Set the rti csv file + rti_csv_file='rti.csv' + else + # Construct the csv file name and add it to the list + csv_files_list="$csv$extension $csv_files_list" + fi + done + +# echo $lft_files_list +# echo $rti_csv_file +# echo $csv_files_list + +# FIXME: Check that python3 is in the path. +if [ $rti_csv_file == '' ] +then + # FIXME: Support the case where no rti file is given + python3 "${base}/util/tracing/visualization/fedsd.py" "-f" $csv_files_list +else + echo Building the communication diagram for the following trace files: $lft_files_list in trace_svg.html + python3 "${base}/util/tracing/visualization/fedsd.py" "-r" "$rti_csv_file" "-f" $csv_files_list +fi diff --git a/org.lflang.tests/build.gradle b/org.lflang.tests/build.gradle index bdb279d61d..020a3a8395 100644 --- a/org.lflang.tests/build.gradle +++ b/org.lflang.tests/build.gradle @@ -1,9 +1,9 @@ repositories { mavenCentral() // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. - //maven { - // url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - //} + maven { + url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + } } dependencies { implementation project(':org.lflang') diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java new file mode 100644 index 0000000000..593e302d25 --- /dev/null +++ b/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java @@ -0,0 +1,102 @@ +package org.lflang.tests.compiler; + +import com.google.inject.Inject; +import com.google.inject.Provider; +import java.nio.file.Files; +import org.eclipse.emf.common.util.URI; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.xtext.generator.JavaIoFileSystemAccess; +import org.eclipse.xtext.testing.InjectWith; +import org.eclipse.xtext.testing.extensions.InjectionExtension; +import org.eclipse.xtext.testing.util.ParseHelper; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; + +import org.lflang.federated.generator.FedFileConfig; +import org.lflang.generator.GeneratorUtils; +import org.lflang.generator.LFGenerator; +import org.lflang.generator.LFGeneratorContext.Mode; +import org.lflang.generator.MainContext; +import org.lflang.lf.Model; +import org.lflang.tests.LFInjectorProvider; + +@ExtendWith(InjectionExtension.class) +@InjectWith(LFInjectorProvider.class) + +/** + * Tests for checking that target properties adequately translate into the target configuration. + */ +class TargetConfigTests { + + @Inject + ParseHelper parser; + + @Inject + LFGenerator generator; + + @Inject + JavaIoFileSystemAccess fileAccess; + + @Inject + Provider resourceSetProvider; + + private void assertHasTargetProperty(Model model, String name) { + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.getTarget().getConfig().getPairs().stream().anyMatch( + p -> p.getName().equals(name) + ) + ); + } + + /** + * Check that tracing target property affects the target configuration. + * @throws Exception + */ + @Test + public void testParsing() throws Exception { + assertHasTargetProperty(parser.parse(""" + target C { + tracing: true + } + """), "tracing"); + } + + /** + * Check that when a federation has the "tracing" target property set, the generated federates + * will also have it set. + * @throws Exception + */ + @Test + public void testFederation() throws Exception { + fileAccess.setOutputPath("src-gen"); + + Model federation = parser.parse(""" + target C { + tracing: true + } + reactor Foo { + + } + federated reactor { + a = new Foo() + b = new Foo() + } + """, URI.createFileURI("tmp/src/Federation.lf"), resourceSetProvider.get()); + assertHasTargetProperty(federation, "tracing"); + + var resource = federation.eResource(); + var context = new MainContext(Mode.STANDALONE, resource, fileAccess, () -> false); + + if (GeneratorUtils.isHostWindows()) return; + + generator.doGenerate(resource, fileAccess, context); + + String lfSrc = Files.readAllLines( + ((FedFileConfig)context.getFileConfig()).getSrcPath().resolve("a.lf") + ).stream().reduce("\n", String::concat); + Model federate = parser.parse(lfSrc); + assertHasTargetProperty(federate, "tracing"); + } +} diff --git a/org.lflang/build.gradle b/org.lflang/build.gradle index 5de780bb07..9c6b9bf5d9 100644 --- a/org.lflang/build.gradle +++ b/org.lflang/build.gradle @@ -3,9 +3,9 @@ import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar repositories { mavenCentral() // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. - //maven { - // url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - //} + maven { + url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + } } dependencies { implementation "org.eclipse.xtext:org.eclipse.xtext:${xtextVersion}" @@ -20,14 +20,14 @@ dependencies { implementation group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.12.4' implementation group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: '2.12.4' implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.12.4' - //implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:${klighdVersion}") { - // exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' - // exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' - //} - //implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.standalone:${klighdVersion}") { - // exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' - // exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' - //} + implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:${klighdVersion}") { + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' + } + implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.standalone:${klighdVersion}") { + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' + } } configurations { diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 8ca094f356..10c275b99a 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 8ca094f35616f0024534ff9a2d46e6c03440a8ef +Subproject commit 10c275b99a01802f00168b92d4e9068fdf9b34b6 diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index 3c368c9481..a1d65a6403 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -2,7 +2,7 @@ "name": "LinguaFrancaDefault", "type": "commonjs", "dependencies": { - "@lf-lang/reactor-ts": "0.3.2", + "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#master", "@babel/cli": "^7.8.4", "@babel/core": "^7.8.7", "@babel/node": "^7.8.7", diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 446460d5c1..23e99541da 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -30,6 +30,7 @@ import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.Properties; import java.util.Set; import org.lflang.TargetProperty.BuildType; @@ -38,7 +39,9 @@ import org.lflang.TargetProperty.LogLevel; import org.lflang.TargetProperty.Platform; import org.lflang.TargetProperty.SchedulerOption; +import org.lflang.TargetProperty.UnionType; import org.lflang.generator.rust.RustTargetConfig; +import org.lflang.lf.KeyValuePair; import org.lflang.lf.TargetDecl; /** @@ -50,12 +53,92 @@ */ public class TargetConfig { + /** + * The target of this configuration (e.g., C, TypeScript, Python). + */ public final Target target; - public TargetConfig(TargetDecl target) { + /** + * Create a new target configuration based on the given target declaration AST node only. + * @param target AST node of a target declaration. + */ + public TargetConfig(TargetDecl target) { // FIXME: eliminate this constructor if we can this.target = Target.fromDecl(target); } + /** + * Create a new target configuration based on the given commandline arguments and target + * declaration AST node. + * @param cliArgs Arguments passed on the commandline. + * @param target AST node of a target declaration. + * @param errorReporter An error reporter to report problems. + */ + public TargetConfig( + Properties cliArgs, + TargetDecl target, + ErrorReporter errorReporter + ) { + this(target); + if (target.getConfig() != null) { + List pairs = target.getConfig().getPairs(); + TargetProperty.set(this, pairs != null ? pairs : List.of(), errorReporter); + } + if (cliArgs.containsKey("no-compile")) { + this.noCompile = true; + } + if (cliArgs.containsKey("docker")) { + var arg = cliArgs.getProperty("docker"); + if (Boolean.parseBoolean(arg)) { + this.dockerOptions = new DockerOptions(); + } else { + this.dockerOptions = null; + } + // FIXME: this is pretty ad-hoc and does not account for more complex overrides yet. + } + if (cliArgs.containsKey("build-type")) { + this.cmakeBuildType = (BuildType) UnionType.BUILD_TYPE_UNION.forName(cliArgs.getProperty("build-type")); + } + if (cliArgs.containsKey("logging")) { + this.logLevel = LogLevel.valueOf(cliArgs.getProperty("logging").toUpperCase()); + } + if (cliArgs.containsKey("workers")) { + this.workers = Integer.parseInt(cliArgs.getProperty("workers")); + } + if (cliArgs.containsKey("threading")) { + this.threading = Boolean.parseBoolean(cliArgs.getProperty("threading")); + } + if (cliArgs.containsKey("target-compiler")) { + this.compiler = cliArgs.getProperty("target-compiler"); + } + if (cliArgs.containsKey("tracing")) { + this.tracing = new TracingOptions(); + } + if (cliArgs.containsKey("scheduler")) { + this.schedulerType = SchedulerOption.valueOf( + cliArgs.getProperty("scheduler") + ); + this.setByUser.add(TargetProperty.SCHEDULER); + } + if (cliArgs.containsKey("target-flags")) { + this.compilerFlags.clear(); + if (!cliArgs.getProperty("target-flags").isEmpty()) { + this.compilerFlags.addAll(List.of( + cliArgs.getProperty("target-flags").split(" ") + )); + } + } + if (cliArgs.containsKey("runtime-version")) { + this.runtimeVersion = cliArgs.getProperty("runtime-version"); + } + if (cliArgs.containsKey("external-runtime-path")) { + this.externalRuntimePath = cliArgs.getProperty("external-runtime-path"); + } + if (cliArgs.containsKey(TargetProperty.KEEPALIVE.description)) { + this.keepalive = Boolean.parseBoolean( + cliArgs.getProperty(TargetProperty.KEEPALIVE.description)); + } + } + /** * Keep track of every target property that is explicitly set by the user. */ @@ -197,9 +280,6 @@ public TargetConfig(TargetDecl target) { * * This is now a wrapped class to account for overloaded definitions * of defining platform (either a string or dictionary of values) - * - * @author Samuel Berkun - * @author Anirudh Rengarajan */ public PlatformOptions platformOptions = new PlatformOptions(); @@ -293,7 +373,7 @@ public static class ClockSyncOptions { public int attenuation = 10; /** - * Whether or not to collect statistics while performing clock synchronization. + * Whether to collect statistics while performing clock synchronization. * This setting is only considered when clock synchronization has been activated. * The default is true. */ diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index f0de831bf4..3f38360d67 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -580,8 +580,7 @@ public enum TargetProperty { }), /** - * Directive to generate a Dockerfile. This is either a boolean, - * true or false, or a dictionary of options. + * Directive to enable tracing. */ TRACING("tracing", UnionType.TRACING_UNION, Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Python), @@ -974,7 +973,7 @@ public static TargetDecl extractTargetDecl(Target target, TargetConfig config) { * @param config The configuration object to update. * @param properties AST node that holds all the target properties. */ - public static void update(TargetConfig config, List properties,ErrorReporter err) { + public static void update(TargetConfig config, List properties, ErrorReporter err) { properties.forEach(property -> { TargetProperty p = forName(property.getName()); if (p != null) { diff --git a/org.lflang/src/org/lflang/ast/FormattingUtils.java b/org.lflang/src/org/lflang/ast/FormattingUtils.java index bd9fbaf3d8..0e148f218b 100644 --- a/org.lflang/src/org/lflang/ast/FormattingUtils.java +++ b/org.lflang/src/org/lflang/ast/FormattingUtils.java @@ -55,8 +55,8 @@ public static String render(EObject object, int lineLength) { } /** Return a function that renders AST nodes for the given target. */ - public static Function renderer(TargetDecl targetDecl) { - return object -> render(object, DEFAULT_LINE_LENGTH, Target.fromDecl(targetDecl), true); + public static Function renderer(Target target) { + return object -> render(object, DEFAULT_LINE_LENGTH, target, true); } /** diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index d9ed222920..fda727d735 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -45,6 +45,7 @@ import org.lflang.federated.generator.FedConnectionInstance; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; +import org.lflang.federated.launcher.RtiConfig; import org.lflang.federated.serialization.FedROS2CPPSerialization; import org.lflang.generator.CodeBuilder; import org.lflang.generator.GeneratorBase; @@ -83,18 +84,10 @@ public void initializeTargetConfig( int numOfFederates, FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter, - LinkedHashMap federationRTIProperties + RtiConfig rtiConfig ) throws IOException { - if(GeneratorUtils.isHostWindows()) { - errorReporter.reportError( - "Federated LF programs with a C target are currently not supported on Windows. " + - "Exiting code generation." - ); - // Return to avoid compiler errors - return; - } - CExtensionUtils.handleCompileDefinitions(federate, numOfFederates, federationRTIProperties); + CExtensionUtils.handleCompileDefinitions(federate, numOfFederates, rtiConfig); generateCMakeInclude(federate, fileConfig); @@ -488,11 +481,11 @@ public String getNetworkBufferType() { public String generatePreamble( FederateInstance federate, FedFileConfig fileConfig, - LinkedHashMap federationRTIProperties, + RtiConfig rtiConfig, ErrorReporter errorReporter ) throws IOException { // Put the C preamble in a `include/_federate.name + _preamble.h` file - String cPreamble = makePreamble(federate, fileConfig, federationRTIProperties, errorReporter); + String cPreamble = makePreamble(federate, fileConfig, rtiConfig, errorReporter); String relPath = "include" + File.separator + "_" + federate.name + "_preamble.h"; Path fedPreamblePath = fileConfig.getSrcPath().resolve(relPath); Files.createDirectories(fedPreamblePath.getParent()); @@ -509,7 +502,7 @@ public String generatePreamble( protected String makePreamble( FederateInstance federate, FedFileConfig fileConfig, - LinkedHashMap federationRTIProperties, + RtiConfig rtiConfig, ErrorReporter errorReporter) { var code = new CodeBuilder(); @@ -532,7 +525,7 @@ protected String makePreamble( code.pr(generateSerializationPreamble(federate, fileConfig)); - code.pr(generateExecutablePreamble(federate, federationRTIProperties, errorReporter)); + code.pr(generateExecutablePreamble(federate, rtiConfig, errorReporter)); code.pr(generateInitializeTriggers(federate, errorReporter)); @@ -582,12 +575,12 @@ private String generateInitializeTriggers(FederateInstance federate, ErrorReport * Generate code for an executed preamble. * */ - private String generateExecutablePreamble(FederateInstance federate, LinkedHashMap federationRTIProperties, ErrorReporter errorReporter) { + private String generateExecutablePreamble(FederateInstance federate, RtiConfig rtiConfig, ErrorReporter errorReporter) { CodeBuilder code = new CodeBuilder(); code.pr(generateCodeForPhysicalActions(federate, errorReporter)); - code.pr(generateCodeToInitializeFederate(federate, federationRTIProperties)); + code.pr(generateCodeToInitializeFederate(federate, rtiConfig)); code.pr(CExtensionUtils.allocateTriggersForFederate(federate)); @@ -600,10 +593,10 @@ void _lf_executable_preamble() { /** * Generate code to initialize the {@code federate}. - * @param federationRTIProperties Properties related to the RTI. + * @param rtiConfig * @return The generated code */ - private String generateCodeToInitializeFederate(FederateInstance federate, LinkedHashMap federationRTIProperties) { + private String generateCodeToInitializeFederate(FederateInstance federate, RtiConfig rtiConfig) { CodeBuilder code = new CodeBuilder(); code.pr("// ***** Start initializing the federated execution. */"); code.pr(String.join("\n", @@ -672,12 +665,12 @@ private String generateCodeToInitializeFederate(FederateInstance federate, Linke code.pr(String.join("\n", "// Connect to the RTI. This sets _fed.socket_TCP_RTI and _lf_rti_socket_UDP.", - "connect_to_rti("+addDoubleQuotes(federationRTIProperties.get("host").toString())+", "+ federationRTIProperties.get("port")+");" + "connect_to_rti("+addDoubleQuotes(rtiConfig.getHost())+", "+ rtiConfig.getPort()+");" )); // Disable clock synchronization for the federate if it resides on the same host as the RTI, // unless that is overridden with the clock-sync-options target property. - if (CExtensionUtils.clockSyncIsOn(federate, federationRTIProperties)) { + if (CExtensionUtils.clockSyncIsOn(federate, rtiConfig)) { code.pr("synchronize_initial_physical_clock_with_rti(_fed.socket_TCP_RTI);"); } diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index a24bcbae58..aabc77ecd5 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -4,7 +4,6 @@ import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; -import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.regex.Pattern; @@ -17,6 +16,7 @@ import org.lflang.TimeValue; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; +import org.lflang.federated.launcher.RtiConfig; import org.lflang.federated.serialization.FedROS2CPPSerialization; import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.generator.CodeBuilder; @@ -239,7 +239,7 @@ static boolean isSharedPtrType(InferredType type, CTypes types) { public static void handleCompileDefinitions( FederateInstance federate, int numOfFederates, - LinkedHashMap federationRTIProperties + RtiConfig rtiConfig ) { federate.targetConfig.setByUser.add(TargetProperty.COMPILE_DEFINITIONS); federate.targetConfig.compileDefinitions.put("FEDERATED", ""); @@ -250,7 +250,7 @@ public static void handleCompileDefinitions( handleAdvanceMessageInterval(federate); - initializeClockSynchronization(federate, federationRTIProperties); + initializeClockSynchronization(federate, rtiConfig); } /** @@ -276,9 +276,9 @@ private static void handleAdvanceMessageInterval(FederateInstance federate) { } } - static boolean clockSyncIsOn(FederateInstance federate, LinkedHashMap federationRTIProperties) { + static boolean clockSyncIsOn(FederateInstance federate, RtiConfig rtiConfig) { return federate.targetConfig.clockSync != ClockSyncMode.OFF - && (!federationRTIProperties.get("host").toString().equals(federate.host) + && (!rtiConfig.getHost().equals(federate.host) || federate.targetConfig.clockSyncOptions.localFederatesOn); } @@ -290,10 +290,10 @@ static boolean clockSyncIsOn(FederateInstance federate, LinkedHashMap federationRTIProperties + RtiConfig rtiConfig ) { // Check if clock synchronization should be enabled for this federate in the first place - if (clockSyncIsOn(federate, federationRTIProperties)) { + if (clockSyncIsOn(federate, rtiConfig)) { System.out.println("Initial clock synchronization is enabled for federate " + federate.id ); diff --git a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java index 7fb42bf007..7aa13d6cfc 100644 --- a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java @@ -1,21 +1,15 @@ package org.lflang.federated.extensions; import java.io.IOException; -import java.util.ArrayList; -import java.util.LinkedHashMap; -import java.util.List; import org.lflang.ErrorReporter; -import org.lflang.FileConfig; import org.lflang.InferredType; -import org.lflang.Target; -import org.lflang.TargetConfig; import org.lflang.TargetProperty.CoordinationType; import org.lflang.TimeValue; import org.lflang.federated.generator.FedConnectionInstance; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; -import org.lflang.federated.serialization.SupportedSerializers; +import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.LFGeneratorContext; import org.lflang.lf.Action; import org.lflang.lf.Reaction; @@ -33,7 +27,7 @@ public interface FedTargetExtension { * @param errorReporter Used to report errors. */ void initializeTargetConfig(LFGeneratorContext context, int numOfFederates, FederateInstance federate, FedFileConfig fileConfig, - ErrorReporter errorReporter, LinkedHashMap federationRTIProperties) throws IOException; + ErrorReporter errorReporter, RtiConfig rtiConfig) throws IOException; /** * Generate code for the body of a reaction that handles the @@ -120,13 +114,13 @@ default void annotateReaction(Reaction reaction) {} * Add necessary preamble to the source to set up federated execution. * * @param federate - * @param federationRTIProperties + * @param rtiConfig * @param errorReporter * @return */ String generatePreamble(FederateInstance federate, FedFileConfig fileConfig, - LinkedHashMap federationRTIProperties, + RtiConfig rtiConfig, ErrorReporter errorReporter) throws IOException; } diff --git a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java index f3ab17514d..5caafc1c0c 100644 --- a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java +++ b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java @@ -12,8 +12,8 @@ public class FedTargetExtensionFactory { /** * Given a target, return the appropriate extension. */ - public static FedTargetExtension getExtension(TargetDecl target) { - switch (Target.fromDecl(target)) { + public static FedTargetExtension getExtension(Target target) { + switch (target) { case CCPP: case C: return new CExtension(); case Python: return new PythonExtension(); diff --git a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java index 21b469228e..ca8ce4dd9c 100644 --- a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java @@ -3,6 +3,8 @@ import static org.lflang.util.StringUtil.addDoubleQuotes; import java.io.IOException; +import java.util.ArrayList; +import java.util.List; import java.util.LinkedHashMap; import java.util.stream.Collectors; @@ -16,6 +18,7 @@ import org.lflang.federated.generator.FedConnectionInstance; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; +import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.GeneratorBase; import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.ReactorInstance; @@ -28,7 +31,7 @@ public class TSExtension implements FedTargetExtension { @Override - public void initializeTargetConfig(LFGeneratorContext context, int numOfFederates, FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter, LinkedHashMap federationRTIProperties) throws IOException { + public void initializeTargetConfig(LFGeneratorContext context, int numOfFederates, FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter, RtiConfig rtiConfig) throws IOException { } @@ -88,9 +91,10 @@ public String getNetworkBufferType() { */ @Override public String generatePreamble(FederateInstance federate, FedFileConfig fileConfig, - LinkedHashMap federationRTIProperties, + RtiConfig rtiConfig, ErrorReporter errorReporter) { var minOutputDelay = getMinOutputDelay(federate, fileConfig, errorReporter); + var upstreamConnectionDelays = getUpstreamConnectionDelays(federate); return """ preamble {= @@ -105,7 +109,8 @@ public String generatePreamble(FederateInstance federate, FedFileConfig fileConf networkMessageActions: [%s], rtiHost: "%s", rtiPort: %d, - sendsTo: [%s] + sendsTo: [%s], + upstreamConnectionDelays: [%s] } =}""".formatted( federate.dependsOn.keySet().stream() @@ -118,11 +123,12 @@ public String generatePreamble(FederateInstance federate, FedFileConfig fileConf .stream() .map(Variable::getName) .collect(Collectors.joining(",", "\"", "\"")), - federationRTIProperties.get("host"), - federationRTIProperties.get("port"), + rtiConfig.getHost(), + rtiConfig.getPort(), federate.sendsTo.keySet().stream() .map(e->String.valueOf(e.id)) - .collect(Collectors.joining(",")) + .collect(Collectors.joining(",")), + upstreamConnectionDelays.stream().collect(Collectors.joining(",")) ); } @@ -167,4 +173,33 @@ private TimeValue getMinOutputDelay(FederateInstance federate, FedFileConfig fil } return null; } + + private List getUpstreamConnectionDelays(FederateInstance federate) { + List candidates = new ArrayList<>(); + if (!federate.dependsOn.keySet().isEmpty()) { + for (FederateInstance upstreamFederate: federate.dependsOn.keySet()) { + String element = "["; + var delays = federate.dependsOn.get(upstreamFederate); + int cnt = 0; + if (delays != null) { + for (Expression delay : delays) { + if (delay == null) { + element += "TimeValue.NEVER()"; + } else { + element += "TimeValue.nsec(" + getNetworkDelayLiteral(delay) + ")"; + } + cnt++; + if (cnt != delays.size()) { + element += ", "; + } + } + } else { + element += "TimeValue.NEVER()"; + } + element += "]"; + candidates.add(element); + } + } + return candidates; + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java b/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java index 21fb3a0729..7a7eb1f183 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java +++ b/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java @@ -208,7 +208,7 @@ private static Action createNetworkAction(FedConnectionInstance connection) { Type action_type = factory.createType(); action_type.setId( FedTargetExtensionFactory.getExtension( - connection.srcFederate.target + connection.srcFederate.targetConfig.target ).getNetworkBufferType() ); action.setType(action_type); @@ -264,7 +264,7 @@ private static void addNetworkReceiverReaction( setReactionBankIndex(networkReceiverReaction, connection.getDstBank()); // FIXME: do not create a new extension every time it is used - FedTargetExtensionFactory.getExtension(connection.srcFederate.target) + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) .annotateReaction(networkReceiverReaction); // The connection is 'physical' if it uses the ~> notation. @@ -298,7 +298,7 @@ private static void addNetworkReceiverReaction( networkReceiverReaction.setCode(factory.createCode()); networkReceiverReaction.getCode().setBody( FedTargetExtensionFactory.getExtension( - connection.dstFederate.target).generateNetworkReceiverBody( + connection.dstFederate.targetConfig.target).generateNetworkReceiverBody( networkAction, sourceRef, destRef, @@ -357,7 +357,7 @@ private static void addNetworkInputControlReaction( setReactionBankIndex(reaction, connection.getDstBank()); // FIXME: do not create a new extension every time it is used - FedTargetExtensionFactory.getExtension(connection.srcFederate.target) + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) .annotateReaction(reaction); // Create a new action that will be used to trigger the @@ -397,7 +397,7 @@ private static void addNetworkInputControlReaction( reaction.getCode() .setBody( FedTargetExtensionFactory - .getExtension(connection.dstFederate.target) + .getExtension(connection.dstFederate.targetConfig.target) .generateNetworkInputControlReactionBody( receivingPortID, maxSTP, @@ -721,7 +721,7 @@ private static void addNetworkSenderReaction( Reaction networkSenderReaction = factory.createReaction(); // FIXME: do not create a new extension every time it is used - FedTargetExtensionFactory.getExtension(connection.srcFederate.target) + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) .annotateReaction(networkSenderReaction); // If the sender or receiver is in a bank of reactors, then we want @@ -750,7 +750,7 @@ private static void addNetworkSenderReaction( networkSenderReaction.getTriggers().add(sourceRef); networkSenderReaction.setCode(factory.createCode()); networkSenderReaction.getCode().setBody( - FedTargetExtensionFactory.getExtension(connection.srcFederate.target) + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) .generateNetworkSenderBody( sourceRef, destRef, @@ -797,7 +797,7 @@ private static void addNetworkOutputControlReaction(FedConnectionInstance connec setReactionBankIndex(reaction, connection.getSrcBank()); // FIXME: do not create a new extension every time it is used - FedTargetExtensionFactory.getExtension(connection.srcFederate.target) + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) .annotateReaction(reaction); // We use an action at the top-level to manually @@ -845,7 +845,7 @@ private static void addNetworkOutputControlReaction(FedConnectionInstance connec reaction.setCode(factory.createCode()); reaction.getCode().setBody( - FedTargetExtensionFactory.getExtension(connection.srcFederate.target) + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) .generateNetworkOutputControlReactionBody(newPortRef, connection)); ASTUtils.addReactionAttribute(reaction, "_unordered"); diff --git a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java index e86af3ab77..9ae5c9d2cc 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java @@ -8,6 +8,7 @@ import java.util.Map; import org.lflang.ErrorReporter; +import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.CodeMap; import org.lflang.generator.LFGeneratorContext; import org.lflang.lf.Reactor; @@ -20,18 +21,18 @@ public class FedEmitter { private final FedFileConfig fileConfig; private final Reactor originalMainReactor; private final ErrorReporter errorReporter; - private final LinkedHashMap federationRTIProperties; + private final RtiConfig rtiConfig; public FedEmitter( FedFileConfig fileConfig, Reactor originalMainReactor, ErrorReporter errorReporter, - LinkedHashMap federationRTIProperties + RtiConfig rtiConfig ) { this.fileConfig = fileConfig; this.originalMainReactor = originalMainReactor; this.errorReporter = errorReporter; - this.federationRTIProperties = federationRTIProperties; + this.rtiConfig = rtiConfig; } /** @@ -55,9 +56,9 @@ Map generateFederate( String federateCode = String.join( "\n", - new FedTargetEmitter().generateTarget(context, numOfFederates, federate, fileConfig, errorReporter, federationRTIProperties), + new FedTargetEmitter().generateTarget(context, numOfFederates, federate, fileConfig, errorReporter, rtiConfig), new FedImportEmitter().generateImports(federate, fileConfig), - new FedPreambleEmitter().generatePreamble(federate, fileConfig, federationRTIProperties, errorReporter), + new FedPreambleEmitter().generatePreamble(federate, fileConfig, rtiConfig, errorReporter), new FedReactorEmitter().generateReactorDefinitions(federate), new FedMainEmitter().generateMainReactor( federate, diff --git a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java index 8e9df19d6e..42f5c60dc7 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java @@ -27,6 +27,8 @@ import java.io.IOException; import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; import org.eclipse.emf.ecore.resource.Resource; @@ -43,10 +45,12 @@ */ public class FedFileConfig extends FileConfig { - public FedFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) throws IOException { - // FIMXE: It is unclear to me that we need this class. + public FedFileConfig( + Resource resource, + Path srcGenBasePath, + boolean useHierarchicalBin + ) throws IOException { super(resource, srcGenBasePath, useHierarchicalBin); - } public FedFileConfig(FileConfig fileConfig) throws IOException { @@ -89,9 +93,44 @@ public Path getFedGenPath() { return srcPkgPath.resolve("fed-gen").resolve(this.name); } + /** + * Return the path to the directory in which the executables of compiled federates are stored. + */ + public Path getFedBinPath() { return getFedGenPath().resolve("bin"); } + @Override public void doClean() throws IOException { super.doClean(); FileUtil.deleteDirectory(this.getFedGenPath()); } + + /** + * Relativize target properties that involve paths like files and cmake-include to be + * relative to the generated .lf file for the federate. + */ + public void relativizePaths(FedTargetConfig targetConfig) { + relativizePathList(targetConfig.protoFiles); + relativizePathList(targetConfig.fileNames); + relativizePathList(targetConfig.cmakeIncludes); + } + + /** + * Relativize each path in the given list. + * @param paths The paths to relativize. + */ + private void relativizePathList(List paths) { + List tempList = new ArrayList<>(); + paths.forEach(f -> tempList.add(relativizePath(f))); + paths.clear(); + paths.addAll(tempList); + } + + /** + * Relativize a single path. + * @param path The path to relativize. + */ + private String relativizePath(String path) { + Path resolvedPath = this.srcPath.resolve(path).toAbsolutePath(); + return this.getSrcPath().relativize(resolvedPath).toString(); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java index 9a98e90291..18d5770165 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java +++ b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java @@ -5,7 +5,6 @@ import java.io.IOException; import java.nio.file.Path; import java.util.ArrayList; -import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashMap; @@ -27,10 +26,7 @@ import org.eclipse.xtext.resource.XtextResource; import org.eclipse.xtext.resource.XtextResourceSet; import org.eclipse.xtext.util.RuntimeIOException; -import org.eclipse.xtext.xbase.lib.CollectionLiterals; import org.eclipse.xtext.xbase.lib.Exceptions; -import org.eclipse.xtext.xbase.lib.Pair; -import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; import org.lflang.ASTUtils; import org.lflang.ErrorReporter; @@ -39,12 +35,11 @@ import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty.CoordinationType; -import org.lflang.federated.launcher.FedLauncher; -import org.lflang.federated.launcher.FedLauncherFactory; +import org.lflang.federated.launcher.FedLauncherGenerator; +import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.CodeMap; import org.lflang.generator.DockerData; import org.lflang.generator.FedDockerComposeGenerator; -import org.lflang.generator.GeneratorResult; import org.lflang.generator.GeneratorResult.Status; import org.lflang.generator.GeneratorUtils; import org.lflang.generator.IntegratedBuilder; @@ -61,55 +56,40 @@ import org.lflang.lf.Instantiation; import org.lflang.lf.LfFactory; import org.lflang.lf.Reactor; -import org.lflang.lf.TargetDecl; +import org.lflang.util.Averager; import com.google.inject.Injector; public class FedGenerator { - /** Average asynchronously reported numbers and do something with them. */ - private static class Averager { - private final int n; - private final int[] reports; - /** Create an averager of reports from {@code n} processes. */ - public Averager(int n) { - this.n = n; - reports = new int[n]; - } - - /** - * Receive {@code x} from process {@code id} and invoke {@code callback} - * on the mean of the numbers most recently reported by the processes. - */ - public synchronized void report(int id, int x, Procedure1 callback) { - assert 0 <= id && id < n; - reports[id] = x; - callback.apply(Arrays.stream(reports).sum() / n); - } - } - - private final FedFileConfig fileConfig; - private final ErrorReporter errorReporter; /** - * The current target configuration. + * */ - private final TargetConfig targetConfig; + private final ErrorReporter errorReporter; + /** * A list of federate instances. */ private final List federates = new ArrayList<>(); + /** - * A map from federate IDs to federate instances. + * File configuration to be used during the LF code generation stage (not the target code + * generation stage of individual federates). */ - private final Map federateByID = new LinkedHashMap<>(); + private final FedFileConfig fileConfig; + /** - * The federation RTI properties, which defaults to 'localhost: 15045'. + * Configuration of the RTI. */ - final LinkedHashMap federationRTIProperties = CollectionLiterals.newLinkedHashMap( - Pair.of("host", "localhost"), - Pair.of("port", 0) // Indicator to use the default port, typically 15045. - ); + final RtiConfig rtiConfig = new RtiConfig(); + + /** + * Target configuration of the federation; drawn from the file + * in which the federated reactor is defined. + */ + private final TargetConfig targetConfig; + /** * A map from instantiations to the federate instances for that * instantiation. @@ -125,12 +105,26 @@ public synchronized void report(int id, int x, Procedure1 callback) { */ private Instantiation mainDef; + /** + * Create a new generator and initialize a file configuration, target configuration, and error + * reporter. + * @param context + */ public FedGenerator(LFGeneratorContext context) { this.fileConfig = (FedFileConfig) context.getFileConfig(); this.targetConfig = context.getTargetConfig(); this.errorReporter = context.getErrorReporter(); } + /** + * Produce LF code for each federate in a separate file, then invoke a target-specific code + * generator for each of those files. + * + * @param resource The resource that has the federated main reactor in it + * @param context The context in which to carry out the code generation. + * @return False if no errors have occurred, true otherwise. + * @throws IOException + */ public boolean doGenerate(Resource resource, LFGeneratorContext context) throws IOException { if (!federatedExecutionIsSupported(resource)) return true; cleanIfNeeded(context); @@ -144,27 +138,26 @@ public boolean doGenerate(Resource resource, LFGeneratorContext context) throws processCLIArguments(context); // Find the federated reactor - Reactor fedReactor = FedASTUtils.findFederatedReactor(resource); + Reactor federation = FedASTUtils.findFederatedReactor(resource); // Extract some useful information about the federation - analyzeFederates(fedReactor); + analyzeFederates(federation, context); // Find all the connections between federates. // For each connection between federates, replace it in the // AST with an action (which inherits the delay) and four reactions. // The action will be physical for physical connections and logical // for logical connections. - replaceFederateConnectionsWithProxies(fedReactor); - - createLauncher(fileConfig, errorReporter, federationRTIProperties); + replaceFederateConnectionsWithProxies(federation); FedEmitter fedEmitter = new FedEmitter( fileConfig, ASTUtils.toDefinition(mainDef.getReactorClass()), errorReporter, - federationRTIProperties + rtiConfig ); - // Generate code for each federate + + // Generate LF code for each federate. Map lf2lfCodeMapMap = new HashMap<>(); for (FederateInstance federate : federates) { lf2lfCodeMapMap.putAll(fedEmitter.generateFederate( @@ -172,45 +165,64 @@ public boolean doGenerate(Resource resource, LFGeneratorContext context) throws )); } + // Do not invoke target code generators if --no-compile flag is used. if (context.getTargetConfig().noCompile) { context.finish(Status.GENERATED, lf2lfCodeMapMap); return false; } Map codeMapMap = compileFederates(context, lf2lfCodeMapMap, subContexts -> { - if (context.getTargetConfig().dockerOptions == null) return; - final List services = new ArrayList<>(); - // 1. create a Dockerfile for each federate - for (SubContext subContext : subContexts) {// Inherit Docker options from main context - subContext.getTargetConfig().dockerOptions = context.getTargetConfig().dockerOptions; - var dockerGenerator = dockerGeneratorFactory(subContext); - var dockerData = dockerGenerator.generateDockerData(); - try { - dockerData.writeDockerFile(); - } catch (IOException e) { - throw new RuntimeIOException(e); - } - services.add(dockerData); - } - // 2. create a docker-compose.yml for the federation - try { - // FIXME: https://issue.lf-lang.org/1559 - // It appears that the rtiHost information should come from federationRTIproperties, - // which is a kludge and not in scope here. - new FedDockerComposeGenerator(context, "localhost").writeDockerComposeFile(services); - } catch (IOException e) { - throw new RuntimeIOException(e); - } + createDockerFiles(context, subContexts); + generateLaunchScript(); }); context.finish(Status.COMPILED, codeMapMap); return false; } + private void generateLaunchScript() { + new FedLauncherGenerator( + this.targetConfig, + this.fileConfig, + this.errorReporter + ).doGenerate(federates, rtiConfig); + } + + /** + * Generate a Dockerfile for each federate and a docker-compose.yml for the federation. + * @param context The main context in which the federation has been compiled. + * @param subContexts The subcontexts in which the federates have been compiled. + */ + private void createDockerFiles(LFGeneratorContext context, List subContexts) { + if (context.getTargetConfig().dockerOptions == null) return; + final List services = new ArrayList<>(); + // 1. create a Dockerfile for each federate + for (SubContext subContext : subContexts) {// Inherit Docker options from main context + subContext.getTargetConfig().dockerOptions = context.getTargetConfig().dockerOptions; + var dockerGenerator = dockerGeneratorFactory(subContext); + var dockerData = dockerGenerator.generateDockerData(); + try { + dockerData.writeDockerFile(); + } catch (IOException e) { + throw new RuntimeIOException(e); + } + services.add(dockerData); + } + // 2. create a docker-compose.yml for the federation + try { + new FedDockerComposeGenerator( + context, + rtiConfig.getHost() + ).writeDockerComposeFile(services); + } catch (IOException e) { + throw new RuntimeIOException(e); + } + } + /** * Check if a clean was requested from the standalone compiler and perform * the clean step. - * @param context + * @param context Context in which the generator operates */ private void cleanIfNeeded(LFGeneratorContext context) { if (context.getArgs().containsKey(BuildParm.CLEAN.getKey())) { @@ -222,54 +234,25 @@ private void cleanIfNeeded(LFGeneratorContext context) { } } - /** - * Create a launcher for the federation. - * @param fileConfig - * @param errorReporter - * @param federationRTIProperties - */ - public void createLauncher( - FedFileConfig fileConfig, - ErrorReporter errorReporter, - LinkedHashMap federationRTIProperties - ) { - FedLauncher launcher; - if (federates.size() == 0) { - // no federates, use target properties of main file - TargetDecl targetDecl = GeneratorUtils.findTarget(fileConfig.resource); - launcher = FedLauncherFactory.getLauncher(Target.fromDecl(targetDecl), - targetConfig, - fileConfig, - errorReporter); - } else { - launcher = FedLauncherFactory.getLauncher( - federates.get(0), // FIXME: This would not work for mixed-target programs. - fileConfig, - errorReporter - ); - } - try { - launcher.createLauncher( - federates, - federationRTIProperties - ); - } catch (IOException e) { - errorReporter.reportError(e.getMessage()); - } - - // System.out.println(PythonInfoGenerator.generateFedRunInfo(fileConfig)); - } - /** Return whether federated execution is supported for {@code resource}. */ private boolean federatedExecutionIsSupported(Resource resource) { - var target = Target.fromDecl(GeneratorUtils.findTarget(resource)); - var ret = List.of(Target.C, Target.Python, Target.TS, Target.CPP, Target.CCPP).contains(target); - if (!ret) { + var target = Target.fromDecl(GeneratorUtils.findTargetDecl(resource)); + var targetOK = List.of( + Target.C, Target.Python, Target.TS, Target.CPP, Target.CCPP + ).contains(target); + if (!targetOK) { errorReporter.reportError( "Federated execution is not supported with target " + target + "." ); } - return ret; + if(target.equals(Target.C) && GeneratorUtils.isHostWindows()) { + errorReporter.reportError( + "Federated LF programs with a C target are currently not supported on Windows." + ); + targetOK = false; + } + + return targetOK; } private Map compileFederates( @@ -295,7 +278,7 @@ private Map compileFederates( var compileThreadPool = Executors.newFixedThreadPool(numOfCompileThreads); System.out.println("******** Using "+numOfCompileThreads+" threads to compile the program."); Map codeMapMap = new ConcurrentHashMap<>(); - List subContexts = Collections.synchronizedList(new ArrayList()); + List subContexts = Collections.synchronizedList(new ArrayList<>()); Averager averager = new Averager(federates.size()); final var threadSafeErrorReporter = new SynchronizedErrorReporter(errorReporter); for (int i = 0; i < federates.size(); i++) { @@ -314,8 +297,8 @@ private Map compileFederates( } props.put("docker", "false"); - TargetConfig subConfig = GeneratorUtils.getTargetConfig( - props, GeneratorUtils.findTarget(subFileConfig.resource), subContextErrorReporter + TargetConfig subConfig = new TargetConfig( + props, GeneratorUtils.findTargetDecl(subFileConfig.resource), subContextErrorReporter ); SubContext subContext = new SubContext(context, IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, 100) { @Override @@ -393,34 +376,34 @@ private void setFederationRTIProperties(LFGeneratorContext context) { String port = matcher.group(3); if (host != null) { - federationRTIProperties.put("host", host); + rtiConfig.setHost(host); } if (port != null) { - federationRTIProperties.put("port", port); + rtiConfig.setPort(Integer.parseInt(port)); } if (user != null) { - federationRTIProperties.put("user", user); + rtiConfig.setUser(user); } } /** * Analyze the federation and record various properties of it. * - * @param fedReactor The federated reactor that contains all federates' instances. + * @param federation The federated reactor that contains all federates' instances. */ - private void analyzeFederates(Reactor fedReactor) { + private void analyzeFederates(Reactor federation, LFGeneratorContext context) { // Create an instantiation for the fed reactor because there isn't one. // Creating a definition for the main reactor because there isn't one. mainDef = LfFactory.eINSTANCE.createInstantiation(); - mainDef.setName(fedReactor.getName()); - mainDef.setReactorClass(fedReactor); + mainDef.setName(federation.getName()); + mainDef.setReactorClass(federation); // Make sure that if no federation RTI properties were given in the // cmdline, then those specified in the lf file are not lost - if (federationRTIProperties.get("host").equals("localhost") && - fedReactor.getHost() != null && - !fedReactor.getHost().getAddr().equals("localhost")) { - federationRTIProperties.put("host", fedReactor.getHost().getAddr()); + if (rtiConfig.getHost().equals("localhost") && + federation.getHost() != null && + !federation.getHost().getAddr().equals("localhost")) { + rtiConfig.setHost(federation.getHost().getAddr()); } // Since federates are always within the main (federated) reactor, @@ -429,15 +412,15 @@ private void analyzeFederates(Reactor fedReactor) { List mainReactorContext = new ArrayList<>(); mainReactorContext.add(mainDef); - // Create a FederateInstance for each top-level reactor. - for (Instantiation instantiation : ASTUtils.allInstantiations(fedReactor)) { + // Create a FederateInstance for each instance in the top-level reactor. + for (Instantiation instantiation : ASTUtils.allInstantiations(federation)) { int bankWidth = ASTUtils.width(instantiation.getWidthSpec(), mainReactorContext); if (bankWidth < 0) { errorReporter.reportError(instantiation, "Cannot determine bank width! Assuming width of 1."); // Continue with a bank width of 1. bankWidth = 1; } - List federateInstances = getFederateInstances(instantiation, bankWidth); + List federateInstances = getFederateInstances(instantiation, bankWidth, context); if (federatesByInstantiation == null) { federatesByInstantiation = new LinkedHashMap<>(); } @@ -454,17 +437,23 @@ private void analyzeFederates(Reactor fedReactor) { * @param bankWidth The width specified for the instantiation. * @return A list of federate instance (of type @see FederateInstance). */ - private List getFederateInstances(Instantiation instantiation, int bankWidth) { + private List getFederateInstances(Instantiation instantiation, int bankWidth, LFGeneratorContext context) { // Create one federate instance for each instance in a bank of reactors. List federateInstances = new ArrayList<>(bankWidth); + for (int i = 0; i < bankWidth; i++) { // Assign an integer ID to the federate. int federateID = federates.size(); - FederateInstance federateInstance = new FederateInstance(instantiation, federateID, i, errorReporter); - federateInstance.bankIndex = i; + var resource = instantiation.getReactorClass().eResource(); + var federateTargetConfig = new FedTargetConfig(context, resource); + FederateInstance federateInstance = new FederateInstance( + instantiation, + federateID, + i, + federateTargetConfig, + errorReporter); federates.add(federateInstance); federateInstances.add(federateInstance); - federateByID.put(federateID, federateInstance); if (instantiation.getHost() != null) { federateInstance.host = instantiation.getHost().getAddr(); @@ -489,16 +478,16 @@ private List getFederateInstances(Instantiation instantiation, * Replace connections between federates in the AST with proxies that * handle sending and receiving data. * - * @param fedReactor + * @param federation Reactor class of the federation. */ - private void replaceFederateConnectionsWithProxies(Reactor fedReactor) { + private void replaceFederateConnectionsWithProxies(Reactor federation) { // Each connection in the AST may represent more than one connection between - // federate instances because of banks and multiports. We need to generate communication + // federation instances because of banks and multiports. We need to generate communication // for each of these. To do this, we create a ReactorInstance so that we don't have // to duplicate the rather complicated logic in that class. We specify a depth of 1, // so it only creates the reactors immediately within the top level, not reactors // that those contain. - ReactorInstance mainInstance = new ReactorInstance(fedReactor, errorReporter); + ReactorInstance mainInstance = new ReactorInstance(federation, errorReporter); for (ReactorInstance child : mainInstance.children) { for (PortInstance output : child.outputs) { @@ -507,7 +496,7 @@ private void replaceFederateConnectionsWithProxies(Reactor fedReactor) { } // Remove the connections at the top level - fedReactor.getConnections().clear(); + federation.getConnections().clear(); // There will be AST transformations that invalidate some info // cached in ReactorInstance. FIXME: most likely not needed anymore diff --git a/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java index 86923c8914..95351237a7 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java @@ -54,7 +54,7 @@ String generateImports(FederateInstance federate, FedFileConfig fileConfig) { ); return new_import; }) - .map(FormattingUtils.renderer(federate.target)) + .map(FormattingUtils.renderer(federate.targetConfig.target)) .collect(Collectors.joining("\n"))); return importStatements.getCode(); diff --git a/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java index ee3b64ab4a..54e215264f 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java @@ -41,7 +41,7 @@ String generateMainReactor(FederateInstance federate, Reactor originalMainReacto "Modes at the top level are not supported under federated execution." ); } - var renderer = FormattingUtils.renderer(federate.target); + var renderer = FormattingUtils.renderer(federate.targetConfig.target); return String .join( diff --git a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java index 827a31fe33..20771e7848 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java @@ -8,6 +8,7 @@ import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.federated.extensions.FedTargetExtensionFactory; +import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Model; import org.lflang.lf.Preamble; @@ -20,7 +21,7 @@ public FedPreambleEmitter() {} * Add necessary code to the source and necessary build support to * enable the requested serializations in 'enabledSerializations' */ - String generatePreamble(FederateInstance federate, FedFileConfig fileConfig, LinkedHashMap federationRTIProperties, ErrorReporter errorReporter) + String generatePreamble(FederateInstance federate, FedFileConfig fileConfig, RtiConfig rtiConfig, ErrorReporter errorReporter) throws IOException { CodeBuilder preambleCode = new CodeBuilder(); @@ -38,8 +39,8 @@ String generatePreamble(FederateInstance federate, FedFileConfig fileConfig, Lin )); } - preambleCode.pr(FedTargetExtensionFactory.getExtension(federate.target).generatePreamble( - federate, fileConfig, federationRTIProperties, errorReporter)); + preambleCode.pr(FedTargetExtensionFactory.getExtension(federate.targetConfig.target).generatePreamble( + federate, fileConfig, rtiConfig, errorReporter)); return preambleCode.getCode(); } diff --git a/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java index 066b344417..976049601c 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java @@ -18,7 +18,7 @@ String generateReactorDefinitions(FederateInstance federate) { .getReactors() .stream() .filter(federate::contains) - .map(FormattingUtils.renderer(federate.target)) + .map(FormattingUtils.renderer(federate.targetConfig.target)) .collect(Collectors.joining("\n")); } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java b/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java new file mode 100644 index 0000000000..9af20347c2 --- /dev/null +++ b/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java @@ -0,0 +1,78 @@ +package org.lflang.federated.generator; + +import static org.lflang.ASTUtils.convertToEmptyListIfNull; + +import org.lflang.ErrorReporter; +import org.lflang.TargetConfig; +import org.lflang.TargetProperty; +import org.lflang.generator.GeneratorUtils; +import org.lflang.generator.LFGeneratorContext; +import org.eclipse.emf.ecore.resource.Resource; + +/** + * Subclass of TargetConfig with a specialized constructor for creating configurations for federates. + * @author Marten Lohstroh + */ +public class FedTargetConfig extends TargetConfig { + + /** + * Create a configuration for a federate given a main context and the resource in which the class + * of the federate is specified. + * @param context The generator context. + * @param federateResource The resource in which to find the reactor class of the federate. + */ + public FedTargetConfig(LFGeneratorContext context, Resource federateResource) { + // Create target config based on the main .lf file + super( + context.getArgs(), + GeneratorUtils.findTargetDecl(context.getFileConfig().resource), + context.getErrorReporter() + ); + + mergeImportedConfig( + federateResource, + context.getFileConfig().resource, + context.getErrorReporter() + ); + + clearPropertiesToIgnore(); + + ((FedFileConfig)context.getFileConfig()).relativizePaths(this); + + } + + /** + * If the federate that target configuration applies to is imported, merge target properties + * declared in the file that it was imported from. + * @param federateResource The resource where the class of the federate is specified. + * @param mainResource The resource in which the federation (i.e., main reactor) is specified. + * @param errorReporter An error reporter to use when problems are encountered. + */ + private void mergeImportedConfig( + Resource federateResource, + Resource mainResource, + ErrorReporter errorReporter) { + // If the federate is imported, then update the configuration based on target properties + // in the imported file. + if (!federateResource.equals(mainResource)) { + var importedTargetDecl = GeneratorUtils.findTargetDecl(federateResource); + var targetProperties = importedTargetDecl.getConfig(); + if (targetProperties != null) { + // Merge properties + TargetProperty.update( + this, + convertToEmptyListIfNull(targetProperties.getPairs()), + errorReporter + ); + } + } + } + + /** + * Method for the removal of things that should not appear in the target config of a federate. + */ + private void clearPropertiesToIgnore() { + this.setByUser.remove(TargetProperty.CLOCK_SYNC); + this.setByUser.remove(TargetProperty.CLOCK_SYNC_OPTIONS); + } +} diff --git a/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java index 7143eb18c5..1616286048 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java @@ -1,19 +1,12 @@ package org.lflang.federated.generator; -import static org.lflang.ASTUtils.convertToEmptyListIfNull; - import java.io.IOException; -import java.nio.file.Path; -import java.util.ArrayList; -import java.util.LinkedHashMap; -import java.util.List; import org.lflang.ErrorReporter; -import org.lflang.Target; import org.lflang.TargetProperty; import org.lflang.ast.FormattingUtils; import org.lflang.federated.extensions.FedTargetExtensionFactory; -import org.lflang.generator.GeneratorUtils; +import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.LFGeneratorContext; public class FedTargetEmitter { @@ -24,86 +17,28 @@ String generateTarget( FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter, - LinkedHashMap federationRTIProperties + RtiConfig rtiConfig ) throws IOException { - federate.targetConfig = - GeneratorUtils.getTargetConfig( - context.getArgs(), - federate.target, - errorReporter - ); - // FIXME: Should we merge some properties with the main .lf file if the federate is imported? - // https://issue.lf-lang.org/1560 - var fedReactorClass = federate.instantiation.getReactorClass(); - if (!fedReactorClass.eResource().equals(fileConfig.resource)) { - // Merge some target properties of the main .lf file. - var target = GeneratorUtils.findTarget(fileConfig.resource); - if (target.getConfig() != null) { - // Merge properties - TargetProperty.update( - federate.targetConfig, - convertToEmptyListIfNull(target.getConfig().getPairs()), - errorReporter - ); - } - } - - relativizeTargetPaths(federate, fileConfig); - - clearFederatedTargetPropertiesI(federate); - FedTargetExtensionFactory.getExtension(federate.target) + // FIXME: First of all, this is not an initialization; there is all sorts of stuff happening + // in the C implementation of this method. Second, true initialization stuff should happen + // when the target config is constructed, not when we're doing code generation. + // See https://issues.lf-lang.org/1667 + FedTargetExtensionFactory.getExtension(federate.targetConfig.target) .initializeTargetConfig( context, numOfFederates, federate, fileConfig, errorReporter, - federationRTIProperties + rtiConfig ); - return FormattingUtils.renderer(federate.target).apply( + return FormattingUtils.renderer(federate.targetConfig.target).apply( TargetProperty.extractTargetDecl( - Target.fromDecl(federate.target), + federate.targetConfig.target, federate.targetConfig ) ); } - - /** - * Clear target properties that should not end up in the generated .lf file - * for {@code federate}. - */ - private void clearFederatedTargetPropertiesI(FederateInstance federate) { - federate.targetConfig.setByUser.remove(TargetProperty.CLOCK_SYNC); - federate.targetConfig.setByUser.remove(TargetProperty.CLOCK_SYNC_OPTIONS); - } - - - /** - * Relativize target properties that involve paths like files and cmake-include to be - * relative to the generated .lf file for the federate. - */ - private void relativizeTargetPaths(FederateInstance federate, FedFileConfig fileConfig) { - // FIXME: Should we relativize here or calculate absolute paths? - relativizePathList(federate.targetConfig.protoFiles, fileConfig); - - relativizePathList(federate.targetConfig.fileNames, fileConfig); - - relativizePathList(federate.targetConfig.cmakeIncludes, fileConfig); - } - - private void relativizePathList(List paths, FedFileConfig fileConfig) { - List tempList = new ArrayList<>(); - paths.forEach( f -> { - tempList.add(relativizePath(f, fileConfig)); - }); - paths.clear(); - paths.addAll(tempList); - } - - private String relativizePath(String path, FedFileConfig fileConfig) { - Path resolvedPath = fileConfig.srcPath.resolve(path).toAbsolutePath(); - return fileConfig.getSrcPath().relativize(resolvedPath).toString(); - } } diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index af581cc74d..f3768cec7c 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -25,6 +25,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.federated.generator; +import java.io.File; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; @@ -39,6 +40,8 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.ASTUtils; import org.lflang.ErrorReporter; +import org.lflang.FileConfig; +import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TimeValue; import org.lflang.federated.serialization.SupportedSerializers; @@ -47,6 +50,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; +import org.lflang.generator.SubContext; import org.lflang.generator.TriggerInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; @@ -62,7 +66,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; -import org.lflang.lf.TargetDecl; import org.lflang.lf.Timer; import org.lflang.lf.TriggerRef; import org.lflang.lf.VarRef; @@ -98,15 +101,14 @@ public FederateInstance( Instantiation instantiation, int id, int bankIndex, + TargetConfig targetConfig, ErrorReporter errorReporter) { this.instantiation = instantiation; this.id = id; this.bankIndex = bankIndex; this.errorReporter = errorReporter; - this.target = GeneratorUtils.findTarget( - ASTUtils.toDefinition(instantiation.getReactorClass()).eResource() - ); - this.targetConfig = new TargetConfig(target); // FIXME: this is actually set in FedTargetEmitter. Why? + this.targetConfig = targetConfig; + if (instantiation != null) { this.name = instantiation.getName(); // If the instantiation is in a bank, then we have to append @@ -249,11 +251,6 @@ public Instantiation getInstantiation() { */ public List networkReactions = new ArrayList<>(); - /** - * Target of the federate. - */ - public TargetDecl target; - /** * Parsed target config of the federate. */ diff --git a/org.lflang/src/org/lflang/federated/launcher/BuildConfig.java b/org.lflang/src/org/lflang/federated/launcher/BuildConfig.java new file mode 100644 index 0000000000..c1a01bfa47 --- /dev/null +++ b/org.lflang/src/org/lflang/federated/launcher/BuildConfig.java @@ -0,0 +1,60 @@ +package org.lflang.federated.launcher; + +import org.lflang.ErrorReporter; +import org.lflang.federated.generator.FedFileConfig; +import org.lflang.federated.generator.FederateInstance; + +/** + * A collection of methods used for building target code for federates. + */ +public abstract class BuildConfig { + + /** + * The federate that this configuration applies to. + */ + protected final FederateInstance federate; + + /** + * An error reporter to report problems. + */ + protected final ErrorReporter errorReporter; + + /** + * The file configuration of the federation that the federate belongs to. + */ + protected final FedFileConfig fileConfig; + + /** + * Create a new build configuration. + * + * @param federate The federate that this configuration applies to. + * @param fileConfig The file configuration of the federation that the federate belongs to. + * @param errorReporter An error reporter to report problems. + */ + public BuildConfig(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + this.errorReporter = errorReporter; + this.federate = federate; + this.fileConfig = fileConfig; + } + + /** + * Return the compile command for the federate that this build configuration belongs to. + */ + public String compileCommand() { + throw new UnsupportedOperationException(); + } + + /** + * Return the command that will execute the federate that this build configuration belongs to + * locally, assuming that the current directory is the top-level project folder. + */ + public abstract String localExecuteCommand(); + + /** + * Return the command that will execute the federate that this build configuration belongs to + * remotely, assuming that the current directory is the top-level project folder. + */ + public String remoteExecuteCommand() { + throw new UnsupportedOperationException(); + } +} diff --git a/org.lflang/src/org/lflang/federated/launcher/FedCLauncher.java b/org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java similarity index 56% rename from org.lflang/src/org/lflang/federated/launcher/FedCLauncher.java rename to org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java index 0b45444be9..bd88a719b4 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedCLauncher.java +++ b/org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java @@ -26,10 +26,8 @@ package org.lflang.federated.launcher; import java.io.File; -import java.io.IOException; import org.lflang.ErrorReporter; -import org.lflang.TargetConfig; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; import org.lflang.generator.c.CCompiler; @@ -39,43 +37,25 @@ * that are written in C. * * @author Soroush Bateni + * @author Marten Lohstroh */ -public class FedCLauncher extends FedLauncher { +public class CBuildConfig extends BuildConfig { - /** - * Create an instance of FedCLauncher. - * - * @param targetConfig The current target configuration. - * @param fileConfig The current file configuration. - * @param errorReporter A error reporter for reporting any errors or warnings during the code generation - */ - public FedCLauncher( - TargetConfig targetConfig, - FedFileConfig fileConfig, - ErrorReporter errorReporter - ) { - super(targetConfig, fileConfig, errorReporter); + public CBuildConfig(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + super(federate, fileConfig, errorReporter); } - /** - * Return the compile command for a federate. - * - * @param federate The federate to compile. - * @throws IOException - */ @Override - protected - String compileCommandForFederate(FederateInstance federate) { - TargetConfig localTargetConfig = targetConfig; + public String compileCommand() { String commandToReturn = ""; // FIXME: Hack to add platform support only for linux systems. // We need to fix the CMake build command for remote federates. String linuxPlatformSupport = "core" + File.separator + "platform" + File.separator + "lf_linux_support.c"; - if (!localTargetConfig.compileAdditionalSources.contains(linuxPlatformSupport)) { - localTargetConfig.compileAdditionalSources.add(linuxPlatformSupport); + if (!federate.targetConfig.compileAdditionalSources.contains(linuxPlatformSupport)) { + federate.targetConfig.compileAdditionalSources.add(linuxPlatformSupport); } - CCompiler cCompiler= new CCompiler(localTargetConfig, fileConfig, errorReporter, false); + CCompiler cCompiler= new CCompiler(federate.targetConfig, fileConfig, errorReporter, false); commandToReturn = String.join(" ", cCompiler.compileCCommand( fileConfig.name+"_"+federate.name, @@ -84,28 +64,13 @@ String compileCommandForFederate(FederateInstance federate) { return commandToReturn; } - /** - * Return the command that will execute a remote federate, assuming that the current - * directory is the top-level project folder. This is used to create a launcher script - * for federates. - * - * @param federate The federate to execute. - */ @Override - protected - String executeCommandForRemoteFederate(FederateInstance federate) { + public String remoteExecuteCommand() { return "bin/"+fileConfig.name+"_"+federate.name+" -i '$FEDERATION_ID'"; } - /** - * Return the command that will execute a local federate. - * This is used to create a launcher script for federates. - * - * @param federate The federate to execute. - */ @Override - protected - String executeCommandForLocalFederate(FedFileConfig fileConfig, FederateInstance federate) { - return fileConfig.getGenPath().resolve("bin/"+federate.name)+" -i $FEDERATION_ID"; + public String localExecuteCommand() { + return fileConfig.getFedBinPath().resolve(federate.name)+" -i $FEDERATION_ID"; } } diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncherFactory.java b/org.lflang/src/org/lflang/federated/launcher/FedLauncherFactory.java deleted file mode 100644 index c92cea1807..0000000000 --- a/org.lflang/src/org/lflang/federated/launcher/FedLauncherFactory.java +++ /dev/null @@ -1,64 +0,0 @@ -package org.lflang.federated.launcher; - -import org.lflang.ErrorReporter; -import org.lflang.Target; -import org.lflang.TargetConfig; -import org.lflang.federated.generator.FedFileConfig; -import org.lflang.federated.generator.FederateInstance; - -/** - * Helper class to get the appropriate launcher generator. - * - * FIXME: This architecture needs to be redesigned for multi-target federations. - */ -public class FedLauncherFactory { - - public static FedLauncher getLauncher ( - FederateInstance federate, - FedFileConfig fileConfig, - ErrorReporter errorReporter - ) { - return getLauncher(Target.fromDecl(federate.target), federate.targetConfig, fileConfig, errorReporter); - } - - /** - * Return a launcher generator. - * @param target The target to generate for. - * @param targetConfig The target config of the federate. - * @param fileConfig The file config for the federate. - * @param errorReporter The error reporter to use. - * @return null if not supported, an instance of {@code #FedLauncher} otherwise. - */ - public static FedLauncher getLauncher( - Target target, - TargetConfig targetConfig, - FedFileConfig fileConfig, - ErrorReporter errorReporter - ) { - switch (target) { - case C: - case CCPP: - return new FedCLauncher( - targetConfig, - fileConfig, - errorReporter - ); - case CPP: - case Rust: - return null; - case TS: - return new FedTSLauncher( - targetConfig, - fileConfig, - errorReporter - ); - case Python: - return new FedPyLauncher( - targetConfig, - fileConfig, - errorReporter - ); - } - return null; - } -} diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncher.java b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java similarity index 86% rename from org.lflang/src/org/lflang/federated/launcher/FedLauncher.java rename to org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java index 48a7149729..3ad08e2450 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedLauncher.java +++ b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java @@ -26,15 +26,16 @@ package org.lflang.federated.launcher; import java.io.File; +import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.List; import org.lflang.ErrorReporter; +import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty.ClockSyncMode; import org.lflang.federated.generator.FedFileConfig; @@ -46,8 +47,7 @@ * @author Edward A. Lee * @author Soroush Bateni */ -public class FedLauncher { - +public class FedLauncherGenerator { protected TargetConfig targetConfig; protected FedFileConfig fileConfig; protected ErrorReporter errorReporter; @@ -57,44 +57,12 @@ public class FedLauncher { * @param fileConfig The current file configuration. * @param errorReporter A error reporter for reporting any errors or warnings during the code generation */ - public FedLauncher(TargetConfig targetConfig, FedFileConfig fileConfig, ErrorReporter errorReporter) { + public FedLauncherGenerator(TargetConfig targetConfig, FedFileConfig fileConfig, ErrorReporter errorReporter) { this.targetConfig = targetConfig; this.fileConfig = fileConfig; this.errorReporter = errorReporter; } - /** - * Return the compile command for a federate. - * - * @param federate The federate to compile. - */ - protected String compileCommandForFederate(FederateInstance federate) { - throw new UnsupportedOperationException("Don't know how to compile the federates."); - } - - /** - * Return the command that will execute a remote federate, assuming that the current - * directory is the top-level project folder. This is used to create a launcher script - * for federates. - * - * @param federate The federate to execute. - */ - protected String executeCommandForRemoteFederate(FederateInstance federate) { - throw new UnsupportedOperationException("Don't know how to execute the federates."); - } - - /** - * Return the command that will execute a local federate, assuming that the current - * directory is the top-level project folder. This is used to create a launcher script - * for federates. - * - * @param federate The federate to execute. - */ - protected String executeCommandForLocalFederate(FedFileConfig fileConfig, - FederateInstance federate) { - throw new UnsupportedOperationException("Don't know how to execute the federates."); - } - /** * Create the launcher shell scripts. This will create one or two files * in the output path (bin directory). The first has name equal to @@ -131,13 +99,13 @@ protected String executeCommandForLocalFederate(FedFileConfig fileConfig, * openssl version * * @param federates A list of federate instances in the federation - * @param federationRTIProperties Contains relevant properties of the RTI. + * @param rtiConfig * Can have values for 'host', 'dir', and 'user' */ - public void createLauncher( + public void doGenerate( List federates, - LinkedHashMap federationRTIProperties - ) throws IOException { + RtiConfig rtiConfig + ) { // NOTE: It might be good to use screen when invoking the RTI // or federates remotely, so you can detach and the process keeps running. // However, I was unable to get it working properly. @@ -154,12 +122,10 @@ public void createLauncher( StringBuilder distCode = new StringBuilder(); shCode.append(getSetupCode() + "\n"); String distHeader = getDistHeader(); - Object host = federationRTIProperties.get("host"); - Object target = host; + String host = rtiConfig.getHost(); + String target = host; - Path path = Path.of(federationRTIProperties.get("dir") == null ? "LinguaFrancaRemote" : federationRTIProperties.get("dir").toString()); - - Object user = federationRTIProperties.get("user"); + String user = rtiConfig.getUser(); if (user != null) { target = user + "@" + host; } @@ -199,17 +165,18 @@ public void createLauncher( // Index used for storing pids of federates int federateIndex = 0; for (FederateInstance federate : federates) { + var buildConfig = getBuildConfig(federate, fileConfig, errorReporter); if (federate.isRemote) { Path fedRelSrcGenPath = fileConfig.getOutPath().relativize(fileConfig.getSrcGenPath()).resolve(federate.name); if(distCode.length() == 0) distCode.append(distHeader + "\n"); String logFileName = String.format("log/%s_%s.log", fileConfig.name, federate.name); - String compileCommand = compileCommandForFederate(federate); + String compileCommand = buildConfig.compileCommand(); // FIXME: Should $FEDERATION_ID be used to ensure unique directories, executables, on the remote host? - distCode.append(getDistCode(path, federate, fedRelSrcGenPath, logFileName, fileConfig.getSrcGenPath(), compileCommand) + "\n"); - String executeCommand = executeCommandForRemoteFederate(federate); - shCode.append(getFedRemoteLaunchCode(federate, path, logFileName, executeCommand, federateIndex++) + "\n"); + distCode.append(getDistCode(rtiConfig.getDirectory(), federate, fedRelSrcGenPath, logFileName, fileConfig.getSrcGenPath(), compileCommand) + "\n"); + String executeCommand = buildConfig.remoteExecuteCommand(); + shCode.append(getFedRemoteLaunchCode(federate, rtiConfig.getDirectory(), logFileName, executeCommand, federateIndex++) + "\n"); } else { - String executeCommand = executeCommandForLocalFederate(fileConfig, federate); + String executeCommand = buildConfig.localExecuteCommand(); shCode.append(getFedLocalLaunchCode(federate, executeCommand, federateIndex++) + "\n"); } } @@ -232,7 +199,11 @@ public void createLauncher( // Create bin directory for the script. if (!Files.exists(fileConfig.binPath)) { - Files.createDirectories(fileConfig.binPath); + try { + Files.createDirectories(fileConfig.binPath); + } catch (IOException e) { + errorReporter.reportError("Unable to create directory: " + fileConfig.binPath); + } } System.out.println("##### Generating launcher for federation " @@ -246,9 +217,19 @@ public void createLauncher( file.delete(); } - FileOutputStream fOut = new FileOutputStream(file); - fOut.write(shCode.toString().getBytes()); - fOut.close(); + FileOutputStream fOut = null; + try { + fOut = new FileOutputStream(file); + } catch (FileNotFoundException e) { + errorReporter.reportError("Unable to find file: " + file); + } + try { + fOut.write(shCode.toString().getBytes()); + fOut.close(); + } catch (IOException e) { + errorReporter.reportError("Unable to write to file: " + file); + } + if (!file.setExecutable(true, false)) { errorReporter.reportWarning("Unable to make launcher script executable."); } @@ -260,11 +241,17 @@ public void createLauncher( file.delete(); } if (distCode.length() > 0) { - fOut = new FileOutputStream(file); - fOut.write(distCode.toString().getBytes()); - fOut.close(); - if (!file.setExecutable(true, false)) { - errorReporter.reportWarning("Unable to make distributor script executable."); + try { + fOut = new FileOutputStream(file); + fOut.write(distCode.toString().getBytes()); + fOut.close(); + if (!file.setExecutable(true, false)) { + errorReporter.reportWarning("Unable to make file executable: " + file); + } + } catch (FileNotFoundException e) { + errorReporter.reportError("Unable to find file: " + file); + } catch (IOException e) { + errorReporter.reportError("Unable to write to file " + file); } } } @@ -329,6 +316,9 @@ private String getRtiCommand(List federates, boolean isRemote) if (targetConfig.auth) { commands.add(" -a \\"); } + if (targetConfig.tracing != null) { + commands.add(" -t \\"); + } commands.addAll(List.of( " -n "+federates.size()+" \\", " -c "+targetConfig.clockSync.toString()+" \\" @@ -451,7 +441,7 @@ private String getUserHost(Object user, Object host) { private String getFedRemoteLaunchCode( FederateInstance federate, - Object path, + Path path, String logFileName, String executeCommand, int federateIndex @@ -482,4 +472,24 @@ private String getFedLocalLaunchCode(FederateInstance federate, String executeCo executeCommand, federateIndex); } + + /** + * Create a build configuration of the appropriate target. + * + * @param federate The federate to which the build configuration applies. + * @param fileConfig The file configuration of the federation to which the federate belongs. + * @param errorReporter An error reporter to report problems. + * @return + */ + private BuildConfig getBuildConfig( + FederateInstance federate, + FedFileConfig fileConfig, + ErrorReporter errorReporter) { + return switch(federate.targetConfig.target) { + case C, CCPP -> new CBuildConfig(federate, fileConfig, errorReporter); + case Python -> new PyBuildConfig(federate, fileConfig, errorReporter); + case TS -> new TsBuildConfig(federate, fileConfig, errorReporter); + case CPP, Rust -> throw new UnsupportedOperationException(); + }; + } } diff --git a/org.lflang/src/org/lflang/federated/launcher/FedPyLauncher.java b/org.lflang/src/org/lflang/federated/launcher/FedPyLauncher.java deleted file mode 100644 index 414caf2ee4..0000000000 --- a/org.lflang/src/org/lflang/federated/launcher/FedPyLauncher.java +++ /dev/null @@ -1,83 +0,0 @@ -/************* - * Copyright (c) 2021, The University of California at Berkeley. - * Copyright (c) 2021, The University of Texas at Dallas. - * - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. - ***************/ - -package org.lflang.federated.launcher; - -import org.lflang.ErrorReporter; -import org.lflang.TargetConfig; -import org.lflang.federated.generator.FedFileConfig; -import org.lflang.federated.generator.FederateInstance; - -/** - * Utility class that can be used to create a launcher for federated LF programs - * that are written in Python. - * - * @author Soroush Bateni - * - */ -public class FedPyLauncher extends FedLauncher { - /** - * Create an instance of FedPyLauncher. - * - * @param targetConfig The current target configuration. - * @param fileConfig The current file configuration. - * @param errorReporter A error reporter for reporting any errors or warnings during the code generation - */ - public FedPyLauncher( - TargetConfig targetConfig, - FedFileConfig fileConfig, - ErrorReporter errorReporter - ) { - super(targetConfig, fileConfig, errorReporter); - } - - /** - * Return the command that will execute a remote federate, assuming that the current - * directory is the top-level project folder. This is used to create a launcher script - * for federates. - * - * @param federate The federate to execute. - */ - @Override - protected - String executeCommandForRemoteFederate(FederateInstance federate) { - return "python3 src-gen/"+fileConfig.name+"/"+federate.name+"/"+fileConfig.name+"_"+federate.name+" -i '$FEDERATION_ID'"; - } - - /** - * Return the command that will execute a local federate, assuming that the current - * directory is the top-level project folder. This is used to create a launcher script - * for federates. - * - * @param federate The federate to execute. - */ - @Override - protected - String executeCommandForLocalFederate(FedFileConfig fileConfig, FederateInstance federate) { - return "python3 " + fileConfig.getSrcGenPath() + "/" + federate.name + "/" + federate.name+".py -i $FEDERATION_ID"; - } -} diff --git a/org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java b/org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java new file mode 100644 index 0000000000..85d6dc4a0f --- /dev/null +++ b/org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java @@ -0,0 +1,22 @@ +package org.lflang.federated.launcher; + +import org.lflang.ErrorReporter; +import org.lflang.federated.generator.FedFileConfig; +import org.lflang.federated.generator.FederateInstance; + +public class PyBuildConfig extends BuildConfig { + + public PyBuildConfig(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + super(federate, fileConfig, errorReporter); + } + + @Override + public String localExecuteCommand() { + return "python3 " + fileConfig.getSrcGenPath() + "/" + federate.name + "/" + federate.name+".py -i $FEDERATION_ID"; + } + + @Override + public String remoteExecuteCommand() { + return "python3 src-gen/"+fileConfig.name+"/"+federate.name+"/"+fileConfig.name+"_"+federate.name+" -i '$FEDERATION_ID'"; + } +} diff --git a/org.lflang/src/org/lflang/federated/launcher/RtiConfig.java b/org.lflang/src/org/lflang/federated/launcher/RtiConfig.java new file mode 100644 index 0000000000..81c608d5b3 --- /dev/null +++ b/org.lflang/src/org/lflang/federated/launcher/RtiConfig.java @@ -0,0 +1,92 @@ +package org.lflang.federated.launcher; + +import java.nio.file.Path; + +/** + * Class for storing configuration settings pertaining to the RTI. + * @author Marten Lohstroh + */ +public class RtiConfig { + + private Path directory; + + /** + * The host on which the RTI process is to be spawned. + */ + private String host; + + /** + * The port on which to connect to the RTI process. + */ + private int port; + + /** + * The username used to gain access to the host where the RTI is to be spawned. + */ + private String user; + + /** + * Construct a new RTI configuration with all options set to their defaults. + */ + public RtiConfig() { + this.directory = Path.of("LinguaFrancaRemote"); + this.host = "localhost"; + this.port = 0; + } + + /** + * Return the directory to create on the remote host. + */ + public Path getDirectory() { + return directory; + } + + /** + * Return the host on which the RTI process is to be spawned. + */ + public String getHost() { + return host; + } + + /** + * Return the port on which to connect to the RTI process. + */ + public int getPort() { + return port; + } + + /** + * Return the username used to gain access to the host where the RTI is to be spawned. + */ + public String getUser() { + return user; + } + + /** + * Set the directory to create on the remote host. + */ + public void setDirectory(Path directory) { + this.directory = directory; + } + + /** + * Set the host on which the RTI process is to be spawned. + */ + public void setHost(String host) { + this.host = host; + } + + /** + * Set the port on which to connect to the RTI process. + */ + public void setPort(int port) { + this.port = port; + } + + /** + * Set the username used to gain access to the host where the RTI is to be spawned. + */ + public void setUser(String user) { + this.user = user; + } +} diff --git a/org.lflang/src/org/lflang/federated/launcher/FedTSLauncher.java b/org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java similarity index 68% rename from org.lflang/src/org/lflang/federated/launcher/FedTSLauncher.java rename to org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java index 67dbd134fa..87b7ffaeb1 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedTSLauncher.java +++ b/org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java @@ -36,35 +36,24 @@ * * @author Soroush Bateni * @author Hokeun Kim + * @author Marten Lohstroh */ -public class FedTSLauncher extends FedLauncher { +public class TsBuildConfig extends BuildConfig { - /** - * Create an instance of FedCLauncher. - * - * @param targetConfig The current target configuration. - * @param fileConfig The current file configuration. - * @param errorReporter A error reporter for reporting any errors or warnings during the code generation - */ - public FedTSLauncher( - TargetConfig targetConfig, - FedFileConfig fileConfig, - ErrorReporter errorReporter - ) { - super(targetConfig, fileConfig, errorReporter); + + public TsBuildConfig(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + super(federate, fileConfig, errorReporter); + } + + @Override + public String compileCommand() { + return null; } - - /** - * Return the command that will execute a local federate, assuming that the current - * directory is the top-level project folder. This is used to create a launcher script - * for federates. - * - * @param federate The federate to execute. - */ + @Override - protected - String executeCommandForLocalFederate(FedFileConfig fileConfig, FederateInstance federate) { + public String localExecuteCommand() { String jsFilename = federate.name + ".js"; return "node "+fileConfig.getSrcGenPath().resolve(federate.name).resolve("dist").resolve(jsFilename)+" -i $FEDERATION_ID"; } + } diff --git a/org.lflang/src/org/lflang/generator/GeneratorUtils.java b/org.lflang/src/org/lflang/generator/GeneratorUtils.java index 32ad03e08b..709e1943bd 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorUtils.java +++ b/org.lflang/src/org/lflang/generator/GeneratorUtils.java @@ -1,52 +1,30 @@ package org.lflang.generator; -import java.io.IOException; import java.nio.file.Path; -import java.nio.file.Paths; import java.util.ArrayList; import java.util.HashSet; -import java.util.Iterator; import java.util.List; -import java.util.Properties; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.emf.common.util.URI; -import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; -import org.eclipse.xtext.generator.IGeneratorContext; -import org.eclipse.xtext.resource.XtextResource; -import org.eclipse.xtext.validation.CheckMode; -import org.eclipse.xtext.validation.IResourceValidator; -import org.eclipse.xtext.validation.Issue; import org.eclipse.xtext.xbase.lib.IteratorExtensions; import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; -import org.lflang.Target; import org.lflang.TargetConfig; -import org.lflang.TargetConfig.DockerOptions; -import org.lflang.TargetProperty.BuildType; -import org.lflang.TargetProperty.LogLevel; -import org.lflang.TargetProperty.UnionType; import org.lflang.generator.LFGeneratorContext.Mode; import org.lflang.TargetProperty; -import org.lflang.TargetProperty.SchedulerOption; -import org.lflang.graph.InstantiationGraph; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; -import org.lflang.lf.Import; import org.lflang.lf.Instantiation; import org.lflang.lf.KeyValuePair; import org.lflang.lf.KeyValuePairs; -import org.lflang.lf.Model; -import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; import org.lflang.lf.TargetDecl; -import org.lflang.util.FileUtil; -import org.lflang.util.IteratorUtil; /** * A helper class with functions that may be useful for code @@ -65,81 +43,10 @@ private GeneratorUtils() { /** * Return the target declaration found in the given resource. */ - public static TargetDecl findTarget(Resource resource) { + public static TargetDecl findTargetDecl(Resource resource) { return findAll(resource, TargetDecl.class).iterator().next(); } - /** - * Set the appropriate target properties based on the target properties of - * the main .lf file and the given command-line arguments, if applicable. - * @param args The commandline arguments to process. - * @param target The target properties AST node. - * @param errorReporter The error reporter to which errors should be sent. - */ - public static TargetConfig getTargetConfig( - Properties args, - TargetDecl target, - ErrorReporter errorReporter - ) { - final TargetConfig targetConfig = new TargetConfig(target); // FIXME: why not just do all of this in the constructor? - if (target.getConfig() != null) { - List pairs = target.getConfig().getPairs(); - TargetProperty.set(targetConfig, pairs != null ? pairs : List.of(), errorReporter); - } - if (args.containsKey("no-compile")) { - targetConfig.noCompile = true; - } - if (args.containsKey("docker")) { - var arg = args.getProperty("docker"); - if (Boolean.parseBoolean(arg)) { - targetConfig.dockerOptions = new DockerOptions(); - } else { - targetConfig.dockerOptions = null; - } - // FIXME: this is pretty ad-hoc and does not account for more complex overrides yet. - } - if (args.containsKey("build-type")) { - targetConfig.cmakeBuildType = (BuildType) UnionType.BUILD_TYPE_UNION.forName(args.getProperty("build-type")); - } - if (args.containsKey("logging")) { - targetConfig.logLevel = LogLevel.valueOf(args.getProperty("logging").toUpperCase()); - } - if (args.containsKey("workers")) { - targetConfig.workers = Integer.parseInt(args.getProperty("workers")); - } - if (args.containsKey("threading")) { - targetConfig.threading = Boolean.parseBoolean(args.getProperty("threading")); - } - if (args.containsKey("target-compiler")) { - targetConfig.compiler = args.getProperty("target-compiler"); - } - if (args.containsKey("scheduler")) { - targetConfig.schedulerType = SchedulerOption.valueOf( - args.getProperty("scheduler") - ); - targetConfig.setByUser.add(TargetProperty.SCHEDULER); - } - if (args.containsKey("target-flags")) { - targetConfig.compilerFlags.clear(); - if (!args.getProperty("target-flags").isEmpty()) { - targetConfig.compilerFlags.addAll(List.of( - args.getProperty("target-flags").split(" ") - )); - } - } - if (args.containsKey("runtime-version")) { - targetConfig.runtimeVersion = args.getProperty("runtime-version"); - } - if (args.containsKey("external-runtime-path")) { - targetConfig.externalRuntimePath = args.getProperty("external-runtime-path"); - } - if (args.containsKey(TargetProperty.KEEPALIVE.description)) { - targetConfig.keepalive = Boolean.parseBoolean( - args.getProperty(TargetProperty.KEEPALIVE.description)); - } - return targetConfig; - } - /** * Look for physical actions in 'resource'. * If appropriate, set keepalive to true in diff --git a/org.lflang/src/org/lflang/generator/MainContext.java b/org.lflang/src/org/lflang/generator/MainContext.java index e7d442e1d3..5ee53e5f83 100644 --- a/org.lflang/src/org/lflang/generator/MainContext.java +++ b/org.lflang/src/org/lflang/generator/MainContext.java @@ -163,8 +163,8 @@ public void reportProgress(String message, int percentage) { * reflected in the target configuration. */ public void loadTargetConfig() { - this.targetConfig = GeneratorUtils.getTargetConfig( - args, GeneratorUtils.findTarget(fileConfig.resource), errorReporter + this.targetConfig = new TargetConfig( + args, GeneratorUtils.findTargetDecl(fileConfig.resource), errorReporter ); } } diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 21ea083e49..3fd3675d52 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -301,7 +301,7 @@ class TSGenerator( if (ret != 0) { val errors: String = pnpmInstall.errors.toString() errorReporter.reportError( - GeneratorUtils.findTarget(resource), + GeneratorUtils.findTargetDecl(resource), "ERROR: pnpm install command failed" + if (errors.isBlank()) "." else ":\n$errors") } installProtoBufsIfNeeded(true, path, context.cancelIndicator) @@ -318,10 +318,10 @@ class TSGenerator( if (npmInstall.run(context.cancelIndicator) != 0) { errorReporter.reportError( - GeneratorUtils.findTarget(resource), + GeneratorUtils.findTargetDecl(resource), "ERROR: npm install command failed: " + npmInstall.errors.toString()) errorReporter.reportError( - GeneratorUtils.findTarget(resource), "ERROR: npm install command failed." + + GeneratorUtils.findTargetDecl(resource), "ERROR: npm install command failed." + "\nFor installation instructions, see: https://www.npmjs.com/get-npm") return } diff --git a/org.lflang/src/org/lflang/util/Averager.java b/org.lflang/src/org/lflang/util/Averager.java new file mode 100644 index 0000000000..81349c9db1 --- /dev/null +++ b/org.lflang/src/org/lflang/util/Averager.java @@ -0,0 +1,27 @@ +package org.lflang.util; + +import java.util.Arrays; + +import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; + +/** Average asynchronously reported numbers and do something with them. */ +public class Averager { + private final int n; + private final int[] reports; + + /** Create an averager of reports from {@code n} processes. */ + public Averager(int n) { + this.n = n; + reports = new int[n]; + } + + /** + * Receive {@code x} from process {@code id} and invoke {@code callback} + * on the mean of the numbers most recently reported by the processes. + */ + public synchronized void report(int id, int x, Procedure1 callback) { + assert 0 <= id && id < n; + reports[id] = x; + callback.apply(Arrays.stream(reports).sum() / n); + } +} diff --git a/test/C/src/federated/SimpleFederatedAuthenticated.lf b/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf similarity index 100% rename from test/C/src/federated/SimpleFederatedAuthenticated.lf rename to test/C/src/federated/failing/SimpleFederatedAuthenticated.lf diff --git a/util/tracing/README.md b/util/tracing/README.md index d189260ef7..28d8db23d7 100644 --- a/util/tracing/README.md +++ b/util/tracing/README.md @@ -3,12 +3,18 @@ This directory contains the source code for utilities that are standalone executables for post-processing tracing data created by the tracing function in Lingua Franca. +Utilities for visualizing the data are contained in the [visualization](visualization/README.md) +directory. + * trace\_to\_csv: Creates a comma-separated values text file from a binary trace file. The resulting file is suitable for analyzing in spreadsheet programs such as Excel. * trace\_to\_chrome: Creates a JSON file suitable for importing into Chrome's trace visualizer. Point Chrome to chrome://tracing/ and load the resulting file. +* trace\_to\_influxdb: A preliminary implementation that takes a binary trace file + and uploads its data into [InfluxDB](https://en.wikipedia.org/wiki/InfluxDB). + ## Installing ``` diff --git a/util/tracing/makefile b/util/tracing/makefile index eb21e42e62..407b153235 100644 --- a/util/tracing/makefile +++ b/util/tracing/makefile @@ -28,6 +28,8 @@ install: trace_to_csv trace_to_chrome trace_to_influxdb mv trace_to_csv ../../bin mv trace_to_chrome ../../bin mv trace_to_influxdb ../../bin + ln -f -s ../lib/scripts/launch-fedsd.sh ../../bin/fedsd + chmod +x ../../bin/fedsd clean: rm -f *.o diff --git a/util/tracing/trace_to_chrome.c b/util/tracing/trace_to_chrome.c index d39f53171e..92eeee71dd 100644 --- a/util/tracing/trace_to_chrome.c +++ b/util/tracing/trace_to_chrome.c @@ -43,6 +43,12 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /** Maximum thread ID seen. */ int max_thread_id = 0; +/** File containing the trace binary data. */ +FILE* trace_file = NULL; + +/** File for writing the output data. */ +FILE* output_file = NULL; + /** * Print a usage message. */ @@ -62,17 +68,23 @@ bool physical_time_only = false; /** * Read a trace in the specified file and write it to the specified json file. + * @param trace_file An open trace file. + * @param output_file An open output .json file. * @return The number of records read or 0 upon seeing an EOF. */ -size_t read_and_write_trace() { +size_t read_and_write_trace(FILE* trace_file, FILE* output_file) { int trace_length = read_trace(trace_file); if (trace_length == 0) return 0; // Write each line. for (int i = 0; i < trace_length; i++) { char* reaction_name = "\"UNKNOWN\""; - if (trace[i].reaction_number >= 0) { + + // Ignore federated trace events. + if (trace[i].event_type > federated) continue; + + if (trace[i].dst_id >= 0) { reaction_name = (char*)malloc(4); - snprintf(reaction_name, 4, "%d", trace[i].reaction_number); + snprintf(reaction_name, 4, "%d", trace[i].dst_id); } // printf("DEBUG: Reactor's self struct pointer: %p\n", trace[i].pointer); int reactor_index; @@ -113,7 +125,7 @@ size_t read_and_write_trace() { } // Default thread id is the worker number. - int thread_id = trace[i].worker; + int thread_id = trace[i].src_id; char* args; asprintf(&args, "{" @@ -182,7 +194,7 @@ size_t read_and_write_trace() { phase = "E"; break; default: - fprintf(stderr, "WARNING: Unrecognized event type %d: %s", + fprintf(stderr, "WARNING: Unrecognized event type %d: %s\n", trace[i].event_type, trace_event_names[trace[i].event_type]); pid = PID_FOR_UNKNOWN_EVENT; phase = "i"; @@ -206,8 +218,8 @@ size_t read_and_write_trace() { ); free(args); - if (trace[i].worker > max_thread_id) { - max_thread_id = trace[i].worker; + if (trace[i].src_id > max_thread_id) { + max_thread_id = trace[i].src_id; } // If the event is reaction_starts and physical_time_only is not set, // then also generate an instantaneous @@ -217,13 +229,13 @@ size_t read_and_write_trace() { pid = reactor_index + 1; reaction_name = (char*)malloc(4); char name[13]; - snprintf(name, 13, "reaction %d", trace[i].reaction_number); + snprintf(name, 13, "reaction %d", trace[i].dst_id); // NOTE: If the reactor has more than 1024 timers and actions, then // there will be a collision of thread IDs here. - thread_id = 1024 + trace[i].reaction_number; - if (trace[i].reaction_number > max_reaction_number) { - max_reaction_number = trace[i].reaction_number; + thread_id = 1024 + trace[i].dst_id; + if (trace[i].dst_id > max_reaction_number) { + max_reaction_number = trace[i].dst_id; } fprintf(output_file, "{" @@ -253,8 +265,9 @@ size_t read_and_write_trace() { /** * Write metadata events, which provide names in the renderer. + * @param output_file An open output .json file. */ -void write_metadata_events() { +void write_metadata_events(FILE* output_file) { // Thread 0 is the main thread. fprintf(output_file, "{" "\"name\": \"thread_name\", " @@ -416,13 +429,22 @@ int main(int argc, char* argv[]) { usage(); exit(0); } - open_files(filename, "json"); + + // Open the trace file. + trace_file = open_file(filename, "r"); + + // Construct the name of the csv output file and open it. + char* root = root_name(filename); + char json_filename[strlen(root) + 6]; + strcpy(json_filename, root); + strcat(json_filename, ".json"); + output_file = open_file(json_filename, "w"); if (read_header(trace_file) >= 0) { // Write the opening bracket into the json file. fprintf(output_file, "{ \"traceEvents\": [\n"); - while (read_and_write_trace() != 0) {}; - write_metadata_events(); + while (read_and_write_trace(trace_file, output_file) != 0) {}; + write_metadata_events(output_file); fprintf(output_file, "]}\n"); } } diff --git a/util/tracing/trace_to_csv.c b/util/tracing/trace_to_csv.c index a2bcfd91a2..707cc5f43b 100644 --- a/util/tracing/trace_to_csv.c +++ b/util/tracing/trace_to_csv.c @@ -37,6 +37,15 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define MAX_NUM_REACTIONS 64 // Maximum number of reactions reported in summary stats. #define MAX_NUM_WORKERS 64 +/** File containing the trace binary data. */ +FILE* trace_file = NULL; + +/** File for writing the output data. */ +FILE* output_file = NULL; + +/** File for writing summary statistics. */ +FILE* summary_file = NULL; + /** Size of the stats table is object_table_size plus twice MAX_NUM_WORKERS. */ int table_size; @@ -69,7 +78,7 @@ typedef struct reaction_stats_t { */ typedef struct summary_stats_t { trace_event_t event_type; // Use reaction_ends for reactions. - char* description; // Description in the reaction table (e.g. reactor name). + const char* description; // Description in the reaction table (e.g. reactor name). int occurrences; // Number of occurrences of this description. int num_reactions_seen; reaction_stats_t reactions[MAX_NUM_REACTIONS]; @@ -94,11 +103,6 @@ size_t read_and_write_trace() { if (trace_length == 0) return 0; // Write each line. for (int i = 0; i < trace_length; i++) { - char* reaction_name = "none"; - if (trace[i].reaction_number >= 0) { - reaction_name = (char*)malloc(4); - snprintf(reaction_name, 4, "%d", trace[i].reaction_number); - } // printf("DEBUG: reactor self struct pointer: %p\n", trace[i].pointer); int object_instance = -1; char* reactor_name = get_object_description(trace[i].pointer, &object_instance); @@ -110,11 +114,11 @@ size_t read_and_write_trace() { if (trigger_name == NULL) { trigger_name = "NO TRIGGER"; } - fprintf(output_file, "%s, %s, %s, %d, %lld, %d, %lld, %s, %lld\n", + fprintf(output_file, "%s, %s, %d, %d, %lld, %d, %lld, %s, %lld\n", trace_event_names[trace[i].event_type], reactor_name, - reaction_name, - trace[i].worker, + trace[i].src_id, + trace[i].dst_id, trace[i].logical_time - start_time, trace[i].microstep, trace[i].physical_time - start_time, @@ -125,33 +129,41 @@ size_t read_and_write_trace() { if (trace[i].physical_time > latest_time) { latest_time = trace[i].physical_time; } - if (summary_stats[object_instance] == NULL) { - summary_stats[object_instance] = (summary_stats_t*)calloc(1, sizeof(summary_stats_t)); + if (object_instance >= 0 && summary_stats[NUM_EVENT_TYPES + object_instance] == NULL) { + summary_stats[NUM_EVENT_TYPES + object_instance] = (summary_stats_t*)calloc(1, sizeof(summary_stats_t)); } - if (trigger_instance >= 0 && summary_stats[trigger_instance] == NULL) { - summary_stats[trigger_instance] = (summary_stats_t*)calloc(1, sizeof(summary_stats_t)); + if (trigger_instance >= 0 && summary_stats[NUM_EVENT_TYPES + trigger_instance] == NULL) { + summary_stats[NUM_EVENT_TYPES + trigger_instance] = (summary_stats_t*)calloc(1, sizeof(summary_stats_t)); } - summary_stats_t* stats; + summary_stats_t* stats = NULL; interval_t exec_time; reaction_stats_t* rstats; int index; + // Count of event type. + if (summary_stats[trace[i].event_type] == NULL) { + summary_stats[trace[i].event_type] = (summary_stats_t*)calloc(1, sizeof(summary_stats_t)); + } + summary_stats[trace[i].event_type]->event_type = trace[i].event_type; + summary_stats[trace[i].event_type]->description = trace_event_names[trace[i].event_type]; + summary_stats[trace[i].event_type]->occurrences++; + switch(trace[i].event_type) { case reaction_starts: case reaction_ends: // This code relies on the mutual exclusion of reactions in a reactor // and the ordering of reaction_starts and reaction_ends events. - if (trace[i].reaction_number >= MAX_NUM_REACTIONS) { + if (trace[i].dst_id >= MAX_NUM_REACTIONS) { fprintf(stderr, "WARNING: Too many reactions. Not all will be shown in summary file.\n"); continue; } - stats = summary_stats[object_instance]; + stats = summary_stats[NUM_EVENT_TYPES + object_instance]; stats->description = reactor_name; - if (trace[i].reaction_number >= stats->num_reactions_seen) { - stats->num_reactions_seen = trace[i].reaction_number + 1; + if (trace[i].dst_id >= stats->num_reactions_seen) { + stats->num_reactions_seen = trace[i].dst_id + 1; } - rstats = &stats->reactions[trace[i].reaction_number]; + rstats = &stats->reactions[trace[i].dst_id]; if (trace[i].event_type == reaction_starts) { rstats->latest_start_time = trace[i].physical_time; } else { @@ -172,19 +184,19 @@ size_t read_and_write_trace() { // No trigger. Do not report. continue; } - stats = summary_stats[trigger_instance]; + stats = summary_stats[NUM_EVENT_TYPES + trigger_instance]; stats->description = trigger_name; break; case user_event: // Although these are not exec times and not reactions, // commandeer the first entry in the reactions array to track values. - stats = summary_stats[object_instance]; + stats = summary_stats[NUM_EVENT_TYPES + object_instance]; stats->description = reactor_name; break; case user_value: // Although these are not exec times and not reactions, // commandeer the first entry in the reactions array to track values. - stats = summary_stats[object_instance]; + stats = summary_stats[NUM_EVENT_TYPES + object_instance]; stats->description = reactor_name; rstats = &stats->reactions[0]; rstats->occurrences++; @@ -205,7 +217,7 @@ size_t read_and_write_trace() { // Use the reactions array to store data. // There will be two entries per worker, one for waits on the // reaction queue and one for waits while advancing time. - index = trace[i].worker * 2; + index = trace[i].src_id * 2; // Even numbered indices are used for waits on reaction queue. // Odd numbered indices for waits for time advancement. if (trace[i].event_type == scheduler_advancing_time_starts @@ -216,10 +228,10 @@ size_t read_and_write_trace() { fprintf(stderr, "WARNING: Too many workers. Not all will be shown in summary file.\n"); continue; } - stats = summary_stats[object_table_size + index]; + stats = summary_stats[NUM_EVENT_TYPES + object_table_size + index]; if (stats == NULL) { stats = (summary_stats_t*)calloc(1, sizeof(summary_stats_t)); - summary_stats[object_table_size + index] = stats; + summary_stats[NUM_EVENT_TYPES + object_table_size + index] = stats; } // num_reactions_seen here will be used to store the number of // entries in the reactions array, which is twice the number of workers. @@ -244,10 +256,15 @@ size_t read_and_write_trace() { } } break; + default: + // No special summary statistics for the rest. + break; } // Common stats across event types. - stats->occurrences++; - stats->event_type = trace[i].event_type; + if (stats != NULL) { + stats->occurrences++; + stats->event_type = trace[i].event_type; + } } return trace_length; } @@ -261,11 +278,22 @@ void write_summary_file() { fprintf(summary_file, "End time:, %lld\n", latest_time); fprintf(summary_file, "Total time:, %lld\n", latest_time - start_time); + fprintf(summary_file, "\nTotal Event Occurrences\n"); + for (int i = 0; i < NUM_EVENT_TYPES; i++) { + summary_stats_t* stats = summary_stats[i]; + if (stats != NULL) { + fprintf(summary_file, "%s, %d\n", + stats->description, + stats->occurrences + ); + } + } + // First pass looks for reaction invocations. // First print a header. fprintf(summary_file, "\nReaction Executions\n"); fprintf(summary_file, "Reactor, Reaction, Occurrences, Total Time, Pct Total Time, Avg Time, Max Time, Min Time\n"); - for (int i = 0; i < table_size; i++) { + for (int i = NUM_EVENT_TYPES; i < table_size; i++) { summary_stats_t* stats = summary_stats[i]; if (stats != NULL && stats->num_reactions_seen > 0) { for (int j = 0; j < stats->num_reactions_seen; j++) { @@ -288,7 +316,7 @@ void write_summary_file() { // Next pass looks for calls to schedule. bool first = true; - for (int i = 0; i < table_size; i++) { + for (int i = NUM_EVENT_TYPES; i < table_size; i++) { summary_stats_t* stats = summary_stats[i]; if (stats != NULL && stats->event_type == schedule_called && stats->occurrences > 0) { if (first) { @@ -302,7 +330,7 @@ void write_summary_file() { // Next pass looks for user-defined events. first = true; - for (int i = 0; i < table_size; i++) { + for (int i = NUM_EVENT_TYPES; i < table_size; i++) { summary_stats_t* stats = summary_stats[i]; if (stats != NULL && (stats->event_type == user_event || stats->event_type == user_value) @@ -329,7 +357,7 @@ void write_summary_file() { // Next pass looks for wait events. first = true; - for (int i = 0; i < table_size; i++) { + for (int i = NUM_EVENT_TYPES; i < table_size; i++) { summary_stats_t* stats = summary_stats[i]; if (stats != NULL && ( stats->event_type == worker_wait_ends @@ -369,15 +397,34 @@ int main(int argc, char* argv[]) { usage(); exit(0); } - open_files(argv[1], "csv"); + // Open the trace file. + trace_file = open_file(argv[1], "r"); + if (trace_file == NULL) exit(1); + + // Construct the name of the csv output file and open it. + char* root = root_name(argv[1]); + char csv_filename[strlen(root) + 5]; + strcpy(csv_filename, root); + strcat(csv_filename, ".csv"); + output_file = open_file(csv_filename, "w"); + if (output_file == NULL) exit(1); + + // Construct the name of the summary output file and open it. + char summary_filename[strlen(root) + 13]; + strcpy(summary_filename, root); + strcat(summary_filename, "_summary.csv"); + summary_file = open_file(summary_filename, "w"); + if (summary_file == NULL) exit(1); + + free(root); if (read_header() >= 0) { // Allocate an array for summary statistics. - table_size = object_table_size + (MAX_NUM_WORKERS * 2); + table_size = NUM_EVENT_TYPES + object_table_size + (MAX_NUM_WORKERS * 2); summary_stats = (summary_stats_t**)calloc(table_size, sizeof(summary_stats_t*)); // Write a header line into the CSV file. - fprintf(output_file, "Event, Reactor, Reaction, Worker, Elapsed Logical Time, Microstep, Elapsed Physical Time, Trigger, Extra Delay\n"); + fprintf(output_file, "Event, Reactor, Source, Destination, Elapsed Logical Time, Microstep, Elapsed Physical Time, Trigger, Extra Delay\n"); while (read_and_write_trace() != 0) {}; write_summary_file(); diff --git a/util/tracing/trace_to_influxdb.c b/util/tracing/trace_to_influxdb.c index d8281abd01..a99ae003ec 100644 --- a/util/tracing/trace_to_influxdb.c +++ b/util/tracing/trace_to_influxdb.c @@ -117,6 +117,9 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define MAX_NUM_REACTIONS 64 // Maximum number of reactions reported in summary stats. #define MAX_NUM_WORKERS 64 +/** File containing the trace binary data. */ +FILE* trace_file = NULL; + /** Struct identifying the influx client. */ influx_client_t influx_client; influx_v2_client_t influx_v2_client; @@ -151,10 +154,14 @@ size_t read_and_write_trace() { if (trace_length == 0) return 0; // Write each line. for (int i = 0; i < trace_length; i++) { + + // Ignore federated traces. + if (trace[i].event_type > federated) continue; + char* reaction_name = "none"; - if (trace[i].reaction_number >= 0) { + if (trace[i].dst_id >= 0) { reaction_name = (char*)malloc(4); - snprintf(reaction_name, 4, "%d", trace[i].reaction_number); + snprintf(reaction_name, 4, "%d", trace[i].dst_id); } // printf("DEBUG: reactor self struct pointer: %p\n", trace[i].pointer); int object_instance = -1; @@ -176,7 +183,7 @@ size_t read_and_write_trace() { INFLUX_MEAS(trace_event_names[trace[i].event_type]), INFLUX_TAG("Reactor", reactor_name), INFLUX_TAG("Reaction", reaction_name), - INFLUX_F_INT("Worker", trace[i].worker), + INFLUX_F_INT("Worker", trace[i].src_id), INFLUX_F_INT("Logical Time", trace[i].logical_time), INFLUX_F_INT("Microstep", trace[i].microstep), INFLUX_F_STR("Trigger Name", trigger_name), @@ -259,7 +266,8 @@ int main(int argc, char* argv[]) { exit(1); } - open_files(filename, NULL); + // Open the trace file. + trace_file = open_file(filename, "r"); if (read_header() >= 0) { size_t num_records = 0, result; diff --git a/util/tracing/trace_util.c b/util/tracing/trace_util.c index f688b560d4..0f97b3bdb9 100644 --- a/util/tracing/trace_util.c +++ b/util/tracing/trace_util.c @@ -37,15 +37,6 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /** Buffer for reading object descriptions. Size limit is BUFFER_SIZE bytes. */ char buffer[BUFFER_SIZE]; -/** File containing the trace binary data. */ -FILE* trace_file = NULL; - -/** File for writing the output data. */ -FILE* output_file = NULL; - -/** File for writing summary statistics. */ -FILE* summary_file = NULL; - /** Buffer for reading trace records. */ trace_record_t trace[TRACE_BUFFER_CAPACITY]; @@ -60,6 +51,13 @@ char* top_level = NULL; object_description_t* object_table; int object_table_size = 0; +typedef struct open_file_t open_file_t; +typedef struct open_file_t { + FILE* file; + open_file_t* next; +} open_file_t; +open_file_t* _open_files = NULL; + /** * Function to be invoked upon exiting. */ @@ -68,82 +66,57 @@ void termination() { for (int i = 0; i < object_table_size; i++) { free(object_table[i].description); } - if (trace_file != NULL) { - fclose(trace_file); - } - if (output_file != NULL) { - fclose(output_file); - } - if (summary_file != NULL) { - fclose(summary_file); + while (_open_files != NULL) { + fclose(_open_files->file); + open_file_t* tmp = _open_files->next; + free(_open_files); + _open_files = tmp; } printf("Done!\n"); } -/** - * Open the trace file and the output file using the given filename. - * This leaves the FILE* pointers in the global variables trace_file and output_file. - * If the extension if "csv", then it also opens a summary_file. - * The filename argument can include path information. - * It can include the ".lft" extension or not. - * The output file will have the same path and name except that the - * extension will be given by the second argument. - * The summary_file, if opened, will have the filename with "_summary.csv" appended. - * @param filename The file name. - * @param output_file_extension The extension to put on the output file name (e.g. "csv"). - * @return A pointer to the file. - */ -void open_files(char* filename, char* output_file_extension) { - // Open the input file for reading. - size_t length = strlen(filename); - if (length > 4 && strcmp(&filename[length - 4], ".lft") == 0) { - // The filename includes the .lft extension. - length -= 4; - } - char trace_file_name[length + 4]; - strncpy(trace_file_name, filename, length); - trace_file_name[length] = 0; - strcat(trace_file_name, ".lft"); - trace_file = fopen(trace_file_name, "r"); - if (trace_file == NULL) { - fprintf(stderr, "No trace file named %s.\n", trace_file_name); +const char PATH_SEPARATOR = +#ifdef _WIN32 + '\\'; +#else + '/'; +#endif + +char* root_name(const char* path) { + if (path == NULL) return NULL; + + // Remove any path. + char* last_separator = strrchr(path, PATH_SEPARATOR); + if (last_separator != NULL) path = last_separator + 1; + + // Allocate and copy name without extension. + char* last_period = strrchr(path, '.'); + size_t length = (last_period == NULL) ? + strlen(path) : last_period - path; + char* result = (char*)malloc(length + 1); + if (result == NULL) return NULL; + strncpy(result, path, length); + result[length] = '\0'; + + return result; +} + +FILE* open_file(const char* path, const char* mode) { + FILE* result = fopen(path, mode); + if (result == NULL) { + fprintf(stderr, "No file named %s.\n", path); usage(); exit(2); } - - // Open the output file for writing. - if (output_file_extension) { - char output_file_name[length + strlen(output_file_extension) + 1]; - strncpy(output_file_name, filename, length); - output_file_name[length] = 0; - strcat(output_file_name, "."); - strcat(output_file_name, output_file_extension); - output_file = fopen(output_file_name, "w"); - if (output_file == NULL) { - fprintf(stderr, "Could not create output file named %s.\n", output_file_name); - usage(); - exit(2); - } - - if (strcmp("csv", output_file_extension) == 0) { - // Also open a summary_file. - char *suffix = "_summary.csv"; - char summary_file_name[length + strlen(suffix) + 1]; - strncpy(summary_file_name, filename, length); - summary_file_name[length] = 0; - strcat(summary_file_name, suffix); - summary_file = fopen(summary_file_name, "w"); - if (summary_file == NULL) { - fprintf(stderr, "Could not create summary file named %s.\n", summary_file_name); - usage(); - exit(2); - } - } - } - - if (atexit(termination) != 0) { - fprintf(stderr, "WARNING: Failed to register termination function!"); + open_file_t* record = (open_file_t*)malloc(sizeof(open_file_t)); + if (record == NULL) { + fprintf(stderr, "Out of memory.\n"); + exit(3); } + record->file = result; + record->next = _open_files; + _open_files = record; + return result; } /** diff --git a/util/tracing/trace_util.h b/util/tracing/trace_util.h index 56eb9fe3e8..dab1f5e989 100644 --- a/util/tracing/trace_util.h +++ b/util/tracing/trace_util.h @@ -36,10 +36,10 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. /** Macro to use when access to trace file fails. */ #define _LF_TRACE_FAILURE(trace_file) \ do { \ - fprintf(stderr, "WARNING: Access to trace file failed.\n"); \ + fprintf(stderr, "ERROR: Access to trace file failed.\n"); \ fclose(trace_file); \ trace_file = NULL; \ - return -1; \ + exit(1); \ } while(0) /** Buffer for reading object descriptions. Size limit is BUFFER_SIZE bytes. */ @@ -73,18 +73,23 @@ extern int object_table_size; extern char* top_level; /** - * Open the trace file and the output file using the given filename. - * This leaves the FILE* pointers in the global variables trace_file and output_file. - * If the extension if "csv", then it also opens a summary_file. - * The filename argument can include path information. - * It can include the ".lft" extension or not. - * The output file will have the same path and name except that the - * extension will be given by the second argument. - * The summary_file, if opened, will have the filename with "_summary.csv" appended. - * @param filename The file name. - * @param output_file_extension The extension to put on the output file name (e.g. "csv"). + * @brief Return the root file name from the given path. + * Given a path to a file, this function returns a dynamically + * allocated string (which you must free) that points to the root + * filename without the preceding path and without the file extension. + * @param path The path including the full filename. + * @return The root name of the file or NULL for failure. */ -void open_files(char* filename, char* output_file_extension); +char* root_name(const char* path); + +/** + * @brief Open the specified file for reading or writing. + * This function records the file for closing at termination. + * @param path The path to the file. + * @param mode "r" for reading and "w" for writing. + * @return A pointer to the open file or NULL for failure. + */ +FILE* open_file(const char* path, const char* mode); /** * Get the description of the object pointed to by the specified pointer. diff --git a/util/tracing/visualization/.gitignore b/util/tracing/visualization/.gitignore new file mode 100644 index 0000000000..ba0430d26c --- /dev/null +++ b/util/tracing/visualization/.gitignore @@ -0,0 +1 @@ +__pycache__/ \ No newline at end of file diff --git a/util/tracing/visualization/README.md b/util/tracing/visualization/README.md new file mode 100644 index 0000000000..82861e9b2a --- /dev/null +++ b/util/tracing/visualization/README.md @@ -0,0 +1,25 @@ +# Trace sequence diagram visualiser + +This is a 1st iteration of a prototyping tool for constructing a sequence diagram +out of the traces. +It operates over the csv files generated by `trace_to_csv`. + +# Running + +Once the `.lft` files collected and tranformed into `csv` files, run: +``` +$ python3 sd_gen.py -r -f ... +``` + +The output is an html file with the svg in it. + +# Current problems + +- The collected traces are not complete. They need to be checked for correcteness as well. +- All arrows are horizontal and can be duplicated. Need further processing to derive the connections +for that. +- The scale needs exploration + + + + diff --git a/util/tracing/visualization/fedsd.py b/util/tracing/visualization/fedsd.py new file mode 100644 index 0000000000..3eb13d11bc --- /dev/null +++ b/util/tracing/visualization/fedsd.py @@ -0,0 +1,314 @@ +''' +Define arrows: + (x1, y1) ==> (x2, y2), when unique result (this arrow will be tilted) + (x1, y1) --> (x2, y2), when a possible result (could be not tilted)? +If not arrow, then triangle with text + +In the dataframe, each row will be marked with one op these values: + - 'arrow': draw a non-dashed arrow + - 'dot': draw a dot only + - 'marked': marked, not to be drawn + - 'pending': pending + - 'adv': for reporting logical time advancing, draw a simple dash +''' + +# Styles to determine appearance: +css_style = ' \ +' + +#!/usr/bin/env python3 +import argparse # For arguments parsing +import pandas as pd # For csv manipulation +from os.path import exists +from pathlib import Path +import math +import fedsd_helper as fhlp + +# Define the arguments to pass in the command line +parser = argparse.ArgumentParser(description='Set of the csv trace files to render.') +parser.add_argument('-r','--rti', type=str, default="rti.csv", + help='RTI csv trace file.') +parser.add_argument('-f','--federates', nargs='+', action='append', + help='List of the federates csv trace files.') + + +''' Clock synchronization error ''' +''' FIXME: There should be a value for each communicating pair ''' +clock_sync_error = 0 + +''' Bound on the network latency ''' +''' FIXME: There should be a value for each communicating pair ''' +network_latency = 100000000 # That is 100us + + +def load_and_process_csv_file(csv_file) : + ''' + Loads and processes the csv entries, based on the type of the actor (if RTI + or federate). + + Args: + * csv_file: String file name + Returns: + * The processed dataframe. + ''' + # Load tracepoints, rename the columns and clean non useful data + df = pd.read_csv(csv_file) + df.columns = ['event', 'reactor', 'self_id', 'partner_id', 'logical_time', 'microstep', 'physical_time', 't', 'ed'] + df = df.drop(columns=['reactor', 't', 'ed']) + + # Remove all the lines that do not contain communication information + # which boils up to having 'RTI' in the 'event' column + df = df[df['event'].str.contains('Sending|Receiving|Scheduler advancing time ends') == True] + df = df.astype({'self_id': 'int', 'partner_id': 'int'}) + + # Add an inout column to set the arrow direction + df['inout'] = df['event'].apply(lambda e: 'in' if 'Receiving' in e else 'out') + + # Prune event names + df['event'] = df['event'].apply(lambda e: fhlp.prune_event_name[e]) + return df + + +if __name__ == '__main__': + args = parser.parse_args() + + # Check if the RTI trace file exists + if (not exists(args.rti)): + print('Error: No RTI csv trace file! Specify with -r argument.') + exit(1) + + # The RTI and each of the federates have a fixed x coordinate. They will be + # saved in a dict + x_coor = {} + actors = [] + actors_names = {} + padding = 50 + spacing = 200 # Spacing between federates + + ############################################################################ + #### RTI trace processing + ############################################################################ + trace_df = load_and_process_csv_file(args.rti) + x_coor[-1] = padding * 2 + actors.append(-1) + actors_names[-1] = "RTI" + # Temporary use + trace_df['x1'] = x_coor[-1] + + ############################################################################ + #### Federates trace processing + ############################################################################ + # Loop over the given list of federates trace files + if (args.federates) : + for fed_trace in args.federates[0]: + if (not exists(fed_trace)): + print('Warning: Trace file ' + fed_trace + ' does not exist! Will resume though') + continue + fed_df = load_and_process_csv_file(fed_trace) + if (not fed_df.empty): + # Get the federate id number + fed_id = fed_df.iloc[-1]['self_id'] + # Add to the list of sequence diagram actors and add the name + actors.append(fed_id) + actors_names[fed_id] = Path(fed_trace).stem + # Derive the x coordinate of the actor + x_coor[fed_id] = (padding * 2) + (spacing * (len(actors)-1)) + fed_df['x1'] = x_coor[fed_id] + # Append into trace_df + trace_df = trace_df.append(fed_df, sort=False, ignore_index=True) + fed_df = fed_df[0:0] + + # Sort all traces by physical time and then reset the index + trace_df = trace_df.sort_values(by=['physical_time']) + trace_df = trace_df.reset_index(drop=True) + + # FIXME: For now, we need to remove the rows with negative physical time values... + # Until the reason behinf such values is investigated. The negative physical + # time is when federates are still in the process of joining + # trace_df = trace_df[trace_df['physical_time'] >= 0] + + # Add the Y column and initialize it with the padding value + trace_df['y1'] = math.ceil(padding * 3 / 2) # Or set a small shift + + ############################################################################ + #### Compute the 'y1' coordinates + ############################################################################ + ppt = 0 # Previous physical time + cpt = 0 # Current physical time + py = 0 # Previous y + min = 15 # Minimum spacing between events when time has not advanced. + scale = 1 # Will probably be set manually + first_pass = True + for index, row in trace_df.iterrows(): + if (not first_pass) : + cpt = row['physical_time'] + # print('cpt = '+str(cpt)+' and ppt = '+str(ppt)) + # From the email: + # Y = T_previous + min + log10(1 + (T - T_previous)*scale) + # But rather think it should be: + if (cpt != ppt) : + py = math.ceil(py + min + (1 + math.log10(cpt - ppt) * scale)) + trace_df.at[index, 'y1'] = py + + ppt = row['physical_time'] + py = trace_df.at[index, 'y1'] + first_pass = False + + ############################################################################ + #### Derive arrows that match sided communications + ############################################################################ + # Intialize all rows as pending to be matched + trace_df['arrow'] = 'pending' + trace_df['x2'] = -1 + trace_df['y2'] = -1 + + # Iterate and check possible sides + for index in trace_df.index: + # If the tracepoint is pending, proceed to look for a match + if (trace_df.at[index,'arrow'] == 'pending') : + # Look for a match only if it is not about advancing time + if (trace_df.at[index,'event'] == 'AdvLT') : + trace_df.at[index,'arrow'] = 'adv' + continue + self_id = trace_df.at[index,'self_id'] + partner_id = trace_df.at[index,'partner_id'] + event = trace_df.at[index,'event'] + logical_time = trace_df.at[index, 'logical_time'] + microstep = trace_df.at[index, 'microstep'] + inout = trace_df.at[index, 'inout'] + + # Match tracepoints + matching_df = trace_df[\ + (trace_df['inout'] != inout) & \ + (trace_df['self_id'] == partner_id) & \ + (trace_df['partner_id'] == self_id) & \ + (trace_df['arrow'] == 'pending') & \ + (trace_df['event'] == event) & \ + (trace_df['logical_time'] == logical_time) & \ + (trace_df['microstep'] == microstep) \ + ] + + if (matching_df.empty) : + # If no matching receiver, than set the arrow to 'dot', + # meaning that only a dot will be rendered + trace_df.loc[index, 'arrow'] = 'dot' + else: + # If there is one or more matching rows, then consider + # the first one, since it is an out -> in arrow, and + # since it is the closet in time + # FIXME: What other possible choices to consider? + if (inout == 'out'): + matching_index = matching_df.index[0] + matching_row = matching_df.loc[matching_index] + trace_df.at[index, 'x2'] = matching_row['x1'] + trace_df.at[index, 'y2'] = matching_row['y1'] + else: + matching_index = matching_df.index[-1] + matching_row = matching_df.loc[matching_index] + trace_df.at[index, 'x2'] = trace_df.at[index, 'x1'] + trace_df.at[index, 'y2'] = trace_df.at[index, 'y1'] + trace_df.at[index, 'x1'] = matching_row['x1'] + trace_df.at[index, 'y1'] = matching_row['y1'] + + # Mark it, so not to consider it anymore + trace_df.at[matching_index, 'arrow'] = 'marked' + + trace_df.at[index, 'arrow'] = 'arrow' + + ############################################################################ + #### Write to svg file + ############################################################################ + svg_width = padding * 2 + (len(actors) - 1) * spacing + padding * 2 + 200 + svg_height = padding + trace_df.iloc[-1]['y1'] + + with open('trace_svg.html', 'w', encoding='utf-8') as f: + # Print header + f.write('\n') + f.write('\n') + f.write('\n\n') + + f.write('\n') + + f.write(css_style) + + # Print the circles and the names + for key in x_coor: + title = actors_names[key] + if (key == -1): + f.write(fhlp.svg_string_comment('RTI Actor and line')) + center = 15 + else: + f.write(fhlp.svg_string_comment('Federate '+str(key)+': ' + title + ' Actor and line')) + center = 5 + f.write(fhlp.svg_string_draw_line(x_coor[key], math.ceil(padding/2), x_coor[key], svg_height, False)) + f.write('\t\n') + f.write('\t'+title+'\n') + + # Now, we need to iterate over the traces to draw the lines + f.write(fhlp.svg_string_comment('Draw interactions')) + for index, row in trace_df.iterrows(): + # For time labels, display them on the left for the RTI, right for everthing else. + anchor = 'start' + if (row['self_id'] < 0): + anchor = 'end' + + # formatted physical time. + # FIXME: Using microseconds is hardwired here. + physical_time = f'{int(row["physical_time"]/1000):,}' + + if (row['event'] in {'FED_ID', 'ACK', 'REJECT', 'ADR_RQ', 'ADR_AD', 'MSG', 'P2P_MSG'}): + label = row['event'] + elif (row['logical_time'] == -1678240241788173894) : + # FIXME: This isn't right. NEVER == -9223372036854775808. + label = row['event'] + '(NEVER)' + else: + label = row['event'] + '(' + f'{int(row["logical_time"]):,}' + ', ' + str(row['microstep']) + ')' + + if (row['arrow'] == 'arrow'): + f.write(fhlp.svg_string_draw_arrow(row['x1'], row['y1'], row['x2'], row['y2'], label, row['event'])) + f.write(fhlp.svg_string_draw_side_label(row['x1'], row['y1'], physical_time, anchor)) + elif (row['arrow'] == 'dot'): + if (row['inout'] == 'in'): + label = "(in) from " + str(row['partner_id']) + ' ' + label + else : + label = "(out) to " + str(row['partner_id']) + ' ' + label + + if (anchor == 'end'): + f.write(fhlp.svg_string_draw_side_label(row['x1'], row['y1'], physical_time, anchor)) + f.write(fhlp.svg_string_draw_dot(row['x1'], row['y1'], label)) + else: + f.write(fhlp.svg_string_draw_dot_with_time(row['x1'], row['y1'], physical_time, label)) + + elif (row['arrow'] == 'marked'): + f.write(fhlp.svg_string_draw_side_label(row['x1'], row['y1'], physical_time, anchor)) + + elif (row['arrow'] == 'adv'): + f.write(fhlp.svg_string_draw_adv(row['x1'], row['y1'], label)) + + f.write('\n\n\n') + + # Print footer + f.write('\n') + f.write('\n') + + # Write to a csv file, just to double check + trace_df.to_csv('all.csv', index=True) \ No newline at end of file diff --git a/util/tracing/visualization/fedsd_helper.py b/util/tracing/visualization/fedsd_helper.py new file mode 100644 index 0000000000..804341f117 --- /dev/null +++ b/util/tracing/visualization/fedsd_helper.py @@ -0,0 +1,241 @@ +import math + +# Disctionary for pruning event names. Usefule for tracepoint matching and +# communication rendering +prune_event_name = { + "Sending ACK": "ACK", + "Sending TIMESTAMP": "TIMESTAMP", + "Sending NET": "NET", + "Sending LTC": "LTC", + "Sending STOP_REQ": "STOP_REQ", + "Sending STOP_REQ_REP": "STOP_REQ_REP", + "Sending STOP_GRN": "STOP_GRN", + "Sending FED_ID": "FED_ID", + "Sending PTAG": "PTAG", + "Sending TAG": "TAG", + "Sending REJECT": "REJECT", + "Sending RESIGN": "RESIGN", + "Sending PORT_ABS": "ABS", + "Sending CLOSE_RQ": "CLOSE_RQ", + "Sending TAGGED_MSG": "T_MSG", + "Sending P2P_TAGGED_MSG": "P2P_T_MSG", + "Sending MSG": "MSG", + "Sending P2P_MSG": "P2P_MSG", + "Sending ADR_AD": "ADR_AD", + "Sending ADR_QR": "ADR_QR", + "Receiving ACK": "ACK", + "Receiving TIMESTAMP": "TIMESTAMP", + "Receiving NET": "NET", + "Receiving LTC": "LTC", + "Receiving STOP_REQ": "STOP_REQ", + "Receiving STOP_REQ_REP": "STOP_REQ_REP", + "Receiving STOP_GRN": "STOP_GRN", + "Receiving FED_ID": "FED_ID", + "Receiving PTAG": "PTAG", + "Receiving TAG": "TAG", + "Receiving REJECT": "REJECT", + "Receiving RESIGN": "RESIGN", + "Receiving PORT_ABS": "ABS", + "Receiving CLOSE_RQ": "CLOSE_RQ", + "Receiving TAGGED_MSG": "T_MSG", + "Receiving P2P_TAGGED_MSG": "P2P_T_MSG", + "Receiving MSG": "MSG", + "Receiving P2P_MSG": "P2P_MSG", + "Receiving ADR_AD": "ADR_AD", + "Receiving ADR_QR": "ADR_QR", + "Receiving UNIDENTIFIED": "UNIDENTIFIED", + "Scheduler advancing time ends": "AdvLT" +} + +prune_event_name.setdefault(" ", "UNIDENTIFIED") + +################################################################################ +### Routines to write to csv file +################################################################################ + +def svg_string_draw_line(x1, y1, x2, y2, type=''): + ''' + Constructs the svg html string to draw a line from (x1, y1) to (x2, y2). + + Args: + * x1: Int X coordinate of the source point + * y1: Int Y coordinate of the source point + * x2: Int X coordinate of the sink point + * y2: Int Y coordinate of the sink point + * type: The type of the message (for styling) + Returns: + * String: the svg string of the line© + ''' + str_line = '\t\n' + return str_line + + +def svg_string_draw_arrow_head(x1, y1, x2, y2, type='') : + ''' + Constructs the svg html string to draw the arrow end + + Args: + * x1: Int X coordinate of the source point + * y1: Int Y coordinate of the source point + * x2: Int X coordinate of the sink point + * y2: Int Y coordinate of the sink point + * type: The type (for styling) + Returns: + * String: the svg string of the triangle + ''' + + rotation = - math.ceil(math.atan((x2-x1)/(y2-y1)) * 180 / 3.14) - 90 + style = '' + if (type): + style = ' class="'+type+'"' + + str_line = '' + if (x1 > x2) : + str_line = '\t\n' + else : + str_line = '\t\n' + + return str_line + + +def svg_string_draw_label(x1, y1, x2, y2, label) : + ''' + Computes the rotation angle of the text and then constructs the svg string. + + Args: + * x1: Int X coordinate of the source point + * y1: Int Y coordinate of the source point + * x2: Int X coordinate of the sink point + * y2: Int Y coordinate of the sink point + * label: The label to draw + Returns: + * String: the svg string of the text + ''' + # FIXME: Need further improvement, based of the position of the arrows + # FIXME: Rotation value is not that accurate. + if (x2 < x1) : + # Left-going arrow. + rotation = - math.ceil(math.atan((x2-x1)/(y2-y1)) * 180 / 3.14) - 90 + str_line = '\t'+label+'\n' + else : + # Right-going arrow. + rotation = - math.ceil(math.atan((x1-x2)/(y1-y2)) * 180 / 3.14) + 90 + str_line = '\t'+label+'\n' + #print('rot = '+str(rotation)+' x1='+str(x1)+' y1='+str(y1)+' x2='+str(x2)+' y2='+str(y2)) + return str_line + + +def svg_string_draw_arrow(x1, y1, x2, y2, label, type=''): + ''' + Constructs the svg html string to draw the arrow from (x1, y1) to (x2, y2). + The arrow end is constructed, together with the label + + Args: + * x1: Int X coordinate of the source point + * y1: Int Y coordinate of the source point + * x2: Int X coordinate of the sink point + * y2: Int Y coordinate of the sink point + * label: String Label to draw on top of the arrow + * type: The type of the message + Returns: + * String: the svg string of the arrow + ''' + str_line1 = svg_string_draw_line(x1, y1, x2, y2, type) + str_line2 = svg_string_draw_arrow_head(x1, y1, x2, y2, type) + str_line3 = svg_string_draw_label(x1, y1, x2, y2, label) + return str_line1 + str_line2 + str_line3 + +def svg_string_draw_side_label(x, y, label, anchor="start") : + ''' + Put a label to the right of the x, y point, + unless x is small, in which case put it to the left. + + Args: + * x: Int X coordinate of the source point + * y: Int Y coordinate of the source point + * label: Label to put by the point. + * anchor: One of "start", "middle", or "end" to specify the text-anchor. + Returns: + * String: the svg string of the text + ''' + offset = 5 + if (anchor == 'end'): + offset = -5 + elif (anchor == 'middle'): + offset = 0 + str_line = '\t'+label+'\n' + + return str_line + +def svg_string_comment(comment): + ''' + Constructs the svg html string to write a comment into an svg file. + + Args: + * comment: String Comment to add + Returns: + * String: the svg string of the comment + ''' + str_line = '\n\t\n' + return str_line + + +def svg_string_draw_dot(x, y, label) : + ''' + Constructs the svg html string to draw at a dot. + + Args: + * x: Int X coordinate of the dot + * y: Int Y coordinate of the dot + * label: String to draw + Returns: + * String: the svg string of the triangle + ''' + str_line = '' + str_line = '\t\n' + str_line = str_line + '\t'+label+'\n' + return str_line + +def svg_string_draw_dot_with_time(x, y, time, label) : + ''' + Constructs the svg html string to draw at a dot with a prefixed physical time. + + Args: + * x: Int X coordinate of the dot + * y: Int Y coordinate of the dot + * time: The time + * label: String to draw + Returns: + * String: the svg string of the triangle + ''' + str_line = '' + str_line = '\t\n' + str_line = str_line + '\t '+time+': '+label+'\n' + return str_line + +def svg_string_draw_adv(x, y, label) : + ''' + Constructs the svg html string to draw at a dash, meaning that logical time is advancing there. + + Args: + * x: Int X coordinate of the dash + * y: Int Y coordinate of the dash + * label: String to draw + Returns: + * String: the svg string of the triangle + ''' + str_line1 = svg_string_draw_line(x-5, y, x+5, y, "ADV") + str_line2 = svg_string_draw_side_label(x, y, label) + return str_line1 + str_line2 \ No newline at end of file From e8a1b0522b68c81d8d275390342799378010bc11 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 11:15:40 +0100 Subject: [PATCH 076/709] Deleted spurious empty files --- thread_active | 0 watchdog_function | 0 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 thread_active delete mode 100644 watchdog_function diff --git a/thread_active b/thread_active deleted file mode 100644 index e69de29bb2..0000000000 diff --git a/watchdog_function b/watchdog_function deleted file mode 100644 index e69de29bb2..0000000000 From 534a003d431eefef1151a31e0ecab9f79a40043e Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 11:37:16 +0100 Subject: [PATCH 077/709] Removed unused imports --- org.lflang/src/org/lflang/ASTUtils.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index fc49242322..19dcc68ca0 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -32,7 +32,6 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.Set; import java.util.function.Predicate; import java.util.regex.Matcher; @@ -60,8 +59,6 @@ import org.lflang.generator.InvalidSourceException; import org.lflang.lf.Action; import org.lflang.lf.Assignment; -import org.lflang.lf.AttrParm; -import org.lflang.lf.Attribute; import org.lflang.lf.Code; import org.lflang.lf.Connection; import org.lflang.lf.Element; From cb06dffb64a3115da6edadb8dfc515695a8e9b15 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 11:37:40 +0100 Subject: [PATCH 078/709] Group watchdog with action --- org.lflang/src/org/lflang/LinguaFranca.xtext | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index 870b1ad049..71213d36c2 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -175,10 +175,10 @@ Mode: (stateVars+=StateVar) | (timers+=Timer) | (actions+=Action) | + (watchdogs+=Watchdog) | (instantiations+=Instantiation) | (connections+=Connection) | - (reactions+=Reaction) | - (watchdogs+=Watchdog) + (reactions+=Reaction) )* '}'; // Action that has either a physical or logical origin. From 302f690158d5aa85862650551bbbc8caf583735a Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 11:37:58 +0100 Subject: [PATCH 079/709] Removed unused imports --- .../org/lflang/federated/generator/FederateInstance.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index f3768cec7c..8ed3b63d70 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -25,7 +25,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.federated.generator; -import java.io.File; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; @@ -40,17 +39,13 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.ASTUtils; import org.lflang.ErrorReporter; -import org.lflang.FileConfig; -import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TimeValue; import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.generator.ActionInstance; -import org.lflang.generator.GeneratorUtils; import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; -import org.lflang.generator.SubContext; import org.lflang.generator.TriggerInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; @@ -70,7 +65,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.TriggerRef; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; -import org.lflang.lf.Watchdog; import com.google.common.base.Objects; From 7b05cd6d7edbf01179e175276187fbef5ecc9eac Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 11:38:29 +0100 Subject: [PATCH 080/709] Removed non-substantive change --- org.lflang/src/org/lflang/generator/ReactionInstance.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/src/org/lflang/generator/ReactionInstance.java index 3ce7f6ceaa..cf9dce7013 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstance.java @@ -221,7 +221,7 @@ public ReactionInstance( * Deadline for this reaction instance, if declared. */ public DeadlineInstance declaredDeadline; - + /** * Sadly, we have no way to mark reaction "unordered" in the AST, * so instead, we use a magic comment at the start of the reaction body. From 673a7fcd58329d2a013ffc748638c6e878ff5eb3 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 11:39:41 +0100 Subject: [PATCH 081/709] Removed unused or redundant imports --- org.lflang/src/org/lflang/generator/ReactorInstance.java | 5 ----- 1 file changed, 5 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index cc049f971c..395bb90d6d 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -35,8 +35,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Map; import java.util.Set; -import org.eclipse.emf.ecore.util.EcoreUtil; - import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; @@ -49,7 +47,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Expression; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; -import org.lflang.lf.LfFactory; import org.lflang.lf.Mode; import org.lflang.lf.Output; import org.lflang.lf.Parameter; @@ -63,8 +60,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Variable; import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; -import org.lflang.lf.Watchdog; - /** * Representation of a compile-time instance of a reactor. From 91086adfabc0612caa763b7bd4cb034b0456e918 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 15:26:45 +0100 Subject: [PATCH 082/709] Made this a real test --- test/C/src/Watchdog.lf | 65 +++++++++++++++++++++++++++++++----------- 1 file changed, 48 insertions(+), 17 deletions(-) diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index e3d7f6cb41..b44a16f22c 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -1,33 +1,64 @@ -target C +/** + * Test watchdog. + * This test starts a watchdog timer of 150ms every 100ms. + * Half the time, it then sleeps after starting the watchdog so that + * the watchdog expires. There should be a total of five watchdog + * expirations. + * @author Benjamin Asch + * @author Edward A. Lee + */ +target C { + timeout: 1100ms +} -reactor Watcher { - input x: int - output d: int // Produced if the deadline is violated. +reactor Watcher(timeout:time(150ms)) { + timer t(100ms, 100ms) // Offset ameliorates startup time. + output d: int // Produced if the watchdog triggers. + state alternating:bool(false) + state count:int(0) - watchdog poodle(10 msec) {= + watchdog poodle(timeout) {= instant_t p = lf_time_physical_elapsed() - lf_time_logical_elapsed(); - printf("Deadline missed! Lag: %lld (too late by %lld nsecs)\n", p, p-500000); + lf_print("Watchdog timed out! Lag: %lld (too late by " PRINTF_TIME " ns)", p, p - self->timeout); + self->count++; =} - reaction(x) -> poodle, d {= + reaction(t) -> poodle, d {= lf_watchdog_start(poodle, 0); - printf("Normal reaction.\n"); + lf_print("Watchdog started at physical time " PRINTF_TIME, lf_time_physical_elapsed()); + lf_print("Will expire at " PRINTF_TIME, lf_time_logical_elapsed() + self->timeout); + if (self->alternating) { + lf_sleep(MSEC(160)); + } + self->alternating = !self->alternating; + =} + + reaction(poodle) -> d {= + lf_set(d, 1); + =} + + reaction(shutdown) -> poodle {= + // FIXME: There needs to be an lf_watchdog_stop() defined. + _lf_watchdog_stop(poodle); + if (self->count != 5) { + lf_print_error_and_exit("Watchdog expired %d times. Expected 5.", self->count); + } =} } main reactor { logical action a + state count:int(0) + w = new Watcher() - reaction(startup) -> w.x, a {= - lf_set(w.x, 0); - lf_schedule(a, 0); + reaction(w.d) {= + lf_print("*** Watcher reactor produced an output."); + self->count++; =} - - reaction(a) -> w.x {= - lf_set(w.x, 0); - lf_nanosleep(MSEC(90)); + reaction(shutdown) {= + if (self->count != 4) { + lf_print_error_and_exit("Watchdog produced output %d times. Expected 4.", self->count); + } =} - - reaction(w.d) {= printf("Deadline reactor produced an output.\n"); =} } From c20e711b19a439deee5d88daf46283a555c920ab Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 15:31:04 +0100 Subject: [PATCH 083/709] Made fields private and rearranged --- .../lflang/generator/WatchdogInstance.java | 38 ++++++++----------- 1 file changed, 16 insertions(+), 22 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index 2a2e11a3ad..001246cf2f 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -13,16 +13,15 @@ public class WatchdogInstance { /** - * Create a new watchdog instance associated with the given reaction + * Create a new watchdog instance associated with the given reactor * instance. */ public WatchdogInstance(Watchdog definition, ReactorInstance reactor) { if (definition.getTimeout() != null) { - // WATCHDOG QUESTION - // How does this .getTimeValue work? Where is expression coming from - // versus other time parameters? + // Get the timeout value given in the watchdog declaration. this.timeout = reactor.getTimeValue(definition.getTimeout()); } else { + // NOTE: The grammar does not allow the timeout to be omitted, so this should not occur. this.timeout = TimeValue.ZERO; } @@ -31,6 +30,9 @@ public WatchdogInstance(Watchdog definition, ReactorInstance reactor) { this.reactor = reactor; } + ////////////////////////////////////////////////////// + //// Public methods. + public String getName() { return this.name; } @@ -47,27 +49,19 @@ public ReactorInstance getReactor() { return this.reactor; } - ////////////////////////////////////////////////////// - //// Public fields. - + @Override + public String toString() { + return "WatchdogInstance " + name + "(" + timeout.toString() + ")"; + } - public final TimeValue timeout; + ////////////////////////////////////////////////////// + //// Private fields. - /** - * The watchdog name. - */ - public final String name; + private final TimeValue timeout; - public final Watchdog definition; + private final String name; - public final ReactorInstance reactor; + private final Watchdog definition; - ////////////////////////////////////////////////////// - //// Public methods. - - //FIXME: unsure of use or need for watchdogs - @Override - public String toString() { - return "WatchdogInstance " + timeout.toString(); - } + private final ReactorInstance reactor; } From bb2a21d38e9abfc906d25b00ed64223af2eefdbc Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 15:32:13 +0100 Subject: [PATCH 084/709] Fixed hasWatchdogs, which was always returning true --- .../src/org/lflang/generator/c/CGenerator.java | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index e7ce2439f8..fbaec56d97 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -36,9 +36,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import static org.lflang.ASTUtils.toText; import static org.lflang.util.StringUtil.addDoubleQuotes; -import java.io.BufferedWriter; import java.io.File; -import java.io.FileWriter; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; @@ -81,7 +79,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.generator.ReactorInstance; import org.lflang.generator.WatchdogInstance; -import org.lflang.generator.SubContext; import org.lflang.generator.TargetTypes; import org.lflang.generator.TimerInstance; @@ -839,7 +836,8 @@ private boolean hasDeadlines(List reactors) { private boolean hasWatchdogs() { for (Reactor reactor : reactors) { - if (ASTUtils.allWatchdogs(reactor) != null) { + List watchdogs = ASTUtils.allWatchdogs(reactor); + if (watchdogs != null && !watchdogs.isEmpty()) { return true; } } @@ -1526,9 +1524,8 @@ private void recordWatchdogs(ReactorInstance instance) { var reactorRef = CUtil.reactorRef(instance); // temp.pr("#ifdef LF_THREADED"); for (WatchdogInstance watchdog : instance.watchdogs) { - temp.pr(" _lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); - temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); - temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); + temp.pr("_lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); + temp.pr(reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); watchdogCount += 1; foundOne = true; } @@ -1903,8 +1900,6 @@ protected void generateStateVariableInitializations(ReactorInstance instance) { * specified reactor instance. * @param instance The reactor instance. */ - // WATCHDOG QUESTION: Why do we wait to set the deadline instead of defining - // it in the constructor of the reactor? private void generateSetDeadline(ReactorInstance instance) { for (ReactionInstance reaction : instance.reactions) { var selfRef = CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+reaction.index; From 6d33efc3a61a51e66707749b7e674039a413c2aa Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 15:32:39 +0100 Subject: [PATCH 085/709] Regularized function pointer --- org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 344209c3b8..4193a7c522 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -150,7 +150,7 @@ public static void generateWatchdogStruct( "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", "self->_lf_watchdog_"+watchdogName+".thread_active = false;", // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", - "self->_lf_watchdog_"+watchdogName+".watchdog_function = &("+watchdogFunctionName+");" + "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";" )); // constructorCode.pr("#endif"); // WATCHDOG QUESTION 6: should I be initializing mutex in this constructor? From 5e31d322765f6bc1706b12b6b016028c4eca6ff1 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 25 Mar 2023 15:34:50 +0100 Subject: [PATCH 086/709] Align reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 10c275b99a..24c0dc700b 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 10c275b99a01802f00168b92d4e9068fdf9b34b6 +Subproject commit 24c0dc700bfde4ddf8a592fef82a837528006340 From c1eafa7c827b7885ca92a31ca5119dca2515bd73 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Mon, 27 Mar 2023 21:47:39 +0500 Subject: [PATCH 087/709] [C-Generics] - Build Fixes - Allowing Template Types to be defined for in/out ports or state variables - Reordering definitions with includes Signed-off-by: mkhubaibumer --- .../generator/ReactionInstanceGraph.java | 4 +- .../org/lflang/generator/ReactorInstance.java | 14 ++++--- .../generator/c/CConstructorGenerator.java | 10 ++--- .../org/lflang/generator/c/CGenerator.java | 37 +++++++++++-------- .../lflang/generator/c/CMethodGenerator.java | 3 +- .../c/CReactorHeaderFileGenerator.java | 21 ++++++----- .../src/org/lflang/generator/c/CUtil.java | 15 +++++++- .../generator/c/TypeParameterizedReactor.java | 2 +- .../generator/python/PythonGenerator.java | 20 +++++----- 9 files changed, 76 insertions(+), 50 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java b/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java index 3422ee0d50..a1598bff0c 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java @@ -411,7 +411,7 @@ public String toDOT() { var currentLevelNodes = groupedNodes.get(level); for (var node: currentLevelNodes) { // Draw the node - var label = CUtil.getName(node.getReaction().getParent().reactorDefinition) + "." + node.getReaction().getName(); + var label = CUtil.getName(node.getReaction().getParent().tpr) + "." + node.getReaction().getName(); // Need a positive number to name the nodes in GraphViz var labelHashCode = label.hashCode() & 0xfffffff; dotRepresentation.pr(" node_" + labelHashCode + " [label=\""+ label +"\"];"); @@ -419,7 +419,7 @@ public String toDOT() { // Draw the edges var downstreamNodes = getDownstreamAdjacentNodes(node); for (var downstreamNode: downstreamNodes) { - var downstreamLabel = CUtil.getName(downstreamNode.getReaction().getParent().reactorDefinition) + "." + downstreamNode.getReaction().getName(); + var downstreamLabel = CUtil.getName(downstreamNode.getReaction().getParent().tpr) + "." + downstreamNode.getReaction().getName(); edges.append(" node_" + labelHashCode + " -> node_" + (downstreamLabel.hashCode() & 0xfffffff) + ";\n" ); diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index af295818b3..0a5c9e0b85 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -767,11 +767,11 @@ protected TriggerInstance getOrCreateBuiltinTrigger(Buil * @param reporter An error reporter. * @param desiredDepth The depth to which to expand the hierarchy. */ - private ReactorInstance( - Instantiation definition, - ReactorInstance parent, - ErrorReporter reporter, - int desiredDepth) { + public ReactorInstance( + Instantiation definition, + ReactorInstance parent, + ErrorReporter reporter, + int desiredDepth) { super(definition, parent); this.reporter = reporter; this.reactorDeclaration = definition.getReactorClass(); @@ -865,6 +865,10 @@ private ReactorInstance( } } + public TypeParameterizedReactor getTypeParameterizedReactor() { + return this.tpr; + } + ////////////////////////////////////////////////////// //// Private methods. diff --git a/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java b/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java index 8944fd0796..41731106c3 100644 --- a/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java @@ -15,12 +15,12 @@ public class CConstructorGenerator { * go into the constructor. */ public static String generateConstructor( - Reactor reactor, + TypeParameterizedReactor tpr, String constructorCode ) { - var structType = CUtil.selfType(reactor); + var structType = CUtil.selfType(tpr); var code = new CodeBuilder(); - code.pr(structType+"* new_"+CUtil.getName(reactor)+"() {"); + code.pr(structType+"* new_"+CUtil.getName(tpr)+"() {"); code.indent(); code.pr(structType+"* self = ("+structType+"*)_lf_new_reactor(sizeof("+structType+"));"); code.pr(constructorCode); @@ -30,7 +30,7 @@ public static String generateConstructor( return code.toString(); } - public static String generateConstructorPrototype(Reactor reactor) { - return CUtil.selfType(reactor)+"* new_"+CUtil.getName(reactor)+"();"; + public static String generateConstructorPrototype(TypeParameterizedReactor tpr) { + return CUtil.selfType(tpr)+"* new_"+CUtil.getName(tpr)+"();"; } } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 0b5602d9d9..282d73d45d 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -939,9 +939,9 @@ private void generateHeaders() throws IOException { fileConfig.getIncludePath(), false ); - for (Reactor r : reactors) { - CReactorHeaderFileGenerator.doGenerate(types, r, fileConfig, this::generateAuxiliaryStructs, this::generateTopLevelPreambles); - } +// for (var r : reactors) { + CReactorHeaderFileGenerator.doGenerate(types, this.main.tpr, fileConfig, this::generateAuxiliaryStructs, this::generateTopLevelPreambles); +// } FileUtil.copyDirectory(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); } @@ -1034,12 +1034,13 @@ private void generateReactorClass(TypeParameterizedReactor tpr) throws IOExcepti header.pr(generateTopLevelPreambles(tpr.r())); generateUserPreamblesForReactor(tpr.r(), src); generateReactorClassBody(tpr, header, src); + tpr.typeArgs().entrySet().forEach(it -> header.pr("#undef " + it.getKey())); header.pr("#endif // " + guardMacro); FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" - : (CCppMode ? ".cpp" : ".c"); + : CCppMode ? ".cpp" : ".c"; FileUtil.writeToFile(src.toString(), fileConfig.getSrcGenPath().resolve( - CUtil.getName(reactor) + extension), true); + CUtil.getName(tpr) + extension), true); } protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String headerName, CodeBuilder header, CodeBuilder src) { @@ -1047,7 +1048,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String src.pr("extern \"C\" {"); header.pr("extern \"C\" {"); } - tpr.typeArgs().entrySet().forEach(it -> src.pr("#define " + it.getKey() + " " + ASTUtils.toText(it.getValue()))); + tpr.typeArgs().entrySet().forEach(it -> header.pr("#define " + it.getKey() + " " + ASTUtils.toText(it.getValue()))); header.pr("#include \"include/core/reactor.h\""); src.pr("#include \"include/api/api.h\""); src.pr("#include \"include/api/set.h\""); @@ -1058,6 +1059,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String } src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(fileConfig, tpr.r()) + "\""); src.pr("#include \"" + headerName + "\""); + tpr.typeArgs().entrySet().forEach(it -> src.pr("#define " + it.getKey() + " " + ASTUtils.toText(it.getValue()))); new HashSet<>(ASTUtils.allInstantiations(tpr.r())).stream() .map(TypeParameterizedReactor::new).map(CUtil::getName) .map(name -> "#include \"" + name + ".h\"") @@ -1068,11 +1070,11 @@ private void generateReactorClassBody(TypeParameterizedReactor tpr, CodeBuilder // Some of the following methods create lines of code that need to // go into the constructor. Collect those lines of code here: var constructorCode = new CodeBuilder(); - generateAuxiliaryStructs(header, reactor, false); - generateSelfStruct(header, reactor, constructorCode); - generateMethods(src, reactor); - generateReactions(src, reactor); - generateConstructor(src, header, reactor, constructorCode); + generateAuxiliaryStructs(header, tpr, false); + generateSelfStruct(header, tpr, constructorCode); + generateMethods(src, tpr.r()); + generateReactions(src, tpr.r()); + generateConstructor(src, header, tpr, constructorCode); } /** @@ -1097,16 +1099,16 @@ protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) /** * Generate a constructor for the specified reactor in the specified federate. - * @param reactor The parsed reactor data structure. + * @param tpr The parsed reactor data structure. * @param constructorCode Lines of code previously generated that need to * go into the constructor. */ protected void generateConstructor( - CodeBuilder src, CodeBuilder header, Reactor reactor, CodeBuilder constructorCode + CodeBuilder src, CodeBuilder header, TypeParameterizedReactor tpr, CodeBuilder constructorCode ) { - header.pr(CConstructorGenerator.generateConstructorPrototype(reactor)); + header.pr(CConstructorGenerator.generateConstructorPrototype(tpr)); src.pr(CConstructorGenerator.generateConstructor( - reactor, + tpr, constructorCode.toString() )); } @@ -1363,7 +1365,7 @@ private void generateInteractingContainedReactors( /** * This function is provided to allow extensions of the CGenerator to append the structure of the self struct * @param body The body of the self struct - * @param decl The reactor declaration for the self struct + * @param reactor The reactor declaration for the self struct * @param constructorCode Code that is executed when the reactor is instantiated */ protected void generateSelfStructExtension( @@ -1650,6 +1652,9 @@ public void processProtoFile(String filename) { public static String variableStructType(Variable variable, TypeParameterizedReactor tpr, boolean userFacing) { return (userFacing ? tpr.getName().toLowerCase() : CUtil.getName(tpr)) +"_"+variable.getName()+"_t"; } + public static String variableStructType(Variable variable, Reactor r, boolean userFacing) { + return (userFacing ? r.getName().toLowerCase() : CUtil.getName(r)) +"_"+variable.getName()+"_t"; + } /** * Construct a unique type for the struct of the specified diff --git a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java index a4e3dba149..5f8a4d6ad1 100644 --- a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java @@ -5,6 +5,7 @@ import org.lflang.ASTUtils; import org.lflang.InferredType; import org.lflang.generator.CodeBuilder; +import org.lflang.generator.ReactorInstance; import org.lflang.lf.Method; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; @@ -67,7 +68,7 @@ public static String generateMethod( code.indent(); // Define the "self" struct. - String structType = CUtil.selfType(ASTUtils.toDefinition(decl)); + String structType = CUtil.selfType((ReactorInstance) ASTUtils.toDefinition(decl)); // A null structType means there are no inputs, state, // or anything else. No need to declare it. if (structType != null) { diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index b947f3ca67..92318c0150 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -16,6 +16,7 @@ import org.lflang.lf.Reactor; import org.lflang.lf.StateVar; import org.lflang.lf.TriggerRef; +import org.lflang.lf.Type; import org.lflang.lf.TypedVariable; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; @@ -24,7 +25,7 @@ public class CReactorHeaderFileGenerator { public interface GenerateAuxiliaryStructs { - void generate(CodeBuilder b, Reactor r, boolean userFacing); + void generate(CodeBuilder b, TypeParameterizedReactor r, boolean userFacing); } public static Path outputPath(CFileConfig fileConfig, Reactor r) { @@ -33,19 +34,19 @@ public static Path outputPath(CFileConfig fileConfig, Reactor r) { .resolve(r.getName() + ".h"); } - public static void doGenerate(CTypes types, Reactor r, CFileConfig fileConfig, GenerateAuxiliaryStructs generator, Function topLevelPreamble) throws IOException { - String contents = generateHeaderFile(types, r, generator, topLevelPreamble.apply(r)); - FileUtil.writeToFile(contents, fileConfig.getIncludePath().resolve(outputPath(fileConfig, r))); + public static void doGenerate(CTypes types, TypeParameterizedReactor tpr, CFileConfig fileConfig, GenerateAuxiliaryStructs generator, Function topLevelPreamble) throws IOException { + String contents = generateHeaderFile(types, tpr, generator, topLevelPreamble.apply(tpr.r())); + FileUtil.writeToFile(contents, fileConfig.getIncludePath().resolve(outputPath(fileConfig, tpr.r()))); } - private static String generateHeaderFile(CTypes types, Reactor r, GenerateAuxiliaryStructs generator, String topLevelPreamble) { + private static String generateHeaderFile(CTypes types, TypeParameterizedReactor tpr, GenerateAuxiliaryStructs generator, String topLevelPreamble) { CodeBuilder builder = new CodeBuilder(); - appendIncludeGuard(builder, r); + appendIncludeGuard(builder, tpr.r()); builder.pr(topLevelPreamble); appendPoundIncludes(builder); - appendSelfStruct(builder, types, r); - generator.generate(builder, r, true); - for (Reaction reaction : r.getReactions()) { - appendSignature(builder, types, reaction, r); + appendSelfStruct(builder, types, tpr.r()); + generator.generate(builder, tpr, true); + for (Reaction reaction : tpr.r().getReactions()) { + appendSignature(builder, types, reaction, tpr.r()); } builder.pr("#endif"); return builder.getCode(); diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index b92f93023d..15097b6205 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -154,6 +154,13 @@ public static String getName(TypeParameterizedReactor reactor) { } return name; } + public static String getName(Reactor reactor) { + String name = reactor.getName().toLowerCase() + reactor.hashCode(); + if (reactor.isMain()) { + return name + "_main"; + } + return name; + } /** * Return a reference to the specified port. @@ -522,10 +529,16 @@ public static String selfType(TypeParameterizedReactor reactor) { } return "_" + CUtil.getName(reactor) + "_self_t"; } + public static String selfType(Reactor reactor) { + if (reactor.isMain()) { + return "_" + CUtil.getName(reactor) + "_main_self_t"; + } + return "_" + CUtil.getName(reactor) + "_self_t"; + } /** Construct a unique type for the "self" struct of the class of the given reactor. */ public static String selfType(ReactorInstance instance) { - return selfType(ASTUtils.toDefinition(instance.getDefinition().getReactorClass())); + return selfType(instance.tpr); } /** diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 9e79a65728..281139c4af 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -36,6 +36,6 @@ public String getName() { @Override public int hashCode() { - return r.hashCode() * 31 + typeArgs.hashCode(); + return Math.abs(r.hashCode() * 31 + typeArgs.hashCode()); } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index b20a5d9de2..fcb1c19595 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -55,6 +55,7 @@ import org.lflang.generator.c.CCmakeGenerator; import org.lflang.generator.c.CGenerator; import org.lflang.generator.c.CUtil; +import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; import org.lflang.lf.Code; import org.lflang.lf.Input; @@ -64,6 +65,7 @@ import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; +import org.lflang.lf.Type; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; import org.lflang.util.StringUtil; @@ -354,16 +356,16 @@ public void processProtoFile(String filename) { */ @Override public void generateAuxiliaryStructs( - CodeBuilder builder, Reactor r, boolean userFacing + CodeBuilder builder, TypeParameterizedReactor tpr, boolean userFacing ) { - for (Input input : ASTUtils.allInputs(r)) { - generateAuxiliaryStructsForPort(builder, r, input); + for (Input input : ASTUtils.allInputs(tpr.r())) { + generateAuxiliaryStructsForPort(builder, tpr.r(), input); } - for (Output output : ASTUtils.allOutputs(r)) { - generateAuxiliaryStructsForPort(builder, r, output); + for (Output output : ASTUtils.allOutputs(tpr.r())) { + generateAuxiliaryStructsForPort(builder, tpr.r(), output); } - for (Action action : ASTUtils.allActions(r)) { - generateAuxiliaryStructsForAction(builder, r, action); + for (Action action : ASTUtils.allActions(tpr.r())) { + generateAuxiliaryStructsForAction(builder, tpr.r(), action); } } @@ -517,9 +519,9 @@ protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) } @Override - protected void generateReactorClassHeaders(Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { + protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String headerName, CodeBuilder header, CodeBuilder src) { header.pr(PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors)); - super.generateReactorClassHeaders(reactor, headerName, header, src); + super.generateReactorClassHeaders(tpr, headerName, header, src); } /** From 9cabad27f5c8214af7f4b4b2bf5113ce5fa1d3f5 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 28 Mar 2023 15:00:25 +0200 Subject: [PATCH 088/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index b260ebc83c..fe5e6c2d1c 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit b260ebc83cea97335e984d1eb26d6b581e900280 +Subproject commit fe5e6c2d1cbc38b46b7298facb5f77e5ba6f387c From 1dfb39d49dcd32b116e07f3e8964037d6898176a Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Wed, 29 Mar 2023 15:58:50 +0500 Subject: [PATCH 089/709] [C-Generics] HashCode missmatch bug --- .../src/org/lflang/generator/c/CReactionGenerator.java | 4 ++-- .../org/lflang/generator/python/PythonActionGenerator.java | 5 +++-- .../src/org/lflang/generator/python/PythonGenerator.java | 6 +++--- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 051540bbf6..23818cb2ef 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -758,9 +758,9 @@ public static void generateReactionAndTriggerStructs( "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", - (reaction.eContainer() instanceof Mode ? + reaction.eContainer() instanceof Mode ? "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+reactor.getModes().indexOf((Mode) reaction.eContainer())+"];" : - "self->_lf__reaction_"+reactionCount+".mode = NULL;") + "self->_lf__reaction_"+reactionCount+".mode = NULL;" )); // Increment the reactionCount even if the reaction is not in the federate // so that reaction indices are consistent across federates. diff --git a/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java index a2a149f522..13dbed0f0f 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java @@ -1,13 +1,14 @@ package org.lflang.generator.python; +import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; import org.lflang.lf.Reactor; import org.lflang.generator.c.CGenerator; public class PythonActionGenerator { - public static String generateAliasTypeDef(Reactor r, Action action, + public static String generateAliasTypeDef(TypeParameterizedReactor tpr, Action action, String genericActionType) { - return "typedef "+genericActionType+" "+CGenerator.variableStructType(action, r, false)+";"; + return "typedef "+genericActionType+" "+CGenerator.variableStructType(action, tpr, false)+";"; } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index fcb1c19595..6a1a6ecd1d 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -365,7 +365,7 @@ public void generateAuxiliaryStructs( generateAuxiliaryStructsForPort(builder, tpr.r(), output); } for (Action action : ASTUtils.allActions(tpr.r())) { - generateAuxiliaryStructsForAction(builder, tpr.r(), action); + generateAuxiliaryStructsForAction(builder, tpr, action); } } @@ -377,9 +377,9 @@ private void generateAuxiliaryStructsForPort(CodeBuilder builder, Reactor r, genericPortType)); } - private void generateAuxiliaryStructsForAction(CodeBuilder builder, Reactor r, + private void generateAuxiliaryStructsForAction(CodeBuilder builder, TypeParameterizedReactor tpr, Action action) { - builder.pr(action, PythonActionGenerator.generateAliasTypeDef(r, action, genericActionType)); + builder.pr(action, PythonActionGenerator.generateAliasTypeDef(tpr, action, genericActionType)); } /** From 77109fe92d2e34ea54cb9ffe45ea413b28dac7b4 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Wed, 29 Mar 2023 19:50:41 +0500 Subject: [PATCH 090/709] [C-Generics] Working Generic Code Basic implementation for Generic Reactors in C-Target are done We can run the following Generic Code for demonstration of this feature. These macros will be included to LF for user conveniance ``` target C { keepalive: true, // fast: true } preamble {= /// -- Start // All C-Generic Reactors will probably need these /// -- End =} reactor Connector(latency:int(0)) { input in:I; output out:O; logical action delayed_sch; reaction(in) -> delayed_sch {= lf_schedule(delayed_sch, self->latency); =} reaction(delayed_sch) in -> out {= if (is_same_type(in->value, out->value)) { lf_set(out, in->value); } else { auto_t tmp = CALL_CONVERTOR(I, O, in->value); // If convertor function is defined this will be called lf_set(out, tmp); } =} } reactor A { output Aout:int; logical action post; timer t(0, 1sec); reaction(t) -> post {= lf_schedule(post, 2); =} reaction(post) -> Aout {= lf_set(Aout, rand()); =} } reactor B { input Bin:float; reaction(Bin) {= printf("got %f\n", Bin->value); =} } main reactor { a = new A(); w = new Connector(latency=500); w2 = new Connector(latency=500); b = new B(); a.Aout -> w.in; w.out -> b.Bin; } ``` Signed-off-by: mkhubaibumer --- .../org/lflang/generator/c/CGenerator.java | 55 +++++---- .../lflang/generator/c/CMethodGenerator.java | 48 ++++---- .../generator/c/CReactionGenerator.java | 111 +++++++++--------- .../c/CReactorHeaderFileGenerator.java | 38 +++--- .../src/org/lflang/generator/c/CUtil.java | 6 - .../generator/python/PythonGenerator.java | 24 ++-- .../generator/python/PythonPortGenerator.java | 5 +- .../python/PythonReactionGenerator.java | 10 +- .../python/PythonReactorGenerator.java | 4 +- .../org/lflang/validation/LFValidator.java | 12 +- 10 files changed, 157 insertions(+), 156 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 282d73d45d..b9fc9e57dc 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1052,7 +1052,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String header.pr("#include \"include/core/reactor.h\""); src.pr("#include \"include/api/api.h\""); src.pr("#include \"include/api/set.h\""); - generateIncludes(tpr.r()); + generateIncludes(tpr); if (CCppMode) { src.pr("}"); header.pr("}"); @@ -1072,16 +1072,16 @@ private void generateReactorClassBody(TypeParameterizedReactor tpr, CodeBuilder var constructorCode = new CodeBuilder(); generateAuxiliaryStructs(header, tpr, false); generateSelfStruct(header, tpr, constructorCode); - generateMethods(src, tpr.r()); - generateReactions(src, tpr.r()); + generateMethods(src, tpr); + generateReactions(src, tpr); generateConstructor(src, header, tpr, constructorCode); } /** * Generate methods for {@code reactor}. */ - protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { - CMethodGenerator.generateMethods(reactor, src, types); + protected void generateMethods(CodeBuilder src, TypeParameterizedReactor tpr) { + CMethodGenerator.generateMethods(tpr, src, types); } /** @@ -1113,8 +1113,8 @@ protected void generateConstructor( )); } - protected void generateIncludes(Reactor r) { - code.pr("#include \"" + CUtil.getName(r) + ".h\""); + protected void generateIncludes(TypeParameterizedReactor tpr) { + code.pr("#include \"" + CUtil.getName(tpr) + ".h\""); } /** @@ -1201,11 +1201,12 @@ private void generateSelfStruct(CodeBuilder builder, TypeParameterizedReactor tp // struct has a place to hold the data produced by this reactor's // reactions and a place to put pointers to data produced by // the contained reactors. - generateInteractingContainedReactors(reactor, body, constructorCode); + generateInteractingContainedReactors(tpr, reactor, body, constructorCode); // Next, generate the fields needed for each reaction. CReactionGenerator.generateReactionAndTriggerStructs( body, + tpr, reactor, constructorCode, types @@ -1237,11 +1238,13 @@ private void generateSelfStruct(CodeBuilder builder, TypeParameterizedReactor tp * reactions and a place to put pointers to data produced by * the contained reactors. * + * @param tpr The TypeParameterized Reactor * @param reactor The reactor. * @param body The place to put the struct definition for the contained reactors. * @param constructorCode The place to put matching code that goes in the container's constructor. */ private void generateInteractingContainedReactors( + TypeParameterizedReactor tpr, Reactor reactor, CodeBuilder body, CodeBuilder constructorCode @@ -1279,12 +1282,12 @@ private void generateInteractingContainedReactors( // to be malloc'd at initialization. if (!ASTUtils.isMultiport(port)) { // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType, false)+" "+port.getName()+";"); + body.pr(port, variableStructType(port, tpr, false)+" "+port.getName()+";"); } else { // Is a multiport. // Memory will be malloc'd in initialization. body.pr(port, String.join("\n", - variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", + variableStructType(port, tpr, false)+"** "+port.getName()+";", "int "+port.getName()+"_width;" )); } @@ -1294,13 +1297,13 @@ private void generateInteractingContainedReactors( // self struct of the container. if (!ASTUtils.isMultiport(port)) { // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType, false)+"* "+port.getName()+";"); + body.pr(port, variableStructType(port, tpr, false)+"* "+port.getName()+";"); } else { // Is a multiport. // Here, we will use an array of pointers. // Memory will be malloc'd in initialization. body.pr(port, String.join("\n", - variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", + variableStructType(port, tpr, false)+"** "+port.getName()+";", "int "+port.getName()+"_width;" )); } @@ -1308,10 +1311,10 @@ private void generateInteractingContainedReactors( var reactorIndex = ""; if (containedReactor.getWidthSpec() != null) { reactorIndex = "[reactor_index]"; - constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactor.getName()+"_width; reactor_index++) {"); + constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+tpr.getName()+"_width; reactor_index++) {"); constructorCode.indent(); } - var portOnSelf = "self->_lf_"+containedReactor.getName()+reactorIndex+"."+port.getName(); + var portOnSelf = "self->_lf_"+tpr.getName()+reactorIndex+"."+port.getName(); constructorCode.pr( port, @@ -1356,8 +1359,8 @@ private void generateInteractingContainedReactors( } body.unindent(); body.pr(String.join("\n", - "} _lf_"+containedReactor.getName()+array+";", - "int _lf_"+containedReactor.getName()+"_width;" + "} _lf_"+tpr.getName()+array+";", + "int _lf_"+tpr.getName()+"_width;" )); } } @@ -1380,13 +1383,13 @@ protected void generateSelfStructExtension( * These functions have a single argument that is a void* pointing to * a struct that contains parameters, state variables, inputs (triggering or not), * actions (triggering or produced), and outputs. - * @param r The reactor. + * @param tpr The reactor. */ - public void generateReactions(CodeBuilder src, Reactor r) { + public void generateReactions(CodeBuilder src, TypeParameterizedReactor tpr) { var reactionIndex = 0; - var reactor = ASTUtils.toDefinition(r); + var reactor = ASTUtils.toDefinition(tpr.r()); for (Reaction reaction : allReactions(reactor)) { - generateReaction(src, reaction, r, reactionIndex); + generateReaction(src, reaction, tpr, reactionIndex); // Increment reaction index even if the reaction is not in the federate // so that across federates, the reaction indices are consistent. reactionIndex++; @@ -1398,13 +1401,13 @@ public void generateReactions(CodeBuilder src, Reactor r) { * a struct that contains parameters, state variables, inputs (triggering or not), * actions (triggering or produced), and outputs. * @param reaction The reaction. - * @param r The reactor. + * @param tpr The reactor. * @param reactionIndex The position of the reaction within the reactor. */ - protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { + protected void generateReaction(CodeBuilder src, Reaction reaction, TypeParameterizedReactor tpr, int reactionIndex) { src.pr(CReactionGenerator.generateReaction( reaction, - r, + tpr, reactionIndex, mainDef, errorReporter, @@ -1660,12 +1663,12 @@ public static String variableStructType(Variable variable, Reactor r, boolean us * Construct a unique type for the struct of the specified * instance (port or action). * This is required to be the same as the type name returned by - * {@link #variableStructType(Variable, Reactor, boolean)}. + * {@link #variableStructType(Variable, TypeParameterizedReactor, boolean)}. * @param portOrAction The port or action instance. * @return The name of the self struct. */ public static String variableStructType(TriggerInstance portOrAction) { - return CUtil.getName(portOrAction.getParent().reactorDefinition)+"_"+portOrAction.getName()+"_t"; + return CUtil.getName(portOrAction.getParent().tpr)+"_"+portOrAction.getName()+"_t"; } /** @@ -1694,7 +1697,7 @@ public void generateReactorInstance(ReactorInstance instance) { "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); // Generate the instance self struct containing parameters, state variables, // and outputs (the "self" struct). - initializeTriggerObjects.pr(CUtil.reactorRefName(instance)+"["+CUtil.runtimeIndex(instance)+"] = new_"+CUtil.getName(reactorClass)+"();"); + initializeTriggerObjects.pr(CUtil.reactorRefName(instance)+"["+CUtil.runtimeIndex(instance)+"] = new_"+CUtil.getName(instance.tpr)+"();"); // Generate code to initialize the "self" struct in the // _lf_initialize_trigger_objects function. generateTraceTableEntries(instance); diff --git a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java index 5f8a4d6ad1..470bee8011 100644 --- a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java @@ -19,15 +19,15 @@ public class CMethodGenerator { /** * Generate macro definitions for methods. - * @param reactor The reactor. + * @param tpr The reactor. * @param body The place to put the macro definitions. */ public static void generateMacrosForMethods( - Reactor reactor, + TypeParameterizedReactor tpr, CodeBuilder body ) { - for (Method method : allMethods(reactor)) { - var functionName = methodFunctionName(reactor, method); + for (Method method : allMethods(tpr.r())) { + var functionName = methodFunctionName(tpr, method); body.pr("#define "+method.getName()+"(...) "+functionName+"(self, ##__VA_ARGS__)"); } } @@ -51,12 +51,12 @@ public static void generateMacroUndefsForMethods( * This function will have a first argument that is a void* pointing to * the self struct, followed by any arguments given in its definition. * @param method The method. - * @param decl The reactor declaration. + * @param tpr The reactor declaration. * @param types The C-specific type conversion functions. */ public static String generateMethod( Method method, - ReactorDecl decl, + TypeParameterizedReactor tpr, CTypes types ) { var code = new CodeBuilder(); @@ -64,11 +64,11 @@ public static String generateMethod( code.prSourceLineNumber(method); code.prComment("Implementation of method "+method.getName()+"()"); - code.pr(generateMethodSignature(method, decl, types) + " {"); + code.pr(generateMethodSignature(method, tpr, types) + " {"); code.indent(); // Define the "self" struct. - String structType = CUtil.selfType((ReactorInstance) ASTUtils.toDefinition(decl)); + String structType = CUtil.selfType(tpr); // A null structType means there are no inputs, state, // or anything else. No need to declare it. if (structType != null) { @@ -89,21 +89,21 @@ public static String generateMethod( * Generate method functions definition for a reactor. * These functions have a first argument that is a void* pointing to * the self struct. - * @param decl The reactor. + * @param tpr The reactor. * @param code The place to put the code. * @param types The C-specific type conversion functions. */ public static void generateMethods( - ReactorDecl decl, + TypeParameterizedReactor tpr, CodeBuilder code, CTypes types ) { - var reactor = ASTUtils.toDefinition(decl); + var reactor = tpr.r(); code.prComment("***** Start of method declarations."); - signatures(decl, code, types); - generateMacrosForMethods(reactor, code); + signatures(tpr, code, types); + generateMacrosForMethods(tpr, code); for (Method method : allMethods(reactor)) { - code.pr(CMethodGenerator.generateMethod(method, decl, types)); + code.pr(CMethodGenerator.generateMethod(method, tpr, types)); } generateMacroUndefsForMethods(reactor, code); code.prComment("***** End of method declarations."); @@ -114,28 +114,28 @@ public static void generateMethods( * This can be used to declare all the methods with signatures only * before giving the full definition so that methods may call each other * (and themselves) regardless of the order of definition. - * @param decl The reactor declaration. + * @param tpr The reactor declaration. * @param types The C-specific type conversion functions. */ public static void signatures( - ReactorDecl decl, + TypeParameterizedReactor tpr, CodeBuilder body, CTypes types ) { - Reactor reactor = ASTUtils.toDefinition(decl); + Reactor reactor = tpr.r(); for (Method method : allMethods(reactor)) { - body.pr(generateMethodSignature(method, decl, types) + ";"); + body.pr(generateMethodSignature(method, tpr, types) + ";"); } } /** * Return the function name for specified method of the specified reactor. - * @param reactor The reactor + * @param tpr The reactor * @param method The method. * @return The function name for the method. */ - private static String methodFunctionName(ReactorDecl reactor, Method method) { - return CUtil.getName(ASTUtils.toDefinition(reactor)) + "_method_" + method.getName(); + private static String methodFunctionName(TypeParameterizedReactor tpr, Method method) { + return CUtil.getName(tpr) + "_method_" + method.getName(); } /** @@ -143,15 +143,15 @@ private static String methodFunctionName(ReactorDecl reactor, Method method) { * This function will have a first argument that is a void* pointing to * the self struct, followed by any arguments given in its definition. * @param method The method. - * @param decl The reactor declaration. + * @param tpr The reactor declaration. * @param types The C-specific type conversion functions. */ public static String generateMethodSignature( Method method, - ReactorDecl decl, + TypeParameterizedReactor tpr, CTypes types ) { - var functionName = methodFunctionName(decl, method); + var functionName = methodFunctionName(tpr, method); StringBuilder result = new StringBuilder(); if (method.getReturn() != null) { diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 23818cb2ef..3630df136f 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -45,18 +45,18 @@ public class CReactionGenerator { * Generate necessary initialization code inside the body of the reaction that belongs to reactor decl. * @param body The body of the reaction. Used to check for the DISABLE_REACTION_INITIALIZATION_MARKER. * @param reaction The initialization code will be generated for this specific reaction - * @param decl The reactor that has the reaction + * @param tpr The reactor that has the reaction * @param reactionIndex The index of the reaction relative to other reactions in the reactor, starting from 0 */ public static String generateInitializationForReaction(String body, Reaction reaction, - Reactor decl, + TypeParameterizedReactor tpr, int reactionIndex, CTypes types, ErrorReporter errorReporter, Instantiation mainDef, boolean requiresTypes) { - Reactor reactor = ASTUtils.toDefinition(decl); + Reactor reactor = tpr.r(); // Construct the reactionInitialization code to go into // the body of the function before the verbatim code. @@ -65,7 +65,7 @@ public static String generateInitializationForReaction(String body, CodeBuilder code = new CodeBuilder(); // Define the "self" struct. - String structType = CUtil.selfType(decl); + String structType = CUtil.selfType(tpr); // A null structType means there are no inputs, state, // or anything else. No need to declare it. if (structType != null) { @@ -113,12 +113,12 @@ public static String generateInitializationForReaction(String body, reactionInitialization, fieldsForStructsForContainedReactors, triggerAsVarRef, - decl, + tpr, types); } else if (triggerAsVarRef.getVariable() instanceof Action) { reactionInitialization.pr(generateActionVariablesInReaction( (Action) triggerAsVarRef.getVariable(), - decl, + tpr, types )); actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); @@ -130,19 +130,19 @@ public static String generateInitializationForReaction(String body, // Declare an argument for every input. // NOTE: this does not include contained outputs. for (Input input : reactor.getInputs()) { - reactionInitialization.pr(generateInputVariablesInReaction(input, decl, types)); + reactionInitialization.pr(generateInputVariablesInReaction(input, tpr, types)); } } // Define argument for non-triggering inputs. for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { if (src.getVariable() instanceof Port) { - generatePortVariablesInReaction(reactionInitialization, fieldsForStructsForContainedReactors, src, decl, types); + generatePortVariablesInReaction(reactionInitialization, fieldsForStructsForContainedReactors, src, tpr, types); } else if (src.getVariable() instanceof Action) { // It's a bit odd to read but not be triggered by an action, but // OK, I guess we allow it. reactionInitialization.pr(generateActionVariablesInReaction( (Action) src.getVariable(), - decl, + tpr, types )); actionsAsTriggers.add((Action) src.getVariable()); @@ -160,7 +160,7 @@ public static String generateInitializationForReaction(String body, // It is an action, not an output. // If it has already appeared as trigger, do not redefine it. if (!actionsAsTriggers.contains(effect.getVariable())) { - reactionInitialization.pr(CGenerator.variableStructType(variable, decl, false)+"* "+variable.getName()+" = &self->_lf_"+variable.getName()+";"); + reactionInitialization.pr(CGenerator.variableStructType(variable, tpr, false)+"* "+variable.getName()+" = &self->_lf_"+variable.getName()+";"); } } else if (effect.getVariable() instanceof Mode) { // Mode change effect @@ -184,7 +184,7 @@ public static String generateInitializationForReaction(String body, if (variable instanceof Output) { reactionInitialization.pr(generateOutputVariablesInReaction( effect, - decl, + tpr, errorReporter, requiresTypes )); @@ -414,15 +414,15 @@ private static void generatePortVariablesInReaction( CodeBuilder builder, Map structs, VarRef port, - Reactor r, + TypeParameterizedReactor tpr, CTypes types ) { if (port.getVariable() instanceof Input) { - builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), r, types)); + builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), tpr, types)); } else { // port is an output of a contained reactor. Output output = (Output) port.getVariable(); - String portStructType = CGenerator.variableStructType(output, ASTUtils.toDefinition(port.getContainer().getReactorClass()), false); + String portStructType = CGenerator.variableStructType(output, tpr, false); CodeBuilder structBuilder = structs.get(port.getContainer()); if (structBuilder == null) { @@ -476,10 +476,10 @@ private static void generatePortVariablesInReaction( */ private static String generateActionVariablesInReaction( Action action, - Reactor r, + TypeParameterizedReactor tpr, CTypes types ) { - String structType = CGenerator.variableStructType(action, r, false); + String structType = CGenerator.variableStructType(action, tpr, false); // If the action has a type, create variables for accessing the value. InferredType type = ASTUtils.getInferredType(action); // Pointer to the lf_token_t sent as the payload in the trigger. @@ -516,14 +516,14 @@ private static String generateActionVariablesInReaction( * initialize local variables for the specified input port * in a reaction function from the "self" struct. * @param input The input statement from the AST. - * @param r The reactor. + * @param tpr The reactor. */ private static String generateInputVariablesInReaction( Input input, - Reactor r, + TypeParameterizedReactor tpr, CTypes types ) { - String structType = CGenerator.variableStructType(input, r, false); + String structType = CGenerator.variableStructType(input, tpr, false); InferredType inputType = ASTUtils.getInferredType(input); CodeBuilder builder = new CodeBuilder(); String inputName = input.getName(); @@ -624,11 +624,11 @@ private static String generateInputVariablesInReaction( * initialize local variables for outputs in a reaction function * from the "self" struct. * @param effect The effect declared by the reaction. This must refer to an output. - * @param r The reactor containing the reaction. + * @param tpr The reactor containing the reaction. */ public static String generateOutputVariablesInReaction( VarRef effect, - Reactor r, + TypeParameterizedReactor tpr, ErrorReporter errorReporter, boolean requiresTypes ) { @@ -642,7 +642,7 @@ public static String generateOutputVariablesInReaction( // The container of the output may be a contained reactor or // the reactor containing the reaction. String outputStructType = (effect.getContainer() == null) ? - CGenerator.variableStructType(output, r, false) + CGenerator.variableStructType(output, tpr, false) : CGenerator.variableStructType(output, ASTUtils.toDefinition(effect.getContainer().getReactorClass()), false); if (!ASTUtils.isMultiport(output)) { @@ -671,6 +671,7 @@ public static String generateOutputVariablesInReaction( */ public static void generateReactionAndTriggerStructs( CodeBuilder body, + TypeParameterizedReactor tpr, Reactor reactor, CodeBuilder constructorCode, CTypes types @@ -688,7 +689,7 @@ public static void generateReactionAndTriggerStructs( var startupReactions = new LinkedHashSet(); var shutdownReactions = new LinkedHashSet(); var resetReactions = new LinkedHashSet(); - for (Reaction reaction : ASTUtils.allReactions(reactor)) { + for (Reaction reaction : ASTUtils.allReactions(tpr.r())) { // Create the reaction_t struct. body.pr(reaction, "reaction_t _lf__reaction_"+reactionCount+";"); @@ -731,7 +732,7 @@ public static void generateReactionAndTriggerStructs( var deadlineFunctionPointer = "NULL"; if (reaction.getDeadline() != null) { // The following has to match the name chosen in generateReactions - var deadlineFunctionName = generateDeadlineFunctionName(reactor, reactionCount); + var deadlineFunctionName = generateDeadlineFunctionName(tpr, reactionCount); deadlineFunctionPointer = "&" + deadlineFunctionName; } @@ -739,7 +740,7 @@ public static void generateReactionAndTriggerStructs( var STPFunctionPointer = "NULL"; if (reaction.getStp() != null) { // The following has to match the name chosen in generateReactions - var STPFunctionName = generateStpFunctionName(reactor, reactionCount); + var STPFunctionName = generateStpFunctionName(tpr, reactionCount); STPFunctionPointer = "&" + STPFunctionName; } @@ -753,7 +754,7 @@ public static void generateReactionAndTriggerStructs( // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; constructorCode.pr(reaction, String.join("\n", "self->_lf__reaction_"+reactionCount+".number = "+reactionCount+";", - "self->_lf__reaction_"+reactionCount+".function = "+CReactionGenerator.generateReactionFunctionName(reactor, reactionCount)+";", + "self->_lf__reaction_"+reactionCount+".function = "+CReactionGenerator.generateReactionFunctionName(tpr, reactionCount)+";", "self->_lf__reaction_"+reactionCount+".self = self;", "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", @@ -1031,12 +1032,12 @@ public static String generateLfModeTriggeredReactions( * a struct that contains parameters, state variables, inputs (triggering or not), * actions (triggering or produced), and outputs. * @param reaction The reaction. - * @param r The reactor. + * @param tpr The reactor. * @param reactionIndex The position of the reaction within the reactor. */ public static String generateReaction( Reaction reaction, - Reactor r, + TypeParameterizedReactor tpr, int reactionIndex, Instantiation mainDef, ErrorReporter errorReporter, @@ -1045,9 +1046,9 @@ public static String generateReaction( boolean requiresType ) { var code = new CodeBuilder(); - var body = ASTUtils.toText(getCode(types, reaction, r)); + var body = ASTUtils.toText(getCode(types, reaction, tpr)); String init = generateInitializationForReaction( - body, reaction, ASTUtils.toDefinition(r), reactionIndex, + body, reaction, tpr, reactionIndex, types, errorReporter, mainDef, requiresType); @@ -1055,37 +1056,37 @@ public static String generateReaction( "#include " + StringUtil.addDoubleQuotes( CCoreFilesUtils.getCTargetSetHeader())); - CMethodGenerator.generateMacrosForMethods(ASTUtils.toDefinition(r), code); + CMethodGenerator.generateMacrosForMethods(tpr, code); code.pr(generateFunction( - generateReactionFunctionHeader(r, reactionIndex), - init, getCode(types, reaction, r) + generateReactionFunctionHeader(tpr, reactionIndex), + init, getCode(types, reaction, tpr) )); // Now generate code for the late function, if there is one // Note that this function can only be defined on reactions // in federates that have inputs from a logical connection. if (reaction.getStp() != null) { code.pr(generateFunction( - generateStpFunctionHeader(r, reactionIndex), + generateStpFunctionHeader(tpr, reactionIndex), init, reaction.getStp().getCode())); } // Now generate code for the deadline violation function, if there is one. if (reaction.getDeadline() != null) { code.pr(generateFunction( - generateDeadlineFunctionHeader(r, reactionIndex), + generateDeadlineFunctionHeader(tpr, reactionIndex), init, reaction.getDeadline().getCode())); } - CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(r), code); + CMethodGenerator.generateMacroUndefsForMethods(tpr.r(), code); code.pr( "#include " + StringUtil.addDoubleQuotes( CCoreFilesUtils.getCTargetSetUndefHeader())); return code.toString(); } - private static Code getCode(CTypes types, Reaction r, ReactorDecl container) { + private static Code getCode(CTypes types, Reaction r, TypeParameterizedReactor tpr) { if (r.getCode() != null) return r.getCode(); Code ret = LfFactory.eINSTANCE.createCode(); - ret.setBody(r.getName() + "( " + CReactorHeaderFileGenerator.reactionArguments(types, r, ASTUtils.toDefinition(container)) + " );"); + ret.setBody(r.getName() + "( " + CReactorHeaderFileGenerator.reactionArguments(types, r, tpr) + " );"); return ret; } @@ -1103,58 +1104,58 @@ public static String generateFunction(String header, String init, Code code) { /** * Returns the name of the deadline function for reaction. - * @param r The reactor with the deadline + * @param tpr The reactor with the deadline * @param reactionIndex The number assigned to this reaction deadline */ - public static String generateDeadlineFunctionName(Reactor r, int reactionIndex) { - return CUtil.getName(r).toLowerCase() + "_deadline_function" + reactionIndex; + public static String generateDeadlineFunctionName(TypeParameterizedReactor tpr, int reactionIndex) { + return CUtil.getName(tpr).toLowerCase() + "_deadline_function" + reactionIndex; } /** * Return the function name for specified reaction of the * specified reactor. - * @param reactor The reactor + * @param tpr The reactor * @param reactionIndex The reaction index. * @return The function name for the reaction. */ - public static String generateReactionFunctionName(Reactor reactor, int reactionIndex) { - return CUtil.getName(reactor).toLowerCase() + "reaction_function_" + reactionIndex; + public static String generateReactionFunctionName(TypeParameterizedReactor tpr, int reactionIndex) { + return CUtil.getName(tpr).toLowerCase() + "reaction_function_" + reactionIndex; } /** * Returns the name of the stp function for reaction. - * @param r The reactor with the stp + * @param tpr The reactor with the stp * @param reactionIndex The number assigned to this reaction deadline */ - public static String generateStpFunctionName(Reactor r, int reactionIndex) { - return CUtil.getName(r).toLowerCase() + "_STP_function" + reactionIndex; + public static String generateStpFunctionName(TypeParameterizedReactor tpr, int reactionIndex) { + return CUtil.getName(tpr).toLowerCase() + "_STP_function" + reactionIndex; } /** Return the top level C function header for the deadline function numbered "reactionIndex" in "r" - * @param r The reactor declaration + * @param tpr The reactor declaration * @param reactionIndex The reaction index. * @return The function name for the deadline function. */ - public static String generateDeadlineFunctionHeader(Reactor r, + public static String generateDeadlineFunctionHeader(TypeParameterizedReactor tpr, int reactionIndex) { - String functionName = generateDeadlineFunctionName(r, reactionIndex); + String functionName = generateDeadlineFunctionName(tpr, reactionIndex); return generateFunctionHeader(functionName); } /** Return the top level C function header for the reaction numbered "reactionIndex" in "r" - * @param r The reactor declaration + * @param tpr The reactor declaration * @param reactionIndex The reaction index. * @return The function name for the reaction. */ - public static String generateReactionFunctionHeader(Reactor r, + public static String generateReactionFunctionHeader(TypeParameterizedReactor tpr, int reactionIndex) { - String functionName = generateReactionFunctionName(r, reactionIndex); + String functionName = generateReactionFunctionName(tpr, reactionIndex); return generateFunctionHeader(functionName); } - public static String generateStpFunctionHeader(Reactor r, + public static String generateStpFunctionHeader(TypeParameterizedReactor tpr, int reactionIndex) { - String functionName = generateStpFunctionName(r, reactionIndex); + String functionName = generateStpFunctionName(tpr, reactionIndex); return generateFunctionHeader(functionName); } diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 92318c0150..041baab112 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -43,10 +43,10 @@ private static String generateHeaderFile(CTypes types, TypeParameterizedReactor appendIncludeGuard(builder, tpr.r()); builder.pr(topLevelPreamble); appendPoundIncludes(builder); - appendSelfStruct(builder, types, tpr.r()); + appendSelfStruct(builder, types, tpr); generator.generate(builder, tpr, true); for (Reaction reaction : tpr.r().getReactions()) { - appendSignature(builder, types, reaction, tpr.r()); + appendSignature(builder, types, reaction, tpr); } builder.pr("#endif"); return builder.getCode(); @@ -71,40 +71,40 @@ private static void appendPoundIncludes(CodeBuilder builder) { """); } - private static String userFacingSelfType(Reactor r) { - return r.getName().toLowerCase() + "_self_t"; + private static String userFacingSelfType(TypeParameterizedReactor tpr) { + return tpr.getName().toLowerCase() + "_self_t"; } - private static void appendSelfStruct(CodeBuilder builder, CTypes types, Reactor r) { - builder.pr("typedef struct " + userFacingSelfType(r) + "{"); - for (Parameter p : r.getParameters()) { + private static void appendSelfStruct(CodeBuilder builder, CTypes types, TypeParameterizedReactor tpr) { + builder.pr("typedef struct " + userFacingSelfType(tpr) + "{"); + for (Parameter p : tpr.r().getParameters()) { builder.pr(types.getTargetType(p) + " " + p.getName() + ";"); } - for (StateVar s : r.getStateVars()) { + for (StateVar s : tpr.r().getStateVars()) { builder.pr(types.getTargetType(s) + " " + s.getName() + ";"); } builder.pr("int end[0]; // placeholder; MSVC does not compile empty structs"); - builder.pr("} " + userFacingSelfType(r) + ";"); + builder.pr("} " + userFacingSelfType(tpr) + ";"); } - private static void appendSignature(CodeBuilder builder, CTypes types, Reaction r, Reactor reactor) { - if (r.getName() != null) builder.pr("void " + r.getName() + "(" + reactionParameters(types, r, reactor) + ");"); + private static void appendSignature(CodeBuilder builder, CTypes types, Reaction r, TypeParameterizedReactor tpr) { + if (r.getName() != null) builder.pr("void " + r.getName() + "(" + reactionParameters(types, r, tpr) + ");"); } - private static String reactionParameters(CTypes types, Reaction r, Reactor reactor) { - return Stream.concat(Stream.of(userFacingSelfType(reactor) + "* self"), ioTypedVariableStream(r) - .map((tv) -> reactor.getName().toLowerCase() + "_" + tv.getName() + "_t* " + tv.getName())) + private static String reactionParameters(CTypes types, Reaction r, TypeParameterizedReactor tpr) { + return Stream.concat(Stream.of(userFacingSelfType(tpr) + "* self"), ioTypedVariableStream(r) + .map((tv) -> tpr.getName().toLowerCase() + "_" + tv.getName() + "_t* " + tv.getName())) .collect(Collectors.joining(", ")); } - public static String reactionArguments(CTypes types, Reaction r, Reactor reactor) { - return Stream.concat(Stream.of(getApiSelfStruct(reactor)), ioTypedVariableStream(r) - .map(it -> String.format("((%s*) %s)", CGenerator.variableStructType(it, reactor, true), it.getName()))) + public static String reactionArguments(CTypes types, Reaction r, TypeParameterizedReactor tpr) { + return Stream.concat(Stream.of(getApiSelfStruct(tpr)), ioTypedVariableStream(r) + .map(it -> String.format("((%s*) %s)", CGenerator.variableStructType(it, tpr, true), it.getName()))) .collect(Collectors.joining(", ")); } - private static String getApiSelfStruct(Reactor reactor) { - return "(" + userFacingSelfType(reactor) + "*) (((char*) self) + sizeof(self_base_t))"; + private static String getApiSelfStruct(TypeParameterizedReactor tpr) { + return "(" + userFacingSelfType(tpr) + "*) (((char*) self) + sizeof(self_base_t))"; } private static Stream ioTypedVariableStream(Reaction r) { diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 15097b6205..418c87157b 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -529,12 +529,6 @@ public static String selfType(TypeParameterizedReactor reactor) { } return "_" + CUtil.getName(reactor) + "_self_t"; } - public static String selfType(Reactor reactor) { - if (reactor.isMain()) { - return "_" + CUtil.getName(reactor) + "_main_self_t"; - } - return "_" + CUtil.getName(reactor) + "_self_t"; - } /** Construct a unique type for the "self" struct of the class of the given reactor. */ public static String selfType(ReactorInstance instance) { diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 6a1a6ecd1d..e0ef28c192 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -352,28 +352,28 @@ public void processProtoFile(String filename) { /** * Generate the aliases for inputs, outputs, and struct type definitions for * actions of the specified reactor in the specified federate. - * @param r The parsed reactor data structure. + * @param tpr The parsed reactor data structure. */ @Override public void generateAuxiliaryStructs( CodeBuilder builder, TypeParameterizedReactor tpr, boolean userFacing ) { for (Input input : ASTUtils.allInputs(tpr.r())) { - generateAuxiliaryStructsForPort(builder, tpr.r(), input); + generateAuxiliaryStructsForPort(builder, tpr, input); } for (Output output : ASTUtils.allOutputs(tpr.r())) { - generateAuxiliaryStructsForPort(builder, tpr.r(), output); + generateAuxiliaryStructsForPort(builder, tpr, output); } for (Action action : ASTUtils.allActions(tpr.r())) { generateAuxiliaryStructsForAction(builder, tpr, action); } } - private void generateAuxiliaryStructsForPort(CodeBuilder builder, Reactor r, + private void generateAuxiliaryStructsForPort(CodeBuilder builder, TypeParameterizedReactor tpr, Port port) { boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); builder.pr(port, - PythonPortGenerator.generateAliasTypeDef(r, port, isTokenType, + PythonPortGenerator.generateAliasTypeDef(tpr, port, isTokenType, genericPortType)); } @@ -455,19 +455,19 @@ protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { * a struct that contains parameters, state variables, inputs (triggering or not), * actions (triggering or produced), and outputs. * @param reaction The reaction. - * @param r The reactor. + * @param tpr The reactor. * @param reactionIndex The position of the reaction within the reactor. */ @Override - protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { - Reactor reactor = ASTUtils.toDefinition(r); + protected void generateReaction(CodeBuilder src, Reaction reaction, TypeParameterizedReactor tpr, int reactionIndex) { + Reactor reactor = ASTUtils.toDefinition(tpr.r()); // Reactions marked with a `@_c_body` attribute are generated in C if (AttributeUtils.hasCBody(reaction)) { - super.generateReaction(src, reaction, r, reactionIndex); + super.generateReaction(src, reaction, tpr, reactionIndex); return; } - src.pr(PythonReactionGenerator.generateCReaction(reaction, reactor, reactionIndex, mainDef, errorReporter, types)); + src.pr(PythonReactionGenerator.generateCReaction(reaction, tpr, reactor, reactionIndex, mainDef, errorReporter, types)); } /** @@ -504,7 +504,7 @@ protected void generateParameterInitialization(ReactorInstance instance) { * @see PythonMethodGenerator */ @Override - protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { } + protected void generateMethods(CodeBuilder src, TypeParameterizedReactor reactor) { } /** * Generate C preambles defined by user for a given reactor @@ -540,7 +540,7 @@ protected void generateReactorInstanceExtension( /** * This function is provided to allow extensions of the CGenerator to append the structure of the self struct * @param selfStructBody The body of the self struct - * @param decl The reactor declaration for the self struct + * @param reactor The reactor declaration for the self struct * @param constructorCode Code that is executed when the reactor is instantiated */ @Override diff --git a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java index 9e0919b52c..a5308798d6 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java @@ -1,5 +1,6 @@ package org.lflang.generator.python; +import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Output; @@ -195,8 +196,8 @@ public static String generatePythonListForContainedBank(String reactorName, Port ); } - public static String generateAliasTypeDef(Reactor r, Port port, boolean isTokenType, String genericPortType) { - return "typedef "+genericPortType+" "+CGenerator.variableStructType(port, r, false)+";"; + public static String generateAliasTypeDef(TypeParameterizedReactor tpr, Port port, boolean isTokenType, String genericPortType) { + return "typedef "+genericPortType+" "+CGenerator.variableStructType(port, tpr, false)+";"; } private static String generateConvertCPortToPy(String port) { diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java index bcc1beeaed..62dd65ff5f 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java @@ -12,6 +12,7 @@ import org.lflang.Target; import org.lflang.generator.c.CReactionGenerator; +import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; @@ -127,6 +128,7 @@ private static String generateCPythonFunctionCaller(String reactorDeclName, */ public static String generateCReaction( Reaction reaction, + TypeParameterizedReactor tpr, Reactor r, int reactionIndex, Instantiation mainDef, @@ -139,14 +141,14 @@ public static String generateCReaction( CodeBuilder code = new CodeBuilder(); String cPyInit = generateCPythonInitializers(reaction, r, pyObjects, errorReporter); String cInit = CReactionGenerator.generateInitializationForReaction( - "", reaction, r, reactionIndex, + "", reaction, tpr, reactionIndex, types, errorReporter, mainDef, Target.Python.requiresTypes); code.pr( "#include " + StringUtil.addDoubleQuotes( CCoreFilesUtils.getCTargetSetHeader())); code.pr(generateFunction( - CReactionGenerator.generateReactionFunctionHeader(r, reactionIndex), + CReactionGenerator.generateReactionFunctionHeader(tpr, reactionIndex), cInit, reaction.getCode(), generateCPythonReactionCaller(r, reactionIndex, pyObjects, cPyInit) )); @@ -154,7 +156,7 @@ public static String generateCReaction( // Generate code for the STP violation handler, if there is one. if (reaction.getStp() != null) { code.pr(generateFunction( - CReactionGenerator.generateStpFunctionHeader(r, reactionIndex), + CReactionGenerator.generateStpFunctionHeader(tpr, reactionIndex), cInit, reaction.getStp().getCode(), generateCPythonSTPCaller(r, reactionIndex, pyObjects) )); @@ -162,7 +164,7 @@ public static String generateCReaction( // Generate code for the deadline violation function, if there is one. if (reaction.getDeadline() != null) { code.pr(generateFunction( - CReactionGenerator.generateDeadlineFunctionHeader(r, reactionIndex), + CReactionGenerator.generateDeadlineFunctionHeader(tpr, reactionIndex), cInit, reaction.getDeadline().getCode(), generateCPythonDeadlineCaller(r, reactionIndex, pyObjects) )); diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java index fd954ca956..e95e9766bd 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java @@ -34,7 +34,7 @@ public static String generatePythonClass(ReactorInstance instance, CodeBuilder pythonClasses = new CodeBuilder(); ReactorDecl decl = instance.getDefinition().getReactorClass(); Reactor reactor = ASTUtils.toDefinition(decl); - String className = PyUtil.getName(reactor); + String className = PyUtil.getName(instance.tpr); if (instantiatedClasses == null) { return ""; } @@ -113,7 +113,7 @@ public static String generatePythonClassInstantiations(ReactorInstance instance, ReactorInstance main) { CodeBuilder code = new CodeBuilder(); - String className = PyUtil.getName(instance.reactorDefinition); + String className = PyUtil.getName(instance.tpr); if (instance.getWidth() > 0) { // For each reactor instance, create a list regardless of whether it is a bank or not. diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 394250d22c..7af840de3d 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -239,9 +239,9 @@ public void checkConnection(Connection connection) { } else { // Unfortunately, xtext does not generate a suitable equals() // method for AST types, so we have to manually check the types. - if (!sameType(type, ((Port) port.getVariable()).getType())) { - error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); - } +// if (!sameType(type, ((Port) port.getVariable()).getType())) { +// error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); +// } } } } @@ -252,9 +252,9 @@ public void checkConnection(Connection connection) { if (type == null) { type = ((Port) port.getVariable()).getType(); } else { - if (!sameType(type, type = ((Port) port.getVariable()).getType())) { - error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); - } +// if (!sameType(type, type = ((Port) port.getVariable()).getType())) { +// error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); +// } } } } From 4af90402d6fee68c42828edf1fb086452f2167c1 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Thu, 30 Mar 2023 17:03:09 +0500 Subject: [PATCH 091/709] [C-Generics] Working Generic Code Basic implementation for Generic Reactors in C-Target are done We can run the following Generic Code for demonstration of this feature. ``` target C { keepalive: true, cmake-include: [ "../lib/lib.cmake" ], files: [ "../lib/convertor.h", "../lib/convertor.c" ] } preamble {= =} reactor Connector(latency:int(0)) { input in:I; output out:O; logical action delayed_sch; reaction(in) -> delayed_sch {= lf_schedule(delayed_sch, self->latency); =} reaction(delayed_sch) in -> out {= if (is_same_type(in->value, out->value)) { lf_set(out, in->value); } else { auto_t tmp = CALL_CONVERTOR(I, O, in->value); lf_set(out, tmp); } =} } reactor A { output Aout:int; logical action post; timer t(0, 1sec); reaction(t) -> post {= lf_schedule(post, 2); =} reaction(post) -> Aout {= lf_set(Aout, rand()); =} } reactor B { input Bin:float; reaction(Bin) {= printf("got %f\n", Bin->value); =} } main reactor { a = new A(); w = new Connector(latency=500); b = new B(); a.Aout -> w.in; w.out -> b.Bin; } ``` Complete Working example can be fetched from: https://github.com/MagnitionIO/LF_Collaboration/blob/main/CGenericsProposal/src/CGenerics.lf Signed-off-by: mkhubaibumer --- org.lflang/src/lib/c/reactor-c | 2 +- .../src/org/lflang/generator/c/CCoreFilesUtils.java | 3 ++- org.lflang/src/org/lflang/generator/c/CGenerator.java | 8 +++++--- .../lflang/generator/c/CReactorHeaderFileGenerator.java | 9 +++++---- 4 files changed, 13 insertions(+), 9 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index d43e973780..f9dd92f15b 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit d43e9737804f2d984d52a99cac20d8e57adad543 +Subproject commit f9dd92f15b89ee57545b983bed45362a53a3375b diff --git a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java index 46503d87cc..6022110943 100644 --- a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java +++ b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java @@ -18,7 +18,8 @@ public static List getCTargetSrc() { public static List getCTargetHeader() { return List.of( - "include/api/api.h" + "include/api/api.h", + "include/api/generics.h" ); } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b9fc9e57dc..bb0944d389 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1048,18 +1048,20 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String src.pr("extern \"C\" {"); header.pr("extern \"C\" {"); } - tpr.typeArgs().entrySet().forEach(it -> header.pr("#define " + it.getKey() + " " + ASTUtils.toText(it.getValue()))); + tpr.typeArgs().forEach((literal, concreteType) -> header.pr( + "#define " + literal + " " + ASTUtils.toText(concreteType))); header.pr("#include \"include/core/reactor.h\""); src.pr("#include \"include/api/api.h\""); src.pr("#include \"include/api/set.h\""); + src.pr("#include \"include/api/generics.h\""); generateIncludes(tpr); if (CCppMode) { src.pr("}"); header.pr("}"); } - src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(fileConfig, tpr.r()) + "\""); src.pr("#include \"" + headerName + "\""); - tpr.typeArgs().entrySet().forEach(it -> src.pr("#define " + it.getKey() + " " + ASTUtils.toText(it.getValue()))); + tpr.typeArgs().forEach((literal, concreteType) -> src.pr( + "#define " + literal + " " + ASTUtils.toText(concreteType))); new HashSet<>(ASTUtils.allInstantiations(tpr.r())).stream() .map(TypeParameterizedReactor::new).map(CUtil::getName) .map(name -> "#include \"" + name + ".h\"") diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 041baab112..9c820cd87c 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -28,15 +28,15 @@ public interface GenerateAuxiliaryStructs { void generate(CodeBuilder b, TypeParameterizedReactor r, boolean userFacing); } - public static Path outputPath(CFileConfig fileConfig, Reactor r) { - return Path.of(Path.of(r.eResource().getURI().toFileString()) + public static Path outputPath(CFileConfig fileConfig, TypeParameterizedReactor tpr) { + return Path.of(Path.of(tpr.r().eResource().getURI().toFileString()) .getFileName().toString().replaceFirst("[.][^.]+$", "")) - .resolve(r.getName() + ".h"); + .resolve(tpr.getName() + ".h"); } public static void doGenerate(CTypes types, TypeParameterizedReactor tpr, CFileConfig fileConfig, GenerateAuxiliaryStructs generator, Function topLevelPreamble) throws IOException { String contents = generateHeaderFile(types, tpr, generator, topLevelPreamble.apply(tpr.r())); - FileUtil.writeToFile(contents, fileConfig.getIncludePath().resolve(outputPath(fileConfig, tpr.r()))); + FileUtil.writeToFile(contents, fileConfig.getIncludePath().resolve(outputPath(fileConfig, tpr))); } private static String generateHeaderFile(CTypes types, TypeParameterizedReactor tpr, GenerateAuxiliaryStructs generator, String topLevelPreamble) { CodeBuilder builder = new CodeBuilder(); @@ -64,6 +64,7 @@ private static void appendPoundIncludes(CodeBuilder builder) { #endif #include "../include/api/api.h" #include "../include/api/set.h" + #include "../include/api/generics.h" #include "../include/core/reactor.h" #ifdef __cplusplus } From 60cf911610a09cbbb07a706212b22808b0c5e07d Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 30 Mar 2023 19:15:40 -0700 Subject: [PATCH 092/709] merged changes, fixed inconsistencies, implemented watchdog stop --- org.lflang/src/lib/c/reactor-c | 2 +- .../platform/arduino/Arduino-CMake-Toolchain | 1 + test/C/src/Watchdog.lf | 6 ++- test/C/src/file0.lf | 40 +++++++++++++++++++ test/C/src/file1.lf | 40 +++++++++++++++++++ test/C/src/file2.lf | 40 +++++++++++++++++++ 6 files changed, 126 insertions(+), 3 deletions(-) create mode 160000 org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain create mode 100644 test/C/src/file0.lf create mode 100644 test/C/src/file1.lf create mode 100644 test/C/src/file2.lf diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 10c275b99a..ff3c84c36b 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 10c275b99a01802f00168b92d4e9068fdf9b34b6 +Subproject commit ff3c84c36b2d7fbcbe09fafa577ec94f75194e83 diff --git a/org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain b/org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain new file mode 160000 index 0000000000..e745a9bed3 --- /dev/null +++ b/org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain @@ -0,0 +1 @@ +Subproject commit e745a9bed3c3fb83442d55bf05630f31574674f2 diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index e3d7f6cb41..4827637f07 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -1,4 +1,6 @@ -target C +target C { + workers: 100 +}; reactor Watcher { input x: int @@ -6,7 +8,7 @@ reactor Watcher { watchdog poodle(10 msec) {= instant_t p = lf_time_physical_elapsed() - lf_time_logical_elapsed(); - printf("Deadline missed! Lag: %lld (too late by %lld nsecs)\n", p, p-500000); + printf("Watchdog missed! Lag: %lld (too late by %lld nsecs)\n", p, p-500000); =} reaction(x) -> poodle, d {= diff --git a/test/C/src/file0.lf b/test/C/src/file0.lf new file mode 100644 index 0000000000..645242845a --- /dev/null +++ b/test/C/src/file0.lf @@ -0,0 +1,40 @@ +target C + +reactor Watcher { + input x: int + // Produced if the + // deadline is + // violated. + output d: int + + reaction(x) -> + d, poodle {= + lf_watchdog_start(poodle, 0); + printf("Normal reaction.\n"); + =} +} + +main reactor { + logical action a + w = new Watcher( + + ) + + reaction( + startup + ) -> + w.x, a {= + lf_set(w.x, 0); + lf_schedule(a, 0); + =} + + reaction(a) -> + w.x {= + lf_set(w.x, 0); + lf_nanosleep(MSEC(40)); + =} + + reaction(w.d) {= + printf("Deadline reactor produced an output.\n"); + =} +} diff --git a/test/C/src/file1.lf b/test/C/src/file1.lf new file mode 100644 index 0000000000..1183364928 --- /dev/null +++ b/test/C/src/file1.lf @@ -0,0 +1,40 @@ +target C + +reactor Watcher { + input x: int + // Produced if the + // deadline is + // violated. + output d: int + + reaction(x) -> + poodle, d {= + lf_watchdog_start(poodle, 0); + printf("Normal reaction.\n"); + =} +} + +main reactor { + logical action a + w = new Watcher( + + ) + + reaction( + startup + ) -> + w.x, a {= + lf_set(w.x, 0); + lf_schedule(a, 0); + =} + + reaction(a) -> + w.x {= + lf_set(w.x, 0); + lf_nanosleep(MSEC(40)); + =} + + reaction(w.d) {= + printf("Deadline reactor produced an output.\n"); + =} +} diff --git a/test/C/src/file2.lf b/test/C/src/file2.lf new file mode 100644 index 0000000000..1183364928 --- /dev/null +++ b/test/C/src/file2.lf @@ -0,0 +1,40 @@ +target C + +reactor Watcher { + input x: int + // Produced if the + // deadline is + // violated. + output d: int + + reaction(x) -> + poodle, d {= + lf_watchdog_start(poodle, 0); + printf("Normal reaction.\n"); + =} +} + +main reactor { + logical action a + w = new Watcher( + + ) + + reaction( + startup + ) -> + w.x, a {= + lf_set(w.x, 0); + lf_schedule(a, 0); + =} + + reaction(a) -> + w.x {= + lf_set(w.x, 0); + lf_nanosleep(MSEC(40)); + =} + + reaction(w.d) {= + printf("Deadline reactor produced an output.\n"); + =} +} From 7fb877be88cf5709758756b4ca1351ec9bace6ef Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 30 Mar 2023 21:04:33 -0700 Subject: [PATCH 093/709] threading error working --- org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain | 1 - org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 +- test/C/src/Watchdog.lf | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) delete mode 160000 org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain diff --git a/org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain b/org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain deleted file mode 160000 index e745a9bed3..0000000000 --- a/org.lflang/src/lib/platform/arduino/Arduino-CMake-Toolchain +++ /dev/null @@ -1 +0,0 @@ -Subproject commit e745a9bed3c3fb83442d55bf05630f31574674f2 diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index e7ce2439f8..2ef5074455 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -473,7 +473,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { super.doGenerate(resource, context); if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; if (!isOSCompatible()) return; // Incompatible OS and configuration - // if (!isWatchdogCompatible()) return; + if (!isWatchdogCompatible()) return; // Perform set up that does not generate code setUpGeneralParameters(); diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index 4827637f07..488ae42acd 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -1,6 +1,6 @@ target C { workers: 100 -}; +} reactor Watcher { input x: int From 8b3b3e3e8ed7e765f2573012ddba1b4c9b5ac60e Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 30 Mar 2023 22:10:38 -0700 Subject: [PATCH 094/709] saving before pull again --- .../tests/compiler/FormattingUnitTests.java | 33 +- .../tests/compiler/LetInferenceTests.java | 2 +- .../compiler/LinguaFrancaValidationTest.java | 2234 ++++++----------- .../lflang/tests/compiler/RoundTripTests.java | 9 +- org.lflang/src/org/lflang/ASTUtils.java | 8 + org.lflang/src/org/lflang/LinguaFranca.xtext | 19 +- org.lflang/src/org/lflang/Target.java | 18 +- org.lflang/src/org/lflang/ast/IsEqual.java | 12 +- org.lflang/src/org/lflang/ast/ToLf.java | 60 +- org.lflang/src/org/lflang/ast/ToText.java | 6 + org.lflang/src/org/lflang/cli/Lff.java | 32 +- .../synthesis/LinguaFrancaSynthesis.java | 11 +- .../federated/extensions/CExtension.java | 13 +- .../federated/extensions/CExtensionUtils.java | 18 +- .../federated/extensions/TSExtension.java | 5 +- .../federated/generator/FederateInstance.java | 6 +- .../src/org/lflang/generator/CodeMap.java | 15 +- .../org/lflang/generator/GeneratorBase.java | 77 - .../org/lflang/generator/GeneratorUtils.java | 2 +- .../lflang/generator/LfExpressionVisitor.java | 160 ++ .../lflang/generator/ParameterInstance.java | 29 +- .../org/lflang/generator/ReactorInstance.java | 81 +- .../src/org/lflang/generator/TargetTypes.java | 14 +- .../lflang/generator/c/CActionGenerator.java | 7 +- .../org/lflang/generator/c/CGenerator.java | 6 +- .../generator/c/CParameterGenerator.java | 50 +- .../lflang/generator/c/CStateGenerator.java | 15 +- .../lflang/generator/c/CTimerGenerator.java | 6 +- .../src/org/lflang/generator/c/CTypes.java | 72 +- .../generator/cpp/CppParameterGenerator.kt | 20 +- .../generator/cpp/CppReactorGenerator.kt | 9 +- .../lflang/generator/cpp/CppStateGenerator.kt | 2 +- .../src/org/lflang/generator/cpp/CppTypes.kt | 21 +- .../org/lflang/generator/python/PyUtil.java | 22 +- .../generator/python/PythonGenerator.java | 2 +- .../python/PythonParameterGenerator.java | 47 +- .../lflang/generator/python/PythonTypes.java | 58 +- .../generator/ts/TSConstructorGenerator.kt | 2 +- .../generator/ts/TSDelayBodyGenerator.kt | 2 +- .../generator/ts/TSDockerGenerator.java | 29 + .../lflang/generator/ts/TSDockerGenerator.kt | 26 - .../org/lflang/generator/ts/TSExtensions.kt | 8 +- .../org/lflang/generator/ts/TSGenerator.kt | 2 +- .../generator/ts/TSInstanceGenerator.kt | 6 +- .../generator/ts/TSParameterGenerator.kt | 2 +- .../ts/TSParameterPreambleGenerator.kt | 4 +- .../generator/ts/TSReactionGenerator.kt | 4 +- .../lflang/generator/ts/TSStateGenerator.kt | 4 +- .../src/org/lflang/generator/ts/TSTypes.java | 75 + .../src/org/lflang/generator/ts/TSTypes.kt | 57 - .../org/lflang/validation/LFValidator.java | 34 +- test/C/src/ActionDelay.lf | 2 +- test/C/src/ActionIsPresent.lf | 4 +- test/C/src/After.lf | 4 +- test/C/src/AfterCycles.lf | 2 +- test/C/src/AfterOverlapped.lf | 4 +- test/C/src/AfterZero.lf | 4 +- test/C/src/Alignment.lf | 8 +- test/C/src/ArrayAsParameter.lf | 10 +- test/C/src/ArrayAsType.lf | 2 +- test/C/src/ArrayFree.lf | 2 +- test/C/src/ArrayFreeMultiple.lf | 4 +- test/C/src/ArrayPrint.lf | 8 +- test/C/src/ArrayScale.lf | 2 +- test/C/src/CharLiteralInitializer.lf | 2 +- test/C/src/Composition.lf | 6 +- test/C/src/CompositionAfter.lf | 8 +- test/C/src/CompositionInheritance.lf | 6 +- test/C/src/CountSelf.lf | 2 +- test/C/src/Deadline.lf | 8 +- test/C/src/DeadlineHandledAbove.lf | 4 +- test/C/src/DeadlineWithBanks.lf | 4 +- test/C/src/DeadlineZero.lf | 2 +- test/C/src/DelayArray.lf | 4 +- test/C/src/DelayArrayWithAfter.lf | 8 +- test/C/src/DelayInt.lf | 6 +- test/C/src/DelayPointer.lf | 6 +- test/C/src/DelayString.lf | 4 +- test/C/src/DelayStruct.lf | 4 +- test/C/src/DelayStructWithAfter.lf | 2 +- test/C/src/DelayStructWithAfterOverlapped.lf | 4 +- test/C/src/DelayedAction.lf | 2 +- test/C/src/DoubleInvocation.lf | 4 +- test/C/src/DoublePort.lf | 2 +- test/C/src/DoubleReaction.lf | 6 +- test/C/src/DoubleTrigger.lf | 2 +- test/C/src/FloatLiteral.lf | 8 +- test/C/src/Gain.lf | 4 +- test/C/src/GetMicroStep.lf | 2 +- test/C/src/Hello.lf | 10 +- test/C/src/HelloWorld.lf | 2 +- test/C/src/Hierarchy2.lf | 4 +- test/C/src/IdentifierLength.lf | 6 +- test/C/src/ImportComposition.lf | 2 +- test/C/src/InheritanceAction.lf | 2 +- test/C/src/ManualDelayedReaction.lf | 2 +- test/C/src/Methods.lf | 2 +- test/C/src/MethodsRecursive.lf | 2 +- test/C/src/MethodsSameName.lf | 4 +- test/C/src/MovingAverage.lf | 8 +- test/C/src/MultipleContained.lf | 2 +- test/C/src/MultipleOutputs.lf | 2 +- test/C/src/NativeListsAndTimes.lf | 22 +- test/C/src/NestedTriggeredReactions.lf | 4 +- test/C/src/ParameterHierarchy.lf | 16 +- test/C/src/ParameterizedState.lf | 4 +- test/C/src/PeriodicDesugared.lf | 2 +- test/C/src/PingPong.lf | 8 +- test/C/src/ReadOutputOfContainedReactor.lf | 2 +- test/C/src/ScheduleLogicalAction.lf | 2 +- test/C/src/SelfLoop.lf | 2 +- test/C/src/SendingInside.lf | 4 +- test/C/src/SendsPointerTest.lf | 2 +- test/C/src/SetArray.lf | 2 +- test/C/src/SetToken.lf | 2 +- test/C/src/SimpleDeadline.lf | 2 +- test/C/src/SlowingClock.lf | 4 +- test/C/src/SlowingClockPhysical.lf | 4 +- test/C/src/Starvation.lf | 6 +- test/C/src/Stop.lf | 2 +- test/C/src/StopZero.lf | 2 +- test/C/src/Stride.lf | 6 +- test/C/src/StructAsState.lf | 2 +- test/C/src/StructAsType.lf | 2 +- test/C/src/StructAsTypeDirect.lf | 2 +- test/C/src/StructParallel.lf | 6 +- test/C/src/StructPrint.lf | 2 +- test/C/src/StructScale.lf | 6 +- test/C/src/SubclassesAndStartup.lf | 6 +- test/C/src/TimeLimit.lf | 8 +- test/C/src/TimeState.lf | 4 +- test/C/src/Timeout.lf | 2 +- test/C/src/TimeoutZero.lf | 2 +- test/C/src/ToReactionNested.lf | 4 +- test/C/src/TriggerDownstreamOnlyIfPresent2.lf | 2 +- test/C/src/UnconnectedInput.lf | 4 +- test/C/src/arduino/DigitalReadSerial.lf | 2 +- test/C/src/arduino/Fade.lf | 6 +- test/C/src/concurrent/AsyncCallback.lf | 8 +- test/C/src/concurrent/AsyncCallbackDrop.lf | 8 +- test/C/src/concurrent/AsyncCallbackReplace.lf | 8 +- test/C/src/concurrent/CompositionThreaded.lf | 6 +- .../DeadlineHandledAboveThreaded.lf | 4 +- test/C/src/concurrent/DeadlineThreaded.lf | 8 +- test/C/src/concurrent/DelayIntThreaded.lf | 6 +- .../src/concurrent/DoubleReactionThreaded.lf | 6 +- test/C/src/concurrent/GainThreaded.lf | 4 +- test/C/src/concurrent/HelloThreaded.lf | 10 +- test/C/src/concurrent/PingPongThreaded.lf | 8 +- test/C/src/concurrent/ScheduleAt.lf | 17 +- test/C/src/concurrent/ScheduleTwice.lf | 2 +- .../C/src/concurrent/ScheduleTwiceThreaded.lf | 2 +- .../C/src/concurrent/SendingInsideThreaded.lf | 4 +- test/C/src/concurrent/StarvationThreaded.lf | 6 +- test/C/src/concurrent/StopThreaded.lf | 2 +- test/C/src/concurrent/StopZeroThreaded.lf | 2 +- test/C/src/concurrent/Threaded.lf | 8 +- test/C/src/concurrent/ThreadedMultiport.lf | 12 +- test/C/src/concurrent/ThreadedThreaded.lf | 8 +- test/C/src/concurrent/TimeLimitThreaded.lf | 8 +- test/C/src/concurrent/TimeoutThreaded.lf | 2 +- test/C/src/concurrent/TimeoutZeroThreaded.lf | 2 +- test/C/src/concurrent/Tracing.lf | 14 +- .../DistributedCountContainerized.lf | 4 +- test/C/src/federated/BroadcastFeedback.lf | 2 +- .../BroadcastFeedbackWithHierarchy.lf | 4 +- test/C/src/federated/CycleDetection.lf | 2 +- test/C/src/federated/DecentralizedP2PComm.lf | 10 +- .../DecentralizedP2PUnbalancedTimeout.lf | 8 +- ...centralizedP2PUnbalancedTimeoutPhysical.lf | 8 +- test/C/src/federated/DistributedBank.lf | 2 +- .../federated/DistributedBankToMultiport.lf | 2 +- test/C/src/federated/DistributedCount.lf | 4 +- .../DistributedCountDecentralized.lf | 2 +- .../DistributedCountDecentralizedLate.lf | 6 +- ...tributedCountDecentralizedLateHierarchy.lf | 8 +- .../src/federated/DistributedCountPhysical.lf | 4 +- .../DistributedCountPhysicalAfterDelay.lf | 2 +- .../DistributedCountPhysicalDecentralized.lf | 4 +- test/C/src/federated/DistributedDoublePort.lf | 2 +- .../DistributedLogicalActionUpstreamLong.lf | 4 +- .../src/federated/DistributedLoopedAction.lf | 11 +- .../DistributedLoopedActionDecentralized.lf | 19 +- .../DistributedLoopedPhysicalAction.lf | 15 +- test/C/src/federated/DistributedMultiport.lf | 4 +- .../federated/DistributedMultiportToBank.lf | 4 +- .../federated/DistributedMultiportToken.lf | 2 +- .../src/federated/DistributedNetworkOrder.lf | 2 +- .../DistributedPhysicalActionUpstream.lf | 2 +- .../DistributedPhysicalActionUpstreamLong.lf | 2 +- test/C/src/federated/DistributedStop.lf | 6 +- test/C/src/federated/DistributedToken.lf | 6 +- test/C/src/federated/FeedbackDelay.lf | 8 +- test/C/src/federated/FeedbackDelaySimple.lf | 2 +- test/C/src/federated/HelloDistributed.lf | 2 +- .../federated/LoopDistributedCentralized.lf | 6 +- .../federated/LoopDistributedCentralized2.lf | 10 +- ...oopDistributedCentralizedPhysicalAction.lf | 6 +- .../LoopDistributedCentralizedPrecedence.lf | 8 +- ...stributedCentralizedPrecedenceHierarchy.lf | 12 +- .../federated/LoopDistributedDecentralized.lf | 6 +- test/C/src/federated/LoopDistributedDouble.lf | 6 +- test/C/src/federated/PhysicalSTP.lf | 4 +- test/C/src/federated/PingPongDistributed.lf | 2 +- .../federated/PingPongDistributedPhysical.lf | 10 +- test/C/src/federated/TopLevelArtifacts.lf | 2 +- test/C/src/federated/failing/ClockSync.lf | 2 +- .../failing/DistributedDoublePortLooped.lf | 4 +- .../failing/DistributedDoublePortLooped2.lf | 4 +- .../DistributedNetworkOrderDecentralized.lf | 2 +- .../LoopDistributedDecentralizedPrecedence.lf | 8 +- ...ributedDecentralizedPrecedenceHierarchy.lf | 38 +- test/C/src/lib/Count.lf | 4 +- test/C/src/lib/InternalDelay.lf | 2 +- test/C/src/lib/LoopedActionSender.lf | 4 +- test/C/src/lib/Test.lf | 4 +- test/C/src/lib/TestCount.lf | 6 +- test/C/src/lib/TestCountMultiport.lf | 12 +- test/C/src/modal_models/ConvertCaseTest.lf | 4 +- test/C/src/modal_models/Count3Modes.lf | 2 +- test/C/src/modal_models/MixedReactions.lf | 4 +- test/C/src/modal_models/ModalAfter.lf | 4 +- test/C/src/modal_models/ModalCycleBreaker.lf | 4 +- test/C/src/modal_models/ModalStateReset.lf | 6 +- .../C/src/modal_models/ModalStateResetAuto.lf | 6 +- .../MultipleOutputFeeder_2Connections.lf | 4 +- ...ultipleOutputFeeder_ReactionConnections.lf | 4 +- test/C/src/modal_models/util/TraceTesting.lf | 16 +- test/C/src/multiport/BankIndexInitializer.lf | 8 +- .../src/multiport/BankMultiportToReaction.lf | 4 +- .../src/multiport/BankReactionsInContainer.lf | 6 +- test/C/src/multiport/BankSelfBroadcast.lf | 4 +- test/C/src/multiport/BankToBank.lf | 10 +- test/C/src/multiport/BankToBankMultiport.lf | 10 +- .../src/multiport/BankToBankMultiportAfter.lf | 10 +- test/C/src/multiport/BankToMultiport.lf | 8 +- test/C/src/multiport/BankToReaction.lf | 2 +- test/C/src/multiport/Broadcast.lf | 4 +- test/C/src/multiport/BroadcastAfter.lf | 4 +- .../C/src/multiport/BroadcastMultipleAfter.lf | 6 +- test/C/src/multiport/DualBanks.lf | 4 +- test/C/src/multiport/DualBanksMultiport.lf | 4 +- test/C/src/multiport/FullyConnected.lf | 6 +- .../multiport/FullyConnectedAddressable.lf | 8 +- .../FullyConnectedAddressableAfter.lf | 2 +- test/C/src/multiport/MultiportFromBank.lf | 8 +- .../multiport/MultiportFromBankHierarchy.lf | 4 +- .../C/src/multiport/MultiportFromHierarchy.lf | 14 +- test/C/src/multiport/MultiportFromReaction.lf | 8 +- test/C/src/multiport/MultiportIn.lf | 4 +- .../src/multiport/MultiportInParameterized.lf | 6 +- test/C/src/multiport/MultiportMutableInput.lf | 4 +- .../multiport/MultiportMutableInputArray.lf | 4 +- test/C/src/multiport/MultiportOut.lf | 4 +- test/C/src/multiport/MultiportToBank.lf | 8 +- test/C/src/multiport/MultiportToBankAfter.lf | 8 +- test/C/src/multiport/MultiportToBankDouble.lf | 4 +- .../src/multiport/MultiportToBankHierarchy.lf | 10 +- test/C/src/multiport/MultiportToHierarchy.lf | 12 +- test/C/src/multiport/MultiportToMultiport.lf | 10 +- test/C/src/multiport/MultiportToMultiport2.lf | 10 +- .../multiport/MultiportToMultiport2After.lf | 4 +- .../multiport/MultiportToMultiportArray.lf | 4 +- .../MultiportToMultiportParameter.lf | 10 +- test/C/src/multiport/MultiportToPort.lf | 4 +- test/C/src/multiport/MultiportToReaction.lf | 6 +- test/C/src/multiport/NestedBanks.lf | 10 +- .../C/src/multiport/NestedInterleavedBanks.lf | 4 +- .../src/multiport/ReactionToContainedBank.lf | 4 +- .../src/multiport/ReactionToContainedBank2.lf | 6 +- .../ReactionToContainedBankMultiport.lf | 4 +- test/C/src/multiport/ReactionsToNested.lf | 4 +- test/C/src/multiport/Sparse.lf | 8 +- test/C/src/multiport/SparseFallback.lf | 8 +- .../TriggerDownstreamOnlyIfPresent.lf | 2 +- .../serialization/ROSBuiltInSerialization.lf | 4 +- .../ROSBuiltInSerializationSharedPtr.lf | 4 +- test/C/src/target/HelloWorldCCPP.lf | 2 +- test/C/src/token/TokenContainedPrint.lf | 2 +- test/C/src/token/TokenContainedPrintBank.lf | 2 +- test/C/src/token/TokenContainedSource.lf | 6 +- test/C/src/token/TokenContainedSourceBank.lf | 6 +- test/C/src/token/lib/Token.lf | 10 +- test/Cpp/src/ActionDelay.lf | 2 +- test/Cpp/src/ActionIsPresent.lf | 6 +- test/Cpp/src/ActionValues.lf | 4 +- test/Cpp/src/After.lf | 4 +- test/Cpp/src/AfterOverlapped.lf | 2 +- test/Cpp/src/AfterZero.lf | 4 +- test/Cpp/src/Alignment.lf | 2 +- test/Cpp/src/ArrayAsParameter.lf | 8 +- test/Cpp/src/ArrayPrint.lf | 2 +- test/Cpp/src/ArrayScale.lf | 2 +- test/Cpp/src/CharLiteralInitializer.lf | 2 +- test/Cpp/src/Composition.lf | 6 +- test/Cpp/src/CompositionAfter.lf | 8 +- test/Cpp/src/CountTest.lf | 2 +- test/Cpp/src/Deadline.lf | 8 +- test/Cpp/src/DeadlineHandledAbove.lf | 4 +- test/Cpp/src/DelayInt.lf | 2 +- test/Cpp/src/DelayedAction.lf | 2 +- test/Cpp/src/DoubleInvocation.lf | 4 +- test/Cpp/src/DoublePort.lf | 2 +- test/Cpp/src/DoubleReaction.lf | 6 +- test/Cpp/src/DoubleTrigger.lf | 2 +- test/Cpp/src/FloatLiteral.lf | 8 +- test/Cpp/src/Gain.lf | 2 +- test/Cpp/src/GetMicroStep.lf | 2 +- test/Cpp/src/Hello.lf | 11 +- test/Cpp/src/Hierarchy2.lf | 4 +- test/Cpp/src/ImportComposition.lf | 2 +- test/Cpp/src/ManualDelayedReaction.lf | 2 +- test/Cpp/src/Methods.lf | 2 +- test/Cpp/src/MovingAverage.lf | 6 +- test/Cpp/src/NativeListsAndTimes.lf | 20 +- test/Cpp/src/NestedTriggeredReactions.lf | 4 +- test/Cpp/src/ParameterHierarchy.lf | 6 +- test/Cpp/src/ParameterizedState.lf | 4 +- test/Cpp/src/ParametersOutOfOrder.lf | 2 +- test/Cpp/src/PeriodicDesugared.lf | 4 +- test/Cpp/src/Pipeline.lf | 4 +- test/Cpp/src/ReadOutputOfContainedReactor.lf | 2 +- test/Cpp/src/ScheduleLogicalAction.lf | 2 +- test/Cpp/src/SelfLoop.lf | 2 +- test/Cpp/src/SendingInside.lf | 4 +- test/Cpp/src/SimpleDeadline.lf | 2 +- test/Cpp/src/SlowingClock.lf | 4 +- test/Cpp/src/SlowingClockPhysical.lf | 4 +- test/Cpp/src/Stride.lf | 4 +- test/Cpp/src/StructPrint.lf | 4 +- test/Cpp/src/StructScale.lf | 2 +- test/Cpp/src/TimeLimit.lf | 8 +- test/Cpp/src/TimeState.lf | 4 +- test/Cpp/src/Timeout_Test.lf | 2 +- test/Cpp/src/ToReactionNested.lf | 4 +- .../src/TriggerDownstreamOnlyIfPresent2.lf | 2 +- test/Cpp/src/concurrent/AsyncCallback.lf | 6 +- test/Cpp/src/concurrent/AsyncCallback2.lf | 4 +- .../Cpp/src/concurrent/CompositionThreaded.lf | 6 +- .../DeadlineHandledAboveThreaded.lf | 4 +- test/Cpp/src/concurrent/DeadlineThreaded.lf | 8 +- test/Cpp/src/concurrent/DelayIntThreaded.lf | 2 +- .../src/concurrent/DoubleReactionThreaded.lf | 6 +- test/Cpp/src/concurrent/GainThreaded.lf | 2 +- test/Cpp/src/concurrent/HelloThreaded.lf | 11 +- .../src/concurrent/SendingInsideThreaded.lf | 4 +- test/Cpp/src/concurrent/Threaded.lf | 4 +- test/Cpp/src/concurrent/ThreadedThreaded.lf | 4 +- test/Cpp/src/concurrent/TimeLimitThreaded.lf | 8 +- test/Cpp/src/enclave/EnclaveBank.lf | 8 +- test/Cpp/src/enclave/EnclaveBankEach.lf | 8 +- test/Cpp/src/enclave/EnclaveHelloWorld.lf | 4 +- test/Cpp/src/enclave/EnclaveHierarchy.lf | 6 +- test/Cpp/src/enclave/EnclaveShutdown.lf | 6 +- test/Cpp/src/enclave/EnclaveTimeout.lf | 2 +- test/Cpp/src/lib/Count.lf | 2 +- test/Cpp/src/lib/LoopedActionSender.lf | 4 +- test/Cpp/src/multiport/BankSelfBroadcast.lf | 4 +- test/Cpp/src/multiport/BankToBank.lf | 10 +- test/Cpp/src/multiport/BankToBankMultiport.lf | 10 +- .../src/multiport/BankToBankMultiportAfter.lf | 12 +- test/Cpp/src/multiport/BankToMultiport.lf | 4 +- test/Cpp/src/multiport/Broadcast.lf | 2 +- test/Cpp/src/multiport/BroadcastAfter.lf | 4 +- .../src/multiport/BroadcastMultipleAfter.lf | 6 +- test/Cpp/src/multiport/FullyConnected.lf | 6 +- .../multiport/FullyConnectedAddressable.lf | 6 +- .../FullyConnectedAddressableAfter.lf | 2 +- .../src/multiport/IndexIntoMultiportOutput.lf | 10 +- test/Cpp/src/multiport/Multiport.lf | 2 +- test/Cpp/src/multiport/MultiportFromBank.lf | 8 +- .../multiport/MultiportFromBankHierarchy.lf | 4 +- .../MultiportFromBankHierarchyAfter.lf | 4 +- .../src/multiport/MultiportFromHierarchy.lf | 4 +- test/Cpp/src/multiport/MultiportIn.lf | 4 +- test/Cpp/src/multiport/MultiportOut.lf | 4 +- test/Cpp/src/multiport/MultiportToBank.lf | 2 +- .../Cpp/src/multiport/MultiportToBankAfter.lf | 2 +- .../src/multiport/MultiportToBankHierarchy.lf | 4 +- .../Cpp/src/multiport/MultiportToHierarchy.lf | 12 +- .../Cpp/src/multiport/MultiportToMultiport.lf | 2 +- .../src/multiport/MultiportToMultiport2.lf | 4 +- .../multiport/MultiportToMultiport2After.lf | 4 +- .../multiport/MultiportToMultiportArray.lf | 4 +- test/Cpp/src/multiport/MultiportToPort.lf | 4 +- .../ReadMultiportOutputOfContainedBank.lf | 4 +- .../multiport/ReadOutputOfContainedBank.lf | 4 +- test/Cpp/src/multiport/WidthGivenByCode.lf | 2 +- .../multiport/WriteInputOfContainedBank.lf | 4 +- .../WriteMultiportInputOfContainedBank.lf | 4 +- test/Cpp/src/properties/Fast.lf | 2 +- test/Cpp/src/properties/Timeout.lf | 2 +- test/Cpp/src/properties/TimeoutZero.lf | 2 +- test/Cpp/src/target/AfterVoid.lf | 4 +- .../src/target/BraceAndParenInitialization.lf | 5 +- .../src/target/CliParserGenericArguments.lf | 26 +- test/Cpp/src/target/CombinedTypeNames.lf | 10 +- test/Cpp/src/target/GenericDelay.lf | 2 +- .../src/target/GenericParameterAndState.lf | 4 +- test/Cpp/src/target/InitializerSyntax.lf | 89 + test/Cpp/src/target/PointerParameters.lf | 2 +- test/Python/src/ActionDelay.lf | 2 +- test/Python/src/ActionIsPresent.lf | 6 +- test/Python/src/After.lf | 4 +- test/Python/src/AfterCycles.lf | 2 +- test/Python/src/AfterOverlapped.lf | 4 +- test/Python/src/ArrayAsParameter.lf | 8 +- test/Python/src/ArrayAsType.lf | 2 +- test/Python/src/ArrayFree.lf | 2 +- test/Python/src/ArrayPrint.lf | 2 +- test/Python/src/ArrayScale.lf | 2 +- test/Python/src/Composition.lf | 6 +- test/Python/src/CompositionAfter.lf | 8 +- test/Python/src/CompositionInheritance.lf | 6 +- test/Python/src/CountSelf.lf | 4 +- test/Python/src/CountTest.lf | 2 +- test/Python/src/Deadline.lf | 8 +- test/Python/src/DeadlineHandledAbove.lf | 4 +- test/Python/src/DelayArray.lf | 4 +- test/Python/src/DelayArrayWithAfter.lf | 8 +- test/Python/src/DelayInt.lf | 6 +- test/Python/src/DelayString.lf | 4 +- test/Python/src/DelayStruct.lf | 4 +- test/Python/src/DelayStructWithAfter.lf | 2 +- .../src/DelayStructWithAfterOverlapped.lf | 4 +- test/Python/src/DelayedAction.lf | 2 +- test/Python/src/DoubleInvocation.lf | 4 +- test/Python/src/DoubleReaction.lf | 6 +- test/Python/src/FloatLiteral.lf | 8 +- test/Python/src/Gain.lf | 4 +- test/Python/src/GetMicroStep.lf | 2 +- test/Python/src/Hello.lf | 8 +- test/Python/src/HelloWorld.lf | 2 +- test/Python/src/Hierarchy2.lf | 4 +- test/Python/src/IdentifierLength.lf | 6 +- test/Python/src/ImportComposition.lf | 2 +- test/Python/src/ManualDelayedReaction.lf | 2 +- test/Python/src/Methods.lf | 2 +- test/Python/src/MethodsRecursive.lf | 2 +- test/Python/src/MethodsSameName.lf | 4 +- test/Python/src/MovingAverage.lf | 6 +- test/Python/src/MultipleContained.lf | 2 +- test/Python/src/NativeListsAndTimes.lf | 14 +- test/Python/src/ParameterizedState.lf | 4 +- test/Python/src/PeriodicDesugared.lf | 2 +- test/Python/src/PingPong.lf | 8 +- test/Python/src/Pipeline.lf | 6 +- .../src/ReadOutputOfContainedReactor.lf | 2 +- test/Python/src/ScheduleLogicalAction.lf | 2 +- test/Python/src/SelfLoop.lf | 2 +- test/Python/src/SendingInside.lf | 4 +- test/Python/src/SetArray.lf | 2 +- test/Python/src/SimpleDeadline.lf | 2 +- test/Python/src/SlowingClock.lf | 4 +- test/Python/src/SlowingClockPhysical.lf | 4 +- test/Python/src/Stride.lf | 6 +- test/Python/src/StructAsState.lf | 2 +- test/Python/src/StructAsType.lf | 2 +- test/Python/src/StructAsTypeDirect.lf | 2 +- test/Python/src/StructParallel.lf | 4 +- test/Python/src/StructPrint.lf | 2 +- test/Python/src/StructScale.lf | 4 +- test/Python/src/SubclassesAndStartup.lf | 6 +- test/Python/src/TimeLimit.lf | 8 +- test/Python/src/TimeState.lf | 4 +- test/Python/src/Timers.lf | 2 +- .../src/TriggerDownstreamOnlyIfPresent.lf | 2 +- .../src/TriggerDownstreamOnlyIfPresent2.lf | 2 +- test/Python/src/UnconnectedInput.lf | 4 +- test/Python/src/concurrent/AsyncCallback.lf | 8 +- .../src/concurrent/AsyncCallbackNoTimer.lf | 8 +- .../src/docker/FilesPropertyContainerized.lf | 2 +- .../DistributedCountContainerized.lf | 2 +- .../Python/src/federated/BroadcastFeedback.lf | 2 +- .../BroadcastFeedbackWithHierarchy.lf | 4 +- test/Python/src/federated/CycleDetection.lf | 2 +- .../src/federated/DecentralizedP2PComm.lf | 6 +- .../DecentralizedP2PUnbalancedTimeout.lf | 8 +- ...centralizedP2PUnbalancedTimeoutPhysical.lf | 8 +- test/Python/src/federated/DistributedBank.lf | 2 +- .../federated/DistributedBankToMultiport.lf | 2 +- test/Python/src/federated/DistributedCount.lf | 4 +- .../DistributedCountDecentralized.lf | 2 +- .../DistributedCountDecentralizedLate.lf | 6 +- ...ributedCountDecentralizedLateDownstream.lf | 8 +- ...tributedCountDecentralizedLateHierarchy.lf | 2 +- .../src/federated/DistributedCountPhysical.lf | 4 +- .../DistributedCountPhysicalAfterDelay.lf | 4 +- .../DistributedCountPhysicalDecentralized.lf | 4 +- .../src/federated/DistributedDoublePort.lf | 2 +- .../src/federated/DistributedLoopedAction.lf | 8 +- .../DistributedLoopedPhysicalAction.lf | 12 +- .../src/federated/DistributedMultiport.lf | 4 +- .../federated/DistributedMultiportToBank.lf | 4 +- .../federated/DistributedMultiportToken.lf | 2 +- test/Python/src/federated/DistributedStop.lf | 6 +- test/Python/src/federated/HelloDistributed.lf | 2 +- ...stributedCentralizedPrecedenceHierarchy.lf | 12 +- test/Python/src/federated/PhysicalSTP.lf | 4 +- .../src/federated/PingPongDistributed.lf | 10 +- .../LoopDistributedCentralizedPrecedence.lf | 8 +- .../failing/LoopDistributedDouble.lf | 6 +- test/Python/src/lib/Count.lf | 4 +- test/Python/src/lib/InternalDelay.lf | 2 +- test/Python/src/lib/LoopedActionSender.lf | 4 +- test/Python/src/lib/Test.lf | 2 +- test/Python/src/lib/TestCount.lf | 6 +- test/Python/src/lib/TestCountMultiport.lf | 6 +- .../src/modal_models/ConvertCaseTest.lf | 4 +- test/Python/src/modal_models/Count3Modes.lf | 2 +- test/Python/src/modal_models/ModalAfter.lf | 4 +- .../src/modal_models/ModalCycleBreaker.lf | 4 +- .../src/modal_models/ModalStateReset.lf | 6 +- .../src/modal_models/ModalStateResetAuto.lf | 6 +- .../MultipleOutputFeeder_2Connections.lf | 4 +- ...ultipleOutputFeeder_ReactionConnections.lf | 4 +- .../src/modal_models/util/TraceTesting.lf | 10 +- .../src/multiport/BankIndexInitializer.lf | 8 +- .../src/multiport/BankReactionsInContainer.lf | 6 +- test/Python/src/multiport/BankToBank.lf | 10 +- .../src/multiport/BankToBankMultiport.lf | 10 +- .../src/multiport/BankToBankMultiportAfter.lf | 2 +- test/Python/src/multiport/BankToMultiport.lf | 8 +- test/Python/src/multiport/Broadcast.lf | 6 +- .../src/multiport/BroadcastMultipleAfter.lf | 4 +- .../Python/src/multiport/MultiportFromBank.lf | 4 +- .../multiport/MultiportFromBankHierarchy.lf | 2 +- .../src/multiport/MultiportFromHierarchy.lf | 4 +- .../src/multiport/MultiportFromReaction.lf | 6 +- test/Python/src/multiport/MultiportIn.lf | 4 +- .../src/multiport/MultiportInParameterized.lf | 6 +- .../src/multiport/MultiportMutableInput.lf | 4 +- .../multiport/MultiportMutableInputArray.lf | 4 +- test/Python/src/multiport/MultiportOut.lf | 4 +- test/Python/src/multiport/MultiportToBank.lf | 4 +- .../src/multiport/MultiportToBankAfter.lf | 4 +- .../src/multiport/MultiportToBankHierarchy.lf | 4 +- .../src/multiport/MultiportToHierarchy.lf | 8 +- .../src/multiport/MultiportToMultiport.lf | 4 +- .../src/multiport/MultiportToMultiport2.lf | 4 +- .../multiport/MultiportToMultiport2After.lf | 2 +- .../multiport/MultiportToMultiportArray.lf | 4 +- .../MultiportToMultiportParameter.lf | 2 +- test/Python/src/multiport/MultiportToPort.lf | 4 +- .../src/multiport/MultiportToReaction.lf | 6 +- test/Python/src/multiport/NestedBanks.lf | 10 +- .../src/multiport/NestedInterleavedBanks.lf | 4 +- .../Python/src/multiport/ReactionsToNested.lf | 4 +- test/Python/src/target/AfterNoTypes.lf | 4 +- test/Rust/src/ActionDelay.lf | 2 +- test/Rust/src/ActionImplicitDelay.lf | 2 +- test/Rust/src/ActionIsPresent.lf | 4 +- test/Rust/src/ActionScheduleMicrostep.lf | 2 +- test/Rust/src/ActionValues.lf | 4 +- test/Rust/src/ActionValuesCleanup.lf | 2 +- test/Rust/src/CtorParamDefault.lf | 4 +- test/Rust/src/CtorParamMixed.lf | 12 +- test/Rust/src/CtorParamSimple.lf | 4 +- test/Rust/src/DependencyOnChildPort.lf | 2 +- test/Rust/src/DependencyUseOnLogicalAction.lf | 2 +- test/Rust/src/FloatLiteral.lf | 8 +- test/Rust/src/MainReactorParam.lf | 6 +- test/Rust/src/MovingAverage.lf | 9 +- test/Rust/src/NativeListsAndTimes.lf | 14 +- test/Rust/src/PortConnectionInSelfInChild.lf | 2 +- test/Rust/src/PortConnectionInSelfOutSelf.lf | 2 +- .../Rust/src/PortConnectionOutChildOutSelf.lf | 4 +- test/Rust/src/PortRefCleanup.lf | 4 +- test/Rust/src/PortValueCleanup.lf | 4 +- test/Rust/src/ReservedKeywords.lf | 4 +- test/Rust/src/StateInitializerVisibility.lf | 4 +- test/Rust/src/Stop.lf | 10 +- test/Rust/src/StopIdempotence.lf | 2 +- test/Rust/src/StopTimeoutExact.lf | 2 +- test/Rust/src/StructAsState.lf | 2 +- test/Rust/src/StructAsType.lf | 4 +- test/Rust/src/TimeState.lf | 2 +- test/Rust/src/TimerDefaults.lf | 2 +- test/Rust/src/TimerIsPresent.lf | 4 +- test/Rust/src/TimerPeriodic.lf | 2 +- test/Rust/src/Timers.lf | 2 +- test/Rust/src/TypeVarLengthList.lf | 2 +- test/Rust/src/concurrent/AsyncCallback.lf | 10 +- test/Rust/src/generics/CtorParamGeneric.lf | 4 +- .../Rust/src/generics/CtorParamGenericInst.lf | 6 +- test/Rust/src/generics/GenericReactor.lf | 2 +- .../src/multiport/ConnectionToSelfBank.lf | 8 +- .../multiport/ConnectionToSelfMultiport.lf | 6 +- test/Rust/src/multiport/CycledLhs_SelfLoop.lf | 2 +- test/Rust/src/multiport/CycledLhs_Single.lf | 2 +- test/Rust/src/multiport/FullyConnected.lf | 10 +- .../multiport/FullyConnectedAddressable.lf | 10 +- test/Rust/src/multiport/MultiportFromBank.lf | 6 +- .../src/multiport/MultiportFromHierarchy.lf | 4 +- test/Rust/src/multiport/MultiportIn.lf | 4 +- test/Rust/src/multiport/MultiportOut.lf | 4 +- test/Rust/src/multiport/MultiportToBank.lf | 6 +- .../src/multiport/MultiportToBankHierarchy.lf | 6 +- .../src/multiport/MultiportToMultiport2.lf | 4 +- .../multiport/ReadOutputOfContainedBank.lf | 6 +- test/Rust/src/multiport/WidthWithParameter.lf | 2 +- .../multiport/WriteInputOfContainedBank.lf | 6 +- test/Rust/src/target/CliFeature.lf | 2 +- .../target/MainParameterCanBeExpression.lf | 4 +- test/TypeScript/src/ActionDelay.lf | 2 +- test/TypeScript/src/After.lf | 2 +- test/TypeScript/src/ArrayAsParameter.lf | 6 +- test/TypeScript/src/ArrayAsType.lf | 2 +- test/TypeScript/src/ArrayPrint.lf | 2 +- test/TypeScript/src/ArrayScale.lf | 2 +- test/TypeScript/src/Composition.lf | 6 +- test/TypeScript/src/CompositionAfter.lf | 8 +- test/TypeScript/src/CountTest.lf | 2 +- test/TypeScript/src/Deadline.lf | 8 +- test/TypeScript/src/DeadlineHandledAbove.lf | 4 +- test/TypeScript/src/DelayInt.lf | 6 +- test/TypeScript/src/DelayedAction.lf | 2 +- test/TypeScript/src/DoubleInvocation.lf | 4 +- test/TypeScript/src/DoubleReaction.lf | 6 +- test/TypeScript/src/DoubleTrigger.lf | 2 +- test/TypeScript/src/FloatLiteral.lf | 8 +- test/TypeScript/src/Gain.lf | 4 +- test/TypeScript/src/Hello.lf | 10 +- test/TypeScript/src/Hierarchy2.lf | 4 +- test/TypeScript/src/MovingAverage.lf | 8 +- test/TypeScript/src/NativeListsAndTimes.lf | 14 +- test/TypeScript/src/ParameterizedState.lf | 4 +- test/TypeScript/src/PeriodicDesugared.lf | 4 +- .../src/ReadOutputOfContainedReactor.lf | 2 +- test/TypeScript/src/ScheduleLogicalAction.lf | 2 +- test/TypeScript/src/SendingInside.lf | 4 +- test/TypeScript/src/SendsPointerTest.lf | 2 +- test/TypeScript/src/SimpleDeadline.lf | 2 +- test/TypeScript/src/SlowingClock.lf | 4 +- test/TypeScript/src/SlowingClockPhysical.lf | 4 +- test/TypeScript/src/Stop.lf | 2 +- test/TypeScript/src/Stride.lf | 4 +- test/TypeScript/src/StructAsState.lf | 2 +- test/TypeScript/src/StructAsType.lf | 2 +- test/TypeScript/src/StructAsTypeDirect.lf | 2 +- test/TypeScript/src/StructPrint.lf | 2 +- test/TypeScript/src/StructScale.lf | 2 +- test/TypeScript/src/TimeLimit.lf | 8 +- test/TypeScript/src/TimeState.lf | 4 +- .../src/concurrent/AsyncCallback.lf | 6 +- .../DistributedCountContainerized.lf | 2 +- .../src/federated/DistributedCount.lf | 4 +- .../src/federated/DistributedCountPhysical.lf | 6 +- .../DistributedCountPhysicalAfterDelay.lf | 49 + .../src/federated/DistributedDoublePort.lf | 2 +- .../src/federated/DistributedLoopedAction.lf | 8 +- .../DistributedLoopedPhysicalAction.lf | 12 +- .../src/federated/DistributedStop.lf | 6 +- .../src/federated/HelloDistributed.lf | 2 +- .../federated/LoopDistributedCentralized.lf | 6 +- .../src/federated/LoopDistributedDouble.lf | 6 +- .../src/federated/PingPongDistributed.lf | 10 +- .../federated/PingPongDistributedPhysical.lf | 10 +- .../src/federated/TopLevelArtifacts.lf | 2 +- test/TypeScript/src/lib/Count.lf | 4 +- test/TypeScript/src/lib/InternalDelay.lf | 2 +- test/TypeScript/src/lib/LoopedActionSender.lf | 4 +- test/TypeScript/src/lib/TestCount.lf | 10 +- .../src/multiport/BankMultiportToReaction.lf | 4 +- .../src/multiport/BankReactionsInContainer.lf | 4 +- .../src/multiport/BankSelfBroadcast.lf | 2 +- test/TypeScript/src/multiport/BankToBank.lf | 6 +- .../src/multiport/BankToBankMultiport.lf | 10 +- .../src/multiport/BankToBankMultiportAfter.lf | 10 +- .../src/multiport/BankToMultiport.lf | 2 +- .../src/multiport/BankToReaction.lf | 2 +- .../src/multiport/BroadcastAfter.lf | 2 +- .../src/multiport/BroadcastMultipleAfter.lf | 4 +- .../src/multiport/FullyConnected.lf | 6 +- .../src/multiport/MultiportFromBank.lf | 6 +- .../multiport/MultiportFromBankHierarchy.lf | 2 +- .../src/multiport/MultiportFromHierarchy.lf | 14 +- .../src/multiport/MultiportFromReaction.lf | 8 +- test/TypeScript/src/multiport/MultiportIn.lf | 4 +- .../src/multiport/MultiportInParameterized.lf | 6 +- .../src/multiport/MultiportMutableInput.lf | 4 +- .../multiport/MultiportMutableInputArray.lf | 4 +- test/TypeScript/src/multiport/MultiportOut.lf | 4 +- .../src/multiport/MultiportToBankAfter.lf | 6 +- .../src/multiport/MultiportToBankDouble.lf | 2 +- .../src/multiport/MultiportToBankHierarchy.lf | 2 +- .../src/multiport/MultiportToHierarchy.lf | 12 +- .../src/multiport/MultiportToMultiport.lf | 2 +- .../src/multiport/MultiportToMultiport2.lf | 4 +- .../multiport/MultiportToMultiport2After.lf | 4 +- .../multiport/MultiportToMultiportArray.lf | 4 +- .../MultiportToMultiportParameter.lf | 10 +- .../src/multiport/MultiportToPort.lf | 4 +- .../src/multiport/MultiportToReaction.lf | 6 +- test/TypeScript/src/multiport/NestedBanks.lf | 6 +- .../src/multiport/ReactionToContainedBank.lf | 4 +- .../src/multiport/ReactionsToNested.lf | 4 +- test/TypeScript/src/target/AfterNoTypes.lf | 2 +- 698 files changed, 3285 insertions(+), 3471 deletions(-) create mode 100644 org.lflang/src/org/lflang/generator/LfExpressionVisitor.java create mode 100644 org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java delete mode 100644 org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.kt create mode 100644 org.lflang/src/org/lflang/generator/ts/TSTypes.java delete mode 100644 org.lflang/src/org/lflang/generator/ts/TSTypes.kt create mode 100644 test/Cpp/src/target/InitializerSyntax.lf create mode 100644 test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java index ae325ab94d..d7862e5d25 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java @@ -34,7 +34,7 @@ public void testSimple() { @Test public void testAssignments() { - assertIsFormatted( + assertFormatsTo( """ target C @@ -43,6 +43,15 @@ public void testAssignments() { input in: int state last_invoked: tag_t({= NEVER_TAG_INITIALIZER =}) } + """, + """ + target C + + reactor Destination { + input ok: bool + input in: int + state last_invoked: tag_t = {= NEVER_TAG_INITIALIZER =} + } """ ); } @@ -56,16 +65,34 @@ public void testState() { reactor Destination { state one_init: tag_t( {= NEVER_TAG_INITIALIZER =}) state no_init: tag_t - state list_init(1,2) + state list_init(1,2) // this syntax is deprecated } """, """ target Python + reactor Destination { + state one_init: tag_t = {= NEVER_TAG_INITIALIZER =} + state no_init: tag_t + state list_init(1, 2) # this syntax is deprecated + } + """ + ); + } + + @Test + public void testCppInits() { + assertIsFormatted( + """ + target Cpp + reactor Destination { state one_init: tag_t({= NEVER_TAG_INITIALIZER =}) state no_init: tag_t - state list_init(1, 2) + state assign: int = 0 + state paren: int(0) + state brace: std::vector{1, 2} + state paren_list: std::vector(1, 2) } """ ); diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java index 3e40927de0..a78d41ac4d 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java @@ -101,7 +101,7 @@ public void testLet() throws Exception { )); Assertions.assertNotNull(model); - final var ctypes = new CTypes(new DefaultErrorReporter()); + final var ctypes = CTypes.getInstance(); final var resource = model.eResource(); final var transformation = new DelayedConnectionTransformation(new CDelayBodyGenerator(ctypes), ctypes, resource, true, true); transformation.applyTransformation(ASTUtils.getAllReactors(resource)); diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java index 4c0d5dee08..67df93ed30 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java @@ -1,29 +1,30 @@ /* Scoping unit tests. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + Copyright (c) 2019, The University of California at Berkeley. + + 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. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ + package org.lflang.tests.compiler; import java.util.LinkedList; @@ -63,7 +64,7 @@ /** * Collection of unit tests to ensure validation is done correctly. - * + * * @author Edward A. Lee * @author Marten Lohstroh * @author Matt Weber @@ -71,7 +72,8 @@ * @author Alexander Schulz-Rosengarten */ public class LinguaFrancaValidationTest { - @Inject + + @Inject ParseHelper parser; @Inject @@ -79,6 +81,7 @@ public class LinguaFrancaValidationTest { /** * Helper function to parse a Lingua Franca program and expect no errors. + * * @return A model representing the parsed string. */ private Model parseWithoutError(String s) throws Exception { @@ -92,6 +95,7 @@ private Model parseWithoutError(String s) throws Exception { /** * Helper function to parse a Lingua Franca program and expect errors. + * * @return A model representing the parsed string. */ private Model parseWithError(String s) throws Exception { @@ -99,105 +103,72 @@ private Model parseWithError(String s) throws Exception { Assertions.assertNotNull(model); Assertions.assertFalse(model.eResource().getErrors().isEmpty()); return model; - } + } /** * Ensure that duplicate identifiers for actions reported. */ @Test public void duplicateVariable() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// main reactor Foo { -// logical action bar; -// physical action bar; -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "main reactor Foo {", - " logical action bar;", - " physical action bar;", - "}"); - validator.assertError(parseWithoutError(testCase), - LfPackage.eINSTANCE.getAction(), - null, - "Duplicate Variable 'bar' in Reactor 'Foo'"); + String testCase = """ + target TypeScript; + main reactor Foo { + logical action bar; + physical action bar; + } + """; + validator.assertError(parseWithoutError(testCase), + LfPackage.eINSTANCE.getAction(), + null, + "Duplicate Variable 'bar' in Reactor 'Foo'"); } /** - * Check that reactors in C++ cannot be named preamble + * Check that reactors in C++ cannot be named preamble */ @Test public void disallowReactorCalledPreamble() throws Exception { -// Java 17: -// Model model_no_errors = """ -// target Cpp; -// main reactor { -// } -// """ -// Java 11: - Model model_no_errors = parser.parse(String.join( - System.getProperty("line.separator"), - "target Cpp;", - "main reactor {", - "}" - )); - -// Java 17: -// Model model_error_1 = """ -// target Cpp; -// main reactor Preamble { -// } -// """ -// Java 11: - Model model_error_1 = parser.parse(String.join( - System.getProperty("line.separator"), - "target Cpp;", - "main reactor Preamble {", - "}" - )); - -// Java 17: -// Model model_error_2 = """ -// target Cpp; -// reactor Preamble { -// } -// main reactor Main { -// } -// """ -// Java 11: - Model model_error_2 = parser.parse(String.join( - System.getProperty("line.separator"), - "target Cpp;", - "reactor Preamble {", - "}", - "main reactor Main {", - "}" - )); - + Model model_no_errors = parser.parse(""" + target Cpp; + main reactor { + } + """); + + Model model_error_1 = parser.parse(""" + target Cpp; + main reactor Preamble { + } + """); + + Model model_error_2 = parser.parse(""" + target Cpp; + reactor Preamble { + } + main reactor Main { + } + """); + Assertions.assertNotNull(model_no_errors); Assertions.assertNotNull(model_error_1); Assertions.assertNotNull(model_error_2); - Assertions.assertTrue(model_no_errors.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + model_no_errors.eResource().getErrors()); - Assertions.assertTrue(model_error_1.eResource().getErrors().isEmpty(), + Assertions.assertTrue(model_no_errors.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + + model_no_errors.eResource().getErrors()); + Assertions.assertTrue(model_error_1.eResource().getErrors().isEmpty(), "Encountered unexpected error while parsing: " + model_error_1.eResource().getErrors()); - Assertions.assertTrue(model_error_2.eResource().getErrors().isEmpty(), + Assertions.assertTrue(model_error_2.eResource().getErrors().isEmpty(), "Encountered unexpected error while parsing: " + model_error_2.eResource().getErrors()); validator.assertNoIssues(model_no_errors); - validator.assertError(model_error_1, - LfPackage.eINSTANCE.getReactor(), - null, - "Reactor cannot be named 'Preamble'"); - validator.assertError(model_error_2, - LfPackage.eINSTANCE.getReactor(), - null, - "Reactor cannot be named 'Preamble'"); + validator.assertError(model_error_1, + LfPackage.eINSTANCE.getReactor(), + null, + "Reactor cannot be named 'Preamble'"); + validator.assertError(model_error_2, + LfPackage.eINSTANCE.getReactor(), + null, + "Reactor cannot be named 'Preamble'"); } @@ -206,59 +177,39 @@ public void disallowReactorCalledPreamble() throws Exception { */ @Test public void disallowUnderscoreInputs() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// main reactor { -// input __bar; -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "main reactor {", - " input __bar;", - "}"); + String testCase = """ + target TypeScript; + main reactor { + input __bar; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); } - + @Test public void disallowMainWithDifferentNameThanFile() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// main reactor Foo {} -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor Foo {}" - ); + String testCase = """ + target C; + main reactor Foo {} + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, "Name of main reactor must match the file name (or be omitted)"); } - + /** * Ensure that "__" is not allowed at the start of an output name. */ @Test public void disallowUnderscoreOutputs() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// main reactor Foo { -// output __bar; -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "main reactor Foo {", - " output __bar;", - "}"); + String testCase = """ + target TypeScript; + main reactor Foo { + output __bar; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getOutput(), null, "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); @@ -269,324 +220,207 @@ public void disallowUnderscoreOutputs() throws Exception { */ @Test public void disallowUnderscoreActions() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// main reactor Foo { -// logical action __bar; -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "main reactor Foo {", - " logical action __bar;", - "}"); + String testCase = """ + target TypeScript; + main reactor Foo { + logical action __bar; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAction(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); } - + /** * Ensure that "__" is not allowed at the start of a timer name. */ @Test public void disallowUnderscoreTimers() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// main reactor Foo { -// timer __bar(0); -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "main reactor Foo {", - " timer __bar(0);", - "}"); + String testCase = """ + target TypeScript; + main reactor Foo { + timer __bar(0); + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); } - + /** * Ensure that "__" is not allowed at the start of a parameter name. */ @Test public void disallowUnderscoreParameters() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// main reactor Foo(__bar) { -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "main reactor Foo(__bar) {", - "}"); + String testCase = """ + target TypeScript; + main reactor Foo(__bar) { + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getParameter(), null, "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); } - + /** * Ensure that "__" is not allowed at the start of an state name. */ @Test public void disallowUnderscoreStates() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// main reactor Foo { -// state __bar; -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "main reactor Foo {", - " state __bar;", - "}"); + String testCase = """ + target TypeScript; + main reactor Foo { + state __bar; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); } - + /** * Ensure that "__" is not allowed at the start of a reactor definition name. */ @Test public void disallowUnderscoreReactorDef() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// main reactor __Foo { -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "main reactor __Foo {", - "}"); + String testCase = """ + target TypeScript; + main reactor __Foo { + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __Foo"); } - + /** * Ensure that "__" is not allowed at the start of a reactor instantiation name. */ @Test public void disallowUnderscoreReactorInstantiation() throws Exception { -// Java 17: -// String testCase = """ -// target TypeScript; -// reactor Foo { -// } -// main reactor Bar { -// __x = new Foo(); -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target TypeScript;", - "reactor Foo {", - "}", - "main reactor Bar {", - " __x = new Foo();", - "}"); + String testCase = """ + target TypeScript; + reactor Foo { + } + main reactor Bar { + __x = new Foo(); + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInstantiation(), null, "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __x"); } - + /** * Disallow connection to port that is effect of reaction. */ @Test public void connectionToEffectPort() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// reactor Foo { -// output out:int; -// } -// main reactor Bar { -// output out:int; -// x = new Foo(); -// x.out -> out; -// reaction(startup) -> out {= -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "reactor Foo {", - " output out:int;", - "}", - "main reactor Bar {", - " output out:int;", - " x = new Foo();", - " x.out -> out;", - " reaction(startup) -> out {=", - " =}", - "}"); + String testCase = """ + target C; + reactor Foo { + output out:int; + } + main reactor Bar { + output out:int; + x = new Foo(); + x.out -> out; + reaction(startup) -> out {= + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, "Cannot connect: Port named 'out' is already effect of a reaction."); } - + /** * Disallow connection to port that is effect of reaction. */ @Test public void connectionToEffectPort2() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// reactor Foo { -// input inp:int; -// output out:int; -// } -// main reactor { -// output out:int; -// x = new Foo(); -// y = new Foo(); -// -// y.out -> x.inp; -// reaction(startup) -> x.inp {= -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "reactor Foo {", - " input inp:int;", - " output out:int;", - "}", - "main reactor {", - " output out:int;", - " x = new Foo();", - " y = new Foo();", - "", - " y.out -> x.inp;", - " reaction(startup) -> x.inp {=", - " =}", - "}"); + String testCase = """ + target C; + reactor Foo { + input inp:int; + output out:int; + } + main reactor { + output out:int; + x = new Foo(); + y = new Foo(); + + y.out -> x.inp; + reaction(startup) -> x.inp {= + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, "Cannot connect: Port named 'inp' is already effect of a reaction."); } - + /** - * Allow connection to the port of a contained reactor if another port with same name is effect of a reaction. + * Allow connection to the port of a contained reactor if another port with same name is effect + * of a reaction. */ @Test public void connectionToEffectPort3() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// -// reactor Foo { -// input in:int; -// } -// reactor Bar { -// input in:int; -// x1 = new Foo(); -// x2 = new Foo(); -// in -> x1.in; -// reaction(startup) -> x2.in {= -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "", - "reactor Foo {", - " input in:int;", - "}", - "reactor Bar {", - " input in:int;", - " x1 = new Foo();", - " x2 = new Foo();", - " in -> x1.in;", - " reaction(startup) -> x2.in {=", - " =}", - "}"); + String testCase = """ + target C; + + reactor Foo { + input in:int; + } + reactor Bar { + input in:int; + x1 = new Foo(); + x2 = new Foo(); + in -> x1.in; + reaction(startup) -> x2.in {= + =} + } + """; validator.assertNoErrors(parseWithoutError(testCase)); } /** - * Allow connection to the port of a contained reactor if another port with same name is effect of a reaction. + * Allow connection to the port of a contained reactor if another port with same name is effect + * of a reaction. */ @Test public void connectionToEffectPort3_5() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// -// reactor Foo { -// input in:int; -// } -// main reactor { -// input in:int; -// x1 = new Foo(); -// x2 = new Foo(); -// in -> x1.in; -// reaction(startup) -> x2.in {= -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "", - "reactor Foo {", - " input in:int;", - "}", - "main reactor {", - " input in:int;", - " x1 = new Foo();", - " x2 = new Foo();", - " in -> x1.in;", - " reaction(startup) -> x2.in {=", - " =}", - "}"); + String testCase = """ + target C; + + reactor Foo { + input in:int; + } + main reactor { + input in:int; + x1 = new Foo(); + x2 = new Foo(); + in -> x1.in; + reaction(startup) -> x2.in {= + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getVariable(), null, - "Main reactor cannot have inputs."); + "Main reactor cannot have inputs."); } /** - * Disallow connection to the port of a contained reactor if the same port is effect of a reaction. + * Disallow connection to the port of a contained reactor if the same port is effect of a + * reaction. */ @Test public void connectionToEffectPort4() throws Exception { -// Java 17: -// String testCase = """ -// target C; - -// reactor Foo { -// input in:int; -// } -// main reactor { -// input in:int; -// x1 = new Foo(); -// in -> x1.in; -// reaction(startup) -> x1.in {= -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "", - "reactor Foo {", - " input in:int;", - "}", - "main reactor {", - " input in:int;", - " x1 = new Foo();", - " in -> x1.in;", - " reaction(startup) -> x1.in {=", - " =}", - "}"); + String testCase = """ + target C; + + reactor Foo { + input in:int; + } + main reactor { + input in:int; + x1 = new Foo(); + in -> x1.in; + reaction(startup) -> x1.in {= + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, "Cannot connect: Port named 'in' is already effect of a reaction."); } @@ -596,39 +430,22 @@ public void connectionToEffectPort4() throws Exception { */ @Test public void multipleConnectionsToInputTest() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// reactor Source { -// output out:int; -// } -// reactor Sink { -// input in:int; -// } -// main reactor { -// input in:int; -// src = new Source(); -// sink = new Sink(); -// in -> sink.in; -// src.out -> sink.in; -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "reactor Source {", - " output out:int;", - "}", - "reactor Sink {", - " input in:int;", - "}", - "main reactor {", - " input in:int;", - " src = new Source();", - " sink = new Sink();", - " in -> sink.in;", - " src.out -> sink.in;", - "}"); + String testCase = """ + target C; + reactor Source { + output out:int; + } + reactor Sink { + input in:int; + } + main reactor { + input in:int; + src = new Source(); + sink = new Sink(); + in -> sink.in; + src.out -> sink.in; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, "Cannot connect: Port named 'in' may only appear once on the right side of a connection."); } @@ -638,146 +455,92 @@ public void multipleConnectionsToInputTest() throws Exception { */ @Test public void detectInstantiationCycle() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// reactor Contained { -// x = new Contained(); -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "reactor Contained {", - " x = new Contained();", - "}"); + String testCase = """ + target C; + reactor Contained { + x = new Contained(); + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInstantiation(), null, "Instantiation is part of a cycle: Contained"); } - - + + /** * Detect cycles in the instantiation graph. */ @Test public void detectInstantiationCycle2() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// reactor Intermediate { -// x = new Contained(); -// } -// -// reactor Contained { -// x = new Intermediate(); -// } -// """ -// Java 11: - Model model = parseWithoutError(String.join( - System.getProperty("line.separator"), - "target C;", - "reactor Intermediate {", - " x = new Contained();", - "}", - "", - "reactor Contained {", - " x = new Intermediate();", - "}" - )); + String testCase = """ + target C; + reactor Intermediate { + x = new Contained(); + } + reactor Contained { + x = new Intermediate(); + } + """; + + Model model = parseWithoutError(testCase); validator.assertError(model, LfPackage.eINSTANCE.getInstantiation(), null, "Instantiation is part of a cycle: Intermediate, Contained."); validator.assertError(model, LfPackage.eINSTANCE.getInstantiation(), null, "Instantiation is part of a cycle: Intermediate, Contained."); } - + /** * Detect causality loop. */ @Test public void detectCausalityLoop() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// -// reactor X { -// input x:int; -// output y:int; -// reaction(x) -> y {= -// =} -// } -// -// main reactor { -// a = new X() -// b = new X() -// a.y -> b.x -// b.y -> a.x -// } -// """ -// Java 11: - Model model = parseWithoutError(String.join( - System.getProperty("line.separator"), - "target C;", - "", - "reactor X {", - " input x:int;", - " output y:int;", - " reaction(x) -> y {=", - " =}", - "}", - "", - "main reactor {", - " a = new X()", - " b = new X()", - " a.y -> b.x", - " b.y -> a.x", - "}" - )); + + String testCase = """ + target C; + + reactor X { + input x:int; + output y:int; + reaction(x) -> y {= + =} + } + + main reactor { + a = new X() + b = new X() + a.y -> b.x + b.y -> a.x + } + """; + Model model = parseWithoutError(testCase); validator.assertError(model, LfPackage.eINSTANCE.getReaction(), null, "Reaction triggers involved in cyclic dependency in reactor X: x."); validator.assertError(model, LfPackage.eINSTANCE.getReaction(), - null, "Reaction effects involved in cyclic dependency in reactor X: y."); + null, "Reaction effects involved in cyclic dependency in reactor X: y."); } - + /** * Let cyclic dependencies be broken by "after" clauses. */ @Test public void afterBreaksCycle() throws Exception { -// Java 17: -// String testCase = """ -// target C -// -// reactor X { -// input x:int; -// output y:int; -// reaction(x) -> y {= -// =} -// } -// -// main reactor { -// a = new X() -// b = new X() -// a.y -> b.x after 5 msec -// b.y -> a.x -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C", - " ", - "reactor X {", - " input x:int;", - " output y:int;", - " reaction(x) -> y {=", - " =}", - "}", - "", - "main reactor {", - " a = new X()", - " b = new X()", - " a.y -> b.x after 5 msec", - " b.y -> a.x", - "}"); + String testCase = """ + target C + + reactor X { + input x:int; + output y:int; + reaction(x) -> y {= + =} + } + + main reactor { + a = new X() + b = new X() + a.y -> b.x after 5 msec + b.y -> a.x + } + """; + validator.assertNoErrors(parseWithoutError(testCase)); } @@ -787,42 +550,23 @@ public void afterBreaksCycle() throws Exception { */ @Test public void afterBreaksCycle2() throws Exception { -// Java 17: -// String testCase = """ -// target C -// -// reactor X { -// input x:int; -// output y:int; -// reaction(x) -> y {= -// =} -// } -// -// main reactor { -// a = new X() -// b = new X() -// a.y -> b.x after 0 sec -// b.y -> a.x -// } -// """ -// Java 11: - - String testCase = String.join(System.getProperty("line.separator"), - "target C", - " ", - "reactor X {", - " input x:int;", - " output y:int;", - " reaction(x) -> y {=", - " =}", - "}", - "", - "main reactor {", - " a = new X()", - " b = new X()", - " a.y -> b.x after 0 sec", - " b.y -> a.x", - "}"); + String testCase = """ + target C + + reactor X { + input x:int; + output y:int; + reaction(x) -> y {= + =} + } + + main reactor { + a = new X() + b = new X() + a.y -> b.x after 0 sec + b.y -> a.x + } + """; validator.assertNoErrors(parseWithoutError(testCase)); } @@ -832,41 +576,23 @@ public void afterBreaksCycle2() throws Exception { */ @Test public void afterBreaksCycle3() throws Exception { -// Java 17: -// String testCase = """ -// target C -// -// reactor X { -// input x:int; -// output y:int; -// reaction(x) -> y {= -// =} -// } -// -// main reactor { -// a = new X() -// b = new X() -// a.y -> b.x after 0 -// b.y -> a.x -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C", - " ", - "reactor X {", - " input x:int;", - " output y:int;", - " reaction(x) -> y {=", - " =}", - "}", - "", - "main reactor {", - " a = new X()", - " b = new X()", - " a.y -> b.x after 0", - " b.y -> a.x", - "}"); + String testCase = """ + target C + + reactor X { + input x:int; + output y:int; + reaction(x) -> y {= + =} + } + + main reactor { + a = new X() + b = new X() + a.y -> b.x after 0 + b.y -> a.x + } + """; validator.assertNoErrors(parseWithoutError(testCase)); } @@ -875,311 +601,198 @@ public void afterBreaksCycle3() throws Exception { */ @Test public void nonzeroAfterMustHaveUnits() throws Exception { -// Java 17: -// String testCase = """ -// target C -// -// reactor X { -// input x:int; -// output y:int; -// reaction(x) -> y {= -// =} -// } -// -// main reactor { -// a = new X() -// b = new X() -// a.y -> b.x after 1 -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C", - " ", - "reactor X {", - " input x:int;", - " output y:int;", - " reaction(x) -> y {=", - " =}", - "}", - "", - "main reactor {", - " a = new X()", - " b = new X()", - " a.y -> b.x after 1", - "}"); + String testCase = """ + target C + + reactor X { + input x:int; + output y:int; + reaction(x) -> y {= + =} + } + + main reactor { + a = new X() + b = new X() + a.y -> b.x after 1 + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, "Missing time unit."); } - /** * Report non-zero time value without units. */ @Test public void nonZeroTimeValueWithoutUnits() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// main reactor { -// timer t(42, 1 sec); -// reaction(t) {= -// printf("Hello World.\\n"); -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " timer t(42, 1 sec);", - " reaction(t) {=", - " printf(\"Hello World.\\n\");", - " =}", - "}"); + String testCase = """ + target C; + main reactor { + timer t(42, 1 sec); + reaction(t) {= + printf("Hello World.\\n"); + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, "Missing time unit."); - } - + } + /** * Report reference to non-time parameter in time argument. */ @Test public void parameterTypeMismatch() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// main reactor (p:int(0)) { -// timer t(p, 1 sec); -// reaction(t) {= -// printf("Hello World.\\n"); -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor (p:int(0)) {", - " timer t(p, 1 sec);", - " reaction(t) {=", - " printf(\"Hello World.\\n\");", - " =}", - "}"); + String testCase = """ + target C; + main reactor (p:int(0)) { + timer t(p, 1 sec); + reaction(t) {= + printf("Hello World.\\n"); + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, "Referenced parameter is not of time type."); } - + /** * Report inappropriate literal in time argument. */ @Test public void targetCodeInTimeArgument() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// main reactor { -// timer t({=foo()=}, 1 sec); -// reaction(t) {= -// printf("Hello World.\\n"); -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " timer t({=foo()=}, 1 sec);", - " reaction(t) {=", - " printf(\"Hello World.\\n\");", - " =}", - "}"); + String testCase = """ + target C; + main reactor { + timer t({=foo()=}, 1 sec); + reaction(t) {= + printf("Hello World.\\n"); + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, "Invalid time value."); - } - + } + /** * Report overflowing deadline. */ @Test public void overflowingDeadlineC() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// main reactor { -// timer t; -// reaction(t) {= -// printf("Hello World.\\n"); -// =} deadline (40 hours) {= -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - "timer t;", - " reaction(t) {=", - " printf(\"Hello World.\\n\");", - " =} deadline (40 hours) {=", - " =}", - "}"); + String testCase = """ + target C; + main reactor { + timer t; + reaction(t) {= + printf("Hello World.\\n"); + =} deadline (40 hours) {= + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getDeadline(), null, "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + - " nanoseconds."); - } + " nanoseconds."); + } + - /** * Report overflowing parameter. */ @Test public void overflowingParameterC() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// main reactor(d:time(40 hours)) { -// timer t; -// reaction(t) {= -// printf("Hello World.\\n"); -// =} deadline (d) {= -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor(d:time(40 hours)) {", - "timer t;", - " reaction(t) {=", - " printf(\"Hello World.\\n\");", - " =} deadline (d) {=", - " =}", - "}"); + String testCase = """ + target C; + main reactor(d:time(40 hours)) { + timer t; + reaction(t) {= + printf("Hello World.\\n"); + =} deadline (d) {= + =} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getParameter(), null, "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); - } - - + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); + } + + /** * Report overflowing assignment. */ @Test public void overflowingAssignmentC() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// reactor Print(d:time(39 hours)) { -// timer t; -// reaction(t) {= -// printf("Hello World.\\n"); -// =} deadline (d) {= -// =} -// } -// main reactor { -// p = new Print(d=40 hours); -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "reactor Print(d:time(39 hours)) {", - " timer t;", - " reaction(t) {=", - " printf(\"Hello World.\\n\");", - " =} deadline (d) {=", - " =}", - "}", - "main reactor {", - " p = new Print(d=40 hours);", - "}"); + String testCase = """ + target C; + reactor Print(d:time(39 hours)) { + timer t; + reaction(t) {= + printf("Hello World.\\n"); + =} deadline (d) {= + =} + } + main reactor { + p = new Print(d=40 hours); + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAssignment(), null, "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); - } + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); + } /** * Report missing trigger. */ @Test public void missingTrigger() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// reactor X { -// reaction() {= -// // -// =} -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "reactor X {", - " reaction() {=", - " //", - " =}", - "}"); + String testCase = """ + target C; + reactor X { + reaction() {= + // + =} + } + """; validator.assertWarning(parseWithoutError(testCase), LfPackage.eINSTANCE.getReaction(), null, "Reaction has no trigger."); } - + /** - * Test warnings and errors for the target dependent preamble visibility qualifiers + * Test warnings and errors for the target dependent preamble visibility qualifiers */ @Test public void testPreambleVisibility() throws Exception { for (Target target : Target.values()) { for (Visibility visibility : Visibility.values()) { -// Java 17: -// Model model_reactor_scope = """ -// target %s; -// reactor Foo { -// %spreamble {==} -// } -// """.formatted(target, visibility != java.beans.Visibility.NONE ? visibility + " " : ""); -// Java 11: - Model model_reactor_scope = parseWithoutError(String.join(System.getProperty("line.separator"), - String.format("target %s;", target), - "reactor Foo {", - String.format(" %spreamble {==}", visibility != Visibility.NONE ? visibility + " " : ""), - "}")); - -// Java 17: -// Model model_file_scope = """ -// target %s; -// %spreamble {==} -// reactor Foo { -// } -// """.formatted(target, visibility != java.beans.Visibility.NONE ? visibility + " " : ""); -// Java 11: - Model model_file_scope = parseWithoutError(String.join(System.getProperty("line.separator"), - String.format("target %s;", target), - String.format(" %spreamble {==}", visibility != Visibility.NONE ? visibility + " " : ""), - "reactor Foo {", - "}")); - -// Java 17: -// Model model_no_preamble = """ -// target %s; -// reactor Foo { -// } -// """.formatted(target); -// Java 11: - Model model_no_preamble = parseWithoutError(String.join(System.getProperty("line.separator"), - String.format("target %s;", target), - "reactor Foo {", - "}")); - + Model model_reactor_scope = parseWithoutError(""" + target %s; + reactor Foo { + %spreamble {==} + } + """.formatted(target, visibility != Visibility.NONE ? visibility + " " : "")); + + Model model_file_scope = parseWithoutError(""" + target %s; + %spreamble {==} + reactor Foo { + } + """.formatted(target, visibility != Visibility.NONE ? visibility + " " : "")); + + Model model_no_preamble = parseWithoutError(""" + target %s; + reactor Foo { + } + """.formatted(target)); + validator.assertNoIssues(model_no_preamble); - + if (target == Target.CPP) { if (visibility == Visibility.NONE) { validator.assertError(model_file_scope, LfPackage.eINSTANCE.getPreamble(), null, "Preambles for the C++ target need a visibility qualifier (private or public)!"); validator.assertError(model_reactor_scope, LfPackage.eINSTANCE.getPreamble(), null, - "Preambles for the C++ target need a visibility qualifier (private or public)!"); + "Preambles for the C++ target need a visibility qualifier (private or public)!"); } else { validator.assertNoIssues(model_file_scope); validator.assertNoIssues(model_reactor_scope); @@ -1198,46 +811,30 @@ public void testPreambleVisibility() throws Exception { } } } - - + + /** * Tests for state and parameter declarations, including native lists. */ @Test public void stateAndParameterDeclarationsInC() throws Exception { -// Java 17: -// String testCase = """ -// target C; -// reactor Bar(a(0), // ERROR: type missing -// b:int, // ERROR: uninitialized -// t:time(42), // ERROR: units missing -// x:int(0), -// h:time("bla"), // ERROR: not a type -// q:time(1 msec, 2 msec), // ERROR: not a list -// y:int(t) // ERROR: init using parameter -// ) { -// state offset:time(42); // ERROR: units missing -// state w:time(x); // ERROR: parameter is not a time -// state foo:time("bla"); // ERROR: assigned value not a time; -// timer tick(1); // ERROR: not a time -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "reactor Bar(a(0), // ERROR: type missing", - " b:int, // ERROR: uninitialized", - " t:time(42), // ERROR: units missing", - " x:int(0),", - " h:time(\"bla\"), // ERROR: not a type ", - " q:time(1 msec, 2 msec), // ERROR: not a list", - " y:int(t) // ERROR: init using parameter", - ") {", - " state offset:time(45); // ERROR: units missing", - " state w:time(x); // ERROR: parameter is not a time", - " state foo:time(\"bla\"); // ERROR: assigned value not a time", - " timer tick(1); // ERROR: not a time", - "}"); + String testCase = """ + target C; + reactor Bar(a(0), // ERROR: type missing + b:int, // ERROR: uninitialized + t:time = 42, // ERROR: units missing + x:int = 0, + h:time = "bla", // ERROR: not a type + q:time(1 msec, 2 msec), // ERROR: not a list + y:int = t // ERROR: init using parameter + ) { + state offset:time = 42; // ERROR: units missing + state w:time = x; // ERROR: parameter is not a time + state foo:time = "bla"; // ERROR: assigned value not a time; + timer tick(1); // ERROR: not a time + } + """; + Model model = parseWithoutError(testCase); @@ -1261,9 +858,9 @@ public void stateAndParameterDeclarationsInC() throws Exception { "Invalid time value."); validator.assertError(model, LfPackage.eINSTANCE.getTimer(), null, "Missing time unit."); - } - - + } + + /** * Recognize valid IPV4 addresses, report invalid ones. */ @@ -1275,69 +872,44 @@ public void recognizeIPV4() throws Exception { // Correct IP addresses. for (String addr : correct) { -// Java 17: -// String testCase = """ -// target C; -// reactor Y {} -// federated reactor X at foo@%s:4242 { -// y = new Y() at %s:2424; -// } -// """.formatted(addr, addr); -// Java 11: + + String testCase = """ + target C; + reactor Y {} + federated reactor X at foo@%s:4242 { + y = new Y() at %s:2424; + } + """.formatted(addr, addr); parseWithoutError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor X at foo@%s:4242 {", addr), - String.format(" y = new Y() at %s:2424; ", addr), - "}") + testCase ); } // IP addresses that don't parse. for (String addr : parseError) { -// Java 17: -// String testCase = """ -// target C; -// reactor Y {} -// federated reactor X at foo@%s:4242 { -// y = new Y() at %s:2424; -// } -// """.formatted(addr, addr); -// Java 11: - parseWithError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor X at foo@%s:4242 {", addr), - String.format(" y = new Y() at %s:2424; ", addr), - "}") - ); + String testCase = """ + target C; + reactor Y {} + federated reactor X at foo@%s:4242 { + y = new Y() at %s:2424; + } + """.formatted(addr, addr); + parseWithError(testCase); } // IP addresses that parse but are invalid. for (String addr : validationError) { -// Java 17: -// Model model = """ -// target C; -// reactor Y {} -// federated reactor X at foo@%s:4242 { -// y = new Y() at %s:2424; -// } -// """.formatted(addr, addr); -// Java 11: - Model model = parseWithoutError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor X at foo@%s:4242 {", addr), - String.format(" y = new Y() at %s:2424; ", addr), - "}") - ); + Model model = parseWithoutError(""" + target C; + reactor Y {} + federated reactor X at foo@%s:4242 { + y = new Y() at %s:2424; + } + """.formatted(addr, addr)); validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, "Invalid IP address."); } } - + /** * Recognize valid IPV6 addresses, report invalid ones. */ @@ -1355,160 +927,114 @@ public void recognizeIPV6() throws Exception { "::ffff:0.0.0.0", "::ffff:1.2.3.4", "::ffff:10.0.0.1", "1:2:3:4:5:6:77:88", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", "2001:db8:3:4::192.0.2.33", "64:ff9b::192.0.2.33", "0:0:0:0:0:0:10.0.0.1"); - + List validationError = List.of("1:2:3:4:5:6:7:8:9", "1:2:3:4:5:6::7:8", "1:2:3:4:5:6:7:8:", "::1:2:3:4:5:6:7:8", "1:2:3:4:5:6:7:8::", "1:2:3:4:5:6:7:88888", "2001:db8:3:4:5::192.0.2.33", "fe08::7:8interface", "fe08::7:8interface", "fe08::7:8i"); - + List parseError = List.of("fe08::7:8%", ":1:2:3:4:5:6:7:8"); - + // Correct IP addresses. for (String addr : correct) { -// Java 17: -// String testCase = """ -// target C; -// reactor Y {} -// federated reactor X at [foo@%s]:4242 { -// y = new Y() at [%s]:2424; -// } -// """.formatted(addr, addr); -// Java 11: - Model model = parseWithoutError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor at [foo@%s]:4242 {", addr), - String.format(" y = new Y() at [%s]:2424; ", addr), - "}") - ); + String testCase = """ + target C; + reactor Y {} + federated reactor at [foo@%s]:4242 { + y = new Y() at [%s]:2424; + } + """.formatted(addr, addr); + Model model = parseWithoutError(testCase); validator.assertNoIssues(model); } - + // IP addresses that don't parse. for (String addr : parseError) { -// Java 17: -// String testCase = """ -// target C; -// reactor Y {} -// federated reactor X at [foo@%s]:4242 { -// y = new Y() at [%s]:2424; -// } -// """.formatted(addr, addr); -// Java 11: - parseWithError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor X at [foo@%s]:4242 {", addr), - String.format(" y = new Y() at [%s]:2424; ", addr), - "}") - ); + String testCase = """ + target C; + reactor Y {} + federated reactor X at [foo@%s]:4242 { + y = new Y() at [%s]:2424; + } + """.formatted(addr, addr); + parseWithError(testCase); } // IP addresses that parse but are invalid. for (String addr : validationError) { -// Java 17: -// String testCase = """ -// target C; -// reactor Y {} -// federated reactor X at [foo@%s]:4242 { -// y = new Y() at [%s]:2424; -// } -// """.formatted(addr, addr); -// Java 11: + String testCase = """ + target C; + reactor Y {} + federated reactor X at [foo@%s]:4242 { + y = new Y() at [%s]:2424; + } + """.formatted(addr, addr); Model model = parseWithoutError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor X at [foo@%s]:4242 {", addr), - String.format(" y = new Y() at [%s]:2424; ", addr), - "}") + testCase ); validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, "Invalid IP address."); } } - + /** * Recognize valid host names and fully qualified names, report invalid ones. */ @Test public void recognizeHostNames() throws Exception { - + List correct = List.of("localhost"); // FIXME: add more - + List validationError = List.of("x.y.z"); // FIXME: add more - + List parseError = List.of("..xyz"); // FIXME: add more // Correct names. for (String addr : correct) { -// Java 17: -// String testCase = """ -// target C; -// reactor Y {} -// federated reactor X at foo@%s:4242 { -// y = new Y() at %s:2424; -// } -// """.formatted(addr, addr); -// Java 11: + String testCase = """ + target C; + reactor Y {} + federated reactor X at foo@%s:4242 { + y = new Y() at %s:2424; + } + """.formatted(addr, addr); parseWithoutError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor X at foo@%s:4242 {", addr), - String.format(" y = new Y() at %s:2424; ", addr), - "}") + testCase ); } - + // Names that don't parse. for (String addr : parseError) { -// Java 17: -// String testCase = """ -// target C; -// reactor Y {} -// federated reactor X at foo@%s:4242 { -// y = new Y() at %s:2424; -// } -// """.formatted(addr, addr); -// Java 11: + String testCase = """ + target C; + reactor Y {} + federated reactor X at foo@%s:4242 { + y = new Y() at %s:2424; + } + """.formatted(addr, addr); parseWithError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor X at foo@%s:4242 {", addr), - String.format(" y = new Y() at %s:2424; ", addr), - "}") + testCase ); } - + // Names that parse but are invalid. for (String addr : validationError) { -// Java 17: -// String testCase = """ -// target C; -// reactor Y {} -// federated reactor X at foo@%s:4242 { -// y = new Y() at %s:2424; -// } -// """.formatted(addr, addr); -// Java 11: + String testCase = """ + target C; + reactor Y {} + federated reactor X at foo@%s:4242 { + y = new Y() at %s:2424; + } + """.formatted(addr, addr); Model model = parseWithoutError( - String.join(System.getProperty("line.separator"), - "target C;", - "reactor Y {}", - String.format("federated reactor X at foo@%s:4242 {", addr), - String.format(" y = new Y() at %s:2424; ", addr), - "}") + testCase ); - validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, + validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, "Invalid host name or fully qualified domain name."); } } - + /** * Maps a type to a list of known good values. */ @@ -1533,7 +1059,7 @@ public void recognizeHostNames() throws Exception { ); /** - * Maps a type to a list, each entry of which represents a list with + * Maps a type to a list, each entry of which represents a list with * three entries: a known wrong value, the suffix to add to the reported * name, and the type that it should be. */ @@ -1575,13 +1101,14 @@ public void recognizeHostNames() throws Exception { List.of("{trace-file-name: [1, 2, 3]}", ".trace-file-name", PrimitiveType.STRING) ) ); - + /** - * Given an array type, return a list of good or bad examples, + * Given an array type, return a list of good or bad examples, * depending on the value of the second parameter. */ private List synthesizeExamples(ArrayType type, boolean correct) { - Map> values = correct ? primitiveTypeToKnownGood : primitiveTypeToKnownBad; + Map> values = correct ? primitiveTypeToKnownGood + : primitiveTypeToKnownBad; List examples = new LinkedList<>(); if (correct) { // Produce an array that has an entry for each value. @@ -1592,9 +1119,9 @@ private List synthesizeExamples(ArrayType type, boolean correct) { } return examples; } - + /** - * Given an union type, return a list of good or bad examples, + * Given an union type, return a list of good or bad examples, * depending on the value of the second parameter. */ private List synthesizeExamples(UnionType type, boolean correct) { @@ -1610,15 +1137,15 @@ private List synthesizeExamples(UnionType type, boolean correct) { } else { // Return some obviously bad examples for the common // case where the options are from an ordinary Enum. - if (!type.options.stream().anyMatch(it -> (it instanceof TargetPropertyType))) { + if (!type.options.stream().anyMatch(it -> it instanceof TargetPropertyType)) { return List.of("foo", "\"bar\"", "1", "-1", "{x: 42}", "[1, 2, 3]"); } } return examples; } - + /** - * Given an union type, return a list of good or bad examples, + * Given an union type, return a list of good or bad examples, * depending on the value of the second parameter. */ private List synthesizeExamples(DictionaryType type, boolean correct) { @@ -1626,7 +1153,8 @@ private List synthesizeExamples(DictionaryType type, boolean correct) { // Produce a set of singleton dictionaries. // If incorrect examples are wanted, garble the key. for (DictionaryElement option : type.options) { - synthesizeExamples(option.getType(), correct).forEach(it -> examples.add("{" + option + (!correct ? "iamwrong: " : ": ") + it + "}")); + synthesizeExamples(option.getType(), correct).forEach(it -> examples.add( + "{" + option + (!correct ? "iamwrong: " : ": ") + it + "}")); } return examples; } @@ -1649,23 +1177,24 @@ private List synthesizeExamples(StringDictionaryType type, boolean corre } return examples; } - + /** * Synthesize a list of values that either conform to the given type or * do not, depending on whether the second argument 'correct' is true. - * Return an empty set if it is too complicated to generate examples + * Return an empty set if it is too complicated to generate examples * (e.g., because the resulting errors are more sophisticated). - * + *

* Not all cases are covered by this function. Currently, the only cases not * covered are known bad examples for composite types, which should be added * to the compositeTypeToKnownBad map. - * + * * @param correct True to synthesize correct examples automatically, otherwise - * synthesize incorrect examples. + * synthesize incorrect examples. */ private List synthesizeExamples(TargetPropertyType type, boolean correct) { if (type instanceof PrimitiveType) { - Map> values = correct ? primitiveTypeToKnownGood : primitiveTypeToKnownBad; + Map> values = correct ? primitiveTypeToKnownGood + : primitiveTypeToKnownBad; List examples = values.get(type); Assertions.assertNotNull(examples); return examples; @@ -1684,29 +1213,21 @@ private List synthesizeExamples(TargetPropertyType type, boolean correct } return new LinkedList<>(); } - + /** * Create an LF program with the given key and value as a target property, * parse it, and return the resulting model. */ private Model createModel(TargetProperty key, String value) throws Exception { String target = key.supportedBy.get(0).getDisplayName(); - System.out.println(String.format("%s: %s", key, value)); -// Java 17: -// Model model = """ -// target %s {%s: %s}; -// reactor Y {} -// main reactor { -// y = new Y() -// } -// """.formatted(target, key, value); -// Java 11: - return parseWithoutError(String.join(System.getProperty("line.separator"), - String.format("target %s {%s: %s};", target, key, value), - "reactor Y {}", - "main reactor {", - " y = new Y() ", - "}")); + System.out.printf("%s: %s%n", key, value); + return parseWithoutError(""" + target %s {%s: %s}; + reactor Y {} + main reactor { + y = new Y() + } + """.formatted(target, key, value)); } /** @@ -1719,21 +1240,21 @@ public void checkTargetProperties() throws Exception { // we test that separately as it has better error messages return; } - System.out.println(String.format("Testing target property %s which is %s", prop, prop.type)); + System.out.printf("Testing target property %s which is %s%n", prop, prop.type); System.out.println("===="); System.out.println("Known good assignments:"); List knownCorrect = synthesizeExamples(prop.type, true); - + for (String it : knownCorrect) { Model model = createModel(prop, it); validator.assertNoErrors(model); // Also make sure warnings are produced when files are not present. if (prop.type == PrimitiveType.FILE) { validator.assertWarning(model, LfPackage.eINSTANCE.getKeyValuePair(), - null, String.format("Could not find file: '%s'.", StringUtil.removeQuotes(it))); + null, String.format("Could not find file: '%s'.", StringUtil.removeQuotes(it))); } } - + // Extra checks for filenames. (This piece of code was commented out in the original xtend file) // Temporarily disabled because we need a more sophisticated check that looks for files in different places. // if (prop.type == prop.type == ArrayType.FILE_ARRAY || @@ -1746,35 +1267,35 @@ public void checkTargetProperties() throws Exception { // null, '''Could not find file: '«it.withoutQuotes»'.''') // ] // } - + System.out.println("Known bad assignments:"); List knownIncorrect = synthesizeExamples(prop.type, false); if (!(knownIncorrect == null || knownIncorrect.isEmpty())) { for (String it : knownIncorrect) { if (prop.type instanceof StringDictionaryType) { validator.assertError(createModel(prop, it), - LfPackage.eINSTANCE.getKeyValuePair(), null, - String.format("Target property '%s.", prop), "' is required to be a string."); + LfPackage.eINSTANCE.getKeyValuePair(), null, + String.format("Target property '%s.", prop), "' is required to be a string."); } else { validator.assertError(createModel(prop, it), - LfPackage.eINSTANCE.getKeyValuePair(), null, - String.format("Target property '%s' is required to be %s.", prop.toString(), prop.type)); + LfPackage.eINSTANCE.getKeyValuePair(), null, + String.format("Target property '%s' is required to be %s.", prop, prop.type)); } } } else { // No type was synthesized. It must be a composite type. List> list = compositeTypeToKnownBad.get(prop.type); if (list == null) { - System.out.println(String.format("No known incorrect values provided for target property '%s'. Aborting test.", prop)); - Assertions.assertTrue(false); + System.out.printf("No known incorrect values provided for target property '%s'. Aborting test.%n", prop); + Assertions.fail(); } else { for (List it : list) { validator.assertError(createModel(prop, it.get(0).toString()), LfPackage.eINSTANCE.getKeyValuePair(), null, - String.format("Target property '%s%s' is required to be %s.", prop.toString(), it.get(1), it.get(2))); + String.format("Target property '%s%s' is required to be %s.", prop, it.get(1), it.get(2))); } } - } + } System.out.println("===="); } System.out.println("Done!"); @@ -1793,7 +1314,7 @@ public void checkCargoDependencyProperty() throws Exception { validator.assertError(createModel(prop, "{ dep: {/*empty*/} }"), LfPackage.eINSTANCE.getKeyValuePairs(), null, "Must specify one of 'version', 'path', or 'git'" ); - + // vvvvvvvvvvv validator.assertError(createModel(prop, "{ dep: { unknown_key: \"\"} }"), LfPackage.eINSTANCE.getKeyValuePair(), null, "Unknown key: 'unknown_key'" @@ -1884,358 +1405,228 @@ public void testUnusedImport() throws Exception { @Test public void testMissingInputType() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor { - // input i; - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " input i;", - "}" - ); + String testCase = """ + target C; + main reactor { + input i; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, "Input must have a type."); } @Test public void testMissingOutputType() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor { - // output i; - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " output i;", - "}" - ); + String testCase = """ + target C; + main reactor { + output i; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getOutput(), null, "Output must have a type."); } @Test public void testMissingStateType() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor { - // state i; - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " state i;", - "}" - ); + String testCase = """ + target C; + main reactor { + state i; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, "State must have a type."); } @Test public void testListWithParam() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor (A:int(1)) { state i:int(A, 2, 3) } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor (A:int(1)) { state i:int(A, 2, 3) }" - ); + String testCase = """ + target C; + main reactor (A:int(1)) { state i:int(A, 2, 3) } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, "List items cannot refer to a parameter."); } @Test public void testCppMutableInput() throws Exception { - // Java 17: - // String testCase = """ - // target Cpp; - // main reactor { - // mutable input i:int; - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target Cpp;", - "main reactor {", - " mutable input i:int;", - "}" - ); + String testCase = """ + target Cpp; + main reactor { + mutable input i:int; + } + """; validator.assertWarning(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, "The mutable qualifier has no meaning for the C++ target and should be removed. " + - "In C++, any value can be made mutable by calling get_mutable_copy()."); + "In C++, any value can be made mutable by calling get_mutable_copy()."); } @Test public void testOverflowingSTP() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor { - // reaction(startup) {==} STP(2147483648) {==} - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " reaction(startup) {==} STP(2147483648) {==}", - "}" - ); + String testCase = """ + target C; + main reactor { + reaction(startup) {==} STP(2147483648) {==} + } + """; // TODO: Uncomment and fix failing test. See issue #903 on Github. // validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getSTP(), null, - // "STP offset exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); + // "STP offset exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); } @Test public void testOverflowingDeadline() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor { - // reaction(startup) {==} STP(2147483648) {==} - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " reaction(startup) {==} deadline(2147483648) {==}", - "}" - ); + String testCase = """ + target C; + main reactor { + reaction(startup) {==} STP(2147483648) {==} + } + """; // TODO: Uncomment and fix failing test. See issue #903 on Github. // validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getDeadline(), null, - // "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); + // "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); } @Test public void testInvalidTargetParam() throws Exception { - // Java 17: - // String testCase = """ - // target C { beefyDesktop: true } - // main reactor {} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C { beefyDesktop: true }", - "main reactor {}" - ); + String testCase = """ + target C { beefyDesktop: true } + main reactor {} + """; List issues = validator.validate(parseWithoutError(testCase)); - Assertions.assertTrue(issues.size() == 1 && issues.get(0).getMessage().contains("Unrecognized target parameter: beefyDesktop")); + Assertions.assertTrue(issues.size() == 1 + && issues.get(0).getMessage().contains("Unrecognized target parameter: beefyDesktop")); } @Test public void testTargetParamNotSupportedForTarget() throws Exception { - // Java 17: - // String testCase = """ - // target Python { build: "" } - // main reactor {} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target Python { build: \"\" }", - "main reactor {}" - ); + String testCase = """ + target Python { build: "" } + main reactor {} + """; List issues = validator.validate(parseWithoutError(testCase)); - Assertions.assertTrue(issues.size() == 1 && issues.get(0).getMessage().contains("The target parameter: build" + - " is not supported by the Python target and will thus be ignored.")); + Assertions.assertTrue(issues.size() == 1 && issues.get(0).getMessage().contains( + "The target parameter: build" + + " is not supported by the Python target and will thus be ignored.")); } @Test public void testUnnamedReactor() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // reactor {} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "reactor {}" - ); + String testCase = """ + target C; + reactor {} + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, "Reactor must be named."); } @Test public void testMainHasInput() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor { - // input x:int; - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " input x:int;", - "}" - ); + String testCase = """ + target C; + main reactor { + input x:int; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, "Main reactor cannot have inputs."); } @Test public void testFederatedHasInput() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // federated reactor { - // input x:int; - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "federated reactor {", - " input x:int;", - "}" - ); + + String testCase = """ + target C; + federated reactor { + input x:int; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, "Main reactor cannot have inputs."); } @Test public void testMainHasOutput() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor { - // output x:int; - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {", - " output x:int;", - "}" - ); + + String testCase = """ + target C; + main reactor { + output x:int; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getOutput(), null, "Main reactor cannot have outputs."); } @Test public void testFederatedHasOutput() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // federated reactor { - // output x:int; - // } - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "federated reactor {", - " output x:int;", - "}" - ); + + String testCase = """ + target C; + federated reactor { + output x:int; + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getOutput(), null, "Main reactor cannot have outputs."); } @Test public void testMultipleMainReactor() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor A {} - // main reactor A {} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor A {}", - "main reactor A {}" - ); + + String testCase = """ + target C; + main reactor A {} + main reactor A {} + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, "Multiple definitions of main or federated reactor."); } @Test public void testMultipleMainReactorUnnamed() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor {} - // main reactor {} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor {}", - "main reactor {}" - ); + + String testCase = """ + target C; + main reactor {} + main reactor {} + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, "Multiple definitions of main or federated reactor."); } @Test public void testMultipleFederatedReactor() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // federated reactor A {} - // federated reactor A {} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "federated reactor A {}", - "federated reactor A {}" - ); + String testCase = """ + target C; + federated reactor A {} + federated reactor A {} + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, "Multiple definitions of main or federated reactor."); } @Test public void testMultipleMainOrFederatedReactor() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // federated reactor A {} - // federated reactor A {} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor A {}", - "federated reactor A {}" - ); + + String testCase = """ + target C; + federated reactor A {} + federated reactor A {} + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, "Multiple definitions of main or federated reactor."); } @Test public void testMainReactorHasHost() throws Exception { - // Java 17: - // String testCase = """ - // target C; - // main reactor at 127.0.0.1{} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target C;", - "main reactor at 127.0.0.1{}" - ); + String testCase = """ + target C; + main reactor at 127.0.0.1{} + """; // TODO: Uncomment and fix test // List issues = validator.validate(parseWithoutError(testCase)); // Assertions.assertTrue(issues.size() == 1 && @@ -2245,16 +1636,11 @@ public void testMainReactorHasHost() throws Exception { @Test public void testUnrecognizedTarget() throws Exception { - // Java 17: - // String testCase = """ - // target Pjthon; - // main reactor {} - // """ - // Java 11: - String testCase = String.join(System.getProperty("line.separator"), - "target Pjthon;", - "main reactor {}" - ); + + String testCase = """ + target Pjthon; + main reactor {} + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTargetDecl(), null, "Unrecognized target: Pjthon"); } @@ -2296,132 +1682,132 @@ public void testWrongParamType() throws Exception { @Test public void testInitialMode() throws Exception { String testCase = """ - target C; - main reactor { - mode M {} - } - """; + target C; + main reactor { + mode M {} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Every modal reactor requires one initial mode."); + "Every modal reactor requires one initial mode."); } @Test public void testInitialModes() throws Exception { String testCase = """ - target C; - main reactor { - initial mode IM1 {} - initial mode IM2 {} - } - """; + target C; + main reactor { + initial mode IM1 {} + initial mode IM2 {} + } + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "A modal reactor can only have one initial mode."); + "A modal reactor can only have one initial mode."); } @Test public void testModeStateNamespace() throws Exception { String testCase = """ - target C; - main reactor { - initial mode IM { - state s:int; - } - mode M { - state s:int; + target C; + main reactor { + initial mode IM { + state s:int; + } + mode M { + state s:int; + } } - } - """; + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, - "Duplicate state variable 's'. (State variables are currently scoped on reactor level not modes)"); + "Duplicate state variable 's'. (State variables are currently scoped on reactor level not modes)"); } @Test public void testModeTimerNamespace() throws Exception { String testCase = """ - target C; - main reactor { - initial mode IM { - timer t; - } - mode M { - timer t; + target C; + main reactor { + initial mode IM { + timer t; + } + mode M { + timer t; + } } - } - """; + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, - "Duplicate Timer 't'. (Timers are currently scoped on reactor level not modes)"); + "Duplicate Timer 't'. (Timers are currently scoped on reactor level not modes)"); } @Test public void testModeActionNamespace() throws Exception { String testCase = """ - target C; - main reactor { - initial mode IM { - logical action a; - } - mode M { - logical action a; + target C; + main reactor { + initial mode IM { + logical action a; + } + mode M { + logical action a; + } } - } - """; + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAction(), null, - "Duplicate Action 'a'. (Actions are currently scoped on reactor level not modes)"); + "Duplicate Action 'a'. (Actions are currently scoped on reactor level not modes)"); } @Test public void testModeInstanceNamespace() throws Exception { String testCase = """ - target C; - reactor R {} - main reactor { - initial mode IM { - r = new R(); - } - mode M { - r = new R(); + target C; + reactor R {} + main reactor { + initial mode IM { + r = new R(); + } + mode M { + r = new R(); + } } - } - """; + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInstantiation(), null, - "Duplicate Instantiation 'r'. (Instantiations are currently scoped on reactor level not modes)"); + "Duplicate Instantiation 'r'. (Instantiations are currently scoped on reactor level not modes)"); } @Test public void testMissingModeStateReset() throws Exception { String testCase = """ - target C; - main reactor { - initial mode IM { - reaction(startup) -> M {==} - } - mode M { - state s:int(0); + target C; + main reactor { + initial mode IM { + reaction(startup) -> M {==} + } + mode M { + state s:int(0); + } } - } - """; + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getMode(), null, - "State variable is not reset upon mode entry. It is neither marked for automatic reset nor is there a reset reaction."); + "State variable is not reset upon mode entry. It is neither marked for automatic reset nor is there a reset reaction."); } @Test public void testMissingModeStateResetInstance() throws Exception { String testCase = """ - target C; - reactor R { - state s:int(0); - } - main reactor { - initial mode IM { - reaction(startup) -> M {==} + target C; + reactor R { + state s:int(0); } - mode M { - r = new R(); + main reactor { + initial mode IM { + reaction(startup) -> M {==} + } + mode M { + r = new R(); + } } - } - """; + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getMode(), null, - "This reactor contains state variables that are not reset upon mode entry: " + "This reactor contains state variables that are not reset upon mode entry: " + "s in R" + ".\nThe state variables are neither marked for automatic reset nor have a dedicated reset reaction. " + "It is usafe to instatiate this reactor inside a mode entered with reset."); @@ -2430,13 +1816,13 @@ public void testMissingModeStateResetInstance() throws Exception { @Test public void testModeStateResetWithoutInitialValue() throws Exception { String testCase = """ - target C; - main reactor { - initial mode IM { - reset state s:int; + target C; + main reactor { + initial mode IM { + reset state s:int; + } } - } - """; + """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, "The state variable can not be automatically reset without an initial value."); } @@ -2444,18 +1830,18 @@ public void testModeStateResetWithoutInitialValue() throws Exception { @Test public void testUnspecifiedTransitionType() throws Exception { String testCase = """ - target C; - main reactor { - initial mode IM { - reaction(startup) -> M {==} - } - mode M { - reset state s:int(0); + target C; + main reactor { + initial mode IM { + reaction(startup) -> M {==} + } + mode M { + reset state s:int(0); + } } - } - """; + """; validator.assertWarning(parseWithoutError(testCase), LfPackage.eINSTANCE.getReaction(), null, - "You should specifiy a transition type! " + "You should specifiy a transition type! " + "Reset and history transitions have different effects on this target mode. " + "Currently, a reset type is implicitly assumed."); } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java index d1ea81e5be..24cb3554ff 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java @@ -3,6 +3,7 @@ import static java.util.Collections.emptyList; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.jupiter.api.Assertions.fail; import java.nio.file.Files; import java.nio.file.Path; @@ -28,11 +29,15 @@ public class RoundTripTests { @Test - public void roundTripTest() throws Exception { + public void roundTripTest() { for (Target target : Target.values()) { for (TestCategory category : TestCategory.values()) { for (LFTest test : TestRegistry.getRegisteredTests(target, category, false)) { - run(test.getSrcPath()); + try { + run(test.getSrcPath()); + } catch (Throwable thrown) { + fail("Test case " + test.getSrcPath() + " failed", thrown); + } } } } diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index fc49242322..b4c63ac337 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -254,6 +254,14 @@ public static boolean changeTargetName(Resource resource, String newTargetName) return true; } + /** + * Return the target of the file in which the given node lives. + */ + public static Target getTarget(EObject object) { + TargetDecl targetDecl = targetDecl(object.eResource()); + return Target.fromDecl(targetDecl); + } + /** * Add a new target property to the given resource. * diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index 870b1ad049..2525f2f710 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -140,7 +140,7 @@ TargetDecl: Initializer: parens?='(' (exprs+=Expression (',' exprs+=Expression)* (trailingComma?=',')?)? ')' | braces?='{' (exprs+=Expression (',' exprs+=Expression)* (trailingComma?=',')?)? '}' -// | assign?='=' exprs+=Expression // todo later + | assign?='=' exprs+=Expression ; @@ -292,13 +292,15 @@ VarRefOrModeTransition returns VarRef: Assignment: lhs=[Parameter] - (equals='=')? rhs=AssignmentInitializer + rhs=AssignmentInitializer ; -// TODO Only allow = based parameter assignment AssignmentInitializer returns Initializer: - exprs+=Expression - | parens?='(' (exprs+=Expression (',' exprs+=Expression)* (trailingComma?=',')?)? ')' + assign?='=' exprs+=Expression + // these syntaxes are legacy and now deprecated + // todo remove in future version. + | '='? parens?='(' (exprs+=Expression (',' exprs+=Expression)* (trailingComma?=',')?)? ')' + // note: the previous syntax `= { expr* }` is now parsed as a BracedListExpression | braces?='{' (exprs+=Expression (',' exprs+=Expression)* (trailingComma?=',')?)? '}' ; @@ -317,6 +319,13 @@ Expression: | Time | ParameterReference | {CodeExpr} code=Code + | BracedListExpression +; + +// A list of expressions within braces. +// In C/C++, this is an array initializer, struct initializer, or std::initializer_list. +BracedListExpression: + '{' {BracedListExpression} (items+=Expression (',' items+=Expression)*)? ','? '}' ; ParameterReference: diff --git a/org.lflang/src/org/lflang/Target.java b/org.lflang/src/org/lflang/Target.java index 4842bc1672..11247b6648 100644 --- a/org.lflang/src/org/lflang/Target.java +++ b/org.lflang/src/org/lflang/Target.java @@ -486,9 +486,7 @@ public boolean supportsMultiports() { * on constants). */ public boolean supportsParameterizedWidths() { - return switch (this) { - case C, CCPP, CPP, Python, Rust, TS -> true; - }; + return true; } /** @@ -502,6 +500,20 @@ public boolean buildsUsingDocker() { }; } + /** + * Whether the target requires using an equal sign to assign a default value to a parameter, + * or initialize a state variable. All targets mandate an equal sign when passing + * arguments to a reactor constructor call, regardless of this method. + */ + public boolean mandatesEqualsInitializers() { + return this != CPP; + } + + /** Allow expressions of the form {@code {a, b, c}}. */ + public boolean allowsBracedListExpressions() { + return this == C || this == CCPP || this == CPP; + } + /** * Return a string that demarcates the beginning of a single-line comment. */ diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index 93c2074829..e18eea02bd 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -16,6 +16,7 @@ import org.lflang.lf.Assignment; import org.lflang.lf.AttrParm; import org.lflang.lf.Attribute; +import org.lflang.lf.BracedListExpression; import org.lflang.lf.BuiltinTriggerRef; import org.lflang.lf.Code; import org.lflang.lf.CodeExpr; @@ -416,7 +417,6 @@ public Boolean caseVarRef(VarRef object) { public Boolean caseAssignment(Assignment object) { return new ComparisonMachine<>(object, Assignment.class) .equivalent(Assignment::getLhs) - .equalAsObjects(Assignment::getEquals) .equivalent(Assignment::getRhs) .conclusion; } @@ -438,10 +438,18 @@ public Boolean caseExpression(Expression object) { Literal.class, Time.class, ParameterReference.class, - Code.class + Code.class, + BracedListExpression.class ); } + @Override + public Boolean caseBracedListExpression(BracedListExpression object) { + return new ComparisonMachine<>(object, BracedListExpression.class) + .listsEquivalent(BracedListExpression::getItems) + .conclusion; + } + @Override public Boolean caseParameterReference(ParameterReference object) { return new ComparisonMachine<>(object, ParameterReference.class) diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index 50722d19eb..be8a68cf7d 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -21,6 +21,7 @@ import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.eclipse.xtext.xbase.lib.StringExtensions; import org.lflang.ASTUtils; +import org.lflang.Target; import org.lflang.ast.MalleableString.Builder; import org.lflang.ast.MalleableString.Joiner; import org.lflang.lf.Action; @@ -29,6 +30,7 @@ import org.lflang.lf.Assignment; import org.lflang.lf.AttrParm; import org.lflang.lf.Attribute; +import org.lflang.lf.BracedListExpression; import org.lflang.lf.BuiltinTriggerRef; import org.lflang.lf.Code; import org.lflang.lf.CodeExpr; @@ -46,6 +48,7 @@ import org.lflang.lf.Instantiation; import org.lflang.lf.KeyValuePair; import org.lflang.lf.KeyValuePairs; +import org.lflang.lf.LfFactory; import org.lflang.lf.Literal; import org.lflang.lf.Method; import org.lflang.lf.MethodArgument; @@ -479,7 +482,7 @@ public MalleableString caseStateVar(StateVar object) { } msb.append("state ").append(object.getName()); msb.append(typeAnnotationFor(object.getType())); - msb.append(initializer(object.getInit(), true)); + msb.append(initializer(object.getInit())); return msb.get(); } @@ -794,7 +797,9 @@ public MalleableString caseSerializer(Serializer object) { @Override public MalleableString caseKeyValuePairs(KeyValuePairs object) { // {KeyValuePairs} '{' (pairs+=KeyValuePair (',' (pairs+=KeyValuePair))* ','?)? '}' - if (object.getPairs().isEmpty()) return MalleableString.anyOf(""); + if (object.getPairs().isEmpty()) { + return MalleableString.anyOf(""); + } return new Builder() .append("{\n") .append(list(",\n", "", "\n", true, true, object.getPairs()).indent()) @@ -802,6 +807,16 @@ public MalleableString caseKeyValuePairs(KeyValuePairs object) { .get(); } + @Override + public MalleableString caseBracedListExpression(BracedListExpression object) { + if (object.getItems().isEmpty()) { + return MalleableString.anyOf("{}"); + } + // Note that this strips the trailing comma. There is no way + // to implement trailing commas with the current set of list() methods AFAIU. + return list(", ", "{", "}", false, false, object.getItems()); + } + @Override public MalleableString caseKeyValuePair(KeyValuePair object) { // name=Kebab ':' value=Element @@ -856,35 +871,52 @@ public MalleableString caseAssignment(Assignment object) { // )); Builder msb = new Builder(); msb.append(object.getLhs().getName()); - if (object.getEquals() != null) { - msb.append(" = "); - } - msb.append(initializer(object.getRhs(), false)); + msb.append(initializer(object.getRhs())); return msb.get(); } @Override public MalleableString caseInitializer(Initializer object) { - return initializer(object, false); + return initializer(object); } - private MalleableString initializer(Initializer init, boolean nothingIfEmpty) { + /** + * Return true if the initializer should be output with an equals initializer. + * Old-style assignments with parentheses are also output that + * way to help with the transition. + */ + private boolean shouldOutputAsAssignment(Initializer init) { + return init.isAssign() + || init.getExprs().size() == 1 && ASTUtils.getTarget(init).mandatesEqualsInitializers(); + } + + private MalleableString initializer(Initializer init) { if (init == null) { return MalleableString.anyOf(""); } + if (shouldOutputAsAssignment(init)) { + Expression expr = ASTUtils.asSingleExpr(init); + Objects.requireNonNull(expr); + return new Builder().append(" = ").append(doSwitch(expr)).get(); + } + if (ASTUtils.getTarget(init) == Target.C) { + // This turns C array initializers into a braced expression. + // C++ variants are not converted. + BracedListExpression list = LfFactory.eINSTANCE.createBracedListExpression(); + list.getItems().addAll(init.getExprs()); + return new Builder().append(" = ").append(doSwitch(list)).get(); + } String prefix; String suffix; if (init.isBraces()) { prefix = "{"; suffix = "}"; - } else if (init.isParens()) { + } else { + assert init.isParens(); prefix = "("; suffix = ")"; - } else { - // unparenthesized parameter assignment. - prefix = suffix = ""; } - return list(", ", prefix, suffix, nothingIfEmpty, false, init.getExprs()); + return list(", ", prefix, suffix, false, false, init.getExprs()); } @@ -899,7 +931,7 @@ public MalleableString caseParameter(Parameter object) { return builder .append(object.getName()) .append(typeAnnotationFor(object.getType())) - .append(initializer(object.getInit(), true)) + .append(initializer(object.getInit())) .get(); } diff --git a/org.lflang/src/org/lflang/ast/ToText.java b/org.lflang/src/org/lflang/ast/ToText.java index ad9a40c95b..0b703ccbe8 100644 --- a/org.lflang/src/org/lflang/ast/ToText.java +++ b/org.lflang/src/org/lflang/ast/ToText.java @@ -10,6 +10,7 @@ import org.lflang.ASTUtils; import org.lflang.lf.ArraySpec; +import org.lflang.lf.BracedListExpression; import org.lflang.lf.Code; import org.lflang.lf.CodeExpr; import org.lflang.lf.Host; @@ -78,6 +79,11 @@ public String caseCode(Code code) { return ""; } + @Override + public String caseBracedListExpression(BracedListExpression object) { + return ToLf.instance.caseBracedListExpression(object).toString(); + } + @Override public String caseHost(Host host) { return ToLf.instance.caseHost(host).toString(); diff --git a/org.lflang/src/org/lflang/cli/Lff.java b/org.lflang/src/org/lflang/cli/Lff.java index 0eeeea6785..1efc207128 100644 --- a/org.lflang/src/org/lflang/cli/Lff.java +++ b/org.lflang/src/org/lflang/cli/Lff.java @@ -51,7 +51,7 @@ public class Lff extends CliBase { @Option( names = "--no-recurse", description = "Do not format files in subdirectories of the" - + " specified paths.") + + " specified paths.") private boolean noRecurse = false; @Option( @@ -59,6 +59,11 @@ public class Lff extends CliBase { description = "Print more details on files affected.") private boolean verbose = false; + @Option( + names = {"--ignore-errors"}, + description = "Ignore validation errors in files and format them anyway.") + private boolean ignoreErrors = false; + /** * Main function of the formatter. * Caution: this will invoke System.exit. @@ -147,12 +152,13 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { if (verbose) { reporter.printInfo("Skipped " + path + ": not an LF file"); } - return; + return; } validateResource(resource); - // todo don't abort whole run if one file has errors - exitIfCollectedErrors(); + if (!ignoreErrors) { + exitIfCollectedErrors(); + } final String formattedFileContents = FormattingUtils.render(resource.getContents().get(0), lineLength); @@ -163,24 +169,30 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { FileUtil.writeToFile(formattedFileContents, outputPath, true); } catch (IOException e) { if (e instanceof FileAlreadyExistsException) { - // Only happens if a subdirectory is named with + // Only happens if a subdirectory is named with // ".lf" at the end. reporter.printFatalErrorAndExit( "Error writing to " + outputPath - + ": file already exists. Make sure that no file or" + + ": file already exists. Make sure that no file or" + " directory within provided input paths have the" + " same relative paths."); } } } - exitIfCollectedErrors(); - issueCollector.getAllIssues().forEach(reporter::printIssue); + if (!ignoreErrors) { + exitIfCollectedErrors(); + } + // Only errors are printed. Warnings are not helpful for LFF + // and since they don't prevent the file from being formatted, + // the position of the issue may be wrong in the formatted file. + // issueCollector.getAllIssues().forEach(reporter::printIssue); if (verbose) { String msg = "Formatted " + io.getWd().relativize(path); - if (path != outputPath) msg += - " -> " + io.getWd().relativize(outputPath); + if (path != outputPath) { + msg += " -> " + io.getWd().relativize(outputPath); + } reporter.printInfo(msg); } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java b/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java index cd013d6c57..1497ee6644 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java @@ -66,6 +66,7 @@ import org.lflang.AttributeUtils; import org.lflang.InferredType; import org.lflang.ast.FormattingUtils; +import org.lflang.ast.ToText; import org.lflang.diagram.synthesis.action.CollapseAllReactorsAction; import org.lflang.diagram.synthesis.action.ExpandAllReactorsAction; import org.lflang.diagram.synthesis.action.FilterCycleAction; @@ -1187,12 +1188,12 @@ private String createParameterLabel(ParameterInstance param) { b.append(param.getName()); String t = param.type.toOriginalText(); if (!StringExtensions.isNullOrEmpty(t)) { - b.append(":").append(t); + b.append(": ").append(t); } - if (!IterableExtensions.isNullOrEmpty(param.getInitialValue())) { - b.append("("); - b.append(IterableExtensions.join(param.getInitialValue(), ", ", ASTUtils::toOriginalText)); - b.append(")"); + if (param.getOverride() != null) { + b.append(" = "); + var init = param.getActualValue(); + b.append(FormattingUtils.render(init)); } return b.toString(); } diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index fda727d735..a2ac48216f 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -48,19 +48,16 @@ import org.lflang.federated.launcher.RtiConfig; import org.lflang.federated.serialization.FedROS2CPPSerialization; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.GeneratorBase; import org.lflang.generator.GeneratorUtils; import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; -import org.lflang.generator.c.CGenerator; import org.lflang.generator.c.CTypes; import org.lflang.generator.c.CUtil; import org.lflang.lf.Action; import org.lflang.lf.Output; import org.lflang.lf.Port; import org.lflang.lf.VarRef; -import org.lflang.util.FileUtil; /** * An extension class to the CGenerator that enables certain federated @@ -170,7 +167,7 @@ protected void deserialize( CodeBuilder result, ErrorReporter errorReporter ) { - CTypes types = new CTypes(errorReporter); + CTypes types = new CTypes(); // Adjust the type of the action and the receivingPort. // If it is "string", then change it to "char*". // This string is dynamically allocated, and type 'string' is to be @@ -338,7 +335,7 @@ protected void serializeAndSend( String commonArgs, ErrorReporter errorReporter ) { - CTypes types = new CTypes(errorReporter); + CTypes types = new CTypes(); var lengthExpression = ""; var pointerExpression = ""; switch (connection.getSerializer()) { @@ -424,7 +421,7 @@ public String generateNetworkInputControlReactionBody( // Find the maximum STP for decentralized coordination if(coordination == CoordinationType.DECENTRALIZED) { - result.pr("max_STP = "+ GeneratorBase.timeInTargetLanguage(maxSTP)+";"); + result.pr("max_STP = "+ CTypes.getInstance().getTargetTimeExpr(maxSTP) +";"); } result.pr("// Wait until the port status is known"); result.pr("wait_until_port_status_known("+receivingPortID+", max_STP);"); @@ -617,7 +614,7 @@ private String generateCodeToInitializeFederate(FederateInstance federate, RtiCo if (stpParam.isPresent()) { var globalSTP = ASTUtils.initialValue(stpParam.get(), List.of(federate.instantiation)).get(0); var globalSTPTV = ASTUtils.getLiteralTimeValue(globalSTP); - code.pr("lf_set_stp_offset("+ CGenerator.timeInTargetLanguage(globalSTPTV)+");"); + code.pr("lf_set_stp_offset("+ CTypes.getInstance().getTargetTimeExpr(globalSTPTV) +");"); } } @@ -742,7 +739,7 @@ private String generateCodeForPhysicalActions(FederateInstance federate, ErrorRe } code.pr( "_fed.min_delay_from_physical_action_to_federate_output = " - + GeneratorBase.timeInTargetLanguage(minDelay) + ";"); + + CTypes.getInstance().getTargetTimeExpr(minDelay) + ";"); } } return code.getCode(); diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index aabc77ecd5..124ffefb4f 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -430,16 +430,16 @@ public static String generateFederateNeighborStructure(FederateInstance federate // Use NEVER to encode no delay at all. code.pr("candidate_tmp = NEVER;"); } else { - var delayTime = GeneratorBase.getTargetTime(delay); - if (delay instanceof ParameterReference) { - // The delay is given as a parameter reference. Find its value. - final var param = ((ParameterReference)delay).getParameter(); - delayTime = GeneratorBase.timeInTargetLanguage(ASTUtils.getDefaultAsTimeValue(param)); - } + var delayTime = + delay instanceof ParameterReference + // In that case use the default value. + ? CTypes.getInstance().getTargetTimeExpr(ASTUtils.getDefaultAsTimeValue(((ParameterReference) delay).getParameter())) + : CTypes.getInstance().getTargetExpr(delay, InferredType.time()); + code.pr(String.join("\n", - "if ("+delayTime+" < candidate_tmp) {", - " candidate_tmp = "+delayTime+";", - "}" + "if (" + delayTime + " < candidate_tmp) {", + " candidate_tmp = " + delayTime + ";", + "}" )); } } diff --git a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java index ca8ce4dd9c..e438b1b866 100644 --- a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java @@ -11,7 +11,6 @@ import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; -import org.lflang.Target; import org.lflang.TargetProperty.CoordinationType; import org.lflang.TimeValue; import org.lflang.federated.generator.FedASTUtils; @@ -22,7 +21,7 @@ import org.lflang.generator.GeneratorBase; import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.ReactorInstance; -import org.lflang.generator.ts.TSExtensionsKt; +import org.lflang.generator.ts.TSTypes; import org.lflang.lf.Action; import org.lflang.lf.Expression; import org.lflang.lf.Output; @@ -118,7 +117,7 @@ public String generatePreamble(FederateInstance federate, FedFileConfig fileConf .collect(Collectors.joining(",")), federate.id, minOutputDelay == null ? "undefined" - : "%s".formatted(TSExtensionsKt.toTsTime(minOutputDelay)), + : "%s".formatted(TSTypes.getInstance().getTargetTimeExpr(minOutputDelay)), federate.networkMessageActions .stream() .map(Variable::getName) diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index f3768cec7c..14b6320bec 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -75,17 +75,17 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import com.google.common.base.Objects; -/** +/** * Instance of a federate, or marker that no federation has been defined * (if isSingleton() returns true) FIXME: this comment makes no sense. * Every top-level reactor (contained * directly by the main reactor) is a federate, so there will be one * instance of this class for each top-level reactor. - * + * * @author Edward A. Lee * @author Soroush Bateni */ -public class FederateInstance { +public class FederateInstance { // why does this not extend ReactorInstance? /** * Construct a new instance with the specified instantiation of diff --git a/org.lflang/src/org/lflang/generator/CodeMap.java b/org.lflang/src/org/lflang/generator/CodeMap.java index 12d5ea8f65..d00fe9bc9a 100644 --- a/org.lflang/src/org/lflang/generator/CodeMap.java +++ b/org.lflang/src/org/lflang/generator/CodeMap.java @@ -17,6 +17,7 @@ import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.eclipse.xtext.util.LineAndColumn; +import org.lflang.lf.ParameterReference; import org.lflang.lf.impl.ParameterReferenceImpl; /** @@ -147,6 +148,10 @@ public static String tag(EObject astNode, String representation, boolean verbati oneBasedLfLineAndColumn.getLine(), oneBasedLfLineAndColumn.getColumn() ); final URI uri = bestEffortGetEResource(astNode).getURI(); + if (uri == null) { + // no EResource, no correspondence can be found + return representation; + } final Path lfPath = Path.of(uri.isFile() ? uri.toFileString() : uri.path()); if (verbatim) lfStart = lfStart.plus(node.getText().substring(0, indexOf(node.getText(), representation))); return new Correspondence( @@ -162,12 +167,10 @@ public static String tag(EObject astNode, String representation, boolean verbati * This is a dangerous operation which can cause an unrecoverable error. */ private static Resource bestEffortGetEResource(EObject astNode) { - if (astNode instanceof ParameterReferenceImpl pri) return pri.getParameter().eResource(); - Resource ret = astNode.eResource(); - if (ret != null) return ret; - throw new RuntimeException( - "Every non-null AST node should have an EResource, but \"" + astNode + "\" does not." - ); + if (astNode instanceof ParameterReference pri) { + return pri.getParameter().eResource(); + } + return astNode.eResource(); } /** diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index ef35d22be1..ba39a94d9f 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -47,19 +47,15 @@ import org.lflang.MainConflictChecker; import org.lflang.Target; import org.lflang.TargetConfig; -import org.lflang.TimeUnit; -import org.lflang.TimeValue; import org.lflang.ast.AstTransformation; import org.lflang.graph.InstantiationGraph; import org.lflang.lf.Connection; -import org.lflang.lf.Expression; import org.lflang.lf.Instantiation; import org.lflang.lf.LfFactory; import org.lflang.lf.Mode; import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; -import org.lflang.lf.Time; import org.lflang.validation.AbstractLFValidator; import com.google.common.base.Objects; @@ -418,33 +414,6 @@ public int getReactionBankIndex(Reaction reaction) { return reactionBankIndices.get(reaction); } - /** - * Given a representation of time that may possibly include units, return - * a string that the target language can recognize as a value. In this base - * class, if units are given, e.g. "msec", then we convert the units to upper - * case and return an expression of the form "MSEC(value)". Particular target - * generators will need to either define functions or macros for each possible - * time unit or override this method to return something acceptable to the - * target language. - * @param time A TimeValue that represents a time. - * @return A string, such as "MSEC(100)" for 100 milliseconds. - */ - public static String timeInTargetLanguage(TimeValue time) { - if (time != null) { - if (time.unit != null) { - return cMacroName(time.unit) + "(" + time.getMagnitude() + ")"; - } else { - return Long.valueOf(time.getMagnitude()).toString(); - } - } - return "0"; // FIXME: do this or throw exception? - } - - // note that this is moved out by #544 - public static String cMacroName(TimeUnit unit) { - return unit.getCanonicalName().toUpperCase(); - } - // ////////////////////////////////////////// // // Protected methods. @@ -674,50 +643,4 @@ public void printInfo(LFGeneratorContext.Mode mode) { */ public abstract Target getTarget(); - /** - * Get textual representation of a time in the target language. - * - * @param t A time AST node - * @return A time string in the target language - */ - // FIXME: this should be placed in ExpressionGenerator - public static String getTargetTime(Time t) { - TimeValue value = new TimeValue(t.getInterval(), TimeUnit.fromName(t.getUnit())); - return timeInTargetLanguage(value); - } - - /** - * Get textual representation of a value in the target language. - * - * If the value evaluates to 0, it is interpreted as a normal value. - * - * @param expr An AST node - * @return A string in the target language - */ - // FIXME: this should be placed in ExpressionGenerator - public static String getTargetValue(Expression expr) { - if (expr instanceof Time) { - return getTargetTime((Time)expr); - } - return ASTUtils.toText(expr); - } - - /** - * Get textual representation of a value in the target language. - * - * If the value evaluates to 0, it is interpreted as a time. - * - * @param expr A time AST node - * @return A time string in the target language - */ - // FIXME: this should be placed in ExpressionGenerator - public static String getTargetTime(Expression expr) { - if (expr instanceof Time) { - return getTargetTime((Time)expr); - } else if (ASTUtils.isZero(expr)) { - TimeValue value = TimeValue.ZERO; - return timeInTargetLanguage(value); - } - return ASTUtils.toText(expr); - } } diff --git a/org.lflang/src/org/lflang/generator/GeneratorUtils.java b/org.lflang/src/org/lflang/generator/GeneratorUtils.java index 709e1943bd..92a57fd424 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorUtils.java +++ b/org.lflang/src/org/lflang/generator/GeneratorUtils.java @@ -16,8 +16,8 @@ import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.TargetConfig; -import org.lflang.generator.LFGeneratorContext.Mode; import org.lflang.TargetProperty; +import org.lflang.generator.LFGeneratorContext.Mode; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; import org.lflang.lf.Instantiation; diff --git a/org.lflang/src/org/lflang/generator/LfExpressionVisitor.java b/org.lflang/src/org/lflang/generator/LfExpressionVisitor.java new file mode 100644 index 0000000000..2bb72789ff --- /dev/null +++ b/org.lflang/src/org/lflang/generator/LfExpressionVisitor.java @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2023, TU Dresden. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + */ + +package org.lflang.generator; + +import org.lflang.lf.BracedListExpression; +import org.lflang.lf.Code; +import org.lflang.lf.CodeExpr; +import org.lflang.lf.Expression; +import org.lflang.lf.LfFactory; +import org.lflang.lf.Literal; +import org.lflang.lf.ParameterReference; +import org.lflang.lf.Time; + +/** + * A visitor for expressions in LF. + * + * @author Clément Fournier <clement.fournier@tu-dresden.de> + */ +public interface LfExpressionVisitor { + + + R visitLiteral(Literal expr, P param); + + R visitBracedListExpr(BracedListExpression expr, P param); + + R visitTimeLiteral(Time expr, P param); + + R visitCodeExpr(CodeExpr expr, P param); + + R visitParameterRef(ParameterReference expr, P param); + + /** + * Dispatch the visitor on the given expression type. + * + * @param e An expression that will be visited + * @param arg Argument for the visitor + * @param visitor Visitor + * @param

Type of parameter expected by the visitor + * @param Return type of the visitor + * @return The return value of the visitor + */ + static R dispatch(Expression e, P arg, LfExpressionVisitor visitor) { + if (e instanceof Literal) { + return visitor.visitLiteral((Literal) e, arg); + } else if (e instanceof BracedListExpression) { + return visitor.visitBracedListExpr((BracedListExpression) e, arg); + } else if (e instanceof Time) { + return visitor.visitTimeLiteral((Time) e, arg); + } else if (e instanceof CodeExpr) { + return visitor.visitCodeExpr((CodeExpr) e, arg); + } else if (e instanceof ParameterReference) { + return visitor.visitParameterRef((ParameterReference) e, arg); + } + + throw new IllegalArgumentException("Expression of type " + e.getClass() + " not handled"); + } + + /** Base visitor class where methods are defaulted to a common one. */ + abstract class DefaultLfVisitor implements LfExpressionVisitor { + + abstract R visitExpression(Expression expr, P param); + + @Override + public R visitLiteral(Literal expr, P param) { + return visitExpression(expr, param); + } + + @Override + public R visitBracedListExpr(BracedListExpression expr, P param) { + return visitExpression(expr, param); + } + + @Override + public R visitTimeLiteral(Time expr, P param) { + return visitExpression(expr, param); + } + + @Override + public R visitCodeExpr(CodeExpr expr, P param) { + return visitExpression(expr, param); + } + + @Override + public R visitParameterRef(ParameterReference expr, P param) { + return visitExpression(expr, param); + } + } + + /** + * A visitor that deep copies the expression. Can be extended + * to replace certain expressions during the copy. + * + * @param

Parameter type + */ + class LfExpressionDeepCopyVisitor

implements LfExpressionVisitor { + + @Override + public Expression visitLiteral(Literal expr, P param) { + Literal clone = LfFactory.eINSTANCE.createLiteral(); + clone.setLiteral(expr.getLiteral()); + return clone; + } + + @Override + public Expression visitBracedListExpr(BracedListExpression expr, P param) { + BracedListExpression clone = LfFactory.eINSTANCE.createBracedListExpression(); + for (Expression item : expr.getItems()) { + clone.getItems().add(dispatch(item, param, this)); + } + return clone; + } + + @Override + public Expression visitTimeLiteral(Time expr, P param) { + Time clone = LfFactory.eINSTANCE.createTime(); + clone.setUnit(expr.getUnit()); + clone.setInterval(expr.getInterval()); + return clone; + } + + @Override + public Expression visitParameterRef(ParameterReference expr, P param) { + ParameterReference clone = LfFactory.eINSTANCE.createParameterReference(); + clone.setParameter(expr.getParameter()); + return clone; + } + + @Override + public Expression visitCodeExpr(CodeExpr expr, P param) { + CodeExpr codeExpr = LfFactory.eINSTANCE.createCodeExpr(); + Code code = LfFactory.eINSTANCE.createCode(); + code.setBody(expr.getCode().getBody()); + codeExpr.setCode(code); + return codeExpr; + } + } + +} diff --git a/org.lflang/src/org/lflang/generator/ParameterInstance.java b/org.lflang/src/org/lflang/generator/ParameterInstance.java index 9da4f1f247..9287710e6b 100644 --- a/org.lflang/src/org/lflang/generator/ParameterInstance.java +++ b/org.lflang/src/org/lflang/generator/ParameterInstance.java @@ -30,10 +30,12 @@ import java.util.List; import java.util.Optional; -import org.lflang.InferredType; import org.lflang.ASTUtils; +import org.lflang.InferredType; import org.lflang.lf.Assignment; import org.lflang.lf.Expression; +import org.lflang.lf.Initializer; +import org.lflang.lf.LfFactory; import org.lflang.lf.Parameter; /** @@ -71,13 +73,26 @@ public ParameterInstance(Parameter definition, ReactorInstance parent) { //// Public Methods /** - * Get the initial value(s) of this parameter as a list of - * Value objects, where each Value is either an instance - * of Time, Literal, or Code. That is, references to other - * parameters have been replaced with their initial values. + * Get the initial value of this parameter. */ - public List getInitialValue() { - return parent.initialParameterValue(this.definition); + private Initializer getInitialValue() { + return definition.getInit(); + } + + /** + * Return the (possibly overridden) value of this parameter + * in the containing instance. Parameter references are resolved + * to actual expressions. + */ + public Initializer getActualValue() { + Assignment override = getOverride(); + Initializer init; + if (override != null) { + init = override.getRhs(); + } else { + init = getInitialValue(); + } + return init; } /** diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index cc049f971c..833cd7e934 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -26,6 +26,9 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.generator; +import static org.lflang.ASTUtils.belongsTo; +import static org.lflang.ASTUtils.getLiteralTimeValue; + import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; @@ -33,6 +36,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; import org.eclipse.emf.ecore.util.EcoreUtil; @@ -43,10 +47,12 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.TimeValue; import org.lflang.generator.TriggerInstance.BuiltinTriggerVariable; import org.lflang.lf.Action; +import org.lflang.lf.Assignment; import org.lflang.lf.BuiltinTrigger; import org.lflang.lf.BuiltinTriggerRef; import org.lflang.lf.Connection; import org.lflang.lf.Expression; +import org.lflang.lf.Initializer; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.LfFactory; @@ -451,29 +457,50 @@ public boolean hasCycles() { */ public Integer initialIntParameterValue(Parameter parameter) { return ASTUtils.initialValueInt(parameter, instantiations()); - } + } - /** - * Given a parameter definition for this reactor, return the initial value - * of the parameter. If the parameter is overridden when instantiating - * this reactor or any of its containing reactors, use that value. - * Otherwise, use the default value in the reactor definition. - * - * The returned list of Value objects is such that each element is an - * instance of Time, String, or Code, never Parameter. - * For most uses, this list has only one element, but parameter - * values can be lists of elements, so the returned value is a list. - * - * @param parameter The parameter definition (a syntactic object in the AST). - * - * @return A list of Value objects, or null if the parameter is not found. - * Return an empty list if no initial value is given. - * Each value is an instance of Literal if a literal value is given, - * a Time if a time value was given, or a Code, if a code value was - * given (text in the target language delimited by {= ... =} - */ - public List initialParameterValue(Parameter parameter) { - return ASTUtils.initialValue(parameter, instantiations()); + public Expression resolveParameters(Expression e) { + return LfExpressionVisitor.dispatch(e, this, ParameterInliner.INSTANCE); + } + + + private static final class ParameterInliner extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { + static final ParameterInliner INSTANCE = new ParameterInliner(); + + @Override + public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { + if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { + throw new IllegalArgumentException("Parameter " + + expr.getParameter().getName() + + " is not a parameter of reactor instance " + + instance.getName() + + "." + ); + } + + Optional assignment = + instance.definition.getParameters().stream() + .filter(it -> it.getLhs().equals(expr.getParameter())) + .findAny(); // There is at most one + + if (assignment.isPresent()) { + // replace the parameter with its value. + Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); + // recursively resolve parameters + return instance.getParent().resolveParameters(value); + } else { + // In that case use the default value. Default values + // cannot use parameter values, so they don't need to + // be recursively resolved. + Initializer init = expr.getParameter().getInit(); + Expression defaultValue = ASTUtils.asSingleExpr(init); + if (defaultValue == null) { + // this is a problem + return super.visitParameterRef(expr, instance); + } + return defaultValue; + } + } } /** @@ -686,14 +713,8 @@ public String toString() { * precise time value assigned to this reactor instance. */ public TimeValue getTimeValue(Expression expr) { - if (expr instanceof ParameterReference) { - final var param = ((ParameterReference)expr).getParameter(); - // Avoid a runtime error in validator for invalid programs. - if (lookupParameterInstance(param).getInitialValue().isEmpty()) return null; - return ASTUtils.getLiteralTimeValue(lookupParameterInstance(param).getInitialValue().get(0)); - } else { - return ASTUtils.getLiteralTimeValue(expr); - } + Expression resolved = resolveParameters(expr); + return getLiteralTimeValue(resolved); } ////////////////////////////////////////////////////// diff --git a/org.lflang/src/org/lflang/generator/TargetTypes.java b/org.lflang/src/org/lflang/generator/TargetTypes.java index fe73bd78cc..8d9788e19e 100644 --- a/org.lflang/src/org/lflang/generator/TargetTypes.java +++ b/org.lflang/src/org/lflang/generator/TargetTypes.java @@ -8,6 +8,7 @@ import org.lflang.InferredType; import org.lflang.TimeValue; import org.lflang.lf.Action; +import org.lflang.lf.BracedListExpression; import org.lflang.lf.CodeExpr; import org.lflang.lf.Expression; import org.lflang.lf.Initializer; @@ -68,6 +69,13 @@ default String getTargetParamRef(ParameterReference expr, InferredType typeOrNul return escapeIdentifier(expr.getParameter().getName()); } + /** Translate the braced list expression into target language syntax. */ + default String getTargetBracedListExpr(BracedListExpression expr, InferredType typeOrNull) { + InferredType t = typeOrNull == null ? InferredType.undefined() : typeOrNull; + return expr.getItems().stream().map(e -> getTargetExpr(e, t)) + .collect(Collectors.joining(",", "{", "}")); + } + /** * Return an "undefined" type which is used as a default * when a type cannot be inferred. @@ -231,10 +239,8 @@ default String getTargetInitializer(Initializer init, Type type) { var targetValues = init.getExprs().stream().map(it -> getTargetExpr(it, inferredType)).collect(Collectors.toList()); if (inferredType.isFixedSizeList) { return getFixedSizeListInitExpression(targetValues, inferredType.listSize, init.isBraces()); - } else if (inferredType.isVariableSizeList) { + } else { return getVariableSizeListInitExpression(targetValues, init.isBraces()); - } else { - return getMissingExpr(inferredType); } } @@ -254,6 +260,8 @@ default String getTargetExpr(Expression expr, InferredType type) { return ASTUtils.addZeroToLeadingDot(((Literal) expr).getLiteral()); // here we don't escape } else if (expr instanceof CodeExpr) { return ASTUtils.toText(((CodeExpr) expr).getCode()); + } else if (expr instanceof BracedListExpression) { + return getTargetBracedListExpr((BracedListExpression) expr, type); } else { throw new IllegalStateException("Invalid value " + expr); } diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index e800328e18..1c4a1b45e8 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -4,10 +4,8 @@ import java.util.ArrayList; import org.lflang.ASTUtils; import org.lflang.Target; -import org.lflang.federated.generator.FederateInstance; import org.lflang.generator.ActionInstance; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.GeneratorBase; import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.Reactor; @@ -40,9 +38,10 @@ public static String generateInitializers( var triggerStructName = CUtil.reactorRef(action.getParent()) + "->_lf__" + action.getName(); var minDelay = action.getMinDelay(); var minSpacing = action.getMinSpacing(); - var offsetInitializer = triggerStructName+".offset = " + GeneratorBase.timeInTargetLanguage(minDelay) + ";"; + var offsetInitializer = triggerStructName+".offset = " + CTypes.getInstance().getTargetTimeExpr(minDelay) + + ";"; var periodInitializer = triggerStructName+".period = " + (minSpacing != null ? - GeneratorBase.timeInTargetLanguage(minSpacing) : + CTypes.getInstance().getTargetTimeExpr(minSpacing) : CGenerator.UNDEFINED_MIN_SPACING) + ";"; code.addAll(List.of( "// Initializing action "+action.getFullName(), diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 2ef5074455..70f76c282e 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -394,9 +394,9 @@ public CGenerator(LFGeneratorContext context, boolean ccppMode) { this( context, ccppMode, - new CTypes(context.getErrorReporter()), + new CTypes(), new CCmakeGenerator(context.getFileConfig(), List.of()), - new CDelayBodyGenerator(new CTypes(context.getErrorReporter())) + new CDelayBodyGenerator(new CTypes()) ); } @@ -1910,7 +1910,7 @@ private void generateSetDeadline(ReactorInstance instance) { var selfRef = CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+reaction.index; if (reaction.declaredDeadline != null) { var deadline = reaction.declaredDeadline.maxDelay; - initializeTriggerObjects.pr(selfRef+".deadline = "+GeneratorBase.timeInTargetLanguage(deadline)+";"); + initializeTriggerObjects.pr(selfRef+".deadline = "+types.getTargetTimeExpr(deadline)+";"); } else { // No deadline. initializeTriggerObjects.pr(selfRef+".deadline = NEVER;"); } diff --git a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java index 23906eae73..1534f0ea02 100644 --- a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java @@ -1,15 +1,16 @@ package org.lflang.generator.c; -import java.util.LinkedList; import java.util.List; +import java.util.stream.Collectors; + +import org.lflang.InferredType; import org.lflang.generator.ParameterInstance; import org.lflang.ASTUtils; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.GeneratorBase; import org.lflang.lf.Assignment; import org.lflang.lf.Expression; +import org.lflang.lf.Initializer; import org.lflang.lf.Parameter; -import org.lflang.lf.ParameterReference; import org.lflang.lf.Reactor; /** @@ -32,46 +33,9 @@ public static String getInitializer(ParameterInstance p) { return CUtil.bankIndex(p.getParent()); } - // Handle overrides in the intantiation. - // In case there is more than one assignment to this parameter, we need to - // find the last one. - Assignment lastAssignment = null; - for (Assignment assignment: p.getParent().getDefinition().getParameters()) { - if (assignment.getLhs() == p.getDefinition()) { - lastAssignment = assignment; - } - } - List list = new LinkedList<>(); - if (lastAssignment != null) { - // The parameter has an assignment. - // Right hand side can be a list. Collect the entries. - for (Expression expr: lastAssignment.getRhs().getExprs()) { - if (expr instanceof ParameterReference) { - // The parameter is being assigned a parameter value. - // Assume that parameter belongs to the parent's parent. - // This should have been checked by the validator. - final var param = ((ParameterReference) expr).getParameter(); - list.add(CUtil.reactorRef(p.getParent().getParent()) + "->" + param.getName()); - } else { - list.add(GeneratorBase.getTargetTime(expr)); - } - } - } else { - // there was no assignment in the instantiation. So just use the - // parameter's initial value. - for (Expression expr : p.getParent().initialParameterValue(p.getDefinition())) { - if (ASTUtils.isOfTimeType(p.getDefinition())) { - list.add(GeneratorBase.getTargetTime(expr)); - } else { - list.add(GeneratorBase.getTargetTime(expr)); - } - } - } - if (list.size() == 1) { - return list.get(0); - } else { - return "{" + String.join(", ", list) + "}"; - } + CTypes ctypes = CTypes.generateParametersIn(p.getParent().getParent()); + Initializer values = p.getActualValue(); + return ctypes.getTargetInitializer(values, p.getDefinition().getType()); } /** diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java index a0bcf28823..46910f4167 100644 --- a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java @@ -3,6 +3,7 @@ import java.util.LinkedList; import org.lflang.ASTUtils; +import org.lflang.InferredType; import org.lflang.generator.CodeBuilder; import org.lflang.generator.GeneratorBase; import org.lflang.generator.ModeInstance; @@ -126,17 +127,7 @@ private static String generateModalReset( * references are replaced with accesses to the self struct of the parent. */ private static String getInitializerExpr(StateVar state, ReactorInstance parent) { - var list = new LinkedList(); - for (Expression expr : state.getInit().getExprs()) { - if (expr instanceof ParameterReference) { - final var param = ((ParameterReference)expr).getParameter(); - list.add(CUtil.reactorRef(parent) + "->" + param.getName()); - } else { - list.add(GeneratorBase.getTargetTime(expr)); - } - } - return list.size() == 1 ? - list.get(0) : - "{" + String.join(", ", list) + "}"; + var ctypes = CTypes.generateParametersIn(parent); + return ctypes.getTargetInitializer(state.getInit(), state.getType()); } } diff --git a/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java b/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java index e0c2000e87..75623fdfe7 100644 --- a/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java @@ -1,7 +1,7 @@ package org.lflang.generator.c; import java.util.List; -import org.lflang.generator.GeneratorBase; + import org.lflang.generator.TimerInstance; /** @@ -18,8 +18,8 @@ public class CTimerGenerator { */ public static String generateInitializer(TimerInstance timer) { var triggerStructName = CUtil.reactorRef(timer.getParent()) + "->_lf__" + timer.getName(); - var offset = GeneratorBase.timeInTargetLanguage(timer.getOffset()); - var period = GeneratorBase.timeInTargetLanguage(timer.getPeriod()); + var offset = CTypes.getInstance().getTargetTimeExpr(timer.getOffset()); + var period = CTypes.getInstance().getTargetTimeExpr(timer.getPeriod()); var mode = timer.getMode(false); var modeRef = mode != null ? "&"+CUtil.reactorRef(mode.getParent())+"->_lf__modes["+mode.getParent().modes.indexOf(mode)+"];" : diff --git a/org.lflang/src/org/lflang/generator/c/CTypes.java b/org.lflang/src/org/lflang/generator/c/CTypes.java index 803d9e8432..ba5b3631a9 100644 --- a/org.lflang/src/org/lflang/generator/c/CTypes.java +++ b/org.lflang/src/org/lflang/generator/c/CTypes.java @@ -1,11 +1,18 @@ package org.lflang.generator.c; +import java.util.List; import java.util.regex.Matcher; import java.util.regex.Pattern; +import java.util.stream.Collectors; -import org.lflang.ErrorReporter; import org.lflang.InferredType; +import org.lflang.TimeUnit; +import org.lflang.TimeValue; +import org.lflang.generator.ReactorInstance; import org.lflang.generator.TargetTypes; +import org.lflang.lf.Initializer; +import org.lflang.lf.ParameterReference; +import org.lflang.lf.Type; public class CTypes implements TargetTypes { @@ -13,20 +20,9 @@ public class CTypes implements TargetTypes { // For example, for "foo[10]", the first match will be "foo" and the second "[10]". // For "foo[]", the first match will be "foo" and the second "". static final Pattern arrayPattern = Pattern.compile("^\\s*(?:/\\*.*?\\*/)?\\s*(\\w+)\\s*\\[([0-9]*)]\\s*$"); + private static final CTypes INSTANCE = new CTypes(); - // FIXME: Instead of using the ErrorReporter, perhaps we should be raising assertion errors or - // UnsupportedOperationExceptions or some other non-recoverable errors. - private final ErrorReporter errorReporter; - - /** - * Initializes a {@code CTargetTypes} with the given - * error reporter. - * @param errorReporter The error reporter for any - * errors raised in the code - * generation process. - */ - public CTypes(ErrorReporter errorReporter) { - this.errorReporter = errorReporter; + public CTypes() { } @Override @@ -56,7 +52,7 @@ public String getTargetVariableSizeListType(String baseType) { @Override public String getTargetUndefinedType() { - return String.format("/* %s */", errorReporter.reportError("undefined type")); + return "/*undefined*/"; } /** @@ -78,6 +74,33 @@ public String getTargetType(InferredType type) { return result; } + @Override + public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + throw new UnsupportedOperationException("No context defined"); + } + + @Override + public String getTargetTimeExpr(TimeValue time) { + if (time != null) { + if (time.unit != null) { + return cMacroName(time.unit) + "(" + time.getMagnitude() + ")"; + } else { + return Long.valueOf(time.getMagnitude()).toString(); + } + } + return "0"; // FIXME: do this or throw exception? + } + + @Override + public String getFixedSizeListInitExpression(List contents, int listSize, boolean withBraces) { + return contents.stream().collect(Collectors.joining(", ", "{ ", " }")); + } + + @Override + public String getVariableSizeListInitExpression(List contents, boolean withBraces) { + return contents.stream().collect(Collectors.joining(", ", "{ ", " }")); + } + /** * Return a variable declaration of the form "{@code type name}". * The type is as returned by {@link #getTargetType(InferredType)}, except with @@ -119,4 +142,23 @@ public String getVariableDeclaration( } return declaration; } + + // note that this is moved out by #544 + public static String cMacroName(TimeUnit unit) { + return unit.getCanonicalName().toUpperCase(); + } + + public static CTypes getInstance() { + return INSTANCE; + } + + + public static CTypes generateParametersIn(ReactorInstance instance) { + return new CTypes() { + @Override + public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + return CUtil.reactorRef(instance) + "->" + expr.getParameter().getName(); + } + }; + } } diff --git a/org.lflang/src/org/lflang/generator/cpp/CppParameterGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppParameterGenerator.kt index a460290287..3c2224e031 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppParameterGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppParameterGenerator.kt @@ -40,32 +40,28 @@ class CppParameterGenerator(private val reactor: Reactor) { val Parameter.typeAlias get(): String = "__lf_${name}_t" } - /** Generate all constructor initializers for parameters */ - fun generateInitializers() = - reactor.parameters.joinWithLn(prefix = "// parameters\n") { - ", ${it.name}(parameters.${it.name})" - } - /** Generate all parameter declarations as used in the parameter struct */ fun generateParameterStructDeclarations() = reactor.parameters.joinToString("\n", postfix = "\n") { with(it) { """ using $typeAlias = $targetType; - const $typeAlias $name${ - if (init == null) "" else " = " + typeAlias + CppTypes.getCppInitializer( + $typeAlias $name${ + if (init == null) "" else CppTypes.getCppInitializer( init, - inferredType + inferredType, + typeAlias = typeAlias ) }; """.trimIndent() } } - /** Generate using declarations for each parameter for use in the inner reactor class. - * This is required for C++ to bring templated parameters into scope. + /** Generate alias declarations for each parameter for use in the inner reactor class. + * This is required to bring parameters into scope. */ - fun generateUsingDeclarations() = reactor.parameters.joinToString(separator = "") { "using Parameters::${it.name};\n" } + fun generateInnerAliasDeclarations() = + reactor.parameters.joinToString(separator = "") { "const typename Parameters::${it.typeAlias}& ${it.name} = __lf_parameters.${it.name};\n" } /** Generate alias declarations for each parameter for use in the outer reactor class. * This is required for some code bodies (e.g. target code in parameter initializers) to have access to the local parameters. diff --git a/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt index de8deb7a4f..50fff0bdb5 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt @@ -94,8 +94,9 @@ class CppReactorGenerator(private val reactor: Reactor, fileConfig: CppFileConfi | private: ${" | "..reactions.generateReactionViewForwardDeclarations()} | - | class Inner: public lfutil::LFScope, public Parameters { - ${" | "..parameters.generateUsingDeclarations()} + | class Inner: public lfutil::LFScope { + | const Parameters __lf_parameters; + ${" | "..parameters.generateInnerAliasDeclarations()} ${" | "..state.generateDeclarations()} ${" | "..methods.generateDeclarations()} ${" | "..reactions.generateBodyDeclarations()} @@ -161,9 +162,9 @@ class CppReactorGenerator(private val reactor: Reactor, fileConfig: CppFileConfi return with(PrependOperator) { """ |${reactor.templateLine} - |${reactor.templateName}::Inner::Inner(::reactor::Reactor* reactor, Parameters&& __lf_parameters) + |${reactor.templateName}::Inner::Inner(::reactor::Reactor* reactor, Parameters&& parameters) | : LFScope(reactor) - ${" | , Parameters(std::forward(__lf_parameters))"} + ${" | , __lf_parameters(std::forward(parameters))"} ${" | "..state.generateInitializers()} |{} """.trimMargin() diff --git a/org.lflang/src/org/lflang/generator/cpp/CppStateGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppStateGenerator.kt index 4b26328155..1d5050fee9 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppStateGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppStateGenerator.kt @@ -42,6 +42,6 @@ class CppStateGenerator(private val reactor: Reactor) { fun generateInitializers(): String = reactor.stateVars.filter { it.isInitialized } .joinWithLn(prefix = "// state variables\n") { - ", " + it.name + CppTypes.getCppInitializer(it.init, it.inferredType) + ", " + it.name + CppTypes.getCppInitializer(it.init, it.inferredType, disableEquals = true) } } diff --git a/org.lflang/src/org/lflang/generator/cpp/CppTypes.kt b/org.lflang/src/org/lflang/generator/cpp/CppTypes.kt index e0a7103f20..6a908392ab 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppTypes.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppTypes.kt @@ -28,6 +28,7 @@ import org.lflang.InferredType import org.lflang.TimeUnit import org.lflang.TimeValue import org.lflang.generator.TargetTypes +import org.lflang.joinWithCommas import org.lflang.lf.Initializer import org.lflang.lf.ParameterReference @@ -71,14 +72,24 @@ val TimeUnit?.cppUnit /** * Returns a C++ variable initializer. */ -fun CppTypes.getCppInitializer(init: Initializer?, inferredType: InferredType): String { - return if (init == null) { +fun CppTypes.getCppInitializer( + init: Initializer?, + inferredType: InferredType, + disableEquals: Boolean = false, + typeAlias: String? = null +): String = + if (init == null) { "/*uninitialized*/" + } else if (init.isAssign && !disableEquals) { + val e = init.exprs.single() + " = " + getTargetExpr(e, inferredType) + } else if (init.isParens && typeAlias != null && !disableEquals) { + " = $typeAlias" + init.exprs.joinWithCommas("(", ")", trailing = false) { + getTargetExpr(it, inferredType.componentType) + } } else { - assert(init.isBraces || init.isParens) val (prefix, postfix) = if (init.isBraces) Pair("{", "}") else Pair("(", ")") - init.exprs.joinToString(", ", prefix, postfix) { + init.exprs.joinWithCommas(prefix, postfix, trailing = false) { getTargetExpr(it, inferredType.componentType) } } -} \ No newline at end of file diff --git a/org.lflang/src/org/lflang/generator/python/PyUtil.java b/org.lflang/src/org/lflang/generator/python/PyUtil.java index 78375c910a..9ca2f7222f 100644 --- a/org.lflang/src/org/lflang/generator/python/PyUtil.java +++ b/org.lflang/src/org/lflang/generator/python/PyUtil.java @@ -26,6 +26,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.generator.python; +import org.lflang.InferredType; import org.lflang.generator.ReactorInstance; import org.lflang.generator.GeneratorBase; import org.lflang.generator.c.CUtil; @@ -143,25 +144,6 @@ public static String generateGILReleaseCode() { * @return A value string in the target language */ protected static String getPythonTargetValue(Expression expr) { - String returnValue; - switch (ASTUtils.toOriginalText(expr)) { - case "false": - returnValue = "False"; - break; - case "true": - returnValue = "True"; - break; - default: - returnValue = GeneratorBase.getTargetValue(expr); - } - - // Parameters in Python are always prepended with a 'self.' - // predicate. Therefore, we need to append the returned value - // if it is a parameter. - if (expr instanceof ParameterReference) { - returnValue = "self." + returnValue; - } - - return returnValue; + return PythonTypes.getInstance().getTargetExpr(expr, InferredType.undefined()); } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 46bcc4f811..3f82f20016 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -96,7 +96,7 @@ public class PythonGenerator extends CGenerator { public PythonGenerator(LFGeneratorContext context) { this(context, - new PythonTypes(context.getErrorReporter()), + new PythonTypes(), new CCmakeGenerator( context.getFileConfig(), List.of("lib/python_action.c", diff --git a/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java index 5617350062..fe78d8187f 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java @@ -8,6 +8,7 @@ import com.google.common.base.Objects; import org.lflang.ASTUtils; +import org.lflang.InferredType; import org.lflang.generator.GeneratorBase; import org.lflang.generator.ParameterInstance; import org.lflang.lf.Expression; @@ -95,8 +96,7 @@ private static List getAllParameters(ReactorDecl decl) { * @return Initialization code */ private static String generatePythonInitializer(Parameter p) { - List values = p.getInit().getExprs().stream().map(PyUtil::getPythonTargetValue).toList(); - return values.size() > 1 ? "(" + String.join(", ", values) + ")" : values.get(0); + return PythonTypes.getInstance().getTargetInitializer(p.getInit(), p.getType()); } /** @@ -110,47 +110,8 @@ private static String generatePythonInitializer(Parameter p) { * @return Initialization code */ public static String generatePythonInitializer(ParameterInstance p) { - // Handle overrides in the instantiation. - // In case there is more than one assignment to this parameter, we need to - // find the last one. - Assignment lastAssignment = getLastAssignment(p); - List list = new LinkedList<>(); - if (lastAssignment != null) { - // The parameter has an assignment. - // Right hand side can be a list. Collect the entries. - for (Expression expr : lastAssignment.getRhs().getExprs()) { - if (expr instanceof ParameterReference) { - // The parameter is being assigned a parameter value. - // Assume that parameter belongs to the parent's parent. - // This should have been checked by the validator. - final var param = ((ParameterReference) expr).getParameter(); - list.add(PyUtil.reactorRef(p.getParent().getParent()) + "." + param.getName()); - } else { - list.add(GeneratorBase.getTargetTime(expr)); - } - } - } else { - for (Expression expr : p.getParent().initialParameterValue(p.getDefinition())) { - list.add(PyUtil.getPythonTargetValue(expr)); - } - } - return list.size() > 1 ? "(" + String.join(", ", list) + ")" : list.get(0); + PythonTypes pyTypes = PythonTypes.generateParametersIn(p.getParent().getParent()); + return pyTypes.getTargetInitializer(p.getActualValue(), p.getDefinition().getType()); } - /** - * Returns the last assignment to "p" if there is one, - * or null if there is no assignment to "p" - * - * @param p The parameter instance to create initializer for - * @return The last assignment of the parameter instance - */ - private static Assignment getLastAssignment(ParameterInstance p) { - Assignment lastAssignment = null; - for (Assignment assignment : p.getParent().getDefinition().getParameters()) { - if (Objects.equal(assignment.getLhs(), p.getDefinition())) { - lastAssignment = assignment; - } - } - return lastAssignment; - } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonTypes.java b/org.lflang/src/org/lflang/generator/python/PythonTypes.java index c066494047..5b62ee5f97 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonTypes.java +++ b/org.lflang/src/org/lflang/generator/python/PythonTypes.java @@ -1,27 +1,20 @@ package org.lflang.generator.python; +import java.util.List; import java.util.regex.Pattern; +import java.util.stream.Collectors; -import org.lflang.ErrorReporter; import org.lflang.InferredType; +import org.lflang.generator.ReactorInstance; import org.lflang.generator.c.CTypes; +import org.lflang.generator.c.CUtil; +import org.lflang.lf.ParameterReference; public class PythonTypes extends CTypes { // Regular expression pattern for pointer types. The star at the end has to be visible. static final Pattern pointerPatternVariable = Pattern.compile("^\\s*+(\\w+)\\s*\\*\\s*$"); - - /** - * Initializes a {@code CTargetTypes} with the given - * error reporter. - * - * @param errorReporter The error reporter for any - * errors raised in the code - * generation process. - */ - public PythonTypes(ErrorReporter errorReporter) { - super(errorReporter); - } + private static final PythonTypes INSTANCE = new PythonTypes(); @Override public String getTargetUndefinedType() { @@ -39,16 +32,45 @@ public String getTargetUndefinedType() { public String getPythonType(InferredType type) { var result = super.getTargetType(type); - switch(result){ - case "double": result = "float"; - case "string": result = "object"; - } + result = switch (result) { + case "double" -> "float"; + case "string" -> "object"; + default -> result; + }; var matcher = pointerPatternVariable.matcher(result); - if(matcher.find()) { + if (matcher.find()) { return matcher.group(1); } return result; } + + @Override + public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + return "self." + expr.getParameter().getName(); + } + + @Override + public String getFixedSizeListInitExpression(List contents, int listSize, boolean withBraces) { + return contents.stream().collect(Collectors.joining(", ", "[ ", " ]")); + } + + @Override + public String getVariableSizeListInitExpression(List contents, boolean withBraces) { + return contents.stream().collect(Collectors.joining(", ", "[ ", " ]")); + } + + public static PythonTypes getInstance() { + return INSTANCE; + } + + public static PythonTypes generateParametersIn(ReactorInstance instance) { + return new PythonTypes() { + @Override + public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + return PyUtil.reactorRef(instance) + "." + expr.getParameter().getName(); + } + }; + } } diff --git a/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt index c65cd157c5..0075950a1f 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt @@ -23,7 +23,7 @@ class TSConstructorGenerator( ) { private fun initializeParameter(p: Parameter): String = - "${p.name}: ${TSTypes.getTargetType(p)} = ${TSTypes.getTargetInitializer(p)}" + "${p.name}: ${TSTypes.getInstance().getTargetType(p)} = ${TSTypes.getInstance().getTargetInitializer(p)}" private fun generateConstructorArguments(reactor: Reactor): String { val arguments = StringJoiner(", \n") diff --git a/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt index b0a011d042..61aac6750e 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt @@ -16,7 +16,7 @@ object TSDelayBodyGenerator : DelayBodyGenerator { */ private fun getActionType(action: Action): String { return if (action.type != null) { - TSTypes.getTargetType(action.type) + TSTypes.getInstance().getTargetType(action.type) } else { "Present" } diff --git a/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java b/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java new file mode 100644 index 0000000000..cf89596a56 --- /dev/null +++ b/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java @@ -0,0 +1,29 @@ +package org.lflang.generator.ts; + +import org.lflang.generator.DockerGenerator; +import org.lflang.generator.LFGeneratorContext; + +/** + * Generates the docker file related code for the Typescript target. + * + * @author Hou Seng Wong + */ +public class TSDockerGenerator extends DockerGenerator { + + /** Construct a new Docker generator. */ + public TSDockerGenerator(LFGeneratorContext context) { + super(context); + } + + /** + * Return the content of the docker file for [tsFileName]. + */ + public String generateDockerFileContent() { + return """ + |FROM node:alpine + |WORKDIR /linguafranca/$name + |COPY . . + |ENTRYPOINT ["node", "dist/%s.js"] + """.formatted(context.getFileConfig().name); + } +} diff --git a/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.kt deleted file mode 100644 index 1ca762340e..0000000000 --- a/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.kt +++ /dev/null @@ -1,26 +0,0 @@ -package org.lflang.generator.ts - -import org.lflang.generator.DockerGenerator -import org.lflang.generator.LFGeneratorContext - -/** - * Generates the docker file related code for the Typescript target. - * - * @author Hou Seng Wong - */ -class TSDockerGenerator(context: LFGeneratorContext) : DockerGenerator(context) { - - /** - * Returns the content of the docker file for [tsFileName]. - */ - override fun generateDockerFileContent(): String { - val name = context.fileConfig.name - val dockerFileContent = """ - |FROM node:alpine - |WORKDIR /linguafranca/$name - |COPY . . - |ENTRYPOINT ["node", "dist/$name.js"] - """ - return dockerFileContent.trimMargin() - } -} diff --git a/org.lflang/src/org/lflang/generator/ts/TSExtensions.kt b/org.lflang/src/org/lflang/generator/ts/TSExtensions.kt index 4ed12daa13..a28e462921 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSExtensions.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSExtensions.kt @@ -39,7 +39,7 @@ fun WidthSpec.toTSCode(): String = terms.joinToString(" + ") { * @return The TS type. */ val Port.tsPortType: String - get() = type?.let { TSTypes.getTargetType(it) } ?: "Present" + get() = type?.let { TSTypes.getInstance().getTargetType(it) } ?: "Present" /** * Return a TS type for the specified action. @@ -48,7 +48,7 @@ val Port.tsPortType: String * @return The TS type. */ val Action.tsActionType: String - get() = type?.let { TSTypes.getTargetType(it) } ?: "Present" + get() = type?.let { TSTypes.getInstance().getTargetType(it) } ?: "Present" -fun Expression.toTsTime(): String = TSTypes.getTargetTimeExpr(this) -fun TimeValue.toTsTime(): String = TSTypes.getTargetTimeExpr(this) +fun Expression.toTsTime(): String = TSTypes.getInstance().getTargetTimeExpr(this) +fun TimeValue.toTsTime(): String = TSTypes.getInstance().getTargetTimeExpr(this) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 3fd3675d52..9262e44e64 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -429,7 +429,7 @@ class TSGenerator( return true } - override fun getTargetTypes(): TargetTypes = TSTypes + override fun getTargetTypes(): TargetTypes = TSTypes.getInstance() override fun getTarget(): Target { return Target.TS diff --git a/org.lflang/src/org/lflang/generator/ts/TSInstanceGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSInstanceGenerator.kt index 63857c0132..97e753f99b 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSInstanceGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSInstanceGenerator.kt @@ -25,10 +25,10 @@ class TSInstanceGenerator( private fun getTypeParams(typeParms: List): String = if (typeParms.isEmpty()) "" - else typeParms.joinToString(", ", "<", ">") { TSTypes.getTargetType(it) } + else typeParms.joinToString(", ", "<", ">") { TSTypes.getInstance().getTargetType(it) } private fun getReactorParameterList(parameters: List): String = - parameters.joinToString(", ", "[__Reactor, ", "]") { TSTypes.getTargetType(it) } + parameters.joinToString(", ", "[__Reactor, ", "]") { TSTypes.getInstance().getTargetType(it) } fun generateClassProperties(): String = @@ -50,7 +50,7 @@ class TSInstanceGenerator( childReactorArguments.add("this") for (parameter in childReactor.reactorClass.toDefinition().parameters) { - childReactorArguments.add(TSTypes.getTargetInitializer(parameter, childReactor)) + childReactorArguments.add(TSTypes.getInstance().getTargetInitializer(parameter, childReactor)) } if (childReactor.isBank) { childReactorInstantiations.add( diff --git a/org.lflang/src/org/lflang/generator/ts/TSParameterGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSParameterGenerator.kt index 5ded5814b0..838186a6dc 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSParameterGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSParameterGenerator.kt @@ -12,7 +12,7 @@ class TSParameterGenerator( fun generateClassProperties(): String = parameters.joinWithLn { - "${it.name}: __Parameter<${TSTypes.getTargetType(it)}>;" + "${it.name}: __Parameter<${TSTypes.getInstance().getTargetType(it)}>;" } fun generateInstantiations(): String = diff --git a/org.lflang/src/org/lflang/generator/ts/TSParameterPreambleGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSParameterPreambleGenerator.kt index c9fef820f0..305369832e 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSParameterPreambleGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSParameterPreambleGenerator.kt @@ -69,7 +69,7 @@ class TSParameterPreambleGenerator( mainParameters.joinWithLn { parameter -> """ - |let __CL${parameter.name}: ${TSTypes.getTargetType(parameter)} | undefined = undefined; + |let __CL${parameter.name}: ${TSTypes.getInstance().getTargetType(parameter)} | undefined = undefined; |if (__processedCLArgs.${parameter.name} !== undefined) { | if (__processedCLArgs.${parameter.name} !== null) { | __CL${parameter.name} = __processedCLArgs.${parameter.name}; @@ -114,7 +114,7 @@ class TSParameterPreambleGenerator( var customArgType: String? = null var customTypeLabel: String? = null - val paramType = TSTypes.getTargetType(parameter) + val paramType = TSTypes.getInstance().getTargetType(parameter) if (paramType == "string") { mainParameters.add(parameter) customArgType = "String"; diff --git a/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt index 4354ac1ea9..aca577aad0 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt @@ -358,7 +358,7 @@ class TSReactionGenerator( // Underscores are added to parameter names to prevent conflict with prologue val name = param.name - reactSignature.add("__$name: __Parameter<${TSTypes.getTargetType(param)}>") + reactSignature.add("__$name: __Parameter<${TSTypes.getInstance().getTargetType(param)}>") reactFunctArgs.add("this.$name") reactPrologue.add("let $name = __$name.get();") } @@ -367,7 +367,7 @@ class TSReactionGenerator( for (state in reactor.stateVars) { // Underscores are added to state names to prevent conflict with prologue val name = state.name - reactSignature.add("__$name: __State<${TSTypes.getTargetType(state)}>") + reactSignature.add("__$name: __State<${TSTypes.getInstance().getTargetType(state)}>") reactFunctArgs.add("this.$name") reactPrologue.add("let $name = __$name.get();") reactEpilogue.add( diff --git a/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt index 091da1d958..6ac2d8b28a 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt @@ -15,7 +15,7 @@ class TSStateGenerator( fun generateClassProperties(): String { val stateClassProperties = LinkedList() for (stateVar in stateVars) { - stateClassProperties.add("${stateVar.name}: __State<${TSTypes.getTargetType(stateVar)}>;"); + stateClassProperties.add("${stateVar.name}: __State<${TSTypes.getInstance().getTargetType(stateVar)}>;"); } return stateClassProperties.joinToString("\n") } @@ -25,7 +25,7 @@ class TSStateGenerator( // Next handle states. for (stateVar in stateVars) { if (ASTUtils.isInitialized(stateVar)) { - stateInstantiations.add("this.${stateVar.name} = new __State(${TSTypes.getTargetInitializer(stateVar)});"); + stateInstantiations.add("this.${stateVar.name} = new __State(${TSTypes.getInstance().getTargetInitializer(stateVar)});"); } else { stateInstantiations.add("this.${stateVar.name} = new __State(undefined);"); } diff --git a/org.lflang/src/org/lflang/generator/ts/TSTypes.java b/org.lflang/src/org/lflang/generator/ts/TSTypes.java new file mode 100644 index 0000000000..e89fff00d4 --- /dev/null +++ b/org.lflang/src/org/lflang/generator/ts/TSTypes.java @@ -0,0 +1,75 @@ +package org.lflang.generator.ts; + +import java.util.List; + +import org.lflang.ASTUtils; +import org.lflang.TimeValue; +import org.lflang.generator.TargetTypes; +import org.lflang.generator.UnsupportedGeneratorFeatureException; +import org.lflang.lf.StateVar; + +public class TSTypes implements TargetTypes { + + private static TSTypes INSTANCE = new TSTypes(); + + private TSTypes() { + + } + + @Override + public String getTargetType(StateVar s) { + var type = TargetTypes.super.getTargetType(s); + if (!ASTUtils.isInitialized(s)) { + return "%s | undefined".formatted(type); + } else { + return type; + } + } + + @Override + public boolean supportsGenerics() { + return true; + } + + @Override + public String getTargetTimeType() { + return "TimeValue"; + } + + @Override + public String getTargetTagType() { + return "TimeValue"; + } + + @Override + public String getTargetUndefinedType() { + return "Present"; + } + + public String getTargetTimeExpr(TimeValue value) { + if (value.unit != null) { + return "TimeValue.%s(%s)".formatted(value.unit.getCanonicalName(), value.time); + } else { + // The value must be zero. + return "TimeValue.zero()"; + } + } + + @Override + public String getTargetFixedSizeListType(String baseType, int size) { + throw new UnsupportedGeneratorFeatureException("TypeScript does not support fixed-size array types."); + } + + @Override + public String getTargetVariableSizeListType(String baseType) { + return "Array<%s>".formatted(baseType); // same as "$baseType[]" + } + + public String getVariableSizeListInitExpression(List contents, boolean withBraces) { + return "[" + String.join(", ", contents) + "]"; + } + + public static TSTypes getInstance() { + return INSTANCE; + } +} diff --git a/org.lflang/src/org/lflang/generator/ts/TSTypes.kt b/org.lflang/src/org/lflang/generator/ts/TSTypes.kt deleted file mode 100644 index 9b7b66f62f..0000000000 --- a/org.lflang/src/org/lflang/generator/ts/TSTypes.kt +++ /dev/null @@ -1,57 +0,0 @@ -package org.lflang.generator.ts - -import org.lflang.ASTUtils -import org.lflang.TimeValue -import org.lflang.generator.TargetTypes -import org.lflang.generator.UnsupportedGeneratorFeatureException -import org.lflang.joinWithCommas -import org.lflang.lf.StateVar - -object TSTypes : TargetTypes { - - override fun getTargetType(s: StateVar): String { - val type = super.getTargetType(s) - return if (!ASTUtils.isInitialized(s)) { - "$type | undefined" - } else { - type - } - } - - override fun supportsGenerics(): Boolean { - return true - } - - override fun getTargetTimeType(): String { - return "TimeValue" - } - - override fun getTargetTagType(): String { - return "TimeValue" - } - - override fun getTargetUndefinedType(): String { - return "Present" - } - - override fun getTargetTimeExpr(value: TimeValue): String { - return if (value.unit != null) { - "TimeValue.${value.unit.canonicalName}(${value.time})" - } else { - // The value must be zero. - "TimeValue.zero()" - } - } - - override fun getTargetFixedSizeListType(baseType: String?, size: Int): String { - throw UnsupportedGeneratorFeatureException("TypeScript does not support fixed-size array types.") - } - - override fun getTargetVariableSizeListType(baseType: String): String { - return "Array<$baseType>" // same as "$baseType[]" - } - - override fun getVariableSizeListInitExpression(contents: MutableList, withBraces: Boolean): String { - return contents.joinWithCommas("[", "]") - } -} diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 3f1fbef2fc..2ea579b753 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -69,6 +69,7 @@ import org.lflang.lf.ActionOrigin; import org.lflang.lf.Assignment; import org.lflang.lf.Attribute; +import org.lflang.lf.BracedListExpression; import org.lflang.lf.BuiltinTrigger; import org.lflang.lf.BuiltinTriggerRef; import org.lflang.lf.CodeExpr; @@ -172,6 +173,30 @@ public void checkAction(Action action) { public void checkInitializer(Initializer init) { if (init.isBraces() && target != Target.CPP) { error("Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); + } else if (init.isParens() && target.mandatesEqualsInitializers()) { + var message = "This syntax is deprecated in the " + target + + " target, use an equal sign instead of parentheses for assignment."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, Literals.INITIALIZER__PARENS); + } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { + var feature = init.isBraces() ? Literals.INITIALIZER__BRACES + : Literals.INITIALIZER__PARENS; + var message = "This syntax is deprecated, do not use parentheses or braces but an equal sign."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, feature); + } + } + + @Check(CheckType.FAST) + public void checkBracedExpression(BracedListExpression expr) { + if (!target.allowsBracedListExpressions()) { + var message = "Braced expression lists are not a valid expression for the " + target + + " target."; + error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); } } @@ -1596,9 +1621,12 @@ public void typeCheck(Initializer init, InferredType type, EStructuralFeature fe // list of times var exprs = init.getExprs(); if (exprs.isEmpty()) { - error("Expected exactly one time value.", feature); + error("Expected at least one time value.", feature); return; } + if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { + exprs = ((BracedListExpression) exprs.get(0)).getItems(); + } for (var component : exprs) { checkExpressionIsTime(component, feature); } @@ -1608,7 +1636,7 @@ public void typeCheck(Initializer init, InferredType type, EStructuralFeature fe } } - public void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { + private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { if (init == null) { return; } @@ -1620,7 +1648,7 @@ public void checkExpressionIsTime(Initializer init, EStructuralFeature feature) } } - public void checkExpressionIsTime(Expression value, EStructuralFeature feature) { + private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { if (value == null || value instanceof Time) { return; } diff --git a/test/C/src/ActionDelay.lf b/test/C/src/ActionDelay.lf index 6a4deddda6..86e510080a 100644 --- a/test/C/src/ActionDelay.lf +++ b/test/C/src/ActionDelay.lf @@ -4,7 +4,7 @@ target C reactor GeneratedDelay { input y_in: int output y_out: int - state y_state: int(0) + state y_state: int = 0 logical action act(100 msec) reaction(y_in) -> act {= diff --git a/test/C/src/ActionIsPresent.lf b/test/C/src/ActionIsPresent.lf index 4f8164bea8..b94108949e 100644 --- a/test/C/src/ActionIsPresent.lf +++ b/test/C/src/ActionIsPresent.lf @@ -1,9 +1,9 @@ // Tests the is_present variable for actions. target C -main reactor ActionIsPresent(offset: time(1 nsec), period: time(500 msec)) { +main reactor ActionIsPresent(offset: time = 1 nsec, period: time = 500 msec) { logical action a - state success: bool(false) + state success: bool = false reaction(startup, a) -> a {= if (!a->is_present) { diff --git a/test/C/src/After.lf b/test/C/src/After.lf index f354d9d7c8..d3663457e4 100644 --- a/test/C/src/After.lf +++ b/test/C/src/After.lf @@ -13,8 +13,8 @@ reactor foo { } reactor print { - state expected_time: time(10 msec) - state received: int(0) + state expected_time: time = 10 msec + state received: int = 0 input x: int reaction(x) {= diff --git a/test/C/src/AfterCycles.lf b/test/C/src/AfterCycles.lf index 3bc9622944..d7d621046b 100644 --- a/test/C/src/AfterCycles.lf +++ b/test/C/src/AfterCycles.lf @@ -16,7 +16,7 @@ reactor Work { } main reactor AfterCycles { - state count: int(0) + state count: int = 0 s = new Source() w0 = new Work() w1 = new Work() diff --git a/test/C/src/AfterOverlapped.lf b/test/C/src/AfterOverlapped.lf index 49d2c22bd2..0925dc5164 100644 --- a/test/C/src/AfterOverlapped.lf +++ b/test/C/src/AfterOverlapped.lf @@ -8,8 +8,8 @@ import Count from "lib/Count.lf" reactor Test { input c: int - state i: int(0) - state received: int(0) + state i: int = 0 + state received: int = 0 reaction(c) {= self->received++; diff --git a/test/C/src/AfterZero.lf b/test/C/src/AfterZero.lf index 85e1d2e000..378114c730 100644 --- a/test/C/src/AfterZero.lf +++ b/test/C/src/AfterZero.lf @@ -13,8 +13,8 @@ reactor foo { } reactor print { - state expected_time: time(0) - state received: int(0) + state expected_time: time = 0 + state received: int = 0 input x: int reaction(x) {= diff --git a/test/C/src/Alignment.lf b/test/C/src/Alignment.lf index 7420bd51c1..551b7c8342 100644 --- a/test/C/src/Alignment.lf +++ b/test/C/src/Alignment.lf @@ -7,7 +7,7 @@ target C { reactor Source { output out: int - state count: int(1) + state count: int = 1 timer t(0, 100 msec) reaction(t) -> out {= lf_set(out, self->count++); =} @@ -16,8 +16,8 @@ reactor Source { reactor Sieve { input in: int output out: bool - state primes: int*({= NULL =}) - state last_prime: int(0) + state primes: int* = {= NULL =} + state last_prime: int = 0 reaction(startup) {= // There are 1229 primes between 1 and 10,000. @@ -74,7 +74,7 @@ reactor Sieve { reactor Destination { input ok: bool input in: int - state last_invoked: tag_t({= NEVER_TAG_INITIALIZER =}) + state last_invoked: tag_t = {= NEVER_TAG_INITIALIZER =} reaction(ok, in) {= if (ok->is_present && in->is_present) { diff --git a/test/C/src/ArrayAsParameter.lf b/test/C/src/ArrayAsParameter.lf index d51778980e..a9df29cb03 100644 --- a/test/C/src/ArrayAsParameter.lf +++ b/test/C/src/ArrayAsParameter.lf @@ -3,9 +3,9 @@ // encode their own length. target C -reactor Source(sequence: int[](0, 1, 2), n_sequence: int(3)) { +reactor Source(sequence: int[] = {0, 1, 2}, n_sequence: int = 3) { output out: int - state count: int(0) + state count: int = 0 logical action next reaction(startup, next) -> out, next {= @@ -19,8 +19,8 @@ reactor Source(sequence: int[](0, 1, 2), n_sequence: int(3)) { reactor Print { input in: int - state count: int(1) - state received: int(0) + state count: int = 1 + state received: int = 0 reaction(in) {= self->received++; @@ -41,7 +41,7 @@ reactor Print { } main reactor ArrayAsParameter { - s = new Source(sequence = (1, 2, 3, 4), n_sequence = 4) + s = new Source(sequence = {1, 2, 3, 4}, n_sequence = 4) p = new Print() s.out -> p.in } diff --git a/test/C/src/ArrayAsType.lf b/test/C/src/ArrayAsType.lf index ad326c9288..c95e5bf385 100644 --- a/test/C/src/ArrayAsType.lf +++ b/test/C/src/ArrayAsType.lf @@ -13,7 +13,7 @@ reactor Source { =} } -reactor Print(scale: int(1)) { // The scale parameter is just for testing. +reactor Print(scale: int = 1) { // The scale parameter is just for testing. input in: int[3] reaction(in) {= diff --git a/test/C/src/ArrayFree.lf b/test/C/src/ArrayFree.lf index eea521aa72..11b31c123f 100644 --- a/test/C/src/ArrayFree.lf +++ b/test/C/src/ArrayFree.lf @@ -10,7 +10,7 @@ target C { import Source, Print from "ArrayPrint.lf" import Scale from "ArrayScale.lf" -reactor Free(scale: int(2), size: int(3)) { +reactor Free(scale: int = 2, size: int = 3) { mutable input in: int[] reaction(in) {= diff --git a/test/C/src/ArrayFreeMultiple.lf b/test/C/src/ArrayFreeMultiple.lf index b82bea9162..7b933ce518 100644 --- a/test/C/src/ArrayFreeMultiple.lf +++ b/test/C/src/ArrayFreeMultiple.lf @@ -12,7 +12,7 @@ import Print from "ArrayPrint.lf" reactor Source { output out: int[] - state c: int(0) + state c: int = 0 timer t(0, 1 sec) reaction(t) -> out {= @@ -26,7 +26,7 @@ reactor Source { =} } -reactor Free(scale: int(2)) { +reactor Free(scale: int = 2) { mutable input in: int[] reaction(in) {= diff --git a/test/C/src/ArrayPrint.lf b/test/C/src/ArrayPrint.lf index 33d75c6455..937bc51bea 100644 --- a/test/C/src/ArrayPrint.lf +++ b/test/C/src/ArrayPrint.lf @@ -6,9 +6,9 @@ target C { fast: true } -reactor Source(size: int(3)) { +reactor Source(size: int = 3) { output out: int[] - state count: int(0) + state count: int = 0 timer t(0, 1 sec) reaction(t) -> out {= @@ -26,9 +26,9 @@ reactor Source(size: int(3)) { } // The scale parameter is just for testing. -reactor Print(scale: int(1), size: int(3)) { +reactor Print(scale: int = 1, size: int = 3) { input in: int[] - state count: int(0) + state count: int = 0 reaction(in) {= bool failed = false; // For testing. diff --git a/test/C/src/ArrayScale.lf b/test/C/src/ArrayScale.lf index 257b0645c3..63edfc421c 100644 --- a/test/C/src/ArrayScale.lf +++ b/test/C/src/ArrayScale.lf @@ -9,7 +9,7 @@ target C { import Print, Source from "ArrayPrint.lf" -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { mutable input in: int[] output out: int[] diff --git a/test/C/src/CharLiteralInitializer.lf b/test/C/src/CharLiteralInitializer.lf index 9ee206efbf..319af0224c 100644 --- a/test/C/src/CharLiteralInitializer.lf +++ b/test/C/src/CharLiteralInitializer.lf @@ -2,7 +2,7 @@ target C main reactor CharLiteralInitializer { - state c: char('x') + state c: char = 'x' reaction(startup) {= if (self->c != 'x') { diff --git a/test/C/src/Composition.lf b/test/C/src/Composition.lf index c450bc0a64..7c024a9eba 100644 --- a/test/C/src/Composition.lf +++ b/test/C/src/Composition.lf @@ -5,10 +5,10 @@ target C { timeout: 10 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { output y: int timer t(1 sec, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -19,7 +19,7 @@ reactor Source(period: time(2 sec)) { reactor Test { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= (self->count)++; diff --git a/test/C/src/CompositionAfter.lf b/test/C/src/CompositionAfter.lf index 43f604de06..cb98ef7d7e 100644 --- a/test/C/src/CompositionAfter.lf +++ b/test/C/src/CompositionAfter.lf @@ -5,10 +5,10 @@ target C { timeout: 10 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { output y: int timer t(1 sec, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -18,7 +18,7 @@ reactor Source(period: time(2 sec)) { reactor Test { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= (self->count)++; @@ -30,7 +30,7 @@ reactor Test { =} } -main reactor CompositionAfter(delay: time(5 sec)) { +main reactor CompositionAfter(delay: time = 5 sec) { s = new Source() d = new Test() s.y -> d.x after delay diff --git a/test/C/src/CompositionInheritance.lf b/test/C/src/CompositionInheritance.lf index f57c1a688e..06221e9788 100644 --- a/test/C/src/CompositionInheritance.lf +++ b/test/C/src/CompositionInheritance.lf @@ -5,11 +5,11 @@ target C { timeout: 10 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { input foo: int output y: int timer t(1 sec, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= printf("Hello World. At time %lld, my count is: %d.\n", lf_time_logical_elapsed(), self->count); @@ -30,7 +30,7 @@ reactor SourceExtended extends Source { reactor Test { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= (self->count)++; diff --git a/test/C/src/CountSelf.lf b/test/C/src/CountSelf.lf index 1a7a6d1ff2..1ef27187ae 100644 --- a/test/C/src/CountSelf.lf +++ b/test/C/src/CountSelf.lf @@ -6,7 +6,7 @@ target C { import TestCount from "lib/TestCount.lf" -reactor CountSelf2(delay: time(100 msec)) { +reactor CountSelf2(delay: time = 100 msec) { output out: int logical action a: int diff --git a/test/C/src/Deadline.lf b/test/C/src/Deadline.lf index 62116353a5..c72dc16dcf 100644 --- a/test/C/src/Deadline.lf +++ b/test/C/src/Deadline.lf @@ -5,10 +5,10 @@ target C { timeout: 6 sec } -reactor Source(period: time(3 sec)) { +reactor Source(period: time = 3 sec) { output y: int timer t(0, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= if (2 * (self->count / 2) != self->count) { @@ -22,9 +22,9 @@ reactor Source(period: time(3 sec)) { =} } -reactor Destination(timeout: time(1 sec)) { +reactor Destination(timeout: time = 1 sec) { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= printf("Destination receives: %d\n", x->value); diff --git a/test/C/src/DeadlineHandledAbove.lf b/test/C/src/DeadlineHandledAbove.lf index d186bf9016..92d7e9dac8 100644 --- a/test/C/src/DeadlineHandledAbove.lf +++ b/test/C/src/DeadlineHandledAbove.lf @@ -2,7 +2,7 @@ // container reacts to that output. target C -reactor Deadline(threshold: time(100 msec)) { +reactor Deadline(threshold: time = 100 msec) { input x: int output deadline_violation: bool @@ -16,7 +16,7 @@ reactor Deadline(threshold: time(100 msec)) { } main reactor DeadlineHandledAbove { - state violation_detected: bool(false) + state violation_detected: bool = false d = new Deadline(threshold = 10 msec) reaction(startup) -> d.x {= diff --git a/test/C/src/DeadlineWithBanks.lf b/test/C/src/DeadlineWithBanks.lf index 266208cdac..18bc8c3682 100644 --- a/test/C/src/DeadlineWithBanks.lf +++ b/test/C/src/DeadlineWithBanks.lf @@ -11,7 +11,7 @@ target C { preamble {= volatile int global_cnt = 0; =} -reactor Bank(bank_index: int(0)) { +reactor Bank(bank_index: int = 0) { timer t(0, 100 msec) output out: int @@ -46,7 +46,7 @@ reactor Bank(bank_index: int(0)) { =} } -reactor Sink(dead: time(0)) { +reactor Sink(dead: time = 0) { input in: int reaction(in) {= =} deadline(dead) {= =} diff --git a/test/C/src/DeadlineZero.lf b/test/C/src/DeadlineZero.lf index 4e946bb63d..3ae49a9409 100644 --- a/test/C/src/DeadlineZero.lf +++ b/test/C/src/DeadlineZero.lf @@ -5,7 +5,7 @@ target C { reactor Detector { input trigger: int - state cnt: int(0) + state cnt: int = 0 reaction(trigger) {= printf("ERROR: failed to detect zero-duration deadline at iteration %d.\n", self->cnt); diff --git a/test/C/src/DelayArray.lf b/test/C/src/DelayArray.lf index 19e49e2464..72eb734888 100644 --- a/test/C/src/DelayArray.lf +++ b/test/C/src/DelayArray.lf @@ -4,7 +4,7 @@ target C { build-type: RelWithDebInfo } -reactor DelayPointer(delay: time(100 msec)) { +reactor DelayPointer(delay: time = 100 msec) { input in: int[] output out: int[] logical action a: int[] @@ -30,7 +30,7 @@ reactor Source { =} } -reactor Print(scale: int(1)) { // The scale parameter is just for testing. +reactor Print(scale: int = 1) { // The scale parameter is just for testing. input in: int[] reaction(in) {= diff --git a/test/C/src/DelayArrayWithAfter.lf b/test/C/src/DelayArrayWithAfter.lf index 42d7ff5275..c94be3b9a1 100644 --- a/test/C/src/DelayArrayWithAfter.lf +++ b/test/C/src/DelayArrayWithAfter.lf @@ -7,7 +7,7 @@ target C { reactor Source { output out: int[] - state iteration: int(1) + state iteration: int = 1 timer t(0, 1 sec) reaction(t) -> out {= @@ -23,10 +23,10 @@ reactor Source { =} } -reactor Print(scale: int(1)) { // The scale parameter is just for testing. +reactor Print(scale: int = 1) { // The scale parameter is just for testing. input in: int[] - state iteration: int(1) - state inputs_received: int(0) + state iteration: int = 1 + state inputs_received: int = 0 reaction(in) {= self->inputs_received++; diff --git a/test/C/src/DelayInt.lf b/test/C/src/DelayInt.lf index c7c27132bc..78ca793716 100644 --- a/test/C/src/DelayInt.lf +++ b/test/C/src/DelayInt.lf @@ -1,7 +1,7 @@ // This tests actions with payloads by delaying an input by a fixed amount. target C -reactor Delay(delay: time(100 msec)) { +reactor Delay(delay: time = 100 msec) { input in: int output out: int logical action a: int @@ -18,8 +18,8 @@ reactor Delay(delay: time(100 msec)) { reactor Test { input in: int - state start_time: time(0) - state received_value: bool(false) + state start_time: time = 0 + state received_value: bool = false reaction(startup) {= // Record the logical time at the start. diff --git a/test/C/src/DelayPointer.lf b/test/C/src/DelayPointer.lf index 87455d32ec..c6313c199d 100644 --- a/test/C/src/DelayPointer.lf +++ b/test/C/src/DelayPointer.lf @@ -1,7 +1,7 @@ // Test delaying a pointer type. target C -reactor DelayPointer2(delay: time(100 msec)) { +reactor DelayPointer2(delay: time = 100 msec) { input in: int* output out: int* logical action a: int* @@ -30,8 +30,8 @@ reactor Source { reactor Test { input in: int* - state start_time: time(0) - state received_value: bool(false) + state start_time: time = 0 + state received_value: bool = false reaction(startup) {= // Record the logical time at the start. diff --git a/test/C/src/DelayString.lf b/test/C/src/DelayString.lf index 1c77190581..b14e680d72 100644 --- a/test/C/src/DelayString.lf +++ b/test/C/src/DelayString.lf @@ -2,7 +2,7 @@ // freed. target C -reactor DelayString2(delay: time(100 msec)) { +reactor DelayString2(delay: time = 100 msec) { input in: string output out: string logical action a: string @@ -17,7 +17,7 @@ reactor DelayString2(delay: time(100 msec)) { reactor Test { input in: string - state start_time: time(0) + state start_time: time = 0 reaction(in) {= printf("Received: %s.\n", in->value); diff --git a/test/C/src/DelayStruct.lf b/test/C/src/DelayStruct.lf index a92acdc483..9cd201aa11 100644 --- a/test/C/src/DelayStruct.lf +++ b/test/C/src/DelayStruct.lf @@ -7,7 +7,7 @@ preamble {= #include "hello.h" =} -reactor DelayPointer(delay: time(100 msec)) { +reactor DelayPointer(delay: time = 100 msec) { input in: hello_t* output out: hello_t* logical action a: hello_t* @@ -38,7 +38,7 @@ reactor Source { =} } -reactor Print(expected: int(42)) { // expected parameter is for testing. +reactor Print(expected: int = 42) { // expected parameter is for testing. input in: hello_t* reaction(in) {= diff --git a/test/C/src/DelayStructWithAfter.lf b/test/C/src/DelayStructWithAfter.lf index 14f24aaf88..6693a437e6 100644 --- a/test/C/src/DelayStructWithAfter.lf +++ b/test/C/src/DelayStructWithAfter.lf @@ -20,7 +20,7 @@ reactor Source { =} } -reactor Print(expected: int(42)) { // expected parameter is for testing. +reactor Print(expected: int = 42) { // expected parameter is for testing. input in: hello_t* reaction(in) {= diff --git a/test/C/src/DelayStructWithAfterOverlapped.lf b/test/C/src/DelayStructWithAfterOverlapped.lf index 671b1ca4b3..8161022653 100644 --- a/test/C/src/DelayStructWithAfterOverlapped.lf +++ b/test/C/src/DelayStructWithAfterOverlapped.lf @@ -12,7 +12,7 @@ preamble {= reactor Source { output out: hello_t* timer t(0, 1 sec) - state s: int(0) + state s: int = 0 reaction(t) -> out {= self->s++; @@ -27,7 +27,7 @@ reactor Source { reactor Print { // expected parameter is for testing. input in: hello_t* - state s: int(0) + state s: int = 0 reaction(in) {= self->s++; diff --git a/test/C/src/DelayedAction.lf b/test/C/src/DelayedAction.lf index b37f6b9710..28a3e81ac5 100644 --- a/test/C/src/DelayedAction.lf +++ b/test/C/src/DelayedAction.lf @@ -6,7 +6,7 @@ target C { main reactor DelayedAction { timer t(0, 1 sec) logical action a - state count: int(0) + state count: int = 0 reaction(t) -> a {= lf_schedule(a, MSEC(100)); =} diff --git a/test/C/src/DoubleInvocation.lf b/test/C/src/DoubleInvocation.lf index 4b60f26fa8..973c8b18f6 100644 --- a/test/C/src/DoubleInvocation.lf +++ b/test/C/src/DoubleInvocation.lf @@ -13,7 +13,7 @@ target C { reactor Ball { output position: int output velocity: int - state p: int(200) + state p: int = 200 timer trigger(0, 1 sec) reaction(trigger) -> position, velocity {= @@ -26,7 +26,7 @@ reactor Ball { reactor Print { input velocity: int input position: int - state previous: int(-1) + state previous: int = -1 reaction(startup) {= printf("####### Print startup\n"); diff --git a/test/C/src/DoublePort.lf b/test/C/src/DoublePort.lf index 97d18f1761..c8bf9811f8 100644 --- a/test/C/src/DoublePort.lf +++ b/test/C/src/DoublePort.lf @@ -13,7 +13,7 @@ target C { import Count from "lib/Count.lf" reactor CountMicrostep { - state count: int(1) + state count: int = 1 output out: int logical action act: int timer t(0, 1 sec) diff --git a/test/C/src/DoubleReaction.lf b/test/C/src/DoubleReaction.lf index fb6aaaabaa..8da6210825 100644 --- a/test/C/src/DoubleReaction.lf +++ b/test/C/src/DoubleReaction.lf @@ -5,10 +5,10 @@ target C { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -19,7 +19,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int input w: int - state s: int(2) + state s: int = 2 reaction(x, w) {= int sum = 0; diff --git a/test/C/src/DoubleTrigger.lf b/test/C/src/DoubleTrigger.lf index 201ac35d7c..68ad603168 100644 --- a/test/C/src/DoubleTrigger.lf +++ b/test/C/src/DoubleTrigger.lf @@ -8,7 +8,7 @@ target C { main reactor DoubleTrigger { timer t1 timer t2 - state s: int(0) + state s: int = 0 reaction(t1, t2) {= self->s++; diff --git a/test/C/src/FloatLiteral.lf b/test/C/src/FloatLiteral.lf index 6d55f6e988..576a20d1ac 100644 --- a/test/C/src/FloatLiteral.lf +++ b/test/C/src/FloatLiteral.lf @@ -6,10 +6,10 @@ main reactor { #include =} - state N: double(6.0221409e+23) - state charge: double(-1.6021766E-19) - state minus_epsilon: double(-.01e0) - state expected: double(.964853323188E5) + state N: double = 6.0221409e+23 + state charge: double = -1.6021766E-19 + state minus_epsilon: double = -.01e0 + state expected: double = .964853323188E5 reaction(startup) {= double F = - self->N * self->charge; diff --git a/test/C/src/Gain.lf b/test/C/src/Gain.lf index 4096ec5973..7cac5eaae6 100644 --- a/test/C/src/Gain.lf +++ b/test/C/src/Gain.lf @@ -1,7 +1,7 @@ // Example in the Wiki. target C -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { input x: int output y: int @@ -10,7 +10,7 @@ reactor Scale(scale: int(2)) { reactor Test { input x: int - state received_value: bool(false) + state received_value: bool = false reaction(x) {= printf("Received %d.\n", x->value); diff --git a/test/C/src/GetMicroStep.lf b/test/C/src/GetMicroStep.lf index 4c7094c42e..0a428fd07d 100644 --- a/test/C/src/GetMicroStep.lf +++ b/test/C/src/GetMicroStep.lf @@ -2,7 +2,7 @@ target C main reactor GetMicroStep { - state s: int(1) + state s: int = 1 logical action l diff --git a/test/C/src/Hello.lf b/test/C/src/Hello.lf index f47b66ecc4..ea37265a23 100644 --- a/test/C/src/Hello.lf +++ b/test/C/src/Hello.lf @@ -8,9 +8,9 @@ target C { fast: true } -reactor Reschedule(period: time(2 sec), message: string("Hello C")) { - state count: int(0) - state previous_time: time(0) +reactor Reschedule(period: time = 2 sec, message: string = "Hello C") { + state count: int = 0 + state previous_time: time = 0 timer t(1 sec, period) logical action a @@ -43,8 +43,8 @@ reactor Reschedule(period: time(2 sec), message: string("Hello C")) { } reactor Inside( - period: time(1 sec), - message: string("Composite default message.") + period: time = 1 sec, + message: string = "Composite default message." ) { third_instance = new Reschedule(period = period, message = message) } diff --git a/test/C/src/HelloWorld.lf b/test/C/src/HelloWorld.lf index dc17cc0626..7de913c8ad 100644 --- a/test/C/src/HelloWorld.lf +++ b/test/C/src/HelloWorld.lf @@ -7,7 +7,7 @@ target C { } reactor HelloWorld2 { - state success: bool(false) + state success: bool = false reaction(startup) {= printf("Hello World.\n"); diff --git a/test/C/src/Hierarchy2.lf b/test/C/src/Hierarchy2.lf index 07fa4c73a0..0a4f20d4bc 100644 --- a/test/C/src/Hierarchy2.lf +++ b/test/C/src/Hierarchy2.lf @@ -14,7 +14,7 @@ reactor Source { reactor Count { output out: int timer t(0, 1 sec) - state i: int(0) + state i: int = 0 reaction(t) -> out {= (self->i)++; @@ -37,7 +37,7 @@ reactor Add { reactor Print { input in: int - state expected: int(2) + state expected: int = 2 reaction(in) {= printf("Received: %d.\n", in->value); diff --git a/test/C/src/IdentifierLength.lf b/test/C/src/IdentifierLength.lf index 69f1fcfd75..8fa38b96f0 100644 --- a/test/C/src/IdentifierLength.lf +++ b/test/C/src/IdentifierLength.lf @@ -5,10 +5,10 @@ target C { fast: true } -reactor A_Really_Long_Name_For_A_Source(period: time(2 sec)) { +reactor A_Really_Long_Name_For_A_Source(period: time = 2 sec) { output y: int timer t(1 sec, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -18,7 +18,7 @@ reactor A_Really_Long_Name_For_A_Source(period: time(2 sec)) { reactor Another_Really_Long_Name_For_A_Test_Class { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= (self->count)++; diff --git a/test/C/src/ImportComposition.lf b/test/C/src/ImportComposition.lf index 023c9736b2..22a1bfef87 100644 --- a/test/C/src/ImportComposition.lf +++ b/test/C/src/ImportComposition.lf @@ -6,7 +6,7 @@ import ImportedComposition from "lib/ImportedComposition.lf" main reactor ImportComposition { a = new ImportedComposition() - state received: bool(false) + state received: bool = false reaction(startup) -> a.x {= lf_set(a.x, 42); =} diff --git a/test/C/src/InheritanceAction.lf b/test/C/src/InheritanceAction.lf index 3941882f2c..680ffe2f75 100644 --- a/test/C/src/InheritanceAction.lf +++ b/test/C/src/InheritanceAction.lf @@ -17,7 +17,7 @@ reactor SourceExtended extends Source { reactor Test { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= (self->count)++; diff --git a/test/C/src/ManualDelayedReaction.lf b/test/C/src/ManualDelayedReaction.lf index 1402e00c62..72c57105ce 100644 --- a/test/C/src/ManualDelayedReaction.lf +++ b/test/C/src/ManualDelayedReaction.lf @@ -9,7 +9,7 @@ target C { reactor GeneratedDelay { input y_in: int output y_out: int - state y_state: int(0) + state y_state: int = 0 physical action act(0 msec) // TODO: delay in act or the schedule call? diff --git a/test/C/src/Methods.lf b/test/C/src/Methods.lf index 02f1f68c8e..edbdd2f7f6 100644 --- a/test/C/src/Methods.lf +++ b/test/C/src/Methods.lf @@ -1,7 +1,7 @@ target C main reactor { - state foo: int(2) + state foo: int = 2 method getFoo(): int {= return self->foo; =} diff --git a/test/C/src/MethodsRecursive.lf b/test/C/src/MethodsRecursive.lf index 73588e5115..5465e0c92c 100644 --- a/test/C/src/MethodsRecursive.lf +++ b/test/C/src/MethodsRecursive.lf @@ -2,7 +2,7 @@ target C main reactor { - state foo: int(2) + state foo: int = 2 method fib(n: int): int {= // Return the n-th Fibonacci number. if (n <= 1) return 1; diff --git a/test/C/src/MethodsSameName.lf b/test/C/src/MethodsSameName.lf index d2978ba4db..b274d153c8 100644 --- a/test/C/src/MethodsSameName.lf +++ b/test/C/src/MethodsSameName.lf @@ -2,7 +2,7 @@ target C reactor Foo { - state foo: int(2) + state foo: int = 2 method add(x: int) {= self->foo += x; =} @@ -16,7 +16,7 @@ reactor Foo { } main reactor { - state foo: int(2) + state foo: int = 2 a = new Foo() diff --git a/test/C/src/MovingAverage.lf b/test/C/src/MovingAverage.lf index cd135dbd26..a8309aa9d3 100644 --- a/test/C/src/MovingAverage.lf +++ b/test/C/src/MovingAverage.lf @@ -10,7 +10,7 @@ import TestDouble from "lib/Test.lf" reactor MASource { output out: double - state count: int(0) + state count: int = 0 timer clock(0, 200 msec) reaction(clock) -> out {= @@ -20,8 +20,8 @@ reactor MASource { } reactor MovingAverageImpl { - state delay_line: double[](0.0, 0.0, 0.0) - state index: int(0) + state delay_line: double[] = {0.0, 0.0, 0.0} + state index: int = 0 input in: double output out: double @@ -47,7 +47,7 @@ reactor MovingAverageImpl { main reactor MovingAverage { s = new MASource() m = new MovingAverageImpl() - p = new TestDouble(expected = (0.0, 0.25, 0.75, 1.5, 2.5, 3.5)) + p = new TestDouble(expected = {0.0, 0.25, 0.75, 1.5, 2.5, 3.5}) s.out -> m.in m.out -> p.in } diff --git a/test/C/src/MultipleContained.lf b/test/C/src/MultipleContained.lf index f3058c9dd4..540052ba87 100644 --- a/test/C/src/MultipleContained.lf +++ b/test/C/src/MultipleContained.lf @@ -6,7 +6,7 @@ reactor Contained { output trigger: int input in1: int input in2: int - state count: int(0) + state count: int = 0 reaction(startup) -> trigger {= lf_set(trigger, 42); =} diff --git a/test/C/src/MultipleOutputs.lf b/test/C/src/MultipleOutputs.lf index 8db9e5e6f9..37b5ddba9f 100644 --- a/test/C/src/MultipleOutputs.lf +++ b/test/C/src/MultipleOutputs.lf @@ -20,7 +20,7 @@ reactor C { main reactor { c = new C() - state triggered: bool(true) + state triggered: bool = true reaction(c.z) {= lf_print("c.z = %d", c.z->value); diff --git a/test/C/src/NativeListsAndTimes.lf b/test/C/src/NativeListsAndTimes.lf index eb3658f8a4..a1d09beb6c 100644 --- a/test/C/src/NativeListsAndTimes.lf +++ b/test/C/src/NativeListsAndTimes.lf @@ -2,22 +2,24 @@ target C // This test passes if it is successfully compiled into valid target code. main reactor( - x: int(0), - y: time(0), // Units are missing but not required - z(1 msec), // Type is missing but not required - p: int[](1, 2, 3, 4), // List of integers - q: interval_t[](1 msec, 2 msec, 3 msec), // list of time values - g: time[](1 msec, 2 msec) // List of time values + x: int = 0, + y: time = 0, // Units are missing but not required + z = 1 msec, // Type is missing but not required + p: int[] = {1, 2, 3, 4}, // List of integers + q: interval_t[] = {1 msec, 2 msec, 3 msec}, // list of time values + g: time[] = {1 msec, 2 msec} // List of time values ) { - state s: time(y) // Reference to explicitly typed time parameter - state t: time(z) // Reference to implicitly typed time parameter + state s: time = y // Reference to explicitly typed time parameter + state t: time = z // Reference to implicitly typed time parameter state v: bool // Uninitialized boolean state variable state w: time // Uninitialized time state variable timer tick(0) // Units missing but not required timer tock(1 sec) // Implicit type time timer toe(z) // Implicit type time - state baz(p) // Implicit type int[] - state period(z) // Implicit type time + state baz = p // Implicit type int[] + state period = z // Implicit type time + + state empty_list: int[] reaction(tick) {= // Target code diff --git a/test/C/src/NestedTriggeredReactions.lf b/test/C/src/NestedTriggeredReactions.lf index 6cc5f911b1..df52d36a14 100644 --- a/test/C/src/NestedTriggeredReactions.lf +++ b/test/C/src/NestedTriggeredReactions.lf @@ -3,7 +3,7 @@ target C reactor Container { input in: bool - state triggered: bool(false) + state triggered: bool = false contained = new Contained() @@ -21,7 +21,7 @@ reactor Container { reactor Contained { input in: bool - state triggered: bool(false) + state triggered: bool = false reaction(in) {= self->triggered = true; =} diff --git a/test/C/src/ParameterHierarchy.lf b/test/C/src/ParameterHierarchy.lf index 433948bd2b..825f9f5a60 100644 --- a/test/C/src/ParameterHierarchy.lf +++ b/test/C/src/ParameterHierarchy.lf @@ -1,24 +1,24 @@ // Test that parameter values pass down a deep hierarchy. target C -reactor Deep(p: int(0)) { +reactor Deep(p0: int = 0) { reaction(startup) {= - if (self->p != 42) { - lf_print_error_and_exit("Parameter value is %d. Should have been 42."); + if (self->p0 != 42) { + lf_print_error_and_exit("Parameter value is %d. Should have been 42.", self->p0); } else { lf_print("Success."); } =} } -reactor Intermediate(p: int(10)) { - a = new Deep(p = p) +reactor Intermediate(p1: int = 10) { + a0 = new Deep(p0 = p1) } -reactor Another(p: int(20)) { - a = new Intermediate(p = p) +reactor Another(p2: int = 20) { + a1 = new Intermediate(p1 = p2) } main reactor ParameterHierarchy { - a = new Intermediate(p = 42) + a2 = new Another(p2 = 42) } diff --git a/test/C/src/ParameterizedState.lf b/test/C/src/ParameterizedState.lf index 1965fa1929..3d92345ca9 100644 --- a/test/C/src/ParameterizedState.lf +++ b/test/C/src/ParameterizedState.lf @@ -1,7 +1,7 @@ target C -reactor Foo(bar: int(42)) { - state baz(bar) +reactor Foo(bar: int = 42) { + state baz = bar reaction(startup) {= printf("Baz: %d\n", self->baz); =} } diff --git a/test/C/src/PeriodicDesugared.lf b/test/C/src/PeriodicDesugared.lf index 6d9f8a8ab4..46eb97db9c 100644 --- a/test/C/src/PeriodicDesugared.lf +++ b/test/C/src/PeriodicDesugared.lf @@ -3,7 +3,7 @@ target C { timeout: 1 sec } -main reactor(offset: time(0), period: time(500 msec)) { +main reactor(offset: time = 0, period: time = 500 msec) { logical action init(offset) logical action recur(period) diff --git a/test/C/src/PingPong.lf b/test/C/src/PingPong.lf index 5ce6caaaaa..2f1699a51d 100644 --- a/test/C/src/PingPong.lf +++ b/test/C/src/PingPong.lf @@ -25,10 +25,10 @@ target C { fast: true } -reactor Ping(count: int(10)) { +reactor Ping(count: int = 10) { input receive: int output send: int - state pingsLeft: int(count) + state pingsLeft: int = count logical action serve reaction(startup, serve) -> send {= lf_set(send, self->pingsLeft--); =} @@ -42,10 +42,10 @@ reactor Ping(count: int(10)) { =} } -reactor Pong(expected: int(10)) { +reactor Pong(expected: int = 10) { input receive: int output send: int - state count: int(0) + state count: int = 0 reaction(receive) -> send {= self->count++; diff --git a/test/C/src/ReadOutputOfContainedReactor.lf b/test/C/src/ReadOutputOfContainedReactor.lf index 6b94d4a44b..ce2129069b 100644 --- a/test/C/src/ReadOutputOfContainedReactor.lf +++ b/test/C/src/ReadOutputOfContainedReactor.lf @@ -10,7 +10,7 @@ reactor Contained { main reactor ReadOutputOfContainedReactor { c = new Contained() - state count: int(0) + state count: int = 0 reaction(startup) c.out {= printf("Startup reaction reading output of contained reactor: %d.\n", c.out->value); diff --git a/test/C/src/ScheduleLogicalAction.lf b/test/C/src/ScheduleLogicalAction.lf index e3c898ebb5..762f8c6f52 100644 --- a/test/C/src/ScheduleLogicalAction.lf +++ b/test/C/src/ScheduleLogicalAction.lf @@ -20,7 +20,7 @@ reactor foo { } reactor print { - state expected_time: time(0) + state expected_time: time = 0 input x: int reaction(x) {= diff --git a/test/C/src/SelfLoop.lf b/test/C/src/SelfLoop.lf index 68ca61278e..855be46792 100644 --- a/test/C/src/SelfLoop.lf +++ b/test/C/src/SelfLoop.lf @@ -7,7 +7,7 @@ reactor Self { input x: int output y: int logical action a: int - state expected: int(43) + state expected: int = 43 reaction(a) -> y {= printf("a = %d\n", a->value); diff --git a/test/C/src/SendingInside.lf b/test/C/src/SendingInside.lf index fcb495305a..b1e8f25f93 100644 --- a/test/C/src/SendingInside.lf +++ b/test/C/src/SendingInside.lf @@ -7,7 +7,7 @@ target C { reactor Printer { input x: int - state count: int(1) + state count: int = 1 reaction(x) {= printf("Inside reactor received: %d\n", x->value); @@ -20,7 +20,7 @@ reactor Printer { } main reactor SendingInside { - state count: int(0) + state count: int = 0 timer t(0, 1 sec) p = new Printer() diff --git a/test/C/src/SendsPointerTest.lf b/test/C/src/SendsPointerTest.lf index c7336ff91f..1f17bd1388 100644 --- a/test/C/src/SendsPointerTest.lf +++ b/test/C/src/SendsPointerTest.lf @@ -13,7 +13,7 @@ reactor SendsPointer { =} } -reactor Print(expected: int(42)) { // expected parameter is for testing. +reactor Print(expected: int = 42) { // expected parameter is for testing. input in: int_pointer reaction(in) {= diff --git a/test/C/src/SetArray.lf b/test/C/src/SetArray.lf index 605eed4081..f30457f9f8 100644 --- a/test/C/src/SetArray.lf +++ b/test/C/src/SetArray.lf @@ -17,7 +17,7 @@ reactor Source { =} } -reactor Print(scale: int(1)) { // The scale parameter is just for testing. +reactor Print(scale: int = 1) { // The scale parameter is just for testing. input in: int[] reaction(in) {= diff --git a/test/C/src/SetToken.lf b/test/C/src/SetToken.lf index c2295dbaa0..b9af4bff20 100644 --- a/test/C/src/SetToken.lf +++ b/test/C/src/SetToken.lf @@ -10,7 +10,7 @@ reactor Source { reaction(a) -> out {= lf_set_token(out, a->token); =} } -reactor Print(expected: int(42)) { // expected parameter is for testing. +reactor Print(expected: int = 42) { // expected parameter is for testing. input in: int* reaction(in) {= diff --git a/test/C/src/SimpleDeadline.lf b/test/C/src/SimpleDeadline.lf index a59a6728e9..3e2d786eec 100644 --- a/test/C/src/SimpleDeadline.lf +++ b/test/C/src/SimpleDeadline.lf @@ -3,7 +3,7 @@ // violation. target C -reactor Deadline(threshold: time(100 msec)) { +reactor Deadline(threshold: time = 100 msec) { input x: int output deadlineViolation: bool diff --git a/test/C/src/SlowingClock.lf b/test/C/src/SlowingClock.lf index 6655e87014..d4a1e1d5f4 100644 --- a/test/C/src/SlowingClock.lf +++ b/test/C/src/SlowingClock.lf @@ -11,8 +11,8 @@ target C { main reactor SlowingClock { logical action a(100 msec) - state interval: time(100 msec) - state expected_time: time(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec reaction(startup) -> a {= lf_schedule(a, 0); =} diff --git a/test/C/src/SlowingClockPhysical.lf b/test/C/src/SlowingClockPhysical.lf index b3255428c2..0e82730112 100644 --- a/test/C/src/SlowingClockPhysical.lf +++ b/test/C/src/SlowingClockPhysical.lf @@ -11,8 +11,8 @@ target C { main reactor SlowingClockPhysical { physical action a(100 msec) - state interval: time(100 msec) - state expected_time: time(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec reaction(startup) -> a {= self->expected_time = MSEC(100); diff --git a/test/C/src/Starvation.lf b/test/C/src/Starvation.lf index 38f2a247b6..a1c1167850 100644 --- a/test/C/src/Starvation.lf +++ b/test/C/src/Starvation.lf @@ -6,10 +6,10 @@ */ target C -reactor SuperDenseSender(number_of_iterations: int(10)) { +reactor SuperDenseSender(number_of_iterations: int = 10) { logical action loop output out: int - state iterator: int(0) + state iterator: int = 0 reaction(startup, loop) -> out {= if (self->iterator < self->number_of_iterations) { @@ -34,7 +34,7 @@ reactor SuperDenseSender(number_of_iterations: int(10)) { =} } -reactor SuperDenseReceiver(number_of_iterations: int(10)) { +reactor SuperDenseReceiver(number_of_iterations: int = 10) { input in: int reaction(in) {= diff --git a/test/C/src/Stop.lf b/test/C/src/Stop.lf index fcfa407d35..1731bced42 100644 --- a/test/C/src/Stop.lf +++ b/test/C/src/Stop.lf @@ -11,7 +11,7 @@ import Sender from "lib/LoopedActionSender.lf" reactor Consumer { input in: int - state reaction_invoked_correctly: bool(false) + state reaction_invoked_correctly: bool = false reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/StopZero.lf b/test/C/src/StopZero.lf index 316cce5c6c..e845c6de48 100644 --- a/test/C/src/StopZero.lf +++ b/test/C/src/StopZero.lf @@ -8,7 +8,7 @@ target C reactor Sender { output out: int - state reaction_invoked_correctly: bool(false) + state reaction_invoked_correctly: bool = false timer t(0, 1 usec) logical action act diff --git a/test/C/src/Stride.lf b/test/C/src/Stride.lf index 137855990d..62b9077878 100644 --- a/test/C/src/Stride.lf +++ b/test/C/src/Stride.lf @@ -5,8 +5,8 @@ target C { fast: true } -reactor Count(stride: int(1)) { - state count: int(1) +reactor Count(stride: int = 1) { + state count: int = 1 output y: int timer t(0, 100 msec) @@ -18,7 +18,7 @@ reactor Count(stride: int(1)) { reactor Display { input x: int - state expected: int(1) // for testing. + state expected: int = 1 // for testing. reaction(x) {= printf("Received: %d.\n", x->value); diff --git a/test/C/src/StructAsState.lf b/test/C/src/StructAsState.lf index b57b15d07b..59ae495853 100644 --- a/test/C/src/StructAsState.lf +++ b/test/C/src/StructAsState.lf @@ -10,7 +10,7 @@ main reactor StructAsState { } hello_t; =} // Notice that target code delimiters are no longer necessary. - state s: hello_t("Earth", 42) + state s: hello_t = {"Earth", 42} reaction(startup) {= printf("State s.name=\"%s\", value=%d.\n", self->s.name, self->s.value); diff --git a/test/C/src/StructAsType.lf b/test/C/src/StructAsType.lf index 9e43173110..8674685530 100644 --- a/test/C/src/StructAsType.lf +++ b/test/C/src/StructAsType.lf @@ -23,7 +23,7 @@ reactor Source { =} } -reactor Print(expected: int(42)) { // expected parameter is for testing. +reactor Print(expected: int = 42) { // expected parameter is for testing. input in: hello_t reaction(in) {= diff --git a/test/C/src/StructAsTypeDirect.lf b/test/C/src/StructAsTypeDirect.lf index f9d85799e9..29472f057b 100644 --- a/test/C/src/StructAsTypeDirect.lf +++ b/test/C/src/StructAsTypeDirect.lf @@ -17,7 +17,7 @@ reactor Source { =} } -reactor Print(expected: int(42)) { // expected parameter is for testing. +reactor Print(expected: int = 42) { // expected parameter is for testing. input in: hello_t reaction(in) {= diff --git a/test/C/src/StructParallel.lf b/test/C/src/StructParallel.lf index 0d3e78cc3e..3c8e61a3a2 100644 --- a/test/C/src/StructParallel.lf +++ b/test/C/src/StructParallel.lf @@ -11,9 +11,9 @@ preamble {= #include "hello.h" =} -reactor Check(expected: int(42)) { +reactor Check(expected: int = 42) { input in: hello_t* - state invoked: bool(false) + state invoked: bool = false reaction(in) {= printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); @@ -32,7 +32,7 @@ reactor Check(expected: int(42)) { =} } -reactor Print(scale: int(2)) { +reactor Print(scale: int = 2) { // Mutable keyword indicates that this reactor wants a writable copy of the // input. mutable input in: hello_t* diff --git a/test/C/src/StructPrint.lf b/test/C/src/StructPrint.lf index adaf7fbf24..6af0d60c4f 100644 --- a/test/C/src/StructPrint.lf +++ b/test/C/src/StructPrint.lf @@ -20,7 +20,7 @@ reactor Print { =} } -reactor Check(expected: int(42)) { // expected parameter is for testing. +reactor Check(expected: int = 42) { // expected parameter is for testing. input in: hello_t* reaction(in) {= diff --git a/test/C/src/StructScale.lf b/test/C/src/StructScale.lf index 076d0e7f3f..3b92bab002 100644 --- a/test/C/src/StructScale.lf +++ b/test/C/src/StructScale.lf @@ -22,9 +22,9 @@ reactor Source { =} } -reactor TestInput(expected: int(42)) { // expected parameter is for testing. +reactor TestInput(expected: int = 42) { // expected parameter is for testing. input in: hello_t* - state invoked: bool(false) + state invoked: bool = false reaction(in) {= printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); @@ -43,7 +43,7 @@ reactor TestInput(expected: int(42)) { // expected parameter is for testing. =} } -reactor Print(scale: int(2)) { +reactor Print(scale: int = 2) { // Mutable keyword indicates that this reactor wants a writable copy of the // input. mutable input in: hello_t* diff --git a/test/C/src/SubclassesAndStartup.lf b/test/C/src/SubclassesAndStartup.lf index a8001a907d..2dbc1f688f 100644 --- a/test/C/src/SubclassesAndStartup.lf +++ b/test/C/src/SubclassesAndStartup.lf @@ -1,7 +1,7 @@ target C reactor Super { - state count: int(0) + state count: int = 0 reaction(startup) {= printf("%s(Super) started\n", self->name); @@ -16,7 +16,7 @@ reactor Super { =} } -reactor SubA(name: string("SubA")) extends Super { +reactor SubA(name: string = "SubA") extends Super { reaction(startup) {= printf("%s started\n", self->name); if (self->count == 0) { @@ -26,7 +26,7 @@ reactor SubA(name: string("SubA")) extends Super { =} } -reactor SubB(name: string("SubB")) extends Super { +reactor SubB(name: string = "SubB") extends Super { reaction(startup) {= printf("%s started\n", self->name); if (self->count == 0) { diff --git a/test/C/src/TimeLimit.lf b/test/C/src/TimeLimit.lf index 2497296efd..ae178d53b5 100644 --- a/test/C/src/TimeLimit.lf +++ b/test/C/src/TimeLimit.lf @@ -5,10 +5,10 @@ target C { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -19,7 +19,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int - state s: int(1) + state s: int = 1 reaction(x) {= // printf("%d\n", x->value); @@ -39,7 +39,7 @@ reactor Destination { =} } -main reactor TimeLimit(period: time(1 sec)) { +main reactor TimeLimit(period: time = 1 sec) { timer stop(10 sec) c = new Clock(period = period) d = new Destination() diff --git a/test/C/src/TimeState.lf b/test/C/src/TimeState.lf index 790679ccda..cb0a9627f3 100644 --- a/test/C/src/TimeState.lf +++ b/test/C/src/TimeState.lf @@ -1,7 +1,7 @@ target C -reactor Foo(bar: int(42)) { - state baz: time(500 msec) +reactor Foo(bar: int = 42) { + state baz: time = 500 msec reaction(startup) {= printf("Baz: %lld\n", self->baz); =} } diff --git a/test/C/src/Timeout.lf b/test/C/src/Timeout.lf index e0bb841b3e..cb13eafba4 100644 --- a/test/C/src/Timeout.lf +++ b/test/C/src/Timeout.lf @@ -11,7 +11,7 @@ import Sender from "lib/LoopedActionSender.lf" reactor Consumer { input in: int - state success: bool(false) + state success: bool = false reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/TimeoutZero.lf b/test/C/src/TimeoutZero.lf index 36a65d6031..2b146bb57c 100644 --- a/test/C/src/TimeoutZero.lf +++ b/test/C/src/TimeoutZero.lf @@ -12,7 +12,7 @@ import Sender from "lib/LoopedActionSender.lf" reactor Consumer { input in: int - state success: bool(false) + state success: bool = false reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/ToReactionNested.lf b/test/C/src/ToReactionNested.lf index 4f89c20e9c..11b3577c84 100644 --- a/test/C/src/ToReactionNested.lf +++ b/test/C/src/ToReactionNested.lf @@ -12,8 +12,8 @@ reactor CountContainer { } main reactor { - state count: int(1) - state received: bool(false) + state count: int = 1 + state received: bool = false s = new CountContainer() diff --git a/test/C/src/TriggerDownstreamOnlyIfPresent2.lf b/test/C/src/TriggerDownstreamOnlyIfPresent2.lf index 544d269242..bc62b214e9 100644 --- a/test/C/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/C/src/TriggerDownstreamOnlyIfPresent2.lf @@ -9,7 +9,7 @@ target C { reactor Source { output[2] out: int - state count: int(0) + state count: int = 0 timer t(0, 200 msec) reaction(t) -> out {= diff --git a/test/C/src/UnconnectedInput.lf b/test/C/src/UnconnectedInput.lf index f41524fa01..21e8cc5a69 100644 --- a/test/C/src/UnconnectedInput.lf +++ b/test/C/src/UnconnectedInput.lf @@ -7,7 +7,7 @@ target C { reactor Source { output out: int timer t(0, 1 sec) - state s: int(1) + state s: int = 1 reaction(t) -> out {= lf_set(out, self->s++); =} } @@ -27,7 +27,7 @@ reactor Add { reactor Print { input in: int - state expected: int(1) + state expected: int = 1 reaction(in) {= printf("Received: %d.\n", in->value); diff --git a/test/C/src/arduino/DigitalReadSerial.lf b/test/C/src/arduino/DigitalReadSerial.lf index febc640eb3..d79f86ad9b 100644 --- a/test/C/src/arduino/DigitalReadSerial.lf +++ b/test/C/src/arduino/DigitalReadSerial.lf @@ -11,7 +11,7 @@ target C { main reactor DigitalReadSerial { timer t1(0, 1 msec) - state pushButton: int(2) + state pushButton: int = 2 reaction(startup) {= pinMode(self->pushButton, INPUT); =} diff --git a/test/C/src/arduino/Fade.lf b/test/C/src/arduino/Fade.lf index 0408fb5a1a..d23aabd646 100644 --- a/test/C/src/arduino/Fade.lf +++ b/test/C/src/arduino/Fade.lf @@ -14,9 +14,9 @@ target C { main reactor Fade { timer t1(0, 30 msec) - state led: int(9) - state brightness: int(9) - state fadeAmount: int(5) + state led: int = 9 + state brightness: int = 9 + state fadeAmount: int = 5 reaction(startup) {= pinMode(self->led, OUTPUT); =} diff --git a/test/C/src/concurrent/AsyncCallback.lf b/test/C/src/concurrent/AsyncCallback.lf index 90c300a8b2..ec2beae766 100644 --- a/test/C/src/concurrent/AsyncCallback.lf +++ b/test/C/src/concurrent/AsyncCallback.lf @@ -33,12 +33,12 @@ main reactor AsyncCallback { lf_thread_t threadId; =} timer t(0, 200 msec) - state thread_id: lf_thread_t(0) - state expected_time: time(100 msec) - state toggle: bool(false) + state thread_id: lf_thread_t = 0 + state expected_time: time = 100 msec + state toggle: bool = false physical action a(100 msec): int - state i: int(0) + state i: int = 0 reaction(t) -> a {= // start new thread, provide callback diff --git a/test/C/src/concurrent/AsyncCallbackDrop.lf b/test/C/src/concurrent/AsyncCallbackDrop.lf index 17cb113a99..f123bcdbdf 100644 --- a/test/C/src/concurrent/AsyncCallbackDrop.lf +++ b/test/C/src/concurrent/AsyncCallbackDrop.lf @@ -28,12 +28,12 @@ main reactor { lf_thread_t threadId; =} timer t(0, 200 msec) - state thread_id: lf_thread_t(0) - state expected_time: time(100 msec) - state toggle: bool(false) + state thread_id: lf_thread_t = 0 + state expected_time: time = 100 msec + state toggle: bool = false physical action a(100 msec, 100 msec, "drop"): int - state i: int(0) + state i: int = 0 reaction(t) -> a {= // start new thread, provide callback diff --git a/test/C/src/concurrent/AsyncCallbackReplace.lf b/test/C/src/concurrent/AsyncCallbackReplace.lf index 49dc3e75e9..b7afeb2363 100644 --- a/test/C/src/concurrent/AsyncCallbackReplace.lf +++ b/test/C/src/concurrent/AsyncCallbackReplace.lf @@ -28,12 +28,12 @@ main reactor { lf_thread_t threadId; =} timer t(0, 200 msec) - state thread_id: lf_thread_t(0) - state expected_time: time(100 msec) - state toggle: bool(false) + state thread_id: lf_thread_t = 0 + state expected_time: time = 100 msec + state toggle: bool = false physical action a(100 msec, 100 msec, "replace"): int - state i: int(0) + state i: int = 0 reaction(t) -> a {= // start new thread, provide callback diff --git a/test/C/src/concurrent/CompositionThreaded.lf b/test/C/src/concurrent/CompositionThreaded.lf index decf56d687..cf0bafeb82 100644 --- a/test/C/src/concurrent/CompositionThreaded.lf +++ b/test/C/src/concurrent/CompositionThreaded.lf @@ -5,10 +5,10 @@ target C { timeout: 10 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { output y: int timer t(1 sec, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -18,7 +18,7 @@ reactor Source(period: time(2 sec)) { reactor Test { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= (self->count)++; diff --git a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf index 87359286ed..545206de91 100644 --- a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -2,7 +2,7 @@ // container reacts to that output. target C -reactor Deadline(threshold: time(100 msec)) { +reactor Deadline(threshold: time = 100 msec) { input x: int output deadline_violation: bool @@ -16,7 +16,7 @@ reactor Deadline(threshold: time(100 msec)) { } main reactor { - state violation_detected: bool(false) + state violation_detected: bool = false d = new Deadline(threshold = 10 msec) reaction(startup) -> d.x {= diff --git a/test/C/src/concurrent/DeadlineThreaded.lf b/test/C/src/concurrent/DeadlineThreaded.lf index fccb60001b..ac765fe6f7 100644 --- a/test/C/src/concurrent/DeadlineThreaded.lf +++ b/test/C/src/concurrent/DeadlineThreaded.lf @@ -5,10 +5,10 @@ target C { timeout: 6 sec } -reactor Source(period: time(3000 msec)) { +reactor Source(period: time = 3000 msec) { output y: int timer t(0, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= if (2 * (self->count / 2) != self->count) { @@ -22,9 +22,9 @@ reactor Source(period: time(3000 msec)) { =} } -reactor Destination(timeout: time(1 sec)) { +reactor Destination(timeout: time = 1 sec) { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= printf("Destination receives: %d\n", x->value); diff --git a/test/C/src/concurrent/DelayIntThreaded.lf b/test/C/src/concurrent/DelayIntThreaded.lf index 5c2c983508..449b17eb60 100644 --- a/test/C/src/concurrent/DelayIntThreaded.lf +++ b/test/C/src/concurrent/DelayIntThreaded.lf @@ -1,7 +1,7 @@ // This tests actions with payloads by delaying an input by a fixed amount. target C -reactor Delay(delay: time(100 msec)) { +reactor Delay(delay: time = 100 msec) { input in: int output out: int logical action a: int @@ -16,8 +16,8 @@ reactor Delay(delay: time(100 msec)) { reactor Test { input in: int - state start_time: time(0) - state received_value: bool(false) + state start_time: time = 0 + state received_value: bool = false reaction(startup) {= // Record the logical time at the start. diff --git a/test/C/src/concurrent/DoubleReactionThreaded.lf b/test/C/src/concurrent/DoubleReactionThreaded.lf index 66885ab7a0..ba6c38ca19 100644 --- a/test/C/src/concurrent/DoubleReactionThreaded.lf +++ b/test/C/src/concurrent/DoubleReactionThreaded.lf @@ -5,10 +5,10 @@ target C { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -19,7 +19,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int input w: int - state s: int(2) + state s: int = 2 reaction(x, w) {= int sum = 0; diff --git a/test/C/src/concurrent/GainThreaded.lf b/test/C/src/concurrent/GainThreaded.lf index b59d2b00fb..d9d6ec7673 100644 --- a/test/C/src/concurrent/GainThreaded.lf +++ b/test/C/src/concurrent/GainThreaded.lf @@ -1,7 +1,7 @@ // Example in the Wiki. target C -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { input x: int output y: int @@ -10,7 +10,7 @@ reactor Scale(scale: int(2)) { reactor Test { input x: int - state received_value: bool(false) + state received_value: bool = false reaction(x) {= printf("Received %d.\n", x->value); diff --git a/test/C/src/concurrent/HelloThreaded.lf b/test/C/src/concurrent/HelloThreaded.lf index 72c7560ede..a8ea34dd05 100644 --- a/test/C/src/concurrent/HelloThreaded.lf +++ b/test/C/src/concurrent/HelloThreaded.lf @@ -8,9 +8,9 @@ target C { fast: true } -reactor Reschedule(period: time(2 sec), message: string("Hello C")) { - state count: int(0) - state previous_time: time(0) +reactor Reschedule(period: time = 2 sec, message: string = "Hello C") { + state count: int = 0 + state previous_time: time = 0 timer t(1 sec, period) logical action a @@ -43,8 +43,8 @@ reactor Reschedule(period: time(2 sec), message: string("Hello C")) { } reactor Inside( - period: time(1 sec), - message: string("Composite default message.") + period: time = 1 sec, + message: string = "Composite default message." ) { third_instance = new Reschedule(period = period, message = message) } diff --git a/test/C/src/concurrent/PingPongThreaded.lf b/test/C/src/concurrent/PingPongThreaded.lf index 0f2e60f065..4fae17911e 100644 --- a/test/C/src/concurrent/PingPongThreaded.lf +++ b/test/C/src/concurrent/PingPongThreaded.lf @@ -25,10 +25,10 @@ target C { fast: true } -reactor Ping(count: int(10)) { +reactor Ping(count: int = 10) { input receive: int output send: int - state pingsLeft: int(count) + state pingsLeft: int = count logical action serve reaction(startup, serve) -> send {= lf_set(send, self->pingsLeft--); =} @@ -42,10 +42,10 @@ reactor Ping(count: int(10)) { =} } -reactor Pong(expected: int(10)) { +reactor Pong(expected: int = 10) { input receive: int output send: int - state count: int(0) + state count: int = 0 reaction(receive) -> send {= self->count++; diff --git a/test/C/src/concurrent/ScheduleAt.lf b/test/C/src/concurrent/ScheduleAt.lf index 7e5e8318b1..e68b3956e8 100644 --- a/test/C/src/concurrent/ScheduleAt.lf +++ b/test/C/src/concurrent/ScheduleAt.lf @@ -12,7 +12,7 @@ target C { reactor Scheduler { logical action act // List of microsteps. Size = 16 - state microstep_delay_list: uint32_t[]( + state microstep_delay_list: uint32_t[] = { 0, 1, 1, @@ -29,8 +29,9 @@ reactor Scheduler { 4, 4, 5 - ) - state times: int[]( + } + + state times: int[] = { 0, 0, 0, @@ -47,10 +48,10 @@ reactor Scheduler { 900 msec, 900 msec, 900 msec - ) + } // Size = 9 - state action_hit_list_microstep: int[](1, 2, 0, 1, 0, 2, 3, 4, 5) - state action_hit_list_times: int[]( + state action_hit_list_microstep: int[] = {1, 2, 0, 1, 0, 2, 3, 4, 5} + state action_hit_list_times: int[] = { 0, 0, 400 msec, @@ -60,9 +61,9 @@ reactor Scheduler { 800 msec, 900 msec, 900 msec - ) + } // Size = 9 - state action_hit_list_index: int(0) + state action_hit_list_index: int = 0 reaction(startup) -> act {= for (int i=0; i < 16; i++) { diff --git a/test/C/src/concurrent/ScheduleTwice.lf b/test/C/src/concurrent/ScheduleTwice.lf index 41512f3c7d..e19f4d02d5 100644 --- a/test/C/src/concurrent/ScheduleTwice.lf +++ b/test/C/src/concurrent/ScheduleTwice.lf @@ -2,7 +2,7 @@ target C main reactor ScheduleTwice { logical action a: int - state rc_count: int(0) + state rc_count: int = 0 preamble {= #define VERBOSE =} diff --git a/test/C/src/concurrent/ScheduleTwiceThreaded.lf b/test/C/src/concurrent/ScheduleTwiceThreaded.lf index a368bec1ec..499e0e4999 100644 --- a/test/C/src/concurrent/ScheduleTwiceThreaded.lf +++ b/test/C/src/concurrent/ScheduleTwiceThreaded.lf @@ -2,7 +2,7 @@ target C main reactor { logical action a: int - state rc_count: int(0) + state rc_count: int = 0 reaction(startup) -> a {= lf_schedule_int(a, MSEC(100), 42); diff --git a/test/C/src/concurrent/SendingInsideThreaded.lf b/test/C/src/concurrent/SendingInsideThreaded.lf index e08a5dffb5..e5185ecfc8 100644 --- a/test/C/src/concurrent/SendingInsideThreaded.lf +++ b/test/C/src/concurrent/SendingInsideThreaded.lf @@ -7,7 +7,7 @@ target C { reactor Printer { input x: int - state count: int(1) + state count: int = 1 reaction(x) {= printf("Inside reactor received: %d\n", x->value); @@ -20,7 +20,7 @@ reactor Printer { } main reactor SendingInsideThreaded { - state count: int(0) + state count: int = 0 timer t(0, 1 sec) p = new Printer() diff --git a/test/C/src/concurrent/StarvationThreaded.lf b/test/C/src/concurrent/StarvationThreaded.lf index 58d063647d..a16b5e46b6 100644 --- a/test/C/src/concurrent/StarvationThreaded.lf +++ b/test/C/src/concurrent/StarvationThreaded.lf @@ -7,10 +7,10 @@ */ target C -reactor SuperDenseSender(number_of_iterations: int(10)) { +reactor SuperDenseSender(number_of_iterations: int = 10) { logical action loop output out: int - state iterator: int(0) + state iterator: int = 0 reaction(startup, loop) -> out {= if (self->iterator < self->number_of_iterations) { @@ -35,7 +35,7 @@ reactor SuperDenseSender(number_of_iterations: int(10)) { =} } -reactor SuperDenseReceiver(number_of_iterations: int(10)) { +reactor SuperDenseReceiver(number_of_iterations: int = 10) { input in: int reaction(in) {= diff --git a/test/C/src/concurrent/StopThreaded.lf b/test/C/src/concurrent/StopThreaded.lf index aa69bda345..1deb1c4ff6 100644 --- a/test/C/src/concurrent/StopThreaded.lf +++ b/test/C/src/concurrent/StopThreaded.lf @@ -13,7 +13,7 @@ import Sender from "../lib/LoopedActionSender.lf" reactor Consumer { input in: int - state reaction_invoked_correctly: bool(false) + state reaction_invoked_correctly: bool = false reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/concurrent/StopZeroThreaded.lf b/test/C/src/concurrent/StopZeroThreaded.lf index 051c615566..7afd4b0069 100644 --- a/test/C/src/concurrent/StopZeroThreaded.lf +++ b/test/C/src/concurrent/StopZeroThreaded.lf @@ -8,7 +8,7 @@ target C reactor Sender { output out: int - state reaction_invoked_correctly: bool(false) + state reaction_invoked_correctly: bool = false timer t(0, 1 usec) logical action act diff --git a/test/C/src/concurrent/Threaded.lf b/test/C/src/concurrent/Threaded.lf index abfcff2c1b..01f67c1bd4 100644 --- a/test/C/src/concurrent/Threaded.lf +++ b/test/C/src/concurrent/Threaded.lf @@ -16,7 +16,7 @@ target C { reactor Source { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= lf_set(out, self->s); @@ -40,8 +40,8 @@ reactor TakeTime { =} } -reactor Destination(width: int(4)) { - state s: int(400000000) +reactor Destination(width: int = 4) { + state s: int = 400000000 input[width] in: int reaction(in) {= @@ -58,7 +58,7 @@ reactor Destination(width: int(4)) { =} } -main reactor(width: int(4)) { +main reactor(width: int = 4) { a = new Source() t = new[width] TakeTime() (a.out)+ -> t.in diff --git a/test/C/src/concurrent/ThreadedMultiport.lf b/test/C/src/concurrent/ThreadedMultiport.lf index b24ead7cd9..2878393dac 100644 --- a/test/C/src/concurrent/ThreadedMultiport.lf +++ b/test/C/src/concurrent/ThreadedMultiport.lf @@ -5,10 +5,10 @@ target C { flags: "" } -reactor Source(width: int(4)) { +reactor Source(width: int = 4) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < out_width; i++) { @@ -18,7 +18,7 @@ reactor Source(width: int(4)) { =} } -reactor Computation(iterations: int(100000000)) { +reactor Computation(iterations: int = 100000000) { input in: int output out: int @@ -34,8 +34,8 @@ reactor Computation(iterations: int(100000000)) { =} } -reactor Destination(width: int(4), iterations: int(100000000)) { - state s: int(0) +reactor Destination(width: int = 4, iterations: int = 100000000) { + state s: int = 0 input[width] in: int reaction(in) {= @@ -61,7 +61,7 @@ reactor Destination(width: int(4), iterations: int(100000000)) { =} } -main reactor ThreadedMultiport(width: int(4), iterations: int(100000000)) { +main reactor ThreadedMultiport(width: int = 4, iterations: int = 100000000) { a = new Source(width = width) t = new[width] Computation(iterations = iterations) b = new Destination(width = width, iterations = iterations) diff --git a/test/C/src/concurrent/ThreadedThreaded.lf b/test/C/src/concurrent/ThreadedThreaded.lf index 9db95faaf0..4037e8c193 100644 --- a/test/C/src/concurrent/ThreadedThreaded.lf +++ b/test/C/src/concurrent/ThreadedThreaded.lf @@ -15,7 +15,7 @@ target C { reactor Source { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= lf_set(out, self->s); @@ -39,8 +39,8 @@ reactor TakeTime { =} } -reactor Destination(width: int(4)) { - state s: int(400000000) +reactor Destination(width: int = 4) { + state s: int = 400000000 input[width] in: int reaction(in) {= @@ -57,7 +57,7 @@ reactor Destination(width: int(4)) { =} } -main reactor ThreadedThreaded(width: int(4)) { +main reactor ThreadedThreaded(width: int = 4) { a = new Source() t = new[width] TakeTime() (a.out)+ -> t.in diff --git a/test/C/src/concurrent/TimeLimitThreaded.lf b/test/C/src/concurrent/TimeLimitThreaded.lf index 97bb9cfec6..8d3824af47 100644 --- a/test/C/src/concurrent/TimeLimitThreaded.lf +++ b/test/C/src/concurrent/TimeLimitThreaded.lf @@ -4,10 +4,10 @@ target C { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -18,7 +18,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int - state s: int(1) + state s: int = 1 reaction(x) {= // printf("%d\n", x->value); @@ -38,7 +38,7 @@ reactor Destination { =} } -main reactor(period: time(1 sec)) { +main reactor(period: time = 1 sec) { timer stop(10 sec) c = new Clock(period = period) d = new Destination() diff --git a/test/C/src/concurrent/TimeoutThreaded.lf b/test/C/src/concurrent/TimeoutThreaded.lf index 993366a2c0..3a7e2181d7 100644 --- a/test/C/src/concurrent/TimeoutThreaded.lf +++ b/test/C/src/concurrent/TimeoutThreaded.lf @@ -12,7 +12,7 @@ import Sender from "../lib/LoopedActionSender.lf" reactor Consumer { input in: int - state success: bool(false) + state success: bool = false reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/concurrent/TimeoutZeroThreaded.lf b/test/C/src/concurrent/TimeoutZeroThreaded.lf index 4a0bdd62a3..9b24ef080f 100644 --- a/test/C/src/concurrent/TimeoutZeroThreaded.lf +++ b/test/C/src/concurrent/TimeoutZeroThreaded.lf @@ -12,7 +12,7 @@ import Sender from "../lib/LoopedActionSender.lf" reactor Consumer { input in: int - state success: bool(false) + state success: bool = false reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/concurrent/Tracing.lf b/test/C/src/concurrent/Tracing.lf index ff2f436e85..71da79c7ef 100644 --- a/test/C/src/concurrent/Tracing.lf +++ b/test/C/src/concurrent/Tracing.lf @@ -10,7 +10,7 @@ target C { reactor Source { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= lf_set(out, self->s); @@ -18,10 +18,10 @@ reactor Source { =} } -reactor TakeTime(bank_index: int(0)) { +reactor TakeTime(bank_index: int = 0) { input in: int output out: int - state event: char*("No ID") + state event: char* = "No ID" reaction(startup) {= // Construct an id string for a user trace event. @@ -57,9 +57,9 @@ reactor TakeTime(bank_index: int(0)) { =} } -reactor Destination(width: int(4)) { - state s: int(400000000) - state count: int(0) +reactor Destination(width: int = 4) { + state s: int = 400000000 + state count: int = 0 input[width] in: int reaction(startup) {= @@ -86,7 +86,7 @@ reactor Destination(width: int(4)) { =} } -main reactor(width: int(4)) { +main reactor(width: int = 4) { a = new Source() t = new[width] TakeTime() (a.out)+ -> t.in diff --git a/test/C/src/docker/federated/DistributedCountContainerized.lf b/test/C/src/docker/federated/DistributedCountContainerized.lf index 9eb6898a9d..4a120c5e1e 100644 --- a/test/C/src/docker/federated/DistributedCountContainerized.lf +++ b/test/C/src/docker/federated/DistributedCountContainerized.lf @@ -15,7 +15,9 @@ target C { import Count from "../../lib/Count.lf" import Print from "../../federated/DistributedCount.lf" -federated reactor DistributedCountContainerized(offset: time(200 msec)) at rti { +federated reactor DistributedCountContainerized( + offset: time = 200 msec +) at rti { c = new Count() p = new Print() c.out -> p.in after offset diff --git a/test/C/src/federated/BroadcastFeedback.lf b/test/C/src/federated/BroadcastFeedback.lf index 0c7146b8f7..2bef908d2d 100644 --- a/test/C/src/federated/BroadcastFeedback.lf +++ b/test/C/src/federated/BroadcastFeedback.lf @@ -9,7 +9,7 @@ target C { reactor SenderAndReceiver { output out: int input[2] in: int - state received: bool(false) + state received: bool = false reaction(startup) -> out {= lf_set(out, 42); =} diff --git a/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf b/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf index 1632f0332a..d9edbc954b 100644 --- a/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf +++ b/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf @@ -8,7 +8,7 @@ target C { reactor SenderAndReceiver { output out: int input[2] in: int - state received: bool(false) + state received: bool = false r = new Receiver() in -> r.in @@ -18,7 +18,7 @@ reactor SenderAndReceiver { reactor Receiver { input[2] in: int - state received: bool(false) + state received: bool = false reaction(in) {= if (in[0]->is_present && in[1]->is_present && in[0]->value == 42 && in[1]->value == 42) { diff --git a/test/C/src/federated/CycleDetection.lf b/test/C/src/federated/CycleDetection.lf index 90ce0faba2..d22837bc1f 100644 --- a/test/C/src/federated/CycleDetection.lf +++ b/test/C/src/federated/CycleDetection.lf @@ -10,7 +10,7 @@ reactor CAReplica { input remote_update: int input query: int - state balance: int(0) + state balance: int = 0 output response: int diff --git a/test/C/src/federated/DecentralizedP2PComm.lf b/test/C/src/federated/DecentralizedP2PComm.lf index 5791ddd8a7..0ca6a10e6f 100644 --- a/test/C/src/federated/DecentralizedP2PComm.lf +++ b/test/C/src/federated/DecentralizedP2PComm.lf @@ -6,15 +6,15 @@ target C { } reactor Platform( - start: int(0), - expected_start: int(0), - stp_offset_param: time(0) + start: int = 0, + expected_start: int = 0, + stp_offset_param: time = 0 ) { input in: int output out: int timer t(0, 100 msec) - state count: int(start) - state expected: int(expected_start) + state count: int = start + state expected: int = expected_start reaction(t) -> out {= lf_set(out, self->count++); =} diff --git a/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf b/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf index 3b872b8408..fca2149fcf 100644 --- a/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf +++ b/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf @@ -11,10 +11,10 @@ target C { coordination: decentralized } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -29,7 +29,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int - state s: int(1) + state s: int = 1 reaction(x) {= lf_print("Received %d", x->value); @@ -48,7 +48,7 @@ reactor Destination { =} } -federated reactor(period: time(10 usec)) { +federated reactor(period: time = 10 usec) { c = new Clock(period = period) d = new Destination() c.y -> d.x diff --git a/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index 49562c7e77..8468e1dc81 100644 --- a/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -12,10 +12,10 @@ target C { coordination: decentralized } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= (self->count)++; @@ -30,7 +30,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int - state s: int(1) + state s: int = 1 reaction(x) {= // printf("%d\n", x->value); @@ -46,7 +46,7 @@ reactor Destination { =} } -federated reactor(period: time(10 usec)) { +federated reactor(period: time = 10 usec) { c = new Clock(period = period) d = new Destination() c.y ~> d.x diff --git a/test/C/src/federated/DistributedBank.lf b/test/C/src/federated/DistributedBank.lf index 9dd1247980..84acb00031 100644 --- a/test/C/src/federated/DistributedBank.lf +++ b/test/C/src/federated/DistributedBank.lf @@ -6,7 +6,7 @@ target C { reactor Node { timer t(0, 100 msec) - state count: int(0) + state count: int = 0 reaction(t) {= lf_print("Hello world %d.", self->count++); =} diff --git a/test/C/src/federated/DistributedBankToMultiport.lf b/test/C/src/federated/DistributedBankToMultiport.lf index b392b3e603..796db0718e 100644 --- a/test/C/src/federated/DistributedBankToMultiport.lf +++ b/test/C/src/federated/DistributedBankToMultiport.lf @@ -7,7 +7,7 @@ import Count from "../lib/Count.lf" reactor Destination { input[2] in: int - state count: int(1) + state count: int = 1 reaction(in) {= for (int i = 0; i < in_width; i++) { diff --git a/test/C/src/federated/DistributedCount.lf b/test/C/src/federated/DistributedCount.lf index 7ffd4eb8e2..2ebdda169a 100644 --- a/test/C/src/federated/DistributedCount.lf +++ b/test/C/src/federated/DistributedCount.lf @@ -14,7 +14,7 @@ import Count from "../lib/Count.lf" reactor Print { input in: int - state c: int(1) + state c: int = 1 reaction(in) {= interval_t elapsed_time = lf_time_logical_elapsed(); @@ -35,7 +35,7 @@ reactor Print { =} } -federated reactor DistributedCount(offset: time(200 msec)) { +federated reactor DistributedCount(offset: time = 200 msec) { c = new Count() p = new Print() c.out -> p.in after offset diff --git a/test/C/src/federated/DistributedCountDecentralized.lf b/test/C/src/federated/DistributedCountDecentralized.lf index e7ee0a7d77..631dfab0c0 100644 --- a/test/C/src/federated/DistributedCountDecentralized.lf +++ b/test/C/src/federated/DistributedCountDecentralized.lf @@ -14,7 +14,7 @@ import Count from "../lib/Count.lf" reactor Print { input in: int - state c: int(1) + state c: int = 1 reaction(in) {= interval_t elapsed_time = lf_time_logical_elapsed(); diff --git a/test/C/src/federated/DistributedCountDecentralizedLate.lf b/test/C/src/federated/DistributedCountDecentralizedLate.lf index fa85987e87..9fb6d3b064 100644 --- a/test/C/src/federated/DistributedCountDecentralizedLate.lf +++ b/test/C/src/federated/DistributedCountDecentralizedLate.lf @@ -15,12 +15,12 @@ import Count from "../lib/Count.lf" reactor Print { input in: int // STP () - state success: int(0) // STP(in, 30 msec); - state success_stp_violation: int(0) + state success: int = 0 // STP(in, 30 msec); + state success_stp_violation: int = 0 // Force a timer to be invoke periodically to ensure logical time will // advance in the absence of incoming messages. timer t(0, 10 msec) - state c: int(0) + state c: int = 0 reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/federated/DistributedCountDecentralizedLateHierarchy.lf b/test/C/src/federated/DistributedCountDecentralizedLateHierarchy.lf index 26c20521e3..31ab87e110 100644 --- a/test/C/src/federated/DistributedCountDecentralizedLateHierarchy.lf +++ b/test/C/src/federated/DistributedCountDecentralizedLateHierarchy.lf @@ -17,12 +17,12 @@ import Count from "../lib/Count.lf" reactor ImportantActuator { input in: int - state success: int(0) - state success_stp_violation: int(0) + state success: int = 0 + state success_stp_violation: int = 0 // Force a timer to be invoke periodically timer t(0, 10 msec) // to ensure logical time will advance in the absence of incoming messages. - state c: int(0) + state c: int = 0 reaction(in) {= tag_t current_tag = lf_tag(); @@ -79,7 +79,7 @@ reactor Receiver { // Force a timer to be invoke periodically timer t(0, 10 msec) // to ensure logical time will advance in the absence of incoming messages. - state c: int(0) + state c: int = 0 p = new Print() a = new ImportantActuator() in -> p.in diff --git a/test/C/src/federated/DistributedCountPhysical.lf b/test/C/src/federated/DistributedCountPhysical.lf index 67d90ec4c1..9e1e15f775 100644 --- a/test/C/src/federated/DistributedCountPhysical.lf +++ b/test/C/src/federated/DistributedCountPhysical.lf @@ -13,7 +13,7 @@ target C { reactor Count { timer t(200 msec, 1 sec) - state s: int(0) + state s: int = 0 output out: int reaction(t) -> out {= @@ -24,7 +24,7 @@ reactor Count { reactor Print { input in: int - state c: int(0) + state c: int = 0 reaction(in) {= interval_t elapsed_time = lf_time_logical_elapsed(); diff --git a/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf index 2d13891bae..b0da42218a 100644 --- a/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf +++ b/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -12,7 +12,7 @@ import Count from "../lib/Count.lf" reactor Print { input in: int - state c: int(1) + state c: int = 1 reaction(in) {= interval_t elapsed_time = lf_time_logical_elapsed(); diff --git a/test/C/src/federated/DistributedCountPhysicalDecentralized.lf b/test/C/src/federated/DistributedCountPhysicalDecentralized.lf index 6bc50fce88..e821e4fb70 100644 --- a/test/C/src/federated/DistributedCountPhysicalDecentralized.lf +++ b/test/C/src/federated/DistributedCountPhysicalDecentralized.lf @@ -14,7 +14,7 @@ target C { reactor Count { timer t(200 msec, 1 sec) - state s: int(0) + state s: int = 0 output out: int reaction(t) -> out {= @@ -25,7 +25,7 @@ reactor Count { reactor Print { input in: int - state c: int(0) + state c: int = 0 reaction(in) {= interval_t elapsed_time = lf_time_logical_elapsed(); diff --git a/test/C/src/federated/DistributedDoublePort.lf b/test/C/src/federated/DistributedDoublePort.lf index 2490df67bf..87de1ddb28 100644 --- a/test/C/src/federated/DistributedDoublePort.lf +++ b/test/C/src/federated/DistributedDoublePort.lf @@ -14,7 +14,7 @@ target C { import Count from "../lib/Count.lf" reactor CountMicrostep { - state count: int(1) + state count: int = 1 output out: int logical action act: int timer t(0, 1 sec) diff --git a/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf b/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf index 078b15ed02..acbbaf4035 100644 --- a/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf @@ -11,8 +11,8 @@ import TestCount from "../lib/TestCount.lf" reactor WithLogicalAction { output out: int - state thread_id: lf_thread_t(0) - state counter: int(1) + state thread_id: lf_thread_t = 0 + state counter: int = 1 logical action act(0): int reaction(startup, act) -> act, out {= diff --git a/test/C/src/federated/DistributedLoopedAction.lf b/test/C/src/federated/DistributedLoopedAction.lf index 1a70412696..8218e73646 100644 --- a/test/C/src/federated/DistributedLoopedAction.lf +++ b/test/C/src/federated/DistributedLoopedAction.lf @@ -10,11 +10,14 @@ target C { import Sender from "../lib/LoopedActionSender.lf" -reactor Receiver(take_a_break_after: int(10), break_interval: time(400 msec)) { +reactor Receiver( + take_a_break_after: int = 10, + break_interval: time = 400 msec +) { input in: int - state received_messages: int(0) - state total_received_messages: int(0) - state breaks: int(0) + state received_messages: int = 0 + state total_received_messages: int = 0 + state breaks: int = 0 timer t(0, 1 msec) // This will impact the performance // but forces the logical time to advance Comment this line for a more diff --git a/test/C/src/federated/DistributedLoopedActionDecentralized.lf b/test/C/src/federated/DistributedLoopedActionDecentralized.lf index f1addfb63c..17842809fa 100644 --- a/test/C/src/federated/DistributedLoopedActionDecentralized.lf +++ b/test/C/src/federated/DistributedLoopedActionDecentralized.lf @@ -20,11 +20,14 @@ target C { import Sender from "../lib/LoopedActionSender.lf" -reactor Receiver(take_a_break_after: int(10), break_interval: time(400 msec)) { +reactor Receiver( + take_a_break_after: int = 10, + break_interval: time = 400 msec +) { input in: int - state received_messages: int(0) - state total_received_messages: int(0) - state breaks: int(0) + state received_messages: int = 0 + state total_received_messages: int = 0 + state breaks: int = 0 reaction(in) {= tag_t current_tag = lf_tag(); @@ -77,12 +80,12 @@ reactor Receiver(take_a_break_after: int(10), break_interval: time(400 msec)) { } reactor STPReceiver( - take_a_break_after: int(10), - break_interval: time(400 msec), - stp_offset: time(0) + take_a_break_after: int = 10, + break_interval: time = 400 msec, + stp_offset: time = 0 ) { input in: int - state last_time_updated_stp: time(0) + state last_time_updated_stp: time = 0 receiver = new Receiver(take_a_break_after = 10, break_interval = 400 msec) timer t(0, 1 msec) // Force advancement of logical time diff --git a/test/C/src/federated/DistributedLoopedPhysicalAction.lf b/test/C/src/federated/DistributedLoopedPhysicalAction.lf index 7b42628683..454577ff35 100644 --- a/test/C/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/C/src/federated/DistributedLoopedPhysicalAction.lf @@ -16,10 +16,10 @@ target C { } } -reactor Sender(take_a_break_after: int(10), break_interval: time(550 msec)) { +reactor Sender(take_a_break_after: int = 10, break_interval: time = 550 msec) { output out: int physical action act - state sent_messages: int(0) + state sent_messages: int = 0 reaction(startup, act) -> act, out {= // Send a message on out @@ -35,11 +35,14 @@ reactor Sender(take_a_break_after: int(10), break_interval: time(550 msec)) { =} } -reactor Receiver(take_a_break_after: int(10), break_interval: time(550 msec)) { +reactor Receiver( + take_a_break_after: int = 10, + break_interval: time = 550 msec +) { input in: int - state received_messages: int(0) - state total_received_messages: int(0) - state breaks: int(0) + state received_messages: int = 0 + state total_received_messages: int = 0 + state breaks: int = 0 timer t(0, 1 msec) // This will impact the performance // but forces the logical time to advance Comment this line for a more diff --git a/test/C/src/federated/DistributedMultiport.lf b/test/C/src/federated/DistributedMultiport.lf index 28156d4b70..3853629731 100644 --- a/test/C/src/federated/DistributedMultiport.lf +++ b/test/C/src/federated/DistributedMultiport.lf @@ -7,7 +7,7 @@ target C { reactor Source { output[4] out: int timer t(0, 100 msec) - state count: int(0) + state count: int = 0 reaction(t) -> out {= for (int i = 0; i < out_width; i++) { @@ -18,7 +18,7 @@ reactor Source { reactor Destination { input[4] in: int - state count: int(0) + state count: int = 0 reaction(in) {= for (int i = 0; i < in_width; i++) { diff --git a/test/C/src/federated/DistributedMultiportToBank.lf b/test/C/src/federated/DistributedMultiportToBank.lf index 503dec692e..0accaf8c60 100644 --- a/test/C/src/federated/DistributedMultiportToBank.lf +++ b/test/C/src/federated/DistributedMultiportToBank.lf @@ -6,7 +6,7 @@ target C { reactor Source { output[2] out: int timer t(0, 100 msec) - state count: int(0) + state count: int = 0 reaction(t) -> out {= for (int i = 0; i < out_width; i++) { @@ -18,7 +18,7 @@ reactor Source { reactor Destination { input in: int - state count: int(0) + state count: int = 0 reaction(in) {= lf_print("Received %d.", in->value); diff --git a/test/C/src/federated/DistributedMultiportToken.lf b/test/C/src/federated/DistributedMultiportToken.lf index 065f480e11..dfb791d861 100644 --- a/test/C/src/federated/DistributedMultiportToken.lf +++ b/test/C/src/federated/DistributedMultiportToken.lf @@ -8,7 +8,7 @@ target C { reactor Source { output[4] out: char* timer t(0, 200 msec) - state count: int(0) + state count: int = 0 reaction(t) -> out {= for (int i = 0; i < out_width; i++) { diff --git a/test/C/src/federated/DistributedNetworkOrder.lf b/test/C/src/federated/DistributedNetworkOrder.lf index 0b9ca0cd17..e18ea4ac04 100644 --- a/test/C/src/federated/DistributedNetworkOrder.lf +++ b/test/C/src/federated/DistributedNetworkOrder.lf @@ -32,7 +32,7 @@ reactor Sender { reactor Receiver { input in: int - state success: int(0) + state success: int = 0 reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/federated/DistributedPhysicalActionUpstream.lf b/test/C/src/federated/DistributedPhysicalActionUpstream.lf index 2cc6735884..47280a24b8 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstream.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstream.lf @@ -30,7 +30,7 @@ preamble {= reactor WithPhysicalAction { output out: int - state thread_id: lf_thread_t(0) + state thread_id: lf_thread_t = 0 physical action act(0): int reaction(startup) -> act {= diff --git a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf index 0a6ee31e62..66bbb964e1 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf @@ -30,7 +30,7 @@ preamble {= reactor WithPhysicalAction { output out: int - state thread_id: lf_thread_t(0) + state thread_id: lf_thread_t = 0 physical action act(0): int reaction(startup) -> act {= diff --git a/test/C/src/federated/DistributedStop.lf b/test/C/src/federated/DistributedStop.lf index cf103d8beb..2d4a616664 100644 --- a/test/C/src/federated/DistributedStop.lf +++ b/test/C/src/federated/DistributedStop.lf @@ -10,7 +10,7 @@ reactor Sender { output out: int timer t(0, 1 usec) logical action act - state reaction_invoked_correctly: bool(false) + state reaction_invoked_correctly: bool = false reaction(t, act) -> out, act {= lf_print("Sending 42 at (%lld, %u).", @@ -63,10 +63,10 @@ reactor Sender { } reactor Receiver( - stp_offset: time(10 msec) // Used in the decentralized variant of the test + stp_offset: time = 10 msec // Used in the decentralized variant of the test ) { input in: int - state reaction_invoked_correctly: bool(false) + state reaction_invoked_correctly: bool = false reaction(in) {= lf_print("Received %d at (%lld, %u).", diff --git a/test/C/src/federated/DistributedToken.lf b/test/C/src/federated/DistributedToken.lf index c408af6ad2..1068bd5f85 100644 --- a/test/C/src/federated/DistributedToken.lf +++ b/test/C/src/federated/DistributedToken.lf @@ -26,11 +26,11 @@ target C { * @param root The root string. * @output message The message. */ -reactor MessageGenerator(root: string("")) { +reactor MessageGenerator(root: string = "") { // Output type char* instead of string is used for dynamically allocated // character arrays (as opposed to static constant strings). output message: char* - state count: int(1) + state count: int = 1 // Send first message after 1 sec so that the startup reactions do not // factor into the transport time measurement on the first message. timer t(1 sec, 1 sec) @@ -57,7 +57,7 @@ reactor MessageGenerator(root: string("")) { */ reactor PrintMessage { input message: char* - state count: int(0) + state count: int = 0 reaction(message) {= printf("PrintMessage: At (elapsed) logical time %lld, receiver receives: %s\n", diff --git a/test/C/src/federated/FeedbackDelay.lf b/test/C/src/federated/FeedbackDelay.lf index 6495fde8db..997a4ad012 100644 --- a/test/C/src/federated/FeedbackDelay.lf +++ b/test/C/src/federated/FeedbackDelay.lf @@ -7,8 +7,8 @@ reactor PhysicalPlant { input control: double output sensor: double timer t(0, 33 msec) - state last_sensor_time: time(0) - state previous_sensor_time: time(0) + state last_sensor_time: time = 0 + state previous_sensor_time: time = 0 reaction(t) -> sensor {= lf_set(sensor, 42); @@ -27,8 +27,8 @@ reactor Controller { input sensor: double output control: double - state latest_control: double(0.0) - state first: bool(true) + state latest_control: double = 0.0 + state first: bool = true output request_for_planning: double input planning: double diff --git a/test/C/src/federated/FeedbackDelaySimple.lf b/test/C/src/federated/FeedbackDelaySimple.lf index 2f00000e03..0c9b147cda 100644 --- a/test/C/src/federated/FeedbackDelaySimple.lf +++ b/test/C/src/federated/FeedbackDelaySimple.lf @@ -6,7 +6,7 @@ reactor Loop { input in: int output out: int timer t(0, 100 msec) - state count: int(1) + state count: int = 1 reaction(in) {= lf_print("Received %d.", in->value); diff --git a/test/C/src/federated/HelloDistributed.lf b/test/C/src/federated/HelloDistributed.lf index 14b446f26d..6841bf91bc 100644 --- a/test/C/src/federated/HelloDistributed.lf +++ b/test/C/src/federated/HelloDistributed.lf @@ -19,7 +19,7 @@ reactor Source { reactor Destination { input in: string - state received: bool(false) + state received: bool = false reaction(startup) {= lf_print("Destination started."); =} diff --git a/test/C/src/federated/LoopDistributedCentralized.lf b/test/C/src/federated/LoopDistributedCentralized.lf index 9643d3f1f3..7fdc972b5a 100644 --- a/test/C/src/federated/LoopDistributedCentralized.lf +++ b/test/C/src/federated/LoopDistributedCentralized.lf @@ -14,11 +14,11 @@ target C { logging: DEBUG } -reactor Looper(incr: int(1), delay: time(0 msec)) { +reactor Looper(incr: int = 1, delay: time = 0 msec) { input in: int output out: int physical action a(delay) - state count: int(0) + state count: int = 0 timer t(0, 1 sec) @@ -42,7 +42,7 @@ reactor Looper(incr: int(1), delay: time(0 msec)) { =} } -federated reactor LoopDistributedCentralized(delay: time(0)) { +federated reactor LoopDistributedCentralized(delay: time = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.in diff --git a/test/C/src/federated/LoopDistributedCentralized2.lf b/test/C/src/federated/LoopDistributedCentralized2.lf index c81a0f012e..82412e16fe 100644 --- a/test/C/src/federated/LoopDistributedCentralized2.lf +++ b/test/C/src/federated/LoopDistributedCentralized2.lf @@ -13,11 +13,11 @@ target C { timeout: 4 sec } -reactor Looper(incr: int(1), delay: time(0 msec)) { +reactor Looper(incr: int = 1, delay: time = 0 msec) { input in: int output out: int physical action a(delay) - state count: int(0) + state count: int = 0 timer t(0, 1 sec) @@ -41,11 +41,11 @@ reactor Looper(incr: int(1), delay: time(0 msec)) { =} } -reactor Looper2(incr: int(1), delay: time(0 msec)) { +reactor Looper2(incr: int = 1, delay: time = 0 msec) { input in: int output out: int physical action a(delay) - state count: int(0) + state count: int = 0 timer t(0, 1 sec) @@ -69,7 +69,7 @@ reactor Looper2(incr: int(1), delay: time(0 msec)) { =} } -federated reactor(delay: time(0)) { +federated reactor(delay: time = 0) { left = new Looper() right = new Looper2(incr = -1) left.out -> right.in diff --git a/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf b/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf index e622e31979..44ce6e1681 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf @@ -27,11 +27,11 @@ preamble {= } =} -reactor Looper(incr: int(1), delay: time(0 msec)) { +reactor Looper(incr: int = 1, delay: time = 0 msec) { input in: int output out: int physical action a(delay) - state count: int(0) + state count: int = 0 reaction(startup) -> a {= // Start the thread that listens for Enter or Return. @@ -62,7 +62,7 @@ reactor Looper(incr: int(1), delay: time(0 msec)) { =} } -federated reactor(delay: time(0)) { +federated reactor(delay: time = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.in diff --git a/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf b/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf index a1e6e87b6e..f9b088b7d1 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf @@ -14,11 +14,11 @@ target C { timeout: 5 sec } -reactor Looper(incr: int(1), delay: time(0 msec)) { +reactor Looper(incr: int = 1, delay: time = 0 msec) { input in: int output out: int - state count: int(0) - state received_count: int(0) + state count: int = 0 + state received_count: int = 0 timer t(0, 1 sec) reaction(t) -> out {= @@ -48,7 +48,7 @@ reactor Looper(incr: int(1), delay: time(0 msec)) { =} } -federated reactor(delay: time(0)) { +federated reactor(delay: time = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.in diff --git a/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf b/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf index ef18cadfbf..17177aadb3 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf @@ -15,11 +15,11 @@ target C { timeout: 5 sec } -reactor Contained(incr: int(1)) { +reactor Contained(incr: int = 1) { timer t(0, 1 sec) input in: int - state count: int(0) - state received_count: int(0) + state count: int = 0 + state received_count: int = 0 reaction(t) {= self->count += self->incr; =} @@ -32,10 +32,10 @@ reactor Contained(incr: int(1)) { =} } -reactor Looper(incr: int(1), delay: time(0 msec)) { +reactor Looper(incr: int = 1, delay: time = 0 msec) { input in: int output out: int - state count: int(0) + state count: int = 0 timer t(0, 1 sec) c = new Contained(incr = incr) @@ -62,7 +62,7 @@ reactor Looper(incr: int(1), delay: time(0 msec)) { =} } -federated reactor(delay: time(0)) { +federated reactor(delay: time = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.in diff --git a/test/C/src/federated/LoopDistributedDecentralized.lf b/test/C/src/federated/LoopDistributedDecentralized.lf index c2d4bcb297..ae64e6e71a 100644 --- a/test/C/src/federated/LoopDistributedDecentralized.lf +++ b/test/C/src/federated/LoopDistributedDecentralized.lf @@ -23,11 +23,11 @@ preamble {= } =} -reactor Looper(incr: int(1), delay: time(0 msec), stp_offset: time(0)) { +reactor Looper(incr: int = 1, delay: time = 0 msec, stp_offset: time = 0) { input in: int output out: int physical action a(stp_offset) - state count: int(0) + state count: int = 0 reaction(startup) -> a {= // Start the thread that listens for Enter or Return. @@ -69,7 +69,7 @@ reactor Looper(incr: int(1), delay: time(0 msec), stp_offset: time(0)) { =} } -federated reactor LoopDistributedDecentralized(delay: time(0)) { +federated reactor LoopDistributedDecentralized(delay: time = 0) { left = new Looper(stp_offset = 900 usec) right = new Looper(incr = -1, stp_offset = 2400 usec) left.out -> right.in diff --git a/test/C/src/federated/LoopDistributedDouble.lf b/test/C/src/federated/LoopDistributedDouble.lf index bba7c7ffaa..31b7eb0f6e 100644 --- a/test/C/src/federated/LoopDistributedDouble.lf +++ b/test/C/src/federated/LoopDistributedDouble.lf @@ -27,13 +27,13 @@ preamble {= } =} -reactor Looper(incr: int(1), delay: time(0 msec)) { +reactor Looper(incr: int = 1, delay: time = 0 msec) { input in: int input in2: int output out: int output out2: int physical action a(delay) - state count: int(0) + state count: int = 0 timer t(0, 1 sec) reaction(startup) -> a {= @@ -82,7 +82,7 @@ reactor Looper(incr: int(1), delay: time(0 msec)) { =} } -federated reactor(delay: time(0)) { +federated reactor(delay: time = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.in diff --git a/test/C/src/federated/PhysicalSTP.lf b/test/C/src/federated/PhysicalSTP.lf index 1824d9ec93..492cd8875b 100644 --- a/test/C/src/federated/PhysicalSTP.lf +++ b/test/C/src/federated/PhysicalSTP.lf @@ -9,9 +9,9 @@ target C { import Count from "../lib/Count.lf" -reactor Print(STP_offset_param: time(0)) { +reactor Print(STP_offset_param: time = 0) { input in: int - state c: int(1) + state c: int = 1 reaction(in) {= interval_t elapsed_time = lf_time_logical_elapsed(); diff --git a/test/C/src/federated/PingPongDistributed.lf b/test/C/src/federated/PingPongDistributed.lf index a1d321cc6d..e16de50ed2 100644 --- a/test/C/src/federated/PingPongDistributed.lf +++ b/test/C/src/federated/PingPongDistributed.lf @@ -23,7 +23,7 @@ target C import Ping, Pong from "PingPongDistributedPhysical.lf" -federated reactor(count: int(10)) { +federated reactor(count: int = 10) { ping = new Ping(count = count) pong = new Pong(expected = count) ping.send -> pong.receive diff --git a/test/C/src/federated/PingPongDistributedPhysical.lf b/test/C/src/federated/PingPongDistributedPhysical.lf index 95427c2a29..d9ba517c59 100644 --- a/test/C/src/federated/PingPongDistributedPhysical.lf +++ b/test/C/src/federated/PingPongDistributedPhysical.lf @@ -26,10 +26,10 @@ */ target C -reactor Ping(count: int(10)) { +reactor Ping(count: int = 10) { input receive: int output send: int - state pingsLeft: int(count) + state pingsLeft: int = count logical action serve reaction(startup, serve) -> send {= @@ -46,10 +46,10 @@ reactor Ping(count: int(10)) { =} } -reactor Pong(expected: int(10)) { +reactor Pong(expected: int = 10) { input receive: int output send: int - state count: int(0) + state count: int = 0 reaction(receive) -> send {= self->count++; @@ -71,7 +71,7 @@ reactor Pong(expected: int(10)) { =} } -federated reactor(count: int(10)) { +federated reactor(count: int = 10) { ping = new Ping(count = count) pong = new Pong(expected = count) ping.send ~> pong.receive diff --git a/test/C/src/federated/TopLevelArtifacts.lf b/test/C/src/federated/TopLevelArtifacts.lf index 5fd4b0c376..05932b1937 100644 --- a/test/C/src/federated/TopLevelArtifacts.lf +++ b/test/C/src/federated/TopLevelArtifacts.lf @@ -15,7 +15,7 @@ import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" federated reactor { - state successes: int(0) + state successes: int = 0 timer t(0, 1 sec) logical action act(0) diff --git a/test/C/src/federated/failing/ClockSync.lf b/test/C/src/federated/failing/ClockSync.lf index e843f0c549..1231ce9cbf 100644 --- a/test/C/src/federated/failing/ClockSync.lf +++ b/test/C/src/federated/failing/ClockSync.lf @@ -29,7 +29,7 @@ target C { } /** Reactor that outputs periodically. */ -reactor Ticker(period: time(1600 msec)) { +reactor Ticker(period: time = 1600 msec) { output out: int timer tick(0, period) diff --git a/test/C/src/federated/failing/DistributedDoublePortLooped.lf b/test/C/src/federated/failing/DistributedDoublePortLooped.lf index 4eca2cee76..67a3300c74 100644 --- a/test/C/src/federated/failing/DistributedDoublePortLooped.lf +++ b/test/C/src/federated/failing/DistributedDoublePortLooped.lf @@ -19,7 +19,7 @@ reactor Foo { } reactor Count { - state count: int(1) + state count: int = 1 input in1: int input in2: int input in3: int @@ -37,7 +37,7 @@ reactor Count { } reactor CountMicrostep { - state count: int(1) + state count: int = 1 output out: int logical action act: int timer t(0, 1 msec) diff --git a/test/C/src/federated/failing/DistributedDoublePortLooped2.lf b/test/C/src/federated/failing/DistributedDoublePortLooped2.lf index 04ea02c4e8..56a873e1bc 100644 --- a/test/C/src/federated/failing/DistributedDoublePortLooped2.lf +++ b/test/C/src/federated/failing/DistributedDoublePortLooped2.lf @@ -12,7 +12,7 @@ target C { } reactor Count { - state count: int(1) + state count: int = 1 input in: int output out: int timer t(0, 1 msec) @@ -26,7 +26,7 @@ reactor Count { } reactor CountMicrostep { - state count: int(1) + state count: int = 1 output out: int logical action act: int timer t(0, 1 msec) diff --git a/test/C/src/federated/failing/DistributedNetworkOrderDecentralized.lf b/test/C/src/federated/failing/DistributedNetworkOrderDecentralized.lf index 19779de3d2..97fa16b016 100644 --- a/test/C/src/federated/failing/DistributedNetworkOrderDecentralized.lf +++ b/test/C/src/federated/failing/DistributedNetworkOrderDecentralized.lf @@ -31,7 +31,7 @@ reactor Sender { reactor Receiver { input in: int - state success: int(0) + state success: int = 0 reaction(in) {= tag_t current_tag = lf_tag(); diff --git a/test/C/src/federated/failing/LoopDistributedDecentralizedPrecedence.lf b/test/C/src/federated/failing/LoopDistributedDecentralizedPrecedence.lf index ee9fc56d83..b991662a05 100644 --- a/test/C/src/federated/failing/LoopDistributedDecentralizedPrecedence.lf +++ b/test/C/src/federated/failing/LoopDistributedDecentralizedPrecedence.lf @@ -11,11 +11,11 @@ target C { timeout: 4900 msec } -reactor Looper(incr: int(1), delay: time(0 msec), stp_offset: time(0)) { +reactor Looper(incr: int = 1, delay: time = 0 msec, stp_offset: time = 0) { input in: int output out: int - state count: int(0) - state received_count: int(0) + state count: int = 0 + state received_count: int = 0 timer t(0, 1 sec) reaction(t) -> out {= @@ -57,7 +57,7 @@ reactor Looper(incr: int(1), delay: time(0 msec), stp_offset: time(0)) { =} } -federated reactor(delay: time(0)) { +federated reactor(delay: time = 0) { left = new Looper(stp_offset = 5 msec) right = new Looper(incr = -1, stp_offset = 5 msec) left.out -> right.in diff --git a/test/C/src/federated/failing/LoopDistributedDecentralizedPrecedenceHierarchy.lf b/test/C/src/federated/failing/LoopDistributedDecentralizedPrecedenceHierarchy.lf index 6cf9236901..357b7f2f2d 100644 --- a/test/C/src/federated/failing/LoopDistributedDecentralizedPrecedenceHierarchy.lf +++ b/test/C/src/federated/failing/LoopDistributedDecentralizedPrecedenceHierarchy.lf @@ -1,6 +1,7 @@ /** - * This tests that the precedence order of reaction invocation is kept - * in the hierarchy of reactors when a feedback loop is present in decentralized coordination. + * This tests that the precedence order of reaction invocation is kept in the + * hierarchy of reactors when a feedback loop is present in decentralized + * coordination. * * @author Edward A. Lee * @author Soroush Bateni @@ -11,37 +12,39 @@ target C { timeout: 4900 msec } -import Contained from "../LoopDistributedCentralizedPrecedenceHierarchy.lf"; +import Contained from "../LoopDistributedCentralizedPrecedenceHierarchy.lf" -reactor Looper(incr:int(1), delay:time(0 msec), stp_offset:time(0)) { - input in:int; - output out:int; - state count:int(0); - timer t(0, 1 sec); +reactor Looper(incr: int = 1, delay: time = 0 msec, stp_offset: time = 0) { + input in: int + output out: int + state count: int = 0 + timer t(0, 1 sec) - c = new Contained(incr = incr); + c = new Contained(incr = incr) + in -> c.in reaction(t) -> out {= lf_set(out, self->count); self->count += self->incr; =} + reaction(in) {= instant_t time_lag = lf_time_physical() - lf_time_logical(); char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 lf_readable_time(time_buffer, time_lag); lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} STP (stp_offset) {= + =} STP(stp_offset) {= instant_t time_lag = lf_time_physical() - lf_time_logical(); char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 lf_readable_time(time_buffer, time_lag); lf_print("STP offset was violated. Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} deadline (10 msec) {= + =} deadline(10 msec) {= instant_t time_lag = lf_time_physical() - lf_time_logical(); char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 lf_readable_time(time_buffer, time_lag); lf_print("Deadline miss. Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); =} - in->c.in; + reaction(shutdown) {= lf_print("******* Shutdown invoked."); if (self->count != 5 * self->incr) { @@ -49,9 +52,10 @@ reactor Looper(incr:int(1), delay:time(0 msec), stp_offset:time(0)) { } =} } -federated reactor (delay:time(0)) { - left = new Looper(stp_offset = 5 msec); - right = new Looper(incr = -1, stp_offset = 5 msec); - left.out -> right.in; - right.out -> left.in; + +federated reactor(delay: time = 0) { + left = new Looper(stp_offset = 5 msec) + right = new Looper(incr = -1, stp_offset = 5 msec) + left.out -> right.in + right.out -> left.in } diff --git a/test/C/src/lib/Count.lf b/test/C/src/lib/Count.lf index fc95ead637..70291e783f 100644 --- a/test/C/src/lib/Count.lf +++ b/test/C/src/lib/Count.lf @@ -1,7 +1,7 @@ target C -reactor Count(offset: time(0), period: time(1 sec)) { - state count: int(1) +reactor Count(offset: time = 0, period: time = 1 sec) { + state count: int = 1 output out: int timer t(offset, period) diff --git a/test/C/src/lib/InternalDelay.lf b/test/C/src/lib/InternalDelay.lf index 013b916ecc..fbbf2f0cb6 100644 --- a/test/C/src/lib/InternalDelay.lf +++ b/test/C/src/lib/InternalDelay.lf @@ -1,6 +1,6 @@ target C -reactor InternalDelay(delay: int(10 msec)) { +reactor InternalDelay(delay: int = 10 msec) { input in: int output out: int logical action d: int diff --git a/test/C/src/lib/LoopedActionSender.lf b/test/C/src/lib/LoopedActionSender.lf index 2e24f1677f..b996fe6ac5 100644 --- a/test/C/src/lib/LoopedActionSender.lf +++ b/test/C/src/lib/LoopedActionSender.lf @@ -11,10 +11,10 @@ target C * @param break_interval: Determines how long the reactor should take a break * after sending take_a_break_after messages. */ -reactor Sender(take_a_break_after: int(10), break_interval: time(400 msec)) { +reactor Sender(take_a_break_after: int = 10, break_interval: time = 400 msec) { output out: int logical action act - state sent_messages: int(0) + state sent_messages: int = 0 reaction(startup, act) -> act, out {= // Send a message on out diff --git a/test/C/src/lib/Test.lf b/test/C/src/lib/Test.lf index ea341ae772..3ad7518d4e 100644 --- a/test/C/src/lib/Test.lf +++ b/test/C/src/lib/Test.lf @@ -1,8 +1,8 @@ target C -reactor TestDouble(expected: double[](1.0, 1.0, 1.0, 1.0)) { +reactor TestDouble(expected: double[] = {1.0, 1.0, 1.0, 1.0}) { input in: double - state count: int(0) + state count: int = 0 reaction(in) {= printf("Received: %f\n", in->value); diff --git a/test/C/src/lib/TestCount.lf b/test/C/src/lib/TestCount.lf index 3db3fbb2fc..d3f29aec6c 100644 --- a/test/C/src/lib/TestCount.lf +++ b/test/C/src/lib/TestCount.lf @@ -9,9 +9,9 @@ */ target C -reactor TestCount(start: int(1), stride: int(1), num_inputs: int(1)) { - state count: int(start) - state inputs_received: int(0) +reactor TestCount(start: int = 1, stride: int = 1, num_inputs: int = 1) { + state count: int = start + state inputs_received: int = 0 input in: int reaction(in) {= diff --git a/test/C/src/lib/TestCountMultiport.lf b/test/C/src/lib/TestCountMultiport.lf index 2a24922ef8..5a2db4b029 100644 --- a/test/C/src/lib/TestCountMultiport.lf +++ b/test/C/src/lib/TestCountMultiport.lf @@ -12,13 +12,13 @@ target C reactor TestCountMultiport( - start: int(1), - stride: int(1), - num_inputs: int(1), - width: int(2) + start: int = 1, + stride: int = 1, + num_inputs: int = 1, + width: int = 2 ) { - state count: int(start) - state inputs_received: int(0) + state count: int = start + state inputs_received: int = 0 input[width] in: int reaction(in) {= diff --git a/test/C/src/modal_models/ConvertCaseTest.lf b/test/C/src/modal_models/ConvertCaseTest.lf index 494a3c273c..5475edaa35 100644 --- a/test/C/src/modal_models/ConvertCaseTest.lf +++ b/test/C/src/modal_models/ConvertCaseTest.lf @@ -83,9 +83,9 @@ reactor Converter { } } -reactor InputFeeder(message: string("")) { +reactor InputFeeder(message: string = "") { output character: char - state idx: int(0) + state idx: int = 0 timer t(0, 250 msec) diff --git a/test/C/src/modal_models/Count3Modes.lf b/test/C/src/modal_models/Count3Modes.lf index 5ef26ccde0..862915abed 100644 --- a/test/C/src/modal_models/Count3Modes.lf +++ b/test/C/src/modal_models/Count3Modes.lf @@ -34,7 +34,7 @@ main reactor { timer stepper(0, 250 msec) counter = new CounterCycle() - state expected_value: int(1) + state expected_value: int = 1 // Trigger reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} diff --git a/test/C/src/modal_models/MixedReactions.lf b/test/C/src/modal_models/MixedReactions.lf index e0c9c7f0f7..78ea39c95c 100644 --- a/test/C/src/modal_models/MixedReactions.lf +++ b/test/C/src/modal_models/MixedReactions.lf @@ -8,8 +8,8 @@ target C { } main reactor { - state x: int(0) - state first: bool(true) + state x: int = 0 + state first: bool = true timer t(0, 100 msec) diff --git a/test/C/src/modal_models/ModalAfter.lf b/test/C/src/modal_models/ModalAfter.lf index 038a368cc9..270fd88d05 100644 --- a/test/C/src/modal_models/ModalAfter.lf +++ b/test/C/src/modal_models/ModalAfter.lf @@ -45,7 +45,7 @@ reactor Modal { } } -reactor Producer(mode_id: int(0)) { +reactor Producer(mode_id: int = 0) { output product: int timer t(0, 750 msec) @@ -56,7 +56,7 @@ reactor Producer(mode_id: int(0)) { =} } -reactor Consumer(mode_id: int(0)) { +reactor Consumer(mode_id: int = 0) { input product: int output report: int diff --git a/test/C/src/modal_models/ModalCycleBreaker.lf b/test/C/src/modal_models/ModalCycleBreaker.lf index 680323a729..cee4fabfec 100644 --- a/test/C/src/modal_models/ModalCycleBreaker.lf +++ b/test/C/src/modal_models/ModalCycleBreaker.lf @@ -42,11 +42,11 @@ reactor Modal { } } -reactor Counter(period: time(1 sec)) { +reactor Counter(period: time = 1 sec) { output value: int timer t(0, period) - state curval: int(0) + state curval: int = 0 reaction(t) -> value {= lf_set(value, self->curval++); =} } diff --git a/test/C/src/modal_models/ModalStateReset.lf b/test/C/src/modal_models/ModalStateReset.lf index cd963cfd8d..61563162b6 100644 --- a/test/C/src/modal_models/ModalStateReset.lf +++ b/test/C/src/modal_models/ModalStateReset.lf @@ -14,7 +14,7 @@ reactor Modal { output count1: int output count2: int - state counter0: int(0) + state counter0: int = 0 reaction(next) -> count0 {= printf("Counter0: %d\n", self->counter0); @@ -22,7 +22,7 @@ reactor Modal { =} initial mode One { - state counter1: int(0) + state counter1: int = 0 timer T1(0 msec, 250 msec) reaction(reset) {= self->counter1 = 0; =} @@ -39,7 +39,7 @@ reactor Modal { } mode Two { - state counter2: int(-2) + state counter2: int = -2 timer T2(0 msec, 250 msec) reaction(reset) {= self->counter2 = -2; =} diff --git a/test/C/src/modal_models/ModalStateResetAuto.lf b/test/C/src/modal_models/ModalStateResetAuto.lf index 24cfe9b187..a2b6b105f0 100644 --- a/test/C/src/modal_models/ModalStateResetAuto.lf +++ b/test/C/src/modal_models/ModalStateResetAuto.lf @@ -14,7 +14,7 @@ reactor Modal { output count1: int output count2: int - state counter0: int(0) + state counter0: int = 0 reaction(next) -> count0 {= printf("Counter0: %d\n", self->counter0); @@ -22,7 +22,7 @@ reactor Modal { =} initial mode One { - state counter1: int(0) + state counter1: int = 0 timer T1(0 msec, 250 msec) reaction(T1) -> count1 {= printf("Counter1: %d\n", self->counter1); @@ -37,7 +37,7 @@ reactor Modal { } mode Two { - reset state counter2: int(-2) + reset state counter2: int = -2 timer T2(0 msec, 250 msec) reaction(T2) -> count2 {= printf("Counter2: %d\n", self->counter2); diff --git a/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf b/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf index 7e75afec13..60fa76dd1e 100644 --- a/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf +++ b/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf @@ -28,11 +28,11 @@ reactor Modal { } } -reactor Counter(period: time(1 sec)) { +reactor Counter(period: time = 1 sec) { output value: int timer t(0, period) - reset state curval: int(0) + reset state curval: int = 0 reaction(t) -> value {= lf_set(value, self->curval++); =} } diff --git a/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf b/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf index 48b335d2b3..dff82c602f 100644 --- a/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf +++ b/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf @@ -31,11 +31,11 @@ reactor Modal { } } -reactor Counter(period: time(1 sec)) { +reactor Counter(period: time = 1 sec) { output value: int timer t(0, period) - reset state curval: int(0) + reset state curval: int = 0 reaction(t) -> value {= lf_set(value, self->curval++); =} } diff --git a/test/C/src/modal_models/util/TraceTesting.lf b/test/C/src/modal_models/util/TraceTesting.lf index 7d5a335db2..247b3f1def 100644 --- a/test/C/src/modal_models/util/TraceTesting.lf +++ b/test/C/src/modal_models/util/TraceTesting.lf @@ -6,17 +6,17 @@ preamble {= =} reactor TraceTesting( - events_size: int(0), - trace_size: int(0), - trace: int[](0), - training: bool(false) + events_size: int = 0, + trace_size: int = 0, + trace: int[] = 0, + training: bool = false ) { input[events_size] events: int - state last_reaction_time: int(0) - state trace_idx: int(0) - state recorded_events: int*(0) - state recorded_events_next: int(0) + state last_reaction_time: int = 0 + state trace_idx: int = 0 + state recorded_events: int* = 0 + state recorded_events_next: int = 0 reaction(startup) {= self->last_reaction_time = lf_time_logical(); =} diff --git a/test/C/src/multiport/BankIndexInitializer.lf b/test/C/src/multiport/BankIndexInitializer.lf index b9b8803943..d8a2c5766e 100644 --- a/test/C/src/multiport/BankIndexInitializer.lf +++ b/test/C/src/multiport/BankIndexInitializer.lf @@ -3,15 +3,15 @@ target C preamble {= int table[] = {4, 3, 2, 1}; =} -reactor Source(bank_index: int(0), value: int(0)) { +reactor Source(bank_index: int = 0, value: int = 0) { output out: int reaction(startup) -> out {= lf_set(out, self->value); =} } -reactor Sink(width: int(4)) { +reactor Sink(width: int = 4) { input[width] in: int - state received: bool(false) + state received: bool = false reaction(in) {= for (int idx = 0; idx < in_width; idx++) { @@ -32,7 +32,7 @@ reactor Sink(width: int(4)) { =} } -main reactor(width: int(4)) { +main reactor(width: int = 4) { source = new[width] Source(value = {= table[bank_index] =}) sink = new Sink(width = width) source.out -> sink.in diff --git a/test/C/src/multiport/BankMultiportToReaction.lf b/test/C/src/multiport/BankMultiportToReaction.lf index c2eff34100..731cd6891b 100644 --- a/test/C/src/multiport/BankMultiportToReaction.lf +++ b/test/C/src/multiport/BankMultiportToReaction.lf @@ -13,8 +13,8 @@ reactor DoubleCount { } main reactor { - state count: int(1) - state received: bool(false) + state count: int = 1 + state received: bool = false s = new[2] DoubleCount() diff --git a/test/C/src/multiport/BankReactionsInContainer.lf b/test/C/src/multiport/BankReactionsInContainer.lf index 6533e7ed0b..98d7cf4e1f 100644 --- a/test/C/src/multiport/BankReactionsInContainer.lf +++ b/test/C/src/multiport/BankReactionsInContainer.lf @@ -5,10 +5,10 @@ target C { timeout: 1 sec } -reactor R(bank_index: int(0)) { +reactor R(bank_index: int = 0) { output[2] out: int input[2] in: int - state received: bool(false) + state received: bool = false reaction(startup) -> out {= for (int i = 0; i < out_width; i++) { @@ -42,7 +42,7 @@ reactor R(bank_index: int(0)) { main reactor { s = new[2] R() - state received: bool(false) + state received: bool = false reaction(startup) -> s.in {= int count = 0; diff --git a/test/C/src/multiport/BankSelfBroadcast.lf b/test/C/src/multiport/BankSelfBroadcast.lf index 587087d550..e1ffb4b2dd 100644 --- a/test/C/src/multiport/BankSelfBroadcast.lf +++ b/test/C/src/multiport/BankSelfBroadcast.lf @@ -7,10 +7,10 @@ */ target C -reactor A(bank_index: int(0)) { +reactor A(bank_index: int = 0) { input[4] in: int output out: int - state received: bool(false) + state received: bool = false reaction(startup) -> out {= lf_set(out, self->bank_index); =} diff --git a/test/C/src/multiport/BankToBank.lf b/test/C/src/multiport/BankToBank.lf index 19a784efd4..beb3a32fa8 100644 --- a/test/C/src/multiport/BankToBank.lf +++ b/test/C/src/multiport/BankToBank.lf @@ -4,10 +4,10 @@ target C { fast: true } -reactor Source(bank_index: int(0)) { +reactor Source(bank_index: int = 0) { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= lf_set(out, self->s); @@ -15,8 +15,8 @@ reactor Source(bank_index: int(0)) { =} } -reactor Destination(bank_index: int(0)) { - state s: int(0) +reactor Destination(bank_index: int = 0) { + state s: int = 0 input in: int reaction(in) {= @@ -37,7 +37,7 @@ reactor Destination(bank_index: int(0)) { =} } -main reactor BankToBank(width: int(4)) { +main reactor BankToBank(width: int = 4) { a = new[width] Source() b = new[width] Destination() a.out -> b.in diff --git a/test/C/src/multiport/BankToBankMultiport.lf b/test/C/src/multiport/BankToBankMultiport.lf index 22c5821cc6..681538f116 100644 --- a/test/C/src/multiport/BankToBankMultiport.lf +++ b/test/C/src/multiport/BankToBankMultiport.lf @@ -4,10 +4,10 @@ target C { fast: true } -reactor Source(width: int(1)) { +reactor Source(width: int = 1) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < out_width; i++) { @@ -16,8 +16,8 @@ reactor Source(width: int(1)) { =} } -reactor Destination(width: int(1)) { - state s: int(6) +reactor Destination(width: int = 1) { + state s: int = 6 input[width] in: int reaction(in) {= @@ -42,7 +42,7 @@ reactor Destination(width: int(1)) { =} } -main reactor BankToBankMultiport(bank_width: int(4)) { +main reactor BankToBankMultiport(bank_width: int = 4) { a = new[bank_width] Source(width = 4) b = new[bank_width] Destination(width = 4) a.out -> b.in diff --git a/test/C/src/multiport/BankToBankMultiportAfter.lf b/test/C/src/multiport/BankToBankMultiportAfter.lf index 38daec6ccf..db0ff7771e 100644 --- a/test/C/src/multiport/BankToBankMultiportAfter.lf +++ b/test/C/src/multiport/BankToBankMultiportAfter.lf @@ -4,10 +4,10 @@ target C { fast: true } -reactor Source(width: int(1)) { +reactor Source(width: int = 1) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < out_width; i++) { @@ -16,8 +16,8 @@ reactor Source(width: int(1)) { =} } -reactor Destination(width: int(1)) { - state s: int(6) +reactor Destination(width: int = 1) { + state s: int = 6 input[width] in: int reaction(in) {= @@ -42,7 +42,7 @@ reactor Destination(width: int(1)) { =} } -main reactor(bank_width: int(4)) { +main reactor(bank_width: int = 4) { a = new[bank_width] Source(width = 4) b = new[bank_width] Destination(width = 4) a.out -> b.in after 200 msec diff --git a/test/C/src/multiport/BankToMultiport.lf b/test/C/src/multiport/BankToMultiport.lf index ee0ad53dc3..f72c104df7 100644 --- a/test/C/src/multiport/BankToMultiport.lf +++ b/test/C/src/multiport/BankToMultiport.lf @@ -1,15 +1,15 @@ // Test bank of reactors to multiport input with id parameter in the bank. target C -reactor Source(bank_index: int(0)) { +reactor Source(bank_index: int = 0) { output out: int reaction(startup) -> out {= lf_set(out, self->bank_index); =} } -reactor Sink(width: int(4)) { +reactor Sink(width: int = 4) { input[width] in: int - state received: bool(false) + state received: bool = false reaction(in) {= for (int i = 0; i < in_width; i++) { @@ -32,7 +32,7 @@ reactor Sink(width: int(4)) { =} } -main reactor BankToMultiport(width: int(5)) { +main reactor BankToMultiport(width: int = 5) { source = new[width] Source() sink = new Sink(width = width) source.out -> sink.in diff --git a/test/C/src/multiport/BankToReaction.lf b/test/C/src/multiport/BankToReaction.lf index c5d68cfe41..4e59352bd5 100644 --- a/test/C/src/multiport/BankToReaction.lf +++ b/test/C/src/multiport/BankToReaction.lf @@ -6,7 +6,7 @@ target C { import Count from "../lib/Count.lf" main reactor { - state count: int(1) + state count: int = 1 s = new[2] Count() diff --git a/test/C/src/multiport/Broadcast.lf b/test/C/src/multiport/Broadcast.lf index dee0ad62ed..e3471da5f6 100644 --- a/test/C/src/multiport/Broadcast.lf +++ b/test/C/src/multiport/Broadcast.lf @@ -9,9 +9,9 @@ reactor Source { reaction(startup) -> out {= lf_set(out, 42); =} } -reactor Destination(bank_index: int(0)) { +reactor Destination(bank_index: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= printf("Destination %d received %d.\n", self->bank_index, in->value); diff --git a/test/C/src/multiport/BroadcastAfter.lf b/test/C/src/multiport/BroadcastAfter.lf index b66979e182..c1be635e55 100644 --- a/test/C/src/multiport/BroadcastAfter.lf +++ b/test/C/src/multiport/BroadcastAfter.lf @@ -9,9 +9,9 @@ reactor Source { reaction(startup) -> out {= lf_set(out, 42); =} } -reactor Destination(bank_index: int(0)) { +reactor Destination(bank_index: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= printf("Destination %d received %d.\n", self->bank_index, in->value); diff --git a/test/C/src/multiport/BroadcastMultipleAfter.lf b/test/C/src/multiport/BroadcastMultipleAfter.lf index b83540e3d4..97d853e4ce 100644 --- a/test/C/src/multiport/BroadcastMultipleAfter.lf +++ b/test/C/src/multiport/BroadcastMultipleAfter.lf @@ -3,15 +3,15 @@ target C { fast: true } -reactor Source(value: int(42)) { +reactor Source(value: int = 42) { output out: int reaction(startup) -> out {= lf_set(out, self->value); =} } -reactor Destination(bank_index: int(0)) { +reactor Destination(bank_index: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= printf("Destination %d received %d.\n", self->bank_index, in->value); diff --git a/test/C/src/multiport/DualBanks.lf b/test/C/src/multiport/DualBanks.lf index aa8faf4b75..3cb5d38887 100644 --- a/test/C/src/multiport/DualBanks.lf +++ b/test/C/src/multiport/DualBanks.lf @@ -1,8 +1,8 @@ target C -reactor Base(bank_index: int(0)) { +reactor Base(bank_index: int = 0) { input I: int - state received: bool(false) + state received: bool = false reaction(shutdown) {= if(!self->received) { diff --git a/test/C/src/multiport/DualBanksMultiport.lf b/test/C/src/multiport/DualBanksMultiport.lf index 42c4adb11e..a5c2120a79 100644 --- a/test/C/src/multiport/DualBanksMultiport.lf +++ b/test/C/src/multiport/DualBanksMultiport.lf @@ -1,8 +1,8 @@ target C -reactor Base(bank_index: int(0)) { +reactor Base(bank_index: int = 0) { input[2] I: int - state received: bool(false) + state received: bool = false reaction(shutdown) {= if(!self->received) { diff --git a/test/C/src/multiport/FullyConnected.lf b/test/C/src/multiport/FullyConnected.lf index 8a26fee83f..758ecf1580 100644 --- a/test/C/src/multiport/FullyConnected.lf +++ b/test/C/src/multiport/FullyConnected.lf @@ -1,10 +1,10 @@ target C -reactor Node(num_nodes: size_t(4), bank_index: int(0)) { +reactor Node(num_nodes: size_t = 4, bank_index: int = 0) { input[num_nodes] in: int output out: int - state received: bool(false) + state received: bool = false reaction(startup) -> out {= lf_print("Hello from node %d!", self->bank_index); @@ -35,7 +35,7 @@ reactor Node(num_nodes: size_t(4), bank_index: int(0)) { =} } -main reactor(num_nodes: size_t(4)) { +main reactor(num_nodes: size_t = 4) { nodes = new[num_nodes] Node(num_nodes = num_nodes) (nodes.out)+ -> nodes.in } diff --git a/test/C/src/multiport/FullyConnectedAddressable.lf b/test/C/src/multiport/FullyConnectedAddressable.lf index ae99d5397e..91b0f5caac 100644 --- a/test/C/src/multiport/FullyConnectedAddressable.lf +++ b/test/C/src/multiport/FullyConnectedAddressable.lf @@ -1,12 +1,12 @@ // In this pattern, each node can send direct messages to individual other nodes target C -reactor Node(num_nodes: size_t(4), bank_index: int(0)) { +reactor Node(num_nodes: size_t = 4, bank_index: int = 0) { input[num_nodes] in: int output[num_nodes] out: int - state received: int(0) - state triggered: bool(false) + state received: int = 0 + state triggered: bool = false reaction(startup) -> out {= int outChannel = (self->bank_index + 1) % self->num_nodes; @@ -45,7 +45,7 @@ reactor Node(num_nodes: size_t(4), bank_index: int(0)) { =} } -main reactor(num_nodes: size_t(4)) { +main reactor(num_nodes: size_t = 4) { nodes1 = new[num_nodes] Node(num_nodes = num_nodes) nodes1.out -> interleaved (nodes1.in) diff --git a/test/C/src/multiport/FullyConnectedAddressableAfter.lf b/test/C/src/multiport/FullyConnectedAddressableAfter.lf index cd6dc4cf85..1d30430deb 100644 --- a/test/C/src/multiport/FullyConnectedAddressableAfter.lf +++ b/test/C/src/multiport/FullyConnectedAddressableAfter.lf @@ -3,7 +3,7 @@ target C import Node from "FullyConnectedAddressable.lf" -main reactor(num_nodes: size_t(4)) { +main reactor(num_nodes: size_t = 4) { nodes1 = new[num_nodes] Node(num_nodes = num_nodes) nodes1.out -> interleaved (nodes1.in) after 200 msec diff --git a/test/C/src/multiport/MultiportFromBank.lf b/test/C/src/multiport/MultiportFromBank.lf index b8ade7a354..1b49786060 100644 --- a/test/C/src/multiport/MultiportFromBank.lf +++ b/test/C/src/multiport/MultiportFromBank.lf @@ -5,7 +5,7 @@ target C { fast: true } -reactor Source(check_override: int(0), bank_index: int(0)) { +reactor Source(check_override: int = 0, bank_index: int = 0) { output out: int reaction(startup) -> out {= @@ -13,9 +13,9 @@ reactor Source(check_override: int(0), bank_index: int(0)) { =} } -reactor Destination(port_width: int(3)) { +reactor Destination(port_width: int = 3) { input[port_width] in: int - state received: bool(false) + state received: bool = false reaction(in) {= for (int i = 0; i < in_width; i++) { @@ -37,7 +37,7 @@ reactor Destination(port_width: int(3)) { =} } -main reactor MultiportFromBank(width: int(4)) { +main reactor MultiportFromBank(width: int = 4) { a = new[width] Source(check_override = 1) b = new Destination(port_width = width) a.out -> b.in diff --git a/test/C/src/multiport/MultiportFromBankHierarchy.lf b/test/C/src/multiport/MultiportFromBankHierarchy.lf index c38046107c..e8ee6194b5 100644 --- a/test/C/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/C/src/multiport/MultiportFromBankHierarchy.lf @@ -7,13 +7,13 @@ target C { import Source, Destination from "MultiportFromBank.lf" -reactor Container(port_width: int(3)) { +reactor Container(port_width: int = 3) { output[port_width] out: int s = new[port_width] Source(check_override = 1) s.out -> out } -main reactor(width: int(4)) { +main reactor(width: int = 4) { a = new Container(port_width = width) b = new Destination(port_width = width) a.out -> b.in diff --git a/test/C/src/multiport/MultiportFromHierarchy.lf b/test/C/src/multiport/MultiportFromHierarchy.lf index f38661345c..8323210946 100644 --- a/test/C/src/multiport/MultiportFromHierarchy.lf +++ b/test/C/src/multiport/MultiportFromHierarchy.lf @@ -5,10 +5,10 @@ target C { fast: true } -reactor Source(width: int(3)) { +reactor Source(width: int = 3) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < out_width; i++) { @@ -17,8 +17,8 @@ reactor Source(width: int(3)) { =} } -reactor Destination(width: int(3)) { - state s: int(6) +reactor Destination(width: int = 3) { + state s: int = 6 input[width] in: int reaction(in) {= @@ -43,19 +43,19 @@ reactor Destination(width: int(3)) { =} } -reactor Container(width: int(3)) { +reactor Container(width: int = 3) { output[width] out: int src = new InsideContainer(width = width) src.out -> out } -reactor InsideContainer(width: int(3)) { +reactor InsideContainer(width: int = 3) { output[width] out: int src = new Source(width = width) src.out -> out } -main reactor MultiportFromHierarchy(width: int(4)) { +main reactor MultiportFromHierarchy(width: int = 4) { a = new Container(width = width) b = new Destination(width = width) a.out -> b.in diff --git a/test/C/src/multiport/MultiportFromReaction.lf b/test/C/src/multiport/MultiportFromReaction.lf index acaa59e519..33cbfffd83 100644 --- a/test/C/src/multiport/MultiportFromReaction.lf +++ b/test/C/src/multiport/MultiportFromReaction.lf @@ -4,8 +4,8 @@ target C { fast: true } -reactor Destination(width: int(1)) { - state s: int(6) +reactor Destination(width: int = 1) { + state s: int = 6 input[width] in: int reaction(in) {= @@ -30,9 +30,9 @@ reactor Destination(width: int(1)) { =} } -main reactor MultiportFromReaction(width: int(4)) { +main reactor MultiportFromReaction(width: int = 4) { timer t(0, 200 msec) - state s: int(0) + state s: int = 0 b = new Destination(width = width) reaction(t) -> b.in {= diff --git a/test/C/src/multiport/MultiportIn.lf b/test/C/src/multiport/MultiportIn.lf index 80269896d8..b87a91a79b 100644 --- a/test/C/src/multiport/MultiportIn.lf +++ b/test/C/src/multiport/MultiportIn.lf @@ -8,7 +8,7 @@ target C { reactor Source { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= lf_set(out, self->s); @@ -24,7 +24,7 @@ reactor Computation { } reactor Destination { - state s: int(0) + state s: int = 0 input[4] in: int reaction(in) {= diff --git a/test/C/src/multiport/MultiportInParameterized.lf b/test/C/src/multiport/MultiportInParameterized.lf index cd9bb27ad2..bf7ec93f6e 100644 --- a/test/C/src/multiport/MultiportInParameterized.lf +++ b/test/C/src/multiport/MultiportInParameterized.lf @@ -8,7 +8,7 @@ target C { reactor Source { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= lf_set(out, self->s); @@ -23,8 +23,8 @@ reactor Computation { reaction(in) -> out {= lf_set(out, in->value); =} } -reactor Destination(width: int(1)) { - state s: int(0) +reactor Destination(width: int = 1) { + state s: int = 0 input[width] in: int reaction(in) {= diff --git a/test/C/src/multiport/MultiportMutableInput.lf b/test/C/src/multiport/MultiportMutableInput.lf index d1b0994012..e1f8d579c2 100644 --- a/test/C/src/multiport/MultiportMutableInput.lf +++ b/test/C/src/multiport/MultiportMutableInput.lf @@ -12,7 +12,7 @@ reactor Source { =} } -reactor Print(scale: int(1)) { // The scale parameter is just for testing. +reactor Print(scale: int = 1) { // The scale parameter is just for testing. input[2] in: int reaction(in) {= @@ -27,7 +27,7 @@ reactor Print(scale: int(1)) { // The scale parameter is just for testing. =} } -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { mutable input[2] in: int output[2] out: int diff --git a/test/C/src/multiport/MultiportMutableInputArray.lf b/test/C/src/multiport/MultiportMutableInputArray.lf index cd279bb6a2..90907e4f44 100644 --- a/test/C/src/multiport/MultiportMutableInputArray.lf +++ b/test/C/src/multiport/MultiportMutableInputArray.lf @@ -26,7 +26,7 @@ reactor Source { =} } -reactor Print(scale: int(1)) { // The scale parameter is just for testing. +reactor Print(scale: int = 1) { // The scale parameter is just for testing. input[2] in: int[] reaction(in) {= @@ -52,7 +52,7 @@ reactor Print(scale: int(1)) { // The scale parameter is just for testing. =} } -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { mutable input[2] in: int[] output[2] out: int[] diff --git a/test/C/src/multiport/MultiportOut.lf b/test/C/src/multiport/MultiportOut.lf index c2707d5d33..38365d217a 100644 --- a/test/C/src/multiport/MultiportOut.lf +++ b/test/C/src/multiport/MultiportOut.lf @@ -7,7 +7,7 @@ target C { reactor Source { timer t(0, 200 msec) output[4] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < 4; i++) { @@ -31,7 +31,7 @@ reactor Computation { } reactor Destination { - state s: int(0) + state s: int = 0 input[4] in: int reaction(in) {= diff --git a/test/C/src/multiport/MultiportToBank.lf b/test/C/src/multiport/MultiportToBank.lf index c1f19d3553..86146b9818 100644 --- a/test/C/src/multiport/MultiportToBank.lf +++ b/test/C/src/multiport/MultiportToBank.lf @@ -4,7 +4,7 @@ target C { fast: true } -reactor Source(width: int(2)) { +reactor Source(width: int = 2) { output[width] out: int // Connected to a bank of Destination reactors input dummy: int // Not connected to anything @@ -24,9 +24,9 @@ reactor Source(width: int(2)) { =} } -reactor Destination(bank_index: int(0)) { +reactor Destination(bank_index: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= printf("Destination %d received %d.\n", self->bank_index, in->value); @@ -46,7 +46,7 @@ reactor Destination(bank_index: int(0)) { =} } -main reactor MultiportToBank(width: int(3)) { +main reactor MultiportToBank(width: int = 3) { a = new Source(width = width) b = new[width] Destination() a.out -> b.in diff --git a/test/C/src/multiport/MultiportToBankAfter.lf b/test/C/src/multiport/MultiportToBankAfter.lf index 66e0fdf837..ba26142243 100644 --- a/test/C/src/multiport/MultiportToBankAfter.lf +++ b/test/C/src/multiport/MultiportToBankAfter.lf @@ -5,7 +5,7 @@ target C { fast: true } -reactor Source(width: int(2)) { +reactor Source(width: int = 2) { output[width] out: int reaction(startup) -> out {= @@ -15,9 +15,9 @@ reactor Source(width: int(2)) { =} } -reactor Destination(bank_index: int(0)) { +reactor Destination(bank_index: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= printf("Destination %d received %d.\n", self->bank_index, in->value); @@ -41,7 +41,7 @@ reactor Destination(bank_index: int(0)) { =} } -main reactor(width: int(3)) { +main reactor(width: int = 3) { a = new Source(width = width) b = new[width] Destination() a.out -> b.in after 1 sec // Width of the bank of delays will be inferred. diff --git a/test/C/src/multiport/MultiportToBankDouble.lf b/test/C/src/multiport/MultiportToBankDouble.lf index a116ef9c00..444f02d170 100644 --- a/test/C/src/multiport/MultiportToBankDouble.lf +++ b/test/C/src/multiport/MultiportToBankDouble.lf @@ -24,9 +24,9 @@ reactor Source { =} } -reactor Destination(bank_index: int(0)) { +reactor Destination(bank_index: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= printf("Destination %d received %d.\n", self->bank_index, in->value); diff --git a/test/C/src/multiport/MultiportToBankHierarchy.lf b/test/C/src/multiport/MultiportToBankHierarchy.lf index e4f231390f..fbdc531bf0 100644 --- a/test/C/src/multiport/MultiportToBankHierarchy.lf +++ b/test/C/src/multiport/MultiportToBankHierarchy.lf @@ -5,7 +5,7 @@ target C { fast: true } -reactor Source(width: int(2)) { +reactor Source(width: int = 2) { output[width] out: int reaction(startup) -> out {= @@ -15,9 +15,9 @@ reactor Source(width: int(2)) { =} } -reactor Destination(bank_index: int(0)) { +reactor Destination(bank_index: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= printf("Destination %d received %d.\n", self->bank_index, in->value); @@ -37,13 +37,13 @@ reactor Destination(bank_index: int(0)) { =} } -reactor Container(width: int(2)) { +reactor Container(width: int = 2) { input[width] in: int c = new[width] Destination() in -> c.in } -main reactor MultiportToBankHierarchy(width: int(3)) { +main reactor MultiportToBankHierarchy(width: int = 3) { a = new Source(width = width) b = new Container(width = width) a.out -> b.in diff --git a/test/C/src/multiport/MultiportToHierarchy.lf b/test/C/src/multiport/MultiportToHierarchy.lf index 24290b56a5..41ca505077 100644 --- a/test/C/src/multiport/MultiportToHierarchy.lf +++ b/test/C/src/multiport/MultiportToHierarchy.lf @@ -6,10 +6,10 @@ target C { fast: true } -reactor Source(width: int(2)) { +reactor Source(width: int = 2) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < 4; i++) { @@ -18,8 +18,8 @@ reactor Source(width: int(2)) { =} } -reactor Destination(width: int(4)) { - state s: int(6) +reactor Destination(width: int = 4) { + state s: int = 6 input[width] in: int reaction(in) {= @@ -44,13 +44,13 @@ reactor Destination(width: int(4)) { =} } -reactor Container(width: int(4)) { +reactor Container(width: int = 4) { input[width] in: int dst = new Destination() in -> dst.in } -main reactor MultiportToHierarchy(width: int(4)) { +main reactor MultiportToHierarchy(width: int = 4) { a = new Source(width = width) b = new Container(width = width) a.out -> b.in diff --git a/test/C/src/multiport/MultiportToMultiport.lf b/test/C/src/multiport/MultiportToMultiport.lf index bf4bbefde4..375fa080e2 100644 --- a/test/C/src/multiport/MultiportToMultiport.lf +++ b/test/C/src/multiport/MultiportToMultiport.lf @@ -4,10 +4,10 @@ target C { fast: true } -reactor Source(width: int(1)) { +reactor Source(width: int = 1) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < out_width; i++) { @@ -19,8 +19,8 @@ reactor Source(width: int(1)) { =} } -reactor Destination(width: int(1)) { - state s: int(6) +reactor Destination(width: int = 1) { + state s: int = 6 input[width] in: int reaction(in) {= @@ -45,7 +45,7 @@ reactor Destination(width: int(1)) { =} } -main reactor MultiportToMultiport(width: int(4)) { +main reactor MultiportToMultiport(width: int = 4) { a = new Source(width = width) b = new Destination(width = width) a.out -> b.in diff --git a/test/C/src/multiport/MultiportToMultiport2.lf b/test/C/src/multiport/MultiportToMultiport2.lf index 29a8632399..76858a2a86 100644 --- a/test/C/src/multiport/MultiportToMultiport2.lf +++ b/test/C/src/multiport/MultiportToMultiport2.lf @@ -1,7 +1,7 @@ // Test multiport to multiport connections. See also MultiportToMultiport. target C -reactor Source(width: int(2)) { +reactor Source(width: int = 2) { output[width] out: int reaction(startup) -> out {= @@ -11,7 +11,7 @@ reactor Source(width: int(2)) { =} } -reactor Destination(width: int(2)) { +reactor Destination(width: int = 2) { input[width] in: int reaction(in) {= @@ -30,9 +30,9 @@ reactor Destination(width: int(2)) { } main reactor MultiportToMultiport2( - width1: int(3), - width2: int(2), - width3: int(5) + width1: int = 3, + width2: int = 2, + width3: int = 5 ) { a1 = new Source(width = width1) a2 = new Source(width = width2) diff --git a/test/C/src/multiport/MultiportToMultiport2After.lf b/test/C/src/multiport/MultiportToMultiport2After.lf index b6f078a099..49585ea1b0 100644 --- a/test/C/src/multiport/MultiportToMultiport2After.lf +++ b/test/C/src/multiport/MultiportToMultiport2After.lf @@ -1,7 +1,7 @@ // Test multiport to multiport connections. See also MultiportToMultiport. target C -reactor Source(width: int(2)) { +reactor Source(width: int = 2) { output[width] out: int reaction(startup) -> out {= @@ -11,7 +11,7 @@ reactor Source(width: int(2)) { =} } -reactor Destination(width: int(2)) { +reactor Destination(width: int = 2) { input[width] in: int reaction(in) {= diff --git a/test/C/src/multiport/MultiportToMultiportArray.lf b/test/C/src/multiport/MultiportToMultiportArray.lf index 100a57c393..9d86a4a522 100644 --- a/test/C/src/multiport/MultiportToMultiportArray.lf +++ b/test/C/src/multiport/MultiportToMultiportArray.lf @@ -8,7 +8,7 @@ target C { reactor Source { timer t(0, 200 msec) output[2] out: int[] - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < 2; i++) { @@ -24,7 +24,7 @@ reactor Source { } reactor Destination { - state s: int(15) + state s: int = 15 input[2] in: int[] reaction(in) {= diff --git a/test/C/src/multiport/MultiportToMultiportParameter.lf b/test/C/src/multiport/MultiportToMultiportParameter.lf index 9dc7288a52..d1c96e5ddd 100644 --- a/test/C/src/multiport/MultiportToMultiportParameter.lf +++ b/test/C/src/multiport/MultiportToMultiportParameter.lf @@ -4,10 +4,10 @@ target C { fast: true } -reactor Source(width: int(1)) { +reactor Source(width: int = 1) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < out_width; i++) { @@ -19,8 +19,8 @@ reactor Source(width: int(1)) { =} } -reactor Destination(width: int(1)) { - state s: int(6) +reactor Destination(width: int = 1) { + state s: int = 6 input[width] in: int // Width is one larger than that of the source. reaction(in) {= @@ -45,7 +45,7 @@ reactor Destination(width: int(1)) { =} } -main reactor(width: int(4)) { +main reactor(width: int = 4) { a = new Source(width = width) b = new Destination(width = width) a.out -> b.in diff --git a/test/C/src/multiport/MultiportToPort.lf b/test/C/src/multiport/MultiportToPort.lf index ccee46566c..1784f2503c 100644 --- a/test/C/src/multiport/MultiportToPort.lf +++ b/test/C/src/multiport/MultiportToPort.lf @@ -16,9 +16,9 @@ reactor Source { =} } -reactor Destination(expected: int(0)) { +reactor Destination(expected: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= printf("Received: %d.\n", in->value); diff --git a/test/C/src/multiport/MultiportToReaction.lf b/test/C/src/multiport/MultiportToReaction.lf index 62e2c302f2..9281633079 100644 --- a/test/C/src/multiport/MultiportToReaction.lf +++ b/test/C/src/multiport/MultiportToReaction.lf @@ -4,9 +4,9 @@ target C { fast: true } -reactor Source(width: int(1)) { +reactor Source(width: int = 1) { timer t(0, 200 msec) - state s: int(0) + state s: int = 0 output[width] out: int reaction(t) -> out {= @@ -18,7 +18,7 @@ reactor Source(width: int(1)) { } main reactor MultiportToReaction { - state s: int(6) + state s: int = 6 b = new Source(width = 4) reaction(b.out) {= diff --git a/test/C/src/multiport/NestedBanks.lf b/test/C/src/multiport/NestedBanks.lf index b80ff2e606..bef08727f3 100644 --- a/test/C/src/multiport/NestedBanks.lf +++ b/test/C/src/multiport/NestedBanks.lf @@ -13,13 +13,13 @@ main reactor { (a.x)+ -> c.z, d.u, e.t } -reactor A(bank_index: int(0)) { +reactor A(bank_index: int = 0) { output[4] x: int b = new[2] B(a_bank_index = bank_index) b.y -> x } -reactor B(a_bank_index: int(0), bank_index: int(0)) { +reactor B(a_bank_index: int = 0, bank_index: int = 0) { output[2] y: int reaction(startup) -> y {= @@ -29,7 +29,7 @@ reactor B(a_bank_index: int(0), bank_index: int(0)) { =} } -reactor C(bank_index: int(0)) { +reactor C(bank_index: int = 0) { input[2] z: int f = new F(c_bank_index = bank_index) g = new G(c_bank_index = bank_index) @@ -59,7 +59,7 @@ reactor E { =} } -reactor F(c_bank_index: int(0)) { +reactor F(c_bank_index: int = 0) { input w: int reaction(w) {= @@ -70,7 +70,7 @@ reactor F(c_bank_index: int(0)) { =} } -reactor G(c_bank_index: int(0)) { +reactor G(c_bank_index: int = 0) { input s: int reaction(s) {= diff --git a/test/C/src/multiport/NestedInterleavedBanks.lf b/test/C/src/multiport/NestedInterleavedBanks.lf index 9f03313972..8e3056bd88 100644 --- a/test/C/src/multiport/NestedInterleavedBanks.lf +++ b/test/C/src/multiport/NestedInterleavedBanks.lf @@ -4,7 +4,7 @@ */ target C -reactor A(bank_index: int(0), outer_bank_index: int(0)) { +reactor A(bank_index: int = 0, outer_bank_index: int = 0) { output[2] p: int reaction(startup) -> p {= @@ -15,7 +15,7 @@ reactor A(bank_index: int(0), outer_bank_index: int(0)) { =} } -reactor B(bank_index: int(0)) { +reactor B(bank_index: int = 0) { output[4] q: int a = new[2] A(outer_bank_index = bank_index) interleaved (a.p) -> q diff --git a/test/C/src/multiport/ReactionToContainedBank.lf b/test/C/src/multiport/ReactionToContainedBank.lf index 3e0afa17d5..30f3f5564c 100644 --- a/test/C/src/multiport/ReactionToContainedBank.lf +++ b/test/C/src/multiport/ReactionToContainedBank.lf @@ -6,9 +6,9 @@ target C { import TestCount from "../lib/TestCount.lf" -main reactor ReactionToContainedBank(width: int(2)) { +main reactor ReactionToContainedBank(width: int = 2) { timer t(0, 100 msec) - state count: int(1) + state count: int = 1 test = new[width] TestCount(num_inputs = 11) diff --git a/test/C/src/multiport/ReactionToContainedBank2.lf b/test/C/src/multiport/ReactionToContainedBank2.lf index b7c7d1cf92..e03e884558 100644 --- a/test/C/src/multiport/ReactionToContainedBank2.lf +++ b/test/C/src/multiport/ReactionToContainedBank2.lf @@ -6,9 +6,9 @@ target C { import TestCount from "../lib/TestCount.lf" -reactor ReactionToContainedBank(width: int(2)) { +reactor ReactionToContainedBank(width: int = 2) { timer t(0, 100 msec) - state count: int(1) + state count: int = 1 test = new[width] TestCount(num_inputs = 11) @@ -20,7 +20,7 @@ reactor ReactionToContainedBank(width: int(2)) { =} } -main reactor(width: int(2)) { +main reactor(width: int = 2) { a = new ReactionToContainedBank(width = width) b = new ReactionToContainedBank(width = 4) } diff --git a/test/C/src/multiport/ReactionToContainedBankMultiport.lf b/test/C/src/multiport/ReactionToContainedBankMultiport.lf index 6a9e067ca1..d84b21c191 100644 --- a/test/C/src/multiport/ReactionToContainedBankMultiport.lf +++ b/test/C/src/multiport/ReactionToContainedBankMultiport.lf @@ -7,9 +7,9 @@ target C { import TestCountMultiport from "../lib/TestCountMultiport.lf" -main reactor(width: int(2)) { +main reactor(width: int = 2) { timer t(0, 100 msec) - state count: int(1) + state count: int = 1 test = new[width] TestCountMultiport(num_inputs = 11, width = width) diff --git a/test/C/src/multiport/ReactionsToNested.lf b/test/C/src/multiport/ReactionsToNested.lf index 102df10f8b..4270f55c2d 100644 --- a/test/C/src/multiport/ReactionsToNested.lf +++ b/test/C/src/multiport/ReactionsToNested.lf @@ -4,9 +4,9 @@ target C { timeout: 1 sec } -reactor T(expected: int(0)) { +reactor T(expected: int = 0) { input z: int - state received: bool(false) + state received: bool = false reaction(z) {= lf_print("T received %d", z->value); diff --git a/test/C/src/multiport/Sparse.lf b/test/C/src/multiport/Sparse.lf index eaa75782cb..537daabb4b 100644 --- a/test/C/src/multiport/Sparse.lf +++ b/test/C/src/multiport/Sparse.lf @@ -3,9 +3,9 @@ target C { timeout: 20 ms } -reactor SparseSource(width: int(20)) { +reactor SparseSource(width: int = 20) { output[width] out: int - state count: int(0) + state count: int = 0 timer t(0, 1 msec) reaction(t) -> out {= @@ -19,7 +19,7 @@ reactor SparseSource(width: int(20)) { =} } -reactor SparseSink(width: int(20)) { +reactor SparseSink(width: int = 20) { input[width] in: int reaction(in) {= @@ -43,7 +43,7 @@ reactor SparseSink(width: int(20)) { =} } -main reactor(width: int(20)) { +main reactor(width: int = 20) { s = new SparseSource(width = width) d = new SparseSink(width = width) s.out -> d.in diff --git a/test/C/src/multiport/SparseFallback.lf b/test/C/src/multiport/SparseFallback.lf index 195dca1f19..a7788858d8 100644 --- a/test/C/src/multiport/SparseFallback.lf +++ b/test/C/src/multiport/SparseFallback.lf @@ -6,9 +6,9 @@ target C { timeout: 20 ms } -reactor SparseSource(width: int(20)) { +reactor SparseSource(width: int = 20) { output[width] out: int - state count: int(0) + state count: int = 0 timer t(0, 1 msec) reaction(t) -> out {= @@ -22,7 +22,7 @@ reactor SparseSource(width: int(20)) { =} } -reactor SparseSink(width: int(20)) { +reactor SparseSink(width: int = 20) { input[width] in: int reaction(in) {= @@ -46,7 +46,7 @@ reactor SparseSink(width: int(20)) { =} } -main reactor(width: int(10)) { +main reactor(width: int = 10) { s = new SparseSource(width = width) d = new SparseSink(width = width) s.out -> d.in diff --git a/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf b/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf index c696261db7..917982af39 100644 --- a/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf +++ b/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf @@ -10,7 +10,7 @@ target C { reactor Source { output a: int output b: int - state count: int(0) + state count: int = 0 timer t(0, 200 msec) reaction(t) -> a, b {= diff --git a/test/C/src/serialization/ROSBuiltInSerialization.lf b/test/C/src/serialization/ROSBuiltInSerialization.lf index d573b23cce..095aadacd2 100644 --- a/test/C/src/serialization/ROSBuiltInSerialization.lf +++ b/test/C/src/serialization/ROSBuiltInSerialization.lf @@ -32,7 +32,7 @@ reactor Sender { output out: std_msgs::msg::Int32 // state serialized_msg_pcl:rclcpp::SerializedMessage({=0u=}); - state count: int(0) + state count: int = 0 timer t(0, 1 sec) @@ -45,7 +45,7 @@ reactor Sender { reactor Receiver { input in: std_msgs::msg::Int32 - state count: int(0) + state count: int = 0 reaction(in) {= // Print the ROS2 message data diff --git a/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf b/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf index 4726809c57..97b5a12554 100644 --- a/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf +++ b/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf @@ -31,7 +31,7 @@ preamble {= reactor Sender { output out: std::shared_ptr - state count: int(0) + state count: int = 0 timer t(0, 1 sec) @@ -44,7 +44,7 @@ reactor Sender { reactor Receiver { input in: std::shared_ptr - state count: int(0) + state count: int = 0 reaction(in) {= // Print the ROS2 message data diff --git a/test/C/src/target/HelloWorldCCPP.lf b/test/C/src/target/HelloWorldCCPP.lf index 0b0e54ed52..91d1cd61d1 100644 --- a/test/C/src/target/HelloWorldCCPP.lf +++ b/test/C/src/target/HelloWorldCCPP.lf @@ -11,7 +11,7 @@ reactor HelloWorld { preamble {= #include =} - state success: bool(false) + state success: bool = false reaction(startup) {= std::cout << "Hello World." << std::endl; diff --git a/test/C/src/token/TokenContainedPrint.lf b/test/C/src/token/TokenContainedPrint.lf index 0d4b19379d..29e6005c4c 100644 --- a/test/C/src/token/TokenContainedPrint.lf +++ b/test/C/src/token/TokenContainedPrint.lf @@ -9,7 +9,7 @@ target C { import TokenPrint from "lib/Token.lf" main reactor { - state count: int(0) + state count: int = 0 timer t(0, 1 ms) p = new TokenPrint() diff --git a/test/C/src/token/TokenContainedPrintBank.lf b/test/C/src/token/TokenContainedPrintBank.lf index b23eb1c109..991a94b5a7 100644 --- a/test/C/src/token/TokenContainedPrintBank.lf +++ b/test/C/src/token/TokenContainedPrintBank.lf @@ -10,7 +10,7 @@ target C { import TokenPrint from "lib/Token.lf" main reactor { - state count: int(0) + state count: int = 0 timer t(0, 1 ms) p = new[2] TokenPrint() diff --git a/test/C/src/token/TokenContainedSource.lf b/test/C/src/token/TokenContainedSource.lf index 9bf517bc18..66095b8a0b 100644 --- a/test/C/src/token/TokenContainedSource.lf +++ b/test/C/src/token/TokenContainedSource.lf @@ -9,9 +9,9 @@ target C { import TokenSource from "lib/Token.lf" -main reactor(scale: int(1)) { - state count: int(0) - state input_received: bool(false) +main reactor(scale: int = 1) { + state count: int = 0 + state input_received: bool = false s = new TokenSource() diff --git a/test/C/src/token/TokenContainedSourceBank.lf b/test/C/src/token/TokenContainedSourceBank.lf index f1faee87dd..615695890b 100644 --- a/test/C/src/token/TokenContainedSourceBank.lf +++ b/test/C/src/token/TokenContainedSourceBank.lf @@ -10,9 +10,9 @@ target C { import TokenSource from "lib/Token.lf" -main reactor(scale: int(1)) { - state count: int(0) - state input_received: bool(false) +main reactor(scale: int = 1) { + state count: int = 0 + state input_received: bool = false s = new[2] TokenSource() diff --git a/test/C/src/token/lib/Token.lf b/test/C/src/token/lib/Token.lf index 4e49cd0006..7b8d2a83ee 100644 --- a/test/C/src/token/lib/Token.lf +++ b/test/C/src/token/lib/Token.lf @@ -20,7 +20,7 @@ preamble {= */ reactor TokenSource { output out: int_array_t* - state count: int(0) + state count: int = 0 timer t(0, 1 ms) reaction(startup) -> out {= @@ -42,10 +42,10 @@ reactor TokenSource { * value is a scaled version of the sequence of values produced by the * TokenSource, where the scaling factor is given by the scale parameter. */ -reactor TokenPrint(scale: int(1)) { +reactor TokenPrint(scale: int = 1) { input in: int_array_t* - state count: int(0) - state input_received: bool(false) + state count: int = 0 + state input_received: bool = false reaction(in) {= self->input_received = true; @@ -79,7 +79,7 @@ reactor TokenPrint(scale: int(1)) { * input is declared mutable so, if possible, the input token will be modified * rather than allocating a new token. */ -reactor TokenScale(scale: int(2)) { +reactor TokenScale(scale: int = 2) { mutable input in: int_array_t* output out: int_array_t* diff --git a/test/Cpp/src/ActionDelay.lf b/test/Cpp/src/ActionDelay.lf index 5bb1402e05..14210e1009 100644 --- a/test/Cpp/src/ActionDelay.lf +++ b/test/Cpp/src/ActionDelay.lf @@ -4,7 +4,7 @@ target Cpp reactor GeneratedDelay { input y_in: int output y_out: int - state y_state: int{0} + state y_state: int = 0 logical action act(100 msec): void reaction(y_in) -> act {= diff --git a/test/Cpp/src/ActionIsPresent.lf b/test/Cpp/src/ActionIsPresent.lf index 7b8267d606..e98c2a2a32 100644 --- a/test/Cpp/src/ActionIsPresent.lf +++ b/test/Cpp/src/ActionIsPresent.lf @@ -1,10 +1,10 @@ // Tests the is_present variable for actions in cpp target Cpp -main reactor ActionIsPresent(offset: time(1 nsec), period: time(500 msec)) { +main reactor ActionIsPresent(offset: time = 1 nsec, period: time(500 msec)) { logical action a - state success: bool(false) - state zero: time(0 nsec) + state success: bool = false + state zero: time = 0 nsec reaction(startup, a) -> a {= if (!a.is_present()) { diff --git a/test/Cpp/src/ActionValues.lf b/test/Cpp/src/ActionValues.lf index 18d06b7b3c..8d115c60fa 100644 --- a/test/Cpp/src/ActionValues.lf +++ b/test/Cpp/src/ActionValues.lf @@ -2,8 +2,8 @@ target Cpp main reactor ActionValues { - state r1done: bool(false) - state r2done: bool(false) + state r1done: bool = false + state r2done: bool = false logical action act(100 msec): int reaction(startup) -> act {= diff --git a/test/Cpp/src/After.lf b/test/Cpp/src/After.lf index 177ebfbe01..bbcc287b78 100644 --- a/test/Cpp/src/After.lf +++ b/test/Cpp/src/After.lf @@ -13,8 +13,8 @@ reactor foo { } reactor print { - state expected_time: time(10 msec) - state i: int(0) + state expected_time: time = 10 msec + state i: int = 0 input x: int reaction(x) {= diff --git a/test/Cpp/src/AfterOverlapped.lf b/test/Cpp/src/AfterOverlapped.lf index 926c4609c2..6a85eaf5bc 100644 --- a/test/Cpp/src/AfterOverlapped.lf +++ b/test/Cpp/src/AfterOverlapped.lf @@ -8,7 +8,7 @@ import Count from "lib/Count.lf" reactor Test { input c: int - state i: int(0) + state i: int = 0 reaction(c) {= std::cout << "Received " << *c.get() << '\n'; diff --git a/test/Cpp/src/AfterZero.lf b/test/Cpp/src/AfterZero.lf index 8baa157e99..152b87cfc2 100644 --- a/test/Cpp/src/AfterZero.lf +++ b/test/Cpp/src/AfterZero.lf @@ -13,8 +13,8 @@ reactor foo { } reactor print { - state expected_time: time(0) - state i: int(0) + state expected_time: time = 0 + state i: int = 0 input x: int reaction(x) {= diff --git a/test/Cpp/src/Alignment.lf b/test/Cpp/src/Alignment.lf index 45e52cb573..1bd3562f41 100644 --- a/test/Cpp/src/Alignment.lf +++ b/test/Cpp/src/Alignment.lf @@ -8,7 +8,7 @@ target Cpp { reactor Source { output out: int - state count: int(1) + state count: int = 1 timer t(0, 100 msec) reaction(t) -> out {= diff --git a/test/Cpp/src/ArrayAsParameter.lf b/test/Cpp/src/ArrayAsParameter.lf index 77795deb56..85cd0630bf 100644 --- a/test/Cpp/src/ArrayAsParameter.lf +++ b/test/Cpp/src/ArrayAsParameter.lf @@ -2,9 +2,9 @@ // passes to Print. target Cpp -reactor Source(sequence: int[]{0, 1, 2}) { +reactor Source(sequence: std::vector = {0, 1, 2}) { output out: size_t - state count: size_t{0} + state count: size_t = 0 logical action next: void reaction(startup, next) -> out, next {= @@ -18,7 +18,7 @@ reactor Source(sequence: int[]{0, 1, 2}) { reactor Print { input in: size_t - state count: size_t{1} + state count: size_t = 1 reaction(in) {= std::cout << "Received: " << *in.get() << '\n'; @@ -38,7 +38,7 @@ reactor Print { } main reactor ArrayAsParameter { - s = new Source(sequence = {= {1, 2, 3, 4} =}) + s = new Source(sequence = {1, 2, 3, 4}) p = new Print() s.out -> p.in } diff --git a/test/Cpp/src/ArrayPrint.lf b/test/Cpp/src/ArrayPrint.lf index 420f7902db..3bdf494107 100644 --- a/test/Cpp/src/ArrayPrint.lf +++ b/test/Cpp/src/ArrayPrint.lf @@ -18,7 +18,7 @@ reactor Source { =} } -reactor Print(scale: int(1)) { +reactor Print(scale: int = 1) { input in: int[3] reaction(in) {= diff --git a/test/Cpp/src/ArrayScale.lf b/test/Cpp/src/ArrayScale.lf index f5b2e56b30..b52e7305b7 100644 --- a/test/Cpp/src/ArrayScale.lf +++ b/test/Cpp/src/ArrayScale.lf @@ -5,7 +5,7 @@ target Cpp import Source, Print from "ArrayPrint.lf" -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { input in: int[3] output out: int[3] diff --git a/test/Cpp/src/CharLiteralInitializer.lf b/test/Cpp/src/CharLiteralInitializer.lf index 2d0edb71b8..e01e5973a6 100644 --- a/test/Cpp/src/CharLiteralInitializer.lf +++ b/test/Cpp/src/CharLiteralInitializer.lf @@ -2,7 +2,7 @@ target Cpp main reactor CharLiteralInitializer { - state c: char('x') + state c: char = 'x' reaction(startup) {= if (c != 'x') { diff --git a/test/Cpp/src/Composition.lf b/test/Cpp/src/Composition.lf index 6ac7364a51..0a341d5e4f 100644 --- a/test/Cpp/src/Composition.lf +++ b/test/Cpp/src/Composition.lf @@ -5,10 +5,10 @@ target Cpp { timeout: 10 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { output y: int timer t(1 sec, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= count++; @@ -18,7 +18,7 @@ reactor Source(period: time(2 sec)) { reactor Test { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= count++; diff --git a/test/Cpp/src/CompositionAfter.lf b/test/Cpp/src/CompositionAfter.lf index 06f71a6fbb..15d68e13ea 100644 --- a/test/Cpp/src/CompositionAfter.lf +++ b/test/Cpp/src/CompositionAfter.lf @@ -5,10 +5,10 @@ target Cpp { timeout: 10 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { output y: int timer t(1 sec, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= count++; @@ -18,7 +18,7 @@ reactor Source(period: time(2 sec)) { reactor Test { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= count++; @@ -38,7 +38,7 @@ reactor Test { =} } -main reactor(delay: time(5 sec)) { +main reactor(delay: time = 5 sec) { s = new Source() d = new Test() s.y -> d.x after delay diff --git a/test/Cpp/src/CountTest.lf b/test/Cpp/src/CountTest.lf index 63a494bc61..838d84a998 100644 --- a/test/Cpp/src/CountTest.lf +++ b/test/Cpp/src/CountTest.lf @@ -7,7 +7,7 @@ import Count from "lib/Count.lf" reactor Test { input c: int - state i: int(0) + state i: int = 0 reaction(c) {= i++; diff --git a/test/Cpp/src/Deadline.lf b/test/Cpp/src/Deadline.lf index 81eab8a004..19a41ff057 100644 --- a/test/Cpp/src/Deadline.lf +++ b/test/Cpp/src/Deadline.lf @@ -5,13 +5,13 @@ target Cpp { timeout: 4 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { private preamble {= #include =} output y: int timer t(0, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= if (count % 2 == 1) { @@ -25,9 +25,9 @@ reactor Source(period: time(2 sec)) { =} } -reactor Destination(timeout: time(1 sec)) { +reactor Destination(timeout: time = 1 sec) { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= std::cout << "Destination receives: " << *x.get() << std::endl; diff --git a/test/Cpp/src/DeadlineHandledAbove.lf b/test/Cpp/src/DeadlineHandledAbove.lf index 76a790fcbf..b2a6c7658a 100644 --- a/test/Cpp/src/DeadlineHandledAbove.lf +++ b/test/Cpp/src/DeadlineHandledAbove.lf @@ -2,7 +2,7 @@ // container reacts to that output. target Cpp -reactor Deadline(threshold: time(100 msec)) { +reactor Deadline(threshold: time = 100 msec) { input x: int output deadline_violation: bool @@ -16,7 +16,7 @@ reactor Deadline(threshold: time(100 msec)) { } main reactor DeadlineHandledAbove { - state violation_detected: bool({= false =}) + state violation_detected: bool = {= false =} d = new Deadline(threshold = 10 msec) reaction(startup) -> d.x {= diff --git a/test/Cpp/src/DelayInt.lf b/test/Cpp/src/DelayInt.lf index 379e22a3ec..f58e5ef45b 100644 --- a/test/Cpp/src/DelayInt.lf +++ b/test/Cpp/src/DelayInt.lf @@ -1,7 +1,7 @@ // This tests actions with payloads by delaying an input by a fixed amount. target Cpp -reactor Delay(delay: time(100 msec)) { +reactor Delay(delay: time = 100 msec) { input in: int output out: int logical action d: int diff --git a/test/Cpp/src/DelayedAction.lf b/test/Cpp/src/DelayedAction.lf index 0b2b748909..1ce1aea63f 100644 --- a/test/Cpp/src/DelayedAction.lf +++ b/test/Cpp/src/DelayedAction.lf @@ -6,7 +6,7 @@ target Cpp { main reactor DelayedAction { timer t(0, 1 sec) logical action a: void - state count: int(0) + state count: int = 0 reaction(t) -> a {= a.schedule(100ms); =} diff --git a/test/Cpp/src/DoubleInvocation.lf b/test/Cpp/src/DoubleInvocation.lf index 3315fafae4..956b54bb17 100644 --- a/test/Cpp/src/DoubleInvocation.lf +++ b/test/Cpp/src/DoubleInvocation.lf @@ -14,7 +14,7 @@ target Cpp { reactor Ball { output position: int output velocity: int - state p: int(200) + state p: int = 200 timer trigger(0, 1 sec) reaction(trigger) -> position, velocity {= @@ -27,7 +27,7 @@ reactor Ball { reactor Print { input velocity: int input position: int - state previous: int(-1) + state previous: int = -1 reaction(startup) {= reactor::log::Info() << "####### Print startup"; diff --git a/test/Cpp/src/DoublePort.lf b/test/Cpp/src/DoublePort.lf index 00950b1331..faaa474db5 100644 --- a/test/Cpp/src/DoublePort.lf +++ b/test/Cpp/src/DoublePort.lf @@ -13,7 +13,7 @@ target Cpp { import Count from "lib/Count.lf" reactor CountMicrostep { - state count: int(1) + state count: int = 1 output out: int logical action act: int timer t(0, 1 sec) diff --git a/test/Cpp/src/DoubleReaction.lf b/test/Cpp/src/DoubleReaction.lf index d5e8964089..1128d63f97 100644 --- a/test/Cpp/src/DoubleReaction.lf +++ b/test/Cpp/src/DoubleReaction.lf @@ -5,10 +5,10 @@ target Cpp { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= count++; @@ -19,7 +19,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int input w: int - state s: int(2) + state s: int = 2 reaction(x, w) {= int sum = 0; diff --git a/test/Cpp/src/DoubleTrigger.lf b/test/Cpp/src/DoubleTrigger.lf index c714d83e9c..5db4818048 100644 --- a/test/Cpp/src/DoubleTrigger.lf +++ b/test/Cpp/src/DoubleTrigger.lf @@ -5,7 +5,7 @@ target Cpp main reactor DoubleTrigger { timer t1 timer t2 - state s: int(0) + state s: int = 0 reaction(t1, t2) {= s++; diff --git a/test/Cpp/src/FloatLiteral.lf b/test/Cpp/src/FloatLiteral.lf index a65af798b4..6ad95f9e55 100644 --- a/test/Cpp/src/FloatLiteral.lf +++ b/test/Cpp/src/FloatLiteral.lf @@ -2,10 +2,10 @@ target Cpp // This test verifies that floating-point literals are handled correctly. main reactor { - state N: double(6.0221409e+23) - state charge: double(-1.6021766E-19) - state minus_epsilon: double(-.01e0) - state expected: double(.964853323188E5) + state N: double = 6.0221409e+23 + state charge: double = -1.6021766E-19 + state minus_epsilon: double = -.01e0 + state expected: double = .964853323188E5 reaction(startup) {= auto F = - N * charge; diff --git a/test/Cpp/src/Gain.lf b/test/Cpp/src/Gain.lf index 4a62a62a8e..4b123cc992 100644 --- a/test/Cpp/src/Gain.lf +++ b/test/Cpp/src/Gain.lf @@ -1,7 +1,7 @@ // Example in the Wiki. target Cpp -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { input x: int output y: int diff --git a/test/Cpp/src/GetMicroStep.lf b/test/Cpp/src/GetMicroStep.lf index c8eb89a4fa..8370a21403 100644 --- a/test/Cpp/src/GetMicroStep.lf +++ b/test/Cpp/src/GetMicroStep.lf @@ -2,7 +2,7 @@ target Cpp main reactor GetMicroStep { - state s: {= reactor::mstep_t =}(1) + state s: {= reactor::mstep_t =} = 1 logical action l diff --git a/test/Cpp/src/Hello.lf b/test/Cpp/src/Hello.lf index c63afbabe4..f74acf6688 100644 --- a/test/Cpp/src/Hello.lf +++ b/test/Cpp/src/Hello.lf @@ -8,8 +8,11 @@ target Cpp { fast: true } -reactor HelloCpp(period: time(2 sec), message: {= std::string =}("Hello C++")) { - state count: int(0) +reactor HelloCpp( + period: time = 2 sec, + message: {= std::string =} = "Hello C++" +) { + state count: int = 0 state previous_time: {= reactor::TimePoint =} timer t(1 sec, period) logical action a: void @@ -37,8 +40,8 @@ reactor HelloCpp(period: time(2 sec), message: {= std::string =}("Hello C++")) { } reactor Inside( - period: time(1 sec), - message: std::string("Composite default message.") + period: time = 1 sec, + message: std::string = "Composite default message." ) { third_instance = new HelloCpp(period = period, message = message) } diff --git a/test/Cpp/src/Hierarchy2.lf b/test/Cpp/src/Hierarchy2.lf index 4e78e3406e..db81bf4971 100644 --- a/test/Cpp/src/Hierarchy2.lf +++ b/test/Cpp/src/Hierarchy2.lf @@ -14,7 +14,7 @@ reactor Source { reactor Count { output out: int timer t(0, 1 sec) - state i: int(0) + state i: int = 0 reaction(t) -> out {= i++; @@ -37,7 +37,7 @@ reactor Add { reactor Print { input in: int - state expected: int(2) + state expected: int = 2 reaction(in) {= auto value = *in.get(); diff --git a/test/Cpp/src/ImportComposition.lf b/test/Cpp/src/ImportComposition.lf index 4b8649a243..0559edacd1 100644 --- a/test/Cpp/src/ImportComposition.lf +++ b/test/Cpp/src/ImportComposition.lf @@ -16,7 +16,7 @@ main reactor ImportComposition { =} imp_comp = new ImportedComposition() - state received: bool(false) + state received: bool = false reaction(startup) -> imp_comp.x {= imp_comp.x.set(42); =} diff --git a/test/Cpp/src/ManualDelayedReaction.lf b/test/Cpp/src/ManualDelayedReaction.lf index 2d426bffb7..3c55bdcaf1 100644 --- a/test/Cpp/src/ManualDelayedReaction.lf +++ b/test/Cpp/src/ManualDelayedReaction.lf @@ -4,7 +4,7 @@ target Cpp reactor GeneratedDelay { input y_in: int output y_out: int - state y_state: int(0) + state y_state: int = 0 logical action act(100 msec): int diff --git a/test/Cpp/src/Methods.lf b/test/Cpp/src/Methods.lf index fc4decbcbd..ff94460b62 100644 --- a/test/Cpp/src/Methods.lf +++ b/test/Cpp/src/Methods.lf @@ -1,7 +1,7 @@ target Cpp main reactor { - state foo: int(2) + state foo: int = 2 const method getFoo(): int {= return foo; =} diff --git a/test/Cpp/src/MovingAverage.lf b/test/Cpp/src/MovingAverage.lf index 160688c2ed..af202ca0a0 100644 --- a/test/Cpp/src/MovingAverage.lf +++ b/test/Cpp/src/MovingAverage.lf @@ -8,7 +8,7 @@ target Cpp { reactor Source { output out: double - state count: int{0} + state count: int = 0 timer clock(0, 200 msec) reaction(clock) -> out {= @@ -19,7 +19,7 @@ reactor Source { reactor MovingAverageImpl { state delay_line: double[3]{0.0, 0.0, 0.0} - state index: int{0} + state index: int = 0 input in: double output out: double @@ -44,7 +44,7 @@ reactor MovingAverageImpl { reactor Print { input in: double - state count: int{0} + state count: int = 0 reaction(in) {= std::cout << "Received: " << *in.get() << '\n'; diff --git a/test/Cpp/src/NativeListsAndTimes.lf b/test/Cpp/src/NativeListsAndTimes.lf index 5ec46d2930..5bf67c8fb4 100644 --- a/test/Cpp/src/NativeListsAndTimes.lf +++ b/test/Cpp/src/NativeListsAndTimes.lf @@ -2,27 +2,29 @@ target Cpp // This test passes if it is successfully compiled into valid target code. reactor Foo( - x: int(0), - y: time(0), // Units are missing but not required - z(1 msec), // Type is missing but not required - p: int[]{1, 2, 3, 4}, // List of integers + x: int = 0, + y: time = 0, // Units are missing but not required + z = 1 msec, // Type is missing but not required + p: int[]{1, 2, 3, 4}, // List of integers q: {= // list of time values std::vector =}{1 msec, 2 msec, 3 msec}, - g: time[]{1 msec, 2 msec} // List of time values + g: time[]{1 msec, 2 msec}, // List of time values + g2: int[] = {} ) { - state s: time(y) // Reference to explicitly typed time parameter - state t: time(z) // Reference to implicitly typed time parameter + state s: time = y // Reference to explicitly typed time parameter + state t: time = z // Reference to implicitly typed time parameter state v: bool // Uninitialized boolean state variable state w: time // Uninitialized time state variable timer tick(0) // Units missing but not required timer tock(1 sec) // Implicit type time timer toe(z) // Implicit type time - state baz(p) // Implicit type int[] - state period(z) // Implicit type time + state baz = p // Implicit type int[] + state period = z // Implicit type time state times: std::vector< // a list of lists std::vector<{= reactor::Duration =}> >{q, g} + state empty_list: int[] = {} reaction(tick) {= // Target code diff --git a/test/Cpp/src/NestedTriggeredReactions.lf b/test/Cpp/src/NestedTriggeredReactions.lf index dcaa64b179..783dcefc7e 100644 --- a/test/Cpp/src/NestedTriggeredReactions.lf +++ b/test/Cpp/src/NestedTriggeredReactions.lf @@ -3,7 +3,7 @@ target Cpp reactor Container { input in: void - state triggered: bool{false} + state triggered: bool = false contained = new Contained() @@ -22,7 +22,7 @@ reactor Container { reactor Contained { input in: void - state triggered: bool{false} + state triggered: bool = false reaction(in) {= triggered = true; =} diff --git a/test/Cpp/src/ParameterHierarchy.lf b/test/Cpp/src/ParameterHierarchy.lf index acd051a5ce..c183cbca03 100644 --- a/test/Cpp/src/ParameterHierarchy.lf +++ b/test/Cpp/src/ParameterHierarchy.lf @@ -7,7 +7,7 @@ */ target Cpp -reactor Deep(p: int(0)) { +reactor Deep(p: int = 0) { reaction(startup) {= if(p != 42) { reactor::log::Error() << "Parameter value is: " << p << ". Should have been 42."; @@ -18,11 +18,11 @@ reactor Deep(p: int(0)) { =} } -reactor Intermediate(p: int(10)) { +reactor Intermediate(p: int = 10) { a = new Deep(p = p) } -reactor Another(p: int(20)) { +reactor Another(p: int = 20) { // also test forwarding parameters via target code blocks a = new Intermediate(p = {= p =}) } diff --git a/test/Cpp/src/ParameterizedState.lf b/test/Cpp/src/ParameterizedState.lf index be03a52b9a..1c39043a75 100644 --- a/test/Cpp/src/ParameterizedState.lf +++ b/test/Cpp/src/ParameterizedState.lf @@ -1,7 +1,7 @@ target Cpp -reactor Foo(bar: int(4)) { - state baz(bar) +reactor Foo(bar: int = 4) { + state baz = bar reaction(startup) {= std::cout << "Baz: " << baz << std::endl; diff --git a/test/Cpp/src/ParametersOutOfOrder.lf b/test/Cpp/src/ParametersOutOfOrder.lf index 64dcbc6ef3..7ef28b914a 100644 --- a/test/Cpp/src/ParametersOutOfOrder.lf +++ b/test/Cpp/src/ParametersOutOfOrder.lf @@ -2,7 +2,7 @@ // definition order. Compilation without errors is success. target Cpp -reactor Foo(a: int(0), b: std::string(""), c: float(0.0)) { +reactor Foo(a: int = 0, b: std::string = "", c: float = 0.0) { reaction(startup) {= if (a != 42 || b != "bar" || c < 3.1) { reactor::log::Error() << "received an unexpected parameter!"; diff --git a/test/Cpp/src/PeriodicDesugared.lf b/test/Cpp/src/PeriodicDesugared.lf index 2b6e92c750..2823835687 100644 --- a/test/Cpp/src/PeriodicDesugared.lf +++ b/test/Cpp/src/PeriodicDesugared.lf @@ -3,10 +3,10 @@ target Cpp { timeout: 5 secs } -main reactor(offset: time(50 msec), period: time(500 msec)) { +main reactor(offset: time = 50 msec, period: time = 500 msec) { logical action init(offset): void logical action recur(period): void - state expected(offset) + state expected = offset reaction(startup) -> init {= std::cout << "Hello from Periodic!\n"; diff --git a/test/Cpp/src/Pipeline.lf b/test/Cpp/src/Pipeline.lf index c4300f13c9..cc86ef67a0 100644 --- a/test/Cpp/src/Pipeline.lf +++ b/test/Cpp/src/Pipeline.lf @@ -6,7 +6,7 @@ import Computation from "concurrent/Threaded.lf" reactor Print { input in: int - state count: int(0) + state count: int = 0 reaction(in) {= std::cout << "Received: " << *in.get() << '\n'; @@ -27,7 +27,7 @@ reactor Print { main reactor Pipeline { timer t(0, 200 msec) - state count: int(0) + state count: int = 0 c1 = new Computation() c2 = new Computation() diff --git a/test/Cpp/src/ReadOutputOfContainedReactor.lf b/test/Cpp/src/ReadOutputOfContainedReactor.lf index 6cba642f04..c7e85083b4 100644 --- a/test/Cpp/src/ReadOutputOfContainedReactor.lf +++ b/test/Cpp/src/ReadOutputOfContainedReactor.lf @@ -10,7 +10,7 @@ reactor Contained { main reactor ReadOutputOfContainedReactor { c = new Contained() - state count: int(0) + state count: int = 0 reaction(startup) c.out {= std::cout << "Startup reaction reading output of contained " diff --git a/test/Cpp/src/ScheduleLogicalAction.lf b/test/Cpp/src/ScheduleLogicalAction.lf index c8eaea1a30..96fd5382b7 100644 --- a/test/Cpp/src/ScheduleLogicalAction.lf +++ b/test/Cpp/src/ScheduleLogicalAction.lf @@ -26,7 +26,7 @@ reactor foo { } reactor print { - state expected_time: time(0) + state expected_time: time = 0 input x: int reaction(x) {= diff --git a/test/Cpp/src/SelfLoop.lf b/test/Cpp/src/SelfLoop.lf index be08cc771b..2be47e3d4e 100644 --- a/test/Cpp/src/SelfLoop.lf +++ b/test/Cpp/src/SelfLoop.lf @@ -12,7 +12,7 @@ reactor Self { input x: int output y: int logical action a: int - state expected: int(43) + state expected: int = 43 reaction(a) -> y {= reactor::log::Info() << "a = " << *a.get(); diff --git a/test/Cpp/src/SendingInside.lf b/test/Cpp/src/SendingInside.lf index 2d947f686b..2f73122bc8 100644 --- a/test/Cpp/src/SendingInside.lf +++ b/test/Cpp/src/SendingInside.lf @@ -7,7 +7,7 @@ target Cpp { reactor Printer { input x: int - state count: int(1) + state count: int = 1 reaction(x) {= std::cout << "Inside reactor received: " << *x.get() << std::endl; @@ -20,7 +20,7 @@ reactor Printer { } main reactor SendingInside { - state count: int(0) + state count: int = 0 timer t(0, 1 sec) p = new Printer() diff --git a/test/Cpp/src/SimpleDeadline.lf b/test/Cpp/src/SimpleDeadline.lf index 17c354108a..be10b55d43 100644 --- a/test/Cpp/src/SimpleDeadline.lf +++ b/test/Cpp/src/SimpleDeadline.lf @@ -3,7 +3,7 @@ // violation. target Cpp -reactor Deadline(threshold: time(100 msec)) { +reactor Deadline(threshold: time = 100 msec) { private preamble {= #include =} diff --git a/test/Cpp/src/SlowingClock.lf b/test/Cpp/src/SlowingClock.lf index 41dda03dba..adbe93e418 100644 --- a/test/Cpp/src/SlowingClock.lf +++ b/test/Cpp/src/SlowingClock.lf @@ -15,8 +15,8 @@ target Cpp { main reactor SlowingClock { logical action a(100 msec) - state interval: time(100 msec) - state expected_time: time(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec reaction(startup) -> a {= a.schedule(0ns); =} diff --git a/test/Cpp/src/SlowingClockPhysical.lf b/test/Cpp/src/SlowingClockPhysical.lf index 24f77cf2be..919f9d6cdf 100644 --- a/test/Cpp/src/SlowingClockPhysical.lf +++ b/test/Cpp/src/SlowingClockPhysical.lf @@ -15,8 +15,8 @@ target Cpp { main reactor SlowingClockPhysical { physical action a - state interval: time(100 msec) - state expected_time: time(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec reaction(startup) -> a {= expected_time=100ms; diff --git a/test/Cpp/src/Stride.lf b/test/Cpp/src/Stride.lf index 8adeaa69b0..5f469e4c70 100644 --- a/test/Cpp/src/Stride.lf +++ b/test/Cpp/src/Stride.lf @@ -5,8 +5,8 @@ target Cpp { fast: true } -reactor Count(stride: int(1)) { - state count: int(0) +reactor Count(stride: int = 1) { + state count: int = 0 output y: int timer t(0, 100 msec) diff --git a/test/Cpp/src/StructPrint.lf b/test/Cpp/src/StructPrint.lf index 9e0bc35d45..4ee404b8bf 100644 --- a/test/Cpp/src/StructPrint.lf +++ b/test/Cpp/src/StructPrint.lf @@ -19,8 +19,8 @@ reactor Source { } reactor Print( - expected_value: int(42), - expected_name: {= std::string =}("Earth") + expected_value: int = 42, + expected_name: {= std::string =} = "Earth" ) { input in: Hello diff --git a/test/Cpp/src/StructScale.lf b/test/Cpp/src/StructScale.lf index cf818f710f..776dad14b1 100644 --- a/test/Cpp/src/StructScale.lf +++ b/test/Cpp/src/StructScale.lf @@ -9,7 +9,7 @@ public preamble {= #include "include/hello.h" =} -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { input in: Hello output out: Hello diff --git a/test/Cpp/src/TimeLimit.lf b/test/Cpp/src/TimeLimit.lf index ec8d43af42..8b33dcd967 100644 --- a/test/Cpp/src/TimeLimit.lf +++ b/test/Cpp/src/TimeLimit.lf @@ -5,10 +5,10 @@ target Cpp { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= count++; @@ -19,7 +19,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int - state s: int(1) + state s: int = 1 reaction(x) {= //std::cout << "Received " << *x.get() << '\n'; @@ -39,7 +39,7 @@ reactor Destination { =} } -main reactor TimeLimit(period: time(1 sec)) { +main reactor TimeLimit(period: time = 1 sec) { timer stop(10 sec) c = new Clock(period = period) d = new Destination() diff --git a/test/Cpp/src/TimeState.lf b/test/Cpp/src/TimeState.lf index 28228c11ec..aefac79b1c 100644 --- a/test/Cpp/src/TimeState.lf +++ b/test/Cpp/src/TimeState.lf @@ -1,7 +1,7 @@ target Cpp -reactor Foo(bar: time(42 msec)) { - state baz(bar) +reactor Foo(bar: time = 42 msec) { + state baz = bar reaction(startup) {= std::cout << "Baz: " << baz << std::endl; =} } diff --git a/test/Cpp/src/Timeout_Test.lf b/test/Cpp/src/Timeout_Test.lf index 53ff8480dd..c3fe1ffbf9 100644 --- a/test/Cpp/src/Timeout_Test.lf +++ b/test/Cpp/src/Timeout_Test.lf @@ -13,7 +13,7 @@ import Sender from "lib/LoopedActionSender.lf" reactor Consumer { input in: int - state success: bool(false) + state success: bool = false reaction(in) {= auto current{get_elapsed_logical_time()}; diff --git a/test/Cpp/src/ToReactionNested.lf b/test/Cpp/src/ToReactionNested.lf index ff391229a0..5b048bc0a7 100644 --- a/test/Cpp/src/ToReactionNested.lf +++ b/test/Cpp/src/ToReactionNested.lf @@ -12,8 +12,8 @@ reactor CountContainer { } main reactor { - state count: int(1) - state received: bool(false) + state count: int = 1 + state received: bool = false s = new CountContainer() diff --git a/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf b/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf index d46507fce4..b8c304b164 100644 --- a/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf @@ -13,7 +13,7 @@ target Cpp { reactor Source { output[2] out: int - state count: int(0) + state count: int = 0 timer t(0, 200 msec) reaction(t) -> out {= diff --git a/test/Cpp/src/concurrent/AsyncCallback.lf b/test/Cpp/src/concurrent/AsyncCallback.lf index 984132f133..1258f69ce5 100644 --- a/test/Cpp/src/concurrent/AsyncCallback.lf +++ b/test/Cpp/src/concurrent/AsyncCallback.lf @@ -11,11 +11,11 @@ main reactor AsyncCallback { timer t(0, 200 msec) state thread: {= std::thread =} - state expected_time: time(100 msec) - state toggle: bool(false) + state expected_time: time = 100 msec + state toggle: bool = false physical action a: int - state i: int(0) + state i: int = 0 reaction(t) -> a {= // make sure to join the old thread first diff --git a/test/Cpp/src/concurrent/AsyncCallback2.lf b/test/Cpp/src/concurrent/AsyncCallback2.lf index 322413617b..c89b8ab712 100644 --- a/test/Cpp/src/concurrent/AsyncCallback2.lf +++ b/test/Cpp/src/concurrent/AsyncCallback2.lf @@ -10,10 +10,10 @@ main reactor AsyncCallback2 { =} timer t(0, 200 msec) - state expected_time: time(0) + state expected_time: time = 0 logical action a: int - state i: int(0) + state i: int = 0 reaction(t) -> a {= // start new thread diff --git a/test/Cpp/src/concurrent/CompositionThreaded.lf b/test/Cpp/src/concurrent/CompositionThreaded.lf index 393b08e060..42817e8b1d 100644 --- a/test/Cpp/src/concurrent/CompositionThreaded.lf +++ b/test/Cpp/src/concurrent/CompositionThreaded.lf @@ -5,10 +5,10 @@ target Cpp { timeout: 10 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { output y: int timer t(1 sec, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= count++; @@ -18,7 +18,7 @@ reactor Source(period: time(2 sec)) { reactor Test { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= count++; diff --git a/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf index eb88c997eb..bb380fe14c 100644 --- a/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -2,7 +2,7 @@ // container reacts to that output. target Cpp -reactor Deadline(threshold: time(100 msec)) { +reactor Deadline(threshold: time = 100 msec) { input x: int output deadline_violation: bool @@ -16,7 +16,7 @@ reactor Deadline(threshold: time(100 msec)) { } main reactor { - state violation_detected: bool({= false =}) + state violation_detected: bool = {= false =} d = new Deadline(threshold = 10 msec) reaction(startup) -> d.x {= diff --git a/test/Cpp/src/concurrent/DeadlineThreaded.lf b/test/Cpp/src/concurrent/DeadlineThreaded.lf index ad87c5a052..cb794f5050 100644 --- a/test/Cpp/src/concurrent/DeadlineThreaded.lf +++ b/test/Cpp/src/concurrent/DeadlineThreaded.lf @@ -5,13 +5,13 @@ target Cpp { timeout: 4 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { private preamble {= #include =} output y: int timer t(0, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= if (count % 2 == 1) { @@ -25,9 +25,9 @@ reactor Source(period: time(2 sec)) { =} } -reactor Destination(timeout: time(1 sec)) { +reactor Destination(timeout: time = 1 sec) { input x: int - state count: int(0) + state count: int = 0 reaction(x) {= std::cout << "Destination receives: " << *x.get() << std::endl; diff --git a/test/Cpp/src/concurrent/DelayIntThreaded.lf b/test/Cpp/src/concurrent/DelayIntThreaded.lf index d935ae12e5..319cae8b76 100644 --- a/test/Cpp/src/concurrent/DelayIntThreaded.lf +++ b/test/Cpp/src/concurrent/DelayIntThreaded.lf @@ -1,7 +1,7 @@ // This tests actions with payloads by delaying an input by a fixed amount. target Cpp -reactor Delay(delay: time(100 msec)) { +reactor Delay(delay: time = 100 msec) { input in: int output out: int logical action d: int diff --git a/test/Cpp/src/concurrent/DoubleReactionThreaded.lf b/test/Cpp/src/concurrent/DoubleReactionThreaded.lf index 1c9c3041b6..d68f2e8b60 100644 --- a/test/Cpp/src/concurrent/DoubleReactionThreaded.lf +++ b/test/Cpp/src/concurrent/DoubleReactionThreaded.lf @@ -5,10 +5,10 @@ target Cpp { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= count++; @@ -19,7 +19,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int input w: int - state s: int(2) + state s: int = 2 reaction(x, w) {= int sum = 0; diff --git a/test/Cpp/src/concurrent/GainThreaded.lf b/test/Cpp/src/concurrent/GainThreaded.lf index 8e96f44ed1..e88801f5a1 100644 --- a/test/Cpp/src/concurrent/GainThreaded.lf +++ b/test/Cpp/src/concurrent/GainThreaded.lf @@ -1,7 +1,7 @@ // Example in the Wiki. target Cpp -reactor Scale(scale: int(2)) { +reactor Scale(scale: int = 2) { input x: int output y: int diff --git a/test/Cpp/src/concurrent/HelloThreaded.lf b/test/Cpp/src/concurrent/HelloThreaded.lf index 7515d76d38..2c849b94dc 100644 --- a/test/Cpp/src/concurrent/HelloThreaded.lf +++ b/test/Cpp/src/concurrent/HelloThreaded.lf @@ -8,8 +8,11 @@ target Cpp { fast: true } -reactor HelloCpp(period: time(2 sec), message: {= std::string =}("Hello C++")) { - state count: int(0) +reactor HelloCpp( + period: time = 2 sec, + message: {= std::string =} = "Hello C++" +) { + state count: int = 0 state previous_time: {= reactor::TimePoint =} timer t(1 sec, period) logical action a: void @@ -37,8 +40,8 @@ reactor HelloCpp(period: time(2 sec), message: {= std::string =}("Hello C++")) { } reactor Inside( - period: time(1 sec), - message: {= std::string =}("Composite default message.") + period: time = 1 sec, + message: {= std::string =} = "Composite default message." ) { third_instance = new HelloCpp(period = period, message = message) } diff --git a/test/Cpp/src/concurrent/SendingInsideThreaded.lf b/test/Cpp/src/concurrent/SendingInsideThreaded.lf index a0e0fcc250..51ca511e26 100644 --- a/test/Cpp/src/concurrent/SendingInsideThreaded.lf +++ b/test/Cpp/src/concurrent/SendingInsideThreaded.lf @@ -7,7 +7,7 @@ target Cpp { reactor Printer { input x: int - state count: int(1) + state count: int = 1 reaction(x) {= std::cout << "Inside reactor received: " << *x.get() << std::endl; @@ -20,7 +20,7 @@ reactor Printer { } main reactor { - state count: int(0) + state count: int = 0 timer t(0, 1 sec) p = new Printer() diff --git a/test/Cpp/src/concurrent/Threaded.lf b/test/Cpp/src/concurrent/Threaded.lf index 0a0d857030..9ad4fcbe56 100644 --- a/test/Cpp/src/concurrent/Threaded.lf +++ b/test/Cpp/src/concurrent/Threaded.lf @@ -13,7 +13,7 @@ target Cpp { reactor Source { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= out.set(s); @@ -35,7 +35,7 @@ reactor Computation { } reactor Destination { - state s: int(0) + state s: int = 0 input in1: int input in2: int input in3: int diff --git a/test/Cpp/src/concurrent/ThreadedThreaded.lf b/test/Cpp/src/concurrent/ThreadedThreaded.lf index 2a6680273b..f8b21a6121 100644 --- a/test/Cpp/src/concurrent/ThreadedThreaded.lf +++ b/test/Cpp/src/concurrent/ThreadedThreaded.lf @@ -13,7 +13,7 @@ target Cpp { reactor Source { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= out.set(s); @@ -35,7 +35,7 @@ reactor Computation { } reactor Destination { - state s: int(0) + state s: int = 0 input[4] in: int reaction(in) {= diff --git a/test/Cpp/src/concurrent/TimeLimitThreaded.lf b/test/Cpp/src/concurrent/TimeLimitThreaded.lf index 5afcf05299..47371f72d7 100644 --- a/test/Cpp/src/concurrent/TimeLimitThreaded.lf +++ b/test/Cpp/src/concurrent/TimeLimitThreaded.lf @@ -6,10 +6,10 @@ target Cpp { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: int timer t(offset, period) - state count: int(0) + state count: int = 0 reaction(t) -> y {= count++; @@ -20,7 +20,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: int - state s: int(1) + state s: int = 1 reaction(x) {= //std::cout << "Received " << *x.get() << '\n'; @@ -40,7 +40,7 @@ reactor Destination { =} } -main reactor(period: time(1 sec)) { +main reactor(period: time = 1 sec) { timer stop(10 sec) c = new Clock(period = period) d = new Destination() diff --git a/test/Cpp/src/enclave/EnclaveBank.lf b/test/Cpp/src/enclave/EnclaveBank.lf index b155bd9f57..8894526927 100644 --- a/test/Cpp/src/enclave/EnclaveBank.lf +++ b/test/Cpp/src/enclave/EnclaveBank.lf @@ -4,10 +4,10 @@ target Cpp { } reactor Node( - bank_index: size_t(0), - id: std::string({= "node" + std::to_string(bank_index) =}), - period: time(500 msec), - duration: time(10 msec) + bank_index: size_t = 0, + id: std::string = {= "node" + std::to_string(bank_index) =}, + period: time = 500 msec, + duration: time = 10 msec ) { logical action a: void diff --git a/test/Cpp/src/enclave/EnclaveBankEach.lf b/test/Cpp/src/enclave/EnclaveBankEach.lf index c632d2ae79..c6cdeac564 100644 --- a/test/Cpp/src/enclave/EnclaveBankEach.lf +++ b/test/Cpp/src/enclave/EnclaveBankEach.lf @@ -5,10 +5,10 @@ target Cpp { } reactor Node( - bank_index: size_t(0), - id: std::string({= "node" + std::to_string(bank_index) =}), - period: {= reactor::Duration =}({= 100ms * (bank_index+1) =}), - duration: {= reactor::Duration =}({= 50ms + 100ms * bank_index =}) + bank_index: size_t = 0, + id: std::string = {= "node" + std::to_string(bank_index) =}, + period: {= reactor::Duration =} = {= 100ms * (bank_index+1) =}, + duration: {= reactor::Duration =} = {= 50ms + 100ms * bank_index =} ) { logical action a: void diff --git a/test/Cpp/src/enclave/EnclaveHelloWorld.lf b/test/Cpp/src/enclave/EnclaveHelloWorld.lf index ab28317cf9..7ca051533b 100644 --- a/test/Cpp/src/enclave/EnclaveHelloWorld.lf +++ b/test/Cpp/src/enclave/EnclaveHelloWorld.lf @@ -1,10 +1,10 @@ target Cpp -reactor Hello(msg: std::string("World")) { +reactor Hello(msg: std::string = "World") { reaction(startup) {= reactor::log::Info() << "Hello " << msg << '!'; =} } -main reactor(msg1: std::string("World"), msg2: std::string("Enclave")) { +main reactor(msg1: std::string = "World", msg2: std::string = "Enclave") { hello1 = new Hello(msg = msg1) @enclave diff --git a/test/Cpp/src/enclave/EnclaveHierarchy.lf b/test/Cpp/src/enclave/EnclaveHierarchy.lf index 87c811f859..9063942575 100644 --- a/test/Cpp/src/enclave/EnclaveHierarchy.lf +++ b/test/Cpp/src/enclave/EnclaveHierarchy.lf @@ -4,9 +4,9 @@ target Cpp { } reactor Node( - id: std::string("node"), - period: time(100 msec), - duration: time(50 msec) + id: std::string = "node", + period: time = 100 msec, + duration: time = 50 msec ) { timer t(0, period) diff --git a/test/Cpp/src/enclave/EnclaveShutdown.lf b/test/Cpp/src/enclave/EnclaveShutdown.lf index 7d25a53643..831adcde9c 100644 --- a/test/Cpp/src/enclave/EnclaveShutdown.lf +++ b/test/Cpp/src/enclave/EnclaveShutdown.lf @@ -1,9 +1,9 @@ target Cpp reactor Node( - message: std::string("Hello"), - period: time(1 sec), - stop: time(3 sec) + message: std::string = "Hello", + period: time = 1 sec, + stop: time = 3 sec ) { timer t(0, period) timer s(stop) diff --git a/test/Cpp/src/enclave/EnclaveTimeout.lf b/test/Cpp/src/enclave/EnclaveTimeout.lf index c9dd51498f..dc87acbd26 100644 --- a/test/Cpp/src/enclave/EnclaveTimeout.lf +++ b/test/Cpp/src/enclave/EnclaveTimeout.lf @@ -2,7 +2,7 @@ target Cpp { timeout: 1 sec } -reactor Node(message: std::string("Hello"), period: time(1 sec)) { +reactor Node(message: std::string = "Hello", period: time = 1 sec) { timer t(0, period) reaction(t) {= reactor::log::Info() << message; =} diff --git a/test/Cpp/src/lib/Count.lf b/test/Cpp/src/lib/Count.lf index aaf689b720..7b56233019 100644 --- a/test/Cpp/src/lib/Count.lf +++ b/test/Cpp/src/lib/Count.lf @@ -3,7 +3,7 @@ target Cpp reactor Count { output c: int timer t(0, 1 sec) - state i: int(0) + state i: int = 0 reaction(t) -> c {= i++; diff --git a/test/Cpp/src/lib/LoopedActionSender.lf b/test/Cpp/src/lib/LoopedActionSender.lf index db35b7a606..3c1cc13631 100644 --- a/test/Cpp/src/lib/LoopedActionSender.lf +++ b/test/Cpp/src/lib/LoopedActionSender.lf @@ -13,10 +13,10 @@ target Cpp * @param break_interval: Determines how long the reactor should take a break * after sending take_a_break_after messages. */ -reactor Sender(take_a_break_after: int(10), break_interval: time(400 msec)) { +reactor Sender(take_a_break_after: int = 10, break_interval: time = 400 msec) { output out: int logical action act - state sent_messages: int(0) + state sent_messages: int = 0 reaction(startup, act) -> act, out {= out.set(sent_messages); diff --git a/test/Cpp/src/multiport/BankSelfBroadcast.lf b/test/Cpp/src/multiport/BankSelfBroadcast.lf index a32e3a8eac..07da948506 100644 --- a/test/Cpp/src/multiport/BankSelfBroadcast.lf +++ b/test/Cpp/src/multiport/BankSelfBroadcast.lf @@ -8,10 +8,10 @@ */ target Cpp -reactor A(bank_index: size_t(0)) { +reactor A(bank_index: size_t = 0) { input[4] in: size_t output out: size_t - state received: bool(false) + state received: bool = false reaction(startup) -> out {= out.set(bank_index); =} diff --git a/test/Cpp/src/multiport/BankToBank.lf b/test/Cpp/src/multiport/BankToBank.lf index 84fc29ea09..f70cfd83e4 100644 --- a/test/Cpp/src/multiport/BankToBank.lf +++ b/test/Cpp/src/multiport/BankToBank.lf @@ -4,10 +4,10 @@ target Cpp { fast: true } -reactor Source(bank_index: size_t(0)) { +reactor Source(bank_index: size_t = 0) { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= out.set(s); @@ -15,8 +15,8 @@ reactor Source(bank_index: size_t(0)) { =} } -reactor Destination(bank_index: size_t(0)) { - state s: int(0) +reactor Destination(bank_index: size_t = 0) { + state s: int = 0 input in: int reaction(in) {= @@ -37,7 +37,7 @@ reactor Destination(bank_index: size_t(0)) { =} } -main reactor BankToBank(width: int(4)) { +main reactor BankToBank(width: int = 4) { // FIXME: Should set the width to "width" rather than "4". a = new[4] Source() b = new[4] Destination() diff --git a/test/Cpp/src/multiport/BankToBankMultiport.lf b/test/Cpp/src/multiport/BankToBankMultiport.lf index e5c26a4d2b..bdb3e9a880 100644 --- a/test/Cpp/src/multiport/BankToBankMultiport.lf +++ b/test/Cpp/src/multiport/BankToBankMultiport.lf @@ -4,10 +4,10 @@ target Cpp { fast: true } -reactor Source(width: size_t(1)) { +reactor Source(width: size_t = 1) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(size_t i = 0; i < out.size(); i++) { @@ -16,8 +16,8 @@ reactor Source(width: size_t(1)) { =} } -reactor Destination(width: size_t(1)) { - state s: int(6) +reactor Destination(width: size_t = 1) { + state s: int = 6 input[width] in: int reaction(in) {= @@ -44,7 +44,7 @@ reactor Destination(width: size_t(1)) { =} } -main reactor(bank_width: size_t(4)) { +main reactor(bank_width: size_t = 4) { a = new[bank_width] Source(width = 4) b = new[bank_width] Destination(width = 4) a.out -> b.in diff --git a/test/Cpp/src/multiport/BankToBankMultiportAfter.lf b/test/Cpp/src/multiport/BankToBankMultiportAfter.lf index 436a647f94..78d832a5ea 100644 --- a/test/Cpp/src/multiport/BankToBankMultiportAfter.lf +++ b/test/Cpp/src/multiport/BankToBankMultiportAfter.lf @@ -4,10 +4,10 @@ target Cpp { fast: true } -reactor Source(width: size_t(1)) { +reactor Source(width: size_t = 1) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(size_t i = 0; i < out.size(); i++) { @@ -16,9 +16,9 @@ reactor Source(width: size_t(1)) { =} } -reactor Destination(width: size_t(1)) { - state s: int(6) - state iterations: unsigned(0) +reactor Destination(width: size_t = 1) { + state s: int = 6 + state iterations: unsigned = 0 input[width] in: int reaction(in) {= @@ -52,7 +52,7 @@ reactor Destination(width: size_t(1)) { =} } -main reactor(bank_width: size_t(4)) { +main reactor(bank_width: size_t = 4) { a = new[bank_width] Source(width = 4) b = new[bank_width] Destination(width = 4) a.out -> b.in after 200 msec diff --git a/test/Cpp/src/multiport/BankToMultiport.lf b/test/Cpp/src/multiport/BankToMultiport.lf index d8132b2630..6b1acf7591 100644 --- a/test/Cpp/src/multiport/BankToMultiport.lf +++ b/test/Cpp/src/multiport/BankToMultiport.lf @@ -1,7 +1,7 @@ // Test bank of reactors to multiport input with id parameter in the bank. target Cpp -reactor Source(bank_index: size_t(0)) { +reactor Source(bank_index: size_t = 0) { output out: unsigned reaction(startup) -> out {= out.set(bank_index); =} @@ -9,7 +9,7 @@ reactor Source(bank_index: size_t(0)) { reactor Sink { input[4] in: unsigned - state received: bool(false) + state received: bool = false reaction(in) {= for (unsigned i = 0; i < in.size(); i++) { diff --git a/test/Cpp/src/multiport/Broadcast.lf b/test/Cpp/src/multiport/Broadcast.lf index 471bc92172..077ca75247 100644 --- a/test/Cpp/src/multiport/Broadcast.lf +++ b/test/Cpp/src/multiport/Broadcast.lf @@ -6,7 +6,7 @@ reactor Source { reaction(startup) -> out {= out.set(42); =} } -reactor Sink(bank_index: size_t(0)) { +reactor Sink(bank_index: size_t = 0) { input in: unsigned reaction(in) {= diff --git a/test/Cpp/src/multiport/BroadcastAfter.lf b/test/Cpp/src/multiport/BroadcastAfter.lf index 7f0ee66712..6cb7f84f4d 100644 --- a/test/Cpp/src/multiport/BroadcastAfter.lf +++ b/test/Cpp/src/multiport/BroadcastAfter.lf @@ -8,9 +8,9 @@ reactor Source { reaction(startup) -> out {= out.set(42); =} } -reactor Sink(bank_index: size_t(0)) { +reactor Sink(bank_index: size_t = 0) { input in: unsigned - state received: bool{false} + state received: bool = false reaction(in) {= std::cout << bank_index << " received " << *in.get() << '\n'; diff --git a/test/Cpp/src/multiport/BroadcastMultipleAfter.lf b/test/Cpp/src/multiport/BroadcastMultipleAfter.lf index 84051887ca..065e9bf403 100644 --- a/test/Cpp/src/multiport/BroadcastMultipleAfter.lf +++ b/test/Cpp/src/multiport/BroadcastMultipleAfter.lf @@ -2,15 +2,15 @@ target Cpp { fast: true } -reactor Source(value: unsigned(42)) { +reactor Source(value: unsigned = 42) { output out: unsigned reaction(startup) -> out {= out.set(value); =} } -reactor Sink(bank_index: size_t(0)) { +reactor Sink(bank_index: size_t = 0) { input in: unsigned - state received: bool{false} + state received: bool = false reaction(in) {= std::cout << bank_index << " received " << *in.get() << '\n'; diff --git a/test/Cpp/src/multiport/FullyConnected.lf b/test/Cpp/src/multiport/FullyConnected.lf index c925460402..0b0a66405e 100644 --- a/test/Cpp/src/multiport/FullyConnected.lf +++ b/test/Cpp/src/multiport/FullyConnected.lf @@ -1,10 +1,10 @@ target Cpp -reactor Node(bank_index: size_t(0), num_nodes: size_t(4)) { +reactor Node(bank_index: size_t = 0, num_nodes: size_t = 4) { input[num_nodes] in: size_t output out: size_t - state received: bool{false} + state received: bool = false reaction(startup) -> out {= std::cout << "Hello from node " << bank_index << "!\n"; @@ -36,7 +36,7 @@ reactor Node(bank_index: size_t(0), num_nodes: size_t(4)) { =} } -main reactor(num_nodes: size_t(4)) { +main reactor(num_nodes: size_t = 4) { nodes = new[num_nodes] Node(num_nodes = num_nodes) (nodes.out)+ -> nodes.in } diff --git a/test/Cpp/src/multiport/FullyConnectedAddressable.lf b/test/Cpp/src/multiport/FullyConnectedAddressable.lf index 2a756c328f..5385c44222 100644 --- a/test/Cpp/src/multiport/FullyConnectedAddressable.lf +++ b/test/Cpp/src/multiport/FullyConnectedAddressable.lf @@ -1,11 +1,11 @@ // In this pattern, each node can send direct messages to individual other nodes target Cpp -reactor Node(bank_index: size_t(0), num_nodes: size_t(4)) { +reactor Node(bank_index: size_t = 0, num_nodes: size_t = 4) { input[num_nodes] in: size_t output[num_nodes] out: size_t - state received: bool{false} + state received: bool = false reaction(startup) -> out {= std::cout << "Hello from node " << bank_index << "!\n"; @@ -41,7 +41,7 @@ reactor Node(bank_index: size_t(0), num_nodes: size_t(4)) { =} } -main reactor(num_nodes: size_t(4)) { +main reactor(num_nodes: size_t = 4) { nodes1 = new[num_nodes] Node(num_nodes = num_nodes) nodes1.out -> interleaved (nodes1.in) diff --git a/test/Cpp/src/multiport/FullyConnectedAddressableAfter.lf b/test/Cpp/src/multiport/FullyConnectedAddressableAfter.lf index e331494b1b..c6fcb4c9e6 100644 --- a/test/Cpp/src/multiport/FullyConnectedAddressableAfter.lf +++ b/test/Cpp/src/multiport/FullyConnectedAddressableAfter.lf @@ -3,7 +3,7 @@ target Cpp import Node from "FullyConnectedAddressable.lf" -main reactor(num_nodes: size_t(4)) { +main reactor(num_nodes: size_t = 4) { nodes1 = new[num_nodes] Node(num_nodes = num_nodes) nodes1.out -> interleaved (nodes1.in) after 200 msec diff --git a/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf b/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf index bf00c15081..964e2e7095 100644 --- a/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf +++ b/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf @@ -8,7 +8,7 @@ */ target Cpp -reactor ReactorWithMultiport(width: size_t(3)) { +reactor ReactorWithMultiport(width: size_t = 3) { output[width] out: int reaction(startup) -> out {= @@ -18,7 +18,7 @@ reactor ReactorWithMultiport(width: size_t(3)) { =} } -reactor MultiportSplitter(width: size_t(3)) { +reactor MultiportSplitter(width: size_t = 3) { input[width] in: int output out0: int @@ -34,9 +34,9 @@ main reactor IndexIntoMultiportOutput { source.out -> splitter.in - state received0: bool{false} - state received1: bool{false} - state received2: bool{false} + state received0: bool = false + state received1: bool = false + state received2: bool = false reaction(splitter.out0) {= received0 = true; diff --git a/test/Cpp/src/multiport/Multiport.lf b/test/Cpp/src/multiport/Multiport.lf index 946282566f..a63924c67c 100644 --- a/test/Cpp/src/multiport/Multiport.lf +++ b/test/Cpp/src/multiport/Multiport.lf @@ -21,7 +21,7 @@ reactor Test { main reactor Multiport { test = new Test() - state received: bool(false) + state received: bool = false reaction(startup) -> test.sink {= for (auto i = 0; i < 30; i++) { diff --git a/test/Cpp/src/multiport/MultiportFromBank.lf b/test/Cpp/src/multiport/MultiportFromBank.lf index 61d33e2a4c..b7339a9184 100644 --- a/test/Cpp/src/multiport/MultiportFromBank.lf +++ b/test/Cpp/src/multiport/MultiportFromBank.lf @@ -5,15 +5,15 @@ target Cpp { fast: true } -reactor Source(bank_index: size_t(0)) { +reactor Source(bank_index: size_t = 0) { output out: unsigned reaction(startup) -> out {= out.set(bank_index); =} } -reactor Destination(port_width: size_t(2)) { +reactor Destination(port_width: size_t = 2) { input[port_width] in: unsigned - state received: bool(false) + state received: bool = false reaction(in) {= for (size_t i = 0; i < in.size(); i++) { @@ -35,7 +35,7 @@ reactor Destination(port_width: size_t(2)) { =} } -main reactor(width: size_t(4)) { +main reactor(width: size_t = 4) { a = new[width] Source() b = new Destination(port_width = width) a.out -> b.in diff --git a/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf b/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf index ec75a59be4..673ef6889a 100644 --- a/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf @@ -5,7 +5,7 @@ target Cpp { fast: true } -reactor Source(bank_index: size_t(0)) { +reactor Source(bank_index: size_t = 0) { output out: unsigned reaction(startup) -> out {= out.set(bank_index); =} @@ -19,7 +19,7 @@ reactor Container { reactor Destination { input[3] in: unsigned - state received: bool(false) + state received: bool = false reaction(in) {= for (size_t i = 0; i < in.size(); i++) { diff --git a/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf index fd0cb4c693..fe27c74f35 100644 --- a/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -5,7 +5,7 @@ target Cpp { fast: true } -reactor Source(bank_index: size_t(0)) { +reactor Source(bank_index: size_t = 0) { output out: int reaction(startup) -> out {= out.set(bank_index); =} @@ -19,7 +19,7 @@ reactor Container { reactor Destination { input[3] in: int - state received: bool(false) + state received: bool = false reaction(in) {= for (int i = 0; i < in.size(); i++) { diff --git a/test/Cpp/src/multiport/MultiportFromHierarchy.lf b/test/Cpp/src/multiport/MultiportFromHierarchy.lf index c63285af13..fae914b609 100644 --- a/test/Cpp/src/multiport/MultiportFromHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportFromHierarchy.lf @@ -8,7 +8,7 @@ target Cpp { reactor Source { timer t(0, 200 msec) output[4] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < 4; i++) { @@ -18,7 +18,7 @@ reactor Source { } reactor Destination { - state s: int(6) + state s: int = 6 input[4] in: int reaction(in) {= diff --git a/test/Cpp/src/multiport/MultiportIn.lf b/test/Cpp/src/multiport/MultiportIn.lf index 31f06bd956..39fce6f8ff 100644 --- a/test/Cpp/src/multiport/MultiportIn.lf +++ b/test/Cpp/src/multiport/MultiportIn.lf @@ -8,7 +8,7 @@ target Cpp { reactor Source { timer t(0, 200 msec) output out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= out.set(s++); =} } @@ -21,7 +21,7 @@ reactor Computation { } reactor Destination { - state s: int(0) + state s: int = 0 input[4] in: int reaction(in) {= diff --git a/test/Cpp/src/multiport/MultiportOut.lf b/test/Cpp/src/multiport/MultiportOut.lf index b4d5e00425..53f2a5bb23 100644 --- a/test/Cpp/src/multiport/MultiportOut.lf +++ b/test/Cpp/src/multiport/MultiportOut.lf @@ -7,7 +7,7 @@ target Cpp { reactor Source { timer t(0, 200 msec) output[4] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < 4; i++) { @@ -31,7 +31,7 @@ reactor Computation { } reactor Destination { - state s: int(0) + state s: int = 0 input[4] in: int reaction(in) {= diff --git a/test/Cpp/src/multiport/MultiportToBank.lf b/test/Cpp/src/multiport/MultiportToBank.lf index 898ccf7b97..fa2f79419f 100644 --- a/test/Cpp/src/multiport/MultiportToBank.lf +++ b/test/Cpp/src/multiport/MultiportToBank.lf @@ -10,7 +10,7 @@ reactor Source { =} } -reactor Sink(bank_index: size_t(0)) { +reactor Sink(bank_index: size_t = 0) { input in: unsigned reaction(in) {= diff --git a/test/Cpp/src/multiport/MultiportToBankAfter.lf b/test/Cpp/src/multiport/MultiportToBankAfter.lf index 546e569e24..c05730680f 100644 --- a/test/Cpp/src/multiport/MultiportToBankAfter.lf +++ b/test/Cpp/src/multiport/MultiportToBankAfter.lf @@ -10,7 +10,7 @@ reactor Source { =} } -reactor Sink(bank_index: size_t(0)) { +reactor Sink(bank_index: size_t = 0) { input in: unsigned reaction(in) {= diff --git a/test/Cpp/src/multiport/MultiportToBankHierarchy.lf b/test/Cpp/src/multiport/MultiportToBankHierarchy.lf index 11671f98bb..f9cef6a676 100644 --- a/test/Cpp/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportToBankHierarchy.lf @@ -15,9 +15,9 @@ reactor Source { =} } -reactor Destination(bank_index: size_t(0)) { +reactor Destination(bank_index: size_t = 0) { input in: unsigned - state received: bool(false) + state received: bool = false reaction(in) {= std::cout << "Destination " << bank_index << " received " << *in.get() << ".\n"; diff --git a/test/Cpp/src/multiport/MultiportToHierarchy.lf b/test/Cpp/src/multiport/MultiportToHierarchy.lf index e0daa5a4c0..573a0e06da 100644 --- a/test/Cpp/src/multiport/MultiportToHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportToHierarchy.lf @@ -6,10 +6,10 @@ target Cpp { fast: true } -reactor Source(width: size_t(4)) { +reactor Source(width: size_t = 4) { timer t(0, 200 msec) output[width] out: int - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(size_t i = 0; i < 4; i++) { @@ -18,8 +18,8 @@ reactor Source(width: size_t(4)) { =} } -reactor Destination(width: size_t(4)) { - state s: int(6) +reactor Destination(width: size_t = 4) { + state s: int = 6 input[width] in: int reaction(in) {= @@ -45,13 +45,13 @@ reactor Destination(width: size_t(4)) { =} } -reactor Container(width: size_t(4)) { +reactor Container(width: size_t = 4) { input[width] in: int dst = new Destination() in -> dst.in } -main reactor MultiportToHierarchy(width: size_t(4)) { +main reactor MultiportToHierarchy(width: size_t = 4) { a = new Source(width = width) b = new Container(width = width) a.out -> b.in diff --git a/test/Cpp/src/multiport/MultiportToMultiport.lf b/test/Cpp/src/multiport/MultiportToMultiport.lf index c7b673ea11..37a1ee5222 100644 --- a/test/Cpp/src/multiport/MultiportToMultiport.lf +++ b/test/Cpp/src/multiport/MultiportToMultiport.lf @@ -12,7 +12,7 @@ reactor Source { reactor Sink { input[4] in: unsigned - state received: bool(false) + state received: bool = false reaction(in) {= for (unsigned i = 0; i < in.size(); i++) { diff --git a/test/Cpp/src/multiport/MultiportToMultiport2.lf b/test/Cpp/src/multiport/MultiportToMultiport2.lf index ac0151731f..165f3201ce 100644 --- a/test/Cpp/src/multiport/MultiportToMultiport2.lf +++ b/test/Cpp/src/multiport/MultiportToMultiport2.lf @@ -1,7 +1,7 @@ // Test multiport to multiport connections. See also MultiportToMultiport. target Cpp -reactor Source(width: size_t(2)) { +reactor Source(width: size_t = 2) { output[width] out: size_t reaction(startup) -> out {= @@ -11,7 +11,7 @@ reactor Source(width: size_t(2)) { =} } -reactor Destination(width: size_t(2)) { +reactor Destination(width: size_t = 2) { input[width] in: size_t reaction(in) {= diff --git a/test/Cpp/src/multiport/MultiportToMultiport2After.lf b/test/Cpp/src/multiport/MultiportToMultiport2After.lf index b015bfe827..781275b2f4 100644 --- a/test/Cpp/src/multiport/MultiportToMultiport2After.lf +++ b/test/Cpp/src/multiport/MultiportToMultiport2After.lf @@ -1,7 +1,7 @@ // Test multiport to multiport connections. See also MultiportToMultiport. target Cpp -reactor Source(width: size_t(2)) { +reactor Source(width: size_t = 2) { output[width] out: size_t reaction(startup) -> out {= @@ -11,7 +11,7 @@ reactor Source(width: size_t(2)) { =} } -reactor Destination(width: size_t(2)) { +reactor Destination(width: size_t = 2) { input[width] in: size_t reaction(in) {= diff --git a/test/Cpp/src/multiport/MultiportToMultiportArray.lf b/test/Cpp/src/multiport/MultiportToMultiportArray.lf index 077aab0f9d..6c96d17150 100644 --- a/test/Cpp/src/multiport/MultiportToMultiportArray.lf +++ b/test/Cpp/src/multiport/MultiportToMultiportArray.lf @@ -8,7 +8,7 @@ target Cpp { reactor Source { timer t(0, 200 msec) output[2] out: int[3] - state s: int(0) + state s: int = 0 reaction(t) -> out {= for(int i = 0; i < 2; i++) { @@ -25,7 +25,7 @@ reactor Source { } reactor Destination { - state s: int(15) + state s: int = 15 input[2] in: int[3] reaction(in) {= diff --git a/test/Cpp/src/multiport/MultiportToPort.lf b/test/Cpp/src/multiport/MultiportToPort.lf index 107198c9cc..c2b0bd66ef 100644 --- a/test/Cpp/src/multiport/MultiportToPort.lf +++ b/test/Cpp/src/multiport/MultiportToPort.lf @@ -16,9 +16,9 @@ reactor Source { =} } -reactor Destination(expected: int(0)) { +reactor Destination(expected: int = 0) { input in: int - state received: bool(false) + state received: bool = false reaction(in) {= std::cout << "Received: " << *in.get() << ".\n"; diff --git a/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf b/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf index c6bbcf1242..6fa6dbb87b 100644 --- a/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf +++ b/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf @@ -2,7 +2,7 @@ // multiport target Cpp -reactor Contained(bank_index: size_t(0)) { +reactor Contained(bank_index: size_t = 0) { output[3] out: unsigned reaction(startup) -> out {= @@ -14,7 +14,7 @@ reactor Contained(bank_index: size_t(0)) { main reactor { c = new[3] Contained() - state count: int(0) + state count: int = 0 reaction(startup) c.out {= for (size_t i = 0; i < c.size(); i++) { diff --git a/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf b/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf index 81deaf91f2..18179b9086 100644 --- a/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf +++ b/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf @@ -2,7 +2,7 @@ // permutations. target Cpp -reactor Contained(bank_index: size_t(0)) { +reactor Contained(bank_index: size_t = 0) { output out: unsigned reaction(startup) -> out {= out.set(42 * bank_index); =} @@ -10,7 +10,7 @@ reactor Contained(bank_index: size_t(0)) { main reactor { c = new[4] Contained() - state count: int(0) + state count: int = 0 reaction(startup) c.out {= for (size_t i = 0; i < c.size(); i++) { diff --git a/test/Cpp/src/multiport/WidthGivenByCode.lf b/test/Cpp/src/multiport/WidthGivenByCode.lf index 52c2f84b36..10a2a59489 100644 --- a/test/Cpp/src/multiport/WidthGivenByCode.lf +++ b/test/Cpp/src/multiport/WidthGivenByCode.lf @@ -1,6 +1,6 @@ target Cpp -reactor Foo(a: size_t{8}, b: size_t{2}) { +reactor Foo(a: size_t = 8, b: size_t = 2) { input[{= a*b =}] in: size_t output[{= a/b =}] out: size_t diff --git a/test/Cpp/src/multiport/WriteInputOfContainedBank.lf b/test/Cpp/src/multiport/WriteInputOfContainedBank.lf index 3824664e35..b8f8d50958 100644 --- a/test/Cpp/src/multiport/WriteInputOfContainedBank.lf +++ b/test/Cpp/src/multiport/WriteInputOfContainedBank.lf @@ -1,9 +1,9 @@ // Test writing inputs to a contained reactor bank target Cpp -reactor Contained(bank_index: size_t(0)) { +reactor Contained(bank_index: size_t = 0) { input in: unsigned - state count: int(0) + state count: int = 0 reaction(in) {= unsigned result = *in.get(); diff --git a/test/Cpp/src/multiport/WriteMultiportInputOfContainedBank.lf b/test/Cpp/src/multiport/WriteMultiportInputOfContainedBank.lf index 49e0614842..5ffe567dfb 100644 --- a/test/Cpp/src/multiport/WriteMultiportInputOfContainedBank.lf +++ b/test/Cpp/src/multiport/WriteMultiportInputOfContainedBank.lf @@ -1,9 +1,9 @@ // Test writing multiport inputs to a contained reactor bank target Cpp -reactor Contained(bank_index: size_t(0)) { +reactor Contained(bank_index: size_t = 0) { input[4] in: unsigned - state count: int(0) + state count: int = 0 reaction(in) {= for (size_t i = 0; i < 3; i++) { diff --git a/test/Cpp/src/properties/Fast.lf b/test/Cpp/src/properties/Fast.lf index a12cbfaf01..1d4ba25d2f 100644 --- a/test/Cpp/src/properties/Fast.lf +++ b/test/Cpp/src/properties/Fast.lf @@ -5,7 +5,7 @@ target Cpp { main reactor { logical action a - state triggered: bool{false} + state triggered: bool = false reaction(startup) -> a {= a.schedule(2s); =} diff --git a/test/Cpp/src/properties/Timeout.lf b/test/Cpp/src/properties/Timeout.lf index 50f647349f..57c55ad24c 100644 --- a/test/Cpp/src/properties/Timeout.lf +++ b/test/Cpp/src/properties/Timeout.lf @@ -5,7 +5,7 @@ target Cpp { main reactor { timer t(1 sec, 1 sec) - state triggered: bool{false} + state triggered: bool = false reaction(t) {= triggered = true; diff --git a/test/Cpp/src/properties/TimeoutZero.lf b/test/Cpp/src/properties/TimeoutZero.lf index 96409f692e..9d04fa8048 100644 --- a/test/Cpp/src/properties/TimeoutZero.lf +++ b/test/Cpp/src/properties/TimeoutZero.lf @@ -5,7 +5,7 @@ target Cpp { main reactor { timer t(0, 1 sec) - state triggered: bool{false} + state triggered: bool = false reaction(t) {= triggered = true; diff --git a/test/Cpp/src/target/AfterVoid.lf b/test/Cpp/src/target/AfterVoid.lf index 0b9beadcff..555e024e6b 100644 --- a/test/Cpp/src/target/AfterVoid.lf +++ b/test/Cpp/src/target/AfterVoid.lf @@ -12,8 +12,8 @@ reactor foo { } reactor print { - state expected_time: time(10 msec) - state i: int(0) + state expected_time: time = 10 msec + state i: int = 0 input x: void reaction(x) {= diff --git a/test/Cpp/src/target/BraceAndParenInitialization.lf b/test/Cpp/src/target/BraceAndParenInitialization.lf index 8838187bc2..003b6d509d 100644 --- a/test/Cpp/src/target/BraceAndParenInitialization.lf +++ b/test/Cpp/src/target/BraceAndParenInitialization.lf @@ -26,8 +26,5 @@ reactor Foo( } main reactor { - foo = new Foo( - param_list_3 = {= std::vector(3, 5) =}, - param_list_4 = {= {3, 5} =} - ) + foo = new Foo(param_list_3 = {= std::vector(3, 5) =}, param_list_4 = {3, 5}) } diff --git a/test/Cpp/src/target/CliParserGenericArguments.lf b/test/Cpp/src/target/CliParserGenericArguments.lf index eb75ac2ef6..9a008ebcab 100644 --- a/test/Cpp/src/target/CliParserGenericArguments.lf +++ b/test/Cpp/src/target/CliParserGenericArguments.lf @@ -43,19 +43,19 @@ private preamble {= =} main reactor CliParserGenericArguments( - int_value: int(10), - signed_value: signed(-10), - unsigned_value: unsigned(11), - long_value: long(-100), - unsigned_long_value: {= unsigned_long =}(42), - long_long_value: {= long_long =}(-42), - ull_value: {= uns_long_long =}(42), - bool_value: bool(false), - char_value: char('T'), - double_value: double(4.2), - long_double_value: {= long_double =}(4.2), - float_value: float(10.5), - string_value: string("This is a testvalue"), + int_value: int = 10, + signed_value: signed = -10, + unsigned_value: unsigned = 11, + long_value: long = -100, + unsigned_long_value: {= unsigned_long =} = 42, + long_long_value: {= long_long =} = -42, + ull_value: {= uns_long_long =} = 42, + bool_value: bool = false, + char_value: char = 'T', + double_value: double = 4.2, + long_double_value: {= long_double =} = 4.2, + float_value: float = 10.5, + string_value: string = "This is a testvalue", custom_class_value: {= CustomClass =}("Peter") ) { reaction(startup) {= std::cout << "Hello World!\n"; =} diff --git a/test/Cpp/src/target/CombinedTypeNames.lf b/test/Cpp/src/target/CombinedTypeNames.lf index 28182b7bf7..d55c70a823 100644 --- a/test/Cpp/src/target/CombinedTypeNames.lf +++ b/test/Cpp/src/target/CombinedTypeNames.lf @@ -3,11 +3,11 @@ target Cpp reactor Foo( - bar: {= unsigned int =}(0), - baz: {= const unsigned int* =}({= nullptr =}) + bar: {= unsigned int =} = 0, + baz: {= const unsigned int* =} = {= nullptr =} ) { - state s_bar: {= unsigned int =}(bar) - state s_baz: {= const unsigned int* =}(baz) + state s_bar: {= unsigned int =} = bar + state s_baz: {= const unsigned int* =} = baz reaction(startup) {= if (bar != 42 || s_bar != 42 || *baz != 42 || *s_baz != 42) { @@ -17,6 +17,6 @@ reactor Foo( =} } -main reactor(bar: {= unsigned int =}(42)) { +main reactor(bar: {= unsigned int =} = 42) { foo = new Foo(bar = bar, baz = {= &bar =}) } diff --git a/test/Cpp/src/target/GenericDelay.lf b/test/Cpp/src/target/GenericDelay.lf index 135c04f417..5efa81b011 100644 --- a/test/Cpp/src/target/GenericDelay.lf +++ b/test/Cpp/src/target/GenericDelay.lf @@ -2,7 +2,7 @@ target Cpp import Test from "../DelayInt.lf" -reactor Delay(delay: time(0)) { +reactor Delay(delay: time = 0) { output out: T input in: T logical action a(delay): T diff --git a/test/Cpp/src/target/GenericParameterAndState.lf b/test/Cpp/src/target/GenericParameterAndState.lf index d259bf3b22..6803eb9509 100644 --- a/test/Cpp/src/target/GenericParameterAndState.lf +++ b/test/Cpp/src/target/GenericParameterAndState.lf @@ -1,7 +1,7 @@ target Cpp -reactor Foo(bar: T(0), expected: T(14542135)) { - state baz: T(bar) +reactor Foo(bar: T = 0, expected: T = 14542135) { + state baz: T = bar reaction(startup) {= if (bar != expected) { diff --git a/test/Cpp/src/target/InitializerSyntax.lf b/test/Cpp/src/target/InitializerSyntax.lf new file mode 100644 index 0000000000..54ae268457 --- /dev/null +++ b/test/Cpp/src/target/InitializerSyntax.lf @@ -0,0 +1,89 @@ +target Cpp + +public preamble {= + #include + struct TestType { + int x; + + // constructor #1 + TestType() : x(42) {} + // constructor #2 + TestType(int x) : x(x) {} + // constructor #3 + TestType(std::initializer_list l) : x(l.size()) {} + // constructor #4 + TestType(const TestType& t) : x(t.x + 10) { } + // constructor #5 + TestType(TestType&& t) : x(t.x + 20) { } + + TestType& operator=(const TestType& t) { + std::cout << "assign\n"; + this->x = t.x + 30; + return *this; + } + TestType& operator=(TestType&& t) { + this->x = t.x + 40; + return *this; + } + + ~TestType() = default; + }; +=} + +reactor TestReactor( + /** + * FIXME: should work without an explicit initialization, see + * https://github.com/lf-lang/lingua-franca/issues/623 + */ + // p_default: TestType, constructor #1 + p_default: TestType(), + p_empty: TestType(), // constructor #1 + p_value: TestType(24), // constructor #2 + p_init_empty: TestType{}, // constructor #1 + p_init_empty2: TestType({}), // constructor #1 + p_init_some: TestType{2, 6, 6, 3, 1}, // constructor #1 + p_assign_init_empty: TestType = {}, // constructor #1 + p_assign_init_some: TestType = {4, 2, 1} // constructor #3 +) { + state s_default: TestType // constructor #1 + state s_empty: TestType() // constructor #1 + state s_value: TestType(24) // constructor #2 + state s_init_empty: TestType{} // constructor #1 + state s_init_empty2: TestType({}) // constructor #3 + state s_init_some: TestType{3, 12, 40} // constructor #3 + state s_assign_init_empty: TestType = {} // constructor #3 + state s_assign_init_some: TestType = {4, 3, 2, 1} // constructor #3 + state s_copy1: TestType(p_default) // constructor #4 + state s_copy2: TestType{p_default} // constructor #4 + state s_copy3: TestType = p_default // constructor #4 + + reaction(startup) {= + reactor::validate(p_default.x == 62, "p_default should be default constructed and then moved"); + reactor::validate(p_empty.x == 62, "p_empty should be default constructed and then moved"); + reactor::validate(p_value.x == 44, "p_value should be constructed from 24 and then moved"); + reactor::validate(p_init_empty.x == 62, "p_init_empty should be default constructed and then moved"); + reactor::validate(p_init_empty2.x == 20, "p_init_empty2 should be constructed with 0 and then moved"); + reactor::validate(p_init_some.x == 25, "p_init_some should be constructed with 3 and then moved"); + reactor::validate(p_assign_init_empty.x == 62, "p_assign_init_empty should be default constructed and then moved"); + reactor::validate(p_assign_init_some.x == 23, "p_assign_init_some should be constructed with 4 and then moved"); + + reactor::validate(s_default.x == 42, "s_default should be default constructed"); + reactor::validate(s_empty.x == 42, "s_empty should be default constructed"); + reactor::validate(s_value.x == 24, "s_value should be constructed with 24"); + reactor::validate(s_init_empty.x == 42, "s_init_empty should be default constructed"); + reactor::validate(s_init_empty2.x == 0, "s_init_empty2 should be constructed with 0"); + reactor::validate(s_init_some.x == 3, "s_init_some should be constructed with 3"); + // NOTE: This is a strange corner case. Since the equal assignment will be translated to a () initializers (e.g. :foo(42)), + // the initialization here in LF behaves differently from what one might expect. When writing `Foo foo = {}`, + // the default constructor would be called instead of the initializer list constructor. + reactor::validate(s_assign_init_empty.x == 0, "s_assign_init_empty should be constructed with 0"); + reactor::validate(s_assign_init_some.x == 4, "s_assign_init_some should be constructed with 4"); + reactor::validate(s_copy1.x == 72, "s_copy1 should be copy constructed from p_default"); + reactor::validate(s_copy2.x == 72, "s_copy1 should be copy constructed from p_default"); + reactor::validate(s_copy3.x == 72, "s_copy1 should be copy constructed from p_default"); + =} +} + +main reactor { + test = new TestReactor() +} diff --git a/test/Cpp/src/target/PointerParameters.lf b/test/Cpp/src/target/PointerParameters.lf index cb8675d014..a769f20da3 100644 --- a/test/Cpp/src/target/PointerParameters.lf +++ b/test/Cpp/src/target/PointerParameters.lf @@ -2,7 +2,7 @@ // Compilation without errors is success. target Cpp -reactor Foo(ptr: int*{{= nullptr =}}) { +reactor Foo(ptr: int* = {= nullptr =}) { reaction(startup) {= if (ptr == nullptr || *ptr != 42) { reactor::log::Error() << "received an unexpected value!"; diff --git a/test/Python/src/ActionDelay.lf b/test/Python/src/ActionDelay.lf index 7c325bb2cb..60efa42f57 100644 --- a/test/Python/src/ActionDelay.lf +++ b/test/Python/src/ActionDelay.lf @@ -4,7 +4,7 @@ target Python reactor GeneratedDelay { input y_in output y_out - state y_state(0) + state y_state = 0 logical action act(100 msec) reaction(y_in) -> act {= diff --git a/test/Python/src/ActionIsPresent.lf b/test/Python/src/ActionIsPresent.lf index 259417110e..ceb52d10b8 100644 --- a/test/Python/src/ActionIsPresent.lf +++ b/test/Python/src/ActionIsPresent.lf @@ -1,10 +1,10 @@ # Tests the is_present variable for actions. target Python -main reactor ActionIsPresent(offset(1 nsec), period(500 msec)) { +main reactor ActionIsPresent(offset = 1 nsec, period = 500 msec) { logical action a - state first_time(True) - state success(False) + state first_time = True + state success = False reaction(startup, a) -> a {= # The is_present field should be initially False diff --git a/test/Python/src/After.lf b/test/Python/src/After.lf index 13b1970d5a..0c8b931543 100644 --- a/test/Python/src/After.lf +++ b/test/Python/src/After.lf @@ -13,8 +13,8 @@ reactor foo { } reactor print { - state expected_time(10 msec) - state received(0) + state expected_time = 10 msec + state received = 0 input x reaction(x) {= diff --git a/test/Python/src/AfterCycles.lf b/test/Python/src/AfterCycles.lf index ef1500af27..cd0f0dd98e 100644 --- a/test/Python/src/AfterCycles.lf +++ b/test/Python/src/AfterCycles.lf @@ -16,7 +16,7 @@ reactor Work { } main reactor AfterCycles { - state count(0) + state count = 0 s = new Source() w0 = new Work() w1 = new Work() diff --git a/test/Python/src/AfterOverlapped.lf b/test/Python/src/AfterOverlapped.lf index 2876538189..32657f1cdb 100644 --- a/test/Python/src/AfterOverlapped.lf +++ b/test/Python/src/AfterOverlapped.lf @@ -8,8 +8,8 @@ import Count from "lib/Count.lf" reactor Test { input c - state i(0) - state received(0) + state i = 0 + state received = 0 reaction(c) {= self.received += 1 diff --git a/test/Python/src/ArrayAsParameter.lf b/test/Python/src/ArrayAsParameter.lf index 67af462358..359e38b7a3 100644 --- a/test/Python/src/ArrayAsParameter.lf +++ b/test/Python/src/ArrayAsParameter.lf @@ -3,7 +3,7 @@ target Python reactor Source(sequence(0, 1, 2)) { output out - state count(0) + state count = 0 logical action next reaction(startup, next) -> out, next {= @@ -16,8 +16,8 @@ reactor Source(sequence(0, 1, 2)) { reactor Print { input _in - state count(1) - state received(0) + state count = 1 + state received = 0 reaction(_in) {= self.received+=1 @@ -36,7 +36,7 @@ reactor Print { } main reactor ArrayAsParameter { - s = new Source(sequence = (1, 2, 3, 4)) + s = new Source(sequence(1, 2, 3, 4)) p = new Print() s.out -> p._in } diff --git a/test/Python/src/ArrayAsType.lf b/test/Python/src/ArrayAsType.lf index 2025cecbd1..dc3b2f6e26 100644 --- a/test/Python/src/ArrayAsType.lf +++ b/test/Python/src/ArrayAsType.lf @@ -11,7 +11,7 @@ reactor Source { =} } -reactor Print(scale(1)) { # The scale parameter is just for testing. +reactor Print(scale = 1) { # The scale parameter is just for testing. input _in reaction(_in) {= diff --git a/test/Python/src/ArrayFree.lf b/test/Python/src/ArrayFree.lf index 893fbc4358..2ea2777c12 100644 --- a/test/Python/src/ArrayFree.lf +++ b/test/Python/src/ArrayFree.lf @@ -7,7 +7,7 @@ target Python import Source, Print from "ArrayPrint.lf" import Scale from "ArrayScale.lf" -reactor Free(scale(2)) { +reactor Free(scale = 2) { mutable input _in reaction(_in) {= diff --git a/test/Python/src/ArrayPrint.lf b/test/Python/src/ArrayPrint.lf index 039debac0c..4420311b93 100644 --- a/test/Python/src/ArrayPrint.lf +++ b/test/Python/src/ArrayPrint.lf @@ -11,7 +11,7 @@ reactor Source { =} } -reactor Print(scale(1)) { # The scale parameter is just for testing. +reactor Print(scale = 1) { # The scale parameter is just for testing. input _in reaction(_in) {= diff --git a/test/Python/src/ArrayScale.lf b/test/Python/src/ArrayScale.lf index 620b63e10f..2b69aebe77 100644 --- a/test/Python/src/ArrayScale.lf +++ b/test/Python/src/ArrayScale.lf @@ -6,7 +6,7 @@ target Python import Print, Source from "ArrayPrint.lf" -reactor Scale(scale(2)) { +reactor Scale(scale = 2) { mutable input _in output out diff --git a/test/Python/src/Composition.lf b/test/Python/src/Composition.lf index 3a737295bf..d1bef93ed2 100644 --- a/test/Python/src/Composition.lf +++ b/test/Python/src/Composition.lf @@ -5,10 +5,10 @@ target Python { timeout: 10 sec } -reactor Source(period(2 sec)) { +reactor Source(period = 2 sec) { output y timer t(1 sec, period) - state count(0) + state count = 0 reaction(t) -> y {= self.count += 1 @@ -20,7 +20,7 @@ reactor Source(period(2 sec)) { reactor Test { input x - state count(0) + state count = 0 reaction(x) {= self.count += 1 diff --git a/test/Python/src/CompositionAfter.lf b/test/Python/src/CompositionAfter.lf index f21b7ae75e..00b95e3ab9 100644 --- a/test/Python/src/CompositionAfter.lf +++ b/test/Python/src/CompositionAfter.lf @@ -5,10 +5,10 @@ target Python { timeout: 10 sec } -reactor Source(period(2 sec)) { +reactor Source(period = 2 sec) { output y timer t(1 sec, period) - state count(0) + state count = 0 reaction(t) -> y {= self.count += 1 @@ -18,7 +18,7 @@ reactor Source(period(2 sec)) { reactor Test { input x - state count(0) + state count = 0 reaction(x) {= self.count += 1 @@ -29,7 +29,7 @@ reactor Test { =} } -main reactor(delay(5 sec)) { +main reactor(delay = 5 sec) { s = new Source() d = new Test() s.y -> d.x after delay diff --git a/test/Python/src/CompositionInheritance.lf b/test/Python/src/CompositionInheritance.lf index deac45b05a..4b0e4a38c9 100644 --- a/test/Python/src/CompositionInheritance.lf +++ b/test/Python/src/CompositionInheritance.lf @@ -5,11 +5,11 @@ target Python { timeout: 10 sec } -reactor Source(period(2 sec)) { +reactor Source(period = 2 sec) { input foo output y timer t(1 sec, period) - state count(0) + state count = 0 reaction(t) -> y {= print("Hello World. My count is: ", self.count) @@ -30,7 +30,7 @@ reactor SourceExtended extends Source { reactor Test { input x - state count(0) + state count = 0 reaction(x) {= self.count += 1 diff --git a/test/Python/src/CountSelf.lf b/test/Python/src/CountSelf.lf index 40f4778c71..74219e6fe0 100644 --- a/test/Python/src/CountSelf.lf +++ b/test/Python/src/CountSelf.lf @@ -4,7 +4,7 @@ target Python { fast: true } -reactor CountSelf2(delay(100 msec)) { +reactor CountSelf2(delay = 100 msec) { output out logical action a @@ -21,7 +21,7 @@ reactor CountSelf2(delay(100 msec)) { reactor Test { input _in - state count(0) + state count = 0 reaction(_in) {= print("Received: {:d}".format(_in.value)) diff --git a/test/Python/src/CountTest.lf b/test/Python/src/CountTest.lf index 2761d22a5b..06c4a6fdb6 100644 --- a/test/Python/src/CountTest.lf +++ b/test/Python/src/CountTest.lf @@ -7,7 +7,7 @@ import Count from "lib/Count.lf" reactor Test { input c - state i(0) + state i = 0 reaction(c) {= print("Received ", c.value) diff --git a/test/Python/src/Deadline.lf b/test/Python/src/Deadline.lf index aeed5f0d5e..ceab2b28e2 100644 --- a/test/Python/src/Deadline.lf +++ b/test/Python/src/Deadline.lf @@ -7,10 +7,10 @@ target Python { preamble {= import time =} -reactor Source(period(3 sec)) { +reactor Source(period = 3 sec) { output y timer t(0, period) - state count(0) + state count = 0 reaction(t) -> y {= if self.count % 2 != 0: @@ -24,9 +24,9 @@ reactor Source(period(3 sec)) { =} } -reactor Destination(timeout(1 sec)) { +reactor Destination(timeout = 1 sec) { input x - state count(0) + state count = 0 reaction(x) {= print("Destination receives: ", x.value) diff --git a/test/Python/src/DeadlineHandledAbove.lf b/test/Python/src/DeadlineHandledAbove.lf index d3df675152..1259253cea 100644 --- a/test/Python/src/DeadlineHandledAbove.lf +++ b/test/Python/src/DeadlineHandledAbove.lf @@ -4,7 +4,7 @@ target Python preamble {= import time =} -reactor Deadline(threshold(100 msec)) { +reactor Deadline(threshold = 100 msec) { input x output deadline_violation @@ -18,7 +18,7 @@ reactor Deadline(threshold(100 msec)) { } main reactor DeadlineHandledAbove { - state violation_detected(false) + state violation_detected = False d = new Deadline(threshold = 10 msec) reaction(startup) -> d.x {= diff --git a/test/Python/src/DelayArray.lf b/test/Python/src/DelayArray.lf index abcf367d45..945b786cca 100644 --- a/test/Python/src/DelayArray.lf +++ b/test/Python/src/DelayArray.lf @@ -1,7 +1,7 @@ # This tests delaying an array type. target Python -reactor DelayPointer(delay(100 msec)) { +reactor DelayPointer(delay = 100 msec) { # The Python target does not require explicit type allocation for types # other than time mutable input _in @@ -25,7 +25,7 @@ reactor Source { =} } -reactor Print(scale(1)) { # The scale parameter is just for testing. +reactor Print(scale = 1) { # The scale parameter is just for testing. input _in reaction(_in) {= diff --git a/test/Python/src/DelayArrayWithAfter.lf b/test/Python/src/DelayArrayWithAfter.lf index e244690ec8..1e6ac1f317 100644 --- a/test/Python/src/DelayArrayWithAfter.lf +++ b/test/Python/src/DelayArrayWithAfter.lf @@ -7,7 +7,7 @@ target Python { reactor Source { output out - state iteration(1) + state iteration = 1 timer t(0, 1 sec) reaction(t) -> out {= @@ -18,10 +18,10 @@ reactor Source { =} } -reactor Print(scale(1)) { # The scale parameter is just for testing. +reactor Print(scale = 1) { # The scale parameter is just for testing. input _in - state iteration(1) - state inputs_received(0) + state iteration = 1 + state inputs_received = 0 reaction(_in) {= self.inputs_received += 1 diff --git a/test/Python/src/DelayInt.lf b/test/Python/src/DelayInt.lf index d12c8b968b..fae554bd30 100644 --- a/test/Python/src/DelayInt.lf +++ b/test/Python/src/DelayInt.lf @@ -1,7 +1,7 @@ # This tests actions with payloads by delaying an input by a fixed amount. target Python -reactor Delay(delay(100 msec)) { +reactor Delay(delay = 100 msec) { input _in output out logical action a @@ -16,8 +16,8 @@ reactor Delay(delay(100 msec)) { reactor Test { input _in - state start_time(0) - state received_value(false) + state start_time = 0 + state received_value = False reaction(startup) {= # Record the logical time at the start. diff --git a/test/Python/src/DelayString.lf b/test/Python/src/DelayString.lf index f315b0bec2..d1201dec02 100644 --- a/test/Python/src/DelayString.lf +++ b/test/Python/src/DelayString.lf @@ -2,7 +2,7 @@ # freed. target Python -reactor DelayString2(delay(100 msec)) { +reactor DelayString2(delay = 100 msec) { input _in output out logical action a @@ -14,7 +14,7 @@ reactor DelayString2(delay(100 msec)) { reactor Test { input _in - state start_time(0) + state start_time = 0 reaction(_in) {= print("Received: ", _in.value) diff --git a/test/Python/src/DelayStruct.lf b/test/Python/src/DelayStruct.lf index f16aedfe7c..e578a42699 100644 --- a/test/Python/src/DelayStruct.lf +++ b/test/Python/src/DelayStruct.lf @@ -5,7 +5,7 @@ target Python { preamble {= import hello =} -reactor DelayPointer(delay(100 msec)) { +reactor DelayPointer(delay = 100 msec) { input _in output out logical action a @@ -25,7 +25,7 @@ reactor Source { reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} } -reactor Print(expected(42)) { # expected parameter is for testing. +reactor Print(expected = 42) { # expected parameter is for testing. input _in reaction(_in) {= diff --git a/test/Python/src/DelayStructWithAfter.lf b/test/Python/src/DelayStructWithAfter.lf index 21dafab29e..5bb945cb3c 100644 --- a/test/Python/src/DelayStructWithAfter.lf +++ b/test/Python/src/DelayStructWithAfter.lf @@ -11,7 +11,7 @@ reactor Source { reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} } -reactor Print(expected(42)) { # expected parameter is for testing. +reactor Print(expected = 42) { # expected parameter is for testing. input _in reaction(_in) {= diff --git a/test/Python/src/DelayStructWithAfterOverlapped.lf b/test/Python/src/DelayStructWithAfterOverlapped.lf index f19c5cd1bd..072012a106 100644 --- a/test/Python/src/DelayStructWithAfterOverlapped.lf +++ b/test/Python/src/DelayStructWithAfterOverlapped.lf @@ -10,7 +10,7 @@ preamble {= import hello =} reactor Source { output out timer t(0, 1 sec) - state s(0) + state s = 0 reaction(t) -> out {= self.s += 1 @@ -20,7 +20,7 @@ reactor Source { reactor Print { # expected parameter is for testing. input _in - state s(0) + state s = 0 reaction(_in) {= self.s += 1 diff --git a/test/Python/src/DelayedAction.lf b/test/Python/src/DelayedAction.lf index 3f6fb70608..06c488b9c5 100644 --- a/test/Python/src/DelayedAction.lf +++ b/test/Python/src/DelayedAction.lf @@ -6,7 +6,7 @@ target Python { main reactor DelayedAction { timer t(0, 1 sec) logical action a - state count(0) + state count = 0 reaction(t) -> a {= a.schedule(MSEC(100)) =} diff --git a/test/Python/src/DoubleInvocation.lf b/test/Python/src/DoubleInvocation.lf index d14edd6332..aaecfa31cb 100644 --- a/test/Python/src/DoubleInvocation.lf +++ b/test/Python/src/DoubleInvocation.lf @@ -13,7 +13,7 @@ target Python { reactor Ball { output position output velocity - state p(200) + state p = 200 timer trigger(0, 1 sec) reaction(trigger) -> position, velocity {= @@ -26,7 +26,7 @@ reactor Ball { reactor Print { input velocity input position - state previous(-1) + state previous = -1 reaction(startup) {= print("####### Print startup\n") diff --git a/test/Python/src/DoubleReaction.lf b/test/Python/src/DoubleReaction.lf index 2061ab5a1c..c20a032a9a 100644 --- a/test/Python/src/DoubleReaction.lf +++ b/test/Python/src/DoubleReaction.lf @@ -5,10 +5,10 @@ target Python { fast: true } -reactor Clock(offset(0), period(1 sec)) { +reactor Clock(offset = 0, period = 1 sec) { output y timer t(offset, period) - state count(0) + state count = 0 reaction(t) -> y {= self.count += 1 @@ -19,7 +19,7 @@ reactor Clock(offset(0), period(1 sec)) { reactor Destination { input x input w - state s(2) + state s = 2 reaction(x, w) {= sm = 0 diff --git a/test/Python/src/FloatLiteral.lf b/test/Python/src/FloatLiteral.lf index 5ed6202429..b55953d135 100644 --- a/test/Python/src/FloatLiteral.lf +++ b/test/Python/src/FloatLiteral.lf @@ -2,10 +2,10 @@ target Python # This test verifies that floating-point literals are handled correctly. main reactor { - state N(6.0221409e+23) - state charge(-1.6021766E-19) - state minus_epsilon(-.01e0) - state expected(.964853323188E5) + state N = 6.0221409e+23 + state charge = -1.6021766E-19 + state minus_epsilon = -.01e0 + state expected = .964853323188E5 reaction(startup) {= F = - self.N * self.charge diff --git a/test/Python/src/Gain.lf b/test/Python/src/Gain.lf index 38459a9380..d69d4d2a65 100644 --- a/test/Python/src/Gain.lf +++ b/test/Python/src/Gain.lf @@ -1,7 +1,7 @@ # Example in the Wiki. target Python -reactor Scale(scale(2)) { +reactor Scale(scale = 2) { input x output y @@ -10,7 +10,7 @@ reactor Scale(scale(2)) { reactor Test { input x - state received_value(0) + state received_value = 0 reaction(x) {= print("Received " + str(x.value)) diff --git a/test/Python/src/GetMicroStep.lf b/test/Python/src/GetMicroStep.lf index 7b1da9bb40..124c692ef8 100644 --- a/test/Python/src/GetMicroStep.lf +++ b/test/Python/src/GetMicroStep.lf @@ -5,7 +5,7 @@ target Python { main reactor GetMicroStep { preamble {= import sys =} - state s(1) + state s = 1 logical action l # timer t(0, 1 msec); diff --git a/test/Python/src/Hello.lf b/test/Python/src/Hello.lf index 0da0d53f47..271ed180ca 100644 --- a/test/Python/src/Hello.lf +++ b/test/Python/src/Hello.lf @@ -8,9 +8,9 @@ target Python { fast: true } -reactor Reschedule(period(2 sec), message("Hello Python")) { - state count(0) - state previous_time(0) +reactor Reschedule(period = 2 sec, message = "Hello Python") { + state count = 0 + state previous_time = 0 timer t(1 sec, period) logical action a @@ -38,7 +38,7 @@ reactor Reschedule(period(2 sec), message("Hello Python")) { =} } -reactor Inside(period(1 sec), message("Composite default message.")) { +reactor Inside(period = 1 sec, message = "Composite default message.") { third_instance = new Reschedule(period = period, message = message) } diff --git a/test/Python/src/HelloWorld.lf b/test/Python/src/HelloWorld.lf index 725a73d0ac..523ff9ce2b 100644 --- a/test/Python/src/HelloWorld.lf +++ b/test/Python/src/HelloWorld.lf @@ -3,7 +3,7 @@ target Python { } reactor HelloWorld2 { - state success(False) + state success = False reaction(startup) {= print("Hello World.") diff --git a/test/Python/src/Hierarchy2.lf b/test/Python/src/Hierarchy2.lf index 07e67a765b..a1792712fa 100644 --- a/test/Python/src/Hierarchy2.lf +++ b/test/Python/src/Hierarchy2.lf @@ -14,7 +14,7 @@ reactor Source { reactor Count { output out timer t(0, 1 sec) - state i(0) + state i = 0 reaction(t) -> out {= self.i += 1 @@ -39,7 +39,7 @@ reactor Add { reactor Print { input _in - state expected(2) + state expected = 2 reaction(_in) {= print("Received: ", _in.value) diff --git a/test/Python/src/IdentifierLength.lf b/test/Python/src/IdentifierLength.lf index 66edf11abf..62b31141a0 100644 --- a/test/Python/src/IdentifierLength.lf +++ b/test/Python/src/IdentifierLength.lf @@ -6,11 +6,11 @@ target Python { } reactor A_Really_Long_Name_For_A_Source_But_Not_Quite_255_Characters_Which_Is_The_Maximum_For_The_Python_Target( - period(2 sec) + period = 2 sec ) { output y timer t(1 sec, period) - state count(0) + state count = 0 reaction(t) -> y {= self.count += 1 @@ -20,7 +20,7 @@ reactor A_Really_Long_Name_For_A_Source_But_Not_Quite_255_Characters_Which_Is_Th reactor Another_Really_Long_Name_For_A_Test_Class { input x - state count(0) + state count = 0 reaction(x) {= self.count += 1 diff --git a/test/Python/src/ImportComposition.lf b/test/Python/src/ImportComposition.lf index 4e57dc6423..369fbcab44 100644 --- a/test/Python/src/ImportComposition.lf +++ b/test/Python/src/ImportComposition.lf @@ -6,7 +6,7 @@ import ImportedComposition from "lib/ImportedComposition.lf" main reactor ImportComposition { a = new ImportedComposition() - state received(false) + state received = False reaction(startup) -> a.x {= a.x.set(42) =} diff --git a/test/Python/src/ManualDelayedReaction.lf b/test/Python/src/ManualDelayedReaction.lf index 0d142405cd..a9e39829eb 100644 --- a/test/Python/src/ManualDelayedReaction.lf +++ b/test/Python/src/ManualDelayedReaction.lf @@ -9,7 +9,7 @@ target Python { reactor GeneratedDelay { input y_in output y_out - state y_state(0) + state y_state = 0 physical action act(0 msec) # TODO: delay in act or the schedule call? diff --git a/test/Python/src/Methods.lf b/test/Python/src/Methods.lf index cc29079dad..5e0023fe8f 100644 --- a/test/Python/src/Methods.lf +++ b/test/Python/src/Methods.lf @@ -2,7 +2,7 @@ target Python main reactor { - state foo(2) + state foo = 2 method getFoo() {= return self.foo =} diff --git a/test/Python/src/MethodsRecursive.lf b/test/Python/src/MethodsRecursive.lf index ca3ea237e7..81afc86bea 100644 --- a/test/Python/src/MethodsRecursive.lf +++ b/test/Python/src/MethodsRecursive.lf @@ -2,7 +2,7 @@ target Python main reactor { - state foo(2) + state foo = 2 method fib(n) {= # Return the n-th Fibonacci number. if n <= 1: diff --git a/test/Python/src/MethodsSameName.lf b/test/Python/src/MethodsSameName.lf index c4d6cdbc4c..a80f521356 100644 --- a/test/Python/src/MethodsSameName.lf +++ b/test/Python/src/MethodsSameName.lf @@ -2,7 +2,7 @@ target Python reactor Foo { - state foo(2) + state foo = 2 method add(x) {= self.foo += x =} @@ -16,7 +16,7 @@ reactor Foo { } main reactor { - state foo(2) + state foo = 2 a = new Foo() diff --git a/test/Python/src/MovingAverage.lf b/test/Python/src/MovingAverage.lf index 505b6a043d..3dbd5636c3 100644 --- a/test/Python/src/MovingAverage.lf +++ b/test/Python/src/MovingAverage.lf @@ -10,7 +10,7 @@ import TestDouble from "lib/Test.lf" reactor MASource { output out - state count(0) + state count = 0 timer clock(0, 200 msec) reaction(clock) -> out {= @@ -21,7 +21,7 @@ reactor MASource { reactor MovingAverageImpl { state delay_line(0.0, 0.0, 0.0) - state index(0) + state index = 0 input m_in output out @@ -45,7 +45,7 @@ reactor MovingAverageImpl { main reactor MovingAverage { s = new MASource() m = new MovingAverageImpl() - p = new TestDouble(expected = (0.0, 0.25, 0.75, 1.5, 2.5, 3.5)) + p = new TestDouble(expected(0.0, 0.25, 0.75, 1.5, 2.5, 3.5)) s.out -> m.m_in m.out -> p.t_in } diff --git a/test/Python/src/MultipleContained.lf b/test/Python/src/MultipleContained.lf index 0b055951c5..27950ccd88 100644 --- a/test/Python/src/MultipleContained.lf +++ b/test/Python/src/MultipleContained.lf @@ -4,7 +4,7 @@ target Python reactor Contained { output trigger - state count(0) + state count = 0 input in1 input in2 diff --git a/test/Python/src/NativeListsAndTimes.lf b/test/Python/src/NativeListsAndTimes.lf index f8b60ed87d..b7b52b3d0a 100644 --- a/test/Python/src/NativeListsAndTimes.lf +++ b/test/Python/src/NativeListsAndTimes.lf @@ -2,22 +2,22 @@ target Python # This test passes if it is successfully compiled into valid target code. main reactor( - x(0), - y(0), # Units are missing but not required - z(1 msec), # Type is missing but not required + x = 0, + y = 0, # Units are missing but not required + z = 1 msec, # Type is missing but not required p(1, 2, 3, 4), # List of integers q(1 msec, 2 msec, 3 msec), # list of time values g(1 msec, 2 msec) # List of time values ) { - state s(y) # Reference to explicitly typed time parameter - state t(z) # Reference to implicitly typed time parameter + state s = y # Reference to explicitly typed time parameter + state t = z # Reference to implicitly typed time parameter state v # Uninitialized boolean state variable state w # Uninitialized time state variable timer tick(0) # Units missing but not required timer tock(1 sec) # Implicit type time timer toe(z) # Implicit type time - state baz(p) # Implicit type int[] - state period(z) # Implicit type time + state baz = p # Implicit type int[] + state period = z # Implicit type time state bar(1 msec, 2 msec, 3 msec) # list of time values state notype(1, 2, 3, 4) diff --git a/test/Python/src/ParameterizedState.lf b/test/Python/src/ParameterizedState.lf index 3511c8d2f5..e8805b027f 100644 --- a/test/Python/src/ParameterizedState.lf +++ b/test/Python/src/ParameterizedState.lf @@ -1,7 +1,7 @@ target Python -reactor Foo(bar(42)) { - state baz(bar) +reactor Foo(bar = 42) { + state baz = bar reaction(startup) {= print("Baz: ", self.baz) =} } diff --git a/test/Python/src/PeriodicDesugared.lf b/test/Python/src/PeriodicDesugared.lf index 5dc7f7bb8f..b003ffc9f8 100644 --- a/test/Python/src/PeriodicDesugared.lf +++ b/test/Python/src/PeriodicDesugared.lf @@ -3,7 +3,7 @@ target Python { timeout: 1 sec } -main reactor(offset(0), period(500 msec)) { +main reactor(offset = 0, period = 500 msec) { logical action init(offset) logical action recur(period) diff --git a/test/Python/src/PingPong.lf b/test/Python/src/PingPong.lf index 25ffdea3a8..f5f80511ae 100644 --- a/test/Python/src/PingPong.lf +++ b/test/Python/src/PingPong.lf @@ -24,10 +24,10 @@ target Python { fast: true } -reactor Ping(count(10)) { +reactor Ping(count = 10) { input receive output send - state pingsLeft(count) + state pingsLeft = count logical action serve reaction(startup, serve) -> send {= @@ -43,10 +43,10 @@ reactor Ping(count(10)) { =} } -reactor Pong(expected(10)) { +reactor Pong(expected = 10) { input receive output send - state count(0) + state count = 0 reaction(receive) -> send {= self.count += 1 diff --git a/test/Python/src/Pipeline.lf b/test/Python/src/Pipeline.lf index 014680e3ca..18436561b8 100644 --- a/test/Python/src/Pipeline.lf +++ b/test/Python/src/Pipeline.lf @@ -17,8 +17,8 @@ reactor TakeTime { reactor Print { input _in - state count(0) - state received(0) + state count = 0 + state received = 0 reaction(_in) {= self.received += 1 @@ -38,7 +38,7 @@ reactor Print { main reactor Pipeline { timer t(0, 200 msec) - state count(0) + state count = 0 c1 = new TakeTime() c2 = new TakeTime() diff --git a/test/Python/src/ReadOutputOfContainedReactor.lf b/test/Python/src/ReadOutputOfContainedReactor.lf index 25c8a1a368..1cb73667ce 100644 --- a/test/Python/src/ReadOutputOfContainedReactor.lf +++ b/test/Python/src/ReadOutputOfContainedReactor.lf @@ -10,7 +10,7 @@ reactor Contained { main reactor ReadOutputOfContainedReactor { c = new Contained() - state count(0) + state count = 0 reaction(startup) c.out {= print("Startup reaction reading output of contained reactor: ", c.out.value) diff --git a/test/Python/src/ScheduleLogicalAction.lf b/test/Python/src/ScheduleLogicalAction.lf index 10f8d4e3cd..3f99c65777 100644 --- a/test/Python/src/ScheduleLogicalAction.lf +++ b/test/Python/src/ScheduleLogicalAction.lf @@ -20,7 +20,7 @@ reactor foo { } reactor print { - state expected_time(0) + state expected_time = 0 input x reaction(x) {= diff --git a/test/Python/src/SelfLoop.lf b/test/Python/src/SelfLoop.lf index 1653b893e3..2b607b09c8 100644 --- a/test/Python/src/SelfLoop.lf +++ b/test/Python/src/SelfLoop.lf @@ -7,7 +7,7 @@ reactor Self { input x output y logical action a - state expected(43) + state expected = 43 reaction(a) -> y {= print("a = ", a.value) diff --git a/test/Python/src/SendingInside.lf b/test/Python/src/SendingInside.lf index 08d05b8ed9..8bcc66c005 100644 --- a/test/Python/src/SendingInside.lf +++ b/test/Python/src/SendingInside.lf @@ -7,7 +7,7 @@ target Python { reactor Printer { input x - state count(1) + state count = 1 reaction(x) {= print("Inside reactor received: ", x.value) @@ -19,7 +19,7 @@ reactor Printer { } main reactor SendingInside { - state count(0) + state count = 0 timer t(0, 1 sec) p = new Printer() diff --git a/test/Python/src/SetArray.lf b/test/Python/src/SetArray.lf index 356899ae8f..4766d529f7 100644 --- a/test/Python/src/SetArray.lf +++ b/test/Python/src/SetArray.lf @@ -9,7 +9,7 @@ reactor Source { reaction(startup) -> out {= out.set([0,1,2]) =} } -reactor Print(scale(1)) { # The scale parameter is just for testing. +reactor Print(scale = 1) { # The scale parameter is just for testing. input _in reaction(_in) {= diff --git a/test/Python/src/SimpleDeadline.lf b/test/Python/src/SimpleDeadline.lf index 0385f95f74..a714124129 100644 --- a/test/Python/src/SimpleDeadline.lf +++ b/test/Python/src/SimpleDeadline.lf @@ -3,7 +3,7 @@ # violation. target Python -reactor Deadline(threshold(100 msec)) { +reactor Deadline(threshold = 100 msec) { input x output deadlineViolation diff --git a/test/Python/src/SlowingClock.lf b/test/Python/src/SlowingClock.lf index b566781677..972421437a 100644 --- a/test/Python/src/SlowingClock.lf +++ b/test/Python/src/SlowingClock.lf @@ -10,8 +10,8 @@ target Python { main reactor SlowingClock { logical action a(100 msec) - state interval(100 msec) - state expected_time(100 msec) + state interval = 100 msec + state expected_time = 100 msec reaction(startup) -> a {= a.schedule(0) =} diff --git a/test/Python/src/SlowingClockPhysical.lf b/test/Python/src/SlowingClockPhysical.lf index b2533acf12..dbb9da705f 100644 --- a/test/Python/src/SlowingClockPhysical.lf +++ b/test/Python/src/SlowingClockPhysical.lf @@ -15,8 +15,8 @@ target Python { main reactor SlowingClockPhysical { # first offset and minimum interarrival time. physical action a(100 msec, 100 msec) - state interval(100 msec) - state expected_time(100 msec) + state interval = 100 msec + state expected_time = 100 msec reaction(startup) -> a {= self.expected_time = MSEC(100) diff --git a/test/Python/src/Stride.lf b/test/Python/src/Stride.lf index 95fe379ead..86c68bab5a 100644 --- a/test/Python/src/Stride.lf +++ b/test/Python/src/Stride.lf @@ -5,8 +5,8 @@ target Python { fast: true } -reactor Count(stride(1)) { - state count(1) +reactor Count(stride = 1) { + state count = 1 output y timer t(0, 100 msec) @@ -18,7 +18,7 @@ reactor Count(stride(1)) { reactor Display { input x - state expected(1) # for testing. + state expected = 1 # for testing. reaction(x) {= print("Received: ", x.value) diff --git a/test/Python/src/StructAsState.lf b/test/Python/src/StructAsState.lf index 4fec8dfc0e..b6f38f8589 100644 --- a/test/Python/src/StructAsState.lf +++ b/test/Python/src/StructAsState.lf @@ -9,7 +9,7 @@ main reactor StructAsState { self.name = name self.value = value =} - state s({= self.hello("Earth", 42) =}) + state s = {= self.hello("Earth", 42) =} reaction(startup) {= print("State s.name=\"{:s}\", value={:d}.".format(self.s.name, self.s.value)) diff --git a/test/Python/src/StructAsType.lf b/test/Python/src/StructAsType.lf index d8955d0064..46951ec86a 100644 --- a/test/Python/src/StructAsType.lf +++ b/test/Python/src/StructAsType.lf @@ -13,7 +13,7 @@ reactor Source { =} } -reactor Print(expected(42)) { # expected parameter is for testing. +reactor Print(expected = 42) { # expected parameter is for testing. input _in reaction(_in) {= diff --git a/test/Python/src/StructAsTypeDirect.lf b/test/Python/src/StructAsTypeDirect.lf index 50f4805a1f..921b7e4390 100644 --- a/test/Python/src/StructAsTypeDirect.lf +++ b/test/Python/src/StructAsTypeDirect.lf @@ -16,7 +16,7 @@ reactor Source { =} } -reactor Print(expected(42)) { # expected parameter is for testing. +reactor Print(expected = 42) { # expected parameter is for testing. input _in reaction(_in) {= diff --git a/test/Python/src/StructParallel.lf b/test/Python/src/StructParallel.lf index fb34a84981..bac79a6abe 100644 --- a/test/Python/src/StructParallel.lf +++ b/test/Python/src/StructParallel.lf @@ -8,7 +8,7 @@ import Source from "StructScale.lf" preamble {= import hello =} -reactor Check(expected(42)) { +reactor Check(expected = 42) { input _in reaction(_in) {= @@ -19,7 +19,7 @@ reactor Check(expected(42)) { =} } -reactor Print(scale(2)) { +reactor Print(scale = 2) { # Mutable keyword indicates that this reactor wants a writable copy of the # input. mutable input _in diff --git a/test/Python/src/StructPrint.lf b/test/Python/src/StructPrint.lf index f232c07a14..3c0138f937 100644 --- a/test/Python/src/StructPrint.lf +++ b/test/Python/src/StructPrint.lf @@ -12,7 +12,7 @@ reactor Print { reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} } -reactor Check(expected(42)) { # expected parameter is for testing. +reactor Check(expected = 42) { # expected parameter is for testing. input _in reaction(_in) {= diff --git a/test/Python/src/StructScale.lf b/test/Python/src/StructScale.lf index e9ed86ff5b..120c6fde65 100644 --- a/test/Python/src/StructScale.lf +++ b/test/Python/src/StructScale.lf @@ -12,7 +12,7 @@ reactor Source { reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} } -reactor TestInput(expected(42)) { # expected parameter is for testing. +reactor TestInput(expected = 42) { # expected parameter is for testing. input _in reaction(_in) {= @@ -23,7 +23,7 @@ reactor TestInput(expected(42)) { # expected parameter is for testing. =} } -reactor Print(scale(2)) { +reactor Print(scale = 2) { # Mutable keyword indicates that this reactor wants a writable copy of the # input. mutable input _in diff --git a/test/Python/src/SubclassesAndStartup.lf b/test/Python/src/SubclassesAndStartup.lf index 9dae1495be..a98e580851 100644 --- a/test/Python/src/SubclassesAndStartup.lf +++ b/test/Python/src/SubclassesAndStartup.lf @@ -1,7 +1,7 @@ target Python reactor Super { - state count(0) + state count = 0 reaction(startup) {= print("{:s}(Super) started".format(self.name)) @@ -15,7 +15,7 @@ reactor Super { =} } -reactor SubA(name("SubA")) extends Super { +reactor SubA(name = "SubA") extends Super { reaction(startup) {= print("{:s} started".format(self.name)) if self.count == 0: @@ -24,7 +24,7 @@ reactor SubA(name("SubA")) extends Super { =} } -reactor SubB(name("SubB")) extends Super { +reactor SubB(name = "SubB") extends Super { reaction(startup) {= print("{:s} started".format(self.name)) if self.count == 0: diff --git a/test/Python/src/TimeLimit.lf b/test/Python/src/TimeLimit.lf index 47577e9ed5..beb7602db9 100644 --- a/test/Python/src/TimeLimit.lf +++ b/test/Python/src/TimeLimit.lf @@ -5,10 +5,10 @@ target Python { fast: true } -reactor Clock(offset(0), period(1 sec)) { +reactor Clock(offset = 0, period = 1 sec) { output y timer t(offset, period) - state count(0) + state count = 0 reaction(t) -> y {= self.count += 1 @@ -19,7 +19,7 @@ reactor Clock(offset(0), period(1 sec)) { reactor Destination { input x - state s(1) + state s = 1 reaction(x) {= # print(x.value) @@ -37,7 +37,7 @@ reactor Destination { =} } -main reactor TimeLimit(period(1 sec)) { +main reactor TimeLimit(period = 1 sec) { timer stop(10 sec) c = new Clock(period = period) d = new Destination() diff --git a/test/Python/src/TimeState.lf b/test/Python/src/TimeState.lf index c12318400b..72ad9f0ebd 100644 --- a/test/Python/src/TimeState.lf +++ b/test/Python/src/TimeState.lf @@ -1,7 +1,7 @@ target Python -reactor Foo(bar(42)) { - state baz(500 msec) +reactor Foo(bar = 42) { + state baz = 500 msec reaction(startup) {= print("Baz: ", self.baz) =} } diff --git a/test/Python/src/Timers.lf b/test/Python/src/Timers.lf index ad59feca99..f6cbba747a 100644 --- a/test/Python/src/Timers.lf +++ b/test/Python/src/Timers.lf @@ -6,7 +6,7 @@ target Python { main reactor { timer t(0, 1 sec) timer t2(0, 2 sec) - state counter(0) + state counter = 0 reaction(t2) {= self.counter += 2 =} diff --git a/test/Python/src/TriggerDownstreamOnlyIfPresent.lf b/test/Python/src/TriggerDownstreamOnlyIfPresent.lf index c436a41cd9..b65f732652 100644 --- a/test/Python/src/TriggerDownstreamOnlyIfPresent.lf +++ b/test/Python/src/TriggerDownstreamOnlyIfPresent.lf @@ -10,7 +10,7 @@ target Python { reactor Source { output a output b - state count(0) + state count = 0 timer t(0, 200 msec) reaction(t) -> a, b {= diff --git a/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf b/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf index 310c1d1d02..b9a9184296 100644 --- a/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf @@ -9,7 +9,7 @@ target Python { reactor Source { output[2] out - state count(0) + state count = 0 timer t(0, 200 msec) reaction(t) -> out {= diff --git a/test/Python/src/UnconnectedInput.lf b/test/Python/src/UnconnectedInput.lf index ee40844a99..66f459138b 100644 --- a/test/Python/src/UnconnectedInput.lf +++ b/test/Python/src/UnconnectedInput.lf @@ -7,7 +7,7 @@ target Python { reactor Source { output out timer t(0, 1 sec) - state s(1) + state s = 1 reaction(t) -> out {= out.set(self.s) @@ -32,7 +32,7 @@ reactor Add { reactor Print { input _in - state expected(1) + state expected = 1 reaction(_in) {= print("Received: ", _in.value) diff --git a/test/Python/src/concurrent/AsyncCallback.lf b/test/Python/src/concurrent/AsyncCallback.lf index 3769f09dc0..5ef4167bed 100644 --- a/test/Python/src/concurrent/AsyncCallback.lf +++ b/test/Python/src/concurrent/AsyncCallback.lf @@ -30,12 +30,12 @@ main reactor AsyncCallback { return None =} timer t(0, 200 msec) - state threads({= list() =}) - state expected_time(100 msec) - state toggle(false) + state threads = {= list() =} + state expected_time = 100 msec + state toggle = False physical action a(100 msec) - state i(0) + state i = 0 reaction(t) -> a {= # start new thread, provide callback diff --git a/test/Python/src/concurrent/AsyncCallbackNoTimer.lf b/test/Python/src/concurrent/AsyncCallbackNoTimer.lf index ff9a8613d6..4e481d1d34 100644 --- a/test/Python/src/concurrent/AsyncCallbackNoTimer.lf +++ b/test/Python/src/concurrent/AsyncCallbackNoTimer.lf @@ -34,12 +34,12 @@ main reactor { return None =} - state threads({= list() =}) - state expected_time(100 msec) - state toggle(false) + state threads = {= list() =} + state expected_time = 100 msec + state toggle = False physical action a(100 msec) - state i(0) + state i = 0 reaction(startup) -> a {= # start new thread, provide callback diff --git a/test/Python/src/docker/FilesPropertyContainerized.lf b/test/Python/src/docker/FilesPropertyContainerized.lf index 2b592921e8..c34736af48 100644 --- a/test/Python/src/docker/FilesPropertyContainerized.lf +++ b/test/Python/src/docker/FilesPropertyContainerized.lf @@ -17,7 +17,7 @@ main reactor { except: lf_request_stop() =} - state passed(false) + state passed = False timer t(1 msec) reaction(t) {= self.passed = True =} diff --git a/test/Python/src/docker/federated/DistributedCountContainerized.lf b/test/Python/src/docker/federated/DistributedCountContainerized.lf index 50f1f5cb12..5f8a348d24 100644 --- a/test/Python/src/docker/federated/DistributedCountContainerized.lf +++ b/test/Python/src/docker/federated/DistributedCountContainerized.lf @@ -15,7 +15,7 @@ target Python { import Count from "../../lib/Count.lf" import Print from "../../federated/DistributedCount.lf" -federated reactor DistributedCountContainerized(offset(200 msec)) at rti { +federated reactor DistributedCountContainerized(offset = 200 msec) at rti { c = new Count() p = new Print() c.out -> p.in_ after offset diff --git a/test/Python/src/federated/BroadcastFeedback.lf b/test/Python/src/federated/BroadcastFeedback.lf index e7c8dcb527..75d313e61d 100644 --- a/test/Python/src/federated/BroadcastFeedback.lf +++ b/test/Python/src/federated/BroadcastFeedback.lf @@ -8,7 +8,7 @@ target Python { reactor SenderAndReceiver { output out input[2] inp - state received(False) + state received = False reaction(startup) -> out {= out.set(42) =} diff --git a/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf b/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf index 63cd79ad1f..ad2a11c10c 100644 --- a/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf +++ b/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf @@ -8,7 +8,7 @@ target Python { reactor SenderAndReceiver { output out input[2] in_ - state received(False) + state received = False r = new Receiver() in_ -> r.in_ @@ -19,7 +19,7 @@ reactor SenderAndReceiver { reactor Receiver { preamble {= import sys =} input[2] in_ - state received(False) + state received = False reaction(in_) {= if in_[0].is_present and in_[1].is_present and in_[0].value == 42 and in_[1].value == 42: diff --git a/test/Python/src/federated/CycleDetection.lf b/test/Python/src/federated/CycleDetection.lf index faba30f7e1..cf9b6d6b54 100644 --- a/test/Python/src/federated/CycleDetection.lf +++ b/test/Python/src/federated/CycleDetection.lf @@ -10,7 +10,7 @@ reactor CAReplica { input remote_update input query - state balance(0) + state balance = 0 output response diff --git a/test/Python/src/federated/DecentralizedP2PComm.lf b/test/Python/src/federated/DecentralizedP2PComm.lf index 29aee88ad5..2725386915 100644 --- a/test/Python/src/federated/DecentralizedP2PComm.lf +++ b/test/Python/src/federated/DecentralizedP2PComm.lf @@ -5,13 +5,13 @@ target Python { coordination: decentralized } -reactor Platform(start(0), expected_start(0), stp_offset_param(0)) { +reactor Platform(start = 0, expected_start = 0, stp_offset_param = 0) { preamble {= import sys =} input in_ output out timer t(0, 100 msec) - state count(start) - state expected(expected_start) + state count = start + state expected = expected_start reaction(t) -> out {= out.set(self.count) diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf index 960a06c650..48ff7a4ca7 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf @@ -12,10 +12,10 @@ target Python { } # reason for failing: lf_tag() not supported by the python target -reactor Clock(offset(0), period(1 sec)) { +reactor Clock(offset = 0, period = 1 sec) { output y timer t(offset, period) - state count(0) + state count = 0 reaction(t) -> y {= self.count += 1 @@ -29,7 +29,7 @@ reactor Clock(offset(0), period(1 sec)) { reactor Destination { preamble {= import sys =} input x - state s(1) + state s = 1 state startup_logical_time reaction(startup) {= self.startup_logical_time = lf.time.logical() =} @@ -50,7 +50,7 @@ reactor Destination { =} } -federated reactor(period(10 usec)) { +federated reactor(period = 10 usec) { c = new Clock(period = period) d = new Destination() c.y -> d.x diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index c9de7270c6..4eb881694f 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -12,10 +12,10 @@ target Python { coordination: decentralized } -reactor Clock(offset(0), period(1 sec)) { +reactor Clock(offset = 0, period = 1 sec) { output y timer t(offset, period) - state count(0) + state count = 0 reaction(t) -> y {= self.count += 1 @@ -28,7 +28,7 @@ reactor Clock(offset(0), period(1 sec)) { reactor Destination { preamble {= import sys =} input x - state s(1) + state s = 1 reaction(x) {= if x.value != self.s: @@ -43,7 +43,7 @@ reactor Destination { =} } -federated reactor(period(10 usec)) { +federated reactor(period = 10 usec) { c = new Clock(period = period) d = new Destination() c.y ~> d.x diff --git a/test/Python/src/federated/DistributedBank.lf b/test/Python/src/federated/DistributedBank.lf index ace6b6b53c..de9ea298e4 100644 --- a/test/Python/src/federated/DistributedBank.lf +++ b/test/Python/src/federated/DistributedBank.lf @@ -7,7 +7,7 @@ target Python { reactor Node { preamble {= import sys =} timer t(0, 100 msec) - state count(0) + state count = 0 reaction(t) {= print("Hello world {}.".format(self.count)) diff --git a/test/Python/src/federated/DistributedBankToMultiport.lf b/test/Python/src/federated/DistributedBankToMultiport.lf index f40a85fc65..493e73a3b1 100644 --- a/test/Python/src/federated/DistributedBankToMultiport.lf +++ b/test/Python/src/federated/DistributedBankToMultiport.lf @@ -8,7 +8,7 @@ import Count from "../lib/Count.lf" reactor Destination { preamble {= import sys =} input[2] in_ - state count(1) + state count = 1 reaction(in_) {= for i in range(len(in_)): diff --git a/test/Python/src/federated/DistributedCount.lf b/test/Python/src/federated/DistributedCount.lf index eb90b4d672..7713256520 100644 --- a/test/Python/src/federated/DistributedCount.lf +++ b/test/Python/src/federated/DistributedCount.lf @@ -15,7 +15,7 @@ import Count from "../lib/Count.lf" reactor Print { preamble {= import sys =} input in_ - state c(1) + state c = 1 reaction(in_) {= elapsed_time = lf.time.logical_elapsed() @@ -36,7 +36,7 @@ reactor Print { =} } -federated reactor DistributedCount(offset(200 msec)) { +federated reactor DistributedCount(offset = 200 msec) { c = new Count() p = new Print() c.out -> p.in_ after offset diff --git a/test/Python/src/federated/DistributedCountDecentralized.lf b/test/Python/src/federated/DistributedCountDecentralized.lf index 232c3ef830..e86adf9946 100644 --- a/test/Python/src/federated/DistributedCountDecentralized.lf +++ b/test/Python/src/federated/DistributedCountDecentralized.lf @@ -16,7 +16,7 @@ import Count from "../lib/Count.lf" reactor Print { preamble {= import sys =} input in_ - state c(1) + state c = 1 reaction(in_) {= print(f"At tag ({lf.time.logical_elapsed()}, {lf.tag().microstep}), received {in_.value}. " diff --git a/test/Python/src/federated/DistributedCountDecentralizedLate.lf b/test/Python/src/federated/DistributedCountDecentralizedLate.lf index 617673aa0e..e3a6899e78 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLate.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLate.lf @@ -18,12 +18,12 @@ reactor Print { # STP () input in_ # STP(in, 30 msec); - state success(0) - state success_stp_violation(0) + state success = 0 + state success_stp_violation = 0 # Force a timer to be invoke periodically timer t(0, 10 usec) # to ensure logical time will advance in the absence of incoming messages. - state c(0) + state c = 0 reaction(in_) {= current_tag = lf.tag() diff --git a/test/Python/src/federated/DistributedCountDecentralizedLateDownstream.lf b/test/Python/src/federated/DistributedCountDecentralizedLateDownstream.lf index 18a55f7e6b..c1c641827f 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLateDownstream.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLateDownstream.lf @@ -28,12 +28,12 @@ import Count from "../lib/Count.lf" reactor ImportantActuator { input inp # Count messages that arrive without STP violation. - state success(0) - state success_stp_violation(0) + state success = 0 + state success_stp_violation = 0 # Force a timer to be invoked periodically timer t(0, 10 usec) # to ensure logical time will advance in the absence of incoming messages. - state c(0) + state c = 0 reaction(inp) {= current_tag = lf.tag() @@ -81,7 +81,7 @@ reactor Receiver { # Force a timer to be invoke periodically timer t(0, 10 msec) # to ensure logical time will advance in the absence of incoming messages. - state c(0) + state c = 0 p = new Print() a = new ImportantActuator() diff --git a/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf b/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf index e9a1bec87e..d806ab5453 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf @@ -21,7 +21,7 @@ reactor Receiver { # Force a timer to be invoke periodically timer t(0, 10 msec) # to ensure logical time will advance in the absence of incoming messages. - state c(0) + state c = 0 p = new Print() a = new ImportantActuator() inp -> p.inp diff --git a/test/Python/src/federated/DistributedCountPhysical.lf b/test/Python/src/federated/DistributedCountPhysical.lf index b957e06172..69bc2faee9 100644 --- a/test/Python/src/federated/DistributedCountPhysical.lf +++ b/test/Python/src/federated/DistributedCountPhysical.lf @@ -13,7 +13,7 @@ target Python { reactor Count { timer t(200 msec, 1 sec) - state s(0) + state s = 0 output out reaction(t) -> out {= @@ -25,7 +25,7 @@ reactor Count { reactor Print { preamble {= import sys =} input in_ - state c(0) + state c = 0 reaction(in_) {= elapsed_time = lf.time.logical_elapsed() diff --git a/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf index 80c931184b..105413d0a0 100644 --- a/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf +++ b/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -13,7 +13,7 @@ target Python { reactor Count { timer t(200 msec, 1 sec) - state s(0) + state s = 0 output out reaction(t) -> out {= @@ -25,7 +25,7 @@ reactor Count { reactor Print { preamble {= import sys =} input in_ - state c(0) + state c = 0 reaction(in_) {= elapsed_time = lf.time.logical_elapsed() diff --git a/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf b/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf index 120bb6255c..0008479138 100644 --- a/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf +++ b/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf @@ -14,7 +14,7 @@ target Python { reactor Count { timer t(200 msec, 1 sec) - state s(0) + state s = 0 output out reaction(t) -> out {= @@ -26,7 +26,7 @@ reactor Count { reactor Print { preamble {= import sys =} input in_ - state c(0) + state c = 0 reaction(in_) {= elapsed_time = lf.time.logical_elapsed() diff --git a/test/Python/src/federated/DistributedDoublePort.lf b/test/Python/src/federated/DistributedDoublePort.lf index 03ad2c4d08..9eb24209e6 100644 --- a/test/Python/src/federated/DistributedDoublePort.lf +++ b/test/Python/src/federated/DistributedDoublePort.lf @@ -14,7 +14,7 @@ target Python { import Count from "../lib/Count.lf" reactor CountMicrostep { - state count(1) + state count = 1 output out logical action act timer t(0, 1 sec) diff --git a/test/Python/src/federated/DistributedLoopedAction.lf b/test/Python/src/federated/DistributedLoopedAction.lf index 83aa1de0a6..8f71d15363 100644 --- a/test/Python/src/federated/DistributedLoopedAction.lf +++ b/test/Python/src/federated/DistributedLoopedAction.lf @@ -10,12 +10,12 @@ target Python { import Sender from "../lib/LoopedActionSender.lf" -reactor Receiver(take_a_break_after(10), break_interval(400 msec)) { +reactor Receiver(take_a_break_after = 10, break_interval = 400 msec) { preamble {= import sys =} input in_ - state received_messages(0) - state total_received_messages(0) - state breaks(0) + state received_messages = 0 + state total_received_messages = 0 + state breaks = 0 timer t(0, 1 msec) # This will impact the performance # but forces the logical time to advance Comment this line for a more diff --git a/test/Python/src/federated/DistributedLoopedPhysicalAction.lf b/test/Python/src/federated/DistributedLoopedPhysicalAction.lf index a2cce3742a..d992e3d841 100644 --- a/test/Python/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/Python/src/federated/DistributedLoopedPhysicalAction.lf @@ -14,10 +14,10 @@ target Python { keepalive: true } -reactor Sender(take_a_break_after(10), break_interval(550 msec)) { +reactor Sender(take_a_break_after = 10, break_interval = 550 msec) { output out physical action act - state sent_messages(0) + state sent_messages = 0 reaction(startup, act) -> act, out {= # Send a message on out @@ -32,12 +32,12 @@ reactor Sender(take_a_break_after(10), break_interval(550 msec)) { =} } -reactor Receiver(take_a_break_after(10), break_interval(550 msec)) { +reactor Receiver(take_a_break_after = 10, break_interval = 550 msec) { preamble {= import sys =} input in_ - state received_messages(0) - state total_received_messages(0) - state breaks(0) + state received_messages = 0 + state total_received_messages = 0 + state breaks = 0 timer t(0, 1 msec) # This will impact the performance # but forces the logical time to advance Comment this line for a more # sensible log output. diff --git a/test/Python/src/federated/DistributedMultiport.lf b/test/Python/src/federated/DistributedMultiport.lf index 729f8697d8..7250f838ef 100644 --- a/test/Python/src/federated/DistributedMultiport.lf +++ b/test/Python/src/federated/DistributedMultiport.lf @@ -7,7 +7,7 @@ target Python { reactor Source { output[4] out timer t(0, 100 msec) - state count(0) + state count = 0 reaction(t) -> out {= for i in range(len(out)): @@ -19,7 +19,7 @@ reactor Source { reactor Destination { preamble {= import sys =} input[4] in_ - state count(0) + state count = 0 reaction(in_) {= for i in range(len(in_)): diff --git a/test/Python/src/federated/DistributedMultiportToBank.lf b/test/Python/src/federated/DistributedMultiportToBank.lf index cbd500394e..69c87b7f0c 100644 --- a/test/Python/src/federated/DistributedMultiportToBank.lf +++ b/test/Python/src/federated/DistributedMultiportToBank.lf @@ -6,7 +6,7 @@ target Python { reactor Source { output[2] out timer t(0, 100 msec) - state count(0) + state count = 0 reaction(t) -> out {= for i in range(len(out)): @@ -18,7 +18,7 @@ reactor Source { reactor Destination { preamble {= import sys =} input in_ - state count(0) + state count = 0 reaction(in_) {= print("Received {}.".format(in_.value)) diff --git a/test/Python/src/federated/DistributedMultiportToken.lf b/test/Python/src/federated/DistributedMultiportToken.lf index fdecd67c32..284e1c21a3 100644 --- a/test/Python/src/federated/DistributedMultiportToken.lf +++ b/test/Python/src/federated/DistributedMultiportToken.lf @@ -8,7 +8,7 @@ target Python { reactor Source { output[4] out timer t(0, 200 msec) - state count(0) + state count = 0 reaction(t) -> out {= for i in range(len(out)): diff --git a/test/Python/src/federated/DistributedStop.lf b/test/Python/src/federated/DistributedStop.lf index b4a84b8bef..06dfe96c36 100644 --- a/test/Python/src/federated/DistributedStop.lf +++ b/test/Python/src/federated/DistributedStop.lf @@ -12,7 +12,7 @@ reactor Sender { output out timer t(0, 1 usec) logical action act - state reaction_invoked_correctly(False) + state reaction_invoked_correctly = False reaction(t, act) -> out, act {= tag = lf.tag() @@ -62,10 +62,10 @@ reactor Sender { } reactor Receiver( - stp_offset(10 msec) # Used in the decentralized variant of the test + stp_offset = 10 msec # Used in the decentralized variant of the test ) { input in_ - state reaction_invoked_correctly(False) + state reaction_invoked_correctly = False reaction(in_) {= tag = lf.tag() diff --git a/test/Python/src/federated/HelloDistributed.lf b/test/Python/src/federated/HelloDistributed.lf index 5b8a2a55e4..ef99c3f793 100644 --- a/test/Python/src/federated/HelloDistributed.lf +++ b/test/Python/src/federated/HelloDistributed.lf @@ -19,7 +19,7 @@ reactor Source { reactor Destination { input _in - state received(false) + state received = False reaction(startup) {= print("Destination started.") =} diff --git a/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf b/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf index 9dc86b3c60..2719fd57ba 100644 --- a/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf +++ b/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf @@ -14,11 +14,11 @@ target Python { timeout: 5 sec } -reactor Contained(incr(1)) { +reactor Contained(incr = 1) { timer t(0, 1 sec) input inp - state count(0) - state received_count(0) + state count = 0 + state received_count = 0 reaction(t) {= self.count += self.incr =} @@ -31,10 +31,10 @@ reactor Contained(incr(1)) { =} } -reactor Looper(incr(1), delay(0 msec)) { +reactor Looper(incr = 1, delay = 0 msec) { input inp output out - state count(0) + state count = 0 timer t(0, 1 sec) c = new Contained(incr = incr) @@ -59,7 +59,7 @@ reactor Looper(incr(1), delay(0 msec)) { =} } -federated reactor(delay(0)) { +federated reactor(delay = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.inp diff --git a/test/Python/src/federated/PhysicalSTP.lf b/test/Python/src/federated/PhysicalSTP.lf index 75e5071bca..5edc61df34 100644 --- a/test/Python/src/federated/PhysicalSTP.lf +++ b/test/Python/src/federated/PhysicalSTP.lf @@ -9,10 +9,10 @@ target Python { import Count from "../lib/Count.lf" -reactor Print(STP_offset(0)) { +reactor Print(STP_offset = 0) { preamble {= import sys =} input in_ - state c(1) + state c = 1 reaction(in_) {= elapsed_time = lf.time.logical_elapsed() diff --git a/test/Python/src/federated/PingPongDistributed.lf b/test/Python/src/federated/PingPongDistributed.lf index a157baa22a..0f58cbf7db 100644 --- a/test/Python/src/federated/PingPongDistributed.lf +++ b/test/Python/src/federated/PingPongDistributed.lf @@ -21,10 +21,10 @@ */ target Python -reactor Ping(count(10)) { +reactor Ping(count = 10) { input receive output send - state pingsLeft(count) + state pingsLeft = count logical action serve reaction(startup, serve) -> send {= @@ -41,12 +41,12 @@ reactor Ping(count(10)) { =} } -reactor Pong(expected(10)) { +reactor Pong(expected = 10) { preamble {= import sys =} input receive output send - state count(0) + state count = 0 reaction(receive) -> send {= self.count += 1 @@ -64,7 +64,7 @@ reactor Pong(expected(10)) { =} } -federated reactor(count(10)) { +federated reactor(count = 10) { ping = new Ping(count = count) pong = new Pong(expected = count) ping.send ~> pong.receive diff --git a/test/Python/src/federated/failing/LoopDistributedCentralizedPrecedence.lf b/test/Python/src/federated/failing/LoopDistributedCentralizedPrecedence.lf index 9068ebfae8..12367332f4 100644 --- a/test/Python/src/federated/failing/LoopDistributedCentralizedPrecedence.lf +++ b/test/Python/src/federated/failing/LoopDistributedCentralizedPrecedence.lf @@ -16,11 +16,11 @@ target Python { timeout: 5 sec } -reactor Looper(incr(1), delay(0 msec)) { +reactor Looper(incr = 1, delay = 0 msec) { input in_ output out - state count(0) - state received_count(0) + state count = 0 + state received_count = 0 timer t(0, 1 sec) reaction(t) -> out {= @@ -50,7 +50,7 @@ reactor Looper(incr(1), delay(0 msec)) { =} } -federated reactor(delay(0)) { +federated reactor(delay = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.in_ diff --git a/test/Python/src/federated/failing/LoopDistributedDouble.lf b/test/Python/src/federated/failing/LoopDistributedDouble.lf index 8788d09288..4ccee4acd6 100644 --- a/test/Python/src/federated/failing/LoopDistributedDouble.lf +++ b/test/Python/src/federated/failing/LoopDistributedDouble.lf @@ -24,13 +24,13 @@ preamble {= } =} -reactor Looper(incr(1), delay(0 msec)) { +reactor Looper(incr = 1, delay = 0 msec) { input in_ input in2 output out output out2 physical action a(delay) - state count(0) + state count = 0 timer t(0, 1 sec) reaction(startup) -> a {= @@ -79,7 +79,7 @@ reactor Looper(incr(1), delay(0 msec)) { =} } -federated reactor(delay(0)) { +federated reactor(delay = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.in_ diff --git a/test/Python/src/lib/Count.lf b/test/Python/src/lib/Count.lf index bcfae967b6..26b53ce13b 100644 --- a/test/Python/src/lib/Count.lf +++ b/test/Python/src/lib/Count.lf @@ -1,7 +1,7 @@ target Python -reactor Count(offset(0), period(1 sec)) { - state count(1) +reactor Count(offset = 0, period = 1 sec) { + state count = 1 output out timer t(offset, period) diff --git a/test/Python/src/lib/InternalDelay.lf b/test/Python/src/lib/InternalDelay.lf index f2ac5449c0..a9796aa8d9 100644 --- a/test/Python/src/lib/InternalDelay.lf +++ b/test/Python/src/lib/InternalDelay.lf @@ -1,6 +1,6 @@ target Python -reactor InternalDelay(delay(10 msec)) { +reactor InternalDelay(delay = 10 msec) { input in_ output out logical action d diff --git a/test/Python/src/lib/LoopedActionSender.lf b/test/Python/src/lib/LoopedActionSender.lf index 3a01219ec8..9d4048d0ea 100644 --- a/test/Python/src/lib/LoopedActionSender.lf +++ b/test/Python/src/lib/LoopedActionSender.lf @@ -11,10 +11,10 @@ target Python * @param break_interval: Determines how long the reactor should take a break * after sending take_a_break_after messages. */ -reactor Sender(take_a_break_after(10), break_interval(400 msec)) { +reactor Sender(take_a_break_after = 10, break_interval = 400 msec) { output out logical action act - state sent_messages(0) + state sent_messages = 0 reaction(startup, act) -> act, out {= # Send a message on out diff --git a/test/Python/src/lib/Test.lf b/test/Python/src/lib/Test.lf index f6bbf867ee..301ed9c8e6 100644 --- a/test/Python/src/lib/Test.lf +++ b/test/Python/src/lib/Test.lf @@ -2,7 +2,7 @@ target Python reactor TestDouble(expected(1.0, 1.0, 1.0, 1.0)) { input t_in - state count(0) + state count = 0 reaction(t_in) {= print("Received: ", t_in.value) diff --git a/test/Python/src/lib/TestCount.lf b/test/Python/src/lib/TestCount.lf index dfe11cd5b9..de611cbc69 100644 --- a/test/Python/src/lib/TestCount.lf +++ b/test/Python/src/lib/TestCount.lf @@ -9,10 +9,10 @@ */ target Python -reactor TestCount(start(1), stride(1), num_inputs(1)) { +reactor TestCount(start = 1, stride = 1, num_inputs = 1) { preamble {= import sys =} - state count(start) - state inputs_received(0) + state count = start + state inputs_received = 0 input in_ reaction(in_) {= diff --git a/test/Python/src/lib/TestCountMultiport.lf b/test/Python/src/lib/TestCountMultiport.lf index d9b711ce89..c30572e4d5 100644 --- a/test/Python/src/lib/TestCountMultiport.lf +++ b/test/Python/src/lib/TestCountMultiport.lf @@ -11,10 +11,10 @@ */ target Python -reactor TestCountMultiport(start(1), stride(1), num_inputs(1), width(2)) { +reactor TestCountMultiport(start = 1, stride = 1, num_inputs = 1, width = 2) { preamble {= import sys =} - state count(start) - state inputs_received(0) + state count = start + state inputs_received = 0 input[width] inp reaction(inp) {= diff --git a/test/Python/src/modal_models/ConvertCaseTest.lf b/test/Python/src/modal_models/ConvertCaseTest.lf index f391660322..f3bdee59fe 100644 --- a/test/Python/src/modal_models/ConvertCaseTest.lf +++ b/test/Python/src/modal_models/ConvertCaseTest.lf @@ -67,9 +67,9 @@ reactor Converter { } } -reactor InputFeeder(message("")) { +reactor InputFeeder(message = "") { output character - state idx(0) + state idx = 0 timer t(0, 250 msec) diff --git a/test/Python/src/modal_models/Count3Modes.lf b/test/Python/src/modal_models/Count3Modes.lf index e512e7d54a..7e2e9d98e2 100644 --- a/test/Python/src/modal_models/Count3Modes.lf +++ b/test/Python/src/modal_models/Count3Modes.lf @@ -34,7 +34,7 @@ main reactor { timer stepper(0, 250 msec) counter = new CounterCycle() - state expected_value(1) + state expected_value = 1 reaction(stepper) -> counter.next {= counter.next.set(True) =} # Trigger diff --git a/test/Python/src/modal_models/ModalAfter.lf b/test/Python/src/modal_models/ModalAfter.lf index c86002c9fa..19c84f33d5 100644 --- a/test/Python/src/modal_models/ModalAfter.lf +++ b/test/Python/src/modal_models/ModalAfter.lf @@ -45,7 +45,7 @@ reactor Modal { } } -reactor Producer(mode_id(0)) { +reactor Producer(mode_id = 0) { output product timer t(0, 750 msec) @@ -56,7 +56,7 @@ reactor Producer(mode_id(0)) { =} } -reactor Consumer(mode_id(0)) { +reactor Consumer(mode_id = 0) { input product output report diff --git a/test/Python/src/modal_models/ModalCycleBreaker.lf b/test/Python/src/modal_models/ModalCycleBreaker.lf index baafdf8378..1ceb2eb5d0 100644 --- a/test/Python/src/modal_models/ModalCycleBreaker.lf +++ b/test/Python/src/modal_models/ModalCycleBreaker.lf @@ -39,11 +39,11 @@ reactor Modal { } } -reactor Counter(period(1 sec)) { +reactor Counter(period = 1 sec) { output value timer t(0, period) - state curval(0) + state curval = 0 reaction(t) -> value {= value.set(self.curval) diff --git a/test/Python/src/modal_models/ModalStateReset.lf b/test/Python/src/modal_models/ModalStateReset.lf index 9bd969b15c..11b7425b63 100644 --- a/test/Python/src/modal_models/ModalStateReset.lf +++ b/test/Python/src/modal_models/ModalStateReset.lf @@ -14,7 +14,7 @@ reactor Modal { output count1 output count2 - state counter0(0) + state counter0 = 0 reaction(next) -> count0 {= print(f"Counter0: {self.counter0}") @@ -23,7 +23,7 @@ reactor Modal { =} initial mode One { - state counter1(0) + state counter1 = 0 timer T1(0 msec, 250 msec) reaction(reset) {= self.counter1 = 0 =} @@ -41,7 +41,7 @@ reactor Modal { } mode Two { - state counter2(-2) + state counter2 = -2 timer T2(0 msec, 250 msec) reaction(reset) {= self.counter2 = -2 =} diff --git a/test/Python/src/modal_models/ModalStateResetAuto.lf b/test/Python/src/modal_models/ModalStateResetAuto.lf index be664676db..492e12259b 100644 --- a/test/Python/src/modal_models/ModalStateResetAuto.lf +++ b/test/Python/src/modal_models/ModalStateResetAuto.lf @@ -14,7 +14,7 @@ reactor Modal { output count1 output count2 - state counter0(0) + state counter0 = 0 reaction(next) -> count0 {= print(f"Counter0: {self.counter0}") @@ -23,7 +23,7 @@ reactor Modal { =} initial mode One { - state counter1(0) + state counter1 = 0 timer T1(0 msec, 250 msec) reaction(T1) -> count1 {= print(f"Counter1: {self.counter1}") @@ -39,7 +39,7 @@ reactor Modal { } mode Two { - reset state counter2(-2) + reset state counter2 = -2 timer T2(0 msec, 250 msec) reaction(T2) -> count2 {= print(f"Counter2: {self.counter2}") diff --git a/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf b/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf index 5654dd9b1e..3dd42f67ce 100644 --- a/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf +++ b/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf @@ -28,11 +28,11 @@ reactor Modal { } } -reactor Counter(period(1 sec)) { +reactor Counter(period = 1 sec) { output value timer t(0, period) - reset state curval(0) + reset state curval = 0 reaction(t) -> value {= value.set(self.curval) diff --git a/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf b/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf index 80c4247972..86f5668357 100644 --- a/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf +++ b/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf @@ -31,11 +31,11 @@ reactor Modal { } } -reactor Counter(period(1 sec)) { +reactor Counter(period = 1 sec) { output value timer t(0, period) - reset state curval(0) + reset state curval = 0 reaction(t) -> value {= value.set(self.curval) diff --git a/test/Python/src/modal_models/util/TraceTesting.lf b/test/Python/src/modal_models/util/TraceTesting.lf index 1014ac3c8d..305ff31a5b 100644 --- a/test/Python/src/modal_models/util/TraceTesting.lf +++ b/test/Python/src/modal_models/util/TraceTesting.lf @@ -1,13 +1,13 @@ /** Utility reactor to record and test execution traces. */ target Python -reactor TraceTesting(events_size(0), trace({= [] =}), training(False)) { +reactor TraceTesting(events_size = 0, trace = {= [] =}, training = False) { input[events_size] events - state last_reaction_time(0) - state trace_idx(0) - state recorded_events({= [] =}) - state recorded_events_next(0) + state last_reaction_time = 0 + state trace_idx = 0 + state recorded_events = {= [] =} + state recorded_events_next = 0 reaction(startup) {= self.last_reaction_time = lf.time.logical() =} diff --git a/test/Python/src/multiport/BankIndexInitializer.lf b/test/Python/src/multiport/BankIndexInitializer.lf index 6754f31d97..52ef58bb1d 100644 --- a/test/Python/src/multiport/BankIndexInitializer.lf +++ b/test/Python/src/multiport/BankIndexInitializer.lf @@ -3,15 +3,15 @@ target Python preamble {= table = [4, 3, 2, 1] =} -reactor Source(bank_index(0), value(0)) { +reactor Source(bank_index = 0, value = 0) { output out reaction(startup) -> out {= out.set(self.value) =} } -reactor Sink(width(4)) { +reactor Sink(width = 4) { input[width] _in - state received(false) + state received = False reaction(_in) {= for (idx, port) in enumerate(_in): @@ -30,7 +30,7 @@ reactor Sink(width(4)) { =} } -main reactor(width(4)) { +main reactor(width = 4) { source = new[width] Source(value = {= table[bank_index] =}) sink = new Sink(width = width) source.out -> sink._in diff --git a/test/Python/src/multiport/BankReactionsInContainer.lf b/test/Python/src/multiport/BankReactionsInContainer.lf index 3a72418405..7316463c3d 100644 --- a/test/Python/src/multiport/BankReactionsInContainer.lf +++ b/test/Python/src/multiport/BankReactionsInContainer.lf @@ -5,10 +5,10 @@ target Python { timeout: 1 sec } -reactor R(bank_index(0)) { +reactor R(bank_index = 0) { output[2] out input[2] inp - state received(false) + state received = False reaction(startup) -> out {= for (i, p) in enumerate(out): @@ -37,7 +37,7 @@ reactor R(bank_index(0)) { main reactor { s = new[2] R() - state received(false) + state received = False reaction(startup) -> s.inp {= count = 0 diff --git a/test/Python/src/multiport/BankToBank.lf b/test/Python/src/multiport/BankToBank.lf index e94b7dd717..6e3ddc734d 100644 --- a/test/Python/src/multiport/BankToBank.lf +++ b/test/Python/src/multiport/BankToBank.lf @@ -4,10 +4,10 @@ target Python { fast: true } -reactor Source(bank_index(0)) { +reactor Source(bank_index = 0) { timer t(0, 200 msec) output out - state s(0) + state s = 0 reaction(t) -> out {= out.set(self.s) @@ -15,8 +15,8 @@ reactor Source(bank_index(0)) { =} } -reactor Destination(bank_index(0)) { - state s(0) +reactor Destination(bank_index = 0) { + state s = 0 input _in reaction(_in) {= @@ -35,7 +35,7 @@ reactor Destination(bank_index(0)) { =} } -main reactor BankToBank(width(4)) { +main reactor BankToBank(width = 4) { a = new[width] Source() b = new[width] Destination() a.out -> b._in diff --git a/test/Python/src/multiport/BankToBankMultiport.lf b/test/Python/src/multiport/BankToBankMultiport.lf index de2f05a55d..f335e53858 100644 --- a/test/Python/src/multiport/BankToBankMultiport.lf +++ b/test/Python/src/multiport/BankToBankMultiport.lf @@ -4,10 +4,10 @@ target Python { fast: true } -reactor Source(width(1)) { +reactor Source(width = 1) { timer t(0, 200 msec) output[width] out - state s(0) + state s = 0 reaction(t) -> out {= for port in out: @@ -16,8 +16,8 @@ reactor Source(width(1)) { =} } -reactor Destination(width(1)) { - state s(6) +reactor Destination(width = 1) { + state s = 6 input[width] _in reaction(_in) {= @@ -43,7 +43,7 @@ reactor Destination(width(1)) { =} } -main reactor BankToBankMultiport(bank_width(4)) { +main reactor BankToBankMultiport(bank_width = 4) { a = new[bank_width] Source(width = 4) b = new[bank_width] Destination(width = 4) a.out -> b._in diff --git a/test/Python/src/multiport/BankToBankMultiportAfter.lf b/test/Python/src/multiport/BankToBankMultiportAfter.lf index eb7f025772..9d6e946122 100644 --- a/test/Python/src/multiport/BankToBankMultiportAfter.lf +++ b/test/Python/src/multiport/BankToBankMultiportAfter.lf @@ -6,7 +6,7 @@ target Python { import Source, Destination from "BankToBankMultiport.lf" -main reactor BankToBankMultiportAfter(bank_width(4)) { +main reactor BankToBankMultiportAfter(bank_width = 4) { a = new[bank_width] Source(width = 4) b = new[bank_width] Destination(width = 4) a.out -> b._in after 200 msec diff --git a/test/Python/src/multiport/BankToMultiport.lf b/test/Python/src/multiport/BankToMultiport.lf index 110295400d..769e0ea2fc 100644 --- a/test/Python/src/multiport/BankToMultiport.lf +++ b/test/Python/src/multiport/BankToMultiport.lf @@ -1,15 +1,15 @@ # Test bank of reactors to multiport input with id parameter in the bank. target Python -reactor Source(bank_index(0)) { +reactor Source(bank_index = 0) { output out reaction(startup) -> out {= out.set(self.bank_index) =} } -reactor Sink(width(4)) { +reactor Sink(width = 4) { input[width] _in - state received(false) + state received = False reaction(_in) {= for (idx, port) in enumerate(_in): @@ -28,7 +28,7 @@ reactor Sink(width(4)) { =} } -main reactor BankToMultiport(width(5)) { +main reactor BankToMultiport(width = 5) { source = new[width] Source() sink = new Sink(width = width) source.out -> sink._in diff --git a/test/Python/src/multiport/Broadcast.lf b/test/Python/src/multiport/Broadcast.lf index ebc4de3067..2e507d607f 100644 --- a/test/Python/src/multiport/Broadcast.lf +++ b/test/Python/src/multiport/Broadcast.lf @@ -3,15 +3,15 @@ target Python { fast: true } -reactor Source(value(42)) { +reactor Source(value = 42) { output out reaction(startup) -> out {= out.set(self.value) =} } -reactor Destination(bank_index(0), delay(0)) { +reactor Destination(bank_index = 0, delay = 0) { input _in - state received(false) + state received = False reaction(_in) {= print(f"Destination {self.bank_index} received {_in.value}.") diff --git a/test/Python/src/multiport/BroadcastMultipleAfter.lf b/test/Python/src/multiport/BroadcastMultipleAfter.lf index 7777406c38..9fc327e6fd 100644 --- a/test/Python/src/multiport/BroadcastMultipleAfter.lf +++ b/test/Python/src/multiport/BroadcastMultipleAfter.lf @@ -5,9 +5,9 @@ target Python { import Source from "Broadcast.lf" -reactor Destination(bank_index(0), delay(0)) { +reactor Destination(bank_index = 0, delay = 0) { input _in - state received(false) + state received = False reaction(_in) {= print(f"Destination {self.bank_index} received {_in.value}.") diff --git a/test/Python/src/multiport/MultiportFromBank.lf b/test/Python/src/multiport/MultiportFromBank.lf index 05dc165fa1..92d9363df5 100644 --- a/test/Python/src/multiport/MultiportFromBank.lf +++ b/test/Python/src/multiport/MultiportFromBank.lf @@ -5,7 +5,7 @@ target Python { fast: true } -reactor Source(check_override(0), bank_index(0)) { +reactor Source(check_override = 0, bank_index = 0) { output out reaction(startup) -> out {= @@ -15,7 +15,7 @@ reactor Source(check_override(0), bank_index(0)) { reactor Destination { input[3] _in - state received(0) + state received = 0 reaction(_in) {= for (idx, port) in enumerate(_in): diff --git a/test/Python/src/multiport/MultiportFromBankHierarchy.lf b/test/Python/src/multiport/MultiportFromBankHierarchy.lf index ac62f5829f..27ecb3c80b 100644 --- a/test/Python/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/Python/src/multiport/MultiportFromBankHierarchy.lf @@ -7,7 +7,7 @@ target Python { import Destination from "MultiportFromBank.lf" -reactor Source(bank_index(0)) { +reactor Source(bank_index = 0) { output out reaction(startup) -> out {= out.set(self.bank_index) =} diff --git a/test/Python/src/multiport/MultiportFromHierarchy.lf b/test/Python/src/multiport/MultiportFromHierarchy.lf index dc7a9a2f68..4116587f01 100644 --- a/test/Python/src/multiport/MultiportFromHierarchy.lf +++ b/test/Python/src/multiport/MultiportFromHierarchy.lf @@ -8,7 +8,7 @@ target Python { reactor Source { timer t(0, 200 msec) output[4] out - state s(0) + state s = 0 reaction(t) -> out {= for port in out: @@ -18,7 +18,7 @@ reactor Source { } reactor Destination { - state s(6) + state s = 6 input[4] _in reaction(_in) {= diff --git a/test/Python/src/multiport/MultiportFromReaction.lf b/test/Python/src/multiport/MultiportFromReaction.lf index f005711683..05b280b126 100644 --- a/test/Python/src/multiport/MultiportFromReaction.lf +++ b/test/Python/src/multiport/MultiportFromReaction.lf @@ -4,8 +4,8 @@ target Python { fast: true } -reactor Destination(width(1)) { - state s(6) +reactor Destination(width = 1) { + state s = 6 input[width] _in reaction(_in) {= @@ -31,7 +31,7 @@ reactor Destination(width(1)) { main reactor MultiportFromReaction { timer t(0, 200 msec) - state s(0) + state s = 0 b = new Destination(width = 4) reaction(t) -> b._in {= diff --git a/test/Python/src/multiport/MultiportIn.lf b/test/Python/src/multiport/MultiportIn.lf index 146dfa6727..35bdee7341 100644 --- a/test/Python/src/multiport/MultiportIn.lf +++ b/test/Python/src/multiport/MultiportIn.lf @@ -8,7 +8,7 @@ target Python { reactor Source { timer t(0, 200 msec) output out - state s(0) + state s = 0 reaction(t) -> out {= out.set(self.s) @@ -24,7 +24,7 @@ reactor Computation { } reactor Destination { - state s(0) + state s = 0 input[4] _in reaction(_in) {= diff --git a/test/Python/src/multiport/MultiportInParameterized.lf b/test/Python/src/multiport/MultiportInParameterized.lf index c4906d7a9c..28b15808e3 100644 --- a/test/Python/src/multiport/MultiportInParameterized.lf +++ b/test/Python/src/multiport/MultiportInParameterized.lf @@ -8,7 +8,7 @@ target Python { reactor Source { timer t(0, 200 msec) output out - state s(0) + state s = 0 reaction(t) -> out {= out.set(self.s) @@ -23,8 +23,8 @@ reactor Computation { reaction(_in) -> out {= out.set(_in.value) =} } -reactor Destination(width(1)) { - state s(0) +reactor Destination(width = 1) { + state s = 0 input[width] _in reaction(_in) {= diff --git a/test/Python/src/multiport/MultiportMutableInput.lf b/test/Python/src/multiport/MultiportMutableInput.lf index d17e1cd8bf..f931900ef7 100644 --- a/test/Python/src/multiport/MultiportMutableInput.lf +++ b/test/Python/src/multiport/MultiportMutableInput.lf @@ -12,7 +12,7 @@ reactor Source { =} } -reactor Print(scale(1)) { # The scale parameter is just for testing. +reactor Print(scale = 1) { # The scale parameter is just for testing. input[2] _in reaction(_in) {= @@ -26,7 +26,7 @@ reactor Print(scale(1)) { # The scale parameter is just for testing. =} } -reactor Scale(scale(2)) { +reactor Scale(scale = 2) { mutable input[2] _in output[2] out diff --git a/test/Python/src/multiport/MultiportMutableInputArray.lf b/test/Python/src/multiport/MultiportMutableInputArray.lf index 76fa5203a6..9efa3eeebf 100644 --- a/test/Python/src/multiport/MultiportMutableInputArray.lf +++ b/test/Python/src/multiport/MultiportMutableInputArray.lf @@ -13,7 +13,7 @@ reactor Source { =} } -reactor Print(scale(1)) { # The scale parameter is just for testing. +reactor Print(scale = 1) { # The scale parameter is just for testing. input[2] _in reaction(_in) {= @@ -25,7 +25,7 @@ reactor Print(scale(1)) { # The scale parameter is just for testing. =} } -reactor Scale(scale(2)) { +reactor Scale(scale = 2) { mutable input[2] _in output[2] out diff --git a/test/Python/src/multiport/MultiportOut.lf b/test/Python/src/multiport/MultiportOut.lf index 0a48f355e6..3d29c5188a 100644 --- a/test/Python/src/multiport/MultiportOut.lf +++ b/test/Python/src/multiport/MultiportOut.lf @@ -7,7 +7,7 @@ target Python { reactor Source { timer t(0, 200 msec) output[4] out - state s(0) + state s = 0 reaction(t) -> out {= for port in out: @@ -25,7 +25,7 @@ reactor Computation { } reactor Destination { - state s(0) + state s = 0 input[4] _in reaction(_in) {= diff --git a/test/Python/src/multiport/MultiportToBank.lf b/test/Python/src/multiport/MultiportToBank.lf index 61b1cabc8b..12d68d6662 100644 --- a/test/Python/src/multiport/MultiportToBank.lf +++ b/test/Python/src/multiport/MultiportToBank.lf @@ -13,9 +13,9 @@ reactor Source { =} } -reactor Destination(bank_index(0)) { +reactor Destination(bank_index = 0) { input _in - state received(0) + state received = 0 reaction(_in) {= print("Destination " + str(self.bank_index) + " received " + str(_in.value)) diff --git a/test/Python/src/multiport/MultiportToBankAfter.lf b/test/Python/src/multiport/MultiportToBankAfter.lf index aeb8a9d0d7..85fc91e513 100644 --- a/test/Python/src/multiport/MultiportToBankAfter.lf +++ b/test/Python/src/multiport/MultiportToBankAfter.lf @@ -7,9 +7,9 @@ target Python { import Source from "MultiportToBank.lf" -reactor Destination(bank_index(0)) { +reactor Destination(bank_index = 0) { input _in - state received(false) + state received = False reaction(_in) {= print("Destination {:d} received {:d}.".format(self.bank_index, _in.value)) diff --git a/test/Python/src/multiport/MultiportToBankHierarchy.lf b/test/Python/src/multiport/MultiportToBankHierarchy.lf index b36ae9b40b..f70fa8ad92 100644 --- a/test/Python/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Python/src/multiport/MultiportToBankHierarchy.lf @@ -7,9 +7,9 @@ target Python { import Source from "MultiportToBank.lf" -reactor Destination(bank_index(0)) { +reactor Destination(bank_index = 0) { input _in - state received(false) + state received = False reaction(_in) {= print("Destination {:d} received {:d}.\n".format(self.bank_index, _in.value)) diff --git a/test/Python/src/multiport/MultiportToHierarchy.lf b/test/Python/src/multiport/MultiportToHierarchy.lf index 6dbf76775f..2a9e25a5e6 100644 --- a/test/Python/src/multiport/MultiportToHierarchy.lf +++ b/test/Python/src/multiport/MultiportToHierarchy.lf @@ -9,7 +9,7 @@ target Python { reactor Source { timer t(0, 200 msec) output[4] out - state s(0) + state s = 0 reaction(t) -> out {= for port in out: @@ -18,8 +18,8 @@ reactor Source { =} } -reactor Destination(width(4)) { - state s(6) +reactor Destination(width = 4) { + state s = 6 input[width] _in reaction(_in) {= @@ -42,7 +42,7 @@ reactor Destination(width(4)) { =} } -reactor Container(width(4)) { +reactor Container(width = 4) { input[width] _in dst = new Destination() _in -> dst._in diff --git a/test/Python/src/multiport/MultiportToMultiport.lf b/test/Python/src/multiport/MultiportToMultiport.lf index 6fd4bbb231..b16e832e7e 100644 --- a/test/Python/src/multiport/MultiportToMultiport.lf +++ b/test/Python/src/multiport/MultiportToMultiport.lf @@ -6,10 +6,10 @@ target Python { import Destination from "MultiportToHierarchy.lf" -reactor Source(width(1)) { +reactor Source(width = 1) { timer t(0, 200 msec) output[width] out - state s(0) + state s = 0 reaction(t) -> out {= for i in range(len(out)): diff --git a/test/Python/src/multiport/MultiportToMultiport2.lf b/test/Python/src/multiport/MultiportToMultiport2.lf index 5b06d8d7d8..cb6da65f35 100644 --- a/test/Python/src/multiport/MultiportToMultiport2.lf +++ b/test/Python/src/multiport/MultiportToMultiport2.lf @@ -1,7 +1,7 @@ # Test multiport to multiport connections. See also MultiportToMultiport. target Python -reactor Source(width(2)) { +reactor Source(width = 2) { output[width] out reaction(startup) -> out {= @@ -10,7 +10,7 @@ reactor Source(width(2)) { =} } -reactor Destination(width(2)) { +reactor Destination(width = 2) { input[width] _in reaction(_in) {= diff --git a/test/Python/src/multiport/MultiportToMultiport2After.lf b/test/Python/src/multiport/MultiportToMultiport2After.lf index d8d85805ce..0e7ee9aef2 100644 --- a/test/Python/src/multiport/MultiportToMultiport2After.lf +++ b/test/Python/src/multiport/MultiportToMultiport2After.lf @@ -3,7 +3,7 @@ target Python import Source from "MultiportToMultiport2.lf" -reactor Destination(width(2)) { +reactor Destination(width = 2) { input[width] _in reaction(_in) {= diff --git a/test/Python/src/multiport/MultiportToMultiportArray.lf b/test/Python/src/multiport/MultiportToMultiportArray.lf index e22f3541b0..5eb043570d 100644 --- a/test/Python/src/multiport/MultiportToMultiportArray.lf +++ b/test/Python/src/multiport/MultiportToMultiportArray.lf @@ -8,7 +8,7 @@ target Python { reactor Source { timer t(0, 200 msec) output[2] out - state s(0) + state s = 0 reaction(t) -> out {= for port in out: @@ -18,7 +18,7 @@ reactor Source { } reactor Destination { - state s(15) + state s = 15 input[2] _in reaction(_in) {= diff --git a/test/Python/src/multiport/MultiportToMultiportParameter.lf b/test/Python/src/multiport/MultiportToMultiportParameter.lf index 933abfd846..b47905bb6e 100644 --- a/test/Python/src/multiport/MultiportToMultiportParameter.lf +++ b/test/Python/src/multiport/MultiportToMultiportParameter.lf @@ -7,7 +7,7 @@ target Python { import Source from "MultiportToMultiport.lf" import Destination from "MultiportToHierarchy.lf" -main reactor MultiportToMultiportParameter(width(4)) { +main reactor MultiportToMultiportParameter(width = 4) { a = new Source(width = width) b = new Destination(width = width) a.out -> b._in diff --git a/test/Python/src/multiport/MultiportToPort.lf b/test/Python/src/multiport/MultiportToPort.lf index 52bb7b7c67..ebfbf81991 100644 --- a/test/Python/src/multiport/MultiportToPort.lf +++ b/test/Python/src/multiport/MultiportToPort.lf @@ -15,9 +15,9 @@ reactor Source { =} } -reactor Destination(expected(0)) { +reactor Destination(expected = 0) { input _in - state received(false) + state received = False reaction(_in) {= print("Received: ", _in.value) diff --git a/test/Python/src/multiport/MultiportToReaction.lf b/test/Python/src/multiport/MultiportToReaction.lf index 6d03ba28ee..b45ee9ac9e 100644 --- a/test/Python/src/multiport/MultiportToReaction.lf +++ b/test/Python/src/multiport/MultiportToReaction.lf @@ -4,9 +4,9 @@ target Python { fast: true } -reactor Source(width(1)) { +reactor Source(width = 1) { timer t(0, 200 msec) - state s(0) + state s = 0 output[width] out reaction(t) -> out {= @@ -17,7 +17,7 @@ reactor Source(width(1)) { } main reactor { - state s(6) + state s = 6 b = new Source(width = 4) reaction(b.out) {= diff --git a/test/Python/src/multiport/NestedBanks.lf b/test/Python/src/multiport/NestedBanks.lf index 8e49b76aef..1e863043e6 100644 --- a/test/Python/src/multiport/NestedBanks.lf +++ b/test/Python/src/multiport/NestedBanks.lf @@ -13,13 +13,13 @@ main reactor { (a.x)+ -> c.z, d.u, e.t } -reactor A(bank_index(0)) { +reactor A(bank_index = 0) { output[4] x b = new[2] B(a_bank_index = bank_index) b.y -> x } -reactor B(a_bank_index(0), bank_index(0)) { +reactor B(a_bank_index = 0, bank_index = 0) { output[2] y reaction(startup) -> y {= @@ -29,7 +29,7 @@ reactor B(a_bank_index(0), bank_index(0)) { =} } -reactor C(bank_index(0)) { +reactor C(bank_index = 0) { input[2] z f = new F(c_bank_index = bank_index) g = new G(c_bank_index = bank_index) @@ -57,7 +57,7 @@ reactor E { =} } -reactor F(c_bank_index(0)) { +reactor F(c_bank_index = 0) { input w reaction(w) {= @@ -68,7 +68,7 @@ reactor F(c_bank_index(0)) { =} } -reactor G(c_bank_index(0)) { +reactor G(c_bank_index = 0) { input s reaction(s) {= diff --git a/test/Python/src/multiport/NestedInterleavedBanks.lf b/test/Python/src/multiport/NestedInterleavedBanks.lf index 5d615a3397..9be37badcd 100644 --- a/test/Python/src/multiport/NestedInterleavedBanks.lf +++ b/test/Python/src/multiport/NestedInterleavedBanks.lf @@ -4,7 +4,7 @@ */ target Python -reactor A(bank_index(0), outer_bank_index(0)) { +reactor A(bank_index = 0, outer_bank_index = 0) { output[2] p reaction(startup) -> p {= @@ -14,7 +14,7 @@ reactor A(bank_index(0), outer_bank_index(0)) { =} } -reactor B(bank_index(0)) { +reactor B(bank_index = 0) { output[4] q a = new[2] A(outer_bank_index = bank_index) interleaved (a.p) -> q diff --git a/test/Python/src/multiport/ReactionsToNested.lf b/test/Python/src/multiport/ReactionsToNested.lf index 9870cb1b68..2c207dffb0 100644 --- a/test/Python/src/multiport/ReactionsToNested.lf +++ b/test/Python/src/multiport/ReactionsToNested.lf @@ -4,9 +4,9 @@ target Python { timeout: 1 sec } -reactor T(expected(0)) { +reactor T(expected = 0) { input z - state received(false) + state received = False reaction(z) {= print(f"T received {z.value}.") diff --git a/test/Python/src/target/AfterNoTypes.lf b/test/Python/src/target/AfterNoTypes.lf index 3ff3983da5..44aaa89c73 100644 --- a/test/Python/src/target/AfterNoTypes.lf +++ b/test/Python/src/target/AfterNoTypes.lf @@ -13,8 +13,8 @@ reactor Foo { } reactor Print { - state expected_time(10 msec) - state received(0) + state expected_time = 10 msec + state received = 0 input x reaction(x) {= diff --git a/test/Rust/src/ActionDelay.lf b/test/Rust/src/ActionDelay.lf index 8612eabbb2..75c7ab909f 100644 --- a/test/Rust/src/ActionDelay.lf +++ b/test/Rust/src/ActionDelay.lf @@ -4,7 +4,7 @@ target Rust main reactor ActionDelay { logical action act0 logical action act1(100 msec) - state count: u32(0) + state count: u32 = 0 reaction(startup) -> act0, act1 {= ctx.schedule(act0, after!(100 ms)); diff --git a/test/Rust/src/ActionImplicitDelay.lf b/test/Rust/src/ActionImplicitDelay.lf index 1278472528..9a3a900d93 100644 --- a/test/Rust/src/ActionImplicitDelay.lf +++ b/test/Rust/src/ActionImplicitDelay.lf @@ -3,7 +3,7 @@ target Rust main reactor ActionImplicitDelay { logical action act(40 msec) - state count: u64(1) + state count: u64 = 1 reaction(startup) -> act {= ctx.schedule(act, Asap); =} diff --git a/test/Rust/src/ActionIsPresent.lf b/test/Rust/src/ActionIsPresent.lf index efe6158e43..3a1e556c5a 100644 --- a/test/Rust/src/ActionIsPresent.lf +++ b/test/Rust/src/ActionIsPresent.lf @@ -3,8 +3,8 @@ target Rust main reactor ActionIsPresent { logical action a - state success: bool(false) - state tried: bool(false) + state success: bool = false + state tried: bool = false reaction(startup, a) -> a {= if !ctx.is_present(a) { diff --git a/test/Rust/src/ActionScheduleMicrostep.lf b/test/Rust/src/ActionScheduleMicrostep.lf index 5ded693d2c..53bf8781b9 100644 --- a/test/Rust/src/ActionScheduleMicrostep.lf +++ b/test/Rust/src/ActionScheduleMicrostep.lf @@ -3,7 +3,7 @@ target Rust main reactor ActionScheduleMicrostep { logical action act - state count: u32(1) + state count: u32 = 1 reaction(startup) -> act {= assert_tag_is!(ctx, T0); diff --git a/test/Rust/src/ActionValues.lf b/test/Rust/src/ActionValues.lf index 635516c3d0..007da1fb5a 100644 --- a/test/Rust/src/ActionValues.lf +++ b/test/Rust/src/ActionValues.lf @@ -2,8 +2,8 @@ target Rust main reactor ActionValues { - state r1done: bool(false) - state r2done: bool(false) + state r1done: bool = false + state r2done: bool = false logical action act(100 msec): i32 reaction(startup) -> act {= diff --git a/test/Rust/src/ActionValuesCleanup.lf b/test/Rust/src/ActionValuesCleanup.lf index 615bd68a90..f4bab7a2b5 100644 --- a/test/Rust/src/ActionValuesCleanup.lf +++ b/test/Rust/src/ActionValuesCleanup.lf @@ -20,7 +20,7 @@ main reactor ActionValuesCleanup { =} logical action act: FooDrop - state count: u32(0) + state count: u32 = 0 reaction(startup) -> act {= ctx.schedule_with_v(act, Some(FooDrop { }), Asap) diff --git a/test/Rust/src/CtorParamDefault.lf b/test/Rust/src/CtorParamDefault.lf index 2a4f4b8074..a7d2d868bc 100644 --- a/test/Rust/src/CtorParamDefault.lf +++ b/test/Rust/src/CtorParamDefault.lf @@ -1,7 +1,7 @@ target Rust -reactor Print(value: i32(42)) { - state v: i32(value) +reactor Print(value: i32 = 42) { + state v: i32 = value reaction(startup) {= assert_eq!(42, self.v); diff --git a/test/Rust/src/CtorParamMixed.lf b/test/Rust/src/CtorParamMixed.lf index cb8536fe0a..5de7a3dc4c 100644 --- a/test/Rust/src/CtorParamMixed.lf +++ b/test/Rust/src/CtorParamMixed.lf @@ -1,13 +1,13 @@ target Rust reactor Print( - value: i32(42), - name: String({= "xxx".into() =}), - other: bool(false) + value: i32 = 42, + name: String = {= "xxx".into() =}, + other: bool = false ) { - state value(value) - state name(name) - state other(other) + state value = value + state name = name + state other = other reaction(startup) {= assert_eq!(42, self.value); diff --git a/test/Rust/src/CtorParamSimple.lf b/test/Rust/src/CtorParamSimple.lf index 8594adde3d..bbf38c04a0 100644 --- a/test/Rust/src/CtorParamSimple.lf +++ b/test/Rust/src/CtorParamSimple.lf @@ -1,7 +1,7 @@ target Rust -reactor Print(value: i32(42)) { - state v: i32(value) +reactor Print(value: i32 = 42) { + state v: i32 = value reaction(startup) {= assert_eq!(self.v, 23); diff --git a/test/Rust/src/DependencyOnChildPort.lf b/test/Rust/src/DependencyOnChildPort.lf index e5c9336c11..ed8b6b2120 100644 --- a/test/Rust/src/DependencyOnChildPort.lf +++ b/test/Rust/src/DependencyOnChildPort.lf @@ -9,7 +9,7 @@ reactor Box { } main reactor { - state done: bool(false) + state done: bool = false box0 = new Box() box1 = new Box() diff --git a/test/Rust/src/DependencyUseOnLogicalAction.lf b/test/Rust/src/DependencyUseOnLogicalAction.lf index bf51944c8b..6278ec76f7 100644 --- a/test/Rust/src/DependencyUseOnLogicalAction.lf +++ b/test/Rust/src/DependencyUseOnLogicalAction.lf @@ -10,7 +10,7 @@ main reactor { timer t(0, 2 msec) - state tick: u32(0) + state tick: u32 = 0 reaction(startup) -> clock, a {= ctx.schedule(a, after!(3 ms)); // out of order on purpose diff --git a/test/Rust/src/FloatLiteral.lf b/test/Rust/src/FloatLiteral.lf index 645581c844..b1dd37ca5e 100644 --- a/test/Rust/src/FloatLiteral.lf +++ b/test/Rust/src/FloatLiteral.lf @@ -2,10 +2,10 @@ target Rust // This test verifies that floating-point literals are handled correctly. main reactor { - state N: f64(6.0221409e+23) - state charge: f64(-1.6021766E-19) - state minus_epsilon: f64(-.01e0) - state expected: f64(.964853323188E5) + state N: f64 = 6.0221409e+23 + state charge: f64 = -1.6021766E-19 + state minus_epsilon: f64 = -.01e0 + state expected: f64 = .964853323188E5 reaction(startup) {= let F = - self.N * self.charge; diff --git a/test/Rust/src/MainReactorParam.lf b/test/Rust/src/MainReactorParam.lf index 36a78d7699..0c9f189548 100644 --- a/test/Rust/src/MainReactorParam.lf +++ b/test/Rust/src/MainReactorParam.lf @@ -1,8 +1,8 @@ target Rust -main reactor(one: u64(1152921504606846976), two: u64({= 1 << 60 =})) { - state one(one) - state two(two) +main reactor(one: u64 = 1152921504606846976, two: u64 = {= 1 << 60 =}) { + state one = one + state two = two reaction(startup) {= assert_eq!(self.one, self.two); =} } diff --git a/test/Rust/src/MovingAverage.lf b/test/Rust/src/MovingAverage.lf index 228c69bd17..3dcbb69c98 100644 --- a/test/Rust/src/MovingAverage.lf +++ b/test/Rust/src/MovingAverage.lf @@ -7,7 +7,7 @@ target Rust { reactor Source { output out: f64 - state count: u32(0) + state count: u32 = 0 timer clock(0, 10 msec) reaction(clock) -> out {= @@ -17,9 +17,8 @@ reactor Source { } reactor MovingAverageImpl { - // fixme inaccessible ({=[0.0 ; 4]=}); - state delay_line: f64[4](0.0, 0.0, 0.0, 0.0) - state index: usize(0) + state delay_line: {= [f64 ; 4] =} = {= [ 0.0 ; 4 ] =} + state index: usize = 0 input in_: f64 output out: f64 @@ -39,7 +38,7 @@ reactor MovingAverageImpl { reactor Print { input in_: f64 - state count: usize(0) + state count: usize = 0 preamble {= const EXPECTED: [ f64 ; 6 ] = [0.0, 0.25, 0.75, 1.5, 2.5, 3.5]; diff --git a/test/Rust/src/NativeListsAndTimes.lf b/test/Rust/src/NativeListsAndTimes.lf index 3e378c2e43..79fd56e004 100644 --- a/test/Rust/src/NativeListsAndTimes.lf +++ b/test/Rust/src/NativeListsAndTimes.lf @@ -2,18 +2,18 @@ target Rust // This test passes if it is successfully compiled into valid target code. reactor Foo( - x: i32(0), - y: time(0), // Units are missing but not required - z(1 msec), // Type is missing but not required + x: i32 = 0, + y: time = 0, // Units are missing but not required + z = 1 msec, // Type is missing but not required p: i32[](1, 2, 3, 4), // List of integers - p2: i32[]({= vec![1] =}), // List of integers with single element + p2: i32[] = {= vec![1] =}, // List of integers with single element // todo // p2: i32[](1), // List of integers with single element p3: // i32[](), // Empty list of integers List of time values q: Vec(1 msec, 2 msec, 3 msec), g: time[](1 msec, 2 msec) // List of time values ) { - state s: time(y) // Reference to explicitly typed time parameter - state t: time(z) // Reference to implicitly typed time parameter + state s: time = y // Reference to explicitly typed time parameter + state t: time = z // Reference to implicitly typed time parameter state v: bool // Uninitialized boolean state variable state w: time // Uninitialized time state variable timer tick(0) // Units missing but not required @@ -29,7 +29,7 @@ reactor Foo( */ // state baz(p); // Implicit type i32[] fixme this interplays badly with // syntax for array init Implicit type time - state period(z) + state period = z state times: Vec>(q, g) // a list of lists /** diff --git a/test/Rust/src/PortConnectionInSelfInChild.lf b/test/Rust/src/PortConnectionInSelfInChild.lf index c72b4edae0..7fd66783f1 100644 --- a/test/Rust/src/PortConnectionInSelfInChild.lf +++ b/test/Rust/src/PortConnectionInSelfInChild.lf @@ -3,7 +3,7 @@ target Rust reactor Child { input inp: i32 - state done: bool(false) + state done: bool = false reaction(inp) {= assert_eq!(ctx.get(inp), Some(76600)); diff --git a/test/Rust/src/PortConnectionInSelfOutSelf.lf b/test/Rust/src/PortConnectionInSelfOutSelf.lf index 6d012b3d62..2e33b0e498 100644 --- a/test/Rust/src/PortConnectionInSelfOutSelf.lf +++ b/test/Rust/src/PortConnectionInSelfOutSelf.lf @@ -18,7 +18,7 @@ reactor TestCase { reactor Sink { input inp: i32 - state done: bool(false) + state done: bool = false reaction(inp) {= assert_eq!(ctx.get(inp), Some(76600)); diff --git a/test/Rust/src/PortConnectionOutChildOutSelf.lf b/test/Rust/src/PortConnectionOutChildOutSelf.lf index 54adbb56eb..4d58153d97 100644 --- a/test/Rust/src/PortConnectionOutChildOutSelf.lf +++ b/test/Rust/src/PortConnectionOutChildOutSelf.lf @@ -19,7 +19,7 @@ reactor Parent { reactor Sink { input inp: i32 - state done: bool(false) + state done: bool = false reaction(inp) {= assert_eq!(ctx.get(inp), Some(76600)); @@ -33,7 +33,7 @@ reactor Sink { main reactor { parent = new Parent() - state done: bool(false) + state done: bool = false reaction(parent.out) {= assert_eq!(ctx.get(parent__out), Some(76600)); diff --git a/test/Rust/src/PortRefCleanup.lf b/test/Rust/src/PortRefCleanup.lf index 65a5b415cf..30573ceee9 100644 --- a/test/Rust/src/PortRefCleanup.lf +++ b/test/Rust/src/PortRefCleanup.lf @@ -14,8 +14,8 @@ main reactor { timer t1(0) timer t2(15 msec) - state reaction_num: u32(0) - state done: bool(false) + state reaction_num: u32 = 0 + state done: bool = false reaction(t1) -> boxr.inp {= ctx.set(boxr__inp, 150); diff --git a/test/Rust/src/PortValueCleanup.lf b/test/Rust/src/PortValueCleanup.lf index be837c2908..9a11372cfb 100644 --- a/test/Rust/src/PortValueCleanup.lf +++ b/test/Rust/src/PortValueCleanup.lf @@ -11,8 +11,8 @@ reactor Sink { timer t2(15 msec) input in: u32 - state reaction_num: u32(0) - state done: bool(false) + state reaction_num: u32 = 0 + state done: bool = false reaction(in, t2) {= if self.reaction_num == 0 { diff --git a/test/Rust/src/ReservedKeywords.lf b/test/Rust/src/ReservedKeywords.lf index f1facfe8ea..5d30ba63a4 100644 --- a/test/Rust/src/ReservedKeywords.lf +++ b/test/Rust/src/ReservedKeywords.lf @@ -8,14 +8,14 @@ reactor box { in -> struct - state foo: bool(true) // not escaped + state foo: bool = true // not escaped reaction(in) {= ctx.get(r#in); =} } -main reactor ReservedKeywords(struct: u32(0)) { +main reactor ReservedKeywords(struct: u32 = 0) { box = new box() timer t1(0) diff --git a/test/Rust/src/StateInitializerVisibility.lf b/test/Rust/src/StateInitializerVisibility.lf index cef728ccfa..d192f0ca98 100644 --- a/test/Rust/src/StateInitializerVisibility.lf +++ b/test/Rust/src/StateInitializerVisibility.lf @@ -3,8 +3,8 @@ target Rust main reactor { - state foo: u32(123) - state x: u32({= *&foo =}) + state foo: u32 = 123 + state x: u32 = {= *&foo =} reaction(startup) {= assert_eq!(self.x, self.foo); diff --git a/test/Rust/src/Stop.lf b/test/Rust/src/Stop.lf index d2f380f634..c43f8c30ff 100644 --- a/test/Rust/src/Stop.lf +++ b/test/Rust/src/Stop.lf @@ -13,13 +13,13 @@ target Rust { * @param break_interval: Determines how long the reactor should take a break * after sending take_a_break_after messages. */ -reactor Sender(take_a_break_after: u32(10), break_interval: time(400 msec)) { +reactor Sender(take_a_break_after: u32 = 10, break_interval: time = 400 msec) { output out: u32 logical action act - state sent_messages: u32(0) + state sent_messages: u32 = 0 - state take_a_break_after(take_a_break_after) - state break_interval(break_interval) + state take_a_break_after = take_a_break_after + state break_interval = break_interval reaction(startup, act) -> act, out {= // Send a message on out @@ -40,7 +40,7 @@ reactor Sender(take_a_break_after: u32(10), break_interval: time(400 msec)) { reactor Consumer { input in_: u32 - state reaction_invoked_correctly: bool(false) + state reaction_invoked_correctly: bool = false reaction(in_) {= let current_tag = ctx.get_tag(); diff --git a/test/Rust/src/StopIdempotence.lf b/test/Rust/src/StopIdempotence.lf index ce9d17514f..1f79347758 100644 --- a/test/Rust/src/StopIdempotence.lf +++ b/test/Rust/src/StopIdempotence.lf @@ -4,7 +4,7 @@ target Rust { } main reactor StopIdempotence { - state count: u32(0) + state count: u32 = 0 reaction(startup) {= ctx.request_stop(Asap); // requested for (T0, 1) diff --git a/test/Rust/src/StopTimeoutExact.lf b/test/Rust/src/StopTimeoutExact.lf index 37e9616fb7..2b9eb85cda 100644 --- a/test/Rust/src/StopTimeoutExact.lf +++ b/test/Rust/src/StopTimeoutExact.lf @@ -9,7 +9,7 @@ target Rust { main reactor StopTimeoutExact { timer t(0, 10 msec) // the fifth triggering will coincide with the timeout - state reacted_on_shutdown: bool(false) + state reacted_on_shutdown: bool = false reaction(t) {= if ctx.get_tag() == tag!(T0 + 50 ms) { diff --git a/test/Rust/src/StructAsState.lf b/test/Rust/src/StructAsState.lf index 955affcc8b..9b35e7a3fb 100644 --- a/test/Rust/src/StructAsState.lf +++ b/test/Rust/src/StructAsState.lf @@ -15,7 +15,7 @@ main reactor StructAsState { * - state s: Hello(name: "Earth".into(), value: 42); * - state s: Hello { name: "Earth".into(), value: 42 }; */ - state s: Hello({= Hello { name: "Earth".into(), value: 42 } =}) + state s: Hello = {= Hello { name: "Earth".into(), value: 42 } =} reaction(startup) {= println!("State s.name=\"{}\", s.value={}.", self.s.name, self.s.value); diff --git a/test/Rust/src/StructAsType.lf b/test/Rust/src/StructAsType.lf index 76cee15f8e..0c8ed51456 100644 --- a/test/Rust/src/StructAsType.lf +++ b/test/Rust/src/StructAsType.lf @@ -18,9 +18,9 @@ reactor Source { =} } -reactor Print(expected: i32(42)) { // expected parameter is for testing. +reactor Print(expected: i32 = 42) { // expected parameter is for testing. input inp: {= super::source::Hello =} - state expected: i32(expected) + state expected: i32 = expected reaction(inp) {= ctx.use_ref_opt(inp, |hello| { diff --git a/test/Rust/src/TimeState.lf b/test/Rust/src/TimeState.lf index bbd80f730f..efffb00c2f 100644 --- a/test/Rust/src/TimeState.lf +++ b/test/Rust/src/TimeState.lf @@ -1,7 +1,7 @@ target Rust reactor Foo { - state baz: time(500 msec) + state baz: time = 500 msec reaction(startup) {= assert_eq!(500, self.baz.as_millis()); =} } diff --git a/test/Rust/src/TimerDefaults.lf b/test/Rust/src/TimerDefaults.lf index 3de189b62b..bbc920bf4a 100644 --- a/test/Rust/src/TimerDefaults.lf +++ b/test/Rust/src/TimerDefaults.lf @@ -1,7 +1,7 @@ target Rust main reactor TimerDefaults { - state i: i32(0) + state i: i32 = 0 timer t reaction(t) {= diff --git a/test/Rust/src/TimerIsPresent.lf b/test/Rust/src/TimerIsPresent.lf index 84327c06a6..1e87c11f51 100644 --- a/test/Rust/src/TimerIsPresent.lf +++ b/test/Rust/src/TimerIsPresent.lf @@ -8,8 +8,8 @@ main reactor { timer b(1 msec, 5 msec) timer c(1 msec) - state success: bool(false) - state tick: u32(0) + state success: bool = false + state tick: u32 = 0 reaction(startup, a, b, c) {= match self.tick { diff --git a/test/Rust/src/TimerPeriodic.lf b/test/Rust/src/TimerPeriodic.lf index fc62900e7c..c6dce10a73 100644 --- a/test/Rust/src/TimerPeriodic.lf +++ b/test/Rust/src/TimerPeriodic.lf @@ -3,7 +3,7 @@ target Rust { } main reactor TimerPeriodic { - state i: i32(0) + state i: i32 = 0 timer t2(0, 3 msec) reaction(t2) {= diff --git a/test/Rust/src/Timers.lf b/test/Rust/src/Timers.lf index 1043aad497..1ef5fc0ae5 100644 --- a/test/Rust/src/Timers.lf +++ b/test/Rust/src/Timers.lf @@ -6,7 +6,7 @@ target Rust { main reactor Timers { timer t(0, 1 sec) timer t2(0, 2 sec) - state counter: i32(0) + state counter: i32 = 0 reaction(t2) {= self.counter += 2; =} diff --git a/test/Rust/src/TypeVarLengthList.lf b/test/Rust/src/TypeVarLengthList.lf index 9dbf082f1f..37ff36df56 100644 --- a/test/Rust/src/TypeVarLengthList.lf +++ b/test/Rust/src/TypeVarLengthList.lf @@ -3,7 +3,7 @@ target Rust // this thing must compile needs to be modified when // https://github.com/lf-lang/lingua-franca/discussions/492 is implemented main reactor TypeVarLengthList { - state l0: i32[]({= Vec::new() =}) // generates l0: Vec::new() + state l0: i32[] = {= Vec::new() =} // generates l0: Vec::new() // generates l1: vec![1, 2] /** * - state l2: i32[](1); // generates l2: 1 // doesn't compile... diff --git a/test/Rust/src/concurrent/AsyncCallback.lf b/test/Rust/src/concurrent/AsyncCallback.lf index 053d8ae33d..dccbcf37c0 100644 --- a/test/Rust/src/concurrent/AsyncCallback.lf +++ b/test/Rust/src/concurrent/AsyncCallback.lf @@ -4,17 +4,17 @@ target Rust { cargo-features: ["cli"] } -main reactor AsyncCallback(period: time(10 msec)) { +main reactor AsyncCallback(period: time = 10 msec) { preamble {= use std::thread; =} timer t(0, period) state thread: Option> - state expected_time: time(period) - state period: time(period) - state toggle: bool(false) + state expected_time: time = period + state period: time = period + state toggle: bool = false physical action act - state i: u32(0) + state i: u32 = 0 reaction(t) -> act {= let act = act.clone(); diff --git a/test/Rust/src/generics/CtorParamGeneric.lf b/test/Rust/src/generics/CtorParamGeneric.lf index 93646e1746..1c8b1cab24 100644 --- a/test/Rust/src/generics/CtorParamGeneric.lf +++ b/test/Rust/src/generics/CtorParamGeneric.lf @@ -2,10 +2,10 @@ target Rust reactor Generic<{= T: Default + Eq + Sync + std::fmt::Debug =}>( - value: T({= Default::default() =}) + value: T = {= Default::default() =} ) { input in: T - state v: T(value) + state v: T = value reaction(in) {= ctx.use_ref_opt(r#in, |i| { diff --git a/test/Rust/src/generics/CtorParamGenericInst.lf b/test/Rust/src/generics/CtorParamGenericInst.lf index 63c38b2e16..86f696185c 100644 --- a/test/Rust/src/generics/CtorParamGenericInst.lf +++ b/test/Rust/src/generics/CtorParamGenericInst.lf @@ -5,10 +5,10 @@ target Rust reactor Generic2< {= T: Default + Eq + Sync + std::fmt::Debug + Send + 'static =} >( - value: T({= Default::default() =}) + value: T = {= Default::default() =} ) { input in: T - state v: T(value) + state v: T = value reaction(in) {= ctx.use_ref_opt(r#in, |i| { @@ -21,7 +21,7 @@ reactor Generic2< reactor Generic< {= T: Default + Eq + Sync + std::fmt::Debug + Copy + Send + 'static =} >( - value: T({= Default::default() =}) + value: T = {= Default::default() =} ) { input in: T diff --git a/test/Rust/src/generics/GenericReactor.lf b/test/Rust/src/generics/GenericReactor.lf index 0bf0675c02..3190524a5b 100644 --- a/test/Rust/src/generics/GenericReactor.lf +++ b/test/Rust/src/generics/GenericReactor.lf @@ -9,7 +9,7 @@ reactor Box<{= T: Sync =}> { } main reactor { - state done: bool(false) + state done: bool = false box0 = new Box() box1 = new Box() diff --git a/test/Rust/src/multiport/ConnectionToSelfBank.lf b/test/Rust/src/multiport/ConnectionToSelfBank.lf index cbdb4ffa5a..c39933de9b 100644 --- a/test/Rust/src/multiport/ConnectionToSelfBank.lf +++ b/test/Rust/src/multiport/ConnectionToSelfBank.lf @@ -1,10 +1,10 @@ target Rust -reactor Node(bank_index: usize(0), num_nodes: usize(4)) { +reactor Node(bank_index: usize = 0, num_nodes: usize = 4) { input[num_nodes] in: usize output out: usize - state bank_index(bank_index) - state num_nodes(num_nodes) + state bank_index = bank_index + state num_nodes = num_nodes reaction(startup) -> out {= ctx.set(out, self.bank_index); =} @@ -15,7 +15,7 @@ reactor Node(bank_index: usize(0), num_nodes: usize(4)) { =} } -main reactor(num_nodes: usize(4)) { +main reactor(num_nodes: usize = 4) { nodes = new[num_nodes] Node(num_nodes = num_nodes) (nodes.out)+ -> nodes.in } diff --git a/test/Rust/src/multiport/ConnectionToSelfMultiport.lf b/test/Rust/src/multiport/ConnectionToSelfMultiport.lf index b29efc3fdf..6042ad7af5 100644 --- a/test/Rust/src/multiport/ConnectionToSelfMultiport.lf +++ b/test/Rust/src/multiport/ConnectionToSelfMultiport.lf @@ -1,10 +1,10 @@ // test a connection from a multiport to another multiport of the same reactor target Rust -reactor Node(num_nodes: usize(4)) { +reactor Node(num_nodes: usize = 4) { input[num_nodes] in: usize output[num_nodes] out: usize - state num_nodes(num_nodes) + state num_nodes = num_nodes reaction(startup) -> out {= for (i, out) in out.into_iter().enumerate() { @@ -19,7 +19,7 @@ reactor Node(num_nodes: usize(4)) { =} } -main reactor(num_nodes: usize(4)) { +main reactor(num_nodes: usize = 4) { nodes = new Node(num_nodes = num_nodes) nodes.out -> nodes.in // todo: (nodes.out)+ -> nodes.in; } diff --git a/test/Rust/src/multiport/CycledLhs_SelfLoop.lf b/test/Rust/src/multiport/CycledLhs_SelfLoop.lf index 5248dcd11e..925fafce21 100644 --- a/test/Rust/src/multiport/CycledLhs_SelfLoop.lf +++ b/test/Rust/src/multiport/CycledLhs_SelfLoop.lf @@ -8,7 +8,7 @@ reactor Test { output out: u32 input[2] in: u32 logical action act: u32 - state last: u32(1) + state last: u32 = 1 reaction(startup) -> act {= ctx.schedule_with_v(act, Some(1), after!(1 us)); diff --git a/test/Rust/src/multiport/CycledLhs_Single.lf b/test/Rust/src/multiport/CycledLhs_Single.lf index 289bd85159..2fdd5c605c 100644 --- a/test/Rust/src/multiport/CycledLhs_Single.lf +++ b/test/Rust/src/multiport/CycledLhs_Single.lf @@ -8,7 +8,7 @@ reactor Test { output[2] out: u32 input[4] in: u32 logical action act: {= (u32, u32) =} - state last: u32(1) + state last: u32 = 1 reaction(startup) -> act {= ctx.schedule_with_v(act, Some((0, 1)), after!(1 us)); diff --git a/test/Rust/src/multiport/FullyConnected.lf b/test/Rust/src/multiport/FullyConnected.lf index 8dc87882ed..c4cd24f908 100644 --- a/test/Rust/src/multiport/FullyConnected.lf +++ b/test/Rust/src/multiport/FullyConnected.lf @@ -1,16 +1,16 @@ // test iterated connection on the left target Rust -reactor Left(bank_index: usize(0)) { +reactor Left(bank_index: usize = 0) { output out: usize - state bank_index(bank_index) + state bank_index = bank_index reaction(startup) -> out {= ctx.set(out, self.bank_index); =} } -reactor Right(bank_index: usize(0), num_nodes: usize(4)) { +reactor Right(bank_index: usize = 0, num_nodes: usize = 4) { input[num_nodes] in: usize - state num_nodes(num_nodes) + state num_nodes = num_nodes reaction(in) {= let count = r#in.iterate_set().count(); @@ -19,7 +19,7 @@ reactor Right(bank_index: usize(0), num_nodes: usize(4)) { =} } -main reactor(num_nodes: usize(4)) { +main reactor(num_nodes: usize = 4) { left = new[num_nodes] Left() right = new[num_nodes] Right(num_nodes = num_nodes) (left.out)+ -> right.in diff --git a/test/Rust/src/multiport/FullyConnectedAddressable.lf b/test/Rust/src/multiport/FullyConnectedAddressable.lf index 63aed7b840..2c8a056ed1 100644 --- a/test/Rust/src/multiport/FullyConnectedAddressable.lf +++ b/test/Rust/src/multiport/FullyConnectedAddressable.lf @@ -1,14 +1,14 @@ // In this pattern, each node can send direct messages to individual other nodes target Rust -reactor Node(bank_index: usize(0), num_nodes: usize(4)) { - state bank_index(bank_index) - state num_nodes(num_nodes) +reactor Node(bank_index: usize = 0, num_nodes: usize = 4) { + state bank_index = bank_index + state num_nodes = num_nodes input[num_nodes] inpt: usize output[num_nodes] out: usize - state received: bool(false) + state received: bool = false reaction(startup) -> out {= println!("Hello from node {}!", self.bank_index); @@ -43,7 +43,7 @@ reactor Node(bank_index: usize(0), num_nodes: usize(4)) { =} } -main reactor(num_nodes: usize(4)) { +main reactor(num_nodes: usize = 4) { nodes1 = new[num_nodes] Node(num_nodes = num_nodes) nodes1.out -> interleaved (nodes1.inpt) diff --git a/test/Rust/src/multiport/MultiportFromBank.lf b/test/Rust/src/multiport/MultiportFromBank.lf index f17a4ffa8d..6f0592ec36 100644 --- a/test/Rust/src/multiport/MultiportFromBank.lf +++ b/test/Rust/src/multiport/MultiportFromBank.lf @@ -3,14 +3,14 @@ target Rust { timeout: 2 sec } -reactor Source(bank_index: usize(0)) { +reactor Source(bank_index: usize = 0) { output out: usize - state bank_index(bank_index) + state bank_index = bank_index reaction(startup) -> out {= ctx.set(out, self.bank_index); =} } -reactor Destination(port_width: usize(2)) { +reactor Destination(port_width: usize = 2) { input[port_width] in: usize reaction(in) {= diff --git a/test/Rust/src/multiport/MultiportFromHierarchy.lf b/test/Rust/src/multiport/MultiportFromHierarchy.lf index 2745424e8c..d2af4253c4 100644 --- a/test/Rust/src/multiport/MultiportFromHierarchy.lf +++ b/test/Rust/src/multiport/MultiportFromHierarchy.lf @@ -7,7 +7,7 @@ target Rust { reactor Source { timer t(0, 200 msec) output[4] out: u32 - state s: u32(0) + state s: u32 = 0 reaction(t) -> out {= for chan in out { @@ -18,7 +18,7 @@ reactor Source { } reactor Destination { - state s: u32(6) + state s: u32 = 6 input[4] in: u32 reaction(in) {= diff --git a/test/Rust/src/multiport/MultiportIn.lf b/test/Rust/src/multiport/MultiportIn.lf index bbaeb65dda..4ebf1c56d5 100644 --- a/test/Rust/src/multiport/MultiportIn.lf +++ b/test/Rust/src/multiport/MultiportIn.lf @@ -8,7 +8,7 @@ target Rust { reactor Source { timer t(0, 200 msec) output out: u32 - state s: u32(0) + state s: u32 = 0 reaction(t) -> out {= ctx.set(out, self.s); @@ -26,7 +26,7 @@ reactor Computation { } reactor Destination { - state s: u32(0) + state s: u32 = 0 input[4] in: u32 reaction(in) {= diff --git a/test/Rust/src/multiport/MultiportOut.lf b/test/Rust/src/multiport/MultiportOut.lf index 010b3a9603..5e3b9afe77 100644 --- a/test/Rust/src/multiport/MultiportOut.lf +++ b/test/Rust/src/multiport/MultiportOut.lf @@ -6,7 +6,7 @@ target Rust { reactor Source { timer t(0, 200 msec) output[4] out: u32 - state s: u32(0) + state s: u32 = 0 reaction(t) -> out {= for i in 0..out.len() { @@ -30,7 +30,7 @@ reactor Computation { } reactor Destination { - state s: u32(0) + state s: u32 = 0 input[4] in: u32 reaction(in) {= diff --git a/test/Rust/src/multiport/MultiportToBank.lf b/test/Rust/src/multiport/MultiportToBank.lf index fcfdb8bf5d..445ab94d54 100644 --- a/test/Rust/src/multiport/MultiportToBank.lf +++ b/test/Rust/src/multiport/MultiportToBank.lf @@ -11,11 +11,11 @@ reactor Source { =} } -reactor Sink(bank_index: usize(0)) { +reactor Sink(bank_index: usize = 0) { input in: usize - state bank_index(bank_index) + state bank_index = bank_index - state asserts_done: u32(0) + state asserts_done: u32 = 0 reaction(in) {= assert_eq!(ctx.get(r#in), Some(self.bank_index)); diff --git a/test/Rust/src/multiport/MultiportToBankHierarchy.lf b/test/Rust/src/multiport/MultiportToBankHierarchy.lf index 6a7af77ebf..4d7dce445a 100644 --- a/test/Rust/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Rust/src/multiport/MultiportToBankHierarchy.lf @@ -13,11 +13,11 @@ reactor Source { =} } -reactor Destination(bank_index: usize(0)) { +reactor Destination(bank_index: usize = 0) { input in: usize - state bank_index(bank_index) - state asserts_done: u32(0) + state bank_index = bank_index + state asserts_done: u32 = 0 reaction(in) {= assert_eq!(ctx.get(r#in), Some(self.bank_index)); diff --git a/test/Rust/src/multiport/MultiportToMultiport2.lf b/test/Rust/src/multiport/MultiportToMultiport2.lf index 703c498ab3..a1e2db235d 100644 --- a/test/Rust/src/multiport/MultiportToMultiport2.lf +++ b/test/Rust/src/multiport/MultiportToMultiport2.lf @@ -2,7 +2,7 @@ // disconnected) target Rust -reactor Source(width: usize(2)) { +reactor Source(width: usize = 2) { output[width] out: usize reaction(startup) -> out {= @@ -12,7 +12,7 @@ reactor Source(width: usize(2)) { =} } -reactor Destination(width: usize(2)) { +reactor Destination(width: usize = 2) { input[width] in: usize reaction(in) {= diff --git a/test/Rust/src/multiport/ReadOutputOfContainedBank.lf b/test/Rust/src/multiport/ReadOutputOfContainedBank.lf index 80103366db..21bbdf6967 100644 --- a/test/Rust/src/multiport/ReadOutputOfContainedBank.lf +++ b/test/Rust/src/multiport/ReadOutputOfContainedBank.lf @@ -2,8 +2,8 @@ // permutations. target Rust -reactor Contained(bank_index: usize(0)) { - state bank_index(bank_index) +reactor Contained(bank_index: usize = 0) { + state bank_index = bank_index output out: usize @@ -12,7 +12,7 @@ reactor Contained(bank_index: usize(0)) { main reactor { c = new[4] Contained() - state count: usize(0) + state count: usize = 0 reaction(startup) c.out {= for (i, chan) in c__out.iter().enumerate() { diff --git a/test/Rust/src/multiport/WidthWithParameter.lf b/test/Rust/src/multiport/WidthWithParameter.lf index e32f67bec5..03e4617e87 100644 --- a/test/Rust/src/multiport/WidthWithParameter.lf +++ b/test/Rust/src/multiport/WidthWithParameter.lf @@ -1,6 +1,6 @@ target Rust -reactor Some(value: usize(30)) { +reactor Some(value: usize = 30) { output[value] finished: unit reaction(startup) -> finished {= diff --git a/test/Rust/src/multiport/WriteInputOfContainedBank.lf b/test/Rust/src/multiport/WriteInputOfContainedBank.lf index cab6e80e16..f339a3aea1 100644 --- a/test/Rust/src/multiport/WriteInputOfContainedBank.lf +++ b/test/Rust/src/multiport/WriteInputOfContainedBank.lf @@ -1,11 +1,11 @@ // Test writing inputs to a contained reactor bank target Rust -reactor Contained(bank_index: usize(0)) { - state bank_index(bank_index) +reactor Contained(bank_index: usize = 0) { + state bank_index = bank_index input inpt: usize - state count: usize(0) + state count: usize = 0 reaction(inpt) {= let result = ctx.get(inpt).unwrap(); diff --git a/test/Rust/src/target/CliFeature.lf b/test/Rust/src/target/CliFeature.lf index bfa8fb5746..2ef81e76bb 100644 --- a/test/Rust/src/target/CliFeature.lf +++ b/test/Rust/src/target/CliFeature.lf @@ -4,6 +4,6 @@ target Rust { } // todo allow test framework to pass CLI arguments. -main reactor CliFeature(size: u32(4), t: time(4 sec)) { +main reactor CliFeature(size: u32 = 4, t: time = 4 sec) { reaction(startup) {= println!("success"); =} } diff --git a/test/Rust/src/target/MainParameterCanBeExpression.lf b/test/Rust/src/target/MainParameterCanBeExpression.lf index 9e62cb29cb..99ab0d7389 100644 --- a/test/Rust/src/target/MainParameterCanBeExpression.lf +++ b/test/Rust/src/target/MainParameterCanBeExpression.lf @@ -3,8 +3,8 @@ target Rust { cargo-features: ["cli"] } -main reactor(size: u32({= 1u32 << 23 =})) { - state s(size) +main reactor(size: u32 = {= 1u32 << 23 =}) { + state s = size reaction(startup) {= assert_eq!(1u32 << 23, self.s); diff --git a/test/TypeScript/src/ActionDelay.lf b/test/TypeScript/src/ActionDelay.lf index 387e0331de..5882d18962 100644 --- a/test/TypeScript/src/ActionDelay.lf +++ b/test/TypeScript/src/ActionDelay.lf @@ -4,7 +4,7 @@ target TypeScript reactor GeneratedDelay { input y_in: number output y_out: number - state y_state: number(0) + state y_state: number = 0 logical action act(100 msec) reaction(y_in) -> act {= diff --git a/test/TypeScript/src/After.lf b/test/TypeScript/src/After.lf index 24aa2cdb29..8a872103e9 100644 --- a/test/TypeScript/src/After.lf +++ b/test/TypeScript/src/After.lf @@ -13,7 +13,7 @@ reactor Foo { } reactor Print { - state expected_time: time(10 msec) + state expected_time: time = 10 msec input x: number reaction(x) {= diff --git a/test/TypeScript/src/ArrayAsParameter.lf b/test/TypeScript/src/ArrayAsParameter.lf index 7f5e272d46..1fd7e47bb3 100644 --- a/test/TypeScript/src/ArrayAsParameter.lf +++ b/test/TypeScript/src/ArrayAsParameter.lf @@ -1,9 +1,9 @@ // Source has an array as a parameter, the elements of which it passes to Print. target TypeScript -reactor Source(sequence: {= Array =}({= [0, 1, 2] =})) { +reactor Source(sequence: {= Array =} = {= [0, 1, 2] =}) { output out: number - state count: number(0) + state count: number = 0 logical action next reaction(startup, next) -> out, next {= @@ -17,7 +17,7 @@ reactor Source(sequence: {= Array =}({= [0, 1, 2] =})) { reactor Print { input x: number - state count: number(1) + state count: number = 1 reaction(x) {= console.log("Received: " + x + "."); diff --git a/test/TypeScript/src/ArrayAsType.lf b/test/TypeScript/src/ArrayAsType.lf index 651dc37f29..9e30764307 100644 --- a/test/TypeScript/src/ArrayAsType.lf +++ b/test/TypeScript/src/ArrayAsType.lf @@ -15,7 +15,7 @@ reactor Source { =} } -reactor Print(scale: number(1)) { // The scale parameter is just for testing. +reactor Print(scale: number = 1) { // The scale parameter is just for testing. input x: {= Array =} reaction(x) {= diff --git a/test/TypeScript/src/ArrayPrint.lf b/test/TypeScript/src/ArrayPrint.lf index 62312c6a8e..93b6486506 100644 --- a/test/TypeScript/src/ArrayPrint.lf +++ b/test/TypeScript/src/ArrayPrint.lf @@ -15,7 +15,7 @@ reactor Source { =} } -reactor Print(scale: number(1)) { // The scale parameter is just for testing. +reactor Print(scale: number = 1) { // The scale parameter is just for testing. input x: {= Array =} reaction(x) {= diff --git a/test/TypeScript/src/ArrayScale.lf b/test/TypeScript/src/ArrayScale.lf index 0b54e4a4ef..107ef8cf2f 100644 --- a/test/TypeScript/src/ArrayScale.lf +++ b/test/TypeScript/src/ArrayScale.lf @@ -6,7 +6,7 @@ target TypeScript import Source, Print from "ArrayPrint.lf" -reactor Scale(scale: number(2)) { +reactor Scale(scale: number = 2) { mutable input x: {= Array =} output out: {= Array =} diff --git a/test/TypeScript/src/Composition.lf b/test/TypeScript/src/Composition.lf index 35c259d967..e74bbe9aa9 100644 --- a/test/TypeScript/src/Composition.lf +++ b/test/TypeScript/src/Composition.lf @@ -4,10 +4,10 @@ target TypeScript { timeout: 5 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { output y: number timer t(1 sec, period) - state count: number(0) + state count: number = 0 reaction(t) -> y {= count++; @@ -17,7 +17,7 @@ reactor Source(period: time(2 sec)) { reactor Test { input x: number - state count: number(0) + state count: number = 0 reaction(x) {= count++; diff --git a/test/TypeScript/src/CompositionAfter.lf b/test/TypeScript/src/CompositionAfter.lf index afce86ccfe..8840298c2d 100644 --- a/test/TypeScript/src/CompositionAfter.lf +++ b/test/TypeScript/src/CompositionAfter.lf @@ -5,10 +5,10 @@ target TypeScript { timeout: 10 sec } -reactor Source(period: time(2 sec)) { +reactor Source(period: time = 2 sec) { output y: number timer t(1 sec, period) - state count: number(0) + state count: number = 0 reaction(t) -> y {= count++; @@ -18,7 +18,7 @@ reactor Source(period: time(2 sec)) { reactor Test { input x: number - state count: number(0) + state count: number = 0 reaction(x) {= count++; @@ -29,7 +29,7 @@ reactor Test { =} } -main reactor(delay: time(5 sec)) { +main reactor(delay: time = 5 sec) { s = new Source() d = new Test() s.y -> d.x after delay diff --git a/test/TypeScript/src/CountTest.lf b/test/TypeScript/src/CountTest.lf index 66737a6007..ba9e179b9b 100644 --- a/test/TypeScript/src/CountTest.lf +++ b/test/TypeScript/src/CountTest.lf @@ -6,7 +6,7 @@ import Count from "lib/Count.lf" reactor Test { input c: number - state i: number(0) + state i: number = 0 reaction(c) {= console.log("Received " + c); diff --git a/test/TypeScript/src/Deadline.lf b/test/TypeScript/src/Deadline.lf index 1d639e94f3..9f3086f1f5 100644 --- a/test/TypeScript/src/Deadline.lf +++ b/test/TypeScript/src/Deadline.lf @@ -5,10 +5,10 @@ target TypeScript { timeout: 4 sec } -reactor Source(period: time(2 sec)) { // run = "bin/Deadline -timeout 4 sec" +reactor Source(period: time = 2 sec) { // run = "bin/Deadline -timeout 4 sec" output y: number timer t(0, period) - state count: number(0) + state count: number = 0 reaction(t) -> y {= if (2 * Math.floor(count / 2) != count){ @@ -25,9 +25,9 @@ reactor Source(period: time(2 sec)) { // run = "bin/Deadline -timeout 4 sec" =} } -reactor Destination(timeout: time(1 sec)) { +reactor Destination(timeout: time = 1 sec) { input x: number - state count: number(0) + state count: number = 0 reaction(x) {= console.log("Destination receives: " + x); diff --git a/test/TypeScript/src/DeadlineHandledAbove.lf b/test/TypeScript/src/DeadlineHandledAbove.lf index 83ab279b23..ba47fd7aac 100644 --- a/test/TypeScript/src/DeadlineHandledAbove.lf +++ b/test/TypeScript/src/DeadlineHandledAbove.lf @@ -4,7 +4,7 @@ target TypeScript { timeout: 2 sec } -reactor Deadline(threshold: time(100 msec)) { +reactor Deadline(threshold: time = 100 msec) { input x: number output deadline_violation: boolean @@ -19,7 +19,7 @@ reactor Deadline(threshold: time(100 msec)) { } main reactor DeadlineHandledAbove { - state violation_detected: boolean(false) + state violation_detected: boolean = false d = new Deadline(threshold = 10 msec) reaction(startup) -> d.x {= diff --git a/test/TypeScript/src/DelayInt.lf b/test/TypeScript/src/DelayInt.lf index d38e1103f5..224a7eab4a 100644 --- a/test/TypeScript/src/DelayInt.lf +++ b/test/TypeScript/src/DelayInt.lf @@ -2,7 +2,7 @@ // is a start at handling dynamic memory allocation for such actions. target TypeScript -reactor Delay(delay: time(100 msec)) { +reactor Delay(delay: time = 100 msec) { input x: number output out: number logical action a: number @@ -18,8 +18,8 @@ reactor Delay(delay: time(100 msec)) { reactor Test { input x: number - state start_time: time(0) - state received_value: boolean(false) + state start_time: time = 0 + state received_value: boolean = false reaction(startup) {= // Record the logical time at the start. diff --git a/test/TypeScript/src/DelayedAction.lf b/test/TypeScript/src/DelayedAction.lf index 6b6a155952..53ee33e963 100644 --- a/test/TypeScript/src/DelayedAction.lf +++ b/test/TypeScript/src/DelayedAction.lf @@ -5,7 +5,7 @@ target TypeScript { main reactor DelayedAction { timer t(0, 1 sec) logical action a - state count: number(0) + state count: number = 0 reaction(t) -> a {= actions.a.schedule(TimeValue.msec(100), null); =} diff --git a/test/TypeScript/src/DoubleInvocation.lf b/test/TypeScript/src/DoubleInvocation.lf index e2b61789e4..9557857ee2 100644 --- a/test/TypeScript/src/DoubleInvocation.lf +++ b/test/TypeScript/src/DoubleInvocation.lf @@ -13,7 +13,7 @@ target TypeScript { reactor Ball { output position: number output velocity: number - state p: number(200) + state p: number = 200 timer trigger(0, 1 sec) reaction(trigger) -> position, velocity {= @@ -26,7 +26,7 @@ reactor Ball { reactor Print { input velocity: number input position: number - state previous: number(-1) + state previous: number = -1 reaction(startup) {= console.log("####### Print startup"); diff --git a/test/TypeScript/src/DoubleReaction.lf b/test/TypeScript/src/DoubleReaction.lf index 26dccb8895..b172166613 100644 --- a/test/TypeScript/src/DoubleReaction.lf +++ b/test/TypeScript/src/DoubleReaction.lf @@ -5,10 +5,10 @@ target TypeScript { fast: true } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: number timer t(offset, period) - state count: number(0) + state count: number = 0 reaction(t) -> y {= count++; @@ -19,7 +19,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: number input w: number - state s: number(2) + state s: number = 2 reaction(x, w) {= let sum = 0; diff --git a/test/TypeScript/src/DoubleTrigger.lf b/test/TypeScript/src/DoubleTrigger.lf index 34c1596325..fc8921622c 100644 --- a/test/TypeScript/src/DoubleTrigger.lf +++ b/test/TypeScript/src/DoubleTrigger.lf @@ -8,7 +8,7 @@ target TypeScript { main reactor DoubleTrigger { timer t1 timer t2 - state s: number(0) + state s: number = 0 reaction(t1, t2) {= s++; diff --git a/test/TypeScript/src/FloatLiteral.lf b/test/TypeScript/src/FloatLiteral.lf index 1d3e688deb..fb50d007d0 100644 --- a/test/TypeScript/src/FloatLiteral.lf +++ b/test/TypeScript/src/FloatLiteral.lf @@ -2,10 +2,10 @@ target TypeScript // This test verifies that floating-point literals are handled correctly. main reactor { - state N: number(6.0221409e+23) - state charge: number(-1.6021766E-19) - state minus_epsilon: number(-.01e0) - state expected: number(.964853323188E5) + state N: number = 6.0221409e+23 + state charge: number = -1.6021766E-19 + state minus_epsilon: number = -.01e0 + state expected: number = .964853323188E5 reaction(startup) {= const F: number = - N * charge; diff --git a/test/TypeScript/src/Gain.lf b/test/TypeScript/src/Gain.lf index 056b15e2d3..23558da9cf 100644 --- a/test/TypeScript/src/Gain.lf +++ b/test/TypeScript/src/Gain.lf @@ -1,7 +1,7 @@ // Example in the Wiki. target TypeScript -reactor Scale(scale: number(2)) { +reactor Scale(scale: number = 2) { input x: number output y: number @@ -10,7 +10,7 @@ reactor Scale(scale: number(2)) { reactor Test { input x: number - state received_value: boolean(false) + state received_value: boolean = false reaction(x) {= console.log("Received " + x + "."); diff --git a/test/TypeScript/src/Hello.lf b/test/TypeScript/src/Hello.lf index d762535149..c2806f83b8 100644 --- a/test/TypeScript/src/Hello.lf +++ b/test/TypeScript/src/Hello.lf @@ -8,9 +8,9 @@ target TypeScript { fast: true } -reactor Reschedule(period: time(2 sec), message: string("Hello TypeScript")) { - state count: number(0) - state previous_time: time(0) +reactor Reschedule(period: time = 2 sec, message: string = "Hello TypeScript") { + state count: number = 0 + state previous_time: time = 0 timer t(1 sec, period) logical action a @@ -38,8 +38,8 @@ reactor Reschedule(period: time(2 sec), message: string("Hello TypeScript")) { } reactor Inside( - period: time(1 sec), - message: string("Composite default message.") + period: time = 1 sec, + message: string = "Composite default message." ) { third_instance = new Reschedule(period = period, message = message) } diff --git a/test/TypeScript/src/Hierarchy2.lf b/test/TypeScript/src/Hierarchy2.lf index bd469242f7..da2db6308f 100644 --- a/test/TypeScript/src/Hierarchy2.lf +++ b/test/TypeScript/src/Hierarchy2.lf @@ -14,7 +14,7 @@ reactor Source { reactor Count { output out: number timer t(0, 1 sec) - state i: number(0) + state i: number = 0 reaction(t) -> out {= i++; @@ -37,7 +37,7 @@ reactor Add { reactor Print { input x: number - state expected: number(2) + state expected: number = 2 reaction(x) {= x = x as number; diff --git a/test/TypeScript/src/MovingAverage.lf b/test/TypeScript/src/MovingAverage.lf index b7b11dc7fd..19e767e3e2 100644 --- a/test/TypeScript/src/MovingAverage.lf +++ b/test/TypeScript/src/MovingAverage.lf @@ -8,7 +8,7 @@ target TypeScript { reactor Source { output out: number - state count: number(0) + state count: number = 0 timer clock(0, 200 msec) reaction(clock) -> out {= @@ -18,8 +18,8 @@ reactor Source { } reactor MovingAverageImpl { - state delay_line: {= Array =}({= [0.0, 0.0, 0.0] =}) - state index: number(0) + state delay_line: {= Array =} = {= [0.0, 0.0, 0.0] =} + state index: number = 0 input x: number output out: number @@ -45,7 +45,7 @@ reactor MovingAverageImpl { reactor Print { input x: number - state count: number(0) + state count: number = 0 reaction(x) {= x = x as number; diff --git a/test/TypeScript/src/NativeListsAndTimes.lf b/test/TypeScript/src/NativeListsAndTimes.lf index 4a3751bd09..ad22d67d02 100644 --- a/test/TypeScript/src/NativeListsAndTimes.lf +++ b/test/TypeScript/src/NativeListsAndTimes.lf @@ -2,22 +2,22 @@ target TypeScript // This test passes if it is successfully compiled into valid target code. main reactor( - x: number(0), - y: time(0), // Units are missing but not required - z(1 msec), // Type is missing but not required + x: number = 0, + y: time = 0, // Units are missing but not required + z = 1 msec, // Type is missing but not required p: number[](1, 2, 3, 4), // List of integers q: TimeValue[](1 msec, 2 msec, 3 msec), // list of time values g: time[](1 msec, 2 msec) // List of time values ) { - state s: time(y) // Reference to explicitly typed time parameter - state t: time(z) // Reference to implicitly typed time parameter + state s: time = y // Reference to explicitly typed time parameter + state t: time = z // Reference to implicitly typed time parameter state v: boolean // Uninitialized boolean state variable state w: time // Uninitialized time state variable timer tick(0) // Units missing but not required timer tock(1 sec) // Implicit type time timer toe(z) // Implicit type time - state baz(p) // Implicit type int[] - state period(z) // Implicit type time + state baz = p // Implicit type int[] + state period = z // Implicit type time reaction(tick) {= // Target code diff --git a/test/TypeScript/src/ParameterizedState.lf b/test/TypeScript/src/ParameterizedState.lf index d2ea34da12..1484812489 100644 --- a/test/TypeScript/src/ParameterizedState.lf +++ b/test/TypeScript/src/ParameterizedState.lf @@ -1,7 +1,7 @@ target TypeScript -reactor Foo(bar: number(42)) { - state baz(bar) +reactor Foo(bar: number = 42) { + state baz = bar reaction(startup) {= console.log("Baz: " + baz); =} } diff --git a/test/TypeScript/src/PeriodicDesugared.lf b/test/TypeScript/src/PeriodicDesugared.lf index aaeac0e7d9..b99317e07a 100644 --- a/test/TypeScript/src/PeriodicDesugared.lf +++ b/test/TypeScript/src/PeriodicDesugared.lf @@ -1,9 +1,9 @@ target TypeScript -main reactor(offset: time(0), period: time(500 msec)) { +main reactor(offset: time = 0, period: time = 500 msec) { logical action init(offset) logical action recur(period) - state count: number(0) + state count: number = 0 reaction(startup) -> init, recur {= if (offset.isZero()) { diff --git a/test/TypeScript/src/ReadOutputOfContainedReactor.lf b/test/TypeScript/src/ReadOutputOfContainedReactor.lf index af1c4ed0e0..01b725e181 100644 --- a/test/TypeScript/src/ReadOutputOfContainedReactor.lf +++ b/test/TypeScript/src/ReadOutputOfContainedReactor.lf @@ -10,7 +10,7 @@ reactor Contained { main reactor ReadOutputOfContainedReactor { c = new Contained() - state count: number(0) + state count: number = 0 reaction(startup) c.out {= console.log("Startup reaction reading output of contained reactor: " + c.out); diff --git a/test/TypeScript/src/ScheduleLogicalAction.lf b/test/TypeScript/src/ScheduleLogicalAction.lf index 65fae1a237..84e8fbe1cb 100644 --- a/test/TypeScript/src/ScheduleLogicalAction.lf +++ b/test/TypeScript/src/ScheduleLogicalAction.lf @@ -21,7 +21,7 @@ reactor foo { } reactor print { - state expected_time: time(0) + state expected_time: time = 0 input x: number reaction(x) {= diff --git a/test/TypeScript/src/SendingInside.lf b/test/TypeScript/src/SendingInside.lf index 720ce71e64..ca4b6489b3 100644 --- a/test/TypeScript/src/SendingInside.lf +++ b/test/TypeScript/src/SendingInside.lf @@ -7,7 +7,7 @@ target TypeScript { reactor Printer { input x: number - state count: number(1) + state count: number = 1 reaction(x) {= console.log("Inside reactor received: " + x); @@ -19,7 +19,7 @@ reactor Printer { } main reactor SendingInside { - state count: number(0) + state count: number = 0 timer t(0, 1 sec) p = new Printer() diff --git a/test/TypeScript/src/SendsPointerTest.lf b/test/TypeScript/src/SendsPointerTest.lf index 55eb6eca26..3c80613b52 100644 --- a/test/TypeScript/src/SendsPointerTest.lf +++ b/test/TypeScript/src/SendsPointerTest.lf @@ -12,7 +12,7 @@ reactor SendsPointer { } // expected parameter is for testing. -reactor Print(expected: {= {value: number} =}({= { value: 42 } =})) { +reactor Print(expected: {= {value: number} =} = {= { value: 42 } =}) { input x: {= {value: number} =} reaction(x) {= diff --git a/test/TypeScript/src/SimpleDeadline.lf b/test/TypeScript/src/SimpleDeadline.lf index 7327dab0a3..a518e04e5e 100644 --- a/test/TypeScript/src/SimpleDeadline.lf +++ b/test/TypeScript/src/SimpleDeadline.lf @@ -3,7 +3,7 @@ // violation. target TypeScript -reactor Deadline(threshold: time(100 msec)) { +reactor Deadline(threshold: time = 100 msec) { input x: number output deadlineViolation: boolean diff --git a/test/TypeScript/src/SlowingClock.lf b/test/TypeScript/src/SlowingClock.lf index cc447bcd7c..772d2e2913 100644 --- a/test/TypeScript/src/SlowingClock.lf +++ b/test/TypeScript/src/SlowingClock.lf @@ -5,8 +5,8 @@ target TypeScript { main reactor SlowingClock { logical action a(100 msec) - state interval: time(100 msec) - state expected_time: time(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec reaction(startup) -> a {= actions.a.schedule(0, null); =} diff --git a/test/TypeScript/src/SlowingClockPhysical.lf b/test/TypeScript/src/SlowingClockPhysical.lf index 4fa5907f73..53bc3f9da4 100644 --- a/test/TypeScript/src/SlowingClockPhysical.lf +++ b/test/TypeScript/src/SlowingClockPhysical.lf @@ -14,8 +14,8 @@ target TypeScript { main reactor SlowingClockPhysical { physical action a(100 msec) - state interval: time(100 msec) - state expected_time: time(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec reaction(startup) -> a {= expected_time = TimeValue.msec(100); diff --git a/test/TypeScript/src/Stop.lf b/test/TypeScript/src/Stop.lf index 625cedaac7..6104c418d5 100644 --- a/test/TypeScript/src/Stop.lf +++ b/test/TypeScript/src/Stop.lf @@ -13,7 +13,7 @@ import Sender from "lib/LoopedActionSender.lf" reactor Consumer { input in1: number - state reactionInvokedCorrectly: boolean(false) + state reactionInvokedCorrectly: boolean = false reaction(in1) {= const currentTag = util.getCurrentTag(); diff --git a/test/TypeScript/src/Stride.lf b/test/TypeScript/src/Stride.lf index c8afaa63ad..04d7805d0b 100644 --- a/test/TypeScript/src/Stride.lf +++ b/test/TypeScript/src/Stride.lf @@ -5,8 +5,8 @@ target TypeScript { fast: true } -reactor Count(stride: number(1)) { - state count: number(0) +reactor Count(stride: number = 1) { + state count: number = 0 output y: number timer t(0, 100 msec) diff --git a/test/TypeScript/src/StructAsState.lf b/test/TypeScript/src/StructAsState.lf index 10da7b2876..a3b1cb081c 100644 --- a/test/TypeScript/src/StructAsState.lf +++ b/test/TypeScript/src/StructAsState.lf @@ -8,7 +8,7 @@ main reactor StructAsState { value: number; } =} - state s: hello_t({= {name: "Earth", value: 42} =}) + state s: hello_t = {= {name: "Earth", value: 42} =} reaction(startup) {= console.log("State s.name=" + s.name + ", s.value=" + s.value); diff --git a/test/TypeScript/src/StructAsType.lf b/test/TypeScript/src/StructAsType.lf index c9d092c7cb..ed70a46653 100644 --- a/test/TypeScript/src/StructAsType.lf +++ b/test/TypeScript/src/StructAsType.lf @@ -18,7 +18,7 @@ reactor Source { =} } -reactor Print(expected: number(42)) { // expected parameter is for testing. +reactor Print(expected: number = 42) { // expected parameter is for testing. input x: hello_t reaction(x) {= diff --git a/test/TypeScript/src/StructAsTypeDirect.lf b/test/TypeScript/src/StructAsTypeDirect.lf index 079735f108..3f891747fc 100644 --- a/test/TypeScript/src/StructAsTypeDirect.lf +++ b/test/TypeScript/src/StructAsTypeDirect.lf @@ -18,7 +18,7 @@ reactor Source { =} } -reactor Print(expected: number(42)) { // expected parameter is for testing. +reactor Print(expected: number = 42) { // expected parameter is for testing. input x: hello_t reaction(x) {= diff --git a/test/TypeScript/src/StructPrint.lf b/test/TypeScript/src/StructPrint.lf index 400d26b610..e75d9ead37 100644 --- a/test/TypeScript/src/StructPrint.lf +++ b/test/TypeScript/src/StructPrint.lf @@ -17,7 +17,7 @@ reactor Source { =} } -reactor Print(expected: number(42)) { // expected parameter is for testing. +reactor Print(expected: number = 42) { // expected parameter is for testing. input x: hello_t reaction(x) {= diff --git a/test/TypeScript/src/StructScale.lf b/test/TypeScript/src/StructScale.lf index 46bef4bc2d..788fd2fe61 100644 --- a/test/TypeScript/src/StructScale.lf +++ b/test/TypeScript/src/StructScale.lf @@ -6,7 +6,7 @@ target TypeScript import Print, Source from "StructPrint.lf" -reactor Scale(scale: number(2)) { +reactor Scale(scale: number = 2) { // Mutable keyword indicates that this reactor wants a writable copy of the // input. mutable input x: hello_t diff --git a/test/TypeScript/src/TimeLimit.lf b/test/TypeScript/src/TimeLimit.lf index d581c8c8a9..05a2a5a3b3 100644 --- a/test/TypeScript/src/TimeLimit.lf +++ b/test/TypeScript/src/TimeLimit.lf @@ -7,10 +7,10 @@ target TypeScript { logging: INFO } -reactor Clock(offset: time(0), period: time(1 sec)) { +reactor Clock(offset: time = 0, period: time = 1 sec) { output y: number timer t(offset, period) - state count: number(0) + state count: number = 0 reaction(t) -> y {= count++; @@ -20,7 +20,7 @@ reactor Clock(offset: time(0), period: time(1 sec)) { reactor Destination { input x: number - state s: number(1) + state s: number = 1 reaction(x) {= if (x != s) { @@ -30,7 +30,7 @@ reactor Destination { =} } -main reactor TimeLimit(period: time(1 msec)) { // usecs take a little too long +main reactor TimeLimit(period: time = 1 msec) { // usecs take a little too long timer stop(10 sec) c = new Clock(period = period) diff --git a/test/TypeScript/src/TimeState.lf b/test/TypeScript/src/TimeState.lf index 95d21f8f52..1dfa86312f 100644 --- a/test/TypeScript/src/TimeState.lf +++ b/test/TypeScript/src/TimeState.lf @@ -1,7 +1,7 @@ target TypeScript -reactor Foo(bar: number(42)) { - state baz: time(500 msec) +reactor Foo(bar: number = 42) { + state baz: time = 500 msec reaction(startup) {= console.log("Baz: " + baz); =} } diff --git a/test/TypeScript/src/concurrent/AsyncCallback.lf b/test/TypeScript/src/concurrent/AsyncCallback.lf index bedf2a47a8..2154d52533 100644 --- a/test/TypeScript/src/concurrent/AsyncCallback.lf +++ b/test/TypeScript/src/concurrent/AsyncCallback.lf @@ -17,11 +17,11 @@ main reactor AsyncCallback { } =} timer t(0, 200 msec) - state expected_time: time(100 msec) - state toggle: boolean(false) + state expected_time: time = 100 msec + state toggle: boolean = false physical action a(100 msec): number - state i: number(0) + state i: number = 0 reaction(t) -> a {= // set a timeout for the callback diff --git a/test/TypeScript/src/docker/federated/DistributedCountContainerized.lf b/test/TypeScript/src/docker/federated/DistributedCountContainerized.lf index 34813bef73..ee03246c37 100644 --- a/test/TypeScript/src/docker/federated/DistributedCountContainerized.lf +++ b/test/TypeScript/src/docker/federated/DistributedCountContainerized.lf @@ -11,7 +11,7 @@ target TypeScript { import Count from "../../lib/Count.lf" import Print from "../../federated/DistributedCount.lf" -federated reactor(offset: time(200 msec)) at rti { +federated reactor(offset: time = 200 msec) at rti { c = new Count() p = new Print() c.out -> p.inp after offset diff --git a/test/TypeScript/src/federated/DistributedCount.lf b/test/TypeScript/src/federated/DistributedCount.lf index 423dadd499..50f510cdcd 100644 --- a/test/TypeScript/src/federated/DistributedCount.lf +++ b/test/TypeScript/src/federated/DistributedCount.lf @@ -14,7 +14,7 @@ import Count from "../lib/Count.lf" reactor Print { input inp: number - state c: number(1) + state c: number = 1 reaction(inp) {= const elapsedTime = util.getElapsedLogicalTime(); @@ -35,7 +35,7 @@ reactor Print { =} } -federated reactor DistributedCount(offset: time(200 msec)) { +federated reactor DistributedCount(offset: time = 200 msec) { c = new Count() p = new Print() c.out -> p.inp after offset diff --git a/test/TypeScript/src/federated/DistributedCountPhysical.lf b/test/TypeScript/src/federated/DistributedCountPhysical.lf index c0edeb4c33..9ab549e0d0 100644 --- a/test/TypeScript/src/federated/DistributedCountPhysical.lf +++ b/test/TypeScript/src/federated/DistributedCountPhysical.lf @@ -14,7 +14,7 @@ target TypeScript { reactor Count { timer t(200 msec, 1 sec) - state s: number(0) + state s: number = 0 output out: number reaction(t) -> out {= @@ -25,8 +25,8 @@ reactor Count { reactor Print { input inp: number - state c: number(0) - state compareTime: time(200 msec) + state c: number = 0 + state compareTime: time = 200 msec reaction(inp) {= let elapsedTime = util.getElapsedLogicalTime(); diff --git a/test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf new file mode 100644 index 0000000000..5f81d3cc5f --- /dev/null +++ b/test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -0,0 +1,49 @@ +/** + * Test a distributed system where a federation receives messages only over + * connections that are marked 'physical' (using the ~> arrow) with an after + * delay. The receiver verifies that the after delay is correctly imposed. + * + * @author Edward A. Lee + * @author Soroush Bateni + * @author Byeong-gil Jun + */ +target TypeScript { + logging: debug, + keepalive: true +} + +import Count from "../lib/Count.lf" + +reactor Print { + input inp: number + state c: number = 1 + + reaction(inp) {= + const elapsedTime = util.getElapsedLogicalTime(); + console.log(`At time ${elapsedTime}, received ${inp}`); + if (inp !== c) { + util.requestErrorStop(`ERROR: Expected to receive ${c}.`); + } + if (!elapsedTime.isLaterThan(TimeValue.msec(600))) { + util.requestErrorStop(`ERROR: Expected received time to be strictly greater than ${TimeValue.msec(600)}`); + } + c++; + console.log(`c = ${c}`); + util.requestStop(); + =} + + reaction(shutdown) {= + if (c !== 2) { + util.requestErrorStop(`ERROR: Expected to receive 1 item. Received ${c - 1}.`); + } else { + console.log("SUCCESS: Successfully received 1 item."); + } + =} +} + +federated reactor at localhost { + c = new Count(offset = 200 msec, period = 0) + p = new Print() + // Indicating a 'physical' connection with a 400 msec after delay. + c.out ~> p.inp after 400 msec +} diff --git a/test/TypeScript/src/federated/DistributedDoublePort.lf b/test/TypeScript/src/federated/DistributedDoublePort.lf index d8677d65a4..d3a2636661 100644 --- a/test/TypeScript/src/federated/DistributedDoublePort.lf +++ b/test/TypeScript/src/federated/DistributedDoublePort.lf @@ -17,7 +17,7 @@ target TypeScript { import Count from "../lib/Count.lf" reactor CountMicrostep { - state count: number(1) + state count: number = 1 output out: number logical action act: number timer t(0, 1 sec) diff --git a/test/TypeScript/src/federated/DistributedLoopedAction.lf b/test/TypeScript/src/federated/DistributedLoopedAction.lf index 5e8619395f..02a7f5dc62 100644 --- a/test/TypeScript/src/federated/DistributedLoopedAction.lf +++ b/test/TypeScript/src/federated/DistributedLoopedAction.lf @@ -11,11 +11,11 @@ target TypeScript { import Sender from "../lib/LoopedActionSender.lf" -reactor Receiver(takeBreakAfter: number(10), breakInterval: time(400 msec)) { +reactor Receiver(takeBreakAfter: number = 10, breakInterval: time = 400 msec) { input inp: number - state receivedMessages: number(0) - state totalReceivedMessages: number(0) - state breaks: number(0) + state receivedMessages: number = 0 + state totalReceivedMessages: number = 0 + state breaks: number = 0 timer t(0, 1 msec) // This will impact the performance // but forces the logical time to advance Comment this line for a more diff --git a/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf b/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf index c747061578..842f13f74c 100644 --- a/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf @@ -10,10 +10,10 @@ target TypeScript { timeout: 1 sec } -reactor Sender(takeBreakAfter: number(10), breakInterval: time(550 msec)) { +reactor Sender(takeBreakAfter: number = 10, breakInterval: time = 550 msec) { output out: number physical action act - state sentMessages: number(0) + state sentMessages: number = 0 reaction(startup, act) -> act, out {= // Send a message on out @@ -29,11 +29,11 @@ reactor Sender(takeBreakAfter: number(10), breakInterval: time(550 msec)) { =} } -reactor Receiver(takeBreakAfter: number(10), breakInterval: time(550 msec)) { +reactor Receiver(takeBreakAfter: number = 10, breakInterval: time = 550 msec) { input inp: number - state receivedMessages: number(0) - state totalReceivedMessages: number(0) - state breaks: number(0) + state receivedMessages: number = 0 + state totalReceivedMessages: number = 0 + state breaks: number = 0 timer t(0, 1 msec) // This will impact the performance // but forces the logical time to advance Comment this line for a more diff --git a/test/TypeScript/src/federated/DistributedStop.lf b/test/TypeScript/src/federated/DistributedStop.lf index 2983ff3f7a..c0dd04149a 100644 --- a/test/TypeScript/src/federated/DistributedStop.lf +++ b/test/TypeScript/src/federated/DistributedStop.lf @@ -11,7 +11,7 @@ reactor Sender { output out: number timer t(0, 1 usec) logical action act - state reaction_invoked_correctly: boolean(false) + state reaction_invoked_correctly: boolean = false reaction(t, act) -> out, act {= console.log(`Sending 42 at (${util.getElapsedLogicalTime()}, ` @@ -58,10 +58,10 @@ reactor Sender { } reactor Receiver( - stp_offset: time(10 msec) // Used in the decentralized variant of the test + stp_offset: time = 10 msec // Used in the decentralized variant of the test ) { input in1: number - state reaction_invoked_correctly: boolean(false) + state reaction_invoked_correctly: boolean = false reaction(in1) {= console.log(`Received ${in1} at (${util.getElapsedLogicalTime()}, ` diff --git a/test/TypeScript/src/federated/HelloDistributed.lf b/test/TypeScript/src/federated/HelloDistributed.lf index 12533129e4..1189270ab1 100644 --- a/test/TypeScript/src/federated/HelloDistributed.lf +++ b/test/TypeScript/src/federated/HelloDistributed.lf @@ -20,7 +20,7 @@ reactor Source { reactor Destination { input inp: string - state received: boolean(false) + state received: boolean = false reaction(startup) {= console.log("Destination started."); =} diff --git a/test/TypeScript/src/federated/LoopDistributedCentralized.lf b/test/TypeScript/src/federated/LoopDistributedCentralized.lf index d5fdae2635..bb52679489 100644 --- a/test/TypeScript/src/federated/LoopDistributedCentralized.lf +++ b/test/TypeScript/src/federated/LoopDistributedCentralized.lf @@ -9,11 +9,11 @@ target TypeScript { timeout: 5 sec } -reactor Looper(incr: number(1), delay: time(0 msec)) { +reactor Looper(incr: number = 1, delay: time = 0 msec) { input inp: number output out: number physical action a(delay) - state count: number(0) + state count: number = 0 preamble {= let stop = false; @@ -57,7 +57,7 @@ reactor Looper(incr: number(1), delay: time(0 msec)) { =} } -federated reactor LoopDistributedCentralized(delay: time(0)) { +federated reactor LoopDistributedCentralized(delay: time = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.inp diff --git a/test/TypeScript/src/federated/LoopDistributedDouble.lf b/test/TypeScript/src/federated/LoopDistributedDouble.lf index b86e55feaa..2c791377f7 100644 --- a/test/TypeScript/src/federated/LoopDistributedDouble.lf +++ b/test/TypeScript/src/federated/LoopDistributedDouble.lf @@ -13,13 +13,13 @@ target TypeScript { } } -reactor Looper(incr: number(1), delay: time(0 msec)) { +reactor Looper(incr: number = 1, delay: time = 0 msec) { input inp: number input inp2: number output out: number output out2: number physical action a(delay) - state count: number(0) + state count: number = 0 timer t(0, 1 sec) preamble {= @@ -71,7 +71,7 @@ reactor Looper(incr: number(1), delay: time(0 msec)) { =} } -federated reactor(delay: time(0)) { +federated reactor(delay: time = 0) { left = new Looper() right = new Looper(incr = -1) left.out -> right.inp diff --git a/test/TypeScript/src/federated/PingPongDistributed.lf b/test/TypeScript/src/federated/PingPongDistributed.lf index 0c362b1bf7..34a633aba4 100644 --- a/test/TypeScript/src/federated/PingPongDistributed.lf +++ b/test/TypeScript/src/federated/PingPongDistributed.lf @@ -1,10 +1,10 @@ /** This checks communication between federates */ target TypeScript -reactor Ping(count: number(10)) { +reactor Ping(count: number = 10) { input receive: number output send: number - state pingsLeft: number(count) + state pingsLeft: number = count logical action serve reaction(startup, serve) -> send {= @@ -23,10 +23,10 @@ reactor Ping(count: number(10)) { =} } -reactor Pong(expected: number(10)) { +reactor Pong(expected: number = 10) { input receive: number output send: number - state count: number(0) + state count: number = 0 reaction(receive) -> send {= count += 1; @@ -45,7 +45,7 @@ reactor Pong(expected: number(10)) { =} } -federated reactor PingPongDistributed(count: number(10)) { +federated reactor PingPongDistributed(count: number = 10) { ping = new Ping(count = count) pong = new Pong(expected = count) ping.send -> pong.receive diff --git a/test/TypeScript/src/federated/PingPongDistributedPhysical.lf b/test/TypeScript/src/federated/PingPongDistributedPhysical.lf index 1f33964abc..58f55a4747 100644 --- a/test/TypeScript/src/federated/PingPongDistributedPhysical.lf +++ b/test/TypeScript/src/federated/PingPongDistributedPhysical.lf @@ -27,10 +27,10 @@ */ target TypeScript -reactor Ping(count: number(10)) { +reactor Ping(count: number = 10) { input receive: number output send: number - state pingsLeft: number(count) + state pingsLeft: number = count logical action serve reaction(startup, serve) -> send {= @@ -47,10 +47,10 @@ reactor Ping(count: number(10)) { =} } -reactor Pong(expected: number(10)) { +reactor Pong(expected: number = 10) { input receive: number output send: number - state count: number(0) + state count: number = 0 reaction(receive) -> send {= count++; @@ -69,7 +69,7 @@ reactor Pong(expected: number(10)) { =} } -federated reactor(count: number(10)) { +federated reactor(count: number = 10) { ping = new Ping(count = count) pong = new Pong(expected = count) ping.send ~> pong.receive diff --git a/test/TypeScript/src/federated/TopLevelArtifacts.lf b/test/TypeScript/src/federated/TopLevelArtifacts.lf index 89bdfd9a68..917da033f5 100644 --- a/test/TypeScript/src/federated/TopLevelArtifacts.lf +++ b/test/TypeScript/src/federated/TopLevelArtifacts.lf @@ -16,7 +16,7 @@ import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" federated reactor { - state successes: number(0) + state successes: number = 0 logical action act timer t(0, 1 sec) diff --git a/test/TypeScript/src/lib/Count.lf b/test/TypeScript/src/lib/Count.lf index b61aaa92e3..d848d8e9d4 100644 --- a/test/TypeScript/src/lib/Count.lf +++ b/test/TypeScript/src/lib/Count.lf @@ -1,9 +1,9 @@ target TypeScript -reactor Count(offset: time(0), period: time(1 sec)) { +reactor Count(offset: time = 0, period: time = 1 sec) { output out: number timer t(offset, period) - state count: number(1) + state count: number = 1 reaction(t) -> out {= out = count++; =} } diff --git a/test/TypeScript/src/lib/InternalDelay.lf b/test/TypeScript/src/lib/InternalDelay.lf index ace3c21c12..0f6f109322 100644 --- a/test/TypeScript/src/lib/InternalDelay.lf +++ b/test/TypeScript/src/lib/InternalDelay.lf @@ -1,7 +1,7 @@ /** @author Youri Su */ target TypeScript -reactor InternalDelay(delay: TimeValue(10 msec)) { +reactor InternalDelay(delay: TimeValue = 10 msec) { input inp: number output out: number logical action d: number diff --git a/test/TypeScript/src/lib/LoopedActionSender.lf b/test/TypeScript/src/lib/LoopedActionSender.lf index f72a427bf1..7da4c133b0 100644 --- a/test/TypeScript/src/lib/LoopedActionSender.lf +++ b/test/TypeScript/src/lib/LoopedActionSender.lf @@ -12,10 +12,10 @@ target TypeScript * @param breakInterval: Determines how long the reactor should take a break * after sending takeBreakAfter messages. */ -reactor Sender(takeBreakAfter: number(10), breakInterval: time(400 msec)) { +reactor Sender(takeBreakAfter: number = 10, breakInterval: time = 400 msec) { output out: number logical action act - state sentMessages: number(0) + state sentMessages: number = 0 reaction(startup, act) -> act, out {= // Send a message on out diff --git a/test/TypeScript/src/lib/TestCount.lf b/test/TypeScript/src/lib/TestCount.lf index 5a4b9067df..822b4c64b1 100644 --- a/test/TypeScript/src/lib/TestCount.lf +++ b/test/TypeScript/src/lib/TestCount.lf @@ -9,9 +9,13 @@ */ target TypeScript -reactor TestCount(start: number(1), stride: number(1), numInputs: number(1)) { - state count: number(start) - state inputsReceived: number(0) +reactor TestCount( + start: number = 1, + stride: number = 1, + numInputs: number = 1 +) { + state count: number = start + state inputsReceived: number = 0 input inp: number reaction(inp) {= diff --git a/test/TypeScript/src/multiport/BankMultiportToReaction.lf b/test/TypeScript/src/multiport/BankMultiportToReaction.lf index 0119785cd5..6516749418 100644 --- a/test/TypeScript/src/multiport/BankMultiportToReaction.lf +++ b/test/TypeScript/src/multiport/BankMultiportToReaction.lf @@ -12,8 +12,8 @@ reactor DoubleCount { } main reactor { - state count: number(1) - state received: boolean(false) + state count: number = 1 + state received: boolean = false s = new[2] DoubleCount() diff --git a/test/TypeScript/src/multiport/BankReactionsInContainer.lf b/test/TypeScript/src/multiport/BankReactionsInContainer.lf index 1628dce060..b14ca33f70 100644 --- a/test/TypeScript/src/multiport/BankReactionsInContainer.lf +++ b/test/TypeScript/src/multiport/BankReactionsInContainer.lf @@ -8,7 +8,7 @@ target TypeScript { reactor R { output[2] out: number input[2] inp: number - state received: boolean(false) + state received: boolean = false reaction(startup) -> out {= for (let i = 0; i < out.length; i++) { @@ -41,7 +41,7 @@ reactor R { main reactor { s = new[2] R() - state received: boolean(false) + state received: boolean = false reaction(startup) -> s.inp {= let count = 0; diff --git a/test/TypeScript/src/multiport/BankSelfBroadcast.lf b/test/TypeScript/src/multiport/BankSelfBroadcast.lf index dcd2aa8dfc..cf5af4bee3 100644 --- a/test/TypeScript/src/multiport/BankSelfBroadcast.lf +++ b/test/TypeScript/src/multiport/BankSelfBroadcast.lf @@ -12,7 +12,7 @@ target TypeScript reactor A { input[4] inp: number output out: number - state received: boolean(false) + state received: boolean = false reaction(startup) -> out {= out = this.getBankIndex(); =} diff --git a/test/TypeScript/src/multiport/BankToBank.lf b/test/TypeScript/src/multiport/BankToBank.lf index 0a4583c65a..5258616899 100644 --- a/test/TypeScript/src/multiport/BankToBank.lf +++ b/test/TypeScript/src/multiport/BankToBank.lf @@ -6,7 +6,7 @@ target TypeScript { reactor Source { timer t(0, 200 msec) output out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= out = s; @@ -15,7 +15,7 @@ reactor Source { } reactor Destination { - state s: number(0) + state s: number = 0 input inp: number reaction(inp) {= @@ -34,7 +34,7 @@ reactor Destination { =} } -main reactor BankToBank(width: number(4)) { +main reactor BankToBank(width: number = 4) { // FIXME: Should set the width to "width" rather than "4". a = new[4] Source() b = new[4] Destination() diff --git a/test/TypeScript/src/multiport/BankToBankMultiport.lf b/test/TypeScript/src/multiport/BankToBankMultiport.lf index ce82471f64..ef58c43ead 100644 --- a/test/TypeScript/src/multiport/BankToBankMultiport.lf +++ b/test/TypeScript/src/multiport/BankToBankMultiport.lf @@ -3,10 +3,10 @@ target TypeScript { timeout: 2 sec } -reactor Source(width: number(1)) { +reactor Source(width: number = 1) { timer t(0, 200 msec) output[width] out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= for(let i = 0; i < out.length; i++) { @@ -15,8 +15,8 @@ reactor Source(width: number(1)) { =} } -reactor Destination(width: number(1)) { - state s: number(6) +reactor Destination(width: number = 1) { + state s: number = 6 input[width] inp: number reaction(inp) {= @@ -40,7 +40,7 @@ reactor Destination(width: number(1)) { =} } -main reactor BankToBankMultiport(bankWidth: number(4)) { +main reactor BankToBankMultiport(bankWidth: number = 4) { a = new[bankWidth] Source(width = 4) b = new[bankWidth] Destination(width = 4) a.out -> b.inp diff --git a/test/TypeScript/src/multiport/BankToBankMultiportAfter.lf b/test/TypeScript/src/multiport/BankToBankMultiportAfter.lf index 8ad676de36..51c095119b 100644 --- a/test/TypeScript/src/multiport/BankToBankMultiportAfter.lf +++ b/test/TypeScript/src/multiport/BankToBankMultiportAfter.lf @@ -3,10 +3,10 @@ target TypeScript { timeout: 2 sec } -reactor Source(width: number(1)) { +reactor Source(width: number = 1) { timer t(0, 200 msec) output[width] out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= for(let i = 0; i < out.length; i++) { @@ -15,8 +15,8 @@ reactor Source(width: number(1)) { =} } -reactor Destination(width: number(1)) { - state s: number(6) +reactor Destination(width: number = 1) { + state s: number = 6 input[width] inp: number reaction(inp) {= @@ -40,7 +40,7 @@ reactor Destination(width: number(1)) { =} } -main reactor(bankWidth: number(4)) { +main reactor(bankWidth: number = 4) { a = new[bankWidth] Source(width = 4) b = new[bankWidth] Destination(width = 4) a.out -> b.inp after 200 msec diff --git a/test/TypeScript/src/multiport/BankToMultiport.lf b/test/TypeScript/src/multiport/BankToMultiport.lf index ecaacb52df..43dc7ee1bb 100644 --- a/test/TypeScript/src/multiport/BankToMultiport.lf +++ b/test/TypeScript/src/multiport/BankToMultiport.lf @@ -9,7 +9,7 @@ reactor Source { reactor Sink { input[4] inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= for (let i = 0; i < inp.length; i++) { diff --git a/test/TypeScript/src/multiport/BankToReaction.lf b/test/TypeScript/src/multiport/BankToReaction.lf index 89b189748d..df65c3063e 100644 --- a/test/TypeScript/src/multiport/BankToReaction.lf +++ b/test/TypeScript/src/multiport/BankToReaction.lf @@ -5,7 +5,7 @@ target TypeScript { import Count from "../lib/Count.lf" main reactor { - state count: number(1) + state count: number = 1 s = new[2] Count() diff --git a/test/TypeScript/src/multiport/BroadcastAfter.lf b/test/TypeScript/src/multiport/BroadcastAfter.lf index 3cf5eb3850..83cf34ddff 100644 --- a/test/TypeScript/src/multiport/BroadcastAfter.lf +++ b/test/TypeScript/src/multiport/BroadcastAfter.lf @@ -10,7 +10,7 @@ reactor Source { reactor Destination { input inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= console.log("Destination " + this.getBankIndex() + " received " + inp + "."); diff --git a/test/TypeScript/src/multiport/BroadcastMultipleAfter.lf b/test/TypeScript/src/multiport/BroadcastMultipleAfter.lf index 598ec737e6..755cf01107 100644 --- a/test/TypeScript/src/multiport/BroadcastMultipleAfter.lf +++ b/test/TypeScript/src/multiport/BroadcastMultipleAfter.lf @@ -2,7 +2,7 @@ target TypeScript { timeout: 2 sec } -reactor Source(value: number(42)) { +reactor Source(value: number = 42) { output out: number reaction(startup) -> out {= out = value; =} @@ -10,7 +10,7 @@ reactor Source(value: number(42)) { reactor Destination { input inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= console.log("Destination " + this.getBankIndex() + " received " + inp + "."); diff --git a/test/TypeScript/src/multiport/FullyConnected.lf b/test/TypeScript/src/multiport/FullyConnected.lf index cf84e92242..e40009ed90 100644 --- a/test/TypeScript/src/multiport/FullyConnected.lf +++ b/test/TypeScript/src/multiport/FullyConnected.lf @@ -1,10 +1,10 @@ target TypeScript -reactor Node(numNodes: number(4)) { +reactor Node(numNodes: number = 4) { input[numNodes] inp: number output out: number - state received: boolean(false) + state received: boolean = false reaction(startup) -> out {= console.log("Hello from node " + this.getBankIndex() + "!"); @@ -36,7 +36,7 @@ reactor Node(numNodes: number(4)) { =} } -main reactor(numNodes: number(4)) { +main reactor(numNodes: number = 4) { nodes = new[numNodes] Node(numNodes = numNodes) (nodes.out)+ -> nodes.inp } diff --git a/test/TypeScript/src/multiport/MultiportFromBank.lf b/test/TypeScript/src/multiport/MultiportFromBank.lf index 489a9df4a8..18896eed2a 100644 --- a/test/TypeScript/src/multiport/MultiportFromBank.lf +++ b/test/TypeScript/src/multiport/MultiportFromBank.lf @@ -10,9 +10,9 @@ reactor Source { reaction(startup) -> out {= out = this.getBankIndex(); =} } -reactor Destination(portWidth: number(3)) { +reactor Destination(portWidth: number = 3) { input[portWidth] inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= for (let i = 0; i < inp.length; i++) { @@ -32,7 +32,7 @@ reactor Destination(portWidth: number(3)) { =} } -main reactor(width: number(4)) { +main reactor(width: number = 4) { a = new[width] Source() b = new Destination(portWidth = width) a.out -> b.inp diff --git a/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf b/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf index e050682ab6..ffc394b26c 100644 --- a/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf @@ -6,7 +6,7 @@ target TypeScript { import Source, Destination from "MultiportFromBank.lf" -reactor Container(portWidth: number(3)) { +reactor Container(portWidth: number = 3) { output[portWidth] out: number s = new[portWidth] Source() s.out -> out diff --git a/test/TypeScript/src/multiport/MultiportFromHierarchy.lf b/test/TypeScript/src/multiport/MultiportFromHierarchy.lf index 5922d2f911..5627652b2f 100644 --- a/test/TypeScript/src/multiport/MultiportFromHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportFromHierarchy.lf @@ -4,10 +4,10 @@ target TypeScript { timeout: 2 sec } -reactor Source(width: number(3)) { +reactor Source(width: number = 3) { timer t(0, 200 msec) output[width] out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= for(let i = 0; i < out.length; i++) { @@ -16,8 +16,8 @@ reactor Source(width: number(3)) { =} } -reactor Destination(width: number(3)) { - state s: number(6) +reactor Destination(width: number = 3) { + state s: number = 6 input[width] inp: number reaction(inp) {= @@ -41,19 +41,19 @@ reactor Destination(width: number(3)) { =} } -reactor Container(width: number(3)) { +reactor Container(width: number = 3) { output[width] out: number src = new InsideContainer(width = width) src.out -> out } -reactor InsideContainer(width: number(3)) { +reactor InsideContainer(width: number = 3) { output[width] out: number src = new Source(width = width) src.out -> out } -main reactor MultiportFromHierarchy(width: number(4)) { +main reactor MultiportFromHierarchy(width: number = 4) { a = new Container(width = width) b = new Destination(width = width) a.out -> b.inp diff --git a/test/TypeScript/src/multiport/MultiportFromReaction.lf b/test/TypeScript/src/multiport/MultiportFromReaction.lf index 6670c2aa5a..ba386bd379 100644 --- a/test/TypeScript/src/multiport/MultiportFromReaction.lf +++ b/test/TypeScript/src/multiport/MultiportFromReaction.lf @@ -3,8 +3,8 @@ target TypeScript { timeout: 2 sec } -reactor Destination(width: number(1)) { - state s: number(6) +reactor Destination(width: number = 1) { + state s: number = 6 input[width] inp: number reaction(inp) {= @@ -28,9 +28,9 @@ reactor Destination(width: number(1)) { =} } -main reactor MultiportFromReaction(width: number(4)) { +main reactor MultiportFromReaction(width: number = 4) { timer t(0, 200 msec) - state s: number(0) + state s: number = 0 b = new Destination(width = width) reaction(t) -> b.inp {= diff --git a/test/TypeScript/src/multiport/MultiportIn.lf b/test/TypeScript/src/multiport/MultiportIn.lf index c409969657..97a36c08d2 100644 --- a/test/TypeScript/src/multiport/MultiportIn.lf +++ b/test/TypeScript/src/multiport/MultiportIn.lf @@ -7,7 +7,7 @@ target TypeScript { reactor Source { timer t(0, 200 msec) output out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= out = s++; =} } @@ -20,7 +20,7 @@ reactor Computation { } reactor Destination { - state s: number(0) + state s: number = 0 input[4] inp: number reaction(inp) {= diff --git a/test/TypeScript/src/multiport/MultiportInParameterized.lf b/test/TypeScript/src/multiport/MultiportInParameterized.lf index c189e56ef4..fb11c5e102 100644 --- a/test/TypeScript/src/multiport/MultiportInParameterized.lf +++ b/test/TypeScript/src/multiport/MultiportInParameterized.lf @@ -7,7 +7,7 @@ target TypeScript { reactor Source { timer t(0, 200 msec) output out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= out = s; @@ -22,8 +22,8 @@ reactor Computation { reaction(inp) -> out {= out = inp; =} } -reactor Destination(width: number(1)) { - state s: number(0) +reactor Destination(width: number = 1) { + state s: number = 0 input[width] inp: number reaction(inp) {= diff --git a/test/TypeScript/src/multiport/MultiportMutableInput.lf b/test/TypeScript/src/multiport/MultiportMutableInput.lf index f04131e411..11120e8d30 100644 --- a/test/TypeScript/src/multiport/MultiportMutableInput.lf +++ b/test/TypeScript/src/multiport/MultiportMutableInput.lf @@ -12,7 +12,7 @@ reactor Source { =} } -reactor Print(scale: number(1)) { // The scale parameter is just for testing. +reactor Print(scale: number = 1) { // The scale parameter is just for testing. input[2] inp: number reaction(inp) {= @@ -27,7 +27,7 @@ reactor Print(scale: number(1)) { // The scale parameter is just for testing. =} } -reactor Scale(scale: number(2)) { +reactor Scale(scale: number = 2) { mutable input[2] inp: number output[2] out: number diff --git a/test/TypeScript/src/multiport/MultiportMutableInputArray.lf b/test/TypeScript/src/multiport/MultiportMutableInputArray.lf index 26b5c3b87c..382f444df7 100644 --- a/test/TypeScript/src/multiport/MultiportMutableInputArray.lf +++ b/test/TypeScript/src/multiport/MultiportMutableInputArray.lf @@ -26,7 +26,7 @@ reactor Source { =} } -reactor Print(scale: number(1)) { // The scale parameter is just for testing. +reactor Print(scale: number = 1) { // The scale parameter is just for testing. input[2] inp: {= Array =} reaction(inp) {= @@ -55,7 +55,7 @@ reactor Print(scale: number(1)) { // The scale parameter is just for testing. =} } -reactor Scale(scale: number(2)) { +reactor Scale(scale: number = 2) { mutable input[2] inp: {= Array =} output[2] out: {= Array =} diff --git a/test/TypeScript/src/multiport/MultiportOut.lf b/test/TypeScript/src/multiport/MultiportOut.lf index 9fa72bf3e2..04588b86b5 100644 --- a/test/TypeScript/src/multiport/MultiportOut.lf +++ b/test/TypeScript/src/multiport/MultiportOut.lf @@ -6,7 +6,7 @@ target TypeScript { reactor Source { timer t(0, 200 msec) output[4] out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= for(let i = 0; i < 4; i++) { @@ -27,7 +27,7 @@ reactor Computation { } reactor Destination { - state s: number(0) + state s: number = 0 input[4] inp: number reaction(inp) {= diff --git a/test/TypeScript/src/multiport/MultiportToBankAfter.lf b/test/TypeScript/src/multiport/MultiportToBankAfter.lf index 357dc1d0e1..ee10df94c6 100644 --- a/test/TypeScript/src/multiport/MultiportToBankAfter.lf +++ b/test/TypeScript/src/multiport/MultiportToBankAfter.lf @@ -4,7 +4,7 @@ target TypeScript { timeout: 2 sec } -reactor Source(width: number(2)) { +reactor Source(width: number = 2) { output[width] out: number reaction(startup) -> out {= @@ -16,7 +16,7 @@ reactor Source(width: number(2)) { reactor Destination { input inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= console.log("Destination " + this.getBankIndex() + " received " + inp + "."); @@ -39,7 +39,7 @@ reactor Destination { =} } -main reactor(width: number(3)) { +main reactor(width: number = 3) { a = new Source(width = width) b = new[width] Destination() a.out -> b.inp after 1 sec // Width of the bank of delays will be inferred. diff --git a/test/TypeScript/src/multiport/MultiportToBankDouble.lf b/test/TypeScript/src/multiport/MultiportToBankDouble.lf index b429a846a4..e618dd898d 100644 --- a/test/TypeScript/src/multiport/MultiportToBankDouble.lf +++ b/test/TypeScript/src/multiport/MultiportToBankDouble.lf @@ -25,7 +25,7 @@ reactor Source { reactor Destination { input inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= console.log("Destination " + this.getBankIndex() + " received " + inp + "."); diff --git a/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf b/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf index 3e5c499d06..7420704ce1 100644 --- a/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf @@ -16,7 +16,7 @@ reactor Source { reactor Destination { input inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= console.log("Destination " + this.getBankIndex() + " received " + inp + "."); diff --git a/test/TypeScript/src/multiport/MultiportToHierarchy.lf b/test/TypeScript/src/multiport/MultiportToHierarchy.lf index 4673ff1e22..c620000872 100644 --- a/test/TypeScript/src/multiport/MultiportToHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportToHierarchy.lf @@ -5,10 +5,10 @@ target TypeScript { timeout: 2 sec } -reactor Source(width: number(4)) { +reactor Source(width: number = 4) { timer t(0, 200 msec) output[width] out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= for(let i = 0; i < 4; i++) { @@ -17,8 +17,8 @@ reactor Source(width: number(4)) { =} } -reactor Destination(width: number(4)) { - state s: number(6) +reactor Destination(width: number = 4) { + state s: number = 6 input[width] inp: number reaction(inp) {= @@ -42,13 +42,13 @@ reactor Destination(width: number(4)) { =} } -reactor Container(width: number(4)) { +reactor Container(width: number = 4) { input[width] inp: number dst = new Destination() inp -> dst.inp } -main reactor MultiportToHierarchy(width: number(4)) { +main reactor MultiportToHierarchy(width: number = 4) { a = new Source(width = width) b = new Container(width = width) a.out -> b.inp diff --git a/test/TypeScript/src/multiport/MultiportToMultiport.lf b/test/TypeScript/src/multiport/MultiportToMultiport.lf index 54bac4fbfb..ecd774e7b6 100644 --- a/test/TypeScript/src/multiport/MultiportToMultiport.lf +++ b/test/TypeScript/src/multiport/MultiportToMultiport.lf @@ -12,7 +12,7 @@ reactor Source { reactor Sink { input[4] inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= for (let i = 0; i < inp.length; i++) { diff --git a/test/TypeScript/src/multiport/MultiportToMultiport2.lf b/test/TypeScript/src/multiport/MultiportToMultiport2.lf index 73b3cfedc5..9e9856af63 100644 --- a/test/TypeScript/src/multiport/MultiportToMultiport2.lf +++ b/test/TypeScript/src/multiport/MultiportToMultiport2.lf @@ -1,7 +1,7 @@ // Test multiport to multiport connections. See also MultiportToMultiport. target TypeScript -reactor Source(width: number(2)) { +reactor Source(width: number = 2) { output[width] out: number reaction(startup) -> out {= @@ -11,7 +11,7 @@ reactor Source(width: number(2)) { =} } -reactor Destination(width: number(2)) { +reactor Destination(width: number = 2) { input[width] inp: number reaction(inp) {= diff --git a/test/TypeScript/src/multiport/MultiportToMultiport2After.lf b/test/TypeScript/src/multiport/MultiportToMultiport2After.lf index 1bca78675c..04890686ab 100644 --- a/test/TypeScript/src/multiport/MultiportToMultiport2After.lf +++ b/test/TypeScript/src/multiport/MultiportToMultiport2After.lf @@ -1,7 +1,7 @@ // Test multiport to multiport connections. See also MultiportToMultiport. target TypeScript -reactor Source(width: number(2)) { +reactor Source(width: number = 2) { output[width] out: number reaction(startup) -> out {= @@ -11,7 +11,7 @@ reactor Source(width: number(2)) { =} } -reactor Destination(width: number(2)) { +reactor Destination(width: number = 2) { input[width] inp: number reaction(inp) {= diff --git a/test/TypeScript/src/multiport/MultiportToMultiportArray.lf b/test/TypeScript/src/multiport/MultiportToMultiportArray.lf index 8e08494cad..737603a5bd 100644 --- a/test/TypeScript/src/multiport/MultiportToMultiportArray.lf +++ b/test/TypeScript/src/multiport/MultiportToMultiportArray.lf @@ -7,7 +7,7 @@ target TypeScript { reactor Source { timer t(0, 200 msec) output[2] out: {= Array =} - state s: number(0) + state s: number = 0 reaction(t) -> out {= for(let i = 0; i < 2; i++) { @@ -24,7 +24,7 @@ reactor Source { } reactor Destination { - state s: number(15) + state s: number = 15 input[2] inp: {= Array =} reaction(inp) {= diff --git a/test/TypeScript/src/multiport/MultiportToMultiportParameter.lf b/test/TypeScript/src/multiport/MultiportToMultiportParameter.lf index d1be5397dd..5252783498 100644 --- a/test/TypeScript/src/multiport/MultiportToMultiportParameter.lf +++ b/test/TypeScript/src/multiport/MultiportToMultiportParameter.lf @@ -3,10 +3,10 @@ target TypeScript { timeout: 2 sec } -reactor Source(width: number(1)) { +reactor Source(width: number = 1) { timer t(0, 200 msec) output[width] out: number - state s: number(0) + state s: number = 0 reaction(t) -> out {= for (let i = 0; i < out.length; i++) { @@ -15,8 +15,8 @@ reactor Source(width: number(1)) { =} } -reactor Destination(width: number(1)) { - state s: number(6) +reactor Destination(width: number = 1) { + state s: number = 6 input[width] inp: number // Width is one larger than that of the source. reaction(inp) {= @@ -39,7 +39,7 @@ reactor Destination(width: number(1)) { =} } -main reactor(width: number(4)) { +main reactor(width: number = 4) { a = new Source(width = width) b = new Destination(width = width) a.out -> b.inp diff --git a/test/TypeScript/src/multiport/MultiportToPort.lf b/test/TypeScript/src/multiport/MultiportToPort.lf index a366089fd9..a00d482fe8 100644 --- a/test/TypeScript/src/multiport/MultiportToPort.lf +++ b/test/TypeScript/src/multiport/MultiportToPort.lf @@ -15,9 +15,9 @@ reactor Source { =} } -reactor Destination(expected: number(0)) { +reactor Destination(expected: number = 0) { input inp: number - state received: boolean(false) + state received: boolean = false reaction(inp) {= console.log("Received " + inp); diff --git a/test/TypeScript/src/multiport/MultiportToReaction.lf b/test/TypeScript/src/multiport/MultiportToReaction.lf index 84d33b642f..e7b5af4c00 100644 --- a/test/TypeScript/src/multiport/MultiportToReaction.lf +++ b/test/TypeScript/src/multiport/MultiportToReaction.lf @@ -3,9 +3,9 @@ target TypeScript { timeout: 2 sec } -reactor Source(width: number(1)) { +reactor Source(width: number = 1) { timer t(0, 200 msec) - state s: number(0) + state s: number = 0 output[width] out: number reaction(t) -> out {= @@ -17,7 +17,7 @@ reactor Source(width: number(1)) { } main reactor MultiportToReaction { - state s: number(6) + state s: number = 6 b = new Source(width = 4) reaction(b.out) {= diff --git a/test/TypeScript/src/multiport/NestedBanks.lf b/test/TypeScript/src/multiport/NestedBanks.lf index fea594d1ea..a5c31d38d9 100644 --- a/test/TypeScript/src/multiport/NestedBanks.lf +++ b/test/TypeScript/src/multiport/NestedBanks.lf @@ -20,7 +20,7 @@ reactor A { b.y -> x } -reactor B(aBankIndex: number(0)) { +reactor B(aBankIndex: number = 0) { output[2] y: number reaction(startup) -> y {= @@ -60,7 +60,7 @@ reactor E { =} } -reactor F(cBankIndex: number(0)) { +reactor F(cBankIndex: number = 0) { input w: number reaction(w) {= @@ -71,7 +71,7 @@ reactor F(cBankIndex: number(0)) { =} } -reactor G(cBankIndex: number(0)) { +reactor G(cBankIndex: number = 0) { input s: number reaction(s) {= diff --git a/test/TypeScript/src/multiport/ReactionToContainedBank.lf b/test/TypeScript/src/multiport/ReactionToContainedBank.lf index 9f54a0123b..9b058671cc 100644 --- a/test/TypeScript/src/multiport/ReactionToContainedBank.lf +++ b/test/TypeScript/src/multiport/ReactionToContainedBank.lf @@ -5,9 +5,9 @@ target TypeScript { import TestCount from "../lib/TestCount.lf" -main reactor ReactionToContainedBank(width: number(2)) { +main reactor ReactionToContainedBank(width: number = 2) { timer t(0, 100 msec) - state count: number(1) + state count: number = 1 test = new[width] TestCount(numInputs = 11) diff --git a/test/TypeScript/src/multiport/ReactionsToNested.lf b/test/TypeScript/src/multiport/ReactionsToNested.lf index dbc20ef8ed..055e08d086 100644 --- a/test/TypeScript/src/multiport/ReactionsToNested.lf +++ b/test/TypeScript/src/multiport/ReactionsToNested.lf @@ -4,9 +4,9 @@ target TypeScript { timeout: 1 sec } -reactor T(expected: number(0)) { +reactor T(expected: number = 0) { input z: number - state received: boolean(false) + state received: boolean = false reaction(z) {= console.log("T received " + z); diff --git a/test/TypeScript/src/target/AfterNoTypes.lf b/test/TypeScript/src/target/AfterNoTypes.lf index 2293faf601..b3477bbf55 100644 --- a/test/TypeScript/src/target/AfterNoTypes.lf +++ b/test/TypeScript/src/target/AfterNoTypes.lf @@ -15,7 +15,7 @@ reactor Foo { } reactor Print { - state expected_time: time(10 msec) + state expected_time: time = 10 msec input x reaction(x) {= From 6c227293396b24cc6075716e3ace57cdd92036c1 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 30 Mar 2023 22:23:57 -0700 Subject: [PATCH 095/709] fixed generator issue --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 70f76c282e..255941e8cd 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1527,7 +1527,7 @@ private void recordWatchdogs(ReactorInstance instance) { // temp.pr("#ifdef LF_THREADED"); for (WatchdogInstance watchdog : instance.watchdogs) { temp.pr(" _lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); - temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+GeneratorBase.timeInTargetLanguage(watchdog.getTimeout())+";"); + temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+watchdog.getTimeout()+";"); temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); watchdogCount += 1; foundOne = true; From 7208c8f2b4bf5056eeddefbf92359125a5f9a65c Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Fri, 31 Mar 2023 15:51:16 +0500 Subject: [PATCH 096/709] [C-Generics] Moved type-converter macro to utils Signed-off-by: mkhubaibumer --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java | 3 ++- org.lflang/src/org/lflang/generator/c/CGenerator.java | 1 + .../org/lflang/generator/c/CReactorHeaderFileGenerator.java | 3 ++- 4 files changed, 6 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index f9dd92f15b..c1ba14d32a 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit f9dd92f15b89ee57545b983bed45362a53a3375b +Subproject commit c1ba14d32a1288356609d59e9631286da52c9fee diff --git a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java index 6022110943..c2ef81bf1d 100644 --- a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java +++ b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java @@ -19,7 +19,8 @@ public static List getCTargetSrc() { public static List getCTargetHeader() { return List.of( "include/api/api.h", - "include/api/generics.h" + "include/api/generics.h", + "include/utils/type_converter.h" ); } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index bb0944d389..6cb187710a 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1054,6 +1054,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String src.pr("#include \"include/api/api.h\""); src.pr("#include \"include/api/set.h\""); src.pr("#include \"include/api/generics.h\""); + src.pr("#include \"include/utils/type_converter.h\""); generateIncludes(tpr); if (CCppMode) { src.pr("}"); diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 9c820cd87c..6bdb08f5a9 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -65,7 +65,8 @@ private static void appendPoundIncludes(CodeBuilder builder) { #include "../include/api/api.h" #include "../include/api/set.h" #include "../include/api/generics.h" - #include "../include/core/reactor.h" + #include "../include/utils/type_converter.h" + #include "../include/core/reactor.h" #ifdef __cplusplus } #endif From 6477a99bd19260d7f58d4a3e4f88608095e0b063 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Fri, 31 Mar 2023 15:51:16 +0500 Subject: [PATCH 097/709] [C-Generics] Moved type-converter macro to utils Signed-off-by: mkhubaibumer --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java | 3 ++- org.lflang/src/org/lflang/generator/c/CGenerator.java | 1 + .../org/lflang/generator/c/CReactorHeaderFileGenerator.java | 3 ++- 4 files changed, 6 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index f9dd92f15b..c1ba14d32a 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit f9dd92f15b89ee57545b983bed45362a53a3375b +Subproject commit c1ba14d32a1288356609d59e9631286da52c9fee diff --git a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java index 6022110943..c2ef81bf1d 100644 --- a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java +++ b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java @@ -19,7 +19,8 @@ public static List getCTargetSrc() { public static List getCTargetHeader() { return List.of( "include/api/api.h", - "include/api/generics.h" + "include/api/generics.h", + "include/utils/type_converter.h" ); } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index bb0944d389..6cb187710a 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1054,6 +1054,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String src.pr("#include \"include/api/api.h\""); src.pr("#include \"include/api/set.h\""); src.pr("#include \"include/api/generics.h\""); + src.pr("#include \"include/utils/type_converter.h\""); generateIncludes(tpr); if (CCppMode) { src.pr("}"); diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 9c820cd87c..6bdb08f5a9 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -65,7 +65,8 @@ private static void appendPoundIncludes(CodeBuilder builder) { #include "../include/api/api.h" #include "../include/api/set.h" #include "../include/api/generics.h" - #include "../include/core/reactor.h" + #include "../include/utils/type_converter.h" + #include "../include/core/reactor.h" #ifdef __cplusplus } #endif From 38e0758838320c8bc76dd52de169c96eb99778f8 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Fri, 31 Mar 2023 16:14:48 +0500 Subject: [PATCH 098/709] Update submodule ref --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index c1ba14d32a..866b189a4f 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit c1ba14d32a1288356609d59e9631286da52c9fee +Subproject commit 866b189a4f04d3fae7a50a256b8ca3686ea1c509 From a7afcee0193ce9b2252f90cae05a56407442fc0c Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 31 Mar 2023 15:25:52 +0200 Subject: [PATCH 099/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index fe5e6c2d1c..6bdf8c9f05 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit fe5e6c2d1cbc38b46b7298facb5f77e5ba6f387c +Subproject commit 6bdf8c9f054e463359f46170eb073928aea33ff9 From 9626826ce83b06b5f3573e03b990372c57a23ceb Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 31 Mar 2023 15:27:17 +0200 Subject: [PATCH 100/709] add tests with cycles --- test/Cpp/src/enclave/EnclaveCycle.lf | 67 ++++++++++++++++ test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf | 70 +++++++++++++++++ .../EnclaveUpstreamPhysicalActionDelayed.lf | 77 +++++++++++++++++++ 3 files changed, 214 insertions(+) create mode 100644 test/Cpp/src/enclave/EnclaveCycle.lf create mode 100644 test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf create mode 100644 test/Cpp/src/enclave/EnclaveUpstreamPhysicalActionDelayed.lf diff --git a/test/Cpp/src/enclave/EnclaveCycle.lf b/test/Cpp/src/enclave/EnclaveCycle.lf new file mode 100644 index 0000000000..d073c801c8 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCycle.lf @@ -0,0 +1,67 @@ +target Cpp { + timeout: 1 s, + workers: 1 +} + +reactor Ping { + timer t(0, 100 ms) + input in: int + output out: int + state counter: int = 0 + state received: bool = false + + reaction(t) -> out {= out.set(counter++); =} + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Ping Received " << value; + auto expected = 50ms + 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +reactor Pong { + input in: int + output out: int + state received: bool = false + + reaction(in) -> out {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Pong Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + out.set(value); + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +main reactor { + @enclave + ping = new Ping() + @enclave + pong = new Pong() + + ping.out -> pong.in + pong.out -> ping.in after 50 ms +} diff --git a/test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf b/test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf new file mode 100644 index 0000000000..f347aa53a4 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf @@ -0,0 +1,70 @@ +target Cpp { + timeout: 1 s, + workers: 1 +} + +reactor Ping { + timer t(0, 100 ms) + input in: int + output out: int + state counter: int = 0 + state received: bool = false + + reaction(t) -> out {= out.set(counter++); =} + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Ping Received " << value; + auto expected = 50ms + 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +reactor Pong { + timer t(0, 100 ms) + input in: int + output out: int + state counter: int = 0 + state received: bool = false + + reaction(t) -> out {= out.set(counter++); =} + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Pong Received " << value; + auto expected = 50ms + 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +main reactor { + @enclave + ping = new Ping() + @enclave + pong = new Pong() + + ping.out -> pong.in after 50 ms + pong.out -> ping.in after 50 ms +} diff --git a/test/Cpp/src/enclave/EnclaveUpstreamPhysicalActionDelayed.lf b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalActionDelayed.lf new file mode 100644 index 0000000000..f87895f960 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalActionDelayed.lf @@ -0,0 +1,77 @@ +// The purpose of this test is to check that the downstream enclave can +// progress, even if there are only sparse upstream events. +target Cpp { + timeout: 10 s, + workers: 1 +} + +reactor Src { + public preamble {= + #include + =} + + state thread: std::thread{} + + physical action a: int + output out: int + + reaction(startup) -> a {= + // start new thread + this->thread = std::thread([&] () { + for (int i{0}; i < 3; i++) { + a.schedule(i); + std::this_thread::sleep_for(2s); + } + }); + =} + + reaction(a) -> out {= out.set(a.get()); =} + + reaction(shutdown) {= + // make sure to join the thread before shutting down + if(thread.joinable()) { + thread.join(); + } + =} +} + +reactor Sink { + timer t(0, 100 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 2s * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= + reactor::log::Info() << "Tick - " << "logical time: " << get_elapsed_logical_time() + << "; physical time: " << get_elapsed_physical_time(); + =} deadline(1 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} +} + +main reactor { + @enclave + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in after 2 s +} From b59b3b7474caf09d189255fdf41990a7cd5615fb Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 31 Mar 2023 13:44:05 -0700 Subject: [PATCH 101/709] Temporarily remove the generics headers. --- org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java | 4 +--- org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 -- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java index c2ef81bf1d..46503d87cc 100644 --- a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java +++ b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java @@ -18,9 +18,7 @@ public static List getCTargetSrc() { public static List getCTargetHeader() { return List.of( - "include/api/api.h", - "include/api/generics.h", - "include/utils/type_converter.h" + "include/api/api.h" ); } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index acaef65b99..2d3c6e79e7 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1062,8 +1062,6 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String header.pr("#include \"include/core/reactor.h\""); src.pr("#include \"include/api/api.h\""); src.pr("#include \"include/api/set.h\""); - src.pr("#include \"include/api/generics.h\""); - src.pr("#include \"include/utils/type_converter.h\""); generateIncludes(tpr); if (CCppMode) { src.pr("}"); From a55a886c5dd69d4025f37f7e3d5873d38d3d1097 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 31 Mar 2023 15:12:29 -0700 Subject: [PATCH 102/709] Update submodule. --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index ac3d19a58a..ac05b8ebc8 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit ac3d19a58ad86dd57c14b2505289f64b8c651d79 +Subproject commit ac05b8ebc8aec4d5596ade92e39429846af51d45 From a4740c35ede3e45fcf1887cf04828ec60b3a3403 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 3 Apr 2023 11:47:53 -0700 Subject: [PATCH 103/709] saving before continuing changes --- org.lflang/src/org/lflang/ASTUtils.java | 7 +++++ .../org/lflang/generator/c/CGenerator.java | 2 +- .../generator/c/CWatchdogGenerator.java | 26 ++++++++++++++++--- test/C/src/Watchdog.lf | 1 + 4 files changed, 32 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 4423363fec..f9767e7e9a 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -586,6 +586,13 @@ public static Iterable allElementsOfClass( //////////////////////////////// //// Utility functions for translating AST nodes into text + // public static Code toCode(String text) { + // Code code = null; + // if (text == null) return code; + // code.setBody(text); + // return code; + // } + /** * Translate the given code into its textual representation * with {@code CodeMap.Correspondence} tags inserted, or diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 1d588aa260..33bcab4b70 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1525,7 +1525,7 @@ private void recordWatchdogs(ReactorInstance instance) { // temp.pr("#ifdef LF_THREADED"); for (WatchdogInstance watchdog : instance.watchdogs) { temp.pr(" _lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); - temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+watchdog.getTimeout()+";"); + temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+CTypes.getInstance().getTargetTimeExpr(watchdog.getTimeout())+";"); temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); watchdogCount += 1; foundOne = true; diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 4193a7c522..0c1ce1f762 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -106,12 +106,32 @@ public static String generateWatchdogFunctionHeader(Watchdog watchdog, * Generate the watchdog function. */ public static String generateWatchdogFunction(Watchdog watchdog, - ReactorDecl decl) { - return CReactionGenerator.generateFunction(generateWatchdogFunctionHeader(watchdog, decl), + ReactorDecl decl) { + return generateFunction(generateWatchdogFunctionHeader(watchdog, decl), generateInitializationForWatchdog(watchdog, decl), - watchdog.getCode()); + watchdog); } + /** + * Do heavy lifting to generate above watchdog function + * @param header function name and declaration. + * @param init initialize variable. + * @param watchdog The watchdog. + */ + public static String generateFunction(String header, String init, Watchdog watchdog) { + var function = new CodeBuilder(); + function.pr(header + " {"); + function.indent(); + function.pr(init); + function.prSourceLineNumber(watchdog.getCode()); + function.pr(ASTUtils.toText(watchdog.getCode())); + function.pr("lf_set("+watchdog.getName()+", 1);"); + function.unindent(); + function.pr("}"); + return function.toString(); + } + + /** * Generate watchdog definition in parent struct. */ diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index b44a16f22c..df88d23d73 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -34,6 +34,7 @@ reactor Watcher(timeout:time(150ms)) { =} reaction(poodle) -> d {= + lf_print("Reaction poodle was called."); lf_set(d, 1); =} From 1af9922b0668c2f32891898b595031e797e9f93f Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 3 Apr 2023 12:38:06 -0700 Subject: [PATCH 104/709] added watchdog to body of itself, started making changes to treat watchdog trigger --- .../src/org/lflang/generator/c/CWatchdogGenerator.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 0c1ce1f762..3c9568699c 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -75,6 +75,8 @@ public static String generateInitializationForWatchdog(Watchdog watchdog, } } } + // Add watchdog definition + watchdogInitialization.pr("watchdog_t* "+watchdog.getName()+" = &(self->_lf_watchdog_"+watchdog.getName()+");\n"); // Next generate all the collected setup code. code.pr(watchdogInitialization.toString()); @@ -125,7 +127,8 @@ public static String generateFunction(String header, String init, Watchdog watch function.pr(init); function.prSourceLineNumber(watchdog.getCode()); function.pr(ASTUtils.toText(watchdog.getCode())); - function.pr("lf_set("+watchdog.getName()+", 1);"); + //FIXME: will need to lf_schedule instead + // function.pr("lf_set("+watchdog.getName()+", 1);"); function.unindent(); function.pr("}"); return function.toString(); From 25aace4fe165a7f59967c56420db4fa71ecc1ba6 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Tue, 4 Apr 2023 21:09:09 +0500 Subject: [PATCH 105/709] [C-Generics] Updates for resolving Actions/StateVariables typenames to concrete types Updates to remove COrresponding tags for declerations Signed-off-by: mkhubaibumer --- .../org/lflang/generator/c/CGenerator.java | 34 +++++++++++-------- .../generator/c/CParameterGenerator.java | 8 ++--- .../lflang/generator/c/CPortGenerator.java | 6 ++-- .../generator/c/CReactionGenerator.java | 16 ++++----- .../lflang/generator/c/CStateGenerator.java | 6 ++-- .../src/org/lflang/generator/c/CUtil.java | 18 ++++++++++ .../c/InteractingContainedReactors.java | 1 + .../generator/c/TypeParameterizedReactor.java | 2 +- 8 files changed, 55 insertions(+), 36 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 6cb187710a..611edf7c62 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1048,8 +1048,6 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String src.pr("extern \"C\" {"); header.pr("extern \"C\" {"); } - tpr.typeArgs().forEach((literal, concreteType) -> header.pr( - "#define " + literal + " " + ASTUtils.toText(concreteType))); header.pr("#include \"include/core/reactor.h\""); src.pr("#include \"include/api/api.h\""); src.pr("#include \"include/api/set.h\""); @@ -1062,11 +1060,19 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String } src.pr("#include \"" + headerName + "\""); tpr.typeArgs().forEach((literal, concreteType) -> src.pr( - "#define " + literal + " " + ASTUtils.toText(concreteType))); + "#if defined " + literal + "\n" + + "#undef " + literal + "\n" + + "#endif // " + literal + "\n" + + "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); new HashSet<>(ASTUtils.allInstantiations(tpr.r())).stream() .map(TypeParameterizedReactor::new).map(CUtil::getName) .map(name -> "#include \"" + name + ".h\"") .forEach(header::pr); + tpr.typeArgs().forEach((literal, concreteType) -> header.pr( + "#if defined " + literal + "\n" + + "#undef " + literal + "\n" + + "#endif // " + literal + "\n" + + "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); } private void generateReactorClassBody(TypeParameterizedReactor tpr, CodeBuilder header, CodeBuilder src) { @@ -1186,10 +1192,10 @@ private void generateSelfStruct(CodeBuilder builder, TypeParameterizedReactor tp generateSelfStructExtension(body, reactor, constructorCode); // Next handle parameters. - body.pr(CParameterGenerator.generateDeclarations(reactor, types)); + body.pr(CParameterGenerator.generateDeclarations(tpr, types)); // Next handle states. - body.pr(CStateGenerator.generateDeclarations(reactor, types)); + body.pr(CStateGenerator.generateDeclarations(tpr, types)); // Next handle actions. CActionGenerator.generateDeclarations(tpr, body, constructorCode); @@ -1204,13 +1210,12 @@ private void generateSelfStruct(CodeBuilder builder, TypeParameterizedReactor tp // struct has a place to hold the data produced by this reactor's // reactions and a place to put pointers to data produced by // the contained reactors. - generateInteractingContainedReactors(tpr, reactor, body, constructorCode); + generateInteractingContainedReactors(tpr, body, constructorCode); // Next, generate the fields needed for each reaction. CReactionGenerator.generateReactionAndTriggerStructs( body, tpr, - reactor, constructorCode, types ); @@ -1241,20 +1246,18 @@ private void generateSelfStruct(CodeBuilder builder, TypeParameterizedReactor tp * reactions and a place to put pointers to data produced by * the contained reactors. * - * @param tpr The TypeParameterized Reactor - * @param reactor The reactor. + * @param tpr {@link TypeParameterizedReactor} * @param body The place to put the struct definition for the contained reactors. * @param constructorCode The place to put matching code that goes in the container's constructor. */ private void generateInteractingContainedReactors( TypeParameterizedReactor tpr, - Reactor reactor, CodeBuilder body, CodeBuilder constructorCode ) { // The contents of the struct will be collected first so that // we avoid duplicate entries and then the struct will be constructed. - var contained = new InteractingContainedReactors(reactor); + var contained = new InteractingContainedReactors(tpr.r()); // Next generate the relevant code. for (Instantiation containedReactor : contained.containedReactors()) { Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); @@ -1285,12 +1288,12 @@ private void generateInteractingContainedReactors( // to be malloc'd at initialization. if (!ASTUtils.isMultiport(port)) { // Not a multiport. - body.pr(port, variableStructType(port, tpr, false)+" "+port.getName()+";"); + body.pr(port, variableStructType(port, containedReactorType, false)+" "+port.getName()+";"); } else { // Is a multiport. // Memory will be malloc'd in initialization. body.pr(port, String.join("\n", - variableStructType(port, tpr, false)+"** "+port.getName()+";", + variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", "int "+port.getName()+"_width;" )); } @@ -1300,13 +1303,13 @@ private void generateInteractingContainedReactors( // self struct of the container. if (!ASTUtils.isMultiport(port)) { // Not a multiport. - body.pr(port, variableStructType(port, tpr, false)+"* "+port.getName()+";"); + body.pr(port, variableStructType(port, containedReactorType, false)+"* "+port.getName()+";"); } else { // Is a multiport. // Here, we will use an array of pointers. // Memory will be malloc'd in initialization. body.pr(port, String.join("\n", - variableStructType(port, tpr, false)+"** "+port.getName()+";", + variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", "int "+port.getName()+"_width;" )); } @@ -1769,6 +1772,7 @@ private void generateInitializeActionToken(ReactorInstance reactor) { if (CUtil.isTokenType(type, types)) { typeStr = CUtil.rootType(typeStr); } + typeStr = CUtil.getConcreteType(reactor.tpr, typeStr); if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { payloadSize = "sizeof("+typeStr+")"; } diff --git a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java index 23906eae73..70038648e9 100644 --- a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java @@ -76,14 +76,14 @@ public static String getInitializer(ParameterInstance p) { /** * Generate code for parameters variables of a reactor in the form "parameter.type parameter.name;" - * @param reactor The reactor + * @param reactor {@link TypeParameterizedReactor} * @param types A helper class for types */ - public static String generateDeclarations(Reactor reactor, CTypes types) { + public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { CodeBuilder code = new CodeBuilder(); - for (Parameter parameter : ASTUtils.allParameters(reactor)) { + for (Parameter parameter : ASTUtils.allParameters(reactor.r())) { code.prSourceLineNumber(parameter); - code.pr(types.getTargetType(parameter) + " " + parameter.getName() + ";"); + code.pr(CUtil.getConcreteType(reactor, types.getTargetType(parameter)) + " " + parameter.getName() + ";"); } return code.toString(); } diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index accda01fb1..5e6320dbfb 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -33,8 +33,8 @@ public static void generateDeclarations( CodeBuilder body, CodeBuilder constructorCode ) { - generateInputDeclarations(tpr, decl, body, constructorCode); - generateOutputDeclarations(tpr, decl, body, constructorCode); + generateInputDeclarations(tpr, body, constructorCode); + generateOutputDeclarations(tpr, body, constructorCode); } /** @@ -198,7 +198,6 @@ private static String valueDeclaration( */ private static void generateInputDeclarations( TypeParameterizedReactor tpr, - ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode ) { @@ -237,7 +236,6 @@ private static void generateInputDeclarations( */ private static void generateOutputDeclarations( TypeParameterizedReactor tpr, - ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode ) { diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 3630df136f..a336752280 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -56,8 +56,6 @@ public static String generateInitializationForReaction(String body, ErrorReporter errorReporter, Instantiation mainDef, boolean requiresTypes) { - Reactor reactor = tpr.r(); - // Construct the reactionInitialization code to go into // the body of the function before the verbatim code. CodeBuilder reactionInitialization = new CodeBuilder(); @@ -129,7 +127,7 @@ public static String generateInitializationForReaction(String body, // No triggers are given, which means react to any input. // Declare an argument for every input. // NOTE: this does not include contained outputs. - for (Input input : reactor.getInputs()) { + for (Input input : tpr.r().getInputs()) { reactionInitialization.pr(generateInputVariablesInReaction(input, tpr, types)); } } @@ -164,7 +162,7 @@ public static String generateInitializationForReaction(String body, } } else if (effect.getVariable() instanceof Mode) { // Mode change effect - int idx = ASTUtils.allModes(reactor).indexOf((Mode)effect.getVariable()); + int idx = ASTUtils.allModes(tpr.r()).indexOf((Mode)effect.getVariable()); String name = effect.getVariable().getName(); if (idx >= 0) { reactionInitialization.pr( @@ -350,6 +348,7 @@ private static void generateVariablesForSendingToContainedReactors( Instantiation definition, Input input ) { + // TODO: Get reactorInstance or TPR from Instantiation CodeBuilder structBuilder = structs.get(definition); if (structBuilder == null) { structBuilder = new CodeBuilder(); @@ -672,7 +671,6 @@ public static String generateOutputVariablesInReaction( public static void generateReactionAndTriggerStructs( CodeBuilder body, TypeParameterizedReactor tpr, - Reactor reactor, CodeBuilder constructorCode, CTypes types ) { @@ -760,7 +758,7 @@ public static void generateReactionAndTriggerStructs( "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", reaction.eContainer() instanceof Mode ? - "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+reactor.getModes().indexOf((Mode) reaction.eContainer())+"];" : + "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+tpr.r().getModes().indexOf((Mode) reaction.eContainer())+"];" : "self->_lf__reaction_"+reactionCount+".mode = NULL;" )); // Increment the reactionCount even if the reaction is not in the federate @@ -770,7 +768,7 @@ public static void generateReactionAndTriggerStructs( // Next, create and initialize the trigger_t objects. // Start with the timers. - for (Timer timer : ASTUtils.allTimers(reactor)) { + for (Timer timer : ASTUtils.allTimers(tpr.r())) { createTriggerT(body, timer, triggerMap, constructorCode, types); // Since the self struct is allocated using calloc, there is no need to set falsy fields. constructorCode.pr("self->_lf__"+timer.getName()+".is_timer = true;"); @@ -791,7 +789,7 @@ public static void generateReactionAndTriggerStructs( } // Next handle actions. - for (Action action : ASTUtils.allActions(reactor)) { + for (Action action : ASTUtils.allActions(tpr.r())) { createTriggerT(body, action, triggerMap, constructorCode, types); var isPhysical = "true"; if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { @@ -821,7 +819,7 @@ public static void generateReactionAndTriggerStructs( } // Next handle inputs. - for (Input input : ASTUtils.allInputs(reactor)) { + for (Input input : ASTUtils.allInputs(tpr.r())) { createTriggerT(body, input, triggerMap, constructorCode, types); } } diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java index a0bcf28823..029648844d 100644 --- a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java @@ -18,11 +18,11 @@ public class CStateGenerator { * @param reactor The reactor * @param types A helper object for types */ - public static String generateDeclarations(Reactor reactor, CTypes types) { + public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { CodeBuilder code = new CodeBuilder(); - for (StateVar stateVar : ASTUtils.allStateVars(reactor)) { + for (StateVar stateVar : ASTUtils.allStateVars(reactor.r())) { code.prSourceLineNumber(stateVar); - code.pr(types.getTargetType(stateVar) + " " + stateVar.getName() + ";"); + code.pr(CUtil.getConcreteType(reactor, types.getTargetType(stateVar)) + " " + stateVar.getName() + ";"); } return code.toString(); } diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 418c87157b..d5580cefa5 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -882,6 +882,24 @@ public static boolean isTokenType(InferredType type, CTypes types) { return type.isVariableSizeList || targetType.trim().endsWith("*"); } + /** + * Given a type we need to check if the type is Generic Type literal and if + * it is we need to find the corresponding concrete type + * + * @param tpr {@link TypeParameterizedReactor} + * @param type Actual typename + */ + public static String getConcreteType(TypeParameterizedReactor tpr, final String type) { + var wrapper = new Object() { String concreteType = ""; }; + tpr.typeArgs().forEach((literal, concreteType) -> { + if (type.equals(literal)) + { + wrapper.concreteType = String.valueOf(concreteType.getId()); + } + }); + return (wrapper.concreteType.isEmpty()) ? type : wrapper.concreteType; + } + public static String generateWidthVariable(String var) { return var + "_width"; } diff --git a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java index 6fd6175a6f..bc4d6893a1 100644 --- a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java +++ b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java @@ -101,6 +101,7 @@ public InteractingContainedReactors(Reactor reactor) { * @param port The port. */ private List addPort(Instantiation containedReactor, Port port) { + var parent = containedReactor.eContainer(); // Get or create the entry for the containedReactor. var containedReactorEntry = portsByContainedReactor.computeIfAbsent( containedReactor, diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 281139c4af..a903d5e9ae 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -31,7 +31,7 @@ private static ImmutableMap addTypeArgs(Instantiation instantiatio public String getName() { // FIXME: Types that are not just a single token need to be escaped or hashed - return r.getName() + typeArgs.values().stream().map(ASTUtils::toText).collect(Collectors.joining("_")); + return r.getName() + typeArgs.values().stream().map(ASTUtils::toOriginalText).collect(Collectors.joining("_")); } @Override From 03ef8de3a973237bd8b3c1d7cf748e5187303a54 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Wed, 5 Apr 2023 15:17:49 +0500 Subject: [PATCH 106/709] [C-Generics] Contained Reactor type collission Defining template types in header can cause redefinitions in case of contained reactors using `#if defined/#undef/#define` construct can cause type collission as contained reactor can use the same template literals for different types than the parent reactor To solve this issue we decided to go for string substitution in header file to rersolve templated types to their respective concrete types and we'll still be using `#define` in scource files as the template types need to be defined as per instantiation in the source file Signed-off-by: mkhubaibumer --- .../src/org/lflang/generator/c/CActionGenerator.java | 6 ++++-- org.lflang/src/org/lflang/generator/c/CGenerator.java | 7 +------ org.lflang/src/org/lflang/generator/c/CPortGenerator.java | 5 +++-- .../src/org/lflang/generator/c/CReactionGenerator.java | 2 +- org.lflang/src/org/lflang/generator/c/CStateGenerator.java | 7 ++++--- org.lflang/src/org/lflang/generator/c/CTypes.java | 3 ++- org.lflang/src/org/lflang/generator/c/CUtil.java | 4 +++- 7 files changed, 18 insertions(+), 16 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index e381ad9bae..2699f276c9 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -140,7 +140,7 @@ public static String generateAuxiliaryStruct( "bool has_value;", // From lf_action_base_t "trigger_t* trigger;" // From lf_action_base_t )); - code.pr(valueDeclaration(action, target, types)); + code.pr(valueDeclaration(tpr, action, target, types)); code.pr(federatedExtension.toString()); code.unindent(); code.pr("} " + variableStructType(action, tpr, userFacing) + ";"); @@ -155,10 +155,12 @@ public static String generateAuxiliaryStruct( * int* value; * ``` * This will return an empty string for an action with no type. + * @param tpr {@link TypeParameterizedReactor} * @param action The action. * @return A string providing the value field of the action struct. */ private static String valueDeclaration( + TypeParameterizedReactor tpr, Action action, Target target, CTypes types @@ -170,6 +172,6 @@ private static String valueDeclaration( // will be a separate field pointing to the token. return action.getType() == null && target.requiresTypes ? "" : - types.getTargetType(action) + " value;"; + CUtil.getConcreteType(tpr, types.getTargetType(action)) + " value;"; } } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 611edf7c62..d0791230be 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1068,11 +1068,6 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String .map(TypeParameterizedReactor::new).map(CUtil::getName) .map(name -> "#include \"" + name + ".h\"") .forEach(header::pr); - tpr.typeArgs().forEach((literal, concreteType) -> header.pr( - "#if defined " + literal + "\n" + - "#undef " + literal + "\n" + - "#endif // " + literal + "\n" + - "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); } private void generateReactorClassBody(TypeParameterizedReactor tpr, CodeBuilder header, CodeBuilder src) { @@ -1878,7 +1873,7 @@ protected void generateParameterInitialization(ReactorInstance instance) { if (initializer.startsWith("{")) { var temporaryVariableName = parameter.uniqueID(); initializeTriggerObjects.pr(String.join("\n", - "static "+types.getVariableDeclaration(parameter.type, temporaryVariableName, true)+" = "+initializer+";", + "static "+types.getVariableDeclaration(instance.tpr, parameter.type, temporaryVariableName, true)+" = "+initializer+";", selfRef+"->"+parameter.getName()+" = "+temporaryVariableName+";" )); } else { diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index 5e6320dbfb..0177868f1d 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -73,7 +73,7 @@ public static String generateAuxiliaryStruct( "int destination_channel;", // From lf_port_base_t "int num_destinations;" // From lf_port_base_t )); - code.pr(valueDeclaration(port, target, errorReporter, types)); + code.pr(valueDeclaration(tpr, port, target, errorReporter, types)); code.pr(federatedExtension.toString()); code.unindent(); code.pr("} "+variableStructType(port, tpr, userFacing)+";"); @@ -172,6 +172,7 @@ public static String initializeOutputMultiport( * @return A string providing the value field of the port struct. */ private static String valueDeclaration( + TypeParameterizedReactor tpr, Port port, Target target, ErrorReporter errorReporter, @@ -184,7 +185,7 @@ private static String valueDeclaration( } // Do not convert to lf_token_t* using lfTypeToTokenType because there // will be a separate field pointing to the token. - return types.getVariableDeclaration(ASTUtils.getInferredType(port), "value", false) + ";"; + return types.getVariableDeclaration(tpr, ASTUtils.getInferredType(port), "value", false) + ";"; } /** diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index a336752280..d54e54d5ee 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -665,7 +665,7 @@ public static String generateOutputVariablesInReaction( * specified reactor and a trigger_t struct for each trigger (input, action, * timer, or output of a contained reactor). * @param body The place to put the code for the self struct. - * @param reactor The reactor. + * @param tpr {@link TypeParameterizedReactor} * @param constructorCode The place to put the constructor code. */ public static void generateReactionAndTriggerStructs( diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java index 029648844d..fc66036511 100644 --- a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java @@ -47,7 +47,7 @@ public static String generateInitializer( CTypes types ) { var initExpr = getInitializerExpr(stateVar, instance); - String baseInitializer = generateBaseInitializer(selfRef, stateVar, initExpr, types); + String baseInitializer = generateBaseInitializer(instance.tpr, selfRef, stateVar, initExpr, types); String modalReset = generateModalReset(instance, selfRef, stateVar, initExpr, mode, types); return String.join("\n", baseInitializer, @@ -56,6 +56,7 @@ public static String generateInitializer( } private static String generateBaseInitializer( + TypeParameterizedReactor tpr, String selfRef, StateVar stateVar, String initExpr, @@ -67,7 +68,7 @@ private static String generateBaseInitializer( ) { return selfRef + "->" + stateVar.getName() + " = " + initExpr + ";"; } else { - var declaration = types.getVariableDeclaration( + var declaration = types.getVariableDeclaration(tpr, ASTUtils.getInferredType(stateVar), "_initial", true); return String.join("\n", @@ -103,7 +104,7 @@ private static String generateModalReset( } else { CodeBuilder code = new CodeBuilder(); var source = "_initial"; - var declaration = types.getVariableDeclaration( + var declaration = types.getVariableDeclaration(instance.tpr, ASTUtils.getInferredType(stateVar), source, true); code.pr("{ // For scoping"); diff --git a/org.lflang/src/org/lflang/generator/c/CTypes.java b/org.lflang/src/org/lflang/generator/c/CTypes.java index 803d9e8432..ebb9c894f4 100644 --- a/org.lflang/src/org/lflang/generator/c/CTypes.java +++ b/org.lflang/src/org/lflang/generator/c/CTypes.java @@ -97,11 +97,12 @@ public String getTargetType(InferredType type) { * @param initializer True to return a form usable in a static initializer. */ public String getVariableDeclaration( + TypeParameterizedReactor tpr, InferredType type, String variableName, boolean initializer ) { - String t = TargetTypes.super.getTargetType(type); + String t = CUtil.getConcreteType(tpr, TargetTypes.super.getTargetType(type)); Matcher matcher = arrayPattern.matcher(t); String declaration = String.format("%s %s", t, variableName); if (matcher.find()) { diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index d5580cefa5..87f75133dd 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -878,7 +878,7 @@ private static List multiportWidthTerms(Variable variable) { public static boolean isTokenType(InferredType type, CTypes types) { if (type.isUndefined()) return false; // This is a hacky way to do this. It is now considered to be a bug (#657) - String targetType = types.getVariableDeclaration(type, "", false); + String targetType = types.getVariableDeclaration(null, type, "", false); return type.isVariableSizeList || targetType.trim().endsWith("*"); } @@ -890,6 +890,8 @@ public static boolean isTokenType(InferredType type, CTypes types) { * @param type Actual typename */ public static String getConcreteType(TypeParameterizedReactor tpr, final String type) { + if (tpr == null) + return type; var wrapper = new Object() { String concreteType = ""; }; tpr.typeArgs().forEach((literal, concreteType) -> { if (type.equals(literal)) From b5d6d5891872e840426f2ba8e9ceb9f475c0466e Mon Sep 17 00:00:00 2001 From: Benichiwa Date: Wed, 5 Apr 2023 12:38:30 -0700 Subject: [PATCH 107/709] create triggers save progress --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CGenerator.java | 1 + .../src/org/lflang/generator/c/CReactionGenerator.java | 5 +++++ 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index ff3c84c36b..e24e3bca22 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit ff3c84c36b2d7fbcbe09fafa577ec94f75194e83 +Subproject commit e24e3bca22c8e2f85be31ec61a1d3e99a72566e2 diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 33bcab4b70..b54c77f6ab 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -310,6 +310,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * @author Alexander Schulz-Rosengarten * @author Hou Seng Wong * @author Anirudh Rengarajan + * @author Benjamin Asch */ @SuppressWarnings("StaticPseudoFunctionalStyleMethod") public class CGenerator extends GeneratorBase { diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index e7e43a903c..e58d423d99 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -854,6 +854,11 @@ public static void generateReactionAndTriggerStructs( for (Input input : ASTUtils.allInputs(reactor)) { createTriggerT(body, input, triggerMap, constructorCode, types); } + + // Next handle watchdogs. + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + createTriggerT(body, watchdog, triggerMap, constructorCode, types); + } } /** From 34f96e576eec63f573527e9c1d10efe26e04415c Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Wed, 5 Apr 2023 14:36:35 -0700 Subject: [PATCH 108/709] fixed watchdog test inconsistency? define watchdog trigger --- org.lflang/src/lib/c/reactor-c | 2 +- .../src/org/lflang/generator/c/CReactionGenerator.java | 2 +- .../src/org/lflang/generator/c/CWatchdogGenerator.java | 5 +++-- test/C/src/Watchdog.lf | 4 ++-- 4 files changed, 7 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index e24e3bca22..ff3c84c36b 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit e24e3bca22c8e2f85be31ec61a1d3e99a72566e2 +Subproject commit ff3c84c36b2d7fbcbe09fafa577ec94f75194e83 diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index e58d423d99..0a1df14302 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -866,7 +866,7 @@ public static void generateReactionAndTriggerStructs( * reaction_t pointers pointing to reactions triggered by this variable, * and initialize the pointers in the array in the constructor. * @param body The place to write the self struct entries. - * @param variable The trigger variable (Timer, Action, or Input). + * @param variable The trigger variable (Timer, Watchdog, Action, or Input). * @param triggerMap A map from Variables to a list of the reaction indices * triggered by the variable. * @param constructorCode The place to write the constructor code. diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 3c9568699c..ece414ac36 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -128,7 +128,7 @@ public static String generateFunction(String header, String init, Watchdog watch function.prSourceLineNumber(watchdog.getCode()); function.pr(ASTUtils.toText(watchdog.getCode())); //FIXME: will need to lf_schedule instead - // function.pr("lf_set("+watchdog.getName()+", 1);"); + function.pr("_lf_schedule((*"+watchdog.getName()+").trigger, 0, NULL);"); function.unindent(); function.pr("}"); return function.toString(); @@ -173,7 +173,8 @@ public static void generateWatchdogStruct( "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", "self->_lf_watchdog_"+watchdogName+".thread_active = false;", // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", - "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";" + "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";", + "self->_lf_watchdog_"+watchdogName+".trigger = &(self->_lf__"+watchdogName+");" )); // constructorCode.pr("#endif"); // WATCHDOG QUESTION 6: should I be initializing mutex in this constructor? diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index df88d23d73..fdac093c49 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -58,8 +58,8 @@ main reactor { self->count++; =} reaction(shutdown) {= - if (self->count != 4) { - lf_print_error_and_exit("Watchdog produced output %d times. Expected 4.", self->count); + if (self->count != 5) { + lf_print_error_and_exit("Watchdog produced output %d times. Expected 5.", self->count); } =} } From ad9a226e83590079fa07d66644da4bce44ca7f8c Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Thu, 6 Apr 2023 21:00:16 +0500 Subject: [PATCH 109/709] [C-Generics] Basic Support for Contained Reactors Signed-off-by: mkhubaibumer --- org.lflang/src/org/lflang/ASTUtils.java | 6 ++- org.lflang/src/org/lflang/cli/Lfc.java | 2 + .../org/lflang/generator/ReactorInstance.java | 43 +++++++++++++--- .../org/lflang/generator/c/CGenerator.java | 26 +++++----- .../generator/c/CReactionGenerator.java | 49 ++++++++++--------- .../lflang/generator/c/CStateGenerator.java | 12 ++--- .../src/org/lflang/generator/c/CTypes.java | 2 +- .../src/org/lflang/generator/c/CUtil.java | 2 +- .../c/InteractingContainedReactors.java | 3 +- 9 files changed, 90 insertions(+), 55 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index ed9daf5def..558e262a59 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -58,7 +58,9 @@ import org.lflang.ast.ToText; import org.lflang.generator.CodeMap; import org.lflang.generator.InvalidSourceException; +import org.lflang.generator.NamedInstance; import org.lflang.generator.ReactorInstance; +import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; import org.lflang.lf.Assignment; import org.lflang.lf.AttrParm; @@ -899,12 +901,12 @@ public static boolean isFloat(String literal) { return true; } - /** + /** * Report whether the given code is an integer number or not. * @param code AST node to inspect. * @return True if the given code is an integer, false otherwise. */ - public static boolean isInteger(Code code) { + public static boolean isInteger(Code code) { return isInteger(toText(code)); } diff --git a/org.lflang/src/org/lflang/cli/Lfc.java b/org.lflang/src/org/lflang/cli/Lfc.java index 489e9cd2f4..a510a7f2d5 100644 --- a/org.lflang/src/org/lflang/cli/Lfc.java +++ b/org.lflang/src/org/lflang/cli/Lfc.java @@ -18,6 +18,7 @@ import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFGeneratorContext.BuildParm; import org.lflang.generator.MainContext; +import org.lflang.generator.ReactorInstance; import com.google.inject.Inject; @@ -201,6 +202,7 @@ private void invokeGenerator( try { this.generator.generate(resource, this.fileAccess, context); + ReactorInstance.clearReactorInstanceMap(); } catch (Exception e) { reporter.printFatalErrorAndExit("Error running generator", e); } diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 0a5c9e0b85..6252b95a28 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -33,10 +33,9 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; -import org.eclipse.emf.ecore.util.EcoreUtil; - import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; @@ -50,7 +49,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Expression; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; -import org.lflang.lf.LfFactory; import org.lflang.lf.Mode; import org.lflang.lf.Output; import org.lflang.lf.Parameter; @@ -60,13 +58,10 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.Timer; -import org.lflang.lf.Type; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.lf.WidthSpec; -import com.google.common.collect.ImmutableMap; - /** * Representation of a compile-time instance of a reactor. @@ -165,6 +160,39 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re public final TypeParameterizedReactor tpr; + private static final HashMap gReactorInstancesMap = new HashMap<>(); + + ////////////////////////////////////////////////////// + //// Static methods. + + /** Map {@link ReactorInstance} against achievable hashcode from {@link Reactor} */ + public static void mapReactorInstance(Reactor r, ReactorInstance i) { + gReactorInstancesMap.put(computeHash(r, i), i); + } + + /** Get {@link ReactorInstance} for supplied {@link Reactor} */ + public static ReactorInstance getReactorInstance(Reactor r) { + var wrapper = new Object() { + ReactorInstance ins = null; + }; + gReactorInstancesMap.forEach((hash, i) -> { + if (Objects.equals(hash, computeHash(r, i))) { + wrapper.ins = i; + } + }); + return wrapper.ins; + } + + /** Clears out the cache of ReactorInstance for next LF processing */ + public static void clearReactorInstanceMap() { + gReactorInstancesMap.clear(); + } + + /** Calculates Unique HashCode for the key of ReactorInstanceMap*/ + private static Integer computeHash(Reactor r, ReactorInstance i) { + return Math.abs(r.hashCode() * 37 + r.getTypeParms().hashCode() + i.tpr.hashCode()); + } + ////////////////////////////////////////////////////// //// Public methods. @@ -778,6 +806,9 @@ public ReactorInstance( this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); this.tpr = new TypeParameterizedReactor(definition); + // Add ReactorInstance against achievable hashcode from Reactor + ReactorInstance.mapReactorInstance(ASTUtils.toDefinition(definition.getReactorClass()), this); + // check for recursive instantiation var currentParent = parent; var foundSelfAsParent = false; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index d0791230be..fb16baa559 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -42,8 +42,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; -import java.util.Locale; -import java.util.Map; import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -86,7 +84,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.generator.TriggerInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; -import org.lflang.lf.Code; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Mode; @@ -97,7 +94,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; -import org.lflang.lf.Type; import org.lflang.lf.Variable; import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; @@ -1255,7 +1251,7 @@ private void generateInteractingContainedReactors( var contained = new InteractingContainedReactors(tpr.r()); // Next generate the relevant code. for (Instantiation containedReactor : contained.containedReactors()) { - Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); + var containedReactorType = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(containedReactor.getReactorClass())); // First define an _width variable in case it is a bank. var array = ""; var width = -2; @@ -1267,11 +1263,11 @@ private void generateInteractingContainedReactors( } // NOTE: The following needs to be done for each instance // so that the width can be parameter, not in the constructor. - // Here, we conservatively use a width that is the largest of all isntances. + // Here, we conservatively use a width that is the largest of all instances. constructorCode.pr(String.join("\n", "// Set the _width variable for all cases. This will be -2", "// if the reactor is not a bank of reactors.", - "self->_lf_"+containedReactor.getName()+"_width = "+width+";" + "self->_lf_"+containedReactorType.tpr.getName()+"_width = "+width+";" )); // Generate one struct for each contained reactor that interacts. @@ -1283,12 +1279,12 @@ private void generateInteractingContainedReactors( // to be malloc'd at initialization. if (!ASTUtils.isMultiport(port)) { // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType, false)+" "+port.getName()+";"); + body.pr(port, variableStructType(port, containedReactorType.tpr, false)+" "+port.getName()+";"); } else { // Is a multiport. // Memory will be malloc'd in initialization. body.pr(port, String.join("\n", - variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", + variableStructType(port, containedReactorType.tpr, false)+"** "+port.getName()+";", "int "+port.getName()+"_width;" )); } @@ -1298,13 +1294,13 @@ private void generateInteractingContainedReactors( // self struct of the container. if (!ASTUtils.isMultiport(port)) { // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType, false)+"* "+port.getName()+";"); + body.pr(port, variableStructType(port, containedReactorType.tpr, false)+"* "+port.getName()+";"); } else { // Is a multiport. // Here, we will use an array of pointers. // Memory will be malloc'd in initialization. body.pr(port, String.join("\n", - variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", + variableStructType(port, containedReactorType.tpr, false)+"** "+port.getName()+";", "int "+port.getName()+"_width;" )); } @@ -1312,10 +1308,10 @@ private void generateInteractingContainedReactors( var reactorIndex = ""; if (containedReactor.getWidthSpec() != null) { reactorIndex = "[reactor_index]"; - constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+tpr.getName()+"_width; reactor_index++) {"); + constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactorType.tpr.getName()+"_width; reactor_index++) {"); constructorCode.indent(); } - var portOnSelf = "self->_lf_"+tpr.getName()+reactorIndex+"."+port.getName(); + var portOnSelf = "self->_lf_"+containedReactorType.tpr.getName()+reactorIndex+"."+port.getName(); constructorCode.pr( port, @@ -1360,8 +1356,8 @@ private void generateInteractingContainedReactors( } body.unindent(); body.pr(String.join("\n", - "} _lf_"+tpr.getName()+array+";", - "int _lf_"+tpr.getName()+"_width;" + "} _lf_"+containedReactorType.tpr.getName()+array+";", + "int _lf_"+containedReactorType.tpr.getName()+"_width;" )); } } diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index d54e54d5ee..28791b9cd1 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -14,9 +14,9 @@ import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetConfig; -import org.lflang.TargetProperty.Platform; import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.CodeBuilder; +import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; import org.lflang.lf.BuiltinTriggerRef; @@ -30,7 +30,6 @@ import org.lflang.lf.Port; import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; import org.lflang.lf.Timer; import org.lflang.lf.TriggerRef; import org.lflang.lf.VarRef; @@ -206,18 +205,19 @@ public static String generateInitializationForReaction(String body, // Before the reaction initialization, // generate the structs used for communication to and from contained reactors. for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { + var containedReactorType = ReactorInstance.getReactorInstance((Reactor) containedReactor.getReactorClass()); String array = ""; if (containedReactor.getWidthSpec() != null) { - String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); + String containedReactorWidthVar = generateWidthVariable(containedReactorType.tpr.getName()); code.pr("int "+containedReactorWidthVar+" = self->_lf_"+containedReactorWidthVar+";"); // Windows does not support variables in arrays declared on the stack, // so we use the maximum size over all bank members. array = "["+maxContainedReactorBankWidth(containedReactor, null, 0, mainDef)+"]"; } code.pr(String.join("\n", - "struct "+containedReactor.getName()+" {", + "struct "+containedReactorType.getName()+" {", " "+fieldsForStructsForContainedReactors.get(containedReactor)+"", - "} "+containedReactor.getName()+array+";" + "} "+containedReactorType.getName()+array+";" )); } // Next generate all the collected setup code. @@ -348,14 +348,15 @@ private static void generateVariablesForSendingToContainedReactors( Instantiation definition, Input input ) { - // TODO: Get reactorInstance or TPR from Instantiation CodeBuilder structBuilder = structs.get(definition); if (structBuilder == null) { structBuilder = new CodeBuilder(); structs.put(definition, structBuilder); } - String inputStructType = CGenerator.variableStructType(input, ASTUtils.toDefinition(definition.getReactorClass()), false); - String defName = definition.getName(); + var reactorInstance = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(definition.getReactorClass())); + String inputStructType = CGenerator.variableStructType(input, reactorInstance.tpr, false); + String defName = reactorInstance.getName(); + String subName = reactorInstance.tpr.getName(); String defWidth = generateWidthVariable(defName); String inputName = input.getName(); String inputWidth = generateWidthVariable(inputName); @@ -366,12 +367,12 @@ private static void generateVariablesForSendingToContainedReactors( // Contained reactor is a bank. builder.pr(String.join("\n", "for (int bankIndex = 0; bankIndex < self->_lf_"+defWidth+"; bankIndex++) {", - " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+defName+"[bankIndex]."+inputName+");", + " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+subName+"[bankIndex]."+inputName+");", "}" )); } else { // Contained reactor is not a bank. - builder.pr(defName+"."+inputName+" = &(self->_lf_"+defName+"."+inputName+");"); + builder.pr(defName+"."+inputName+" = &(self->_lf_"+subName+"."+inputName+");"); } } else { // Contained reactor's input is a multiport. @@ -384,14 +385,14 @@ private static void generateVariablesForSendingToContainedReactors( if (definition.getWidthSpec() != null) { builder.pr(String.join("\n", "for (int _i = 0; _i < self->_lf_"+defWidth+"; _i++) {", - " "+defName+"[_i]."+inputName+" = self->_lf_"+defName+"[_i]."+inputName+";", - " "+defName+"[_i]."+inputWidth+" = self->_lf_"+defName+"[_i]."+inputWidth+";", + " "+defName+"[_i]."+inputName+" = self->_lf_"+subName+"[_i]."+inputName+";", + " "+defName+"[_i]."+inputWidth+" = self->_lf_"+subName+"[_i]."+inputWidth+";", "}" )); } else { builder.pr(String.join("\n", - defName+"."+inputName+" = self->_lf_"+defName+"."+inputName+";", - defName+"."+inputWidth+" = self->_lf_"+defName+"."+inputWidth+";" + defName+"."+inputName+" = self->_lf_"+subName+"."+inputName+";", + defName+"."+inputWidth+" = self->_lf_"+subName+"."+inputWidth+";" )); } } @@ -421,14 +422,15 @@ private static void generatePortVariablesInReaction( } else { // port is an output of a contained reactor. Output output = (Output) port.getVariable(); - String portStructType = CGenerator.variableStructType(output, tpr, false); + String portStructType = CGenerator.variableStructType(output, ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass())).getTypeParameterizedReactor(), false); CodeBuilder structBuilder = structs.get(port.getContainer()); if (structBuilder == null) { structBuilder = new CodeBuilder(); structs.put(port.getContainer(), structBuilder); } - String reactorName = port.getContainer().getName(); + String reactorName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass())).tpr.getName(); + String subName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass())).getName(); String reactorWidth = generateWidthVariable(reactorName); String outputName = output.getName(); String outputWidth = generateWidthVariable(outputName); @@ -450,21 +452,21 @@ private static void generatePortVariablesInReaction( // Output is in a bank. builder.pr(String.join("\n", "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+reactorName+"[i]."+outputName+" = self->_lf_"+reactorName+"[i]."+outputName+";", + " "+subName+"[i]."+outputName+" = self->_lf_"+reactorName+"[i]."+outputName+";", "}" )); if (ASTUtils.isMultiport(output)) { builder.pr(String.join("\n", "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+reactorName+"[i]."+outputWidth+" = self->_lf_"+reactorName+"[i]."+outputWidth+";", + " "+subName+"[i]."+outputWidth+" = self->_lf_"+reactorName+"[i]."+outputWidth+";", "}" )); } } else { // Output is not in a bank. - builder.pr(reactorName+"."+outputName+" = self->_lf_"+reactorName+"."+outputName+";"); + builder.pr(subName+"."+outputName+" = self->_lf_"+reactorName+"."+outputName+";"); if (ASTUtils.isMultiport(output)) { - builder.pr(reactorName+"."+outputWidth+" = self->_lf_"+reactorName+"."+outputWidth+";"); + builder.pr(subName+"."+outputWidth+" = self->_lf_"+reactorName+"."+outputWidth+";"); } } } @@ -641,9 +643,10 @@ public static String generateOutputVariablesInReaction( // The container of the output may be a contained reactor or // the reactor containing the reaction. String outputStructType = (effect.getContainer() == null) ? - CGenerator.variableStructType(output, tpr, false) - : - CGenerator.variableStructType(output, ASTUtils.toDefinition(effect.getContainer().getReactorClass()), false); + CGenerator.variableStructType(output, tpr, false) + : + CGenerator.variableStructType(output, ReactorInstance.getReactorInstance( + ASTUtils.toDefinition(effect.getContainer().getReactorClass())).getTypeParameterizedReactor(), false); if (!ASTUtils.isMultiport(output)) { // Output port is not a multiport. return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java index fc66036511..70d21a1f23 100644 --- a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java @@ -15,7 +15,7 @@ public class CStateGenerator { /** * Generate code for state variables of a reactor in the form "stateVar.type stateVar.name;" - * @param reactor The reactor + * @param reactor {@link TypeParameterizedReactor} * @param types A helper object for types */ public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { @@ -34,10 +34,10 @@ public static String generateDeclarations(TypeParameterizedReactor reactor, CTyp * this way, and there is no way to tell whether the type of the array * is a struct. * - * @param instance - * @param stateVar - * @param mode - * @return + * @param instance {@link ReactorInstance} + * @param stateVar {@link StateVar} + * @param mode {@link ModeInstance} + * @return String */ public static String generateInitializer( ReactorInstance instance, @@ -92,7 +92,7 @@ private static String generateModalReset( return ""; } var modeRef = "&"+CUtil.reactorRef(mode.getParent())+"->_lf__modes["+mode.getParent().modes.indexOf(mode)+"]"; - var type = types.getTargetType(ASTUtils.getInferredType(stateVar)); + var type = CUtil.getConcreteType(instance.tpr, types.getTargetType(ASTUtils.getInferredType(stateVar))); if (ASTUtils.isOfTimeType(stateVar) || ASTUtils.isParameterized(stateVar) && diff --git a/org.lflang/src/org/lflang/generator/c/CTypes.java b/org.lflang/src/org/lflang/generator/c/CTypes.java index ebb9c894f4..361046c27a 100644 --- a/org.lflang/src/org/lflang/generator/c/CTypes.java +++ b/org.lflang/src/org/lflang/generator/c/CTypes.java @@ -65,7 +65,7 @@ public String getTargetUndefinedType() { * as a type, and {@code int*} must be used instead, except when initializing * a variable using a static initializer, as in {@code int[] foo = {1, 2, 3};}. * When initializing a variable using a static initializer, use - * {@link #getVariableDeclaration(InferredType, String, boolean)} instead. + * {@link #getVariableDeclaration(TypeParameterizedReactor, InferredType, String, boolean)} instead. * @param type The type. */ @Override diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 87f75133dd..3cae52d931 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -469,7 +469,7 @@ public static String reactorRefNested(ReactorInstance reactor) { * default, the string returned by {@link CUtil#bankIndex(ReactorInstance)}. */ public static String reactorRefNested(ReactorInstance reactor, String runtimeIndex, String bankIndex) { - String result = reactorRef(reactor.getParent(), runtimeIndex) + "->_lf_" + reactor.getName(); + String result = reactorRef(reactor.getParent(), runtimeIndex) + "->_lf_" + reactor.tpr.getName(); if (reactor.isBank()) { // Need the bank index not the runtimeIndex. if (bankIndex == null) bankIndex = bankIndex(reactor); diff --git a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java index bc4d6893a1..ae6b37437f 100644 --- a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java +++ b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java @@ -8,12 +8,14 @@ import org.lflang.ASTUtils; import org.lflang.federated.generator.FederateInstance; +import org.lflang.generator.NamedInstance; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Output; import org.lflang.lf.Port; import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; +import org.lflang.lf.ReactorDecl; import org.lflang.lf.TriggerRef; import org.lflang.lf.VarRef; @@ -101,7 +103,6 @@ public InteractingContainedReactors(Reactor reactor) { * @param port The port. */ private List addPort(Instantiation containedReactor, Port port) { - var parent = containedReactor.eContainer(); // Get or create the entry for the containedReactor. var containedReactorEntry = portsByContainedReactor.computeIfAbsent( containedReactor, From a35208f360e02f4ad4788ba1589d8717ca72f8d8 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 10 Apr 2023 13:52:29 -0700 Subject: [PATCH 110/709] tried removing boolean from self-base_t struct, failed, everything working now --- .../org/lflang/generator/c/CGenerator.java | 5 ++ .../generator/c/CWatchdogGenerator.java | 22 +------ test/Python/src/PyWatchdog.lf | 66 +++++++++++++++++++ 3 files changed, 74 insertions(+), 19 deletions(-) create mode 100644 test/Python/src/PyWatchdog.lf diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b54c77f6ab..5e94fe55fb 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1243,6 +1243,11 @@ private void generateSelfStruct(ReactorDecl decl, CodeBuilder constructorCode) { // Next, generate fields for modes CModesGenerator.generateDeclarations(reactor, body, constructorCode); + // constructorCode.pr(reactor, String.join("\n", + // "#ifdef LF_THREADED", + // " self->base->watchdog_mutex = NULL;", + // "#endif")); + // The first field has to always be a pointer to the list of // of allocated memory that must be freed when the reactor is freed. // This means that the struct can be safely cast to self_base_t. diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index ece414ac36..9163883962 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -124,11 +124,9 @@ public static String generateFunction(String header, String init, Watchdog watch var function = new CodeBuilder(); function.pr(header + " {"); function.indent(); - function.pr(init); + function.pr(init);function.pr("_lf_schedule((*"+watchdog.getName()+").trigger, 0, NULL);"); function.prSourceLineNumber(watchdog.getCode()); function.pr(ASTUtils.toText(watchdog.getCode())); - //FIXME: will need to lf_schedule instead - function.pr("_lf_schedule((*"+watchdog.getName()+").trigger, 0, NULL);"); function.unindent(); function.pr("}"); return function.toString(); @@ -147,25 +145,12 @@ public static void generateWatchdogStruct( for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { String watchdogName = watchdog.getName(); - // Create pointer to the watchdog_t struct - // WATCHDOG QUESTION 2: Why need to put object at beginning of - // `.pr` func call? - - // WATCHDOG QUESTION 3: Is the space for this struct automatically allocated - // through `_lf_new_reactor`? `_lf__startup_reaction` is also a pointer in self struct - // but does not seem to have a separate allocation call. - body.pr(watchdog, "watchdog_t _lf_watchdog_"+watchdogName+";"); - // WATCHDOG QUESTION 4: Not sure if this is correct, may need to use - // 'getTargetTime' instead. watchdog timeout is listed as "Expression" - // in the grammar, so I'm not sure if it is reading the timeout as - // a Time class or TimeValue class. - // var min_expiration = GeneratorBase.timeInTargetLanguage(watchdog.getTimeout()); + body.pr(watchdog, "watchdog_t _lf_watchdog_"+watchdogName+";"); // watchdog function name var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); // Set values of watchdog_t struct in the reactor's constructor - // WATCHDOG QUESTION 5: should I be defining these in the constructor of the reactor? //FIXME: update parameters // constructorCode.pr("#ifdef LF_THREADED"); constructorCode.pr(watchdog, String.join("\n", @@ -176,8 +161,7 @@ public static void generateWatchdogStruct( "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";", "self->_lf_watchdog_"+watchdogName+".trigger = &(self->_lf__"+watchdogName+");" )); - // constructorCode.pr("#endif"); - // WATCHDOG QUESTION 6: should I be initializing mutex in this constructor? + } } diff --git a/test/Python/src/PyWatchdog.lf b/test/Python/src/PyWatchdog.lf new file mode 100644 index 0000000000..a89cf0d7de --- /dev/null +++ b/test/Python/src/PyWatchdog.lf @@ -0,0 +1,66 @@ +/** + * Test watchdog. + * This test starts a watchdog timer of 150ms every 100ms. + * Half the time, it then sleeps after starting the watchdog so that + * the watchdog expires. There should be a total of five watchdog + * expirations. + * @author Benjamin Asch + * @author Edward A. Lee + */ + +target Python { + timeout: 1100ms, + threading: true +} + +reactor Watcher(timeout(150 ms)) { + timer t(100 ms, 100 ms) // Offset ameliorates startup time. + output d // Produced if watchdog triggers. + state alternating(False) + state count(0) + + watchdog poodle(timeout) {= + p = lf_time_physical_elapsed() - lf_time_logical_elapsed() + lf_print("Watchdog timed out! Lag: "+p+" (too late by "+(p - self.timeout)+" ns)") + self.count += 1 + =} + + reaction(t) -> poodle, d {= + lf_watchdog_start(poodle, 0) + lf_print("Watchdog started at physical time "+lf_time_physical_elapsed()) + lf_print("Will expire at "+lf_time_logical_elapsed() + self.timeout) + if (self.alternating) { + lf_sleep(160 ms) + } + self.alternating = not self.alternating + =} + + reaction(poodle) -> d {= + lf_print("Reaction poodle was called.") + d.set(1) + =} + + reaction(shutdown) -> poodle {= + _lf_watchdog_stop(poodle) + if (self.count != 5) { + lf_print_error_and_exit("Watchdog expired "+self.count+" times. Expected 5.") + } + =} +} + +main reactor { + logical action a + state count(0) + w = new Watcher() + + reaction(w.d) {= + lf_print("*** Watcher reactor produced an output.") + self.count += 1 + =} + + reaction(shutdown) {= + if (self.count != 5) { + lf_print_error_and_exit("Watchdog produced output "+self.count+" times. Expected 5.") + } + =} +} From 9f32cefab1dc30c0ed2f72a3fbf5b5d11089090d Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Tue, 11 Apr 2023 18:51:22 +0500 Subject: [PATCH 111/709] [C-Generic] Contained Generic Reactor This commit fixes the issues with having multiple contained generic reactors Signed-off-by: mkhubaibumer --- .../org/lflang/generator/ReactorInstance.java | 23 +++++++------------ .../org/lflang/generator/c/CGenerator.java | 2 +- .../generator/c/CReactionGenerator.java | 12 +++++----- .../generator/c/TypeParameterizedReactor.java | 1 - 4 files changed, 15 insertions(+), 23 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 6252b95a28..46ff5b1a73 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -166,21 +166,14 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re //// Static methods. /** Map {@link ReactorInstance} against achievable hashcode from {@link Reactor} */ - public static void mapReactorInstance(Reactor r, ReactorInstance i) { - gReactorInstancesMap.put(computeHash(r, i), i); + public static void mapReactorInstance(Reactor r, ReactorInstance i, final String n) { + gReactorInstancesMap.put(computeHash(r, n), i); } /** Get {@link ReactorInstance} for supplied {@link Reactor} */ - public static ReactorInstance getReactorInstance(Reactor r) { - var wrapper = new Object() { - ReactorInstance ins = null; - }; - gReactorInstancesMap.forEach((hash, i) -> { - if (Objects.equals(hash, computeHash(r, i))) { - wrapper.ins = i; - } - }); - return wrapper.ins; + public static ReactorInstance getReactorInstance(Reactor r, final String n) { + var instance = gReactorInstancesMap.get(computeHash(r, n)); + return instance; } /** Clears out the cache of ReactorInstance for next LF processing */ @@ -189,8 +182,8 @@ public static void clearReactorInstanceMap() { } /** Calculates Unique HashCode for the key of ReactorInstanceMap*/ - private static Integer computeHash(Reactor r, ReactorInstance i) { - return Math.abs(r.hashCode() * 37 + r.getTypeParms().hashCode() + i.tpr.hashCode()); + private static Integer computeHash(Reactor r, final String n) { + return Math.abs(r.hashCode() * 37 + r.getTypeParms().hashCode() + n.hashCode()); } ////////////////////////////////////////////////////// @@ -807,7 +800,7 @@ public ReactorInstance( this.tpr = new TypeParameterizedReactor(definition); // Add ReactorInstance against achievable hashcode from Reactor - ReactorInstance.mapReactorInstance(ASTUtils.toDefinition(definition.getReactorClass()), this); + ReactorInstance.mapReactorInstance(ASTUtils.toDefinition(definition.getReactorClass()), this, definition.getName()); // check for recursive instantiation var currentParent = parent; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index fb16baa559..abbaee4428 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1251,7 +1251,7 @@ private void generateInteractingContainedReactors( var contained = new InteractingContainedReactors(tpr.r()); // Next generate the relevant code. for (Instantiation containedReactor : contained.containedReactors()) { - var containedReactorType = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(containedReactor.getReactorClass())); + var containedReactorType = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(containedReactor.getReactorClass()), containedReactor.getName()); // First define an _width variable in case it is a bank. var array = ""; var width = -2; diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 28791b9cd1..ead750738d 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -205,7 +205,7 @@ public static String generateInitializationForReaction(String body, // Before the reaction initialization, // generate the structs used for communication to and from contained reactors. for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { - var containedReactorType = ReactorInstance.getReactorInstance((Reactor) containedReactor.getReactorClass()); + var containedReactorType = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(containedReactor.getReactorClass()), containedReactor.getName()); String array = ""; if (containedReactor.getWidthSpec() != null) { String containedReactorWidthVar = generateWidthVariable(containedReactorType.tpr.getName()); @@ -353,7 +353,7 @@ private static void generateVariablesForSendingToContainedReactors( structBuilder = new CodeBuilder(); structs.put(definition, structBuilder); } - var reactorInstance = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(definition.getReactorClass())); + var reactorInstance = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(definition.getReactorClass()), definition.getName()); String inputStructType = CGenerator.variableStructType(input, reactorInstance.tpr, false); String defName = reactorInstance.getName(); String subName = reactorInstance.tpr.getName(); @@ -422,15 +422,15 @@ private static void generatePortVariablesInReaction( } else { // port is an output of a contained reactor. Output output = (Output) port.getVariable(); - String portStructType = CGenerator.variableStructType(output, ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass())).getTypeParameterizedReactor(), false); + String portStructType = CGenerator.variableStructType(output, ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass()), port.getContainer().getName()).getTypeParameterizedReactor(), false); CodeBuilder structBuilder = structs.get(port.getContainer()); if (structBuilder == null) { structBuilder = new CodeBuilder(); structs.put(port.getContainer(), structBuilder); } - String reactorName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass())).tpr.getName(); - String subName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass())).getName(); + String reactorName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass()), port.getContainer().getName()).tpr.getName(); + String subName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass()), port.getContainer().getName()).getName(); String reactorWidth = generateWidthVariable(reactorName); String outputName = output.getName(); String outputWidth = generateWidthVariable(outputName); @@ -646,7 +646,7 @@ public static String generateOutputVariablesInReaction( CGenerator.variableStructType(output, tpr, false) : CGenerator.variableStructType(output, ReactorInstance.getReactorInstance( - ASTUtils.toDefinition(effect.getContainer().getReactorClass())).getTypeParameterizedReactor(), false); + ASTUtils.toDefinition(effect.getContainer().getReactorClass()), effect.getContainer().getName()).getTypeParameterizedReactor(), false); if (!ASTUtils.isMultiport(output)) { // Output port is not a multiport. return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index a903d5e9ae..df5cd4444b 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -3,7 +3,6 @@ import java.util.HashMap; import java.util.Map; -import java.util.Map.Entry; import java.util.stream.Collectors; import org.lflang.ASTUtils; From 272dbaa15903da0487c097c37fd9795f20d865f1 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Tue, 11 Apr 2023 19:00:42 +0500 Subject: [PATCH 112/709] Update documentation --- .../org/lflang/generator/ReactorInstance.java | 26 +++++++++++++------ 1 file changed, 18 insertions(+), 8 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 46ff5b1a73..f0211ab22e 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -160,20 +160,27 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re public final TypeParameterizedReactor tpr; + /** HashMap containing {@link ReactorInstance} against hashCode achievable from Reactor */ private static final HashMap gReactorInstancesMap = new HashMap<>(); ////////////////////////////////////////////////////// //// Static methods. - /** Map {@link ReactorInstance} against achievable hashcode from {@link Reactor} */ - public static void mapReactorInstance(Reactor r, ReactorInstance i, final String n) { - gReactorInstancesMap.put(computeHash(r, n), i); + /** Map {@link ReactorInstance} against achievable hashcode from {@link Reactor} + * @param reactor The Reactor + * @param reactorInstance The ReactorInstance for the specified Reactor + * @param defName definition Name for the specified Reactor + * */ + public static void mapReactorInstance(Reactor reactor, ReactorInstance reactorInstance, final String defName) { + gReactorInstancesMap.put(computeHash(reactor, defName), reactorInstance); } - /** Get {@link ReactorInstance} for supplied {@link Reactor} */ - public static ReactorInstance getReactorInstance(Reactor r, final String n) { - var instance = gReactorInstancesMap.get(computeHash(r, n)); - return instance; + /** Get {@link ReactorInstance} for supplied {@link Reactor} + * @param reactor The reactor + * @param defName definition Name for the specified reactor + * */ + public static ReactorInstance getReactorInstance(Reactor reactor, final String defName) { + return gReactorInstancesMap.get(computeHash(reactor, defName)); } /** Clears out the cache of ReactorInstance for next LF processing */ @@ -181,7 +188,10 @@ public static void clearReactorInstanceMap() { gReactorInstancesMap.clear(); } - /** Calculates Unique HashCode for the key of ReactorInstanceMap*/ + /** Calculates Unique HashCode for the key of ReactorInstanceMap + * @param r The reactor + * @param n definition Name for the Reactor + * */ private static Integer computeHash(Reactor r, final String n) { return Math.abs(r.hashCode() * 37 + r.getTypeParms().hashCode() + n.hashCode()); } From 571333f75a3270a4840da7c27a713dda94dd7790 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 13 Apr 2023 23:46:38 -0700 Subject: [PATCH 113/709] Add spurious dependency example. --- test/C/src/federated/SpuriousDependency.lf | 33 ++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 test/C/src/federated/SpuriousDependency.lf diff --git a/test/C/src/federated/SpuriousDependency.lf b/test/C/src/federated/SpuriousDependency.lf new file mode 100644 index 0000000000..fefadc4617 --- /dev/null +++ b/test/C/src/federated/SpuriousDependency.lf @@ -0,0 +1,33 @@ +target C + +reactor Passthrough { + input in: int + output out: int + reaction(in) -> out {= + lf_print("Hello from passthrough"); + lf_set(out, in->value); + =} +} + +reactor Twisty { + input in0: int + input in1: int + output out0: int + output out1: int + p0 = new Passthrough() + p1 = new Passthrough() + in0 -> p0.in + p0.out -> out0 + in1 -> p1.in + p1.out -> out1 +} + +federated reactor { + t0 = new Twisty() + t1 = new Twisty() + t0.out1 -> t1.in0 + t1.out1 -> t0.in0 + reaction(startup) -> t0.in1 {= + lf_set(t0.in1, 0); + =} +} From 5773b8919f46cb2590adb0516ae4e32696314712 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Fri, 14 Apr 2023 00:30:20 -0700 Subject: [PATCH 114/709] created check for runtime, and removed local one for each class --- .../org/lflang/generator/GeneratorBase.java | 24 +++++++++++++++++++ .../org/lflang/generator/c/CGenerator.java | 9 ++++++- .../generator/python/PythonGenerator.java | 1 + 3 files changed, 33 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index ba39a94d9f..ac141b9259 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -165,6 +165,12 @@ public abstract class GeneratorBase extends AbstractLFValidator { */ public boolean hasDeadlines = false; + /** + * Indicates whether the program has any watchdogs. + * This is used to check for support. + */ + public boolean hasWatchdogs = false; + // ////////////////////////////////////////// // // Private fields. @@ -293,6 +299,10 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { // Check for existence and support of modes hasModalReactors = IterableExtensions.exists(reactors, it -> !it.getModes().isEmpty()); checkModalReactorSupport(false); + + // Check for the existence and support of watchdogs + hasWatchdogs = IterableExtensions.exists(reactors, it -> !it.getWatchdogs().isEmpty()); + checkWatchdogSupport(targetConfig.threading && getTarget() == Target.C); additionalPostProcessingForModes(); } @@ -429,6 +439,20 @@ protected void checkModalReactorSupport(boolean isSupported) { } } + /** + * Checks whether watchdogs are present and are supported. + * @param isSupported indicates whether or not this is a supported target + * and whether or not it is a threaded runtime. + */ + protected void checkWatchdogSupport(boolean isSupported) { + if (hasWatchdogs && !isSupported) { + errorReporter.reportError( + "Watchdogs are currently only supported for threaded programs in the C target." + ); + } + } + + /** * Finds and transforms connections into forwarding reactions iff the connections have the same destination as other * connections or reaction in mutually exclusive modes. diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 5e94fe55fb..07d77cdbd5 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -446,6 +446,7 @@ protected boolean isOSCompatible() { /** Returns false if watchdogs exist and are * unsupported in this context. * Otherwise, return true. + * (DEPRECATED) Alternative implemented in GeneratorBase */ protected boolean isWatchdogCompatible() { if (hasWatchdogs() && !targetConfig.threading) { @@ -454,6 +455,12 @@ protected boolean isWatchdogCompatible() { ); return false; } + if (hasWatchdogs() && CCppMode) { + //FIXME: check to see if watchdogs work in CCppMode cases + errorReporter.reportError( + "Watchdogs are not currently supported in the CCpp target." + ); + } return true; } @@ -471,7 +478,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { super.doGenerate(resource, context); if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; if (!isOSCompatible()) return; // Incompatible OS and configuration - if (!isWatchdogCompatible()) return; + // if (!isWatchdogCompatible()) return; // Perform set up that does not generate code setUpGeneralParameters(); diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 3f82f20016..2767a05b9c 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -62,6 +62,7 @@ import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; +import org.lflang.lf.Watchdog; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; import org.lflang.util.StringUtil; From 801a3321e1ad86833de3c695af6133c5e2d55097 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Fri, 14 Apr 2023 17:10:56 +0900 Subject: [PATCH 115/709] Test SimpleFederatedAuthenticatd CI test --- .../C/src/federated/{failing => }/SimpleFederatedAuthenticated.lf | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/C/src/federated/{failing => }/SimpleFederatedAuthenticated.lf (100%) diff --git a/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf b/test/C/src/federated/SimpleFederatedAuthenticated.lf similarity index 100% rename from test/C/src/federated/failing/SimpleFederatedAuthenticated.lf rename to test/C/src/federated/SimpleFederatedAuthenticated.lf From ee610f060f679fc74f275888999071e31070ed6b Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Fri, 14 Apr 2023 16:22:25 +0500 Subject: [PATCH 116/709] [C-Generics] Contained Generic Reactor Update to support Templated Initialization of Generic Contained Reactor with `typeArgs` from Parent Reactor Signed-off-by: mkhubaibumer --- org.lflang/src/org/lflang/ASTUtils.java | 16 +++++++ .../org/lflang/generator/ReactorInstance.java | 2 +- .../org/lflang/generator/c/CGenerator.java | 45 ++++++++++++++----- .../c/CReactorHeaderFileGenerator.java | 4 +- .../src/org/lflang/generator/c/CUtil.java | 8 +--- .../generator/c/TypeParameterizedReactor.java | 5 ++- .../python/PythonReactionGenerator.java | 12 ++--- 7 files changed, 63 insertions(+), 29 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 558e262a59..8f3cb710aa 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -60,6 +60,7 @@ import org.lflang.generator.InvalidSourceException; import org.lflang.generator.NamedInstance; import org.lflang.generator.ReactorInstance; +import org.lflang.generator.c.CUtil; import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; import org.lflang.lf.Assignment; @@ -381,6 +382,21 @@ public static List allInstantiations(Reactor definition) { return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); } + /** + * Given a reactor Class, returns a set of include names for + * interacting reactors which includes all instantiations of base class that it extends + * + * @param r Reactor Class + * */ + public static HashSet allIncludes(Reactor r) { + var set = new HashSet(); + for (var i : allInstantiations(r)) + { + set.add(CUtil.getName(ReactorInstance.getReactorInstance(ASTUtils.toDefinition(i.getReactorClass()), i.getName()).tpr)); + } + return set; + } + public static List allChildInstances(Reactor definition, ErrorReporter reporter) { return allInstantiations(definition).stream().map(it -> new ReactorInstance( it, diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index f0211ab22e..ccde52a1ff 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -158,7 +158,7 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re /** Indicator that this reactor has itself as a parent, an error condition. */ public final boolean recursive; - public final TypeParameterizedReactor tpr; + public TypeParameterizedReactor tpr; /** HashMap containing {@link ReactorInstance} against hashCode achievable from Reactor */ private static final HashMap gReactorInstancesMap = new HashMap<>(); diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index abbaee4428..0a1c0d69cc 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -39,9 +39,11 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import java.util.HashMap; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; +import java.util.Map; import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -94,11 +96,13 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; +import org.lflang.lf.Type; import org.lflang.lf.Variable; import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; import com.google.common.base.Objects; +import com.google.common.collect.ImmutableMap; import com.google.common.collect.Iterables; /** @@ -922,12 +926,39 @@ public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { private void generateReactorDefinitions() throws IOException { var generatedReactors = new LinkedHashSet(); if (this.main != null) { + resolveTemplatedTypes(this.main, this.main.tpr); generateReactorChildren(this.main, generatedReactors); generateReactorClass(this.main.getTypeParameterizedReactor()); } // do not generate code for reactors that are not instantiated } + /** + * Recursively Resolve all Templated Types of child Reactors to their respective + * concrete types + * + * @param reactorInstance The Reactor Class + * @param parentTpr {@link TypeParameterizedReactor} of Parent + * */ + private void resolveTemplatedTypes(ReactorInstance reactorInstance, TypeParameterizedReactor parentTpr) { + for (var child : reactorInstance.children) { + if (parentTpr.typeArgs() != null) { + Map copy = new HashMap<>(); + child.tpr.typeArgs().forEach((literal, typename) -> { + var type = typename.getId(); + if (parentTpr.typeArgs().containsKey(type)) { + var basicType = parentTpr.typeArgs().get(type); + copy.put(literal, basicType); + } + }); + if (!copy.isEmpty()) { // If we found some templated-types update the tpr with new map + child.tpr = new TypeParameterizedReactor(child.tpr.r(), copy); + } + resolveTemplatedTypes(child, child.tpr); + } + } + } + private void generateHeaders() throws IOException { // Cannot delete existing header files directory because this would create a race condition in fed-gen FileUtil.copyDirectoryFromClassPath( @@ -935,9 +966,7 @@ private void generateHeaders() throws IOException { fileConfig.getIncludePath(), false ); -// for (var r : reactors) { - CReactorHeaderFileGenerator.doGenerate(types, this.main.tpr, fileConfig, this::generateAuxiliaryStructs, this::generateTopLevelPreambles); -// } + CReactorHeaderFileGenerator.doGenerate(types, this.main.tpr, fileConfig, this::generateAuxiliaryStructs, this::generateTopLevelPreambles); FileUtil.copyDirectory(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); } @@ -1030,7 +1059,6 @@ private void generateReactorClass(TypeParameterizedReactor tpr) throws IOExcepti header.pr(generateTopLevelPreambles(tpr.r())); generateUserPreamblesForReactor(tpr.r(), src); generateReactorClassBody(tpr, header, src); - tpr.typeArgs().entrySet().forEach(it -> header.pr("#undef " + it.getKey())); header.pr("#endif // " + guardMacro); FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" @@ -1060,10 +1088,8 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String "#undef " + literal + "\n" + "#endif // " + literal + "\n" + "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); - new HashSet<>(ASTUtils.allInstantiations(tpr.r())).stream() - .map(TypeParameterizedReactor::new).map(CUtil::getName) - .map(name -> "#include \"" + name + ".h\"") - .forEach(header::pr); + ASTUtils.allIncludes(tpr.r()).stream().map(name -> "#include \"" + + name + ".h\"").forEach(header::pr); } private void generateReactorClassBody(TypeParameterizedReactor tpr, CodeBuilder header, CodeBuilder src) { @@ -1652,9 +1678,6 @@ public void processProtoFile(String filename) { public static String variableStructType(Variable variable, TypeParameterizedReactor tpr, boolean userFacing) { return (userFacing ? tpr.getName().toLowerCase() : CUtil.getName(tpr)) +"_"+variable.getName()+"_t"; } - public static String variableStructType(Variable variable, Reactor r, boolean userFacing) { - return (userFacing ? r.getName().toLowerCase() : CUtil.getName(r)) +"_"+variable.getName()+"_t"; - } /** * Construct a unique type for the struct of the specified diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 6bdb08f5a9..88a9e2e6cb 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -40,7 +40,7 @@ public static void doGenerate(CTypes types, TypeParameterizedReactor tpr, CFileC } private static String generateHeaderFile(CTypes types, TypeParameterizedReactor tpr, GenerateAuxiliaryStructs generator, String topLevelPreamble) { CodeBuilder builder = new CodeBuilder(); - appendIncludeGuard(builder, tpr.r()); + appendIncludeGuard(builder, tpr); builder.pr(topLevelPreamble); appendPoundIncludes(builder); appendSelfStruct(builder, types, tpr); @@ -52,7 +52,7 @@ private static String generateHeaderFile(CTypes types, TypeParameterizedReactor return builder.getCode(); } - private static void appendIncludeGuard(CodeBuilder builder, Reactor r) { + private static void appendIncludeGuard(CodeBuilder builder, TypeParameterizedReactor r) { String macro = CUtil.getName(r) + "_H"; builder.pr("#ifndef " + macro); builder.pr("#define " + macro); diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 3cae52d931..9bfac8e7ba 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -28,6 +28,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.io.File; import java.io.IOException; +import java.math.BigInteger; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; @@ -154,13 +155,6 @@ public static String getName(TypeParameterizedReactor reactor) { } return name; } - public static String getName(Reactor reactor) { - String name = reactor.getName().toLowerCase() + reactor.hashCode(); - if (reactor.isMain()) { - return name + "_main"; - } - return name; - } /** * Return a reference to the specified port. diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index df5cd4444b..c04e1ac247 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -18,14 +18,15 @@ public TypeParameterizedReactor(Instantiation i) { this(ASTUtils.toDefinition(i.getReactorClass()), addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()))); } - private static ImmutableMap addTypeArgs(Instantiation instantiation, Reactor r) { + + private static Map addTypeArgs(Instantiation instantiation, Reactor r) { HashMap ret = new HashMap<>(); if (instantiation.getTypeArgs() != null) { for (int i = 0; i < r.getTypeParms().size(); i++) { ret.put(r.getTypeParms().get(i).getLiteral(), instantiation.getTypeArgs().get(i)); } } - return ImmutableMap.copyOf(ret); + return ret; // ImmutableMap.copyOf(ret); } public String getName() { diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java index 62dd65ff5f..e7bf570385 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java @@ -40,7 +40,7 @@ public class PythonReactionGenerator { * @param reactionIndex The index of the reaction * @param pyObjects CPython related objects */ - public static String generateCPythonReactionCaller(Reactor reactor, + public static String generateCPythonReactionCaller(TypeParameterizedReactor reactor, int reactionIndex, List pyObjects, String inits) { @@ -55,7 +55,7 @@ public static String generateCPythonReactionCaller(Reactor reactor, * @param reactionIndex The index of the reaction * @param pyObjects CPython related objects */ - public static String generateCPythonDeadlineCaller(Reactor r, + public static String generateCPythonDeadlineCaller(TypeParameterizedReactor r, int reactionIndex, List pyObjects) { String pythonFunctionName = generatePythonDeadlineFunctionName(reactionIndex); @@ -69,7 +69,7 @@ public static String generateCPythonDeadlineCaller(Reactor r, * @param reactionIndex The index of the reaction * @param pyObjects CPython related objects */ - public static String generateCPythonSTPCaller(Reactor r, + public static String generateCPythonSTPCaller(TypeParameterizedReactor r, int reactionIndex, List pyObjects) { String pythonFunctionName = generatePythonSTPFunctionName(reactionIndex); @@ -150,7 +150,7 @@ public static String generateCReaction( code.pr(generateFunction( CReactionGenerator.generateReactionFunctionHeader(tpr, reactionIndex), cInit, reaction.getCode(), - generateCPythonReactionCaller(r, reactionIndex, pyObjects, cPyInit) + generateCPythonReactionCaller(tpr, reactionIndex, pyObjects, cPyInit) )); // Generate code for the STP violation handler, if there is one. @@ -158,7 +158,7 @@ public static String generateCReaction( code.pr(generateFunction( CReactionGenerator.generateStpFunctionHeader(tpr, reactionIndex), cInit, reaction.getStp().getCode(), - generateCPythonSTPCaller(r, reactionIndex, pyObjects) + generateCPythonSTPCaller(tpr, reactionIndex, pyObjects) )); } // Generate code for the deadline violation function, if there is one. @@ -166,7 +166,7 @@ public static String generateCReaction( code.pr(generateFunction( CReactionGenerator.generateDeadlineFunctionHeader(tpr, reactionIndex), cInit, reaction.getDeadline().getCode(), - generateCPythonDeadlineCaller(r, reactionIndex, pyObjects) + generateCPythonDeadlineCaller(tpr, reactionIndex, pyObjects) )); } code.pr( From e066c099ecbd2e6746ac528106a3c88b82b031db Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Fri, 14 Apr 2023 17:50:01 +0500 Subject: [PATCH 117/709] Cosmetic Changes and Cleanup --- org.lflang/src/org/lflang/generator/ReactorInstance.java | 5 +---- org.lflang/src/org/lflang/generator/c/CGenerator.java | 8 ++++---- .../src/org/lflang/generator/c/CReactionGenerator.java | 9 ++++----- .../lflang/generator/c/CReactorHeaderFileGenerator.java | 2 +- org.lflang/src/org/lflang/generator/c/CUtil.java | 2 +- .../org/lflang/generator/c/TypeParameterizedReactor.java | 4 +--- .../lflang/generator/python/PythonReactionGenerator.java | 8 +++----- 7 files changed, 15 insertions(+), 23 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index ccde52a1ff..7dcf7ee330 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -1185,9 +1185,6 @@ private void setInitialWidth() { */ public boolean isGeneratedDelay() { // FIXME: hacky string matching again... - if (this.definition.getReactorClass().getName().contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME)) { - return true; - } - return false; + return this.definition.getReactorClass().getName().contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME); } } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 0a1c0d69cc..4d628de5b4 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -344,10 +344,10 @@ public class CGenerator extends GeneratorBase { /** * Extra lines that need to go into the generated CMakeLists.txt. */ - private String cMakeExtras = ""; + private final String cMakeExtras = ""; /** Place to collect code to execute at the start of a time step. */ - private CodeBuilder startTimeStep = new CodeBuilder(); + private final CodeBuilder startTimeStep = new CodeBuilder(); /** Count of the number of token pointers that need to have their * reference count decremented in _lf_start_time_step(). @@ -515,7 +515,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { try { var dockerData = getDockerGenerator(context).generateDockerData(); dockerData.writeDockerFile(); - (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); + new DockerComposeGenerator(context).writeDockerComposeFile(List.of(dockerData)); } catch (IOException e) { throw new RuntimeException("Error while writing Docker files", e); } @@ -1949,7 +1949,7 @@ protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { // Perform set up that does not generate code protected void setUpGeneralParameters() { accommodatePhysicalActionsIfPresent(); - targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); + targetConfig.compileDefinitions.put("LOG_LEVEL", String.valueOf(targetConfig.logLevel.ordinal())); targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); // Create the main reactor instance if there is a main reactor. createMainReactorInstance(); diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index ead750738d..8287fdfc80 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -216,7 +216,7 @@ public static String generateInitializationForReaction(String body, } code.pr(String.join("\n", "struct "+containedReactorType.getName()+" {", - " "+fieldsForStructsForContainedReactors.get(containedReactor)+"", + " "+fieldsForStructsForContainedReactors.get(containedReactor), "} "+containedReactorType.getName()+array+";" )); } @@ -697,8 +697,7 @@ public static void generateReactionAndTriggerStructs( // Create the map of triggers to reactions. for (TriggerRef trigger : reaction.getTriggers()) { // trigger may not be a VarRef (it could be "startup" or "shutdown"). - if (trigger instanceof VarRef) { - var triggerAsVarRef = (VarRef) trigger; + if (trigger instanceof VarRef triggerAsVarRef) { var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); if (reactionList == null) { reactionList = new LinkedList<>(); @@ -811,9 +810,9 @@ public static void generateReactionAndTriggerStructs( // self->_lf__"+action.getName()+".is_timer = false; constructorCode.pr(String.join("\n", "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", - (!(action.getPolicy() == null || action.getPolicy().isEmpty()) ? + !(action.getPolicy() == null || action.getPolicy().isEmpty()) ? "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" : - ""), + "", // Need to set the element_size in the trigger_t and the action struct. "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize + ";", diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 88a9e2e6cb..9cef515dba 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -95,7 +95,7 @@ private static void appendSignature(CodeBuilder builder, CTypes types, Reaction private static String reactionParameters(CTypes types, Reaction r, TypeParameterizedReactor tpr) { return Stream.concat(Stream.of(userFacingSelfType(tpr) + "* self"), ioTypedVariableStream(r) - .map((tv) -> tpr.getName().toLowerCase() + "_" + tv.getName() + "_t* " + tv.getName())) + .map(tv -> tpr.getName().toLowerCase() + "_" + tv.getName() + "_t* " + tv.getName())) .collect(Collectors.joining(", ")); } diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 9bfac8e7ba..b53298d5b9 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -853,7 +853,7 @@ private static List multiportWidthTerms(Variable variable) { if (term.getParameter() != null) { result.add(getTargetReference(term.getParameter())); } else { - result.add("" + term.getWidth()); + result.add(String.valueOf(term.getWidth())); } } } diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index c04e1ac247..1a9ac13761 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -10,8 +10,6 @@ import org.lflang.lf.Reactor; import org.lflang.lf.Type; -import com.google.common.collect.ImmutableMap; - public record TypeParameterizedReactor(Reactor r, Map typeArgs) { public TypeParameterizedReactor(Instantiation i) { @@ -26,7 +24,7 @@ private static Map addTypeArgs(Instantiation instantiation, Reacto ret.put(r.getTypeParms().get(i).getLiteral(), instantiation.getTypeArgs().get(i)); } } - return ret; // ImmutableMap.copyOf(ret); + return ret; } public String getName() { diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java index e7bf570385..8ea44b2a2f 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java @@ -209,8 +209,7 @@ private static String generateCPythonInitializers(Reaction reaction, // Next, add the triggers (input and actions; timers are not needed). // TODO: handle triggers for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { - if (trigger instanceof VarRef) { - VarRef triggerAsVarRef = (VarRef) trigger; + if (trigger instanceof VarRef triggerAsVarRef) { code.pr(generateVariableToSendPythonReaction(triggerAsVarRef, actionsAsTriggers, decl, pyObjects)); } } @@ -274,14 +273,13 @@ public static void generatePythonReactionParametersAndInitializations(List Date: Fri, 14 Apr 2023 20:55:49 +0500 Subject: [PATCH 118/709] [C-Generics] Resolve Templated-Typed Pointers Converted the Context Manager to Generic This required us to seperate the Templated-Types Pointers from their Tokens( * OR [] ) This commit fixes these issue and the GenericContextManager is now available in our Repo Signed-off-by: mkhubaibumer --- .../src/org/lflang/generator/c/CUtil.java | 30 ++++++-- org.lflang/src/org/lflang/util/Pair.java | 77 +++++++++++++++++++ 2 files changed, 101 insertions(+), 6 deletions(-) create mode 100644 org.lflang/src/org/lflang/util/Pair.java diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index b53298d5b9..49357161a5 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -28,7 +28,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.io.File; import java.io.IOException; -import java.math.BigInteger; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; @@ -39,7 +38,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Objects; import java.util.stream.Collectors; -import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.InferredType; @@ -55,12 +53,12 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Parameter; import org.lflang.lf.Port; import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.lf.WidthTerm; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; +import org.lflang.util.Pair; /** * A collection of utilities for C code generation. @@ -876,6 +874,21 @@ public static boolean isTokenType(InferredType type, CTypes types) { return type.isVariableSizeList || targetType.trim().endsWith("*"); } + /** + * Given a String str separate the Typename from tokens (* OR []) + * + * @param str Input String + * @return {@link Pair} of Typename and Tokens + * */ + public static Pair separateTokensFromTypes(String str) { + var starIdx = str.indexOf("*"); + if (starIdx == -1) { + var idx = str.indexOf("["); + return idx == -1 ? new Pair<>(str, "") : new Pair<>(str.substring(0, idx), str.substring(idx)); + } + return new Pair<>(str.substring(0, starIdx), str.substring(starIdx)); + } + /** * Given a type we need to check if the type is Generic Type literal and if * it is we need to find the corresponding concrete type @@ -886,14 +899,19 @@ public static boolean isTokenType(InferredType type, CTypes types) { public static String getConcreteType(TypeParameterizedReactor tpr, final String type) { if (tpr == null) return type; - var wrapper = new Object() { String concreteType = ""; }; + + var wrapper = new Object() { + String concreteType = ""; + final Pair inPair = separateTokensFromTypes(type); + }; tpr.typeArgs().forEach((literal, concreteType) -> { - if (type.equals(literal)) + if (wrapper.inPair.getFirst().equals(literal)) { wrapper.concreteType = String.valueOf(concreteType.getId()); } }); - return (wrapper.concreteType.isEmpty()) ? type : wrapper.concreteType; + + return wrapper.concreteType.isEmpty() ? type : wrapper.concreteType + wrapper.inPair.getSecond(); } public static String generateWidthVariable(String var) { diff --git a/org.lflang/src/org/lflang/util/Pair.java b/org.lflang/src/org/lflang/util/Pair.java new file mode 100644 index 0000000000..9e237104d3 --- /dev/null +++ b/org.lflang/src/org/lflang/util/Pair.java @@ -0,0 +1,77 @@ +/** + * @file + * @author Muhammad Khubaib Umer (khubaib@magnition.io) + * + * @section LICENSE +Copyright (c) 2023, MagnitionIO +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. +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * @section DESCRIPTION + * + * This Class provides a Pair of Templated Types + * This provides the same facility as std::pair in C++ + */ + +package org.lflang.util; + +public final class Pair { + private final T first; + private final U second; + public Pair(final T t, final U u) + { + this.first = t; + this.second = u; + } + + public T getFirst() + { + return this.first; + } + + public U getSecond() + { + return this.second; + } + + @Override + public boolean equals(Object other) { + if (other == null) + return false; + if (this == other) + return true; + if (this.getClass().equals(other.getClass())) { + Pair otherPair = (Pair) other; + boolean isEqual = (first == null) ? otherPair.getFirst() == null : first.equals(otherPair.getFirst()); + + if (!isEqual) + return false; + + return (second == null) ? otherPair.getSecond() == null : second.equals(otherPair.getSecond()); + } + return false; + } + + @Override + public int hashCode() { + return first == null ? 0 : first.hashCode() + 27 * (second == null ? 0 : second.hashCode()); + } + + @Override + public String toString() { + return "Pair(" + first + ", " + second + ")"; + } +} From 9e9aac73566ec2903440900b5049121d9e8aff17 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Fri, 14 Apr 2023 09:47:47 -0700 Subject: [PATCH 119/709] saving changes before merging --- org.lflang/src/org/lflang/ASTUtils.java | 3278 +++++++------- org.lflang/src/org/lflang/ast/IsEqual.java | 1203 +++-- org.lflang/src/org/lflang/ast/ToLf.java | 6 +- .../federated/generator/FederateInstance.java | 1121 +++-- .../org/lflang/generator/GeneratorBase.java | 1152 +++-- .../org/lflang/generator/ReactorInstance.java | 2108 +++++---- .../lflang/generator/WatchdogInstance.java | 84 +- .../org/lflang/generator/c/CGenerator.java | 3975 ++++++++--------- .../generator/c/CReactionGenerator.java | 2334 +++++----- .../generator/c/CWatchdogGenerator.java | 410 +- .../generator/python/PythonGenerator.java | 1093 +++-- .../lflang/scoping/LFScopeProviderImpl.java | 437 +- .../org/lflang/validation/LFValidator.java | 3343 +++++++------- test/C/src/file0.lf | 40 - test/C/src/file1.lf | 40 - test/C/src/file2.lf | 40 - 16 files changed, 10269 insertions(+), 10395 deletions(-) delete mode 100644 test/C/src/file0.lf delete mode 100644 test/C/src/file1.lf delete mode 100644 test/C/src/file2.lf diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index f9767e7e9a..46b913eee0 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -25,6 +25,9 @@ package org.lflang; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Iterators; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; @@ -39,7 +42,6 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; - import org.eclipse.emf.common.util.EList; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EStructuralFeature; @@ -87,1730 +89,1652 @@ import org.lflang.lf.Type; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; - import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; import org.lflang.util.StringUtil; -import com.google.common.collect.HashMultimap; -import com.google.common.collect.Iterables; -import com.google.common.collect.Iterators; - /** * A helper class for modifying and analyzing the AST. + * * @author Marten Lohstroh * @author Edward A. Lee * @author Christian Menard */ public class ASTUtils { - /** - * The Lingua Franca factory for creating new AST nodes. - */ - public static final LfFactory factory = LfFactory.eINSTANCE; - - /** - * The Lingua Franca feature package. - */ - public static final LfPackage featurePackage = LfPackage.eINSTANCE; - - /* Match an abbreviated form of a float literal. */ - private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); - - /** - * A mapping from Reactor features to corresponding Mode features for collecting contained elements. - */ - private static final Map reactorModeFeatureMap = Map.of( - featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), - featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), - featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), - featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), - featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), - featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), - featurePackage.getReactor_Watchdogs(), featurePackage.getMode_Watchdogs() - ); - - - /** - * Get all reactors defined in the given resource. - * @param resource the resource to extract reactors from - * @return An iterable over all reactors found in the resource - */ - public static List getAllReactors(Resource resource) { - return StreamSupport.stream(IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) - .filter(Reactor.class::isInstance) - .map(Reactor.class::cast) - .collect(Collectors.toList()); - } - - /** - * Find connections in the given resource that would be conflicting writes if they were not located in mutually - * exclusive modes. - * - * @param resource The AST. - * @return a list of connections being able to be transformed - */ - public static Collection findConflictingConnectionsInModalReactors(Resource resource) { - var transform = new HashSet(); - - for (Reactor reactor : getAllReactors(resource)) { - if (!reactor.getModes().isEmpty()) { // Only for modal reactors - var allWriters = HashMultimap., EObject>create(); - - // Collect destinations - for (var rea : allReactions(reactor)) { - for (var eff : rea.getEffects()) { - if (eff.getVariable() instanceof Port) { - allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); - } - } - } - for (var con : ASTUtils.collectElements(reactor, featurePackage.getReactor_Connections(), false, true)) { - for (var port : con.getRightPorts()) { - allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); - } - } - - // Handle conflicting writers - for (var key : allWriters.keySet()) { - var writers = allWriters.get(key); - if (writers.size() > 1) { // has multiple sources - var writerModes = HashMultimap.create(); - // find modes - for (var writer : writers) { - if (writer.eContainer() instanceof Mode) { - writerModes.put((Mode) writer.eContainer(), writer); - } else { - writerModes.put(null, writer); - } - } - // Conflicting connection can only be handled if.. - if (!writerModes.containsKey(null) && // no writer is on root level (outside of modes) and... - writerModes.keySet().stream().map(writerModes::get).allMatch(writersInMode -> // all writers in a mode are either... - writersInMode.size() == 1 || // the only writer or... - writersInMode.stream().allMatch(w -> w instanceof Reaction) // all are reactions and hence ordered - )) { - // Add connections to transform list - writers.stream().filter(w -> w instanceof Connection).forEach(c -> transform.add((Connection) c)); - } - } - } + /** The Lingua Franca factory for creating new AST nodes. */ + public static final LfFactory factory = LfFactory.eINSTANCE; + + /** The Lingua Franca feature package. */ + public static final LfPackage featurePackage = LfPackage.eINSTANCE; + + /* Match an abbreviated form of a float literal. */ + private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); + + /** + * A mapping from Reactor features to corresponding Mode features for collecting contained + * elements. + */ + private static final Map reactorModeFeatureMap = + Map.of( + featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), + featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), + featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), + featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), + featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), + featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), + featurePackage.getReactor_Watchdogs(), featurePackage.getMode_Watchdogs()); + + /** + * Get all reactors defined in the given resource. + * + * @param resource the resource to extract reactors from + * @return An iterable over all reactors found in the resource + */ + public static List getAllReactors(Resource resource) { + return StreamSupport.stream( + IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) + .filter(Reactor.class::isInstance) + .map(Reactor.class::cast) + .collect(Collectors.toList()); + } + + /** + * Find connections in the given resource that would be conflicting writes if they were not + * located in mutually exclusive modes. + * + * @param resource The AST. + * @return a list of connections being able to be transformed + */ + public static Collection findConflictingConnectionsInModalReactors( + Resource resource) { + var transform = new HashSet(); + + for (Reactor reactor : getAllReactors(resource)) { + if (!reactor.getModes().isEmpty()) { // Only for modal reactors + var allWriters = HashMultimap., EObject>create(); + + // Collect destinations + for (var rea : allReactions(reactor)) { + for (var eff : rea.getEffects()) { + if (eff.getVariable() instanceof Port) { + allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); } + } } - - return transform; - } - - /** - * Return the enclosing reactor of an LF EObject in a reactor or mode. - * @param obj the LF model element - * @return the reactor or null - */ - public static Reactor getEnclosingReactor(EObject obj) { - if (obj.eContainer() instanceof Reactor) { - return (Reactor) obj.eContainer(); - } else if (obj.eContainer() instanceof Mode) { - return (Reactor) obj.eContainer().eContainer(); + for (var con : + ASTUtils.collectElements( + reactor, featurePackage.getReactor_Connections(), false, true)) { + for (var port : con.getRightPorts()) { + allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); + } } - return null; - } - /** - * Return the main reactor in the given resource if there is one, null otherwise. - */ - public static Reactor findMainReactor(Resource resource) { - return IteratorExtensions.findFirst( - Iterators.filter(resource.getAllContents(), Reactor.class), - Reactor::isMain - ); - } - - /** - * Find the main reactor and change it to a federated reactor. - * Return true if the transformation was successful (or the given resource - * already had a federated reactor); return false otherwise. - */ - public static boolean makeFederated(Resource resource) { - // Find the main reactor - Reactor r = findMainReactor(resource); - if (r == null) { - return false; - } - r.setMain(false); - r.setFederated(true); - return true; - } - - /** - * Change the target name to 'newTargetName'. - * For example, change C to CCpp. - */ - public static boolean changeTargetName(Resource resource, String newTargetName) { - targetDecl(resource).setName(newTargetName); - return true; - } - - /** - * Return the target of the file in which the given node lives. - */ - public static Target getTarget(EObject object) { - TargetDecl targetDecl = targetDecl(object.eResource()); - return Target.fromDecl(targetDecl); - } - - /** - * Add a new target property to the given resource. - * - * This also creates a config object if the resource does not yey have one. - * - * @param resource The resource to modify - * @param name Name of the property to add - * @param value Value to be assigned to the property - */ - public static boolean addTargetProperty(final Resource resource, final String name, final Element value) { - var config = targetDecl(resource).getConfig(); - if (config == null) { - config = LfFactory.eINSTANCE.createKeyValuePairs(); - targetDecl(resource).setConfig(config); - } - final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); - newProperty.setName(name); - newProperty.setValue(value); - config.getPairs().add(newProperty); - return true; - } - - /** - * Return true if the connection involves multiple ports on the left or right side of the connection, or - * if the port on the left or right of the connection involves a bank of reactors or a multiport. - * @param connection The connection. - */ - public static boolean hasMultipleConnections(Connection connection) { - if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { - return true; - } - VarRef leftPort = connection.getLeftPorts().get(0); - VarRef rightPort = connection.getRightPorts().get(0); - Instantiation leftContainer = leftPort.getContainer(); - Instantiation rightContainer = rightPort.getContainer(); - Port leftPortAsPort = (Port) leftPort.getVariable(); - Port rightPortAsPort = (Port) rightPort.getVariable(); - return leftPortAsPort.getWidthSpec() != null - || leftContainer != null && leftContainer.getWidthSpec() != null - || rightPortAsPort.getWidthSpec() != null - || rightContainer != null && rightContainer.getWidthSpec() != null; - } - - /** - * Produce a unique identifier within a reactor based on a - * given based name. If the name does not exists, it is returned; - * if does exist, an index is appended that makes the name unique. - * @param reactor The reactor to find a unique identifier within. - * @param name The name to base the returned identifier on. - */ - public static String getUniqueIdentifier(Reactor reactor, String name) { - LinkedHashSet vars = new LinkedHashSet<>(); - allActions(reactor).forEach(it -> vars.add(it.getName())); - allTimers(reactor).forEach(it -> vars.add(it.getName())); - allParameters(reactor).forEach(it -> vars.add(it.getName())); - allInputs(reactor).forEach(it -> vars.add(it.getName())); - allOutputs(reactor).forEach(it -> vars.add(it.getName())); - allStateVars(reactor).forEach(it -> vars.add(it.getName())); - allInstantiations(reactor).forEach(it -> vars.add(it.getName())); - - int index = 0; - String suffix = ""; - boolean exists = true; - while (exists) { - String id = name + suffix; - if (IterableExtensions.exists(vars, it -> it.equals(id))) { - suffix = "_" + index; - index++; - } else { - exists = false; + // Handle conflicting writers + for (var key : allWriters.keySet()) { + var writers = allWriters.get(key); + if (writers.size() > 1) { // has multiple sources + var writerModes = HashMultimap.create(); + // find modes + for (var writer : writers) { + if (writer.eContainer() instanceof Mode) { + writerModes.put((Mode) writer.eContainer(), writer); + } else { + writerModes.put(null, writer); + } } - } - return name + suffix; - } - - //////////////////////////////// - //// Utility functions for supporting inheritance and modes - - /** - * Given a reactor class, return a list of all its actions, - * which includes actions of base classes that it extends. - * This also includes actions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allActions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); - } - - /** - * Given a reactor class, return a list of all its connections, - * which includes connections of base classes that it extends. - * This also includes connections in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allConnections(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); - } - - /** - * Given a reactor class, return a list of all its inputs, - * which includes inputs of base classes that it extends. - * If the base classes include a cycle, where X extends Y and Y extends X, - * then return only the input defined in the base class. - * The returned list may be empty. - * @param definition Reactor class definition. - */ - public static List allInputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); - } - - /** - * Given a reactor class, return a list of all its instantiations, - * which includes instantiations of base classes that it extends. - * This also includes instantiations in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allInstantiations(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); - } - - /** - * Given a reactor class, return a list of all its methods, - * which includes methods of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allMethods(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); - } - - /** - * Given a reactor class, return a list of all its outputs, - * which includes outputs of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allOutputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); - } - - /** - * Given a reactor class, return a list of all its parameters, - * which includes parameters of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allParameters(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); - } - - /** - * Given a reactor class, return a list of all its reactions, - * which includes reactions of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allReactions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); - } - - /** - * Given a reactor class, return a list of all its watchdogs. - * @param definition Reactor class definition - * @return List - */ - public static List allWatchdogs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); - } - - /** - * Given a reactor class, return a list of all its state variables, - * which includes state variables of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allStateVars(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); - } - - /** - * Given a reactor class, return a list of all its timers, - * which includes timers of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allTimers(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); - } - - /** - * Given a reactor class, returns a list of all its modes, - * which includes modes of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allModes(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); - } - - /** - * Return all the superclasses of the specified reactor - * in deepest-first order. For example, if A extends B and C, and - * B and C both extend D, this will return the list [D, B, C, A]. - * Duplicates are removed. If the specified reactor does not extend - * any other reactor, then return an empty list. - * If a cycle is found, where X extends Y and Y extends X, or if - * a superclass is declared that is not found, then return null. - * @param reactor The specified reactor. - */ - public static LinkedHashSet superClasses(Reactor reactor) { - return superClasses(reactor, new LinkedHashSet<>()); - } - - /** - * Collect elements of type T from the class hierarchy and modes - * defined by a given reactor definition. - * @param definition The reactor definition. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - public static List collectElements(Reactor definition, EStructuralFeature feature) { - return ASTUtils.collectElements(definition, feature, true, true); - } - - /** - * Collect elements of type T contained in given reactor definition, including - * modes and the class hierarchy defined depending on configuration. - * @param definition The reactor definition. - * @param feature The structual model elements to collect. - * @param includeSuperClasses Whether to include elements in super classes. - * @param includeModes Whether to include elements in modes. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - @SuppressWarnings("unchecked") - public static List collectElements(Reactor definition, EStructuralFeature feature, boolean includeSuperClasses, boolean includeModes) { - List result = new ArrayList<>(); - - if (includeSuperClasses) { - // Add elements of elements defined in superclasses. - LinkedHashSet s = superClasses(definition); - if (s != null) { - for (Reactor superClass : s) { - result.addAll((EList) superClass.eGet(feature)); - } + // Conflicting connection can only be handled if.. + if (!writerModes.containsKey(null) + && // no writer is on root level (outside of modes) and... + writerModes.keySet().stream() + .map(writerModes::get) + .allMatch( + writersInMode -> // all writers in a mode are either... + writersInMode.size() == 1 + || // the only writer or... + writersInMode.stream() + .allMatch( + w -> + w + instanceof + Reaction) // all are reactions and hence ordered + )) { + // Add connections to transform list + writers.stream() + .filter(w -> w instanceof Connection) + .forEach(c -> transform.add((Connection) c)); } + } } - - // Add elements of the current reactor. - result.addAll((EList) definition.eGet(feature)); - - if (includeModes && reactorModeFeatureMap.containsKey(feature)) { - var modeFeature = reactorModeFeatureMap.get(feature); - // Add elements of elements defined in modes. - for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { - insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); - } + } + } + + return transform; + } + + /** + * Return the enclosing reactor of an LF EObject in a reactor or mode. + * + * @param obj the LF model element + * @return the reactor or null + */ + public static Reactor getEnclosingReactor(EObject obj) { + if (obj.eContainer() instanceof Reactor) { + return (Reactor) obj.eContainer(); + } else if (obj.eContainer() instanceof Mode) { + return (Reactor) obj.eContainer().eContainer(); + } + return null; + } + + /** Return the main reactor in the given resource if there is one, null otherwise. */ + public static Reactor findMainReactor(Resource resource) { + return IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), Reactor::isMain); + } + + /** + * Find the main reactor and change it to a federated reactor. Return true if the transformation + * was successful (or the given resource already had a federated reactor); return false otherwise. + */ + public static boolean makeFederated(Resource resource) { + // Find the main reactor + Reactor r = findMainReactor(resource); + if (r == null) { + return false; + } + r.setMain(false); + r.setFederated(true); + return true; + } + + /** Change the target name to 'newTargetName'. For example, change C to CCpp. */ + public static boolean changeTargetName(Resource resource, String newTargetName) { + targetDecl(resource).setName(newTargetName); + return true; + } + + /** Return the target of the file in which the given node lives. */ + public static Target getTarget(EObject object) { + TargetDecl targetDecl = targetDecl(object.eResource()); + return Target.fromDecl(targetDecl); + } + + /** + * Add a new target property to the given resource. + * + *

This also creates a config object if the resource does not yey have one. + * + * @param resource The resource to modify + * @param name Name of the property to add + * @param value Value to be assigned to the property + */ + public static boolean addTargetProperty( + final Resource resource, final String name, final Element value) { + var config = targetDecl(resource).getConfig(); + if (config == null) { + config = LfFactory.eINSTANCE.createKeyValuePairs(); + targetDecl(resource).setConfig(config); + } + final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); + newProperty.setName(name); + newProperty.setValue(value); + config.getPairs().add(newProperty); + return true; + } + + /** + * Return true if the connection involves multiple ports on the left or right side of the + * connection, or if the port on the left or right of the connection involves a bank of reactors + * or a multiport. + * + * @param connection The connection. + */ + public static boolean hasMultipleConnections(Connection connection) { + if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { + return true; + } + VarRef leftPort = connection.getLeftPorts().get(0); + VarRef rightPort = connection.getRightPorts().get(0); + Instantiation leftContainer = leftPort.getContainer(); + Instantiation rightContainer = rightPort.getContainer(); + Port leftPortAsPort = (Port) leftPort.getVariable(); + Port rightPortAsPort = (Port) rightPort.getVariable(); + return leftPortAsPort.getWidthSpec() != null + || leftContainer != null && leftContainer.getWidthSpec() != null + || rightPortAsPort.getWidthSpec() != null + || rightContainer != null && rightContainer.getWidthSpec() != null; + } + + /** + * Produce a unique identifier within a reactor based on a given based name. If the name does not + * exists, it is returned; if does exist, an index is appended that makes the name unique. + * + * @param reactor The reactor to find a unique identifier within. + * @param name The name to base the returned identifier on. + */ + public static String getUniqueIdentifier(Reactor reactor, String name) { + LinkedHashSet vars = new LinkedHashSet<>(); + allActions(reactor).forEach(it -> vars.add(it.getName())); + allTimers(reactor).forEach(it -> vars.add(it.getName())); + allParameters(reactor).forEach(it -> vars.add(it.getName())); + allInputs(reactor).forEach(it -> vars.add(it.getName())); + allOutputs(reactor).forEach(it -> vars.add(it.getName())); + allStateVars(reactor).forEach(it -> vars.add(it.getName())); + allInstantiations(reactor).forEach(it -> vars.add(it.getName())); + + int index = 0; + String suffix = ""; + boolean exists = true; + while (exists) { + String id = name + suffix; + if (IterableExtensions.exists(vars, it -> it.equals(id))) { + suffix = "_" + index; + index++; + } else { + exists = false; + } + } + return name + suffix; + } + + //////////////////////////////// + //// Utility functions for supporting inheritance and modes + + /** + * Given a reactor class, return a list of all its actions, which includes actions of base classes + * that it extends. This also includes actions in modes, returning a flattened view over all + * modes. + * + * @param definition Reactor class definition. + */ + public static List allActions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); + } + + /** + * Given a reactor class, return a list of all its connections, which includes connections of base + * classes that it extends. This also includes connections in modes, returning a flattened view + * over all modes. + * + * @param definition Reactor class definition. + */ + public static List allConnections(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); + } + + /** + * Given a reactor class, return a list of all its inputs, which includes inputs of base classes + * that it extends. If the base classes include a cycle, where X extends Y and Y extends X, then + * return only the input defined in the base class. The returned list may be empty. + * + * @param definition Reactor class definition. + */ + public static List allInputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); + } + + /** + * Given a reactor class, return a list of all its instantiations, which includes instantiations + * of base classes that it extends. This also includes instantiations in modes, returning a + * flattened view over all modes. + * + * @param definition Reactor class definition. + */ + public static List allInstantiations(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); + } + + /** + * Given a reactor class, return a list of all its methods, which includes methods of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allMethods(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); + } + + /** + * Given a reactor class, return a list of all its outputs, which includes outputs of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allOutputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); + } + + /** + * Given a reactor class, return a list of all its parameters, which includes parameters of base + * classes that it extends. + * + * @param definition Reactor class definition. + */ + public static List allParameters(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); + } + + /** + * Given a reactor class, return a list of all its reactions, which includes reactions of base + * classes that it extends. This also includes reactions in modes, returning a flattened view over + * all modes. + * + * @param definition Reactor class definition. + */ + public static List allReactions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); + } + + /** + * Given a reactor class, return a list of all its watchdogs. + * + * @param definition Reactor class definition + * @return List + */ + public static List allWatchdogs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); + } + + /** + * Given a reactor class, return a list of all its state variables, which includes state variables + * of base classes that it extends. This also includes reactions in modes, returning a flattened + * view over all modes. + * + * @param definition Reactor class definition. + */ + public static List allStateVars(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); + } + + /** + * Given a reactor class, return a list of all its timers, which includes timers of base classes + * that it extends. This also includes reactions in modes, returning a flattened view over all + * modes. + * + * @param definition Reactor class definition. + */ + public static List allTimers(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); + } + + /** + * Given a reactor class, returns a list of all its modes, which includes modes of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allModes(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); + } + + /** + * Return all the superclasses of the specified reactor in deepest-first order. For example, if A + * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates + * are removed. If the specified reactor does not extend any other reactor, then return an empty + * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared + * that is not found, then return null. + * + * @param reactor The specified reactor. + */ + public static LinkedHashSet superClasses(Reactor reactor) { + return superClasses(reactor, new LinkedHashSet<>()); + } + + /** + * Collect elements of type T from the class hierarchy and modes defined by a given reactor + * definition. + * + * @param definition The reactor definition. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + public static List collectElements( + Reactor definition, EStructuralFeature feature) { + return ASTUtils.collectElements(definition, feature, true, true); + } + + /** + * Collect elements of type T contained in given reactor definition, including modes and the class + * hierarchy defined depending on configuration. + * + * @param definition The reactor definition. + * @param feature The structual model elements to collect. + * @param includeSuperClasses Whether to include elements in super classes. + * @param includeModes Whether to include elements in modes. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + @SuppressWarnings("unchecked") + public static List collectElements( + Reactor definition, + EStructuralFeature feature, + boolean includeSuperClasses, + boolean includeModes) { + List result = new ArrayList<>(); + + if (includeSuperClasses) { + // Add elements of elements defined in superclasses. + LinkedHashSet s = superClasses(definition); + if (s != null) { + for (Reactor superClass : s) { + result.addAll((EList) superClass.eGet(feature)); } - - return result; - } - - /** - * Adds the elements into the given list at a location matching to their textual position. - * - * When creating a flat view onto reactor elements including modes, the final list must be ordered according - * to the textual positions. - * - * Example: - * reactor R { - * reaction // -> is R.reactions[0] - * mode M { - * reaction // -> is R.mode[0].reactions[0] - * reaction // -> is R.mode[0].reactions[1] - * } - * reaction // -> is R.reactions[1] - * } - * In this example, it is important that the reactions in the mode are inserted between the top-level - * reactions to retain the correct global reaction ordering, which will be derived from this flattened view. - * - * @param list The list to add the elements into. - * @param elements The elements to add. - * @param mode The mode containing the elements. - * @param The type of elements to add (e.g., Port, Timer, etc.) - */ - private static void insertModeElementsAtTextualPosition(List list, List elements, Mode mode) { - if (elements.isEmpty()) { - return; // Nothing to add - } - - var idx = list.size(); - if (idx > 0) { - // If there are elements in the list, first check if the last element has the same container as the mode. - // I.e. we don't want to compare textual positions of different reactors (super classes) - if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { - var modeAstNode = NodeModelUtils.getNode(mode); - if (modeAstNode != null) { - var modePos = modeAstNode.getOffset(); - // Now move the insertion index from the last element forward as long as this element has a textual - // position after the mode. - do { - var astNode = NodeModelUtils.getNode(list.get(idx - 1)); - if (astNode != null && astNode.getOffset() > modePos) { - idx--; - } else { - break; // Insertion index is ok. - } - } while (idx > 0); - } - } - } - list.addAll(idx, elements); - } - - public static Iterable allElementsOfClass( - Resource resource, - Class elementClass - ) { - //noinspection StaticPseudoFunctionalStyleMethod - return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); - } - - //////////////////////////////// - //// Utility functions for translating AST nodes into text - - // public static Code toCode(String text) { - // Code code = null; - // if (text == null) return code; - // code.setBody(text); - // return code; - // } - - /** - * Translate the given code into its textual representation - * with {@code CodeMap.Correspondence} tags inserted, or - * return the empty string if {@code node} is {@code null}. - * This method should be used to generate code. - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toText(EObject node) { - if (node == null) return ""; - return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); - } - - /** - * Translate the given code into its textual representation - * without {@code CodeMap.Correspondence} tags, or return - * the empty string if {@code node} is {@code null}. - * This method should be used for analyzing AST nodes in - * cases where they are easiest to analyze as strings. - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toOriginalText(EObject node) { - if (node == null) return ""; - return ToText.instance.doSwitch(node); - } - - /** - * Return an integer representation of the given element. - * - * Internally, this method uses Integer.decode, so it will - * also understand hexadecimal, binary, etc. - * - * @param e The element to be rendered as an integer. - */ - public static Integer toInteger(Element e) { - return Integer.decode(e.getLiteral()); - } - - /** - * Return a time value based on the given element. - * - * @param e The element to be rendered as a time value. - */ - public static TimeValue toTimeValue(Element e) { - return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); - } - - /** - * Returns the time value represented by the given AST node. - */ - public static TimeValue toTimeValue(Time e) { - if (!isValidTime(e)) { - // invalid unit, will have been reported by validator - throw new IllegalArgumentException(); - } - return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); - } - - /** - * Return a boolean based on the given element. - * - * @param e The element to be rendered as a boolean. - */ - public static boolean toBoolean(Element e) { - return elementToSingleString(e).equalsIgnoreCase("true"); - } - - /** - * Given the right-hand side of a target property, return a string that - * represents the given value/ - * - * If the given value is not a literal or and id (but for instance and array or dict), - * an empty string is returned. If the element is a string, any quotes are removed. - * - * @param e The right-hand side of a target property. - */ - public static String elementToSingleString(Element e) { - if (e.getLiteral() != null) { - return StringUtil.removeQuotes(e.getLiteral()).trim(); - } else if (e.getId() != null) { - return e.getId(); - } - return ""; - } - - /** - * Given the right-hand side of a target property, return a list with all - * the strings that the property lists. - * - * Arrays are traversed, so strings are collected recursively. Empty strings - * are ignored; they are not added to the list. - * @param value The right-hand side of a target property. - */ - public static List elementToListOfStrings(Element value) { - List elements = new ArrayList<>(); - if (value.getArray() != null) { - for (Element element : value.getArray().getElements()) { - elements.addAll(elementToListOfStrings(element)); - } - return elements; - } else { - String v = elementToSingleString(value); - if (!v.isEmpty()) { - elements.add(v); - } - } - return elements; - } - - /** - * Convert key-value pairs in an Element to a map, assuming that both the key - * and the value are strings. - */ - public static Map elementToStringMaps(Element value) { - Map elements = new HashMap<>(); - for (var element: value.getKeyvalue().getPairs()) { - elements.put( - element.getName().trim(), - StringUtil.removeQuotes(elementToSingleString(element.getValue())) - ); - } - return elements; - } - - // Various utility methods to convert various data types to Elements - - /** - * Convert a map to key-value pairs in an Element. - */ - public static Element toElement(Map map) { - Element e = LfFactory.eINSTANCE.createElement(); - if (map.size() == 0) return null; - else { - var kv = LfFactory.eINSTANCE.createKeyValuePairs(); - for (var entry : map.entrySet()) { - var pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(entry.getKey()); - var element = LfFactory.eINSTANCE.createElement(); - element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); - pair.setValue(element); - kv.getPairs().add(pair); - } - e.setKeyvalue(kv); - } - - return e; - } - - /** - * Given a single string, convert it into its AST representation. - * {@code addQuotes} controls if the generated representation should be - * accompanied by double quotes ("") or not. - */ - private static Element toElement(String str, boolean addQuotes) { - if (str == null) return null; - var strToReturn = addQuotes? StringUtil.addDoubleQuotes(str):str; - Element e = LfFactory.eINSTANCE.createElement(); - e.setLiteral(strToReturn); - return e; - - } - - /** - * Given a single string, convert it into its AST representation. - */ - public static Element toElement(String str) { - return toElement(str, true); - } - - /** - * Given a list of strings, convert it into its AST representation. - * Stores the list in the Array field of the element, unless the list only has one string, - * in which case it is stored in the Literal field. Returns null if the provided list is empty. - */ - public static Element toElement(List list) { - Element e = LfFactory.eINSTANCE.createElement(); - if (list.size() == 0) return null; - else if (list.size() == 1) { - return toElement(list.get(0)); - } else { - var arr = LfFactory.eINSTANCE.createArray(); - for (String s : list) { - arr.getElements().add(ASTUtils.toElement(s)); - } - e.setArray(arr); - } - return e; - } - - /** - * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit inside an Element. - */ - public static Element toElement(TimeValue tv) { - Element e = LfFactory.eINSTANCE.createElement(); - e.setTime((int)tv.time); - if (tv.unit != null) { - e.setUnit(tv.unit.toString()); - } - return e; - } - - public static Element toElement(boolean val) { - return toElement(Boolean.toString(val), false); - } - - public static Element toElement(int val) { - return toElement(Integer.toString(val), false); - } - - /** - * Translate the given type into its textual representation, but - * do not append any array specifications or type arguments. - * @param type AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String baseType(Type type) { - if (type != null) { - if (type.getCode() != null) { - return toText(type.getCode()); + } + } + + // Add elements of the current reactor. + result.addAll((EList) definition.eGet(feature)); + + if (includeModes && reactorModeFeatureMap.containsKey(feature)) { + var modeFeature = reactorModeFeatureMap.get(feature); + // Add elements of elements defined in modes. + for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { + insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); + } + } + + return result; + } + + /** + * Adds the elements into the given list at a location matching to their textual position. + * + *

When creating a flat view onto reactor elements including modes, the final list must be + * ordered according to the textual positions. + * + *

Example: reactor R { reaction // -> is R.reactions[0] mode M { reaction // -> is + * R.mode[0].reactions[0] reaction // -> is R.mode[0].reactions[1] } reaction // -> is + * R.reactions[1] } In this example, it is important that the reactions in the mode are inserted + * between the top-level reactions to retain the correct global reaction ordering, which will be + * derived from this flattened view. + * + * @param list The list to add the elements into. + * @param elements The elements to add. + * @param mode The mode containing the elements. + * @param The type of elements to add (e.g., Port, Timer, etc.) + */ + private static void insertModeElementsAtTextualPosition( + List list, List elements, Mode mode) { + if (elements.isEmpty()) { + return; // Nothing to add + } + + var idx = list.size(); + if (idx > 0) { + // If there are elements in the list, first check if the last element has the same container + // as the mode. + // I.e. we don't want to compare textual positions of different reactors (super classes) + if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { + var modeAstNode = NodeModelUtils.getNode(mode); + if (modeAstNode != null) { + var modePos = modeAstNode.getOffset(); + // Now move the insertion index from the last element forward as long as this element has + // a textual + // position after the mode. + do { + var astNode = NodeModelUtils.getNode(list.get(idx - 1)); + if (astNode != null && astNode.getOffset() > modePos) { + idx--; } else { - if (type.isTime()) { - return "time"; - } else { - StringBuilder result = new StringBuilder(type.getId()); - - for (String s : convertToEmptyListIfNull(type.getStars())) { - result.append(s); - } - return result.toString(); - } + break; // Insertion index is ok. } + } while (idx > 0); } - return ""; - } - - /** - * Report whether the given literal is zero or not. - * @param literal AST node to inspect. - * @return True if the given literal denotes the constant `0`, false - * otherwise. - */ - public static boolean isZero(String literal) { - try { - if (literal != null && - Integer.parseInt(literal) == 0) { - return true; - } - } catch (NumberFormatException e) { - // Not an int. - } - return false; - } - - /** - * Report whether the given expression is zero or not. - * - * @param expr AST node to inspect. - * @return True if the given value denotes the constant `0`, false otherwise. - */ - public static boolean isZero(Expression expr) { - if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; - } + } + } + list.addAll(idx, elements); + } + + public static Iterable allElementsOfClass( + Resource resource, Class elementClass) { + //noinspection StaticPseudoFunctionalStyleMethod + return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); + } + + //////////////////////////////// + //// Utility functions for translating AST nodes into text + + // public static Code toCode(String text) { + // Code code = null; + // if (text == null) return code; + // code.setBody(text); + // return code; + // } + + /** + * Translate the given code into its textual representation with {@code CodeMap.Correspondence} + * tags inserted, or return the empty string if {@code node} is {@code null}. This method should + * be used to generate code. + * + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toText(EObject node) { + if (node == null) return ""; + return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); + } + + /** + * Translate the given code into its textual representation without {@code CodeMap.Correspondence} + * tags, or return the empty string if {@code node} is {@code null}. This method should be used + * for analyzing AST nodes in cases where they are easiest to analyze as strings. + * + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toOriginalText(EObject node) { + if (node == null) return ""; + return ToText.instance.doSwitch(node); + } + + /** + * Return an integer representation of the given element. + * + *

Internally, this method uses Integer.decode, so it will also understand hexadecimal, binary, + * etc. + * + * @param e The element to be rendered as an integer. + */ + public static Integer toInteger(Element e) { + return Integer.decode(e.getLiteral()); + } + + /** + * Return a time value based on the given element. + * + * @param e The element to be rendered as a time value. + */ + public static TimeValue toTimeValue(Element e) { + return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); + } + + /** Returns the time value represented by the given AST node. */ + public static TimeValue toTimeValue(Time e) { + if (!isValidTime(e)) { + // invalid unit, will have been reported by validator + throw new IllegalArgumentException(); + } + return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); + } + + /** + * Return a boolean based on the given element. + * + * @param e The element to be rendered as a boolean. + */ + public static boolean toBoolean(Element e) { + return elementToSingleString(e).equalsIgnoreCase("true"); + } + + /** + * Given the right-hand side of a target property, return a string that represents the given + * value/ + * + *

If the given value is not a literal or and id (but for instance and array or dict), an empty + * string is returned. If the element is a string, any quotes are removed. + * + * @param e The right-hand side of a target property. + */ + public static String elementToSingleString(Element e) { + if (e.getLiteral() != null) { + return StringUtil.removeQuotes(e.getLiteral()).trim(); + } else if (e.getId() != null) { + return e.getId(); + } + return ""; + } + + /** + * Given the right-hand side of a target property, return a list with all the strings that the + * property lists. + * + *

Arrays are traversed, so strings are collected recursively. Empty strings are ignored; they + * are not added to the list. + * + * @param value The right-hand side of a target property. + */ + public static List elementToListOfStrings(Element value) { + List elements = new ArrayList<>(); + if (value.getArray() != null) { + for (Element element : value.getArray().getElements()) { + elements.addAll(elementToListOfStrings(element)); + } + return elements; + } else { + String v = elementToSingleString(value); + if (!v.isEmpty()) { + elements.add(v); + } + } + return elements; + } + + /** + * Convert key-value pairs in an Element to a map, assuming that both the key and the value are + * strings. + */ + public static Map elementToStringMaps(Element value) { + Map elements = new HashMap<>(); + for (var element : value.getKeyvalue().getPairs()) { + elements.put( + element.getName().trim(), + StringUtil.removeQuotes(elementToSingleString(element.getValue()))); + } + return elements; + } + + // Various utility methods to convert various data types to Elements + + /** Convert a map to key-value pairs in an Element. */ + public static Element toElement(Map map) { + Element e = LfFactory.eINSTANCE.createElement(); + if (map.size() == 0) return null; + else { + var kv = LfFactory.eINSTANCE.createKeyValuePairs(); + for (var entry : map.entrySet()) { + var pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(entry.getKey()); + var element = LfFactory.eINSTANCE.createElement(); + element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); + pair.setValue(element); + kv.getPairs().add(pair); + } + e.setKeyvalue(kv); + } + + return e; + } + + /** + * Given a single string, convert it into its AST representation. {@code addQuotes} controls if + * the generated representation should be accompanied by double quotes ("") or not. + */ + private static Element toElement(String str, boolean addQuotes) { + if (str == null) return null; + var strToReturn = addQuotes ? StringUtil.addDoubleQuotes(str) : str; + Element e = LfFactory.eINSTANCE.createElement(); + e.setLiteral(strToReturn); + return e; + } + + /** Given a single string, convert it into its AST representation. */ + public static Element toElement(String str) { + return toElement(str, true); + } + + /** + * Given a list of strings, convert it into its AST representation. Stores the list in the Array + * field of the element, unless the list only has one string, in which case it is stored in the + * Literal field. Returns null if the provided list is empty. + */ + public static Element toElement(List list) { + Element e = LfFactory.eINSTANCE.createElement(); + if (list.size() == 0) return null; + else if (list.size() == 1) { + return toElement(list.get(0)); + } else { + var arr = LfFactory.eINSTANCE.createArray(); + for (String s : list) { + arr.getElements().add(ASTUtils.toElement(s)); + } + e.setArray(arr); + } + return e; + } + + /** + * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit + * inside an Element. + */ + public static Element toElement(TimeValue tv) { + Element e = LfFactory.eINSTANCE.createElement(); + e.setTime((int) tv.time); + if (tv.unit != null) { + e.setUnit(tv.unit.toString()); + } + return e; + } + + public static Element toElement(boolean val) { + return toElement(Boolean.toString(val), false); + } + + public static Element toElement(int val) { + return toElement(Integer.toString(val), false); + } + + /** + * Translate the given type into its textual representation, but do not append any array + * specifications or type arguments. + * + * @param type AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String baseType(Type type) { + if (type != null) { + if (type.getCode() != null) { + return toText(type.getCode()); + } else { + if (type.isTime()) { + return "time"; + } else { + StringBuilder result = new StringBuilder(type.getId()); - /** - * Report whether the given string literal is an integer number or not. - * - * @param literal AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Integer.decode(literal); - } catch (NumberFormatException e) { - return false; + for (String s : convertToEmptyListIfNull(type.getStars())) { + result.append(s); + } + return result.toString(); } + } + } + return ""; + } + + /** + * Report whether the given literal is zero or not. + * + * @param literal AST node to inspect. + * @return True if the given literal denotes the constant `0`, false otherwise. + */ + public static boolean isZero(String literal) { + try { + if (literal != null && Integer.parseInt(literal) == 0) { return true; - } - - /** - * Report whether the given string literal is a boolean value or not. - * @param literal AST node to inspect. - * @return True if the given value is a boolean, false otherwise. - */ - public static boolean isBoolean(String literal) { - return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); - } - - /** - * Report whether the given string literal is a float value or not. - * @param literal AST node to inspect. - * @return True if the given value is a float, false otherwise. - */ - public static boolean isFloat(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Float.parseFloat(literal); - } catch (NumberFormatException e) { - return false; + } + } catch (NumberFormatException e) { + // Not an int. + } + return false; + } + + /** + * Report whether the given expression is zero or not. + * + * @param expr AST node to inspect. + * @return True if the given value denotes the constant `0`, false otherwise. + */ + public static boolean isZero(Expression expr) { + if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; + } + + /** + * Report whether the given string literal is an integer number or not. + * + * @param literal AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Integer.decode(literal); + } catch (NumberFormatException e) { + return false; + } + return true; + } + + /** + * Report whether the given string literal is a boolean value or not. + * + * @param literal AST node to inspect. + * @return True if the given value is a boolean, false otherwise. + */ + public static boolean isBoolean(String literal) { + return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); + } + + /** + * Report whether the given string literal is a float value or not. + * + * @param literal AST node to inspect. + * @return True if the given value is a float, false otherwise. + */ + public static boolean isFloat(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Float.parseFloat(literal); + } catch (NumberFormatException e) { + return false; + } + return true; + } + + /** + * Report whether the given code is an integer number or not. + * + * @param code AST node to inspect. + * @return True if the given code is an integer, false otherwise. + */ + public static boolean isInteger(Code code) { + return isInteger(toText(code)); + } + + /** + * Report whether the given expression is an integer number or not. + * + * @param expr AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(Expression expr) { + if (expr instanceof Literal) { + return isInteger(((Literal) expr).getLiteral()); + } else if (expr instanceof Code) { + return isInteger((Code) expr); + } + return false; + } + + /** + * Report whether the given expression denotes a valid time or not. + * + * @param expr AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Expression expr) { + if (expr instanceof ParameterReference) { + return isOfTimeType(((ParameterReference) expr).getParameter()); + } else if (expr instanceof Time) { + return isValidTime((Time) expr); + } else if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; + } + + /** + * Report whether the given time denotes a valid time or not. + * + * @param t AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Time t) { + if (t == null) return false; + String unit = t.getUnit(); + return t.getInterval() == 0 || TimeUnit.isValidUnit(unit); + } + + /** If the initializer contains exactly one expression, return it. Otherwise, return null. */ + public static Expression asSingleExpr(Initializer init) { + if (init == null) { + return null; + } + var exprs = init.getExprs(); + return exprs.size() == 1 ? exprs.get(0) : null; + } + + public static boolean isSingleExpr(Initializer init) { + // todo expand that to = initialization + if (init == null) { + return false; + } + var exprs = init.getExprs(); + return exprs.size() == 1; + } + + public static boolean isListInitializer(Initializer init) { + return init != null && !isSingleExpr(init); + } + + /** + * Return the type of a declaration with the given (nullable) explicit type, and the given + * (nullable) initializer. If the explicit type is null, then the type is inferred from the + * initializer. Only two types can be inferred: "time" and "timeList". Return the "undefined" type + * if neither can be inferred. + * + * @param type Explicit type declared on the declaration + * @param init The initializer expression + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Type type, Initializer init) { + if (type != null) { + return InferredType.fromAST(type); + } else if (init == null) { + return InferredType.undefined(); + } + + var single = asSingleExpr(init); + if (single != null) { + // If there is a single element in the list, and it is a proper + // time value with units, we infer the type "time". + if (single instanceof ParameterReference) { + return getInferredType(((ParameterReference) single).getParameter()); + } else if (single instanceof Time) { + return InferredType.time(); + } + } else if (init.getExprs().size() > 1) { + // If there are multiple elements in the list, and there is at + // least one proper time value with units, and all other elements + // are valid times (including zero without units), we infer the + // type "time list". + var allValidTime = true; + var foundNonZero = false; + + for (var e : init.getExprs()) { + if (!ASTUtils.isValidTime(e)) { + allValidTime = false; } - return true; - } - - /** - * Report whether the given code is an integer number or not. - * @param code AST node to inspect. - * @return True if the given code is an integer, false otherwise. - */ - public static boolean isInteger(Code code) { - return isInteger(toText(code)); - } - - /** - * Report whether the given expression is an integer number or not. - * @param expr AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(Expression expr) { - if (expr instanceof Literal) { - return isInteger(((Literal) expr).getLiteral()); - } else if (expr instanceof Code) { - return isInteger((Code) expr); + if (!ASTUtils.isZero(e)) { + foundNonZero = true; } - return false; - } - - /** - * Report whether the given expression denotes a valid time or not. - * @param expr AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Expression expr) { - if (expr instanceof ParameterReference) { - return isOfTimeType(((ParameterReference)expr).getParameter()); - } else if (expr instanceof Time) { - return isValidTime((Time) expr); - } else if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; - } - - /** - * Report whether the given time denotes a valid time or not. - * @param t AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Time t) { - if (t == null) return false; - String unit = t.getUnit(); - return t.getInterval() == 0 || - TimeUnit.isValidUnit(unit); - } - - /** - * If the initializer contains exactly one expression, - * return it. Otherwise, return null. - */ - public static Expression asSingleExpr(Initializer init) { - if (init == null) { - return null; - } - var exprs = init.getExprs(); - return exprs.size() == 1 ? exprs.get(0) : null; - } - - public static boolean isSingleExpr(Initializer init) { - // todo expand that to = initialization - if (init == null) { - return false; - } - var exprs = init.getExprs(); - return exprs.size() == 1; - } - - public static boolean isListInitializer(Initializer init) { - return init != null && !isSingleExpr(init); - } - - /** - * Return the type of a declaration with the given - * (nullable) explicit type, and the given (nullable) - * initializer. If the explicit type is null, then the - * type is inferred from the initializer. Only two types - * can be inferred: "time" and "timeList". Return the - * "undefined" type if neither can be inferred. - * - * @param type Explicit type declared on the declaration - * @param init The initializer expression - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Type type, Initializer init) { - if (type != null) { - return InferredType.fromAST(type); - } else if (init == null) { - return InferredType.undefined(); - } - - var single = asSingleExpr(init); - if (single != null) { - // If there is a single element in the list, and it is a proper - // time value with units, we infer the type "time". - if (single instanceof ParameterReference) { - return getInferredType(((ParameterReference) single).getParameter()); - } else if (single instanceof Time) { - return InferredType.time(); - } - } else if (init.getExprs().size() > 1) { - // If there are multiple elements in the list, and there is at - // least one proper time value with units, and all other elements - // are valid times (including zero without units), we infer the - // type "time list". - var allValidTime = true; - var foundNonZero = false; - - for (var e : init.getExprs()) { - if (!ASTUtils.isValidTime(e)) { - allValidTime = false; - } - if (!ASTUtils.isZero(e)) { - foundNonZero = true; - } - } - - if (allValidTime && foundNonZero) { - // Conservatively, no bounds are inferred; the returned type - // is a variable-size list. - return InferredType.timeList(); - } - } - return InferredType.undefined(); - } - - /** - * Given a parameter, return an inferred type. Only two types can be - * inferred: "time" and "timeList". Return the "undefined" type if - * neither can be inferred. - * - * @param p A parameter to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Parameter p) { - return getInferredType(p.getType(), p.getInit()); - } - - /** - * Given a state variable, return an inferred type. Only two types can be - * inferred: "time" and "timeList". Return the "undefined" type if - * neither can be inferred. - * - * @param s A state variable to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(StateVar s) { - return getInferredType(s.getType(), s.getInit()); - } - - /** - * Construct an inferred type from an "action" AST node based - * on its declared type. If no type is declared, return the "undefined" - * type. - * - * @param a An action to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Action a) { - return getInferredType(a.getType(), null); - } - - /** - * Construct an inferred type from a "port" AST node based on its declared - * type. If no type is declared, return the "undefined" type. - * - * @param p A port to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Port p) { - return getInferredType(p.getType(), null); - } - - /** - * If the given string can be recognized as a floating-point number that has a leading decimal point, - * prepend the string with a zero and return it. Otherwise, return the original string. - * - * @param literal A string might be recognizable as a floating point number with a leading decimal point. - * @return an equivalent representation of literal - * - */ - public static String addZeroToLeadingDot(String literal) { - Matcher m = ABBREVIATED_FLOAT.matcher(literal); - if (m.matches()) { - return literal.replace(".", "0."); - } - return literal; - } - - /** - * Return true if the specified port is a multiport. - * @param port The port. - * @return True if the port is a multiport. - */ - public static boolean isMultiport(Port port) { - return port.getWidthSpec() != null; - } - - //////////////////////////////// - //// Utility functions for translating AST nodes into text - // This is a continuation of a large section of ASTUtils.xtend - // with the same name. - - /** - * Generate code for referencing a port, action, or timer. - * @param reference The reference to the variable. - */ - public static String generateVarRef(VarRef reference) { - var prefix = ""; - if (reference.getContainer() != null) { - prefix = reference.getContainer().getName() + "."; + } + + if (allValidTime && foundNonZero) { + // Conservatively, no bounds are inferred; the returned type + // is a variable-size list. + return InferredType.timeList(); + } + } + return InferredType.undefined(); + } + + /** + * Given a parameter, return an inferred type. Only two types can be inferred: "time" and + * "timeList". Return the "undefined" type if neither can be inferred. + * + * @param p A parameter to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Parameter p) { + return getInferredType(p.getType(), p.getInit()); + } + + /** + * Given a state variable, return an inferred type. Only two types can be inferred: "time" and + * "timeList". Return the "undefined" type if neither can be inferred. + * + * @param s A state variable to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(StateVar s) { + return getInferredType(s.getType(), s.getInit()); + } + + /** + * Construct an inferred type from an "action" AST node based on its declared type. If no type is + * declared, return the "undefined" type. + * + * @param a An action to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Action a) { + return getInferredType(a.getType(), null); + } + + /** + * Construct an inferred type from a "port" AST node based on its declared type. If no type is + * declared, return the "undefined" type. + * + * @param p A port to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Port p) { + return getInferredType(p.getType(), null); + } + + /** + * If the given string can be recognized as a floating-point number that has a leading decimal + * point, prepend the string with a zero and return it. Otherwise, return the original string. + * + * @param literal A string might be recognizable as a floating point number with a leading decimal + * point. + * @return an equivalent representation of literal + * + */ + public static String addZeroToLeadingDot(String literal) { + Matcher m = ABBREVIATED_FLOAT.matcher(literal); + if (m.matches()) { + return literal.replace(".", "0."); + } + return literal; + } + + /** + * Return true if the specified port is a multiport. + * + * @param port The port. + * @return True if the port is a multiport. + */ + public static boolean isMultiport(Port port) { + return port.getWidthSpec() != null; + } + + //////////////////////////////// + //// Utility functions for translating AST nodes into text + // This is a continuation of a large section of ASTUtils.xtend + // with the same name. + + /** + * Generate code for referencing a port, action, or timer. + * + * @param reference The reference to the variable. + */ + public static String generateVarRef(VarRef reference) { + var prefix = ""; + if (reference.getContainer() != null) { + prefix = reference.getContainer().getName() + "."; + } + return prefix + reference.getVariable().getName(); + } + + /** Assuming that the given expression denotes a valid time literal, return a time value. */ + public static TimeValue getLiteralTimeValue(Expression expr) { + if (expr instanceof Time) { + return toTimeValue((Time) expr); + } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { + return TimeValue.ZERO; + } else { + return null; + } + } + + /** If the parameter is of time type, return its default value. Otherwise, return null. */ + public static TimeValue getDefaultAsTimeValue(Parameter p) { + if (isOfTimeType(p)) { + var init = asSingleExpr(p.getInit()); + if (init != null) { + return getLiteralTimeValue(init); + } + } + return null; + } + + /** Return whether the given state variable is inferred to a time type. */ + public static boolean isOfTimeType(StateVar state) { + InferredType t = getInferredType(state); + return t.isTime && !t.isList; + } + + /** Return whether the given parameter is inferred to a time type. */ + public static boolean isOfTimeType(Parameter param) { + InferredType t = getInferredType(param); + return t.isTime && !t.isList; + } + + /** + * Given a parameter, return its initial value. The initial value is a list of instances of + * Expressions. + * + *

If the instantiations argument is null or an empty list, then the value returned is simply + * the default value given when the parameter is defined. + * + *

If a list of instantiations is given, then the first instantiation is required to be an + * instantiation of the reactor class that is parameterized by the parameter. I.e., ``` + * parameter.eContainer == instantiations.get(0).reactorClass ``` If a second instantiation is + * given, then it is required to be an instantiation of a reactor class that contains the first + * instantiation. That is, ``` instantiations.get(0).eContainer == + * instantiations.get(1).reactorClass ``` More generally, for all 0 <= i < instantiations.size - + * 1, ``` instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass ``` If any of + * these conditions is not satisfied, then an IllegalArgumentException will be thrown. + * + *

Note that this chain of reactions cannot be inferred from the parameter because in each of + * the predicates above, there may be more than one instantiation that can appear on the right + * hand side of the predicate. + * + *

For example, consider the following program: ``` reactor A(x:int(1)) {} reactor B(y:int(2)) + * { a1 = new A(x = y); a2 = new A(x = -1); } reactor C(z:int(3)) { b1 = new B(y = z); b2 = new + * B(y = -2); } ``` Notice that there are a total of four instances of reactor class A. Then ``` + * initialValue(x, null) returns 1 initialValue(x, [a1]) returns 2 initialValue(x, [a2]) returns + * -1 initialValue(x, [a1, b1]) returns 3 initialValue(x, [a2, b1]) returns -1 initialValue(x, + * [a1, b2]) returns -2 initialValue(x, [a2, b2]) returns -1 ``` (Actually, in each of the above + * cases, the returned value is a list with one entry, a Literal, e.g. ["1"]). + * + *

There are two instances of reactor class B. ``` initialValue(y, null) returns 2 + * initialValue(y, [a1]) throws an IllegalArgumentException initialValue(y, [b1]) returns 3 + * initialValue(y, [b2]) returns -2 ``` + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * @return The value of the parameter. + * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the + * reactor class that is parameterized by the respective parameter or if the chain of + * instantiations is not nested. + */ + public static List initialValue( + Parameter parameter, List instantiations) { + // If instantiations are given, then check to see whether this parameter gets overridden in + // the first of those instantiations. + if (instantiations != null && instantiations.size() > 0) { + // Check to be sure that the instantiation is in fact an instantiation + // of the reactor class for which this is a parameter. + Instantiation instantiation = instantiations.get(0); + + if (!belongsTo(parameter, instantiation)) { + throw new IllegalArgumentException( + "Parameter " + + parameter.getName() + + " is not a parameter of reactor instance " + + instantiation.getName() + + "."); + } + // In case there is more than one assignment to this parameter, we need to + // find the last one. + Assignment lastAssignment = null; + for (Assignment assignment : instantiation.getParameters()) { + if (assignment.getLhs().equals(parameter)) { + lastAssignment = assignment; } - return prefix + reference.getVariable().getName(); - } - - /** - * Assuming that the given expression denotes a valid time literal, - * return a time value. - */ - public static TimeValue getLiteralTimeValue(Expression expr) { - if (expr instanceof Time) { - return toTimeValue((Time)expr); - } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { - return TimeValue.ZERO; - } else { - return null; - } - } - - /** - * If the parameter is of time type, return its default value. - * Otherwise, return null. - */ - public static TimeValue getDefaultAsTimeValue(Parameter p) { - if (isOfTimeType(p)) { - var init = asSingleExpr(p.getInit()); - if (init != null) { - return getLiteralTimeValue(init); - } - } - return null; - } - - /** - * Return whether the given state variable is inferred - * to a time type. - */ - public static boolean isOfTimeType(StateVar state) { - InferredType t = getInferredType(state); - return t.isTime && !t.isList; - } - - /** - * Return whether the given parameter is inferred - * to a time type. - */ - public static boolean isOfTimeType(Parameter param) { - InferredType t = getInferredType(param); - return t.isTime && !t.isList; - } - - /** - * Given a parameter, return its initial value. - * The initial value is a list of instances of Expressions. - * - * If the instantiations argument is null or an empty list, then the - * value returned is simply the default value given when the parameter - * is defined. - * - * If a list of instantiations is given, then the first instantiation - * is required to be an instantiation of the reactor class that is - * parameterized by the parameter. I.e., - * ``` - * parameter.eContainer == instantiations.get(0).reactorClass - * ``` - * If a second instantiation is given, then it is required to be an instantiation of a - * reactor class that contains the first instantiation. That is, - * ``` - * instantiations.get(0).eContainer == instantiations.get(1).reactorClass - * ``` - * More generally, for all 0 <= i < instantiations.size - 1, - * ``` - * instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass - * ``` - * If any of these conditions is not satisfied, then an IllegalArgumentException - * will be thrown. - * - * Note that this chain of reactions cannot be inferred from the parameter because - * in each of the predicates above, there may be more than one instantiation that - * can appear on the right hand side of the predicate. - * - * For example, consider the following program: - * ``` - * reactor A(x:int(1)) {} - * reactor B(y:int(2)) { - * a1 = new A(x = y); - * a2 = new A(x = -1); - * } - * reactor C(z:int(3)) { - * b1 = new B(y = z); - * b2 = new B(y = -2); - * } - * ``` - * Notice that there are a total of four instances of reactor class A. - * Then - * ``` - * initialValue(x, null) returns 1 - * initialValue(x, [a1]) returns 2 - * initialValue(x, [a2]) returns -1 - * initialValue(x, [a1, b1]) returns 3 - * initialValue(x, [a2, b1]) returns -1 - * initialValue(x, [a1, b2]) returns -2 - * initialValue(x, [a2, b2]) returns -1 - * ``` - * (Actually, in each of the above cases, the returned value is a list with - * one entry, a Literal, e.g. ["1"]). - * - * There are two instances of reactor class B. - * ``` - * initialValue(y, null) returns 2 - * initialValue(y, [a1]) throws an IllegalArgumentException - * initialValue(y, [b1]) returns 3 - * initialValue(y, [b2]) returns -2 - * ``` - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * - * @return The value of the parameter. - * - * @throws IllegalArgumentException If an instantiation provided is not an - * instantiation of the reactor class that is parameterized by the - * respective parameter or if the chain of instantiations is not nested. - */ - public static List initialValue(Parameter parameter, List instantiations) { - // If instantiations are given, then check to see whether this parameter gets overridden in - // the first of those instantiations. - if (instantiations != null && instantiations.size() > 0) { - // Check to be sure that the instantiation is in fact an instantiation - // of the reactor class for which this is a parameter. - Instantiation instantiation = instantiations.get(0); - - if (!belongsTo(parameter, instantiation)) { - throw new IllegalArgumentException("Parameter " - + parameter.getName() - + " is not a parameter of reactor instance " - + instantiation.getName() - + "." - ); - } - // In case there is more than one assignment to this parameter, we need to - // find the last one. - Assignment lastAssignment = null; - for (Assignment assignment: instantiation.getParameters()) { - if (assignment.getLhs().equals(parameter)) { - lastAssignment = assignment; - } - } - if (lastAssignment != null) { - // Right hand side can be a list. Collect the entries. - List result = new ArrayList<>(); - for (Expression expr: lastAssignment.getRhs().getExprs()) { - if (expr instanceof ParameterReference) { - if (instantiations.size() > 1 - && instantiation.eContainer() != instantiations.get(1).getReactorClass() - ) { - throw new IllegalArgumentException("Reactor instance " - + instantiation.getName() - + " is not contained by instance " - + instantiations.get(1).getName() - + "." - ); - } - result.addAll(initialValue(((ParameterReference)expr).getParameter(), - instantiations.subList(1, instantiations.size()))); - } else { - result.add(expr); - } - } - return result; - } - } - // If we reach here, then either no instantiation was supplied or - // there was no assignment in the instantiation. So just use the - // parameter's initial value. - return parameter.getInit().getExprs(); - } - - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) - * belongs to the specified instantiation, meaning that it is defined in - * the reactor class being instantiated or one of its base classes. - * @param eobject The object. - * @param instantiation The instantiation. - */ - public static boolean belongsTo(EObject eobject, Instantiation instantiation) { - Reactor reactor = toDefinition(instantiation.getReactorClass()); - return belongsTo(eobject, reactor); - } - - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) - * belongs to the specified reactor, meaning that it is defined in - * reactor class or one of its base classes. - * @param eobject The object. - * @param reactor The reactor. - */ - public static boolean belongsTo(EObject eobject, Reactor reactor) { - if (eobject.eContainer() == reactor) return true; - for (ReactorDecl baseClass : reactor.getSuperClasses()) { - if (belongsTo(eobject, toDefinition(baseClass))) { - return true; - } - } - return false; - } - - /** - * Given a parameter return its integer value or null - * if it does not have an integer value. - * If the value of the parameter is a list of integers, - * return the sum of value in the list. - * The instantiations parameter is as in - * {@link #initialValue(Parameter, List)}. - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * - * @return The integer value of the parameter, or null if it does not have an integer value. - * - * @throws IllegalArgumentException If an instantiation provided is not an - * instantiation of the reactor class that is parameterized by the - * respective parameter or if the chain of instantiations is not nested. - */ - public static Integer initialValueInt(Parameter parameter, List instantiations) { - List expressions = initialValue(parameter, instantiations); - int result = 0; - for (Expression expr: expressions) { - if (!(expr instanceof Literal)) { - return null; - } - try { - result += Integer.decode(((Literal) expr).getLiteral()); - } catch (NumberFormatException ex) { - return null; + } + if (lastAssignment != null) { + // Right hand side can be a list. Collect the entries. + List result = new ArrayList<>(); + for (Expression expr : lastAssignment.getRhs().getExprs()) { + if (expr instanceof ParameterReference) { + if (instantiations.size() > 1 + && instantiation.eContainer() != instantiations.get(1).getReactorClass()) { + throw new IllegalArgumentException( + "Reactor instance " + + instantiation.getName() + + " is not contained by instance " + + instantiations.get(1).getName() + + "."); } + result.addAll( + initialValue( + ((ParameterReference) expr).getParameter(), + instantiations.subList(1, instantiations.size()))); + } else { + result.add(expr); + } } return result; - } - - /** - * Given the width specification of port or instantiation - * and an (optional) list of nested instantiations, return - * the width if it can be determined and -1 if not. - * It will not be able to be determined if either the - * width is variable (in which case you should use - * {@link #inferPortWidth(VarRef, Connection, List)} ) - * or the list of instantiations is incomplete or missing. - * If there are parameter references in the width, they are - * evaluated to the extent possible given the instantiations list. - * - * The instantiations list is as in - * {@link #initialValue(Parameter, List)}. - * If the spec belongs to an instantiation (for a bank of reactors), - * then the first element on this list should be the instantiation - * that contains this instantiation. If the spec belongs to a port, - * then the first element on the list should be the instantiation - * of the reactor that contains the port. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * - * @return The width, or -1 if the width could not be determined. - * - * @throws IllegalArgumentException If an instantiation provided is not as - * given above or if the chain of instantiations is not nested. - */ - public static int width(WidthSpec spec, List instantiations) { - if (spec == null) { - return 1; + } + } + // If we reach here, then either no instantiation was supplied or + // there was no assignment in the instantiation. So just use the + // parameter's initial value. + return parameter.getInit().getExprs(); + } + + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the + * specified instantiation, meaning that it is defined in the reactor class being instantiated or + * one of its base classes. + * + * @param eobject The object. + * @param instantiation The instantiation. + */ + public static boolean belongsTo(EObject eobject, Instantiation instantiation) { + Reactor reactor = toDefinition(instantiation.getReactorClass()); + return belongsTo(eobject, reactor); + } + + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the + * specified reactor, meaning that it is defined in reactor class or one of its base classes. + * + * @param eobject The object. + * @param reactor The reactor. + */ + public static boolean belongsTo(EObject eobject, Reactor reactor) { + if (eobject.eContainer() == reactor) return true; + for (ReactorDecl baseClass : reactor.getSuperClasses()) { + if (belongsTo(eobject, toDefinition(baseClass))) { + return true; + } + } + return false; + } + + /** + * Given a parameter return its integer value or null if it does not have an integer value. If the + * value of the parameter is a list of integers, return the sum of value in the list. The + * instantiations parameter is as in {@link #initialValue(Parameter, List)}. + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * @return The integer value of the parameter, or null if it does not have an integer value. + * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the + * reactor class that is parameterized by the respective parameter or if the chain of + * instantiations is not nested. + */ + public static Integer initialValueInt(Parameter parameter, List instantiations) { + List expressions = initialValue(parameter, instantiations); + int result = 0; + for (Expression expr : expressions) { + if (!(expr instanceof Literal)) { + return null; + } + try { + result += Integer.decode(((Literal) expr).getLiteral()); + } catch (NumberFormatException ex) { + return null; + } + } + return result; + } + + /** + * Given the width specification of port or instantiation and an (optional) list of nested + * instantiations, return the width if it can be determined and -1 if not. It will not be able to + * be determined if either the width is variable (in which case you should use {@link + * #inferPortWidth(VarRef, Connection, List)} ) or the list of instantiations is incomplete or + * missing. If there are parameter references in the width, they are evaluated to the extent + * possible given the instantiations list. + * + *

The instantiations list is as in {@link #initialValue(Parameter, List)}. If the spec belongs + * to an instantiation (for a bank of reactors), then the first element on this list should be the + * instantiation that contains this instantiation. If the spec belongs to a port, then the first + * element on the list should be the instantiation of the reactor that contains the port. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * @return The width, or -1 if the width could not be determined. + * @throws IllegalArgumentException If an instantiation provided is not as given above or if the + * chain of instantiations is not nested. + */ + public static int width(WidthSpec spec, List instantiations) { + if (spec == null) { + return 1; + } + if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { + return inferWidthFromConnections(spec, instantiations); + } + var result = 0; + for (WidthTerm term : spec.getTerms()) { + if (term.getParameter() != null) { + Integer termWidth = initialValueInt(term.getParameter(), instantiations); + if (termWidth != null) { + result += termWidth; + } else { + return -1; } - if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { + } else if (term.getWidth() > 0) { + result += term.getWidth(); + } else { + // If the width cannot be determined because term's width <= 0, which means the term's width + // must be inferred, try to infer the width using connections. + if (spec.eContainer() instanceof Instantiation) { + try { return inferWidthFromConnections(spec, instantiations); + } catch (InvalidSourceException e) { + // If the inference fails, return -1. + return -1; + } } - var result = 0; - for (WidthTerm term: spec.getTerms()) { - if (term.getParameter() != null) { - Integer termWidth = initialValueInt(term.getParameter(), instantiations); - if (termWidth != null) { - result += termWidth; - } else { - return -1; - } - } else if (term.getWidth() > 0) { - result += term.getWidth(); - } else { - // If the width cannot be determined because term's width <= 0, which means the term's width - // must be inferred, try to infer the width using connections. - if (spec.eContainer() instanceof Instantiation) { - try { - return inferWidthFromConnections(spec, instantiations); - } catch (InvalidSourceException e) { - // If the inference fails, return -1. - return -1; - } - } - } + } + } + return result; + } + + /** + * Infer the width of a port reference in a connection. The port reference one or two parts, a + * port and an (optional) container which is an Instantiation that may refer to a bank of + * reactors. The width will be the product of the bank width and the port width. The returned + * value will be 1 if the port is not in a bank and is not a multiport. + * + *

If the width cannot be determined, this will return -1. The width cannot be determined if + * the list of instantiations is missing or incomplete. + * + *

The instantiations list is as in {@link #initialValue(Parameter, List)}. The first element + * on this list should be the instantiation that contains the specified connection. + * + * @param reference A port reference. + * @param connection A connection, or null if not in the context of a connection. + * @param instantiations The (optional) list of instantiations. + * @return The width or -1 if it could not be determined. + * @throws IllegalArgumentException If an instantiation provided is not as given above or if the + * chain of instantiations is not nested. + */ + public static int inferPortWidth( + VarRef reference, Connection connection, List instantiations) { + if (reference.getVariable() instanceof Port) { + // If the port is given as a.b, then we want to prepend a to + // the list of instantiations to determine the width of this port. + List extended = instantiations; + if (reference.getContainer() != null) { + extended = new ArrayList<>(); + extended.add(reference.getContainer()); + if (instantiations != null) { + extended.addAll(instantiations); } - return result; - } - - /** - * Infer the width of a port reference in a connection. - * The port reference one or two parts, a port and an (optional) container - * which is an Instantiation that may refer to a bank of reactors. - * The width will be the product of the bank width and the port width. - * The returned value will be 1 if the port is not in a bank and is not a multiport. - * - * If the width cannot be determined, this will return -1. - * The width cannot be determined if the list of instantiations is - * missing or incomplete. - * - * The instantiations list is as in - * {@link #initialValue(Parameter, List)}. - * The first element on this list should be the instantiation - * that contains the specified connection. - * - * @param reference A port reference. - * @param connection A connection, or null if not in the context of a connection. - * @param instantiations The (optional) list of instantiations. - * - * @return The width or -1 if it could not be determined. - * - * @throws IllegalArgumentException If an instantiation provided is not as - * given above or if the chain of instantiations is not nested. - */ - public static int inferPortWidth( - VarRef reference, Connection connection, List instantiations - ) { - if (reference.getVariable() instanceof Port) { - // If the port is given as a.b, then we want to prepend a to - // the list of instantiations to determine the width of this port. - List extended = instantiations; - if (reference.getContainer() != null) { - extended = new ArrayList<>(); - extended.add(reference.getContainer()); - if (instantiations != null) { - extended.addAll(instantiations); - } - } + } - int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); - if (portWidth < 0) { - // Could not determine port width. - return -1; - } - - // Next determine the bank width. This may be unspecified, in which - // case it has to be inferred using the connection. - int bankWidth = 1; - if (reference.getContainer() != null) { - bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); - if (bankWidth < 0 && connection != null) { - // Try to infer the bank width from the connection. - if (reference.getContainer().getWidthSpec().isOfVariableLength()) { - // This occurs for a bank of delays. - int leftWidth = 0; - int rightWidth = 0; - int leftOrRight = 0; - for (VarRef leftPort : connection.getLeftPorts()) { - if (leftPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that this port is on the left. - leftOrRight = -1; - } else { - // The left port is not the same as this reference. - int otherWidth = inferPortWidth(leftPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; - } - leftWidth += otherWidth; - } - } - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that this port is on the right. - leftOrRight = 1; - } else { - int otherWidth = inferPortWidth(rightPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; - } - rightWidth += otherWidth; - } - } - int discrepancy = 0; - if (leftOrRight < 0) { - // This port is on the left. - discrepancy = rightWidth - leftWidth; - } else if (leftOrRight > 0) { - // This port is on the right. - discrepancy = leftWidth - rightWidth; - } - // Check that portWidth divides the discrepancy. - if (discrepancy % portWidth != 0) { - // This is an error. - return -1; - } - bankWidth = discrepancy / portWidth; - } else { - // Could not determine the bank width. - return -1; - } - } - } - return portWidth * bankWidth; - } - // Argument is not a port. + int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); + if (portWidth < 0) { + // Could not determine port width. return -1; - } - - /** - * Given an instantiation of a reactor or bank of reactors, return - * the width. This will be 1 if this is not a reactor bank. Otherwise, - * this will attempt to determine the width. If the width is declared - * as a literal constant, it will return that constant. If the width - * is specified as a reference to a parameter, this will throw an - * exception. If the width is variable, this will find - * connections in the enclosing reactor and attempt to infer the - * width. If the width cannot be determined, it will throw an exception. - * - * IMPORTANT: This method should not be used you really need to - * determine the width! It will not evaluate parameter values. - * @see #width(WidthSpec, List) - * - * @param instantiation A reactor instantiation. - * - * @return The width, if it can be determined. - * @deprecated - */ - @Deprecated - public static int widthSpecification(Instantiation instantiation) { - int result = width(instantiation.getWidthSpec(), null); - if (result < 0) { - throw new InvalidSourceException("Cannot determine width for the instance " - + instantiation.getName()); - } - return result; - } - - /** - * Report whether a state variable has been initialized or not. - * @param v The state variable to be checked. - * @return True if the variable was initialized, false otherwise. - */ - public static boolean isInitialized(StateVar v) { - return v != null && v.getInit() != null; - } - - /** - * Report whether the given time state variable is initialized using a - * parameter or not. - * @param s A state variable. - * @return True if the argument is initialized using a parameter, false - * otherwise. - */ - public static boolean isParameterized(StateVar s) { - return s.getInit() != null && - IterableExtensions.exists(s.getInit().getExprs(), it -> it instanceof ParameterReference); - } - - /** - * Check if the reactor class uses generics - * @param r the reactor to check - * @return true if the reactor uses generics - */ - public static boolean isGeneric(Reactor r) { - if (r == null) { - return false; - } - return r.getTypeParms().size() != 0; - } - - /** - * If the specified reactor declaration is an import, then - * return the imported reactor class definition. Otherwise, - * just return the argument. - * @param r A Reactor or an ImportedReactor. - * @return The Reactor class definition or null if no definition is found. - */ - public static Reactor toDefinition(ReactorDecl r) { - if (r == null) - return null; - if (r instanceof Reactor) { - return (Reactor) r; - } else if (r instanceof ImportedReactor) { - return ((ImportedReactor) r).getReactorClass(); - } - return null; - } - - /** - * Return all single-line or multi-line comments immediately preceding the - * given EObject. - */ - public static Stream getPrecedingComments( - ICompositeNode compNode, - Predicate filter - ) { - return getPrecedingCommentNodes(compNode, filter).map(INode::getText); - } - - /** - * Return all single-line or multi-line comments immediately preceding the - * given EObject. - */ - public static Stream getPrecedingCommentNodes( - ICompositeNode compNode, - Predicate filter - ) { - if (compNode == null) return Stream.of(); - List ret = new ArrayList<>(); - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode)) { - if (isComment(node)) { - if (filter.test(node)) ret.add(node); - } else if (!node.getText().isBlank()) { - break; - } - } - } - return ret.stream(); - } - - /** Return whether {@code node} is a comment. */ - public static boolean isComment(INode node) { - return node instanceof HiddenLeafNode hlNode - && hlNode.getGrammarElement() instanceof TerminalRule tRule - && tRule.getName().endsWith("_COMMENT"); - } - - /** - * Return true if the given node starts on the same line as the given other - * node. - */ - public static Predicate sameLine(ICompositeNode compNode) { - return other -> { - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { - return node.getStartLine() == other.getStartLine(); - } - } - return false; - }; - } - - /** - * Find the main reactor and set its name if none was defined. - * @param resource The resource to find the main reactor in. - */ - public static void setMainName(Resource resource, String name) { - Reactor main = IteratorExtensions.findFirst(Iterators.filter(resource.getAllContents(), Reactor.class), - it -> it.isMain() || it.isFederated() - ); - if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { - main.setName(name); - } - } - - /** - * Create a new instantiation node with the given reactor as its defining class. - * @param reactor The reactor class to create an instantiation of. - */ - public static Instantiation createInstantiation(Reactor reactor) { - Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); - inst.setReactorClass(reactor); - // If the reactor is federated or at the top level, then it - // may not have a name. In the generator's doGenerate() - // method, the name gets set using setMainName(). - // But this may be called before that, e.g. during - // diagram synthesis. We assign a temporary name here. - if (reactor.getName() == null) { - if (reactor.isFederated() || reactor.isMain()) { - inst.setName("main"); - } else { - inst.setName(""); - } - - } else { - inst.setName(reactor.getName()); - } - return inst; - } - - /** - * Returns the target declaration in the given model. - * Non-null because it would cause a parse error. - */ - public static TargetDecl targetDecl(Model model) { - return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); - } - - /** - * Returns the target declaration in the given resource. - * Non-null because it would cause a parse error. - */ - public static TargetDecl targetDecl(Resource model) { - return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); - } - - ///////////////////////////////////////////////////////// - //// Private methods - - /** - * Returns the list if it is not null. Otherwise, return an empty list. - */ - public static List convertToEmptyListIfNull(List list) { - return list != null ? list : new ArrayList<>(); - } - - /** - * Return all the superclasses of the specified reactor - * in deepest-first order. For example, if A extends B and C, and - * B and C both extend D, this will return the list [D, B, C, A]. - * Duplicates are removed. If the specified reactor does not extend - * any other reactor, then return an empty list. - * If a cycle is found, where X extends Y and Y extends X, or if - * a superclass is declared that is not found, then return null. - * @param reactor The specified reactor. - * @param extensions A set of reactors extending the specified reactor - * (used to detect circular extensions). - */ - private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { - LinkedHashSet result = new LinkedHashSet<>(); - for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { - Reactor r = toDefinition(superDecl); - if (r == reactor || r == null) return null; - // If r is in the extensions, then we have a circular inheritance structure. - if (extensions.contains(r)) return null; - extensions.add(r); - LinkedHashSet baseExtends = superClasses(r, extensions); - extensions.remove(r); - if (baseExtends == null) return null; - result.addAll(baseExtends); - result.add(r); - } - return result; - } - - /** - * We may be able to infer the width by examining the connections of - * the enclosing reactor definition. This works, for example, with - * delays between multiports or banks of reactors. - * Attempt to infer the width from connections and return -1 if the width cannot be inferred. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * - * @return The width, or -1 if the width could not be inferred from connections. - */ - private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { - for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { + } + + // Next determine the bank width. This may be unspecified, in which + // case it has to be inferred using the connection. + int bankWidth = 1; + if (reference.getContainer() != null) { + bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); + if (bankWidth < 0 && connection != null) { + // Try to infer the bank width from the connection. + if (reference.getContainer().getWidthSpec().isOfVariableLength()) { + // This occurs for a bank of delays. int leftWidth = 0; int rightWidth = 0; int leftOrRight = 0; - for (VarRef leftPort : c.getLeftPorts()) { - if (leftPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the left. - leftOrRight = -1; - } else { - leftWidth += inferPortWidth(leftPort, c, instantiations); + for (VarRef leftPort : connection.getLeftPorts()) { + if (leftPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException( + "Multiple ports with variable width on a connection."); + } + // Indicate that this port is on the left. + leftOrRight = -1; + } else { + // The left port is not the same as this reference. + int otherWidth = inferPortWidth(leftPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; } + leftWidth += otherWidth; + } } - for (VarRef rightPort : c.getRightPorts()) { - if (rightPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the right. - leftOrRight = 1; - } else { - rightWidth += inferPortWidth(rightPort, c, instantiations); + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException( + "Multiple ports with variable width on a connection."); + } + // Indicate that this port is on the right. + leftOrRight = 1; + } else { + int otherWidth = inferPortWidth(rightPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; } + rightWidth += otherWidth; + } } + int discrepancy = 0; if (leftOrRight < 0) { - return rightWidth - leftWidth; + // This port is on the left. + discrepancy = rightWidth - leftWidth; } else if (leftOrRight > 0) { - return leftWidth - rightWidth; + // This port is on the right. + discrepancy = leftWidth - rightWidth; } + // Check that portWidth divides the discrepancy. + if (discrepancy % portWidth != 0) { + // This is an error. + return -1; + } + bankWidth = discrepancy / portWidth; + } else { + // Could not determine the bank width. + return -1; + } } - // A connection was not found with the instantiation. - return -1; - } - - public static void addReactionAttribute(Reaction reaction, String name) { - var fedAttr = factory.createAttribute(); - fedAttr.setAttrName(name); - reaction.getAttributes().add(fedAttr); - } + } + return portWidth * bankWidth; + } + // Argument is not a port. + return -1; + } + + /** + * Given an instantiation of a reactor or bank of reactors, return the width. This will be 1 if + * this is not a reactor bank. Otherwise, this will attempt to determine the width. If the width + * is declared as a literal constant, it will return that constant. If the width is specified as a + * reference to a parameter, this will throw an exception. If the width is variable, this will + * find connections in the enclosing reactor and attempt to infer the width. If the width cannot + * be determined, it will throw an exception. + * + *

IMPORTANT: This method should not be used you really need to determine the width! It will + * not evaluate parameter values. + * + * @see #width(WidthSpec, List) + * @param instantiation A reactor instantiation. + * @return The width, if it can be determined. + * @deprecated + */ + @Deprecated + public static int widthSpecification(Instantiation instantiation) { + int result = width(instantiation.getWidthSpec(), null); + if (result < 0) { + throw new InvalidSourceException( + "Cannot determine width for the instance " + instantiation.getName()); + } + return result; + } + + /** + * Report whether a state variable has been initialized or not. + * + * @param v The state variable to be checked. + * @return True if the variable was initialized, false otherwise. + */ + public static boolean isInitialized(StateVar v) { + return v != null && v.getInit() != null; + } + + /** + * Report whether the given time state variable is initialized using a parameter or not. + * + * @param s A state variable. + * @return True if the argument is initialized using a parameter, false otherwise. + */ + public static boolean isParameterized(StateVar s) { + return s.getInit() != null + && IterableExtensions.exists( + s.getInit().getExprs(), it -> it instanceof ParameterReference); + } + + /** + * Check if the reactor class uses generics + * + * @param r the reactor to check + * @return true if the reactor uses generics + */ + public static boolean isGeneric(Reactor r) { + if (r == null) { + return false; + } + return r.getTypeParms().size() != 0; + } + + /** + * If the specified reactor declaration is an import, then return the imported reactor class + * definition. Otherwise, just return the argument. + * + * @param r A Reactor or an ImportedReactor. + * @return The Reactor class definition or null if no definition is found. + */ + public static Reactor toDefinition(ReactorDecl r) { + if (r == null) return null; + if (r instanceof Reactor) { + return (Reactor) r; + } else if (r instanceof ImportedReactor) { + return ((ImportedReactor) r).getReactorClass(); + } + return null; + } + + /** Return all single-line or multi-line comments immediately preceding the given EObject. */ + public static Stream getPrecedingComments( + ICompositeNode compNode, Predicate filter) { + return getPrecedingCommentNodes(compNode, filter).map(INode::getText); + } + + /** Return all single-line or multi-line comments immediately preceding the given EObject. */ + public static Stream getPrecedingCommentNodes( + ICompositeNode compNode, Predicate filter) { + if (compNode == null) return Stream.of(); + List ret = new ArrayList<>(); + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode)) { + if (isComment(node)) { + if (filter.test(node)) ret.add(node); + } else if (!node.getText().isBlank()) { + break; + } + } + } + return ret.stream(); + } + + /** Return whether {@code node} is a comment. */ + public static boolean isComment(INode node) { + return node instanceof HiddenLeafNode hlNode + && hlNode.getGrammarElement() instanceof TerminalRule tRule + && tRule.getName().endsWith("_COMMENT"); + } + + /** Return true if the given node starts on the same line as the given other node. */ + public static Predicate sameLine(ICompositeNode compNode) { + return other -> { + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { + return node.getStartLine() == other.getStartLine(); + } + } + return false; + }; + } + + /** + * Find the main reactor and set its name if none was defined. + * + * @param resource The resource to find the main reactor in. + */ + public static void setMainName(Resource resource, String name) { + Reactor main = + IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), + it -> it.isMain() || it.isFederated()); + if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { + main.setName(name); + } + } + + /** + * Create a new instantiation node with the given reactor as its defining class. + * + * @param reactor The reactor class to create an instantiation of. + */ + public static Instantiation createInstantiation(Reactor reactor) { + Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); + inst.setReactorClass(reactor); + // If the reactor is federated or at the top level, then it + // may not have a name. In the generator's doGenerate() + // method, the name gets set using setMainName(). + // But this may be called before that, e.g. during + // diagram synthesis. We assign a temporary name here. + if (reactor.getName() == null) { + if (reactor.isFederated() || reactor.isMain()) { + inst.setName("main"); + } else { + inst.setName(""); + } + + } else { + inst.setName(reactor.getName()); + } + return inst; + } + + /** + * Returns the target declaration in the given model. Non-null because it would cause a parse + * error. + */ + public static TargetDecl targetDecl(Model model) { + return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); + } + + /** + * Returns the target declaration in the given resource. Non-null because it would cause a parse + * error. + */ + public static TargetDecl targetDecl(Resource model) { + return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); + } + + ///////////////////////////////////////////////////////// + //// Private methods + + /** Returns the list if it is not null. Otherwise, return an empty list. */ + public static List convertToEmptyListIfNull(List list) { + return list != null ? list : new ArrayList<>(); + } + + /** + * Return all the superclasses of the specified reactor in deepest-first order. For example, if A + * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates + * are removed. If the specified reactor does not extend any other reactor, then return an empty + * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared + * that is not found, then return null. + * + * @param reactor The specified reactor. + * @param extensions A set of reactors extending the specified reactor (used to detect circular + * extensions). + */ + private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { + LinkedHashSet result = new LinkedHashSet<>(); + for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { + Reactor r = toDefinition(superDecl); + if (r == reactor || r == null) return null; + // If r is in the extensions, then we have a circular inheritance structure. + if (extensions.contains(r)) return null; + extensions.add(r); + LinkedHashSet baseExtends = superClasses(r, extensions); + extensions.remove(r); + if (baseExtends == null) return null; + result.addAll(baseExtends); + result.add(r); + } + return result; + } + + /** + * We may be able to infer the width by examining the connections of the enclosing reactor + * definition. This works, for example, with delays between multiports or banks of reactors. + * Attempt to infer the width from connections and return -1 if the width cannot be inferred. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * @return The width, or -1 if the width could not be inferred from connections. + */ + private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { + for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { + int leftWidth = 0; + int rightWidth = 0; + int leftOrRight = 0; + for (VarRef leftPort : c.getLeftPorts()) { + if (leftPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the left. + leftOrRight = -1; + } else { + leftWidth += inferPortWidth(leftPort, c, instantiations); + } + } + for (VarRef rightPort : c.getRightPorts()) { + if (rightPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the right. + leftOrRight = 1; + } else { + rightWidth += inferPortWidth(rightPort, c, instantiations); + } + } + if (leftOrRight < 0) { + return rightWidth - leftWidth; + } else if (leftOrRight > 0) { + return leftWidth - rightWidth; + } + } + // A connection was not found with the instantiation. + return -1; + } + + public static void addReactionAttribute(Reaction reaction, String name) { + var fedAttr = factory.createAttribute(); + fedAttr.setAttrName(name); + reaction.getAttributes().add(fedAttr); + } } diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index e18eea02bd..f4bbc17f6d 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -6,9 +6,7 @@ import java.util.function.BiPredicate; import java.util.function.Function; import java.util.stream.Collectors; - import org.eclipse.emf.ecore.EObject; - import org.lflang.TimeUnit; import org.lflang.lf.Action; import org.lflang.lf.Array; @@ -60,626 +58,609 @@ import org.lflang.lf.TypedVariable; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; +import org.lflang.lf.Watchdog; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; -import org.lflang.lf.Watchdog; import org.lflang.lf.util.LfSwitch; /** - * Switch class that checks if subtrees of the AST are semantically equivalent - * to each other. Return {@code false} if they are not equivalent; return - * {@code true} or {@code false} (but preferably {@code true}) if they are - * equivalent. + * Switch class that checks if subtrees of the AST are semantically equivalent to each other. Return + * {@code false} if they are not equivalent; return {@code true} or {@code false} (but preferably + * {@code true}) if they are equivalent. */ public class IsEqual extends LfSwitch { - private final EObject otherObject; - - public IsEqual(EObject other) { - this.otherObject = other; - } - - @Override - public Boolean doSwitch(EObject eObject) { - if (otherObject == eObject) return true; - if (eObject == null) return false; - return super.doSwitch(eObject); - } - - @Override - public Boolean caseModel(Model object) { - return new ComparisonMachine<>(object, Model.class) - .equivalent(Model::getTarget) - .listsEquivalent(Model::getImports) - .listsEquivalent(Model::getPreambles) - .listsEquivalent(Model::getReactors).conclusion; - } - - @Override - public Boolean caseImport(Import object) { - return new ComparisonMachine<>(object, Import.class) - .equalAsObjects(Import::getImportURI) - .listsEquivalent(Import::getReactorClasses).conclusion; - } - - @Override - public Boolean caseReactorDecl(ReactorDecl object) { - return new ComparisonMachine<>(object, ReactorDecl.class) - .equalAsObjects(ReactorDecl::getName) - .conclusion; - } - - @Override - public Boolean caseImportedReactor(ImportedReactor object) { - return new ComparisonMachine<>(object, ImportedReactor.class) - .equalAsObjects(ImportedReactor::getName) - .equivalent(ImportedReactor::getReactorClass) - .conclusion; - } - - @Override - public Boolean caseReactor(Reactor object) { - return new ComparisonMachine<>(object, Reactor.class) - .listsEquivalent(Reactor::getAttributes) - .equalAsObjects(Reactor::isFederated) - .equalAsObjects(Reactor::isRealtime) - .equalAsObjects(Reactor::isMain) - .equalAsObjects(Reactor::getName) - .listsEquivalent(Reactor::getTypeParms) - .listsEquivalent(Reactor::getParameters) - .equivalent(Reactor::getHost) - .listsEquivalent(Reactor::getSuperClasses) - .listsEquivalent(Reactor::getPreambles) - .listsEquivalent(Reactor::getInputs) - .listsEquivalent(Reactor::getOutputs) - .listsEquivalent(Reactor::getTimers) - .listsEquivalent(Reactor::getActions) - .listsEquivalent(Reactor::getInstantiations) - .listsEquivalent(Reactor::getConnections) - .listsEquivalent(Reactor::getStateVars) - .listsEquivalent(Reactor::getReactions) - .listsEquivalent(Reactor::getMethods) - .listsEquivalent(Reactor::getModes) - .conclusion; - } - - @Override - public Boolean caseTypeParm(TypeParm object) { - return new ComparisonMachine<>(object, TypeParm.class) - .equalAsObjects(TypeParm::getLiteral) - .equivalent(TypeParm::getCode) - .conclusion; - } - - @Override - public Boolean caseTargetDecl(TargetDecl object) { - return new ComparisonMachine<>(object, TargetDecl.class) - .equalAsObjects(TargetDecl::getName) - .equivalentModulo( - TargetDecl::getConfig, - (KeyValuePairs it) -> it != null && it.getPairs().isEmpty() ? null : it - ) - .conclusion; - } - - @Override - public Boolean caseStateVar(StateVar object) { - return new ComparisonMachine<>(object, StateVar.class) - .listsEquivalent(StateVar::getAttributes) - .equalAsObjects(StateVar::getName) - .equivalent(StateVar::getType) - .equivalent(StateVar::getInit) - .conclusion; - } - - @Override - public Boolean caseInitializer(Initializer object) { - // Empty braces are not equivalent to no init. - return new ComparisonMachine<>(object, Initializer.class) - .equalAsObjects(Initializer::isBraces) - // An initializer with no parens is equivalent to one with parens, - // if the list has a single element. This is probably going to change - // when we introduce equals initializers. - // .equalAsObjects(Initializer::isParens) - .listsEquivalent(Initializer::getExprs) - .conclusion; - } - - @Override - public Boolean caseMethod(Method object) { - return new ComparisonMachine<>(object, Method.class) - .equalAsObjects(Method::isConst) - .equalAsObjects(Method::getName) - .listsEquivalent(Method::getArguments) - .equivalent(Method::getReturn) - .equivalent(Method::getCode) - .conclusion; - } - - @Override - public Boolean caseMethodArgument(MethodArgument object) { - return new ComparisonMachine<>(object, MethodArgument.class) - .equalAsObjects(MethodArgument::getName) - .equivalent(MethodArgument::getType) - .conclusion; - } - - @Override - public Boolean caseInput(Input object) { - return new ComparisonMachine<>(object, Input.class) - .listsEquivalent(Input::getAttributes) - .equalAsObjects(Input::isMutable) - .equivalent(Input::getWidthSpec) - .equivalent(Input::getType) - .conclusion; - } - - @Override - public Boolean caseOutput(Output object) { - return new ComparisonMachine<>(object, Output.class) - .listsEquivalent(Output::getAttributes) - .equivalent(Output::getWidthSpec) - .equalAsObjects(Output::getName) - .equivalent(Output::getType) - .conclusion; - } - - @Override - public Boolean caseTimer(Timer object) { - return new ComparisonMachine<>(object, Timer.class) - .listsEquivalent(Timer::getAttributes) - .equalAsObjects(Timer::getName) - .equivalent(Timer::getOffset) - .equivalent(Timer::getPeriod) - .conclusion; - } - - @Override - public Boolean caseMode(Mode object) { - return new ComparisonMachine<>(object, Mode.class) - .equalAsObjects(Mode::isInitial) - .equalAsObjects(Mode::getName) - .listsEquivalent(Mode::getStateVars) - .listsEquivalent(Mode::getTimers) - .listsEquivalent(Mode::getActions) - .listsEquivalent(Mode::getInstantiations) - .listsEquivalent(Mode::getConnections) - .listsEquivalent(Mode::getReactions) - .conclusion; - } - - @Override - public Boolean caseAction(Action object) { - return new ComparisonMachine<>(object, Action.class) - .listsEquivalent(Action::getAttributes) - .equalAsObjects(Action::getOrigin) // This is an enum - .equalAsObjects(Action::getName) - .equivalent(Action::getMinDelay) - .equivalent(Action::getMinSpacing) - .equalAsObjects(Action::getPolicy) - .equivalent(Action::getType) - .conclusion; - } - - @Override - public Boolean caseAttribute(Attribute object) { - return new ComparisonMachine<>(object, Attribute.class) - .equalAsObjects(Attribute::getAttrName) - .listsEquivalent(Attribute::getAttrParms) - .conclusion; - } - - @Override - public Boolean caseAttrParm(AttrParm object) { - return new ComparisonMachine<>(object, AttrParm.class) - .equalAsObjects(AttrParm::getName) - .equalAsObjects(AttrParm::getValue) - .conclusion; - } - - @Override - public Boolean caseReaction(Reaction object) { - return new ComparisonMachine<>(object, Reaction.class) - .listsEquivalent(Reaction::getAttributes) - .listsEquivalent(Reaction::getTriggers) - .listsEquivalent(Reaction::getSources) - .listsEquivalent(Reaction::getEffects) - .equalAsObjects(Reaction::isMutation) - .equivalent(Reaction::getCode) - .equivalent(Reaction::getStp) - .equivalent(Reaction::getDeadline) - .conclusion; - } - - @Override - public Boolean caseTriggerRef(TriggerRef object) { - throw thereIsAMoreSpecificCase(TriggerRef.class, BuiltinTriggerRef.class, VarRef.class); - } - - @Override - public Boolean caseBuiltinTriggerRef(BuiltinTriggerRef object) { - return new ComparisonMachine<>(object, BuiltinTriggerRef.class) - .equalAsObjects(BuiltinTriggerRef::getType) // This is an enum - .conclusion; - } - - @Override - public Boolean caseDeadline(Deadline object) { - return new ComparisonMachine<>(object, Deadline.class) - .equivalent(Deadline::getDelay) - .equivalent(Deadline::getCode) - .conclusion; - } - - @Override - public Boolean caseSTP(STP object) { - return new ComparisonMachine<>(object, STP.class) - .equivalent(STP::getValue) - .equivalent(STP::getCode) - .conclusion; - } - - - @Override - public Boolean casePreamble(Preamble object) { - return new ComparisonMachine<>(object, Preamble.class) - .equalAsObjects(Preamble::getVisibility) // This is an enum - .equivalent(Preamble::getCode) - .conclusion; - } - - @Override - public Boolean caseInstantiation(Instantiation object) { - return new ComparisonMachine<>(object, Instantiation.class) - .equalAsObjects(Instantiation::getName) - .equivalent(Instantiation::getWidthSpec) - .equivalent(Instantiation::getReactorClass) - .listsEquivalent(Instantiation::getTypeArgs) - .listsEquivalent(Instantiation::getParameters) - .equivalent(Instantiation::getHost) - .conclusion; - } - - @Override - public Boolean caseConnection(Connection object) { - return new ComparisonMachine<>(object, Connection.class) - .listsEquivalent(Connection::getLeftPorts) - .equalAsObjects(Connection::isIterated) - .equalAsObjects(Connection::isPhysical) - .listsEquivalent(Connection::getRightPorts) - .equivalent(Connection::getDelay) - .equivalent(Connection::getSerializer) - .conclusion; - } - - @Override - public Boolean caseSerializer(Serializer object) { - return new ComparisonMachine<>(object, Serializer.class) - .equalAsObjects(Serializer::getType) - .conclusion; - } - - @Override - public Boolean caseKeyValuePairs(KeyValuePairs object) { - return new ComparisonMachine<>(object, KeyValuePairs.class) - .listsEquivalent(KeyValuePairs::getPairs) - .conclusion; - } - - @Override - public Boolean caseKeyValuePair(KeyValuePair object) { - return new ComparisonMachine<>(object, KeyValuePair.class) - .equalAsObjects(KeyValuePair::getName) - .equivalent(KeyValuePair::getValue) - .conclusion; - } - - @Override - public Boolean caseArray(Array object) { - return new ComparisonMachine<>(object, Array.class) - .listsEquivalent(Array::getElements) - .conclusion; - } - - @Override - public Boolean caseElement(Element object) { - return new ComparisonMachine<>(object, Element.class) - .equivalent(Element::getKeyvalue) - .equivalent(Element::getArray) - .equalAsObjects(Element::getLiteral) - .equalAsObjects(Element::getId) - .equalAsObjects(Element::getUnit) - .conclusion; - } - - @Override - public Boolean caseTypedVariable(TypedVariable object) { - throw thereIsAMoreSpecificCase(TypedVariable.class, Port.class, Action.class); - } - - @Override - public Boolean caseVariable(Variable object) { - throw thereIsAMoreSpecificCase(Variable.class, TypedVariable.class, Timer.class, Mode.class, Watchdog.class); - } - - @Override - public Boolean caseVarRef(VarRef object) { - return new ComparisonMachine<>(object, VarRef.class) - .equalAsObjects(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable().getName()) - .equivalent(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable()) - .equalAsObjects(varRef -> varRef.getContainer() == null ? null : varRef.getContainer().getName()) - .equalAsObjects(VarRef::isInterleaved) - .equalAsObjects(VarRef::getTransition) - .conclusion; - } - - @Override - public Boolean caseAssignment(Assignment object) { - return new ComparisonMachine<>(object, Assignment.class) - .equivalent(Assignment::getLhs) - .equivalent(Assignment::getRhs) - .conclusion; - } - - @Override - public Boolean caseParameter(Parameter object) { - return new ComparisonMachine<>(object, Parameter.class) - .listsEquivalent(Parameter::getAttributes) - .equalAsObjects(Parameter::getName) - .equivalent(Parameter::getType) - .equivalent(Parameter::getInit) - .conclusion; - } - - @Override - public Boolean caseExpression(Expression object) { - throw thereIsAMoreSpecificCase( - Expression.class, - Literal.class, - Time.class, - ParameterReference.class, - Code.class, - BracedListExpression.class - ); - } - - @Override - public Boolean caseBracedListExpression(BracedListExpression object) { - return new ComparisonMachine<>(object, BracedListExpression.class) - .listsEquivalent(BracedListExpression::getItems) - .conclusion; - } - - @Override - public Boolean caseParameterReference(ParameterReference object) { - return new ComparisonMachine<>(object, ParameterReference.class) - .equivalent(ParameterReference::getParameter) - .conclusion; - } - - @Override - public Boolean caseTime(Time object) { - return new ComparisonMachine<>(object, Time.class) - .equalAsObjects(Time::getInterval) - .equalAsObjectsModulo( - Time::getUnit, - ((Function) TimeUnit::getCanonicalName) - .compose(TimeUnit::fromName) - ) - .conclusion; - } - - @Override - public Boolean casePort(Port object) { - throw thereIsAMoreSpecificCase(Port.class, Input.class, Output.class); - } - - @Override - public Boolean caseType(Type object) { - return new ComparisonMachine<>(object, Type.class) - .equivalent(Type::getCode) - .equalAsObjects(Type::isTime) - .equivalent(Type::getArraySpec) - .equalAsObjects(Type::getId) - .listsEquivalent(Type::getTypeArgs) - .listsEqualAsObjects(Type::getStars) - .equivalent(Type::getArraySpec) - .equivalent(Type::getCode) - .conclusion; - } - - @Override - public Boolean caseArraySpec(ArraySpec object) { - return new ComparisonMachine<>(object, ArraySpec.class) - .equalAsObjects(ArraySpec::isOfVariableLength) - .equalAsObjects(ArraySpec::getLength) - .conclusion; - } - - @Override - public Boolean caseWatchdog(Watchdog object) { - return new ComparisonMachine<>(object, Watchdog.class) - .equalAsObjects(Watchdog::getName) - .equivalent(Watchdog::getTimeout) - .listsEquivalent(Watchdog::getEffects) - .equivalent(Watchdog::getCode) - .conclusion; - } - - @Override - public Boolean caseWidthSpec(WidthSpec object) { - return new ComparisonMachine<>(object, WidthSpec.class) - .equalAsObjects(WidthSpec::isOfVariableLength) - .listsEquivalent(WidthSpec::getTerms) - .conclusion; - } - - @Override - public Boolean caseWidthTerm(WidthTerm object) { - return new ComparisonMachine<>(object, WidthTerm.class) - .equalAsObjects(WidthTerm::getWidth) - .equivalent(WidthTerm::getParameter) - .equivalent(WidthTerm::getPort) - .equivalent(WidthTerm::getCode) - .conclusion; - } - - @Override - public Boolean caseIPV4Host(IPV4Host object) { - return caseHost(object); - } - - @Override - public Boolean caseIPV6Host(IPV6Host object) { - return caseHost(object); - } - - @Override - public Boolean caseNamedHost(NamedHost object) { - return caseHost(object); - } - - @Override - public Boolean caseHost(Host object) { - return new ComparisonMachine<>(object, Host.class) - .equalAsObjects(Host::getUser) - .equalAsObjects(Host::getAddr) - .equalAsObjects(Host::getPort) - .conclusion; - } - - @Override - public Boolean caseCodeExpr(CodeExpr object) { - return new ComparisonMachine<>(object, CodeExpr.class).equivalent(CodeExpr::getCode).conclusion; - } - - @Override - public Boolean caseCode(Code object) { - return new ComparisonMachine<>(object, Code.class) - .equalAsObjectsModulo( - Code::getBody, - s -> s == null ? null : s.strip().stripIndent() - ) - .conclusion; - } - - @Override - public Boolean caseLiteral(Literal object) { - return new ComparisonMachine<>(object, Literal.class) - .equalAsObjects(Literal::getLiteral) - .conclusion; - } - - @Override - public Boolean defaultCase(EObject object) { - return super.defaultCase(object); - } - - @SafeVarargs - private UnsupportedOperationException thereIsAMoreSpecificCase( - Class thisCase, - Class... moreSpecificCases - ) { - return new UnsupportedOperationException(String.format( + private final EObject otherObject; + + public IsEqual(EObject other) { + this.otherObject = other; + } + + @Override + public Boolean doSwitch(EObject eObject) { + if (otherObject == eObject) return true; + if (eObject == null) return false; + return super.doSwitch(eObject); + } + + @Override + public Boolean caseModel(Model object) { + return new ComparisonMachine<>(object, Model.class) + .equivalent(Model::getTarget) + .listsEquivalent(Model::getImports) + .listsEquivalent(Model::getPreambles) + .listsEquivalent(Model::getReactors) + .conclusion; + } + + @Override + public Boolean caseImport(Import object) { + return new ComparisonMachine<>(object, Import.class) + .equalAsObjects(Import::getImportURI) + .listsEquivalent(Import::getReactorClasses) + .conclusion; + } + + @Override + public Boolean caseReactorDecl(ReactorDecl object) { + return new ComparisonMachine<>(object, ReactorDecl.class) + .equalAsObjects(ReactorDecl::getName) + .conclusion; + } + + @Override + public Boolean caseImportedReactor(ImportedReactor object) { + return new ComparisonMachine<>(object, ImportedReactor.class) + .equalAsObjects(ImportedReactor::getName) + .equivalent(ImportedReactor::getReactorClass) + .conclusion; + } + + @Override + public Boolean caseReactor(Reactor object) { + return new ComparisonMachine<>(object, Reactor.class) + .listsEquivalent(Reactor::getAttributes) + .equalAsObjects(Reactor::isFederated) + .equalAsObjects(Reactor::isRealtime) + .equalAsObjects(Reactor::isMain) + .equalAsObjects(Reactor::getName) + .listsEquivalent(Reactor::getTypeParms) + .listsEquivalent(Reactor::getParameters) + .equivalent(Reactor::getHost) + .listsEquivalent(Reactor::getSuperClasses) + .listsEquivalent(Reactor::getPreambles) + .listsEquivalent(Reactor::getInputs) + .listsEquivalent(Reactor::getOutputs) + .listsEquivalent(Reactor::getTimers) + .listsEquivalent(Reactor::getActions) + .listsEquivalent(Reactor::getInstantiations) + .listsEquivalent(Reactor::getConnections) + .listsEquivalent(Reactor::getStateVars) + .listsEquivalent(Reactor::getReactions) + .listsEquivalent(Reactor::getMethods) + .listsEquivalent(Reactor::getModes) + .conclusion; + } + + @Override + public Boolean caseTypeParm(TypeParm object) { + return new ComparisonMachine<>(object, TypeParm.class) + .equalAsObjects(TypeParm::getLiteral) + .equivalent(TypeParm::getCode) + .conclusion; + } + + @Override + public Boolean caseTargetDecl(TargetDecl object) { + return new ComparisonMachine<>(object, TargetDecl.class) + .equalAsObjects(TargetDecl::getName) + .equivalentModulo( + TargetDecl::getConfig, + (KeyValuePairs it) -> it != null && it.getPairs().isEmpty() ? null : it) + .conclusion; + } + + @Override + public Boolean caseStateVar(StateVar object) { + return new ComparisonMachine<>(object, StateVar.class) + .listsEquivalent(StateVar::getAttributes) + .equalAsObjects(StateVar::getName) + .equivalent(StateVar::getType) + .equivalent(StateVar::getInit) + .conclusion; + } + + @Override + public Boolean caseInitializer(Initializer object) { + // Empty braces are not equivalent to no init. + return new ComparisonMachine<>(object, Initializer.class) + .equalAsObjects(Initializer::isBraces) + // An initializer with no parens is equivalent to one with parens, + // if the list has a single element. This is probably going to change + // when we introduce equals initializers. + // .equalAsObjects(Initializer::isParens) + .listsEquivalent(Initializer::getExprs) + .conclusion; + } + + @Override + public Boolean caseMethod(Method object) { + return new ComparisonMachine<>(object, Method.class) + .equalAsObjects(Method::isConst) + .equalAsObjects(Method::getName) + .listsEquivalent(Method::getArguments) + .equivalent(Method::getReturn) + .equivalent(Method::getCode) + .conclusion; + } + + @Override + public Boolean caseMethodArgument(MethodArgument object) { + return new ComparisonMachine<>(object, MethodArgument.class) + .equalAsObjects(MethodArgument::getName) + .equivalent(MethodArgument::getType) + .conclusion; + } + + @Override + public Boolean caseInput(Input object) { + return new ComparisonMachine<>(object, Input.class) + .listsEquivalent(Input::getAttributes) + .equalAsObjects(Input::isMutable) + .equivalent(Input::getWidthSpec) + .equivalent(Input::getType) + .conclusion; + } + + @Override + public Boolean caseOutput(Output object) { + return new ComparisonMachine<>(object, Output.class) + .listsEquivalent(Output::getAttributes) + .equivalent(Output::getWidthSpec) + .equalAsObjects(Output::getName) + .equivalent(Output::getType) + .conclusion; + } + + @Override + public Boolean caseTimer(Timer object) { + return new ComparisonMachine<>(object, Timer.class) + .listsEquivalent(Timer::getAttributes) + .equalAsObjects(Timer::getName) + .equivalent(Timer::getOffset) + .equivalent(Timer::getPeriod) + .conclusion; + } + + @Override + public Boolean caseMode(Mode object) { + return new ComparisonMachine<>(object, Mode.class) + .equalAsObjects(Mode::isInitial) + .equalAsObjects(Mode::getName) + .listsEquivalent(Mode::getStateVars) + .listsEquivalent(Mode::getTimers) + .listsEquivalent(Mode::getActions) + .listsEquivalent(Mode::getInstantiations) + .listsEquivalent(Mode::getConnections) + .listsEquivalent(Mode::getReactions) + .conclusion; + } + + @Override + public Boolean caseAction(Action object) { + return new ComparisonMachine<>(object, Action.class) + .listsEquivalent(Action::getAttributes) + .equalAsObjects(Action::getOrigin) // This is an enum + .equalAsObjects(Action::getName) + .equivalent(Action::getMinDelay) + .equivalent(Action::getMinSpacing) + .equalAsObjects(Action::getPolicy) + .equivalent(Action::getType) + .conclusion; + } + + @Override + public Boolean caseAttribute(Attribute object) { + return new ComparisonMachine<>(object, Attribute.class) + .equalAsObjects(Attribute::getAttrName) + .listsEquivalent(Attribute::getAttrParms) + .conclusion; + } + + @Override + public Boolean caseAttrParm(AttrParm object) { + return new ComparisonMachine<>(object, AttrParm.class) + .equalAsObjects(AttrParm::getName) + .equalAsObjects(AttrParm::getValue) + .conclusion; + } + + @Override + public Boolean caseReaction(Reaction object) { + return new ComparisonMachine<>(object, Reaction.class) + .listsEquivalent(Reaction::getAttributes) + .listsEquivalent(Reaction::getTriggers) + .listsEquivalent(Reaction::getSources) + .listsEquivalent(Reaction::getEffects) + .equalAsObjects(Reaction::isMutation) + .equivalent(Reaction::getCode) + .equivalent(Reaction::getStp) + .equivalent(Reaction::getDeadline) + .conclusion; + } + + @Override + public Boolean caseTriggerRef(TriggerRef object) { + throw thereIsAMoreSpecificCase(TriggerRef.class, BuiltinTriggerRef.class, VarRef.class); + } + + @Override + public Boolean caseBuiltinTriggerRef(BuiltinTriggerRef object) { + return new ComparisonMachine<>(object, BuiltinTriggerRef.class) + .equalAsObjects(BuiltinTriggerRef::getType) // This is an enum + .conclusion; + } + + @Override + public Boolean caseDeadline(Deadline object) { + return new ComparisonMachine<>(object, Deadline.class) + .equivalent(Deadline::getDelay) + .equivalent(Deadline::getCode) + .conclusion; + } + + @Override + public Boolean caseSTP(STP object) { + return new ComparisonMachine<>(object, STP.class) + .equivalent(STP::getValue) + .equivalent(STP::getCode) + .conclusion; + } + + @Override + public Boolean casePreamble(Preamble object) { + return new ComparisonMachine<>(object, Preamble.class) + .equalAsObjects(Preamble::getVisibility) // This is an enum + .equivalent(Preamble::getCode) + .conclusion; + } + + @Override + public Boolean caseInstantiation(Instantiation object) { + return new ComparisonMachine<>(object, Instantiation.class) + .equalAsObjects(Instantiation::getName) + .equivalent(Instantiation::getWidthSpec) + .equivalent(Instantiation::getReactorClass) + .listsEquivalent(Instantiation::getTypeArgs) + .listsEquivalent(Instantiation::getParameters) + .equivalent(Instantiation::getHost) + .conclusion; + } + + @Override + public Boolean caseConnection(Connection object) { + return new ComparisonMachine<>(object, Connection.class) + .listsEquivalent(Connection::getLeftPorts) + .equalAsObjects(Connection::isIterated) + .equalAsObjects(Connection::isPhysical) + .listsEquivalent(Connection::getRightPorts) + .equivalent(Connection::getDelay) + .equivalent(Connection::getSerializer) + .conclusion; + } + + @Override + public Boolean caseSerializer(Serializer object) { + return new ComparisonMachine<>(object, Serializer.class) + .equalAsObjects(Serializer::getType) + .conclusion; + } + + @Override + public Boolean caseKeyValuePairs(KeyValuePairs object) { + return new ComparisonMachine<>(object, KeyValuePairs.class) + .listsEquivalent(KeyValuePairs::getPairs) + .conclusion; + } + + @Override + public Boolean caseKeyValuePair(KeyValuePair object) { + return new ComparisonMachine<>(object, KeyValuePair.class) + .equalAsObjects(KeyValuePair::getName) + .equivalent(KeyValuePair::getValue) + .conclusion; + } + + @Override + public Boolean caseArray(Array object) { + return new ComparisonMachine<>(object, Array.class) + .listsEquivalent(Array::getElements) + .conclusion; + } + + @Override + public Boolean caseElement(Element object) { + return new ComparisonMachine<>(object, Element.class) + .equivalent(Element::getKeyvalue) + .equivalent(Element::getArray) + .equalAsObjects(Element::getLiteral) + .equalAsObjects(Element::getId) + .equalAsObjects(Element::getUnit) + .conclusion; + } + + @Override + public Boolean caseTypedVariable(TypedVariable object) { + throw thereIsAMoreSpecificCase(TypedVariable.class, Port.class, Action.class); + } + + @Override + public Boolean caseVariable(Variable object) { + throw thereIsAMoreSpecificCase( + Variable.class, TypedVariable.class, Timer.class, Mode.class, Watchdog.class); + } + + @Override + public Boolean caseVarRef(VarRef object) { + return new ComparisonMachine<>(object, VarRef.class) + .equalAsObjects( + varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable().getName()) + .equivalent(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable()) + .equalAsObjects( + varRef -> varRef.getContainer() == null ? null : varRef.getContainer().getName()) + .equalAsObjects(VarRef::isInterleaved) + .equalAsObjects(VarRef::getTransition) + .conclusion; + } + + @Override + public Boolean caseAssignment(Assignment object) { + return new ComparisonMachine<>(object, Assignment.class) + .equivalent(Assignment::getLhs) + .equivalent(Assignment::getRhs) + .conclusion; + } + + @Override + public Boolean caseParameter(Parameter object) { + return new ComparisonMachine<>(object, Parameter.class) + .listsEquivalent(Parameter::getAttributes) + .equalAsObjects(Parameter::getName) + .equivalent(Parameter::getType) + .equivalent(Parameter::getInit) + .conclusion; + } + + @Override + public Boolean caseExpression(Expression object) { + throw thereIsAMoreSpecificCase( + Expression.class, + Literal.class, + Time.class, + ParameterReference.class, + Code.class, + BracedListExpression.class); + } + + @Override + public Boolean caseBracedListExpression(BracedListExpression object) { + return new ComparisonMachine<>(object, BracedListExpression.class) + .listsEquivalent(BracedListExpression::getItems) + .conclusion; + } + + @Override + public Boolean caseParameterReference(ParameterReference object) { + return new ComparisonMachine<>(object, ParameterReference.class) + .equivalent(ParameterReference::getParameter) + .conclusion; + } + + @Override + public Boolean caseTime(Time object) { + return new ComparisonMachine<>(object, Time.class) + .equalAsObjects(Time::getInterval) + .equalAsObjectsModulo( + Time::getUnit, + ((Function) TimeUnit::getCanonicalName).compose(TimeUnit::fromName)) + .conclusion; + } + + @Override + public Boolean casePort(Port object) { + throw thereIsAMoreSpecificCase(Port.class, Input.class, Output.class); + } + + @Override + public Boolean caseType(Type object) { + return new ComparisonMachine<>(object, Type.class) + .equivalent(Type::getCode) + .equalAsObjects(Type::isTime) + .equivalent(Type::getArraySpec) + .equalAsObjects(Type::getId) + .listsEquivalent(Type::getTypeArgs) + .listsEqualAsObjects(Type::getStars) + .equivalent(Type::getArraySpec) + .equivalent(Type::getCode) + .conclusion; + } + + @Override + public Boolean caseArraySpec(ArraySpec object) { + return new ComparisonMachine<>(object, ArraySpec.class) + .equalAsObjects(ArraySpec::isOfVariableLength) + .equalAsObjects(ArraySpec::getLength) + .conclusion; + } + + @Override + public Boolean caseWatchdog(Watchdog object) { + return new ComparisonMachine<>(object, Watchdog.class) + .equalAsObjects(Watchdog::getName) + .equivalent(Watchdog::getTimeout) + .listsEquivalent(Watchdog::getEffects) + .equivalent(Watchdog::getCode) + .conclusion; + } + + @Override + public Boolean caseWidthSpec(WidthSpec object) { + return new ComparisonMachine<>(object, WidthSpec.class) + .equalAsObjects(WidthSpec::isOfVariableLength) + .listsEquivalent(WidthSpec::getTerms) + .conclusion; + } + + @Override + public Boolean caseWidthTerm(WidthTerm object) { + return new ComparisonMachine<>(object, WidthTerm.class) + .equalAsObjects(WidthTerm::getWidth) + .equivalent(WidthTerm::getParameter) + .equivalent(WidthTerm::getPort) + .equivalent(WidthTerm::getCode) + .conclusion; + } + + @Override + public Boolean caseIPV4Host(IPV4Host object) { + return caseHost(object); + } + + @Override + public Boolean caseIPV6Host(IPV6Host object) { + return caseHost(object); + } + + @Override + public Boolean caseNamedHost(NamedHost object) { + return caseHost(object); + } + + @Override + public Boolean caseHost(Host object) { + return new ComparisonMachine<>(object, Host.class) + .equalAsObjects(Host::getUser) + .equalAsObjects(Host::getAddr) + .equalAsObjects(Host::getPort) + .conclusion; + } + + @Override + public Boolean caseCodeExpr(CodeExpr object) { + return new ComparisonMachine<>(object, CodeExpr.class).equivalent(CodeExpr::getCode).conclusion; + } + + @Override + public Boolean caseCode(Code object) { + return new ComparisonMachine<>(object, Code.class) + .equalAsObjectsModulo(Code::getBody, s -> s == null ? null : s.strip().stripIndent()) + .conclusion; + } + + @Override + public Boolean caseLiteral(Literal object) { + return new ComparisonMachine<>(object, Literal.class) + .equalAsObjects(Literal::getLiteral) + .conclusion; + } + + @Override + public Boolean defaultCase(EObject object) { + return super.defaultCase(object); + } + + @SafeVarargs + private UnsupportedOperationException thereIsAMoreSpecificCase( + Class thisCase, Class... moreSpecificCases) { + return new UnsupportedOperationException( + String.format( "%ss are %s, so the methods " + "corresponding to those types should be invoked instead.", thisCase.getName(), Arrays.stream(moreSpecificCases) - .map(Class::getName) - .map(it -> it + (it.endsWith("s") ? "es" : "s")) - .collect(Collectors.joining(" or ")) - )); - } - - /** Fluently compare a pair of parse tree nodes for equivalence. */ - private class ComparisonMachine { - private final E object; - private final E other; - private boolean conclusion; - - ComparisonMachine(E object, Class clz) { - this.object = object; - this.conclusion = clz.isInstance(otherObject); - this.other = conclusion ? clz.cast(otherObject) : null; + .map(Class::getName) + .map(it -> it + (it.endsWith("s") ? "es" : "s")) + .collect(Collectors.joining(" or ")))); + } + + /** Fluently compare a pair of parse tree nodes for equivalence. */ + private class ComparisonMachine { + private final E object; + private final E other; + private boolean conclusion; + + ComparisonMachine(E object, Class clz) { + this.object = object; + this.conclusion = clz.isInstance(otherObject); + this.other = conclusion ? clz.cast(otherObject) : null; + } + + /** Conclude false if the two given Lists are different as EObject sequences. Order matters. */ + ComparisonMachine listsEquivalent(Function> listGetter) { + if (conclusion) + conclusion = listsEqualish(listGetter, (T a, T b) -> new IsEqual(a).doSwitch(b)); + return this; + } + + /** Conclude false if the two given Lists are different as object sequences. Order matters. */ + ComparisonMachine listsEqualAsObjects(Function> listGetter) { + if (conclusion) conclusion = listsEqualish(listGetter, Objects::equals); + return this; + } + + boolean listsEqualish( + Function> listGetter, BiPredicate equalish) { + if (!conclusion) return false; + List list0 = listGetter.apply(object); + List list1 = listGetter.apply(other); + if (list0 == list1) return true; // e.g., they are both null + if (list0.size() != list1.size()) return false; + for (int i = 0; i < list0.size(); i++) { + if (!equalish.test(list0.get(i), list1.get(i))) { + return false; } - - /** - * Conclude false if the two given Lists are different as EObject - * sequences. Order matters. - */ - ComparisonMachine listsEquivalent(Function> listGetter) { - if (conclusion) conclusion = listsEqualish(listGetter, (T a, T b) -> new IsEqual(a).doSwitch(b)); - return this; - } - - /** - * Conclude false if the two given Lists are different as object - * sequences. Order matters. - */ - ComparisonMachine listsEqualAsObjects(Function> listGetter) { - if (conclusion) conclusion = listsEqualish(listGetter, Objects::equals); - return this; - } - - boolean listsEqualish(Function> listGetter, BiPredicate equalish) { - if (!conclusion) return false; - List list0 = listGetter.apply(object); - List list1 = listGetter.apply(other); - if (list0 == list1) return true; // e.g., they are both null - if (list0.size() != list1.size()) return false; - for (int i = 0; i < list0.size(); i++) { - if (!equalish.test(list0.get(i), list1.get(i))) { - return false; - } - } - return true; - } - - /** Conclude false if the two properties are not equal as objects. */ - ComparisonMachine equalAsObjects(Function propertyGetter) { - return equalAsObjectsModulo(propertyGetter, Function.identity()); - } - - /** - * Conclude false if the two properties are not equal as objects, - * given that {@code projectionToClassRepresentatives} maps each - * object to some semantically equivalent object. - */ - ComparisonMachine equalAsObjectsModulo( - Function propertyGetter, - Function projectionToClassRepresentatives - ) { - if (propertyGetter.apply(object) instanceof EObject) { - throw new IllegalArgumentException( - "EObjects should be compared for semantic equivalence, not object equality." - ); - } - propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); - if (conclusion) conclusion = Objects.equals(propertyGetter.apply(object), propertyGetter.apply(other)); - return this; - } - - /** - * Conclude false if the two properties are not semantically equivalent - * parse nodes. - */ - ComparisonMachine equivalent(Function propertyGetter) { - return equivalentModulo(propertyGetter, Function.identity()); - } - - /** - * Conclude false if the two properties are not semantically equivalent - * parse nodes, given that {@code projectionToClassRepresentatives} - * maps each parse node to some semantically equivalent node. - */ - ComparisonMachine equivalentModulo( - Function propertyGetter, - Function projectionToClassRepresentatives - ) { - propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); - if (conclusion) conclusion = new IsEqual(propertyGetter.apply(object)) - .doSwitch(propertyGetter.apply(other)); - return this; - } - } + } + return true; + } + + /** Conclude false if the two properties are not equal as objects. */ + ComparisonMachine equalAsObjects(Function propertyGetter) { + return equalAsObjectsModulo(propertyGetter, Function.identity()); + } + + /** + * Conclude false if the two properties are not equal as objects, given that {@code + * projectionToClassRepresentatives} maps each object to some semantically equivalent object. + */ + ComparisonMachine equalAsObjectsModulo( + Function propertyGetter, Function projectionToClassRepresentatives) { + if (propertyGetter.apply(object) instanceof EObject) { + throw new IllegalArgumentException( + "EObjects should be compared for semantic equivalence, not object equality."); + } + propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); + if (conclusion) + conclusion = Objects.equals(propertyGetter.apply(object), propertyGetter.apply(other)); + return this; + } + + /** Conclude false if the two properties are not semantically equivalent parse nodes. */ + ComparisonMachine equivalent(Function propertyGetter) { + return equivalentModulo(propertyGetter, Function.identity()); + } + + /** + * Conclude false if the two properties are not semantically equivalent parse nodes, given that + * {@code projectionToClassRepresentatives} maps each parse node to some semantically equivalent + * node. + */ + ComparisonMachine equivalentModulo( + Function propertyGetter, Function projectionToClassRepresentatives) { + propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); + if (conclusion) + conclusion = + new IsEqual(propertyGetter.apply(object)).doSwitch(propertyGetter.apply(other)); + return this; + } + } } diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index be8a68cf7d..2f0ec76d9b 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -881,9 +881,8 @@ public MalleableString caseInitializer(Initializer object) { } /** - * Return true if the initializer should be output with an equals initializer. - * Old-style assignments with parentheses are also output that - * way to help with the transition. + * Return true if the initializer should be output with an equals initializer. Old-style + * assignments with parentheses are also output that way to help with the transition. */ private boolean shouldOutputAsAssignment(Initializer init) { return init.isAssign() @@ -919,7 +918,6 @@ private MalleableString initializer(Initializer init) { return list(", ", prefix, suffix, false, false, init.getExprs()); } - @Override public MalleableString caseParameter(Parameter object) { // name=ID (':' (type=Type))? diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index c0475ad37d..349ff0fff7 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -1,30 +1,31 @@ -/** Instance of a federate specification. +/** + * Instance of a federate specification. * -Copyright (c) 2020, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ - + *

Copyright (c) 2020, The University of California at Berkeley. + * + *

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. + * + *

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR + * CONTRIBUTORS 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. + * ************* + */ package org.lflang.federated.generator; +import com.google.common.base.Objects; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; @@ -34,9 +35,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.EObject; - import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.TargetConfig; @@ -66,597 +65,557 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.VarRef; import org.lflang.lf.Variable; -import com.google.common.base.Objects; - - /** - * Instance of a federate, or marker that no federation has been defined - * (if isSingleton() returns true) FIXME: this comment makes no sense. - * Every top-level reactor (contained - * directly by the main reactor) is a federate, so there will be one - * instance of this class for each top-level reactor. + * Instance of a federate, or marker that no federation has been defined (if isSingleton() returns + * true) FIXME: this comment makes no sense. Every top-level reactor (contained directly by the main + * reactor) is a federate, so there will be one instance of this class for each top-level reactor. * * @author Edward A. Lee * @author Soroush Bateni */ public class FederateInstance { // why does this not extend ReactorInstance? - /** - * Construct a new instance with the specified instantiation of - * of a top-level reactor. The federate will be given the specified - * integer ID. - * @param instantiation The instantiation of a top-level reactor, - * or null if no federation has been defined. - * @param id The federate ID. - * @param bankIndex If instantiation.widthSpec !== null, this gives the bank position. - * @param errorReporter The error reporter - */ - public FederateInstance( - Instantiation instantiation, - int id, - int bankIndex, - TargetConfig targetConfig, - ErrorReporter errorReporter) { - this.instantiation = instantiation; - this.id = id; - this.bankIndex = bankIndex; - this.errorReporter = errorReporter; - this.targetConfig = targetConfig; - - if (instantiation != null) { - this.name = instantiation.getName(); - // If the instantiation is in a bank, then we have to append - // the bank index to the name. - if (instantiation.getWidthSpec() != null) { - this.name = instantiation.getName() + "__" + bankIndex; - } - } + /** + * Construct a new instance with the specified instantiation of of a top-level reactor. The + * federate will be given the specified integer ID. + * + * @param instantiation The instantiation of a top-level reactor, or null if no federation has + * been defined. + * @param id The federate ID. + * @param bankIndex If instantiation.widthSpec !== null, this gives the bank position. + * @param errorReporter The error reporter + */ + public FederateInstance( + Instantiation instantiation, + int id, + int bankIndex, + TargetConfig targetConfig, + ErrorReporter errorReporter) { + this.instantiation = instantiation; + this.id = id; + this.bankIndex = bankIndex; + this.errorReporter = errorReporter; + this.targetConfig = targetConfig; + + if (instantiation != null) { + this.name = instantiation.getName(); + // If the instantiation is in a bank, then we have to append + // the bank index to the name. + if (instantiation.getWidthSpec() != null) { + this.name = instantiation.getName() + "__" + bankIndex; + } } - - ///////////////////////////////////////////// - //// Public Fields - - /** - * The position within a bank of reactors for this federate. - * This is 0 if the instantiation is not a bank of reactors. - */ - public int bankIndex = 0; - - /** - * A list of outputs that can be triggered directly or indirectly by physical actions. - */ - public Set outputsConnectedToPhysicalActions = new LinkedHashSet<>(); - - /** - * The host, if specified using the 'at' keyword. - */ - public String host = "localhost"; - - - /** - * The instantiation of the top-level reactor, or null if there is no federation. - */ - public Instantiation instantiation; - public Instantiation getInstantiation() { - return instantiation; + } + + ///////////////////////////////////////////// + //// Public Fields + + /** + * The position within a bank of reactors for this federate. This is 0 if the instantiation is not + * a bank of reactors. + */ + public int bankIndex = 0; + + /** A list of outputs that can be triggered directly or indirectly by physical actions. */ + public Set outputsConnectedToPhysicalActions = new LinkedHashSet<>(); + + /** The host, if specified using the 'at' keyword. */ + public String host = "localhost"; + + /** The instantiation of the top-level reactor, or null if there is no federation. */ + public Instantiation instantiation; + + public Instantiation getInstantiation() { + return instantiation; + } + + /** A list of individual connections between federates */ + public Set connections = new HashSet<>(); + + /** + * Map from the federates that this federate receives messages from to the delays on connections + * from that federate. The delay set may include null, meaning that there is a connection from the + * federate instance that has no delay. + */ + public Map> dependsOn = new LinkedHashMap<>(); + + /** The directory, if specified using the 'at' keyword. */ + public String dir = null; + + /** The port, if specified using the 'at' keyword. */ + public int port = 0; + + /** + * Map from the federates that this federate sends messages to to the delays on connections to + * that federate. The delay set may may include null, meaning that there is a connection from the + * federate instance that has no delay. + */ + public Map> sendsTo = new LinkedHashMap<>(); + + /** The user, if specified using the 'at' keyword. */ + public String user = null; + + /** The integer ID of this federate. */ + public int id = 0; + + /** + * The name of this federate instance. This will be the instantiation name, possibly appended with + * "__n", where n is the bank position of this instance if the instantiation is of a bank of + * reactors. + */ + public String name = "Unnamed"; + + /** + * List of networkMessage actions. Each of these handles a message received from another federate + * over the network. The ID of receiving port is simply the position of the action in the list. + * The sending federate needs to specify this ID. + */ + public List networkMessageActions = new ArrayList<>(); + + /** + * A set of federates with which this federate has an inbound connection There will only be one + * physical connection even if federate A has defined multiple physical connections to federate B. + * The message handler on federate A will be responsible for including the appropriate information + * in the message header (such as port ID) to help the receiver distinguish different events. + */ + public Set inboundP2PConnections = new LinkedHashSet<>(); + + /** + * A list of federate with which this federate has an outbound physical connection. There will + * only be one physical connection even if federate A has defined multiple physical connections to + * federate B. The message handler on federate B will be responsible for distinguishing the + * incoming messages by parsing their header and scheduling the appropriate action. + */ + public Set outboundP2PConnections = new LinkedHashSet<>(); + + /** + * A list of triggers for network input control reactions. This is used to trigger all the input + * network control reactions that might be nested in a hierarchy. + */ + public List networkInputControlReactionsTriggers = new ArrayList<>(); + + /** + * The trigger that triggers the output control reaction of this federate. + * + *

The network output control reactions send a PORT_ABSENT message for a network output port, + * if it is absent at the current tag, to notify all downstream federates that no value will be + * present on the given network port, allowing input control reactions on those federates to stop + * blocking. + */ + public Variable networkOutputControlReactionsTrigger = null; + + /** Indicates whether the federate is remote or local */ + public boolean isRemote = false; + + /** + * List of generated network reactions (network receivers, network input control reactions, + * network senders, and network output control reactions) that belong to this federate instance. + */ + public List networkReactions = new ArrayList<>(); + + /** Parsed target config of the federate. */ + public TargetConfig targetConfig; + + /** Keep a unique list of enabled serializers */ + public HashSet enabledSerializers = new HashSet<>(); + + /** + * Return true if the specified EObject should be included in the code generated for this + * federate. + * + * @param object An {@code EObject} + * @return True if this federate contains the EObject. + */ + public boolean contains(EObject object) { + if (object instanceof Action) { + return contains((Action) object); + } else if (object instanceof Reaction) { + return contains((Reaction) object); + } else if (object instanceof Timer) { + return contains((Timer) object); + } else if (object instanceof ReactorDecl) { + return contains(this.instantiation, (ReactorDecl) object); + } else if (object instanceof Import) { + return contains((Import) object); + } else if (object instanceof Parameter) { + return contains((Parameter) object); + } else if (object instanceof StateVar) { + return true; // FIXME: Should we disallow state vars at the top level? + } + throw new UnsupportedOperationException( + "EObject class " + object.eClass().getName() + " not supported."); + } + + /** + * Return true if the specified reactor belongs to this federate. + * + * @param instantiation The instantiation to look inside + * @param reactor The reactor declaration to find + */ + private boolean contains(Instantiation instantiation, ReactorDecl reactor) { + if (instantiation.getReactorClass().equals(ASTUtils.toDefinition(reactor))) { + return true; } - /** - * A list of individual connections between federates - */ - public Set connections = new HashSet<>(); - - /** - * Map from the federates that this federate receives messages from - * to the delays on connections from that federate. The delay set - * may include null, meaning that there is a connection - * from the federate instance that has no delay. - */ - public Map> dependsOn = new LinkedHashMap<>(); - - /** - * The directory, if specified using the 'at' keyword. - */ - public String dir = null; - - /** - * The port, if specified using the 'at' keyword. - */ - public int port = 0; - - /** - * Map from the federates that this federate sends messages to - * to the delays on connections to that federate. The delay set - * may may include null, meaning that there is a connection - * from the federate instance that has no delay. - */ - public Map> sendsTo = new LinkedHashMap<>(); - - /** - * The user, if specified using the 'at' keyword. - */ - public String user = null; - - /** - * The integer ID of this federate. - */ - public int id = 0; - - - /** - * The name of this federate instance. This will be the instantiation - * name, possibly appended with "__n", where n is the bank position of - * this instance if the instantiation is of a bank of reactors. - */ - public String name = "Unnamed"; - - /** - * List of networkMessage actions. Each of these handles a message - * received from another federate over the network. The ID of - * receiving port is simply the position of the action in the list. - * The sending federate needs to specify this ID. - */ - public List networkMessageActions = new ArrayList<>(); - - /** - * A set of federates with which this federate has an inbound connection - * There will only be one physical connection even if federate A has defined multiple - * physical connections to federate B. The message handler on federate A will be - * responsible for including the appropriate information in the message header (such as port ID) - * to help the receiver distinguish different events. - */ - public Set inboundP2PConnections = new LinkedHashSet<>(); - - /** - * A list of federate with which this federate has an outbound physical connection. - * There will only be one physical connection even if federate A has defined multiple - * physical connections to federate B. The message handler on federate B will be - * responsible for distinguishing the incoming messages by parsing their header and - * scheduling the appropriate action. - */ - public Set outboundP2PConnections = new LinkedHashSet<>(); - - /** - * A list of triggers for network input control reactions. This is used to trigger - * all the input network control reactions that might be nested in a hierarchy. - */ - public List networkInputControlReactionsTriggers = new ArrayList<>(); - - /** - * The trigger that triggers the output control reaction of this - * federate. - * - * The network output control reactions send a PORT_ABSENT message for a network output port, - * if it is absent at the current tag, to notify all downstream federates that no value will - * be present on the given network port, allowing input control reactions on those federates - * to stop blocking. - */ - public Variable networkOutputControlReactionsTrigger = null; - - /** - * Indicates whether the federate is remote or local - */ - public boolean isRemote = false; - - /** - * List of generated network reactions (network receivers, - * network input control reactions, network senders, and network output control - * reactions) that belong to this federate instance. - */ - public List networkReactions = new ArrayList<>(); - - /** - * Parsed target config of the federate. - */ - public TargetConfig targetConfig; - - /** - * Keep a unique list of enabled serializers - */ - public HashSet enabledSerializers = new HashSet<>(); - - /** - * Return true if the specified EObject should be included in the code - * generated for this federate. - * - * @param object An {@code EObject} - * @return True if this federate contains the EObject. - */ - public boolean contains(EObject object) { - if (object instanceof Action) { - return contains((Action)object); - } else if (object instanceof Reaction) { - return contains((Reaction)object); - } else if (object instanceof Timer) { - return contains((Timer)object); - } else if (object instanceof ReactorDecl) { - return contains(this.instantiation, (ReactorDecl)object); - } else if (object instanceof Import) { - return contains((Import)object); - } else if (object instanceof Parameter) { - return contains((Parameter)object); - } else if (object instanceof StateVar) { - return true; // FIXME: Should we disallow state vars at the top level? - } - throw new UnsupportedOperationException("EObject class "+object.eClass().getName()+" not supported."); + boolean instantiationsCheck = false; + // For a federate, we don't need to look inside imported reactors. + if (instantiation.getReactorClass() instanceof Reactor reactorDef) { + for (Instantiation child : reactorDef.getInstantiations()) { + instantiationsCheck |= contains(child, reactor); + } } - /** - * Return true if the specified reactor belongs to this federate. - * @param instantiation The instantiation to look inside - * @param reactor The reactor declaration to find - */ - private boolean contains( - Instantiation instantiation, - ReactorDecl reactor - ) { - if (instantiation.getReactorClass().equals(ASTUtils.toDefinition(reactor))) { + return instantiationsCheck; + } + + /** + * Return true if the specified import should be included in the code generated for this federate. + * + * @param imp The import + */ + private boolean contains(Import imp) { + for (ImportedReactor reactor : imp.getReactorClasses()) { + if (contains(reactor)) { + return true; + } + } + return false; + } + + /** + * Return true if the specified parameter should be included in the code generated for this + * federate. + * + * @param param The parameter + */ + private boolean contains(Parameter param) { + boolean returnValue = false; + // Check if param is referenced in this federate's instantiation + returnValue = + instantiation.getParameters().stream() + .anyMatch( + assignment -> + assignment.getRhs().getExprs().stream() + .filter(it -> it instanceof ParameterReference) + .map(it -> ((ParameterReference) it).getParameter()) + .toList() + .contains(param)); + // If there are any user-defined top-level reactions, they could access + // the parameters, so we need to include the parameter. + var topLevelUserDefinedReactions = + ((Reactor) instantiation.eContainer()) + .getReactions().stream() + .filter(r -> !networkReactions.contains(r) && contains(r)) + .collect(Collectors.toCollection(ArrayList::new)); + returnValue |= !topLevelUserDefinedReactions.isEmpty(); + return returnValue; + } + + /** + * Return true if the specified action should be included in the code generated for this federate. + * This means that either the action is used as a trigger, a source, or an effect in a top-level + * reaction that belongs to this federate. This returns true if the program is not federated. + * + * @param action The action + * @return True if this federate contains the action. + */ + private boolean contains(Action action) { + Reactor reactor = ASTUtils.getEnclosingReactor(action); + + // If the action is used as a trigger, a source, or an effect for a top-level reaction + // that belongs to this federate, then generate it. + for (Reaction react : ASTUtils.allReactions(reactor)) { + if (contains(react)) { + // Look in triggers + for (TriggerRef trigger : convertToEmptyListIfNull(react.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (Objects.equal(triggerAsVarRef.getVariable(), action)) { + return true; + } + } + } + // Look in sources + for (VarRef source : convertToEmptyListIfNull(react.getSources())) { + if (Objects.equal(source.getVariable(), action)) { return true; + } } - - boolean instantiationsCheck = false; - // For a federate, we don't need to look inside imported reactors. - if (instantiation.getReactorClass() instanceof Reactor reactorDef) { - for (Instantiation child : reactorDef.getInstantiations()) { - instantiationsCheck |= contains(child, reactor); - } + // Look in effects + for (VarRef effect : convertToEmptyListIfNull(react.getEffects())) { + if (Objects.equal(effect.getVariable(), action)) { + return true; + } } + } + } - return instantiationsCheck; + return false; + } + + /** + * Return true if the specified reaction should be included in the code generated for this + * federate at the top-level. This means that if the reaction is triggered by or sends data to a + * port of a contained reactor, then that reaction is in the federate. Otherwise, return false. + * + *

NOTE: This method assumes that it will not be called with reaction arguments that are within + * other federates. It should only be called on reactions that are either at the top level or + * within this federate. For this reason, for any reaction not at the top level, it returns true. + * + * @param reaction The reaction. + */ + private boolean contains(Reaction reaction) { + Reactor reactor = ASTUtils.getEnclosingReactor(reaction); + + assert reactor != null; + if (!reactor.getReactions().contains(reaction)) return false; + + if (networkReactions.contains(reaction)) { + // Reaction is a network reaction that belongs to this federate + return true; } - /** - * Return true if the specified import should be included in the code generated for this federate. - * @param imp The import - */ - private boolean contains(Import imp) { - for (ImportedReactor reactor : imp.getReactorClasses()) { - if (contains(reactor)) { - return true; - } - } - return false; + int reactionBankIndex = FedASTUtils.getReactionBankIndex(reaction); + if (reactionBankIndex >= 0 && this.bankIndex >= 0 && reactionBankIndex != this.bankIndex) { + return false; } - /** - * Return true if the specified parameter should be included in the code generated for this federate. - * @param param The parameter - */ - private boolean contains(Parameter param) { - boolean returnValue = false; - // Check if param is referenced in this federate's instantiation - returnValue = instantiation.getParameters().stream().anyMatch( - assignment -> assignment.getRhs() - .getExprs() - .stream() - .filter( - it -> it instanceof ParameterReference - ) - .map(it -> ((ParameterReference) it).getParameter()) - .toList() - .contains(param) - ); - // If there are any user-defined top-level reactions, they could access - // the parameters, so we need to include the parameter. - var topLevelUserDefinedReactions = ((Reactor) instantiation.eContainer()) - .getReactions().stream().filter( - r -> !networkReactions.contains(r) && contains(r) - ).collect(Collectors.toCollection(ArrayList::new)); - returnValue |= !topLevelUserDefinedReactions.isEmpty(); - return returnValue; + // If this has been called before, then the result of the + // following check is cached. + if (excludeReactions != null) { + return !excludeReactions.contains(reaction); } - /** - * Return true if the specified action should be included in the code generated - * for this federate. This means that either the action is used as a trigger, - * a source, or an effect in a top-level reaction that belongs to this federate. - * This returns true if the program is not federated. - * - * @param action The action - * @return True if this federate contains the action. - */ - private boolean contains(Action action) { - Reactor reactor = ASTUtils.getEnclosingReactor(action); - - // If the action is used as a trigger, a source, or an effect for a top-level reaction - // that belongs to this federate, then generate it. - for (Reaction react : ASTUtils.allReactions(reactor)) { - if (contains(react)) { - // Look in triggers - for (TriggerRef trigger : convertToEmptyListIfNull(react.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (Objects.equal(triggerAsVarRef.getVariable(), action)) { - return true; - } - } - } - // Look in sources - for (VarRef source : convertToEmptyListIfNull(react.getSources())) { - if (Objects.equal(source.getVariable(), action)) { - return true; - } - } - // Look in effects - for (VarRef effect : convertToEmptyListIfNull(react.getEffects())) { - if (Objects.equal(effect.getVariable(), action)) { - return true; - } - } + indexExcludedTopLevelReactions(reactor); + + return !excludeReactions.contains(reaction); + } + + /** + * Return true if the specified timer should be included in the code generated for the federate. + * This means that the timer is used as a trigger in a top-level reaction that belongs to this + * federate. This also returns true if the program is not federated. + * + * @return True if this federate contains the action in the specified reactor + */ + private boolean contains(Timer timer) { + Reactor reactor = ASTUtils.getEnclosingReactor(timer); + + // If the action is used as a trigger, a source, or an effect for a top-level reaction + // that belongs to this federate, then generate it. + for (Reaction r : ASTUtils.allReactions(reactor)) { + if (contains(r)) { + // Look in triggers + for (TriggerRef trigger : convertToEmptyListIfNull(r.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (Objects.equal(triggerAsVarRef.getVariable(), timer)) { + return true; } + } } - - return false; + } } - - /** - * Return true if the specified reaction should be included in the code generated for this - * federate at the top-level. This means that if the reaction is triggered by or - * sends data to a port of a contained reactor, then that reaction - * is in the federate. Otherwise, return false. - * - * NOTE: This method assumes that it will not be called with reaction arguments - * that are within other federates. It should only be called on reactions that are - * either at the top level or within this federate. For this reason, for any reaction - * not at the top level, it returns true. - * - * @param reaction The reaction. - */ - private boolean contains(Reaction reaction) { - Reactor reactor = ASTUtils.getEnclosingReactor(reaction); - - assert reactor != null; - if (!reactor.getReactions().contains(reaction)) return false; - - if (networkReactions.contains(reaction)) { - // Reaction is a network reaction that belongs to this federate - return true; - } - - int reactionBankIndex = FedASTUtils.getReactionBankIndex(reaction); - if (reactionBankIndex >= 0 && this.bankIndex >= 0 && reactionBankIndex != this.bankIndex) { - return false; - } - - // If this has been called before, then the result of the - // following check is cached. - if (excludeReactions != null) { - return !excludeReactions.contains(reaction); - } - - indexExcludedTopLevelReactions(reactor); - - return !excludeReactions.contains(reaction); + return false; + } + + /** + * Return true if the specified reactor instance or any parent reactor instance is contained by + * this federate. If the specified instance is the top-level reactor, return true (the top-level + * reactor belongs to all federates). If this federate instance is a singleton, then return true + * if the instance is non null. + * + *

NOTE: If the instance is bank within the top level, then this returns true even though only + * one of the bank members is in the federate. + * + * @param instance The reactor instance. + * @return True if this federate contains the reactor instance + */ + public boolean contains(ReactorInstance instance) { + if (instance.getParent() == null) { + return true; // Top-level reactor } - - /** - * Return true if the specified timer should be included in the code generated - * for the federate. This means that the timer is used as a trigger - * in a top-level reaction that belongs to this federate. - * This also returns true if the program is not federated. - * - * @return True if this federate contains the action in the specified reactor - */ - private boolean contains(Timer timer) { - Reactor reactor = ASTUtils.getEnclosingReactor(timer); - - // If the action is used as a trigger, a source, or an effect for a top-level reaction - // that belongs to this federate, then generate it. - for (Reaction r : ASTUtils.allReactions(reactor)) { - if (contains(r)) { - // Look in triggers - for (TriggerRef trigger : convertToEmptyListIfNull(r.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (Objects.equal(triggerAsVarRef.getVariable(), timer)) { - return true; - } - } - } - } - } - return false; + // Start with this instance, then check its parents. + ReactorInstance i = instance; + while (i != null) { + if (i.getDefinition() == instantiation) { + return true; + } + i = i.getParent(); } - - /** - * Return true if the specified reactor instance or any parent - * reactor instance is contained by this federate. - * If the specified instance is the top-level reactor, return true - * (the top-level reactor belongs to all federates). - * If this federate instance is a singleton, then return true if the - * instance is non null. - * - * NOTE: If the instance is bank within the top level, then this - * returns true even though only one of the bank members is in the federate. - * - * @param instance The reactor instance. - * @return True if this federate contains the reactor instance - */ - public boolean contains(ReactorInstance instance) { - if (instance.getParent() == null) { - return true; // Top-level reactor - } - // Start with this instance, then check its parents. - ReactorInstance i = instance; - while (i != null) { - if (i.getDefinition() == instantiation) { - return true; - } - i = i.getParent(); - } - return false; + return false; + } + + /** + * Build an index of reactions at the top-level (in the federatedReactor) that don't belong to + * this federate instance. This index is put in the excludeReactions class variable. + * + * @param federatedReactor The top-level federated reactor + */ + private void indexExcludedTopLevelReactions(Reactor federatedReactor) { + boolean inFederate = false; + if (excludeReactions != null) { + throw new IllegalStateException( + "The index for excluded reactions at the top level is already built."); } - /** - * Build an index of reactions at the top-level (in the - * federatedReactor) that don't belong to this federate - * instance. This index is put in the excludeReactions - * class variable. - * - * @param federatedReactor The top-level federated reactor - */ - private void indexExcludedTopLevelReactions(Reactor federatedReactor) { - boolean inFederate = false; - if (excludeReactions != null) { - throw new IllegalStateException("The index for excluded reactions at the top level is already built."); - } - - excludeReactions = new LinkedHashSet<>(); - - // Construct the set of excluded reactions for this federate. - // If a reaction is a network reaction that belongs to this federate, we - // don't need to perform this analysis. - Iterable reactions = ASTUtils.allReactions(federatedReactor).stream().filter(it -> !networkReactions.contains(it)).collect(Collectors.toList()); - for (Reaction react : reactions) { - // Create a collection of all the VarRefs (i.e., triggers, sources, and effects) in the react - // signature that are ports that reference federates. - // We then later check that all these VarRefs reference this federate. If not, we will add this - // react to the list of reactions that have to be excluded (note that mixing VarRefs from - // different federates is not allowed). - List allVarRefsReferencingFederates = new ArrayList<>(); - // Add all the triggers that are outputs - Stream triggersAsVarRef = react.getTriggers().stream().filter(it -> it instanceof VarRef).map(it -> (VarRef) it); - allVarRefsReferencingFederates.addAll( - triggersAsVarRef.filter(it -> it.getVariable() instanceof Output).toList() - ); - // Add all the sources that are outputs - allVarRefsReferencingFederates.addAll( - react.getSources().stream().filter(it -> it.getVariable() instanceof Output).toList() - ); - // Add all the effects that are inputs - allVarRefsReferencingFederates.addAll( - react.getEffects().stream().filter(it -> it.getVariable() instanceof Input).toList() - ); - inFederate = containsAllVarRefs(allVarRefsReferencingFederates); - if (!inFederate) { - excludeReactions.add(react); - } + excludeReactions = new LinkedHashSet<>(); + + // Construct the set of excluded reactions for this federate. + // If a reaction is a network reaction that belongs to this federate, we + // don't need to perform this analysis. + Iterable reactions = + ASTUtils.allReactions(federatedReactor).stream() + .filter(it -> !networkReactions.contains(it)) + .collect(Collectors.toList()); + for (Reaction react : reactions) { + // Create a collection of all the VarRefs (i.e., triggers, sources, and effects) in the react + // signature that are ports that reference federates. + // We then later check that all these VarRefs reference this federate. If not, we will add + // this + // react to the list of reactions that have to be excluded (note that mixing VarRefs from + // different federates is not allowed). + List allVarRefsReferencingFederates = new ArrayList<>(); + // Add all the triggers that are outputs + Stream triggersAsVarRef = + react.getTriggers().stream().filter(it -> it instanceof VarRef).map(it -> (VarRef) it); + allVarRefsReferencingFederates.addAll( + triggersAsVarRef.filter(it -> it.getVariable() instanceof Output).toList()); + // Add all the sources that are outputs + allVarRefsReferencingFederates.addAll( + react.getSources().stream().filter(it -> it.getVariable() instanceof Output).toList()); + // Add all the effects that are inputs + allVarRefsReferencingFederates.addAll( + react.getEffects().stream().filter(it -> it.getVariable() instanceof Input).toList()); + inFederate = containsAllVarRefs(allVarRefsReferencingFederates); + if (!inFederate) { + excludeReactions.add(react); + } + } + } + + /** + * Return true if all members of 'varRefs' belong to this federate. + * + *

As a convenience measure, if some members of 'varRefs' are from different federates, also + * report an error. + * + * @param varRefs A collection of VarRefs + */ + private boolean containsAllVarRefs(Iterable varRefs) { + var referencesFederate = false; + var inFederate = true; + for (VarRef varRef : varRefs) { + if (varRef.getContainer() == this.instantiation) { + referencesFederate = true; + } else { + if (referencesFederate) { + errorReporter.reportError( + varRef, + "Mixed triggers and effects from" + " different federates. This is not permitted"); } + inFederate = false; + } } - - /** - * Return true if all members of 'varRefs' belong to this federate. - * - * As a convenience measure, if some members of 'varRefs' are from - * different federates, also report an error. - * - * @param varRefs A collection of VarRefs - */ - private boolean containsAllVarRefs(Iterable varRefs) { - var referencesFederate = false; - var inFederate = true; - for (VarRef varRef : varRefs) { - if (varRef.getContainer() == this.instantiation) { - referencesFederate = true; - } else { - if (referencesFederate) { - errorReporter.reportError(varRef, - "Mixed triggers and effects from" - + - " different federates. This is not permitted"); - } - inFederate = false; - } + return inFederate; + } + + /** + * Find output ports that are connected to a physical action trigger upstream in the same reactor. + * Return a list of such outputs paired with the minimum delay from the nearest physical action. + * + * @param instance The reactor instance containing the output ports + * @return A LinkedHashMap + */ + public LinkedHashMap findOutputsConnectedToPhysicalActions( + ReactorInstance instance) { + LinkedHashMap physicalActionToOutputMinDelay = new LinkedHashMap<>(); + // Find reactions that write to the output port of the reactor + for (PortInstance output : instance.outputs) { + for (ReactionInstance reaction : output.getDependsOnReactions()) { + TimeValue minDelay = findNearestPhysicalActionTrigger(reaction); + if (!Objects.equal(minDelay, TimeValue.MAX_VALUE)) { + physicalActionToOutputMinDelay.put((Output) output.getDefinition(), minDelay); } - return inFederate; + } } - - /** - * Find output ports that are connected to a physical action trigger upstream - * in the same reactor. Return a list of such outputs paired with the minimum delay - * from the nearest physical action. - * @param instance The reactor instance containing the output ports - * @return A LinkedHashMap - */ - public LinkedHashMap findOutputsConnectedToPhysicalActions(ReactorInstance instance) { - LinkedHashMap physicalActionToOutputMinDelay = new LinkedHashMap<>(); - // Find reactions that write to the output port of the reactor - for (PortInstance output : instance.outputs) { - for (ReactionInstance reaction : output.getDependsOnReactions()) { - TimeValue minDelay = findNearestPhysicalActionTrigger(reaction); - if (!Objects.equal(minDelay, TimeValue.MAX_VALUE)) { - physicalActionToOutputMinDelay.put((Output) output.getDefinition(), minDelay); - } + return physicalActionToOutputMinDelay; + } + + /** + * Return a list of federates that are upstream of this federate and have a zero-delay (direct) + * connection to this federate. + */ + public List getZeroDelayImmediateUpstreamFederates() { + return this.dependsOn.entrySet().stream() + .filter(e -> e.getValue().contains(null)) + .map(Map.Entry::getKey) + .toList(); + } + + @Override + public String toString() { + return "Federate " + + id + + ": " + + ((instantiation != null) ? instantiation.getName() : "no name"); + } + + ///////////////////////////////////////////// + //// Private Fields + + /** Cached result of analysis of which reactions to exclude from main. */ + private Set excludeReactions = null; + + /** An error reporter */ + private final ErrorReporter errorReporter; + + /** + * Find the nearest (shortest) path to a physical action trigger from this 'reaction' in terms of + * minimum delay. + * + * @param reaction The reaction to start with + * @return The minimum delay found to the nearest physical action and TimeValue.MAX_VALUE + * otherwise + */ + public TimeValue findNearestPhysicalActionTrigger(ReactionInstance reaction) { + TimeValue minDelay = TimeValue.MAX_VALUE; + for (TriggerInstance trigger : reaction.triggers) { + if (trigger.getDefinition() instanceof Action action) { + ActionInstance actionInstance = (ActionInstance) trigger; + if (action.getOrigin() == ActionOrigin.PHYSICAL) { + if (actionInstance.getMinDelay().isEarlierThan(minDelay)) { + minDelay = actionInstance.getMinDelay(); + } + } else if (action.getOrigin() == ActionOrigin.LOGICAL) { + // Logical action + // Follow it upstream inside the reactor + for (ReactionInstance uReaction : actionInstance.getDependsOnReactions()) { + // Avoid a loop + if (!Objects.equal(uReaction, reaction)) { + TimeValue uMinDelay = + actionInstance.getMinDelay().add(findNearestPhysicalActionTrigger(uReaction)); + if (uMinDelay.isEarlierThan(minDelay)) { + minDelay = uMinDelay; + } } + } } - return physicalActionToOutputMinDelay; - } - - /** - * Return a list of federates that are upstream of this federate and have a - * zero-delay (direct) connection to this federate. - */ - public List getZeroDelayImmediateUpstreamFederates() { - return this.dependsOn.entrySet() - .stream() - .filter(e -> e.getValue().contains(null)) - .map(Map.Entry::getKey).toList(); - } - - @Override - public String toString() { - return "Federate " + id + ": " - + ((instantiation != null) ? instantiation.getName() : "no name"); - } - ///////////////////////////////////////////// - //// Private Fields - - /** - * Cached result of analysis of which reactions to exclude from main. - */ - private Set excludeReactions = null; - - /** - * An error reporter - */ - private final ErrorReporter errorReporter; - - /** - * Find the nearest (shortest) path to a physical action trigger from this - * 'reaction' in terms of minimum delay. - * - * @param reaction The reaction to start with - * @return The minimum delay found to the nearest physical action and - * TimeValue.MAX_VALUE otherwise - */ - public TimeValue findNearestPhysicalActionTrigger(ReactionInstance reaction) { - TimeValue minDelay = TimeValue.MAX_VALUE; - for (TriggerInstance trigger : reaction.triggers) { - if (trigger.getDefinition() instanceof Action action) { - ActionInstance actionInstance = (ActionInstance) trigger; - if (action.getOrigin() == ActionOrigin.PHYSICAL) { - if (actionInstance.getMinDelay().isEarlierThan(minDelay)) { - minDelay = actionInstance.getMinDelay(); - } - } else if (action.getOrigin() == ActionOrigin.LOGICAL) { - // Logical action - // Follow it upstream inside the reactor - for (ReactionInstance uReaction: actionInstance.getDependsOnReactions()) { - // Avoid a loop - if (!Objects.equal(uReaction, reaction)) { - TimeValue uMinDelay = actionInstance.getMinDelay().add(findNearestPhysicalActionTrigger(uReaction)); - if (uMinDelay.isEarlierThan(minDelay)) { - minDelay = uMinDelay; - } - } - } - } - - } else if (trigger.getDefinition() instanceof Output) { - // Outputs of contained reactions - PortInstance outputInstance = (PortInstance) trigger; - for (ReactionInstance uReaction: outputInstance.getDependsOnReactions()) { - TimeValue uMinDelay = findNearestPhysicalActionTrigger(uReaction); - if (uMinDelay.isEarlierThan(minDelay)) { - minDelay = uMinDelay; - } - } - } + } else if (trigger.getDefinition() instanceof Output) { + // Outputs of contained reactions + PortInstance outputInstance = (PortInstance) trigger; + for (ReactionInstance uReaction : outputInstance.getDependsOnReactions()) { + TimeValue uMinDelay = findNearestPhysicalActionTrigger(uReaction); + if (uMinDelay.isEarlierThan(minDelay)) { + minDelay = uMinDelay; + } } - return minDelay; - } - - // TODO: Put this function into a utils file instead - private List convertToEmptyListIfNull(List list) { - return list == null ? new ArrayList<>() : list; + } } + return minDelay; + } + + // TODO: Put this function into a utils file instead + private List convertToEmptyListIfNull(List list) { + return list == null ? new ArrayList<>() : list; + } } diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index ac141b9259..9ae46ad357 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2019-2020, The University of California at Berkeley. - + * * 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. - + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -24,23 +24,23 @@ ***************/ package org.lflang.generator; +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; import java.io.IOException; import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; -import java.util.LinkedHashSet; import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; - import org.eclipse.core.resources.IMarker; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.IteratorExtensions; - import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; @@ -53,17 +53,12 @@ import org.lflang.lf.Instantiation; import org.lflang.lf.LfFactory; import org.lflang.lf.Mode; - import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; import org.lflang.validation.AbstractLFValidator; -import com.google.common.base.Objects; -import com.google.common.collect.Iterables; - /** - * Generator base class for specifying core functionality - * that all code generators should have. + * Generator base class for specifying core functionality that all code generators should have. * * @author Edward A. Lee * @author Marten Lohstroh @@ -73,598 +68,595 @@ */ public abstract class GeneratorBase extends AbstractLFValidator { - //////////////////////////////////////////// - //// Public fields. - - /** - * The main (top-level) reactor instance. - */ - public ReactorInstance main; - - /** An error reporter for reporting any errors or warnings during the code generation */ - public ErrorReporter errorReporter; - - //////////////////////////////////////////// - //// Protected fields. - - /** - * The current target configuration. - */ - protected final TargetConfig targetConfig; - - public TargetConfig getTargetConfig() { return this.targetConfig;} - - public final LFGeneratorContext context; - - /** - * A factory for compiler commands. - */ - protected GeneratorCommandFactory commandFactory; - - public GeneratorCommandFactory getCommandFactory() { return commandFactory; } - - /** - * Definition of the main (top-level) reactor. - * This is an automatically generated AST node for the top-level - * reactor. - */ - protected Instantiation mainDef; - public Instantiation getMainDef() { return mainDef; } - - /** - * A list of Reactor definitions in the main resource, including non-main - * reactors defined in imported resources. These are ordered in the list in - * such a way that each reactor is preceded by any reactor that it instantiates - * using a command like `foo = new Foo();` - */ - protected List reactors = new ArrayList<>(); - - /** - * The set of resources referenced reactor classes reside in. - */ - protected Set resources = new LinkedHashSet<>(); // FIXME: Why do we need this? - - /** - * Graph that tracks dependencies between instantiations. - * This is a graph where each node is a Reactor (not a ReactorInstance) - * and an arc from Reactor A to Reactor B means that B contains an instance of A, constructed with a statement - * like `a = new A();` After creating the graph, - * sort the reactors in topological order and assign them to the reactors class variable. - * Hence, after this method returns, `this.reactors` will be a list of Reactors such that any - * reactor is preceded in the list by reactors that it instantiates. - */ - protected InstantiationGraph instantiationGraph; - - /** - * The set of unordered reactions. An unordered reaction is one that does - * not have any dependency on other reactions in the containing reactor, - * and where no other reaction in the containing reactor depends on it. - * There is currently no way in the syntax of LF to make a reaction - * unordered, deliberately, because it can introduce unexpected - * nondeterminacy. However, certain automatically generated reactions are - * known to be safe to be unordered because they do not interact with the - * state of the containing reactor. To make a reaction unordered, when - * the Reaction instance is created, add that instance to this set. - */ - protected Set unorderedReactions = null; - - /** - * Map from reactions to bank indices - */ - protected Map reactionBankIndices = null; - - /** - * Indicates whether the current Lingua Franca program - * contains model reactors. - */ - public boolean hasModalReactors = false; - - /** - * Indicates whether the program has any deadlines and thus - * needs to propagate deadlines through the reaction instance graph - */ - public boolean hasDeadlines = false; - - /** - * Indicates whether the program has any watchdogs. - * This is used to check for support. - */ - public boolean hasWatchdogs = false; - - // ////////////////////////////////////////// - // // Private fields. - - /** - * A list ot AST transformations to apply before code generation - */ - private final List astTransformations = new ArrayList<>(); - - /** - * Create a new GeneratorBase object. - */ - public GeneratorBase(LFGeneratorContext context) { - this.context = context; - this.targetConfig = context.getTargetConfig(); - this.errorReporter = context.getErrorReporter(); - this.commandFactory = new GeneratorCommandFactory(errorReporter, context.getFileConfig()); + //////////////////////////////////////////// + //// Public fields. + + /** The main (top-level) reactor instance. */ + public ReactorInstance main; + + /** An error reporter for reporting any errors or warnings during the code generation */ + public ErrorReporter errorReporter; + + //////////////////////////////////////////// + //// Protected fields. + + /** The current target configuration. */ + protected final TargetConfig targetConfig; + + public TargetConfig getTargetConfig() { + return this.targetConfig; + } + + public final LFGeneratorContext context; + + /** A factory for compiler commands. */ + protected GeneratorCommandFactory commandFactory; + + public GeneratorCommandFactory getCommandFactory() { + return commandFactory; + } + + /** + * Definition of the main (top-level) reactor. This is an automatically generated AST node for the + * top-level reactor. + */ + protected Instantiation mainDef; + + public Instantiation getMainDef() { + return mainDef; + } + + /** + * A list of Reactor definitions in the main resource, including non-main reactors defined in + * imported resources. These are ordered in the list in such a way that each reactor is preceded + * by any reactor that it instantiates using a command like `foo = new Foo();` + */ + protected List reactors = new ArrayList<>(); + + /** The set of resources referenced reactor classes reside in. */ + protected Set resources = new LinkedHashSet<>(); // FIXME: Why do we need this? + + /** + * Graph that tracks dependencies between instantiations. This is a graph where each node is a + * Reactor (not a ReactorInstance) and an arc from Reactor A to Reactor B means that B contains an + * instance of A, constructed with a statement like `a = new A();` After creating the graph, sort + * the reactors in topological order and assign them to the reactors class variable. Hence, after + * this method returns, `this.reactors` will be a list of Reactors such that any reactor is + * preceded in the list by reactors that it instantiates. + */ + protected InstantiationGraph instantiationGraph; + + /** + * The set of unordered reactions. An unordered reaction is one that does not have any dependency + * on other reactions in the containing reactor, and where no other reaction in the containing + * reactor depends on it. There is currently no way in the syntax of LF to make a reaction + * unordered, deliberately, because it can introduce unexpected nondeterminacy. However, certain + * automatically generated reactions are known to be safe to be unordered because they do not + * interact with the state of the containing reactor. To make a reaction unordered, when the + * Reaction instance is created, add that instance to this set. + */ + protected Set unorderedReactions = null; + + /** Map from reactions to bank indices */ + protected Map reactionBankIndices = null; + + /** Indicates whether the current Lingua Franca program contains model reactors. */ + public boolean hasModalReactors = false; + + /** + * Indicates whether the program has any deadlines and thus needs to propagate deadlines through + * the reaction instance graph + */ + public boolean hasDeadlines = false; + + /** Indicates whether the program has any watchdogs. This is used to check for support. */ + public boolean hasWatchdogs = false; + + // ////////////////////////////////////////// + // // Private fields. + + /** A list ot AST transformations to apply before code generation */ + private final List astTransformations = new ArrayList<>(); + + /** Create a new GeneratorBase object. */ + public GeneratorBase(LFGeneratorContext context) { + this.context = context; + this.targetConfig = context.getTargetConfig(); + this.errorReporter = context.getErrorReporter(); + this.commandFactory = new GeneratorCommandFactory(errorReporter, context.getFileConfig()); + } + + /** + * Register an AST transformation to be applied to the AST. + * + *

The transformations will be applied in the order that they are registered in. + */ + protected void registerTransformation(AstTransformation transformation) { + astTransformations.add(transformation); + } + + // ////////////////////////////////////////// + // // Code generation functions to override for a concrete code generator. + + /** + * If there is a main or federated reactor, then create a synthetic Instantiation for that + * top-level reactor and set the field mainDef to refer to it. + */ + private void createMainInstantiation() { + // Find the main reactor and create an AST node for its instantiation. + Iterable nodes = + IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); + for (Reactor reactor : Iterables.filter(nodes, Reactor.class)) { + if (reactor.isMain()) { + // Creating a definition for the main reactor because there isn't one. + this.mainDef = LfFactory.eINSTANCE.createInstantiation(); + this.mainDef.setName(reactor.getName()); + this.mainDef.setReactorClass(reactor); + } } - - /** - * Register an AST transformation to be applied to the AST. - * - * The transformations will be applied in the order that they are registered in. - */ - protected void registerTransformation(AstTransformation transformation) { - astTransformations.add(transformation); + } + + /** + * Generate code from the Lingua Franca model contained by the specified resource. + * + *

This is the main entry point for code generation. This base class finds all reactor class + * definitions, including any reactors defined in imported .lf files (except any main reactors in + * those imported files), and adds them to the {@link GeneratorBase#reactors reactors} list. If + * errors occur during generation, then a subsequent call to errorsOccurred() will return true. + * + * @param resource The resource containing the source code. + * @param context Context relating to invocation of the code generator. In standalone mode, this + * object is also used to relay CLI arguments. + */ + public void doGenerate(Resource resource, LFGeneratorContext context) { + + // FIXME: the signature can be reduced to only take context. + // The constructor also need not take a file config because this is tied to the context as well. + cleanIfNeeded(context); + + printInfo(context.getMode()); + + // Clear any IDE markers that may have been created by a previous build. + // Markers mark problems in the Eclipse IDE when running in integrated mode. + errorReporter.clearHistory(); + + ASTUtils.setMainName(context.getFileConfig().resource, context.getFileConfig().name); + + createMainInstantiation(); + + // Check if there are any conflicting main reactors elsewhere in the package. + if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && mainDef != null) { + for (String conflict : new MainConflictChecker(context.getFileConfig()).conflicts) { + errorReporter.reportError( + this.mainDef.getReactorClass(), "Conflicting main reactor in " + conflict); + } } - // ////////////////////////////////////////// - // // Code generation functions to override for a concrete code generator. - - /** - * If there is a main or federated reactor, then create a synthetic Instantiation - * for that top-level reactor and set the field mainDef to refer to it. - */ - private void createMainInstantiation() { - // Find the main reactor and create an AST node for its instantiation. - Iterable nodes = IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); - for (Reactor reactor : Iterables.filter(nodes, Reactor.class)) { - if (reactor.isMain()) { - // Creating a definition for the main reactor because there isn't one. - this.mainDef = LfFactory.eINSTANCE.createInstantiation(); - this.mainDef.setName(reactor.getName()); - this.mainDef.setReactorClass(reactor); - } - } + // Configure the command factory + commandFactory.setVerbose(); + if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) + && context.getArgs().containsKey("quiet")) { + commandFactory.setQuiet(); } - /** - * Generate code from the Lingua Franca model contained by the specified resource. - * - * This is the main entry point for code generation. This base class finds all - * reactor class definitions, including any reactors defined in imported .lf files - * (except any main reactors in those imported files), and adds them to the - * {@link GeneratorBase#reactors reactors} list. If errors occur during - * generation, then a subsequent call to errorsOccurred() will return true. - * @param resource The resource containing the source code. - * @param context Context relating to invocation of the code generator. - * In standalone mode, this object is also used to relay CLI arguments. - */ - public void doGenerate(Resource resource, LFGeneratorContext context) { - - // FIXME: the signature can be reduced to only take context. - // The constructor also need not take a file config because this is tied to the context as well. - cleanIfNeeded(context); - - printInfo(context.getMode()); - - // Clear any IDE markers that may have been created by a previous build. - // Markers mark problems in the Eclipse IDE when running in integrated mode. - errorReporter.clearHistory(); - - ASTUtils.setMainName(context.getFileConfig().resource, context.getFileConfig().name); - - createMainInstantiation(); - - // Check if there are any conflicting main reactors elsewhere in the package. - if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && mainDef != null) { - for (String conflict : new MainConflictChecker(context.getFileConfig()).conflicts) { - errorReporter.reportError(this.mainDef.getReactorClass(), "Conflicting main reactor in " + conflict); - } - } - - // Configure the command factory - commandFactory.setVerbose(); - if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && context.getArgs().containsKey("quiet")) { - commandFactory.setQuiet(); - } - - // Process target files. Copy each of them into the src-gen dir. - // FIXME: Should we do this here? This doesn't make sense for federates the way it is - // done here. - copyUserFiles(this.targetConfig, context.getFileConfig()); - - // Collect reactors and create an instantiation graph. - // These are needed to figure out which resources we need - // to validate, which happens in setResources(). - setReactorsAndInstantiationGraph(context.getMode()); - - List allResources = GeneratorUtils.getResources(reactors); - resources.addAll(allResources.stream() // FIXME: This filter reproduces the behavior of the method it replaces. But why must it be so complicated? Why are we worried about weird corner cases like this? - .filter(it -> !Objects.equal(it, context.getFileConfig().resource) || mainDef != null && it == mainDef.getReactorClass().eResource()) - .map(it -> GeneratorUtils.getLFResource(it, context.getFileConfig().getSrcGenBasePath(), context, errorReporter)) - .toList() - ); - GeneratorUtils.accommodatePhysicalActionsIfPresent( - allResources, - getTarget().setsKeepAliveOptionAutomatically(), - targetConfig, - errorReporter - ); - // FIXME: Should the GeneratorBase pull in `files` from imported - // resources? - - for (AstTransformation transformation : astTransformations) { - transformation.applyTransformation(reactors); - } - - // Transform connections that reside in mutually exclusive modes and are otherwise conflicting - // This should be done before creating the instantiation graph - transformConflictingConnectionsInModalReactors(); - - // Invoke these functions a second time because transformations - // may have introduced new reactors! - setReactorsAndInstantiationGraph(context.getMode()); - - // Check for existence and support of modes - hasModalReactors = IterableExtensions.exists(reactors, it -> !it.getModes().isEmpty()); - checkModalReactorSupport(false); - - // Check for the existence and support of watchdogs - hasWatchdogs = IterableExtensions.exists(reactors, it -> !it.getWatchdogs().isEmpty()); - checkWatchdogSupport(targetConfig.threading && getTarget() == Target.C); - additionalPostProcessingForModes(); + // Process target files. Copy each of them into the src-gen dir. + // FIXME: Should we do this here? This doesn't make sense for federates the way it is + // done here. + copyUserFiles(this.targetConfig, context.getFileConfig()); + + // Collect reactors and create an instantiation graph. + // These are needed to figure out which resources we need + // to validate, which happens in setResources(). + setReactorsAndInstantiationGraph(context.getMode()); + + List allResources = GeneratorUtils.getResources(reactors); + resources.addAll( + allResources + .stream() // FIXME: This filter reproduces the behavior of the method it replaces. But + // why must it be so complicated? Why are we worried about weird corner cases + // like this? + .filter( + it -> + !Objects.equal(it, context.getFileConfig().resource) + || mainDef != null && it == mainDef.getReactorClass().eResource()) + .map( + it -> + GeneratorUtils.getLFResource( + it, context.getFileConfig().getSrcGenBasePath(), context, errorReporter)) + .toList()); + GeneratorUtils.accommodatePhysicalActionsIfPresent( + allResources, getTarget().setsKeepAliveOptionAutomatically(), targetConfig, errorReporter); + // FIXME: Should the GeneratorBase pull in `files` from imported + // resources? + + for (AstTransformation transformation : astTransformations) { + transformation.applyTransformation(reactors); } - /** - * Check if a clean was requested from the standalone compiler and perform - * the clean step. - */ - protected void cleanIfNeeded(LFGeneratorContext context) { - if (context.getArgs().containsKey("clean")) { - try { - context.getFileConfig().doClean(); - } catch (IOException e) { - System.err.println("WARNING: IO Error during clean"); - } - } + // Transform connections that reside in mutually exclusive modes and are otherwise conflicting + // This should be done before creating the instantiation graph + transformConflictingConnectionsInModalReactors(); + + // Invoke these functions a second time because transformations + // may have introduced new reactors! + setReactorsAndInstantiationGraph(context.getMode()); + + // Check for existence and support of modes + hasModalReactors = IterableExtensions.exists(reactors, it -> !it.getModes().isEmpty()); + checkModalReactorSupport(false); + + // Check for the existence and support of watchdogs + hasWatchdogs = IterableExtensions.exists(reactors, it -> !it.getWatchdogs().isEmpty()); + checkWatchdogSupport(targetConfig.threading && getTarget() == Target.C); + additionalPostProcessingForModes(); + } + + /** Check if a clean was requested from the standalone compiler and perform the clean step. */ + protected void cleanIfNeeded(LFGeneratorContext context) { + if (context.getArgs().containsKey("clean")) { + try { + context.getFileConfig().doClean(); + } catch (IOException e) { + System.err.println("WARNING: IO Error during clean"); + } } - - /** - * Create a new instantiation graph. This is a graph where each node is a Reactor (not a ReactorInstance) - * and an arc from Reactor A to Reactor B means that B contains an instance of A, constructed with a statement - * like `a = new A();` After creating the graph, - * sort the reactors in topological order and assign them to the reactors class variable. - * Hence, after this method returns, `this.reactors` will be a list of Reactors such that any - * reactor is preceded in the list by reactors that it instantiates. - */ - protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { - // Build the instantiation graph . - instantiationGraph = new InstantiationGraph(context.getFileConfig().resource, false); - - // Topologically sort the reactors such that all of a reactor's instantiation dependencies occur earlier in - // the sorted list of reactors. This helps the code generator output code in the correct order. - // For example if `reactor Foo {bar = new Bar()}` then the definition of `Bar` has to be generated before - // the definition of `Foo`. - reactors = instantiationGraph.nodesInTopologicalOrder(); - - // If there is no main reactor or if all reactors in the file need to be validated, then make sure the reactors - // list includes even reactors that are not instantiated anywhere. - if (mainDef == null || Objects.equal(mode, LFGeneratorContext.Mode.LSP_MEDIUM)) { - Iterable nodes = IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); - for (Reactor r : IterableExtensions.filter(nodes, Reactor.class)) { - if (!reactors.contains(r)) { - reactors.add(r); - } - } + } + + /** + * Create a new instantiation graph. This is a graph where each node is a Reactor (not a + * ReactorInstance) and an arc from Reactor A to Reactor B means that B contains an instance of A, + * constructed with a statement like `a = new A();` After creating the graph, sort the reactors in + * topological order and assign them to the reactors class variable. Hence, after this method + * returns, `this.reactors` will be a list of Reactors such that any reactor is preceded in the + * list by reactors that it instantiates. + */ + protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { + // Build the instantiation graph . + instantiationGraph = new InstantiationGraph(context.getFileConfig().resource, false); + + // Topologically sort the reactors such that all of a reactor's instantiation dependencies occur + // earlier in + // the sorted list of reactors. This helps the code generator output code in the correct order. + // For example if `reactor Foo {bar = new Bar()}` then the definition of `Bar` has to be + // generated before + // the definition of `Foo`. + reactors = instantiationGraph.nodesInTopologicalOrder(); + + // If there is no main reactor or if all reactors in the file need to be validated, then make + // sure the reactors + // list includes even reactors that are not instantiated anywhere. + if (mainDef == null || Objects.equal(mode, LFGeneratorContext.Mode.LSP_MEDIUM)) { + Iterable nodes = + IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); + for (Reactor r : IterableExtensions.filter(nodes, Reactor.class)) { + if (!reactors.contains(r)) { + reactors.add(r); } + } } - - /** - * Copy user specific files to the src-gen folder. - * - * This should be overridden by the target generators. - * - * @param targetConfig The targetConfig to read the `files` from. - * @param fileConfig The fileConfig used to make the copy and resolve paths. - */ - protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) {} - - /** - * Return true if errors occurred in the last call to doGenerate(). - * This will return true if any of the reportError methods was called. - * @return True if errors occurred. - */ - public boolean errorsOccurred() { - return errorReporter.getErrorsOccurred(); + } + + /** + * Copy user specific files to the src-gen folder. + * + *

This should be overridden by the target generators. + * + * @param targetConfig The targetConfig to read the `files` from. + * @param fileConfig The fileConfig used to make the copy and resolve paths. + */ + protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) {} + + /** + * Return true if errors occurred in the last call to doGenerate(). This will return true if any + * of the reportError methods was called. + * + * @return True if errors occurred. + */ + public boolean errorsOccurred() { + return errorReporter.getErrorsOccurred(); + } + + /* + * Return the TargetTypes instance associated with this. + */ + public abstract TargetTypes getTargetTypes(); + + /** + * Mark the reaction unordered. An unordered reaction is one that does not have any dependency on + * other reactions in the containing reactor, and where no other reaction in the containing + * reactor depends on it. There is currently no way in the syntax of LF to make a reaction + * unordered, deliberately, because it can introduce unexpected nondeterminacy. However, certain + * automatically generated reactions are known to be safe to be unordered because they do not + * interact with the state of the containing reactor. To make a reaction unordered, when the + * Reaction instance is created, add that instance to this set. + * + * @param reaction The reaction to make unordered. + */ + public void makeUnordered(Reaction reaction) { + if (unorderedReactions == null) { + unorderedReactions = new LinkedHashSet<>(); } - - /* - * Return the TargetTypes instance associated with this. - */ - public abstract TargetTypes getTargetTypes(); - - /** - * Mark the reaction unordered. An unordered reaction is one that does not - * have any dependency on other reactions in the containing reactor, and - * where no other reaction in the containing reactor depends on it. There - * is currently no way in the syntax of LF to make a reaction unordered, - * deliberately, because it can introduce unexpected nondeterminacy. - * However, certain automatically generated reactions are known to be safe - * to be unordered because they do not interact with the state of the - * containing reactor. To make a reaction unordered, when the Reaction - * instance is created, add that instance to this set. - * @param reaction The reaction to make unordered. - */ - public void makeUnordered(Reaction reaction) { - if (unorderedReactions == null) { - unorderedReactions = new LinkedHashSet<>(); - } - unorderedReactions.add(reaction); + unorderedReactions.add(reaction); + } + + /** + * Mark the specified reaction to belong to only the specified bank index. This is needed because + * reactions cannot declare a specific bank index as an effect or trigger. Reactions that send + * messages between federates, including absent messages, need to be specific to a bank member. + * + * @param reaction The reaction. + * @param bankIndex The bank index, or -1 if there is no bank. + */ + public void setReactionBankIndex(Reaction reaction, int bankIndex) { + if (bankIndex < 0) { + return; } - - /** - * Mark the specified reaction to belong to only the specified - * bank index. This is needed because reactions cannot declare - * a specific bank index as an effect or trigger. Reactions that - * send messages between federates, including absent messages, - * need to be specific to a bank member. - * @param reaction The reaction. - * @param bankIndex The bank index, or -1 if there is no bank. - */ - public void setReactionBankIndex(Reaction reaction, int bankIndex) { - if (bankIndex < 0) { - return; - } - if (reactionBankIndices == null) { - reactionBankIndices = new LinkedHashMap<>(); - } - reactionBankIndices.put(reaction, bankIndex); + if (reactionBankIndices == null) { + reactionBankIndices = new LinkedHashMap<>(); } - - /** - * Return the reaction bank index. - * @see #setReactionBankIndex(Reaction reaction, int bankIndex) - * @param reaction The reaction. - * @return The reaction bank index, if one has been set, and -1 otherwise. - */ - public int getReactionBankIndex(Reaction reaction) { - if (reactionBankIndices == null) return -1; - if (reactionBankIndices.get(reaction) == null) return -1; - return reactionBankIndices.get(reaction); + reactionBankIndices.put(reaction, bankIndex); + } + + /** + * Return the reaction bank index. + * + * @see #setReactionBankIndex(Reaction reaction, int bankIndex) + * @param reaction The reaction. + * @return The reaction bank index, if one has been set, and -1 otherwise. + */ + public int getReactionBankIndex(Reaction reaction) { + if (reactionBankIndices == null) return -1; + if (reactionBankIndices.get(reaction) == null) return -1; + return reactionBankIndices.get(reaction); + } + + // ////////////////////////////////////////// + // // Protected methods. + + /** + * Checks whether modal reactors are present and require appropriate code generation. This will + * set the hasModalReactors variable. + * + * @param isSupported indicates if modes are supported by this code generation. + */ + protected void checkModalReactorSupport(boolean isSupported) { + if (hasModalReactors && !isSupported) { + errorReporter.reportError( + "The currently selected code generation or " + + "target configuration does not support modal reactors!"); } - - // ////////////////////////////////////////// - // // Protected methods. - - /** - * Checks whether modal reactors are present and require appropriate code generation. - * This will set the hasModalReactors variable. - * @param isSupported indicates if modes are supported by this code generation. - */ - protected void checkModalReactorSupport(boolean isSupported) { - if (hasModalReactors && !isSupported) { - errorReporter.reportError("The currently selected code generation or " + - "target configuration does not support modal reactors!"); - } + } + + /** + * Checks whether watchdogs are present and are supported. + * + * @param isSupported indicates whether or not this is a supported target and whether or not it is + * a threaded runtime. + */ + protected void checkWatchdogSupport(boolean isSupported) { + if (hasWatchdogs && !isSupported) { + errorReporter.reportError( + "Watchdogs are currently only supported for threaded programs in the C target."); } - - /** - * Checks whether watchdogs are present and are supported. - * @param isSupported indicates whether or not this is a supported target - * and whether or not it is a threaded runtime. - */ - protected void checkWatchdogSupport(boolean isSupported) { - if (hasWatchdogs && !isSupported) { + } + + /** + * Finds and transforms connections into forwarding reactions iff the connections have the same + * destination as other connections or reaction in mutually exclusive modes. + */ + private void transformConflictingConnectionsInModalReactors() { + for (LFResource r : resources) { + var transform = ASTUtils.findConflictingConnectionsInModalReactors(r.eResource); + if (!transform.isEmpty()) { + var factory = LfFactory.eINSTANCE; + for (Connection connection : transform) { + // Currently only simple transformations are supported + if (connection.isPhysical() + || connection.getDelay() != null + || connection.isIterated() + || connection.getLeftPorts().size() > 1 + || connection.getRightPorts().size() > 1) { errorReporter.reportError( - "Watchdogs are currently only supported for threaded programs in the C target." - ); + connection, + "Cannot transform connection in modal reactor. Connection uses currently not" + + " supported features."); + } else { + var reaction = factory.createReaction(); + ((Mode) connection.eContainer()).getReactions().add(reaction); + + var sourceRef = connection.getLeftPorts().get(0); + var destRef = connection.getRightPorts().get(0); + reaction.getTriggers().add(sourceRef); + reaction.getEffects().add(destRef); + + var code = factory.createCode(); + var source = + (sourceRef.getContainer() != null ? sourceRef.getContainer().getName() + "." : "") + + sourceRef.getVariable().getName(); + var dest = + (destRef.getContainer() != null ? destRef.getContainer().getName() + "." : "") + + destRef.getVariable().getName(); + code.setBody(getConflictingConnectionsInModalReactorsBody(source, dest)); + reaction.setCode(code); + + EcoreUtil.remove(connection); + } } + } } - - - /** - * Finds and transforms connections into forwarding reactions iff the connections have the same destination as other - * connections or reaction in mutually exclusive modes. - */ - private void transformConflictingConnectionsInModalReactors() { - for (LFResource r : resources) { - var transform = ASTUtils.findConflictingConnectionsInModalReactors(r.eResource); - if (!transform.isEmpty()) { - var factory = LfFactory.eINSTANCE; - for (Connection connection : transform) { - // Currently only simple transformations are supported - if (connection.isPhysical() || connection.getDelay() != null || connection.isIterated() || - connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1 - ) { - errorReporter.reportError(connection, "Cannot transform connection in modal reactor. Connection uses currently not supported features."); - } else { - var reaction = factory.createReaction(); - ((Mode)connection.eContainer()).getReactions().add(reaction); - - var sourceRef = connection.getLeftPorts().get(0); - var destRef = connection.getRightPorts().get(0); - reaction.getTriggers().add(sourceRef); - reaction.getEffects().add(destRef); - - var code = factory.createCode(); - var source = (sourceRef.getContainer() != null ? - sourceRef.getContainer().getName() + "." : "") + sourceRef.getVariable().getName(); - var dest = (destRef.getContainer() != null ? - destRef.getContainer().getName() + "." : "") + destRef.getVariable().getName(); - code.setBody(getConflictingConnectionsInModalReactorsBody(source, dest)); - reaction.setCode(code); - - EcoreUtil.remove(connection); - } - } - } - } - } - /** - * Return target code for forwarding reactions iff the connections have the - * same destination as other connections or reaction in mutually exclusive modes. - * - * This method needs to be overridden in target specific code generators that - * support modal reactors. - */ - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - errorReporter.reportError("The currently selected code generation " + - "is missing an implementation for conflicting " + - "transforming connections in modal reactors."); - return "MODAL MODELS NOT SUPPORTED"; + } + /** + * Return target code for forwarding reactions iff the connections have the same destination as + * other connections or reaction in mutually exclusive modes. + * + *

This method needs to be overridden in target specific code generators that support modal + * reactors. + */ + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + errorReporter.reportError( + "The currently selected code generation " + + "is missing an implementation for conflicting " + + "transforming connections in modal reactors."); + return "MODAL MODELS NOT SUPPORTED"; + } + + /** Hook for additional post-processing of the model. */ + protected void additionalPostProcessingForModes() { + // Do nothing + } + + /** Parsed error message from a compiler is returned here. */ + public static class ErrorFileAndLine { + public String filepath = null; + public String line = "1"; + public String character = "0"; + public String message = ""; + public boolean isError = true; // false for a warning. + + @Override + public String toString() { + return (isError ? "Error" : "Non-error") + + " at " + + line + + ":" + + character + + " of file " + + filepath + + ": " + + message; } - - /** - * Hook for additional post-processing of the model. - */ - protected void additionalPostProcessingForModes() { - // Do nothing - } - - /** - * Parsed error message from a compiler is returned here. - */ - public static class ErrorFileAndLine { - public String filepath = null; - public String line = "1"; - public String character = "0"; - public String message = ""; - public boolean isError = true; // false for a warning. - - @Override - public String toString() { - return (isError ? "Error" : "Non-error") + " at " + line + ":" + character + " of file " + filepath + ": " + message; - } - } - - /** - * Given a line of text from the output of a compiler, return - * an instance of ErrorFileAndLine if the line is recognized as - * the first line of an error message. Otherwise, return null. - * This base class simply returns null. - * @param line A line of output from a compiler or other external - * tool that might generate errors. - * @return If the line is recognized as the start of an error message, - * then return a class containing the path to the file on which the - * error occurred (or null if there is none), the line number (or the - * string "1" if there is none), the character position (or the string - * "0" if there is none), and the message (or an empty string if there - * is none). - */ - protected ErrorFileAndLine parseCommandOutput(String line) { - return null; - } - - /** - * Parse the specified string for command errors that can be reported - * using marks in the Eclipse IDE. In this class, we attempt to parse - * the messages to look for file and line information, thereby generating - * marks on the appropriate lines. This should not be called in standalone - * mode. - * - * @param stderr The output on standard error of executing a command. - */ - public void reportCommandErrors(String stderr) { - // NOTE: If the VS Code branch passes code review, then this function, - // parseCommandOutput, and ErrorFileAndLine will be deleted soon after. - // First, split the message into lines. - String[] lines = stderr.split("\\r?\\n"); - StringBuilder message = new StringBuilder(); - Integer lineNumber = null; - Path path = context.getFileConfig().srcFile; - // In case errors occur within an imported file, record the original path. - Path originalPath = path; - - int severity = IMarker.SEVERITY_ERROR; - for (String line : lines) { - ErrorFileAndLine parsed = parseCommandOutput(line); - if (parsed != null) { - // Found a new line number designator. - // If there is a previously accumulated message, report it. - if (message.length() > 0) { - if (severity == IMarker.SEVERITY_ERROR) - errorReporter.reportError(path, lineNumber, message.toString()); - else - errorReporter.reportWarning(path, lineNumber, message.toString()); - - if (!Objects.equal(originalPath.toFile(), path.toFile())) { - // Report an error also in the top-level resource. - // FIXME: It should be possible to descend through the import - // statements to find which one matches and mark all the - // import statements down the chain. But what a pain! - if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); - } else { - errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); - } - } - } - if (parsed.isError) { - severity = IMarker.SEVERITY_ERROR; - } else { - severity = IMarker.SEVERITY_WARNING; - } - - // Start accumulating a new message. - message = new StringBuilder(); - // Append the message on the line number designator line. - message.append(parsed.message); - - // Set the new line number. - try { - lineNumber = Integer.decode(parsed.line); - } catch (Exception ex) { - // Set the line number unknown. - lineNumber = null; - } - // FIXME: Ignoring the position within the line. - // Determine the path within which the error occurred. - path = Paths.get(parsed.filepath); - } else { - // No line designator. - if (message.length() > 0) { - message.append("\n"); - } else { - if (!line.toLowerCase().contains("error:")) { - severity = IMarker.SEVERITY_WARNING; - } - } - message.append(line); - } - } + } + + /** + * Given a line of text from the output of a compiler, return an instance of ErrorFileAndLine if + * the line is recognized as the first line of an error message. Otherwise, return null. This base + * class simply returns null. + * + * @param line A line of output from a compiler or other external tool that might generate errors. + * @return If the line is recognized as the start of an error message, then return a class + * containing the path to the file on which the error occurred (or null if there is none), the + * line number (or the string "1" if there is none), the character position (or the string "0" + * if there is none), and the message (or an empty string if there is none). + */ + protected ErrorFileAndLine parseCommandOutput(String line) { + return null; + } + + /** + * Parse the specified string for command errors that can be reported using marks in the Eclipse + * IDE. In this class, we attempt to parse the messages to look for file and line information, + * thereby generating marks on the appropriate lines. This should not be called in standalone + * mode. + * + * @param stderr The output on standard error of executing a command. + */ + public void reportCommandErrors(String stderr) { + // NOTE: If the VS Code branch passes code review, then this function, + // parseCommandOutput, and ErrorFileAndLine will be deleted soon after. + // First, split the message into lines. + String[] lines = stderr.split("\\r?\\n"); + StringBuilder message = new StringBuilder(); + Integer lineNumber = null; + Path path = context.getFileConfig().srcFile; + // In case errors occur within an imported file, record the original path. + Path originalPath = path; + + int severity = IMarker.SEVERITY_ERROR; + for (String line : lines) { + ErrorFileAndLine parsed = parseCommandOutput(line); + if (parsed != null) { + // Found a new line number designator. + // If there is a previously accumulated message, report it. if (message.length() > 0) { + if (severity == IMarker.SEVERITY_ERROR) + errorReporter.reportError(path, lineNumber, message.toString()); + else errorReporter.reportWarning(path, lineNumber, message.toString()); + + if (!Objects.equal(originalPath.toFile(), path.toFile())) { + // Report an error also in the top-level resource. + // FIXME: It should be possible to descend through the import + // statements to find which one matches and mark all the + // import statements down the chain. But what a pain! if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(path, lineNumber, message.toString()); + errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); } else { - errorReporter.reportWarning(path, lineNumber, message.toString()); + errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); } + } + } + if (parsed.isError) { + severity = IMarker.SEVERITY_ERROR; + } else { + severity = IMarker.SEVERITY_WARNING; + } - if (originalPath.toFile() != path.toFile()) { - // Report an error also in the top-level resource. - // FIXME: It should be possible to descend through the import - // statements to find which one matches and mark all the - // import statements down the chain. But what a pain! - if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); - } else { - errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); - } - } + // Start accumulating a new message. + message = new StringBuilder(); + // Append the message on the line number designator line. + message.append(parsed.message); + + // Set the new line number. + try { + lineNumber = Integer.decode(parsed.line); + } catch (Exception ex) { + // Set the line number unknown. + lineNumber = null; + } + // FIXME: Ignoring the position within the line. + // Determine the path within which the error occurred. + path = Paths.get(parsed.filepath); + } else { + // No line designator. + if (message.length() > 0) { + message.append("\n"); + } else { + if (!line.toLowerCase().contains("error:")) { + severity = IMarker.SEVERITY_WARNING; + } } + message.append(line); + } } - - // ////////////////////////////////////////////////// - // // Private functions - - /** - * Print to stdout information about what source file is being generated, - * what mode the generator is in, and where the generated sources are to be put. - */ - public void printInfo(LFGeneratorContext.Mode mode) { - System.out.println("Generating code for: " + context.getFileConfig().resource.getURI().toString()); - System.out.println("******** mode: " + mode); - System.out.println("******** generated sources: " + context.getFileConfig().getSrcGenPath()); + if (message.length() > 0) { + if (severity == IMarker.SEVERITY_ERROR) { + errorReporter.reportError(path, lineNumber, message.toString()); + } else { + errorReporter.reportWarning(path, lineNumber, message.toString()); + } + + if (originalPath.toFile() != path.toFile()) { + // Report an error also in the top-level resource. + // FIXME: It should be possible to descend through the import + // statements to find which one matches and mark all the + // import statements down the chain. But what a pain! + if (severity == IMarker.SEVERITY_ERROR) { + errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); + } else { + errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); + } + } } - - /** - * Get the buffer type used for network messages - */ - public String getNetworkBufferType() { return ""; } - - /** - * Return the Targets enum for the current target - */ - public abstract Target getTarget(); - + } + + // ////////////////////////////////////////////////// + // // Private functions + + /** + * Print to stdout information about what source file is being generated, what mode the generator + * is in, and where the generated sources are to be put. + */ + public void printInfo(LFGeneratorContext.Mode mode) { + System.out.println( + "Generating code for: " + context.getFileConfig().resource.getURI().toString()); + System.out.println("******** mode: " + mode); + System.out.println("******** generated sources: " + context.getFileConfig().getSrcGenPath()); + } + + /** Get the buffer type used for network messages */ + public String getNetworkBufferType() { + return ""; + } + + /** Return the Targets enum for the current target */ + public abstract Target getTarget(); } diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 3ab3607b2a..ba85ae8288 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -1,32 +1,31 @@ /** A data structure for a reactor instance. */ /************* -Copyright (c) 2019-2022, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2022, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; -import static org.lflang.ASTUtils.belongsTo; import static org.lflang.ASTUtils.getLiteralTimeValue; import java.util.ArrayList; @@ -38,7 +37,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Map; import java.util.Optional; import java.util.Set; - import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; @@ -68,1121 +66,1087 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.WidthSpec; /** - * Representation of a compile-time instance of a reactor. - * If the reactor is instantiated as a bank of reactors, or if any - * of its parents is instantiated as a bank of reactors, then one instance - * of this ReactorInstance class represents all the runtime instances within - * these banks. The {@link #getTotalWidth()} method returns the number of such - * runtime instances, which is the product of the bank width of this reactor - * instance and the bank widths of all of its parents. - * There is exactly one instance of this ReactorInstance class for each - * graphical rendition of a reactor in the diagram view. - * - * For the main reactor, which has no parent, once constructed, - * this object represents the entire Lingua Franca program. - * If the program has causality loops (a programming error), then - * {@link #hasCycles()} will return true and {@link #getCycles()} will - * return the ports and reaction instances involved in the cycles. + * Representation of a compile-time instance of a reactor. If the reactor is instantiated as a bank + * of reactors, or if any of its parents is instantiated as a bank of reactors, then one instance of + * this ReactorInstance class represents all the runtime instances within these banks. The {@link + * #getTotalWidth()} method returns the number of such runtime instances, which is the product of + * the bank width of this reactor instance and the bank widths of all of its parents. There is + * exactly one instance of this ReactorInstance class for each graphical rendition of a reactor in + * the diagram view. + * + *

For the main reactor, which has no parent, once constructed, this object represents the entire + * Lingua Franca program. If the program has causality loops (a programming error), then {@link + * #hasCycles()} will return true and {@link #getCycles()} will return the ports and reaction + * instances involved in the cycles. * * @author Marten Lohstroh * @author Edward A. Lee */ public class ReactorInstance extends NamedInstance { - /** - * Create a new instantiation hierarchy that starts with the given top-level reactor. - * @param reactor The top-level reactor. - * @param reporter The error reporter. - */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter) { - this(ASTUtils.createInstantiation(reactor), null, reporter, -1); + /** + * Create a new instantiation hierarchy that starts with the given top-level reactor. + * + * @param reactor The top-level reactor. + * @param reporter The error reporter. + */ + public ReactorInstance(Reactor reactor, ErrorReporter reporter) { + this(ASTUtils.createInstantiation(reactor), null, reporter, -1); + } + + /** + * Create a new instantiation hierarchy that starts with the given top-level reactor but only + * creates contained reactors up to the specified depth. + * + * @param reactor The top-level reactor. + * @param reporter The error reporter. + * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. + */ + public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth) { + this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth); + } + + /** + * Create a new instantiation with the specified parent. This constructor is here to allow for + * unit tests. It should not be used for any other purpose. + * + * @param reactor The top-level reactor. + * @param parent The parent reactor instance. + * @param reporter The error reporter. + */ + public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter) { + this(ASTUtils.createInstantiation(reactor), parent, reporter, -1); + } + + ////////////////////////////////////////////////////// + //// Public fields. + + /** The action instances belonging to this reactor instance. */ + public List actions = new ArrayList<>(); + + /** + * The contained reactor instances, in order of declaration. For banks of reactors, this includes + * both the bank definition Reactor (which has bankIndex == -2) followed by each of the bank + * members (which have bankIndex >= 0). + */ + public final List children = new ArrayList<>(); + + /** The input port instances belonging to this reactor instance. */ + public final List inputs = new ArrayList<>(); + + /** The output port instances belonging to this reactor instance. */ + public final List outputs = new ArrayList<>(); + + /** The parameters of this instance. */ + public final List parameters = new ArrayList<>(); + + /** List of reaction instances for this reactor instance. */ + public final List reactions = new ArrayList<>(); + + /** List of watchdog instances for this reactor instance. */ + public final List watchdogs = new ArrayList<>(); + + /** The timer instances belonging to this reactor instance. */ + public final List timers = new ArrayList<>(); + + /** The mode instances belonging to this reactor instance. */ + public final List modes = new ArrayList<>(); + + /** The reactor declaration in the AST. This is either an import or Reactor declaration. */ + public final ReactorDecl reactorDeclaration; + + /** The reactor after imports are resolve. */ + public final Reactor reactorDefinition; + + /** Indicator that this reactor has itself as a parent, an error condition. */ + public final boolean recursive; + + ////////////////////////////////////////////////////// + //// Public methods. + + /** + * Assign levels to all reactions within the same root as this reactor. The level of a reaction r + * is equal to the length of the longest chain of reactions that must have the opportunity to + * execute before r at each logical tag. This fails and returns false if a causality cycle exists. + * + *

This method uses a variant of Kahn's algorithm, which is linear in V + E, where V is the + * number of vertices (reactions) and E is the number of edges (dependencies between reactions). + * + * @return An empty graph if successful and otherwise a graph with runtime reaction instances that + * form cycles. + */ + public ReactionInstanceGraph assignLevels() { + if (depth != 0) return root().assignLevels(); + if (cachedReactionLoopGraph == null) { + cachedReactionLoopGraph = new ReactionInstanceGraph(this); } - - /** - * Create a new instantiation hierarchy that starts with the given top-level reactor - * but only creates contained reactors up to the specified depth. - * @param reactor The top-level reactor. - * @param reporter The error reporter. - * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. - */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth) { - this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth); + return cachedReactionLoopGraph; + } + + /** + * This function assigns/propagates deadlines through the Reaction Instance Graph. It performs + * Kahn`s algorithm in reverse, starting from the leaf nodes and propagates deadlines upstream. To + * reduce cost, it should only be invoked when there are user-specified deadlines in the program. + * + * @return + */ + public ReactionInstanceGraph assignDeadlines() { + if (depth != 0) return root().assignDeadlines(); + if (cachedReactionLoopGraph == null) { + cachedReactionLoopGraph = new ReactionInstanceGraph(this); } - - /** - * Create a new instantiation with the specified parent. - * This constructor is here to allow for unit tests. - * It should not be used for any other purpose. - * @param reactor The top-level reactor. - * @param parent The parent reactor instance. - * @param reporter The error reporter. - */ - public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter) { - this(ASTUtils.createInstantiation(reactor), parent, reporter, -1); - } - - ////////////////////////////////////////////////////// - //// Public fields. - - /** The action instances belonging to this reactor instance. */ - public List actions = new ArrayList<>(); - - /** - * The contained reactor instances, in order of declaration. - * For banks of reactors, this includes both the bank definition - * Reactor (which has bankIndex == -2) followed by each of the - * bank members (which have bankIndex >= 0). - */ - public final List children = new ArrayList<>(); - - /** The input port instances belonging to this reactor instance. */ - public final List inputs = new ArrayList<>(); - - /** The output port instances belonging to this reactor instance. */ - public final List outputs = new ArrayList<>(); - - /** The parameters of this instance. */ - public final List parameters = new ArrayList<>(); - - /** List of reaction instances for this reactor instance. */ - public final List reactions = new ArrayList<>(); - - /** List of watchdog instances for this reactor instance. */ - public final List watchdogs = new ArrayList<>(); - - /** The timer instances belonging to this reactor instance. */ - public final List timers = new ArrayList<>(); - - /** The mode instances belonging to this reactor instance. */ - public final List modes = new ArrayList<>(); - - /** The reactor declaration in the AST. This is either an import or Reactor declaration. */ - public final ReactorDecl reactorDeclaration; - - /** The reactor after imports are resolve. */ - public final Reactor reactorDefinition; - - /** Indicator that this reactor has itself as a parent, an error condition. */ - public final boolean recursive; - - ////////////////////////////////////////////////////// - //// Public methods. - - /** - * Assign levels to all reactions within the same root as this - * reactor. The level of a reaction r is equal to the length of the - * longest chain of reactions that must have the opportunity to - * execute before r at each logical tag. This fails and returns - * false if a causality cycle exists. - * - * This method uses a variant of Kahn's algorithm, which is linear - * in V + E, where V is the number of vertices (reactions) and E - * is the number of edges (dependencies between reactions). - * - * @return An empty graph if successful and otherwise a graph - * with runtime reaction instances that form cycles. - */ - public ReactionInstanceGraph assignLevels() { - if (depth != 0) return root().assignLevels(); - if (cachedReactionLoopGraph == null) { - cachedReactionLoopGraph = new ReactionInstanceGraph(this); - } - return cachedReactionLoopGraph; + cachedReactionLoopGraph.rebuildAndAssignDeadlines(); + return cachedReactionLoopGraph; + } + + /** + * Return the instance of a child rector created by the specified definition or null if there is + * none. + * + * @param definition The definition of the child reactor ("new" statement). + */ + public ReactorInstance getChildReactorInstance(Instantiation definition) { + for (ReactorInstance child : this.children) { + if (child.definition == definition) { + return child; + } } - - /** - * This function assigns/propagates deadlines through the Reaction Instance Graph. - * It performs Kahn`s algorithm in reverse, starting from the leaf nodes and - * propagates deadlines upstream. To reduce cost, it should only be invoked when - * there are user-specified deadlines in the program. - * @return - */ - public ReactionInstanceGraph assignDeadlines() { - if (depth != 0) return root().assignDeadlines(); - if (cachedReactionLoopGraph == null) { - cachedReactionLoopGraph = new ReactionInstanceGraph(this); - } - cachedReactionLoopGraph.rebuildAndAssignDeadlines(); - return cachedReactionLoopGraph; + return null; + } + + /** + * Clear any cached data in this reactor and its children. This is useful if a mutation has been + * realized. + */ + public void clearCaches() { + clearCaches(true); + } + + /** + * Clear any cached data in this reactor and its children. This is useful if a mutation has been + * realized. + * + * @param includingRuntimes If false, leave the runtime instances of reactions intact. This is + * useful for federated execution where levels are computed using the top-level connections, + * but then those connections are discarded. + */ + public void clearCaches(boolean includingRuntimes) { + if (includingRuntimes) cachedReactionLoopGraph = null; + for (ReactorInstance child : children) { + child.clearCaches(includingRuntimes); } - - /** - * Return the instance of a child rector created by the specified - * definition or null if there is none. - * @param definition The definition of the child reactor ("new" statement). - */ - public ReactorInstance getChildReactorInstance(Instantiation definition) { - for (ReactorInstance child : this.children) { - if (child.definition == definition) { - return child; - } - } - return null; + for (PortInstance port : inputs) { + port.clearCaches(); } - - /** - * Clear any cached data in this reactor and its children. - * This is useful if a mutation has been realized. - */ - public void clearCaches() { - clearCaches(true); + for (PortInstance port : outputs) { + port.clearCaches(); } - - /** - * Clear any cached data in this reactor and its children. - * This is useful if a mutation has been realized. - * @param includingRuntimes If false, leave the runtime instances of reactions intact. - * This is useful for federated execution where levels are computed using - * the top-level connections, but then those connections are discarded. - */ - public void clearCaches(boolean includingRuntimes) { - if (includingRuntimes) cachedReactionLoopGraph = null; - for (ReactorInstance child : children) { - child.clearCaches(includingRuntimes); - } - for (PortInstance port : inputs) { - port.clearCaches(); - } - for (PortInstance port : outputs) { - port.clearCaches(); - } - for (ReactionInstance reaction : reactions) { - reaction.clearCaches(includingRuntimes); - } - cachedCycles = null; + for (ReactionInstance reaction : reactions) { + reaction.clearCaches(includingRuntimes); } - - /** - * Return the set of ReactionInstance and PortInstance that form causality - * loops in the topmost parent reactor in the instantiation hierarchy. This will return an - * empty set if there are no causality loops. - */ - public Set> getCycles() { - if (depth != 0) return root().getCycles(); - if (cachedCycles != null) return cachedCycles; - cachedCycles = new LinkedHashSet<>(); - - ReactionInstanceGraph reactionRuntimes = assignLevels(); - if (reactionRuntimes.nodes().size() > 0) { - Set reactions = new LinkedHashSet<>(); - Set ports = new LinkedHashSet<>(); - // There are cycles. But the nodes set includes not - // just the cycles, but also nodes that are downstream of the - // cycles. Use Tarjan's algorithm to get just the cycles. - var cycleNodes = reactionRuntimes.getCycles(); - for (var cycle : cycleNodes) { - for (ReactionInstance.Runtime runtime : cycle) { - reactions.add(runtime.getReaction()); - } - } - // Need to figure out which ports are involved in the cycles. - // It may not be all ports that depend on this reaction. - for (ReactionInstance r : reactions) { - for (TriggerInstance p : r.effects) { - if (p instanceof PortInstance) { - findPaths((PortInstance)p, reactions, ports); - } - } - } - cachedCycles.addAll(reactions); - cachedCycles.addAll(ports); + cachedCycles = null; + } + + /** + * Return the set of ReactionInstance and PortInstance that form causality loops in the topmost + * parent reactor in the instantiation hierarchy. This will return an empty set if there are no + * causality loops. + */ + public Set> getCycles() { + if (depth != 0) return root().getCycles(); + if (cachedCycles != null) return cachedCycles; + cachedCycles = new LinkedHashSet<>(); + + ReactionInstanceGraph reactionRuntimes = assignLevels(); + if (reactionRuntimes.nodes().size() > 0) { + Set reactions = new LinkedHashSet<>(); + Set ports = new LinkedHashSet<>(); + // There are cycles. But the nodes set includes not + // just the cycles, but also nodes that are downstream of the + // cycles. Use Tarjan's algorithm to get just the cycles. + var cycleNodes = reactionRuntimes.getCycles(); + for (var cycle : cycleNodes) { + for (ReactionInstance.Runtime runtime : cycle) { + reactions.add(runtime.getReaction()); } - - return cachedCycles; - } - - /** - * Return the specified input by name or null if there is no such input. - * @param name The input name. - */ - public PortInstance getInput(String name) { - for (PortInstance port: inputs) { - if (port.getName().equals(name)) { - return port; - } + } + // Need to figure out which ports are involved in the cycles. + // It may not be all ports that depend on this reaction. + for (ReactionInstance r : reactions) { + for (TriggerInstance p : r.effects) { + if (p instanceof PortInstance) { + findPaths((PortInstance) p, reactions, ports); + } } - return null; - } - - /** - * Override the base class to append [i_d], where d is the depth, - * if this reactor is in a bank of reactors. - * @return The name of this instance. - */ - @Override - public String getName() { - return this.definition.getName(); + } + cachedCycles.addAll(reactions); + cachedCycles.addAll(ports); } - /** - * @see NamedInstance#uniqueID() - * - * Append `_main` to the name of the main reactor to allow instantiations - * within that reactor to have the same name. - */ - @Override - public String uniqueID() { - if (this.isMainOrFederated()) { - return super.uniqueID() + "_main"; - } - return super.uniqueID(); + return cachedCycles; + } + + /** + * Return the specified input by name or null if there is no such input. + * + * @param name The input name. + */ + public PortInstance getInput(String name) { + for (PortInstance port : inputs) { + if (port.getName().equals(name)) { + return port; + } } - - /** - * Return the specified output by name or null if there is no such output. - * @param name The output name. - */ - public PortInstance getOutput(String name) { - for (PortInstance port: outputs) { - if (port.getName().equals(name)) { - return port; - } - } - return null; + return null; + } + + /** + * Override the base class to append [i_d], where d is the depth, if this reactor is in a bank of + * reactors. + * + * @return The name of this instance. + */ + @Override + public String getName() { + return this.definition.getName(); + } + + /** + * @see NamedInstance#uniqueID() + *

Append `_main` to the name of the main reactor to allow instantiations within that + * reactor to have the same name. + */ + @Override + public String uniqueID() { + if (this.isMainOrFederated()) { + return super.uniqueID() + "_main"; } - - /** - * Return a parameter matching the specified name if the reactor has one - * and otherwise return null. - * @param name The parameter name. - */ - public ParameterInstance getParameter(String name) { - for (ParameterInstance parameter: parameters) { - if (parameter.getName().equals(name)) { - return parameter; - } - } - return null; + return super.uniqueID(); + } + + /** + * Return the specified output by name or null if there is no such output. + * + * @param name The output name. + */ + public PortInstance getOutput(String name) { + for (PortInstance port : outputs) { + if (port.getName().equals(name)) { + return port; + } } - - /** - * Return the startup trigger or null if not used in any reaction. - */ - public TriggerInstance getStartupTrigger() { - return builtinTriggers.get(BuiltinTrigger.STARTUP); + return null; + } + + /** + * Return a parameter matching the specified name if the reactor has one and otherwise return + * null. + * + * @param name The parameter name. + */ + public ParameterInstance getParameter(String name) { + for (ParameterInstance parameter : parameters) { + if (parameter.getName().equals(name)) { + return parameter; + } } - - /** - * Return the shutdown trigger or null if not used in any reaction. - */ - public TriggerInstance getShutdownTrigger() { - return builtinTriggers.get(BuiltinTrigger.SHUTDOWN); + return null; + } + + /** Return the startup trigger or null if not used in any reaction. */ + public TriggerInstance getStartupTrigger() { + return builtinTriggers.get(BuiltinTrigger.STARTUP); + } + + /** Return the shutdown trigger or null if not used in any reaction. */ + public TriggerInstance getShutdownTrigger() { + return builtinTriggers.get(BuiltinTrigger.SHUTDOWN); + } + + /** + * If this reactor is a bank or any of its parents is a bank, return the total number of runtime + * instances, which is the product of the widths of all the parents. Return -1 if the width cannot + * be determined. + */ + public int getTotalWidth() { + return getTotalWidth(0); + } + + /** + * If this reactor is a bank or any of its parents is a bank, return the total number of runtime + * instances, which is the product of the widths of all the parents. Return -1 if the width cannot + * be determined. + * + * @param atDepth The depth at which to determine the width. Use 0 to get the total number of + * instances. Use 1 to get the number of instances within a single top-level bank member (this + * is useful for federates). + */ + public int getTotalWidth(int atDepth) { + if (width <= 0) return -1; + if (depth <= atDepth) return 1; + int result = width; + ReactorInstance p = parent; + while (p != null && p.depth > atDepth) { + if (p.width <= 0) return -1; + result *= p.width; + p = p.parent; } - - /** - * If this reactor is a bank or any of its parents is a bank, - * return the total number of runtime instances, which is the product - * of the widths of all the parents. - * Return -1 if the width cannot be determined. - */ - public int getTotalWidth() { - return getTotalWidth(0); + return result; + } + + /** + * Return the trigger instances (input ports, timers, and actions that trigger reactions) + * belonging to this reactor instance. + */ + public Set> getTriggers() { + // FIXME: Cache this. + var triggers = new LinkedHashSet>(); + for (ReactionInstance reaction : this.reactions) { + triggers.addAll(reaction.triggers); } - - /** - * If this reactor is a bank or any of its parents is a bank, - * return the total number of runtime instances, which is the product - * of the widths of all the parents. - * Return -1 if the width cannot be determined. - * @param atDepth The depth at which to determine the width. - * Use 0 to get the total number of instances. - * Use 1 to get the number of instances within a single top-level - * bank member (this is useful for federates). - */ - public int getTotalWidth(int atDepth) { - if (width <= 0) return -1; - if (depth <= atDepth) return 1; - int result = width; - ReactorInstance p = parent; - while (p != null && p.depth > atDepth) { - if (p.width <= 0) return -1; - result *= p.width; - p = p.parent; - } - return result; + return triggers; + } + + /** + * Return the trigger instances (input ports, timers, and actions that trigger reactions) together + * the ports that the reaction reads but that don't trigger it. + * + * @return The trigger instances belonging to this reactor instance. + */ + public Set> getTriggersAndReads() { + // FIXME: Cache this. + var triggers = new LinkedHashSet>(); + for (ReactionInstance reaction : this.reactions) { + triggers.addAll(reaction.triggers); + triggers.addAll(reaction.reads); } + return triggers; + } + + /** Return true if the top-level parent of this reactor has causality cycles. */ + public boolean hasCycles() { + return assignLevels().nodeCount() != 0; + } + + /** + * Given a parameter definition for this reactor, return the initial integer value of the + * parameter. If the parameter is overridden when instantiating this reactor or any of its + * containing reactors, use that value. Otherwise, use the default value in the reactor + * definition. If the parameter cannot be found or its value is not an integer, return null. + * + * @param parameter The parameter definition (a syntactic object in the AST). + * @return An integer value or null. + */ + public Integer initialIntParameterValue(Parameter parameter) { + return ASTUtils.initialValueInt(parameter, instantiations()); + } + + public Expression resolveParameters(Expression e) { + return LfExpressionVisitor.dispatch(e, this, ParameterInliner.INSTANCE); + } + + private static final class ParameterInliner + extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { + static final ParameterInliner INSTANCE = new ParameterInliner(); - /** - * Return the trigger instances (input ports, timers, and actions - * that trigger reactions) belonging to this reactor instance. - */ - public Set> getTriggers() { - // FIXME: Cache this. - var triggers = new LinkedHashSet>(); - for (ReactionInstance reaction : this.reactions) { - triggers.addAll(reaction.triggers); + @Override + public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { + if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { + throw new IllegalArgumentException( + "Parameter " + + expr.getParameter().getName() + + " is not a parameter of reactor instance " + + instance.getName() + + "."); + } + + Optional assignment = + instance.definition.getParameters().stream() + .filter(it -> it.getLhs().equals(expr.getParameter())) + .findAny(); // There is at most one + + if (assignment.isPresent()) { + // replace the parameter with its value. + Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); + // recursively resolve parameters + return instance.getParent().resolveParameters(value); + } else { + // In that case use the default value. Default values + // cannot use parameter values, so they don't need to + // be recursively resolved. + Initializer init = expr.getParameter().getInit(); + Expression defaultValue = ASTUtils.asSingleExpr(init); + if (defaultValue == null) { + // this is a problem + return super.visitParameterRef(expr, instance); } - return triggers; + return defaultValue; + } } - - /** - * Return the trigger instances (input ports, timers, and actions - * that trigger reactions) together the ports that the reaction reads - * but that don't trigger it. - * - * @return The trigger instances belonging to this reactor instance. - */ - public Set> getTriggersAndReads() { - // FIXME: Cache this. - var triggers = new LinkedHashSet>(); - for (ReactionInstance reaction : this.reactions) { - triggers.addAll(reaction.triggers); - triggers.addAll(reaction.reads); + } + + /** + * Return a list of Instantiation objects for evaluating parameter values. The first object in the + * list is the AST Instantiation that created this reactor instance, the second is the AST + * instantiation that created the containing reactor instance, and so on until there are no more + * containing reactor instances. This will return an empty list if this reactor instance is at the + * top level (is main). + */ + public List instantiations() { + if (_instantiations == null) { + _instantiations = new ArrayList<>(); + if (definition != null) { + _instantiations.add(definition); + if (parent != null) { + _instantiations.addAll(parent.instantiations()); } - return triggers; + } } - - /** - * Return true if the top-level parent of this reactor has causality cycles. - */ - public boolean hasCycles() { - return assignLevels().nodeCount() != 0; + return _instantiations; + } + + /** + * Returns true if this is a bank of reactors. + * + * @return true if a reactor is a bank, false otherwise + */ + public boolean isBank() { + return definition.getWidthSpec() != null; + } + + /** + * Returns whether this is a main or federated reactor. + * + * @return true if reactor definition is marked as main or federated, false otherwise. + */ + public boolean isMainOrFederated() { + return reactorDefinition != null + && (reactorDefinition.isMain() || reactorDefinition.isFederated()); + } + + /** + * Return true if the specified reactor instance is either equal to this reactor instance or a + * parent of it. + * + * @param r The reactor instance. + */ + public boolean isParent(ReactorInstance r) { + ReactorInstance p = this; + while (p != null) { + if (p == r) return true; + p = p.getParent(); } - - /** - * Given a parameter definition for this reactor, return the initial integer - * value of the parameter. If the parameter is overridden when instantiating - * this reactor or any of its containing reactors, use that value. - * Otherwise, use the default value in the reactor definition. - * If the parameter cannot be found or its value is not an integer, return null. - * - * @param parameter The parameter definition (a syntactic object in the AST). - * - * @return An integer value or null. - */ - public Integer initialIntParameterValue(Parameter parameter) { - return ASTUtils.initialValueInt(parameter, instantiations()); + return false; + } + + /////////////////////////////////////////////////// + //// Methods for finding instances in this reactor given an AST node. + + /** + * Return the action instance within this reactor instance corresponding to the specified action + * reference. + * + * @param action The action as an AST node. + * @return The corresponding action instance or null if the action does not belong to this + * reactor. + */ + public ActionInstance lookupActionInstance(Action action) { + for (ActionInstance actionInstance : actions) { + if (actionInstance.definition == action) { + return actionInstance; + } } - - public Expression resolveParameters(Expression e) { - return LfExpressionVisitor.dispatch(e, this, ParameterInliner.INSTANCE); + return null; + } + + /** + * Given a parameter definition, return the parameter instance corresponding to that definition, + * or null if there is no such instance. + * + * @param parameter The parameter definition (a syntactic object in the AST). + * @return A parameter instance, or null if there is none. + */ + public ParameterInstance lookupParameterInstance(Parameter parameter) { + for (ParameterInstance param : parameters) { + if (param.definition == parameter) { + return param; + } } - - - private static final class ParameterInliner extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { - static final ParameterInliner INSTANCE = new ParameterInliner(); - - @Override - public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { - if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { - throw new IllegalArgumentException("Parameter " - + expr.getParameter().getName() - + " is not a parameter of reactor instance " - + instance.getName() - + "." - ); - } - - Optional assignment = - instance.definition.getParameters().stream() - .filter(it -> it.getLhs().equals(expr.getParameter())) - .findAny(); // There is at most one - - if (assignment.isPresent()) { - // replace the parameter with its value. - Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); - // recursively resolve parameters - return instance.getParent().resolveParameters(value); - } else { - // In that case use the default value. Default values - // cannot use parameter values, so they don't need to - // be recursively resolved. - Initializer init = expr.getParameter().getInit(); - Expression defaultValue = ASTUtils.asSingleExpr(init); - if (defaultValue == null) { - // this is a problem - return super.visitParameterRef(expr, instance); - } - return defaultValue; - } - } + return null; + } + + /** + * Given a port definition, return the port instance corresponding to that definition, or null if + * there is no such instance. + * + * @param port The port definition (a syntactic object in the AST). + * @return A port instance, or null if there is none. + */ + public PortInstance lookupPortInstance(Port port) { + // Search one of the inputs and outputs sets. + List ports = null; + if (port instanceof Input) { + ports = this.inputs; + } else if (port instanceof Output) { + ports = this.outputs; } - - /** - * Return a list of Instantiation objects for evaluating parameter - * values. The first object in the list is the AST Instantiation - * that created this reactor instance, the second is the AST instantiation - * that created the containing reactor instance, and so on until there - * are no more containing reactor instances. This will return an empty - * list if this reactor instance is at the top level (is main). - */ - public List instantiations() { - if (_instantiations == null) { - _instantiations = new ArrayList<>(); - if (definition != null) { - _instantiations.add(definition); - if (parent != null) { - _instantiations.addAll(parent.instantiations()); - } - } - } - return _instantiations; + for (PortInstance portInstance : ports) { + if (portInstance.definition == port) { + return portInstance; + } } - - /** - * Returns true if this is a bank of reactors. - * @return true if a reactor is a bank, false otherwise - */ - public boolean isBank() { - return definition.getWidthSpec() != null; + return null; + } + + /** + * Given a reference to a port belonging to this reactor instance, return the port instance. + * Return null if there is no such instance. + * + * @param reference The port reference. + * @return A port instance, or null if there is none. + */ + public PortInstance lookupPortInstance(VarRef reference) { + if (!(reference.getVariable() instanceof Port)) { + // Trying to resolve something that is not a port + return null; } - - /** - * Returns whether this is a main or federated reactor. - * @return true if reactor definition is marked as main or federated, false otherwise. - */ - public boolean isMainOrFederated() { - return reactorDefinition != null - && (reactorDefinition.isMain() || reactorDefinition.isFederated()); + if (reference.getContainer() == null) { + // Handle local reference + return lookupPortInstance((Port) reference.getVariable()); + } else { + // Handle hierarchical reference + var containerInstance = getChildReactorInstance(reference.getContainer()); + if (containerInstance == null) return null; + return containerInstance.lookupPortInstance((Port) reference.getVariable()); } - - /** - * Return true if the specified reactor instance is either equal to this - * reactor instance or a parent of it. - * @param r The reactor instance. - */ - public boolean isParent(ReactorInstance r) { - ReactorInstance p = this; - while (p != null) { - if (p == r) return true; - p = p.getParent(); - } - return false; + } + + /** + * Return the reaction instance within this reactor instance corresponding to the specified + * reaction. + * + * @param reaction The reaction as an AST node. + * @return The corresponding reaction instance or null if the reaction does not belong to this + * reactor. + */ + public ReactionInstance lookupReactionInstance(Reaction reaction) { + for (ReactionInstance reactionInstance : reactions) { + if (reactionInstance.definition == reaction) { + return reactionInstance; + } } - - /////////////////////////////////////////////////// - //// Methods for finding instances in this reactor given an AST node. - - /** - * Return the action instance within this reactor - * instance corresponding to the specified action reference. - * @param action The action as an AST node. - * @return The corresponding action instance or null if the - * action does not belong to this reactor. - */ - public ActionInstance lookupActionInstance(Action action) { - for (ActionInstance actionInstance : actions) { - if (actionInstance.definition == action) { - return actionInstance; - } - } - return null; + return null; + } + + /** + * Return the reactor instance within this reactor that has the specified instantiation. Note that + * this may be a bank of reactors. Return null if there is no such reactor instance. + */ + public ReactorInstance lookupReactorInstance(Instantiation instantiation) { + for (ReactorInstance reactorInstance : children) { + if (reactorInstance.definition == instantiation) { + return reactorInstance; + } } - - /** - * Given a parameter definition, return the parameter instance - * corresponding to that definition, or null if there is - * no such instance. - * @param parameter The parameter definition (a syntactic object in the AST). - * @return A parameter instance, or null if there is none. - */ - public ParameterInstance lookupParameterInstance(Parameter parameter) { - for (ParameterInstance param : parameters) { - if (param.definition == parameter) { - return param; - } - } - return null; - } - - /** - * Given a port definition, return the port instance - * corresponding to that definition, or null if there is - * no such instance. - * @param port The port definition (a syntactic object in the AST). - * @return A port instance, or null if there is none. - */ - public PortInstance lookupPortInstance(Port port) { - // Search one of the inputs and outputs sets. - List ports = null; - if (port instanceof Input) { - ports = this.inputs; - } else if (port instanceof Output) { - ports = this.outputs; - } - for (PortInstance portInstance : ports) { - if (portInstance.definition == port) { - return portInstance; - } - } - return null; + return null; + } + + /** + * Return the timer instance within this reactor instance corresponding to the specified timer + * reference. + * + * @param timer The timer as an AST node. + * @return The corresponding timer instance or null if the timer does not belong to this reactor. + */ + public TimerInstance lookupTimerInstance(Timer timer) { + for (TimerInstance timerInstance : timers) { + if (timerInstance.definition == timer) { + return timerInstance; + } } - - /** - * Given a reference to a port belonging to this reactor - * instance, return the port instance. - * Return null if there is no such instance. - * @param reference The port reference. - * @return A port instance, or null if there is none. - */ - public PortInstance lookupPortInstance(VarRef reference) { - if (!(reference.getVariable() instanceof Port)) { - // Trying to resolve something that is not a port - return null; - } - if (reference.getContainer() == null) { - // Handle local reference - return lookupPortInstance((Port) reference.getVariable()); - } else { - // Handle hierarchical reference - var containerInstance = getChildReactorInstance(reference.getContainer()); - if (containerInstance == null) return null; - return containerInstance.lookupPortInstance((Port) reference.getVariable()); - } - } - - /** - * Return the reaction instance within this reactor - * instance corresponding to the specified reaction. - * @param reaction The reaction as an AST node. - * @return The corresponding reaction instance or null if the - * reaction does not belong to this reactor. - */ - public ReactionInstance lookupReactionInstance(Reaction reaction) { - for (ReactionInstance reactionInstance : reactions) { - if (reactionInstance.definition == reaction) { - return reactionInstance; - } - } - return null; + return null; + } + + /** + * Returns the mode instance within this reactor instance corresponding to the specified mode + * reference. + * + * @param mode The mode as an AST node. + * @return The corresponding mode instance or null if the mode does not belong to this reactor. + */ + public ModeInstance lookupModeInstance(Mode mode) { + for (ModeInstance modeInstance : modes) { + if (modeInstance.definition == mode) { + return modeInstance; + } } - - /** - * Return the reactor instance within this reactor - * that has the specified instantiation. Note that this - * may be a bank of reactors. Return null if there - * is no such reactor instance. - */ - public ReactorInstance lookupReactorInstance(Instantiation instantiation) { - for (ReactorInstance reactorInstance : children) { - if (reactorInstance.definition == instantiation) { - return reactorInstance; - } + return null; + } + + /** Return a descriptive string. */ + @Override + public String toString() { + return "ReactorInstance " + getFullName(); + } + + /** + * Assuming that the given expression denotes a valid time, return a time value. + * + *

If the value is given as a parameter reference, this will look up the precise time value + * assigned to this reactor instance. + */ + public TimeValue getTimeValue(Expression expr) { + Expression resolved = resolveParameters(expr); + return getLiteralTimeValue(resolved); + } + + ////////////////////////////////////////////////////// + //// Protected fields. + + /** The generator that created this reactor instance. */ + protected ErrorReporter reporter; // FIXME: This accumulates a lot of redundant references + + /** The map of used built-in triggers. */ + protected Map> builtinTriggers = + new HashMap<>(); + + /** + * The LF syntax does not currently support declaring reactions unordered, but unordered reactions + * are created in the AST transformations handling federated communication and after delays. + * Unordered reactions can execute in any order and concurrently even though they are in the same + * reactor. FIXME: Remove this when the language provides syntax. + */ + protected Set unorderedReactions = new LinkedHashSet<>(); + + /** The nested list of instantiations that created this reactor instance. */ + protected List _instantiations; + + ////////////////////////////////////////////////////// + //// Protected methods. + + /** + * Create all the reaction instances of this reactor instance and record the dependencies and + * antidependencies between ports, actions, and timers and reactions. This also records the + * dependencies between reactions that follows from the order in which they are defined. + */ + protected void createReactionInstances() { + List reactions = ASTUtils.allReactions(reactorDefinition); + if (reactions != null) { + int count = 0; + + // Check for startup and shutdown triggers. + for (Reaction reaction : reactions) { + if (AttributeUtils.isUnordered(reaction)) { + unorderedReactions.add(reaction); } - return null; + // Create the reaction instance. + var reactionInstance = + new ReactionInstance(reaction, this, unorderedReactions.contains(reaction), count++); + + // Add the reaction instance to the map of reactions for this + // reactor. + this.reactions.add(reactionInstance); + } } - - /** - * Return the timer instance within this reactor - * instance corresponding to the specified timer reference. - * @param timer The timer as an AST node. - * @return The corresponding timer instance or null if the - * timer does not belong to this reactor. - */ - public TimerInstance lookupTimerInstance(Timer timer) { - for (TimerInstance timerInstance : timers) { - if (timerInstance.definition == timer) { - return timerInstance; - } - } - return null; + } + + /** Create all the watchdog instances of this reactor instance. */ + protected void createWatchdogInstances() { + List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); + if (watchdogs != null) { + for (Watchdog watchdog : watchdogs) { + // Create the watchdog instance. + var watchdogInstance = new WatchdogInstance(watchdog, this); + + // Add the watchdog instance to the list of watchdogs for this + // reactor. + this.watchdogs.add(watchdogInstance); + } } - - /** Returns the mode instance within this reactor - * instance corresponding to the specified mode reference. - * @param mode The mode as an AST node. - * @return The corresponding mode instance or null if the - * mode does not belong to this reactor. - */ - public ModeInstance lookupModeInstance(Mode mode) { - for (ModeInstance modeInstance : modes) { - if (modeInstance.definition == mode) { - return modeInstance; - } + } + + /** Returns the built-in trigger or create a new one if none exists. */ + protected TriggerInstance getOrCreateBuiltinTrigger( + BuiltinTriggerRef trigger) { + return builtinTriggers.computeIfAbsent( + trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); + } + + //////////////////////////////////////// + //// Private constructors + + /** + * Create a runtime instance from the specified definition and with the specified parent that + * instantiated it. + * + * @param definition The instantiation statement in the AST. + * @param parent The parent, or null for the main rector. + * @param reporter An error reporter. + * @param desiredDepth The depth to which to expand the hierarchy. + */ + private ReactorInstance( + Instantiation definition, ReactorInstance parent, ErrorReporter reporter, int desiredDepth) { + super(definition, parent); + this.reporter = reporter; + this.reactorDeclaration = definition.getReactorClass(); + this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); + + // check for recursive instantiation + var currentParent = parent; + var foundSelfAsParent = false; + do { + if (currentParent != null) { + if (currentParent.reactorDefinition == this.reactorDefinition) { + foundSelfAsParent = true; + currentParent = null; // break + } else { + currentParent = currentParent.parent; } - return null; - } + } + } while (currentParent != null); - /** - * Return a descriptive string. - */ - @Override - public String toString() { - return "ReactorInstance " + getFullName(); - } - - /** - * Assuming that the given expression denotes a valid time, return a time value. - * - * If the value is given as a parameter reference, this will look up the - * precise time value assigned to this reactor instance. - */ - public TimeValue getTimeValue(Expression expr) { - Expression resolved = resolveParameters(expr); - return getLiteralTimeValue(resolved); + this.recursive = foundSelfAsParent; + if (recursive) { + reporter.reportError(definition, "Recursive reactor instantiation."); } - - ////////////////////////////////////////////////////// - //// Protected fields. - - /** The generator that created this reactor instance. */ - protected ErrorReporter reporter; // FIXME: This accumulates a lot of redundant references - - /** The map of used built-in triggers. */ - protected Map> builtinTriggers = new HashMap<>(); - - /** - * The LF syntax does not currently support declaring reactions unordered, - * but unordered reactions are created in the AST transformations handling - * federated communication and after delays. Unordered reactions can execute - * in any order and concurrently even though they are in the same reactor. - * FIXME: Remove this when the language provides syntax. - */ - protected Set unorderedReactions = new LinkedHashSet<>(); - - /** The nested list of instantiations that created this reactor instance. */ - protected List _instantiations; - - ////////////////////////////////////////////////////// - //// Protected methods. - - /** - * Create all the reaction instances of this reactor instance - * and record the dependencies and antidependencies - * between ports, actions, and timers and reactions. - * This also records the dependencies between reactions - * that follows from the order in which they are defined. - */ - protected void createReactionInstances() { - List reactions = ASTUtils.allReactions(reactorDefinition); - if (reactions != null) { - int count = 0; - - // Check for startup and shutdown triggers. - for (Reaction reaction : reactions) { - if (AttributeUtils.isUnordered(reaction)) { - unorderedReactions.add(reaction); - } - // Create the reaction instance. - var reactionInstance = new ReactionInstance(reaction, this, - unorderedReactions.contains(reaction), count++); - - // Add the reaction instance to the map of reactions for this - // reactor. - this.reactions.add(reactionInstance); - } - } + + // If the reactor definition is null, give up here. Otherwise, diagram generation + // will fail an NPE. + if (reactorDefinition == null) { + reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); + return; } - /** - * Create all the watchdog instances of this reactor instance. - */ - protected void createWatchdogInstances() { - List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); - if (watchdogs != null) { - for (Watchdog watchdog : watchdogs) { - // Create the watchdog instance. - var watchdogInstance = new WatchdogInstance(watchdog, this); - - // Add the watchdog instance to the list of watchdogs for this - // reactor. - this.watchdogs.add(watchdogInstance); - } - } + setInitialWidth(); + + // Apply overrides and instantiate parameters for this reactor instance. + for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { + this.parameters.add(new ParameterInstance(parameter, this)); } - /** - * Returns the built-in trigger or create a new one if none exists. - */ - protected TriggerInstance getOrCreateBuiltinTrigger(BuiltinTriggerRef trigger) { - return builtinTriggers.computeIfAbsent(trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); + // Instantiate inputs for this reactor instance + for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { + this.inputs.add(new PortInstance(inputDecl, this, reporter)); } - - //////////////////////////////////////// - //// Private constructors - - /** - * Create a runtime instance from the specified definition - * and with the specified parent that instantiated it. - * @param definition The instantiation statement in the AST. - * @param parent The parent, or null for the main rector. - * @param reporter An error reporter. - * @param desiredDepth The depth to which to expand the hierarchy. - */ - private ReactorInstance( - Instantiation definition, - ReactorInstance parent, - ErrorReporter reporter, - int desiredDepth) { - super(definition, parent); - this.reporter = reporter; - this.reactorDeclaration = definition.getReactorClass(); - this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); - - // check for recursive instantiation - var currentParent = parent; - var foundSelfAsParent = false; - do { - if (currentParent != null) { - if (currentParent.reactorDefinition == this.reactorDefinition) { - foundSelfAsParent = true; - currentParent = null; // break - } else { - currentParent = currentParent.parent; - } - } - } while(currentParent != null); - - this.recursive = foundSelfAsParent; - if (recursive) { - reporter.reportError(definition, "Recursive reactor instantiation."); - } - - // If the reactor definition is null, give up here. Otherwise, diagram generation - // will fail an NPE. - if (reactorDefinition == null) { - reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); - return; - } - - setInitialWidth(); - - // Apply overrides and instantiate parameters for this reactor instance. - for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { - this.parameters.add(new ParameterInstance(parameter, this)); - } - // Instantiate inputs for this reactor instance - for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { - this.inputs.add(new PortInstance(inputDecl, this, reporter)); - } + // Instantiate outputs for this reactor instance + for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { + this.outputs.add(new PortInstance(outputDecl, this, reporter)); + } - // Instantiate outputs for this reactor instance - for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { - this.outputs.add(new PortInstance(outputDecl, this, reporter)); + // Do not process content (except interface above) if recursive + if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { + // Instantiate children for this reactor instance. + // While doing this, assign an index offset to each. + for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { + var childInstance = new ReactorInstance(child, this, reporter, desiredDepth); + this.children.add(childInstance); + } + + // Instantiate timers for this reactor instance + for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { + this.timers.add(new TimerInstance(timerDecl, this)); + } + + // Instantiate actions for this reactor instance + for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { + this.actions.add(new ActionInstance(actionDecl, this)); + } + + establishPortConnections(); + + // Create the reaction instances in this reactor instance. + // This also establishes all the implied dependencies. + // Note that this can only happen _after_ the children, + // port, action, and timer instances have been created. + createReactionInstances(); + + // Create the reaction instances in this reactor instance. + createWatchdogInstances(); + + // Instantiate modes for this reactor instance + // This must come after the child elements (reactions, etc) of this reactor + // are created in order to allow their association with modes + for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { + this.modes.add(new ModeInstance(modeDecl, this)); + } + for (ModeInstance mode : this.modes) { + mode.setupTranstions(); + } + } + } + + ////////////////////////////////////////////////////// + //// Private methods. + + /** + * Connect the given left port range to the given right port range. + * + *

NOTE: This method is public to enable its use in unit tests. Otherwise, it should be + * private. This is why it is defined here, in the section labeled "Private methods." + * + * @param src The source range. + * @param dst The destination range. + * @param connection The connection establishing this relationship. + */ + public static void connectPortInstances( + RuntimeRange src, RuntimeRange dst, Connection connection) { + SendRange range = new SendRange(src, dst, src._interleaved, connection); + src.instance.dependentPorts.add(range); + dst.instance.dependsOnPorts.add(src); + } + + /** + * Populate connectivity information in the port instances. Note that this can only happen _after_ + * the children and port instances have been created. Unfortunately, we have to do some + * complicated things here to support multiport-to-multiport, multiport-to-bank, and + * bank-to-multiport communication. The principle being followed is: in each connection statement, + * for each port instance on the left, connect to the next available port on the right. + */ + private void establishPortConnections() { + for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { + List> leftPorts = + listPortInstances(connection.getLeftPorts(), connection); + Iterator> srcRanges = leftPorts.iterator(); + List> rightPorts = + listPortInstances(connection.getRightPorts(), connection); + Iterator> dstRanges = rightPorts.iterator(); + + // Check for empty lists. + if (!srcRanges.hasNext()) { + if (dstRanges.hasNext()) { + reporter.reportWarning(connection, "No sources to provide inputs."); } - - // Do not process content (except interface above) if recursive - if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { - // Instantiate children for this reactor instance. - // While doing this, assign an index offset to each. - for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { - var childInstance = new ReactorInstance( - child, - this, - reporter, - desiredDepth - ); - this.children.add(childInstance); + return; + } else if (!dstRanges.hasNext()) { + reporter.reportWarning(connection, "No destination. Outputs will be lost."); + return; + } + + RuntimeRange src = srcRanges.next(); + RuntimeRange dst = dstRanges.next(); + + while (true) { + if (dst.width == src.width) { + connectPortInstances(src, dst, connection); + if (!dstRanges.hasNext()) { + if (srcRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Source is wider than the destination. Outputs will be lost."); } - - // Instantiate timers for this reactor instance - for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { - this.timers.add(new TimerInstance(timerDecl, this)); - } - - // Instantiate actions for this reactor instance - for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { - this.actions.add(new ActionInstance(actionDecl, this)); - } - - establishPortConnections(); - - // Create the reaction instances in this reactor instance. - // This also establishes all the implied dependencies. - // Note that this can only happen _after_ the children, - // port, action, and timer instances have been created. - createReactionInstances(); - - // Create the reaction instances in this reactor instance. - createWatchdogInstances(); - - // Instantiate modes for this reactor instance - // This must come after the child elements (reactions, etc) of this reactor - // are created in order to allow their association with modes - for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { - this.modes.add(new ModeInstance(modeDecl, this)); + break; + } + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + if (dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Destination is wider than the source. Inputs will be missing."); + } + break; } - for (ModeInstance mode : this.modes) { - mode.setupTranstions(); + } + dst = dstRanges.next(); + src = srcRanges.next(); + } else if (dst.width < src.width) { + // Split the left (src) range in two. + connectPortInstances(src.head(dst.width), dst, connection); + src = src.tail(dst.width); + if (!dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Source is wider than the destination. Outputs will be lost."); + break; + } + dst = dstRanges.next(); + } else if (src.width < dst.width) { + // Split the right (dst) range in two. + connectPortInstances(src, dst.head(src.width), connection); + dst = dst.tail(src.width); + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + reporter.reportWarning( + connection, "Destination is wider than the source. Inputs will be missing."); + break; } + } + src = srcRanges.next(); } + } } - - ////////////////////////////////////////////////////// - //// Private methods. - - /** - * Connect the given left port range to the given right port range. - * - * NOTE: This method is public to enable its use in unit tests. - * Otherwise, it should be private. This is why it is defined here, - * in the section labeled "Private methods." - * - * @param src The source range. - * @param dst The destination range. - * @param connection The connection establishing this relationship. - */ - public static void connectPortInstances( - RuntimeRange src, - RuntimeRange dst, - Connection connection - ) { - SendRange range = new SendRange(src, dst, src._interleaved, connection); - src.instance.dependentPorts.add(range); - dst.instance.dependsOnPorts.add(src); + } + + /** + * If path exists from the specified port to any reaction in the specified set of reactions, then + * add the specified port and all ports along the path to the specified set of ports. + * + * @return True if the specified port was added. + */ + private boolean findPaths( + PortInstance port, Set reactions, Set ports) { + if (ports.contains(port)) return false; + boolean result = false; + for (ReactionInstance d : port.getDependentReactions()) { + if (reactions.contains(d)) ports.add(port); + result = true; } - - /** - * Populate connectivity information in the port instances. - * Note that this can only happen _after_ the children and port instances have been created. - * Unfortunately, we have to do some complicated things here - * to support multiport-to-multiport, multiport-to-bank, - * and bank-to-multiport communication. The principle being followed is: - * in each connection statement, for each port instance on the left, - * connect to the next available port on the right. - */ - private void establishPortConnections() { - for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { - List> leftPorts = listPortInstances(connection.getLeftPorts(), connection); - Iterator> srcRanges = leftPorts.iterator(); - List> rightPorts = listPortInstances(connection.getRightPorts(), connection); - Iterator> dstRanges = rightPorts.iterator(); - - // Check for empty lists. - if (!srcRanges.hasNext()) { - if (dstRanges.hasNext()) { - reporter.reportWarning(connection, "No sources to provide inputs."); - } - return; - } else if (!dstRanges.hasNext()) { - reporter.reportWarning(connection, "No destination. Outputs will be lost."); - return; - } - - RuntimeRange src = srcRanges.next(); - RuntimeRange dst = dstRanges.next(); - - while(true) { - if (dst.width == src.width) { - connectPortInstances(src, dst, connection); - if (!dstRanges.hasNext()) { - if (srcRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Source is wider than the destination. Outputs will be lost."); - } - break; - } - if (!srcRanges.hasNext()) { - if (connection.isIterated()) { - srcRanges = leftPorts.iterator(); - } else { - if (dstRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Destination is wider than the source. Inputs will be missing."); - } - break; - } - } - dst = dstRanges.next(); - src = srcRanges.next(); - } else if (dst.width < src.width) { - // Split the left (src) range in two. - connectPortInstances(src.head(dst.width), dst, connection); - src = src.tail(dst.width); - if (!dstRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Source is wider than the destination. Outputs will be lost."); - break; - } - dst = dstRanges.next(); - } else if (src.width < dst.width) { - // Split the right (dst) range in two. - connectPortInstances(src, dst.head(src.width), connection); - dst = dst.tail(src.width); - if (!srcRanges.hasNext()) { - if (connection.isIterated()) { - srcRanges = leftPorts.iterator(); - } else { - reporter.reportWarning(connection, - "Destination is wider than the source. Inputs will be missing."); - break; - } - } - src = srcRanges.next(); - } - } + // Perform a depth-first search. + for (SendRange r : port.dependentPorts) { + for (RuntimeRange p : r.destinations) { + boolean added = findPaths(p.instance, reactions, ports); + if (added) { + result = true; + ports.add(port); } + } } - - /** - * If path exists from the specified port to any reaction in the specified - * set of reactions, then add the specified port and all ports along the path - * to the specified set of ports. - * @return True if the specified port was added. - */ - private boolean findPaths( - PortInstance port, - Set reactions, - Set ports - ) { - if (ports.contains(port)) return false; - boolean result = false; - for (ReactionInstance d : port.getDependentReactions()) { - if (reactions.contains(d)) ports.add(port); - result = true; - } - // Perform a depth-first search. - for (SendRange r : port.dependentPorts) { - for (RuntimeRange p : r.destinations) { - boolean added = findPaths(p.instance, reactions, ports); - if (added) { - result = true; - ports.add(port); - } - } - } + return result; + } + + /** + * Given a list of port references, as found on either side of a connection, return a list of the + * port instance ranges referenced. These may be multiports, and may be ports of a contained bank + * (a port representing ports of the bank members) so the returned list includes ranges of banks + * and channels. + * + *

If a given port reference has the form `interleaved(b.m)`, where `b` is a bank and `m` is a + * multiport, then the corresponding range in the returned list is marked interleaved. + * + *

For example, if `b` and `m` have width 2, without the interleaved keyword, the returned + * range represents the sequence `[b0.m0, b0.m1, b1.m0, b1.m1]`. With the interleaved marking, the + * returned range represents the sequence `[b0.m0, b1.m0, b0.m1, b1.m1]`. Both ranges will have + * width 4. + * + * @param references The variable references on one side of the connection. + * @param connection The connection. + */ + private List> listPortInstances( + List references, Connection connection) { + List> result = new ArrayList<>(); + List> tails = new LinkedList<>(); + int count = 0; + for (VarRef portRef : references) { + // Simple error checking first. + if (!(portRef.getVariable() instanceof Port)) { + reporter.reportError(portRef, "Not a port."); return result; - } - - /** - * Given a list of port references, as found on either side of a connection, - * return a list of the port instance ranges referenced. These may be multiports, - * and may be ports of a contained bank (a port representing ports of the bank - * members) so the returned list includes ranges of banks and channels. - * - * If a given port reference has the form `interleaved(b.m)`, where `b` is - * a bank and `m` is a multiport, then the corresponding range in the returned - * list is marked interleaved. - * - * For example, if `b` and `m` have width 2, without the interleaved keyword, - * the returned range represents the sequence `[b0.m0, b0.m1, b1.m0, b1.m1]`. - * With the interleaved marking, the returned range represents the sequence - * `[b0.m0, b1.m0, b0.m1, b1.m1]`. Both ranges will have width 4. - * - * @param references The variable references on one side of the connection. - * @param connection The connection. - */ - private List> listPortInstances( - List references, Connection connection - ) { - List> result = new ArrayList<>(); - List> tails = new LinkedList<>(); - int count = 0; - for (VarRef portRef : references) { - // Simple error checking first. - if (!(portRef.getVariable() instanceof Port)) { - reporter.reportError(portRef, "Not a port."); - return result; - } - // First, figure out which reactor we are dealing with. - // The reactor we want is the container of the port. - // If the port reference has no container, then the reactor is this one. - var reactor = this; - if (portRef.getContainer() != null) { - reactor = getChildReactorInstance(portRef.getContainer()); - } - // The reactor can be null only if there is an error in the code. - // Skip this portRef so that diagram synthesis can complete. - if (reactor != null) { - PortInstance portInstance = reactor.lookupPortInstance( - (Port) portRef.getVariable()); - - Set interleaved = new LinkedHashSet<>(); - if (portRef.isInterleaved()) { - // NOTE: Here, we are assuming that the interleaved() - // keyword is only allowed on the multiports contained by - // contained reactors. - interleaved.add(portInstance.parent); - } - RuntimeRange range = new RuntimeRange.Port( - portInstance, interleaved); - // If this portRef is not the last one in the references list - // then we have to check whether the range can be incremented at - // the lowest two levels (port and container). If not, - // split the range and add the tail to list to iterate over again. - // The reason for this is that the connection has only local visibility, - // but the range width may be reflective of bank structure higher - // in the hierarchy. - if (count < references.size() - 1) { - int portWidth = portInstance.width; - int portParentWidth = portInstance.parent.width; - // If the port is being connected on the inside and there is - // more than one port in the list, then we can only connect one - // bank member at a time. - if (reactor == this && references.size() > 1) { - portParentWidth = 1; - } - int widthBound = portWidth * portParentWidth; - - // If either of these widths cannot be determined, assume infinite. - if (portWidth < 0) widthBound = Integer.MAX_VALUE; - if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; - - if (widthBound < range.width) { - // Need to split the range. - tails.add(range.tail(widthBound)); - range = range.head(widthBound); - } - } - result.add(range); - } + } + // First, figure out which reactor we are dealing with. + // The reactor we want is the container of the port. + // If the port reference has no container, then the reactor is this one. + var reactor = this; + if (portRef.getContainer() != null) { + reactor = getChildReactorInstance(portRef.getContainer()); + } + // The reactor can be null only if there is an error in the code. + // Skip this portRef so that diagram synthesis can complete. + if (reactor != null) { + PortInstance portInstance = reactor.lookupPortInstance((Port) portRef.getVariable()); + + Set interleaved = new LinkedHashSet<>(); + if (portRef.isInterleaved()) { + // NOTE: Here, we are assuming that the interleaved() + // keyword is only allowed on the multiports contained by + // contained reactors. + interleaved.add(portInstance.parent); } - // Iterate over the tails. - while(tails.size() > 0) { - List> moreTails = new LinkedList<>(); - count = 0; - for (RuntimeRange tail : tails) { - if (count < tails.size() - 1) { - int widthBound = tail.instance.width; - if (tail._interleaved.contains(tail.instance.parent)) { - widthBound = tail.instance.parent.width; - } - // If the width cannot be determined, assume infinite. - if (widthBound < 0) widthBound = Integer.MAX_VALUE; - - if (widthBound < tail.width) { - // Need to split the range again - moreTails.add(tail.tail(widthBound)); - tail = tail.head(widthBound); - } - } - result.add(tail); - } - tails = moreTails; + RuntimeRange range = new RuntimeRange.Port(portInstance, interleaved); + // If this portRef is not the last one in the references list + // then we have to check whether the range can be incremented at + // the lowest two levels (port and container). If not, + // split the range and add the tail to list to iterate over again. + // The reason for this is that the connection has only local visibility, + // but the range width may be reflective of bank structure higher + // in the hierarchy. + if (count < references.size() - 1) { + int portWidth = portInstance.width; + int portParentWidth = portInstance.parent.width; + // If the port is being connected on the inside and there is + // more than one port in the list, then we can only connect one + // bank member at a time. + if (reactor == this && references.size() > 1) { + portParentWidth = 1; + } + int widthBound = portWidth * portParentWidth; + + // If either of these widths cannot be determined, assume infinite. + if (portWidth < 0) widthBound = Integer.MAX_VALUE; + if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < range.width) { + // Need to split the range. + tails.add(range.tail(widthBound)); + range = range.head(widthBound); + } } - return result; + result.add(range); + } } - - /** - * If this is a bank of reactors, set the width. - * It will be set to -1 if it cannot be determined. - */ - private void setInitialWidth() { - WidthSpec widthSpec = definition.getWidthSpec(); - if (widthSpec != null) { - // We need the instantiations list of the containing reactor, - // not this one. - width = ASTUtils.width(widthSpec, parent.instantiations()); + // Iterate over the tails. + while (tails.size() > 0) { + List> moreTails = new LinkedList<>(); + count = 0; + for (RuntimeRange tail : tails) { + if (count < tails.size() - 1) { + int widthBound = tail.instance.width; + if (tail._interleaved.contains(tail.instance.parent)) { + widthBound = tail.instance.parent.width; + } + // If the width cannot be determined, assume infinite. + if (widthBound < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < tail.width) { + // Need to split the range again + moreTails.add(tail.tail(widthBound)); + tail = tail.head(widthBound); + } } + result.add(tail); + } + tails = moreTails; } - - ////////////////////////////////////////////////////// - //// Private fields. - - /** - * Cached set of reactions and ports that form a causality loop. - */ - private Set> cachedCycles; - - /** - * Cached reaction graph containing reactions that form a causality loop. - */ - private ReactionInstanceGraph cachedReactionLoopGraph = null; - - /** - * Return true if this is a generated delay reactor that originates from - * an "after" delay on a connection. - * - * @return True if this is a generated delay, false otherwise. - */ - public boolean isGeneratedDelay() { - if (this.definition.getReactorClass().getName().contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME)) { - return true; - } - return false; + return result; + } + + /** + * If this is a bank of reactors, set the width. It will be set to -1 if it cannot be determined. + */ + private void setInitialWidth() { + WidthSpec widthSpec = definition.getWidthSpec(); + if (widthSpec != null) { + // We need the instantiations list of the containing reactor, + // not this one. + width = ASTUtils.width(widthSpec, parent.instantiations()); + } + } + + ////////////////////////////////////////////////////// + //// Private fields. + + /** Cached set of reactions and ports that form a causality loop. */ + private Set> cachedCycles; + + /** Cached reaction graph containing reactions that form a causality loop. */ + private ReactionInstanceGraph cachedReactionLoopGraph = null; + + /** + * Return true if this is a generated delay reactor that originates from an "after" delay on a + * connection. + * + * @return True if this is a generated delay, false otherwise. + */ + public boolean isGeneratedDelay() { + if (this.definition + .getReactorClass() + .getName() + .contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME)) { + return true; } + return false; + } } diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index 001246cf2f..ca5cb3d192 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -4,64 +4,60 @@ import org.lflang.lf.Watchdog; /** - * Instance of a watchdog. Upon creation the actual delay is converted into - * a proper time value. If a parameter is referenced, it is looked up in the - * given (grand)parent reactor instance. - * + * Instance of a watchdog. Upon creation the actual delay is converted into a proper time value. If + * a parameter is referenced, it is looked up in the given (grand)parent reactor instance. + * * @author{Benjamin Asch } */ public class WatchdogInstance { - - /** - * Create a new watchdog instance associated with the given reactor - * instance. - */ - public WatchdogInstance(Watchdog definition, ReactorInstance reactor) { - if (definition.getTimeout() != null) { - // Get the timeout value given in the watchdog declaration. - this.timeout = reactor.getTimeValue(definition.getTimeout()); - } else { - // NOTE: The grammar does not allow the timeout to be omitted, so this should not occur. - this.timeout = TimeValue.ZERO; - } - this.name = definition.getName().toString(); - this.definition = definition; - this.reactor = reactor; + /** Create a new watchdog instance associated with the given reactor instance. */ + public WatchdogInstance(Watchdog definition, ReactorInstance reactor) { + if (definition.getTimeout() != null) { + // Get the timeout value given in the watchdog declaration. + this.timeout = reactor.getTimeValue(definition.getTimeout()); + } else { + // NOTE: The grammar does not allow the timeout to be omitted, so this should not occur. + this.timeout = TimeValue.ZERO; } - ////////////////////////////////////////////////////// - //// Public methods. + this.name = definition.getName().toString(); + this.definition = definition; + this.reactor = reactor; + } - public String getName() { - return this.name; - } + ////////////////////////////////////////////////////// + //// Public methods. - public Watchdog getDefinition() { - return this.definition; - } + public String getName() { + return this.name; + } - public TimeValue getTimeout() { - return (TimeValue) this.timeout; - } + public Watchdog getDefinition() { + return this.definition; + } - public ReactorInstance getReactor() { - return this.reactor; - } + public TimeValue getTimeout() { + return (TimeValue) this.timeout; + } - @Override - public String toString() { - return "WatchdogInstance " + name + "(" + timeout.toString() + ")"; - } + public ReactorInstance getReactor() { + return this.reactor; + } + + @Override + public String toString() { + return "WatchdogInstance " + name + "(" + timeout.toString() + ")"; + } - ////////////////////////////////////////////////////// - //// Private fields. + ////////////////////////////////////////////////////// + //// Private fields. - private final TimeValue timeout; + private final TimeValue timeout; - private final String name; + private final String name; - private final Watchdog definition; + private final Watchdog definition; - private final ReactorInstance reactor; + private final ReactorInstance reactor; } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 07d77cdbd5..0ded0e2bc2 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1,26 +1,26 @@ /************* -Copyright (c) 2019-2021, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2021, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator.c; @@ -36,6 +36,8 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import static org.lflang.ASTUtils.toText; import static org.lflang.util.StringUtil.addDoubleQuotes; +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; import java.io.File; import java.io.IOException; import java.nio.file.Files; @@ -45,44 +47,36 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.StringExtensions; - import org.lflang.ASTUtils; -import org.lflang.generator.DockerComposeGenerator; import org.lflang.FileConfig; import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty; import org.lflang.TargetProperty.Platform; - -import org.lflang.federated.extensions.CExtensionUtils; - import org.lflang.ast.DelayedConnectionTransformation; - +import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.ActionInstance; import org.lflang.generator.CodeBuilder; +import org.lflang.generator.DelayBodyGenerator; +import org.lflang.generator.DockerComposeGenerator; import org.lflang.generator.DockerGenerator; import org.lflang.generator.GeneratorBase; import org.lflang.generator.GeneratorResult; import org.lflang.generator.GeneratorUtils; -import org.lflang.generator.DelayBodyGenerator; - import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFResource; import org.lflang.generator.ParameterInstance; import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; - -import org.lflang.generator.WatchdogInstance; - import org.lflang.generator.TargetTypes; import org.lflang.generator.TimerInstance; import org.lflang.generator.TriggerInstance; +import org.lflang.generator.WatchdogInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; import org.lflang.lf.Input; @@ -97,209 +91,172 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; import org.lflang.lf.Variable; -import org.lflang.util.ArduinoUtil; import org.lflang.lf.Watchdog; +import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; -import org.lflang.lf.Watchdog; -import org.lflang.util.LFCommand; - -import com.google.common.base.Objects; -import com.google.common.collect.Iterables; - /** - * Generator for C target. This class generates C code defining each reactor - * class given in the input .lf file and imported .lf files. The generated code - * has the following components: + * Generator for C target. This class generates C code defining each reactor class given in the + * input .lf file and imported .lf files. The generated code has the following components: * - * * A typedef for inputs, outputs, and actions of each reactor class. These - * define the types of the variables that reactions use to access inputs and - * action values and to set output values. + *

* A typedef for inputs, outputs, and actions of each reactor class. These define the types of + * the variables that reactions use to access inputs and action values and to set output values. * - * * A typedef for a "self" struct for each reactor class. One instance of this - * struct will be created for each reactor instance. See below for details. + *

* A typedef for a "self" struct for each reactor class. One instance of this struct will be + * created for each reactor instance. See below for details. * - * * A function definition for each reaction in each reactor class. These - * functions take an instance of the self struct as an argument. + *

* A function definition for each reaction in each reactor class. These functions take an + * instance of the self struct as an argument. * - * * A constructor function for each reactor class. This is used to create - * a new instance of the reactor. + *

* A constructor function for each reactor class. This is used to create a new instance of the + * reactor. * - * After these, the main generated function is `_lf_initialize_trigger_objects()`. - * This function creates the instances of reactors (using their constructors) - * and makes connections between them. + *

After these, the main generated function is `_lf_initialize_trigger_objects()`. This function + * creates the instances of reactors (using their constructors) and makes connections between them. * - * A few other smaller functions are also generated. + *

A few other smaller functions are also generated. * - * ## Self Struct + *

## Self Struct * - * The "self" struct has fields for each of the following: + *

The "self" struct has fields for each of the following: * - * * parameter: the field name and type match the parameter. - * * state: the field name and type match the state. - * * action: the field name prepends the action name with "_lf_". - * A second field for the action is also created to house the trigger_t object. - * That second field prepends the action name with "_lf__". - * * output: the field name prepends the output name with "_lf_". - * * input: the field name prepends the output name with "_lf_". - * A second field for the input is also created to house the trigger_t object. - * That second field prepends the input name with "_lf__". + *

* parameter: the field name and type match the parameter. * state: the field name and type + * match the state. * action: the field name prepends the action name with "_lf_". A second field + * for the action is also created to house the trigger_t object. That second field prepends the + * action name with "_lf__". * output: the field name prepends the output name with "_lf_". * input: + * the field name prepends the output name with "_lf_". A second field for the input is also created + * to house the trigger_t object. That second field prepends the input name with "_lf__". * - * If, in addition, the reactor contains other reactors and reacts to their outputs, - * then there will be a struct within the self struct for each such contained reactor. - * The name of that self struct will be the name of the contained reactor prepended with "_lf_". - * That inside struct will contain pointers the outputs of the contained reactors - * that are read together with pointers to booleans indicating whether those outputs are present. + *

If, in addition, the reactor contains other reactors and reacts to their outputs, then there + * will be a struct within the self struct for each such contained reactor. The name of that self + * struct will be the name of the contained reactor prepended with "_lf_". That inside struct will + * contain pointers the outputs of the contained reactors that are read together with pointers to + * booleans indicating whether those outputs are present. * - * If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to - * trigger_t object (see reactor.h) for the shutdown event and an action struct named - * _lf_shutdown on the self struct. + *

If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to + * trigger_t object (see reactor.h) for the shutdown event and an action struct named _lf_shutdown + * on the self struct. * - * ## Reaction Functions + *

## Reaction Functions * - * For each reaction in a reactor class, this generator will produce a C function - * that expects a pointer to an instance of the "self" struct as an argument. - * This function will contain verbatim the C code specified in the reaction, but - * before that C code, the generator inserts a few lines of code that extract from the - * self struct the variables that that code has declared it will use. For example, if - * the reaction declares that it is triggered by or uses an input named "x" of type - * int, the function will contain a line like this: - * ``` - * r_x_t* x = self->_lf_x; - * ``` - * where `r` is the full name of the reactor class and the struct type `r_x_t` - * has fields `is_present` and `value`, where the type of `value` matches the port type. - * If the programmer fails to declare that it uses x, then the absence of the - * above code will trigger a compile error when the verbatim code attempts to read `x`. + *

For each reaction in a reactor class, this generator will produce a C function that expects a + * pointer to an instance of the "self" struct as an argument. This function will contain verbatim + * the C code specified in the reaction, but before that C code, the generator inserts a few lines + * of code that extract from the self struct the variables that that code has declared it will use. + * For example, if the reaction declares that it is triggered by or uses an input named "x" of type + * int, the function will contain a line like this: ``` r_x_t* x = self->_lf_x; ``` where `r` is the + * full name of the reactor class and the struct type `r_x_t` has fields `is_present` and `value`, + * where the type of `value` matches the port type. If the programmer fails to declare that it uses + * x, then the absence of the above code will trigger a compile error when the verbatim code + * attempts to read `x`. * - * ## Constructor + *

## Constructor * - * For each reactor class, this generator will create a constructor function named - * `new_r`, where `r` is the reactor class name. This function will malloc and return - * a pointer to an instance of the "self" struct. This struct initially represents - * an unconnected reactor. To establish connections between reactors, additional - * information needs to be inserted (see below). The self struct is made visible - * to the body of a reaction as a variable named "self". The self struct contains the - * following: + *

For each reactor class, this generator will create a constructor function named `new_r`, where + * `r` is the reactor class name. This function will malloc and return a pointer to an instance of + * the "self" struct. This struct initially represents an unconnected reactor. To establish + * connections between reactors, additional information needs to be inserted (see below). The self + * struct is made visible to the body of a reaction as a variable named "self". The self struct + * contains the following: * - * * Parameters: For each parameter `p` of the reactor, there will be a field `p` - * with the type and value of the parameter. So C code in the body of a reaction - * can access parameter values as `self->p`. + *

* Parameters: For each parameter `p` of the reactor, there will be a field `p` with the type + * and value of the parameter. So C code in the body of a reaction can access parameter values as + * `self->p`. * - * * State variables: For each state variable `s` of the reactor, there will be a field `s` - * with the type and value of the state variable. So C code in the body of a reaction - * can access state variables as `self->s`. + *

* State variables: For each state variable `s` of the reactor, there will be a field `s` with + * the type and value of the state variable. So C code in the body of a reaction can access state + * variables as `self->s`. * - * The self struct also contains various fields that the user is not intended to - * use. The names of these fields begin with at least two underscores. They are: + *

The self struct also contains various fields that the user is not intended to use. The names + * of these fields begin with at least two underscores. They are: * - * * Outputs: For each output named `out`, there will be a field `_lf_out` that is - * a struct containing a value field whose type matches that of the output. - * The output value is stored here. That struct also has a field `is_present` - * that is a boolean indicating whether the output has been set. - * This field is reset to false at the start of every time - * step. There is also a field `num_destinations` whose value matches the - * number of downstream reactors that use this variable. This field must be - * set when connections are made or changed. It is used to determine for - * a mutable input destination whether a copy needs to be made. + *

* Outputs: For each output named `out`, there will be a field `_lf_out` that is a struct + * containing a value field whose type matches that of the output. The output value is stored here. + * That struct also has a field `is_present` that is a boolean indicating whether the output has + * been set. This field is reset to false at the start of every time step. There is also a field + * `num_destinations` whose value matches the number of downstream reactors that use this variable. + * This field must be set when connections are made or changed. It is used to determine for a + * mutable input destination whether a copy needs to be made. * - * * Inputs: For each input named `in` of type T, there is a field named `_lf_in` - * that is a pointer struct with a value field of type T. The struct pointed - * to also has an `is_present` field of type bool that indicates whether the - * input is present. + *

* Inputs: For each input named `in` of type T, there is a field named `_lf_in` that is a + * pointer struct with a value field of type T. The struct pointed to also has an `is_present` field + * of type bool that indicates whether the input is present. * - * * Outputs of contained reactors: If a reactor reacts to outputs of a - * contained reactor `r`, then the self struct will contain a nested struct - * named `_lf_r` that has fields pointing to those outputs. For example, - * if `r` has an output `out` of type T, then there will be field in `_lf_r` - * named `out` that points to a struct containing a value field - * of type T and a field named `is_present` of type bool. + *

* Outputs of contained reactors: If a reactor reacts to outputs of a contained reactor `r`, + * then the self struct will contain a nested struct named `_lf_r` that has fields pointing to those + * outputs. For example, if `r` has an output `out` of type T, then there will be field in `_lf_r` + * named `out` that points to a struct containing a value field of type T and a field named + * `is_present` of type bool. * - * * Inputs of contained reactors: If a reactor sends to inputs of a - * contained reactor `r`, then the self struct will contain a nested struct - * named `_lf_r` that has fields for storing the values provided to those - * inputs. For example, if R has an input `in` of type T, then there will - * be field in _lf_R named `in` that is a struct with a value field - * of type T and a field named `is_present` of type bool. + *

* Inputs of contained reactors: If a reactor sends to inputs of a contained reactor `r`, then + * the self struct will contain a nested struct named `_lf_r` that has fields for storing the values + * provided to those inputs. For example, if R has an input `in` of type T, then there will be field + * in _lf_R named `in` that is a struct with a value field of type T and a field named `is_present` + * of type bool. * - * * Actions: If the reactor has an action a (logical or physical), then there - * will be a field in the self struct named `_lf_a` and another named `_lf__a`. - * The type of the first is specific to the action and contains a `value` - * field with the type and value of the action (if it has a value). That - * struct also has a `has_value` field, an `is_present` field, and a - * `token` field (which is NULL if the action carries no value). - * The `_lf__a` field is of type trigger_t. - * That struct contains various things, including an array of reactions - * sensitive to this trigger and a lf_token_t struct containing the value of - * the action, if it has a value. See reactor.h in the C library for - * details. + *

* Actions: If the reactor has an action a (logical or physical), then there will be a field in + * the self struct named `_lf_a` and another named `_lf__a`. The type of the first is specific to + * the action and contains a `value` field with the type and value of the action (if it has a + * value). That struct also has a `has_value` field, an `is_present` field, and a `token` field + * (which is NULL if the action carries no value). The `_lf__a` field is of type trigger_t. That + * struct contains various things, including an array of reactions sensitive to this trigger and a + * lf_token_t struct containing the value of the action, if it has a value. See reactor.h in the C + * library for details. * - * * Reactions: Each reaction will have several fields in the self struct. - * Each of these has a name that begins with `_lf__reaction_i`, where i is - * the number of the reaction, starting with 0. The fields are: - * * _lf__reaction_i: The struct that is put onto the reaction queue to - * execute the reaction (see reactor.h in the C library). + *

* Reactions: Each reaction will have several fields in the self struct. Each of these has a + * name that begins with `_lf__reaction_i`, where i is the number of the reaction, starting with 0. + * The fields are: * _lf__reaction_i: The struct that is put onto the reaction queue to execute the + * reaction (see reactor.h in the C library). * - * * Timers: For each timer t, there is are two fields in the self struct: - * * _lf__t: The trigger_t struct for this timer (see reactor.h). - * * _lf__t_reactions: An array of reactions (pointers to the - * reaction_t structs on this self struct) sensitive to this timer. + *

* Timers: For each timer t, there is are two fields in the self struct: * _lf__t: The + * trigger_t struct for this timer (see reactor.h). * _lf__t_reactions: An array of reactions + * (pointers to the reaction_t structs on this self struct) sensitive to this timer. * - * * Triggers: For each Timer, Action, Input, and Output of a contained - * reactor that triggers reactions, there will be a trigger_t struct - * on the self struct with name `_lf__t`, where t is the name of the trigger. + *

* Triggers: For each Timer, Action, Input, and Output of a contained reactor that triggers + * reactions, there will be a trigger_t struct on the self struct with name `_lf__t`, where t is the + * name of the trigger. * - * ## Connections Between Reactors + *

## Connections Between Reactors * - * Establishing connections between reactors involves two steps. - * First, each destination (e.g. an input port) must have pointers to - * the source (the output port). As explained above, for an input named - * `in`, the field `_lf_in->value` is a pointer to the output data being read. - * In addition, `_lf_in->is_present` is a pointer to the corresponding - * `out->is_present` field of the output reactor's self struct. + *

Establishing connections between reactors involves two steps. First, each destination (e.g. an + * input port) must have pointers to the source (the output port). As explained above, for an input + * named `in`, the field `_lf_in->value` is a pointer to the output data being read. In addition, + * `_lf_in->is_present` is a pointer to the corresponding `out->is_present` field of the output + * reactor's self struct. * - * In addition, the `reaction_i` struct on the self struct has a `triggers` - * field that records all the trigger_t structs for ports and actions - * that are triggered by the i-th reaction. The triggers field is - * an array of arrays of pointers to trigger_t structs. - * The length of the outer array is the number of output channels - * (single ports plus multiport widths) that the reaction effects - * plus the number of input port channels of contained - * reactors that it effects. Each inner array has a length equal to the - * number of final destinations of that output channel or input channel. - * The reaction_i struct has an array triggered_sizes that indicates - * the sizes of these inner arrays. The num_outputs field of the - * reaction_i struct gives the length of the triggered_sizes and - * (outer) triggers arrays. The num_outputs field is equal to the - * total number of single ports and multiport channels that the reaction - * writes to. + *

In addition, the `reaction_i` struct on the self struct has a `triggers` field that records + * all the trigger_t structs for ports and actions that are triggered by the i-th reaction. The + * triggers field is an array of arrays of pointers to trigger_t structs. The length of the outer + * array is the number of output channels (single ports plus multiport widths) that the reaction + * effects plus the number of input port channels of contained reactors that it effects. Each inner + * array has a length equal to the number of final destinations of that output channel or input + * channel. The reaction_i struct has an array triggered_sizes that indicates the sizes of these + * inner arrays. The num_outputs field of the reaction_i struct gives the length of the + * triggered_sizes and (outer) triggers arrays. The num_outputs field is equal to the total number + * of single ports and multiport channels that the reaction writes to. * - * ## Runtime Tables + *

## Runtime Tables * - * This generator creates an populates the following tables used at run time. - * These tables may have to be resized and adjusted when mutations occur. + *

This generator creates an populates the following tables used at run time. These tables may + * have to be resized and adjusted when mutations occur. * - * * _lf_is_present_fields: An array of pointers to booleans indicating whether an - * event is present. The _lf_start_time_step() function in reactor_common.c uses - * this to mark every event absent at the start of a time step. The size of this - * table is contained in the variable _lf_is_present_fields_size. - * * This table is accompanied by another list, _lf_is_present_fields_abbreviated, - * which only contains the is_present fields that have been set to true in the - * current tag. This list can allow a performance improvement if most ports are - * seldom present because only fields that have been set to true need to be - * reset to false. + *

* _lf_is_present_fields: An array of pointers to booleans indicating whether an event is + * present. The _lf_start_time_step() function in reactor_common.c uses this to mark every event + * absent at the start of a time step. The size of this table is contained in the variable + * _lf_is_present_fields_size. * This table is accompanied by another list, + * _lf_is_present_fields_abbreviated, which only contains the is_present fields that have been set + * to true in the current tag. This list can allow a performance improvement if most ports are + * seldom present because only fields that have been set to true need to be reset to false. * - * * _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown - * reactions. The length of this table is in the _lf_shutdown_triggers_size - * variable. + *

* _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown reactions. The + * length of this table is in the _lf_shutdown_triggers_size variable. * - * * _lf_timer_triggers: An array of pointers to trigger_t structs for timers that - * need to be started when the program runs. The length of this table is in the - * _lf_timer_triggers_size variable. + *

* _lf_timer_triggers: An array of pointers to trigger_t structs for timers that need to be + * started when the program runs. The length of this table is in the _lf_timer_triggers_size + * variable. * - * * _lf_action_table: For a federated execution, each federate will have this table - * that maps port IDs to the corresponding action struct, which can be cast to - * action_base_t. + *

* _lf_action_table: For a federated execution, each federate will have this table that maps + * port IDs to the corresponding action struct, which can be cast to action_base_t. * * @author Edward A. Lee * @author Marten Lohstroh @@ -314,1136 +271,1093 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY */ @SuppressWarnings("StaticPseudoFunctionalStyleMethod") public class CGenerator extends GeneratorBase { - // Regular expression pattern for compiler error messages with resource - // and line number information. The first match will a resource URI in the - // form of "file:/path/file.lf". The second match will be a line number. - // The third match is a character position within the line. - // The fourth match will be the error message. - static final Pattern compileErrorPattern = Pattern.compile( - "^(?.*):(?\\d+):(?\\d+):(?.*)$" - ); - - public static int UNDEFINED_MIN_SPACING = -1; - - //////////////////////////////////////////// - //// Protected fields - - /** The main place to put generated code. */ - protected CodeBuilder code = new CodeBuilder(); - - /** Place to collect code to initialize the trigger objects for all reactor instances. */ - protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); - - protected final CFileConfig fileConfig; - - /** - * Count of the number of is_present fields of the self struct that - * need to be reinitialized in _lf_start_time_step(). - */ - protected int startTimeStepIsPresentCount = 0; - - //////////////////////////////////////////// - //// Private fields - /** - * Extra lines that need to go into the generated CMakeLists.txt. - */ - private String cMakeExtras = ""; - - /** Place to collect code to execute at the start of a time step. */ - private CodeBuilder startTimeStep = new CodeBuilder(); - - /** Count of the number of token pointers that need to have their - * reference count decremented in _lf_start_time_step(). - */ - private int timerCount = 0; - private int startupReactionCount = 0; - private int shutdownReactionCount = 0; - private int resetReactionCount = 0; - private int modalReactorCount = 0; - private int modalStateResetCount = 0; - private int watchdogCount = 0; - - // Indicate whether the generator is in Cpp mode or not - private final boolean CCppMode; - - private final CTypes types; - - private final CCmakeGenerator cmakeGenerator; - - protected CGenerator( - LFGeneratorContext context, - boolean CCppMode, - CTypes types, - CCmakeGenerator cmakeGenerator, - DelayBodyGenerator delayBodyGenerator - ) { - super(context); - this.fileConfig = (CFileConfig) context.getFileConfig(); - this.CCppMode = CCppMode; - this.types = types; - this.cmakeGenerator = cmakeGenerator; - - // Register the delayed connection transformation to be applied by GeneratorBase. - // transform both after delays and physical connections - registerTransformation(new DelayedConnectionTransformation(delayBodyGenerator, types, fileConfig.resource, true, true)); + // Regular expression pattern for compiler error messages with resource + // and line number information. The first match will a resource URI in the + // form of "file:/path/file.lf". The second match will be a line number. + // The third match is a character position within the line. + // The fourth match will be the error message. + static final Pattern compileErrorPattern = + Pattern.compile("^(?.*):(?\\d+):(?\\d+):(?.*)$"); + + public static int UNDEFINED_MIN_SPACING = -1; + + //////////////////////////////////////////// + //// Protected fields + + /** The main place to put generated code. */ + protected CodeBuilder code = new CodeBuilder(); + + /** Place to collect code to initialize the trigger objects for all reactor instances. */ + protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); + + protected final CFileConfig fileConfig; + + /** + * Count of the number of is_present fields of the self struct that need to be reinitialized in + * _lf_start_time_step(). + */ + protected int startTimeStepIsPresentCount = 0; + + //////////////////////////////////////////// + //// Private fields + /** Extra lines that need to go into the generated CMakeLists.txt. */ + private String cMakeExtras = ""; + + /** Place to collect code to execute at the start of a time step. */ + private CodeBuilder startTimeStep = new CodeBuilder(); + + /** + * Count of the number of token pointers that need to have their reference count decremented in + * _lf_start_time_step(). + */ + private int timerCount = 0; + + private int startupReactionCount = 0; + private int shutdownReactionCount = 0; + private int resetReactionCount = 0; + private int modalReactorCount = 0; + private int modalStateResetCount = 0; + private int watchdogCount = 0; + + // Indicate whether the generator is in Cpp mode or not + private final boolean CCppMode; + + private final CTypes types; + + private final CCmakeGenerator cmakeGenerator; + + protected CGenerator( + LFGeneratorContext context, + boolean CCppMode, + CTypes types, + CCmakeGenerator cmakeGenerator, + DelayBodyGenerator delayBodyGenerator) { + super(context); + this.fileConfig = (CFileConfig) context.getFileConfig(); + this.CCppMode = CCppMode; + this.types = types; + this.cmakeGenerator = cmakeGenerator; + + // Register the delayed connection transformation to be applied by GeneratorBase. + // transform both after delays and physical connections + registerTransformation( + new DelayedConnectionTransformation( + delayBodyGenerator, types, fileConfig.resource, true, true)); + } + + public CGenerator(LFGeneratorContext context, boolean ccppMode) { + this( + context, + ccppMode, + new CTypes(), + new CCmakeGenerator(context.getFileConfig(), List.of()), + new CDelayBodyGenerator(new CTypes())); + } + + /** + * Look for physical actions in all resources. If found, set threads to be at least one to allow + * asynchronous schedule calls. + */ + public void accommodatePhysicalActionsIfPresent() { + // If there are any physical actions, ensure the threaded engine is used and that + // keepalive is set to true, unless the user has explicitly set it to false. + for (Resource resource : GeneratorUtils.getResources(reactors)) { + for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { + if (Objects.equal(action.getOrigin(), ActionOrigin.PHYSICAL)) { + // If the unthreaded runtime is not requested by the user, use the threaded runtime + // instead + // because it is the only one currently capable of handling asynchronous events. + if (!targetConfig.threading + && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = true; + errorReporter.reportWarning( + action, + "Using the threaded C runtime to allow for asynchronous handling of physical action" + + " " + + action.getName()); + return; + } + } + } } - - public CGenerator(LFGeneratorContext context, boolean ccppMode) { - this( - context, - ccppMode, - new CTypes(), - new CCmakeGenerator(context.getFileConfig(), List.of()), - new CDelayBodyGenerator(new CTypes()) - ); + } + + /** + * Return true if the host operating system is compatible and otherwise report an error and return + * false. + */ + protected boolean isOSCompatible() { + if (GeneratorUtils.isHostWindows()) { + if (CCppMode) { + errorReporter.reportError( + "LF programs with a CCpp target are currently not supported on Windows. " + + "Exiting code generation."); + // FIXME: The incompatibility between our C runtime code and the + // Visual Studio compiler is extensive. + return false; + } } - - /** - * Look for physical actions in all resources. - * If found, set threads to be at least one to allow asynchronous schedule calls. - */ - public void accommodatePhysicalActionsIfPresent() { - // If there are any physical actions, ensure the threaded engine is used and that - // keepalive is set to true, unless the user has explicitly set it to false. - for (Resource resource : GeneratorUtils.getResources(reactors)) { - for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { - if (Objects.equal(action.getOrigin(), ActionOrigin.PHYSICAL)) { - // If the unthreaded runtime is not requested by the user, use the threaded runtime instead - // because it is the only one currently capable of handling asynchronous events. - if (!targetConfig.threading && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = true; - errorReporter.reportWarning( - action, - "Using the threaded C runtime to allow for asynchronous handling of physical action " + - action.getName() - ); - return; - } - } - } - } + return true; + } + + /** + * Returns false if watchdogs exist and are unsupported in this context. Otherwise, return true. + * (DEPRECATED) Alternative implemented in GeneratorBase + */ + protected boolean isWatchdogCompatible() { + if (hasWatchdogs() && !targetConfig.threading) { + errorReporter.reportError("Watchdogs are not supported for unthreaded programs."); + return false; } - - /** - * Return true if the host operating system is compatible and - * otherwise report an error and return false. - */ - protected boolean isOSCompatible() { - if (GeneratorUtils.isHostWindows()) { - if (CCppMode) { - errorReporter.reportError( - "LF programs with a CCpp target are currently not supported on Windows. " + - "Exiting code generation." - ); - // FIXME: The incompatibility between our C runtime code and the - // Visual Studio compiler is extensive. - return false; - } - } - return true; + if (hasWatchdogs() && CCppMode) { + // FIXME: check to see if watchdogs work in CCppMode cases + errorReporter.reportError("Watchdogs are not currently supported in the CCpp target."); } + return true; + } + + /** + * Generate C code from the Lingua Franca model contained by the specified resource. This is the + * main entry point for code generation. + * + * @param resource The resource containing the source code. + * @param context The context in which the generator is invoked, including whether it is cancelled + * and whether it is a standalone context + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + super.doGenerate(resource, context); + if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; + if (!isOSCompatible()) return; // Incompatible OS and configuration + // if (!isWatchdogCompatible()) return; - /** Returns false if watchdogs exist and are - * unsupported in this context. - * Otherwise, return true. - * (DEPRECATED) Alternative implemented in GeneratorBase - */ - protected boolean isWatchdogCompatible() { - if (hasWatchdogs() && !targetConfig.threading) { - errorReporter.reportError( - "Watchdogs are not supported for unthreaded programs." - ); - return false; - } - if (hasWatchdogs() && CCppMode) { - //FIXME: check to see if watchdogs work in CCppMode cases - errorReporter.reportError( - "Watchdogs are not currently supported in the CCpp target." - ); - } - return true; - } + // Perform set up that does not generate code + setUpGeneralParameters(); - /** - * Generate C code from the Lingua Franca model contained by the - * specified resource. This is the main entry point for code - * generation. - * @param resource The resource containing the source code. - * @param context The context in which the generator is - * invoked, including whether it is cancelled and - * whether it is a standalone context - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - super.doGenerate(resource, context); - if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; - if (!isOSCompatible()) return; // Incompatible OS and configuration - // if (!isWatchdogCompatible()) return; - - // Perform set up that does not generate code - setUpGeneralParameters(); - - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); - handleProtoFiles(); - - var lfModuleName = fileConfig.name; - generateCodeFor(lfModuleName); - - // Derive target filename from the .lf filename. - var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); - var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; - - try { - - String srcPrefix = targetConfig.platformOptions.platform == Platform.ARDUINO ? "src/" : ""; - - // Copy the core lib - FileUtil.copyDirectoryFromClassPath( - "/lib/c/reactor-c/core", - fileConfig.getSrcGenPath().resolve(srcPrefix + "core"), - true - ); - // Copy the C target files - copyTargetFiles(); - - // For the Zephyr target, copy default config and board files. - if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - FileUtil.copyDirectoryFromClassPath( - "/lib/platform/zephyr/boards", - fileConfig.getSrcGenPath().resolve("boards"), - false - ); - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/prj_lf.conf", - fileConfig.getSrcGenPath().resolve("prj_lf.conf"), - true - ); - - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/Kconfig", - fileConfig.getSrcGenPath().resolve("Kconfig"), - true - ); - } - - // Write the generated code - code.writeToFile(targetFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); + handleProtoFiles(); - // Create docker file. - if (targetConfig.dockerOptions != null && mainDef != null) { - try { - var dockerData = getDockerGenerator(context).generateDockerData(); - dockerData.writeDockerFile(); - (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); - } catch (IOException e) { - throw new RuntimeException("Error while writing Docker files", e); - } - } + var lfModuleName = fileConfig.name; + generateCodeFor(lfModuleName); - // If cmake is requested, generate the CMakeLists.txt - if (targetConfig.platformOptions.platform != Platform.ARDUINO) { - var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; - var cmakeCode = cmakeGenerator.generateCMakeCode( - List.of(cFilename), - lfModuleName, - errorReporter, - CCppMode, - mainDef != null, - cMakeExtras, - targetConfig - ); - try { - cmakeCode.writeToFile(cmakeFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - } else { - try { - FileUtil.arduinoDeleteHelper(fileConfig.getSrcGenPath().resolve("src/"), targetConfig.threading); - FileUtil.relativeIncludeHelper(fileConfig.getSrcGenPath().resolve("src/")); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - - if (!targetConfig.noCompile) { - ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); - arduinoUtil.buildArduino(fileConfig, targetConfig); - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } else { - System.out.println("********"); - System.out.println("To compile your program, run the following command to see information about the board you plugged in:\n\n\tarduino-cli board list\n\nGrab the FQBN and PORT from the command and run the following command in the generated sources directory:\n\n\tarduino-cli compile -b --build-property compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\nTo flash/upload your generated sketch to the board, run the following command in the generated sources directory:\n\n\tarduino-cli upload -b -p \n"); - // System.out.println("For a list of all boards installed on your computer, you can use the following command:\n\n\tarduino-cli board listall\n"); - context.finish( - GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null) - ); - } - GeneratorUtils.refreshProject(resource, context.getMode()); - return; - } + // Derive target filename from the .lf filename. + var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); + var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; - // Dump the additional compile definitions to a file to keep the generated project - // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can - // take over and do the rest of compilation. - try { - String compileDefs = targetConfig.compileDefinitions.keySet().stream() - .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) - .collect(Collectors.joining("\n")); - FileUtil.writeToFile( - compileDefs, - Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt") - ); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + try { - // If this code generator is directly compiling the code, compile it now so that we - // clean it up after, removing the #line directives after errors have been reported. - if ( - !targetConfig.noCompile && targetConfig.dockerOptions == null - && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) - // This code is unreachable in LSP_FAST mode, so that check is omitted. - && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM - ) { - // FIXME: Currently, a lack of main is treated as a request to not produce - // a binary and produce a .o file instead. There should be a way to control - // this. - // Create an anonymous Runnable class and add it to the compileThreadPool - // so that compilation can happen in parallel. - var cleanCode = code.removeLines("#line"); - - var execName = lfModuleName; - var threadFileConfig = fileConfig; - var generator = this; // FIXME: currently only passed to report errors with line numbers in the Eclipse IDE - var CppMode = CCppMode; - // generatingContext.reportProgress( - // String.format("Generated code for %d/%d executables. Compiling...", federateCount, federates.size()), - // 100 * federateCount / federates.size() - // ); // FIXME: Move to FedGenerator - // Create the compiler to be used later - - var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); - try { - if (!cCompiler.runCCompiler(generator, context)) { - // If compilation failed, remove any bin files that may have been created. - CUtil.deleteBinFiles(threadFileConfig); - // If finish has already been called, it is illegal and makes no sense. However, - // if finish has already been called, then this must be a federated execution. - context.unsuccessfulFinish(); - } else { - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } - cleanCode.writeToFile(targetFile); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + String srcPrefix = targetConfig.platformOptions.platform == Platform.ARDUINO ? "src/" : ""; - } + // Copy the core lib + FileUtil.copyDirectoryFromClassPath( + "/lib/c/reactor-c/core", fileConfig.getSrcGenPath().resolve(srcPrefix + "core"), true); + // Copy the C target files + copyTargetFiles(); - // If a build directive has been given, invoke it now. - // Note that the code does not get cleaned in this case. - if (!targetConfig.noCompile) { - if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { - CUtil.runBuildCommand( - fileConfig, - targetConfig, - commandFactory, - errorReporter, - this::reportCommandErrors, - context.getMode() - ); - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } - System.out.println("Compiled binary is in " + fileConfig.binPath); - } else { - context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); - } - - // In case we are in Eclipse, make sure the generated code is visible. - GeneratorUtils.refreshProject(resource, context.getMode()); + // For the Zephyr target, copy default config and board files. + if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + FileUtil.copyDirectoryFromClassPath( + "/lib/platform/zephyr/boards", fileConfig.getSrcGenPath().resolve("boards"), false); + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/prj_lf.conf", + fileConfig.getSrcGenPath().resolve("prj_lf.conf"), + true); + + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath().resolve("Kconfig"), true); + } + + // Write the generated code + code.writeToFile(targetFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); } - private void generateCodeFor( - String lfModuleName - ) { - startTimeStepIsPresentCount = 0; - code.pr(generateDirectives()); - code.pr(generateTopLevelPreambles()); - code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); - // Generate code for each reactor. - generateReactorDefinitions(); - - // Generate main instance, if there is one. - // Note that any main reactors in imported files are ignored. - // Skip generation if there are cycles. - if (main != null) { - initializeTriggerObjects.pr(String.join("\n", - "int _lf_startup_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", - "int _lf_shutdown_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", - "int _lf_reset_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", - "int _lf_timer_triggers_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", - "int bank_index;", - "SUPPRESS_UNUSED_WARNING(bank_index);", - "int _lf_watchdog_number_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_watchdog_number_count);" - )); - // Add counters for modal initialization - initializeTriggerObjects.pr(CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); - - // Create an array of arrays to store all self structs. - // This is needed because connections cannot be established until - // all reactor instances have self structs because ports that - // receive data reference the self structs of the originating - // reactors, which are arbitarily far away in the program graph. - generateSelfStructs(main); - generateReactorInstance(main); - - // If there are timers, create a table of timers to be initialized. - code.pr(CTimerGenerator.generateDeclarations(timerCount)); - - // If there are startup reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); - - // If there are shutdown reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); - - // If there are reset reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); - - // If there are watchdogs, create a table of triggers. - code.pr(CWatchdogGenerator.generateBuiltinTriggersTable(watchdogCount, "watchdog")); - - // If there are modes, create a table of mode state to be checked for transitions. - code.pr(CModesGenerator.generateModeStatesTable( - hasModalReactors, - modalReactorCount, - modalStateResetCount - )); - - // Generate function to initialize the trigger objects for all reactors. - code.pr(CTriggerObjectsGenerator.generateInitializeTriggerObjects( - main, - targetConfig, - initializeTriggerObjects, - startTimeStep, - types, - lfModuleName, - startTimeStepIsPresentCount - )); - - // Generate function to trigger startup reactions for all reactors. - code.pr(CReactionGenerator.generateLfTriggerStartupReactions(startupReactionCount, hasModalReactors)); - - // Generate function to schedule timers for all reactors. - code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); - - // Generate function to initialize mutexes for all reactors with watchdogs. - // needs to be implemented still - code.pr(CWatchdogGenerator.generateLfInitializeWatchdogMutexes(watchdogCount)); - - // Generate a function that will either do nothing - // (if there is only one federate or the coordination - // is set to decentralized) or, if there are - // downstream federates, will notify the RTI - // that the specified logical time is complete. - if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) code.pr("extern \"C\""); - code.pr(String.join("\n", - "void logical_tag_complete(tag_t tag_to_send) {", - CExtensionUtils.surroundWithIfFederatedCentralized( - " _lf_logical_tag_complete(tag_to_send);" - ), - "}" - )); - - // Generate function to schedule shutdown reactions if any - // reactors have reactions to shutdown. - code.pr(CReactionGenerator.generateLfTriggerShutdownReactions(shutdownReactionCount, hasModalReactors)); - - // Generate an empty termination function for non-federated - // execution. For federated execution, an implementation is - // provided in federate.c. That implementation will resign - // from the federation and close any open sockets. - code.pr(""" - #ifndef FEDERATED - void terminate_execution() {} - #endif""" - ); - - - // Generate functions for modes - code.pr(CModesGenerator.generateLfInitializeModes( - hasModalReactors - )); - code.pr(CModesGenerator.generateLfHandleModeChanges( - hasModalReactors, - modalStateResetCount - )); - code.pr(CReactionGenerator.generateLfModeTriggeredReactions( - startupReactionCount, - resetReactionCount, - hasModalReactors - )); - } + // Create docker file. + if (targetConfig.dockerOptions != null && mainDef != null) { + try { + var dockerData = getDockerGenerator(context).generateDockerData(); + dockerData.writeDockerFile(); + (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); + } catch (IOException e) { + throw new RuntimeException("Error while writing Docker files", e); + } } - @Override - public void checkModalReactorSupport(boolean __) { - // Modal reactors are currently only supported for non federated applications - super.checkModalReactorSupport(true); + // If cmake is requested, generate the CMakeLists.txt + if (targetConfig.platformOptions.platform != Platform.ARDUINO) { + var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; + var cmakeCode = + cmakeGenerator.generateCMakeCode( + List.of(cFilename), + lfModuleName, + errorReporter, + CCppMode, + mainDef != null, + cMakeExtras, + targetConfig); + try { + cmakeCode.writeToFile(cmakeFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + } else { + try { + FileUtil.arduinoDeleteHelper( + fileConfig.getSrcGenPath().resolve("src/"), targetConfig.threading); + FileUtil.relativeIncludeHelper(fileConfig.getSrcGenPath().resolve("src/")); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + + if (!targetConfig.noCompile) { + ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); + arduinoUtil.buildArduino(fileConfig, targetConfig); + context.finish(GeneratorResult.Status.COMPILED, null); + } else { + System.out.println("********"); + System.out.println( + "To compile your program, run the following command to see information about the board" + + " you plugged in:\n\n" + + "\tarduino-cli board list\n\n" + + "Grab the FQBN and PORT from the command and run the following command in the" + + " generated sources directory:\n\n" + + "\tarduino-cli compile -b --build-property" + + " compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" + + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property" + + " compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" + + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\n" + + "To flash/upload your generated sketch to the board, run the following command in" + + " the generated sources directory:\n\n" + + "\tarduino-cli upload -b -p \n"); + // System.out.println("For a list of all boards installed on your computer, you can use the + // following command:\n\n\tarduino-cli board listall\n"); + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + } + GeneratorUtils.refreshProject(resource, context.getMode()); + return; } - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - return String.join("\n", - "// Generated forwarding reaction for connections with the same destination", - "// but located in mutually exclusive modes.", - "lf_set("+dest+", "+source+"->value);" - ); + // Dump the additional compile definitions to a file to keep the generated project + // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can + // take over and do the rest of compilation. + try { + String compileDefs = + targetConfig.compileDefinitions.keySet().stream() + .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) + .collect(Collectors.joining("\n")); + FileUtil.writeToFile( + compileDefs, + Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt")); + } catch (IOException e) { + Exceptions.sneakyThrow(e); } - /** Set the scheduler type in the target config as needed. */ - private void pickScheduler() { - // Don't use a scheduler that does not prioritize reactions based on deadlines - // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. - if (!targetConfig.schedulerType.prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - if (hasDeadlines(reactors)) { - if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { - targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; - } - } + // If this code generator is directly compiling the code, compile it now so that we + // clean it up after, removing the #line directives after errors have been reported. + if (!targetConfig.noCompile + && targetConfig.dockerOptions == null + && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) + // This code is unreachable in LSP_FAST mode, so that check is omitted. + && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM) { + // FIXME: Currently, a lack of main is treated as a request to not produce + // a binary and produce a .o file instead. There should be a way to control + // this. + // Create an anonymous Runnable class and add it to the compileThreadPool + // so that compilation can happen in parallel. + var cleanCode = code.removeLines("#line"); + + var execName = lfModuleName; + var threadFileConfig = fileConfig; + var generator = + this; // FIXME: currently only passed to report errors with line numbers in the Eclipse + // IDE + var CppMode = CCppMode; + // generatingContext.reportProgress( + // String.format("Generated code for %d/%d executables. Compiling...", federateCount, + // federates.size()), + // 100 * federateCount / federates.size() + // ); // FIXME: Move to FedGenerator + // Create the compiler to be used later + + var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); + try { + if (!cCompiler.runCCompiler(generator, context)) { + // If compilation failed, remove any bin files that may have been created. + CUtil.deleteBinFiles(threadFileConfig); + // If finish has already been called, it is illegal and makes no sense. However, + // if finish has already been called, then this must be a federated execution. + context.unsuccessfulFinish(); + } else { + context.finish(GeneratorResult.Status.COMPILED, null); } + cleanCode.writeToFile(targetFile); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } } - private boolean hasDeadlines(List reactors) { - for (Reactor reactor : reactors) { - for (Reaction reaction : allReactions(reactor)) { - if (reaction.getDeadline() != null) { - return true; - } - } - } - return false; + // If a build directive has been given, invoke it now. + // Note that the code does not get cleaned in this case. + if (!targetConfig.noCompile) { + if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { + CUtil.runBuildCommand( + fileConfig, + targetConfig, + commandFactory, + errorReporter, + this::reportCommandErrors, + context.getMode()); + context.finish(GeneratorResult.Status.COMPILED, null); + } + System.out.println("Compiled binary is in " + fileConfig.binPath); + } else { + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); } - private boolean hasWatchdogs() { - for (Reactor reactor : reactors) { - List watchdogs = ASTUtils.allWatchdogs(reactor); - if (watchdogs != null && !watchdogs.isEmpty()) { - return true; - } - } - return false; + // In case we are in Eclipse, make sure the generated code is visible. + GeneratorUtils.refreshProject(resource, context.getMode()); + } + + private void generateCodeFor(String lfModuleName) { + startTimeStepIsPresentCount = 0; + code.pr(generateDirectives()); + code.pr(generateTopLevelPreambles()); + code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); + // Generate code for each reactor. + generateReactorDefinitions(); + + // Generate main instance, if there is one. + // Note that any main reactors in imported files are ignored. + // Skip generation if there are cycles. + if (main != null) { + initializeTriggerObjects.pr( + String.join( + "\n", + "int _lf_startup_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", + "int _lf_shutdown_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", + "int _lf_reset_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", + "int _lf_timer_triggers_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", + "int bank_index;", + "SUPPRESS_UNUSED_WARNING(bank_index);", + "int _lf_watchdog_number_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_watchdog_number_count);")); + // Add counters for modal initialization + initializeTriggerObjects.pr( + CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); + + // Create an array of arrays to store all self structs. + // This is needed because connections cannot be established until + // all reactor instances have self structs because ports that + // receive data reference the self structs of the originating + // reactors, which are arbitarily far away in the program graph. + generateSelfStructs(main); + generateReactorInstance(main); + + // If there are timers, create a table of timers to be initialized. + code.pr(CTimerGenerator.generateDeclarations(timerCount)); + + // If there are startup reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); + + // If there are shutdown reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); + + // If there are reset reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); + + // If there are watchdogs, create a table of triggers. + code.pr(CWatchdogGenerator.generateBuiltinTriggersTable(watchdogCount, "watchdog")); + + // If there are modes, create a table of mode state to be checked for transitions. + code.pr( + CModesGenerator.generateModeStatesTable( + hasModalReactors, modalReactorCount, modalStateResetCount)); + + // Generate function to initialize the trigger objects for all reactors. + code.pr( + CTriggerObjectsGenerator.generateInitializeTriggerObjects( + main, + targetConfig, + initializeTriggerObjects, + startTimeStep, + types, + lfModuleName, + startTimeStepIsPresentCount)); + + // Generate function to trigger startup reactions for all reactors. + code.pr( + CReactionGenerator.generateLfTriggerStartupReactions( + startupReactionCount, hasModalReactors)); + + // Generate function to schedule timers for all reactors. + code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); + + // Generate function to initialize mutexes for all reactors with watchdogs. + // needs to be implemented still + code.pr(CWatchdogGenerator.generateLfInitializeWatchdogMutexes(watchdogCount)); + + // Generate a function that will either do nothing + // (if there is only one federate or the coordination + // is set to decentralized) or, if there are + // downstream federates, will notify the RTI + // that the specified logical time is complete. + if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) + code.pr("extern \"C\""); + code.pr( + String.join( + "\n", + "void logical_tag_complete(tag_t tag_to_send) {", + CExtensionUtils.surroundWithIfFederatedCentralized( + " _lf_logical_tag_complete(tag_to_send);"), + "}")); + + // Generate function to schedule shutdown reactions if any + // reactors have reactions to shutdown. + code.pr( + CReactionGenerator.generateLfTriggerShutdownReactions( + shutdownReactionCount, hasModalReactors)); + + // Generate an empty termination function for non-federated + // execution. For federated execution, an implementation is + // provided in federate.c. That implementation will resign + // from the federation and close any open sockets. + code.pr( + """ + #ifndef FEDERATED + void terminate_execution() {} + #endif"""); + + // Generate functions for modes + code.pr(CModesGenerator.generateLfInitializeModes(hasModalReactors)); + code.pr(CModesGenerator.generateLfHandleModeChanges(hasModalReactors, modalStateResetCount)); + code.pr( + CReactionGenerator.generateLfModeTriggeredReactions( + startupReactionCount, resetReactionCount, hasModalReactors)); } - - /** - * Look at the 'reactor' eResource. - * If it is an imported .lf file, incorporate it into the current - * program in the following manner: - * - Merge its target property with `targetConfig` - * - If there are any preambles, add them to the preambles of the reactor. - */ - private void inspectReactorEResource(ReactorDecl reactor) { - // If the reactor is imported, look at the - // target definition of the .lf file in which the reactor is imported from and - // append any cmake-include. - // Check if the reactor definition is imported - if (reactor.eResource() != mainDef.getReactorClass().eResource()) { - // Find the LFResource corresponding to this eResource - LFResource lfResource = null; - for (var resource : resources) { - if (resource.getEResource() == reactor.eResource()) { - lfResource = resource; - break; - } - } - // Copy the user files and cmake-includes to the src-gen path of the main .lf file - if (lfResource != null) { - copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); - } - // Extract the contents of the imported file for the preambles - var contents = toDefinition(reactor).eResource().getContents(); - var model = (Model) contents.get(0); - // Add the preambles from the imported .lf file - toDefinition(reactor).getPreambles().addAll(model.getPreambles()); + } + + @Override + public void checkModalReactorSupport(boolean __) { + // Modal reactors are currently only supported for non federated applications + super.checkModalReactorSupport(true); + } + + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + return String.join( + "\n", + "// Generated forwarding reaction for connections with the same destination", + "// but located in mutually exclusive modes.", + "lf_set(" + dest + ", " + source + "->value);"); + } + + /** Set the scheduler type in the target config as needed. */ + private void pickScheduler() { + // Don't use a scheduler that does not prioritize reactions based on deadlines + // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. + if (!targetConfig.schedulerType.prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + if (hasDeadlines(reactors)) { + if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { + targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; } + } } + } - /** - * Copy all files or directories listed in the target property `files`, `cmake-include`, - * and `_fed_setup` into the src-gen folder of the main .lf file - * - * @param targetConfig The targetConfig to read the target properties from. - * @param fileConfig The fileConfig used to make the copy and resolve paths. - */ - @Override - public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - super.copyUserFiles(targetConfig, fileConfig); - // Make sure the target directory exists. - var targetDir = this.fileConfig.getSrcGenPath(); - try { - Files.createDirectories(targetDir); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - - for (String filename : targetConfig.fileNames) { - var relativeFileName = CUtil.copyFileOrResource( - filename, - fileConfig.srcFile.getParent(), - targetDir); - if (StringExtensions.isNullOrEmpty(relativeFileName)) { - errorReporter.reportError( - "Failed to find file " + filename + " specified in the" + - " files target property." - ); - } else { - targetConfig.filesNamesWithoutPath.add( - relativeFileName - ); - } - } - - for (String filename : targetConfig.cmakeIncludes) { - var relativeCMakeIncludeFileName = - CUtil.copyFileOrResource( - filename, - fileConfig.srcFile.getParent(), - targetDir); - // Check if the file exists - if (StringExtensions.isNullOrEmpty(relativeCMakeIncludeFileName)) { - errorReporter.reportError( - "Failed to find cmake-include file " + filename - ); - } else { - this.targetConfig.cmakeIncludesWithoutPath.add( - relativeCMakeIncludeFileName - ); - } - } - - if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { - try { - FileUtil.copyFile(fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), - targetDir.resolve(targetConfig.fedSetupPreamble)); - } catch (IOException e) { - errorReporter.reportError("Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); - } + private boolean hasDeadlines(List reactors) { + for (Reactor reactor : reactors) { + for (Reaction reaction : allReactions(reactor)) { + if (reaction.getDeadline() != null) { + return true; } + } } + return false; + } - /** - * Generate code for defining all reactors that belong to the federate, - * including all the child reactors down the hierarchy. Duplicate - * Duplicates are avoided. - * - * Imported reactors' original .lf file is - * incorporated in the following manner: - * - If there are any cmake-include files, add them to the current list - * of cmake-include files. - * - If there are any preambles, add them to the preambles of the reactor. - */ - private void generateReactorDefinitions() { - var generatedReactorDecls = new LinkedHashSet(); - if (this.main != null) { - generateReactorChildren(this.main, generatedReactorDecls); - } - - if (this.mainDef != null) { - generateReactorClass(this.mainDef.getReactorClass()); - } - - if (mainDef == null) { - // Generate code for each reactor that was not instantiated in main or its children. - for (Reactor r : reactors) { - // Get the declarations for reactors that are instantiated somewhere. - // A declaration is either a reactor definition or an import statement.; - var declarations = this.instantiationGraph.getDeclarations(r); - // If the reactor has no instantiations and there is no main reactor, then - // generate code for it anyway (at a minimum, this means that the compiler is invoked - // so that reaction bodies are checked). - if (declarations.isEmpty()) { - generateReactorClass(r); - } - } - } + private boolean hasWatchdogs() { + for (Reactor reactor : reactors) { + List watchdogs = ASTUtils.allWatchdogs(reactor); + if (watchdogs != null && !watchdogs.isEmpty()) { + return true; + } } - - /** - * Generate code for the children of 'reactor' that belong to 'federate'. - * Duplicates are avoided. - * - * Imported reactors' original .lf file is - * incorporated in the following manner: - * - If there are any cmake-include files, add them to the current list - * of cmake-include files. - * - If there are any preambles, add them to the preambles of the reactor. - * - * @param reactor Used to extract children from - */ - private void generateReactorChildren( - ReactorInstance reactor, - LinkedHashSet generatedReactorDecls - ) { - for (ReactorInstance r : reactor.children) { - if (r.reactorDeclaration != null && - !generatedReactorDecls.contains(r.reactorDeclaration)) { - generatedReactorDecls.add(r.reactorDeclaration); - generateReactorChildren(r, generatedReactorDecls); - inspectReactorEResource(r.reactorDeclaration); - generateReactorClass(r.reactorDeclaration); - } + return false; + } + + /** + * Look at the 'reactor' eResource. If it is an imported .lf file, incorporate it into the current + * program in the following manner: - Merge its target property with `targetConfig` - If there are + * any preambles, add them to the preambles of the reactor. + */ + private void inspectReactorEResource(ReactorDecl reactor) { + // If the reactor is imported, look at the + // target definition of the .lf file in which the reactor is imported from and + // append any cmake-include. + // Check if the reactor definition is imported + if (reactor.eResource() != mainDef.getReactorClass().eResource()) { + // Find the LFResource corresponding to this eResource + LFResource lfResource = null; + for (var resource : resources) { + if (resource.getEResource() == reactor.eResource()) { + lfResource = resource; + break; } + } + // Copy the user files and cmake-includes to the src-gen path of the main .lf file + if (lfResource != null) { + copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); + } + // Extract the contents of the imported file for the preambles + var contents = toDefinition(reactor).eResource().getContents(); + var model = (Model) contents.get(0); + // Add the preambles from the imported .lf file + toDefinition(reactor).getPreambles().addAll(model.getPreambles()); } - - /** - * Choose which platform files to compile with according to the OS. - * If there is no main reactor, then compilation will produce a .o file requiring further linking. - * Also, if useCmake is set to true, we don't need to add platform files. The CMakeLists.txt file - * will detect and use the appropriate platform file based on the platform that cmake is invoked on. - */ - private void pickCompilePlatform() { - var osName = System.getProperty("os.name").toLowerCase(); - // if platform target was set, use given platform instead - if (targetConfig.platformOptions.platform != Platform.AUTO) { - osName = targetConfig.platformOptions.platform.toString(); - } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { - errorReporter.reportError("Platform " + osName + " is not supported"); - } + } + + /** + * Copy all files or directories listed in the target property `files`, `cmake-include`, and + * `_fed_setup` into the src-gen folder of the main .lf file + * + * @param targetConfig The targetConfig to read the target properties from. + * @param fileConfig The fileConfig used to make the copy and resolve paths. + */ + @Override + public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + super.copyUserFiles(targetConfig, fileConfig); + // Make sure the target directory exists. + var targetDir = this.fileConfig.getSrcGenPath(); + try { + Files.createDirectories(targetDir); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); } - - /** - * Copy target-specific header file to the src-gen directory. - */ - protected void copyTargetFiles() throws IOException { - - String srcPrefix = targetConfig.platformOptions.platform == Platform.ARDUINO ? "src/" : ""; - - FileUtil.copyDirectoryFromClassPath( - "/lib/c/reactor-c/include", - fileConfig.getSrcGenPath().resolve(srcPrefix + "include"), - false - ); - FileUtil.copyDirectoryFromClassPath( - "/lib/c/reactor-c/lib", - fileConfig.getSrcGenPath().resolve(srcPrefix + "lib"), - false - ); + for (String filename : targetConfig.fileNames) { + var relativeFileName = + CUtil.copyFileOrResource(filename, fileConfig.srcFile.getParent(), targetDir); + if (StringExtensions.isNullOrEmpty(relativeFileName)) { + errorReporter.reportError( + "Failed to find file " + filename + " specified in the" + " files target property."); + } else { + targetConfig.filesNamesWithoutPath.add(relativeFileName); + } } - //////////////////////////////////////////// - //// Code generators. - /** - * Generate a reactor class definition for the specified federate. - * A class definition has four parts: - * - * * Preamble code, if any, specified in the Lingua Franca file. - * * A "self" struct type definition (see the class documentation above). - * * A function for each reaction. - * * A constructor for creating an instance. - * for deleting an instance. - * - * If the reactor is the main reactor, then - * the generated code may be customized. Specifically, - * if the main reactor has reactions, these reactions - * will not be generated if they are triggered by or send - * data to contained reactors that are not in the federate. - * @param reactor The parsed reactor data structure. - */ - private void generateReactorClass(ReactorDecl reactor) { - // FIXME: Currently we're not reusing definitions for declarations that point to the same definition. - - Reactor defn = ASTUtils.toDefinition(reactor); - - if (reactor instanceof Reactor) { - code.pr("// =============== START reactor class " + reactor.getName()); - } else { - code.pr("// =============== START reactor class " + defn.getName() + " as " + reactor.getName()); - } - - // Preamble code contains state declarations with static initializers. - generateUserPreamblesForReactor(defn); - - // Some of the following methods create lines of code that need to - // go into the constructor. Collect those lines of code here: - var constructorCode = new CodeBuilder(); - generateAuxiliaryStructs(reactor); - generateSelfStruct(reactor, constructorCode); - generateMethods(reactor); - - generateWatchdogs(reactor); - generateReactions(reactor); - generateConstructor(reactor, constructorCode); + for (String filename : targetConfig.cmakeIncludes) { + var relativeCMakeIncludeFileName = + CUtil.copyFileOrResource(filename, fileConfig.srcFile.getParent(), targetDir); + // Check if the file exists + if (StringExtensions.isNullOrEmpty(relativeCMakeIncludeFileName)) { + errorReporter.reportError("Failed to find cmake-include file " + filename); + } else { + this.targetConfig.cmakeIncludesWithoutPath.add(relativeCMakeIncludeFileName); + } + } - code.pr("// =============== END reactor class " + reactor.getName()); - code.pr(""); + if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { + try { + FileUtil.copyFile( + fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), + targetDir.resolve(targetConfig.fedSetupPreamble)); + } catch (IOException e) { + errorReporter.reportError( + "Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); + } + } + } + + /** + * Generate code for defining all reactors that belong to the federate, including all the child + * reactors down the hierarchy. Duplicate Duplicates are avoided. + * + *

Imported reactors' original .lf file is incorporated in the following manner: - If there are + * any cmake-include files, add them to the current list of cmake-include files. - If there are + * any preambles, add them to the preambles of the reactor. + */ + private void generateReactorDefinitions() { + var generatedReactorDecls = new LinkedHashSet(); + if (this.main != null) { + generateReactorChildren(this.main, generatedReactorDecls); } - /** - * Generate methods for {@code reactor}. - */ - protected void generateMethods(ReactorDecl reactor) { - CMethodGenerator.generateMethods(reactor, code, types); + if (this.mainDef != null) { + generateReactorClass(this.mainDef.getReactorClass()); } - /** - * Generates preambles defined by user for a given reactor - * @param reactor The given reactor - */ - protected void generateUserPreamblesForReactor(Reactor reactor) { - for (Preamble p : convertToEmptyListIfNull(reactor.getPreambles())) { - code.pr("// *********** From the preamble, verbatim:"); - code.prSourceLineNumber(p.getCode()); - code.pr(toText(p.getCode())); - code.pr("\n// *********** End of preamble."); + if (mainDef == null) { + // Generate code for each reactor that was not instantiated in main or its children. + for (Reactor r : reactors) { + // Get the declarations for reactors that are instantiated somewhere. + // A declaration is either a reactor definition or an import statement.; + var declarations = this.instantiationGraph.getDeclarations(r); + // If the reactor has no instantiations and there is no main reactor, then + // generate code for it anyway (at a minimum, this means that the compiler is invoked + // so that reaction bodies are checked). + if (declarations.isEmpty()) { + generateReactorClass(r); } + } } - - /** - * Generate a constructor for the specified reactor in the specified federate. - * @param reactor The parsed reactor data structure. - * @param constructorCode Lines of code previously generated that need to - * go into the constructor. - */ - protected void generateConstructor( - ReactorDecl reactor, CodeBuilder constructorCode - ) { - code.pr(CConstructorGenerator.generateConstructor( - reactor, - constructorCode.toString() - )); + } + + /** + * Generate code for the children of 'reactor' that belong to 'federate'. Duplicates are avoided. + * + *

Imported reactors' original .lf file is incorporated in the following manner: - If there are + * any cmake-include files, add them to the current list of cmake-include files. - If there are + * any preambles, add them to the preambles of the reactor. + * + * @param reactor Used to extract children from + */ + private void generateReactorChildren( + ReactorInstance reactor, LinkedHashSet generatedReactorDecls) { + for (ReactorInstance r : reactor.children) { + if (r.reactorDeclaration != null && !generatedReactorDecls.contains(r.reactorDeclaration)) { + generatedReactorDecls.add(r.reactorDeclaration); + generateReactorChildren(r, generatedReactorDecls); + inspectReactorEResource(r.reactorDeclaration); + generateReactorClass(r.reactorDeclaration); + } + } + } + + /** + * Choose which platform files to compile with according to the OS. If there is no main reactor, + * then compilation will produce a .o file requiring further linking. Also, if useCmake is set to + * true, we don't need to add platform files. The CMakeLists.txt file will detect and use the + * appropriate platform file based on the platform that cmake is invoked on. + */ + private void pickCompilePlatform() { + var osName = System.getProperty("os.name").toLowerCase(); + // if platform target was set, use given platform instead + if (targetConfig.platformOptions.platform != Platform.AUTO) { + osName = targetConfig.platformOptions.platform.toString(); + } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { + errorReporter.reportError("Platform " + osName + " is not supported"); + } + } + + /** Copy target-specific header file to the src-gen directory. */ + protected void copyTargetFiles() throws IOException { + + String srcPrefix = targetConfig.platformOptions.platform == Platform.ARDUINO ? "src/" : ""; + + FileUtil.copyDirectoryFromClassPath( + "/lib/c/reactor-c/include", + fileConfig.getSrcGenPath().resolve(srcPrefix + "include"), + false); + FileUtil.copyDirectoryFromClassPath( + "/lib/c/reactor-c/lib", fileConfig.getSrcGenPath().resolve(srcPrefix + "lib"), false); + } + + //////////////////////////////////////////// + //// Code generators. + /** + * Generate a reactor class definition for the specified federate. A class definition has four + * parts: + * + *

* Preamble code, if any, specified in the Lingua Franca file. * A "self" struct type + * definition (see the class documentation above). * A function for each reaction. * A constructor + * for creating an instance. for deleting an instance. + * + *

If the reactor is the main reactor, then the generated code may be customized. Specifically, + * if the main reactor has reactions, these reactions will not be generated if they are triggered + * by or send data to contained reactors that are not in the federate. + * + * @param reactor The parsed reactor data structure. + */ + private void generateReactorClass(ReactorDecl reactor) { + // FIXME: Currently we're not reusing definitions for declarations that point to the same + // definition. + + Reactor defn = ASTUtils.toDefinition(reactor); + + if (reactor instanceof Reactor) { + code.pr("// =============== START reactor class " + reactor.getName()); + } else { + code.pr( + "// =============== START reactor class " + defn.getName() + " as " + reactor.getName()); } - /** - * Generate the struct type definitions for inputs, outputs, and - * actions of the specified reactor. - * @param decl The parsed reactor data structure. - */ - protected void generateAuxiliaryStructs(ReactorDecl decl) { - var reactor = ASTUtils.toDefinition(decl); - // In the case where there are incoming - // p2p logical connections in decentralized - // federated execution, there will be an - // intended_tag field added to accommodate - // the case where a reaction triggered by a - // port or action is late due to network - // latency, etc.. - var federatedExtension = new CodeBuilder(); - federatedExtension.pr(""" + // Preamble code contains state declarations with static initializers. + generateUserPreamblesForReactor(defn); + + // Some of the following methods create lines of code that need to + // go into the constructor. Collect those lines of code here: + var constructorCode = new CodeBuilder(); + generateAuxiliaryStructs(reactor); + generateSelfStruct(reactor, constructorCode); + generateMethods(reactor); + + generateWatchdogs(reactor); + generateReactions(reactor); + generateConstructor(reactor, constructorCode); + + code.pr("// =============== END reactor class " + reactor.getName()); + code.pr(""); + } + + /** Generate methods for {@code reactor}. */ + protected void generateMethods(ReactorDecl reactor) { + CMethodGenerator.generateMethods(reactor, code, types); + } + + /** + * Generates preambles defined by user for a given reactor + * + * @param reactor The given reactor + */ + protected void generateUserPreamblesForReactor(Reactor reactor) { + for (Preamble p : convertToEmptyListIfNull(reactor.getPreambles())) { + code.pr("// *********** From the preamble, verbatim:"); + code.prSourceLineNumber(p.getCode()); + code.pr(toText(p.getCode())); + code.pr("\n// *********** End of preamble."); + } + } + + /** + * Generate a constructor for the specified reactor in the specified federate. + * + * @param reactor The parsed reactor data structure. + * @param constructorCode Lines of code previously generated that need to go into the constructor. + */ + protected void generateConstructor(ReactorDecl reactor, CodeBuilder constructorCode) { + code.pr(CConstructorGenerator.generateConstructor(reactor, constructorCode.toString())); + } + + /** + * Generate the struct type definitions for inputs, outputs, and actions of the specified reactor. + * + * @param decl The parsed reactor data structure. + */ + protected void generateAuxiliaryStructs(ReactorDecl decl) { + var reactor = ASTUtils.toDefinition(decl); + // In the case where there are incoming + // p2p logical connections in decentralized + // federated execution, there will be an + // intended_tag field added to accommodate + // the case where a reaction triggered by a + // port or action is late due to network + // latency, etc.. + var federatedExtension = new CodeBuilder(); + federatedExtension.pr( + """ #ifdef FEDERATED #ifdef FEDERATED_DECENTRALIZED %s intended_tag; #endif %s physical_time_of_arrival; #endif - """.formatted(types.getTargetTagType(), types.getTargetTimeType()) - ); - // First, handle inputs. - for (Input input : allInputs(reactor)) { - code.pr(CPortGenerator.generateAuxiliaryStruct( - decl, - input, - getTarget(), - errorReporter, - types, - federatedExtension - )); - } - // Next, handle outputs. - for (Output output : allOutputs(reactor)) { - code.pr(CPortGenerator.generateAuxiliaryStruct( - decl, - output, - getTarget(), - errorReporter, - types, - federatedExtension - )); - } - // Finally, handle actions. - // The very first item on this struct needs to be - // a trigger_t* because the struct will be cast to (trigger_t*) - // by the lf_schedule() functions to get to the trigger. - for (Action action : allActions(reactor)) { - code.pr(CActionGenerator.generateAuxiliaryStruct( - decl, - action, - getTarget(), - types, - federatedExtension - )); - } + """ + .formatted(types.getTargetTagType(), types.getTargetTimeType())); + // First, handle inputs. + for (Input input : allInputs(reactor)) { + code.pr( + CPortGenerator.generateAuxiliaryStruct( + decl, input, getTarget(), errorReporter, types, federatedExtension)); } - - /** - * Generate the self struct type definition for the specified reactor - * in the specified federate. - * @param decl The parsed reactor data structure. - * @param constructorCode Place to put lines of code that need to - * go into the constructor. - */ - private void generateSelfStruct(ReactorDecl decl, CodeBuilder constructorCode) { - var reactor = toDefinition(decl); - var selfType = CUtil.selfType(decl); - - // Construct the typedef for the "self" struct. - // Create a type name for the self struct. - var body = new CodeBuilder(); - - // Extensions can add functionality to the CGenerator - generateSelfStructExtension(body, decl, constructorCode); - - // Next handle parameters. - body.pr(CParameterGenerator.generateDeclarations(reactor, types)); - - // Next handle states. - body.pr(CStateGenerator.generateDeclarations(reactor, types)); - - // Next handle actions. - CActionGenerator.generateDeclarations(reactor, decl, body, constructorCode); - - // Next handle inputs and outputs. - CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); - - // If there are contained reactors that either receive inputs - // from reactions of this reactor or produce outputs that trigger - // reactions of this reactor, then we need to create a struct - // inside the self struct for each contained reactor. That - // struct has a place to hold the data produced by this reactor's - // reactions and a place to put pointers to data produced by - // the contained reactors. - generateInteractingContainedReactors(reactor, body, constructorCode); - - // Next, generate the fields needed for each reaction. - CReactionGenerator.generateReactionAndTriggerStructs( - body, - decl, - constructorCode, - types - ); - - // Generate the fields needed for each watchdog. - CWatchdogGenerator.generateWatchdogStruct( - body, - decl, - constructorCode - ); - - // Next, generate fields for modes - CModesGenerator.generateDeclarations(reactor, body, constructorCode); - - // constructorCode.pr(reactor, String.join("\n", - // "#ifdef LF_THREADED", - // " self->base->watchdog_mutex = NULL;", - // "#endif")); - - // The first field has to always be a pointer to the list of - // of allocated memory that must be freed when the reactor is freed. - // This means that the struct can be safely cast to self_base_t. - code.pr("typedef struct {"); - code.indent(); - code.pr("struct self_base_t base;"); - code.pr(body.toString()); - code.unindent(); - code.pr("} " + selfType + ";"); + // Next, handle outputs. + for (Output output : allOutputs(reactor)) { + code.pr( + CPortGenerator.generateAuxiliaryStruct( + decl, output, getTarget(), errorReporter, types, federatedExtension)); } - - /** - * Generate structs and associated code for contained reactors that - * send or receive data to or from the container's reactions. - * - * If there are contained reactors that either receive inputs - * from reactions of this reactor or produce outputs that trigger - * reactions of this reactor, then we need to create a struct - * inside the self struct of the container for each contained reactor. - * That struct has a place to hold the data produced by the container reactor's - * reactions and a place to put pointers to data produced by - * the contained reactors. - * - * @param reactor The reactor. - * @param body The place to put the struct definition for the contained reactors. - * @param constructorCode The place to put matching code that goes in the container's constructor. - */ - private void generateInteractingContainedReactors( - Reactor reactor, - CodeBuilder body, - CodeBuilder constructorCode - ) { - // The contents of the struct will be collected first so that - // we avoid duplicate entries and then the struct will be constructed. - var contained = new InteractingContainedReactors(reactor); - // Next generate the relevant code. - for (Instantiation containedReactor : contained.containedReactors()) { - // First define an _width variable in case it is a bank. - var array = ""; - var width = -2; - // If the instantiation is a bank, find the maximum bank width - // to define an array. - if (containedReactor.getWidthSpec() != null) { - width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); - array = "[" + width + "]"; - } - // NOTE: The following needs to be done for each instance - // so that the width can be parameter, not in the constructor. - // Here, we conservatively use a width that is the largest of all isntances. - constructorCode.pr(String.join("\n", - "// Set the _width variable for all cases. This will be -2", - "// if the reactor is not a bank of reactors.", - "self->_lf_"+containedReactor.getName()+"_width = "+width+";" - )); - - // Generate one struct for each contained reactor that interacts. - body.pr("struct {"); - body.indent(); - for (Port port : contained.portsOfInstance(containedReactor)) { - if (port instanceof Input) { - // If the variable is a multiport, then the place to store the data has - // to be malloc'd at initialization. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr(port, variableStructType(port, containedReactor.getReactorClass())+" "+port.getName()+";"); - } else { - // Is a multiport. - // Memory will be malloc'd in initialization. - body.pr(port, String.join("\n", - variableStructType(port, containedReactor.getReactorClass())+"** "+port.getName()+";", - "int "+port.getName()+"_width;" - )); - } - } else { - // Must be an output port. - // Outputs of contained reactors are pointers to the source of data on the - // self struct of the container. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr(port, variableStructType(port, containedReactor.getReactorClass())+"* "+port.getName()+";"); - } else { - // Is a multiport. - // Here, we will use an array of pointers. - // Memory will be malloc'd in initialization. - body.pr(port, String.join("\n", - variableStructType(port, containedReactor.getReactorClass())+"** "+port.getName()+";", - "int "+port.getName()+"_width;" - )); - } - body.pr(port, "trigger_t "+port.getName()+"_trigger;"); - var reactorIndex = ""; - if (containedReactor.getWidthSpec() != null) { - reactorIndex = "[reactor_index]"; - constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactor.getName()+"_width; reactor_index++) {"); - constructorCode.indent(); - } - var portOnSelf = "self->_lf_"+containedReactor.getName()+reactorIndex+"."+port.getName(); - - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederatedDecentralized( - portOnSelf+"_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};" - ) - ); - - var triggered = contained.reactionsTriggered(containedReactor, port); - //noinspection StatementWithEmptyBody - if (triggered.size() > 0) { - body.pr(port, "reaction_t* "+port.getName()+"_reactions["+triggered.size()+"];"); - var triggeredCount = 0; - for (Integer index : triggered) { - constructorCode.pr(port, portOnSelf+"_reactions["+triggeredCount+++"] = &self->_lf__reaction_"+index+";"); - } - constructorCode.pr(port, portOnSelf+"_trigger.reactions = "+portOnSelf+"_reactions;"); - } else { - // Since the self struct is created using calloc, there is no need to set - // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL - } - // Since the self struct is created using calloc, there is no need to set falsy fields. - constructorCode.pr(port, String.join("\n", - portOnSelf+"_trigger.last = NULL;", - portOnSelf+"_trigger.number_of_reactions = "+triggered.size()+";" - )); - - - // Set the physical_time_of_arrival - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederated( - portOnSelf+"_trigger.physical_time_of_arrival = NEVER;" - ) - ); - - if (containedReactor.getWidthSpec() != null) { - constructorCode.unindent(); - constructorCode.pr("}"); - } - } + // Finally, handle actions. + // The very first item on this struct needs to be + // a trigger_t* because the struct will be cast to (trigger_t*) + // by the lf_schedule() functions to get to the trigger. + for (Action action : allActions(reactor)) { + code.pr( + CActionGenerator.generateAuxiliaryStruct( + decl, action, getTarget(), types, federatedExtension)); + } + } + + /** + * Generate the self struct type definition for the specified reactor in the specified federate. + * + * @param decl The parsed reactor data structure. + * @param constructorCode Place to put lines of code that need to go into the constructor. + */ + private void generateSelfStruct(ReactorDecl decl, CodeBuilder constructorCode) { + var reactor = toDefinition(decl); + var selfType = CUtil.selfType(decl); + + // Construct the typedef for the "self" struct. + // Create a type name for the self struct. + var body = new CodeBuilder(); + + // Extensions can add functionality to the CGenerator + generateSelfStructExtension(body, decl, constructorCode); + + // Next handle parameters. + body.pr(CParameterGenerator.generateDeclarations(reactor, types)); + + // Next handle states. + body.pr(CStateGenerator.generateDeclarations(reactor, types)); + + // Next handle actions. + CActionGenerator.generateDeclarations(reactor, decl, body, constructorCode); + + // Next handle inputs and outputs. + CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); + + // If there are contained reactors that either receive inputs + // from reactions of this reactor or produce outputs that trigger + // reactions of this reactor, then we need to create a struct + // inside the self struct for each contained reactor. That + // struct has a place to hold the data produced by this reactor's + // reactions and a place to put pointers to data produced by + // the contained reactors. + generateInteractingContainedReactors(reactor, body, constructorCode); + + // Next, generate the fields needed for each reaction. + CReactionGenerator.generateReactionAndTriggerStructs(body, decl, constructorCode, types); + + // Generate the fields needed for each watchdog. + CWatchdogGenerator.generateWatchdogStruct(body, decl, constructorCode); + + // Next, generate fields for modes + CModesGenerator.generateDeclarations(reactor, body, constructorCode); + + // constructorCode.pr(reactor, String.join("\n", + // "#ifdef LF_THREADED", + // " self->base->watchdog_mutex = NULL;", + // "#endif")); + + // The first field has to always be a pointer to the list of + // of allocated memory that must be freed when the reactor is freed. + // This means that the struct can be safely cast to self_base_t. + code.pr("typedef struct {"); + code.indent(); + code.pr("struct self_base_t base;"); + code.pr(body.toString()); + code.unindent(); + code.pr("} " + selfType + ";"); + } + + /** + * Generate structs and associated code for contained reactors that send or receive data to or + * from the container's reactions. + * + *

If there are contained reactors that either receive inputs from reactions of this reactor or + * produce outputs that trigger reactions of this reactor, then we need to create a struct inside + * the self struct of the container for each contained reactor. That struct has a place to hold + * the data produced by the container reactor's reactions and a place to put pointers to data + * produced by the contained reactors. + * + * @param reactor The reactor. + * @param body The place to put the struct definition for the contained reactors. + * @param constructorCode The place to put matching code that goes in the container's constructor. + */ + private void generateInteractingContainedReactors( + Reactor reactor, CodeBuilder body, CodeBuilder constructorCode) { + // The contents of the struct will be collected first so that + // we avoid duplicate entries and then the struct will be constructed. + var contained = new InteractingContainedReactors(reactor); + // Next generate the relevant code. + for (Instantiation containedReactor : contained.containedReactors()) { + // First define an _width variable in case it is a bank. + var array = ""; + var width = -2; + // If the instantiation is a bank, find the maximum bank width + // to define an array. + if (containedReactor.getWidthSpec() != null) { + width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); + array = "[" + width + "]"; + } + // NOTE: The following needs to be done for each instance + // so that the width can be parameter, not in the constructor. + // Here, we conservatively use a width that is the largest of all isntances. + constructorCode.pr( + String.join( + "\n", + "// Set the _width variable for all cases. This will be -2", + "// if the reactor is not a bank of reactors.", + "self->_lf_" + containedReactor.getName() + "_width = " + width + ";")); + + // Generate one struct for each contained reactor that interacts. + body.pr("struct {"); + body.indent(); + for (Port port : contained.portsOfInstance(containedReactor)) { + if (port instanceof Input) { + // If the variable is a multiport, then the place to store the data has + // to be malloc'd at initialization. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr( + port, + variableStructType(port, containedReactor.getReactorClass()) + + " " + + port.getName() + + ";"); + } else { + // Is a multiport. + // Memory will be malloc'd in initialization. + body.pr( + port, + String.join( + "\n", + variableStructType(port, containedReactor.getReactorClass()) + + "** " + + port.getName() + + ";", + "int " + port.getName() + "_width;")); + } + } else { + // Must be an output port. + // Outputs of contained reactors are pointers to the source of data on the + // self struct of the container. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr( + port, + variableStructType(port, containedReactor.getReactorClass()) + + "* " + + port.getName() + + ";"); + } else { + // Is a multiport. + // Here, we will use an array of pointers. + // Memory will be malloc'd in initialization. + body.pr( + port, + String.join( + "\n", + variableStructType(port, containedReactor.getReactorClass()) + + "** " + + port.getName() + + ";", + "int " + port.getName() + "_width;")); + } + body.pr(port, "trigger_t " + port.getName() + "_trigger;"); + var reactorIndex = ""; + if (containedReactor.getWidthSpec() != null) { + reactorIndex = "[reactor_index]"; + constructorCode.pr( + "for (int reactor_index = 0; reactor_index < self->_lf_" + + containedReactor.getName() + + "_width; reactor_index++) {"); + constructorCode.indent(); + } + var portOnSelf = + "self->_lf_" + containedReactor.getName() + reactorIndex + "." + port.getName(); + + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederatedDecentralized( + portOnSelf + + "_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + + var triggered = contained.reactionsTriggered(containedReactor, port); + //noinspection StatementWithEmptyBody + if (triggered.size() > 0) { + body.pr( + port, "reaction_t* " + port.getName() + "_reactions[" + triggered.size() + "];"); + var triggeredCount = 0; + for (Integer index : triggered) { + constructorCode.pr( + port, + portOnSelf + + "_reactions[" + + triggeredCount++ + + "] = &self->_lf__reaction_" + + index + + ";"); } - body.unindent(); - body.pr(String.join("\n", - "} _lf_"+containedReactor.getName()+array+";", - "int _lf_"+containedReactor.getName()+"_width;" - )); + constructorCode.pr( + port, portOnSelf + "_trigger.reactions = " + portOnSelf + "_reactions;"); + } else { + // Since the self struct is created using calloc, there is no need to set + // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL + } + // Since the self struct is created using calloc, there is no need to set falsy fields. + constructorCode.pr( + port, + String.join( + "\n", + portOnSelf + "_trigger.last = NULL;", + portOnSelf + "_trigger.number_of_reactions = " + triggered.size() + ";")); + + // Set the physical_time_of_arrival + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederated( + portOnSelf + "_trigger.physical_time_of_arrival = NEVER;")); + + if (containedReactor.getWidthSpec() != null) { + constructorCode.unindent(); + constructorCode.pr("}"); + } } + } + body.unindent(); + body.pr( + String.join( + "\n", + "} _lf_" + containedReactor.getName() + array + ";", + "int _lf_" + containedReactor.getName() + "_width;")); } - - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the self struct - * @param body The body of the self struct - * @param decl The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - protected void generateSelfStructExtension( - CodeBuilder body, - ReactorDecl decl, - CodeBuilder constructorCode - ) { - // Do nothing + } + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the + * self struct + * + * @param body The body of the self struct + * @param decl The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + protected void generateSelfStructExtension( + CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode) { + // Do nothing + } + + /** + * Generate reaction functions definition for a reactor. These functions have a single argument + * that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param decl The reactor. + */ + public void generateReactions(ReactorDecl decl) { + var reactionIndex = 0; + var reactor = ASTUtils.toDefinition(decl); + for (Reaction reaction : allReactions(reactor)) { + generateReaction(reaction, decl, reactionIndex); + // Increment reaction index even if the reaction is not in the federate + // so that across federates, the reaction indices are consistent. + reactionIndex++; } - - /** Generate reaction functions definition for a reactor. - * These functions have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param decl The reactor. - */ - public void generateReactions(ReactorDecl decl) { - var reactionIndex = 0; - var reactor = ASTUtils.toDefinition(decl); - for (Reaction reaction : allReactions(reactor)) { - generateReaction(reaction, decl, reactionIndex); - // Increment reaction index even if the reaction is not in the federate - // so that across federates, the reaction indices are consistent. - reactionIndex++; - } - } - - /** Generate a reaction function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param decl The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactionIndex) { - - code.pr(CReactionGenerator.generateReaction( + } + + /** + * Generate a reaction function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param decl The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactionIndex) { + + code.pr( + CReactionGenerator.generateReaction( reaction, decl, reactionIndex, @@ -1451,793 +1365,834 @@ protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactio errorReporter, types, targetConfig, - getTarget().requiresTypes - )); + getTarget().requiresTypes)); + } + + /** + * Generate watchdog functions definition for a reactor. These functions have a single argument + * that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param decl The reactor. federated or not the main reactor and reactions should be + * unconditionally generated. + */ + public void generateWatchdogs(ReactorDecl decl) { + // WATCHDOG QUESTION: A similar question is asked somewhere else for a + // different function - Do we need to check if this federate contains the + // watchdog? This is done in the code generation for reactions. + var reactor = ASTUtils.toDefinition(decl); + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + generateWatchdog(watchdog, decl); } - - /** Generate watchdog functions definition for a reactor. - * These functions have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param decl The reactor. - * federated or not the main reactor and reactions should be - * unconditionally generated. - */ - public void generateWatchdogs(ReactorDecl decl) { - // WATCHDOG QUESTION: A similar question is asked somewhere else for a - // different function - Do we need to check if this federate contains the - // watchdog? This is done in the code generation for reactions. - var reactor = ASTUtils.toDefinition(decl); - for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - generateWatchdog(watchdog, decl); + } + + /** + * Generate a watchdog function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param watchdog The watchdog. + * @param decl The reactor. + */ + protected void generateWatchdog(Watchdog watchdog, ReactorDecl decl) { + code.pr(CWatchdogGenerator.generateWatchdog(watchdog, decl)); + } + + /** + * Record startup, shutdown, and reset reactions. + * + * @param instance A reactor instance. + */ + private void recordBuiltinTriggers(ReactorInstance instance) { + // For each reaction instance, allocate the arrays that will be used to + // trigger downstream reactions. + for (ReactionInstance reaction : instance.reactions) { + var reactor = reaction.getParent(); + var temp = new CodeBuilder(); + var foundOne = false; + + var reactionRef = CUtil.reactionRef(reaction); + + // Next handle triggers of the reaction that come from a multiport output + // of a contained reactor. Also, handle startup and shutdown triggers. + for (TriggerInstance trigger : reaction.triggers) { + if (trigger.isStartup()) { + temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &" + reactionRef + ";"); + startupReactionCount += reactor.getTotalWidth(); + foundOne = true; + } else if (trigger.isShutdown()) { + temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &" + reactionRef + ";"); + foundOne = true; + shutdownReactionCount += reactor.getTotalWidth(); + + if (targetConfig.tracing != null) { + var description = CUtil.getShortenedName(reactor); + var reactorRef = CUtil.reactorRef(reactor); + temp.pr( + String.join( + "\n", + "_lf_register_trace_event(" + + reactorRef + + ", &(" + + reactorRef + + "->_lf__shutdown),", + "trace_trigger, " + addDoubleQuotes(description + ".shutdown") + ");")); + } + } else if (trigger.isReset()) { + temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &" + reactionRef + ";"); + resetReactionCount += reactor.getTotalWidth(); + foundOne = true; } + } + if (foundOne) initializeTriggerObjects.pr(temp.toString()); } - - /** Generate a watchdog function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param watchdog The watchdog. - * @param decl The reactor. - */ - protected void generateWatchdog(Watchdog watchdog, ReactorDecl decl) { - code.pr(CWatchdogGenerator.generateWatchdog( - watchdog, - decl - )); + } + + private void recordWatchdogs(ReactorInstance instance) { + var foundOne = false; + var temp = new CodeBuilder(); + var reactorRef = CUtil.reactorRef(instance); + // temp.pr("#ifdef LF_THREADED"); + for (WatchdogInstance watchdog : instance.watchdogs) { + temp.pr( + " _lf_watchdogs[_lf_watchdog_number_count++] = &" + + reactorRef + + "->_lf_watchdog_" + + watchdog.getName() + + ";"); + temp.pr( + " " + + reactorRef + + "->_lf_watchdog_" + + watchdog.getName() + + ".min_expiration = " + + CTypes.getInstance().getTargetTimeExpr(watchdog.getTimeout()) + + ";"); + temp.pr(" " + reactorRef + "->_lf_watchdog_" + watchdog.getName() + ".thread_id;"); + watchdogCount += 1; + foundOne = true; } - - /** - * Record startup, shutdown, and reset reactions. - * @param instance A reactor instance. - */ - private void recordBuiltinTriggers(ReactorInstance instance) { - // For each reaction instance, allocate the arrays that will be used to - // trigger downstream reactions. - for (ReactionInstance reaction : instance.reactions) { - var reactor = reaction.getParent(); - var temp = new CodeBuilder(); - var foundOne = false; - - var reactionRef = CUtil.reactionRef(reaction); - - // Next handle triggers of the reaction that come from a multiport output - // of a contained reactor. Also, handle startup and shutdown triggers. - for (TriggerInstance trigger : reaction.triggers) { - if (trigger.isStartup()) { - temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &"+reactionRef+";"); - startupReactionCount += reactor.getTotalWidth(); - foundOne = true; - } else if (trigger.isShutdown()) { - temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &"+reactionRef+";"); - foundOne = true; - shutdownReactionCount += reactor.getTotalWidth(); - - if (targetConfig.tracing != null) { - var description = CUtil.getShortenedName(reactor); - var reactorRef = CUtil.reactorRef(reactor); - temp.pr(String.join("\n", - "_lf_register_trace_event("+reactorRef+", &("+reactorRef+"->_lf__shutdown),", - "trace_trigger, "+addDoubleQuotes(description+".shutdown")+");" - )); - } - } else if (trigger.isReset()) { - temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &"+reactionRef+";"); - resetReactionCount += reactor.getTotalWidth(); - foundOne = true; - } - } - if (foundOne) initializeTriggerObjects.pr(temp.toString()); - } + // temp.pr("#endif"); + if (foundOne) { + initializeTriggerObjects.pr(temp.toString()); } - - private void recordWatchdogs(ReactorInstance instance) { - var foundOne = false; - var temp = new CodeBuilder(); - var reactorRef = CUtil.reactorRef(instance); - // temp.pr("#ifdef LF_THREADED"); - for (WatchdogInstance watchdog : instance.watchdogs) { - temp.pr(" _lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); - temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+CTypes.getInstance().getTargetTimeExpr(watchdog.getTimeout())+";"); - temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); - watchdogCount += 1; - foundOne = true; - } - // temp.pr("#endif"); - if (foundOne) { - initializeTriggerObjects.pr(temp.toString()); + } + + /** + * Generate code to set up the tables used in _lf_start_time_step to decrement reference counts + * and mark outputs absent between time steps. This function puts the code into startTimeStep. + */ + private void generateStartTimeStep(ReactorInstance instance) { + // Avoid generating dead code if nothing is relevant. + var foundOne = false; + var temp = new CodeBuilder(); + var containerSelfStructName = CUtil.reactorRef(instance); + + // Handle inputs that get sent data from a reaction rather than from + // another contained reactor and reactions that are triggered by an + // output of a contained reactor. + // Note that there may be more than one reaction reacting to the same + // port so we have to avoid listing the port more than once. + var portsSeen = new LinkedHashSet(); + for (ReactionInstance reaction : instance.reactions) { + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { + portsSeen.add(port); + // This reaction is sending to an input. Must be + // the input of a contained reactor in the federate. + // NOTE: If instance == main and the federate is within a bank, + // this assumes that the reaction writes only to the bank member in the federate. + foundOne = true; + + temp.pr("// Add port " + port.getFullName() + " to array of is_present fields."); + + if (!Objects.equal(port.getParent(), instance)) { + // The port belongs to contained reactor, so we also have + // iterate over the instance bank members. + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(instance); + temp.startScopedBankChannelIteration(port, null); + } else { + temp.startScopedBankChannelIteration(port, "count"); + } + var portRef = CUtil.portRefNested(port); + var con = (port.isMultiport()) ? "->" : "."; + + temp.pr( + "_lf_is_present_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + portRef + + con + + "is_present;"); + // Intended_tag is only applicable to ports in federated execution. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + portRef + + con + + "intended_tag;")); + + startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); + + if (!Objects.equal(port.getParent(), instance)) { + temp.pr("count++;"); + temp.endScopedBlock(); + temp.endScopedBlock(); + temp.endScopedBankChannelIteration(port, null); + } else { + temp.endScopedBankChannelIteration(port, "count"); + } } + } } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; + + for (ActionInstance action : instance.actions) { + foundOne = true; + temp.startScopedBlock(instance); + + temp.pr( + String.join( + "\n", + "// Add action " + action.getFullName() + " to array of is_present fields.", + "_lf_is_present_fields[" + startTimeStepIsPresentCount + "] ", + " = &" + + containerSelfStructName + + "->_lf_" + + action.getName() + + ".is_present;")); + + // Intended_tag is only applicable to actions in federated execution with decentralized + // coordination. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + String.join( + "\n", + "// Add action " + action.getFullName() + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + startTimeStepIsPresentCount + "] ", + " = &" + + containerSelfStructName + + "->_lf_" + + action.getName() + + ".intended_tag;"))); + + startTimeStepIsPresentCount += action.getParent().getTotalWidth(); + temp.endScopedBlock(); + } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; + // Next, set up the table to mark each output of each contained reactor absent. + for (ReactorInstance child : instance.children) { + if (child.outputs.size() > 0) { - /** - * Generate code to set up the tables used in _lf_start_time_step to decrement reference - * counts and mark outputs absent between time steps. This function puts the code - * into startTimeStep. - */ - private void generateStartTimeStep(ReactorInstance instance) { - // Avoid generating dead code if nothing is relevant. - var foundOne = false; - var temp = new CodeBuilder(); - var containerSelfStructName = CUtil.reactorRef(instance); - - // Handle inputs that get sent data from a reaction rather than from - // another contained reactor and reactions that are triggered by an - // output of a contained reactor. - // Note that there may be more than one reaction reacting to the same - // port so we have to avoid listing the port more than once. - var portsSeen = new LinkedHashSet(); - for (ReactionInstance reaction : instance.reactions) { - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { - portsSeen.add(port); - // This reaction is sending to an input. Must be - // the input of a contained reactor in the federate. - // NOTE: If instance == main and the federate is within a bank, - // this assumes that the reaction writes only to the bank member in the federate. - foundOne = true; - - temp.pr("// Add port "+port.getFullName()+" to array of is_present fields."); - - if (!Objects.equal(port.getParent(), instance)) { - // The port belongs to contained reactor, so we also have - // iterate over the instance bank members. - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(instance); - temp.startScopedBankChannelIteration(port, null); - } else { - temp.startScopedBankChannelIteration(port, "count"); - } - var portRef = CUtil.portRefNested(port); - var con = (port.isMultiport()) ? "->" : "."; - - temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"is_present;"); - // Intended_tag is only applicable to ports in federated execution. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"intended_tag;" - ) - ); - - startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); - - if (!Objects.equal(port.getParent(), instance)) { - temp.pr("count++;"); - temp.endScopedBlock(); - temp.endScopedBlock(); - temp.endScopedBankChannelIteration(port, null); - } else { - temp.endScopedBankChannelIteration(port, "count"); - } - } - } - } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(child); - for (ActionInstance action : instance.actions) { + var channelCount = 0; + for (PortInstance output : child.outputs) { + if (!output.getDependsOnReactions().isEmpty()) { foundOne = true; - temp.startScopedBlock(instance); - - temp.pr(String.join("\n", - "// Add action "+action.getFullName()+" to array of is_present fields.", - "_lf_is_present_fields["+startTimeStepIsPresentCount+"] ", - " = &"+containerSelfStructName+"->_lf_"+action.getName()+".is_present;" - )); - - // Intended_tag is only applicable to actions in federated execution with decentralized coordination. + temp.pr("// Add port " + output.getFullName() + " to array of is_present fields."); + temp.startChannelIteration(output); + temp.pr( + "_lf_is_present_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + CUtil.portRef(output) + + ".is_present;"); + + // Intended_tag is only applicable to ports in federated execution with decentralized + // coordination. temp.pr( CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join("\n", - "// Add action " + action.getFullName() - + " to array of intended_tag fields.", - "_lf_intended_tag_fields[" - + startTimeStepIsPresentCount + "] ", - " = &" + containerSelfStructName - + "->_lf_" + action.getName() - + ".intended_tag;" - ))); - - startTimeStepIsPresentCount += action.getParent().getTotalWidth(); - temp.endScopedBlock(); + String.join( + "\n", + "// Add port " + output.getFullName() + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + CUtil.portRef(output) + + ".intended_tag;"))); + + temp.pr("count++;"); + channelCount += output.getWidth(); + temp.endChannelIteration(output); + } } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; - - // Next, set up the table to mark each output of each contained reactor absent. - for (ReactorInstance child : instance.children) { - if (child.outputs.size() > 0) { - - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(child); - - var channelCount = 0; - for (PortInstance output : child.outputs) { - if (!output.getDependsOnReactions().isEmpty()){ - foundOne = true; - temp.pr("// Add port "+output.getFullName()+" to array of is_present fields."); - temp.startChannelIteration(output); - temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".is_present;"); - - // Intended_tag is only applicable to ports in federated execution with decentralized coordination. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join("\n", - "// Add port "+output.getFullName()+" to array of intended_tag fields.", - "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".intended_tag;" - ))); - - temp.pr("count++;"); - channelCount += output.getWidth(); - temp.endChannelIteration(output); - } - } - startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); - temp.endScopedBlock(); - temp.endScopedBlock(); - } - } - if (foundOne) startTimeStep.pr(temp.toString()); + startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); + temp.endScopedBlock(); + temp.endScopedBlock(); + } } - - /** - * For each timer in the given reactor, generate initialization code for the offset - * and period fields. - * - * This method will also populate the global _lf_timer_triggers array, which is - * used to start all timers at the start of execution. - * - * @param instance A reactor instance. - */ - private void generateTimerInitializations(ReactorInstance instance) { - for (TimerInstance timer : instance.timers) { - if (!timer.isStartup()) { - initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); - timerCount += timer.getParent().getTotalWidth(); - } - } + if (foundOne) startTimeStep.pr(temp.toString()); + } + + /** + * For each timer in the given reactor, generate initialization code for the offset and period + * fields. + * + *

This method will also populate the global _lf_timer_triggers array, which is used to start + * all timers at the start of execution. + * + * @param instance A reactor instance. + */ + private void generateTimerInitializations(ReactorInstance instance) { + for (TimerInstance timer : instance.timers) { + if (!timer.isStartup()) { + initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); + timerCount += timer.getParent().getTotalWidth(); + } } - - /** - * Process a given .proto file. - * - * Run, if possible, the proto-c protocol buffer code generator to produce - * the required .h and .c files. - * @param filename Name of the file to process. - */ - public void processProtoFile(String filename) { - var protoc = commandFactory.createCommand( + } + + /** + * Process a given .proto file. + * + *

Run, if possible, the proto-c protocol buffer code generator to produce the required .h and + * .c files. + * + * @param filename Name of the file to process. + */ + public void processProtoFile(String filename) { + var protoc = + commandFactory.createCommand( "protoc-c", - List.of("--c_out="+this.fileConfig.getSrcGenPath(), filename), + List.of("--c_out=" + this.fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); - return; - } - var returnCode = protoc.run(); - if (returnCode == 0) { - var nameSansProto = filename.substring(0, filename.length() - 6); - targetConfig.compileAdditionalSources.add( - fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString() - ); - - targetConfig.compileLibraries.add("-l"); - targetConfig.compileLibraries.add("protobuf-c"); - targetConfig.compilerFlags.add("-lprotobuf-c"); - } else { - errorReporter.reportError("protoc-c returns error code " + returnCode); - } + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); + return; } - - /** - * Construct a unique type for the struct of the specified - * typed variable (port or action) of the specified reactor class. - * This is required to be the same as the type name returned by - * {@link #variableStructType(TriggerInstance)}. - * @param variable The variable. - * @param reactor The reactor class. - * @return The name of the self struct. - */ - public static String variableStructType(Variable variable, ReactorDecl reactor) { - return reactor.getName().toLowerCase()+"_"+variable.getName()+"_t"; + var returnCode = protoc.run(); + if (returnCode == 0) { + var nameSansProto = filename.substring(0, filename.length() - 6); + targetConfig.compileAdditionalSources.add( + fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString()); + + targetConfig.compileLibraries.add("-l"); + targetConfig.compileLibraries.add("protobuf-c"); + targetConfig.compilerFlags.add("-lprotobuf-c"); + } else { + errorReporter.reportError("protoc-c returns error code " + returnCode); } - - /** - * Construct a unique type for the struct of the specified - * instance (port or action). - * This is required to be the same as the type name returned by - * {@link #variableStructType(Variable, ReactorDecl)}. - * @param portOrAction The port or action instance. - * @return The name of the self struct. - */ - public static String variableStructType(TriggerInstance portOrAction) { - return portOrAction.getParent().reactorDeclaration.getName().toLowerCase()+"_"+portOrAction.getName()+"_t"; + } + + /** + * Construct a unique type for the struct of the specified typed variable (port or action) of the + * specified reactor class. This is required to be the same as the type name returned by {@link + * #variableStructType(TriggerInstance)}. + * + * @param variable The variable. + * @param reactor The reactor class. + * @return The name of the self struct. + */ + public static String variableStructType(Variable variable, ReactorDecl reactor) { + return reactor.getName().toLowerCase() + "_" + variable.getName() + "_t"; + } + + /** + * Construct a unique type for the struct of the specified instance (port or action). This is + * required to be the same as the type name returned by {@link #variableStructType(Variable, + * ReactorDecl)}. + * + * @param portOrAction The port or action instance. + * @return The name of the self struct. + */ + public static String variableStructType(TriggerInstance portOrAction) { + return portOrAction.getParent().reactorDeclaration.getName().toLowerCase() + + "_" + + portOrAction.getName() + + "_t"; + } + + /** + * If tracing is turned on, then generate code that records the full name of the specified reactor + * instance in the trace table. If tracing is not turned on, do nothing. + * + * @param instance The reactor instance. + */ + private void generateTraceTableEntries(ReactorInstance instance) { + if (targetConfig.tracing != null) { + initializeTriggerObjects.pr(CTracingGenerator.generateTraceTableEntries(instance)); } - - /** - * If tracing is turned on, then generate code that records - * the full name of the specified reactor instance in the - * trace table. If tracing is not turned on, do nothing. - * @param instance The reactor instance. - */ - private void generateTraceTableEntries(ReactorInstance instance) { - if (targetConfig.tracing != null) { - initializeTriggerObjects.pr( - CTracingGenerator.generateTraceTableEntries(instance) - ); - } + } + + /** + * Generate code to instantiate the specified reactor instance and initialize it. + * + * @param instance A reactor instance. + */ + public void generateReactorInstance(ReactorInstance instance) { + var reactorClass = instance.getDefinition().getReactorClass(); + var fullName = instance.getFullName(); + initializeTriggerObjects.pr( + "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); + // Generate the instance self struct containing parameters, state variables, + // and outputs (the "self" struct). + initializeTriggerObjects.pr( + CUtil.reactorRefName(instance) + + "[" + + CUtil.runtimeIndex(instance) + + "] = new_" + + reactorClass.getName() + + "();"); + // Generate code to initialize the "self" struct in the + // _lf_initialize_trigger_objects function. + generateTraceTableEntries(instance); + generateReactorInstanceExtension(instance); + generateParameterInitialization(instance); + initializeOutputMultiports(instance); + initializeInputMultiports(instance); + recordBuiltinTriggers(instance); + recordWatchdogs(instance); + + // Next, initialize the "self" struct with state variables. + // These values may be expressions that refer to the parameter values defined above. + generateStateVariableInitializations(instance); + + // Generate trigger objects for the instance. + generateTimerInitializations(instance); + generateActionInitializations(instance); + generateInitializeActionToken(instance); + generateSetDeadline(instance); + generateModeStructure(instance); + + // Recursively generate code for the children. + for (ReactorInstance child : instance.children) { + // If this reactor is a placeholder for a bank of reactors, then generate + // an array of instances of reactors and create an enclosing for loop. + // Need to do this for each of the builders into which the code writes. + startTimeStep.startScopedBlock(child); + initializeTriggerObjects.startScopedBlock(child); + generateReactorInstance(child); + initializeTriggerObjects.endScopedBlock(); + startTimeStep.endScopedBlock(); } - /** - * Generate code to instantiate the specified reactor instance and - * initialize it. - * @param instance A reactor instance. - */ - public void generateReactorInstance(ReactorInstance instance) { - var reactorClass = instance.getDefinition().getReactorClass(); - var fullName = instance.getFullName(); - initializeTriggerObjects.pr( - "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); - // Generate the instance self struct containing parameters, state variables, - // and outputs (the "self" struct). - initializeTriggerObjects.pr(CUtil.reactorRefName(instance)+"["+CUtil.runtimeIndex(instance)+"] = new_"+reactorClass.getName()+"();"); - // Generate code to initialize the "self" struct in the - // _lf_initialize_trigger_objects function. - generateTraceTableEntries(instance); - generateReactorInstanceExtension(instance); - generateParameterInitialization(instance); - initializeOutputMultiports(instance); - initializeInputMultiports(instance); - recordBuiltinTriggers(instance); - recordWatchdogs(instance); - - // Next, initialize the "self" struct with state variables. - // These values may be expressions that refer to the parameter values defined above. - generateStateVariableInitializations(instance); - - // Generate trigger objects for the instance. - generateTimerInitializations(instance); - generateActionInitializations(instance); - generateInitializeActionToken(instance); - generateSetDeadline(instance); - generateModeStructure(instance); - - // Recursively generate code for the children. - for (ReactorInstance child : instance.children) { - // If this reactor is a placeholder for a bank of reactors, then generate - // an array of instances of reactors and create an enclosing for loop. - // Need to do this for each of the builders into which the code writes. - startTimeStep.startScopedBlock(child); - initializeTriggerObjects.startScopedBlock(child); - generateReactorInstance(child); - initializeTriggerObjects.endScopedBlock(); - startTimeStep.endScopedBlock(); + // For this instance, define what must be done at the start of + // each time step. This sets up the tables that are used by the + // _lf_start_time_step() function in reactor_common.c. + // Note that this function is also run once at the end + // so that it can deallocate any memory. + generateStartTimeStep(instance); + initializeTriggerObjects.pr("//***** End initializing " + fullName); + } + + /** + * For each action of the specified reactor instance, generate initialization code for the offset + * and period fields. + * + * @param instance The reactor. + */ + private void generateActionInitializations(ReactorInstance instance) { + initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + } + + /** + * Initialize actions by creating a lf_token_t in the self struct. This has the information + * required to allocate memory for the action payload. Skip any action that is not actually used + * as a trigger. + * + * @param reactor The reactor containing the actions. + */ + private void generateInitializeActionToken(ReactorInstance reactor) { + for (ActionInstance action : reactor.actions) { + // Skip this step if the action is not in use. + if (action.getParent().getTriggers().contains(action)) { + var type = getInferredType(action.getDefinition()); + var payloadSize = "0"; + if (!type.isUndefined()) { + var typeStr = types.getTargetType(type); + if (CUtil.isTokenType(type, types)) { + typeStr = CUtil.rootType(typeStr); + } + if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { + payloadSize = "sizeof(" + typeStr + ")"; + } } - // For this instance, define what must be done at the start of - // each time step. This sets up the tables that are used by the - // _lf_start_time_step() function in reactor_common.c. - // Note that this function is also run once at the end - // so that it can deallocate any memory. - generateStartTimeStep(instance); - initializeTriggerObjects.pr("//***** End initializing " + fullName); - } - - /** - * For each action of the specified reactor instance, generate initialization code - * for the offset and period fields. - * @param instance The reactor. - */ - private void generateActionInitializations(ReactorInstance instance) { - initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + var selfStruct = CUtil.reactorRef(action.getParent()); + initializeTriggerObjects.pr( + CActionGenerator.generateTokenInitializer(selfStruct, action.getName(), payloadSize)); + } } - - /** - * Initialize actions by creating a lf_token_t in the self struct. - * This has the information required to allocate memory for the action payload. - * Skip any action that is not actually used as a trigger. - * @param reactor The reactor containing the actions. - */ - private void generateInitializeActionToken(ReactorInstance reactor) { - for (ActionInstance action : reactor.actions) { - // Skip this step if the action is not in use. - if (action.getParent().getTriggers().contains(action) - ) { - var type = getInferredType(action.getDefinition()); - var payloadSize = "0"; - if (!type.isUndefined()) { - var typeStr = types.getTargetType(type); - if (CUtil.isTokenType(type, types)) { - typeStr = CUtil.rootType(typeStr); - } - if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { - payloadSize = "sizeof("+typeStr+")"; - } - } - - var selfStruct = CUtil.reactorRef(action.getParent()); - initializeTriggerObjects.pr( - CActionGenerator.generateTokenInitializer( - selfStruct, action.getName(), payloadSize - ) - ); - } + } + + /** + * Generate code that is executed while the reactor instance is being initialized. This is + * provided as an extension point for subclasses. Normally, the reactions argument is the full + * list of reactions, but for the top-level of a federate, will be a subset of reactions that is + * relevant to the federate. + * + * @param instance The reactor instance. + */ + protected void generateReactorInstanceExtension(ReactorInstance instance) { + // Do nothing + } + + /** + * Generate code that initializes the state variables for a given instance. Unlike parameters, + * state variables are uniformly initialized for all instances of the same reactor. + * + * @param instance The reactor class instance + */ + protected void generateStateVariableInitializations(ReactorInstance instance) { + var reactorClass = instance.getDefinition().getReactorClass(); + var selfRef = CUtil.reactorRef(instance); + for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { + if (isInitialized(stateVar)) { + var mode = + stateVar.eContainer() instanceof Mode + ? instance.lookupModeInstance((Mode) stateVar.eContainer()) + : instance.getMode(false); + initializeTriggerObjects.pr( + CStateGenerator.generateInitializer(instance, selfRef, stateVar, mode, types)); + if (mode != null && stateVar.isReset()) { + modalStateResetCount += instance.getTotalWidth(); } + } } - - /** - * Generate code that is executed while the reactor instance is being initialized. - * This is provided as an extension point for subclasses. - * Normally, the reactions argument is the full list of reactions, - * but for the top-level of a federate, will be a subset of reactions that - * is relevant to the federate. - * @param instance The reactor instance. - */ - protected void generateReactorInstanceExtension(ReactorInstance instance) { - // Do nothing - } - - /** - * Generate code that initializes the state variables for a given instance. - * Unlike parameters, state variables are uniformly initialized for all instances - * of the same reactor. - * @param instance The reactor class instance - */ - protected void generateStateVariableInitializations(ReactorInstance instance) { - var reactorClass = instance.getDefinition().getReactorClass(); - var selfRef = CUtil.reactorRef(instance); - for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { - if (isInitialized(stateVar)) { - var mode = stateVar.eContainer() instanceof Mode ? - instance.lookupModeInstance((Mode) stateVar.eContainer()) : - instance.getMode(false); - initializeTriggerObjects.pr(CStateGenerator.generateInitializer( - instance, - selfRef, - stateVar, - mode, - types - )); - if (mode != null && stateVar.isReset()) { - modalStateResetCount += instance.getTotalWidth(); - } - } - } + } + + /** + * Generate code to set the deadline field of the reactions in the specified reactor instance. + * + * @param instance The reactor instance. + */ + private void generateSetDeadline(ReactorInstance instance) { + for (ReactionInstance reaction : instance.reactions) { + var selfRef = CUtil.reactorRef(reaction.getParent()) + "->_lf__reaction_" + reaction.index; + if (reaction.declaredDeadline != null) { + var deadline = reaction.declaredDeadline.maxDelay; + initializeTriggerObjects.pr( + selfRef + ".deadline = " + types.getTargetTimeExpr(deadline) + ";"); + } else { // No deadline. + initializeTriggerObjects.pr(selfRef + ".deadline = NEVER;"); + } } - - /** - * Generate code to set the deadline field of the reactions in the - * specified reactor instance. - * @param instance The reactor instance. - */ - private void generateSetDeadline(ReactorInstance instance) { - for (ReactionInstance reaction : instance.reactions) { - var selfRef = CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+reaction.index; - if (reaction.declaredDeadline != null) { - var deadline = reaction.declaredDeadline.maxDelay; - initializeTriggerObjects.pr(selfRef+".deadline = "+types.getTargetTimeExpr(deadline)+";"); - } else { // No deadline. - initializeTriggerObjects.pr(selfRef+".deadline = NEVER;"); - } - } + } + + /** + * Generate code to initialize modes. + * + * @param instance The reactor instance. + */ + private void generateModeStructure(ReactorInstance instance) { + CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); + if (!instance.modes.isEmpty()) { + modalReactorCount += instance.getTotalWidth(); } - - /** - * Generate code to initialize modes. - * @param instance The reactor instance. - */ - private void generateModeStructure(ReactorInstance instance) { - CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); - if (!instance.modes.isEmpty()) { - modalReactorCount += instance.getTotalWidth(); - } + } + + /** + * Generate runtime initialization code for parameters of a given reactor instance + * + * @param instance The reactor instance. + */ + protected void generateParameterInitialization(ReactorInstance instance) { + var selfRef = CUtil.reactorRef(instance); + // Set the local bank_index variable so that initializers can use it. + initializeTriggerObjects.pr( + "bank_index = " + + CUtil.bankIndex(instance) + + ";" + + " SUPPRESS_UNUSED_WARNING(bank_index);"); + for (ParameterInstance parameter : instance.parameters) { + // NOTE: we now use the resolved literal value. For better efficiency, we could + // store constants in a global array and refer to its elements to avoid duplicate + // memory allocations. + // NOTE: If the parameter is initialized with a static initializer for an array + // or struct (the initialization expression is surrounded by { ... }), then we + // have to declare a static variable to ensure that the memory is put in data space + // and not on the stack. + // FIXME: Is there a better way to determine this than the string comparison? + var initializer = CParameterGenerator.getInitializer(parameter); + if (initializer.startsWith("{")) { + var temporaryVariableName = parameter.uniqueID(); + initializeTriggerObjects.pr( + String.join( + "\n", + "static " + + types.getVariableDeclaration(parameter.type, temporaryVariableName, true) + + " = " + + initializer + + ";", + selfRef + "->" + parameter.getName() + " = " + temporaryVariableName + ";")); + } else { + initializeTriggerObjects.pr( + selfRef + "->" + parameter.getName() + " = " + initializer + ";"); + } } - - /** - * Generate runtime initialization code for parameters of a given reactor instance - * @param instance The reactor instance. - */ - protected void generateParameterInitialization(ReactorInstance instance) { - var selfRef = CUtil.reactorRef(instance); - // Set the local bank_index variable so that initializers can use it. - initializeTriggerObjects.pr("bank_index = "+CUtil.bankIndex(instance)+";" - + " SUPPRESS_UNUSED_WARNING(bank_index);"); - for (ParameterInstance parameter : instance.parameters) { - // NOTE: we now use the resolved literal value. For better efficiency, we could - // store constants in a global array and refer to its elements to avoid duplicate - // memory allocations. - // NOTE: If the parameter is initialized with a static initializer for an array - // or struct (the initialization expression is surrounded by { ... }), then we - // have to declare a static variable to ensure that the memory is put in data space - // and not on the stack. - // FIXME: Is there a better way to determine this than the string comparison? - var initializer = CParameterGenerator.getInitializer(parameter); - if (initializer.startsWith("{")) { - var temporaryVariableName = parameter.uniqueID(); - initializeTriggerObjects.pr(String.join("\n", - "static "+types.getVariableDeclaration(parameter.type, temporaryVariableName, true)+" = "+initializer+";", - selfRef+"->"+parameter.getName()+" = "+temporaryVariableName+";" - )); - } else { - initializeTriggerObjects.pr(selfRef+"->"+parameter.getName()+" = "+initializer+";"); - } - } + } + + /** + * Generate code that mallocs memory for any output multiports. + * + * @param reactor The reactor instance. + */ + private void initializeOutputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance output : reactor.outputs) { + initializeTriggerObjects.pr( + CPortGenerator.initializeOutputMultiport(output, reactorSelfStruct)); } - - /** - * Generate code that mallocs memory for any output multiports. - * @param reactor The reactor instance. - */ - private void initializeOutputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance output : reactor.outputs) { - initializeTriggerObjects.pr(CPortGenerator.initializeOutputMultiport( - output, - reactorSelfStruct - )); - } + } + + /** + * Allocate memory for inputs. + * + * @param reactor The reactor. + */ + private void initializeInputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance input : reactor.inputs) { + initializeTriggerObjects.pr( + CPortGenerator.initializeInputMultiport(input, reactorSelfStruct)); } - - /** - * Allocate memory for inputs. - * @param reactor The reactor. - */ - private void initializeInputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance input : reactor.inputs) { - initializeTriggerObjects.pr(CPortGenerator.initializeInputMultiport( - input, - reactorSelfStruct - )); - } + } + + @Override + public TargetTypes getTargetTypes() { + return types; + } + + /** + * @param context + * @return + */ + protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new CDockerGenerator(context); + } + + // ////////////////////////////////////////// + // // Protected methods. + + // Perform set up that does not generate code + protected void setUpGeneralParameters() { + accommodatePhysicalActionsIfPresent(); + targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); + targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); + // Create the main reactor instance if there is a main reactor. + createMainReactorInstance(); + if (hasModalReactors) { + // So that each separate compile knows about modal reactors, do this: + targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); } - - @Override - public TargetTypes getTargetTypes() { - return types; + if (targetConfig.threading + && targetConfig.platformOptions.platform == Platform.ARDUINO + && (targetConfig.platformOptions.board == null + || !targetConfig.platformOptions.board.contains("mbed"))) { + // non-MBED boards should not use threading + System.out.println( + "Threading is incompatible on your current Arduino flavor. Setting threading to false."); + targetConfig.threading = false; } - /** - * - * @param context - * @return - */ - protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new CDockerGenerator(context); + if (targetConfig.platformOptions.platform == Platform.ARDUINO + && !targetConfig.noCompile + && targetConfig.platformOptions.board == null) { + System.out.println( + "To enable compilation for the Arduino platform, you must specify the fully-qualified" + + " board name (FQBN) in the target property. For example, platform: {name: arduino," + + " board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target" + + " code only."); + targetConfig.noCompile = true; } - - // ////////////////////////////////////////// - // // Protected methods. - - // Perform set up that does not generate code - protected void setUpGeneralParameters() { - accommodatePhysicalActionsIfPresent(); - targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); - targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); - // Create the main reactor instance if there is a main reactor. - createMainReactorInstance(); - if (hasModalReactors) { - // So that each separate compile knows about modal reactors, do this: - targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); - } - if (targetConfig.threading && targetConfig.platformOptions.platform == Platform.ARDUINO - && (targetConfig.platformOptions.board == null || !targetConfig.platformOptions.board.contains("mbed"))) { - //non-MBED boards should not use threading - System.out.println("Threading is incompatible on your current Arduino flavor. Setting threading to false."); - targetConfig.threading = false; - } - - if (targetConfig.platformOptions.platform == Platform.ARDUINO && !targetConfig.noCompile - && targetConfig.platformOptions.board == null) { - System.out.println("To enable compilation for the Arduino platform, you must specify the fully-qualified board name (FQBN) in the target property. For example, platform: {name: arduino, board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target code only."); - targetConfig.noCompile = true; - } - if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake - pickScheduler(); - // FIXME: this and pickScheduler should be combined. - targetConfig.compileDefinitions.put( - "SCHEDULER", - targetConfig.schedulerType.name() - ); - targetConfig.compileDefinitions.put( - "NUMBER_OF_WORKERS", - String.valueOf(targetConfig.workers) - ); - } - pickCompilePlatform(); + if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake + pickScheduler(); + // FIXME: this and pickScheduler should be combined. + targetConfig.compileDefinitions.put("SCHEDULER", targetConfig.schedulerType.name()); + targetConfig.compileDefinitions.put( + "NUMBER_OF_WORKERS", String.valueOf(targetConfig.workers)); } - - -// // Perform set up that does not generate code -// protected void setUpFederateSpecificParameters(FederateInstance federate, CodeBuilder commonCode) { -// currentFederate = federate; -// if (isFederated) { -// // Reset the cmake-includes and files, to be repopulated for each federate individually. -// // This is done to enable support for separately -// // adding cmake-includes/files for different federates to prevent linking and mixing -// // all federates' supporting libraries/files together. -// targetConfig.cmakeIncludes.clear(); -// targetConfig.cmakeIncludesWithoutPath.clear(); -// targetConfig.fileNames.clear(); -// targetConfig.filesNamesWithoutPath.clear(); -// -// // Re-apply the cmake-include target property of the main .lf file. -// var target = GeneratorUtils.findTarget(mainDef.getReactorClass().eResource()); -// if (target.getConfig() != null) { -// // Update the cmake-include -// TargetProperty.updateOne( -// this.targetConfig, -// TargetProperty.CMAKE_INCLUDE, -// convertToEmptyListIfNull(target.getConfig().getPairs()), -// errorReporter -// ); -// // Update the files -// TargetProperty.updateOne( -// this.targetConfig, -// TargetProperty.FILES, -// convertToEmptyListIfNull(target.getConfig().getPairs()), -// errorReporter -// ); -// } -// // Clear out previously generated code. -// code = new CodeBuilder(commonCode); -// initializeTriggerObjects = new CodeBuilder(); -// // Enable clock synchronization if the federate -// // is not local and clock-sync is enabled -// initializeClockSynchronization(); -// startTimeStep = new CodeBuilder(); -// } -// } - - protected void handleProtoFiles() { - // Handle .proto files. - for (String file : targetConfig.protoFiles) { - this.processProtoFile(file); - var dotIndex = file.lastIndexOf("."); - var rootFilename = file; - if (dotIndex > 0) { - rootFilename = file.substring(0, dotIndex); - } - code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); - } + pickCompilePlatform(); + } + + // // Perform set up that does not generate code + // protected void setUpFederateSpecificParameters(FederateInstance federate, CodeBuilder + // commonCode) { + // currentFederate = federate; + // if (isFederated) { + // // Reset the cmake-includes and files, to be repopulated for each federate + // individually. + // // This is done to enable support for separately + // // adding cmake-includes/files for different federates to prevent linking and mixing + // // all federates' supporting libraries/files together. + // targetConfig.cmakeIncludes.clear(); + // targetConfig.cmakeIncludesWithoutPath.clear(); + // targetConfig.fileNames.clear(); + // targetConfig.filesNamesWithoutPath.clear(); + // + // // Re-apply the cmake-include target property of the main .lf file. + // var target = GeneratorUtils.findTarget(mainDef.getReactorClass().eResource()); + // if (target.getConfig() != null) { + // // Update the cmake-include + // TargetProperty.updateOne( + // this.targetConfig, + // TargetProperty.CMAKE_INCLUDE, + // convertToEmptyListIfNull(target.getConfig().getPairs()), + // errorReporter + // ); + // // Update the files + // TargetProperty.updateOne( + // this.targetConfig, + // TargetProperty.FILES, + // convertToEmptyListIfNull(target.getConfig().getPairs()), + // errorReporter + // ); + // } + // // Clear out previously generated code. + // code = new CodeBuilder(commonCode); + // initializeTriggerObjects = new CodeBuilder(); + // // Enable clock synchronization if the federate + // // is not local and clock-sync is enabled + // initializeClockSynchronization(); + // startTimeStep = new CodeBuilder(); + // } + // } + + protected void handleProtoFiles() { + // Handle .proto files. + for (String file : targetConfig.protoFiles) { + this.processProtoFile(file); + var dotIndex = file.lastIndexOf("."); + var rootFilename = file; + if (dotIndex > 0) { + rootFilename = file.substring(0, dotIndex); + } + code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); } - - /** - * Generate code that needs to appear at the top of the generated - * C file, such as #define and #include statements. - */ - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr(CPreambleGenerator.generateDefineDirectives( - targetConfig, - fileConfig.getSrcGenPath(), - hasModalReactors - )); - code.pr(CPreambleGenerator.generateIncludeStatements( - targetConfig, - CCppMode - )); - return code.toString(); + } + + /** + * Generate code that needs to appear at the top of the generated C file, such as #define and + * #include statements. + */ + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr( + CPreambleGenerator.generateDefineDirectives( + targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); + code.pr(CPreambleGenerator.generateIncludeStatements(targetConfig, CCppMode)); + return code.toString(); + } + + /** Generate top-level preamble code. */ + protected String generateTopLevelPreambles() { + CodeBuilder code = new CodeBuilder(); + + // preamble for federated execution setup + if (targetConfig.fedSetupPreamble != null) { + if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); + code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); + if (targetLanguageIsCpp()) code.pr("}"); } - /** - * Generate top-level preamble code. - */ - protected String generateTopLevelPreambles() { - CodeBuilder code = new CodeBuilder(); - - // preamble for federated execution setup - if (targetConfig.fedSetupPreamble != null) { - if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); - code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); - if (targetLanguageIsCpp()) code.pr("}"); - } - - // user preambles - if (this.mainDef != null) { - var mainModel = (Model) toDefinition(mainDef.getReactorClass()).eContainer(); - for (Preamble p : mainModel.getPreambles()) { - code.pr(toText(p.getCode())); - } - } - return code.toString(); + // user preambles + if (this.mainDef != null) { + var mainModel = (Model) toDefinition(mainDef.getReactorClass()).eContainer(); + for (Preamble p : mainModel.getPreambles()) { + code.pr(toText(p.getCode())); + } } - - protected boolean targetLanguageIsCpp() { - return CCppMode; + return code.toString(); + } + + protected boolean targetLanguageIsCpp() { + return CCppMode; + } + + /** + * Given a line of text from the output of a compiler, return an instance of ErrorFileAndLine if + * the line is recognized as the first line of an error message. Otherwise, return null. + * + * @param line A line of output from a compiler or other external tool that might generate errors. + * @return If the line is recognized as the start of an error message, then return a class + * containing the path to the file on which the error occurred (or null if there is none), the + * line number (or the string "1" if there is none), the character position (or the string "0" + * if there is none), and the message (or an empty string if there is none). + */ + @Override + public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { + var matcher = compileErrorPattern.matcher(line); + if (matcher.find()) { + var result = new ErrorFileAndLine(); + result.filepath = matcher.group("path"); + result.line = matcher.group("line"); + result.character = matcher.group("column"); + result.message = matcher.group("message"); + + if (!result.message.toLowerCase().contains("error:")) { + result.isError = false; + } + return result; } - - /** Given a line of text from the output of a compiler, return - * an instance of ErrorFileAndLine if the line is recognized as - * the first line of an error message. Otherwise, return null. - * @param line A line of output from a compiler or other external - * tool that might generate errors. - * @return If the line is recognized as the start of an error message, - * then return a class containing the path to the file on which the - * error occurred (or null if there is none), the line number (or the - * string "1" if there is none), the character position (or the string - * "0" if there is none), and the message (or an empty string if there - * is none). - */ - @Override - public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { - var matcher = compileErrorPattern.matcher(line); - if (matcher.find()) { - var result = new ErrorFileAndLine(); - result.filepath = matcher.group("path"); - result.line = matcher.group("line"); - result.character = matcher.group("column"); - result.message = matcher.group("message"); - - if (!result.message.toLowerCase().contains("error:")) { - result.isError = false; - } - return result; + return null; + } + + //////////////////////////////////////////// + //// Private methods. + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.C; + } + + //////////////////////////////////////////////////////////// + //// Private methods + + /** + * If a main or federated reactor has been declared, create a ReactorInstance for this top level. + * This will also assign levels to reactions, then, if the program is federated, perform an AST + * transformation to disconnect connections between federates. + */ + private void createMainReactorInstance() { + if (this.mainDef != null) { + if (this.main == null) { + // Recursively build instances. + this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); + var reactionInstanceGraph = this.main.assignLevels(); + if (reactionInstanceGraph.nodeCount() > 0) { + errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); + return; } - return null; - } - - //////////////////////////////////////////// - //// Private methods. - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.C; - } - - //////////////////////////////////////////////////////////// - //// Private methods - - /** - * If a main or federated reactor has been declared, create a ReactorInstance - * for this top level. This will also assign levels to reactions, then, - * if the program is federated, perform an AST transformation to disconnect - * connections between federates. - */ - private void createMainReactorInstance() { - if (this.mainDef != null) { - if (this.main == null) { - // Recursively build instances. - this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); - var reactionInstanceGraph = this.main.assignLevels(); - if (reactionInstanceGraph.nodeCount() > 0) { - errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); - return; - } - if (hasDeadlines) { - this.main.assignDeadlines(); - } - // Inform the run-time of the breadth/parallelism of the reaction graph - var breadth = reactionInstanceGraph.getBreadth(); - if (breadth == 0) { - errorReporter.reportWarning("The program has no reactions"); - } else { - targetConfig.compileDefinitions.put( - "LF_REACTION_GRAPH_BREADTH", - String.valueOf(reactionInstanceGraph.getBreadth()) - ); - } - } + if (hasDeadlines) { + this.main.assignDeadlines(); } - - } - - /** - * Generate an array of self structs for the reactor - * and one for each of its children. - * @param r The reactor instance. - */ - private void generateSelfStructs(ReactorInstance r) { - initializeTriggerObjects.pr(CUtil.selfType(r)+"* "+CUtil.reactorRefName(r)+"["+r.getTotalWidth()+"];"); - initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING("+CUtil.reactorRefName(r)+");"); - for (ReactorInstance child : r.children) { - generateSelfStructs(child); + // Inform the run-time of the breadth/parallelism of the reaction graph + var breadth = reactionInstanceGraph.getBreadth(); + if (breadth == 0) { + errorReporter.reportWarning("The program has no reactions"); + } else { + targetConfig.compileDefinitions.put( + "LF_REACTION_GRAPH_BREADTH", String.valueOf(reactionInstanceGraph.getBreadth())); } + } + } + } + + /** + * Generate an array of self structs for the reactor and one for each of its children. + * + * @param r The reactor instance. + */ + private void generateSelfStructs(ReactorInstance r) { + initializeTriggerObjects.pr( + CUtil.selfType(r) + "* " + CUtil.reactorRefName(r) + "[" + r.getTotalWidth() + "];"); + initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING(" + CUtil.reactorRefName(r) + ");"); + for (ReactorInstance child : r.children) { + generateSelfStructs(child); } + } } diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 0a1df14302..b7f72e216a 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -9,7 +9,6 @@ import java.util.List; import java.util.Map; import java.util.Set; - import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; @@ -38,1158 +37,1335 @@ import org.lflang.util.StringUtil; public class CReactionGenerator { - protected static String DISABLE_REACTION_INITIALIZATION_MARKER - = "// **** Do not include initialization code in this reaction."; + protected static String DISABLE_REACTION_INITIALIZATION_MARKER = + "// **** Do not include initialization code in this reaction."; - /** - * Generate necessary initialization code inside the body of the reaction that belongs to reactor decl. - * @param body The body of the reaction. Used to check for the DISABLE_REACTION_INITIALIZATION_MARKER. - * @param reaction The initialization code will be generated for this specific reaction - * @param decl The reactor that has the reaction - * @param reactionIndex The index of the reaction relative to other reactions in the reactor, starting from 0 - */ - public static String generateInitializationForReaction(String body, - Reaction reaction, - ReactorDecl decl, - int reactionIndex, - CTypes types, - ErrorReporter errorReporter, - Instantiation mainDef, - boolean requiresTypes) { - Reactor reactor = ASTUtils.toDefinition(decl); + /** + * Generate necessary initialization code inside the body of the reaction that belongs to reactor + * decl. + * + * @param body The body of the reaction. Used to check for the + * DISABLE_REACTION_INITIALIZATION_MARKER. + * @param reaction The initialization code will be generated for this specific reaction + * @param decl The reactor that has the reaction + * @param reactionIndex The index of the reaction relative to other reactions in the reactor, + * starting from 0 + */ + public static String generateInitializationForReaction( + String body, + Reaction reaction, + ReactorDecl decl, + int reactionIndex, + CTypes types, + ErrorReporter errorReporter, + Instantiation mainDef, + boolean requiresTypes) { + Reactor reactor = ASTUtils.toDefinition(decl); - // Construct the reactionInitialization code to go into - // the body of the function before the verbatim code. - CodeBuilder reactionInitialization = new CodeBuilder(); + // Construct the reactionInitialization code to go into + // the body of the function before the verbatim code. + CodeBuilder reactionInitialization = new CodeBuilder(); - CodeBuilder code = new CodeBuilder(); + CodeBuilder code = new CodeBuilder(); - // Define the "self" struct. - String structType = CUtil.selfType(decl); - // A null structType means there are no inputs, state, - // or anything else. No need to declare it. - if (structType != null) { - code.pr(String.join("\n", - structType+"* self = ("+structType+"*)instance_args; SUPPRESS_UNUSED_WARNING(self);" - )); - } + // Define the "self" struct. + String structType = CUtil.selfType(decl); + // A null structType means there are no inputs, state, + // or anything else. No need to declare it. + if (structType != null) { + code.pr( + String.join( + "\n", + structType + + "* self = (" + + structType + + "*)instance_args; SUPPRESS_UNUSED_WARNING(self);")); + } - // Do not generate the initialization code if the body is marked - // to not generate it. - if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { - return code.toString(); - } + // Do not generate the initialization code if the body is marked + // to not generate it. + if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { + return code.toString(); + } - // A reaction may send to or receive from multiple ports of - // a contained reactor. The variables for these ports need to - // all be declared as fields of the same struct. Hence, we first - // collect the fields to be defined in the structs and then - // generate the structs. - Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); + // A reaction may send to or receive from multiple ports of + // a contained reactor. The variables for these ports need to + // all be declared as fields of the same struct. Hence, we first + // collect the fields to be defined in the structs and then + // generate the structs. + Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); - // Actions may appear twice, first as a trigger, then with the outputs. - // But we need to declare it only once. Collect in this data structure - // the actions that are declared as triggered so that if they appear - // again with the outputs, they are not defined a second time. - // That second redefinition would trigger a compile error. - Set actionsAsTriggers = new LinkedHashSet<>(); + // Actions may appear twice, first as a trigger, then with the outputs. + // But we need to declare it only once. Collect in this data structure + // the actions that are declared as triggered so that if they appear + // again with the outputs, they are not defined a second time. + // That second redefinition would trigger a compile error. + Set actionsAsTriggers = new LinkedHashSet<>(); - // Next, add the triggers (input and actions; timers are not needed). - // This defines a local variable in the reaction function whose - // name matches that of the trigger. The value of the local variable - // is a struct with a value and is_present field, the latter a boolean - // that indicates whether the input/action is present. - // If the trigger is an output, then it is an output of a - // contained reactor. In this case, a struct with the name - // of the contained reactor is created with one field that is - // a pointer to a struct with a value and is_present field. - // E.g., if the contained reactor is named 'c' and its output - // port is named 'out', then c.out->value c.out->is_present are - // defined so that they can be used in the verbatim code. - for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (triggerAsVarRef.getVariable() instanceof Port) { - generatePortVariablesInReaction( - reactionInitialization, - fieldsForStructsForContainedReactors, - triggerAsVarRef, - decl, - types); - } else if (triggerAsVarRef.getVariable() instanceof Action) { - reactionInitialization.pr(generateActionVariablesInReaction( - (Action) triggerAsVarRef.getVariable(), - decl, - types - )); - actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); - } - } - } - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - // No triggers are given, which means react to any input. - // Declare an argument for every input. - // NOTE: this does not include contained outputs. - for (Input input : reactor.getInputs()) { - reactionInitialization.pr(generateInputVariablesInReaction(input, decl, types)); - } - } - // Define argument for non-triggering inputs. - for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { - if (src.getVariable() instanceof Port) { - generatePortVariablesInReaction(reactionInitialization, fieldsForStructsForContainedReactors, src, decl, types); - } else if (src.getVariable() instanceof Action) { - // It's a bit odd to read but not be triggered by an action, but - // OK, I guess we allow it. - reactionInitialization.pr(generateActionVariablesInReaction( - (Action) src.getVariable(), - decl, - types - )); - actionsAsTriggers.add((Action) src.getVariable()); - } + // Next, add the triggers (input and actions; timers are not needed). + // This defines a local variable in the reaction function whose + // name matches that of the trigger. The value of the local variable + // is a struct with a value and is_present field, the latter a boolean + // that indicates whether the input/action is present. + // If the trigger is an output, then it is an output of a + // contained reactor. In this case, a struct with the name + // of the contained reactor is created with one field that is + // a pointer to a struct with a value and is_present field. + // E.g., if the contained reactor is named 'c' and its output + // port is named 'out', then c.out->value c.out->is_present are + // defined so that they can be used in the verbatim code. + for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (triggerAsVarRef.getVariable() instanceof Port) { + generatePortVariablesInReaction( + reactionInitialization, + fieldsForStructsForContainedReactors, + triggerAsVarRef, + decl, + types); + } else if (triggerAsVarRef.getVariable() instanceof Action) { + reactionInitialization.pr( + generateActionVariablesInReaction( + (Action) triggerAsVarRef.getVariable(), decl, types)); + actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); } - - // Define variables for each declared output or action. - // In the case of outputs, the variable is a pointer to where the - // output is stored. This gives the reaction code access to any previous - // value that may have been written to that output in an earlier reaction. - if (reaction.getEffects() != null) { - for (VarRef effect : reaction.getEffects()) { - Variable variable = effect.getVariable(); - if (variable instanceof Action) { - // It is an action, not an output. - // If it has already appeared as trigger, do not redefine it. - if (!actionsAsTriggers.contains(effect.getVariable())) { - reactionInitialization.pr(CGenerator.variableStructType(variable, decl)+"* "+variable.getName()+" = &self->_lf_"+variable.getName()+";"); - } - } else if (effect.getVariable() instanceof Mode) { - // Mode change effect - int idx = ASTUtils.allModes(reactor).indexOf((Mode)effect.getVariable()); - String name = effect.getVariable().getName(); - if (idx >= 0) { - reactionInitialization.pr( - "reactor_mode_t* " + name + " = &self->_lf__modes[" + idx + "];\n" - + "lf_mode_change_type_t _lf_" + name + "_change_type = " - + (effect.getTransition() == ModeTransition.HISTORY ? - "history_transition" : "reset_transition") - + ";" - ); - } else { - errorReporter.reportError( - reaction, - "In generateReaction(): " + name + " not a valid mode of this reactor." - ); - } - } else { - if (variable instanceof Output) { - reactionInitialization.pr(generateOutputVariablesInReaction( - effect, - decl, - errorReporter, - requiresTypes - )); - } else if (variable instanceof Input) { - // It is the input of a contained reactor. - generateVariablesForSendingToContainedReactors( - reactionInitialization, - fieldsForStructsForContainedReactors, - effect.getContainer(), - (Input) variable - ); - } else if (variable instanceof Watchdog) { - reactionInitialization.pr(generateWatchdogVariablesInReaction( - effect, - decl - )); - } else { - errorReporter.reportError( - reaction, - "In generateReaction(): effect is neither an input nor an output." - ); - } - } - } - } - // Before the reaction initialization, - // generate the structs used for communication to and from contained reactors. - for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { - String array = ""; - if (containedReactor.getWidthSpec() != null) { - String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); - code.pr("int "+containedReactorWidthVar+" = self->_lf_"+containedReactorWidthVar+";"); - // Windows does not support variables in arrays declared on the stack, - // so we use the maximum size over all bank members. - array = "["+maxContainedReactorBankWidth(containedReactor, null, 0, mainDef)+"]"; - } - code.pr(String.join("\n", - "struct "+containedReactor.getName()+" {", - " "+fieldsForStructsForContainedReactors.get(containedReactor)+"", - "} "+containedReactor.getName()+array+";" - )); - } - // Next generate all the collected setup code. - code.pr(reactionInitialization.toString()); - return code.toString(); + } + } + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + // No triggers are given, which means react to any input. + // Declare an argument for every input. + // NOTE: this does not include contained outputs. + for (Input input : reactor.getInputs()) { + reactionInitialization.pr(generateInputVariablesInReaction(input, decl, types)); + } + } + // Define argument for non-triggering inputs. + for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { + if (src.getVariable() instanceof Port) { + generatePortVariablesInReaction( + reactionInitialization, fieldsForStructsForContainedReactors, src, decl, types); + } else if (src.getVariable() instanceof Action) { + // It's a bit odd to read but not be triggered by an action, but + // OK, I guess we allow it. + reactionInitialization.pr( + generateActionVariablesInReaction((Action) src.getVariable(), decl, types)); + actionsAsTriggers.add((Action) src.getVariable()); + } } - /** - * Return the maximum bank width for the given instantiation within all - * instantiations of its parent reactor. - * On the first call to this method, the breadcrumbs should be null and the max - * argument should be zero. On recursive calls, breadcrumbs is a list of nested - * instantiations, the max is the maximum width found so far. The search for - * instances of the parent reactor will begin with the last instantiation - * in the specified list. - * - * This rather complicated method is used when a reaction sends or receives data - * to or from a bank of contained reactors. There will be an array of structs on - * the self struct of the parent, and the size of the array is conservatively set - * to the maximum of all the identified bank widths. This is a bit wasteful of - * memory, but it avoids having to malloc the array for each instance, and in - * typical usage, there will be few instances or instances that are all the same - * width. - * - * @param containedReactor The contained reactor instantiation. - * @param breadcrumbs null on first call (non-recursive). - * @param max 0 on first call. - */ - public static int maxContainedReactorBankWidth( - Instantiation containedReactor, - LinkedList breadcrumbs, - int max, - Instantiation mainDef - ) { - // If the instantiation is not a bank, return 1. - if (containedReactor.getWidthSpec() == null) { - return 1; - } - // If there is no main, then we just use the default width. - if (mainDef == null) { - return ASTUtils.width(containedReactor.getWidthSpec(), null); - } - LinkedList nestedBreadcrumbs = breadcrumbs; - if (nestedBreadcrumbs == null) { - nestedBreadcrumbs = new LinkedList<>(); - nestedBreadcrumbs.add(mainDef); - } - int result = max; - Reactor parent = (Reactor) containedReactor.eContainer(); - if (parent == ASTUtils.toDefinition(mainDef.getReactorClass())) { - // The parent is main, so there can't be any other instantiations of it. - return ASTUtils.width(containedReactor.getWidthSpec(), null); - } - // Search for instances of the parent within the tail of the breadcrumbs list. - Reactor container = ASTUtils.toDefinition(nestedBreadcrumbs.get(0).getReactorClass()); - for (Instantiation instantiation : container.getInstantiations()) { - // Put this new instantiation at the head of the list. - nestedBreadcrumbs.add(0, instantiation); - if (ASTUtils.toDefinition(instantiation.getReactorClass()) == parent) { - // Found a matching instantiation of the parent. - // Evaluate the original width specification in this context. - int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); - if (candidate > result) { - result = candidate; - } - } else { - // Found some other instantiation, not the parent. - // Search within it for instantiations of the parent. - // Note that we assume here that the parent cannot contain - // instances of itself. - int candidate = maxContainedReactorBankWidth(containedReactor, nestedBreadcrumbs, result, mainDef); - if (candidate > result) { - result = candidate; - } - } - nestedBreadcrumbs.remove(); + // Define variables for each declared output or action. + // In the case of outputs, the variable is a pointer to where the + // output is stored. This gives the reaction code access to any previous + // value that may have been written to that output in an earlier reaction. + if (reaction.getEffects() != null) { + for (VarRef effect : reaction.getEffects()) { + Variable variable = effect.getVariable(); + if (variable instanceof Action) { + // It is an action, not an output. + // If it has already appeared as trigger, do not redefine it. + if (!actionsAsTriggers.contains(effect.getVariable())) { + reactionInitialization.pr( + CGenerator.variableStructType(variable, decl) + + "* " + + variable.getName() + + " = &self->_lf_" + + variable.getName() + + ";"); + } + } else if (effect.getVariable() instanceof Mode) { + // Mode change effect + int idx = ASTUtils.allModes(reactor).indexOf((Mode) effect.getVariable()); + String name = effect.getVariable().getName(); + if (idx >= 0) { + reactionInitialization.pr( + "reactor_mode_t* " + + name + + " = &self->_lf__modes[" + + idx + + "];\n" + + "lf_mode_change_type_t _lf_" + + name + + "_change_type = " + + (effect.getTransition() == ModeTransition.HISTORY + ? "history_transition" + : "reset_transition") + + ";"); + } else { + errorReporter.reportError( + reaction, "In generateReaction(): " + name + " not a valid mode of this reactor."); + } + } else { + if (variable instanceof Output) { + reactionInitialization.pr( + generateOutputVariablesInReaction(effect, decl, errorReporter, requiresTypes)); + } else if (variable instanceof Input) { + // It is the input of a contained reactor. + generateVariablesForSendingToContainedReactors( + reactionInitialization, + fieldsForStructsForContainedReactors, + effect.getContainer(), + (Input) variable); + } else if (variable instanceof Watchdog) { + reactionInitialization.pr(generateWatchdogVariablesInReaction(effect, decl)); + } else { + errorReporter.reportError( + reaction, "In generateReaction(): effect is neither an input nor an output."); + } } - return result; + } } - - /** - * Generate code for the body of a reaction that takes an input and - * schedules an action with the value of that input. - * @param actionName The action to schedule - */ - public static String generateDelayBody(String ref, String actionName, boolean isTokenType) { - // Note that the action.type set by the base class is actually - // the port type. - return isTokenType ? - String.join("\n", - "if ("+ref+"->is_present) {", - " // Put the whole token on the event queue, not just the payload.", - " // This way, the length and element_size are transported.", - " lf_schedule_token("+actionName+", 0, "+ref+"->token);", - "}" - ) : - "lf_schedule_copy("+actionName+", 0, &"+ref+"->value, 1); // Length is 1."; + // Before the reaction initialization, + // generate the structs used for communication to and from contained reactors. + for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { + String array = ""; + if (containedReactor.getWidthSpec() != null) { + String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); + code.pr( + "int " + containedReactorWidthVar + " = self->_lf_" + containedReactorWidthVar + ";"); + // Windows does not support variables in arrays declared on the stack, + // so we use the maximum size over all bank members. + array = "[" + maxContainedReactorBankWidth(containedReactor, null, 0, mainDef) + "]"; + } + code.pr( + String.join( + "\n", + "struct " + containedReactor.getName() + " {", + " " + fieldsForStructsForContainedReactors.get(containedReactor) + "", + "} " + containedReactor.getName() + array + ";")); } + // Next generate all the collected setup code. + code.pr(reactionInitialization.toString()); + return code.toString(); + } - public static String generateForwardBody(String outputName, String targetType, String actionName, boolean isTokenType) { - return isTokenType ? - String.join("\n", - DISABLE_REACTION_INITIALIZATION_MARKER, - "self->_lf_"+outputName+".value = ("+targetType+")self->_lf__"+actionName+".tmplt.token->value;", - "_lf_replace_template_token((token_template_t*)&self->_lf_"+outputName+", (lf_token_t*)self->_lf__"+actionName+".tmplt.token);", - "self->_lf_"+outputName+".is_present = true;" - ) : - "lf_set("+outputName+", "+actionName+"->value);"; + /** + * Return the maximum bank width for the given instantiation within all instantiations of its + * parent reactor. On the first call to this method, the breadcrumbs should be null and the max + * argument should be zero. On recursive calls, breadcrumbs is a list of nested instantiations, + * the max is the maximum width found so far. The search for instances of the parent reactor will + * begin with the last instantiation in the specified list. + * + *

This rather complicated method is used when a reaction sends or receives data to or from a + * bank of contained reactors. There will be an array of structs on the self struct of the parent, + * and the size of the array is conservatively set to the maximum of all the identified bank + * widths. This is a bit wasteful of memory, but it avoids having to malloc the array for each + * instance, and in typical usage, there will be few instances or instances that are all the same + * width. + * + * @param containedReactor The contained reactor instantiation. + * @param breadcrumbs null on first call (non-recursive). + * @param max 0 on first call. + */ + public static int maxContainedReactorBankWidth( + Instantiation containedReactor, + LinkedList breadcrumbs, + int max, + Instantiation mainDef) { + // If the instantiation is not a bank, return 1. + if (containedReactor.getWidthSpec() == null) { + return 1; } - - /** - * Generate into the specified string builder the code to - * initialize local variables for sending data to an input - * of a contained reactor. This will also, if necessary, - * generate entries for local struct definitions into the - * struct argument. These entries point to where the data - * is stored. - * - * @param builder The string builder. - * @param structs A map from reactor instantiations to a place to write - * struct fields. - * @param definition AST node defining the reactor within which this occurs - * @param input Input of the contained reactor. - */ - private static void generateVariablesForSendingToContainedReactors( - CodeBuilder builder, - Map structs, - Instantiation definition, - Input input - ) { - CodeBuilder structBuilder = structs.get(definition); - if (structBuilder == null) { - structBuilder = new CodeBuilder(); - structs.put(definition, structBuilder); + // If there is no main, then we just use the default width. + if (mainDef == null) { + return ASTUtils.width(containedReactor.getWidthSpec(), null); + } + LinkedList nestedBreadcrumbs = breadcrumbs; + if (nestedBreadcrumbs == null) { + nestedBreadcrumbs = new LinkedList<>(); + nestedBreadcrumbs.add(mainDef); + } + int result = max; + Reactor parent = (Reactor) containedReactor.eContainer(); + if (parent == ASTUtils.toDefinition(mainDef.getReactorClass())) { + // The parent is main, so there can't be any other instantiations of it. + return ASTUtils.width(containedReactor.getWidthSpec(), null); + } + // Search for instances of the parent within the tail of the breadcrumbs list. + Reactor container = ASTUtils.toDefinition(nestedBreadcrumbs.get(0).getReactorClass()); + for (Instantiation instantiation : container.getInstantiations()) { + // Put this new instantiation at the head of the list. + nestedBreadcrumbs.add(0, instantiation); + if (ASTUtils.toDefinition(instantiation.getReactorClass()) == parent) { + // Found a matching instantiation of the parent. + // Evaluate the original width specification in this context. + int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); + if (candidate > result) { + result = candidate; } - String inputStructType = CGenerator.variableStructType(input, definition.getReactorClass()); - String defName = definition.getName(); - String defWidth = generateWidthVariable(defName); - String inputName = input.getName(); - String inputWidth = generateWidthVariable(inputName); - if (!ASTUtils.isMultiport(input)) { - // Contained reactor's input is not a multiport. - structBuilder.pr(inputStructType+"* "+inputName+";"); - if (definition.getWidthSpec() != null) { - // Contained reactor is a bank. - builder.pr(String.join("\n", - "for (int bankIndex = 0; bankIndex < self->_lf_"+defWidth+"; bankIndex++) {", - " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+defName+"[bankIndex]."+inputName+");", - "}" - )); - } else { - // Contained reactor is not a bank. - builder.pr(defName+"."+inputName+" = &(self->_lf_"+defName+"."+inputName+");"); - } - } else { - // Contained reactor's input is a multiport. - structBuilder.pr(String.join("\n", - inputStructType+"** "+inputName+";", - "int "+inputWidth+";" - )); - // If the contained reactor is a bank, then we have to set the - // pointer for each element of the bank. - if (definition.getWidthSpec() != null) { - builder.pr(String.join("\n", - "for (int _i = 0; _i < self->_lf_"+defWidth+"; _i++) {", - " "+defName+"[_i]."+inputName+" = self->_lf_"+defName+"[_i]."+inputName+";", - " "+defName+"[_i]."+inputWidth+" = self->_lf_"+defName+"[_i]."+inputWidth+";", - "}" - )); - } else { - builder.pr(String.join("\n", - defName+"."+inputName+" = self->_lf_"+defName+"."+inputName+";", - defName+"."+inputWidth+" = self->_lf_"+defName+"."+inputWidth+";" - )); - } + } else { + // Found some other instantiation, not the parent. + // Search within it for instantiations of the parent. + // Note that we assume here that the parent cannot contain + // instances of itself. + int candidate = + maxContainedReactorBankWidth(containedReactor, nestedBreadcrumbs, result, mainDef); + if (candidate > result) { + result = candidate; } + } + nestedBreadcrumbs.remove(); } + return result; + } - /** - * Generate into the specified string builder the code to - * initialize local variables for ports in a reaction function - * from the "self" struct. The port may be an input of the - * reactor or an output of a contained reactor. The second - * argument provides, for each contained reactor, a place to - * write the declaration of the output of that reactor that - * is triggering reactions. - * @param builder The place into which to write the code. - * @param structs A map from reactor instantiations to a place to write - * struct fields. - * @param port The port. - * @param decl The reactor or import statement. - */ - private static void generatePortVariablesInReaction( - CodeBuilder builder, - Map structs, - VarRef port, - ReactorDecl decl, - CTypes types - ) { - if (port.getVariable() instanceof Input) { - builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), decl, types)); - } else { - // port is an output of a contained reactor. - Output output = (Output) port.getVariable(); - String portStructType = CGenerator.variableStructType(output, port.getContainer().getReactorClass()); + /** + * Generate code for the body of a reaction that takes an input and schedules an action with the + * value of that input. + * + * @param actionName The action to schedule + */ + public static String generateDelayBody(String ref, String actionName, boolean isTokenType) { + // Note that the action.type set by the base class is actually + // the port type. + return isTokenType + ? String.join( + "\n", + "if (" + ref + "->is_present) {", + " // Put the whole token on the event queue, not just the payload.", + " // This way, the length and element_size are transported.", + " lf_schedule_token(" + actionName + ", 0, " + ref + "->token);", + "}") + : "lf_schedule_copy(" + actionName + ", 0, &" + ref + "->value, 1); // Length is 1."; + } - CodeBuilder structBuilder = structs.get(port.getContainer()); - if (structBuilder == null) { - structBuilder = new CodeBuilder(); - structs.put(port.getContainer(), structBuilder); - } - String reactorName = port.getContainer().getName(); - String reactorWidth = generateWidthVariable(reactorName); - String outputName = output.getName(); - String outputWidth = generateWidthVariable(outputName); - // First define the struct containing the output value and indicator - // of its presence. - if (!ASTUtils.isMultiport(output)) { - // Output is not a multiport. - structBuilder.pr(portStructType+"* "+outputName+";"); - } else { - // Output is a multiport. - structBuilder.pr(String.join("\n", - portStructType+"** "+outputName+";", - "int "+outputWidth+";" - )); - } + public static String generateForwardBody( + String outputName, String targetType, String actionName, boolean isTokenType) { + return isTokenType + ? String.join( + "\n", + DISABLE_REACTION_INITIALIZATION_MARKER, + "self->_lf_" + + outputName + + ".value = (" + + targetType + + ")self->_lf__" + + actionName + + ".tmplt.token->value;", + "_lf_replace_template_token((token_template_t*)&self->_lf_" + + outputName + + ", (lf_token_t*)self->_lf__" + + actionName + + ".tmplt.token);", + "self->_lf_" + outputName + ".is_present = true;") + : "lf_set(" + outputName + ", " + actionName + "->value);"; + } - // Next, initialize the struct with the current values. - if (port.getContainer().getWidthSpec() != null) { - // Output is in a bank. - builder.pr(String.join("\n", - "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+reactorName+"[i]."+outputName+" = self->_lf_"+reactorName+"[i]."+outputName+";", - "}" - )); - if (ASTUtils.isMultiport(output)) { - builder.pr(String.join("\n", - "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+reactorName+"[i]."+outputWidth+" = self->_lf_"+reactorName+"[i]."+outputWidth+";", - "}" - )); - } - } else { - // Output is not in a bank. - builder.pr(reactorName+"."+outputName+" = self->_lf_"+reactorName+"."+outputName+";"); - if (ASTUtils.isMultiport(output)) { - builder.pr(reactorName+"."+outputWidth+" = self->_lf_"+reactorName+"."+outputWidth+";"); - } - } - } + /** + * Generate into the specified string builder the code to initialize local variables for sending + * data to an input of a contained reactor. This will also, if necessary, generate entries for + * local struct definitions into the struct argument. These entries point to where the data is + * stored. + * + * @param builder The string builder. + * @param structs A map from reactor instantiations to a place to write struct fields. + * @param definition AST node defining the reactor within which this occurs + * @param input Input of the contained reactor. + */ + private static void generateVariablesForSendingToContainedReactors( + CodeBuilder builder, + Map structs, + Instantiation definition, + Input input) { + CodeBuilder structBuilder = structs.get(definition); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(definition, structBuilder); } - - /** Generate action variables for a reaction. - * @param action The action. - * @param decl The reactor. - */ - private static String generateActionVariablesInReaction( - Action action, - ReactorDecl decl, - CTypes types - ) { - String structType = CGenerator.variableStructType(action, decl); - // If the action has a type, create variables for accessing the value. - InferredType type = ASTUtils.getInferredType(action); - // Pointer to the lf_token_t sent as the payload in the trigger. - String tokenPointer = "(self->_lf__"+action.getName()+".tmplt.token)"; - CodeBuilder builder = new CodeBuilder(); - + String inputStructType = CGenerator.variableStructType(input, definition.getReactorClass()); + String defName = definition.getName(); + String defWidth = generateWidthVariable(defName); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); + if (!ASTUtils.isMultiport(input)) { + // Contained reactor's input is not a multiport. + structBuilder.pr(inputStructType + "* " + inputName + ";"); + if (definition.getWidthSpec() != null) { + // Contained reactor is a bank. builder.pr( - String.join("\n", - "// Expose the action struct as a local variable whose name matches the action name.", - structType+"* "+action.getName()+" = &self->_lf_"+action.getName()+";", - "// Set the fields of the action struct to match the current trigger.", - action.getName()+"->is_present = (bool)self->_lf__"+action.getName()+".status;", - action.getName()+"->has_value = ("+tokenPointer+" != NULL && "+tokenPointer+"->value != NULL);", - "_lf_replace_template_token((token_template_t*)"+action.getName()+", "+tokenPointer+");") - ); - // Set the value field only if there is a type. - if (!type.isUndefined()) { - // The value field will either be a copy (for primitive types) - // or a pointer (for types ending in *). - builder.pr("if ("+action.getName()+"->has_value) {"); - builder.indent(); - if (CUtil.isTokenType(type, types)) { - builder.pr(action.getName()+"->value = ("+types.getTargetType(type)+")"+tokenPointer+"->value;"); - } else { - builder.pr(action.getName()+"->value = *("+types.getTargetType(type)+"*)"+tokenPointer+"->value;"); - } - builder.unindent(); - builder.pr("}"); - } - return builder.toString(); + String.join( + "\n", + "for (int bankIndex = 0; bankIndex < self->_lf_" + defWidth + "; bankIndex++) {", + " " + + defName + + "[bankIndex]." + + inputName + + " = &(self->_lf_" + + defName + + "[bankIndex]." + + inputName + + ");", + "}")); + } else { + // Contained reactor is not a bank. + builder.pr( + defName + "." + inputName + " = &(self->_lf_" + defName + "." + inputName + ");"); + } + } else { + // Contained reactor's input is a multiport. + structBuilder.pr( + String.join("\n", inputStructType + "** " + inputName + ";", "int " + inputWidth + ";")); + // If the contained reactor is a bank, then we have to set the + // pointer for each element of the bank. + if (definition.getWidthSpec() != null) { + builder.pr( + String.join( + "\n", + "for (int _i = 0; _i < self->_lf_" + defWidth + "; _i++) {", + " " + + defName + + "[_i]." + + inputName + + " = self->_lf_" + + defName + + "[_i]." + + inputName + + ";", + " " + + defName + + "[_i]." + + inputWidth + + " = self->_lf_" + + defName + + "[_i]." + + inputWidth + + ";", + "}")); + } else { + builder.pr( + String.join( + "\n", + defName + "." + inputName + " = self->_lf_" + defName + "." + inputName + ";", + defName + "." + inputWidth + " = self->_lf_" + defName + "." + inputWidth + ";")); + } } + } - /** Generate into the specified string builder the code to - * initialize local variables for the specified input port - * in a reaction function from the "self" struct. - * @param input The input statement from the AST. - * @param decl The reactor. - */ - private static String generateInputVariablesInReaction( - Input input, - ReactorDecl decl, - CTypes types - ) { - String structType = CGenerator.variableStructType(input, decl); - InferredType inputType = ASTUtils.getInferredType(input); - CodeBuilder builder = new CodeBuilder(); - String inputName = input.getName(); - String inputWidth = generateWidthVariable(inputName); - - // Create the local variable whose name matches the input name. - // If the input has not been declared mutable, then this is a pointer - // to the upstream output. Otherwise, it is a copy of the upstream output, - // which nevertheless points to the same token and value (hence, as done - // below, we have to use lf_writable_copy()). There are 8 cases, - // depending on whether the input is mutable, whether it is a multiport, - // and whether it is a token type. - // Easy case first. - if (!input.isMutable() && !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, primitive type. - builder.pr(structType+"* "+inputName+" = self->_lf_"+inputName+";"); - } else if (input.isMutable()&& !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, primitive type. - builder.pr(String.join("\n", - "// Mutable input, so copy the input into a temporary variable.", - "// The input value on the struct is a copy.", - structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", - structType+"* "+inputName+" = &_lf_tmp_"+inputName+";" - )); - } else if (!input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, token type. - builder.pr(String.join("\n", - structType+"* "+inputName+" = self->_lf_"+inputName+";", - "if ("+inputName+"->is_present) {", - " "+inputName+"->length = "+inputName+"->token->length;", - " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", - "} else {", - " "+inputName+"->length = 0;", - "}" - )); - } else if (input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, token type. - builder.pr(String.join("\n", - "// Mutable input, so copy the input struct into a temporary variable.", - structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", - structType+"* "+inputName+" = &_lf_tmp_"+inputName+";", - inputName+"->value = NULL;", // Prevent payload from being freed. - "if ("+inputName+"->is_present) {", - " "+inputName+"->length = "+inputName+"->token->length;", - " "+inputName+"->token = lf_writable_copy((lf_port_base_t*)self->_lf_"+inputName+");", - " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", - "} else {", - " "+inputName+"->length = 0;", - "}" - )); - } else if (!input.isMutable()&& ASTUtils.isMultiport(input)) { - // Non-mutable, multiport, primitive or token type. - builder.pr(structType+"** "+inputName+" = self->_lf_"+inputName+";"); - } else if (CUtil.isTokenType(inputType, types)) { - // Mutable, multiport, token type - builder.pr(String.join("\n", - "// Mutable multiport input, so copy the input structs", - "// into an array of temporary variables on the stack.", - structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", - " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", - " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", - " // If necessary, copy the tokens.", - " if ("+inputName+"[i]->is_present) {", - " "+inputName+"[i]->length = "+inputName+"[i]->token->length;", - " token_template_t* _lf_input = (token_template_t*)self->_lf_"+inputName+"[i];", - " "+inputName+"[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", - " "+inputName+"[i]->value = ("+types.getTargetType(inputType)+")"+inputName+"[i]->token->value;", - " } else {", - " "+inputName+"[i]->length = 0;", - " }", - "}" - )); - } else { - // Mutable, multiport, primitive type - builder.pr(String.join("\n", - "// Mutable multiport input, so copy the input structs", - "// into an array of temporary variables on the stack.", - structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", - " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", - " // Copy the struct, which includes the value.", - " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", - "}" - )); - } - // Set the _width variable for all cases. This will be -1 - // for a variable-width multiport, which is not currently supported. - // It will be -2 if it is not multiport. - builder.pr("int "+inputWidth+" = self->_lf_"+inputWidth+"; SUPPRESS_UNUSED_WARNING("+inputWidth+");"); - return builder.toString(); - } + /** + * Generate into the specified string builder the code to initialize local variables for ports in + * a reaction function from the "self" struct. The port may be an input of the reactor or an + * output of a contained reactor. The second argument provides, for each contained reactor, a + * place to write the declaration of the output of that reactor that is triggering reactions. + * + * @param builder The place into which to write the code. + * @param structs A map from reactor instantiations to a place to write struct fields. + * @param port The port. + * @param decl The reactor or import statement. + */ + private static void generatePortVariablesInReaction( + CodeBuilder builder, + Map structs, + VarRef port, + ReactorDecl decl, + CTypes types) { + if (port.getVariable() instanceof Input) { + builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), decl, types)); + } else { + // port is an output of a contained reactor. + Output output = (Output) port.getVariable(); + String portStructType = + CGenerator.variableStructType(output, port.getContainer().getReactorClass()); - /** - * Generate into the specified string builder the code to - * initialize local variables for outputs in a reaction function - * from the "self" struct. - * @param effect The effect declared by the reaction. This must refer to an output. - * @param decl The reactor containing the reaction or the import statement. - */ - public static String generateOutputVariablesInReaction( - VarRef effect, - ReactorDecl decl, - ErrorReporter errorReporter, - boolean requiresTypes - ) { - Output output = (Output) effect.getVariable(); - String outputName = output.getName(); - String outputWidth = generateWidthVariable(outputName); - if (output.getType() == null && requiresTypes) { - errorReporter.reportError(output, "Output is required to have a type: " + outputName); - return ""; - } else { - // The container of the output may be a contained reactor or - // the reactor containing the reaction. - String outputStructType = (effect.getContainer() == null) ? - CGenerator.variableStructType(output, decl) - : - CGenerator.variableStructType(output, effect.getContainer().getReactorClass()); - if (!ASTUtils.isMultiport(output)) { - // Output port is not a multiport. - return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; - } else { - // Output port is a multiport. - // Set the _width variable. - return String.join("\n", - "int "+outputWidth+" = self->_lf_"+outputWidth+"; SUPPRESS_UNUSED_WARNING("+outputWidth+");", - outputStructType+"** "+outputName+" = self->_lf_"+outputName+"_pointers;" - ); + CodeBuilder structBuilder = structs.get(port.getContainer()); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(port.getContainer(), structBuilder); + } + String reactorName = port.getContainer().getName(); + String reactorWidth = generateWidthVariable(reactorName); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + // First define the struct containing the output value and indicator + // of its presence. + if (!ASTUtils.isMultiport(output)) { + // Output is not a multiport. + structBuilder.pr(portStructType + "* " + outputName + ";"); + } else { + // Output is a multiport. + structBuilder.pr( + String.join( + "\n", portStructType + "** " + outputName + ";", "int " + outputWidth + ";")); + } - } + // Next, initialize the struct with the current values. + if (port.getContainer().getWidthSpec() != null) { + // Output is in a bank. + builder.pr( + String.join( + "\n", + "for (int i = 0; i < " + reactorWidth + "; i++) {", + " " + + reactorName + + "[i]." + + outputName + + " = self->_lf_" + + reactorName + + "[i]." + + outputName + + ";", + "}")); + if (ASTUtils.isMultiport(output)) { + builder.pr( + String.join( + "\n", + "for (int i = 0; i < " + reactorWidth + "; i++) {", + " " + + reactorName + + "[i]." + + outputWidth + + " = self->_lf_" + + reactorName + + "[i]." + + outputWidth + + ";", + "}")); + } + } else { + // Output is not in a bank. + builder.pr( + reactorName + + "." + + outputName + + " = self->_lf_" + + reactorName + + "." + + outputName + + ";"); + if (ASTUtils.isMultiport(output)) { + builder.pr( + reactorName + + "." + + outputWidth + + " = self->_lf_" + + reactorName + + "." + + outputWidth + + ";"); } + } } + } - /** - * Generate into the specified string builder the code to - * initialize local variables for watchdogs in a reaction function - * from the "self" struct. - * @param effect The effect declared by the reaction. This must refer to a watchdog. - * @param decl The reactor containing the reaction or the import statement. - */ - // Fine to have watchdog be in reactor self struct? - public static String generateWatchdogVariablesInReaction( - VarRef effect, - ReactorDecl decl - ) { - Watchdog watchdog = (Watchdog) effect.getVariable(); - String watchdogName = watchdog.getName(); + /** + * Generate action variables for a reaction. + * + * @param action The action. + * @param decl The reactor. + */ + private static String generateActionVariablesInReaction( + Action action, ReactorDecl decl, CTypes types) { + String structType = CGenerator.variableStructType(action, decl); + // If the action has a type, create variables for accessing the value. + InferredType type = ASTUtils.getInferredType(action); + // Pointer to the lf_token_t sent as the payload in the trigger. + String tokenPointer = "(self->_lf__" + action.getName() + ".tmplt.token)"; + CodeBuilder builder = new CodeBuilder(); - return String.join("\n", List.of( - "watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");" - )); + builder.pr( + String.join( + "\n", + "// Expose the action struct as a local variable whose name matches the action name.", + structType + "* " + action.getName() + " = &self->_lf_" + action.getName() + ";", + "// Set the fields of the action struct to match the current trigger.", + action.getName() + "->is_present = (bool)self->_lf__" + action.getName() + ".status;", + action.getName() + + "->has_value = (" + + tokenPointer + + " != NULL && " + + tokenPointer + + "->value != NULL);", + "_lf_replace_template_token((token_template_t*)" + + action.getName() + + ", " + + tokenPointer + + ");")); + // Set the value field only if there is a type. + if (!type.isUndefined()) { + // The value field will either be a copy (for primitive types) + // or a pointer (for types ending in *). + builder.pr("if (" + action.getName() + "->has_value) {"); + builder.indent(); + if (CUtil.isTokenType(type, types)) { + builder.pr( + action.getName() + + "->value = (" + + types.getTargetType(type) + + ")" + + tokenPointer + + "->value;"); + } else { + builder.pr( + action.getName() + + "->value = *(" + + types.getTargetType(type) + + "*)" + + tokenPointer + + "->value;"); + } + builder.unindent(); + builder.pr("}"); } + return builder.toString(); + } - /** - * Generate the fields of the self struct and statements for the constructor - * to create and initialize a reaction_t struct for each reaction in the - * specified reactor and a trigger_t struct for each trigger (input, action, - * timer, or output of a contained reactor). - * @param body The place to put the code for the self struct. - * @param decl The reactor. - * @param constructorCode The place to put the constructor code. - */ - public static void generateReactionAndTriggerStructs( - CodeBuilder body, - ReactorDecl decl, - CodeBuilder constructorCode, - CTypes types - ) { - var reactionCount = 0; - var reactor = ASTUtils.toDefinition(decl); - // Iterate over reactions and create initialize the reaction_t struct - // on the self struct. Also, collect a map from triggers to the reactions - // that are triggered by that trigger. Also, collect a set of sources - // that are read by reactions but do not trigger reactions. - // Finally, collect a set of triggers and sources that are outputs - // of contained reactors. - var triggerMap = new LinkedHashMap>(); - var sourceSet = new LinkedHashSet(); - var outputsOfContainedReactors = new LinkedHashMap(); - var startupReactions = new LinkedHashSet(); - var shutdownReactions = new LinkedHashSet(); - var resetReactions = new LinkedHashSet(); - // WATCHDOG QUESTION: Why need to grab all reactions from reactor only to check - // if it exists in currentFederate? - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - // Create the reaction_t struct. - body.pr(reaction, "reaction_t _lf__reaction_"+reactionCount+";"); + /** + * Generate into the specified string builder the code to initialize local variables for the + * specified input port in a reaction function from the "self" struct. + * + * @param input The input statement from the AST. + * @param decl The reactor. + */ + private static String generateInputVariablesInReaction( + Input input, ReactorDecl decl, CTypes types) { + String structType = CGenerator.variableStructType(input, decl); + InferredType inputType = ASTUtils.getInferredType(input); + CodeBuilder builder = new CodeBuilder(); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); - // Create the map of triggers to reactions. - for (TriggerRef trigger : reaction.getTriggers()) { - // trigger may not be a VarRef (it could be "startup" or "shutdown"). - if (trigger instanceof VarRef) { - var triggerAsVarRef = (VarRef) trigger; - var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); - if (reactionList == null) { - reactionList = new LinkedList<>(); - triggerMap.put(triggerAsVarRef.getVariable(), reactionList); - } - reactionList.add(reactionCount); - if (triggerAsVarRef.getContainer() != null) { - outputsOfContainedReactors.put(triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); - } - } else if (trigger instanceof BuiltinTriggerRef) { - switch(((BuiltinTriggerRef) trigger).getType()) { - case STARTUP: - startupReactions.add(reactionCount); - break; - case SHUTDOWN: - shutdownReactions.add(reactionCount); - break; - case RESET: - resetReactions.add(reactionCount); - break; - } - } - } - // Create the set of sources read but not triggering. - for (VarRef source : reaction.getSources()) { - sourceSet.add(source.getVariable()); - if (source.getContainer() != null) { - outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); - } - } + // Create the local variable whose name matches the input name. + // If the input has not been declared mutable, then this is a pointer + // to the upstream output. Otherwise, it is a copy of the upstream output, + // which nevertheless points to the same token and value (hence, as done + // below, we have to use lf_writable_copy()). There are 8 cases, + // depending on whether the input is mutable, whether it is a multiport, + // and whether it is a token type. + // Easy case first. + if (!input.isMutable() + && !CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, primitive type. + builder.pr(structType + "* " + inputName + " = self->_lf_" + inputName + ";"); + } else if (input.isMutable() + && !CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, primitive type. + builder.pr( + String.join( + "\n", + "// Mutable input, so copy the input into a temporary variable.", + "// The input value on the struct is a copy.", + structType + " _lf_tmp_" + inputName + " = *(self->_lf_" + inputName + ");", + structType + "* " + inputName + " = &_lf_tmp_" + inputName + ";")); + } else if (!input.isMutable() + && CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, token type. + builder.pr( + String.join( + "\n", + structType + "* " + inputName + " = self->_lf_" + inputName + ";", + "if (" + inputName + "->is_present) {", + " " + inputName + "->length = " + inputName + "->token->length;", + " " + + inputName + + "->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "->token->value;", + "} else {", + " " + inputName + "->length = 0;", + "}")); + } else if (input.isMutable() + && CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, token type. + builder.pr( + String.join( + "\n", + "// Mutable input, so copy the input struct into a temporary variable.", + structType + " _lf_tmp_" + inputName + " = *(self->_lf_" + inputName + ");", + structType + "* " + inputName + " = &_lf_tmp_" + inputName + ";", + inputName + "->value = NULL;", // Prevent payload from being freed. + "if (" + inputName + "->is_present) {", + " " + inputName + "->length = " + inputName + "->token->length;", + " " + + inputName + + "->token = lf_writable_copy((lf_port_base_t*)self->_lf_" + + inputName + + ");", + " " + + inputName + + "->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "->token->value;", + "} else {", + " " + inputName + "->length = 0;", + "}")); + } else if (!input.isMutable() && ASTUtils.isMultiport(input)) { + // Non-mutable, multiport, primitive or token type. + builder.pr(structType + "** " + inputName + " = self->_lf_" + inputName + ";"); + } else if (CUtil.isTokenType(inputType, types)) { + // Mutable, multiport, token type + builder.pr( + String.join( + "\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType + + " _lf_tmp_" + + inputName + + "[" + + CUtil.multiportWidthExpression(input) + + "];", + structType + "* " + inputName + "[" + CUtil.multiportWidthExpression(input) + "];", + "for (int i = 0; i < " + CUtil.multiportWidthExpression(input) + "; i++) {", + " " + inputName + "[i] = &_lf_tmp_" + inputName + "[i];", + " _lf_tmp_" + inputName + "[i] = *(self->_lf_" + inputName + "[i]);", + " // If necessary, copy the tokens.", + " if (" + inputName + "[i]->is_present) {", + " " + inputName + "[i]->length = " + inputName + "[i]->token->length;", + " token_template_t* _lf_input = (token_template_t*)self->_lf_" + + inputName + + "[i];", + " " + inputName + "[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", + " " + + inputName + + "[i]->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "[i]->token->value;", + " } else {", + " " + inputName + "[i]->length = 0;", + " }", + "}")); + } else { + // Mutable, multiport, primitive type + builder.pr( + String.join( + "\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType + + " _lf_tmp_" + + inputName + + "[" + + CUtil.multiportWidthExpression(input) + + "];", + structType + "* " + inputName + "[" + CUtil.multiportWidthExpression(input) + "];", + "for (int i = 0; i < " + CUtil.multiportWidthExpression(input) + "; i++) {", + " " + inputName + "[i] = &_lf_tmp_" + inputName + "[i];", + " // Copy the struct, which includes the value.", + " _lf_tmp_" + inputName + "[i] = *(self->_lf_" + inputName + "[i]);", + "}")); + } + // Set the _width variable for all cases. This will be -1 + // for a variable-width multiport, which is not currently supported. + // It will be -2 if it is not multiport. + builder.pr( + "int " + + inputWidth + + " = self->_lf_" + + inputWidth + + "; SUPPRESS_UNUSED_WARNING(" + + inputWidth + + ");"); + return builder.toString(); + } - var deadlineFunctionPointer = "NULL"; - if (reaction.getDeadline() != null) { - // The following has to match the name chosen in generateReactions - var deadlineFunctionName = generateDeadlineFunctionName(decl, reactionCount); - deadlineFunctionPointer = "&" + deadlineFunctionName; - } + /** + * Generate into the specified string builder the code to initialize local variables for outputs + * in a reaction function from the "self" struct. + * + * @param effect The effect declared by the reaction. This must refer to an output. + * @param decl The reactor containing the reaction or the import statement. + */ + public static String generateOutputVariablesInReaction( + VarRef effect, ReactorDecl decl, ErrorReporter errorReporter, boolean requiresTypes) { + Output output = (Output) effect.getVariable(); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + if (output.getType() == null && requiresTypes) { + errorReporter.reportError(output, "Output is required to have a type: " + outputName); + return ""; + } else { + // The container of the output may be a contained reactor or + // the reactor containing the reaction. + String outputStructType = + (effect.getContainer() == null) + ? CGenerator.variableStructType(output, decl) + : CGenerator.variableStructType(output, effect.getContainer().getReactorClass()); + if (!ASTUtils.isMultiport(output)) { + // Output port is not a multiport. + return outputStructType + "* " + outputName + " = &self->_lf_" + outputName + ";"; + } else { + // Output port is a multiport. + // Set the _width variable. + return String.join( + "\n", + "int " + + outputWidth + + " = self->_lf_" + + outputWidth + + "; SUPPRESS_UNUSED_WARNING(" + + outputWidth + + ");", + outputStructType + "** " + outputName + " = self->_lf_" + outputName + "_pointers;"); + } + } + } - // Assign the STP handler - var STPFunctionPointer = "NULL"; - if (reaction.getStp() != null) { - // The following has to match the name chosen in generateReactions - var STPFunctionName = generateStpFunctionName(decl, reactionCount); - STPFunctionPointer = "&" + STPFunctionName; - } + /** + * Generate into the specified string builder the code to initialize local variables for watchdogs + * in a reaction function from the "self" struct. + * + * @param effect The effect declared by the reaction. This must refer to a watchdog. + * @param decl The reactor containing the reaction or the import statement. + */ + // Fine to have watchdog be in reactor self struct? + public static String generateWatchdogVariablesInReaction(VarRef effect, ReactorDecl decl) { + Watchdog watchdog = (Watchdog) effect.getVariable(); + String watchdogName = watchdog.getName(); - // Set the defaults of the reaction_t struct in the constructor. - // Since the self struct is allocated using calloc, there is no need to set: - // self->_lf__reaction_"+reactionCount+".index = 0; - // self->_lf__reaction_"+reactionCount+".chain_id = 0; - // self->_lf__reaction_"+reactionCount+".pos = 0; - // self->_lf__reaction_"+reactionCount+".status = inactive; - // self->_lf__reaction_"+reactionCount+".deadline = 0LL; - // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; - constructorCode.pr(reaction, String.join("\n", - "self->_lf__reaction_"+reactionCount+".number = "+reactionCount+";", - "self->_lf__reaction_"+reactionCount+".function = "+CReactionGenerator.generateReactionFunctionName(decl, reactionCount)+";", - "self->_lf__reaction_"+reactionCount+".self = self;", - "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", - "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", - "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", - (reaction.eContainer() instanceof Mode ? - "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+reactor.getModes().indexOf((Mode) reaction.eContainer())+"];" : - "self->_lf__reaction_"+reactionCount+".mode = NULL;") - )); - // Increment the reactionCount even if the reaction is not in the federate - // so that reaction indices are consistent across federates. - reactionCount++; - } + return String.join( + "\n", + List.of("watchdog_t* " + watchdogName + " = &(self->_lf_watchdog_" + watchdogName + ");")); + } - // Next, create and initialize the trigger_t objects. - // Start with the timers. - for (Timer timer : ASTUtils.allTimers(reactor)) { - createTriggerT(body, timer, triggerMap, constructorCode, types); - // Since the self struct is allocated using calloc, there is no need to set falsy fields. - constructorCode.pr("self->_lf__"+timer.getName()+".is_timer = true;"); - constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+timer.getName()+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - } + /** + * Generate the fields of the self struct and statements for the constructor to create and + * initialize a reaction_t struct for each reaction in the specified reactor and a trigger_t + * struct for each trigger (input, action, timer, or output of a contained reactor). + * + * @param body The place to put the code for the self struct. + * @param decl The reactor. + * @param constructorCode The place to put the constructor code. + */ + public static void generateReactionAndTriggerStructs( + CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode, CTypes types) { + var reactionCount = 0; + var reactor = ASTUtils.toDefinition(decl); + // Iterate over reactions and create initialize the reaction_t struct + // on the self struct. Also, collect a map from triggers to the reactions + // that are triggered by that trigger. Also, collect a set of sources + // that are read by reactions but do not trigger reactions. + // Finally, collect a set of triggers and sources that are outputs + // of contained reactors. + var triggerMap = new LinkedHashMap>(); + var sourceSet = new LinkedHashSet(); + var outputsOfContainedReactors = new LinkedHashMap(); + var startupReactions = new LinkedHashSet(); + var shutdownReactions = new LinkedHashSet(); + var resetReactions = new LinkedHashSet(); + // WATCHDOG QUESTION: Why need to grab all reactions from reactor only to check + // if it exists in currentFederate? + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create the reaction_t struct. + body.pr(reaction, "reaction_t _lf__reaction_" + reactionCount + ";"); - // Handle builtin triggers. - if (startupReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); - } - // Handle shutdown triggers. - if (shutdownReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); + // Create the map of triggers to reactions. + for (TriggerRef trigger : reaction.getTriggers()) { + // trigger may not be a VarRef (it could be "startup" or "shutdown"). + if (trigger instanceof VarRef) { + var triggerAsVarRef = (VarRef) trigger; + var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); + if (reactionList == null) { + reactionList = new LinkedList<>(); + triggerMap.put(triggerAsVarRef.getVariable(), reactionList); + } + reactionList.add(reactionCount); + if (triggerAsVarRef.getContainer() != null) { + outputsOfContainedReactors.put( + triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); + } + } else if (trigger instanceof BuiltinTriggerRef) { + switch (((BuiltinTriggerRef) trigger).getType()) { + case STARTUP: + startupReactions.add(reactionCount); + break; + case SHUTDOWN: + shutdownReactions.add(reactionCount); + break; + case RESET: + resetReactions.add(reactionCount); + break; + } } - if (resetReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); + } + // Create the set of sources read but not triggering. + for (VarRef source : reaction.getSources()) { + sourceSet.add(source.getVariable()); + if (source.getContainer() != null) { + outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); } + } - // Next handle actions. - for (Action action : ASTUtils.allActions(reactor)) { - createTriggerT(body, action, triggerMap, constructorCode, types); - var isPhysical = "true"; - if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { - isPhysical = "false"; - } - var elementSize = "0"; - // If the action type is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) - : null; - if (rootType != null && !rootType.equals("void")) { - elementSize = "sizeof(" + rootType + ")"; - } + var deadlineFunctionPointer = "NULL"; + if (reaction.getDeadline() != null) { + // The following has to match the name chosen in generateReactions + var deadlineFunctionName = generateDeadlineFunctionName(decl, reactionCount); + deadlineFunctionPointer = "&" + deadlineFunctionName; + } - // Since the self struct is allocated using calloc, there is no need to set: - // self->_lf__"+action.getName()+".is_timer = false; - constructorCode.pr(String.join("\n", - "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", - (!(action.getPolicy() == null || action.getPolicy().isEmpty()) ? - "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" : - ""), - // Need to set the element_size in the trigger_t and the action struct. - "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize - + ";", - "self->_lf_" + action.getName() + ".type.element_size = " + elementSize + ";" - )); - } - - // Next handle inputs. - for (Input input : ASTUtils.allInputs(reactor)) { - createTriggerT(body, input, triggerMap, constructorCode, types); - } + // Assign the STP handler + var STPFunctionPointer = "NULL"; + if (reaction.getStp() != null) { + // The following has to match the name chosen in generateReactions + var STPFunctionName = generateStpFunctionName(decl, reactionCount); + STPFunctionPointer = "&" + STPFunctionName; + } - // Next handle watchdogs. - for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - createTriggerT(body, watchdog, triggerMap, constructorCode, types); - } + // Set the defaults of the reaction_t struct in the constructor. + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__reaction_"+reactionCount+".index = 0; + // self->_lf__reaction_"+reactionCount+".chain_id = 0; + // self->_lf__reaction_"+reactionCount+".pos = 0; + // self->_lf__reaction_"+reactionCount+".status = inactive; + // self->_lf__reaction_"+reactionCount+".deadline = 0LL; + // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; + constructorCode.pr( + reaction, + String.join( + "\n", + "self->_lf__reaction_" + reactionCount + ".number = " + reactionCount + ";", + "self->_lf__reaction_" + + reactionCount + + ".function = " + + CReactionGenerator.generateReactionFunctionName(decl, reactionCount) + + ";", + "self->_lf__reaction_" + reactionCount + ".self = self;", + "self->_lf__reaction_" + + reactionCount + + ".deadline_violation_handler = " + + deadlineFunctionPointer + + ";", + "self->_lf__reaction_" + reactionCount + ".STP_handler = " + STPFunctionPointer + ";", + "self->_lf__reaction_" + reactionCount + ".name = " + addDoubleQuotes("?") + ";", + (reaction.eContainer() instanceof Mode + ? "self->_lf__reaction_" + + reactionCount + + ".mode = &self->_lf__modes[" + + reactor.getModes().indexOf((Mode) reaction.eContainer()) + + "];" + : "self->_lf__reaction_" + reactionCount + ".mode = NULL;"))); + // Increment the reactionCount even if the reaction is not in the federate + // so that reaction indices are consistent across federates. + reactionCount++; } - /** - * Define the trigger_t object on the self struct, an array of - * reaction_t pointers pointing to reactions triggered by this variable, - * and initialize the pointers in the array in the constructor. - * @param body The place to write the self struct entries. - * @param variable The trigger variable (Timer, Watchdog, Action, or Input). - * @param triggerMap A map from Variables to a list of the reaction indices - * triggered by the variable. - * @param constructorCode The place to write the constructor code. - */ - private static void createTriggerT( - CodeBuilder body, - Variable variable, - LinkedHashMap> triggerMap, - CodeBuilder constructorCode, - CTypes types - ) { - var varName = variable.getName(); - // variable is a port, a timer, or an action. - body.pr(variable, "trigger_t _lf__"+varName+";"); - constructorCode.pr(variable, "self->_lf__"+varName+".last = NULL;"); - constructorCode.pr(variable, CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+varName+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - - // Generate the reactions triggered table. - var reactionsTriggered = triggerMap.get(variable); - if (reactionsTriggered != null) { - body.pr(variable, "reaction_t* _lf__"+varName+"_reactions["+reactionsTriggered.size()+"];"); - var count = 0; - for (Integer reactionTriggered : reactionsTriggered) { - constructorCode.prSourceLineNumber(variable); - constructorCode.pr(variable, "self->_lf__"+varName+"_reactions["+count+"] = &self->_lf__reaction_"+reactionTriggered+";"); - count++; - } - // Set up the trigger_t struct's pointer to the reactions. - constructorCode.pr(variable, String.join("\n", - "self->_lf__"+varName+".reactions = &self->_lf__"+varName+"_reactions[0];", - "self->_lf__"+varName+".number_of_reactions = "+count+";" - )); - - // If federated, set the physical_time_of_arrival - constructorCode.pr(variable, CExtensionUtils.surroundWithIfFederated( - "self->_lf__"+varName+".physical_time_of_arrival = NEVER;")); - } - if (variable instanceof Input) { - var rootType = CUtil.rootType(types.getTargetType((Input) variable)); - // Since the self struct is allocated using calloc, there is no need to set falsy fields. - // If the input type is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var size = (rootType.equals("void")) ? "0" : "sizeof("+rootType+")"; - - constructorCode.pr("self->_lf__"+varName+".tmplt.type.element_size = "+size+";"); - body.pr( - CExtensionUtils.surroundWithIfFederated( - CExtensionUtils.createPortStatusFieldForInput((Input) variable) - ) - ); - } + // Next, create and initialize the trigger_t objects. + // Start with the timers. + for (Timer timer : ASTUtils.allTimers(reactor)) { + createTriggerT(body, timer, triggerMap, constructorCode, types); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + constructorCode.pr("self->_lf__" + timer.getName() + ".is_timer = true;"); + constructorCode.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + + timer.getName() + + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); } - public static void generateBuiltinTriggeredReactionsArray( - Set reactions, - String name, - CodeBuilder body, - CodeBuilder constructorCode - ) { - body.pr(String.join("\n", - "trigger_t _lf__"+name+";", - "reaction_t* _lf__"+name+"_reactions["+reactions.size()+"];" - )); - constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+name+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - var i = 0; - for (Integer reactionIndex : reactions) { - constructorCode.pr("self->_lf__"+name+"_reactions["+i+++"] = &self->_lf__reaction_"+reactionIndex+";"); - } - constructorCode.pr(String.join("\n", - "self->_lf__"+name+".last = NULL;", - "self->_lf__"+name+".reactions = &self->_lf__"+name+"_reactions[0];", - "self->_lf__"+name+".number_of_reactions = "+reactions.size()+";", - "self->_lf__"+name+".is_timer = false;" - )); + // Handle builtin triggers. + if (startupReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); } - - public static String generateBuiltinTriggersTable(int reactionCount, String name) { - return String.join("\n", List.of( - "// Array of pointers to "+name+" triggers.", - (reactionCount > 0 ? - "reaction_t* _lf_"+name+"_reactions["+reactionCount+"]" : - "reaction_t** _lf_"+name+"_reactions = NULL") + ";", - "int _lf_"+name+"_reactions_size = "+reactionCount+";" - )); + // Handle shutdown triggers. + if (shutdownReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); + } + if (resetReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); } - /** - * Generate the _lf_trigger_startup_reactions function. - */ - public static String generateLfTriggerStartupReactions(int startupReactionCount, boolean hasModalReactors) { - var s = new StringBuilder(); - s.append("void _lf_trigger_startup_reactions() {"); - if (startupReactionCount > 0) { - s.append("\n"); - if (hasModalReactors) { - s.append(String.join("\n", - " for (int i = 0; i < _lf_startup_reactions_size; i++) {", - " if (_lf_startup_reactions[i] != NULL) {", - " if (_lf_startup_reactions[i]->mode != NULL) {", - " // Skip reactions in modes", - " continue;", - " }", - " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", - " }", - " }", - " _lf_handle_mode_startup_reset_reactions(", - " _lf_startup_reactions, _lf_startup_reactions_size,", - " NULL, 0,", - " _lf_modal_reactor_states, _lf_modal_reactor_states_size);" - )); - } else { - s.append(String.join("\n", - " for (int i = 0; i < _lf_startup_reactions_size; i++) {", - " if (_lf_startup_reactions[i] != NULL) {", - " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", - " }", - " }" - )); - } - s.append("\n"); - } - s.append("}\n"); - return s.toString(); + // Next handle actions. + for (Action action : ASTUtils.allActions(reactor)) { + createTriggerT(body, action, triggerMap, constructorCode, types); + var isPhysical = "true"; + if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { + isPhysical = "false"; + } + var elementSize = "0"; + // If the action type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) : null; + if (rootType != null && !rootType.equals("void")) { + elementSize = "sizeof(" + rootType + ")"; + } + + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__"+action.getName()+".is_timer = false; + constructorCode.pr( + String.join( + "\n", + "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", + (!(action.getPolicy() == null || action.getPolicy().isEmpty()) + ? "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" + : ""), + // Need to set the element_size in the trigger_t and the action struct. + "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize + ";", + "self->_lf_" + action.getName() + ".type.element_size = " + elementSize + ";")); } - /** - * Generate the _lf_trigger_shutdown_reactions function. - */ - public static String generateLfTriggerShutdownReactions(int shutdownReactionCount, boolean hasModalReactors) { - var s = new StringBuilder(); - s.append("bool _lf_trigger_shutdown_reactions() {\n"); - if (shutdownReactionCount > 0) { - if (hasModalReactors) { - s.append(String.join("\n", - " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", - " if (_lf_shutdown_reactions[i] != NULL) {", - " if (_lf_shutdown_reactions[i]->mode != NULL) {", - " // Skip reactions in modes", - " continue;", - " }", - " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", - " }", - " }", - " _lf_handle_mode_shutdown_reactions(_lf_shutdown_reactions, _lf_shutdown_reactions_size);", - " return true;" - )); - } else { - s.append(String.join("\n", - " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", - " if (_lf_shutdown_reactions[i] != NULL) {", - " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", - " }", - " }", - " return true;" - )); - } - s.append("\n"); - } else { - s.append(" return false;\n"); - } - s.append("}\n"); - return s.toString(); + // Next handle inputs. + for (Input input : ASTUtils.allInputs(reactor)) { + createTriggerT(body, input, triggerMap, constructorCode, types); } - /** - * Generate the _lf_handle_mode_triggered_reactions function. - */ - public static String generateLfModeTriggeredReactions( - int startupReactionCount, - int resetReactionCount, - boolean hasModalReactors - ) { - if (!hasModalReactors) { - return ""; - } - var s = new StringBuilder(); - s.append("void _lf_handle_mode_triggered_reactions() {\n"); - s.append(" _lf_handle_mode_startup_reset_reactions(\n"); - if (startupReactionCount > 0) { - s.append(" _lf_startup_reactions, _lf_startup_reactions_size,\n"); - } else { - s.append(" NULL, 0,\n"); - } - if (resetReactionCount > 0) { - s.append(" _lf_reset_reactions, _lf_reset_reactions_size,\n"); - } else { - s.append(" NULL, 0,\n"); - } - s.append(" _lf_modal_reactor_states, _lf_modal_reactor_states_size);\n"); - s.append("}\n"); - return s.toString(); + // Next handle watchdogs. + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + createTriggerT(body, watchdog, triggerMap, constructorCode, types); } + } - /** Generate a reaction function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param decl The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - public static String generateReaction( - Reaction reaction, - ReactorDecl decl, - int reactionIndex, - Instantiation mainDef, - ErrorReporter errorReporter, - CTypes types, - TargetConfig targetConfig, - boolean requiresType - ) { - var code = new CodeBuilder(); - var body = ASTUtils.toText(reaction.getCode()); - String init = generateInitializationForReaction( - body, reaction, decl, reactionIndex, - types, errorReporter, mainDef, - requiresType); - - String srcPrefix = targetConfig.platformOptions.platform == Platform.ARDUINO ? "src/" : ""; - code.pr( - "#include " + StringUtil.addDoubleQuotes( - srcPrefix + CCoreFilesUtils.getCTargetSetHeader())); - - CMethodGenerator.generateMacrosForMethods(ASTUtils.toDefinition(decl), code); - code.pr(generateFunction( - generateReactionFunctionHeader(decl, reactionIndex), - init, reaction.getCode() - )); - // Now generate code for the late function, if there is one - // Note that this function can only be defined on reactions - // in federates that have inputs from a logical connection. - if (reaction.getStp() != null) { - code.pr(generateFunction( - generateStpFunctionHeader(decl, reactionIndex), - init, reaction.getStp().getCode())); - } + /** + * Define the trigger_t object on the self struct, an array of reaction_t pointers pointing to + * reactions triggered by this variable, and initialize the pointers in the array in the + * constructor. + * + * @param body The place to write the self struct entries. + * @param variable The trigger variable (Timer, Watchdog, Action, or Input). + * @param triggerMap A map from Variables to a list of the reaction indices triggered by the + * variable. + * @param constructorCode The place to write the constructor code. + */ + private static void createTriggerT( + CodeBuilder body, + Variable variable, + LinkedHashMap> triggerMap, + CodeBuilder constructorCode, + CTypes types) { + var varName = variable.getName(); + // variable is a port, a timer, or an action. + body.pr(variable, "trigger_t _lf__" + varName + ";"); + constructorCode.pr(variable, "self->_lf__" + varName + ".last = NULL;"); + constructorCode.pr( + variable, + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + + varName + + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - // Now generate code for the deadline violation function, if there is one. - if (reaction.getDeadline() != null) { - code.pr(generateFunction( - generateDeadlineFunctionHeader(decl, reactionIndex), - init, reaction.getDeadline().getCode())); - } + // Generate the reactions triggered table. + var reactionsTriggered = triggerMap.get(variable); + if (reactionsTriggered != null) { + body.pr( + variable, + "reaction_t* _lf__" + varName + "_reactions[" + reactionsTriggered.size() + "];"); + var count = 0; + for (Integer reactionTriggered : reactionsTriggered) { + constructorCode.prSourceLineNumber(variable); + constructorCode.pr( + variable, + "self->_lf__" + + varName + + "_reactions[" + + count + + "] = &self->_lf__reaction_" + + reactionTriggered + + ";"); + count++; + } + // Set up the trigger_t struct's pointer to the reactions. + constructorCode.pr( + variable, + String.join( + "\n", + "self->_lf__" + varName + ".reactions = &self->_lf__" + varName + "_reactions[0];", + "self->_lf__" + varName + ".number_of_reactions = " + count + ";")); - CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(decl), code); - code.pr( - "#include " + StringUtil.addDoubleQuotes( - srcPrefix + CCoreFilesUtils.getCTargetSetUndefHeader())); - return code.toString(); + // If federated, set the physical_time_of_arrival + constructorCode.pr( + variable, + CExtensionUtils.surroundWithIfFederated( + "self->_lf__" + varName + ".physical_time_of_arrival = NEVER;")); } + if (variable instanceof Input) { + var rootType = CUtil.rootType(types.getTargetType((Input) variable)); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + // If the input type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var size = (rootType.equals("void")) ? "0" : "sizeof(" + rootType + ")"; - public static String generateFunction(String header, String init, Code code) { - var function = new CodeBuilder(); - function.pr(header + " {"); - function.indent(); - function.pr(init); - function.prSourceLineNumber(code); - function.pr(ASTUtils.toText(code)); - function.unindent(); - function.pr("}"); - return function.toString(); + constructorCode.pr("self->_lf__" + varName + ".tmplt.type.element_size = " + size + ";"); + body.pr( + CExtensionUtils.surroundWithIfFederated( + CExtensionUtils.createPortStatusFieldForInput((Input) variable))); } + } - /** - * Returns the name of the deadline function for reaction. - * @param decl The reactor with the deadline - * @param reactionIndex The number assigned to this reaction deadline - */ - public static String generateDeadlineFunctionName(ReactorDecl decl, int reactionIndex) { - return CUtil.getName(decl).toLowerCase() + "_deadline_function" + reactionIndex; + public static void generateBuiltinTriggeredReactionsArray( + Set reactions, String name, CodeBuilder body, CodeBuilder constructorCode) { + body.pr( + String.join( + "\n", + "trigger_t _lf__" + name + ";", + "reaction_t* _lf__" + name + "_reactions[" + reactions.size() + "];")); + constructorCode.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + name + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + var i = 0; + for (Integer reactionIndex : reactions) { + constructorCode.pr( + "self->_lf__" + + name + + "_reactions[" + + i++ + + "] = &self->_lf__reaction_" + + reactionIndex + + ";"); } + constructorCode.pr( + String.join( + "\n", + "self->_lf__" + name + ".last = NULL;", + "self->_lf__" + name + ".reactions = &self->_lf__" + name + "_reactions[0];", + "self->_lf__" + name + ".number_of_reactions = " + reactions.size() + ";", + "self->_lf__" + name + ".is_timer = false;")); + } - /** - * Return the function name for specified reaction of the - * specified reactor. - * @param reactor The reactor - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateReactionFunctionName(ReactorDecl reactor, int reactionIndex) { - return CUtil.getName(reactor).toLowerCase() + "reaction_function_" + reactionIndex; - } + public static String generateBuiltinTriggersTable(int reactionCount, String name) { + return String.join( + "\n", + List.of( + "// Array of pointers to " + name + " triggers.", + (reactionCount > 0 + ? "reaction_t* _lf_" + name + "_reactions[" + reactionCount + "]" + : "reaction_t** _lf_" + name + "_reactions = NULL") + + ";", + "int _lf_" + name + "_reactions_size = " + reactionCount + ";")); + } - /** - * Returns the name of the stp function for reaction. - * @param decl The reactor with the stp - * @param reactionIndex The number assigned to this reaction deadline - */ - public static String generateStpFunctionName(ReactorDecl decl, int reactionIndex) { - return CUtil.getName(decl).toLowerCase() + "_STP_function" + reactionIndex; + /** Generate the _lf_trigger_startup_reactions function. */ + public static String generateLfTriggerStartupReactions( + int startupReactionCount, boolean hasModalReactors) { + var s = new StringBuilder(); + s.append("void _lf_trigger_startup_reactions() {"); + if (startupReactionCount > 0) { + s.append("\n"); + if (hasModalReactors) { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_startup_reactions_size; i++) {", + " if (_lf_startup_reactions[i] != NULL) {", + " if (_lf_startup_reactions[i]->mode != NULL) {", + " // Skip reactions in modes", + " continue;", + " }", + " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", + " }", + " }", + " _lf_handle_mode_startup_reset_reactions(", + " _lf_startup_reactions, _lf_startup_reactions_size,", + " NULL, 0,", + " _lf_modal_reactor_states, _lf_modal_reactor_states_size);")); + } else { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_startup_reactions_size; i++) {", + " if (_lf_startup_reactions[i] != NULL) {", + " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", + " }", + " }")); + } + s.append("\n"); } + s.append("}\n"); + return s.toString(); + } - /** Return the top level C function header for the deadline function numbered "reactionIndex" in "decl" - * @param decl The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the deadline function. - */ - public static String generateDeadlineFunctionHeader(ReactorDecl decl, - int reactionIndex) { - String functionName = generateDeadlineFunctionName(decl, reactionIndex); - return generateFunctionHeader(functionName); + /** Generate the _lf_trigger_shutdown_reactions function. */ + public static String generateLfTriggerShutdownReactions( + int shutdownReactionCount, boolean hasModalReactors) { + var s = new StringBuilder(); + s.append("bool _lf_trigger_shutdown_reactions() {\n"); + if (shutdownReactionCount > 0) { + if (hasModalReactors) { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", + " if (_lf_shutdown_reactions[i] != NULL) {", + " if (_lf_shutdown_reactions[i]->mode != NULL) {", + " // Skip reactions in modes", + " continue;", + " }", + " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", + " }", + " }", + " _lf_handle_mode_shutdown_reactions(_lf_shutdown_reactions," + + " _lf_shutdown_reactions_size);", + " return true;")); + } else { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", + " if (_lf_shutdown_reactions[i] != NULL) {", + " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", + " }", + " }", + " return true;")); + } + s.append("\n"); + } else { + s.append(" return false;\n"); } + s.append("}\n"); + return s.toString(); + } - /** Return the top level C function header for the reaction numbered "reactionIndex" in "decl" - * @param decl The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateReactionFunctionHeader(ReactorDecl decl, - int reactionIndex) { - String functionName = generateReactionFunctionName(decl, reactionIndex); - return generateFunctionHeader(functionName); + /** Generate the _lf_handle_mode_triggered_reactions function. */ + public static String generateLfModeTriggeredReactions( + int startupReactionCount, int resetReactionCount, boolean hasModalReactors) { + if (!hasModalReactors) { + return ""; + } + var s = new StringBuilder(); + s.append("void _lf_handle_mode_triggered_reactions() {\n"); + s.append(" _lf_handle_mode_startup_reset_reactions(\n"); + if (startupReactionCount > 0) { + s.append(" _lf_startup_reactions, _lf_startup_reactions_size,\n"); + } else { + s.append(" NULL, 0,\n"); } + if (resetReactionCount > 0) { + s.append(" _lf_reset_reactions, _lf_reset_reactions_size,\n"); + } else { + s.append(" NULL, 0,\n"); + } + s.append(" _lf_modal_reactor_states, _lf_modal_reactor_states_size);\n"); + s.append("}\n"); + return s.toString(); + } + + /** + * Generate a reaction function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param decl The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + public static String generateReaction( + Reaction reaction, + ReactorDecl decl, + int reactionIndex, + Instantiation mainDef, + ErrorReporter errorReporter, + CTypes types, + TargetConfig targetConfig, + boolean requiresType) { + var code = new CodeBuilder(); + var body = ASTUtils.toText(reaction.getCode()); + String init = + generateInitializationForReaction( + body, reaction, decl, reactionIndex, types, errorReporter, mainDef, requiresType); + + String srcPrefix = targetConfig.platformOptions.platform == Platform.ARDUINO ? "src/" : ""; + code.pr( + "#include " + + StringUtil.addDoubleQuotes(srcPrefix + CCoreFilesUtils.getCTargetSetHeader())); - public static String generateStpFunctionHeader(ReactorDecl decl, - int reactionIndex) { - String functionName = generateStpFunctionName(decl, reactionIndex); - return generateFunctionHeader(functionName); + CMethodGenerator.generateMacrosForMethods(ASTUtils.toDefinition(decl), code); + code.pr( + generateFunction( + generateReactionFunctionHeader(decl, reactionIndex), init, reaction.getCode())); + // Now generate code for the late function, if there is one + // Note that this function can only be defined on reactions + // in federates that have inputs from a logical connection. + if (reaction.getStp() != null) { + code.pr( + generateFunction( + generateStpFunctionHeader(decl, reactionIndex), init, reaction.getStp().getCode())); } - public static String generateFunctionHeader(String functionName) { - return "void " + functionName + "(void* instance_args)"; + // Now generate code for the deadline violation function, if there is one. + if (reaction.getDeadline() != null) { + code.pr( + generateFunction( + generateDeadlineFunctionHeader(decl, reactionIndex), + init, + reaction.getDeadline().getCode())); } + + CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(decl), code); + code.pr( + "#include " + + StringUtil.addDoubleQuotes(srcPrefix + CCoreFilesUtils.getCTargetSetUndefHeader())); + return code.toString(); + } + + public static String generateFunction(String header, String init, Code code) { + var function = new CodeBuilder(); + function.pr(header + " {"); + function.indent(); + function.pr(init); + function.prSourceLineNumber(code); + function.pr(ASTUtils.toText(code)); + function.unindent(); + function.pr("}"); + return function.toString(); + } + + /** + * Returns the name of the deadline function for reaction. + * + * @param decl The reactor with the deadline + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateDeadlineFunctionName(ReactorDecl decl, int reactionIndex) { + return CUtil.getName(decl).toLowerCase() + "_deadline_function" + reactionIndex; + } + + /** + * Return the function name for specified reaction of the specified reactor. + * + * @param reactor The reactor + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionName(ReactorDecl reactor, int reactionIndex) { + return CUtil.getName(reactor).toLowerCase() + "reaction_function_" + reactionIndex; + } + + /** + * Returns the name of the stp function for reaction. + * + * @param decl The reactor with the stp + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateStpFunctionName(ReactorDecl decl, int reactionIndex) { + return CUtil.getName(decl).toLowerCase() + "_STP_function" + reactionIndex; + } + + /** + * Return the top level C function header for the deadline function numbered "reactionIndex" in + * "decl" + * + * @param decl The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the deadline function. + */ + public static String generateDeadlineFunctionHeader(ReactorDecl decl, int reactionIndex) { + String functionName = generateDeadlineFunctionName(decl, reactionIndex); + return generateFunctionHeader(functionName); + } + + /** + * Return the top level C function header for the reaction numbered "reactionIndex" in "decl" + * + * @param decl The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionHeader(ReactorDecl decl, int reactionIndex) { + String functionName = generateReactionFunctionName(decl, reactionIndex); + return generateFunctionHeader(functionName); + } + + public static String generateStpFunctionHeader(ReactorDecl decl, int reactionIndex) { + String functionName = generateStpFunctionName(decl, reactionIndex); + return generateFunctionHeader(functionName); + } + + public static String generateFunctionHeader(String functionName) { + return "void " + functionName + "(void* instance_args)"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 9163883962..6ad7f405eb 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -1,19 +1,14 @@ package org.lflang.generator.c; +import java.util.List; import org.lflang.ASTUtils; import org.lflang.generator.CodeBuilder; +import org.lflang.lf.Mode; +import org.lflang.lf.ModeTransition; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; - -import org.lflang.lf.Reactor; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; -import org.lflang.lf.Mode; -import org.lflang.lf.ModeTransition; -import org.lflang.lf.Watchdog; -import org.lflang.generator.GeneratorBase; -import org.lflang.generator.c.CReactionGenerator; -import java.util.List; import org.lflang.lf.Watchdog; /** @@ -21,202 +16,223 @@ * * @author{Benjamin Asch } */ - public class CWatchdogGenerator { - /** - * Generate necessary initialization code inside the body of the watchdog that belongs to reactor decl. - * @param decl The reactor that has the watchdog - */ - public static String generateInitializationForWatchdog(Watchdog watchdog, - ReactorDecl decl) { - Reactor reactor = ASTUtils.toDefinition(decl); - - // Construct the reactionInitialization code to go into - // the body of the function before the verbatim code. - CodeBuilder watchdogInitialization = new CodeBuilder(); - - CodeBuilder code = new CodeBuilder(); - - // Define the "self" struct. - String structType = CUtil.selfType(decl); - // A null structType means there are no inputs, state, - // or anything else. No need to declare it. - if (structType != null) { - code.pr(String.join("\n", - structType+"* self = ("+structType+"*)instance_args; SUPPRESS_UNUSED_WARNING(self);" - )); - } - - // Declare mode if in effects field of watchdog - if (watchdog.getEffects() != null) { - for (VarRef effect : watchdog.getEffects()) { - Variable variable = effect.getVariable(); - if (variable instanceof Mode) { - // Mode change effect - int idx = ASTUtils.allModes(reactor).indexOf((Mode)effect.getVariable()); - String name = effect.getVariable().getName(); - if (idx >= 0) { - watchdogInitialization.pr( - "reactor_mode_t* " + name + " = &self->_lf__modes[" + idx + "];\n" - + "lf_mode_change_type_t _lf_" + name + "_change_type = " - + (effect.getTransition() == ModeTransition.HISTORY ? - "history_transition" : "reset_transition") - + ";" - ); - } - // FIXME: include error reporter - // else { - // errorReporter.reportError( - // watchdog, - // "In generateWatchdog(): " + name + " not a valid mode of this reactor." - // ); - // } - } - } - } - // Add watchdog definition - watchdogInitialization.pr("watchdog_t* "+watchdog.getName()+" = &(self->_lf_watchdog_"+watchdog.getName()+");\n"); - - // Next generate all the collected setup code. - code.pr(watchdogInitialization.toString()); - return code.toString(); + /** + * Generate necessary initialization code inside the body of the watchdog that belongs to reactor + * decl. + * + * @param decl The reactor that has the watchdog + */ + public static String generateInitializationForWatchdog(Watchdog watchdog, ReactorDecl decl) { + Reactor reactor = ASTUtils.toDefinition(decl); + + // Construct the reactionInitialization code to go into + // the body of the function before the verbatim code. + CodeBuilder watchdogInitialization = new CodeBuilder(); + + CodeBuilder code = new CodeBuilder(); + + // Define the "self" struct. + String structType = CUtil.selfType(decl); + // A null structType means there are no inputs, state, + // or anything else. No need to declare it. + if (structType != null) { + code.pr( + String.join( + "\n", + structType + + "* self = (" + + structType + + "*)instance_args; SUPPRESS_UNUSED_WARNING(self);")); } - /** - * Returns the name of the watchdog function for reaction. - * @param decl The reactor with the watchdog - * @param watchdog The watchdog - * @return Name of the watchdog function for reaction - */ - public static String generateWatchdogFunctionName(Watchdog watchdog, ReactorDecl decl) { - return decl.getName().toLowerCase() + "_" + watchdog.getName().toLowerCase() + "_watchdog_function"; - } - - /** Return the top level C function header for the watchdog function in "decl" - * @param decl The reactor declaration - * @param watchdog The watchdog. - * @return The function name for the watchdog function. - */ - public static String generateWatchdogFunctionHeader(Watchdog watchdog, - ReactorDecl decl) { - String functionName = generateWatchdogFunctionName(watchdog, decl); - return CReactionGenerator.generateFunctionHeader(functionName); - } - - /** - * Generate the watchdog function. - */ - public static String generateWatchdogFunction(Watchdog watchdog, - ReactorDecl decl) { - return generateFunction(generateWatchdogFunctionHeader(watchdog, decl), - generateInitializationForWatchdog(watchdog, decl), - watchdog); - } - - /** - * Do heavy lifting to generate above watchdog function - * @param header function name and declaration. - * @param init initialize variable. - * @param watchdog The watchdog. - */ - public static String generateFunction(String header, String init, Watchdog watchdog) { - var function = new CodeBuilder(); - function.pr(header + " {"); - function.indent(); - function.pr(init);function.pr("_lf_schedule((*"+watchdog.getName()+").trigger, 0, NULL);"); - function.prSourceLineNumber(watchdog.getCode()); - function.pr(ASTUtils.toText(watchdog.getCode())); - function.unindent(); - function.pr("}"); - return function.toString(); - } - - - /** - * Generate watchdog definition in parent struct. - */ - public static void generateWatchdogStruct( - CodeBuilder body, - ReactorDecl decl, - CodeBuilder constructorCode - ) { - var reactor = ASTUtils.toDefinition(decl); - - for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - String watchdogName = watchdog.getName(); - - body.pr(watchdog, "watchdog_t _lf_watchdog_"+watchdogName+";"); - - // watchdog function name - var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); - // Set values of watchdog_t struct in the reactor's constructor - //FIXME: update parameters - // constructorCode.pr("#ifdef LF_THREADED"); - constructorCode.pr(watchdog, String.join("\n", - "self->_lf_watchdog_"+watchdogName+".base = &(self->base);", - "self->_lf_watchdog_"+watchdogName+".expiration = NEVER;", - "self->_lf_watchdog_"+watchdogName+".thread_active = false;", - // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", - "self->_lf_watchdog_"+watchdogName+".watchdog_function = "+watchdogFunctionName+";", - "self->_lf_watchdog_"+watchdogName+".trigger = &(self->_lf__"+watchdogName+");" - )); - - + // Declare mode if in effects field of watchdog + if (watchdog.getEffects() != null) { + for (VarRef effect : watchdog.getEffects()) { + Variable variable = effect.getVariable(); + if (variable instanceof Mode) { + // Mode change effect + int idx = ASTUtils.allModes(reactor).indexOf((Mode) effect.getVariable()); + String name = effect.getVariable().getName(); + if (idx >= 0) { + watchdogInitialization.pr( + "reactor_mode_t* " + + name + + " = &self->_lf__modes[" + + idx + + "];\n" + + "lf_mode_change_type_t _lf_" + + name + + "_change_type = " + + (effect.getTransition() == ModeTransition.HISTORY + ? "history_transition" + : "reset_transition") + + ";"); + } + // FIXME: include error reporter + // else { + // errorReporter.reportError( + // watchdog, + // "In generateWatchdog(): " + name + " not a valid mode of this reactor." + // ); + // } } + } } - - /** Generate a watchdog function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param watchdog The watchdog. - * @param decl The reactor. - */ - public static String generateWatchdog( - Watchdog watchdog, - ReactorDecl decl - ) { - var code = new CodeBuilder(); - - code.pr(generateWatchdogFunction(watchdog, decl)); - - return code.toString(); + // Add watchdog definition + watchdogInitialization.pr( + "watchdog_t* " + + watchdog.getName() + + " = &(self->_lf_watchdog_" + + watchdog.getName() + + ");\n"); + + // Next generate all the collected setup code. + code.pr(watchdogInitialization.toString()); + return code.toString(); + } + + /** + * Returns the name of the watchdog function for reaction. + * + * @param decl The reactor with the watchdog + * @param watchdog The watchdog + * @return Name of the watchdog function for reaction + */ + public static String generateWatchdogFunctionName(Watchdog watchdog, ReactorDecl decl) { + return decl.getName().toLowerCase() + + "_" + + watchdog.getName().toLowerCase() + + "_watchdog_function"; + } + + /** + * Return the top level C function header for the watchdog function in "decl" + * + * @param decl The reactor declaration + * @param watchdog The watchdog. + * @return The function name for the watchdog function. + */ + public static String generateWatchdogFunctionHeader(Watchdog watchdog, ReactorDecl decl) { + String functionName = generateWatchdogFunctionName(watchdog, decl); + return CReactionGenerator.generateFunctionHeader(functionName); + } + + /** Generate the watchdog function. */ + public static String generateWatchdogFunction(Watchdog watchdog, ReactorDecl decl) { + return generateFunction( + generateWatchdogFunctionHeader(watchdog, decl), + generateInitializationForWatchdog(watchdog, decl), + watchdog); + } + + /** + * Do heavy lifting to generate above watchdog function + * + * @param header function name and declaration. + * @param init initialize variable. + * @param watchdog The watchdog. + */ + public static String generateFunction(String header, String init, Watchdog watchdog) { + var function = new CodeBuilder(); + function.pr(header + " {"); + function.indent(); + function.pr(init); + function.pr("_lf_schedule((*" + watchdog.getName() + ").trigger, 0, NULL);"); + function.prSourceLineNumber(watchdog.getCode()); + function.pr(ASTUtils.toText(watchdog.getCode())); + function.unindent(); + function.pr("}"); + return function.toString(); + } + + /** Generate watchdog definition in parent struct. */ + public static void generateWatchdogStruct( + CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode) { + var reactor = ASTUtils.toDefinition(decl); + + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + String watchdogName = watchdog.getName(); + + body.pr(watchdog, "watchdog_t _lf_watchdog_" + watchdogName + ";"); + + // watchdog function name + var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); + // Set values of watchdog_t struct in the reactor's constructor + // FIXME: update parameters + // constructorCode.pr("#ifdef LF_THREADED"); + constructorCode.pr( + watchdog, + String.join( + "\n", + "self->_lf_watchdog_" + watchdogName + ".base = &(self->base);", + "self->_lf_watchdog_" + watchdogName + ".expiration = NEVER;", + "self->_lf_watchdog_" + watchdogName + ".thread_active = false;", + // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", + "self->_lf_watchdog_" + + watchdogName + + ".watchdog_function = " + + watchdogFunctionName + + ";", + "self->_lf_watchdog_" + + watchdogName + + ".trigger = &(self->_lf__" + + watchdogName + + ");")); } - - public static String generateBuiltinTriggersTable(int count, String name) { - return String.join("\n", List.of( - "// Array of pointers to "+name+" triggers.", + } + + /** + * Generate a watchdog function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param watchdog The watchdog. + * @param decl The reactor. + */ + public static String generateWatchdog(Watchdog watchdog, ReactorDecl decl) { + var code = new CodeBuilder(); + + code.pr(generateWatchdogFunction(watchdog, decl)); + + return code.toString(); + } + + public static String generateBuiltinTriggersTable(int count, String name) { + return String.join( + "\n", + List.of( + "// Array of pointers to " + name + " triggers.", "#ifdef LF_THREADED", - (count > 0 ? - " watchdog_t* _lf_"+name+"s["+count+"]" : - " watchdog_t* _lf_"+name+"s = NULL") + ";", - " int _lf_"+name+"_number = "+count+";", - "#endif" - )); - } - - /** - * Generate _lf_initialize_watchdog_mutexes function. - */ - //FIXME: finish implementing - public static String generateLfInitializeWatchdogMutexes(int watchdogCount) { - var s = new StringBuilder(); - s.append("void _lf_initialize_watchdog_mutexes() {"); - if (watchdogCount > 0) { - s.append("\n"); - s.append(String.join("\n", - " for (int i = 0; i < _lf_watchdog_number; i++) {", - " self_base_t* current_base = _lf_watchdogs[i]->base;", - " if (&(current_base->watchdog_mutex) == NULL) {", - " lf_mutex_init(&(current_base->watchdog_mutex));", - " current_base->has_watchdog = true;", - " }", - " }" - )); - } - s.append("\n"); - s.append("}\n"); - return s.toString(); + (count > 0 + ? " watchdog_t* _lf_" + name + "s[" + count + "]" + : " watchdog_t* _lf_" + name + "s = NULL") + + ";", + " int _lf_" + name + "_number = " + count + ";", + "#endif")); + } + + /** Generate _lf_initialize_watchdog_mutexes function. */ + // FIXME: finish implementing + public static String generateLfInitializeWatchdogMutexes(int watchdogCount) { + var s = new StringBuilder(); + s.append("void _lf_initialize_watchdog_mutexes() {"); + if (watchdogCount > 0) { + s.append("\n"); + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_watchdog_number; i++) {", + " self_base_t* current_base = _lf_watchdogs[i]->base;", + " if (&(current_base->watchdog_mutex) == NULL) {", + " lf_mutex_init(&(current_base->watchdog_mutex));", + " current_base->has_watchdog = true;", + " }", + " }")); } + s.append("\n"); + s.append("}\n"); + return s.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 2767a05b9c..442afd79f3 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -34,17 +34,14 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; - import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.Target; import org.lflang.TargetProperty; import org.lflang.generator.CodeBuilder; import org.lflang.generator.CodeMap; - import org.lflang.generator.GeneratorResult; import org.lflang.generator.IntegratedBuilder; import org.lflang.generator.LFGeneratorContext; @@ -62,541 +59,517 @@ import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; -import org.lflang.lf.Watchdog; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; import org.lflang.util.StringUtil; - /** - * Generator for Python target. This class generates Python code defining each - * reactor - * class given in the input .lf file and imported .lf files. + * Generator for Python target. This class generates Python code defining each reactor class given + * in the input .lf file and imported .lf files. * - * Each class will contain all the reaction functions defined by the user in - * order, with the necessary ports/actions given as parameters. - * Moreover, each class will contain all state variables in native Python - * format. + *

Each class will contain all the reaction functions defined by the user in order, with the + * necessary ports/actions given as parameters. Moreover, each class will contain all state + * variables in native Python format. * - * A backend is also generated using the CGenerator that interacts with the C - * code library (see CGenerator.xtend). - * The backend is responsible for passing arguments to the Python reactor + *

A backend is also generated using the CGenerator that interacts with the C code library (see + * CGenerator.xtend). The backend is responsible for passing arguments to the Python reactor * functions. * * @author Soroush Bateni */ public class PythonGenerator extends CGenerator { - // Used to add statements that come before reactor classes and user code - private final CodeBuilder pythonPreamble = new CodeBuilder(); - - // Used to add module requirements to setup.py (delimited with ,) - private final List pythonRequiredModules = new ArrayList<>(); - - private final PythonTypes types; - - public PythonGenerator(LFGeneratorContext context) { - this(context, - new PythonTypes(), - new CCmakeGenerator( - context.getFileConfig(), - List.of("lib/python_action.c", - "lib/python_port.c", - "lib/python_tag.c", - "lib/python_time.c", - "lib/pythontarget.c" - ), - PythonGenerator::setUpMainTarget, - "install(TARGETS)" // No-op - ) - ); - } - - - private PythonGenerator(LFGeneratorContext context, PythonTypes types, CCmakeGenerator cmakeGenerator) { - super(context, false, types, cmakeGenerator, new PythonDelayBodyGenerator(types)); - this.targetConfig.compiler = "gcc"; - this.targetConfig.compilerFlags = new ArrayList<>(); - this.targetConfig.linkerFlags = ""; - this.types = types; - } - - /** - * Generic struct for ports with primitive types and - * statically allocated arrays in Lingua Franca. - * This template is defined as - * typedef struct { - * bool is_present; - * lf_sparse_io_record_t* sparse_record; // NULL if there is no sparse record. - * int destination_channel; // -1 if there is no destination. - * PyObject* value; - * int num_destinations; - * lf_token_t* token; - * int length; - * void (*destructor) (void* value); - * void* (*copy_constructor) (void* value); - * FEDERATED_GENERIC_EXTENSION - * } generic_port_instance_struct; - * - * See reactor-c-py/lib/pythontarget.h for details. - */ - String genericPortType = "generic_port_instance_struct"; - - /** - * Generic struct for actions. - * This template is defined as - * typedef struct { - * trigger_t* trigger; - * PyObject* value; - * bool is_present; - * bool has_value; - * lf_token_t* token; - * FEDERATED_CAPSULE_EXTENSION - * } generic_action_instance_struct; - * - * See reactor-c-py/lib/pythontarget.h for details. - */ - String genericActionType = "generic_action_instance_struct"; - - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.Python; + // Used to add statements that come before reactor classes and user code + private final CodeBuilder pythonPreamble = new CodeBuilder(); + + // Used to add module requirements to setup.py (delimited with ,) + private final List pythonRequiredModules = new ArrayList<>(); + + private final PythonTypes types; + + public PythonGenerator(LFGeneratorContext context) { + this( + context, + new PythonTypes(), + new CCmakeGenerator( + context.getFileConfig(), + List.of( + "lib/python_action.c", + "lib/python_port.c", + "lib/python_tag.c", + "lib/python_time.c", + "lib/pythontarget.c"), + PythonGenerator::setUpMainTarget, + "install(TARGETS)" // No-op + )); + } + + private PythonGenerator( + LFGeneratorContext context, PythonTypes types, CCmakeGenerator cmakeGenerator) { + super(context, false, types, cmakeGenerator, new PythonDelayBodyGenerator(types)); + this.targetConfig.compiler = "gcc"; + this.targetConfig.compilerFlags = new ArrayList<>(); + this.targetConfig.linkerFlags = ""; + this.types = types; + } + + /** + * Generic struct for ports with primitive types and statically allocated arrays in Lingua Franca. + * This template is defined as typedef struct { bool is_present; lf_sparse_io_record_t* + * sparse_record; // NULL if there is no sparse record. int destination_channel; // -1 if there is + * no destination. PyObject* value; int num_destinations; lf_token_t* token; int length; void + * (*destructor) (void* value); void* (*copy_constructor) (void* value); + * FEDERATED_GENERIC_EXTENSION } generic_port_instance_struct; + * + *

See reactor-c-py/lib/pythontarget.h for details. + */ + String genericPortType = "generic_port_instance_struct"; + + /** + * Generic struct for actions. This template is defined as typedef struct { trigger_t* trigger; + * PyObject* value; bool is_present; bool has_value; lf_token_t* token; + * FEDERATED_CAPSULE_EXTENSION } generic_action_instance_struct; + * + *

See reactor-c-py/lib/pythontarget.h for details. + */ + String genericActionType = "generic_action_instance_struct"; + + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.Python; + } + + private final Set protoNames = new HashSet<>(); + + // ////////////////////////////////////////// + // // Public methods + @Override + public TargetTypes getTargetTypes() { + return types; + } + + // ////////////////////////////////////////// + // // Protected methods + + /** Generate all Python classes if they have a reaction */ + public String generatePythonReactorClasses() { + CodeBuilder pythonClasses = new CodeBuilder(); + CodeBuilder pythonClassesInstantiation = new CodeBuilder(); + + // Generate reactor classes in Python + pythonClasses.pr(PythonReactorGenerator.generatePythonClass(main, main, types)); + + // Create empty lists to hold reactor instances + pythonClassesInstantiation.pr(PythonReactorGenerator.generateListsToHoldClassInstances(main)); + + // Instantiate generated classes + pythonClassesInstantiation.pr( + PythonReactorGenerator.generatePythonClassInstantiations(main, main)); + + return String.join( + "\n", + pythonClasses.toString(), + "", + "# Instantiate classes", + pythonClassesInstantiation.toString()); + } + + /** + * Generate the Python code constructed from reactor classes and user-written classes. + * + * @return the code body + */ + public String generatePythonCode(String pyModuleName) { + return String.join( + "\n", + "import os", + "import sys", + "sys.path.append(os.path.dirname(__file__))", + "# List imported names, but do not use pylint's --extension-pkg-allow-list option", + "# so that these names will be assumed present without having to compile and install.", + "# pylint: disable=no-name-in-module, import-error", + "from " + pyModuleName + " import (", + " Tag, action_capsule_t, port_capsule, request_stop, schedule_copy, start", + ")", + "# pylint: disable=c-extension-no-member", + "import " + pyModuleName + " as lf", + "try:", + " from LinguaFrancaBase.constants import BILLION, FOREVER, NEVER, instant_t, interval_t", + " from LinguaFrancaBase.functions import (", + " DAY, DAYS, HOUR, HOURS, MINUTE, MINUTES, MSEC, MSECS, NSEC, NSECS, SEC, SECS," + + " USEC,", + " USECS, WEEK, WEEKS", + " )", + " from LinguaFrancaBase.classes import Make", + "except ModuleNotFoundError:", + " print(\"No module named 'LinguaFrancaBase'. \"", + " \"Install using \\\"pip3 install LinguaFrancaBase\\\".\")", + " sys.exit(1)", + "import copy", + "", + pythonPreamble.toString(), + "", + generatePythonReactorClasses(), + "", + PythonMainFunctionGenerator.generateCode()); + } + + /** Generate the necessary Python files. */ + public Map generatePythonFiles( + String lfModuleName, String pyModuleName, String pyFileName) throws IOException { + Path filePath = fileConfig.getSrcGenPath().resolve(pyFileName); + File file = filePath.toFile(); + Files.deleteIfExists(filePath); + // Create the necessary directories + if (!file.getParentFile().exists()) { + if (!file.getParentFile().mkdirs()) { + throw new IOException( + "Failed to create directories required for the Python code generator."); + } } - - private final Set protoNames = new HashSet<>(); - - // ////////////////////////////////////////// - // // Public methods - @Override - public TargetTypes getTargetTypes() { - return types; - } - - // ////////////////////////////////////////// - // // Protected methods - - /** - * Generate all Python classes if they have a reaction - * - */ - public String generatePythonReactorClasses() { - CodeBuilder pythonClasses = new CodeBuilder(); - CodeBuilder pythonClassesInstantiation = new CodeBuilder(); - - // Generate reactor classes in Python - pythonClasses.pr(PythonReactorGenerator.generatePythonClass(main, main, types)); - - // Create empty lists to hold reactor instances - pythonClassesInstantiation.pr(PythonReactorGenerator.generateListsToHoldClassInstances(main)); - - // Instantiate generated classes - pythonClassesInstantiation.pr(PythonReactorGenerator.generatePythonClassInstantiations(main, main)); - - return String.join("\n", - pythonClasses.toString(), - "", - "# Instantiate classes", - pythonClassesInstantiation.toString() - ); - } - - /** - * Generate the Python code constructed from reactor classes and - * user-written classes. - * - * @return the code body - */ - public String generatePythonCode(String pyModuleName) { - return String.join("\n", - "import os", - "import sys", - "sys.path.append(os.path.dirname(__file__))", - "# List imported names, but do not use pylint's --extension-pkg-allow-list option", - "# so that these names will be assumed present without having to compile and install.", - "# pylint: disable=no-name-in-module, import-error", - "from "+pyModuleName+" import (", - " Tag, action_capsule_t, port_capsule, request_stop, schedule_copy, start", - ")", - "# pylint: disable=c-extension-no-member", - "import "+pyModuleName+" as lf", - "try:", - " from LinguaFrancaBase.constants import BILLION, FOREVER, NEVER, instant_t, interval_t", - " from LinguaFrancaBase.functions import (", - " DAY, DAYS, HOUR, HOURS, MINUTE, MINUTES, MSEC, MSECS, NSEC, NSECS, SEC, SECS, USEC,", - " USECS, WEEK, WEEKS", - " )", - " from LinguaFrancaBase.classes import Make", - "except ModuleNotFoundError:", - " print(\"No module named 'LinguaFrancaBase'. \"", - " \"Install using \\\"pip3 install LinguaFrancaBase\\\".\")", - " sys.exit(1)", - "import copy", - "", - pythonPreamble.toString(), - "", - generatePythonReactorClasses(), - "", - PythonMainFunctionGenerator.generateCode() - ); - } - - /** - * Generate the necessary Python files. - */ - public Map generatePythonFiles( - String lfModuleName, - String pyModuleName, - String pyFileName - ) throws IOException { - Path filePath = fileConfig.getSrcGenPath().resolve(pyFileName); - File file = filePath.toFile(); - Files.deleteIfExists(filePath); - // Create the necessary directories - if (!file.getParentFile().exists()) { - if (!file.getParentFile().mkdirs()) { - throw new IOException( - "Failed to create directories required for the Python code generator." - ); - } - } - Map codeMaps = new HashMap<>(); - codeMaps.put(filePath, CodeMap.fromGeneratedCode( - generatePythonCode(pyModuleName))); - FileUtil.writeToFile(codeMaps.get(filePath).getGeneratedCode(), filePath); - return codeMaps; - } - - /** - * Generate code that needs to appear at the top of the generated - * C file, such as #define and #include statements. - */ - @Override - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr(PythonPreambleGenerator.generateCDefineDirectives( + Map codeMaps = new HashMap<>(); + codeMaps.put(filePath, CodeMap.fromGeneratedCode(generatePythonCode(pyModuleName))); + FileUtil.writeToFile(codeMaps.get(filePath).getGeneratedCode(), filePath); + return codeMaps; + } + + /** + * Generate code that needs to appear at the top of the generated C file, such as #define and + * #include statements. + */ + @Override + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr( + PythonPreambleGenerator.generateCDefineDirectives( targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); - code.pr(PythonPreambleGenerator.generateCIncludeStatements( + code.pr( + PythonPreambleGenerator.generateCIncludeStatements( targetConfig, targetLanguageIsCpp(), hasModalReactors)); - return code.toString(); + return code.toString(); + } + + /** + * Override generate top-level preambles, but put the user preambles in the .py file rather than + * the C file. Also handles including the federated execution setup preamble specified in the + * target config. + */ + @Override + protected String generateTopLevelPreambles() { + // user preambles + Set models = new LinkedHashSet<>(); + for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { + // The following assumes all reactors have a container. + // This means that generated reactors **have** to be + // added to a resource; not doing so will result in a NPE. + models.add((Model) ASTUtils.toDefinition(r).eContainer()); } - - /** - * Override generate top-level preambles, but put the user preambles in the - * .py file rather than the C file. Also handles including the federated - * execution setup preamble specified in the target config. - */ - @Override - protected String generateTopLevelPreambles() { - // user preambles - Set models = new LinkedHashSet<>(); - for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { - // The following assumes all reactors have a container. - // This means that generated reactors **have** to be - // added to a resource; not doing so will result in a NPE. - models.add((Model) ASTUtils.toDefinition(r).eContainer()); - } - // Add the main reactor if it is defined - if (this.mainDef != null) { - models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); - } - for (Model m : models) { - pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); - } - - // C preamble for federated execution setup - String ret = ""; - if (targetConfig.fedSetupPreamble != null) { - ret = "#include \"" + targetConfig.fedSetupPreamble + "\""; - } - return ret; + // Add the main reactor if it is defined + if (this.mainDef != null) { + models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); } - - @Override - protected void handleProtoFiles() { - for (String name : targetConfig.protoFiles) { - this.processProtoFile(name); - int dotIndex = name.lastIndexOf("."); - String rootFilename = dotIndex > 0 ? name.substring(0, dotIndex) : name; - pythonPreamble.pr("import "+rootFilename+"_pb2 as "+rootFilename); - protoNames.add(rootFilename); - } + for (Model m : models) { + pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); } - /** - * Process a given .proto file. - * - * Run, if possible, the proto-c protocol buffer code generator to produce - * the required .h and .c files. - * - * @param filename Name of the file to process. - */ - @Override - public void processProtoFile(String filename) { - LFCommand protoc = commandFactory.createCommand( - "protoc", List.of("--python_out=" - + fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); - - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires libprotoc >= 3.6.1"); - return; - } - int returnCode = protoc.run(); - if (returnCode == 0) { - pythonRequiredModules.add("google-api-python-client"); - } else { - errorReporter.reportError( - "protoc returns error code " + returnCode); - } + // C preamble for federated execution setup + String ret = ""; + if (targetConfig.fedSetupPreamble != null) { + ret = "#include \"" + targetConfig.fedSetupPreamble + "\""; } - - /** - * Generate the aliases for inputs, outputs, and struct type definitions for - * actions of the specified reactor in the specified federate. - * @param decl The parsed reactor data structure. - */ - @Override - public void generateAuxiliaryStructs( - ReactorDecl decl - ) { - Reactor reactor = ASTUtils.toDefinition(decl); - // First, handle inputs. - for (Input input : ASTUtils.allInputs(reactor)) { - generateAuxiliaryStructsForPort(decl, input); - } - // Next, handle outputs. - for (Output output : ASTUtils.allOutputs(reactor)) { - generateAuxiliaryStructsForPort(decl, output); - } - // Finally, handle actions. - for (Action action : ASTUtils.allActions(reactor)) { - generateAuxiliaryStructsForAction(decl, action); - } + return ret; + } + + @Override + protected void handleProtoFiles() { + for (String name : targetConfig.protoFiles) { + this.processProtoFile(name); + int dotIndex = name.lastIndexOf("."); + String rootFilename = dotIndex > 0 ? name.substring(0, dotIndex) : name; + pythonPreamble.pr("import " + rootFilename + "_pb2 as " + rootFilename); + protoNames.add(rootFilename); } - - private void generateAuxiliaryStructsForPort(ReactorDecl decl, - Port port) { - boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); - code.pr(port, - PythonPortGenerator.generateAliasTypeDef(decl, port, isTokenType, - genericPortType)); + } + + /** + * Process a given .proto file. + * + *

Run, if possible, the proto-c protocol buffer code generator to produce the required .h and + * .c files. + * + * @param filename Name of the file to process. + */ + @Override + public void processProtoFile(String filename) { + LFCommand protoc = + commandFactory.createCommand( + "protoc", + List.of("--python_out=" + fileConfig.getSrcGenPath(), filename), + fileConfig.srcPath); + + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires libprotoc >= 3.6.1"); + return; } - - private void generateAuxiliaryStructsForAction(ReactorDecl decl, - Action action) { - code.pr(action, PythonActionGenerator.generateAliasTypeDef(decl, action, genericActionType)); + int returnCode = protoc.run(); + if (returnCode == 0) { + pythonRequiredModules.add("google-api-python-client"); + } else { + errorReporter.reportError("protoc returns error code " + returnCode); } - - /** - * Return true if the host operating system is compatible and - * otherwise report an error and return false. - */ - @Override - public boolean isOSCompatible() { - return true; + } + + /** + * Generate the aliases for inputs, outputs, and struct type definitions for actions of the + * specified reactor in the specified federate. + * + * @param decl The parsed reactor data structure. + */ + @Override + public void generateAuxiliaryStructs(ReactorDecl decl) { + Reactor reactor = ASTUtils.toDefinition(decl); + // First, handle inputs. + for (Input input : ASTUtils.allInputs(reactor)) { + generateAuxiliaryStructsForPort(decl, input); } - - /** - * Generate C code from the Lingua Franca model contained by the - * specified resource. This is the main entry point for code - * generation. - * - * @param resource The resource containing the source code. - * @param context Context relating to invocation of the code generator. - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - // Set the threading to false by default, unless the user has - // specifically asked for it. - if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = false; - } - int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; - super.doGenerate(resource, new SubContext( - context, - IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, - cGeneratedPercentProgress - )); - - if (errorsOccurred()) { - context.unsuccessfulFinish(); - return; - } - - Map codeMaps = new HashMap<>(); - var lfModuleName = fileConfig.name; - // Don't generate code if there is no main reactor - if (this.main != null) { - try { - Map codeMapsForFederate = generatePythonFiles(lfModuleName, generatePythonModuleName(lfModuleName), generatePythonFileName(lfModuleName)); - codeMaps.putAll(codeMapsForFederate); - copyTargetFiles(); - new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); - if (targetConfig.noCompile) { - System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); - } - } catch (Exception e) { - //noinspection ConstantConditions - throw Exceptions.sneakyThrow(e); - } - - System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); - } - - if (errorReporter.getErrorsOccurred()) { - context.unsuccessfulFinish(); - } else { - context.finish(GeneratorResult.Status.COMPILED, codeMaps); - } + // Next, handle outputs. + for (Output output : ASTUtils.allOutputs(reactor)) { + generateAuxiliaryStructsForPort(decl, output); } - - @Override - protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new PythonDockerGenerator(context); + // Finally, handle actions. + for (Action action : ASTUtils.allActions(reactor)) { + generateAuxiliaryStructsForAction(decl, action); } - - /** Generate a reaction function definition for a reactor. - * This function has a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param decl The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - @Override - protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactionIndex) { - Reactor reactor = ASTUtils.toDefinition(decl); - - // Reactions marked with a `@_c_body` attribute are generated in C - if (AttributeUtils.hasCBody(reaction)) { - super.generateReaction(reaction, decl, reactionIndex); - return; - } - code.pr(PythonReactionGenerator.generateCReaction(reaction, decl, reactionIndex, mainDef, errorReporter, types)); + } + + private void generateAuxiliaryStructsForPort(ReactorDecl decl, Port port) { + boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); + code.pr( + port, PythonPortGenerator.generateAliasTypeDef(decl, port, isTokenType, genericPortType)); + } + + private void generateAuxiliaryStructsForAction(ReactorDecl decl, Action action) { + code.pr(action, PythonActionGenerator.generateAliasTypeDef(decl, action, genericActionType)); + } + + /** + * Return true if the host operating system is compatible and otherwise report an error and return + * false. + */ + @Override + public boolean isOSCompatible() { + return true; + } + + /** + * Generate C code from the Lingua Franca model contained by the specified resource. This is the + * main entry point for code generation. + * + * @param resource The resource containing the source code. + * @param context Context relating to invocation of the code generator. + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + // Set the threading to false by default, unless the user has + // specifically asked for it. + if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = false; } - - /** - * Generate code that initializes the state variables for a given instance. - * Unlike parameters, state variables are uniformly initialized for all - * instances - * of the same reactor. This task is left to Python code to allow for more - * liberal - * state variable assignments. - * - * @param instance The reactor class instance - * @return Initialization code fore state variables of instance - */ - @Override - protected void generateStateVariableInitializations(ReactorInstance instance) { - // Do nothing + int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; + super.doGenerate( + resource, + new SubContext( + context, IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, cGeneratedPercentProgress)); + + if (errorsOccurred()) { + context.unsuccessfulFinish(); + return; } - /** - * Generate runtime initialization code in C for parameters of a given - * reactor instance - * - * @param instance The reactor instance. - */ - @Override - protected void generateParameterInitialization(ReactorInstance instance) { - // Do nothing - // Parameters are initialized in Python - } + Map codeMaps = new HashMap<>(); + var lfModuleName = fileConfig.name; + // Don't generate code if there is no main reactor + if (this.main != null) { + try { + Map codeMapsForFederate = + generatePythonFiles( + lfModuleName, + generatePythonModuleName(lfModuleName), + generatePythonFileName(lfModuleName)); + codeMaps.putAll(codeMapsForFederate); + copyTargetFiles(); + new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); + if (targetConfig.noCompile) { + System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); + } + } catch (Exception e) { + //noinspection ConstantConditions + throw Exceptions.sneakyThrow(e); + } - /** - * Do nothing. - * Methods are generated in Python not C. - * @see PythonMethodGenerator - */ - @Override - protected void generateMethods(ReactorDecl reactor) { } - - /** - * Generate C preambles defined by user for a given reactor - * Since the Python generator expects preambles written in C, - * this function is overridden and does nothing. - * - * @param reactor The given reactor - */ - @Override - protected void generateUserPreamblesForReactor(Reactor reactor) { - // Do nothing + System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); } - /** - * Generate code that is executed while the reactor instance is being - * initialized. - * This wraps the reaction functions in a Python function. - * @param instance The reactor instance. - */ - @Override - protected void generateReactorInstanceExtension( - ReactorInstance instance - ) { - initializeTriggerObjects.pr(PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); + if (errorReporter.getErrorsOccurred()) { + context.unsuccessfulFinish(); + } else { + context.finish(GeneratorResult.Status.COMPILED, codeMaps); } - - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the self struct - * @param selfStructBody The body of the self struct - * @param decl The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - @Override - protected void generateSelfStructExtension( - CodeBuilder selfStructBody, - ReactorDecl decl, - CodeBuilder constructorCode - ) { - Reactor reactor = ASTUtils.toDefinition(decl); - // Add the name field - selfStructBody.pr("char *_lf_name;"); - int reactionIndex = 0; - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - // Create a PyObject for each reaction - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex)+";"); - if (reaction.getStp() != null) { - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex)+";"); - } - if (reaction.getDeadline() != null) { - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex)+";"); - } - reactionIndex++; - } + } + + @Override + protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new PythonDockerGenerator(context); + } + + /** + * Generate a reaction function definition for a reactor. This function has a single argument that + * is a void* pointing to a struct that contains parameters, state variables, inputs (triggering + * or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param decl The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + @Override + protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactionIndex) { + Reactor reactor = ASTUtils.toDefinition(decl); + + // Reactions marked with a `@_c_body` attribute are generated in C + if (AttributeUtils.hasCBody(reaction)) { + super.generateReaction(reaction, decl, reactionIndex); + return; } - - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - // NOTE: Strangely, a newline is needed at the beginning or indentation - // gets swallowed. - return String.join("\n", - "\n# Generated forwarding reaction for connections with the same destination", - "# but located in mutually exclusive modes.", - dest + ".set(" + source + ".value)\n" - ); + code.pr( + PythonReactionGenerator.generateCReaction( + reaction, decl, reactionIndex, mainDef, errorReporter, types)); + } + + /** + * Generate code that initializes the state variables for a given instance. Unlike parameters, + * state variables are uniformly initialized for all instances of the same reactor. This task is + * left to Python code to allow for more liberal state variable assignments. + * + * @param instance The reactor class instance + * @return Initialization code fore state variables of instance + */ + @Override + protected void generateStateVariableInitializations(ReactorInstance instance) { + // Do nothing + } + + /** + * Generate runtime initialization code in C for parameters of a given reactor instance + * + * @param instance The reactor instance. + */ + @Override + protected void generateParameterInitialization(ReactorInstance instance) { + // Do nothing + // Parameters are initialized in Python + } + + /** + * Do nothing. Methods are generated in Python not C. + * + * @see PythonMethodGenerator + */ + @Override + protected void generateMethods(ReactorDecl reactor) {} + + /** + * Generate C preambles defined by user for a given reactor Since the Python generator expects + * preambles written in C, this function is overridden and does nothing. + * + * @param reactor The given reactor + */ + @Override + protected void generateUserPreamblesForReactor(Reactor reactor) { + // Do nothing + } + + /** + * Generate code that is executed while the reactor instance is being initialized. This wraps the + * reaction functions in a Python function. + * + * @param instance The reactor instance. + */ + @Override + protected void generateReactorInstanceExtension(ReactorInstance instance) { + initializeTriggerObjects.pr( + PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); + } + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the + * self struct + * + * @param selfStructBody The body of the self struct + * @param decl The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + @Override + protected void generateSelfStructExtension( + CodeBuilder selfStructBody, ReactorDecl decl, CodeBuilder constructorCode) { + Reactor reactor = ASTUtils.toDefinition(decl); + // Add the name field + selfStructBody.pr("char *_lf_name;"); + int reactionIndex = 0; + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create a PyObject for each reaction + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex) + + ";"); + if (reaction.getStp() != null) { + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex) + + ";"); + } + if (reaction.getDeadline() != null) { + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex) + + ";"); + } + reactionIndex++; } - - @Override - protected void setUpGeneralParameters() { - super.setUpGeneralParameters(); - if (hasModalReactors) { - targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); - } + } + + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + // NOTE: Strangely, a newline is needed at the beginning or indentation + // gets swallowed. + return String.join( + "\n", + "\n# Generated forwarding reaction for connections with the same destination", + "# but located in mutually exclusive modes.", + dest + ".set(" + source + ".value)\n"); + } + + @Override + protected void setUpGeneralParameters() { + super.setUpGeneralParameters(); + if (hasModalReactors) { + targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); } + } - @Override - protected void additionalPostProcessingForModes() { - if (!hasModalReactors) { - return; - } - PythonModeGenerator.generateResetReactionsIfNeeded(reactors); + @Override + protected void additionalPostProcessingForModes() { + if (!hasModalReactors) { + return; } + PythonModeGenerator.generateResetReactionsIfNeeded(reactors); + } - private static String setUpMainTarget(boolean hasMain, String executableName, Stream cSources) { - return ( - """ + private static String setUpMainTarget( + boolean hasMain, String executableName, Stream cSources) { + return (""" set(CMAKE_POSITION_INDEPENDENT_CODE ON) add_compile_definitions(_LF_GARBAGE_COLLECTED) add_subdirectory(core) @@ -621,71 +594,61 @@ private static String setUpMainTarget(boolean hasMain, String executableName, St include_directories(${Python_INCLUDE_DIRS}) target_link_libraries(${LF_MAIN_TARGET} PRIVATE ${Python_LIBRARIES}) target_compile_definitions(${LF_MAIN_TARGET} PUBLIC MODULE_NAME=) - """ - ).replace("", generatePythonModuleName(executableName)) - .replace("executableName", executableName); - // The use of fileConfig.name will break federated execution, but that's fine - } - - /** - * Generate a (`key`, `val`) tuple pair for the `define_macros` field - * of the Extension class constructor from setuptools. - * - * @param key The key of the macro entry - * @param val The value of the macro entry - * @return A (`key`, `val`) tuple pair as String - */ - private static String generateMacroEntry(String key, String val) { - return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; - } - - /** - * Generate the name of the python module. - * - * Ideally, this function would belong in a class like `PyFileConfig` - * that specifies all the paths to the generated code. - * - * @param lfModuleName The name of the LF module. - * @return The name of the python module. - */ - private static String generatePythonModuleName(String lfModuleName) { - return "LinguaFranca" + lfModuleName; - } - - /** - * Generate the python file name given an `lfModuleName`. - * - * Ideally, this function would belong in a class like `PyFileConfig` - * that specifies all the paths to the generated code. - * - * @param lfModuleName The name of the LF module - * @return The name of the generated python file. - */ - private static String generatePythonFileName(String lfModuleName) { - return lfModuleName + ".py"; - } - - /** - * Copy Python specific target code to the src-gen directory - */ - @Override - protected void copyTargetFiles() throws IOException { - super.copyTargetFiles(); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/include", - fileConfig.getSrcGenPath().resolve("include"), - true - ); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/lib", - fileConfig.getSrcGenPath().resolve("lib"), - true - ); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/LinguaFrancaBase", - fileConfig.getSrcGenPath().resolve("LinguaFrancaBase"), - true - ); - } - + """) + .replace("", generatePythonModuleName(executableName)) + .replace("executableName", executableName); + // The use of fileConfig.name will break federated execution, but that's fine + } + + /** + * Generate a (`key`, `val`) tuple pair for the `define_macros` field of the Extension class + * constructor from setuptools. + * + * @param key The key of the macro entry + * @param val The value of the macro entry + * @return A (`key`, `val`) tuple pair as String + */ + private static String generateMacroEntry(String key, String val) { + return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; + } + + /** + * Generate the name of the python module. + * + *

Ideally, this function would belong in a class like `PyFileConfig` that specifies all the + * paths to the generated code. + * + * @param lfModuleName The name of the LF module. + * @return The name of the python module. + */ + private static String generatePythonModuleName(String lfModuleName) { + return "LinguaFranca" + lfModuleName; + } + + /** + * Generate the python file name given an `lfModuleName`. + * + *

Ideally, this function would belong in a class like `PyFileConfig` that specifies all the + * paths to the generated code. + * + * @param lfModuleName The name of the LF module + * @return The name of the generated python file. + */ + private static String generatePythonFileName(String lfModuleName) { + return lfModuleName + ".py"; + } + + /** Copy Python specific target code to the src-gen directory */ + @Override + protected void copyTargetFiles() throws IOException { + super.copyTargetFiles(); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/include", fileConfig.getSrcGenPath().resolve("include"), true); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/lib", fileConfig.getSrcGenPath().resolve("lib"), true); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/LinguaFrancaBase", + fileConfig.getSrcGenPath().resolve("LinguaFrancaBase"), + true); + } } diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java index a770235b31..32cd8d4a97 100644 --- a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java +++ b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java @@ -1,27 +1,27 @@ /************* -Copyright (c) 2020, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.scoping; @@ -29,256 +29,251 @@ import static org.lflang.ASTUtils.*; import com.google.inject.Inject; - import java.util.ArrayList; - import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EReference; import org.eclipse.xtext.naming.SimpleNameProvider; import org.eclipse.xtext.scoping.IScope; import org.eclipse.xtext.scoping.Scopes; import org.eclipse.xtext.scoping.impl.SelectableBasedScope; - import org.lflang.lf.Assignment; import org.lflang.lf.Connection; import org.lflang.lf.Deadline; import org.lflang.lf.Import; import org.lflang.lf.ImportedReactor; import org.lflang.lf.Instantiation; +import org.lflang.lf.LfPackage; +import org.lflang.lf.Mode; import org.lflang.lf.Model; import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.VarRef; -import org.lflang.lf.LfPackage; -import org.lflang.lf.Mode; /** - * This class enforces custom rules. In particular, it resolves references to - * parameters, ports, actions, and timers. Ports can be referenced across at - * most one level of hierarchy. Parameters, actions, and timers can be - * referenced locally, within the reactor. + * This class enforces custom rules. In particular, it resolves references to parameters, ports, + * actions, and timers. Ports can be referenced across at most one level of hierarchy. Parameters, + * actions, and timers can be referenced locally, within the reactor. * * @author Marten Lohstroh * @see */ public class LFScopeProviderImpl extends AbstractLFScopeProvider { - @Inject - private SimpleNameProvider nameProvider; + @Inject private SimpleNameProvider nameProvider; - @Inject - private LFGlobalScopeProvider scopeProvider; + @Inject private LFGlobalScopeProvider scopeProvider; - /** - * Enumerate of the kinds of references. - */ - enum RefType { - NULL, - TRIGGER, - SOURCE, - EFFECT, - WATCHDOG, - DEADLINE, - CLEFT, - CRIGHT - } + /** Enumerate of the kinds of references. */ + enum RefType { + NULL, + TRIGGER, + SOURCE, + EFFECT, + WATCHDOG, + DEADLINE, + CLEFT, + CRIGHT + } - /** - * Depending on the provided context, construct the appropriate scope - * for the given reference. - * - * @param context The AST node in which a to-be-resolved reference occurs. - * @param reference The reference to resolve. - */ - @Override - public IScope getScope(EObject context, EReference reference) { - if (context instanceof VarRef) { - return getScopeForVarRef((VarRef) context, reference); - } else if (context instanceof Assignment) { - return getScopeForAssignment((Assignment) context, reference); - } else if (context instanceof Instantiation) { - return getScopeForReactorDecl(context, reference); - } else if (context instanceof Reactor) { - return getScopeForReactorDecl(context, reference); - } else if (context instanceof ImportedReactor) { - return getScopeForImportedReactor((ImportedReactor) context, reference); - } - return super.getScope(context, reference); + /** + * Depending on the provided context, construct the appropriate scope for the given reference. + * + * @param context The AST node in which a to-be-resolved reference occurs. + * @param reference The reference to resolve. + */ + @Override + public IScope getScope(EObject context, EReference reference) { + if (context instanceof VarRef) { + return getScopeForVarRef((VarRef) context, reference); + } else if (context instanceof Assignment) { + return getScopeForAssignment((Assignment) context, reference); + } else if (context instanceof Instantiation) { + return getScopeForReactorDecl(context, reference); + } else if (context instanceof Reactor) { + return getScopeForReactorDecl(context, reference); + } else if (context instanceof ImportedReactor) { + return getScopeForImportedReactor((ImportedReactor) context, reference); } + return super.getScope(context, reference); + } - /** - * Filter out candidates that do not originate from the file listed in - * this particular import statement. - */ - protected IScope getScopeForImportedReactor(ImportedReactor context, EReference reference) { - String importURI = ((Import) context.eContainer()).getImportURI(); - var importedURI = scopeProvider.resolve(importURI == null ? "" : importURI, context.eResource()); - if (importedURI != null) { - var uniqueImportURIs = scopeProvider.getImportedUris(context.eResource()); - var descriptions = scopeProvider.getResourceDescriptions(context.eResource(), uniqueImportURIs); - var description = descriptions.getResourceDescription(importedURI); - return SelectableBasedScope.createScope(IScope.NULLSCOPE, description, null, reference.getEReferenceType(), false); - } - return Scopes.scopeFor(emptyList()); + /** + * Filter out candidates that do not originate from the file listed in this particular import + * statement. + */ + protected IScope getScopeForImportedReactor(ImportedReactor context, EReference reference) { + String importURI = ((Import) context.eContainer()).getImportURI(); + var importedURI = + scopeProvider.resolve(importURI == null ? "" : importURI, context.eResource()); + if (importedURI != null) { + var uniqueImportURIs = scopeProvider.getImportedUris(context.eResource()); + var descriptions = + scopeProvider.getResourceDescriptions(context.eResource(), uniqueImportURIs); + var description = descriptions.getResourceDescription(importedURI); + return SelectableBasedScope.createScope( + IScope.NULLSCOPE, description, null, reference.getEReferenceType(), false); } + return Scopes.scopeFor(emptyList()); + } - /** - * @param obj Instantiation or Reactor that has a ReactorDecl to resolve. - * @param reference The reference to link to a ReactorDecl node. - */ - protected IScope getScopeForReactorDecl(EObject obj, EReference reference) { + /** + * @param obj Instantiation or Reactor that has a ReactorDecl to resolve. + * @param reference The reference to link to a ReactorDecl node. + */ + protected IScope getScopeForReactorDecl(EObject obj, EReference reference) { - // Find the local Model - Model model = null; - EObject container = obj; - while(model == null && container != null) { - container = container.eContainer(); - if (container instanceof Model) { - model = (Model)container; - } - } - if (model == null) { - return Scopes.scopeFor(emptyList()); - } + // Find the local Model + Model model = null; + EObject container = obj; + while (model == null && container != null) { + container = container.eContainer(); + if (container instanceof Model) { + model = (Model) container; + } + } + if (model == null) { + return Scopes.scopeFor(emptyList()); + } - // Collect eligible candidates, all of which are local (i.e., not in other files). - var locals = new ArrayList(model.getReactors()); + // Collect eligible candidates, all of which are local (i.e., not in other files). + var locals = new ArrayList(model.getReactors()); - // Either point to the import statement (if it is renamed) - // or directly to the reactor definition. - for (Import it : model.getImports()) { - for (ImportedReactor ir : it.getReactorClasses()) { - if (ir.getName() != null) { - locals.add(ir); - } else if (ir.getReactorClass() != null) { - locals.add(ir.getReactorClass()); - } - } + // Either point to the import statement (if it is renamed) + // or directly to the reactor definition. + for (Import it : model.getImports()) { + for (ImportedReactor ir : it.getReactorClasses()) { + if (ir.getName() != null) { + locals.add(ir); + } else if (ir.getReactorClass() != null) { + locals.add(ir.getReactorClass()); } - return Scopes.scopeFor(locals); + } } + return Scopes.scopeFor(locals); + } - protected IScope getScopeForAssignment(Assignment assignment, EReference reference) { + protected IScope getScopeForAssignment(Assignment assignment, EReference reference) { - if (reference == LfPackage.Literals.ASSIGNMENT__LHS) { - var defn = toDefinition(((Instantiation) assignment.eContainer()).getReactorClass()); - if (defn != null) { - return Scopes.scopeFor(allParameters(defn)); - } - - } - if (reference == LfPackage.Literals.ASSIGNMENT__RHS) { - return Scopes.scopeFor(((Reactor) assignment.eContainer().eContainer()).getParameters()); - } - return Scopes.scopeFor(emptyList()); + if (reference == LfPackage.Literals.ASSIGNMENT__LHS) { + var defn = toDefinition(((Instantiation) assignment.eContainer()).getReactorClass()); + if (defn != null) { + return Scopes.scopeFor(allParameters(defn)); + } + } + if (reference == LfPackage.Literals.ASSIGNMENT__RHS) { + return Scopes.scopeFor(((Reactor) assignment.eContainer().eContainer()).getParameters()); } + return Scopes.scopeFor(emptyList()); + } - protected IScope getScopeForVarRef(VarRef variable, EReference reference) { - if (reference == LfPackage.Literals.VAR_REF__VARIABLE) { - // Resolve hierarchical reference - Reactor reactor; - Mode mode = null; - if (variable.eContainer().eContainer() instanceof Reactor) { - reactor = (Reactor) variable.eContainer().eContainer(); - } else if (variable.eContainer().eContainer() instanceof Mode) { - mode = (Mode) variable.eContainer().eContainer(); - reactor = (Reactor) variable.eContainer().eContainer().eContainer(); - } else { - return Scopes.scopeFor(emptyList()); - } + protected IScope getScopeForVarRef(VarRef variable, EReference reference) { + if (reference == LfPackage.Literals.VAR_REF__VARIABLE) { + // Resolve hierarchical reference + Reactor reactor; + Mode mode = null; + if (variable.eContainer().eContainer() instanceof Reactor) { + reactor = (Reactor) variable.eContainer().eContainer(); + } else if (variable.eContainer().eContainer() instanceof Mode) { + mode = (Mode) variable.eContainer().eContainer(); + reactor = (Reactor) variable.eContainer().eContainer().eContainer(); + } else { + return Scopes.scopeFor(emptyList()); + } - RefType type = getRefType(variable); + RefType type = getRefType(variable); - if (variable.getContainer() != null) { // Resolve hierarchical port reference - var instanceName = nameProvider.getFullyQualifiedName(variable.getContainer()); - var instances = new ArrayList(reactor.getInstantiations()); - if (mode != null) { - instances.addAll(mode.getInstantiations()); - } + if (variable.getContainer() != null) { // Resolve hierarchical port reference + var instanceName = nameProvider.getFullyQualifiedName(variable.getContainer()); + var instances = new ArrayList(reactor.getInstantiations()); + if (mode != null) { + instances.addAll(mode.getInstantiations()); + } - if (instanceName != null) { - for (var instance : instances) { - var defn = toDefinition(instance.getReactorClass()); - if (defn != null && instance.getName().equals(instanceName.toString())) { - switch (type) { - case TRIGGER: - case SOURCE: - case CLEFT: - return Scopes.scopeFor(allOutputs(defn)); - case EFFECT: - case DEADLINE: - case CRIGHT: - return Scopes.scopeFor(allInputs(defn)); - } - } - } - } - return Scopes.scopeFor(emptyList()); - } else { - // Resolve local reference - switch (type) { - case TRIGGER: { - var candidates = new ArrayList(); - if (mode != null) { - candidates.addAll(mode.getActions()); - candidates.addAll(mode.getTimers()); - } - candidates.addAll(allInputs(reactor)); - candidates.addAll(allActions(reactor)); - candidates.addAll(allTimers(reactor)); - candidates.addAll(allWatchdogs(reactor)); - return Scopes.scopeFor(candidates); - } + if (instanceName != null) { + for (var instance : instances) { + var defn = toDefinition(instance.getReactorClass()); + if (defn != null && instance.getName().equals(instanceName.toString())) { + switch (type) { + case TRIGGER: case SOURCE: - return super.getScope(variable, reference); - case EFFECT: { - var candidates = new ArrayList(); - if (mode != null) { - candidates.addAll(mode.getActions()); - candidates.addAll(reactor.getModes()); - } - candidates.addAll(allOutputs(reactor)); - candidates.addAll(allActions(reactor)); - candidates.addAll(allWatchdogs(reactor)); - return Scopes.scopeFor(candidates); - } - case WATCHDOG: - return Scopes.scopeFor(allWatchdogs(reactor)); - case DEADLINE: case CLEFT: - return Scopes.scopeFor(allInputs(reactor)); + return Scopes.scopeFor(allOutputs(defn)); + case EFFECT: + case DEADLINE: case CRIGHT: - return Scopes.scopeFor(allOutputs(reactor)); - default: - return Scopes.scopeFor(emptyList()); - } + return Scopes.scopeFor(allInputs(defn)); + } } - } else { // Resolve instance - return super.getScope(variable, reference); + } } - } - - private RefType getRefType(VarRef variable) { - if (variable.eContainer() instanceof Deadline) { - return RefType.DEADLINE; - } else if (variable.eContainer() instanceof Reaction) { - var reaction = (Reaction) variable.eContainer(); - if (reaction.getTriggers().contains(variable)) { - return RefType.TRIGGER; - } else if (reaction.getSources().contains(variable)) { - return RefType.SOURCE; - } else if (reaction.getEffects().contains(variable)) { - return RefType.EFFECT; + return Scopes.scopeFor(emptyList()); + } else { + // Resolve local reference + switch (type) { + case TRIGGER: + { + var candidates = new ArrayList(); + if (mode != null) { + candidates.addAll(mode.getActions()); + candidates.addAll(mode.getTimers()); + } + candidates.addAll(allInputs(reactor)); + candidates.addAll(allActions(reactor)); + candidates.addAll(allTimers(reactor)); + candidates.addAll(allWatchdogs(reactor)); + return Scopes.scopeFor(candidates); } - } else if (variable.eContainer() instanceof Connection) { - var conn = (Connection) variable.eContainer(); - if (conn.getLeftPorts().contains(variable)) { - return RefType.CLEFT; - } else if (conn.getRightPorts().contains(variable)) { - return RefType.CRIGHT; + case SOURCE: + return super.getScope(variable, reference); + case EFFECT: + { + var candidates = new ArrayList(); + if (mode != null) { + candidates.addAll(mode.getActions()); + candidates.addAll(reactor.getModes()); + } + candidates.addAll(allOutputs(reactor)); + candidates.addAll(allActions(reactor)); + candidates.addAll(allWatchdogs(reactor)); + return Scopes.scopeFor(candidates); } + case WATCHDOG: + return Scopes.scopeFor(allWatchdogs(reactor)); + case DEADLINE: + case CLEFT: + return Scopes.scopeFor(allInputs(reactor)); + case CRIGHT: + return Scopes.scopeFor(allOutputs(reactor)); + default: + return Scopes.scopeFor(emptyList()); } - return RefType.NULL; + } + } else { // Resolve instance + return super.getScope(variable, reference); + } + } + + private RefType getRefType(VarRef variable) { + if (variable.eContainer() instanceof Deadline) { + return RefType.DEADLINE; + } else if (variable.eContainer() instanceof Reaction) { + var reaction = (Reaction) variable.eContainer(); + if (reaction.getTriggers().contains(variable)) { + return RefType.TRIGGER; + } else if (reaction.getSources().contains(variable)) { + return RefType.SOURCE; + } else if (reaction.getEffects().contains(variable)) { + return RefType.EFFECT; + } + } else if (variable.eContainer() instanceof Connection) { + var conn = (Connection) variable.eContainer(); + if (conn.getLeftPorts().contains(variable)) { + return RefType.CLEFT; + } else if (conn.getRightPorts().contains(variable)) { + return RefType.CRIGHT; + } } + return RefType.NULL; + } } diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 2ea579b753..2d0d4f332b 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -2,17 +2,17 @@ /************* * Copyright (c) 2019-2020, The University of California at Berkeley. - + * * 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. - + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -28,12 +28,10 @@ import static org.lflang.ASTUtils.inferPortWidth; import static org.lflang.ASTUtils.isGeneric; -import static org.lflang.ASTUtils.isInteger; -import static org.lflang.ASTUtils.isOfTimeType; -import static org.lflang.ASTUtils.isZero; import static org.lflang.ASTUtils.toDefinition; import static org.lflang.ASTUtils.toOriginalText; +import com.google.inject.Inject; import java.io.File; import java.io.IOException; import java.util.ArrayList; @@ -45,7 +43,6 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; - import org.eclipse.emf.common.util.EList; import org.eclipse.emf.common.util.TreeIterator; import org.eclipse.emf.ecore.EAttribute; @@ -72,7 +69,6 @@ import org.lflang.lf.BracedListExpression; import org.lflang.lf.BuiltinTrigger; import org.lflang.lf.BuiltinTriggerRef; -import org.lflang.lf.CodeExpr; import org.lflang.lf.Connection; import org.lflang.lf.Deadline; import org.lflang.lf.Expression; @@ -114,15 +110,12 @@ import org.lflang.lf.Visibility; import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; -import org.lflang.lf.Watchdog; import org.lflang.util.FileUtil; -import com.google.inject.Inject; - /** * Custom validation checks for Lingua Franca programs. * - * Also see: https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + *

Also see: https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation * * @author Edward A. Lee * @author Marten Lohstroh @@ -133,1750 +126,1832 @@ */ public class LFValidator extends BaseLFValidator { - ////////////////////////////////////////////////////////////// - //// Public check methods. - - // These methods are automatically invoked on AST nodes matching - // the types of their arguments. - // CheckType.FAST ensures that these checks run whenever a file is modified. - // Alternatives are CheckType.NORMAL (when saving) and - // CheckType.EXPENSIVE (only when right-click, validate). - // FIXME: What is the default when nothing is specified? - - // These methods are listed in alphabetical order, and, although - // it is isn't strictly required, follow a naming convention - // checkClass, where Class is the AST class, where possible. - - @Check(CheckType.FAST) - public void checkAction(Action action) { - checkName(action.getName(), Literals.VARIABLE__NAME); - if (action.getOrigin() == ActionOrigin.NONE) { - error( - "Action must have modifier `logical` or `physical`.", - Literals.ACTION__ORIGIN - ); - } - if (action.getPolicy() != null && - !SPACING_VIOLATION_POLICIES.contains(action.getPolicy())) { - error( - "Unrecognized spacing violation policy: " + action.getPolicy() + - ". Available policies are: " + - String.join(", ", SPACING_VIOLATION_POLICIES) + ".", - Literals.ACTION__POLICY); - } - checkExpressionIsTime(action.getMinDelay(), Literals.ACTION__MIN_DELAY); - checkExpressionIsTime(action.getMinSpacing(), Literals.ACTION__MIN_SPACING); + ////////////////////////////////////////////////////////////// + //// Public check methods. + + // These methods are automatically invoked on AST nodes matching + // the types of their arguments. + // CheckType.FAST ensures that these checks run whenever a file is modified. + // Alternatives are CheckType.NORMAL (when saving) and + // CheckType.EXPENSIVE (only when right-click, validate). + // FIXME: What is the default when nothing is specified? + + // These methods are listed in alphabetical order, and, although + // it is isn't strictly required, follow a naming convention + // checkClass, where Class is the AST class, where possible. + + @Check(CheckType.FAST) + public void checkAction(Action action) { + checkName(action.getName(), Literals.VARIABLE__NAME); + if (action.getOrigin() == ActionOrigin.NONE) { + error("Action must have modifier `logical` or `physical`.", Literals.ACTION__ORIGIN); } - - - @Check(CheckType.FAST) - public void checkInitializer(Initializer init) { - if (init.isBraces() && target != Target.CPP) { - error("Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); - } else if (init.isParens() && target.mandatesEqualsInitializers()) { - var message = "This syntax is deprecated in the " + target - + " target, use an equal sign instead of parentheses for assignment."; - if (init.getExprs().size() == 1) { - message += " (run the formatter to fix this automatically)"; - } - warning(message, Literals.INITIALIZER__PARENS); - } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { - var feature = init.isBraces() ? Literals.INITIALIZER__BRACES - : Literals.INITIALIZER__PARENS; - var message = "This syntax is deprecated, do not use parentheses or braces but an equal sign."; - if (init.getExprs().size() == 1) { - message += " (run the formatter to fix this automatically)"; - } - warning(message, feature); - } + if (action.getPolicy() != null && !SPACING_VIOLATION_POLICIES.contains(action.getPolicy())) { + error( + "Unrecognized spacing violation policy: " + + action.getPolicy() + + ". Available policies are: " + + String.join(", ", SPACING_VIOLATION_POLICIES) + + ".", + Literals.ACTION__POLICY); } - - @Check(CheckType.FAST) - public void checkBracedExpression(BracedListExpression expr) { - if (!target.allowsBracedListExpressions()) { - var message = "Braced expression lists are not a valid expression for the " + target - + " target."; - error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); - } + checkExpressionIsTime(action.getMinDelay(), Literals.ACTION__MIN_DELAY); + checkExpressionIsTime(action.getMinSpacing(), Literals.ACTION__MIN_SPACING); + } + + @Check(CheckType.FAST) + public void checkInitializer(Initializer init) { + if (init.isBraces() && target != Target.CPP) { + error( + "Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); + } else if (init.isParens() && target.mandatesEqualsInitializers()) { + var message = + "This syntax is deprecated in the " + + target + + " target, use an equal sign instead of parentheses for assignment."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, Literals.INITIALIZER__PARENS); + } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { + var feature = init.isBraces() ? Literals.INITIALIZER__BRACES : Literals.INITIALIZER__PARENS; + var message = + "This syntax is deprecated, do not use parentheses or braces but an equal sign."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, feature); } - - @Check(CheckType.FAST) - public void checkAssignment(Assignment assignment) { - - // If the left-hand side is a time parameter, make sure the assignment has units - typeCheck(assignment.getRhs(), ASTUtils.getInferredType(assignment.getLhs()), Literals.ASSIGNMENT__RHS); - // If this assignment overrides a parameter that is used in a deadline, - // report possible overflow. - if (isCBasedTarget() && - this.info.overflowingAssignments.contains(assignment)) { - error( - "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.ASSIGNMENT__RHS); - } - + } + + @Check(CheckType.FAST) + public void checkBracedExpression(BracedListExpression expr) { + if (!target.allowsBracedListExpressions()) { + var message = + "Braced expression lists are not a valid expression for the " + target + " target."; + error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); } + } + + @Check(CheckType.FAST) + public void checkAssignment(Assignment assignment) { + + // If the left-hand side is a time parameter, make sure the assignment has units + typeCheck( + assignment.getRhs(), + ASTUtils.getInferredType(assignment.getLhs()), + Literals.ASSIGNMENT__RHS); + // If this assignment overrides a parameter that is used in a deadline, + // report possible overflow. + if (isCBasedTarget() && this.info.overflowingAssignments.contains(assignment)) { + error( + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + + " nanoseconds.", + Literals.ASSIGNMENT__RHS); + } + } - @Check(CheckType.FAST) - public void checkConnection(Connection connection) { - - // Report if connection is part of a cycle. - Set> cycles = this.info.topologyCycles(); - for (VarRef lp : connection.getLeftPorts()) { - for (VarRef rp : connection.getRightPorts()) { - boolean leftInCycle = false; - - for (NamedInstance it : cycles) { - if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) - || (it.getDefinition().equals(lp.getVariable()) && it.getParent().equals(lp.getContainer()))) { - leftInCycle = true; - break; - } - } - - for (NamedInstance it : cycles) { - if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) - || (it.getDefinition().equals(rp.getVariable()) && it.getParent().equals(rp.getContainer()))) { - if (leftInCycle) { - Reactor reactor = ASTUtils.getEnclosingReactor(connection); - String reactorName = reactor.getName(); - error(String.format("Connection in reactor %s creates", reactorName) + - String.format("a cyclic dependency between %s and %s.", toOriginalText(lp), toOriginalText(rp)), - Literals.CONNECTION__DELAY); - } - } - } - } - } + @Check(CheckType.FAST) + public void checkConnection(Connection connection) { - // FIXME: look up all ReactorInstance objects that have a definition equal to the - // container of this connection. For each of those occurrences, the widths have to match. - // For the C target, since C has such a weak type system, check that - // the types on both sides of every connection match. For other languages, - // we leave type compatibility that language's compiler or interpreter. - if (isCBasedTarget()) { - Type type = (Type) null; - for (VarRef port : connection.getLeftPorts()) { - // If the variable is not a port, then there is some other - // error. Avoid a class cast exception. - if (port.getVariable() instanceof Port) { - if (type == null) { - type = ((Port) port.getVariable()).getType(); - } else { - // Unfortunately, xtext does not generate a suitable equals() - // method for AST types, so we have to manually check the types. - if (!sameType(type, ((Port) port.getVariable()).getType())) { - error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); - } - } - } - } - for (VarRef port : connection.getRightPorts()) { - // If the variable is not a port, then there is some other - // error. Avoid a class cast exception. - if (port.getVariable() instanceof Port) { - if (type == null) { - type = ((Port) port.getVariable()).getType(); - } else { - if (!sameType(type, type = ((Port) port.getVariable()).getType())) { - error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); - } - } - } - } - } + // Report if connection is part of a cycle. + Set> cycles = this.info.topologyCycles(); + for (VarRef lp : connection.getLeftPorts()) { + for (VarRef rp : connection.getRightPorts()) { + boolean leftInCycle = false; - // Check whether the total width of the left side of the connection - // matches the total width of the right side. This cannot be determined - // here if the width is not given as a constant. In that case, it is up - // to the code generator to check it. - int leftWidth = 0; - for (VarRef port : connection.getLeftPorts()) { - int width = inferPortWidth(port, null, null); // null args imply incomplete check. - if (width < 0 || leftWidth < 0) { - // Cannot determine the width of the left ports. - leftWidth = -1; - } else { - leftWidth += width; - } - } - int rightWidth = 0; - for (VarRef port : connection.getRightPorts()) { - int width = inferPortWidth(port, null, null); // null args imply incomplete check. - if (width < 0 || rightWidth < 0) { - // Cannot determine the width of the left ports. - rightWidth = -1; - } else { - rightWidth += width; - } + for (NamedInstance it : cycles) { + if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) + || (it.getDefinition().equals(lp.getVariable()) + && it.getParent().equals(lp.getContainer()))) { + leftInCycle = true; + break; + } } - if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { - if (connection.isIterated()) { - if (leftWidth == 0 || rightWidth % leftWidth != 0) { - // FIXME: The second argument should be Literals.CONNECTION, but - // stupidly, xtext will not accept that. There seems to be no way to - // report an error for the whole connection statement. - warning(String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), - Literals.CONNECTION__LEFT_PORTS - ); - } - } else { - // FIXME: The second argument should be Literals.CONNECTION, but - // stupidly, xtext will not accept that. There seems to be no way to - // report an error for the whole connection statement. - warning(String.format("Left width %s does not match right width %s", leftWidth, rightWidth), - Literals.CONNECTION__LEFT_PORTS - ); - } - } + for (NamedInstance it : cycles) { + if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) + || (it.getDefinition().equals(rp.getVariable()) + && it.getParent().equals(rp.getContainer()))) { + if (leftInCycle) { + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + String reactorName = reactor.getName(); + error( + String.format("Connection in reactor %s creates", reactorName) + + String.format( + "a cyclic dependency between %s and %s.", + toOriginalText(lp), toOriginalText(rp)), + Literals.CONNECTION__DELAY); + } + } + } + } + } - Reactor reactor = ASTUtils.getEnclosingReactor(connection); - - // Make sure the right port is not already an effect of a reaction. - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - for (VarRef effect : reaction.getEffects()) { - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort.getVariable().equals(effect.getVariable()) && // Refers to the same variable - rightPort.getContainer() == effect.getContainer() && // Refers to the same instance - ( reaction.eContainer() instanceof Reactor || // Either is not part of a mode - connection.eContainer() instanceof Reactor || - connection.eContainer() == reaction.eContainer() // Or they are in the same mode - )) { - error("Cannot connect: Port named '" + effect.getVariable().getName() + - "' is already effect of a reaction.", - Literals.CONNECTION__RIGHT_PORTS); - } - } - } - } + // FIXME: look up all ReactorInstance objects that have a definition equal to the + // container of this connection. For each of those occurrences, the widths have to match. + // For the C target, since C has such a weak type system, check that + // the types on both sides of every connection match. For other languages, + // we leave type compatibility that language's compiler or interpreter. + if (isCBasedTarget()) { + Type type = (Type) null; + for (VarRef port : connection.getLeftPorts()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + // Unfortunately, xtext does not generate a suitable equals() + // method for AST types, so we have to manually check the types. + if (!sameType(type, ((Port) port.getVariable()).getType())) { + error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); + } + } + } + } + for (VarRef port : connection.getRightPorts()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + if (!sameType(type, type = ((Port) port.getVariable()).getType())) { + error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); + } + } + } + } + } - // Check that the right port does not already have some other - // upstream connection. - for (Connection c : reactor.getConnections()) { - if (c != connection) { - for (VarRef thisRightPort : connection.getRightPorts()) { - for (VarRef thatRightPort : c.getRightPorts()) { - if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) && // Refers to the same variable - thisRightPort.getContainer() == thatRightPort.getContainer() && // Refers to the same instance - ( connection.eContainer() instanceof Reactor || // Or either of the connections in not part of a mode - c.eContainer() instanceof Reactor || - connection.eContainer() == c.eContainer() // Or they are in the same mode - )) { - error( - "Cannot connect: Port named '" + thisRightPort.getVariable().getName() + - "' may only appear once on the right side of a connection.", - Literals.CONNECTION__RIGHT_PORTS); - } - } - } - } - } + // Check whether the total width of the left side of the connection + // matches the total width of the right side. This cannot be determined + // here if the width is not given as a constant. In that case, it is up + // to the code generator to check it. + int leftWidth = 0; + for (VarRef port : connection.getLeftPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || leftWidth < 0) { + // Cannot determine the width of the left ports. + leftWidth = -1; + } else { + leftWidth += width; + } + } + int rightWidth = 0; + for (VarRef port : connection.getRightPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || rightWidth < 0) { + // Cannot determine the width of the left ports. + rightWidth = -1; + } else { + rightWidth += width; + } + } - // Check the after delay - if (connection.getDelay() != null) { - final var delay = connection.getDelay(); - if (delay instanceof ParameterReference || delay instanceof Time || delay instanceof Literal) { - checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); - } else { - error("After delays can only be given by time literals or parameters.", - Literals.CONNECTION__DELAY); - } - } + if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { + if (connection.isIterated()) { + if (leftWidth == 0 || rightWidth % leftWidth != 0) { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning( + String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS); + } + } else { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning( + String.format("Left width %s does not match right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS); + } } - @Check(CheckType.FAST) - public void checkDeadline(Deadline deadline) { - if (isCBasedTarget() && - this.info.overflowingDeadlines.contains(deadline)) { + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + + // Make sure the right port is not already an effect of a reaction. + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + for (VarRef effect : reaction.getEffects()) { + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort.getVariable().equals(effect.getVariable()) + && // Refers to the same variable + rightPort.getContainer() == effect.getContainer() + && // Refers to the same instance + (reaction.eContainer() instanceof Reactor + || // Either is not part of a mode + connection.eContainer() instanceof Reactor + || connection.eContainer() + == reaction.eContainer() // Or they are in the same mode + )) { error( - "Deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.DEADLINE__DELAY); + "Cannot connect: Port named '" + + effect.getVariable().getName() + + "' is already effect of a reaction.", + Literals.CONNECTION__RIGHT_PORTS); + } } - checkExpressionIsTime(deadline.getDelay(), Literals.DEADLINE__DELAY); + } } - @Check(CheckType.FAST) - public void checkHost(Host host) { - String addr = host.getAddr(); - String user = host.getUser(); - if (user != null && !user.matches(USERNAME_REGEX)) { - warning( - "Invalid user name.", - Literals.HOST__USER - ); - } - if (host instanceof IPV4Host && !addr.matches(IPV4_REGEX)) { - warning( - "Invalid IP address.", - Literals.HOST__ADDR - ); - } else if (host instanceof IPV6Host && !addr.matches(IPV6_REGEX)) { - warning( - "Invalid IP address.", - Literals.HOST__ADDR - ); - } else if (host instanceof NamedHost && !addr.matches(HOST_OR_FQN_REGEX)) { - warning( - "Invalid host name or fully qualified domain name.", - Literals.HOST__ADDR - ); - } + // Check that the right port does not already have some other + // upstream connection. + for (Connection c : reactor.getConnections()) { + if (c != connection) { + for (VarRef thisRightPort : connection.getRightPorts()) { + for (VarRef thatRightPort : c.getRightPorts()) { + if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) + && // Refers to the same variable + thisRightPort.getContainer() == thatRightPort.getContainer() + && // Refers to the same instance + (connection.eContainer() instanceof Reactor + || // Or either of the connections in not part of a mode + c.eContainer() instanceof Reactor + || connection.eContainer() == c.eContainer() // Or they are in the same mode + )) { + error( + "Cannot connect: Port named '" + + thisRightPort.getVariable().getName() + + "' may only appear once on the right side of a connection.", + Literals.CONNECTION__RIGHT_PORTS); + } + } + } + } } - @Check - public void checkImport(Import imp) { - if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { - error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. - return; - } - - // FIXME: report error if resource cannot be resolved. - for (ImportedReactor reactor : imp.getReactorClasses()) { - if (!isUnused(reactor)) { - return; - } - } - warning("Unused import.", Literals.IMPORT__IMPORT_URI); + // Check the after delay + if (connection.getDelay() != null) { + final var delay = connection.getDelay(); + if (delay instanceof ParameterReference + || delay instanceof Time + || delay instanceof Literal) { + checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); + } else { + error( + "After delays can only be given by time literals or parameters.", + Literals.CONNECTION__DELAY); + } } - - @Check - public void checkImportedReactor(ImportedReactor reactor) { - if (isUnused(reactor)) { - warning("Unused reactor class.", - Literals.IMPORTED_REACTOR__REACTOR_CLASS); - } - - if (info.instantiationGraph.hasCycles()) { - Set cycleSet = new HashSet<>(); - for (Set cycle : info.instantiationGraph.getCycles()) { - cycleSet.addAll(cycle); - } - if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { - error("Imported reactor '" + toDefinition(reactor).getName() + - "' has cyclic instantiation in it.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); - } - } + } + + @Check(CheckType.FAST) + public void checkDeadline(Deadline deadline) { + if (isCBasedTarget() && this.info.overflowingDeadlines.contains(deadline)) { + error( + "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.DEADLINE__DELAY); } - - @Check(CheckType.FAST) - public void checkInput(Input input) { - Reactor parent = (Reactor)input.eContainer(); - if (parent.isMain() || parent.isFederated()) { - error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); - } - checkName(input.getName(), Literals.VARIABLE__NAME); - if (target.requiresTypes) { - if (input.getType() == null) { - error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); - } - } - - // mutable has no meaning in C++ - if (input.isMutable() && this.target == Target.CPP) { - warning( - "The mutable qualifier has no meaning for the C++ target and should be removed. " + - "In C++, any value can be made mutable by calling get_mutable_copy().", - Literals.INPUT__MUTABLE - ); - } - - // Variable width multiports are not supported (yet?). - if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { - error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); - } + checkExpressionIsTime(deadline.getDelay(), Literals.DEADLINE__DELAY); + } + + @Check(CheckType.FAST) + public void checkHost(Host host) { + String addr = host.getAddr(); + String user = host.getUser(); + if (user != null && !user.matches(USERNAME_REGEX)) { + warning("Invalid user name.", Literals.HOST__USER); } + if (host instanceof IPV4Host && !addr.matches(IPV4_REGEX)) { + warning("Invalid IP address.", Literals.HOST__ADDR); + } else if (host instanceof IPV6Host && !addr.matches(IPV6_REGEX)) { + warning("Invalid IP address.", Literals.HOST__ADDR); + } else if (host instanceof NamedHost && !addr.matches(HOST_OR_FQN_REGEX)) { + warning("Invalid host name or fully qualified domain name.", Literals.HOST__ADDR); + } + } - @Check(CheckType.FAST) - public void checkInstantiation(Instantiation instantiation) { - checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); - Reactor reactor = toDefinition(instantiation.getReactorClass()); - if (reactor.isMain() || reactor.isFederated()) { - error( - "Cannot instantiate a main (or federated) reactor: " + - instantiation.getReactorClass().getName(), - Literals.INSTANTIATION__REACTOR_CLASS - ); - } + @Check + public void checkImport(Import imp) { + if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { + error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. + return; + } - // Report error if this instantiation is part of a cycle. - // FIXME: improve error message. - // FIXME: Also report if there exists a cycle within. - if (this.info.instantiationGraph.getCycles().size() > 0) { - for (Set cycle : this.info.instantiationGraph.getCycles()) { - Reactor container = (Reactor) instantiation.eContainer(); - if (cycle.contains(container) && cycle.contains(reactor)) { - List names = new ArrayList<>(); - for (Reactor r : cycle) { - names.add(r.getName()); - } - - error( - "Instantiation is part of a cycle: " + String.join(", ", names) + ".", - Literals.INSTANTIATION__REACTOR_CLASS - ); - } - } - } - // Variable width multiports are not supported (yet?). - if (instantiation.getWidthSpec() != null - && instantiation.getWidthSpec().isOfVariableLength() - ) { - if (isCBasedTarget()) { - warning("Variable-width banks are for internal use only.", - Literals.INSTANTIATION__WIDTH_SPEC - ); - } else { - error("Variable-width banks are not supported.", - Literals.INSTANTIATION__WIDTH_SPEC - ); - } - } + // FIXME: report error if resource cannot be resolved. + for (ImportedReactor reactor : imp.getReactorClasses()) { + if (!isUnused(reactor)) { + return; + } } + warning("Unused import.", Literals.IMPORT__IMPORT_URI); + } - /** Check target parameters, which are key-value pairs. */ - @Check(CheckType.FAST) - public void checkKeyValuePair(KeyValuePair param) { - // Check only if the container's container is a Target. - if (param.eContainer().eContainer() instanceof TargetDecl) { - TargetProperty prop = TargetProperty.forName(param.getName()); - - // Make sure the key is valid. - if (prop == null) { - String options = TargetProperty.getOptions().stream() - .map(p -> p.description).sorted() - .collect(Collectors.joining(", ")); - warning( - "Unrecognized target parameter: " + param.getName() + - ". Recognized parameters are: " + options, - Literals.KEY_VALUE_PAIR__NAME); - } else { - // Check whether the property is supported by the target. - if (!prop.supportedBy.contains(this.target)) { - warning( - "The target parameter: " + param.getName() + - " is not supported by the " + this.target + - " target and will thus be ignored.", - Literals.KEY_VALUE_PAIR__NAME); - } + @Check + public void checkImportedReactor(ImportedReactor reactor) { + if (isUnused(reactor)) { + warning("Unused reactor class.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } - // Report problem with the assigned value. - prop.type.check(param.getValue(), param.getName(), this); - } - - for (String it : targetPropertyErrors) { - error(it, Literals.KEY_VALUE_PAIR__VALUE); - } - targetPropertyErrors.clear(); - - for (String it : targetPropertyWarnings) { - error(it, Literals.KEY_VALUE_PAIR__VALUE); - } - targetPropertyWarnings.clear(); - } + if (info.instantiationGraph.hasCycles()) { + Set cycleSet = new HashSet<>(); + for (Set cycle : info.instantiationGraph.getCycles()) { + cycleSet.addAll(cycle); + } + if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { + error( + "Imported reactor '" + + toDefinition(reactor).getName() + + "' has cyclic instantiation in it.", + Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } } + } - @Check(CheckType.FAST) - public void checkModel(Model model) { - // Since we're doing a fast check, we only want to update - // if the model info hasn't been initialized yet. If it has, - // we use the old information and update it during a normal - // check (see below). - if (!info.updated) { - info.update(model, errorReporter); - } + @Check(CheckType.FAST) + public void checkInput(Input input) { + Reactor parent = (Reactor) input.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); + } + checkName(input.getName(), Literals.VARIABLE__NAME); + if (target.requiresTypes) { + if (input.getType() == null) { + error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); + } } - @Check(CheckType.NORMAL) - public void updateModelInfo(Model model) { - info.update(model, errorReporter); + // mutable has no meaning in C++ + if (input.isMutable() && this.target == Target.CPP) { + warning( + "The mutable qualifier has no meaning for the C++ target and should be removed. " + + "In C++, any value can be made mutable by calling get_mutable_copy().", + Literals.INPUT__MUTABLE); } - @Check(CheckType.FAST) - public void checkOutput(Output output) { - Reactor parent = (Reactor)output.eContainer(); - if (parent.isMain() || parent.isFederated()) { - error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); - } - checkName(output.getName(), Literals.VARIABLE__NAME); - if (this.target.requiresTypes) { - if (output.getType() == null) { - error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); - } - } + // Variable width multiports are not supported (yet?). + if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } + } + + @Check(CheckType.FAST) + public void checkInstantiation(Instantiation instantiation) { + checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); + Reactor reactor = toDefinition(instantiation.getReactorClass()); + if (reactor.isMain() || reactor.isFederated()) { + error( + "Cannot instantiate a main (or federated) reactor: " + + instantiation.getReactorClass().getName(), + Literals.INSTANTIATION__REACTOR_CLASS); + } - // Variable width multiports are not supported (yet?). - if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { - error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); - } + // Report error if this instantiation is part of a cycle. + // FIXME: improve error message. + // FIXME: Also report if there exists a cycle within. + if (this.info.instantiationGraph.getCycles().size() > 0) { + for (Set cycle : this.info.instantiationGraph.getCycles()) { + Reactor container = (Reactor) instantiation.eContainer(); + if (cycle.contains(container) && cycle.contains(reactor)) { + List names = new ArrayList<>(); + for (Reactor r : cycle) { + names.add(r.getName()); + } + + error( + "Instantiation is part of a cycle: " + String.join(", ", names) + ".", + Literals.INSTANTIATION__REACTOR_CLASS); + } + } + } + // Variable width multiports are not supported (yet?). + if (instantiation.getWidthSpec() != null && instantiation.getWidthSpec().isOfVariableLength()) { + if (isCBasedTarget()) { + warning( + "Variable-width banks are for internal use only.", Literals.INSTANTIATION__WIDTH_SPEC); + } else { + error("Variable-width banks are not supported.", Literals.INSTANTIATION__WIDTH_SPEC); + } + } + } + + /** Check target parameters, which are key-value pairs. */ + @Check(CheckType.FAST) + public void checkKeyValuePair(KeyValuePair param) { + // Check only if the container's container is a Target. + if (param.eContainer().eContainer() instanceof TargetDecl) { + TargetProperty prop = TargetProperty.forName(param.getName()); + + // Make sure the key is valid. + if (prop == null) { + String options = + TargetProperty.getOptions().stream() + .map(p -> p.description) + .sorted() + .collect(Collectors.joining(", ")); + warning( + "Unrecognized target parameter: " + + param.getName() + + ". Recognized parameters are: " + + options, + Literals.KEY_VALUE_PAIR__NAME); + } else { + // Check whether the property is supported by the target. + if (!prop.supportedBy.contains(this.target)) { + warning( + "The target parameter: " + + param.getName() + + " is not supported by the " + + this.target + + " target and will thus be ignored.", + Literals.KEY_VALUE_PAIR__NAME); + } + + // Report problem with the assigned value. + prop.type.check(param.getValue(), param.getName(), this); + } + + for (String it : targetPropertyErrors) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyErrors.clear(); + + for (String it : targetPropertyWarnings) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyWarnings.clear(); + } + } + + @Check(CheckType.FAST) + public void checkModel(Model model) { + // Since we're doing a fast check, we only want to update + // if the model info hasn't been initialized yet. If it has, + // we use the old information and update it during a normal + // check (see below). + if (!info.updated) { + info.update(model, errorReporter); + } + } + + @Check(CheckType.NORMAL) + public void updateModelInfo(Model model) { + info.update(model, errorReporter); + } + + @Check(CheckType.FAST) + public void checkOutput(Output output) { + Reactor parent = (Reactor) output.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); + } + checkName(output.getName(), Literals.VARIABLE__NAME); + if (this.target.requiresTypes) { + if (output.getType() == null) { + error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); + } } - @Check(CheckType.FAST) - public void checkParameter(Parameter param) { - checkName(param.getName(), Literals.PARAMETER__NAME); + // Variable width multiports are not supported (yet?). + if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } + } - if (param.getInit() == null) { - // todo make initialization non-mandatory - // https://github.com/lf-lang/lingua-franca/issues/623 - error("Parameter must have a default value.", Literals.PARAMETER__INIT); - return; - } + @Check(CheckType.FAST) + public void checkParameter(Parameter param) { + checkName(param.getName(), Literals.PARAMETER__NAME); - if (this.target.requiresTypes) { - // Report missing target type. param.inferredType.undefine - if (ASTUtils.getInferredType(param).isUndefined()) { - error("Type declaration missing.", Literals.PARAMETER__TYPE); - } - } + if (param.getInit() == null) { + // todo make initialization non-mandatory + // https://github.com/lf-lang/lingua-franca/issues/623 + error("Parameter must have a default value.", Literals.PARAMETER__INIT); + return; + } - if (param.getType() != null) { - typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); - } + if (this.target.requiresTypes) { + // Report missing target type. param.inferredType.undefine + if (ASTUtils.getInferredType(param).isUndefined()) { + error("Type declaration missing.", Literals.PARAMETER__TYPE); + } + } - if (param.getInit() != null) { - for (Expression expr : param.getInit().getExprs()) { - if (expr instanceof ParameterReference) { - // Initialization using parameters is forbidden. - error("Parameter cannot be initialized using parameter.", - Literals.PARAMETER__INIT); - } - } - } + if (param.getType() != null) { + typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); + } - if (this.target == Target.CPP) { - EObject container = param.eContainer(); - Reactor reactor = (Reactor) container; - if (reactor.isMain()) { - // we need to check for the cli parameters that are always taken - List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); - if (cliParams.contains(param.getName())) { - error("Parameter '" + param.getName() - + "' is already in use as command line argument by Lingua Franca,", - Literals.PARAMETER__NAME); - } - } + if (param.getInit() != null) { + for (Expression expr : param.getInit().getExprs()) { + if (expr instanceof ParameterReference) { + // Initialization using parameters is forbidden. + error("Parameter cannot be initialized using parameter.", Literals.PARAMETER__INIT); } + } + } - if (isCBasedTarget() && - this.info.overflowingParameters.contains(param)) { - error( - "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.PARAMETER__INIT); - } - + if (this.target == Target.CPP) { + EObject container = param.eContainer(); + Reactor reactor = (Reactor) container; + if (reactor.isMain()) { + // we need to check for the cli parameters that are always taken + List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); + if (cliParams.contains(param.getName())) { + error( + "Parameter '" + + param.getName() + + "' is already in use as command line argument by Lingua Franca,", + Literals.PARAMETER__NAME); + } + } } - @Check(CheckType.FAST) - public void checkPreamble(Preamble preamble) { - if (this.target == Target.CPP) { - if (preamble.getVisibility() == Visibility.NONE) { - error( - "Preambles for the C++ target need a visibility qualifier (private or public)!", - Literals.PREAMBLE__VISIBILITY - ); - } else if (preamble.getVisibility() == Visibility.PRIVATE) { - EObject container = preamble.eContainer(); - if (container != null && container instanceof Reactor) { - Reactor reactor = (Reactor) container; - if (isGeneric(reactor)) { - warning( - "Private preambles in generic reactors are not truly private. " + - "Since the generated code is placed in a *_impl.hh file, it will " + - "be visible on the public interface. Consider using a public " + - "preamble within the reactor or a private preamble on file scope.", - Literals.PREAMBLE__VISIBILITY); - } - } - } - } else if (preamble.getVisibility() != Visibility.NONE) { + if (isCBasedTarget() && this.info.overflowingParameters.contains(param)) { + error( + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + + " nanoseconds.", + Literals.PARAMETER__INIT); + } + } + + @Check(CheckType.FAST) + public void checkPreamble(Preamble preamble) { + if (this.target == Target.CPP) { + if (preamble.getVisibility() == Visibility.NONE) { + error( + "Preambles for the C++ target need a visibility qualifier (private or public)!", + Literals.PREAMBLE__VISIBILITY); + } else if (preamble.getVisibility() == Visibility.PRIVATE) { + EObject container = preamble.eContainer(); + if (container != null && container instanceof Reactor) { + Reactor reactor = (Reactor) container; + if (isGeneric(reactor)) { warning( - String.format("The %s qualifier has no meaning for the %s target. It should be removed.", - preamble.getVisibility(), this.target.name()), - Literals.PREAMBLE__VISIBILITY - ); - } + "Private preambles in generic reactors are not truly private. " + + "Since the generated code is placed in a *_impl.hh file, it will " + + "be visible on the public interface. Consider using a public " + + "preamble within the reactor or a private preamble on file scope.", + Literals.PREAMBLE__VISIBILITY); + } + } + } + } else if (preamble.getVisibility() != Visibility.NONE) { + warning( + String.format( + "The %s qualifier has no meaning for the %s target. It should be removed.", + preamble.getVisibility(), this.target.name()), + Literals.PREAMBLE__VISIBILITY); } + } - @Check(CheckType.FAST) - public void checkReaction(Reaction reaction) { - - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); - } - HashSet triggers = new HashSet<>(); - // Make sure input triggers have no container and output sources do. - for (TriggerRef trigger : reaction.getTriggers()) { - if (trigger instanceof VarRef) { - VarRef triggerVarRef = (VarRef) trigger; - triggers.add(triggerVarRef.getVariable()); - if (triggerVarRef instanceof Input) { - if (triggerVarRef.getContainer() != null) { - error(String.format("Cannot have an input of a contained reactor as a trigger: %s.%s", triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), - Literals.REACTION__TRIGGERS); - } - } else if (triggerVarRef.getVariable() instanceof Output) { - if (triggerVarRef.getContainer() == null) { - error(String.format("Cannot have an output of this reactor as a trigger: %s", triggerVarRef.getVariable().getName()), - Literals.REACTION__TRIGGERS); - } - } - } - } + @Check(CheckType.FAST) + public void checkReaction(Reaction reaction) { - // Make sure input sources have no container and output sources do. - // Also check that a source is not already listed as a trigger. - for (VarRef source : reaction.getSources()) { - if (triggers.contains(source.getVariable())) { - error(String.format("Source is already listed as a trigger: %s", source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - if (source.getVariable() instanceof Input) { - if (source.getContainer() != null) { - error(String.format("Cannot have an input of a contained reactor as a source: %s.%s", source.getContainer().getName(), source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - } else if (source.getVariable() instanceof Output) { - if (source.getContainer() == null) { - error(String.format("Cannot have an output of this reactor as a source: %s", source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - } - } - - // Make sure output effects have no container and input effects do. - for (VarRef effect : reaction.getEffects()) { - if (effect.getVariable() instanceof Input) { - if (effect.getContainer() == null) { - error(String.format("Cannot have an input of this reactor as an effect: %s", effect.getVariable().getName()), - Literals.REACTION__EFFECTS); - } - } else if (effect.getVariable() instanceof Output) { - if (effect.getContainer() != null) { - error(String.format("Cannot have an output of a contained reactor as an effect: %s.%s", effect.getContainer().getName(), effect.getVariable().getName()), - Literals.REACTION__EFFECTS); - } - } - } - - // // Report error if this reaction is part of a cycle. - Set> cycles = this.info.topologyCycles(); - Reactor reactor = ASTUtils.getEnclosingReactor(reaction); - boolean reactionInCycle = false; - for (NamedInstance it : cycles) { - if (it.getDefinition().equals(reaction)) { - reactionInCycle = true; - break; - } - } - if (reactionInCycle) { - // Report involved triggers. - List trigs = new ArrayList<>(); - for (TriggerRef t : reaction.getTriggers()) { - if (!(t instanceof VarRef)) { - continue; - } - VarRef tVarRef = (VarRef) t; - boolean triggerExistsInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(tVarRef.getVariable())) { - triggerExistsInCycle = true; - break; - } - } - if (triggerExistsInCycle) { - trigs.add(toOriginalText(tVarRef)); - } - } - if (trigs.size() > 0) { - error(String.format("Reaction triggers involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", trigs)), - Literals.REACTION__TRIGGERS); - } - - // Report involved sources. - List sources = new ArrayList<>(); - for (VarRef t : reaction.getSources()) { - boolean sourceExistInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(t.getVariable())) { - sourceExistInCycle = true; - break; - } - } - if (sourceExistInCycle) { - sources.add(toOriginalText(t)); - } - } - if (sources.size() > 0) { - error(String.format("Reaction sources involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", sources)), - Literals.REACTION__SOURCES); - } - - // Report involved effects. - List effects = new ArrayList<>(); - for (VarRef t : reaction.getEffects()) { - boolean effectExistInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(t.getVariable())) { - effectExistInCycle = true; - break; - } - } - if (effectExistInCycle) { - effects.add(toOriginalText(t)); - } - } - if (effects.size() > 0) { - error(String.format("Reaction effects involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", effects)), - Literals.REACTION__EFFECTS); - } - - if (trigs.size() + sources.size() == 0) { - error( - String.format("Cyclic dependency due to preceding reaction. Consider reordering reactions within reactor %s to avoid causality loop.", reactor.getName()), - reaction.eContainer(), - Literals.REACTOR__REACTIONS, - reactor.getReactions().indexOf(reaction) - ); - } else if (effects.size() == 0) { - error( - String.format("Cyclic dependency due to succeeding reaction. Consider reordering reactions within reactor %s to avoid causality loop.", reactor.getName()), - reaction.eContainer(), - Literals.REACTOR__REACTIONS, - reactor.getReactions().indexOf(reaction) - ); - } - // Not reporting reactions that are part of cycle _only_ due to reaction ordering. - // Moving them won't help solve the problem. - } - // FIXME: improve error message. + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); } - - @Check(CheckType.FAST) - public void checkReactor(Reactor reactor) throws IOException { - Set superClasses = ASTUtils.superClasses(reactor); - if (superClasses == null) { + HashSet triggers = new HashSet<>(); + // Make sure input triggers have no container and output sources do. + for (TriggerRef trigger : reaction.getTriggers()) { + if (trigger instanceof VarRef) { + VarRef triggerVarRef = (VarRef) trigger; + triggers.add(triggerVarRef.getVariable()); + if (triggerVarRef instanceof Input) { + if (triggerVarRef.getContainer() != null) { error( - "Problem with superclasses: Either they form a cycle or are not defined", - Literals.REACTOR_DECL__NAME - ); - // Continue checks, but without any superclasses. - superClasses = new LinkedHashSet<>(); - } - String name = FileUtil.nameWithoutExtension(reactor.eResource()); - if (reactor.getName() == null) { - if (!reactor.isFederated() && !reactor.isMain()) { - error( - "Reactor must be named.", - Literals.REACTOR_DECL__NAME - ); - // Prevent NPE in tests below. - return; - } - } - TreeIterator iter = reactor.eResource().getAllContents(); - if (reactor.isFederated() || reactor.isMain()) { - if(reactor.getName() != null && !reactor.getName().equals(name)) { - // Make sure that if the name is given, it matches the expected name. - error( - "Name of main reactor must match the file name (or be omitted).", - Literals.REACTOR_DECL__NAME - ); - } - // Do not allow multiple main/federated reactors. - int nMain = countMainOrFederated(iter); - if (nMain > 1) { - EAttribute attribute = Literals.REACTOR__MAIN; - if (reactor.isFederated()) { - attribute = Literals.REACTOR__FEDERATED; - } - error( - "Multiple definitions of main or federated reactor.", - attribute - ); - } - } else { - // Not federated or main. - int nMain = countMainOrFederated(iter); - if (nMain > 0 && reactor.getName().equals(name)) { - error( - "Name conflict with main reactor.", - Literals.REACTOR_DECL__NAME - ); - } - } - - // Check for illegal names. - checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); - - // C++ reactors may not be called 'preamble' - if (this.target == Target.CPP && reactor.getName().equalsIgnoreCase("preamble")) { + String.format( + "Cannot have an input of a contained reactor as a trigger: %s.%s", + triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } + } else if (triggerVarRef.getVariable() instanceof Output) { + if (triggerVarRef.getContainer() == null) { error( - "Reactor cannot be named '" + reactor.getName() + "'", - Literals.REACTOR_DECL__NAME - ); - } - - if (reactor.getHost() != null) { - if (!reactor.isFederated()) { - error( - "Cannot assign a host to reactor '" + reactor.getName() + - "' because it is not federated.", - Literals.REACTOR__HOST - ); - } + String.format( + "Cannot have an output of this reactor as a trigger: %s", + triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } } + } + } - List variables = new ArrayList<>(); - variables.addAll(reactor.getInputs()); - variables.addAll(reactor.getOutputs()); - variables.addAll(reactor.getActions()); - variables.addAll(reactor.getTimers()); - - // Perform checks on super classes. - for (Reactor superClass : superClasses) { - HashSet conflicts = new HashSet<>(); - - // Detect input conflicts - checkConflict(superClass.getInputs(), reactor.getInputs(), variables, conflicts); - // Detect output conflicts - checkConflict(superClass.getOutputs(), reactor.getOutputs(), variables, conflicts); - // Detect output conflicts - checkConflict(superClass.getActions(), reactor.getActions(), variables, conflicts); - // Detect conflicts - for (Timer timer : superClass.getTimers()) { - List filteredVariables = new ArrayList<>(variables); - filteredVariables.removeIf(it -> reactor.getTimers().contains(it)); - if (hasNameConflict(timer, filteredVariables)) { - conflicts.add(timer); - } else { - variables.add(timer); - } - } + // Make sure input sources have no container and output sources do. + // Also check that a source is not already listed as a trigger. + for (VarRef source : reaction.getSources()) { + if (triggers.contains(source.getVariable())) { + error( + String.format( + "Source is already listed as a trigger: %s", source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + if (source.getVariable() instanceof Input) { + if (source.getContainer() != null) { + error( + String.format( + "Cannot have an input of a contained reactor as a source: %s.%s", + source.getContainer().getName(), source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } else if (source.getVariable() instanceof Output) { + if (source.getContainer() == null) { + error( + String.format( + "Cannot have an output of this reactor as a source: %s", + source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } + } - // Report conflicts. - if (conflicts.size() > 0) { - List names = new ArrayList<>(); - for (Variable it : conflicts) { - names.add(it.getName()); - } - error( - String.format("Cannot extend %s due to the following conflicts: %s.", - superClass.getName(), String.join(",", names)), - Literals.REACTOR__SUPER_CLASSES - ); - } - } + // Make sure output effects have no container and input effects do. + for (VarRef effect : reaction.getEffects()) { + if (effect.getVariable() instanceof Input) { + if (effect.getContainer() == null) { + error( + String.format( + "Cannot have an input of this reactor as an effect: %s", + effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } else if (effect.getVariable() instanceof Output) { + if (effect.getContainer() != null) { + error( + String.format( + "Cannot have an output of a contained reactor as an effect: %s.%s", + effect.getContainer().getName(), effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } + } + // // Report error if this reaction is part of a cycle. + Set> cycles = this.info.topologyCycles(); + Reactor reactor = ASTUtils.getEnclosingReactor(reaction); + boolean reactionInCycle = false; + for (NamedInstance it : cycles) { + if (it.getDefinition().equals(reaction)) { + reactionInCycle = true; + break; + } + } + if (reactionInCycle) { + // Report involved triggers. + List trigs = new ArrayList<>(); + for (TriggerRef t : reaction.getTriggers()) { + if (!(t instanceof VarRef)) { + continue; + } + VarRef tVarRef = (VarRef) t; + boolean triggerExistsInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(tVarRef.getVariable())) { + triggerExistsInCycle = true; + break; + } + } + if (triggerExistsInCycle) { + trigs.add(toOriginalText(tVarRef)); + } + } + if (trigs.size() > 0) { + error( + String.format( + "Reaction triggers involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", trigs)), + Literals.REACTION__TRIGGERS); + } + + // Report involved sources. + List sources = new ArrayList<>(); + for (VarRef t : reaction.getSources()) { + boolean sourceExistInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(t.getVariable())) { + sourceExistInCycle = true; + break; + } + } + if (sourceExistInCycle) { + sources.add(toOriginalText(t)); + } + } + if (sources.size() > 0) { + error( + String.format( + "Reaction sources involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", sources)), + Literals.REACTION__SOURCES); + } + + // Report involved effects. + List effects = new ArrayList<>(); + for (VarRef t : reaction.getEffects()) { + boolean effectExistInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(t.getVariable())) { + effectExistInCycle = true; + break; + } + } + if (effectExistInCycle) { + effects.add(toOriginalText(t)); + } + } + if (effects.size() > 0) { + error( + String.format( + "Reaction effects involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", effects)), + Literals.REACTION__EFFECTS); + } + + if (trigs.size() + sources.size() == 0) { + error( + String.format( + "Cyclic dependency due to preceding reaction. Consider reordering reactions within" + + " reactor %s to avoid causality loop.", + reactor.getName()), + reaction.eContainer(), + Literals.REACTOR__REACTIONS, + reactor.getReactions().indexOf(reaction)); + } else if (effects.size() == 0) { + error( + String.format( + "Cyclic dependency due to succeeding reaction. Consider reordering reactions within" + + " reactor %s to avoid causality loop.", + reactor.getName()), + reaction.eContainer(), + Literals.REACTOR__REACTIONS, + reactor.getReactions().indexOf(reaction)); + } + // Not reporting reactions that are part of cycle _only_ due to reaction ordering. + // Moving them won't help solve the problem. + } + // FIXME: improve error message. + } + + @Check(CheckType.FAST) + public void checkReactor(Reactor reactor) throws IOException { + Set superClasses = ASTUtils.superClasses(reactor); + if (superClasses == null) { + error( + "Problem with superclasses: Either they form a cycle or are not defined", + Literals.REACTOR_DECL__NAME); + // Continue checks, but without any superclasses. + superClasses = new LinkedHashSet<>(); + } + String name = FileUtil.nameWithoutExtension(reactor.eResource()); + if (reactor.getName() == null) { + if (!reactor.isFederated() && !reactor.isMain()) { + error("Reactor must be named.", Literals.REACTOR_DECL__NAME); + // Prevent NPE in tests below. + return; + } + } + TreeIterator iter = reactor.eResource().getAllContents(); + if (reactor.isFederated() || reactor.isMain()) { + if (reactor.getName() != null && !reactor.getName().equals(name)) { + // Make sure that if the name is given, it matches the expected name. + error( + "Name of main reactor must match the file name (or be omitted).", + Literals.REACTOR_DECL__NAME); + } + // Do not allow multiple main/federated reactors. + int nMain = countMainOrFederated(iter); + if (nMain > 1) { + EAttribute attribute = Literals.REACTOR__MAIN; if (reactor.isFederated()) { - FedValidator.validateFederatedReactor(reactor, this.errorReporter); - } + attribute = Literals.REACTOR__FEDERATED; + } + error("Multiple definitions of main or federated reactor.", attribute); + } + } else { + // Not federated or main. + int nMain = countMainOrFederated(iter); + if (nMain > 0 && reactor.getName().equals(name)) { + error("Name conflict with main reactor.", Literals.REACTOR_DECL__NAME); + } } - /** - * Check if the requested serialization is supported. - */ - @Check(CheckType.FAST) - public void checkSerializer(Serializer serializer) { - boolean isValidSerializer = false; - for (SupportedSerializers method : SupportedSerializers.values()) { - if (method.name().equalsIgnoreCase(serializer.getType())){ - isValidSerializer = true; - } - } - - if (!isValidSerializer) { - error( - "Serializer can be " + Arrays.asList(SupportedSerializers.values()), - Literals.SERIALIZER__TYPE - ); - } + // Check for illegal names. + checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); + + // C++ reactors may not be called 'preamble' + if (this.target == Target.CPP && reactor.getName().equalsIgnoreCase("preamble")) { + error("Reactor cannot be named '" + reactor.getName() + "'", Literals.REACTOR_DECL__NAME); } - @Check(CheckType.FAST) - public void checkState(StateVar stateVar) { - checkName(stateVar.getName(), Literals.STATE_VAR__NAME); - if (stateVar.getInit() != null && stateVar.getInit().getExprs().size() != 0) { - typeCheck(stateVar.getInit(), ASTUtils.getInferredType(stateVar), Literals.STATE_VAR__INIT); - } + if (reactor.getHost() != null) { + if (!reactor.isFederated()) { + error( + "Cannot assign a host to reactor '" + + reactor.getName() + + "' because it is not federated.", + Literals.REACTOR__HOST); + } + } - if (this.target.requiresTypes && ASTUtils.getInferredType(stateVar).isUndefined()) { - // Report if a type is missing - error("State must have a type.", Literals.STATE_VAR__TYPE); - } + List variables = new ArrayList<>(); + variables.addAll(reactor.getInputs()); + variables.addAll(reactor.getOutputs()); + variables.addAll(reactor.getActions()); + variables.addAll(reactor.getTimers()); + + // Perform checks on super classes. + for (Reactor superClass : superClasses) { + HashSet conflicts = new HashSet<>(); + + // Detect input conflicts + checkConflict(superClass.getInputs(), reactor.getInputs(), variables, conflicts); + // Detect output conflicts + checkConflict(superClass.getOutputs(), reactor.getOutputs(), variables, conflicts); + // Detect output conflicts + checkConflict(superClass.getActions(), reactor.getActions(), variables, conflicts); + // Detect conflicts + for (Timer timer : superClass.getTimers()) { + List filteredVariables = new ArrayList<>(variables); + filteredVariables.removeIf(it -> reactor.getTimers().contains(it)); + if (hasNameConflict(timer, filteredVariables)) { + conflicts.add(timer); + } else { + variables.add(timer); + } + } + + // Report conflicts. + if (conflicts.size() > 0) { + List names = new ArrayList<>(); + for (Variable it : conflicts) { + names.add(it.getName()); + } + error( + String.format( + "Cannot extend %s due to the following conflicts: %s.", + superClass.getName(), String.join(",", names)), + Literals.REACTOR__SUPER_CLASSES); + } + } - if (isCBasedTarget() - && ASTUtils.isListInitializer(stateVar.getInit()) - && stateVar.getInit().getExprs().stream().anyMatch(it -> it instanceof ParameterReference)) { - // In C, if initialization is done with a list, elements cannot - // refer to parameters. - error("List items cannot refer to a parameter.", - Literals.STATE_VAR__INIT); - } + if (reactor.isFederated()) { + FedValidator.validateFederatedReactor(reactor, this.errorReporter); + } + } + + /** Check if the requested serialization is supported. */ + @Check(CheckType.FAST) + public void checkSerializer(Serializer serializer) { + boolean isValidSerializer = false; + for (SupportedSerializers method : SupportedSerializers.values()) { + if (method.name().equalsIgnoreCase(serializer.getType())) { + isValidSerializer = true; + } + } + if (!isValidSerializer) { + error( + "Serializer can be " + Arrays.asList(SupportedSerializers.values()), + Literals.SERIALIZER__TYPE); } + } - @Check(CheckType.FAST) - public void checkSTPOffset(STP stp) { - if (isCBasedTarget() && - this.info.overflowingSTP.contains(stp)) { - error( - "STP offset exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.STP__VALUE); - } + @Check(CheckType.FAST) + public void checkState(StateVar stateVar) { + checkName(stateVar.getName(), Literals.STATE_VAR__NAME); + if (stateVar.getInit() != null && stateVar.getInit().getExprs().size() != 0) { + typeCheck(stateVar.getInit(), ASTUtils.getInferredType(stateVar), Literals.STATE_VAR__INIT); } - @Check(CheckType.FAST) - public void checkTargetDecl(TargetDecl target) throws IOException { - Optional targetOpt = Target.forName(target.getName()); - if (targetOpt.isEmpty()) { - error("Unrecognized target: " + target.getName(), - Literals.TARGET_DECL__NAME); - } else { - this.target = targetOpt.get(); - } - String lfFileName = FileUtil.nameWithoutExtension(target.eResource()); - if (Character.isDigit(lfFileName.charAt(0))) { - errorReporter.reportError("LF file names must not start with a number"); - } + if (this.target.requiresTypes && ASTUtils.getInferredType(stateVar).isUndefined()) { + // Report if a type is missing + error("State must have a type.", Literals.STATE_VAR__TYPE); } - /** - * Check for consistency of the target properties, which are - * defined as KeyValuePairs. - * - * @param targetProperties The target properties defined - * in the current Lingua Franca program. - */ - @Check(CheckType.EXPENSIVE) - public void checkTargetProperties(KeyValuePairs targetProperties) { - validateFastTargetProperty(targetProperties); - validateClockSyncTargetProperties(targetProperties); - validateSchedulerTargetProperties(targetProperties); - validateRos2TargetProperties(targetProperties); - validateKeepalive(targetProperties); - } - - private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { - List properties = targetProperties.getPairs().stream() + if (isCBasedTarget() + && ASTUtils.isListInitializer(stateVar.getInit()) + && stateVar.getInit().getExprs().stream() + .anyMatch(it -> it instanceof ParameterReference)) { + // In C, if initialization is done with a list, elements cannot + // refer to parameters. + error("List items cannot refer to a parameter.", Literals.STATE_VAR__INIT); + } + } + + @Check(CheckType.FAST) + public void checkSTPOffset(STP stp) { + if (isCBasedTarget() && this.info.overflowingSTP.contains(stp)) { + error( + "STP offset exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.STP__VALUE); + } + } + + @Check(CheckType.FAST) + public void checkTargetDecl(TargetDecl target) throws IOException { + Optional targetOpt = Target.forName(target.getName()); + if (targetOpt.isEmpty()) { + error("Unrecognized target: " + target.getName(), Literals.TARGET_DECL__NAME); + } else { + this.target = targetOpt.get(); + } + String lfFileName = FileUtil.nameWithoutExtension(target.eResource()); + if (Character.isDigit(lfFileName.charAt(0))) { + errorReporter.reportError("LF file names must not start with a number"); + } + } + + /** + * Check for consistency of the target properties, which are defined as KeyValuePairs. + * + * @param targetProperties The target properties defined in the current Lingua Franca program. + */ + @Check(CheckType.EXPENSIVE) + public void checkTargetProperties(KeyValuePairs targetProperties) { + validateFastTargetProperty(targetProperties); + validateClockSyncTargetProperties(targetProperties); + validateSchedulerTargetProperties(targetProperties); + validateRos2TargetProperties(targetProperties); + validateKeepalive(targetProperties); + } + + private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { + List properties = + targetProperties.getPairs().stream() .filter(pair -> pair.getName().equals(property.description)) .toList(); - assert (properties.size() <= 1); - return properties.size() > 0 ? properties.get(0) : null; - } - private void validateFastTargetProperty(KeyValuePairs targetProperties) { - KeyValuePair fastTargetProperty = getKeyValuePair(targetProperties, TargetProperty.FAST); - - if (fastTargetProperty != null) { - // Check for federated - for (Reactor reactor : info.model.getReactors()) { - // Check to see if the program has a federated reactor - if (reactor.isFederated()) { - error( - "The fast target property is incompatible with federated programs.", - fastTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - break; - } - } - - // Check for physical actions - for (Reactor reactor : info.model.getReactors()) { - // Check to see if the program has a physical action in a reactor - for (Action action : reactor.getActions()) { - if (action.getOrigin().equals(ActionOrigin.PHYSICAL)) { - error( - "The fast target property is incompatible with physical actions.", - fastTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - break; - } - } - } - } - } + assert (properties.size() <= 1); + return properties.size() > 0 ? properties.get(0) : null; + } - private void validateClockSyncTargetProperties(KeyValuePairs targetProperties) { - KeyValuePair clockSyncTargetProperty = getKeyValuePair(targetProperties, TargetProperty.CLOCK_SYNC); + private void validateFastTargetProperty(KeyValuePairs targetProperties) { + KeyValuePair fastTargetProperty = getKeyValuePair(targetProperties, TargetProperty.FAST); - if (clockSyncTargetProperty != null) { - boolean federatedExists = false; - for (Reactor reactor : info.model.getReactors()) { - if (reactor.isFederated()) { - federatedExists = true; - } - } - if (!federatedExists) { - warning( - "The clock-sync target property is incompatible with non-federated programs.", - clockSyncTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - } + if (fastTargetProperty != null) { + // Check for federated + for (Reactor reactor : info.model.getReactors()) { + // Check to see if the program has a federated reactor + if (reactor.isFederated()) { + error( + "The fast target property is incompatible with federated programs.", + fastTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + break; + } + } + + // Check for physical actions + for (Reactor reactor : info.model.getReactors()) { + // Check to see if the program has a physical action in a reactor + for (Action action : reactor.getActions()) { + if (action.getOrigin().equals(ActionOrigin.PHYSICAL)) { + error( + "The fast target property is incompatible with physical actions.", + fastTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + break; + } } + } } + } - private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { - KeyValuePair schedulerTargetProperty = getKeyValuePair(targetProperties, TargetProperty.SCHEDULER); - if (schedulerTargetProperty != null) { - String schedulerName = ASTUtils.elementToSingleString(schedulerTargetProperty.getValue()); - try { - if (!TargetProperty.SchedulerOption.valueOf(schedulerName) - .prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - // Filter reactors that contain at least one reaction that - // has a deadline handler. - if (info.model.getReactors().stream().anyMatch( - // Filter reactors that contain at least one reaction that - // has a deadline handler. - reactor -> ASTUtils.allReactions(reactor).stream().anyMatch( - reaction -> reaction.getDeadline() != null - )) - ) { - warning("This program contains deadlines, but the chosen " - + schedulerName - + " scheduler does not prioritize reaction execution " - + "based on deadlines. This might result in a sub-optimal " - + "scheduling.", schedulerTargetProperty, - Literals.KEY_VALUE_PAIR__VALUE); - } - } - } catch (IllegalArgumentException e) { - // the given scheduler is invalid, but this is already checked by - // checkTargetProperties - } - } - } + private void validateClockSyncTargetProperties(KeyValuePairs targetProperties) { + KeyValuePair clockSyncTargetProperty = + getKeyValuePair(targetProperties, TargetProperty.CLOCK_SYNC); - private void validateKeepalive(KeyValuePairs targetProperties) { - KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); - if (keepalive != null && target == Target.CPP) { - warning("The keepalive property is inferred automatically by the C++ " + - "runtime and the value given here is ignored", keepalive, Literals.KEY_VALUE_PAIR__NAME); - } + if (clockSyncTargetProperty != null) { + boolean federatedExists = false; + for (Reactor reactor : info.model.getReactors()) { + if (reactor.isFederated()) { + federatedExists = true; + } + } + if (!federatedExists) { + warning( + "The clock-sync target property is incompatible with non-federated programs.", + clockSyncTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + } } - - private void validateRos2TargetProperties(KeyValuePairs targetProperties) { - KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); - KeyValuePair ros2Dependencies = getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); - if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { + } + + private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { + KeyValuePair schedulerTargetProperty = + getKeyValuePair(targetProperties, TargetProperty.SCHEDULER); + if (schedulerTargetProperty != null) { + String schedulerName = ASTUtils.elementToSingleString(schedulerTargetProperty.getValue()); + try { + if (!TargetProperty.SchedulerOption.valueOf(schedulerName).prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + // Filter reactors that contain at least one reaction that + // has a deadline handler. + if (info.model.getReactors().stream() + .anyMatch( + // Filter reactors that contain at least one reaction that + // has a deadline handler. + reactor -> + ASTUtils.allReactions(reactor).stream() + .anyMatch(reaction -> reaction.getDeadline() != null))) { warning( - "Ignoring ros2-dependencies as ros2 compilation is disabled", - ros2Dependencies, - Literals.KEY_VALUE_PAIR__NAME - ); - } + "This program contains deadlines, but the chosen " + + schedulerName + + " scheduler does not prioritize reaction execution " + + "based on deadlines. This might result in a sub-optimal " + + "scheduling.", + schedulerTargetProperty, + Literals.KEY_VALUE_PAIR__VALUE); + } + } + } catch (IllegalArgumentException e) { + // the given scheduler is invalid, but this is already checked by + // checkTargetProperties + } } - - @Check(CheckType.FAST) - public void checkTimer(Timer timer) { - checkName(timer.getName(), Literals.VARIABLE__NAME); - checkExpressionIsTime(timer.getOffset(), Literals.TIMER__OFFSET); - checkExpressionIsTime(timer.getPeriod(), Literals.TIMER__PERIOD); + } + + private void validateKeepalive(KeyValuePairs targetProperties) { + KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); + if (keepalive != null && target == Target.CPP) { + warning( + "The keepalive property is inferred automatically by the C++ " + + "runtime and the value given here is ignored", + keepalive, + Literals.KEY_VALUE_PAIR__NAME); } - - @Check(CheckType.FAST) - public void checkType(Type type) { - // FIXME: disallow the use of generics in C - if (this.target == Target.Python) { - if (type != null) { - error( - "Types are not allowed in the Python target", - Literals.TYPE__ID - ); - } - } + } + + private void validateRos2TargetProperties(KeyValuePairs targetProperties) { + KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); + KeyValuePair ros2Dependencies = + getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); + if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { + warning( + "Ignoring ros2-dependencies as ros2 compilation is disabled", + ros2Dependencies, + Literals.KEY_VALUE_PAIR__NAME); } - - @Check(CheckType.FAST) - public void checkVarRef(VarRef varRef) { - // check correct usage of interleaved - if (varRef.isInterleaved()) { - var supportedTargets = List.of(Target.CPP, Target.Python, Target.Rust); - if (!supportedTargets.contains(this.target) && !isCBasedTarget()) { - error("This target does not support interleaved port references.", Literals.VAR_REF__INTERLEAVED); - } - if (!(varRef.eContainer() instanceof Connection)) { - error("interleaved can only be used in connections.", Literals.VAR_REF__INTERLEAVED); - } - - if (varRef.getVariable() instanceof Port) { - // This test only works correctly if the variable is actually a port. If it is not a port, other - // validator rules will produce error messages. - if (varRef.getContainer() == null || varRef.getContainer().getWidthSpec() == null || - ((Port) varRef.getVariable()).getWidthSpec() == null - ) { - error("interleaved can only be used for multiports contained within banks.", Literals.VAR_REF__INTERLEAVED); - } - } - } + } + + @Check(CheckType.FAST) + public void checkTimer(Timer timer) { + checkName(timer.getName(), Literals.VARIABLE__NAME); + checkExpressionIsTime(timer.getOffset(), Literals.TIMER__OFFSET); + checkExpressionIsTime(timer.getPeriod(), Literals.TIMER__PERIOD); + } + + @Check(CheckType.FAST) + public void checkType(Type type) { + // FIXME: disallow the use of generics in C + if (this.target == Target.Python) { + if (type != null) { + error("Types are not allowed in the Python target", Literals.TYPE__ID); + } } - - /** - * Check whether an attribute is supported - * and the validity of the attribute. - * - * @param attr The attribute being checked - */ - @Check(CheckType.FAST) - public void checkAttributes(Attribute attr) { - String name = attr.getAttrName().toString(); - AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); - if (spec == null) { - error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); - return; - } - // Check the validity of the attribute. - spec.check(this, attr); + } + + @Check(CheckType.FAST) + public void checkVarRef(VarRef varRef) { + // check correct usage of interleaved + if (varRef.isInterleaved()) { + var supportedTargets = List.of(Target.CPP, Target.Python, Target.Rust); + if (!supportedTargets.contains(this.target) && !isCBasedTarget()) { + error( + "This target does not support interleaved port references.", + Literals.VAR_REF__INTERLEAVED); + } + if (!(varRef.eContainer() instanceof Connection)) { + error("interleaved can only be used in connections.", Literals.VAR_REF__INTERLEAVED); + } + + if (varRef.getVariable() instanceof Port) { + // This test only works correctly if the variable is actually a port. If it is not a port, + // other + // validator rules will produce error messages. + if (varRef.getContainer() == null + || varRef.getContainer().getWidthSpec() == null + || ((Port) varRef.getVariable()).getWidthSpec() == null) { + error( + "interleaved can only be used for multiports contained within banks.", + Literals.VAR_REF__INTERLEAVED); + } + } } - - @Check(CheckType.FAST) - public void checkWidthSpec(WidthSpec widthSpec) { - if (!this.target.supportsMultiports()) { - error("Multiports and banks are currently not supported by the given target.", + } + + /** + * Check whether an attribute is supported and the validity of the attribute. + * + * @param attr The attribute being checked + */ + @Check(CheckType.FAST) + public void checkAttributes(Attribute attr) { + String name = attr.getAttrName().toString(); + AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); + if (spec == null) { + error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); + return; + } + // Check the validity of the attribute. + spec.check(this, attr); + } + + @Check(CheckType.FAST) + public void checkWidthSpec(WidthSpec widthSpec) { + if (!this.target.supportsMultiports()) { + error( + "Multiports and banks are currently not supported by the given target.", + Literals.WIDTH_SPEC__TERMS); + } else { + for (WidthTerm term : widthSpec.getTerms()) { + if (term.getParameter() != null) { + if (!this.target.supportsParameterizedWidths()) { + error( + "Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); - } else { - for (WidthTerm term : widthSpec.getTerms()) { - if (term.getParameter() != null) { - if (!this.target.supportsParameterizedWidths()) { - error("Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); - } - } else if (term.getPort() != null) { - // Widths given with `widthof()` are not supported (yet?). - // This feature is currently only used for after delays. - error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); - } else if (term.getCode() != null) { - if (this.target != Target.CPP) { - error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); - } - } else if (term.getWidth() < 0) { - error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); - } - } - } + } + } else if (term.getPort() != null) { + // Widths given with `widthof()` are not supported (yet?). + // This feature is currently only used for after delays. + error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); + } else if (term.getCode() != null) { + if (this.target != Target.CPP) { + error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); + } + } else if (term.getWidth() < 0) { + error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); + } + } } - - @Check(CheckType.FAST) - public void checkReactorIconAttribute(Reactor reactor) { - var path = AttributeUtils.getIconPath(reactor); - if (path != null) { - var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); - // Check file extension - var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); - var extensionStrart = path.lastIndexOf("."); - var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; - if (!validExtensions.contains(extension.toLowerCase())) { - warning("File extension '" + extension + "' is not supported. Provide any of: " + String.join(", ", validExtensions), - param, Literals.ATTR_PARM__VALUE); - return; - } - - // Check file location - var iconLocation = FileUtil.locateFile(path, reactor.eResource()); - if (iconLocation == null) { - warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); - } - if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) && !(new File(iconLocation.getPath()).exists())) { - warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); - } - } + } + + @Check(CheckType.FAST) + public void checkReactorIconAttribute(Reactor reactor) { + var path = AttributeUtils.getIconPath(reactor); + if (path != null) { + var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); + // Check file extension + var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); + var extensionStrart = path.lastIndexOf("."); + var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; + if (!validExtensions.contains(extension.toLowerCase())) { + warning( + "File extension '" + + extension + + "' is not supported. Provide any of: " + + String.join(", ", validExtensions), + param, + Literals.ATTR_PARM__VALUE); + return; + } + + // Check file location + var iconLocation = FileUtil.locateFile(path, reactor.eResource()); + if (iconLocation == null) { + warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); + } + if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) + && !(new File(iconLocation.getPath()).exists())) { + warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); + } } - - @Check(CheckType.FAST) - public void checkInitialMode(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - long initialModesCount = reactor.getModes().stream().filter(m -> m.isInitial()).count(); - if (initialModesCount == 0) { - error("Every modal reactor requires one initial mode.", Literals.REACTOR__MODES, 0); - } else if (initialModesCount > 1) { - reactor.getModes().stream().filter(m -> m.isInitial()).skip(1).forEach(m -> { - error("A modal reactor can only have one initial mode.", - Literals.REACTOR__MODES, reactor.getModes().indexOf(m)); + } + + @Check(CheckType.FAST) + public void checkInitialMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + long initialModesCount = reactor.getModes().stream().filter(m -> m.isInitial()).count(); + if (initialModesCount == 0) { + error("Every modal reactor requires one initial mode.", Literals.REACTOR__MODES, 0); + } else if (initialModesCount > 1) { + reactor.getModes().stream() + .filter(m -> m.isInitial()) + .skip(1) + .forEach( + m -> { + error( + "A modal reactor can only have one initial mode.", + Literals.REACTOR__MODES, + reactor.getModes().indexOf(m)); }); - } - } + } } - - @Check(CheckType.FAST) - public void checkModeStateNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getStateVars().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var stateVar : mode.getStateVars()) { - if (names.contains(stateVar.getName())) { - error(String.format("Duplicate state variable '%s'. (State variables are currently scoped on reactor level not modes)", - stateVar.getName()), stateVar, Literals.STATE_VAR__NAME); - } - names.add(stateVar.getName()); - } - } - } + } + + @Check(CheckType.FAST) + public void checkModeStateNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getStateVars().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var stateVar : mode.getStateVars()) { + if (names.contains(stateVar.getName())) { + error( + String.format( + "Duplicate state variable '%s'. (State variables are currently scoped on" + + " reactor level not modes)", + stateVar.getName()), + stateVar, + Literals.STATE_VAR__NAME); + } + names.add(stateVar.getName()); + } + } } - - @Check(CheckType.FAST) - public void checkModeTimerNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getTimers().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var timer : mode.getTimers()) { - if (names.contains(timer.getName())) { - error(String.format("Duplicate Timer '%s'. (Timers are currently scoped on reactor level not modes)", - timer.getName()), timer, Literals.VARIABLE__NAME); - } - names.add(timer.getName()); - } - } - } + } + + @Check(CheckType.FAST) + public void checkModeTimerNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getTimers().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var timer : mode.getTimers()) { + if (names.contains(timer.getName())) { + error( + String.format( + "Duplicate Timer '%s'. (Timers are currently scoped on reactor level not" + + " modes)", + timer.getName()), + timer, + Literals.VARIABLE__NAME); + } + names.add(timer.getName()); + } + } } - - @Check(CheckType.FAST) - public void checkModeActionNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var action : mode.getActions()) { - if (names.contains(action.getName())) { - error(String.format("Duplicate Action '%s'. (Actions are currently scoped on reactor level not modes)", - action.getName()), action, Literals.VARIABLE__NAME); - } - names.add(action.getName()); - } - } - } + } + + @Check(CheckType.FAST) + public void checkModeActionNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var action : mode.getActions()) { + if (names.contains(action.getName())) { + error( + String.format( + "Duplicate Action '%s'. (Actions are currently scoped on reactor level not" + + " modes)", + action.getName()), + action, + Literals.VARIABLE__NAME); + } + names.add(action.getName()); + } + } } - - @Check(CheckType.FAST) - public void checkModeInstanceNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var instantiation : mode.getInstantiations()) { - if (names.contains(instantiation.getName())) { - error(String.format("Duplicate Instantiation '%s'. (Instantiations are currently scoped on reactor level not modes)", - instantiation.getName()), instantiation, Literals.INSTANTIATION__NAME); - } - names.add(instantiation.getName()); - } - } - } + } + + @Check(CheckType.FAST) + public void checkModeInstanceNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var instantiation : mode.getInstantiations()) { + if (names.contains(instantiation.getName())) { + error( + String.format( + "Duplicate Instantiation '%s'. (Instantiations are currently scoped on reactor" + + " level not modes)", + instantiation.getName()), + instantiation, + Literals.INSTANTIATION__NAME); + } + names.add(instantiation.getName()); + } + } } - - @Check(CheckType.FAST) - public void checkMissingStateResetInMode(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var resetModes = new HashSet(); - // Collect all modes that may be reset - for (var m : reactor.getModes()) { - for (var r : m.getReactions()) { - for (var e : r.getEffects()) { - if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { - resetModes.add((Mode) e.getVariable()); - } - } - } - } - for (var m : resetModes) { - // Check state variables in this mode - if (!m.getStateVars().isEmpty()) { - var hasResetReaction = m.getReactions().stream().anyMatch( - r -> r.getTriggers().stream().anyMatch( - t -> (t instanceof BuiltinTriggerRef && - ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); - if (!hasResetReaction) { - for (var s : m.getStateVars()) { - if (!s.isReset()) { - error("State variable is not reset upon mode entry. It is neither marked for automatic reset nor is there a reset reaction.", - m, Literals.MODE__STATE_VARS, m.getStateVars().indexOf(s)); - } - } - } + } + + @Check(CheckType.FAST) + public void checkMissingStateResetInMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var resetModes = new HashSet(); + // Collect all modes that may be reset + for (var m : reactor.getModes()) { + for (var r : m.getReactions()) { + for (var e : r.getEffects()) { + if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { + resetModes.add((Mode) e.getVariable()); + } + } + } + } + for (var m : resetModes) { + // Check state variables in this mode + if (!m.getStateVars().isEmpty()) { + var hasResetReaction = + m.getReactions().stream() + .anyMatch( + r -> + r.getTriggers().stream() + .anyMatch( + t -> + (t instanceof BuiltinTriggerRef + && ((BuiltinTriggerRef) t).getType() + == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + for (var s : m.getStateVars()) { + if (!s.isReset()) { + error( + "State variable is not reset upon mode entry. It is neither marked for" + + " automatic reset nor is there a reset reaction.", + m, + Literals.MODE__STATE_VARS, + m.getStateVars().indexOf(s)); + } + } + } + } + // Check state variables in instantiated reactors + if (!m.getInstantiations().isEmpty()) { + for (var i : m.getInstantiations()) { + var error = new LinkedHashSet(); + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty()) { + var check = toCheck.pop(); + checked.add(check); + if (!check.getStateVars().isEmpty()) { + var hasResetReaction = + check.getReactions().stream() + .anyMatch( + r -> + r.getTriggers().stream() + .anyMatch( + t -> + (t instanceof BuiltinTriggerRef + && ((BuiltinTriggerRef) t).getType() + == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + // Add state vars that are not self-resetting to the error + check.getStateVars().stream() + .filter(s -> !s.isReset()) + .forEachOrdered(error::add); } - // Check state variables in instantiated reactors - if (!m.getInstantiations().isEmpty()) { - for (var i : m.getInstantiations()) { - var error = new LinkedHashSet(); - var checked = new HashSet(); - var toCheck = new LinkedList(); - toCheck.add((Reactor) i.getReactorClass()); - while (!toCheck.isEmpty()) { - var check = toCheck.pop(); - checked.add(check); - if (!check.getStateVars().isEmpty()) { - var hasResetReaction = check.getReactions().stream().anyMatch( - r -> r.getTriggers().stream().anyMatch( - t -> (t instanceof BuiltinTriggerRef && - ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); - if (!hasResetReaction) { - // Add state vars that are not self-resetting to the error - check.getStateVars().stream().filter(s -> !s.isReset()).forEachOrdered(error::add); - } - } - // continue with inner - for (var innerInstance : check.getInstantiations()) { - var next = (Reactor) innerInstance.getReactorClass(); - if (!checked.contains(next)) { - toCheck.push(next); - } - } - } - if (!error.isEmpty()) { - error("This reactor contains state variables that are not reset upon mode entry: " - + error.stream().map(e -> e.getName() + " in " - + ASTUtils.getEnclosingReactor(e).getName()).collect(Collectors.joining(", ")) - + ".\nThe state variables are neither marked for automatic reset nor have a dedicated reset reaction. " - + "It is usafe to instatiate this reactor inside a mode entered with reset.", - m, Literals.MODE__INSTANTIATIONS, - m.getInstantiations().indexOf(i)); - } - } + } + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); } - } - } + } + } + if (!error.isEmpty()) { + error( + "This reactor contains state variables that are not reset upon mode entry: " + + error.stream() + .map( + e -> e.getName() + " in " + ASTUtils.getEnclosingReactor(e).getName()) + .collect(Collectors.joining(", ")) + + ".\n" + + "The state variables are neither marked for automatic reset nor have a" + + " dedicated reset reaction. It is usafe to instatiate this reactor inside a" + + " mode entered with reset.", + m, + Literals.MODE__INSTANTIATIONS, + m.getInstantiations().indexOf(i)); + } + } + } + } } - - @Check(CheckType.FAST) - public void checkStateResetWithoutInitialValue(StateVar state) { - if (state.isReset() && (state.getInit() == null || state.getInit().getExprs().isEmpty())) { - error("The state variable can not be automatically reset without an initial value.", state, Literals.STATE_VAR__RESET); - } + } + + @Check(CheckType.FAST) + public void checkStateResetWithoutInitialValue(StateVar state) { + if (state.isReset() && (state.getInit() == null || state.getInit().getExprs().isEmpty())) { + error( + "The state variable can not be automatically reset without an initial value.", + state, + Literals.STATE_VAR__RESET); } - - @Check(CheckType.FAST) - public void checkUnspecifiedTransitionType(Reaction reaction) { - for (var effect : reaction.getEffects()) { - var variable = effect.getVariable(); - if (variable instanceof Mode) { - // The transition type is always set to default by Xtext. - // Hence, check if there is an explicit node for the transition type in the AST. - var transitionAssignment = NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); - if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. - var mode = (Mode) variable; - // Check if reset or history transition would make a difference. - var makesDifference = !mode.getStateVars().isEmpty() - || !mode.getTimers().isEmpty() - || !mode.getActions().isEmpty() - || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); - if (!makesDifference && !mode.getInstantiations().isEmpty()) { - // Also check instantiated reactors - for (var i : mode.getInstantiations()) { - var checked = new HashSet(); - var toCheck = new LinkedList(); - toCheck.add((Reactor) i.getReactorClass()); - while (!toCheck.isEmpty() && !makesDifference) { - var check = toCheck.pop(); - checked.add(check); - - makesDifference |= !check.getModes().isEmpty() - || !ASTUtils.allStateVars(check).isEmpty() - || !ASTUtils.allTimers(check).isEmpty() - || !ASTUtils.allActions(check).isEmpty() - || ASTUtils.allConnections(check).stream().anyMatch(c -> c.getDelay() != null); - - // continue with inner - for (var innerInstance : check.getInstantiations()) { - var next = (Reactor) innerInstance.getReactorClass(); - if (!checked.contains(next)) { - toCheck.push(next); - } - } - } - } - } - if (makesDifference) { - warning("You should specifiy a transition type! " - + "Reset and history transitions have different effects on this target mode. " - + "Currently, a reset type is implicitly assumed.", - reaction, Literals.REACTION__EFFECTS, reaction.getEffects().indexOf(effect)); - } + } + + @Check(CheckType.FAST) + public void checkUnspecifiedTransitionType(Reaction reaction) { + for (var effect : reaction.getEffects()) { + var variable = effect.getVariable(); + if (variable instanceof Mode) { + // The transition type is always set to default by Xtext. + // Hence, check if there is an explicit node for the transition type in the AST. + var transitionAssignment = + NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); + if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. + var mode = (Mode) variable; + // Check if reset or history transition would make a difference. + var makesDifference = + !mode.getStateVars().isEmpty() + || !mode.getTimers().isEmpty() + || !mode.getActions().isEmpty() + || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); + if (!makesDifference && !mode.getInstantiations().isEmpty()) { + // Also check instantiated reactors + for (var i : mode.getInstantiations()) { + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty() && !makesDifference) { + var check = toCheck.pop(); + checked.add(check); + + makesDifference |= + !check.getModes().isEmpty() + || !ASTUtils.allStateVars(check).isEmpty() + || !ASTUtils.allTimers(check).isEmpty() + || !ASTUtils.allActions(check).isEmpty() + || ASTUtils.allConnections(check).stream() + .anyMatch(c -> c.getDelay() != null); + + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); + } } + } } - } + } + if (makesDifference) { + warning( + "You should specifiy a transition type! " + + "Reset and history transitions have different effects on this target mode. " + + "Currently, a reset type is implicitly assumed.", + reaction, + Literals.REACTION__EFFECTS, + reaction.getEffects().indexOf(effect)); + } + } + } + } + } + + ////////////////////////////////////////////////////////////// + //// Public methods. + + /** Return the error reporter for this validator. */ + public ValidatorErrorReporter getErrorReporter() { + return this.errorReporter; + } + + /** Implementation required by xtext to report validation errors. */ + @Override + public ValidationMessageAcceptor getMessageAcceptor() { + return messageAcceptor == null ? this : messageAcceptor; + } + + /** Return a list of error messages for the target declaration. */ + public List getTargetPropertyErrors() { + return this.targetPropertyErrors; + } + + ////////////////////////////////////////////////////////////// + //// Protected methods. + + /** Generate an error message for an AST node. */ + @Override + protected void error(java.lang.String message, org.eclipse.emf.ecore.EStructuralFeature feature) { + super.error(message, feature); + } + + ////////////////////////////////////////////////////////////// + //// Private methods. + + /** + * For each input, report a conflict if: 1) the input exists and the type doesn't match; or 2) the + * input has a name clash with variable that is not an input. + * + * @param superVars List of typed variables of a particular kind (i.e., inputs, outputs, or + * actions), found in a super class. + * @param sameKind Typed variables of the same kind, found in the subclass. + * @param allOwn Accumulator of non-conflicting variables incorporated in the subclass. + * @param conflicts Set of variables that are in conflict, to be used by this function to report + * conflicts. + */ + private void checkConflict( + EList superVars, EList sameKind, List allOwn, HashSet conflicts) { + for (T superVar : superVars) { + T match = null; + for (T it : sameKind) { + if (it.getName().equals(superVar.getName())) { + match = it; + break; + } + } + List rest = new ArrayList<>(allOwn); + rest.removeIf(it -> sameKind.contains(it)); + + if ((match != null && superVar.getType() != match.getType()) + || hasNameConflict(superVar, rest)) { + conflicts.add(superVar); + } else { + allOwn.add(superVar); + } + } + } + + /** + * Check the name of a feature for illegal substrings such as reserved identifiers and names with + * double leading underscores. + * + * @param name The name. + * @param feature The feature containing the name (for error reporting). + */ + private void checkName(String name, EStructuralFeature feature) { + + // Raises an error if the string starts with two underscores. + if (name.length() >= 2 && name.substring(0, 2).equals("__")) { + error(UNDERSCORE_MESSAGE + name, feature); } - ////////////////////////////////////////////////////////////// - //// Public methods. - - /** - * Return the error reporter for this validator. - */ - public ValidatorErrorReporter getErrorReporter() { - return this.errorReporter; - } - - /** - * Implementation required by xtext to report validation errors. - */ - @Override - public ValidationMessageAcceptor getMessageAcceptor() { - return messageAcceptor == null ? this : messageAcceptor; - } - - /** - * Return a list of error messages for the target declaration. - */ - public List getTargetPropertyErrors() { - return this.targetPropertyErrors; - } - - ////////////////////////////////////////////////////////////// - //// Protected methods. - - /** - * Generate an error message for an AST node. - */ - @Override - protected void error(java.lang.String message, - org.eclipse.emf.ecore.EStructuralFeature feature) { - super.error(message, feature); - } - - ////////////////////////////////////////////////////////////// - //// Private methods. - - /** - * For each input, report a conflict if: - * 1) the input exists and the type doesn't match; or - * 2) the input has a name clash with variable that is not an input. - * @param superVars List of typed variables of a particular kind (i.e., - * inputs, outputs, or actions), found in a super class. - * @param sameKind Typed variables of the same kind, found in the subclass. - * @param allOwn Accumulator of non-conflicting variables incorporated in the - * subclass. - * @param conflicts Set of variables that are in conflict, to be used by this - * function to report conflicts. - */ - private void checkConflict ( - EList superVars, EList sameKind, List allOwn, HashSet conflicts - ) { - for (T superVar : superVars) { - T match = null; - for (T it : sameKind) { - if (it.getName().equals(superVar.getName())) { - match = it; - break; - } - } - List rest = new ArrayList<>(allOwn); - rest.removeIf(it -> sameKind.contains(it)); + if (this.target.isReservedIdent(name)) { + error(RESERVED_MESSAGE + name, feature); + } - if ((match != null && superVar.getType() != match.getType()) || hasNameConflict(superVar, rest)) { - conflicts.add(superVar); - } else { - allOwn.add(superVar); - } - } + if (this.target == Target.TS) { + // "actions" is a reserved word within a TS reaction + if (name.equals("actions")) { + error(ACTIONS_MESSAGE + name, feature); + } + } + } + + /** + * Check that the initializer is compatible with the type. Note that if the type is inferred it + * will necessarily be compatible so this method is not harmful. + */ + public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { + if (init == null) { + return; } - /** - * Check the name of a feature for illegal substrings such as reserved - * identifiers and names with double leading underscores. - * @param name The name. - * @param feature The feature containing the name (for error reporting). - */ - private void checkName(String name, EStructuralFeature feature) { + // TODO: + // type is list => init is list + // type is fixed with size n => init is fixed with size n + // Specifically for C: list can only be literal or time lists - // Raises an error if the string starts with two underscores. - if (name.length() >= 2 && name.substring(0, 2).equals("__")) { - error(UNDERSCORE_MESSAGE + name, feature); + if (type.isTime) { + if (type.isList) { + // list of times + var exprs = init.getExprs(); + if (exprs.isEmpty()) { + error("Expected at least one time value.", feature); + return; } - - if (this.target.isReservedIdent(name)) { - error(RESERVED_MESSAGE + name, feature); + if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { + exprs = ((BracedListExpression) exprs.get(0)).getItems(); } - - if (this.target == Target.TS) { - // "actions" is a reserved word within a TS reaction - if (name.equals("actions")) { - error(ACTIONS_MESSAGE + name, feature); - } + for (var component : exprs) { + checkExpressionIsTime(component, feature); } + } else { + checkExpressionIsTime(init, feature); + } } + } - - /** - * Check that the initializer is compatible with the type. - * Note that if the type is inferred it will necessarily be compatible - * so this method is not harmful. - */ - public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { - if (init == null) { - return; - } - - // TODO: - // type is list => init is list - // type is fixed with size n => init is fixed with size n - // Specifically for C: list can only be literal or time lists - - if (type.isTime) { - if (type.isList) { - // list of times - var exprs = init.getExprs(); - if (exprs.isEmpty()) { - error("Expected at least one time value.", feature); - return; - } - if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { - exprs = ((BracedListExpression) exprs.get(0)).getItems(); - } - for (var component : exprs) { - checkExpressionIsTime(component, feature); - } - } else { - checkExpressionIsTime(init, feature); - } - } + private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { + if (init == null) { + return; } - private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { - if (init == null) { - return; - } - - if (init.getExprs().size() != 1) { - error("Expected exactly one time value.", feature); - } else { - checkExpressionIsTime(ASTUtils.asSingleExpr(init), feature); - } + if (init.getExprs().size() != 1) { + error("Expected exactly one time value.", feature); + } else { + checkExpressionIsTime(ASTUtils.asSingleExpr(init), feature); } + } - private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { - if (value == null || value instanceof Time) { - return; - } - - if (value instanceof ParameterReference) { - if (!ASTUtils.isOfTimeType(((ParameterReference) value).getParameter()) - && target.requiresTypes) { - error("Referenced parameter is not of time type.", feature); - } - return; - } else if (value instanceof Literal) { - if (ASTUtils.isZero(((Literal) value).getLiteral())) { - return; - } - - if (ASTUtils.isInteger(((Literal) value).getLiteral())) { - error("Missing time unit.", feature); - return; - } - // fallthrough - } - - error("Invalid time value.", feature); + private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { + if (value == null || value instanceof Time) { + return; } - /** - * Return the number of main or federated reactors declared. - * - * @param iter An iterator over all objects in the resource. - */ - private int countMainOrFederated(TreeIterator iter) { - int nMain = 0; - while (iter.hasNext()) { - EObject obj = iter.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor r = (Reactor) obj; - if (r.isMain() || r.isFederated()) { - nMain++; - } - } - return nMain; - } - - /** - * Report whether a given reactor has dependencies on a cyclic - * instantiation pattern. This means the reactor has an instantiation - * in it -- directly or in one of its contained reactors -- that is - * self-referential. - * @param reactor The reactor definition to find out whether it has any - * dependencies on cyclic instantiations. - * @param cycleSet The set of all reactors that are part of an - * instantiation cycle. - * @param visited The set of nodes already visited in this graph traversal. - */ - private boolean dependsOnCycle( - Reactor reactor, Set cycleSet, Set visited - ) { - Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); - if (visited.contains(reactor)) { - return false; - } else { - visited.add(reactor); - for (Reactor it : origins) { - if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { - // Reached a cycle. - return true; - } - } - } - return false; - } - - /** - * Report whether the name of the given element matches any variable in - * the ones to check against. - * @param element The element to compare against all variables in the given iterable. - * @param toCheckAgainst Iterable variables to compare the given element against. - */ - private boolean hasNameConflict(Variable element, - Iterable toCheckAgainst) { - int numNameConflicts = 0; - for (Variable it : toCheckAgainst) { - if (it.getName().equals(element.getName())) { - numNameConflicts++; - } - } - return numNameConflicts > 0; + if (value instanceof ParameterReference) { + if (!ASTUtils.isOfTimeType(((ParameterReference) value).getParameter()) + && target.requiresTypes) { + error("Referenced parameter is not of time type.", feature); + } + return; + } else if (value instanceof Literal) { + if (ASTUtils.isZero(((Literal) value).getLiteral())) { + return; + } + + if (ASTUtils.isInteger(((Literal) value).getLiteral())) { + error("Missing time unit.", feature); + return; + } + // fallthrough } - /** - * Return true if target is C or a C-based target like CCpp. - */ - private boolean isCBasedTarget() { - return (this.target == Target.C || this.target == Target.CCPP); + error("Invalid time value.", feature); + } + + /** + * Return the number of main or federated reactors declared. + * + * @param iter An iterator over all objects in the resource. + */ + private int countMainOrFederated(TreeIterator iter) { + int nMain = 0; + while (iter.hasNext()) { + EObject obj = iter.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor r = (Reactor) obj; + if (r.isMain() || r.isFederated()) { + nMain++; + } } - - /** - * Report whether a given imported reactor is used in this resource or not. - * @param reactor The imported reactor to check whether it is used. - */ - private boolean isUnused(ImportedReactor reactor) { - TreeIterator instantiations = reactor.eResource().getAllContents(); - TreeIterator subclasses = reactor.eResource().getAllContents(); - - boolean instantiationsCheck = true; - while (instantiations.hasNext() && instantiationsCheck) { - EObject obj = instantiations.next(); - if (!(obj instanceof Instantiation)) { - continue; - } - Instantiation inst = (Instantiation) obj; - instantiationsCheck &= (inst.getReactorClass() != reactor && inst.getReactorClass() != reactor.getReactorClass()); - } - - boolean subclassesCheck = true; - while (subclasses.hasNext() && subclassesCheck) { - EObject obj = subclasses.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor subclass = (Reactor) obj; - for (ReactorDecl decl : subclass.getSuperClasses()) { - subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); - } - } - return instantiationsCheck && subclassesCheck; + return nMain; + } + + /** + * Report whether a given reactor has dependencies on a cyclic instantiation pattern. This means + * the reactor has an instantiation in it -- directly or in one of its contained reactors -- that + * is self-referential. + * + * @param reactor The reactor definition to find out whether it has any dependencies on cyclic + * instantiations. + * @param cycleSet The set of all reactors that are part of an instantiation cycle. + * @param visited The set of nodes already visited in this graph traversal. + */ + private boolean dependsOnCycle(Reactor reactor, Set cycleSet, Set visited) { + Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); + if (visited.contains(reactor)) { + return false; + } else { + visited.add(reactor); + for (Reactor it : origins) { + if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { + // Reached a cycle. + return true; + } + } } - - /** - * Return true if the two types match. Unfortunately, xtext does not - * seem to create a suitable equals() method for Type, so we have to - * do this manually. - */ - private boolean sameType(Type type1, Type type2) { - if (type1 == null) { - return type2 == null; - } - if (type2 == null) { - return type1 == null; - } - // Most common case first. - if (type1.getId() != null) { - if (type1.getStars() != null) { - if (type2.getStars() == null) return false; - if (type1.getStars().size() != type2.getStars().size()) return false; - } - return (type1.getId().equals(type2.getId())); - } - - // Type specification in the grammar is: - // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); - if (type1.isTime()) { - if (!type2.isTime()) return false; - // Ignore the arraySpec because that is checked when connection - // is checked for balance. - return true; - } - // Type must be given in a code body - return type1.getCode().getBody().equals(type2.getCode().getBody()); + return false; + } + + /** + * Report whether the name of the given element matches any variable in the ones to check against. + * + * @param element The element to compare against all variables in the given iterable. + * @param toCheckAgainst Iterable variables to compare the given element against. + */ + private boolean hasNameConflict(Variable element, Iterable toCheckAgainst) { + int numNameConflicts = 0; + for (Variable it : toCheckAgainst) { + if (it.getName().equals(element.getName())) { + numNameConflicts++; + } + } + return numNameConflicts > 0; + } + + /** Return true if target is C or a C-based target like CCpp. */ + private boolean isCBasedTarget() { + return (this.target == Target.C || this.target == Target.CCPP); + } + + /** + * Report whether a given imported reactor is used in this resource or not. + * + * @param reactor The imported reactor to check whether it is used. + */ + private boolean isUnused(ImportedReactor reactor) { + TreeIterator instantiations = reactor.eResource().getAllContents(); + TreeIterator subclasses = reactor.eResource().getAllContents(); + + boolean instantiationsCheck = true; + while (instantiations.hasNext() && instantiationsCheck) { + EObject obj = instantiations.next(); + if (!(obj instanceof Instantiation)) { + continue; + } + Instantiation inst = (Instantiation) obj; + instantiationsCheck &= + (inst.getReactorClass() != reactor + && inst.getReactorClass() != reactor.getReactorClass()); } - ////////////////////////////////////////////////////////////// - //// Private fields. - - /** The error reporter. */ - private ValidatorErrorReporter errorReporter - = new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); - - /** Helper class containing information about the model. */ - private ModelInfo info = new ModelInfo(); - - @Inject(optional = true) - private ValidationMessageAcceptor messageAcceptor; - - /** The declared target. */ - private Target target; - - private List targetPropertyErrors = new ArrayList<>(); - - private List targetPropertyWarnings = new ArrayList<>(); - - ////////////////////////////////////////////////////////////// - //// Private static constants. - - private static String ACTIONS_MESSAGE - = "\"actions\" is a reserved word for the TypeScript target for objects " - + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " - + "and reactor instantiation): "; - - private static String HOST_OR_FQN_REGEX - = "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; - - /** - * Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). - */ - private static String IPV4_REGEX = "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" + - "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; - - /** - * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), - * with minor adjustment to allow up to six IPV6 segments (without truncation) in front - * of an embedded IPv4-address. - **/ - private static String IPV6_REGEX = - "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" + - "([0-9a-fA-F]{1,4}:){1,7}:|" + - "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" + - "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" + - "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" + - "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" + - "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" + - "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" + - ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" + - "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" + - "::(ffff(:0{1,4}){0,1}:){0,1}" + IPV4_REGEX + "|" + - "([0-9a-fA-F]{1,4}:){1,4}:" + IPV4_REGEX + "|" + - "([0-9a-fA-F]{1,4}:){1,6}" + IPV4_REGEX + ")"; - - private static String RESERVED_MESSAGE = "Reserved words in the target language are not allowed for objects " - + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation): "; - - private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); - - private static String UNDERSCORE_MESSAGE = "Names of objects (inputs, outputs, actions, timers, parameters, " - + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; + boolean subclassesCheck = true; + while (subclasses.hasNext() && subclassesCheck) { + EObject obj = subclasses.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor subclass = (Reactor) obj; + for (ReactorDecl decl : subclass.getSuperClasses()) { + subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); + } + } + return instantiationsCheck && subclassesCheck; + } + + /** + * Return true if the two types match. Unfortunately, xtext does not seem to create a suitable + * equals() method for Type, so we have to do this manually. + */ + private boolean sameType(Type type1, Type type2) { + if (type1 == null) { + return type2 == null; + } + if (type2 == null) { + return type1 == null; + } + // Most common case first. + if (type1.getId() != null) { + if (type1.getStars() != null) { + if (type2.getStars() == null) return false; + if (type1.getStars().size() != type2.getStars().size()) return false; + } + return (type1.getId().equals(type2.getId())); + } - private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; - + // Type specification in the grammar is: + // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' + // typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); + if (type1.isTime()) { + if (!type2.isTime()) return false; + // Ignore the arraySpec because that is checked when connection + // is checked for balance. + return true; + } + // Type must be given in a code body + return type1.getCode().getBody().equals(type2.getCode().getBody()); + } + + ////////////////////////////////////////////////////////////// + //// Private fields. + + /** The error reporter. */ + private ValidatorErrorReporter errorReporter = + new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); + + /** Helper class containing information about the model. */ + private ModelInfo info = new ModelInfo(); + + @Inject(optional = true) + private ValidationMessageAcceptor messageAcceptor; + + /** The declared target. */ + private Target target; + + private List targetPropertyErrors = new ArrayList<>(); + + private List targetPropertyWarnings = new ArrayList<>(); + + ////////////////////////////////////////////////////////////// + //// Private static constants. + + private static String ACTIONS_MESSAGE = + "\"actions\" is a reserved word for the TypeScript target for objects " + + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " + + "and reactor instantiation): "; + + private static String HOST_OR_FQN_REGEX = + "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; + + /** Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). */ + private static String IPV4_REGEX = + "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" + + "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; + + /** + * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), with minor + * adjustment to allow up to six IPV6 segments (without truncation) in front of an embedded + * IPv4-address. + */ + private static String IPV6_REGEX = + "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,7}:|" + + "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" + + "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" + + "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" + + "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" + + "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" + + ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" + + "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" + + "::(ffff(:0{1,4}){0,1}:){0,1}" + + IPV4_REGEX + + "|" + + "([0-9a-fA-F]{1,4}:){1,4}:" + + IPV4_REGEX + + "|" + + "([0-9a-fA-F]{1,4}:){1,6}" + + IPV4_REGEX + + ")"; + + private static String RESERVED_MESSAGE = + "Reserved words in the target language are not allowed for objects (inputs, outputs, actions," + + " timers, parameters, state, reactor definitions, and reactor instantiation): "; + + private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); + + private static String UNDERSCORE_MESSAGE = + "Names of objects (inputs, outputs, actions, timers, parameters, " + + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; + + private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; } diff --git a/test/C/src/file0.lf b/test/C/src/file0.lf deleted file mode 100644 index 645242845a..0000000000 --- a/test/C/src/file0.lf +++ /dev/null @@ -1,40 +0,0 @@ -target C - -reactor Watcher { - input x: int - // Produced if the - // deadline is - // violated. - output d: int - - reaction(x) -> - d, poodle {= - lf_watchdog_start(poodle, 0); - printf("Normal reaction.\n"); - =} -} - -main reactor { - logical action a - w = new Watcher( - - ) - - reaction( - startup - ) -> - w.x, a {= - lf_set(w.x, 0); - lf_schedule(a, 0); - =} - - reaction(a) -> - w.x {= - lf_set(w.x, 0); - lf_nanosleep(MSEC(40)); - =} - - reaction(w.d) {= - printf("Deadline reactor produced an output.\n"); - =} -} diff --git a/test/C/src/file1.lf b/test/C/src/file1.lf deleted file mode 100644 index 1183364928..0000000000 --- a/test/C/src/file1.lf +++ /dev/null @@ -1,40 +0,0 @@ -target C - -reactor Watcher { - input x: int - // Produced if the - // deadline is - // violated. - output d: int - - reaction(x) -> - poodle, d {= - lf_watchdog_start(poodle, 0); - printf("Normal reaction.\n"); - =} -} - -main reactor { - logical action a - w = new Watcher( - - ) - - reaction( - startup - ) -> - w.x, a {= - lf_set(w.x, 0); - lf_schedule(a, 0); - =} - - reaction(a) -> - w.x {= - lf_set(w.x, 0); - lf_nanosleep(MSEC(40)); - =} - - reaction(w.d) {= - printf("Deadline reactor produced an output.\n"); - =} -} diff --git a/test/C/src/file2.lf b/test/C/src/file2.lf deleted file mode 100644 index 1183364928..0000000000 --- a/test/C/src/file2.lf +++ /dev/null @@ -1,40 +0,0 @@ -target C - -reactor Watcher { - input x: int - // Produced if the - // deadline is - // violated. - output d: int - - reaction(x) -> - poodle, d {= - lf_watchdog_start(poodle, 0); - printf("Normal reaction.\n"); - =} -} - -main reactor { - logical action a - w = new Watcher( - - ) - - reaction( - startup - ) -> - w.x, a {= - lf_set(w.x, 0); - lf_schedule(a, 0); - =} - - reaction(a) -> - w.x {= - lf_set(w.x, 0); - lf_nanosleep(MSEC(40)); - =} - - reaction(w.d) {= - printf("Deadline reactor produced an output.\n"); - =} -} From b7c60da680b48928f6b3ce7d4e9fe1179dbe7435 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 14 Apr 2023 21:19:22 -0700 Subject: [PATCH 120/709] Progress towards addressing #1685 --- org.lflang/src/org/lflang/TargetConfig.java | 10 +- .../federated/generator/FedFileConfig.java | 16 +- .../org/lflang/generator/c/CGenerator.java | 81 ++++--- .../src/org/lflang/generator/c/CUtil.java | 215 +++++++++--------- org.lflang/src/org/lflang/util/FileUtil.java | 41 +++- 5 files changed, 209 insertions(+), 154 deletions(-) diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 23e99541da..6f15181172 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -177,6 +177,7 @@ public TargetConfig( * Useful for copying them to remote machines. This is needed because * target cmake-includes can be resources with resource paths. */ + // FIXME: Code smell. This gets populated in CGenerator.copyUserFiles public List cmakeIncludesWithoutPath = new ArrayList<>(); /** @@ -237,14 +238,7 @@ public TargetConfig( /** * List of files to be copied to src-gen. */ - public List fileNames = new ArrayList<>(); - - /** - * List of file names from the files target property with no path info. - * Useful for copying them to remote machines. This is needed because - * target files can be resources with resource paths. - */ - public List filesNamesWithoutPath = new ArrayList<>(); + public List fileNames = new ArrayList<>(); // FIXME: misnamed, these are files or paths, not file names. /** * If true, configure the execution environment to keep executing if there diff --git a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java index 42f5c60dc7..6ac65236f8 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java @@ -27,6 +27,7 @@ import java.io.IOException; import java.nio.file.Path; +import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; @@ -120,17 +121,22 @@ public void relativizePaths(FedTargetConfig targetConfig) { */ private void relativizePathList(List paths) { List tempList = new ArrayList<>(); - paths.forEach(f -> tempList.add(relativizePath(f))); + paths.forEach(f -> tempList.add(relativizePath(Paths.get(f)))); paths.clear(); paths.addAll(tempList); } /** - * Relativize a single path. + * Relativize a single path, but only if it points to a local resource in the project (i.e., not + * on the class path). * @param path The path to relativize. */ - private String relativizePath(String path) { - Path resolvedPath = this.srcPath.resolve(path).toAbsolutePath(); - return this.getSrcPath().relativize(resolvedPath).toString(); + private String relativizePath(Path path) { + if (FileUtil.findInProject(path, this) == null) { + return String.valueOf(path); + } else { + Path resolvedPath = this.srcPath.resolve(path).toAbsolutePath(); + return this.getSrcPath().relativize(resolvedPath).toString(); + } } } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index f598219ddd..93c407a410 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -39,6 +39,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import java.nio.file.Paths; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; @@ -820,49 +821,55 @@ private void inspectReactorEResource(ReactorDecl reactor) { @Override public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { super.copyUserFiles(targetConfig, fileConfig); - // Make sure the target directory exists. var targetDir = this.fileConfig.getSrcGenPath(); - try { - Files.createDirectories(targetDir); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - + // FIXME: this code probably belongs in the super method. for (String filename : targetConfig.fileNames) { - var relativeFileName = CUtil.copyFileOrResource( - filename, - fileConfig.srcFile.getParent(), - targetDir); - if (StringExtensions.isNullOrEmpty(relativeFileName)) { - errorReporter.reportError( - "Failed to find file " + filename + " specified in the" + - " files target property." - ); + var path = Paths.get(filename); + var copied = false; + var found = FileUtil.findInProject(path, fileConfig); + if (found != null) { + try { + FileUtil.copyFileOrDirectory(found, targetDir); + } catch (IOException e) { + throw new RuntimeException(e); + } } else { - targetConfig.filesNamesWithoutPath.add( - relativeFileName - ); + // Attempt to copy from the classpath instead. + // If the filename is not a directory, it will + // just be copied without further recursion. + try { + FileUtil.copyDirectoryFromClassPath( + filename, + targetDir, + false + ); + } catch (IOException e) { + errorReporter.reportError( + "Failed to find '" + filename + "' specified in the" + + " files target property." + ); + } } } - for (String filename : targetConfig.cmakeIncludes) { - var relativeCMakeIncludeFileName = - CUtil.copyFileOrResource( - filename, - fileConfig.srcFile.getParent(), - targetDir); - // Check if the file exists - if (StringExtensions.isNullOrEmpty(relativeCMakeIncludeFileName)) { - errorReporter.reportError( - "Failed to find cmake-include file " + filename - ); - } else { - this.targetConfig.cmakeIncludesWithoutPath.add( - relativeCMakeIncludeFileName - ); - } - } +// for (String filename : targetConfig.cmakeIncludes) { +// var relativeCMakeIncludeFileName = +// CUtil.copyFileOrResource( +// filename, +// fileConfig.srcFile.getParent(), +// targetDir); +// // Check if the file exists +// if (StringExtensions.isNullOrEmpty(relativeCMakeIncludeFileName)) { +// errorReporter.reportError( +// "Failed to find cmake-include file " + filename +// ); +// } else { +// // FIXME: weird +// this.targetConfig.cmakeIncludesWithoutPath.add( +// relativeCMakeIncludeFileName +// ); +// } +// } if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { try { diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 69e9ec30ae..f59f45eef2 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -575,69 +575,76 @@ public static String triggerRefNested(PortInstance port, String runtimeIndex, St return reactorRefNested(port.getParent(), runtimeIndex, bankIndex) + "." + port.getName() + "_trigger"; } - /** - * Copy the 'fileName' (which also could be a directory name) from the - * 'srcDirectory' to the 'destinationDirectory'. This function has a - * fallback search mechanism, where if `fileName` is not found in the - * `srcDirectory`, it will try to find `fileName` via the following - * procedure: - * 1- Search in LF_CLASSPATH. @see findFile() - * 2- Search in CLASSPATH. @see findFile() - * 3- Search for 'fileName' as a resource. That means the `fileName` - * can be '/path/to/class/resource'. @see java.lang.Class.getResourceAsStream() - * - * @param fileName Name of the file or directory. - * @param srcDir Where the file or directory is currently located. - * @param dstDir Where the file or directory should be placed. - * @return The name of the file or directory in destinationDirectory or an empty string on failure. - */ - public static String copyFileOrResource(String fileName, Path srcDir, - Path dstDir) { - // Try to copy the file or directory from the file system. - Path file = findFileOrDirectory(fileName, srcDir); - if (file != null) { - Path target = dstDir.resolve(file.getFileName()); - try { - if (Files.isDirectory(file)) { - FileUtil.copyDirectory(file, target); - } else if (Files.isRegularFile(file)) { - Files.copy(file, target, - StandardCopyOption.REPLACE_EXISTING); - } - return file.getFileName().toString(); - } catch (IOException e) { - // Failed to copy the file or directory, most likely - // because it doesn't exist. Will try to find it as a - // resource before giving up. - } - } - - String filenameWithoutPath = fileName; - int lastSeparator = fileName.lastIndexOf(File.separator); - if (lastSeparator > 0) { - // FIXME: Brittle. What if the file is in a subdirectory? - filenameWithoutPath = fileName.substring(lastSeparator + 1); - } - // Try to copy the file or directory as a resource. - try { - FileUtil.copyFileFromClassPath(fileName, - dstDir.resolve(filenameWithoutPath)); - return filenameWithoutPath; - } catch (IOException ex) { - // Will try one more time as a directory - } - - try { - FileUtil.copyDirectoryFromClassPath(fileName, - dstDir.resolve(filenameWithoutPath), false); - return filenameWithoutPath; - } catch (IOException ex) { - System.err.println( - "WARNING: Failed to find file or directory " + fileName); - } - - return ""; - } +// /** +// * Copy the 'fileName' (which also could be a directory name) from the +// * 'srcDirectory' to the 'destinationDirectory'. This function has a +// * fallback search mechanism, where if `fileName` is not found in the +// * `srcDirectory`, it will try to find `fileName` via the following +// * procedure: +// * 1- Search in LF_CLASSPATH. @see findFile() +// * 2- Search in CLASSPATH. @see findFile() +// * 3- Search for 'fileName' as a resource. That means the `fileName` +// * can be '/path/to/class/resource'. @see java.lang.Class.getResourceAsStream() +// * +// * @param fileName Name of the file or directory. +// * @param srcDir Where the file or directory is currently located. +// * @param dstDir Where the file or directory should be placed. +// * @return The name of the file or directory in destinationDirectory or an empty string on failure. +// */ +// public static String copyFileOrResource(String fileName, Path srcDir, +// Path dstDir) { +// +// // Check whether file exists +// +// +// // Try to copy the file or directory from the file system. +// Path file = FileUtil.findInProject(fileName, srcDir); +// if (file != null) { +// Path target = dstDir.resolve(file.getFileName()); +// try { +// if (Files.isDirectory(file)) { +// FileUtil.copyDirectory(file, target); +// } else if (Files.isRegularFile(file)) { +// Files.copy(file, target, +// StandardCopyOption.REPLACE_EXISTING); +// } +// return file.getFileName().toString(); +// } catch (IOException e) { +// // Failed to copy the file or directory, most likely +// // because it doesn't exist. Will try to find it as a +// // resource before giving up. +// } +// } +// +// +// +// String filenameWithoutPath = fileName; +// int lastSeparator = fileName.lastIndexOf(File.separator); +// if (lastSeparator > 0) { +// // FIXME: Brittle. What if the file is in a subdirectory? +// filenameWithoutPath = fileName.substring(lastSeparator + 1); +// } +// // Try to copy the file or directory as a resource. +// try { +// System.out.println("Classpath lookup: " + dstDir.resolve(filenameWithoutPath)); +// FileUtil.copyFileFromClassPath(fileName, +// dstDir.resolve(filenameWithoutPath)); +// return filenameWithoutPath; +// } catch (IOException ex) { +// // Will try one more time as a directory +// } +// +// try { +// FileUtil.copyDirectoryFromClassPath(fileName, +// dstDir.resolve(filenameWithoutPath), false); +// return filenameWithoutPath; +// } catch (IOException ex) { +// System.err.println( +// "WARNING: Failed to find file or directory " + fileName); +// } +// +// return ""; +// } ////////////////////////////////////////////////////// //// FIXME: Not clear what the strategy is with the following inner interface. @@ -661,45 +668,49 @@ public interface ReportCommandErrors { void report(String errors); } - /** - * Search for a given file or directory name in the given directory. - * If not found, search in directories in LF_CLASSPATH. - * If there is no LF_CLASSPATH environment variable, use CLASSPATH, - * if it is defined. The first file or directory that is found will - * be returned. Otherwise, null is returned. - * - * @param fileName The file or directory name or relative path + name - * as a String. - * @param directory String representation of the directory to search in. - * @return A Java Path or null if not found. - */ - public static Path findFileOrDirectory(String fileName, Path directory) { - Path foundFile; - - // Check in local directory - foundFile = directory.resolve(fileName); - if (Files.exists(foundFile)) { - return foundFile; - } - - // Check in LF_CLASSPATH - // Load all the resources in LF_CLASSPATH if it is set. - String classpathLF = System.getenv("LF_CLASSPATH"); - if (classpathLF == null) { - classpathLF = System.getenv("CLASSPATH"); - } - if (classpathLF != null) { - String[] paths = classpathLF.split(System.getProperty("path.separator")); - for (String path : paths) { - foundFile = Paths.get(path).resolve(fileName); - if (Files.exists(foundFile)) { - return foundFile; - } - } - } - // Not found. - return null; - } +// /** +// * Search for a given file or directory name in the given directory. +// * If not found, search in directories in LF_CLASSPATH. +// * If there is no LF_CLASSPATH environment variable, use CLASSPATH, +// * if it is defined. The first file or directory that is found will +// * be returned. Otherwise, null is returned. +// * +// * @param fileName The file or directory name or relative path + name +// * as a String. +// * @param directory String representation of the directory to search in. +// * @return A Java Path or null if not found. +// */ +// public static Path findFileOrDirectory(String fileName, Path directory) { +// Path foundFile; +// +// // Check in local directory +// foundFile = directory.resolve(fileName); +// if (Files.exists(foundFile)) { +// System.out.println(">>> File found in filesystem"); +// return foundFile; +// } +// +// // Check in LF_CLASSPATH +// // Load all the resources in LF_CLASSPATH if it is set. +// String classpathLF = System.getenv("LF_CLASSPATH"); +// if (classpathLF == null) { +// classpathLF = System.getenv("CLASSPATH"); +// } +// if (classpathLF != null) { +// String[] paths = classpathLF.split(System.getProperty("path.separator")); +// for (String path : paths) { +// System.out.println("++++Looking in path: " + path); +// foundFile = Paths.get(path).resolve(fileName); +// if (Files.exists(foundFile)) { +// System.out.println(">>> File found on classpath: %s".formatted(foundFile)); +// return foundFile; +// } +// } +// } +// +// // Not found. +// return null; +// } /** diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index d4d34c7b08..8b4a56bc77 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -14,6 +14,7 @@ import java.nio.file.Paths; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.Comparator; import java.util.Enumeration; import java.util.HashMap; @@ -239,6 +240,15 @@ public static void copyFile(Path source, Path destination) throws IOException { copyFile(source, destination, false); } + public static void copyFileOrDirectory(Path source, Path destination) throws IOException { + if (Files.isDirectory(source)) { + copyDirectory(source, destination); + } else if (Files.isRegularFile(source)) { + copyFile(source, destination); + } else { + throw new IllegalArgumentException("Source is neither a directory nor a regular file."); + } + } /** * Copy a given input stream to a destination file. * @@ -359,6 +369,7 @@ private static boolean copyDirectoryFromJar(JarURLConnection connection, final P final String connectionEntryName = connection.getEntryName(); boolean copiedFiles = false; + // Iterate all entries in the jar file. for (Enumeration e = jar.entries(); e.hasMoreElements(); ) { final JarEntry entry = e.nextElement(); @@ -366,9 +377,10 @@ private static boolean copyDirectoryFromJar(JarURLConnection connection, final P // Extract files only if they match the given source path. if (entryName.startsWith(connectionEntryName)) { - String filename = entry.getName().substring(connectionEntryName.length() + 1); + String filename = entryName.equals(connectionEntryName) ? + connectionEntryName : + entryName.substring(connectionEntryName.length() + 1); Path currentFile = destination.resolve(filename); - if (entry.isDirectory()) { Files.createDirectories(currentFile); } else { @@ -511,6 +523,31 @@ public static void deleteDirectory(Path dir) throws IOException { } } + public static Path findInProject(Path fileOrDirectory, FileConfig fileConfig) { + if (fileOrDirectory.isAbsolute() && Files.exists(fileOrDirectory)) { + return fileOrDirectory; + } else { + Path relPath; + // Disregard root and interpret as relative path + if (fileOrDirectory.isAbsolute()) { + relPath = Paths.get( + String.valueOf(fileOrDirectory).replaceFirst( + String.valueOf(fileOrDirectory.getRoot()), + "") + ); + } else { + relPath = fileOrDirectory; + } + // Look relative to the source file and relative to the package root. + var locations = List.of(fileConfig.srcFile, fileConfig.srcPkgPath); + var found = locations.stream().filter(loc -> Files.exists(loc.resolve(relPath))).findFirst(); + if (found.isPresent()) { + return found.get(); + } + } + return null; + } + /** * Get the iResource corresponding to the provided resource if it can be * found. From b2d532217ce8b7aa72396d82af67fb7cf100695d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 14 Apr 2023 22:02:47 -0700 Subject: [PATCH 121/709] Fix typo --- org.lflang/src/org/lflang/util/FileUtil.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 8b4a56bc77..8d5518e555 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -539,7 +539,7 @@ public static Path findInProject(Path fileOrDirectory, FileConfig fileConfig) { relPath = fileOrDirectory; } // Look relative to the source file and relative to the package root. - var locations = List.of(fileConfig.srcFile, fileConfig.srcPkgPath); + var locations = List.of(fileConfig.srcPath, fileConfig.srcPkgPath); var found = locations.stream().filter(loc -> Files.exists(loc.resolve(relPath))).findFirst(); if (found.isPresent()) { return found.get(); From 9dfed7f64892a658d4a2a9dd6a9f33766af63e11 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 14 Apr 2023 23:51:21 -0700 Subject: [PATCH 122/709] Fix bug --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 3 +-- org.lflang/src/org/lflang/util/FileUtil.java | 7 +++++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 93c407a410..0f1ababde8 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -825,11 +825,10 @@ public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { // FIXME: this code probably belongs in the super method. for (String filename : targetConfig.fileNames) { var path = Paths.get(filename); - var copied = false; var found = FileUtil.findInProject(path, fileConfig); if (found != null) { try { - FileUtil.copyFileOrDirectory(found, targetDir); + FileUtil.copyFileOrDirectory(found, targetDir.resolve(found.getFileName())); } catch (IOException e) { throw new RuntimeException(e); } diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 8d5518e555..6025400a7d 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -538,11 +538,14 @@ public static Path findInProject(Path fileOrDirectory, FileConfig fileConfig) { } else { relPath = fileOrDirectory; } + // Look relative to the source file and relative to the package root. var locations = List.of(fileConfig.srcPath, fileConfig.srcPkgPath); - var found = locations.stream().filter(loc -> Files.exists(loc.resolve(relPath))).findFirst(); + var found = locations.stream().filter( + loc -> Files.exists(loc.resolve(relPath)) + ).findFirst(); if (found.isPresent()) { - return found.get(); + return found.get().resolve(relPath); } } return null; From aede8750e5ffa1f767df6cc4e90e9c59bf6289e5 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sat, 15 Apr 2023 16:19:27 +0900 Subject: [PATCH 123/709] Add option to add FEDERATED_AUTHENTICATED --- .../src/org/lflang/federated/extensions/CExtensionUtils.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index 124ffefb4f..a0b391c4b7 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -244,6 +244,10 @@ public static void handleCompileDefinitions( federate.targetConfig.setByUser.add(TargetProperty.COMPILE_DEFINITIONS); federate.targetConfig.compileDefinitions.put("FEDERATED", ""); federate.targetConfig.compileDefinitions.put("FEDERATED_"+federate.targetConfig.coordination.toString().toUpperCase(), ""); + if (federate.targetConfig.auth) { + System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); + federate.targetConfig.compileDefinitions.put("FEDERATED_AUTHENTICATED", ""); + } federate.targetConfig.compileDefinitions.put("NUMBER_OF_FEDERATES", String.valueOf(numOfFederates)); federate.targetConfig.compileDefinitions.put("EXECUTABLE_PREAMBLE", ""); federate.targetConfig.compileDefinitions.put("WORKERS_NEEDED_FOR_FEDERATE", String.valueOf(minThreadsToHandleInputPorts(federate))); From 33452aa4ea64717dcaa2c9ec598bb65a45b3c6a1 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sat, 15 Apr 2023 16:19:41 +0900 Subject: [PATCH 124/709] Match version --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 667a5d702c..6dfa1a0e57 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 667a5d702cbcd0288328417d8c632e6b5af19c04 +Subproject commit 6dfa1a0e573692af48f114c844fddb6de8d2cbab From 057777fa8e6f724178190164db9a00ba30febb17 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sat, 15 Apr 2023 17:30:49 +0900 Subject: [PATCH 125/709] Remove prints. --- .../src/org/lflang/federated/extensions/CExtensionUtils.java | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index a0b391c4b7..c84bf36197 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -245,7 +245,6 @@ public static void handleCompileDefinitions( federate.targetConfig.compileDefinitions.put("FEDERATED", ""); federate.targetConfig.compileDefinitions.put("FEDERATED_"+federate.targetConfig.coordination.toString().toUpperCase(), ""); if (federate.targetConfig.auth) { - System.out.println("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); federate.targetConfig.compileDefinitions.put("FEDERATED_AUTHENTICATED", ""); } federate.targetConfig.compileDefinitions.put("NUMBER_OF_FEDERATES", String.valueOf(numOfFederates)); From 9f650b2986d3763aaedfd787f91da1c4b36d047d Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sat, 15 Apr 2023 19:48:38 +0900 Subject: [PATCH 126/709] Change ci.yml point --- .github/workflows/c-tests.yml | 2 ++ .github/workflows/ci.yml | 4 ++-- org.lflang/src/lib/c/reactor-c | 2 +- 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 0764128a1b..8c85928ff1 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -45,6 +45,8 @@ jobs: brew install coreutils brew install openssl brew link openssl --force + export LDFLAGS="-L/usr/local/opt/openssl@3/lib" + export CPPFLAGS="-I/usr/local/opt/openssl@3/include" if: ${{ runner.os == 'macOS' }} - name: Install RTI uses: ./.github/actions/install-rti diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f6dd56ae40..64a524ff8f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -62,7 +62,7 @@ jobs: # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@auth-fail-test needs: cancel # Run the C Arduino integration tests. @@ -77,7 +77,7 @@ jobs: # Run the CCpp integration tests. ccpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@auth-fail-test with: use-cpp: true needs: cancel diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 6dfa1a0e57..4920ead796 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 6dfa1a0e573692af48f114c844fddb6de8d2cbab +Subproject commit 4920ead7960d1d30d7b4ba6becfb1bd9362b81e5 From 4c844909d9edb36df7b892d54f5231842b9ca6f3 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sat, 15 Apr 2023 22:08:22 +0900 Subject: [PATCH 127/709] Try removing OPENSSL_ROOT_DIR --- .github/workflows/c-tests.yml | 2 -- org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java | 6 +++--- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 8c85928ff1..0764128a1b 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -45,8 +45,6 @@ jobs: brew install coreutils brew install openssl brew link openssl --force - export LDFLAGS="-L/usr/local/opt/openssl@3/lib" - export CPPFLAGS="-I/usr/local/opt/openssl@3/include" if: ${{ runner.os == 'macOS' }} - name: Install RTI uses: ./.github/actions/install-rti diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 3f5eb4a5b7..d8033a8465 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -227,9 +227,9 @@ CodeBuilder generateCMakeCode( if (targetConfig.platformOptions.platform != Platform.AUTO) { osName = targetConfig.platformOptions.platform.toString(); } - if (osName.contains("mac")) { - cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)"); - } + // if (osName.contains("mac")) { + // cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)"); + // } cMakeCode.pr("# Find OpenSSL and link to it"); cMakeCode.pr("find_package(OpenSSL REQUIRED)"); cMakeCode.pr("target_link_libraries( ${LF_MAIN_TARGET} PRIVATE OpenSSL::SSL)"); From 381582983e81aa37ca505b2ef239353418aac364 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sun, 16 Apr 2023 00:34:23 +0900 Subject: [PATCH 128/709] Revert "Try removing OPENSSL_ROOT_DIR" This reverts commit 4c844909d9edb36df7b892d54f5231842b9ca6f3. --- .github/workflows/c-tests.yml | 2 ++ org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java | 6 +++--- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 0764128a1b..8c85928ff1 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -45,6 +45,8 @@ jobs: brew install coreutils brew install openssl brew link openssl --force + export LDFLAGS="-L/usr/local/opt/openssl@3/lib" + export CPPFLAGS="-I/usr/local/opt/openssl@3/include" if: ${{ runner.os == 'macOS' }} - name: Install RTI uses: ./.github/actions/install-rti diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index d8033a8465..3f5eb4a5b7 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -227,9 +227,9 @@ CodeBuilder generateCMakeCode( if (targetConfig.platformOptions.platform != Platform.AUTO) { osName = targetConfig.platformOptions.platform.toString(); } - // if (osName.contains("mac")) { - // cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)"); - // } + if (osName.contains("mac")) { + cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)"); + } cMakeCode.pr("# Find OpenSSL and link to it"); cMakeCode.pr("find_package(OpenSSL REQUIRED)"); cMakeCode.pr("target_link_libraries( ${LF_MAIN_TARGET} PRIVATE OpenSSL::SSL)"); From 114dd25df58e36230d52c5b906afaf361d4f749e Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sun, 16 Apr 2023 00:44:00 +0900 Subject: [PATCH 129/709] Add library path --- .github/workflows/c-tests.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 8c85928ff1..9d175941ed 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -45,8 +45,7 @@ jobs: brew install coreutils brew install openssl brew link openssl --force - export LDFLAGS="-L/usr/local/opt/openssl@3/lib" - export CPPFLAGS="-I/usr/local/opt/openssl@3/include" + export LIBRARY_PATH=$LIBRARY_PATH:/usr/local/opt/openssl/lib/ if: ${{ runner.os == 'macOS' }} - name: Install RTI uses: ./.github/actions/install-rti From c4238ccc0478292c7bd963256f17b8877694fd62 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 15 Apr 2023 23:02:54 -0700 Subject: [PATCH 130/709] Add doc comment. --- test/C/src/federated/SpuriousDependency.lf | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/C/src/federated/SpuriousDependency.lf b/test/C/src/federated/SpuriousDependency.lf index fefadc4617..84ad5d94a2 100644 --- a/test/C/src/federated/SpuriousDependency.lf +++ b/test/C/src/federated/SpuriousDependency.lf @@ -1,3 +1,10 @@ +/** + * This checks that a federated program does not deadlock when it is ambiguous, + * given the structure of a federate, whether certain ports should be allowed to + * precede others in the execution of a given tag. The version of LFC that was + * in the master branch on 4/15/2023 resolved the ambiguity in a way that does + * appear to result in deadlock. + */ target C reactor Passthrough { From a1653ac65929ddbb78f7b0b00dba59e88d0f723b Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 15 Apr 2023 23:10:55 -0700 Subject: [PATCH 131/709] Format test. --- test/C/src/federated/SpuriousDependency.lf | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/C/src/federated/SpuriousDependency.lf b/test/C/src/federated/SpuriousDependency.lf index 84ad5d94a2..05db0fe724 100644 --- a/test/C/src/federated/SpuriousDependency.lf +++ b/test/C/src/federated/SpuriousDependency.lf @@ -10,6 +10,7 @@ target C reactor Passthrough { input in: int output out: int + reaction(in) -> out {= lf_print("Hello from passthrough"); lf_set(out, in->value); @@ -34,7 +35,6 @@ federated reactor { t1 = new Twisty() t0.out1 -> t1.in0 t1.out1 -> t0.in0 - reaction(startup) -> t0.in1 {= - lf_set(t0.in1, 0); - =} + + reaction(startup) -> t0.in1 {= lf_set(t0.in1, 0); =} } From b39a00421a0f2c64e8a6cb78a9b2cc56c54b5641 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 16 Apr 2023 00:16:24 -0700 Subject: [PATCH 132/709] Address comments from review. --- test/C/src/federated/SpuriousDependency.lf | 22 +++++++++++++++++----- 1 file changed, 17 insertions(+), 5 deletions(-) diff --git a/test/C/src/federated/SpuriousDependency.lf b/test/C/src/federated/SpuriousDependency.lf index 05db0fe724..0b9cad6e6c 100644 --- a/test/C/src/federated/SpuriousDependency.lf +++ b/test/C/src/federated/SpuriousDependency.lf @@ -1,11 +1,13 @@ /** * This checks that a federated program does not deadlock when it is ambiguous, - * given the structure of a federate, whether certain ports should be allowed to - * precede others in the execution of a given tag. The version of LFC that was - * in the master branch on 4/15/2023 resolved the ambiguity in a way that does - * appear to result in deadlock. + * given the structure of a federate, whether certain network sender/receiver + * reactions should be allowed to precede others in the execution of a given + * tag. The version of LFC that was in the master branch on 4/15/2023 resolved + * the ambiguity in a way that does appear to result in deadlock. */ -target C +target C { + timeout: 2 sec +} reactor Passthrough { input in: int @@ -35,6 +37,16 @@ federated reactor { t1 = new Twisty() t0.out1 -> t1.in0 t1.out1 -> t0.in0 + state count: int = 0 reaction(startup) -> t0.in1 {= lf_set(t0.in1, 0); =} + + reaction(t1.out0) {= self->count++; =} + + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + if (self->count != 1) { + lf_print_error_and_exit("Failed to receive expected input."); + } + =} } From 622cce6dd6d490f48c538913c936d99d46efa77b Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 16 Apr 2023 00:19:02 -0700 Subject: [PATCH 133/709] Update comment again. --- test/C/src/federated/SpuriousDependency.lf | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/C/src/federated/SpuriousDependency.lf b/test/C/src/federated/SpuriousDependency.lf index 0b9cad6e6c..a022c3abf4 100644 --- a/test/C/src/federated/SpuriousDependency.lf +++ b/test/C/src/federated/SpuriousDependency.lf @@ -1,9 +1,9 @@ /** * This checks that a federated program does not deadlock when it is ambiguous, - * given the structure of a federate, whether certain network sender/receiver - * reactions should be allowed to precede others in the execution of a given - * tag. The version of LFC that was in the master branch on 4/15/2023 resolved - * the ambiguity in a way that does appear to result in deadlock. + * given the structure of a federate, whether it is permissible to require + * certain network sender/receiver reactions to precede others in the execution + * of a given tag. The version of LFC that was in the master branch on 4/15/2023 + * resolved the ambiguity in a way that does appear to result in deadlock. */ target C { timeout: 2 sec From 145edf9e362d372861717a0138f1d66b1f166d9c Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sun, 16 Apr 2023 18:28:28 +0900 Subject: [PATCH 134/709] Add openssl to runner PATH --- .github/workflows/c-tests.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 9d175941ed..fbb2669090 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -45,7 +45,9 @@ jobs: brew install coreutils brew install openssl brew link openssl --force - export LIBRARY_PATH=$LIBRARY_PATH:/usr/local/opt/openssl/lib/ + echo 'export PATH="/usr/local/opt/openssl@3/bin:$PATH"' >> /Users/runner/.bash_profile + export LDFLAGS="-L/usr/local/opt/openssl@3/lib" + export CPPFLAGS="-I/usr/local/opt/openssl@3/include" if: ${{ runner.os == 'macOS' }} - name: Install RTI uses: ./.github/actions/install-rti From 6cfd90a6a62dc23af989f6c5e6fe3eb4f00e0677 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sun, 16 Apr 2023 19:35:27 +0900 Subject: [PATCH 135/709] Update reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 4920ead796..1d573dac67 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 4920ead7960d1d30d7b4ba6becfb1bd9362b81e5 +Subproject commit 1d573dac6775c09bdec92b28a0a5fad5c88476f7 From e00e62e5e1624961f2997b58a65761907fed1443 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sun, 16 Apr 2023 20:39:14 +0900 Subject: [PATCH 136/709] Try brew reinstall openssl --- .github/workflows/c-tests.yml | 8 ++++---- org.lflang/src/lib/c/reactor-c | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index fbb2669090..c0539a1c46 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -43,11 +43,11 @@ jobs: - name: Install dependencies OS X run: | brew install coreutils - brew install openssl + brew reinstall openssl brew link openssl --force - echo 'export PATH="/usr/local/opt/openssl@3/bin:$PATH"' >> /Users/runner/.bash_profile - export LDFLAGS="-L/usr/local/opt/openssl@3/lib" - export CPPFLAGS="-I/usr/local/opt/openssl@3/include" + # echo 'export PATH="/usr/local/opt/openssl@3/bin:$PATH"' >> /Users/runner/.bash_profile + # export LDFLAGS="-L/usr/local/opt/openssl@3/lib" + # export CPPFLAGS="-I/usr/local/opt/openssl@3/include" if: ${{ runner.os == 'macOS' }} - name: Install RTI uses: ./.github/actions/install-rti diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 1d573dac67..8525a1fa27 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 1d573dac6775c09bdec92b28a0a5fad5c88476f7 +Subproject commit 8525a1fa27fdf3b420871ff0121b0f374fc3f053 From 69934f1271b5fb09a586eeb1b06b66257f487989 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sun, 16 Apr 2023 22:31:47 +0900 Subject: [PATCH 137/709] Try add openssl@3 --- org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 3f5eb4a5b7..1c7c68f676 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -228,7 +228,7 @@ CodeBuilder generateCMakeCode( osName = targetConfig.platformOptions.platform.toString(); } if (osName.contains("mac")) { - cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)"); + cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl@3)"); } cMakeCode.pr("# Find OpenSSL and link to it"); cMakeCode.pr("find_package(OpenSSL REQUIRED)"); From f3f99c1727220c3ba1af24a193e2de9995fedc32 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Mon, 17 Apr 2023 10:27:18 +0900 Subject: [PATCH 138/709] Try ssh --- .github/workflows/c-tests.yml | 12 ++++++++---- .../src/org/lflang/generator/c/CCmakeGenerator.java | 2 +- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index c0539a1c46..da060ce38a 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -23,6 +23,10 @@ jobs: matrix: platform: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.platform }} + steps: + - uses: actions/checkout@v2 + - name: Setup upterm session + uses: lhotari/action-upterm@v1 steps: - name: Check out lingua-franca repository uses: actions/checkout@v3 @@ -43,11 +47,11 @@ jobs: - name: Install dependencies OS X run: | brew install coreutils - brew reinstall openssl + brew install openssl brew link openssl --force - # echo 'export PATH="/usr/local/opt/openssl@3/bin:$PATH"' >> /Users/runner/.bash_profile - # export LDFLAGS="-L/usr/local/opt/openssl@3/lib" - # export CPPFLAGS="-I/usr/local/opt/openssl@3/include" + echo 'export PATH="/usr/local/opt/openssl@3/bin:$PATH"' >> /Users/runner/.bash_profile + export LDFLAGS="-L/usr/local/opt/openssl@3/lib" + export CPPFLAGS="-I/usr/local/opt/openssl@3/include" if: ${{ runner.os == 'macOS' }} - name: Install RTI uses: ./.github/actions/install-rti diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 1c7c68f676..3f5eb4a5b7 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -228,7 +228,7 @@ CodeBuilder generateCMakeCode( osName = targetConfig.platformOptions.platform.toString(); } if (osName.contains("mac")) { - cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl@3)"); + cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)"); } cMakeCode.pr("# Find OpenSSL and link to it"); cMakeCode.pr("find_package(OpenSSL REQUIRED)"); From 755ff0984af939c4b9263342639c4de9a2e4ea43 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Mon, 17 Apr 2023 20:07:09 -0700 Subject: [PATCH 139/709] save before reattempting the merge --- .github/actions/prepare-build-env/action.yml | 14 +- .github/workflows/c-arduino-tests.yml | 9 +- .github/workflows/c-zephyr-tests.yml | 7 + .github/workflows/ci.yml | 2 + .github/workflows/cli-tests.yml | 15 +- .github/workflows/unit-tests.yml | 1 + .../org/lflang/tests/cli/issue490.stderr | 24 +- .../src/org/lflang/tests/TestRegistry.java | 70 +- .../src/org/lflang/tests/cli/LfcCliTest.java | 7 +- .../src/org/lflang/tests/cli/LffCliTest.java | 7 +- .../compiler/LinguaFrancaValidationTest.java | 10 +- .../lflang/tests/compiler/RoundTripTests.java | 1 + .../lflang/tests/lsp/MockReportProgress.java | 2 +- .../org/lflang/tests/runtime/CCppTest.java | 1 + org.lflang/src/org/lflang/ASTUtils.java | 332 ++++++ org.lflang/src/org/lflang/LinguaFranca.xtext | 74 +- org.lflang/src/org/lflang/ast/IsEqual.java | 27 +- org.lflang/src/org/lflang/ast/ToLf.java | 12 +- org.lflang/src/org/lflang/cli/CliBase.java | 8 +- .../federated/extensions/CExtension.java | 30 +- .../federated/extensions/TSExtension.java | 31 +- .../federated/generator/FedGenerator.java | 2 +- .../generator/FedPreambleEmitter.java | 9 +- .../generator/ReactionInstanceGraph.java | 76 +- .../org/lflang/generator/ReactorInstance.java | 966 +++++++++++++++ .../src/org/lflang/generator/Validator.java | 2 +- .../lflang/generator/c/CActionGenerator.java | 10 +- .../lflang/generator/c/CCmakeGenerator.java | 1 + .../generator/c/CConstructorGenerator.java | 11 +- .../org/lflang/generator/c/CFileConfig.java | 14 +- .../org/lflang/generator/c/CGenerator.java | 1048 ++++++++++++++++- .../lflang/generator/c/CMethodGenerator.java | 4 +- .../lflang/generator/c/CPortGenerator.java | 34 +- .../generator/c/CPreambleGenerator.java | 34 +- .../generator/c/CReactionGenerator.java | 767 +++++++++++- .../c/CReactorHeaderFileGenerator.java | 208 ++++ .../src/org/lflang/generator/c/CUtil.java | 20 +- .../cpp/CppAssembleMethodGenerator.kt | 16 +- .../org/lflang/generator/cpp/CppExtensions.kt | 2 +- .../generator/cpp/CppReactionGenerator.kt | 24 +- .../python/PythonActionGenerator.java | 6 +- .../generator/python/PythonGenerator.java | 283 +++++ .../generator/python/PythonPortGenerator.java | 5 +- .../python/PythonPreambleGenerator.java | 2 +- .../python/PythonReactionGenerator.java | 47 +- .../python/PythonReactorGenerator.java | 4 +- org.lflang/src/org/lflang/util/FileUtil.java | 13 +- .../org/lflang/validation/LFValidator.java | 944 +++++++++++++++ test/C/.gitignore | 1 + .../bank_multiport_to_reaction_no_inlining.c | 16 + ...nk_multiport_to_reaction_no_inlining.cmake | 1 + test/C/c/bank_to_reaction_no_inlining.c | 11 + test/C/c/bank_to_reaction_no_inlining.cmake | 1 + test/C/c/count.c | 15 + test/C/c/count.cmake | 1 + test/C/c/count_hierarchy.c | 15 + test/C/c/count_hierarchy.cmake | 1 + test/C/c/multiport_to_reaction_no_inlining.c | 14 + .../c/multiport_to_reaction_no_inlining.cmake | 1 + test/C/c/sendreceive.c | 17 + test/C/c/sendreceive.cmake | 1 + test/C/src/Deadline.lf | 12 +- test/C/src/DeadlineHandledAbove.lf | 10 + test/C/src/DeadlineInherited.lf | 3 +- test/C/src/DeadlinePriority.lf | 3 +- test/C/src/DeadlineWithAfterDelay.lf | 4 +- test/C/src/DeadlineWithBanks.lf | 4 +- test/C/src/DelayString.lf | 10 + test/C/src/DelayStruct.lf | 1 + test/C/src/Hello.lf | 4 + test/C/src/ScheduleValue.lf | 11 + test/C/src/SimpleDeadline.lf | 10 + test/C/src/StructAsState.lf | 13 +- test/C/src/TestForPreviousOutput.lf | 10 + test/C/src/Watchdog.lf | 29 +- test/C/src/concurrent/AsyncCallback.lf | 13 +- test/C/src/concurrent/AsyncCallbackDrop.lf | 10 + test/C/src/concurrent/AsyncCallbackReplace.lf | 10 + .../DeadlineHandledAboveThreaded.lf | 12 +- test/C/src/concurrent/DeadlineThreaded.lf | 12 +- test/C/src/concurrent/HelloThreaded.lf | 4 + test/C/src/concurrent/ScheduleAt.lf | 9 + test/C/src/concurrent/Tracing.lf | 4 + .../src/federated/DistributedNetworkOrder.lf | 10 + .../DistributedPhysicalActionUpstream.lf | 32 +- .../DistributedPhysicalActionUpstreamLong.lf | 31 +- test/C/src/federated/HelloDistributed.lf | 4 + ...oopDistributedCentralizedPhysicalAction.lf | 24 +- .../federated/LoopDistributedDecentralized.lf | 24 +- test/C/src/federated/LoopDistributedDouble.lf | 24 +- test/C/src/include/hello.h | 4 +- .../modal_models/BanksCount3ModesComplex.lf | 4 +- .../modal_models/BanksCount3ModesSimple.lf | 4 +- .../src/modal_models/BanksModalStateReset.lf | 4 +- test/C/src/modal_models/ConvertCaseTest.lf | 8 +- test/C/src/modal_models/ModalActions.lf | 4 +- test/C/src/modal_models/ModalAfter.lf | 4 +- test/C/src/modal_models/ModalCycleBreaker.lf | 4 +- .../src/modal_models/ModalStartupShutdown.lf | 4 +- test/C/src/modal_models/ModalStateReset.lf | 4 +- .../C/src/modal_models/ModalStateResetAuto.lf | 4 +- test/C/src/modal_models/ModalTimers.lf | 4 +- .../MultipleOutputFeeder_2Connections.lf | 4 +- ...ultipleOutputFeeder_ReactionConnections.lf | 4 +- test/C/src/modal_models/util/TraceTesting.lf | 4 - test/C/src/multiport/BankIndexInitializer.lf | 4 +- .../BankMultiportToReactionNoInlining.lf | 30 + .../no_inlining/BankToReactionNoInlining.lf | 16 + test/C/src/no_inlining/Count.lf | 16 + test/C/src/no_inlining/CountHierarchy.lf | 23 + test/C/src/no_inlining/IntPrint.lf | 22 + .../MultiportToReactionNoInlining.lf | 35 + test/C/src/token/include/array.h | 6 +- test/Python/.gitignore | 1 + util/tracing/.gitignore | 2 + util/tracing/trace_to_chrome.c | 25 +- util/tracing/trace_to_csv.c | 10 +- util/tracing/trace_to_influxdb.c | 33 +- util/tracing/trace_util.c | 7 +- 119 files changed, 5503 insertions(+), 469 deletions(-) create mode 100644 org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java create mode 100644 test/C/.gitignore create mode 100644 test/C/c/bank_multiport_to_reaction_no_inlining.c create mode 100644 test/C/c/bank_multiport_to_reaction_no_inlining.cmake create mode 100644 test/C/c/bank_to_reaction_no_inlining.c create mode 100644 test/C/c/bank_to_reaction_no_inlining.cmake create mode 100644 test/C/c/count.c create mode 100644 test/C/c/count.cmake create mode 100644 test/C/c/count_hierarchy.c create mode 100644 test/C/c/count_hierarchy.cmake create mode 100644 test/C/c/multiport_to_reaction_no_inlining.c create mode 100644 test/C/c/multiport_to_reaction_no_inlining.cmake create mode 100644 test/C/c/sendreceive.c create mode 100644 test/C/c/sendreceive.cmake create mode 100644 test/C/src/no_inlining/BankMultiportToReactionNoInlining.lf create mode 100644 test/C/src/no_inlining/BankToReactionNoInlining.lf create mode 100644 test/C/src/no_inlining/Count.lf create mode 100644 test/C/src/no_inlining/CountHierarchy.lf create mode 100644 test/C/src/no_inlining/IntPrint.lf create mode 100644 test/C/src/no_inlining/MultiportToReactionNoInlining.lf create mode 100644 test/Python/.gitignore create mode 100644 util/tracing/.gitignore diff --git a/.github/actions/prepare-build-env/action.yml b/.github/actions/prepare-build-env/action.yml index 16cfc3c410..2d0c82c78f 100644 --- a/.github/actions/prepare-build-env/action.yml +++ b/.github/actions/prepare-build-env/action.yml @@ -15,9 +15,15 @@ runs: cat gradle.properties echo $JAVA_HOME shell: bash - - name: Create hash of Gradle configuration + - name: Create hash of Gradle configuration (macOS only) + run: | + echo "gradle-hash"="$(find . -type f \( -name "gradle.properties" -o -name "gradle-wrapper.properties" \) -exec cat {} + | shasum -a 256 | cut -d ' ' -f 1)" >> $GITHUB_ENV + if: ${{ runner.os == 'macOS' }} + shell: bash + - name: Create hash of Gradle configuration (Linux and Windows only) run: | echo "gradle-hash"="$(find . -type f \( -name "gradle.properties" -o -name "gradle-wrapper.properties" \) -exec cat {} + | sha256sum | cut -d ' ' -f 1)" >> $GITHUB_ENV + if: ${{ runner.os == 'Windows' || runner.os == 'Linux' }} shell: bash - name: Cache uses: actions/cache@v3 @@ -28,3 +34,9 @@ runs: key: gradle-${{ runner.os }}-${{ env.gradle-hash }} # restore-keys: | # ${{ runner.os }}-gradle- + - name: Bring down Gradle daemon (Windows) + uses: webiny/action-post-run@3.0.0 + id: post-run-command + with: + run: ./gradlew --stop + if: ${{ runner.os == 'Windows' }} diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index f0f52bd93f..167e8f6f1c 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -59,4 +59,11 @@ jobs: arduino-cli core install arduino:sam arduino-cli core install arduino:mbed - name: Perform Arduino tests for C target with default scheduler - run: ./gradlew test --tests org.lflang.tests.runtime.CArduinoTest.buildArduinoTests \ No newline at end of file + run: ./gradlew test --tests org.lflang.tests.runtime.CArduinoTest.buildArduinoTests + - name: Report to CodeCov + uses: codecov/codecov-action@v3.1.1 + with: + file: org.lflang.tests/build/reports/xml/jacoco + fail_ci_if_error: false + verbose: true + if: ${{ !inputs.runtime-ref && runner.os == 'Linux' }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 87d48f37f1..8af72a2f39 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -61,3 +61,10 @@ jobs: run: | ./gradlew test --tests org.lflang.tests.runtime.CZephyrTest.build* util/RunZephyrTests.sh test/C/src-gen + - name: Report to CodeCov + uses: codecov/codecov-action@v3.1.1 + with: + file: org.lflang.tests/build/reports/xml/jacoco + fail_ci_if_error: false + verbose: true + if: ${{ !inputs.runtime-ref && runner.os == 'Linux' }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 48110ac926..f6dd56ae40 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -51,6 +51,8 @@ jobs: uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'C' + benchmarks-ref: main + compiler-ref: master needs: cancel # Run language server tests. diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 9aaced4aba..056e32c04c 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -16,10 +16,6 @@ jobs: fetch-depth: 0 - name: Prepare build environment uses: ./.github/actions/prepare-build-env - # FIXME: reenable once the cli test is fixed - # - name: Run standalone cli tests - # run: | - # ./gradlew :org.lflang.cli:test --stacktrace - name: Test build bash scripts (Linux and macOS only) run: | .github/scripts/test-build.sh @@ -37,3 +33,14 @@ jobs: ./gradlew buildAll bin/lfc.ps1 --help if: ${{ runner.os == 'Windows' }} + - name: Run standalone cli tests + run: | + ./gradlew test --tests org.lflang.tests.cli.* --stacktrace +# NOTE: do not put other invocations for gradlew in between these steps, or coverage reporting will break. + - name: Report to CodeCov + uses: codecov/codecov-action@v3.1.1 + with: + file: org.lflang.tests/build/reports/xml/jacoco + fail_ci_if_error: false + verbose: true + if: ${{ runner.os == 'Linux' }} diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 6c2704629e..1caec5c1ac 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -12,6 +12,7 @@ jobs: steps: - uses: actions/checkout@v3 with: + submodules: true fetch-depth: 0 - name: Prepare build environment uses: ./.github/actions/prepare-build-env diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/issue490.stderr b/org.lflang.tests/resources/org/lflang/tests/cli/issue490.stderr index edf3254755..fdaa4f8e0e 100644 --- a/org.lflang.tests/resources/org/lflang/tests/cli/issue490.stderr +++ b/org.lflang.tests/resources/org/lflang/tests/cli/issue490.stderr @@ -6,23 +6,19 @@ lfc: error: Name of main reactor must match the file name (or be omitted). | ^ Name of main reactor must match the file name (or be omitted). | 5 | state liss(2, 3); - -lfc: error: missing '{=' at '{' +lfc: error: no viable alternative at input '{' --> %%%PATH.lf%%%:6:22 | 5 | state liss(2, 3); 6 | reaction (startup) { - | ^ missing '{=' at '{' + | ^ no viable alternative at input '{' | 7 | print(self.liss) - -lfc: error: mismatched input '' expecting '=}' - --> %%%PATH.lf%%%:9:2 - | - 8 | } - | >>>>>>>>>>>>>> - 9 | } -10 | - | < mismatched input '' expecting '=}' -11 | - +lfc: error: no viable alternative at input '(' +--> %%%PATH.lf%%%:7:5 + | +6 | reaction (startup) { +7 | print(self.liss) + | ^^^^^ no viable alternative at input '(' + | +8 | } diff --git a/org.lflang.tests/src/org/lflang/tests/TestRegistry.java b/org.lflang.tests/src/org/lflang/tests/TestRegistry.java index 232e735641..10fa68acaf 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestRegistry.java +++ b/org.lflang.tests/src/org/lflang/tests/TestRegistry.java @@ -32,14 +32,14 @@ /** * A registry to retrieve tests from, organized by target and category. - * + * * @author Marten Lohstroh */ public class TestRegistry { - + static class TestMap { /** - * Registry that maps targets to maps from categories to sets of tests. + * Registry that maps targets to maps from categories to sets of tests. */ protected final Map>> map = new HashMap<>(); @@ -57,7 +57,7 @@ public TestMap() { map.put(target, categories); } } - + /** * Return a set of tests given a target and test category. * @param t The target. @@ -68,26 +68,26 @@ public Set getTests(Target t, TestCategory c) { return this.map.get(t).get(c); } } - + /** * List of directories that should be skipped when indexing test files. Any * test file that has a directory in its path that matches an entry in this * array will not be discovered. */ public static final String[] IGNORED_DIRECTORIES = {"failing", "knownfailed", "failed", "fed-gen"}; - + /** * Path to the root of the repository. */ public static final Path LF_REPO_PATH = Paths.get("").toAbsolutePath(); - + /** * Path to the test directory in the repository. */ public static final Path LF_TEST_PATH = LF_REPO_PATH.resolve("test"); /** - * Internal data structure that stores registered tests. + * Internal data structure that stores registered tests. */ protected static final TestMap registered = new TestMap(); @@ -96,31 +96,31 @@ public Set getTests(Target t, TestCategory c) { * source files with no main reactor are indexed here. */ protected static final TestMap ignored = new TestMap(); - + /** * A map from each test category to a set of tests that is the union of * all registered tests in that category across all targets. */ protected static final Map> allTargets = new HashMap<>(); - + /** * Enumeration of test categories, used to map tests to categories. The * nearest containing directory that matches any of the categories will * determine the category that the test is mapped to. Matching is case * insensitive. - * + * * For example, the following files will all map to THREADED: * - C/threaded/Foo.lf - * - C/THREADED/Foo.lf + * - C/THREADED/Foo.lf * - C/Threaded/Foo.lf - * - C/foo/threaded/Bar.lf - * - C/foo/bar/threaded/Threaded.lf + * - C/foo/threaded/Bar.lf + * - C/foo/bar/threaded/Threaded.lf * - C/federated/threaded/bar.lf - * but the following will not: + * but the following will not: * - C/Foo.lf (maps to COMMON) * - C/Threaded.lf (maps to COMMON) * - C/threaded/federated/foo.lf (maps to FEDERATED) - * + * * @author Marten Lohstroh */ public enum TestCategory { @@ -140,7 +140,7 @@ public enum TestCategory { PROPERTIES(true), /** Tests concerning modal reactors */ MODAL_MODELS(true), - + NO_INLINING(false), // non-shared tests DOCKER(true), DOCKER_FEDERATED(true, "docker" + File.separator + "federated"), @@ -155,7 +155,7 @@ public enum TestCategory { public final boolean isCommon; public final String path; public final TestLevel level ; - + /** * Create a new test category. */ @@ -189,14 +189,14 @@ public String getPath() { /** * Return a header associated with the category. - * + * * @return A header to print in the test report. */ public String getHeader() { return TestBase.THICK_LINE + "Category: " + this.name(); } } - + // Static code that performs the file system traversal and discovers // all .lf files to be included in the registry. static { @@ -220,7 +220,7 @@ public String getHeader() { } else { System.out.println("WARNING: No test directory for target " + target + "\n"); } - + } catch (IOException e) { System.err.println( "ERROR: Caught exception while indexing tests for target " + target); @@ -231,7 +231,7 @@ public String getHeader() { c -> allTargets.get(c).addAll(getRegisteredTests(target, c, false))); } } - + /** * Calling this function forces the lazy initialization of the static code * that indexes all files. It is advisable to do this prior to executing @@ -239,10 +239,10 @@ public String getHeader() { * printed while indexing are printed first. */ public static void initialize() {} - + /** * Return the tests that were indexed for a given target and category. - * + * * @param target The target to get indexed tests for. * @param category The category of tests to include in the returned tests. * @param copy Whether to return copies of the indexed tests instead of the indexed tests themselves. @@ -260,7 +260,7 @@ public static Set getRegisteredTests(Target target, return registered.getTests(target, category); } } - + /** * Return the test that were found but not indexed because they did not * have a main reactor. @@ -275,11 +275,11 @@ public static String getCoverageReport(Target target, TestCategory category) { s.append(TestBase.THIN_LINE); s.append("Ignored: ").append(ignored.size()).append("\n"); s.append(TestBase.THIN_LINE); - + for (LFTest test : ignored) { s.append("No main reactor in: ").append(test).append("\n"); } - + Set own = getRegisteredTests(target, category, false); if (category.isCommon) { Set all = allTargets.get(category); @@ -301,17 +301,17 @@ public static String getCoverageReport(Target target, TestCategory category) { /** * FileVisitor implementation that maintains a stack to map found tests to - * the appropriate category and excludes directories that are listed as + * the appropriate category and excludes directories that are listed as * "ignored" from walks. - * + * * Specifically, when a directory is encountered that matches a category, * this category is pushed onto the stack. Similarly, when the DFS leaves * such a directory, its corresponding category is popped from the stack. * Any test (*.lf) file that is encountered will be mapped to the category - * that is on top of the stack. Initially, the stack has one element that + * that is on top of the stack. Initially, the stack has one element that * is TestCategory.COMMON, meaning that test files in the top-level test * directory for a given target will be mapped to that category. - * + * * @author Marten Lohstroh */ public static class TestDirVisitor extends SimpleFileVisitor { @@ -325,7 +325,7 @@ public static class TestDirVisitor extends SimpleFileVisitor { * The target that all encountered tests belong to. */ protected Target target; - + protected ResourceSet rs; protected Path srcBasePath; @@ -342,7 +342,7 @@ public TestDirVisitor(ResourceSet rs, Target target, Path srcBasePath) { this.target = target; this.srcBasePath = srcBasePath; } - + /** * Push categories onto the stack as appropriate and skip directories * that should be ignored. @@ -363,7 +363,7 @@ public FileVisitResult preVisitDirectory(Path dir, } return CONTINUE; } - + /** * Pop categories from the stack as appropriate. */ @@ -377,7 +377,7 @@ public FileVisitResult postVisitDirectory(Path dir, IOException exc) { } return CONTINUE; } - + /** * Add test files to the registry if they end with ".lf", but only if they have a main reactor. */ diff --git a/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java b/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java index 477bd26c32..7143ba9375 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java +++ b/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java @@ -34,6 +34,7 @@ import com.google.inject.Injector; +import java.io.File; import java.io.IOException; import java.nio.file.Path; import java.util.Properties; @@ -125,7 +126,8 @@ public void testVersion() { .verify(result -> { result.checkOk(); result.checkNoErrorOutput(); - result.checkStdOut(equalTo("lfc " + LocalStrings.VERSION + "\n")); + result.checkStdOut(equalTo( + "lfc " + LocalStrings.VERSION + System.lineSeparator())); }); } @@ -227,7 +229,8 @@ public void verifyGeneratorArgs(Path tempDir, String[] args) { assertEquals(properties.getProperty(BuildParm.LINT.getKey()), "true"); assertEquals(properties.getProperty(BuildParm.NO_COMPILE.getKey()), "true"); assertEquals(properties.getProperty(BuildParm.QUIET.getKey()), "true"); - assertEquals(properties.getProperty(BuildParm.RTI.getKey()), "path/to/rti"); + assertEquals(properties.getProperty(BuildParm.RTI.getKey()), + "path" + File.separator + "to" + File.separator + "rti"); assertEquals(properties.getProperty(BuildParm.RUNTIME_VERSION.getKey()), "rs"); assertEquals(properties.getProperty(BuildParm.SCHEDULER.getKey()), "GEDF_NP"); assertEquals(properties.getProperty(BuildParm.THREADING.getKey()), "false"); diff --git a/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java b/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java index 3a34e9cb81..16a4e9b32d 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java +++ b/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java @@ -30,6 +30,7 @@ import static org.lflang.tests.TestUtils.TempDirBuilder.dirBuilder; import static org.lflang.tests.TestUtils.TempDirChecker.dirChecker; +import java.io.File; import java.io.IOException; import java.nio.file.Path; @@ -76,7 +77,8 @@ public void testVersion() { ExecutionResult result = lffTester.run("--version"); result.checkOk(); result.checkNoErrorOutput(); - result.checkStdOut(equalTo("lff " + LocalStrings.VERSION + "\n")); + result.checkStdOut( + equalTo("lff " + LocalStrings.VERSION + System.lineSeparator())); } @@ -119,7 +121,8 @@ public void testFormatDirectoryVerbose(@TempDir Path tempDir) throws IOException result.checkOk(); - result.checkStdOut(containsString("Formatted src/File.lf")); + result.checkStdOut(containsString( + "Formatted src" + File.separator + "File.lf")); dirChecker(tempDir).checkContentsOf("src/File.lf", equalTo(FILE_AFTER_REFORMAT)); } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java index c5ead40cb7..847a364193 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java @@ -1150,7 +1150,7 @@ private List synthesizeExamples(UnionType type, boolean correct) { */ private List synthesizeExamples(DictionaryType type, boolean correct) { List examples = new LinkedList<>(); - // Produce a set of singleton dictionaries. + // Produce a set of singleton dictionaries. // If incorrect examples are wanted, garble the key. for (DictionaryElement option : type.options) { synthesizeExamples(option.getType(), correct).forEach(it -> examples.add( @@ -1629,7 +1629,7 @@ public void testMainReactorHasHost() throws Exception { """; // TODO: Uncomment and fix test // List issues = validator.validate(parseWithoutError(testCase)); - // Assertions.assertTrue(issues.size() == 1 && + // Assertions.assertTrue(issues.size() == 1 && // issues.get(0).getMessage().contains("Cannot assign a host to reactor '") && // issues.get(0).getMessage().contains("' because it is not federated.")); } @@ -1810,7 +1810,7 @@ public void testMissingModeStateResetInstance() throws Exception { "This reactor contains state variables that are not reset upon mode entry: " + "s in R" + ".\nThe state variables are neither marked for automatic reset nor have a dedicated reset reaction. " - + "It is usafe to instatiate this reactor inside a mode entered with reset."); + + "It is unsafe to instantiate this reactor inside a mode entered with reset."); } @Test @@ -1841,11 +1841,9 @@ public void testUnspecifiedTransitionType() throws Exception { } """; validator.assertWarning(parseWithoutError(testCase), LfPackage.eINSTANCE.getReaction(), null, - "You should specifiy a transition type! " + "You should specify a transition type! " + "Reset and history transitions have different effects on this target mode. " + "Currently, a reset type is implicitly assumed."); } } - - diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java index 24cb3554ff..801211be23 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java @@ -45,6 +45,7 @@ public void roundTripTest() { private void run(Path file) throws Exception { Model originalModel = LfParsingUtil.parse(file); + System.out.println(file); assertThat(originalModel.eResource().getErrors(), equalTo(emptyList())); // TODO: Check that the output is a fixed point final int smallLineLength = 20; diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java b/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java index 901f0e6154..014fcc7276 100644 --- a/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java +++ b/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java @@ -17,7 +17,7 @@ public MockReportProgress() { @Override public void apply(String message, Integer percentage) { - System.out.printf("%s [%d -> %d]%n", message, previousPercentProgress, percentage); + System.out.printf("MockReportProgress: %s [%d -> %d]%n", message, previousPercentProgress, percentage); if (percentage == null) return; if (percentage < previousPercentProgress || percentage < 0 || percentage > 100) failed = true; previousPercentProgress = percentage; diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java index db0ee3431f..17fd386ad8 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java @@ -46,6 +46,7 @@ private static boolean isExcludedFromCCpp(TestCategory category) { excluded |= isMac() && (category == TestCategory.DOCKER_FEDERATED || category == TestCategory.DOCKER); excluded |= category == TestCategory.ZEPHYR; excluded |= category == TestCategory.ARDUINO; + excluded |= category == TestCategory.NO_INLINING; return !excluded; } } diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 46b913eee0..0fd819e0e0 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -59,6 +59,7 @@ import org.lflang.ast.ToText; import org.lflang.generator.CodeMap; import org.lflang.generator.InvalidSourceException; +import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.Assignment; import org.lflang.lf.Code; @@ -801,6 +802,7 @@ public static Element toElement(boolean val) { return toElement(Boolean.toString(val), false); } +<<<<<<< HEAD public static Element toElement(int val) { return toElement(Integer.toString(val), false); } @@ -819,6 +821,336 @@ public static String baseType(Type type) { } else { if (type.isTime()) { return "time"; +======= + /** A list of all ports of {@code definition}, in an unspecified order. */ + public static List allPorts(Reactor definition) { + return Stream.concat(ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()).toList(); + } + + /** + * Given a reactor class, return a list of all its instantiations, + * which includes instantiations of base classes that it extends. + * This also includes instantiations in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allInstantiations(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); + } + + public static Stream allNestedClasses(Reactor definition) { + return new HashSet<>(ASTUtils.allInstantiations(definition)).stream() + .map(Instantiation::getReactorClass) + .map(ASTUtils::toDefinition); + } + + /** + * Given a reactor class, return a list of all its methods, + * which includes methods of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allMethods(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); + } + + /** + * Given a reactor class, return a list of all its outputs, + * which includes outputs of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allOutputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); + } + + /** + * Given a reactor class, return a list of all its parameters, + * which includes parameters of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allParameters(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); + } + + /** + * Given a reactor class, return a list of all its reactions, + * which includes reactions of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allReactions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); + } + + /** + * Given a reactor class, return a list of all its state variables, + * which includes state variables of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allStateVars(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); + } + + /** + * Given a reactor class, return a list of all its timers, + * which includes timers of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allTimers(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); + } + + /** + * Given a reactor class, returns a list of all its modes, + * which includes modes of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allModes(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); + } + + /** A list of all reactors instantiated, transitively or intransitively, by {@code r}. */ + public static List recursiveChildren(ReactorInstance r) { + List ret = new ArrayList<>(); + ret.add(r.reactorDefinition); + for (var child: r.children) { + ret.addAll(recursiveChildren(child)); + } + return ret; + } + + /** + * Return all the superclasses of the specified reactor + * in deepest-first order. For example, if A extends B and C, and + * B and C both extend D, this will return the list [D, B, C, A]. + * Duplicates are removed. If the specified reactor does not extend + * any other reactor, then return an empty list. + * If a cycle is found, where X extends Y and Y extends X, or if + * a superclass is declared that is not found, then return null. + * @param reactor The specified reactor. + */ + public static LinkedHashSet superClasses(Reactor reactor) { + return superClasses(reactor, new LinkedHashSet<>()); + } + + /** + * Collect elements of type T from the class hierarchy and modes + * defined by a given reactor definition. + * @param definition The reactor definition. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + public static List collectElements(Reactor definition, EStructuralFeature feature) { + return ASTUtils.collectElements(definition, feature, true, true); + } + + /** + * Collect elements of type T contained in given reactor definition, including + * modes and the class hierarchy defined depending on configuration. + * @param definition The reactor definition. + * @param feature The structual model elements to collect. + * @param includeSuperClasses Whether to include elements in super classes. + * @param includeModes Whether to include elements in modes. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + @SuppressWarnings("unchecked") + public static List collectElements(Reactor definition, EStructuralFeature feature, boolean includeSuperClasses, boolean includeModes) { + List result = new ArrayList<>(); + + if (includeSuperClasses) { + // Add elements of elements defined in superclasses. + LinkedHashSet s = superClasses(definition); + if (s != null) { + for (Reactor superClass : s) { + result.addAll((EList) superClass.eGet(feature)); + } + } + } + + // Add elements of the current reactor. + result.addAll((EList) definition.eGet(feature)); + + if (includeModes && reactorModeFeatureMap.containsKey(feature)) { + var modeFeature = reactorModeFeatureMap.get(feature); + // Add elements of elements defined in modes. + for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { + insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); + } + } + + return result; + } + + /** + * Adds the elements into the given list at a location matching to their textual position. + * + * When creating a flat view onto reactor elements including modes, the final list must be ordered according + * to the textual positions. + * + * Example: + * reactor R { + * reaction // -> is R.reactions[0] + * mode M { + * reaction // -> is R.mode[0].reactions[0] + * reaction // -> is R.mode[0].reactions[1] + * } + * reaction // -> is R.reactions[1] + * } + * In this example, it is important that the reactions in the mode are inserted between the top-level + * reactions to retain the correct global reaction ordering, which will be derived from this flattened view. + * + * @param list The list to add the elements into. + * @param elements The elements to add. + * @param mode The mode containing the elements. + * @param The type of elements to add (e.g., Port, Timer, etc.) + */ + private static void insertModeElementsAtTextualPosition(List list, List elements, Mode mode) { + if (elements.isEmpty()) { + return; // Nothing to add + } + + var idx = list.size(); + if (idx > 0) { + // If there are elements in the list, first check if the last element has the same container as the mode. + // I.e. we don't want to compare textual positions of different reactors (super classes) + if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { + var modeAstNode = NodeModelUtils.getNode(mode); + if (modeAstNode != null) { + var modePos = modeAstNode.getOffset(); + // Now move the insertion index from the last element forward as long as this element has a textual + // position after the mode. + do { + var astNode = NodeModelUtils.getNode(list.get(idx - 1)); + if (astNode != null && astNode.getOffset() > modePos) { + idx--; + } else { + break; // Insertion index is ok. + } + } while (idx > 0); + } + } + } + list.addAll(idx, elements); + } + + public static Iterable allElementsOfClass( + Resource resource, + Class elementClass + ) { + //noinspection StaticPseudoFunctionalStyleMethod + return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); + } + + //////////////////////////////// + //// Utility functions for translating AST nodes into text + + /** + * Translate the given code into its textual representation + * with {@code CodeMap.Correspondence} tags inserted, or + * return the empty string if {@code node} is {@code null}. + * This method should be used to generate code. + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toText(EObject node) { + if (node == null) return ""; + return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); + } + + /** + * Translate the given code into its textual representation + * without {@code CodeMap.Correspondence} tags, or return + * the empty string if {@code node} is {@code null}. + * This method should be used for analyzing AST nodes in + * cases where they are easiest to analyze as strings. + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toOriginalText(EObject node) { + if (node == null) return ""; + return ToText.instance.doSwitch(node); + } + + /** + * Return an integer representation of the given element. + * + * Internally, this method uses Integer.decode, so it will + * also understand hexadecimal, binary, etc. + * + * @param e The element to be rendered as an integer. + */ + public static Integer toInteger(Element e) { + return Integer.decode(e.getLiteral()); + } + + /** + * Return a time value based on the given element. + * + * @param e The element to be rendered as a time value. + */ + public static TimeValue toTimeValue(Element e) { + return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); + } + + /** + * Returns the time value represented by the given AST node. + */ + public static TimeValue toTimeValue(Time e) { + if (!isValidTime(e)) { + // invalid unit, will have been reported by validator + throw new IllegalArgumentException(); + } + return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); + } + + /** + * Return a boolean based on the given element. + * + * @param e The element to be rendered as a boolean. + */ + public static boolean toBoolean(Element e) { + return elementToSingleString(e).equalsIgnoreCase("true"); + } + + /** + * Given the right-hand side of a target property, return a string that + * represents the given value/ + * + * If the given value is not a literal or and id (but for instance and array or dict), + * an empty string is returned. If the element is a string, any quotes are removed. + * + * @param e The right-hand side of a target property. + */ + public static String elementToSingleString(Element e) { + if (e.getLiteral() != null) { + return StringUtil.removeQuotes(e.getLiteral()).trim(); + } else if (e.getId() != null) { + return e.getId(); + } + return ""; + } + + /** + * Given the right-hand side of a target property, return a list with all + * the strings that the property lists. + * + * Arrays are traversed, so strings are collected recursively. Empty strings + * are ignored; they are not added to the list. + * @param value The right-hand side of a target property. + */ + public static List elementToListOfStrings(Element value) { + List elements = new ArrayList<>(); + if (value.getArray() != null) { + for (Element element : value.getArray().getElements()) { + elements.addAll(elementToListOfStrings(element)); + } + return elements; +>>>>>>> origin } else { StringBuilder result = new StringBuilder(type.getId()); diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/src/org/lflang/LinguaFranca.xtext index 9ee2cb520d..4e1645e9db 100644 --- a/org.lflang/src/org/lflang/LinguaFranca.xtext +++ b/org.lflang/src/org/lflang/LinguaFranca.xtext @@ -13,22 +13,22 @@ are permitted provided that the following conditions are met: this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +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. ***************/ -/** +/** * Grammar for Lingua Franca. * A note of caution: extending this grammar with productions that introduce - * new terminals (i.e., anything written between quotes), will require those + * new terminals (i.e., anything written between quotes), will require those * terminals to also be added to the Token production at the bottom of this * file. Failing to do so will cause a parse error whenever a terminal not * listed in the Token production is featured in a segment of target-language @@ -44,7 +44,7 @@ import "http://www.eclipse.org/emf/2002/Ecore" as ecore // Use the package name "lf" for generated files defining the classes // in the metamodel (i.e., the classes representing nodes in the -// abstract syntax tree (AST), i.e., the eCore model). +// abstract syntax tree (AST), i.e., the eCore model). generate lf "https://lf-lang.org" /////////// Overall file @@ -106,7 +106,7 @@ TypeExpr: /** * Specification of the target language. Target properties can be specified in - * YAML format to pass on configuration details to the runtime environment. + * YAML format to pass on configuration details to the runtime environment. */ TargetDecl: 'target' name=ID (config=KeyValuePairs)? ';'?; @@ -115,11 +115,11 @@ TargetDecl: /////////// Statements /** - * Declaration of a state variable. Types are optional, but may be required - * during validation (depending on the target language). Initialization is also + * Declaration of a state variable. Types are optional, but may be required + * during validation (depending on the target language). Initialization is also * optional. A state variable can be initialized by assigning a `Expression` or list * of these. Note that a `Expression` may also be a reference to a parameter. - * The following checks must be carried out during validation: + * The following checks must be carried out during validation: * - if the list of initialization expressions has more than one element in it, a * type must be specified; * - if the `time` type is specified, there can only be a single initialization @@ -182,10 +182,10 @@ Mode: )* '}'; // Action that has either a physical or logical origin. -// +// // If the origin is logical, the minDelay is a minimum logical delay // after the logical time at which schedule() is called that the -// action will occur. If the origin is physical, then the +// action will occur. If the origin is physical, then the // minDelay is a minimum logical delay after the physical time // at which schedule() is called that the action will occur. // @@ -200,12 +200,11 @@ Action: Reaction: (attributes+=Attribute)* (('reaction') | mutation ?= 'mutation') - ('(' (triggers+=TriggerRef (',' triggers+=TriggerRef)*)? ')')? + ('(' (triggers+=TriggerRef (',' triggers+=TriggerRef)*)? ')') (sources+=VarRef (',' sources+=VarRef)*)? ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? - code=Code - (stp=STP)? - (deadline=Deadline)?; + ((('named' name=ID)? code=Code) | 'named' name=ID)(stp=STP)?(deadline=Deadline)? + ; TriggerRef: BuiltinTriggerRef | VarRef; @@ -237,7 +236,7 @@ Instantiation: Connection: ((leftPorts += VarRef (',' leftPorts += VarRef)*) | ( '(' leftPorts += VarRef (',' leftPorts += VarRef)* ')' iterated ?= '+'?)) - ('->' | physical?='~>') + ('->' | physical?='~>') rightPorts += VarRef (',' rightPorts += VarRef)* ('after' delay=Expression)? (serializer=Serializer)? @@ -271,7 +270,7 @@ Array: // todo allow empty array in grammar, replace with validator error Element: keyvalue=KeyValuePairs | array=Array - | literal=Literal + | literal=Literal | (time=INT unit=TimeUnit) | id=Path; @@ -284,8 +283,8 @@ Variable: TypedVariable | Timer | Mode | Watchdog; VarRef: - variable=[Variable] | container=[Instantiation] '.' variable=[Variable] - | interleaved?='interleaved' '(' (variable=[Variable] | container=[Instantiation] '.' variable=[Variable]) ')' + (variable=[Variable] | container=[Instantiation] '.' variable=[Variable] + | interleaved?='interleaved' '(' (variable=[Variable] | container=[Instantiation] '.' variable=[Variable]) ')') ('as' (alias=ID))? ; VarRefOrModeTransition returns VarRef: VarRef | transition=ModeTransition '(' variable=[Mode] ')'; @@ -338,7 +337,7 @@ Time: Port: Input | Output; - + // A type is in the target language, hence either an ID or target code. Type: time?='time' (arraySpec=ArraySpec)? @@ -435,24 +434,24 @@ IPV4Addr: ; IPV6Seg: - // NOTE: This rule is too permissive by design. + // NOTE: This rule is too permissive by design. // Further checking is done during validation. (INT | (INT? ID)) ; IPV6Addr: - // NOTE: This rule is too permissive by design. - // Further checking is done during validation. + // NOTE: This rule is too permissive by design. + // Further checking is done during validation. // IPV6 with truncation. - '::' | ('::' (IPV6Seg (':'))* IPV6Seg) | ((IPV6Seg (':'|'::'))+ IPV6Seg?) | - + '::' | ('::' (IPV6Seg (':'))* IPV6Seg) | ((IPV6Seg (':'|'::'))+ IPV6Seg?) | + // (Link-local IPv6 addresses with zone index) "fe80::7:8%1" (ID '::' IPV6Seg (':' IPV6Seg)* '%' (INT | ID)+) | // IPv4-mapped IPv6 addresses and IPv4-translated addresses ('::' IPV4Addr) | ('::' ID ':' (INT ':')? IPV4Addr) | - + // IPv4-Embedded IPv6 Address (((IPV6Seg (':' IPV6Seg)* '::') | (IPV6Seg (':' IPV6Seg)*) ':') IPV4Addr) ; @@ -469,7 +468,7 @@ Code: {Code} '{=' body=Body '=}' ; -FSName: +FSName: (ID | '.' | '_')+ ; // Absolute or relative directory path in Windows, Linux, or MacOS. @@ -508,11 +507,12 @@ Token: // Non-constant terminals ID | INT | FLOAT_EXP_SUFFIX | LT_ANNOT | STRING | CHAR_LIT | ML_COMMENT | SL_COMMENT | WS | ANY_OTHER | // Keywords - 'target' | 'import' | 'main' | 'realtime' | 'reactor' | 'state' | 'time' | - 'mutable' | 'input' | 'output' | 'timer' | 'action' | 'reaction' | + 'target' | 'import' | 'main' | 'realtime' | 'reactor' | 'state' | 'time' | + 'mutable' | 'input' | 'output' | 'timer' | 'action' | 'reaction' | 'startup' | 'shutdown' | 'after' | 'deadline' | 'mutation' | 'preamble' | 'new' | 'federated' | 'at' | 'as' | 'from' | 'widthof' | 'const' | 'method' | - 'interleaved' | 'mode' | 'initial' | 'reset' | 'history' | 'watchdog' | + 'interleaved' | 'mode' | 'initial' | 'reset' | 'history' | 'watchdog' | 'named' | + // Other terminals NEGINT | TRUE | FALSE | // Action origins @@ -532,7 +532,7 @@ Token: // Underscore '_' | // Arrow - '->' | + '->' | // Assignment '=' | // Percentage diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index f4bbc17f6d..3a7a5fb2cd 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -275,19 +275,20 @@ public Boolean caseAttrParm(AttrParm object) { .conclusion; } - @Override - public Boolean caseReaction(Reaction object) { - return new ComparisonMachine<>(object, Reaction.class) - .listsEquivalent(Reaction::getAttributes) - .listsEquivalent(Reaction::getTriggers) - .listsEquivalent(Reaction::getSources) - .listsEquivalent(Reaction::getEffects) - .equalAsObjects(Reaction::isMutation) - .equivalent(Reaction::getCode) - .equivalent(Reaction::getStp) - .equivalent(Reaction::getDeadline) - .conclusion; - } + @Override + public Boolean caseReaction(Reaction object) { + return new ComparisonMachine<>(object, Reaction.class) + .listsEquivalent(Reaction::getAttributes) + .listsEquivalent(Reaction::getTriggers) + .listsEquivalent(Reaction::getSources) + .listsEquivalent(Reaction::getEffects) + .equalAsObjects(Reaction::isMutation) + .equalAsObjects(Reaction::getName) + .equivalent(Reaction::getCode) + .equivalent(Reaction::getStp) + .equivalent(Reaction::getDeadline) + .conclusion; + } @Override public Boolean caseTriggerRef(TriggerRef object) { diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index 2f0ec76d9b..ce1cdca9fe 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -598,13 +598,12 @@ public MalleableString caseAction(Action object) { @Override public MalleableString caseReaction(Reaction object) { - // ('reaction') - // ('(' (triggers+=TriggerRef (',' triggers+=TriggerRef)*)? ')')? + // (attributes+=Attribute)* + // (('reaction') | mutation ?= 'mutation') + // ('(' (triggers+=TriggerRef (',' triggers+=TriggerRef)*)? ')') // (sources+=VarRef (',' sources+=VarRef)*)? // ('->' effects+=VarRefOrModeTransition (',' effects+=VarRefOrModeTransition)*)? - // code=Code - // (stp=STP)? - // (deadline=Deadline)? + // ((('named' name=ID)? code=Code) | 'named' name=ID)(stp=STP)?(deadline=Deadline)? Builder msb = new Builder(); addAttributes(msb, object::getAttributes); if (object.isMutation()) { @@ -633,7 +632,8 @@ public MalleableString caseReaction(Reaction object) { : doSwitch(varRef)) .collect(new Joiner(", "))); } - msb.append(" ").append(doSwitch(object.getCode())); + if (object.getName() != null) msb.append(" named ").append(object.getName()); + if (object.getCode() != null) msb.append(" ").append(doSwitch(object.getCode())); if (object.getStp() != null) msb.append(" ").append(doSwitch(object.getStp())); if (object.getDeadline() != null) msb.append(" ").append(doSwitch(object.getDeadline())); return msb.get(); diff --git a/org.lflang/src/org/lflang/cli/CliBase.java b/org.lflang/src/org/lflang/cli/CliBase.java index 4dea30b865..2f4a9d849c 100644 --- a/org.lflang/src/org/lflang/cli/CliBase.java +++ b/org.lflang/src/org/lflang/cli/CliBase.java @@ -157,16 +157,14 @@ public void run() { "No such file: " + topLevelArg.jsonFile); } } - // If args are given in a json string, (1) unpack them into an args - // array, and (2) call cmd.execute on them, which assigns them to their - // correct instance variables, then (3) recurses into run(). + // If args are given in a json string, unpack them and re-run + // picocli argument validation. if (topLevelArg.jsonString != null) { // Unpack args from json string. String[] args = jsonStringToArgs(topLevelArg.jsonString); // Execute application on unpacked args. CommandLine cmd = spec.commandLine(); - int exitCode = cmd.execute(args); - io.callSystemExit(exitCode); + cmd.execute(args); // If args are already unpacked, invoke tool-specific logic. } else { doRun(); diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index a2ac48216f..4698c2eb84 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -38,6 +38,7 @@ import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; +import org.lflang.Target; import org.lflang.TargetProperty; import org.lflang.TargetProperty.CoordinationType; import org.lflang.TimeValue; @@ -99,7 +100,7 @@ public void initializeTargetConfig( federate.targetConfig.setByUser.add(TargetProperty.THREADING); // Include the fed setup file for this federate in the target property - String relPath = "include" + File.separator + "_" + federate.name + "_preamble.h"; + String relPath = getPreamblePath(federate); federate.targetConfig.fedSetupPreamble = relPath; federate.targetConfig.setByUser.add(TargetProperty.FED_SETUP); } @@ -471,7 +472,7 @@ public String getNetworkBufferType() { } /** - * Add preamble to a separate file `include/_federateName_preamble.h` to set up federated execution. + * Add preamble to a separate file to set up federated execution. * Return an empty string since no code generated needs to go in the source. */ @Override @@ -483,14 +484,29 @@ public String generatePreamble( ) throws IOException { // Put the C preamble in a `include/_federate.name + _preamble.h` file String cPreamble = makePreamble(federate, fileConfig, rtiConfig, errorReporter); - String relPath = "include" + File.separator + "_" + federate.name + "_preamble.h"; + String relPath = getPreamblePath(federate); Path fedPreamblePath = fileConfig.getSrcPath().resolve(relPath); Files.createDirectories(fedPreamblePath.getParent()); try (var writer = Files.newBufferedWriter(fedPreamblePath)) { writer.write(cPreamble); } + var includes = new CodeBuilder(); + if (federate.targetConfig.target != Target.Python) { + includes.pr("#ifdef __cplusplus\n" + + "extern \"C\" {\n" + + "#endif"); + includes.pr("#include \"core/federated/federate.h\""); + includes.pr("#include \"core/federated/net_common.h\""); + includes.pr("#include \"core/federated/net_util.h\""); + includes.pr("#include \"core/threaded/reactor_threaded.h\""); + includes.pr("#include \"core/utils/util.h\""); + includes.pr("extern federate_instance_t _fed;"); + includes.pr("#ifdef __cplusplus\n" + + "}\n" + + "#endif"); + } - return ""; + return includes.toString(); } /** @@ -558,7 +574,7 @@ private String generateInitializeTriggers(FederateInstance federate, ErrorReport code.pr(CExtensionUtils.initializeTriggersForNetworkActions(federate, main)); code.pr(CExtensionUtils.initializeTriggerForControlReactions(main, main, federate)); federatedReactor.setName(oldFederatedReactorName); - + return """ #define initialize_triggers_for_federate() \\ do { \\ @@ -744,5 +760,7 @@ private String generateCodeForPhysicalActions(FederateInstance federate, ErrorRe } return code.getCode(); } - + private String getPreamblePath(FederateInstance f) { + return "include" + File.separator + "_" + f.name + "_preamble.h"; + } } diff --git a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java index e438b1b866..77d6203a93 100644 --- a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java @@ -96,22 +96,21 @@ public String generatePreamble(FederateInstance federate, FedFileConfig fileConf var upstreamConnectionDelays = getUpstreamConnectionDelays(federate); return """ - preamble {= - const defaultFederateConfig: __FederateConfig = { - dependsOn: [%s], - executionTimeout: undefined, - fast: false, - federateID: %d, - federationID: "Unidentified Federation", - keepAlive: false, - minOutputDelay: %s, - networkMessageActions: [%s], - rtiHost: "%s", - rtiPort: %d, - sendsTo: [%s], - upstreamConnectionDelays: [%s] - } - =}""".formatted( + const defaultFederateConfig: __FederateConfig = { + dependsOn: [%s], + executionTimeout: undefined, + fast: false, + federateID: %d, + federationID: "Unidentified Federation", + keepAlive: false, + minOutputDelay: %s, + networkMessageActions: [%s], + rtiHost: "%s", + rtiPort: %d, + sendsTo: [%s], + upstreamConnectionDelays: [%s] + } + """.formatted( federate.dependsOn.keySet().stream() .map(e->String.valueOf(e.id)) .collect(Collectors.joining(",")), diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java index 18d5770165..cd9c2e95d0 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java +++ b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java @@ -288,7 +288,7 @@ private Map compileFederates( Resource res = rs.getResource(URI.createFileURI( fileConfig.getSrcPath().resolve(fed.name + ".lf").toAbsolutePath().toString() ), true); - FileConfig subFileConfig = LFGenerator.createFileConfig(res, fileConfig.getSrcGenPath(), false); + FileConfig subFileConfig = LFGenerator.createFileConfig(res, fileConfig.getSrcGenPath(), true); ErrorReporter subContextErrorReporter = new LineAdjustingErrorReporter(threadSafeErrorReporter, lf2lfCodeMapMap); var props = new Properties(); diff --git a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java index 20771e7848..354cd33044 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java @@ -39,8 +39,13 @@ String generatePreamble(FederateInstance federate, FedFileConfig fileConfig, Rti )); } - preambleCode.pr(FedTargetExtensionFactory.getExtension(federate.targetConfig.target).generatePreamble( - federate, fileConfig, rtiConfig, errorReporter)); + preambleCode.pr(""" + preamble {= + %s + =}""".formatted(FedTargetExtensionFactory.getExtension(federate.targetConfig.target).generatePreamble( + federate, fileConfig, rtiConfig, errorReporter + )) + ); return preambleCode.getCode(); } diff --git a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java b/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java index 116cbf3046..3422ee0d50 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java @@ -44,23 +44,23 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * In the worst case, of these runtime instances may have distinct dependencies, * and hence distinct levels in the graph. Moreover, some of these instances * may be involved in cycles while others are not. - * + * * Upon construction of this class, the runtime instances are created if necessary, * stored each ReactionInstance, and assigned levels (maximum number of * upstream reaction instances), deadlines, and single dominating reactions. - * + * * After creation, the resulting graph will be empty unless there are causality * cycles, in which case, the resulting graph is a graph of runtime reaction * instances that form cycles. - * + * * @author Marten Lohstroh * @author Edward A. Lee */ public class ReactionInstanceGraph extends PrecedenceGraph { - + /** - * Create a new graph by traversing the maps in the named instances - * embedded in the hierarchy of the program. + * Create a new graph by traversing the maps in the named instances + * embedded in the hierarchy of the program. */ public ReactionInstanceGraph(ReactorInstance main) { this.main = main; @@ -74,12 +74,12 @@ public ReactionInstanceGraph(ReactorInstance main) { * The main reactor instance that this graph is associated with. */ public final ReactorInstance main; - + /////////////////////////////////////////////////////////// //// Public methods - + /** - * Rebuild this graph by clearing and repeating the traversal that + * Rebuild this graph by clearing and repeating the traversal that * adds all the nodes and edges. */ public void rebuild() { @@ -89,7 +89,7 @@ public void rebuild() { // FIXME: Use {@link TargetProperty#EXPORT_DEPENDENCY_GRAPH}. // System.out.println(toDOT()); - // Assign a level to each reaction. + // Assign a level to each reaction. // If there are cycles present in the graph, it will be detected here. assignLevels(); if (nodeCount() != 0) { @@ -109,9 +109,9 @@ public void rebuildAndAssignDeadlines() { assignInferredDeadlines(); this.clear(); } - + /* - * Get an array of non-negative integers representing the number of reactions + * Get an array of non-negative integers representing the number of reactions * per each level, where levels are indices of the array. */ public Integer[] getNumReactionsPerLevel() { @@ -133,7 +133,7 @@ public int getBreadth() { /////////////////////////////////////////////////////////// //// Protected methods - + /** * Add to the graph edges between the given reaction and all the reactions * that depend on the specified port. @@ -144,19 +144,19 @@ protected void addDownstreamReactions(PortInstance port, ReactionInstance reacti // Use mixed-radix numbers to increment over the ranges. List srcRuntimes = reaction.getRuntimeInstances(); List eventualDestinations = port.eventualDestinations(); - + int srcDepth = (port.isInput())? 2 : 1; - + for (SendRange sendRange : eventualDestinations) { for (RuntimeRange dstRange : sendRange.destinations) { - + int dstDepth = (dstRange.instance.isOutput())? 2 : 1; MixedRadixInt dstRangePosition = dstRange.startMR(); int dstRangeCount = 0; MixedRadixInt sendRangePosition = sendRange.startMR(); int sendRangeCount = 0; - + while (dstRangeCount++ < dstRange.width) { int srcIndex = sendRangePosition.get(srcDepth); int dstIndex = dstRangePosition.get(dstDepth); @@ -177,7 +177,7 @@ protected void addDownstreamReactions(PortInstance port, ReactionInstance reacti if (srcRuntime.deadline.compareTo(dstRuntime.deadline) > 0) { srcRuntime.deadline = dstRuntime.deadline; } - + // If this seems to be a single dominating reaction, set it. // If another upstream reaction shows up, then this will be // reset to null. @@ -203,7 +203,7 @@ protected void addDownstreamReactions(PortInstance port, ReactionInstance reacti } /** - * Build the graph by adding nodes and edges based on the given reactor + * Build the graph by adding nodes and edges based on the given reactor * instance. * @param reactor The reactor on the basis of which to add nodes and edges. */ @@ -211,12 +211,12 @@ protected void addNodesAndEdges(ReactorInstance reactor) { ReactionInstance previousReaction = null; for (ReactionInstance reaction : reactor.reactions) { List runtimes = reaction.getRuntimeInstances(); - + // Add reactions of this reactor. for (Runtime runtime : runtimes) { - this.addNode(runtime); + this.addNode(runtime); } - + // If this is not an unordered reaction, then create a dependency // on any previously defined reaction. if (!reaction.isUnordered) { @@ -251,12 +251,12 @@ protected void addNodesAndEdges(ReactorInstance reactor) { addNodesAndEdges(child); } } - + /////////////////////////////////////////////////////////// //// Private fields - + /** - * Number of reactions per level, represented as a list of + * Number of reactions per level, represented as a list of * integers where the indices are the levels. */ private List numReactionsPerLevel = new ArrayList<>(List.of(0)); @@ -268,7 +268,7 @@ protected void addNodesAndEdges(ReactorInstance reactor) { * Analyze the dependencies between reactions and assign each reaction * instance a level. This method removes nodes from this graph as it * assigns levels. Any remaining nodes are part of causality cycles. - * + * * This procedure is based on Kahn's algorithm for topological sorting. * Rather than establishing a total order, we establish a partial order. * In this order, the level of each reaction is the least upper bound of @@ -276,13 +276,13 @@ protected void addNodesAndEdges(ReactorInstance reactor) { */ private void assignLevels() { List start = new ArrayList<>(rootNodes()); - + // All root nodes start with level 0. for (Runtime origin : start) { origin.level = 0; } - // No need to do any of this if there are no root nodes; + // No need to do any of this if there are no root nodes; // the graph must be cyclic. while (!start.isEmpty()) { Runtime origin = start.remove(0); @@ -293,7 +293,7 @@ private void assignLevels() { for (Runtime effect : downstreamAdjacentNodes) { // Stage edge between origin and effect for removal. toRemove.add(effect); - + // Update level of downstream node. effect.level = origin.level + 1; } @@ -306,7 +306,7 @@ private void assignLevels() { start.add(effect); } } - + // Remove visited origin. removeNode(origin); @@ -314,16 +314,16 @@ private void assignLevels() { adjustNumReactionsPerLevel(origin.level, 1); } } - + /** * This function assigns inferred deadlines to all the reactions in the graph. * It is modeled after `assignLevels` but it starts at the leaf nodes and uses * Kahns algorithm to build a reverse topologically sorted graph - * + * */ private void assignInferredDeadlines() { List start = new ArrayList<>(leafNodes()); - + // All leaf nodes have deadline initialized to their declared deadline or MAX_VALUE while (!start.isEmpty()) { Runtime origin = start.remove(0); @@ -334,7 +334,7 @@ private void assignInferredDeadlines() { for (Runtime upstream : upstreamAdjacentNodes) { // Stage edge between origin and upstream for removal. toRemove.add(upstream); - + // Update deadline of upstream node if origins deadline is earlier. if (origin.deadline.isEarlierThan(upstream.deadline)) { upstream.deadline = origin.deadline; @@ -349,12 +349,12 @@ private void assignInferredDeadlines() { start.add(upstream); } } - + // Remove visited origin. removeNode(origin); } } - + /** * Adjust {@link #numReactionsPerLevel} at index level by * adding to the previously recorded number valueToAdd. @@ -411,7 +411,7 @@ public String toDOT() { var currentLevelNodes = groupedNodes.get(level); for (var node: currentLevelNodes) { // Draw the node - var label = CUtil.getName(node.getReaction().getParent().reactorDeclaration) + "." + node.getReaction().getName(); + var label = CUtil.getName(node.getReaction().getParent().reactorDefinition) + "." + node.getReaction().getName(); // Need a positive number to name the nodes in GraphViz var labelHashCode = label.hashCode() & 0xfffffff; dotRepresentation.pr(" node_" + labelHashCode + " [label=\""+ label +"\"];"); @@ -419,7 +419,7 @@ public String toDOT() { // Draw the edges var downstreamNodes = getDownstreamAdjacentNodes(node); for (var downstreamNode: downstreamNodes) { - var downstreamLabel = CUtil.getName(downstreamNode.getReaction().getParent().reactorDeclaration) + "." + downstreamNode.getReaction().getName(); + var downstreamLabel = CUtil.getName(downstreamNode.getReaction().getParent().reactorDefinition) + "." + downstreamNode.getReaction().getName(); edges.append(" node_" + labelHashCode + " -> node_" + (downstreamLabel.hashCode() & 0xfffffff) + ";\n" ); diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index ba85ae8288..cb8f67b073 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -66,6 +66,7 @@ import org.lflang.lf.WidthSpec; /** +<<<<<<< HEAD * Representation of a compile-time instance of a reactor. If the reactor is instantiated as a bank * of reactors, or if any of its parents is instantiated as a bank of reactors, then one instance of * this ReactorInstance class represents all the runtime instances within these banks. The {@link @@ -78,6 +79,23 @@ * Lingua Franca program. If the program has causality loops (a programming error), then {@link * #hasCycles()} will return true and {@link #getCycles()} will return the ports and reaction * instances involved in the cycles. +======= + * Representation of a compile-time instance of a reactor. + * If the reactor is instantiated as a bank of reactors, or if any + * of its parents is instantiated as a bank of reactors, then one instance + * of this ReactorInstance class represents all the runtime instances within + * these banks. The {@link #getTotalWidth()} method returns the number of such + * runtime instances, which is the product of the bank width of this reactor + * instance and the bank widths of all of its parents. + * There is exactly one instance of this ReactorInstance class for each + * graphical rendition of a reactor in the diagram view. + * + * For the main reactor, which has no parent, once constructed, + * this object represents the entire Lingua Franca program. + * If the program has causality loops (a programming error), then + * {@link #hasCycles()} will return true and {@link #getCycles()} will + * return the ports and reaction instances involved in the cycles. +>>>>>>> origin * * @author Marten Lohstroh * @author Edward A. Lee @@ -247,6 +265,7 @@ public void clearCaches(boolean includingRuntimes) { cachedCycles = null; } +<<<<<<< HEAD /** * Return the set of ReactionInstance and PortInstance that form causality loops in the topmost * parent reactor in the instantiation hierarchy. This will return an empty set if there are no @@ -268,6 +287,64 @@ public Set> getCycles() { for (var cycle : cycleNodes) { for (ReactionInstance.Runtime runtime : cycle) { reactions.add(runtime.getReaction()); +======= + /** + * The contained reactor instances, in order of declaration. + * For banks of reactors, this includes both the bank definition + * Reactor (which has bankIndex == -2) followed by each of the + * bank members (which have bankIndex >= 0). + */ + public final List children = new ArrayList<>(); + + /** The input port instances belonging to this reactor instance. */ + public final List inputs = new ArrayList<>(); + + /** The output port instances belonging to this reactor instance. */ + public final List outputs = new ArrayList<>(); + + /** The parameters of this instance. */ + public final List parameters = new ArrayList<>(); + + /** List of reaction instances for this reactor instance. */ + public final List reactions = new ArrayList<>(); + + /** The timer instances belonging to this reactor instance. */ + public final List timers = new ArrayList<>(); + + /** The mode instances belonging to this reactor instance. */ + public final List modes = new ArrayList<>(); + + /** The reactor declaration in the AST. This is either an import or Reactor declaration. */ + public final ReactorDecl reactorDeclaration; + + /** The reactor after imports are resolve. */ + public final Reactor reactorDefinition; + + /** Indicator that this reactor has itself as a parent, an error condition. */ + public final boolean recursive; + + ////////////////////////////////////////////////////// + //// Public methods. + + /** + * Assign levels to all reactions within the same root as this + * reactor. The level of a reaction r is equal to the length of the + * longest chain of reactions that must have the opportunity to + * execute before r at each logical tag. This fails and returns + * false if a causality cycle exists. + * + * This method uses a variant of Kahn's algorithm, which is linear + * in V + E, where V is the number of vertices (reactions) and E + * is the number of edges (dependencies between reactions). + * + * @return An empty graph if successful and otherwise a graph + * with runtime reaction instances that form cycles. + */ + public ReactionInstanceGraph assignLevels() { + if (depth != 0) return root().assignLevels(); + if (cachedReactionLoopGraph == null) { + cachedReactionLoopGraph = new ReactionInstanceGraph(this); +>>>>>>> origin } } // Need to figure out which ports are involved in the cycles. @@ -283,6 +360,7 @@ public Set> getCycles() { cachedCycles.addAll(ports); } +<<<<<<< HEAD return cachedCycles; } @@ -296,6 +374,107 @@ public PortInstance getInput(String name) { if (port.getName().equals(name)) { return port; } +======= + /** + * This function assigns/propagates deadlines through the Reaction Instance Graph. + * It performs Kahn`s algorithm in reverse, starting from the leaf nodes and + * propagates deadlines upstream. To reduce cost, it should only be invoked when + * there are user-specified deadlines in the program. + * @return + */ + public ReactionInstanceGraph assignDeadlines() { + if (depth != 0) return root().assignDeadlines(); + if (cachedReactionLoopGraph == null) { + cachedReactionLoopGraph = new ReactionInstanceGraph(this); + } + cachedReactionLoopGraph.rebuildAndAssignDeadlines(); + return cachedReactionLoopGraph; + } + + /** + * Return the instance of a child rector created by the specified + * definition or null if there is none. + * @param definition The definition of the child reactor ("new" statement). + */ + public ReactorInstance getChildReactorInstance(Instantiation definition) { + for (ReactorInstance child : this.children) { + if (child.definition == definition) { + return child; + } + } + return null; + } + + /** + * Clear any cached data in this reactor and its children. + * This is useful if a mutation has been realized. + */ + public void clearCaches() { + clearCaches(true); + } + + /** + * Clear any cached data in this reactor and its children. + * This is useful if a mutation has been realized. + * @param includingRuntimes If false, leave the runtime instances of reactions intact. + * This is useful for federated execution where levels are computed using + * the top-level connections, but then those connections are discarded. + */ + public void clearCaches(boolean includingRuntimes) { + if (includingRuntimes) cachedReactionLoopGraph = null; + for (ReactorInstance child : children) { + child.clearCaches(includingRuntimes); + } + for (PortInstance port : inputs) { + port.clearCaches(); + } + for (PortInstance port : outputs) { + port.clearCaches(); + } + for (ReactionInstance reaction : reactions) { + reaction.clearCaches(includingRuntimes); + } + cachedCycles = null; + } + + /** + * Return the set of ReactionInstance and PortInstance that form causality + * loops in the topmost parent reactor in the instantiation hierarchy. This will return an + * empty set if there are no causality loops. + */ + public Set> getCycles() { + if (depth != 0) return root().getCycles(); + if (cachedCycles != null) return cachedCycles; + cachedCycles = new LinkedHashSet<>(); + + ReactionInstanceGraph reactionRuntimes = assignLevels(); + if (reactionRuntimes.nodes().size() > 0) { + Set reactions = new LinkedHashSet<>(); + Set ports = new LinkedHashSet<>(); + // There are cycles. But the nodes set includes not + // just the cycles, but also nodes that are downstream of the + // cycles. Use Tarjan's algorithm to get just the cycles. + var cycleNodes = reactionRuntimes.getCycles(); + for (var cycle : cycleNodes) { + for (ReactionInstance.Runtime runtime : cycle) { + reactions.add(runtime.getReaction()); + } + } + // Need to figure out which ports are involved in the cycles. + // It may not be all ports that depend on this reaction. + for (ReactionInstance r : reactions) { + for (TriggerInstance p : r.effects) { + if (p instanceof PortInstance) { + findPaths((PortInstance)p, reactions, ports); + } + } + } + cachedCycles.addAll(reactions); + cachedCycles.addAll(ports); + } + + return cachedCycles; +>>>>>>> origin } return null; } @@ -321,6 +500,7 @@ public String uniqueID() { if (this.isMainOrFederated()) { return super.uniqueID() + "_main"; } +<<<<<<< HEAD return super.uniqueID(); } @@ -449,6 +629,14 @@ private static final class ParameterInliner extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { static final ParameterInliner INSTANCE = new ParameterInliner(); +======= + + /** + * Override the base class to append [i_d], where d is the depth, + * if this reactor is in a bank of reactors. + * @return The name of this instance. + */ +>>>>>>> origin @Override public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { @@ -483,6 +671,7 @@ public Expression visitParameterRef(ParameterReference expr, ReactorInstance ins return defaultValue; } } +<<<<<<< HEAD } /** @@ -501,6 +690,28 @@ public List instantiations() { _instantiations.addAll(parent.instantiations()); } } +======= + + /** + * Return a parameter matching the specified name if the reactor has one + * and otherwise return null. + * @param name The parameter name. + */ + public ParameterInstance getParameter(String name) { + for (ParameterInstance parameter: parameters) { + if (parameter.getName().equals(name)) { + return parameter; + } + } + return null; + } + + /** + * Return the startup trigger or null if not used in any reaction. + */ + public TriggerInstance getStartupTrigger() { + return builtinTriggers.get(BuiltinTrigger.STARTUP); +>>>>>>> origin } return _instantiations; } @@ -536,6 +747,7 @@ public boolean isParent(ReactorInstance r) { if (p == r) return true; p = p.getParent(); } +<<<<<<< HEAD return false; } @@ -738,18 +950,65 @@ protected void createReactionInstances() { for (Reaction reaction : reactions) { if (AttributeUtils.isUnordered(reaction)) { unorderedReactions.add(reaction); +======= + + /** + * If this reactor is a bank or any of its parents is a bank, + * return the total number of runtime instances, which is the product + * of the widths of all the parents. + * Return -1 if the width cannot be determined. + */ + public int getTotalWidth() { + return getTotalWidth(0); + } + + /** + * If this reactor is a bank or any of its parents is a bank, + * return the total number of runtime instances, which is the product + * of the widths of all the parents. + * Return -1 if the width cannot be determined. + * @param atDepth The depth at which to determine the width. + * Use 0 to get the total number of instances. + * Use 1 to get the number of instances within a single top-level + * bank member (this is useful for federates). + */ + public int getTotalWidth(int atDepth) { + if (width <= 0) return -1; + if (depth <= atDepth) return 1; + int result = width; + ReactorInstance p = parent; + while (p != null && p.depth > atDepth) { + if (p.width <= 0) return -1; + result *= p.width; + p = p.parent; +>>>>>>> origin } // Create the reaction instance. var reactionInstance = new ReactionInstance(reaction, this, unorderedReactions.contains(reaction), count++); +<<<<<<< HEAD // Add the reaction instance to the map of reactions for this // reactor. this.reactions.add(reactionInstance); } +======= + /** + * Return the trigger instances (input ports, timers, and actions + * that trigger reactions) belonging to this reactor instance. + */ + public Set> getTriggers() { + // FIXME: Cache this. + var triggers = new LinkedHashSet>(); + for (ReactionInstance reaction : this.reactions) { + triggers.addAll(reaction.triggers); + } + return triggers; +>>>>>>> origin } } +<<<<<<< HEAD /** Create all the watchdog instances of this reactor instance. */ protected void createWatchdogInstances() { List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); @@ -757,6 +1016,46 @@ protected void createWatchdogInstances() { for (Watchdog watchdog : watchdogs) { // Create the watchdog instance. var watchdogInstance = new WatchdogInstance(watchdog, this); +======= + /** + * Return the trigger instances (input ports, timers, and actions + * that trigger reactions) together the ports that the reaction reads + * but that don't trigger it. + * + * @return The trigger instances belonging to this reactor instance. + */ + public Set> getTriggersAndReads() { + // FIXME: Cache this. + var triggers = new LinkedHashSet>(); + for (ReactionInstance reaction : this.reactions) { + triggers.addAll(reaction.triggers); + triggers.addAll(reaction.reads); + } + return triggers; + } + + /** + * Return true if the top-level parent of this reactor has causality cycles. + */ + public boolean hasCycles() { + return assignLevels().nodeCount() != 0; + } + + /** + * Given a parameter definition for this reactor, return the initial integer + * value of the parameter. If the parameter is overridden when instantiating + * this reactor or any of its containing reactors, use that value. + * Otherwise, use the default value in the reactor definition. + * If the parameter cannot be found or its value is not an integer, return null. + * + * @param parameter The parameter definition (a syntactic object in the AST). + * + * @return An integer value or null. + */ + public Integer initialIntParameterValue(Parameter parameter) { + return ASTUtils.initialValueInt(parameter, instantiations()); + } +>>>>>>> origin // Add the watchdog instance to the list of watchdogs for this // reactor. @@ -791,6 +1090,7 @@ private ReactorInstance( this.reactorDeclaration = definition.getReactorClass(); this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); +<<<<<<< HEAD // check for recursive instantiation var currentParent = parent; var foundSelfAsParent = false; @@ -799,6 +1099,158 @@ private ReactorInstance( if (currentParent.reactorDefinition == this.reactorDefinition) { foundSelfAsParent = true; currentParent = null; // break +======= + Optional assignment = + instance.definition.getParameters().stream() + .filter(it -> it.getLhs().equals(expr.getParameter())) + .findAny(); // There is at most one + + if (assignment.isPresent()) { + // replace the parameter with its value. + Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); + // recursively resolve parameters + return instance.getParent().resolveParameters(value); + } else { + // In that case use the default value. Default values + // cannot use parameter values, so they don't need to + // be recursively resolved. + Initializer init = expr.getParameter().getInit(); + Expression defaultValue = ASTUtils.asSingleExpr(init); + if (defaultValue == null) { + // this is a problem + return super.visitParameterRef(expr, instance); + } + return defaultValue; + } + } + } + + /** + * Return a list of Instantiation objects for evaluating parameter + * values. The first object in the list is the AST Instantiation + * that created this reactor instance, the second is the AST instantiation + * that created the containing reactor instance, and so on until there + * are no more containing reactor instances. This will return an empty + * list if this reactor instance is at the top level (is main). + */ + public List instantiations() { + if (_instantiations == null) { + _instantiations = new ArrayList<>(); + if (definition != null) { + _instantiations.add(definition); + if (parent != null) { + _instantiations.addAll(parent.instantiations()); + } + } + } + return _instantiations; + } + + /** + * Returns true if this is a bank of reactors. + * @return true if a reactor is a bank, false otherwise + */ + public boolean isBank() { + return definition.getWidthSpec() != null; + } + + /** + * Returns whether this is a main or federated reactor. + * @return true if reactor definition is marked as main or federated, false otherwise. + */ + public boolean isMainOrFederated() { + return reactorDefinition != null + && (reactorDefinition.isMain() || reactorDefinition.isFederated()); + } + + /** + * Return true if the specified reactor instance is either equal to this + * reactor instance or a parent of it. + * @param r The reactor instance. + */ + public boolean isParent(ReactorInstance r) { + ReactorInstance p = this; + while (p != null) { + if (p == r) return true; + p = p.getParent(); + } + return false; + } + + /////////////////////////////////////////////////// + //// Methods for finding instances in this reactor given an AST node. + + /** + * Return the action instance within this reactor + * instance corresponding to the specified action reference. + * @param action The action as an AST node. + * @return The corresponding action instance or null if the + * action does not belong to this reactor. + */ + public ActionInstance lookupActionInstance(Action action) { + for (ActionInstance actionInstance : actions) { + if (actionInstance.definition == action) { + return actionInstance; + } + } + return null; + } + + /** + * Given a parameter definition, return the parameter instance + * corresponding to that definition, or null if there is + * no such instance. + * @param parameter The parameter definition (a syntactic object in the AST). + * @return A parameter instance, or null if there is none. + */ + public ParameterInstance lookupParameterInstance(Parameter parameter) { + for (ParameterInstance param : parameters) { + if (param.definition == parameter) { + return param; + } + } + return null; + } + + /** + * Given a port definition, return the port instance + * corresponding to that definition, or null if there is + * no such instance. + * @param port The port definition (a syntactic object in the AST). + * @return A port instance, or null if there is none. + */ + public PortInstance lookupPortInstance(Port port) { + // Search one of the inputs and outputs sets. + List ports = null; + if (port instanceof Input) { + ports = this.inputs; + } else if (port instanceof Output) { + ports = this.outputs; + } + for (PortInstance portInstance : ports) { + if (portInstance.definition == port) { + return portInstance; + } + } + return null; + } + + /** + * Given a reference to a port belonging to this reactor + * instance, return the port instance. + * Return null if there is no such instance. + * @param reference The port reference. + * @return A port instance, or null if there is none. + */ + public PortInstance lookupPortInstance(VarRef reference) { + if (!(reference.getVariable() instanceof Port)) { + // Trying to resolve something that is not a port + return null; + } + if (reference.getContainer() == null) { + // Handle local reference + return lookupPortInstance((Port) reference.getVariable()); +>>>>>>> origin } else { currentParent = currentParent.parent; } @@ -810,6 +1262,7 @@ private ReactorInstance( reporter.reportError(definition, "Recursive reactor instantiation."); } +<<<<<<< HEAD // If the reactor definition is null, give up here. Otherwise, diagram generation // will fail an NPE. if (reactorDefinition == null) { @@ -916,6 +1369,381 @@ private void establishPortConnections() { if (!srcRanges.hasNext()) { if (dstRanges.hasNext()) { reporter.reportWarning(connection, "No sources to provide inputs."); +======= + /** + * Return the reaction instance within this reactor + * instance corresponding to the specified reaction. + * @param reaction The reaction as an AST node. + * @return The corresponding reaction instance or null if the + * reaction does not belong to this reactor. + */ + public ReactionInstance lookupReactionInstance(Reaction reaction) { + for (ReactionInstance reactionInstance : reactions) { + if (reactionInstance.definition == reaction) { + return reactionInstance; + } + } + return null; + } + + /** + * Return the reactor instance within this reactor + * that has the specified instantiation. Note that this + * may be a bank of reactors. Return null if there + * is no such reactor instance. + */ + public ReactorInstance lookupReactorInstance(Instantiation instantiation) { + for (ReactorInstance reactorInstance : children) { + if (reactorInstance.definition == instantiation) { + return reactorInstance; + } + } + return null; + } + + /** + * Return the timer instance within this reactor + * instance corresponding to the specified timer reference. + * @param timer The timer as an AST node. + * @return The corresponding timer instance or null if the + * timer does not belong to this reactor. + */ + public TimerInstance lookupTimerInstance(Timer timer) { + for (TimerInstance timerInstance : timers) { + if (timerInstance.definition == timer) { + return timerInstance; + } + } + return null; + } + + /** Returns the mode instance within this reactor + * instance corresponding to the specified mode reference. + * @param mode The mode as an AST node. + * @return The corresponding mode instance or null if the + * mode does not belong to this reactor. + */ + public ModeInstance lookupModeInstance(Mode mode) { + for (ModeInstance modeInstance : modes) { + if (modeInstance.definition == mode) { + return modeInstance; + } + } + return null; + } + + /** + * Return a descriptive string. + */ + @Override + public String toString() { + return "ReactorInstance " + getFullName(); + } + + /** + * Assuming that the given expression denotes a valid time, return a time value. + * + * If the value is given as a parameter reference, this will look up the + * precise time value assigned to this reactor instance. + */ + public TimeValue getTimeValue(Expression expr) { + Expression resolved = resolveParameters(expr); + return getLiteralTimeValue(resolved); + } + + ////////////////////////////////////////////////////// + //// Protected fields. + + /** The generator that created this reactor instance. */ + protected ErrorReporter reporter; // FIXME: This accumulates a lot of redundant references + + /** The map of used built-in triggers. */ + protected Map> builtinTriggers = new HashMap<>(); + + /** + * The LF syntax does not currently support declaring reactions unordered, + * but unordered reactions are created in the AST transformations handling + * federated communication and after delays. Unordered reactions can execute + * in any order and concurrently even though they are in the same reactor. + * FIXME: Remove this when the language provides syntax. + */ + protected Set unorderedReactions = new LinkedHashSet<>(); + + /** The nested list of instantiations that created this reactor instance. */ + protected List _instantiations; + + ////////////////////////////////////////////////////// + //// Protected methods. + + /** + * Create all the reaction instances of this reactor instance + * and record the dependencies and antidependencies + * between ports, actions, and timers and reactions. + * This also records the dependencies between reactions + * that follows from the order in which they are defined. + */ + protected void createReactionInstances() { + List reactions = ASTUtils.allReactions(reactorDefinition); + if (reactions != null) { + int count = 0; + + // Check for startup and shutdown triggers. + for (Reaction reaction : reactions) { + if (AttributeUtils.isUnordered(reaction)) { + unorderedReactions.add(reaction); + } + // Create the reaction instance. + var reactionInstance = new ReactionInstance(reaction, this, + unorderedReactions.contains(reaction), count++); + + // Add the reaction instance to the map of reactions for this + // reactor. + this.reactions.add(reactionInstance); + } + } + } + + /** + * Returns the built-in trigger or create a new one if none exists. + */ + protected TriggerInstance getOrCreateBuiltinTrigger(BuiltinTriggerRef trigger) { + return builtinTriggers.computeIfAbsent(trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); + } + + //////////////////////////////////////// + //// Private constructors + + /** + * Create a runtime instance from the specified definition + * and with the specified parent that instantiated it. + * @param definition The instantiation statement in the AST. + * @param parent The parent, or null for the main rector. + * @param reporter An error reporter. + * @param desiredDepth The depth to which to expand the hierarchy. + */ + private ReactorInstance( + Instantiation definition, + ReactorInstance parent, + ErrorReporter reporter, + int desiredDepth) { + super(definition, parent); + this.reporter = reporter; + this.reactorDeclaration = definition.getReactorClass(); + this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); + + // check for recursive instantiation + var currentParent = parent; + var foundSelfAsParent = false; + do { + if (currentParent != null) { + if (currentParent.reactorDefinition == this.reactorDefinition) { + foundSelfAsParent = true; + currentParent = null; // break + } else { + currentParent = currentParent.parent; + } + } + } while(currentParent != null); + + this.recursive = foundSelfAsParent; + if (recursive) { + reporter.reportError(definition, "Recursive reactor instantiation."); + } + + // If the reactor definition is null, give up here. Otherwise, diagram generation + // will fail an NPE. + if (reactorDefinition == null) { + reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); + return; + } + + setInitialWidth(); + + // Apply overrides and instantiate parameters for this reactor instance. + for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { + this.parameters.add(new ParameterInstance(parameter, this)); + } + + // Instantiate inputs for this reactor instance + for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { + this.inputs.add(new PortInstance(inputDecl, this, reporter)); + } + + // Instantiate outputs for this reactor instance + for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { + this.outputs.add(new PortInstance(outputDecl, this, reporter)); + } + + // Do not process content (except interface above) if recursive + if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { + // Instantiate children for this reactor instance. + // While doing this, assign an index offset to each. + for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { + var childInstance = new ReactorInstance( + child, + this, + reporter, + desiredDepth + ); + this.children.add(childInstance); + } + + // Instantiate timers for this reactor instance + for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { + this.timers.add(new TimerInstance(timerDecl, this)); + } + + // Instantiate actions for this reactor instance + for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { + this.actions.add(new ActionInstance(actionDecl, this)); + } + + establishPortConnections(); + + // Create the reaction instances in this reactor instance. + // This also establishes all the implied dependencies. + // Note that this can only happen _after_ the children, + // port, action, and timer instances have been created. + createReactionInstances(); + + // Instantiate modes for this reactor instance + // This must come after the child elements (reactions, etc) of this reactor + // are created in order to allow their association with modes + for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { + this.modes.add(new ModeInstance(modeDecl, this)); + } + for (ModeInstance mode : this.modes) { + mode.setupTranstions(); + } + } + } + + ////////////////////////////////////////////////////// + //// Private methods. + + /** + * Connect the given left port range to the given right port range. + * + * NOTE: This method is public to enable its use in unit tests. + * Otherwise, it should be private. This is why it is defined here, + * in the section labeled "Private methods." + * + * @param src The source range. + * @param dst The destination range. + * @param connection The connection establishing this relationship. + */ + public static void connectPortInstances( + RuntimeRange src, + RuntimeRange dst, + Connection connection + ) { + SendRange range = new SendRange(src, dst, src._interleaved, connection); + src.instance.dependentPorts.add(range); + dst.instance.dependsOnPorts.add(src); + } + + /** + * Populate connectivity information in the port instances. + * Note that this can only happen _after_ the children and port instances have been created. + * Unfortunately, we have to do some complicated things here + * to support multiport-to-multiport, multiport-to-bank, + * and bank-to-multiport communication. The principle being followed is: + * in each connection statement, for each port instance on the left, + * connect to the next available port on the right. + */ + private void establishPortConnections() { + for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { + List> leftPorts = listPortInstances(connection.getLeftPorts(), connection); + Iterator> srcRanges = leftPorts.iterator(); + List> rightPorts = listPortInstances(connection.getRightPorts(), connection); + Iterator> dstRanges = rightPorts.iterator(); + + // Check for empty lists. + if (!srcRanges.hasNext()) { + if (dstRanges.hasNext()) { + reporter.reportWarning(connection, "No sources to provide inputs."); + } + return; + } else if (!dstRanges.hasNext()) { + reporter.reportWarning(connection, "No destination. Outputs will be lost."); + return; + } + + RuntimeRange src = srcRanges.next(); + RuntimeRange dst = dstRanges.next(); + + while(true) { + if (dst.width == src.width) { + connectPortInstances(src, dst, connection); + if (!dstRanges.hasNext()) { + if (srcRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning(connection, + "Source is wider than the destination. Outputs will be lost."); + } + break; + } + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + if (dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning(connection, + "Destination is wider than the source. Inputs will be missing."); + } + break; + } + } + dst = dstRanges.next(); + src = srcRanges.next(); + } else if (dst.width < src.width) { + // Split the left (src) range in two. + connectPortInstances(src.head(dst.width), dst, connection); + src = src.tail(dst.width); + if (!dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning(connection, + "Source is wider than the destination. Outputs will be lost."); + break; + } + dst = dstRanges.next(); + } else if (src.width < dst.width) { + // Split the right (dst) range in two. + connectPortInstances(src, dst.head(src.width), connection); + dst = dst.tail(src.width); + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + reporter.reportWarning(connection, + "Destination is wider than the source. Inputs will be missing."); + break; + } + } + src = srcRanges.next(); + } + } + } + } + + /** + * If path exists from the specified port to any reaction in the specified + * set of reactions, then add the specified port and all ports along the path + * to the specified set of ports. + * @return True if the specified port was added. + */ + private boolean findPaths( + PortInstance port, + Set reactions, + Set ports + ) { + if (ports.contains(port)) return false; + boolean result = false; + for (ReactionInstance d : port.getDependentReactions()) { + if (reactions.contains(d)) ports.add(port); + result = true; +>>>>>>> origin } return; } else if (!dstRanges.hasNext()) { @@ -1035,6 +1863,7 @@ private List> listPortInstances( if (!(portRef.getVariable() instanceof Port)) { reporter.reportError(portRef, "Not a port."); return result; +<<<<<<< HEAD } // First, figure out which reactor we are dealing with. // The reactor we want is the container of the port. @@ -1047,6 +1876,118 @@ private List> listPortInstances( // Skip this portRef so that diagram synthesis can complete. if (reactor != null) { PortInstance portInstance = reactor.lookupPortInstance((Port) portRef.getVariable()); +======= + } + + /** + * Given a list of port references, as found on either side of a connection, + * return a list of the port instance ranges referenced. These may be multiports, + * and may be ports of a contained bank (a port representing ports of the bank + * members) so the returned list includes ranges of banks and channels. + * + * If a given port reference has the form `interleaved(b.m)`, where `b` is + * a bank and `m` is a multiport, then the corresponding range in the returned + * list is marked interleaved. + * + * For example, if `b` and `m` have width 2, without the interleaved keyword, + * the returned range represents the sequence `[b0.m0, b0.m1, b1.m0, b1.m1]`. + * With the interleaved marking, the returned range represents the sequence + * `[b0.m0, b1.m0, b0.m1, b1.m1]`. Both ranges will have width 4. + * + * @param references The variable references on one side of the connection. + * @param connection The connection. + */ + private List> listPortInstances( + List references, Connection connection + ) { + List> result = new ArrayList<>(); + List> tails = new LinkedList<>(); + int count = 0; + for (VarRef portRef : references) { + // Simple error checking first. + if (!(portRef.getVariable() instanceof Port)) { + reporter.reportError(portRef, "Not a port."); + return result; + } + // First, figure out which reactor we are dealing with. + // The reactor we want is the container of the port. + // If the port reference has no container, then the reactor is this one. + var reactor = this; + if (portRef.getContainer() != null) { + reactor = getChildReactorInstance(portRef.getContainer()); + } + // The reactor can be null only if there is an error in the code. + // Skip this portRef so that diagram synthesis can complete. + if (reactor != null) { + PortInstance portInstance = reactor.lookupPortInstance( + (Port) portRef.getVariable()); + + Set interleaved = new LinkedHashSet<>(); + if (portRef.isInterleaved()) { + // NOTE: Here, we are assuming that the interleaved() + // keyword is only allowed on the multiports contained by + // contained reactors. + interleaved.add(portInstance.parent); + } + RuntimeRange range = new RuntimeRange.Port( + portInstance, interleaved); + // If this portRef is not the last one in the references list + // then we have to check whether the range can be incremented at + // the lowest two levels (port and container). If not, + // split the range and add the tail to list to iterate over again. + // The reason for this is that the connection has only local visibility, + // but the range width may be reflective of bank structure higher + // in the hierarchy. + if (count < references.size() - 1) { + int portWidth = portInstance.width; + int portParentWidth = portInstance.parent.width; + // If the port is being connected on the inside and there is + // more than one port in the list, then we can only connect one + // bank member at a time. + if (reactor == this && references.size() > 1) { + portParentWidth = 1; + } + int widthBound = portWidth * portParentWidth; + + // If either of these widths cannot be determined, assume infinite. + if (portWidth < 0) widthBound = Integer.MAX_VALUE; + if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < range.width) { + // Need to split the range. + tails.add(range.tail(widthBound)); + range = range.head(widthBound); + } + } + result.add(range); + } + } + // Iterate over the tails. + while(tails.size() > 0) { + List> moreTails = new LinkedList<>(); + count = 0; + for (RuntimeRange tail : tails) { + if (count < tails.size() - 1) { + int widthBound = tail.instance.width; + if (tail._interleaved.contains(tail.instance.parent)) { + widthBound = tail.instance.parent.width; + } + // If the width cannot be determined, assume infinite. + if (widthBound < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < tail.width) { + // Need to split the range again + moreTails.add(tail.tail(widthBound)); + tail = tail.head(widthBound); + } + } + result.add(tail); + } + tails = moreTails; + } + return result; + } +>>>>>>> origin Set interleaved = new LinkedHashSet<>(); if (portRef.isInterleaved()) { @@ -1055,6 +1996,7 @@ private List> listPortInstances( // contained reactors. interleaved.add(portInstance.parent); } +<<<<<<< HEAD RuntimeRange range = new RuntimeRange.Port(portInstance, interleaved); // If this portRef is not the last one in the references list // then we have to check whether the range can be incremented at @@ -1073,16 +2015,40 @@ private List> listPortInstances( portParentWidth = 1; } int widthBound = portWidth * portParentWidth; +======= + } + + ////////////////////////////////////////////////////// + //// Private fields. +>>>>>>> origin // If either of these widths cannot be determined, assume infinite. if (portWidth < 0) widthBound = Integer.MAX_VALUE; if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; +<<<<<<< HEAD if (widthBound < range.width) { // Need to split the range. tails.add(range.tail(widthBound)); range = range.head(widthBound); } +======= + /** + * Cached reaction graph containing reactions that form a causality loop. + */ + private ReactionInstanceGraph cachedReactionLoopGraph = null; + + /** + * Return true if this is a generated delay reactor that originates from + * an "after" delay on a connection. + * + * @return True if this is a generated delay, false otherwise. + */ + public boolean isGeneratedDelay() { + // FIXME: hacky string matching again... + if (this.definition.getReactorClass().getName().contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME)) { + return true; +>>>>>>> origin } result.add(range); } diff --git a/org.lflang/src/org/lflang/generator/Validator.java b/org.lflang/src/org/lflang/generator/Validator.java index bc11061f0d..7a9b85c453 100644 --- a/org.lflang/src/org/lflang/generator/Validator.java +++ b/org.lflang/src/org/lflang/generator/Validator.java @@ -161,7 +161,7 @@ private List> getValidationStrategies() { */ private Pair getValidationStrategy(Path generatedFile) { List sorted = getPossibleStrategies().stream() - .sorted(Comparator.comparingInt(vs -> -vs.getPriority())).collect(Collectors.toList()); + .sorted(Comparator.comparingInt(vs -> -vs.getPriority())).toList(); for (ValidationStrategy strategy : sorted) { LFCommand validateCommand = strategy.getCommand(generatedFile); if (validateCommand != null) { diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index 1c4a1b45e8..af41440641 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -97,13 +97,12 @@ public static String generateTokenInitializer( */ public static void generateDeclarations( Reactor reactor, - ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode ) { for (Action action : ASTUtils.allActions(reactor)) { var actionName = action.getName(); - body.pr(action, CGenerator.variableStructType(action, decl)+" _lf_"+actionName+";"); + body.pr(action, CGenerator.variableStructType(action, reactor, false)+" _lf_"+actionName+";"); // Initialize the trigger pointer in the action. constructorCode.pr(action, "self->_lf_"+actionName+".trigger = &self->_lf__"+actionName+";"); } @@ -121,11 +120,12 @@ public static void generateDeclarations( * @return The auxiliary struct for the port as a string */ public static String generateAuxiliaryStruct( - ReactorDecl decl, + Reactor r, Action action, Target target, CTypes types, - CodeBuilder federatedExtension + CodeBuilder federatedExtension, + boolean userFacing ) { var code = new CodeBuilder(); code.pr("typedef struct {"); @@ -145,7 +145,7 @@ public static String generateAuxiliaryStruct( code.pr(valueDeclaration(action, target, types)); code.pr(federatedExtension.toString()); code.unindent(); - code.pr("} " + variableStructType(action, decl) + ";"); + code.pr("} " + variableStructType(action, r, userFacing) + ";"); return code.toString(); } diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 6710a0eb68..3f5eb4a5b7 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -212,6 +212,7 @@ CodeBuilder generateCMakeCode( cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE core)"); + cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC .)"); cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/)"); cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/api)"); cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core)"); diff --git a/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java b/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java index 0cc2199cae..8944fd0796 100644 --- a/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java @@ -1,8 +1,7 @@ package org.lflang.generator.c; -import org.lflang.federated.generator.FederateInstance; import org.lflang.generator.CodeBuilder; -import org.lflang.lf.ReactorDecl; +import org.lflang.lf.Reactor; /** * Generates C constructor code for a reactor. @@ -16,12 +15,12 @@ public class CConstructorGenerator { * go into the constructor. */ public static String generateConstructor( - ReactorDecl reactor, + Reactor reactor, String constructorCode ) { var structType = CUtil.selfType(reactor); var code = new CodeBuilder(); - code.pr(structType+"* new_"+reactor.getName()+"() {"); + code.pr(structType+"* new_"+CUtil.getName(reactor)+"() {"); code.indent(); code.pr(structType+"* self = ("+structType+"*)_lf_new_reactor(sizeof("+structType+"));"); code.pr(constructorCode); @@ -30,4 +29,8 @@ public static String generateConstructor( code.pr("}"); return code.toString(); } + + public static String generateConstructorPrototype(Reactor reactor) { + return CUtil.selfType(reactor)+"* new_"+CUtil.getName(reactor)+"();"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CFileConfig.java b/org.lflang/src/org/lflang/generator/c/CFileConfig.java index 8bd70b74c3..362b8645b5 100644 --- a/org.lflang/src/org/lflang/generator/c/CFileConfig.java +++ b/org.lflang/src/org/lflang/generator/c/CFileConfig.java @@ -8,12 +8,18 @@ import org.lflang.FileConfig; public class CFileConfig extends FileConfig { + private final Path includePath; public CFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) throws IOException { super(resource, srcGenBasePath, useHierarchicalBin); + var includeDir = getOutPath().resolve("include"); + includePath = !useHierarchicalBin ? includeDir : includeDir.resolve(getOutPath().relativize(srcPath)).resolve(srcFile.getFileName().toString().split("\\.")[0]); } -} - - - + public Path getIncludePath() { + return includePath; + } + public String getRuntimeIncludePath() { + return "/lib/c/reactor-c/include"; + } +} diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 0ded0e2bc2..2ed77b27e1 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -25,8 +25,7 @@ package org.lflang.generator.c; import static org.lflang.ASTUtils.allActions; -import static org.lflang.ASTUtils.allInputs; -import static org.lflang.ASTUtils.allOutputs; +import static org.lflang.ASTUtils.allPorts; import static org.lflang.ASTUtils.allReactions; import static org.lflang.ASTUtils.allStateVars; import static org.lflang.ASTUtils.convertToEmptyListIfNull; @@ -36,12 +35,16 @@ import static org.lflang.ASTUtils.toText; import static org.lflang.util.StringUtil.addDoubleQuotes; +<<<<<<< HEAD import com.google.common.base.Objects; import com.google.common.collect.Iterables; +======= +>>>>>>> origin import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; +import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.regex.Pattern; @@ -83,7 +86,6 @@ import org.lflang.lf.Instantiation; import org.lflang.lf.Mode; import org.lflang.lf.Model; -import org.lflang.lf.Output; import org.lflang.lf.Port; import org.lflang.lf.Preamble; import org.lflang.lf.Reaction; @@ -94,6 +96,12 @@ import org.lflang.lf.Watchdog; import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; +<<<<<<< HEAD +======= + +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; +>>>>>>> origin /** * Generator for C target. This class generates C code defining each reactor class given in the @@ -584,6 +592,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { // ); // FIXME: Move to FedGenerator // Create the compiler to be used later +<<<<<<< HEAD var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); try { if (!cCompiler.runCCompiler(generator, context)) { @@ -592,6 +601,167 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { // If finish has already been called, it is illegal and makes no sense. However, // if finish has already been called, then this must be a federated execution. context.unsuccessfulFinish(); +======= + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); + handleProtoFiles(); + + // Derive target filename from the .lf filename. + var lfModuleName = fileConfig.name; + var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); + var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; + try { + generateCodeFor(lfModuleName); + copyTargetFiles(); + generateHeaders(); + code.writeToFile(targetFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + + // Create docker file. + if (targetConfig.dockerOptions != null && mainDef != null) { + try { + var dockerData = getDockerGenerator(context).generateDockerData(); + dockerData.writeDockerFile(); + (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); + } catch (IOException e) { + throw new RuntimeException("Error while writing Docker files", e); + } + } + + // If cmake is requested, generate the CMakeLists.txt + if (targetConfig.platformOptions.platform != Platform.ARDUINO) { + var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; + var sources = new HashSet<>(ASTUtils.recursiveChildren(main)).stream() + .map(CUtil::getName).map(it -> it + (CCppMode ? ".cpp" : ".c")) + .collect(Collectors.toList()); + sources.add(cFilename); + var cmakeCode = cmakeGenerator.generateCMakeCode( + sources, + lfModuleName, + errorReporter, + CCppMode, + mainDef != null, + cMakeExtras, + targetConfig + ); + try { + cmakeCode.writeToFile(cmakeFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + } else { + try { + Path include = fileConfig.getSrcGenPath().resolve("include/"); + Path src = fileConfig.getSrcGenPath().resolve("src/"); + FileUtil.arduinoDeleteHelper(src, targetConfig.threading); + FileUtil.relativeIncludeHelper(src, include); + FileUtil.relativeIncludeHelper(include, include); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + + if (!targetConfig.noCompile) { + ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); + arduinoUtil.buildArduino(fileConfig, targetConfig); + context.finish( + GeneratorResult.Status.COMPILED, null + ); + } else { + System.out.println("********"); + System.out.println("To compile your program, run the following command to see information about the board you plugged in:\n\n\tarduino-cli board list\n\nGrab the FQBN and PORT from the command and run the following command in the generated sources directory:\n\n\tarduino-cli compile -b --build-property compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\nTo flash/upload your generated sketch to the board, run the following command in the generated sources directory:\n\n\tarduino-cli upload -b -p \n"); + // System.out.println("For a list of all boards installed on your computer, you can use the following command:\n\n\tarduino-cli board listall\n"); + context.finish( + GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null) + ); + } + GeneratorUtils.refreshProject(resource, context.getMode()); + return; + } + + // Dump the additional compile definitions to a file to keep the generated project + // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can + // take over and do the rest of compilation. + try { + String compileDefs = targetConfig.compileDefinitions.keySet().stream() + .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) + .collect(Collectors.joining("\n")); + FileUtil.writeToFile( + compileDefs, + Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt") + ); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } + + // If this code generator is directly compiling the code, compile it now so that we + // clean it up after, removing the #line directives after errors have been reported. + if ( + !targetConfig.noCompile && targetConfig.dockerOptions == null + && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) + // This code is unreachable in LSP_FAST mode, so that check is omitted. + && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM + ) { + // FIXME: Currently, a lack of main is treated as a request to not produce + // a binary and produce a .o file instead. There should be a way to control + // this. + // Create an anonymous Runnable class and add it to the compileThreadPool + // so that compilation can happen in parallel. + var cleanCode = code.removeLines("#line"); + + var execName = lfModuleName; + var threadFileConfig = fileConfig; + var generator = this; // FIXME: currently only passed to report errors with line numbers in the Eclipse IDE + var CppMode = CCppMode; + // generatingContext.reportProgress( + // String.format("Generated code for %d/%d executables. Compiling...", federateCount, federates.size()), + // 100 * federateCount / federates.size() + // ); // FIXME: Move to FedGenerator + // Create the compiler to be used later + + var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); + try { + if (!cCompiler.runCCompiler(generator, context)) { + // If compilation failed, remove any bin files that may have been created. + CUtil.deleteBinFiles(threadFileConfig); + // If finish has already been called, it is illegal and makes no sense. However, + // if finish has already been called, then this must be a federated execution. + context.unsuccessfulFinish(); + } else { + context.finish( + GeneratorResult.Status.COMPILED, null + ); + } + cleanCode.writeToFile(targetFile); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } + + } + + // If a build directive has been given, invoke it now. + // Note that the code does not get cleaned in this case. + if (!targetConfig.noCompile) { + if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { + CUtil.runBuildCommand( + fileConfig, + targetConfig, + commandFactory, + errorReporter, + this::reportCommandErrors, + context.getMode() + ); + context.finish( + GeneratorResult.Status.COMPILED, null + ); + } + System.out.println("Compiled binary is in " + fileConfig.binPath); +>>>>>>> origin } else { context.finish(GeneratorResult.Status.COMPILED, null); } @@ -601,6 +771,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { } } +<<<<<<< HEAD // If a build directive has been given, invoke it now. // Note that the code does not get cleaned in this case. if (!targetConfig.noCompile) { @@ -618,6 +789,16 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { } else { context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); } +======= + private void generateCodeFor( + String lfModuleName + ) throws IOException { + startTimeStepIsPresentCount = 0; + code.pr(generateDirectives()); + code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); + // Generate code for each reactor. + generateReactorDefinitions(); +>>>>>>> origin // In case we are in Eclipse, make sure the generated code is visible. GeneratorUtils.refreshProject(resource, context.getMode()); @@ -631,6 +812,7 @@ private void generateCodeFor(String lfModuleName) { // Generate code for each reactor. generateReactorDefinitions(); +<<<<<<< HEAD // Generate main instance, if there is one. // Note that any main reactors in imported files are ignored. // Skip generation if there are cycles. @@ -653,6 +835,16 @@ private void generateCodeFor(String lfModuleName) { // Add counters for modal initialization initializeTriggerObjects.pr( CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); +======= + if (targetConfig.fedSetupPreamble != null) { + if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); + code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); + if (targetLanguageIsCpp()) code.pr("}"); + } + + // If there are timers, create a table of timers to be initialized. + code.pr(CTimerGenerator.generateDeclarations(timerCount)); +>>>>>>> origin // Create an array of arrays to store all self structs. // This is needed because connections cannot be established until @@ -897,6 +1089,7 @@ private void generateReactorDefinitions() { generateReactorClass(this.mainDef.getReactorClass()); } +<<<<<<< HEAD if (mainDef == null) { // Generate code for each reactor that was not instantiated in main or its children. for (Reactor r : reactors) { @@ -908,6 +1101,33 @@ private void generateReactorDefinitions() { // so that reaction bodies are checked). if (declarations.isEmpty()) { generateReactorClass(r); +======= + /** + * Look at the 'reactor' eResource. + * If it is an imported .lf file, incorporate it into the current + * program in the following manner: + * - Merge its target property with `targetConfig` + * - If there are any preambles, add them to the preambles of the reactor. + */ + private void inspectReactorEResource(ReactorDecl reactor) { + // If the reactor is imported, look at the + // target definition of the .lf file in which the reactor is imported from and + // append any cmake-include. + // Check if the reactor definition is imported + if (reactor.eResource() != mainDef.getReactorClass().eResource()) { + // Find the LFResource corresponding to this eResource + LFResource lfResource = null; + for (var resource : resources) { + if (resource.getEResource() == reactor.eResource()) { + lfResource = resource; + break; + } + } + // Copy the user files and cmake-includes to the src-gen path of the main .lf file + if (lfResource != null) { + copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); + } +>>>>>>> origin } } } @@ -1029,6 +1249,7 @@ protected void generateUserPreamblesForReactor(Reactor reactor) { } } +<<<<<<< HEAD /** * Generate a constructor for the specified reactor in the specified federate. * @@ -1056,12 +1277,290 @@ protected void generateAuxiliaryStructs(ReactorDecl decl) { var federatedExtension = new CodeBuilder(); federatedExtension.pr( """ +======= + /** + * Generate code for defining all reactors that belong to the federate, + * including all the child reactors down the hierarchy. Duplicate + * Duplicates are avoided. + * + * Imported reactors' original .lf file is + * incorporated in the following manner: + * - If there are any cmake-include files, add them to the current list + * of cmake-include files. + * - If there are any preambles, add them to the preambles of the reactor. + */ + private void generateReactorDefinitions() throws IOException { + var generatedReactors = new LinkedHashSet(); + if (this.main != null) { + generateReactorChildren(this.main, generatedReactors); + } + + if (this.mainDef != null) { + generateReactorClass(ASTUtils.toDefinition(this.mainDef.getReactorClass())); + } + + if (mainDef == null) { + // Generate code for each reactor that was not instantiated in main or its children. + for (Reactor r : reactors) { + // Get the declarations for reactors that are instantiated somewhere. + // A declaration is either a reactor definition or an import statement.; + var declarations = this.instantiationGraph.getDeclarations(r); + // If the reactor has no instantiations and there is no main reactor, then + // generate code for it anyway (at a minimum, this means that the compiler is invoked + // so that reaction bodies are checked). + if (declarations.isEmpty()) { + generateReactorClass(r); + } + } + } + } + + /** Generate user-visible header files for all reactors instantiated. */ + private void generateHeaders() throws IOException { + FileUtil.deleteDirectory(fileConfig.getIncludePath()); + FileUtil.copyDirectoryFromClassPath( + fileConfig.getRuntimeIncludePath(), + fileConfig.getIncludePath(), + false + ); + for (Reactor r : reactors) { + CReactorHeaderFileGenerator.doGenerate( + types, r, fileConfig, + (builder, rr, userFacing) -> { + generateAuxiliaryStructs(builder, rr, userFacing); + if (userFacing) { + ASTUtils.allInstantiations(r).stream().map(Instantiation::getReactorClass).collect(Collectors.toSet()).forEach(it -> { + ASTUtils.allPorts(ASTUtils.toDefinition(it)) + .forEach(p -> builder.pr(CPortGenerator.generateAuxiliaryStruct( + ASTUtils.toDefinition(it), p, getTarget(), errorReporter, types, new CodeBuilder(), true, it + ))); + }); + } + }, + this::generateTopLevelPreambles); + } + FileUtil.copyDirectory(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + } + + /** + * Generate code for the children of 'reactor' that belong to 'federate'. + * Duplicates are avoided. + * + * Imported reactors' original .lf file is + * incorporated in the following manner: + * - If there are any cmake-include files, add them to the current list + * of cmake-include files. + * - If there are any preambles, add them to the preambles of the reactor. + * + * @param reactor Used to extract children from + */ + private void generateReactorChildren( + ReactorInstance reactor, + LinkedHashSet generatedReactors + ) throws IOException { + for (ReactorInstance r : reactor.children) { + if (r.reactorDeclaration != null && + !generatedReactors.contains(r.reactorDefinition)) { + generatedReactors.add(r.reactorDefinition); + generateReactorChildren(r, generatedReactors); + inspectReactorEResource(r.reactorDeclaration); + generateReactorClass(r.reactorDefinition); + } + } + } + + /** + * Choose which platform files to compile with according to the OS. + * If there is no main reactor, then compilation will produce a .o file requiring further linking. + * Also, if useCmake is set to true, we don't need to add platform files. The CMakeLists.txt file + * will detect and use the appropriate platform file based on the platform that cmake is invoked on. + */ + private void pickCompilePlatform() { + var osName = System.getProperty("os.name").toLowerCase(); + // if platform target was set, use given platform instead + if (targetConfig.platformOptions.platform != Platform.AUTO) { + osName = targetConfig.platformOptions.platform.toString(); + } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { + errorReporter.reportError("Platform " + osName + " is not supported"); + } + } + + + /** + * Copy target-specific header file to the src-gen directory. + */ + protected void copyTargetFiles() throws IOException { + // Copy the core lib + String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); + Path dest = fileConfig.getSrcGenPath(); + if (targetConfig.platformOptions.platform == Platform.ARDUINO) dest = dest.resolve("src"); + if (coreLib != null) { + FileUtil.copyDirectory(Path.of(coreLib), dest, true); + } else { + FileUtil.copyDirectoryFromClassPath( + "/lib/c/reactor-c/core", + dest.resolve("core"), + true + ); + FileUtil.copyDirectoryFromClassPath( + "/lib/c/reactor-c/lib", + dest.resolve("lib"), + true + ); + } + + // For the Zephyr target, copy default config and board files. + if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + FileUtil.copyDirectoryFromClassPath( + "/lib/platform/zephyr/boards", + fileConfig.getSrcGenPath().resolve("boards"), + false + ); + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/prj_lf.conf", + fileConfig.getSrcGenPath().resolve("prj_lf.conf"), + true + ); + + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/Kconfig", + fileConfig.getSrcGenPath().resolve("Kconfig"), + true + ); + } + } + + //////////////////////////////////////////// + //// Code generators. + /** + * Generate a reactor class definition for the specified federate. + * A class definition has four parts: + * + * * Preamble code, if any, specified in the Lingua Franca file. + * * A "self" struct type definition (see the class documentation above). + * * A function for each reaction. + * * A constructor for creating an instance. + * for deleting an instance. + * + * If the reactor is the main reactor, then + * the generated code may be customized. Specifically, + * if the main reactor has reactions, these reactions + * will not be generated if they are triggered by or send + * data to contained reactors that are not in the federate. + * @param reactor The parsed reactor data structure. + */ + private void generateReactorClass(Reactor reactor) throws IOException { + // FIXME: Currently we're not reusing definitions for declarations that point to the same definition. + CodeBuilder header = new CodeBuilder(); + CodeBuilder src = new CodeBuilder(); + final String headerName = CUtil.getName(reactor) + ".h"; + var guardMacro = headerName.toUpperCase().replace(".", "_"); + header.pr("#ifndef " + guardMacro); + header.pr("#define " + guardMacro); + generateReactorClassHeaders(reactor, headerName, header, src); + header.pr(generateTopLevelPreambles(reactor)); + generateUserPreamblesForReactor(reactor, src); + generateReactorClassBody(reactor, header, src); + header.pr("#endif // " + guardMacro); + FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); + var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" : + CCppMode ? ".cpp" : ".c"; + FileUtil.writeToFile(src.toString(), fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), true); + } + + protected void generateReactorClassHeaders(Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { + if (CCppMode) { + src.pr("extern \"C\" {"); + header.pr("extern \"C\" {"); + } + header.pr("#include \"include/core/reactor.h\""); + src.pr("#include \"include/api/api.h\""); + src.pr("#include \"include/api/set.h\""); + generateIncludes(reactor); + if (CCppMode) { + src.pr("}"); + header.pr("}"); + } + src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(reactor) + "\""); + src.pr("#include \"" + headerName + "\""); + ASTUtils.allNestedClasses(reactor).map(CUtil::getName) + .map(name -> "#include \"" + name + ".h\"") + .forEach(header::pr); + } + + private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeBuilder src) { + // Some of the following methods create lines of code that need to + // go into the constructor. Collect those lines of code here: + var constructorCode = new CodeBuilder(); + generateAuxiliaryStructs(header, reactor, false); + generateSelfStruct(header, reactor, constructorCode); + generateMethods(src, reactor); + generateReactions(src, reactor); + generateConstructor(src, header, reactor, constructorCode); + } + + /** + * Generate methods for {@code reactor}. + */ + protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { + CMethodGenerator.generateMethods(reactor, src, types); + } + + /** + * Generates preambles defined by user for a given reactor + * @param reactor The given reactor + */ + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + for (Preamble p : convertToEmptyListIfNull(reactor.getPreambles())) { + src.pr("// *********** From the preamble, verbatim:"); + src.prSourceLineNumber(p.getCode()); + src.pr(toText(p.getCode())); + src.pr("\n// *********** End of preamble."); + } + } + + /** + * Generate a constructor for the specified reactor in the specified federate. + * @param reactor The parsed reactor data structure. + * @param constructorCode Lines of code previously generated that need to + * go into the constructor. + */ + protected void generateConstructor( + CodeBuilder src, CodeBuilder header, Reactor reactor, CodeBuilder constructorCode + ) { + header.pr(CConstructorGenerator.generateConstructorPrototype(reactor)); + src.pr(CConstructorGenerator.generateConstructor( + reactor, + constructorCode.toString() + )); + } + + protected void generateIncludes(Reactor r) { + code.pr("#include \"" + CUtil.getName(r) + ".h\""); + } + + /** + * Generate the struct type definitions for inputs, outputs, and + * actions of the specified reactor. + */ + protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { + // In the case where there are incoming + // p2p logical connections in decentralized + // federated execution, there will be an + // intended_tag field added to accommodate + // the case where a reaction triggered by a + // port or action is late due to network + // latency, etc.. + var federatedExtension = new CodeBuilder(); + federatedExtension.pr(""" +>>>>>>> origin #ifdef FEDERATED #ifdef FEDERATED_DECENTRALIZED %s intended_tag; #endif %s physical_time_of_arrival; #endif +<<<<<<< HEAD """ .formatted(types.getTargetTagType(), types.getTargetTimeType())); // First, handle inputs. @@ -1075,6 +1574,96 @@ protected void generateAuxiliaryStructs(ReactorDecl decl) { code.pr( CPortGenerator.generateAuxiliaryStruct( decl, output, getTarget(), errorReporter, types, federatedExtension)); +======= + """.formatted(types.getTargetTagType(), types.getTargetTimeType()) + ); + for (Port p : allPorts(r)) { + builder.pr(CPortGenerator.generateAuxiliaryStruct( + r, + p, + getTarget(), + errorReporter, + types, + federatedExtension, + userFacing, + null + )); + } + // The very first item on this struct needs to be + // a trigger_t* because the struct will be cast to (trigger_t*) + // by the lf_schedule() functions to get to the trigger. + for (Action action : allActions(r)) { + builder.pr(CActionGenerator.generateAuxiliaryStruct( + r, + action, + getTarget(), + types, + federatedExtension, + userFacing + )); + } + } + + /** + * Generate the self struct type definition for the specified reactor + * in the specified federate. + * @param decl The parsed reactor data structure. + * @param constructorCode Place to put lines of code that need to + * go into the constructor. + */ + private void generateSelfStruct(CodeBuilder builder, ReactorDecl decl, CodeBuilder constructorCode) { + var reactor = toDefinition(decl); + var selfType = CUtil.selfType(ASTUtils.toDefinition(decl)); + + // Construct the typedef for the "self" struct. + // Create a type name for the self struct. + var body = new CodeBuilder(); + + // Extensions can add functionality to the CGenerator + generateSelfStructExtension(body, decl, constructorCode); + + // Next handle parameters. + body.pr(CParameterGenerator.generateDeclarations(reactor, types)); + + // Next handle states. + body.pr(CStateGenerator.generateDeclarations(reactor, types)); + + // Next handle actions. + CActionGenerator.generateDeclarations(reactor, body, constructorCode); + + // Next handle inputs and outputs. + CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); + + // If there are contained reactors that either receive inputs + // from reactions of this reactor or produce outputs that trigger + // reactions of this reactor, then we need to create a struct + // inside the self struct for each contained reactor. That + // struct has a place to hold the data produced by this reactor's + // reactions and a place to put pointers to data produced by + // the contained reactors. + generateInteractingContainedReactors(reactor, body, constructorCode); + + // Next, generate the fields needed for each reaction. + CReactionGenerator.generateReactionAndTriggerStructs( + body, + reactor, + constructorCode, + types + ); + + // Next, generate fields for modes + CModesGenerator.generateDeclarations(reactor, body, constructorCode); + + // The first field has to always be a pointer to the list of + // of allocated memory that must be freed when the reactor is freed. + // This means that the struct can be safely cast to self_base_t. + builder.pr("typedef struct {"); + builder.indent(); + builder.pr("struct self_base_t base;"); + builder.pr(body.toString()); + builder.unindent(); + builder.pr("} " + selfType + ";"); +>>>>>>> origin } // Finally, handle actions. // The very first item on this struct needs to be @@ -1087,6 +1676,7 @@ protected void generateAuxiliaryStructs(ReactorDecl decl) { } } +<<<<<<< HEAD /** * Generate the self struct type definition for the specified reactor in the specified federate. * @@ -1278,6 +1868,43 @@ private void generateInteractingContainedReactors( + "] = &self->_lf__reaction_" + index + ";"); +======= + /** + * Generate structs and associated code for contained reactors that + * send or receive data to or from the container's reactions. + * + * If there are contained reactors that either receive inputs + * from reactions of this reactor or produce outputs that trigger + * reactions of this reactor, then we need to create a struct + * inside the self struct of the container for each contained reactor. + * That struct has a place to hold the data produced by the container reactor's + * reactions and a place to put pointers to data produced by + * the contained reactors. + * + * @param reactor The reactor. + * @param body The place to put the struct definition for the contained reactors. + * @param constructorCode The place to put matching code that goes in the container's constructor. + */ + private void generateInteractingContainedReactors( + Reactor reactor, + CodeBuilder body, + CodeBuilder constructorCode + ) { + // The contents of the struct will be collected first so that + // we avoid duplicate entries and then the struct will be constructed. + var contained = new InteractingContainedReactors(reactor); + // Next generate the relevant code. + for (Instantiation containedReactor : contained.containedReactors()) { + Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); + // First define an _width variable in case it is a bank. + var array = ""; + var width = -2; + // If the instantiation is a bank, find the maximum bank width + // to define an array. + if (containedReactor.getWidthSpec() != null) { + width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); + array = "[" + width + "]"; +>>>>>>> origin } constructorCode.pr( port, portOnSelf + "_trigger.reactions = " + portOnSelf + "_reactions;"); @@ -1293,11 +1920,56 @@ private void generateInteractingContainedReactors( portOnSelf + "_trigger.last = NULL;", portOnSelf + "_trigger.number_of_reactions = " + triggered.size() + ";")); +<<<<<<< HEAD // Set the physical_time_of_arrival constructorCode.pr( port, CExtensionUtils.surroundWithIfFederated( portOnSelf + "_trigger.physical_time_of_arrival = NEVER;")); +======= + // Generate one struct for each contained reactor that interacts. + body.pr("struct {"); + body.indent(); + for (Port port : contained.portsOfInstance(containedReactor)) { + if (port instanceof Input) { + // If the variable is a multiport, then the place to store the data has + // to be malloc'd at initialization. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr(port, variableStructType(port, containedReactorType, false)+" "+port.getName()+";"); + } else { + // Is a multiport. + // Memory will be malloc'd in initialization. + body.pr(port, String.join("\n", + variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", + "int "+port.getName()+"_width;" + )); + } + } else { + // Must be an output port. + // Outputs of contained reactors are pointers to the source of data on the + // self struct of the container. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr(port, variableStructType(port, containedReactorType, false)+"* "+port.getName()+";"); + } else { + // Is a multiport. + // Here, we will use an array of pointers. + // Memory will be malloc'd in initialization. + body.pr(port, String.join("\n", + variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", + "int "+port.getName()+"_width;" + )); + } + body.pr(port, "trigger_t "+port.getName()+"_trigger;"); + var reactorIndex = ""; + if (containedReactor.getWidthSpec() != null) { + reactorIndex = "[reactor_index]"; + constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactor.getName()+"_width; reactor_index++) {"); + constructorCode.indent(); + } + var portOnSelf = "self->_lf_"+containedReactor.getName()+reactorIndex+"."+port.getName(); +>>>>>>> origin if (containedReactor.getWidthSpec() != null) { constructorCode.unindent(); @@ -1345,6 +2017,7 @@ public void generateReactions(ReactorDecl decl) { } } +<<<<<<< HEAD /** * Generate a reaction function definition for a reactor. This function will have a single * argument that is a void* pointing to a struct that contains parameters, state variables, inputs @@ -1358,8 +2031,37 @@ protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactio code.pr( CReactionGenerator.generateReaction( +======= + /** Generate reaction functions definition for a reactor. + * These functions have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param r The reactor. + */ + public void generateReactions(CodeBuilder src, Reactor r) { + var reactionIndex = 0; + var reactor = ASTUtils.toDefinition(r); + for (Reaction reaction : allReactions(reactor)) { + generateReaction(src, reaction, r, reactionIndex); + // Increment reaction index even if the reaction is not in the federate + // so that across federates, the reaction indices are consistent. + reactionIndex++; + } + } + + /** Generate a reaction function definition for a reactor. + * This function will have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { + src.pr(CReactionGenerator.generateReaction( +>>>>>>> origin reaction, - decl, + r, reactionIndex, mainDef, errorReporter, @@ -1820,12 +2522,80 @@ private void generateInitializeActionToken(ReactorInstance reactor) { } } +<<<<<<< HEAD var selfStruct = CUtil.reactorRef(action.getParent()); initializeTriggerObjects.pr( CActionGenerator.generateTokenInitializer(selfStruct, action.getName(), payloadSize)); } } } +======= + targetConfig.compileLibraries.add("-l"); + targetConfig.compileLibraries.add("protobuf-c"); + targetConfig.compilerFlags.add("-lprotobuf-c"); + } else { + errorReporter.reportError("protoc-c returns error code " + returnCode); + } + } + + /** + * Construct a unique type for the struct of the specified + * typed variable (port or action) of the specified reactor class. + * This is required to be the same as the type name returned by + * {@link #variableStructType(TriggerInstance)}. + */ + public static String variableStructType(Variable variable, Reactor reactor, boolean userFacing) { + return (userFacing ? reactor.getName().toLowerCase() : CUtil.getName(reactor)) +"_"+variable.getName()+"_t"; + } + + /** + * Construct a unique type for the struct of the specified + * instance (port or action). + * This is required to be the same as the type name returned by + * {@link #variableStructType(Variable, Reactor, boolean)}. + * @param portOrAction The port or action instance. + * @return The name of the self struct. + */ + public static String variableStructType(TriggerInstance portOrAction) { + return CUtil.getName(portOrAction.getParent().reactorDefinition)+"_"+portOrAction.getName()+"_t"; + } + + /** + * If tracing is turned on, then generate code that records + * the full name of the specified reactor instance in the + * trace table. If tracing is not turned on, do nothing. + * @param instance The reactor instance. + */ + private void generateTraceTableEntries(ReactorInstance instance) { + if (targetConfig.tracing != null) { + initializeTriggerObjects.pr( + CTracingGenerator.generateTraceTableEntries(instance) + ); + } + } + + /** + * Generate code to instantiate the specified reactor instance and + * initialize it. + * @param instance A reactor instance. + */ + public void generateReactorInstance(ReactorInstance instance) { + var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); + var fullName = instance.getFullName(); + initializeTriggerObjects.pr( + "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); + // Generate the instance self struct containing parameters, state variables, + // and outputs (the "self" struct). + initializeTriggerObjects.pr(CUtil.reactorRefName(instance)+"["+CUtil.runtimeIndex(instance)+"] = new_"+CUtil.getName(reactorClass)+"();"); + // Generate code to initialize the "self" struct in the + // _lf_initialize_trigger_objects function. + generateTraceTableEntries(instance); + generateReactorInstanceExtension(instance); + generateParameterInitialization(instance); + initializeOutputMultiports(instance); + initializeInputMultiports(instance); + recordBuiltinTriggers(instance); +>>>>>>> origin /** * Generate code that is executed while the reactor instance is being initialized. This is @@ -2182,6 +2952,7 @@ private void createMainReactorInstance() { } } +<<<<<<< HEAD /** * Generate an array of self structs for the reactor and one for each of its children. * @@ -2193,6 +2964,275 @@ private void generateSelfStructs(ReactorInstance r) { initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING(" + CUtil.reactorRefName(r) + ");"); for (ReactorInstance child : r.children) { generateSelfStructs(child); +======= + /** + * Generate code to initialize modes. + * @param instance The reactor instance. + */ + private void generateModeStructure(ReactorInstance instance) { + CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); + if (!instance.modes.isEmpty()) { + modalReactorCount += instance.getTotalWidth(); + } + } + + /** + * Generate runtime initialization code for parameters of a given reactor instance + * @param instance The reactor instance. + */ + protected void generateParameterInitialization(ReactorInstance instance) { + var selfRef = CUtil.reactorRef(instance); + // Set the local bank_index variable so that initializers can use it. + initializeTriggerObjects.pr("bank_index = "+CUtil.bankIndex(instance)+";" + + " SUPPRESS_UNUSED_WARNING(bank_index);"); + for (ParameterInstance parameter : instance.parameters) { + // NOTE: we now use the resolved literal value. For better efficiency, we could + // store constants in a global array and refer to its elements to avoid duplicate + // memory allocations. + // NOTE: If the parameter is initialized with a static initializer for an array + // or struct (the initialization expression is surrounded by { ... }), then we + // have to declare a static variable to ensure that the memory is put in data space + // and not on the stack. + // FIXME: Is there a better way to determine this than the string comparison? + var initializer = CParameterGenerator.getInitializer(parameter); + if (initializer.startsWith("{")) { + var temporaryVariableName = parameter.uniqueID(); + initializeTriggerObjects.pr(String.join("\n", + "static "+types.getVariableDeclaration(parameter.type, temporaryVariableName, true)+" = "+initializer+";", + selfRef+"->"+parameter.getName()+" = "+temporaryVariableName+";" + )); + } else { + initializeTriggerObjects.pr(selfRef+"->"+parameter.getName()+" = "+initializer+";"); + } + } + } + + /** + * Generate code that mallocs memory for any output multiports. + * @param reactor The reactor instance. + */ + private void initializeOutputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance output : reactor.outputs) { + initializeTriggerObjects.pr(CPortGenerator.initializeOutputMultiport( + output, + reactorSelfStruct + )); + } + } + + /** + * Allocate memory for inputs. + * @param reactor The reactor. + */ + private void initializeInputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance input : reactor.inputs) { + initializeTriggerObjects.pr(CPortGenerator.initializeInputMultiport( + input, + reactorSelfStruct + )); + } + } + + @Override + public TargetTypes getTargetTypes() { + return types; + } + + /** + * + * @param context + * @return + */ + protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new CDockerGenerator(context); + } + + // ////////////////////////////////////////// + // // Protected methods. + + // Perform set up that does not generate code + protected void setUpGeneralParameters() { + accommodatePhysicalActionsIfPresent(); + targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); + targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); + // Create the main reactor instance if there is a main reactor. + createMainReactorInstance(); + if (hasModalReactors) { + // So that each separate compile knows about modal reactors, do this: + targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); + } + if (targetConfig.threading && targetConfig.platformOptions.platform == Platform.ARDUINO + && (targetConfig.platformOptions.board == null || !targetConfig.platformOptions.board.contains("mbed"))) { + //non-MBED boards should not use threading + System.out.println("Threading is incompatible on your current Arduino flavor. Setting threading to false."); + targetConfig.threading = false; + } + + if (targetConfig.platformOptions.platform == Platform.ARDUINO && !targetConfig.noCompile + && targetConfig.platformOptions.board == null) { + System.out.println("To enable compilation for the Arduino platform, you must specify the fully-qualified board name (FQBN) in the target property. For example, platform: {name: arduino, board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target code only."); + targetConfig.noCompile = true; + } + if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake + pickScheduler(); + // FIXME: this and pickScheduler should be combined. + targetConfig.compileDefinitions.put( + "SCHEDULER", + targetConfig.schedulerType.name() + ); + targetConfig.compileDefinitions.put( + "NUMBER_OF_WORKERS", + String.valueOf(targetConfig.workers) + ); + } + pickCompilePlatform(); + } + + protected void handleProtoFiles() { + // Handle .proto files. + for (String file : targetConfig.protoFiles) { + this.processProtoFile(file); + } + } + + /** + * Generate code that needs to appear at the top of the generated + * C file, such as #define and #include statements. + */ + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr(CPreambleGenerator.generateDefineDirectives( + targetConfig, + fileConfig.getSrcGenPath(), + hasModalReactors + )); + code.pr(CPreambleGenerator.generateIncludeStatements( + targetConfig, + CCppMode + )); + return code.toString(); + } + + /** + * Generate top-level preamble code. + */ + protected String generateTopLevelPreambles(Reactor reactor) { + CodeBuilder builder = new CodeBuilder(); + var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; + builder.pr("#ifndef " + guard); + builder.pr("#define " + guard); + Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) + .flatMap(it -> ((Model) it.eContainer()).getPreambles().stream()) + .collect(Collectors.toSet()) + .forEach(it -> builder.pr(toText(it.getCode()))); + for (String file : targetConfig.protoFiles) { + var dotIndex = file.lastIndexOf("."); + var rootFilename = file; + if (dotIndex > 0) { + rootFilename = file.substring(0, dotIndex); + } + code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); + builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); + } + builder.pr("#endif"); + return builder.toString(); + } + + protected boolean targetLanguageIsCpp() { + return CCppMode; + } + + /** Given a line of text from the output of a compiler, return + * an instance of ErrorFileAndLine if the line is recognized as + * the first line of an error message. Otherwise, return null. + * @param line A line of output from a compiler or other external + * tool that might generate errors. + * @return If the line is recognized as the start of an error message, + * then return a class containing the path to the file on which the + * error occurred (or null if there is none), the line number (or the + * string "1" if there is none), the character position (or the string + * "0" if there is none), and the message (or an empty string if there + * is none). + */ + @Override + public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { + var matcher = compileErrorPattern.matcher(line); + if (matcher.find()) { + var result = new ErrorFileAndLine(); + result.filepath = matcher.group("path"); + result.line = matcher.group("line"); + result.character = matcher.group("column"); + result.message = matcher.group("message"); + + if (!result.message.toLowerCase().contains("error:")) { + result.isError = false; + } + return result; + } + return null; + } + + //////////////////////////////////////////// + //// Private methods. + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.C; + } + + //////////////////////////////////////////////////////////// + //// Private methods + + /** + * If a main or federated reactor has been declared, create a ReactorInstance + * for this top level. This will also assign levels to reactions, then, + * if the program is federated, perform an AST transformation to disconnect + * connections between federates. + */ + private void createMainReactorInstance() { + if (this.mainDef != null) { + if (this.main == null) { + // Recursively build instances. + this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); + var reactionInstanceGraph = this.main.assignLevels(); + if (reactionInstanceGraph.nodeCount() > 0) { + errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); + return; + } + if (hasDeadlines) { + this.main.assignDeadlines(); + } + // Inform the run-time of the breadth/parallelism of the reaction graph + var breadth = reactionInstanceGraph.getBreadth(); + if (breadth == 0) { + errorReporter.reportWarning("The program has no reactions"); + } else { + targetConfig.compileDefinitions.put( + "LF_REACTION_GRAPH_BREADTH", + String.valueOf(reactionInstanceGraph.getBreadth()) + ); + } + } + } + + } + + /** + * Generate an array of self structs for the reactor + * and one for each of its children. + * @param r The reactor instance. + */ + private void generateSelfStructs(ReactorInstance r) { + initializeTriggerObjects.pr(CUtil.selfType(r)+"* "+CUtil.reactorRefName(r)+"["+r.getTotalWidth()+"];"); + initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING("+CUtil.reactorRefName(r)+");"); + for (ReactorInstance child : r.children) { + generateSelfStructs(child); + } +>>>>>>> origin } } } diff --git a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java index febac3362c..8228ce320c 100644 --- a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java @@ -72,7 +72,7 @@ public static String generateMethod( code.indent(); // Define the "self" struct. - String structType = CUtil.selfType(decl); + String structType = CUtil.selfType(ASTUtils.toDefinition(decl)); // A null structType means there are no inputs, state, // or anything else. No need to declare it. if (structType != null) { @@ -139,7 +139,7 @@ public static void signatures( * @return The function name for the method. */ private static String methodFunctionName(ReactorDecl reactor, Method method) { - return reactor.getName().toLowerCase() + "_method_" + method.getName(); + return CUtil.getName(ASTUtils.toDefinition(reactor)) + "_method_" + method.getName(); } /** diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index 0db76a16ff..1b22b41f9a 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -44,22 +44,28 @@ public static void generateDeclarations( * Generate the struct type definitions for the port of the * reactor * - * @param decl The reactor declaration + * @param r The reactor * @param port The port to generate the struct * @param target The target of the code generation (C, CCpp or Python) * @param errorReporter The error reporter * @param types The helper object for types related stuff * @param federatedExtension The code needed to support federated execution + * @param userFacing Whether this struct is to be presented in a user-facing header + * @param decl The reactorDecl if this struct is for the header of this reactor's container; + * null otherwise * @return The auxiliary struct for the port as a string */ public static String generateAuxiliaryStruct( - ReactorDecl decl, + Reactor r, Port port, Target target, ErrorReporter errorReporter, CTypes types, - CodeBuilder federatedExtension + CodeBuilder federatedExtension, + boolean userFacing, + ReactorDecl decl ) { + assert decl == null || userFacing; var code = new CodeBuilder(); code.pr("typedef struct {"); code.indent(); @@ -79,10 +85,16 @@ public static String generateAuxiliaryStruct( code.pr(valueDeclaration(port, target, errorReporter, types)); code.pr(federatedExtension.toString()); code.unindent(); - code.pr("} "+variableStructType(port, decl)+";"); + var name = decl != null ? localPortName(decl, port.getName()) + : variableStructType(port, r, userFacing); + code.pr("} " + name + ";"); return code.toString(); } + public static String localPortName(ReactorDecl decl, String portName) { + return decl.getName().toLowerCase() + "_" + portName + "_t"; + } + /** * Allocate memory for the input port. * @param input The input port @@ -210,21 +222,21 @@ private static void generateInputDeclarations( if (ASTUtils.isMultiport(input)) { body.pr(input, String.join("\n", "// Multiport input array will be malloc'd later.", - variableStructType(input, decl)+"** _lf_"+inputName+";", + variableStructType(input, reactor, false)+"** _lf_"+inputName+";", "int _lf_"+inputName+"_width;", "// Default input (in case it does not get connected)", - variableStructType(input, decl)+" _lf_default__"+inputName+";", + variableStructType(input, reactor, false)+" _lf_default__"+inputName+";", "// Struct to support efficiently reading sparse inputs.", "lf_sparse_io_record_t* _lf_"+inputName+"__sparse;" )); } else { // input is not a multiport. body.pr(input, String.join("\n", - variableStructType(input, decl)+"* _lf_"+inputName+";", + variableStructType(input, reactor, false)+"* _lf_"+inputName+";", "// width of -2 indicates that it is not a multiport.", "int _lf_"+inputName+"_width;", "// Default input (in case it does not get connected)", - variableStructType(input, decl)+" _lf_default__"+inputName+";" + variableStructType(input, reactor, false)+" _lf_default__"+inputName+";" )); constructorCode.pr(input, String.join("\n", @@ -256,7 +268,7 @@ private static void generateOutputDeclarations( if (ASTUtils.isMultiport(output)) { body.pr(output, String.join("\n", "// Array of output ports.", - variableStructType(output, decl)+"* _lf_"+outputName+";", + variableStructType(output, reactor, false)+"* _lf_"+outputName+";", "int _lf_"+outputName+"_width;", "// An array of pointers to the individual ports. Useful", "// for the lf_set macros to work out-of-the-box for", @@ -264,11 +276,11 @@ private static void generateOutputDeclarations( "// value can be accessed via a -> operator (e.g.,foo[i]->value).", "// So we have to handle multiports specially here a construct that", "// array of pointers.", - variableStructType(output, decl)+"** _lf_"+outputName+"_pointers;" + variableStructType(output, reactor, false)+"** _lf_"+outputName+"_pointers;" )); } else { body.pr(output, String.join("\n", - variableStructType(output, decl)+" _lf_"+outputName+";", + variableStructType(output, reactor, false)+" _lf_"+outputName+";", "int _lf_"+outputName+"_width;" )); } diff --git a/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java b/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java index d78456e4ae..8ca0404d75 100644 --- a/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java @@ -36,34 +36,26 @@ public static String generateIncludeStatements( if (cppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) { code.pr("extern \"C\" {"); } - - String relPathHeader = ""; - if (targetConfig.platformOptions.platform == Platform.ARDUINO) { - relPathHeader = "src/include/"; - - CCoreFilesUtils.getCTargetHeader().forEach( - it -> code.pr("#include " + StringUtil.addDoubleQuotes("src/" + it)) - ); - } else { - CCoreFilesUtils.getCTargetHeader().forEach( - it -> code.pr("#include " + StringUtil.addDoubleQuotes(it)) - ); - } - code.pr("#include \"" + relPathHeader + "core/reactor.h\""); - code.pr("#include \"" + relPathHeader + "core/reactor_common.h\""); + code.pr("#include "); + code.pr("#include \"include/core/platform.h\""); + CCoreFilesUtils.getCTargetHeader().forEach( + it -> code.pr("#include " + StringUtil.addDoubleQuotes(it)) + ); + code.pr("#include \"include/core/reactor.h\""); + code.pr("#include \"include/core/reactor_common.h\""); if (targetConfig.threading) { - code.pr("#include \"" + relPathHeader + "core/threaded/scheduler.h\""); + code.pr("#include \"include/core/threaded/scheduler.h\""); } if (tracing != null) { - code.pr("#include \"" + relPathHeader + "core/trace.h\""); + code.pr("#include \"include/core/trace.h\""); } - code.pr("#include \"" + relPathHeader + "core/mixed_radix.h\""); - code.pr("#include \"" + relPathHeader + "core/port.h\""); + code.pr("#include \"include/core/mixed_radix.h\""); + code.pr("#include \"include/core/port.h\""); code.pr("int lf_reactor_c_main(int argc, const char* argv[]);"); if(targetConfig.fedSetupPreamble != null) { - code.pr("#include \"" + relPathHeader + "core/federated/federate.h\""); - code.pr("#include \"" + relPathHeader + "core/federated/net_common.h\""); + code.pr("#include \"include/core/federated/federate.h\""); + code.pr("#include \"include/core/federated/net_common.h\""); } if (cppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) { code.pr("}"); diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index b7f72e216a..9625122e2b 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -13,7 +13,6 @@ import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetConfig; -import org.lflang.TargetProperty.Platform; import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Action; @@ -22,6 +21,7 @@ import org.lflang.lf.Code; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; +import org.lflang.lf.LfFactory; import org.lflang.lf.Mode; import org.lflang.lf.ModeTransition; import org.lflang.lf.Output; @@ -37,6 +37,7 @@ import org.lflang.util.StringUtil; public class CReactionGenerator { +<<<<<<< HEAD protected static String DISABLE_REACTION_INITIALIZATION_MARKER = "// **** Do not include initialization code in this reaction."; @@ -61,6 +62,27 @@ public static String generateInitializationForReaction( Instantiation mainDef, boolean requiresTypes) { Reactor reactor = ASTUtils.toDefinition(decl); +======= + protected static String DISABLE_REACTION_INITIALIZATION_MARKER + = "// **** Do not include initialization code in this reaction."; // FIXME: Such markers should not exist (#1687) + + /** + * Generate necessary initialization code inside the body of the reaction that belongs to reactor decl. + * @param body The body of the reaction. Used to check for the DISABLE_REACTION_INITIALIZATION_MARKER. + * @param reaction The initialization code will be generated for this specific reaction + * @param decl The reactor that has the reaction + * @param reactionIndex The index of the reaction relative to other reactions in the reactor, starting from 0 + */ + public static String generateInitializationForReaction(String body, + Reaction reaction, + Reactor decl, + int reactionIndex, + CTypes types, + ErrorReporter errorReporter, + Instantiation mainDef, + boolean requiresTypes) { + Reactor reactor = ASTUtils.toDefinition(decl); +>>>>>>> origin // Construct the reactionInitialization code to go into // the body of the function before the verbatim code. @@ -68,6 +90,7 @@ public static String generateInitializationForReaction( CodeBuilder code = new CodeBuilder(); +<<<<<<< HEAD // Define the "self" struct. String structType = CUtil.selfType(decl); // A null structType means there are no inputs, state, @@ -80,6 +103,169 @@ public static String generateInitializationForReaction( + "* self = (" + structType + "*)instance_args; SUPPRESS_UNUSED_WARNING(self);")); +======= + // Define the "self" struct. + String structType = CUtil.selfType(decl); + // A null structType means there are no inputs, state, + // or anything else. No need to declare it. + if (structType != null) { + code.pr(String.join("\n", + structType+"* self = ("+structType+"*)instance_args; SUPPRESS_UNUSED_WARNING(self);" + )); + } + + // Do not generate the initialization code if the body is marked + // to not generate it. + if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { + return code.toString(); + } + + // A reaction may send to or receive from multiple ports of + // a contained reactor. The variables for these ports need to + // all be declared as fields of the same struct. Hence, we first + // collect the fields to be defined in the structs and then + // generate the structs. + Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); + + // Actions may appear twice, first as a trigger, then with the outputs. + // But we need to declare it only once. Collect in this data structure + // the actions that are declared as triggered so that if they appear + // again with the outputs, they are not defined a second time. + // That second redefinition would trigger a compile error. + Set actionsAsTriggers = new LinkedHashSet<>(); + + // Next, add the triggers (input and actions; timers are not needed). + // This defines a local variable in the reaction function whose + // name matches that of the trigger. The value of the local variable + // is a struct with a value and is_present field, the latter a boolean + // that indicates whether the input/action is present. + // If the trigger is an output, then it is an output of a + // contained reactor. In this case, a struct with the name + // of the contained reactor is created with one field that is + // a pointer to a struct with a value and is_present field. + // E.g., if the contained reactor is named 'c' and its output + // port is named 'out', then c.out->value c.out->is_present are + // defined so that they can be used in the verbatim code. + for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (triggerAsVarRef.getVariable() instanceof Port) { + generatePortVariablesInReaction( + reactionInitialization, + fieldsForStructsForContainedReactors, + triggerAsVarRef, + decl, + types); + } else if (triggerAsVarRef.getVariable() instanceof Action) { + reactionInitialization.pr(generateActionVariablesInReaction( + (Action) triggerAsVarRef.getVariable(), + decl, + types + )); + actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); + } + } + } + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + // No triggers are given, which means react to any input. + // Declare an argument for every input. + // NOTE: this does not include contained outputs. + for (Input input : reactor.getInputs()) { + reactionInitialization.pr(generateInputVariablesInReaction(input, decl, types)); + } + } + // Define argument for non-triggering inputs. + for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { + if (src.getVariable() instanceof Port) { + generatePortVariablesInReaction(reactionInitialization, fieldsForStructsForContainedReactors, src, decl, types); + } else if (src.getVariable() instanceof Action) { + // It's a bit odd to read but not be triggered by an action, but + // OK, I guess we allow it. + reactionInitialization.pr(generateActionVariablesInReaction( + (Action) src.getVariable(), + decl, + types + )); + actionsAsTriggers.add((Action) src.getVariable()); + } + } + + // Define variables for each declared output or action. + // In the case of outputs, the variable is a pointer to where the + // output is stored. This gives the reaction code access to any previous + // value that may have been written to that output in an earlier reaction. + if (reaction.getEffects() != null) { + for (VarRef effect : reaction.getEffects()) { + Variable variable = effect.getVariable(); + if (variable instanceof Action) { + // It is an action, not an output. + // If it has already appeared as trigger, do not redefine it. + if (!actionsAsTriggers.contains(effect.getVariable())) { + reactionInitialization.pr(CGenerator.variableStructType(variable, decl, false)+"* "+variable.getName()+" = &self->_lf_"+variable.getName()+";"); + } + } else if (effect.getVariable() instanceof Mode) { + // Mode change effect + int idx = ASTUtils.allModes(reactor).indexOf((Mode)effect.getVariable()); + String name = effect.getVariable().getName(); + if (idx >= 0) { + reactionInitialization.pr( + "reactor_mode_t* " + name + " = &self->_lf__modes[" + idx + "];\n" + + "lf_mode_change_type_t _lf_" + name + "_change_type = " + + (effect.getTransition() == ModeTransition.HISTORY ? + "history_transition" : "reset_transition") + + ";" + ); + } else { + errorReporter.reportError( + reaction, + "In generateReaction(): " + name + " not a valid mode of this reactor." + ); + } + } else { + if (variable instanceof Output) { + reactionInitialization.pr(generateOutputVariablesInReaction( + effect, + decl, + errorReporter, + requiresTypes + )); + } else if (variable instanceof Input) { + // It is the input of a contained reactor. + generateVariablesForSendingToContainedReactors( + reactionInitialization, + fieldsForStructsForContainedReactors, + effect.getContainer(), + (Input) variable + ); + } else { + errorReporter.reportError( + reaction, + "In generateReaction(): effect is neither an input nor an output." + ); + } + } + } + } + // Before the reaction initialization, + // generate the structs used for communication to and from contained reactors. + for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { + String array = ""; + if (containedReactor.getWidthSpec() != null) { + String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); + code.pr("int "+containedReactorWidthVar+" = self->_lf_"+containedReactorWidthVar+";"); + // Windows does not support variables in arrays declared on the stack, + // so we use the maximum size over all bank members. + array = "["+maxContainedReactorBankWidth(containedReactor, null, 0, mainDef)+"]"; + } + code.pr(String.join("\n", + "struct "+containedReactor.getName()+" {", + " "+fieldsForStructsForContainedReactors.get(containedReactor)+"", + "} "+containedReactor.getName()+array+";" + )); + } + // Next generate all the collected setup code. + code.pr(reactionInitialization.toString()); + return code.toString(); +>>>>>>> origin } // Do not generate the initialization code if the body is marked @@ -129,6 +315,7 @@ public static String generateInitializationForReaction( (Action) triggerAsVarRef.getVariable(), decl, types)); actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); } +<<<<<<< HEAD } } if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { @@ -194,6 +381,27 @@ public static String generateInitializationForReaction( errorReporter.reportError( reaction, "In generateReaction(): " + name + " not a valid mode of this reactor."); } +======= + String inputStructType = CGenerator.variableStructType(input, ASTUtils.toDefinition(definition.getReactorClass()), false); + String defName = definition.getName(); + String defWidth = generateWidthVariable(defName); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); + if (!ASTUtils.isMultiport(input)) { + // Contained reactor's input is not a multiport. + structBuilder.pr(inputStructType+"* "+inputName+";"); + if (definition.getWidthSpec() != null) { + // Contained reactor is a bank. + builder.pr(String.join("\n", + "for (int bankIndex = 0; bankIndex < self->_lf_"+defWidth+"; bankIndex++) {", + " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+defName+"[bankIndex]."+inputName+");", + "}" + )); + } else { + // Contained reactor is not a bank. + builder.pr(defName+"."+inputName+" = &(self->_lf_"+defName+"."+inputName+");"); + } +>>>>>>> origin } else { if (variable instanceof Output) { reactionInitialization.pr( @@ -238,6 +446,7 @@ public static String generateInitializationForReaction( return code.toString(); } +<<<<<<< HEAD /** * Return the maximum bank width for the given instantiation within all instantiations of its * parent reactor. On the first call to this method, the breadcrumbs should be null and the max @@ -291,6 +500,78 @@ public static int maxContainedReactorBankWidth( int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); if (candidate > result) { result = candidate; +======= + /** + * Generate into the specified string builder the code to + * initialize local variables for ports in a reaction function + * from the "self" struct. The port may be an input of the + * reactor or an output of a contained reactor. The second + * argument provides, for each contained reactor, a place to + * write the declaration of the output of that reactor that + * is triggering reactions. + * @param builder The place into which to write the code. + * @param structs A map from reactor instantiations to a place to write + * struct fields. + */ + private static void generatePortVariablesInReaction( + CodeBuilder builder, + Map structs, + VarRef port, + Reactor r, + CTypes types + ) { + if (port.getVariable() instanceof Input) { + builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), r, types)); + } else { + // port is an output of a contained reactor. + Output output = (Output) port.getVariable(); + String portStructType = CGenerator.variableStructType(output, ASTUtils.toDefinition(port.getContainer().getReactorClass()), false); + + CodeBuilder structBuilder = structs.get(port.getContainer()); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(port.getContainer(), structBuilder); + } + String reactorName = port.getContainer().getName(); + String reactorWidth = generateWidthVariable(reactorName); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + // First define the struct containing the output value and indicator + // of its presence. + if (!ASTUtils.isMultiport(output)) { + // Output is not a multiport. + structBuilder.pr(portStructType+"* "+outputName+";"); + } else { + // Output is a multiport. + structBuilder.pr(String.join("\n", + portStructType+"** "+outputName+";", + "int "+outputWidth+";" + )); + } + + // Next, initialize the struct with the current values. + if (port.getContainer().getWidthSpec() != null) { + // Output is in a bank. + builder.pr(String.join("\n", + "for (int i = 0; i < "+reactorWidth+"; i++) {", + " "+reactorName+"[i]."+outputName+" = self->_lf_"+reactorName+"[i]."+outputName+";", + "}" + )); + if (ASTUtils.isMultiport(output)) { + builder.pr(String.join("\n", + "for (int i = 0; i < "+reactorWidth+"; i++) {", + " "+reactorName+"[i]."+outputWidth+" = self->_lf_"+reactorName+"[i]."+outputWidth+";", + "}" + )); + } + } else { + // Output is not in a bank. + builder.pr(reactorName+"."+outputName+" = self->_lf_"+reactorName+"."+outputName+";"); + if (ASTUtils.isMultiport(output)) { + builder.pr(reactorName+"."+outputWidth+" = self->_lf_"+reactorName+"."+outputWidth+";"); + } + } +>>>>>>> origin } } else { // Found some other instantiation, not the parent. @@ -308,6 +589,7 @@ public static int maxContainedReactorBankWidth( return result; } +<<<<<<< HEAD /** * Generate code for the body of a reaction that takes an input and schedules an action with the * value of that input. @@ -327,6 +609,22 @@ public static String generateDelayBody(String ref, String actionName, boolean is "}") : "lf_schedule_copy(" + actionName + ", 0, &" + ref + "->value, 1); // Length is 1."; } +======= + /** Generate action variables for a reaction. + * @param action The action. + */ + private static String generateActionVariablesInReaction( + Action action, + Reactor r, + CTypes types + ) { + String structType = CGenerator.variableStructType(action, r, false); + // If the action has a type, create variables for accessing the value. + InferredType type = ASTUtils.getInferredType(action); + // Pointer to the lf_token_t sent as the payload in the trigger. + String tokenPointer = "(self->_lf__"+action.getName()+".tmplt.token)"; + CodeBuilder builder = new CodeBuilder(); +>>>>>>> origin public static String generateForwardBody( String outputName, String targetType, String actionName, boolean isTokenType) { @@ -382,6 +680,7 @@ private static void generateVariablesForSendingToContainedReactors( if (definition.getWidthSpec() != null) { // Contained reactor is a bank. builder.pr( +<<<<<<< HEAD String.join( "\n", "for (int bankIndex = 0; bankIndex < self->_lf_" + defWidth + "; bankIndex++) {", @@ -419,6 +718,335 @@ private static void generateVariablesForSendingToContainedReactors( + defName + "[_i]." + inputName +======= + String.join("\n", + "// Expose the action struct as a local variable whose name matches the action name.", + structType+"* "+action.getName()+" = &self->_lf_"+action.getName()+";", + "// Set the fields of the action struct to match the current trigger.", + action.getName()+"->is_present = (bool)self->_lf__"+action.getName()+".status;", + action.getName()+"->has_value = ("+tokenPointer+" != NULL && "+tokenPointer+"->value != NULL);", + "_lf_replace_template_token((token_template_t*)"+action.getName()+", "+tokenPointer+");") + ); + // Set the value field only if there is a type. + if (!type.isUndefined()) { + // The value field will either be a copy (for primitive types) + // or a pointer (for types ending in *). + builder.pr("if ("+action.getName()+"->has_value) {"); + builder.indent(); + if (CUtil.isTokenType(type, types)) { + builder.pr(action.getName()+"->value = ("+types.getTargetType(type)+")"+tokenPointer+"->value;"); + } else { + builder.pr(action.getName()+"->value = *("+types.getTargetType(type)+"*)"+tokenPointer+"->value;"); + } + builder.unindent(); + builder.pr("}"); + } + return builder.toString(); + } + + /** Generate into the specified string builder the code to + * initialize local variables for the specified input port + * in a reaction function from the "self" struct. + * @param input The input statement from the AST. + * @param r The reactor. + */ + private static String generateInputVariablesInReaction( + Input input, + Reactor r, + CTypes types + ) { + String structType = CGenerator.variableStructType(input, r, false); + InferredType inputType = ASTUtils.getInferredType(input); + CodeBuilder builder = new CodeBuilder(); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); + + // Create the local variable whose name matches the input name. + // If the input has not been declared mutable, then this is a pointer + // to the upstream output. Otherwise, it is a copy of the upstream output, + // which nevertheless points to the same token and value (hence, as done + // below, we have to use lf_writable_copy()). There are 8 cases, + // depending on whether the input is mutable, whether it is a multiport, + // and whether it is a token type. + // Easy case first. + if (!input.isMutable() && !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, primitive type. + builder.pr(structType+"* "+inputName+" = self->_lf_"+inputName+";"); + } else if (input.isMutable()&& !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, primitive type. + builder.pr(String.join("\n", + "// Mutable input, so copy the input into a temporary variable.", + "// The input value on the struct is a copy.", + structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", + structType+"* "+inputName+" = &_lf_tmp_"+inputName+";" + )); + } else if (!input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, token type. + builder.pr(String.join("\n", + structType+"* "+inputName+" = self->_lf_"+inputName+";", + "if ("+inputName+"->is_present) {", + " "+inputName+"->length = "+inputName+"->token->length;", + " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", + "} else {", + " "+inputName+"->length = 0;", + "}" + )); + } else if (input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, token type. + builder.pr(String.join("\n", + "// Mutable input, so copy the input struct into a temporary variable.", + structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", + structType+"* "+inputName+" = &_lf_tmp_"+inputName+";", + inputName+"->value = NULL;", // Prevent payload from being freed. + "if ("+inputName+"->is_present) {", + " "+inputName+"->length = "+inputName+"->token->length;", + " "+inputName+"->token = lf_writable_copy((lf_port_base_t*)self->_lf_"+inputName+");", + " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", + "} else {", + " "+inputName+"->length = 0;", + "}" + )); + } else if (!input.isMutable()&& ASTUtils.isMultiport(input)) { + // Non-mutable, multiport, primitive or token type. + builder.pr(structType+"** "+inputName+" = self->_lf_"+inputName+";"); + } else if (CUtil.isTokenType(inputType, types)) { + // Mutable, multiport, token type + builder.pr(String.join("\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", + structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", + "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", + " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", + " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", + " // If necessary, copy the tokens.", + " if ("+inputName+"[i]->is_present) {", + " "+inputName+"[i]->length = "+inputName+"[i]->token->length;", + " token_template_t* _lf_input = (token_template_t*)self->_lf_"+inputName+"[i];", + " "+inputName+"[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", + " "+inputName+"[i]->value = ("+types.getTargetType(inputType)+")"+inputName+"[i]->token->value;", + " } else {", + " "+inputName+"[i]->length = 0;", + " }", + "}" + )); + } else { + // Mutable, multiport, primitive type + builder.pr(String.join("\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", + structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", + "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", + " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", + " // Copy the struct, which includes the value.", + " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", + "}" + )); + } + // Set the _width variable for all cases. This will be -1 + // for a variable-width multiport, which is not currently supported. + // It will be -2 if it is not multiport. + builder.pr("int "+inputWidth+" = self->_lf_"+inputWidth+"; SUPPRESS_UNUSED_WARNING("+inputWidth+");"); + return builder.toString(); + } + + /** + * Generate into the specified string builder the code to + * initialize local variables for outputs in a reaction function + * from the "self" struct. + * @param effect The effect declared by the reaction. This must refer to an output. + * @param r The reactor containing the reaction. + */ + public static String generateOutputVariablesInReaction( + VarRef effect, + Reactor r, + ErrorReporter errorReporter, + boolean requiresTypes + ) { + Output output = (Output) effect.getVariable(); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + if (output.getType() == null && requiresTypes) { + errorReporter.reportError(output, "Output is required to have a type: " + outputName); + return ""; + } else { + // The container of the output may be a contained reactor or + // the reactor containing the reaction. + String outputStructType = (effect.getContainer() == null) ? + CGenerator.variableStructType(output, r, false) + : + CGenerator.variableStructType(output, ASTUtils.toDefinition(effect.getContainer().getReactorClass()), false); + if (!ASTUtils.isMultiport(output)) { + // Output port is not a multiport. + return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; + } else { + // Output port is a multiport. + // Set the _width variable. + return String.join("\n", + "int "+outputWidth+" = self->_lf_"+outputWidth+"; SUPPRESS_UNUSED_WARNING("+outputWidth+");", + outputStructType+"** "+outputName+" = self->_lf_"+outputName+"_pointers;" + ); + + } + } + } + + /** + * Generate the fields of the self struct and statements for the constructor + * to create and initialize a reaction_t struct for each reaction in the + * specified reactor and a trigger_t struct for each trigger (input, action, + * timer, or output of a contained reactor). + * @param body The place to put the code for the self struct. + * @param reactor The reactor. + * @param constructorCode The place to put the constructor code. + */ + public static void generateReactionAndTriggerStructs( + CodeBuilder body, + Reactor reactor, + CodeBuilder constructorCode, + CTypes types + ) { + var reactionCount = 0; + // Iterate over reactions and create initialize the reaction_t struct + // on the self struct. Also, collect a map from triggers to the reactions + // that are triggered by that trigger. Also, collect a set of sources + // that are read by reactions but do not trigger reactions. + // Finally, collect a set of triggers and sources that are outputs + // of contained reactors. + var triggerMap = new LinkedHashMap>(); + var sourceSet = new LinkedHashSet(); + var outputsOfContainedReactors = new LinkedHashMap(); + var startupReactions = new LinkedHashSet(); + var shutdownReactions = new LinkedHashSet(); + var resetReactions = new LinkedHashSet(); + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create the reaction_t struct. + body.pr(reaction, "reaction_t _lf__reaction_"+reactionCount+";"); + + // Create the map of triggers to reactions. + for (TriggerRef trigger : reaction.getTriggers()) { + // trigger may not be a VarRef (it could be "startup" or "shutdown"). + if (trigger instanceof VarRef) { + var triggerAsVarRef = (VarRef) trigger; + var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); + if (reactionList == null) { + reactionList = new LinkedList<>(); + triggerMap.put(triggerAsVarRef.getVariable(), reactionList); + } + reactionList.add(reactionCount); + if (triggerAsVarRef.getContainer() != null) { + outputsOfContainedReactors.put(triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); + } + } else if (trigger instanceof BuiltinTriggerRef) { + switch(((BuiltinTriggerRef) trigger).getType()) { + case STARTUP: + startupReactions.add(reactionCount); + break; + case SHUTDOWN: + shutdownReactions.add(reactionCount); + break; + case RESET: + resetReactions.add(reactionCount); + break; + } + } + } + // Create the set of sources read but not triggering. + for (VarRef source : reaction.getSources()) { + sourceSet.add(source.getVariable()); + if (source.getContainer() != null) { + outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); + } + } + + var deadlineFunctionPointer = "NULL"; + if (reaction.getDeadline() != null) { + // The following has to match the name chosen in generateReactions + var deadlineFunctionName = generateDeadlineFunctionName(reactor, reactionCount); + deadlineFunctionPointer = "&" + deadlineFunctionName; + } + + // Assign the STP handler + var STPFunctionPointer = "NULL"; + if (reaction.getStp() != null) { + // The following has to match the name chosen in generateReactions + var STPFunctionName = generateStpFunctionName(reactor, reactionCount); + STPFunctionPointer = "&" + STPFunctionName; + } + + // Set the defaults of the reaction_t struct in the constructor. + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__reaction_"+reactionCount+".index = 0; + // self->_lf__reaction_"+reactionCount+".chain_id = 0; + // self->_lf__reaction_"+reactionCount+".pos = 0; + // self->_lf__reaction_"+reactionCount+".status = inactive; + // self->_lf__reaction_"+reactionCount+".deadline = 0LL; + // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; + constructorCode.pr(reaction, String.join("\n", + "self->_lf__reaction_"+reactionCount+".number = "+reactionCount+";", + "self->_lf__reaction_"+reactionCount+".function = "+CReactionGenerator.generateReactionFunctionName(reactor, reactionCount)+";", + "self->_lf__reaction_"+reactionCount+".self = self;", + "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", + "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", + "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", + (reaction.eContainer() instanceof Mode ? + "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+reactor.getModes().indexOf((Mode) reaction.eContainer())+"];" : + "self->_lf__reaction_"+reactionCount+".mode = NULL;") + )); + // Increment the reactionCount even if the reaction is not in the federate + // so that reaction indices are consistent across federates. + reactionCount++; + } + + // Next, create and initialize the trigger_t objects. + // Start with the timers. + for (Timer timer : ASTUtils.allTimers(reactor)) { + createTriggerT(body, timer, triggerMap, constructorCode, types); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + constructorCode.pr("self->_lf__"+timer.getName()+".is_timer = true;"); + constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__"+timer.getName()+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + } + + // Handle builtin triggers. + if (startupReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); + } + // Handle shutdown triggers. + if (shutdownReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); + } + if (resetReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); + } + + // Next handle actions. + for (Action action : ASTUtils.allActions(reactor)) { + createTriggerT(body, action, triggerMap, constructorCode, types); + var isPhysical = "true"; + if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { + isPhysical = "false"; + } + var elementSize = "0"; + // If the action type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) + : null; + if (rootType != null && !rootType.equals("void")) { + elementSize = "sizeof(" + rootType + ")"; + } + + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__"+action.getName()+".is_timer = false; + constructorCode.pr(String.join("\n", + "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", + (!(action.getPolicy() == null || action.getPolicy().isEmpty()) ? + "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" : + ""), + // Need to set the element_size in the trigger_t and the action struct. + "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize +>>>>>>> origin + ";", " " + defName @@ -1276,6 +1904,7 @@ public static String generateReaction( generateStpFunctionHeader(decl, reactionIndex), init, reaction.getStp().getCode())); } +<<<<<<< HEAD // Now generate code for the deadline violation function, if there is one. if (reaction.getDeadline() != null) { code.pr( @@ -1359,6 +1988,142 @@ public static String generateReactionFunctionHeader(ReactorDecl decl, int reacti String functionName = generateReactionFunctionName(decl, reactionIndex); return generateFunctionHeader(functionName); } +======= + /** Generate a reaction function definition for a reactor. + * This function will have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + public static String generateReaction( + Reaction reaction, + Reactor r, + int reactionIndex, + Instantiation mainDef, + ErrorReporter errorReporter, + CTypes types, + TargetConfig targetConfig, + boolean requiresType + ) { + var code = new CodeBuilder(); + var body = ASTUtils.toText(getCode(types, reaction, r)); + String init = generateInitializationForReaction( + body, reaction, ASTUtils.toDefinition(r), reactionIndex, + types, errorReporter, mainDef, + requiresType); + + code.pr( + "#include " + StringUtil.addDoubleQuotes( + CCoreFilesUtils.getCTargetSetHeader())); + + CMethodGenerator.generateMacrosForMethods(ASTUtils.toDefinition(r), code); + code.pr(generateFunction( + generateReactionFunctionHeader(r, reactionIndex), + init, getCode(types, reaction, r) + )); + // Now generate code for the late function, if there is one + // Note that this function can only be defined on reactions + // in federates that have inputs from a logical connection. + if (reaction.getStp() != null) { + code.pr(generateFunction( + generateStpFunctionHeader(r, reactionIndex), + init, reaction.getStp().getCode())); + } + + // Now generate code for the deadline violation function, if there is one. + if (reaction.getDeadline() != null) { + code.pr(generateFunction( + generateDeadlineFunctionHeader(r, reactionIndex), + init, reaction.getDeadline().getCode())); + } + CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(r), code); + code.pr( + "#include " + StringUtil.addDoubleQuotes( + CCoreFilesUtils.getCTargetSetUndefHeader())); + return code.toString(); + } + + private static Code getCode(CTypes types, Reaction r, ReactorDecl container) { + if (r.getCode() != null) return r.getCode(); + Code ret = LfFactory.eINSTANCE.createCode(); + var reactor = ASTUtils.toDefinition(container); + ret.setBody( + CReactorHeaderFileGenerator.nonInlineInitialization(r, reactor) + "\n" + + r.getName() + "( " + CReactorHeaderFileGenerator.reactionArguments(r, reactor) + " );"); + return ret; + } + + public static String generateFunction(String header, String init, Code code) { + var function = new CodeBuilder(); + function.pr(header + " {"); + function.indent(); + function.pr(init); + function.prSourceLineNumber(code); + function.pr(ASTUtils.toText(code)); + function.unindent(); + function.pr("}"); + return function.toString(); + } + + /** + * Returns the name of the deadline function for reaction. + * @param r The reactor with the deadline + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateDeadlineFunctionName(Reactor r, int reactionIndex) { + return CUtil.getName(r).toLowerCase() + "_deadline_function" + reactionIndex; + } + + /** + * Return the function name for specified reaction of the + * specified reactor. + * @param reactor The reactor + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionName(Reactor reactor, int reactionIndex) { + return CUtil.getName(reactor).toLowerCase() + "reaction_function_" + reactionIndex; + } + + /** + * Returns the name of the stp function for reaction. + * @param r The reactor with the stp + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateStpFunctionName(Reactor r, int reactionIndex) { + return CUtil.getName(r).toLowerCase() + "_STP_function" + reactionIndex; + } + + /** Return the top level C function header for the deadline function numbered "reactionIndex" in "r" + * @param r The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the deadline function. + */ + public static String generateDeadlineFunctionHeader(Reactor r, + int reactionIndex) { + String functionName = generateDeadlineFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } + + /** Return the top level C function header for the reaction numbered "reactionIndex" in "r" + * @param r The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionHeader(Reactor r, + int reactionIndex) { + String functionName = generateReactionFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } + + public static String generateStpFunctionHeader(Reactor r, + int reactionIndex) { + String functionName = generateStpFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } +>>>>>>> origin public static String generateStpFunctionHeader(ReactorDecl decl, int reactionIndex) { String functionName = generateStpFunctionName(decl, reactionIndex); diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java new file mode 100644 index 0000000000..68b05f656a --- /dev/null +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -0,0 +1,208 @@ +package org.lflang.generator.c; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.Objects; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import org.lflang.ASTUtils; +import org.lflang.generator.CodeBuilder; +import org.lflang.lf.Instantiation; +import org.lflang.lf.LfFactory; +import org.lflang.lf.Parameter; +import org.lflang.lf.Reaction; +import org.lflang.lf.Reactor; +import org.lflang.lf.StateVar; +import org.lflang.lf.TriggerRef; +import org.lflang.lf.TypedVariable; +import org.lflang.lf.VarRef; +import org.lflang.util.FileUtil; + +/** Generate user-visible header files. */ +public class CReactorHeaderFileGenerator { + + /** Functional interface for generating auxiliary structs such as port structs. */ + public interface GenerateAuxiliaryStructs { + void generate(CodeBuilder b, Reactor r, boolean userFacing); + } + + /** Return the path to the user-visible header file that would be generated for {@code r}. */ + public static Path outputPath(Reactor r) { + return Path.of(Path.of(r.eResource().getURI().toFileString()) + .getFileName().toString().replaceFirst("[.][^.]+$", "")) + .resolve(r.getName() + ".h"); + } + + /** Generate the user-visible header file for {@code r}. */ + public static void doGenerate(CTypes types, Reactor r, CFileConfig fileConfig, GenerateAuxiliaryStructs generator, Function topLevelPreamble) throws IOException { + String contents = generateHeaderFile(types, r, generator, topLevelPreamble.apply(r)); + FileUtil.writeToFile(contents, fileConfig.getIncludePath().resolve(outputPath(r))); + } + private static String generateHeaderFile(CTypes types, Reactor r, GenerateAuxiliaryStructs generator, String topLevelPreamble) { + CodeBuilder builder = new CodeBuilder(); + appendIncludeGuard(builder, r); + builder.pr(topLevelPreamble); + appendPoundIncludes(builder); + appendSelfStruct(builder, types, r); + generator.generate(builder, r, true); + for (Reaction reaction : r.getReactions()) { + appendSignature(builder, reaction, r); + } + builder.pr("#endif"); + return builder.getCode(); + } + + private static void appendIncludeGuard(CodeBuilder builder, Reactor r) { + String macro = CUtil.getName(r) + "_H"; + builder.pr("#ifndef " + macro); + builder.pr("#define " + macro); + } + private static void appendPoundIncludes(CodeBuilder builder) { + builder.pr(""" + #ifdef __cplusplus + extern "C" { + #endif + #include "../include/api/api.h" + #include "../include/api/set.h" + #include "../include/core/reactor.h" + #ifdef __cplusplus + } + #endif + """); + } + + /** The type name of the user-facing version of the self struct. */ + private static String userFacingSelfType(Reactor r) { + return r.getName().toLowerCase() + "_self_t"; + } + + private static void appendSelfStruct(CodeBuilder builder, CTypes types, Reactor r) { + builder.pr("typedef struct " + userFacingSelfType(r) + "{"); + for (Parameter p : r.getParameters()) { + builder.pr(types.getTargetType(p) + " " + p.getName() + ";"); + } + for (StateVar s : r.getStateVars()) { + builder.pr(types.getTargetType(s) + " " + s.getName() + ";"); + } + builder.pr("int end[0]; // placeholder; MSVC does not compile empty structs"); + builder.pr("} " + userFacingSelfType(r) + ";"); + } + + /** Generate the signature of the reaction function of {@code r}. */ + private static void appendSignature(CodeBuilder builder, Reaction r, Reactor reactor) { + if (r.getName() != null) builder.pr("void " + r.getName() + "(" + reactionParameters(r, reactor) + ");"); + } + /** Return a string representation of the parameters of the reaction function of {@code r}. */ + private static String reactionParameters(Reaction r, Reactor reactor) { + return Stream.concat(Stream.of(userFacingSelfType(reactor) + "* self"), portVariableStream(r, reactor) + .map(it -> it.getType(true) + " " + it.getName())) + .collect(Collectors.joining(", ")); + } + + /** Generate initialization code that is needed if {@code r} is not inlined. */ + public static String nonInlineInitialization(Reaction r, Reactor reactor) { + var mainDef = LfFactory.eINSTANCE.createInstantiation(); + mainDef.setName(reactor.getName()); + mainDef.setReactorClass(ASTUtils.findMainReactor(reactor.eResource())); + return portVariableStream(r, reactor) + .map(it -> it.container == null ? "" : it.getWidth() == null ? + String.format("%s %s = (%s) %s;", it.getType(false), it.getAlias(), it.getType(false), it.getRvalue()) + : String.format(""" + %s %s[%s]; + for (int i = 0; i < %s; i++) { + %s[i] = (%s) self->_lf_%s[i].%s; + } + """, + it.getType(true).replaceFirst("\\*", ""), + it.getAlias(), + CReactionGenerator.maxContainedReactorBankWidth( + reactor.getInstantiations().stream() + .filter(instantiation -> ASTUtils.toDefinition(instantiation.getReactorClass()).equals(it.r)) + .findAny().orElseThrow(), + null, 0, mainDef), + "self->_lf_"+it.container.getName()+"_width", + it.getAlias(), + it.getType(true).replaceFirst("\\*", ""), + it.container.getName(), + it.getName())) + .collect(Collectors.joining("\n")); + } + + /** Return a string representation of the arguments passed to the function for {@code r}. */ + public static String reactionArguments(Reaction r, Reactor reactor) { + return Stream.concat(Stream.of(getApiSelfStruct(reactor)), portVariableStream(r, reactor) + .map(it -> String.format("((%s) %s)", it.getType(true), it.getAlias()))) + .collect(Collectors.joining(", ")); + } + + /** Return code for extracting the user-facing part of the self struct from the self struct. */ + private static String getApiSelfStruct(Reactor reactor) { + return "(" + userFacingSelfType(reactor) + "*) (((char*) self) + sizeof(self_base_t))"; + } + + /** Return a stream of all ports referenced by the signature of {@code r}. */ + private static Stream portVariableStream(Reaction r, Reactor defaultReactorClass) { + return varRefStream(r) + .map(it -> it.getVariable() instanceof TypedVariable tv ? + new PortVariable( + tv, + ASTUtils.toDefinition(it.getContainer() == null ? defaultReactorClass : it.getContainer().getReactorClass()), + it.getContainer()) + : null) + .filter(Objects::nonNull); + } + + /** + * A variable that refers to a port. + * @param tv The variable of the variable reference. + * @param r The reactor that contains the port. + * @param container The {@code Instantiation} referenced in the obtaining of {@code tv}, if + * applicable; {@code null} otherwise. + */ + private record PortVariable(TypedVariable tv, Reactor r, Instantiation container) { + String getType(boolean userFacing) { + var typeName = container == null ? + CGenerator.variableStructType(tv, r, userFacing) + : CPortGenerator.localPortName(container.getReactorClass(), getName()); + var isMultiport = ASTUtils.isMultiport(ASTUtils.allPorts(r).stream() + .filter(it -> it.getName().equals(tv.getName())) + .findAny().orElseThrow()); + return typeName + "*" + (getWidth() != null ? "*" : "") + (isMultiport ? "*" : ""); + } + /** The name of the variable as it appears in the LF source. */ + String getName() { + return tv.getName(); + } + /** The alias of the variable that should be used in code generation. */ + String getAlias() { + return getName(); // TODO: avoid naming conflicts + } + /** The width of the container, if applicable. */ + String getWidth() { + return container == null || container.getWidthSpec() == null ? null : "self->_lf_"+r.getName()+"_width"; + } + /** The representation of this port as used by the LF programmer. */ + String getRvalue() { + return container == null ? getName() : container.getName() + "." + getName(); + } + } + + private static Stream inputVarRefStream(Reaction reaction) { + return varRefStream(Stream.concat(reaction.getTriggers().stream(), reaction.getSources().stream())); + } + + private static Stream varRefStream(Stream toFilter) { + return toFilter.map(it -> it instanceof VarRef v ? v : null) + .filter(Objects::nonNull); + } + + private static Stream outputVarRefStream(Reaction reaction) { + return reaction.getEffects().stream(); + } + + private static Stream varRefStream(Reaction reaction) { + return Stream.concat(inputVarRefStream(reaction), outputVarRefStream(reaction)); + } +} diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 411a0a464b..69e9ec30ae 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -38,6 +38,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Objects; import java.util.stream.Collectors; +import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.InferredType; @@ -146,11 +147,12 @@ public static String channelIndexName(PortInstance port) { * reactor is main (to allow for instantiations that have the same name as * the main reactor or the .lf file). */ - public static String getName(ReactorDecl reactor) { - if (reactor instanceof Reactor r && r.isMain()) { - return reactor.getName() + "_main"; + public static String getName(Reactor reactor) { + String name = reactor.getName().toLowerCase() + reactor.hashCode(); + if (reactor.isMain()) { + return name + "_main"; } - return reactor.getName(); + return name; } /** @@ -514,16 +516,16 @@ public static String runtimeIndex(ReactorInstance reactor) { * @param reactor The reactor class. * @return The type of a self struct for the specified reactor class. */ - public static String selfType(ReactorDecl reactor) { - if (reactor instanceof Reactor r && r.isMain()) { - return reactor.getName().toLowerCase() + "_main_self_t"; + public static String selfType(Reactor reactor) { + if (reactor.isMain()) { + return "_" + CUtil.getName(reactor) + "_main_self_t"; } - return reactor.getName().toLowerCase() + "_self_t"; + return "_" + CUtil.getName(reactor) + "_self_t"; } /** Construct a unique type for the "self" struct of the class of the given reactor. */ public static String selfType(ReactorInstance instance) { - return selfType(instance.getDefinition().getReactorClass()); + return selfType(ASTUtils.toDefinition(instance.getDefinition().getReactorClass())); } /** diff --git a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt index 45f6f10b0a..fb4f8605d2 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt @@ -100,41 +100,41 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { private fun declareTrigger(reaction: Reaction, trigger: TriggerRef): String = if (trigger is VarRef && trigger.variable is Port) { // if the trigger is a port, then it could be a multiport or contained in a bank - iterateOverAllPortsAndApply(trigger) { port: String -> "${reaction.name}.declare_trigger(&$port);" } + iterateOverAllPortsAndApply(trigger) { port: String -> "${reaction.codeName}.declare_trigger(&$port);" } } else { // treat as single trigger otherwise - "${reaction.name}.declare_trigger(&${trigger.name});" + "${reaction.codeName}.declare_trigger(&${trigger.name});" } private fun declareDependency(reaction: Reaction, dependency: VarRef): String { assert(dependency.variable is Port) // if the trigger is a port, then it could be a multiport or contained in a bank - return iterateOverAllPortsAndApply(dependency) { port: String -> "${reaction.name}.declare_dependency(&$port);" } + return iterateOverAllPortsAndApply(dependency) { port: String -> "${reaction.codeName}.declare_dependency(&$port);" } } private fun declareAntidependency(reaction: Reaction, antidependency: VarRef): String { val variable = antidependency.variable return if (variable is Port) { // if the trigger is a port, then it could be a multiport or contained in a bank - iterateOverAllPortsAndApply(antidependency) { port: String -> "${reaction.name}.declare_antidependency(&$port);" } + iterateOverAllPortsAndApply(antidependency) { port: String -> "${reaction.codeName}.declare_antidependency(&$port);" } } else { // treat as single antidependency otherwise - if (variable is Action) "${reaction.name}.declare_schedulable_action(&${antidependency.name});" - else "${reaction.name}.declare_antidependency(&${antidependency.name});" + if (variable is Action) "${reaction.codeName}.declare_schedulable_action(&${antidependency.name});" + else "${reaction.codeName}.declare_antidependency(&${antidependency.name});" } } private fun setDeadline(reaction: Reaction): String { val delay = reaction.deadline.delay val value = if (delay is ParameterReference) "__lf_inner.${delay.parameter.name}" else delay.toCppTime() - return "${reaction.name}.set_deadline($value, [this]() { ${reaction.name}_deadline_handler(); });" + return "${reaction.codeName}.set_deadline($value, [this]() { ${reaction.codeName}_deadline_handler(); });" } private fun assembleReaction(reaction: Reaction): String { val sources = reaction.sources.filter { it.variable is Port } return with(PrependOperator) { """ - |// ${reaction.name} + |// ${reaction.codeName} ${" |"..reaction.triggers.joinToString(separator = "\n") { declareTrigger(reaction, it) }} ${" |"..sources.joinToString(separator = "\n") { declareDependency(reaction, it) }} ${" |"..reaction.effects.joinToString(separator = "\n") { declareAntidependency(reaction, it) }} diff --git a/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt b/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt index f2386bf96a..2944cd3b67 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt @@ -45,7 +45,7 @@ import org.lflang.lf.WidthSpec */ /** Get the "name" a reaction is represented with in target code.*/ -val Reaction.name +val Reaction.codeName get(): String = "r$indexInContainer" /* ********************************************************************************************** diff --git a/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt index c1e66f3632..de34478723 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt @@ -67,8 +67,8 @@ class CppReactionGenerator( private fun Reaction.getAllReferencedVariablesForContainer(container: Instantiation) = allVariableReferences.filter { it.container == container }.distinct() - private fun Reaction.getViewClassName(container: Instantiation) = "__lf_view_of_${name}_on_${container.name}_t" - private fun Reaction.getViewInstanceName(container: Instantiation) = "__lf_view_of_${name}_on_${container.name}" + private fun Reaction.getViewClassName(container: Instantiation) = "__lf_view_of_${codeName}_on_${container.name}_t" + private fun Reaction.getViewInstanceName(container: Instantiation) = "__lf_view_of_${codeName}_on_${container.name}" private val VarRef.cppType get() = @@ -102,20 +102,20 @@ class CppReactionGenerator( allUncontainedSources.map { it.name } + allUncontainedEffects.map { it.name } + allReferencedContainers.map { getViewInstanceName(it) } - val body = "void ${name}_body() { __lf_inner.${name}_body(${parameters.joinToString(", ")}); }" + val body = "void ${codeName}_body() { __lf_inner.${codeName}_body(${parameters.joinToString(", ")}); }" val deadlineHandler = - "void ${name}_deadline_handler() { __lf_inner.${name}_deadline_handler(${parameters.joinToString(", ")}); }" + "void ${codeName}_deadline_handler() { __lf_inner.${codeName}_deadline_handler(${parameters.joinToString(", ")}); }" return if (deadline == null) """ $body - reactor::Reaction $name{"$label", $priority, this, [this]() { ${name}_body(); }}; + reactor::Reaction $codeName{"$label", $priority, this, [this]() { ${codeName}_body(); }}; """.trimIndent() else """ $body $deadlineHandler - reactor::Reaction $name{"$label", $priority, this, [this]() { ${name}_body(); }}; + reactor::Reaction $codeName{"$label", $priority, this, [this]() { ${codeName}_body(); }}; """.trimIndent() } } @@ -123,11 +123,11 @@ class CppReactionGenerator( private fun generateFunctionDeclaration(reaction: Reaction, postfix: String): String { val params = reaction.getBodyParameters() return when (params.size) { - 0 -> "void ${reaction.name}_$postfix();" - 1 -> "void ${reaction.name}_$postfix(${params[0]});" + 0 -> "void ${reaction.codeName}_$postfix();" + 1 -> "void ${reaction.codeName}_$postfix(${params[0]});" else -> with(PrependOperator) { """ - |void ${reaction.name}_$postfix( + |void ${reaction.codeName}_$postfix( ${" | "..params.joinToString(",\n")}); """.trimMargin() } @@ -137,11 +137,11 @@ class CppReactionGenerator( private fun getFunctionDefinitionSignature(reaction: Reaction, postfix: String): String { val params = reaction.getBodyParameters() return when (params.size) { - 0 -> "void ${reactor.templateName}::Inner::${reaction.name}_$postfix()" - 1 -> "void ${reactor.templateName}::Inner::${reaction.name}_$postfix(${params[0]})" + 0 -> "void ${reactor.templateName}::Inner::${reaction.codeName}_$postfix()" + 1 -> "void ${reactor.templateName}::Inner::${reaction.codeName}_$postfix(${params[0]})" else -> with(PrependOperator) { """ - |void ${reactor.templateName}::Inner::${reaction.name}_$postfix( + |void ${reactor.templateName}::Inner::${reaction.codeName}_$postfix( ${" | "..params.joinToString(",\n")}) """.trimMargin() } diff --git a/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java index f1a095403f..a2a149f522 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java @@ -1,13 +1,13 @@ package org.lflang.generator.python; import org.lflang.lf.Action; -import org.lflang.lf.ReactorDecl; +import org.lflang.lf.Reactor; import org.lflang.generator.c.CGenerator; public class PythonActionGenerator { - public static String generateAliasTypeDef(ReactorDecl decl, Action action, + public static String generateAliasTypeDef(Reactor r, Action action, String genericActionType) { - return "typedef "+genericActionType+" "+CGenerator.variableStructType(action, decl)+";"; + return "typedef "+genericActionType+" "+CGenerator.variableStructType(action, r, false)+";"; } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 442afd79f3..24e1a4f55b 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -34,6 +34,11 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; +<<<<<<< HEAD +======= + +import org.eclipse.emf.ecore.EObject; +>>>>>>> origin import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; import org.lflang.ASTUtils; @@ -52,6 +57,7 @@ import org.lflang.generator.c.CGenerator; import org.lflang.generator.c.CUtil; import org.lflang.lf.Action; +import org.lflang.lf.Code; import org.lflang.lf.Input; import org.lflang.lf.Model; import org.lflang.lf.Output; @@ -246,6 +252,7 @@ public String generateDirectives() { code.pr( PythonPreambleGenerator.generateCDefineDirectives( targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); +<<<<<<< HEAD code.pr( PythonPreambleGenerator.generateCIncludeStatements( targetConfig, targetLanguageIsCpp(), hasModalReactors)); @@ -411,6 +418,34 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { } System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); +======= + return code.toString(); + } + + /** + * Override generate top-level preambles, but put the user preambles in the + * .py file rather than the C file. Also handles including the federated + * execution setup preamble specified in the target config. + */ + @Override + protected String generateTopLevelPreambles(Reactor ignored) { + // user preambles + Set models = new LinkedHashSet<>(); + for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { + // The following assumes all reactors have a container. + // This means that generated reactors **have** to be + // added to a resource; not doing so will result in a NPE. + models.add((Model) ASTUtils.toDefinition(r).eContainer()); + } + // Add the main reactor if it is defined + if (this.mainDef != null) { + models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); + } + for (Model m : models) { + pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); + } + return PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors); +>>>>>>> origin } if (errorReporter.getErrorsOccurred()) { @@ -448,6 +483,7 @@ protected void generateReaction(Reaction reaction, ReactorDecl decl, int reactio reaction, decl, reactionIndex, mainDef, errorReporter, types)); } +<<<<<<< HEAD /** * Generate code that initializes the state variables for a given instance. Unlike parameters, * state variables are uniformly initialized for all instances of the same reactor. This task is @@ -537,9 +573,30 @@ protected void generateSelfStructExtension( + ";"); } reactionIndex++; +======= + /** + * Generate the aliases for inputs, outputs, and struct type definitions for + * actions of the specified reactor in the specified federate. + * @param r The parsed reactor data structure. + */ + @Override + public void generateAuxiliaryStructs( + CodeBuilder builder, Reactor r, boolean userFacing + ) { + for (Input input : ASTUtils.allInputs(r)) { + generateAuxiliaryStructsForPort(builder, r, input); + } + for (Output output : ASTUtils.allOutputs(r)) { + generateAuxiliaryStructsForPort(builder, r, output); + } + for (Action action : ASTUtils.allActions(r)) { + generateAuxiliaryStructsForAction(builder, r, action); + } +>>>>>>> origin } } +<<<<<<< HEAD @Override protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { // NOTE: Strangely, a newline is needed at the beginning or indentation @@ -556,20 +613,246 @@ protected void setUpGeneralParameters() { super.setUpGeneralParameters(); if (hasModalReactors) { targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); +======= + private void generateAuxiliaryStructsForPort(CodeBuilder builder, Reactor r, + Port port) { + boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); + builder.pr(port, + PythonPortGenerator.generateAliasTypeDef(r, port, isTokenType, + genericPortType)); +>>>>>>> origin } } +<<<<<<< HEAD @Override protected void additionalPostProcessingForModes() { if (!hasModalReactors) { return; +======= + private void generateAuxiliaryStructsForAction(CodeBuilder builder, Reactor r, + Action action) { + builder.pr(action, PythonActionGenerator.generateAliasTypeDef(r, action, genericActionType)); +>>>>>>> origin } PythonModeGenerator.generateResetReactionsIfNeeded(reactors); } +<<<<<<< HEAD private static String setUpMainTarget( boolean hasMain, String executableName, Stream cSources) { return (""" +======= + /** + * Return true if the host operating system is compatible and + * otherwise report an error and return false. + */ + @Override + public boolean isOSCompatible() { + return true; + } + + /** + * Generate C code from the Lingua Franca model contained by the + * specified resource. This is the main entry point for code + * generation. + * + * @param resource The resource containing the source code. + * @param context Context relating to invocation of the code generator. + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + // Set the threading to false by default, unless the user has + // specifically asked for it. + if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = false; + } + int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; + code.pr(PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors)); + super.doGenerate(resource, new SubContext( + context, + IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, + cGeneratedPercentProgress + )); + + if (errorsOccurred()) { + context.unsuccessfulFinish(); + return; + } + + Map codeMaps = new HashMap<>(); + var lfModuleName = fileConfig.name; + // Don't generate code if there is no main reactor + if (this.main != null) { + try { + Map codeMapsForFederate = generatePythonFiles(lfModuleName, generatePythonModuleName(lfModuleName), generatePythonFileName(lfModuleName)); + codeMaps.putAll(codeMapsForFederate); + copyTargetFiles(); + new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); + if (targetConfig.noCompile) { + System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); + } + } catch (Exception e) { + //noinspection ConstantConditions + throw Exceptions.sneakyThrow(e); + } + + System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); + } + + if (errorReporter.getErrorsOccurred()) { + context.unsuccessfulFinish(); + } else { + context.finish(GeneratorResult.Status.COMPILED, codeMaps); + } + } + + @Override + protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new PythonDockerGenerator(context); + } + + /** Generate a reaction function definition for a reactor. + * This function has a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + @Override + protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { + Reactor reactor = ASTUtils.toDefinition(r); + + // Reactions marked with a `@_c_body` attribute are generated in C + if (AttributeUtils.hasCBody(reaction)) { + super.generateReaction(src, reaction, r, reactionIndex); + return; + } + src.pr(PythonReactionGenerator.generateCReaction(reaction, reactor, reactionIndex, mainDef, errorReporter, types)); + } + + /** + * Generate code that initializes the state variables for a given instance. + * Unlike parameters, state variables are uniformly initialized for all + * instances + * of the same reactor. This task is left to Python code to allow for more + * liberal + * state variable assignments. + * + * @param instance The reactor class instance + * @return Initialization code fore state variables of instance + */ + @Override + protected void generateStateVariableInitializations(ReactorInstance instance) { + // Do nothing + } + + /** + * Generate runtime initialization code in C for parameters of a given + * reactor instance + * + * @param instance The reactor instance. + */ + @Override + protected void generateParameterInitialization(ReactorInstance instance) { + // Do nothing + // Parameters are initialized in Python + } + + /** + * Do nothing. + * Methods are generated in Python not C. + * @see PythonMethodGenerator + */ + @Override + protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { } + + /** + * Generate C preambles defined by user for a given reactor + * Since the Python generator expects preambles written in C, + * this function is overridden and does nothing. + * + * @param reactor The given reactor + */ + @Override + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + // Do nothing + } + + /** + * Generate code that is executed while the reactor instance is being + * initialized. + * This wraps the reaction functions in a Python function. + * @param instance The reactor instance. + */ + @Override + protected void generateReactorInstanceExtension( + ReactorInstance instance + ) { + initializeTriggerObjects.pr(PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); + } + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the self struct + * @param selfStructBody The body of the self struct + * @param decl The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + @Override + protected void generateSelfStructExtension( + CodeBuilder selfStructBody, + ReactorDecl decl, + CodeBuilder constructorCode + ) { + Reactor reactor = ASTUtils.toDefinition(decl); + // Add the name field + selfStructBody.pr("char *_lf_name;"); + int reactionIndex = 0; + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create a PyObject for each reaction + selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex)+";"); + if (reaction.getStp() != null) { + selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex)+";"); + } + if (reaction.getDeadline() != null) { + selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex)+";"); + } + reactionIndex++; + } + } + + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + // NOTE: Strangely, a newline is needed at the beginning or indentation + // gets swallowed. + return String.join("\n", + "\n# Generated forwarding reaction for connections with the same destination", + "# but located in mutually exclusive modes.", + dest + ".set(" + source + ".value)\n" + ); + } + + @Override + protected void setUpGeneralParameters() { + super.setUpGeneralParameters(); + if (hasModalReactors) { + targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); + } + } + + @Override + protected void additionalPostProcessingForModes() { + if (!hasModalReactors) { + return; + } + PythonModeGenerator.generateResetReactionsIfNeeded(reactors); + } + + private static String setUpMainTarget(boolean hasMain, String executableName, Stream cSources) { + return ( + """ +>>>>>>> origin set(CMAKE_POSITION_INDEPENDENT_CODE ON) add_compile_definitions(_LF_GARBAGE_COLLECTED) add_subdirectory(core) diff --git a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java index 2c7512b499..9e0919b52c 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java @@ -5,6 +5,7 @@ import org.lflang.lf.Output; import org.lflang.lf.Port; import org.lflang.lf.Action; +import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.VarRef; import java.util.List; @@ -194,8 +195,8 @@ public static String generatePythonListForContainedBank(String reactorName, Port ); } - public static String generateAliasTypeDef(ReactorDecl decl, Port port, boolean isTokenType, String genericPortType) { - return "typedef "+genericPortType+" "+CGenerator.variableStructType(port, decl)+";"; + public static String generateAliasTypeDef(Reactor r, Port port, boolean isTokenType, String genericPortType) { + return "typedef "+genericPortType+" "+CGenerator.variableStructType(port, r, false)+";"; } private static String generateConvertCPortToPy(String port) { diff --git a/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java index 5fa8aff84f..e2fd7af86a 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java @@ -55,7 +55,7 @@ public static String generateCIncludeStatements( code.pr(CPreambleGenerator.generateIncludeStatements(targetConfig, CCppMode)); code.pr("#include \"pythontarget.h\""); if (hasModalReactors) { - code.pr("#include \"modal_models/definitions.h\""); + code.pr("#include \"include/modal_models/definitions.h\""); } return code.toString(); } diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java index 77f7352f08..bcc1beeaed 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java @@ -34,49 +34,46 @@ public class PythonReactionGenerator { /** - * Generate code to call reaction numbered "reactionIndex" in reactor "decl". - * @param decl The reactor containing the reaction + * Generate code to call reaction numbered "reactionIndex" in reactor "reactor". + * @param reactor The reactor containing the reaction * @param reactionIndex The index of the reaction - * @param pyObjectDescriptor CPython related descriptors for each object in "pyObjects". * @param pyObjects CPython related objects */ - public static String generateCPythonReactionCaller(ReactorDecl decl, + public static String generateCPythonReactionCaller(Reactor reactor, int reactionIndex, List pyObjects, String inits) { String pythonFunctionName = generatePythonReactionFunctionName(reactionIndex); String cpythonFunctionName = generateCPythonReactionFunctionName(reactionIndex); - return generateCPythonFunctionCaller(decl.getName(), pythonFunctionName, cpythonFunctionName, pyObjects, inits); + return generateCPythonFunctionCaller(CUtil.getName(reactor), pythonFunctionName, cpythonFunctionName, pyObjects, inits); } /** - * Generate code to call deadline function numbered "reactionIndex" in reactor "decl". - * @param decl The reactor containing the reaction + * Generate code to call deadline function numbered "reactionIndex" in reactor "r". + * @param r The reactor containing the reaction * @param reactionIndex The index of the reaction - * @param pyObjectDescriptor CPython related descriptors for each object in "pyObjects". * @param pyObjects CPython related objects */ - public static String generateCPythonDeadlineCaller(ReactorDecl decl, + public static String generateCPythonDeadlineCaller(Reactor r, int reactionIndex, List pyObjects) { String pythonFunctionName = generatePythonDeadlineFunctionName(reactionIndex); String cpythonFunctionName = generateCPythonDeadlineFunctionName(reactionIndex); - return generateCPythonFunctionCaller(decl.getName(), pythonFunctionName, cpythonFunctionName, pyObjects, ""); + return generateCPythonFunctionCaller(CUtil.getName(r), pythonFunctionName, cpythonFunctionName, pyObjects, ""); } /** - * Generate code to call deadline function numbered "reactionIndex" in reactor "decl". - * @param decl The reactor containing the reaction + * Generate code to call deadline function numbered "reactionIndex" in reactor "r". + * @param r The reactor containing the reaction * @param reactionIndex The index of the reaction - * @param pyObjectDescriptor CPython related descriptors for each object in "pyObjects". * @param pyObjects CPython related objects */ - public static String generateCPythonSTPCaller(ReactorDecl decl, + public static String generateCPythonSTPCaller(Reactor r, int reactionIndex, List pyObjects) { String pythonFunctionName = generatePythonSTPFunctionName(reactionIndex); String cpythonFunctionName = generateCPythonSTPFunctionName(reactionIndex); - return generateCPythonFunctionCaller(decl.getName(), pythonFunctionName, cpythonFunctionName, pyObjects, ""); + return generateCPythonFunctionCaller(CUtil.getName(r), pythonFunctionName, cpythonFunctionName, pyObjects, ""); } /** @@ -122,7 +119,7 @@ private static String generateCPythonFunctionCaller(String reactorDeclName, * Generate the reaction in the .c file, which calls the Python reaction through the CPython interface. * * @param reaction The reaction to generate Python-specific initialization for. - * @param decl The reactor to which reaction belongs to. + * @param r The reactor to which reaction belongs to. * @param reactionIndex The index number of the reaction in decl. * @param mainDef The main reactor. * @param errorReporter An error reporter. @@ -130,7 +127,7 @@ private static String generateCPythonFunctionCaller(String reactorDeclName, */ public static String generateCReaction( Reaction reaction, - ReactorDecl decl, + Reactor r, int reactionIndex, Instantiation mainDef, ErrorReporter errorReporter, @@ -140,34 +137,34 @@ public static String generateCReaction( // Each input must be cast to (PyObject *) (aka their descriptors for Py_BuildValue are "O") List pyObjects = new ArrayList<>(); CodeBuilder code = new CodeBuilder(); - String cPyInit = generateCPythonInitializers(reaction, decl, pyObjects, errorReporter); + String cPyInit = generateCPythonInitializers(reaction, r, pyObjects, errorReporter); String cInit = CReactionGenerator.generateInitializationForReaction( - "", reaction, decl, reactionIndex, + "", reaction, r, reactionIndex, types, errorReporter, mainDef, Target.Python.requiresTypes); code.pr( "#include " + StringUtil.addDoubleQuotes( CCoreFilesUtils.getCTargetSetHeader())); code.pr(generateFunction( - CReactionGenerator.generateReactionFunctionHeader(decl, reactionIndex), + CReactionGenerator.generateReactionFunctionHeader(r, reactionIndex), cInit, reaction.getCode(), - generateCPythonReactionCaller(decl, reactionIndex, pyObjects, cPyInit) + generateCPythonReactionCaller(r, reactionIndex, pyObjects, cPyInit) )); // Generate code for the STP violation handler, if there is one. if (reaction.getStp() != null) { code.pr(generateFunction( - CReactionGenerator.generateStpFunctionHeader(decl, reactionIndex), + CReactionGenerator.generateStpFunctionHeader(r, reactionIndex), cInit, reaction.getStp().getCode(), - generateCPythonSTPCaller(decl, reactionIndex, pyObjects) + generateCPythonSTPCaller(r, reactionIndex, pyObjects) )); } // Generate code for the deadline violation function, if there is one. if (reaction.getDeadline() != null) { code.pr(generateFunction( - CReactionGenerator.generateDeadlineFunctionHeader(decl, reactionIndex), + CReactionGenerator.generateDeadlineFunctionHeader(r, reactionIndex), cInit, reaction.getDeadline().getCode(), - generateCPythonDeadlineCaller(decl, reactionIndex, pyObjects) + generateCPythonDeadlineCaller(r, reactionIndex, pyObjects) )); } code.pr( diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java index 5778791f76..fd954ca956 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java @@ -34,7 +34,7 @@ public static String generatePythonClass(ReactorInstance instance, CodeBuilder pythonClasses = new CodeBuilder(); ReactorDecl decl = instance.getDefinition().getReactorClass(); Reactor reactor = ASTUtils.toDefinition(decl); - String className = PyUtil.getName(decl); + String className = PyUtil.getName(reactor); if (instantiatedClasses == null) { return ""; } @@ -113,7 +113,7 @@ public static String generatePythonClassInstantiations(ReactorInstance instance, ReactorInstance main) { CodeBuilder code = new CodeBuilder(); - String className = PyUtil.getName(instance.reactorDeclaration); + String className = PyUtil.getName(instance.reactorDefinition); if (instance.getWidth() > 0) { // For each reactor instance, create a list regardless of whether it is a bank or not. diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 61fa3d8816..d4d34c7b08 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -455,15 +455,20 @@ public static boolean isCFile(Path path) { * @param dir The folder to search for includes to change. * @throws IOException If the given set of files cannot be relativized. */ - public static void relativeIncludeHelper(Path dir) throws IOException { + public static void relativeIncludeHelper(Path dir, Path includePath) throws IOException { System.out.println("Relativizing all includes in " + dir.toString()); - List allPaths = Files.walk(dir) + List includePaths = Files.walk(includePath) + .filter(Files::isRegularFile) + .filter(FileUtil::isCFile) + .sorted(Comparator.reverseOrder()) + .collect(Collectors.toList()); + List srcPaths = Files.walk(dir) .filter(Files::isRegularFile) .filter(FileUtil::isCFile) .sorted(Comparator.reverseOrder()) .collect(Collectors.toList()); Map fileStringToFilePath = new HashMap(); - for (Path path : allPaths) { + for (Path path : includePaths) { String fileName = path.getFileName().toString(); if (path.getFileName().toString().contains("CMakeLists.txt")) continue; if (fileStringToFilePath.put(fileName, path) != null) { @@ -471,7 +476,7 @@ public static void relativeIncludeHelper(Path dir) throws IOException { } } Pattern regexExpression = Pattern.compile("#include\s+[\"]([^\"]+)*[\"]"); - for (Path path : allPaths) { + for (Path path : srcPaths) { String fileName = path.getFileName().toString(); String fileContents = Files.readString(path); Matcher matcher = regexExpression.matcher(fileContents); diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 2d0d4f332b..928466da91 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -196,6 +196,7 @@ public void checkBracedExpression(BracedListExpression expr) { @Check(CheckType.FAST) public void checkAssignment(Assignment assignment) { +<<<<<<< HEAD // If the left-hand side is a time parameter, make sure the assignment has units typeCheck( assignment.getRhs(), @@ -209,6 +210,171 @@ public void checkAssignment(Assignment assignment) { + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", Literals.ASSIGNMENT__RHS); +======= + // Report if connection is part of a cycle. + Set> cycles = this.info.topologyCycles(); + for (VarRef lp : connection.getLeftPorts()) { + for (VarRef rp : connection.getRightPorts()) { + boolean leftInCycle = false; + + for (NamedInstance it : cycles) { + if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) + || (it.getDefinition().equals(lp.getVariable()) && it.getParent().equals(lp.getContainer()))) { + leftInCycle = true; + break; + } + } + + for (NamedInstance it : cycles) { + if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) + || (it.getDefinition().equals(rp.getVariable()) && it.getParent().equals(rp.getContainer()))) { + if (leftInCycle) { + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + String reactorName = reactor.getName(); + error(String.format("Connection in reactor %s creates", reactorName) + + String.format("a cyclic dependency between %s and %s.", toOriginalText(lp), toOriginalText(rp)), + Literals.CONNECTION__DELAY); + } + } + } + } + } + + // FIXME: look up all ReactorInstance objects that have a definition equal to the + // container of this connection. For each of those occurrences, the widths have to match. + // For the C target, since C has such a weak type system, check that + // the types on both sides of every connection match. For other languages, + // we leave type compatibility that language's compiler or interpreter. + if (isCBasedTarget()) { + Type type = (Type) null; + for (VarRef port : connection.getLeftPorts()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + // Unfortunately, xtext does not generate a suitable equals() + // method for AST types, so we have to manually check the types. + if (!sameType(type, ((Port) port.getVariable()).getType())) { + error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); + } + } + } + } + for (VarRef port : connection.getRightPorts()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + if (!sameType(type, type = ((Port) port.getVariable()).getType())) { + error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); + } + } + } + } + } + + // Check whether the total width of the left side of the connection + // matches the total width of the right side. This cannot be determined + // here if the width is not given as a constant. In that case, it is up + // to the code generator to check it. + int leftWidth = 0; + for (VarRef port : connection.getLeftPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || leftWidth < 0) { + // Cannot determine the width of the left ports. + leftWidth = -1; + } else { + leftWidth += width; + } + } + int rightWidth = 0; + for (VarRef port : connection.getRightPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || rightWidth < 0) { + // Cannot determine the width of the left ports. + rightWidth = -1; + } else { + rightWidth += width; + } + } + + if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { + if (connection.isIterated()) { + if (leftWidth == 0 || rightWidth % leftWidth != 0) { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning(String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS + ); + } + } else { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning(String.format("Left width %s does not match right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS + ); + } + } + + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + + // Make sure the right port is not already an effect of a reaction. + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + for (VarRef effect : reaction.getEffects()) { + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort.getVariable().equals(effect.getVariable()) && // Refers to the same variable + rightPort.getContainer() == effect.getContainer() && // Refers to the same instance + ( reaction.eContainer() instanceof Reactor || // Either is not part of a mode + connection.eContainer() instanceof Reactor || + connection.eContainer() == reaction.eContainer() // Or they are in the same mode + )) { + error("Cannot connect: Port named '" + effect.getVariable().getName() + + "' is already effect of a reaction.", + Literals.CONNECTION__RIGHT_PORTS); + } + } + } + } + + // Check that the right port does not already have some other + // upstream connection. + for (Connection c : reactor.getConnections()) { + if (c != connection) { + for (VarRef thisRightPort : connection.getRightPorts()) { + for (VarRef thatRightPort : c.getRightPorts()) { + if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) && // Refers to the same variable + thisRightPort.getContainer() == thatRightPort.getContainer() && // Refers to the same instance + ( connection.eContainer() instanceof Reactor || // Or either of the connections in not part of a mode + c.eContainer() instanceof Reactor || + connection.eContainer() == c.eContainer() // Or they are in the same mode + )) { + error( + "Cannot connect: Port named '" + thisRightPort.getVariable().getName() + + "' may only appear once on the right side of a connection.", + Literals.CONNECTION__RIGHT_PORTS); + } + } + } + } + } + + // Check the after delay + if (connection.getDelay() != null) { + final var delay = connection.getDelay(); + if (delay instanceof ParameterReference || delay instanceof Time || delay instanceof Literal) { + checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); + } else { + error("After delays can only be given by time literals or parameters.", + Literals.CONNECTION__DELAY); + } + } +>>>>>>> origin } } @@ -221,6 +387,348 @@ public void checkConnection(Connection connection) { for (VarRef rp : connection.getRightPorts()) { boolean leftInCycle = false; +<<<<<<< HEAD +======= + @Check + public void checkImport(Import imp) { + if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { + error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. + return; + } + + // FIXME: report error if resource cannot be resolved. + for (ImportedReactor reactor : imp.getReactorClasses()) { + if (!isUnused(reactor)) { + return; + } + } + warning("Unused import.", Literals.IMPORT__IMPORT_URI); + } + + @Check + public void checkImportedReactor(ImportedReactor reactor) { + if (isUnused(reactor)) { + warning("Unused reactor class.", + Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } + + if (info.instantiationGraph.hasCycles()) { + Set cycleSet = new HashSet<>(); + for (Set cycle : info.instantiationGraph.getCycles()) { + cycleSet.addAll(cycle); + } + if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { + error("Imported reactor '" + toDefinition(reactor).getName() + + "' has cyclic instantiation in it.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } + } + } + + @Check(CheckType.FAST) + public void checkInput(Input input) { + Reactor parent = (Reactor)input.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); + } + checkName(input.getName(), Literals.VARIABLE__NAME); + if (target.requiresTypes) { + if (input.getType() == null) { + error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); + } + } + + // mutable has no meaning in C++ + if (input.isMutable() && this.target == Target.CPP) { + warning( + "The mutable qualifier has no meaning for the C++ target and should be removed. " + + "In C++, any value can be made mutable by calling get_mutable_copy().", + Literals.INPUT__MUTABLE + ); + } + + // Variable width multiports are not supported (yet?). + if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } + } + + @Check(CheckType.FAST) + public void checkInstantiation(Instantiation instantiation) { + checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); + Reactor reactor = toDefinition(instantiation.getReactorClass()); + if (reactor.isMain() || reactor.isFederated()) { + error( + "Cannot instantiate a main (or federated) reactor: " + + instantiation.getReactorClass().getName(), + Literals.INSTANTIATION__REACTOR_CLASS + ); + } + + // Report error if this instantiation is part of a cycle. + // FIXME: improve error message. + // FIXME: Also report if there exists a cycle within. + if (this.info.instantiationGraph.getCycles().size() > 0) { + for (Set cycle : this.info.instantiationGraph.getCycles()) { + Reactor container = (Reactor) instantiation.eContainer(); + if (cycle.contains(container) && cycle.contains(reactor)) { + List names = new ArrayList<>(); + for (Reactor r : cycle) { + names.add(r.getName()); + } + + error( + "Instantiation is part of a cycle: " + String.join(", ", names) + ".", + Literals.INSTANTIATION__REACTOR_CLASS + ); + } + } + } + // Variable width multiports are not supported (yet?). + if (instantiation.getWidthSpec() != null + && instantiation.getWidthSpec().isOfVariableLength() + ) { + if (isCBasedTarget()) { + warning("Variable-width banks are for internal use only.", + Literals.INSTANTIATION__WIDTH_SPEC + ); + } else { + error("Variable-width banks are not supported.", + Literals.INSTANTIATION__WIDTH_SPEC + ); + } + } + } + + /** Check target parameters, which are key-value pairs. */ + @Check(CheckType.FAST) + public void checkKeyValuePair(KeyValuePair param) { + // Check only if the container's container is a Target. + if (param.eContainer().eContainer() instanceof TargetDecl) { + TargetProperty prop = TargetProperty.forName(param.getName()); + + // Make sure the key is valid. + if (prop == null) { + String options = TargetProperty.getOptions().stream() + .map(p -> p.description).sorted() + .collect(Collectors.joining(", ")); + warning( + "Unrecognized target parameter: " + param.getName() + + ". Recognized parameters are: " + options, + Literals.KEY_VALUE_PAIR__NAME); + } else { + // Check whether the property is supported by the target. + if (!prop.supportedBy.contains(this.target)) { + warning( + "The target parameter: " + param.getName() + + " is not supported by the " + this.target + + " target and will thus be ignored.", + Literals.KEY_VALUE_PAIR__NAME); + } + + // Report problem with the assigned value. + prop.type.check(param.getValue(), param.getName(), this); + } + + for (String it : targetPropertyErrors) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyErrors.clear(); + + for (String it : targetPropertyWarnings) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyWarnings.clear(); + } + } + + @Check(CheckType.FAST) + public void checkModel(Model model) { + // Since we're doing a fast check, we only want to update + // if the model info hasn't been initialized yet. If it has, + // we use the old information and update it during a normal + // check (see below). + if (!info.updated) { + info.update(model, errorReporter); + } + } + + @Check(CheckType.NORMAL) + public void updateModelInfo(Model model) { + info.update(model, errorReporter); + } + + @Check(CheckType.FAST) + public void checkOutput(Output output) { + Reactor parent = (Reactor)output.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); + } + checkName(output.getName(), Literals.VARIABLE__NAME); + if (this.target.requiresTypes) { + if (output.getType() == null) { + error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); + } + } + + // Variable width multiports are not supported (yet?). + if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } + } + + @Check(CheckType.FAST) + public void checkParameter(Parameter param) { + checkName(param.getName(), Literals.PARAMETER__NAME); + + if (param.getInit() == null) { + // todo make initialization non-mandatory + // https://github.com/lf-lang/lingua-franca/issues/623 + error("Parameter must have a default value.", Literals.PARAMETER__INIT); + return; + } + + if (this.target.requiresTypes) { + // Report missing target type. param.inferredType.undefine + if (ASTUtils.getInferredType(param).isUndefined()) { + error("Type declaration missing.", Literals.PARAMETER__TYPE); + } + } + + if (param.getType() != null) { + typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); + } + + if (param.getInit() != null) { + for (Expression expr : param.getInit().getExprs()) { + if (expr instanceof ParameterReference) { + // Initialization using parameters is forbidden. + error("Parameter cannot be initialized using parameter.", + Literals.PARAMETER__INIT); + } + } + } + + if (this.target == Target.CPP) { + EObject container = param.eContainer(); + Reactor reactor = (Reactor) container; + if (reactor.isMain()) { + // we need to check for the cli parameters that are always taken + List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); + if (cliParams.contains(param.getName())) { + error("Parameter '" + param.getName() + + "' is already in use as command line argument by Lingua Franca,", + Literals.PARAMETER__NAME); + } + } + } + + if (isCBasedTarget() && + this.info.overflowingParameters.contains(param)) { + error( + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.PARAMETER__INIT); + } + + } + + @Check(CheckType.FAST) + public void checkPreamble(Preamble preamble) { + if (this.target == Target.CPP) { + if (preamble.getVisibility() == Visibility.NONE) { + error( + "Preambles for the C++ target need a visibility qualifier (private or public)!", + Literals.PREAMBLE__VISIBILITY + ); + } else if (preamble.getVisibility() == Visibility.PRIVATE) { + EObject container = preamble.eContainer(); + if (container != null && container instanceof Reactor) { + Reactor reactor = (Reactor) container; + if (isGeneric(reactor)) { + warning( + "Private preambles in generic reactors are not truly private. " + + "Since the generated code is placed in a *_impl.hh file, it will " + + "be visible on the public interface. Consider using a public " + + "preamble within the reactor or a private preamble on file scope.", + Literals.PREAMBLE__VISIBILITY); + } + } + } + } else if (preamble.getVisibility() != Visibility.NONE) { + warning( + String.format("The %s qualifier has no meaning for the %s target. It should be removed.", + preamble.getVisibility(), this.target.name()), + Literals.PREAMBLE__VISIBILITY + ); + } + } + + @Check(CheckType.FAST) + public void checkReaction(Reaction reaction) { + + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); + } + HashSet triggers = new HashSet<>(); + // Make sure input triggers have no container and output sources do. + for (TriggerRef trigger : reaction.getTriggers()) { + if (trigger instanceof VarRef) { + VarRef triggerVarRef = (VarRef) trigger; + triggers.add(triggerVarRef.getVariable()); + if (triggerVarRef instanceof Input) { + if (triggerVarRef.getContainer() != null) { + error(String.format("Cannot have an input of a contained reactor as a trigger: %s.%s", triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } + } else if (triggerVarRef.getVariable() instanceof Output) { + if (triggerVarRef.getContainer() == null) { + error(String.format("Cannot have an output of this reactor as a trigger: %s", triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } + } + } + } + + // Make sure input sources have no container and output sources do. + // Also check that a source is not already listed as a trigger. + for (VarRef source : reaction.getSources()) { + if (triggers.contains(source.getVariable())) { + error(String.format("Source is already listed as a trigger: %s", source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + if (source.getVariable() instanceof Input) { + if (source.getContainer() != null) { + error(String.format("Cannot have an input of a contained reactor as a source: %s.%s", source.getContainer().getName(), source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } else if (source.getVariable() instanceof Output) { + if (source.getContainer() == null) { + error(String.format("Cannot have an output of this reactor as a source: %s", source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } + } + + // Make sure output effects have no container and input effects do. + for (VarRef effect : reaction.getEffects()) { + if (effect.getVariable() instanceof Input) { + if (effect.getContainer() == null) { + error(String.format("Cannot have an input of this reactor as an effect: %s", effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } else if (effect.getVariable() instanceof Output) { + if (effect.getContainer() != null) { + error(String.format("Cannot have an output of a contained reactor as an effect: %s.%s", effect.getContainer().getName(), effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } + } + + // // Report error if this reaction is part of a cycle. + Set> cycles = this.info.topologyCycles(); + Reactor reactor = ASTUtils.getEnclosingReactor(reaction); + boolean reactionInCycle = false; +>>>>>>> origin for (NamedInstance it : cycles) { if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) || (it.getDefinition().equals(lp.getVariable()) @@ -927,12 +1435,33 @@ public void checkReactor(Reactor reactor) throws IOException { } } +<<<<<<< HEAD // Check for illegal names. checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); // C++ reactors may not be called 'preamble' if (this.target == Target.CPP && reactor.getName().equalsIgnoreCase("preamble")) { error("Reactor cannot be named '" + reactor.getName() + "'", Literals.REACTOR_DECL__NAME); +======= + /** + * Check if the requested serialization is supported. + */ + @Check(CheckType.FAST) + public void checkSerializer(Serializer serializer) { + boolean isValidSerializer = false; + for (SupportedSerializers method : SupportedSerializers.values()) { + if (method.name().equalsIgnoreCase(serializer.getType())){ + isValidSerializer = true; + } + } + + if (!isValidSerializer) { + error( + "Serializer can be " + Arrays.asList(SupportedSerializers.values()), + Literals.SERIALIZER__TYPE + ); + } +>>>>>>> origin } if (reactor.getHost() != null) { @@ -1248,6 +1777,7 @@ public void checkAttributes(Attribute attr) { spec.check(this, attr); } +<<<<<<< HEAD @Check(CheckType.FAST) public void checkWidthSpec(WidthSpec widthSpec) { if (!this.target.supportsMultiports()) { @@ -1272,6 +1802,75 @@ public void checkWidthSpec(WidthSpec widthSpec) { } } else if (term.getWidth() < 0) { error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); +======= + /** + * Check whether an attribute is supported + * and the validity of the attribute. + * + * @param attr The attribute being checked + */ + @Check(CheckType.FAST) + public void checkAttributes(Attribute attr) { + String name = attr.getAttrName().toString(); + AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); + if (spec == null) { + error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); + return; + } + // Check the validity of the attribute. + spec.check(this, attr); + } + + @Check(CheckType.FAST) + public void checkWidthSpec(WidthSpec widthSpec) { + if (!this.target.supportsMultiports()) { + error("Multiports and banks are currently not supported by the given target.", + Literals.WIDTH_SPEC__TERMS); + } else { + for (WidthTerm term : widthSpec.getTerms()) { + if (term.getParameter() != null) { + if (!this.target.supportsParameterizedWidths()) { + error("Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); + } + } else if (term.getPort() != null) { + // Widths given with `widthof()` are not supported (yet?). + // This feature is currently only used for after delays. + error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); + } else if (term.getCode() != null) { + if (this.target != Target.CPP) { + error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); + } + } else if (term.getWidth() < 0) { + error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); + } + } + } + } + + @Check(CheckType.FAST) + public void checkReactorIconAttribute(Reactor reactor) { + var path = AttributeUtils.getIconPath(reactor); + if (path != null) { + var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); + // Check file extension + var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); + var extensionStrart = path.lastIndexOf("."); + var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; + if (!validExtensions.contains(extension.toLowerCase())) { + warning("File extension '" + extension + "' is not supported. Provide any of: " + String.join(", ", validExtensions), + param, Literals.ATTR_PARM__VALUE); + return; + } + + // Check file location + var iconLocation = FileUtil.locateFile(path, reactor.eResource()); + if (iconLocation == null) { + warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); + } + if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) && !(new File(iconLocation.getPath()).exists())) { + warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); + } +>>>>>>> origin } } } @@ -1666,6 +2265,7 @@ private void checkName(String name, EStructuralFeature feature) { error(RESERVED_MESSAGE + name, feature); } +<<<<<<< HEAD if (this.target == Target.TS) { // "actions" is a reserved word within a TS reaction if (name.equals("actions")) { @@ -1681,6 +2281,79 @@ private void checkName(String name, EStructuralFeature feature) { public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { if (init == null) { return; +======= + @Check(CheckType.FAST) + public void checkMissingStateResetInMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var resetModes = new HashSet(); + // Collect all modes that may be reset + for (var m : reactor.getModes()) { + for (var r : m.getReactions()) { + for (var e : r.getEffects()) { + if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { + resetModes.add((Mode) e.getVariable()); + } + } + } + } + for (var m : resetModes) { + // Check state variables in this mode + if (!m.getStateVars().isEmpty()) { + var hasResetReaction = m.getReactions().stream().anyMatch( + r -> r.getTriggers().stream().anyMatch( + t -> (t instanceof BuiltinTriggerRef && + ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + for (var s : m.getStateVars()) { + if (!s.isReset()) { + error("State variable is not reset upon mode entry. It is neither marked for automatic reset nor is there a reset reaction.", + m, Literals.MODE__STATE_VARS, m.getStateVars().indexOf(s)); + } + } + } + } + // Check state variables in instantiated reactors + if (!m.getInstantiations().isEmpty()) { + for (var i : m.getInstantiations()) { + var error = new LinkedHashSet(); + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty()) { + var check = toCheck.pop(); + checked.add(check); + if (!check.getStateVars().isEmpty()) { + var hasResetReaction = check.getReactions().stream().anyMatch( + r -> r.getTriggers().stream().anyMatch( + t -> (t instanceof BuiltinTriggerRef && + ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + // Add state vars that are not self-resetting to the error + check.getStateVars().stream().filter(s -> !s.isReset()).forEachOrdered(error::add); + } + } + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); + } + } + } + if (!error.isEmpty()) { + error("This reactor contains state variables that are not reset upon mode entry: " + + error.stream().map(e -> e.getName() + " in " + + ASTUtils.getEnclosingReactor(e).getName()).collect(Collectors.joining(", ")) + + ".\nThe state variables are neither marked for automatic reset nor have a dedicated reset reaction. " + + "It is unsafe to instantiate this reactor inside a mode entered with reset.", + m, Literals.MODE__INSTANTIATIONS, + m.getInstantiations().indexOf(i)); + } + } + } + } + } +>>>>>>> origin } // TODO: @@ -1713,6 +2386,7 @@ private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) return; } +<<<<<<< HEAD if (init.getExprs().size() != 1) { error("Expected exactly one time value.", feature); } else { @@ -1723,6 +2397,58 @@ private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { if (value == null || value instanceof Time) { return; +======= + @Check(CheckType.FAST) + public void checkUnspecifiedTransitionType(Reaction reaction) { + for (var effect : reaction.getEffects()) { + var variable = effect.getVariable(); + if (variable instanceof Mode) { + // The transition type is always set to default by Xtext. + // Hence, check if there is an explicit node for the transition type in the AST. + var transitionAssignment = NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); + if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. + var mode = (Mode) variable; + // Check if reset or history transition would make a difference. + var makesDifference = !mode.getStateVars().isEmpty() + || !mode.getTimers().isEmpty() + || !mode.getActions().isEmpty() + || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); + if (!makesDifference && !mode.getInstantiations().isEmpty()) { + // Also check instantiated reactors + for (var i : mode.getInstantiations()) { + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty() && !makesDifference) { + var check = toCheck.pop(); + checked.add(check); + + makesDifference |= !check.getModes().isEmpty() + || !ASTUtils.allStateVars(check).isEmpty() + || !ASTUtils.allTimers(check).isEmpty() + || !ASTUtils.allActions(check).isEmpty() + || ASTUtils.allConnections(check).stream().anyMatch(c -> c.getDelay() != null); + + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); + } + } + } + } + } + if (makesDifference) { + warning("You should specify a transition type! " + + "Reset and history transitions have different effects on this target mode. " + + "Currently, a reset type is implicitly assumed.", + reaction, Literals.REACTION__EFFECTS, reaction.getEffects().indexOf(effect)); + } + } + } + } +>>>>>>> origin } if (value instanceof ParameterReference) { @@ -1953,5 +2679,223 @@ private boolean sameType(Type type1, Type type2) { "Names of objects (inputs, outputs, actions, timers, parameters, " + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; +<<<<<<< HEAD private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; +======= + if (ASTUtils.isInteger(((Literal) value).getLiteral())) { + error("Missing time unit.", feature); + return; + } + // fallthrough + } + + error("Invalid time value.", feature); + } + + /** + * Return the number of main or federated reactors declared. + * + * @param iter An iterator over all objects in the resource. + */ + private int countMainOrFederated(TreeIterator iter) { + int nMain = 0; + while (iter.hasNext()) { + EObject obj = iter.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor r = (Reactor) obj; + if (r.isMain() || r.isFederated()) { + nMain++; + } + } + return nMain; + } + + /** + * Report whether a given reactor has dependencies on a cyclic + * instantiation pattern. This means the reactor has an instantiation + * in it -- directly or in one of its contained reactors -- that is + * self-referential. + * @param reactor The reactor definition to find out whether it has any + * dependencies on cyclic instantiations. + * @param cycleSet The set of all reactors that are part of an + * instantiation cycle. + * @param visited The set of nodes already visited in this graph traversal. + */ + private boolean dependsOnCycle( + Reactor reactor, Set cycleSet, Set visited + ) { + Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); + if (visited.contains(reactor)) { + return false; + } else { + visited.add(reactor); + for (Reactor it : origins) { + if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { + // Reached a cycle. + return true; + } + } + } + return false; + } + + /** + * Report whether the name of the given element matches any variable in + * the ones to check against. + * @param element The element to compare against all variables in the given iterable. + * @param toCheckAgainst Iterable variables to compare the given element against. + */ + private boolean hasNameConflict(Variable element, + Iterable toCheckAgainst) { + int numNameConflicts = 0; + for (Variable it : toCheckAgainst) { + if (it.getName().equals(element.getName())) { + numNameConflicts++; + } + } + return numNameConflicts > 0; + } + + /** + * Return true if target is C or a C-based target like CCpp. + */ + private boolean isCBasedTarget() { + return (this.target == Target.C || this.target == Target.CCPP); + } + + /** + * Report whether a given imported reactor is used in this resource or not. + * @param reactor The imported reactor to check whether it is used. + */ + private boolean isUnused(ImportedReactor reactor) { + TreeIterator instantiations = reactor.eResource().getAllContents(); + TreeIterator subclasses = reactor.eResource().getAllContents(); + + boolean instantiationsCheck = true; + while (instantiations.hasNext() && instantiationsCheck) { + EObject obj = instantiations.next(); + if (!(obj instanceof Instantiation)) { + continue; + } + Instantiation inst = (Instantiation) obj; + instantiationsCheck &= (inst.getReactorClass() != reactor && inst.getReactorClass() != reactor.getReactorClass()); + } + + boolean subclassesCheck = true; + while (subclasses.hasNext() && subclassesCheck) { + EObject obj = subclasses.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor subclass = (Reactor) obj; + for (ReactorDecl decl : subclass.getSuperClasses()) { + subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); + } + } + return instantiationsCheck && subclassesCheck; + } + + /** + * Return true if the two types match. Unfortunately, xtext does not + * seem to create a suitable equals() method for Type, so we have to + * do this manually. + */ + private boolean sameType(Type type1, Type type2) { + if (type1 == null) { + return type2 == null; + } + if (type2 == null) { + return type1 == null; + } + // Most common case first. + if (type1.getId() != null) { + if (type1.getStars() != null) { + if (type2.getStars() == null) return false; + if (type1.getStars().size() != type2.getStars().size()) return false; + } + return (type1.getId().equals(type2.getId())); + } + + // Type specification in the grammar is: + // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); + if (type1.isTime()) { + if (!type2.isTime()) return false; + // Ignore the arraySpec because that is checked when connection + // is checked for balance. + return true; + } + // Type must be given in a code body + return type1.getCode().getBody().equals(type2.getCode().getBody()); + } + + ////////////////////////////////////////////////////////////// + //// Private fields. + + /** The error reporter. */ + private ValidatorErrorReporter errorReporter + = new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); + + /** Helper class containing information about the model. */ + private ModelInfo info = new ModelInfo(); + + @Inject(optional = true) + private ValidationMessageAcceptor messageAcceptor; + + /** The declared target. */ + private Target target; + + private List targetPropertyErrors = new ArrayList<>(); + + private List targetPropertyWarnings = new ArrayList<>(); + + ////////////////////////////////////////////////////////////// + //// Private static constants. + + private static String ACTIONS_MESSAGE + = "\"actions\" is a reserved word for the TypeScript target for objects " + + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " + + "and reactor instantiation): "; + + private static String HOST_OR_FQN_REGEX + = "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; + + /** + * Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). + */ + private static String IPV4_REGEX = "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" + + "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; + + /** + * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), + * with minor adjustment to allow up to six IPV6 segments (without truncation) in front + * of an embedded IPv4-address. + **/ + private static String IPV6_REGEX = + "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,7}:|" + + "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" + + "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" + + "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" + + "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" + + "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" + + ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" + + "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" + + "::(ffff(:0{1,4}){0,1}:){0,1}" + IPV4_REGEX + "|" + + "([0-9a-fA-F]{1,4}:){1,4}:" + IPV4_REGEX + "|" + + "([0-9a-fA-F]{1,4}:){1,6}" + IPV4_REGEX + ")"; + + private static String RESERVED_MESSAGE = "Reserved words in the target language are not allowed for objects " + + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation): "; + + private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); + + private static String UNDERSCORE_MESSAGE = "Names of objects (inputs, outputs, actions, timers, parameters, " + + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; + + private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; + +>>>>>>> origin } diff --git a/test/C/.gitignore b/test/C/.gitignore new file mode 100644 index 0000000000..08f514ebc5 --- /dev/null +++ b/test/C/.gitignore @@ -0,0 +1 @@ +include/ diff --git a/test/C/c/bank_multiport_to_reaction_no_inlining.c b/test/C/c/bank_multiport_to_reaction_no_inlining.c new file mode 100644 index 0000000000..ae54c84c2d --- /dev/null +++ b/test/C/c/bank_multiport_to_reaction_no_inlining.c @@ -0,0 +1,16 @@ +#include "../include/BankMultiportToReactionNoInlining/BankMultiportToReactionNoInlining.h" + +void check(bankmultiporttoreactionnoinlining_self_t* self, doublecount_out_t*** out) { + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + if (out[i][j]->is_present) { + lf_print("Received %d.", out[i][j]->value); + if (self->count != out[i][j]->value) { + lf_print_error_and_exit("Expected %d.", self->count); + } + self->received = true; + } + } + } + self->count++; +} diff --git a/test/C/c/bank_multiport_to_reaction_no_inlining.cmake b/test/C/c/bank_multiport_to_reaction_no_inlining.cmake new file mode 100644 index 0000000000..c433f89d7e --- /dev/null +++ b/test/C/c/bank_multiport_to_reaction_no_inlining.cmake @@ -0,0 +1 @@ +target_sources(${LF_MAIN_TARGET} PRIVATE c/bank_multiport_to_reaction_no_inlining.c) diff --git a/test/C/c/bank_to_reaction_no_inlining.c b/test/C/c/bank_to_reaction_no_inlining.c new file mode 100644 index 0000000000..9cf5b220b9 --- /dev/null +++ b/test/C/c/bank_to_reaction_no_inlining.c @@ -0,0 +1,11 @@ +#include "../include/BankToReactionNoInlining/BankToReactionNoInlining.h" + +void check(banktoreactionnoinlining_self_t* self, count_out_t** out) { + for (int i = 0; i < 2; i++) { + lf_print("Received %d.", out[i]->value); + if (self->count != out[i]->value) { + lf_print_error_and_exit("Expected %d but got %d.", self->count, out[i]->value); + } + } + self->count++; +} diff --git a/test/C/c/bank_to_reaction_no_inlining.cmake b/test/C/c/bank_to_reaction_no_inlining.cmake new file mode 100644 index 0000000000..a4f8d8dfa3 --- /dev/null +++ b/test/C/c/bank_to_reaction_no_inlining.cmake @@ -0,0 +1 @@ +target_sources(${LF_MAIN_TARGET} PRIVATE c/bank_to_reaction_no_inlining.c) diff --git a/test/C/c/count.c b/test/C/c/count.c new file mode 100644 index 0000000000..2bc5378b7d --- /dev/null +++ b/test/C/c/count.c @@ -0,0 +1,15 @@ +#include +#include "../include/Count/Count.h" + +void increment(count_self_t* self) { + printf("in increment, count=%d\n", self->count); + self->count++; +} + +void check_done(count_self_t* self) { + printf("in done, count=%d\n", self->count); + if (self->count > 10) { + printf("%s", "requesting stop\n"); + lf_request_stop(); + } +} diff --git a/test/C/c/count.cmake b/test/C/c/count.cmake new file mode 100644 index 0000000000..a9b364a871 --- /dev/null +++ b/test/C/c/count.cmake @@ -0,0 +1 @@ +target_sources(${LF_MAIN_TARGET} PRIVATE c/count.c) diff --git a/test/C/c/count_hierarchy.c b/test/C/c/count_hierarchy.c new file mode 100644 index 0000000000..999159aab8 --- /dev/null +++ b/test/C/c/count_hierarchy.c @@ -0,0 +1,15 @@ +#include +#include "../include/CountHierarchy/CountHierarchy.h" + +void increment(counthierarchy_self_t* self, timer_out_t* out) { + printf("in increment, count=%d\n", self->count); + self->count++; +} + +void check_done(counthierarchy_self_t* self, timer_out_t* out) { + printf("in done, count=%d\n", self->count); + if (self->count > 10) { + printf("%s", "requesting stop\n"); + lf_request_stop(); + } +} diff --git a/test/C/c/count_hierarchy.cmake b/test/C/c/count_hierarchy.cmake new file mode 100644 index 0000000000..955c07270a --- /dev/null +++ b/test/C/c/count_hierarchy.cmake @@ -0,0 +1 @@ +target_sources(${LF_MAIN_TARGET} PRIVATE c/count_hierarchy.c) diff --git a/test/C/c/multiport_to_reaction_no_inlining.c b/test/C/c/multiport_to_reaction_no_inlining.c new file mode 100644 index 0000000000..5036771cbd --- /dev/null +++ b/test/C/c/multiport_to_reaction_no_inlining.c @@ -0,0 +1,14 @@ +#include "../include/MultiportToReactionNoInlining/MultiportToReactionNoInlining.h" + +void check(multiporttoreactionnoinlining_self_t* self, source_out_t** out) { + int sum = 0; + for (int i = 0; i < 4; i++) { + if (out[i]->is_present) sum += out[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; +} diff --git a/test/C/c/multiport_to_reaction_no_inlining.cmake b/test/C/c/multiport_to_reaction_no_inlining.cmake new file mode 100644 index 0000000000..8f4226aff2 --- /dev/null +++ b/test/C/c/multiport_to_reaction_no_inlining.cmake @@ -0,0 +1 @@ +target_sources(${LF_MAIN_TARGET} PRIVATE c/multiport_to_reaction_no_inlining.c) diff --git a/test/C/c/sendreceive.c b/test/C/c/sendreceive.c new file mode 100644 index 0000000000..95a08176e7 --- /dev/null +++ b/test/C/c/sendreceive.c @@ -0,0 +1,17 @@ +#include + +#include "../include/IntPrint/Print.h" +#include "../include/IntPrint/Check.h" +#include "../include/api/set.h" + +void send(print_self_t* self, print_out_t* out) { + lf_set(out, 42); +} + +void receive(check_self_t* self, check_in_t* in) { + printf("Received: %d\n", in->value); + if (in->value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } +} diff --git a/test/C/c/sendreceive.cmake b/test/C/c/sendreceive.cmake new file mode 100644 index 0000000000..acd63f229c --- /dev/null +++ b/test/C/c/sendreceive.cmake @@ -0,0 +1 @@ +target_sources(${LF_MAIN_TARGET} PRIVATE c/sendreceive.c) diff --git a/test/C/src/Deadline.lf b/test/C/src/Deadline.lf index c72dc16dcf..21ea7df141 100644 --- a/test/C/src/Deadline.lf +++ b/test/C/src/Deadline.lf @@ -5,6 +5,16 @@ target C { timeout: 6 sec } +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif +=} + reactor Source(period: time = 3 sec) { output y: int timer t(0, period) @@ -14,7 +24,7 @@ reactor Source(period: time = 3 sec) { if (2 * (self->count / 2) != self->count) { // The count variable is odd. // Take time to cause a deadline violation. - lf_nanosleep(MSEC(1500)); + lf_sleep(MSEC(1500)); } printf("Source sends: %d.\n", self->count); lf_set(y, self->count); diff --git a/test/C/src/DeadlineHandledAbove.lf b/test/C/src/DeadlineHandledAbove.lf index 92d7e9dac8..3b0dc49198 100644 --- a/test/C/src/DeadlineHandledAbove.lf +++ b/test/C/src/DeadlineHandledAbove.lf @@ -2,6 +2,16 @@ // container reacts to that output. target C +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif +=} + reactor Deadline(threshold: time = 100 msec) { input x: int output deadline_violation: bool diff --git a/test/C/src/DeadlineInherited.lf b/test/C/src/DeadlineInherited.lf index eab2f56d9b..3d3c8ac96b 100644 --- a/test/C/src/DeadlineInherited.lf +++ b/test/C/src/DeadlineInherited.lf @@ -4,9 +4,10 @@ target C { threading: false } -preamble {= int global_cnt = 0; =} +preamble {= extern int global_cnt; =} reactor NoDeadline { + preamble {= int global_cnt = 0; =} timer t(0 msec, 100 msec) reaction(t) {= global_cnt++; =} diff --git a/test/C/src/DeadlinePriority.lf b/test/C/src/DeadlinePriority.lf index 723a29b754..2aa5c8136f 100644 --- a/test/C/src/DeadlinePriority.lf +++ b/test/C/src/DeadlinePriority.lf @@ -4,9 +4,10 @@ target C { threading: false } -preamble {= int global_cnt = 0; =} +preamble {= extern int global_cnt; =} reactor NoDeadline { + preamble {= int global_cnt = 0; =} timer t(0 msec, 100 msec) reaction(t) {= global_cnt++; =} diff --git a/test/C/src/DeadlineWithAfterDelay.lf b/test/C/src/DeadlineWithAfterDelay.lf index d1b87860ac..5e33e129e6 100644 --- a/test/C/src/DeadlineWithAfterDelay.lf +++ b/test/C/src/DeadlineWithAfterDelay.lf @@ -4,9 +4,11 @@ target C { threading: false } -preamble {= int global_cnt = 0; =} +preamble {= extern int global_cnt; =} reactor Source { + preamble {= int global_cnt = 0; =} + output out: int timer t(0 msec, 100 msec) diff --git a/test/C/src/DeadlineWithBanks.lf b/test/C/src/DeadlineWithBanks.lf index 18bc8c3682..7a9445ec8d 100644 --- a/test/C/src/DeadlineWithBanks.lf +++ b/test/C/src/DeadlineWithBanks.lf @@ -9,9 +9,11 @@ target C { build-type: Debug } -preamble {= volatile int global_cnt = 0; =} +preamble {= extern volatile int global_cnt; =} reactor Bank(bank_index: int = 0) { + preamble {= volatile int global_cnt = 0; =} + timer t(0, 100 msec) output out: int diff --git a/test/C/src/DelayString.lf b/test/C/src/DelayString.lf index b14e680d72..80b89020dd 100644 --- a/test/C/src/DelayString.lf +++ b/test/C/src/DelayString.lf @@ -2,6 +2,16 @@ // freed. target C +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include + #ifdef __cplusplus + } + #endif +=} + reactor DelayString2(delay: time = 100 msec) { input in: string output out: string diff --git a/test/C/src/DelayStruct.lf b/test/C/src/DelayStruct.lf index 9cd201aa11..0a92171d35 100644 --- a/test/C/src/DelayStruct.lf +++ b/test/C/src/DelayStruct.lf @@ -5,6 +5,7 @@ target C { preamble {= #include "hello.h" + #include =} reactor DelayPointer(delay: time = 100 msec) { diff --git a/test/C/src/Hello.lf b/test/C/src/Hello.lf index ea37265a23..7784e2f86f 100644 --- a/test/C/src/Hello.lf +++ b/test/C/src/Hello.lf @@ -8,6 +8,10 @@ target C { fast: true } +preamble {= + #include +=} + reactor Reschedule(period: time = 2 sec, message: string = "Hello C") { state count: int = 0 state previous_time: time = 0 diff --git a/test/C/src/ScheduleValue.lf b/test/C/src/ScheduleValue.lf index 65e36fbd06..8481d47d61 100644 --- a/test/C/src/ScheduleValue.lf +++ b/test/C/src/ScheduleValue.lf @@ -3,6 +3,17 @@ target C { timeout: 3 sec } +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include + #include + #ifdef __cplusplus + } + #endif +=} + main reactor ScheduleValue { logical action a: char* diff --git a/test/C/src/SimpleDeadline.lf b/test/C/src/SimpleDeadline.lf index 3e2d786eec..fba3e03cbc 100644 --- a/test/C/src/SimpleDeadline.lf +++ b/test/C/src/SimpleDeadline.lf @@ -3,6 +3,16 @@ // violation. target C +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif +=} + reactor Deadline(threshold: time = 100 msec) { input x: int output deadlineViolation: bool diff --git a/test/C/src/StructAsState.lf b/test/C/src/StructAsState.lf index 59ae495853..119762c14c 100644 --- a/test/C/src/StructAsState.lf +++ b/test/C/src/StructAsState.lf @@ -2,13 +2,14 @@ // value. target C +preamble {= + typedef struct hello_t { + char* name; + int value; + } hello_t; +=} + main reactor StructAsState { - preamble {= - typedef struct hello_t { - char* name; - int value; - } hello_t; - =} // Notice that target code delimiters are no longer necessary. state s: hello_t = {"Earth", 42} diff --git a/test/C/src/TestForPreviousOutput.lf b/test/C/src/TestForPreviousOutput.lf index fec3bc54da..583c6cbb74 100644 --- a/test/C/src/TestForPreviousOutput.lf +++ b/test/C/src/TestForPreviousOutput.lf @@ -2,6 +2,16 @@ // a given output. The output should always be 42. target C +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include + #ifdef __cplusplus + } + #endif +=} + reactor Source { output out: int diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index fdac093c49..16d6723f7f 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -1,21 +1,19 @@ /** - * Test watchdog. - * This test starts a watchdog timer of 150ms every 100ms. - * Half the time, it then sleeps after starting the watchdog so that - * the watchdog expires. There should be a total of five watchdog - * expirations. + * Test watchdog. This test starts a watchdog timer of 150ms every 100ms. Half + * the time, it then sleeps after starting the watchdog so that the watchdog + * expires. There should be a total of five watchdog expirations. * @author Benjamin Asch * @author Edward A. Lee */ target C { - timeout: 1100ms + timeout: 1100 ms } -reactor Watcher(timeout:time(150ms)) { - timer t(100ms, 100ms) // Offset ameliorates startup time. - output d: int // Produced if the watchdog triggers. - state alternating:bool(false) - state count:int(0) +reactor Watcher(timeout: time = 150 ms) { + timer t(100 ms, 100 ms) // Offset ameliorates startup time. + output d: int // Produced if the watchdog triggers. + state alternating: bool = false + state count: int = 0 watchdog poodle(timeout) {= instant_t p = lf_time_physical_elapsed() - lf_time_logical_elapsed(); @@ -32,12 +30,12 @@ reactor Watcher(timeout:time(150ms)) { } self->alternating = !self->alternating; =} - + reaction(poodle) -> d {= lf_print("Reaction poodle was called."); lf_set(d, 1); =} - + reaction(shutdown) -> poodle {= // FIXME: There needs to be an lf_watchdog_stop() defined. _lf_watchdog_stop(poodle); @@ -49,14 +47,15 @@ reactor Watcher(timeout:time(150ms)) { main reactor { logical action a - state count:int(0) - + state count: int = 0 + w = new Watcher() reaction(w.d) {= lf_print("*** Watcher reactor produced an output."); self->count++; =} + reaction(shutdown) {= if (self->count != 5) { lf_print_error_and_exit("Watchdog produced output %d times. Expected 5.", self->count); diff --git a/test/C/src/concurrent/AsyncCallback.lf b/test/C/src/concurrent/AsyncCallback.lf index ec2beae766..58120446d4 100644 --- a/test/C/src/concurrent/AsyncCallback.lf +++ b/test/C/src/concurrent/AsyncCallback.lf @@ -9,9 +9,20 @@ */ target C { tracing: true, - timeout: 2 sec + timeout: 2 sec, + keepalive: true } +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif +=} + main reactor AsyncCallback { preamble {= void callback(void* a) { diff --git a/test/C/src/concurrent/AsyncCallbackDrop.lf b/test/C/src/concurrent/AsyncCallbackDrop.lf index f123bcdbdf..b0c5c502f2 100644 --- a/test/C/src/concurrent/AsyncCallbackDrop.lf +++ b/test/C/src/concurrent/AsyncCallbackDrop.lf @@ -7,6 +7,16 @@ target C { timeout: 2 sec } +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif +=} + main reactor { preamble {= void callback(void* a) { diff --git a/test/C/src/concurrent/AsyncCallbackReplace.lf b/test/C/src/concurrent/AsyncCallbackReplace.lf index b7afeb2363..7bac7496b5 100644 --- a/test/C/src/concurrent/AsyncCallbackReplace.lf +++ b/test/C/src/concurrent/AsyncCallbackReplace.lf @@ -7,6 +7,16 @@ target C { timeout: 2 sec } +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif +=} + main reactor { preamble {= void callback(void* a) { diff --git a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf index 545206de91..ad14879080 100644 --- a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -2,6 +2,16 @@ // container reacts to that output. target C +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif +=} + reactor Deadline(threshold: time = 100 msec) { input x: int output deadline_violation: bool @@ -20,7 +30,7 @@ main reactor { d = new Deadline(threshold = 10 msec) reaction(startup) -> d.x {= - lf_nanosleep(MSEC(200)); + lf_sleep(MSEC(200)); lf_set(d.x, 42); =} diff --git a/test/C/src/concurrent/DeadlineThreaded.lf b/test/C/src/concurrent/DeadlineThreaded.lf index ac765fe6f7..ffc1be2701 100644 --- a/test/C/src/concurrent/DeadlineThreaded.lf +++ b/test/C/src/concurrent/DeadlineThreaded.lf @@ -5,6 +5,16 @@ target C { timeout: 6 sec } +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif +=} + reactor Source(period: time = 3000 msec) { output y: int timer t(0, period) @@ -14,7 +24,7 @@ reactor Source(period: time = 3000 msec) { if (2 * (self->count / 2) != self->count) { // The count variable is odd. // Take time to cause a deadline violation. - lf_nanosleep(MSEC(210)); + lf_sleep(MSEC(210)); } printf("Source sends: %d.\n", self->count); lf_set(y, self->count); diff --git a/test/C/src/concurrent/HelloThreaded.lf b/test/C/src/concurrent/HelloThreaded.lf index a8ea34dd05..285811a17d 100644 --- a/test/C/src/concurrent/HelloThreaded.lf +++ b/test/C/src/concurrent/HelloThreaded.lf @@ -8,6 +8,10 @@ target C { fast: true } +preamble {= + #include +=} + reactor Reschedule(period: time = 2 sec, message: string = "Hello C") { state count: int = 0 state previous_time: time = 0 diff --git a/test/C/src/concurrent/ScheduleAt.lf b/test/C/src/concurrent/ScheduleAt.lf index e68b3956e8..2ef6af7af6 100644 --- a/test/C/src/concurrent/ScheduleAt.lf +++ b/test/C/src/concurrent/ScheduleAt.lf @@ -10,6 +10,15 @@ target C { } reactor Scheduler { + preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "include/core/reactor_common.h" + #ifdef __cplusplus + } + #endif + =} logical action act // List of microsteps. Size = 16 state microstep_delay_list: uint32_t[] = { diff --git a/test/C/src/concurrent/Tracing.lf b/test/C/src/concurrent/Tracing.lf index 71da79c7ef..cbc4513732 100644 --- a/test/C/src/concurrent/Tracing.lf +++ b/test/C/src/concurrent/Tracing.lf @@ -7,6 +7,10 @@ target C { logging: DEBUG } +preamble {= + #include +=} + reactor Source { timer t(0, 200 msec) output out: int diff --git a/test/C/src/federated/DistributedNetworkOrder.lf b/test/C/src/federated/DistributedNetworkOrder.lf index e18ea4ac04..ef979a949d 100644 --- a/test/C/src/federated/DistributedNetworkOrder.lf +++ b/test/C/src/federated/DistributedNetworkOrder.lf @@ -13,6 +13,16 @@ target C { build-type: RelWithDebInfo // Release with debug info } +preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "federate.h" + #ifdef __cplusplus + } + #endif +=} + reactor Sender { output out: int timer t(0, 1 msec) diff --git a/test/C/src/federated/DistributedPhysicalActionUpstream.lf b/test/C/src/federated/DistributedPhysicalActionUpstream.lf index 47280a24b8..520142b466 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstream.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstream.lf @@ -13,22 +13,28 @@ import PassThrough from "../lib/PassThrough.lf" import TestCount from "../lib/TestCount.lf" preamble {= - int _counter = 1; - void callback(void *a) { - lf_schedule_int(a, 0, _counter++); - } - // Simulate time passing before a callback occurs. - void* take_time(void* a) { - while (_counter < 15) { - instant_t sleep_time = MSEC(10); - lf_sleep(sleep_time); - callback(a); - } - return NULL; - } + extern int _counter; + void callback(void *a); + void* take_time(void* a); =} reactor WithPhysicalAction { + preamble {= + int _counter = 1; + void callback(void *a) { + lf_schedule_int(a, 0, _counter++); + } + // Simulate time passing before a callback occurs. + void* take_time(void* a) { + while (_counter < 15) { + instant_t sleep_time = MSEC(10); + lf_sleep(sleep_time); + callback(a); + } + return NULL; + } + =} + output out: int state thread_id: lf_thread_t = 0 physical action act(0): int diff --git a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf index 66bbb964e1..5cee1171cc 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf @@ -13,22 +13,27 @@ import PassThrough from "../lib/PassThrough.lf" import TestCount from "../lib/TestCount.lf" preamble {= - int _counter = 1; - void callback(void *a) { - lf_schedule_int(a, 0, _counter++); - } - // Simulate time passing before a callback occurs. - void* take_time(void* a) { - while (_counter < 20) { - instant_t sleep_time = USEC(50); - lf_sleep(sleep_time); - callback(a); - } - return NULL; - } + extern int _counter; + void callback(void *a); + void* take_time(void* a); =} reactor WithPhysicalAction { + preamble {= + int _counter = 1; + void callback(void *a) { + lf_schedule_int(a, 0, _counter++); + } + // Simulate time passing before a callback occurs. + void* take_time(void* a) { + while (_counter < 20) { + instant_t sleep_time = USEC(50); + lf_sleep(sleep_time); + callback(a); + } + return NULL; + } + =} output out: int state thread_id: lf_thread_t = 0 physical action act(0): int diff --git a/test/C/src/federated/HelloDistributed.lf b/test/C/src/federated/HelloDistributed.lf index 6841bf91bc..909ce53b43 100644 --- a/test/C/src/federated/HelloDistributed.lf +++ b/test/C/src/federated/HelloDistributed.lf @@ -7,6 +7,10 @@ */ target C +preamble {= + #include +=} + reactor Source { output out: string diff --git a/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf b/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf index 44ce6e1681..b4501cd555 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf @@ -15,19 +15,23 @@ target C { preamble {= #include // Defines sleep() - bool stop = false; - // Thread to trigger an action once every second. - void* ping(void* actionref) { - while(!stop) { - lf_print("Scheduling action."); - lf_schedule(actionref, 0); - sleep(1); - } - return NULL; - } + extern bool stop; + void* ping(void* actionref); =} reactor Looper(incr: int = 1, delay: time = 0 msec) { + preamble {= + bool stop = false; + // Thread to trigger an action once every second. + void* ping(void* actionref) { + while(!stop) { + lf_print("Scheduling action."); + lf_schedule(actionref, 0); + sleep(1); + } + return NULL; + } + =} input in: int output out: int physical action a(delay) diff --git a/test/C/src/federated/LoopDistributedDecentralized.lf b/test/C/src/federated/LoopDistributedDecentralized.lf index ae64e6e71a..4350c984b3 100644 --- a/test/C/src/federated/LoopDistributedDecentralized.lf +++ b/test/C/src/federated/LoopDistributedDecentralized.lf @@ -11,19 +11,23 @@ target C { preamble {= #include // Defines sleep() - bool stop = false; - // Thread to trigger an action once every second. - void* ping(void* actionref) { - while(!stop) { - lf_print("Scheduling action."); - lf_schedule(actionref, 0); - sleep(1); - } - return NULL; - } + extern bool stop; + void* ping(void* actionref); =} reactor Looper(incr: int = 1, delay: time = 0 msec, stp_offset: time = 0) { + preamble {= + bool stop = false; + // Thread to trigger an action once every second. + void* ping(void* actionref) { + while(!stop) { + lf_print("Scheduling action."); + lf_schedule(actionref, 0); + sleep(1); + } + return NULL; + } + =} input in: int output out: int physical action a(stp_offset) diff --git a/test/C/src/federated/LoopDistributedDouble.lf b/test/C/src/federated/LoopDistributedDouble.lf index 31b7eb0f6e..28723650d7 100644 --- a/test/C/src/federated/LoopDistributedDouble.lf +++ b/test/C/src/federated/LoopDistributedDouble.lf @@ -15,19 +15,23 @@ target C { preamble {= #include // Defines sleep() - bool stop = false; - // Thread to trigger an action once every second. - void* ping(void* actionref) { - while(!stop) { - lf_print("Scheduling action."); - lf_schedule(actionref, 0); - sleep(1); - } - return NULL; - } + extern bool stop; + void* ping(void* actionref); =} reactor Looper(incr: int = 1, delay: time = 0 msec) { + preamble {= + bool stop = false; + // Thread to trigger an action once every second. + void* ping(void* actionref) { + while(!stop) { + lf_print("Scheduling action."); + lf_schedule(actionref, 0); + sleep(1); + } + return NULL; + } + =} input in: int input in2: int output out: int diff --git a/test/C/src/include/hello.h b/test/C/src/include/hello.h index 6ee45b62a7..7b290fba89 100644 --- a/test/C/src/include/hello.h +++ b/test/C/src/include/hello.h @@ -18,14 +18,14 @@ typedef struct hello_t { typedef int* int_pointer; -hello_t* hello_constructor(char* name, int value) { +static hello_t* hello_constructor(char* name, int value) { hello_t* val = (hello_t*) malloc(sizeof(hello_t)); val->name = name; val->value = value; return val; } -hello_t* hello_copy_constructor(hello_t v) { +static hello_t* hello_copy_constructor(hello_t v) { hello_t* val = (hello_t*) malloc(sizeof(hello_t)); val->name = v.name; val->value = v.value; diff --git a/test/C/src/modal_models/BanksCount3ModesComplex.lf b/test/C/src/modal_models/BanksCount3ModesComplex.lf index ad08cc7325..47805f1009 100644 --- a/test/C/src/modal_models/BanksCount3ModesComplex.lf +++ b/test/C/src/modal_models/BanksCount3ModesComplex.lf @@ -55,7 +55,7 @@ main reactor { test = new TraceTesting( // keep-format events_size = 16, trace_size = 429, - trace = ( + trace = { 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 250000000,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, @@ -69,7 +69,7 @@ main reactor { 250000000,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0 - ), training = false) + }, training = false) counters.always, counters.mode1, counters.mode2, counters.never -> test.events diff --git a/test/C/src/modal_models/BanksCount3ModesSimple.lf b/test/C/src/modal_models/BanksCount3ModesSimple.lf index c03fb7e562..40c2ba50a8 100644 --- a/test/C/src/modal_models/BanksCount3ModesSimple.lf +++ b/test/C/src/modal_models/BanksCount3ModesSimple.lf @@ -13,7 +13,7 @@ main reactor { test = new TraceTesting( events_size = 3, trace_size = 63, - trace = ( // keep-format + trace = { // keep-format 0,1,1,1,1,1,1, 250000000,1,2,1,2,1,2, 250000000,1,3,1,3,1,3, @@ -23,7 +23,7 @@ main reactor { 250000000,1,1,1,1,1,1, 250000000,1,2,1,2,1,2, 250000000,1,3,1,3,1,3 - ), + }, training = false ) diff --git a/test/C/src/modal_models/BanksModalStateReset.lf b/test/C/src/modal_models/BanksModalStateReset.lf index 1dde9c5b97..8e075715c8 100644 --- a/test/C/src/modal_models/BanksModalStateReset.lf +++ b/test/C/src/modal_models/BanksModalStateReset.lf @@ -16,7 +16,7 @@ main reactor { reset1 = new[2] ResetReaction() reset2 = new[2] AutoReset() - test = new TraceTesting(events_size = 16, trace_size = 627, trace = ( // keep-format + test = new TraceTesting(events_size = 16, trace_size = 627, trace = { // keep-format 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, 250000000,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, 0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, 250000000,0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, 0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, @@ -36,7 +36,7 @@ main reactor { 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, 0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, 0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, 250000000,1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2, 1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2 - ), training = false) + }, training = false) reset1.mode_switch, reset1.count0, diff --git a/test/C/src/modal_models/ConvertCaseTest.lf b/test/C/src/modal_models/ConvertCaseTest.lf index 5475edaa35..3f644eb133 100644 --- a/test/C/src/modal_models/ConvertCaseTest.lf +++ b/test/C/src/modal_models/ConvertCaseTest.lf @@ -50,10 +50,6 @@ reactor Converter { input raw: char output converted: int - preamble {= - #include - =} - initial mode Upper { reaction(raw) -> converted, reset(Lower) {= char c = raw->value; @@ -114,7 +110,7 @@ main reactor { test = new TraceTesting( events_size = 2, trace_size = 60, - trace = ( // keep-format + trace = { // keep-format 0,1,72,1,72, 250000000,1,69,1,69, 250000000,1,76,1,76, @@ -127,7 +123,7 @@ main reactor { 250000000,1,76,1,108, 250000000,1,68,1,100, 250000000,1,95,1,95 - ), + }, training = false ) diff --git a/test/C/src/modal_models/ModalActions.lf b/test/C/src/modal_models/ModalActions.lf index 1d8dff8cb4..e687d4bafd 100644 --- a/test/C/src/modal_models/ModalActions.lf +++ b/test/C/src/modal_models/ModalActions.lf @@ -68,7 +68,7 @@ main reactor { test = new TraceTesting( events_size = 5, trace_size = 165, - trace = ( // keep-format + trace = { // keep-format 0,0,0,1,1,0,0,0,0,0,0, 500000000,0,0,0,1,1,1,0,0,0,0, 250000000,0,0,1,1,0,1,0,0,0,0, @@ -84,7 +84,7 @@ main reactor { 500000000,0,1,0,1,0,1,0,1,1,1, 250000000,0,1,0,1,0,1,1,1,0,1, 250000000,1,1,0,1,0,1,0,1,0,1 - ), + }, training = false ) diff --git a/test/C/src/modal_models/ModalAfter.lf b/test/C/src/modal_models/ModalAfter.lf index 270fd88d05..f5cc8d229e 100644 --- a/test/C/src/modal_models/ModalAfter.lf +++ b/test/C/src/modal_models/ModalAfter.lf @@ -73,7 +73,7 @@ main reactor { test = new TraceTesting( events_size = 5, trace_size = 165, - trace = ( // keep-format + trace = { // keep-format 0,0,0,1,1,0,0,0,0,0,0, 500000000,0,0,0,1,1,1,0,0,0,0, 250000000,0,0,1,1,0,1,0,0,0,0, @@ -89,7 +89,7 @@ main reactor { 500000000,0,1,0,1,0,1,0,1,1,1, 250000000,0,1,0,1,0,1,1,1,0,1, 250000000,1,1,0,1,0,1,0,1,0,1 - ), + }, training = false ) diff --git a/test/C/src/modal_models/ModalCycleBreaker.lf b/test/C/src/modal_models/ModalCycleBreaker.lf index cee4fabfec..aae727b23d 100644 --- a/test/C/src/modal_models/ModalCycleBreaker.lf +++ b/test/C/src/modal_models/ModalCycleBreaker.lf @@ -57,7 +57,7 @@ main reactor { test = new TraceTesting( events_size = 1, trace_size = 27, - trace = ( // keep-format + trace = { // keep-format 0,1,0, 100000000,1,1, 100000000,1,2, @@ -67,7 +67,7 @@ main reactor { 100000000,1,7, 100000000,1,8, 100000000,1,9 - ), + }, training = false ) diff --git a/test/C/src/modal_models/ModalStartupShutdown.lf b/test/C/src/modal_models/ModalStartupShutdown.lf index fa1ebaacdf..d39117882a 100644 --- a/test/C/src/modal_models/ModalStartupShutdown.lf +++ b/test/C/src/modal_models/ModalStartupShutdown.lf @@ -113,7 +113,7 @@ main reactor { test = new TraceTesting( events_size = 11, trace_size = 253, - trace = ( // keep-format + trace = { // keep-format 0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 500000000,1,2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,2,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, @@ -125,7 +125,7 @@ main reactor { 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, 500000000,1,4,0,1,0,1,1,1,1,1,0,1,0,1,1,1,0,0,0,0,0,0 - ), + }, training = false ) diff --git a/test/C/src/modal_models/ModalStateReset.lf b/test/C/src/modal_models/ModalStateReset.lf index 61563162b6..c098f088d5 100644 --- a/test/C/src/modal_models/ModalStateReset.lf +++ b/test/C/src/modal_models/ModalStateReset.lf @@ -63,7 +63,7 @@ main reactor { test = new TraceTesting( events_size = 4, trace_size = 171, - trace = ( // keep-format + trace = { // keep-format 0,0,0,0,0,1,0,0,0, 250000000,0,0,0,0,1,1,0,0, 250000000,0,0,0,0,1,2,0,0, @@ -83,7 +83,7 @@ main reactor { 250000000,0,1,0,2,0,8,1,0, 250000000,0,1,0,2,0,8,1,1, 250000000,1,1,1,3,0,8,1,2 - ), + }, training = false ) diff --git a/test/C/src/modal_models/ModalStateResetAuto.lf b/test/C/src/modal_models/ModalStateResetAuto.lf index a2b6b105f0..a82fd18212 100644 --- a/test/C/src/modal_models/ModalStateResetAuto.lf +++ b/test/C/src/modal_models/ModalStateResetAuto.lf @@ -59,7 +59,7 @@ main reactor { test = new TraceTesting( events_size = 4, trace_size = 171, - trace = ( // keep-format + trace = { // keep-format 0,0,0,0,0,1,0,0,0, 250000000,0,0,0,0,1,1,0,0, 250000000,0,0,0,0,1,2,0,0, @@ -79,7 +79,7 @@ main reactor { 250000000,0,1,0,2,0,8,1,0, 250000000,0,1,0,2,0,8,1,1, 250000000,1,1,1,3,0,8,1,2 - ), + }, training = false ) diff --git a/test/C/src/modal_models/ModalTimers.lf b/test/C/src/modal_models/ModalTimers.lf index 47fcf5f9e4..954a677de4 100644 --- a/test/C/src/modal_models/ModalTimers.lf +++ b/test/C/src/modal_models/ModalTimers.lf @@ -49,7 +49,7 @@ main reactor { test = new TraceTesting( events_size = 3, trace_size = 77, - trace = ( // keep-format + trace = { // keep-format 0,0,0,1,1,0,0, 750000000,0,0,1,1,0,0, 250000000,1,1,0,1,0,0, @@ -61,7 +61,7 @@ main reactor { 0,0,1,0,1,1,1, 750000000,0,1,0,1,1,1, 250000000,1,1,0,1,0,1 - ), + }, training = false ) diff --git a/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf b/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf index 60fa76dd1e..31de4fe6bd 100644 --- a/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf +++ b/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf @@ -44,7 +44,7 @@ main reactor { test = new TraceTesting( events_size = 1, trace_size = 51, - trace = ( // keep-format + trace = { // keep-format 0,1,0, 250000000,1,1, 250000000,1,2, @@ -62,7 +62,7 @@ main reactor { 100000000,1,3, 100000000,1,4, 100000000,1,5 - ), + }, training = false ) diff --git a/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf b/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf index dff82c602f..f89073dfc1 100644 --- a/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf +++ b/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf @@ -47,7 +47,7 @@ main reactor { test = new TraceTesting( events_size = 1, trace_size = 51, - trace = ( // keep-format + trace = { // keep-format 0,1,0, 250000000,1,1, 250000000,1,2, @@ -65,7 +65,7 @@ main reactor { 100000000,1,30, 100000000,1,40, 100000000,1,50 - ), + }, training = false ) diff --git a/test/C/src/modal_models/util/TraceTesting.lf b/test/C/src/modal_models/util/TraceTesting.lf index 247b3f1def..c63de35f2a 100644 --- a/test/C/src/modal_models/util/TraceTesting.lf +++ b/test/C/src/modal_models/util/TraceTesting.lf @@ -1,10 +1,6 @@ /** Utility reactor to record and test execution traces. */ target C -preamble {= - #include -=} - reactor TraceTesting( events_size: int = 0, trace_size: int = 0, diff --git a/test/C/src/multiport/BankIndexInitializer.lf b/test/C/src/multiport/BankIndexInitializer.lf index d8a2c5766e..e6c52e8efe 100644 --- a/test/C/src/multiport/BankIndexInitializer.lf +++ b/test/C/src/multiport/BankIndexInitializer.lf @@ -1,9 +1,11 @@ // Test bank of reactors to multiport input with id parameter in the bank. target C -preamble {= int table[] = {4, 3, 2, 1}; =} +preamble {= extern int table[4]; =} reactor Source(bank_index: int = 0, value: int = 0) { + preamble {= int table[] = {4, 3, 2, 1}; =} + output out: int reaction(startup) -> out {= lf_set(out, self->value); =} diff --git a/test/C/src/no_inlining/BankMultiportToReactionNoInlining.lf b/test/C/src/no_inlining/BankMultiportToReactionNoInlining.lf new file mode 100644 index 0000000000..e69e0af0b4 --- /dev/null +++ b/test/C/src/no_inlining/BankMultiportToReactionNoInlining.lf @@ -0,0 +1,30 @@ +target C { + timeout: 5 sec, + fast: true, + cmake-include: ["../../c/bank_multiport_to_reaction_no_inlining.cmake"], + files: ["../../c"] +} + +import Count from "../lib/Count.lf" + +reactor DoubleCount { + output[2] out: int + c1 = new Count() + c2 = new Count() + c1.out, c2.out -> out +} + +main reactor { + state count: int = 1 + state received: bool = false + + s = new[2] DoubleCount() + + reaction(s.out) named check + + reaction(shutdown) {= + if (!self->received) { + lf_print_error_and_exit("No inputs present."); + } + =} +} diff --git a/test/C/src/no_inlining/BankToReactionNoInlining.lf b/test/C/src/no_inlining/BankToReactionNoInlining.lf new file mode 100644 index 0000000000..4956bf68cd --- /dev/null +++ b/test/C/src/no_inlining/BankToReactionNoInlining.lf @@ -0,0 +1,16 @@ +target C { + timeout: 5 sec, + fast: true, + cmake-include: ["../../c/bank_to_reaction_no_inlining.cmake"], + files: ["../../c"] +} + +import Count from "../lib/Count.lf" + +main reactor { + state count: int = 1 + + s = new[2] Count() + + reaction(s.out) named check +} diff --git a/test/C/src/no_inlining/Count.lf b/test/C/src/no_inlining/Count.lf new file mode 100644 index 0000000000..f8fd51bec7 --- /dev/null +++ b/test/C/src/no_inlining/Count.lf @@ -0,0 +1,16 @@ +target C { + cmake-include: ["../../c/count.cmake"], + files: ["../../c"] +} + +main reactor Count { + timer t(0, 1 msec) + + state count: int + + reaction(t) named increment + + reaction(t) named check_done + + reaction(shutdown) {= printf("%s", "shutting down\n"); =} +} diff --git a/test/C/src/no_inlining/CountHierarchy.lf b/test/C/src/no_inlining/CountHierarchy.lf new file mode 100644 index 0000000000..771222af2f --- /dev/null +++ b/test/C/src/no_inlining/CountHierarchy.lf @@ -0,0 +1,23 @@ +target C { + cmake-include: ["../../c/count_hierarchy.cmake"], + files: ["../../c"] +} + +reactor Timer(m: time = 0, n: time = 0) { + output out: int + timer t(m, n) + + reaction(t) -> out {= lf_set(out, 0); =} +} + +main reactor { + t = new Timer(m = 0, n = 1 msec) + + state count: int + + reaction(t.out) named increment + + reaction(t.out) named check_done + + reaction(shutdown) {= printf("%s", "shutting down\n"); =} +} diff --git a/test/C/src/no_inlining/IntPrint.lf b/test/C/src/no_inlining/IntPrint.lf new file mode 100644 index 0000000000..fa6ab8c757 --- /dev/null +++ b/test/C/src/no_inlining/IntPrint.lf @@ -0,0 +1,22 @@ +target C { + cmake-include: ["../../c/sendreceive.cmake"], + files: ["../../c"] +} + +reactor Print { + output out: int + + reaction(startup) -> out named send +} + +reactor Check(expected: int = 42) { // expected parameter is for testing. + input in: int + + reaction(in) named receive +} + +main reactor { + s = new Print() + p = new Check() + s.out -> p.in +} diff --git a/test/C/src/no_inlining/MultiportToReactionNoInlining.lf b/test/C/src/no_inlining/MultiportToReactionNoInlining.lf new file mode 100644 index 0000000000..3c5f18d62a --- /dev/null +++ b/test/C/src/no_inlining/MultiportToReactionNoInlining.lf @@ -0,0 +1,35 @@ +// Check reaction to multiport output of a contained reactor. +target C { + timeout: 2 sec, + fast: true, + cmake-include: ["../../c/multiport_to_reaction_no_inlining.cmake"], + files: ["../../c"] +} + +reactor Source(width: int = 1) { + timer t(0, 200 msec) + state s: int = 0 + output[width] out: int + + reaction(t) -> out {= + printf("Sending.\n"); + for(int i = 0; i < out_width; i++) { + lf_set(out[i], self->s++); + } + =} +} + +main reactor { + state s: int = 6 + b = new Source(width = 4) + + reaction(b.out) named check + + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} +} diff --git a/test/C/src/token/include/array.h b/test/C/src/token/include/array.h index c1fd1b4991..5ea8d5230b 100644 --- a/test/C/src/token/include/array.h +++ b/test/C/src/token/include/array.h @@ -21,7 +21,7 @@ typedef struct int_array_t { * @param length The length. * @return A pointer to the array struct. */ -int_array_t* int_array_constructor(size_t length) { +static inline int_array_t* int_array_constructor(size_t length) { int_array_t* result = (int_array_t*) malloc(sizeof(int_array_t)); result->data = (int*) calloc(length, sizeof(int)); result->length = length; @@ -36,7 +36,7 @@ int_array_t* int_array_constructor(size_t length) { * @param array The array to copy. * @return void* */ -void* int_array_copy_constructor(void* array) { +static inline void* int_array_copy_constructor(void* array) { int_array_t* source = (int_array_t*) array; int_array_t* copy = (int_array_t*) malloc(sizeof(int_array_t)); copy->data = (int*) calloc(source->length, sizeof(int)); @@ -54,7 +54,7 @@ void* int_array_copy_constructor(void* array) { * when their reference count decrements to zero. * @param array The array to free. */ -void int_array_destructor(void* array) { +static inline void int_array_destructor(void* array) { free(((int_array_t*) array)->data); free(array); } diff --git a/test/Python/.gitignore b/test/Python/.gitignore new file mode 100644 index 0000000000..08f514ebc5 --- /dev/null +++ b/test/Python/.gitignore @@ -0,0 +1 @@ +include/ diff --git a/util/tracing/.gitignore b/util/tracing/.gitignore new file mode 100644 index 0000000000..5fe4f5283d --- /dev/null +++ b/util/tracing/.gitignore @@ -0,0 +1,2 @@ +*.o +trace_to_csv diff --git a/util/tracing/trace_to_chrome.c b/util/tracing/trace_to_chrome.c index 92eeee71dd..5cf979227a 100644 --- a/util/tracing/trace_to_chrome.c +++ b/util/tracing/trace_to_chrome.c @@ -31,6 +31,7 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * point your chrome browser to chrome://tracing/ and the load the .json file. */ #define LF_TRACE +#include #include "reactor.h" #include "trace.h" #include "trace_util.h" @@ -92,7 +93,7 @@ size_t read_and_write_trace(FILE* trace_file, FILE* output_file) { if (reactor_name == NULL) { if (trace[i].event_type == worker_wait_starts || trace[i].event_type == worker_wait_ends) { reactor_name = "WAIT"; - } else if (trace[i].event_type == scheduler_advancing_time_starts + } else if (trace[i].event_type == scheduler_advancing_time_starts || trace[i].event_type == scheduler_advancing_time_starts) { reactor_name = "ADVANCE TIME"; } else { @@ -194,7 +195,7 @@ size_t read_and_write_trace(FILE* trace_file, FILE* output_file) { phase = "E"; break; default: - fprintf(stderr, "WARNING: Unrecognized event type %d: %s\n", + fprintf(stderr, "WARNING: Unrecognized event type %d: %s\n", trace[i].event_type, trace_event_names[trace[i].event_type]); pid = PID_FOR_UNKNOWN_EVENT; phase = "i"; @@ -275,7 +276,7 @@ void write_metadata_events(FILE* output_file) { "\"pid\": 0, " "\"tid\": 0, " "\"args\": {" - "\"name\": \"Main thread\"" + "\"name\": \"Main thread\"" "}},\n" ); @@ -328,7 +329,7 @@ void write_metadata_events(FILE* output_file) { ); } } - + // Write the reactor names for the logical timelines. for (int i = 0; i < object_table_size; i++) { if (object_table[i].type == trace_trigger) { @@ -341,10 +342,10 @@ void write_metadata_events(FILE* output_file) { "\"pid\": %d, " // the "process" to identify by reactor. "\"tid\": %d," // The "thread" to label with action or timer name. "\"args\": {" - "\"name\": \"Trigger %s\"" + "\"name\": \"Trigger %s\"" "}},\n", reactor_index + 1, // Offset of 1 prevents collision with Execution. - i, + i, object_table[i].description); } else if (object_table[i].type == trace_reactor) { fprintf(output_file, "{" @@ -352,7 +353,7 @@ void write_metadata_events(FILE* output_file) { "\"ph\": \"M\", " // mark as metadata. "\"pid\": %d, " // the "process" to label as reactor. "\"args\": {" - "\"name\": \"Reactor %s reactions, actions, and timers in logical time\"" + "\"name\": \"Reactor %s reactions, actions, and timers in logical time\"" "}},\n", i + 1, // Offset of 1 prevents collision with Execution. object_table[i].description); @@ -363,7 +364,7 @@ void write_metadata_events(FILE* output_file) { "\"pid\": %d, " // the "process" to label as reactor. "\"tid\": %d," // The "thread" to label with action or timer name. "\"args\": {" - "\"name\": \"%s\"" + "\"name\": \"%s\"" "}},\n", PID_FOR_USER_EVENT, i, // This is the index in the object table. @@ -376,7 +377,7 @@ void write_metadata_events(FILE* output_file) { "\"ph\": \"M\", " // mark as metadata. "\"pid\": 0, " // the "process" to label "Execution". "\"args\": {" - "\"name\": \"Execution of %s\"" + "\"name\": \"Execution of %s\"" "}},\n", top_level); // Name the "process" for "Worker Waiting" if the PID is not the main execution one. @@ -386,7 +387,7 @@ void write_metadata_events(FILE* output_file) { "\"ph\": \"M\", " // mark as metadata. "\"pid\": %d, " // the "process" to label "Workers waiting for reaction queue". "\"args\": {" - "\"name\": \"Workers waiting for reaction queue\"" + "\"name\": \"Workers waiting for reaction queue\"" "}},\n", PID_FOR_WORKER_WAIT); } @@ -397,7 +398,7 @@ void write_metadata_events(FILE* output_file) { "\"ph\": \"M\", " // mark as metadata. "\"pid\": %d, " // the "process" to label "Workers waiting for reaction queue". "\"args\": {" - "\"name\": \"Workers advancing time\"" + "\"name\": \"Workers advancing time\"" "}},\n", PID_FOR_WORKER_ADVANCING_TIME); } @@ -408,7 +409,7 @@ void write_metadata_events(FILE* output_file) { "\"ph\": \"M\", " // mark as metadata. "\"pid\": %d, " // the "process" to label "User events". "\"args\": {" - "\"name\": \"User events in %s, shown in physical time:\"" + "\"name\": \"User events in %s, shown in physical time:\"" "}}\n", PID_FOR_USER_EVENT, top_level); } diff --git a/util/tracing/trace_to_csv.c b/util/tracing/trace_to_csv.c index 707cc5f43b..1abf08c082 100644 --- a/util/tracing/trace_to_csv.c +++ b/util/tracing/trace_to_csv.c @@ -30,6 +30,8 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * text file. */ #define LF_TRACE +#include +#include #include "reactor.h" #include "trace.h" #include "trace_util.h" @@ -84,7 +86,7 @@ typedef struct summary_stats_t { reaction_stats_t reactions[MAX_NUM_REACTIONS]; } summary_stats_t; -/** +/** * Sumary stats array. This array has the same size as the * object table. Pointer in the array will be void if there * are no stats for the object table item. @@ -135,7 +137,7 @@ size_t read_and_write_trace() { if (trigger_instance >= 0 && summary_stats[NUM_EVENT_TYPES + trigger_instance] == NULL) { summary_stats[NUM_EVENT_TYPES + trigger_instance] = (summary_stats_t*)calloc(1, sizeof(summary_stats_t)); } - + summary_stats_t* stats = NULL; interval_t exec_time; reaction_stats_t* rstats; @@ -198,7 +200,7 @@ size_t read_and_write_trace() { // commandeer the first entry in the reactions array to track values. stats = summary_stats[NUM_EVENT_TYPES + object_instance]; stats->description = reactor_name; - rstats = &stats->reactions[0]; + rstats = &stats->reactions[0]; rstats->occurrences++; // User values are stored in the "extra_delay" field, which is an interval_t. interval_t value = trace[i].extra_delay; @@ -332,7 +334,7 @@ void write_summary_file() { first = true; for (int i = NUM_EVENT_TYPES; i < table_size; i++) { summary_stats_t* stats = summary_stats[i]; - if (stats != NULL + if (stats != NULL && (stats->event_type == user_event || stats->event_type == user_value) && stats->occurrences > 0) { if (first) { diff --git a/util/tracing/trace_to_influxdb.c b/util/tracing/trace_to_influxdb.c index a99ae003ec..aa50911e5e 100644 --- a/util/tracing/trace_to_influxdb.c +++ b/util/tracing/trace_to_influxdb.c @@ -27,13 +27,13 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * @section DESCRIPTION - * + * * Standalone program to send a Lingua Franca trace file to InfluxDB. * InfluxDB is a database server to which data can be posted using HTTP * or sent as a UDP datagram. - * + * * ## Compiling this Program - * + * * To compile this program, simply do this in this source directory: * ``` * make install @@ -41,13 +41,13 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * This will place an executable program `trace_to_influxdb` in the directory `lingua-franca/bin`. * I find it convenient to have this directory in my `PATH` (this is also where the * `lfc` command-line Lingua Franca compiler is located). - * + * * ## Setting up InfluxDB - * + * * To set up InfluxDB, see: - * + * * [https://docs.influxdata.com/influxdb/v2.0/get-started/](https://docs.influxdata.com/influxdb/v2.0/get-started/) - * + * * If you have previously installed InfluxDB and you want a fresh start, do this: * ```shell * rm -rf ~/.influxdbv2/ @@ -58,13 +58,13 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * kill -9 PID * ``` * where 'PID' is replaced with whatever process ID(s) are reported by the `ps` command above. - * + * * To start an InfluxDB server on localhost with port 8087: * ```shell * influxd --http-bind-address :8087 --reporting-disabled * ``` * The 'reporting-disabled' option simply disables notifications to the InfluxDB mother ship. - * + * * You then need to set up at least one user, organization, and bucket. You can do this by pointing your browser to * ``` * http://localhost:8087 @@ -77,9 +77,9 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ``` * The UI in the browser will then give you the options Quick Start or Advanced, either of which you can select. * If you select "Data" on the left, you can browse Buckets to verify that your test bucket was created. - * + * * ## Uploading Trace Data to InfluxDB - * + * * First, generate a trace file by setting a target parameter in a Lingua Franca program: * ``` * target C { @@ -87,7 +87,7 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * }; * ``` * Then, when you run this program, a binary file with extension `.lft` will be created. - * + * * In your browser, in the InfluxDB UI, select Data on the left, then select the Tokens tab. * Select a token and copy the token string to clipboard. It will looks something like this: * ``` @@ -100,15 +100,16 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ``` * where 'Filename' and the token are replaced with your values. * This will upload the trace data to InfluxDB. - * + * * You can also specify the following command-line options: * * -h, --host: The host name running InfluxDB. If not given, this defaults to "localhost". * * -p, --port: The port for accessing InfluxDB. This defaults to 8086. If you used 8087, as shown above, then you have to give this option. - * + * * The data can then be viewed in the InfluxDB browser, or you can configure an external * tool such as Grafana to visualize it (see https://grafana.com/docs/grafana/latest/datasources/influxdb/). */ #define LF_TRACE +#include #include "reactor.h" #include "trace.h" #include "trace_util.h" @@ -208,7 +209,7 @@ int main(int argc, char* argv[]) { influx_v2_client.token = NULL; influx_v2_client.host = "localhost"; influx_v2_client.port = 8086; - influx_v2_client.org = "iCyPhy"; + influx_v2_client.org = "iCyPhy"; influx_v2_client.bucket = "test"; char* filename = NULL; @@ -277,4 +278,4 @@ int main(int argc, char* argv[]) { printf("***** %zu records written to InfluxDB.\n", num_records); // File closing is handled by termination function. } -} \ No newline at end of file +} diff --git a/util/tracing/trace_util.c b/util/tracing/trace_util.c index 0f97b3bdb9..551ec94473 100644 --- a/util/tracing/trace_util.c +++ b/util/tracing/trace_util.c @@ -30,6 +30,9 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * text file. */ #define LF_TRACE +#include +#include +#include #include "reactor.h" #include "trace.h" #include "trace_util.h" @@ -187,12 +190,12 @@ void print_table() { } else { type = "unknown type"; } - printf("pointer = %p, trigger = %p, type = %s: %s\n", + printf("pointer = %p, trigger = %p, type = %s: %s\n", object_table[i].pointer, object_table[i].trigger, type, object_table[i].description); - } + } printf("-------\n"); } From 40b075a460e5d1ce8ec5a11f5dc8b79b3922ddfa Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Wed, 19 Apr 2023 15:45:25 +0500 Subject: [PATCH 140/709] Update Reactor-C --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 866b189a4f..8523f14b96 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 866b189a4f04d3fae7a50a256b8ca3686ea1c509 +Subproject commit 8523f14b962ae56aad375dde22141a600821fdce From e39e1e9e9c84cb910287b231a4d5de36a1ff0294 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Wed, 19 Apr 2023 21:28:59 +0500 Subject: [PATCH 141/709] [C-Generics] Fix the case where Contained Reactor is initiated with a combination of Templated Types and Concrete Types Signed-off-by: mkhubaibumer --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 4d628de5b4..99540cce83 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -949,6 +949,9 @@ private void resolveTemplatedTypes(ReactorInstance reactorInstance, TypeParamete if (parentTpr.typeArgs().containsKey(type)) { var basicType = parentTpr.typeArgs().get(type); copy.put(literal, basicType); + } else { + // Typename is not inherited from Parent Reactor. Keep As Is! + copy.put(literal, typename); } }); if (!copy.isEmpty()) { // If we found some templated-types update the tpr with new map From 414970ff2c04df9e62d866b1d2b75f4e361f175a Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Thu, 20 Apr 2023 11:17:59 +0900 Subject: [PATCH 142/709] Fix ssh --- .github/workflows/c-tests.yml | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index da060ce38a..ce13f0cee8 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -24,10 +24,8 @@ jobs: platform: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.platform }} steps: - - uses: actions/checkout@v2 - - name: Setup upterm session - uses: lhotari/action-upterm@v1 - steps: + - name: Setup upterm session + uses: lhotari/action-upterm@v1 - name: Check out lingua-franca repository uses: actions/checkout@v3 with: From b63b27546ba93664566963683f5f427813358769 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Thu, 20 Apr 2023 13:56:29 +0900 Subject: [PATCH 143/709] Fix ssh to last --- .github/workflows/c-tests.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index ce13f0cee8..ed1ba0d784 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -24,8 +24,6 @@ jobs: platform: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.platform }} steps: - - name: Setup upterm session - uses: lhotari/action-upterm@v1 - name: Check out lingua-franca repository uses: actions/checkout@v3 with: @@ -74,3 +72,5 @@ jobs: fail_ci_if_error: false verbose: true if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI + - name: Setup upterm session + uses: lhotari/action-upterm@v1 \ No newline at end of file From b95830e7ae3b0894a54dfe0aeeba62cbc2b0db95 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 20 Apr 2023 11:08:57 -0700 Subject: [PATCH 144/709] issues fixed w watchdog test, seems to be working as expected, not sure why though --- org.lflang/src/org/lflang/ASTUtils.java | 3091 +++++++++-------- .../org/lflang/generator/c/CGenerator.java | 10 +- .../generator/c/CReactionGenerator.java | 2 +- .../generator/c/CWatchdogGenerator.java | 3 +- test/C/src/Watchdog.lf | 4 +- 5 files changed, 1605 insertions(+), 1505 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 996ce1509f..9c3003007e 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -1,16 +1,12 @@ /* Copyright (c) 2020, The University of California at Berkeley. - 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. - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -25,9 +21,6 @@ package org.lflang; -import com.google.common.collect.HashMultimap; -import com.google.common.collect.Iterables; -import com.google.common.collect.Iterators; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; @@ -35,6 +28,7 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.function.Predicate; import java.util.regex.Matcher; @@ -42,6 +36,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; + import org.eclipse.emf.common.util.EList; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EStructuralFeature; @@ -62,6 +57,8 @@ import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.Assignment; +import org.lflang.lf.AttrParm; +import org.lflang.lf.Attribute; import org.lflang.lf.Code; import org.lflang.lf.Connection; import org.lflang.lf.Element; @@ -95,1640 +92,1740 @@ import org.lflang.lf.WidthTerm; import org.lflang.util.StringUtil; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Iterators; + /** * A helper class for modifying and analyzing the AST. - * * @author Marten Lohstroh * @author Edward A. Lee * @author Christian Menard */ public class ASTUtils { - /** The Lingua Franca factory for creating new AST nodes. */ - public static final LfFactory factory = LfFactory.eINSTANCE; - - /** The Lingua Franca feature package. */ - public static final LfPackage featurePackage = LfPackage.eINSTANCE; - - /* Match an abbreviated form of a float literal. */ - private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); - - /** - * A mapping from Reactor features to corresponding Mode features for collecting contained - * elements. - */ - private static final Map reactorModeFeatureMap = - Map.of( - featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), - featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), - featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), - featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), - featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), - featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), - featurePackage.getReactor_Watchdogs(), featurePackage.getMode_Watchdogs()); - - /** - * Get all reactors defined in the given resource. - * - * @param resource the resource to extract reactors from - * @return An iterable over all reactors found in the resource - */ - public static List getAllReactors(Resource resource) { - return StreamSupport.stream( - IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) - .filter(Reactor.class::isInstance) - .map(Reactor.class::cast) - .collect(Collectors.toList()); - } + /** + * The Lingua Franca factory for creating new AST nodes. + */ + public static final LfFactory factory = LfFactory.eINSTANCE; + + /** + * The Lingua Franca feature package. + */ + public static final LfPackage featurePackage = LfPackage.eINSTANCE; + + /* Match an abbreviated form of a float literal. */ + private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); + + /** + * A mapping from Reactor features to corresponding Mode features for collecting contained elements. + */ + private static final Map reactorModeFeatureMap = Map.of( + featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), + featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), + featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), + featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), + featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), + featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), + featurePackage.getReactor_Watchdogs(), featurePackage.getMode_Watchdogs() + ); + + + /** + * Get all reactors defined in the given resource. + * @param resource the resource to extract reactors from + * @return An iterable over all reactors found in the resource + */ + public static List getAllReactors(Resource resource) { + return StreamSupport.stream(IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) + .filter(Reactor.class::isInstance) + .map(Reactor.class::cast) + .collect(Collectors.toList()); + } + + /** + * Find connections in the given resource that would be conflicting writes if they were not located in mutually + * exclusive modes. + * + * @param resource The AST. + * @return a list of connections being able to be transformed + */ + public static Collection findConflictingConnectionsInModalReactors(Resource resource) { + var transform = new HashSet(); + + for (Reactor reactor : getAllReactors(resource)) { + if (!reactor.getModes().isEmpty()) { // Only for modal reactors + var allWriters = HashMultimap., EObject>create(); + + // Collect destinations + for (var rea : allReactions(reactor)) { + for (var eff : rea.getEffects()) { + if (eff.getVariable() instanceof Port) { + allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); + } + } + } + for (var con : ASTUtils.collectElements(reactor, featurePackage.getReactor_Connections(), false, true)) { + for (var port : con.getRightPorts()) { + allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); + } + } - /** - * Find connections in the given resource that would be conflicting writes if they were not - * located in mutually exclusive modes. - * - * @param resource The AST. - * @return a list of connections being able to be transformed - */ - public static Collection findConflictingConnectionsInModalReactors( - Resource resource) { - var transform = new HashSet(); - - for (Reactor reactor : getAllReactors(resource)) { - if (!reactor.getModes().isEmpty()) { // Only for modal reactors - var allWriters = HashMultimap., EObject>create(); - - // Collect destinations - for (var rea : allReactions(reactor)) { - for (var eff : rea.getEffects()) { - if (eff.getVariable() instanceof Port) { - allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); + // Handle conflicting writers + for (var key : allWriters.keySet()) { + var writers = allWriters.get(key); + if (writers.size() > 1) { // has multiple sources + var writerModes = HashMultimap.create(); + // find modes + for (var writer : writers) { + if (writer.eContainer() instanceof Mode) { + writerModes.put((Mode) writer.eContainer(), writer); + } else { + writerModes.put(null, writer); + } + } + // Conflicting connection can only be handled if.. + if (!writerModes.containsKey(null) && // no writer is on root level (outside of modes) and... + writerModes.keySet().stream().map(writerModes::get).allMatch(writersInMode -> // all writers in a mode are either... + writersInMode.size() == 1 || // the only writer or... + writersInMode.stream().allMatch(w -> w instanceof Reaction) // all are reactions and hence ordered + )) { + // Add connections to transform list + writers.stream().filter(w -> w instanceof Connection).forEach(c -> transform.add((Connection) c)); + } + } + } } - } - } - for (var con : - ASTUtils.collectElements( - reactor, featurePackage.getReactor_Connections(), false, true)) { - for (var port : con.getRightPorts()) { - allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); - } } - // Handle conflicting writers - for (var key : allWriters.keySet()) { - var writers = allWriters.get(key); - if (writers.size() > 1) { // has multiple sources - var writerModes = HashMultimap.create(); - // find modes - for (var writer : writers) { - if (writer.eContainer() instanceof Mode) { - writerModes.put((Mode) writer.eContainer(), writer); - } else { - writerModes.put(null, writer); - } - } - // Conflicting connection can only be handled if.. - if (!writerModes.containsKey(null) - && // no writer is on root level (outside of modes) and... - writerModes.keySet().stream() - .map(writerModes::get) - .allMatch( - writersInMode -> // all writers in a mode are either... - writersInMode.size() == 1 - || // the only writer or... - writersInMode.stream() - .allMatch( - w -> - w - instanceof - Reaction) // all are reactions and hence ordered - )) { - // Add connections to transform list - writers.stream() - .filter(w -> w instanceof Connection) - .forEach(c -> transform.add((Connection) c)); - } - } + return transform; + } + + /** + * Return the enclosing reactor of an LF EObject in a reactor or mode. + * @param obj the LF model element + * @return the reactor or null + */ + public static Reactor getEnclosingReactor(EObject obj) { + if (obj.eContainer() instanceof Reactor) { + return (Reactor) obj.eContainer(); + } else if (obj.eContainer() instanceof Mode) { + return (Reactor) obj.eContainer().eContainer(); } - } + return null; } - return transform; - } + /** + * Return the main reactor in the given resource if there is one, null otherwise. + */ + public static Reactor findMainReactor(Resource resource) { + return IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), + Reactor::isMain + ); + } - /** - * Return the enclosing reactor of an LF EObject in a reactor or mode. - * - * @param obj the LF model element - * @return the reactor or null - */ - public static Reactor getEnclosingReactor(EObject obj) { - if (obj.eContainer() instanceof Reactor) { - return (Reactor) obj.eContainer(); - } else if (obj.eContainer() instanceof Mode) { - return (Reactor) obj.eContainer().eContainer(); - } - return null; - } + /** + * Find the main reactor and change it to a federated reactor. + * Return true if the transformation was successful (or the given resource + * already had a federated reactor); return false otherwise. + */ + public static boolean makeFederated(Resource resource) { + // Find the main reactor + Reactor r = findMainReactor(resource); + if (r == null) { + return false; + } + r.setMain(false); + r.setFederated(true); + return true; + } - /** Return the main reactor in the given resource if there is one, null otherwise. */ - public static Reactor findMainReactor(Resource resource) { - return IteratorExtensions.findFirst( - Iterators.filter(resource.getAllContents(), Reactor.class), Reactor::isMain); - } + /** + * Change the target name to 'newTargetName'. + * For example, change C to CCpp. + */ + public static boolean changeTargetName(Resource resource, String newTargetName) { + targetDecl(resource).setName(newTargetName); + return true; + } - /** - * Find the main reactor and change it to a federated reactor. Return true if the transformation - * was successful (or the given resource already had a federated reactor); return false otherwise. - */ - public static boolean makeFederated(Resource resource) { - // Find the main reactor - Reactor r = findMainReactor(resource); - if (r == null) { - return false; - } - r.setMain(false); - r.setFederated(true); - return true; - } + /** + * Return the target of the file in which the given node lives. + */ + public static Target getTarget(EObject object) { + TargetDecl targetDecl = targetDecl(object.eResource()); + return Target.fromDecl(targetDecl); + } - /** Change the target name to 'newTargetName'. For example, change C to CCpp. */ - public static boolean changeTargetName(Resource resource, String newTargetName) { - targetDecl(resource).setName(newTargetName); - return true; - } + /** + * Add a new target property to the given resource. + * + * This also creates a config object if the resource does not yey have one. + * + * @param resource The resource to modify + * @param name Name of the property to add + * @param value Value to be assigned to the property + */ + public static boolean addTargetProperty(final Resource resource, final String name, final Element value) { + var config = targetDecl(resource).getConfig(); + if (config == null) { + config = LfFactory.eINSTANCE.createKeyValuePairs(); + targetDecl(resource).setConfig(config); + } + final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); + newProperty.setName(name); + newProperty.setValue(value); + config.getPairs().add(newProperty); + return true; + } - /** Return the target of the file in which the given node lives. */ - public static Target getTarget(EObject object) { - TargetDecl targetDecl = targetDecl(object.eResource()); - return Target.fromDecl(targetDecl); - } + /** + * Return true if the connection involves multiple ports on the left or right side of the connection, or + * if the port on the left or right of the connection involves a bank of reactors or a multiport. + * @param connection The connection. + */ + public static boolean hasMultipleConnections(Connection connection) { + if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { + return true; + } + VarRef leftPort = connection.getLeftPorts().get(0); + VarRef rightPort = connection.getRightPorts().get(0); + Instantiation leftContainer = leftPort.getContainer(); + Instantiation rightContainer = rightPort.getContainer(); + Port leftPortAsPort = (Port) leftPort.getVariable(); + Port rightPortAsPort = (Port) rightPort.getVariable(); + return leftPortAsPort.getWidthSpec() != null + || leftContainer != null && leftContainer.getWidthSpec() != null + || rightPortAsPort.getWidthSpec() != null + || rightContainer != null && rightContainer.getWidthSpec() != null; + } - /** - * Add a new target property to the given resource. - * - *

This also creates a config object if the resource does not yey have one. - * - * @param resource The resource to modify - * @param name Name of the property to add - * @param value Value to be assigned to the property - */ - public static boolean addTargetProperty( - final Resource resource, final String name, final Element value) { - var config = targetDecl(resource).getConfig(); - if (config == null) { - config = LfFactory.eINSTANCE.createKeyValuePairs(); - targetDecl(resource).setConfig(config); - } - final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); - newProperty.setName(name); - newProperty.setValue(value); - config.getPairs().add(newProperty); - return true; - } + /** + * Produce a unique identifier within a reactor based on a + * given based name. If the name does not exists, it is returned; + * if does exist, an index is appended that makes the name unique. + * @param reactor The reactor to find a unique identifier within. + * @param name The name to base the returned identifier on. + */ + public static String getUniqueIdentifier(Reactor reactor, String name) { + LinkedHashSet vars = new LinkedHashSet<>(); + allActions(reactor).forEach(it -> vars.add(it.getName())); + allTimers(reactor).forEach(it -> vars.add(it.getName())); + allParameters(reactor).forEach(it -> vars.add(it.getName())); + allInputs(reactor).forEach(it -> vars.add(it.getName())); + allOutputs(reactor).forEach(it -> vars.add(it.getName())); + allStateVars(reactor).forEach(it -> vars.add(it.getName())); + allInstantiations(reactor).forEach(it -> vars.add(it.getName())); + + int index = 0; + String suffix = ""; + boolean exists = true; + while (exists) { + String id = name + suffix; + if (IterableExtensions.exists(vars, it -> it.equals(id))) { + suffix = "_" + index; + index++; + } else { + exists = false; + } + } + return name + suffix; + } - /** - * Return true if the connection involves multiple ports on the left or right side of the - * connection, or if the port on the left or right of the connection involves a bank of reactors - * or a multiport. - * - * @param connection The connection. - */ - public static boolean hasMultipleConnections(Connection connection) { - if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { - return true; - } - VarRef leftPort = connection.getLeftPorts().get(0); - VarRef rightPort = connection.getRightPorts().get(0); - Instantiation leftContainer = leftPort.getContainer(); - Instantiation rightContainer = rightPort.getContainer(); - Port leftPortAsPort = (Port) leftPort.getVariable(); - Port rightPortAsPort = (Port) rightPort.getVariable(); - return leftPortAsPort.getWidthSpec() != null - || leftContainer != null && leftContainer.getWidthSpec() != null - || rightPortAsPort.getWidthSpec() != null - || rightContainer != null && rightContainer.getWidthSpec() != null; - } + //////////////////////////////// + //// Utility functions for supporting inheritance and modes + + /** + * Given a reactor class, return a list of all its actions, + * which includes actions of base classes that it extends. + * This also includes actions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allActions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); + } - /** - * Produce a unique identifier within a reactor based on a given based name. If the name does not - * exists, it is returned; if does exist, an index is appended that makes the name unique. - * - * @param reactor The reactor to find a unique identifier within. - * @param name The name to base the returned identifier on. - */ - public static String getUniqueIdentifier(Reactor reactor, String name) { - LinkedHashSet vars = new LinkedHashSet<>(); - allActions(reactor).forEach(it -> vars.add(it.getName())); - allTimers(reactor).forEach(it -> vars.add(it.getName())); - allParameters(reactor).forEach(it -> vars.add(it.getName())); - allInputs(reactor).forEach(it -> vars.add(it.getName())); - allOutputs(reactor).forEach(it -> vars.add(it.getName())); - allStateVars(reactor).forEach(it -> vars.add(it.getName())); - allInstantiations(reactor).forEach(it -> vars.add(it.getName())); - - int index = 0; - String suffix = ""; - boolean exists = true; - while (exists) { - String id = name + suffix; - if (IterableExtensions.exists(vars, it -> it.equals(id))) { - suffix = "_" + index; - index++; - } else { - exists = false; - } - } - return name + suffix; - } + /** + * Given a reactor class, return a list of all its connections, + * which includes connections of base classes that it extends. + * This also includes connections in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allConnections(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); + } - //////////////////////////////// - //// Utility functions for supporting inheritance and modes - - /** - * Given a reactor class, return a list of all its actions, which includes actions of base classes - * that it extends. This also includes actions in modes, returning a flattened view over all - * modes. - * - * @param definition Reactor class definition. - */ - public static List allActions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); - } + /** + * Given a reactor class, return a list of all its inputs, + * which includes inputs of base classes that it extends. + * If the base classes include a cycle, where X extends Y and Y extends X, + * then return only the input defined in the base class. + * The returned list may be empty. + * @param definition Reactor class definition. + */ + public static List allInputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); + } - /** - * Given a reactor class, return a list of all its connections, which includes connections of base - * classes that it extends. This also includes connections in modes, returning a flattened view - * over all modes. - * - * @param definition Reactor class definition. - */ - public static List allConnections(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); - } + /** A list of all ports of {@code definition}, in an unspecified order. */ + public static List allPorts(Reactor definition) { + return Stream.concat(ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()).toList(); + } - /** - * Given a reactor class, return a list of all its inputs, which includes inputs of base classes - * that it extends. If the base classes include a cycle, where X extends Y and Y extends X, then - * return only the input defined in the base class. The returned list may be empty. - * - * @param definition Reactor class definition. - */ - public static List allInputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); - } + /** + * Given a reactor class, return a list of all its instantiations, + * which includes instantiations of base classes that it extends. + * This also includes instantiations in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allInstantiations(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); + } - /** - * Given a reactor class, return a list of all its instantiations, which includes instantiations - * of base classes that it extends. This also includes instantiations in modes, returning a - * flattened view over all modes. - * - * @param definition Reactor class definition. - */ - public static List allInstantiations(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); - } + public static Stream allNestedClasses(Reactor definition) { + return new HashSet<>(ASTUtils.allInstantiations(definition)).stream() + .map(Instantiation::getReactorClass) + .map(ASTUtils::toDefinition); + } - /** - * Given a reactor class, return a list of all its methods, which includes methods of base classes - * that it extends. - * - * @param definition Reactor class definition. - */ - public static List allMethods(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); - } + /** + * Given a reactor class, return a list of all its methods, + * which includes methods of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allMethods(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); + } - /** - * Given a reactor class, return a list of all its outputs, which includes outputs of base classes - * that it extends. - * - * @param definition Reactor class definition. - */ - public static List allOutputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); - } + /** + * Given a reactor class, return a list of all its outputs, + * which includes outputs of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allOutputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); + } - /** - * Given a reactor class, return a list of all its parameters, which includes parameters of base - * classes that it extends. - * - * @param definition Reactor class definition. - */ - public static List allParameters(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); - } + /** + * Given a reactor class, return a list of all its parameters, + * which includes parameters of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allParameters(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); + } - /** - * Given a reactor class, return a list of all its reactions, which includes reactions of base - * classes that it extends. This also includes reactions in modes, returning a flattened view over - * all modes. - * - * @param definition Reactor class definition. - */ - public static List allReactions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); - } + /** + * Given a reactor class, return a list of all its reactions, + * which includes reactions of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allReactions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); + } - /** - * Given a reactor class, return a list of all its watchdogs. - * - * @param definition Reactor class definition - * @return List - */ - public static List allWatchdogs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); - } + /** + * Given a reactor class, return a list of all its watchdogs. + * @param definition Reactor class definition + * @return List + */ + public static List allWatchdogs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); + } + + /** + * Given a reactor class, return a list of all its state variables, + * which includes state variables of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allStateVars(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); + } - /** - * Given a reactor class, return a list of all its state variables, which includes state variables - * of base classes that it extends. This also includes reactions in modes, returning a flattened - * view over all modes. - * - * @param definition Reactor class definition. - */ - public static List allStateVars(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); - } + /** + * Given a reactor class, return a list of all its timers, + * which includes timers of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allTimers(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); + } - /** - * Given a reactor class, return a list of all its timers, which includes timers of base classes - * that it extends. This also includes reactions in modes, returning a flattened view over all - * modes. - * - * @param definition Reactor class definition. - */ - public static List allTimers(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); - } + /** + * Given a reactor class, returns a list of all its modes, + * which includes modes of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allModes(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); + } - /** - * Given a reactor class, returns a list of all its modes, which includes modes of base classes - * that it extends. - * - * @param definition Reactor class definition. - */ - public static List allModes(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); - } + /** A list of all reactors instantiated, transitively or intransitively, by {@code r}. */ + public static List recursiveChildren(ReactorInstance r) { + List ret = new ArrayList<>(); + ret.add(r.reactorDefinition); + for (var child: r.children) { + ret.addAll(recursiveChildren(child)); + } + return ret; + } - /** - * Return all the superclasses of the specified reactor in deepest-first order. For example, if A - * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates - * are removed. If the specified reactor does not extend any other reactor, then return an empty - * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared - * that is not found, then return null. - * - * @param reactor The specified reactor. - */ - public static LinkedHashSet superClasses(Reactor reactor) { - return superClasses(reactor, new LinkedHashSet<>()); - } + /** + * Return all the superclasses of the specified reactor + * in deepest-first order. For example, if A extends B and C, and + * B and C both extend D, this will return the list [D, B, C, A]. + * Duplicates are removed. If the specified reactor does not extend + * any other reactor, then return an empty list. + * If a cycle is found, where X extends Y and Y extends X, or if + * a superclass is declared that is not found, then return null. + * @param reactor The specified reactor. + */ + public static LinkedHashSet superClasses(Reactor reactor) { + return superClasses(reactor, new LinkedHashSet<>()); + } - /** - * Collect elements of type T from the class hierarchy and modes defined by a given reactor - * definition. - * - * @param definition The reactor definition. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - public static List collectElements( - Reactor definition, EStructuralFeature feature) { - return ASTUtils.collectElements(definition, feature, true, true); - } + /** + * Collect elements of type T from the class hierarchy and modes + * defined by a given reactor definition. + * @param definition The reactor definition. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + public static List collectElements(Reactor definition, EStructuralFeature feature) { + return ASTUtils.collectElements(definition, feature, true, true); + } - /** - * Collect elements of type T contained in given reactor definition, including modes and the class - * hierarchy defined depending on configuration. - * - * @param definition The reactor definition. - * @param feature The structual model elements to collect. - * @param includeSuperClasses Whether to include elements in super classes. - * @param includeModes Whether to include elements in modes. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - @SuppressWarnings("unchecked") - public static List collectElements( - Reactor definition, - EStructuralFeature feature, - boolean includeSuperClasses, - boolean includeModes) { - List result = new ArrayList<>(); - - if (includeSuperClasses) { - // Add elements of elements defined in superclasses. - LinkedHashSet s = superClasses(definition); - if (s != null) { - for (Reactor superClass : s) { - result.addAll((EList) superClass.eGet(feature)); + /** + * Collect elements of type T contained in given reactor definition, including + * modes and the class hierarchy defined depending on configuration. + * @param definition The reactor definition. + * @param feature The structual model elements to collect. + * @param includeSuperClasses Whether to include elements in super classes. + * @param includeModes Whether to include elements in modes. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + @SuppressWarnings("unchecked") + public static List collectElements(Reactor definition, EStructuralFeature feature, boolean includeSuperClasses, boolean includeModes) { + List result = new ArrayList<>(); + + if (includeSuperClasses) { + // Add elements of elements defined in superclasses. + LinkedHashSet s = superClasses(definition); + if (s != null) { + for (Reactor superClass : s) { + result.addAll((EList) superClass.eGet(feature)); + } + } } - } - } - // Add elements of the current reactor. - result.addAll((EList) definition.eGet(feature)); + // Add elements of the current reactor. + result.addAll((EList) definition.eGet(feature)); + + if (includeModes && reactorModeFeatureMap.containsKey(feature)) { + var modeFeature = reactorModeFeatureMap.get(feature); + // Add elements of elements defined in modes. + for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { + insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); + } + } - if (includeModes && reactorModeFeatureMap.containsKey(feature)) { - var modeFeature = reactorModeFeatureMap.get(feature); - // Add elements of elements defined in modes. - for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { - insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); - } + return result; } - return result; - } + /** + * Adds the elements into the given list at a location matching to their textual position. + * + * When creating a flat view onto reactor elements including modes, the final list must be ordered according + * to the textual positions. + * + * Example: + * reactor R { + * reaction // -> is R.reactions[0] + * mode M { + * reaction // -> is R.mode[0].reactions[0] + * reaction // -> is R.mode[0].reactions[1] + * } + * reaction // -> is R.reactions[1] + * } + * In this example, it is important that the reactions in the mode are inserted between the top-level + * reactions to retain the correct global reaction ordering, which will be derived from this flattened view. + * + * @param list The list to add the elements into. + * @param elements The elements to add. + * @param mode The mode containing the elements. + * @param The type of elements to add (e.g., Port, Timer, etc.) + */ + private static void insertModeElementsAtTextualPosition(List list, List elements, Mode mode) { + if (elements.isEmpty()) { + return; // Nothing to add + } - /** - * Adds the elements into the given list at a location matching to their textual position. - * - *

When creating a flat view onto reactor elements including modes, the final list must be - * ordered according to the textual positions. - * - *

Example: reactor R { reaction // -> is R.reactions[0] mode M { reaction // -> is - * R.mode[0].reactions[0] reaction // -> is R.mode[0].reactions[1] } reaction // -> is - * R.reactions[1] } In this example, it is important that the reactions in the mode are inserted - * between the top-level reactions to retain the correct global reaction ordering, which will be - * derived from this flattened view. - * - * @param list The list to add the elements into. - * @param elements The elements to add. - * @param mode The mode containing the elements. - * @param The type of elements to add (e.g., Port, Timer, etc.) - */ - private static void insertModeElementsAtTextualPosition( - List list, List elements, Mode mode) { - if (elements.isEmpty()) { - return; // Nothing to add - } - - var idx = list.size(); - if (idx > 0) { - // If there are elements in the list, first check if the last element has the same container - // as the mode. - // I.e. we don't want to compare textual positions of different reactors (super classes) - if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { - var modeAstNode = NodeModelUtils.getNode(mode); - if (modeAstNode != null) { - var modePos = modeAstNode.getOffset(); - // Now move the insertion index from the last element forward as long as this element has - // a textual - // position after the mode. - do { - var astNode = NodeModelUtils.getNode(list.get(idx - 1)); - if (astNode != null && astNode.getOffset() > modePos) { - idx--; - } else { - break; // Insertion index is ok. + var idx = list.size(); + if (idx > 0) { + // If there are elements in the list, first check if the last element has the same container as the mode. + // I.e. we don't want to compare textual positions of different reactors (super classes) + if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { + var modeAstNode = NodeModelUtils.getNode(mode); + if (modeAstNode != null) { + var modePos = modeAstNode.getOffset(); + // Now move the insertion index from the last element forward as long as this element has a textual + // position after the mode. + do { + var astNode = NodeModelUtils.getNode(list.get(idx - 1)); + if (astNode != null && astNode.getOffset() > modePos) { + idx--; + } else { + break; // Insertion index is ok. + } + } while (idx > 0); + } } - } while (idx > 0); } - } + list.addAll(idx, elements); } - list.addAll(idx, elements); - } - - public static Iterable allElementsOfClass( - Resource resource, Class elementClass) { - //noinspection StaticPseudoFunctionalStyleMethod - return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); - } - //////////////////////////////// - //// Utility functions for translating AST nodes into text - - // public static Code toCode(String text) { - // Code code = null; - // if (text == null) return code; - // code.setBody(text); - // return code; - // } - - /** - * Translate the given code into its textual representation with {@code CodeMap.Correspondence} - * tags inserted, or return the empty string if {@code node} is {@code null}. This method should - * be used to generate code. - * - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toText(EObject node) { - if (node == null) return ""; - return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); - } + public static Iterable allElementsOfClass( + Resource resource, + Class elementClass + ) { + //noinspection StaticPseudoFunctionalStyleMethod + return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); + } - /** - * Translate the given code into its textual representation without {@code CodeMap.Correspondence} - * tags, or return the empty string if {@code node} is {@code null}. This method should be used - * for analyzing AST nodes in cases where they are easiest to analyze as strings. - * - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toOriginalText(EObject node) { - if (node == null) return ""; - return ToText.instance.doSwitch(node); - } + //////////////////////////////// + //// Utility functions for translating AST nodes into text + + /** + * Translate the given code into its textual representation + * with {@code CodeMap.Correspondence} tags inserted, or + * return the empty string if {@code node} is {@code null}. + * This method should be used to generate code. + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toText(EObject node) { + if (node == null) return ""; + return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); + } - /** - * Return an integer representation of the given element. - * - *

Internally, this method uses Integer.decode, so it will also understand hexadecimal, binary, - * etc. - * - * @param e The element to be rendered as an integer. - */ - public static Integer toInteger(Element e) { - return Integer.decode(e.getLiteral()); - } + /** + * Translate the given code into its textual representation + * without {@code CodeMap.Correspondence} tags, or return + * the empty string if {@code node} is {@code null}. + * This method should be used for analyzing AST nodes in + * cases where they are easiest to analyze as strings. + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toOriginalText(EObject node) { + if (node == null) return ""; + return ToText.instance.doSwitch(node); + } - /** - * Return a time value based on the given element. - * - * @param e The element to be rendered as a time value. - */ - public static TimeValue toTimeValue(Element e) { - return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); - } + /** + * Return an integer representation of the given element. + * + * Internally, this method uses Integer.decode, so it will + * also understand hexadecimal, binary, etc. + * + * @param e The element to be rendered as an integer. + */ + public static Integer toInteger(Element e) { + return Integer.decode(e.getLiteral()); + } - /** Returns the time value represented by the given AST node. */ - public static TimeValue toTimeValue(Time e) { - if (!isValidTime(e)) { - // invalid unit, will have been reported by validator - throw new IllegalArgumentException(); + /** + * Return a time value based on the given element. + * + * @param e The element to be rendered as a time value. + */ + public static TimeValue toTimeValue(Element e) { + return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); } - return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); - } - /** - * Return a boolean based on the given element. - * - * @param e The element to be rendered as a boolean. - */ - public static boolean toBoolean(Element e) { - return elementToSingleString(e).equalsIgnoreCase("true"); - } + /** + * Returns the time value represented by the given AST node. + */ + public static TimeValue toTimeValue(Time e) { + if (!isValidTime(e)) { + // invalid unit, will have been reported by validator + throw new IllegalArgumentException(); + } + return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); + } - /** - * Given the right-hand side of a target property, return a string that represents the given - * value/ - * - *

If the given value is not a literal or and id (but for instance and array or dict), an empty - * string is returned. If the element is a string, any quotes are removed. - * - * @param e The right-hand side of a target property. - */ - public static String elementToSingleString(Element e) { - if (e.getLiteral() != null) { - return StringUtil.removeQuotes(e.getLiteral()).trim(); - } else if (e.getId() != null) { - return e.getId(); - } - return ""; - } + /** + * Return a boolean based on the given element. + * + * @param e The element to be rendered as a boolean. + */ + public static boolean toBoolean(Element e) { + return elementToSingleString(e).equalsIgnoreCase("true"); + } - /** - * Given the right-hand side of a target property, return a list with all the strings that the - * property lists. - * - *

Arrays are traversed, so strings are collected recursively. Empty strings are ignored; they - * are not added to the list. - * - * @param value The right-hand side of a target property. - */ - public static List elementToListOfStrings(Element value) { - List elements = new ArrayList<>(); - if (value.getArray() != null) { - for (Element element : value.getArray().getElements()) { - elements.addAll(elementToListOfStrings(element)); - } - return elements; - } else { - String v = elementToSingleString(value); - if (!v.isEmpty()) { - elements.add(v); - } - } - return elements; - } + /** + * Given the right-hand side of a target property, return a string that + * represents the given value/ + * + * If the given value is not a literal or and id (but for instance and array or dict), + * an empty string is returned. If the element is a string, any quotes are removed. + * + * @param e The right-hand side of a target property. + */ + public static String elementToSingleString(Element e) { + if (e.getLiteral() != null) { + return StringUtil.removeQuotes(e.getLiteral()).trim(); + } else if (e.getId() != null) { + return e.getId(); + } + return ""; + } - /** - * Convert key-value pairs in an Element to a map, assuming that both the key and the value are - * strings. - */ - public static Map elementToStringMaps(Element value) { - Map elements = new HashMap<>(); - for (var element : value.getKeyvalue().getPairs()) { - elements.put( - element.getName().trim(), - StringUtil.removeQuotes(elementToSingleString(element.getValue()))); - } - return elements; - } + /** + * Given the right-hand side of a target property, return a list with all + * the strings that the property lists. + * + * Arrays are traversed, so strings are collected recursively. Empty strings + * are ignored; they are not added to the list. + * @param value The right-hand side of a target property. + */ + public static List elementToListOfStrings(Element value) { + List elements = new ArrayList<>(); + if (value.getArray() != null) { + for (Element element : value.getArray().getElements()) { + elements.addAll(elementToListOfStrings(element)); + } + return elements; + } else { + String v = elementToSingleString(value); + if (!v.isEmpty()) { + elements.add(v); + } + } + return elements; + } - // Various utility methods to convert various data types to Elements - - /** Convert a map to key-value pairs in an Element. */ - public static Element toElement(Map map) { - Element e = LfFactory.eINSTANCE.createElement(); - if (map.size() == 0) return null; - else { - var kv = LfFactory.eINSTANCE.createKeyValuePairs(); - for (var entry : map.entrySet()) { - var pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(entry.getKey()); - var element = LfFactory.eINSTANCE.createElement(); - element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); - pair.setValue(element); - kv.getPairs().add(pair); - } - e.setKeyvalue(kv); - } - - return e; - } + /** + * Convert key-value pairs in an Element to a map, assuming that both the key + * and the value are strings. + */ + public static Map elementToStringMaps(Element value) { + Map elements = new HashMap<>(); + for (var element: value.getKeyvalue().getPairs()) { + elements.put( + element.getName().trim(), + StringUtil.removeQuotes(elementToSingleString(element.getValue())) + ); + } + return elements; + } - /** - * Given a single string, convert it into its AST representation. {@code addQuotes} controls if - * the generated representation should be accompanied by double quotes ("") or not. - */ - private static Element toElement(String str, boolean addQuotes) { - if (str == null) return null; - var strToReturn = addQuotes ? StringUtil.addDoubleQuotes(str) : str; - Element e = LfFactory.eINSTANCE.createElement(); - e.setLiteral(strToReturn); - return e; - } + // Various utility methods to convert various data types to Elements + + /** + * Convert a map to key-value pairs in an Element. + */ + public static Element toElement(Map map) { + Element e = LfFactory.eINSTANCE.createElement(); + if (map.size() == 0) return null; + else { + var kv = LfFactory.eINSTANCE.createKeyValuePairs(); + for (var entry : map.entrySet()) { + var pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(entry.getKey()); + var element = LfFactory.eINSTANCE.createElement(); + element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); + pair.setValue(element); + kv.getPairs().add(pair); + } + e.setKeyvalue(kv); + } - /** Given a single string, convert it into its AST representation. */ - public static Element toElement(String str) { - return toElement(str, true); - } + return e; + } - /** - * Given a list of strings, convert it into its AST representation. Stores the list in the Array - * field of the element, unless the list only has one string, in which case it is stored in the - * Literal field. Returns null if the provided list is empty. - */ - public static Element toElement(List list) { - Element e = LfFactory.eINSTANCE.createElement(); - if (list.size() == 0) return null; - else if (list.size() == 1) { - return toElement(list.get(0)); - } else { - var arr = LfFactory.eINSTANCE.createArray(); - for (String s : list) { - arr.getElements().add(ASTUtils.toElement(s)); - } - e.setArray(arr); - } - return e; - } + /** + * Given a single string, convert it into its AST representation. + * {@code addQuotes} controls if the generated representation should be + * accompanied by double quotes ("") or not. + */ + private static Element toElement(String str, boolean addQuotes) { + if (str == null) return null; + var strToReturn = addQuotes? StringUtil.addDoubleQuotes(str):str; + Element e = LfFactory.eINSTANCE.createElement(); + e.setLiteral(strToReturn); + return e; - /** - * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit - * inside an Element. - */ - public static Element toElement(TimeValue tv) { - Element e = LfFactory.eINSTANCE.createElement(); - e.setTime((int) tv.time); - if (tv.unit != null) { - e.setUnit(tv.unit.toString()); - } - return e; - } + } - public static Element toElement(boolean val) { - return toElement(Boolean.toString(val), false); - } + /** + * Given a single string, convert it into its AST representation. + */ + public static Element toElement(String str) { + return toElement(str, true); + } - public static Element toElement(int val) { - return toElement(Integer.toString(val), false); - } + /** + * Given a list of strings, convert it into its AST representation. + * Stores the list in the Array field of the element, unless the list only has one string, + * in which case it is stored in the Literal field. Returns null if the provided list is empty. + */ + public static Element toElement(List list) { + Element e = LfFactory.eINSTANCE.createElement(); + if (list.size() == 0) return null; + else if (list.size() == 1) { + return toElement(list.get(0)); + } else { + var arr = LfFactory.eINSTANCE.createArray(); + for (String s : list) { + arr.getElements().add(ASTUtils.toElement(s)); + } + e.setArray(arr); + } + return e; + } - /** - * Translate the given type into its textual representation, but do not append any array - * specifications or type arguments. - * - * @param type AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String baseType(Type type) { - if (type != null) { - if (type.getCode() != null) { - return toText(type.getCode()); - } else { - if (type.isTime()) { - return "time"; + /** + * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit inside an Element. + */ + public static Element toElement(TimeValue tv) { + Element e = LfFactory.eINSTANCE.createElement(); + e.setTime((int)tv.time); + if (tv.unit != null) { + e.setUnit(tv.unit.toString()); } - } + return e; } - return ""; - } - /** - * Report whether the given literal is zero or not. - * - * @param literal AST node to inspect. - * @return True if the given literal denotes the constant `0`, false otherwise. - */ - public static boolean isZero(String literal) { - try { - if (literal != null && Integer.parseInt(literal) == 0) { - return true; - } - } catch (NumberFormatException e) { - // Not an int. + public static Element toElement(boolean val) { + return toElement(Boolean.toString(val), false); } - return false; - } - /** - * Report whether the given expression is zero or not. - * - * @param expr AST node to inspect. - * @return True if the given value denotes the constant `0`, false otherwise. - */ - public static boolean isZero(Expression expr) { - if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; - } + public static Element toElement(int val) { + return toElement(Integer.toString(val), false); + } - /** - * Report whether the given string literal is an integer number or not. - * - * @param literal AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Integer.decode(literal); - } catch (NumberFormatException e) { - return false; - } - return true; - } + /** + * Translate the given type into its textual representation, but + * do not append any array specifications or type arguments. + * @param type AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String baseType(Type type) { + if (type != null) { + if (type.getCode() != null) { + return toText(type.getCode()); + } else { + if (type.isTime()) { + return "time"; + } else { + StringBuilder result = new StringBuilder(type.getId()); + + for (String s : convertToEmptyListIfNull(type.getStars())) { + result.append(s); + } + return result.toString(); + } + } + } + return ""; + } - /** - * Report whether the given string literal is a boolean value or not. - * - * @param literal AST node to inspect. - * @return True if the given value is a boolean, false otherwise. - */ - public static boolean isBoolean(String literal) { - return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); - } + /** + * Report whether the given literal is zero or not. + * @param literal AST node to inspect. + * @return True if the given literal denotes the constant `0`, false + * otherwise. + */ + public static boolean isZero(String literal) { + try { + if (literal != null && + Integer.parseInt(literal) == 0) { + return true; + } + } catch (NumberFormatException e) { + // Not an int. + } + return false; + } - /** - * Report whether the given string literal is a float value or not. - * - * @param literal AST node to inspect. - * @return True if the given value is a float, false otherwise. - */ - public static boolean isFloat(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Float.parseFloat(literal); - } catch (NumberFormatException e) { - return false; - } - return true; - } + /** + * Report whether the given expression is zero or not. + * + * @param expr AST node to inspect. + * @return True if the given value denotes the constant `0`, false otherwise. + */ + public static boolean isZero(Expression expr) { + if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; + } - /** - * Report whether the given code is an integer number or not. - * - * @param code AST node to inspect. - * @return True if the given code is an integer, false otherwise. - */ - public static boolean isInteger(Code code) { - return isInteger(toText(code)); - } + /** + * Report whether the given string literal is an integer number or not. + * + * @param literal AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Integer.decode(literal); + } catch (NumberFormatException e) { + return false; + } + return true; + } - /** - * Report whether the given expression is an integer number or not. - * - * @param expr AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(Expression expr) { - if (expr instanceof Literal) { - return isInteger(((Literal) expr).getLiteral()); - } else if (expr instanceof Code) { - return isInteger((Code) expr); - } - return false; - } + /** + * Report whether the given string literal is a boolean value or not. + * @param literal AST node to inspect. + * @return True if the given value is a boolean, false otherwise. + */ + public static boolean isBoolean(String literal) { + return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); + } - /** - * Report whether the given expression denotes a valid time or not. - * - * @param expr AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Expression expr) { - if (expr instanceof ParameterReference) { - return isOfTimeType(((ParameterReference) expr).getParameter()); - } else if (expr instanceof Time) { - return isValidTime((Time) expr); - } else if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; - } + /** + * Report whether the given string literal is a float value or not. + * @param literal AST node to inspect. + * @return True if the given value is a float, false otherwise. + */ + public static boolean isFloat(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Float.parseFloat(literal); + } catch (NumberFormatException e) { + return false; + } + return true; + } - /** - * Report whether the given time denotes a valid time or not. - * - * @param t AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Time t) { - if (t == null) return false; - String unit = t.getUnit(); - return t.getInterval() == 0 || TimeUnit.isValidUnit(unit); - } + /** + * Report whether the given code is an integer number or not. + * @param code AST node to inspect. + * @return True if the given code is an integer, false otherwise. + */ + public static boolean isInteger(Code code) { + return isInteger(toText(code)); + } - /** If the initializer contains exactly one expression, return it. Otherwise, return null. */ - public static Expression asSingleExpr(Initializer init) { - if (init == null) { - return null; + /** + * Report whether the given expression is an integer number or not. + * @param expr AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(Expression expr) { + if (expr instanceof Literal) { + return isInteger(((Literal) expr).getLiteral()); + } else if (expr instanceof Code) { + return isInteger((Code) expr); + } + return false; } - var exprs = init.getExprs(); - return exprs.size() == 1 ? exprs.get(0) : null; - } - public static boolean isSingleExpr(Initializer init) { - // todo expand that to = initialization - if (init == null) { - return false; + /** + * Report whether the given expression denotes a valid time or not. + * @param expr AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Expression expr) { + if (expr instanceof ParameterReference) { + return isOfTimeType(((ParameterReference)expr).getParameter()); + } else if (expr instanceof Time) { + return isValidTime((Time) expr); + } else if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; } - var exprs = init.getExprs(); - return exprs.size() == 1; - } - public static boolean isListInitializer(Initializer init) { - return init != null && !isSingleExpr(init); - } + /** + * Report whether the given time denotes a valid time or not. + * @param t AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Time t) { + if (t == null) return false; + String unit = t.getUnit(); + return t.getInterval() == 0 || + TimeUnit.isValidUnit(unit); + } - /** - * Return the type of a declaration with the given (nullable) explicit type, and the given - * (nullable) initializer. If the explicit type is null, then the type is inferred from the - * initializer. Only two types can be inferred: "time" and "timeList". Return the "undefined" type - * if neither can be inferred. - * - * @param type Explicit type declared on the declaration - * @param init The initializer expression - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Type type, Initializer init) { - if (type != null) { - return InferredType.fromAST(type); - } else if (init == null) { - return InferredType.undefined(); - } - - var single = asSingleExpr(init); - if (single != null) { - // If there is a single element in the list, and it is a proper - // time value with units, we infer the type "time". - if (single instanceof ParameterReference) { - return getInferredType(((ParameterReference) single).getParameter()); - } else if (single instanceof Time) { - return InferredType.time(); - } - } else if (init.getExprs().size() > 1) { - // If there are multiple elements in the list, and there is at - // least one proper time value with units, and all other elements - // are valid times (including zero without units), we infer the - // type "time list". - var allValidTime = true; - var foundNonZero = false; - - for (var e : init.getExprs()) { - if (!ASTUtils.isValidTime(e)) { - allValidTime = false; + /** + * If the initializer contains exactly one expression, + * return it. Otherwise, return null. + */ + public static Expression asSingleExpr(Initializer init) { + if (init == null) { + return null; } - if (!ASTUtils.isZero(e)) { - foundNonZero = true; - } - } + var exprs = init.getExprs(); + return exprs.size() == 1 ? exprs.get(0) : null; + } - if (allValidTime && foundNonZero) { - // Conservatively, no bounds are inferred; the returned type - // is a variable-size list. - return InferredType.timeList(); - } + public static boolean isSingleExpr(Initializer init) { + // todo expand that to = initialization + if (init == null) { + return false; + } + var exprs = init.getExprs(); + return exprs.size() == 1; } - return InferredType.undefined(); - } - /** - * Given a parameter, return an inferred type. Only two types can be inferred: "time" and - * "timeList". Return the "undefined" type if neither can be inferred. - * - * @param p A parameter to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Parameter p) { - return getInferredType(p.getType(), p.getInit()); - } + public static boolean isListInitializer(Initializer init) { + return init != null && !isSingleExpr(init); + } - /** - * Given a state variable, return an inferred type. Only two types can be inferred: "time" and - * "timeList". Return the "undefined" type if neither can be inferred. - * - * @param s A state variable to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(StateVar s) { - return getInferredType(s.getType(), s.getInit()); - } + /** + * Return the type of a declaration with the given + * (nullable) explicit type, and the given (nullable) + * initializer. If the explicit type is null, then the + * type is inferred from the initializer. Only two types + * can be inferred: "time" and "timeList". Return the + * "undefined" type if neither can be inferred. + * + * @param type Explicit type declared on the declaration + * @param init The initializer expression + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Type type, Initializer init) { + if (type != null) { + return InferredType.fromAST(type); + } else if (init == null) { + return InferredType.undefined(); + } - /** - * Construct an inferred type from an "action" AST node based on its declared type. If no type is - * declared, return the "undefined" type. - * - * @param a An action to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Action a) { - return getInferredType(a.getType(), null); - } + var single = asSingleExpr(init); + if (single != null) { + // If there is a single element in the list, and it is a proper + // time value with units, we infer the type "time". + if (single instanceof ParameterReference) { + return getInferredType(((ParameterReference) single).getParameter()); + } else if (single instanceof Time) { + return InferredType.time(); + } + } else if (init.getExprs().size() > 1) { + // If there are multiple elements in the list, and there is at + // least one proper time value with units, and all other elements + // are valid times (including zero without units), we infer the + // type "time list". + var allValidTime = true; + var foundNonZero = false; + + for (var e : init.getExprs()) { + if (!ASTUtils.isValidTime(e)) { + allValidTime = false; + } + if (!ASTUtils.isZero(e)) { + foundNonZero = true; + } + } - /** - * Construct an inferred type from a "port" AST node based on its declared type. If no type is - * declared, return the "undefined" type. - * - * @param p A port to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Port p) { - return getInferredType(p.getType(), null); - } + if (allValidTime && foundNonZero) { + // Conservatively, no bounds are inferred; the returned type + // is a variable-size list. + return InferredType.timeList(); + } + } + return InferredType.undefined(); + } - /** - * If the given string can be recognized as a floating-point number that has a leading decimal - * point, prepend the string with a zero and return it. Otherwise, return the original string. - * - * @param literal A string might be recognizable as a floating point number with a leading decimal - * point. - * @return an equivalent representation of literal - * - */ - public static String addZeroToLeadingDot(String literal) { - Matcher m = ABBREVIATED_FLOAT.matcher(literal); - if (m.matches()) { - return literal.replace(".", "0."); - } - return literal; - } + /** + * Given a parameter, return an inferred type. Only two types can be + * inferred: "time" and "timeList". Return the "undefined" type if + * neither can be inferred. + * + * @param p A parameter to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Parameter p) { + return getInferredType(p.getType(), p.getInit()); + } - /** - * Return true if the specified port is a multiport. - * - * @param port The port. - * @return True if the port is a multiport. - */ - public static boolean isMultiport(Port port) { - return port.getWidthSpec() != null; - } + /** + * Given a state variable, return an inferred type. Only two types can be + * inferred: "time" and "timeList". Return the "undefined" type if + * neither can be inferred. + * + * @param s A state variable to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(StateVar s) { + return getInferredType(s.getType(), s.getInit()); + } - //////////////////////////////// - //// Utility functions for translating AST nodes into text - // This is a continuation of a large section of ASTUtils.xtend - // with the same name. - - /** - * Generate code for referencing a port, action, or timer. - * - * @param reference The reference to the variable. - */ - public static String generateVarRef(VarRef reference) { - var prefix = ""; - if (reference.getContainer() != null) { - prefix = reference.getContainer().getName() + "."; - } - return prefix + reference.getVariable().getName(); - } + /** + * Construct an inferred type from an "action" AST node based + * on its declared type. If no type is declared, return the "undefined" + * type. + * + * @param a An action to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Action a) { + return getInferredType(a.getType(), null); + } - /** Assuming that the given expression denotes a valid time literal, return a time value. */ - public static TimeValue getLiteralTimeValue(Expression expr) { - if (expr instanceof Time) { - return toTimeValue((Time) expr); - } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { - return TimeValue.ZERO; - } else { - return null; + /** + * Construct an inferred type from a "port" AST node based on its declared + * type. If no type is declared, return the "undefined" type. + * + * @param p A port to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Port p) { + return getInferredType(p.getType(), null); } - } - /** If the parameter is of time type, return its default value. Otherwise, return null. */ - public static TimeValue getDefaultAsTimeValue(Parameter p) { - if (isOfTimeType(p)) { - var init = asSingleExpr(p.getInit()); - if (init != null) { - return getLiteralTimeValue(init); - } + + + /** + * If the given string can be recognized as a floating-point number that has a leading decimal point, + * prepend the string with a zero and return it. Otherwise, return the original string. + * + * @param literal A string might be recognizable as a floating point number with a leading decimal point. + * @return an equivalent representation of literal + * + */ + public static String addZeroToLeadingDot(String literal) { + Matcher m = ABBREVIATED_FLOAT.matcher(literal); + if (m.matches()) { + return literal.replace(".", "0."); + } + return literal; } - return null; - } - /** Return whether the given state variable is inferred to a time type. */ - public static boolean isOfTimeType(StateVar state) { - InferredType t = getInferredType(state); - return t.isTime && !t.isList; - } + /** + * Return true if the specified port is a multiport. + * @param port The port. + * @return True if the port is a multiport. + */ + public static boolean isMultiport(Port port) { + return port.getWidthSpec() != null; + } - /** Return whether the given parameter is inferred to a time type. */ - public static boolean isOfTimeType(Parameter param) { - InferredType t = getInferredType(param); - return t.isTime && !t.isList; - } + //////////////////////////////// + //// Utility functions for translating AST nodes into text + // This is a continuation of a large section of ASTUtils.xtend + // with the same name. + + /** + * Generate code for referencing a port, action, or timer. + * @param reference The reference to the variable. + */ + public static String generateVarRef(VarRef reference) { + var prefix = ""; + if (reference.getContainer() != null) { + prefix = reference.getContainer().getName() + "."; + } + return prefix + reference.getVariable().getName(); + } - /** - * Given a parameter, return its initial value. The initial value is a list of instances of - * Expressions. - * - *

If the instantiations argument is null or an empty list, then the value returned is simply - * the default value given when the parameter is defined. - * - *

If a list of instantiations is given, then the first instantiation is required to be an - * instantiation of the reactor class that is parameterized by the parameter. I.e., ``` - * parameter.eContainer == instantiations.get(0).reactorClass ``` If a second instantiation is - * given, then it is required to be an instantiation of a reactor class that contains the first - * instantiation. That is, ``` instantiations.get(0).eContainer == - * instantiations.get(1).reactorClass ``` More generally, for all 0 <= i < instantiations.size - - * 1, ``` instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass ``` If any of - * these conditions is not satisfied, then an IllegalArgumentException will be thrown. - * - *

Note that this chain of reactions cannot be inferred from the parameter because in each of - * the predicates above, there may be more than one instantiation that can appear on the right - * hand side of the predicate. - * - *

For example, consider the following program: ``` reactor A(x:int(1)) {} reactor B(y:int(2)) - * { a1 = new A(x = y); a2 = new A(x = -1); } reactor C(z:int(3)) { b1 = new B(y = z); b2 = new - * B(y = -2); } ``` Notice that there are a total of four instances of reactor class A. Then ``` - * initialValue(x, null) returns 1 initialValue(x, [a1]) returns 2 initialValue(x, [a2]) returns - * -1 initialValue(x, [a1, b1]) returns 3 initialValue(x, [a2, b1]) returns -1 initialValue(x, - * [a1, b2]) returns -2 initialValue(x, [a2, b2]) returns -1 ``` (Actually, in each of the above - * cases, the returned value is a list with one entry, a Literal, e.g. ["1"]). - * - *

There are two instances of reactor class B. ``` initialValue(y, null) returns 2 - * initialValue(y, [a1]) throws an IllegalArgumentException initialValue(y, [b1]) returns 3 - * initialValue(y, [b2]) returns -2 ``` - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * @return The value of the parameter. - * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the - * reactor class that is parameterized by the respective parameter or if the chain of - * instantiations is not nested. - */ - public static List initialValue( - Parameter parameter, List instantiations) { - // If instantiations are given, then check to see whether this parameter gets overridden in - // the first of those instantiations. - if (instantiations != null && instantiations.size() > 0) { - // Check to be sure that the instantiation is in fact an instantiation - // of the reactor class for which this is a parameter. - Instantiation instantiation = instantiations.get(0); - - if (!belongsTo(parameter, instantiation)) { - throw new IllegalArgumentException( - "Parameter " - + parameter.getName() - + " is not a parameter of reactor instance " - + instantiation.getName() - + "."); - } - // In case there is more than one assignment to this parameter, we need to - // find the last one. - Assignment lastAssignment = null; - for (Assignment assignment : instantiation.getParameters()) { - if (assignment.getLhs().equals(parameter)) { - lastAssignment = assignment; + /** + * Assuming that the given expression denotes a valid time literal, + * return a time value. + */ + public static TimeValue getLiteralTimeValue(Expression expr) { + if (expr instanceof Time) { + return toTimeValue((Time)expr); + } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { + return TimeValue.ZERO; + } else { + return null; } - } - if (lastAssignment != null) { - // Right hand side can be a list. Collect the entries. - List result = new ArrayList<>(); - for (Expression expr : lastAssignment.getRhs().getExprs()) { - if (expr instanceof ParameterReference) { - if (instantiations.size() > 1 - && instantiation.eContainer() != instantiations.get(1).getReactorClass()) { - throw new IllegalArgumentException( - "Reactor instance " - + instantiation.getName() - + " is not contained by instance " - + instantiations.get(1).getName() - + "."); + } + + /** + * If the parameter is of time type, return its default value. + * Otherwise, return null. + */ + public static TimeValue getDefaultAsTimeValue(Parameter p) { + if (isOfTimeType(p)) { + var init = asSingleExpr(p.getInit()); + if (init != null) { + return getLiteralTimeValue(init); } - result.addAll( - initialValue( - ((ParameterReference) expr).getParameter(), - instantiations.subList(1, instantiations.size()))); - } else { - result.add(expr); - } } - return result; - } + return null; } - // If we reach here, then either no instantiation was supplied or - // there was no assignment in the instantiation. So just use the - // parameter's initial value. - return parameter.getInit().getExprs(); - } - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the - * specified instantiation, meaning that it is defined in the reactor class being instantiated or - * one of its base classes. - * - * @param eobject The object. - * @param instantiation The instantiation. - */ - public static boolean belongsTo(EObject eobject, Instantiation instantiation) { - Reactor reactor = toDefinition(instantiation.getReactorClass()); - return belongsTo(eobject, reactor); - } - - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the - * specified reactor, meaning that it is defined in reactor class or one of its base classes. - * - * @param eobject The object. - * @param reactor The reactor. - */ - public static boolean belongsTo(EObject eobject, Reactor reactor) { - if (eobject.eContainer() == reactor) return true; - for (ReactorDecl baseClass : reactor.getSuperClasses()) { - if (belongsTo(eobject, toDefinition(baseClass))) { - return true; - } + /** + * Return whether the given state variable is inferred + * to a time type. + */ + public static boolean isOfTimeType(StateVar state) { + InferredType t = getInferredType(state); + return t.isTime && !t.isList; } - return false; - } - /** - * Given a parameter return its integer value or null if it does not have an integer value. If the - * value of the parameter is a list of integers, return the sum of value in the list. The - * instantiations parameter is as in {@link #initialValue(Parameter, List)}. - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * @return The integer value of the parameter, or null if it does not have an integer value. - * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the - * reactor class that is parameterized by the respective parameter or if the chain of - * instantiations is not nested. - */ - public static Integer initialValueInt(Parameter parameter, List instantiations) { - List expressions = initialValue(parameter, instantiations); - int result = 0; - for (Expression expr : expressions) { - if (!(expr instanceof Literal)) { - return null; - } - try { - result += Integer.decode(((Literal) expr).getLiteral()); - } catch (NumberFormatException ex) { - return null; - } + /** + * Return whether the given parameter is inferred + * to a time type. + */ + public static boolean isOfTimeType(Parameter param) { + InferredType t = getInferredType(param); + return t.isTime && !t.isList; } - return result; - } - /** - * Given the width specification of port or instantiation and an (optional) list of nested - * instantiations, return the width if it can be determined and -1 if not. It will not be able to - * be determined if either the width is variable (in which case you should use {@link - * #inferPortWidth(VarRef, Connection, List)} ) or the list of instantiations is incomplete or - * missing. If there are parameter references in the width, they are evaluated to the extent - * possible given the instantiations list. - * - *

The instantiations list is as in {@link #initialValue(Parameter, List)}. If the spec belongs - * to an instantiation (for a bank of reactors), then the first element on this list should be the - * instantiation that contains this instantiation. If the spec belongs to a port, then the first - * element on the list should be the instantiation of the reactor that contains the port. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * @return The width, or -1 if the width could not be determined. - * @throws IllegalArgumentException If an instantiation provided is not as given above or if the - * chain of instantiations is not nested. - */ - public static int width(WidthSpec spec, List instantiations) { - if (spec == null) { - return 1; - } - if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { - return inferWidthFromConnections(spec, instantiations); - } - var result = 0; - for (WidthTerm term : spec.getTerms()) { - if (term.getParameter() != null) { - Integer termWidth = initialValueInt(term.getParameter(), instantiations); - if (termWidth != null) { - result += termWidth; - } else { - return -1; + /** + * Given a parameter, return its initial value. + * The initial value is a list of instances of Expressions. + * + * If the instantiations argument is null or an empty list, then the + * value returned is simply the default value given when the parameter + * is defined. + * + * If a list of instantiations is given, then the first instantiation + * is required to be an instantiation of the reactor class that is + * parameterized by the parameter. I.e., + * ``` + * parameter.eContainer == instantiations.get(0).reactorClass + * ``` + * If a second instantiation is given, then it is required to be an instantiation of a + * reactor class that contains the first instantiation. That is, + * ``` + * instantiations.get(0).eContainer == instantiations.get(1).reactorClass + * ``` + * More generally, for all 0 <= i < instantiations.size - 1, + * ``` + * instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass + * ``` + * If any of these conditions is not satisfied, then an IllegalArgumentException + * will be thrown. + * + * Note that this chain of reactions cannot be inferred from the parameter because + * in each of the predicates above, there may be more than one instantiation that + * can appear on the right hand side of the predicate. + * + * For example, consider the following program: + * ``` + * reactor A(x:int(1)) {} + * reactor B(y:int(2)) { + * a1 = new A(x = y); + * a2 = new A(x = -1); + * } + * reactor C(z:int(3)) { + * b1 = new B(y = z); + * b2 = new B(y = -2); + * } + * ``` + * Notice that there are a total of four instances of reactor class A. + * Then + * ``` + * initialValue(x, null) returns 1 + * initialValue(x, [a1]) returns 2 + * initialValue(x, [a2]) returns -1 + * initialValue(x, [a1, b1]) returns 3 + * initialValue(x, [a2, b1]) returns -1 + * initialValue(x, [a1, b2]) returns -2 + * initialValue(x, [a2, b2]) returns -1 + * ``` + * (Actually, in each of the above cases, the returned value is a list with + * one entry, a Literal, e.g. ["1"]). + * + * There are two instances of reactor class B. + * ``` + * initialValue(y, null) returns 2 + * initialValue(y, [a1]) throws an IllegalArgumentException + * initialValue(y, [b1]) returns 3 + * initialValue(y, [b2]) returns -2 + * ``` + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * + * @return The value of the parameter. + * + * @throws IllegalArgumentException If an instantiation provided is not an + * instantiation of the reactor class that is parameterized by the + * respective parameter or if the chain of instantiations is not nested. + */ + public static List initialValue(Parameter parameter, List instantiations) { + // If instantiations are given, then check to see whether this parameter gets overridden in + // the first of those instantiations. + if (instantiations != null && instantiations.size() > 0) { + // Check to be sure that the instantiation is in fact an instantiation + // of the reactor class for which this is a parameter. + Instantiation instantiation = instantiations.get(0); + + if (!belongsTo(parameter, instantiation)) { + throw new IllegalArgumentException("Parameter " + + parameter.getName() + + " is not a parameter of reactor instance " + + instantiation.getName() + + "." + ); + } + // In case there is more than one assignment to this parameter, we need to + // find the last one. + Assignment lastAssignment = null; + for (Assignment assignment: instantiation.getParameters()) { + if (assignment.getLhs().equals(parameter)) { + lastAssignment = assignment; + } + } + if (lastAssignment != null) { + // Right hand side can be a list. Collect the entries. + List result = new ArrayList<>(); + for (Expression expr: lastAssignment.getRhs().getExprs()) { + if (expr instanceof ParameterReference) { + if (instantiations.size() > 1 + && instantiation.eContainer() != instantiations.get(1).getReactorClass() + ) { + throw new IllegalArgumentException("Reactor instance " + + instantiation.getName() + + " is not contained by instance " + + instantiations.get(1).getName() + + "." + ); + } + result.addAll(initialValue(((ParameterReference)expr).getParameter(), + instantiations.subList(1, instantiations.size()))); + } else { + result.add(expr); + } + } + return result; + } } - } else if (term.getWidth() > 0) { - result += term.getWidth(); - } else { - // If the width cannot be determined because term's width <= 0, which means the term's width - // must be inferred, try to infer the width using connections. - if (spec.eContainer() instanceof Instantiation) { - try { - return inferWidthFromConnections(spec, instantiations); - } catch (InvalidSourceException e) { - // If the inference fails, return -1. - return -1; - } + // If we reach here, then either no instantiation was supplied or + // there was no assignment in the instantiation. So just use the + // parameter's initial value. + return parameter.getInit().getExprs(); + } + + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) + * belongs to the specified instantiation, meaning that it is defined in + * the reactor class being instantiated or one of its base classes. + * @param eobject The object. + * @param instantiation The instantiation. + */ + public static boolean belongsTo(EObject eobject, Instantiation instantiation) { + Reactor reactor = toDefinition(instantiation.getReactorClass()); + return belongsTo(eobject, reactor); + } + + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) + * belongs to the specified reactor, meaning that it is defined in + * reactor class or one of its base classes. + * @param eobject The object. + * @param reactor The reactor. + */ + public static boolean belongsTo(EObject eobject, Reactor reactor) { + if (eobject.eContainer() == reactor) return true; + for (ReactorDecl baseClass : reactor.getSuperClasses()) { + if (belongsTo(eobject, toDefinition(baseClass))) { + return true; + } } - } + return false; } - return result; - } - /** - * Infer the width of a port reference in a connection. The port reference one or two parts, a - * port and an (optional) container which is an Instantiation that may refer to a bank of - * reactors. The width will be the product of the bank width and the port width. The returned - * value will be 1 if the port is not in a bank and is not a multiport. - * - *

If the width cannot be determined, this will return -1. The width cannot be determined if - * the list of instantiations is missing or incomplete. - * - *

The instantiations list is as in {@link #initialValue(Parameter, List)}. The first element - * on this list should be the instantiation that contains the specified connection. - * - * @param reference A port reference. - * @param connection A connection, or null if not in the context of a connection. - * @param instantiations The (optional) list of instantiations. - * @return The width or -1 if it could not be determined. - * @throws IllegalArgumentException If an instantiation provided is not as given above or if the - * chain of instantiations is not nested. - */ - public static int inferPortWidth( - VarRef reference, Connection connection, List instantiations) { - if (reference.getVariable() instanceof Port) { - // If the port is given as a.b, then we want to prepend a to - // the list of instantiations to determine the width of this port. - List extended = instantiations; - if (reference.getContainer() != null) { - extended = new ArrayList<>(); - extended.add(reference.getContainer()); - if (instantiations != null) { - extended.addAll(instantiations); + /** + * Given a parameter return its integer value or null + * if it does not have an integer value. + * If the value of the parameter is a list of integers, + * return the sum of value in the list. + * The instantiations parameter is as in + * {@link #initialValue(Parameter, List)}. + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * + * @return The integer value of the parameter, or null if it does not have an integer value. + * + * @throws IllegalArgumentException If an instantiation provided is not an + * instantiation of the reactor class that is parameterized by the + * respective parameter or if the chain of instantiations is not nested. + */ + public static Integer initialValueInt(Parameter parameter, List instantiations) { + List expressions = initialValue(parameter, instantiations); + int result = 0; + for (Expression expr: expressions) { + if (!(expr instanceof Literal)) { + return null; + } + try { + result += Integer.decode(((Literal) expr).getLiteral()); + } catch (NumberFormatException ex) { + return null; + } } - } + return result; + } - int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); - if (portWidth < 0) { - // Could not determine port width. - return -1; - } - - // Next determine the bank width. This may be unspecified, in which - // case it has to be inferred using the connection. - int bankWidth = 1; - if (reference.getContainer() != null) { - bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); - if (bankWidth < 0 && connection != null) { - // Try to infer the bank width from the connection. - if (reference.getContainer().getWidthSpec().isOfVariableLength()) { - // This occurs for a bank of delays. - int leftWidth = 0; - int rightWidth = 0; - int leftOrRight = 0; - for (VarRef leftPort : connection.getLeftPorts()) { - if (leftPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException( - "Multiple ports with variable width on a connection."); + /** + * Given the width specification of port or instantiation + * and an (optional) list of nested instantiations, return + * the width if it can be determined and -1 if not. + * It will not be able to be determined if either the + * width is variable (in which case you should use + * {@link #inferPortWidth(VarRef, Connection, List)} ) + * or the list of instantiations is incomplete or missing. + * If there are parameter references in the width, they are + * evaluated to the extent possible given the instantiations list. + * + * The instantiations list is as in + * {@link #initialValue(Parameter, List)}. + * If the spec belongs to an instantiation (for a bank of reactors), + * then the first element on this list should be the instantiation + * that contains this instantiation. If the spec belongs to a port, + * then the first element on the list should be the instantiation + * of the reactor that contains the port. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * + * @return The width, or -1 if the width could not be determined. + * + * @throws IllegalArgumentException If an instantiation provided is not as + * given above or if the chain of instantiations is not nested. + */ + public static int width(WidthSpec spec, List instantiations) { + if (spec == null) { + return 1; + } + if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { + return inferWidthFromConnections(spec, instantiations); + } + var result = 0; + for (WidthTerm term: spec.getTerms()) { + if (term.getParameter() != null) { + Integer termWidth = initialValueInt(term.getParameter(), instantiations); + if (termWidth != null) { + result += termWidth; + } else { + return -1; } - // Indicate that this port is on the left. - leftOrRight = -1; - } else { - // The left port is not the same as this reference. - int otherWidth = inferPortWidth(leftPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; + } else if (term.getWidth() > 0) { + result += term.getWidth(); + } else { + // If the width cannot be determined because term's width <= 0, which means the term's width + // must be inferred, try to infer the width using connections. + if (spec.eContainer() instanceof Instantiation) { + try { + return inferWidthFromConnections(spec, instantiations); + } catch (InvalidSourceException e) { + // If the inference fails, return -1. + return -1; + } } - leftWidth += otherWidth; - } } - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException( - "Multiple ports with variable width on a connection."); - } - // Indicate that this port is on the right. - leftOrRight = 1; - } else { - int otherWidth = inferPortWidth(rightPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; + } + return result; + } + + /** + * Infer the width of a port reference in a connection. + * The port reference one or two parts, a port and an (optional) container + * which is an Instantiation that may refer to a bank of reactors. + * The width will be the product of the bank width and the port width. + * The returned value will be 1 if the port is not in a bank and is not a multiport. + * + * If the width cannot be determined, this will return -1. + * The width cannot be determined if the list of instantiations is + * missing or incomplete. + * + * The instantiations list is as in + * {@link #initialValue(Parameter, List)}. + * The first element on this list should be the instantiation + * that contains the specified connection. + * + * @param reference A port reference. + * @param connection A connection, or null if not in the context of a connection. + * @param instantiations The (optional) list of instantiations. + * + * @return The width or -1 if it could not be determined. + * + * @throws IllegalArgumentException If an instantiation provided is not as + * given above or if the chain of instantiations is not nested. + */ + public static int inferPortWidth( + VarRef reference, Connection connection, List instantiations + ) { + if (reference.getVariable() instanceof Port) { + // If the port is given as a.b, then we want to prepend a to + // the list of instantiations to determine the width of this port. + List extended = instantiations; + if (reference.getContainer() != null) { + extended = new ArrayList<>(); + extended.add(reference.getContainer()); + if (instantiations != null) { + extended.addAll(instantiations); } - rightWidth += otherWidth; - } } - int discrepancy = 0; - if (leftOrRight < 0) { - // This port is on the left. - discrepancy = rightWidth - leftWidth; - } else if (leftOrRight > 0) { - // This port is on the right. - discrepancy = leftWidth - rightWidth; + + int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); + if (portWidth < 0) { + // Could not determine port width. + return -1; } - // Check that portWidth divides the discrepancy. - if (discrepancy % portWidth != 0) { - // This is an error. - return -1; + + // Next determine the bank width. This may be unspecified, in which + // case it has to be inferred using the connection. + int bankWidth = 1; + if (reference.getContainer() != null) { + bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); + if (bankWidth < 0 && connection != null) { + // Try to infer the bank width from the connection. + if (reference.getContainer().getWidthSpec().isOfVariableLength()) { + // This occurs for a bank of delays. + int leftWidth = 0; + int rightWidth = 0; + int leftOrRight = 0; + for (VarRef leftPort : connection.getLeftPorts()) { + if (leftPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that this port is on the left. + leftOrRight = -1; + } else { + // The left port is not the same as this reference. + int otherWidth = inferPortWidth(leftPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; + } + leftWidth += otherWidth; + } + } + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that this port is on the right. + leftOrRight = 1; + } else { + int otherWidth = inferPortWidth(rightPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; + } + rightWidth += otherWidth; + } + } + int discrepancy = 0; + if (leftOrRight < 0) { + // This port is on the left. + discrepancy = rightWidth - leftWidth; + } else if (leftOrRight > 0) { + // This port is on the right. + discrepancy = leftWidth - rightWidth; + } + // Check that portWidth divides the discrepancy. + if (discrepancy % portWidth != 0) { + // This is an error. + return -1; + } + bankWidth = discrepancy / portWidth; + } else { + // Could not determine the bank width. + return -1; + } + } } - bankWidth = discrepancy / portWidth; - } else { - // Could not determine the bank width. - return -1; - } + return portWidth * bankWidth; } - } - return portWidth * bankWidth; + // Argument is not a port. + return -1; } - // Argument is not a port. - return -1; - } - /** - * Given an instantiation of a reactor or bank of reactors, return the width. This will be 1 if - * this is not a reactor bank. Otherwise, this will attempt to determine the width. If the width - * is declared as a literal constant, it will return that constant. If the width is specified as a - * reference to a parameter, this will throw an exception. If the width is variable, this will - * find connections in the enclosing reactor and attempt to infer the width. If the width cannot - * be determined, it will throw an exception. - * - *

IMPORTANT: This method should not be used you really need to determine the width! It will - * not evaluate parameter values. - * - * @see #width(WidthSpec, List) - * @param instantiation A reactor instantiation. - * @return The width, if it can be determined. - * @deprecated - */ - @Deprecated - public static int widthSpecification(Instantiation instantiation) { - int result = width(instantiation.getWidthSpec(), null); - if (result < 0) { - throw new InvalidSourceException( - "Cannot determine width for the instance " + instantiation.getName()); - } - return result; - } + /** + * Given an instantiation of a reactor or bank of reactors, return + * the width. This will be 1 if this is not a reactor bank. Otherwise, + * this will attempt to determine the width. If the width is declared + * as a literal constant, it will return that constant. If the width + * is specified as a reference to a parameter, this will throw an + * exception. If the width is variable, this will find + * connections in the enclosing reactor and attempt to infer the + * width. If the width cannot be determined, it will throw an exception. + * + * IMPORTANT: This method should not be used you really need to + * determine the width! It will not evaluate parameter values. + * @see #width(WidthSpec, List) + * + * @param instantiation A reactor instantiation. + * + * @return The width, if it can be determined. + * @deprecated + */ + @Deprecated + public static int widthSpecification(Instantiation instantiation) { + int result = width(instantiation.getWidthSpec(), null); + if (result < 0) { + throw new InvalidSourceException("Cannot determine width for the instance " + + instantiation.getName()); + } + return result; + } - /** - * Report whether a state variable has been initialized or not. - * - * @param v The state variable to be checked. - * @return True if the variable was initialized, false otherwise. - */ - public static boolean isInitialized(StateVar v) { - return v != null && v.getInit() != null; - } + /** + * Report whether a state variable has been initialized or not. + * @param v The state variable to be checked. + * @return True if the variable was initialized, false otherwise. + */ + public static boolean isInitialized(StateVar v) { + return v != null && v.getInit() != null; + } - /** - * Report whether the given time state variable is initialized using a parameter or not. - * - * @param s A state variable. - * @return True if the argument is initialized using a parameter, false otherwise. - */ - public static boolean isParameterized(StateVar s) { - return s.getInit() != null - && IterableExtensions.exists( - s.getInit().getExprs(), it -> it instanceof ParameterReference); - } + /** + * Report whether the given time state variable is initialized using a + * parameter or not. + * @param s A state variable. + * @return True if the argument is initialized using a parameter, false + * otherwise. + */ + public static boolean isParameterized(StateVar s) { + return s.getInit() != null && + IterableExtensions.exists(s.getInit().getExprs(), it -> it instanceof ParameterReference); + } - /** - * Check if the reactor class uses generics - * - * @param r the reactor to check - * @return true if the reactor uses generics - */ - public static boolean isGeneric(Reactor r) { - if (r == null) { - return false; - } - return r.getTypeParms().size() != 0; - } + /** + * Check if the reactor class uses generics + * @param r the reactor to check + * @return true if the reactor uses generics + */ + public static boolean isGeneric(Reactor r) { + if (r == null) { + return false; + } + return r.getTypeParms().size() != 0; + } - /** - * If the specified reactor declaration is an import, then return the imported reactor class - * definition. Otherwise, just return the argument. - * - * @param r A Reactor or an ImportedReactor. - * @return The Reactor class definition or null if no definition is found. - */ - public static Reactor toDefinition(ReactorDecl r) { - if (r == null) return null; - if (r instanceof Reactor) { - return (Reactor) r; - } else if (r instanceof ImportedReactor) { - return ((ImportedReactor) r).getReactorClass(); - } - return null; - } + /** + * If the specified reactor declaration is an import, then + * return the imported reactor class definition. Otherwise, + * just return the argument. + * @param r A Reactor or an ImportedReactor. + * @return The Reactor class definition or null if no definition is found. + */ + public static Reactor toDefinition(ReactorDecl r) { + if (r == null) + return null; + if (r instanceof Reactor) { + return (Reactor) r; + } else if (r instanceof ImportedReactor) { + return ((ImportedReactor) r).getReactorClass(); + } + return null; + } - /** Return all single-line or multi-line comments immediately preceding the given EObject. */ - public static Stream getPrecedingComments( - ICompositeNode compNode, Predicate filter) { - return getPrecedingCommentNodes(compNode, filter).map(INode::getText); - } + /** + * Return all single-line or multi-line comments immediately preceding the + * given EObject. + */ + public static Stream getPrecedingComments( + ICompositeNode compNode, + Predicate filter + ) { + return getPrecedingCommentNodes(compNode, filter).map(INode::getText); + } - /** Return all single-line or multi-line comments immediately preceding the given EObject. */ - public static Stream getPrecedingCommentNodes( - ICompositeNode compNode, Predicate filter) { - if (compNode == null) return Stream.of(); - List ret = new ArrayList<>(); - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode)) { - if (isComment(node)) { - if (filter.test(node)) ret.add(node); - } else if (!node.getText().isBlank()) { - break; + /** + * Return all single-line or multi-line comments immediately preceding the + * given EObject. + */ + public static Stream getPrecedingCommentNodes( + ICompositeNode compNode, + Predicate filter + ) { + if (compNode == null) return Stream.of(); + List ret = new ArrayList<>(); + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode)) { + if (isComment(node)) { + if (filter.test(node)) ret.add(node); + } else if (!node.getText().isBlank()) { + break; + } + } } - } + return ret.stream(); } - return ret.stream(); - } - /** Return whether {@code node} is a comment. */ - public static boolean isComment(INode node) { - return node instanceof HiddenLeafNode hlNode - && hlNode.getGrammarElement() instanceof TerminalRule tRule - && tRule.getName().endsWith("_COMMENT"); - } + /** Return whether {@code node} is a comment. */ + public static boolean isComment(INode node) { + return node instanceof HiddenLeafNode hlNode + && hlNode.getGrammarElement() instanceof TerminalRule tRule + && tRule.getName().endsWith("_COMMENT"); + } - /** Return true if the given node starts on the same line as the given other node. */ - public static Predicate sameLine(ICompositeNode compNode) { - return other -> { - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { - return node.getStartLine() == other.getStartLine(); - } - } - return false; - }; - } + /** + * Return true if the given node starts on the same line as the given other + * node. + */ + public static Predicate sameLine(ICompositeNode compNode) { + return other -> { + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { + return node.getStartLine() == other.getStartLine(); + } + } + return false; + }; + } - /** - * Find the main reactor and set its name if none was defined. - * - * @param resource The resource to find the main reactor in. - */ - public static void setMainName(Resource resource, String name) { - Reactor main = - IteratorExtensions.findFirst( - Iterators.filter(resource.getAllContents(), Reactor.class), - it -> it.isMain() || it.isFederated()); - if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { - main.setName(name); + /** + * Find the main reactor and set its name if none was defined. + * @param resource The resource to find the main reactor in. + */ + public static void setMainName(Resource resource, String name) { + Reactor main = IteratorExtensions.findFirst(Iterators.filter(resource.getAllContents(), Reactor.class), + it -> it.isMain() || it.isFederated() + ); + if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { + main.setName(name); + } } - } - /** - * Create a new instantiation node with the given reactor as its defining class. - * - * @param reactor The reactor class to create an instantiation of. - */ - public static Instantiation createInstantiation(Reactor reactor) { - Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); - inst.setReactorClass(reactor); - // If the reactor is federated or at the top level, then it - // may not have a name. In the generator's doGenerate() - // method, the name gets set using setMainName(). - // But this may be called before that, e.g. during - // diagram synthesis. We assign a temporary name here. - if (reactor.getName() == null) { - if (reactor.isFederated() || reactor.isMain()) { - inst.setName("main"); - } else { - inst.setName(""); - } - - } else { - inst.setName(reactor.getName()); - } - return inst; - } + /** + * Create a new instantiation node with the given reactor as its defining class. + * @param reactor The reactor class to create an instantiation of. + */ + public static Instantiation createInstantiation(Reactor reactor) { + Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); + inst.setReactorClass(reactor); + // If the reactor is federated or at the top level, then it + // may not have a name. In the generator's doGenerate() + // method, the name gets set using setMainName(). + // But this may be called before that, e.g. during + // diagram synthesis. We assign a temporary name here. + if (reactor.getName() == null) { + if (reactor.isFederated() || reactor.isMain()) { + inst.setName("main"); + } else { + inst.setName(""); + } - /** - * Returns the target declaration in the given model. Non-null because it would cause a parse - * error. - */ - public static TargetDecl targetDecl(Model model) { - return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); - } + } else { + inst.setName(reactor.getName()); + } + return inst; + } - /** - * Returns the target declaration in the given resource. Non-null because it would cause a parse - * error. - */ - public static TargetDecl targetDecl(Resource model) { - return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); - } + /** + * Returns the target declaration in the given model. + * Non-null because it would cause a parse error. + */ + public static TargetDecl targetDecl(Model model) { + return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); + } - ///////////////////////////////////////////////////////// - //// Private methods + /** + * Returns the target declaration in the given resource. + * Non-null because it would cause a parse error. + */ + public static TargetDecl targetDecl(Resource model) { + return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); + } - /** Returns the list if it is not null. Otherwise, return an empty list. */ - public static List convertToEmptyListIfNull(List list) { - return list != null ? list : new ArrayList<>(); - } + ///////////////////////////////////////////////////////// + //// Private methods - /** - * Return all the superclasses of the specified reactor in deepest-first order. For example, if A - * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates - * are removed. If the specified reactor does not extend any other reactor, then return an empty - * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared - * that is not found, then return null. - * - * @param reactor The specified reactor. - * @param extensions A set of reactors extending the specified reactor (used to detect circular - * extensions). - */ - private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { - LinkedHashSet result = new LinkedHashSet<>(); - for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { - Reactor r = toDefinition(superDecl); - if (r == reactor || r == null) return null; - // If r is in the extensions, then we have a circular inheritance structure. - if (extensions.contains(r)) return null; - extensions.add(r); - LinkedHashSet baseExtends = superClasses(r, extensions); - extensions.remove(r); - if (baseExtends == null) return null; - result.addAll(baseExtends); - result.add(r); - } - return result; - } + /** + * Returns the list if it is not null. Otherwise, return an empty list. + */ + public static List convertToEmptyListIfNull(List list) { + return list != null ? list : new ArrayList<>(); + } - /** - * We may be able to infer the width by examining the connections of the enclosing reactor - * definition. This works, for example, with delays between multiports or banks of reactors. - * Attempt to infer the width from connections and return -1 if the width cannot be inferred. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * @return The width, or -1 if the width could not be inferred from connections. - */ - private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { - for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { - int leftWidth = 0; - int rightWidth = 0; - int leftOrRight = 0; - for (VarRef leftPort : c.getLeftPorts()) { - if (leftPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the left. - leftOrRight = -1; - } else { - leftWidth += inferPortWidth(leftPort, c, instantiations); + /** + * Return all the superclasses of the specified reactor + * in deepest-first order. For example, if A extends B and C, and + * B and C both extend D, this will return the list [D, B, C, A]. + * Duplicates are removed. If the specified reactor does not extend + * any other reactor, then return an empty list. + * If a cycle is found, where X extends Y and Y extends X, or if + * a superclass is declared that is not found, then return null. + * @param reactor The specified reactor. + * @param extensions A set of reactors extending the specified reactor + * (used to detect circular extensions). + */ + private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { + LinkedHashSet result = new LinkedHashSet<>(); + for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { + Reactor r = toDefinition(superDecl); + if (r == reactor || r == null) return null; + // If r is in the extensions, then we have a circular inheritance structure. + if (extensions.contains(r)) return null; + extensions.add(r); + LinkedHashSet baseExtends = superClasses(r, extensions); + extensions.remove(r); + if (baseExtends == null) return null; + result.addAll(baseExtends); + result.add(r); } - } - for (VarRef rightPort : c.getRightPorts()) { - if (rightPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the right. - leftOrRight = 1; - } else { - rightWidth += inferPortWidth(rightPort, c, instantiations); + return result; + } + + /** + * We may be able to infer the width by examining the connections of + * the enclosing reactor definition. This works, for example, with + * delays between multiports or banks of reactors. + * Attempt to infer the width from connections and return -1 if the width cannot be inferred. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * + * @return The width, or -1 if the width could not be inferred from connections. + */ + private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { + for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { + int leftWidth = 0; + int rightWidth = 0; + int leftOrRight = 0; + for (VarRef leftPort : c.getLeftPorts()) { + if (leftPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the left. + leftOrRight = -1; + } else { + leftWidth += inferPortWidth(leftPort, c, instantiations); + } + } + for (VarRef rightPort : c.getRightPorts()) { + if (rightPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the right. + leftOrRight = 1; + } else { + rightWidth += inferPortWidth(rightPort, c, instantiations); + } + } + if (leftOrRight < 0) { + return rightWidth - leftWidth; + } else if (leftOrRight > 0) { + return leftWidth - rightWidth; + } } - } - if (leftOrRight < 0) { - return rightWidth - leftWidth; - } else if (leftOrRight > 0) { - return leftWidth - rightWidth; - } - } - // A connection was not found with the instantiation. - return -1; - } + // A connection was not found with the instantiation. + return -1; + } - public static void addReactionAttribute(Reaction reaction, String name) { - var fedAttr = factory.createAttribute(); - fedAttr.setAttrName(name); - reaction.getAttributes().add(fedAttr); - } -} + public static void addReactionAttribute(Reaction reaction, String name) { + var fedAttr = factory.createAttribute(); + fedAttr.setAttrName(name); + reaction.getAttributes().add(fedAttr); + } +} \ No newline at end of file diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index bfd89bdc14..e344e9f873 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1110,7 +1110,7 @@ private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeB generateAuxiliaryStructs(header, reactor, false); generateSelfStruct(header, reactor, constructorCode); generateMethods(src, reactor); - generateWatchdogs(reactor); + generateWatchdogs(src, reactor); generateReactions(src, reactor); generateConstructor(src, header, reactor, constructorCode); } @@ -1469,10 +1469,10 @@ protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, i * federated or not the main reactor and reactions should be * unconditionally generated. */ - public void generateWatchdogs(ReactorDecl decl) { + public void generateWatchdogs(CodeBuilder src, ReactorDecl decl) { var reactor = ASTUtils.toDefinition(decl); for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - generateWatchdog(watchdog, decl); + generateWatchdog(src, watchdog, decl); } } @@ -1483,8 +1483,8 @@ public void generateWatchdogs(ReactorDecl decl) { * @param watchdog The watchdog. * @param decl The reactor. */ - protected void generateWatchdog(Watchdog watchdog, ReactorDecl decl) { - code.pr(CWatchdogGenerator.generateWatchdog( + protected void generateWatchdog(CodeBuilder src, Watchdog watchdog, ReactorDecl decl) { + src.pr(CWatchdogGenerator.generateWatchdog( watchdog, decl )); diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index f2f9630bea..67a76eb0e2 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -1191,7 +1191,7 @@ public static String generateStpFunctionHeader(Reactor r, return generateFunctionHeader(functionName); } - private static String generateFunctionHeader(String functionName) { + public static String generateFunctionHeader(String functionName) { return "void " + functionName + "(void* instance_args)"; } } \ No newline at end of file diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 6ad7f405eb..621077de86 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -1,6 +1,7 @@ package org.lflang.generator.c; import java.util.List; + import org.lflang.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Mode; @@ -34,7 +35,7 @@ public static String generateInitializationForWatchdog(Watchdog watchdog, Reacto CodeBuilder code = new CodeBuilder(); // Define the "self" struct. - String structType = CUtil.selfType(decl); + String structType = CUtil.selfType(reactor); // A null structType means there are no inputs, state, // or anything else. No need to declare it. if (structType != null) { diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index 16d6723f7f..5d2c87b724 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -6,7 +6,8 @@ * @author Edward A. Lee */ target C { - timeout: 1100 ms + timeout: 1100 ms, + fast: false } reactor Watcher(timeout: time = 150 ms) { @@ -18,6 +19,7 @@ reactor Watcher(timeout: time = 150 ms) { watchdog poodle(timeout) {= instant_t p = lf_time_physical_elapsed() - lf_time_logical_elapsed(); lf_print("Watchdog timed out! Lag: %lld (too late by " PRINTF_TIME " ns)", p, p - self->timeout); + lf_print("At logical time inside watchdog panic: " PRINTF_TIME, lf_time_logical_elapsed()); self->count++; =} From 3b8e0f7007f0e69c5238df6ee97ad7f57fe910ce Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Thu, 20 Apr 2023 14:02:08 -0700 Subject: [PATCH 145/709] removed fake python test --- org.lflang/src/org/lflang/ASTUtils.java | 3103 +++++++------- org.lflang/src/org/lflang/ast/IsEqual.java | 28 +- .../org/lflang/generator/ReactorInstance.java | 831 ++-- .../org/lflang/generator/c/CGenerator.java | 3815 ++++++++--------- .../generator/c/CReactionGenerator.java | 2346 +++++----- .../generator/c/CWatchdogGenerator.java | 1 - .../generator/python/PythonGenerator.java | 1083 +++-- .../org/lflang/validation/LFValidator.java | 3291 +++++++------- test/Python/src/PyWatchdog.lf | 66 - 9 files changed, 7309 insertions(+), 7255 deletions(-) delete mode 100644 test/Python/src/PyWatchdog.lf diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 9c3003007e..4606b4d35f 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -21,6 +21,9 @@ package org.lflang; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Iterators; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; @@ -28,7 +31,6 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.Set; import java.util.function.Predicate; import java.util.regex.Matcher; @@ -36,7 +38,6 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; - import org.eclipse.emf.common.util.EList; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EStructuralFeature; @@ -57,8 +58,6 @@ import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.Assignment; -import org.lflang.lf.AttrParm; -import org.lflang.lf.Attribute; import org.lflang.lf.Code; import org.lflang.lf.Connection; import org.lflang.lf.Element; @@ -92,1740 +91,1662 @@ import org.lflang.lf.WidthTerm; import org.lflang.util.StringUtil; -import com.google.common.collect.HashMultimap; -import com.google.common.collect.Iterables; -import com.google.common.collect.Iterators; - /** * A helper class for modifying and analyzing the AST. + * * @author Marten Lohstroh * @author Edward A. Lee * @author Christian Menard */ public class ASTUtils { - /** - * The Lingua Franca factory for creating new AST nodes. - */ - public static final LfFactory factory = LfFactory.eINSTANCE; - - /** - * The Lingua Franca feature package. - */ - public static final LfPackage featurePackage = LfPackage.eINSTANCE; - - /* Match an abbreviated form of a float literal. */ - private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); - - /** - * A mapping from Reactor features to corresponding Mode features for collecting contained elements. - */ - private static final Map reactorModeFeatureMap = Map.of( - featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), - featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), - featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), - featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), - featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), - featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), - featurePackage.getReactor_Watchdogs(), featurePackage.getMode_Watchdogs() - ); - - - /** - * Get all reactors defined in the given resource. - * @param resource the resource to extract reactors from - * @return An iterable over all reactors found in the resource - */ - public static List getAllReactors(Resource resource) { - return StreamSupport.stream(IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) - .filter(Reactor.class::isInstance) - .map(Reactor.class::cast) - .collect(Collectors.toList()); - } - - /** - * Find connections in the given resource that would be conflicting writes if they were not located in mutually - * exclusive modes. - * - * @param resource The AST. - * @return a list of connections being able to be transformed - */ - public static Collection findConflictingConnectionsInModalReactors(Resource resource) { - var transform = new HashSet(); - - for (Reactor reactor : getAllReactors(resource)) { - if (!reactor.getModes().isEmpty()) { // Only for modal reactors - var allWriters = HashMultimap., EObject>create(); - - // Collect destinations - for (var rea : allReactions(reactor)) { - for (var eff : rea.getEffects()) { - if (eff.getVariable() instanceof Port) { - allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); - } - } - } - for (var con : ASTUtils.collectElements(reactor, featurePackage.getReactor_Connections(), false, true)) { - for (var port : con.getRightPorts()) { - allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); - } - } + /** The Lingua Franca factory for creating new AST nodes. */ + public static final LfFactory factory = LfFactory.eINSTANCE; + + /** The Lingua Franca feature package. */ + public static final LfPackage featurePackage = LfPackage.eINSTANCE; + + /* Match an abbreviated form of a float literal. */ + private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); + + /** + * A mapping from Reactor features to corresponding Mode features for collecting contained + * elements. + */ + private static final Map reactorModeFeatureMap = + Map.of( + featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), + featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), + featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), + featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), + featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), + featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), + featurePackage.getReactor_Watchdogs(), featurePackage.getMode_Watchdogs()); + + /** + * Get all reactors defined in the given resource. + * + * @param resource the resource to extract reactors from + * @return An iterable over all reactors found in the resource + */ + public static List getAllReactors(Resource resource) { + return StreamSupport.stream( + IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) + .filter(Reactor.class::isInstance) + .map(Reactor.class::cast) + .collect(Collectors.toList()); + } - // Handle conflicting writers - for (var key : allWriters.keySet()) { - var writers = allWriters.get(key); - if (writers.size() > 1) { // has multiple sources - var writerModes = HashMultimap.create(); - // find modes - for (var writer : writers) { - if (writer.eContainer() instanceof Mode) { - writerModes.put((Mode) writer.eContainer(), writer); - } else { - writerModes.put(null, writer); - } - } - // Conflicting connection can only be handled if.. - if (!writerModes.containsKey(null) && // no writer is on root level (outside of modes) and... - writerModes.keySet().stream().map(writerModes::get).allMatch(writersInMode -> // all writers in a mode are either... - writersInMode.size() == 1 || // the only writer or... - writersInMode.stream().allMatch(w -> w instanceof Reaction) // all are reactions and hence ordered - )) { - // Add connections to transform list - writers.stream().filter(w -> w instanceof Connection).forEach(c -> transform.add((Connection) c)); - } - } - } + /** + * Find connections in the given resource that would be conflicting writes if they were not + * located in mutually exclusive modes. + * + * @param resource The AST. + * @return a list of connections being able to be transformed + */ + public static Collection findConflictingConnectionsInModalReactors( + Resource resource) { + var transform = new HashSet(); + + for (Reactor reactor : getAllReactors(resource)) { + if (!reactor.getModes().isEmpty()) { // Only for modal reactors + var allWriters = HashMultimap., EObject>create(); + + // Collect destinations + for (var rea : allReactions(reactor)) { + for (var eff : rea.getEffects()) { + if (eff.getVariable() instanceof Port) { + allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); } + } + } + for (var con : + ASTUtils.collectElements( + reactor, featurePackage.getReactor_Connections(), false, true)) { + for (var port : con.getRightPorts()) { + allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); + } } - return transform; - } - - /** - * Return the enclosing reactor of an LF EObject in a reactor or mode. - * @param obj the LF model element - * @return the reactor or null - */ - public static Reactor getEnclosingReactor(EObject obj) { - if (obj.eContainer() instanceof Reactor) { - return (Reactor) obj.eContainer(); - } else if (obj.eContainer() instanceof Mode) { - return (Reactor) obj.eContainer().eContainer(); + // Handle conflicting writers + for (var key : allWriters.keySet()) { + var writers = allWriters.get(key); + if (writers.size() > 1) { // has multiple sources + var writerModes = HashMultimap.create(); + // find modes + for (var writer : writers) { + if (writer.eContainer() instanceof Mode) { + writerModes.put((Mode) writer.eContainer(), writer); + } else { + writerModes.put(null, writer); + } + } + // Conflicting connection can only be handled if.. + if (!writerModes.containsKey(null) + && // no writer is on root level (outside of modes) and... + writerModes.keySet().stream() + .map(writerModes::get) + .allMatch( + writersInMode -> // all writers in a mode are either... + writersInMode.size() == 1 + || // the only writer or... + writersInMode.stream() + .allMatch( + w -> + w + instanceof + Reaction) // all are reactions and hence ordered + )) { + // Add connections to transform list + writers.stream() + .filter(w -> w instanceof Connection) + .forEach(c -> transform.add((Connection) c)); + } + } } - return null; + } } - /** - * Return the main reactor in the given resource if there is one, null otherwise. - */ - public static Reactor findMainReactor(Resource resource) { - return IteratorExtensions.findFirst( - Iterators.filter(resource.getAllContents(), Reactor.class), - Reactor::isMain - ); - } + return transform; + } - /** - * Find the main reactor and change it to a federated reactor. - * Return true if the transformation was successful (or the given resource - * already had a federated reactor); return false otherwise. - */ - public static boolean makeFederated(Resource resource) { - // Find the main reactor - Reactor r = findMainReactor(resource); - if (r == null) { - return false; - } - r.setMain(false); - r.setFederated(true); - return true; - } + /** + * Return the enclosing reactor of an LF EObject in a reactor or mode. + * + * @param obj the LF model element + * @return the reactor or null + */ + public static Reactor getEnclosingReactor(EObject obj) { + if (obj.eContainer() instanceof Reactor) { + return (Reactor) obj.eContainer(); + } else if (obj.eContainer() instanceof Mode) { + return (Reactor) obj.eContainer().eContainer(); + } + return null; + } - /** - * Change the target name to 'newTargetName'. - * For example, change C to CCpp. - */ - public static boolean changeTargetName(Resource resource, String newTargetName) { - targetDecl(resource).setName(newTargetName); - return true; - } + /** Return the main reactor in the given resource if there is one, null otherwise. */ + public static Reactor findMainReactor(Resource resource) { + return IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), Reactor::isMain); + } - /** - * Return the target of the file in which the given node lives. - */ - public static Target getTarget(EObject object) { - TargetDecl targetDecl = targetDecl(object.eResource()); - return Target.fromDecl(targetDecl); - } + /** + * Find the main reactor and change it to a federated reactor. Return true if the transformation + * was successful (or the given resource already had a federated reactor); return false otherwise. + */ + public static boolean makeFederated(Resource resource) { + // Find the main reactor + Reactor r = findMainReactor(resource); + if (r == null) { + return false; + } + r.setMain(false); + r.setFederated(true); + return true; + } - /** - * Add a new target property to the given resource. - * - * This also creates a config object if the resource does not yey have one. - * - * @param resource The resource to modify - * @param name Name of the property to add - * @param value Value to be assigned to the property - */ - public static boolean addTargetProperty(final Resource resource, final String name, final Element value) { - var config = targetDecl(resource).getConfig(); - if (config == null) { - config = LfFactory.eINSTANCE.createKeyValuePairs(); - targetDecl(resource).setConfig(config); - } - final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); - newProperty.setName(name); - newProperty.setValue(value); - config.getPairs().add(newProperty); - return true; - } + /** Change the target name to 'newTargetName'. For example, change C to CCpp. */ + public static boolean changeTargetName(Resource resource, String newTargetName) { + targetDecl(resource).setName(newTargetName); + return true; + } - /** - * Return true if the connection involves multiple ports on the left or right side of the connection, or - * if the port on the left or right of the connection involves a bank of reactors or a multiport. - * @param connection The connection. - */ - public static boolean hasMultipleConnections(Connection connection) { - if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { - return true; - } - VarRef leftPort = connection.getLeftPorts().get(0); - VarRef rightPort = connection.getRightPorts().get(0); - Instantiation leftContainer = leftPort.getContainer(); - Instantiation rightContainer = rightPort.getContainer(); - Port leftPortAsPort = (Port) leftPort.getVariable(); - Port rightPortAsPort = (Port) rightPort.getVariable(); - return leftPortAsPort.getWidthSpec() != null - || leftContainer != null && leftContainer.getWidthSpec() != null - || rightPortAsPort.getWidthSpec() != null - || rightContainer != null && rightContainer.getWidthSpec() != null; - } + /** Return the target of the file in which the given node lives. */ + public static Target getTarget(EObject object) { + TargetDecl targetDecl = targetDecl(object.eResource()); + return Target.fromDecl(targetDecl); + } - /** - * Produce a unique identifier within a reactor based on a - * given based name. If the name does not exists, it is returned; - * if does exist, an index is appended that makes the name unique. - * @param reactor The reactor to find a unique identifier within. - * @param name The name to base the returned identifier on. - */ - public static String getUniqueIdentifier(Reactor reactor, String name) { - LinkedHashSet vars = new LinkedHashSet<>(); - allActions(reactor).forEach(it -> vars.add(it.getName())); - allTimers(reactor).forEach(it -> vars.add(it.getName())); - allParameters(reactor).forEach(it -> vars.add(it.getName())); - allInputs(reactor).forEach(it -> vars.add(it.getName())); - allOutputs(reactor).forEach(it -> vars.add(it.getName())); - allStateVars(reactor).forEach(it -> vars.add(it.getName())); - allInstantiations(reactor).forEach(it -> vars.add(it.getName())); - - int index = 0; - String suffix = ""; - boolean exists = true; - while (exists) { - String id = name + suffix; - if (IterableExtensions.exists(vars, it -> it.equals(id))) { - suffix = "_" + index; - index++; - } else { - exists = false; - } - } - return name + suffix; - } + /** + * Add a new target property to the given resource. + * + *

This also creates a config object if the resource does not yey have one. + * + * @param resource The resource to modify + * @param name Name of the property to add + * @param value Value to be assigned to the property + */ + public static boolean addTargetProperty( + final Resource resource, final String name, final Element value) { + var config = targetDecl(resource).getConfig(); + if (config == null) { + config = LfFactory.eINSTANCE.createKeyValuePairs(); + targetDecl(resource).setConfig(config); + } + final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); + newProperty.setName(name); + newProperty.setValue(value); + config.getPairs().add(newProperty); + return true; + } - //////////////////////////////// - //// Utility functions for supporting inheritance and modes - - /** - * Given a reactor class, return a list of all its actions, - * which includes actions of base classes that it extends. - * This also includes actions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allActions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); - } + /** + * Return true if the connection involves multiple ports on the left or right side of the + * connection, or if the port on the left or right of the connection involves a bank of reactors + * or a multiport. + * + * @param connection The connection. + */ + public static boolean hasMultipleConnections(Connection connection) { + if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { + return true; + } + VarRef leftPort = connection.getLeftPorts().get(0); + VarRef rightPort = connection.getRightPorts().get(0); + Instantiation leftContainer = leftPort.getContainer(); + Instantiation rightContainer = rightPort.getContainer(); + Port leftPortAsPort = (Port) leftPort.getVariable(); + Port rightPortAsPort = (Port) rightPort.getVariable(); + return leftPortAsPort.getWidthSpec() != null + || leftContainer != null && leftContainer.getWidthSpec() != null + || rightPortAsPort.getWidthSpec() != null + || rightContainer != null && rightContainer.getWidthSpec() != null; + } - /** - * Given a reactor class, return a list of all its connections, - * which includes connections of base classes that it extends. - * This also includes connections in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allConnections(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); - } + /** + * Produce a unique identifier within a reactor based on a given based name. If the name does not + * exists, it is returned; if does exist, an index is appended that makes the name unique. + * + * @param reactor The reactor to find a unique identifier within. + * @param name The name to base the returned identifier on. + */ + public static String getUniqueIdentifier(Reactor reactor, String name) { + LinkedHashSet vars = new LinkedHashSet<>(); + allActions(reactor).forEach(it -> vars.add(it.getName())); + allTimers(reactor).forEach(it -> vars.add(it.getName())); + allParameters(reactor).forEach(it -> vars.add(it.getName())); + allInputs(reactor).forEach(it -> vars.add(it.getName())); + allOutputs(reactor).forEach(it -> vars.add(it.getName())); + allStateVars(reactor).forEach(it -> vars.add(it.getName())); + allInstantiations(reactor).forEach(it -> vars.add(it.getName())); + + int index = 0; + String suffix = ""; + boolean exists = true; + while (exists) { + String id = name + suffix; + if (IterableExtensions.exists(vars, it -> it.equals(id))) { + suffix = "_" + index; + index++; + } else { + exists = false; + } + } + return name + suffix; + } - /** - * Given a reactor class, return a list of all its inputs, - * which includes inputs of base classes that it extends. - * If the base classes include a cycle, where X extends Y and Y extends X, - * then return only the input defined in the base class. - * The returned list may be empty. - * @param definition Reactor class definition. - */ - public static List allInputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); - } + //////////////////////////////// + //// Utility functions for supporting inheritance and modes + + /** + * Given a reactor class, return a list of all its actions, which includes actions of base classes + * that it extends. This also includes actions in modes, returning a flattened view over all + * modes. + * + * @param definition Reactor class definition. + */ + public static List allActions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); + } - /** A list of all ports of {@code definition}, in an unspecified order. */ - public static List allPorts(Reactor definition) { - return Stream.concat(ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()).toList(); - } + /** + * Given a reactor class, return a list of all its connections, which includes connections of base + * classes that it extends. This also includes connections in modes, returning a flattened view + * over all modes. + * + * @param definition Reactor class definition. + */ + public static List allConnections(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); + } - /** - * Given a reactor class, return a list of all its instantiations, - * which includes instantiations of base classes that it extends. - * This also includes instantiations in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allInstantiations(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); - } + /** + * Given a reactor class, return a list of all its inputs, which includes inputs of base classes + * that it extends. If the base classes include a cycle, where X extends Y and Y extends X, then + * return only the input defined in the base class. The returned list may be empty. + * + * @param definition Reactor class definition. + */ + public static List allInputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); + } - public static Stream allNestedClasses(Reactor definition) { - return new HashSet<>(ASTUtils.allInstantiations(definition)).stream() - .map(Instantiation::getReactorClass) - .map(ASTUtils::toDefinition); - } + /** A list of all ports of {@code definition}, in an unspecified order. */ + public static List allPorts(Reactor definition) { + return Stream.concat( + ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()) + .toList(); + } - /** - * Given a reactor class, return a list of all its methods, - * which includes methods of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allMethods(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); - } + /** + * Given a reactor class, return a list of all its instantiations, which includes instantiations + * of base classes that it extends. This also includes instantiations in modes, returning a + * flattened view over all modes. + * + * @param definition Reactor class definition. + */ + public static List allInstantiations(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); + } - /** - * Given a reactor class, return a list of all its outputs, - * which includes outputs of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allOutputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); - } + public static Stream allNestedClasses(Reactor definition) { + return new HashSet<>(ASTUtils.allInstantiations(definition)) + .stream().map(Instantiation::getReactorClass).map(ASTUtils::toDefinition); + } - /** - * Given a reactor class, return a list of all its parameters, - * which includes parameters of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allParameters(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); - } + /** + * Given a reactor class, return a list of all its methods, which includes methods of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allMethods(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); + } - /** - * Given a reactor class, return a list of all its reactions, - * which includes reactions of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allReactions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); - } + /** + * Given a reactor class, return a list of all its outputs, which includes outputs of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allOutputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); + } - /** - * Given a reactor class, return a list of all its watchdogs. - * @param definition Reactor class definition - * @return List - */ - public static List allWatchdogs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); - } - - /** - * Given a reactor class, return a list of all its state variables, - * which includes state variables of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allStateVars(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); - } + /** + * Given a reactor class, return a list of all its parameters, which includes parameters of base + * classes that it extends. + * + * @param definition Reactor class definition. + */ + public static List allParameters(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); + } - /** - * Given a reactor class, return a list of all its timers, - * which includes timers of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allTimers(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); - } + /** + * Given a reactor class, return a list of all its reactions, which includes reactions of base + * classes that it extends. This also includes reactions in modes, returning a flattened view over + * all modes. + * + * @param definition Reactor class definition. + */ + public static List allReactions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); + } - /** - * Given a reactor class, returns a list of all its modes, - * which includes modes of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allModes(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); - } + /** + * Given a reactor class, return a list of all its watchdogs. + * + * @param definition Reactor class definition + * @return List + */ + public static List allWatchdogs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); + } - /** A list of all reactors instantiated, transitively or intransitively, by {@code r}. */ - public static List recursiveChildren(ReactorInstance r) { - List ret = new ArrayList<>(); - ret.add(r.reactorDefinition); - for (var child: r.children) { - ret.addAll(recursiveChildren(child)); - } - return ret; - } + /** + * Given a reactor class, return a list of all its state variables, which includes state variables + * of base classes that it extends. This also includes reactions in modes, returning a flattened + * view over all modes. + * + * @param definition Reactor class definition. + */ + public static List allStateVars(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); + } - /** - * Return all the superclasses of the specified reactor - * in deepest-first order. For example, if A extends B and C, and - * B and C both extend D, this will return the list [D, B, C, A]. - * Duplicates are removed. If the specified reactor does not extend - * any other reactor, then return an empty list. - * If a cycle is found, where X extends Y and Y extends X, or if - * a superclass is declared that is not found, then return null. - * @param reactor The specified reactor. - */ - public static LinkedHashSet superClasses(Reactor reactor) { - return superClasses(reactor, new LinkedHashSet<>()); - } + /** + * Given a reactor class, return a list of all its timers, which includes timers of base classes + * that it extends. This also includes reactions in modes, returning a flattened view over all + * modes. + * + * @param definition Reactor class definition. + */ + public static List allTimers(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); + } - /** - * Collect elements of type T from the class hierarchy and modes - * defined by a given reactor definition. - * @param definition The reactor definition. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - public static List collectElements(Reactor definition, EStructuralFeature feature) { - return ASTUtils.collectElements(definition, feature, true, true); + /** + * Given a reactor class, returns a list of all its modes, which includes modes of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allModes(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); + } + + /** A list of all reactors instantiated, transitively or intransitively, by {@code r}. */ + public static List recursiveChildren(ReactorInstance r) { + List ret = new ArrayList<>(); + ret.add(r.reactorDefinition); + for (var child : r.children) { + ret.addAll(recursiveChildren(child)); } + return ret; + } - /** - * Collect elements of type T contained in given reactor definition, including - * modes and the class hierarchy defined depending on configuration. - * @param definition The reactor definition. - * @param feature The structual model elements to collect. - * @param includeSuperClasses Whether to include elements in super classes. - * @param includeModes Whether to include elements in modes. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - @SuppressWarnings("unchecked") - public static List collectElements(Reactor definition, EStructuralFeature feature, boolean includeSuperClasses, boolean includeModes) { - List result = new ArrayList<>(); - - if (includeSuperClasses) { - // Add elements of elements defined in superclasses. - LinkedHashSet s = superClasses(definition); - if (s != null) { - for (Reactor superClass : s) { - result.addAll((EList) superClass.eGet(feature)); - } - } - } + /** + * Return all the superclasses of the specified reactor in deepest-first order. For example, if A + * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates + * are removed. If the specified reactor does not extend any other reactor, then return an empty + * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared + * that is not found, then return null. + * + * @param reactor The specified reactor. + */ + public static LinkedHashSet superClasses(Reactor reactor) { + return superClasses(reactor, new LinkedHashSet<>()); + } - // Add elements of the current reactor. - result.addAll((EList) definition.eGet(feature)); + /** + * Collect elements of type T from the class hierarchy and modes defined by a given reactor + * definition. + * + * @param definition The reactor definition. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + public static List collectElements( + Reactor definition, EStructuralFeature feature) { + return ASTUtils.collectElements(definition, feature, true, true); + } - if (includeModes && reactorModeFeatureMap.containsKey(feature)) { - var modeFeature = reactorModeFeatureMap.get(feature); - // Add elements of elements defined in modes. - for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { - insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); - } + /** + * Collect elements of type T contained in given reactor definition, including modes and the class + * hierarchy defined depending on configuration. + * + * @param definition The reactor definition. + * @param feature The structual model elements to collect. + * @param includeSuperClasses Whether to include elements in super classes. + * @param includeModes Whether to include elements in modes. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + @SuppressWarnings("unchecked") + public static List collectElements( + Reactor definition, + EStructuralFeature feature, + boolean includeSuperClasses, + boolean includeModes) { + List result = new ArrayList<>(); + + if (includeSuperClasses) { + // Add elements of elements defined in superclasses. + LinkedHashSet s = superClasses(definition); + if (s != null) { + for (Reactor superClass : s) { + result.addAll((EList) superClass.eGet(feature)); } + } + } - return result; + // Add elements of the current reactor. + result.addAll((EList) definition.eGet(feature)); + + if (includeModes && reactorModeFeatureMap.containsKey(feature)) { + var modeFeature = reactorModeFeatureMap.get(feature); + // Add elements of elements defined in modes. + for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { + insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); + } } - /** - * Adds the elements into the given list at a location matching to their textual position. - * - * When creating a flat view onto reactor elements including modes, the final list must be ordered according - * to the textual positions. - * - * Example: - * reactor R { - * reaction // -> is R.reactions[0] - * mode M { - * reaction // -> is R.mode[0].reactions[0] - * reaction // -> is R.mode[0].reactions[1] - * } - * reaction // -> is R.reactions[1] - * } - * In this example, it is important that the reactions in the mode are inserted between the top-level - * reactions to retain the correct global reaction ordering, which will be derived from this flattened view. - * - * @param list The list to add the elements into. - * @param elements The elements to add. - * @param mode The mode containing the elements. - * @param The type of elements to add (e.g., Port, Timer, etc.) - */ - private static void insertModeElementsAtTextualPosition(List list, List elements, Mode mode) { - if (elements.isEmpty()) { - return; // Nothing to add - } + return result; + } - var idx = list.size(); - if (idx > 0) { - // If there are elements in the list, first check if the last element has the same container as the mode. - // I.e. we don't want to compare textual positions of different reactors (super classes) - if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { - var modeAstNode = NodeModelUtils.getNode(mode); - if (modeAstNode != null) { - var modePos = modeAstNode.getOffset(); - // Now move the insertion index from the last element forward as long as this element has a textual - // position after the mode. - do { - var astNode = NodeModelUtils.getNode(list.get(idx - 1)); - if (astNode != null && astNode.getOffset() > modePos) { - idx--; - } else { - break; // Insertion index is ok. - } - } while (idx > 0); - } + /** + * Adds the elements into the given list at a location matching to their textual position. + * + *

When creating a flat view onto reactor elements including modes, the final list must be + * ordered according to the textual positions. + * + *

Example: reactor R { reaction // -> is R.reactions[0] mode M { reaction // -> is + * R.mode[0].reactions[0] reaction // -> is R.mode[0].reactions[1] } reaction // -> is + * R.reactions[1] } In this example, it is important that the reactions in the mode are inserted + * between the top-level reactions to retain the correct global reaction ordering, which will be + * derived from this flattened view. + * + * @param list The list to add the elements into. + * @param elements The elements to add. + * @param mode The mode containing the elements. + * @param The type of elements to add (e.g., Port, Timer, etc.) + */ + private static void insertModeElementsAtTextualPosition( + List list, List elements, Mode mode) { + if (elements.isEmpty()) { + return; // Nothing to add + } + + var idx = list.size(); + if (idx > 0) { + // If there are elements in the list, first check if the last element has the same container + // as the mode. + // I.e. we don't want to compare textual positions of different reactors (super classes) + if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { + var modeAstNode = NodeModelUtils.getNode(mode); + if (modeAstNode != null) { + var modePos = modeAstNode.getOffset(); + // Now move the insertion index from the last element forward as long as this element has + // a textual + // position after the mode. + do { + var astNode = NodeModelUtils.getNode(list.get(idx - 1)); + if (astNode != null && astNode.getOffset() > modePos) { + idx--; + } else { + break; // Insertion index is ok. } + } while (idx > 0); } - list.addAll(idx, elements); + } } + list.addAll(idx, elements); + } - public static Iterable allElementsOfClass( - Resource resource, - Class elementClass - ) { - //noinspection StaticPseudoFunctionalStyleMethod - return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); - } + public static Iterable allElementsOfClass( + Resource resource, Class elementClass) { + //noinspection StaticPseudoFunctionalStyleMethod + return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); + } - //////////////////////////////// - //// Utility functions for translating AST nodes into text - - /** - * Translate the given code into its textual representation - * with {@code CodeMap.Correspondence} tags inserted, or - * return the empty string if {@code node} is {@code null}. - * This method should be used to generate code. - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toText(EObject node) { - if (node == null) return ""; - return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); - } + //////////////////////////////// + //// Utility functions for translating AST nodes into text + + /** + * Translate the given code into its textual representation with {@code CodeMap.Correspondence} + * tags inserted, or return the empty string if {@code node} is {@code null}. This method should + * be used to generate code. + * + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toText(EObject node) { + if (node == null) return ""; + return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); + } - /** - * Translate the given code into its textual representation - * without {@code CodeMap.Correspondence} tags, or return - * the empty string if {@code node} is {@code null}. - * This method should be used for analyzing AST nodes in - * cases where they are easiest to analyze as strings. - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toOriginalText(EObject node) { - if (node == null) return ""; - return ToText.instance.doSwitch(node); - } + /** + * Translate the given code into its textual representation without {@code CodeMap.Correspondence} + * tags, or return the empty string if {@code node} is {@code null}. This method should be used + * for analyzing AST nodes in cases where they are easiest to analyze as strings. + * + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toOriginalText(EObject node) { + if (node == null) return ""; + return ToText.instance.doSwitch(node); + } - /** - * Return an integer representation of the given element. - * - * Internally, this method uses Integer.decode, so it will - * also understand hexadecimal, binary, etc. - * - * @param e The element to be rendered as an integer. - */ - public static Integer toInteger(Element e) { - return Integer.decode(e.getLiteral()); - } + /** + * Return an integer representation of the given element. + * + *

Internally, this method uses Integer.decode, so it will also understand hexadecimal, binary, + * etc. + * + * @param e The element to be rendered as an integer. + */ + public static Integer toInteger(Element e) { + return Integer.decode(e.getLiteral()); + } - /** - * Return a time value based on the given element. - * - * @param e The element to be rendered as a time value. - */ - public static TimeValue toTimeValue(Element e) { - return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); - } + /** + * Return a time value based on the given element. + * + * @param e The element to be rendered as a time value. + */ + public static TimeValue toTimeValue(Element e) { + return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); + } - /** - * Returns the time value represented by the given AST node. - */ - public static TimeValue toTimeValue(Time e) { - if (!isValidTime(e)) { - // invalid unit, will have been reported by validator - throw new IllegalArgumentException(); - } - return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); + /** Returns the time value represented by the given AST node. */ + public static TimeValue toTimeValue(Time e) { + if (!isValidTime(e)) { + // invalid unit, will have been reported by validator + throw new IllegalArgumentException(); } + return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); + } - /** - * Return a boolean based on the given element. - * - * @param e The element to be rendered as a boolean. - */ - public static boolean toBoolean(Element e) { - return elementToSingleString(e).equalsIgnoreCase("true"); - } + /** + * Return a boolean based on the given element. + * + * @param e The element to be rendered as a boolean. + */ + public static boolean toBoolean(Element e) { + return elementToSingleString(e).equalsIgnoreCase("true"); + } - /** - * Given the right-hand side of a target property, return a string that - * represents the given value/ - * - * If the given value is not a literal or and id (but for instance and array or dict), - * an empty string is returned. If the element is a string, any quotes are removed. - * - * @param e The right-hand side of a target property. - */ - public static String elementToSingleString(Element e) { - if (e.getLiteral() != null) { - return StringUtil.removeQuotes(e.getLiteral()).trim(); - } else if (e.getId() != null) { - return e.getId(); - } - return ""; - } + /** + * Given the right-hand side of a target property, return a string that represents the given + * value/ + * + *

If the given value is not a literal or and id (but for instance and array or dict), an empty + * string is returned. If the element is a string, any quotes are removed. + * + * @param e The right-hand side of a target property. + */ + public static String elementToSingleString(Element e) { + if (e.getLiteral() != null) { + return StringUtil.removeQuotes(e.getLiteral()).trim(); + } else if (e.getId() != null) { + return e.getId(); + } + return ""; + } - /** - * Given the right-hand side of a target property, return a list with all - * the strings that the property lists. - * - * Arrays are traversed, so strings are collected recursively. Empty strings - * are ignored; they are not added to the list. - * @param value The right-hand side of a target property. - */ - public static List elementToListOfStrings(Element value) { - List elements = new ArrayList<>(); - if (value.getArray() != null) { - for (Element element : value.getArray().getElements()) { - elements.addAll(elementToListOfStrings(element)); - } - return elements; - } else { - String v = elementToSingleString(value); - if (!v.isEmpty()) { - elements.add(v); - } - } - return elements; - } + /** + * Given the right-hand side of a target property, return a list with all the strings that the + * property lists. + * + *

Arrays are traversed, so strings are collected recursively. Empty strings are ignored; they + * are not added to the list. + * + * @param value The right-hand side of a target property. + */ + public static List elementToListOfStrings(Element value) { + List elements = new ArrayList<>(); + if (value.getArray() != null) { + for (Element element : value.getArray().getElements()) { + elements.addAll(elementToListOfStrings(element)); + } + return elements; + } else { + String v = elementToSingleString(value); + if (!v.isEmpty()) { + elements.add(v); + } + } + return elements; + } - /** - * Convert key-value pairs in an Element to a map, assuming that both the key - * and the value are strings. - */ - public static Map elementToStringMaps(Element value) { - Map elements = new HashMap<>(); - for (var element: value.getKeyvalue().getPairs()) { - elements.put( - element.getName().trim(), - StringUtil.removeQuotes(elementToSingleString(element.getValue())) - ); - } - return elements; - } + /** + * Convert key-value pairs in an Element to a map, assuming that both the key and the value are + * strings. + */ + public static Map elementToStringMaps(Element value) { + Map elements = new HashMap<>(); + for (var element : value.getKeyvalue().getPairs()) { + elements.put( + element.getName().trim(), + StringUtil.removeQuotes(elementToSingleString(element.getValue()))); + } + return elements; + } - // Various utility methods to convert various data types to Elements - - /** - * Convert a map to key-value pairs in an Element. - */ - public static Element toElement(Map map) { - Element e = LfFactory.eINSTANCE.createElement(); - if (map.size() == 0) return null; - else { - var kv = LfFactory.eINSTANCE.createKeyValuePairs(); - for (var entry : map.entrySet()) { - var pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(entry.getKey()); - var element = LfFactory.eINSTANCE.createElement(); - element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); - pair.setValue(element); - kv.getPairs().add(pair); - } - e.setKeyvalue(kv); - } + // Various utility methods to convert various data types to Elements + + /** Convert a map to key-value pairs in an Element. */ + public static Element toElement(Map map) { + Element e = LfFactory.eINSTANCE.createElement(); + if (map.size() == 0) return null; + else { + var kv = LfFactory.eINSTANCE.createKeyValuePairs(); + for (var entry : map.entrySet()) { + var pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(entry.getKey()); + var element = LfFactory.eINSTANCE.createElement(); + element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); + pair.setValue(element); + kv.getPairs().add(pair); + } + e.setKeyvalue(kv); + } + + return e; + } - return e; - } + /** + * Given a single string, convert it into its AST representation. {@code addQuotes} controls if + * the generated representation should be accompanied by double quotes ("") or not. + */ + private static Element toElement(String str, boolean addQuotes) { + if (str == null) return null; + var strToReturn = addQuotes ? StringUtil.addDoubleQuotes(str) : str; + Element e = LfFactory.eINSTANCE.createElement(); + e.setLiteral(strToReturn); + return e; + } - /** - * Given a single string, convert it into its AST representation. - * {@code addQuotes} controls if the generated representation should be - * accompanied by double quotes ("") or not. - */ - private static Element toElement(String str, boolean addQuotes) { - if (str == null) return null; - var strToReturn = addQuotes? StringUtil.addDoubleQuotes(str):str; - Element e = LfFactory.eINSTANCE.createElement(); - e.setLiteral(strToReturn); - return e; + /** Given a single string, convert it into its AST representation. */ + public static Element toElement(String str) { + return toElement(str, true); + } - } + /** + * Given a list of strings, convert it into its AST representation. Stores the list in the Array + * field of the element, unless the list only has one string, in which case it is stored in the + * Literal field. Returns null if the provided list is empty. + */ + public static Element toElement(List list) { + Element e = LfFactory.eINSTANCE.createElement(); + if (list.size() == 0) return null; + else if (list.size() == 1) { + return toElement(list.get(0)); + } else { + var arr = LfFactory.eINSTANCE.createArray(); + for (String s : list) { + arr.getElements().add(ASTUtils.toElement(s)); + } + e.setArray(arr); + } + return e; + } - /** - * Given a single string, convert it into its AST representation. - */ - public static Element toElement(String str) { - return toElement(str, true); - } + /** + * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit + * inside an Element. + */ + public static Element toElement(TimeValue tv) { + Element e = LfFactory.eINSTANCE.createElement(); + e.setTime((int) tv.time); + if (tv.unit != null) { + e.setUnit(tv.unit.toString()); + } + return e; + } + + public static Element toElement(boolean val) { + return toElement(Boolean.toString(val), false); + } - /** - * Given a list of strings, convert it into its AST representation. - * Stores the list in the Array field of the element, unless the list only has one string, - * in which case it is stored in the Literal field. Returns null if the provided list is empty. - */ - public static Element toElement(List list) { - Element e = LfFactory.eINSTANCE.createElement(); - if (list.size() == 0) return null; - else if (list.size() == 1) { - return toElement(list.get(0)); + public static Element toElement(int val) { + return toElement(Integer.toString(val), false); + } + + /** + * Translate the given type into its textual representation, but do not append any array + * specifications or type arguments. + * + * @param type AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String baseType(Type type) { + if (type != null) { + if (type.getCode() != null) { + return toText(type.getCode()); + } else { + if (type.isTime()) { + return "time"; } else { - var arr = LfFactory.eINSTANCE.createArray(); - for (String s : list) { - arr.getElements().add(ASTUtils.toElement(s)); - } - e.setArray(arr); - } - return e; - } + StringBuilder result = new StringBuilder(type.getId()); - /** - * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit inside an Element. - */ - public static Element toElement(TimeValue tv) { - Element e = LfFactory.eINSTANCE.createElement(); - e.setTime((int)tv.time); - if (tv.unit != null) { - e.setUnit(tv.unit.toString()); + for (String s : convertToEmptyListIfNull(type.getStars())) { + result.append(s); + } + return result.toString(); } - return e; + } } + return ""; + } - public static Element toElement(boolean val) { - return toElement(Boolean.toString(val), false); + /** + * Report whether the given literal is zero or not. + * + * @param literal AST node to inspect. + * @return True if the given literal denotes the constant `0`, false otherwise. + */ + public static boolean isZero(String literal) { + try { + if (literal != null && Integer.parseInt(literal) == 0) { + return true; + } + } catch (NumberFormatException e) { + // Not an int. } + return false; + } - public static Element toElement(int val) { - return toElement(Integer.toString(val), false); - } + /** + * Report whether the given expression is zero or not. + * + * @param expr AST node to inspect. + * @return True if the given value denotes the constant `0`, false otherwise. + */ + public static boolean isZero(Expression expr) { + if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; + } - /** - * Translate the given type into its textual representation, but - * do not append any array specifications or type arguments. - * @param type AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String baseType(Type type) { - if (type != null) { - if (type.getCode() != null) { - return toText(type.getCode()); - } else { - if (type.isTime()) { - return "time"; - } else { - StringBuilder result = new StringBuilder(type.getId()); - - for (String s : convertToEmptyListIfNull(type.getStars())) { - result.append(s); - } - return result.toString(); - } - } - } - return ""; - } + /** + * Report whether the given string literal is an integer number or not. + * + * @param literal AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Integer.decode(literal); + } catch (NumberFormatException e) { + return false; + } + return true; + } - /** - * Report whether the given literal is zero or not. - * @param literal AST node to inspect. - * @return True if the given literal denotes the constant `0`, false - * otherwise. - */ - public static boolean isZero(String literal) { - try { - if (literal != null && - Integer.parseInt(literal) == 0) { - return true; - } - } catch (NumberFormatException e) { - // Not an int. - } - return false; - } + /** + * Report whether the given string literal is a boolean value or not. + * + * @param literal AST node to inspect. + * @return True if the given value is a boolean, false otherwise. + */ + public static boolean isBoolean(String literal) { + return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); + } - /** - * Report whether the given expression is zero or not. - * - * @param expr AST node to inspect. - * @return True if the given value denotes the constant `0`, false otherwise. - */ - public static boolean isZero(Expression expr) { - if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; - } + /** + * Report whether the given string literal is a float value or not. + * + * @param literal AST node to inspect. + * @return True if the given value is a float, false otherwise. + */ + public static boolean isFloat(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Float.parseFloat(literal); + } catch (NumberFormatException e) { + return false; + } + return true; + } - /** - * Report whether the given string literal is an integer number or not. - * - * @param literal AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Integer.decode(literal); - } catch (NumberFormatException e) { - return false; - } - return true; - } + /** + * Report whether the given code is an integer number or not. + * + * @param code AST node to inspect. + * @return True if the given code is an integer, false otherwise. + */ + public static boolean isInteger(Code code) { + return isInteger(toText(code)); + } - /** - * Report whether the given string literal is a boolean value or not. - * @param literal AST node to inspect. - * @return True if the given value is a boolean, false otherwise. - */ - public static boolean isBoolean(String literal) { - return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); - } + /** + * Report whether the given expression is an integer number or not. + * + * @param expr AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(Expression expr) { + if (expr instanceof Literal) { + return isInteger(((Literal) expr).getLiteral()); + } else if (expr instanceof Code) { + return isInteger((Code) expr); + } + return false; + } - /** - * Report whether the given string literal is a float value or not. - * @param literal AST node to inspect. - * @return True if the given value is a float, false otherwise. - */ - public static boolean isFloat(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Float.parseFloat(literal); - } catch (NumberFormatException e) { - return false; - } - return true; - } + /** + * Report whether the given expression denotes a valid time or not. + * + * @param expr AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Expression expr) { + if (expr instanceof ParameterReference) { + return isOfTimeType(((ParameterReference) expr).getParameter()); + } else if (expr instanceof Time) { + return isValidTime((Time) expr); + } else if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; + } - /** - * Report whether the given code is an integer number or not. - * @param code AST node to inspect. - * @return True if the given code is an integer, false otherwise. - */ - public static boolean isInteger(Code code) { - return isInteger(toText(code)); - } + /** + * Report whether the given time denotes a valid time or not. + * + * @param t AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Time t) { + if (t == null) return false; + String unit = t.getUnit(); + return t.getInterval() == 0 || TimeUnit.isValidUnit(unit); + } - /** - * Report whether the given expression is an integer number or not. - * @param expr AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(Expression expr) { - if (expr instanceof Literal) { - return isInteger(((Literal) expr).getLiteral()); - } else if (expr instanceof Code) { - return isInteger((Code) expr); - } - return false; + /** If the initializer contains exactly one expression, return it. Otherwise, return null. */ + public static Expression asSingleExpr(Initializer init) { + if (init == null) { + return null; } + var exprs = init.getExprs(); + return exprs.size() == 1 ? exprs.get(0) : null; + } - /** - * Report whether the given expression denotes a valid time or not. - * @param expr AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Expression expr) { - if (expr instanceof ParameterReference) { - return isOfTimeType(((ParameterReference)expr).getParameter()); - } else if (expr instanceof Time) { - return isValidTime((Time) expr); - } else if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; + public static boolean isSingleExpr(Initializer init) { + // todo expand that to = initialization + if (init == null) { + return false; } + var exprs = init.getExprs(); + return exprs.size() == 1; + } - /** - * Report whether the given time denotes a valid time or not. - * @param t AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Time t) { - if (t == null) return false; - String unit = t.getUnit(); - return t.getInterval() == 0 || - TimeUnit.isValidUnit(unit); - } + public static boolean isListInitializer(Initializer init) { + return init != null && !isSingleExpr(init); + } - /** - * If the initializer contains exactly one expression, - * return it. Otherwise, return null. - */ - public static Expression asSingleExpr(Initializer init) { - if (init == null) { - return null; + /** + * Return the type of a declaration with the given (nullable) explicit type, and the given + * (nullable) initializer. If the explicit type is null, then the type is inferred from the + * initializer. Only two types can be inferred: "time" and "timeList". Return the "undefined" type + * if neither can be inferred. + * + * @param type Explicit type declared on the declaration + * @param init The initializer expression + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Type type, Initializer init) { + if (type != null) { + return InferredType.fromAST(type); + } else if (init == null) { + return InferredType.undefined(); + } + + var single = asSingleExpr(init); + if (single != null) { + // If there is a single element in the list, and it is a proper + // time value with units, we infer the type "time". + if (single instanceof ParameterReference) { + return getInferredType(((ParameterReference) single).getParameter()); + } else if (single instanceof Time) { + return InferredType.time(); + } + } else if (init.getExprs().size() > 1) { + // If there are multiple elements in the list, and there is at + // least one proper time value with units, and all other elements + // are valid times (including zero without units), we infer the + // type "time list". + var allValidTime = true; + var foundNonZero = false; + + for (var e : init.getExprs()) { + if (!ASTUtils.isValidTime(e)) { + allValidTime = false; } - var exprs = init.getExprs(); - return exprs.size() == 1 ? exprs.get(0) : null; - } - - public static boolean isSingleExpr(Initializer init) { - // todo expand that to = initialization - if (init == null) { - return false; + if (!ASTUtils.isZero(e)) { + foundNonZero = true; } - var exprs = init.getExprs(); - return exprs.size() == 1; - } + } - public static boolean isListInitializer(Initializer init) { - return init != null && !isSingleExpr(init); + if (allValidTime && foundNonZero) { + // Conservatively, no bounds are inferred; the returned type + // is a variable-size list. + return InferredType.timeList(); + } } + return InferredType.undefined(); + } - /** - * Return the type of a declaration with the given - * (nullable) explicit type, and the given (nullable) - * initializer. If the explicit type is null, then the - * type is inferred from the initializer. Only two types - * can be inferred: "time" and "timeList". Return the - * "undefined" type if neither can be inferred. - * - * @param type Explicit type declared on the declaration - * @param init The initializer expression - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Type type, Initializer init) { - if (type != null) { - return InferredType.fromAST(type); - } else if (init == null) { - return InferredType.undefined(); - } - - var single = asSingleExpr(init); - if (single != null) { - // If there is a single element in the list, and it is a proper - // time value with units, we infer the type "time". - if (single instanceof ParameterReference) { - return getInferredType(((ParameterReference) single).getParameter()); - } else if (single instanceof Time) { - return InferredType.time(); - } - } else if (init.getExprs().size() > 1) { - // If there are multiple elements in the list, and there is at - // least one proper time value with units, and all other elements - // are valid times (including zero without units), we infer the - // type "time list". - var allValidTime = true; - var foundNonZero = false; - - for (var e : init.getExprs()) { - if (!ASTUtils.isValidTime(e)) { - allValidTime = false; - } - if (!ASTUtils.isZero(e)) { - foundNonZero = true; - } - } - - if (allValidTime && foundNonZero) { - // Conservatively, no bounds are inferred; the returned type - // is a variable-size list. - return InferredType.timeList(); - } - } - return InferredType.undefined(); - } + /** + * Given a parameter, return an inferred type. Only two types can be inferred: "time" and + * "timeList". Return the "undefined" type if neither can be inferred. + * + * @param p A parameter to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Parameter p) { + return getInferredType(p.getType(), p.getInit()); + } - /** - * Given a parameter, return an inferred type. Only two types can be - * inferred: "time" and "timeList". Return the "undefined" type if - * neither can be inferred. - * - * @param p A parameter to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Parameter p) { - return getInferredType(p.getType(), p.getInit()); - } + /** + * Given a state variable, return an inferred type. Only two types can be inferred: "time" and + * "timeList". Return the "undefined" type if neither can be inferred. + * + * @param s A state variable to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(StateVar s) { + return getInferredType(s.getType(), s.getInit()); + } - /** - * Given a state variable, return an inferred type. Only two types can be - * inferred: "time" and "timeList". Return the "undefined" type if - * neither can be inferred. - * - * @param s A state variable to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(StateVar s) { - return getInferredType(s.getType(), s.getInit()); - } + /** + * Construct an inferred type from an "action" AST node based on its declared type. If no type is + * declared, return the "undefined" type. + * + * @param a An action to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Action a) { + return getInferredType(a.getType(), null); + } - /** - * Construct an inferred type from an "action" AST node based - * on its declared type. If no type is declared, return the "undefined" - * type. - * - * @param a An action to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Action a) { - return getInferredType(a.getType(), null); - } + /** + * Construct an inferred type from a "port" AST node based on its declared type. If no type is + * declared, return the "undefined" type. + * + * @param p A port to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Port p) { + return getInferredType(p.getType(), null); + } - /** - * Construct an inferred type from a "port" AST node based on its declared - * type. If no type is declared, return the "undefined" type. - * - * @param p A port to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Port p) { - return getInferredType(p.getType(), null); - } + /** + * If the given string can be recognized as a floating-point number that has a leading decimal + * point, prepend the string with a zero and return it. Otherwise, return the original string. + * + * @param literal A string might be recognizable as a floating point number with a leading decimal + * point. + * @return an equivalent representation of literal + * + */ + public static String addZeroToLeadingDot(String literal) { + Matcher m = ABBREVIATED_FLOAT.matcher(literal); + if (m.matches()) { + return literal.replace(".", "0."); + } + return literal; + } + /** + * Return true if the specified port is a multiport. + * + * @param port The port. + * @return True if the port is a multiport. + */ + public static boolean isMultiport(Port port) { + return port.getWidthSpec() != null; + } + //////////////////////////////// + //// Utility functions for translating AST nodes into text + // This is a continuation of a large section of ASTUtils.xtend + // with the same name. + + /** + * Generate code for referencing a port, action, or timer. + * + * @param reference The reference to the variable. + */ + public static String generateVarRef(VarRef reference) { + var prefix = ""; + if (reference.getContainer() != null) { + prefix = reference.getContainer().getName() + "."; + } + return prefix + reference.getVariable().getName(); + } - /** - * If the given string can be recognized as a floating-point number that has a leading decimal point, - * prepend the string with a zero and return it. Otherwise, return the original string. - * - * @param literal A string might be recognizable as a floating point number with a leading decimal point. - * @return an equivalent representation of literal - * - */ - public static String addZeroToLeadingDot(String literal) { - Matcher m = ABBREVIATED_FLOAT.matcher(literal); - if (m.matches()) { - return literal.replace(".", "0."); - } - return literal; + /** Assuming that the given expression denotes a valid time literal, return a time value. */ + public static TimeValue getLiteralTimeValue(Expression expr) { + if (expr instanceof Time) { + return toTimeValue((Time) expr); + } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { + return TimeValue.ZERO; + } else { + return null; } + } - /** - * Return true if the specified port is a multiport. - * @param port The port. - * @return True if the port is a multiport. - */ - public static boolean isMultiport(Port port) { - return port.getWidthSpec() != null; + /** If the parameter is of time type, return its default value. Otherwise, return null. */ + public static TimeValue getDefaultAsTimeValue(Parameter p) { + if (isOfTimeType(p)) { + var init = asSingleExpr(p.getInit()); + if (init != null) { + return getLiteralTimeValue(init); + } } + return null; + } - //////////////////////////////// - //// Utility functions for translating AST nodes into text - // This is a continuation of a large section of ASTUtils.xtend - // with the same name. - - /** - * Generate code for referencing a port, action, or timer. - * @param reference The reference to the variable. - */ - public static String generateVarRef(VarRef reference) { - var prefix = ""; - if (reference.getContainer() != null) { - prefix = reference.getContainer().getName() + "."; - } - return prefix + reference.getVariable().getName(); - } + /** Return whether the given state variable is inferred to a time type. */ + public static boolean isOfTimeType(StateVar state) { + InferredType t = getInferredType(state); + return t.isTime && !t.isList; + } - /** - * Assuming that the given expression denotes a valid time literal, - * return a time value. - */ - public static TimeValue getLiteralTimeValue(Expression expr) { - if (expr instanceof Time) { - return toTimeValue((Time)expr); - } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { - return TimeValue.ZERO; - } else { - return null; - } - } + /** Return whether the given parameter is inferred to a time type. */ + public static boolean isOfTimeType(Parameter param) { + InferredType t = getInferredType(param); + return t.isTime && !t.isList; + } - /** - * If the parameter is of time type, return its default value. - * Otherwise, return null. - */ - public static TimeValue getDefaultAsTimeValue(Parameter p) { - if (isOfTimeType(p)) { - var init = asSingleExpr(p.getInit()); - if (init != null) { - return getLiteralTimeValue(init); + /** + * Given a parameter, return its initial value. The initial value is a list of instances of + * Expressions. + * + *

If the instantiations argument is null or an empty list, then the value returned is simply + * the default value given when the parameter is defined. + * + *

If a list of instantiations is given, then the first instantiation is required to be an + * instantiation of the reactor class that is parameterized by the parameter. I.e., ``` + * parameter.eContainer == instantiations.get(0).reactorClass ``` If a second instantiation is + * given, then it is required to be an instantiation of a reactor class that contains the first + * instantiation. That is, ``` instantiations.get(0).eContainer == + * instantiations.get(1).reactorClass ``` More generally, for all 0 <= i < instantiations.size - + * 1, ``` instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass ``` If any of + * these conditions is not satisfied, then an IllegalArgumentException will be thrown. + * + *

Note that this chain of reactions cannot be inferred from the parameter because in each of + * the predicates above, there may be more than one instantiation that can appear on the right + * hand side of the predicate. + * + *

For example, consider the following program: ``` reactor A(x:int(1)) {} reactor B(y:int(2)) + * { a1 = new A(x = y); a2 = new A(x = -1); } reactor C(z:int(3)) { b1 = new B(y = z); b2 = new + * B(y = -2); } ``` Notice that there are a total of four instances of reactor class A. Then ``` + * initialValue(x, null) returns 1 initialValue(x, [a1]) returns 2 initialValue(x, [a2]) returns + * -1 initialValue(x, [a1, b1]) returns 3 initialValue(x, [a2, b1]) returns -1 initialValue(x, + * [a1, b2]) returns -2 initialValue(x, [a2, b2]) returns -1 ``` (Actually, in each of the above + * cases, the returned value is a list with one entry, a Literal, e.g. ["1"]). + * + *

There are two instances of reactor class B. ``` initialValue(y, null) returns 2 + * initialValue(y, [a1]) throws an IllegalArgumentException initialValue(y, [b1]) returns 3 + * initialValue(y, [b2]) returns -2 ``` + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * @return The value of the parameter. + * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the + * reactor class that is parameterized by the respective parameter or if the chain of + * instantiations is not nested. + */ + public static List initialValue( + Parameter parameter, List instantiations) { + // If instantiations are given, then check to see whether this parameter gets overridden in + // the first of those instantiations. + if (instantiations != null && instantiations.size() > 0) { + // Check to be sure that the instantiation is in fact an instantiation + // of the reactor class for which this is a parameter. + Instantiation instantiation = instantiations.get(0); + + if (!belongsTo(parameter, instantiation)) { + throw new IllegalArgumentException( + "Parameter " + + parameter.getName() + + " is not a parameter of reactor instance " + + instantiation.getName() + + "."); + } + // In case there is more than one assignment to this parameter, we need to + // find the last one. + Assignment lastAssignment = null; + for (Assignment assignment : instantiation.getParameters()) { + if (assignment.getLhs().equals(parameter)) { + lastAssignment = assignment; + } + } + if (lastAssignment != null) { + // Right hand side can be a list. Collect the entries. + List result = new ArrayList<>(); + for (Expression expr : lastAssignment.getRhs().getExprs()) { + if (expr instanceof ParameterReference) { + if (instantiations.size() > 1 + && instantiation.eContainer() != instantiations.get(1).getReactorClass()) { + throw new IllegalArgumentException( + "Reactor instance " + + instantiation.getName() + + " is not contained by instance " + + instantiations.get(1).getName() + + "."); } + result.addAll( + initialValue( + ((ParameterReference) expr).getParameter(), + instantiations.subList(1, instantiations.size()))); + } else { + result.add(expr); + } } - return null; - } - - /** - * Return whether the given state variable is inferred - * to a time type. - */ - public static boolean isOfTimeType(StateVar state) { - InferredType t = getInferredType(state); - return t.isTime && !t.isList; + return result; + } } + // If we reach here, then either no instantiation was supplied or + // there was no assignment in the instantiation. So just use the + // parameter's initial value. + return parameter.getInit().getExprs(); + } - /** - * Return whether the given parameter is inferred - * to a time type. - */ - public static boolean isOfTimeType(Parameter param) { - InferredType t = getInferredType(param); - return t.isTime && !t.isList; - } + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the + * specified instantiation, meaning that it is defined in the reactor class being instantiated or + * one of its base classes. + * + * @param eobject The object. + * @param instantiation The instantiation. + */ + public static boolean belongsTo(EObject eobject, Instantiation instantiation) { + Reactor reactor = toDefinition(instantiation.getReactorClass()); + return belongsTo(eobject, reactor); + } - /** - * Given a parameter, return its initial value. - * The initial value is a list of instances of Expressions. - * - * If the instantiations argument is null or an empty list, then the - * value returned is simply the default value given when the parameter - * is defined. - * - * If a list of instantiations is given, then the first instantiation - * is required to be an instantiation of the reactor class that is - * parameterized by the parameter. I.e., - * ``` - * parameter.eContainer == instantiations.get(0).reactorClass - * ``` - * If a second instantiation is given, then it is required to be an instantiation of a - * reactor class that contains the first instantiation. That is, - * ``` - * instantiations.get(0).eContainer == instantiations.get(1).reactorClass - * ``` - * More generally, for all 0 <= i < instantiations.size - 1, - * ``` - * instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass - * ``` - * If any of these conditions is not satisfied, then an IllegalArgumentException - * will be thrown. - * - * Note that this chain of reactions cannot be inferred from the parameter because - * in each of the predicates above, there may be more than one instantiation that - * can appear on the right hand side of the predicate. - * - * For example, consider the following program: - * ``` - * reactor A(x:int(1)) {} - * reactor B(y:int(2)) { - * a1 = new A(x = y); - * a2 = new A(x = -1); - * } - * reactor C(z:int(3)) { - * b1 = new B(y = z); - * b2 = new B(y = -2); - * } - * ``` - * Notice that there are a total of four instances of reactor class A. - * Then - * ``` - * initialValue(x, null) returns 1 - * initialValue(x, [a1]) returns 2 - * initialValue(x, [a2]) returns -1 - * initialValue(x, [a1, b1]) returns 3 - * initialValue(x, [a2, b1]) returns -1 - * initialValue(x, [a1, b2]) returns -2 - * initialValue(x, [a2, b2]) returns -1 - * ``` - * (Actually, in each of the above cases, the returned value is a list with - * one entry, a Literal, e.g. ["1"]). - * - * There are two instances of reactor class B. - * ``` - * initialValue(y, null) returns 2 - * initialValue(y, [a1]) throws an IllegalArgumentException - * initialValue(y, [b1]) returns 3 - * initialValue(y, [b2]) returns -2 - * ``` - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * - * @return The value of the parameter. - * - * @throws IllegalArgumentException If an instantiation provided is not an - * instantiation of the reactor class that is parameterized by the - * respective parameter or if the chain of instantiations is not nested. - */ - public static List initialValue(Parameter parameter, List instantiations) { - // If instantiations are given, then check to see whether this parameter gets overridden in - // the first of those instantiations. - if (instantiations != null && instantiations.size() > 0) { - // Check to be sure that the instantiation is in fact an instantiation - // of the reactor class for which this is a parameter. - Instantiation instantiation = instantiations.get(0); - - if (!belongsTo(parameter, instantiation)) { - throw new IllegalArgumentException("Parameter " - + parameter.getName() - + " is not a parameter of reactor instance " - + instantiation.getName() - + "." - ); - } - // In case there is more than one assignment to this parameter, we need to - // find the last one. - Assignment lastAssignment = null; - for (Assignment assignment: instantiation.getParameters()) { - if (assignment.getLhs().equals(parameter)) { - lastAssignment = assignment; - } - } - if (lastAssignment != null) { - // Right hand side can be a list. Collect the entries. - List result = new ArrayList<>(); - for (Expression expr: lastAssignment.getRhs().getExprs()) { - if (expr instanceof ParameterReference) { - if (instantiations.size() > 1 - && instantiation.eContainer() != instantiations.get(1).getReactorClass() - ) { - throw new IllegalArgumentException("Reactor instance " - + instantiation.getName() - + " is not contained by instance " - + instantiations.get(1).getName() - + "." - ); - } - result.addAll(initialValue(((ParameterReference)expr).getParameter(), - instantiations.subList(1, instantiations.size()))); - } else { - result.add(expr); - } - } - return result; - } - } - // If we reach here, then either no instantiation was supplied or - // there was no assignment in the instantiation. So just use the - // parameter's initial value. - return parameter.getInit().getExprs(); + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the + * specified reactor, meaning that it is defined in reactor class or one of its base classes. + * + * @param eobject The object. + * @param reactor The reactor. + */ + public static boolean belongsTo(EObject eobject, Reactor reactor) { + if (eobject.eContainer() == reactor) return true; + for (ReactorDecl baseClass : reactor.getSuperClasses()) { + if (belongsTo(eobject, toDefinition(baseClass))) { + return true; + } } + return false; + } - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) - * belongs to the specified instantiation, meaning that it is defined in - * the reactor class being instantiated or one of its base classes. - * @param eobject The object. - * @param instantiation The instantiation. - */ - public static boolean belongsTo(EObject eobject, Instantiation instantiation) { - Reactor reactor = toDefinition(instantiation.getReactorClass()); - return belongsTo(eobject, reactor); + /** + * Given a parameter return its integer value or null if it does not have an integer value. If the + * value of the parameter is a list of integers, return the sum of value in the list. The + * instantiations parameter is as in {@link #initialValue(Parameter, List)}. + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * @return The integer value of the parameter, or null if it does not have an integer value. + * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the + * reactor class that is parameterized by the respective parameter or if the chain of + * instantiations is not nested. + */ + public static Integer initialValueInt(Parameter parameter, List instantiations) { + List expressions = initialValue(parameter, instantiations); + int result = 0; + for (Expression expr : expressions) { + if (!(expr instanceof Literal)) { + return null; + } + try { + result += Integer.decode(((Literal) expr).getLiteral()); + } catch (NumberFormatException ex) { + return null; + } } + return result; + } - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) - * belongs to the specified reactor, meaning that it is defined in - * reactor class or one of its base classes. - * @param eobject The object. - * @param reactor The reactor. - */ - public static boolean belongsTo(EObject eobject, Reactor reactor) { - if (eobject.eContainer() == reactor) return true; - for (ReactorDecl baseClass : reactor.getSuperClasses()) { - if (belongsTo(eobject, toDefinition(baseClass))) { - return true; - } + /** + * Given the width specification of port or instantiation and an (optional) list of nested + * instantiations, return the width if it can be determined and -1 if not. It will not be able to + * be determined if either the width is variable (in which case you should use {@link + * #inferPortWidth(VarRef, Connection, List)} ) or the list of instantiations is incomplete or + * missing. If there are parameter references in the width, they are evaluated to the extent + * possible given the instantiations list. + * + *

The instantiations list is as in {@link #initialValue(Parameter, List)}. If the spec belongs + * to an instantiation (for a bank of reactors), then the first element on this list should be the + * instantiation that contains this instantiation. If the spec belongs to a port, then the first + * element on the list should be the instantiation of the reactor that contains the port. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * @return The width, or -1 if the width could not be determined. + * @throws IllegalArgumentException If an instantiation provided is not as given above or if the + * chain of instantiations is not nested. + */ + public static int width(WidthSpec spec, List instantiations) { + if (spec == null) { + return 1; + } + if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { + return inferWidthFromConnections(spec, instantiations); + } + var result = 0; + for (WidthTerm term : spec.getTerms()) { + if (term.getParameter() != null) { + Integer termWidth = initialValueInt(term.getParameter(), instantiations); + if (termWidth != null) { + result += termWidth; + } else { + return -1; } - return false; - } - - /** - * Given a parameter return its integer value or null - * if it does not have an integer value. - * If the value of the parameter is a list of integers, - * return the sum of value in the list. - * The instantiations parameter is as in - * {@link #initialValue(Parameter, List)}. - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * - * @return The integer value of the parameter, or null if it does not have an integer value. - * - * @throws IllegalArgumentException If an instantiation provided is not an - * instantiation of the reactor class that is parameterized by the - * respective parameter or if the chain of instantiations is not nested. - */ - public static Integer initialValueInt(Parameter parameter, List instantiations) { - List expressions = initialValue(parameter, instantiations); - int result = 0; - for (Expression expr: expressions) { - if (!(expr instanceof Literal)) { - return null; - } - try { - result += Integer.decode(((Literal) expr).getLiteral()); - } catch (NumberFormatException ex) { - return null; - } + } else if (term.getWidth() > 0) { + result += term.getWidth(); + } else { + // If the width cannot be determined because term's width <= 0, which means the term's width + // must be inferred, try to infer the width using connections. + if (spec.eContainer() instanceof Instantiation) { + try { + return inferWidthFromConnections(spec, instantiations); + } catch (InvalidSourceException e) { + // If the inference fails, return -1. + return -1; + } } - return result; + } } + return result; + } - /** - * Given the width specification of port or instantiation - * and an (optional) list of nested instantiations, return - * the width if it can be determined and -1 if not. - * It will not be able to be determined if either the - * width is variable (in which case you should use - * {@link #inferPortWidth(VarRef, Connection, List)} ) - * or the list of instantiations is incomplete or missing. - * If there are parameter references in the width, they are - * evaluated to the extent possible given the instantiations list. - * - * The instantiations list is as in - * {@link #initialValue(Parameter, List)}. - * If the spec belongs to an instantiation (for a bank of reactors), - * then the first element on this list should be the instantiation - * that contains this instantiation. If the spec belongs to a port, - * then the first element on the list should be the instantiation - * of the reactor that contains the port. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * - * @return The width, or -1 if the width could not be determined. - * - * @throws IllegalArgumentException If an instantiation provided is not as - * given above or if the chain of instantiations is not nested. - */ - public static int width(WidthSpec spec, List instantiations) { - if (spec == null) { - return 1; + /** + * Infer the width of a port reference in a connection. The port reference one or two parts, a + * port and an (optional) container which is an Instantiation that may refer to a bank of + * reactors. The width will be the product of the bank width and the port width. The returned + * value will be 1 if the port is not in a bank and is not a multiport. + * + *

If the width cannot be determined, this will return -1. The width cannot be determined if + * the list of instantiations is missing or incomplete. + * + *

The instantiations list is as in {@link #initialValue(Parameter, List)}. The first element + * on this list should be the instantiation that contains the specified connection. + * + * @param reference A port reference. + * @param connection A connection, or null if not in the context of a connection. + * @param instantiations The (optional) list of instantiations. + * @return The width or -1 if it could not be determined. + * @throws IllegalArgumentException If an instantiation provided is not as given above or if the + * chain of instantiations is not nested. + */ + public static int inferPortWidth( + VarRef reference, Connection connection, List instantiations) { + if (reference.getVariable() instanceof Port) { + // If the port is given as a.b, then we want to prepend a to + // the list of instantiations to determine the width of this port. + List extended = instantiations; + if (reference.getContainer() != null) { + extended = new ArrayList<>(); + extended.add(reference.getContainer()); + if (instantiations != null) { + extended.addAll(instantiations); } - if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { - return inferWidthFromConnections(spec, instantiations); - } - var result = 0; - for (WidthTerm term: spec.getTerms()) { - if (term.getParameter() != null) { - Integer termWidth = initialValueInt(term.getParameter(), instantiations); - if (termWidth != null) { - result += termWidth; - } else { - return -1; + } + + int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); + if (portWidth < 0) { + // Could not determine port width. + return -1; + } + + // Next determine the bank width. This may be unspecified, in which + // case it has to be inferred using the connection. + int bankWidth = 1; + if (reference.getContainer() != null) { + bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); + if (bankWidth < 0 && connection != null) { + // Try to infer the bank width from the connection. + if (reference.getContainer().getWidthSpec().isOfVariableLength()) { + // This occurs for a bank of delays. + int leftWidth = 0; + int rightWidth = 0; + int leftOrRight = 0; + for (VarRef leftPort : connection.getLeftPorts()) { + if (leftPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException( + "Multiple ports with variable width on a connection."); } - } else if (term.getWidth() > 0) { - result += term.getWidth(); - } else { - // If the width cannot be determined because term's width <= 0, which means the term's width - // must be inferred, try to infer the width using connections. - if (spec.eContainer() instanceof Instantiation) { - try { - return inferWidthFromConnections(spec, instantiations); - } catch (InvalidSourceException e) { - // If the inference fails, return -1. - return -1; - } + // Indicate that this port is on the left. + leftOrRight = -1; + } else { + // The left port is not the same as this reference. + int otherWidth = inferPortWidth(leftPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; } + leftWidth += otherWidth; + } } - } - return result; - } - - /** - * Infer the width of a port reference in a connection. - * The port reference one or two parts, a port and an (optional) container - * which is an Instantiation that may refer to a bank of reactors. - * The width will be the product of the bank width and the port width. - * The returned value will be 1 if the port is not in a bank and is not a multiport. - * - * If the width cannot be determined, this will return -1. - * The width cannot be determined if the list of instantiations is - * missing or incomplete. - * - * The instantiations list is as in - * {@link #initialValue(Parameter, List)}. - * The first element on this list should be the instantiation - * that contains the specified connection. - * - * @param reference A port reference. - * @param connection A connection, or null if not in the context of a connection. - * @param instantiations The (optional) list of instantiations. - * - * @return The width or -1 if it could not be determined. - * - * @throws IllegalArgumentException If an instantiation provided is not as - * given above or if the chain of instantiations is not nested. - */ - public static int inferPortWidth( - VarRef reference, Connection connection, List instantiations - ) { - if (reference.getVariable() instanceof Port) { - // If the port is given as a.b, then we want to prepend a to - // the list of instantiations to determine the width of this port. - List extended = instantiations; - if (reference.getContainer() != null) { - extended = new ArrayList<>(); - extended.add(reference.getContainer()); - if (instantiations != null) { - extended.addAll(instantiations); + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException( + "Multiple ports with variable width on a connection."); } + // Indicate that this port is on the right. + leftOrRight = 1; + } else { + int otherWidth = inferPortWidth(rightPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; + } + rightWidth += otherWidth; + } } - - int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); - if (portWidth < 0) { - // Could not determine port width. - return -1; + int discrepancy = 0; + if (leftOrRight < 0) { + // This port is on the left. + discrepancy = rightWidth - leftWidth; + } else if (leftOrRight > 0) { + // This port is on the right. + discrepancy = leftWidth - rightWidth; } - - // Next determine the bank width. This may be unspecified, in which - // case it has to be inferred using the connection. - int bankWidth = 1; - if (reference.getContainer() != null) { - bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); - if (bankWidth < 0 && connection != null) { - // Try to infer the bank width from the connection. - if (reference.getContainer().getWidthSpec().isOfVariableLength()) { - // This occurs for a bank of delays. - int leftWidth = 0; - int rightWidth = 0; - int leftOrRight = 0; - for (VarRef leftPort : connection.getLeftPorts()) { - if (leftPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that this port is on the left. - leftOrRight = -1; - } else { - // The left port is not the same as this reference. - int otherWidth = inferPortWidth(leftPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; - } - leftWidth += otherWidth; - } - } - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that this port is on the right. - leftOrRight = 1; - } else { - int otherWidth = inferPortWidth(rightPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; - } - rightWidth += otherWidth; - } - } - int discrepancy = 0; - if (leftOrRight < 0) { - // This port is on the left. - discrepancy = rightWidth - leftWidth; - } else if (leftOrRight > 0) { - // This port is on the right. - discrepancy = leftWidth - rightWidth; - } - // Check that portWidth divides the discrepancy. - if (discrepancy % portWidth != 0) { - // This is an error. - return -1; - } - bankWidth = discrepancy / portWidth; - } else { - // Could not determine the bank width. - return -1; - } - } + // Check that portWidth divides the discrepancy. + if (discrepancy % portWidth != 0) { + // This is an error. + return -1; } - return portWidth * bankWidth; + bankWidth = discrepancy / portWidth; + } else { + // Could not determine the bank width. + return -1; + } } - // Argument is not a port. - return -1; + } + return portWidth * bankWidth; } + // Argument is not a port. + return -1; + } - /** - * Given an instantiation of a reactor or bank of reactors, return - * the width. This will be 1 if this is not a reactor bank. Otherwise, - * this will attempt to determine the width. If the width is declared - * as a literal constant, it will return that constant. If the width - * is specified as a reference to a parameter, this will throw an - * exception. If the width is variable, this will find - * connections in the enclosing reactor and attempt to infer the - * width. If the width cannot be determined, it will throw an exception. - * - * IMPORTANT: This method should not be used you really need to - * determine the width! It will not evaluate parameter values. - * @see #width(WidthSpec, List) - * - * @param instantiation A reactor instantiation. - * - * @return The width, if it can be determined. - * @deprecated - */ - @Deprecated - public static int widthSpecification(Instantiation instantiation) { - int result = width(instantiation.getWidthSpec(), null); - if (result < 0) { - throw new InvalidSourceException("Cannot determine width for the instance " - + instantiation.getName()); - } - return result; - } + /** + * Given an instantiation of a reactor or bank of reactors, return the width. This will be 1 if + * this is not a reactor bank. Otherwise, this will attempt to determine the width. If the width + * is declared as a literal constant, it will return that constant. If the width is specified as a + * reference to a parameter, this will throw an exception. If the width is variable, this will + * find connections in the enclosing reactor and attempt to infer the width. If the width cannot + * be determined, it will throw an exception. + * + *

IMPORTANT: This method should not be used you really need to determine the width! It will + * not evaluate parameter values. + * + * @see #width(WidthSpec, List) + * @param instantiation A reactor instantiation. + * @return The width, if it can be determined. + * @deprecated + */ + @Deprecated + public static int widthSpecification(Instantiation instantiation) { + int result = width(instantiation.getWidthSpec(), null); + if (result < 0) { + throw new InvalidSourceException( + "Cannot determine width for the instance " + instantiation.getName()); + } + return result; + } - /** - * Report whether a state variable has been initialized or not. - * @param v The state variable to be checked. - * @return True if the variable was initialized, false otherwise. - */ - public static boolean isInitialized(StateVar v) { - return v != null && v.getInit() != null; - } + /** + * Report whether a state variable has been initialized or not. + * + * @param v The state variable to be checked. + * @return True if the variable was initialized, false otherwise. + */ + public static boolean isInitialized(StateVar v) { + return v != null && v.getInit() != null; + } - /** - * Report whether the given time state variable is initialized using a - * parameter or not. - * @param s A state variable. - * @return True if the argument is initialized using a parameter, false - * otherwise. - */ - public static boolean isParameterized(StateVar s) { - return s.getInit() != null && - IterableExtensions.exists(s.getInit().getExprs(), it -> it instanceof ParameterReference); - } + /** + * Report whether the given time state variable is initialized using a parameter or not. + * + * @param s A state variable. + * @return True if the argument is initialized using a parameter, false otherwise. + */ + public static boolean isParameterized(StateVar s) { + return s.getInit() != null + && IterableExtensions.exists( + s.getInit().getExprs(), it -> it instanceof ParameterReference); + } - /** - * Check if the reactor class uses generics - * @param r the reactor to check - * @return true if the reactor uses generics - */ - public static boolean isGeneric(Reactor r) { - if (r == null) { - return false; - } - return r.getTypeParms().size() != 0; - } + /** + * Check if the reactor class uses generics + * + * @param r the reactor to check + * @return true if the reactor uses generics + */ + public static boolean isGeneric(Reactor r) { + if (r == null) { + return false; + } + return r.getTypeParms().size() != 0; + } - /** - * If the specified reactor declaration is an import, then - * return the imported reactor class definition. Otherwise, - * just return the argument. - * @param r A Reactor or an ImportedReactor. - * @return The Reactor class definition or null if no definition is found. - */ - public static Reactor toDefinition(ReactorDecl r) { - if (r == null) - return null; - if (r instanceof Reactor) { - return (Reactor) r; - } else if (r instanceof ImportedReactor) { - return ((ImportedReactor) r).getReactorClass(); - } - return null; - } + /** + * If the specified reactor declaration is an import, then return the imported reactor class + * definition. Otherwise, just return the argument. + * + * @param r A Reactor or an ImportedReactor. + * @return The Reactor class definition or null if no definition is found. + */ + public static Reactor toDefinition(ReactorDecl r) { + if (r == null) return null; + if (r instanceof Reactor) { + return (Reactor) r; + } else if (r instanceof ImportedReactor) { + return ((ImportedReactor) r).getReactorClass(); + } + return null; + } - /** - * Return all single-line or multi-line comments immediately preceding the - * given EObject. - */ - public static Stream getPrecedingComments( - ICompositeNode compNode, - Predicate filter - ) { - return getPrecedingCommentNodes(compNode, filter).map(INode::getText); - } + /** Return all single-line or multi-line comments immediately preceding the given EObject. */ + public static Stream getPrecedingComments( + ICompositeNode compNode, Predicate filter) { + return getPrecedingCommentNodes(compNode, filter).map(INode::getText); + } - /** - * Return all single-line or multi-line comments immediately preceding the - * given EObject. - */ - public static Stream getPrecedingCommentNodes( - ICompositeNode compNode, - Predicate filter - ) { - if (compNode == null) return Stream.of(); - List ret = new ArrayList<>(); - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode)) { - if (isComment(node)) { - if (filter.test(node)) ret.add(node); - } else if (!node.getText().isBlank()) { - break; - } - } + /** Return all single-line or multi-line comments immediately preceding the given EObject. */ + public static Stream getPrecedingCommentNodes( + ICompositeNode compNode, Predicate filter) { + if (compNode == null) return Stream.of(); + List ret = new ArrayList<>(); + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode)) { + if (isComment(node)) { + if (filter.test(node)) ret.add(node); + } else if (!node.getText().isBlank()) { + break; } - return ret.stream(); - } - - /** Return whether {@code node} is a comment. */ - public static boolean isComment(INode node) { - return node instanceof HiddenLeafNode hlNode - && hlNode.getGrammarElement() instanceof TerminalRule tRule - && tRule.getName().endsWith("_COMMENT"); + } } + return ret.stream(); + } - /** - * Return true if the given node starts on the same line as the given other - * node. - */ - public static Predicate sameLine(ICompositeNode compNode) { - return other -> { - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { - return node.getStartLine() == other.getStartLine(); - } - } - return false; - }; - } + /** Return whether {@code node} is a comment. */ + public static boolean isComment(INode node) { + return node instanceof HiddenLeafNode hlNode + && hlNode.getGrammarElement() instanceof TerminalRule tRule + && tRule.getName().endsWith("_COMMENT"); + } - /** - * Find the main reactor and set its name if none was defined. - * @param resource The resource to find the main reactor in. - */ - public static void setMainName(Resource resource, String name) { - Reactor main = IteratorExtensions.findFirst(Iterators.filter(resource.getAllContents(), Reactor.class), - it -> it.isMain() || it.isFederated() - ); - if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { - main.setName(name); + /** Return true if the given node starts on the same line as the given other node. */ + public static Predicate sameLine(ICompositeNode compNode) { + return other -> { + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { + return node.getStartLine() == other.getStartLine(); } + } + return false; + }; + } + + /** + * Find the main reactor and set its name if none was defined. + * + * @param resource The resource to find the main reactor in. + */ + public static void setMainName(Resource resource, String name) { + Reactor main = + IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), + it -> it.isMain() || it.isFederated()); + if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { + main.setName(name); } + } - /** - * Create a new instantiation node with the given reactor as its defining class. - * @param reactor The reactor class to create an instantiation of. - */ - public static Instantiation createInstantiation(Reactor reactor) { - Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); - inst.setReactorClass(reactor); - // If the reactor is federated or at the top level, then it - // may not have a name. In the generator's doGenerate() - // method, the name gets set using setMainName(). - // But this may be called before that, e.g. during - // diagram synthesis. We assign a temporary name here. - if (reactor.getName() == null) { - if (reactor.isFederated() || reactor.isMain()) { - inst.setName("main"); - } else { - inst.setName(""); - } + /** + * Create a new instantiation node with the given reactor as its defining class. + * + * @param reactor The reactor class to create an instantiation of. + */ + public static Instantiation createInstantiation(Reactor reactor) { + Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); + inst.setReactorClass(reactor); + // If the reactor is federated or at the top level, then it + // may not have a name. In the generator's doGenerate() + // method, the name gets set using setMainName(). + // But this may be called before that, e.g. during + // diagram synthesis. We assign a temporary name here. + if (reactor.getName() == null) { + if (reactor.isFederated() || reactor.isMain()) { + inst.setName("main"); + } else { + inst.setName(""); + } + + } else { + inst.setName(reactor.getName()); + } + return inst; + } - } else { - inst.setName(reactor.getName()); - } - return inst; - } + /** + * Returns the target declaration in the given model. Non-null because it would cause a parse + * error. + */ + public static TargetDecl targetDecl(Model model) { + return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); + } - /** - * Returns the target declaration in the given model. - * Non-null because it would cause a parse error. - */ - public static TargetDecl targetDecl(Model model) { - return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); - } + /** + * Returns the target declaration in the given resource. Non-null because it would cause a parse + * error. + */ + public static TargetDecl targetDecl(Resource model) { + return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); + } - /** - * Returns the target declaration in the given resource. - * Non-null because it would cause a parse error. - */ - public static TargetDecl targetDecl(Resource model) { - return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); - } + ///////////////////////////////////////////////////////// + //// Private methods - ///////////////////////////////////////////////////////// - //// Private methods + /** Returns the list if it is not null. Otherwise, return an empty list. */ + public static List convertToEmptyListIfNull(List list) { + return list != null ? list : new ArrayList<>(); + } - /** - * Returns the list if it is not null. Otherwise, return an empty list. - */ - public static List convertToEmptyListIfNull(List list) { - return list != null ? list : new ArrayList<>(); - } + /** + * Return all the superclasses of the specified reactor in deepest-first order. For example, if A + * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates + * are removed. If the specified reactor does not extend any other reactor, then return an empty + * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared + * that is not found, then return null. + * + * @param reactor The specified reactor. + * @param extensions A set of reactors extending the specified reactor (used to detect circular + * extensions). + */ + private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { + LinkedHashSet result = new LinkedHashSet<>(); + for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { + Reactor r = toDefinition(superDecl); + if (r == reactor || r == null) return null; + // If r is in the extensions, then we have a circular inheritance structure. + if (extensions.contains(r)) return null; + extensions.add(r); + LinkedHashSet baseExtends = superClasses(r, extensions); + extensions.remove(r); + if (baseExtends == null) return null; + result.addAll(baseExtends); + result.add(r); + } + return result; + } - /** - * Return all the superclasses of the specified reactor - * in deepest-first order. For example, if A extends B and C, and - * B and C both extend D, this will return the list [D, B, C, A]. - * Duplicates are removed. If the specified reactor does not extend - * any other reactor, then return an empty list. - * If a cycle is found, where X extends Y and Y extends X, or if - * a superclass is declared that is not found, then return null. - * @param reactor The specified reactor. - * @param extensions A set of reactors extending the specified reactor - * (used to detect circular extensions). - */ - private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { - LinkedHashSet result = new LinkedHashSet<>(); - for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { - Reactor r = toDefinition(superDecl); - if (r == reactor || r == null) return null; - // If r is in the extensions, then we have a circular inheritance structure. - if (extensions.contains(r)) return null; - extensions.add(r); - LinkedHashSet baseExtends = superClasses(r, extensions); - extensions.remove(r); - if (baseExtends == null) return null; - result.addAll(baseExtends); - result.add(r); + /** + * We may be able to infer the width by examining the connections of the enclosing reactor + * definition. This works, for example, with delays between multiports or banks of reactors. + * Attempt to infer the width from connections and return -1 if the width cannot be inferred. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * @return The width, or -1 if the width could not be inferred from connections. + */ + private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { + for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { + int leftWidth = 0; + int rightWidth = 0; + int leftOrRight = 0; + for (VarRef leftPort : c.getLeftPorts()) { + if (leftPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the left. + leftOrRight = -1; + } else { + leftWidth += inferPortWidth(leftPort, c, instantiations); } - return result; - } - - /** - * We may be able to infer the width by examining the connections of - * the enclosing reactor definition. This works, for example, with - * delays between multiports or banks of reactors. - * Attempt to infer the width from connections and return -1 if the width cannot be inferred. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * - * @return The width, or -1 if the width could not be inferred from connections. - */ - private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { - for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { - int leftWidth = 0; - int rightWidth = 0; - int leftOrRight = 0; - for (VarRef leftPort : c.getLeftPorts()) { - if (leftPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the left. - leftOrRight = -1; - } else { - leftWidth += inferPortWidth(leftPort, c, instantiations); - } - } - for (VarRef rightPort : c.getRightPorts()) { - if (rightPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the right. - leftOrRight = 1; - } else { - rightWidth += inferPortWidth(rightPort, c, instantiations); - } - } - if (leftOrRight < 0) { - return rightWidth - leftWidth; - } else if (leftOrRight > 0) { - return leftWidth - rightWidth; - } + } + for (VarRef rightPort : c.getRightPorts()) { + if (rightPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the right. + leftOrRight = 1; + } else { + rightWidth += inferPortWidth(rightPort, c, instantiations); } - // A connection was not found with the instantiation. - return -1; - } + } + if (leftOrRight < 0) { + return rightWidth - leftWidth; + } else if (leftOrRight > 0) { + return leftWidth - rightWidth; + } + } + // A connection was not found with the instantiation. + return -1; + } - public static void addReactionAttribute(Reaction reaction, String name) { - var fedAttr = factory.createAttribute(); - fedAttr.setAttrName(name); - reaction.getAttributes().add(fedAttr); - } -} \ No newline at end of file + public static void addReactionAttribute(Reaction reaction, String name) { + var fedAttr = factory.createAttribute(); + fedAttr.setAttrName(name); + reaction.getAttributes().add(fedAttr); + } +} diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index 3a7a5fb2cd..73cd12916a 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -275,20 +275,20 @@ public Boolean caseAttrParm(AttrParm object) { .conclusion; } - @Override - public Boolean caseReaction(Reaction object) { - return new ComparisonMachine<>(object, Reaction.class) - .listsEquivalent(Reaction::getAttributes) - .listsEquivalent(Reaction::getTriggers) - .listsEquivalent(Reaction::getSources) - .listsEquivalent(Reaction::getEffects) - .equalAsObjects(Reaction::isMutation) - .equalAsObjects(Reaction::getName) - .equivalent(Reaction::getCode) - .equivalent(Reaction::getStp) - .equivalent(Reaction::getDeadline) - .conclusion; - } + @Override + public Boolean caseReaction(Reaction object) { + return new ComparisonMachine<>(object, Reaction.class) + .listsEquivalent(Reaction::getAttributes) + .listsEquivalent(Reaction::getTriggers) + .listsEquivalent(Reaction::getSources) + .listsEquivalent(Reaction::getEffects) + .equalAsObjects(Reaction::isMutation) + .equalAsObjects(Reaction::getName) + .equivalent(Reaction::getCode) + .equivalent(Reaction::getStp) + .equivalent(Reaction::getDeadline) + .conclusion; + } @Override public Boolean caseTriggerRef(TriggerRef object) { diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 52e2a5794b..b3bf51d836 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -66,21 +66,18 @@ import org.lflang.lf.WidthSpec; /** - * Representation of a compile-time instance of a reactor. - * If the reactor is instantiated as a bank of reactors, or if any - * of its parents is instantiated as a bank of reactors, then one instance - * of this ReactorInstance class represents all the runtime instances within - * these banks. The {@link #getTotalWidth()} method returns the number of such - * runtime instances, which is the product of the bank width of this reactor - * instance and the bank widths of all of its parents. - * There is exactly one instance of this ReactorInstance class for each - * graphical rendition of a reactor in the diagram view. + * Representation of a compile-time instance of a reactor. If the reactor is instantiated as a bank + * of reactors, or if any of its parents is instantiated as a bank of reactors, then one instance of + * this ReactorInstance class represents all the runtime instances within these banks. The {@link + * #getTotalWidth()} method returns the number of such runtime instances, which is the product of + * the bank width of this reactor instance and the bank widths of all of its parents. There is + * exactly one instance of this ReactorInstance class for each graphical rendition of a reactor in + * the diagram view. * - * For the main reactor, which has no parent, once constructed, - * this object represents the entire Lingua Franca program. - * If the program has causality loops (a programming error), then - * {@link #hasCycles()} will return true and {@link #getCycles()} will - * return the ports and reaction instances involved in the cycles. + *

For the main reactor, which has no parent, once constructed, this object represents the entire + * Lingua Franca program. If the program has causality loops (a programming error), then {@link + * #hasCycles()} will return true and {@link #getCycles()} will return the ports and reaction + * instances involved in the cycles. * * @author Marten Lohstroh * @author Edward A. Lee @@ -264,45 +261,45 @@ public PortInstance getInput(String name) { return null; } - /** - * Return the set of ReactionInstance and PortInstance that form causality - * loops in the topmost parent reactor in the instantiation hierarchy. This will return an - * empty set if there are no causality loops. - */ - public Set> getCycles() { - if (depth != 0) return root().getCycles(); - if (cachedCycles != null) return cachedCycles; - cachedCycles = new LinkedHashSet<>(); - - ReactionInstanceGraph reactionRuntimes = assignLevels(); - if (reactionRuntimes.nodes().size() > 0) { - Set reactions = new LinkedHashSet<>(); - Set ports = new LinkedHashSet<>(); - // There are cycles. But the nodes set includes not - // just the cycles, but also nodes that are downstream of the - // cycles. Use Tarjan's algorithm to get just the cycles. - var cycleNodes = reactionRuntimes.getCycles(); - for (var cycle : cycleNodes) { - for (ReactionInstance.Runtime runtime : cycle) { - reactions.add(runtime.getReaction()); - } - } - // Need to figure out which ports are involved in the cycles. - // It may not be all ports that depend on this reaction. - for (ReactionInstance r : reactions) { - for (TriggerInstance p : r.effects) { - if (p instanceof PortInstance) { - findPaths((PortInstance)p, reactions, ports); - } - } - } - cachedCycles.addAll(reactions); - cachedCycles.addAll(ports); + /** + * Return the set of ReactionInstance and PortInstance that form causality loops in the topmost + * parent reactor in the instantiation hierarchy. This will return an empty set if there are no + * causality loops. + */ + public Set> getCycles() { + if (depth != 0) return root().getCycles(); + if (cachedCycles != null) return cachedCycles; + cachedCycles = new LinkedHashSet<>(); + + ReactionInstanceGraph reactionRuntimes = assignLevels(); + if (reactionRuntimes.nodes().size() > 0) { + Set reactions = new LinkedHashSet<>(); + Set ports = new LinkedHashSet<>(); + // There are cycles. But the nodes set includes not + // just the cycles, but also nodes that are downstream of the + // cycles. Use Tarjan's algorithm to get just the cycles. + var cycleNodes = reactionRuntimes.getCycles(); + for (var cycle : cycleNodes) { + for (ReactionInstance.Runtime runtime : cycle) { + reactions.add(runtime.getReaction()); } - - return cachedCycles; + } + // Need to figure out which ports are involved in the cycles. + // It may not be all ports that depend on this reaction. + for (ReactionInstance r : reactions) { + for (TriggerInstance p : r.effects) { + if (p instanceof PortInstance) { + findPaths((PortInstance) p, reactions, ports); + } + } + } + cachedCycles.addAll(reactions); + cachedCycles.addAll(ports); } + return cachedCycles; + } + /** * Override the base class to append [i_d], where d is the depth, if this reactor is in a bank of * reactors. @@ -448,51 +445,52 @@ public Expression resolveParameters(Expression e) { return LfExpressionVisitor.dispatch(e, this, ParameterInliner.INSTANCE); } - private static final class ParameterInliner extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { + private static final class ParameterInliner + extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { static final ParameterInliner INSTANCE = new ParameterInliner(); @Override public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { - if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { - throw new IllegalArgumentException("Parameter " + if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { + throw new IllegalArgumentException( + "Parameter " + expr.getParameter().getName() + " is not a parameter of reactor instance " + instance.getName() - + "." - ); - } - - Optional assignment = - instance.definition.getParameters().stream() - .filter(it -> it.getLhs().equals(expr.getParameter())) - .findAny(); // There is at most one + + "."); + } - if (assignment.isPresent()) { - // replace the parameter with its value. - Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); - // recursively resolve parameters - return instance.getParent().resolveParameters(value); - } else { - // In that case use the default value. Default values - // cannot use parameter values, so they don't need to - // be recursively resolved. - Initializer init = expr.getParameter().getInit(); - Expression defaultValue = ASTUtils.asSingleExpr(init); - if (defaultValue == null) { - // this is a problem - return super.visitParameterRef(expr, instance); - } - return defaultValue; + Optional assignment = + instance.definition.getParameters().stream() + .filter(it -> it.getLhs().equals(expr.getParameter())) + .findAny(); // There is at most one + + if (assignment.isPresent()) { + // replace the parameter with its value. + Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); + // recursively resolve parameters + return instance.getParent().resolveParameters(value); + } else { + // In that case use the default value. Default values + // cannot use parameter values, so they don't need to + // be recursively resolved. + Initializer init = expr.getParameter().getInit(); + Expression defaultValue = ASTUtils.asSingleExpr(init); + if (defaultValue == null) { + // this is a problem + return super.visitParameterRef(expr, instance); } + return defaultValue; + } } -} + } - // /** - // * Return the startup trigger or null if not used in any reaction. - // */ - // public TriggerInstance getStartupTrigger() { - // return _instantiations; - // } + // /** + // * Return the startup trigger or null if not used in any reaction. + // */ + // public TriggerInstance getStartupTrigger() { + // return _instantiations; + // } /////////////////////////////////////////////////// //// Methods for finding instances in this reactor given an AST node. @@ -670,21 +668,21 @@ public TimeValue getTimeValue(Expression expr) { protected void createReactionInstances() { List reactions = ASTUtils.allReactions(reactorDefinition); if (reactions != null) { - int count = 0; + int count = 0; - // Check for startup and shutdown triggers. - for (Reaction reaction : reactions) { - if (AttributeUtils.isUnordered(reaction)) { - unorderedReactions.add(reaction); - } - // Create the reaction instance. - var reactionInstance = new ReactionInstance(reaction, this, - unorderedReactions.contains(reaction), count++); - - // Add the reaction instance to the map of reactions for this - // reactor. - this.reactions.add(reactionInstance); + // Check for startup and shutdown triggers. + for (Reaction reaction : reactions) { + if (AttributeUtils.isUnordered(reaction)) { + unorderedReactions.add(reaction); } + // Create the reaction instance. + var reactionInstance = + new ReactionInstance(reaction, this, unorderedReactions.contains(reaction), count++); + + // Add the reaction instance to the map of reactions for this + // reactor. + this.reactions.add(reactionInstance); + } } } @@ -692,14 +690,14 @@ protected void createReactionInstances() { protected void createWatchdogInstances() { List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); if (watchdogs != null) { - for (Watchdog watchdog : watchdogs) { - // Create the watchdog instance. - var watchdogInstance = new WatchdogInstance(watchdog, this); + for (Watchdog watchdog : watchdogs) { + // Create the watchdog instance. + var watchdogInstance = new WatchdogInstance(watchdog, this); - // Add the watchdog instance to the list of watchdogs for this - // reactor. - this.watchdogs.add(watchdogInstance); - } + // Add the watchdog instance to the list of watchdogs for this + // reactor. + this.watchdogs.add(watchdogInstance); + } } } @@ -716,172 +714,167 @@ protected void createWatchdogInstances() { * @param desiredDepth The depth to which to expand the hierarchy. */ private ReactorInstance( - Instantiation definition, - ReactorInstance parent, - ErrorReporter reporter, - int desiredDepth) { - super(definition, parent); - this.reporter = reporter; - this.reactorDeclaration = definition.getReactorClass(); - this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); - - // check for recursive instantiation - var currentParent = parent; - var foundSelfAsParent = false; - do { - if (currentParent != null) { - if (currentParent.reactorDefinition == this.reactorDefinition) { - foundSelfAsParent = true; - currentParent = null; // break - } else { - currentParent = currentParent.parent; - } - } - } while(currentParent != null); - - this.recursive = foundSelfAsParent; - if (recursive) { - reporter.reportError(definition, "Recursive reactor instantiation."); + Instantiation definition, ReactorInstance parent, ErrorReporter reporter, int desiredDepth) { + super(definition, parent); + this.reporter = reporter; + this.reactorDeclaration = definition.getReactorClass(); + this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); + + // check for recursive instantiation + var currentParent = parent; + var foundSelfAsParent = false; + do { + if (currentParent != null) { + if (currentParent.reactorDefinition == this.reactorDefinition) { + foundSelfAsParent = true; + currentParent = null; // break + } else { + currentParent = currentParent.parent; } + } + } while (currentParent != null); - // If the reactor definition is null, give up here. Otherwise, diagram generation - // will fail an NPE. - if (reactorDefinition == null) { - reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); - return; - } + this.recursive = foundSelfAsParent; + if (recursive) { + reporter.reportError(definition, "Recursive reactor instantiation."); + } - setInitialWidth(); + // If the reactor definition is null, give up here. Otherwise, diagram generation + // will fail an NPE. + if (reactorDefinition == null) { + reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); + return; + } - // Apply overrides and instantiate parameters for this reactor instance. - for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { - this.parameters.add(new ParameterInstance(parameter, this)); - } + setInitialWidth(); - // Instantiate inputs for this reactor instance - for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { - this.inputs.add(new PortInstance(inputDecl, this, reporter)); - } + // Apply overrides and instantiate parameters for this reactor instance. + for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { + this.parameters.add(new ParameterInstance(parameter, this)); + } - // Instantiate outputs for this reactor instance - for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { - this.outputs.add(new PortInstance(outputDecl, this, reporter)); - } + // Instantiate inputs for this reactor instance + for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { + this.inputs.add(new PortInstance(inputDecl, this, reporter)); + } - // Do not process content (except interface above) if recursive - if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { - // Instantiate children for this reactor instance. - // While doing this, assign an index offset to each. - for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { - var childInstance = new ReactorInstance( - child, - this, - reporter, - desiredDepth - ); - this.children.add(childInstance); - } + // Instantiate outputs for this reactor instance + for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { + this.outputs.add(new PortInstance(outputDecl, this, reporter)); + } - // Instantiate timers for this reactor instance - for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { - this.timers.add(new TimerInstance(timerDecl, this)); - } + // Do not process content (except interface above) if recursive + if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { + // Instantiate children for this reactor instance. + // While doing this, assign an index offset to each. + for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { + var childInstance = new ReactorInstance(child, this, reporter, desiredDepth); + this.children.add(childInstance); + } - // Instantiate actions for this reactor instance - for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { - this.actions.add(new ActionInstance(actionDecl, this)); - } + // Instantiate timers for this reactor instance + for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { + this.timers.add(new TimerInstance(timerDecl, this)); + } - establishPortConnections(); + // Instantiate actions for this reactor instance + for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { + this.actions.add(new ActionInstance(actionDecl, this)); + } - // Create the reaction instances in this reactor instance. - // This also establishes all the implied dependencies. - // Note that this can only happen _after_ the children, - // port, action, and timer instances have been created. - createReactionInstances(); + establishPortConnections(); - // Instantiate modes for this reactor instance - // This must come after the child elements (reactions, etc) of this reactor - // are created in order to allow their association with modes - for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { - this.modes.add(new ModeInstance(modeDecl, this)); - } - for (ModeInstance mode : this.modes) { - mode.setupTranstions(); - } - } + // Create the reaction instances in this reactor instance. + // This also establishes all the implied dependencies. + // Note that this can only happen _after_ the children, + // port, action, and timer instances have been created. + createReactionInstances(); + + // Instantiate modes for this reactor instance + // This must come after the child elements (reactions, etc) of this reactor + // are created in order to allow their association with modes + for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { + this.modes.add(new ModeInstance(modeDecl, this)); + } + for (ModeInstance mode : this.modes) { + mode.setupTranstions(); + } } + } - /** - * Return a list of Instantiation objects for evaluating parameter - * values. The first object in the list is the AST Instantiation - * that created this reactor instance, the second is the AST instantiation - * that created the containing reactor instance, and so on until there - * are no more containing reactor instances. This will return an empty - * list if this reactor instance is at the top level (is main). - */ - public List instantiations() { - if (_instantiations == null) { - _instantiations = new ArrayList<>(); - if (definition != null) { - _instantiations.add(definition); - if (parent != null) { - _instantiations.addAll(parent.instantiations()); - } - } + /** + * Return a list of Instantiation objects for evaluating parameter values. The first object in the + * list is the AST Instantiation that created this reactor instance, the second is the AST + * instantiation that created the containing reactor instance, and so on until there are no more + * containing reactor instances. This will return an empty list if this reactor instance is at the + * top level (is main). + */ + public List instantiations() { + if (_instantiations == null) { + _instantiations = new ArrayList<>(); + if (definition != null) { + _instantiations.add(definition); + if (parent != null) { + _instantiations.addAll(parent.instantiations()); } - return _instantiations; + } } + return _instantiations; + } - /** - * Returns true if this is a bank of reactors. - * @return true if a reactor is a bank, false otherwise - */ - public boolean isBank() { - return definition.getWidthSpec() != null; - } + /** + * Returns true if this is a bank of reactors. + * + * @return true if a reactor is a bank, false otherwise + */ + public boolean isBank() { + return definition.getWidthSpec() != null; + } - /** - * Returns whether this is a main or federated reactor. - * @return true if reactor definition is marked as main or federated, false otherwise. - */ - public boolean isMainOrFederated() { - return reactorDefinition != null - && (reactorDefinition.isMain() || reactorDefinition.isFederated()); - } + /** + * Returns whether this is a main or federated reactor. + * + * @return true if reactor definition is marked as main or federated, false otherwise. + */ + public boolean isMainOrFederated() { + return reactorDefinition != null + && (reactorDefinition.isMain() || reactorDefinition.isFederated()); + } - /** - * Return true if the specified reactor instance is either equal to this - * reactor instance or a parent of it. - * @param r The reactor instance. - */ - public boolean isParent(ReactorInstance r) { - ReactorInstance p = this; - while (p != null) { - if (p == r) return true; - p = p.getParent(); - } - return false; + /** + * Return true if the specified reactor instance is either equal to this reactor instance or a + * parent of it. + * + * @param r The reactor instance. + */ + public boolean isParent(ReactorInstance r) { + ReactorInstance p = this; + while (p != null) { + if (p == r) return true; + p = p.getParent(); } + return false; + } - /////////////////////////////////////////////////// - //// Methods for finding instances in this reactor given an AST node. - - /** - * Return the action instance within this reactor - * instance corresponding to the specified action reference. - * @param action The action as an AST node. - * @return The corresponding action instance or null if the - * action does not belong to this reactor. - */ - public ActionInstance lookupActionInstance(Action action) { - for (ActionInstance actionInstance : actions) { - if (actionInstance.definition == action) { - return actionInstance; - } - } - return null; + /////////////////////////////////////////////////// + //// Methods for finding instances in this reactor given an AST node. + + /** + * Return the action instance within this reactor instance corresponding to the specified action + * reference. + * + * @param action The action as an AST node. + * @return The corresponding action instance or null if the action does not belong to this + * reactor. + */ + public ActionInstance lookupActionInstance(Action action) { + for (ActionInstance actionInstance : actions) { + if (actionInstance.definition == action) { + return actionInstance; + } } + return null; + } ////////////////////////////////////////////////////// //// Private methods. @@ -903,100 +896,100 @@ public static void connectPortInstances( dst.instance.dependsOnPorts.add(src); } - ////////////////////////////////////////////////////// - //// Protected methods. + ////////////////////////////////////////////////////// + //// Protected methods. - /** - * Returns the built-in trigger or create a new one if none exists. - */ - protected TriggerInstance getOrCreateBuiltinTrigger(BuiltinTriggerRef trigger) { - return builtinTriggers.computeIfAbsent(trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); - } + /** Returns the built-in trigger or create a new one if none exists. */ + protected TriggerInstance getOrCreateBuiltinTrigger( + BuiltinTriggerRef trigger) { + return builtinTriggers.computeIfAbsent( + trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); + } - /** - * Populate connectivity information in the port instances. - * Note that this can only happen _after_ the children and port instances have been created. - * Unfortunately, we have to do some complicated things here - * to support multiport-to-multiport, multiport-to-bank, - * and bank-to-multiport communication. The principle being followed is: - * in each connection statement, for each port instance on the left, - * connect to the next available port on the right. - */ - private void establishPortConnections() { - for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { - List> leftPorts = listPortInstances(connection.getLeftPorts(), connection); - Iterator> srcRanges = leftPorts.iterator(); - List> rightPorts = listPortInstances(connection.getRightPorts(), connection); - Iterator> dstRanges = rightPorts.iterator(); - - // Check for empty lists. - if (!srcRanges.hasNext()) { - if (dstRanges.hasNext()) { - reporter.reportWarning(connection, "No sources to provide inputs."); - } - return; - } else if (!dstRanges.hasNext()) { - reporter.reportWarning(connection, "No destination. Outputs will be lost."); - return; - } + /** + * Populate connectivity information in the port instances. Note that this can only happen _after_ + * the children and port instances have been created. Unfortunately, we have to do some + * complicated things here to support multiport-to-multiport, multiport-to-bank, and + * bank-to-multiport communication. The principle being followed is: in each connection statement, + * for each port instance on the left, connect to the next available port on the right. + */ + private void establishPortConnections() { + for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { + List> leftPorts = + listPortInstances(connection.getLeftPorts(), connection); + Iterator> srcRanges = leftPorts.iterator(); + List> rightPorts = + listPortInstances(connection.getRightPorts(), connection); + Iterator> dstRanges = rightPorts.iterator(); + + // Check for empty lists. + if (!srcRanges.hasNext()) { + if (dstRanges.hasNext()) { + reporter.reportWarning(connection, "No sources to provide inputs."); + } + return; + } else if (!dstRanges.hasNext()) { + reporter.reportWarning(connection, "No destination. Outputs will be lost."); + return; + } - RuntimeRange src = srcRanges.next(); - RuntimeRange dst = dstRanges.next(); - - while(true) { - if (dst.width == src.width) { - connectPortInstances(src, dst, connection); - if (!dstRanges.hasNext()) { - if (srcRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Source is wider than the destination. Outputs will be lost."); - } - break; - } - if (!srcRanges.hasNext()) { - if (connection.isIterated()) { - srcRanges = leftPorts.iterator(); - } else { - if (dstRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Destination is wider than the source. Inputs will be missing."); - } - break; - } - } - dst = dstRanges.next(); - src = srcRanges.next(); - } else if (dst.width < src.width) { - // Split the left (src) range in two. - connectPortInstances(src.head(dst.width), dst, connection); - src = src.tail(dst.width); - if (!dstRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Source is wider than the destination. Outputs will be lost."); - break; - } - dst = dstRanges.next(); - } else if (src.width < dst.width) { - // Split the right (dst) range in two. - connectPortInstances(src, dst.head(src.width), connection); - dst = dst.tail(src.width); - if (!srcRanges.hasNext()) { - if (connection.isIterated()) { - srcRanges = leftPorts.iterator(); - } else { - reporter.reportWarning(connection, - "Destination is wider than the source. Inputs will be missing."); - break; - } - } - src = srcRanges.next(); - } + RuntimeRange src = srcRanges.next(); + RuntimeRange dst = dstRanges.next(); + + while (true) { + if (dst.width == src.width) { + connectPortInstances(src, dst, connection); + if (!dstRanges.hasNext()) { + if (srcRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Source is wider than the destination. Outputs will be lost."); + } + break; + } + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + if (dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Destination is wider than the source. Inputs will be missing."); + } + break; + } + } + dst = dstRanges.next(); + src = srcRanges.next(); + } else if (dst.width < src.width) { + // Split the left (src) range in two. + connectPortInstances(src.head(dst.width), dst, connection); + src = src.tail(dst.width); + if (!dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Source is wider than the destination. Outputs will be lost."); + break; + } + dst = dstRanges.next(); + } else if (src.width < dst.width) { + // Split the right (dst) range in two. + connectPortInstances(src, dst.head(src.width), connection); + dst = dst.tail(src.width); + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + reporter.reportWarning( + connection, "Destination is wider than the source. Inputs will be missing."); + break; } + } + src = srcRanges.next(); } + } } + } /** * If path exists from the specified port to any reaction in the specified set of reactions, then @@ -1044,93 +1037,91 @@ private boolean findPaths( */ private List> listPortInstances( List references, Connection connection) { - List> result = new ArrayList<>(); - List> tails = new LinkedList<>(); - int count = 0; - for (VarRef portRef : references) { - // Simple error checking first. - if (!(portRef.getVariable() instanceof Port)) { - reporter.reportError(portRef, "Not a port."); - return result; - } - // First, figure out which reactor we are dealing with. - // The reactor we want is the container of the port. - // If the port reference has no container, then the reactor is this one. - var reactor = this; - if (portRef.getContainer() != null) { - reactor = getChildReactorInstance(portRef.getContainer()); - } - // The reactor can be null only if there is an error in the code. - // Skip this portRef so that diagram synthesis can complete. - if (reactor != null) { - PortInstance portInstance = reactor.lookupPortInstance( - (Port) portRef.getVariable()); - - Set interleaved = new LinkedHashSet<>(); - if (portRef.isInterleaved()) { - // NOTE: Here, we are assuming that the interleaved() - // keyword is only allowed on the multiports contained by - // contained reactors. - interleaved.add(portInstance.parent); - } - RuntimeRange range = new RuntimeRange.Port( - portInstance, interleaved); - // If this portRef is not the last one in the references list - // then we have to check whether the range can be incremented at - // the lowest two levels (port and container). If not, - // split the range and add the tail to list to iterate over again. - // The reason for this is that the connection has only local visibility, - // but the range width may be reflective of bank structure higher - // in the hierarchy. - if (count < references.size() - 1) { - int portWidth = portInstance.width; - int portParentWidth = portInstance.parent.width; - // If the port is being connected on the inside and there is - // more than one port in the list, then we can only connect one - // bank member at a time. - if (reactor == this && references.size() > 1) { - portParentWidth = 1; - } - int widthBound = portWidth * portParentWidth; - - // If either of these widths cannot be determined, assume infinite. - if (portWidth < 0) widthBound = Integer.MAX_VALUE; - if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; - - if (widthBound < range.width) { - // Need to split the range. - tails.add(range.tail(widthBound)); - range = range.head(widthBound); - } - } - result.add(range); - } + List> result = new ArrayList<>(); + List> tails = new LinkedList<>(); + int count = 0; + for (VarRef portRef : references) { + // Simple error checking first. + if (!(portRef.getVariable() instanceof Port)) { + reporter.reportError(portRef, "Not a port."); + return result; + } + // First, figure out which reactor we are dealing with. + // The reactor we want is the container of the port. + // If the port reference has no container, then the reactor is this one. + var reactor = this; + if (portRef.getContainer() != null) { + reactor = getChildReactorInstance(portRef.getContainer()); + } + // The reactor can be null only if there is an error in the code. + // Skip this portRef so that diagram synthesis can complete. + if (reactor != null) { + PortInstance portInstance = reactor.lookupPortInstance((Port) portRef.getVariable()); + + Set interleaved = new LinkedHashSet<>(); + if (portRef.isInterleaved()) { + // NOTE: Here, we are assuming that the interleaved() + // keyword is only allowed on the multiports contained by + // contained reactors. + interleaved.add(portInstance.parent); } - // Iterate over the tails. - while(tails.size() > 0) { - List> moreTails = new LinkedList<>(); - count = 0; - for (RuntimeRange tail : tails) { - if (count < tails.size() - 1) { - int widthBound = tail.instance.width; - if (tail._interleaved.contains(tail.instance.parent)) { - widthBound = tail.instance.parent.width; - } - // If the width cannot be determined, assume infinite. - if (widthBound < 0) widthBound = Integer.MAX_VALUE; - - if (widthBound < tail.width) { - // Need to split the range again - moreTails.add(tail.tail(widthBound)); - tail = tail.head(widthBound); - } - } - result.add(tail); - } - tails = moreTails; + RuntimeRange range = new RuntimeRange.Port(portInstance, interleaved); + // If this portRef is not the last one in the references list + // then we have to check whether the range can be incremented at + // the lowest two levels (port and container). If not, + // split the range and add the tail to list to iterate over again. + // The reason for this is that the connection has only local visibility, + // but the range width may be reflective of bank structure higher + // in the hierarchy. + if (count < references.size() - 1) { + int portWidth = portInstance.width; + int portParentWidth = portInstance.parent.width; + // If the port is being connected on the inside and there is + // more than one port in the list, then we can only connect one + // bank member at a time. + if (reactor == this && references.size() > 1) { + portParentWidth = 1; + } + int widthBound = portWidth * portParentWidth; + + // If either of these widths cannot be determined, assume infinite. + if (portWidth < 0) widthBound = Integer.MAX_VALUE; + if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < range.width) { + // Need to split the range. + tails.add(range.tail(widthBound)); + range = range.head(widthBound); + } } - return result; + result.add(range); + } + } + // Iterate over the tails. + while (tails.size() > 0) { + List> moreTails = new LinkedList<>(); + count = 0; + for (RuntimeRange tail : tails) { + if (count < tails.size() - 1) { + int widthBound = tail.instance.width; + if (tail._interleaved.contains(tail.instance.parent)) { + widthBound = tail.instance.parent.width; + } + // If the width cannot be determined, assume infinite. + if (widthBound < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < tail.width) { + // Need to split the range again + moreTails.add(tail.tail(widthBound)); + tail = tail.head(widthBound); + } + } + result.add(tail); + } + tails = moreTails; } + return result; + } /** * If this is a bank of reactors, set the width. It will be set to -1 if it cannot be determined. diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index e344e9f873..b26b3061c0 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1,22 +1,22 @@ /************* -Copyright (c) 2019-2021, The University of California at Berkeley. -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. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2021, The University of California at Berkeley. + * 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. + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator.c; @@ -31,6 +31,8 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import static org.lflang.ASTUtils.toText; import static org.lflang.util.StringUtil.addDoubleQuotes; +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; import java.io.File; import java.io.IOException; import java.nio.file.Files; @@ -41,33 +43,26 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.StringExtensions; - import org.lflang.ASTUtils; -import org.lflang.generator.DockerComposeGenerator; import org.lflang.FileConfig; import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty; import org.lflang.TargetProperty.Platform; - -import org.lflang.federated.extensions.CExtensionUtils; - import org.lflang.ast.DelayedConnectionTransformation; - +import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.ActionInstance; import org.lflang.generator.CodeBuilder; +import org.lflang.generator.DelayBodyGenerator; +import org.lflang.generator.DockerComposeGenerator; import org.lflang.generator.DockerGenerator; import org.lflang.generator.GeneratorBase; import org.lflang.generator.GeneratorResult; import org.lflang.generator.GeneratorUtils; - -import org.lflang.generator.DelayBodyGenerator; - import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFResource; import org.lflang.generator.ParameterInstance; @@ -78,7 +73,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.generator.TimerInstance; import org.lflang.generator.TriggerInstance; import org.lflang.generator.WatchdogInstance; - import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; import org.lflang.lf.Input; @@ -93,206 +87,171 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.StateVar; import org.lflang.lf.Variable; import org.lflang.lf.Watchdog; - import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; -import com.google.common.base.Objects; -import com.google.common.collect.Iterables; - /** - * Generator for C target. This class generates C code defining each reactor - * class given in the input .lf file and imported .lf files. The generated code - * has the following components: + * Generator for C target. This class generates C code defining each reactor class given in the + * input .lf file and imported .lf files. The generated code has the following components: * - * * A typedef for inputs, outputs, and actions of each reactor class. These - * define the types of the variables that reactions use to access inputs and - * action values and to set output values. + *

* A typedef for inputs, outputs, and actions of each reactor class. These define the types of + * the variables that reactions use to access inputs and action values and to set output values. * - * * A typedef for a "self" struct for each reactor class. One instance of this - * struct will be created for each reactor instance. See below for details. + *

* A typedef for a "self" struct for each reactor class. One instance of this struct will be + * created for each reactor instance. See below for details. * - * * A function definition for each reaction in each reactor class. These - * functions take an instance of the self struct as an argument. + *

* A function definition for each reaction in each reactor class. These functions take an + * instance of the self struct as an argument. * - * * A constructor function for each reactor class. This is used to create - * a new instance of the reactor. + *

* A constructor function for each reactor class. This is used to create a new instance of the + * reactor. * - * After these, the main generated function is `_lf_initialize_trigger_objects()`. - * This function creates the instances of reactors (using their constructors) - * and makes connections between them. + *

After these, the main generated function is `_lf_initialize_trigger_objects()`. This function + * creates the instances of reactors (using their constructors) and makes connections between them. * - * A few other smaller functions are also generated. + *

A few other smaller functions are also generated. * - * ## Self Struct + *

## Self Struct * - * The "self" struct has fields for each of the following: + *

The "self" struct has fields for each of the following: * - * * parameter: the field name and type match the parameter. - * * state: the field name and type match the state. - * * action: the field name prepends the action name with "_lf_". - * A second field for the action is also created to house the trigger_t object. - * That second field prepends the action name with "_lf__". - * * output: the field name prepends the output name with "_lf_". - * * input: the field name prepends the output name with "_lf_". - * A second field for the input is also created to house the trigger_t object. - * That second field prepends the input name with "_lf__". + *

* parameter: the field name and type match the parameter. * state: the field name and type + * match the state. * action: the field name prepends the action name with "_lf_". A second field + * for the action is also created to house the trigger_t object. That second field prepends the + * action name with "_lf__". * output: the field name prepends the output name with "_lf_". * input: + * the field name prepends the output name with "_lf_". A second field for the input is also created + * to house the trigger_t object. That second field prepends the input name with "_lf__". * - * If, in addition, the reactor contains other reactors and reacts to their outputs, - * then there will be a struct within the self struct for each such contained reactor. - * The name of that self struct will be the name of the contained reactor prepended with "_lf_". - * That inside struct will contain pointers the outputs of the contained reactors - * that are read together with pointers to booleans indicating whether those outputs are present. + *

If, in addition, the reactor contains other reactors and reacts to their outputs, then there + * will be a struct within the self struct for each such contained reactor. The name of that self + * struct will be the name of the contained reactor prepended with "_lf_". That inside struct will + * contain pointers the outputs of the contained reactors that are read together with pointers to + * booleans indicating whether those outputs are present. * - * If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to - * trigger_t object (see reactor.h) for the shutdown event and an action struct named - * _lf_shutdown on the self struct. + *

If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to + * trigger_t object (see reactor.h) for the shutdown event and an action struct named _lf_shutdown + * on the self struct. * - * ## Reaction Functions + *

## Reaction Functions * - * For each reaction in a reactor class, this generator will produce a C function - * that expects a pointer to an instance of the "self" struct as an argument. - * This function will contain verbatim the C code specified in the reaction, but - * before that C code, the generator inserts a few lines of code that extract from the - * self struct the variables that that code has declared it will use. For example, if - * the reaction declares that it is triggered by or uses an input named "x" of type - * int, the function will contain a line like this: - * ``` - * r_x_t* x = self->_lf_x; - * ``` - * where `r` is the full name of the reactor class and the struct type `r_x_t` - * has fields `is_present` and `value`, where the type of `value` matches the port type. - * If the programmer fails to declare that it uses x, then the absence of the - * above code will trigger a compile error when the verbatim code attempts to read `x`. + *

For each reaction in a reactor class, this generator will produce a C function that expects a + * pointer to an instance of the "self" struct as an argument. This function will contain verbatim + * the C code specified in the reaction, but before that C code, the generator inserts a few lines + * of code that extract from the self struct the variables that that code has declared it will use. + * For example, if the reaction declares that it is triggered by or uses an input named "x" of type + * int, the function will contain a line like this: ``` r_x_t* x = self->_lf_x; ``` where `r` is the + * full name of the reactor class and the struct type `r_x_t` has fields `is_present` and `value`, + * where the type of `value` matches the port type. If the programmer fails to declare that it uses + * x, then the absence of the above code will trigger a compile error when the verbatim code + * attempts to read `x`. * - * ## Constructor + *

## Constructor * - * For each reactor class, this generator will create a constructor function named - * `new_r`, where `r` is the reactor class name. This function will malloc and return - * a pointer to an instance of the "self" struct. This struct initially represents - * an unconnected reactor. To establish connections between reactors, additional - * information needs to be inserted (see below). The self struct is made visible - * to the body of a reaction as a variable named "self". The self struct contains the - * following: + *

For each reactor class, this generator will create a constructor function named `new_r`, where + * `r` is the reactor class name. This function will malloc and return a pointer to an instance of + * the "self" struct. This struct initially represents an unconnected reactor. To establish + * connections between reactors, additional information needs to be inserted (see below). The self + * struct is made visible to the body of a reaction as a variable named "self". The self struct + * contains the following: * - * * Parameters: For each parameter `p` of the reactor, there will be a field `p` - * with the type and value of the parameter. So C code in the body of a reaction - * can access parameter values as `self->p`. + *

* Parameters: For each parameter `p` of the reactor, there will be a field `p` with the type + * and value of the parameter. So C code in the body of a reaction can access parameter values as + * `self->p`. * - * * State variables: For each state variable `s` of the reactor, there will be a field `s` - * with the type and value of the state variable. So C code in the body of a reaction - * can access state variables as `self->s`. + *

* State variables: For each state variable `s` of the reactor, there will be a field `s` with + * the type and value of the state variable. So C code in the body of a reaction can access state + * variables as `self->s`. * - * The self struct also contains various fields that the user is not intended to - * use. The names of these fields begin with at least two underscores. They are: + *

The self struct also contains various fields that the user is not intended to use. The names + * of these fields begin with at least two underscores. They are: * - * * Outputs: For each output named `out`, there will be a field `_lf_out` that is - * a struct containing a value field whose type matches that of the output. - * The output value is stored here. That struct also has a field `is_present` - * that is a boolean indicating whether the output has been set. - * This field is reset to false at the start of every time - * step. There is also a field `num_destinations` whose value matches the - * number of downstream reactors that use this variable. This field must be - * set when connections are made or changed. It is used to determine for - * a mutable input destination whether a copy needs to be made. + *

* Outputs: For each output named `out`, there will be a field `_lf_out` that is a struct + * containing a value field whose type matches that of the output. The output value is stored here. + * That struct also has a field `is_present` that is a boolean indicating whether the output has + * been set. This field is reset to false at the start of every time step. There is also a field + * `num_destinations` whose value matches the number of downstream reactors that use this variable. + * This field must be set when connections are made or changed. It is used to determine for a + * mutable input destination whether a copy needs to be made. * - * * Inputs: For each input named `in` of type T, there is a field named `_lf_in` - * that is a pointer struct with a value field of type T. The struct pointed - * to also has an `is_present` field of type bool that indicates whether the - * input is present. + *

* Inputs: For each input named `in` of type T, there is a field named `_lf_in` that is a + * pointer struct with a value field of type T. The struct pointed to also has an `is_present` field + * of type bool that indicates whether the input is present. * - * * Outputs of contained reactors: If a reactor reacts to outputs of a - * contained reactor `r`, then the self struct will contain a nested struct - * named `_lf_r` that has fields pointing to those outputs. For example, - * if `r` has an output `out` of type T, then there will be field in `_lf_r` - * named `out` that points to a struct containing a value field - * of type T and a field named `is_present` of type bool. + *

* Outputs of contained reactors: If a reactor reacts to outputs of a contained reactor `r`, + * then the self struct will contain a nested struct named `_lf_r` that has fields pointing to those + * outputs. For example, if `r` has an output `out` of type T, then there will be field in `_lf_r` + * named `out` that points to a struct containing a value field of type T and a field named + * `is_present` of type bool. * - * * Inputs of contained reactors: If a reactor sends to inputs of a - * contained reactor `r`, then the self struct will contain a nested struct - * named `_lf_r` that has fields for storing the values provided to those - * inputs. For example, if R has an input `in` of type T, then there will - * be field in _lf_R named `in` that is a struct with a value field - * of type T and a field named `is_present` of type bool. + *

* Inputs of contained reactors: If a reactor sends to inputs of a contained reactor `r`, then + * the self struct will contain a nested struct named `_lf_r` that has fields for storing the values + * provided to those inputs. For example, if R has an input `in` of type T, then there will be field + * in _lf_R named `in` that is a struct with a value field of type T and a field named `is_present` + * of type bool. * - * * Actions: If the reactor has an action a (logical or physical), then there - * will be a field in the self struct named `_lf_a` and another named `_lf__a`. - * The type of the first is specific to the action and contains a `value` - * field with the type and value of the action (if it has a value). That - * struct also has a `has_value` field, an `is_present` field, and a - * `token` field (which is NULL if the action carries no value). - * The `_lf__a` field is of type trigger_t. - * That struct contains various things, including an array of reactions - * sensitive to this trigger and a lf_token_t struct containing the value of - * the action, if it has a value. See reactor.h in the C library for - * details. + *

* Actions: If the reactor has an action a (logical or physical), then there will be a field in + * the self struct named `_lf_a` and another named `_lf__a`. The type of the first is specific to + * the action and contains a `value` field with the type and value of the action (if it has a + * value). That struct also has a `has_value` field, an `is_present` field, and a `token` field + * (which is NULL if the action carries no value). The `_lf__a` field is of type trigger_t. That + * struct contains various things, including an array of reactions sensitive to this trigger and a + * lf_token_t struct containing the value of the action, if it has a value. See reactor.h in the C + * library for details. * - * * Reactions: Each reaction will have several fields in the self struct. - * Each of these has a name that begins with `_lf__reaction_i`, where i is - * the number of the reaction, starting with 0. The fields are: - * * _lf__reaction_i: The struct that is put onto the reaction queue to - * execute the reaction (see reactor.h in the C library). + *

* Reactions: Each reaction will have several fields in the self struct. Each of these has a + * name that begins with `_lf__reaction_i`, where i is the number of the reaction, starting with 0. + * The fields are: * _lf__reaction_i: The struct that is put onto the reaction queue to execute the + * reaction (see reactor.h in the C library). * - * * Timers: For each timer t, there is are two fields in the self struct: - * * _lf__t: The trigger_t struct for this timer (see reactor.h). - * * _lf__t_reactions: An array of reactions (pointers to the - * reaction_t structs on this self struct) sensitive to this timer. + *

* Timers: For each timer t, there is are two fields in the self struct: * _lf__t: The + * trigger_t struct for this timer (see reactor.h). * _lf__t_reactions: An array of reactions + * (pointers to the reaction_t structs on this self struct) sensitive to this timer. * - * * Triggers: For each Timer, Action, Input, and Output of a contained - * reactor that triggers reactions, there will be a trigger_t struct - * on the self struct with name `_lf__t`, where t is the name of the trigger. + *

* Triggers: For each Timer, Action, Input, and Output of a contained reactor that triggers + * reactions, there will be a trigger_t struct on the self struct with name `_lf__t`, where t is the + * name of the trigger. * - * ## Connections Between Reactors + *

## Connections Between Reactors * - * Establishing connections between reactors involves two steps. - * First, each destination (e.g. an input port) must have pointers to - * the source (the output port). As explained above, for an input named - * `in`, the field `_lf_in->value` is a pointer to the output data being read. - * In addition, `_lf_in->is_present` is a pointer to the corresponding - * `out->is_present` field of the output reactor's self struct. + *

Establishing connections between reactors involves two steps. First, each destination (e.g. an + * input port) must have pointers to the source (the output port). As explained above, for an input + * named `in`, the field `_lf_in->value` is a pointer to the output data being read. In addition, + * `_lf_in->is_present` is a pointer to the corresponding `out->is_present` field of the output + * reactor's self struct. * - * In addition, the `reaction_i` struct on the self struct has a `triggers` - * field that records all the trigger_t structs for ports and actions - * that are triggered by the i-th reaction. The triggers field is - * an array of arrays of pointers to trigger_t structs. - * The length of the outer array is the number of output channels - * (single ports plus multiport widths) that the reaction effects - * plus the number of input port channels of contained - * reactors that it effects. Each inner array has a length equal to the - * number of final destinations of that output channel or input channel. - * The reaction_i struct has an array triggered_sizes that indicates - * the sizes of these inner arrays. The num_outputs field of the - * reaction_i struct gives the length of the triggered_sizes and - * (outer) triggers arrays. The num_outputs field is equal to the - * total number of single ports and multiport channels that the reaction - * writes to. + *

In addition, the `reaction_i` struct on the self struct has a `triggers` field that records + * all the trigger_t structs for ports and actions that are triggered by the i-th reaction. The + * triggers field is an array of arrays of pointers to trigger_t structs. The length of the outer + * array is the number of output channels (single ports plus multiport widths) that the reaction + * effects plus the number of input port channels of contained reactors that it effects. Each inner + * array has a length equal to the number of final destinations of that output channel or input + * channel. The reaction_i struct has an array triggered_sizes that indicates the sizes of these + * inner arrays. The num_outputs field of the reaction_i struct gives the length of the + * triggered_sizes and (outer) triggers arrays. The num_outputs field is equal to the total number + * of single ports and multiport channels that the reaction writes to. * - * ## Runtime Tables + *

## Runtime Tables * - * This generator creates an populates the following tables used at run time. - * These tables may have to be resized and adjusted when mutations occur. + *

This generator creates an populates the following tables used at run time. These tables may + * have to be resized and adjusted when mutations occur. * - * * _lf_is_present_fields: An array of pointers to booleans indicating whether an - * event is present. The _lf_start_time_step() function in reactor_common.c uses - * this to mark every event absent at the start of a time step. The size of this - * table is contained in the variable _lf_is_present_fields_size. - * * This table is accompanied by another list, _lf_is_present_fields_abbreviated, - * which only contains the is_present fields that have been set to true in the - * current tag. This list can allow a performance improvement if most ports are - * seldom present because only fields that have been set to true need to be - * reset to false. + *

* _lf_is_present_fields: An array of pointers to booleans indicating whether an event is + * present. The _lf_start_time_step() function in reactor_common.c uses this to mark every event + * absent at the start of a time step. The size of this table is contained in the variable + * _lf_is_present_fields_size. * This table is accompanied by another list, + * _lf_is_present_fields_abbreviated, which only contains the is_present fields that have been set + * to true in the current tag. This list can allow a performance improvement if most ports are + * seldom present because only fields that have been set to true need to be reset to false. * - * * _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown - * reactions. The length of this table is in the _lf_shutdown_triggers_size - * variable. + *

* _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown reactions. The + * length of this table is in the _lf_shutdown_triggers_size variable. * - * * _lf_timer_triggers: An array of pointers to trigger_t structs for timers that - * need to be started when the program runs. The length of this table is in the - * _lf_timer_triggers_size variable. + *

* _lf_timer_triggers: An array of pointers to trigger_t structs for timers that need to be + * started when the program runs. The length of this table is in the _lf_timer_triggers_size + * variable. * - * * _lf_action_table: For a federated execution, each federate will have this table - * that maps port IDs to the corresponding action struct, which can be cast to - * action_base_t. + *

* _lf_action_table: For a federated execution, each federate will have this table that maps + * port IDs to the corresponding action struct, which can be cast to action_base_t. * * @author Edward A. Lee * @author Marten Lohstroh @@ -306,1150 +265,1133 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY */ @SuppressWarnings("StaticPseudoFunctionalStyleMethod") public class CGenerator extends GeneratorBase { - // Regular expression pattern for compiler error messages with resource - // and line number information. The first match will a resource URI in the - // form of "file:/path/file.lf". The second match will be a line number. - // The third match is a character position within the line. - // The fourth match will be the error message. - static final Pattern compileErrorPattern = Pattern.compile( - "^(?.*):(?\\d+):(?\\d+):(?.*)$" - ); - - public static int UNDEFINED_MIN_SPACING = -1; - - //////////////////////////////////////////// - //// Protected fields - - /** The main place to put generated code. */ - protected CodeBuilder code = new CodeBuilder(); - - /** Place to collect code to initialize the trigger objects for all reactor instances. */ - protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); - - protected final CFileConfig fileConfig; - - /** - * Count of the number of is_present fields of the self struct that - * need to be reinitialized in _lf_start_time_step(). - */ - protected int startTimeStepIsPresentCount = 0; - - //////////////////////////////////////////// - //// Private fields - /** - * Extra lines that need to go into the generated CMakeLists.txt. - */ - private String cMakeExtras = ""; - - /** Place to collect code to execute at the start of a time step. */ - private CodeBuilder startTimeStep = new CodeBuilder(); - - /** Count of the number of token pointers that need to have their - * reference count decremented in _lf_start_time_step(). - */ - private int timerCount = 0; - private int startupReactionCount = 0; - private int shutdownReactionCount = 0; - private int resetReactionCount = 0; - private int modalReactorCount = 0; - private int modalStateResetCount = 0; - private int watchdogCount = 0; - - // Indicate whether the generator is in Cpp mode or not - private final boolean CCppMode; - - private final CTypes types; - - private final CCmakeGenerator cmakeGenerator; - - protected CGenerator( - LFGeneratorContext context, - boolean CCppMode, - CTypes types, - CCmakeGenerator cmakeGenerator, - DelayBodyGenerator delayBodyGenerator - ) { - super(context); - this.fileConfig = (CFileConfig) context.getFileConfig(); - this.CCppMode = CCppMode; - this.types = types; - this.cmakeGenerator = cmakeGenerator; - - // Register the delayed connection transformation to be applied by GeneratorBase. - // transform both after delays and physical connections - registerTransformation(new DelayedConnectionTransformation(delayBodyGenerator, types, fileConfig.resource, true, true)); - } + // Regular expression pattern for compiler error messages with resource + // and line number information. The first match will a resource URI in the + // form of "file:/path/file.lf". The second match will be a line number. + // The third match is a character position within the line. + // The fourth match will be the error message. + static final Pattern compileErrorPattern = + Pattern.compile("^(?.*):(?\\d+):(?\\d+):(?.*)$"); - public CGenerator(LFGeneratorContext context, boolean ccppMode) { - this( - context, - ccppMode, - new CTypes(), - new CCmakeGenerator(context.getFileConfig(), List.of()), - new CDelayBodyGenerator(new CTypes()) - ); - } + public static int UNDEFINED_MIN_SPACING = -1; - /** - * Look for physical actions in all resources. - * If found, set threads to be at least one to allow asynchronous schedule calls. - */ - public void accommodatePhysicalActionsIfPresent() { - // If there are any physical actions, ensure the threaded engine is used and that - // keepalive is set to true, unless the user has explicitly set it to false. - for (Resource resource : GeneratorUtils.getResources(reactors)) { - for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { - if (Objects.equal(action.getOrigin(), ActionOrigin.PHYSICAL)) { - // If the unthreaded runtime is not requested by the user, use the threaded runtime instead - // because it is the only one currently capable of handling asynchronous events. - if (!targetConfig.threading && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = true; - errorReporter.reportWarning( - action, - "Using the threaded C runtime to allow for asynchronous handling of physical action " + - action.getName() - ); - return; - } - } - } - } - } + //////////////////////////////////////////// + //// Protected fields - /** - * Return true if the host operating system is compatible and - * otherwise report an error and return false. - */ - protected boolean isOSCompatible() { - if (GeneratorUtils.isHostWindows()) { - if (CCppMode) { - errorReporter.reportError( - "LF programs with a CCpp target are currently not supported on Windows. " + - "Exiting code generation." - ); - // FIXME: The incompatibility between our C runtime code and the - // Visual Studio compiler is extensive. - return false; - } - } - return true; - } + /** The main place to put generated code. */ + protected CodeBuilder code = new CodeBuilder(); - /** - * Generate C code from the Lingua Franca model contained by the - * specified resource. This is the main entry point for code - * generation. - * @param resource The resource containing the source code. - * @param context The context in which the generator is - * invoked, including whether it is cancelled and - * whether it is a standalone context - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - super.doGenerate(resource, context); - if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; - if (!isOSCompatible()) return; // Incompatible OS and configuration - - // Perform set up that does not generate code - setUpGeneralParameters(); - - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); - handleProtoFiles(); - - // Derive target filename from the .lf filename. - var lfModuleName = fileConfig.name; - var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); - var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; - try { - generateCodeFor(lfModuleName); - copyTargetFiles(); - generateHeaders(); - code.writeToFile(targetFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } + /** Place to collect code to initialize the trigger objects for all reactor instances. */ + protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); - // Create docker file. - if (targetConfig.dockerOptions != null && mainDef != null) { - try { - var dockerData = getDockerGenerator(context).generateDockerData(); - dockerData.writeDockerFile(); - (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); - } catch (IOException e) { - throw new RuntimeException("Error while writing Docker files", e); - } - } + protected final CFileConfig fileConfig; - // If cmake is requested, generate the CMakeLists.txt - if (targetConfig.platformOptions.platform != Platform.ARDUINO) { - var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; - var sources = new HashSet<>(ASTUtils.recursiveChildren(main)).stream() - .map(CUtil::getName).map(it -> it + (CCppMode ? ".cpp" : ".c")) - .collect(Collectors.toList()); - sources.add(cFilename); - var cmakeCode = cmakeGenerator.generateCMakeCode( - sources, - lfModuleName, - errorReporter, - CCppMode, - mainDef != null, - cMakeExtras, - targetConfig - ); - try { - cmakeCode.writeToFile(cmakeFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - } else { - try { - Path include = fileConfig.getSrcGenPath().resolve("include/"); - Path src = fileConfig.getSrcGenPath().resolve("src/"); - FileUtil.arduinoDeleteHelper(src, targetConfig.threading); - FileUtil.relativeIncludeHelper(src, include); - FileUtil.relativeIncludeHelper(include, include); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } + /** + * Count of the number of is_present fields of the self struct that need to be reinitialized in + * _lf_start_time_step(). + */ + protected int startTimeStepIsPresentCount = 0; - if (!targetConfig.noCompile) { - ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); - arduinoUtil.buildArduino(fileConfig, targetConfig); - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } else { - System.out.println("********"); - System.out.println("To compile your program, run the following command to see information about the board you plugged in:\n\n\tarduino-cli board list\n\nGrab the FQBN and PORT from the command and run the following command in the generated sources directory:\n\n\tarduino-cli compile -b --build-property compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\nTo flash/upload your generated sketch to the board, run the following command in the generated sources directory:\n\n\tarduino-cli upload -b -p \n"); - // System.out.println("For a list of all boards installed on your computer, you can use the following command:\n\n\tarduino-cli board listall\n"); - context.finish( - GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null) - ); - } - GeneratorUtils.refreshProject(resource, context.getMode()); - return; - } + //////////////////////////////////////////// + //// Private fields + /** Extra lines that need to go into the generated CMakeLists.txt. */ + private String cMakeExtras = ""; - // Dump the additional compile definitions to a file to keep the generated project - // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can - // take over and do the rest of compilation. - try { - String compileDefs = targetConfig.compileDefinitions.keySet().stream() - .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) - .collect(Collectors.joining("\n")); - FileUtil.writeToFile( - compileDefs, - Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt") - ); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + /** Place to collect code to execute at the start of a time step. */ + private CodeBuilder startTimeStep = new CodeBuilder(); - // If this code generator is directly compiling the code, compile it now so that we - // clean it up after, removing the #line directives after errors have been reported. - if ( - !targetConfig.noCompile && targetConfig.dockerOptions == null - && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) - // This code is unreachable in LSP_FAST mode, so that check is omitted. - && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM - ) { - // FIXME: Currently, a lack of main is treated as a request to not produce - // a binary and produce a .o file instead. There should be a way to control - // this. - // Create an anonymous Runnable class and add it to the compileThreadPool - // so that compilation can happen in parallel. - var cleanCode = code.removeLines("#line"); - - var execName = lfModuleName; - var threadFileConfig = fileConfig; - var generator = this; // FIXME: currently only passed to report errors with line numbers in the Eclipse IDE - var CppMode = CCppMode; - // generatingContext.reportProgress( - // String.format("Generated code for %d/%d executables. Compiling...", federateCount, federates.size()), - // 100 * federateCount / federates.size() - // ); // FIXME: Move to FedGenerator - // Create the compiler to be used later - - var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); - try { - if (!cCompiler.runCCompiler(generator, context)) { - // If compilation failed, remove any bin files that may have been created. - CUtil.deleteBinFiles(threadFileConfig); - // If finish has already been called, it is illegal and makes no sense. However, - // if finish has already been called, then this must be a federated execution. - context.unsuccessfulFinish(); - } else { - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } - cleanCode.writeToFile(targetFile); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + /** + * Count of the number of token pointers that need to have their reference count decremented in + * _lf_start_time_step(). + */ + private int timerCount = 0; + + private int startupReactionCount = 0; + private int shutdownReactionCount = 0; + private int resetReactionCount = 0; + private int modalReactorCount = 0; + private int modalStateResetCount = 0; + private int watchdogCount = 0; + + // Indicate whether the generator is in Cpp mode or not + private final boolean CCppMode; + + private final CTypes types; + + private final CCmakeGenerator cmakeGenerator; + + protected CGenerator( + LFGeneratorContext context, + boolean CCppMode, + CTypes types, + CCmakeGenerator cmakeGenerator, + DelayBodyGenerator delayBodyGenerator) { + super(context); + this.fileConfig = (CFileConfig) context.getFileConfig(); + this.CCppMode = CCppMode; + this.types = types; + this.cmakeGenerator = cmakeGenerator; + + // Register the delayed connection transformation to be applied by GeneratorBase. + // transform both after delays and physical connections + registerTransformation( + new DelayedConnectionTransformation( + delayBodyGenerator, types, fileConfig.resource, true, true)); + } - } + public CGenerator(LFGeneratorContext context, boolean ccppMode) { + this( + context, + ccppMode, + new CTypes(), + new CCmakeGenerator(context.getFileConfig(), List.of()), + new CDelayBodyGenerator(new CTypes())); + } - // If a build directive has been given, invoke it now. - // Note that the code does not get cleaned in this case. - if (!targetConfig.noCompile) { - if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { - CUtil.runBuildCommand( - fileConfig, - targetConfig, - commandFactory, - errorReporter, - this::reportCommandErrors, - context.getMode() - ); - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } - System.out.println("Compiled binary is in " + fileConfig.binPath); - } else { - context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + /** + * Look for physical actions in all resources. If found, set threads to be at least one to allow + * asynchronous schedule calls. + */ + public void accommodatePhysicalActionsIfPresent() { + // If there are any physical actions, ensure the threaded engine is used and that + // keepalive is set to true, unless the user has explicitly set it to false. + for (Resource resource : GeneratorUtils.getResources(reactors)) { + for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { + if (Objects.equal(action.getOrigin(), ActionOrigin.PHYSICAL)) { + // If the unthreaded runtime is not requested by the user, use the threaded runtime + // instead + // because it is the only one currently capable of handling asynchronous events. + if (!targetConfig.threading + && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = true; + errorReporter.reportWarning( + action, + "Using the threaded C runtime to allow for asynchronous handling of physical action" + + " " + + action.getName()); + return; + } } + } + } + } - // In case we are in Eclipse, make sure the generated code is visible. - GeneratorUtils.refreshProject(resource, context.getMode()); + /** + * Return true if the host operating system is compatible and otherwise report an error and return + * false. + */ + protected boolean isOSCompatible() { + if (GeneratorUtils.isHostWindows()) { + if (CCppMode) { + errorReporter.reportError( + "LF programs with a CCpp target are currently not supported on Windows. " + + "Exiting code generation."); + // FIXME: The incompatibility between our C runtime code and the + // Visual Studio compiler is extensive. + return false; + } } + return true; + } - private void generateCodeFor( - String lfModuleName - ) throws IOException { - startTimeStepIsPresentCount = 0; - code.pr(generateDirectives()); - code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); - // Generate code for each reactor. - generateReactorDefinitions(); - - // Generate main instance, if there is one. - // Note that any main reactors in imported files are ignored. - // Skip generation if there are cycles. - if (main != null) { - initializeTriggerObjects.pr(String.join("\n", - "int _lf_startup_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", - "int _lf_shutdown_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", - "int _lf_reset_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", - "int _lf_timer_triggers_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", - "int bank_index;", - "SUPPRESS_UNUSED_WARNING(bank_index);", - "int _lf_watchdog_number_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_watchdog_number_count);" - )); - // Add counters for modal initialization - initializeTriggerObjects.pr(CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); - - // Create an array of arrays to store all self structs. - // This is needed because connections cannot be established until - // all reactor instances have self structs because ports that - // receive data reference the self structs of the originating - // reactors, which are arbitarily far away in the program graph. - generateSelfStructs(main); - generateReactorInstance(main); - - if (targetConfig.fedSetupPreamble != null) { - if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); - code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); - if (targetLanguageIsCpp()) code.pr("}"); - } + /** + * Generate C code from the Lingua Franca model contained by the specified resource. This is the + * main entry point for code generation. + * + * @param resource The resource containing the source code. + * @param context The context in which the generator is invoked, including whether it is cancelled + * and whether it is a standalone context + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + super.doGenerate(resource, context); + if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; + if (!isOSCompatible()) return; // Incompatible OS and configuration - // If there are timers, create a table of timers to be initialized. - code.pr(CTimerGenerator.generateDeclarations(timerCount)); - - // If there are startup reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); - - // If there are shutdown reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); - - // If there are reset reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); - - // If there are watchdogs, create a table of triggers. - code.pr(CWatchdogGenerator.generateBuiltinTriggersTable(watchdogCount, "watchdog")); - - // If there are modes, create a table of mode state to be checked for transitions. - code.pr(CModesGenerator.generateModeStatesTable( - hasModalReactors, - modalReactorCount, - modalStateResetCount - )); - - // Generate function to initialize the trigger objects for all reactors. - code.pr(CTriggerObjectsGenerator.generateInitializeTriggerObjects( - main, - targetConfig, - initializeTriggerObjects, - startTimeStep, - types, - lfModuleName, - startTimeStepIsPresentCount - )); - - // Generate function to trigger startup reactions for all reactors. - code.pr(CReactionGenerator.generateLfTriggerStartupReactions(startupReactionCount, hasModalReactors)); - - // Generate function to schedule timers for all reactors. - code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); - - // Generate function to initialize mutexes for all reactors with watchdogs. - code.pr(CWatchdogGenerator.generateLfInitializeWatchdogMutexes(watchdogCount)); - - // Generate a function that will either do nothing - // (if there is only one federate or the coordination - // is set to decentralized) or, if there are - // downstream federates, will notify the RTI - // that the specified logical time is complete. - if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) code.pr("extern \"C\""); - code.pr(String.join("\n", - "void logical_tag_complete(tag_t tag_to_send) {", - CExtensionUtils.surroundWithIfFederatedCentralized( - " _lf_logical_tag_complete(tag_to_send);" - ), - "}" - )); - - // Generate function to schedule shutdown reactions if any - // reactors have reactions to shutdown. - code.pr(CReactionGenerator.generateLfTriggerShutdownReactions(shutdownReactionCount, hasModalReactors)); - - // Generate an empty termination function for non-federated - // execution. For federated execution, an implementation is - // provided in federate.c. That implementation will resign - // from the federation and close any open sockets. - code.pr(""" - #ifndef FEDERATED - void terminate_execution() {} - #endif""" - ); - - - // Generate functions for modes - code.pr(CModesGenerator.generateLfInitializeModes( - hasModalReactors - )); - code.pr(CModesGenerator.generateLfHandleModeChanges( - hasModalReactors, - modalStateResetCount - )); - code.pr(CReactionGenerator.generateLfModeTriggeredReactions( - startupReactionCount, - resetReactionCount, - hasModalReactors - )); - } + // Perform set up that does not generate code + setUpGeneralParameters(); + + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); + handleProtoFiles(); + + // Derive target filename from the .lf filename. + var lfModuleName = fileConfig.name; + var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); + var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; + try { + generateCodeFor(lfModuleName); + copyTargetFiles(); + generateHeaders(); + code.writeToFile(targetFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); } - @Override - public void checkModalReactorSupport(boolean __) { - // Modal reactors are currently only supported for non federated applications - super.checkModalReactorSupport(true); + // Create docker file. + if (targetConfig.dockerOptions != null && mainDef != null) { + try { + var dockerData = getDockerGenerator(context).generateDockerData(); + dockerData.writeDockerFile(); + (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); + } catch (IOException e) { + throw new RuntimeException("Error while writing Docker files", e); + } } - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - return String.join("\n", - "// Generated forwarding reaction for connections with the same destination", - "// but located in mutually exclusive modes.", - "lf_set("+dest+", "+source+"->value);" - ); + // If cmake is requested, generate the CMakeLists.txt + if (targetConfig.platformOptions.platform != Platform.ARDUINO) { + var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; + var sources = + new HashSet<>(ASTUtils.recursiveChildren(main)) + .stream() + .map(CUtil::getName) + .map(it -> it + (CCppMode ? ".cpp" : ".c")) + .collect(Collectors.toList()); + sources.add(cFilename); + var cmakeCode = + cmakeGenerator.generateCMakeCode( + sources, + lfModuleName, + errorReporter, + CCppMode, + mainDef != null, + cMakeExtras, + targetConfig); + try { + cmakeCode.writeToFile(cmakeFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + } else { + try { + Path include = fileConfig.getSrcGenPath().resolve("include/"); + Path src = fileConfig.getSrcGenPath().resolve("src/"); + FileUtil.arduinoDeleteHelper(src, targetConfig.threading); + FileUtil.relativeIncludeHelper(src, include); + FileUtil.relativeIncludeHelper(include, include); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + + if (!targetConfig.noCompile) { + ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); + arduinoUtil.buildArduino(fileConfig, targetConfig); + context.finish(GeneratorResult.Status.COMPILED, null); + } else { + System.out.println("********"); + System.out.println( + "To compile your program, run the following command to see information about the board" + + " you plugged in:\n\n" + + "\tarduino-cli board list\n\n" + + "Grab the FQBN and PORT from the command and run the following command in the" + + " generated sources directory:\n\n" + + "\tarduino-cli compile -b --build-property" + + " compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" + + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property" + + " compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" + + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\n" + + "To flash/upload your generated sketch to the board, run the following command in" + + " the generated sources directory:\n\n" + + "\tarduino-cli upload -b -p \n"); + // System.out.println("For a list of all boards installed on your computer, you can use the + // following command:\n\n\tarduino-cli board listall\n"); + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + } + GeneratorUtils.refreshProject(resource, context.getMode()); + return; } - /** Set the scheduler type in the target config as needed. */ - private void pickScheduler() { - // Don't use a scheduler that does not prioritize reactions based on deadlines - // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. - if (!targetConfig.schedulerType.prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - if (hasDeadlines(reactors)) { - if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { - targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; - } - } - } + // Dump the additional compile definitions to a file to keep the generated project + // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can + // take over and do the rest of compilation. + try { + String compileDefs = + targetConfig.compileDefinitions.keySet().stream() + .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) + .collect(Collectors.joining("\n")); + FileUtil.writeToFile( + compileDefs, + Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt")); + } catch (IOException e) { + Exceptions.sneakyThrow(e); } - private boolean hasDeadlines(List reactors) { - for (Reactor reactor : reactors) { - for (Reaction reaction : allReactions(reactor)) { - if (reaction.getDeadline() != null) { - return true; - } - } + // If this code generator is directly compiling the code, compile it now so that we + // clean it up after, removing the #line directives after errors have been reported. + if (!targetConfig.noCompile + && targetConfig.dockerOptions == null + && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) + // This code is unreachable in LSP_FAST mode, so that check is omitted. + && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM) { + // FIXME: Currently, a lack of main is treated as a request to not produce + // a binary and produce a .o file instead. There should be a way to control + // this. + // Create an anonymous Runnable class and add it to the compileThreadPool + // so that compilation can happen in parallel. + var cleanCode = code.removeLines("#line"); + + var execName = lfModuleName; + var threadFileConfig = fileConfig; + var generator = + this; // FIXME: currently only passed to report errors with line numbers in the Eclipse + // IDE + var CppMode = CCppMode; + // generatingContext.reportProgress( + // String.format("Generated code for %d/%d executables. Compiling...", federateCount, + // federates.size()), + // 100 * federateCount / federates.size() + // ); // FIXME: Move to FedGenerator + // Create the compiler to be used later + + var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); + try { + if (!cCompiler.runCCompiler(generator, context)) { + // If compilation failed, remove any bin files that may have been created. + CUtil.deleteBinFiles(threadFileConfig); + // If finish has already been called, it is illegal and makes no sense. However, + // if finish has already been called, then this must be a federated execution. + context.unsuccessfulFinish(); + } else { + context.finish(GeneratorResult.Status.COMPILED, null); } - return false; + cleanCode.writeToFile(targetFile); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } } - private boolean hasWatchdogs() { - for (Reactor reactor : reactors) { - List watchdogs = ASTUtils.allWatchdogs(reactor); - if (watchdogs != null && !watchdogs.isEmpty()) { - return true; - } + // If a build directive has been given, invoke it now. + // Note that the code does not get cleaned in this case. + if (!targetConfig.noCompile) { + if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { + CUtil.runBuildCommand( + fileConfig, + targetConfig, + commandFactory, + errorReporter, + this::reportCommandErrors, + context.getMode()); + context.finish(GeneratorResult.Status.COMPILED, null); } - return false; + System.out.println("Compiled binary is in " + fileConfig.binPath); + } else { + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + } + + // In case we are in Eclipse, make sure the generated code is visible. + GeneratorUtils.refreshProject(resource, context.getMode()); } - /** - * Look at the 'reactor' eResource. - * If it is an imported .lf file, incorporate it into the current - * program in the following manner: - * - Merge its target property with `targetConfig` - * - If there are any preambles, add them to the preambles of the reactor. - */ - private void inspectReactorEResource(ReactorDecl reactor) { - // If the reactor is imported, look at the - // target definition of the .lf file in which the reactor is imported from and - // append any cmake-include. - // Check if the reactor definition is imported - if (reactor.eResource() != mainDef.getReactorClass().eResource()) { - // Find the LFResource corresponding to this eResource - LFResource lfResource = null; - for (var resource : resources) { - if (resource.getEResource() == reactor.eResource()) { - lfResource = resource; - break; - } - } - // Copy the user files and cmake-includes to the src-gen path of the main .lf file - if (lfResource != null) { - copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); - } - } + private void generateCodeFor(String lfModuleName) throws IOException { + startTimeStepIsPresentCount = 0; + code.pr(generateDirectives()); + code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); + // Generate code for each reactor. + generateReactorDefinitions(); + + // Generate main instance, if there is one. + // Note that any main reactors in imported files are ignored. + // Skip generation if there are cycles. + if (main != null) { + initializeTriggerObjects.pr( + String.join( + "\n", + "int _lf_startup_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", + "int _lf_shutdown_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", + "int _lf_reset_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", + "int _lf_timer_triggers_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", + "int bank_index;", + "SUPPRESS_UNUSED_WARNING(bank_index);", + "int _lf_watchdog_number_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_watchdog_number_count);")); + // Add counters for modal initialization + initializeTriggerObjects.pr( + CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); + + // Create an array of arrays to store all self structs. + // This is needed because connections cannot be established until + // all reactor instances have self structs because ports that + // receive data reference the self structs of the originating + // reactors, which are arbitarily far away in the program graph. + generateSelfStructs(main); + generateReactorInstance(main); + + if (targetConfig.fedSetupPreamble != null) { + if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); + code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); + if (targetLanguageIsCpp()) code.pr("}"); + } + + // If there are timers, create a table of timers to be initialized. + code.pr(CTimerGenerator.generateDeclarations(timerCount)); + + // If there are startup reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); + + // If there are shutdown reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); + + // If there are reset reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); + + // If there are watchdogs, create a table of triggers. + code.pr(CWatchdogGenerator.generateBuiltinTriggersTable(watchdogCount, "watchdog")); + + // If there are modes, create a table of mode state to be checked for transitions. + code.pr( + CModesGenerator.generateModeStatesTable( + hasModalReactors, modalReactorCount, modalStateResetCount)); + + // Generate function to initialize the trigger objects for all reactors. + code.pr( + CTriggerObjectsGenerator.generateInitializeTriggerObjects( + main, + targetConfig, + initializeTriggerObjects, + startTimeStep, + types, + lfModuleName, + startTimeStepIsPresentCount)); + + // Generate function to trigger startup reactions for all reactors. + code.pr( + CReactionGenerator.generateLfTriggerStartupReactions( + startupReactionCount, hasModalReactors)); + + // Generate function to schedule timers for all reactors. + code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); + + // Generate function to initialize mutexes for all reactors with watchdogs. + code.pr(CWatchdogGenerator.generateLfInitializeWatchdogMutexes(watchdogCount)); + + // Generate a function that will either do nothing + // (if there is only one federate or the coordination + // is set to decentralized) or, if there are + // downstream federates, will notify the RTI + // that the specified logical time is complete. + if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) + code.pr("extern \"C\""); + code.pr( + String.join( + "\n", + "void logical_tag_complete(tag_t tag_to_send) {", + CExtensionUtils.surroundWithIfFederatedCentralized( + " _lf_logical_tag_complete(tag_to_send);"), + "}")); + + // Generate function to schedule shutdown reactions if any + // reactors have reactions to shutdown. + code.pr( + CReactionGenerator.generateLfTriggerShutdownReactions( + shutdownReactionCount, hasModalReactors)); + + // Generate an empty termination function for non-federated + // execution. For federated execution, an implementation is + // provided in federate.c. That implementation will resign + // from the federation and close any open sockets. + code.pr( + """ + #ifndef FEDERATED + void terminate_execution() {} + #endif"""); + + // Generate functions for modes + code.pr(CModesGenerator.generateLfInitializeModes(hasModalReactors)); + code.pr(CModesGenerator.generateLfHandleModeChanges(hasModalReactors, modalStateResetCount)); + code.pr( + CReactionGenerator.generateLfModeTriggeredReactions( + startupReactionCount, resetReactionCount, hasModalReactors)); } + } - /** - * Copy all files or directories listed in the target property `files`, `cmake-include`, - * and `_fed_setup` into the src-gen folder of the main .lf file - * - * @param targetConfig The targetConfig to read the target properties from. - * @param fileConfig The fileConfig used to make the copy and resolve paths. - */ - @Override - public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - super.copyUserFiles(targetConfig, fileConfig); - // Make sure the target directory exists. - var targetDir = this.fileConfig.getSrcGenPath(); - try { - Files.createDirectories(targetDir); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } + @Override + public void checkModalReactorSupport(boolean __) { + // Modal reactors are currently only supported for non federated applications + super.checkModalReactorSupport(true); + } - for (String filename : targetConfig.fileNames) { - var relativeFileName = CUtil.copyFileOrResource( - filename, - fileConfig.srcFile.getParent(), - targetDir); - if (StringExtensions.isNullOrEmpty(relativeFileName)) { - errorReporter.reportError( - "Failed to find file " + filename + " specified in the" + - " files target property." - ); - } else { - targetConfig.filesNamesWithoutPath.add( - relativeFileName - ); - } - } + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + return String.join( + "\n", + "// Generated forwarding reaction for connections with the same destination", + "// but located in mutually exclusive modes.", + "lf_set(" + dest + ", " + source + "->value);"); + } - for (String filename : targetConfig.cmakeIncludes) { - var relativeCMakeIncludeFileName = - CUtil.copyFileOrResource( - filename, - fileConfig.srcFile.getParent(), - targetDir); - // Check if the file exists - if (StringExtensions.isNullOrEmpty(relativeCMakeIncludeFileName)) { - errorReporter.reportError( - "Failed to find cmake-include file " + filename - ); - } else { - this.targetConfig.cmakeIncludesWithoutPath.add( - relativeCMakeIncludeFileName - ); - } + /** Set the scheduler type in the target config as needed. */ + private void pickScheduler() { + // Don't use a scheduler that does not prioritize reactions based on deadlines + // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. + if (!targetConfig.schedulerType.prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + if (hasDeadlines(reactors)) { + if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { + targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; } + } + } + } - if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { - try { - FileUtil.copyFile(fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), - targetDir.resolve(targetConfig.fedSetupPreamble)); - } catch (IOException e) { - errorReporter.reportError("Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); - } + private boolean hasDeadlines(List reactors) { + for (Reactor reactor : reactors) { + for (Reaction reaction : allReactions(reactor)) { + if (reaction.getDeadline() != null) { + return true; } + } } + return false; + } - /** - * Generate code for defining all reactors that belong to the federate, - * including all the child reactors down the hierarchy. Duplicate - * Duplicates are avoided. - * - * Imported reactors' original .lf file is - * incorporated in the following manner: - * - If there are any cmake-include files, add them to the current list - * of cmake-include files. - * - If there are any preambles, add them to the preambles of the reactor. - */ - private void generateReactorDefinitions() throws IOException { - var generatedReactors = new LinkedHashSet(); - if (this.main != null) { - generateReactorChildren(this.main, generatedReactors); - } + private boolean hasWatchdogs() { + for (Reactor reactor : reactors) { + List watchdogs = ASTUtils.allWatchdogs(reactor); + if (watchdogs != null && !watchdogs.isEmpty()) { + return true; + } + } + return false; + } - if (this.mainDef != null) { - generateReactorClass(ASTUtils.toDefinition(this.mainDef.getReactorClass())); + /** + * Look at the 'reactor' eResource. If it is an imported .lf file, incorporate it into the current + * program in the following manner: - Merge its target property with `targetConfig` - If there are + * any preambles, add them to the preambles of the reactor. + */ + private void inspectReactorEResource(ReactorDecl reactor) { + // If the reactor is imported, look at the + // target definition of the .lf file in which the reactor is imported from and + // append any cmake-include. + // Check if the reactor definition is imported + if (reactor.eResource() != mainDef.getReactorClass().eResource()) { + // Find the LFResource corresponding to this eResource + LFResource lfResource = null; + for (var resource : resources) { + if (resource.getEResource() == reactor.eResource()) { + lfResource = resource; + break; } + } + // Copy the user files and cmake-includes to the src-gen path of the main .lf file + if (lfResource != null) { + copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); + } + } + } - if (mainDef == null) { - // Generate code for each reactor that was not instantiated in main or its children. - for (Reactor r : reactors) { - // Get the declarations for reactors that are instantiated somewhere. - // A declaration is either a reactor definition or an import statement.; - var declarations = this.instantiationGraph.getDeclarations(r); - // If the reactor has no instantiations and there is no main reactor, then - // generate code for it anyway (at a minimum, this means that the compiler is invoked - // so that reaction bodies are checked). - if (declarations.isEmpty()) { - generateReactorClass(r); - } - } - } + /** + * Copy all files or directories listed in the target property `files`, `cmake-include`, and + * `_fed_setup` into the src-gen folder of the main .lf file + * + * @param targetConfig The targetConfig to read the target properties from. + * @param fileConfig The fileConfig used to make the copy and resolve paths. + */ + @Override + public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + super.copyUserFiles(targetConfig, fileConfig); + // Make sure the target directory exists. + var targetDir = this.fileConfig.getSrcGenPath(); + try { + Files.createDirectories(targetDir); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); } - /** Generate user-visible header files for all reactors instantiated. */ - private void generateHeaders() throws IOException { - FileUtil.deleteDirectory(fileConfig.getIncludePath()); - FileUtil.copyDirectoryFromClassPath( - fileConfig.getRuntimeIncludePath(), - fileConfig.getIncludePath(), - false - ); - for (Reactor r : reactors) { - CReactorHeaderFileGenerator.doGenerate( - types, r, fileConfig, - (builder, rr, userFacing) -> { - generateAuxiliaryStructs(builder, rr, userFacing); - if (userFacing) { - ASTUtils.allInstantiations(r).stream().map(Instantiation::getReactorClass).collect(Collectors.toSet()).forEach(it -> { - ASTUtils.allPorts(ASTUtils.toDefinition(it)) - .forEach(p -> builder.pr(CPortGenerator.generateAuxiliaryStruct( - ASTUtils.toDefinition(it), p, getTarget(), errorReporter, types, new CodeBuilder(), true, it - ))); - }); - } - }, - this::generateTopLevelPreambles); - } - FileUtil.copyDirectory(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + for (String filename : targetConfig.fileNames) { + var relativeFileName = + CUtil.copyFileOrResource(filename, fileConfig.srcFile.getParent(), targetDir); + if (StringExtensions.isNullOrEmpty(relativeFileName)) { + errorReporter.reportError( + "Failed to find file " + filename + " specified in the" + " files target property."); + } else { + targetConfig.filesNamesWithoutPath.add(relativeFileName); + } } - /** - * Generate code for the children of 'reactor' that belong to 'federate'. - * Duplicates are avoided. - * - * Imported reactors' original .lf file is - * incorporated in the following manner: - * - If there are any cmake-include files, add them to the current list - * of cmake-include files. - * - If there are any preambles, add them to the preambles of the reactor. - * - * @param reactor Used to extract children from - */ - private void generateReactorChildren( - ReactorInstance reactor, - LinkedHashSet generatedReactors - ) throws IOException { - for (ReactorInstance r : reactor.children) { - if (r.reactorDeclaration != null && - !generatedReactors.contains(r.reactorDefinition)) { - generatedReactors.add(r.reactorDefinition); - generateReactorChildren(r, generatedReactors); - inspectReactorEResource(r.reactorDeclaration); - generateReactorClass(r.reactorDefinition); - } - } + for (String filename : targetConfig.cmakeIncludes) { + var relativeCMakeIncludeFileName = + CUtil.copyFileOrResource(filename, fileConfig.srcFile.getParent(), targetDir); + // Check if the file exists + if (StringExtensions.isNullOrEmpty(relativeCMakeIncludeFileName)) { + errorReporter.reportError("Failed to find cmake-include file " + filename); + } else { + this.targetConfig.cmakeIncludesWithoutPath.add(relativeCMakeIncludeFileName); + } } - /** - * Choose which platform files to compile with according to the OS. - * If there is no main reactor, then compilation will produce a .o file requiring further linking. - * Also, if useCmake is set to true, we don't need to add platform files. The CMakeLists.txt file - * will detect and use the appropriate platform file based on the platform that cmake is invoked on. - */ - private void pickCompilePlatform() { - var osName = System.getProperty("os.name").toLowerCase(); - // if platform target was set, use given platform instead - if (targetConfig.platformOptions.platform != Platform.AUTO) { - osName = targetConfig.platformOptions.platform.toString(); - } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { - errorReporter.reportError("Platform " + osName + " is not supported"); - } + if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { + try { + FileUtil.copyFile( + fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), + targetDir.resolve(targetConfig.fedSetupPreamble)); + } catch (IOException e) { + errorReporter.reportError( + "Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); + } } + } + /** + * Generate code for defining all reactors that belong to the federate, including all the child + * reactors down the hierarchy. Duplicate Duplicates are avoided. + * + *

Imported reactors' original .lf file is incorporated in the following manner: - If there are + * any cmake-include files, add them to the current list of cmake-include files. - If there are + * any preambles, add them to the preambles of the reactor. + */ + private void generateReactorDefinitions() throws IOException { + var generatedReactors = new LinkedHashSet(); + if (this.main != null) { + generateReactorChildren(this.main, generatedReactors); + } - /** - * Copy target-specific header file to the src-gen directory. - */ - protected void copyTargetFiles() throws IOException { - // Copy the core lib - String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); - Path dest = fileConfig.getSrcGenPath(); - if (targetConfig.platformOptions.platform == Platform.ARDUINO) dest = dest.resolve("src"); - if (coreLib != null) { - FileUtil.copyDirectory(Path.of(coreLib), dest, true); - } else { - FileUtil.copyDirectoryFromClassPath( - "/lib/c/reactor-c/core", - dest.resolve("core"), - true - ); - FileUtil.copyDirectoryFromClassPath( - "/lib/c/reactor-c/lib", - dest.resolve("lib"), - true - ); - } + if (this.mainDef != null) { + generateReactorClass(ASTUtils.toDefinition(this.mainDef.getReactorClass())); + } - // For the Zephyr target, copy default config and board files. - if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - FileUtil.copyDirectoryFromClassPath( - "/lib/platform/zephyr/boards", - fileConfig.getSrcGenPath().resolve("boards"), - false - ); - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/prj_lf.conf", - fileConfig.getSrcGenPath().resolve("prj_lf.conf"), - true - ); - - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/Kconfig", - fileConfig.getSrcGenPath().resolve("Kconfig"), - true - ); + if (mainDef == null) { + // Generate code for each reactor that was not instantiated in main or its children. + for (Reactor r : reactors) { + // Get the declarations for reactors that are instantiated somewhere. + // A declaration is either a reactor definition or an import statement.; + var declarations = this.instantiationGraph.getDeclarations(r); + // If the reactor has no instantiations and there is no main reactor, then + // generate code for it anyway (at a minimum, this means that the compiler is invoked + // so that reaction bodies are checked). + if (declarations.isEmpty()) { + generateReactorClass(r); } + } } + } - //////////////////////////////////////////// - //// Code generators. - /** - * Generate a reactor class definition for the specified federate. - * A class definition has four parts: - * - * * Preamble code, if any, specified in the Lingua Franca file. - * * A "self" struct type definition (see the class documentation above). - * * A function for each reaction. - * * A constructor for creating an instance. - * for deleting an instance. - * - * If the reactor is the main reactor, then - * the generated code may be customized. Specifically, - * if the main reactor has reactions, these reactions - * will not be generated if they are triggered by or send - * data to contained reactors that are not in the federate. - * @param reactor The parsed reactor data structure. - */ - private void generateReactorClass(Reactor reactor) throws IOException { - // FIXME: Currently we're not reusing definitions for declarations that point to the same definition. - CodeBuilder header = new CodeBuilder(); - CodeBuilder src = new CodeBuilder(); - final String headerName = CUtil.getName(reactor) + ".h"; - var guardMacro = headerName.toUpperCase().replace(".", "_"); - header.pr("#ifndef " + guardMacro); - header.pr("#define " + guardMacro); - generateReactorClassHeaders(reactor, headerName, header, src); - header.pr(generateTopLevelPreambles(reactor)); - generateUserPreamblesForReactor(reactor, src); - generateReactorClassBody(reactor, header, src); - header.pr("#endif // " + guardMacro); - FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); - var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" : - CCppMode ? ".cpp" : ".c"; - FileUtil.writeToFile(src.toString(), fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), true); + /** Generate user-visible header files for all reactors instantiated. */ + private void generateHeaders() throws IOException { + FileUtil.deleteDirectory(fileConfig.getIncludePath()); + FileUtil.copyDirectoryFromClassPath( + fileConfig.getRuntimeIncludePath(), fileConfig.getIncludePath(), false); + for (Reactor r : reactors) { + CReactorHeaderFileGenerator.doGenerate( + types, + r, + fileConfig, + (builder, rr, userFacing) -> { + generateAuxiliaryStructs(builder, rr, userFacing); + if (userFacing) { + ASTUtils.allInstantiations(r).stream() + .map(Instantiation::getReactorClass) + .collect(Collectors.toSet()) + .forEach( + it -> { + ASTUtils.allPorts(ASTUtils.toDefinition(it)) + .forEach( + p -> + builder.pr( + CPortGenerator.generateAuxiliaryStruct( + ASTUtils.toDefinition(it), + p, + getTarget(), + errorReporter, + types, + new CodeBuilder(), + true, + it))); + }); + } + }, + this::generateTopLevelPreambles); } + FileUtil.copyDirectory( + fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + } - protected void generateReactorClassHeaders(Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { - if (CCppMode) { - src.pr("extern \"C\" {"); - header.pr("extern \"C\" {"); - } - header.pr("#include \"include/core/reactor.h\""); - src.pr("#include \"include/api/api.h\""); - src.pr("#include \"include/api/set.h\""); - generateIncludes(reactor); - if (CCppMode) { - src.pr("}"); - header.pr("}"); - } - src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(reactor) + "\""); - src.pr("#include \"" + headerName + "\""); - ASTUtils.allNestedClasses(reactor).map(CUtil::getName) - .map(name -> "#include \"" + name + ".h\"") - .forEach(header::pr); + /** + * Generate code for the children of 'reactor' that belong to 'federate'. Duplicates are avoided. + * + *

Imported reactors' original .lf file is incorporated in the following manner: - If there are + * any cmake-include files, add them to the current list of cmake-include files. - If there are + * any preambles, add them to the preambles of the reactor. + * + * @param reactor Used to extract children from + */ + private void generateReactorChildren( + ReactorInstance reactor, LinkedHashSet generatedReactors) throws IOException { + for (ReactorInstance r : reactor.children) { + if (r.reactorDeclaration != null && !generatedReactors.contains(r.reactorDefinition)) { + generatedReactors.add(r.reactorDefinition); + generateReactorChildren(r, generatedReactors); + inspectReactorEResource(r.reactorDeclaration); + generateReactorClass(r.reactorDefinition); + } } + } - private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeBuilder src) { - // Some of the following methods create lines of code that need to - // go into the constructor. Collect those lines of code here: - var constructorCode = new CodeBuilder(); - generateAuxiliaryStructs(header, reactor, false); - generateSelfStruct(header, reactor, constructorCode); - generateMethods(src, reactor); - generateWatchdogs(src, reactor); - generateReactions(src, reactor); - generateConstructor(src, header, reactor, constructorCode); + /** + * Choose which platform files to compile with according to the OS. If there is no main reactor, + * then compilation will produce a .o file requiring further linking. Also, if useCmake is set to + * true, we don't need to add platform files. The CMakeLists.txt file will detect and use the + * appropriate platform file based on the platform that cmake is invoked on. + */ + private void pickCompilePlatform() { + var osName = System.getProperty("os.name").toLowerCase(); + // if platform target was set, use given platform instead + if (targetConfig.platformOptions.platform != Platform.AUTO) { + osName = targetConfig.platformOptions.platform.toString(); + } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { + errorReporter.reportError("Platform " + osName + " is not supported"); } + } - /** - * Generate methods for {@code reactor}. - */ - protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { - CMethodGenerator.generateMethods(reactor, src, types); + /** Copy target-specific header file to the src-gen directory. */ + protected void copyTargetFiles() throws IOException { + // Copy the core lib + String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); + Path dest = fileConfig.getSrcGenPath(); + if (targetConfig.platformOptions.platform == Platform.ARDUINO) dest = dest.resolve("src"); + if (coreLib != null) { + FileUtil.copyDirectory(Path.of(coreLib), dest, true); + } else { + FileUtil.copyDirectoryFromClassPath("/lib/c/reactor-c/core", dest.resolve("core"), true); + FileUtil.copyDirectoryFromClassPath("/lib/c/reactor-c/lib", dest.resolve("lib"), true); } - /** - * Generates preambles defined by user for a given reactor - * @param reactor The given reactor - */ - protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { - for (Preamble p : convertToEmptyListIfNull(reactor.getPreambles())) { - src.pr("// *********** From the preamble, verbatim:"); - src.prSourceLineNumber(p.getCode()); - src.pr(toText(p.getCode())); - src.pr("\n// *********** End of preamble."); - } + // For the Zephyr target, copy default config and board files. + if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + FileUtil.copyDirectoryFromClassPath( + "/lib/platform/zephyr/boards", fileConfig.getSrcGenPath().resolve("boards"), false); + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/prj_lf.conf", + fileConfig.getSrcGenPath().resolve("prj_lf.conf"), + true); + + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath().resolve("Kconfig"), true); } + } - /** - * Generate a constructor for the specified reactor in the specified federate. - * @param reactor The parsed reactor data structure. - * @param constructorCode Lines of code previously generated that need to - * go into the constructor. - */ - protected void generateConstructor( - CodeBuilder src, CodeBuilder header, Reactor reactor, CodeBuilder constructorCode - ) { - header.pr(CConstructorGenerator.generateConstructorPrototype(reactor)); - src.pr(CConstructorGenerator.generateConstructor( - reactor, - constructorCode.toString() - )); + //////////////////////////////////////////// + //// Code generators. + /** + * Generate a reactor class definition for the specified federate. A class definition has four + * parts: + * + *

* Preamble code, if any, specified in the Lingua Franca file. * A "self" struct type + * definition (see the class documentation above). * A function for each reaction. * A constructor + * for creating an instance. for deleting an instance. + * + *

If the reactor is the main reactor, then the generated code may be customized. Specifically, + * if the main reactor has reactions, these reactions will not be generated if they are triggered + * by or send data to contained reactors that are not in the federate. + * + * @param reactor The parsed reactor data structure. + */ + private void generateReactorClass(Reactor reactor) throws IOException { + // FIXME: Currently we're not reusing definitions for declarations that point to the same + // definition. + CodeBuilder header = new CodeBuilder(); + CodeBuilder src = new CodeBuilder(); + final String headerName = CUtil.getName(reactor) + ".h"; + var guardMacro = headerName.toUpperCase().replace(".", "_"); + header.pr("#ifndef " + guardMacro); + header.pr("#define " + guardMacro); + generateReactorClassHeaders(reactor, headerName, header, src); + header.pr(generateTopLevelPreambles(reactor)); + generateUserPreamblesForReactor(reactor, src); + generateReactorClassBody(reactor, header, src); + header.pr("#endif // " + guardMacro); + FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); + var extension = + targetConfig.platformOptions.platform == Platform.ARDUINO + ? ".ino" + : CCppMode ? ".cpp" : ".c"; + FileUtil.writeToFile( + src.toString(), + fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), + true); + } + + protected void generateReactorClassHeaders( + Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { + if (CCppMode) { + src.pr("extern \"C\" {"); + header.pr("extern \"C\" {"); + } + header.pr("#include \"include/core/reactor.h\""); + src.pr("#include \"include/api/api.h\""); + src.pr("#include \"include/api/set.h\""); + generateIncludes(reactor); + if (CCppMode) { + src.pr("}"); + header.pr("}"); } + src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(reactor) + "\""); + src.pr("#include \"" + headerName + "\""); + ASTUtils.allNestedClasses(reactor) + .map(CUtil::getName) + .map(name -> "#include \"" + name + ".h\"") + .forEach(header::pr); + } + + private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeBuilder src) { + // Some of the following methods create lines of code that need to + // go into the constructor. Collect those lines of code here: + var constructorCode = new CodeBuilder(); + generateAuxiliaryStructs(header, reactor, false); + generateSelfStruct(header, reactor, constructorCode); + generateMethods(src, reactor); + generateWatchdogs(src, reactor); + generateReactions(src, reactor); + generateConstructor(src, header, reactor, constructorCode); + } + + /** Generate methods for {@code reactor}. */ + protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { + CMethodGenerator.generateMethods(reactor, src, types); + } - protected void generateIncludes(Reactor r) { - code.pr("#include \"" + CUtil.getName(r) + ".h\""); + /** + * Generates preambles defined by user for a given reactor + * + * @param reactor The given reactor + */ + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + for (Preamble p : convertToEmptyListIfNull(reactor.getPreambles())) { + src.pr("// *********** From the preamble, verbatim:"); + src.prSourceLineNumber(p.getCode()); + src.pr(toText(p.getCode())); + src.pr("\n// *********** End of preamble."); } + } - /** - * Generate the struct type definitions for inputs, outputs, and - * actions of the specified reactor. - */ - protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { - // In the case where there are incoming - // p2p logical connections in decentralized - // federated execution, there will be an - // intended_tag field added to accommodate - // the case where a reaction triggered by a - // port or action is late due to network - // latency, etc.. - var federatedExtension = new CodeBuilder(); - federatedExtension.pr(""" + /** + * Generate a constructor for the specified reactor in the specified federate. + * + * @param reactor The parsed reactor data structure. + * @param constructorCode Lines of code previously generated that need to go into the constructor. + */ + protected void generateConstructor( + CodeBuilder src, CodeBuilder header, Reactor reactor, CodeBuilder constructorCode) { + header.pr(CConstructorGenerator.generateConstructorPrototype(reactor)); + src.pr(CConstructorGenerator.generateConstructor(reactor, constructorCode.toString())); + } + + protected void generateIncludes(Reactor r) { + code.pr("#include \"" + CUtil.getName(r) + ".h\""); + } + + /** + * Generate the struct type definitions for inputs, outputs, and actions of the specified reactor. + */ + protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { + // In the case where there are incoming + // p2p logical connections in decentralized + // federated execution, there will be an + // intended_tag field added to accommodate + // the case where a reaction triggered by a + // port or action is late due to network + // latency, etc.. + var federatedExtension = new CodeBuilder(); + federatedExtension.pr( + """ #ifdef FEDERATED #ifdef FEDERATED_DECENTRALIZED %s intended_tag; #endif %s physical_time_of_arrival; #endif - """.formatted(types.getTargetTagType(), types.getTargetTimeType()) - ); - for (Port p : allPorts(r)) { - builder.pr(CPortGenerator.generateAuxiliaryStruct( - r, - p, - getTarget(), - errorReporter, - types, - federatedExtension, - userFacing, - null - )); - } - // The very first item on this struct needs to be - // a trigger_t* because the struct will be cast to (trigger_t*) - // by the lf_schedule() functions to get to the trigger. - for (Action action : allActions(r)) { - builder.pr(CActionGenerator.generateAuxiliaryStruct( - r, - action, - getTarget(), - types, - federatedExtension, - userFacing - )); - } + """ + .formatted(types.getTargetTagType(), types.getTargetTimeType())); + for (Port p : allPorts(r)) { + builder.pr( + CPortGenerator.generateAuxiliaryStruct( + r, p, getTarget(), errorReporter, types, federatedExtension, userFacing, null)); } - - /** - * Generate the self struct type definition for the specified reactor - * in the specified federate. - * @param decl The parsed reactor data structure. - * @param constructorCode Place to put lines of code that need to - * go into the constructor. - */ - private void generateSelfStruct(CodeBuilder builder, ReactorDecl decl, CodeBuilder constructorCode) { - var reactor = toDefinition(decl); - var selfType = CUtil.selfType(ASTUtils.toDefinition(decl)); - - // Construct the typedef for the "self" struct. - // Create a type name for the self struct. - var body = new CodeBuilder(); - - // Extensions can add functionality to the CGenerator - generateSelfStructExtension(body, decl, constructorCode); - - // Next handle parameters. - body.pr(CParameterGenerator.generateDeclarations(reactor, types)); - - // Next handle states. - body.pr(CStateGenerator.generateDeclarations(reactor, types)); - - // Next handle actions. - CActionGenerator.generateDeclarations(reactor, body, constructorCode); - - // Next handle inputs and outputs. - CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); - - // If there are contained reactors that either receive inputs - // from reactions of this reactor or produce outputs that trigger - // reactions of this reactor, then we need to create a struct - // inside the self struct for each contained reactor. That - // struct has a place to hold the data produced by this reactor's - // reactions and a place to put pointers to data produced by - // the contained reactors. - generateInteractingContainedReactors(reactor, body, constructorCode); - - // Next, generate the fields needed for each reaction. - CReactionGenerator.generateReactionAndTriggerStructs( - body, - reactor, - constructorCode, - types - ); - - // Generate the fields needed for each watchdog. - CWatchdogGenerator.generateWatchdogStruct( - body, - decl, - constructorCode - ); - - // Next, generate fields for modes - CModesGenerator.generateDeclarations(reactor, body, constructorCode); - - // The first field has to always be a pointer to the list of - // of allocated memory that must be freed when the reactor is freed. - // This means that the struct can be safely cast to self_base_t. - builder.pr("typedef struct {"); - builder.indent(); - builder.pr("struct self_base_t base;"); - builder.pr(body.toString()); - builder.unindent(); - builder.pr("} " + selfType + ";"); + // The very first item on this struct needs to be + // a trigger_t* because the struct will be cast to (trigger_t*) + // by the lf_schedule() functions to get to the trigger. + for (Action action : allActions(r)) { + builder.pr( + CActionGenerator.generateAuxiliaryStruct( + r, action, getTarget(), types, federatedExtension, userFacing)); } + } - /** - * Generate structs and associated code for contained reactors that - * send or receive data to or from the container's reactions. - * - * If there are contained reactors that either receive inputs - * from reactions of this reactor or produce outputs that trigger - * reactions of this reactor, then we need to create a struct - * inside the self struct of the container for each contained reactor. - * That struct has a place to hold the data produced by the container reactor's - * reactions and a place to put pointers to data produced by - * the contained reactors. - * - * @param reactor The reactor. - * @param body The place to put the struct definition for the contained reactors. - * @param constructorCode The place to put matching code that goes in the container's constructor. - */ - private void generateInteractingContainedReactors( - Reactor reactor, - CodeBuilder body, - CodeBuilder constructorCode - ) { - // The contents of the struct will be collected first so that - // we avoid duplicate entries and then the struct will be constructed. - var contained = new InteractingContainedReactors(reactor); - // Next generate the relevant code. - for (Instantiation containedReactor : contained.containedReactors()) { - Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); - // First define an _width variable in case it is a bank. - var array = ""; - var width = -2; - // If the instantiation is a bank, find the maximum bank width - // to define an array. - if (containedReactor.getWidthSpec() != null) { - width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); - array = "[" + width + "]"; - } - // NOTE: The following needs to be done for each instance - // so that the width can be parameter, not in the constructor. - // Here, we conservatively use a width that is the largest of all isntances. - constructorCode.pr(String.join("\n", - "// Set the _width variable for all cases. This will be -2", - "// if the reactor is not a bank of reactors.", - "self->_lf_"+containedReactor.getName()+"_width = "+width+";" - )); - - // Generate one struct for each contained reactor that interacts. - body.pr("struct {"); - body.indent(); - for (Port port : contained.portsOfInstance(containedReactor)) { - if (port instanceof Input) { - // If the variable is a multiport, then the place to store the data has - // to be malloc'd at initialization. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType, false)+" "+port.getName()+";"); - } else { - // Is a multiport. - // Memory will be malloc'd in initialization. - body.pr(port, String.join("\n", - variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", - "int "+port.getName()+"_width;" - )); - } - } else { - // Must be an output port. - // Outputs of contained reactors are pointers to the source of data on the - // self struct of the container. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType, false)+"* "+port.getName()+";"); - } else { - // Is a multiport. - // Here, we will use an array of pointers. - // Memory will be malloc'd in initialization. - body.pr(port, String.join("\n", - variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", - "int "+port.getName()+"_width;" - )); - } - body.pr(port, "trigger_t "+port.getName()+"_trigger;"); - var reactorIndex = ""; - if (containedReactor.getWidthSpec() != null) { - reactorIndex = "[reactor_index]"; - constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactor.getName()+"_width; reactor_index++) {"); - constructorCode.indent(); - } - var portOnSelf = "self->_lf_"+containedReactor.getName()+reactorIndex+"."+port.getName(); - - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederatedDecentralized( - portOnSelf+"_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};" - ) - ); - - var triggered = contained.reactionsTriggered(containedReactor, port); - //noinspection StatementWithEmptyBody - if (triggered.size() > 0) { - body.pr(port, "reaction_t* "+port.getName()+"_reactions["+triggered.size()+"];"); - var triggeredCount = 0; - for (Integer index : triggered) { - constructorCode.pr(port, portOnSelf+"_reactions["+triggeredCount+++"] = &self->_lf__reaction_"+index+";"); - } - constructorCode.pr(port, portOnSelf+"_trigger.reactions = "+portOnSelf+"_reactions;"); - } else { - // Since the self struct is created using calloc, there is no need to set - // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL - } - // Since the self struct is created using calloc, there is no need to set falsy fields. - constructorCode.pr(port, String.join("\n", - portOnSelf+"_trigger.last = NULL;", - portOnSelf+"_trigger.number_of_reactions = "+triggered.size()+";" - )); - - - // Set the physical_time_of_arrival - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederated( - portOnSelf+"_trigger.physical_time_of_arrival = NEVER;" - ) - ); - - if (containedReactor.getWidthSpec() != null) { - constructorCode.unindent(); - constructorCode.pr("}"); - } - } + /** + * Generate the self struct type definition for the specified reactor in the specified federate. + * + * @param decl The parsed reactor data structure. + * @param constructorCode Place to put lines of code that need to go into the constructor. + */ + private void generateSelfStruct( + CodeBuilder builder, ReactorDecl decl, CodeBuilder constructorCode) { + var reactor = toDefinition(decl); + var selfType = CUtil.selfType(ASTUtils.toDefinition(decl)); + + // Construct the typedef for the "self" struct. + // Create a type name for the self struct. + var body = new CodeBuilder(); + + // Extensions can add functionality to the CGenerator + generateSelfStructExtension(body, decl, constructorCode); + + // Next handle parameters. + body.pr(CParameterGenerator.generateDeclarations(reactor, types)); + + // Next handle states. + body.pr(CStateGenerator.generateDeclarations(reactor, types)); + + // Next handle actions. + CActionGenerator.generateDeclarations(reactor, body, constructorCode); + + // Next handle inputs and outputs. + CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); + + // If there are contained reactors that either receive inputs + // from reactions of this reactor or produce outputs that trigger + // reactions of this reactor, then we need to create a struct + // inside the self struct for each contained reactor. That + // struct has a place to hold the data produced by this reactor's + // reactions and a place to put pointers to data produced by + // the contained reactors. + generateInteractingContainedReactors(reactor, body, constructorCode); + + // Next, generate the fields needed for each reaction. + CReactionGenerator.generateReactionAndTriggerStructs(body, reactor, constructorCode, types); + + // Generate the fields needed for each watchdog. + CWatchdogGenerator.generateWatchdogStruct(body, decl, constructorCode); + + // Next, generate fields for modes + CModesGenerator.generateDeclarations(reactor, body, constructorCode); + + // The first field has to always be a pointer to the list of + // of allocated memory that must be freed when the reactor is freed. + // This means that the struct can be safely cast to self_base_t. + builder.pr("typedef struct {"); + builder.indent(); + builder.pr("struct self_base_t base;"); + builder.pr(body.toString()); + builder.unindent(); + builder.pr("} " + selfType + ";"); + } + + /** + * Generate structs and associated code for contained reactors that send or receive data to or + * from the container's reactions. + * + *

If there are contained reactors that either receive inputs from reactions of this reactor or + * produce outputs that trigger reactions of this reactor, then we need to create a struct inside + * the self struct of the container for each contained reactor. That struct has a place to hold + * the data produced by the container reactor's reactions and a place to put pointers to data + * produced by the contained reactors. + * + * @param reactor The reactor. + * @param body The place to put the struct definition for the contained reactors. + * @param constructorCode The place to put matching code that goes in the container's constructor. + */ + private void generateInteractingContainedReactors( + Reactor reactor, CodeBuilder body, CodeBuilder constructorCode) { + // The contents of the struct will be collected first so that + // we avoid duplicate entries and then the struct will be constructed. + var contained = new InteractingContainedReactors(reactor); + // Next generate the relevant code. + for (Instantiation containedReactor : contained.containedReactors()) { + Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); + // First define an _width variable in case it is a bank. + var array = ""; + var width = -2; + // If the instantiation is a bank, find the maximum bank width + // to define an array. + if (containedReactor.getWidthSpec() != null) { + width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); + array = "[" + width + "]"; + } + // NOTE: The following needs to be done for each instance + // so that the width can be parameter, not in the constructor. + // Here, we conservatively use a width that is the largest of all isntances. + constructorCode.pr( + String.join( + "\n", + "// Set the _width variable for all cases. This will be -2", + "// if the reactor is not a bank of reactors.", + "self->_lf_" + containedReactor.getName() + "_width = " + width + ";")); + + // Generate one struct for each contained reactor that interacts. + body.pr("struct {"); + body.indent(); + for (Port port : contained.portsOfInstance(containedReactor)) { + if (port instanceof Input) { + // If the variable is a multiport, then the place to store the data has + // to be malloc'd at initialization. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr( + port, + variableStructType(port, containedReactorType, false) + " " + port.getName() + ";"); + } else { + // Is a multiport. + // Memory will be malloc'd in initialization. + body.pr( + port, + String.join( + "\n", + variableStructType(port, containedReactorType, false) + + "** " + + port.getName() + + ";", + "int " + port.getName() + "_width;")); + } + } else { + // Must be an output port. + // Outputs of contained reactors are pointers to the source of data on the + // self struct of the container. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr( + port, + variableStructType(port, containedReactorType, false) + + "* " + + port.getName() + + ";"); + } else { + // Is a multiport. + // Here, we will use an array of pointers. + // Memory will be malloc'd in initialization. + body.pr( + port, + String.join( + "\n", + variableStructType(port, containedReactorType, false) + + "** " + + port.getName() + + ";", + "int " + port.getName() + "_width;")); + } + body.pr(port, "trigger_t " + port.getName() + "_trigger;"); + var reactorIndex = ""; + if (containedReactor.getWidthSpec() != null) { + reactorIndex = "[reactor_index]"; + constructorCode.pr( + "for (int reactor_index = 0; reactor_index < self->_lf_" + + containedReactor.getName() + + "_width; reactor_index++) {"); + constructorCode.indent(); + } + var portOnSelf = + "self->_lf_" + containedReactor.getName() + reactorIndex + "." + port.getName(); + + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederatedDecentralized( + portOnSelf + + "_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + + var triggered = contained.reactionsTriggered(containedReactor, port); + //noinspection StatementWithEmptyBody + if (triggered.size() > 0) { + body.pr( + port, "reaction_t* " + port.getName() + "_reactions[" + triggered.size() + "];"); + var triggeredCount = 0; + for (Integer index : triggered) { + constructorCode.pr( + port, + portOnSelf + + "_reactions[" + + triggeredCount++ + + "] = &self->_lf__reaction_" + + index + + ";"); } - body.unindent(); - body.pr(String.join("\n", - "} _lf_"+containedReactor.getName()+array+";", - "int _lf_"+containedReactor.getName()+"_width;" - )); + constructorCode.pr( + port, portOnSelf + "_trigger.reactions = " + portOnSelf + "_reactions;"); + } else { + // Since the self struct is created using calloc, there is no need to set + // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL + } + // Since the self struct is created using calloc, there is no need to set falsy fields. + constructorCode.pr( + port, + String.join( + "\n", + portOnSelf + "_trigger.last = NULL;", + portOnSelf + "_trigger.number_of_reactions = " + triggered.size() + ";")); + + // Set the physical_time_of_arrival + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederated( + portOnSelf + "_trigger.physical_time_of_arrival = NEVER;")); + + if (containedReactor.getWidthSpec() != null) { + constructorCode.unindent(); + constructorCode.pr("}"); + } } + } + body.unindent(); + body.pr( + String.join( + "\n", + "} _lf_" + containedReactor.getName() + array + ";", + "int _lf_" + containedReactor.getName() + "_width;")); } + } - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the self struct - * @param body The body of the self struct - * @param decl The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - protected void generateSelfStructExtension( - CodeBuilder body, - ReactorDecl decl, - CodeBuilder constructorCode - ) { - // Do nothing - } + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the + * self struct + * + * @param body The body of the self struct + * @param decl The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + protected void generateSelfStructExtension( + CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode) { + // Do nothing + } - /** Generate reaction functions definition for a reactor. - * These functions have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param r The reactor. - */ - public void generateReactions(CodeBuilder src, Reactor r) { - var reactionIndex = 0; - var reactor = ASTUtils.toDefinition(r); - for (Reaction reaction : allReactions(reactor)) { - generateReaction(src, reaction, r, reactionIndex); - // Increment reaction index even if the reaction is not in the federate - // so that across federates, the reaction indices are consistent. - reactionIndex++; - } + /** + * Generate reaction functions definition for a reactor. These functions have a single argument + * that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param r The reactor. + */ + public void generateReactions(CodeBuilder src, Reactor r) { + var reactionIndex = 0; + var reactor = ASTUtils.toDefinition(r); + for (Reaction reaction : allReactions(reactor)) { + generateReaction(src, reaction, r, reactionIndex); + // Increment reaction index even if the reaction is not in the federate + // so that across federates, the reaction indices are consistent. + reactionIndex++; } + } - /** Generate a reaction function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param r The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { - src.pr(CReactionGenerator.generateReaction( + /** + * Generate a reaction function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + protected void generateReaction( + CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { + src.pr( + CReactionGenerator.generateReaction( reaction, r, reactionIndex, @@ -1457,740 +1399,783 @@ protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, i errorReporter, types, targetConfig, - getTarget().requiresTypes - )); - } + getTarget().requiresTypes)); + } - /** Generate watchdog functions definition for a reactor. - * These functions have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param decl The reactor. - * federated or not the main reactor and reactions should be - * unconditionally generated. - */ - public void generateWatchdogs(CodeBuilder src, ReactorDecl decl) { - var reactor = ASTUtils.toDefinition(decl); - for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - generateWatchdog(src, watchdog, decl); - } + /** + * Generate watchdog functions definition for a reactor. These functions have a single argument + * that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param decl The reactor. federated or not the main reactor and reactions should be + * unconditionally generated. + */ + public void generateWatchdogs(CodeBuilder src, ReactorDecl decl) { + var reactor = ASTUtils.toDefinition(decl); + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + generateWatchdog(src, watchdog, decl); + } } - /** Generate a watchdog function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param watchdog The watchdog. - * @param decl The reactor. + /** + * Generate a watchdog function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param watchdog The watchdog. + * @param decl The reactor. */ protected void generateWatchdog(CodeBuilder src, Watchdog watchdog, ReactorDecl decl) { - src.pr(CWatchdogGenerator.generateWatchdog( - watchdog, - decl - )); + src.pr(CWatchdogGenerator.generateWatchdog(watchdog, decl)); } - /** - * Record startup, shutdown, and reset reactions. - * @param instance A reactor instance. - */ - private void recordBuiltinTriggers(ReactorInstance instance) { - // For each reaction instance, allocate the arrays that will be used to - // trigger downstream reactions. - for (ReactionInstance reaction : instance.reactions) { - var reactor = reaction.getParent(); - var temp = new CodeBuilder(); - var foundOne = false; - - var reactionRef = CUtil.reactionRef(reaction); - - // Next handle triggers of the reaction that come from a multiport output - // of a contained reactor. Also, handle startup and shutdown triggers. - for (TriggerInstance trigger : reaction.triggers) { - if (trigger.isStartup()) { - temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &"+reactionRef+";"); - startupReactionCount += reactor.getTotalWidth(); - foundOne = true; - } else if (trigger.isShutdown()) { - temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &"+reactionRef+";"); - foundOne = true; - shutdownReactionCount += reactor.getTotalWidth(); - - if (targetConfig.tracing != null) { - var description = CUtil.getShortenedName(reactor); - var reactorRef = CUtil.reactorRef(reactor); - temp.pr(String.join("\n", - "_lf_register_trace_event("+reactorRef+", &("+reactorRef+"->_lf__shutdown),", - "trace_trigger, "+addDoubleQuotes(description+".shutdown")+");" - )); - } - } else if (trigger.isReset()) { - temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &"+reactionRef+";"); - resetReactionCount += reactor.getTotalWidth(); - foundOne = true; - } - } - if (foundOne) initializeTriggerObjects.pr(temp.toString()); - } - } - - private void recordWatchdogs(ReactorInstance instance) { - var foundOne = false; + /** + * Record startup, shutdown, and reset reactions. + * + * @param instance A reactor instance. + */ + private void recordBuiltinTriggers(ReactorInstance instance) { + // For each reaction instance, allocate the arrays that will be used to + // trigger downstream reactions. + for (ReactionInstance reaction : instance.reactions) { + var reactor = reaction.getParent(); var temp = new CodeBuilder(); - var reactorRef = CUtil.reactorRef(instance); - // temp.pr("#ifdef LF_THREADED"); - for (WatchdogInstance watchdog : instance.watchdogs) { - temp.pr(" _lf_watchdogs[_lf_watchdog_number_count++] = &"+reactorRef+"->_lf_watchdog_"+watchdog.getName()+";"); - temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".min_expiration = "+CTypes.getInstance().getTargetTimeExpr(watchdog.getTimeout())+";"); - temp.pr(" " + reactorRef+"->_lf_watchdog_"+watchdog.getName()+".thread_id;"); - watchdogCount += 1; + var foundOne = false; + + var reactionRef = CUtil.reactionRef(reaction); + + // Next handle triggers of the reaction that come from a multiport output + // of a contained reactor. Also, handle startup and shutdown triggers. + for (TriggerInstance trigger : reaction.triggers) { + if (trigger.isStartup()) { + temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &" + reactionRef + ";"); + startupReactionCount += reactor.getTotalWidth(); foundOne = true; + } else if (trigger.isShutdown()) { + temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &" + reactionRef + ";"); + foundOne = true; + shutdownReactionCount += reactor.getTotalWidth(); + + if (targetConfig.tracing != null) { + var description = CUtil.getShortenedName(reactor); + var reactorRef = CUtil.reactorRef(reactor); + temp.pr( + String.join( + "\n", + "_lf_register_trace_event(" + + reactorRef + + ", &(" + + reactorRef + + "->_lf__shutdown),", + "trace_trigger, " + addDoubleQuotes(description + ".shutdown") + ");")); + } + } else if (trigger.isReset()) { + temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &" + reactionRef + ";"); + resetReactionCount += reactor.getTotalWidth(); + foundOne = true; + } } - // temp.pr("#endif"); - if (foundOne) { - initializeTriggerObjects.pr(temp.toString()); - } + if (foundOne) initializeTriggerObjects.pr(temp.toString()); + } } - /** - * Generate code to set up the tables used in _lf_start_time_step to decrement reference - * counts and mark outputs absent between time steps. This function puts the code - * into startTimeStep. - */ - private void generateStartTimeStep(ReactorInstance instance) { - // Avoid generating dead code if nothing is relevant. - var foundOne = false; - var temp = new CodeBuilder(); - var containerSelfStructName = CUtil.reactorRef(instance); - - // Handle inputs that get sent data from a reaction rather than from - // another contained reactor and reactions that are triggered by an - // output of a contained reactor. - // Note that there may be more than one reaction reacting to the same - // port so we have to avoid listing the port more than once. - var portsSeen = new LinkedHashSet(); - for (ReactionInstance reaction : instance.reactions) { - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { - portsSeen.add(port); - // This reaction is sending to an input. Must be - // the input of a contained reactor in the federate. - // NOTE: If instance == main and the federate is within a bank, - // this assumes that the reaction writes only to the bank member in the federate. - foundOne = true; - - temp.pr("// Add port "+port.getFullName()+" to array of is_present fields."); - - if (!Objects.equal(port.getParent(), instance)) { - // The port belongs to contained reactor, so we also have - // iterate over the instance bank members. - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(instance); - temp.startScopedBankChannelIteration(port, null); - } else { - temp.startScopedBankChannelIteration(port, "count"); - } - var portRef = CUtil.portRefNested(port); - var con = (port.isMultiport()) ? "->" : "."; - - temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"is_present;"); - // Intended_tag is only applicable to ports in federated execution. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"intended_tag;" - ) - ); - - startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); - - if (!Objects.equal(port.getParent(), instance)) { - temp.pr("count++;"); - temp.endScopedBlock(); - temp.endScopedBlock(); - temp.endScopedBankChannelIteration(port, null); - } else { - temp.endScopedBankChannelIteration(port, "count"); - } - } - } - } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; + private void recordWatchdogs(ReactorInstance instance) { + var foundOne = false; + var temp = new CodeBuilder(); + var reactorRef = CUtil.reactorRef(instance); + // temp.pr("#ifdef LF_THREADED"); + for (WatchdogInstance watchdog : instance.watchdogs) { + temp.pr( + " _lf_watchdogs[_lf_watchdog_number_count++] = &" + + reactorRef + + "->_lf_watchdog_" + + watchdog.getName() + + ";"); + temp.pr( + " " + + reactorRef + + "->_lf_watchdog_" + + watchdog.getName() + + ".min_expiration = " + + CTypes.getInstance().getTargetTimeExpr(watchdog.getTimeout()) + + ";"); + temp.pr(" " + reactorRef + "->_lf_watchdog_" + watchdog.getName() + ".thread_id;"); + watchdogCount += 1; + foundOne = true; + } + // temp.pr("#endif"); + if (foundOne) { + initializeTriggerObjects.pr(temp.toString()); + } + } - for (ActionInstance action : instance.actions) { - foundOne = true; + /** + * Generate code to set up the tables used in _lf_start_time_step to decrement reference counts + * and mark outputs absent between time steps. This function puts the code into startTimeStep. + */ + private void generateStartTimeStep(ReactorInstance instance) { + // Avoid generating dead code if nothing is relevant. + var foundOne = false; + var temp = new CodeBuilder(); + var containerSelfStructName = CUtil.reactorRef(instance); + + // Handle inputs that get sent data from a reaction rather than from + // another contained reactor and reactions that are triggered by an + // output of a contained reactor. + // Note that there may be more than one reaction reacting to the same + // port so we have to avoid listing the port more than once. + var portsSeen = new LinkedHashSet(); + for (ReactionInstance reaction : instance.reactions) { + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { + portsSeen.add(port); + // This reaction is sending to an input. Must be + // the input of a contained reactor in the federate. + // NOTE: If instance == main and the federate is within a bank, + // this assumes that the reaction writes only to the bank member in the federate. + foundOne = true; + + temp.pr("// Add port " + port.getFullName() + " to array of is_present fields."); + + if (!Objects.equal(port.getParent(), instance)) { + // The port belongs to contained reactor, so we also have + // iterate over the instance bank members. + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); temp.startScopedBlock(instance); + temp.startScopedBankChannelIteration(port, null); + } else { + temp.startScopedBankChannelIteration(port, "count"); + } + var portRef = CUtil.portRefNested(port); + var con = (port.isMultiport()) ? "->" : "."; + + temp.pr( + "_lf_is_present_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + portRef + + con + + "is_present;"); + // Intended_tag is only applicable to ports in federated execution. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + portRef + + con + + "intended_tag;")); + + startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); + + if (!Objects.equal(port.getParent(), instance)) { + temp.pr("count++;"); + temp.endScopedBlock(); + temp.endScopedBlock(); + temp.endScopedBankChannelIteration(port, null); + } else { + temp.endScopedBankChannelIteration(port, "count"); + } + } + } + } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; + + for (ActionInstance action : instance.actions) { + foundOne = true; + temp.startScopedBlock(instance); + + temp.pr( + String.join( + "\n", + "// Add action " + action.getFullName() + " to array of is_present fields.", + "_lf_is_present_fields[" + startTimeStepIsPresentCount + "] ", + " = &" + + containerSelfStructName + + "->_lf_" + + action.getName() + + ".is_present;")); + + // Intended_tag is only applicable to actions in federated execution with decentralized + // coordination. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + String.join( + "\n", + "// Add action " + action.getFullName() + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + startTimeStepIsPresentCount + "] ", + " = &" + + containerSelfStructName + + "->_lf_" + + action.getName() + + ".intended_tag;"))); + + startTimeStepIsPresentCount += action.getParent().getTotalWidth(); + temp.endScopedBlock(); + } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; + + // Next, set up the table to mark each output of each contained reactor absent. + for (ReactorInstance child : instance.children) { + if (child.outputs.size() > 0) { - temp.pr(String.join("\n", - "// Add action "+action.getFullName()+" to array of is_present fields.", - "_lf_is_present_fields["+startTimeStepIsPresentCount+"] ", - " = &"+containerSelfStructName+"->_lf_"+action.getName()+".is_present;" - )); + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(child); - // Intended_tag is only applicable to actions in federated execution with decentralized coordination. + var channelCount = 0; + for (PortInstance output : child.outputs) { + if (!output.getDependsOnReactions().isEmpty()) { + foundOne = true; + temp.pr("// Add port " + output.getFullName() + " to array of is_present fields."); + temp.startChannelIteration(output); + temp.pr( + "_lf_is_present_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + CUtil.portRef(output) + + ".is_present;"); + + // Intended_tag is only applicable to ports in federated execution with decentralized + // coordination. temp.pr( CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join("\n", - "// Add action " + action.getFullName() - + " to array of intended_tag fields.", - "_lf_intended_tag_fields[" - + startTimeStepIsPresentCount + "] ", - " = &" + containerSelfStructName - + "->_lf_" + action.getName() - + ".intended_tag;" - ))); - - startTimeStepIsPresentCount += action.getParent().getTotalWidth(); - temp.endScopedBlock(); - } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; - - // Next, set up the table to mark each output of each contained reactor absent. - for (ReactorInstance child : instance.children) { - if (child.outputs.size() > 0) { - - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(child); - - var channelCount = 0; - for (PortInstance output : child.outputs) { - if (!output.getDependsOnReactions().isEmpty()){ - foundOne = true; - temp.pr("// Add port "+output.getFullName()+" to array of is_present fields."); - temp.startChannelIteration(output); - temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".is_present;"); - - // Intended_tag is only applicable to ports in federated execution with decentralized coordination. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join("\n", - "// Add port "+output.getFullName()+" to array of intended_tag fields.", - "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".intended_tag;" - ))); - - temp.pr("count++;"); - channelCount += output.getWidth(); - temp.endChannelIteration(output); - } - } - startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); - temp.endScopedBlock(); - temp.endScopedBlock(); - } + String.join( + "\n", + "// Add port " + output.getFullName() + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + CUtil.portRef(output) + + ".intended_tag;"))); + + temp.pr("count++;"); + channelCount += output.getWidth(); + temp.endChannelIteration(output); + } } - if (foundOne) startTimeStep.pr(temp.toString()); + startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); + temp.endScopedBlock(); + temp.endScopedBlock(); + } } + if (foundOne) startTimeStep.pr(temp.toString()); + } - /** - * For each timer in the given reactor, generate initialization code for the offset - * and period fields. - * - * This method will also populate the global _lf_timer_triggers array, which is - * used to start all timers at the start of execution. - * - * @param instance A reactor instance. - */ - private void generateTimerInitializations(ReactorInstance instance) { - for (TimerInstance timer : instance.timers) { - if (!timer.isStartup()) { - initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); - timerCount += timer.getParent().getTotalWidth(); - } - } + /** + * For each timer in the given reactor, generate initialization code for the offset and period + * fields. + * + *

This method will also populate the global _lf_timer_triggers array, which is used to start + * all timers at the start of execution. + * + * @param instance A reactor instance. + */ + private void generateTimerInitializations(ReactorInstance instance) { + for (TimerInstance timer : instance.timers) { + if (!timer.isStartup()) { + initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); + timerCount += timer.getParent().getTotalWidth(); + } } + } - /** - * Process a given .proto file. - * - * Run, if possible, the proto-c protocol buffer code generator to produce - * the required .h and .c files. - * @param filename Name of the file to process. - */ - public void processProtoFile(String filename) { - var protoc = commandFactory.createCommand( + /** + * Process a given .proto file. + * + *

Run, if possible, the proto-c protocol buffer code generator to produce the required .h and + * .c files. + * + * @param filename Name of the file to process. + */ + public void processProtoFile(String filename) { + var protoc = + commandFactory.createCommand( "protoc-c", - List.of("--c_out="+this.fileConfig.getSrcGenPath(), filename), + List.of("--c_out=" + this.fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); - return; - } - var returnCode = protoc.run(); - if (returnCode == 0) { - var nameSansProto = filename.substring(0, filename.length() - 6); - targetConfig.compileAdditionalSources.add( - fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString() - ); - - targetConfig.compileLibraries.add("-l"); - targetConfig.compileLibraries.add("protobuf-c"); - targetConfig.compilerFlags.add("-lprotobuf-c"); - } else { - errorReporter.reportError("protoc-c returns error code " + returnCode); - } + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); + return; } - - /** - * Construct a unique type for the struct of the specified - * typed variable (port or action) of the specified reactor class. - * This is required to be the same as the type name returned by - * {@link #variableStructType(TriggerInstance)}. - */ - public static String variableStructType(Variable variable, Reactor reactor, boolean userFacing) { - return (userFacing ? reactor.getName().toLowerCase() : CUtil.getName(reactor)) +"_"+variable.getName()+"_t"; - } - - /** - * Construct a unique type for the struct of the specified - * instance (port or action). - * This is required to be the same as the type name returned by - * {@link #variableStructType(Variable, Reactor, boolean)}. - * @param portOrAction The port or action instance. - * @return The name of the self struct. - */ - public static String variableStructType(TriggerInstance portOrAction) { - return CUtil.getName(portOrAction.getParent().reactorDefinition)+"_"+portOrAction.getName()+"_t"; + var returnCode = protoc.run(); + if (returnCode == 0) { + var nameSansProto = filename.substring(0, filename.length() - 6); + targetConfig.compileAdditionalSources.add( + fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString()); + + targetConfig.compileLibraries.add("-l"); + targetConfig.compileLibraries.add("protobuf-c"); + targetConfig.compilerFlags.add("-lprotobuf-c"); + } else { + errorReporter.reportError("protoc-c returns error code " + returnCode); } + } - /** - * If tracing is turned on, then generate code that records - * the full name of the specified reactor instance in the - * trace table. If tracing is not turned on, do nothing. - * @param instance The reactor instance. - */ - private void generateTraceTableEntries(ReactorInstance instance) { - if (targetConfig.tracing != null) { - initializeTriggerObjects.pr( - CTracingGenerator.generateTraceTableEntries(instance) - ); - } - } + /** + * Construct a unique type for the struct of the specified typed variable (port or action) of the + * specified reactor class. This is required to be the same as the type name returned by {@link + * #variableStructType(TriggerInstance)}. + */ + public static String variableStructType(Variable variable, Reactor reactor, boolean userFacing) { + return (userFacing ? reactor.getName().toLowerCase() : CUtil.getName(reactor)) + + "_" + + variable.getName() + + "_t"; + } - /** - * Generate code to instantiate the specified reactor instance and - * initialize it. - * @param instance A reactor instance. - */ - public void generateReactorInstance(ReactorInstance instance) { - var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); - var fullName = instance.getFullName(); - initializeTriggerObjects.pr( - "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); - // Generate the instance self struct containing parameters, state variables, - // and outputs (the "self" struct). - initializeTriggerObjects.pr(CUtil.reactorRefName(instance)+"["+CUtil.runtimeIndex(instance)+"] = new_"+CUtil.getName(reactorClass)+"();"); - // Generate code to initialize the "self" struct in the - // _lf_initialize_trigger_objects function. - generateTraceTableEntries(instance); - generateReactorInstanceExtension(instance); - generateParameterInitialization(instance); - initializeOutputMultiports(instance); - initializeInputMultiports(instance); - recordBuiltinTriggers(instance); - recordWatchdogs(instance); - - // Next, initialize the "self" struct with state variables. - // These values may be expressions that refer to the parameter values defined above. - generateStateVariableInitializations(instance); - - // Generate trigger objects for the instance. - generateTimerInitializations(instance); - generateActionInitializations(instance); - generateInitializeActionToken(instance); - generateSetDeadline(instance); - generateModeStructure(instance); - - // Recursively generate code for the children. - for (ReactorInstance child : instance.children) { - // If this reactor is a placeholder for a bank of reactors, then generate - // an array of instances of reactors and create an enclosing for loop. - // Need to do this for each of the builders into which the code writes. - startTimeStep.startScopedBlock(child); - initializeTriggerObjects.startScopedBlock(child); - generateReactorInstance(child); - initializeTriggerObjects.endScopedBlock(); - startTimeStep.endScopedBlock(); - } + /** + * Construct a unique type for the struct of the specified instance (port or action). This is + * required to be the same as the type name returned by {@link #variableStructType(Variable, + * Reactor, boolean)}. + * + * @param portOrAction The port or action instance. + * @return The name of the self struct. + */ + public static String variableStructType(TriggerInstance portOrAction) { + return CUtil.getName(portOrAction.getParent().reactorDefinition) + + "_" + + portOrAction.getName() + + "_t"; + } - // For this instance, define what must be done at the start of - // each time step. This sets up the tables that are used by the - // _lf_start_time_step() function in reactor_common.c. - // Note that this function is also run once at the end - // so that it can deallocate any memory. - generateStartTimeStep(instance); - initializeTriggerObjects.pr("//***** End initializing " + fullName); + /** + * If tracing is turned on, then generate code that records the full name of the specified reactor + * instance in the trace table. If tracing is not turned on, do nothing. + * + * @param instance The reactor instance. + */ + private void generateTraceTableEntries(ReactorInstance instance) { + if (targetConfig.tracing != null) { + initializeTriggerObjects.pr(CTracingGenerator.generateTraceTableEntries(instance)); } + } - /** - * For each action of the specified reactor instance, generate initialization code - * for the offset and period fields. - * @param instance The reactor. - */ - private void generateActionInitializations(ReactorInstance instance) { - initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + /** + * Generate code to instantiate the specified reactor instance and initialize it. + * + * @param instance A reactor instance. + */ + public void generateReactorInstance(ReactorInstance instance) { + var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); + var fullName = instance.getFullName(); + initializeTriggerObjects.pr( + "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); + // Generate the instance self struct containing parameters, state variables, + // and outputs (the "self" struct). + initializeTriggerObjects.pr( + CUtil.reactorRefName(instance) + + "[" + + CUtil.runtimeIndex(instance) + + "] = new_" + + CUtil.getName(reactorClass) + + "();"); + // Generate code to initialize the "self" struct in the + // _lf_initialize_trigger_objects function. + generateTraceTableEntries(instance); + generateReactorInstanceExtension(instance); + generateParameterInitialization(instance); + initializeOutputMultiports(instance); + initializeInputMultiports(instance); + recordBuiltinTriggers(instance); + recordWatchdogs(instance); + + // Next, initialize the "self" struct with state variables. + // These values may be expressions that refer to the parameter values defined above. + generateStateVariableInitializations(instance); + + // Generate trigger objects for the instance. + generateTimerInitializations(instance); + generateActionInitializations(instance); + generateInitializeActionToken(instance); + generateSetDeadline(instance); + generateModeStructure(instance); + + // Recursively generate code for the children. + for (ReactorInstance child : instance.children) { + // If this reactor is a placeholder for a bank of reactors, then generate + // an array of instances of reactors and create an enclosing for loop. + // Need to do this for each of the builders into which the code writes. + startTimeStep.startScopedBlock(child); + initializeTriggerObjects.startScopedBlock(child); + generateReactorInstance(child); + initializeTriggerObjects.endScopedBlock(); + startTimeStep.endScopedBlock(); } - /** - * Initialize actions by creating a lf_token_t in the self struct. - * This has the information required to allocate memory for the action payload. - * Skip any action that is not actually used as a trigger. - * @param reactor The reactor containing the actions. - */ - private void generateInitializeActionToken(ReactorInstance reactor) { - for (ActionInstance action : reactor.actions) { - // Skip this step if the action is not in use. - if (action.getParent().getTriggers().contains(action) - ) { - var type = getInferredType(action.getDefinition()); - var payloadSize = "0"; - if (!type.isUndefined()) { - var typeStr = types.getTargetType(type); - if (CUtil.isTokenType(type, types)) { - typeStr = CUtil.rootType(typeStr); - } - if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { - payloadSize = "sizeof("+typeStr+")"; - } - } - - var selfStruct = CUtil.reactorRef(action.getParent()); - initializeTriggerObjects.pr( - CActionGenerator.generateTokenInitializer( - selfStruct, action.getName(), payloadSize - ) - ); - } - } - } + // For this instance, define what must be done at the start of + // each time step. This sets up the tables that are used by the + // _lf_start_time_step() function in reactor_common.c. + // Note that this function is also run once at the end + // so that it can deallocate any memory. + generateStartTimeStep(instance); + initializeTriggerObjects.pr("//***** End initializing " + fullName); + } - /** - * Generate code that is executed while the reactor instance is being initialized. - * This is provided as an extension point for subclasses. - * Normally, the reactions argument is the full list of reactions, - * but for the top-level of a federate, will be a subset of reactions that - * is relevant to the federate. - * @param instance The reactor instance. - */ - protected void generateReactorInstanceExtension(ReactorInstance instance) { - // Do nothing - } + /** + * For each action of the specified reactor instance, generate initialization code for the offset + * and period fields. + * + * @param instance The reactor. + */ + private void generateActionInitializations(ReactorInstance instance) { + initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + } - /** - * Generate code that initializes the state variables for a given instance. - * Unlike parameters, state variables are uniformly initialized for all instances - * of the same reactor. - * @param instance The reactor class instance - */ - protected void generateStateVariableInitializations(ReactorInstance instance) { - var reactorClass = instance.getDefinition().getReactorClass(); - var selfRef = CUtil.reactorRef(instance); - for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { - if (isInitialized(stateVar)) { - var mode = stateVar.eContainer() instanceof Mode ? - instance.lookupModeInstance((Mode) stateVar.eContainer()) : - instance.getMode(false); - initializeTriggerObjects.pr(CStateGenerator.generateInitializer( - instance, - selfRef, - stateVar, - mode, - types - )); - if (mode != null && stateVar.isReset()) { - modalStateResetCount += instance.getTotalWidth(); - } - } + /** + * Initialize actions by creating a lf_token_t in the self struct. This has the information + * required to allocate memory for the action payload. Skip any action that is not actually used + * as a trigger. + * + * @param reactor The reactor containing the actions. + */ + private void generateInitializeActionToken(ReactorInstance reactor) { + for (ActionInstance action : reactor.actions) { + // Skip this step if the action is not in use. + if (action.getParent().getTriggers().contains(action)) { + var type = getInferredType(action.getDefinition()); + var payloadSize = "0"; + if (!type.isUndefined()) { + var typeStr = types.getTargetType(type); + if (CUtil.isTokenType(type, types)) { + typeStr = CUtil.rootType(typeStr); + } + if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { + payloadSize = "sizeof(" + typeStr + ")"; + } } - } - /** - * Generate code to set the deadline field of the reactions in the - * specified reactor instance. - * @param instance The reactor instance. - */ - private void generateSetDeadline(ReactorInstance instance) { - for (ReactionInstance reaction : instance.reactions) { - var selfRef = CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+reaction.index; - if (reaction.declaredDeadline != null) { - var deadline = reaction.declaredDeadline.maxDelay; - initializeTriggerObjects.pr(selfRef+".deadline = "+types.getTargetTimeExpr(deadline)+";"); - } else { // No deadline. - initializeTriggerObjects.pr(selfRef+".deadline = NEVER;"); - } - } + var selfStruct = CUtil.reactorRef(action.getParent()); + initializeTriggerObjects.pr( + CActionGenerator.generateTokenInitializer(selfStruct, action.getName(), payloadSize)); + } } + } - /** - * Generate code to initialize modes. - * @param instance The reactor instance. - */ - private void generateModeStructure(ReactorInstance instance) { - CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); - if (!instance.modes.isEmpty()) { - modalReactorCount += instance.getTotalWidth(); + /** + * Generate code that is executed while the reactor instance is being initialized. This is + * provided as an extension point for subclasses. Normally, the reactions argument is the full + * list of reactions, but for the top-level of a federate, will be a subset of reactions that is + * relevant to the federate. + * + * @param instance The reactor instance. + */ + protected void generateReactorInstanceExtension(ReactorInstance instance) { + // Do nothing + } + + /** + * Generate code that initializes the state variables for a given instance. Unlike parameters, + * state variables are uniformly initialized for all instances of the same reactor. + * + * @param instance The reactor class instance + */ + protected void generateStateVariableInitializations(ReactorInstance instance) { + var reactorClass = instance.getDefinition().getReactorClass(); + var selfRef = CUtil.reactorRef(instance); + for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { + if (isInitialized(stateVar)) { + var mode = + stateVar.eContainer() instanceof Mode + ? instance.lookupModeInstance((Mode) stateVar.eContainer()) + : instance.getMode(false); + initializeTriggerObjects.pr( + CStateGenerator.generateInitializer(instance, selfRef, stateVar, mode, types)); + if (mode != null && stateVar.isReset()) { + modalStateResetCount += instance.getTotalWidth(); } + } } + } - /** - * Generate runtime initialization code for parameters of a given reactor instance - * @param instance The reactor instance. - */ - protected void generateParameterInitialization(ReactorInstance instance) { - var selfRef = CUtil.reactorRef(instance); - // Set the local bank_index variable so that initializers can use it. - initializeTriggerObjects.pr("bank_index = "+CUtil.bankIndex(instance)+";" - + " SUPPRESS_UNUSED_WARNING(bank_index);"); - for (ParameterInstance parameter : instance.parameters) { - // NOTE: we now use the resolved literal value. For better efficiency, we could - // store constants in a global array and refer to its elements to avoid duplicate - // memory allocations. - // NOTE: If the parameter is initialized with a static initializer for an array - // or struct (the initialization expression is surrounded by { ... }), then we - // have to declare a static variable to ensure that the memory is put in data space - // and not on the stack. - // FIXME: Is there a better way to determine this than the string comparison? - var initializer = CParameterGenerator.getInitializer(parameter); - if (initializer.startsWith("{")) { - var temporaryVariableName = parameter.uniqueID(); - initializeTriggerObjects.pr(String.join("\n", - "static "+types.getVariableDeclaration(parameter.type, temporaryVariableName, true)+" = "+initializer+";", - selfRef+"->"+parameter.getName()+" = "+temporaryVariableName+";" - )); - } else { - initializeTriggerObjects.pr(selfRef+"->"+parameter.getName()+" = "+initializer+";"); - } - } + /** + * Generate code to set the deadline field of the reactions in the specified reactor instance. + * + * @param instance The reactor instance. + */ + private void generateSetDeadline(ReactorInstance instance) { + for (ReactionInstance reaction : instance.reactions) { + var selfRef = CUtil.reactorRef(reaction.getParent()) + "->_lf__reaction_" + reaction.index; + if (reaction.declaredDeadline != null) { + var deadline = reaction.declaredDeadline.maxDelay; + initializeTriggerObjects.pr( + selfRef + ".deadline = " + types.getTargetTimeExpr(deadline) + ";"); + } else { // No deadline. + initializeTriggerObjects.pr(selfRef + ".deadline = NEVER;"); + } } + } - /** - * Generate code that mallocs memory for any output multiports. - * @param reactor The reactor instance. - */ - private void initializeOutputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance output : reactor.outputs) { - initializeTriggerObjects.pr(CPortGenerator.initializeOutputMultiport( - output, - reactorSelfStruct - )); - } + /** + * Generate code to initialize modes. + * + * @param instance The reactor instance. + */ + private void generateModeStructure(ReactorInstance instance) { + CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); + if (!instance.modes.isEmpty()) { + modalReactorCount += instance.getTotalWidth(); } + } - /** - * Allocate memory for inputs. - * @param reactor The reactor. - */ - private void initializeInputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance input : reactor.inputs) { - initializeTriggerObjects.pr(CPortGenerator.initializeInputMultiport( - input, - reactorSelfStruct - )); - } + /** + * Generate runtime initialization code for parameters of a given reactor instance + * + * @param instance The reactor instance. + */ + protected void generateParameterInitialization(ReactorInstance instance) { + var selfRef = CUtil.reactorRef(instance); + // Set the local bank_index variable so that initializers can use it. + initializeTriggerObjects.pr( + "bank_index = " + + CUtil.bankIndex(instance) + + ";" + + " SUPPRESS_UNUSED_WARNING(bank_index);"); + for (ParameterInstance parameter : instance.parameters) { + // NOTE: we now use the resolved literal value. For better efficiency, we could + // store constants in a global array and refer to its elements to avoid duplicate + // memory allocations. + // NOTE: If the parameter is initialized with a static initializer for an array + // or struct (the initialization expression is surrounded by { ... }), then we + // have to declare a static variable to ensure that the memory is put in data space + // and not on the stack. + // FIXME: Is there a better way to determine this than the string comparison? + var initializer = CParameterGenerator.getInitializer(parameter); + if (initializer.startsWith("{")) { + var temporaryVariableName = parameter.uniqueID(); + initializeTriggerObjects.pr( + String.join( + "\n", + "static " + + types.getVariableDeclaration(parameter.type, temporaryVariableName, true) + + " = " + + initializer + + ";", + selfRef + "->" + parameter.getName() + " = " + temporaryVariableName + ";")); + } else { + initializeTriggerObjects.pr( + selfRef + "->" + parameter.getName() + " = " + initializer + ";"); + } } + } - @Override - public TargetTypes getTargetTypes() { - return types; + /** + * Generate code that mallocs memory for any output multiports. + * + * @param reactor The reactor instance. + */ + private void initializeOutputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance output : reactor.outputs) { + initializeTriggerObjects.pr( + CPortGenerator.initializeOutputMultiport(output, reactorSelfStruct)); } + } - /** - * - * @param context - * @return - */ - protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new CDockerGenerator(context); + /** + * Allocate memory for inputs. + * + * @param reactor The reactor. + */ + private void initializeInputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance input : reactor.inputs) { + initializeTriggerObjects.pr( + CPortGenerator.initializeInputMultiport(input, reactorSelfStruct)); } + } - // ////////////////////////////////////////// - // // Protected methods. + @Override + public TargetTypes getTargetTypes() { + return types; + } - // Perform set up that does not generate code - protected void setUpGeneralParameters() { - accommodatePhysicalActionsIfPresent(); - targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); - targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); - // Create the main reactor instance if there is a main reactor. - createMainReactorInstance(); - if (hasModalReactors) { - // So that each separate compile knows about modal reactors, do this: - targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); - } - if (targetConfig.threading && targetConfig.platformOptions.platform == Platform.ARDUINO - && (targetConfig.platformOptions.board == null || !targetConfig.platformOptions.board.contains("mbed"))) { - //non-MBED boards should not use threading - System.out.println("Threading is incompatible on your current Arduino flavor. Setting threading to false."); - targetConfig.threading = false; - } + /** + * @param context + * @return + */ + protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new CDockerGenerator(context); + } - if (targetConfig.platformOptions.platform == Platform.ARDUINO && !targetConfig.noCompile - && targetConfig.platformOptions.board == null) { - System.out.println("To enable compilation for the Arduino platform, you must specify the fully-qualified board name (FQBN) in the target property. For example, platform: {name: arduino, board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target code only."); - targetConfig.noCompile = true; - } - if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake - pickScheduler(); - // FIXME: this and pickScheduler should be combined. - targetConfig.compileDefinitions.put( - "SCHEDULER", - targetConfig.schedulerType.name() - ); - targetConfig.compileDefinitions.put( - "NUMBER_OF_WORKERS", - String.valueOf(targetConfig.workers) - ); - } - pickCompilePlatform(); + // ////////////////////////////////////////// + // // Protected methods. + + // Perform set up that does not generate code + protected void setUpGeneralParameters() { + accommodatePhysicalActionsIfPresent(); + targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); + targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); + // Create the main reactor instance if there is a main reactor. + createMainReactorInstance(); + if (hasModalReactors) { + // So that each separate compile knows about modal reactors, do this: + targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); } - - protected void handleProtoFiles() { - // Handle .proto files. - for (String file : targetConfig.protoFiles) { - this.processProtoFile(file); - } + if (targetConfig.threading + && targetConfig.platformOptions.platform == Platform.ARDUINO + && (targetConfig.platformOptions.board == null + || !targetConfig.platformOptions.board.contains("mbed"))) { + // non-MBED boards should not use threading + System.out.println( + "Threading is incompatible on your current Arduino flavor. Setting threading to false."); + targetConfig.threading = false; } - /** - * Generate code that needs to appear at the top of the generated - * C file, such as #define and #include statements. - */ - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr(CPreambleGenerator.generateDefineDirectives( - targetConfig, - fileConfig.getSrcGenPath(), - hasModalReactors - )); - code.pr(CPreambleGenerator.generateIncludeStatements( - targetConfig, - CCppMode - )); - return code.toString(); + if (targetConfig.platformOptions.platform == Platform.ARDUINO + && !targetConfig.noCompile + && targetConfig.platformOptions.board == null) { + System.out.println( + "To enable compilation for the Arduino platform, you must specify the fully-qualified" + + " board name (FQBN) in the target property. For example, platform: {name: arduino," + + " board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target" + + " code only."); + targetConfig.noCompile = true; } - - /** - * Generate top-level preamble code. - */ - protected String generateTopLevelPreambles(Reactor reactor) { - CodeBuilder builder = new CodeBuilder(); - var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; - builder.pr("#ifndef " + guard); - builder.pr("#define " + guard); - Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) - .flatMap(it -> ((Model) it.eContainer()).getPreambles().stream()) - .collect(Collectors.toSet()) - .forEach(it -> builder.pr(toText(it.getCode()))); - for (String file : targetConfig.protoFiles) { - var dotIndex = file.lastIndexOf("."); - var rootFilename = file; - if (dotIndex > 0) { - rootFilename = file.substring(0, dotIndex); - } - code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); - builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); - } - builder.pr("#endif"); - return builder.toString(); + if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake + pickScheduler(); + // FIXME: this and pickScheduler should be combined. + targetConfig.compileDefinitions.put("SCHEDULER", targetConfig.schedulerType.name()); + targetConfig.compileDefinitions.put( + "NUMBER_OF_WORKERS", String.valueOf(targetConfig.workers)); } + pickCompilePlatform(); + } - protected boolean targetLanguageIsCpp() { - return CCppMode; + protected void handleProtoFiles() { + // Handle .proto files. + for (String file : targetConfig.protoFiles) { + this.processProtoFile(file); } + } - /** Given a line of text from the output of a compiler, return - * an instance of ErrorFileAndLine if the line is recognized as - * the first line of an error message. Otherwise, return null. - * @param line A line of output from a compiler or other external - * tool that might generate errors. - * @return If the line is recognized as the start of an error message, - * then return a class containing the path to the file on which the - * error occurred (or null if there is none), the line number (or the - * string "1" if there is none), the character position (or the string - * "0" if there is none), and the message (or an empty string if there - * is none). - */ - @Override - public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { - var matcher = compileErrorPattern.matcher(line); - if (matcher.find()) { - var result = new ErrorFileAndLine(); - result.filepath = matcher.group("path"); - result.line = matcher.group("line"); - result.character = matcher.group("column"); - result.message = matcher.group("message"); - - if (!result.message.toLowerCase().contains("error:")) { - result.isError = false; - } - return result; - } - return null; - } + /** + * Generate code that needs to appear at the top of the generated C file, such as #define and + * #include statements. + */ + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr( + CPreambleGenerator.generateDefineDirectives( + targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); + code.pr(CPreambleGenerator.generateIncludeStatements(targetConfig, CCppMode)); + return code.toString(); + } - //////////////////////////////////////////// - //// Private methods. - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.C; + /** Generate top-level preamble code. */ + protected String generateTopLevelPreambles(Reactor reactor) { + CodeBuilder builder = new CodeBuilder(); + var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; + builder.pr("#ifndef " + guard); + builder.pr("#define " + guard); + Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) + .flatMap(it -> ((Model) it.eContainer()).getPreambles().stream()) + .collect(Collectors.toSet()) + .forEach(it -> builder.pr(toText(it.getCode()))); + for (String file : targetConfig.protoFiles) { + var dotIndex = file.lastIndexOf("."); + var rootFilename = file; + if (dotIndex > 0) { + rootFilename = file.substring(0, dotIndex); + } + code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); + builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); } + builder.pr("#endif"); + return builder.toString(); + } - //////////////////////////////////////////////////////////// - //// Private methods - - /** - * If a main or federated reactor has been declared, create a ReactorInstance - * for this top level. This will also assign levels to reactions, then, - * if the program is federated, perform an AST transformation to disconnect - * connections between federates. - */ - private void createMainReactorInstance() { - if (this.mainDef != null) { - if (this.main == null) { - // Recursively build instances. - this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); - var reactionInstanceGraph = this.main.assignLevels(); - if (reactionInstanceGraph.nodeCount() > 0) { - errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); - return; - } - if (hasDeadlines) { - this.main.assignDeadlines(); - } - // Inform the run-time of the breadth/parallelism of the reaction graph - var breadth = reactionInstanceGraph.getBreadth(); - if (breadth == 0) { - errorReporter.reportWarning("The program has no reactions"); - } else { - targetConfig.compileDefinitions.put( - "LF_REACTION_GRAPH_BREADTH", - String.valueOf(reactionInstanceGraph.getBreadth()) - ); - } - } - } + protected boolean targetLanguageIsCpp() { + return CCppMode; + } + /** + * Given a line of text from the output of a compiler, return an instance of ErrorFileAndLine if + * the line is recognized as the first line of an error message. Otherwise, return null. + * + * @param line A line of output from a compiler or other external tool that might generate errors. + * @return If the line is recognized as the start of an error message, then return a class + * containing the path to the file on which the error occurred (or null if there is none), the + * line number (or the string "1" if there is none), the character position (or the string "0" + * if there is none), and the message (or an empty string if there is none). + */ + @Override + public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { + var matcher = compileErrorPattern.matcher(line); + if (matcher.find()) { + var result = new ErrorFileAndLine(); + result.filepath = matcher.group("path"); + result.line = matcher.group("line"); + result.character = matcher.group("column"); + result.message = matcher.group("message"); + + if (!result.message.toLowerCase().contains("error:")) { + result.isError = false; + } + return result; } + return null; + } + + //////////////////////////////////////////// + //// Private methods. + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.C; + } + + //////////////////////////////////////////////////////////// + //// Private methods - /** - * Generate an array of self structs for the reactor - * and one for each of its children. - * @param r The reactor instance. - */ - private void generateSelfStructs(ReactorInstance r) { - initializeTriggerObjects.pr(CUtil.selfType(r)+"* "+CUtil.reactorRefName(r)+"["+r.getTotalWidth()+"];"); - initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING("+CUtil.reactorRefName(r)+");"); - for (ReactorInstance child : r.children) { - generateSelfStructs(child); + /** + * If a main or federated reactor has been declared, create a ReactorInstance for this top level. + * This will also assign levels to reactions, then, if the program is federated, perform an AST + * transformation to disconnect connections between federates. + */ + private void createMainReactorInstance() { + if (this.mainDef != null) { + if (this.main == null) { + // Recursively build instances. + this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); + var reactionInstanceGraph = this.main.assignLevels(); + if (reactionInstanceGraph.nodeCount() > 0) { + errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); + return; + } + if (hasDeadlines) { + this.main.assignDeadlines(); } + // Inform the run-time of the breadth/parallelism of the reaction graph + var breadth = reactionInstanceGraph.getBreadth(); + if (breadth == 0) { + errorReporter.reportWarning("The program has no reactions"); + } else { + targetConfig.compileDefinitions.put( + "LF_REACTION_GRAPH_BREADTH", String.valueOf(reactionInstanceGraph.getBreadth())); + } + } } -} \ No newline at end of file + } + + /** + * Generate an array of self structs for the reactor and one for each of its children. + * + * @param r The reactor instance. + */ + private void generateSelfStructs(ReactorInstance r) { + initializeTriggerObjects.pr( + CUtil.selfType(r) + "* " + CUtil.reactorRefName(r) + "[" + r.getTotalWidth() + "];"); + initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING(" + CUtil.reactorRefName(r) + ");"); + for (ReactorInstance child : r.children) { + generateSelfStructs(child); + } + } +} diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 67a76eb0e2..dae1f01230 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -9,7 +9,6 @@ import java.util.List; import java.util.Map; import java.util.Set; - import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; @@ -38,1160 +37,1347 @@ import org.lflang.util.StringUtil; public class CReactionGenerator { - protected static String DISABLE_REACTION_INITIALIZATION_MARKER - = "// **** Do not include initialization code in this reaction."; // FIXME: Such markers should not exist (#1687) + protected static String DISABLE_REACTION_INITIALIZATION_MARKER = + "// **** Do not include initialization code in this reaction."; // FIXME: Such markers should + // not exist (#1687) - /** - * Generate necessary initialization code inside the body of the reaction that belongs to reactor decl. - * @param body The body of the reaction. Used to check for the DISABLE_REACTION_INITIALIZATION_MARKER. - * @param reaction The initialization code will be generated for this specific reaction - * @param decl The reactor that has the reaction - * @param reactionIndex The index of the reaction relative to other reactions in the reactor, starting from 0 - */ - public static String generateInitializationForReaction(String body, - Reaction reaction, - Reactor decl, - int reactionIndex, - CTypes types, - ErrorReporter errorReporter, - Instantiation mainDef, - boolean requiresTypes) { - Reactor reactor = ASTUtils.toDefinition(decl); + /** + * Generate necessary initialization code inside the body of the reaction that belongs to reactor + * decl. + * + * @param body The body of the reaction. Used to check for the + * DISABLE_REACTION_INITIALIZATION_MARKER. + * @param reaction The initialization code will be generated for this specific reaction + * @param decl The reactor that has the reaction + * @param reactionIndex The index of the reaction relative to other reactions in the reactor, + * starting from 0 + */ + public static String generateInitializationForReaction( + String body, + Reaction reaction, + Reactor decl, + int reactionIndex, + CTypes types, + ErrorReporter errorReporter, + Instantiation mainDef, + boolean requiresTypes) { + Reactor reactor = ASTUtils.toDefinition(decl); - // Construct the reactionInitialization code to go into - // the body of the function before the verbatim code. - CodeBuilder reactionInitialization = new CodeBuilder(); + // Construct the reactionInitialization code to go into + // the body of the function before the verbatim code. + CodeBuilder reactionInitialization = new CodeBuilder(); - CodeBuilder code = new CodeBuilder(); + CodeBuilder code = new CodeBuilder(); - // Define the "self" struct. - String structType = CUtil.selfType(decl); - // A null structType means there are no inputs, state, - // or anything else. No need to declare it. - if (structType != null) { - code.pr(String.join("\n", - structType+"* self = ("+structType+"*)instance_args; SUPPRESS_UNUSED_WARNING(self);" - )); - } + // Define the "self" struct. + String structType = CUtil.selfType(decl); + // A null structType means there are no inputs, state, + // or anything else. No need to declare it. + if (structType != null) { + code.pr( + String.join( + "\n", + structType + + "* self = (" + + structType + + "*)instance_args; SUPPRESS_UNUSED_WARNING(self);")); + } - // Do not generate the initialization code if the body is marked - // to not generate it. - if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { - return code.toString(); - } + // Do not generate the initialization code if the body is marked + // to not generate it. + if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { + return code.toString(); + } - // A reaction may send to or receive from multiple ports of - // a contained reactor. The variables for these ports need to - // all be declared as fields of the same struct. Hence, we first - // collect the fields to be defined in the structs and then - // generate the structs. - Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); + // A reaction may send to or receive from multiple ports of + // a contained reactor. The variables for these ports need to + // all be declared as fields of the same struct. Hence, we first + // collect the fields to be defined in the structs and then + // generate the structs. + Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); - // Actions may appear twice, first as a trigger, then with the outputs. - // But we need to declare it only once. Collect in this data structure - // the actions that are declared as triggered so that if they appear - // again with the outputs, they are not defined a second time. - // That second redefinition would trigger a compile error. - Set actionsAsTriggers = new LinkedHashSet<>(); + // Actions may appear twice, first as a trigger, then with the outputs. + // But we need to declare it only once. Collect in this data structure + // the actions that are declared as triggered so that if they appear + // again with the outputs, they are not defined a second time. + // That second redefinition would trigger a compile error. + Set actionsAsTriggers = new LinkedHashSet<>(); - // Next, add the triggers (input and actions; timers are not needed). - // This defines a local variable in the reaction function whose - // name matches that of the trigger. The value of the local variable - // is a struct with a value and is_present field, the latter a boolean - // that indicates whether the input/action is present. - // If the trigger is an output, then it is an output of a - // contained reactor. In this case, a struct with the name - // of the contained reactor is created with one field that is - // a pointer to a struct with a value and is_present field. - // E.g., if the contained reactor is named 'c' and its output - // port is named 'out', then c.out->value c.out->is_present are - // defined so that they can be used in the verbatim code. - for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (triggerAsVarRef.getVariable() instanceof Port) { - generatePortVariablesInReaction( - reactionInitialization, - fieldsForStructsForContainedReactors, - triggerAsVarRef, - decl, - types); - } else if (triggerAsVarRef.getVariable() instanceof Action) { - reactionInitialization.pr(generateActionVariablesInReaction( - (Action) triggerAsVarRef.getVariable(), - decl, - types - )); - actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); - } - } - } - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - // No triggers are given, which means react to any input. - // Declare an argument for every input. - // NOTE: this does not include contained outputs. - for (Input input : reactor.getInputs()) { - reactionInitialization.pr(generateInputVariablesInReaction(input, decl, types)); - } + // Next, add the triggers (input and actions; timers are not needed). + // This defines a local variable in the reaction function whose + // name matches that of the trigger. The value of the local variable + // is a struct with a value and is_present field, the latter a boolean + // that indicates whether the input/action is present. + // If the trigger is an output, then it is an output of a + // contained reactor. In this case, a struct with the name + // of the contained reactor is created with one field that is + // a pointer to a struct with a value and is_present field. + // E.g., if the contained reactor is named 'c' and its output + // port is named 'out', then c.out->value c.out->is_present are + // defined so that they can be used in the verbatim code. + for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (triggerAsVarRef.getVariable() instanceof Port) { + generatePortVariablesInReaction( + reactionInitialization, + fieldsForStructsForContainedReactors, + triggerAsVarRef, + decl, + types); + } else if (triggerAsVarRef.getVariable() instanceof Action) { + reactionInitialization.pr( + generateActionVariablesInReaction( + (Action) triggerAsVarRef.getVariable(), decl, types)); + actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); } - // Define argument for non-triggering inputs. - for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { - if (src.getVariable() instanceof Port) { - generatePortVariablesInReaction(reactionInitialization, fieldsForStructsForContainedReactors, src, decl, types); - } else if (src.getVariable() instanceof Action) { - // It's a bit odd to read but not be triggered by an action, but - // OK, I guess we allow it. - reactionInitialization.pr(generateActionVariablesInReaction( - (Action) src.getVariable(), - decl, - types - )); - actionsAsTriggers.add((Action) src.getVariable()); - } - } - - // Define variables for each declared output or action. - // In the case of outputs, the variable is a pointer to where the - // output is stored. This gives the reaction code access to any previous - // value that may have been written to that output in an earlier reaction. - if (reaction.getEffects() != null) { - for (VarRef effect : reaction.getEffects()) { - Variable variable = effect.getVariable(); - if (variable instanceof Action) { - // It is an action, not an output. - // If it has already appeared as trigger, do not redefine it. - if (!actionsAsTriggers.contains(effect.getVariable())) { - reactionInitialization.pr(CGenerator.variableStructType(variable, decl, false)+"* "+variable.getName()+" = &self->_lf_"+variable.getName()+";"); - } - } else if (effect.getVariable() instanceof Mode) { - // Mode change effect - int idx = ASTUtils.allModes(reactor).indexOf((Mode)effect.getVariable()); - String name = effect.getVariable().getName(); - if (idx >= 0) { - reactionInitialization.pr( - "reactor_mode_t* " + name + " = &self->_lf__modes[" + idx + "];\n" - + "lf_mode_change_type_t _lf_" + name + "_change_type = " - + (effect.getTransition() == ModeTransition.HISTORY ? - "history_transition" : "reset_transition") - + ";" - ); - } else { - errorReporter.reportError( - reaction, - "In generateReaction(): " + name + " not a valid mode of this reactor." - ); - } - } else { - if (variable instanceof Output) { - reactionInitialization.pr(generateOutputVariablesInReaction( - effect, - decl, - errorReporter, - requiresTypes - )); - } else if (variable instanceof Input) { - // It is the input of a contained reactor. - generateVariablesForSendingToContainedReactors( - reactionInitialization, - fieldsForStructsForContainedReactors, - effect.getContainer(), - (Input) variable - ); - } else if (variable instanceof Watchdog) { - reactionInitialization.pr(generateWatchdogVariablesInReaction( - effect, - decl - )); - } else { - errorReporter.reportError( - reaction, - "In generateReaction(): effect is neither an input nor an output." - ); - } - } - } - } - // Before the reaction initialization, - // generate the structs used for communication to and from contained reactors. - for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { - String array = ""; - if (containedReactor.getWidthSpec() != null) { - String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); - code.pr("int "+containedReactorWidthVar+" = self->_lf_"+containedReactorWidthVar+";"); - // Windows does not support variables in arrays declared on the stack, - // so we use the maximum size over all bank members. - array = "["+maxContainedReactorBankWidth(containedReactor, null, 0, mainDef)+"]"; - } - code.pr(String.join("\n", - "struct "+containedReactor.getName()+" {", - " "+fieldsForStructsForContainedReactors.get(containedReactor)+"", - "} "+containedReactor.getName()+array+";" - )); - } - // Next generate all the collected setup code. - code.pr(reactionInitialization.toString()); - return code.toString(); + } + } + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + // No triggers are given, which means react to any input. + // Declare an argument for every input. + // NOTE: this does not include contained outputs. + for (Input input : reactor.getInputs()) { + reactionInitialization.pr(generateInputVariablesInReaction(input, decl, types)); + } + } + // Define argument for non-triggering inputs. + for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { + if (src.getVariable() instanceof Port) { + generatePortVariablesInReaction( + reactionInitialization, fieldsForStructsForContainedReactors, src, decl, types); + } else if (src.getVariable() instanceof Action) { + // It's a bit odd to read but not be triggered by an action, but + // OK, I guess we allow it. + reactionInitialization.pr( + generateActionVariablesInReaction((Action) src.getVariable(), decl, types)); + actionsAsTriggers.add((Action) src.getVariable()); + } } - /** - * Return the maximum bank width for the given instantiation within all - * instantiations of its parent reactor. - * On the first call to this method, the breadcrumbs should be null and the max - * argument should be zero. On recursive calls, breadcrumbs is a list of nested - * instantiations, the max is the maximum width found so far. The search for - * instances of the parent reactor will begin with the last instantiation - * in the specified list. - * - * This rather complicated method is used when a reaction sends or receives data - * to or from a bank of contained reactors. There will be an array of structs on - * the self struct of the parent, and the size of the array is conservatively set - * to the maximum of all the identified bank widths. This is a bit wasteful of - * memory, but it avoids having to malloc the array for each instance, and in - * typical usage, there will be few instances or instances that are all the same - * width. - * - * @param containedReactor The contained reactor instantiation. - * @param breadcrumbs null on first call (non-recursive). - * @param max 0 on first call. - */ - public static int maxContainedReactorBankWidth( - Instantiation containedReactor, - LinkedList breadcrumbs, - int max, - Instantiation mainDef - ) { - // If the instantiation is not a bank, return 1. - if (containedReactor.getWidthSpec() == null) { - return 1; - } - // If there is no main, then we just use the default width. - if (mainDef == null) { - return ASTUtils.width(containedReactor.getWidthSpec(), null); - } - LinkedList nestedBreadcrumbs = breadcrumbs; - if (nestedBreadcrumbs == null) { - nestedBreadcrumbs = new LinkedList<>(); - nestedBreadcrumbs.add(mainDef); - } - int result = max; - Reactor parent = (Reactor) containedReactor.eContainer(); - if (parent == ASTUtils.toDefinition(mainDef.getReactorClass())) { - // The parent is main, so there can't be any other instantiations of it. - return ASTUtils.width(containedReactor.getWidthSpec(), null); - } - // Search for instances of the parent within the tail of the breadcrumbs list. - Reactor container = ASTUtils.toDefinition(nestedBreadcrumbs.get(0).getReactorClass()); - for (Instantiation instantiation : container.getInstantiations()) { - // Put this new instantiation at the head of the list. - nestedBreadcrumbs.add(0, instantiation); - if (ASTUtils.toDefinition(instantiation.getReactorClass()) == parent) { - // Found a matching instantiation of the parent. - // Evaluate the original width specification in this context. - int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); - if (candidate > result) { - result = candidate; - } - } else { - // Found some other instantiation, not the parent. - // Search within it for instantiations of the parent. - // Note that we assume here that the parent cannot contain - // instances of itself. - int candidate = maxContainedReactorBankWidth(containedReactor, nestedBreadcrumbs, result, mainDef); - if (candidate > result) { - result = candidate; - } - } - nestedBreadcrumbs.remove(); + // Define variables for each declared output or action. + // In the case of outputs, the variable is a pointer to where the + // output is stored. This gives the reaction code access to any previous + // value that may have been written to that output in an earlier reaction. + if (reaction.getEffects() != null) { + for (VarRef effect : reaction.getEffects()) { + Variable variable = effect.getVariable(); + if (variable instanceof Action) { + // It is an action, not an output. + // If it has already appeared as trigger, do not redefine it. + if (!actionsAsTriggers.contains(effect.getVariable())) { + reactionInitialization.pr( + CGenerator.variableStructType(variable, decl, false) + + "* " + + variable.getName() + + " = &self->_lf_" + + variable.getName() + + ";"); + } + } else if (effect.getVariable() instanceof Mode) { + // Mode change effect + int idx = ASTUtils.allModes(reactor).indexOf((Mode) effect.getVariable()); + String name = effect.getVariable().getName(); + if (idx >= 0) { + reactionInitialization.pr( + "reactor_mode_t* " + + name + + " = &self->_lf__modes[" + + idx + + "];\n" + + "lf_mode_change_type_t _lf_" + + name + + "_change_type = " + + (effect.getTransition() == ModeTransition.HISTORY + ? "history_transition" + : "reset_transition") + + ";"); + } else { + errorReporter.reportError( + reaction, "In generateReaction(): " + name + " not a valid mode of this reactor."); + } + } else { + if (variable instanceof Output) { + reactionInitialization.pr( + generateOutputVariablesInReaction(effect, decl, errorReporter, requiresTypes)); + } else if (variable instanceof Input) { + // It is the input of a contained reactor. + generateVariablesForSendingToContainedReactors( + reactionInitialization, + fieldsForStructsForContainedReactors, + effect.getContainer(), + (Input) variable); + } else if (variable instanceof Watchdog) { + reactionInitialization.pr(generateWatchdogVariablesInReaction(effect, decl)); + } else { + errorReporter.reportError( + reaction, "In generateReaction(): effect is neither an input nor an output."); + } } - return result; + } } - - /** - * Generate code for the body of a reaction that takes an input and - * schedules an action with the value of that input. - * @param actionName The action to schedule - */ - public static String generateDelayBody(String ref, String actionName, boolean isTokenType) { - // Note that the action.type set by the base class is actually - // the port type. - return isTokenType ? - String.join("\n", - "if ("+ref+"->is_present) {", - " // Put the whole token on the event queue, not just the payload.", - " // This way, the length and element_size are transported.", - " lf_schedule_token("+actionName+", 0, "+ref+"->token);", - "}" - ) : - "lf_schedule_copy("+actionName+", 0, &"+ref+"->value, 1); // Length is 1."; + // Before the reaction initialization, + // generate the structs used for communication to and from contained reactors. + for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { + String array = ""; + if (containedReactor.getWidthSpec() != null) { + String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); + code.pr( + "int " + containedReactorWidthVar + " = self->_lf_" + containedReactorWidthVar + ";"); + // Windows does not support variables in arrays declared on the stack, + // so we use the maximum size over all bank members. + array = "[" + maxContainedReactorBankWidth(containedReactor, null, 0, mainDef) + "]"; + } + code.pr( + String.join( + "\n", + "struct " + containedReactor.getName() + " {", + " " + fieldsForStructsForContainedReactors.get(containedReactor) + "", + "} " + containedReactor.getName() + array + ";")); } + // Next generate all the collected setup code. + code.pr(reactionInitialization.toString()); + return code.toString(); + } - public static String generateForwardBody(String outputName, String targetType, String actionName, boolean isTokenType) { - return isTokenType ? - String.join("\n", - DISABLE_REACTION_INITIALIZATION_MARKER, - "self->_lf_"+outputName+".value = ("+targetType+")self->_lf__"+actionName+".tmplt.token->value;", - "_lf_replace_template_token((token_template_t*)&self->_lf_"+outputName+", (lf_token_t*)self->_lf__"+actionName+".tmplt.token);", - "self->_lf_"+outputName+".is_present = true;" - ) : - "lf_set("+outputName+", "+actionName+"->value);"; + /** + * Return the maximum bank width for the given instantiation within all instantiations of its + * parent reactor. On the first call to this method, the breadcrumbs should be null and the max + * argument should be zero. On recursive calls, breadcrumbs is a list of nested instantiations, + * the max is the maximum width found so far. The search for instances of the parent reactor will + * begin with the last instantiation in the specified list. + * + *

This rather complicated method is used when a reaction sends or receives data to or from a + * bank of contained reactors. There will be an array of structs on the self struct of the parent, + * and the size of the array is conservatively set to the maximum of all the identified bank + * widths. This is a bit wasteful of memory, but it avoids having to malloc the array for each + * instance, and in typical usage, there will be few instances or instances that are all the same + * width. + * + * @param containedReactor The contained reactor instantiation. + * @param breadcrumbs null on first call (non-recursive). + * @param max 0 on first call. + */ + public static int maxContainedReactorBankWidth( + Instantiation containedReactor, + LinkedList breadcrumbs, + int max, + Instantiation mainDef) { + // If the instantiation is not a bank, return 1. + if (containedReactor.getWidthSpec() == null) { + return 1; } - - /** - * Generate into the specified string builder the code to - * initialize local variables for sending data to an input - * of a contained reactor. This will also, if necessary, - * generate entries for local struct definitions into the - * struct argument. These entries point to where the data - * is stored. - * - * @param builder The string builder. - * @param structs A map from reactor instantiations to a place to write - * struct fields. - * @param definition AST node defining the reactor within which this occurs - * @param input Input of the contained reactor. - */ - private static void generateVariablesForSendingToContainedReactors( - CodeBuilder builder, - Map structs, - Instantiation definition, - Input input - ) { - CodeBuilder structBuilder = structs.get(definition); - if (structBuilder == null) { - structBuilder = new CodeBuilder(); - structs.put(definition, structBuilder); + // If there is no main, then we just use the default width. + if (mainDef == null) { + return ASTUtils.width(containedReactor.getWidthSpec(), null); + } + LinkedList nestedBreadcrumbs = breadcrumbs; + if (nestedBreadcrumbs == null) { + nestedBreadcrumbs = new LinkedList<>(); + nestedBreadcrumbs.add(mainDef); + } + int result = max; + Reactor parent = (Reactor) containedReactor.eContainer(); + if (parent == ASTUtils.toDefinition(mainDef.getReactorClass())) { + // The parent is main, so there can't be any other instantiations of it. + return ASTUtils.width(containedReactor.getWidthSpec(), null); + } + // Search for instances of the parent within the tail of the breadcrumbs list. + Reactor container = ASTUtils.toDefinition(nestedBreadcrumbs.get(0).getReactorClass()); + for (Instantiation instantiation : container.getInstantiations()) { + // Put this new instantiation at the head of the list. + nestedBreadcrumbs.add(0, instantiation); + if (ASTUtils.toDefinition(instantiation.getReactorClass()) == parent) { + // Found a matching instantiation of the parent. + // Evaluate the original width specification in this context. + int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); + if (candidate > result) { + result = candidate; } - String inputStructType = CGenerator.variableStructType(input, ASTUtils.toDefinition(definition.getReactorClass()), false); - String defName = definition.getName(); - String defWidth = generateWidthVariable(defName); - String inputName = input.getName(); - String inputWidth = generateWidthVariable(inputName); - if (!ASTUtils.isMultiport(input)) { - // Contained reactor's input is not a multiport. - structBuilder.pr(inputStructType+"* "+inputName+";"); - if (definition.getWidthSpec() != null) { - // Contained reactor is a bank. - builder.pr(String.join("\n", - "for (int bankIndex = 0; bankIndex < self->_lf_"+defWidth+"; bankIndex++) {", - " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+defName+"[bankIndex]."+inputName+");", - "}" - )); - } else { - // Contained reactor is not a bank. - builder.pr(defName+"."+inputName+" = &(self->_lf_"+defName+"."+inputName+");"); - } - } else { - // Contained reactor's input is a multiport. - structBuilder.pr(String.join("\n", - inputStructType+"** "+inputName+";", - "int "+inputWidth+";" - )); - // If the contained reactor is a bank, then we have to set the - // pointer for each element of the bank. - if (definition.getWidthSpec() != null) { - builder.pr(String.join("\n", - "for (int _i = 0; _i < self->_lf_"+defWidth+"; _i++) {", - " "+defName+"[_i]."+inputName+" = self->_lf_"+defName+"[_i]."+inputName+";", - " "+defName+"[_i]."+inputWidth+" = self->_lf_"+defName+"[_i]."+inputWidth+";", - "}" - )); - } else { - builder.pr(String.join("\n", - defName+"."+inputName+" = self->_lf_"+defName+"."+inputName+";", - defName+"."+inputWidth+" = self->_lf_"+defName+"."+inputWidth+";" - )); - } + } else { + // Found some other instantiation, not the parent. + // Search within it for instantiations of the parent. + // Note that we assume here that the parent cannot contain + // instances of itself. + int candidate = + maxContainedReactorBankWidth(containedReactor, nestedBreadcrumbs, result, mainDef); + if (candidate > result) { + result = candidate; } + } + nestedBreadcrumbs.remove(); } + return result; + } - /** - * Generate into the specified string builder the code to - * initialize local variables for ports in a reaction function - * from the "self" struct. The port may be an input of the - * reactor or an output of a contained reactor. The second - * argument provides, for each contained reactor, a place to - * write the declaration of the output of that reactor that - * is triggering reactions. - * @param builder The place into which to write the code. - * @param structs A map from reactor instantiations to a place to write - * struct fields. - */ - private static void generatePortVariablesInReaction( - CodeBuilder builder, - Map structs, - VarRef port, - Reactor r, - CTypes types - ) { - if (port.getVariable() instanceof Input) { - builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), r, types)); - } else { - // port is an output of a contained reactor. - Output output = (Output) port.getVariable(); - String portStructType = CGenerator.variableStructType(output, ASTUtils.toDefinition(port.getContainer().getReactorClass()), false); + /** + * Generate code for the body of a reaction that takes an input and schedules an action with the + * value of that input. + * + * @param actionName The action to schedule + */ + public static String generateDelayBody(String ref, String actionName, boolean isTokenType) { + // Note that the action.type set by the base class is actually + // the port type. + return isTokenType + ? String.join( + "\n", + "if (" + ref + "->is_present) {", + " // Put the whole token on the event queue, not just the payload.", + " // This way, the length and element_size are transported.", + " lf_schedule_token(" + actionName + ", 0, " + ref + "->token);", + "}") + : "lf_schedule_copy(" + actionName + ", 0, &" + ref + "->value, 1); // Length is 1."; + } - CodeBuilder structBuilder = structs.get(port.getContainer()); - if (structBuilder == null) { - structBuilder = new CodeBuilder(); - structs.put(port.getContainer(), structBuilder); - } - String reactorName = port.getContainer().getName(); - String reactorWidth = generateWidthVariable(reactorName); - String outputName = output.getName(); - String outputWidth = generateWidthVariable(outputName); - // First define the struct containing the output value and indicator - // of its presence. - if (!ASTUtils.isMultiport(output)) { - // Output is not a multiport. - structBuilder.pr(portStructType+"* "+outputName+";"); - } else { - // Output is a multiport. - structBuilder.pr(String.join("\n", - portStructType+"** "+outputName+";", - "int "+outputWidth+";" - )); - } + public static String generateForwardBody( + String outputName, String targetType, String actionName, boolean isTokenType) { + return isTokenType + ? String.join( + "\n", + DISABLE_REACTION_INITIALIZATION_MARKER, + "self->_lf_" + + outputName + + ".value = (" + + targetType + + ")self->_lf__" + + actionName + + ".tmplt.token->value;", + "_lf_replace_template_token((token_template_t*)&self->_lf_" + + outputName + + ", (lf_token_t*)self->_lf__" + + actionName + + ".tmplt.token);", + "self->_lf_" + outputName + ".is_present = true;") + : "lf_set(" + outputName + ", " + actionName + "->value);"; + } - // Next, initialize the struct with the current values. - if (port.getContainer().getWidthSpec() != null) { - // Output is in a bank. - builder.pr(String.join("\n", - "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+reactorName+"[i]."+outputName+" = self->_lf_"+reactorName+"[i]."+outputName+";", - "}" - )); - if (ASTUtils.isMultiport(output)) { - builder.pr(String.join("\n", - "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+reactorName+"[i]."+outputWidth+" = self->_lf_"+reactorName+"[i]."+outputWidth+";", - "}" - )); - } - } else { - // Output is not in a bank. - builder.pr(reactorName+"."+outputName+" = self->_lf_"+reactorName+"."+outputName+";"); - if (ASTUtils.isMultiport(output)) { - builder.pr(reactorName+"."+outputWidth+" = self->_lf_"+reactorName+"."+outputWidth+";"); - } - } - } + /** + * Generate into the specified string builder the code to initialize local variables for sending + * data to an input of a contained reactor. This will also, if necessary, generate entries for + * local struct definitions into the struct argument. These entries point to where the data is + * stored. + * + * @param builder The string builder. + * @param structs A map from reactor instantiations to a place to write struct fields. + * @param definition AST node defining the reactor within which this occurs + * @param input Input of the contained reactor. + */ + private static void generateVariablesForSendingToContainedReactors( + CodeBuilder builder, + Map structs, + Instantiation definition, + Input input) { + CodeBuilder structBuilder = structs.get(definition); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(definition, structBuilder); } - - /** Generate action variables for a reaction. - * @param action The action. - */ - private static String generateActionVariablesInReaction( - Action action, - Reactor r, - CTypes types - ) { - String structType = CGenerator.variableStructType(action, r, false); - // If the action has a type, create variables for accessing the value. - InferredType type = ASTUtils.getInferredType(action); - // Pointer to the lf_token_t sent as the payload in the trigger. - String tokenPointer = "(self->_lf__"+action.getName()+".tmplt.token)"; - CodeBuilder builder = new CodeBuilder(); - + String inputStructType = + CGenerator.variableStructType( + input, ASTUtils.toDefinition(definition.getReactorClass()), false); + String defName = definition.getName(); + String defWidth = generateWidthVariable(defName); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); + if (!ASTUtils.isMultiport(input)) { + // Contained reactor's input is not a multiport. + structBuilder.pr(inputStructType + "* " + inputName + ";"); + if (definition.getWidthSpec() != null) { + // Contained reactor is a bank. builder.pr( - String.join("\n", - "// Expose the action struct as a local variable whose name matches the action name.", - structType+"* "+action.getName()+" = &self->_lf_"+action.getName()+";", - "// Set the fields of the action struct to match the current trigger.", - action.getName()+"->is_present = (bool)self->_lf__"+action.getName()+".status;", - action.getName()+"->has_value = ("+tokenPointer+" != NULL && "+tokenPointer+"->value != NULL);", - "_lf_replace_template_token((token_template_t*)"+action.getName()+", "+tokenPointer+");") - ); - // Set the value field only if there is a type. - if (!type.isUndefined()) { - // The value field will either be a copy (for primitive types) - // or a pointer (for types ending in *). - builder.pr("if ("+action.getName()+"->has_value) {"); - builder.indent(); - if (CUtil.isTokenType(type, types)) { - builder.pr(action.getName()+"->value = ("+types.getTargetType(type)+")"+tokenPointer+"->value;"); - } else { - builder.pr(action.getName()+"->value = *("+types.getTargetType(type)+"*)"+tokenPointer+"->value;"); - } - builder.unindent(); - builder.pr("}"); - } - return builder.toString(); + String.join( + "\n", + "for (int bankIndex = 0; bankIndex < self->_lf_" + defWidth + "; bankIndex++) {", + " " + + defName + + "[bankIndex]." + + inputName + + " = &(self->_lf_" + + defName + + "[bankIndex]." + + inputName + + ");", + "}")); + } else { + // Contained reactor is not a bank. + builder.pr( + defName + "." + inputName + " = &(self->_lf_" + defName + "." + inputName + ");"); + } + } else { + // Contained reactor's input is a multiport. + structBuilder.pr( + String.join("\n", inputStructType + "** " + inputName + ";", "int " + inputWidth + ";")); + // If the contained reactor is a bank, then we have to set the + // pointer for each element of the bank. + if (definition.getWidthSpec() != null) { + builder.pr( + String.join( + "\n", + "for (int _i = 0; _i < self->_lf_" + defWidth + "; _i++) {", + " " + + defName + + "[_i]." + + inputName + + " = self->_lf_" + + defName + + "[_i]." + + inputName + + ";", + " " + + defName + + "[_i]." + + inputWidth + + " = self->_lf_" + + defName + + "[_i]." + + inputWidth + + ";", + "}")); + } else { + builder.pr( + String.join( + "\n", + defName + "." + inputName + " = self->_lf_" + defName + "." + inputName + ";", + defName + "." + inputWidth + " = self->_lf_" + defName + "." + inputWidth + ";")); + } } + } - /** Generate into the specified string builder the code to - * initialize local variables for the specified input port - * in a reaction function from the "self" struct. - * @param input The input statement from the AST. - * @param r The reactor. - */ - private static String generateInputVariablesInReaction( - Input input, - Reactor r, - CTypes types - ) { - String structType = CGenerator.variableStructType(input, r, false); - InferredType inputType = ASTUtils.getInferredType(input); - CodeBuilder builder = new CodeBuilder(); - String inputName = input.getName(); - String inputWidth = generateWidthVariable(inputName); + /** + * Generate into the specified string builder the code to initialize local variables for ports in + * a reaction function from the "self" struct. The port may be an input of the reactor or an + * output of a contained reactor. The second argument provides, for each contained reactor, a + * place to write the declaration of the output of that reactor that is triggering reactions. + * + * @param builder The place into which to write the code. + * @param structs A map from reactor instantiations to a place to write struct fields. + */ + private static void generatePortVariablesInReaction( + CodeBuilder builder, + Map structs, + VarRef port, + Reactor r, + CTypes types) { + if (port.getVariable() instanceof Input) { + builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), r, types)); + } else { + // port is an output of a contained reactor. + Output output = (Output) port.getVariable(); + String portStructType = + CGenerator.variableStructType( + output, ASTUtils.toDefinition(port.getContainer().getReactorClass()), false); - // Create the local variable whose name matches the input name. - // If the input has not been declared mutable, then this is a pointer - // to the upstream output. Otherwise, it is a copy of the upstream output, - // which nevertheless points to the same token and value (hence, as done - // below, we have to use lf_writable_copy()). There are 8 cases, - // depending on whether the input is mutable, whether it is a multiport, - // and whether it is a token type. - // Easy case first. - if (!input.isMutable() && !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, primitive type. - builder.pr(structType+"* "+inputName+" = self->_lf_"+inputName+";"); - } else if (input.isMutable()&& !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, primitive type. - builder.pr(String.join("\n", - "// Mutable input, so copy the input into a temporary variable.", - "// The input value on the struct is a copy.", - structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", - structType+"* "+inputName+" = &_lf_tmp_"+inputName+";" - )); - } else if (!input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, token type. - builder.pr(String.join("\n", - structType+"* "+inputName+" = self->_lf_"+inputName+";", - "if ("+inputName+"->is_present) {", - " "+inputName+"->length = "+inputName+"->token->length;", - " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", - "} else {", - " "+inputName+"->length = 0;", - "}" - )); - } else if (input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, token type. - builder.pr(String.join("\n", - "// Mutable input, so copy the input struct into a temporary variable.", - structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", - structType+"* "+inputName+" = &_lf_tmp_"+inputName+";", - inputName+"->value = NULL;", // Prevent payload from being freed. - "if ("+inputName+"->is_present) {", - " "+inputName+"->length = "+inputName+"->token->length;", - " "+inputName+"->token = lf_writable_copy((lf_port_base_t*)self->_lf_"+inputName+");", - " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", - "} else {", - " "+inputName+"->length = 0;", - "}" - )); - } else if (!input.isMutable()&& ASTUtils.isMultiport(input)) { - // Non-mutable, multiport, primitive or token type. - builder.pr(structType+"** "+inputName+" = self->_lf_"+inputName+";"); - } else if (CUtil.isTokenType(inputType, types)) { - // Mutable, multiport, token type - builder.pr(String.join("\n", - "// Mutable multiport input, so copy the input structs", - "// into an array of temporary variables on the stack.", - structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", - " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", - " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", - " // If necessary, copy the tokens.", - " if ("+inputName+"[i]->is_present) {", - " "+inputName+"[i]->length = "+inputName+"[i]->token->length;", - " token_template_t* _lf_input = (token_template_t*)self->_lf_"+inputName+"[i];", - " "+inputName+"[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", - " "+inputName+"[i]->value = ("+types.getTargetType(inputType)+")"+inputName+"[i]->token->value;", - " } else {", - " "+inputName+"[i]->length = 0;", - " }", - "}" - )); - } else { - // Mutable, multiport, primitive type - builder.pr(String.join("\n", - "// Mutable multiport input, so copy the input structs", - "// into an array of temporary variables on the stack.", - structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", - " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", - " // Copy the struct, which includes the value.", - " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", - "}" - )); + CodeBuilder structBuilder = structs.get(port.getContainer()); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(port.getContainer(), structBuilder); + } + String reactorName = port.getContainer().getName(); + String reactorWidth = generateWidthVariable(reactorName); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + // First define the struct containing the output value and indicator + // of its presence. + if (!ASTUtils.isMultiport(output)) { + // Output is not a multiport. + structBuilder.pr(portStructType + "* " + outputName + ";"); + } else { + // Output is a multiport. + structBuilder.pr( + String.join( + "\n", portStructType + "** " + outputName + ";", "int " + outputWidth + ";")); + } + + // Next, initialize the struct with the current values. + if (port.getContainer().getWidthSpec() != null) { + // Output is in a bank. + builder.pr( + String.join( + "\n", + "for (int i = 0; i < " + reactorWidth + "; i++) {", + " " + + reactorName + + "[i]." + + outputName + + " = self->_lf_" + + reactorName + + "[i]." + + outputName + + ";", + "}")); + if (ASTUtils.isMultiport(output)) { + builder.pr( + String.join( + "\n", + "for (int i = 0; i < " + reactorWidth + "; i++) {", + " " + + reactorName + + "[i]." + + outputWidth + + " = self->_lf_" + + reactorName + + "[i]." + + outputWidth + + ";", + "}")); + } + } else { + // Output is not in a bank. + builder.pr( + reactorName + + "." + + outputName + + " = self->_lf_" + + reactorName + + "." + + outputName + + ";"); + if (ASTUtils.isMultiport(output)) { + builder.pr( + reactorName + + "." + + outputWidth + + " = self->_lf_" + + reactorName + + "." + + outputWidth + + ";"); } - // Set the _width variable for all cases. This will be -1 - // for a variable-width multiport, which is not currently supported. - // It will be -2 if it is not multiport. - builder.pr("int "+inputWidth+" = self->_lf_"+inputWidth+"; SUPPRESS_UNUSED_WARNING("+inputWidth+");"); - return builder.toString(); + } } + } - /** - * Generate into the specified string builder the code to - * initialize local variables for outputs in a reaction function - * from the "self" struct. - * @param effect The effect declared by the reaction. This must refer to an output. - * @param r The reactor containing the reaction. - */ - public static String generateOutputVariablesInReaction( - VarRef effect, - Reactor r, - ErrorReporter errorReporter, - boolean requiresTypes - ) { - Output output = (Output) effect.getVariable(); - String outputName = output.getName(); - String outputWidth = generateWidthVariable(outputName); - if (output.getType() == null && requiresTypes) { - errorReporter.reportError(output, "Output is required to have a type: " + outputName); - return ""; - } else { - // The container of the output may be a contained reactor or - // the reactor containing the reaction. - String outputStructType = (effect.getContainer() == null) ? - CGenerator.variableStructType(output, r, false) - : - CGenerator.variableStructType(output, ASTUtils.toDefinition(effect.getContainer().getReactorClass()), false); - if (!ASTUtils.isMultiport(output)) { - // Output port is not a multiport. - return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; - } else { - // Output port is a multiport. - // Set the _width variable. - return String.join("\n", - "int "+outputWidth+" = self->_lf_"+outputWidth+"; SUPPRESS_UNUSED_WARNING("+outputWidth+");", - outputStructType+"** "+outputName+" = self->_lf_"+outputName+"_pointers;" - ); + /** + * Generate action variables for a reaction. + * + * @param action The action. + */ + private static String generateActionVariablesInReaction(Action action, Reactor r, CTypes types) { + String structType = CGenerator.variableStructType(action, r, false); + // If the action has a type, create variables for accessing the value. + InferredType type = ASTUtils.getInferredType(action); + // Pointer to the lf_token_t sent as the payload in the trigger. + String tokenPointer = "(self->_lf__" + action.getName() + ".tmplt.token)"; + CodeBuilder builder = new CodeBuilder(); - } - } + builder.pr( + String.join( + "\n", + "// Expose the action struct as a local variable whose name matches the action name.", + structType + "* " + action.getName() + " = &self->_lf_" + action.getName() + ";", + "// Set the fields of the action struct to match the current trigger.", + action.getName() + "->is_present = (bool)self->_lf__" + action.getName() + ".status;", + action.getName() + + "->has_value = (" + + tokenPointer + + " != NULL && " + + tokenPointer + + "->value != NULL);", + "_lf_replace_template_token((token_template_t*)" + + action.getName() + + ", " + + tokenPointer + + ");")); + // Set the value field only if there is a type. + if (!type.isUndefined()) { + // The value field will either be a copy (for primitive types) + // or a pointer (for types ending in *). + builder.pr("if (" + action.getName() + "->has_value) {"); + builder.indent(); + if (CUtil.isTokenType(type, types)) { + builder.pr( + action.getName() + + "->value = (" + + types.getTargetType(type) + + ")" + + tokenPointer + + "->value;"); + } else { + builder.pr( + action.getName() + + "->value = *(" + + types.getTargetType(type) + + "*)" + + tokenPointer + + "->value;"); + } + builder.unindent(); + builder.pr("}"); } + return builder.toString(); + } - /** - * Generate into the specified string builder the code to - * initialize local variables for watchdogs in a reaction function - * from the "self" struct. - * @param effect The effect declared by the reaction. This must refer to a watchdog. - * @param decl The reactor containing the reaction or the import statement. - */ - // Fine to have watchdog be in reactor self struct? - public static String generateWatchdogVariablesInReaction( - VarRef effect, - ReactorDecl decl - ) { - Watchdog watchdog = (Watchdog) effect.getVariable(); - String watchdogName = watchdog.getName(); + /** + * Generate into the specified string builder the code to initialize local variables for the + * specified input port in a reaction function from the "self" struct. + * + * @param input The input statement from the AST. + * @param r The reactor. + */ + private static String generateInputVariablesInReaction(Input input, Reactor r, CTypes types) { + String structType = CGenerator.variableStructType(input, r, false); + InferredType inputType = ASTUtils.getInferredType(input); + CodeBuilder builder = new CodeBuilder(); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); - return String.join("\n", List.of( - "watchdog_t* "+watchdogName+" = &(self->_lf_watchdog_"+watchdogName+");" - )); + // Create the local variable whose name matches the input name. + // If the input has not been declared mutable, then this is a pointer + // to the upstream output. Otherwise, it is a copy of the upstream output, + // which nevertheless points to the same token and value (hence, as done + // below, we have to use lf_writable_copy()). There are 8 cases, + // depending on whether the input is mutable, whether it is a multiport, + // and whether it is a token type. + // Easy case first. + if (!input.isMutable() + && !CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, primitive type. + builder.pr(structType + "* " + inputName + " = self->_lf_" + inputName + ";"); + } else if (input.isMutable() + && !CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, primitive type. + builder.pr( + String.join( + "\n", + "// Mutable input, so copy the input into a temporary variable.", + "// The input value on the struct is a copy.", + structType + " _lf_tmp_" + inputName + " = *(self->_lf_" + inputName + ");", + structType + "* " + inputName + " = &_lf_tmp_" + inputName + ";")); + } else if (!input.isMutable() + && CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, token type. + builder.pr( + String.join( + "\n", + structType + "* " + inputName + " = self->_lf_" + inputName + ";", + "if (" + inputName + "->is_present) {", + " " + inputName + "->length = " + inputName + "->token->length;", + " " + + inputName + + "->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "->token->value;", + "} else {", + " " + inputName + "->length = 0;", + "}")); + } else if (input.isMutable() + && CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, token type. + builder.pr( + String.join( + "\n", + "// Mutable input, so copy the input struct into a temporary variable.", + structType + " _lf_tmp_" + inputName + " = *(self->_lf_" + inputName + ");", + structType + "* " + inputName + " = &_lf_tmp_" + inputName + ";", + inputName + "->value = NULL;", // Prevent payload from being freed. + "if (" + inputName + "->is_present) {", + " " + inputName + "->length = " + inputName + "->token->length;", + " " + + inputName + + "->token = lf_writable_copy((lf_port_base_t*)self->_lf_" + + inputName + + ");", + " " + + inputName + + "->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "->token->value;", + "} else {", + " " + inputName + "->length = 0;", + "}")); + } else if (!input.isMutable() && ASTUtils.isMultiport(input)) { + // Non-mutable, multiport, primitive or token type. + builder.pr(structType + "** " + inputName + " = self->_lf_" + inputName + ";"); + } else if (CUtil.isTokenType(inputType, types)) { + // Mutable, multiport, token type + builder.pr( + String.join( + "\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType + + " _lf_tmp_" + + inputName + + "[" + + CUtil.multiportWidthExpression(input) + + "];", + structType + "* " + inputName + "[" + CUtil.multiportWidthExpression(input) + "];", + "for (int i = 0; i < " + CUtil.multiportWidthExpression(input) + "; i++) {", + " " + inputName + "[i] = &_lf_tmp_" + inputName + "[i];", + " _lf_tmp_" + inputName + "[i] = *(self->_lf_" + inputName + "[i]);", + " // If necessary, copy the tokens.", + " if (" + inputName + "[i]->is_present) {", + " " + inputName + "[i]->length = " + inputName + "[i]->token->length;", + " token_template_t* _lf_input = (token_template_t*)self->_lf_" + + inputName + + "[i];", + " " + inputName + "[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", + " " + + inputName + + "[i]->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "[i]->token->value;", + " } else {", + " " + inputName + "[i]->length = 0;", + " }", + "}")); + } else { + // Mutable, multiport, primitive type + builder.pr( + String.join( + "\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType + + " _lf_tmp_" + + inputName + + "[" + + CUtil.multiportWidthExpression(input) + + "];", + structType + "* " + inputName + "[" + CUtil.multiportWidthExpression(input) + "];", + "for (int i = 0; i < " + CUtil.multiportWidthExpression(input) + "; i++) {", + " " + inputName + "[i] = &_lf_tmp_" + inputName + "[i];", + " // Copy the struct, which includes the value.", + " _lf_tmp_" + inputName + "[i] = *(self->_lf_" + inputName + "[i]);", + "}")); } + // Set the _width variable for all cases. This will be -1 + // for a variable-width multiport, which is not currently supported. + // It will be -2 if it is not multiport. + builder.pr( + "int " + + inputWidth + + " = self->_lf_" + + inputWidth + + "; SUPPRESS_UNUSED_WARNING(" + + inputWidth + + ");"); + return builder.toString(); + } - /** - * Generate the fields of the self struct and statements for the constructor - * to create and initialize a reaction_t struct for each reaction in the - * specified reactor and a trigger_t struct for each trigger (input, action, - * timer, or output of a contained reactor). - * @param body The place to put the code for the self struct. - * @param reactor The reactor. - * @param constructorCode The place to put the constructor code. - */ - public static void generateReactionAndTriggerStructs( - CodeBuilder body, - Reactor reactor, - CodeBuilder constructorCode, - CTypes types - ) { - var reactionCount = 0; - // Iterate over reactions and create initialize the reaction_t struct - // on the self struct. Also, collect a map from triggers to the reactions - // that are triggered by that trigger. Also, collect a set of sources - // that are read by reactions but do not trigger reactions. - // Finally, collect a set of triggers and sources that are outputs - // of contained reactors. - var triggerMap = new LinkedHashMap>(); - var sourceSet = new LinkedHashSet(); - var outputsOfContainedReactors = new LinkedHashMap(); - var startupReactions = new LinkedHashSet(); - var shutdownReactions = new LinkedHashSet(); - var resetReactions = new LinkedHashSet(); - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - // Create the reaction_t struct. - body.pr(reaction, "reaction_t _lf__reaction_"+reactionCount+";"); + /** + * Generate into the specified string builder the code to initialize local variables for outputs + * in a reaction function from the "self" struct. + * + * @param effect The effect declared by the reaction. This must refer to an output. + * @param r The reactor containing the reaction. + */ + public static String generateOutputVariablesInReaction( + VarRef effect, Reactor r, ErrorReporter errorReporter, boolean requiresTypes) { + Output output = (Output) effect.getVariable(); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + if (output.getType() == null && requiresTypes) { + errorReporter.reportError(output, "Output is required to have a type: " + outputName); + return ""; + } else { + // The container of the output may be a contained reactor or + // the reactor containing the reaction. + String outputStructType = + (effect.getContainer() == null) + ? CGenerator.variableStructType(output, r, false) + : CGenerator.variableStructType( + output, ASTUtils.toDefinition(effect.getContainer().getReactorClass()), false); + if (!ASTUtils.isMultiport(output)) { + // Output port is not a multiport. + return outputStructType + "* " + outputName + " = &self->_lf_" + outputName + ";"; + } else { + // Output port is a multiport. + // Set the _width variable. + return String.join( + "\n", + "int " + + outputWidth + + " = self->_lf_" + + outputWidth + + "; SUPPRESS_UNUSED_WARNING(" + + outputWidth + + ");", + outputStructType + "** " + outputName + " = self->_lf_" + outputName + "_pointers;"); + } + } + } - // Create the map of triggers to reactions. - for (TriggerRef trigger : reaction.getTriggers()) { - // trigger may not be a VarRef (it could be "startup" or "shutdown"). - if (trigger instanceof VarRef) { - var triggerAsVarRef = (VarRef) trigger; - var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); - if (reactionList == null) { - reactionList = new LinkedList<>(); - triggerMap.put(triggerAsVarRef.getVariable(), reactionList); - } - reactionList.add(reactionCount); - if (triggerAsVarRef.getContainer() != null) { - outputsOfContainedReactors.put(triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); - } - } else if (trigger instanceof BuiltinTriggerRef) { - switch(((BuiltinTriggerRef) trigger).getType()) { - case STARTUP: - startupReactions.add(reactionCount); - break; - case SHUTDOWN: - shutdownReactions.add(reactionCount); - break; - case RESET: - resetReactions.add(reactionCount); - break; - } - } - } - // Create the set of sources read but not triggering. - for (VarRef source : reaction.getSources()) { - sourceSet.add(source.getVariable()); - if (source.getContainer() != null) { - outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); - } - } + /** + * Generate into the specified string builder the code to initialize local variables for watchdogs + * in a reaction function from the "self" struct. + * + * @param effect The effect declared by the reaction. This must refer to a watchdog. + * @param decl The reactor containing the reaction or the import statement. + */ + // Fine to have watchdog be in reactor self struct? + public static String generateWatchdogVariablesInReaction(VarRef effect, ReactorDecl decl) { + Watchdog watchdog = (Watchdog) effect.getVariable(); + String watchdogName = watchdog.getName(); - var deadlineFunctionPointer = "NULL"; - if (reaction.getDeadline() != null) { - // The following has to match the name chosen in generateReactions - var deadlineFunctionName = generateDeadlineFunctionName(reactor, reactionCount); - deadlineFunctionPointer = "&" + deadlineFunctionName; - } + return String.join( + "\n", + List.of("watchdog_t* " + watchdogName + " = &(self->_lf_watchdog_" + watchdogName + ");")); + } - // Assign the STP handler - var STPFunctionPointer = "NULL"; - if (reaction.getStp() != null) { - // The following has to match the name chosen in generateReactions - var STPFunctionName = generateStpFunctionName(reactor, reactionCount); - STPFunctionPointer = "&" + STPFunctionName; - } + /** + * Generate the fields of the self struct and statements for the constructor to create and + * initialize a reaction_t struct for each reaction in the specified reactor and a trigger_t + * struct for each trigger (input, action, timer, or output of a contained reactor). + * + * @param body The place to put the code for the self struct. + * @param reactor The reactor. + * @param constructorCode The place to put the constructor code. + */ + public static void generateReactionAndTriggerStructs( + CodeBuilder body, Reactor reactor, CodeBuilder constructorCode, CTypes types) { + var reactionCount = 0; + // Iterate over reactions and create initialize the reaction_t struct + // on the self struct. Also, collect a map from triggers to the reactions + // that are triggered by that trigger. Also, collect a set of sources + // that are read by reactions but do not trigger reactions. + // Finally, collect a set of triggers and sources that are outputs + // of contained reactors. + var triggerMap = new LinkedHashMap>(); + var sourceSet = new LinkedHashSet(); + var outputsOfContainedReactors = new LinkedHashMap(); + var startupReactions = new LinkedHashSet(); + var shutdownReactions = new LinkedHashSet(); + var resetReactions = new LinkedHashSet(); + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create the reaction_t struct. + body.pr(reaction, "reaction_t _lf__reaction_" + reactionCount + ";"); - // Set the defaults of the reaction_t struct in the constructor. - // Since the self struct is allocated using calloc, there is no need to set: - // self->_lf__reaction_"+reactionCount+".index = 0; - // self->_lf__reaction_"+reactionCount+".chain_id = 0; - // self->_lf__reaction_"+reactionCount+".pos = 0; - // self->_lf__reaction_"+reactionCount+".status = inactive; - // self->_lf__reaction_"+reactionCount+".deadline = 0LL; - // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; - constructorCode.pr(reaction, String.join("\n", - "self->_lf__reaction_"+reactionCount+".number = "+reactionCount+";", - "self->_lf__reaction_"+reactionCount+".function = "+CReactionGenerator.generateReactionFunctionName(reactor, reactionCount)+";", - "self->_lf__reaction_"+reactionCount+".self = self;", - "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", - "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", - "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", - (reaction.eContainer() instanceof Mode ? - "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+reactor.getModes().indexOf((Mode) reaction.eContainer())+"];" : - "self->_lf__reaction_"+reactionCount+".mode = NULL;") - )); - // Increment the reactionCount even if the reaction is not in the federate - // so that reaction indices are consistent across federates. - reactionCount++; + // Create the map of triggers to reactions. + for (TriggerRef trigger : reaction.getTriggers()) { + // trigger may not be a VarRef (it could be "startup" or "shutdown"). + if (trigger instanceof VarRef) { + var triggerAsVarRef = (VarRef) trigger; + var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); + if (reactionList == null) { + reactionList = new LinkedList<>(); + triggerMap.put(triggerAsVarRef.getVariable(), reactionList); + } + reactionList.add(reactionCount); + if (triggerAsVarRef.getContainer() != null) { + outputsOfContainedReactors.put( + triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); + } + } else if (trigger instanceof BuiltinTriggerRef) { + switch (((BuiltinTriggerRef) trigger).getType()) { + case STARTUP: + startupReactions.add(reactionCount); + break; + case SHUTDOWN: + shutdownReactions.add(reactionCount); + break; + case RESET: + resetReactions.add(reactionCount); + break; + } } - - // Next, create and initialize the trigger_t objects. - // Start with the timers. - for (Timer timer : ASTUtils.allTimers(reactor)) { - createTriggerT(body, timer, triggerMap, constructorCode, types); - // Since the self struct is allocated using calloc, there is no need to set falsy fields. - constructorCode.pr("self->_lf__"+timer.getName()+".is_timer = true;"); - constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+timer.getName()+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + } + // Create the set of sources read but not triggering. + for (VarRef source : reaction.getSources()) { + sourceSet.add(source.getVariable()); + if (source.getContainer() != null) { + outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); } + } - // Handle builtin triggers. - if (startupReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); - } - // Handle shutdown triggers. - if (shutdownReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); - } - if (resetReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); - } + var deadlineFunctionPointer = "NULL"; + if (reaction.getDeadline() != null) { + // The following has to match the name chosen in generateReactions + var deadlineFunctionName = generateDeadlineFunctionName(reactor, reactionCount); + deadlineFunctionPointer = "&" + deadlineFunctionName; + } - // Next handle actions. - for (Action action : ASTUtils.allActions(reactor)) { - createTriggerT(body, action, triggerMap, constructorCode, types); - var isPhysical = "true"; - if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { - isPhysical = "false"; - } - var elementSize = "0"; - // If the action type is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) - : null; - if (rootType != null && !rootType.equals("void")) { - elementSize = "sizeof(" + rootType + ")"; - } + // Assign the STP handler + var STPFunctionPointer = "NULL"; + if (reaction.getStp() != null) { + // The following has to match the name chosen in generateReactions + var STPFunctionName = generateStpFunctionName(reactor, reactionCount); + STPFunctionPointer = "&" + STPFunctionName; + } - // Since the self struct is allocated using calloc, there is no need to set: - // self->_lf__"+action.getName()+".is_timer = false; - constructorCode.pr(String.join("\n", - "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", - (!(action.getPolicy() == null || action.getPolicy().isEmpty()) ? - "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" : - ""), - // Need to set the element_size in the trigger_t and the action struct. - "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize - + ";", - "self->_lf_" + action.getName() + ".type.element_size = " + elementSize + ";" - )); - } + // Set the defaults of the reaction_t struct in the constructor. + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__reaction_"+reactionCount+".index = 0; + // self->_lf__reaction_"+reactionCount+".chain_id = 0; + // self->_lf__reaction_"+reactionCount+".pos = 0; + // self->_lf__reaction_"+reactionCount+".status = inactive; + // self->_lf__reaction_"+reactionCount+".deadline = 0LL; + // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; + constructorCode.pr( + reaction, + String.join( + "\n", + "self->_lf__reaction_" + reactionCount + ".number = " + reactionCount + ";", + "self->_lf__reaction_" + + reactionCount + + ".function = " + + CReactionGenerator.generateReactionFunctionName(reactor, reactionCount) + + ";", + "self->_lf__reaction_" + reactionCount + ".self = self;", + "self->_lf__reaction_" + + reactionCount + + ".deadline_violation_handler = " + + deadlineFunctionPointer + + ";", + "self->_lf__reaction_" + reactionCount + ".STP_handler = " + STPFunctionPointer + ";", + "self->_lf__reaction_" + reactionCount + ".name = " + addDoubleQuotes("?") + ";", + (reaction.eContainer() instanceof Mode + ? "self->_lf__reaction_" + + reactionCount + + ".mode = &self->_lf__modes[" + + reactor.getModes().indexOf((Mode) reaction.eContainer()) + + "];" + : "self->_lf__reaction_" + reactionCount + ".mode = NULL;"))); + // Increment the reactionCount even if the reaction is not in the federate + // so that reaction indices are consistent across federates. + reactionCount++; + } - // Next handle inputs. - for (Input input : ASTUtils.allInputs(reactor)) { - createTriggerT(body, input, triggerMap, constructorCode, types); - } + // Next, create and initialize the trigger_t objects. + // Start with the timers. + for (Timer timer : ASTUtils.allTimers(reactor)) { + createTriggerT(body, timer, triggerMap, constructorCode, types); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + constructorCode.pr("self->_lf__" + timer.getName() + ".is_timer = true;"); + constructorCode.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + + timer.getName() + + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + } - // Next handle watchdogs. - for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - createTriggerT(body, watchdog, triggerMap, constructorCode, types); - } + // Handle builtin triggers. + if (startupReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); + } + // Handle shutdown triggers. + if (shutdownReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); + } + if (resetReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); } - /** - * Define the trigger_t object on the self struct, an array of - * reaction_t pointers pointing to reactions triggered by this variable, - * and initialize the pointers in the array in the constructor. - * @param body The place to write the self struct entries. - * @param variable The trigger variable (Timer, Action, Watchdog, or Input). - * @param triggerMap A map from Variables to a list of the reaction indices - * triggered by the variable. - * @param constructorCode The place to write the constructor code. - */ - private static void createTriggerT( - CodeBuilder body, - Variable variable, - LinkedHashMap> triggerMap, - CodeBuilder constructorCode, - CTypes types - ) { - var varName = variable.getName(); - // variable is a port, a timer, or an action. - body.pr(variable, "trigger_t _lf__"+varName+";"); - constructorCode.pr(variable, "self->_lf__"+varName+".last = NULL;"); - constructorCode.pr(variable, CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+varName+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + // Next handle actions. + for (Action action : ASTUtils.allActions(reactor)) { + createTriggerT(body, action, triggerMap, constructorCode, types); + var isPhysical = "true"; + if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { + isPhysical = "false"; + } + var elementSize = "0"; + // If the action type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) : null; + if (rootType != null && !rootType.equals("void")) { + elementSize = "sizeof(" + rootType + ")"; + } - // Generate the reactions triggered table. - var reactionsTriggered = triggerMap.get(variable); - if (reactionsTriggered != null) { - body.pr(variable, "reaction_t* _lf__"+varName+"_reactions["+reactionsTriggered.size()+"];"); - var count = 0; - for (Integer reactionTriggered : reactionsTriggered) { - constructorCode.prSourceLineNumber(variable); - constructorCode.pr(variable, "self->_lf__"+varName+"_reactions["+count+"] = &self->_lf__reaction_"+reactionTriggered+";"); - count++; - } - // Set up the trigger_t struct's pointer to the reactions. - constructorCode.pr(variable, String.join("\n", - "self->_lf__"+varName+".reactions = &self->_lf__"+varName+"_reactions[0];", - "self->_lf__"+varName+".number_of_reactions = "+count+";" - )); + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__"+action.getName()+".is_timer = false; + constructorCode.pr( + String.join( + "\n", + "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", + (!(action.getPolicy() == null || action.getPolicy().isEmpty()) + ? "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" + : ""), + // Need to set the element_size in the trigger_t and the action struct. + "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize + ";", + "self->_lf_" + action.getName() + ".type.element_size = " + elementSize + ";")); + } - // If federated, set the physical_time_of_arrival - constructorCode.pr(variable, CExtensionUtils.surroundWithIfFederated( - "self->_lf__"+varName+".physical_time_of_arrival = NEVER;")); - } - if (variable instanceof Input) { - var rootType = CUtil.rootType(types.getTargetType((Input) variable)); - // Since the self struct is allocated using calloc, there is no need to set falsy fields. - // If the input type is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var size = (rootType.equals("void")) ? "0" : "sizeof("+rootType+")"; + // Next handle inputs. + for (Input input : ASTUtils.allInputs(reactor)) { + createTriggerT(body, input, triggerMap, constructorCode, types); + } - constructorCode.pr("self->_lf__"+varName+".tmplt.type.element_size = "+size+";"); - body.pr( - CExtensionUtils.surroundWithIfFederated( - CExtensionUtils.createPortStatusFieldForInput((Input) variable) - ) - ); - } + // Next handle watchdogs. + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + createTriggerT(body, watchdog, triggerMap, constructorCode, types); } + } - public static void generateBuiltinTriggeredReactionsArray( - Set reactions, - String name, - CodeBuilder body, - CodeBuilder constructorCode - ) { - body.pr(String.join("\n", - "trigger_t _lf__"+name+";", - "reaction_t* _lf__"+name+"_reactions["+reactions.size()+"];" - )); - constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+name+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - var i = 0; - for (Integer reactionIndex : reactions) { - constructorCode.pr("self->_lf__"+name+"_reactions["+i+++"] = &self->_lf__reaction_"+reactionIndex+";"); - } - constructorCode.pr(String.join("\n", - "self->_lf__"+name+".last = NULL;", - "self->_lf__"+name+".reactions = &self->_lf__"+name+"_reactions[0];", - "self->_lf__"+name+".number_of_reactions = "+reactions.size()+";", - "self->_lf__"+name+".is_timer = false;" - )); + /** + * Define the trigger_t object on the self struct, an array of reaction_t pointers pointing to + * reactions triggered by this variable, and initialize the pointers in the array in the + * constructor. + * + * @param body The place to write the self struct entries. + * @param variable The trigger variable (Timer, Action, Watchdog, or Input). + * @param triggerMap A map from Variables to a list of the reaction indices triggered by the + * variable. + * @param constructorCode The place to write the constructor code. + */ + private static void createTriggerT( + CodeBuilder body, + Variable variable, + LinkedHashMap> triggerMap, + CodeBuilder constructorCode, + CTypes types) { + var varName = variable.getName(); + // variable is a port, a timer, or an action. + body.pr(variable, "trigger_t _lf__" + varName + ";"); + constructorCode.pr(variable, "self->_lf__" + varName + ".last = NULL;"); + constructorCode.pr( + variable, + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + + varName + + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + + // Generate the reactions triggered table. + var reactionsTriggered = triggerMap.get(variable); + if (reactionsTriggered != null) { + body.pr( + variable, + "reaction_t* _lf__" + varName + "_reactions[" + reactionsTriggered.size() + "];"); + var count = 0; + for (Integer reactionTriggered : reactionsTriggered) { + constructorCode.prSourceLineNumber(variable); + constructorCode.pr( + variable, + "self->_lf__" + + varName + + "_reactions[" + + count + + "] = &self->_lf__reaction_" + + reactionTriggered + + ";"); + count++; + } + // Set up the trigger_t struct's pointer to the reactions. + constructorCode.pr( + variable, + String.join( + "\n", + "self->_lf__" + varName + ".reactions = &self->_lf__" + varName + "_reactions[0];", + "self->_lf__" + varName + ".number_of_reactions = " + count + ";")); + + // If federated, set the physical_time_of_arrival + constructorCode.pr( + variable, + CExtensionUtils.surroundWithIfFederated( + "self->_lf__" + varName + ".physical_time_of_arrival = NEVER;")); } + if (variable instanceof Input) { + var rootType = CUtil.rootType(types.getTargetType((Input) variable)); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + // If the input type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var size = (rootType.equals("void")) ? "0" : "sizeof(" + rootType + ")"; - public static String generateBuiltinTriggersTable(int reactionCount, String name) { - return String.join("\n", List.of( - "// Array of pointers to "+name+" triggers.", - (reactionCount > 0 ? - "reaction_t* _lf_"+name+"_reactions["+reactionCount+"]" : - "reaction_t** _lf_"+name+"_reactions = NULL") + ";", - "int _lf_"+name+"_reactions_size = "+reactionCount+";" - )); + constructorCode.pr("self->_lf__" + varName + ".tmplt.type.element_size = " + size + ";"); + body.pr( + CExtensionUtils.surroundWithIfFederated( + CExtensionUtils.createPortStatusFieldForInput((Input) variable))); } + } - /** - * Generate the _lf_trigger_startup_reactions function. - */ - public static String generateLfTriggerStartupReactions(int startupReactionCount, boolean hasModalReactors) { - var s = new StringBuilder(); - s.append("void _lf_trigger_startup_reactions() {"); - if (startupReactionCount > 0) { - s.append("\n"); - if (hasModalReactors) { - s.append(String.join("\n", - " for (int i = 0; i < _lf_startup_reactions_size; i++) {", - " if (_lf_startup_reactions[i] != NULL) {", - " if (_lf_startup_reactions[i]->mode != NULL) {", - " // Skip reactions in modes", - " continue;", - " }", - " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", - " }", - " }", - " _lf_handle_mode_startup_reset_reactions(", - " _lf_startup_reactions, _lf_startup_reactions_size,", - " NULL, 0,", - " _lf_modal_reactor_states, _lf_modal_reactor_states_size);" - )); - } else { - s.append(String.join("\n", - " for (int i = 0; i < _lf_startup_reactions_size; i++) {", - " if (_lf_startup_reactions[i] != NULL) {", - " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", - " }", - " }" - )); - } - s.append("\n"); - } - s.append("}\n"); - return s.toString(); + public static void generateBuiltinTriggeredReactionsArray( + Set reactions, String name, CodeBuilder body, CodeBuilder constructorCode) { + body.pr( + String.join( + "\n", + "trigger_t _lf__" + name + ";", + "reaction_t* _lf__" + name + "_reactions[" + reactions.size() + "];")); + constructorCode.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + name + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + var i = 0; + for (Integer reactionIndex : reactions) { + constructorCode.pr( + "self->_lf__" + + name + + "_reactions[" + + i++ + + "] = &self->_lf__reaction_" + + reactionIndex + + ";"); } + constructorCode.pr( + String.join( + "\n", + "self->_lf__" + name + ".last = NULL;", + "self->_lf__" + name + ".reactions = &self->_lf__" + name + "_reactions[0];", + "self->_lf__" + name + ".number_of_reactions = " + reactions.size() + ";", + "self->_lf__" + name + ".is_timer = false;")); + } - /** - * Generate the _lf_trigger_shutdown_reactions function. - */ - public static String generateLfTriggerShutdownReactions(int shutdownReactionCount, boolean hasModalReactors) { - var s = new StringBuilder(); - s.append("bool _lf_trigger_shutdown_reactions() {\n"); - if (shutdownReactionCount > 0) { - if (hasModalReactors) { - s.append(String.join("\n", - " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", - " if (_lf_shutdown_reactions[i] != NULL) {", - " if (_lf_shutdown_reactions[i]->mode != NULL) {", - " // Skip reactions in modes", - " continue;", - " }", - " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", - " }", - " }", - " _lf_handle_mode_shutdown_reactions(_lf_shutdown_reactions, _lf_shutdown_reactions_size);", - " return true;" - )); - } else { - s.append(String.join("\n", - " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", - " if (_lf_shutdown_reactions[i] != NULL) {", - " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", - " }", - " }", - " return true;" - )); - } - s.append("\n"); - } else { - s.append(" return false;\n"); - } - s.append("}\n"); - return s.toString(); + public static String generateBuiltinTriggersTable(int reactionCount, String name) { + return String.join( + "\n", + List.of( + "// Array of pointers to " + name + " triggers.", + (reactionCount > 0 + ? "reaction_t* _lf_" + name + "_reactions[" + reactionCount + "]" + : "reaction_t** _lf_" + name + "_reactions = NULL") + + ";", + "int _lf_" + name + "_reactions_size = " + reactionCount + ";")); + } + + /** Generate the _lf_trigger_startup_reactions function. */ + public static String generateLfTriggerStartupReactions( + int startupReactionCount, boolean hasModalReactors) { + var s = new StringBuilder(); + s.append("void _lf_trigger_startup_reactions() {"); + if (startupReactionCount > 0) { + s.append("\n"); + if (hasModalReactors) { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_startup_reactions_size; i++) {", + " if (_lf_startup_reactions[i] != NULL) {", + " if (_lf_startup_reactions[i]->mode != NULL) {", + " // Skip reactions in modes", + " continue;", + " }", + " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", + " }", + " }", + " _lf_handle_mode_startup_reset_reactions(", + " _lf_startup_reactions, _lf_startup_reactions_size,", + " NULL, 0,", + " _lf_modal_reactor_states, _lf_modal_reactor_states_size);")); + } else { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_startup_reactions_size; i++) {", + " if (_lf_startup_reactions[i] != NULL) {", + " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", + " }", + " }")); + } + s.append("\n"); } + s.append("}\n"); + return s.toString(); + } - /** - * Generate the _lf_handle_mode_triggered_reactions function. - */ - public static String generateLfModeTriggeredReactions( - int startupReactionCount, - int resetReactionCount, - boolean hasModalReactors - ) { - if (!hasModalReactors) { - return ""; - } - var s = new StringBuilder(); - s.append("void _lf_handle_mode_triggered_reactions() {\n"); - s.append(" _lf_handle_mode_startup_reset_reactions(\n"); - if (startupReactionCount > 0) { - s.append(" _lf_startup_reactions, _lf_startup_reactions_size,\n"); - } else { - s.append(" NULL, 0,\n"); - } - if (resetReactionCount > 0) { - s.append(" _lf_reset_reactions, _lf_reset_reactions_size,\n"); - } else { - s.append(" NULL, 0,\n"); - } - s.append(" _lf_modal_reactor_states, _lf_modal_reactor_states_size);\n"); - s.append("}\n"); - return s.toString(); + /** Generate the _lf_trigger_shutdown_reactions function. */ + public static String generateLfTriggerShutdownReactions( + int shutdownReactionCount, boolean hasModalReactors) { + var s = new StringBuilder(); + s.append("bool _lf_trigger_shutdown_reactions() {\n"); + if (shutdownReactionCount > 0) { + if (hasModalReactors) { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", + " if (_lf_shutdown_reactions[i] != NULL) {", + " if (_lf_shutdown_reactions[i]->mode != NULL) {", + " // Skip reactions in modes", + " continue;", + " }", + " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", + " }", + " }", + " _lf_handle_mode_shutdown_reactions(_lf_shutdown_reactions," + + " _lf_shutdown_reactions_size);", + " return true;")); + } else { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", + " if (_lf_shutdown_reactions[i] != NULL) {", + " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", + " }", + " }", + " return true;")); + } + s.append("\n"); + } else { + s.append(" return false;\n"); } + s.append("}\n"); + return s.toString(); + } - /** Generate a reaction function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param r The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - public static String generateReaction( - Reaction reaction, - Reactor r, - int reactionIndex, - Instantiation mainDef, - ErrorReporter errorReporter, - CTypes types, - TargetConfig targetConfig, - boolean requiresType - ) { - var code = new CodeBuilder(); - var body = ASTUtils.toText(getCode(types, reaction, r)); - String init = generateInitializationForReaction( - body, reaction, ASTUtils.toDefinition(r), reactionIndex, - types, errorReporter, mainDef, - requiresType); + /** Generate the _lf_handle_mode_triggered_reactions function. */ + public static String generateLfModeTriggeredReactions( + int startupReactionCount, int resetReactionCount, boolean hasModalReactors) { + if (!hasModalReactors) { + return ""; + } + var s = new StringBuilder(); + s.append("void _lf_handle_mode_triggered_reactions() {\n"); + s.append(" _lf_handle_mode_startup_reset_reactions(\n"); + if (startupReactionCount > 0) { + s.append(" _lf_startup_reactions, _lf_startup_reactions_size,\n"); + } else { + s.append(" NULL, 0,\n"); + } + if (resetReactionCount > 0) { + s.append(" _lf_reset_reactions, _lf_reset_reactions_size,\n"); + } else { + s.append(" NULL, 0,\n"); + } + s.append(" _lf_modal_reactor_states, _lf_modal_reactor_states_size);\n"); + s.append("}\n"); + return s.toString(); + } - code.pr( - "#include " + StringUtil.addDoubleQuotes( - CCoreFilesUtils.getCTargetSetHeader())); + /** + * Generate a reaction function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + public static String generateReaction( + Reaction reaction, + Reactor r, + int reactionIndex, + Instantiation mainDef, + ErrorReporter errorReporter, + CTypes types, + TargetConfig targetConfig, + boolean requiresType) { + var code = new CodeBuilder(); + var body = ASTUtils.toText(getCode(types, reaction, r)); + String init = + generateInitializationForReaction( + body, + reaction, + ASTUtils.toDefinition(r), + reactionIndex, + types, + errorReporter, + mainDef, + requiresType); - CMethodGenerator.generateMacrosForMethods(ASTUtils.toDefinition(r), code); - code.pr(generateFunction( - generateReactionFunctionHeader(r, reactionIndex), - init, getCode(types, reaction, r) - )); - // Now generate code for the late function, if there is one - // Note that this function can only be defined on reactions - // in federates that have inputs from a logical connection. - if (reaction.getStp() != null) { - code.pr(generateFunction( - generateStpFunctionHeader(r, reactionIndex), - init, reaction.getStp().getCode())); - } + code.pr("#include " + StringUtil.addDoubleQuotes(CCoreFilesUtils.getCTargetSetHeader())); - // Now generate code for the deadline violation function, if there is one. - if (reaction.getDeadline() != null) { - code.pr(generateFunction( - generateDeadlineFunctionHeader(r, reactionIndex), - init, reaction.getDeadline().getCode())); - } - CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(r), code); - code.pr( - "#include " + StringUtil.addDoubleQuotes( - CCoreFilesUtils.getCTargetSetUndefHeader())); - return code.toString(); + CMethodGenerator.generateMacrosForMethods(ASTUtils.toDefinition(r), code); + code.pr( + generateFunction( + generateReactionFunctionHeader(r, reactionIndex), init, getCode(types, reaction, r))); + // Now generate code for the late function, if there is one + // Note that this function can only be defined on reactions + // in federates that have inputs from a logical connection. + if (reaction.getStp() != null) { + code.pr( + generateFunction( + generateStpFunctionHeader(r, reactionIndex), init, reaction.getStp().getCode())); } - private static Code getCode(CTypes types, Reaction r, ReactorDecl container) { - if (r.getCode() != null) return r.getCode(); - Code ret = LfFactory.eINSTANCE.createCode(); - var reactor = ASTUtils.toDefinition(container); - ret.setBody( - CReactorHeaderFileGenerator.nonInlineInitialization(r, reactor) + "\n" - + r.getName() + "( " + CReactorHeaderFileGenerator.reactionArguments(r, reactor) + " );"); - return ret; + // Now generate code for the deadline violation function, if there is one. + if (reaction.getDeadline() != null) { + code.pr( + generateFunction( + generateDeadlineFunctionHeader(r, reactionIndex), + init, + reaction.getDeadline().getCode())); } + CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(r), code); + code.pr("#include " + StringUtil.addDoubleQuotes(CCoreFilesUtils.getCTargetSetUndefHeader())); + return code.toString(); + } - public static String generateFunction(String header, String init, Code code) { - var function = new CodeBuilder(); - function.pr(header + " {"); - function.indent(); - function.pr(init); - function.prSourceLineNumber(code); - function.pr(ASTUtils.toText(code)); - function.unindent(); - function.pr("}"); - return function.toString(); - } + private static Code getCode(CTypes types, Reaction r, ReactorDecl container) { + if (r.getCode() != null) return r.getCode(); + Code ret = LfFactory.eINSTANCE.createCode(); + var reactor = ASTUtils.toDefinition(container); + ret.setBody( + CReactorHeaderFileGenerator.nonInlineInitialization(r, reactor) + + "\n" + + r.getName() + + "( " + + CReactorHeaderFileGenerator.reactionArguments(r, reactor) + + " );"); + return ret; + } - /** - * Returns the name of the deadline function for reaction. - * @param r The reactor with the deadline - * @param reactionIndex The number assigned to this reaction deadline - */ - public static String generateDeadlineFunctionName(Reactor r, int reactionIndex) { - return CUtil.getName(r).toLowerCase() + "_deadline_function" + reactionIndex; - } + public static String generateFunction(String header, String init, Code code) { + var function = new CodeBuilder(); + function.pr(header + " {"); + function.indent(); + function.pr(init); + function.prSourceLineNumber(code); + function.pr(ASTUtils.toText(code)); + function.unindent(); + function.pr("}"); + return function.toString(); + } - /** - * Return the function name for specified reaction of the - * specified reactor. - * @param reactor The reactor - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateReactionFunctionName(Reactor reactor, int reactionIndex) { - return CUtil.getName(reactor).toLowerCase() + "reaction_function_" + reactionIndex; - } + /** + * Returns the name of the deadline function for reaction. + * + * @param r The reactor with the deadline + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateDeadlineFunctionName(Reactor r, int reactionIndex) { + return CUtil.getName(r).toLowerCase() + "_deadline_function" + reactionIndex; + } - /** - * Returns the name of the stp function for reaction. - * @param r The reactor with the stp - * @param reactionIndex The number assigned to this reaction deadline - */ - public static String generateStpFunctionName(Reactor r, int reactionIndex) { - return CUtil.getName(r).toLowerCase() + "_STP_function" + reactionIndex; - } + /** + * Return the function name for specified reaction of the specified reactor. + * + * @param reactor The reactor + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionName(Reactor reactor, int reactionIndex) { + return CUtil.getName(reactor).toLowerCase() + "reaction_function_" + reactionIndex; + } - /** Return the top level C function header for the deadline function numbered "reactionIndex" in "r" - * @param r The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the deadline function. - */ - public static String generateDeadlineFunctionHeader(Reactor r, - int reactionIndex) { - String functionName = generateDeadlineFunctionName(r, reactionIndex); - return generateFunctionHeader(functionName); - } + /** + * Returns the name of the stp function for reaction. + * + * @param r The reactor with the stp + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateStpFunctionName(Reactor r, int reactionIndex) { + return CUtil.getName(r).toLowerCase() + "_STP_function" + reactionIndex; + } - /** Return the top level C function header for the reaction numbered "reactionIndex" in "r" - * @param r The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateReactionFunctionHeader(Reactor r, - int reactionIndex) { - String functionName = generateReactionFunctionName(r, reactionIndex); - return generateFunctionHeader(functionName); - } + /** + * Return the top level C function header for the deadline function numbered "reactionIndex" in + * "r" + * + * @param r The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the deadline function. + */ + public static String generateDeadlineFunctionHeader(Reactor r, int reactionIndex) { + String functionName = generateDeadlineFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } - public static String generateStpFunctionHeader(Reactor r, - int reactionIndex) { - String functionName = generateStpFunctionName(r, reactionIndex); - return generateFunctionHeader(functionName); - } + /** + * Return the top level C function header for the reaction numbered "reactionIndex" in "r" + * + * @param r The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionHeader(Reactor r, int reactionIndex) { + String functionName = generateReactionFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } - public static String generateFunctionHeader(String functionName) { - return "void " + functionName + "(void* instance_args)"; - } -} \ No newline at end of file + public static String generateStpFunctionHeader(Reactor r, int reactionIndex) { + String functionName = generateStpFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } + + public static String generateFunctionHeader(String functionName) { + return "void " + functionName + "(void* instance_args)"; + } +} diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 621077de86..5a6f1dc3ba 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -1,7 +1,6 @@ package org.lflang.generator.c; import java.util.List; - import org.lflang.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Mode; diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 2cf96e0d68..f1f0e9b59d 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -34,18 +34,14 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; - -import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; - import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.Target; import org.lflang.TargetProperty; import org.lflang.generator.CodeBuilder; import org.lflang.generator.CodeMap; - import org.lflang.generator.GeneratorResult; import org.lflang.generator.IntegratedBuilder; import org.lflang.generator.LFGeneratorContext; @@ -56,7 +52,6 @@ import org.lflang.generator.c.CGenerator; import org.lflang.generator.c.CUtil; import org.lflang.lf.Action; -import org.lflang.lf.Code; import org.lflang.lf.Input; import org.lflang.lf.Model; import org.lflang.lf.Output; @@ -68,525 +63,505 @@ import org.lflang.util.LFCommand; import org.lflang.util.StringUtil; - /** - * Generator for Python target. This class generates Python code defining each - * reactor - * class given in the input .lf file and imported .lf files. + * Generator for Python target. This class generates Python code defining each reactor class given + * in the input .lf file and imported .lf files. * - * Each class will contain all the reaction functions defined by the user in - * order, with the necessary ports/actions given as parameters. - * Moreover, each class will contain all state variables in native Python - * format. + *

Each class will contain all the reaction functions defined by the user in order, with the + * necessary ports/actions given as parameters. Moreover, each class will contain all state + * variables in native Python format. * - * A backend is also generated using the CGenerator that interacts with the C - * code library (see CGenerator.xtend). - * The backend is responsible for passing arguments to the Python reactor + *

A backend is also generated using the CGenerator that interacts with the C code library (see + * CGenerator.xtend). The backend is responsible for passing arguments to the Python reactor * functions. * * @author Soroush Bateni */ public class PythonGenerator extends CGenerator { - // Used to add statements that come before reactor classes and user code - private final CodeBuilder pythonPreamble = new CodeBuilder(); - - // Used to add module requirements to setup.py (delimited with ,) - private final List pythonRequiredModules = new ArrayList<>(); - - private final PythonTypes types; - - public PythonGenerator(LFGeneratorContext context) { - this(context, - new PythonTypes(), - new CCmakeGenerator( - context.getFileConfig(), - List.of("lib/python_action.c", - "lib/python_port.c", - "lib/python_tag.c", - "lib/python_time.c", - "lib/pythontarget.c" - ), - PythonGenerator::setUpMainTarget, - "install(TARGETS)" // No-op - ) - ); - } - - - private PythonGenerator(LFGeneratorContext context, PythonTypes types, CCmakeGenerator cmakeGenerator) { - super(context, false, types, cmakeGenerator, new PythonDelayBodyGenerator(types)); - this.targetConfig.compiler = "gcc"; - this.targetConfig.compilerFlags = new ArrayList<>(); - this.targetConfig.linkerFlags = ""; - this.types = types; - } - - /** - * Generic struct for ports with primitive types and - * statically allocated arrays in Lingua Franca. - * This template is defined as - * typedef struct { - * bool is_present; - * lf_sparse_io_record_t* sparse_record; // NULL if there is no sparse record. - * int destination_channel; // -1 if there is no destination. - * PyObject* value; - * int num_destinations; - * lf_token_t* token; - * int length; - * void (*destructor) (void* value); - * void* (*copy_constructor) (void* value); - * FEDERATED_GENERIC_EXTENSION - * } generic_port_instance_struct; - * - * See reactor-c-py/lib/pythontarget.h for details. - */ - String genericPortType = "generic_port_instance_struct"; - - /** - * Generic struct for actions. - * This template is defined as - * typedef struct { - * trigger_t* trigger; - * PyObject* value; - * bool is_present; - * bool has_value; - * lf_token_t* token; - * FEDERATED_CAPSULE_EXTENSION - * } generic_action_instance_struct; - * - * See reactor-c-py/lib/pythontarget.h for details. - */ - String genericActionType = "generic_action_instance_struct"; - - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.Python; + // Used to add statements that come before reactor classes and user code + private final CodeBuilder pythonPreamble = new CodeBuilder(); + + // Used to add module requirements to setup.py (delimited with ,) + private final List pythonRequiredModules = new ArrayList<>(); + + private final PythonTypes types; + + public PythonGenerator(LFGeneratorContext context) { + this( + context, + new PythonTypes(), + new CCmakeGenerator( + context.getFileConfig(), + List.of( + "lib/python_action.c", + "lib/python_port.c", + "lib/python_tag.c", + "lib/python_time.c", + "lib/pythontarget.c"), + PythonGenerator::setUpMainTarget, + "install(TARGETS)" // No-op + )); + } + + private PythonGenerator( + LFGeneratorContext context, PythonTypes types, CCmakeGenerator cmakeGenerator) { + super(context, false, types, cmakeGenerator, new PythonDelayBodyGenerator(types)); + this.targetConfig.compiler = "gcc"; + this.targetConfig.compilerFlags = new ArrayList<>(); + this.targetConfig.linkerFlags = ""; + this.types = types; + } + + /** + * Generic struct for ports with primitive types and statically allocated arrays in Lingua Franca. + * This template is defined as typedef struct { bool is_present; lf_sparse_io_record_t* + * sparse_record; // NULL if there is no sparse record. int destination_channel; // -1 if there is + * no destination. PyObject* value; int num_destinations; lf_token_t* token; int length; void + * (*destructor) (void* value); void* (*copy_constructor) (void* value); + * FEDERATED_GENERIC_EXTENSION } generic_port_instance_struct; + * + *

See reactor-c-py/lib/pythontarget.h for details. + */ + String genericPortType = "generic_port_instance_struct"; + + /** + * Generic struct for actions. This template is defined as typedef struct { trigger_t* trigger; + * PyObject* value; bool is_present; bool has_value; lf_token_t* token; + * FEDERATED_CAPSULE_EXTENSION } generic_action_instance_struct; + * + *

See reactor-c-py/lib/pythontarget.h for details. + */ + String genericActionType = "generic_action_instance_struct"; + + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.Python; + } + + private final Set protoNames = new HashSet<>(); + + // ////////////////////////////////////////// + // // Public methods + @Override + public TargetTypes getTargetTypes() { + return types; + } + + // ////////////////////////////////////////// + // // Protected methods + + /** Generate all Python classes if they have a reaction */ + public String generatePythonReactorClasses() { + CodeBuilder pythonClasses = new CodeBuilder(); + CodeBuilder pythonClassesInstantiation = new CodeBuilder(); + + // Generate reactor classes in Python + pythonClasses.pr(PythonReactorGenerator.generatePythonClass(main, main, types)); + + // Create empty lists to hold reactor instances + pythonClassesInstantiation.pr(PythonReactorGenerator.generateListsToHoldClassInstances(main)); + + // Instantiate generated classes + pythonClassesInstantiation.pr( + PythonReactorGenerator.generatePythonClassInstantiations(main, main)); + + return String.join( + "\n", + pythonClasses.toString(), + "", + "# Instantiate classes", + pythonClassesInstantiation.toString()); + } + + /** + * Generate the Python code constructed from reactor classes and user-written classes. + * + * @return the code body + */ + public String generatePythonCode(String pyModuleName) { + return String.join( + "\n", + "import os", + "import sys", + "sys.path.append(os.path.dirname(__file__))", + "# List imported names, but do not use pylint's --extension-pkg-allow-list option", + "# so that these names will be assumed present without having to compile and install.", + "# pylint: disable=no-name-in-module, import-error", + "from " + pyModuleName + " import (", + " Tag, action_capsule_t, port_capsule, request_stop, schedule_copy, start", + ")", + "# pylint: disable=c-extension-no-member", + "import " + pyModuleName + " as lf", + "try:", + " from LinguaFrancaBase.constants import BILLION, FOREVER, NEVER, instant_t, interval_t", + " from LinguaFrancaBase.functions import (", + " DAY, DAYS, HOUR, HOURS, MINUTE, MINUTES, MSEC, MSECS, NSEC, NSECS, SEC, SECS," + + " USEC,", + " USECS, WEEK, WEEKS", + " )", + " from LinguaFrancaBase.classes import Make", + "except ModuleNotFoundError:", + " print(\"No module named 'LinguaFrancaBase'. \"", + " \"Install using \\\"pip3 install LinguaFrancaBase\\\".\")", + " sys.exit(1)", + "import copy", + "", + pythonPreamble.toString(), + "", + generatePythonReactorClasses(), + "", + PythonMainFunctionGenerator.generateCode()); + } + + /** Generate the necessary Python files. */ + public Map generatePythonFiles( + String lfModuleName, String pyModuleName, String pyFileName) throws IOException { + Path filePath = fileConfig.getSrcGenPath().resolve(pyFileName); + File file = filePath.toFile(); + Files.deleteIfExists(filePath); + // Create the necessary directories + if (!file.getParentFile().exists()) { + if (!file.getParentFile().mkdirs()) { + throw new IOException( + "Failed to create directories required for the Python code generator."); + } } - - private final Set protoNames = new HashSet<>(); - - // ////////////////////////////////////////// - // // Public methods - @Override - public TargetTypes getTargetTypes() { - return types; - } - - // ////////////////////////////////////////// - // // Protected methods - - /** - * Generate all Python classes if they have a reaction - * - */ - public String generatePythonReactorClasses() { - CodeBuilder pythonClasses = new CodeBuilder(); - CodeBuilder pythonClassesInstantiation = new CodeBuilder(); - - // Generate reactor classes in Python - pythonClasses.pr(PythonReactorGenerator.generatePythonClass(main, main, types)); - - // Create empty lists to hold reactor instances - pythonClassesInstantiation.pr(PythonReactorGenerator.generateListsToHoldClassInstances(main)); - - // Instantiate generated classes - pythonClassesInstantiation.pr(PythonReactorGenerator.generatePythonClassInstantiations(main, main)); - - return String.join("\n", - pythonClasses.toString(), - "", - "# Instantiate classes", - pythonClassesInstantiation.toString() - ); - } - - /** - * Generate the Python code constructed from reactor classes and - * user-written classes. - * - * @return the code body - */ - public String generatePythonCode(String pyModuleName) { - return String.join("\n", - "import os", - "import sys", - "sys.path.append(os.path.dirname(__file__))", - "# List imported names, but do not use pylint's --extension-pkg-allow-list option", - "# so that these names will be assumed present without having to compile and install.", - "# pylint: disable=no-name-in-module, import-error", - "from "+pyModuleName+" import (", - " Tag, action_capsule_t, port_capsule, request_stop, schedule_copy, start", - ")", - "# pylint: disable=c-extension-no-member", - "import "+pyModuleName+" as lf", - "try:", - " from LinguaFrancaBase.constants import BILLION, FOREVER, NEVER, instant_t, interval_t", - " from LinguaFrancaBase.functions import (", - " DAY, DAYS, HOUR, HOURS, MINUTE, MINUTES, MSEC, MSECS, NSEC, NSECS, SEC, SECS, USEC,", - " USECS, WEEK, WEEKS", - " )", - " from LinguaFrancaBase.classes import Make", - "except ModuleNotFoundError:", - " print(\"No module named 'LinguaFrancaBase'. \"", - " \"Install using \\\"pip3 install LinguaFrancaBase\\\".\")", - " sys.exit(1)", - "import copy", - "", - pythonPreamble.toString(), - "", - generatePythonReactorClasses(), - "", - PythonMainFunctionGenerator.generateCode() - ); - } - - /** - * Generate the necessary Python files. - */ - public Map generatePythonFiles( - String lfModuleName, - String pyModuleName, - String pyFileName - ) throws IOException { - Path filePath = fileConfig.getSrcGenPath().resolve(pyFileName); - File file = filePath.toFile(); - Files.deleteIfExists(filePath); - // Create the necessary directories - if (!file.getParentFile().exists()) { - if (!file.getParentFile().mkdirs()) { - throw new IOException( - "Failed to create directories required for the Python code generator." - ); - } - } - Map codeMaps = new HashMap<>(); - codeMaps.put(filePath, CodeMap.fromGeneratedCode( - generatePythonCode(pyModuleName))); - FileUtil.writeToFile(codeMaps.get(filePath).getGeneratedCode(), filePath); - return codeMaps; - } - - /** - * Generate code that needs to appear at the top of the generated - * C file, such as #define and #include statements. - */ - @Override - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr(PythonPreambleGenerator.generateCDefineDirectives( + Map codeMaps = new HashMap<>(); + codeMaps.put(filePath, CodeMap.fromGeneratedCode(generatePythonCode(pyModuleName))); + FileUtil.writeToFile(codeMaps.get(filePath).getGeneratedCode(), filePath); + return codeMaps; + } + + /** + * Generate code that needs to appear at the top of the generated C file, such as #define and + * #include statements. + */ + @Override + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr( + PythonPreambleGenerator.generateCDefineDirectives( targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); - return code.toString(); - } - - /** - * Override generate top-level preambles, but put the user preambles in the - * .py file rather than the C file. Also handles including the federated - * execution setup preamble specified in the target config. - */ - @Override - protected String generateTopLevelPreambles(Reactor ignored) { - // user preambles - Set models = new LinkedHashSet<>(); - for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { - // The following assumes all reactors have a container. - // This means that generated reactors **have** to be - // added to a resource; not doing so will result in a NPE. - models.add((Model) ASTUtils.toDefinition(r).eContainer()); - } - // Add the main reactor if it is defined - if (this.mainDef != null) { - models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); - } - for (Model m : models) { - pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); - } - return PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors); + return code.toString(); + } + + /** + * Override generate top-level preambles, but put the user preambles in the .py file rather than + * the C file. Also handles including the federated execution setup preamble specified in the + * target config. + */ + @Override + protected String generateTopLevelPreambles(Reactor ignored) { + // user preambles + Set models = new LinkedHashSet<>(); + for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { + // The following assumes all reactors have a container. + // This means that generated reactors **have** to be + // added to a resource; not doing so will result in a NPE. + models.add((Model) ASTUtils.toDefinition(r).eContainer()); } - - @Override - protected void handleProtoFiles() { - for (String name : targetConfig.protoFiles) { - this.processProtoFile(name); - int dotIndex = name.lastIndexOf("."); - String rootFilename = dotIndex > 0 ? name.substring(0, dotIndex) : name; - pythonPreamble.pr("import "+rootFilename+"_pb2 as "+rootFilename); - protoNames.add(rootFilename); - } + // Add the main reactor if it is defined + if (this.mainDef != null) { + models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); } - - /** - * Process a given .proto file. - * - * Run, if possible, the proto-c protocol buffer code generator to produce - * the required .h and .c files. - * - * @param filename Name of the file to process. - */ - @Override - public void processProtoFile(String filename) { - LFCommand protoc = commandFactory.createCommand( - "protoc", List.of("--python_out=" - + fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); - - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires libprotoc >= 3.6.1"); - return; - } - int returnCode = protoc.run(); - if (returnCode == 0) { - pythonRequiredModules.add("google-api-python-client"); - } else { - errorReporter.reportError( - "protoc returns error code " + returnCode); - } + for (Model m : models) { + pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); } - - /** - * Generate the aliases for inputs, outputs, and struct type definitions for - * actions of the specified reactor in the specified federate. - * @param r The parsed reactor data structure. - */ - @Override - public void generateAuxiliaryStructs( - CodeBuilder builder, Reactor r, boolean userFacing - ) { - for (Input input : ASTUtils.allInputs(r)) { - generateAuxiliaryStructsForPort(builder, r, input); - } - for (Output output : ASTUtils.allOutputs(r)) { - generateAuxiliaryStructsForPort(builder, r, output); - } - for (Action action : ASTUtils.allActions(r)) { - generateAuxiliaryStructsForAction(builder, r, action); - } + return PythonPreambleGenerator.generateCIncludeStatements( + targetConfig, targetLanguageIsCpp(), hasModalReactors); + } + + @Override + protected void handleProtoFiles() { + for (String name : targetConfig.protoFiles) { + this.processProtoFile(name); + int dotIndex = name.lastIndexOf("."); + String rootFilename = dotIndex > 0 ? name.substring(0, dotIndex) : name; + pythonPreamble.pr("import " + rootFilename + "_pb2 as " + rootFilename); + protoNames.add(rootFilename); } - - private void generateAuxiliaryStructsForPort(CodeBuilder builder, Reactor r, - Port port) { - boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); - builder.pr(port, - PythonPortGenerator.generateAliasTypeDef(r, port, isTokenType, - genericPortType)); + } + + /** + * Process a given .proto file. + * + *

Run, if possible, the proto-c protocol buffer code generator to produce the required .h and + * .c files. + * + * @param filename Name of the file to process. + */ + @Override + public void processProtoFile(String filename) { + LFCommand protoc = + commandFactory.createCommand( + "protoc", + List.of("--python_out=" + fileConfig.getSrcGenPath(), filename), + fileConfig.srcPath); + + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires libprotoc >= 3.6.1"); + return; } - - private void generateAuxiliaryStructsForAction(CodeBuilder builder, Reactor r, - Action action) { - builder.pr(action, PythonActionGenerator.generateAliasTypeDef(r, action, genericActionType)); + int returnCode = protoc.run(); + if (returnCode == 0) { + pythonRequiredModules.add("google-api-python-client"); + } else { + errorReporter.reportError("protoc returns error code " + returnCode); } - - /** - * Return true if the host operating system is compatible and - * otherwise report an error and return false. - */ - @Override - public boolean isOSCompatible() { - return true; + } + + /** + * Generate the aliases for inputs, outputs, and struct type definitions for actions of the + * specified reactor in the specified federate. + * + * @param r The parsed reactor data structure. + */ + @Override + public void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { + for (Input input : ASTUtils.allInputs(r)) { + generateAuxiliaryStructsForPort(builder, r, input); } - - /** - * Generate C code from the Lingua Franca model contained by the - * specified resource. This is the main entry point for code - * generation. - * - * @param resource The resource containing the source code. - * @param context Context relating to invocation of the code generator. - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - // Set the threading to false by default, unless the user has - // specifically asked for it. - if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = false; - } - int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; - code.pr(PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors)); - super.doGenerate(resource, new SubContext( - context, - IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, - cGeneratedPercentProgress - )); - - if (errorsOccurred()) { - context.unsuccessfulFinish(); - return; - } - - Map codeMaps = new HashMap<>(); - var lfModuleName = fileConfig.name; - // Don't generate code if there is no main reactor - if (this.main != null) { - try { - Map codeMapsForFederate = generatePythonFiles(lfModuleName, generatePythonModuleName(lfModuleName), generatePythonFileName(lfModuleName)); - codeMaps.putAll(codeMapsForFederate); - copyTargetFiles(); - new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); - if (targetConfig.noCompile) { - System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); - } - } catch (Exception e) { - //noinspection ConstantConditions - throw Exceptions.sneakyThrow(e); - } - - System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); - } - - if (errorReporter.getErrorsOccurred()) { - context.unsuccessfulFinish(); - } else { - context.finish(GeneratorResult.Status.COMPILED, codeMaps); - } + for (Output output : ASTUtils.allOutputs(r)) { + generateAuxiliaryStructsForPort(builder, r, output); } - - @Override - protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new PythonDockerGenerator(context); + for (Action action : ASTUtils.allActions(r)) { + generateAuxiliaryStructsForAction(builder, r, action); } - - /** Generate a reaction function definition for a reactor. - * This function has a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param r The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - @Override - protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { - Reactor reactor = ASTUtils.toDefinition(r); - - // Reactions marked with a `@_c_body` attribute are generated in C - if (AttributeUtils.hasCBody(reaction)) { - super.generateReaction(src, reaction, r, reactionIndex); - return; - } - src.pr(PythonReactionGenerator.generateCReaction(reaction, reactor, reactionIndex, mainDef, errorReporter, types)); + } + + private void generateAuxiliaryStructsForPort(CodeBuilder builder, Reactor r, Port port) { + boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); + builder.pr( + port, PythonPortGenerator.generateAliasTypeDef(r, port, isTokenType, genericPortType)); + } + + private void generateAuxiliaryStructsForAction(CodeBuilder builder, Reactor r, Action action) { + builder.pr(action, PythonActionGenerator.generateAliasTypeDef(r, action, genericActionType)); + } + + /** + * Return true if the host operating system is compatible and otherwise report an error and return + * false. + */ + @Override + public boolean isOSCompatible() { + return true; + } + + /** + * Generate C code from the Lingua Franca model contained by the specified resource. This is the + * main entry point for code generation. + * + * @param resource The resource containing the source code. + * @param context Context relating to invocation of the code generator. + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + // Set the threading to false by default, unless the user has + // specifically asked for it. + if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = false; } - - /** - * Generate code that initializes the state variables for a given instance. - * Unlike parameters, state variables are uniformly initialized for all - * instances - * of the same reactor. This task is left to Python code to allow for more - * liberal - * state variable assignments. - * - * @param instance The reactor class instance - * @return Initialization code fore state variables of instance - */ - @Override - protected void generateStateVariableInitializations(ReactorInstance instance) { - // Do nothing + int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; + code.pr( + PythonPreambleGenerator.generateCIncludeStatements( + targetConfig, targetLanguageIsCpp(), hasModalReactors)); + super.doGenerate( + resource, + new SubContext( + context, IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, cGeneratedPercentProgress)); + + if (errorsOccurred()) { + context.unsuccessfulFinish(); + return; } - /** - * Generate runtime initialization code in C for parameters of a given - * reactor instance - * - * @param instance The reactor instance. - */ - @Override - protected void generateParameterInitialization(ReactorInstance instance) { - // Do nothing - // Parameters are initialized in Python - } + Map codeMaps = new HashMap<>(); + var lfModuleName = fileConfig.name; + // Don't generate code if there is no main reactor + if (this.main != null) { + try { + Map codeMapsForFederate = + generatePythonFiles( + lfModuleName, + generatePythonModuleName(lfModuleName), + generatePythonFileName(lfModuleName)); + codeMaps.putAll(codeMapsForFederate); + copyTargetFiles(); + new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); + if (targetConfig.noCompile) { + System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); + } + } catch (Exception e) { + //noinspection ConstantConditions + throw Exceptions.sneakyThrow(e); + } - /** - * Do nothing. - * Methods are generated in Python not C. - * @see PythonMethodGenerator - */ - @Override - protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { } - - /** - * Generate C preambles defined by user for a given reactor - * Since the Python generator expects preambles written in C, - * this function is overridden and does nothing. - * - * @param reactor The given reactor - */ - @Override - protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { - // Do nothing + System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); } - /** - * Generate code that is executed while the reactor instance is being - * initialized. - * This wraps the reaction functions in a Python function. - * @param instance The reactor instance. - */ - @Override - protected void generateReactorInstanceExtension( - ReactorInstance instance - ) { - initializeTriggerObjects.pr(PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); + if (errorReporter.getErrorsOccurred()) { + context.unsuccessfulFinish(); + } else { + context.finish(GeneratorResult.Status.COMPILED, codeMaps); } - - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the self struct - * @param selfStructBody The body of the self struct - * @param decl The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - @Override - protected void generateSelfStructExtension( - CodeBuilder selfStructBody, - ReactorDecl decl, - CodeBuilder constructorCode - ) { - Reactor reactor = ASTUtils.toDefinition(decl); - // Add the name field - selfStructBody.pr("char *_lf_name;"); - int reactionIndex = 0; - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - // Create a PyObject for each reaction - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex)+";"); - if (reaction.getStp() != null) { - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex)+";"); - } - if (reaction.getDeadline() != null) { - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex)+";"); - } - reactionIndex++; - } + } + + @Override + protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new PythonDockerGenerator(context); + } + + /** + * Generate a reaction function definition for a reactor. This function has a single argument that + * is a void* pointing to a struct that contains parameters, state variables, inputs (triggering + * or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + @Override + protected void generateReaction( + CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { + Reactor reactor = ASTUtils.toDefinition(r); + + // Reactions marked with a `@_c_body` attribute are generated in C + if (AttributeUtils.hasCBody(reaction)) { + super.generateReaction(src, reaction, r, reactionIndex); + return; } - - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - // NOTE: Strangely, a newline is needed at the beginning or indentation - // gets swallowed. - return String.join("\n", - "\n# Generated forwarding reaction for connections with the same destination", - "# but located in mutually exclusive modes.", - dest + ".set(" + source + ".value)\n" - ); + src.pr( + PythonReactionGenerator.generateCReaction( + reaction, reactor, reactionIndex, mainDef, errorReporter, types)); + } + + /** + * Generate code that initializes the state variables for a given instance. Unlike parameters, + * state variables are uniformly initialized for all instances of the same reactor. This task is + * left to Python code to allow for more liberal state variable assignments. + * + * @param instance The reactor class instance + * @return Initialization code fore state variables of instance + */ + @Override + protected void generateStateVariableInitializations(ReactorInstance instance) { + // Do nothing + } + + /** + * Generate runtime initialization code in C for parameters of a given reactor instance + * + * @param instance The reactor instance. + */ + @Override + protected void generateParameterInitialization(ReactorInstance instance) { + // Do nothing + // Parameters are initialized in Python + } + + /** + * Do nothing. Methods are generated in Python not C. + * + * @see PythonMethodGenerator + */ + @Override + protected void generateMethods(CodeBuilder src, ReactorDecl reactor) {} + + /** + * Generate C preambles defined by user for a given reactor Since the Python generator expects + * preambles written in C, this function is overridden and does nothing. + * + * @param reactor The given reactor + */ + @Override + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + // Do nothing + } + + /** + * Generate code that is executed while the reactor instance is being initialized. This wraps the + * reaction functions in a Python function. + * + * @param instance The reactor instance. + */ + @Override + protected void generateReactorInstanceExtension(ReactorInstance instance) { + initializeTriggerObjects.pr( + PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); + } + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the + * self struct + * + * @param selfStructBody The body of the self struct + * @param decl The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + @Override + protected void generateSelfStructExtension( + CodeBuilder selfStructBody, ReactorDecl decl, CodeBuilder constructorCode) { + Reactor reactor = ASTUtils.toDefinition(decl); + // Add the name field + selfStructBody.pr("char *_lf_name;"); + int reactionIndex = 0; + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create a PyObject for each reaction + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex) + + ";"); + if (reaction.getStp() != null) { + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex) + + ";"); + } + if (reaction.getDeadline() != null) { + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex) + + ";"); + } + reactionIndex++; } - - @Override - protected void setUpGeneralParameters() { - super.setUpGeneralParameters(); - if (hasModalReactors) { - targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); - } + } + + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + // NOTE: Strangely, a newline is needed at the beginning or indentation + // gets swallowed. + return String.join( + "\n", + "\n# Generated forwarding reaction for connections with the same destination", + "# but located in mutually exclusive modes.", + dest + ".set(" + source + ".value)\n"); + } + + @Override + protected void setUpGeneralParameters() { + super.setUpGeneralParameters(); + if (hasModalReactors) { + targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); } + } - @Override - protected void additionalPostProcessingForModes() { - if (!hasModalReactors) { - return; - } - PythonModeGenerator.generateResetReactionsIfNeeded(reactors); + @Override + protected void additionalPostProcessingForModes() { + if (!hasModalReactors) { + return; } + PythonModeGenerator.generateResetReactionsIfNeeded(reactors); + } - private static String setUpMainTarget(boolean hasMain, String executableName, Stream cSources) { - return ( - """ + private static String setUpMainTarget( + boolean hasMain, String executableName, Stream cSources) { + return (""" set(CMAKE_POSITION_INDEPENDENT_CODE ON) add_compile_definitions(_LF_GARBAGE_COLLECTED) add_subdirectory(core) @@ -611,71 +586,61 @@ private static String setUpMainTarget(boolean hasMain, String executableName, St include_directories(${Python_INCLUDE_DIRS}) target_link_libraries(${LF_MAIN_TARGET} PRIVATE ${Python_LIBRARIES}) target_compile_definitions(${LF_MAIN_TARGET} PUBLIC MODULE_NAME=) - """ - ).replace("", generatePythonModuleName(executableName)) - .replace("executableName", executableName); - // The use of fileConfig.name will break federated execution, but that's fine - } - - /** - * Generate a (`key`, `val`) tuple pair for the `define_macros` field - * of the Extension class constructor from setuptools. - * - * @param key The key of the macro entry - * @param val The value of the macro entry - * @return A (`key`, `val`) tuple pair as String - */ - private static String generateMacroEntry(String key, String val) { - return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; - } - - /** - * Generate the name of the python module. - * - * Ideally, this function would belong in a class like `PyFileConfig` - * that specifies all the paths to the generated code. - * - * @param lfModuleName The name of the LF module. - * @return The name of the python module. - */ - private static String generatePythonModuleName(String lfModuleName) { - return "LinguaFranca" + lfModuleName; - } - - /** - * Generate the python file name given an `lfModuleName`. - * - * Ideally, this function would belong in a class like `PyFileConfig` - * that specifies all the paths to the generated code. - * - * @param lfModuleName The name of the LF module - * @return The name of the generated python file. - */ - private static String generatePythonFileName(String lfModuleName) { - return lfModuleName + ".py"; - } - - /** - * Copy Python specific target code to the src-gen directory - */ - @Override - protected void copyTargetFiles() throws IOException { - super.copyTargetFiles(); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/include", - fileConfig.getSrcGenPath().resolve("include"), - true - ); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/lib", - fileConfig.getSrcGenPath().resolve("lib"), - true - ); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/LinguaFrancaBase", - fileConfig.getSrcGenPath().resolve("LinguaFrancaBase"), - true - ); - } - -} \ No newline at end of file + """) + .replace("", generatePythonModuleName(executableName)) + .replace("executableName", executableName); + // The use of fileConfig.name will break federated execution, but that's fine + } + + /** + * Generate a (`key`, `val`) tuple pair for the `define_macros` field of the Extension class + * constructor from setuptools. + * + * @param key The key of the macro entry + * @param val The value of the macro entry + * @return A (`key`, `val`) tuple pair as String + */ + private static String generateMacroEntry(String key, String val) { + return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; + } + + /** + * Generate the name of the python module. + * + *

Ideally, this function would belong in a class like `PyFileConfig` that specifies all the + * paths to the generated code. + * + * @param lfModuleName The name of the LF module. + * @return The name of the python module. + */ + private static String generatePythonModuleName(String lfModuleName) { + return "LinguaFranca" + lfModuleName; + } + + /** + * Generate the python file name given an `lfModuleName`. + * + *

Ideally, this function would belong in a class like `PyFileConfig` that specifies all the + * paths to the generated code. + * + * @param lfModuleName The name of the LF module + * @return The name of the generated python file. + */ + private static String generatePythonFileName(String lfModuleName) { + return lfModuleName + ".py"; + } + + /** Copy Python specific target code to the src-gen directory */ + @Override + protected void copyTargetFiles() throws IOException { + super.copyTargetFiles(); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/include", fileConfig.getSrcGenPath().resolve("include"), true); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/lib", fileConfig.getSrcGenPath().resolve("lib"), true); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/LinguaFrancaBase", + fileConfig.getSrcGenPath().resolve("LinguaFrancaBase"), + true); + } +} diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 99e0a5bab4..b0555dc4e0 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -1,6 +1,3 @@ - - - /* Validation checks for Lingua Franca code. */ /************* @@ -27,12 +24,10 @@ import static org.lflang.ASTUtils.inferPortWidth; import static org.lflang.ASTUtils.isGeneric; -import static org.lflang.ASTUtils.isInteger; -import static org.lflang.ASTUtils.isOfTimeType; -import static org.lflang.ASTUtils.isZero; import static org.lflang.ASTUtils.toDefinition; import static org.lflang.ASTUtils.toOriginalText; +import com.google.inject.Inject; import java.io.File; import java.io.IOException; import java.util.ArrayList; @@ -44,7 +39,6 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; - import org.eclipse.emf.common.util.EList; import org.eclipse.emf.common.util.TreeIterator; import org.eclipse.emf.ecore.EAttribute; @@ -71,7 +65,6 @@ import org.lflang.lf.BracedListExpression; import org.lflang.lf.BuiltinTrigger; import org.lflang.lf.BuiltinTriggerRef; -import org.lflang.lf.CodeExpr; import org.lflang.lf.Connection; import org.lflang.lf.Deadline; import org.lflang.lf.Expression; @@ -115,12 +108,10 @@ import org.lflang.lf.WidthTerm; import org.lflang.util.FileUtil; -import com.google.inject.Inject; - /** * Custom validation checks for Lingua Franca programs. * - * Also see: https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + *

Also see: https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation * * @author Edward A. Lee * @author Marten Lohstroh @@ -131,1750 +122,1832 @@ */ public class LFValidator extends BaseLFValidator { - ////////////////////////////////////////////////////////////// - //// Public check methods. - - // These methods are automatically invoked on AST nodes matching - // the types of their arguments. - // CheckType.FAST ensures that these checks run whenever a file is modified. - // Alternatives are CheckType.NORMAL (when saving) and - // CheckType.EXPENSIVE (only when right-click, validate). - // FIXME: What is the default when nothing is specified? - - // These methods are listed in alphabetical order, and, although - // it is isn't strictly required, follow a naming convention - // checkClass, where Class is the AST class, where possible. - - @Check(CheckType.FAST) - public void checkAction(Action action) { - checkName(action.getName(), Literals.VARIABLE__NAME); - if (action.getOrigin() == ActionOrigin.NONE) { - error( - "Action must have modifier `logical` or `physical`.", - Literals.ACTION__ORIGIN - ); - } - if (action.getPolicy() != null && - !SPACING_VIOLATION_POLICIES.contains(action.getPolicy())) { - error( - "Unrecognized spacing violation policy: " + action.getPolicy() + - ". Available policies are: " + - String.join(", ", SPACING_VIOLATION_POLICIES) + ".", - Literals.ACTION__POLICY); - } - checkExpressionIsTime(action.getMinDelay(), Literals.ACTION__MIN_DELAY); - checkExpressionIsTime(action.getMinSpacing(), Literals.ACTION__MIN_SPACING); + ////////////////////////////////////////////////////////////// + //// Public check methods. + + // These methods are automatically invoked on AST nodes matching + // the types of their arguments. + // CheckType.FAST ensures that these checks run whenever a file is modified. + // Alternatives are CheckType.NORMAL (when saving) and + // CheckType.EXPENSIVE (only when right-click, validate). + // FIXME: What is the default when nothing is specified? + + // These methods are listed in alphabetical order, and, although + // it is isn't strictly required, follow a naming convention + // checkClass, where Class is the AST class, where possible. + + @Check(CheckType.FAST) + public void checkAction(Action action) { + checkName(action.getName(), Literals.VARIABLE__NAME); + if (action.getOrigin() == ActionOrigin.NONE) { + error("Action must have modifier `logical` or `physical`.", Literals.ACTION__ORIGIN); } - - - @Check(CheckType.FAST) - public void checkInitializer(Initializer init) { - if (init.isBraces() && target != Target.CPP) { - error("Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); - } else if (init.isParens() && target.mandatesEqualsInitializers()) { - var message = "This syntax is deprecated in the " + target - + " target, use an equal sign instead of parentheses for assignment."; - if (init.getExprs().size() == 1) { - message += " (run the formatter to fix this automatically)"; - } - warning(message, Literals.INITIALIZER__PARENS); - } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { - var feature = init.isBraces() ? Literals.INITIALIZER__BRACES - : Literals.INITIALIZER__PARENS; - var message = "This syntax is deprecated, do not use parentheses or braces but an equal sign."; - if (init.getExprs().size() == 1) { - message += " (run the formatter to fix this automatically)"; - } - warning(message, feature); - } + if (action.getPolicy() != null && !SPACING_VIOLATION_POLICIES.contains(action.getPolicy())) { + error( + "Unrecognized spacing violation policy: " + + action.getPolicy() + + ". Available policies are: " + + String.join(", ", SPACING_VIOLATION_POLICIES) + + ".", + Literals.ACTION__POLICY); } - - @Check(CheckType.FAST) - public void checkBracedExpression(BracedListExpression expr) { - if (!target.allowsBracedListExpressions()) { - var message = "Braced expression lists are not a valid expression for the " + target - + " target."; - error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); - } + checkExpressionIsTime(action.getMinDelay(), Literals.ACTION__MIN_DELAY); + checkExpressionIsTime(action.getMinSpacing(), Literals.ACTION__MIN_SPACING); + } + + @Check(CheckType.FAST) + public void checkInitializer(Initializer init) { + if (init.isBraces() && target != Target.CPP) { + error( + "Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); + } else if (init.isParens() && target.mandatesEqualsInitializers()) { + var message = + "This syntax is deprecated in the " + + target + + " target, use an equal sign instead of parentheses for assignment."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, Literals.INITIALIZER__PARENS); + } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { + var feature = init.isBraces() ? Literals.INITIALIZER__BRACES : Literals.INITIALIZER__PARENS; + var message = + "This syntax is deprecated, do not use parentheses or braces but an equal sign."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, feature); } - - @Check(CheckType.FAST) - public void checkAssignment(Assignment assignment) { - - // If the left-hand side is a time parameter, make sure the assignment has units - typeCheck(assignment.getRhs(), ASTUtils.getInferredType(assignment.getLhs()), Literals.ASSIGNMENT__RHS); - // If this assignment overrides a parameter that is used in a deadline, - // report possible overflow. - if (isCBasedTarget() && - this.info.overflowingAssignments.contains(assignment)) { - error( - "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.ASSIGNMENT__RHS); - } - + } + + @Check(CheckType.FAST) + public void checkBracedExpression(BracedListExpression expr) { + if (!target.allowsBracedListExpressions()) { + var message = + "Braced expression lists are not a valid expression for the " + target + " target."; + error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); } + } + + @Check(CheckType.FAST) + public void checkAssignment(Assignment assignment) { + + // If the left-hand side is a time parameter, make sure the assignment has units + typeCheck( + assignment.getRhs(), + ASTUtils.getInferredType(assignment.getLhs()), + Literals.ASSIGNMENT__RHS); + // If this assignment overrides a parameter that is used in a deadline, + // report possible overflow. + if (isCBasedTarget() && this.info.overflowingAssignments.contains(assignment)) { + error( + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + + " nanoseconds.", + Literals.ASSIGNMENT__RHS); + } + } - @Check(CheckType.FAST) - public void checkConnection(Connection connection) { - - // Report if connection is part of a cycle. - Set> cycles = this.info.topologyCycles(); - for (VarRef lp : connection.getLeftPorts()) { - for (VarRef rp : connection.getRightPorts()) { - boolean leftInCycle = false; - - for (NamedInstance it : cycles) { - if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) - || (it.getDefinition().equals(lp.getVariable()) && it.getParent().equals(lp.getContainer()))) { - leftInCycle = true; - break; - } - } + @Check(CheckType.FAST) + public void checkConnection(Connection connection) { - for (NamedInstance it : cycles) { - if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) - || (it.getDefinition().equals(rp.getVariable()) && it.getParent().equals(rp.getContainer()))) { - if (leftInCycle) { - Reactor reactor = ASTUtils.getEnclosingReactor(connection); - String reactorName = reactor.getName(); - error(String.format("Connection in reactor %s creates", reactorName) + - String.format("a cyclic dependency between %s and %s.", toOriginalText(lp), toOriginalText(rp)), - Literals.CONNECTION__DELAY); - } - } - } - } - } - - // FIXME: look up all ReactorInstance objects that have a definition equal to the - // container of this connection. For each of those occurrences, the widths have to match. - // For the C target, since C has such a weak type system, check that - // the types on both sides of every connection match. For other languages, - // we leave type compatibility that language's compiler or interpreter. - if (isCBasedTarget()) { - Type type = (Type) null; - for (VarRef port : connection.getLeftPorts()) { - // If the variable is not a port, then there is some other - // error. Avoid a class cast exception. - if (port.getVariable() instanceof Port) { - if (type == null) { - type = ((Port) port.getVariable()).getType(); - } else { - // Unfortunately, xtext does not generate a suitable equals() - // method for AST types, so we have to manually check the types. - if (!sameType(type, ((Port) port.getVariable()).getType())) { - error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); - } - } - } - } - for (VarRef port : connection.getRightPorts()) { - // If the variable is not a port, then there is some other - // error. Avoid a class cast exception. - if (port.getVariable() instanceof Port) { - if (type == null) { - type = ((Port) port.getVariable()).getType(); - } else { - if (!sameType(type, type = ((Port) port.getVariable()).getType())) { - error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); - } - } - } - } - } + // Report if connection is part of a cycle. + Set> cycles = this.info.topologyCycles(); + for (VarRef lp : connection.getLeftPorts()) { + for (VarRef rp : connection.getRightPorts()) { + boolean leftInCycle = false; - // Check whether the total width of the left side of the connection - // matches the total width of the right side. This cannot be determined - // here if the width is not given as a constant. In that case, it is up - // to the code generator to check it. - int leftWidth = 0; - for (VarRef port : connection.getLeftPorts()) { - int width = inferPortWidth(port, null, null); // null args imply incomplete check. - if (width < 0 || leftWidth < 0) { - // Cannot determine the width of the left ports. - leftWidth = -1; - } else { - leftWidth += width; - } - } - int rightWidth = 0; - for (VarRef port : connection.getRightPorts()) { - int width = inferPortWidth(port, null, null); // null args imply incomplete check. - if (width < 0 || rightWidth < 0) { - // Cannot determine the width of the left ports. - rightWidth = -1; - } else { - rightWidth += width; - } - } - - if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { - if (connection.isIterated()) { - if (leftWidth == 0 || rightWidth % leftWidth != 0) { - // FIXME: The second argument should be Literals.CONNECTION, but - // stupidly, xtext will not accept that. There seems to be no way to - // report an error for the whole connection statement. - warning(String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), - Literals.CONNECTION__LEFT_PORTS - ); - } - } else { - // FIXME: The second argument should be Literals.CONNECTION, but - // stupidly, xtext will not accept that. There seems to be no way to - // report an error for the whole connection statement. - warning(String.format("Left width %s does not match right width %s", leftWidth, rightWidth), - Literals.CONNECTION__LEFT_PORTS - ); - } + for (NamedInstance it : cycles) { + if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) + || (it.getDefinition().equals(lp.getVariable()) + && it.getParent().equals(lp.getContainer()))) { + leftInCycle = true; + break; + } } - Reactor reactor = ASTUtils.getEnclosingReactor(connection); - - // Make sure the right port is not already an effect of a reaction. - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - for (VarRef effect : reaction.getEffects()) { - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort.getVariable().equals(effect.getVariable()) && // Refers to the same variable - rightPort.getContainer() == effect.getContainer() && // Refers to the same instance - ( reaction.eContainer() instanceof Reactor || // Either is not part of a mode - connection.eContainer() instanceof Reactor || - connection.eContainer() == reaction.eContainer() // Or they are in the same mode - )) { - error("Cannot connect: Port named '" + effect.getVariable().getName() + - "' is already effect of a reaction.", - Literals.CONNECTION__RIGHT_PORTS); - } - } + for (NamedInstance it : cycles) { + if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) + || (it.getDefinition().equals(rp.getVariable()) + && it.getParent().equals(rp.getContainer()))) { + if (leftInCycle) { + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + String reactorName = reactor.getName(); + error( + String.format("Connection in reactor %s creates", reactorName) + + String.format( + "a cyclic dependency between %s and %s.", + toOriginalText(lp), toOriginalText(rp)), + Literals.CONNECTION__DELAY); } + } } + } + } - // Check that the right port does not already have some other - // upstream connection. - for (Connection c : reactor.getConnections()) { - if (c != connection) { - for (VarRef thisRightPort : connection.getRightPorts()) { - for (VarRef thatRightPort : c.getRightPorts()) { - if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) && // Refers to the same variable - thisRightPort.getContainer() == thatRightPort.getContainer() && // Refers to the same instance - ( connection.eContainer() instanceof Reactor || // Or either of the connections in not part of a mode - c.eContainer() instanceof Reactor || - connection.eContainer() == c.eContainer() // Or they are in the same mode - )) { - error( - "Cannot connect: Port named '" + thisRightPort.getVariable().getName() + - "' may only appear once on the right side of a connection.", - Literals.CONNECTION__RIGHT_PORTS); - } - } - } + // FIXME: look up all ReactorInstance objects that have a definition equal to the + // container of this connection. For each of those occurrences, the widths have to match. + // For the C target, since C has such a weak type system, check that + // the types on both sides of every connection match. For other languages, + // we leave type compatibility that language's compiler or interpreter. + if (isCBasedTarget()) { + Type type = (Type) null; + for (VarRef port : connection.getLeftPorts()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + // Unfortunately, xtext does not generate a suitable equals() + // method for AST types, so we have to manually check the types. + if (!sameType(type, ((Port) port.getVariable()).getType())) { + error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); } + } } - - // Check the after delay - if (connection.getDelay() != null) { - final var delay = connection.getDelay(); - if (delay instanceof ParameterReference || delay instanceof Time || delay instanceof Literal) { - checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); - } else { - error("After delays can only be given by time literals or parameters.", - Literals.CONNECTION__DELAY); + } + for (VarRef port : connection.getRightPorts()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + if (!sameType(type, type = ((Port) port.getVariable()).getType())) { + error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); } + } } + } } - @Check(CheckType.FAST) - public void checkDeadline(Deadline deadline) { - if (isCBasedTarget() && - this.info.overflowingDeadlines.contains(deadline)) { - error( - "Deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.DEADLINE__DELAY); - } - checkExpressionIsTime(deadline.getDelay(), Literals.DEADLINE__DELAY); + // Check whether the total width of the left side of the connection + // matches the total width of the right side. This cannot be determined + // here if the width is not given as a constant. In that case, it is up + // to the code generator to check it. + int leftWidth = 0; + for (VarRef port : connection.getLeftPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || leftWidth < 0) { + // Cannot determine the width of the left ports. + leftWidth = -1; + } else { + leftWidth += width; + } + } + int rightWidth = 0; + for (VarRef port : connection.getRightPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || rightWidth < 0) { + // Cannot determine the width of the left ports. + rightWidth = -1; + } else { + rightWidth += width; + } } - @Check(CheckType.FAST) - public void checkHost(Host host) { - String addr = host.getAddr(); - String user = host.getUser(); - if (user != null && !user.matches(USERNAME_REGEX)) { - warning( - "Invalid user name.", - Literals.HOST__USER - ); - } - if (host instanceof IPV4Host && !addr.matches(IPV4_REGEX)) { - warning( - "Invalid IP address.", - Literals.HOST__ADDR - ); - } else if (host instanceof IPV6Host && !addr.matches(IPV6_REGEX)) { - warning( - "Invalid IP address.", - Literals.HOST__ADDR - ); - } else if (host instanceof NamedHost && !addr.matches(HOST_OR_FQN_REGEX)) { - warning( - "Invalid host name or fully qualified domain name.", - Literals.HOST__ADDR - ); - } + if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { + if (connection.isIterated()) { + if (leftWidth == 0 || rightWidth % leftWidth != 0) { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning( + String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS); + } + } else { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning( + String.format("Left width %s does not match right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS); + } } - @Check - public void checkImport(Import imp) { - if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { - error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. - return; + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + + // Make sure the right port is not already an effect of a reaction. + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + for (VarRef effect : reaction.getEffects()) { + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort.getVariable().equals(effect.getVariable()) + && // Refers to the same variable + rightPort.getContainer() == effect.getContainer() + && // Refers to the same instance + (reaction.eContainer() instanceof Reactor + || // Either is not part of a mode + connection.eContainer() instanceof Reactor + || connection.eContainer() + == reaction.eContainer() // Or they are in the same mode + )) { + error( + "Cannot connect: Port named '" + + effect.getVariable().getName() + + "' is already effect of a reaction.", + Literals.CONNECTION__RIGHT_PORTS); + } } + } + } - // FIXME: report error if resource cannot be resolved. - for (ImportedReactor reactor : imp.getReactorClasses()) { - if (!isUnused(reactor)) { - return; + // Check that the right port does not already have some other + // upstream connection. + for (Connection c : reactor.getConnections()) { + if (c != connection) { + for (VarRef thisRightPort : connection.getRightPorts()) { + for (VarRef thatRightPort : c.getRightPorts()) { + if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) + && // Refers to the same variable + thisRightPort.getContainer() == thatRightPort.getContainer() + && // Refers to the same instance + (connection.eContainer() instanceof Reactor + || // Or either of the connections in not part of a mode + c.eContainer() instanceof Reactor + || connection.eContainer() == c.eContainer() // Or they are in the same mode + )) { + error( + "Cannot connect: Port named '" + + thisRightPort.getVariable().getName() + + "' may only appear once on the right side of a connection.", + Literals.CONNECTION__RIGHT_PORTS); } + } } - warning("Unused import.", Literals.IMPORT__IMPORT_URI); + } } - @Check - public void checkImportedReactor(ImportedReactor reactor) { - if (isUnused(reactor)) { - warning("Unused reactor class.", - Literals.IMPORTED_REACTOR__REACTOR_CLASS); - } - - if (info.instantiationGraph.hasCycles()) { - Set cycleSet = new HashSet<>(); - for (Set cycle : info.instantiationGraph.getCycles()) { - cycleSet.addAll(cycle); - } - if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { - error("Imported reactor '" + toDefinition(reactor).getName() + - "' has cyclic instantiation in it.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); - } - } + // Check the after delay + if (connection.getDelay() != null) { + final var delay = connection.getDelay(); + if (delay instanceof ParameterReference + || delay instanceof Time + || delay instanceof Literal) { + checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); + } else { + error( + "After delays can only be given by time literals or parameters.", + Literals.CONNECTION__DELAY); + } + } + } + + @Check(CheckType.FAST) + public void checkDeadline(Deadline deadline) { + if (isCBasedTarget() && this.info.overflowingDeadlines.contains(deadline)) { + error( + "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.DEADLINE__DELAY); + } + checkExpressionIsTime(deadline.getDelay(), Literals.DEADLINE__DELAY); + } + + @Check(CheckType.FAST) + public void checkHost(Host host) { + String addr = host.getAddr(); + String user = host.getUser(); + if (user != null && !user.matches(USERNAME_REGEX)) { + warning("Invalid user name.", Literals.HOST__USER); } + if (host instanceof IPV4Host && !addr.matches(IPV4_REGEX)) { + warning("Invalid IP address.", Literals.HOST__ADDR); + } else if (host instanceof IPV6Host && !addr.matches(IPV6_REGEX)) { + warning("Invalid IP address.", Literals.HOST__ADDR); + } else if (host instanceof NamedHost && !addr.matches(HOST_OR_FQN_REGEX)) { + warning("Invalid host name or fully qualified domain name.", Literals.HOST__ADDR); + } + } - @Check(CheckType.FAST) - public void checkInput(Input input) { - Reactor parent = (Reactor)input.eContainer(); - if (parent.isMain() || parent.isFederated()) { - error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); - } - checkName(input.getName(), Literals.VARIABLE__NAME); - if (target.requiresTypes) { - if (input.getType() == null) { - error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); - } - } + @Check + public void checkImport(Import imp) { + if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { + error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. + return; + } - // mutable has no meaning in C++ - if (input.isMutable() && this.target == Target.CPP) { - warning( - "The mutable qualifier has no meaning for the C++ target and should be removed. " + - "In C++, any value can be made mutable by calling get_mutable_copy().", - Literals.INPUT__MUTABLE - ); - } + // FIXME: report error if resource cannot be resolved. + for (ImportedReactor reactor : imp.getReactorClasses()) { + if (!isUnused(reactor)) { + return; + } + } + warning("Unused import.", Literals.IMPORT__IMPORT_URI); + } - // Variable width multiports are not supported (yet?). - if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { - error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); - } + @Check + public void checkImportedReactor(ImportedReactor reactor) { + if (isUnused(reactor)) { + warning("Unused reactor class.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); } - @Check(CheckType.FAST) - public void checkInstantiation(Instantiation instantiation) { - checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); - Reactor reactor = toDefinition(instantiation.getReactorClass()); - if (reactor.isMain() || reactor.isFederated()) { - error( - "Cannot instantiate a main (or federated) reactor: " + - instantiation.getReactorClass().getName(), - Literals.INSTANTIATION__REACTOR_CLASS - ); - } + if (info.instantiationGraph.hasCycles()) { + Set cycleSet = new HashSet<>(); + for (Set cycle : info.instantiationGraph.getCycles()) { + cycleSet.addAll(cycle); + } + if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { + error( + "Imported reactor '" + + toDefinition(reactor).getName() + + "' has cyclic instantiation in it.", + Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } + } + } - // Report error if this instantiation is part of a cycle. - // FIXME: improve error message. - // FIXME: Also report if there exists a cycle within. - if (this.info.instantiationGraph.getCycles().size() > 0) { - for (Set cycle : this.info.instantiationGraph.getCycles()) { - Reactor container = (Reactor) instantiation.eContainer(); - if (cycle.contains(container) && cycle.contains(reactor)) { - List names = new ArrayList<>(); - for (Reactor r : cycle) { - names.add(r.getName()); - } - - error( - "Instantiation is part of a cycle: " + String.join(", ", names) + ".", - Literals.INSTANTIATION__REACTOR_CLASS - ); - } - } - } - // Variable width multiports are not supported (yet?). - if (instantiation.getWidthSpec() != null - && instantiation.getWidthSpec().isOfVariableLength() - ) { - if (isCBasedTarget()) { - warning("Variable-width banks are for internal use only.", - Literals.INSTANTIATION__WIDTH_SPEC - ); - } else { - error("Variable-width banks are not supported.", - Literals.INSTANTIATION__WIDTH_SPEC - ); - } - } + @Check(CheckType.FAST) + public void checkInput(Input input) { + Reactor parent = (Reactor) input.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); + } + checkName(input.getName(), Literals.VARIABLE__NAME); + if (target.requiresTypes) { + if (input.getType() == null) { + error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); + } } - /** Check target parameters, which are key-value pairs. */ - @Check(CheckType.FAST) - public void checkKeyValuePair(KeyValuePair param) { - // Check only if the container's container is a Target. - if (param.eContainer().eContainer() instanceof TargetDecl) { - TargetProperty prop = TargetProperty.forName(param.getName()); - - // Make sure the key is valid. - if (prop == null) { - String options = TargetProperty.getOptions().stream() - .map(p -> p.description).sorted() - .collect(Collectors.joining(", ")); - warning( - "Unrecognized target parameter: " + param.getName() + - ". Recognized parameters are: " + options, - Literals.KEY_VALUE_PAIR__NAME); - } else { - // Check whether the property is supported by the target. - if (!prop.supportedBy.contains(this.target)) { - warning( - "The target parameter: " + param.getName() + - " is not supported by the " + this.target + - " target and will thus be ignored.", - Literals.KEY_VALUE_PAIR__NAME); - } + // mutable has no meaning in C++ + if (input.isMutable() && this.target == Target.CPP) { + warning( + "The mutable qualifier has no meaning for the C++ target and should be removed. " + + "In C++, any value can be made mutable by calling get_mutable_copy().", + Literals.INPUT__MUTABLE); + } - // Report problem with the assigned value. - prop.type.check(param.getValue(), param.getName(), this); - } + // Variable width multiports are not supported (yet?). + if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } + } + + @Check(CheckType.FAST) + public void checkInstantiation(Instantiation instantiation) { + checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); + Reactor reactor = toDefinition(instantiation.getReactorClass()); + if (reactor.isMain() || reactor.isFederated()) { + error( + "Cannot instantiate a main (or federated) reactor: " + + instantiation.getReactorClass().getName(), + Literals.INSTANTIATION__REACTOR_CLASS); + } - for (String it : targetPropertyErrors) { - error(it, Literals.KEY_VALUE_PAIR__VALUE); - } - targetPropertyErrors.clear(); + // Report error if this instantiation is part of a cycle. + // FIXME: improve error message. + // FIXME: Also report if there exists a cycle within. + if (this.info.instantiationGraph.getCycles().size() > 0) { + for (Set cycle : this.info.instantiationGraph.getCycles()) { + Reactor container = (Reactor) instantiation.eContainer(); + if (cycle.contains(container) && cycle.contains(reactor)) { + List names = new ArrayList<>(); + for (Reactor r : cycle) { + names.add(r.getName()); + } - for (String it : targetPropertyWarnings) { - error(it, Literals.KEY_VALUE_PAIR__VALUE); - } - targetPropertyWarnings.clear(); + error( + "Instantiation is part of a cycle: " + String.join(", ", names) + ".", + Literals.INSTANTIATION__REACTOR_CLASS); } + } } - - @Check(CheckType.FAST) - public void checkModel(Model model) { - // Since we're doing a fast check, we only want to update - // if the model info hasn't been initialized yet. If it has, - // we use the old information and update it during a normal - // check (see below). - if (!info.updated) { - info.update(model, errorReporter); - } + // Variable width multiports are not supported (yet?). + if (instantiation.getWidthSpec() != null && instantiation.getWidthSpec().isOfVariableLength()) { + if (isCBasedTarget()) { + warning( + "Variable-width banks are for internal use only.", Literals.INSTANTIATION__WIDTH_SPEC); + } else { + error("Variable-width banks are not supported.", Literals.INSTANTIATION__WIDTH_SPEC); + } + } + } + + /** Check target parameters, which are key-value pairs. */ + @Check(CheckType.FAST) + public void checkKeyValuePair(KeyValuePair param) { + // Check only if the container's container is a Target. + if (param.eContainer().eContainer() instanceof TargetDecl) { + TargetProperty prop = TargetProperty.forName(param.getName()); + + // Make sure the key is valid. + if (prop == null) { + String options = + TargetProperty.getOptions().stream() + .map(p -> p.description) + .sorted() + .collect(Collectors.joining(", ")); + warning( + "Unrecognized target parameter: " + + param.getName() + + ". Recognized parameters are: " + + options, + Literals.KEY_VALUE_PAIR__NAME); + } else { + // Check whether the property is supported by the target. + if (!prop.supportedBy.contains(this.target)) { + warning( + "The target parameter: " + + param.getName() + + " is not supported by the " + + this.target + + " target and will thus be ignored.", + Literals.KEY_VALUE_PAIR__NAME); + } + + // Report problem with the assigned value. + prop.type.check(param.getValue(), param.getName(), this); + } + + for (String it : targetPropertyErrors) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyErrors.clear(); + + for (String it : targetPropertyWarnings) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyWarnings.clear(); + } + } + + @Check(CheckType.FAST) + public void checkModel(Model model) { + // Since we're doing a fast check, we only want to update + // if the model info hasn't been initialized yet. If it has, + // we use the old information and update it during a normal + // check (see below). + if (!info.updated) { + info.update(model, errorReporter); + } + } + + @Check(CheckType.NORMAL) + public void updateModelInfo(Model model) { + info.update(model, errorReporter); + } + + @Check(CheckType.FAST) + public void checkOutput(Output output) { + Reactor parent = (Reactor) output.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); + } + checkName(output.getName(), Literals.VARIABLE__NAME); + if (this.target.requiresTypes) { + if (output.getType() == null) { + error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); + } } - @Check(CheckType.NORMAL) - public void updateModelInfo(Model model) { - info.update(model, errorReporter); + // Variable width multiports are not supported (yet?). + if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); } + } - @Check(CheckType.FAST) - public void checkOutput(Output output) { - Reactor parent = (Reactor)output.eContainer(); - if (parent.isMain() || parent.isFederated()) { - error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); - } - checkName(output.getName(), Literals.VARIABLE__NAME); - if (this.target.requiresTypes) { - if (output.getType() == null) { - error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); - } - } + @Check(CheckType.FAST) + public void checkParameter(Parameter param) { + checkName(param.getName(), Literals.PARAMETER__NAME); - // Variable width multiports are not supported (yet?). - if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { - error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); - } + if (param.getInit() == null) { + // todo make initialization non-mandatory + // https://github.com/lf-lang/lingua-franca/issues/623 + error("Parameter must have a default value.", Literals.PARAMETER__INIT); + return; } - @Check(CheckType.FAST) - public void checkParameter(Parameter param) { - checkName(param.getName(), Literals.PARAMETER__NAME); + if (this.target.requiresTypes) { + // Report missing target type. param.inferredType.undefine + if (ASTUtils.getInferredType(param).isUndefined()) { + error("Type declaration missing.", Literals.PARAMETER__TYPE); + } + } - if (param.getInit() == null) { - // todo make initialization non-mandatory - // https://github.com/lf-lang/lingua-franca/issues/623 - error("Parameter must have a default value.", Literals.PARAMETER__INIT); - return; - } + if (param.getType() != null) { + typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); + } - if (this.target.requiresTypes) { - // Report missing target type. param.inferredType.undefine - if (ASTUtils.getInferredType(param).isUndefined()) { - error("Type declaration missing.", Literals.PARAMETER__TYPE); - } + if (param.getInit() != null) { + for (Expression expr : param.getInit().getExprs()) { + if (expr instanceof ParameterReference) { + // Initialization using parameters is forbidden. + error("Parameter cannot be initialized using parameter.", Literals.PARAMETER__INIT); } + } + } - if (param.getType() != null) { - typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); - } + if (this.target == Target.CPP) { + EObject container = param.eContainer(); + Reactor reactor = (Reactor) container; + if (reactor.isMain()) { + // we need to check for the cli parameters that are always taken + List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); + if (cliParams.contains(param.getName())) { + error( + "Parameter '" + + param.getName() + + "' is already in use as command line argument by Lingua Franca,", + Literals.PARAMETER__NAME); + } + } + } - if (param.getInit() != null) { - for (Expression expr : param.getInit().getExprs()) { - if (expr instanceof ParameterReference) { - // Initialization using parameters is forbidden. - error("Parameter cannot be initialized using parameter.", - Literals.PARAMETER__INIT); - } - } + if (isCBasedTarget() && this.info.overflowingParameters.contains(param)) { + error( + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + + " nanoseconds.", + Literals.PARAMETER__INIT); + } + } + + @Check(CheckType.FAST) + public void checkPreamble(Preamble preamble) { + if (this.target == Target.CPP) { + if (preamble.getVisibility() == Visibility.NONE) { + error( + "Preambles for the C++ target need a visibility qualifier (private or public)!", + Literals.PREAMBLE__VISIBILITY); + } else if (preamble.getVisibility() == Visibility.PRIVATE) { + EObject container = preamble.eContainer(); + if (container != null && container instanceof Reactor) { + Reactor reactor = (Reactor) container; + if (isGeneric(reactor)) { + warning( + "Private preambles in generic reactors are not truly private. " + + "Since the generated code is placed in a *_impl.hh file, it will " + + "be visible on the public interface. Consider using a public " + + "preamble within the reactor or a private preamble on file scope.", + Literals.PREAMBLE__VISIBILITY); + } } + } + } else if (preamble.getVisibility() != Visibility.NONE) { + warning( + String.format( + "The %s qualifier has no meaning for the %s target. It should be removed.", + preamble.getVisibility(), this.target.name()), + Literals.PREAMBLE__VISIBILITY); + } + } - if (this.target == Target.CPP) { - EObject container = param.eContainer(); - Reactor reactor = (Reactor) container; - if (reactor.isMain()) { - // we need to check for the cli parameters that are always taken - List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); - if (cliParams.contains(param.getName())) { - error("Parameter '" + param.getName() - + "' is already in use as command line argument by Lingua Franca,", - Literals.PARAMETER__NAME); - } - } - } + @Check(CheckType.FAST) + public void checkReaction(Reaction reaction) { - if (isCBasedTarget() && - this.info.overflowingParameters.contains(param)) { + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); + } + HashSet triggers = new HashSet<>(); + // Make sure input triggers have no container and output sources do. + for (TriggerRef trigger : reaction.getTriggers()) { + if (trigger instanceof VarRef) { + VarRef triggerVarRef = (VarRef) trigger; + triggers.add(triggerVarRef.getVariable()); + if (triggerVarRef instanceof Input) { + if (triggerVarRef.getContainer() != null) { + error( + String.format( + "Cannot have an input of a contained reactor as a trigger: %s.%s", + triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } + } else if (triggerVarRef.getVariable() instanceof Output) { + if (triggerVarRef.getContainer() == null) { error( - "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.PARAMETER__INIT); + String.format( + "Cannot have an output of this reactor as a trigger: %s", + triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } } - + } } - @Check(CheckType.FAST) - public void checkPreamble(Preamble preamble) { - if (this.target == Target.CPP) { - if (preamble.getVisibility() == Visibility.NONE) { - error( - "Preambles for the C++ target need a visibility qualifier (private or public)!", - Literals.PREAMBLE__VISIBILITY - ); - } else if (preamble.getVisibility() == Visibility.PRIVATE) { - EObject container = preamble.eContainer(); - if (container != null && container instanceof Reactor) { - Reactor reactor = (Reactor) container; - if (isGeneric(reactor)) { - warning( - "Private preambles in generic reactors are not truly private. " + - "Since the generated code is placed in a *_impl.hh file, it will " + - "be visible on the public interface. Consider using a public " + - "preamble within the reactor or a private preamble on file scope.", - Literals.PREAMBLE__VISIBILITY); - } - } - } - } else if (preamble.getVisibility() != Visibility.NONE) { - warning( - String.format("The %s qualifier has no meaning for the %s target. It should be removed.", - preamble.getVisibility(), this.target.name()), - Literals.PREAMBLE__VISIBILITY - ); - } + // Make sure input sources have no container and output sources do. + // Also check that a source is not already listed as a trigger. + for (VarRef source : reaction.getSources()) { + if (triggers.contains(source.getVariable())) { + error( + String.format( + "Source is already listed as a trigger: %s", source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + if (source.getVariable() instanceof Input) { + if (source.getContainer() != null) { + error( + String.format( + "Cannot have an input of a contained reactor as a source: %s.%s", + source.getContainer().getName(), source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } else if (source.getVariable() instanceof Output) { + if (source.getContainer() == null) { + error( + String.format( + "Cannot have an output of this reactor as a source: %s", + source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } } - @Check(CheckType.FAST) - public void checkReaction(Reaction reaction) { - - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); - } - HashSet triggers = new HashSet<>(); - // Make sure input triggers have no container and output sources do. - for (TriggerRef trigger : reaction.getTriggers()) { - if (trigger instanceof VarRef) { - VarRef triggerVarRef = (VarRef) trigger; - triggers.add(triggerVarRef.getVariable()); - if (triggerVarRef instanceof Input) { - if (triggerVarRef.getContainer() != null) { - error(String.format("Cannot have an input of a contained reactor as a trigger: %s.%s", triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), - Literals.REACTION__TRIGGERS); - } - } else if (triggerVarRef.getVariable() instanceof Output) { - if (triggerVarRef.getContainer() == null) { - error(String.format("Cannot have an output of this reactor as a trigger: %s", triggerVarRef.getVariable().getName()), - Literals.REACTION__TRIGGERS); - } - } - } - } - - // Make sure input sources have no container and output sources do. - // Also check that a source is not already listed as a trigger. - for (VarRef source : reaction.getSources()) { - if (triggers.contains(source.getVariable())) { - error(String.format("Source is already listed as a trigger: %s", source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - if (source.getVariable() instanceof Input) { - if (source.getContainer() != null) { - error(String.format("Cannot have an input of a contained reactor as a source: %s.%s", source.getContainer().getName(), source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - } else if (source.getVariable() instanceof Output) { - if (source.getContainer() == null) { - error(String.format("Cannot have an output of this reactor as a source: %s", source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - } - } + // Make sure output effects have no container and input effects do. + for (VarRef effect : reaction.getEffects()) { + if (effect.getVariable() instanceof Input) { + if (effect.getContainer() == null) { + error( + String.format( + "Cannot have an input of this reactor as an effect: %s", + effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } else if (effect.getVariable() instanceof Output) { + if (effect.getContainer() != null) { + error( + String.format( + "Cannot have an output of a contained reactor as an effect: %s.%s", + effect.getContainer().getName(), effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } + } - // Make sure output effects have no container and input effects do. - for (VarRef effect : reaction.getEffects()) { - if (effect.getVariable() instanceof Input) { - if (effect.getContainer() == null) { - error(String.format("Cannot have an input of this reactor as an effect: %s", effect.getVariable().getName()), - Literals.REACTION__EFFECTS); - } - } else if (effect.getVariable() instanceof Output) { - if (effect.getContainer() != null) { - error(String.format("Cannot have an output of a contained reactor as an effect: %s.%s", effect.getContainer().getName(), effect.getVariable().getName()), - Literals.REACTION__EFFECTS); - } - } + // // Report error if this reaction is part of a cycle. + Set> cycles = this.info.topologyCycles(); + Reactor reactor = ASTUtils.getEnclosingReactor(reaction); + boolean reactionInCycle = false; + for (NamedInstance it : cycles) { + if (it.getDefinition().equals(reaction)) { + reactionInCycle = true; + break; + } + } + if (reactionInCycle) { + // Report involved triggers. + List trigs = new ArrayList<>(); + for (TriggerRef t : reaction.getTriggers()) { + if (!(t instanceof VarRef)) { + continue; + } + VarRef tVarRef = (VarRef) t; + boolean triggerExistsInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(tVarRef.getVariable())) { + triggerExistsInCycle = true; + break; + } } - - // // Report error if this reaction is part of a cycle. - Set> cycles = this.info.topologyCycles(); - Reactor reactor = ASTUtils.getEnclosingReactor(reaction); - boolean reactionInCycle = false; - for (NamedInstance it : cycles) { - if (it.getDefinition().equals(reaction)) { - reactionInCycle = true; - break; - } + if (triggerExistsInCycle) { + trigs.add(toOriginalText(tVarRef)); + } + } + if (trigs.size() > 0) { + error( + String.format( + "Reaction triggers involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", trigs)), + Literals.REACTION__TRIGGERS); + } + + // Report involved sources. + List sources = new ArrayList<>(); + for (VarRef t : reaction.getSources()) { + boolean sourceExistInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(t.getVariable())) { + sourceExistInCycle = true; + break; + } } - if (reactionInCycle) { - // Report involved triggers. - List trigs = new ArrayList<>(); - for (TriggerRef t : reaction.getTriggers()) { - if (!(t instanceof VarRef)) { - continue; - } - VarRef tVarRef = (VarRef) t; - boolean triggerExistsInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(tVarRef.getVariable())) { - triggerExistsInCycle = true; - break; - } - } - if (triggerExistsInCycle) { - trigs.add(toOriginalText(tVarRef)); - } - } - if (trigs.size() > 0) { - error(String.format("Reaction triggers involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", trigs)), - Literals.REACTION__TRIGGERS); - } - - // Report involved sources. - List sources = new ArrayList<>(); - for (VarRef t : reaction.getSources()) { - boolean sourceExistInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(t.getVariable())) { - sourceExistInCycle = true; - break; - } - } - if (sourceExistInCycle) { - sources.add(toOriginalText(t)); - } - } - if (sources.size() > 0) { - error(String.format("Reaction sources involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", sources)), - Literals.REACTION__SOURCES); - } - - // Report involved effects. - List effects = new ArrayList<>(); - for (VarRef t : reaction.getEffects()) { - boolean effectExistInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(t.getVariable())) { - effectExistInCycle = true; - break; - } - } - if (effectExistInCycle) { - effects.add(toOriginalText(t)); - } - } - if (effects.size() > 0) { - error(String.format("Reaction effects involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", effects)), - Literals.REACTION__EFFECTS); - } - - if (trigs.size() + sources.size() == 0) { - error( - String.format("Cyclic dependency due to preceding reaction. Consider reordering reactions within reactor %s to avoid causality loop.", reactor.getName()), - reaction.eContainer(), - Literals.REACTOR__REACTIONS, - reactor.getReactions().indexOf(reaction) - ); - } else if (effects.size() == 0) { - error( - String.format("Cyclic dependency due to succeeding reaction. Consider reordering reactions within reactor %s to avoid causality loop.", reactor.getName()), - reaction.eContainer(), - Literals.REACTOR__REACTIONS, - reactor.getReactions().indexOf(reaction) - ); - } - // Not reporting reactions that are part of cycle _only_ due to reaction ordering. - // Moving them won't help solve the problem. + if (sourceExistInCycle) { + sources.add(toOriginalText(t)); + } + } + if (sources.size() > 0) { + error( + String.format( + "Reaction sources involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", sources)), + Literals.REACTION__SOURCES); + } + + // Report involved effects. + List effects = new ArrayList<>(); + for (VarRef t : reaction.getEffects()) { + boolean effectExistInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(t.getVariable())) { + effectExistInCycle = true; + break; + } } + if (effectExistInCycle) { + effects.add(toOriginalText(t)); + } + } + if (effects.size() > 0) { + error( + String.format( + "Reaction effects involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", effects)), + Literals.REACTION__EFFECTS); + } + + if (trigs.size() + sources.size() == 0) { + error( + String.format( + "Cyclic dependency due to preceding reaction. Consider reordering reactions within" + + " reactor %s to avoid causality loop.", + reactor.getName()), + reaction.eContainer(), + Literals.REACTOR__REACTIONS, + reactor.getReactions().indexOf(reaction)); + } else if (effects.size() == 0) { + error( + String.format( + "Cyclic dependency due to succeeding reaction. Consider reordering reactions within" + + " reactor %s to avoid causality loop.", + reactor.getName()), + reaction.eContainer(), + Literals.REACTOR__REACTIONS, + reactor.getReactions().indexOf(reaction)); + } + // Not reporting reactions that are part of cycle _only_ due to reaction ordering. + // Moving them won't help solve the problem. + } // FIXME: improve error message. + } + + @Check(CheckType.FAST) + public void checkReactor(Reactor reactor) throws IOException { + Set superClasses = ASTUtils.superClasses(reactor); + if (superClasses == null) { + error( + "Problem with superclasses: Either they form a cycle or are not defined", + Literals.REACTOR_DECL__NAME); + // Continue checks, but without any superclasses. + superClasses = new LinkedHashSet<>(); } - - @Check(CheckType.FAST) - public void checkReactor(Reactor reactor) throws IOException { - Set superClasses = ASTUtils.superClasses(reactor); - if (superClasses == null) { - error( - "Problem with superclasses: Either they form a cycle or are not defined", - Literals.REACTOR_DECL__NAME - ); - // Continue checks, but without any superclasses. - superClasses = new LinkedHashSet<>(); - } - String name = FileUtil.nameWithoutExtension(reactor.eResource()); - if (reactor.getName() == null) { - if (!reactor.isFederated() && !reactor.isMain()) { - error( - "Reactor must be named.", - Literals.REACTOR_DECL__NAME - ); - // Prevent NPE in tests below. - return; - } - } - TreeIterator iter = reactor.eResource().getAllContents(); - if (reactor.isFederated() || reactor.isMain()) { - if(reactor.getName() != null && !reactor.getName().equals(name)) { - // Make sure that if the name is given, it matches the expected name. - error( - "Name of main reactor must match the file name (or be omitted).", - Literals.REACTOR_DECL__NAME - ); - } - // Do not allow multiple main/federated reactors. - int nMain = countMainOrFederated(iter); - if (nMain > 1) { - EAttribute attribute = Literals.REACTOR__MAIN; - if (reactor.isFederated()) { - attribute = Literals.REACTOR__FEDERATED; - } - error( - "Multiple definitions of main or federated reactor.", - attribute - ); - } - } else { - // Not federated or main. - int nMain = countMainOrFederated(iter); - if (nMain > 0 && reactor.getName().equals(name)) { - error( - "Name conflict with main reactor.", - Literals.REACTOR_DECL__NAME - ); - } - } - - // Check for illegal names. - checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); - - // C++ reactors may not be called 'preamble' - if (this.target == Target.CPP && reactor.getName().equalsIgnoreCase("preamble")) { - error( - "Reactor cannot be named '" + reactor.getName() + "'", - Literals.REACTOR_DECL__NAME - ); - } - - if (reactor.getHost() != null) { - if (!reactor.isFederated()) { - error( - "Cannot assign a host to reactor '" + reactor.getName() + - "' because it is not federated.", - Literals.REACTOR__HOST - ); - } - } - - List variables = new ArrayList<>(); - variables.addAll(reactor.getInputs()); - variables.addAll(reactor.getOutputs()); - variables.addAll(reactor.getActions()); - variables.addAll(reactor.getTimers()); - - // Perform checks on super classes. - for (Reactor superClass : superClasses) { - HashSet conflicts = new HashSet<>(); - - // Detect input conflicts - checkConflict(superClass.getInputs(), reactor.getInputs(), variables, conflicts); - // Detect output conflicts - checkConflict(superClass.getOutputs(), reactor.getOutputs(), variables, conflicts); - // Detect output conflicts - checkConflict(superClass.getActions(), reactor.getActions(), variables, conflicts); - // Detect conflicts - for (Timer timer : superClass.getTimers()) { - List filteredVariables = new ArrayList<>(variables); - filteredVariables.removeIf(it -> reactor.getTimers().contains(it)); - if (hasNameConflict(timer, filteredVariables)) { - conflicts.add(timer); - } else { - variables.add(timer); - } - } - - // Report conflicts. - if (conflicts.size() > 0) { - List names = new ArrayList<>(); - for (Variable it : conflicts) { - names.add(it.getName()); - } - error( - String.format("Cannot extend %s due to the following conflicts: %s.", - superClass.getName(), String.join(",", names)), - Literals.REACTOR__SUPER_CLASSES - ); - } - } - + String name = FileUtil.nameWithoutExtension(reactor.eResource()); + if (reactor.getName() == null) { + if (!reactor.isFederated() && !reactor.isMain()) { + error("Reactor must be named.", Literals.REACTOR_DECL__NAME); + // Prevent NPE in tests below. + return; + } + } + TreeIterator iter = reactor.eResource().getAllContents(); + if (reactor.isFederated() || reactor.isMain()) { + if (reactor.getName() != null && !reactor.getName().equals(name)) { + // Make sure that if the name is given, it matches the expected name. + error( + "Name of main reactor must match the file name (or be omitted).", + Literals.REACTOR_DECL__NAME); + } + // Do not allow multiple main/federated reactors. + int nMain = countMainOrFederated(iter); + if (nMain > 1) { + EAttribute attribute = Literals.REACTOR__MAIN; if (reactor.isFederated()) { - FedValidator.validateFederatedReactor(reactor, this.errorReporter); - } + attribute = Literals.REACTOR__FEDERATED; + } + error("Multiple definitions of main or federated reactor.", attribute); + } + } else { + // Not federated or main. + int nMain = countMainOrFederated(iter); + if (nMain > 0 && reactor.getName().equals(name)) { + error("Name conflict with main reactor.", Literals.REACTOR_DECL__NAME); + } } - /** - * Check if the requested serialization is supported. - */ - @Check(CheckType.FAST) - public void checkSerializer(Serializer serializer) { - boolean isValidSerializer = false; - for (SupportedSerializers method : SupportedSerializers.values()) { - if (method.name().equalsIgnoreCase(serializer.getType())){ - isValidSerializer = true; - } - } + // Check for illegal names. + checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); - if (!isValidSerializer) { - error( - "Serializer can be " + Arrays.asList(SupportedSerializers.values()), - Literals.SERIALIZER__TYPE - ); - } + // C++ reactors may not be called 'preamble' + if (this.target == Target.CPP && reactor.getName().equalsIgnoreCase("preamble")) { + error("Reactor cannot be named '" + reactor.getName() + "'", Literals.REACTOR_DECL__NAME); } - @Check(CheckType.FAST) - public void checkState(StateVar stateVar) { - checkName(stateVar.getName(), Literals.STATE_VAR__NAME); - if (stateVar.getInit() != null && stateVar.getInit().getExprs().size() != 0) { - typeCheck(stateVar.getInit(), ASTUtils.getInferredType(stateVar), Literals.STATE_VAR__INIT); - } + if (reactor.getHost() != null) { + if (!reactor.isFederated()) { + error( + "Cannot assign a host to reactor '" + + reactor.getName() + + "' because it is not federated.", + Literals.REACTOR__HOST); + } + } - if (this.target.requiresTypes && ASTUtils.getInferredType(stateVar).isUndefined()) { - // Report if a type is missing - error("State must have a type.", Literals.STATE_VAR__TYPE); - } + List variables = new ArrayList<>(); + variables.addAll(reactor.getInputs()); + variables.addAll(reactor.getOutputs()); + variables.addAll(reactor.getActions()); + variables.addAll(reactor.getTimers()); + + // Perform checks on super classes. + for (Reactor superClass : superClasses) { + HashSet conflicts = new HashSet<>(); + + // Detect input conflicts + checkConflict(superClass.getInputs(), reactor.getInputs(), variables, conflicts); + // Detect output conflicts + checkConflict(superClass.getOutputs(), reactor.getOutputs(), variables, conflicts); + // Detect output conflicts + checkConflict(superClass.getActions(), reactor.getActions(), variables, conflicts); + // Detect conflicts + for (Timer timer : superClass.getTimers()) { + List filteredVariables = new ArrayList<>(variables); + filteredVariables.removeIf(it -> reactor.getTimers().contains(it)); + if (hasNameConflict(timer, filteredVariables)) { + conflicts.add(timer); + } else { + variables.add(timer); + } + } + + // Report conflicts. + if (conflicts.size() > 0) { + List names = new ArrayList<>(); + for (Variable it : conflicts) { + names.add(it.getName()); + } + error( + String.format( + "Cannot extend %s due to the following conflicts: %s.", + superClass.getName(), String.join(",", names)), + Literals.REACTOR__SUPER_CLASSES); + } + } - if (isCBasedTarget() - && ASTUtils.isListInitializer(stateVar.getInit()) - && stateVar.getInit().getExprs().stream().anyMatch(it -> it instanceof ParameterReference)) { - // In C, if initialization is done with a list, elements cannot - // refer to parameters. - error("List items cannot refer to a parameter.", - Literals.STATE_VAR__INIT); - } + if (reactor.isFederated()) { + FedValidator.validateFederatedReactor(reactor, this.errorReporter); + } + } + + /** Check if the requested serialization is supported. */ + @Check(CheckType.FAST) + public void checkSerializer(Serializer serializer) { + boolean isValidSerializer = false; + for (SupportedSerializers method : SupportedSerializers.values()) { + if (method.name().equalsIgnoreCase(serializer.getType())) { + isValidSerializer = true; + } + } + if (!isValidSerializer) { + error( + "Serializer can be " + Arrays.asList(SupportedSerializers.values()), + Literals.SERIALIZER__TYPE); } + } - @Check(CheckType.FAST) - public void checkSTPOffset(STP stp) { - if (isCBasedTarget() && - this.info.overflowingSTP.contains(stp)) { - error( - "STP offset exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.STP__VALUE); - } + @Check(CheckType.FAST) + public void checkState(StateVar stateVar) { + checkName(stateVar.getName(), Literals.STATE_VAR__NAME); + if (stateVar.getInit() != null && stateVar.getInit().getExprs().size() != 0) { + typeCheck(stateVar.getInit(), ASTUtils.getInferredType(stateVar), Literals.STATE_VAR__INIT); } - @Check(CheckType.FAST) - public void checkTargetDecl(TargetDecl target) throws IOException { - Optional targetOpt = Target.forName(target.getName()); - if (targetOpt.isEmpty()) { - error("Unrecognized target: " + target.getName(), - Literals.TARGET_DECL__NAME); - } else { - this.target = targetOpt.get(); - } - String lfFileName = FileUtil.nameWithoutExtension(target.eResource()); - if (Character.isDigit(lfFileName.charAt(0))) { - errorReporter.reportError("LF file names must not start with a number"); - } + if (this.target.requiresTypes && ASTUtils.getInferredType(stateVar).isUndefined()) { + // Report if a type is missing + error("State must have a type.", Literals.STATE_VAR__TYPE); } - /** - * Check for consistency of the target properties, which are - * defined as KeyValuePairs. - * - * @param targetProperties The target properties defined - * in the current Lingua Franca program. - */ - @Check(CheckType.EXPENSIVE) - public void checkTargetProperties(KeyValuePairs targetProperties) { - validateFastTargetProperty(targetProperties); - validateClockSyncTargetProperties(targetProperties); - validateSchedulerTargetProperties(targetProperties); - validateRos2TargetProperties(targetProperties); - validateKeepalive(targetProperties); - } - - private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { - List properties = targetProperties.getPairs().stream() + if (isCBasedTarget() + && ASTUtils.isListInitializer(stateVar.getInit()) + && stateVar.getInit().getExprs().stream() + .anyMatch(it -> it instanceof ParameterReference)) { + // In C, if initialization is done with a list, elements cannot + // refer to parameters. + error("List items cannot refer to a parameter.", Literals.STATE_VAR__INIT); + } + } + + @Check(CheckType.FAST) + public void checkSTPOffset(STP stp) { + if (isCBasedTarget() && this.info.overflowingSTP.contains(stp)) { + error( + "STP offset exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.STP__VALUE); + } + } + + @Check(CheckType.FAST) + public void checkTargetDecl(TargetDecl target) throws IOException { + Optional targetOpt = Target.forName(target.getName()); + if (targetOpt.isEmpty()) { + error("Unrecognized target: " + target.getName(), Literals.TARGET_DECL__NAME); + } else { + this.target = targetOpt.get(); + } + String lfFileName = FileUtil.nameWithoutExtension(target.eResource()); + if (Character.isDigit(lfFileName.charAt(0))) { + errorReporter.reportError("LF file names must not start with a number"); + } + } + + /** + * Check for consistency of the target properties, which are defined as KeyValuePairs. + * + * @param targetProperties The target properties defined in the current Lingua Franca program. + */ + @Check(CheckType.EXPENSIVE) + public void checkTargetProperties(KeyValuePairs targetProperties) { + validateFastTargetProperty(targetProperties); + validateClockSyncTargetProperties(targetProperties); + validateSchedulerTargetProperties(targetProperties); + validateRos2TargetProperties(targetProperties); + validateKeepalive(targetProperties); + } + + private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { + List properties = + targetProperties.getPairs().stream() .filter(pair -> pair.getName().equals(property.description)) .toList(); - assert (properties.size() <= 1); - return properties.size() > 0 ? properties.get(0) : null; - } - private void validateFastTargetProperty(KeyValuePairs targetProperties) { - KeyValuePair fastTargetProperty = getKeyValuePair(targetProperties, TargetProperty.FAST); - - if (fastTargetProperty != null) { - // Check for federated - for (Reactor reactor : info.model.getReactors()) { - // Check to see if the program has a federated reactor - if (reactor.isFederated()) { - error( - "The fast target property is incompatible with federated programs.", - fastTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - break; - } - } - - // Check for physical actions - for (Reactor reactor : info.model.getReactors()) { - // Check to see if the program has a physical action in a reactor - for (Action action : reactor.getActions()) { - if (action.getOrigin().equals(ActionOrigin.PHYSICAL)) { - error( - "The fast target property is incompatible with physical actions.", - fastTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - break; - } - } - } - } - } + assert (properties.size() <= 1); + return properties.size() > 0 ? properties.get(0) : null; + } - private void validateClockSyncTargetProperties(KeyValuePairs targetProperties) { - KeyValuePair clockSyncTargetProperty = getKeyValuePair(targetProperties, TargetProperty.CLOCK_SYNC); + private void validateFastTargetProperty(KeyValuePairs targetProperties) { + KeyValuePair fastTargetProperty = getKeyValuePair(targetProperties, TargetProperty.FAST); - if (clockSyncTargetProperty != null) { - boolean federatedExists = false; - for (Reactor reactor : info.model.getReactors()) { - if (reactor.isFederated()) { - federatedExists = true; - } - } - if (!federatedExists) { - warning( - "The clock-sync target property is incompatible with non-federated programs.", - clockSyncTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - } + if (fastTargetProperty != null) { + // Check for federated + for (Reactor reactor : info.model.getReactors()) { + // Check to see if the program has a federated reactor + if (reactor.isFederated()) { + error( + "The fast target property is incompatible with federated programs.", + fastTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + break; + } + } + + // Check for physical actions + for (Reactor reactor : info.model.getReactors()) { + // Check to see if the program has a physical action in a reactor + for (Action action : reactor.getActions()) { + if (action.getOrigin().equals(ActionOrigin.PHYSICAL)) { + error( + "The fast target property is incompatible with physical actions.", + fastTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + break; + } } + } } + } - private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { - KeyValuePair schedulerTargetProperty = getKeyValuePair(targetProperties, TargetProperty.SCHEDULER); - if (schedulerTargetProperty != null) { - String schedulerName = ASTUtils.elementToSingleString(schedulerTargetProperty.getValue()); - try { - if (!TargetProperty.SchedulerOption.valueOf(schedulerName) - .prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - // Filter reactors that contain at least one reaction that - // has a deadline handler. - if (info.model.getReactors().stream().anyMatch( - // Filter reactors that contain at least one reaction that - // has a deadline handler. - reactor -> ASTUtils.allReactions(reactor).stream().anyMatch( - reaction -> reaction.getDeadline() != null - )) - ) { - warning("This program contains deadlines, but the chosen " - + schedulerName - + " scheduler does not prioritize reaction execution " - + "based on deadlines. This might result in a sub-optimal " - + "scheduling.", schedulerTargetProperty, - Literals.KEY_VALUE_PAIR__VALUE); - } - } - } catch (IllegalArgumentException e) { - // the given scheduler is invalid, but this is already checked by - // checkTargetProperties - } - } - } + private void validateClockSyncTargetProperties(KeyValuePairs targetProperties) { + KeyValuePair clockSyncTargetProperty = + getKeyValuePair(targetProperties, TargetProperty.CLOCK_SYNC); - private void validateKeepalive(KeyValuePairs targetProperties) { - KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); - if (keepalive != null && target == Target.CPP) { - warning("The keepalive property is inferred automatically by the C++ " + - "runtime and the value given here is ignored", keepalive, Literals.KEY_VALUE_PAIR__NAME); - } + if (clockSyncTargetProperty != null) { + boolean federatedExists = false; + for (Reactor reactor : info.model.getReactors()) { + if (reactor.isFederated()) { + federatedExists = true; + } + } + if (!federatedExists) { + warning( + "The clock-sync target property is incompatible with non-federated programs.", + clockSyncTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + } } - - private void validateRos2TargetProperties(KeyValuePairs targetProperties) { - KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); - KeyValuePair ros2Dependencies = getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); - if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { + } + + private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { + KeyValuePair schedulerTargetProperty = + getKeyValuePair(targetProperties, TargetProperty.SCHEDULER); + if (schedulerTargetProperty != null) { + String schedulerName = ASTUtils.elementToSingleString(schedulerTargetProperty.getValue()); + try { + if (!TargetProperty.SchedulerOption.valueOf(schedulerName).prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + // Filter reactors that contain at least one reaction that + // has a deadline handler. + if (info.model.getReactors().stream() + .anyMatch( + // Filter reactors that contain at least one reaction that + // has a deadline handler. + reactor -> + ASTUtils.allReactions(reactor).stream() + .anyMatch(reaction -> reaction.getDeadline() != null))) { warning( - "Ignoring ros2-dependencies as ros2 compilation is disabled", - ros2Dependencies, - Literals.KEY_VALUE_PAIR__NAME - ); + "This program contains deadlines, but the chosen " + + schedulerName + + " scheduler does not prioritize reaction execution " + + "based on deadlines. This might result in a sub-optimal " + + "scheduling.", + schedulerTargetProperty, + Literals.KEY_VALUE_PAIR__VALUE); + } } + } catch (IllegalArgumentException e) { + // the given scheduler is invalid, but this is already checked by + // checkTargetProperties + } } - - @Check(CheckType.FAST) - public void checkTimer(Timer timer) { - checkName(timer.getName(), Literals.VARIABLE__NAME); - checkExpressionIsTime(timer.getOffset(), Literals.TIMER__OFFSET); - checkExpressionIsTime(timer.getPeriod(), Literals.TIMER__PERIOD); + } + + private void validateKeepalive(KeyValuePairs targetProperties) { + KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); + if (keepalive != null && target == Target.CPP) { + warning( + "The keepalive property is inferred automatically by the C++ " + + "runtime and the value given here is ignored", + keepalive, + Literals.KEY_VALUE_PAIR__NAME); } - - @Check(CheckType.FAST) - public void checkType(Type type) { - // FIXME: disallow the use of generics in C - if (this.target == Target.Python) { - if (type != null) { - error( - "Types are not allowed in the Python target", - Literals.TYPE__ID - ); - } - } + } + + private void validateRos2TargetProperties(KeyValuePairs targetProperties) { + KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); + KeyValuePair ros2Dependencies = + getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); + if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { + warning( + "Ignoring ros2-dependencies as ros2 compilation is disabled", + ros2Dependencies, + Literals.KEY_VALUE_PAIR__NAME); } - - @Check(CheckType.FAST) - public void checkVarRef(VarRef varRef) { - // check correct usage of interleaved - if (varRef.isInterleaved()) { - var supportedTargets = List.of(Target.CPP, Target.Python, Target.Rust); - if (!supportedTargets.contains(this.target) && !isCBasedTarget()) { - error("This target does not support interleaved port references.", Literals.VAR_REF__INTERLEAVED); - } - if (!(varRef.eContainer() instanceof Connection)) { - error("interleaved can only be used in connections.", Literals.VAR_REF__INTERLEAVED); - } - - if (varRef.getVariable() instanceof Port) { - // This test only works correctly if the variable is actually a port. If it is not a port, other - // validator rules will produce error messages. - if (varRef.getContainer() == null || varRef.getContainer().getWidthSpec() == null || - ((Port) varRef.getVariable()).getWidthSpec() == null - ) { - error("interleaved can only be used for multiports contained within banks.", Literals.VAR_REF__INTERLEAVED); - } - } - } + } + + @Check(CheckType.FAST) + public void checkTimer(Timer timer) { + checkName(timer.getName(), Literals.VARIABLE__NAME); + checkExpressionIsTime(timer.getOffset(), Literals.TIMER__OFFSET); + checkExpressionIsTime(timer.getPeriod(), Literals.TIMER__PERIOD); + } + + @Check(CheckType.FAST) + public void checkType(Type type) { + // FIXME: disallow the use of generics in C + if (this.target == Target.Python) { + if (type != null) { + error("Types are not allowed in the Python target", Literals.TYPE__ID); + } } - - /** - * Check whether an attribute is supported - * and the validity of the attribute. - * - * @param attr The attribute being checked - */ - @Check(CheckType.FAST) - public void checkAttributes(Attribute attr) { - String name = attr.getAttrName().toString(); - AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); - if (spec == null) { - error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); - return; - } - // Check the validity of the attribute. - spec.check(this, attr); + } + + @Check(CheckType.FAST) + public void checkVarRef(VarRef varRef) { + // check correct usage of interleaved + if (varRef.isInterleaved()) { + var supportedTargets = List.of(Target.CPP, Target.Python, Target.Rust); + if (!supportedTargets.contains(this.target) && !isCBasedTarget()) { + error( + "This target does not support interleaved port references.", + Literals.VAR_REF__INTERLEAVED); + } + if (!(varRef.eContainer() instanceof Connection)) { + error("interleaved can only be used in connections.", Literals.VAR_REF__INTERLEAVED); + } + + if (varRef.getVariable() instanceof Port) { + // This test only works correctly if the variable is actually a port. If it is not a port, + // other + // validator rules will produce error messages. + if (varRef.getContainer() == null + || varRef.getContainer().getWidthSpec() == null + || ((Port) varRef.getVariable()).getWidthSpec() == null) { + error( + "interleaved can only be used for multiports contained within banks.", + Literals.VAR_REF__INTERLEAVED); + } + } } - - @Check(CheckType.FAST) - public void checkWidthSpec(WidthSpec widthSpec) { - if (!this.target.supportsMultiports()) { - error("Multiports and banks are currently not supported by the given target.", + } + + /** + * Check whether an attribute is supported and the validity of the attribute. + * + * @param attr The attribute being checked + */ + @Check(CheckType.FAST) + public void checkAttributes(Attribute attr) { + String name = attr.getAttrName().toString(); + AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); + if (spec == null) { + error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); + return; + } + // Check the validity of the attribute. + spec.check(this, attr); + } + + @Check(CheckType.FAST) + public void checkWidthSpec(WidthSpec widthSpec) { + if (!this.target.supportsMultiports()) { + error( + "Multiports and banks are currently not supported by the given target.", + Literals.WIDTH_SPEC__TERMS); + } else { + for (WidthTerm term : widthSpec.getTerms()) { + if (term.getParameter() != null) { + if (!this.target.supportsParameterizedWidths()) { + error( + "Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); - } else { - for (WidthTerm term : widthSpec.getTerms()) { - if (term.getParameter() != null) { - if (!this.target.supportsParameterizedWidths()) { - error("Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); - } - } else if (term.getPort() != null) { - // Widths given with `widthof()` are not supported (yet?). - // This feature is currently only used for after delays. - error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); - } else if (term.getCode() != null) { - if (this.target != Target.CPP) { - error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); - } - } else if (term.getWidth() < 0) { - error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); - } - } + } + } else if (term.getPort() != null) { + // Widths given with `widthof()` are not supported (yet?). + // This feature is currently only used for after delays. + error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); + } else if (term.getCode() != null) { + if (this.target != Target.CPP) { + error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); + } + } else if (term.getWidth() < 0) { + error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); } + } } - - @Check(CheckType.FAST) - public void checkReactorIconAttribute(Reactor reactor) { - var path = AttributeUtils.getIconPath(reactor); - if (path != null) { - var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); - // Check file extension - var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); - var extensionStrart = path.lastIndexOf("."); - var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; - if (!validExtensions.contains(extension.toLowerCase())) { - warning("File extension '" + extension + "' is not supported. Provide any of: " + String.join(", ", validExtensions), - param, Literals.ATTR_PARM__VALUE); - return; - } - - // Check file location - var iconLocation = FileUtil.locateFile(path, reactor.eResource()); - if (iconLocation == null) { - warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); - } - if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) && !(new File(iconLocation.getPath()).exists())) { - warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); - } - } + } + + @Check(CheckType.FAST) + public void checkReactorIconAttribute(Reactor reactor) { + var path = AttributeUtils.getIconPath(reactor); + if (path != null) { + var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); + // Check file extension + var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); + var extensionStrart = path.lastIndexOf("."); + var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; + if (!validExtensions.contains(extension.toLowerCase())) { + warning( + "File extension '" + + extension + + "' is not supported. Provide any of: " + + String.join(", ", validExtensions), + param, + Literals.ATTR_PARM__VALUE); + return; + } + + // Check file location + var iconLocation = FileUtil.locateFile(path, reactor.eResource()); + if (iconLocation == null) { + warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); + } + if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) + && !(new File(iconLocation.getPath()).exists())) { + warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); + } } - - @Check(CheckType.FAST) - public void checkInitialMode(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - long initialModesCount = reactor.getModes().stream().filter(m -> m.isInitial()).count(); - if (initialModesCount == 0) { - error("Every modal reactor requires one initial mode.", Literals.REACTOR__MODES, 0); - } else if (initialModesCount > 1) { - reactor.getModes().stream().filter(m -> m.isInitial()).skip(1).forEach(m -> { - error("A modal reactor can only have one initial mode.", - Literals.REACTOR__MODES, reactor.getModes().indexOf(m)); + } + + @Check(CheckType.FAST) + public void checkInitialMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + long initialModesCount = reactor.getModes().stream().filter(m -> m.isInitial()).count(); + if (initialModesCount == 0) { + error("Every modal reactor requires one initial mode.", Literals.REACTOR__MODES, 0); + } else if (initialModesCount > 1) { + reactor.getModes().stream() + .filter(m -> m.isInitial()) + .skip(1) + .forEach( + m -> { + error( + "A modal reactor can only have one initial mode.", + Literals.REACTOR__MODES, + reactor.getModes().indexOf(m)); }); - } + } + } + } + + @Check(CheckType.FAST) + public void checkModeStateNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getStateVars().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var stateVar : mode.getStateVars()) { + if (names.contains(stateVar.getName())) { + error( + String.format( + "Duplicate state variable '%s'. (State variables are currently scoped on" + + " reactor level not modes)", + stateVar.getName()), + stateVar, + Literals.STATE_VAR__NAME); + } + names.add(stateVar.getName()); } + } } - - @Check(CheckType.FAST) - public void checkModeStateNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getStateVars().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var stateVar : mode.getStateVars()) { - if (names.contains(stateVar.getName())) { - error(String.format("Duplicate state variable '%s'. (State variables are currently scoped on reactor level not modes)", - stateVar.getName()), stateVar, Literals.STATE_VAR__NAME); - } - names.add(stateVar.getName()); - } - } + } + + @Check(CheckType.FAST) + public void checkModeTimerNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getTimers().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var timer : mode.getTimers()) { + if (names.contains(timer.getName())) { + error( + String.format( + "Duplicate Timer '%s'. (Timers are currently scoped on reactor level not" + + " modes)", + timer.getName()), + timer, + Literals.VARIABLE__NAME); + } + names.add(timer.getName()); } + } } - - @Check(CheckType.FAST) - public void checkModeTimerNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getTimers().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var timer : mode.getTimers()) { - if (names.contains(timer.getName())) { - error(String.format("Duplicate Timer '%s'. (Timers are currently scoped on reactor level not modes)", - timer.getName()), timer, Literals.VARIABLE__NAME); - } - names.add(timer.getName()); - } - } + } + + @Check(CheckType.FAST) + public void checkModeActionNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var action : mode.getActions()) { + if (names.contains(action.getName())) { + error( + String.format( + "Duplicate Action '%s'. (Actions are currently scoped on reactor level not" + + " modes)", + action.getName()), + action, + Literals.VARIABLE__NAME); + } + names.add(action.getName()); } + } } - - @Check(CheckType.FAST) - public void checkModeActionNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var action : mode.getActions()) { - if (names.contains(action.getName())) { - error(String.format("Duplicate Action '%s'. (Actions are currently scoped on reactor level not modes)", - action.getName()), action, Literals.VARIABLE__NAME); - } - names.add(action.getName()); - } - } + } + + @Check(CheckType.FAST) + public void checkModeInstanceNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var instantiation : mode.getInstantiations()) { + if (names.contains(instantiation.getName())) { + error( + String.format( + "Duplicate Instantiation '%s'. (Instantiations are currently scoped on reactor" + + " level not modes)", + instantiation.getName()), + instantiation, + Literals.INSTANTIATION__NAME); + } + names.add(instantiation.getName()); } + } } - - @Check(CheckType.FAST) - public void checkModeInstanceNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var instantiation : mode.getInstantiations()) { - if (names.contains(instantiation.getName())) { - error(String.format("Duplicate Instantiation '%s'. (Instantiations are currently scoped on reactor level not modes)", - instantiation.getName()), instantiation, Literals.INSTANTIATION__NAME); - } - names.add(instantiation.getName()); - } + } + + @Check(CheckType.FAST) + public void checkMissingStateResetInMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var resetModes = new HashSet(); + // Collect all modes that may be reset + for (var m : reactor.getModes()) { + for (var r : m.getReactions()) { + for (var e : r.getEffects()) { + if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { + resetModes.add((Mode) e.getVariable()); } + } } - } - - @Check(CheckType.FAST) - public void checkMissingStateResetInMode(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var resetModes = new HashSet(); - // Collect all modes that may be reset - for (var m : reactor.getModes()) { - for (var r : m.getReactions()) { - for (var e : r.getEffects()) { - if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { - resetModes.add((Mode) e.getVariable()); - } - } - } + } + for (var m : resetModes) { + // Check state variables in this mode + if (!m.getStateVars().isEmpty()) { + var hasResetReaction = + m.getReactions().stream() + .anyMatch( + r -> + r.getTriggers().stream() + .anyMatch( + t -> + (t instanceof BuiltinTriggerRef + && ((BuiltinTriggerRef) t).getType() + == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + for (var s : m.getStateVars()) { + if (!s.isReset()) { + error( + "State variable is not reset upon mode entry. It is neither marked for" + + " automatic reset nor is there a reset reaction.", + m, + Literals.MODE__STATE_VARS, + m.getStateVars().indexOf(s)); + } } - for (var m : resetModes) { - // Check state variables in this mode - if (!m.getStateVars().isEmpty()) { - var hasResetReaction = m.getReactions().stream().anyMatch( - r -> r.getTriggers().stream().anyMatch( - t -> (t instanceof BuiltinTriggerRef && - ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); - if (!hasResetReaction) { - for (var s : m.getStateVars()) { - if (!s.isReset()) { - error("State variable is not reset upon mode entry. It is neither marked for automatic reset nor is there a reset reaction.", - m, Literals.MODE__STATE_VARS, m.getStateVars().indexOf(s)); - } - } - } + } + } + // Check state variables in instantiated reactors + if (!m.getInstantiations().isEmpty()) { + for (var i : m.getInstantiations()) { + var error = new LinkedHashSet(); + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty()) { + var check = toCheck.pop(); + checked.add(check); + if (!check.getStateVars().isEmpty()) { + var hasResetReaction = + check.getReactions().stream() + .anyMatch( + r -> + r.getTriggers().stream() + .anyMatch( + t -> + (t instanceof BuiltinTriggerRef + && ((BuiltinTriggerRef) t).getType() + == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + // Add state vars that are not self-resetting to the error + check.getStateVars().stream() + .filter(s -> !s.isReset()) + .forEachOrdered(error::add); } - // Check state variables in instantiated reactors - if (!m.getInstantiations().isEmpty()) { - for (var i : m.getInstantiations()) { - var error = new LinkedHashSet(); - var checked = new HashSet(); - var toCheck = new LinkedList(); - toCheck.add((Reactor) i.getReactorClass()); - while (!toCheck.isEmpty()) { - var check = toCheck.pop(); - checked.add(check); - if (!check.getStateVars().isEmpty()) { - var hasResetReaction = check.getReactions().stream().anyMatch( - r -> r.getTriggers().stream().anyMatch( - t -> (t instanceof BuiltinTriggerRef && - ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); - if (!hasResetReaction) { - // Add state vars that are not self-resetting to the error - check.getStateVars().stream().filter(s -> !s.isReset()).forEachOrdered(error::add); - } - } - // continue with inner - for (var innerInstance : check.getInstantiations()) { - var next = (Reactor) innerInstance.getReactorClass(); - if (!checked.contains(next)) { - toCheck.push(next); - } - } - } - if (!error.isEmpty()) { - error("This reactor contains state variables that are not reset upon mode entry: " - + error.stream().map(e -> e.getName() + " in " - + ASTUtils.getEnclosingReactor(e).getName()).collect(Collectors.joining(", ")) - + ".\nThe state variables are neither marked for automatic reset nor have a dedicated reset reaction. " - + "It is unsafe to instantiate this reactor inside a mode entered with reset.", - m, Literals.MODE__INSTANTIATIONS, - m.getInstantiations().indexOf(i)); - } - } + } + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); } + } + } + if (!error.isEmpty()) { + error( + "This reactor contains state variables that are not reset upon mode entry: " + + error.stream() + .map( + e -> e.getName() + " in " + ASTUtils.getEnclosingReactor(e).getName()) + .collect(Collectors.joining(", ")) + + ".\n" + + "The state variables are neither marked for automatic reset nor have a" + + " dedicated reset reaction. It is unsafe to instantiate this reactor inside" + + " a mode entered with reset.", + m, + Literals.MODE__INSTANTIATIONS, + m.getInstantiations().indexOf(i)); } + } } + } } - - @Check(CheckType.FAST) - public void checkStateResetWithoutInitialValue(StateVar state) { - if (state.isReset() && (state.getInit() == null || state.getInit().getExprs().isEmpty())) { - error("The state variable can not be automatically reset without an initial value.", state, Literals.STATE_VAR__RESET); - } + } + + @Check(CheckType.FAST) + public void checkStateResetWithoutInitialValue(StateVar state) { + if (state.isReset() && (state.getInit() == null || state.getInit().getExprs().isEmpty())) { + error( + "The state variable can not be automatically reset without an initial value.", + state, + Literals.STATE_VAR__RESET); } - - @Check(CheckType.FAST) - public void checkUnspecifiedTransitionType(Reaction reaction) { - for (var effect : reaction.getEffects()) { - var variable = effect.getVariable(); - if (variable instanceof Mode) { - // The transition type is always set to default by Xtext. - // Hence, check if there is an explicit node for the transition type in the AST. - var transitionAssignment = NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); - if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. - var mode = (Mode) variable; - // Check if reset or history transition would make a difference. - var makesDifference = !mode.getStateVars().isEmpty() - || !mode.getTimers().isEmpty() - || !mode.getActions().isEmpty() - || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); - if (!makesDifference && !mode.getInstantiations().isEmpty()) { - // Also check instantiated reactors - for (var i : mode.getInstantiations()) { - var checked = new HashSet(); - var toCheck = new LinkedList(); - toCheck.add((Reactor) i.getReactorClass()); - while (!toCheck.isEmpty() && !makesDifference) { - var check = toCheck.pop(); - checked.add(check); - - makesDifference |= !check.getModes().isEmpty() - || !ASTUtils.allStateVars(check).isEmpty() - || !ASTUtils.allTimers(check).isEmpty() - || !ASTUtils.allActions(check).isEmpty() - || ASTUtils.allConnections(check).stream().anyMatch(c -> c.getDelay() != null); - - // continue with inner - for (var innerInstance : check.getInstantiations()) { - var next = (Reactor) innerInstance.getReactorClass(); - if (!checked.contains(next)) { - toCheck.push(next); - } - } - } - } - } - if (makesDifference) { - warning("You should specify a transition type! " - + "Reset and history transitions have different effects on this target mode. " - + "Currently, a reset type is implicitly assumed.", - reaction, Literals.REACTION__EFFECTS, reaction.getEffects().indexOf(effect)); - } + } + + @Check(CheckType.FAST) + public void checkUnspecifiedTransitionType(Reaction reaction) { + for (var effect : reaction.getEffects()) { + var variable = effect.getVariable(); + if (variable instanceof Mode) { + // The transition type is always set to default by Xtext. + // Hence, check if there is an explicit node for the transition type in the AST. + var transitionAssignment = + NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); + if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. + var mode = (Mode) variable; + // Check if reset or history transition would make a difference. + var makesDifference = + !mode.getStateVars().isEmpty() + || !mode.getTimers().isEmpty() + || !mode.getActions().isEmpty() + || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); + if (!makesDifference && !mode.getInstantiations().isEmpty()) { + // Also check instantiated reactors + for (var i : mode.getInstantiations()) { + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty() && !makesDifference) { + var check = toCheck.pop(); + checked.add(check); + + makesDifference |= + !check.getModes().isEmpty() + || !ASTUtils.allStateVars(check).isEmpty() + || !ASTUtils.allTimers(check).isEmpty() + || !ASTUtils.allActions(check).isEmpty() + || ASTUtils.allConnections(check).stream() + .anyMatch(c -> c.getDelay() != null); + + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); + } } + } } + } + if (makesDifference) { + warning( + "You should specify a transition type! " + + "Reset and history transitions have different effects on this target mode. " + + "Currently, a reset type is implicitly assumed.", + reaction, + Literals.REACTION__EFFECTS, + reaction.getEffects().indexOf(effect)); + } } + } + } + } + + ////////////////////////////////////////////////////////////// + //// Public methods. + + /** Return the error reporter for this validator. */ + public ValidatorErrorReporter getErrorReporter() { + return this.errorReporter; + } + + /** Implementation required by xtext to report validation errors. */ + @Override + public ValidationMessageAcceptor getMessageAcceptor() { + return messageAcceptor == null ? this : messageAcceptor; + } + + /** Return a list of error messages for the target declaration. */ + public List getTargetPropertyErrors() { + return this.targetPropertyErrors; + } + + ////////////////////////////////////////////////////////////// + //// Protected methods. + + /** Generate an error message for an AST node. */ + @Override + protected void error(java.lang.String message, org.eclipse.emf.ecore.EStructuralFeature feature) { + super.error(message, feature); + } + + ////////////////////////////////////////////////////////////// + //// Private methods. + + /** + * For each input, report a conflict if: 1) the input exists and the type doesn't match; or 2) the + * input has a name clash with variable that is not an input. + * + * @param superVars List of typed variables of a particular kind (i.e., inputs, outputs, or + * actions), found in a super class. + * @param sameKind Typed variables of the same kind, found in the subclass. + * @param allOwn Accumulator of non-conflicting variables incorporated in the subclass. + * @param conflicts Set of variables that are in conflict, to be used by this function to report + * conflicts. + */ + private void checkConflict( + EList superVars, EList sameKind, List allOwn, HashSet conflicts) { + for (T superVar : superVars) { + T match = null; + for (T it : sameKind) { + if (it.getName().equals(superVar.getName())) { + match = it; + break; + } + } + List rest = new ArrayList<>(allOwn); + rest.removeIf(it -> sameKind.contains(it)); + + if ((match != null && superVar.getType() != match.getType()) + || hasNameConflict(superVar, rest)) { + conflicts.add(superVar); + } else { + allOwn.add(superVar); + } + } + } + + /** + * Check the name of a feature for illegal substrings such as reserved identifiers and names with + * double leading underscores. + * + * @param name The name. + * @param feature The feature containing the name (for error reporting). + */ + private void checkName(String name, EStructuralFeature feature) { + + // Raises an error if the string starts with two underscores. + if (name.length() >= 2 && name.substring(0, 2).equals("__")) { + error(UNDERSCORE_MESSAGE + name, feature); } - ////////////////////////////////////////////////////////////// - //// Public methods. - - /** - * Return the error reporter for this validator. - */ - public ValidatorErrorReporter getErrorReporter() { - return this.errorReporter; - } - - /** - * Implementation required by xtext to report validation errors. - */ - @Override - public ValidationMessageAcceptor getMessageAcceptor() { - return messageAcceptor == null ? this : messageAcceptor; - } - - /** - * Return a list of error messages for the target declaration. - */ - public List getTargetPropertyErrors() { - return this.targetPropertyErrors; - } - - ////////////////////////////////////////////////////////////// - //// Protected methods. - - /** - * Generate an error message for an AST node. - */ - @Override - protected void error(java.lang.String message, - org.eclipse.emf.ecore.EStructuralFeature feature) { - super.error(message, feature); - } - - ////////////////////////////////////////////////////////////// - //// Private methods. - - /** - * For each input, report a conflict if: - * 1) the input exists and the type doesn't match; or - * 2) the input has a name clash with variable that is not an input. - * @param superVars List of typed variables of a particular kind (i.e., - * inputs, outputs, or actions), found in a super class. - * @param sameKind Typed variables of the same kind, found in the subclass. - * @param allOwn Accumulator of non-conflicting variables incorporated in the - * subclass. - * @param conflicts Set of variables that are in conflict, to be used by this - * function to report conflicts. - */ - private void checkConflict ( - EList superVars, EList sameKind, List allOwn, HashSet conflicts - ) { - for (T superVar : superVars) { - T match = null; - for (T it : sameKind) { - if (it.getName().equals(superVar.getName())) { - match = it; - break; - } - } - List rest = new ArrayList<>(allOwn); - rest.removeIf(it -> sameKind.contains(it)); + if (this.target.isReservedIdent(name)) { + error(RESERVED_MESSAGE + name, feature); + } - if ((match != null && superVar.getType() != match.getType()) || hasNameConflict(superVar, rest)) { - conflicts.add(superVar); - } else { - allOwn.add(superVar); - } - } + if (this.target == Target.TS) { + // "actions" is a reserved word within a TS reaction + if (name.equals("actions")) { + error(ACTIONS_MESSAGE + name, feature); + } + } + } + + /** + * Check that the initializer is compatible with the type. Note that if the type is inferred it + * will necessarily be compatible so this method is not harmful. + */ + public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { + if (init == null) { + return; } - /** - * Check the name of a feature for illegal substrings such as reserved - * identifiers and names with double leading underscores. - * @param name The name. - * @param feature The feature containing the name (for error reporting). - */ - private void checkName(String name, EStructuralFeature feature) { + // TODO: + // type is list => init is list + // type is fixed with size n => init is fixed with size n + // Specifically for C: list can only be literal or time lists - // Raises an error if the string starts with two underscores. - if (name.length() >= 2 && name.substring(0, 2).equals("__")) { - error(UNDERSCORE_MESSAGE + name, feature); + if (type.isTime) { + if (type.isList) { + // list of times + var exprs = init.getExprs(); + if (exprs.isEmpty()) { + error("Expected at least one time value.", feature); + return; } - - if (this.target.isReservedIdent(name)) { - error(RESERVED_MESSAGE + name, feature); + if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { + exprs = ((BracedListExpression) exprs.get(0)).getItems(); } - - if (this.target == Target.TS) { - // "actions" is a reserved word within a TS reaction - if (name.equals("actions")) { - error(ACTIONS_MESSAGE + name, feature); - } + for (var component : exprs) { + checkExpressionIsTime(component, feature); } + } else { + checkExpressionIsTime(init, feature); + } } + } - - /** - * Check that the initializer is compatible with the type. - * Note that if the type is inferred it will necessarily be compatible - * so this method is not harmful. - */ - public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { - if (init == null) { - return; - } - - // TODO: - // type is list => init is list - // type is fixed with size n => init is fixed with size n - // Specifically for C: list can only be literal or time lists - - if (type.isTime) { - if (type.isList) { - // list of times - var exprs = init.getExprs(); - if (exprs.isEmpty()) { - error("Expected at least one time value.", feature); - return; - } - if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { - exprs = ((BracedListExpression) exprs.get(0)).getItems(); - } - for (var component : exprs) { - checkExpressionIsTime(component, feature); - } - } else { - checkExpressionIsTime(init, feature); - } - } + private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { + if (init == null) { + return; } - private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { - if (init == null) { - return; - } - - if (init.getExprs().size() != 1) { - error("Expected exactly one time value.", feature); - } else { - checkExpressionIsTime(ASTUtils.asSingleExpr(init), feature); - } + if (init.getExprs().size() != 1) { + error("Expected exactly one time value.", feature); + } else { + checkExpressionIsTime(ASTUtils.asSingleExpr(init), feature); } + } - private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { - if (value == null || value instanceof Time) { - return; - } - - if (value instanceof ParameterReference) { - if (!ASTUtils.isOfTimeType(((ParameterReference) value).getParameter()) - && target.requiresTypes) { - error("Referenced parameter is not of time type.", feature); - } - return; - } else if (value instanceof Literal) { - if (ASTUtils.isZero(((Literal) value).getLiteral())) { - return; - } - - if (ASTUtils.isInteger(((Literal) value).getLiteral())) { - error("Missing time unit.", feature); - return; - } - // fallthrough - } - - error("Invalid time value.", feature); + private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { + if (value == null || value instanceof Time) { + return; } - /** - * Return the number of main or federated reactors declared. - * - * @param iter An iterator over all objects in the resource. - */ - private int countMainOrFederated(TreeIterator iter) { - int nMain = 0; - while (iter.hasNext()) { - EObject obj = iter.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor r = (Reactor) obj; - if (r.isMain() || r.isFederated()) { - nMain++; - } - } - return nMain; - } - - /** - * Report whether a given reactor has dependencies on a cyclic - * instantiation pattern. This means the reactor has an instantiation - * in it -- directly or in one of its contained reactors -- that is - * self-referential. - * @param reactor The reactor definition to find out whether it has any - * dependencies on cyclic instantiations. - * @param cycleSet The set of all reactors that are part of an - * instantiation cycle. - * @param visited The set of nodes already visited in this graph traversal. - */ - private boolean dependsOnCycle( - Reactor reactor, Set cycleSet, Set visited - ) { - Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); - if (visited.contains(reactor)) { - return false; - } else { - visited.add(reactor); - for (Reactor it : origins) { - if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { - // Reached a cycle. - return true; - } - } - } - return false; - } - - /** - * Report whether the name of the given element matches any variable in - * the ones to check against. - * @param element The element to compare against all variables in the given iterable. - * @param toCheckAgainst Iterable variables to compare the given element against. - */ - private boolean hasNameConflict(Variable element, - Iterable toCheckAgainst) { - int numNameConflicts = 0; - for (Variable it : toCheckAgainst) { - if (it.getName().equals(element.getName())) { - numNameConflicts++; - } - } - return numNameConflicts > 0; + if (value instanceof ParameterReference) { + if (!ASTUtils.isOfTimeType(((ParameterReference) value).getParameter()) + && target.requiresTypes) { + error("Referenced parameter is not of time type.", feature); + } + return; + } else if (value instanceof Literal) { + if (ASTUtils.isZero(((Literal) value).getLiteral())) { + return; + } + + if (ASTUtils.isInteger(((Literal) value).getLiteral())) { + error("Missing time unit.", feature); + return; + } + // fallthrough } - /** - * Return true if target is C or a C-based target like CCpp. - */ - private boolean isCBasedTarget() { - return (this.target == Target.C || this.target == Target.CCPP); + error("Invalid time value.", feature); + } + + /** + * Return the number of main or federated reactors declared. + * + * @param iter An iterator over all objects in the resource. + */ + private int countMainOrFederated(TreeIterator iter) { + int nMain = 0; + while (iter.hasNext()) { + EObject obj = iter.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor r = (Reactor) obj; + if (r.isMain() || r.isFederated()) { + nMain++; + } } - - /** - * Report whether a given imported reactor is used in this resource or not. - * @param reactor The imported reactor to check whether it is used. - */ - private boolean isUnused(ImportedReactor reactor) { - TreeIterator instantiations = reactor.eResource().getAllContents(); - TreeIterator subclasses = reactor.eResource().getAllContents(); - - boolean instantiationsCheck = true; - while (instantiations.hasNext() && instantiationsCheck) { - EObject obj = instantiations.next(); - if (!(obj instanceof Instantiation)) { - continue; - } - Instantiation inst = (Instantiation) obj; - instantiationsCheck &= (inst.getReactorClass() != reactor && inst.getReactorClass() != reactor.getReactorClass()); - } - - boolean subclassesCheck = true; - while (subclasses.hasNext() && subclassesCheck) { - EObject obj = subclasses.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor subclass = (Reactor) obj; - for (ReactorDecl decl : subclass.getSuperClasses()) { - subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); - } - } - return instantiationsCheck && subclassesCheck; + return nMain; + } + + /** + * Report whether a given reactor has dependencies on a cyclic instantiation pattern. This means + * the reactor has an instantiation in it -- directly or in one of its contained reactors -- that + * is self-referential. + * + * @param reactor The reactor definition to find out whether it has any dependencies on cyclic + * instantiations. + * @param cycleSet The set of all reactors that are part of an instantiation cycle. + * @param visited The set of nodes already visited in this graph traversal. + */ + private boolean dependsOnCycle(Reactor reactor, Set cycleSet, Set visited) { + Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); + if (visited.contains(reactor)) { + return false; + } else { + visited.add(reactor); + for (Reactor it : origins) { + if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { + // Reached a cycle. + return true; + } + } } - - /** - * Return true if the two types match. Unfortunately, xtext does not - * seem to create a suitable equals() method for Type, so we have to - * do this manually. - */ - private boolean sameType(Type type1, Type type2) { - if (type1 == null) { - return type2 == null; - } - if (type2 == null) { - return type1 == null; - } - // Most common case first. - if (type1.getId() != null) { - if (type1.getStars() != null) { - if (type2.getStars() == null) return false; - if (type1.getStars().size() != type2.getStars().size()) return false; - } - return (type1.getId().equals(type2.getId())); - } - - // Type specification in the grammar is: - // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); - if (type1.isTime()) { - if (!type2.isTime()) return false; - // Ignore the arraySpec because that is checked when connection - // is checked for balance. - return true; - } - // Type must be given in a code body - return type1.getCode().getBody().equals(type2.getCode().getBody()); + return false; + } + + /** + * Report whether the name of the given element matches any variable in the ones to check against. + * + * @param element The element to compare against all variables in the given iterable. + * @param toCheckAgainst Iterable variables to compare the given element against. + */ + private boolean hasNameConflict(Variable element, Iterable toCheckAgainst) { + int numNameConflicts = 0; + for (Variable it : toCheckAgainst) { + if (it.getName().equals(element.getName())) { + numNameConflicts++; + } + } + return numNameConflicts > 0; + } + + /** Return true if target is C or a C-based target like CCpp. */ + private boolean isCBasedTarget() { + return (this.target == Target.C || this.target == Target.CCPP); + } + + /** + * Report whether a given imported reactor is used in this resource or not. + * + * @param reactor The imported reactor to check whether it is used. + */ + private boolean isUnused(ImportedReactor reactor) { + TreeIterator instantiations = reactor.eResource().getAllContents(); + TreeIterator subclasses = reactor.eResource().getAllContents(); + + boolean instantiationsCheck = true; + while (instantiations.hasNext() && instantiationsCheck) { + EObject obj = instantiations.next(); + if (!(obj instanceof Instantiation)) { + continue; + } + Instantiation inst = (Instantiation) obj; + instantiationsCheck &= + (inst.getReactorClass() != reactor + && inst.getReactorClass() != reactor.getReactorClass()); } - ////////////////////////////////////////////////////////////// - //// Private fields. - - /** The error reporter. */ - private ValidatorErrorReporter errorReporter - = new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); - - /** Helper class containing information about the model. */ - private ModelInfo info = new ModelInfo(); - - @Inject(optional = true) - private ValidationMessageAcceptor messageAcceptor; - - /** The declared target. */ - private Target target; - - private List targetPropertyErrors = new ArrayList<>(); - - private List targetPropertyWarnings = new ArrayList<>(); - - ////////////////////////////////////////////////////////////// - //// Private static constants. - - private static String ACTIONS_MESSAGE - = "\"actions\" is a reserved word for the TypeScript target for objects " - + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " - + "and reactor instantiation): "; - - private static String HOST_OR_FQN_REGEX - = "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; - - /** - * Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). - */ - private static String IPV4_REGEX = "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" + - "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; - - /** - * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), - * with minor adjustment to allow up to six IPV6 segments (without truncation) in front - * of an embedded IPv4-address. - **/ - private static String IPV6_REGEX = - "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" + - "([0-9a-fA-F]{1,4}:){1,7}:|" + - "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" + - "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" + - "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" + - "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" + - "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" + - "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" + - ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" + - "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" + - "::(ffff(:0{1,4}){0,1}:){0,1}" + IPV4_REGEX + "|" + - "([0-9a-fA-F]{1,4}:){1,4}:" + IPV4_REGEX + "|" + - "([0-9a-fA-F]{1,4}:){1,6}" + IPV4_REGEX + ")"; - - private static String RESERVED_MESSAGE = "Reserved words in the target language are not allowed for objects " - + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation): "; - - private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); - - private static String UNDERSCORE_MESSAGE = "Names of objects (inputs, outputs, actions, timers, parameters, " - + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; - - private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; + boolean subclassesCheck = true; + while (subclasses.hasNext() && subclassesCheck) { + EObject obj = subclasses.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor subclass = (Reactor) obj; + for (ReactorDecl decl : subclass.getSuperClasses()) { + subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); + } + } + return instantiationsCheck && subclassesCheck; + } + + /** + * Return true if the two types match. Unfortunately, xtext does not seem to create a suitable + * equals() method for Type, so we have to do this manually. + */ + private boolean sameType(Type type1, Type type2) { + if (type1 == null) { + return type2 == null; + } + if (type2 == null) { + return type1 == null; + } + // Most common case first. + if (type1.getId() != null) { + if (type1.getStars() != null) { + if (type2.getStars() == null) return false; + if (type1.getStars().size() != type2.getStars().size()) return false; + } + return (type1.getId().equals(type2.getId())); + } -} \ No newline at end of file + // Type specification in the grammar is: + // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' + // typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); + if (type1.isTime()) { + if (!type2.isTime()) return false; + // Ignore the arraySpec because that is checked when connection + // is checked for balance. + return true; + } + // Type must be given in a code body + return type1.getCode().getBody().equals(type2.getCode().getBody()); + } + + ////////////////////////////////////////////////////////////// + //// Private fields. + + /** The error reporter. */ + private ValidatorErrorReporter errorReporter = + new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); + + /** Helper class containing information about the model. */ + private ModelInfo info = new ModelInfo(); + + @Inject(optional = true) + private ValidationMessageAcceptor messageAcceptor; + + /** The declared target. */ + private Target target; + + private List targetPropertyErrors = new ArrayList<>(); + + private List targetPropertyWarnings = new ArrayList<>(); + + ////////////////////////////////////////////////////////////// + //// Private static constants. + + private static String ACTIONS_MESSAGE = + "\"actions\" is a reserved word for the TypeScript target for objects " + + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " + + "and reactor instantiation): "; + + private static String HOST_OR_FQN_REGEX = + "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; + + /** Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). */ + private static String IPV4_REGEX = + "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" + + "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; + + /** + * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), with minor + * adjustment to allow up to six IPV6 segments (without truncation) in front of an embedded + * IPv4-address. + */ + private static String IPV6_REGEX = + "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,7}:|" + + "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" + + "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" + + "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" + + "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" + + "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" + + ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" + + "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" + + "::(ffff(:0{1,4}){0,1}:){0,1}" + + IPV4_REGEX + + "|" + + "([0-9a-fA-F]{1,4}:){1,4}:" + + IPV4_REGEX + + "|" + + "([0-9a-fA-F]{1,4}:){1,6}" + + IPV4_REGEX + + ")"; + + private static String RESERVED_MESSAGE = + "Reserved words in the target language are not allowed for objects (inputs, outputs, actions," + + " timers, parameters, state, reactor definitions, and reactor instantiation): "; + + private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); + + private static String UNDERSCORE_MESSAGE = + "Names of objects (inputs, outputs, actions, timers, parameters, " + + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; + + private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; +} diff --git a/test/Python/src/PyWatchdog.lf b/test/Python/src/PyWatchdog.lf deleted file mode 100644 index a89cf0d7de..0000000000 --- a/test/Python/src/PyWatchdog.lf +++ /dev/null @@ -1,66 +0,0 @@ -/** - * Test watchdog. - * This test starts a watchdog timer of 150ms every 100ms. - * Half the time, it then sleeps after starting the watchdog so that - * the watchdog expires. There should be a total of five watchdog - * expirations. - * @author Benjamin Asch - * @author Edward A. Lee - */ - -target Python { - timeout: 1100ms, - threading: true -} - -reactor Watcher(timeout(150 ms)) { - timer t(100 ms, 100 ms) // Offset ameliorates startup time. - output d // Produced if watchdog triggers. - state alternating(False) - state count(0) - - watchdog poodle(timeout) {= - p = lf_time_physical_elapsed() - lf_time_logical_elapsed() - lf_print("Watchdog timed out! Lag: "+p+" (too late by "+(p - self.timeout)+" ns)") - self.count += 1 - =} - - reaction(t) -> poodle, d {= - lf_watchdog_start(poodle, 0) - lf_print("Watchdog started at physical time "+lf_time_physical_elapsed()) - lf_print("Will expire at "+lf_time_logical_elapsed() + self.timeout) - if (self.alternating) { - lf_sleep(160 ms) - } - self.alternating = not self.alternating - =} - - reaction(poodle) -> d {= - lf_print("Reaction poodle was called.") - d.set(1) - =} - - reaction(shutdown) -> poodle {= - _lf_watchdog_stop(poodle) - if (self.count != 5) { - lf_print_error_and_exit("Watchdog expired "+self.count+" times. Expected 5.") - } - =} -} - -main reactor { - logical action a - state count(0) - w = new Watcher() - - reaction(w.d) {= - lf_print("*** Watcher reactor produced an output.") - self.count += 1 - =} - - reaction(shutdown) {= - if (self.count != 5) { - lf_print_error_and_exit("Watchdog produced output "+self.count+" times. Expected 5.") - } - =} -} From 02b02e56af7a952a903dc9e85091c57c6c1952b2 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Fri, 21 Apr 2023 17:01:03 +0900 Subject: [PATCH 146/709] Revert ci test changes --- .github/workflows/c-tests.yml | 3 --- .github/workflows/ci.yml | 4 ++-- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index ed1ba0d784..79c66d8ab4 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -45,9 +45,6 @@ jobs: brew install coreutils brew install openssl brew link openssl --force - echo 'export PATH="/usr/local/opt/openssl@3/bin:$PATH"' >> /Users/runner/.bash_profile - export LDFLAGS="-L/usr/local/opt/openssl@3/lib" - export CPPFLAGS="-I/usr/local/opt/openssl@3/include" if: ${{ runner.os == 'macOS' }} - name: Install RTI uses: ./.github/actions/install-rti diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 64a524ff8f..f6dd56ae40 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -62,7 +62,7 @@ jobs: # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@auth-fail-test + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master needs: cancel # Run the C Arduino integration tests. @@ -77,7 +77,7 @@ jobs: # Run the CCpp integration tests. ccpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@auth-fail-test + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master with: use-cpp: true needs: cancel From 37936c5072359955b1dbc040039147975d64e657 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Fri, 21 Apr 2023 17:01:56 +0900 Subject: [PATCH 147/709] Delete ssh --- .github/workflows/c-tests.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 79c66d8ab4..b02775ad65 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -69,5 +69,4 @@ jobs: fail_ci_if_error: false verbose: true if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI - - name: Setup upterm session - uses: lhotari/action-upterm@v1 \ No newline at end of file + \ No newline at end of file From 42cc3fd9e3a70b86262edfaa752920ead5935e5b Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Fri, 21 Apr 2023 17:02:44 +0900 Subject: [PATCH 148/709] Remove unneeded line --- .github/workflows/c-tests.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index b02775ad65..0764128a1b 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -69,4 +69,3 @@ jobs: fail_ci_if_error: false verbose: true if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI - \ No newline at end of file From f2b3eadaca7d82be3f6829eeb1345ff38dcbb2b1 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Fri, 21 Apr 2023 17:12:00 +0900 Subject: [PATCH 149/709] Checkout reactor-c auth-fail-test branch --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 9d939578e0..6d0854a9eb 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 9d939578e095029deab5153326362555fad0382b +Subproject commit 6d0854a9ebb0ff06a774e28a12dcef0118037f06 From 604a697cf3a29f62643beabf95897ab2df6e53b7 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 21 Apr 2023 11:49:36 +0200 Subject: [PATCH 150/709] delete build-lfc --- bin/build-lfc | 1 - 1 file changed, 1 deletion(-) delete mode 120000 bin/build-lfc diff --git a/bin/build-lfc b/bin/build-lfc deleted file mode 120000 index 55c54a4b7a..0000000000 --- a/bin/build-lfc +++ /dev/null @@ -1 +0,0 @@ -../lib/scripts/build.sh \ No newline at end of file From 520d5330bee0cd4b93fa7eb2e96b37a7635d561b Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 21 Apr 2023 11:50:27 +0200 Subject: [PATCH 151/709] remove buildLfc gradle task --- org.lflang/build.gradle | 6 ------ 1 file changed, 6 deletions(-) diff --git a/org.lflang/build.gradle b/org.lflang/build.gradle index 00410d16f5..5155c0a6e2 100644 --- a/org.lflang/build.gradle +++ b/org.lflang/build.gradle @@ -174,12 +174,6 @@ task buildAll() { mainClassName = 'org.lflang.cli.Lfc' } -// define buildLfc as an alias to buildAll -task buildLfc { - dependsOn buildAll - doFirst({{logger.warn("The buildLfc task is deprecated! Please use buildAll instead.")}}) -} - task jarCliTools(type: ShadowJar) { manifest { attributes('Main-Class': 'org.lflang.cli.Lfc') From 57a1bbaf71de0fcde144fcdc805cc6bf1fc32c41 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 21 Apr 2023 18:06:41 +0200 Subject: [PATCH 152/709] Added LF_SOURCE_DIRECTORY and LF_FILE_SEPARATOR --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 06095f553d..43a3568631 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -25,6 +25,7 @@ package org.lflang.generator.c; +import java.io.File; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; @@ -230,6 +231,8 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f fileConfig.binPath ) ), + "-DLF_SOURCE_DIRECTORY=\"" + fileConfig.srcPath + "\"", // Do not convert to Unix path. + "-DLF_FILE_SEPARATOR=\"" + File.separator + "\"", FileUtil.toUnixString(fileConfig.getSrcGenPath()) )); From 1f86008ea9b321e057af51b9aa5256590c578515 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Fri, 21 Apr 2023 10:36:36 -0700 Subject: [PATCH 153/709] updating reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index ff3c84c36b..7dcdb7dfdb 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit ff3c84c36b2d7fbcbe09fafa577ec94f75194e83 +Subproject commit 7dcdb7dfdbc065c59fe1372779d5e0606dccda30 From 1493800e22e4aa007e6ffadb25706696bd08d7d3 Mon Sep 17 00:00:00 2001 From: Benjamin Asch Date: Fri, 21 Apr 2023 10:38:51 -0700 Subject: [PATCH 154/709] fixed invocation of watchdog_stop in watchdog test --- test/C/src/Watchdog.lf | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index 5d2c87b724..e40157a9e6 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -6,8 +6,7 @@ * @author Edward A. Lee */ target C { - timeout: 1100 ms, - fast: false + timeout: 1100 ms } reactor Watcher(timeout: time = 150 ms) { @@ -39,8 +38,7 @@ reactor Watcher(timeout: time = 150 ms) { =} reaction(shutdown) -> poodle {= - // FIXME: There needs to be an lf_watchdog_stop() defined. - _lf_watchdog_stop(poodle); + lf_watchdog_stop(poodle); if (self->count != 5) { lf_print_error_and_exit("Watchdog expired %d times. Expected 5.", self->count); } From dd934257cefa42c268c15d51bed3d0477ef33cc3 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 22 Apr 2023 01:06:49 +0200 Subject: [PATCH 155/709] Align to reactor-c file-access branch --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 42a87b1b9c..c75d29ec9e 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 42a87b1b9cb678ab9170dbf800019bcbeb80c61f +Subproject commit c75d29ec9e600b428db78dc5ead63b49722cd7b9 From fad460269503802f255a857802591b38b4b8e7c2 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sat, 22 Apr 2023 14:06:11 +0900 Subject: [PATCH 156/709] Check if os.type is working --- .github/workflows/c-tests.yml | 2 ++ org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java | 2 ++ 2 files changed, 4 insertions(+) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 0764128a1b..37f0c2bed3 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -49,6 +49,8 @@ jobs: - name: Install RTI uses: ./.github/actions/install-rti if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} + - name: Setup upterm session + uses: lhotari/action-upterm@v1 - name: Perform tests for C target with default scheduler run: | ./gradlew test --tests org.lflang.tests.runtime.CTest.* diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 3f5eb4a5b7..0028064641 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -223,6 +223,8 @@ CodeBuilder generateCMakeCode( if(targetConfig.auth) { // If security is requested, add the auth option. var osName = System.getProperty("os.name").toLowerCase(); + System.out.println(osName); + System.out.println("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); // if platform target was set, use given platform instead if (targetConfig.platformOptions.platform != Platform.AUTO) { osName = targetConfig.platformOptions.platform.toString(); From 9e67b93c131aa49011fcad840f3f3d42c372fb98 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sat, 22 Apr 2023 14:19:13 +0900 Subject: [PATCH 157/709] Change pointing ci --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f6dd56ae40..7f3da5fe92 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -62,7 +62,7 @@ jobs: # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@auth-fail-test needs: cancel # Run the C Arduino integration tests. From 6b9eed2718eee0add7e006d86a74a4a32ec83a59 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 22 Apr 2023 07:38:19 +0200 Subject: [PATCH 158/709] Escape Windows file separator --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 43a3568631..507c4f45d3 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -223,6 +223,8 @@ static Stream cmakeCompileDefinitions(TargetConfig targetConfig) { private static List cmakeOptions(TargetConfig targetConfig, FileConfig fileConfig) { List arguments = new ArrayList<>(); cmakeCompileDefinitions(targetConfig).forEachOrdered(arguments::add); + String separator = File.separator; + if (separator.equals("\\")) separator = "\\\\"; arguments.addAll(List.of( "-DCMAKE_BUILD_TYPE=" + ((targetConfig.cmakeBuildType!=null) ? targetConfig.cmakeBuildType.toString() : "Release"), "-DCMAKE_INSTALL_PREFIX=" + FileUtil.toUnixString(fileConfig.getOutPath()), @@ -232,7 +234,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f ) ), "-DLF_SOURCE_DIRECTORY=\"" + fileConfig.srcPath + "\"", // Do not convert to Unix path. - "-DLF_FILE_SEPARATOR=\"" + File.separator + "\"", + "-DLF_FILE_SEPARATOR=\"" + separator + "\"", FileUtil.toUnixString(fileConfig.getSrcGenPath()) )); From 68b0090184593e0aa286a3589d3a639f9cae272b Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Sat, 22 Apr 2023 14:47:46 +0900 Subject: [PATCH 159/709] Remove ci test changes --- .github/workflows/c-tests.yml | 2 -- .github/workflows/ci.yml | 2 +- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java | 2 -- 4 files changed, 2 insertions(+), 6 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 37f0c2bed3..0764128a1b 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -49,8 +49,6 @@ jobs: - name: Install RTI uses: ./.github/actions/install-rti if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - - name: Setup upterm session - uses: lhotari/action-upterm@v1 - name: Perform tests for C target with default scheduler run: | ./gradlew test --tests org.lflang.tests.runtime.CTest.* diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7f3da5fe92..f6dd56ae40 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -62,7 +62,7 @@ jobs: # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@auth-fail-test + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master needs: cancel # Run the C Arduino integration tests. diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 6d0854a9eb..f344f55e67 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 6d0854a9ebb0ff06a774e28a12dcef0118037f06 +Subproject commit f344f55e678d2eb4d7a40eb4725ea2dcc3baf897 diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 0028064641..3f5eb4a5b7 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -223,8 +223,6 @@ CodeBuilder generateCMakeCode( if(targetConfig.auth) { // If security is requested, add the auth option. var osName = System.getProperty("os.name").toLowerCase(); - System.out.println(osName); - System.out.println("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"); // if platform target was set, use given platform instead if (targetConfig.platformOptions.platform != Platform.AUTO) { osName = targetConfig.platformOptions.platform.toString(); From 483bffe088454dae5d74d5bc23ad24556bf042e1 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 23 Apr 2023 08:45:43 +0200 Subject: [PATCH 160/709] Put LF_SOURCE_DIRECTORY definition in cmake file for federations --- .../org/lflang/federated/extensions/CExtensionUtils.java | 5 +++++ org.lflang/src/org/lflang/generator/c/CCompiler.java | 8 +++++++- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index 124ffefb4f..2bf74c3176 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -358,6 +358,11 @@ public static void generateCMakeInclude( CodeBuilder cmakeIncludeCode = new CodeBuilder(); cmakeIncludeCode.pr(generateSerializationCMakeExtension(federate)); + cmakeIncludeCode.pr( + "add_compile_definitions(LF_SOURCE_DIRECTORY=\"" + + fileConfig.srcPath + + "\")" + ); try (var srcWriter = Files.newBufferedWriter(cmakeIncludePath)) { srcWriter.write(cmakeIncludeCode.getCode()); diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 507c4f45d3..93d3ea3244 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -233,10 +233,16 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f fileConfig.binPath ) ), - "-DLF_SOURCE_DIRECTORY=\"" + fileConfig.srcPath + "\"", // Do not convert to Unix path. "-DLF_FILE_SEPARATOR=\"" + separator + "\"", FileUtil.toUnixString(fileConfig.getSrcGenPath()) )); + // Add #define for source file directory. + // Do not do this for federated programs because for those, the definition is put + // into the cmake file (and fileConfig.srcPath is the wrong directory anyway). + if (!fileConfig.srcPath.toString().contains("fed-gen")) { + // Do not convert to Unix path + arguments.add("-DLF_SOURCE_DIRECTORY=\"" + fileConfig.srcPath + "\""); + } if (GeneratorUtils.isHostWindows()) { arguments.add("-DCMAKE_SYSTEM_VERSION=\"10.0\""); From ddacb09bae7273d7cec3c77bcbcd7758467053f1 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 23 Apr 2023 08:46:49 +0200 Subject: [PATCH 161/709] Align reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index c75d29ec9e..2c4ee46d63 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit c75d29ec9e600b428db78dc5ead63b49722cd7b9 +Subproject commit 2c4ee46d63da73afb1516233120651560d5458d1 From c0657d34751b848f2d23591b59cf1360eb233226 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 23 Apr 2023 09:00:21 +0200 Subject: [PATCH 162/709] Include clock-sync.h so target parameters are supported --- org.lflang/src/org/lflang/federated/extensions/CExtension.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index 4698c2eb84..8a69e979c6 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -498,6 +498,7 @@ public String generatePreamble( includes.pr("#include \"core/federated/federate.h\""); includes.pr("#include \"core/federated/net_common.h\""); includes.pr("#include \"core/federated/net_util.h\""); + includes.pr("#include \"core/federated/clock-sync.h\""); includes.pr("#include \"core/threaded/reactor_threaded.h\""); includes.pr("#include \"core/utils/util.h\""); includes.pr("extern federate_instance_t _fed;"); From 729a2a44b53d0d42f0de4a15c002a26ac4c4e230 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Wed, 26 Apr 2023 11:02:52 +0200 Subject: [PATCH 163/709] Made a proper test --- test/C/src/FileReader.lf | 44 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 test/C/src/FileReader.lf diff --git a/test/C/src/FileReader.lf b/test/C/src/FileReader.lf new file mode 100644 index 0000000000..b1a1d177c7 --- /dev/null +++ b/test/C/src/FileReader.lf @@ -0,0 +1,44 @@ +/** + * Test reading a file at a location relative to the source file. + */ +target C +reactor Source { + output out:char* // Use char*, not string, so memory is freed. + reaction(startup) -> out {= + char* file_path = + LF_SOURCE_DIRECTORY + LF_FILE_SEPARATOR "lib" + LF_FILE_SEPARATOR "FileReader.txt"; + + FILE* file = fopen(file_path, "rb"); + if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); + + // Determine the file size + fseek(file, 0, SEEK_END); + long file_size = ftell(file); + fseek(file, 0, SEEK_SET); + + // Allocate memory for the buffer + char* buffer = (char *) malloc(file_size + 1); + if (buffer == NULL) lf_print_error_and_exit("Out of memory."); + + // Read the file into the buffer + fread(buffer, file_size, 1, file); + buffer[file_size] = '\0'; + fclose(file); + + lf_set(out, buffer); + =} +} +main reactor { + preamble {= + #include + =} + s = new Source() + reaction(s.out) {= + printf("Received: %s\n", s.out->value); + if (strcmp("Hello World", s.out->value) != 0) { + lf_print_error_and_exit("Expected 'Hello World'"); + } + =} +} \ No newline at end of file From fdf1b896986ac4faae18bc2abe2d565e2def626b Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Wed, 26 Apr 2023 11:04:39 +0200 Subject: [PATCH 164/709] Aligned reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- test/C/src/federated/FederatedFileReader.lf | 54 +++++++++++++++++++++ test/C/src/lib/FileReader.txt | 1 + 3 files changed, 56 insertions(+), 1 deletion(-) create mode 100644 test/C/src/federated/FederatedFileReader.lf create mode 100644 test/C/src/lib/FileReader.txt diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 2c4ee46d63..2f0fdad753 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 2c4ee46d63da73afb1516233120651560d5458d1 +Subproject commit 2f0fdad7535a7f639f421ac8bc5eec2a159df34c diff --git a/test/C/src/federated/FederatedFileReader.lf b/test/C/src/federated/FederatedFileReader.lf new file mode 100644 index 0000000000..15eb451c27 --- /dev/null +++ b/test/C/src/federated/FederatedFileReader.lf @@ -0,0 +1,54 @@ +/** + * Test reading a file at a location relative to the source file. + */ +target C { + timeout: 0s +} +reactor Source { + output out:char* // Use char*, not string, so memory is freed. + reaction(startup) -> out {= + char* file_path = + LF_SOURCE_DIRECTORY + LF_FILE_SEPARATOR ".." + LF_FILE_SEPARATOR "lib" + LF_FILE_SEPARATOR "FileReader.txt"; + + FILE* file = fopen(file_path, "rb"); + if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); + + // Determine the file size + fseek(file, 0, SEEK_END); + long file_size = ftell(file); + fseek(file, 0, SEEK_SET); + + // Allocate memory for the buffer + char* buffer = (char *) malloc(file_size + 1); + if (buffer == NULL) lf_print_error_and_exit("Out of memory."); + + // Read the file into the buffer + fread(buffer, file_size, 1, file); + buffer[file_size] = '\0'; + fclose(file); + + // For federated version, have to use lf_set_array so array size is know + // to the serializer. + lf_set_array(out, buffer, file_size + 1); + =} +} +reactor Check { + preamble {= + #include + =} + input in:char* + reaction(in) {= + printf("Received: %s\n", in->value); + if (strcmp("Hello World", in->value) != 0) { + lf_print_error_and_exit("Expected 'Hello World'"); + } + =} +} +federated reactor { + s = new Source() + c = new Check() + s.out -> c.in +} \ No newline at end of file diff --git a/test/C/src/lib/FileReader.txt b/test/C/src/lib/FileReader.txt new file mode 100644 index 0000000000..5e1c309dae --- /dev/null +++ b/test/C/src/lib/FileReader.txt @@ -0,0 +1 @@ +Hello World \ No newline at end of file From c33a75b9492b841910025d1d700db1efceb2d0e3 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Wed, 26 Apr 2023 11:19:23 +0200 Subject: [PATCH 165/709] Formatted tests --- test/C/src/FileReader.lf | 16 +++++++++------- test/C/src/federated/FederatedFileReader.lf | 21 ++++++++++++--------- 2 files changed, 21 insertions(+), 16 deletions(-) diff --git a/test/C/src/FileReader.lf b/test/C/src/FileReader.lf index b1a1d177c7..10be772fb7 100644 --- a/test/C/src/FileReader.lf +++ b/test/C/src/FileReader.lf @@ -1,15 +1,15 @@ -/** - * Test reading a file at a location relative to the source file. - */ +/** Test reading a file at a location relative to the source file. */ target C + reactor Source { - output out:char* // Use char*, not string, so memory is freed. + output out: char* // Use char*, not string, so memory is freed. + reaction(startup) -> out {= char* file_path = LF_SOURCE_DIRECTORY LF_FILE_SEPARATOR "lib" LF_FILE_SEPARATOR "FileReader.txt"; - + FILE* file = fopen(file_path, "rb"); if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); @@ -26,19 +26,21 @@ reactor Source { fread(buffer, file_size, 1, file); buffer[file_size] = '\0'; fclose(file); - + lf_set(out, buffer); =} } + main reactor { preamble {= #include =} s = new Source() + reaction(s.out) {= printf("Received: %s\n", s.out->value); if (strcmp("Hello World", s.out->value) != 0) { lf_print_error_and_exit("Expected 'Hello World'"); } =} -} \ No newline at end of file +} diff --git a/test/C/src/federated/FederatedFileReader.lf b/test/C/src/federated/FederatedFileReader.lf index 15eb451c27..6ba2da763f 100644 --- a/test/C/src/federated/FederatedFileReader.lf +++ b/test/C/src/federated/FederatedFileReader.lf @@ -1,18 +1,18 @@ -/** - * Test reading a file at a location relative to the source file. - */ +/** Test reading a file at a location relative to the source file. */ target C { - timeout: 0s + timeout: 0 s } + reactor Source { - output out:char* // Use char*, not string, so memory is freed. + output out: char* // Use char*, not string, so memory is freed. + reaction(startup) -> out {= char* file_path = LF_SOURCE_DIRECTORY LF_FILE_SEPARATOR ".." LF_FILE_SEPARATOR "lib" LF_FILE_SEPARATOR "FileReader.txt"; - + FILE* file = fopen(file_path, "rb"); if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); @@ -29,17 +29,19 @@ reactor Source { fread(buffer, file_size, 1, file); buffer[file_size] = '\0'; fclose(file); - + // For federated version, have to use lf_set_array so array size is know // to the serializer. lf_set_array(out, buffer, file_size + 1); =} } + reactor Check { preamble {= #include =} - input in:char* + input in: char* + reaction(in) {= printf("Received: %s\n", in->value); if (strcmp("Hello World", in->value) != 0) { @@ -47,8 +49,9 @@ reactor Check { } =} } + federated reactor { s = new Source() c = new Check() s.out -> c.in -} \ No newline at end of file +} From 6f3dd1fde2743691c807d853a3a5e185c60bbb0e Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 05:57:24 +0200 Subject: [PATCH 166/709] Extra quoting attempt to make Windows work --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 93d3ea3244..248a4b929a 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -224,7 +224,11 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f List arguments = new ArrayList<>(); cmakeCompileDefinitions(targetConfig).forEachOrdered(arguments::add); String separator = File.separator; - if (separator.equals("\\")) separator = "\\\\"; + String maybeQuote = ""; // Windows seems to require extra level of quoting. + if (separator.equals("\\")) { + separator = "\\\\"; + maybeQuote = "\\\""; + } arguments.addAll(List.of( "-DCMAKE_BUILD_TYPE=" + ((targetConfig.cmakeBuildType!=null) ? targetConfig.cmakeBuildType.toString() : "Release"), "-DCMAKE_INSTALL_PREFIX=" + FileUtil.toUnixString(fileConfig.getOutPath()), @@ -233,7 +237,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f fileConfig.binPath ) ), - "-DLF_FILE_SEPARATOR=\"" + separator + "\"", + "-DLF_FILE_SEPARATOR=\"" + maybeQuote + separator + maybeQuote + "\"", FileUtil.toUnixString(fileConfig.getSrcGenPath()) )); // Add #define for source file directory. @@ -241,7 +245,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f // into the cmake file (and fileConfig.srcPath is the wrong directory anyway). if (!fileConfig.srcPath.toString().contains("fed-gen")) { // Do not convert to Unix path - arguments.add("-DLF_SOURCE_DIRECTORY=\"" + fileConfig.srcPath + "\""); + arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + fileConfig.srcPath + maybeQuote + "\""); } if (GeneratorUtils.isHostWindows()) { From c9fbd4622ce0e0ab595968e870850f729aa5a975 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 06:07:59 +0200 Subject: [PATCH 167/709] Align to reactor-c main --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index f344f55e67..e363b14648 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit f344f55e678d2eb4d7a40eb4725ea2dcc3baf897 +Subproject commit e363b146486e07d1593ba05746cc9b8b5c4df643 From 8c91a380cd4297fce6624d536707f2bbd4b3daab Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 06:49:30 +0200 Subject: [PATCH 168/709] Aligned to reactor-c/main --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 2f0fdad753..75ddd1d4a9 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 2f0fdad7535a7f639f421ac8bc5eec2a159df34c +Subproject commit 75ddd1d4a9cfab83639730863f9d31eb245cb61f From 78b028e36879e46c631fda275308c45d5f287bde Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 08:08:15 +0200 Subject: [PATCH 169/709] Next attempt to get Windows to work --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 248a4b929a..64e92bb65a 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -238,7 +238,6 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f ) ), "-DLF_FILE_SEPARATOR=\"" + maybeQuote + separator + maybeQuote + "\"", - FileUtil.toUnixString(fileConfig.getSrcGenPath()) )); // Add #define for source file directory. // Do not do this for federated programs because for those, the definition is put @@ -247,6 +246,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f // Do not convert to Unix path arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + fileConfig.srcPath + maybeQuote + "\""); } + arguments.add(FileUtil.toUnixString(fileConfig.getSrcGenPath())); if (GeneratorUtils.isHostWindows()) { arguments.add("-DCMAKE_SYSTEM_VERSION=\"10.0\""); From 2e986dce1e756be4e58793b57bdaaede847abee6 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 08:37:37 +0200 Subject: [PATCH 170/709] Aligned to reactor-c/watchdogs --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 7dcdb7dfdb..abe2485cca 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 7dcdb7dfdbc065c59fe1372779d5e0606dccda30 +Subproject commit abe2485cca3299d9e056cc7f9a55d306295f00ee From 134b97046adcd20c994d8660d35f530623a63e1a Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 27 Apr 2023 10:43:01 +0200 Subject: [PATCH 171/709] Skip FileReader for Zephyr --- util/RunZephyrTests.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/RunZephyrTests.sh b/util/RunZephyrTests.sh index 66dcd10ffa..cabbbec0b2 100755 --- a/util/RunZephyrTests.sh +++ b/util/RunZephyrTests.sh @@ -9,7 +9,7 @@ num_failures=0 failed_tests="" # Skip -skip=() +skip=("FileReader") find_kconfig_folders() { if [ -f "$folder/CMakeLists.txt" ]; then From e32c9ff4f0b620eee7d2831a1511862ed0881a2e Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 13:29:24 +0200 Subject: [PATCH 172/709] First pass a refactoring --- org.lflang/src/lib/c/reactor-c | 2 +- .../org/lflang/generator/c/CGenerator.java | 6 +---- .../generator/c/CWatchdogGenerator.java | 23 ------------------- 3 files changed, 2 insertions(+), 29 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index abe2485cca..5c0ba3b435 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit abe2485cca3299d9e056cc7f9a55d306295f00ee +Subproject commit 5c0ba3b43545758a8f96dc168e6947afc767626b diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b26b3061c0..7dbabf8aee 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -670,9 +670,6 @@ private void generateCodeFor(String lfModuleName) throws IOException { // Generate function to schedule timers for all reactors. code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); - // Generate function to initialize mutexes for all reactors with watchdogs. - code.pr(CWatchdogGenerator.generateLfInitializeWatchdogMutexes(watchdogCount)); - // Generate a function that will either do nothing // (if there is only one federate or the coordination // is set to decentralized) or, if there are @@ -1175,8 +1172,7 @@ private void generateSelfStruct( // Next, generate fields for modes CModesGenerator.generateDeclarations(reactor, body, constructorCode); - // The first field has to always be a pointer to the list of - // of allocated memory that must be freed when the reactor is freed. + // The first field has to always be a pointer to be struct_base_t. // This means that the struct can be safely cast to self_base_t. builder.pr("typedef struct {"); builder.indent(); diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 5a6f1dc3ba..50428910f5 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -212,27 +212,4 @@ public static String generateBuiltinTriggersTable(int count, String name) { " int _lf_" + name + "_number = " + count + ";", "#endif")); } - - /** Generate _lf_initialize_watchdog_mutexes function. */ - // FIXME: finish implementing - public static String generateLfInitializeWatchdogMutexes(int watchdogCount) { - var s = new StringBuilder(); - s.append("void _lf_initialize_watchdog_mutexes() {"); - if (watchdogCount > 0) { - s.append("\n"); - s.append( - String.join( - "\n", - " for (int i = 0; i < _lf_watchdog_number; i++) {", - " self_base_t* current_base = _lf_watchdogs[i]->base;", - " if (&(current_base->watchdog_mutex) == NULL) {", - " lf_mutex_init(&(current_base->watchdog_mutex));", - " current_base->has_watchdog = true;", - " }", - " }")); - } - s.append("\n"); - s.append("}\n"); - return s.toString(); - } } From 0b68ed468edf8535c0d1675aed02170aa374776b Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 13:30:50 +0200 Subject: [PATCH 173/709] Align reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 75ddd1d4a9..2f0fdad753 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 75ddd1d4a9cfab83639730863f9d31eb245cb61f +Subproject commit 2f0fdad7535a7f639f421ac8bc5eec2a159df34c From 2910f0ad45ac7c036881a751e4e7d622c5504d06 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 13:34:01 +0200 Subject: [PATCH 174/709] Typo --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 64e92bb65a..0cae84982e 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -237,7 +237,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f fileConfig.binPath ) ), - "-DLF_FILE_SEPARATOR=\"" + maybeQuote + separator + maybeQuote + "\"", + "-DLF_FILE_SEPARATOR=\"" + maybeQuote + separator + maybeQuote + "\"" )); // Add #define for source file directory. // Do not do this for federated programs because for those, the definition is put From 23309f9e8a4e02393d827f1d74011995a02c272d Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 16:16:01 +0200 Subject: [PATCH 175/709] Flailing to try one last time for Windows --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 0cae84982e..527b5d0168 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -226,7 +226,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f String separator = File.separator; String maybeQuote = ""; // Windows seems to require extra level of quoting. if (separator.equals("\\")) { - separator = "\\\\"; + separator = "\\\\\\\\"; maybeQuote = "\\\""; } arguments.addAll(List.of( From 6f9873967b1827cb60dd6299ef06b63fb403e44f Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 17:23:25 +0200 Subject: [PATCH 176/709] Align reactor-c-py to main --- org.lflang/src/lib/py/reactor-c-py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/py/reactor-c-py b/org.lflang/src/lib/py/reactor-c-py index 14146b2f7b..80c24aa2e5 160000 --- a/org.lflang/src/lib/py/reactor-c-py +++ b/org.lflang/src/lib/py/reactor-c-py @@ -1 +1 @@ -Subproject commit 14146b2f7be6db8261b6a45724e18e0693f1f822 +Subproject commit 80c24aa2e5bc814434893e9b6e4b183b4827c36a From b6ef20dba5d3f8fa3433d1a97e6cd79324d8a057 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 17:57:47 +0200 Subject: [PATCH 177/709] Aligned reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 5c0ba3b435..4aef0ef54c 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 5c0ba3b43545758a8f96dc168e6947afc767626b +Subproject commit 4aef0ef54ca233b3cd9ff43863d0ffa715b91e8b From 0564a9f139d332ab90642323a6c1746a410e9afb Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 19:36:29 +0200 Subject: [PATCH 178/709] Yet another attempt at a Windows fix --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 527b5d0168..26b7716ab2 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -225,9 +225,11 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f cmakeCompileDefinitions(targetConfig).forEachOrdered(arguments::add); String separator = File.separator; String maybeQuote = ""; // Windows seems to require extra level of quoting. + String srcPath = fileConfig.srcPath.toString(); // Windows requires escaping the backslashes. if (separator.equals("\\")) { separator = "\\\\\\\\"; maybeQuote = "\\\""; + srcPath = srcPath.replaceAll("\\\\", "\\\\"); } arguments.addAll(List.of( "-DCMAKE_BUILD_TYPE=" + ((targetConfig.cmakeBuildType!=null) ? targetConfig.cmakeBuildType.toString() : "Release"), @@ -244,7 +246,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f // into the cmake file (and fileConfig.srcPath is the wrong directory anyway). if (!fileConfig.srcPath.toString().contains("fed-gen")) { // Do not convert to Unix path - arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + fileConfig.srcPath + maybeQuote + "\""); + arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + srcPath + maybeQuote + "\""); } arguments.add(FileUtil.toUnixString(fileConfig.getSrcGenPath())); From 2b1b4c2477c82bd5040dfa0053a3427c4375401a Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 27 Apr 2023 22:26:54 +0200 Subject: [PATCH 179/709] More fumbling to try to get Windows to work --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 26b7716ab2..f0860a0e91 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -229,7 +229,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f if (separator.equals("\\")) { separator = "\\\\\\\\"; maybeQuote = "\\\""; - srcPath = srcPath.replaceAll("\\\\", "\\\\"); + srcPath = srcPath.replaceAll("\\\\", "\\\\\\\\"); } arguments.addAll(List.of( "-DCMAKE_BUILD_TYPE=" + ((targetConfig.cmakeBuildType!=null) ? targetConfig.cmakeBuildType.toString() : "Release"), From 3b6600aa2249c2b2208db684c26b312d4cc33aa0 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 27 Apr 2023 17:07:04 -0700 Subject: [PATCH 180/709] Update org.lflang/src/lib/ts/package.json --- org.lflang/src/lib/ts/package.json | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index 88999eb785..d994f27145 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -20,7 +20,6 @@ "rimraf": "^3.0.2" }, "scripts": { - "check-types": "tsc", "build": "npx rimraf dist && npx tsc --outDir dist" } } From 2e986ad454560cf0e91a01c805879ec287f9f14e Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 27 Apr 2023 22:03:43 -0700 Subject: [PATCH 181/709] Fix copying of CMake files --- org.lflang/src/org/lflang/FileConfig.java | 4 +- org.lflang/src/org/lflang/TargetConfig.java | 8 -- .../federated/generator/FedFileConfig.java | 2 +- .../org/lflang/generator/GeneratorBase.java | 7 +- .../lflang/generator/c/CCmakeGenerator.java | 5 +- .../org/lflang/generator/c/CGenerator.java | 52 +------- .../src/org/lflang/generator/c/CUtil.java | 121 ------------------ org.lflang/src/org/lflang/util/FileUtil.java | 38 +++++- 8 files changed, 50 insertions(+), 187 deletions(-) diff --git a/org.lflang/src/org/lflang/FileConfig.java b/org.lflang/src/org/lflang/FileConfig.java index ed0f663ee9..91d681046a 100644 --- a/org.lflang/src/org/lflang/FileConfig.java +++ b/org.lflang/src/org/lflang/FileConfig.java @@ -1,6 +1,5 @@ package org.lflang; -import java.io.File; import java.io.IOException; import java.nio.file.Path; import java.nio.file.Paths; @@ -15,7 +14,6 @@ import org.eclipse.xtext.generator.IFileSystemAccess2; -import org.lflang.federated.generator.FedFileConfig; import org.lflang.generator.GeneratorUtils; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; @@ -308,7 +306,7 @@ public LFCommand getCommand() { * Return the extension used for binaries on the platform on which compilation takes place. */ protected String getExecutableExtension() { - return (GeneratorUtils.isHostWindows() ? ".exe" : ""); + return GeneratorUtils.isHostWindows() ? ".exe" : ""; } /** diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 6f15181172..58b6e9ae2c 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -172,14 +172,6 @@ public TargetConfig( */ public List cmakeIncludes = new ArrayList<>(); - /** - * List of cmake-includes from the cmake-include target property with no path info. - * Useful for copying them to remote machines. This is needed because - * target cmake-includes can be resources with resource paths. - */ - // FIXME: Code smell. This gets populated in CGenerator.copyUserFiles - public List cmakeIncludesWithoutPath = new ArrayList<>(); - /** * The compiler to invoke, unless a build command has been specified. */ diff --git a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java index 6ac65236f8..07c8bfdf9a 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java @@ -132,7 +132,7 @@ private void relativizePathList(List paths) { * @param path The path to relativize. */ private String relativizePath(Path path) { - if (FileUtil.findInProject(path, this) == null) { + if (FileUtil.findInPackage(path, this) == null) { return String.valueOf(path); } else { Path resolvedPath = this.srcPath.resolve(path).toAbsolutePath(); diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index ba39a94d9f..c9f80293db 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -56,6 +56,7 @@ import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; +import org.lflang.util.FileUtil; import org.lflang.validation.AbstractLFValidator; import com.google.common.base.Objects; @@ -348,7 +349,11 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * @param targetConfig The targetConfig to read the `files` from. * @param fileConfig The fileConfig used to make the copy and resolve paths. */ - protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) {} + protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + var targetDir = fileConfig.getSrcGenPath(); + + FileUtil.copyFiles(targetConfig.fileNames, targetDir, context); + } /** * Return true if errors occurred in the last call to doGenerate(). diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 3f5eb4a5b7..d158f7491b 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -25,6 +25,7 @@ package org.lflang.generator.c; +import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; @@ -313,8 +314,8 @@ CodeBuilder generateCMakeCode( cMakeCode.newLine(); // Add the include file - for (String includeFile : targetConfig.cmakeIncludesWithoutPath) { - cMakeCode.pr("include(\""+includeFile+"\")"); + for (String includeFile : targetConfig.cmakeIncludes) { + cMakeCode.pr("include(\""+ Path.of(includeFile).getFileName()+"\")"); } cMakeCode.newLine(); diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 0f1ababde8..5ae2cbd58e 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -819,57 +819,13 @@ private void inspectReactorEResource(ReactorDecl reactor) { * @param fileConfig The fileConfig used to make the copy and resolve paths. */ @Override - public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { super.copyUserFiles(targetConfig, fileConfig); - var targetDir = this.fileConfig.getSrcGenPath(); - // FIXME: this code probably belongs in the super method. - for (String filename : targetConfig.fileNames) { - var path = Paths.get(filename); - var found = FileUtil.findInProject(path, fileConfig); - if (found != null) { - try { - FileUtil.copyFileOrDirectory(found, targetDir.resolve(found.getFileName())); - } catch (IOException e) { - throw new RuntimeException(e); - } - } else { - // Attempt to copy from the classpath instead. - // If the filename is not a directory, it will - // just be copied without further recursion. - try { - FileUtil.copyDirectoryFromClassPath( - filename, - targetDir, - false - ); - } catch (IOException e) { - errorReporter.reportError( - "Failed to find '" + filename + "' specified in the" + - " files target property." - ); - } - } - } + var targetDir = fileConfig.getSrcGenPath(); -// for (String filename : targetConfig.cmakeIncludes) { -// var relativeCMakeIncludeFileName = -// CUtil.copyFileOrResource( -// filename, -// fileConfig.srcFile.getParent(), -// targetDir); -// // Check if the file exists -// if (StringExtensions.isNullOrEmpty(relativeCMakeIncludeFileName)) { -// errorReporter.reportError( -// "Failed to find cmake-include file " + filename -// ); -// } else { -// // FIXME: weird -// this.targetConfig.cmakeIncludesWithoutPath.add( -// relativeCMakeIncludeFileName -// ); -// } -// } + FileUtil.copyFiles(targetConfig.cmakeIncludes, targetDir, context); + // FIXME: Unclear what the following does, but it does not appear to belong here. if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { try { FileUtil.copyFile(fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index f59f45eef2..ce1c83d87d 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -26,12 +26,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.generator.c; -import java.io.File; -import java.io.IOException; -import java.nio.file.Files; import java.nio.file.Path; -import java.nio.file.Paths; -import java.nio.file.StandardCopyOption; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; @@ -54,7 +49,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Parameter; import org.lflang.lf.Port; import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.lf.WidthTerm; @@ -575,76 +569,6 @@ public static String triggerRefNested(PortInstance port, String runtimeIndex, St return reactorRefNested(port.getParent(), runtimeIndex, bankIndex) + "." + port.getName() + "_trigger"; } -// /** -// * Copy the 'fileName' (which also could be a directory name) from the -// * 'srcDirectory' to the 'destinationDirectory'. This function has a -// * fallback search mechanism, where if `fileName` is not found in the -// * `srcDirectory`, it will try to find `fileName` via the following -// * procedure: -// * 1- Search in LF_CLASSPATH. @see findFile() -// * 2- Search in CLASSPATH. @see findFile() -// * 3- Search for 'fileName' as a resource. That means the `fileName` -// * can be '/path/to/class/resource'. @see java.lang.Class.getResourceAsStream() -// * -// * @param fileName Name of the file or directory. -// * @param srcDir Where the file or directory is currently located. -// * @param dstDir Where the file or directory should be placed. -// * @return The name of the file or directory in destinationDirectory or an empty string on failure. -// */ -// public static String copyFileOrResource(String fileName, Path srcDir, -// Path dstDir) { -// -// // Check whether file exists -// -// -// // Try to copy the file or directory from the file system. -// Path file = FileUtil.findInProject(fileName, srcDir); -// if (file != null) { -// Path target = dstDir.resolve(file.getFileName()); -// try { -// if (Files.isDirectory(file)) { -// FileUtil.copyDirectory(file, target); -// } else if (Files.isRegularFile(file)) { -// Files.copy(file, target, -// StandardCopyOption.REPLACE_EXISTING); -// } -// return file.getFileName().toString(); -// } catch (IOException e) { -// // Failed to copy the file or directory, most likely -// // because it doesn't exist. Will try to find it as a -// // resource before giving up. -// } -// } -// -// -// -// String filenameWithoutPath = fileName; -// int lastSeparator = fileName.lastIndexOf(File.separator); -// if (lastSeparator > 0) { -// // FIXME: Brittle. What if the file is in a subdirectory? -// filenameWithoutPath = fileName.substring(lastSeparator + 1); -// } -// // Try to copy the file or directory as a resource. -// try { -// System.out.println("Classpath lookup: " + dstDir.resolve(filenameWithoutPath)); -// FileUtil.copyFileFromClassPath(fileName, -// dstDir.resolve(filenameWithoutPath)); -// return filenameWithoutPath; -// } catch (IOException ex) { -// // Will try one more time as a directory -// } -// -// try { -// FileUtil.copyDirectoryFromClassPath(fileName, -// dstDir.resolve(filenameWithoutPath), false); -// return filenameWithoutPath; -// } catch (IOException ex) { -// System.err.println( -// "WARNING: Failed to find file or directory " + fileName); -// } -// -// return ""; -// } ////////////////////////////////////////////////////// //// FIXME: Not clear what the strategy is with the following inner interface. @@ -668,51 +592,6 @@ public interface ReportCommandErrors { void report(String errors); } -// /** -// * Search for a given file or directory name in the given directory. -// * If not found, search in directories in LF_CLASSPATH. -// * If there is no LF_CLASSPATH environment variable, use CLASSPATH, -// * if it is defined. The first file or directory that is found will -// * be returned. Otherwise, null is returned. -// * -// * @param fileName The file or directory name or relative path + name -// * as a String. -// * @param directory String representation of the directory to search in. -// * @return A Java Path or null if not found. -// */ -// public static Path findFileOrDirectory(String fileName, Path directory) { -// Path foundFile; -// -// // Check in local directory -// foundFile = directory.resolve(fileName); -// if (Files.exists(foundFile)) { -// System.out.println(">>> File found in filesystem"); -// return foundFile; -// } -// -// // Check in LF_CLASSPATH -// // Load all the resources in LF_CLASSPATH if it is set. -// String classpathLF = System.getenv("LF_CLASSPATH"); -// if (classpathLF == null) { -// classpathLF = System.getenv("CLASSPATH"); -// } -// if (classpathLF != null) { -// String[] paths = classpathLF.split(System.getProperty("path.separator")); -// for (String path : paths) { -// System.out.println("++++Looking in path: " + path); -// foundFile = Paths.get(path).resolve(fileName); -// if (Files.exists(foundFile)) { -// System.out.println(">>> File found on classpath: %s".formatted(foundFile)); -// return foundFile; -// } -// } -// } -// -// // Not found. -// return null; -// } - - /** * Run the custom build command specified with the "build" parameter. * This command is executed in the same directory as the source file. diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 6025400a7d..62cb5c8e20 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -14,7 +14,6 @@ import java.nio.file.Paths; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collections; import java.util.Comparator; import java.util.Enumeration; import java.util.HashMap; @@ -38,6 +37,7 @@ import org.eclipse.xtext.util.RuntimeIOException; import org.lflang.FileConfig; +import org.lflang.generator.LFGeneratorContext; public class FileUtil { @@ -151,7 +151,7 @@ public static java.net.URI locateFile(String path, Resource resource) { sourceURI = iFile != null ? iFile.getRawLocation().toFile().getParentFile().toURI() : null; } if (sourceURI != null) { - return sourceURI.resolve(path.toString()); + return sourceURI.resolve(path); } } catch (Exception e) { // nothing @@ -240,6 +240,38 @@ public static void copyFile(Path source, Path destination) throws IOException { copyFile(source, destination, false); } + public static void copyFiles(List filesOrDirectories, Path destination, LFGeneratorContext context) { + for (String fileOrDirectory : filesOrDirectories) { + System.out.println("****Copying " + fileOrDirectory + " to " + destination); + var path = Paths.get(fileOrDirectory); + var found = FileUtil.findInPackage(path, context.getFileConfig()); + if (found != null) { + try { + FileUtil.copyFileOrDirectory(found, destination.resolve(found.getFileName())); + } catch (IOException e) { + context.getErrorReporter().reportError( + "Unable to copy '" + fileOrDirectory + "' from the file system." + ); + } + } else { + // Attempt to copy from the classpath instead. + // If the filename is not a directory, it will + // just be copied without further recursion. + try { + FileUtil.copyDirectoryFromClassPath( + fileOrDirectory, + destination, + false + ); + } catch (IOException e) { + context.getErrorReporter().reportError( + "Unable to copy '" + fileOrDirectory + "' from the class path." + ); + } + } + } + } + public static void copyFileOrDirectory(Path source, Path destination) throws IOException { if (Files.isDirectory(source)) { copyDirectory(source, destination); @@ -523,7 +555,7 @@ public static void deleteDirectory(Path dir) throws IOException { } } - public static Path findInProject(Path fileOrDirectory, FileConfig fileConfig) { + public static Path findInPackage(Path fileOrDirectory, FileConfig fileConfig) { if (fileOrDirectory.isAbsolute() && Files.exists(fileOrDirectory)) { return fileOrDirectory; } else { From ab054f0e9b45b8cf9b9e853e0b525cd2d90f9d36 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 27 Apr 2023 22:18:12 -0700 Subject: [PATCH 182/709] Comments --- .../org/lflang/generator/GeneratorBase.java | 4 +--- org.lflang/src/org/lflang/util/FileUtil.java | 18 ++++++++++++++++++ 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index c9f80293db..ef083cbbda 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -350,9 +350,7 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * @param fileConfig The fileConfig used to make the copy and resolve paths. */ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - var targetDir = fileConfig.getSrcGenPath(); - - FileUtil.copyFiles(targetConfig.fileNames, targetDir, context); + FileUtil.copyFiles(targetConfig.fileNames, fileConfig.getSrcGenPath(), context); } /** diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 62cb5c8e20..8805d0c1f1 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -272,6 +272,13 @@ public static void copyFiles(List filesOrDirectories, Path destination, } } + /** + * If the source is a directory, then copy the contents of the directory to the destination. + * If the source is a file, then copy the file to the destination. + * @param source A file or directory to copy to the destination. + * @param destination A directory to copy the file(s) at the source to. + * @throws IOException + */ public static void copyFileOrDirectory(Path source, Path destination) throws IOException { if (Files.isDirectory(source)) { copyDirectory(source, destination); @@ -555,6 +562,17 @@ public static void deleteDirectory(Path dir) throws IOException { } } + /** + * Return an absolute path to the given file or directory if it can be found within the package. + * Otherwise, return null. + * + * NOTE: If the given file or directory is given as an absolute path but cannot be found, it is + * interpreted as a relative path with respect to the project root. + * + * @param fileOrDirectory The file or directory to look for. + * @param fileConfig A file configuration that determines where the package is located. + * @return An absolute path of the file or directory was found; null otherwise. + */ public static Path findInPackage(Path fileOrDirectory, FileConfig fileConfig) { if (fileOrDirectory.isAbsolute() && Files.exists(fileOrDirectory)) { return fileOrDirectory; From f9dff176f0d4b841ab658b565ee0091ac085252e Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 27 Apr 2023 22:22:39 -0700 Subject: [PATCH 183/709] More comments --- org.lflang/src/org/lflang/util/FileUtil.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 8805d0c1f1..beaf5e7ea9 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -240,9 +240,15 @@ public static void copyFile(Path source, Path destination) throws IOException { copyFile(source, destination, false); } + /** + * Given a list of files or directories, attempt to find them based on the given generator + * context, and copy then to the destination. + * @param filesOrDirectories The files or directories to copy. + * @param destination The location to copy them to. + * @param context The generator context that specifies where the files must be found. + */ public static void copyFiles(List filesOrDirectories, Path destination, LFGeneratorContext context) { for (String fileOrDirectory : filesOrDirectories) { - System.out.println("****Copying " + fileOrDirectory + " to " + destination); var path = Paths.get(fileOrDirectory); var found = FileUtil.findInPackage(path, context.getFileConfig()); if (found != null) { From 23d08fd622c9d8101a1e2becee510902f860cfce Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 27 Apr 2023 22:24:55 -0700 Subject: [PATCH 184/709] Clarification --- org.lflang/src/org/lflang/util/FileUtil.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index beaf5e7ea9..6f9a90d868 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -242,7 +242,9 @@ public static void copyFile(Path source, Path destination) throws IOException { /** * Given a list of files or directories, attempt to find them based on the given generator - * context, and copy then to the destination. + * context, and copy then to the destination. Files are searched for in the file system first. + * Files that cannot be found in the file system are looked for on the class path. + * * @param filesOrDirectories The files or directories to copy. * @param destination The location to copy them to. * @param context The generator context that specifies where the files must be found. From 4e4986746fc7ff0c1f312f5eef08721f371b6a49 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 27 Apr 2023 22:26:25 -0700 Subject: [PATCH 185/709] Address FIXME --- org.lflang/src/org/lflang/TargetConfig.java | 2 +- org.lflang/src/org/lflang/TargetProperty.java | 6 +++--- .../src/org/lflang/federated/generator/FedFileConfig.java | 2 +- org.lflang/src/org/lflang/generator/GeneratorBase.java | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 58b6e9ae2c..845f214ec8 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -230,7 +230,7 @@ public TargetConfig( /** * List of files to be copied to src-gen. */ - public List fileNames = new ArrayList<>(); // FIXME: misnamed, these are files or paths, not file names. + public List files = new ArrayList<>(); /** * If true, configure the execution environment to keep executing if there diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index 1bacb1f75e..61cda14431 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -276,16 +276,16 @@ public enum TargetProperty { * processed by the code generator. */ FILES("files", UnionType.FILE_OR_FILE_ARRAY, List.of(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.fileNames), + (config) -> ASTUtils.toElement(config.files), (config, value, err) -> { - config.fileNames = ASTUtils.elementToListOfStrings(value); + config.files = ASTUtils.elementToListOfStrings(value); }, // FIXME: This merging of lists is potentially dangerous since // the incoming list of files can belong to a .lf file that is // located in a different location, and keeping just filename // strings like this without absolute paths is incorrect. (config, value, err) -> { - config.fileNames.addAll(ASTUtils.elementToListOfStrings(value)); + config.files.addAll(ASTUtils.elementToListOfStrings(value)); }), /** diff --git a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java index 07c8bfdf9a..e434501825 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java @@ -111,7 +111,7 @@ public void doClean() throws IOException { */ public void relativizePaths(FedTargetConfig targetConfig) { relativizePathList(targetConfig.protoFiles); - relativizePathList(targetConfig.fileNames); + relativizePathList(targetConfig.files); relativizePathList(targetConfig.cmakeIncludes); } diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index ef083cbbda..ecb09dfbf9 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -350,7 +350,7 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * @param fileConfig The fileConfig used to make the copy and resolve paths. */ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - FileUtil.copyFiles(targetConfig.fileNames, fileConfig.getSrcGenPath(), context); + FileUtil.copyFiles(targetConfig.files, fileConfig.getSrcGenPath(), context); } /** From 927be22a496ba0deb68daf95b8794718bcfa817e Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 27 Apr 2023 22:40:24 -0700 Subject: [PATCH 186/709] Fix #1719 --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 5ae2cbd58e..8ae50498c9 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -611,7 +611,9 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { GeneratorResult.Status.COMPILED, null ); } - System.out.println("Compiled binary is in " + fileConfig.binPath); + if (!errorsOccurred()){ + System.out.println("Compiled binary is in " + fileConfig.binPath); + } } else { context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); } From d8ff9a698b07f14f2210172ece3fe852f0f4440f Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 27 Apr 2023 23:15:25 -0700 Subject: [PATCH 187/709] Bugfix --- .../src/org/lflang/generator/GeneratorBase.java | 2 +- .../src/org/lflang/generator/c/CGenerator.java | 9 ++++----- org.lflang/src/org/lflang/util/FileUtil.java | 17 ++++++++++++----- 3 files changed, 17 insertions(+), 11 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index ecb09dfbf9..15d703bcbf 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -350,7 +350,7 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * @param fileConfig The fileConfig used to make the copy and resolve paths. */ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - FileUtil.copyFiles(targetConfig.files, fileConfig.getSrcGenPath(), context); + FileUtil.copyFiles(targetConfig.files, this.context.getFileConfig().getSrcGenPath(), fileConfig, errorReporter); } /** diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 8ae50498c9..e52eae4db5 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -37,9 +37,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.io.File; import java.io.IOException; -import java.nio.file.Files; import java.nio.file.Path; -import java.nio.file.Paths; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; @@ -823,15 +821,16 @@ private void inspectReactorEResource(ReactorDecl reactor) { @Override protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { super.copyUserFiles(targetConfig, fileConfig); - var targetDir = fileConfig.getSrcGenPath(); + // Must use class variable to determine destination! + var destination = this.fileConfig.getSrcGenPath(); - FileUtil.copyFiles(targetConfig.cmakeIncludes, targetDir, context); + FileUtil.copyFiles(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter); // FIXME: Unclear what the following does, but it does not appear to belong here. if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { try { FileUtil.copyFile(fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), - targetDir.resolve(targetConfig.fedSetupPreamble)); + destination.resolve(targetConfig.fedSetupPreamble)); } catch (IOException e) { errorReporter.reportError("Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); } diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 6f9a90d868..a2cfb81e4d 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -36,6 +36,7 @@ import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.util.RuntimeIOException; +import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.generator.LFGeneratorContext; @@ -247,17 +248,23 @@ public static void copyFile(Path source, Path destination) throws IOException { * * @param filesOrDirectories The files or directories to copy. * @param destination The location to copy them to. - * @param context The generator context that specifies where the files must be found. + * @param fileConfig The file configuration that specifies where the files must be found. + * @param errorReporter An error reporter to report problems. */ - public static void copyFiles(List filesOrDirectories, Path destination, LFGeneratorContext context) { + public static void copyFiles( + List filesOrDirectories, + Path destination, + FileConfig fileConfig, + ErrorReporter errorReporter + ) { for (String fileOrDirectory : filesOrDirectories) { var path = Paths.get(fileOrDirectory); - var found = FileUtil.findInPackage(path, context.getFileConfig()); + var found = FileUtil.findInPackage(path, fileConfig); if (found != null) { try { FileUtil.copyFileOrDirectory(found, destination.resolve(found.getFileName())); } catch (IOException e) { - context.getErrorReporter().reportError( + errorReporter.reportError( "Unable to copy '" + fileOrDirectory + "' from the file system." ); } @@ -272,7 +279,7 @@ public static void copyFiles(List filesOrDirectories, Path destination, false ); } catch (IOException e) { - context.getErrorReporter().reportError( + errorReporter.reportError( "Unable to copy '" + fileOrDirectory + "' from the class path." ); } From a6487556e9f5ae075ae9fc14dff4efcbb01007ef Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 28 Apr 2023 08:28:02 +0200 Subject: [PATCH 188/709] Align reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 2f0fdad753..75ddd1d4a9 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 2f0fdad7535a7f639f421ac8bc5eec2a159df34c +Subproject commit 75ddd1d4a9cfab83639730863f9d31eb245cb61f From 3333bcbd84ffd88db09f987193c12aeca812e9ca Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 28 Apr 2023 09:35:58 +0200 Subject: [PATCH 189/709] Added LF_PROJECT_DIRECTORY --- org.lflang/src/lib/c/reactor-c | 2 +- .../federated/extensions/CExtensionUtils.java | 5 ++ .../generator/GeneratorCommandFactory.java | 1 + .../src/org/lflang/generator/c/CCompiler.java | 3 + .../src/org/lflang/generator/c/CUtil.java | 1 + test/C/src/FilePkgReader.lf | 47 +++++++++++++++ .../C/src/federated/FederatedFilePkgReader.lf | 57 +++++++++++++++++++ util/RunZephyrTests.sh | 2 +- 8 files changed, 116 insertions(+), 2 deletions(-) create mode 100644 test/C/src/FilePkgReader.lf create mode 100644 test/C/src/federated/FederatedFilePkgReader.lf diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 75ddd1d4a9..c6c549d43a 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 75ddd1d4a9cfab83639730863f9d31eb245cb61f +Subproject commit c6c549d43aa5144e5c1d4eea4feb16a410c40fd3 diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index 2ad19c64cc..f1fc4423e8 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -366,6 +366,11 @@ public static void generateCMakeInclude( + fileConfig.srcPath + "\")" ); + cmakeIncludeCode.pr( + "add_compile_definitions(LF_PROJECT_DIRECTORY=\"" + + fileConfig.srcPkgPath + + "\")" + ); try (var srcWriter = Files.newBufferedWriter(cmakeIncludePath)) { srcWriter.write(cmakeIncludeCode.getCode()); diff --git a/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java b/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java index 4868542afe..93026bf069 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java +++ b/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java @@ -128,6 +128,7 @@ public LFCommand createCommand(String cmd, List args, Path dir, boolean if (command != null) { command.setEnvironmentVariable("LF_CURRENT_WORKING_DIRECTORY", dir.toString()); command.setEnvironmentVariable("LF_SOURCE_DIRECTORY", fileConfig.srcPath.toString()); + command.setEnvironmentVariable("LF_PROJECT_DIRECTORY", fileConfig.srcPkgPath.toString()); command.setEnvironmentVariable("LF_SOURCE_GEN_DIRECTORY", fileConfig.getSrcGenPath().toString()); command.setEnvironmentVariable("LF_BIN_DIRECTORY", fileConfig.binPath.toString()); } else { diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index f0860a0e91..d9be4268bd 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -226,10 +226,12 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f String separator = File.separator; String maybeQuote = ""; // Windows seems to require extra level of quoting. String srcPath = fileConfig.srcPath.toString(); // Windows requires escaping the backslashes. + String rootPath = fileConfig.srcPkgPath.toString(); if (separator.equals("\\")) { separator = "\\\\\\\\"; maybeQuote = "\\\""; srcPath = srcPath.replaceAll("\\\\", "\\\\\\\\"); + rootPath = rootPath.replaceAll("\\\\", "\\\\\\\\"); } arguments.addAll(List.of( "-DCMAKE_BUILD_TYPE=" + ((targetConfig.cmakeBuildType!=null) ? targetConfig.cmakeBuildType.toString() : "Release"), @@ -247,6 +249,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f if (!fileConfig.srcPath.toString().contains("fed-gen")) { // Do not convert to Unix path arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + srcPath + maybeQuote + "\""); + arguments.add("-DLF_PROJECT_DIRECTORY=\"" + maybeQuote + rootPath + maybeQuote + "\""); } arguments.add(FileUtil.toUnixString(fileConfig.getSrcGenPath())); diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 69e9ec30ae..856849218b 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -710,6 +710,7 @@ public static Path findFileOrDirectory(String fileName, Path directory) { * * * LF_CURRENT_WORKING_DIRECTORY: The directory in which the command is invoked. * * LF_SOURCE_DIRECTORY: The directory containing the .lf file being compiled. + * * LF_PACKAGE_DIRECTORY: The directory for the root of the project. * * LF_SOURCE_GEN_DIRECTORY: The directory in which generated files are placed. * * LF_BIN_DIRECTORY: The directory into which to put binaries. * diff --git a/test/C/src/FilePkgReader.lf b/test/C/src/FilePkgReader.lf new file mode 100644 index 0000000000..e1dce78c8f --- /dev/null +++ b/test/C/src/FilePkgReader.lf @@ -0,0 +1,47 @@ +/** Test reading a file at a location relative to the source file. */ +target C + +reactor Source { + output out: char* // Use char*, not string, so memory is freed. + + reaction(startup) -> out {= + char* file_path = + LF_PROJECT_DIRECTORY + LF_FILE_SEPARATOR "src" + LF_FILE_SEPARATOR "lib" + LF_FILE_SEPARATOR "FileReader.txt"; + + FILE* file = fopen(file_path, "rb"); + if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); + + // Determine the file size + fseek(file, 0, SEEK_END); + long file_size = ftell(file); + fseek(file, 0, SEEK_SET); + + // Allocate memory for the buffer + char* buffer = (char *) malloc(file_size + 1); + if (buffer == NULL) lf_print_error_and_exit("Out of memory."); + + // Read the file into the buffer + fread(buffer, file_size, 1, file); + buffer[file_size] = '\0'; + fclose(file); + + lf_set(out, buffer); + =} +} + +main reactor { + preamble {= + #include + =} + s = new Source() + + reaction(s.out) {= + printf("Received: %s\n", s.out->value); + if (strcmp("Hello World", s.out->value) != 0) { + lf_print_error_and_exit("Expected 'Hello World'"); + } + =} +} diff --git a/test/C/src/federated/FederatedFilePkgReader.lf b/test/C/src/federated/FederatedFilePkgReader.lf new file mode 100644 index 0000000000..b553ec5ee1 --- /dev/null +++ b/test/C/src/federated/FederatedFilePkgReader.lf @@ -0,0 +1,57 @@ +/** Test reading a file at a location relative to the source file. */ +target C { + timeout: 0 s +} + +reactor Source { + output out: char* // Use char*, not string, so memory is freed. + + reaction(startup) -> out {= + char* file_path = + LF_PROJECT_DIRECTORY + LF_FILE_SEPARATOR "src" + LF_FILE_SEPARATOR "lib" + LF_FILE_SEPARATOR "FileReader.txt"; + + FILE* file = fopen(file_path, "rb"); + if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); + + // Determine the file size + fseek(file, 0, SEEK_END); + long file_size = ftell(file); + fseek(file, 0, SEEK_SET); + + // Allocate memory for the buffer + char* buffer = (char *) malloc(file_size + 1); + if (buffer == NULL) lf_print_error_and_exit("Out of memory."); + + // Read the file into the buffer + fread(buffer, file_size, 1, file); + buffer[file_size] = '\0'; + fclose(file); + + // For federated version, have to use lf_set_array so array size is know + // to the serializer. + lf_set_array(out, buffer, file_size + 1); + =} +} + +reactor Check { + preamble {= + #include + =} + input in: char* + + reaction(in) {= + printf("Received: %s\n", in->value); + if (strcmp("Hello World", in->value) != 0) { + lf_print_error_and_exit("Expected 'Hello World'"); + } + =} +} + +federated reactor { + s = new Source() + c = new Check() + s.out -> c.in +} diff --git a/util/RunZephyrTests.sh b/util/RunZephyrTests.sh index cabbbec0b2..25f5c12c58 100755 --- a/util/RunZephyrTests.sh +++ b/util/RunZephyrTests.sh @@ -9,7 +9,7 @@ num_failures=0 failed_tests="" # Skip -skip=("FileReader") +skip=("FileReader", "FilePkgReader") find_kconfig_folders() { if [ -f "$folder/CMakeLists.txt" ]; then From 5c3114e46b3cbf29fde1ef0b621dd8b3b066321c Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 28 Apr 2023 11:51:57 +0200 Subject: [PATCH 190/709] Continued refactoring --- org.lflang/src/lib/c/reactor-c | 2 +- .../org/lflang/generator/c/CGenerator.java | 49 +++---------- .../generator/c/CWatchdogGenerator.java | 72 ++++++++++++------- 3 files changed, 54 insertions(+), 69 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 4aef0ef54c..5d58c62cb1 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 4aef0ef54ca233b3cd9ff43863d0ffa715b91e8b +Subproject commit 5d58c62cb141e13c423cdadd11dbf97c8edd2d75 diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 7dbabf8aee..44691e773b 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -644,7 +644,7 @@ private void generateCodeFor(String lfModuleName) throws IOException { code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); // If there are watchdogs, create a table of triggers. - code.pr(CWatchdogGenerator.generateBuiltinTriggersTable(watchdogCount, "watchdog")); + code.pr(CWatchdogGenerator.generateWatchdogTable(watchdogCount)); // If there are modes, create a table of mode state to be checked for transitions. code.pr( @@ -750,16 +750,6 @@ private boolean hasDeadlines(List reactors) { return false; } - private boolean hasWatchdogs() { - for (Reactor reactor : reactors) { - List watchdogs = ASTUtils.allWatchdogs(reactor); - if (watchdogs != null && !watchdogs.isEmpty()) { - return true; - } - } - return false; - } - /** * Look at the 'reactor' eResource. If it is an imported .lf file, incorporate it into the current * program in the following manner: - Merge its target property with `targetConfig` - If there are @@ -1045,9 +1035,10 @@ private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeB // go into the constructor. Collect those lines of code here: var constructorCode = new CodeBuilder(); generateAuxiliaryStructs(header, reactor, false); + // The following must go before the self struct so the #include watchdog.h ends up in the header. + CWatchdogGenerator.generateWatchdogs(src, header, reactor); generateSelfStruct(header, reactor, constructorCode); generateMethods(src, reactor); - generateWatchdogs(src, reactor); generateReactions(src, reactor); generateConstructor(src, header, reactor, constructorCode); } @@ -1074,6 +1065,8 @@ protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) /** * Generate a constructor for the specified reactor in the specified federate. * + * @param src Where to put the assembled code. + * @param header Where to put header code. * @param reactor The parsed reactor data structure. * @param constructorCode Lines of code previously generated that need to go into the constructor. */ @@ -1398,33 +1391,6 @@ protected void generateReaction( getTarget().requiresTypes)); } - /** - * Generate watchdog functions definition for a reactor. These functions have a single argument - * that is a void* pointing to a struct that contains parameters, state variables, inputs - * (triggering or not), actions (triggering or produced), and outputs. - * - * @param decl The reactor. federated or not the main reactor and reactions should be - * unconditionally generated. - */ - public void generateWatchdogs(CodeBuilder src, ReactorDecl decl) { - var reactor = ASTUtils.toDefinition(decl); - for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - generateWatchdog(src, watchdog, decl); - } - } - - /** - * Generate a watchdog function definition for a reactor. This function will have a single - * argument that is a void* pointing to a struct that contains parameters, state variables, inputs - * (triggering or not), actions (triggering or produced), and outputs. - * - * @param watchdog The watchdog. - * @param decl The reactor. - */ - protected void generateWatchdog(CodeBuilder src, Watchdog watchdog, ReactorDecl decl) { - src.pr(CWatchdogGenerator.generateWatchdog(watchdog, decl)); - } - /** * Record startup, shutdown, and reset reactions. * @@ -1480,7 +1446,8 @@ private void recordWatchdogs(ReactorInstance instance) { var temp = new CodeBuilder(); var reactorRef = CUtil.reactorRef(instance); // temp.pr("#ifdef LF_THREADED"); - for (WatchdogInstance watchdog : instance.watchdogs) { + for (Watchdog watchdog + : ASTUtils.allWatchdogs(ASTUtils.toDefinition(instance.getDefinition().getReactorClass()))) { temp.pr( " _lf_watchdogs[_lf_watchdog_number_count++] = &" + reactorRef @@ -1493,7 +1460,7 @@ private void recordWatchdogs(ReactorInstance instance) { + "->_lf_watchdog_" + watchdog.getName() + ".min_expiration = " - + CTypes.getInstance().getTargetTimeExpr(watchdog.getTimeout()) + + CTypes.getInstance().getTargetTimeExpr(instance.getTimeValue(watchdog.getTimeout())) + ";"); temp.pr(" " + reactorRef + "->_lf_watchdog_" + watchdog.getName() + ".thread_id;"); watchdogCount += 1; diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 50428910f5..5bd0fe648d 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -18,6 +18,36 @@ */ public class CWatchdogGenerator { + /** + * Generate watchdog functions definition for a reactor. These functions have a single argument + * that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param src The place to put the code. + * @param header The place to put header code. + * @param decl The reactor declaration. + */ + public static void generateWatchdogs(CodeBuilder src, CodeBuilder header, ReactorDecl decl) { + var reactor = ASTUtils.toDefinition(decl); + if (hasWatchdogs(reactor)) { + header.pr("#include \"core/threaded/watchdog.h\""); + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + src.pr(generateWatchdogFunction(watchdog, decl)); + } + } + } + + /** + * Return true if the given reactor has one or more watchdogs. + * @param reactor The reactor. + * @return True if the given reactor has watchdogs. + */ + public static boolean hasWatchdogs(Reactor reactor) { + List watchdogs = ASTUtils.allWatchdogs(reactor); + if (watchdogs != null && !watchdogs.isEmpty()) return true; + return false; + } + /** * Generate necessary initialization code inside the body of the watchdog that belongs to reactor * decl. @@ -147,7 +177,7 @@ public static String generateFunction(String header, String init, Watchdog watch return function.toString(); } - /** Generate watchdog definition in parent struct. */ + /** Generate watchdog definition in the reactor's self struct. */ public static void generateWatchdogStruct( CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode) { var reactor = ASTUtils.toDefinition(decl); @@ -161,7 +191,6 @@ public static void generateWatchdogStruct( var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); // Set values of watchdog_t struct in the reactor's constructor // FIXME: update parameters - // constructorCode.pr("#ifdef LF_THREADED"); constructorCode.pr( watchdog, String.join( @@ -169,7 +198,6 @@ public static void generateWatchdogStruct( "self->_lf_watchdog_" + watchdogName + ".base = &(self->base);", "self->_lf_watchdog_" + watchdogName + ".expiration = NEVER;", "self->_lf_watchdog_" + watchdogName + ".thread_active = false;", - // "self->_lf_watchdog_"+watchdogName+".min_expiration = "+min_expiration+";", "self->_lf_watchdog_" + watchdogName + ".watchdog_function = " @@ -179,37 +207,27 @@ public static void generateWatchdogStruct( + watchdogName + ".trigger = &(self->_lf__" + watchdogName - + ");")); + + ");" + ) + ); } } /** - * Generate a watchdog function definition for a reactor. This function will have a single - * argument that is a void* pointing to a struct that contains parameters, state variables, inputs - * (triggering or not), actions (triggering or produced), and outputs. - * - * @param watchdog The watchdog. - * @param decl The reactor. + * Generate a global table of watchdog structs. + * @param count The number of watchdogs found. + * @return The code that defines the table or a comment if count is 0. */ - public static String generateWatchdog(Watchdog watchdog, ReactorDecl decl) { - var code = new CodeBuilder(); - - code.pr(generateWatchdogFunction(watchdog, decl)); - - return code.toString(); - } - - public static String generateBuiltinTriggersTable(int count, String name) { + public static String generateWatchdogTable(int count) { + if (count == 0) { + return "// No watchdogs found."; + } return String.join( "\n", List.of( - "// Array of pointers to " + name + " triggers.", - "#ifdef LF_THREADED", - (count > 0 - ? " watchdog_t* _lf_" + name + "s[" + count + "]" - : " watchdog_t* _lf_" + name + "s = NULL") - + ";", - " int _lf_" + name + "_number = " + count + ";", - "#endif")); + "// Array of pointers to watchdog structs.", + " watchdog_t* _lf_watchdogs[" + count + "];", + " int _lf_watchdog_number = " + count + ";" + )); } } From af103df9737ec9d98efc28d79c88d7f91b1b8ebe Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 28 Apr 2023 13:51:48 +0200 Subject: [PATCH 191/709] Attempt to exclude FilePkgReader --- util/RunZephyrTests.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/RunZephyrTests.sh b/util/RunZephyrTests.sh index cabbbec0b2..25f5c12c58 100755 --- a/util/RunZephyrTests.sh +++ b/util/RunZephyrTests.sh @@ -9,7 +9,7 @@ num_failures=0 failed_tests="" # Skip -skip=("FileReader") +skip=("FileReader", "FilePkgReader") find_kconfig_folders() { if [ -f "$folder/CMakeLists.txt" ]; then From 2db62e8c0e95d942528ef9ff2daababe17644872 Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Fri, 28 Apr 2023 17:26:13 +0200 Subject: [PATCH 192/709] Make USER_THREADS possible to specify as a target property in platform options --- org.lflang/src/org/lflang/TargetConfig.java | 5 +++++ org.lflang/src/org/lflang/TargetProperty.java | 9 ++++++++- org.lflang/src/org/lflang/generator/c/CGenerator.java | 8 ++++++++ 3 files changed, 21 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 23e99541da..9a34529124 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -478,6 +478,11 @@ public static class PlatformOptions { * port values depending on the infrastructure you use to flash the boards. */ public boolean flash = false; + + /** + * The int value is used to determine the number of needed threads for the user application in Zephyr. + */ + public int userThreads = 0; } /** diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index 1bacb1f75e..d8058009bb 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -432,6 +432,9 @@ public enum TargetProperty { case PORT: pair.setValue(ASTUtils.toElement(config.platformOptions.port)); break; + case USERTHREADS: + pair.setValue(ASTUtils.toElement(config.platformOptions.userThreads)); + break; } kvp.getPairs().add(pair); } @@ -472,6 +475,9 @@ public enum TargetProperty { case PORT: config.platformOptions.port = ASTUtils.elementToSingleString(entry.getValue()); break; + case USERTHREADS: + config.platformOptions.userThreads = ASTUtils.toInteger(entry.getValue()); + break; default: break; } @@ -1659,7 +1665,8 @@ public enum PlatformOption implements DictionaryElement { BAUDRATE("baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER), BOARD("board", PrimitiveType.STRING), FLASH("flash", PrimitiveType.BOOLEAN), - PORT("port", PrimitiveType.STRING); + PORT("port", PrimitiveType.STRING), + USERTHREADS("user_threads", PrimitiveType.NON_NEGATIVE_INTEGER); public final PrimitiveType type; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index f598219ddd..2bec8857bf 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1962,6 +1962,14 @@ protected void setUpGeneralParameters() { System.out.println("To enable compilation for the Arduino platform, you must specify the fully-qualified board name (FQBN) in the target property. For example, platform: {name: arduino, board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target code only."); targetConfig.noCompile = true; } + + if (targetConfig.platformOptions.platform == Platform.ZEPHYR && targetConfig.platformOptions.userThreads >= 0) { + targetConfig.compileDefinitions.put( + "USER_THREADS", + String.valueOf(targetConfig.platformOptions.userThreads) + ); + } + if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake pickScheduler(); // FIXME: this and pickScheduler should be combined. From f81a8fdafa5ed36825d99753cbc778c48de3ccf7 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 09:11:29 -0700 Subject: [PATCH 193/709] Fix a failing test and add a test that was failing but had already been fixed --- .../src/org/lflang/generator/c/CGenerator.java | 8 +++++++- test/C/src/target/FederatedFiles.lf | 14 ++++++++++++++ 2 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 test/C/src/target/FederatedFiles.lf diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index e52eae4db5..c01a85925d 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -804,9 +804,15 @@ private void inspectReactorEResource(ReactorDecl reactor) { break; } } - // Copy the user files and cmake-includes to the src-gen path of the main .lf file if (lfResource != null) { + // Copy the user files and cmake-includes to the src-gen path of the main .lf file copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); + // Merge the CMake includes from the imported file into the target config + lfResource.getTargetConfig().cmakeIncludes.stream().forEach(incl -> { + if (!this.targetConfig.cmakeIncludes.contains(incl)) { + this.targetConfig.cmakeIncludes.add(incl); + } + }); } } } diff --git a/test/C/src/target/FederatedFiles.lf b/test/C/src/target/FederatedFiles.lf new file mode 100644 index 0000000000..ebc1ff210e --- /dev/null +++ b/test/C/src/target/FederatedFiles.lf @@ -0,0 +1,14 @@ +// This test references a header file in reactor-c, which has to be obtained +// from the class path. This test is successful if it compiles. +target C { + files: "/lib/c/reactor-c/util/sensor_simulator.h", + timeout: 1 s +} + +reactor Foo { + reaction(startup) {= lf_print("Hello World"); =} +} + +federated reactor { + f = new Foo() +} From e3703397980f71a7b3814543fbbaba59b448acae Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 09:33:18 -0700 Subject: [PATCH 194/709] Update .github/workflows/ts-tests.yml --- .github/workflows/ts-tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 79c972d744..83c04d8cf7 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -28,7 +28,7 @@ jobs: if: ${{ runner.os == 'macOS' }} - name: Perform TypeScript tests run: | - ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#cleanup-deps" + ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#master" - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: From 9d665e6d288150971bb175c5e92b3e1599c6b3ac Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 09:33:43 -0700 Subject: [PATCH 195/709] Update action.yml --- .github/actions/prepare-build-env/action.yml | 5 ----- 1 file changed, 5 deletions(-) diff --git a/.github/actions/prepare-build-env/action.yml b/.github/actions/prepare-build-env/action.yml index 1ac9d0a813..2d0c82c78f 100644 --- a/.github/actions/prepare-build-env/action.yml +++ b/.github/actions/prepare-build-env/action.yml @@ -1,10 +1,5 @@ name: Prepare build environment (Linux only) description: Set up Java, Maven, Gradle, etc. -inputs: - lf-dir: - description: 'Relative path from $GITHUB_WORKSPACE to lingua-franca checkout' - required: false - default: '' runs: using: "composite" steps: From d7846a6330330b163154005342a0a1b5cd26bca5 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 09:36:17 -0700 Subject: [PATCH 196/709] Remove Babel config --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/lib/cpp/reactor-cpp | 2 +- org.lflang/src/lib/py/reactor-c-py | 2 +- org.lflang/src/lib/ts/babel.config.js | 19 ------------------- 4 files changed, 3 insertions(+), 22 deletions(-) delete mode 100644 org.lflang/src/lib/ts/babel.config.js diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 42a87b1b9c..4f78b42ac8 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 42a87b1b9cb678ab9170dbf800019bcbeb80c61f +Subproject commit 4f78b42ac806c113aed0ecd6510e56a20c049b61 diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index e80cd36ce5..a37f0ade9e 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit e80cd36ce5bd625a7b167e7dfd65d25f78b0dd01 +Subproject commit a37f0ade9ee0f97606528fd7ba67712495948373 diff --git a/org.lflang/src/lib/py/reactor-c-py b/org.lflang/src/lib/py/reactor-c-py index 9f82617589..14146b2f7b 160000 --- a/org.lflang/src/lib/py/reactor-c-py +++ b/org.lflang/src/lib/py/reactor-c-py @@ -1 +1 @@ -Subproject commit 9f82617589994ce5f71c88a091b32f5a4ac431f0 +Subproject commit 14146b2f7be6db8261b6a45724e18e0693f1f822 diff --git a/org.lflang/src/lib/ts/babel.config.js b/org.lflang/src/lib/ts/babel.config.js deleted file mode 100644 index 9fd078c1b2..0000000000 --- a/org.lflang/src/lib/ts/babel.config.js +++ /dev/null @@ -1,19 +0,0 @@ -module.exports = function (api) { - api.cache(true); - - const presets = [ - "@babel/typescript" - ]; - - const plugins = [ - "@babel/proposal-class-properties", - "@babel/proposal-object-rest-spread", - "@babel/plugin-proposal-optional-chaining", - "@babel/plugin-transform-modules-commonjs" - ]; - - return { - presets, - plugins - }; -} From 97e53b6c9dea50ea0785d75c81a569f6365d150c Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 29 Apr 2023 06:23:01 +0200 Subject: [PATCH 197/709] Another attempt to exclude FileReader --- util/RunZephyrTests.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/RunZephyrTests.sh b/util/RunZephyrTests.sh index 25f5c12c58..742a23ef18 100755 --- a/util/RunZephyrTests.sh +++ b/util/RunZephyrTests.sh @@ -9,7 +9,7 @@ num_failures=0 failed_tests="" # Skip -skip=("FileReader", "FilePkgReader") +skip=("FileReader" "FilePkgReader") find_kconfig_folders() { if [ -f "$folder/CMakeLists.txt" ]; then From 4c1197584294843049785156ddc5a7d1bc027344 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 29 Apr 2023 06:43:39 +0200 Subject: [PATCH 198/709] Another attempt to exclude FileReader --- util/RunZephyrTests.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/RunZephyrTests.sh b/util/RunZephyrTests.sh index 25f5c12c58..742a23ef18 100755 --- a/util/RunZephyrTests.sh +++ b/util/RunZephyrTests.sh @@ -9,7 +9,7 @@ num_failures=0 failed_tests="" # Skip -skip=("FileReader", "FilePkgReader") +skip=("FileReader" "FilePkgReader") find_kconfig_folders() { if [ -f "$folder/CMakeLists.txt" ]; then From ac2fef8e861601a3bee1c42da145a9a7f81c5331 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 29 Apr 2023 06:51:26 +0200 Subject: [PATCH 199/709] LF_PROJECT_DIRECTORY to LF_PACKAGE_DIRECTORY --- org.lflang/src/lib/c/reactor-c | 2 +- .../src/org/lflang/federated/extensions/CExtensionUtils.java | 2 +- .../src/org/lflang/generator/GeneratorCommandFactory.java | 2 +- org.lflang/src/org/lflang/generator/c/CCompiler.java | 2 +- test/C/src/FilePkgReader.lf | 2 +- test/C/src/federated/FederatedFilePkgReader.lf | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index c6c549d43a..8eaf16fdc4 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit c6c549d43aa5144e5c1d4eea4feb16a410c40fd3 +Subproject commit 8eaf16fdc46df596cf85f7be7e901988cabcd873 diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index f1fc4423e8..55a489ce51 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -367,7 +367,7 @@ public static void generateCMakeInclude( + "\")" ); cmakeIncludeCode.pr( - "add_compile_definitions(LF_PROJECT_DIRECTORY=\"" + "add_compile_definitions(LF_PACKAGE_DIRECTORY=\"" + fileConfig.srcPkgPath + "\")" ); diff --git a/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java b/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java index 93026bf069..081f07320b 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java +++ b/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java @@ -128,7 +128,7 @@ public LFCommand createCommand(String cmd, List args, Path dir, boolean if (command != null) { command.setEnvironmentVariable("LF_CURRENT_WORKING_DIRECTORY", dir.toString()); command.setEnvironmentVariable("LF_SOURCE_DIRECTORY", fileConfig.srcPath.toString()); - command.setEnvironmentVariable("LF_PROJECT_DIRECTORY", fileConfig.srcPkgPath.toString()); + command.setEnvironmentVariable("LF_PACKAGE_DIRECTORY", fileConfig.srcPkgPath.toString()); command.setEnvironmentVariable("LF_SOURCE_GEN_DIRECTORY", fileConfig.getSrcGenPath().toString()); command.setEnvironmentVariable("LF_BIN_DIRECTORY", fileConfig.binPath.toString()); } else { diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index d9be4268bd..e609144b62 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -249,7 +249,7 @@ private static List cmakeOptions(TargetConfig targetConfig, FileConfig f if (!fileConfig.srcPath.toString().contains("fed-gen")) { // Do not convert to Unix path arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + srcPath + maybeQuote + "\""); - arguments.add("-DLF_PROJECT_DIRECTORY=\"" + maybeQuote + rootPath + maybeQuote + "\""); + arguments.add("-DLF_PACKAGE_DIRECTORY=\"" + maybeQuote + rootPath + maybeQuote + "\""); } arguments.add(FileUtil.toUnixString(fileConfig.getSrcGenPath())); diff --git a/test/C/src/FilePkgReader.lf b/test/C/src/FilePkgReader.lf index e1dce78c8f..df2c03ab78 100644 --- a/test/C/src/FilePkgReader.lf +++ b/test/C/src/FilePkgReader.lf @@ -6,7 +6,7 @@ reactor Source { reaction(startup) -> out {= char* file_path = - LF_PROJECT_DIRECTORY + LF_PACKAGE_DIRECTORY LF_FILE_SEPARATOR "src" LF_FILE_SEPARATOR "lib" LF_FILE_SEPARATOR "FileReader.txt"; diff --git a/test/C/src/federated/FederatedFilePkgReader.lf b/test/C/src/federated/FederatedFilePkgReader.lf index b553ec5ee1..597ebbf96a 100644 --- a/test/C/src/federated/FederatedFilePkgReader.lf +++ b/test/C/src/federated/FederatedFilePkgReader.lf @@ -8,7 +8,7 @@ reactor Source { reaction(startup) -> out {= char* file_path = - LF_PROJECT_DIRECTORY + LF_PACKAGE_DIRECTORY LF_FILE_SEPARATOR "src" LF_FILE_SEPARATOR "lib" LF_FILE_SEPARATOR "FileReader.txt"; From b81f3a8fd3350eb81b1a8985e8d8307434325531 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 21:56:29 -0700 Subject: [PATCH 200/709] Address npm not properly building reactor-ts from GitHub dependency --- org.lflang/src/lib/ts/package.json | 2 +- .../org/lflang/generator/ts/TSGenerator.kt | 25 ++++++++++++++++++- 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index d994f27145..fc063d791e 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -16,7 +16,7 @@ "@typescript-eslint/parser": "^5.8.1", "eslint": "^8.5.0", "typescript": "~4.8.2", - "ts-protoc-gen": "^0.12.0", + "ts-protoc-gen": "^0.15.0", "rimraf": "^3.0.2" }, "scripts": { diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index fa9012d74d..8f36fbace4 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -61,8 +61,10 @@ class TSGenerator( val fileConfig: TSFileConfig = context.fileConfig as TSFileConfig + var devMode = false; companion object { + /** Path to the TS lib directory (relative to class path) */ const val LIB_PATH = "/lib/ts" @@ -72,6 +74,8 @@ class TSGenerator( */ val CONFIG_FILES = arrayOf("package.json", "tsconfig.json", ".eslintrc.json") + const val RUNTIME_URL = "git://github.com/lf-lang/reactor-ts.git" + fun timeInTargetLanguage(value: TimeValue): String { return if (value.unit != null) { "TimeValue.${value.unit.canonicalName}(${value.magnitude})" @@ -186,12 +190,18 @@ class TSGenerator( if (rtPath != null) rtPath = formatRuntimePath(rtPath) // FIXME: do better CLI arg validation upstream // https://github.com/lf-lang/lingua-franca/issues/1429 + if (rtPath != null || rtVersion != null) { + devMode = true; + } manifest.toFile().forEachLine { var line = it.replace("\"LinguaFrancaDefault\"", "\"${fileConfig.name}\""); + if (line.matches(rtRegex) && line.contains(RUNTIME_URL)) { + devMode = true; + } if (rtPath != null) { line = line.replace(rtRegex, "$1: \"$rtPath\",") } else if (rtVersion != null) { - line = line.replace(rtRegex, "$1: \"git://github.com/lf-lang/reactor-ts.git#$rtVersion\",") + line = line.replace(rtRegex, "$1: \"$RUNTIME_URL#$rtVersion\",") } sb.appendLine(line) } @@ -311,6 +321,7 @@ class TSGenerator( errorReporter.reportWarning( "Falling back on npm. To prevent an accumulation of replicated dependencies, " + "it is highly recommended to install pnpm globally (npm install -g pnpm).") + val npmInstall = commandFactory.createCommand("npm", if (production) listOf("install", "--production") else listOf("install"), path) if (npmInstall == null) { @@ -318,6 +329,18 @@ class TSGenerator( return } + // If reactor-ts is pulled from GitHub and building is done using npm, + // first build reactor-ts (pnpm does this automatically). + if (devMode) { + val rtPath = path.resolve("node_modules").resolve("@lf-lang").resolve("reactor-ts") + val buildRuntime = commandFactory.createCommand("npm", listOf("prepublish"), rtPath) + if (buildRuntime.run(context.cancelIndicator) != 0) { + errorReporter.reportError( + GeneratorUtils.findTargetDecl(resource), + "ERROR: unable to build runtime in dev mode: " + buildRuntime.errors.toString()) + } + } + if (npmInstall.run(context.cancelIndicator) != 0) { errorReporter.reportError( GeneratorUtils.findTargetDecl(resource), From 1b5d1dc781e0564d0cdb54eb48440b229b78798d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 21:59:47 -0700 Subject: [PATCH 201/709] Undo unintended submodule update --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 4f78b42ac8..75ddd1d4a9 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 4f78b42ac806c113aed0ecd6510e56a20c049b61 +Subproject commit 75ddd1d4a9cfab83639730863f9d31eb245cb61f From a2339df9f86ab11715aa697edf51ead899fe6c70 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 29 Apr 2023 07:20:00 +0200 Subject: [PATCH 202/709] Added test for resource-based file include for federated --- test/C/src/federated/FederatedFileInclude.lf | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 test/C/src/federated/FederatedFileInclude.lf diff --git a/test/C/src/federated/FederatedFileInclude.lf b/test/C/src/federated/FederatedFileInclude.lf new file mode 100644 index 0000000000..02b2d261bf --- /dev/null +++ b/test/C/src/federated/FederatedFileInclude.lf @@ -0,0 +1,13 @@ +/** Success here is just successfully compiling. */ +target C { + files: "/lib/c/reactor-c/util/sensor_simulator.h", + timeout: 1s +} +reactor Foo { + reaction(startup) {= + lf_print("Hello World"); + =} +} +federated reactor { + f = new Foo() +} \ No newline at end of file From 4f3be0b740334f753fac3c294321ce3f15b765b6 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 22:46:10 -0700 Subject: [PATCH 203/709] Fix detection of dev mode --- .../org/lflang/generator/ts/TSGenerator.kt | 23 ++++++++++--------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 8f36fbace4..bd92a144ce 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -195,7 +195,7 @@ class TSGenerator( } manifest.toFile().forEachLine { var line = it.replace("\"LinguaFrancaDefault\"", "\"${fileConfig.name}\""); - if (line.matches(rtRegex) && line.contains(RUNTIME_URL)) { + if (line.contains(rtRegex) && line.contains(RUNTIME_URL)) { devMode = true; } if (rtPath != null) { @@ -329,11 +329,21 @@ class TSGenerator( return } + if (npmInstall.run(context.cancelIndicator) != 0) { + errorReporter.reportError( + GeneratorUtils.findTargetDecl(resource), + "ERROR: npm install command failed: " + npmInstall.errors.toString()) + errorReporter.reportError( + GeneratorUtils.findTargetDecl(resource), "ERROR: npm install command failed." + + "\nFor installation instructions, see: https://www.npmjs.com/get-npm") + return + } + // If reactor-ts is pulled from GitHub and building is done using npm, // first build reactor-ts (pnpm does this automatically). if (devMode) { val rtPath = path.resolve("node_modules").resolve("@lf-lang").resolve("reactor-ts") - val buildRuntime = commandFactory.createCommand("npm", listOf("prepublish"), rtPath) + val buildRuntime = commandFactory.createCommand("npm", listOf("run", "prepublish"), rtPath) if (buildRuntime.run(context.cancelIndicator) != 0) { errorReporter.reportError( GeneratorUtils.findTargetDecl(resource), @@ -341,15 +351,6 @@ class TSGenerator( } } - if (npmInstall.run(context.cancelIndicator) != 0) { - errorReporter.reportError( - GeneratorUtils.findTargetDecl(resource), - "ERROR: npm install command failed: " + npmInstall.errors.toString()) - errorReporter.reportError( - GeneratorUtils.findTargetDecl(resource), "ERROR: npm install command failed." + - "\nFor installation instructions, see: https://www.npmjs.com/get-npm") - return - } installProtoBufsIfNeeded(false, path, context.cancelIndicator) } } From 35d39a3b5dcfc4682ea6d08799a4680604abe564 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 22:51:17 -0700 Subject: [PATCH 204/709] Undo more unintended submodule updates --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- org.lflang/src/lib/py/reactor-c-py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index a37f0ade9e..e80cd36ce5 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit a37f0ade9ee0f97606528fd7ba67712495948373 +Subproject commit e80cd36ce5bd625a7b167e7dfd65d25f78b0dd01 diff --git a/org.lflang/src/lib/py/reactor-c-py b/org.lflang/src/lib/py/reactor-c-py index 14146b2f7b..9f82617589 160000 --- a/org.lflang/src/lib/py/reactor-c-py +++ b/org.lflang/src/lib/py/reactor-c-py @@ -1 +1 @@ -Subproject commit 14146b2f7be6db8261b6a45724e18e0693f1f822 +Subproject commit 9f82617589994ce5f71c88a091b32f5a4ac431f0 From 9020ccada00c4004dd753c7ec42d0c4ec544ed50 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 09:15:45 -0700 Subject: [PATCH 205/709] Minor simplification --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index c01a85925d..fbedb23253 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -808,7 +808,7 @@ private void inspectReactorEResource(ReactorDecl reactor) { // Copy the user files and cmake-includes to the src-gen path of the main .lf file copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); // Merge the CMake includes from the imported file into the target config - lfResource.getTargetConfig().cmakeIncludes.stream().forEach(incl -> { + lfResource.getTargetConfig().cmakeIncludes.forEach(incl -> { if (!this.targetConfig.cmakeIncludes.contains(incl)) { this.targetConfig.cmakeIncludes.add(incl); } From 8c5cab94ac365f302018e1cfbf0c6f55216fb2d1 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 28 Apr 2023 23:19:51 -0700 Subject: [PATCH 206/709] Revert "Added test for resource-based file include for federated" This reverts commit a2339df9f86ab11715aa697edf51ead899fe6c70. --- test/C/src/federated/FederatedFileInclude.lf | 13 ------------- 1 file changed, 13 deletions(-) delete mode 100644 test/C/src/federated/FederatedFileInclude.lf diff --git a/test/C/src/federated/FederatedFileInclude.lf b/test/C/src/federated/FederatedFileInclude.lf deleted file mode 100644 index 02b2d261bf..0000000000 --- a/test/C/src/federated/FederatedFileInclude.lf +++ /dev/null @@ -1,13 +0,0 @@ -/** Success here is just successfully compiling. */ -target C { - files: "/lib/c/reactor-c/util/sensor_simulator.h", - timeout: 1s -} -reactor Foo { - reaction(startup) {= - lf_print("Hello World"); - =} -} -federated reactor { - f = new Foo() -} \ No newline at end of file From 49d3ba9fd15de7bcb354cb0db93f0bc67b843cdf Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 29 Apr 2023 11:28:53 +0200 Subject: [PATCH 207/709] Watcher cannot watch its own reactions --- test/C/src/Watchdog.lf | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index e40157a9e6..a836c93c3f 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -11,14 +11,13 @@ target C { reactor Watcher(timeout: time = 150 ms) { timer t(100 ms, 100 ms) // Offset ameliorates startup time. + // Period has to be smaller than watchdog timeout. output d: int // Produced if the watchdog triggers. - state alternating: bool = false state count: int = 0 watchdog poodle(timeout) {= - instant_t p = lf_time_physical_elapsed() - lf_time_logical_elapsed(); - lf_print("Watchdog timed out! Lag: %lld (too late by " PRINTF_TIME " ns)", p, p - self->timeout); - lf_print("At logical time inside watchdog panic: " PRINTF_TIME, lf_time_logical_elapsed()); + instant_t p = lf_time_physical_elapsed(); + lf_print("******** Watchdog timed out at elapsed physical time: " PRINTF_TIME, p); self->count++; =} @@ -26,10 +25,7 @@ reactor Watcher(timeout: time = 150 ms) { lf_watchdog_start(poodle, 0); lf_print("Watchdog started at physical time " PRINTF_TIME, lf_time_physical_elapsed()); lf_print("Will expire at " PRINTF_TIME, lf_time_logical_elapsed() + self->timeout); - if (self->alternating) { - lf_sleep(MSEC(160)); - } - self->alternating = !self->alternating; + lf_set(d, 42); =} reaction(poodle) -> d {= @@ -39,8 +35,8 @@ reactor Watcher(timeout: time = 150 ms) { reaction(shutdown) -> poodle {= lf_watchdog_stop(poodle); - if (self->count != 5) { - lf_print_error_and_exit("Watchdog expired %d times. Expected 5.", self->count); + if (self->count != 2) { + lf_print_error_and_exit("Watchdog expired %d times. Expected 2.", self->count); } =} } @@ -52,13 +48,17 @@ main reactor { w = new Watcher() reaction(w.d) {= - lf_print("*** Watcher reactor produced an output."); + lf_print("Watcher reactor produced an output. %d", self->count % 2); self->count++; + if (self->count % 4 == 0) { + lf_print(">>>>>> Taking a long time to process that output!"); + lf_sleep(MSEC(160)); + } =} reaction(shutdown) {= - if (self->count != 5) { - lf_print_error_and_exit("Watchdog produced output %d times. Expected 5.", self->count); + if (self->count != 12) { + lf_print_error_and_exit("Watchdog produced output %d times. Expected 12.", self->count); } =} } From 661df8802900db14666b8b5134495b681768852a Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 29 Apr 2023 11:29:34 +0200 Subject: [PATCH 208/709] Continued refactoring and docs --- org.lflang/src/lib/c/reactor-c | 2 +- .../org/lflang/generator/c/CGenerator.java | 35 +-- .../generator/c/CReactionGenerator.java | 6 + .../generator/c/CWatchdogGenerator.java | 272 +++++++++++------- 4 files changed, 177 insertions(+), 138 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 5d58c62cb1..68e2c14fab 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 5d58c62cb141e13c423cdadd11dbf97c8edd2d75 +Subproject commit 68e2c14fabf124f280e656e23f1954df1fd80657 diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 44691e773b..3a3352aa03 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -72,7 +72,6 @@ import org.lflang.generator.TargetTypes; import org.lflang.generator.TimerInstance; import org.lflang.generator.TriggerInstance; -import org.lflang.generator.WatchdogInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; import org.lflang.lf.Input; @@ -86,7 +85,6 @@ import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; import org.lflang.lf.Variable; -import org.lflang.lf.Watchdog; import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; @@ -1441,37 +1439,6 @@ private void recordBuiltinTriggers(ReactorInstance instance) { } } - private void recordWatchdogs(ReactorInstance instance) { - var foundOne = false; - var temp = new CodeBuilder(); - var reactorRef = CUtil.reactorRef(instance); - // temp.pr("#ifdef LF_THREADED"); - for (Watchdog watchdog - : ASTUtils.allWatchdogs(ASTUtils.toDefinition(instance.getDefinition().getReactorClass()))) { - temp.pr( - " _lf_watchdogs[_lf_watchdog_number_count++] = &" - + reactorRef - + "->_lf_watchdog_" - + watchdog.getName() - + ";"); - temp.pr( - " " - + reactorRef - + "->_lf_watchdog_" - + watchdog.getName() - + ".min_expiration = " - + CTypes.getInstance().getTargetTimeExpr(instance.getTimeValue(watchdog.getTimeout())) - + ";"); - temp.pr(" " + reactorRef + "->_lf_watchdog_" + watchdog.getName() + ".thread_id;"); - watchdogCount += 1; - foundOne = true; - } - // temp.pr("#endif"); - if (foundOne) { - initializeTriggerObjects.pr(temp.toString()); - } - } - /** * Generate code to set up the tables used in _lf_start_time_step to decrement reference counts * and mark outputs absent between time steps. This function puts the code into startTimeStep. @@ -1746,7 +1713,7 @@ public void generateReactorInstance(ReactorInstance instance) { initializeOutputMultiports(instance); initializeInputMultiports(instance); recordBuiltinTriggers(instance); - recordWatchdogs(instance); + watchdogCount += CWatchdogGenerator.generateInitializeWatchdogs(initializeTriggerObjects, instance); // Next, initialize the "self" struct with state variables. // These values may be expressions that refer to the parameter values defined above. diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index dae1f01230..a203f9ee3c 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -1377,6 +1377,12 @@ public static String generateStpFunctionHeader(Reactor r, int reactionIndex) { return generateFunctionHeader(functionName); } + /** + * Return the start of a function declaration for a function that takes + * a `void*` argument and returns void. + * @param functionName + * @return + */ public static String generateFunctionHeader(String functionName) { return "void " + functionName + "(void* instance_args)"; } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 5bd0fe648d..695bd5eefa 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -1,8 +1,17 @@ +/** + * @file + * @author Benjamin Asch + * @author Edward A. Lee + * @copyright (c) 2023, The University of California at Berkeley. + * License: BSD 2-clause + * @brief Code generation methods for watchdogs in C. + */ package org.lflang.generator.c; import java.util.List; import org.lflang.ASTUtils; import org.lflang.generator.CodeBuilder; +import org.lflang.generator.ReactorInstance; import org.lflang.lf.Mode; import org.lflang.lf.ModeTransition; import org.lflang.lf.Reactor; @@ -12,22 +21,77 @@ import org.lflang.lf.Watchdog; /** - * Generates necessary C code for watchdogs. + * @brief Generate C code for watchdogs. + * This class contains a collection of static methods supporting code generation in C + * for watchdogs. These methods are protected because they are intended to be used + * only within the same package. * - * @author{Benjamin Asch } + * @author Benjamin Asch + * @author Edward A. Lee */ public class CWatchdogGenerator { + /** + * Return true if the given reactor has one or more watchdogs. + * @param reactor The reactor. + * @return True if the given reactor has watchdogs. + */ + public static boolean hasWatchdogs(Reactor reactor) { + List watchdogs = ASTUtils.allWatchdogs(reactor); + if (watchdogs != null && !watchdogs.isEmpty()) return true; + return false; + } + + ///////////////////////////////////////////////////////////////// + // Protected methods + + /** + * For the specified reactor instance, generate initialization code for each watchdog + * in the reactor. This code initializes the watchdog-related fields on the self struct + * of the reactor instance. + * @param code The place to put the code + * @param instance The reactor instance + * @return The count of watchdogs found in the reactor + */ + protected static int generateInitializeWatchdogs(CodeBuilder code, ReactorInstance instance) { + var foundOne = false; + var temp = new CodeBuilder(); + var reactorRef = CUtil.reactorRef(instance); + int watchdogCount = 0; + for (Watchdog watchdog + : ASTUtils.allWatchdogs(ASTUtils.toDefinition(instance.getDefinition().getReactorClass()))) { + var watchdogField = reactorRef + "->_lf_watchdog_" + watchdog.getName(); + temp.pr(String.join("\n", + "_lf_watchdogs[_lf_watchdog_number_count++] = &" + watchdogField + ";", + watchdogField + ".min_expiration = " + + CTypes.getInstance().getTargetTimeExpr(instance.getTimeValue(watchdog.getTimeout())) + + ";", + watchdogField + ".thread_active = false;", + "if (" + watchdogField + ".base->reactor_mutex == NULL) {", + " " + watchdogField + ".base->reactor_mutex = (lf_mutex_t*)calloc(1, sizeof(lf_mutex_t));", + "}" + )); + watchdogCount += 1; + foundOne = true; + } + // temp.pr("#endif"); + if (foundOne) { + code.pr(temp.toString()); + } + code.pr("SUPPRESS_UNUSED_WARNING(_lf_watchdog_number);"); + return watchdogCount; + } + /** * Generate watchdog functions definition for a reactor. These functions have a single argument - * that is a void* pointing to a struct that contains parameters, state variables, inputs - * (triggering or not), actions (triggering or produced), and outputs. + * that is a void* pointing to the self struct of the reactor, which contains parameters, state + * variables, inputs (triggering or not), actions (triggering or produced), and outputs. * - * @param src The place to put the code. - * @param header The place to put header code. - * @param decl The reactor declaration. + * @param src The place to put the code + * @param header The place to put header code + * @param decl The reactor declaration */ - public static void generateWatchdogs(CodeBuilder src, CodeBuilder header, ReactorDecl decl) { + protected static void generateWatchdogs(CodeBuilder src, CodeBuilder header, ReactorDecl decl) { var reactor = ASTUtils.toDefinition(decl); if (hasWatchdogs(reactor)) { header.pr("#include \"core/threaded/watchdog.h\""); @@ -38,23 +102,78 @@ public static void generateWatchdogs(CodeBuilder src, CodeBuilder header, Reacto } /** - * Return true if the given reactor has one or more watchdogs. - * @param reactor The reactor. - * @return True if the given reactor has watchdogs. + * Generate watchdog definitions in the reactor's self struct. + * @param body The place to put the definitions + * @param decl The reactor declaration + * @param constructorCode The place to put initialization code. */ - public static boolean hasWatchdogs(Reactor reactor) { - List watchdogs = ASTUtils.allWatchdogs(reactor); - if (watchdogs != null && !watchdogs.isEmpty()) return true; - return false; + protected static void generateWatchdogStruct( + CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode) { + var reactor = ASTUtils.toDefinition(decl); + + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + String watchdogName = watchdog.getName(); + + body.pr(watchdog, "watchdog_t _lf_watchdog_" + watchdogName + ";"); + + // watchdog function name + var watchdogFunctionName = watchdogFunctionName(watchdog, decl); + // Set values of watchdog_t struct in the reactor's constructor. + constructorCode.pr( + watchdog, + String.join( + "\n", + "self->_lf_watchdog_" + watchdogName + ".base = &(self->base);", + "self->_lf_watchdog_" + watchdogName + ".expiration = NEVER;", + "self->_lf_watchdog_" + watchdogName + ".thread_active = false;", + "self->_lf_watchdog_" + + watchdogName + + ".watchdog_function = " + + watchdogFunctionName + + ";", + "self->_lf_watchdog_" + + watchdogName + + ".trigger = &(self->_lf__" + + watchdogName + + ");" + ) + ); + } } /** - * Generate necessary initialization code inside the body of the watchdog that belongs to reactor - * decl. + * Generate a global table of watchdog structs. + * @param count The number of watchdogs found. + * @return The code that defines the table or a comment if count is 0. + */ + protected static String generateWatchdogTable(int count) { + if (count == 0) { + return String.join("\n", + "// No watchdogs found.", + "watchdog_t* _lf_watchdogs = NULL;", + "int _lf_watchdog_number = 0;" + ); + } + return String.join( + "\n", + List.of( + "// Array of pointers to watchdog structs.", + "watchdog_t* _lf_watchdogs[" + count + "];", + "int _lf_watchdog_number = " + count + ";" + ) + ); + } + + ///////////////////////////////////////////////////////////////// + // Private methods + + /** + * Generate necessary initialization code inside the body of a watchdog handler. * - * @param decl The reactor that has the watchdog + * @param watchdog The wotchdog + * @param decl The declaration for the reactor that has the watchdog */ - public static String generateInitializationForWatchdog(Watchdog watchdog, ReactorDecl decl) { + private static String generateInitializationForWatchdog(Watchdog watchdog, ReactorDecl decl) { Reactor reactor = ASTUtils.toDefinition(decl); // Construct the reactionInitialization code to go into @@ -96,8 +215,8 @@ public static String generateInitializationForWatchdog(Watchdog watchdog, Reacto + name + "_change_type = " + (effect.getTransition() == ModeTransition.HISTORY - ? "history_transition" - : "reset_transition") + ? "history_transition" + : "reset_transition") + ";"); } // FIXME: include error reporter @@ -124,47 +243,13 @@ public static String generateInitializationForWatchdog(Watchdog watchdog, Reacto } /** - * Returns the name of the watchdog function for reaction. - * - * @param decl The reactor with the watchdog - * @param watchdog The watchdog - * @return Name of the watchdog function for reaction - */ - public static String generateWatchdogFunctionName(Watchdog watchdog, ReactorDecl decl) { - return decl.getName().toLowerCase() - + "_" - + watchdog.getName().toLowerCase() - + "_watchdog_function"; - } - - /** - * Return the top level C function header for the watchdog function in "decl" - * - * @param decl The reactor declaration - * @param watchdog The watchdog. - * @return The function name for the watchdog function. - */ - public static String generateWatchdogFunctionHeader(Watchdog watchdog, ReactorDecl decl) { - String functionName = generateWatchdogFunctionName(watchdog, decl); - return CReactionGenerator.generateFunctionHeader(functionName); - } - - /** Generate the watchdog function. */ - public static String generateWatchdogFunction(Watchdog watchdog, ReactorDecl decl) { - return generateFunction( - generateWatchdogFunctionHeader(watchdog, decl), - generateInitializationForWatchdog(watchdog, decl), - watchdog); - } - - /** - * Do heavy lifting to generate above watchdog function + * Do heavy lifting to generate the watchdog handler function * * @param header function name and declaration. * @param init initialize variable. * @param watchdog The watchdog. */ - public static String generateFunction(String header, String init, Watchdog watchdog) { + private static String generateFunction(String header, String init, Watchdog watchdog) { var function = new CodeBuilder(); function.pr(header + " {"); function.indent(); @@ -177,57 +262,38 @@ public static String generateFunction(String header, String init, Watchdog watch return function.toString(); } - /** Generate watchdog definition in the reactor's self struct. */ - public static void generateWatchdogStruct( - CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode) { - var reactor = ASTUtils.toDefinition(decl); - - for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - String watchdogName = watchdog.getName(); - body.pr(watchdog, "watchdog_t _lf_watchdog_" + watchdogName + ";"); + /** Generate the watchdog handler function. */ + private static String generateWatchdogFunction(Watchdog watchdog, ReactorDecl decl) { + return generateFunction( + generateWatchdogFunctionHeader(watchdog, decl), + generateInitializationForWatchdog(watchdog, decl), + watchdog); + } - // watchdog function name - var watchdogFunctionName = generateWatchdogFunctionName(watchdog, decl); - // Set values of watchdog_t struct in the reactor's constructor - // FIXME: update parameters - constructorCode.pr( - watchdog, - String.join( - "\n", - "self->_lf_watchdog_" + watchdogName + ".base = &(self->base);", - "self->_lf_watchdog_" + watchdogName + ".expiration = NEVER;", - "self->_lf_watchdog_" + watchdogName + ".thread_active = false;", - "self->_lf_watchdog_" - + watchdogName - + ".watchdog_function = " - + watchdogFunctionName - + ";", - "self->_lf_watchdog_" - + watchdogName - + ".trigger = &(self->_lf__" - + watchdogName - + ");" - ) - ); - } + /** + * Return the start of a C function definition for a watchdog. + * + * @param watchdog The watchdog + * @param decl The reactor declaration + * @return The function name for the watchdog function. + */ + private static String generateWatchdogFunctionHeader(Watchdog watchdog, ReactorDecl decl) { + String functionName = watchdogFunctionName(watchdog, decl); + return CReactionGenerator.generateFunctionHeader(functionName); } /** - * Generate a global table of watchdog structs. - * @param count The number of watchdogs found. - * @return The code that defines the table or a comment if count is 0. + * Return the name of the watchdog expiration handler function. + * + * @param watchdog The watchdog + * @param decl The reactor with the watchdog + * @return Name of the watchdog handler function */ - public static String generateWatchdogTable(int count) { - if (count == 0) { - return "// No watchdogs found."; - } - return String.join( - "\n", - List.of( - "// Array of pointers to watchdog structs.", - " watchdog_t* _lf_watchdogs[" + count + "];", - " int _lf_watchdog_number = " + count + ";" - )); + private static String watchdogFunctionName(Watchdog watchdog, ReactorDecl decl) { + return decl.getName().toLowerCase() + + "_" + + watchdog.getName().toLowerCase() + + "_watchdog_function"; } } From 95a7116ee548a0781efdd384b871cd564f679eff Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 30 Apr 2023 09:37:12 +0200 Subject: [PATCH 209/709] Aligned reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 68e2c14fab..97466da394 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 68e2c14fabf124f280e656e23f1954df1fd80657 +Subproject commit 97466da394d9572e4ba905b2706759bef73c0af0 From 4a5582524869a886a76fcde0159bcd37283eb1e2 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 30 Apr 2023 10:45:32 +0200 Subject: [PATCH 210/709] Manually reverted formatting changes. --- org.lflang/src/org/lflang/ASTUtils.java | 3312 ++++++++++++----------- 1 file changed, 1696 insertions(+), 1616 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 4606b4d35f..f8c436727c 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -1,12 +1,16 @@ /* Copyright (c) 2020, The University of California at Berkeley. + 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. + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -21,9 +25,6 @@ package org.lflang; -import com.google.common.collect.HashMultimap; -import com.google.common.collect.Iterables; -import com.google.common.collect.Iterators; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; @@ -31,6 +32,7 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.Set; import java.util.function.Predicate; import java.util.regex.Matcher; @@ -38,6 +40,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; + import org.eclipse.emf.common.util.EList; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EStructuralFeature; @@ -58,6 +61,8 @@ import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.Assignment; +import org.lflang.lf.AttrParm; +import org.lflang.lf.Attribute; import org.lflang.lf.Code; import org.lflang.lf.Connection; import org.lflang.lf.Element; @@ -91,1662 +96,1737 @@ import org.lflang.lf.WidthTerm; import org.lflang.util.StringUtil; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Iterators; + /** * A helper class for modifying and analyzing the AST. - * * @author Marten Lohstroh * @author Edward A. Lee * @author Christian Menard */ public class ASTUtils { - /** The Lingua Franca factory for creating new AST nodes. */ - public static final LfFactory factory = LfFactory.eINSTANCE; - - /** The Lingua Franca feature package. */ - public static final LfPackage featurePackage = LfPackage.eINSTANCE; - - /* Match an abbreviated form of a float literal. */ - private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); - - /** - * A mapping from Reactor features to corresponding Mode features for collecting contained - * elements. - */ - private static final Map reactorModeFeatureMap = - Map.of( - featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), - featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), - featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), - featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), - featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), - featurePackage.getReactor_Timers(), featurePackage.getMode_Timers(), - featurePackage.getReactor_Watchdogs(), featurePackage.getMode_Watchdogs()); - - /** - * Get all reactors defined in the given resource. - * - * @param resource the resource to extract reactors from - * @return An iterable over all reactors found in the resource - */ - public static List getAllReactors(Resource resource) { - return StreamSupport.stream( - IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) - .filter(Reactor.class::isInstance) - .map(Reactor.class::cast) - .collect(Collectors.toList()); - } - - /** - * Find connections in the given resource that would be conflicting writes if they were not - * located in mutually exclusive modes. - * - * @param resource The AST. - * @return a list of connections being able to be transformed - */ - public static Collection findConflictingConnectionsInModalReactors( - Resource resource) { - var transform = new HashSet(); - - for (Reactor reactor : getAllReactors(resource)) { - if (!reactor.getModes().isEmpty()) { // Only for modal reactors - var allWriters = HashMultimap., EObject>create(); - - // Collect destinations - for (var rea : allReactions(reactor)) { - for (var eff : rea.getEffects()) { - if (eff.getVariable() instanceof Port) { - allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); + /** + * The Lingua Franca factory for creating new AST nodes. + */ + public static final LfFactory factory = LfFactory.eINSTANCE; + + /** + * The Lingua Franca feature package. + */ + public static final LfPackage featurePackage = LfPackage.eINSTANCE; + + /* Match an abbreviated form of a float literal. */ + private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); + + /** + * A mapping from Reactor features to corresponding Mode features for collecting contained elements. + */ + private static final Map reactorModeFeatureMap = Map.of( + featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), + featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), + featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), + featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), + featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), + featurePackage.getReactor_Timers(), featurePackage.getMode_Timers() + ); + + + /** + * Get all reactors defined in the given resource. + * @param resource the resource to extract reactors from + * @return An iterable over all reactors found in the resource + */ + public static List getAllReactors(Resource resource) { + return StreamSupport.stream(IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) + .filter(Reactor.class::isInstance) + .map(Reactor.class::cast) + .collect(Collectors.toList()); + } + + /** + * Find connections in the given resource that would be conflicting writes if they were not located in mutually + * exclusive modes. + * + * @param resource The AST. + * @return a list of connections being able to be transformed + */ + public static Collection findConflictingConnectionsInModalReactors(Resource resource) { + var transform = new HashSet(); + + for (Reactor reactor : getAllReactors(resource)) { + if (!reactor.getModes().isEmpty()) { // Only for modal reactors + var allWriters = HashMultimap., EObject>create(); + + // Collect destinations + for (var rea : allReactions(reactor)) { + for (var eff : rea.getEffects()) { + if (eff.getVariable() instanceof Port) { + allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); + } + } + } + for (var con : ASTUtils.collectElements(reactor, featurePackage.getReactor_Connections(), false, true)) { + for (var port : con.getRightPorts()) { + allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); + } + } + + // Handle conflicting writers + for (var key : allWriters.keySet()) { + var writers = allWriters.get(key); + if (writers.size() > 1) { // has multiple sources + var writerModes = HashMultimap.create(); + // find modes + for (var writer : writers) { + if (writer.eContainer() instanceof Mode) { + writerModes.put((Mode) writer.eContainer(), writer); + } else { + writerModes.put(null, writer); + } + } + // Conflicting connection can only be handled if.. + if (!writerModes.containsKey(null) && // no writer is on root level (outside of modes) and... + writerModes.keySet().stream().map(writerModes::get).allMatch(writersInMode -> // all writers in a mode are either... + writersInMode.size() == 1 || // the only writer or... + writersInMode.stream().allMatch(w -> w instanceof Reaction) // all are reactions and hence ordered + )) { + // Add connections to transform list + writers.stream().filter(w -> w instanceof Connection).forEach(c -> transform.add((Connection) c)); + } + } + } } - } } - for (var con : - ASTUtils.collectElements( - reactor, featurePackage.getReactor_Connections(), false, true)) { - for (var port : con.getRightPorts()) { - allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); - } + + return transform; + } + + /** + * Return the enclosing reactor of an LF EObject in a reactor or mode. + * @param obj the LF model element + * @return the reactor or null + */ + public static Reactor getEnclosingReactor(EObject obj) { + if (obj.eContainer() instanceof Reactor) { + return (Reactor) obj.eContainer(); + } else if (obj.eContainer() instanceof Mode) { + return (Reactor) obj.eContainer().eContainer(); + } + return null; + } + + /** + * Return the main reactor in the given resource if there is one, null otherwise. + */ + public static Reactor findMainReactor(Resource resource) { + return IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), + Reactor::isMain + ); + } + + /** + * Find the main reactor and change it to a federated reactor. + * Return true if the transformation was successful (or the given resource + * already had a federated reactor); return false otherwise. + */ + public static boolean makeFederated(Resource resource) { + // Find the main reactor + Reactor r = findMainReactor(resource); + if (r == null) { + return false; + } + r.setMain(false); + r.setFederated(true); + return true; + } + + /** + * Change the target name to 'newTargetName'. + * For example, change C to CCpp. + */ + public static boolean changeTargetName(Resource resource, String newTargetName) { + targetDecl(resource).setName(newTargetName); + return true; + } + + /** + * Return the target of the file in which the given node lives. + */ + public static Target getTarget(EObject object) { + TargetDecl targetDecl = targetDecl(object.eResource()); + return Target.fromDecl(targetDecl); + } + + /** + * Add a new target property to the given resource. + * + * This also creates a config object if the resource does not yey have one. + * + * @param resource The resource to modify + * @param name Name of the property to add + * @param value Value to be assigned to the property + */ + public static boolean addTargetProperty(final Resource resource, final String name, final Element value) { + var config = targetDecl(resource).getConfig(); + if (config == null) { + config = LfFactory.eINSTANCE.createKeyValuePairs(); + targetDecl(resource).setConfig(config); + } + final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); + newProperty.setName(name); + newProperty.setValue(value); + config.getPairs().add(newProperty); + return true; + } + + /** + * Return true if the connection involves multiple ports on the left or right side of the connection, or + * if the port on the left or right of the connection involves a bank of reactors or a multiport. + * @param connection The connection. + */ + public static boolean hasMultipleConnections(Connection connection) { + if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { + return true; } + VarRef leftPort = connection.getLeftPorts().get(0); + VarRef rightPort = connection.getRightPorts().get(0); + Instantiation leftContainer = leftPort.getContainer(); + Instantiation rightContainer = rightPort.getContainer(); + Port leftPortAsPort = (Port) leftPort.getVariable(); + Port rightPortAsPort = (Port) rightPort.getVariable(); + return leftPortAsPort.getWidthSpec() != null + || leftContainer != null && leftContainer.getWidthSpec() != null + || rightPortAsPort.getWidthSpec() != null + || rightContainer != null && rightContainer.getWidthSpec() != null; + } + + /** + * Produce a unique identifier within a reactor based on a + * given based name. If the name does not exists, it is returned; + * if does exist, an index is appended that makes the name unique. + * @param reactor The reactor to find a unique identifier within. + * @param name The name to base the returned identifier on. + */ + public static String getUniqueIdentifier(Reactor reactor, String name) { + LinkedHashSet vars = new LinkedHashSet<>(); + allActions(reactor).forEach(it -> vars.add(it.getName())); + allTimers(reactor).forEach(it -> vars.add(it.getName())); + allParameters(reactor).forEach(it -> vars.add(it.getName())); + allInputs(reactor).forEach(it -> vars.add(it.getName())); + allOutputs(reactor).forEach(it -> vars.add(it.getName())); + allStateVars(reactor).forEach(it -> vars.add(it.getName())); + allInstantiations(reactor).forEach(it -> vars.add(it.getName())); + + int index = 0; + String suffix = ""; + boolean exists = true; + while (exists) { + String id = name + suffix; + if (IterableExtensions.exists(vars, it -> it.equals(id))) { + suffix = "_" + index; + index++; + } else { + exists = false; + } + } + return name + suffix; + } + + //////////////////////////////// + //// Utility functions for supporting inheritance and modes + + /** + * Given a reactor class, return a list of all its actions, + * which includes actions of base classes that it extends. + * This also includes actions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allActions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); + } + + /** + * Given a reactor class, return a list of all its connections, + * which includes connections of base classes that it extends. + * This also includes connections in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allConnections(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); + } + + /** + * Given a reactor class, return a list of all its inputs, + * which includes inputs of base classes that it extends. + * If the base classes include a cycle, where X extends Y and Y extends X, + * then return only the input defined in the base class. + * The returned list may be empty. + * @param definition Reactor class definition. + */ + public static List allInputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); + } + + /** A list of all ports of {@code definition}, in an unspecified order. */ + public static List allPorts(Reactor definition) { + return Stream.concat(ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()).toList(); + } + + /** + * Given a reactor class, return a list of all its instantiations, + * which includes instantiations of base classes that it extends. + * This also includes instantiations in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allInstantiations(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); + } + + public static Stream allNestedClasses(Reactor definition) { + return new HashSet<>(ASTUtils.allInstantiations(definition)).stream() + .map(Instantiation::getReactorClass) + .map(ASTUtils::toDefinition); + } + + /** + * Given a reactor class, return a list of all its methods, + * which includes methods of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allMethods(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); + } + + /** + * Given a reactor class, return a list of all its outputs, + * which includes outputs of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allOutputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); + } + + /** + * Given a reactor class, return a list of all its parameters, + * which includes parameters of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allParameters(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); + } + + /** + * Given a reactor class, return a list of all its reactions, + * which includes reactions of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allReactions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); + } + + /** + * Given a reactor class, return a list of all its watchdogs. + * + * @param definition Reactor class definition + * @return List + */ + public static List allWatchdogs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); + } + + /** + * Given a reactor class, return a list of all its state variables, + * which includes state variables of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allStateVars(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); + } + + /** + * Given a reactor class, return a list of all its timers, + * which includes timers of base classes that it extends. + * This also includes reactions in modes, returning a flattened + * view over all modes. + * @param definition Reactor class definition. + */ + public static List allTimers(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); + } + + /** + * Given a reactor class, returns a list of all its modes, + * which includes modes of base classes that it extends. + * @param definition Reactor class definition. + */ + public static List allModes(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); + } + + /** A list of all reactors instantiated, transitively or intransitively, by {@code r}. */ + public static List recursiveChildren(ReactorInstance r) { + List ret = new ArrayList<>(); + ret.add(r.reactorDefinition); + for (var child : r.children) { + ret.addAll(recursiveChildren(child)); + } + return ret; + } + + /** + * Return all the superclasses of the specified reactor + * in deepest-first order. For example, if A extends B and C, and + * B and C both extend D, this will return the list [D, B, C, A]. + * Duplicates are removed. If the specified reactor does not extend + * any other reactor, then return an empty list. + * If a cycle is found, where X extends Y and Y extends X, or if + * a superclass is declared that is not found, then return null. + * @param reactor The specified reactor. + */ + public static LinkedHashSet superClasses(Reactor reactor) { + return superClasses(reactor, new LinkedHashSet<>()); + } - // Handle conflicting writers - for (var key : allWriters.keySet()) { - var writers = allWriters.get(key); - if (writers.size() > 1) { // has multiple sources - var writerModes = HashMultimap.create(); - // find modes - for (var writer : writers) { - if (writer.eContainer() instanceof Mode) { - writerModes.put((Mode) writer.eContainer(), writer); - } else { - writerModes.put(null, writer); - } + /** + * Collect elements of type T from the class hierarchy and modes + * defined by a given reactor definition. + * @param definition The reactor definition. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + public static List collectElements(Reactor definition, EStructuralFeature feature) { + return ASTUtils.collectElements(definition, feature, true, true); + } + + /** + * Collect elements of type T contained in given reactor definition, including + * modes and the class hierarchy defined depending on configuration. + * @param definition The reactor definition. + * @param feature The structual model elements to collect. + * @param includeSuperClasses Whether to include elements in super classes. + * @param includeModes Whether to include elements in modes. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + @SuppressWarnings("unchecked") + public static List collectElements(Reactor definition, EStructuralFeature feature, boolean includeSuperClasses, boolean includeModes) { + List result = new ArrayList<>(); + + if (includeSuperClasses) { + // Add elements of elements defined in superclasses. + LinkedHashSet s = superClasses(definition); + if (s != null) { + for (Reactor superClass : s) { + result.addAll((EList) superClass.eGet(feature)); + } } - // Conflicting connection can only be handled if.. - if (!writerModes.containsKey(null) - && // no writer is on root level (outside of modes) and... - writerModes.keySet().stream() - .map(writerModes::get) - .allMatch( - writersInMode -> // all writers in a mode are either... - writersInMode.size() == 1 - || // the only writer or... - writersInMode.stream() - .allMatch( - w -> - w - instanceof - Reaction) // all are reactions and hence ordered - )) { - // Add connections to transform list - writers.stream() - .filter(w -> w instanceof Connection) - .forEach(c -> transform.add((Connection) c)); + } + + // Add elements of the current reactor. + result.addAll((EList) definition.eGet(feature)); + + if (includeModes && reactorModeFeatureMap.containsKey(feature)) { + var modeFeature = reactorModeFeatureMap.get(feature); + // Add elements of elements defined in modes. + for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { + insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); } - } } - } - } - - return transform; - } - - /** - * Return the enclosing reactor of an LF EObject in a reactor or mode. - * - * @param obj the LF model element - * @return the reactor or null - */ - public static Reactor getEnclosingReactor(EObject obj) { - if (obj.eContainer() instanceof Reactor) { - return (Reactor) obj.eContainer(); - } else if (obj.eContainer() instanceof Mode) { - return (Reactor) obj.eContainer().eContainer(); - } - return null; - } - - /** Return the main reactor in the given resource if there is one, null otherwise. */ - public static Reactor findMainReactor(Resource resource) { - return IteratorExtensions.findFirst( - Iterators.filter(resource.getAllContents(), Reactor.class), Reactor::isMain); - } - - /** - * Find the main reactor and change it to a federated reactor. Return true if the transformation - * was successful (or the given resource already had a federated reactor); return false otherwise. - */ - public static boolean makeFederated(Resource resource) { - // Find the main reactor - Reactor r = findMainReactor(resource); - if (r == null) { - return false; - } - r.setMain(false); - r.setFederated(true); - return true; - } - - /** Change the target name to 'newTargetName'. For example, change C to CCpp. */ - public static boolean changeTargetName(Resource resource, String newTargetName) { - targetDecl(resource).setName(newTargetName); - return true; - } - - /** Return the target of the file in which the given node lives. */ - public static Target getTarget(EObject object) { - TargetDecl targetDecl = targetDecl(object.eResource()); - return Target.fromDecl(targetDecl); - } - - /** - * Add a new target property to the given resource. - * - *

This also creates a config object if the resource does not yey have one. - * - * @param resource The resource to modify - * @param name Name of the property to add - * @param value Value to be assigned to the property - */ - public static boolean addTargetProperty( - final Resource resource, final String name, final Element value) { - var config = targetDecl(resource).getConfig(); - if (config == null) { - config = LfFactory.eINSTANCE.createKeyValuePairs(); - targetDecl(resource).setConfig(config); - } - final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); - newProperty.setName(name); - newProperty.setValue(value); - config.getPairs().add(newProperty); - return true; - } - - /** - * Return true if the connection involves multiple ports on the left or right side of the - * connection, or if the port on the left or right of the connection involves a bank of reactors - * or a multiport. - * - * @param connection The connection. - */ - public static boolean hasMultipleConnections(Connection connection) { - if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { - return true; - } - VarRef leftPort = connection.getLeftPorts().get(0); - VarRef rightPort = connection.getRightPorts().get(0); - Instantiation leftContainer = leftPort.getContainer(); - Instantiation rightContainer = rightPort.getContainer(); - Port leftPortAsPort = (Port) leftPort.getVariable(); - Port rightPortAsPort = (Port) rightPort.getVariable(); - return leftPortAsPort.getWidthSpec() != null - || leftContainer != null && leftContainer.getWidthSpec() != null - || rightPortAsPort.getWidthSpec() != null - || rightContainer != null && rightContainer.getWidthSpec() != null; - } - - /** - * Produce a unique identifier within a reactor based on a given based name. If the name does not - * exists, it is returned; if does exist, an index is appended that makes the name unique. - * - * @param reactor The reactor to find a unique identifier within. - * @param name The name to base the returned identifier on. - */ - public static String getUniqueIdentifier(Reactor reactor, String name) { - LinkedHashSet vars = new LinkedHashSet<>(); - allActions(reactor).forEach(it -> vars.add(it.getName())); - allTimers(reactor).forEach(it -> vars.add(it.getName())); - allParameters(reactor).forEach(it -> vars.add(it.getName())); - allInputs(reactor).forEach(it -> vars.add(it.getName())); - allOutputs(reactor).forEach(it -> vars.add(it.getName())); - allStateVars(reactor).forEach(it -> vars.add(it.getName())); - allInstantiations(reactor).forEach(it -> vars.add(it.getName())); - - int index = 0; - String suffix = ""; - boolean exists = true; - while (exists) { - String id = name + suffix; - if (IterableExtensions.exists(vars, it -> it.equals(id))) { - suffix = "_" + index; - index++; - } else { - exists = false; - } - } - return name + suffix; - } - - //////////////////////////////// - //// Utility functions for supporting inheritance and modes - - /** - * Given a reactor class, return a list of all its actions, which includes actions of base classes - * that it extends. This also includes actions in modes, returning a flattened view over all - * modes. - * - * @param definition Reactor class definition. - */ - public static List allActions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); - } - - /** - * Given a reactor class, return a list of all its connections, which includes connections of base - * classes that it extends. This also includes connections in modes, returning a flattened view - * over all modes. - * - * @param definition Reactor class definition. - */ - public static List allConnections(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); - } - - /** - * Given a reactor class, return a list of all its inputs, which includes inputs of base classes - * that it extends. If the base classes include a cycle, where X extends Y and Y extends X, then - * return only the input defined in the base class. The returned list may be empty. - * - * @param definition Reactor class definition. - */ - public static List allInputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); - } - - /** A list of all ports of {@code definition}, in an unspecified order. */ - public static List allPorts(Reactor definition) { - return Stream.concat( - ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()) - .toList(); - } - - /** - * Given a reactor class, return a list of all its instantiations, which includes instantiations - * of base classes that it extends. This also includes instantiations in modes, returning a - * flattened view over all modes. - * - * @param definition Reactor class definition. - */ - public static List allInstantiations(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); - } - - public static Stream allNestedClasses(Reactor definition) { - return new HashSet<>(ASTUtils.allInstantiations(definition)) - .stream().map(Instantiation::getReactorClass).map(ASTUtils::toDefinition); - } - - /** - * Given a reactor class, return a list of all its methods, which includes methods of base classes - * that it extends. - * - * @param definition Reactor class definition. - */ - public static List allMethods(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); - } - - /** - * Given a reactor class, return a list of all its outputs, which includes outputs of base classes - * that it extends. - * - * @param definition Reactor class definition. - */ - public static List allOutputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); - } - - /** - * Given a reactor class, return a list of all its parameters, which includes parameters of base - * classes that it extends. - * - * @param definition Reactor class definition. - */ - public static List allParameters(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); - } - - /** - * Given a reactor class, return a list of all its reactions, which includes reactions of base - * classes that it extends. This also includes reactions in modes, returning a flattened view over - * all modes. - * - * @param definition Reactor class definition. - */ - public static List allReactions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); - } - - /** - * Given a reactor class, return a list of all its watchdogs. - * - * @param definition Reactor class definition - * @return List - */ - public static List allWatchdogs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); - } - - /** - * Given a reactor class, return a list of all its state variables, which includes state variables - * of base classes that it extends. This also includes reactions in modes, returning a flattened - * view over all modes. - * - * @param definition Reactor class definition. - */ - public static List allStateVars(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); - } - - /** - * Given a reactor class, return a list of all its timers, which includes timers of base classes - * that it extends. This also includes reactions in modes, returning a flattened view over all - * modes. - * - * @param definition Reactor class definition. - */ - public static List allTimers(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); - } - - /** - * Given a reactor class, returns a list of all its modes, which includes modes of base classes - * that it extends. - * - * @param definition Reactor class definition. - */ - public static List allModes(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); - } - - /** A list of all reactors instantiated, transitively or intransitively, by {@code r}. */ - public static List recursiveChildren(ReactorInstance r) { - List ret = new ArrayList<>(); - ret.add(r.reactorDefinition); - for (var child : r.children) { - ret.addAll(recursiveChildren(child)); - } - return ret; - } - - /** - * Return all the superclasses of the specified reactor in deepest-first order. For example, if A - * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates - * are removed. If the specified reactor does not extend any other reactor, then return an empty - * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared - * that is not found, then return null. - * - * @param reactor The specified reactor. - */ - public static LinkedHashSet superClasses(Reactor reactor) { - return superClasses(reactor, new LinkedHashSet<>()); - } - - /** - * Collect elements of type T from the class hierarchy and modes defined by a given reactor - * definition. - * - * @param definition The reactor definition. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - public static List collectElements( - Reactor definition, EStructuralFeature feature) { - return ASTUtils.collectElements(definition, feature, true, true); - } - - /** - * Collect elements of type T contained in given reactor definition, including modes and the class - * hierarchy defined depending on configuration. - * - * @param definition The reactor definition. - * @param feature The structual model elements to collect. - * @param includeSuperClasses Whether to include elements in super classes. - * @param includeModes Whether to include elements in modes. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - @SuppressWarnings("unchecked") - public static List collectElements( - Reactor definition, - EStructuralFeature feature, - boolean includeSuperClasses, - boolean includeModes) { - List result = new ArrayList<>(); - - if (includeSuperClasses) { - // Add elements of elements defined in superclasses. - LinkedHashSet s = superClasses(definition); - if (s != null) { - for (Reactor superClass : s) { - result.addAll((EList) superClass.eGet(feature)); + + return result; + } + + /** + * Adds the elements into the given list at a location matching to their textual position. + * + * When creating a flat view onto reactor elements including modes, the final list must be ordered according + * to the textual positions. + * + * Example: + * reactor R { + * reaction // -> is R.reactions[0] + * mode M { + * reaction // -> is R.mode[0].reactions[0] + * reaction // -> is R.mode[0].reactions[1] + * } + * reaction // -> is R.reactions[1] + * } + * In this example, it is important that the reactions in the mode are inserted between the top-level + * reactions to retain the correct global reaction ordering, which will be derived from this flattened view. + * + * @param list The list to add the elements into. + * @param elements The elements to add. + * @param mode The mode containing the elements. + * @param The type of elements to add (e.g., Port, Timer, etc.) + */ + private static void insertModeElementsAtTextualPosition(List list, List elements, Mode mode) { + if (elements.isEmpty()) { + return; // Nothing to add } - } - } - - // Add elements of the current reactor. - result.addAll((EList) definition.eGet(feature)); - - if (includeModes && reactorModeFeatureMap.containsKey(feature)) { - var modeFeature = reactorModeFeatureMap.get(feature); - // Add elements of elements defined in modes. - for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { - insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); - } - } - - return result; - } - - /** - * Adds the elements into the given list at a location matching to their textual position. - * - *

When creating a flat view onto reactor elements including modes, the final list must be - * ordered according to the textual positions. - * - *

Example: reactor R { reaction // -> is R.reactions[0] mode M { reaction // -> is - * R.mode[0].reactions[0] reaction // -> is R.mode[0].reactions[1] } reaction // -> is - * R.reactions[1] } In this example, it is important that the reactions in the mode are inserted - * between the top-level reactions to retain the correct global reaction ordering, which will be - * derived from this flattened view. - * - * @param list The list to add the elements into. - * @param elements The elements to add. - * @param mode The mode containing the elements. - * @param The type of elements to add (e.g., Port, Timer, etc.) - */ - private static void insertModeElementsAtTextualPosition( - List list, List elements, Mode mode) { - if (elements.isEmpty()) { - return; // Nothing to add - } - - var idx = list.size(); - if (idx > 0) { - // If there are elements in the list, first check if the last element has the same container - // as the mode. - // I.e. we don't want to compare textual positions of different reactors (super classes) - if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { - var modeAstNode = NodeModelUtils.getNode(mode); - if (modeAstNode != null) { - var modePos = modeAstNode.getOffset(); - // Now move the insertion index from the last element forward as long as this element has - // a textual - // position after the mode. - do { - var astNode = NodeModelUtils.getNode(list.get(idx - 1)); - if (astNode != null && astNode.getOffset() > modePos) { - idx--; - } else { - break; // Insertion index is ok. + + var idx = list.size(); + if (idx > 0) { + // If there are elements in the list, first check if the last element has the same container as the mode. + // I.e. we don't want to compare textual positions of different reactors (super classes) + if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { + var modeAstNode = NodeModelUtils.getNode(mode); + if (modeAstNode != null) { + var modePos = modeAstNode.getOffset(); + // Now move the insertion index from the last element forward as long as this element has a textual + // position after the mode. + do { + var astNode = NodeModelUtils.getNode(list.get(idx - 1)); + if (astNode != null && astNode.getOffset() > modePos) { + idx--; + } else { + break; // Insertion index is ok. + } + } while (idx > 0); + } } - } while (idx > 0); } - } - } - list.addAll(idx, elements); - } - - public static Iterable allElementsOfClass( - Resource resource, Class elementClass) { - //noinspection StaticPseudoFunctionalStyleMethod - return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); - } - - //////////////////////////////// - //// Utility functions for translating AST nodes into text - - /** - * Translate the given code into its textual representation with {@code CodeMap.Correspondence} - * tags inserted, or return the empty string if {@code node} is {@code null}. This method should - * be used to generate code. - * - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toText(EObject node) { - if (node == null) return ""; - return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); - } - - /** - * Translate the given code into its textual representation without {@code CodeMap.Correspondence} - * tags, or return the empty string if {@code node} is {@code null}. This method should be used - * for analyzing AST nodes in cases where they are easiest to analyze as strings. - * - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toOriginalText(EObject node) { - if (node == null) return ""; - return ToText.instance.doSwitch(node); - } - - /** - * Return an integer representation of the given element. - * - *

Internally, this method uses Integer.decode, so it will also understand hexadecimal, binary, - * etc. - * - * @param e The element to be rendered as an integer. - */ - public static Integer toInteger(Element e) { - return Integer.decode(e.getLiteral()); - } - - /** - * Return a time value based on the given element. - * - * @param e The element to be rendered as a time value. - */ - public static TimeValue toTimeValue(Element e) { - return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); - } - - /** Returns the time value represented by the given AST node. */ - public static TimeValue toTimeValue(Time e) { - if (!isValidTime(e)) { - // invalid unit, will have been reported by validator - throw new IllegalArgumentException(); - } - return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); - } - - /** - * Return a boolean based on the given element. - * - * @param e The element to be rendered as a boolean. - */ - public static boolean toBoolean(Element e) { - return elementToSingleString(e).equalsIgnoreCase("true"); - } - - /** - * Given the right-hand side of a target property, return a string that represents the given - * value/ - * - *

If the given value is not a literal or and id (but for instance and array or dict), an empty - * string is returned. If the element is a string, any quotes are removed. - * - * @param e The right-hand side of a target property. - */ - public static String elementToSingleString(Element e) { - if (e.getLiteral() != null) { - return StringUtil.removeQuotes(e.getLiteral()).trim(); - } else if (e.getId() != null) { - return e.getId(); - } - return ""; - } - - /** - * Given the right-hand side of a target property, return a list with all the strings that the - * property lists. - * - *

Arrays are traversed, so strings are collected recursively. Empty strings are ignored; they - * are not added to the list. - * - * @param value The right-hand side of a target property. - */ - public static List elementToListOfStrings(Element value) { - List elements = new ArrayList<>(); - if (value.getArray() != null) { - for (Element element : value.getArray().getElements()) { - elements.addAll(elementToListOfStrings(element)); - } - return elements; - } else { - String v = elementToSingleString(value); - if (!v.isEmpty()) { - elements.add(v); - } - } - return elements; - } - - /** - * Convert key-value pairs in an Element to a map, assuming that both the key and the value are - * strings. - */ - public static Map elementToStringMaps(Element value) { - Map elements = new HashMap<>(); - for (var element : value.getKeyvalue().getPairs()) { - elements.put( - element.getName().trim(), - StringUtil.removeQuotes(elementToSingleString(element.getValue()))); - } - return elements; - } - - // Various utility methods to convert various data types to Elements - - /** Convert a map to key-value pairs in an Element. */ - public static Element toElement(Map map) { - Element e = LfFactory.eINSTANCE.createElement(); - if (map.size() == 0) return null; - else { - var kv = LfFactory.eINSTANCE.createKeyValuePairs(); - for (var entry : map.entrySet()) { - var pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(entry.getKey()); - var element = LfFactory.eINSTANCE.createElement(); - element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); - pair.setValue(element); - kv.getPairs().add(pair); - } - e.setKeyvalue(kv); - } - - return e; - } - - /** - * Given a single string, convert it into its AST representation. {@code addQuotes} controls if - * the generated representation should be accompanied by double quotes ("") or not. - */ - private static Element toElement(String str, boolean addQuotes) { - if (str == null) return null; - var strToReturn = addQuotes ? StringUtil.addDoubleQuotes(str) : str; - Element e = LfFactory.eINSTANCE.createElement(); - e.setLiteral(strToReturn); - return e; - } - - /** Given a single string, convert it into its AST representation. */ - public static Element toElement(String str) { - return toElement(str, true); - } - - /** - * Given a list of strings, convert it into its AST representation. Stores the list in the Array - * field of the element, unless the list only has one string, in which case it is stored in the - * Literal field. Returns null if the provided list is empty. - */ - public static Element toElement(List list) { - Element e = LfFactory.eINSTANCE.createElement(); - if (list.size() == 0) return null; - else if (list.size() == 1) { - return toElement(list.get(0)); - } else { - var arr = LfFactory.eINSTANCE.createArray(); - for (String s : list) { - arr.getElements().add(ASTUtils.toElement(s)); - } - e.setArray(arr); - } - return e; - } - - /** - * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit - * inside an Element. - */ - public static Element toElement(TimeValue tv) { - Element e = LfFactory.eINSTANCE.createElement(); - e.setTime((int) tv.time); - if (tv.unit != null) { - e.setUnit(tv.unit.toString()); - } - return e; - } - - public static Element toElement(boolean val) { - return toElement(Boolean.toString(val), false); - } - - public static Element toElement(int val) { - return toElement(Integer.toString(val), false); - } - - /** - * Translate the given type into its textual representation, but do not append any array - * specifications or type arguments. - * - * @param type AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String baseType(Type type) { - if (type != null) { - if (type.getCode() != null) { - return toText(type.getCode()); - } else { - if (type.isTime()) { - return "time"; + list.addAll(idx, elements); + } + + public static Iterable allElementsOfClass( + Resource resource, + Class elementClass + ) { + //noinspection StaticPseudoFunctionalStyleMethod + return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); + } + + //////////////////////////////// + //// Utility functions for translating AST nodes into text + + /** + * Translate the given code into its textual representation + * with {@code CodeMap.Correspondence} tags inserted, or + * return the empty string if {@code node} is {@code null}. + * This method should be used to generate code. + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toText(EObject node) { + if (node == null) return ""; + return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); + } + + /** + * Translate the given code into its textual representation + * without {@code CodeMap.Correspondence} tags, or return + * the empty string if {@code node} is {@code null}. + * This method should be used for analyzing AST nodes in + * cases where they are easiest to analyze as strings. + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toOriginalText(EObject node) { + if (node == null) return ""; + return ToText.instance.doSwitch(node); + } + + /** + * Return an integer representation of the given element. + * + * Internally, this method uses Integer.decode, so it will + * also understand hexadecimal, binary, etc. + * + * @param e The element to be rendered as an integer. + */ + public static Integer toInteger(Element e) { + return Integer.decode(e.getLiteral()); + } + + /** + * Return a time value based on the given element. + * + * @param e The element to be rendered as a time value. + */ + public static TimeValue toTimeValue(Element e) { + return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); + } + + /** + * Returns the time value represented by the given AST node. + */ + public static TimeValue toTimeValue(Time e) { + if (!isValidTime(e)) { + // invalid unit, will have been reported by validator + throw new IllegalArgumentException(); + } + return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); + } + + /** + * Return a boolean based on the given element. + * + * @param e The element to be rendered as a boolean. + */ + public static boolean toBoolean(Element e) { + return elementToSingleString(e).equalsIgnoreCase("true"); + } + + /** + * Given the right-hand side of a target property, return a string that + * represents the given value/ + * + * If the given value is not a literal or and id (but for instance and array or dict), + * an empty string is returned. If the element is a string, any quotes are removed. + * + * @param e The right-hand side of a target property. + */ + public static String elementToSingleString(Element e) { + if (e.getLiteral() != null) { + return StringUtil.removeQuotes(e.getLiteral()).trim(); + } else if (e.getId() != null) { + return e.getId(); + } + return ""; + } + + /** + * Given the right-hand side of a target property, return a list with all + * the strings that the property lists. + * + * Arrays are traversed, so strings are collected recursively. Empty strings + * are ignored; they are not added to the list. + * @param value The right-hand side of a target property. + */ + public static List elementToListOfStrings(Element value) { + List elements = new ArrayList<>(); + if (value.getArray() != null) { + for (Element element : value.getArray().getElements()) { + elements.addAll(elementToListOfStrings(element)); + } + return elements; } else { - StringBuilder result = new StringBuilder(type.getId()); + String v = elementToSingleString(value); + if (!v.isEmpty()) { + elements.add(v); + } + } + return elements; + } - for (String s : convertToEmptyListIfNull(type.getStars())) { - result.append(s); - } - return result.toString(); + /** + * Convert key-value pairs in an Element to a map, assuming that both the key + * and the value are strings. + */ + public static Map elementToStringMaps(Element value) { + Map elements = new HashMap<>(); + for (var element: value.getKeyvalue().getPairs()) { + elements.put( + element.getName().trim(), + StringUtil.removeQuotes(elementToSingleString(element.getValue())) + ); } - } - } - return ""; - } - - /** - * Report whether the given literal is zero or not. - * - * @param literal AST node to inspect. - * @return True if the given literal denotes the constant `0`, false otherwise. - */ - public static boolean isZero(String literal) { - try { - if (literal != null && Integer.parseInt(literal) == 0) { - return true; - } - } catch (NumberFormatException e) { - // Not an int. - } - return false; - } - - /** - * Report whether the given expression is zero or not. - * - * @param expr AST node to inspect. - * @return True if the given value denotes the constant `0`, false otherwise. - */ - public static boolean isZero(Expression expr) { - if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; - } - - /** - * Report whether the given string literal is an integer number or not. - * - * @param literal AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Integer.decode(literal); - } catch (NumberFormatException e) { - return false; - } - return true; - } - - /** - * Report whether the given string literal is a boolean value or not. - * - * @param literal AST node to inspect. - * @return True if the given value is a boolean, false otherwise. - */ - public static boolean isBoolean(String literal) { - return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); - } - - /** - * Report whether the given string literal is a float value or not. - * - * @param literal AST node to inspect. - * @return True if the given value is a float, false otherwise. - */ - public static boolean isFloat(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Float.parseFloat(literal); - } catch (NumberFormatException e) { - return false; - } - return true; - } - - /** - * Report whether the given code is an integer number or not. - * - * @param code AST node to inspect. - * @return True if the given code is an integer, false otherwise. - */ - public static boolean isInteger(Code code) { - return isInteger(toText(code)); - } - - /** - * Report whether the given expression is an integer number or not. - * - * @param expr AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(Expression expr) { - if (expr instanceof Literal) { - return isInteger(((Literal) expr).getLiteral()); - } else if (expr instanceof Code) { - return isInteger((Code) expr); - } - return false; - } - - /** - * Report whether the given expression denotes a valid time or not. - * - * @param expr AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Expression expr) { - if (expr instanceof ParameterReference) { - return isOfTimeType(((ParameterReference) expr).getParameter()); - } else if (expr instanceof Time) { - return isValidTime((Time) expr); - } else if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; - } - - /** - * Report whether the given time denotes a valid time or not. - * - * @param t AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Time t) { - if (t == null) return false; - String unit = t.getUnit(); - return t.getInterval() == 0 || TimeUnit.isValidUnit(unit); - } - - /** If the initializer contains exactly one expression, return it. Otherwise, return null. */ - public static Expression asSingleExpr(Initializer init) { - if (init == null) { - return null; - } - var exprs = init.getExprs(); - return exprs.size() == 1 ? exprs.get(0) : null; - } - - public static boolean isSingleExpr(Initializer init) { - // todo expand that to = initialization - if (init == null) { - return false; - } - var exprs = init.getExprs(); - return exprs.size() == 1; - } - - public static boolean isListInitializer(Initializer init) { - return init != null && !isSingleExpr(init); - } - - /** - * Return the type of a declaration with the given (nullable) explicit type, and the given - * (nullable) initializer. If the explicit type is null, then the type is inferred from the - * initializer. Only two types can be inferred: "time" and "timeList". Return the "undefined" type - * if neither can be inferred. - * - * @param type Explicit type declared on the declaration - * @param init The initializer expression - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Type type, Initializer init) { - if (type != null) { - return InferredType.fromAST(type); - } else if (init == null) { - return InferredType.undefined(); - } - - var single = asSingleExpr(init); - if (single != null) { - // If there is a single element in the list, and it is a proper - // time value with units, we infer the type "time". - if (single instanceof ParameterReference) { - return getInferredType(((ParameterReference) single).getParameter()); - } else if (single instanceof Time) { - return InferredType.time(); - } - } else if (init.getExprs().size() > 1) { - // If there are multiple elements in the list, and there is at - // least one proper time value with units, and all other elements - // are valid times (including zero without units), we infer the - // type "time list". - var allValidTime = true; - var foundNonZero = false; - - for (var e : init.getExprs()) { - if (!ASTUtils.isValidTime(e)) { - allValidTime = false; + return elements; + } + + // Various utility methods to convert various data types to Elements + + /** + * Convert a map to key-value pairs in an Element. + */ + public static Element toElement(Map map) { + Element e = LfFactory.eINSTANCE.createElement(); + if (map.size() == 0) return null; + else { + var kv = LfFactory.eINSTANCE.createKeyValuePairs(); + for (var entry : map.entrySet()) { + var pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(entry.getKey()); + var element = LfFactory.eINSTANCE.createElement(); + element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); + pair.setValue(element); + kv.getPairs().add(pair); + } + e.setKeyvalue(kv); } - if (!ASTUtils.isZero(e)) { - foundNonZero = true; + + return e; + } + + /** + * Given a single string, convert it into its AST representation. + * {@code addQuotes} controls if the generated representation should be + * accompanied by double quotes ("") or not. + */ + private static Element toElement(String str, boolean addQuotes) { + if (str == null) return null; + var strToReturn = addQuotes? StringUtil.addDoubleQuotes(str):str; + Element e = LfFactory.eINSTANCE.createElement(); + e.setLiteral(strToReturn); + return e; + } + + /** + * Given a single string, convert it into its AST representation. + */ + public static Element toElement(String str) { + return toElement(str, true); + } + + /** + * Given a list of strings, convert it into its AST representation. + * Stores the list in the Array field of the element, unless the list only has one string, + * in which case it is stored in the Literal field. Returns null if the provided list is empty. + */ + public static Element toElement(List list) { + Element e = LfFactory.eINSTANCE.createElement(); + if (list.size() == 0) return null; + else if (list.size() == 1) { + return toElement(list.get(0)); + } else { + var arr = LfFactory.eINSTANCE.createArray(); + for (String s : list) { + arr.getElements().add(ASTUtils.toElement(s)); + } + e.setArray(arr); } - } - - if (allValidTime && foundNonZero) { - // Conservatively, no bounds are inferred; the returned type - // is a variable-size list. - return InferredType.timeList(); - } - } - return InferredType.undefined(); - } - - /** - * Given a parameter, return an inferred type. Only two types can be inferred: "time" and - * "timeList". Return the "undefined" type if neither can be inferred. - * - * @param p A parameter to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Parameter p) { - return getInferredType(p.getType(), p.getInit()); - } - - /** - * Given a state variable, return an inferred type. Only two types can be inferred: "time" and - * "timeList". Return the "undefined" type if neither can be inferred. - * - * @param s A state variable to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(StateVar s) { - return getInferredType(s.getType(), s.getInit()); - } - - /** - * Construct an inferred type from an "action" AST node based on its declared type. If no type is - * declared, return the "undefined" type. - * - * @param a An action to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Action a) { - return getInferredType(a.getType(), null); - } - - /** - * Construct an inferred type from a "port" AST node based on its declared type. If no type is - * declared, return the "undefined" type. - * - * @param p A port to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Port p) { - return getInferredType(p.getType(), null); - } - - /** - * If the given string can be recognized as a floating-point number that has a leading decimal - * point, prepend the string with a zero and return it. Otherwise, return the original string. - * - * @param literal A string might be recognizable as a floating point number with a leading decimal - * point. - * @return an equivalent representation of literal - * - */ - public static String addZeroToLeadingDot(String literal) { - Matcher m = ABBREVIATED_FLOAT.matcher(literal); - if (m.matches()) { - return literal.replace(".", "0."); - } - return literal; - } - - /** - * Return true if the specified port is a multiport. - * - * @param port The port. - * @return True if the port is a multiport. - */ - public static boolean isMultiport(Port port) { - return port.getWidthSpec() != null; - } - - //////////////////////////////// - //// Utility functions for translating AST nodes into text - // This is a continuation of a large section of ASTUtils.xtend - // with the same name. - - /** - * Generate code for referencing a port, action, or timer. - * - * @param reference The reference to the variable. - */ - public static String generateVarRef(VarRef reference) { - var prefix = ""; - if (reference.getContainer() != null) { - prefix = reference.getContainer().getName() + "."; - } - return prefix + reference.getVariable().getName(); - } - - /** Assuming that the given expression denotes a valid time literal, return a time value. */ - public static TimeValue getLiteralTimeValue(Expression expr) { - if (expr instanceof Time) { - return toTimeValue((Time) expr); - } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { - return TimeValue.ZERO; - } else { - return null; - } - } - - /** If the parameter is of time type, return its default value. Otherwise, return null. */ - public static TimeValue getDefaultAsTimeValue(Parameter p) { - if (isOfTimeType(p)) { - var init = asSingleExpr(p.getInit()); - if (init != null) { - return getLiteralTimeValue(init); - } - } - return null; - } - - /** Return whether the given state variable is inferred to a time type. */ - public static boolean isOfTimeType(StateVar state) { - InferredType t = getInferredType(state); - return t.isTime && !t.isList; - } - - /** Return whether the given parameter is inferred to a time type. */ - public static boolean isOfTimeType(Parameter param) { - InferredType t = getInferredType(param); - return t.isTime && !t.isList; - } - - /** - * Given a parameter, return its initial value. The initial value is a list of instances of - * Expressions. - * - *

If the instantiations argument is null or an empty list, then the value returned is simply - * the default value given when the parameter is defined. - * - *

If a list of instantiations is given, then the first instantiation is required to be an - * instantiation of the reactor class that is parameterized by the parameter. I.e., ``` - * parameter.eContainer == instantiations.get(0).reactorClass ``` If a second instantiation is - * given, then it is required to be an instantiation of a reactor class that contains the first - * instantiation. That is, ``` instantiations.get(0).eContainer == - * instantiations.get(1).reactorClass ``` More generally, for all 0 <= i < instantiations.size - - * 1, ``` instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass ``` If any of - * these conditions is not satisfied, then an IllegalArgumentException will be thrown. - * - *

Note that this chain of reactions cannot be inferred from the parameter because in each of - * the predicates above, there may be more than one instantiation that can appear on the right - * hand side of the predicate. - * - *

For example, consider the following program: ``` reactor A(x:int(1)) {} reactor B(y:int(2)) - * { a1 = new A(x = y); a2 = new A(x = -1); } reactor C(z:int(3)) { b1 = new B(y = z); b2 = new - * B(y = -2); } ``` Notice that there are a total of four instances of reactor class A. Then ``` - * initialValue(x, null) returns 1 initialValue(x, [a1]) returns 2 initialValue(x, [a2]) returns - * -1 initialValue(x, [a1, b1]) returns 3 initialValue(x, [a2, b1]) returns -1 initialValue(x, - * [a1, b2]) returns -2 initialValue(x, [a2, b2]) returns -1 ``` (Actually, in each of the above - * cases, the returned value is a list with one entry, a Literal, e.g. ["1"]). - * - *

There are two instances of reactor class B. ``` initialValue(y, null) returns 2 - * initialValue(y, [a1]) throws an IllegalArgumentException initialValue(y, [b1]) returns 3 - * initialValue(y, [b2]) returns -2 ``` - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * @return The value of the parameter. - * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the - * reactor class that is parameterized by the respective parameter or if the chain of - * instantiations is not nested. - */ - public static List initialValue( - Parameter parameter, List instantiations) { - // If instantiations are given, then check to see whether this parameter gets overridden in - // the first of those instantiations. - if (instantiations != null && instantiations.size() > 0) { - // Check to be sure that the instantiation is in fact an instantiation - // of the reactor class for which this is a parameter. - Instantiation instantiation = instantiations.get(0); - - if (!belongsTo(parameter, instantiation)) { - throw new IllegalArgumentException( - "Parameter " - + parameter.getName() - + " is not a parameter of reactor instance " - + instantiation.getName() - + "."); - } - // In case there is more than one assignment to this parameter, we need to - // find the last one. - Assignment lastAssignment = null; - for (Assignment assignment : instantiation.getParameters()) { - if (assignment.getLhs().equals(parameter)) { - lastAssignment = assignment; + return e; + } + + /** + * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit inside an Element. + */ + public static Element toElement(TimeValue tv) { + Element e = LfFactory.eINSTANCE.createElement(); + e.setTime((int)tv.time); + if (tv.unit != null) { + e.setUnit(tv.unit.toString()); } - } - if (lastAssignment != null) { - // Right hand side can be a list. Collect the entries. - List result = new ArrayList<>(); - for (Expression expr : lastAssignment.getRhs().getExprs()) { - if (expr instanceof ParameterReference) { - if (instantiations.size() > 1 - && instantiation.eContainer() != instantiations.get(1).getReactorClass()) { - throw new IllegalArgumentException( - "Reactor instance " - + instantiation.getName() - + " is not contained by instance " - + instantiations.get(1).getName() - + "."); + return e; + } + + public static Element toElement(boolean val) { + return toElement(Boolean.toString(val), false); + } + + public static Element toElement(int val) { + return toElement(Integer.toString(val), false); + } + + /** + * Translate the given type into its textual representation, but + * do not append any array specifications or type arguments. + * @param type AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String baseType(Type type) { + if (type != null) { + if (type.getCode() != null) { + return toText(type.getCode()); + } else { + if (type.isTime()) { + return "time"; + } else { + StringBuilder result = new StringBuilder(type.getId()); + + for (String s : convertToEmptyListIfNull(type.getStars())) { + result.append(s); + } + return result.toString(); + } } - result.addAll( - initialValue( - ((ParameterReference) expr).getParameter(), - instantiations.subList(1, instantiations.size()))); - } else { - result.add(expr); - } } - return result; - } - } - // If we reach here, then either no instantiation was supplied or - // there was no assignment in the instantiation. So just use the - // parameter's initial value. - return parameter.getInit().getExprs(); - } - - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the - * specified instantiation, meaning that it is defined in the reactor class being instantiated or - * one of its base classes. - * - * @param eobject The object. - * @param instantiation The instantiation. - */ - public static boolean belongsTo(EObject eobject, Instantiation instantiation) { - Reactor reactor = toDefinition(instantiation.getReactorClass()); - return belongsTo(eobject, reactor); - } - - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the - * specified reactor, meaning that it is defined in reactor class or one of its base classes. - * - * @param eobject The object. - * @param reactor The reactor. - */ - public static boolean belongsTo(EObject eobject, Reactor reactor) { - if (eobject.eContainer() == reactor) return true; - for (ReactorDecl baseClass : reactor.getSuperClasses()) { - if (belongsTo(eobject, toDefinition(baseClass))) { + return ""; + } + + /** + * Report whether the given literal is zero or not. + * @param literal AST node to inspect. + * @return True if the given literal denotes the constant `0`, false + * otherwise. + */ + public static boolean isZero(String literal) { + try { + if (literal != null && + Integer.parseInt(literal) == 0) { + return true; + } + } catch (NumberFormatException e) { + // Not an int. + } + return false; + } + + /** + * Report whether the given expression is zero or not. + * + * @param expr AST node to inspect. + * @return True if the given value denotes the constant `0`, false otherwise. + */ + public static boolean isZero(Expression expr) { + if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; + } + + /** + * Report whether the given string literal is an integer number or not. + * + * @param literal AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Integer.decode(literal); + } catch (NumberFormatException e) { + return false; + } return true; - } - } - return false; - } - - /** - * Given a parameter return its integer value or null if it does not have an integer value. If the - * value of the parameter is a list of integers, return the sum of value in the list. The - * instantiations parameter is as in {@link #initialValue(Parameter, List)}. - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * @return The integer value of the parameter, or null if it does not have an integer value. - * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the - * reactor class that is parameterized by the respective parameter or if the chain of - * instantiations is not nested. - */ - public static Integer initialValueInt(Parameter parameter, List instantiations) { - List expressions = initialValue(parameter, instantiations); - int result = 0; - for (Expression expr : expressions) { - if (!(expr instanceof Literal)) { - return null; - } - try { - result += Integer.decode(((Literal) expr).getLiteral()); - } catch (NumberFormatException ex) { - return null; - } - } - return result; - } - - /** - * Given the width specification of port or instantiation and an (optional) list of nested - * instantiations, return the width if it can be determined and -1 if not. It will not be able to - * be determined if either the width is variable (in which case you should use {@link - * #inferPortWidth(VarRef, Connection, List)} ) or the list of instantiations is incomplete or - * missing. If there are parameter references in the width, they are evaluated to the extent - * possible given the instantiations list. - * - *

The instantiations list is as in {@link #initialValue(Parameter, List)}. If the spec belongs - * to an instantiation (for a bank of reactors), then the first element on this list should be the - * instantiation that contains this instantiation. If the spec belongs to a port, then the first - * element on the list should be the instantiation of the reactor that contains the port. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * @return The width, or -1 if the width could not be determined. - * @throws IllegalArgumentException If an instantiation provided is not as given above or if the - * chain of instantiations is not nested. - */ - public static int width(WidthSpec spec, List instantiations) { - if (spec == null) { - return 1; - } - if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { - return inferWidthFromConnections(spec, instantiations); - } - var result = 0; - for (WidthTerm term : spec.getTerms()) { - if (term.getParameter() != null) { - Integer termWidth = initialValueInt(term.getParameter(), instantiations); - if (termWidth != null) { - result += termWidth; - } else { - return -1; + } + + /** + * Report whether the given string literal is a boolean value or not. + * @param literal AST node to inspect. + * @return True if the given value is a boolean, false otherwise. + */ + public static boolean isBoolean(String literal) { + return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); + } + + /** + * Report whether the given string literal is a float value or not. + * @param literal AST node to inspect. + * @return True if the given value is a float, false otherwise. + */ + public static boolean isFloat(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Float.parseFloat(literal); + } catch (NumberFormatException e) { + return false; } - } else if (term.getWidth() > 0) { - result += term.getWidth(); - } else { - // If the width cannot be determined because term's width <= 0, which means the term's width - // must be inferred, try to infer the width using connections. - if (spec.eContainer() instanceof Instantiation) { - try { - return inferWidthFromConnections(spec, instantiations); - } catch (InvalidSourceException e) { - // If the inference fails, return -1. - return -1; - } + return true; + } + + /** + * Report whether the given code is an integer number or not. + * @param code AST node to inspect. + * @return True if the given code is an integer, false otherwise. + */ + public static boolean isInteger(Code code) { + return isInteger(toText(code)); + } + + /** + * Report whether the given expression is an integer number or not. + * @param expr AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(Expression expr) { + if (expr instanceof Literal) { + return isInteger(((Literal) expr).getLiteral()); + } else if (expr instanceof Code) { + return isInteger((Code) expr); } - } - } - return result; - } - - /** - * Infer the width of a port reference in a connection. The port reference one or two parts, a - * port and an (optional) container which is an Instantiation that may refer to a bank of - * reactors. The width will be the product of the bank width and the port width. The returned - * value will be 1 if the port is not in a bank and is not a multiport. - * - *

If the width cannot be determined, this will return -1. The width cannot be determined if - * the list of instantiations is missing or incomplete. - * - *

The instantiations list is as in {@link #initialValue(Parameter, List)}. The first element - * on this list should be the instantiation that contains the specified connection. - * - * @param reference A port reference. - * @param connection A connection, or null if not in the context of a connection. - * @param instantiations The (optional) list of instantiations. - * @return The width or -1 if it could not be determined. - * @throws IllegalArgumentException If an instantiation provided is not as given above or if the - * chain of instantiations is not nested. - */ - public static int inferPortWidth( - VarRef reference, Connection connection, List instantiations) { - if (reference.getVariable() instanceof Port) { - // If the port is given as a.b, then we want to prepend a to - // the list of instantiations to determine the width of this port. - List extended = instantiations; - if (reference.getContainer() != null) { - extended = new ArrayList<>(); - extended.add(reference.getContainer()); - if (instantiations != null) { - extended.addAll(instantiations); + return false; + } + + /** + * Report whether the given expression denotes a valid time or not. + * @param expr AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Expression expr) { + if (expr instanceof ParameterReference) { + return isOfTimeType(((ParameterReference) expr).getParameter()); + } else if (expr instanceof Time) { + return isValidTime((Time) expr); + } else if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); } - } + return false; + } - int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); - if (portWidth < 0) { - // Could not determine port width. - return -1; - } - - // Next determine the bank width. This may be unspecified, in which - // case it has to be inferred using the connection. - int bankWidth = 1; - if (reference.getContainer() != null) { - bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); - if (bankWidth < 0 && connection != null) { - // Try to infer the bank width from the connection. - if (reference.getContainer().getWidthSpec().isOfVariableLength()) { - // This occurs for a bank of delays. - int leftWidth = 0; - int rightWidth = 0; - int leftOrRight = 0; - for (VarRef leftPort : connection.getLeftPorts()) { - if (leftPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException( - "Multiple ports with variable width on a connection."); + /** + * Report whether the given time denotes a valid time or not. + * @param t AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Time t) { + if (t == null) return false; + String unit = t.getUnit(); + return t.getInterval() == 0 || + TimeUnit.isValidUnit(unit); + } + + /** + * If the initializer contains exactly one expression, + * return it. Otherwise, return null. + */ + public static Expression asSingleExpr(Initializer init) { + if (init == null) { + return null; + } + var exprs = init.getExprs(); + return exprs.size() == 1 ? exprs.get(0) : null; + } + + public static boolean isSingleExpr(Initializer init) { + // todo expand that to = initialization + if (init == null) { + return false; + } + var exprs = init.getExprs(); + return exprs.size() == 1; + } + + public static boolean isListInitializer(Initializer init) { + return init != null && !isSingleExpr(init); + } + + /** + * Return the type of a declaration with the given + * (nullable) explicit type, and the given (nullable) + * initializer. If the explicit type is null, then the + * type is inferred from the initializer. Only two types + * can be inferred: "time" and "timeList". Return the + * "undefined" type if neither can be inferred. + * + * @param type Explicit type declared on the declaration + * @param init The initializer expression + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Type type, Initializer init) { + if (type != null) { + return InferredType.fromAST(type); + } else if (init == null) { + return InferredType.undefined(); + } + + var single = asSingleExpr(init); + if (single != null) { + // If there is a single element in the list, and it is a proper + // time value with units, we infer the type "time". + if (single instanceof ParameterReference) { + return getInferredType(((ParameterReference) single).getParameter()); + } else if (single instanceof Time) { + return InferredType.time(); + } + } else if (init.getExprs().size() > 1) { + // If there are multiple elements in the list, and there is at + // least one proper time value with units, and all other elements + // are valid times (including zero without units), we infer the + // type "time list". + var allValidTime = true; + var foundNonZero = false; + + for (var e : init.getExprs()) { + if (!ASTUtils.isValidTime(e)) { + allValidTime = false; } - // Indicate that this port is on the left. - leftOrRight = -1; - } else { - // The left port is not the same as this reference. - int otherWidth = inferPortWidth(leftPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; + if (!ASTUtils.isZero(e)) { + foundNonZero = true; } - leftWidth += otherWidth; - } } - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException( - "Multiple ports with variable width on a connection."); + + if (allValidTime && foundNonZero) { + // Conservatively, no bounds are inferred; the returned type + // is a variable-size list. + return InferredType.timeList(); + } + } + return InferredType.undefined(); + } + + /** + * Given a parameter, return an inferred type. Only two types can be + * inferred: "time" and "timeList". Return the "undefined" type if + * neither can be inferred. + * + * @param p A parameter to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Parameter p) { + return getInferredType(p.getType(), p.getInit()); + } + + /** + * Given a state variable, return an inferred type. Only two types can be + * inferred: "time" and "timeList". Return the "undefined" type if + * neither can be inferred. + * + * @param s A state variable to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(StateVar s) { + return getInferredType(s.getType(), s.getInit()); + } + + /** + * Construct an inferred type from an "action" AST node based + * on its declared type. If no type is declared, return the "undefined" + * type. + * + * @param a An action to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Action a) { + return getInferredType(a.getType(), null); + } + + /** + * Construct an inferred type from a "port" AST node based on its declared + * type. If no type is declared, return the "undefined" type. + * + * @param p A port to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Port p) { + return getInferredType(p.getType(), null); + } + + /** + * If the given string can be recognized as a floating-point number that has a leading decimal point, + * prepend the string with a zero and return it. Otherwise, return the original string. + * + * @param literal A string might be recognizable as a floating point number with a leading decimal point. + * @return an equivalent representation of literal + * + */ + public static String addZeroToLeadingDot(String literal) { + Matcher m = ABBREVIATED_FLOAT.matcher(literal); + if (m.matches()) { + return literal.replace(".", "0."); + } + return literal; + } + + /** + * Return true if the specified port is a multiport. + * @param port The port. + * @return True if the port is a multiport. + */ + public static boolean isMultiport(Port port) { + return port.getWidthSpec() != null; + } + + //////////////////////////////// + //// Utility functions for translating AST nodes into text + // This is a continuation of a large section of ASTUtils.xtend + // with the same name. + + /** + * Generate code for referencing a port, action, or timer. + * @param reference The reference to the variable. + */ + public static String generateVarRef(VarRef reference) { + var prefix = ""; + if (reference.getContainer() != null) { + prefix = reference.getContainer().getName() + "."; + } + return prefix + reference.getVariable().getName(); + } + + /** + * Assuming that the given expression denotes a valid time literal, + * return a time value. + */ + public static TimeValue getLiteralTimeValue(Expression expr) { + if (expr instanceof Time) { + return toTimeValue((Time)expr); + } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { + return TimeValue.ZERO; + } else { + return null; + } + } + + /** + * If the parameter is of time type, return its default value. + * Otherwise, return null. + */ + public static TimeValue getDefaultAsTimeValue(Parameter p) { + if (isOfTimeType(p)) { + var init = asSingleExpr(p.getInit()); + if (init != null) { + return getLiteralTimeValue(init); + } + } + return null; + } + + /** + * Return whether the given state variable is inferred + * to a time type. + */ + public static boolean isOfTimeType(StateVar state) { + InferredType t = getInferredType(state); + return t.isTime && !t.isList; + } + + /** + * Return whether the given parameter is inferred + * to a time type. + */ + public static boolean isOfTimeType(Parameter param) { + InferredType t = getInferredType(param); + return t.isTime && !t.isList; + } + + /** + * Given a parameter, return its initial value. + * The initial value is a list of instances of Expressions. + * + * If the instantiations argument is null or an empty list, then the + * value returned is simply the default value given when the parameter + * is defined. + * + * If a list of instantiations is given, then the first instantiation + * is required to be an instantiation of the reactor class that is + * parameterized by the parameter. I.e., + * ``` + * parameter.eContainer == instantiations.get(0).reactorClass + * ``` + * If a second instantiation is given, then it is required to be an instantiation of a + * reactor class that contains the first instantiation. That is, + * ``` + * instantiations.get(0).eContainer == instantiations.get(1).reactorClass + * ``` + * More generally, for all 0 <= i < instantiations.size - 1, + * ``` + * instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass + * ``` + * If any of these conditions is not satisfied, then an IllegalArgumentException + * will be thrown. + * + * Note that this chain of reactions cannot be inferred from the parameter because + * in each of the predicates above, there may be more than one instantiation that + * can appear on the right hand side of the predicate. + * + * For example, consider the following program: + * ``` + * reactor A(x:int(1)) {} + * reactor B(y:int(2)) { + * a1 = new A(x = y); + * a2 = new A(x = -1); + * } + * reactor C(z:int(3)) { + * b1 = new B(y = z); + * b2 = new B(y = -2); + * } + * ``` + * Notice that there are a total of four instances of reactor class A. + * Then + * ``` + * initialValue(x, null) returns 1 + * initialValue(x, [a1]) returns 2 + * initialValue(x, [a2]) returns -1 + * initialValue(x, [a1, b1]) returns 3 + * initialValue(x, [a2, b1]) returns -1 + * initialValue(x, [a1, b2]) returns -2 + * initialValue(x, [a2, b2]) returns -1 + * ``` + * (Actually, in each of the above cases, the returned value is a list with + * one entry, a Literal, e.g. ["1"]). + * + * There are two instances of reactor class B. + * ``` + * initialValue(y, null) returns 2 + * initialValue(y, [a1]) throws an IllegalArgumentException + * initialValue(y, [b1]) returns 3 + * initialValue(y, [b2]) returns -2 + * ``` + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * + * @return The value of the parameter. + * + * @throws IllegalArgumentException If an instantiation provided is not an + * instantiation of the reactor class that is parameterized by the + * respective parameter or if the chain of instantiations is not nested. + */ + public static List initialValue(Parameter parameter, List instantiations) { + // If instantiations are given, then check to see whether this parameter gets overridden in + // the first of those instantiations. + if (instantiations != null && instantiations.size() > 0) { + // Check to be sure that the instantiation is in fact an instantiation + // of the reactor class for which this is a parameter. + Instantiation instantiation = instantiations.get(0); + + if (!belongsTo(parameter, instantiation)) { + throw new IllegalArgumentException("Parameter " + + parameter.getName() + + " is not a parameter of reactor instance " + + instantiation.getName() + + "." + ); + } + // In case there is more than one assignment to this parameter, we need to + // find the last one. + Assignment lastAssignment = null; + for (Assignment assignment: instantiation.getParameters()) { + if (assignment.getLhs().equals(parameter)) { + lastAssignment = assignment; } - // Indicate that this port is on the right. - leftOrRight = 1; - } else { - int otherWidth = inferPortWidth(rightPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; + } + if (lastAssignment != null) { + // Right hand side can be a list. Collect the entries. + List result = new ArrayList<>(); + for (Expression expr: lastAssignment.getRhs().getExprs()) { + if (expr instanceof ParameterReference) { + if (instantiations.size() > 1 + && instantiation.eContainer() != instantiations.get(1).getReactorClass() + ) { + throw new IllegalArgumentException("Reactor instance " + + instantiation.getName() + + " is not contained by instance " + + instantiations.get(1).getName() + + "." + ); + } + result.addAll(initialValue(((ParameterReference)expr).getParameter(), + instantiations.subList(1, instantiations.size()))); + } else { + result.add(expr); + } } - rightWidth += otherWidth; - } + return result; } - int discrepancy = 0; - if (leftOrRight < 0) { - // This port is on the left. - discrepancy = rightWidth - leftWidth; - } else if (leftOrRight > 0) { - // This port is on the right. - discrepancy = leftWidth - rightWidth; + } + // If we reach here, then either no instantiation was supplied or + // there was no assignment in the instantiation. So just use the + // parameter's initial value. + return parameter.getInit().getExprs(); + } + + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) + * belongs to the specified instantiation, meaning that it is defined in + * the reactor class being instantiated or one of its base classes. + * @param eobject The object. + * @param instantiation The instantiation. + */ + public static boolean belongsTo(EObject eobject, Instantiation instantiation) { + Reactor reactor = toDefinition(instantiation.getReactorClass()); + return belongsTo(eobject, reactor); + } + + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) + * belongs to the specified reactor, meaning that it is defined in + * reactor class or one of its base classes. + * @param eobject The object. + * @param reactor The reactor. + */ + public static boolean belongsTo(EObject eobject, Reactor reactor) { + if (eobject.eContainer() == reactor) return true; + for (ReactorDecl baseClass : reactor.getSuperClasses()) { + if (belongsTo(eobject, toDefinition(baseClass))) { + return true; } - // Check that portWidth divides the discrepancy. - if (discrepancy % portWidth != 0) { - // This is an error. - return -1; + } + return false; + } + + /** + * Given a parameter return its integer value or null + * if it does not have an integer value. + * If the value of the parameter is a list of integers, + * return the sum of value in the list. + * The instantiations parameter is as in + * {@link #initialValue(Parameter, List)}. + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * + * @return The integer value of the parameter, or null if it does not have an integer value. + * + * @throws IllegalArgumentException If an instantiation provided is not an + * instantiation of the reactor class that is parameterized by the + * respective parameter or if the chain of instantiations is not nested. + */ + public static Integer initialValueInt(Parameter parameter, List instantiations) { + List expressions = initialValue(parameter, instantiations); + int result = 0; + for (Expression expr: expressions) { + if (!(expr instanceof Literal)) { + return null; + } + try { + result += Integer.decode(((Literal) expr).getLiteral()); + } catch (NumberFormatException ex) { + return null; } - bankWidth = discrepancy / portWidth; - } else { - // Could not determine the bank width. - return -1; - } } - } - return portWidth * bankWidth; - } - // Argument is not a port. - return -1; - } - - /** - * Given an instantiation of a reactor or bank of reactors, return the width. This will be 1 if - * this is not a reactor bank. Otherwise, this will attempt to determine the width. If the width - * is declared as a literal constant, it will return that constant. If the width is specified as a - * reference to a parameter, this will throw an exception. If the width is variable, this will - * find connections in the enclosing reactor and attempt to infer the width. If the width cannot - * be determined, it will throw an exception. - * - *

IMPORTANT: This method should not be used you really need to determine the width! It will - * not evaluate parameter values. - * - * @see #width(WidthSpec, List) - * @param instantiation A reactor instantiation. - * @return The width, if it can be determined. - * @deprecated - */ - @Deprecated - public static int widthSpecification(Instantiation instantiation) { - int result = width(instantiation.getWidthSpec(), null); - if (result < 0) { - throw new InvalidSourceException( - "Cannot determine width for the instance " + instantiation.getName()); - } - return result; - } - - /** - * Report whether a state variable has been initialized or not. - * - * @param v The state variable to be checked. - * @return True if the variable was initialized, false otherwise. - */ - public static boolean isInitialized(StateVar v) { - return v != null && v.getInit() != null; - } - - /** - * Report whether the given time state variable is initialized using a parameter or not. - * - * @param s A state variable. - * @return True if the argument is initialized using a parameter, false otherwise. - */ - public static boolean isParameterized(StateVar s) { - return s.getInit() != null - && IterableExtensions.exists( - s.getInit().getExprs(), it -> it instanceof ParameterReference); - } - - /** - * Check if the reactor class uses generics - * - * @param r the reactor to check - * @return true if the reactor uses generics - */ - public static boolean isGeneric(Reactor r) { - if (r == null) { - return false; - } - return r.getTypeParms().size() != 0; - } - - /** - * If the specified reactor declaration is an import, then return the imported reactor class - * definition. Otherwise, just return the argument. - * - * @param r A Reactor or an ImportedReactor. - * @return The Reactor class definition or null if no definition is found. - */ - public static Reactor toDefinition(ReactorDecl r) { - if (r == null) return null; - if (r instanceof Reactor) { - return (Reactor) r; - } else if (r instanceof ImportedReactor) { - return ((ImportedReactor) r).getReactorClass(); - } - return null; - } - - /** Return all single-line or multi-line comments immediately preceding the given EObject. */ - public static Stream getPrecedingComments( - ICompositeNode compNode, Predicate filter) { - return getPrecedingCommentNodes(compNode, filter).map(INode::getText); - } - - /** Return all single-line or multi-line comments immediately preceding the given EObject. */ - public static Stream getPrecedingCommentNodes( - ICompositeNode compNode, Predicate filter) { - if (compNode == null) return Stream.of(); - List ret = new ArrayList<>(); - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode)) { - if (isComment(node)) { - if (filter.test(node)) ret.add(node); - } else if (!node.getText().isBlank()) { - break; + return result; + } + + /** + * Given the width specification of port or instantiation + * and an (optional) list of nested instantiations, return + * the width if it can be determined and -1 if not. + * It will not be able to be determined if either the + * width is variable (in which case you should use + * {@link #inferPortWidth(VarRef, Connection, List)} ) + * or the list of instantiations is incomplete or missing. + * If there are parameter references in the width, they are + * evaluated to the extent possible given the instantiations list. + * + * The instantiations list is as in + * {@link #initialValue(Parameter, List)}. + * If the spec belongs to an instantiation (for a bank of reactors), + * then the first element on this list should be the instantiation + * that contains this instantiation. If the spec belongs to a port, + * then the first element on the list should be the instantiation + * of the reactor that contains the port. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * + * @return The width, or -1 if the width could not be determined. + * + * @throws IllegalArgumentException If an instantiation provided is not as + * given above or if the chain of instantiations is not nested. + */ + public static int width(WidthSpec spec, List instantiations) { + if (spec == null) { + return 1; } - } - } - return ret.stream(); - } - - /** Return whether {@code node} is a comment. */ - public static boolean isComment(INode node) { - return node instanceof HiddenLeafNode hlNode - && hlNode.getGrammarElement() instanceof TerminalRule tRule - && tRule.getName().endsWith("_COMMENT"); - } - - /** Return true if the given node starts on the same line as the given other node. */ - public static Predicate sameLine(ICompositeNode compNode) { - return other -> { - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { - return node.getStartLine() == other.getStartLine(); + if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { + return inferWidthFromConnections(spec, instantiations); } - } - return false; - }; - } - - /** - * Find the main reactor and set its name if none was defined. - * - * @param resource The resource to find the main reactor in. - */ - public static void setMainName(Resource resource, String name) { - Reactor main = - IteratorExtensions.findFirst( - Iterators.filter(resource.getAllContents(), Reactor.class), - it -> it.isMain() || it.isFederated()); - if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { - main.setName(name); - } - } - - /** - * Create a new instantiation node with the given reactor as its defining class. - * - * @param reactor The reactor class to create an instantiation of. - */ - public static Instantiation createInstantiation(Reactor reactor) { - Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); - inst.setReactorClass(reactor); - // If the reactor is federated or at the top level, then it - // may not have a name. In the generator's doGenerate() - // method, the name gets set using setMainName(). - // But this may be called before that, e.g. during - // diagram synthesis. We assign a temporary name here. - if (reactor.getName() == null) { - if (reactor.isFederated() || reactor.isMain()) { - inst.setName("main"); - } else { - inst.setName(""); - } - - } else { - inst.setName(reactor.getName()); - } - return inst; - } - - /** - * Returns the target declaration in the given model. Non-null because it would cause a parse - * error. - */ - public static TargetDecl targetDecl(Model model) { - return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); - } - - /** - * Returns the target declaration in the given resource. Non-null because it would cause a parse - * error. - */ - public static TargetDecl targetDecl(Resource model) { - return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); - } - - ///////////////////////////////////////////////////////// - //// Private methods - - /** Returns the list if it is not null. Otherwise, return an empty list. */ - public static List convertToEmptyListIfNull(List list) { - return list != null ? list : new ArrayList<>(); - } - - /** - * Return all the superclasses of the specified reactor in deepest-first order. For example, if A - * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates - * are removed. If the specified reactor does not extend any other reactor, then return an empty - * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared - * that is not found, then return null. - * - * @param reactor The specified reactor. - * @param extensions A set of reactors extending the specified reactor (used to detect circular - * extensions). - */ - private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { - LinkedHashSet result = new LinkedHashSet<>(); - for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { - Reactor r = toDefinition(superDecl); - if (r == reactor || r == null) return null; - // If r is in the extensions, then we have a circular inheritance structure. - if (extensions.contains(r)) return null; - extensions.add(r); - LinkedHashSet baseExtends = superClasses(r, extensions); - extensions.remove(r); - if (baseExtends == null) return null; - result.addAll(baseExtends); - result.add(r); - } - return result; - } - - /** - * We may be able to infer the width by examining the connections of the enclosing reactor - * definition. This works, for example, with delays between multiports or banks of reactors. - * Attempt to infer the width from connections and return -1 if the width cannot be inferred. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * @return The width, or -1 if the width could not be inferred from connections. - */ - private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { - for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { - int leftWidth = 0; - int rightWidth = 0; - int leftOrRight = 0; - for (VarRef leftPort : c.getLeftPorts()) { - if (leftPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the left. - leftOrRight = -1; - } else { - leftWidth += inferPortWidth(leftPort, c, instantiations); + var result = 0; + for (WidthTerm term: spec.getTerms()) { + if (term.getParameter() != null) { + Integer termWidth = initialValueInt(term.getParameter(), instantiations); + if (termWidth != null) { + result += termWidth; + } else { + return -1; + } + } else if (term.getWidth() > 0) { + result += term.getWidth(); + } else { + // If the width cannot be determined because term's width <= 0, which means the term's width + // must be inferred, try to infer the width using connections. + if (spec.eContainer() instanceof Instantiation) { + try { + return inferWidthFromConnections(spec, instantiations); + } catch (InvalidSourceException e) { + // If the inference fails, return -1. + return -1; + } + } + } + } + return result; + } + + /** + * Infer the width of a port reference in a connection. + * The port reference one or two parts, a port and an (optional) container + * which is an Instantiation that may refer to a bank of reactors. + * The width will be the product of the bank width and the port width. + * The returned value will be 1 if the port is not in a bank and is not a multiport. + * + * If the width cannot be determined, this will return -1. + * The width cannot be determined if the list of instantiations is + * missing or incomplete. + * + * The instantiations list is as in + * {@link #initialValue(Parameter, List)}. + * The first element on this list should be the instantiation + * that contains the specified connection. + * + * @param reference A port reference. + * @param connection A connection, or null if not in the context of a connection. + * @param instantiations The (optional) list of instantiations. + * + * @return The width or -1 if it could not be determined. + * + * @throws IllegalArgumentException If an instantiation provided is not as + * given above or if the chain of instantiations is not nested. + */ + public static int inferPortWidth( + VarRef reference, Connection connection, List instantiations + ) { + if (reference.getVariable() instanceof Port) { + // If the port is given as a.b, then we want to prepend a to + // the list of instantiations to determine the width of this port. + List extended = instantiations; + if (reference.getContainer() != null) { + extended = new ArrayList<>(); + extended.add(reference.getContainer()); + if (instantiations != null) { + extended.addAll(instantiations); + } + } + + int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); + if (portWidth < 0) { + // Could not determine port width. + return -1; + } + + // Next determine the bank width. This may be unspecified, in which + // case it has to be inferred using the connection. + int bankWidth = 1; + if (reference.getContainer() != null) { + bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); + if (bankWidth < 0 && connection != null) { + // Try to infer the bank width from the connection. + if (reference.getContainer().getWidthSpec().isOfVariableLength()) { + // This occurs for a bank of delays. + int leftWidth = 0; + int rightWidth = 0; + int leftOrRight = 0; + for (VarRef leftPort : connection.getLeftPorts()) { + if (leftPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that this port is on the left. + leftOrRight = -1; + } else { + // The left port is not the same as this reference. + int otherWidth = inferPortWidth(leftPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; + } + leftWidth += otherWidth; + } + } + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that this port is on the right. + leftOrRight = 1; + } else { + int otherWidth = inferPortWidth(rightPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; + } + rightWidth += otherWidth; + } + } + int discrepancy = 0; + if (leftOrRight < 0) { + // This port is on the left. + discrepancy = rightWidth - leftWidth; + } else if (leftOrRight > 0) { + // This port is on the right. + discrepancy = leftWidth - rightWidth; + } + // Check that portWidth divides the discrepancy. + if (discrepancy % portWidth != 0) { + // This is an error. + return -1; + } + bankWidth = discrepancy / portWidth; + } else { + // Could not determine the bank width. + return -1; + } + } + } + return portWidth * bankWidth; + } + // Argument is not a port. + return -1; + } + + /** + * Given an instantiation of a reactor or bank of reactors, return + * the width. This will be 1 if this is not a reactor bank. Otherwise, + * this will attempt to determine the width. If the width is declared + * as a literal constant, it will return that constant. If the width + * is specified as a reference to a parameter, this will throw an + * exception. If the width is variable, this will find + * connections in the enclosing reactor and attempt to infer the + * width. If the width cannot be determined, it will throw an exception. + * + * IMPORTANT: This method should not be used you really need to + * determine the width! It will not evaluate parameter values. + * @see #width(WidthSpec, List) + * + * @param instantiation A reactor instantiation. + * + * @return The width, if it can be determined. + * @deprecated + */ + @Deprecated + public static int widthSpecification(Instantiation instantiation) { + int result = width(instantiation.getWidthSpec(), null); + if (result < 0) { + throw new InvalidSourceException("Cannot determine width for the instance " + + instantiation.getName()); + } + return result; + } + + /** + * Report whether a state variable has been initialized or not. + * @param v The state variable to be checked. + * @return True if the variable was initialized, false otherwise. + */ + public static boolean isInitialized(StateVar v) { + return v != null && v.getInit() != null; + } + + /** + * Report whether the given time state variable is initialized using a + * parameter or not. + * @param s A state variable. + * @return True if the argument is initialized using a parameter, false + * otherwise. + */ + public static boolean isParameterized(StateVar s) { + return s.getInit() != null && + IterableExtensions.exists(s.getInit().getExprs(), it -> it instanceof ParameterReference); + } + + /** + * Check if the reactor class uses generics + * @param r the reactor to check + * @return true if the reactor uses generics + */ + public static boolean isGeneric(Reactor r) { + if (r == null) { + return false; + } + return r.getTypeParms().size() != 0; + } + + /** + * If the specified reactor declaration is an import, then + * return the imported reactor class definition. Otherwise, + * just return the argument. + * @param r A Reactor or an ImportedReactor. + * @return The Reactor class definition or null if no definition is found. + */ + public static Reactor toDefinition(ReactorDecl r) { + if (r == null) + return null; + if (r instanceof Reactor) { + return (Reactor) r; + } else if (r instanceof ImportedReactor) { + return ((ImportedReactor) r).getReactorClass(); + } + return null; + } + + /** + * Return all single-line or multi-line comments immediately preceding the + * given EObject. + */ + public static Stream getPrecedingComments( + ICompositeNode compNode, + Predicate filter + ) { + return getPrecedingCommentNodes(compNode, filter).map(INode::getText); + } + + /** + * Return all single-line or multi-line comments immediately preceding the + * given EObject. + */ + public static Stream getPrecedingCommentNodes( + ICompositeNode compNode, + Predicate filter + ) { + if (compNode == null) return Stream.of(); + List ret = new ArrayList<>(); + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode)) { + if (isComment(node)) { + if (filter.test(node)) ret.add(node); + } else if (!node.getText().isBlank()) { + break; + } + } + } + return ret.stream(); + } + + /** Return whether {@code node} is a comment. */ + public static boolean isComment(INode node) { + return node instanceof HiddenLeafNode hlNode + && hlNode.getGrammarElement() instanceof TerminalRule tRule + && tRule.getName().endsWith("_COMMENT"); + } + + /** + * Return true if the given node starts on the same line as the given other + * node. + */ + public static Predicate sameLine(ICompositeNode compNode) { + return other -> { + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { + return node.getStartLine() == other.getStartLine(); + } + } + return false; + }; + } + + /** + * Find the main reactor and set its name if none was defined. + * @param resource The resource to find the main reactor in. + */ + public static void setMainName(Resource resource, String name) { + Reactor main = IteratorExtensions.findFirst(Iterators.filter(resource.getAllContents(), Reactor.class), + it -> it.isMain() || it.isFederated() + ); + if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { + main.setName(name); } - } - for (VarRef rightPort : c.getRightPorts()) { - if (rightPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the right. - leftOrRight = 1; + } + + /** + * Create a new instantiation node with the given reactor as its defining class. + * @param reactor The reactor class to create an instantiation of. + */ + public static Instantiation createInstantiation(Reactor reactor) { + Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); + inst.setReactorClass(reactor); + // If the reactor is federated or at the top level, then it + // may not have a name. In the generator's doGenerate() + // method, the name gets set using setMainName(). + // But this may be called before that, e.g. during + // diagram synthesis. We assign a temporary name here. + if (reactor.getName() == null) { + if (reactor.isFederated() || reactor.isMain()) { + inst.setName("main"); + } else { + inst.setName(""); + } + } else { - rightWidth += inferPortWidth(rightPort, c, instantiations); + inst.setName(reactor.getName()); } - } - if (leftOrRight < 0) { - return rightWidth - leftWidth; - } else if (leftOrRight > 0) { - return leftWidth - rightWidth; - } - } - // A connection was not found with the instantiation. - return -1; - } - - public static void addReactionAttribute(Reaction reaction, String name) { - var fedAttr = factory.createAttribute(); - fedAttr.setAttrName(name); - reaction.getAttributes().add(fedAttr); - } + return inst; + } + + /** + * Returns the target declaration in the given model. + * Non-null because it would cause a parse error. + */ + public static TargetDecl targetDecl(Model model) { + return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); + } + + /** + * Returns the target declaration in the given resource. + * Non-null because it would cause a parse error. + */ + public static TargetDecl targetDecl(Resource model) { + return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); + } + + ///////////////////////////////////////////////////////// + //// Private methods + + /** + * Returns the list if it is not null. Otherwise, return an empty list. + */ + public static List convertToEmptyListIfNull(List list) { + return list != null ? list : new ArrayList<>(); + } + + /** + * Return all the superclasses of the specified reactor + * in deepest-first order. For example, if A extends B and C, and + * B and C both extend D, this will return the list [D, B, C, A]. + * Duplicates are removed. If the specified reactor does not extend + * any other reactor, then return an empty list. + * If a cycle is found, where X extends Y and Y extends X, or if + * a superclass is declared that is not found, then return null. + * @param reactor The specified reactor. + * @param extensions A set of reactors extending the specified reactor + * (used to detect circular extensions). + */ + private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { + LinkedHashSet result = new LinkedHashSet<>(); + for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { + Reactor r = toDefinition(superDecl); + if (r == reactor || r == null) return null; + // If r is in the extensions, then we have a circular inheritance structure. + if (extensions.contains(r)) return null; + extensions.add(r); + LinkedHashSet baseExtends = superClasses(r, extensions); + extensions.remove(r); + if (baseExtends == null) return null; + result.addAll(baseExtends); + result.add(r); + } + return result; + } + + /** + * We may be able to infer the width by examining the connections of + * the enclosing reactor definition. This works, for example, with + * delays between multiports or banks of reactors. + * Attempt to infer the width from connections and return -1 if the width cannot be inferred. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * + * @return The width, or -1 if the width could not be inferred from connections. + */ + private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { + for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { + int leftWidth = 0; + int rightWidth = 0; + int leftOrRight = 0; + for (VarRef leftPort : c.getLeftPorts()) { + if (leftPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the left. + leftOrRight = -1; + } else { + leftWidth += inferPortWidth(leftPort, c, instantiations); + } + } + for (VarRef rightPort : c.getRightPorts()) { + if (rightPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the right. + leftOrRight = 1; + } else { + rightWidth += inferPortWidth(rightPort, c, instantiations); + } + } + if (leftOrRight < 0) { + return rightWidth - leftWidth; + } else if (leftOrRight > 0) { + return leftWidth - rightWidth; + } + } + // A connection was not found with the instantiation. + return -1; + } + + public static void addReactionAttribute(Reaction reaction, String name) { + var fedAttr = factory.createAttribute(); + fedAttr.setAttrName(name); + reaction.getAttributes().add(fedAttr); + } } From c25c8b7f01017437780596a174a8c609c76a1f03 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 30 Apr 2023 10:54:44 +0200 Subject: [PATCH 211/709] Removed unused imports --- org.lflang/src/org/lflang/ASTUtils.java | 4 ---- 1 file changed, 4 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index f8c436727c..23b799dd53 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -32,7 +32,6 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.Set; import java.util.function.Predicate; import java.util.regex.Matcher; @@ -61,8 +60,6 @@ import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.Assignment; -import org.lflang.lf.AttrParm; -import org.lflang.lf.Attribute; import org.lflang.lf.Code; import org.lflang.lf.Connection; import org.lflang.lf.Element; @@ -263,7 +260,6 @@ public static Target getTarget(EObject object) { /** * Add a new target property to the given resource. - * * This also creates a config object if the resource does not yey have one. * * @param resource The resource to modify From 592e2c0180b88ff809595145580d2bfde0bc41bb Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 30 Apr 2023 10:58:28 +0200 Subject: [PATCH 212/709] Revert formatting changes --- org.lflang/src/org/lflang/ast/IsEqual.java | 1202 ++++++++++---------- 1 file changed, 610 insertions(+), 592 deletions(-) diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index 73cd12916a..af0274ea2a 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -6,7 +6,9 @@ import java.util.function.BiPredicate; import java.util.function.Function; import java.util.stream.Collectors; + import org.eclipse.emf.ecore.EObject; + import org.lflang.TimeUnit; import org.lflang.lf.Action; import org.lflang.lf.Array; @@ -64,604 +66,620 @@ import org.lflang.lf.util.LfSwitch; /** - * Switch class that checks if subtrees of the AST are semantically equivalent to each other. Return - * {@code false} if they are not equivalent; return {@code true} or {@code false} (but preferably - * {@code true}) if they are equivalent. + * Switch class that checks if subtrees of the AST are semantically equivalent + * to each other. Return {@code false} if they are not equivalent; return + * {@code true} or {@code false} (but preferably {@code true}) if they are + * equivalent. */ public class IsEqual extends LfSwitch { - private final EObject otherObject; - - public IsEqual(EObject other) { - this.otherObject = other; - } - - @Override - public Boolean doSwitch(EObject eObject) { - if (otherObject == eObject) return true; - if (eObject == null) return false; - return super.doSwitch(eObject); - } - - @Override - public Boolean caseModel(Model object) { - return new ComparisonMachine<>(object, Model.class) - .equivalent(Model::getTarget) - .listsEquivalent(Model::getImports) - .listsEquivalent(Model::getPreambles) - .listsEquivalent(Model::getReactors) - .conclusion; - } - - @Override - public Boolean caseImport(Import object) { - return new ComparisonMachine<>(object, Import.class) - .equalAsObjects(Import::getImportURI) - .listsEquivalent(Import::getReactorClasses) - .conclusion; - } - - @Override - public Boolean caseReactorDecl(ReactorDecl object) { - return new ComparisonMachine<>(object, ReactorDecl.class) - .equalAsObjects(ReactorDecl::getName) - .conclusion; - } - - @Override - public Boolean caseImportedReactor(ImportedReactor object) { - return new ComparisonMachine<>(object, ImportedReactor.class) - .equalAsObjects(ImportedReactor::getName) - .equivalent(ImportedReactor::getReactorClass) - .conclusion; - } - - @Override - public Boolean caseReactor(Reactor object) { - return new ComparisonMachine<>(object, Reactor.class) - .listsEquivalent(Reactor::getAttributes) - .equalAsObjects(Reactor::isFederated) - .equalAsObjects(Reactor::isRealtime) - .equalAsObjects(Reactor::isMain) - .equalAsObjects(Reactor::getName) - .listsEquivalent(Reactor::getTypeParms) - .listsEquivalent(Reactor::getParameters) - .equivalent(Reactor::getHost) - .listsEquivalent(Reactor::getSuperClasses) - .listsEquivalent(Reactor::getPreambles) - .listsEquivalent(Reactor::getInputs) - .listsEquivalent(Reactor::getOutputs) - .listsEquivalent(Reactor::getTimers) - .listsEquivalent(Reactor::getActions) - .listsEquivalent(Reactor::getInstantiations) - .listsEquivalent(Reactor::getConnections) - .listsEquivalent(Reactor::getStateVars) - .listsEquivalent(Reactor::getReactions) - .listsEquivalent(Reactor::getMethods) - .listsEquivalent(Reactor::getModes) - .conclusion; - } - - @Override - public Boolean caseTypeParm(TypeParm object) { - return new ComparisonMachine<>(object, TypeParm.class) - .equalAsObjects(TypeParm::getLiteral) - .equivalent(TypeParm::getCode) - .conclusion; - } - - @Override - public Boolean caseTargetDecl(TargetDecl object) { - return new ComparisonMachine<>(object, TargetDecl.class) - .equalAsObjects(TargetDecl::getName) - .equivalentModulo( - TargetDecl::getConfig, - (KeyValuePairs it) -> it != null && it.getPairs().isEmpty() ? null : it) - .conclusion; - } - - @Override - public Boolean caseStateVar(StateVar object) { - return new ComparisonMachine<>(object, StateVar.class) - .listsEquivalent(StateVar::getAttributes) - .equalAsObjects(StateVar::getName) - .equivalent(StateVar::getType) - .equivalent(StateVar::getInit) - .conclusion; - } - - @Override - public Boolean caseInitializer(Initializer object) { - // Empty braces are not equivalent to no init. - return new ComparisonMachine<>(object, Initializer.class) - .equalAsObjects(Initializer::isBraces) - // An initializer with no parens is equivalent to one with parens, - // if the list has a single element. This is probably going to change - // when we introduce equals initializers. - // .equalAsObjects(Initializer::isParens) - .listsEquivalent(Initializer::getExprs) - .conclusion; - } - - @Override - public Boolean caseMethod(Method object) { - return new ComparisonMachine<>(object, Method.class) - .equalAsObjects(Method::isConst) - .equalAsObjects(Method::getName) - .listsEquivalent(Method::getArguments) - .equivalent(Method::getReturn) - .equivalent(Method::getCode) - .conclusion; - } - - @Override - public Boolean caseMethodArgument(MethodArgument object) { - return new ComparisonMachine<>(object, MethodArgument.class) - .equalAsObjects(MethodArgument::getName) - .equivalent(MethodArgument::getType) - .conclusion; - } - - @Override - public Boolean caseInput(Input object) { - return new ComparisonMachine<>(object, Input.class) - .listsEquivalent(Input::getAttributes) - .equalAsObjects(Input::isMutable) - .equivalent(Input::getWidthSpec) - .equivalent(Input::getType) - .conclusion; - } - - @Override - public Boolean caseOutput(Output object) { - return new ComparisonMachine<>(object, Output.class) - .listsEquivalent(Output::getAttributes) - .equivalent(Output::getWidthSpec) - .equalAsObjects(Output::getName) - .equivalent(Output::getType) - .conclusion; - } - - @Override - public Boolean caseTimer(Timer object) { - return new ComparisonMachine<>(object, Timer.class) - .listsEquivalent(Timer::getAttributes) - .equalAsObjects(Timer::getName) - .equivalent(Timer::getOffset) - .equivalent(Timer::getPeriod) - .conclusion; - } - - @Override - public Boolean caseMode(Mode object) { - return new ComparisonMachine<>(object, Mode.class) - .equalAsObjects(Mode::isInitial) - .equalAsObjects(Mode::getName) - .listsEquivalent(Mode::getStateVars) - .listsEquivalent(Mode::getTimers) - .listsEquivalent(Mode::getActions) - .listsEquivalent(Mode::getInstantiations) - .listsEquivalent(Mode::getConnections) - .listsEquivalent(Mode::getReactions) - .conclusion; - } - - @Override - public Boolean caseAction(Action object) { - return new ComparisonMachine<>(object, Action.class) - .listsEquivalent(Action::getAttributes) - .equalAsObjects(Action::getOrigin) // This is an enum - .equalAsObjects(Action::getName) - .equivalent(Action::getMinDelay) - .equivalent(Action::getMinSpacing) - .equalAsObjects(Action::getPolicy) - .equivalent(Action::getType) - .conclusion; - } - - @Override - public Boolean caseAttribute(Attribute object) { - return new ComparisonMachine<>(object, Attribute.class) - .equalAsObjects(Attribute::getAttrName) - .listsEquivalent(Attribute::getAttrParms) - .conclusion; - } - - @Override - public Boolean caseAttrParm(AttrParm object) { - return new ComparisonMachine<>(object, AttrParm.class) - .equalAsObjects(AttrParm::getName) - .equalAsObjects(AttrParm::getValue) - .conclusion; - } - - @Override - public Boolean caseReaction(Reaction object) { - return new ComparisonMachine<>(object, Reaction.class) - .listsEquivalent(Reaction::getAttributes) - .listsEquivalent(Reaction::getTriggers) - .listsEquivalent(Reaction::getSources) - .listsEquivalent(Reaction::getEffects) - .equalAsObjects(Reaction::isMutation) - .equalAsObjects(Reaction::getName) - .equivalent(Reaction::getCode) - .equivalent(Reaction::getStp) - .equivalent(Reaction::getDeadline) - .conclusion; - } - - @Override - public Boolean caseTriggerRef(TriggerRef object) { - throw thereIsAMoreSpecificCase(TriggerRef.class, BuiltinTriggerRef.class, VarRef.class); - } - - @Override - public Boolean caseBuiltinTriggerRef(BuiltinTriggerRef object) { - return new ComparisonMachine<>(object, BuiltinTriggerRef.class) - .equalAsObjects(BuiltinTriggerRef::getType) // This is an enum - .conclusion; - } - - @Override - public Boolean caseDeadline(Deadline object) { - return new ComparisonMachine<>(object, Deadline.class) - .equivalent(Deadline::getDelay) - .equivalent(Deadline::getCode) - .conclusion; - } - - @Override - public Boolean caseSTP(STP object) { - return new ComparisonMachine<>(object, STP.class) - .equivalent(STP::getValue) - .equivalent(STP::getCode) - .conclusion; - } - - @Override - public Boolean casePreamble(Preamble object) { - return new ComparisonMachine<>(object, Preamble.class) - .equalAsObjects(Preamble::getVisibility) // This is an enum - .equivalent(Preamble::getCode) - .conclusion; - } - - @Override - public Boolean caseInstantiation(Instantiation object) { - return new ComparisonMachine<>(object, Instantiation.class) - .equalAsObjects(Instantiation::getName) - .equivalent(Instantiation::getWidthSpec) - .equivalent(Instantiation::getReactorClass) - .listsEquivalent(Instantiation::getTypeArgs) - .listsEquivalent(Instantiation::getParameters) - .equivalent(Instantiation::getHost) - .conclusion; - } - - @Override - public Boolean caseConnection(Connection object) { - return new ComparisonMachine<>(object, Connection.class) - .listsEquivalent(Connection::getLeftPorts) - .equalAsObjects(Connection::isIterated) - .equalAsObjects(Connection::isPhysical) - .listsEquivalent(Connection::getRightPorts) - .equivalent(Connection::getDelay) - .equivalent(Connection::getSerializer) - .conclusion; - } - - @Override - public Boolean caseSerializer(Serializer object) { - return new ComparisonMachine<>(object, Serializer.class) - .equalAsObjects(Serializer::getType) - .conclusion; - } - - @Override - public Boolean caseKeyValuePairs(KeyValuePairs object) { - return new ComparisonMachine<>(object, KeyValuePairs.class) - .listsEquivalent(KeyValuePairs::getPairs) - .conclusion; - } - - @Override - public Boolean caseKeyValuePair(KeyValuePair object) { - return new ComparisonMachine<>(object, KeyValuePair.class) - .equalAsObjects(KeyValuePair::getName) - .equivalent(KeyValuePair::getValue) - .conclusion; - } - - @Override - public Boolean caseArray(Array object) { - return new ComparisonMachine<>(object, Array.class) - .listsEquivalent(Array::getElements) - .conclusion; - } - - @Override - public Boolean caseElement(Element object) { - return new ComparisonMachine<>(object, Element.class) - .equivalent(Element::getKeyvalue) - .equivalent(Element::getArray) - .equalAsObjects(Element::getLiteral) - .equalAsObjects(Element::getId) - .equalAsObjects(Element::getUnit) - .conclusion; - } - - @Override - public Boolean caseTypedVariable(TypedVariable object) { - throw thereIsAMoreSpecificCase(TypedVariable.class, Port.class, Action.class); - } - - @Override - public Boolean caseVariable(Variable object) { - throw thereIsAMoreSpecificCase( - Variable.class, TypedVariable.class, Timer.class, Mode.class, Watchdog.class); - } - - @Override - public Boolean caseVarRef(VarRef object) { - return new ComparisonMachine<>(object, VarRef.class) - .equalAsObjects( - varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable().getName()) - .equivalent(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable()) - .equalAsObjects( - varRef -> varRef.getContainer() == null ? null : varRef.getContainer().getName()) - .equalAsObjects(VarRef::isInterleaved) - .equalAsObjects(VarRef::getTransition) - .conclusion; - } - - @Override - public Boolean caseAssignment(Assignment object) { - return new ComparisonMachine<>(object, Assignment.class) - .equivalent(Assignment::getLhs) - .equivalent(Assignment::getRhs) - .conclusion; - } - - @Override - public Boolean caseParameter(Parameter object) { - return new ComparisonMachine<>(object, Parameter.class) - .listsEquivalent(Parameter::getAttributes) - .equalAsObjects(Parameter::getName) - .equivalent(Parameter::getType) - .equivalent(Parameter::getInit) - .conclusion; - } - - @Override - public Boolean caseExpression(Expression object) { - throw thereIsAMoreSpecificCase( - Expression.class, - Literal.class, - Time.class, - ParameterReference.class, - Code.class, - BracedListExpression.class); - } - - @Override - public Boolean caseBracedListExpression(BracedListExpression object) { - return new ComparisonMachine<>(object, BracedListExpression.class) - .listsEquivalent(BracedListExpression::getItems) - .conclusion; - } - - @Override - public Boolean caseParameterReference(ParameterReference object) { - return new ComparisonMachine<>(object, ParameterReference.class) - .equivalent(ParameterReference::getParameter) - .conclusion; - } - - @Override - public Boolean caseTime(Time object) { - return new ComparisonMachine<>(object, Time.class) - .equalAsObjects(Time::getInterval) - .equalAsObjectsModulo( - Time::getUnit, - ((Function) TimeUnit::getCanonicalName).compose(TimeUnit::fromName)) - .conclusion; - } - - @Override - public Boolean casePort(Port object) { - throw thereIsAMoreSpecificCase(Port.class, Input.class, Output.class); - } - - @Override - public Boolean caseType(Type object) { - return new ComparisonMachine<>(object, Type.class) - .equivalent(Type::getCode) - .equalAsObjects(Type::isTime) - .equivalent(Type::getArraySpec) - .equalAsObjects(Type::getId) - .listsEquivalent(Type::getTypeArgs) - .listsEqualAsObjects(Type::getStars) - .equivalent(Type::getArraySpec) - .equivalent(Type::getCode) - .conclusion; - } - - @Override - public Boolean caseArraySpec(ArraySpec object) { - return new ComparisonMachine<>(object, ArraySpec.class) - .equalAsObjects(ArraySpec::isOfVariableLength) - .equalAsObjects(ArraySpec::getLength) - .conclusion; - } - - @Override - public Boolean caseWatchdog(Watchdog object) { - return new ComparisonMachine<>(object, Watchdog.class) - .equalAsObjects(Watchdog::getName) - .equivalent(Watchdog::getTimeout) - .listsEquivalent(Watchdog::getEffects) - .equivalent(Watchdog::getCode) - .conclusion; - } - - @Override - public Boolean caseWidthSpec(WidthSpec object) { - return new ComparisonMachine<>(object, WidthSpec.class) - .equalAsObjects(WidthSpec::isOfVariableLength) - .listsEquivalent(WidthSpec::getTerms) - .conclusion; - } - - @Override - public Boolean caseWidthTerm(WidthTerm object) { - return new ComparisonMachine<>(object, WidthTerm.class) - .equalAsObjects(WidthTerm::getWidth) - .equivalent(WidthTerm::getParameter) - .equivalent(WidthTerm::getPort) - .equivalent(WidthTerm::getCode) - .conclusion; - } - - @Override - public Boolean caseIPV4Host(IPV4Host object) { - return caseHost(object); - } - - @Override - public Boolean caseIPV6Host(IPV6Host object) { - return caseHost(object); - } - - @Override - public Boolean caseNamedHost(NamedHost object) { - return caseHost(object); - } - - @Override - public Boolean caseHost(Host object) { - return new ComparisonMachine<>(object, Host.class) - .equalAsObjects(Host::getUser) - .equalAsObjects(Host::getAddr) - .equalAsObjects(Host::getPort) - .conclusion; - } - - @Override - public Boolean caseCodeExpr(CodeExpr object) { - return new ComparisonMachine<>(object, CodeExpr.class).equivalent(CodeExpr::getCode).conclusion; - } - - @Override - public Boolean caseCode(Code object) { - return new ComparisonMachine<>(object, Code.class) - .equalAsObjectsModulo(Code::getBody, s -> s == null ? null : s.strip().stripIndent()) - .conclusion; - } - - @Override - public Boolean caseLiteral(Literal object) { - return new ComparisonMachine<>(object, Literal.class) - .equalAsObjects(Literal::getLiteral) - .conclusion; - } - - @Override - public Boolean defaultCase(EObject object) { - return super.defaultCase(object); - } - - @SafeVarargs - private UnsupportedOperationException thereIsAMoreSpecificCase( - Class thisCase, Class... moreSpecificCases) { - return new UnsupportedOperationException( - String.format( + private final EObject otherObject; + + public IsEqual(EObject other) { + this.otherObject = other; + } + + @Override + public Boolean doSwitch(EObject eObject) { + if (otherObject == eObject) return true; + if (eObject == null) return false; + return super.doSwitch(eObject); + } + + @Override + public Boolean caseModel(Model object) { + return new ComparisonMachine<>(object, Model.class) + .equivalent(Model::getTarget) + .listsEquivalent(Model::getImports) + .listsEquivalent(Model::getPreambles) + .listsEquivalent(Model::getReactors).conclusion; + } + + @Override + public Boolean caseImport(Import object) { + return new ComparisonMachine<>(object, Import.class) + .equalAsObjects(Import::getImportURI) + .listsEquivalent(Import::getReactorClasses).conclusion; + } + + @Override + public Boolean caseReactorDecl(ReactorDecl object) { + return new ComparisonMachine<>(object, ReactorDecl.class) + .equalAsObjects(ReactorDecl::getName) + .conclusion; + } + + @Override + public Boolean caseImportedReactor(ImportedReactor object) { + return new ComparisonMachine<>(object, ImportedReactor.class) + .equalAsObjects(ImportedReactor::getName) + .equivalent(ImportedReactor::getReactorClass) + .conclusion; + } + + @Override + public Boolean caseReactor(Reactor object) { + return new ComparisonMachine<>(object, Reactor.class) + .listsEquivalent(Reactor::getAttributes) + .equalAsObjects(Reactor::isFederated) + .equalAsObjects(Reactor::isRealtime) + .equalAsObjects(Reactor::isMain) + .equalAsObjects(Reactor::getName) + .listsEquivalent(Reactor::getTypeParms) + .listsEquivalent(Reactor::getParameters) + .equivalent(Reactor::getHost) + .listsEquivalent(Reactor::getSuperClasses) + .listsEquivalent(Reactor::getPreambles) + .listsEquivalent(Reactor::getInputs) + .listsEquivalent(Reactor::getOutputs) + .listsEquivalent(Reactor::getTimers) + .listsEquivalent(Reactor::getActions) + .listsEquivalent(Reactor::getInstantiations) + .listsEquivalent(Reactor::getConnections) + .listsEquivalent(Reactor::getStateVars) + .listsEquivalent(Reactor::getReactions) + .listsEquivalent(Reactor::getMethods) + .listsEquivalent(Reactor::getModes) + .conclusion; + } + + @Override + public Boolean caseTypeParm(TypeParm object) { + return new ComparisonMachine<>(object, TypeParm.class) + .equalAsObjects(TypeParm::getLiteral) + .equivalent(TypeParm::getCode) + .conclusion; + } + + @Override + public Boolean caseTargetDecl(TargetDecl object) { + return new ComparisonMachine<>(object, TargetDecl.class) + .equalAsObjects(TargetDecl::getName) + .equivalentModulo( + TargetDecl::getConfig, + (KeyValuePairs it) -> it != null && it.getPairs().isEmpty() ? null : it + ) + .conclusion; + } + + @Override + public Boolean caseStateVar(StateVar object) { + return new ComparisonMachine<>(object, StateVar.class) + .listsEquivalent(StateVar::getAttributes) + .equalAsObjects(StateVar::getName) + .equivalent(StateVar::getType) + .equivalent(StateVar::getInit) + .conclusion; + } + + @Override + public Boolean caseInitializer(Initializer object) { + // Empty braces are not equivalent to no init. + return new ComparisonMachine<>(object, Initializer.class) + .equalAsObjects(Initializer::isBraces) + // An initializer with no parens is equivalent to one with parens, + // if the list has a single element. This is probably going to change + // when we introduce equals initializers. + // .equalAsObjects(Initializer::isParens) + .listsEquivalent(Initializer::getExprs) + .conclusion; + } + + @Override + public Boolean caseMethod(Method object) { + return new ComparisonMachine<>(object, Method.class) + .equalAsObjects(Method::isConst) + .equalAsObjects(Method::getName) + .listsEquivalent(Method::getArguments) + .equivalent(Method::getReturn) + .equivalent(Method::getCode) + .conclusion; + } + + @Override + public Boolean caseMethodArgument(MethodArgument object) { + return new ComparisonMachine<>(object, MethodArgument.class) + .equalAsObjects(MethodArgument::getName) + .equivalent(MethodArgument::getType) + .conclusion; + } + + @Override + public Boolean caseInput(Input object) { + return new ComparisonMachine<>(object, Input.class) + .listsEquivalent(Input::getAttributes) + .equalAsObjects(Input::isMutable) + .equivalent(Input::getWidthSpec) + .equivalent(Input::getType) + .conclusion; + } + + @Override + public Boolean caseOutput(Output object) { + return new ComparisonMachine<>(object, Output.class) + .listsEquivalent(Output::getAttributes) + .equivalent(Output::getWidthSpec) + .equalAsObjects(Output::getName) + .equivalent(Output::getType) + .conclusion; + } + + @Override + public Boolean caseTimer(Timer object) { + return new ComparisonMachine<>(object, Timer.class) + .listsEquivalent(Timer::getAttributes) + .equalAsObjects(Timer::getName) + .equivalent(Timer::getOffset) + .equivalent(Timer::getPeriod) + .conclusion; + } + + @Override + public Boolean caseMode(Mode object) { + return new ComparisonMachine<>(object, Mode.class) + .equalAsObjects(Mode::isInitial) + .equalAsObjects(Mode::getName) + .listsEquivalent(Mode::getStateVars) + .listsEquivalent(Mode::getTimers) + .listsEquivalent(Mode::getActions) + .listsEquivalent(Mode::getInstantiations) + .listsEquivalent(Mode::getConnections) + .listsEquivalent(Mode::getReactions) + .conclusion; + } + + @Override + public Boolean caseAction(Action object) { + return new ComparisonMachine<>(object, Action.class) + .listsEquivalent(Action::getAttributes) + .equalAsObjects(Action::getOrigin) // This is an enum + .equalAsObjects(Action::getName) + .equivalent(Action::getMinDelay) + .equivalent(Action::getMinSpacing) + .equalAsObjects(Action::getPolicy) + .equivalent(Action::getType) + .conclusion; + } + + @Override + public Boolean caseAttribute(Attribute object) { + return new ComparisonMachine<>(object, Attribute.class) + .equalAsObjects(Attribute::getAttrName) + .listsEquivalent(Attribute::getAttrParms) + .conclusion; + } + + @Override + public Boolean caseAttrParm(AttrParm object) { + return new ComparisonMachine<>(object, AttrParm.class) + .equalAsObjects(AttrParm::getName) + .equalAsObjects(AttrParm::getValue) + .conclusion; + } + + @Override + public Boolean caseReaction(Reaction object) { + return new ComparisonMachine<>(object, Reaction.class) + .listsEquivalent(Reaction::getAttributes) + .listsEquivalent(Reaction::getTriggers) + .listsEquivalent(Reaction::getSources) + .listsEquivalent(Reaction::getEffects) + .equalAsObjects(Reaction::isMutation) + .equalAsObjects(Reaction::getName) + .equivalent(Reaction::getCode) + .equivalent(Reaction::getStp) + .equivalent(Reaction::getDeadline) + .conclusion; + } + + @Override + public Boolean caseTriggerRef(TriggerRef object) { + throw thereIsAMoreSpecificCase(TriggerRef.class, BuiltinTriggerRef.class, VarRef.class); + } + + @Override + public Boolean caseBuiltinTriggerRef(BuiltinTriggerRef object) { + return new ComparisonMachine<>(object, BuiltinTriggerRef.class) + .equalAsObjects(BuiltinTriggerRef::getType) // This is an enum + .conclusion; + } + + @Override + public Boolean caseDeadline(Deadline object) { + return new ComparisonMachine<>(object, Deadline.class) + .equivalent(Deadline::getDelay) + .equivalent(Deadline::getCode) + .conclusion; + } + + @Override + public Boolean caseSTP(STP object) { + return new ComparisonMachine<>(object, STP.class) + .equivalent(STP::getValue) + .equivalent(STP::getCode) + .conclusion; + } + + @Override + public Boolean casePreamble(Preamble object) { + return new ComparisonMachine<>(object, Preamble.class) + .equalAsObjects(Preamble::getVisibility) // This is an enum + .equivalent(Preamble::getCode) + .conclusion; + } + + @Override + public Boolean caseInstantiation(Instantiation object) { + return new ComparisonMachine<>(object, Instantiation.class) + .equalAsObjects(Instantiation::getName) + .equivalent(Instantiation::getWidthSpec) + .equivalent(Instantiation::getReactorClass) + .listsEquivalent(Instantiation::getTypeArgs) + .listsEquivalent(Instantiation::getParameters) + .equivalent(Instantiation::getHost) + .conclusion; + } + + @Override + public Boolean caseConnection(Connection object) { + return new ComparisonMachine<>(object, Connection.class) + .listsEquivalent(Connection::getLeftPorts) + .equalAsObjects(Connection::isIterated) + .equalAsObjects(Connection::isPhysical) + .listsEquivalent(Connection::getRightPorts) + .equivalent(Connection::getDelay) + .equivalent(Connection::getSerializer) + .conclusion; + } + + @Override + public Boolean caseSerializer(Serializer object) { + return new ComparisonMachine<>(object, Serializer.class) + .equalAsObjects(Serializer::getType) + .conclusion; + } + + @Override + public Boolean caseKeyValuePairs(KeyValuePairs object) { + return new ComparisonMachine<>(object, KeyValuePairs.class) + .listsEquivalent(KeyValuePairs::getPairs) + .conclusion; + } + + @Override + public Boolean caseKeyValuePair(KeyValuePair object) { + return new ComparisonMachine<>(object, KeyValuePair.class) + .equalAsObjects(KeyValuePair::getName) + .equivalent(KeyValuePair::getValue) + .conclusion; + } + + @Override + public Boolean caseArray(Array object) { + return new ComparisonMachine<>(object, Array.class) + .listsEquivalent(Array::getElements) + .conclusion; + } + + @Override + public Boolean caseElement(Element object) { + return new ComparisonMachine<>(object, Element.class) + .equivalent(Element::getKeyvalue) + .equivalent(Element::getArray) + .equalAsObjects(Element::getLiteral) + .equalAsObjects(Element::getId) + .equalAsObjects(Element::getUnit) + .conclusion; + } + + @Override + public Boolean caseTypedVariable(TypedVariable object) { + throw thereIsAMoreSpecificCase(TypedVariable.class, Port.class, Action.class); + } + + @Override + public Boolean caseVariable(Variable object) { + throw thereIsAMoreSpecificCase(Variable.class, TypedVariable.class, Timer.class, Mode.class); + } + + @Override + public Boolean caseVarRef(VarRef object) { + return new ComparisonMachine<>(object, VarRef.class) + .equalAsObjects(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable().getName()) + .equivalent(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable()) + .equalAsObjects(varRef -> varRef.getContainer() == null ? null : varRef.getContainer().getName()) + .equalAsObjects(VarRef::isInterleaved) + .equalAsObjects(VarRef::getTransition) + .conclusion; + } + + @Override + public Boolean caseAssignment(Assignment object) { + return new ComparisonMachine<>(object, Assignment.class) + .equivalent(Assignment::getLhs) + .equivalent(Assignment::getRhs) + .conclusion; + } + + @Override + public Boolean caseParameter(Parameter object) { + return new ComparisonMachine<>(object, Parameter.class) + .listsEquivalent(Parameter::getAttributes) + .equalAsObjects(Parameter::getName) + .equivalent(Parameter::getType) + .equivalent(Parameter::getInit) + .conclusion; + } + + @Override + public Boolean caseExpression(Expression object) { + throw thereIsAMoreSpecificCase( + Expression.class, + Literal.class, + Time.class, + ParameterReference.class, + Code.class, + BracedListExpression.class + ); + } + + @Override + public Boolean caseBracedListExpression(BracedListExpression object) { + return new ComparisonMachine<>(object, BracedListExpression.class) + .listsEquivalent(BracedListExpression::getItems) + .conclusion; + } + + @Override + public Boolean caseParameterReference(ParameterReference object) { + return new ComparisonMachine<>(object, ParameterReference.class) + .equivalent(ParameterReference::getParameter) + .conclusion; + } + + @Override + public Boolean caseTime(Time object) { + return new ComparisonMachine<>(object, Time.class) + .equalAsObjects(Time::getInterval) + .equalAsObjectsModulo( + Time::getUnit, + ((Function) TimeUnit::getCanonicalName) + .compose(TimeUnit::fromName) + ) + .conclusion; + } + + @Override + public Boolean casePort(Port object) { + throw thereIsAMoreSpecificCase(Port.class, Input.class, Output.class); + } + + @Override + public Boolean caseType(Type object) { + return new ComparisonMachine<>(object, Type.class) + .equivalent(Type::getCode) + .equalAsObjects(Type::isTime) + .equivalent(Type::getArraySpec) + .equalAsObjects(Type::getId) + .listsEquivalent(Type::getTypeArgs) + .listsEqualAsObjects(Type::getStars) + .equivalent(Type::getArraySpec) + .equivalent(Type::getCode) + .conclusion; + } + + @Override + public Boolean caseArraySpec(ArraySpec object) { + return new ComparisonMachine<>(object, ArraySpec.class) + .equalAsObjects(ArraySpec::isOfVariableLength) + .equalAsObjects(ArraySpec::getLength) + .conclusion; + } + + @Override + public Boolean caseWatchdog(Watchdog object) { + return new ComparisonMachine<>(object, Watchdog.class) + .equalAsObjects(Watchdog::getName) + .equivalent(Watchdog::getTimeout) + .listsEquivalent(Watchdog::getEffects) + .equivalent(Watchdog::getCode) + .conclusion; + } + + @Override + public Boolean caseWidthSpec(WidthSpec object) { + return new ComparisonMachine<>(object, WidthSpec.class) + .equalAsObjects(WidthSpec::isOfVariableLength) + .listsEquivalent(WidthSpec::getTerms) + .conclusion; + } + + @Override + public Boolean caseWidthTerm(WidthTerm object) { + return new ComparisonMachine<>(object, WidthTerm.class) + .equalAsObjects(WidthTerm::getWidth) + .equivalent(WidthTerm::getParameter) + .equivalent(WidthTerm::getPort) + .equivalent(WidthTerm::getCode) + .conclusion; + } + + @Override + public Boolean caseIPV4Host(IPV4Host object) { + return caseHost(object); + } + + @Override + public Boolean caseIPV6Host(IPV6Host object) { + return caseHost(object); + } + + @Override + public Boolean caseNamedHost(NamedHost object) { + return caseHost(object); + } + + @Override + public Boolean caseHost(Host object) { + return new ComparisonMachine<>(object, Host.class) + .equalAsObjects(Host::getUser) + .equalAsObjects(Host::getAddr) + .equalAsObjects(Host::getPort) + .conclusion; + } + + @Override + public Boolean caseCodeExpr(CodeExpr object) { + return new ComparisonMachine<>(object, CodeExpr.class).equivalent(CodeExpr::getCode).conclusion; + } + + @Override + public Boolean caseCode(Code object) { + return new ComparisonMachine<>(object, Code.class) + .equalAsObjectsModulo( + Code::getBody, + s -> s == null ? null : s.strip().stripIndent() + ) + .conclusion; + } + + @Override + public Boolean caseLiteral(Literal object) { + return new ComparisonMachine<>(object, Literal.class) + .equalAsObjects(Literal::getLiteral) + .conclusion; + } + + @Override + public Boolean defaultCase(EObject object) { + return super.defaultCase(object); + } + + @SafeVarargs + private UnsupportedOperationException thereIsAMoreSpecificCase( + Class thisCase, + Class... moreSpecificCases + ) { + return new UnsupportedOperationException(String.format( "%ss are %s, so the methods " + "corresponding to those types should be invoked instead.", thisCase.getName(), Arrays.stream(moreSpecificCases) - .map(Class::getName) - .map(it -> it + (it.endsWith("s") ? "es" : "s")) - .collect(Collectors.joining(" or ")))); - } - - /** Fluently compare a pair of parse tree nodes for equivalence. */ - private class ComparisonMachine { - private final E object; - private final E other; - private boolean conclusion; - - ComparisonMachine(E object, Class clz) { - this.object = object; - this.conclusion = clz.isInstance(otherObject); - this.other = conclusion ? clz.cast(otherObject) : null; - } - - /** Conclude false if the two given Lists are different as EObject sequences. Order matters. */ - ComparisonMachine listsEquivalent(Function> listGetter) { - if (conclusion) - conclusion = listsEqualish(listGetter, (T a, T b) -> new IsEqual(a).doSwitch(b)); - return this; - } - - /** Conclude false if the two given Lists are different as object sequences. Order matters. */ - ComparisonMachine listsEqualAsObjects(Function> listGetter) { - if (conclusion) conclusion = listsEqualish(listGetter, Objects::equals); - return this; - } - - boolean listsEqualish( - Function> listGetter, BiPredicate equalish) { - if (!conclusion) return false; - List list0 = listGetter.apply(object); - List list1 = listGetter.apply(other); - if (list0 == list1) return true; // e.g., they are both null - if (list0.size() != list1.size()) return false; - for (int i = 0; i < list0.size(); i++) { - if (!equalish.test(list0.get(i), list1.get(i))) { - return false; + .map(Class::getName) + .map(it -> it + (it.endsWith("s") ? "es" : "s")) + .collect(Collectors.joining(" or ")) + )); + } + + /** Fluently compare a pair of parse tree nodes for equivalence. */ + private class ComparisonMachine { + private final E object; + private final E other; + private boolean conclusion; + + ComparisonMachine(E object, Class clz) { + this.object = object; + this.conclusion = clz.isInstance(otherObject); + this.other = conclusion ? clz.cast(otherObject) : null; + } + + /** + * Conclude false if the two given Lists are different as EObject + * sequences. Order matters. + */ + ComparisonMachine listsEquivalent(Function> listGetter) { + if (conclusion) conclusion = listsEqualish(listGetter, (T a, T b) -> new IsEqual(a).doSwitch(b)); + return this; + } + + /** + * Conclude false if the two given Lists are different as object + * sequences. Order matters. + */ + ComparisonMachine listsEqualAsObjects(Function> listGetter) { + if (conclusion) conclusion = listsEqualish(listGetter, Objects::equals); + return this; + } + + boolean listsEqualish(Function> listGetter, BiPredicate equalish) { + if (!conclusion) return false; + List list0 = listGetter.apply(object); + List list1 = listGetter.apply(other); + if (list0 == list1) return true; // e.g., they are both null + if (list0.size() != list1.size()) return false; + for (int i = 0; i < list0.size(); i++) { + if (!equalish.test(list0.get(i), list1.get(i))) { + return false; + } + } + return true; + } + + /** Conclude false if the two properties are not equal as objects. */ + ComparisonMachine equalAsObjects(Function propertyGetter) { + return equalAsObjectsModulo(propertyGetter, Function.identity()); + } + + /** + * Conclude false if the two properties are not equal as objects, + * given that {@code projectionToClassRepresentatives} maps each + * object to some semantically equivalent object. + */ + ComparisonMachine equalAsObjectsModulo( + Function propertyGetter, + Function projectionToClassRepresentatives + ) { + if (propertyGetter.apply(object) instanceof EObject) { + throw new IllegalArgumentException( + "EObjects should be compared for semantic equivalence, not object equality." + ); + } + propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); + if (conclusion) conclusion = Objects.equals(propertyGetter.apply(object), propertyGetter.apply(other)); + return this; + } + + /** + * Conclude false if the two properties are not semantically equivalent + * parse nodes. + */ + ComparisonMachine equivalent(Function propertyGetter) { + return equivalentModulo(propertyGetter, Function.identity()); + } + + /** + * Conclude false if the two properties are not semantically equivalent + * parse nodes, given that {@code projectionToClassRepresentatives} + * maps each parse node to some semantically equivalent node. + */ + ComparisonMachine equivalentModulo( + Function propertyGetter, + Function projectionToClassRepresentatives + ) { + propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); + if (conclusion) conclusion = new IsEqual(propertyGetter.apply(object)) + .doSwitch(propertyGetter.apply(other)); + return this; } - } - return true; - } - - /** Conclude false if the two properties are not equal as objects. */ - ComparisonMachine equalAsObjects(Function propertyGetter) { - return equalAsObjectsModulo(propertyGetter, Function.identity()); - } - - /** - * Conclude false if the two properties are not equal as objects, given that {@code - * projectionToClassRepresentatives} maps each object to some semantically equivalent object. - */ - ComparisonMachine equalAsObjectsModulo( - Function propertyGetter, Function projectionToClassRepresentatives) { - if (propertyGetter.apply(object) instanceof EObject) { - throw new IllegalArgumentException( - "EObjects should be compared for semantic equivalence, not object equality."); - } - propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); - if (conclusion) - conclusion = Objects.equals(propertyGetter.apply(object), propertyGetter.apply(other)); - return this; - } - - /** Conclude false if the two properties are not semantically equivalent parse nodes. */ - ComparisonMachine equivalent(Function propertyGetter) { - return equivalentModulo(propertyGetter, Function.identity()); - } - - /** - * Conclude false if the two properties are not semantically equivalent parse nodes, given that - * {@code projectionToClassRepresentatives} maps each parse node to some semantically equivalent - * node. - */ - ComparisonMachine equivalentModulo( - Function propertyGetter, Function projectionToClassRepresentatives) { - propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); - if (conclusion) - conclusion = - new IsEqual(propertyGetter.apply(object)).doSwitch(propertyGetter.apply(other)); - return this; - } - } + } } From b7e902b4918a8ccb489037c7fc8ed3e2798831c2 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 30 Apr 2023 11:17:06 +0200 Subject: [PATCH 213/709] Merge master changes in --- org.lflang/src/org/lflang/TargetConfig.java | 16 +-- org.lflang/src/org/lflang/util/FileUtil.java | 111 ++++++++++++++++++- 2 files changed, 109 insertions(+), 18 deletions(-) diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 23e99541da..845f214ec8 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -172,13 +172,6 @@ public TargetConfig( */ public List cmakeIncludes = new ArrayList<>(); - /** - * List of cmake-includes from the cmake-include target property with no path info. - * Useful for copying them to remote machines. This is needed because - * target cmake-includes can be resources with resource paths. - */ - public List cmakeIncludesWithoutPath = new ArrayList<>(); - /** * The compiler to invoke, unless a build command has been specified. */ @@ -237,14 +230,7 @@ public TargetConfig( /** * List of files to be copied to src-gen. */ - public List fileNames = new ArrayList<>(); - - /** - * List of file names from the files target property with no path info. - * Useful for copying them to remote machines. This is needed because - * target files can be resources with resource paths. - */ - public List filesNamesWithoutPath = new ArrayList<>(); + public List files = new ArrayList<>(); /** * If true, configure the execution environment to keep executing if there diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index d4d34c7b08..a2cfb81e4d 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -36,7 +36,9 @@ import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.util.RuntimeIOException; +import org.lflang.ErrorReporter; import org.lflang.FileConfig; +import org.lflang.generator.LFGeneratorContext; public class FileUtil { @@ -150,7 +152,7 @@ public static java.net.URI locateFile(String path, Resource resource) { sourceURI = iFile != null ? iFile.getRawLocation().toFile().getParentFile().toURI() : null; } if (sourceURI != null) { - return sourceURI.resolve(path.toString()); + return sourceURI.resolve(path); } } catch (Exception e) { // nothing @@ -239,6 +241,68 @@ public static void copyFile(Path source, Path destination) throws IOException { copyFile(source, destination, false); } + /** + * Given a list of files or directories, attempt to find them based on the given generator + * context, and copy then to the destination. Files are searched for in the file system first. + * Files that cannot be found in the file system are looked for on the class path. + * + * @param filesOrDirectories The files or directories to copy. + * @param destination The location to copy them to. + * @param fileConfig The file configuration that specifies where the files must be found. + * @param errorReporter An error reporter to report problems. + */ + public static void copyFiles( + List filesOrDirectories, + Path destination, + FileConfig fileConfig, + ErrorReporter errorReporter + ) { + for (String fileOrDirectory : filesOrDirectories) { + var path = Paths.get(fileOrDirectory); + var found = FileUtil.findInPackage(path, fileConfig); + if (found != null) { + try { + FileUtil.copyFileOrDirectory(found, destination.resolve(found.getFileName())); + } catch (IOException e) { + errorReporter.reportError( + "Unable to copy '" + fileOrDirectory + "' from the file system." + ); + } + } else { + // Attempt to copy from the classpath instead. + // If the filename is not a directory, it will + // just be copied without further recursion. + try { + FileUtil.copyDirectoryFromClassPath( + fileOrDirectory, + destination, + false + ); + } catch (IOException e) { + errorReporter.reportError( + "Unable to copy '" + fileOrDirectory + "' from the class path." + ); + } + } + } + } + + /** + * If the source is a directory, then copy the contents of the directory to the destination. + * If the source is a file, then copy the file to the destination. + * @param source A file or directory to copy to the destination. + * @param destination A directory to copy the file(s) at the source to. + * @throws IOException + */ + public static void copyFileOrDirectory(Path source, Path destination) throws IOException { + if (Files.isDirectory(source)) { + copyDirectory(source, destination); + } else if (Files.isRegularFile(source)) { + copyFile(source, destination); + } else { + throw new IllegalArgumentException("Source is neither a directory nor a regular file."); + } + } /** * Copy a given input stream to a destination file. * @@ -359,6 +423,7 @@ private static boolean copyDirectoryFromJar(JarURLConnection connection, final P final String connectionEntryName = connection.getEntryName(); boolean copiedFiles = false; + // Iterate all entries in the jar file. for (Enumeration e = jar.entries(); e.hasMoreElements(); ) { final JarEntry entry = e.nextElement(); @@ -366,9 +431,10 @@ private static boolean copyDirectoryFromJar(JarURLConnection connection, final P // Extract files only if they match the given source path. if (entryName.startsWith(connectionEntryName)) { - String filename = entry.getName().substring(connectionEntryName.length() + 1); + String filename = entryName.equals(connectionEntryName) ? + connectionEntryName : + entryName.substring(connectionEntryName.length() + 1); Path currentFile = destination.resolve(filename); - if (entry.isDirectory()) { Files.createDirectories(currentFile); } else { @@ -511,6 +577,45 @@ public static void deleteDirectory(Path dir) throws IOException { } } + /** + * Return an absolute path to the given file or directory if it can be found within the package. + * Otherwise, return null. + * + * NOTE: If the given file or directory is given as an absolute path but cannot be found, it is + * interpreted as a relative path with respect to the project root. + * + * @param fileOrDirectory The file or directory to look for. + * @param fileConfig A file configuration that determines where the package is located. + * @return An absolute path of the file or directory was found; null otherwise. + */ + public static Path findInPackage(Path fileOrDirectory, FileConfig fileConfig) { + if (fileOrDirectory.isAbsolute() && Files.exists(fileOrDirectory)) { + return fileOrDirectory; + } else { + Path relPath; + // Disregard root and interpret as relative path + if (fileOrDirectory.isAbsolute()) { + relPath = Paths.get( + String.valueOf(fileOrDirectory).replaceFirst( + String.valueOf(fileOrDirectory.getRoot()), + "") + ); + } else { + relPath = fileOrDirectory; + } + + // Look relative to the source file and relative to the package root. + var locations = List.of(fileConfig.srcPath, fileConfig.srcPkgPath); + var found = locations.stream().filter( + loc -> Files.exists(loc.resolve(relPath)) + ).findFirst(); + if (found.isPresent()) { + return found.get().resolve(relPath); + } + } + return null; + } + /** * Get the iResource corresponding to the provided resource if it can be * found. From 5159e0a7cc0aa96b7ad64fe595f50b6f6f3bf3ae Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 30 Apr 2023 11:17:15 +0200 Subject: [PATCH 214/709] Undo formatting changes --- .../org/lflang/generator/GeneratorBase.java | 1144 +++++++++-------- 1 file changed, 576 insertions(+), 568 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 9ae46ad357..4cae3f7cf1 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -24,23 +24,23 @@ ***************/ package org.lflang.generator; -import com.google.common.base.Objects; -import com.google.common.collect.Iterables; import java.io.IOException; import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; -import java.util.LinkedHashMap; import java.util.LinkedHashSet; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Set; + import org.eclipse.core.resources.IMarker; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.IteratorExtensions; + import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; @@ -53,12 +53,18 @@ import org.lflang.lf.Instantiation; import org.lflang.lf.LfFactory; import org.lflang.lf.Mode; + import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; +import org.lflang.util.FileUtil; import org.lflang.validation.AbstractLFValidator; +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; + /** - * Generator base class for specifying core functionality that all code generators should have. + * Generator base class for specifying core functionality + * that all code generators should have. * * @author Edward A. Lee * @author Marten Lohstroh @@ -68,595 +74,597 @@ */ public abstract class GeneratorBase extends AbstractLFValidator { - //////////////////////////////////////////// - //// Public fields. - - /** The main (top-level) reactor instance. */ - public ReactorInstance main; - - /** An error reporter for reporting any errors or warnings during the code generation */ - public ErrorReporter errorReporter; - - //////////////////////////////////////////// - //// Protected fields. - - /** The current target configuration. */ - protected final TargetConfig targetConfig; - - public TargetConfig getTargetConfig() { - return this.targetConfig; - } - - public final LFGeneratorContext context; - - /** A factory for compiler commands. */ - protected GeneratorCommandFactory commandFactory; - - public GeneratorCommandFactory getCommandFactory() { - return commandFactory; - } - - /** - * Definition of the main (top-level) reactor. This is an automatically generated AST node for the - * top-level reactor. - */ - protected Instantiation mainDef; - - public Instantiation getMainDef() { - return mainDef; - } - - /** - * A list of Reactor definitions in the main resource, including non-main reactors defined in - * imported resources. These are ordered in the list in such a way that each reactor is preceded - * by any reactor that it instantiates using a command like `foo = new Foo();` - */ - protected List reactors = new ArrayList<>(); - - /** The set of resources referenced reactor classes reside in. */ - protected Set resources = new LinkedHashSet<>(); // FIXME: Why do we need this? - - /** - * Graph that tracks dependencies between instantiations. This is a graph where each node is a - * Reactor (not a ReactorInstance) and an arc from Reactor A to Reactor B means that B contains an - * instance of A, constructed with a statement like `a = new A();` After creating the graph, sort - * the reactors in topological order and assign them to the reactors class variable. Hence, after - * this method returns, `this.reactors` will be a list of Reactors such that any reactor is - * preceded in the list by reactors that it instantiates. - */ - protected InstantiationGraph instantiationGraph; - - /** - * The set of unordered reactions. An unordered reaction is one that does not have any dependency - * on other reactions in the containing reactor, and where no other reaction in the containing - * reactor depends on it. There is currently no way in the syntax of LF to make a reaction - * unordered, deliberately, because it can introduce unexpected nondeterminacy. However, certain - * automatically generated reactions are known to be safe to be unordered because they do not - * interact with the state of the containing reactor. To make a reaction unordered, when the - * Reaction instance is created, add that instance to this set. - */ - protected Set unorderedReactions = null; - - /** Map from reactions to bank indices */ - protected Map reactionBankIndices = null; - - /** Indicates whether the current Lingua Franca program contains model reactors. */ - public boolean hasModalReactors = false; - - /** - * Indicates whether the program has any deadlines and thus needs to propagate deadlines through - * the reaction instance graph - */ - public boolean hasDeadlines = false; - - /** Indicates whether the program has any watchdogs. This is used to check for support. */ - public boolean hasWatchdogs = false; - - // ////////////////////////////////////////// - // // Private fields. - - /** A list ot AST transformations to apply before code generation */ - private final List astTransformations = new ArrayList<>(); - - /** Create a new GeneratorBase object. */ - public GeneratorBase(LFGeneratorContext context) { - this.context = context; - this.targetConfig = context.getTargetConfig(); - this.errorReporter = context.getErrorReporter(); - this.commandFactory = new GeneratorCommandFactory(errorReporter, context.getFileConfig()); - } - - /** - * Register an AST transformation to be applied to the AST. - * - *

The transformations will be applied in the order that they are registered in. - */ - protected void registerTransformation(AstTransformation transformation) { - astTransformations.add(transformation); - } - - // ////////////////////////////////////////// - // // Code generation functions to override for a concrete code generator. - - /** - * If there is a main or federated reactor, then create a synthetic Instantiation for that - * top-level reactor and set the field mainDef to refer to it. - */ - private void createMainInstantiation() { - // Find the main reactor and create an AST node for its instantiation. - Iterable nodes = - IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); - for (Reactor reactor : Iterables.filter(nodes, Reactor.class)) { - if (reactor.isMain()) { - // Creating a definition for the main reactor because there isn't one. - this.mainDef = LfFactory.eINSTANCE.createInstantiation(); - this.mainDef.setName(reactor.getName()); - this.mainDef.setReactorClass(reactor); - } + //////////////////////////////////////////// + //// Public fields. + + /** + * The main (top-level) reactor instance. + */ + public ReactorInstance main; + + /** An error reporter for reporting any errors or warnings during the code generation */ + public ErrorReporter errorReporter; + + //////////////////////////////////////////// + //// Protected fields. + + /** + * The current target configuration. + */ + protected final TargetConfig targetConfig; + + public TargetConfig getTargetConfig() { return this.targetConfig;} + + public final LFGeneratorContext context; + + /** + * A factory for compiler commands. + */ + protected GeneratorCommandFactory commandFactory; + + public GeneratorCommandFactory getCommandFactory() { return commandFactory; } + + /** + * Definition of the main (top-level) reactor. + * This is an automatically generated AST node for the top-level + * reactor. + */ + protected Instantiation mainDef; + public Instantiation getMainDef() { return mainDef; } + + /** + * A list of Reactor definitions in the main resource, including non-main + * reactors defined in imported resources. These are ordered in the list in + * such a way that each reactor is preceded by any reactor that it instantiates + * using a command like `foo = new Foo();` + */ + protected List reactors = new ArrayList<>(); + + /** + * The set of resources referenced reactor classes reside in. + */ + protected Set resources = new LinkedHashSet<>(); // FIXME: Why do we need this? + + /** + * Graph that tracks dependencies between instantiations. + * This is a graph where each node is a Reactor (not a ReactorInstance) + * and an arc from Reactor A to Reactor B means that B contains an instance of A, constructed with a statement + * like `a = new A();` After creating the graph, + * sort the reactors in topological order and assign them to the reactors class variable. + * Hence, after this method returns, `this.reactors` will be a list of Reactors such that any + * reactor is preceded in the list by reactors that it instantiates. + */ + protected InstantiationGraph instantiationGraph; + + /** + * The set of unordered reactions. An unordered reaction is one that does + * not have any dependency on other reactions in the containing reactor, + * and where no other reaction in the containing reactor depends on it. + * There is currently no way in the syntax of LF to make a reaction + * unordered, deliberately, because it can introduce unexpected + * nondeterminacy. However, certain automatically generated reactions are + * known to be safe to be unordered because they do not interact with the + * state of the containing reactor. To make a reaction unordered, when + * the Reaction instance is created, add that instance to this set. + */ + protected Set unorderedReactions = null; + + /** + * Map from reactions to bank indices + */ + protected Map reactionBankIndices = null; + + /** + * Indicates whether the current Lingua Franca program + * contains model reactors. + */ + public boolean hasModalReactors = false; + + /** + * Indicates whether the program has any deadlines and thus + * needs to propagate deadlines through the reaction instance graph + */ + public boolean hasDeadlines = false; + + /** Indicates whether the program has any watchdogs. This is used to check for support. */ + public boolean hasWatchdogs = false; + + // ////////////////////////////////////////// + // // Private fields. + + /** + * A list ot AST transformations to apply before code generation + */ + private final List astTransformations = new ArrayList<>(); + + /** + * Create a new GeneratorBase object. + */ + public GeneratorBase(LFGeneratorContext context) { + this.context = context; + this.targetConfig = context.getTargetConfig(); + this.errorReporter = context.getErrorReporter(); + this.commandFactory = new GeneratorCommandFactory(errorReporter, context.getFileConfig()); } - } - - /** - * Generate code from the Lingua Franca model contained by the specified resource. - * - *

This is the main entry point for code generation. This base class finds all reactor class - * definitions, including any reactors defined in imported .lf files (except any main reactors in - * those imported files), and adds them to the {@link GeneratorBase#reactors reactors} list. If - * errors occur during generation, then a subsequent call to errorsOccurred() will return true. - * - * @param resource The resource containing the source code. - * @param context Context relating to invocation of the code generator. In standalone mode, this - * object is also used to relay CLI arguments. - */ - public void doGenerate(Resource resource, LFGeneratorContext context) { - - // FIXME: the signature can be reduced to only take context. - // The constructor also need not take a file config because this is tied to the context as well. - cleanIfNeeded(context); - - printInfo(context.getMode()); - - // Clear any IDE markers that may have been created by a previous build. - // Markers mark problems in the Eclipse IDE when running in integrated mode. - errorReporter.clearHistory(); - - ASTUtils.setMainName(context.getFileConfig().resource, context.getFileConfig().name); - - createMainInstantiation(); - - // Check if there are any conflicting main reactors elsewhere in the package. - if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && mainDef != null) { - for (String conflict : new MainConflictChecker(context.getFileConfig()).conflicts) { - errorReporter.reportError( - this.mainDef.getReactorClass(), "Conflicting main reactor in " + conflict); - } + + /** + * Register an AST transformation to be applied to the AST. + * + * The transformations will be applied in the order that they are registered in. + */ + protected void registerTransformation(AstTransformation transformation) { + astTransformations.add(transformation); } - // Configure the command factory - commandFactory.setVerbose(); - if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) - && context.getArgs().containsKey("quiet")) { - commandFactory.setQuiet(); + // ////////////////////////////////////////// + // // Code generation functions to override for a concrete code generator. + + /** + * If there is a main or federated reactor, then create a synthetic Instantiation + * for that top-level reactor and set the field mainDef to refer to it. + */ + private void createMainInstantiation() { + // Find the main reactor and create an AST node for its instantiation. + Iterable nodes = IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); + for (Reactor reactor : Iterables.filter(nodes, Reactor.class)) { + if (reactor.isMain()) { + // Creating a definition for the main reactor because there isn't one. + this.mainDef = LfFactory.eINSTANCE.createInstantiation(); + this.mainDef.setName(reactor.getName()); + this.mainDef.setReactorClass(reactor); + } + } } - // Process target files. Copy each of them into the src-gen dir. - // FIXME: Should we do this here? This doesn't make sense for federates the way it is - // done here. - copyUserFiles(this.targetConfig, context.getFileConfig()); - - // Collect reactors and create an instantiation graph. - // These are needed to figure out which resources we need - // to validate, which happens in setResources(). - setReactorsAndInstantiationGraph(context.getMode()); - - List allResources = GeneratorUtils.getResources(reactors); - resources.addAll( - allResources - .stream() // FIXME: This filter reproduces the behavior of the method it replaces. But - // why must it be so complicated? Why are we worried about weird corner cases - // like this? - .filter( - it -> - !Objects.equal(it, context.getFileConfig().resource) - || mainDef != null && it == mainDef.getReactorClass().eResource()) - .map( - it -> - GeneratorUtils.getLFResource( - it, context.getFileConfig().getSrcGenBasePath(), context, errorReporter)) - .toList()); - GeneratorUtils.accommodatePhysicalActionsIfPresent( - allResources, getTarget().setsKeepAliveOptionAutomatically(), targetConfig, errorReporter); - // FIXME: Should the GeneratorBase pull in `files` from imported - // resources? - - for (AstTransformation transformation : astTransformations) { - transformation.applyTransformation(reactors); + /** + * Generate code from the Lingua Franca model contained by the specified resource. + * + * This is the main entry point for code generation. This base class finds all + * reactor class definitions, including any reactors defined in imported .lf files + * (except any main reactors in those imported files), and adds them to the + * {@link GeneratorBase#reactors reactors} list. If errors occur during + * generation, then a subsequent call to errorsOccurred() will return true. + * @param resource The resource containing the source code. + * @param context Context relating to invocation of the code generator. + * In standalone mode, this object is also used to relay CLI arguments. + */ + public void doGenerate(Resource resource, LFGeneratorContext context) { + + // FIXME: the signature can be reduced to only take context. + // The constructor also need not take a file config because this is tied to the context as well. + cleanIfNeeded(context); + + printInfo(context.getMode()); + + // Clear any IDE markers that may have been created by a previous build. + // Markers mark problems in the Eclipse IDE when running in integrated mode. + errorReporter.clearHistory(); + + ASTUtils.setMainName(context.getFileConfig().resource, context.getFileConfig().name); + + createMainInstantiation(); + + // Check if there are any conflicting main reactors elsewhere in the package. + if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && mainDef != null) { + for (String conflict : new MainConflictChecker(context.getFileConfig()).conflicts) { + errorReporter.reportError(this.mainDef.getReactorClass(), "Conflicting main reactor in " + conflict); + } + } + + // Configure the command factory + commandFactory.setVerbose(); + if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && context.getArgs().containsKey("quiet")) { + commandFactory.setQuiet(); + } + + // Process target files. Copy each of them into the src-gen dir. + // FIXME: Should we do this here? This doesn't make sense for federates the way it is + // done here. + copyUserFiles(this.targetConfig, context.getFileConfig()); + + // Collect reactors and create an instantiation graph. + // These are needed to figure out which resources we need + // to validate, which happens in setResources(). + setReactorsAndInstantiationGraph(context.getMode()); + + List allResources = GeneratorUtils.getResources(reactors); + resources.addAll(allResources.stream() // FIXME: This filter reproduces the behavior of the method it replaces. But why must it be so complicated? Why are we worried about weird corner cases like this? + .filter(it -> !Objects.equal(it, context.getFileConfig().resource) || mainDef != null && it == mainDef.getReactorClass().eResource()) + .map(it -> GeneratorUtils.getLFResource(it, context.getFileConfig().getSrcGenBasePath(), context, errorReporter)) + .toList() + ); + GeneratorUtils.accommodatePhysicalActionsIfPresent( + allResources, + getTarget().setsKeepAliveOptionAutomatically(), + targetConfig, + errorReporter + ); + // FIXME: Should the GeneratorBase pull in `files` from imported + // resources? + + for (AstTransformation transformation : astTransformations) { + transformation.applyTransformation(reactors); + } + + // Transform connections that reside in mutually exclusive modes and are otherwise conflicting + // This should be done before creating the instantiation graph + transformConflictingConnectionsInModalReactors(); + + // Invoke these functions a second time because transformations + // may have introduced new reactors! + setReactorsAndInstantiationGraph(context.getMode()); + + // Check for existence and support of modes + hasModalReactors = IterableExtensions.exists(reactors, it -> !it.getModes().isEmpty()); + checkModalReactorSupport(false); + + // Check for the existence and support of watchdogs + hasWatchdogs = IterableExtensions.exists(reactors, it -> !it.getWatchdogs().isEmpty()); + checkWatchdogSupport(targetConfig.threading && getTarget() == Target.C); + additionalPostProcessingForModes(); } - // Transform connections that reside in mutually exclusive modes and are otherwise conflicting - // This should be done before creating the instantiation graph - transformConflictingConnectionsInModalReactors(); - - // Invoke these functions a second time because transformations - // may have introduced new reactors! - setReactorsAndInstantiationGraph(context.getMode()); - - // Check for existence and support of modes - hasModalReactors = IterableExtensions.exists(reactors, it -> !it.getModes().isEmpty()); - checkModalReactorSupport(false); - - // Check for the existence and support of watchdogs - hasWatchdogs = IterableExtensions.exists(reactors, it -> !it.getWatchdogs().isEmpty()); - checkWatchdogSupport(targetConfig.threading && getTarget() == Target.C); - additionalPostProcessingForModes(); - } - - /** Check if a clean was requested from the standalone compiler and perform the clean step. */ - protected void cleanIfNeeded(LFGeneratorContext context) { - if (context.getArgs().containsKey("clean")) { - try { - context.getFileConfig().doClean(); - } catch (IOException e) { - System.err.println("WARNING: IO Error during clean"); - } + /** + * Check if a clean was requested from the standalone compiler and perform + * the clean step. + */ + protected void cleanIfNeeded(LFGeneratorContext context) { + if (context.getArgs().containsKey("clean")) { + try { + context.getFileConfig().doClean(); + } catch (IOException e) { + System.err.println("WARNING: IO Error during clean"); + } + } } - } - - /** - * Create a new instantiation graph. This is a graph where each node is a Reactor (not a - * ReactorInstance) and an arc from Reactor A to Reactor B means that B contains an instance of A, - * constructed with a statement like `a = new A();` After creating the graph, sort the reactors in - * topological order and assign them to the reactors class variable. Hence, after this method - * returns, `this.reactors` will be a list of Reactors such that any reactor is preceded in the - * list by reactors that it instantiates. - */ - protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { - // Build the instantiation graph . - instantiationGraph = new InstantiationGraph(context.getFileConfig().resource, false); - - // Topologically sort the reactors such that all of a reactor's instantiation dependencies occur - // earlier in - // the sorted list of reactors. This helps the code generator output code in the correct order. - // For example if `reactor Foo {bar = new Bar()}` then the definition of `Bar` has to be - // generated before - // the definition of `Foo`. - reactors = instantiationGraph.nodesInTopologicalOrder(); - - // If there is no main reactor or if all reactors in the file need to be validated, then make - // sure the reactors - // list includes even reactors that are not instantiated anywhere. - if (mainDef == null || Objects.equal(mode, LFGeneratorContext.Mode.LSP_MEDIUM)) { - Iterable nodes = - IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); - for (Reactor r : IterableExtensions.filter(nodes, Reactor.class)) { - if (!reactors.contains(r)) { - reactors.add(r); + + /** + * Create a new instantiation graph. This is a graph where each node is a Reactor (not a ReactorInstance) + * and an arc from Reactor A to Reactor B means that B contains an instance of A, constructed with a statement + * like `a = new A();` After creating the graph, + * sort the reactors in topological order and assign them to the reactors class variable. + * Hence, after this method returns, `this.reactors` will be a list of Reactors such that any + * reactor is preceded in the list by reactors that it instantiates. + */ + protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { + // Build the instantiation graph . + instantiationGraph = new InstantiationGraph(context.getFileConfig().resource, false); + + // Topologically sort the reactors such that all of a reactor's instantiation dependencies occur earlier in + // the sorted list of reactors. This helps the code generator output code in the correct order. + // For example if `reactor Foo {bar = new Bar()}` then the definition of `Bar` has to be generated before + // the definition of `Foo`. + reactors = instantiationGraph.nodesInTopologicalOrder(); + + // If there is no main reactor or if all reactors in the file need to be validated, then make sure the reactors + // list includes even reactors that are not instantiated anywhere. + if (mainDef == null || Objects.equal(mode, LFGeneratorContext.Mode.LSP_MEDIUM)) { + Iterable nodes = IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); + for (Reactor r : IterableExtensions.filter(nodes, Reactor.class)) { + if (!reactors.contains(r)) { + reactors.add(r); + } + } } - } } - } - - /** - * Copy user specific files to the src-gen folder. - * - *

This should be overridden by the target generators. - * - * @param targetConfig The targetConfig to read the `files` from. - * @param fileConfig The fileConfig used to make the copy and resolve paths. - */ - protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) {} - - /** - * Return true if errors occurred in the last call to doGenerate(). This will return true if any - * of the reportError methods was called. - * - * @return True if errors occurred. - */ - public boolean errorsOccurred() { - return errorReporter.getErrorsOccurred(); - } - - /* - * Return the TargetTypes instance associated with this. - */ - public abstract TargetTypes getTargetTypes(); - - /** - * Mark the reaction unordered. An unordered reaction is one that does not have any dependency on - * other reactions in the containing reactor, and where no other reaction in the containing - * reactor depends on it. There is currently no way in the syntax of LF to make a reaction - * unordered, deliberately, because it can introduce unexpected nondeterminacy. However, certain - * automatically generated reactions are known to be safe to be unordered because they do not - * interact with the state of the containing reactor. To make a reaction unordered, when the - * Reaction instance is created, add that instance to this set. - * - * @param reaction The reaction to make unordered. - */ - public void makeUnordered(Reaction reaction) { - if (unorderedReactions == null) { - unorderedReactions = new LinkedHashSet<>(); + + /** + * Copy user specific files to the src-gen folder. + * + * This should be overridden by the target generators. + * + * @param targetConfig The targetConfig to read the `files` from. + * @param fileConfig The fileConfig used to make the copy and resolve paths. + */ + protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + FileUtil.copyFiles(targetConfig.files, this.context.getFileConfig().getSrcGenPath(), fileConfig, errorReporter); + } + + /** + * Return true if errors occurred in the last call to doGenerate(). + * This will return true if any of the reportError methods was called. + * @return True if errors occurred. + */ + public boolean errorsOccurred() { + return errorReporter.getErrorsOccurred(); } - unorderedReactions.add(reaction); - } - - /** - * Mark the specified reaction to belong to only the specified bank index. This is needed because - * reactions cannot declare a specific bank index as an effect or trigger. Reactions that send - * messages between federates, including absent messages, need to be specific to a bank member. - * - * @param reaction The reaction. - * @param bankIndex The bank index, or -1 if there is no bank. - */ - public void setReactionBankIndex(Reaction reaction, int bankIndex) { - if (bankIndex < 0) { - return; + + /* + * Return the TargetTypes instance associated with this. + */ + public abstract TargetTypes getTargetTypes(); + + /** + * Mark the reaction unordered. An unordered reaction is one that does not + * have any dependency on other reactions in the containing reactor, and + * where no other reaction in the containing reactor depends on it. There + * is currently no way in the syntax of LF to make a reaction unordered, + * deliberately, because it can introduce unexpected nondeterminacy. + * However, certain automatically generated reactions are known to be safe + * to be unordered because they do not interact with the state of the + * containing reactor. To make a reaction unordered, when the Reaction + * instance is created, add that instance to this set. + * @param reaction The reaction to make unordered. + */ + public void makeUnordered(Reaction reaction) { + if (unorderedReactions == null) { + unorderedReactions = new LinkedHashSet<>(); + } + unorderedReactions.add(reaction); } - if (reactionBankIndices == null) { - reactionBankIndices = new LinkedHashMap<>(); + + /** + * Mark the specified reaction to belong to only the specified + * bank index. This is needed because reactions cannot declare + * a specific bank index as an effect or trigger. Reactions that + * send messages between federates, including absent messages, + * need to be specific to a bank member. + * @param reaction The reaction. + * @param bankIndex The bank index, or -1 if there is no bank. + */ + public void setReactionBankIndex(Reaction reaction, int bankIndex) { + if (bankIndex < 0) { + return; + } + if (reactionBankIndices == null) { + reactionBankIndices = new LinkedHashMap<>(); + } + reactionBankIndices.put(reaction, bankIndex); } - reactionBankIndices.put(reaction, bankIndex); - } - - /** - * Return the reaction bank index. - * - * @see #setReactionBankIndex(Reaction reaction, int bankIndex) - * @param reaction The reaction. - * @return The reaction bank index, if one has been set, and -1 otherwise. - */ - public int getReactionBankIndex(Reaction reaction) { - if (reactionBankIndices == null) return -1; - if (reactionBankIndices.get(reaction) == null) return -1; - return reactionBankIndices.get(reaction); - } - - // ////////////////////////////////////////// - // // Protected methods. - - /** - * Checks whether modal reactors are present and require appropriate code generation. This will - * set the hasModalReactors variable. - * - * @param isSupported indicates if modes are supported by this code generation. - */ - protected void checkModalReactorSupport(boolean isSupported) { - if (hasModalReactors && !isSupported) { - errorReporter.reportError( - "The currently selected code generation or " - + "target configuration does not support modal reactors!"); + + /** + * Return the reaction bank index. + * @see #setReactionBankIndex(Reaction reaction, int bankIndex) + * @param reaction The reaction. + * @return The reaction bank index, if one has been set, and -1 otherwise. + */ + public int getReactionBankIndex(Reaction reaction) { + if (reactionBankIndices == null) return -1; + if (reactionBankIndices.get(reaction) == null) return -1; + return reactionBankIndices.get(reaction); } - } - - /** - * Checks whether watchdogs are present and are supported. - * - * @param isSupported indicates whether or not this is a supported target and whether or not it is - * a threaded runtime. - */ - protected void checkWatchdogSupport(boolean isSupported) { - if (hasWatchdogs && !isSupported) { - errorReporter.reportError( - "Watchdogs are currently only supported for threaded programs in the C target."); + + // ////////////////////////////////////////// + // // Protected methods. + + /** + * Checks whether modal reactors are present and require appropriate code generation. + * This will set the hasModalReactors variable. + * @param isSupported indicates if modes are supported by this code generation. + */ + protected void checkModalReactorSupport(boolean isSupported) { + if (hasModalReactors && !isSupported) { + errorReporter.reportError("The currently selected code generation or " + + "target configuration does not support modal reactors!"); + } } - } - - /** - * Finds and transforms connections into forwarding reactions iff the connections have the same - * destination as other connections or reaction in mutually exclusive modes. - */ - private void transformConflictingConnectionsInModalReactors() { - for (LFResource r : resources) { - var transform = ASTUtils.findConflictingConnectionsInModalReactors(r.eResource); - if (!transform.isEmpty()) { - var factory = LfFactory.eINSTANCE; - for (Connection connection : transform) { - // Currently only simple transformations are supported - if (connection.isPhysical() - || connection.getDelay() != null - || connection.isIterated() - || connection.getLeftPorts().size() > 1 - || connection.getRightPorts().size() > 1) { + + /** + * Check whether watchdogs are present and are supported. + * + * @param isSupported indicates whether or not this is a supported target and whether or not it + * is + * a threaded runtime. + */ + protected void checkWatchdogSupport(boolean isSupported) { + if (hasWatchdogs && !isSupported) { errorReporter.reportError( - connection, - "Cannot transform connection in modal reactor. Connection uses currently not" - + " supported features."); - } else { - var reaction = factory.createReaction(); - ((Mode) connection.eContainer()).getReactions().add(reaction); - - var sourceRef = connection.getLeftPorts().get(0); - var destRef = connection.getRightPorts().get(0); - reaction.getTriggers().add(sourceRef); - reaction.getEffects().add(destRef); - - var code = factory.createCode(); - var source = - (sourceRef.getContainer() != null ? sourceRef.getContainer().getName() + "." : "") - + sourceRef.getVariable().getName(); - var dest = - (destRef.getContainer() != null ? destRef.getContainer().getName() + "." : "") - + destRef.getVariable().getName(); - code.setBody(getConflictingConnectionsInModalReactorsBody(source, dest)); - reaction.setCode(code); - - EcoreUtil.remove(connection); - } + "Watchdogs are currently only supported for threaded programs in the C target."); } - } - } - } - /** - * Return target code for forwarding reactions iff the connections have the same destination as - * other connections or reaction in mutually exclusive modes. - * - *

This method needs to be overridden in target specific code generators that support modal - * reactors. - */ - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - errorReporter.reportError( - "The currently selected code generation " - + "is missing an implementation for conflicting " - + "transforming connections in modal reactors."); - return "MODAL MODELS NOT SUPPORTED"; - } - - /** Hook for additional post-processing of the model. */ - protected void additionalPostProcessingForModes() { - // Do nothing - } - - /** Parsed error message from a compiler is returned here. */ - public static class ErrorFileAndLine { - public String filepath = null; - public String line = "1"; - public String character = "0"; - public String message = ""; - public boolean isError = true; // false for a warning. - - @Override - public String toString() { - return (isError ? "Error" : "Non-error") - + " at " - + line - + ":" - + character - + " of file " - + filepath - + ": " - + message; } - } - - /** - * Given a line of text from the output of a compiler, return an instance of ErrorFileAndLine if - * the line is recognized as the first line of an error message. Otherwise, return null. This base - * class simply returns null. - * - * @param line A line of output from a compiler or other external tool that might generate errors. - * @return If the line is recognized as the start of an error message, then return a class - * containing the path to the file on which the error occurred (or null if there is none), the - * line number (or the string "1" if there is none), the character position (or the string "0" - * if there is none), and the message (or an empty string if there is none). - */ - protected ErrorFileAndLine parseCommandOutput(String line) { - return null; - } - - /** - * Parse the specified string for command errors that can be reported using marks in the Eclipse - * IDE. In this class, we attempt to parse the messages to look for file and line information, - * thereby generating marks on the appropriate lines. This should not be called in standalone - * mode. - * - * @param stderr The output on standard error of executing a command. - */ - public void reportCommandErrors(String stderr) { - // NOTE: If the VS Code branch passes code review, then this function, - // parseCommandOutput, and ErrorFileAndLine will be deleted soon after. - // First, split the message into lines. - String[] lines = stderr.split("\\r?\\n"); - StringBuilder message = new StringBuilder(); - Integer lineNumber = null; - Path path = context.getFileConfig().srcFile; - // In case errors occur within an imported file, record the original path. - Path originalPath = path; - - int severity = IMarker.SEVERITY_ERROR; - for (String line : lines) { - ErrorFileAndLine parsed = parseCommandOutput(line); - if (parsed != null) { - // Found a new line number designator. - // If there is a previously accumulated message, report it. - if (message.length() > 0) { - if (severity == IMarker.SEVERITY_ERROR) - errorReporter.reportError(path, lineNumber, message.toString()); - else errorReporter.reportWarning(path, lineNumber, message.toString()); - - if (!Objects.equal(originalPath.toFile(), path.toFile())) { - // Report an error also in the top-level resource. - // FIXME: It should be possible to descend through the import - // statements to find which one matches and mark all the - // import statements down the chain. But what a pain! - if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); - } else { - errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); + + /** + * Finds and transforms connections into forwarding reactions iff the connections have the same + * destination as other connections or reaction in mutually exclusive modes. + */ + private void transformConflictingConnectionsInModalReactors() { + for (LFResource r : resources) { + var transform = ASTUtils.findConflictingConnectionsInModalReactors(r.eResource); + if (!transform.isEmpty()) { + var factory = LfFactory.eINSTANCE; + for (Connection connection : transform) { + // Currently only simple transformations are supported + if (connection.isPhysical() || connection.getDelay() != null || connection.isIterated() || + connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1 + ) { + errorReporter.reportError(connection, "Cannot transform connection in modal reactor. Connection uses currently not supported features."); + } else { + var reaction = factory.createReaction(); + ((Mode)connection.eContainer()).getReactions().add(reaction); + + var sourceRef = connection.getLeftPorts().get(0); + var destRef = connection.getRightPorts().get(0); + reaction.getTriggers().add(sourceRef); + reaction.getEffects().add(destRef); + + var code = factory.createCode(); + var source = (sourceRef.getContainer() != null ? + sourceRef.getContainer().getName() + "." : "") + sourceRef.getVariable().getName(); + var dest = (destRef.getContainer() != null ? + destRef.getContainer().getName() + "." : "") + destRef.getVariable().getName(); + code.setBody(getConflictingConnectionsInModalReactorsBody(source, dest)); + reaction.setCode(code); + + EcoreUtil.remove(connection); + } + } } - } } - if (parsed.isError) { - severity = IMarker.SEVERITY_ERROR; - } else { - severity = IMarker.SEVERITY_WARNING; + } + + /** + * Return target code for forwarding reactions iff the connections have the + * same destination as other connections or reaction in mutually exclusive modes. + * + * This method needs to be overridden in target specific code generators that + * support modal reactors. + */ + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + errorReporter.reportError("The currently selected code generation " + + "is missing an implementation for conflicting " + + "transforming connections in modal reactors."); + return "MODAL MODELS NOT SUPPORTED"; + } + + /** + * Hook for additional post-processing of the model. + */ + protected void additionalPostProcessingForModes() { + // Do nothing + } + + /** + * Parsed error message from a compiler is returned here. + */ + public static class ErrorFileAndLine { + public String filepath = null; + public String line = "1"; + public String character = "0"; + public String message = ""; + public boolean isError = true; // false for a warning. + + @Override + public String toString() { + return (isError ? "Error" : "Non-error") + " at " + line + ":" + character + " of file " + filepath + ": " + message; } + } + + /** + * Given a line of text from the output of a compiler, return + * an instance of ErrorFileAndLine if the line is recognized as + * the first line of an error message. Otherwise, return null. + * This base class simply returns null. + * @param line A line of output from a compiler or other external + * tool that might generate errors. + * @return If the line is recognized as the start of an error message, + * then return a class containing the path to the file on which the + * error occurred (or null if there is none), the line number (or the + * string "1" if there is none), the character position (or the string + * "0" if there is none), and the message (or an empty string if there + * is none). + */ + protected ErrorFileAndLine parseCommandOutput(String line) { + return null; + } - // Start accumulating a new message. - message = new StringBuilder(); - // Append the message on the line number designator line. - message.append(parsed.message); - - // Set the new line number. - try { - lineNumber = Integer.decode(parsed.line); - } catch (Exception ex) { - // Set the line number unknown. - lineNumber = null; + /** + * Parse the specified string for command errors that can be reported + * using marks in the Eclipse IDE. In this class, we attempt to parse + * the messages to look for file and line information, thereby generating + * marks on the appropriate lines. This should not be called in standalone + * mode. + * + * @param stderr The output on standard error of executing a command. + */ + public void reportCommandErrors(String stderr) { + // NOTE: If the VS Code branch passes code review, then this function, + // parseCommandOutput, and ErrorFileAndLine will be deleted soon after. + // First, split the message into lines. + String[] lines = stderr.split("\\r?\\n"); + StringBuilder message = new StringBuilder(); + Integer lineNumber = null; + Path path = context.getFileConfig().srcFile; + // In case errors occur within an imported file, record the original path. + Path originalPath = path; + + int severity = IMarker.SEVERITY_ERROR; + for (String line : lines) { + ErrorFileAndLine parsed = parseCommandOutput(line); + if (parsed != null) { + // Found a new line number designator. + // If there is a previously accumulated message, report it. + if (message.length() > 0) { + if (severity == IMarker.SEVERITY_ERROR) + errorReporter.reportError(path, lineNumber, message.toString()); + else + errorReporter.reportWarning(path, lineNumber, message.toString()); + + if (!Objects.equal(originalPath.toFile(), path.toFile())) { + // Report an error also in the top-level resource. + // FIXME: It should be possible to descend through the import + // statements to find which one matches and mark all the + // import statements down the chain. But what a pain! + if (severity == IMarker.SEVERITY_ERROR) { + errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); + } else { + errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); + } + } + } + if (parsed.isError) { + severity = IMarker.SEVERITY_ERROR; + } else { + severity = IMarker.SEVERITY_WARNING; + } + + // Start accumulating a new message. + message = new StringBuilder(); + // Append the message on the line number designator line. + message.append(parsed.message); + + // Set the new line number. + try { + lineNumber = Integer.decode(parsed.line); + } catch (Exception ex) { + // Set the line number unknown. + lineNumber = null; + } + // FIXME: Ignoring the position within the line. + // Determine the path within which the error occurred. + path = Paths.get(parsed.filepath); + } else { + // No line designator. + if (message.length() > 0) { + message.append("\n"); + } else { + if (!line.toLowerCase().contains("error:")) { + severity = IMarker.SEVERITY_WARNING; + } + } + message.append(line); + } } - // FIXME: Ignoring the position within the line. - // Determine the path within which the error occurred. - path = Paths.get(parsed.filepath); - } else { - // No line designator. if (message.length() > 0) { - message.append("\n"); - } else { - if (!line.toLowerCase().contains("error:")) { - severity = IMarker.SEVERITY_WARNING; - } + if (severity == IMarker.SEVERITY_ERROR) { + errorReporter.reportError(path, lineNumber, message.toString()); + } else { + errorReporter.reportWarning(path, lineNumber, message.toString()); + } + + if (originalPath.toFile() != path.toFile()) { + // Report an error also in the top-level resource. + // FIXME: It should be possible to descend through the import + // statements to find which one matches and mark all the + // import statements down the chain. But what a pain! + if (severity == IMarker.SEVERITY_ERROR) { + errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); + } else { + errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); + } + } } - message.append(line); - } } - if (message.length() > 0) { - if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(path, lineNumber, message.toString()); - } else { - errorReporter.reportWarning(path, lineNumber, message.toString()); - } - - if (originalPath.toFile() != path.toFile()) { - // Report an error also in the top-level resource. - // FIXME: It should be possible to descend through the import - // statements to find which one matches and mark all the - // import statements down the chain. But what a pain! - if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); - } else { - errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); - } - } + + // ////////////////////////////////////////////////// + // // Private functions + + /** + * Print to stdout information about what source file is being generated, + * what mode the generator is in, and where the generated sources are to be put. + */ + public void printInfo(LFGeneratorContext.Mode mode) { + System.out.println("Generating code for: " + context.getFileConfig().resource.getURI().toString()); + System.out.println("******** mode: " + mode); + System.out.println("******** generated sources: " + context.getFileConfig().getSrcGenPath()); } - } - - // ////////////////////////////////////////////////// - // // Private functions - - /** - * Print to stdout information about what source file is being generated, what mode the generator - * is in, and where the generated sources are to be put. - */ - public void printInfo(LFGeneratorContext.Mode mode) { - System.out.println( - "Generating code for: " + context.getFileConfig().resource.getURI().toString()); - System.out.println("******** mode: " + mode); - System.out.println("******** generated sources: " + context.getFileConfig().getSrcGenPath()); - } - - /** Get the buffer type used for network messages */ - public String getNetworkBufferType() { - return ""; - } - - /** Return the Targets enum for the current target */ - public abstract Target getTarget(); + + /** + * Get the buffer type used for network messages + */ + public String getNetworkBufferType() { return ""; } + + /** + * Return the Targets enum for the current target + */ + public abstract Target getTarget(); } From 6463813cf99c97f0e534bec59e8321aa1c6e6f65 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 07:33:50 +0200 Subject: [PATCH 215/709] Undid formatting --- .../org/lflang/generator/c/CGenerator.java | 3764 ++++++++--------- 1 file changed, 1876 insertions(+), 1888 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 3a3352aa03..7bc579ac0f 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1,22 +1,26 @@ /************* - * Copyright (c) 2019-2021, The University of California at Berkeley. - * 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. - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. - ***************/ +Copyright (c) 2019-2021, The University of California at Berkeley. + +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. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. +***************/ package org.lflang.generator.c; @@ -31,11 +35,8 @@ import static org.lflang.ASTUtils.toText; import static org.lflang.util.StringUtil.addDoubleQuotes; -import com.google.common.base.Objects; -import com.google.common.collect.Iterables; import java.io.File; import java.io.IOException; -import java.nio.file.Files; import java.nio.file.Path; import java.util.HashSet; import java.util.LinkedHashSet; @@ -43,26 +44,33 @@ import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; + import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.StringExtensions; + import org.lflang.ASTUtils; +import org.lflang.generator.DockerComposeGenerator; import org.lflang.FileConfig; import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty; import org.lflang.TargetProperty.Platform; -import org.lflang.ast.DelayedConnectionTransformation; + import org.lflang.federated.extensions.CExtensionUtils; + +import org.lflang.ast.DelayedConnectionTransformation; + import org.lflang.generator.ActionInstance; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.DelayBodyGenerator; -import org.lflang.generator.DockerComposeGenerator; import org.lflang.generator.DockerGenerator; import org.lflang.generator.GeneratorBase; import org.lflang.generator.GeneratorResult; import org.lflang.generator.GeneratorUtils; + +import org.lflang.generator.DelayBodyGenerator; + import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFResource; import org.lflang.generator.ParameterInstance; @@ -88,168 +96,201 @@ import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; +import com.google.common.collect.Iterables; + /** - * Generator for C target. This class generates C code defining each reactor class given in the - * input .lf file and imported .lf files. The generated code has the following components: + * Generator for C target. This class generates C code defining each reactor + * class given in the input .lf file and imported .lf files. The generated code + * has the following components: * - *

* A typedef for inputs, outputs, and actions of each reactor class. These define the types of - * the variables that reactions use to access inputs and action values and to set output values. + * * A typedef for inputs, outputs, and actions of each reactor class. These + * define the types of the variables that reactions use to access inputs and + * action values and to set output values. * - *

* A typedef for a "self" struct for each reactor class. One instance of this struct will be - * created for each reactor instance. See below for details. + * * A typedef for a "self" struct for each reactor class. One instance of this + * struct will be created for each reactor instance. See below for details. * - *

* A function definition for each reaction in each reactor class. These functions take an - * instance of the self struct as an argument. + * * A function definition for each reaction in each reactor class. These + * functions take an instance of the self struct as an argument. * - *

* A constructor function for each reactor class. This is used to create a new instance of the - * reactor. + * * A constructor function for each reactor class. This is used to create + * a new instance of the reactor. * - *

After these, the main generated function is `_lf_initialize_trigger_objects()`. This function - * creates the instances of reactors (using their constructors) and makes connections between them. + * After these, the main generated function is `_lf_initialize_trigger_objects()`. + * This function creates the instances of reactors (using their constructors) + * and makes connections between them. * - *

A few other smaller functions are also generated. + * A few other smaller functions are also generated. * - *

## Self Struct + * ## Self Struct * - *

The "self" struct has fields for each of the following: + * The "self" struct has fields for each of the following: * - *

* parameter: the field name and type match the parameter. * state: the field name and type - * match the state. * action: the field name prepends the action name with "_lf_". A second field - * for the action is also created to house the trigger_t object. That second field prepends the - * action name with "_lf__". * output: the field name prepends the output name with "_lf_". * input: - * the field name prepends the output name with "_lf_". A second field for the input is also created - * to house the trigger_t object. That second field prepends the input name with "_lf__". + * * parameter: the field name and type match the parameter. + * * state: the field name and type match the state. + * * action: the field name prepends the action name with "_lf_". + * A second field for the action is also created to house the trigger_t object. + * That second field prepends the action name with "_lf__". + * * output: the field name prepends the output name with "_lf_". + * * input: the field name prepends the output name with "_lf_". + * A second field for the input is also created to house the trigger_t object. + * That second field prepends the input name with "_lf__". * - *

If, in addition, the reactor contains other reactors and reacts to their outputs, then there - * will be a struct within the self struct for each such contained reactor. The name of that self - * struct will be the name of the contained reactor prepended with "_lf_". That inside struct will - * contain pointers the outputs of the contained reactors that are read together with pointers to - * booleans indicating whether those outputs are present. + * If, in addition, the reactor contains other reactors and reacts to their outputs, + * then there will be a struct within the self struct for each such contained reactor. + * The name of that self struct will be the name of the contained reactor prepended with "_lf_". + * That inside struct will contain pointers the outputs of the contained reactors + * that are read together with pointers to booleans indicating whether those outputs are present. * - *

If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to - * trigger_t object (see reactor.h) for the shutdown event and an action struct named _lf_shutdown - * on the self struct. + * If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to + * trigger_t object (see reactor.h) for the shutdown event and an action struct named + * _lf_shutdown on the self struct. * - *

## Reaction Functions + * ## Reaction Functions * - *

For each reaction in a reactor class, this generator will produce a C function that expects a - * pointer to an instance of the "self" struct as an argument. This function will contain verbatim - * the C code specified in the reaction, but before that C code, the generator inserts a few lines - * of code that extract from the self struct the variables that that code has declared it will use. - * For example, if the reaction declares that it is triggered by or uses an input named "x" of type - * int, the function will contain a line like this: ``` r_x_t* x = self->_lf_x; ``` where `r` is the - * full name of the reactor class and the struct type `r_x_t` has fields `is_present` and `value`, - * where the type of `value` matches the port type. If the programmer fails to declare that it uses - * x, then the absence of the above code will trigger a compile error when the verbatim code - * attempts to read `x`. + * For each reaction in a reactor class, this generator will produce a C function + * that expects a pointer to an instance of the "self" struct as an argument. + * This function will contain verbatim the C code specified in the reaction, but + * before that C code, the generator inserts a few lines of code that extract from the + * self struct the variables that that code has declared it will use. For example, if + * the reaction declares that it is triggered by or uses an input named "x" of type + * int, the function will contain a line like this: + * ``` + * r_x_t* x = self->_lf_x; + * ``` + * where `r` is the full name of the reactor class and the struct type `r_x_t` + * has fields `is_present` and `value`, where the type of `value` matches the port type. + * If the programmer fails to declare that it uses x, then the absence of the + * above code will trigger a compile error when the verbatim code attempts to read `x`. * - *

## Constructor + * ## Constructor * - *

For each reactor class, this generator will create a constructor function named `new_r`, where - * `r` is the reactor class name. This function will malloc and return a pointer to an instance of - * the "self" struct. This struct initially represents an unconnected reactor. To establish - * connections between reactors, additional information needs to be inserted (see below). The self - * struct is made visible to the body of a reaction as a variable named "self". The self struct - * contains the following: + * For each reactor class, this generator will create a constructor function named + * `new_r`, where `r` is the reactor class name. This function will malloc and return + * a pointer to an instance of the "self" struct. This struct initially represents + * an unconnected reactor. To establish connections between reactors, additional + * information needs to be inserted (see below). The self struct is made visible + * to the body of a reaction as a variable named "self". The self struct contains the + * following: * - *

* Parameters: For each parameter `p` of the reactor, there will be a field `p` with the type - * and value of the parameter. So C code in the body of a reaction can access parameter values as - * `self->p`. + * * Parameters: For each parameter `p` of the reactor, there will be a field `p` + * with the type and value of the parameter. So C code in the body of a reaction + * can access parameter values as `self->p`. * - *

* State variables: For each state variable `s` of the reactor, there will be a field `s` with - * the type and value of the state variable. So C code in the body of a reaction can access state - * variables as `self->s`. + * * State variables: For each state variable `s` of the reactor, there will be a field `s` + * with the type and value of the state variable. So C code in the body of a reaction + * can access state variables as `self->s`. * - *

The self struct also contains various fields that the user is not intended to use. The names - * of these fields begin with at least two underscores. They are: + * The self struct also contains various fields that the user is not intended to + * use. The names of these fields begin with at least two underscores. They are: * - *

* Outputs: For each output named `out`, there will be a field `_lf_out` that is a struct - * containing a value field whose type matches that of the output. The output value is stored here. - * That struct also has a field `is_present` that is a boolean indicating whether the output has - * been set. This field is reset to false at the start of every time step. There is also a field - * `num_destinations` whose value matches the number of downstream reactors that use this variable. - * This field must be set when connections are made or changed. It is used to determine for a - * mutable input destination whether a copy needs to be made. + * * Outputs: For each output named `out`, there will be a field `_lf_out` that is + * a struct containing a value field whose type matches that of the output. + * The output value is stored here. That struct also has a field `is_present` + * that is a boolean indicating whether the output has been set. + * This field is reset to false at the start of every time + * step. There is also a field `num_destinations` whose value matches the + * number of downstream reactors that use this variable. This field must be + * set when connections are made or changed. It is used to determine for + * a mutable input destination whether a copy needs to be made. * - *

* Inputs: For each input named `in` of type T, there is a field named `_lf_in` that is a - * pointer struct with a value field of type T. The struct pointed to also has an `is_present` field - * of type bool that indicates whether the input is present. + * * Inputs: For each input named `in` of type T, there is a field named `_lf_in` + * that is a pointer struct with a value field of type T. The struct pointed + * to also has an `is_present` field of type bool that indicates whether the + * input is present. * - *

* Outputs of contained reactors: If a reactor reacts to outputs of a contained reactor `r`, - * then the self struct will contain a nested struct named `_lf_r` that has fields pointing to those - * outputs. For example, if `r` has an output `out` of type T, then there will be field in `_lf_r` - * named `out` that points to a struct containing a value field of type T and a field named - * `is_present` of type bool. + * * Outputs of contained reactors: If a reactor reacts to outputs of a + * contained reactor `r`, then the self struct will contain a nested struct + * named `_lf_r` that has fields pointing to those outputs. For example, + * if `r` has an output `out` of type T, then there will be field in `_lf_r` + * named `out` that points to a struct containing a value field + * of type T and a field named `is_present` of type bool. * - *

* Inputs of contained reactors: If a reactor sends to inputs of a contained reactor `r`, then - * the self struct will contain a nested struct named `_lf_r` that has fields for storing the values - * provided to those inputs. For example, if R has an input `in` of type T, then there will be field - * in _lf_R named `in` that is a struct with a value field of type T and a field named `is_present` - * of type bool. + * * Inputs of contained reactors: If a reactor sends to inputs of a + * contained reactor `r`, then the self struct will contain a nested struct + * named `_lf_r` that has fields for storing the values provided to those + * inputs. For example, if R has an input `in` of type T, then there will + * be field in _lf_R named `in` that is a struct with a value field + * of type T and a field named `is_present` of type bool. * - *

* Actions: If the reactor has an action a (logical or physical), then there will be a field in - * the self struct named `_lf_a` and another named `_lf__a`. The type of the first is specific to - * the action and contains a `value` field with the type and value of the action (if it has a - * value). That struct also has a `has_value` field, an `is_present` field, and a `token` field - * (which is NULL if the action carries no value). The `_lf__a` field is of type trigger_t. That - * struct contains various things, including an array of reactions sensitive to this trigger and a - * lf_token_t struct containing the value of the action, if it has a value. See reactor.h in the C - * library for details. + * * Actions: If the reactor has an action a (logical or physical), then there + * will be a field in the self struct named `_lf_a` and another named `_lf__a`. + * The type of the first is specific to the action and contains a `value` + * field with the type and value of the action (if it has a value). That + * struct also has a `has_value` field, an `is_present` field, and a + * `token` field (which is NULL if the action carries no value). + * The `_lf__a` field is of type trigger_t. + * That struct contains various things, including an array of reactions + * sensitive to this trigger and a lf_token_t struct containing the value of + * the action, if it has a value. See reactor.h in the C library for + * details. * - *

* Reactions: Each reaction will have several fields in the self struct. Each of these has a - * name that begins with `_lf__reaction_i`, where i is the number of the reaction, starting with 0. - * The fields are: * _lf__reaction_i: The struct that is put onto the reaction queue to execute the - * reaction (see reactor.h in the C library). + * * Reactions: Each reaction will have several fields in the self struct. + * Each of these has a name that begins with `_lf__reaction_i`, where i is + * the number of the reaction, starting with 0. The fields are: + * * _lf__reaction_i: The struct that is put onto the reaction queue to + * execute the reaction (see reactor.h in the C library). * - *

* Timers: For each timer t, there is are two fields in the self struct: * _lf__t: The - * trigger_t struct for this timer (see reactor.h). * _lf__t_reactions: An array of reactions - * (pointers to the reaction_t structs on this self struct) sensitive to this timer. + * * Timers: For each timer t, there is are two fields in the self struct: + * * _lf__t: The trigger_t struct for this timer (see reactor.h). + * * _lf__t_reactions: An array of reactions (pointers to the + * reaction_t structs on this self struct) sensitive to this timer. * - *

* Triggers: For each Timer, Action, Input, and Output of a contained reactor that triggers - * reactions, there will be a trigger_t struct on the self struct with name `_lf__t`, where t is the - * name of the trigger. + * * Triggers: For each Timer, Action, Input, and Output of a contained + * reactor that triggers reactions, there will be a trigger_t struct + * on the self struct with name `_lf__t`, where t is the name of the trigger. * - *

## Connections Between Reactors + * ## Connections Between Reactors * - *

Establishing connections between reactors involves two steps. First, each destination (e.g. an - * input port) must have pointers to the source (the output port). As explained above, for an input - * named `in`, the field `_lf_in->value` is a pointer to the output data being read. In addition, - * `_lf_in->is_present` is a pointer to the corresponding `out->is_present` field of the output - * reactor's self struct. + * Establishing connections between reactors involves two steps. + * First, each destination (e.g. an input port) must have pointers to + * the source (the output port). As explained above, for an input named + * `in`, the field `_lf_in->value` is a pointer to the output data being read. + * In addition, `_lf_in->is_present` is a pointer to the corresponding + * `out->is_present` field of the output reactor's self struct. * - *

In addition, the `reaction_i` struct on the self struct has a `triggers` field that records - * all the trigger_t structs for ports and actions that are triggered by the i-th reaction. The - * triggers field is an array of arrays of pointers to trigger_t structs. The length of the outer - * array is the number of output channels (single ports plus multiport widths) that the reaction - * effects plus the number of input port channels of contained reactors that it effects. Each inner - * array has a length equal to the number of final destinations of that output channel or input - * channel. The reaction_i struct has an array triggered_sizes that indicates the sizes of these - * inner arrays. The num_outputs field of the reaction_i struct gives the length of the - * triggered_sizes and (outer) triggers arrays. The num_outputs field is equal to the total number - * of single ports and multiport channels that the reaction writes to. + * In addition, the `reaction_i` struct on the self struct has a `triggers` + * field that records all the trigger_t structs for ports and actions + * that are triggered by the i-th reaction. The triggers field is + * an array of arrays of pointers to trigger_t structs. + * The length of the outer array is the number of output channels + * (single ports plus multiport widths) that the reaction effects + * plus the number of input port channels of contained + * reactors that it effects. Each inner array has a length equal to the + * number of final destinations of that output channel or input channel. + * The reaction_i struct has an array triggered_sizes that indicates + * the sizes of these inner arrays. The num_outputs field of the + * reaction_i struct gives the length of the triggered_sizes and + * (outer) triggers arrays. The num_outputs field is equal to the + * total number of single ports and multiport channels that the reaction + * writes to. * - *

## Runtime Tables + * ## Runtime Tables * - *

This generator creates an populates the following tables used at run time. These tables may - * have to be resized and adjusted when mutations occur. + * This generator creates an populates the following tables used at run time. + * These tables may have to be resized and adjusted when mutations occur. * - *

* _lf_is_present_fields: An array of pointers to booleans indicating whether an event is - * present. The _lf_start_time_step() function in reactor_common.c uses this to mark every event - * absent at the start of a time step. The size of this table is contained in the variable - * _lf_is_present_fields_size. * This table is accompanied by another list, - * _lf_is_present_fields_abbreviated, which only contains the is_present fields that have been set - * to true in the current tag. This list can allow a performance improvement if most ports are - * seldom present because only fields that have been set to true need to be reset to false. + * * _lf_is_present_fields: An array of pointers to booleans indicating whether an + * event is present. The _lf_start_time_step() function in reactor_common.c uses + * this to mark every event absent at the start of a time step. The size of this + * table is contained in the variable _lf_is_present_fields_size. + * * This table is accompanied by another list, _lf_is_present_fields_abbreviated, + * which only contains the is_present fields that have been set to true in the + * current tag. This list can allow a performance improvement if most ports are + * seldom present because only fields that have been set to true need to be + * reset to false. * - *

* _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown reactions. The - * length of this table is in the _lf_shutdown_triggers_size variable. + * * _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown + * reactions. The length of this table is in the _lf_shutdown_triggers_size + * variable. * - *

* _lf_timer_triggers: An array of pointers to trigger_t structs for timers that need to be - * started when the program runs. The length of this table is in the _lf_timer_triggers_size - * variable. + * * _lf_timer_triggers: An array of pointers to trigger_t structs for timers that + * need to be started when the program runs. The length of this table is in the + * _lf_timer_triggers_size variable. * - *

* _lf_action_table: For a federated execution, each federate will have this table that maps - * port IDs to the corresponding action struct, which can be cast to action_base_t. + * * _lf_action_table: For a federated execution, each federate will have this table + * that maps port IDs to the corresponding action struct, which can be cast to + * action_base_t. * * @author Edward A. Lee * @author Marten Lohstroh @@ -263,1122 +304,1102 @@ */ @SuppressWarnings("StaticPseudoFunctionalStyleMethod") public class CGenerator extends GeneratorBase { - // Regular expression pattern for compiler error messages with resource - // and line number information. The first match will a resource URI in the - // form of "file:/path/file.lf". The second match will be a line number. - // The third match is a character position within the line. - // The fourth match will be the error message. - static final Pattern compileErrorPattern = - Pattern.compile("^(?.*):(?\\d+):(?\\d+):(?.*)$"); - - public static int UNDEFINED_MIN_SPACING = -1; - - //////////////////////////////////////////// - //// Protected fields - - /** The main place to put generated code. */ - protected CodeBuilder code = new CodeBuilder(); - - /** Place to collect code to initialize the trigger objects for all reactor instances. */ - protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); - - protected final CFileConfig fileConfig; - - /** - * Count of the number of is_present fields of the self struct that need to be reinitialized in - * _lf_start_time_step(). - */ - protected int startTimeStepIsPresentCount = 0; - - //////////////////////////////////////////// - //// Private fields - /** Extra lines that need to go into the generated CMakeLists.txt. */ - private String cMakeExtras = ""; - - /** Place to collect code to execute at the start of a time step. */ - private CodeBuilder startTimeStep = new CodeBuilder(); - - /** - * Count of the number of token pointers that need to have their reference count decremented in - * _lf_start_time_step(). - */ - private int timerCount = 0; - - private int startupReactionCount = 0; - private int shutdownReactionCount = 0; - private int resetReactionCount = 0; - private int modalReactorCount = 0; - private int modalStateResetCount = 0; - private int watchdogCount = 0; - - // Indicate whether the generator is in Cpp mode or not - private final boolean CCppMode; - - private final CTypes types; - - private final CCmakeGenerator cmakeGenerator; - - protected CGenerator( - LFGeneratorContext context, - boolean CCppMode, - CTypes types, - CCmakeGenerator cmakeGenerator, - DelayBodyGenerator delayBodyGenerator) { - super(context); - this.fileConfig = (CFileConfig) context.getFileConfig(); - this.CCppMode = CCppMode; - this.types = types; - this.cmakeGenerator = cmakeGenerator; - - // Register the delayed connection transformation to be applied by GeneratorBase. - // transform both after delays and physical connections - registerTransformation( - new DelayedConnectionTransformation( - delayBodyGenerator, types, fileConfig.resource, true, true)); - } - - public CGenerator(LFGeneratorContext context, boolean ccppMode) { - this( - context, - ccppMode, - new CTypes(), - new CCmakeGenerator(context.getFileConfig(), List.of()), - new CDelayBodyGenerator(new CTypes())); - } - - /** - * Look for physical actions in all resources. If found, set threads to be at least one to allow - * asynchronous schedule calls. - */ - public void accommodatePhysicalActionsIfPresent() { - // If there are any physical actions, ensure the threaded engine is used and that - // keepalive is set to true, unless the user has explicitly set it to false. - for (Resource resource : GeneratorUtils.getResources(reactors)) { - for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { - if (Objects.equal(action.getOrigin(), ActionOrigin.PHYSICAL)) { - // If the unthreaded runtime is not requested by the user, use the threaded runtime - // instead - // because it is the only one currently capable of handling asynchronous events. - if (!targetConfig.threading - && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = true; - errorReporter.reportWarning( - action, - "Using the threaded C runtime to allow for asynchronous handling of physical action" - + " " - + action.getName()); - return; - } - } - } + + // Regular expression pattern for compiler error messages with resource + // and line number information. The first match will a resource URI in the + // form of "file:/path/file.lf". The second match will be a line number. + // The third match is a character position within the line. + // The fourth match will be the error message. + static final Pattern compileErrorPattern = Pattern.compile( + "^(?.*):(?\\d+):(?\\d+):(?.*)$" + ); + + public static int UNDEFINED_MIN_SPACING = -1; + + //////////////////////////////////////////// + //// Protected fields + + /** The main place to put generated code. */ + protected CodeBuilder code = new CodeBuilder(); + + /** Place to collect code to initialize the trigger objects for all reactor instances. */ + protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); + + protected final CFileConfig fileConfig; + + /** + * Count of the number of is_present fields of the self struct that + * need to be reinitialized in _lf_start_time_step(). + */ + protected int startTimeStepIsPresentCount = 0; + + //////////////////////////////////////////// + //// Private fields + /** + * Extra lines that need to go into the generated CMakeLists.txt. + */ + private String cMakeExtras = ""; + + /** Place to collect code to execute at the start of a time step. */ + private CodeBuilder startTimeStep = new CodeBuilder(); + + /** Count of the number of token pointers that need to have their + * reference count decremented in _lf_start_time_step(). + */ + private int timerCount = 0; + private int startupReactionCount = 0; + private int shutdownReactionCount = 0; + private int resetReactionCount = 0; + private int modalReactorCount = 0; + private int modalStateResetCount = 0; + private int watchdogCount = 0; + + // Indicate whether the generator is in Cpp mode or not + private final boolean CCppMode; + + private final CTypes types; + + private final CCmakeGenerator cmakeGenerator; + + protected CGenerator( + LFGeneratorContext context, + boolean CCppMode, + CTypes types, + CCmakeGenerator cmakeGenerator, + DelayBodyGenerator delayBodyGenerator + ) { + super(context); + this.fileConfig = (CFileConfig) context.getFileConfig(); + this.CCppMode = CCppMode; + this.types = types; + this.cmakeGenerator = cmakeGenerator; + + // Register the delayed connection transformation to be applied by GeneratorBase. + // transform both after delays and physical connections + registerTransformation(new DelayedConnectionTransformation(delayBodyGenerator, types, fileConfig.resource, true, true)); } - } - - /** - * Return true if the host operating system is compatible and otherwise report an error and return - * false. - */ - protected boolean isOSCompatible() { - if (GeneratorUtils.isHostWindows()) { - if (CCppMode) { - errorReporter.reportError( - "LF programs with a CCpp target are currently not supported on Windows. " - + "Exiting code generation."); - // FIXME: The incompatibility between our C runtime code and the - // Visual Studio compiler is extensive. - return false; - } + + public CGenerator(LFGeneratorContext context, boolean ccppMode) { + this( + context, + ccppMode, + new CTypes(), + new CCmakeGenerator(context.getFileConfig(), List.of()), + new CDelayBodyGenerator(new CTypes()) + ); } - return true; - } - - /** - * Generate C code from the Lingua Franca model contained by the specified resource. This is the - * main entry point for code generation. - * - * @param resource The resource containing the source code. - * @param context The context in which the generator is invoked, including whether it is cancelled - * and whether it is a standalone context - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - super.doGenerate(resource, context); - if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; - if (!isOSCompatible()) return; // Incompatible OS and configuration - // Perform set up that does not generate code - setUpGeneralParameters(); - - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); - handleProtoFiles(); - - // Derive target filename from the .lf filename. - var lfModuleName = fileConfig.name; - var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); - var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; - try { - generateCodeFor(lfModuleName); - copyTargetFiles(); - generateHeaders(); - code.writeToFile(targetFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); + /** + * Look for physical actions in all resources. + * If found, set threads to be at least one to allow asynchronous schedule calls. + */ + public void accommodatePhysicalActionsIfPresent() { + // If there are any physical actions, ensure the threaded engine is used and that + // keepalive is set to true, unless the user has explicitly set it to false. + for (Resource resource : GeneratorUtils.getResources(reactors)) { + for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { + if (Objects.equal(action.getOrigin(), ActionOrigin.PHYSICAL)) { + // If the unthreaded runtime is not requested by the user, use the threaded runtime instead + // because it is the only one currently capable of handling asynchronous events. + if (!targetConfig.threading && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = true; + errorReporter.reportWarning( + action, + "Using the threaded C runtime to allow for asynchronous handling of physical action " + + action.getName() + ); + return; + } + } + } + } } - // Create docker file. - if (targetConfig.dockerOptions != null && mainDef != null) { - try { - var dockerData = getDockerGenerator(context).generateDockerData(); - dockerData.writeDockerFile(); - (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); - } catch (IOException e) { - throw new RuntimeException("Error while writing Docker files", e); - } + /** + * Return true if the host operating system is compatible and + * otherwise report an error and return false. + */ + protected boolean isOSCompatible() { + if (GeneratorUtils.isHostWindows()) { + if (CCppMode) { + errorReporter.reportError( + "LF programs with a CCpp target are currently not supported on Windows. " + + "Exiting code generation." + ); + // FIXME: The incompatibility between our C runtime code and the + // Visual Studio compiler is extensive. + return false; + } + } + return true; } - // If cmake is requested, generate the CMakeLists.txt - if (targetConfig.platformOptions.platform != Platform.ARDUINO) { - var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; - var sources = - new HashSet<>(ASTUtils.recursiveChildren(main)) - .stream() - .map(CUtil::getName) - .map(it -> it + (CCppMode ? ".cpp" : ".c")) - .collect(Collectors.toList()); - sources.add(cFilename); - var cmakeCode = - cmakeGenerator.generateCMakeCode( - sources, - lfModuleName, - errorReporter, - CCppMode, - mainDef != null, - cMakeExtras, - targetConfig); - try { - cmakeCode.writeToFile(cmakeFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - } else { - try { - Path include = fileConfig.getSrcGenPath().resolve("include/"); - Path src = fileConfig.getSrcGenPath().resolve("src/"); - FileUtil.arduinoDeleteHelper(src, targetConfig.threading); - FileUtil.relativeIncludeHelper(src, include); - FileUtil.relativeIncludeHelper(include, include); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } + /** + * Generate C code from the Lingua Franca model contained by the + * specified resource. This is the main entry point for code + * generation. + * @param resource The resource containing the source code. + * @param context The context in which the generator is + * invoked, including whether it is cancelled and + * whether it is a standalone context + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + super.doGenerate(resource, context); + if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; + if (!isOSCompatible()) return; // Incompatible OS and configuration + + // Perform set up that does not generate code + setUpGeneralParameters(); + + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); + handleProtoFiles(); + + // Derive target filename from the .lf filename. + var lfModuleName = fileConfig.name; + var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); + var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; + try { + generateCodeFor(lfModuleName); + copyTargetFiles(); + generateHeaders(); + code.writeToFile(targetFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } - if (!targetConfig.noCompile) { - ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); - arduinoUtil.buildArduino(fileConfig, targetConfig); - context.finish(GeneratorResult.Status.COMPILED, null); - } else { - System.out.println("********"); - System.out.println( - "To compile your program, run the following command to see information about the board" - + " you plugged in:\n\n" - + "\tarduino-cli board list\n\n" - + "Grab the FQBN and PORT from the command and run the following command in the" - + " generated sources directory:\n\n" - + "\tarduino-cli compile -b --build-property" - + " compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" - + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property" - + " compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" - + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\n" - + "To flash/upload your generated sketch to the board, run the following command in" - + " the generated sources directory:\n\n" - + "\tarduino-cli upload -b -p \n"); - // System.out.println("For a list of all boards installed on your computer, you can use the - // following command:\n\n\tarduino-cli board listall\n"); - context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); - } - GeneratorUtils.refreshProject(resource, context.getMode()); - return; - } + // Create docker file. + if (targetConfig.dockerOptions != null && mainDef != null) { + try { + var dockerData = getDockerGenerator(context).generateDockerData(); + dockerData.writeDockerFile(); + (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); + } catch (IOException e) { + throw new RuntimeException("Error while writing Docker files", e); + } + } - // Dump the additional compile definitions to a file to keep the generated project - // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can - // take over and do the rest of compilation. - try { - String compileDefs = - targetConfig.compileDefinitions.keySet().stream() - .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) - .collect(Collectors.joining("\n")); - FileUtil.writeToFile( - compileDefs, - Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt")); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + // If cmake is requested, generate the CMakeLists.txt + if (targetConfig.platformOptions.platform != Platform.ARDUINO) { + var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; + var sources = new HashSet<>(ASTUtils.recursiveChildren(main)).stream() + .map(CUtil::getName).map(it -> it + (CCppMode ? ".cpp" : ".c")) + .collect(Collectors.toList()); + sources.add(cFilename); + var cmakeCode = cmakeGenerator.generateCMakeCode( + sources, + lfModuleName, + errorReporter, + CCppMode, + mainDef != null, + cMakeExtras, + targetConfig + ); + try { + cmakeCode.writeToFile(cmakeFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + } else { + try { + Path include = fileConfig.getSrcGenPath().resolve("include/"); + Path src = fileConfig.getSrcGenPath().resolve("src/"); + FileUtil.arduinoDeleteHelper(src, targetConfig.threading); + FileUtil.relativeIncludeHelper(src, include); + FileUtil.relativeIncludeHelper(include, include); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + + if (!targetConfig.noCompile) { + ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); + arduinoUtil.buildArduino(fileConfig, targetConfig); + context.finish( + GeneratorResult.Status.COMPILED, null + ); + } else { + System.out.println("********"); + System.out.println("To compile your program, run the following command to see information about the board you plugged in:\n\n\tarduino-cli board list\n\nGrab the FQBN and PORT from the command and run the following command in the generated sources directory:\n\n\tarduino-cli compile -b --build-property compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\nTo flash/upload your generated sketch to the board, run the following command in the generated sources directory:\n\n\tarduino-cli upload -b -p \n"); + // System.out.println("For a list of all boards installed on your computer, you can use the following command:\n\n\tarduino-cli board listall\n"); + context.finish( + GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null) + ); + } + GeneratorUtils.refreshProject(resource, context.getMode()); + return; + } - // If this code generator is directly compiling the code, compile it now so that we - // clean it up after, removing the #line directives after errors have been reported. - if (!targetConfig.noCompile - && targetConfig.dockerOptions == null - && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) - // This code is unreachable in LSP_FAST mode, so that check is omitted. - && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM) { - // FIXME: Currently, a lack of main is treated as a request to not produce - // a binary and produce a .o file instead. There should be a way to control - // this. - // Create an anonymous Runnable class and add it to the compileThreadPool - // so that compilation can happen in parallel. - var cleanCode = code.removeLines("#line"); - - var execName = lfModuleName; - var threadFileConfig = fileConfig; - var generator = - this; // FIXME: currently only passed to report errors with line numbers in the Eclipse - // IDE - var CppMode = CCppMode; - // generatingContext.reportProgress( - // String.format("Generated code for %d/%d executables. Compiling...", federateCount, - // federates.size()), - // 100 * federateCount / federates.size() - // ); // FIXME: Move to FedGenerator - // Create the compiler to be used later - - var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); - try { - if (!cCompiler.runCCompiler(generator, context)) { - // If compilation failed, remove any bin files that may have been created. - CUtil.deleteBinFiles(threadFileConfig); - // If finish has already been called, it is illegal and makes no sense. However, - // if finish has already been called, then this must be a federated execution. - context.unsuccessfulFinish(); + // Dump the additional compile definitions to a file to keep the generated project + // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can + // take over and do the rest of compilation. + try { + String compileDefs = targetConfig.compileDefinitions.keySet().stream() + .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) + .collect(Collectors.joining("\n")); + FileUtil.writeToFile( + compileDefs, + Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt") + ); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } + + // If this code generator is directly compiling the code, compile it now so that we + // clean it up after, removing the #line directives after errors have been reported. + if ( + !targetConfig.noCompile && targetConfig.dockerOptions == null + && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) + // This code is unreachable in LSP_FAST mode, so that check is omitted. + && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM + ) { + // FIXME: Currently, a lack of main is treated as a request to not produce + // a binary and produce a .o file instead. There should be a way to control + // this. + // Create an anonymous Runnable class and add it to the compileThreadPool + // so that compilation can happen in parallel. + var cleanCode = code.removeLines("#line"); + + var execName = lfModuleName; + var threadFileConfig = fileConfig; + var generator = this; // FIXME: currently only passed to report errors with line numbers in the Eclipse IDE + var CppMode = CCppMode; + // generatingContext.reportProgress( + // String.format("Generated code for %d/%d executables. Compiling...", federateCount, federates.size()), + // 100 * federateCount / federates.size() + // ); // FIXME: Move to FedGenerator + // Create the compiler to be used later + + var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); + try { + if (!cCompiler.runCCompiler(generator, context)) { + // If compilation failed, remove any bin files that may have been created. + CUtil.deleteBinFiles(threadFileConfig); + // If finish has already been called, it is illegal and makes no sense. However, + // if finish has already been called, then this must be a federated execution. + context.unsuccessfulFinish(); + } else { + context.finish( + GeneratorResult.Status.COMPILED, null + ); + } + cleanCode.writeToFile(targetFile); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } + } + + // If a build directive has been given, invoke it now. + // Note that the code does not get cleaned in this case. + if (!targetConfig.noCompile) { + if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { + CUtil.runBuildCommand( + fileConfig, + targetConfig, + commandFactory, + errorReporter, + this::reportCommandErrors, + context.getMode() + ); + context.finish( + GeneratorResult.Status.COMPILED, null + ); + } + if (!errorsOccurred()){ + System.out.println("Compiled binary is in " + fileConfig.binPath); + } } else { - context.finish(GeneratorResult.Status.COMPILED, null); + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); } - cleanCode.writeToFile(targetFile); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } - } - // If a build directive has been given, invoke it now. - // Note that the code does not get cleaned in this case. - if (!targetConfig.noCompile) { - if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { - CUtil.runBuildCommand( - fileConfig, - targetConfig, - commandFactory, - errorReporter, - this::reportCommandErrors, - context.getMode()); - context.finish(GeneratorResult.Status.COMPILED, null); - } - System.out.println("Compiled binary is in " + fileConfig.binPath); - } else { - context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + // In case we are in Eclipse, make sure the generated code is visible. + GeneratorUtils.refreshProject(resource, context.getMode()); } - // In case we are in Eclipse, make sure the generated code is visible. - GeneratorUtils.refreshProject(resource, context.getMode()); - } - - private void generateCodeFor(String lfModuleName) throws IOException { - startTimeStepIsPresentCount = 0; - code.pr(generateDirectives()); - code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); - // Generate code for each reactor. - generateReactorDefinitions(); - - // Generate main instance, if there is one. - // Note that any main reactors in imported files are ignored. - // Skip generation if there are cycles. - if (main != null) { - initializeTriggerObjects.pr( - String.join( - "\n", - "int _lf_startup_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", - "int _lf_shutdown_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", - "int _lf_reset_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", - "int _lf_timer_triggers_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", - "int bank_index;", - "SUPPRESS_UNUSED_WARNING(bank_index);", - "int _lf_watchdog_number_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_watchdog_number_count);")); - // Add counters for modal initialization - initializeTriggerObjects.pr( - CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); - - // Create an array of arrays to store all self structs. - // This is needed because connections cannot be established until - // all reactor instances have self structs because ports that - // receive data reference the self structs of the originating - // reactors, which are arbitarily far away in the program graph. - generateSelfStructs(main); - generateReactorInstance(main); - - if (targetConfig.fedSetupPreamble != null) { - if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); - code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); - if (targetLanguageIsCpp()) code.pr("}"); - } + private void generateCodeFor( + String lfModuleName + ) throws IOException { + startTimeStepIsPresentCount = 0; + code.pr(generateDirectives()); + code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); + // Generate code for each reactor. + generateReactorDefinitions(); + + // Generate main instance, if there is one. + // Note that any main reactors in imported files are ignored. + // Skip generation if there are cycles. + if (main != null) { + initializeTriggerObjects.pr(String.join("\n", + "int _lf_startup_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", + "int _lf_shutdown_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", + "int _lf_reset_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", + "int _lf_timer_triggers_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", + "int bank_index;", + "SUPPRESS_UNUSED_WARNING(bank_index);", + "int _lf_watchdog_number_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_watchdog_number_count);")); + // Add counters for modal initialization + initializeTriggerObjects.pr(CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); + + // Create an array of arrays to store all self structs. + // This is needed because connections cannot be established until + // all reactor instances have self structs because ports that + // receive data reference the self structs of the originating + // reactors, which are arbitarily far away in the program graph. + generateSelfStructs(main); + generateReactorInstance(main); + + if (targetConfig.fedSetupPreamble != null) { + if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); + code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); + if (targetLanguageIsCpp()) code.pr("}"); + } - // If there are timers, create a table of timers to be initialized. - code.pr(CTimerGenerator.generateDeclarations(timerCount)); - - // If there are startup reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); - - // If there are shutdown reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); - - // If there are reset reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); - - // If there are watchdogs, create a table of triggers. - code.pr(CWatchdogGenerator.generateWatchdogTable(watchdogCount)); - - // If there are modes, create a table of mode state to be checked for transitions. - code.pr( - CModesGenerator.generateModeStatesTable( - hasModalReactors, modalReactorCount, modalStateResetCount)); - - // Generate function to initialize the trigger objects for all reactors. - code.pr( - CTriggerObjectsGenerator.generateInitializeTriggerObjects( - main, - targetConfig, - initializeTriggerObjects, - startTimeStep, - types, - lfModuleName, - startTimeStepIsPresentCount)); - - // Generate function to trigger startup reactions for all reactors. - code.pr( - CReactionGenerator.generateLfTriggerStartupReactions( - startupReactionCount, hasModalReactors)); - - // Generate function to schedule timers for all reactors. - code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); - - // Generate a function that will either do nothing - // (if there is only one federate or the coordination - // is set to decentralized) or, if there are - // downstream federates, will notify the RTI - // that the specified logical time is complete. - if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) - code.pr("extern \"C\""); - code.pr( - String.join( - "\n", - "void logical_tag_complete(tag_t tag_to_send) {", - CExtensionUtils.surroundWithIfFederatedCentralized( - " _lf_logical_tag_complete(tag_to_send);"), - "}")); - - // Generate function to schedule shutdown reactions if any - // reactors have reactions to shutdown. - code.pr( - CReactionGenerator.generateLfTriggerShutdownReactions( - shutdownReactionCount, hasModalReactors)); - - // Generate an empty termination function for non-federated - // execution. For federated execution, an implementation is - // provided in federate.c. That implementation will resign - // from the federation and close any open sockets. - code.pr( - """ + // If there are timers, create a table of timers to be initialized. + code.pr(CTimerGenerator.generateDeclarations(timerCount)); + + // If there are startup reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); + + // If there are shutdown reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); + + // If there are reset reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); + + // If there are watchdogs, create a table of triggers. + code.pr(CWatchdogGenerator.generateWatchdogTable(watchdogCount)); + + // If there are modes, create a table of mode state to be checked for transitions. + code.pr(CModesGenerator.generateModeStatesTable( + hasModalReactors, + modalReactorCount, + modalStateResetCount + )); + + // Generate function to initialize the trigger objects for all reactors. + code.pr(CTriggerObjectsGenerator.generateInitializeTriggerObjects( + main, + targetConfig, + initializeTriggerObjects, + startTimeStep, + types, + lfModuleName, + startTimeStepIsPresentCount + )); + + // Generate function to trigger startup reactions for all reactors. + code.pr(CReactionGenerator.generateLfTriggerStartupReactions(startupReactionCount, hasModalReactors)); + + // Generate function to schedule timers for all reactors. + code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); + + // Generate a function that will either do nothing + // (if there is only one federate or the coordination + // is set to decentralized) or, if there are + // downstream federates, will notify the RTI + // that the specified logical time is complete. + if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) code.pr("extern \"C\""); + code.pr(String.join("\n", + "void logical_tag_complete(tag_t tag_to_send) {", + CExtensionUtils.surroundWithIfFederatedCentralized( + " _lf_logical_tag_complete(tag_to_send);" + ), + "}" + )); + + // Generate function to schedule shutdown reactions if any + // reactors have reactions to shutdown. + code.pr(CReactionGenerator.generateLfTriggerShutdownReactions(shutdownReactionCount, hasModalReactors)); + + // Generate an empty termination function for non-federated + // execution. For federated execution, an implementation is + // provided in federate.c. That implementation will resign + // from the federation and close any open sockets. + code.pr(""" #ifndef FEDERATED void terminate_execution() {} - #endif"""); - - // Generate functions for modes - code.pr(CModesGenerator.generateLfInitializeModes(hasModalReactors)); - code.pr(CModesGenerator.generateLfHandleModeChanges(hasModalReactors, modalStateResetCount)); - code.pr( - CReactionGenerator.generateLfModeTriggeredReactions( - startupReactionCount, resetReactionCount, hasModalReactors)); - } - } - - @Override - public void checkModalReactorSupport(boolean __) { - // Modal reactors are currently only supported for non federated applications - super.checkModalReactorSupport(true); - } - - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - return String.join( - "\n", - "// Generated forwarding reaction for connections with the same destination", - "// but located in mutually exclusive modes.", - "lf_set(" + dest + ", " + source + "->value);"); - } - - /** Set the scheduler type in the target config as needed. */ - private void pickScheduler() { - // Don't use a scheduler that does not prioritize reactions based on deadlines - // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. - if (!targetConfig.schedulerType.prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - if (hasDeadlines(reactors)) { - if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { - targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; + #endif""" + ); + + + // Generate functions for modes + code.pr(CModesGenerator.generateLfInitializeModes( + hasModalReactors + )); + code.pr(CModesGenerator.generateLfHandleModeChanges( + hasModalReactors, + modalStateResetCount + )); + code.pr(CReactionGenerator.generateLfModeTriggeredReactions( + startupReactionCount, + resetReactionCount, + hasModalReactors + )); } - } } - } - private boolean hasDeadlines(List reactors) { - for (Reactor reactor : reactors) { - for (Reaction reaction : allReactions(reactor)) { - if (reaction.getDeadline() != null) { - return true; - } - } - } - return false; - } - - /** - * Look at the 'reactor' eResource. If it is an imported .lf file, incorporate it into the current - * program in the following manner: - Merge its target property with `targetConfig` - If there are - * any preambles, add them to the preambles of the reactor. - */ - private void inspectReactorEResource(ReactorDecl reactor) { - // If the reactor is imported, look at the - // target definition of the .lf file in which the reactor is imported from and - // append any cmake-include. - // Check if the reactor definition is imported - if (reactor.eResource() != mainDef.getReactorClass().eResource()) { - // Find the LFResource corresponding to this eResource - LFResource lfResource = null; - for (var resource : resources) { - if (resource.getEResource() == reactor.eResource()) { - lfResource = resource; - break; - } - } - // Copy the user files and cmake-includes to the src-gen path of the main .lf file - if (lfResource != null) { - copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); - } + @Override + public void checkModalReactorSupport(boolean __) { + // Modal reactors are currently only supported for non federated applications + super.checkModalReactorSupport(true); } - } - - /** - * Copy all files or directories listed in the target property `files`, `cmake-include`, and - * `_fed_setup` into the src-gen folder of the main .lf file - * - * @param targetConfig The targetConfig to read the target properties from. - * @param fileConfig The fileConfig used to make the copy and resolve paths. - */ - @Override - public void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - super.copyUserFiles(targetConfig, fileConfig); - // Make sure the target directory exists. - var targetDir = this.fileConfig.getSrcGenPath(); - try { - Files.createDirectories(targetDir); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); + + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + return String.join("\n", + "// Generated forwarding reaction for connections with the same destination", + "// but located in mutually exclusive modes.", + "lf_set("+dest+", "+source+"->value);" + ); } - for (String filename : targetConfig.fileNames) { - var relativeFileName = - CUtil.copyFileOrResource(filename, fileConfig.srcFile.getParent(), targetDir); - if (StringExtensions.isNullOrEmpty(relativeFileName)) { - errorReporter.reportError( - "Failed to find file " + filename + " specified in the" + " files target property."); - } else { - targetConfig.filesNamesWithoutPath.add(relativeFileName); - } + /** Set the scheduler type in the target config as needed. */ + private void pickScheduler() { + // Don't use a scheduler that does not prioritize reactions based on deadlines + // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. + if (!targetConfig.schedulerType.prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + if (hasDeadlines(reactors)) { + if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { + targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; + } + } + } } - for (String filename : targetConfig.cmakeIncludes) { - var relativeCMakeIncludeFileName = - CUtil.copyFileOrResource(filename, fileConfig.srcFile.getParent(), targetDir); - // Check if the file exists - if (StringExtensions.isNullOrEmpty(relativeCMakeIncludeFileName)) { - errorReporter.reportError("Failed to find cmake-include file " + filename); - } else { - this.targetConfig.cmakeIncludesWithoutPath.add(relativeCMakeIncludeFileName); - } + private boolean hasDeadlines(List reactors) { + for (Reactor reactor : reactors) { + for (Reaction reaction : allReactions(reactor)) { + if (reaction.getDeadline() != null) { + return true; + } + } + } + return false; } - if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { - try { - FileUtil.copyFile( - fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), - targetDir.resolve(targetConfig.fedSetupPreamble)); - } catch (IOException e) { - errorReporter.reportError( - "Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); - } + /** + * Look at the 'reactor' eResource. + * If it is an imported .lf file, incorporate it into the current + * program in the following manner: + * - Merge its target property with `targetConfig` + * - If there are any preambles, add them to the preambles of the reactor. + */ + private void inspectReactorEResource(ReactorDecl reactor) { + // If the reactor is imported, look at the + // target definition of the .lf file in which the reactor is imported from and + // append any cmake-include. + // Check if the reactor definition is imported + if (reactor.eResource() != mainDef.getReactorClass().eResource()) { + // Find the LFResource corresponding to this eResource + LFResource lfResource = null; + for (var resource : resources) { + if (resource.getEResource() == reactor.eResource()) { + lfResource = resource; + break; + } + } + if (lfResource != null) { + // Copy the user files and cmake-includes to the src-gen path of the main .lf file + copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); + // Merge the CMake includes from the imported file into the target config + lfResource.getTargetConfig().cmakeIncludes.forEach(incl -> { + if (!this.targetConfig.cmakeIncludes.contains(incl)) { + this.targetConfig.cmakeIncludes.add(incl); + } + }); + } + } } - } - - /** - * Generate code for defining all reactors that belong to the federate, including all the child - * reactors down the hierarchy. Duplicate Duplicates are avoided. - * - *

Imported reactors' original .lf file is incorporated in the following manner: - If there are - * any cmake-include files, add them to the current list of cmake-include files. - If there are - * any preambles, add them to the preambles of the reactor. - */ - private void generateReactorDefinitions() throws IOException { - var generatedReactors = new LinkedHashSet(); - if (this.main != null) { - generateReactorChildren(this.main, generatedReactors); + + /** + * Copy all files or directories listed in the target property `files`, `cmake-include`, + * and `_fed_setup` into the src-gen folder of the main .lf file + * + * @param targetConfig The targetConfig to read the target properties from. + * @param fileConfig The fileConfig used to make the copy and resolve paths. + */ + @Override + protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + super.copyUserFiles(targetConfig, fileConfig); + // Must use class variable to determine destination! + var destination = this.fileConfig.getSrcGenPath(); + + FileUtil.copyFiles(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter); + + // FIXME: Unclear what the following does, but it does not appear to belong here. + if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { + try { + FileUtil.copyFile(fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), + destination.resolve(targetConfig.fedSetupPreamble)); + } catch (IOException e) { + errorReporter.reportError("Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); + } + } } - if (this.mainDef != null) { - generateReactorClass(ASTUtils.toDefinition(this.mainDef.getReactorClass())); + /** + * Generate code for defining all reactors that belong to the federate, + * including all the child reactors down the hierarchy. Duplicate + * Duplicates are avoided. + * + * Imported reactors' original .lf file is + * incorporated in the following manner: + * - If there are any cmake-include files, add them to the current list + * of cmake-include files. + * - If there are any preambles, add them to the preambles of the reactor. + */ + private void generateReactorDefinitions() throws IOException { + var generatedReactors = new LinkedHashSet(); + if (this.main != null) { + generateReactorChildren(this.main, generatedReactors); + } + + if (this.mainDef != null) { + generateReactorClass(ASTUtils.toDefinition(this.mainDef.getReactorClass())); + } + + if (mainDef == null) { + // Generate code for each reactor that was not instantiated in main or its children. + for (Reactor r : reactors) { + // Get the declarations for reactors that are instantiated somewhere. + // A declaration is either a reactor definition or an import statement.; + var declarations = this.instantiationGraph.getDeclarations(r); + // If the reactor has no instantiations and there is no main reactor, then + // generate code for it anyway (at a minimum, this means that the compiler is invoked + // so that reaction bodies are checked). + if (declarations.isEmpty()) { + generateReactorClass(r); + } + } + } } - if (mainDef == null) { - // Generate code for each reactor that was not instantiated in main or its children. - for (Reactor r : reactors) { - // Get the declarations for reactors that are instantiated somewhere. - // A declaration is either a reactor definition or an import statement.; - var declarations = this.instantiationGraph.getDeclarations(r); - // If the reactor has no instantiations and there is no main reactor, then - // generate code for it anyway (at a minimum, this means that the compiler is invoked - // so that reaction bodies are checked). - if (declarations.isEmpty()) { - generateReactorClass(r); + /** Generate user-visible header files for all reactors instantiated. */ + private void generateHeaders() throws IOException { + FileUtil.deleteDirectory(fileConfig.getIncludePath()); + FileUtil.copyDirectoryFromClassPath( + fileConfig.getRuntimeIncludePath(), + fileConfig.getIncludePath(), + false + ); + for (Reactor r : reactors) { + CReactorHeaderFileGenerator.doGenerate( + types, r, fileConfig, + (builder, rr, userFacing) -> { + generateAuxiliaryStructs(builder, rr, userFacing); + if (userFacing) { + ASTUtils.allInstantiations(r).stream().map(Instantiation::getReactorClass).collect(Collectors.toSet()).forEach(it -> { + ASTUtils.allPorts(ASTUtils.toDefinition(it)) + .forEach(p -> builder.pr(CPortGenerator.generateAuxiliaryStruct( + ASTUtils.toDefinition(it), p, getTarget(), errorReporter, types, new CodeBuilder(), true, it + ))); + }); + } + }, + this::generateTopLevelPreambles); } - } + FileUtil.copyDirectory(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); } - } - - /** Generate user-visible header files for all reactors instantiated. */ - private void generateHeaders() throws IOException { - FileUtil.deleteDirectory(fileConfig.getIncludePath()); - FileUtil.copyDirectoryFromClassPath( - fileConfig.getRuntimeIncludePath(), fileConfig.getIncludePath(), false); - for (Reactor r : reactors) { - CReactorHeaderFileGenerator.doGenerate( - types, - r, - fileConfig, - (builder, rr, userFacing) -> { - generateAuxiliaryStructs(builder, rr, userFacing); - if (userFacing) { - ASTUtils.allInstantiations(r).stream() - .map(Instantiation::getReactorClass) - .collect(Collectors.toSet()) - .forEach( - it -> { - ASTUtils.allPorts(ASTUtils.toDefinition(it)) - .forEach( - p -> - builder.pr( - CPortGenerator.generateAuxiliaryStruct( - ASTUtils.toDefinition(it), - p, - getTarget(), - errorReporter, - types, - new CodeBuilder(), - true, - it))); - }); + + /** + * Generate code for the children of 'reactor' that belong to 'federate'. + * Duplicates are avoided. + * + * Imported reactors' original .lf file is + * incorporated in the following manner: + * - If there are any cmake-include files, add them to the current list + * of cmake-include files. + * - If there are any preambles, add them to the preambles of the reactor. + * + * @param reactor Used to extract children from + */ + private void generateReactorChildren( + ReactorInstance reactor, + LinkedHashSet generatedReactors + ) throws IOException { + for (ReactorInstance r : reactor.children) { + if (r.reactorDeclaration != null && + !generatedReactors.contains(r.reactorDefinition)) { + generatedReactors.add(r.reactorDefinition); + generateReactorChildren(r, generatedReactors); + inspectReactorEResource(r.reactorDeclaration); + generateReactorClass(r.reactorDefinition); } - }, - this::generateTopLevelPreambles); + } + } + + /** + * Choose which platform files to compile with according to the OS. + * If there is no main reactor, then compilation will produce a .o file requiring further linking. + * Also, if useCmake is set to true, we don't need to add platform files. The CMakeLists.txt file + * will detect and use the appropriate platform file based on the platform that cmake is invoked on. + */ + private void pickCompilePlatform() { + var osName = System.getProperty("os.name").toLowerCase(); + // if platform target was set, use given platform instead + if (targetConfig.platformOptions.platform != Platform.AUTO) { + osName = targetConfig.platformOptions.platform.toString(); + } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { + errorReporter.reportError("Platform " + osName + " is not supported"); + } } - FileUtil.copyDirectory( - fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); - } - - /** - * Generate code for the children of 'reactor' that belong to 'federate'. Duplicates are avoided. - * - *

Imported reactors' original .lf file is incorporated in the following manner: - If there are - * any cmake-include files, add them to the current list of cmake-include files. - If there are - * any preambles, add them to the preambles of the reactor. - * - * @param reactor Used to extract children from - */ - private void generateReactorChildren( - ReactorInstance reactor, LinkedHashSet generatedReactors) throws IOException { - for (ReactorInstance r : reactor.children) { - if (r.reactorDeclaration != null && !generatedReactors.contains(r.reactorDefinition)) { - generatedReactors.add(r.reactorDefinition); - generateReactorChildren(r, generatedReactors); - inspectReactorEResource(r.reactorDeclaration); - generateReactorClass(r.reactorDefinition); + + /** + * Copy target-specific header file to the src-gen directory. + */ + protected void copyTargetFiles() throws IOException { + // Copy the core lib + String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); + Path dest = fileConfig.getSrcGenPath(); + if (targetConfig.platformOptions.platform == Platform.ARDUINO) { + dest = dest.resolve("src"); } + if (coreLib != null) { + FileUtil.copyDirectory(Path.of(coreLib), dest, true); + } else { + FileUtil.copyDirectoryFromClassPath( + "/lib/c/reactor-c/core", + dest.resolve("core"), + true + ); + FileUtil.copyDirectoryFromClassPath( + "/lib/c/reactor-c/lib", + dest.resolve("lib"), + true + ); + } + + // For the Zephyr target, copy default config and board files. + if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + FileUtil.copyDirectoryFromClassPath( + "/lib/platform/zephyr/boards", + fileConfig.getSrcGenPath().resolve("boards"), + false + ); + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/prj_lf.conf", + fileConfig.getSrcGenPath().resolve("prj_lf.conf"), + true + ); + + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/Kconfig", + fileConfig.getSrcGenPath().resolve("Kconfig"), + true + ); + } + } + + //////////////////////////////////////////// + //// Code generators. + + /** + * Generate a reactor class definition for the specified federate. + * A class definition has four parts: + * + * * Preamble code, if any, specified in the Lingua Franca file. + * * A "self" struct type definition (see the class documentation above). + * * A function for each reaction. + * * A constructor for creating an instance. + * for deleting an instance. + * + * If the reactor is the main reactor, then + * the generated code may be customized. Specifically, + * if the main reactor has reactions, these reactions + * will not be generated if they are triggered by or send + * data to contained reactors that are not in the federate. + * @param reactor The parsed reactor data structure. + */ + private void generateReactorClass(Reactor reactor) throws IOException { + // FIXME: Currently we're not reusing definitions for declarations that point to the same definition. + CodeBuilder header = new CodeBuilder(); + CodeBuilder src = new CodeBuilder(); + final String headerName = CUtil.getName(reactor) + ".h"; + var guardMacro = headerName.toUpperCase().replace(".", "_"); + header.pr("#ifndef " + guardMacro); + header.pr("#define " + guardMacro); + generateReactorClassHeaders(reactor, headerName, header, src); + header.pr(generateTopLevelPreambles(reactor)); + generateUserPreamblesForReactor(reactor, src); + generateReactorClassBody(reactor, header, src); + header.pr("#endif // " + guardMacro); + FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); + var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" : + CCppMode ? ".cpp" : ".c"; + FileUtil.writeToFile(src.toString(), fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), true); } - } - - /** - * Choose which platform files to compile with according to the OS. If there is no main reactor, - * then compilation will produce a .o file requiring further linking. Also, if useCmake is set to - * true, we don't need to add platform files. The CMakeLists.txt file will detect and use the - * appropriate platform file based on the platform that cmake is invoked on. - */ - private void pickCompilePlatform() { - var osName = System.getProperty("os.name").toLowerCase(); - // if platform target was set, use given platform instead - if (targetConfig.platformOptions.platform != Platform.AUTO) { - osName = targetConfig.platformOptions.platform.toString(); - } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { - errorReporter.reportError("Platform " + osName + " is not supported"); + + protected void generateReactorClassHeaders(Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { + if (CCppMode) { + src.pr("extern \"C\" {"); + header.pr("extern \"C\" {"); + } + header.pr("#include \"include/core/reactor.h\""); + src.pr("#include \"include/api/api.h\""); + src.pr("#include \"include/api/set.h\""); + generateIncludes(reactor); + if (CCppMode) { + src.pr("}"); + header.pr("}"); + } + src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(reactor) + "\""); + src.pr("#include \"" + headerName + "\""); + ASTUtils.allNestedClasses(reactor).map(CUtil::getName) + .map(name -> "#include \"" + name + ".h\"") + .forEach(header::pr); } - } - - /** Copy target-specific header file to the src-gen directory. */ - protected void copyTargetFiles() throws IOException { - // Copy the core lib - String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); - Path dest = fileConfig.getSrcGenPath(); - if (targetConfig.platformOptions.platform == Platform.ARDUINO) dest = dest.resolve("src"); - if (coreLib != null) { - FileUtil.copyDirectory(Path.of(coreLib), dest, true); - } else { - FileUtil.copyDirectoryFromClassPath("/lib/c/reactor-c/core", dest.resolve("core"), true); - FileUtil.copyDirectoryFromClassPath("/lib/c/reactor-c/lib", dest.resolve("lib"), true); + + private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeBuilder src) { + // Some of the following methods create lines of code that need to + // go into the constructor. Collect those lines of code here: + var constructorCode = new CodeBuilder(); + generateAuxiliaryStructs(header, reactor, false); + // The following must go before the self struct so the #include watchdog.h ends up in the header. + CWatchdogGenerator.generateWatchdogs(src, header, reactor); + generateSelfStruct(header, reactor, constructorCode); + generateMethods(src, reactor); + generateReactions(src, reactor); + generateConstructor(src, header, reactor, constructorCode); } - // For the Zephyr target, copy default config and board files. - if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - FileUtil.copyDirectoryFromClassPath( - "/lib/platform/zephyr/boards", fileConfig.getSrcGenPath().resolve("boards"), false); - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/prj_lf.conf", - fileConfig.getSrcGenPath().resolve("prj_lf.conf"), - true); - - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath().resolve("Kconfig"), true); + /** + * Generate methods for {@code reactor}. + */ + protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { + CMethodGenerator.generateMethods(reactor, src, types); } - } - - //////////////////////////////////////////// - //// Code generators. - /** - * Generate a reactor class definition for the specified federate. A class definition has four - * parts: - * - *

* Preamble code, if any, specified in the Lingua Franca file. * A "self" struct type - * definition (see the class documentation above). * A function for each reaction. * A constructor - * for creating an instance. for deleting an instance. - * - *

If the reactor is the main reactor, then the generated code may be customized. Specifically, - * if the main reactor has reactions, these reactions will not be generated if they are triggered - * by or send data to contained reactors that are not in the federate. - * - * @param reactor The parsed reactor data structure. - */ - private void generateReactorClass(Reactor reactor) throws IOException { - // FIXME: Currently we're not reusing definitions for declarations that point to the same - // definition. - CodeBuilder header = new CodeBuilder(); - CodeBuilder src = new CodeBuilder(); - final String headerName = CUtil.getName(reactor) + ".h"; - var guardMacro = headerName.toUpperCase().replace(".", "_"); - header.pr("#ifndef " + guardMacro); - header.pr("#define " + guardMacro); - generateReactorClassHeaders(reactor, headerName, header, src); - header.pr(generateTopLevelPreambles(reactor)); - generateUserPreamblesForReactor(reactor, src); - generateReactorClassBody(reactor, header, src); - header.pr("#endif // " + guardMacro); - FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); - var extension = - targetConfig.platformOptions.platform == Platform.ARDUINO - ? ".ino" - : CCppMode ? ".cpp" : ".c"; - FileUtil.writeToFile( - src.toString(), - fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), - true); - } - - protected void generateReactorClassHeaders( - Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { - if (CCppMode) { - src.pr("extern \"C\" {"); - header.pr("extern \"C\" {"); + + /** + * Generates preambles defined by user for a given reactor + * @param reactor The given reactor + */ + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + for (Preamble p : convertToEmptyListIfNull(reactor.getPreambles())) { + src.pr("// *********** From the preamble, verbatim:"); + src.prSourceLineNumber(p.getCode()); + src.pr(toText(p.getCode())); + src.pr("\n// *********** End of preamble."); + } } - header.pr("#include \"include/core/reactor.h\""); - src.pr("#include \"include/api/api.h\""); - src.pr("#include \"include/api/set.h\""); - generateIncludes(reactor); - if (CCppMode) { - src.pr("}"); - header.pr("}"); + + /** + * Generate a constructor for the specified reactor in the specified federate. + * @param reactor The parsed reactor data structure. + * @param constructorCode Lines of code previously generated that need to + * go into the constructor. + */ + protected void generateConstructor( + CodeBuilder src, CodeBuilder header, Reactor reactor, CodeBuilder constructorCode + ) { + header.pr(CConstructorGenerator.generateConstructorPrototype(reactor)); + src.pr(CConstructorGenerator.generateConstructor( + reactor, + constructorCode.toString() + )); } - src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(reactor) + "\""); - src.pr("#include \"" + headerName + "\""); - ASTUtils.allNestedClasses(reactor) - .map(CUtil::getName) - .map(name -> "#include \"" + name + ".h\"") - .forEach(header::pr); - } - - private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeBuilder src) { - // Some of the following methods create lines of code that need to - // go into the constructor. Collect those lines of code here: - var constructorCode = new CodeBuilder(); - generateAuxiliaryStructs(header, reactor, false); - // The following must go before the self struct so the #include watchdog.h ends up in the header. - CWatchdogGenerator.generateWatchdogs(src, header, reactor); - generateSelfStruct(header, reactor, constructorCode); - generateMethods(src, reactor); - generateReactions(src, reactor); - generateConstructor(src, header, reactor, constructorCode); - } - - /** Generate methods for {@code reactor}. */ - protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { - CMethodGenerator.generateMethods(reactor, src, types); - } - - /** - * Generates preambles defined by user for a given reactor - * - * @param reactor The given reactor - */ - protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { - for (Preamble p : convertToEmptyListIfNull(reactor.getPreambles())) { - src.pr("// *********** From the preamble, verbatim:"); - src.prSourceLineNumber(p.getCode()); - src.pr(toText(p.getCode())); - src.pr("\n// *********** End of preamble."); + + protected void generateIncludes(Reactor r) { + code.pr("#include \"" + CUtil.getName(r) + ".h\""); } - } - - /** - * Generate a constructor for the specified reactor in the specified federate. - * - * @param src Where to put the assembled code. - * @param header Where to put header code. - * @param reactor The parsed reactor data structure. - * @param constructorCode Lines of code previously generated that need to go into the constructor. - */ - protected void generateConstructor( - CodeBuilder src, CodeBuilder header, Reactor reactor, CodeBuilder constructorCode) { - header.pr(CConstructorGenerator.generateConstructorPrototype(reactor)); - src.pr(CConstructorGenerator.generateConstructor(reactor, constructorCode.toString())); - } - - protected void generateIncludes(Reactor r) { - code.pr("#include \"" + CUtil.getName(r) + ".h\""); - } - - /** - * Generate the struct type definitions for inputs, outputs, and actions of the specified reactor. - */ - protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { - // In the case where there are incoming - // p2p logical connections in decentralized - // federated execution, there will be an - // intended_tag field added to accommodate - // the case where a reaction triggered by a - // port or action is late due to network - // latency, etc.. - var federatedExtension = new CodeBuilder(); - federatedExtension.pr( - """ + + /** + * Generate the struct type definitions for inputs, outputs, and + * actions of the specified reactor. + */ + protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { + // In the case where there are incoming + // p2p logical connections in decentralized + // federated execution, there will be an + // intended_tag field added to accommodate + // the case where a reaction triggered by a + // port or action is late due to network + // latency, etc.. + var federatedExtension = new CodeBuilder(); + federatedExtension.pr(""" #ifdef FEDERATED #ifdef FEDERATED_DECENTRALIZED %s intended_tag; #endif %s physical_time_of_arrival; #endif - """ - .formatted(types.getTargetTagType(), types.getTargetTimeType())); - for (Port p : allPorts(r)) { - builder.pr( - CPortGenerator.generateAuxiliaryStruct( - r, p, getTarget(), errorReporter, types, federatedExtension, userFacing, null)); + """.formatted(types.getTargetTagType(), types.getTargetTimeType()) + ); + for (Port p : allPorts(r)) { + builder.pr(CPortGenerator.generateAuxiliaryStruct( + r, + p, + getTarget(), + errorReporter, + types, + federatedExtension, + userFacing, + null + )); + } + // The very first item on this struct needs to be + // a trigger_t* because the struct will be cast to (trigger_t*) + // by the lf_schedule() functions to get to the trigger. + for (Action action : allActions(r)) { + builder.pr(CActionGenerator.generateAuxiliaryStruct( + r, + action, + getTarget(), + types, + federatedExtension, + userFacing + )); + } } - // The very first item on this struct needs to be - // a trigger_t* because the struct will be cast to (trigger_t*) - // by the lf_schedule() functions to get to the trigger. - for (Action action : allActions(r)) { - builder.pr( - CActionGenerator.generateAuxiliaryStruct( - r, action, getTarget(), types, federatedExtension, userFacing)); + + /** + * Generate the self struct type definition for the specified reactor + * in the specified federate. + * @param decl The parsed reactor data structure. + * @param constructorCode Place to put lines of code that need to + * go into the constructor. + */ + private void generateSelfStruct(CodeBuilder builder, ReactorDecl decl, CodeBuilder constructorCode) { + var reactor = toDefinition(decl); + var selfType = CUtil.selfType(ASTUtils.toDefinition(decl)); + + // Construct the typedef for the "self" struct. + // Create a type name for the self struct. + var body = new CodeBuilder(); + + // Extensions can add functionality to the CGenerator + generateSelfStructExtension(body, decl, constructorCode); + + // Next handle parameters. + body.pr(CParameterGenerator.generateDeclarations(reactor, types)); + + // Next handle states. + body.pr(CStateGenerator.generateDeclarations(reactor, types)); + + // Next handle actions. + CActionGenerator.generateDeclarations(reactor, body, constructorCode); + + // Next handle inputs and outputs. + CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); + + // If there are contained reactors that either receive inputs + // from reactions of this reactor or produce outputs that trigger + // reactions of this reactor, then we need to create a struct + // inside the self struct for each contained reactor. That + // struct has a place to hold the data produced by this reactor's + // reactions and a place to put pointers to data produced by + // the contained reactors. + generateInteractingContainedReactors(reactor, body, constructorCode); + + // Next, generate the fields needed for each reaction. + CReactionGenerator.generateReactionAndTriggerStructs( + body, + reactor, + constructorCode, + types + ); + + // Next, generate fields for modes + CModesGenerator.generateDeclarations(reactor, body, constructorCode); + + // The first field has to always be a pointer to the list of + // of allocated memory that must be freed when the reactor is freed. + // This means that the struct can be safely cast to self_base_t. + builder.pr("typedef struct {"); + builder.indent(); + builder.pr("struct self_base_t base;"); + builder.pr(body.toString()); + builder.unindent(); + builder.pr("} " + selfType + ";"); } - } - - /** - * Generate the self struct type definition for the specified reactor in the specified federate. - * - * @param decl The parsed reactor data structure. - * @param constructorCode Place to put lines of code that need to go into the constructor. - */ - private void generateSelfStruct( - CodeBuilder builder, ReactorDecl decl, CodeBuilder constructorCode) { - var reactor = toDefinition(decl); - var selfType = CUtil.selfType(ASTUtils.toDefinition(decl)); - - // Construct the typedef for the "self" struct. - // Create a type name for the self struct. - var body = new CodeBuilder(); - - // Extensions can add functionality to the CGenerator - generateSelfStructExtension(body, decl, constructorCode); - - // Next handle parameters. - body.pr(CParameterGenerator.generateDeclarations(reactor, types)); - - // Next handle states. - body.pr(CStateGenerator.generateDeclarations(reactor, types)); - - // Next handle actions. - CActionGenerator.generateDeclarations(reactor, body, constructorCode); - - // Next handle inputs and outputs. - CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); - - // If there are contained reactors that either receive inputs - // from reactions of this reactor or produce outputs that trigger - // reactions of this reactor, then we need to create a struct - // inside the self struct for each contained reactor. That - // struct has a place to hold the data produced by this reactor's - // reactions and a place to put pointers to data produced by - // the contained reactors. - generateInteractingContainedReactors(reactor, body, constructorCode); - - // Next, generate the fields needed for each reaction. - CReactionGenerator.generateReactionAndTriggerStructs(body, reactor, constructorCode, types); - - // Generate the fields needed for each watchdog. - CWatchdogGenerator.generateWatchdogStruct(body, decl, constructorCode); - - // Next, generate fields for modes - CModesGenerator.generateDeclarations(reactor, body, constructorCode); - - // The first field has to always be a pointer to be struct_base_t. - // This means that the struct can be safely cast to self_base_t. - builder.pr("typedef struct {"); - builder.indent(); - builder.pr("struct self_base_t base;"); - builder.pr(body.toString()); - builder.unindent(); - builder.pr("} " + selfType + ";"); - } - - /** - * Generate structs and associated code for contained reactors that send or receive data to or - * from the container's reactions. - * - *

If there are contained reactors that either receive inputs from reactions of this reactor or - * produce outputs that trigger reactions of this reactor, then we need to create a struct inside - * the self struct of the container for each contained reactor. That struct has a place to hold - * the data produced by the container reactor's reactions and a place to put pointers to data - * produced by the contained reactors. - * - * @param reactor The reactor. - * @param body The place to put the struct definition for the contained reactors. - * @param constructorCode The place to put matching code that goes in the container's constructor. - */ - private void generateInteractingContainedReactors( - Reactor reactor, CodeBuilder body, CodeBuilder constructorCode) { - // The contents of the struct will be collected first so that - // we avoid duplicate entries and then the struct will be constructed. - var contained = new InteractingContainedReactors(reactor); - // Next generate the relevant code. - for (Instantiation containedReactor : contained.containedReactors()) { - Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); - // First define an _width variable in case it is a bank. - var array = ""; - var width = -2; - // If the instantiation is a bank, find the maximum bank width - // to define an array. - if (containedReactor.getWidthSpec() != null) { - width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); - array = "[" + width + "]"; - } - // NOTE: The following needs to be done for each instance - // so that the width can be parameter, not in the constructor. - // Here, we conservatively use a width that is the largest of all isntances. - constructorCode.pr( - String.join( - "\n", - "// Set the _width variable for all cases. This will be -2", - "// if the reactor is not a bank of reactors.", - "self->_lf_" + containedReactor.getName() + "_width = " + width + ";")); - - // Generate one struct for each contained reactor that interacts. - body.pr("struct {"); - body.indent(); - for (Port port : contained.portsOfInstance(containedReactor)) { - if (port instanceof Input) { - // If the variable is a multiport, then the place to store the data has - // to be malloc'd at initialization. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr( - port, - variableStructType(port, containedReactorType, false) + " " + port.getName() + ";"); - } else { - // Is a multiport. - // Memory will be malloc'd in initialization. - body.pr( - port, - String.join( - "\n", - variableStructType(port, containedReactorType, false) - + "** " - + port.getName() - + ";", - "int " + port.getName() + "_width;")); - } - } else { - // Must be an output port. - // Outputs of contained reactors are pointers to the source of data on the - // self struct of the container. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr( - port, - variableStructType(port, containedReactorType, false) - + "* " - + port.getName() - + ";"); - } else { - // Is a multiport. - // Here, we will use an array of pointers. - // Memory will be malloc'd in initialization. - body.pr( - port, - String.join( - "\n", - variableStructType(port, containedReactorType, false) - + "** " - + port.getName() - + ";", - "int " + port.getName() + "_width;")); - } - body.pr(port, "trigger_t " + port.getName() + "_trigger;"); - var reactorIndex = ""; - if (containedReactor.getWidthSpec() != null) { - reactorIndex = "[reactor_index]"; - constructorCode.pr( - "for (int reactor_index = 0; reactor_index < self->_lf_" - + containedReactor.getName() - + "_width; reactor_index++) {"); - constructorCode.indent(); - } - var portOnSelf = - "self->_lf_" + containedReactor.getName() + reactorIndex + "." + port.getName(); - - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederatedDecentralized( - portOnSelf - + "_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - - var triggered = contained.reactionsTriggered(containedReactor, port); - //noinspection StatementWithEmptyBody - if (triggered.size() > 0) { - body.pr( - port, "reaction_t* " + port.getName() + "_reactions[" + triggered.size() + "];"); - var triggeredCount = 0; - for (Integer index : triggered) { - constructorCode.pr( - port, - portOnSelf - + "_reactions[" - + triggeredCount++ - + "] = &self->_lf__reaction_" - + index - + ";"); + + /** + * Generate structs and associated code for contained reactors that + * send or receive data to or from the container's reactions. + * + * If there are contained reactors that either receive inputs + * from reactions of this reactor or produce outputs that trigger + * reactions of this reactor, then we need to create a struct + * inside the self struct of the container for each contained reactor. + * That struct has a place to hold the data produced by the container reactor's + * reactions and a place to put pointers to data produced by + * the contained reactors. + * + * @param reactor The reactor. + * @param body The place to put the struct definition for the contained reactors. + * @param constructorCode The place to put matching code that goes in the container's constructor. + */ + private void generateInteractingContainedReactors( + Reactor reactor, + CodeBuilder body, + CodeBuilder constructorCode + ) { + // The contents of the struct will be collected first so that + // we avoid duplicate entries and then the struct will be constructed. + var contained = new InteractingContainedReactors(reactor); + // Next generate the relevant code. + for (Instantiation containedReactor : contained.containedReactors()) { + Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); + // First define an _width variable in case it is a bank. + var array = ""; + var width = -2; + // If the instantiation is a bank, find the maximum bank width + // to define an array. + if (containedReactor.getWidthSpec() != null) { + width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); + array = "[" + width + "]"; } - constructorCode.pr( - port, portOnSelf + "_trigger.reactions = " + portOnSelf + "_reactions;"); - } else { - // Since the self struct is created using calloc, there is no need to set - // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL - } - // Since the self struct is created using calloc, there is no need to set falsy fields. - constructorCode.pr( - port, - String.join( - "\n", - portOnSelf + "_trigger.last = NULL;", - portOnSelf + "_trigger.number_of_reactions = " + triggered.size() + ";")); - - // Set the physical_time_of_arrival - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederated( - portOnSelf + "_trigger.physical_time_of_arrival = NEVER;")); - - if (containedReactor.getWidthSpec() != null) { - constructorCode.unindent(); - constructorCode.pr("}"); - } + // NOTE: The following needs to be done for each instance + // so that the width can be parameter, not in the constructor. + // Here, we conservatively use a width that is the largest of all isntances. + constructorCode.pr(String.join("\n", + "// Set the _width variable for all cases. This will be -2", + "// if the reactor is not a bank of reactors.", + "self->_lf_"+containedReactor.getName()+"_width = "+width+";" + )); + + // Generate one struct for each contained reactor that interacts. + body.pr("struct {"); + body.indent(); + for (Port port : contained.portsOfInstance(containedReactor)) { + if (port instanceof Input) { + // If the variable is a multiport, then the place to store the data has + // to be malloc'd at initialization. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr(port, variableStructType(port, containedReactorType, false)+" "+port.getName()+";"); + } else { + // Is a multiport. + // Memory will be malloc'd in initialization. + body.pr(port, String.join("\n", + variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", + "int "+port.getName()+"_width;" + )); + } + } else { + // Must be an output port. + // Outputs of contained reactors are pointers to the source of data on the + // self struct of the container. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr(port, variableStructType(port, containedReactorType, false)+"* "+port.getName()+";"); + } else { + // Is a multiport. + // Here, we will use an array of pointers. + // Memory will be malloc'd in initialization. + body.pr(port, String.join("\n", + variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", + "int "+port.getName()+"_width;" + )); + } + body.pr(port, "trigger_t "+port.getName()+"_trigger;"); + var reactorIndex = ""; + if (containedReactor.getWidthSpec() != null) { + reactorIndex = "[reactor_index]"; + constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactor.getName()+"_width; reactor_index++) {"); + constructorCode.indent(); + } + var portOnSelf = "self->_lf_"+containedReactor.getName()+reactorIndex+"."+port.getName(); + + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederatedDecentralized( + portOnSelf+"_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};" + ) + ); + + var triggered = contained.reactionsTriggered(containedReactor, port); + //noinspection StatementWithEmptyBody + if (triggered.size() > 0) { + body.pr(port, "reaction_t* "+port.getName()+"_reactions["+triggered.size()+"];"); + var triggeredCount = 0; + for (Integer index : triggered) { + constructorCode.pr(port, portOnSelf+"_reactions["+triggeredCount+++"] = &self->_lf__reaction_"+index+";"); + } + constructorCode.pr(port, portOnSelf+"_trigger.reactions = "+portOnSelf+"_reactions;"); + } else { + // Since the self struct is created using calloc, there is no need to set + // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL + } + // Since the self struct is created using calloc, there is no need to set falsy fields. + constructorCode.pr(port, String.join("\n", + portOnSelf+"_trigger.last = NULL;", + portOnSelf+"_trigger.number_of_reactions = "+triggered.size()+";" + )); + + + // Set the physical_time_of_arrival + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederated( + portOnSelf+"_trigger.physical_time_of_arrival = NEVER;" + ) + ); + + if (containedReactor.getWidthSpec() != null) { + constructorCode.unindent(); + constructorCode.pr("}"); + } + } + } + body.unindent(); + body.pr(String.join("\n", + "} _lf_"+containedReactor.getName()+array+";", + "int _lf_"+containedReactor.getName()+"_width;" + )); } - } - body.unindent(); - body.pr( - String.join( - "\n", - "} _lf_" + containedReactor.getName() + array + ";", - "int _lf_" + containedReactor.getName() + "_width;")); } - } - - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the - * self struct - * - * @param body The body of the self struct - * @param decl The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - protected void generateSelfStructExtension( - CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode) { - // Do nothing - } - - /** - * Generate reaction functions definition for a reactor. These functions have a single argument - * that is a void* pointing to a struct that contains parameters, state variables, inputs - * (triggering or not), actions (triggering or produced), and outputs. - * - * @param r The reactor. - */ - public void generateReactions(CodeBuilder src, Reactor r) { - var reactionIndex = 0; - var reactor = ASTUtils.toDefinition(r); - for (Reaction reaction : allReactions(reactor)) { - generateReaction(src, reaction, r, reactionIndex); - // Increment reaction index even if the reaction is not in the federate - // so that across federates, the reaction indices are consistent. - reactionIndex++; + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the self struct + * @param body The body of the self struct + * @param decl The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + protected void generateSelfStructExtension( + CodeBuilder body, + ReactorDecl decl, + CodeBuilder constructorCode + ) { + // Do nothing + } + + /** Generate reaction functions definition for a reactor. + * These functions have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param r The reactor. + */ + public void generateReactions(CodeBuilder src, Reactor r) { + var reactionIndex = 0; + var reactor = ASTUtils.toDefinition(r); + for (Reaction reaction : allReactions(reactor)) { + generateReaction(src, reaction, r, reactionIndex); + // Increment reaction index even if the reaction is not in the federate + // so that across federates, the reaction indices are consistent. + reactionIndex++; + } } - } - - /** - * Generate a reaction function definition for a reactor. This function will have a single - * argument that is a void* pointing to a struct that contains parameters, state variables, inputs - * (triggering or not), actions (triggering or produced), and outputs. - * - * @param reaction The reaction. - * @param r The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - protected void generateReaction( - CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { - src.pr( - CReactionGenerator.generateReaction( + + /** Generate a reaction function definition for a reactor. + * This function will have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { + src.pr(CReactionGenerator.generateReaction( reaction, r, reactionIndex, @@ -1386,726 +1407,693 @@ protected void generateReaction( errorReporter, types, targetConfig, - getTarget().requiresTypes)); - } - - /** - * Record startup, shutdown, and reset reactions. - * - * @param instance A reactor instance. - */ - private void recordBuiltinTriggers(ReactorInstance instance) { - // For each reaction instance, allocate the arrays that will be used to - // trigger downstream reactions. - for (ReactionInstance reaction : instance.reactions) { - var reactor = reaction.getParent(); - var temp = new CodeBuilder(); - var foundOne = false; - - var reactionRef = CUtil.reactionRef(reaction); - - // Next handle triggers of the reaction that come from a multiport output - // of a contained reactor. Also, handle startup and shutdown triggers. - for (TriggerInstance trigger : reaction.triggers) { - if (trigger.isStartup()) { - temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &" + reactionRef + ";"); - startupReactionCount += reactor.getTotalWidth(); - foundOne = true; - } else if (trigger.isShutdown()) { - temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &" + reactionRef + ";"); - foundOne = true; - shutdownReactionCount += reactor.getTotalWidth(); - - if (targetConfig.tracing != null) { - var description = CUtil.getShortenedName(reactor); - var reactorRef = CUtil.reactorRef(reactor); - temp.pr( - String.join( - "\n", - "_lf_register_trace_event(" - + reactorRef - + ", &(" - + reactorRef - + "->_lf__shutdown),", - "trace_trigger, " + addDoubleQuotes(description + ".shutdown") + ");")); - } - } else if (trigger.isReset()) { - temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &" + reactionRef + ";"); - resetReactionCount += reactor.getTotalWidth(); - foundOne = true; - } - } - if (foundOne) initializeTriggerObjects.pr(temp.toString()); + getTarget().requiresTypes + )); } - } - - /** - * Generate code to set up the tables used in _lf_start_time_step to decrement reference counts - * and mark outputs absent between time steps. This function puts the code into startTimeStep. - */ - private void generateStartTimeStep(ReactorInstance instance) { - // Avoid generating dead code if nothing is relevant. - var foundOne = false; - var temp = new CodeBuilder(); - var containerSelfStructName = CUtil.reactorRef(instance); - - // Handle inputs that get sent data from a reaction rather than from - // another contained reactor and reactions that are triggered by an - // output of a contained reactor. - // Note that there may be more than one reaction reacting to the same - // port so we have to avoid listing the port more than once. - var portsSeen = new LinkedHashSet(); - for (ReactionInstance reaction : instance.reactions) { - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { - portsSeen.add(port); - // This reaction is sending to an input. Must be - // the input of a contained reactor in the federate. - // NOTE: If instance == main and the federate is within a bank, - // this assumes that the reaction writes only to the bank member in the federate. - foundOne = true; - - temp.pr("// Add port " + port.getFullName() + " to array of is_present fields."); - - if (!Objects.equal(port.getParent(), instance)) { - // The port belongs to contained reactor, so we also have - // iterate over the instance bank members. - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(instance); - temp.startScopedBankChannelIteration(port, null); - } else { - temp.startScopedBankChannelIteration(port, "count"); - } - var portRef = CUtil.portRefNested(port); - var con = (port.isMultiport()) ? "->" : "."; - - temp.pr( - "_lf_is_present_fields[" - + startTimeStepIsPresentCount - + " + count] = &" - + portRef - + con - + "is_present;"); - // Intended_tag is only applicable to ports in federated execution. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - "_lf_intended_tag_fields[" - + startTimeStepIsPresentCount - + " + count] = &" - + portRef - + con - + "intended_tag;")); - - startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); - - if (!Objects.equal(port.getParent(), instance)) { - temp.pr("count++;"); - temp.endScopedBlock(); - temp.endScopedBlock(); - temp.endScopedBankChannelIteration(port, null); - } else { - temp.endScopedBankChannelIteration(port, "count"); - } + + /** + * Record startup, shutdown, and reset reactions. + * @param instance A reactor instance. + */ + private void recordBuiltinTriggers(ReactorInstance instance) { + // For each reaction instance, allocate the arrays that will be used to + // trigger downstream reactions. + for (ReactionInstance reaction : instance.reactions) { + var reactor = reaction.getParent(); + var temp = new CodeBuilder(); + var foundOne = false; + + var reactionRef = CUtil.reactionRef(reaction); + + // Next handle triggers of the reaction that come from a multiport output + // of a contained reactor. Also, handle startup and shutdown triggers. + for (TriggerInstance trigger : reaction.triggers) { + if (trigger.isStartup()) { + temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &"+reactionRef+";"); + startupReactionCount += reactor.getTotalWidth(); + foundOne = true; + } else if (trigger.isShutdown()) { + temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &"+reactionRef+";"); + foundOne = true; + shutdownReactionCount += reactor.getTotalWidth(); + + if (targetConfig.tracing != null) { + var description = CUtil.getShortenedName(reactor); + var reactorRef = CUtil.reactorRef(reactor); + temp.pr(String.join("\n", + "_lf_register_trace_event("+reactorRef+", &("+reactorRef+"->_lf__shutdown),", + "trace_trigger, "+addDoubleQuotes(description+".shutdown")+");" + )); + } + } else if (trigger.isReset()) { + temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &"+reactionRef+";"); + resetReactionCount += reactor.getTotalWidth(); + foundOne = true; + } + } + if (foundOne) initializeTriggerObjects.pr(temp.toString()); } - } } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; - - for (ActionInstance action : instance.actions) { - foundOne = true; - temp.startScopedBlock(instance); - - temp.pr( - String.join( - "\n", - "// Add action " + action.getFullName() + " to array of is_present fields.", - "_lf_is_present_fields[" + startTimeStepIsPresentCount + "] ", - " = &" - + containerSelfStructName - + "->_lf_" - + action.getName() - + ".is_present;")); - - // Intended_tag is only applicable to actions in federated execution with decentralized - // coordination. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join( - "\n", - "// Add action " + action.getFullName() + " to array of intended_tag fields.", - "_lf_intended_tag_fields[" + startTimeStepIsPresentCount + "] ", - " = &" - + containerSelfStructName - + "->_lf_" - + action.getName() - + ".intended_tag;"))); - - startTimeStepIsPresentCount += action.getParent().getTotalWidth(); - temp.endScopedBlock(); - } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; - - // Next, set up the table to mark each output of each contained reactor absent. - for (ReactorInstance child : instance.children) { - if (child.outputs.size() > 0) { - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(child); + /** + * Generate code to set up the tables used in _lf_start_time_step to decrement reference + * counts and mark outputs absent between time steps. This function puts the code + * into startTimeStep. + */ + private void generateStartTimeStep(ReactorInstance instance) { + // Avoid generating dead code if nothing is relevant. + var foundOne = false; + var temp = new CodeBuilder(); + var containerSelfStructName = CUtil.reactorRef(instance); + + // Handle inputs that get sent data from a reaction rather than from + // another contained reactor and reactions that are triggered by an + // output of a contained reactor. + // Note that there may be more than one reaction reacting to the same + // port so we have to avoid listing the port more than once. + var portsSeen = new LinkedHashSet(); + for (ReactionInstance reaction : instance.reactions) { + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { + portsSeen.add(port); + // This reaction is sending to an input. Must be + // the input of a contained reactor in the federate. + // NOTE: If instance == main and the federate is within a bank, + // this assumes that the reaction writes only to the bank member in the federate. + foundOne = true; + + temp.pr("// Add port "+port.getFullName()+" to array of is_present fields."); + + if (!Objects.equal(port.getParent(), instance)) { + // The port belongs to contained reactor, so we also have + // iterate over the instance bank members. + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(instance); + temp.startScopedBankChannelIteration(port, null); + } else { + temp.startScopedBankChannelIteration(port, "count"); + } + var portRef = CUtil.portRefNested(port); + var con = (port.isMultiport()) ? "->" : "."; + + temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"is_present;"); + // Intended_tag is only applicable to ports in federated execution. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"intended_tag;" + ) + ); + + startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); + + if (!Objects.equal(port.getParent(), instance)) { + temp.pr("count++;"); + temp.endScopedBlock(); + temp.endScopedBlock(); + temp.endScopedBankChannelIteration(port, null); + } else { + temp.endScopedBankChannelIteration(port, "count"); + } + } + } + } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; - var channelCount = 0; - for (PortInstance output : child.outputs) { - if (!output.getDependsOnReactions().isEmpty()) { + for (ActionInstance action : instance.actions) { foundOne = true; - temp.pr("// Add port " + output.getFullName() + " to array of is_present fields."); - temp.startChannelIteration(output); - temp.pr( - "_lf_is_present_fields[" - + startTimeStepIsPresentCount - + " + count] = &" - + CUtil.portRef(output) - + ".is_present;"); - - // Intended_tag is only applicable to ports in federated execution with decentralized - // coordination. + temp.startScopedBlock(instance); + + temp.pr(String.join("\n", + "// Add action "+action.getFullName()+" to array of is_present fields.", + "_lf_is_present_fields["+startTimeStepIsPresentCount+"] ", + " = &"+containerSelfStructName+"->_lf_"+action.getName()+".is_present;" + )); + + // Intended_tag is only applicable to actions in federated execution with decentralized coordination. temp.pr( CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join( - "\n", - "// Add port " + output.getFullName() + " to array of intended_tag fields.", - "_lf_intended_tag_fields[" - + startTimeStepIsPresentCount - + " + count] = &" - + CUtil.portRef(output) - + ".intended_tag;"))); - - temp.pr("count++;"); - channelCount += output.getWidth(); - temp.endChannelIteration(output); - } + String.join("\n", + "// Add action " + action.getFullName() + + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + "] ", + " = &" + containerSelfStructName + + "->_lf_" + action.getName() + + ".intended_tag;" + ))); + + startTimeStepIsPresentCount += action.getParent().getTotalWidth(); + temp.endScopedBlock(); } - startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); - temp.endScopedBlock(); - temp.endScopedBlock(); - } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; + + // Next, set up the table to mark each output of each contained reactor absent. + for (ReactorInstance child : instance.children) { + if (child.outputs.size() > 0) { + + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(child); + + var channelCount = 0; + for (PortInstance output : child.outputs) { + if (!output.getDependsOnReactions().isEmpty()){ + foundOne = true; + temp.pr("// Add port "+output.getFullName()+" to array of is_present fields."); + temp.startChannelIteration(output); + temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".is_present;"); + + // Intended_tag is only applicable to ports in federated execution with decentralized coordination. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + String.join("\n", + "// Add port "+output.getFullName()+" to array of intended_tag fields.", + "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".intended_tag;" + ))); + + temp.pr("count++;"); + channelCount += output.getWidth(); + temp.endChannelIteration(output); + } + } + startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); + temp.endScopedBlock(); + temp.endScopedBlock(); + } + } + if (foundOne) startTimeStep.pr(temp.toString()); } - if (foundOne) startTimeStep.pr(temp.toString()); - } - - /** - * For each timer in the given reactor, generate initialization code for the offset and period - * fields. - * - *

This method will also populate the global _lf_timer_triggers array, which is used to start - * all timers at the start of execution. - * - * @param instance A reactor instance. - */ - private void generateTimerInitializations(ReactorInstance instance) { - for (TimerInstance timer : instance.timers) { - if (!timer.isStartup()) { - initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); - timerCount += timer.getParent().getTotalWidth(); - } + + /** + * For each timer in the given reactor, generate initialization code for the offset + * and period fields. + * + * This method will also populate the global _lf_timer_triggers array, which is + * used to start all timers at the start of execution. + * + * @param instance A reactor instance. + */ + private void generateTimerInitializations(ReactorInstance instance) { + for (TimerInstance timer : instance.timers) { + if (!timer.isStartup()) { + initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); + timerCount += timer.getParent().getTotalWidth(); + } + } } - } - - /** - * Process a given .proto file. - * - *

Run, if possible, the proto-c protocol buffer code generator to produce the required .h and - * .c files. - * - * @param filename Name of the file to process. - */ - public void processProtoFile(String filename) { - var protoc = - commandFactory.createCommand( + + /** + * Process a given .proto file. + * + * Run, if possible, the proto-c protocol buffer code generator to produce + * the required .h and .c files. + * @param filename Name of the file to process. + */ + public void processProtoFile(String filename) { + var protoc = commandFactory.createCommand( "protoc-c", - List.of("--c_out=" + this.fileConfig.getSrcGenPath(), filename), + List.of("--c_out="+this.fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); - return; - } - var returnCode = protoc.run(); - if (returnCode == 0) { - var nameSansProto = filename.substring(0, filename.length() - 6); - targetConfig.compileAdditionalSources.add( - fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString()); - - targetConfig.compileLibraries.add("-l"); - targetConfig.compileLibraries.add("protobuf-c"); - targetConfig.compilerFlags.add("-lprotobuf-c"); - } else { - errorReporter.reportError("protoc-c returns error code " + returnCode); + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); + return; + } + var returnCode = protoc.run(); + if (returnCode == 0) { + var nameSansProto = filename.substring(0, filename.length() - 6); + targetConfig.compileAdditionalSources.add( + fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString() + ); + + targetConfig.compileLibraries.add("-l"); + targetConfig.compileLibraries.add("protobuf-c"); + targetConfig.compilerFlags.add("-lprotobuf-c"); + } else { + errorReporter.reportError("protoc-c returns error code " + returnCode); + } } - } - - /** - * Construct a unique type for the struct of the specified typed variable (port or action) of the - * specified reactor class. This is required to be the same as the type name returned by {@link - * #variableStructType(TriggerInstance)}. - */ - public static String variableStructType(Variable variable, Reactor reactor, boolean userFacing) { - return (userFacing ? reactor.getName().toLowerCase() : CUtil.getName(reactor)) - + "_" - + variable.getName() - + "_t"; - } - - /** - * Construct a unique type for the struct of the specified instance (port or action). This is - * required to be the same as the type name returned by {@link #variableStructType(Variable, - * Reactor, boolean)}. - * - * @param portOrAction The port or action instance. - * @return The name of the self struct. - */ - public static String variableStructType(TriggerInstance portOrAction) { - return CUtil.getName(portOrAction.getParent().reactorDefinition) - + "_" - + portOrAction.getName() - + "_t"; - } - - /** - * If tracing is turned on, then generate code that records the full name of the specified reactor - * instance in the trace table. If tracing is not turned on, do nothing. - * - * @param instance The reactor instance. - */ - private void generateTraceTableEntries(ReactorInstance instance) { - if (targetConfig.tracing != null) { - initializeTriggerObjects.pr(CTracingGenerator.generateTraceTableEntries(instance)); + + /** + * Construct a unique type for the struct of the specified + * typed variable (port or action) of the specified reactor class. + * This is required to be the same as the type name returned by + * {@link #variableStructType(TriggerInstance)}. + */ + public static String variableStructType(Variable variable, Reactor reactor, boolean userFacing) { + return (userFacing ? reactor.getName().toLowerCase() : CUtil.getName(reactor)) +"_"+variable.getName()+"_t"; } - } - - /** - * Generate code to instantiate the specified reactor instance and initialize it. - * - * @param instance A reactor instance. - */ - public void generateReactorInstance(ReactorInstance instance) { - var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); - var fullName = instance.getFullName(); - initializeTriggerObjects.pr( - "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); - // Generate the instance self struct containing parameters, state variables, - // and outputs (the "self" struct). - initializeTriggerObjects.pr( - CUtil.reactorRefName(instance) - + "[" - + CUtil.runtimeIndex(instance) - + "] = new_" - + CUtil.getName(reactorClass) - + "();"); - // Generate code to initialize the "self" struct in the - // _lf_initialize_trigger_objects function. - generateTraceTableEntries(instance); - generateReactorInstanceExtension(instance); - generateParameterInitialization(instance); - initializeOutputMultiports(instance); - initializeInputMultiports(instance); - recordBuiltinTriggers(instance); - watchdogCount += CWatchdogGenerator.generateInitializeWatchdogs(initializeTriggerObjects, instance); - - // Next, initialize the "self" struct with state variables. - // These values may be expressions that refer to the parameter values defined above. - generateStateVariableInitializations(instance); - - // Generate trigger objects for the instance. - generateTimerInitializations(instance); - generateActionInitializations(instance); - generateInitializeActionToken(instance); - generateSetDeadline(instance); - generateModeStructure(instance); - - // Recursively generate code for the children. - for (ReactorInstance child : instance.children) { - // If this reactor is a placeholder for a bank of reactors, then generate - // an array of instances of reactors and create an enclosing for loop. - // Need to do this for each of the builders into which the code writes. - startTimeStep.startScopedBlock(child); - initializeTriggerObjects.startScopedBlock(child); - generateReactorInstance(child); - initializeTriggerObjects.endScopedBlock(); - startTimeStep.endScopedBlock(); + + /** + * Construct a unique type for the struct of the specified + * instance (port or action). + * This is required to be the same as the type name returned by + * {@link #variableStructType(Variable, Reactor, boolean)}. + * @param portOrAction The port or action instance. + * @return The name of the self struct. + */ + public static String variableStructType(TriggerInstance portOrAction) { + return CUtil.getName(portOrAction.getParent().reactorDefinition)+"_"+portOrAction.getName()+"_t"; } - // For this instance, define what must be done at the start of - // each time step. This sets up the tables that are used by the - // _lf_start_time_step() function in reactor_common.c. - // Note that this function is also run once at the end - // so that it can deallocate any memory. - generateStartTimeStep(instance); - initializeTriggerObjects.pr("//***** End initializing " + fullName); - } - - /** - * For each action of the specified reactor instance, generate initialization code for the offset - * and period fields. - * - * @param instance The reactor. - */ - private void generateActionInitializations(ReactorInstance instance) { - initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); - } - - /** - * Initialize actions by creating a lf_token_t in the self struct. This has the information - * required to allocate memory for the action payload. Skip any action that is not actually used - * as a trigger. - * - * @param reactor The reactor containing the actions. - */ - private void generateInitializeActionToken(ReactorInstance reactor) { - for (ActionInstance action : reactor.actions) { - // Skip this step if the action is not in use. - if (action.getParent().getTriggers().contains(action)) { - var type = getInferredType(action.getDefinition()); - var payloadSize = "0"; - if (!type.isUndefined()) { - var typeStr = types.getTargetType(type); - if (CUtil.isTokenType(type, types)) { - typeStr = CUtil.rootType(typeStr); - } - if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { - payloadSize = "sizeof(" + typeStr + ")"; - } + /** + * If tracing is turned on, then generate code that records + * the full name of the specified reactor instance in the + * trace table. If tracing is not turned on, do nothing. + * @param instance The reactor instance. + */ + private void generateTraceTableEntries(ReactorInstance instance) { + if (targetConfig.tracing != null) { + initializeTriggerObjects.pr( + CTracingGenerator.generateTraceTableEntries(instance) + ); } + } - var selfStruct = CUtil.reactorRef(action.getParent()); + /** + * Generate code to instantiate the specified reactor instance and + * initialize it. + * @param instance A reactor instance. + */ + public void generateReactorInstance(ReactorInstance instance) { + var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); + var fullName = instance.getFullName(); initializeTriggerObjects.pr( - CActionGenerator.generateTokenInitializer(selfStruct, action.getName(), payloadSize)); - } + "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); + // Generate the instance self struct containing parameters, state variables, + // and outputs (the "self" struct). + initializeTriggerObjects.pr(CUtil.reactorRefName(instance)+"["+CUtil.runtimeIndex(instance)+"] = new_"+CUtil.getName(reactorClass)+"();"); + // Generate code to initialize the "self" struct in the + // _lf_initialize_trigger_objects function. + generateTraceTableEntries(instance); + generateReactorInstanceExtension(instance); + generateParameterInitialization(instance); + initializeOutputMultiports(instance); + initializeInputMultiports(instance); + recordBuiltinTriggers(instance); + watchdogCount += CWatchdogGenerator.generateInitializeWatchdogs(initializeTriggerObjects, instance); + + // Next, initialize the "self" struct with state variables. + // These values may be expressions that refer to the parameter values defined above. + generateStateVariableInitializations(instance); + + // Generate trigger objects for the instance. + generateTimerInitializations(instance); + generateActionInitializations(instance); + generateInitializeActionToken(instance); + generateSetDeadline(instance); + generateModeStructure(instance); + + // Recursively generate code for the children. + for (ReactorInstance child : instance.children) { + // If this reactor is a placeholder for a bank of reactors, then generate + // an array of instances of reactors and create an enclosing for loop. + // Need to do this for each of the builders into which the code writes. + startTimeStep.startScopedBlock(child); + initializeTriggerObjects.startScopedBlock(child); + generateReactorInstance(child); + initializeTriggerObjects.endScopedBlock(); + startTimeStep.endScopedBlock(); + } + + // For this instance, define what must be done at the start of + // each time step. This sets up the tables that are used by the + // _lf_start_time_step() function in reactor_common.c. + // Note that this function is also run once at the end + // so that it can deallocate any memory. + generateStartTimeStep(instance); + initializeTriggerObjects.pr("//***** End initializing " + fullName); } - } - - /** - * Generate code that is executed while the reactor instance is being initialized. This is - * provided as an extension point for subclasses. Normally, the reactions argument is the full - * list of reactions, but for the top-level of a federate, will be a subset of reactions that is - * relevant to the federate. - * - * @param instance The reactor instance. - */ - protected void generateReactorInstanceExtension(ReactorInstance instance) { - // Do nothing - } - - /** - * Generate code that initializes the state variables for a given instance. Unlike parameters, - * state variables are uniformly initialized for all instances of the same reactor. - * - * @param instance The reactor class instance - */ - protected void generateStateVariableInitializations(ReactorInstance instance) { - var reactorClass = instance.getDefinition().getReactorClass(); - var selfRef = CUtil.reactorRef(instance); - for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { - if (isInitialized(stateVar)) { - var mode = - stateVar.eContainer() instanceof Mode - ? instance.lookupModeInstance((Mode) stateVar.eContainer()) - : instance.getMode(false); - initializeTriggerObjects.pr( - CStateGenerator.generateInitializer(instance, selfRef, stateVar, mode, types)); - if (mode != null && stateVar.isReset()) { - modalStateResetCount += instance.getTotalWidth(); + + /** + * For each action of the specified reactor instance, generate initialization code + * for the offset and period fields. + * @param instance The reactor. + */ + private void generateActionInitializations(ReactorInstance instance) { + initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + } + + /** + * Initialize actions by creating a lf_token_t in the self struct. + * This has the information required to allocate memory for the action payload. + * Skip any action that is not actually used as a trigger. + * @param reactor The reactor containing the actions. + */ + private void generateInitializeActionToken(ReactorInstance reactor) { + for (ActionInstance action : reactor.actions) { + // Skip this step if the action is not in use. + if (action.getParent().getTriggers().contains(action) + ) { + var type = getInferredType(action.getDefinition()); + var payloadSize = "0"; + if (!type.isUndefined()) { + var typeStr = types.getTargetType(type); + if (CUtil.isTokenType(type, types)) { + typeStr = CUtil.rootType(typeStr); + } + if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { + payloadSize = "sizeof("+typeStr+")"; + } + } + + var selfStruct = CUtil.reactorRef(action.getParent()); + initializeTriggerObjects.pr( + CActionGenerator.generateTokenInitializer( + selfStruct, action.getName(), payloadSize + ) + ); + } } - } } - } - - /** - * Generate code to set the deadline field of the reactions in the specified reactor instance. - * - * @param instance The reactor instance. - */ - private void generateSetDeadline(ReactorInstance instance) { - for (ReactionInstance reaction : instance.reactions) { - var selfRef = CUtil.reactorRef(reaction.getParent()) + "->_lf__reaction_" + reaction.index; - if (reaction.declaredDeadline != null) { - var deadline = reaction.declaredDeadline.maxDelay; - initializeTriggerObjects.pr( - selfRef + ".deadline = " + types.getTargetTimeExpr(deadline) + ";"); - } else { // No deadline. - initializeTriggerObjects.pr(selfRef + ".deadline = NEVER;"); - } + + /** + * Generate code that is executed while the reactor instance is being initialized. + * This is provided as an extension point for subclasses. + * Normally, the reactions argument is the full list of reactions, + * but for the top-level of a federate, will be a subset of reactions that + * is relevant to the federate. + * @param instance The reactor instance. + */ + protected void generateReactorInstanceExtension(ReactorInstance instance) { + // Do nothing } - } - - /** - * Generate code to initialize modes. - * - * @param instance The reactor instance. - */ - private void generateModeStructure(ReactorInstance instance) { - CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); - if (!instance.modes.isEmpty()) { - modalReactorCount += instance.getTotalWidth(); + + /** + * Generate code that initializes the state variables for a given instance. + * Unlike parameters, state variables are uniformly initialized for all instances + * of the same reactor. + * @param instance The reactor class instance + */ + protected void generateStateVariableInitializations(ReactorInstance instance) { + var reactorClass = instance.getDefinition().getReactorClass(); + var selfRef = CUtil.reactorRef(instance); + for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { + if (isInitialized(stateVar)) { + var mode = stateVar.eContainer() instanceof Mode ? + instance.lookupModeInstance((Mode) stateVar.eContainer()) : + instance.getMode(false); + initializeTriggerObjects.pr(CStateGenerator.generateInitializer( + instance, + selfRef, + stateVar, + mode, + types + )); + if (mode != null && stateVar.isReset()) { + modalStateResetCount += instance.getTotalWidth(); + } + } + } } - } - - /** - * Generate runtime initialization code for parameters of a given reactor instance - * - * @param instance The reactor instance. - */ - protected void generateParameterInitialization(ReactorInstance instance) { - var selfRef = CUtil.reactorRef(instance); - // Set the local bank_index variable so that initializers can use it. - initializeTriggerObjects.pr( - "bank_index = " - + CUtil.bankIndex(instance) - + ";" - + " SUPPRESS_UNUSED_WARNING(bank_index);"); - for (ParameterInstance parameter : instance.parameters) { - // NOTE: we now use the resolved literal value. For better efficiency, we could - // store constants in a global array and refer to its elements to avoid duplicate - // memory allocations. - // NOTE: If the parameter is initialized with a static initializer for an array - // or struct (the initialization expression is surrounded by { ... }), then we - // have to declare a static variable to ensure that the memory is put in data space - // and not on the stack. - // FIXME: Is there a better way to determine this than the string comparison? - var initializer = CParameterGenerator.getInitializer(parameter); - if (initializer.startsWith("{")) { - var temporaryVariableName = parameter.uniqueID(); - initializeTriggerObjects.pr( - String.join( - "\n", - "static " - + types.getVariableDeclaration(parameter.type, temporaryVariableName, true) - + " = " - + initializer - + ";", - selfRef + "->" + parameter.getName() + " = " + temporaryVariableName + ";")); - } else { - initializeTriggerObjects.pr( - selfRef + "->" + parameter.getName() + " = " + initializer + ";"); - } + + /** + * Generate code to set the deadline field of the reactions in the + * specified reactor instance. + * @param instance The reactor instance. + */ + private void generateSetDeadline(ReactorInstance instance) { + for (ReactionInstance reaction : instance.reactions) { + var selfRef = CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+reaction.index; + if (reaction.declaredDeadline != null) { + var deadline = reaction.declaredDeadline.maxDelay; + initializeTriggerObjects.pr(selfRef+".deadline = "+types.getTargetTimeExpr(deadline)+";"); + } else { // No deadline. + initializeTriggerObjects.pr(selfRef+".deadline = NEVER;"); + } + } } - } - - /** - * Generate code that mallocs memory for any output multiports. - * - * @param reactor The reactor instance. - */ - private void initializeOutputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance output : reactor.outputs) { - initializeTriggerObjects.pr( - CPortGenerator.initializeOutputMultiport(output, reactorSelfStruct)); + + /** + * Generate code to initialize modes. + * @param instance The reactor instance. + */ + private void generateModeStructure(ReactorInstance instance) { + CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); + if (!instance.modes.isEmpty()) { + modalReactorCount += instance.getTotalWidth(); + } } - } - - /** - * Allocate memory for inputs. - * - * @param reactor The reactor. - */ - private void initializeInputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance input : reactor.inputs) { - initializeTriggerObjects.pr( - CPortGenerator.initializeInputMultiport(input, reactorSelfStruct)); + + /** + * Generate runtime initialization code for parameters of a given reactor instance + * @param instance The reactor instance. + */ + protected void generateParameterInitialization(ReactorInstance instance) { + var selfRef = CUtil.reactorRef(instance); + // Set the local bank_index variable so that initializers can use it. + initializeTriggerObjects.pr("bank_index = "+CUtil.bankIndex(instance)+";" + + " SUPPRESS_UNUSED_WARNING(bank_index);"); + for (ParameterInstance parameter : instance.parameters) { + // NOTE: we now use the resolved literal value. For better efficiency, we could + // store constants in a global array and refer to its elements to avoid duplicate + // memory allocations. + // NOTE: If the parameter is initialized with a static initializer for an array + // or struct (the initialization expression is surrounded by { ... }), then we + // have to declare a static variable to ensure that the memory is put in data space + // and not on the stack. + // FIXME: Is there a better way to determine this than the string comparison? + var initializer = CParameterGenerator.getInitializer(parameter); + if (initializer.startsWith("{")) { + var temporaryVariableName = parameter.uniqueID(); + initializeTriggerObjects.pr(String.join("\n", + "static "+types.getVariableDeclaration(parameter.type, temporaryVariableName, true)+" = "+initializer+";", + selfRef+"->"+parameter.getName()+" = "+temporaryVariableName+";" + )); + } else { + initializeTriggerObjects.pr(selfRef+"->"+parameter.getName()+" = "+initializer+";"); + } + } } - } - - @Override - public TargetTypes getTargetTypes() { - return types; - } - - /** - * @param context - * @return - */ - protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new CDockerGenerator(context); - } - - // ////////////////////////////////////////// - // // Protected methods. - - // Perform set up that does not generate code - protected void setUpGeneralParameters() { - accommodatePhysicalActionsIfPresent(); - targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); - targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); - // Create the main reactor instance if there is a main reactor. - createMainReactorInstance(); - if (hasModalReactors) { - // So that each separate compile knows about modal reactors, do this: - targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); + + /** + * Generate code that mallocs memory for any output multiports. + * @param reactor The reactor instance. + */ + private void initializeOutputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance output : reactor.outputs) { + initializeTriggerObjects.pr(CPortGenerator.initializeOutputMultiport( + output, + reactorSelfStruct + )); + } } - if (targetConfig.threading - && targetConfig.platformOptions.platform == Platform.ARDUINO - && (targetConfig.platformOptions.board == null - || !targetConfig.platformOptions.board.contains("mbed"))) { - // non-MBED boards should not use threading - System.out.println( - "Threading is incompatible on your current Arduino flavor. Setting threading to false."); - targetConfig.threading = false; + + /** + * Allocate memory for inputs. + * @param reactor The reactor. + */ + private void initializeInputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance input : reactor.inputs) { + initializeTriggerObjects.pr(CPortGenerator.initializeInputMultiport( + input, + reactorSelfStruct + )); + } } - if (targetConfig.platformOptions.platform == Platform.ARDUINO - && !targetConfig.noCompile - && targetConfig.platformOptions.board == null) { - System.out.println( - "To enable compilation for the Arduino platform, you must specify the fully-qualified" - + " board name (FQBN) in the target property. For example, platform: {name: arduino," - + " board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target" - + " code only."); - targetConfig.noCompile = true; + @Override + public TargetTypes getTargetTypes() { + return types; } - if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake - pickScheduler(); - // FIXME: this and pickScheduler should be combined. - targetConfig.compileDefinitions.put("SCHEDULER", targetConfig.schedulerType.name()); - targetConfig.compileDefinitions.put( - "NUMBER_OF_WORKERS", String.valueOf(targetConfig.workers)); + + /** + * Get the Docker generator. + * @param context + * @return + */ + protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new CDockerGenerator(context); } - pickCompilePlatform(); - } - protected void handleProtoFiles() { - // Handle .proto files. - for (String file : targetConfig.protoFiles) { - this.processProtoFile(file); + // ////////////////////////////////////////// + // // Protected methods. + + // Perform set up that does not generate code + protected void setUpGeneralParameters() { + accommodatePhysicalActionsIfPresent(); + targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); + targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); + // Create the main reactor instance if there is a main reactor. + createMainReactorInstance(); + if (hasModalReactors) { + // So that each separate compile knows about modal reactors, do this: + targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); + } + if (targetConfig.threading && targetConfig.platformOptions.platform == Platform.ARDUINO + && (targetConfig.platformOptions.board == null || !targetConfig.platformOptions.board.contains("mbed"))) { + //non-MBED boards should not use threading + System.out.println("Threading is incompatible on your current Arduino flavor. Setting threading to false."); + targetConfig.threading = false; + } + + if (targetConfig.platformOptions.platform == Platform.ARDUINO && !targetConfig.noCompile + && targetConfig.platformOptions.board == null) { + System.out.println("To enable compilation for the Arduino platform, you must specify the fully-qualified board name (FQBN) in the target property. For example, platform: {name: arduino, board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target code only."); + targetConfig.noCompile = true; + } + if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake + pickScheduler(); + // FIXME: this and pickScheduler should be combined. + targetConfig.compileDefinitions.put( + "SCHEDULER", + targetConfig.schedulerType.name() + ); + targetConfig.compileDefinitions.put( + "NUMBER_OF_WORKERS", + String.valueOf(targetConfig.workers) + ); + } + pickCompilePlatform(); } - } - - /** - * Generate code that needs to appear at the top of the generated C file, such as #define and - * #include statements. - */ - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr( - CPreambleGenerator.generateDefineDirectives( - targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); - code.pr(CPreambleGenerator.generateIncludeStatements(targetConfig, CCppMode)); - return code.toString(); - } - - /** Generate top-level preamble code. */ - protected String generateTopLevelPreambles(Reactor reactor) { - CodeBuilder builder = new CodeBuilder(); - var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; - builder.pr("#ifndef " + guard); - builder.pr("#define " + guard); - Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) - .flatMap(it -> ((Model) it.eContainer()).getPreambles().stream()) - .collect(Collectors.toSet()) - .forEach(it -> builder.pr(toText(it.getCode()))); - for (String file : targetConfig.protoFiles) { - var dotIndex = file.lastIndexOf("."); - var rootFilename = file; - if (dotIndex > 0) { - rootFilename = file.substring(0, dotIndex); - } - code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); - builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); + + protected void handleProtoFiles() { + // Handle .proto files. + for (String file : targetConfig.protoFiles) { + this.processProtoFile(file); + } } - builder.pr("#endif"); - return builder.toString(); - } - - protected boolean targetLanguageIsCpp() { - return CCppMode; - } - - /** - * Given a line of text from the output of a compiler, return an instance of ErrorFileAndLine if - * the line is recognized as the first line of an error message. Otherwise, return null. - * - * @param line A line of output from a compiler or other external tool that might generate errors. - * @return If the line is recognized as the start of an error message, then return a class - * containing the path to the file on which the error occurred (or null if there is none), the - * line number (or the string "1" if there is none), the character position (or the string "0" - * if there is none), and the message (or an empty string if there is none). - */ - @Override - public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { - var matcher = compileErrorPattern.matcher(line); - if (matcher.find()) { - var result = new ErrorFileAndLine(); - result.filepath = matcher.group("path"); - result.line = matcher.group("line"); - result.character = matcher.group("column"); - result.message = matcher.group("message"); - - if (!result.message.toLowerCase().contains("error:")) { - result.isError = false; - } - return result; + + /** + * Generate code that needs to appear at the top of the generated + * C file, such as #define and #include statements. + */ + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr(CPreambleGenerator.generateDefineDirectives( + targetConfig, + fileConfig.getSrcGenPath(), + hasModalReactors + )); + code.pr(CPreambleGenerator.generateIncludeStatements( + targetConfig, + CCppMode + )); + return code.toString(); } - return null; - } - - //////////////////////////////////////////// - //// Private methods. - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.C; - } - - //////////////////////////////////////////////////////////// - //// Private methods - - /** - * If a main or federated reactor has been declared, create a ReactorInstance for this top level. - * This will also assign levels to reactions, then, if the program is federated, perform an AST - * transformation to disconnect connections between federates. - */ - private void createMainReactorInstance() { - if (this.mainDef != null) { - if (this.main == null) { - // Recursively build instances. - this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); - var reactionInstanceGraph = this.main.assignLevels(); - if (reactionInstanceGraph.nodeCount() > 0) { - errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); - return; + + /** + * Generate top-level preamble code. + */ + protected String generateTopLevelPreambles(Reactor reactor) { + CodeBuilder builder = new CodeBuilder(); + var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; + builder.pr("#ifndef " + guard); + builder.pr("#define " + guard); + Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) + .flatMap(it -> ((Model) it.eContainer()).getPreambles().stream()) + .collect(Collectors.toSet()) + .forEach(it -> builder.pr(toText(it.getCode()))); + for (String file : targetConfig.protoFiles) { + var dotIndex = file.lastIndexOf("."); + var rootFilename = file; + if (dotIndex > 0) { + rootFilename = file.substring(0, dotIndex); + } + code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); + builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); } - if (hasDeadlines) { - this.main.assignDeadlines(); + builder.pr("#endif"); + return builder.toString(); + } + + protected boolean targetLanguageIsCpp() { + return CCppMode; + } + + /** Given a line of text from the output of a compiler, return + * an instance of ErrorFileAndLine if the line is recognized as + * the first line of an error message. Otherwise, return null. + * @param line A line of output from a compiler or other external + * tool that might generate errors. + * @return If the line is recognized as the start of an error message, + * then return a class containing the path to the file on which the + * error occurred (or null if there is none), the line number (or the + * string "1" if there is none), the character position (or the string + * "0" if there is none), and the message (or an empty string if there + * is none). + */ + @Override + public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { + var matcher = compileErrorPattern.matcher(line); + if (matcher.find()) { + var result = new ErrorFileAndLine(); + result.filepath = matcher.group("path"); + result.line = matcher.group("line"); + result.character = matcher.group("column"); + result.message = matcher.group("message"); + + if (!result.message.toLowerCase().contains("error:")) { + result.isError = false; + } + return result; } - // Inform the run-time of the breadth/parallelism of the reaction graph - var breadth = reactionInstanceGraph.getBreadth(); - if (breadth == 0) { - errorReporter.reportWarning("The program has no reactions"); - } else { - targetConfig.compileDefinitions.put( - "LF_REACTION_GRAPH_BREADTH", String.valueOf(reactionInstanceGraph.getBreadth())); + return null; + } + + //////////////////////////////////////////// + //// Private methods. + + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.C; + } + + //////////////////////////////////////////////////////////// + //// Private methods + + /** + * If a main or federated reactor has been declared, create a ReactorInstance + * for this top level. This will also assign levels to reactions, then, + * if the program is federated, perform an AST transformation to disconnect + * connections between federates. + */ + private void createMainReactorInstance() { + if (this.mainDef != null) { + if (this.main == null) { + // Recursively build instances. + this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); + var reactionInstanceGraph = this.main.assignLevels(); + if (reactionInstanceGraph.nodeCount() > 0) { + errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); + return; + } + if (hasDeadlines) { + this.main.assignDeadlines(); + } + // Inform the run-time of the breadth/parallelism of the reaction graph + var breadth = reactionInstanceGraph.getBreadth(); + if (breadth == 0) { + errorReporter.reportWarning("The program has no reactions"); + } else { + targetConfig.compileDefinitions.put( + "LF_REACTION_GRAPH_BREADTH", + String.valueOf(reactionInstanceGraph.getBreadth()) + ); + } + } } - } } - } - - /** - * Generate an array of self structs for the reactor and one for each of its children. - * - * @param r The reactor instance. - */ - private void generateSelfStructs(ReactorInstance r) { - initializeTriggerObjects.pr( - CUtil.selfType(r) + "* " + CUtil.reactorRefName(r) + "[" + r.getTotalWidth() + "];"); - initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING(" + CUtil.reactorRefName(r) + ");"); - for (ReactorInstance child : r.children) { - generateSelfStructs(child); + + /** + * Generate an array of self structs for the reactor + * and one for each of its children. + * @param r The reactor instance. + */ + private void generateSelfStructs(ReactorInstance r) { + initializeTriggerObjects.pr(CUtil.selfType(r)+"* "+CUtil.reactorRefName(r)+"["+r.getTotalWidth()+"];"); + initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING("+CUtil.reactorRefName(r)+");"); + for (ReactorInstance child : r.children) { + generateSelfStructs(child); + } } - } } From 11ccfad20c2e7fcd150de800e8e1e29d466b6843 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 07:43:05 +0200 Subject: [PATCH 216/709] Removed the advice to run the formatter --- CONTRIBUTING.md | 15 +-------------- 1 file changed, 1 insertion(+), 14 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 13d24c957c..55716f5b17 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -25,8 +25,7 @@ Test categories are declared in the [TestCategory enum in TestRegistry.java](htt ### Workflow All code contributions must go through a pull request (PR), pass all tests run in CI, and get an approving review before it is merged. Pushing to the `master` branch is restricted. All code review is conducted using the Github review system on PRs. Before requesting a code review, ensure that you have: -- applied the [code formatter](#code-style-and-formatting); -- [documented](#code-style-and-formatting) your code; +- documented your code; - written [tests](#writing-tests) that cover your code; and - accompanied any remaining `TODO`s or `FIXME`s with a link to an active [issue](#reporting-issues). @@ -73,18 +72,6 @@ Perform merges to bring your feature branch up-to-date with master locally (do n #### Addressing reviews To address feedback from code review, implement changes and push to your feature branch. If you are certain that a reviewer's concern has been addressed by your new changes, hit the `Resolve conversation` button. If you are unsure, ask for follow up in the conversation and let the reviewer determine whether the feedback was addressed accordingly. -### Code style and formatting -The Lingua Franca compiler is implemented in Java and Kotlin. The overarching advice is to use each language's most widely used idioms and conventions, which are fortunately very similar. The code base is shipped with a [Spotless](https://github.com/diffplug/spotless) configuration to check and enforce style compliance. Lingua Franca code (e.g., tests) in this repository is also automatically formatted via Spotless. - -- To check that modified files are formatted correctly, run: -``` -./gradlew spotlessCheck -``` -- To apply the changes recommended by the formatter, run: -``` -./gradlew spotlessApply -``` - #### General guidelines - _Do not copy-paste code._ If you want to reuse code, factor it out into a method and call it. - _Keep methods concise._ As a rule of thumb, a method should fit on your screen so that it can be read without scrolling. We impose no hard limit on method length, but anything above 40 lines should be considered for breaking up. From e3d967bc1daf29089aa8a4ab7234c57cd0dc1945 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 08:28:41 +0200 Subject: [PATCH 217/709] Merge single file with master --- org.lflang/src/org/lflang/TargetProperty.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index 1bacb1f75e..61cda14431 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -276,16 +276,16 @@ public enum TargetProperty { * processed by the code generator. */ FILES("files", UnionType.FILE_OR_FILE_ARRAY, List.of(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.fileNames), + (config) -> ASTUtils.toElement(config.files), (config, value, err) -> { - config.fileNames = ASTUtils.elementToListOfStrings(value); + config.files = ASTUtils.elementToListOfStrings(value); }, // FIXME: This merging of lists is potentially dangerous since // the incoming list of files can belong to a .lf file that is // located in a different location, and keeping just filename // strings like this without absolute paths is incorrect. (config, value, err) -> { - config.fileNames.addAll(ASTUtils.elementToListOfStrings(value)); + config.files.addAll(ASTUtils.elementToListOfStrings(value)); }), /** From eae9ebda5927974068e1641ad93d4a7642b21b37 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 08:29:20 +0200 Subject: [PATCH 218/709] Merge single file with master --- .../federated/generator/FedFileConfig.java | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java index 42f5c60dc7..e434501825 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java @@ -27,6 +27,7 @@ import java.io.IOException; import java.nio.file.Path; +import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; @@ -110,7 +111,7 @@ public void doClean() throws IOException { */ public void relativizePaths(FedTargetConfig targetConfig) { relativizePathList(targetConfig.protoFiles); - relativizePathList(targetConfig.fileNames); + relativizePathList(targetConfig.files); relativizePathList(targetConfig.cmakeIncludes); } @@ -120,17 +121,22 @@ public void relativizePaths(FedTargetConfig targetConfig) { */ private void relativizePathList(List paths) { List tempList = new ArrayList<>(); - paths.forEach(f -> tempList.add(relativizePath(f))); + paths.forEach(f -> tempList.add(relativizePath(Paths.get(f)))); paths.clear(); paths.addAll(tempList); } /** - * Relativize a single path. + * Relativize a single path, but only if it points to a local resource in the project (i.e., not + * on the class path). * @param path The path to relativize. */ - private String relativizePath(String path) { - Path resolvedPath = this.srcPath.resolve(path).toAbsolutePath(); - return this.getSrcPath().relativize(resolvedPath).toString(); + private String relativizePath(Path path) { + if (FileUtil.findInPackage(path, this) == null) { + return String.valueOf(path); + } else { + Path resolvedPath = this.srcPath.resolve(path).toAbsolutePath(); + return this.getSrcPath().relativize(resolvedPath).toString(); + } } } From 92ce015a0f99c4768bca01f27cdcbce27aae149a Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 08:29:55 +0200 Subject: [PATCH 219/709] Merge single file with master --- org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index 3f5eb4a5b7..d158f7491b 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -25,6 +25,7 @@ package org.lflang.generator.c; +import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; @@ -313,8 +314,8 @@ CodeBuilder generateCMakeCode( cMakeCode.newLine(); // Add the include file - for (String includeFile : targetConfig.cmakeIncludesWithoutPath) { - cMakeCode.pr("include(\""+includeFile+"\")"); + for (String includeFile : targetConfig.cmakeIncludes) { + cMakeCode.pr("include(\""+ Path.of(includeFile).getFileName()+"\")"); } cMakeCode.newLine(); From a4365c867db012be21fab28336231195846ed246 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 08:30:36 +0200 Subject: [PATCH 220/709] Remove use of Google Objects class --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 7bc579ac0f..590cdb167c 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -398,7 +398,7 @@ public void accommodatePhysicalActionsIfPresent() { // keepalive is set to true, unless the user has explicitly set it to false. for (Resource resource : GeneratorUtils.getResources(reactors)) { for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { - if (Objects.equal(action.getOrigin(), ActionOrigin.PHYSICAL)) { + if (ActionOrigin.PHYSICAL.equals(action.getOrigin())) { // If the unthreaded runtime is not requested by the user, use the threaded runtime instead // because it is the only one currently capable of handling asynchronous events. if (!targetConfig.threading && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { @@ -1484,7 +1484,7 @@ private void generateStartTimeStep(ReactorInstance instance) { temp.pr("// Add port "+port.getFullName()+" to array of is_present fields."); - if (!Objects.equal(port.getParent(), instance)) { + if (!instance.equals(port.getParent())) { // The port belongs to contained reactor, so we also have // iterate over the instance bank members. temp.startScopedBlock(); @@ -1507,7 +1507,7 @@ private void generateStartTimeStep(ReactorInstance instance) { startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); - if (!Objects.equal(port.getParent(), instance)) { + if (!instance.equals(port.getParent())) { temp.pr("count++;"); temp.endScopedBlock(); temp.endScopedBlock(); From e71ffdf9bc350781777aba85b193f4dc15e79c57 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 08:45:20 +0200 Subject: [PATCH 221/709] Restored accidentally removed watchdog line --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 590cdb167c..b7ce5ff1fb 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1208,6 +1208,9 @@ private void generateSelfStruct(CodeBuilder builder, ReactorDecl decl, CodeBuild types ); + // Generate the fields needed for each watchdog. + CWatchdogGenerator.generateWatchdogStruct(body, decl, constructorCode); + // Next, generate fields for modes CModesGenerator.generateDeclarations(reactor, body, constructorCode); From 45f728620d6930515c874ed19bbec4b4c69904eb Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 08:50:17 +0200 Subject: [PATCH 222/709] Merge single file with master --- .gitmodules | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitmodules b/.gitmodules index 274bffab2c..3ccd9f3a7f 100644 --- a/.gitmodules +++ b/.gitmodules @@ -6,7 +6,7 @@ url = https://github.com/lf-lang/reactor-c-py.git [submodule "org.lflang/src/lib/cpp/reactor-cpp"] path = org.lflang/src/lib/cpp/reactor-cpp - url = https://github.com/lf-lang/reactor-cpp.git + url = https://github.com/lf-lang/reactor-cpp [submodule "org.lflang/src/lib/rs/reactor-rs"] path = org.lflang/src/lib/rs/reactor-rs - url = https://github.com/lf-lang/reactor-rs.git + url = https://github.com/lf-lang/reactor-rs From 442f80869c7d7f486aa2be52e8addb211573f694 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 09:06:15 +0200 Subject: [PATCH 223/709] Restored file to unformatted version --- .../federated/generator/FederateInstance.java | 1127 +++++++++-------- 1 file changed, 587 insertions(+), 540 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index 349ff0fff7..7ca5a19bca 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -1,31 +1,31 @@ -/** - * Instance of a federate specification. - * - *

Copyright (c) 2020, The University of California at Berkeley. - * - *

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. +/** Instance of a federate specification. * - *

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. - * - *

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR - * CONTRIBUTORS 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. - * ************* - */ +Copyright (c) 2020, The University of California at Berkeley. + +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. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. +***************/ + package org.lflang.federated.generator; -import com.google.common.base.Objects; +import java.io.File; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; @@ -35,16 +35,22 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; + import org.eclipse.emf.ecore.EObject; + import org.lflang.ASTUtils; import org.lflang.ErrorReporter; +import org.lflang.FileConfig; +import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TimeValue; import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.generator.ActionInstance; +import org.lflang.generator.GeneratorUtils; import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; +import org.lflang.generator.SubContext; import org.lflang.generator.TriggerInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; @@ -65,557 +71,598 @@ import org.lflang.lf.VarRef; import org.lflang.lf.Variable; +import com.google.common.base.Objects; + + /** - * Instance of a federate, or marker that no federation has been defined (if isSingleton() returns - * true) FIXME: this comment makes no sense. Every top-level reactor (contained directly by the main - * reactor) is a federate, so there will be one instance of this class for each top-level reactor. + * Instance of a federate, or marker that no federation has been defined + * (if isSingleton() returns true) FIXME: this comment makes no sense. + * Every top-level reactor (contained + * directly by the main reactor) is a federate, so there will be one + * instance of this class for each top-level reactor. * * @author Edward A. Lee * @author Soroush Bateni */ public class FederateInstance { // why does this not extend ReactorInstance? - /** - * Construct a new instance with the specified instantiation of of a top-level reactor. The - * federate will be given the specified integer ID. - * - * @param instantiation The instantiation of a top-level reactor, or null if no federation has - * been defined. - * @param id The federate ID. - * @param bankIndex If instantiation.widthSpec !== null, this gives the bank position. - * @param errorReporter The error reporter - */ - public FederateInstance( - Instantiation instantiation, - int id, - int bankIndex, - TargetConfig targetConfig, - ErrorReporter errorReporter) { - this.instantiation = instantiation; - this.id = id; - this.bankIndex = bankIndex; - this.errorReporter = errorReporter; - this.targetConfig = targetConfig; - - if (instantiation != null) { - this.name = instantiation.getName(); - // If the instantiation is in a bank, then we have to append - // the bank index to the name. - if (instantiation.getWidthSpec() != null) { - this.name = instantiation.getName() + "__" + bankIndex; - } - } - } - - ///////////////////////////////////////////// - //// Public Fields - - /** - * The position within a bank of reactors for this federate. This is 0 if the instantiation is not - * a bank of reactors. - */ - public int bankIndex = 0; - - /** A list of outputs that can be triggered directly or indirectly by physical actions. */ - public Set outputsConnectedToPhysicalActions = new LinkedHashSet<>(); - - /** The host, if specified using the 'at' keyword. */ - public String host = "localhost"; - - /** The instantiation of the top-level reactor, or null if there is no federation. */ - public Instantiation instantiation; - - public Instantiation getInstantiation() { - return instantiation; - } - - /** A list of individual connections between federates */ - public Set connections = new HashSet<>(); - - /** - * Map from the federates that this federate receives messages from to the delays on connections - * from that federate. The delay set may include null, meaning that there is a connection from the - * federate instance that has no delay. - */ - public Map> dependsOn = new LinkedHashMap<>(); - - /** The directory, if specified using the 'at' keyword. */ - public String dir = null; - - /** The port, if specified using the 'at' keyword. */ - public int port = 0; - - /** - * Map from the federates that this federate sends messages to to the delays on connections to - * that federate. The delay set may may include null, meaning that there is a connection from the - * federate instance that has no delay. - */ - public Map> sendsTo = new LinkedHashMap<>(); - - /** The user, if specified using the 'at' keyword. */ - public String user = null; - - /** The integer ID of this federate. */ - public int id = 0; - - /** - * The name of this federate instance. This will be the instantiation name, possibly appended with - * "__n", where n is the bank position of this instance if the instantiation is of a bank of - * reactors. - */ - public String name = "Unnamed"; - - /** - * List of networkMessage actions. Each of these handles a message received from another federate - * over the network. The ID of receiving port is simply the position of the action in the list. - * The sending federate needs to specify this ID. - */ - public List networkMessageActions = new ArrayList<>(); - - /** - * A set of federates with which this federate has an inbound connection There will only be one - * physical connection even if federate A has defined multiple physical connections to federate B. - * The message handler on federate A will be responsible for including the appropriate information - * in the message header (such as port ID) to help the receiver distinguish different events. - */ - public Set inboundP2PConnections = new LinkedHashSet<>(); - - /** - * A list of federate with which this federate has an outbound physical connection. There will - * only be one physical connection even if federate A has defined multiple physical connections to - * federate B. The message handler on federate B will be responsible for distinguishing the - * incoming messages by parsing their header and scheduling the appropriate action. - */ - public Set outboundP2PConnections = new LinkedHashSet<>(); - - /** - * A list of triggers for network input control reactions. This is used to trigger all the input - * network control reactions that might be nested in a hierarchy. - */ - public List networkInputControlReactionsTriggers = new ArrayList<>(); - - /** - * The trigger that triggers the output control reaction of this federate. - * - *

The network output control reactions send a PORT_ABSENT message for a network output port, - * if it is absent at the current tag, to notify all downstream federates that no value will be - * present on the given network port, allowing input control reactions on those federates to stop - * blocking. - */ - public Variable networkOutputControlReactionsTrigger = null; - - /** Indicates whether the federate is remote or local */ - public boolean isRemote = false; - - /** - * List of generated network reactions (network receivers, network input control reactions, - * network senders, and network output control reactions) that belong to this federate instance. - */ - public List networkReactions = new ArrayList<>(); - - /** Parsed target config of the federate. */ - public TargetConfig targetConfig; - - /** Keep a unique list of enabled serializers */ - public HashSet enabledSerializers = new HashSet<>(); - - /** - * Return true if the specified EObject should be included in the code generated for this - * federate. - * - * @param object An {@code EObject} - * @return True if this federate contains the EObject. - */ - public boolean contains(EObject object) { - if (object instanceof Action) { - return contains((Action) object); - } else if (object instanceof Reaction) { - return contains((Reaction) object); - } else if (object instanceof Timer) { - return contains((Timer) object); - } else if (object instanceof ReactorDecl) { - return contains(this.instantiation, (ReactorDecl) object); - } else if (object instanceof Import) { - return contains((Import) object); - } else if (object instanceof Parameter) { - return contains((Parameter) object); - } else if (object instanceof StateVar) { - return true; // FIXME: Should we disallow state vars at the top level? - } - throw new UnsupportedOperationException( - "EObject class " + object.eClass().getName() + " not supported."); - } - - /** - * Return true if the specified reactor belongs to this federate. - * - * @param instantiation The instantiation to look inside - * @param reactor The reactor declaration to find - */ - private boolean contains(Instantiation instantiation, ReactorDecl reactor) { - if (instantiation.getReactorClass().equals(ASTUtils.toDefinition(reactor))) { - return true; + /** + * Construct a new instance with the specified instantiation of + * of a top-level reactor. The federate will be given the specified + * integer ID. + * @param instantiation The instantiation of a top-level reactor, + * or null if no federation has been defined. + * @param id The federate ID. + * @param bankIndex If instantiation.widthSpec !== null, this gives the bank position. + * @param errorReporter The error reporter + */ + public FederateInstance( + Instantiation instantiation, + int id, + int bankIndex, + TargetConfig targetConfig, + ErrorReporter errorReporter) { + this.instantiation = instantiation; + this.id = id; + this.bankIndex = bankIndex; + this.errorReporter = errorReporter; + this.targetConfig = targetConfig; + + if (instantiation != null) { + this.name = instantiation.getName(); + // If the instantiation is in a bank, then we have to append + // the bank index to the name. + if (instantiation.getWidthSpec() != null) { + this.name = instantiation.getName() + "__" + bankIndex; + } + } } - boolean instantiationsCheck = false; - // For a federate, we don't need to look inside imported reactors. - if (instantiation.getReactorClass() instanceof Reactor reactorDef) { - for (Instantiation child : reactorDef.getInstantiations()) { - instantiationsCheck |= contains(child, reactor); - } + ///////////////////////////////////////////// + //// Public Fields + + /** + * The position within a bank of reactors for this federate. + * This is 0 if the instantiation is not a bank of reactors. + */ + public int bankIndex = 0; + + /** + * A list of outputs that can be triggered directly or indirectly by physical actions. + */ + public Set outputsConnectedToPhysicalActions = new LinkedHashSet<>(); + + /** + * The host, if specified using the 'at' keyword. + */ + public String host = "localhost"; + + + /** + * The instantiation of the top-level reactor, or null if there is no federation. + */ + public Instantiation instantiation; + public Instantiation getInstantiation() { + return instantiation; } - return instantiationsCheck; - } - - /** - * Return true if the specified import should be included in the code generated for this federate. - * - * @param imp The import - */ - private boolean contains(Import imp) { - for (ImportedReactor reactor : imp.getReactorClasses()) { - if (contains(reactor)) { - return true; - } - } - return false; - } - - /** - * Return true if the specified parameter should be included in the code generated for this - * federate. - * - * @param param The parameter - */ - private boolean contains(Parameter param) { - boolean returnValue = false; - // Check if param is referenced in this federate's instantiation - returnValue = - instantiation.getParameters().stream() - .anyMatch( - assignment -> - assignment.getRhs().getExprs().stream() - .filter(it -> it instanceof ParameterReference) - .map(it -> ((ParameterReference) it).getParameter()) - .toList() - .contains(param)); - // If there are any user-defined top-level reactions, they could access - // the parameters, so we need to include the parameter. - var topLevelUserDefinedReactions = - ((Reactor) instantiation.eContainer()) - .getReactions().stream() - .filter(r -> !networkReactions.contains(r) && contains(r)) - .collect(Collectors.toCollection(ArrayList::new)); - returnValue |= !topLevelUserDefinedReactions.isEmpty(); - return returnValue; - } - - /** - * Return true if the specified action should be included in the code generated for this federate. - * This means that either the action is used as a trigger, a source, or an effect in a top-level - * reaction that belongs to this federate. This returns true if the program is not federated. - * - * @param action The action - * @return True if this federate contains the action. - */ - private boolean contains(Action action) { - Reactor reactor = ASTUtils.getEnclosingReactor(action); - - // If the action is used as a trigger, a source, or an effect for a top-level reaction - // that belongs to this federate, then generate it. - for (Reaction react : ASTUtils.allReactions(reactor)) { - if (contains(react)) { - // Look in triggers - for (TriggerRef trigger : convertToEmptyListIfNull(react.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (Objects.equal(triggerAsVarRef.getVariable(), action)) { - return true; - } - } + /** + * A list of individual connections between federates + */ + public Set connections = new HashSet<>(); + + /** + * Map from the federates that this federate receives messages from + * to the delays on connections from that federate. The delay set + * may include null, meaning that there is a connection + * from the federate instance that has no delay. + */ + public Map> dependsOn = new LinkedHashMap<>(); + + /** + * The directory, if specified using the 'at' keyword. + */ + public String dir = null; + + /** + * The port, if specified using the 'at' keyword. + */ + public int port = 0; + + /** + * Map from the federates that this federate sends messages to + * to the delays on connections to that federate. The delay set + * may may include null, meaning that there is a connection + * from the federate instance that has no delay. + */ + public Map> sendsTo = new LinkedHashMap<>(); + + /** + * The user, if specified using the 'at' keyword. + */ + public String user = null; + + /** + * The integer ID of this federate. + */ + public int id = 0; + + + /** + * The name of this federate instance. This will be the instantiation + * name, possibly appended with "__n", where n is the bank position of + * this instance if the instantiation is of a bank of reactors. + */ + public String name = "Unnamed"; + + /** + * List of networkMessage actions. Each of these handles a message + * received from another federate over the network. The ID of + * receiving port is simply the position of the action in the list. + * The sending federate needs to specify this ID. + */ + public List networkMessageActions = new ArrayList<>(); + + /** + * A set of federates with which this federate has an inbound connection + * There will only be one physical connection even if federate A has defined multiple + * physical connections to federate B. The message handler on federate A will be + * responsible for including the appropriate information in the message header (such as port ID) + * to help the receiver distinguish different events. + */ + public Set inboundP2PConnections = new LinkedHashSet<>(); + + /** + * A list of federate with which this federate has an outbound physical connection. + * There will only be one physical connection even if federate A has defined multiple + * physical connections to federate B. The message handler on federate B will be + * responsible for distinguishing the incoming messages by parsing their header and + * scheduling the appropriate action. + */ + public Set outboundP2PConnections = new LinkedHashSet<>(); + + /** + * A list of triggers for network input control reactions. This is used to trigger + * all the input network control reactions that might be nested in a hierarchy. + */ + public List networkInputControlReactionsTriggers = new ArrayList<>(); + + /** + * The trigger that triggers the output control reaction of this + * federate. + * + * The network output control reactions send a PORT_ABSENT message for a network output port, + * if it is absent at the current tag, to notify all downstream federates that no value will + * be present on the given network port, allowing input control reactions on those federates + * to stop blocking. + */ + public Variable networkOutputControlReactionsTrigger = null; + + /** + * Indicates whether the federate is remote or local + */ + public boolean isRemote = false; + + /** + * List of generated network reactions (network receivers, + * network input control reactions, network senders, and network output control + * reactions) that belong to this federate instance. + */ + public List networkReactions = new ArrayList<>(); + + /** + * Parsed target config of the federate. + */ + public TargetConfig targetConfig; + + /** + * Keep a unique list of enabled serializers + */ + public HashSet enabledSerializers = new HashSet<>(); + + /** + * Return true if the specified EObject should be included in the code + * generated for this federate. + * + * @param object An {@code EObject} + * @return True if this federate contains the EObject. + */ + public boolean contains(EObject object) { + if (object instanceof Action) { + return contains((Action)object); + } else if (object instanceof Reaction) { + return contains((Reaction)object); + } else if (object instanceof Timer) { + return contains((Timer)object); + } else if (object instanceof ReactorDecl) { + return contains(this.instantiation, (ReactorDecl)object); + } else if (object instanceof Import) { + return contains((Import)object); + } else if (object instanceof Parameter) { + return contains((Parameter)object); + } else if (object instanceof StateVar) { + return true; // FIXME: Should we disallow state vars at the top level? } - // Look in sources - for (VarRef source : convertToEmptyListIfNull(react.getSources())) { - if (Objects.equal(source.getVariable(), action)) { + throw new UnsupportedOperationException("EObject class "+object.eClass().getName()+" not supported."); + } + + /** + * Return true if the specified reactor belongs to this federate. + * @param instantiation The instantiation to look inside + * @param reactor The reactor declaration to find + */ + private boolean contains( + Instantiation instantiation, + ReactorDecl reactor + ) { + if (instantiation.getReactorClass().equals(ASTUtils.toDefinition(reactor))) { return true; - } } - // Look in effects - for (VarRef effect : convertToEmptyListIfNull(react.getEffects())) { - if (Objects.equal(effect.getVariable(), action)) { - return true; - } + + boolean instantiationsCheck = false; + // For a federate, we don't need to look inside imported reactors. + if (instantiation.getReactorClass() instanceof Reactor reactorDef) { + for (Instantiation child : reactorDef.getInstantiations()) { + instantiationsCheck |= contains(child, reactor); + } } - } - } - return false; - } - - /** - * Return true if the specified reaction should be included in the code generated for this - * federate at the top-level. This means that if the reaction is triggered by or sends data to a - * port of a contained reactor, then that reaction is in the federate. Otherwise, return false. - * - *

NOTE: This method assumes that it will not be called with reaction arguments that are within - * other federates. It should only be called on reactions that are either at the top level or - * within this federate. For this reason, for any reaction not at the top level, it returns true. - * - * @param reaction The reaction. - */ - private boolean contains(Reaction reaction) { - Reactor reactor = ASTUtils.getEnclosingReactor(reaction); - - assert reactor != null; - if (!reactor.getReactions().contains(reaction)) return false; - - if (networkReactions.contains(reaction)) { - // Reaction is a network reaction that belongs to this federate - return true; + return instantiationsCheck; } - int reactionBankIndex = FedASTUtils.getReactionBankIndex(reaction); - if (reactionBankIndex >= 0 && this.bankIndex >= 0 && reactionBankIndex != this.bankIndex) { - return false; + /** + * Return true if the specified import should be included in the code generated for this federate. + * @param imp The import + */ + private boolean contains(Import imp) { + for (ImportedReactor reactor : imp.getReactorClasses()) { + if (contains(reactor)) { + return true; + } + } + return false; } - // If this has been called before, then the result of the - // following check is cached. - if (excludeReactions != null) { - return !excludeReactions.contains(reaction); + /** + * Return true if the specified parameter should be included in the code generated for this federate. + * @param param The parameter + */ + private boolean contains(Parameter param) { + boolean returnValue = false; + // Check if param is referenced in this federate's instantiation + returnValue = instantiation.getParameters().stream().anyMatch( + assignment -> assignment.getRhs() + .getExprs() + .stream() + .filter( + it -> it instanceof ParameterReference + ) + .map(it -> ((ParameterReference) it).getParameter()) + .toList() + .contains(param) + ); + // If there are any user-defined top-level reactions, they could access + // the parameters, so we need to include the parameter. + var topLevelUserDefinedReactions = ((Reactor) instantiation.eContainer()) + .getReactions().stream().filter( + r -> !networkReactions.contains(r) && contains(r) + ).collect(Collectors.toCollection(ArrayList::new)); + returnValue |= !topLevelUserDefinedReactions.isEmpty(); + return returnValue; } - indexExcludedTopLevelReactions(reactor); - - return !excludeReactions.contains(reaction); - } - - /** - * Return true if the specified timer should be included in the code generated for the federate. - * This means that the timer is used as a trigger in a top-level reaction that belongs to this - * federate. This also returns true if the program is not federated. - * - * @return True if this federate contains the action in the specified reactor - */ - private boolean contains(Timer timer) { - Reactor reactor = ASTUtils.getEnclosingReactor(timer); - - // If the action is used as a trigger, a source, or an effect for a top-level reaction - // that belongs to this federate, then generate it. - for (Reaction r : ASTUtils.allReactions(reactor)) { - if (contains(r)) { - // Look in triggers - for (TriggerRef trigger : convertToEmptyListIfNull(r.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (Objects.equal(triggerAsVarRef.getVariable(), timer)) { - return true; + /** + * Return true if the specified action should be included in the code generated + * for this federate. This means that either the action is used as a trigger, + * a source, or an effect in a top-level reaction that belongs to this federate. + * This returns true if the program is not federated. + * + * @param action The action + * @return True if this federate contains the action. + */ + private boolean contains(Action action) { + Reactor reactor = ASTUtils.getEnclosingReactor(action); + + // If the action is used as a trigger, a source, or an effect for a top-level reaction + // that belongs to this federate, then generate it. + for (Reaction react : ASTUtils.allReactions(reactor)) { + if (contains(react)) { + // Look in triggers + for (TriggerRef trigger : convertToEmptyListIfNull(react.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (Objects.equal(triggerAsVarRef.getVariable(), action)) { + return true; + } + } + } + // Look in sources + for (VarRef source : convertToEmptyListIfNull(react.getSources())) { + if (Objects.equal(source.getVariable(), action)) { + return true; + } + } + // Look in effects + for (VarRef effect : convertToEmptyListIfNull(react.getEffects())) { + if (Objects.equal(effect.getVariable(), action)) { + return true; + } + } } - } } - } + + return false; } - return false; - } - - /** - * Return true if the specified reactor instance or any parent reactor instance is contained by - * this federate. If the specified instance is the top-level reactor, return true (the top-level - * reactor belongs to all federates). If this federate instance is a singleton, then return true - * if the instance is non null. - * - *

NOTE: If the instance is bank within the top level, then this returns true even though only - * one of the bank members is in the federate. - * - * @param instance The reactor instance. - * @return True if this federate contains the reactor instance - */ - public boolean contains(ReactorInstance instance) { - if (instance.getParent() == null) { - return true; // Top-level reactor - } - // Start with this instance, then check its parents. - ReactorInstance i = instance; - while (i != null) { - if (i.getDefinition() == instantiation) { - return true; - } - i = i.getParent(); + + /** + * Return true if the specified reaction should be included in the code generated for this + * federate at the top-level. This means that if the reaction is triggered by or + * sends data to a port of a contained reactor, then that reaction + * is in the federate. Otherwise, return false. + * + * NOTE: This method assumes that it will not be called with reaction arguments + * that are within other federates. It should only be called on reactions that are + * either at the top level or within this federate. For this reason, for any reaction + * not at the top level, it returns true. + * + * @param reaction The reaction. + */ + private boolean contains(Reaction reaction) { + Reactor reactor = ASTUtils.getEnclosingReactor(reaction); + + assert reactor != null; + if (!reactor.getReactions().contains(reaction)) return false; + + if (networkReactions.contains(reaction)) { + // Reaction is a network reaction that belongs to this federate + return true; + } + + int reactionBankIndex = FedASTUtils.getReactionBankIndex(reaction); + if (reactionBankIndex >= 0 && this.bankIndex >= 0 && reactionBankIndex != this.bankIndex) { + return false; + } + + // If this has been called before, then the result of the + // following check is cached. + if (excludeReactions != null) { + return !excludeReactions.contains(reaction); + } + + indexExcludedTopLevelReactions(reactor); + + return !excludeReactions.contains(reaction); } - return false; - } - - /** - * Build an index of reactions at the top-level (in the federatedReactor) that don't belong to - * this federate instance. This index is put in the excludeReactions class variable. - * - * @param federatedReactor The top-level federated reactor - */ - private void indexExcludedTopLevelReactions(Reactor federatedReactor) { - boolean inFederate = false; - if (excludeReactions != null) { - throw new IllegalStateException( - "The index for excluded reactions at the top level is already built."); + + /** + * Return true if the specified timer should be included in the code generated + * for the federate. This means that the timer is used as a trigger + * in a top-level reaction that belongs to this federate. + * This also returns true if the program is not federated. + * + * @return True if this federate contains the action in the specified reactor + */ + private boolean contains(Timer timer) { + Reactor reactor = ASTUtils.getEnclosingReactor(timer); + + // If the action is used as a trigger, a source, or an effect for a top-level reaction + // that belongs to this federate, then generate it. + for (Reaction r : ASTUtils.allReactions(reactor)) { + if (contains(r)) { + // Look in triggers + for (TriggerRef trigger : convertToEmptyListIfNull(r.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (Objects.equal(triggerAsVarRef.getVariable(), timer)) { + return true; + } + } + } + } + } + + return false; } - excludeReactions = new LinkedHashSet<>(); - - // Construct the set of excluded reactions for this federate. - // If a reaction is a network reaction that belongs to this federate, we - // don't need to perform this analysis. - Iterable reactions = - ASTUtils.allReactions(federatedReactor).stream() - .filter(it -> !networkReactions.contains(it)) - .collect(Collectors.toList()); - for (Reaction react : reactions) { - // Create a collection of all the VarRefs (i.e., triggers, sources, and effects) in the react - // signature that are ports that reference federates. - // We then later check that all these VarRefs reference this federate. If not, we will add - // this - // react to the list of reactions that have to be excluded (note that mixing VarRefs from - // different federates is not allowed). - List allVarRefsReferencingFederates = new ArrayList<>(); - // Add all the triggers that are outputs - Stream triggersAsVarRef = - react.getTriggers().stream().filter(it -> it instanceof VarRef).map(it -> (VarRef) it); - allVarRefsReferencingFederates.addAll( - triggersAsVarRef.filter(it -> it.getVariable() instanceof Output).toList()); - // Add all the sources that are outputs - allVarRefsReferencingFederates.addAll( - react.getSources().stream().filter(it -> it.getVariable() instanceof Output).toList()); - // Add all the effects that are inputs - allVarRefsReferencingFederates.addAll( - react.getEffects().stream().filter(it -> it.getVariable() instanceof Input).toList()); - inFederate = containsAllVarRefs(allVarRefsReferencingFederates); - if (!inFederate) { - excludeReactions.add(react); - } + /** + * Return true if the specified reactor instance or any parent + * reactor instance is contained by this federate. + * If the specified instance is the top-level reactor, return true + * (the top-level reactor belongs to all federates). + * If this federate instance is a singleton, then return true if the + * instance is non null. + * + * NOTE: If the instance is bank within the top level, then this + * returns true even though only one of the bank members is in the federate. + * + * @param instance The reactor instance. + * @return True if this federate contains the reactor instance + */ + public boolean contains(ReactorInstance instance) { + if (instance.getParent() == null) { + return true; // Top-level reactor + } + // Start with this instance, then check its parents. + ReactorInstance i = instance; + while (i != null) { + if (i.getDefinition() == instantiation) { + return true; + } + i = i.getParent(); + } + return false; } - } - - /** - * Return true if all members of 'varRefs' belong to this federate. - * - *

As a convenience measure, if some members of 'varRefs' are from different federates, also - * report an error. - * - * @param varRefs A collection of VarRefs - */ - private boolean containsAllVarRefs(Iterable varRefs) { - var referencesFederate = false; - var inFederate = true; - for (VarRef varRef : varRefs) { - if (varRef.getContainer() == this.instantiation) { - referencesFederate = true; - } else { - if (referencesFederate) { - errorReporter.reportError( - varRef, - "Mixed triggers and effects from" + " different federates. This is not permitted"); + + /** + * Build an index of reactions at the top-level (in the + * federatedReactor) that don't belong to this federate + * instance. This index is put in the excludeReactions + * class variable. + * + * @param federatedReactor The top-level federated reactor + */ + private void indexExcludedTopLevelReactions(Reactor federatedReactor) { + boolean inFederate = false; + if (excludeReactions != null) { + throw new IllegalStateException("The index for excluded reactions at the top level is already built."); + } + + excludeReactions = new LinkedHashSet<>(); + + // Construct the set of excluded reactions for this federate. + // If a reaction is a network reaction that belongs to this federate, we + // don't need to perform this analysis. + Iterable reactions = ASTUtils.allReactions(federatedReactor).stream().filter(it -> !networkReactions.contains(it)).collect(Collectors.toList()); + for (Reaction react : reactions) { + // Create a collection of all the VarRefs (i.e., triggers, sources, and effects) in the react + // signature that are ports that reference federates. + // We then later check that all these VarRefs reference this federate. If not, we will add this + // react to the list of reactions that have to be excluded (note that mixing VarRefs from + // different federates is not allowed). + List allVarRefsReferencingFederates = new ArrayList<>(); + // Add all the triggers that are outputs + Stream triggersAsVarRef = react.getTriggers().stream().filter(it -> it instanceof VarRef).map(it -> (VarRef) it); + allVarRefsReferencingFederates.addAll( + triggersAsVarRef.filter(it -> it.getVariable() instanceof Output).toList() + ); + // Add all the sources that are outputs + allVarRefsReferencingFederates.addAll( + react.getSources().stream().filter(it -> it.getVariable() instanceof Output).toList() + ); + // Add all the effects that are inputs + allVarRefsReferencingFederates.addAll( + react.getEffects().stream().filter(it -> it.getVariable() instanceof Input).toList() + ); + inFederate = containsAllVarRefs(allVarRefsReferencingFederates); + if (!inFederate) { + excludeReactions.add(react); + } } - inFederate = false; - } } - return inFederate; - } - - /** - * Find output ports that are connected to a physical action trigger upstream in the same reactor. - * Return a list of such outputs paired with the minimum delay from the nearest physical action. - * - * @param instance The reactor instance containing the output ports - * @return A LinkedHashMap - */ - public LinkedHashMap findOutputsConnectedToPhysicalActions( - ReactorInstance instance) { - LinkedHashMap physicalActionToOutputMinDelay = new LinkedHashMap<>(); - // Find reactions that write to the output port of the reactor - for (PortInstance output : instance.outputs) { - for (ReactionInstance reaction : output.getDependsOnReactions()) { - TimeValue minDelay = findNearestPhysicalActionTrigger(reaction); - if (!Objects.equal(minDelay, TimeValue.MAX_VALUE)) { - physicalActionToOutputMinDelay.put((Output) output.getDefinition(), minDelay); + + /** + * Return true if all members of 'varRefs' belong to this federate. + * + * As a convenience measure, if some members of 'varRefs' are from + * different federates, also report an error. + * + * @param varRefs A collection of VarRefs + */ + private boolean containsAllVarRefs(Iterable varRefs) { + var referencesFederate = false; + var inFederate = true; + for (VarRef varRef : varRefs) { + if (varRef.getContainer() == this.instantiation) { + referencesFederate = true; + } else { + if (referencesFederate) { + errorReporter.reportError(varRef, + "Mixed triggers and effects from" + + + " different federates. This is not permitted"); + } + inFederate = false; + } } - } + return inFederate; } - return physicalActionToOutputMinDelay; - } - - /** - * Return a list of federates that are upstream of this federate and have a zero-delay (direct) - * connection to this federate. - */ - public List getZeroDelayImmediateUpstreamFederates() { - return this.dependsOn.entrySet().stream() - .filter(e -> e.getValue().contains(null)) - .map(Map.Entry::getKey) - .toList(); - } - - @Override - public String toString() { - return "Federate " - + id - + ": " - + ((instantiation != null) ? instantiation.getName() : "no name"); - } - - ///////////////////////////////////////////// - //// Private Fields - - /** Cached result of analysis of which reactions to exclude from main. */ - private Set excludeReactions = null; - - /** An error reporter */ - private final ErrorReporter errorReporter; - - /** - * Find the nearest (shortest) path to a physical action trigger from this 'reaction' in terms of - * minimum delay. - * - * @param reaction The reaction to start with - * @return The minimum delay found to the nearest physical action and TimeValue.MAX_VALUE - * otherwise - */ - public TimeValue findNearestPhysicalActionTrigger(ReactionInstance reaction) { - TimeValue minDelay = TimeValue.MAX_VALUE; - for (TriggerInstance trigger : reaction.triggers) { - if (trigger.getDefinition() instanceof Action action) { - ActionInstance actionInstance = (ActionInstance) trigger; - if (action.getOrigin() == ActionOrigin.PHYSICAL) { - if (actionInstance.getMinDelay().isEarlierThan(minDelay)) { - minDelay = actionInstance.getMinDelay(); - } - } else if (action.getOrigin() == ActionOrigin.LOGICAL) { - // Logical action - // Follow it upstream inside the reactor - for (ReactionInstance uReaction : actionInstance.getDependsOnReactions()) { - // Avoid a loop - if (!Objects.equal(uReaction, reaction)) { - TimeValue uMinDelay = - actionInstance.getMinDelay().add(findNearestPhysicalActionTrigger(uReaction)); - if (uMinDelay.isEarlierThan(minDelay)) { - minDelay = uMinDelay; - } + + /** + * Find output ports that are connected to a physical action trigger upstream + * in the same reactor. Return a list of such outputs paired with the minimum delay + * from the nearest physical action. + * @param instance The reactor instance containing the output ports + * @return A LinkedHashMap + */ + public LinkedHashMap findOutputsConnectedToPhysicalActions(ReactorInstance instance) { + LinkedHashMap physicalActionToOutputMinDelay = new LinkedHashMap<>(); + // Find reactions that write to the output port of the reactor + for (PortInstance output : instance.outputs) { + for (ReactionInstance reaction : output.getDependsOnReactions()) { + TimeValue minDelay = findNearestPhysicalActionTrigger(reaction); + if (!Objects.equal(minDelay, TimeValue.MAX_VALUE)) { + physicalActionToOutputMinDelay.put((Output) output.getDefinition(), minDelay); + } } - } } + return physicalActionToOutputMinDelay; + } - } else if (trigger.getDefinition() instanceof Output) { - // Outputs of contained reactions - PortInstance outputInstance = (PortInstance) trigger; - for (ReactionInstance uReaction : outputInstance.getDependsOnReactions()) { - TimeValue uMinDelay = findNearestPhysicalActionTrigger(uReaction); - if (uMinDelay.isEarlierThan(minDelay)) { - minDelay = uMinDelay; - } - } - } + /** + * Return a list of federates that are upstream of this federate and have a + * zero-delay (direct) connection to this federate. + */ + public List getZeroDelayImmediateUpstreamFederates() { + return this.dependsOn.entrySet() + .stream() + .filter(e -> e.getValue().contains(null)) + .map(Map.Entry::getKey).toList(); + } + + @Override + public String toString() { + return "Federate " + id + ": " + + ((instantiation != null) ? instantiation.getName() : "no name"); } - return minDelay; - } - // TODO: Put this function into a utils file instead - private List convertToEmptyListIfNull(List list) { - return list == null ? new ArrayList<>() : list; - } + ///////////////////////////////////////////// + //// Private Fields + + /** + * Cached result of analysis of which reactions to exclude from main. + */ + private Set excludeReactions = null; + + /** + * An error reporter + */ + private final ErrorReporter errorReporter; + + /** + * Find the nearest (shortest) path to a physical action trigger from this + * 'reaction' in terms of minimum delay. + * + * @param reaction The reaction to start with + * @return The minimum delay found to the nearest physical action and + * TimeValue.MAX_VALUE otherwise + */ + public TimeValue findNearestPhysicalActionTrigger(ReactionInstance reaction) { + TimeValue minDelay = TimeValue.MAX_VALUE; + for (TriggerInstance trigger : reaction.triggers) { + if (trigger.getDefinition() instanceof Action action) { + ActionInstance actionInstance = (ActionInstance) trigger; + if (action.getOrigin() == ActionOrigin.PHYSICAL) { + if (actionInstance.getMinDelay().isEarlierThan(minDelay)) { + minDelay = actionInstance.getMinDelay(); + } + } else if (action.getOrigin() == ActionOrigin.LOGICAL) { + // Logical action + // Follow it upstream inside the reactor + for (ReactionInstance uReaction: actionInstance.getDependsOnReactions()) { + // Avoid a loop + if (!Objects.equal(uReaction, reaction)) { + TimeValue uMinDelay = actionInstance.getMinDelay().add(findNearestPhysicalActionTrigger(uReaction)); + if (uMinDelay.isEarlierThan(minDelay)) { + minDelay = uMinDelay; + } + } + } + } + + } else if (trigger.getDefinition() instanceof Output) { + // Outputs of contained reactions + PortInstance outputInstance = (PortInstance) trigger; + for (ReactionInstance uReaction: outputInstance.getDependsOnReactions()) { + TimeValue uMinDelay = findNearestPhysicalActionTrigger(uReaction); + if (uMinDelay.isEarlierThan(minDelay)) { + minDelay = uMinDelay; + } + } + } + } + return minDelay; + } + + // TODO: Put this function into a utils file instead + private List convertToEmptyListIfNull(List list) { + return list == null ? new ArrayList<>() : list; + } } From 17f5071b8b351979178be7750d8d6f5bccd258ff Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 10:05:09 +0200 Subject: [PATCH 224/709] Added file docs --- org.lflang/src/org/lflang/generator/WatchdogInstance.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index ca5cb3d192..78c0c9bc81 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -1,3 +1,11 @@ +/** + * @file + * @author Benjamin Asch + * @author Edward A. Lee + * @copyright (c) 2023, The University of California at Berkeley + * License in [BSD 2-clause](https://github.com/lf-lang/lingua-franca/blob/master/LICENSE) + * @brief Instance of a watchdog + */ package org.lflang.generator; import org.lflang.TimeValue; From 0867ec87dbf44e5eb31e3d9ce3f4d0b1c803f802 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 10:05:30 +0200 Subject: [PATCH 225/709] Revert formatting --- .../org/lflang/generator/ReactorInstance.java | 2105 +++++++-------- .../generator/c/CReactionGenerator.java | 2345 ++++++++--------- 2 files changed, 2140 insertions(+), 2310 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index b3bf51d836..0d6154c1bb 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -1,31 +1,32 @@ /** A data structure for a reactor instance. */ /************* - * Copyright (c) 2019-2022, The University of California at Berkeley. - * - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. - ***************/ +Copyright (c) 2019-2022, The University of California at Berkeley. + +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. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. +***************/ package org.lflang.generator; +import static org.lflang.ASTUtils.belongsTo; import static org.lflang.ASTUtils.getLiteralTimeValue; import java.util.ArrayList; @@ -37,6 +38,7 @@ import java.util.Map; import java.util.Optional; import java.util.Set; + import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; @@ -51,6 +53,7 @@ import org.lflang.lf.Initializer; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; +import org.lflang.lf.LfFactory; import org.lflang.lf.Mode; import org.lflang.lf.Output; import org.lflang.lf.Parameter; @@ -66,1097 +69,1117 @@ import org.lflang.lf.WidthSpec; /** - * Representation of a compile-time instance of a reactor. If the reactor is instantiated as a bank - * of reactors, or if any of its parents is instantiated as a bank of reactors, then one instance of - * this ReactorInstance class represents all the runtime instances within these banks. The {@link - * #getTotalWidth()} method returns the number of such runtime instances, which is the product of - * the bank width of this reactor instance and the bank widths of all of its parents. There is - * exactly one instance of this ReactorInstance class for each graphical rendition of a reactor in - * the diagram view. + * Representation of a compile-time instance of a reactor. + * If the reactor is instantiated as a bank of reactors, or if any + * of its parents is instantiated as a bank of reactors, then one instance + * of this ReactorInstance class represents all the runtime instances within + * these banks. The {@link #getTotalWidth()} method returns the number of such + * runtime instances, which is the product of the bank width of this reactor + * instance and the bank widths of all of its parents. + * There is exactly one instance of this ReactorInstance class for each + * graphical rendition of a reactor in the diagram view. * - *

For the main reactor, which has no parent, once constructed, this object represents the entire - * Lingua Franca program. If the program has causality loops (a programming error), then {@link - * #hasCycles()} will return true and {@link #getCycles()} will return the ports and reaction - * instances involved in the cycles. + * For the main reactor, which has no parent, once constructed, + * this object represents the entire Lingua Franca program. + * If the program has causality loops (a programming error), then + * {@link #hasCycles()} will return true and {@link #getCycles()} will + * return the ports and reaction instances involved in the cycles. * * @author Marten Lohstroh * @author Edward A. Lee */ public class ReactorInstance extends NamedInstance { - /** - * Create a new instantiation hierarchy that starts with the given top-level reactor. - * - * @param reactor The top-level reactor. - * @param reporter The error reporter. - */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter) { - this(ASTUtils.createInstantiation(reactor), null, reporter, -1); - } - - /** - * Create a new instantiation hierarchy that starts with the given top-level reactor but only - * creates contained reactors up to the specified depth. - * - * @param reactor The top-level reactor. - * @param reporter The error reporter. - * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. - */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth) { - this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth); - } - - /** - * Create a new instantiation with the specified parent. This constructor is here to allow for - * unit tests. It should not be used for any other purpose. - * - * @param reactor The top-level reactor. - * @param parent The parent reactor instance. - * @param reporter The error reporter. - */ - public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter) { - this(ASTUtils.createInstantiation(reactor), parent, reporter, -1); - } - - ////////////////////////////////////////////////////// - //// Public fields. - - /** The action instances belonging to this reactor instance. */ - public List actions = new ArrayList<>(); - - /** - * The contained reactor instances, in order of declaration. For banks of reactors, this includes - * both the bank definition Reactor (which has bankIndex == -2) followed by each of the bank - * members (which have bankIndex >= 0). - */ - public final List children = new ArrayList<>(); - - /** The input port instances belonging to this reactor instance. */ - public final List inputs = new ArrayList<>(); - - /** The output port instances belonging to this reactor instance. */ - public final List outputs = new ArrayList<>(); - - /** The parameters of this instance. */ - public final List parameters = new ArrayList<>(); - - /** List of reaction instances for this reactor instance. */ - public final List reactions = new ArrayList<>(); - - /** List of watchdog instances for this reactor instance. */ - public final List watchdogs = new ArrayList<>(); - - /** The timer instances belonging to this reactor instance. */ - public final List timers = new ArrayList<>(); - - /** The mode instances belonging to this reactor instance. */ - public final List modes = new ArrayList<>(); - - /** The reactor declaration in the AST. This is either an import or Reactor declaration. */ - public final ReactorDecl reactorDeclaration; - - /** The reactor after imports are resolve. */ - public final Reactor reactorDefinition; - - /** Indicator that this reactor has itself as a parent, an error condition. */ - public final boolean recursive; - - ////////////////////////////////////////////////////// - //// Public methods. - - /** - * Assign levels to all reactions within the same root as this reactor. The level of a reaction r - * is equal to the length of the longest chain of reactions that must have the opportunity to - * execute before r at each logical tag. This fails and returns false if a causality cycle exists. - * - *

This method uses a variant of Kahn's algorithm, which is linear in V + E, where V is the - * number of vertices (reactions) and E is the number of edges (dependencies between reactions). - * - * @return An empty graph if successful and otherwise a graph with runtime reaction instances that - * form cycles. - */ - public ReactionInstanceGraph assignLevels() { - if (depth != 0) return root().assignLevels(); - if (cachedReactionLoopGraph == null) { - cachedReactionLoopGraph = new ReactionInstanceGraph(this); + /** + * Create a new instantiation hierarchy that starts with the given top-level reactor. + * @param reactor The top-level reactor. + * @param reporter The error reporter. + */ + public ReactorInstance(Reactor reactor, ErrorReporter reporter) { + this(ASTUtils.createInstantiation(reactor), null, reporter, -1); } - return cachedReactionLoopGraph; - } - - /** - * This function assigns/propagates deadlines through the Reaction Instance Graph. It performs - * Kahn`s algorithm in reverse, starting from the leaf nodes and propagates deadlines upstream. To - * reduce cost, it should only be invoked when there are user-specified deadlines in the program. - * - * @return - */ - public ReactionInstanceGraph assignDeadlines() { - if (depth != 0) return root().assignDeadlines(); - if (cachedReactionLoopGraph == null) { - cachedReactionLoopGraph = new ReactionInstanceGraph(this); + + /** + * Create a new instantiation hierarchy that starts with the given top-level reactor + * but only creates contained reactors up to the specified depth. + * @param reactor The top-level reactor. + * @param reporter The error reporter. + * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. + */ + public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth) { + this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth); } - cachedReactionLoopGraph.rebuildAndAssignDeadlines(); - return cachedReactionLoopGraph; - } - - /** - * Return the instance of a child rector created by the specified definition or null if there is - * none. - * - * @param definition The definition of the child reactor ("new" statement). - */ - public ReactorInstance getChildReactorInstance(Instantiation definition) { - for (ReactorInstance child : this.children) { - if (child.definition == definition) { - return child; - } + + /** + * Create a new instantiation with the specified parent. + * This constructor is here to allow for unit tests. + * It should not be used for any other purpose. + * @param reactor The top-level reactor. + * @param parent The parent reactor instance. + * @param reporter The error reporter. + */ + public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter) { + this(ASTUtils.createInstantiation(reactor), parent, reporter, -1); } - return null; - } - - /** - * Clear any cached data in this reactor and its children. This is useful if a mutation has been - * realized. - */ - public void clearCaches() { - clearCaches(true); - } - - /** - * Clear any cached data in this reactor and its children. This is useful if a mutation has been - * realized. - * - * @param includingRuntimes If false, leave the runtime instances of reactions intact. This is - * useful for federated execution where levels are computed using the top-level connections, - * but then those connections are discarded. - */ - public void clearCaches(boolean includingRuntimes) { - if (includingRuntimes) cachedReactionLoopGraph = null; - for (ReactorInstance child : children) { - child.clearCaches(includingRuntimes); + + ////////////////////////////////////////////////////// + //// Public fields. + + /** The action instances belonging to this reactor instance. */ + public List actions = new ArrayList<>(); + + /** + * The contained reactor instances, in order of declaration. + * For banks of reactors, this includes both the bank definition + * Reactor (which has bankIndex == -2) followed by each of the + * bank members (which have bankIndex >= 0). + */ + public final List children = new ArrayList<>(); + + /** The input port instances belonging to this reactor instance. */ + public final List inputs = new ArrayList<>(); + + /** The output port instances belonging to this reactor instance. */ + public final List outputs = new ArrayList<>(); + + /** The parameters of this instance. */ + public final List parameters = new ArrayList<>(); + + /** List of reaction instances for this reactor instance. */ + public final List reactions = new ArrayList<>(); + + /** List of watchdog instances for this reactor instance. */ + public final List watchdogs = new ArrayList<>(); + + /** The timer instances belonging to this reactor instance. */ + public final List timers = new ArrayList<>(); + + /** The mode instances belonging to this reactor instance. */ + public final List modes = new ArrayList<>(); + + /** The reactor declaration in the AST. This is either an import or Reactor declaration. */ + public final ReactorDecl reactorDeclaration; + + /** The reactor after imports are resolve. */ + public final Reactor reactorDefinition; + + /** Indicator that this reactor has itself as a parent, an error condition. */ + public final boolean recursive; + + ////////////////////////////////////////////////////// + //// Public methods. + + /** + * Assign levels to all reactions within the same root as this + * reactor. The level of a reaction r is equal to the length of the + * longest chain of reactions that must have the opportunity to + * execute before r at each logical tag. This fails and returns + * false if a causality cycle exists. + * + * This method uses a variant of Kahn's algorithm, which is linear + * in V + E, where V is the number of vertices (reactions) and E + * is the number of edges (dependencies between reactions). + * + * @return An empty graph if successful and otherwise a graph + * with runtime reaction instances that form cycles. + */ + public ReactionInstanceGraph assignLevels() { + if (depth != 0) return root().assignLevels(); + if (cachedReactionLoopGraph == null) { + cachedReactionLoopGraph = new ReactionInstanceGraph(this); + } + return cachedReactionLoopGraph; } - for (PortInstance port : inputs) { - port.clearCaches(); + + /** + * This function assigns/propagates deadlines through the Reaction Instance Graph. + * It performs Kahn`s algorithm in reverse, starting from the leaf nodes and + * propagates deadlines upstream. To reduce cost, it should only be invoked when + * there are user-specified deadlines in the program. + * @return + */ + public ReactionInstanceGraph assignDeadlines() { + if (depth != 0) return root().assignDeadlines(); + if (cachedReactionLoopGraph == null) { + cachedReactionLoopGraph = new ReactionInstanceGraph(this); + } + cachedReactionLoopGraph.rebuildAndAssignDeadlines(); + return cachedReactionLoopGraph; } - for (PortInstance port : outputs) { - port.clearCaches(); + + /** + * Return the instance of a child rector created by the specified + * definition or null if there is none. + * @param definition The definition of the child reactor ("new" statement). + */ + public ReactorInstance getChildReactorInstance(Instantiation definition) { + for (ReactorInstance child : this.children) { + if (child.definition == definition) { + return child; + } + } + return null; } - for (ReactionInstance reaction : reactions) { - reaction.clearCaches(includingRuntimes); + + /** + * Clear any cached data in this reactor and its children. + * This is useful if a mutation has been realized. + */ + public void clearCaches() { + clearCaches(true); } - cachedCycles = null; - } - - /** - * Return the specified input by name or null if there is no such input. - * - * @param name The input name. - */ - public PortInstance getInput(String name) { - for (PortInstance port : inputs) { - if (port.getName().equals(name)) { - return port; - } + + /** + * Clear any cached data in this reactor and its children. + * This is useful if a mutation has been realized. + * @param includingRuntimes If false, leave the runtime instances of reactions intact. + * This is useful for federated execution where levels are computed using + * the top-level connections, but then those connections are discarded. + */ + public void clearCaches(boolean includingRuntimes) { + if (includingRuntimes) cachedReactionLoopGraph = null; + for (ReactorInstance child : children) { + child.clearCaches(includingRuntimes); + } + for (PortInstance port : inputs) { + port.clearCaches(); + } + for (PortInstance port : outputs) { + port.clearCaches(); + } + for (ReactionInstance reaction : reactions) { + reaction.clearCaches(includingRuntimes); + } + cachedCycles = null; } - return null; - } - - /** - * Return the set of ReactionInstance and PortInstance that form causality loops in the topmost - * parent reactor in the instantiation hierarchy. This will return an empty set if there are no - * causality loops. - */ - public Set> getCycles() { - if (depth != 0) return root().getCycles(); - if (cachedCycles != null) return cachedCycles; - cachedCycles = new LinkedHashSet<>(); - - ReactionInstanceGraph reactionRuntimes = assignLevels(); - if (reactionRuntimes.nodes().size() > 0) { - Set reactions = new LinkedHashSet<>(); - Set ports = new LinkedHashSet<>(); - // There are cycles. But the nodes set includes not - // just the cycles, but also nodes that are downstream of the - // cycles. Use Tarjan's algorithm to get just the cycles. - var cycleNodes = reactionRuntimes.getCycles(); - for (var cycle : cycleNodes) { - for (ReactionInstance.Runtime runtime : cycle) { - reactions.add(runtime.getReaction()); + + /** + * Return the set of ReactionInstance and PortInstance that form causality + * loops in the topmost parent reactor in the instantiation hierarchy. This will return an + * empty set if there are no causality loops. + */ + public Set> getCycles() { + if (depth != 0) return root().getCycles(); + if (cachedCycles != null) return cachedCycles; + cachedCycles = new LinkedHashSet<>(); + + ReactionInstanceGraph reactionRuntimes = assignLevels(); + if (reactionRuntimes.nodes().size() > 0) { + Set reactions = new LinkedHashSet<>(); + Set ports = new LinkedHashSet<>(); + // There are cycles. But the nodes set includes not + // just the cycles, but also nodes that are downstream of the + // cycles. Use Tarjan's algorithm to get just the cycles. + var cycleNodes = reactionRuntimes.getCycles(); + for (var cycle : cycleNodes) { + for (ReactionInstance.Runtime runtime : cycle) { + reactions.add(runtime.getReaction()); + } + } + // Need to figure out which ports are involved in the cycles. + // It may not be all ports that depend on this reaction. + for (ReactionInstance r : reactions) { + for (TriggerInstance p : r.effects) { + if (p instanceof PortInstance) { + findPaths((PortInstance)p, reactions, ports); + } + } + } + cachedCycles.addAll(reactions); + cachedCycles.addAll(ports); } - } - // Need to figure out which ports are involved in the cycles. - // It may not be all ports that depend on this reaction. - for (ReactionInstance r : reactions) { - for (TriggerInstance p : r.effects) { - if (p instanceof PortInstance) { - findPaths((PortInstance) p, reactions, ports); - } + + return cachedCycles; + } + + /** + * Return the specified input by name or null if there is no such input. + * @param name The input name. + */ + public PortInstance getInput(String name) { + for (PortInstance port: inputs) { + if (port.getName().equals(name)) { + return port; + } } - } - cachedCycles.addAll(reactions); - cachedCycles.addAll(ports); + return null; } - return cachedCycles; - } - - /** - * Override the base class to append [i_d], where d is the depth, if this reactor is in a bank of - * reactors. - * - * @return The name of this instance. - */ - @Override - public String getName() { - return this.definition.getName(); - } - - /** - * @see NamedInstance#uniqueID() - *

Append `_main` to the name of the main reactor to allow instantiations within that - * reactor to have the same name. - */ - @Override - public String uniqueID() { - if (this.isMainOrFederated()) { - return super.uniqueID() + "_main"; + /** + * Override the base class to append [i_d], where d is the depth, + * if this reactor is in a bank of reactors. + * @return The name of this instance. + */ + @Override + public String getName() { + return this.definition.getName(); } - return super.uniqueID(); - } - - /** - * Return the specified output by name or null if there is no such output. - * - * @param name The output name. - */ - public PortInstance getOutput(String name) { - for (PortInstance port : outputs) { - if (port.getName().equals(name)) { - return port; - } + + /** + * @see NamedInstance#uniqueID() + * + * Append `_main` to the name of the main reactor to allow instantiations + * within that reactor to have the same name. + */ + @Override + public String uniqueID() { + if (this.isMainOrFederated()) { + return super.uniqueID() + "_main"; + } + return super.uniqueID(); } - return null; - } - - /** - * Return a parameter matching the specified name if the reactor has one and otherwise return - * null. - * - * @param name The parameter name. - */ - public ParameterInstance getParameter(String name) { - for (ParameterInstance parameter : parameters) { - if (parameter.getName().equals(name)) { - return parameter; - } + + /** + * Return the specified output by name or null if there is no such output. + * @param name The output name. + */ + public PortInstance getOutput(String name) { + for (PortInstance port: outputs) { + if (port.getName().equals(name)) { + return port; + } + } + return null; } - return null; - } - - /** Return the startup trigger or null if not used in any reaction. */ - public TriggerInstance getStartupTrigger() { - return builtinTriggers.get(BuiltinTrigger.STARTUP); - } - - /** Return the shutdown trigger or null if not used in any reaction. */ - public TriggerInstance getShutdownTrigger() { - return builtinTriggers.get(BuiltinTrigger.SHUTDOWN); - } - - /** - * If this reactor is a bank or any of its parents is a bank, return the total number of runtime - * instances, which is the product of the widths of all the parents. Return -1 if the width cannot - * be determined. - */ - public int getTotalWidth() { - return getTotalWidth(0); - } - - /** - * If this reactor is a bank or any of its parents is a bank, return the total number of runtime - * instances, which is the product of the widths of all the parents. Return -1 if the width cannot - * be determined. - * - * @param atDepth The depth at which to determine the width. Use 0 to get the total number of - * instances. Use 1 to get the number of instances within a single top-level bank member (this - * is useful for federates). - */ - public int getTotalWidth(int atDepth) { - if (width <= 0) return -1; - if (depth <= atDepth) return 1; - int result = width; - ReactorInstance p = parent; - while (p != null && p.depth > atDepth) { - if (p.width <= 0) return -1; - result *= p.width; - p = p.parent; + + /** + * Return a parameter matching the specified name if the reactor has one + * and otherwise return null. + * @param name The parameter name. + */ + public ParameterInstance getParameter(String name) { + for (ParameterInstance parameter: parameters) { + if (parameter.getName().equals(name)) { + return parameter; + } + } + return null; } - return result; - } - - /** - * Return the trigger instances (input ports, timers, and actions that trigger reactions) - * belonging to this reactor instance. - */ - public Set> getTriggers() { - // FIXME: Cache this. - var triggers = new LinkedHashSet>(); - for (ReactionInstance reaction : this.reactions) { - triggers.addAll(reaction.triggers); + + /** + * Return the startup trigger or null if not used in any reaction. + */ + public TriggerInstance getStartupTrigger() { + return builtinTriggers.get(BuiltinTrigger.STARTUP); } - return triggers; - } - - /** - * Return the trigger instances (input ports, timers, and actions that trigger reactions) together - * the ports that the reaction reads but that don't trigger it. - * - * @return The trigger instances belonging to this reactor instance. - */ - public Set> getTriggersAndReads() { - // FIXME: Cache this. - var triggers = new LinkedHashSet>(); - for (ReactionInstance reaction : this.reactions) { - triggers.addAll(reaction.triggers); - triggers.addAll(reaction.reads); + + /** + * Return the shutdown trigger or null if not used in any reaction. + */ + public TriggerInstance getShutdownTrigger() { + return builtinTriggers.get(BuiltinTrigger.SHUTDOWN); } - return triggers; - } - - /** Return true if the top-level parent of this reactor has causality cycles. */ - public boolean hasCycles() { - return assignLevels().nodeCount() != 0; - } - - /** - * Given a parameter definition for this reactor, return the initial integer value of the - * parameter. If the parameter is overridden when instantiating this reactor or any of its - * containing reactors, use that value. Otherwise, use the default value in the reactor - * definition. If the parameter cannot be found or its value is not an integer, return null. - * - * @param parameter The parameter definition (a syntactic object in the AST). - * @return An integer value or null. - */ - public Integer initialIntParameterValue(Parameter parameter) { - return ASTUtils.initialValueInt(parameter, instantiations()); - } - - public Expression resolveParameters(Expression e) { - return LfExpressionVisitor.dispatch(e, this, ParameterInliner.INSTANCE); - } - - private static final class ParameterInliner - extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { - static final ParameterInliner INSTANCE = new ParameterInliner(); - @Override - public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { - if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { - throw new IllegalArgumentException( - "Parameter " - + expr.getParameter().getName() - + " is not a parameter of reactor instance " - + instance.getName() - + "."); - } - - Optional assignment = - instance.definition.getParameters().stream() - .filter(it -> it.getLhs().equals(expr.getParameter())) - .findAny(); // There is at most one - - if (assignment.isPresent()) { - // replace the parameter with its value. - Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); - // recursively resolve parameters - return instance.getParent().resolveParameters(value); - } else { - // In that case use the default value. Default values - // cannot use parameter values, so they don't need to - // be recursively resolved. - Initializer init = expr.getParameter().getInit(); - Expression defaultValue = ASTUtils.asSingleExpr(init); - if (defaultValue == null) { - // this is a problem - return super.visitParameterRef(expr, instance); + /** + * If this reactor is a bank or any of its parents is a bank, + * return the total number of runtime instances, which is the product + * of the widths of all the parents. + * Return -1 if the width cannot be determined. + */ + public int getTotalWidth() { + return getTotalWidth(0); + } + + /** + * If this reactor is a bank or any of its parents is a bank, + * return the total number of runtime instances, which is the product + * of the widths of all the parents. + * Return -1 if the width cannot be determined. + * @param atDepth The depth at which to determine the width. + * Use 0 to get the total number of instances. + * Use 1 to get the number of instances within a single top-level + * bank member (this is useful for federates). + */ + public int getTotalWidth(int atDepth) { + if (width <= 0) return -1; + if (depth <= atDepth) return 1; + int result = width; + ReactorInstance p = parent; + while (p != null && p.depth > atDepth) { + if (p.width <= 0) return -1; + result *= p.width; + p = p.parent; } - return defaultValue; - } + return result; } - } - - // /** - // * Return the startup trigger or null if not used in any reaction. - // */ - // public TriggerInstance getStartupTrigger() { - // return _instantiations; - // } - - /////////////////////////////////////////////////// - //// Methods for finding instances in this reactor given an AST node. - - /** - * Given a parameter definition, return the parameter instance corresponding to that definition, - * or null if there is no such instance. - * - * @param parameter The parameter definition (a syntactic object in the AST). - * @return A parameter instance, or null if there is none. - */ - public ParameterInstance lookupParameterInstance(Parameter parameter) { - for (ParameterInstance param : parameters) { - if (param.definition == parameter) { - return param; - } + + /** + * Return the trigger instances (input ports, timers, and actions + * that trigger reactions) belonging to this reactor instance. + */ + public Set> getTriggers() { + // FIXME: Cache this. + var triggers = new LinkedHashSet>(); + for (ReactionInstance reaction : this.reactions) { + triggers.addAll(reaction.triggers); + } + return triggers; } - return null; - } - - /** - * Given a port definition, return the port instance corresponding to that definition, or null if - * there is no such instance. - * - * @param port The port definition (a syntactic object in the AST). - * @return A port instance, or null if there is none. - */ - public PortInstance lookupPortInstance(Port port) { - // Search one of the inputs and outputs sets. - List ports = null; - if (port instanceof Input) { - ports = this.inputs; - } else if (port instanceof Output) { - ports = this.outputs; + + /** + * Return the trigger instances (input ports, timers, and actions + * that trigger reactions) together the ports that the reaction reads + * but that don't trigger it. + * + * @return The trigger instances belonging to this reactor instance. + */ + public Set> getTriggersAndReads() { + // FIXME: Cache this. + var triggers = new LinkedHashSet>(); + for (ReactionInstance reaction : this.reactions) { + triggers.addAll(reaction.triggers); + triggers.addAll(reaction.reads); + } + return triggers; } - for (PortInstance portInstance : ports) { - if (portInstance.definition == port) { - return portInstance; - } + + /** + * Return true if the top-level parent of this reactor has causality cycles. + */ + public boolean hasCycles() { + return assignLevels().nodeCount() != 0; } - return null; - } - - /** - * Given a reference to a port belonging to this reactor instance, return the port instance. - * Return null if there is no such instance. - * - * @param reference The port reference. - * @return A port instance, or null if there is none. - */ - public PortInstance lookupPortInstance(VarRef reference) { - if (!(reference.getVariable() instanceof Port)) { - // Trying to resolve something that is not a port - return null; + + /** + * Given a parameter definition for this reactor, return the initial integer + * value of the parameter. If the parameter is overridden when instantiating + * this reactor or any of its containing reactors, use that value. + * Otherwise, use the default value in the reactor definition. + * If the parameter cannot be found or its value is not an integer, return null. + * + * @param parameter The parameter definition (a syntactic object in the AST). + * + * @return An integer value or null. + */ + public Integer initialIntParameterValue(Parameter parameter) { + return ASTUtils.initialValueInt(parameter, instantiations()); } - if (reference.getContainer() == null) { - // Handle local reference - return lookupPortInstance((Port) reference.getVariable()); - } else { - // Handle hierarchical reference - var containerInstance = getChildReactorInstance(reference.getContainer()); - if (containerInstance == null) return null; - return containerInstance.lookupPortInstance((Port) reference.getVariable()); + + public Expression resolveParameters(Expression e) { + return LfExpressionVisitor.dispatch(e, this, ParameterInliner.INSTANCE); } - } - - /** - * Return the reaction instance within this reactor instance corresponding to the specified - * reaction. - * - * @param reaction The reaction as an AST node. - * @return The corresponding reaction instance or null if the reaction does not belong to this - * reactor. - */ - public ReactionInstance lookupReactionInstance(Reaction reaction) { - for (ReactionInstance reactionInstance : reactions) { - if (reactionInstance.definition == reaction) { - return reactionInstance; - } + + + private static final class ParameterInliner extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { + static final ParameterInliner INSTANCE = new ParameterInliner(); + + @Override + public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { + if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { + throw new IllegalArgumentException("Parameter " + + expr.getParameter().getName() + + " is not a parameter of reactor instance " + + instance.getName() + + "." + ); + } + + Optional assignment = + instance.definition.getParameters().stream() + .filter(it -> it.getLhs().equals(expr.getParameter())) + .findAny(); // There is at most one + + if (assignment.isPresent()) { + // replace the parameter with its value. + Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); + // recursively resolve parameters + return instance.getParent().resolveParameters(value); + } else { + // In that case use the default value. Default values + // cannot use parameter values, so they don't need to + // be recursively resolved. + Initializer init = expr.getParameter().getInit(); + Expression defaultValue = ASTUtils.asSingleExpr(init); + if (defaultValue == null) { + // this is a problem + return super.visitParameterRef(expr, instance); + } + return defaultValue; + } + } } - return null; - } - - /** - * Return the reactor instance within this reactor that has the specified instantiation. Note that - * this may be a bank of reactors. Return null if there is no such reactor instance. - */ - public ReactorInstance lookupReactorInstance(Instantiation instantiation) { - for (ReactorInstance reactorInstance : children) { - if (reactorInstance.definition == instantiation) { - return reactorInstance; - } + + /** + * Return a list of Instantiation objects for evaluating parameter + * values. The first object in the list is the AST Instantiation + * that created this reactor instance, the second is the AST instantiation + * that created the containing reactor instance, and so on until there + * are no more containing reactor instances. This will return an empty + * list if this reactor instance is at the top level (is main). + */ + public List instantiations() { + if (_instantiations == null) { + _instantiations = new ArrayList<>(); + if (definition != null) { + _instantiations.add(definition); + if (parent != null) { + _instantiations.addAll(parent.instantiations()); + } + } + } + return _instantiations; } - return null; - } - - /** - * Return the timer instance within this reactor instance corresponding to the specified timer - * reference. - * - * @param timer The timer as an AST node. - * @return The corresponding timer instance or null if the timer does not belong to this reactor. - */ - public TimerInstance lookupTimerInstance(Timer timer) { - for (TimerInstance timerInstance : timers) { - if (timerInstance.definition == timer) { - return timerInstance; - } + + /** + * Returns true if this is a bank of reactors. + * @return true if a reactor is a bank, false otherwise + */ + public boolean isBank() { + return definition.getWidthSpec() != null; } - return null; - } - - /** - * Returns the mode instance within this reactor instance corresponding to the specified mode - * reference. - * - * @param mode The mode as an AST node. - * @return The corresponding mode instance or null if the mode does not belong to this reactor. - */ - public ModeInstance lookupModeInstance(Mode mode) { - for (ModeInstance modeInstance : modes) { - if (modeInstance.definition == mode) { - return modeInstance; - } + + /** + * Returns whether this is a main or federated reactor. + * @return true if reactor definition is marked as main or federated, false otherwise. + */ + public boolean isMainOrFederated() { + return reactorDefinition != null + && (reactorDefinition.isMain() || reactorDefinition.isFederated()); } - return null; - } - - /** Return a descriptive string. */ - @Override - public String toString() { - return "ReactorInstance " + getFullName(); - } - - /** - * Assuming that the given expression denotes a valid time, return a time value. - * - *

If the value is given as a parameter reference, this will look up the precise time value - * assigned to this reactor instance. - */ - public TimeValue getTimeValue(Expression expr) { - Expression resolved = resolveParameters(expr); - return getLiteralTimeValue(resolved); - } - - ////////////////////////////////////////////////////// - //// Protected fields. - - /** The generator that created this reactor instance. */ - protected ErrorReporter reporter; // FIXME: This accumulates a lot of redundant references - - /** The map of used built-in triggers. */ - protected Map> builtinTriggers = - new HashMap<>(); - - /** - * The LF syntax does not currently support declaring reactions unordered, but unordered reactions - * are created in the AST transformations handling federated communication and after delays. - * Unordered reactions can execute in any order and concurrently even though they are in the same - * reactor. FIXME: Remove this when the language provides syntax. - */ - protected Set unorderedReactions = new LinkedHashSet<>(); - - /** The nested list of instantiations that created this reactor instance. */ - protected List _instantiations; - - ////////////////////////////////////////////////////// - //// Protected methods. - - /** - * Create all the reaction instances of this reactor instance and record the dependencies and - * antidependencies between ports, actions, and timers and reactions. This also records the - * dependencies between reactions that follows from the order in which they are defined. - */ - protected void createReactionInstances() { - List reactions = ASTUtils.allReactions(reactorDefinition); - if (reactions != null) { - int count = 0; - - // Check for startup and shutdown triggers. - for (Reaction reaction : reactions) { - if (AttributeUtils.isUnordered(reaction)) { - unorderedReactions.add(reaction); + + /** + * Return true if the specified reactor instance is either equal to this + * reactor instance or a parent of it. + * @param r The reactor instance. + */ + public boolean isParent(ReactorInstance r) { + ReactorInstance p = this; + while (p != null) { + if (p == r) return true; + p = p.getParent(); } - // Create the reaction instance. - var reactionInstance = - new ReactionInstance(reaction, this, unorderedReactions.contains(reaction), count++); - - // Add the reaction instance to the map of reactions for this - // reactor. - this.reactions.add(reactionInstance); - } + return false; } - } - - /** Create all the watchdog instances of this reactor instance. */ - protected void createWatchdogInstances() { - List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); - if (watchdogs != null) { - for (Watchdog watchdog : watchdogs) { - // Create the watchdog instance. - var watchdogInstance = new WatchdogInstance(watchdog, this); - - // Add the watchdog instance to the list of watchdogs for this - // reactor. - this.watchdogs.add(watchdogInstance); - } + + /////////////////////////////////////////////////// + //// Methods for finding instances in this reactor given an AST node. + + /** + * Return the action instance within this reactor + * instance corresponding to the specified action reference. + * @param action The action as an AST node. + * @return The corresponding action instance or null if the + * action does not belong to this reactor. + */ + public ActionInstance lookupActionInstance(Action action) { + for (ActionInstance actionInstance : actions) { + if (actionInstance.definition == action) { + return actionInstance; + } + } + return null; } - } - - //////////////////////////////////////// - //// Private constructors - - /** - * Create a runtime instance from the specified definition and with the specified parent that - * instantiated it. - * - * @param definition The instantiation statement in the AST. - * @param parent The parent, or null for the main rector. - * @param reporter An error reporter. - * @param desiredDepth The depth to which to expand the hierarchy. - */ - private ReactorInstance( - Instantiation definition, ReactorInstance parent, ErrorReporter reporter, int desiredDepth) { - super(definition, parent); - this.reporter = reporter; - this.reactorDeclaration = definition.getReactorClass(); - this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); - - // check for recursive instantiation - var currentParent = parent; - var foundSelfAsParent = false; - do { - if (currentParent != null) { - if (currentParent.reactorDefinition == this.reactorDefinition) { - foundSelfAsParent = true; - currentParent = null; // break - } else { - currentParent = currentParent.parent; + + /** + * Given a parameter definition, return the parameter instance + * corresponding to that definition, or null if there is + * no such instance. + * @param parameter The parameter definition (a syntactic object in the AST). + * @return A parameter instance, or null if there is none. + */ + public ParameterInstance lookupParameterInstance(Parameter parameter) { + for (ParameterInstance param : parameters) { + if (param.definition == parameter) { + return param; + } } - } - } while (currentParent != null); + return null; + } - this.recursive = foundSelfAsParent; - if (recursive) { - reporter.reportError(definition, "Recursive reactor instantiation."); + /** + * Given a port definition, return the port instance + * corresponding to that definition, or null if there is + * no such instance. + * @param port The port definition (a syntactic object in the AST). + * @return A port instance, or null if there is none. + */ + public PortInstance lookupPortInstance(Port port) { + // Search one of the inputs and outputs sets. + List ports = null; + if (port instanceof Input) { + ports = this.inputs; + } else if (port instanceof Output) { + ports = this.outputs; + } + for (PortInstance portInstance : ports) { + if (portInstance.definition == port) { + return portInstance; + } + } + return null; } - // If the reactor definition is null, give up here. Otherwise, diagram generation - // will fail an NPE. - if (reactorDefinition == null) { - reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); - return; + /** + * Given a reference to a port belonging to this reactor + * instance, return the port instance. + * Return null if there is no such instance. + * @param reference The port reference. + * @return A port instance, or null if there is none. + */ + public PortInstance lookupPortInstance(VarRef reference) { + if (!(reference.getVariable() instanceof Port)) { + // Trying to resolve something that is not a port + return null; + } + if (reference.getContainer() == null) { + // Handle local reference + return lookupPortInstance((Port) reference.getVariable()); + } else { + // Handle hierarchical reference + var containerInstance = getChildReactorInstance(reference.getContainer()); + if (containerInstance == null) return null; + return containerInstance.lookupPortInstance((Port) reference.getVariable()); + } } - setInitialWidth(); + /** + * Return the reaction instance within this reactor + * instance corresponding to the specified reaction. + * @param reaction The reaction as an AST node. + * @return The corresponding reaction instance or null if the + * reaction does not belong to this reactor. + */ + public ReactionInstance lookupReactionInstance(Reaction reaction) { + for (ReactionInstance reactionInstance : reactions) { + if (reactionInstance.definition == reaction) { + return reactionInstance; + } + } + return null; + } - // Apply overrides and instantiate parameters for this reactor instance. - for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { - this.parameters.add(new ParameterInstance(parameter, this)); + /** + * Return the reactor instance within this reactor + * that has the specified instantiation. Note that this + * may be a bank of reactors. Return null if there + * is no such reactor instance. + */ + public ReactorInstance lookupReactorInstance(Instantiation instantiation) { + for (ReactorInstance reactorInstance : children) { + if (reactorInstance.definition == instantiation) { + return reactorInstance; + } + } + return null; } - // Instantiate inputs for this reactor instance - for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { - this.inputs.add(new PortInstance(inputDecl, this, reporter)); + /** + * Return the timer instance within this reactor + * instance corresponding to the specified timer reference. + * @param timer The timer as an AST node. + * @return The corresponding timer instance or null if the + * timer does not belong to this reactor. + */ + public TimerInstance lookupTimerInstance(Timer timer) { + for (TimerInstance timerInstance : timers) { + if (timerInstance.definition == timer) { + return timerInstance; + } + } + return null; } - // Instantiate outputs for this reactor instance - for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { - this.outputs.add(new PortInstance(outputDecl, this, reporter)); + /** Returns the mode instance within this reactor + * instance corresponding to the specified mode reference. + * @param mode The mode as an AST node. + * @return The corresponding mode instance or null if the + * mode does not belong to this reactor. + */ + public ModeInstance lookupModeInstance(Mode mode) { + for (ModeInstance modeInstance : modes) { + if (modeInstance.definition == mode) { + return modeInstance; + } + } + return null; } - // Do not process content (except interface above) if recursive - if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { - // Instantiate children for this reactor instance. - // While doing this, assign an index offset to each. - for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { - var childInstance = new ReactorInstance(child, this, reporter, desiredDepth); - this.children.add(childInstance); - } - - // Instantiate timers for this reactor instance - for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { - this.timers.add(new TimerInstance(timerDecl, this)); - } - - // Instantiate actions for this reactor instance - for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { - this.actions.add(new ActionInstance(actionDecl, this)); - } - - establishPortConnections(); - - // Create the reaction instances in this reactor instance. - // This also establishes all the implied dependencies. - // Note that this can only happen _after_ the children, - // port, action, and timer instances have been created. - createReactionInstances(); - - // Instantiate modes for this reactor instance - // This must come after the child elements (reactions, etc) of this reactor - // are created in order to allow their association with modes - for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { - this.modes.add(new ModeInstance(modeDecl, this)); - } - for (ModeInstance mode : this.modes) { - mode.setupTranstions(); - } + /** + * Return a descriptive string. + */ + @Override + public String toString() { + return "ReactorInstance " + getFullName(); } - } - - /** - * Return a list of Instantiation objects for evaluating parameter values. The first object in the - * list is the AST Instantiation that created this reactor instance, the second is the AST - * instantiation that created the containing reactor instance, and so on until there are no more - * containing reactor instances. This will return an empty list if this reactor instance is at the - * top level (is main). - */ - public List instantiations() { - if (_instantiations == null) { - _instantiations = new ArrayList<>(); - if (definition != null) { - _instantiations.add(definition); - if (parent != null) { - _instantiations.addAll(parent.instantiations()); + + /** + * Assuming that the given expression denotes a valid time, return a time value. + * + * If the value is given as a parameter reference, this will look up the + * precise time value assigned to this reactor instance. + */ + public TimeValue getTimeValue(Expression expr) { + Expression resolved = resolveParameters(expr); + return getLiteralTimeValue(resolved); + } + + ////////////////////////////////////////////////////// + //// Protected fields. + + /** The generator that created this reactor instance. */ + protected ErrorReporter reporter; // FIXME: This accumulates a lot of redundant references + + /** The map of used built-in triggers. */ + protected Map> builtinTriggers = new HashMap<>(); + + /** + * The LF syntax does not currently support declaring reactions unordered, + * but unordered reactions are created in the AST transformations handling + * federated communication and after delays. Unordered reactions can execute + * in any order and concurrently even though they are in the same reactor. + * FIXME: Remove this when the language provides syntax. + */ + protected Set unorderedReactions = new LinkedHashSet<>(); + + /** The nested list of instantiations that created this reactor instance. */ + protected List _instantiations; + + ////////////////////////////////////////////////////// + //// Protected methods. + + /** + * Create all the reaction instances of this reactor instance + * and record the dependencies and antidependencies + * between ports, actions, and timers and reactions. + * This also records the dependencies between reactions + * that follows from the order in which they are defined. + */ + protected void createReactionInstances() { + List reactions = ASTUtils.allReactions(reactorDefinition); + if (reactions != null) { + int count = 0; + + // Check for startup and shutdown triggers. + for (Reaction reaction : reactions) { + if (AttributeUtils.isUnordered(reaction)) { + unorderedReactions.add(reaction); + } + // Create the reaction instance. + var reactionInstance = new ReactionInstance(reaction, this, + unorderedReactions.contains(reaction), count++); + + // Add the reaction instance to the map of reactions for this + // reactor. + this.reactions.add(reactionInstance); + } } - } } - return _instantiations; - } - - /** - * Returns true if this is a bank of reactors. - * - * @return true if a reactor is a bank, false otherwise - */ - public boolean isBank() { - return definition.getWidthSpec() != null; - } - - /** - * Returns whether this is a main or federated reactor. - * - * @return true if reactor definition is marked as main or federated, false otherwise. - */ - public boolean isMainOrFederated() { - return reactorDefinition != null - && (reactorDefinition.isMain() || reactorDefinition.isFederated()); - } - - /** - * Return true if the specified reactor instance is either equal to this reactor instance or a - * parent of it. - * - * @param r The reactor instance. - */ - public boolean isParent(ReactorInstance r) { - ReactorInstance p = this; - while (p != null) { - if (p == r) return true; - p = p.getParent(); + + /** + * Returns the built-in trigger or create a new one if none exists. + */ + protected TriggerInstance getOrCreateBuiltinTrigger(BuiltinTriggerRef trigger) { + return builtinTriggers.computeIfAbsent(trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); } - return false; - } - - /////////////////////////////////////////////////// - //// Methods for finding instances in this reactor given an AST node. - - /** - * Return the action instance within this reactor instance corresponding to the specified action - * reference. - * - * @param action The action as an AST node. - * @return The corresponding action instance or null if the action does not belong to this - * reactor. - */ - public ActionInstance lookupActionInstance(Action action) { - for (ActionInstance actionInstance : actions) { - if (actionInstance.definition == action) { - return actionInstance; - } + + /** Create all the watchdog instances of this reactor instance. */ + protected void createWatchdogInstances() { + List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); + if (watchdogs != null) { + for (Watchdog watchdog : watchdogs) { + // Create the watchdog instance. + var watchdogInstance = new WatchdogInstance(watchdog, this); + + // Add the watchdog instance to the list of watchdogs for this + // reactor. + this.watchdogs.add(watchdogInstance); + } + } } - return null; - } - - ////////////////////////////////////////////////////// - //// Private methods. - - /** - * Connect the given left port range to the given right port range. - * - *

NOTE: This method is public to enable its use in unit tests. Otherwise, it should be - * private. This is why it is defined here, in the section labeled "Private methods." - * - * @param src The source range. - * @param dst The destination range. - * @param connection The connection establishing this relationship. - */ - public static void connectPortInstances( - RuntimeRange src, RuntimeRange dst, Connection connection) { - SendRange range = new SendRange(src, dst, src._interleaved, connection); - src.instance.dependentPorts.add(range); - dst.instance.dependsOnPorts.add(src); - } - - ////////////////////////////////////////////////////// - //// Protected methods. - - /** Returns the built-in trigger or create a new one if none exists. */ - protected TriggerInstance getOrCreateBuiltinTrigger( - BuiltinTriggerRef trigger) { - return builtinTriggers.computeIfAbsent( - trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); - } - - /** - * Populate connectivity information in the port instances. Note that this can only happen _after_ - * the children and port instances have been created. Unfortunately, we have to do some - * complicated things here to support multiport-to-multiport, multiport-to-bank, and - * bank-to-multiport communication. The principle being followed is: in each connection statement, - * for each port instance on the left, connect to the next available port on the right. - */ - private void establishPortConnections() { - for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { - List> leftPorts = - listPortInstances(connection.getLeftPorts(), connection); - Iterator> srcRanges = leftPorts.iterator(); - List> rightPorts = - listPortInstances(connection.getRightPorts(), connection); - Iterator> dstRanges = rightPorts.iterator(); - - // Check for empty lists. - if (!srcRanges.hasNext()) { - if (dstRanges.hasNext()) { - reporter.reportWarning(connection, "No sources to provide inputs."); + + //////////////////////////////////////// + //// Private constructors + + /** + * Create a runtime instance from the specified definition + * and with the specified parent that instantiated it. + * @param definition The instantiation statement in the AST. + * @param parent The parent, or null for the main rector. + * @param reporter An error reporter. + * @param desiredDepth The depth to which to expand the hierarchy. + */ + private ReactorInstance( + Instantiation definition, + ReactorInstance parent, + ErrorReporter reporter, + int desiredDepth) { + super(definition, parent); + this.reporter = reporter; + this.reactorDeclaration = definition.getReactorClass(); + this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); + + // check for recursive instantiation + var currentParent = parent; + var foundSelfAsParent = false; + do { + if (currentParent != null) { + if (currentParent.reactorDefinition == this.reactorDefinition) { + foundSelfAsParent = true; + currentParent = null; // break + } else { + currentParent = currentParent.parent; + } + } + } while(currentParent != null); + + this.recursive = foundSelfAsParent; + if (recursive) { + reporter.reportError(definition, "Recursive reactor instantiation."); + } + + // If the reactor definition is null, give up here. Otherwise, diagram generation + // will fail an NPE. + if (reactorDefinition == null) { + reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); + return; + } + + setInitialWidth(); + + // Apply overrides and instantiate parameters for this reactor instance. + for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { + this.parameters.add(new ParameterInstance(parameter, this)); + } + + // Instantiate inputs for this reactor instance + for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { + this.inputs.add(new PortInstance(inputDecl, this, reporter)); + } + + // Instantiate outputs for this reactor instance + for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { + this.outputs.add(new PortInstance(outputDecl, this, reporter)); } - return; - } else if (!dstRanges.hasNext()) { - reporter.reportWarning(connection, "No destination. Outputs will be lost."); - return; - } - - RuntimeRange src = srcRanges.next(); - RuntimeRange dst = dstRanges.next(); - - while (true) { - if (dst.width == src.width) { - connectPortInstances(src, dst, connection); - if (!dstRanges.hasNext()) { - if (srcRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning( - connection, "Source is wider than the destination. Outputs will be lost."); + + // Do not process content (except interface above) if recursive + if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { + // Instantiate children for this reactor instance. + // While doing this, assign an index offset to each. + for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { + var childInstance = new ReactorInstance( + child, + this, + reporter, + desiredDepth + ); + this.children.add(childInstance); } - break; - } - if (!srcRanges.hasNext()) { - if (connection.isIterated()) { - srcRanges = leftPorts.iterator(); - } else { - if (dstRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning( - connection, "Destination is wider than the source. Inputs will be missing."); - } - break; + + // Instantiate timers for this reactor instance + for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { + this.timers.add(new TimerInstance(timerDecl, this)); } - } - dst = dstRanges.next(); - src = srcRanges.next(); - } else if (dst.width < src.width) { - // Split the left (src) range in two. - connectPortInstances(src.head(dst.width), dst, connection); - src = src.tail(dst.width); - if (!dstRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning( - connection, "Source is wider than the destination. Outputs will be lost."); - break; - } - dst = dstRanges.next(); - } else if (src.width < dst.width) { - // Split the right (dst) range in two. - connectPortInstances(src, dst.head(src.width), connection); - dst = dst.tail(src.width); - if (!srcRanges.hasNext()) { - if (connection.isIterated()) { - srcRanges = leftPorts.iterator(); - } else { - reporter.reportWarning( - connection, "Destination is wider than the source. Inputs will be missing."); - break; + + // Instantiate actions for this reactor instance + for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { + this.actions.add(new ActionInstance(actionDecl, this)); + } + + establishPortConnections(); + + // Create the reaction instances in this reactor instance. + // This also establishes all the implied dependencies. + // Note that this can only happen _after_ the children, + // port, action, and timer instances have been created. + createReactionInstances(); + + // Instantiate modes for this reactor instance + // This must come after the child elements (reactions, etc) of this reactor + // are created in order to allow their association with modes + for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { + this.modes.add(new ModeInstance(modeDecl, this)); + } + for (ModeInstance mode : this.modes) { + mode.setupTranstions(); } - } - src = srcRanges.next(); } - } } - } - - /** - * If path exists from the specified port to any reaction in the specified set of reactions, then - * add the specified port and all ports along the path to the specified set of ports. - * - * @return True if the specified port was added. - */ - private boolean findPaths( - PortInstance port, Set reactions, Set ports) { - if (ports.contains(port)) return false; - boolean result = false; - for (ReactionInstance d : port.getDependentReactions()) { - if (reactions.contains(d)) ports.add(port); - result = true; + + ////////////////////////////////////////////////////// + //// Private methods. + + /** + * Connect the given left port range to the given right port range. + * + * NOTE: This method is public to enable its use in unit tests. + * Otherwise, it should be private. This is why it is defined here, + * in the section labeled "Private methods." + * + * @param src The source range. + * @param dst The destination range. + * @param connection The connection establishing this relationship. + */ + public static void connectPortInstances( + RuntimeRange src, + RuntimeRange dst, + Connection connection + ) { + SendRange range = new SendRange(src, dst, src._interleaved, connection); + src.instance.dependentPorts.add(range); + dst.instance.dependsOnPorts.add(src); } - // Perform a depth-first search. - for (SendRange r : port.dependentPorts) { - for (RuntimeRange p : r.destinations) { - boolean added = findPaths(p.instance, reactions, ports); - if (added) { - result = true; - ports.add(port); + + /** + * Populate connectivity information in the port instances. + * Note that this can only happen _after_ the children and port instances have been created. + * Unfortunately, we have to do some complicated things here + * to support multiport-to-multiport, multiport-to-bank, + * and bank-to-multiport communication. The principle being followed is: + * in each connection statement, for each port instance on the left, + * connect to the next available port on the right. + */ + private void establishPortConnections() { + for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { + List> leftPorts = listPortInstances(connection.getLeftPorts(), connection); + Iterator> srcRanges = leftPorts.iterator(); + List> rightPorts = listPortInstances(connection.getRightPorts(), connection); + Iterator> dstRanges = rightPorts.iterator(); + + // Check for empty lists. + if (!srcRanges.hasNext()) { + if (dstRanges.hasNext()) { + reporter.reportWarning(connection, "No sources to provide inputs."); + } + return; + } else if (!dstRanges.hasNext()) { + reporter.reportWarning(connection, "No destination. Outputs will be lost."); + return; + } + + RuntimeRange src = srcRanges.next(); + RuntimeRange dst = dstRanges.next(); + + while(true) { + if (dst.width == src.width) { + connectPortInstances(src, dst, connection); + if (!dstRanges.hasNext()) { + if (srcRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning(connection, + "Source is wider than the destination. Outputs will be lost."); + } + break; + } + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + if (dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning(connection, + "Destination is wider than the source. Inputs will be missing."); + } + break; + } + } + dst = dstRanges.next(); + src = srcRanges.next(); + } else if (dst.width < src.width) { + // Split the left (src) range in two. + connectPortInstances(src.head(dst.width), dst, connection); + src = src.tail(dst.width); + if (!dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning(connection, + "Source is wider than the destination. Outputs will be lost."); + break; + } + dst = dstRanges.next(); + } else if (src.width < dst.width) { + // Split the right (dst) range in two. + connectPortInstances(src, dst.head(src.width), connection); + dst = dst.tail(src.width); + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + reporter.reportWarning(connection, + "Destination is wider than the source. Inputs will be missing."); + break; + } + } + src = srcRanges.next(); + } + } } - } } - return result; - } - - /** - * Given a list of port references, as found on either side of a connection, return a list of the - * port instance ranges referenced. These may be multiports, and may be ports of a contained bank - * (a port representing ports of the bank members) so the returned list includes ranges of banks - * and channels. - * - *

If a given port reference has the form `interleaved(b.m)`, where `b` is a bank and `m` is a - * multiport, then the corresponding range in the returned list is marked interleaved. - * - *

For example, if `b` and `m` have width 2, without the interleaved keyword, the returned - * range represents the sequence `[b0.m0, b0.m1, b1.m0, b1.m1]`. With the interleaved marking, the - * returned range represents the sequence `[b0.m0, b1.m0, b0.m1, b1.m1]`. Both ranges will have - * width 4. - * - * @param references The variable references on one side of the connection. - * @param connection The connection. - */ - private List> listPortInstances( - List references, Connection connection) { - List> result = new ArrayList<>(); - List> tails = new LinkedList<>(); - int count = 0; - for (VarRef portRef : references) { - // Simple error checking first. - if (!(portRef.getVariable() instanceof Port)) { - reporter.reportError(portRef, "Not a port."); - return result; - } - // First, figure out which reactor we are dealing with. - // The reactor we want is the container of the port. - // If the port reference has no container, then the reactor is this one. - var reactor = this; - if (portRef.getContainer() != null) { - reactor = getChildReactorInstance(portRef.getContainer()); - } - // The reactor can be null only if there is an error in the code. - // Skip this portRef so that diagram synthesis can complete. - if (reactor != null) { - PortInstance portInstance = reactor.lookupPortInstance((Port) portRef.getVariable()); - - Set interleaved = new LinkedHashSet<>(); - if (portRef.isInterleaved()) { - // NOTE: Here, we are assuming that the interleaved() - // keyword is only allowed on the multiports contained by - // contained reactors. - interleaved.add(portInstance.parent); + + /** + * If path exists from the specified port to any reaction in the specified + * set of reactions, then add the specified port and all ports along the path + * to the specified set of ports. + * @return True if the specified port was added. + */ + private boolean findPaths( + PortInstance port, + Set reactions, + Set ports + ) { + if (ports.contains(port)) return false; + boolean result = false; + for (ReactionInstance d : port.getDependentReactions()) { + if (reactions.contains(d)) ports.add(port); + result = true; } - RuntimeRange range = new RuntimeRange.Port(portInstance, interleaved); - // If this portRef is not the last one in the references list - // then we have to check whether the range can be incremented at - // the lowest two levels (port and container). If not, - // split the range and add the tail to list to iterate over again. - // The reason for this is that the connection has only local visibility, - // but the range width may be reflective of bank structure higher - // in the hierarchy. - if (count < references.size() - 1) { - int portWidth = portInstance.width; - int portParentWidth = portInstance.parent.width; - // If the port is being connected on the inside and there is - // more than one port in the list, then we can only connect one - // bank member at a time. - if (reactor == this && references.size() > 1) { - portParentWidth = 1; - } - int widthBound = portWidth * portParentWidth; - - // If either of these widths cannot be determined, assume infinite. - if (portWidth < 0) widthBound = Integer.MAX_VALUE; - if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; - - if (widthBound < range.width) { - // Need to split the range. - tails.add(range.tail(widthBound)); - range = range.head(widthBound); - } + // Perform a depth-first search. + for (SendRange r : port.dependentPorts) { + for (RuntimeRange p : r.destinations) { + boolean added = findPaths(p.instance, reactions, ports); + if (added) { + result = true; + ports.add(port); + } + } } - result.add(range); - } + return result; } - // Iterate over the tails. - while (tails.size() > 0) { - List> moreTails = new LinkedList<>(); - count = 0; - for (RuntimeRange tail : tails) { - if (count < tails.size() - 1) { - int widthBound = tail.instance.width; - if (tail._interleaved.contains(tail.instance.parent)) { - widthBound = tail.instance.parent.width; - } - // If the width cannot be determined, assume infinite. - if (widthBound < 0) widthBound = Integer.MAX_VALUE; - - if (widthBound < tail.width) { - // Need to split the range again - moreTails.add(tail.tail(widthBound)); - tail = tail.head(widthBound); - } + + /** + * Given a list of port references, as found on either side of a connection, + * return a list of the port instance ranges referenced. These may be multiports, + * and may be ports of a contained bank (a port representing ports of the bank + * members) so the returned list includes ranges of banks and channels. + * + * If a given port reference has the form `interleaved(b.m)`, where `b` is + * a bank and `m` is a multiport, then the corresponding range in the returned + * list is marked interleaved. + * + * For example, if `b` and `m` have width 2, without the interleaved keyword, + * the returned range represents the sequence `[b0.m0, b0.m1, b1.m0, b1.m1]`. + * With the interleaved marking, the returned range represents the sequence + * `[b0.m0, b1.m0, b0.m1, b1.m1]`. Both ranges will have width 4. + * + * @param references The variable references on one side of the connection. + * @param connection The connection. + */ + private List> listPortInstances( + List references, Connection connection + ) { + List> result = new ArrayList<>(); + List> tails = new LinkedList<>(); + int count = 0; + for (VarRef portRef : references) { + // Simple error checking first. + if (!(portRef.getVariable() instanceof Port)) { + reporter.reportError(portRef, "Not a port."); + return result; + } + // First, figure out which reactor we are dealing with. + // The reactor we want is the container of the port. + // If the port reference has no container, then the reactor is this one. + var reactor = this; + if (portRef.getContainer() != null) { + reactor = getChildReactorInstance(portRef.getContainer()); + } + // The reactor can be null only if there is an error in the code. + // Skip this portRef so that diagram synthesis can complete. + if (reactor != null) { + PortInstance portInstance = reactor.lookupPortInstance( + (Port) portRef.getVariable()); + + Set interleaved = new LinkedHashSet<>(); + if (portRef.isInterleaved()) { + // NOTE: Here, we are assuming that the interleaved() + // keyword is only allowed on the multiports contained by + // contained reactors. + interleaved.add(portInstance.parent); + } + RuntimeRange range = new RuntimeRange.Port( + portInstance, interleaved); + // If this portRef is not the last one in the references list + // then we have to check whether the range can be incremented at + // the lowest two levels (port and container). If not, + // split the range and add the tail to list to iterate over again. + // The reason for this is that the connection has only local visibility, + // but the range width may be reflective of bank structure higher + // in the hierarchy. + if (count < references.size() - 1) { + int portWidth = portInstance.width; + int portParentWidth = portInstance.parent.width; + // If the port is being connected on the inside and there is + // more than one port in the list, then we can only connect one + // bank member at a time. + if (reactor == this && references.size() > 1) { + portParentWidth = 1; + } + int widthBound = portWidth * portParentWidth; + + // If either of these widths cannot be determined, assume infinite. + if (portWidth < 0) widthBound = Integer.MAX_VALUE; + if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < range.width) { + // Need to split the range. + tails.add(range.tail(widthBound)); + range = range.head(widthBound); + } + } + result.add(range); + } + } + // Iterate over the tails. + while(tails.size() > 0) { + List> moreTails = new LinkedList<>(); + count = 0; + for (RuntimeRange tail : tails) { + if (count < tails.size() - 1) { + int widthBound = tail.instance.width; + if (tail._interleaved.contains(tail.instance.parent)) { + widthBound = tail.instance.parent.width; + } + // If the width cannot be determined, assume infinite. + if (widthBound < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < tail.width) { + // Need to split the range again + moreTails.add(tail.tail(widthBound)); + tail = tail.head(widthBound); + } + } + result.add(tail); + } + tails = moreTails; } - result.add(tail); - } - tails = moreTails; + return result; } - return result; - } - - /** - * If this is a bank of reactors, set the width. It will be set to -1 if it cannot be determined. - */ - private void setInitialWidth() { - WidthSpec widthSpec = definition.getWidthSpec(); - if (widthSpec != null) { - // We need the instantiations list of the containing reactor, - // not this one. - width = ASTUtils.width(widthSpec, parent.instantiations()); + + /** + * If this is a bank of reactors, set the width. + * It will be set to -1 if it cannot be determined. + */ + private void setInitialWidth() { + WidthSpec widthSpec = definition.getWidthSpec(); + if (widthSpec != null) { + // We need the instantiations list of the containing reactor, + // not this one. + width = ASTUtils.width(widthSpec, parent.instantiations()); + } } - } - - ////////////////////////////////////////////////////// - //// Private fields. - - /** Cached set of reactions and ports that form a causality loop. */ - private Set> cachedCycles; - - /** Cached reaction graph containing reactions that form a causality loop. */ - private ReactionInstanceGraph cachedReactionLoopGraph = null; - - /** - * Return true if this is a generated delay reactor that originates from an "after" delay on a - * connection. - * - * @return True if this is a generated delay, false otherwise. - */ - public boolean isGeneratedDelay() { - if (this.definition - .getReactorClass() - .getName() - .contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME)) { - return true; + + ////////////////////////////////////////////////////// + //// Private fields. + + /** + * Cached set of reactions and ports that form a causality loop. + */ + private Set> cachedCycles; + + /** + * Cached reaction graph containing reactions that form a causality loop. + */ + private ReactionInstanceGraph cachedReactionLoopGraph = null; + + /** + * Return true if this is a generated delay reactor that originates from + * an "after" delay on a connection. + * + * @return True if this is a generated delay, false otherwise. + */ + public boolean isGeneratedDelay() { + // FIXME: hacky string matching again... + if (this.definition.getReactorClass().getName().contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME)) { + return true; + } + return false; } - return false; - } } diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index a203f9ee3c..3dd1aef157 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -9,6 +9,7 @@ import java.util.List; import java.util.Map; import java.util.Set; + import org.lflang.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; @@ -37,1353 +38,1159 @@ import org.lflang.util.StringUtil; public class CReactionGenerator { - protected static String DISABLE_REACTION_INITIALIZATION_MARKER = - "// **** Do not include initialization code in this reaction."; // FIXME: Such markers should - // not exist (#1687) + protected static String DISABLE_REACTION_INITIALIZATION_MARKER + = "// **** Do not include initialization code in this reaction."; // FIXME: Such markers should not exist (#1687) - /** - * Generate necessary initialization code inside the body of the reaction that belongs to reactor - * decl. - * - * @param body The body of the reaction. Used to check for the - * DISABLE_REACTION_INITIALIZATION_MARKER. - * @param reaction The initialization code will be generated for this specific reaction - * @param decl The reactor that has the reaction - * @param reactionIndex The index of the reaction relative to other reactions in the reactor, - * starting from 0 - */ - public static String generateInitializationForReaction( - String body, - Reaction reaction, - Reactor decl, - int reactionIndex, - CTypes types, - ErrorReporter errorReporter, - Instantiation mainDef, - boolean requiresTypes) { - Reactor reactor = ASTUtils.toDefinition(decl); + /** + * Generate necessary initialization code inside the body of the reaction that belongs to reactor decl. + * @param body The body of the reaction. Used to check for the DISABLE_REACTION_INITIALIZATION_MARKER. + * @param reaction The initialization code will be generated for this specific reaction + * @param decl The reactor that has the reaction + * @param reactionIndex The index of the reaction relative to other reactions in the reactor, starting from 0 + */ + public static String generateInitializationForReaction(String body, + Reaction reaction, + Reactor decl, + int reactionIndex, + CTypes types, + ErrorReporter errorReporter, + Instantiation mainDef, + boolean requiresTypes) { + Reactor reactor = ASTUtils.toDefinition(decl); - // Construct the reactionInitialization code to go into - // the body of the function before the verbatim code. - CodeBuilder reactionInitialization = new CodeBuilder(); + // Construct the reactionInitialization code to go into + // the body of the function before the verbatim code. + CodeBuilder reactionInitialization = new CodeBuilder(); - CodeBuilder code = new CodeBuilder(); + CodeBuilder code = new CodeBuilder(); - // Define the "self" struct. - String structType = CUtil.selfType(decl); - // A null structType means there are no inputs, state, - // or anything else. No need to declare it. - if (structType != null) { - code.pr( - String.join( - "\n", - structType - + "* self = (" - + structType - + "*)instance_args; SUPPRESS_UNUSED_WARNING(self);")); - } + // Define the "self" struct. + String structType = CUtil.selfType(decl); + // A null structType means there are no inputs, state, + // or anything else. No need to declare it. + if (structType != null) { + code.pr(String.join("\n", + structType+"* self = ("+structType+"*)instance_args; SUPPRESS_UNUSED_WARNING(self);" + )); + } - // Do not generate the initialization code if the body is marked - // to not generate it. - if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { - return code.toString(); - } + // Do not generate the initialization code if the body is marked + // to not generate it. + if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { + return code.toString(); + } - // A reaction may send to or receive from multiple ports of - // a contained reactor. The variables for these ports need to - // all be declared as fields of the same struct. Hence, we first - // collect the fields to be defined in the structs and then - // generate the structs. - Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); + // A reaction may send to or receive from multiple ports of + // a contained reactor. The variables for these ports need to + // all be declared as fields of the same struct. Hence, we first + // collect the fields to be defined in the structs and then + // generate the structs. + Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); - // Actions may appear twice, first as a trigger, then with the outputs. - // But we need to declare it only once. Collect in this data structure - // the actions that are declared as triggered so that if they appear - // again with the outputs, they are not defined a second time. - // That second redefinition would trigger a compile error. - Set actionsAsTriggers = new LinkedHashSet<>(); + // Actions may appear twice, first as a trigger, then with the outputs. + // But we need to declare it only once. Collect in this data structure + // the actions that are declared as triggered so that if they appear + // again with the outputs, they are not defined a second time. + // That second redefinition would trigger a compile error. + Set actionsAsTriggers = new LinkedHashSet<>(); - // Next, add the triggers (input and actions; timers are not needed). - // This defines a local variable in the reaction function whose - // name matches that of the trigger. The value of the local variable - // is a struct with a value and is_present field, the latter a boolean - // that indicates whether the input/action is present. - // If the trigger is an output, then it is an output of a - // contained reactor. In this case, a struct with the name - // of the contained reactor is created with one field that is - // a pointer to a struct with a value and is_present field. - // E.g., if the contained reactor is named 'c' and its output - // port is named 'out', then c.out->value c.out->is_present are - // defined so that they can be used in the verbatim code. - for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (triggerAsVarRef.getVariable() instanceof Port) { - generatePortVariablesInReaction( - reactionInitialization, - fieldsForStructsForContainedReactors, - triggerAsVarRef, - decl, - types); - } else if (triggerAsVarRef.getVariable() instanceof Action) { - reactionInitialization.pr( - generateActionVariablesInReaction( - (Action) triggerAsVarRef.getVariable(), decl, types)); - actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); + // Next, add the triggers (input and actions; timers are not needed). + // This defines a local variable in the reaction function whose + // name matches that of the trigger. The value of the local variable + // is a struct with a value and is_present field, the latter a boolean + // that indicates whether the input/action is present. + // If the trigger is an output, then it is an output of a + // contained reactor. In this case, a struct with the name + // of the contained reactor is created with one field that is + // a pointer to a struct with a value and is_present field. + // E.g., if the contained reactor is named 'c' and its output + // port is named 'out', then c.out->value c.out->is_present are + // defined so that they can be used in the verbatim code. + for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (triggerAsVarRef.getVariable() instanceof Port) { + generatePortVariablesInReaction( + reactionInitialization, + fieldsForStructsForContainedReactors, + triggerAsVarRef, + decl, + types); + } else if (triggerAsVarRef.getVariable() instanceof Action) { + reactionInitialization.pr(generateActionVariablesInReaction( + (Action) triggerAsVarRef.getVariable(), + decl, + types + )); + actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); + } + } + } + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + // No triggers are given, which means react to any input. + // Declare an argument for every input. + // NOTE: this does not include contained outputs. + for (Input input : reactor.getInputs()) { + reactionInitialization.pr(generateInputVariablesInReaction(input, decl, types)); + } + } + // Define argument for non-triggering inputs. + for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { + if (src.getVariable() instanceof Port) { + generatePortVariablesInReaction(reactionInitialization, fieldsForStructsForContainedReactors, src, decl, types); + } else if (src.getVariable() instanceof Action) { + // It's a bit odd to read but not be triggered by an action, but + // OK, I guess we allow it. + reactionInitialization.pr(generateActionVariablesInReaction( + (Action) src.getVariable(), + decl, + types + )); + actionsAsTriggers.add((Action) src.getVariable()); + } } - } - } - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - // No triggers are given, which means react to any input. - // Declare an argument for every input. - // NOTE: this does not include contained outputs. - for (Input input : reactor.getInputs()) { - reactionInitialization.pr(generateInputVariablesInReaction(input, decl, types)); - } - } - // Define argument for non-triggering inputs. - for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { - if (src.getVariable() instanceof Port) { - generatePortVariablesInReaction( - reactionInitialization, fieldsForStructsForContainedReactors, src, decl, types); - } else if (src.getVariable() instanceof Action) { - // It's a bit odd to read but not be triggered by an action, but - // OK, I guess we allow it. - reactionInitialization.pr( - generateActionVariablesInReaction((Action) src.getVariable(), decl, types)); - actionsAsTriggers.add((Action) src.getVariable()); - } - } - // Define variables for each declared output or action. - // In the case of outputs, the variable is a pointer to where the - // output is stored. This gives the reaction code access to any previous - // value that may have been written to that output in an earlier reaction. - if (reaction.getEffects() != null) { - for (VarRef effect : reaction.getEffects()) { - Variable variable = effect.getVariable(); - if (variable instanceof Action) { - // It is an action, not an output. - // If it has already appeared as trigger, do not redefine it. - if (!actionsAsTriggers.contains(effect.getVariable())) { - reactionInitialization.pr( - CGenerator.variableStructType(variable, decl, false) - + "* " - + variable.getName() - + " = &self->_lf_" - + variable.getName() - + ";"); - } - } else if (effect.getVariable() instanceof Mode) { - // Mode change effect - int idx = ASTUtils.allModes(reactor).indexOf((Mode) effect.getVariable()); - String name = effect.getVariable().getName(); - if (idx >= 0) { - reactionInitialization.pr( - "reactor_mode_t* " - + name - + " = &self->_lf__modes[" - + idx - + "];\n" - + "lf_mode_change_type_t _lf_" - + name - + "_change_type = " - + (effect.getTransition() == ModeTransition.HISTORY - ? "history_transition" - : "reset_transition") - + ";"); - } else { - errorReporter.reportError( - reaction, "In generateReaction(): " + name + " not a valid mode of this reactor."); - } - } else { - if (variable instanceof Output) { - reactionInitialization.pr( - generateOutputVariablesInReaction(effect, decl, errorReporter, requiresTypes)); - } else if (variable instanceof Input) { - // It is the input of a contained reactor. - generateVariablesForSendingToContainedReactors( - reactionInitialization, - fieldsForStructsForContainedReactors, - effect.getContainer(), - (Input) variable); - } else if (variable instanceof Watchdog) { - reactionInitialization.pr(generateWatchdogVariablesInReaction(effect, decl)); - } else { - errorReporter.reportError( - reaction, "In generateReaction(): effect is neither an input nor an output."); - } + // Define variables for each declared output or action. + // In the case of outputs, the variable is a pointer to where the + // output is stored. This gives the reaction code access to any previous + // value that may have been written to that output in an earlier reaction. + if (reaction.getEffects() != null) { + for (VarRef effect : reaction.getEffects()) { + Variable variable = effect.getVariable(); + if (variable instanceof Action) { + // It is an action, not an output. + // If it has already appeared as trigger, do not redefine it. + if (!actionsAsTriggers.contains(effect.getVariable())) { + reactionInitialization.pr(CGenerator.variableStructType(variable, decl, false)+"* "+variable.getName()+" = &self->_lf_"+variable.getName()+";"); + } + } else if (effect.getVariable() instanceof Mode) { + // Mode change effect + int idx = ASTUtils.allModes(reactor).indexOf((Mode)effect.getVariable()); + String name = effect.getVariable().getName(); + if (idx >= 0) { + reactionInitialization.pr( + "reactor_mode_t* " + name + " = &self->_lf__modes[" + idx + "];\n" + + "lf_mode_change_type_t _lf_" + name + "_change_type = " + + (effect.getTransition() == ModeTransition.HISTORY ? + "history_transition" : "reset_transition") + + ";" + ); + } else { + errorReporter.reportError( + reaction, + "In generateReaction(): " + name + " not a valid mode of this reactor." + ); + } + } else { + if (variable instanceof Output) { + reactionInitialization.pr(generateOutputVariablesInReaction( + effect, + decl, + errorReporter, + requiresTypes + )); + } else if (variable instanceof Input) { + // It is the input of a contained reactor. + generateVariablesForSendingToContainedReactors( + reactionInitialization, + fieldsForStructsForContainedReactors, + effect.getContainer(), + (Input) variable); + } else if (variable instanceof Watchdog) { + reactionInitialization.pr(generateWatchdogVariablesInReaction(effect, decl)); + } else { + errorReporter.reportError( + reaction, + "In generateReaction(): effect is not an input, output, or watchdog." + ); + } + } + } } - } - } - // Before the reaction initialization, - // generate the structs used for communication to and from contained reactors. - for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { - String array = ""; - if (containedReactor.getWidthSpec() != null) { - String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); - code.pr( - "int " + containedReactorWidthVar + " = self->_lf_" + containedReactorWidthVar + ";"); - // Windows does not support variables in arrays declared on the stack, - // so we use the maximum size over all bank members. - array = "[" + maxContainedReactorBankWidth(containedReactor, null, 0, mainDef) + "]"; - } - code.pr( - String.join( - "\n", - "struct " + containedReactor.getName() + " {", - " " + fieldsForStructsForContainedReactors.get(containedReactor) + "", - "} " + containedReactor.getName() + array + ";")); + // Before the reaction initialization, + // generate the structs used for communication to and from contained reactors. + for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { + String array = ""; + if (containedReactor.getWidthSpec() != null) { + String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); + code.pr("int "+containedReactorWidthVar+" = self->_lf_"+containedReactorWidthVar+";"); + // Windows does not support variables in arrays declared on the stack, + // so we use the maximum size over all bank members. + array = "["+maxContainedReactorBankWidth(containedReactor, null, 0, mainDef)+"]"; + } + code.pr(String.join("\n", + "struct "+containedReactor.getName()+" {", + " "+fieldsForStructsForContainedReactors.get(containedReactor)+"", + "} "+containedReactor.getName()+array+";" + )); + } + // Next generate all the collected setup code. + code.pr(reactionInitialization.toString()); + return code.toString(); } - // Next generate all the collected setup code. - code.pr(reactionInitialization.toString()); - return code.toString(); - } - /** - * Return the maximum bank width for the given instantiation within all instantiations of its - * parent reactor. On the first call to this method, the breadcrumbs should be null and the max - * argument should be zero. On recursive calls, breadcrumbs is a list of nested instantiations, - * the max is the maximum width found so far. The search for instances of the parent reactor will - * begin with the last instantiation in the specified list. - * - *

This rather complicated method is used when a reaction sends or receives data to or from a - * bank of contained reactors. There will be an array of structs on the self struct of the parent, - * and the size of the array is conservatively set to the maximum of all the identified bank - * widths. This is a bit wasteful of memory, but it avoids having to malloc the array for each - * instance, and in typical usage, there will be few instances or instances that are all the same - * width. - * - * @param containedReactor The contained reactor instantiation. - * @param breadcrumbs null on first call (non-recursive). - * @param max 0 on first call. - */ - public static int maxContainedReactorBankWidth( - Instantiation containedReactor, - LinkedList breadcrumbs, - int max, - Instantiation mainDef) { - // If the instantiation is not a bank, return 1. - if (containedReactor.getWidthSpec() == null) { - return 1; - } - // If there is no main, then we just use the default width. - if (mainDef == null) { - return ASTUtils.width(containedReactor.getWidthSpec(), null); + /** + * Return the maximum bank width for the given instantiation within all + * instantiations of its parent reactor. + * On the first call to this method, the breadcrumbs should be null and the max + * argument should be zero. On recursive calls, breadcrumbs is a list of nested + * instantiations, the max is the maximum width found so far. The search for + * instances of the parent reactor will begin with the last instantiation + * in the specified list. + * + * This rather complicated method is used when a reaction sends or receives data + * to or from a bank of contained reactors. There will be an array of structs on + * the self struct of the parent, and the size of the array is conservatively set + * to the maximum of all the identified bank widths. This is a bit wasteful of + * memory, but it avoids having to malloc the array for each instance, and in + * typical usage, there will be few instances or instances that are all the same + * width. + * + * @param containedReactor The contained reactor instantiation. + * @param breadcrumbs null on first call (non-recursive). + * @param max 0 on first call. + */ + public static int maxContainedReactorBankWidth( + Instantiation containedReactor, + LinkedList breadcrumbs, + int max, + Instantiation mainDef + ) { + // If the instantiation is not a bank, return 1. + if (containedReactor.getWidthSpec() == null) { + return 1; + } + // If there is no main, then we just use the default width. + if (mainDef == null) { + return ASTUtils.width(containedReactor.getWidthSpec(), null); + } + LinkedList nestedBreadcrumbs = breadcrumbs; + if (nestedBreadcrumbs == null) { + nestedBreadcrumbs = new LinkedList<>(); + nestedBreadcrumbs.add(mainDef); + } + int result = max; + Reactor parent = (Reactor) containedReactor.eContainer(); + if (parent == ASTUtils.toDefinition(mainDef.getReactorClass())) { + // The parent is main, so there can't be any other instantiations of it. + return ASTUtils.width(containedReactor.getWidthSpec(), null); + } + // Search for instances of the parent within the tail of the breadcrumbs list. + Reactor container = ASTUtils.toDefinition(nestedBreadcrumbs.get(0).getReactorClass()); + for (Instantiation instantiation : container.getInstantiations()) { + // Put this new instantiation at the head of the list. + nestedBreadcrumbs.add(0, instantiation); + if (ASTUtils.toDefinition(instantiation.getReactorClass()) == parent) { + // Found a matching instantiation of the parent. + // Evaluate the original width specification in this context. + int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); + if (candidate > result) { + result = candidate; + } + } else { + // Found some other instantiation, not the parent. + // Search within it for instantiations of the parent. + // Note that we assume here that the parent cannot contain + // instances of itself. + int candidate = maxContainedReactorBankWidth(containedReactor, nestedBreadcrumbs, result, mainDef); + if (candidate > result) { + result = candidate; + } + } + nestedBreadcrumbs.remove(); + } + return result; } - LinkedList nestedBreadcrumbs = breadcrumbs; - if (nestedBreadcrumbs == null) { - nestedBreadcrumbs = new LinkedList<>(); - nestedBreadcrumbs.add(mainDef); + + /** + * Generate code for the body of a reaction that takes an input and + * schedules an action with the value of that input. + * @param actionName The action to schedule + */ + public static String generateDelayBody(String ref, String actionName, boolean isTokenType) { + // Note that the action.type set by the base class is actually + // the port type. + return isTokenType ? + String.join("\n", + "if ("+ref+"->is_present) {", + " // Put the whole token on the event queue, not just the payload.", + " // This way, the length and element_size are transported.", + " lf_schedule_token("+actionName+", 0, "+ref+"->token);", + "}" + ) : + "lf_schedule_copy("+actionName+", 0, &"+ref+"->value, 1); // Length is 1."; } - int result = max; - Reactor parent = (Reactor) containedReactor.eContainer(); - if (parent == ASTUtils.toDefinition(mainDef.getReactorClass())) { - // The parent is main, so there can't be any other instantiations of it. - return ASTUtils.width(containedReactor.getWidthSpec(), null); + + public static String generateForwardBody(String outputName, String targetType, String actionName, boolean isTokenType) { + return isTokenType ? + String.join("\n", + DISABLE_REACTION_INITIALIZATION_MARKER, + "self->_lf_"+outputName+".value = ("+targetType+")self->_lf__"+actionName+".tmplt.token->value;", + "_lf_replace_template_token((token_template_t*)&self->_lf_"+outputName+", (lf_token_t*)self->_lf__"+actionName+".tmplt.token);", + "self->_lf_"+outputName+".is_present = true;" + ) : + "lf_set("+outputName+", "+actionName+"->value);"; } - // Search for instances of the parent within the tail of the breadcrumbs list. - Reactor container = ASTUtils.toDefinition(nestedBreadcrumbs.get(0).getReactorClass()); - for (Instantiation instantiation : container.getInstantiations()) { - // Put this new instantiation at the head of the list. - nestedBreadcrumbs.add(0, instantiation); - if (ASTUtils.toDefinition(instantiation.getReactorClass()) == parent) { - // Found a matching instantiation of the parent. - // Evaluate the original width specification in this context. - int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); - if (candidate > result) { - result = candidate; + + /** + * Generate into the specified string builder the code to + * initialize local variables for sending data to an input + * of a contained reactor. This will also, if necessary, + * generate entries for local struct definitions into the + * struct argument. These entries point to where the data + * is stored. + * + * @param builder The string builder. + * @param structs A map from reactor instantiations to a place to write + * struct fields. + * @param definition AST node defining the reactor within which this occurs + * @param input Input of the contained reactor. + */ + private static void generateVariablesForSendingToContainedReactors( + CodeBuilder builder, + Map structs, + Instantiation definition, + Input input + ) { + CodeBuilder structBuilder = structs.get(definition); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(definition, structBuilder); } - } else { - // Found some other instantiation, not the parent. - // Search within it for instantiations of the parent. - // Note that we assume here that the parent cannot contain - // instances of itself. - int candidate = - maxContainedReactorBankWidth(containedReactor, nestedBreadcrumbs, result, mainDef); - if (candidate > result) { - result = candidate; + String inputStructType = CGenerator.variableStructType(input, ASTUtils.toDefinition(definition.getReactorClass()), false); + String defName = definition.getName(); + String defWidth = generateWidthVariable(defName); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); + if (!ASTUtils.isMultiport(input)) { + // Contained reactor's input is not a multiport. + structBuilder.pr(inputStructType+"* "+inputName+";"); + if (definition.getWidthSpec() != null) { + // Contained reactor is a bank. + builder.pr(String.join("\n", + "for (int bankIndex = 0; bankIndex < self->_lf_"+defWidth+"; bankIndex++) {", + " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+defName+"[bankIndex]."+inputName+");", + "}" + )); + } else { + // Contained reactor is not a bank. + builder.pr(defName+"."+inputName+" = &(self->_lf_"+defName+"."+inputName+");"); + } + } else { + // Contained reactor's input is a multiport. + structBuilder.pr(String.join("\n", + inputStructType+"** "+inputName+";", + "int "+inputWidth+";" + )); + // If the contained reactor is a bank, then we have to set the + // pointer for each element of the bank. + if (definition.getWidthSpec() != null) { + builder.pr(String.join("\n", + "for (int _i = 0; _i < self->_lf_"+defWidth+"; _i++) {", + " "+defName+"[_i]."+inputName+" = self->_lf_"+defName+"[_i]."+inputName+";", + " "+defName+"[_i]."+inputWidth+" = self->_lf_"+defName+"[_i]."+inputWidth+";", + "}" + )); + } else { + builder.pr(String.join("\n", + defName+"."+inputName+" = self->_lf_"+defName+"."+inputName+";", + defName+"."+inputWidth+" = self->_lf_"+defName+"."+inputWidth+";" + )); + } } - } - nestedBreadcrumbs.remove(); } - return result; - } - /** - * Generate code for the body of a reaction that takes an input and schedules an action with the - * value of that input. - * - * @param actionName The action to schedule - */ - public static String generateDelayBody(String ref, String actionName, boolean isTokenType) { - // Note that the action.type set by the base class is actually - // the port type. - return isTokenType - ? String.join( - "\n", - "if (" + ref + "->is_present) {", - " // Put the whole token on the event queue, not just the payload.", - " // This way, the length and element_size are transported.", - " lf_schedule_token(" + actionName + ", 0, " + ref + "->token);", - "}") - : "lf_schedule_copy(" + actionName + ", 0, &" + ref + "->value, 1); // Length is 1."; - } + /** + * Generate into the specified string builder the code to + * initialize local variables for ports in a reaction function + * from the "self" struct. The port may be an input of the + * reactor or an output of a contained reactor. The second + * argument provides, for each contained reactor, a place to + * write the declaration of the output of that reactor that + * is triggering reactions. + * @param builder The place into which to write the code. + * @param structs A map from reactor instantiations to a place to write + * struct fields. + */ + private static void generatePortVariablesInReaction( + CodeBuilder builder, + Map structs, + VarRef port, + Reactor r, + CTypes types + ) { + if (port.getVariable() instanceof Input) { + builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), r, types)); + } else { + // port is an output of a contained reactor. + Output output = (Output) port.getVariable(); + String portStructType = CGenerator.variableStructType(output, ASTUtils.toDefinition(port.getContainer().getReactorClass()), false); - public static String generateForwardBody( - String outputName, String targetType, String actionName, boolean isTokenType) { - return isTokenType - ? String.join( - "\n", - DISABLE_REACTION_INITIALIZATION_MARKER, - "self->_lf_" - + outputName - + ".value = (" - + targetType - + ")self->_lf__" - + actionName - + ".tmplt.token->value;", - "_lf_replace_template_token((token_template_t*)&self->_lf_" - + outputName - + ", (lf_token_t*)self->_lf__" - + actionName - + ".tmplt.token);", - "self->_lf_" + outputName + ".is_present = true;") - : "lf_set(" + outputName + ", " + actionName + "->value);"; - } + CodeBuilder structBuilder = structs.get(port.getContainer()); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(port.getContainer(), structBuilder); + } + String reactorName = port.getContainer().getName(); + String reactorWidth = generateWidthVariable(reactorName); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + // First define the struct containing the output value and indicator + // of its presence. + if (!ASTUtils.isMultiport(output)) { + // Output is not a multiport. + structBuilder.pr(portStructType+"* "+outputName+";"); + } else { + // Output is a multiport. + structBuilder.pr(String.join("\n", + portStructType+"** "+outputName+";", + "int "+outputWidth+";" + )); + } - /** - * Generate into the specified string builder the code to initialize local variables for sending - * data to an input of a contained reactor. This will also, if necessary, generate entries for - * local struct definitions into the struct argument. These entries point to where the data is - * stored. - * - * @param builder The string builder. - * @param structs A map from reactor instantiations to a place to write struct fields. - * @param definition AST node defining the reactor within which this occurs - * @param input Input of the contained reactor. - */ - private static void generateVariablesForSendingToContainedReactors( - CodeBuilder builder, - Map structs, - Instantiation definition, - Input input) { - CodeBuilder structBuilder = structs.get(definition); - if (structBuilder == null) { - structBuilder = new CodeBuilder(); - structs.put(definition, structBuilder); - } - String inputStructType = - CGenerator.variableStructType( - input, ASTUtils.toDefinition(definition.getReactorClass()), false); - String defName = definition.getName(); - String defWidth = generateWidthVariable(defName); - String inputName = input.getName(); - String inputWidth = generateWidthVariable(inputName); - if (!ASTUtils.isMultiport(input)) { - // Contained reactor's input is not a multiport. - structBuilder.pr(inputStructType + "* " + inputName + ";"); - if (definition.getWidthSpec() != null) { - // Contained reactor is a bank. - builder.pr( - String.join( - "\n", - "for (int bankIndex = 0; bankIndex < self->_lf_" + defWidth + "; bankIndex++) {", - " " - + defName - + "[bankIndex]." - + inputName - + " = &(self->_lf_" - + defName - + "[bankIndex]." - + inputName - + ");", - "}")); - } else { - // Contained reactor is not a bank. - builder.pr( - defName + "." + inputName + " = &(self->_lf_" + defName + "." + inputName + ");"); - } - } else { - // Contained reactor's input is a multiport. - structBuilder.pr( - String.join("\n", inputStructType + "** " + inputName + ";", "int " + inputWidth + ";")); - // If the contained reactor is a bank, then we have to set the - // pointer for each element of the bank. - if (definition.getWidthSpec() != null) { - builder.pr( - String.join( - "\n", - "for (int _i = 0; _i < self->_lf_" + defWidth + "; _i++) {", - " " - + defName - + "[_i]." - + inputName - + " = self->_lf_" - + defName - + "[_i]." - + inputName - + ";", - " " - + defName - + "[_i]." - + inputWidth - + " = self->_lf_" - + defName - + "[_i]." - + inputWidth - + ";", - "}")); - } else { - builder.pr( - String.join( - "\n", - defName + "." + inputName + " = self->_lf_" + defName + "." + inputName + ";", - defName + "." + inputWidth + " = self->_lf_" + defName + "." + inputWidth + ";")); - } + // Next, initialize the struct with the current values. + if (port.getContainer().getWidthSpec() != null) { + // Output is in a bank. + builder.pr(String.join("\n", + "for (int i = 0; i < "+reactorWidth+"; i++) {", + " "+reactorName+"[i]."+outputName+" = self->_lf_"+reactorName+"[i]."+outputName+";", + "}" + )); + if (ASTUtils.isMultiport(output)) { + builder.pr(String.join("\n", + "for (int i = 0; i < "+reactorWidth+"; i++) {", + " "+reactorName+"[i]."+outputWidth+" = self->_lf_"+reactorName+"[i]."+outputWidth+";", + "}" + )); + } + } else { + // Output is not in a bank. + builder.pr(reactorName+"."+outputName+" = self->_lf_"+reactorName+"."+outputName+";"); + if (ASTUtils.isMultiport(output)) { + builder.pr(reactorName+"."+outputWidth+" = self->_lf_"+reactorName+"."+outputWidth+";"); + } + } + } } - } - - /** - * Generate into the specified string builder the code to initialize local variables for ports in - * a reaction function from the "self" struct. The port may be an input of the reactor or an - * output of a contained reactor. The second argument provides, for each contained reactor, a - * place to write the declaration of the output of that reactor that is triggering reactions. - * - * @param builder The place into which to write the code. - * @param structs A map from reactor instantiations to a place to write struct fields. - */ - private static void generatePortVariablesInReaction( - CodeBuilder builder, - Map structs, - VarRef port, - Reactor r, - CTypes types) { - if (port.getVariable() instanceof Input) { - builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), r, types)); - } else { - // port is an output of a contained reactor. - Output output = (Output) port.getVariable(); - String portStructType = - CGenerator.variableStructType( - output, ASTUtils.toDefinition(port.getContainer().getReactorClass()), false); - CodeBuilder structBuilder = structs.get(port.getContainer()); - if (structBuilder == null) { - structBuilder = new CodeBuilder(); - structs.put(port.getContainer(), structBuilder); - } - String reactorName = port.getContainer().getName(); - String reactorWidth = generateWidthVariable(reactorName); - String outputName = output.getName(); - String outputWidth = generateWidthVariable(outputName); - // First define the struct containing the output value and indicator - // of its presence. - if (!ASTUtils.isMultiport(output)) { - // Output is not a multiport. - structBuilder.pr(portStructType + "* " + outputName + ";"); - } else { - // Output is a multiport. - structBuilder.pr( - String.join( - "\n", portStructType + "** " + outputName + ";", "int " + outputWidth + ";")); - } + /** Generate action variables for a reaction. + * @param action The action. + */ + private static String generateActionVariablesInReaction( + Action action, + Reactor r, + CTypes types + ) { + String structType = CGenerator.variableStructType(action, r, false); + // If the action has a type, create variables for accessing the value. + InferredType type = ASTUtils.getInferredType(action); + // Pointer to the lf_token_t sent as the payload in the trigger. + String tokenPointer = "(self->_lf__"+action.getName()+".tmplt.token)"; + CodeBuilder builder = new CodeBuilder(); - // Next, initialize the struct with the current values. - if (port.getContainer().getWidthSpec() != null) { - // Output is in a bank. - builder.pr( - String.join( - "\n", - "for (int i = 0; i < " + reactorWidth + "; i++) {", - " " - + reactorName - + "[i]." - + outputName - + " = self->_lf_" - + reactorName - + "[i]." - + outputName - + ";", - "}")); - if (ASTUtils.isMultiport(output)) { - builder.pr( - String.join( - "\n", - "for (int i = 0; i < " + reactorWidth + "; i++) {", - " " - + reactorName - + "[i]." - + outputWidth - + " = self->_lf_" - + reactorName - + "[i]." - + outputWidth - + ";", - "}")); - } - } else { - // Output is not in a bank. builder.pr( - reactorName - + "." - + outputName - + " = self->_lf_" - + reactorName - + "." - + outputName - + ";"); - if (ASTUtils.isMultiport(output)) { - builder.pr( - reactorName - + "." - + outputWidth - + " = self->_lf_" - + reactorName - + "." - + outputWidth - + ";"); + String.join("\n", + "// Expose the action struct as a local variable whose name matches the action name.", + structType+"* "+action.getName()+" = &self->_lf_"+action.getName()+";", + "// Set the fields of the action struct to match the current trigger.", + action.getName()+"->is_present = (bool)self->_lf__"+action.getName()+".status;", + action.getName()+"->has_value = ("+tokenPointer+" != NULL && "+tokenPointer+"->value != NULL);", + "_lf_replace_template_token((token_template_t*)"+action.getName()+", "+tokenPointer+");") + ); + // Set the value field only if there is a type. + if (!type.isUndefined()) { + // The value field will either be a copy (for primitive types) + // or a pointer (for types ending in *). + builder.pr("if ("+action.getName()+"->has_value) {"); + builder.indent(); + if (CUtil.isTokenType(type, types)) { + builder.pr(action.getName()+"->value = ("+types.getTargetType(type)+")"+tokenPointer+"->value;"); + } else { + builder.pr(action.getName()+"->value = *("+types.getTargetType(type)+"*)"+tokenPointer+"->value;"); + } + builder.unindent(); + builder.pr("}"); } - } + return builder.toString(); } - } - /** - * Generate action variables for a reaction. - * - * @param action The action. - */ - private static String generateActionVariablesInReaction(Action action, Reactor r, CTypes types) { - String structType = CGenerator.variableStructType(action, r, false); - // If the action has a type, create variables for accessing the value. - InferredType type = ASTUtils.getInferredType(action); - // Pointer to the lf_token_t sent as the payload in the trigger. - String tokenPointer = "(self->_lf__" + action.getName() + ".tmplt.token)"; - CodeBuilder builder = new CodeBuilder(); + /** Generate into the specified string builder the code to + * initialize local variables for the specified input port + * in a reaction function from the "self" struct. + * @param input The input statement from the AST. + * @param r The reactor. + */ + private static String generateInputVariablesInReaction( + Input input, + Reactor r, + CTypes types + ) { + String structType = CGenerator.variableStructType(input, r, false); + InferredType inputType = ASTUtils.getInferredType(input); + CodeBuilder builder = new CodeBuilder(); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); - builder.pr( - String.join( - "\n", - "// Expose the action struct as a local variable whose name matches the action name.", - structType + "* " + action.getName() + " = &self->_lf_" + action.getName() + ";", - "// Set the fields of the action struct to match the current trigger.", - action.getName() + "->is_present = (bool)self->_lf__" + action.getName() + ".status;", - action.getName() - + "->has_value = (" - + tokenPointer - + " != NULL && " - + tokenPointer - + "->value != NULL);", - "_lf_replace_template_token((token_template_t*)" - + action.getName() - + ", " - + tokenPointer - + ");")); - // Set the value field only if there is a type. - if (!type.isUndefined()) { - // The value field will either be a copy (for primitive types) - // or a pointer (for types ending in *). - builder.pr("if (" + action.getName() + "->has_value) {"); - builder.indent(); - if (CUtil.isTokenType(type, types)) { - builder.pr( - action.getName() - + "->value = (" - + types.getTargetType(type) - + ")" - + tokenPointer - + "->value;"); - } else { - builder.pr( - action.getName() - + "->value = *(" - + types.getTargetType(type) - + "*)" - + tokenPointer - + "->value;"); - } - builder.unindent(); - builder.pr("}"); + // Create the local variable whose name matches the input name. + // If the input has not been declared mutable, then this is a pointer + // to the upstream output. Otherwise, it is a copy of the upstream output, + // which nevertheless points to the same token and value (hence, as done + // below, we have to use lf_writable_copy()). There are 8 cases, + // depending on whether the input is mutable, whether it is a multiport, + // and whether it is a token type. + // Easy case first. + if (!input.isMutable() && !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, primitive type. + builder.pr(structType+"* "+inputName+" = self->_lf_"+inputName+";"); + } else if (input.isMutable()&& !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, primitive type. + builder.pr(String.join("\n", + "// Mutable input, so copy the input into a temporary variable.", + "// The input value on the struct is a copy.", + structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", + structType+"* "+inputName+" = &_lf_tmp_"+inputName+";" + )); + } else if (!input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, token type. + builder.pr(String.join("\n", + structType+"* "+inputName+" = self->_lf_"+inputName+";", + "if ("+inputName+"->is_present) {", + " "+inputName+"->length = "+inputName+"->token->length;", + " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", + "} else {", + " "+inputName+"->length = 0;", + "}" + )); + } else if (input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, token type. + builder.pr(String.join("\n", + "// Mutable input, so copy the input struct into a temporary variable.", + structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", + structType+"* "+inputName+" = &_lf_tmp_"+inputName+";", + inputName+"->value = NULL;", // Prevent payload from being freed. + "if ("+inputName+"->is_present) {", + " "+inputName+"->length = "+inputName+"->token->length;", + " "+inputName+"->token = lf_writable_copy((lf_port_base_t*)self->_lf_"+inputName+");", + " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", + "} else {", + " "+inputName+"->length = 0;", + "}" + )); + } else if (!input.isMutable()&& ASTUtils.isMultiport(input)) { + // Non-mutable, multiport, primitive or token type. + builder.pr(structType+"** "+inputName+" = self->_lf_"+inputName+";"); + } else if (CUtil.isTokenType(inputType, types)) { + // Mutable, multiport, token type + builder.pr(String.join("\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", + structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", + "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", + " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", + " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", + " // If necessary, copy the tokens.", + " if ("+inputName+"[i]->is_present) {", + " "+inputName+"[i]->length = "+inputName+"[i]->token->length;", + " token_template_t* _lf_input = (token_template_t*)self->_lf_"+inputName+"[i];", + " "+inputName+"[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", + " "+inputName+"[i]->value = ("+types.getTargetType(inputType)+")"+inputName+"[i]->token->value;", + " } else {", + " "+inputName+"[i]->length = 0;", + " }", + "}" + )); + } else { + // Mutable, multiport, primitive type + builder.pr(String.join("\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", + structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", + "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", + " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", + " // Copy the struct, which includes the value.", + " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", + "}" + )); + } + // Set the _width variable for all cases. This will be -1 + // for a variable-width multiport, which is not currently supported. + // It will be -2 if it is not multiport. + builder.pr("int "+inputWidth+" = self->_lf_"+inputWidth+"; SUPPRESS_UNUSED_WARNING("+inputWidth+");"); + return builder.toString(); } - return builder.toString(); - } - /** - * Generate into the specified string builder the code to initialize local variables for the - * specified input port in a reaction function from the "self" struct. - * - * @param input The input statement from the AST. - * @param r The reactor. - */ - private static String generateInputVariablesInReaction(Input input, Reactor r, CTypes types) { - String structType = CGenerator.variableStructType(input, r, false); - InferredType inputType = ASTUtils.getInferredType(input); - CodeBuilder builder = new CodeBuilder(); - String inputName = input.getName(); - String inputWidth = generateWidthVariable(inputName); + /** + * Generate into the specified string builder the code to + * initialize local variables for outputs in a reaction function + * from the "self" struct. + * @param effect The effect declared by the reaction. This must refer to an output. + * @param r The reactor containing the reaction. + */ + public static String generateOutputVariablesInReaction( + VarRef effect, + Reactor r, + ErrorReporter errorReporter, + boolean requiresTypes + ) { + Output output = (Output) effect.getVariable(); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + if (output.getType() == null && requiresTypes) { + errorReporter.reportError(output, "Output is required to have a type: " + outputName); + return ""; + } else { + // The container of the output may be a contained reactor or + // the reactor containing the reaction. + String outputStructType = (effect.getContainer() == null) ? + CGenerator.variableStructType(output, r, false) + : + CGenerator.variableStructType(output, ASTUtils.toDefinition(effect.getContainer().getReactorClass()), false); + if (!ASTUtils.isMultiport(output)) { + // Output port is not a multiport. + return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; + } else { + // Output port is a multiport. + // Set the _width variable. + return String.join("\n", + "int "+outputWidth+" = self->_lf_"+outputWidth+"; SUPPRESS_UNUSED_WARNING("+outputWidth+");", + outputStructType+"** "+outputName+" = self->_lf_"+outputName+"_pointers;" + ); - // Create the local variable whose name matches the input name. - // If the input has not been declared mutable, then this is a pointer - // to the upstream output. Otherwise, it is a copy of the upstream output, - // which nevertheless points to the same token and value (hence, as done - // below, we have to use lf_writable_copy()). There are 8 cases, - // depending on whether the input is mutable, whether it is a multiport, - // and whether it is a token type. - // Easy case first. - if (!input.isMutable() - && !CUtil.isTokenType(inputType, types) - && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, primitive type. - builder.pr(structType + "* " + inputName + " = self->_lf_" + inputName + ";"); - } else if (input.isMutable() - && !CUtil.isTokenType(inputType, types) - && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, primitive type. - builder.pr( - String.join( - "\n", - "// Mutable input, so copy the input into a temporary variable.", - "// The input value on the struct is a copy.", - structType + " _lf_tmp_" + inputName + " = *(self->_lf_" + inputName + ");", - structType + "* " + inputName + " = &_lf_tmp_" + inputName + ";")); - } else if (!input.isMutable() - && CUtil.isTokenType(inputType, types) - && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, token type. - builder.pr( - String.join( - "\n", - structType + "* " + inputName + " = self->_lf_" + inputName + ";", - "if (" + inputName + "->is_present) {", - " " + inputName + "->length = " + inputName + "->token->length;", - " " - + inputName - + "->value = (" - + types.getTargetType(inputType) - + ")" - + inputName - + "->token->value;", - "} else {", - " " + inputName + "->length = 0;", - "}")); - } else if (input.isMutable() - && CUtil.isTokenType(inputType, types) - && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, token type. - builder.pr( - String.join( - "\n", - "// Mutable input, so copy the input struct into a temporary variable.", - structType + " _lf_tmp_" + inputName + " = *(self->_lf_" + inputName + ");", - structType + "* " + inputName + " = &_lf_tmp_" + inputName + ";", - inputName + "->value = NULL;", // Prevent payload from being freed. - "if (" + inputName + "->is_present) {", - " " + inputName + "->length = " + inputName + "->token->length;", - " " - + inputName - + "->token = lf_writable_copy((lf_port_base_t*)self->_lf_" - + inputName - + ");", - " " - + inputName - + "->value = (" - + types.getTargetType(inputType) - + ")" - + inputName - + "->token->value;", - "} else {", - " " + inputName + "->length = 0;", - "}")); - } else if (!input.isMutable() && ASTUtils.isMultiport(input)) { - // Non-mutable, multiport, primitive or token type. - builder.pr(structType + "** " + inputName + " = self->_lf_" + inputName + ";"); - } else if (CUtil.isTokenType(inputType, types)) { - // Mutable, multiport, token type - builder.pr( - String.join( - "\n", - "// Mutable multiport input, so copy the input structs", - "// into an array of temporary variables on the stack.", - structType - + " _lf_tmp_" - + inputName - + "[" - + CUtil.multiportWidthExpression(input) - + "];", - structType + "* " + inputName + "[" + CUtil.multiportWidthExpression(input) + "];", - "for (int i = 0; i < " + CUtil.multiportWidthExpression(input) + "; i++) {", - " " + inputName + "[i] = &_lf_tmp_" + inputName + "[i];", - " _lf_tmp_" + inputName + "[i] = *(self->_lf_" + inputName + "[i]);", - " // If necessary, copy the tokens.", - " if (" + inputName + "[i]->is_present) {", - " " + inputName + "[i]->length = " + inputName + "[i]->token->length;", - " token_template_t* _lf_input = (token_template_t*)self->_lf_" - + inputName - + "[i];", - " " + inputName + "[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", - " " - + inputName - + "[i]->value = (" - + types.getTargetType(inputType) - + ")" - + inputName - + "[i]->token->value;", - " } else {", - " " + inputName + "[i]->length = 0;", - " }", - "}")); - } else { - // Mutable, multiport, primitive type - builder.pr( - String.join( - "\n", - "// Mutable multiport input, so copy the input structs", - "// into an array of temporary variables on the stack.", - structType - + " _lf_tmp_" - + inputName - + "[" - + CUtil.multiportWidthExpression(input) - + "];", - structType + "* " + inputName + "[" + CUtil.multiportWidthExpression(input) + "];", - "for (int i = 0; i < " + CUtil.multiportWidthExpression(input) + "; i++) {", - " " + inputName + "[i] = &_lf_tmp_" + inputName + "[i];", - " // Copy the struct, which includes the value.", - " _lf_tmp_" + inputName + "[i] = *(self->_lf_" + inputName + "[i]);", - "}")); + } + } } - // Set the _width variable for all cases. This will be -1 - // for a variable-width multiport, which is not currently supported. - // It will be -2 if it is not multiport. - builder.pr( - "int " - + inputWidth - + " = self->_lf_" - + inputWidth - + "; SUPPRESS_UNUSED_WARNING(" - + inputWidth - + ");"); - return builder.toString(); - } - /** - * Generate into the specified string builder the code to initialize local variables for outputs - * in a reaction function from the "self" struct. - * - * @param effect The effect declared by the reaction. This must refer to an output. - * @param r The reactor containing the reaction. - */ - public static String generateOutputVariablesInReaction( - VarRef effect, Reactor r, ErrorReporter errorReporter, boolean requiresTypes) { - Output output = (Output) effect.getVariable(); - String outputName = output.getName(); - String outputWidth = generateWidthVariable(outputName); - if (output.getType() == null && requiresTypes) { - errorReporter.reportError(output, "Output is required to have a type: " + outputName); - return ""; - } else { - // The container of the output may be a contained reactor or - // the reactor containing the reaction. - String outputStructType = - (effect.getContainer() == null) - ? CGenerator.variableStructType(output, r, false) - : CGenerator.variableStructType( - output, ASTUtils.toDefinition(effect.getContainer().getReactorClass()), false); - if (!ASTUtils.isMultiport(output)) { - // Output port is not a multiport. - return outputStructType + "* " + outputName + " = &self->_lf_" + outputName + ";"; - } else { - // Output port is a multiport. - // Set the _width variable. + /** + * Generate into the specified string builder the code to initialize local variables for watchdogs + * in a reaction function from the "self" struct. + * + * @param effect The effect declared by the reaction. This must refer to a watchdog. + * @param decl The reactor containing the reaction or the import statement. + */ + public static String generateWatchdogVariablesInReaction(VarRef effect, ReactorDecl decl) { + Watchdog watchdog = (Watchdog) effect.getVariable(); + String watchdogName = watchdog.getName(); return String.join( "\n", - "int " - + outputWidth - + " = self->_lf_" - + outputWidth - + "; SUPPRESS_UNUSED_WARNING(" - + outputWidth - + ");", - outputStructType + "** " + outputName + " = self->_lf_" + outputName + "_pointers;"); - } + List.of("watchdog_t* " + watchdogName + " = &(self->_lf_watchdog_" + watchdogName + ");") + ); } - } - /** - * Generate into the specified string builder the code to initialize local variables for watchdogs - * in a reaction function from the "self" struct. - * - * @param effect The effect declared by the reaction. This must refer to a watchdog. - * @param decl The reactor containing the reaction or the import statement. - */ - // Fine to have watchdog be in reactor self struct? - public static String generateWatchdogVariablesInReaction(VarRef effect, ReactorDecl decl) { - Watchdog watchdog = (Watchdog) effect.getVariable(); - String watchdogName = watchdog.getName(); + /** + * Generate the fields of the self struct and statements for the constructor + * to create and initialize a reaction_t struct for each reaction in the + * specified reactor and a trigger_t struct for each trigger (input, action, + * timer, or output of a contained reactor). + * @param body The place to put the code for the self struct. + * @param reactor The reactor. + * @param constructorCode The place to put the constructor code. + */ + public static void generateReactionAndTriggerStructs( + CodeBuilder body, + Reactor reactor, + CodeBuilder constructorCode, + CTypes types + ) { + var reactionCount = 0; + // Iterate over reactions and create initialize the reaction_t struct + // on the self struct. Also, collect a map from triggers to the reactions + // that are triggered by that trigger. Also, collect a set of sources + // that are read by reactions but do not trigger reactions. + // Finally, collect a set of triggers and sources that are outputs + // of contained reactors. + var triggerMap = new LinkedHashMap>(); + var sourceSet = new LinkedHashSet(); + var outputsOfContainedReactors = new LinkedHashMap(); + var startupReactions = new LinkedHashSet(); + var shutdownReactions = new LinkedHashSet(); + var resetReactions = new LinkedHashSet(); + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create the reaction_t struct. + body.pr(reaction, "reaction_t _lf__reaction_"+reactionCount+";"); - return String.join( - "\n", - List.of("watchdog_t* " + watchdogName + " = &(self->_lf_watchdog_" + watchdogName + ");")); - } + // Create the map of triggers to reactions. + for (TriggerRef trigger : reaction.getTriggers()) { + // trigger may not be a VarRef (it could be "startup" or "shutdown"). + if (trigger instanceof VarRef) { + var triggerAsVarRef = (VarRef) trigger; + var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); + if (reactionList == null) { + reactionList = new LinkedList<>(); + triggerMap.put(triggerAsVarRef.getVariable(), reactionList); + } + reactionList.add(reactionCount); + if (triggerAsVarRef.getContainer() != null) { + outputsOfContainedReactors.put(triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); + } + } else if (trigger instanceof BuiltinTriggerRef) { + switch(((BuiltinTriggerRef) trigger).getType()) { + case STARTUP: + startupReactions.add(reactionCount); + break; + case SHUTDOWN: + shutdownReactions.add(reactionCount); + break; + case RESET: + resetReactions.add(reactionCount); + break; + } + } + } + // Create the set of sources read but not triggering. + for (VarRef source : reaction.getSources()) { + sourceSet.add(source.getVariable()); + if (source.getContainer() != null) { + outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); + } + } - /** - * Generate the fields of the self struct and statements for the constructor to create and - * initialize a reaction_t struct for each reaction in the specified reactor and a trigger_t - * struct for each trigger (input, action, timer, or output of a contained reactor). - * - * @param body The place to put the code for the self struct. - * @param reactor The reactor. - * @param constructorCode The place to put the constructor code. - */ - public static void generateReactionAndTriggerStructs( - CodeBuilder body, Reactor reactor, CodeBuilder constructorCode, CTypes types) { - var reactionCount = 0; - // Iterate over reactions and create initialize the reaction_t struct - // on the self struct. Also, collect a map from triggers to the reactions - // that are triggered by that trigger. Also, collect a set of sources - // that are read by reactions but do not trigger reactions. - // Finally, collect a set of triggers and sources that are outputs - // of contained reactors. - var triggerMap = new LinkedHashMap>(); - var sourceSet = new LinkedHashSet(); - var outputsOfContainedReactors = new LinkedHashMap(); - var startupReactions = new LinkedHashSet(); - var shutdownReactions = new LinkedHashSet(); - var resetReactions = new LinkedHashSet(); - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - // Create the reaction_t struct. - body.pr(reaction, "reaction_t _lf__reaction_" + reactionCount + ";"); + var deadlineFunctionPointer = "NULL"; + if (reaction.getDeadline() != null) { + // The following has to match the name chosen in generateReactions + var deadlineFunctionName = generateDeadlineFunctionName(reactor, reactionCount); + deadlineFunctionPointer = "&" + deadlineFunctionName; + } - // Create the map of triggers to reactions. - for (TriggerRef trigger : reaction.getTriggers()) { - // trigger may not be a VarRef (it could be "startup" or "shutdown"). - if (trigger instanceof VarRef) { - var triggerAsVarRef = (VarRef) trigger; - var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); - if (reactionList == null) { - reactionList = new LinkedList<>(); - triggerMap.put(triggerAsVarRef.getVariable(), reactionList); - } - reactionList.add(reactionCount); - if (triggerAsVarRef.getContainer() != null) { - outputsOfContainedReactors.put( - triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); - } - } else if (trigger instanceof BuiltinTriggerRef) { - switch (((BuiltinTriggerRef) trigger).getType()) { - case STARTUP: - startupReactions.add(reactionCount); - break; - case SHUTDOWN: - shutdownReactions.add(reactionCount); - break; - case RESET: - resetReactions.add(reactionCount); - break; - } + // Assign the STP handler + var STPFunctionPointer = "NULL"; + if (reaction.getStp() != null) { + // The following has to match the name chosen in generateReactions + var STPFunctionName = generateStpFunctionName(reactor, reactionCount); + STPFunctionPointer = "&" + STPFunctionName; + } + + // Set the defaults of the reaction_t struct in the constructor. + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__reaction_"+reactionCount+".index = 0; + // self->_lf__reaction_"+reactionCount+".chain_id = 0; + // self->_lf__reaction_"+reactionCount+".pos = 0; + // self->_lf__reaction_"+reactionCount+".status = inactive; + // self->_lf__reaction_"+reactionCount+".deadline = 0LL; + // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; + constructorCode.pr(reaction, String.join("\n", + "self->_lf__reaction_"+reactionCount+".number = "+reactionCount+";", + "self->_lf__reaction_"+reactionCount+".function = "+CReactionGenerator.generateReactionFunctionName(reactor, reactionCount)+";", + "self->_lf__reaction_"+reactionCount+".self = self;", + "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", + "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", + "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", + (reaction.eContainer() instanceof Mode ? + "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+reactor.getModes().indexOf((Mode) reaction.eContainer())+"];" : + "self->_lf__reaction_"+reactionCount+".mode = NULL;") + )); + // Increment the reactionCount even if the reaction is not in the federate + // so that reaction indices are consistent across federates. + reactionCount++; } - } - // Create the set of sources read but not triggering. - for (VarRef source : reaction.getSources()) { - sourceSet.add(source.getVariable()); - if (source.getContainer() != null) { - outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); + + // Next, create and initialize the trigger_t objects. + // Start with the timers. + for (Timer timer : ASTUtils.allTimers(reactor)) { + createTriggerT(body, timer, triggerMap, constructorCode, types); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + constructorCode.pr("self->_lf__"+timer.getName()+".is_timer = true;"); + constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__"+timer.getName()+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); } - } - var deadlineFunctionPointer = "NULL"; - if (reaction.getDeadline() != null) { - // The following has to match the name chosen in generateReactions - var deadlineFunctionName = generateDeadlineFunctionName(reactor, reactionCount); - deadlineFunctionPointer = "&" + deadlineFunctionName; - } + // Handle builtin triggers. + if (startupReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); + } + // Handle shutdown triggers. + if (shutdownReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); + } + if (resetReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); + } - // Assign the STP handler - var STPFunctionPointer = "NULL"; - if (reaction.getStp() != null) { - // The following has to match the name chosen in generateReactions - var STPFunctionName = generateStpFunctionName(reactor, reactionCount); - STPFunctionPointer = "&" + STPFunctionName; - } + // Next handle actions. + for (Action action : ASTUtils.allActions(reactor)) { + createTriggerT(body, action, triggerMap, constructorCode, types); + var isPhysical = "true"; + if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { + isPhysical = "false"; + } + var elementSize = "0"; + // If the action type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) + : null; + if (rootType != null && !rootType.equals("void")) { + elementSize = "sizeof(" + rootType + ")"; + } - // Set the defaults of the reaction_t struct in the constructor. - // Since the self struct is allocated using calloc, there is no need to set: - // self->_lf__reaction_"+reactionCount+".index = 0; - // self->_lf__reaction_"+reactionCount+".chain_id = 0; - // self->_lf__reaction_"+reactionCount+".pos = 0; - // self->_lf__reaction_"+reactionCount+".status = inactive; - // self->_lf__reaction_"+reactionCount+".deadline = 0LL; - // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; - constructorCode.pr( - reaction, - String.join( - "\n", - "self->_lf__reaction_" + reactionCount + ".number = " + reactionCount + ";", - "self->_lf__reaction_" - + reactionCount - + ".function = " - + CReactionGenerator.generateReactionFunctionName(reactor, reactionCount) - + ";", - "self->_lf__reaction_" + reactionCount + ".self = self;", - "self->_lf__reaction_" - + reactionCount - + ".deadline_violation_handler = " - + deadlineFunctionPointer - + ";", - "self->_lf__reaction_" + reactionCount + ".STP_handler = " + STPFunctionPointer + ";", - "self->_lf__reaction_" + reactionCount + ".name = " + addDoubleQuotes("?") + ";", - (reaction.eContainer() instanceof Mode - ? "self->_lf__reaction_" - + reactionCount - + ".mode = &self->_lf__modes[" - + reactor.getModes().indexOf((Mode) reaction.eContainer()) - + "];" - : "self->_lf__reaction_" + reactionCount + ".mode = NULL;"))); - // Increment the reactionCount even if the reaction is not in the federate - // so that reaction indices are consistent across federates. - reactionCount++; - } + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__"+action.getName()+".is_timer = false; + constructorCode.pr(String.join("\n", + "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", + (!(action.getPolicy() == null || action.getPolicy().isEmpty()) ? + "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" : + ""), + // Need to set the element_size in the trigger_t and the action struct. + "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize + + ";", + "self->_lf_" + action.getName() + ".type.element_size = " + elementSize + ";" + )); + } - // Next, create and initialize the trigger_t objects. - // Start with the timers. - for (Timer timer : ASTUtils.allTimers(reactor)) { - createTriggerT(body, timer, triggerMap, constructorCode, types); - // Since the self struct is allocated using calloc, there is no need to set falsy fields. - constructorCode.pr("self->_lf__" + timer.getName() + ".is_timer = true;"); - constructorCode.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__" - + timer.getName() - + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - } + // Next handle inputs. + for (Input input : ASTUtils.allInputs(reactor)) { + createTriggerT(body, input, triggerMap, constructorCode, types); + } - // Handle builtin triggers. - if (startupReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); - } - // Handle shutdown triggers. - if (shutdownReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); - } - if (resetReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); + // Next handle watchdogs. + for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { + createTriggerT(body, watchdog, triggerMap, constructorCode, types); + } } - // Next handle actions. - for (Action action : ASTUtils.allActions(reactor)) { - createTriggerT(body, action, triggerMap, constructorCode, types); - var isPhysical = "true"; - if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { - isPhysical = "false"; - } - var elementSize = "0"; - // If the action type is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) : null; - if (rootType != null && !rootType.equals("void")) { - elementSize = "sizeof(" + rootType + ")"; - } + /** + * Define the trigger_t object on the self struct, an array of + * reaction_t pointers pointing to reactions triggered by this variable, + * and initialize the pointers in the array in the constructor. + * @param body The place to write the self struct entries. + * @param variable The trigger variable (Timer, Action, Watchdog, or Input). + * @param triggerMap A map from Variables to a list of the reaction indices triggered by the + * variable. + * @param constructorCode The place to write the constructor code. + */ + private static void createTriggerT( + CodeBuilder body, + Variable variable, + LinkedHashMap> triggerMap, + CodeBuilder constructorCode, + CTypes types + ) { + var varName = variable.getName(); + // variable is a port, a timer, or an action. + body.pr(variable, "trigger_t _lf__"+varName+";"); + constructorCode.pr(variable, "self->_lf__"+varName+".last = NULL;"); + constructorCode.pr(variable, CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__"+varName+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - // Since the self struct is allocated using calloc, there is no need to set: - // self->_lf__"+action.getName()+".is_timer = false; - constructorCode.pr( - String.join( - "\n", - "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", - (!(action.getPolicy() == null || action.getPolicy().isEmpty()) - ? "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" - : ""), - // Need to set the element_size in the trigger_t and the action struct. - "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize + ";", - "self->_lf_" + action.getName() + ".type.element_size = " + elementSize + ";")); - } + // Generate the reactions triggered table. + var reactionsTriggered = triggerMap.get(variable); + if (reactionsTriggered != null) { + body.pr(variable, "reaction_t* _lf__"+varName+"_reactions["+reactionsTriggered.size()+"];"); + var count = 0; + for (Integer reactionTriggered : reactionsTriggered) { + constructorCode.prSourceLineNumber(variable); + constructorCode.pr(variable, "self->_lf__"+varName+"_reactions["+count+"] = &self->_lf__reaction_"+reactionTriggered+";"); + count++; + } + // Set up the trigger_t struct's pointer to the reactions. + constructorCode.pr(variable, String.join("\n", + "self->_lf__"+varName+".reactions = &self->_lf__"+varName+"_reactions[0];", + "self->_lf__"+varName+".number_of_reactions = "+count+";" + )); - // Next handle inputs. - for (Input input : ASTUtils.allInputs(reactor)) { - createTriggerT(body, input, triggerMap, constructorCode, types); - } + // If federated, set the physical_time_of_arrival + constructorCode.pr(variable, CExtensionUtils.surroundWithIfFederated( + "self->_lf__"+varName+".physical_time_of_arrival = NEVER;")); + } + if (variable instanceof Input) { + var rootType = CUtil.rootType(types.getTargetType((Input) variable)); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + // If the input type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var size = (rootType.equals("void")) ? "0" : "sizeof("+rootType+")"; - // Next handle watchdogs. - for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - createTriggerT(body, watchdog, triggerMap, constructorCode, types); + constructorCode.pr("self->_lf__"+varName+".tmplt.type.element_size = "+size+";"); + body.pr( + CExtensionUtils.surroundWithIfFederated( + CExtensionUtils.createPortStatusFieldForInput((Input) variable) + ) + ); + } } - } - - /** - * Define the trigger_t object on the self struct, an array of reaction_t pointers pointing to - * reactions triggered by this variable, and initialize the pointers in the array in the - * constructor. - * - * @param body The place to write the self struct entries. - * @param variable The trigger variable (Timer, Action, Watchdog, or Input). - * @param triggerMap A map from Variables to a list of the reaction indices triggered by the - * variable. - * @param constructorCode The place to write the constructor code. - */ - private static void createTriggerT( - CodeBuilder body, - Variable variable, - LinkedHashMap> triggerMap, - CodeBuilder constructorCode, - CTypes types) { - var varName = variable.getName(); - // variable is a port, a timer, or an action. - body.pr(variable, "trigger_t _lf__" + varName + ";"); - constructorCode.pr(variable, "self->_lf__" + varName + ".last = NULL;"); - constructorCode.pr( - variable, - CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__" - + varName - + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - - // Generate the reactions triggered table. - var reactionsTriggered = triggerMap.get(variable); - if (reactionsTriggered != null) { - body.pr( - variable, - "reaction_t* _lf__" + varName + "_reactions[" + reactionsTriggered.size() + "];"); - var count = 0; - for (Integer reactionTriggered : reactionsTriggered) { - constructorCode.prSourceLineNumber(variable); - constructorCode.pr( - variable, - "self->_lf__" - + varName - + "_reactions[" - + count - + "] = &self->_lf__reaction_" - + reactionTriggered - + ";"); - count++; - } - // Set up the trigger_t struct's pointer to the reactions. - constructorCode.pr( - variable, - String.join( - "\n", - "self->_lf__" + varName + ".reactions = &self->_lf__" + varName + "_reactions[0];", - "self->_lf__" + varName + ".number_of_reactions = " + count + ";")); - // If federated, set the physical_time_of_arrival - constructorCode.pr( - variable, - CExtensionUtils.surroundWithIfFederated( - "self->_lf__" + varName + ".physical_time_of_arrival = NEVER;")); + public static void generateBuiltinTriggeredReactionsArray( + Set reactions, + String name, + CodeBuilder body, + CodeBuilder constructorCode + ) { + body.pr(String.join("\n", + "trigger_t _lf__"+name+";", + "reaction_t* _lf__"+name+"_reactions["+reactions.size()+"];" + )); + constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__"+name+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + var i = 0; + for (Integer reactionIndex : reactions) { + constructorCode.pr("self->_lf__"+name+"_reactions["+i+++"] = &self->_lf__reaction_"+reactionIndex+";"); + } + constructorCode.pr(String.join("\n", + "self->_lf__"+name+".last = NULL;", + "self->_lf__"+name+".reactions = &self->_lf__"+name+"_reactions[0];", + "self->_lf__"+name+".number_of_reactions = "+reactions.size()+";", + "self->_lf__"+name+".is_timer = false;" + )); } - if (variable instanceof Input) { - var rootType = CUtil.rootType(types.getTargetType((Input) variable)); - // Since the self struct is allocated using calloc, there is no need to set falsy fields. - // If the input type is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var size = (rootType.equals("void")) ? "0" : "sizeof(" + rootType + ")"; - constructorCode.pr("self->_lf__" + varName + ".tmplt.type.element_size = " + size + ";"); - body.pr( - CExtensionUtils.surroundWithIfFederated( - CExtensionUtils.createPortStatusFieldForInput((Input) variable))); + public static String generateBuiltinTriggersTable(int reactionCount, String name) { + return String.join("\n", List.of( + "// Array of pointers to "+name+" triggers.", + (reactionCount > 0 ? + "reaction_t* _lf_"+name+"_reactions["+reactionCount+"]" : + "reaction_t** _lf_"+name+"_reactions = NULL") + ";", + "int _lf_"+name+"_reactions_size = "+reactionCount+";" + )); } - } - public static void generateBuiltinTriggeredReactionsArray( - Set reactions, String name, CodeBuilder body, CodeBuilder constructorCode) { - body.pr( - String.join( - "\n", - "trigger_t _lf__" + name + ";", - "reaction_t* _lf__" + name + "_reactions[" + reactions.size() + "];")); - constructorCode.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__" + name + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - var i = 0; - for (Integer reactionIndex : reactions) { - constructorCode.pr( - "self->_lf__" - + name - + "_reactions[" - + i++ - + "] = &self->_lf__reaction_" - + reactionIndex - + ";"); + /** + * Generate the _lf_trigger_startup_reactions function. + */ + public static String generateLfTriggerStartupReactions(int startupReactionCount, boolean hasModalReactors) { + var s = new StringBuilder(); + s.append("void _lf_trigger_startup_reactions() {"); + if (startupReactionCount > 0) { + s.append("\n"); + if (hasModalReactors) { + s.append(String.join("\n", + " for (int i = 0; i < _lf_startup_reactions_size; i++) {", + " if (_lf_startup_reactions[i] != NULL) {", + " if (_lf_startup_reactions[i]->mode != NULL) {", + " // Skip reactions in modes", + " continue;", + " }", + " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", + " }", + " }", + " _lf_handle_mode_startup_reset_reactions(", + " _lf_startup_reactions, _lf_startup_reactions_size,", + " NULL, 0,", + " _lf_modal_reactor_states, _lf_modal_reactor_states_size);" + )); + } else { + s.append(String.join("\n", + " for (int i = 0; i < _lf_startup_reactions_size; i++) {", + " if (_lf_startup_reactions[i] != NULL) {", + " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", + " }", + " }" + )); + } + s.append("\n"); + } + s.append("}\n"); + return s.toString(); } - constructorCode.pr( - String.join( - "\n", - "self->_lf__" + name + ".last = NULL;", - "self->_lf__" + name + ".reactions = &self->_lf__" + name + "_reactions[0];", - "self->_lf__" + name + ".number_of_reactions = " + reactions.size() + ";", - "self->_lf__" + name + ".is_timer = false;")); - } - - public static String generateBuiltinTriggersTable(int reactionCount, String name) { - return String.join( - "\n", - List.of( - "// Array of pointers to " + name + " triggers.", - (reactionCount > 0 - ? "reaction_t* _lf_" + name + "_reactions[" + reactionCount + "]" - : "reaction_t** _lf_" + name + "_reactions = NULL") - + ";", - "int _lf_" + name + "_reactions_size = " + reactionCount + ";")); - } - /** Generate the _lf_trigger_startup_reactions function. */ - public static String generateLfTriggerStartupReactions( - int startupReactionCount, boolean hasModalReactors) { - var s = new StringBuilder(); - s.append("void _lf_trigger_startup_reactions() {"); - if (startupReactionCount > 0) { - s.append("\n"); - if (hasModalReactors) { - s.append( - String.join( - "\n", - " for (int i = 0; i < _lf_startup_reactions_size; i++) {", - " if (_lf_startup_reactions[i] != NULL) {", - " if (_lf_startup_reactions[i]->mode != NULL) {", - " // Skip reactions in modes", - " continue;", - " }", - " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", - " }", - " }", - " _lf_handle_mode_startup_reset_reactions(", - " _lf_startup_reactions, _lf_startup_reactions_size,", - " NULL, 0,", - " _lf_modal_reactor_states, _lf_modal_reactor_states_size);")); - } else { - s.append( - String.join( - "\n", - " for (int i = 0; i < _lf_startup_reactions_size; i++) {", - " if (_lf_startup_reactions[i] != NULL) {", - " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", - " }", - " }")); - } - s.append("\n"); + /** + * Generate the _lf_trigger_shutdown_reactions function. + */ + public static String generateLfTriggerShutdownReactions(int shutdownReactionCount, boolean hasModalReactors) { + var s = new StringBuilder(); + s.append("bool _lf_trigger_shutdown_reactions() {\n"); + if (shutdownReactionCount > 0) { + if (hasModalReactors) { + s.append(String.join("\n", + " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", + " if (_lf_shutdown_reactions[i] != NULL) {", + " if (_lf_shutdown_reactions[i]->mode != NULL) {", + " // Skip reactions in modes", + " continue;", + " }", + " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", + " }", + " }", + " _lf_handle_mode_shutdown_reactions(_lf_shutdown_reactions, _lf_shutdown_reactions_size);", + " return true;" + )); + } else { + s.append(String.join("\n", + " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", + " if (_lf_shutdown_reactions[i] != NULL) {", + " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", + " }", + " }", + " return true;" + )); + } + s.append("\n"); + } else { + s.append(" return false;\n"); + } + s.append("}\n"); + return s.toString(); } - s.append("}\n"); - return s.toString(); - } - /** Generate the _lf_trigger_shutdown_reactions function. */ - public static String generateLfTriggerShutdownReactions( - int shutdownReactionCount, boolean hasModalReactors) { - var s = new StringBuilder(); - s.append("bool _lf_trigger_shutdown_reactions() {\n"); - if (shutdownReactionCount > 0) { - if (hasModalReactors) { - s.append( - String.join( - "\n", - " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", - " if (_lf_shutdown_reactions[i] != NULL) {", - " if (_lf_shutdown_reactions[i]->mode != NULL) {", - " // Skip reactions in modes", - " continue;", - " }", - " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", - " }", - " }", - " _lf_handle_mode_shutdown_reactions(_lf_shutdown_reactions," - + " _lf_shutdown_reactions_size);", - " return true;")); - } else { - s.append( - String.join( - "\n", - " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", - " if (_lf_shutdown_reactions[i] != NULL) {", - " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", - " }", - " }", - " return true;")); - } - s.append("\n"); - } else { - s.append(" return false;\n"); + /** + * Generate the _lf_handle_mode_triggered_reactions function. + */ + public static String generateLfModeTriggeredReactions( + int startupReactionCount, + int resetReactionCount, + boolean hasModalReactors + ) { + if (!hasModalReactors) { + return ""; + } + var s = new StringBuilder(); + s.append("void _lf_handle_mode_triggered_reactions() {\n"); + s.append(" _lf_handle_mode_startup_reset_reactions(\n"); + if (startupReactionCount > 0) { + s.append(" _lf_startup_reactions, _lf_startup_reactions_size,\n"); + } else { + s.append(" NULL, 0,\n"); + } + if (resetReactionCount > 0) { + s.append(" _lf_reset_reactions, _lf_reset_reactions_size,\n"); + } else { + s.append(" NULL, 0,\n"); + } + s.append(" _lf_modal_reactor_states, _lf_modal_reactor_states_size);\n"); + s.append("}\n"); + return s.toString(); } - s.append("}\n"); - return s.toString(); - } - /** Generate the _lf_handle_mode_triggered_reactions function. */ - public static String generateLfModeTriggeredReactions( - int startupReactionCount, int resetReactionCount, boolean hasModalReactors) { - if (!hasModalReactors) { - return ""; - } - var s = new StringBuilder(); - s.append("void _lf_handle_mode_triggered_reactions() {\n"); - s.append(" _lf_handle_mode_startup_reset_reactions(\n"); - if (startupReactionCount > 0) { - s.append(" _lf_startup_reactions, _lf_startup_reactions_size,\n"); - } else { - s.append(" NULL, 0,\n"); - } - if (resetReactionCount > 0) { - s.append(" _lf_reset_reactions, _lf_reset_reactions_size,\n"); - } else { - s.append(" NULL, 0,\n"); - } - s.append(" _lf_modal_reactor_states, _lf_modal_reactor_states_size);\n"); - s.append("}\n"); - return s.toString(); - } + /** Generate a reaction function definition for a reactor. + * This function will have a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + public static String generateReaction( + Reaction reaction, + Reactor r, + int reactionIndex, + Instantiation mainDef, + ErrorReporter errorReporter, + CTypes types, + TargetConfig targetConfig, + boolean requiresType + ) { + var code = new CodeBuilder(); + var body = ASTUtils.toText(getCode(types, reaction, r)); + String init = generateInitializationForReaction( + body, reaction, ASTUtils.toDefinition(r), reactionIndex, + types, errorReporter, mainDef, + requiresType); - /** - * Generate a reaction function definition for a reactor. This function will have a single - * argument that is a void* pointing to a struct that contains parameters, state variables, inputs - * (triggering or not), actions (triggering or produced), and outputs. - * - * @param reaction The reaction. - * @param r The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - public static String generateReaction( - Reaction reaction, - Reactor r, - int reactionIndex, - Instantiation mainDef, - ErrorReporter errorReporter, - CTypes types, - TargetConfig targetConfig, - boolean requiresType) { - var code = new CodeBuilder(); - var body = ASTUtils.toText(getCode(types, reaction, r)); - String init = - generateInitializationForReaction( - body, - reaction, - ASTUtils.toDefinition(r), - reactionIndex, - types, - errorReporter, - mainDef, - requiresType); + code.pr( + "#include " + StringUtil.addDoubleQuotes( + CCoreFilesUtils.getCTargetSetHeader())); - code.pr("#include " + StringUtil.addDoubleQuotes(CCoreFilesUtils.getCTargetSetHeader())); + CMethodGenerator.generateMacrosForMethods(ASTUtils.toDefinition(r), code); + code.pr(generateFunction( + generateReactionFunctionHeader(r, reactionIndex), + init, getCode(types, reaction, r) + )); + // Now generate code for the late function, if there is one + // Note that this function can only be defined on reactions + // in federates that have inputs from a logical connection. + if (reaction.getStp() != null) { + code.pr(generateFunction( + generateStpFunctionHeader(r, reactionIndex), + init, reaction.getStp().getCode())); + } - CMethodGenerator.generateMacrosForMethods(ASTUtils.toDefinition(r), code); - code.pr( - generateFunction( - generateReactionFunctionHeader(r, reactionIndex), init, getCode(types, reaction, r))); - // Now generate code for the late function, if there is one - // Note that this function can only be defined on reactions - // in federates that have inputs from a logical connection. - if (reaction.getStp() != null) { - code.pr( - generateFunction( - generateStpFunctionHeader(r, reactionIndex), init, reaction.getStp().getCode())); + // Now generate code for the deadline violation function, if there is one. + if (reaction.getDeadline() != null) { + code.pr(generateFunction( + generateDeadlineFunctionHeader(r, reactionIndex), + init, reaction.getDeadline().getCode())); + } + CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(r), code); + code.pr( + "#include " + StringUtil.addDoubleQuotes( + CCoreFilesUtils.getCTargetSetUndefHeader())); + return code.toString(); } - // Now generate code for the deadline violation function, if there is one. - if (reaction.getDeadline() != null) { - code.pr( - generateFunction( - generateDeadlineFunctionHeader(r, reactionIndex), - init, - reaction.getDeadline().getCode())); + private static Code getCode(CTypes types, Reaction r, ReactorDecl container) { + if (r.getCode() != null) return r.getCode(); + Code ret = LfFactory.eINSTANCE.createCode(); + var reactor = ASTUtils.toDefinition(container); + ret.setBody( + CReactorHeaderFileGenerator.nonInlineInitialization(r, reactor) + "\n" + + r.getName() + "( " + CReactorHeaderFileGenerator.reactionArguments(r, reactor) + " );"); + return ret; } - CMethodGenerator.generateMacroUndefsForMethods(ASTUtils.toDefinition(r), code); - code.pr("#include " + StringUtil.addDoubleQuotes(CCoreFilesUtils.getCTargetSetUndefHeader())); - return code.toString(); - } - private static Code getCode(CTypes types, Reaction r, ReactorDecl container) { - if (r.getCode() != null) return r.getCode(); - Code ret = LfFactory.eINSTANCE.createCode(); - var reactor = ASTUtils.toDefinition(container); - ret.setBody( - CReactorHeaderFileGenerator.nonInlineInitialization(r, reactor) - + "\n" - + r.getName() - + "( " - + CReactorHeaderFileGenerator.reactionArguments(r, reactor) - + " );"); - return ret; - } - - public static String generateFunction(String header, String init, Code code) { - var function = new CodeBuilder(); - function.pr(header + " {"); - function.indent(); - function.pr(init); - function.prSourceLineNumber(code); - function.pr(ASTUtils.toText(code)); - function.unindent(); - function.pr("}"); - return function.toString(); - } + public static String generateFunction(String header, String init, Code code) { + var function = new CodeBuilder(); + function.pr(header + " {"); + function.indent(); + function.pr(init); + function.prSourceLineNumber(code); + function.pr(ASTUtils.toText(code)); + function.unindent(); + function.pr("}"); + return function.toString(); + } - /** - * Returns the name of the deadline function for reaction. - * - * @param r The reactor with the deadline - * @param reactionIndex The number assigned to this reaction deadline - */ - public static String generateDeadlineFunctionName(Reactor r, int reactionIndex) { - return CUtil.getName(r).toLowerCase() + "_deadline_function" + reactionIndex; - } + /** + * Returns the name of the deadline function for reaction. + * @param r The reactor with the deadline + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateDeadlineFunctionName(Reactor r, int reactionIndex) { + return CUtil.getName(r).toLowerCase() + "_deadline_function" + reactionIndex; + } - /** - * Return the function name for specified reaction of the specified reactor. - * - * @param reactor The reactor - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateReactionFunctionName(Reactor reactor, int reactionIndex) { - return CUtil.getName(reactor).toLowerCase() + "reaction_function_" + reactionIndex; - } + /** + * Return the function name for specified reaction of the + * specified reactor. + * @param reactor The reactor + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionName(Reactor reactor, int reactionIndex) { + return CUtil.getName(reactor).toLowerCase() + "reaction_function_" + reactionIndex; + } - /** - * Returns the name of the stp function for reaction. - * - * @param r The reactor with the stp - * @param reactionIndex The number assigned to this reaction deadline - */ - public static String generateStpFunctionName(Reactor r, int reactionIndex) { - return CUtil.getName(r).toLowerCase() + "_STP_function" + reactionIndex; - } + /** + * Returns the name of the stp function for reaction. + * @param r The reactor with the stp + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateStpFunctionName(Reactor r, int reactionIndex) { + return CUtil.getName(r).toLowerCase() + "_STP_function" + reactionIndex; + } - /** - * Return the top level C function header for the deadline function numbered "reactionIndex" in - * "r" - * - * @param r The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the deadline function. - */ - public static String generateDeadlineFunctionHeader(Reactor r, int reactionIndex) { - String functionName = generateDeadlineFunctionName(r, reactionIndex); - return generateFunctionHeader(functionName); - } + /** Return the top level C function header for the deadline function numbered "reactionIndex" in "r" + * @param r The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the deadline function. + */ + public static String generateDeadlineFunctionHeader(Reactor r, + int reactionIndex) { + String functionName = generateDeadlineFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } - /** - * Return the top level C function header for the reaction numbered "reactionIndex" in "r" - * - * @param r The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateReactionFunctionHeader(Reactor r, int reactionIndex) { - String functionName = generateReactionFunctionName(r, reactionIndex); - return generateFunctionHeader(functionName); - } + /** Return the top level C function header for the reaction numbered "reactionIndex" in "r" + * @param r The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionHeader(Reactor r, + int reactionIndex) { + String functionName = generateReactionFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } - public static String generateStpFunctionHeader(Reactor r, int reactionIndex) { - String functionName = generateStpFunctionName(r, reactionIndex); - return generateFunctionHeader(functionName); - } + public static String generateStpFunctionHeader(Reactor r, + int reactionIndex) { + String functionName = generateStpFunctionName(r, reactionIndex); + return generateFunctionHeader(functionName); + } - /** - * Return the start of a function declaration for a function that takes - * a `void*` argument and returns void. - * @param functionName - * @return - */ - public static String generateFunctionHeader(String functionName) { - return "void " + functionName + "(void* instance_args)"; - } + /** + * Return the start of a function declaration for a function that takes + * a `void*` argument and returns void. + * + * @param functionName + * @return + */ + public static String generateFunctionHeader(String functionName) { + return "void " + functionName + "(void* instance_args)"; + } } From e6a0ed03a3a8087b377bb41bf02f641bbf8a6daa Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 10:09:39 +0200 Subject: [PATCH 226/709] Revert to master version (reverse formatting) --- .../generator/python/PythonGenerator.java | 1081 +++++++++-------- 1 file changed, 558 insertions(+), 523 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index f1f0e9b59d..020954be80 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -34,14 +34,18 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; + +import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; + import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.Target; import org.lflang.TargetProperty; import org.lflang.generator.CodeBuilder; import org.lflang.generator.CodeMap; + import org.lflang.generator.GeneratorResult; import org.lflang.generator.IntegratedBuilder; import org.lflang.generator.LFGeneratorContext; @@ -52,6 +56,7 @@ import org.lflang.generator.c.CGenerator; import org.lflang.generator.c.CUtil; import org.lflang.lf.Action; +import org.lflang.lf.Code; import org.lflang.lf.Input; import org.lflang.lf.Model; import org.lflang.lf.Output; @@ -63,505 +68,525 @@ import org.lflang.util.LFCommand; import org.lflang.util.StringUtil; + /** - * Generator for Python target. This class generates Python code defining each reactor class given - * in the input .lf file and imported .lf files. + * Generator for Python target. This class generates Python code defining each + * reactor + * class given in the input .lf file and imported .lf files. * - *

Each class will contain all the reaction functions defined by the user in order, with the - * necessary ports/actions given as parameters. Moreover, each class will contain all state - * variables in native Python format. + * Each class will contain all the reaction functions defined by the user in + * order, with the necessary ports/actions given as parameters. + * Moreover, each class will contain all state variables in native Python + * format. * - *

A backend is also generated using the CGenerator that interacts with the C code library (see - * CGenerator.xtend). The backend is responsible for passing arguments to the Python reactor + * A backend is also generated using the CGenerator that interacts with the C + * code library (see CGenerator.xtend). + * The backend is responsible for passing arguments to the Python reactor * functions. * * @author Soroush Bateni */ public class PythonGenerator extends CGenerator { - // Used to add statements that come before reactor classes and user code - private final CodeBuilder pythonPreamble = new CodeBuilder(); - - // Used to add module requirements to setup.py (delimited with ,) - private final List pythonRequiredModules = new ArrayList<>(); - - private final PythonTypes types; - - public PythonGenerator(LFGeneratorContext context) { - this( - context, - new PythonTypes(), - new CCmakeGenerator( - context.getFileConfig(), - List.of( - "lib/python_action.c", - "lib/python_port.c", - "lib/python_tag.c", - "lib/python_time.c", - "lib/pythontarget.c"), - PythonGenerator::setUpMainTarget, - "install(TARGETS)" // No-op - )); - } - - private PythonGenerator( - LFGeneratorContext context, PythonTypes types, CCmakeGenerator cmakeGenerator) { - super(context, false, types, cmakeGenerator, new PythonDelayBodyGenerator(types)); - this.targetConfig.compiler = "gcc"; - this.targetConfig.compilerFlags = new ArrayList<>(); - this.targetConfig.linkerFlags = ""; - this.types = types; - } - - /** - * Generic struct for ports with primitive types and statically allocated arrays in Lingua Franca. - * This template is defined as typedef struct { bool is_present; lf_sparse_io_record_t* - * sparse_record; // NULL if there is no sparse record. int destination_channel; // -1 if there is - * no destination. PyObject* value; int num_destinations; lf_token_t* token; int length; void - * (*destructor) (void* value); void* (*copy_constructor) (void* value); - * FEDERATED_GENERIC_EXTENSION } generic_port_instance_struct; - * - *

See reactor-c-py/lib/pythontarget.h for details. - */ - String genericPortType = "generic_port_instance_struct"; - - /** - * Generic struct for actions. This template is defined as typedef struct { trigger_t* trigger; - * PyObject* value; bool is_present; bool has_value; lf_token_t* token; - * FEDERATED_CAPSULE_EXTENSION } generic_action_instance_struct; - * - *

See reactor-c-py/lib/pythontarget.h for details. - */ - String genericActionType = "generic_action_instance_struct"; - - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.Python; - } - - private final Set protoNames = new HashSet<>(); - - // ////////////////////////////////////////// - // // Public methods - @Override - public TargetTypes getTargetTypes() { - return types; - } - - // ////////////////////////////////////////// - // // Protected methods - - /** Generate all Python classes if they have a reaction */ - public String generatePythonReactorClasses() { - CodeBuilder pythonClasses = new CodeBuilder(); - CodeBuilder pythonClassesInstantiation = new CodeBuilder(); - - // Generate reactor classes in Python - pythonClasses.pr(PythonReactorGenerator.generatePythonClass(main, main, types)); - - // Create empty lists to hold reactor instances - pythonClassesInstantiation.pr(PythonReactorGenerator.generateListsToHoldClassInstances(main)); - - // Instantiate generated classes - pythonClassesInstantiation.pr( - PythonReactorGenerator.generatePythonClassInstantiations(main, main)); - - return String.join( - "\n", - pythonClasses.toString(), - "", - "# Instantiate classes", - pythonClassesInstantiation.toString()); - } - - /** - * Generate the Python code constructed from reactor classes and user-written classes. - * - * @return the code body - */ - public String generatePythonCode(String pyModuleName) { - return String.join( - "\n", - "import os", - "import sys", - "sys.path.append(os.path.dirname(__file__))", - "# List imported names, but do not use pylint's --extension-pkg-allow-list option", - "# so that these names will be assumed present without having to compile and install.", - "# pylint: disable=no-name-in-module, import-error", - "from " + pyModuleName + " import (", - " Tag, action_capsule_t, port_capsule, request_stop, schedule_copy, start", - ")", - "# pylint: disable=c-extension-no-member", - "import " + pyModuleName + " as lf", - "try:", - " from LinguaFrancaBase.constants import BILLION, FOREVER, NEVER, instant_t, interval_t", - " from LinguaFrancaBase.functions import (", - " DAY, DAYS, HOUR, HOURS, MINUTE, MINUTES, MSEC, MSECS, NSEC, NSECS, SEC, SECS," - + " USEC,", - " USECS, WEEK, WEEKS", - " )", - " from LinguaFrancaBase.classes import Make", - "except ModuleNotFoundError:", - " print(\"No module named 'LinguaFrancaBase'. \"", - " \"Install using \\\"pip3 install LinguaFrancaBase\\\".\")", - " sys.exit(1)", - "import copy", - "", - pythonPreamble.toString(), - "", - generatePythonReactorClasses(), - "", - PythonMainFunctionGenerator.generateCode()); - } - - /** Generate the necessary Python files. */ - public Map generatePythonFiles( - String lfModuleName, String pyModuleName, String pyFileName) throws IOException { - Path filePath = fileConfig.getSrcGenPath().resolve(pyFileName); - File file = filePath.toFile(); - Files.deleteIfExists(filePath); - // Create the necessary directories - if (!file.getParentFile().exists()) { - if (!file.getParentFile().mkdirs()) { - throw new IOException( - "Failed to create directories required for the Python code generator."); - } + // Used to add statements that come before reactor classes and user code + private final CodeBuilder pythonPreamble = new CodeBuilder(); + + // Used to add module requirements to setup.py (delimited with ,) + private final List pythonRequiredModules = new ArrayList<>(); + + private final PythonTypes types; + + public PythonGenerator(LFGeneratorContext context) { + this(context, + new PythonTypes(), + new CCmakeGenerator( + context.getFileConfig(), + List.of("lib/python_action.c", + "lib/python_port.c", + "lib/python_tag.c", + "lib/python_time.c", + "lib/pythontarget.c" + ), + PythonGenerator::setUpMainTarget, + "install(TARGETS)" // No-op + ) + ); } - Map codeMaps = new HashMap<>(); - codeMaps.put(filePath, CodeMap.fromGeneratedCode(generatePythonCode(pyModuleName))); - FileUtil.writeToFile(codeMaps.get(filePath).getGeneratedCode(), filePath); - return codeMaps; - } - - /** - * Generate code that needs to appear at the top of the generated C file, such as #define and - * #include statements. - */ - @Override - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr( - PythonPreambleGenerator.generateCDefineDirectives( - targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); - return code.toString(); - } - - /** - * Override generate top-level preambles, but put the user preambles in the .py file rather than - * the C file. Also handles including the federated execution setup preamble specified in the - * target config. - */ - @Override - protected String generateTopLevelPreambles(Reactor ignored) { - // user preambles - Set models = new LinkedHashSet<>(); - for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { - // The following assumes all reactors have a container. - // This means that generated reactors **have** to be - // added to a resource; not doing so will result in a NPE. - models.add((Model) ASTUtils.toDefinition(r).eContainer()); + + + private PythonGenerator(LFGeneratorContext context, PythonTypes types, CCmakeGenerator cmakeGenerator) { + super(context, false, types, cmakeGenerator, new PythonDelayBodyGenerator(types)); + this.targetConfig.compiler = "gcc"; + this.targetConfig.compilerFlags = new ArrayList<>(); + this.targetConfig.linkerFlags = ""; + this.types = types; } - // Add the main reactor if it is defined - if (this.mainDef != null) { - models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); + + /** + * Generic struct for ports with primitive types and + * statically allocated arrays in Lingua Franca. + * This template is defined as + * typedef struct { + * bool is_present; + * lf_sparse_io_record_t* sparse_record; // NULL if there is no sparse record. + * int destination_channel; // -1 if there is no destination. + * PyObject* value; + * int num_destinations; + * lf_token_t* token; + * int length; + * void (*destructor) (void* value); + * void* (*copy_constructor) (void* value); + * FEDERATED_GENERIC_EXTENSION + * } generic_port_instance_struct; + * + * See reactor-c-py/lib/pythontarget.h for details. + */ + String genericPortType = "generic_port_instance_struct"; + + /** + * Generic struct for actions. + * This template is defined as + * typedef struct { + * trigger_t* trigger; + * PyObject* value; + * bool is_present; + * bool has_value; + * lf_token_t* token; + * FEDERATED_CAPSULE_EXTENSION + * } generic_action_instance_struct; + * + * See reactor-c-py/lib/pythontarget.h for details. + */ + String genericActionType = "generic_action_instance_struct"; + + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.Python; } - for (Model m : models) { - pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); + + private final Set protoNames = new HashSet<>(); + + // ////////////////////////////////////////// + // // Public methods + @Override + public TargetTypes getTargetTypes() { + return types; } - return PythonPreambleGenerator.generateCIncludeStatements( - targetConfig, targetLanguageIsCpp(), hasModalReactors); - } - - @Override - protected void handleProtoFiles() { - for (String name : targetConfig.protoFiles) { - this.processProtoFile(name); - int dotIndex = name.lastIndexOf("."); - String rootFilename = dotIndex > 0 ? name.substring(0, dotIndex) : name; - pythonPreamble.pr("import " + rootFilename + "_pb2 as " + rootFilename); - protoNames.add(rootFilename); + + // ////////////////////////////////////////// + // // Protected methods + + /** + * Generate all Python classes if they have a reaction + * + */ + public String generatePythonReactorClasses() { + CodeBuilder pythonClasses = new CodeBuilder(); + CodeBuilder pythonClassesInstantiation = new CodeBuilder(); + + // Generate reactor classes in Python + pythonClasses.pr(PythonReactorGenerator.generatePythonClass(main, main, types)); + + // Create empty lists to hold reactor instances + pythonClassesInstantiation.pr(PythonReactorGenerator.generateListsToHoldClassInstances(main)); + + // Instantiate generated classes + pythonClassesInstantiation.pr(PythonReactorGenerator.generatePythonClassInstantiations(main, main)); + + return String.join("\n", + pythonClasses.toString(), + "", + "# Instantiate classes", + pythonClassesInstantiation.toString() + ); } - } - - /** - * Process a given .proto file. - * - *

Run, if possible, the proto-c protocol buffer code generator to produce the required .h and - * .c files. - * - * @param filename Name of the file to process. - */ - @Override - public void processProtoFile(String filename) { - LFCommand protoc = - commandFactory.createCommand( - "protoc", - List.of("--python_out=" + fileConfig.getSrcGenPath(), filename), - fileConfig.srcPath); - - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires libprotoc >= 3.6.1"); - return; + + /** + * Generate the Python code constructed from reactor classes and + * user-written classes. + * + * @return the code body + */ + public String generatePythonCode(String pyModuleName) { + return String.join("\n", + "import os", + "import sys", + "sys.path.append(os.path.dirname(__file__))", + "# List imported names, but do not use pylint's --extension-pkg-allow-list option", + "# so that these names will be assumed present without having to compile and install.", + "# pylint: disable=no-name-in-module, import-error", + "from "+pyModuleName+" import (", + " Tag, action_capsule_t, port_capsule, request_stop, schedule_copy, start", + ")", + "# pylint: disable=c-extension-no-member", + "import "+pyModuleName+" as lf", + "try:", + " from LinguaFrancaBase.constants import BILLION, FOREVER, NEVER, instant_t, interval_t", + " from LinguaFrancaBase.functions import (", + " DAY, DAYS, HOUR, HOURS, MINUTE, MINUTES, MSEC, MSECS, NSEC, NSECS, SEC, SECS, USEC,", + " USECS, WEEK, WEEKS", + " )", + " from LinguaFrancaBase.classes import Make", + "except ModuleNotFoundError:", + " print(\"No module named 'LinguaFrancaBase'. \"", + " \"Install using \\\"pip3 install LinguaFrancaBase\\\".\")", + " sys.exit(1)", + "import copy", + "", + pythonPreamble.toString(), + "", + generatePythonReactorClasses(), + "", + PythonMainFunctionGenerator.generateCode() + ); } - int returnCode = protoc.run(); - if (returnCode == 0) { - pythonRequiredModules.add("google-api-python-client"); - } else { - errorReporter.reportError("protoc returns error code " + returnCode); + + /** + * Generate the necessary Python files. + */ + public Map generatePythonFiles( + String lfModuleName, + String pyModuleName, + String pyFileName + ) throws IOException { + Path filePath = fileConfig.getSrcGenPath().resolve(pyFileName); + File file = filePath.toFile(); + Files.deleteIfExists(filePath); + // Create the necessary directories + if (!file.getParentFile().exists()) { + if (!file.getParentFile().mkdirs()) { + throw new IOException( + "Failed to create directories required for the Python code generator." + ); + } + } + Map codeMaps = new HashMap<>(); + codeMaps.put(filePath, CodeMap.fromGeneratedCode( + generatePythonCode(pyModuleName))); + FileUtil.writeToFile(codeMaps.get(filePath).getGeneratedCode(), filePath); + return codeMaps; + } + + /** + * Generate code that needs to appear at the top of the generated + * C file, such as #define and #include statements. + */ + @Override + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr(PythonPreambleGenerator.generateCDefineDirectives( + targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); + return code.toString(); + } + + /** + * Override generate top-level preambles, but put the user preambles in the + * .py file rather than the C file. Also handles including the federated + * execution setup preamble specified in the target config. + */ + @Override + protected String generateTopLevelPreambles(Reactor ignored) { + // user preambles + Set models = new LinkedHashSet<>(); + for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { + // The following assumes all reactors have a container. + // This means that generated reactors **have** to be + // added to a resource; not doing so will result in a NPE. + models.add((Model) ASTUtils.toDefinition(r).eContainer()); + } + // Add the main reactor if it is defined + if (this.mainDef != null) { + models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); + } + for (Model m : models) { + pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); + } + return PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors); + } + + @Override + protected void handleProtoFiles() { + for (String name : targetConfig.protoFiles) { + this.processProtoFile(name); + int dotIndex = name.lastIndexOf("."); + String rootFilename = dotIndex > 0 ? name.substring(0, dotIndex) : name; + pythonPreamble.pr("import "+rootFilename+"_pb2 as "+rootFilename); + protoNames.add(rootFilename); + } + } + + /** + * Process a given .proto file. + * + * Run, if possible, the proto-c protocol buffer code generator to produce + * the required .h and .c files. + * + * @param filename Name of the file to process. + */ + @Override + public void processProtoFile(String filename) { + LFCommand protoc = commandFactory.createCommand( + "protoc", List.of("--python_out=" + + fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); + + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires libprotoc >= 3.6.1"); + return; + } + int returnCode = protoc.run(); + if (returnCode == 0) { + pythonRequiredModules.add("google-api-python-client"); + } else { + errorReporter.reportError( + "protoc returns error code " + returnCode); + } + } + + /** + * Generate the aliases for inputs, outputs, and struct type definitions for + * actions of the specified reactor in the specified federate. + * @param r The parsed reactor data structure. + */ + @Override + public void generateAuxiliaryStructs( + CodeBuilder builder, Reactor r, boolean userFacing + ) { + for (Input input : ASTUtils.allInputs(r)) { + generateAuxiliaryStructsForPort(builder, r, input); + } + for (Output output : ASTUtils.allOutputs(r)) { + generateAuxiliaryStructsForPort(builder, r, output); + } + for (Action action : ASTUtils.allActions(r)) { + generateAuxiliaryStructsForAction(builder, r, action); + } } - } - - /** - * Generate the aliases for inputs, outputs, and struct type definitions for actions of the - * specified reactor in the specified federate. - * - * @param r The parsed reactor data structure. - */ - @Override - public void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { - for (Input input : ASTUtils.allInputs(r)) { - generateAuxiliaryStructsForPort(builder, r, input); + + private void generateAuxiliaryStructsForPort(CodeBuilder builder, Reactor r, + Port port) { + boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); + builder.pr(port, + PythonPortGenerator.generateAliasTypeDef(r, port, isTokenType, + genericPortType)); } - for (Output output : ASTUtils.allOutputs(r)) { - generateAuxiliaryStructsForPort(builder, r, output); + + private void generateAuxiliaryStructsForAction(CodeBuilder builder, Reactor r, + Action action) { + builder.pr(action, PythonActionGenerator.generateAliasTypeDef(r, action, genericActionType)); } - for (Action action : ASTUtils.allActions(r)) { - generateAuxiliaryStructsForAction(builder, r, action); + + /** + * Return true if the host operating system is compatible and + * otherwise report an error and return false. + */ + @Override + public boolean isOSCompatible() { + return true; } - } - - private void generateAuxiliaryStructsForPort(CodeBuilder builder, Reactor r, Port port) { - boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); - builder.pr( - port, PythonPortGenerator.generateAliasTypeDef(r, port, isTokenType, genericPortType)); - } - - private void generateAuxiliaryStructsForAction(CodeBuilder builder, Reactor r, Action action) { - builder.pr(action, PythonActionGenerator.generateAliasTypeDef(r, action, genericActionType)); - } - - /** - * Return true if the host operating system is compatible and otherwise report an error and return - * false. - */ - @Override - public boolean isOSCompatible() { - return true; - } - - /** - * Generate C code from the Lingua Franca model contained by the specified resource. This is the - * main entry point for code generation. - * - * @param resource The resource containing the source code. - * @param context Context relating to invocation of the code generator. - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - // Set the threading to false by default, unless the user has - // specifically asked for it. - if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = false; + + /** + * Generate C code from the Lingua Franca model contained by the + * specified resource. This is the main entry point for code + * generation. + * + * @param resource The resource containing the source code. + * @param context Context relating to invocation of the code generator. + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + // Set the threading to false by default, unless the user has + // specifically asked for it. + if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = false; + } + int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; + code.pr(PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors)); + super.doGenerate(resource, new SubContext( + context, + IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, + cGeneratedPercentProgress + )); + + if (errorsOccurred()) { + context.unsuccessfulFinish(); + return; + } + + Map codeMaps = new HashMap<>(); + var lfModuleName = fileConfig.name; + // Don't generate code if there is no main reactor + if (this.main != null) { + try { + Map codeMapsForFederate = generatePythonFiles(lfModuleName, generatePythonModuleName(lfModuleName), generatePythonFileName(lfModuleName)); + codeMaps.putAll(codeMapsForFederate); + copyTargetFiles(); + new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); + if (targetConfig.noCompile) { + System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); + } + } catch (Exception e) { + //noinspection ConstantConditions + throw Exceptions.sneakyThrow(e); + } + + System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); + } + + if (errorReporter.getErrorsOccurred()) { + context.unsuccessfulFinish(); + } else { + context.finish(GeneratorResult.Status.COMPILED, codeMaps); + } } - int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; - code.pr( - PythonPreambleGenerator.generateCIncludeStatements( - targetConfig, targetLanguageIsCpp(), hasModalReactors)); - super.doGenerate( - resource, - new SubContext( - context, IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, cGeneratedPercentProgress)); - - if (errorsOccurred()) { - context.unsuccessfulFinish(); - return; + + @Override + protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new PythonDockerGenerator(context); } - Map codeMaps = new HashMap<>(); - var lfModuleName = fileConfig.name; - // Don't generate code if there is no main reactor - if (this.main != null) { - try { - Map codeMapsForFederate = - generatePythonFiles( - lfModuleName, - generatePythonModuleName(lfModuleName), - generatePythonFileName(lfModuleName)); - codeMaps.putAll(codeMapsForFederate); - copyTargetFiles(); - new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); - if (targetConfig.noCompile) { - System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); + /** Generate a reaction function definition for a reactor. + * This function has a single argument that is a void* pointing to + * a struct that contains parameters, state variables, inputs (triggering or not), + * actions (triggering or produced), and outputs. + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + @Override + protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { + Reactor reactor = ASTUtils.toDefinition(r); + + // Reactions marked with a `@_c_body` attribute are generated in C + if (AttributeUtils.hasCBody(reaction)) { + super.generateReaction(src, reaction, r, reactionIndex); + return; } - } catch (Exception e) { - //noinspection ConstantConditions - throw Exceptions.sneakyThrow(e); - } + src.pr(PythonReactionGenerator.generateCReaction(reaction, reactor, reactionIndex, mainDef, errorReporter, types)); + } - System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); + /** + * Generate code that initializes the state variables for a given instance. + * Unlike parameters, state variables are uniformly initialized for all + * instances + * of the same reactor. This task is left to Python code to allow for more + * liberal + * state variable assignments. + * + * @param instance The reactor class instance + * @return Initialization code fore state variables of instance + */ + @Override + protected void generateStateVariableInitializations(ReactorInstance instance) { + // Do nothing } - if (errorReporter.getErrorsOccurred()) { - context.unsuccessfulFinish(); - } else { - context.finish(GeneratorResult.Status.COMPILED, codeMaps); + /** + * Generate runtime initialization code in C for parameters of a given + * reactor instance + * + * @param instance The reactor instance. + */ + @Override + protected void generateParameterInitialization(ReactorInstance instance) { + // Do nothing + // Parameters are initialized in Python } - } - - @Override - protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new PythonDockerGenerator(context); - } - - /** - * Generate a reaction function definition for a reactor. This function has a single argument that - * is a void* pointing to a struct that contains parameters, state variables, inputs (triggering - * or not), actions (triggering or produced), and outputs. - * - * @param reaction The reaction. - * @param r The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - @Override - protected void generateReaction( - CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { - Reactor reactor = ASTUtils.toDefinition(r); - - // Reactions marked with a `@_c_body` attribute are generated in C - if (AttributeUtils.hasCBody(reaction)) { - super.generateReaction(src, reaction, r, reactionIndex); - return; + + /** + * Do nothing. + * Methods are generated in Python not C. + * @see PythonMethodGenerator + */ + @Override + protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { } + + /** + * Generate C preambles defined by user for a given reactor + * Since the Python generator expects preambles written in C, + * this function is overridden and does nothing. + * + * @param reactor The given reactor + */ + @Override + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + // Do nothing } - src.pr( - PythonReactionGenerator.generateCReaction( - reaction, reactor, reactionIndex, mainDef, errorReporter, types)); - } - - /** - * Generate code that initializes the state variables for a given instance. Unlike parameters, - * state variables are uniformly initialized for all instances of the same reactor. This task is - * left to Python code to allow for more liberal state variable assignments. - * - * @param instance The reactor class instance - * @return Initialization code fore state variables of instance - */ - @Override - protected void generateStateVariableInitializations(ReactorInstance instance) { - // Do nothing - } - - /** - * Generate runtime initialization code in C for parameters of a given reactor instance - * - * @param instance The reactor instance. - */ - @Override - protected void generateParameterInitialization(ReactorInstance instance) { - // Do nothing - // Parameters are initialized in Python - } - - /** - * Do nothing. Methods are generated in Python not C. - * - * @see PythonMethodGenerator - */ - @Override - protected void generateMethods(CodeBuilder src, ReactorDecl reactor) {} - - /** - * Generate C preambles defined by user for a given reactor Since the Python generator expects - * preambles written in C, this function is overridden and does nothing. - * - * @param reactor The given reactor - */ - @Override - protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { - // Do nothing - } - - /** - * Generate code that is executed while the reactor instance is being initialized. This wraps the - * reaction functions in a Python function. - * - * @param instance The reactor instance. - */ - @Override - protected void generateReactorInstanceExtension(ReactorInstance instance) { - initializeTriggerObjects.pr( - PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); - } - - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the - * self struct - * - * @param selfStructBody The body of the self struct - * @param decl The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - @Override - protected void generateSelfStructExtension( - CodeBuilder selfStructBody, ReactorDecl decl, CodeBuilder constructorCode) { - Reactor reactor = ASTUtils.toDefinition(decl); - // Add the name field - selfStructBody.pr("char *_lf_name;"); - int reactionIndex = 0; - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - // Create a PyObject for each reaction - selfStructBody.pr( - "PyObject* " - + PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex) - + ";"); - if (reaction.getStp() != null) { - selfStructBody.pr( - "PyObject* " - + PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex) - + ";"); - } - if (reaction.getDeadline() != null) { - selfStructBody.pr( - "PyObject* " - + PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex) - + ";"); - } - reactionIndex++; + + /** + * Generate code that is executed while the reactor instance is being + * initialized. + * This wraps the reaction functions in a Python function. + * @param instance The reactor instance. + */ + @Override + protected void generateReactorInstanceExtension( + ReactorInstance instance + ) { + initializeTriggerObjects.pr(PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); } - } - - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - // NOTE: Strangely, a newline is needed at the beginning or indentation - // gets swallowed. - return String.join( - "\n", - "\n# Generated forwarding reaction for connections with the same destination", - "# but located in mutually exclusive modes.", - dest + ".set(" + source + ".value)\n"); - } - - @Override - protected void setUpGeneralParameters() { - super.setUpGeneralParameters(); - if (hasModalReactors) { - targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the self struct + * @param selfStructBody The body of the self struct + * @param decl The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + @Override + protected void generateSelfStructExtension( + CodeBuilder selfStructBody, + ReactorDecl decl, + CodeBuilder constructorCode + ) { + Reactor reactor = ASTUtils.toDefinition(decl); + // Add the name field + selfStructBody.pr("char *_lf_name;"); + int reactionIndex = 0; + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create a PyObject for each reaction + selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex)+";"); + if (reaction.getStp() != null) { + selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex)+";"); + } + if (reaction.getDeadline() != null) { + selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex)+";"); + } + reactionIndex++; + } } - } - @Override - protected void additionalPostProcessingForModes() { - if (!hasModalReactors) { - return; + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + // NOTE: Strangely, a newline is needed at the beginning or indentation + // gets swallowed. + return String.join("\n", + "\n# Generated forwarding reaction for connections with the same destination", + "# but located in mutually exclusive modes.", + dest + ".set(" + source + ".value)\n" + ); } - PythonModeGenerator.generateResetReactionsIfNeeded(reactors); - } - private static String setUpMainTarget( - boolean hasMain, String executableName, Stream cSources) { - return (""" + @Override + protected void setUpGeneralParameters() { + super.setUpGeneralParameters(); + if (hasModalReactors) { + targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); + } + } + + @Override + protected void additionalPostProcessingForModes() { + if (!hasModalReactors) { + return; + } + PythonModeGenerator.generateResetReactionsIfNeeded(reactors); + } + + private static String setUpMainTarget(boolean hasMain, String executableName, Stream cSources) { + return ( + """ set(CMAKE_POSITION_INDEPENDENT_CODE ON) add_compile_definitions(_LF_GARBAGE_COLLECTED) add_subdirectory(core) @@ -586,61 +611,71 @@ private static String setUpMainTarget( include_directories(${Python_INCLUDE_DIRS}) target_link_libraries(${LF_MAIN_TARGET} PRIVATE ${Python_LIBRARIES}) target_compile_definitions(${LF_MAIN_TARGET} PUBLIC MODULE_NAME=) - """) - .replace("", generatePythonModuleName(executableName)) - .replace("executableName", executableName); - // The use of fileConfig.name will break federated execution, but that's fine - } - - /** - * Generate a (`key`, `val`) tuple pair for the `define_macros` field of the Extension class - * constructor from setuptools. - * - * @param key The key of the macro entry - * @param val The value of the macro entry - * @return A (`key`, `val`) tuple pair as String - */ - private static String generateMacroEntry(String key, String val) { - return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; - } - - /** - * Generate the name of the python module. - * - *

Ideally, this function would belong in a class like `PyFileConfig` that specifies all the - * paths to the generated code. - * - * @param lfModuleName The name of the LF module. - * @return The name of the python module. - */ - private static String generatePythonModuleName(String lfModuleName) { - return "LinguaFranca" + lfModuleName; - } - - /** - * Generate the python file name given an `lfModuleName`. - * - *

Ideally, this function would belong in a class like `PyFileConfig` that specifies all the - * paths to the generated code. - * - * @param lfModuleName The name of the LF module - * @return The name of the generated python file. - */ - private static String generatePythonFileName(String lfModuleName) { - return lfModuleName + ".py"; - } - - /** Copy Python specific target code to the src-gen directory */ - @Override - protected void copyTargetFiles() throws IOException { - super.copyTargetFiles(); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/include", fileConfig.getSrcGenPath().resolve("include"), true); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/lib", fileConfig.getSrcGenPath().resolve("lib"), true); - FileUtil.copyDirectoryFromClassPath( - "/lib/py/reactor-c-py/LinguaFrancaBase", - fileConfig.getSrcGenPath().resolve("LinguaFrancaBase"), - true); - } + """ + ).replace("", generatePythonModuleName(executableName)) + .replace("executableName", executableName); + // The use of fileConfig.name will break federated execution, but that's fine + } + + /** + * Generate a (`key`, `val`) tuple pair for the `define_macros` field + * of the Extension class constructor from setuptools. + * + * @param key The key of the macro entry + * @param val The value of the macro entry + * @return A (`key`, `val`) tuple pair as String + */ + private static String generateMacroEntry(String key, String val) { + return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; + } + + /** + * Generate the name of the python module. + * + * Ideally, this function would belong in a class like `PyFileConfig` + * that specifies all the paths to the generated code. + * + * @param lfModuleName The name of the LF module. + * @return The name of the python module. + */ + private static String generatePythonModuleName(String lfModuleName) { + return "LinguaFranca" + lfModuleName; + } + + /** + * Generate the python file name given an `lfModuleName`. + * + * Ideally, this function would belong in a class like `PyFileConfig` + * that specifies all the paths to the generated code. + * + * @param lfModuleName The name of the LF module + * @return The name of the generated python file. + */ + private static String generatePythonFileName(String lfModuleName) { + return lfModuleName + ".py"; + } + + /** + * Copy Python specific target code to the src-gen directory + */ + @Override + protected void copyTargetFiles() throws IOException { + super.copyTargetFiles(); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/include", + fileConfig.getSrcGenPath().resolve("include"), + true + ); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/lib", + fileConfig.getSrcGenPath().resolve("lib"), + true + ); + FileUtil.copyDirectoryFromClassPath( + "/lib/py/reactor-c-py/LinguaFrancaBase", + fileConfig.getSrcGenPath().resolve("LinguaFrancaBase"), + true + ); + } + } From e52a3bc220212b19d23cfd31cbc124242415bc02 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 10:16:13 +0200 Subject: [PATCH 227/709] Revert formatting --- .../lflang/scoping/LFScopeProviderImpl.java | 425 +-- .../org/lflang/validation/LFValidator.java | 3290 ++++++++--------- 2 files changed, 1823 insertions(+), 1892 deletions(-) diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java index 32cd8d4a97..70a05a40f7 100644 --- a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java +++ b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java @@ -1,27 +1,27 @@ /************* - * Copyright (c) 2020, The University of California at Berkeley. - * - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. - ***************/ +Copyright (c) 2020, The University of California at Berkeley. + +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. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. +***************/ package org.lflang.scoping; @@ -29,13 +29,16 @@ import static org.lflang.ASTUtils.*; import com.google.inject.Inject; + import java.util.ArrayList; + import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EReference; import org.eclipse.xtext.naming.SimpleNameProvider; import org.eclipse.xtext.scoping.IScope; import org.eclipse.xtext.scoping.Scopes; import org.eclipse.xtext.scoping.impl.SelectableBasedScope; + import org.lflang.lf.Assignment; import org.lflang.lf.Connection; import org.lflang.lf.Deadline; @@ -60,220 +63,220 @@ */ public class LFScopeProviderImpl extends AbstractLFScopeProvider { - @Inject private SimpleNameProvider nameProvider; + @Inject + private SimpleNameProvider nameProvider; - @Inject private LFGlobalScopeProvider scopeProvider; + @Inject + private LFGlobalScopeProvider scopeProvider; - /** Enumerate of the kinds of references. */ - enum RefType { - NULL, - TRIGGER, - SOURCE, - EFFECT, - WATCHDOG, - DEADLINE, - CLEFT, - CRIGHT - } + /** + * Enumerate of the kinds of references. + */ + enum RefType { + NULL, + TRIGGER, + SOURCE, + EFFECT, + WATCHDOG, + DEADLINE, + CLEFT, + CRIGHT + } - /** - * Depending on the provided context, construct the appropriate scope for the given reference. - * - * @param context The AST node in which a to-be-resolved reference occurs. - * @param reference The reference to resolve. - */ - @Override - public IScope getScope(EObject context, EReference reference) { - if (context instanceof VarRef) { - return getScopeForVarRef((VarRef) context, reference); - } else if (context instanceof Assignment) { - return getScopeForAssignment((Assignment) context, reference); - } else if (context instanceof Instantiation) { - return getScopeForReactorDecl(context, reference); - } else if (context instanceof Reactor) { - return getScopeForReactorDecl(context, reference); - } else if (context instanceof ImportedReactor) { - return getScopeForImportedReactor((ImportedReactor) context, reference); + /** + * Depending on the provided context, construct the appropriate scope + * for the given reference. + * + * @param context The AST node in which a to-be-resolved reference occurs. + * @param reference The reference to resolve. + */ + @Override + public IScope getScope(EObject context, EReference reference) { + if (context instanceof VarRef) { + return getScopeForVarRef((VarRef) context, reference); + } else if (context instanceof Assignment) { + return getScopeForAssignment((Assignment) context, reference); + } else if (context instanceof Instantiation) { + return getScopeForReactorDecl(context, reference); + } else if (context instanceof Reactor) { + return getScopeForReactorDecl(context, reference); + } else if (context instanceof ImportedReactor) { + return getScopeForImportedReactor((ImportedReactor) context, reference); + } + return super.getScope(context, reference); } - return super.getScope(context, reference); - } - /** - * Filter out candidates that do not originate from the file listed in this particular import - * statement. - */ - protected IScope getScopeForImportedReactor(ImportedReactor context, EReference reference) { - String importURI = ((Import) context.eContainer()).getImportURI(); - var importedURI = - scopeProvider.resolve(importURI == null ? "" : importURI, context.eResource()); - if (importedURI != null) { - var uniqueImportURIs = scopeProvider.getImportedUris(context.eResource()); - var descriptions = - scopeProvider.getResourceDescriptions(context.eResource(), uniqueImportURIs); - var description = descriptions.getResourceDescription(importedURI); - return SelectableBasedScope.createScope( - IScope.NULLSCOPE, description, null, reference.getEReferenceType(), false); + /** + * Filter out candidates that do not originate from the file listed in + * this particular import statement. + */ + protected IScope getScopeForImportedReactor(ImportedReactor context, EReference reference) { + String importURI = ((Import) context.eContainer()).getImportURI(); + var importedURI = scopeProvider.resolve(importURI == null ? "" : importURI, context.eResource()); + if (importedURI != null) { + var uniqueImportURIs = scopeProvider.getImportedUris(context.eResource()); + var descriptions = scopeProvider.getResourceDescriptions(context.eResource(), uniqueImportURIs); + var description = descriptions.getResourceDescription(importedURI); + return SelectableBasedScope.createScope(IScope.NULLSCOPE, description, null, reference.getEReferenceType(), false); + } + return Scopes.scopeFor(emptyList()); } - return Scopes.scopeFor(emptyList()); - } - /** - * @param obj Instantiation or Reactor that has a ReactorDecl to resolve. - * @param reference The reference to link to a ReactorDecl node. - */ - protected IScope getScopeForReactorDecl(EObject obj, EReference reference) { + /** + * @param obj Instantiation or Reactor that has a ReactorDecl to resolve. + * @param reference The reference to link to a ReactorDecl node. + */ + protected IScope getScopeForReactorDecl(EObject obj, EReference reference) { - // Find the local Model - Model model = null; - EObject container = obj; - while (model == null && container != null) { - container = container.eContainer(); - if (container instanceof Model) { - model = (Model) container; - } - } - if (model == null) { - return Scopes.scopeFor(emptyList()); - } + // Find the local Model + Model model = null; + EObject container = obj; + while(model == null && container != null) { + container = container.eContainer(); + if (container instanceof Model) { + model = (Model)container; + } + } + if (model == null) { + return Scopes.scopeFor(emptyList()); + } - // Collect eligible candidates, all of which are local (i.e., not in other files). - var locals = new ArrayList(model.getReactors()); + // Collect eligible candidates, all of which are local (i.e., not in other files). + var locals = new ArrayList(model.getReactors()); - // Either point to the import statement (if it is renamed) - // or directly to the reactor definition. - for (Import it : model.getImports()) { - for (ImportedReactor ir : it.getReactorClasses()) { - if (ir.getName() != null) { - locals.add(ir); - } else if (ir.getReactorClass() != null) { - locals.add(ir.getReactorClass()); + // Either point to the import statement (if it is renamed) + // or directly to the reactor definition. + for (Import it : model.getImports()) { + for (ImportedReactor ir : it.getReactorClasses()) { + if (ir.getName() != null) { + locals.add(ir); + } else if (ir.getReactorClass() != null) { + locals.add(ir.getReactorClass()); + } + } } - } + return Scopes.scopeFor(locals); } - return Scopes.scopeFor(locals); - } - protected IScope getScopeForAssignment(Assignment assignment, EReference reference) { + protected IScope getScopeForAssignment(Assignment assignment, EReference reference) { - if (reference == LfPackage.Literals.ASSIGNMENT__LHS) { - var defn = toDefinition(((Instantiation) assignment.eContainer()).getReactorClass()); - if (defn != null) { - return Scopes.scopeFor(allParameters(defn)); - } - } - if (reference == LfPackage.Literals.ASSIGNMENT__RHS) { - return Scopes.scopeFor(((Reactor) assignment.eContainer().eContainer()).getParameters()); + if (reference == LfPackage.Literals.ASSIGNMENT__LHS) { + var defn = toDefinition(((Instantiation) assignment.eContainer()).getReactorClass()); + if (defn != null) { + return Scopes.scopeFor(allParameters(defn)); + } + } + if (reference == LfPackage.Literals.ASSIGNMENT__RHS) { + return Scopes.scopeFor(((Reactor) assignment.eContainer().eContainer()).getParameters()); + } + return Scopes.scopeFor(emptyList()); } - return Scopes.scopeFor(emptyList()); - } - protected IScope getScopeForVarRef(VarRef variable, EReference reference) { - if (reference == LfPackage.Literals.VAR_REF__VARIABLE) { - // Resolve hierarchical reference - Reactor reactor; - Mode mode = null; - if (variable.eContainer().eContainer() instanceof Reactor) { - reactor = (Reactor) variable.eContainer().eContainer(); - } else if (variable.eContainer().eContainer() instanceof Mode) { - mode = (Mode) variable.eContainer().eContainer(); - reactor = (Reactor) variable.eContainer().eContainer().eContainer(); - } else { - return Scopes.scopeFor(emptyList()); - } + protected IScope getScopeForVarRef(VarRef variable, EReference reference) { + if (reference == LfPackage.Literals.VAR_REF__VARIABLE) { + // Resolve hierarchical reference + Reactor reactor; + Mode mode = null; + if (variable.eContainer().eContainer() instanceof Reactor) { + reactor = (Reactor) variable.eContainer().eContainer(); + } else if (variable.eContainer().eContainer() instanceof Mode) { + mode = (Mode) variable.eContainer().eContainer(); + reactor = (Reactor) variable.eContainer().eContainer().eContainer(); + } else { + return Scopes.scopeFor(emptyList()); + } - RefType type = getRefType(variable); + RefType type = getRefType(variable); - if (variable.getContainer() != null) { // Resolve hierarchical port reference - var instanceName = nameProvider.getFullyQualifiedName(variable.getContainer()); - var instances = new ArrayList(reactor.getInstantiations()); - if (mode != null) { - instances.addAll(mode.getInstantiations()); - } + if (variable.getContainer() != null) { // Resolve hierarchical port reference + var instanceName = nameProvider.getFullyQualifiedName(variable.getContainer()); + var instances = new ArrayList(reactor.getInstantiations()); + if (mode != null) { + instances.addAll(mode.getInstantiations()); + } - if (instanceName != null) { - for (var instance : instances) { - var defn = toDefinition(instance.getReactorClass()); - if (defn != null && instance.getName().equals(instanceName.toString())) { - switch (type) { - case TRIGGER: + if (instanceName != null) { + for (var instance : instances) { + var defn = toDefinition(instance.getReactorClass()); + if (defn != null && instance.getName().equals(instanceName.toString())) { + switch (type) { + case TRIGGER: + case SOURCE: + case CLEFT: + return Scopes.scopeFor(allOutputs(defn)); + case EFFECT: + case DEADLINE: + case CRIGHT: + return Scopes.scopeFor(allInputs(defn)); + } + } + } + } + return Scopes.scopeFor(emptyList()); + } else { + // Resolve local reference + switch (type) { + case TRIGGER: { + var candidates = new ArrayList(); + if (mode != null) { + candidates.addAll(mode.getActions()); + candidates.addAll(mode.getTimers()); + } + candidates.addAll(allInputs(reactor)); + candidates.addAll(allActions(reactor)); + candidates.addAll(allTimers(reactor)); + candidates.addAll(allWatchdogs(reactor)); + return Scopes.scopeFor(candidates); + } case SOURCE: - case CLEFT: - return Scopes.scopeFor(allOutputs(defn)); - case EFFECT: + return super.getScope(variable, reference); + case EFFECT: { + var candidates = new ArrayList(); + if (mode != null) { + candidates.addAll(mode.getActions()); + candidates.addAll(reactor.getModes()); + } + candidates.addAll(allOutputs(reactor)); + candidates.addAll(allActions(reactor)); + candidates.addAll(allWatchdogs(reactor)); + return Scopes.scopeFor(candidates); + } + case WATCHDOG: + return Scopes.scopeFor(allWatchdogs(reactor)); case DEADLINE: + case CLEFT: + return Scopes.scopeFor(allInputs(reactor)); case CRIGHT: - return Scopes.scopeFor(allInputs(defn)); - } - } - } - } - return Scopes.scopeFor(emptyList()); - } else { - // Resolve local reference - switch (type) { - case TRIGGER: - { - var candidates = new ArrayList(); - if (mode != null) { - candidates.addAll(mode.getActions()); - candidates.addAll(mode.getTimers()); - } - candidates.addAll(allInputs(reactor)); - candidates.addAll(allActions(reactor)); - candidates.addAll(allTimers(reactor)); - candidates.addAll(allWatchdogs(reactor)); - return Scopes.scopeFor(candidates); + return Scopes.scopeFor(allOutputs(reactor)); + default: + return Scopes.scopeFor(emptyList()); + } } - case SOURCE: + } else { // Resolve instance return super.getScope(variable, reference); - case EFFECT: - { - var candidates = new ArrayList(); - if (mode != null) { - candidates.addAll(mode.getActions()); - candidates.addAll(reactor.getModes()); - } - candidates.addAll(allOutputs(reactor)); - candidates.addAll(allActions(reactor)); - candidates.addAll(allWatchdogs(reactor)); - return Scopes.scopeFor(candidates); - } - case WATCHDOG: - return Scopes.scopeFor(allWatchdogs(reactor)); - case DEADLINE: - case CLEFT: - return Scopes.scopeFor(allInputs(reactor)); - case CRIGHT: - return Scopes.scopeFor(allOutputs(reactor)); - default: - return Scopes.scopeFor(emptyList()); } - } - } else { // Resolve instance - return super.getScope(variable, reference); } - } - private RefType getRefType(VarRef variable) { - if (variable.eContainer() instanceof Deadline) { - return RefType.DEADLINE; - } else if (variable.eContainer() instanceof Reaction) { - var reaction = (Reaction) variable.eContainer(); - if (reaction.getTriggers().contains(variable)) { - return RefType.TRIGGER; - } else if (reaction.getSources().contains(variable)) { - return RefType.SOURCE; - } else if (reaction.getEffects().contains(variable)) { - return RefType.EFFECT; - } - } else if (variable.eContainer() instanceof Connection) { - var conn = (Connection) variable.eContainer(); - if (conn.getLeftPorts().contains(variable)) { - return RefType.CLEFT; - } else if (conn.getRightPorts().contains(variable)) { - return RefType.CRIGHT; - } + private RefType getRefType(VarRef variable) { + if (variable.eContainer() instanceof Deadline) { + return RefType.DEADLINE; + } else if (variable.eContainer() instanceof Reaction) { + var reaction = (Reaction) variable.eContainer(); + if (reaction.getTriggers().contains(variable)) { + return RefType.TRIGGER; + } else if (reaction.getSources().contains(variable)) { + return RefType.SOURCE; + } else if (reaction.getEffects().contains(variable)) { + return RefType.EFFECT; + } + } else if (variable.eContainer() instanceof Connection) { + var conn = (Connection) variable.eContainer(); + if (conn.getLeftPorts().contains(variable)) { + return RefType.CLEFT; + } else if (conn.getRightPorts().contains(variable)) { + return RefType.CRIGHT; + } + } + return RefType.NULL; } - return RefType.NULL; - } } diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index b0555dc4e0..7f1aa5c808 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -2,13 +2,17 @@ /************* * Copyright (c) 2019-2020, The University of California at Berkeley. + * 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. + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -24,10 +28,12 @@ import static org.lflang.ASTUtils.inferPortWidth; import static org.lflang.ASTUtils.isGeneric; +import static org.lflang.ASTUtils.isInteger; +import static org.lflang.ASTUtils.isOfTimeType; +import static org.lflang.ASTUtils.isZero; import static org.lflang.ASTUtils.toDefinition; import static org.lflang.ASTUtils.toOriginalText; -import com.google.inject.Inject; import java.io.File; import java.io.IOException; import java.util.ArrayList; @@ -39,6 +45,7 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; + import org.eclipse.emf.common.util.EList; import org.eclipse.emf.common.util.TreeIterator; import org.eclipse.emf.ecore.EAttribute; @@ -65,6 +72,7 @@ import org.lflang.lf.BracedListExpression; import org.lflang.lf.BuiltinTrigger; import org.lflang.lf.BuiltinTriggerRef; +import org.lflang.lf.CodeExpr; import org.lflang.lf.Connection; import org.lflang.lf.Deadline; import org.lflang.lf.Expression; @@ -108,10 +116,12 @@ import org.lflang.lf.WidthTerm; import org.lflang.util.FileUtil; +import com.google.inject.Inject; + /** * Custom validation checks for Lingua Franca programs. * - *

Also see: https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + * Also see: https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation * * @author Edward A. Lee * @author Marten Lohstroh @@ -122,1832 +132,1750 @@ */ public class LFValidator extends BaseLFValidator { - ////////////////////////////////////////////////////////////// - //// Public check methods. - - // These methods are automatically invoked on AST nodes matching - // the types of their arguments. - // CheckType.FAST ensures that these checks run whenever a file is modified. - // Alternatives are CheckType.NORMAL (when saving) and - // CheckType.EXPENSIVE (only when right-click, validate). - // FIXME: What is the default when nothing is specified? - - // These methods are listed in alphabetical order, and, although - // it is isn't strictly required, follow a naming convention - // checkClass, where Class is the AST class, where possible. - - @Check(CheckType.FAST) - public void checkAction(Action action) { - checkName(action.getName(), Literals.VARIABLE__NAME); - if (action.getOrigin() == ActionOrigin.NONE) { - error("Action must have modifier `logical` or `physical`.", Literals.ACTION__ORIGIN); - } - if (action.getPolicy() != null && !SPACING_VIOLATION_POLICIES.contains(action.getPolicy())) { - error( - "Unrecognized spacing violation policy: " - + action.getPolicy() - + ". Available policies are: " - + String.join(", ", SPACING_VIOLATION_POLICIES) - + ".", - Literals.ACTION__POLICY); + ////////////////////////////////////////////////////////////// + //// Public check methods. + + // These methods are automatically invoked on AST nodes matching + // the types of their arguments. + // CheckType.FAST ensures that these checks run whenever a file is modified. + // Alternatives are CheckType.NORMAL (when saving) and + // CheckType.EXPENSIVE (only when right-click, validate). + // FIXME: What is the default when nothing is specified? + + // These methods are listed in alphabetical order, and, although + // it is isn't strictly required, follow a naming convention + // checkClass, where Class is the AST class, where possible. + + @Check(CheckType.FAST) + public void checkAction(Action action) { + checkName(action.getName(), Literals.VARIABLE__NAME); + if (action.getOrigin() == ActionOrigin.NONE) { + error( + "Action must have modifier `logical` or `physical`.", + Literals.ACTION__ORIGIN + ); + } + if (action.getPolicy() != null && + !SPACING_VIOLATION_POLICIES.contains(action.getPolicy())) { + error( + "Unrecognized spacing violation policy: " + action.getPolicy() + + ". Available policies are: " + + String.join(", ", SPACING_VIOLATION_POLICIES) + ".", + Literals.ACTION__POLICY); + } + checkExpressionIsTime(action.getMinDelay(), Literals.ACTION__MIN_DELAY); + checkExpressionIsTime(action.getMinSpacing(), Literals.ACTION__MIN_SPACING); } - checkExpressionIsTime(action.getMinDelay(), Literals.ACTION__MIN_DELAY); - checkExpressionIsTime(action.getMinSpacing(), Literals.ACTION__MIN_SPACING); - } - - @Check(CheckType.FAST) - public void checkInitializer(Initializer init) { - if (init.isBraces() && target != Target.CPP) { - error( - "Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); - } else if (init.isParens() && target.mandatesEqualsInitializers()) { - var message = - "This syntax is deprecated in the " - + target - + " target, use an equal sign instead of parentheses for assignment."; - if (init.getExprs().size() == 1) { - message += " (run the formatter to fix this automatically)"; - } - warning(message, Literals.INITIALIZER__PARENS); - } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { - var feature = init.isBraces() ? Literals.INITIALIZER__BRACES : Literals.INITIALIZER__PARENS; - var message = - "This syntax is deprecated, do not use parentheses or braces but an equal sign."; - if (init.getExprs().size() == 1) { - message += " (run the formatter to fix this automatically)"; - } - warning(message, feature); + + + @Check(CheckType.FAST) + public void checkInitializer(Initializer init) { + if (init.isBraces() && target != Target.CPP) { + error("Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); + } else if (init.isParens() && target.mandatesEqualsInitializers()) { + var message = "This syntax is deprecated in the " + target + + " target, use an equal sign instead of parentheses for assignment."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, Literals.INITIALIZER__PARENS); + } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { + var feature = init.isBraces() ? Literals.INITIALIZER__BRACES + : Literals.INITIALIZER__PARENS; + var message = "This syntax is deprecated, do not use parentheses or braces but an equal sign."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, feature); + } } - } - - @Check(CheckType.FAST) - public void checkBracedExpression(BracedListExpression expr) { - if (!target.allowsBracedListExpressions()) { - var message = - "Braced expression lists are not a valid expression for the " + target + " target."; - error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); + + @Check(CheckType.FAST) + public void checkBracedExpression(BracedListExpression expr) { + if (!target.allowsBracedListExpressions()) { + var message = "Braced expression lists are not a valid expression for the " + target + + " target."; + error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); + } } - } - - @Check(CheckType.FAST) - public void checkAssignment(Assignment assignment) { - - // If the left-hand side is a time parameter, make sure the assignment has units - typeCheck( - assignment.getRhs(), - ASTUtils.getInferredType(assignment.getLhs()), - Literals.ASSIGNMENT__RHS); - // If this assignment overrides a parameter that is used in a deadline, - // report possible overflow. - if (isCBasedTarget() && this.info.overflowingAssignments.contains(assignment)) { - error( - "Time value used to specify a deadline exceeds the maximum of " - + TimeValue.MAX_LONG_DEADLINE - + " nanoseconds.", - Literals.ASSIGNMENT__RHS); + + @Check(CheckType.FAST) + public void checkAssignment(Assignment assignment) { + + // If the left-hand side is a time parameter, make sure the assignment has units + typeCheck(assignment.getRhs(), ASTUtils.getInferredType(assignment.getLhs()), Literals.ASSIGNMENT__RHS); + // If this assignment overrides a parameter that is used in a deadline, + // report possible overflow. + if (isCBasedTarget() && + this.info.overflowingAssignments.contains(assignment)) { + error( + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.ASSIGNMENT__RHS); + } + } - } - @Check(CheckType.FAST) - public void checkConnection(Connection connection) { + @Check(CheckType.FAST) + public void checkConnection(Connection connection) { - // Report if connection is part of a cycle. - Set> cycles = this.info.topologyCycles(); - for (VarRef lp : connection.getLeftPorts()) { - for (VarRef rp : connection.getRightPorts()) { - boolean leftInCycle = false; + // Report if connection is part of a cycle. + Set> cycles = this.info.topologyCycles(); + for (VarRef lp : connection.getLeftPorts()) { + for (VarRef rp : connection.getRightPorts()) { + boolean leftInCycle = false; - for (NamedInstance it : cycles) { - if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) - || (it.getDefinition().equals(lp.getVariable()) - && it.getParent().equals(lp.getContainer()))) { - leftInCycle = true; - break; - } + for (NamedInstance it : cycles) { + if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) + || (it.getDefinition().equals(lp.getVariable()) && it.getParent().equals(lp.getContainer()))) { + leftInCycle = true; + break; + } + } + + for (NamedInstance it : cycles) { + if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) + || (it.getDefinition().equals(rp.getVariable()) && it.getParent().equals(rp.getContainer()))) { + if (leftInCycle) { + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + String reactorName = reactor.getName(); + error(String.format("Connection in reactor %s creates", reactorName) + + String.format("a cyclic dependency between %s and %s.", toOriginalText(lp), toOriginalText(rp)), + Literals.CONNECTION__DELAY); + } + } + } + } } - for (NamedInstance it : cycles) { - if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) - || (it.getDefinition().equals(rp.getVariable()) - && it.getParent().equals(rp.getContainer()))) { - if (leftInCycle) { - Reactor reactor = ASTUtils.getEnclosingReactor(connection); - String reactorName = reactor.getName(); - error( - String.format("Connection in reactor %s creates", reactorName) - + String.format( - "a cyclic dependency between %s and %s.", - toOriginalText(lp), toOriginalText(rp)), - Literals.CONNECTION__DELAY); + // FIXME: look up all ReactorInstance objects that have a definition equal to the + // container of this connection. For each of those occurrences, the widths have to match. + // For the C target, since C has such a weak type system, check that + // the types on both sides of every connection match. For other languages, + // we leave type compatibility that language's compiler or interpreter. + if (isCBasedTarget()) { + Type type = (Type) null; + for (VarRef port : connection.getLeftPorts()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + // Unfortunately, xtext does not generate a suitable equals() + // method for AST types, so we have to manually check the types. + if (!sameType(type, ((Port) port.getVariable()).getType())) { + error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); + } + } + } + } + for (VarRef port : connection.getRightPorts()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + if (!sameType(type, type = ((Port) port.getVariable()).getType())) { + error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); + } + } + } } - } } - } - } - // FIXME: look up all ReactorInstance objects that have a definition equal to the - // container of this connection. For each of those occurrences, the widths have to match. - // For the C target, since C has such a weak type system, check that - // the types on both sides of every connection match. For other languages, - // we leave type compatibility that language's compiler or interpreter. - if (isCBasedTarget()) { - Type type = (Type) null; - for (VarRef port : connection.getLeftPorts()) { - // If the variable is not a port, then there is some other - // error. Avoid a class cast exception. - if (port.getVariable() instanceof Port) { - if (type == null) { - type = ((Port) port.getVariable()).getType(); - } else { - // Unfortunately, xtext does not generate a suitable equals() - // method for AST types, so we have to manually check the types. - if (!sameType(type, ((Port) port.getVariable()).getType())) { - error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); + // Check whether the total width of the left side of the connection + // matches the total width of the right side. This cannot be determined + // here if the width is not given as a constant. In that case, it is up + // to the code generator to check it. + int leftWidth = 0; + for (VarRef port : connection.getLeftPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || leftWidth < 0) { + // Cannot determine the width of the left ports. + leftWidth = -1; + } else { + leftWidth += width; } - } } - } - for (VarRef port : connection.getRightPorts()) { - // If the variable is not a port, then there is some other - // error. Avoid a class cast exception. - if (port.getVariable() instanceof Port) { - if (type == null) { - type = ((Port) port.getVariable()).getType(); - } else { - if (!sameType(type, type = ((Port) port.getVariable()).getType())) { - error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); + int rightWidth = 0; + for (VarRef port : connection.getRightPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || rightWidth < 0) { + // Cannot determine the width of the left ports. + rightWidth = -1; + } else { + rightWidth += width; } - } } - } - } - // Check whether the total width of the left side of the connection - // matches the total width of the right side. This cannot be determined - // here if the width is not given as a constant. In that case, it is up - // to the code generator to check it. - int leftWidth = 0; - for (VarRef port : connection.getLeftPorts()) { - int width = inferPortWidth(port, null, null); // null args imply incomplete check. - if (width < 0 || leftWidth < 0) { - // Cannot determine the width of the left ports. - leftWidth = -1; - } else { - leftWidth += width; - } - } - int rightWidth = 0; - for (VarRef port : connection.getRightPorts()) { - int width = inferPortWidth(port, null, null); // null args imply incomplete check. - if (width < 0 || rightWidth < 0) { - // Cannot determine the width of the left ports. - rightWidth = -1; - } else { - rightWidth += width; - } - } + if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { + if (connection.isIterated()) { + if (leftWidth == 0 || rightWidth % leftWidth != 0) { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning(String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS + ); + } + } else { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning(String.format("Left width %s does not match right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS + ); + } + } - if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { - if (connection.isIterated()) { - if (leftWidth == 0 || rightWidth % leftWidth != 0) { - // FIXME: The second argument should be Literals.CONNECTION, but - // stupidly, xtext will not accept that. There seems to be no way to - // report an error for the whole connection statement. - warning( - String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), - Literals.CONNECTION__LEFT_PORTS); - } - } else { - // FIXME: The second argument should be Literals.CONNECTION, but - // stupidly, xtext will not accept that. There seems to be no way to - // report an error for the whole connection statement. - warning( - String.format("Left width %s does not match right width %s", leftWidth, rightWidth), - Literals.CONNECTION__LEFT_PORTS); - } - } + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + + // Make sure the right port is not already an effect of a reaction. + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + for (VarRef effect : reaction.getEffects()) { + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort.getVariable().equals(effect.getVariable()) && // Refers to the same variable + rightPort.getContainer() == effect.getContainer() && // Refers to the same instance + ( reaction.eContainer() instanceof Reactor || // Either is not part of a mode + connection.eContainer() instanceof Reactor || + connection.eContainer() == reaction.eContainer() // Or they are in the same mode + )) { + error("Cannot connect: Port named '" + effect.getVariable().getName() + + "' is already effect of a reaction.", + Literals.CONNECTION__RIGHT_PORTS); + } + } + } + } - Reactor reactor = ASTUtils.getEnclosingReactor(connection); - - // Make sure the right port is not already an effect of a reaction. - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - for (VarRef effect : reaction.getEffects()) { - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort.getVariable().equals(effect.getVariable()) - && // Refers to the same variable - rightPort.getContainer() == effect.getContainer() - && // Refers to the same instance - (reaction.eContainer() instanceof Reactor - || // Either is not part of a mode - connection.eContainer() instanceof Reactor - || connection.eContainer() - == reaction.eContainer() // Or they are in the same mode - )) { - error( - "Cannot connect: Port named '" - + effect.getVariable().getName() - + "' is already effect of a reaction.", - Literals.CONNECTION__RIGHT_PORTS); - } + // Check that the right port does not already have some other + // upstream connection. + for (Connection c : reactor.getConnections()) { + if (c != connection) { + for (VarRef thisRightPort : connection.getRightPorts()) { + for (VarRef thatRightPort : c.getRightPorts()) { + if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) && // Refers to the same variable + thisRightPort.getContainer() == thatRightPort.getContainer() && // Refers to the same instance + ( connection.eContainer() instanceof Reactor || // Or either of the connections in not part of a mode + c.eContainer() instanceof Reactor || + connection.eContainer() == c.eContainer() // Or they are in the same mode + )) { + error( + "Cannot connect: Port named '" + thisRightPort.getVariable().getName() + + "' may only appear once on the right side of a connection.", + Literals.CONNECTION__RIGHT_PORTS); + } + } + } + } } - } - } - // Check that the right port does not already have some other - // upstream connection. - for (Connection c : reactor.getConnections()) { - if (c != connection) { - for (VarRef thisRightPort : connection.getRightPorts()) { - for (VarRef thatRightPort : c.getRightPorts()) { - if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) - && // Refers to the same variable - thisRightPort.getContainer() == thatRightPort.getContainer() - && // Refers to the same instance - (connection.eContainer() instanceof Reactor - || // Or either of the connections in not part of a mode - c.eContainer() instanceof Reactor - || connection.eContainer() == c.eContainer() // Or they are in the same mode - )) { - error( - "Cannot connect: Port named '" - + thisRightPort.getVariable().getName() - + "' may only appear once on the right side of a connection.", - Literals.CONNECTION__RIGHT_PORTS); + // Check the after delay + if (connection.getDelay() != null) { + final var delay = connection.getDelay(); + if (delay instanceof ParameterReference || delay instanceof Time || delay instanceof Literal) { + checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); + } else { + error("After delays can only be given by time literals or parameters.", + Literals.CONNECTION__DELAY); } - } } - } } - // Check the after delay - if (connection.getDelay() != null) { - final var delay = connection.getDelay(); - if (delay instanceof ParameterReference - || delay instanceof Time - || delay instanceof Literal) { - checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); - } else { - error( - "After delays can only be given by time literals or parameters.", - Literals.CONNECTION__DELAY); - } - } - } - - @Check(CheckType.FAST) - public void checkDeadline(Deadline deadline) { - if (isCBasedTarget() && this.info.overflowingDeadlines.contains(deadline)) { - error( - "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.DEADLINE__DELAY); - } - checkExpressionIsTime(deadline.getDelay(), Literals.DEADLINE__DELAY); - } - - @Check(CheckType.FAST) - public void checkHost(Host host) { - String addr = host.getAddr(); - String user = host.getUser(); - if (user != null && !user.matches(USERNAME_REGEX)) { - warning("Invalid user name.", Literals.HOST__USER); - } - if (host instanceof IPV4Host && !addr.matches(IPV4_REGEX)) { - warning("Invalid IP address.", Literals.HOST__ADDR); - } else if (host instanceof IPV6Host && !addr.matches(IPV6_REGEX)) { - warning("Invalid IP address.", Literals.HOST__ADDR); - } else if (host instanceof NamedHost && !addr.matches(HOST_OR_FQN_REGEX)) { - warning("Invalid host name or fully qualified domain name.", Literals.HOST__ADDR); + @Check(CheckType.FAST) + public void checkDeadline(Deadline deadline) { + if (isCBasedTarget() && + this.info.overflowingDeadlines.contains(deadline)) { + error( + "Deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.DEADLINE__DELAY); + } + checkExpressionIsTime(deadline.getDelay(), Literals.DEADLINE__DELAY); } - } - @Check - public void checkImport(Import imp) { - if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { - error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. - return; + @Check(CheckType.FAST) + public void checkHost(Host host) { + String addr = host.getAddr(); + String user = host.getUser(); + if (user != null && !user.matches(USERNAME_REGEX)) { + warning( + "Invalid user name.", + Literals.HOST__USER + ); + } + if (host instanceof IPV4Host && !addr.matches(IPV4_REGEX)) { + warning( + "Invalid IP address.", + Literals.HOST__ADDR + ); + } else if (host instanceof IPV6Host && !addr.matches(IPV6_REGEX)) { + warning( + "Invalid IP address.", + Literals.HOST__ADDR + ); + } else if (host instanceof NamedHost && !addr.matches(HOST_OR_FQN_REGEX)) { + warning( + "Invalid host name or fully qualified domain name.", + Literals.HOST__ADDR + ); + } } - // FIXME: report error if resource cannot be resolved. - for (ImportedReactor reactor : imp.getReactorClasses()) { - if (!isUnused(reactor)) { - return; - } - } - warning("Unused import.", Literals.IMPORT__IMPORT_URI); - } + @Check + public void checkImport(Import imp) { + if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { + error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. + return; + } - @Check - public void checkImportedReactor(ImportedReactor reactor) { - if (isUnused(reactor)) { - warning("Unused reactor class.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); + // FIXME: report error if resource cannot be resolved. + for (ImportedReactor reactor : imp.getReactorClasses()) { + if (!isUnused(reactor)) { + return; + } + } + warning("Unused import.", Literals.IMPORT__IMPORT_URI); } - if (info.instantiationGraph.hasCycles()) { - Set cycleSet = new HashSet<>(); - for (Set cycle : info.instantiationGraph.getCycles()) { - cycleSet.addAll(cycle); - } - if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { - error( - "Imported reactor '" - + toDefinition(reactor).getName() - + "' has cyclic instantiation in it.", - Literals.IMPORTED_REACTOR__REACTOR_CLASS); - } - } - } + @Check + public void checkImportedReactor(ImportedReactor reactor) { + if (isUnused(reactor)) { + warning("Unused reactor class.", + Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } - @Check(CheckType.FAST) - public void checkInput(Input input) { - Reactor parent = (Reactor) input.eContainer(); - if (parent.isMain() || parent.isFederated()) { - error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); - } - checkName(input.getName(), Literals.VARIABLE__NAME); - if (target.requiresTypes) { - if (input.getType() == null) { - error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); - } + if (info.instantiationGraph.hasCycles()) { + Set cycleSet = new HashSet<>(); + for (Set cycle : info.instantiationGraph.getCycles()) { + cycleSet.addAll(cycle); + } + if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { + error("Imported reactor '" + toDefinition(reactor).getName() + + "' has cyclic instantiation in it.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } + } } - // mutable has no meaning in C++ - if (input.isMutable() && this.target == Target.CPP) { - warning( - "The mutable qualifier has no meaning for the C++ target and should be removed. " - + "In C++, any value can be made mutable by calling get_mutable_copy().", - Literals.INPUT__MUTABLE); - } + @Check(CheckType.FAST) + public void checkInput(Input input) { + Reactor parent = (Reactor)input.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); + } + checkName(input.getName(), Literals.VARIABLE__NAME); + if (target.requiresTypes) { + if (input.getType() == null) { + error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); + } + } - // Variable width multiports are not supported (yet?). - if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { - error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); - } - } - - @Check(CheckType.FAST) - public void checkInstantiation(Instantiation instantiation) { - checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); - Reactor reactor = toDefinition(instantiation.getReactorClass()); - if (reactor.isMain() || reactor.isFederated()) { - error( - "Cannot instantiate a main (or federated) reactor: " - + instantiation.getReactorClass().getName(), - Literals.INSTANTIATION__REACTOR_CLASS); + // mutable has no meaning in C++ + if (input.isMutable() && this.target == Target.CPP) { + warning( + "The mutable qualifier has no meaning for the C++ target and should be removed. " + + "In C++, any value can be made mutable by calling get_mutable_copy().", + Literals.INPUT__MUTABLE + ); + } + + // Variable width multiports are not supported (yet?). + if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } } - // Report error if this instantiation is part of a cycle. - // FIXME: improve error message. - // FIXME: Also report if there exists a cycle within. - if (this.info.instantiationGraph.getCycles().size() > 0) { - for (Set cycle : this.info.instantiationGraph.getCycles()) { - Reactor container = (Reactor) instantiation.eContainer(); - if (cycle.contains(container) && cycle.contains(reactor)) { - List names = new ArrayList<>(); - for (Reactor r : cycle) { - names.add(r.getName()); - } + @Check(CheckType.FAST) + public void checkInstantiation(Instantiation instantiation) { + checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); + Reactor reactor = toDefinition(instantiation.getReactorClass()); + if (reactor.isMain() || reactor.isFederated()) { + error( + "Cannot instantiate a main (or federated) reactor: " + + instantiation.getReactorClass().getName(), + Literals.INSTANTIATION__REACTOR_CLASS + ); + } - error( - "Instantiation is part of a cycle: " + String.join(", ", names) + ".", - Literals.INSTANTIATION__REACTOR_CLASS); + // Report error if this instantiation is part of a cycle. + // FIXME: improve error message. + // FIXME: Also report if there exists a cycle within. + if (this.info.instantiationGraph.getCycles().size() > 0) { + for (Set cycle : this.info.instantiationGraph.getCycles()) { + Reactor container = (Reactor) instantiation.eContainer(); + if (cycle.contains(container) && cycle.contains(reactor)) { + List names = new ArrayList<>(); + for (Reactor r : cycle) { + names.add(r.getName()); + } + + error( + "Instantiation is part of a cycle: " + String.join(", ", names) + ".", + Literals.INSTANTIATION__REACTOR_CLASS + ); + } + } + } + // Variable width multiports are not supported (yet?). + if (instantiation.getWidthSpec() != null + && instantiation.getWidthSpec().isOfVariableLength() + ) { + if (isCBasedTarget()) { + warning("Variable-width banks are for internal use only.", + Literals.INSTANTIATION__WIDTH_SPEC + ); + } else { + error("Variable-width banks are not supported.", + Literals.INSTANTIATION__WIDTH_SPEC + ); + } } - } - } - // Variable width multiports are not supported (yet?). - if (instantiation.getWidthSpec() != null && instantiation.getWidthSpec().isOfVariableLength()) { - if (isCBasedTarget()) { - warning( - "Variable-width banks are for internal use only.", Literals.INSTANTIATION__WIDTH_SPEC); - } else { - error("Variable-width banks are not supported.", Literals.INSTANTIATION__WIDTH_SPEC); - } - } - } - - /** Check target parameters, which are key-value pairs. */ - @Check(CheckType.FAST) - public void checkKeyValuePair(KeyValuePair param) { - // Check only if the container's container is a Target. - if (param.eContainer().eContainer() instanceof TargetDecl) { - TargetProperty prop = TargetProperty.forName(param.getName()); - - // Make sure the key is valid. - if (prop == null) { - String options = - TargetProperty.getOptions().stream() - .map(p -> p.description) - .sorted() - .collect(Collectors.joining(", ")); - warning( - "Unrecognized target parameter: " - + param.getName() - + ". Recognized parameters are: " - + options, - Literals.KEY_VALUE_PAIR__NAME); - } else { - // Check whether the property is supported by the target. - if (!prop.supportedBy.contains(this.target)) { - warning( - "The target parameter: " - + param.getName() - + " is not supported by the " - + this.target - + " target and will thus be ignored.", - Literals.KEY_VALUE_PAIR__NAME); - } - - // Report problem with the assigned value. - prop.type.check(param.getValue(), param.getName(), this); - } - - for (String it : targetPropertyErrors) { - error(it, Literals.KEY_VALUE_PAIR__VALUE); - } - targetPropertyErrors.clear(); - - for (String it : targetPropertyWarnings) { - error(it, Literals.KEY_VALUE_PAIR__VALUE); - } - targetPropertyWarnings.clear(); - } - } - - @Check(CheckType.FAST) - public void checkModel(Model model) { - // Since we're doing a fast check, we only want to update - // if the model info hasn't been initialized yet. If it has, - // we use the old information and update it during a normal - // check (see below). - if (!info.updated) { - info.update(model, errorReporter); - } - } - - @Check(CheckType.NORMAL) - public void updateModelInfo(Model model) { - info.update(model, errorReporter); - } - - @Check(CheckType.FAST) - public void checkOutput(Output output) { - Reactor parent = (Reactor) output.eContainer(); - if (parent.isMain() || parent.isFederated()) { - error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); - } - checkName(output.getName(), Literals.VARIABLE__NAME); - if (this.target.requiresTypes) { - if (output.getType() == null) { - error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); - } } - // Variable width multiports are not supported (yet?). - if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { - error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); - } - } + /** Check target parameters, which are key-value pairs. */ + @Check(CheckType.FAST) + public void checkKeyValuePair(KeyValuePair param) { + // Check only if the container's container is a Target. + if (param.eContainer().eContainer() instanceof TargetDecl) { + TargetProperty prop = TargetProperty.forName(param.getName()); + + // Make sure the key is valid. + if (prop == null) { + String options = TargetProperty.getOptions().stream() + .map(p -> p.description).sorted() + .collect(Collectors.joining(", ")); + warning( + "Unrecognized target parameter: " + param.getName() + + ". Recognized parameters are: " + options, + Literals.KEY_VALUE_PAIR__NAME); + } else { + // Check whether the property is supported by the target. + if (!prop.supportedBy.contains(this.target)) { + warning( + "The target parameter: " + param.getName() + + " is not supported by the " + this.target + + " target and will thus be ignored.", + Literals.KEY_VALUE_PAIR__NAME); + } - @Check(CheckType.FAST) - public void checkParameter(Parameter param) { - checkName(param.getName(), Literals.PARAMETER__NAME); + // Report problem with the assigned value. + prop.type.check(param.getValue(), param.getName(), this); + } - if (param.getInit() == null) { - // todo make initialization non-mandatory - // https://github.com/lf-lang/lingua-franca/issues/623 - error("Parameter must have a default value.", Literals.PARAMETER__INIT); - return; + for (String it : targetPropertyErrors) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyErrors.clear(); + + for (String it : targetPropertyWarnings) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyWarnings.clear(); + } } - if (this.target.requiresTypes) { - // Report missing target type. param.inferredType.undefine - if (ASTUtils.getInferredType(param).isUndefined()) { - error("Type declaration missing.", Literals.PARAMETER__TYPE); - } + @Check(CheckType.FAST) + public void checkModel(Model model) { + // Since we're doing a fast check, we only want to update + // if the model info hasn't been initialized yet. If it has, + // we use the old information and update it during a normal + // check (see below). + if (!info.updated) { + info.update(model, errorReporter); + } } - if (param.getType() != null) { - typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); + @Check(CheckType.NORMAL) + public void updateModelInfo(Model model) { + info.update(model, errorReporter); } - if (param.getInit() != null) { - for (Expression expr : param.getInit().getExprs()) { - if (expr instanceof ParameterReference) { - // Initialization using parameters is forbidden. - error("Parameter cannot be initialized using parameter.", Literals.PARAMETER__INIT); + @Check(CheckType.FAST) + public void checkOutput(Output output) { + Reactor parent = (Reactor)output.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); + } + checkName(output.getName(), Literals.VARIABLE__NAME); + if (this.target.requiresTypes) { + if (output.getType() == null) { + error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); + } } - } - } - if (this.target == Target.CPP) { - EObject container = param.eContainer(); - Reactor reactor = (Reactor) container; - if (reactor.isMain()) { - // we need to check for the cli parameters that are always taken - List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); - if (cliParams.contains(param.getName())) { - error( - "Parameter '" - + param.getName() - + "' is already in use as command line argument by Lingua Franca,", - Literals.PARAMETER__NAME); - } - } + // Variable width multiports are not supported (yet?). + if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } } - if (isCBasedTarget() && this.info.overflowingParameters.contains(param)) { - error( - "Time value used to specify a deadline exceeds the maximum of " - + TimeValue.MAX_LONG_DEADLINE - + " nanoseconds.", - Literals.PARAMETER__INIT); - } - } - - @Check(CheckType.FAST) - public void checkPreamble(Preamble preamble) { - if (this.target == Target.CPP) { - if (preamble.getVisibility() == Visibility.NONE) { - error( - "Preambles for the C++ target need a visibility qualifier (private or public)!", - Literals.PREAMBLE__VISIBILITY); - } else if (preamble.getVisibility() == Visibility.PRIVATE) { - EObject container = preamble.eContainer(); - if (container != null && container instanceof Reactor) { - Reactor reactor = (Reactor) container; - if (isGeneric(reactor)) { - warning( - "Private preambles in generic reactors are not truly private. " - + "Since the generated code is placed in a *_impl.hh file, it will " - + "be visible on the public interface. Consider using a public " - + "preamble within the reactor or a private preamble on file scope.", - Literals.PREAMBLE__VISIBILITY); - } + @Check(CheckType.FAST) + public void checkParameter(Parameter param) { + checkName(param.getName(), Literals.PARAMETER__NAME); + + if (param.getInit() == null) { + // todo make initialization non-mandatory + // https://github.com/lf-lang/lingua-franca/issues/623 + error("Parameter must have a default value.", Literals.PARAMETER__INIT); + return; + } + + if (this.target.requiresTypes) { + // Report missing target type. param.inferredType.undefine + if (ASTUtils.getInferredType(param).isUndefined()) { + error("Type declaration missing.", Literals.PARAMETER__TYPE); + } } - } - } else if (preamble.getVisibility() != Visibility.NONE) { - warning( - String.format( - "The %s qualifier has no meaning for the %s target. It should be removed.", - preamble.getVisibility(), this.target.name()), - Literals.PREAMBLE__VISIBILITY); - } - } - @Check(CheckType.FAST) - public void checkReaction(Reaction reaction) { + if (param.getType() != null) { + typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); + } - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); - } - HashSet triggers = new HashSet<>(); - // Make sure input triggers have no container and output sources do. - for (TriggerRef trigger : reaction.getTriggers()) { - if (trigger instanceof VarRef) { - VarRef triggerVarRef = (VarRef) trigger; - triggers.add(triggerVarRef.getVariable()); - if (triggerVarRef instanceof Input) { - if (triggerVarRef.getContainer() != null) { - error( - String.format( - "Cannot have an input of a contained reactor as a trigger: %s.%s", - triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), - Literals.REACTION__TRIGGERS); - } - } else if (triggerVarRef.getVariable() instanceof Output) { - if (triggerVarRef.getContainer() == null) { + if (param.getInit() != null) { + for (Expression expr : param.getInit().getExprs()) { + if (expr instanceof ParameterReference) { + // Initialization using parameters is forbidden. + error("Parameter cannot be initialized using parameter.", + Literals.PARAMETER__INIT); + } + } + } + + if (this.target == Target.CPP) { + EObject container = param.eContainer(); + Reactor reactor = (Reactor) container; + if (reactor.isMain()) { + // we need to check for the cli parameters that are always taken + List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); + if (cliParams.contains(param.getName())) { + error("Parameter '" + param.getName() + + "' is already in use as command line argument by Lingua Franca,", + Literals.PARAMETER__NAME); + } + } + } + + if (isCBasedTarget() && + this.info.overflowingParameters.contains(param)) { error( - String.format( - "Cannot have an output of this reactor as a trigger: %s", - triggerVarRef.getVariable().getName()), - Literals.REACTION__TRIGGERS); - } + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.PARAMETER__INIT); } - } - } - // Make sure input sources have no container and output sources do. - // Also check that a source is not already listed as a trigger. - for (VarRef source : reaction.getSources()) { - if (triggers.contains(source.getVariable())) { - error( - String.format( - "Source is already listed as a trigger: %s", source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - if (source.getVariable() instanceof Input) { - if (source.getContainer() != null) { - error( - String.format( - "Cannot have an input of a contained reactor as a source: %s.%s", - source.getContainer().getName(), source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - } else if (source.getVariable() instanceof Output) { - if (source.getContainer() == null) { - error( - String.format( - "Cannot have an output of this reactor as a source: %s", - source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - } } - // Make sure output effects have no container and input effects do. - for (VarRef effect : reaction.getEffects()) { - if (effect.getVariable() instanceof Input) { - if (effect.getContainer() == null) { - error( - String.format( - "Cannot have an input of this reactor as an effect: %s", - effect.getVariable().getName()), - Literals.REACTION__EFFECTS); - } - } else if (effect.getVariable() instanceof Output) { - if (effect.getContainer() != null) { - error( - String.format( - "Cannot have an output of a contained reactor as an effect: %s.%s", - effect.getContainer().getName(), effect.getVariable().getName()), - Literals.REACTION__EFFECTS); - } - } + @Check(CheckType.FAST) + public void checkPreamble(Preamble preamble) { + if (this.target == Target.CPP) { + if (preamble.getVisibility() == Visibility.NONE) { + error( + "Preambles for the C++ target need a visibility qualifier (private or public)!", + Literals.PREAMBLE__VISIBILITY + ); + } else if (preamble.getVisibility() == Visibility.PRIVATE) { + EObject container = preamble.eContainer(); + if (container != null && container instanceof Reactor) { + Reactor reactor = (Reactor) container; + if (isGeneric(reactor)) { + warning( + "Private preambles in generic reactors are not truly private. " + + "Since the generated code is placed in a *_impl.hh file, it will " + + "be visible on the public interface. Consider using a public " + + "preamble within the reactor or a private preamble on file scope.", + Literals.PREAMBLE__VISIBILITY); + } + } + } + } else if (preamble.getVisibility() != Visibility.NONE) { + warning( + String.format("The %s qualifier has no meaning for the %s target. It should be removed.", + preamble.getVisibility(), this.target.name()), + Literals.PREAMBLE__VISIBILITY + ); + } } - // // Report error if this reaction is part of a cycle. - Set> cycles = this.info.topologyCycles(); - Reactor reactor = ASTUtils.getEnclosingReactor(reaction); - boolean reactionInCycle = false; - for (NamedInstance it : cycles) { - if (it.getDefinition().equals(reaction)) { - reactionInCycle = true; - break; - } - } - if (reactionInCycle) { - // Report involved triggers. - List trigs = new ArrayList<>(); - for (TriggerRef t : reaction.getTriggers()) { - if (!(t instanceof VarRef)) { - continue; - } - VarRef tVarRef = (VarRef) t; - boolean triggerExistsInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(tVarRef.getVariable())) { - triggerExistsInCycle = true; - break; - } + @Check(CheckType.FAST) + public void checkReaction(Reaction reaction) { + + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); } - if (triggerExistsInCycle) { - trigs.add(toOriginalText(tVarRef)); - } - } - if (trigs.size() > 0) { - error( - String.format( - "Reaction triggers involved in cyclic dependency in reactor %s: %s.", - reactor.getName(), String.join(", ", trigs)), - Literals.REACTION__TRIGGERS); - } - - // Report involved sources. - List sources = new ArrayList<>(); - for (VarRef t : reaction.getSources()) { - boolean sourceExistInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(t.getVariable())) { - sourceExistInCycle = true; - break; - } + HashSet triggers = new HashSet<>(); + // Make sure input triggers have no container and output sources do. + for (TriggerRef trigger : reaction.getTriggers()) { + if (trigger instanceof VarRef) { + VarRef triggerVarRef = (VarRef) trigger; + triggers.add(triggerVarRef.getVariable()); + if (triggerVarRef instanceof Input) { + if (triggerVarRef.getContainer() != null) { + error(String.format("Cannot have an input of a contained reactor as a trigger: %s.%s", triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } + } else if (triggerVarRef.getVariable() instanceof Output) { + if (triggerVarRef.getContainer() == null) { + error(String.format("Cannot have an output of this reactor as a trigger: %s", triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } + } + } } - if (sourceExistInCycle) { - sources.add(toOriginalText(t)); - } - } - if (sources.size() > 0) { - error( - String.format( - "Reaction sources involved in cyclic dependency in reactor %s: %s.", - reactor.getName(), String.join(", ", sources)), - Literals.REACTION__SOURCES); - } - - // Report involved effects. - List effects = new ArrayList<>(); - for (VarRef t : reaction.getEffects()) { - boolean effectExistInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(t.getVariable())) { - effectExistInCycle = true; - break; - } + + // Make sure input sources have no container and output sources do. + // Also check that a source is not already listed as a trigger. + for (VarRef source : reaction.getSources()) { + if (triggers.contains(source.getVariable())) { + error(String.format("Source is already listed as a trigger: %s", source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + if (source.getVariable() instanceof Input) { + if (source.getContainer() != null) { + error(String.format("Cannot have an input of a contained reactor as a source: %s.%s", source.getContainer().getName(), source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } else if (source.getVariable() instanceof Output) { + if (source.getContainer() == null) { + error(String.format("Cannot have an output of this reactor as a source: %s", source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } + } + + // Make sure output effects have no container and input effects do. + for (VarRef effect : reaction.getEffects()) { + if (effect.getVariable() instanceof Input) { + if (effect.getContainer() == null) { + error(String.format("Cannot have an input of this reactor as an effect: %s", effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } else if (effect.getVariable() instanceof Output) { + if (effect.getContainer() != null) { + error(String.format("Cannot have an output of a contained reactor as an effect: %s.%s", effect.getContainer().getName(), effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } + } + + // // Report error if this reaction is part of a cycle. + Set> cycles = this.info.topologyCycles(); + Reactor reactor = ASTUtils.getEnclosingReactor(reaction); + boolean reactionInCycle = false; + for (NamedInstance it : cycles) { + if (it.getDefinition().equals(reaction)) { + reactionInCycle = true; + break; + } + } + if (reactionInCycle) { + // Report involved triggers. + List trigs = new ArrayList<>(); + for (TriggerRef t : reaction.getTriggers()) { + if (!(t instanceof VarRef)) { + continue; + } + VarRef tVarRef = (VarRef) t; + boolean triggerExistsInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(tVarRef.getVariable())) { + triggerExistsInCycle = true; + break; + } + } + if (triggerExistsInCycle) { + trigs.add(toOriginalText(tVarRef)); + } + } + if (trigs.size() > 0) { + error(String.format("Reaction triggers involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", trigs)), + Literals.REACTION__TRIGGERS); + } + + // Report involved sources. + List sources = new ArrayList<>(); + for (VarRef t : reaction.getSources()) { + boolean sourceExistInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(t.getVariable())) { + sourceExistInCycle = true; + break; + } + } + if (sourceExistInCycle) { + sources.add(toOriginalText(t)); + } + } + if (sources.size() > 0) { + error(String.format("Reaction sources involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", sources)), + Literals.REACTION__SOURCES); + } + + // Report involved effects. + List effects = new ArrayList<>(); + for (VarRef t : reaction.getEffects()) { + boolean effectExistInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(t.getVariable())) { + effectExistInCycle = true; + break; + } + } + if (effectExistInCycle) { + effects.add(toOriginalText(t)); + } + } + if (effects.size() > 0) { + error(String.format("Reaction effects involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", effects)), + Literals.REACTION__EFFECTS); + } + + if (trigs.size() + sources.size() == 0) { + error( + String.format("Cyclic dependency due to preceding reaction. Consider reordering reactions within reactor %s to avoid causality loop.", reactor.getName()), + reaction.eContainer(), + Literals.REACTOR__REACTIONS, + reactor.getReactions().indexOf(reaction) + ); + } else if (effects.size() == 0) { + error( + String.format("Cyclic dependency due to succeeding reaction. Consider reordering reactions within reactor %s to avoid causality loop.", reactor.getName()), + reaction.eContainer(), + Literals.REACTOR__REACTIONS, + reactor.getReactions().indexOf(reaction) + ); + } + // Not reporting reactions that are part of cycle _only_ due to reaction ordering. + // Moving them won't help solve the problem. } - if (effectExistInCycle) { - effects.add(toOriginalText(t)); - } - } - if (effects.size() > 0) { - error( - String.format( - "Reaction effects involved in cyclic dependency in reactor %s: %s.", - reactor.getName(), String.join(", ", effects)), - Literals.REACTION__EFFECTS); - } - - if (trigs.size() + sources.size() == 0) { - error( - String.format( - "Cyclic dependency due to preceding reaction. Consider reordering reactions within" - + " reactor %s to avoid causality loop.", - reactor.getName()), - reaction.eContainer(), - Literals.REACTOR__REACTIONS, - reactor.getReactions().indexOf(reaction)); - } else if (effects.size() == 0) { - error( - String.format( - "Cyclic dependency due to succeeding reaction. Consider reordering reactions within" - + " reactor %s to avoid causality loop.", - reactor.getName()), - reaction.eContainer(), - Literals.REACTOR__REACTIONS, - reactor.getReactions().indexOf(reaction)); - } - // Not reporting reactions that are part of cycle _only_ due to reaction ordering. - // Moving them won't help solve the problem. - } // FIXME: improve error message. - } - - @Check(CheckType.FAST) - public void checkReactor(Reactor reactor) throws IOException { - Set superClasses = ASTUtils.superClasses(reactor); - if (superClasses == null) { - error( - "Problem with superclasses: Either they form a cycle or are not defined", - Literals.REACTOR_DECL__NAME); - // Continue checks, but without any superclasses. - superClasses = new LinkedHashSet<>(); - } - String name = FileUtil.nameWithoutExtension(reactor.eResource()); - if (reactor.getName() == null) { - if (!reactor.isFederated() && !reactor.isMain()) { - error("Reactor must be named.", Literals.REACTOR_DECL__NAME); - // Prevent NPE in tests below. - return; - } } - TreeIterator iter = reactor.eResource().getAllContents(); - if (reactor.isFederated() || reactor.isMain()) { - if (reactor.getName() != null && !reactor.getName().equals(name)) { - // Make sure that if the name is given, it matches the expected name. - error( - "Name of main reactor must match the file name (or be omitted).", - Literals.REACTOR_DECL__NAME); - } - // Do not allow multiple main/federated reactors. - int nMain = countMainOrFederated(iter); - if (nMain > 1) { - EAttribute attribute = Literals.REACTOR__MAIN; + + @Check(CheckType.FAST) + public void checkReactor(Reactor reactor) throws IOException { + Set superClasses = ASTUtils.superClasses(reactor); + if (superClasses == null) { + error( + "Problem with superclasses: Either they form a cycle or are not defined", + Literals.REACTOR_DECL__NAME + ); + // Continue checks, but without any superclasses. + superClasses = new LinkedHashSet<>(); + } + String name = FileUtil.nameWithoutExtension(reactor.eResource()); + if (reactor.getName() == null) { + if (!reactor.isFederated() && !reactor.isMain()) { + error( + "Reactor must be named.", + Literals.REACTOR_DECL__NAME + ); + // Prevent NPE in tests below. + return; + } + } + TreeIterator iter = reactor.eResource().getAllContents(); + if (reactor.isFederated() || reactor.isMain()) { + if(reactor.getName() != null && !reactor.getName().equals(name)) { + // Make sure that if the name is given, it matches the expected name. + error( + "Name of main reactor must match the file name (or be omitted).", + Literals.REACTOR_DECL__NAME + ); + } + // Do not allow multiple main/federated reactors. + int nMain = countMainOrFederated(iter); + if (nMain > 1) { + EAttribute attribute = Literals.REACTOR__MAIN; + if (reactor.isFederated()) { + attribute = Literals.REACTOR__FEDERATED; + } + error( + "Multiple definitions of main or federated reactor.", + attribute + ); + } + } else { + // Not federated or main. + int nMain = countMainOrFederated(iter); + if (nMain > 0 && reactor.getName().equals(name)) { + error( + "Name conflict with main reactor.", + Literals.REACTOR_DECL__NAME + ); + } + } + + // Check for illegal names. + checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); + + // C++ reactors may not be called 'preamble' + if (this.target == Target.CPP && reactor.getName().equalsIgnoreCase("preamble")) { + error( + "Reactor cannot be named '" + reactor.getName() + "'", + Literals.REACTOR_DECL__NAME + ); + } + + if (reactor.getHost() != null) { + if (!reactor.isFederated()) { + error( + "Cannot assign a host to reactor '" + reactor.getName() + + "' because it is not federated.", + Literals.REACTOR__HOST + ); + } + } + + List variables = new ArrayList<>(); + variables.addAll(reactor.getInputs()); + variables.addAll(reactor.getOutputs()); + variables.addAll(reactor.getActions()); + variables.addAll(reactor.getTimers()); + + // Perform checks on super classes. + for (Reactor superClass : superClasses) { + HashSet conflicts = new HashSet<>(); + + // Detect input conflicts + checkConflict(superClass.getInputs(), reactor.getInputs(), variables, conflicts); + // Detect output conflicts + checkConflict(superClass.getOutputs(), reactor.getOutputs(), variables, conflicts); + // Detect output conflicts + checkConflict(superClass.getActions(), reactor.getActions(), variables, conflicts); + // Detect conflicts + for (Timer timer : superClass.getTimers()) { + List filteredVariables = new ArrayList<>(variables); + filteredVariables.removeIf(it -> reactor.getTimers().contains(it)); + if (hasNameConflict(timer, filteredVariables)) { + conflicts.add(timer); + } else { + variables.add(timer); + } + } + + // Report conflicts. + if (conflicts.size() > 0) { + List names = new ArrayList<>(); + for (Variable it : conflicts) { + names.add(it.getName()); + } + error( + String.format("Cannot extend %s due to the following conflicts: %s.", + superClass.getName(), String.join(",", names)), + Literals.REACTOR__SUPER_CLASSES + ); + } + } + if (reactor.isFederated()) { - attribute = Literals.REACTOR__FEDERATED; - } - error("Multiple definitions of main or federated reactor.", attribute); - } - } else { - // Not federated or main. - int nMain = countMainOrFederated(iter); - if (nMain > 0 && reactor.getName().equals(name)) { - error("Name conflict with main reactor.", Literals.REACTOR_DECL__NAME); - } + FedValidator.validateFederatedReactor(reactor, this.errorReporter); + } } - // Check for illegal names. - checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); + /** + * Check if the requested serialization is supported. + */ + @Check(CheckType.FAST) + public void checkSerializer(Serializer serializer) { + boolean isValidSerializer = false; + for (SupportedSerializers method : SupportedSerializers.values()) { + if (method.name().equalsIgnoreCase(serializer.getType())){ + isValidSerializer = true; + } + } - // C++ reactors may not be called 'preamble' - if (this.target == Target.CPP && reactor.getName().equalsIgnoreCase("preamble")) { - error("Reactor cannot be named '" + reactor.getName() + "'", Literals.REACTOR_DECL__NAME); + if (!isValidSerializer) { + error( + "Serializer can be " + Arrays.asList(SupportedSerializers.values()), + Literals.SERIALIZER__TYPE + ); + } } - if (reactor.getHost() != null) { - if (!reactor.isFederated()) { - error( - "Cannot assign a host to reactor '" - + reactor.getName() - + "' because it is not federated.", - Literals.REACTOR__HOST); - } - } + @Check(CheckType.FAST) + public void checkState(StateVar stateVar) { + checkName(stateVar.getName(), Literals.STATE_VAR__NAME); + if (stateVar.getInit() != null && stateVar.getInit().getExprs().size() != 0) { + typeCheck(stateVar.getInit(), ASTUtils.getInferredType(stateVar), Literals.STATE_VAR__INIT); + } - List variables = new ArrayList<>(); - variables.addAll(reactor.getInputs()); - variables.addAll(reactor.getOutputs()); - variables.addAll(reactor.getActions()); - variables.addAll(reactor.getTimers()); - - // Perform checks on super classes. - for (Reactor superClass : superClasses) { - HashSet conflicts = new HashSet<>(); - - // Detect input conflicts - checkConflict(superClass.getInputs(), reactor.getInputs(), variables, conflicts); - // Detect output conflicts - checkConflict(superClass.getOutputs(), reactor.getOutputs(), variables, conflicts); - // Detect output conflicts - checkConflict(superClass.getActions(), reactor.getActions(), variables, conflicts); - // Detect conflicts - for (Timer timer : superClass.getTimers()) { - List filteredVariables = new ArrayList<>(variables); - filteredVariables.removeIf(it -> reactor.getTimers().contains(it)); - if (hasNameConflict(timer, filteredVariables)) { - conflicts.add(timer); - } else { - variables.add(timer); - } - } - - // Report conflicts. - if (conflicts.size() > 0) { - List names = new ArrayList<>(); - for (Variable it : conflicts) { - names.add(it.getName()); - } - error( - String.format( - "Cannot extend %s due to the following conflicts: %s.", - superClass.getName(), String.join(",", names)), - Literals.REACTOR__SUPER_CLASSES); - } - } + if (this.target.requiresTypes && ASTUtils.getInferredType(stateVar).isUndefined()) { + // Report if a type is missing + error("State must have a type.", Literals.STATE_VAR__TYPE); + } - if (reactor.isFederated()) { - FedValidator.validateFederatedReactor(reactor, this.errorReporter); - } - } - - /** Check if the requested serialization is supported. */ - @Check(CheckType.FAST) - public void checkSerializer(Serializer serializer) { - boolean isValidSerializer = false; - for (SupportedSerializers method : SupportedSerializers.values()) { - if (method.name().equalsIgnoreCase(serializer.getType())) { - isValidSerializer = true; - } - } + if (isCBasedTarget() + && ASTUtils.isListInitializer(stateVar.getInit()) + && stateVar.getInit().getExprs().stream().anyMatch(it -> it instanceof ParameterReference)) { + // In C, if initialization is done with a list, elements cannot + // refer to parameters. + error("List items cannot refer to a parameter.", + Literals.STATE_VAR__INIT); + } - if (!isValidSerializer) { - error( - "Serializer can be " + Arrays.asList(SupportedSerializers.values()), - Literals.SERIALIZER__TYPE); } - } - @Check(CheckType.FAST) - public void checkState(StateVar stateVar) { - checkName(stateVar.getName(), Literals.STATE_VAR__NAME); - if (stateVar.getInit() != null && stateVar.getInit().getExprs().size() != 0) { - typeCheck(stateVar.getInit(), ASTUtils.getInferredType(stateVar), Literals.STATE_VAR__INIT); + @Check(CheckType.FAST) + public void checkSTPOffset(STP stp) { + if (isCBasedTarget() && + this.info.overflowingSTP.contains(stp)) { + error( + "STP offset exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.STP__VALUE); + } } - if (this.target.requiresTypes && ASTUtils.getInferredType(stateVar).isUndefined()) { - // Report if a type is missing - error("State must have a type.", Literals.STATE_VAR__TYPE); + @Check(CheckType.FAST) + public void checkTargetDecl(TargetDecl target) throws IOException { + Optional targetOpt = Target.forName(target.getName()); + if (targetOpt.isEmpty()) { + error("Unrecognized target: " + target.getName(), + Literals.TARGET_DECL__NAME); + } else { + this.target = targetOpt.get(); + } + String lfFileName = FileUtil.nameWithoutExtension(target.eResource()); + if (Character.isDigit(lfFileName.charAt(0))) { + errorReporter.reportError("LF file names must not start with a number"); + } } - if (isCBasedTarget() - && ASTUtils.isListInitializer(stateVar.getInit()) - && stateVar.getInit().getExprs().stream() - .anyMatch(it -> it instanceof ParameterReference)) { - // In C, if initialization is done with a list, elements cannot - // refer to parameters. - error("List items cannot refer to a parameter.", Literals.STATE_VAR__INIT); - } - } - - @Check(CheckType.FAST) - public void checkSTPOffset(STP stp) { - if (isCBasedTarget() && this.info.overflowingSTP.contains(stp)) { - error( - "STP offset exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.STP__VALUE); - } - } - - @Check(CheckType.FAST) - public void checkTargetDecl(TargetDecl target) throws IOException { - Optional targetOpt = Target.forName(target.getName()); - if (targetOpt.isEmpty()) { - error("Unrecognized target: " + target.getName(), Literals.TARGET_DECL__NAME); - } else { - this.target = targetOpt.get(); - } - String lfFileName = FileUtil.nameWithoutExtension(target.eResource()); - if (Character.isDigit(lfFileName.charAt(0))) { - errorReporter.reportError("LF file names must not start with a number"); - } - } - - /** - * Check for consistency of the target properties, which are defined as KeyValuePairs. - * - * @param targetProperties The target properties defined in the current Lingua Franca program. - */ - @Check(CheckType.EXPENSIVE) - public void checkTargetProperties(KeyValuePairs targetProperties) { - validateFastTargetProperty(targetProperties); - validateClockSyncTargetProperties(targetProperties); - validateSchedulerTargetProperties(targetProperties); - validateRos2TargetProperties(targetProperties); - validateKeepalive(targetProperties); - } - - private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { - List properties = - targetProperties.getPairs().stream() + /** + * Check for consistency of the target properties, which are + * defined as KeyValuePairs. + * + * @param targetProperties The target properties defined + * in the current Lingua Franca program. + */ + @Check(CheckType.EXPENSIVE) + public void checkTargetProperties(KeyValuePairs targetProperties) { + validateFastTargetProperty(targetProperties); + validateClockSyncTargetProperties(targetProperties); + validateSchedulerTargetProperties(targetProperties); + validateRos2TargetProperties(targetProperties); + validateKeepalive(targetProperties); + } + + private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { + List properties = targetProperties.getPairs().stream() .filter(pair -> pair.getName().equals(property.description)) .toList(); - assert (properties.size() <= 1); - return properties.size() > 0 ? properties.get(0) : null; - } + assert (properties.size() <= 1); + return properties.size() > 0 ? properties.get(0) : null; + } + private void validateFastTargetProperty(KeyValuePairs targetProperties) { + KeyValuePair fastTargetProperty = getKeyValuePair(targetProperties, TargetProperty.FAST); + + if (fastTargetProperty != null) { + // Check for federated + for (Reactor reactor : info.model.getReactors()) { + // Check to see if the program has a federated reactor + if (reactor.isFederated()) { + error( + "The fast target property is incompatible with federated programs.", + fastTargetProperty, + Literals.KEY_VALUE_PAIR__NAME + ); + break; + } + } + + // Check for physical actions + for (Reactor reactor : info.model.getReactors()) { + // Check to see if the program has a physical action in a reactor + for (Action action : reactor.getActions()) { + if (action.getOrigin().equals(ActionOrigin.PHYSICAL)) { + error( + "The fast target property is incompatible with physical actions.", + fastTargetProperty, + Literals.KEY_VALUE_PAIR__NAME + ); + break; + } + } + } + } + } - private void validateFastTargetProperty(KeyValuePairs targetProperties) { - KeyValuePair fastTargetProperty = getKeyValuePair(targetProperties, TargetProperty.FAST); + private void validateClockSyncTargetProperties(KeyValuePairs targetProperties) { + KeyValuePair clockSyncTargetProperty = getKeyValuePair(targetProperties, TargetProperty.CLOCK_SYNC); - if (fastTargetProperty != null) { - // Check for federated - for (Reactor reactor : info.model.getReactors()) { - // Check to see if the program has a federated reactor - if (reactor.isFederated()) { - error( - "The fast target property is incompatible with federated programs.", - fastTargetProperty, - Literals.KEY_VALUE_PAIR__NAME); - break; - } - } - - // Check for physical actions - for (Reactor reactor : info.model.getReactors()) { - // Check to see if the program has a physical action in a reactor - for (Action action : reactor.getActions()) { - if (action.getOrigin().equals(ActionOrigin.PHYSICAL)) { - error( - "The fast target property is incompatible with physical actions.", - fastTargetProperty, - Literals.KEY_VALUE_PAIR__NAME); - break; - } + if (clockSyncTargetProperty != null) { + boolean federatedExists = false; + for (Reactor reactor : info.model.getReactors()) { + if (reactor.isFederated()) { + federatedExists = true; + } + } + if (!federatedExists) { + warning( + "The clock-sync target property is incompatible with non-federated programs.", + clockSyncTargetProperty, + Literals.KEY_VALUE_PAIR__NAME + ); + } } - } } - } - private void validateClockSyncTargetProperties(KeyValuePairs targetProperties) { - KeyValuePair clockSyncTargetProperty = - getKeyValuePair(targetProperties, TargetProperty.CLOCK_SYNC); + private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { + KeyValuePair schedulerTargetProperty = getKeyValuePair(targetProperties, TargetProperty.SCHEDULER); + if (schedulerTargetProperty != null) { + String schedulerName = ASTUtils.elementToSingleString(schedulerTargetProperty.getValue()); + try { + if (!TargetProperty.SchedulerOption.valueOf(schedulerName) + .prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + // Filter reactors that contain at least one reaction that + // has a deadline handler. + if (info.model.getReactors().stream().anyMatch( + // Filter reactors that contain at least one reaction that + // has a deadline handler. + reactor -> ASTUtils.allReactions(reactor).stream().anyMatch( + reaction -> reaction.getDeadline() != null + )) + ) { + warning("This program contains deadlines, but the chosen " + + schedulerName + + " scheduler does not prioritize reaction execution " + + "based on deadlines. This might result in a sub-optimal " + + "scheduling.", schedulerTargetProperty, + Literals.KEY_VALUE_PAIR__VALUE); + } + } + } catch (IllegalArgumentException e) { + // the given scheduler is invalid, but this is already checked by + // checkTargetProperties + } + } + } - if (clockSyncTargetProperty != null) { - boolean federatedExists = false; - for (Reactor reactor : info.model.getReactors()) { - if (reactor.isFederated()) { - federatedExists = true; - } - } - if (!federatedExists) { - warning( - "The clock-sync target property is incompatible with non-federated programs.", - clockSyncTargetProperty, - Literals.KEY_VALUE_PAIR__NAME); - } + private void validateKeepalive(KeyValuePairs targetProperties) { + KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); + if (keepalive != null && target == Target.CPP) { + warning("The keepalive property is inferred automatically by the C++ " + + "runtime and the value given here is ignored", keepalive, Literals.KEY_VALUE_PAIR__NAME); + } } - } - - private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { - KeyValuePair schedulerTargetProperty = - getKeyValuePair(targetProperties, TargetProperty.SCHEDULER); - if (schedulerTargetProperty != null) { - String schedulerName = ASTUtils.elementToSingleString(schedulerTargetProperty.getValue()); - try { - if (!TargetProperty.SchedulerOption.valueOf(schedulerName).prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - // Filter reactors that contain at least one reaction that - // has a deadline handler. - if (info.model.getReactors().stream() - .anyMatch( - // Filter reactors that contain at least one reaction that - // has a deadline handler. - reactor -> - ASTUtils.allReactions(reactor).stream() - .anyMatch(reaction -> reaction.getDeadline() != null))) { + + private void validateRos2TargetProperties(KeyValuePairs targetProperties) { + KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); + KeyValuePair ros2Dependencies = getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); + if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { warning( - "This program contains deadlines, but the chosen " - + schedulerName - + " scheduler does not prioritize reaction execution " - + "based on deadlines. This might result in a sub-optimal " - + "scheduling.", - schedulerTargetProperty, - Literals.KEY_VALUE_PAIR__VALUE); - } + "Ignoring ros2-dependencies as ros2 compilation is disabled", + ros2Dependencies, + Literals.KEY_VALUE_PAIR__NAME + ); } - } catch (IllegalArgumentException e) { - // the given scheduler is invalid, but this is already checked by - // checkTargetProperties - } - } - } - - private void validateKeepalive(KeyValuePairs targetProperties) { - KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); - if (keepalive != null && target == Target.CPP) { - warning( - "The keepalive property is inferred automatically by the C++ " - + "runtime and the value given here is ignored", - keepalive, - Literals.KEY_VALUE_PAIR__NAME); } - } - - private void validateRos2TargetProperties(KeyValuePairs targetProperties) { - KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); - KeyValuePair ros2Dependencies = - getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); - if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { - warning( - "Ignoring ros2-dependencies as ros2 compilation is disabled", - ros2Dependencies, - Literals.KEY_VALUE_PAIR__NAME); + + @Check(CheckType.FAST) + public void checkTimer(Timer timer) { + checkName(timer.getName(), Literals.VARIABLE__NAME); + checkExpressionIsTime(timer.getOffset(), Literals.TIMER__OFFSET); + checkExpressionIsTime(timer.getPeriod(), Literals.TIMER__PERIOD); } - } - - @Check(CheckType.FAST) - public void checkTimer(Timer timer) { - checkName(timer.getName(), Literals.VARIABLE__NAME); - checkExpressionIsTime(timer.getOffset(), Literals.TIMER__OFFSET); - checkExpressionIsTime(timer.getPeriod(), Literals.TIMER__PERIOD); - } - - @Check(CheckType.FAST) - public void checkType(Type type) { - // FIXME: disallow the use of generics in C - if (this.target == Target.Python) { - if (type != null) { - error("Types are not allowed in the Python target", Literals.TYPE__ID); - } + + @Check(CheckType.FAST) + public void checkType(Type type) { + // FIXME: disallow the use of generics in C + if (this.target == Target.Python) { + if (type != null) { + error( + "Types are not allowed in the Python target", + Literals.TYPE__ID + ); + } + } } - } - - @Check(CheckType.FAST) - public void checkVarRef(VarRef varRef) { - // check correct usage of interleaved - if (varRef.isInterleaved()) { - var supportedTargets = List.of(Target.CPP, Target.Python, Target.Rust); - if (!supportedTargets.contains(this.target) && !isCBasedTarget()) { - error( - "This target does not support interleaved port references.", - Literals.VAR_REF__INTERLEAVED); - } - if (!(varRef.eContainer() instanceof Connection)) { - error("interleaved can only be used in connections.", Literals.VAR_REF__INTERLEAVED); - } - - if (varRef.getVariable() instanceof Port) { - // This test only works correctly if the variable is actually a port. If it is not a port, - // other - // validator rules will produce error messages. - if (varRef.getContainer() == null - || varRef.getContainer().getWidthSpec() == null - || ((Port) varRef.getVariable()).getWidthSpec() == null) { - error( - "interleaved can only be used for multiports contained within banks.", - Literals.VAR_REF__INTERLEAVED); - } - } + + @Check(CheckType.FAST) + public void checkVarRef(VarRef varRef) { + // check correct usage of interleaved + if (varRef.isInterleaved()) { + var supportedTargets = List.of(Target.CPP, Target.Python, Target.Rust); + if (!supportedTargets.contains(this.target) && !isCBasedTarget()) { + error("This target does not support interleaved port references.", Literals.VAR_REF__INTERLEAVED); + } + if (!(varRef.eContainer() instanceof Connection)) { + error("interleaved can only be used in connections.", Literals.VAR_REF__INTERLEAVED); + } + + if (varRef.getVariable() instanceof Port) { + // This test only works correctly if the variable is actually a port. If it is not a port, other + // validator rules will produce error messages. + if (varRef.getContainer() == null || varRef.getContainer().getWidthSpec() == null || + ((Port) varRef.getVariable()).getWidthSpec() == null + ) { + error("interleaved can only be used for multiports contained within banks.", Literals.VAR_REF__INTERLEAVED); + } + } + } } - } - - /** - * Check whether an attribute is supported and the validity of the attribute. - * - * @param attr The attribute being checked - */ - @Check(CheckType.FAST) - public void checkAttributes(Attribute attr) { - String name = attr.getAttrName().toString(); - AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); - if (spec == null) { - error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); - return; + + /** + * Check whether an attribute is supported + * and the validity of the attribute. + * + * @param attr The attribute being checked + */ + @Check(CheckType.FAST) + public void checkAttributes(Attribute attr) { + String name = attr.getAttrName().toString(); + AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); + if (spec == null) { + error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); + return; + } + // Check the validity of the attribute. + spec.check(this, attr); } - // Check the validity of the attribute. - spec.check(this, attr); - } - - @Check(CheckType.FAST) - public void checkWidthSpec(WidthSpec widthSpec) { - if (!this.target.supportsMultiports()) { - error( - "Multiports and banks are currently not supported by the given target.", - Literals.WIDTH_SPEC__TERMS); - } else { - for (WidthTerm term : widthSpec.getTerms()) { - if (term.getParameter() != null) { - if (!this.target.supportsParameterizedWidths()) { - error( - "Parameterized widths are not supported by this target.", + + @Check(CheckType.FAST) + public void checkWidthSpec(WidthSpec widthSpec) { + if (!this.target.supportsMultiports()) { + error("Multiports and banks are currently not supported by the given target.", Literals.WIDTH_SPEC__TERMS); - } - } else if (term.getPort() != null) { - // Widths given with `widthof()` are not supported (yet?). - // This feature is currently only used for after delays. - error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); - } else if (term.getCode() != null) { - if (this.target != Target.CPP) { - error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); - } - } else if (term.getWidth() < 0) { - error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); + } else { + for (WidthTerm term : widthSpec.getTerms()) { + if (term.getParameter() != null) { + if (!this.target.supportsParameterizedWidths()) { + error("Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); + } + } else if (term.getPort() != null) { + // Widths given with `widthof()` are not supported (yet?). + // This feature is currently only used for after delays. + error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); + } else if (term.getCode() != null) { + if (this.target != Target.CPP) { + error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); + } + } else if (term.getWidth() < 0) { + error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); + } + } } - } } - } - - @Check(CheckType.FAST) - public void checkReactorIconAttribute(Reactor reactor) { - var path = AttributeUtils.getIconPath(reactor); - if (path != null) { - var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); - // Check file extension - var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); - var extensionStrart = path.lastIndexOf("."); - var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; - if (!validExtensions.contains(extension.toLowerCase())) { - warning( - "File extension '" - + extension - + "' is not supported. Provide any of: " - + String.join(", ", validExtensions), - param, - Literals.ATTR_PARM__VALUE); - return; - } - - // Check file location - var iconLocation = FileUtil.locateFile(path, reactor.eResource()); - if (iconLocation == null) { - warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); - } - if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) - && !(new File(iconLocation.getPath()).exists())) { - warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); - } + + @Check(CheckType.FAST) + public void checkReactorIconAttribute(Reactor reactor) { + var path = AttributeUtils.getIconPath(reactor); + if (path != null) { + var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); + // Check file extension + var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); + var extensionStrart = path.lastIndexOf("."); + var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; + if (!validExtensions.contains(extension.toLowerCase())) { + warning("File extension '" + extension + "' is not supported. Provide any of: " + String.join(", ", validExtensions), + param, Literals.ATTR_PARM__VALUE); + return; + } + + // Check file location + var iconLocation = FileUtil.locateFile(path, reactor.eResource()); + if (iconLocation == null) { + warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); + } + if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) && !(new File(iconLocation.getPath()).exists())) { + warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); + } + } } - } - - @Check(CheckType.FAST) - public void checkInitialMode(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - long initialModesCount = reactor.getModes().stream().filter(m -> m.isInitial()).count(); - if (initialModesCount == 0) { - error("Every modal reactor requires one initial mode.", Literals.REACTOR__MODES, 0); - } else if (initialModesCount > 1) { - reactor.getModes().stream() - .filter(m -> m.isInitial()) - .skip(1) - .forEach( - m -> { - error( - "A modal reactor can only have one initial mode.", - Literals.REACTOR__MODES, - reactor.getModes().indexOf(m)); + + @Check(CheckType.FAST) + public void checkInitialMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + long initialModesCount = reactor.getModes().stream().filter(m -> m.isInitial()).count(); + if (initialModesCount == 0) { + error("Every modal reactor requires one initial mode.", Literals.REACTOR__MODES, 0); + } else if (initialModesCount > 1) { + reactor.getModes().stream().filter(m -> m.isInitial()).skip(1).forEach(m -> { + error("A modal reactor can only have one initial mode.", + Literals.REACTOR__MODES, reactor.getModes().indexOf(m)); }); - } - } - } - - @Check(CheckType.FAST) - public void checkModeStateNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getStateVars().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var stateVar : mode.getStateVars()) { - if (names.contains(stateVar.getName())) { - error( - String.format( - "Duplicate state variable '%s'. (State variables are currently scoped on" - + " reactor level not modes)", - stateVar.getName()), - stateVar, - Literals.STATE_VAR__NAME); - } - names.add(stateVar.getName()); + } } - } } - } - - @Check(CheckType.FAST) - public void checkModeTimerNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getTimers().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var timer : mode.getTimers()) { - if (names.contains(timer.getName())) { - error( - String.format( - "Duplicate Timer '%s'. (Timers are currently scoped on reactor level not" - + " modes)", - timer.getName()), - timer, - Literals.VARIABLE__NAME); - } - names.add(timer.getName()); + + @Check(CheckType.FAST) + public void checkModeStateNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getStateVars().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var stateVar : mode.getStateVars()) { + if (names.contains(stateVar.getName())) { + error(String.format("Duplicate state variable '%s'. (State variables are currently scoped on reactor level not modes)", + stateVar.getName()), stateVar, Literals.STATE_VAR__NAME); + } + names.add(stateVar.getName()); + } + } } - } } - } - - @Check(CheckType.FAST) - public void checkModeActionNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var action : mode.getActions()) { - if (names.contains(action.getName())) { - error( - String.format( - "Duplicate Action '%s'. (Actions are currently scoped on reactor level not" - + " modes)", - action.getName()), - action, - Literals.VARIABLE__NAME); - } - names.add(action.getName()); + + @Check(CheckType.FAST) + public void checkModeTimerNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getTimers().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var timer : mode.getTimers()) { + if (names.contains(timer.getName())) { + error(String.format("Duplicate Timer '%s'. (Timers are currently scoped on reactor level not modes)", + timer.getName()), timer, Literals.VARIABLE__NAME); + } + names.add(timer.getName()); + } + } } - } } - } - - @Check(CheckType.FAST) - public void checkModeInstanceNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var instantiation : mode.getInstantiations()) { - if (names.contains(instantiation.getName())) { - error( - String.format( - "Duplicate Instantiation '%s'. (Instantiations are currently scoped on reactor" - + " level not modes)", - instantiation.getName()), - instantiation, - Literals.INSTANTIATION__NAME); - } - names.add(instantiation.getName()); + + @Check(CheckType.FAST) + public void checkModeActionNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var action : mode.getActions()) { + if (names.contains(action.getName())) { + error(String.format("Duplicate Action '%s'. (Actions are currently scoped on reactor level not modes)", + action.getName()), action, Literals.VARIABLE__NAME); + } + names.add(action.getName()); + } + } } - } } - } - - @Check(CheckType.FAST) - public void checkMissingStateResetInMode(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var resetModes = new HashSet(); - // Collect all modes that may be reset - for (var m : reactor.getModes()) { - for (var r : m.getReactions()) { - for (var e : r.getEffects()) { - if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { - resetModes.add((Mode) e.getVariable()); + + @Check(CheckType.FAST) + public void checkModeInstanceNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var instantiation : mode.getInstantiations()) { + if (names.contains(instantiation.getName())) { + error(String.format("Duplicate Instantiation '%s'. (Instantiations are currently scoped on reactor level not modes)", + instantiation.getName()), instantiation, Literals.INSTANTIATION__NAME); + } + names.add(instantiation.getName()); + } } - } } - } - for (var m : resetModes) { - // Check state variables in this mode - if (!m.getStateVars().isEmpty()) { - var hasResetReaction = - m.getReactions().stream() - .anyMatch( - r -> - r.getTriggers().stream() - .anyMatch( - t -> - (t instanceof BuiltinTriggerRef - && ((BuiltinTriggerRef) t).getType() - == BuiltinTrigger.RESET))); - if (!hasResetReaction) { - for (var s : m.getStateVars()) { - if (!s.isReset()) { - error( - "State variable is not reset upon mode entry. It is neither marked for" - + " automatic reset nor is there a reset reaction.", - m, - Literals.MODE__STATE_VARS, - m.getStateVars().indexOf(s)); - } + } + + @Check(CheckType.FAST) + public void checkMissingStateResetInMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var resetModes = new HashSet(); + // Collect all modes that may be reset + for (var m : reactor.getModes()) { + for (var r : m.getReactions()) { + for (var e : r.getEffects()) { + if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { + resetModes.add((Mode) e.getVariable()); + } + } + } } - } - } - // Check state variables in instantiated reactors - if (!m.getInstantiations().isEmpty()) { - for (var i : m.getInstantiations()) { - var error = new LinkedHashSet(); - var checked = new HashSet(); - var toCheck = new LinkedList(); - toCheck.add((Reactor) i.getReactorClass()); - while (!toCheck.isEmpty()) { - var check = toCheck.pop(); - checked.add(check); - if (!check.getStateVars().isEmpty()) { - var hasResetReaction = - check.getReactions().stream() - .anyMatch( - r -> - r.getTriggers().stream() - .anyMatch( - t -> - (t instanceof BuiltinTriggerRef - && ((BuiltinTriggerRef) t).getType() - == BuiltinTrigger.RESET))); - if (!hasResetReaction) { - // Add state vars that are not self-resetting to the error - check.getStateVars().stream() - .filter(s -> !s.isReset()) - .forEachOrdered(error::add); + for (var m : resetModes) { + // Check state variables in this mode + if (!m.getStateVars().isEmpty()) { + var hasResetReaction = m.getReactions().stream().anyMatch( + r -> r.getTriggers().stream().anyMatch( + t -> (t instanceof BuiltinTriggerRef && + ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + for (var s : m.getStateVars()) { + if (!s.isReset()) { + error("State variable is not reset upon mode entry. It is neither marked for automatic reset nor is there a reset reaction.", + m, Literals.MODE__STATE_VARS, m.getStateVars().indexOf(s)); + } + } + } } - } - // continue with inner - for (var innerInstance : check.getInstantiations()) { - var next = (Reactor) innerInstance.getReactorClass(); - if (!checked.contains(next)) { - toCheck.push(next); + // Check state variables in instantiated reactors + if (!m.getInstantiations().isEmpty()) { + for (var i : m.getInstantiations()) { + var error = new LinkedHashSet(); + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty()) { + var check = toCheck.pop(); + checked.add(check); + if (!check.getStateVars().isEmpty()) { + var hasResetReaction = check.getReactions().stream().anyMatch( + r -> r.getTriggers().stream().anyMatch( + t -> (t instanceof BuiltinTriggerRef && + ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + // Add state vars that are not self-resetting to the error + check.getStateVars().stream().filter(s -> !s.isReset()).forEachOrdered(error::add); + } + } + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); + } + } + } + if (!error.isEmpty()) { + error("This reactor contains state variables that are not reset upon mode entry: " + + error.stream().map(e -> e.getName() + " in " + + ASTUtils.getEnclosingReactor(e).getName()).collect(Collectors.joining(", ")) + + ".\nThe state variables are neither marked for automatic reset nor have a dedicated reset reaction. " + + "It is unsafe to instantiate this reactor inside a mode entered with reset.", + m, Literals.MODE__INSTANTIATIONS, + m.getInstantiations().indexOf(i)); + } + } } - } - } - if (!error.isEmpty()) { - error( - "This reactor contains state variables that are not reset upon mode entry: " - + error.stream() - .map( - e -> e.getName() + " in " + ASTUtils.getEnclosingReactor(e).getName()) - .collect(Collectors.joining(", ")) - + ".\n" - + "The state variables are neither marked for automatic reset nor have a" - + " dedicated reset reaction. It is unsafe to instantiate this reactor inside" - + " a mode entered with reset.", - m, - Literals.MODE__INSTANTIATIONS, - m.getInstantiations().indexOf(i)); } - } } - } } - } - - @Check(CheckType.FAST) - public void checkStateResetWithoutInitialValue(StateVar state) { - if (state.isReset() && (state.getInit() == null || state.getInit().getExprs().isEmpty())) { - error( - "The state variable can not be automatically reset without an initial value.", - state, - Literals.STATE_VAR__RESET); + + @Check(CheckType.FAST) + public void checkStateResetWithoutInitialValue(StateVar state) { + if (state.isReset() && (state.getInit() == null || state.getInit().getExprs().isEmpty())) { + error("The state variable can not be automatically reset without an initial value.", state, Literals.STATE_VAR__RESET); + } } - } - - @Check(CheckType.FAST) - public void checkUnspecifiedTransitionType(Reaction reaction) { - for (var effect : reaction.getEffects()) { - var variable = effect.getVariable(); - if (variable instanceof Mode) { - // The transition type is always set to default by Xtext. - // Hence, check if there is an explicit node for the transition type in the AST. - var transitionAssignment = - NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); - if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. - var mode = (Mode) variable; - // Check if reset or history transition would make a difference. - var makesDifference = - !mode.getStateVars().isEmpty() - || !mode.getTimers().isEmpty() - || !mode.getActions().isEmpty() - || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); - if (!makesDifference && !mode.getInstantiations().isEmpty()) { - // Also check instantiated reactors - for (var i : mode.getInstantiations()) { - var checked = new HashSet(); - var toCheck = new LinkedList(); - toCheck.add((Reactor) i.getReactorClass()); - while (!toCheck.isEmpty() && !makesDifference) { - var check = toCheck.pop(); - checked.add(check); - - makesDifference |= - !check.getModes().isEmpty() - || !ASTUtils.allStateVars(check).isEmpty() - || !ASTUtils.allTimers(check).isEmpty() - || !ASTUtils.allActions(check).isEmpty() - || ASTUtils.allConnections(check).stream() - .anyMatch(c -> c.getDelay() != null); - - // continue with inner - for (var innerInstance : check.getInstantiations()) { - var next = (Reactor) innerInstance.getReactorClass(); - if (!checked.contains(next)) { - toCheck.push(next); - } + + @Check(CheckType.FAST) + public void checkUnspecifiedTransitionType(Reaction reaction) { + for (var effect : reaction.getEffects()) { + var variable = effect.getVariable(); + if (variable instanceof Mode) { + // The transition type is always set to default by Xtext. + // Hence, check if there is an explicit node for the transition type in the AST. + var transitionAssignment = NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); + if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. + var mode = (Mode) variable; + // Check if reset or history transition would make a difference. + var makesDifference = !mode.getStateVars().isEmpty() + || !mode.getTimers().isEmpty() + || !mode.getActions().isEmpty() + || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); + if (!makesDifference && !mode.getInstantiations().isEmpty()) { + // Also check instantiated reactors + for (var i : mode.getInstantiations()) { + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty() && !makesDifference) { + var check = toCheck.pop(); + checked.add(check); + + makesDifference |= !check.getModes().isEmpty() + || !ASTUtils.allStateVars(check).isEmpty() + || !ASTUtils.allTimers(check).isEmpty() + || !ASTUtils.allActions(check).isEmpty() + || ASTUtils.allConnections(check).stream().anyMatch(c -> c.getDelay() != null); + + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); + } + } + } + } + } + if (makesDifference) { + warning("You should specify a transition type! " + + "Reset and history transitions have different effects on this target mode. " + + "Currently, a reset type is implicitly assumed.", + reaction, Literals.REACTION__EFFECTS, reaction.getEffects().indexOf(effect)); + } } - } } - } - if (makesDifference) { - warning( - "You should specify a transition type! " - + "Reset and history transitions have different effects on this target mode. " - + "Currently, a reset type is implicitly assumed.", - reaction, - Literals.REACTION__EFFECTS, - reaction.getEffects().indexOf(effect)); - } } - } - } - } - - ////////////////////////////////////////////////////////////// - //// Public methods. - - /** Return the error reporter for this validator. */ - public ValidatorErrorReporter getErrorReporter() { - return this.errorReporter; - } - - /** Implementation required by xtext to report validation errors. */ - @Override - public ValidationMessageAcceptor getMessageAcceptor() { - return messageAcceptor == null ? this : messageAcceptor; - } - - /** Return a list of error messages for the target declaration. */ - public List getTargetPropertyErrors() { - return this.targetPropertyErrors; - } - - ////////////////////////////////////////////////////////////// - //// Protected methods. - - /** Generate an error message for an AST node. */ - @Override - protected void error(java.lang.String message, org.eclipse.emf.ecore.EStructuralFeature feature) { - super.error(message, feature); - } - - ////////////////////////////////////////////////////////////// - //// Private methods. - - /** - * For each input, report a conflict if: 1) the input exists and the type doesn't match; or 2) the - * input has a name clash with variable that is not an input. - * - * @param superVars List of typed variables of a particular kind (i.e., inputs, outputs, or - * actions), found in a super class. - * @param sameKind Typed variables of the same kind, found in the subclass. - * @param allOwn Accumulator of non-conflicting variables incorporated in the subclass. - * @param conflicts Set of variables that are in conflict, to be used by this function to report - * conflicts. - */ - private void checkConflict( - EList superVars, EList sameKind, List allOwn, HashSet conflicts) { - for (T superVar : superVars) { - T match = null; - for (T it : sameKind) { - if (it.getName().equals(superVar.getName())) { - match = it; - break; - } - } - List rest = new ArrayList<>(allOwn); - rest.removeIf(it -> sameKind.contains(it)); - - if ((match != null && superVar.getType() != match.getType()) - || hasNameConflict(superVar, rest)) { - conflicts.add(superVar); - } else { - allOwn.add(superVar); - } - } - } - - /** - * Check the name of a feature for illegal substrings such as reserved identifiers and names with - * double leading underscores. - * - * @param name The name. - * @param feature The feature containing the name (for error reporting). - */ - private void checkName(String name, EStructuralFeature feature) { - - // Raises an error if the string starts with two underscores. - if (name.length() >= 2 && name.substring(0, 2).equals("__")) { - error(UNDERSCORE_MESSAGE + name, feature); } - if (this.target.isReservedIdent(name)) { - error(RESERVED_MESSAGE + name, feature); - } + ////////////////////////////////////////////////////////////// + //// Public methods. + + /** + * Return the error reporter for this validator. + */ + public ValidatorErrorReporter getErrorReporter() { + return this.errorReporter; + } + + /** + * Implementation required by xtext to report validation errors. + */ + @Override + public ValidationMessageAcceptor getMessageAcceptor() { + return messageAcceptor == null ? this : messageAcceptor; + } + + /** + * Return a list of error messages for the target declaration. + */ + public List getTargetPropertyErrors() { + return this.targetPropertyErrors; + } + + ////////////////////////////////////////////////////////////// + //// Protected methods. + + /** + * Generate an error message for an AST node. + */ + @Override + protected void error(java.lang.String message, + org.eclipse.emf.ecore.EStructuralFeature feature) { + super.error(message, feature); + } + + ////////////////////////////////////////////////////////////// + //// Private methods. + + /** + * For each input, report a conflict if: + * 1) the input exists and the type doesn't match; or + * 2) the input has a name clash with variable that is not an input. + * @param superVars List of typed variables of a particular kind (i.e., + * inputs, outputs, or actions), found in a super class. + * @param sameKind Typed variables of the same kind, found in the subclass. + * @param allOwn Accumulator of non-conflicting variables incorporated in the + * subclass. + * @param conflicts Set of variables that are in conflict, to be used by this + * function to report conflicts. + */ + private void checkConflict ( + EList superVars, EList sameKind, List allOwn, HashSet conflicts + ) { + for (T superVar : superVars) { + T match = null; + for (T it : sameKind) { + if (it.getName().equals(superVar.getName())) { + match = it; + break; + } + } + List rest = new ArrayList<>(allOwn); + rest.removeIf(it -> sameKind.contains(it)); - if (this.target == Target.TS) { - // "actions" is a reserved word within a TS reaction - if (name.equals("actions")) { - error(ACTIONS_MESSAGE + name, feature); - } - } - } - - /** - * Check that the initializer is compatible with the type. Note that if the type is inferred it - * will necessarily be compatible so this method is not harmful. - */ - public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { - if (init == null) { - return; + if ((match != null && superVar.getType() != match.getType()) || hasNameConflict(superVar, rest)) { + conflicts.add(superVar); + } else { + allOwn.add(superVar); + } + } } - // TODO: - // type is list => init is list - // type is fixed with size n => init is fixed with size n - // Specifically for C: list can only be literal or time lists + /** + * Check the name of a feature for illegal substrings such as reserved + * identifiers and names with double leading underscores. + * @param name The name. + * @param feature The feature containing the name (for error reporting). + */ + private void checkName(String name, EStructuralFeature feature) { - if (type.isTime) { - if (type.isList) { - // list of times - var exprs = init.getExprs(); - if (exprs.isEmpty()) { - error("Expected at least one time value.", feature); - return; + // Raises an error if the string starts with two underscores. + if (name.length() >= 2 && name.substring(0, 2).equals("__")) { + error(UNDERSCORE_MESSAGE + name, feature); } - if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { - exprs = ((BracedListExpression) exprs.get(0)).getItems(); + + if (this.target.isReservedIdent(name)) { + error(RESERVED_MESSAGE + name, feature); } - for (var component : exprs) { - checkExpressionIsTime(component, feature); + + if (this.target == Target.TS) { + // "actions" is a reserved word within a TS reaction + if (name.equals("actions")) { + error(ACTIONS_MESSAGE + name, feature); + } } - } else { - checkExpressionIsTime(init, feature); - } } - } - private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { - if (init == null) { - return; - } - if (init.getExprs().size() != 1) { - error("Expected exactly one time value.", feature); - } else { - checkExpressionIsTime(ASTUtils.asSingleExpr(init), feature); - } - } + /** + * Check that the initializer is compatible with the type. + * Note that if the type is inferred it will necessarily be compatible + * so this method is not harmful. + */ + public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { + if (init == null) { + return; + } - private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { - if (value == null || value instanceof Time) { - return; + // TODO: + // type is list => init is list + // type is fixed with size n => init is fixed with size n + // Specifically for C: list can only be literal or time lists + + if (type.isTime) { + if (type.isList) { + // list of times + var exprs = init.getExprs(); + if (exprs.isEmpty()) { + error("Expected at least one time value.", feature); + return; + } + if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { + exprs = ((BracedListExpression) exprs.get(0)).getItems(); + } + for (var component : exprs) { + checkExpressionIsTime(component, feature); + } + } else { + checkExpressionIsTime(init, feature); + } + } } - if (value instanceof ParameterReference) { - if (!ASTUtils.isOfTimeType(((ParameterReference) value).getParameter()) - && target.requiresTypes) { - error("Referenced parameter is not of time type.", feature); - } - return; - } else if (value instanceof Literal) { - if (ASTUtils.isZero(((Literal) value).getLiteral())) { - return; - } - - if (ASTUtils.isInteger(((Literal) value).getLiteral())) { - error("Missing time unit.", feature); - return; - } - // fallthrough - } + private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { + if (init == null) { + return; + } - error("Invalid time value.", feature); - } - - /** - * Return the number of main or federated reactors declared. - * - * @param iter An iterator over all objects in the resource. - */ - private int countMainOrFederated(TreeIterator iter) { - int nMain = 0; - while (iter.hasNext()) { - EObject obj = iter.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor r = (Reactor) obj; - if (r.isMain() || r.isFederated()) { - nMain++; - } - } - return nMain; - } - - /** - * Report whether a given reactor has dependencies on a cyclic instantiation pattern. This means - * the reactor has an instantiation in it -- directly or in one of its contained reactors -- that - * is self-referential. - * - * @param reactor The reactor definition to find out whether it has any dependencies on cyclic - * instantiations. - * @param cycleSet The set of all reactors that are part of an instantiation cycle. - * @param visited The set of nodes already visited in this graph traversal. - */ - private boolean dependsOnCycle(Reactor reactor, Set cycleSet, Set visited) { - Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); - if (visited.contains(reactor)) { - return false; - } else { - visited.add(reactor); - for (Reactor it : origins) { - if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { - // Reached a cycle. - return true; - } - } - } - return false; - } - - /** - * Report whether the name of the given element matches any variable in the ones to check against. - * - * @param element The element to compare against all variables in the given iterable. - * @param toCheckAgainst Iterable variables to compare the given element against. - */ - private boolean hasNameConflict(Variable element, Iterable toCheckAgainst) { - int numNameConflicts = 0; - for (Variable it : toCheckAgainst) { - if (it.getName().equals(element.getName())) { - numNameConflicts++; - } - } - return numNameConflicts > 0; - } - - /** Return true if target is C or a C-based target like CCpp. */ - private boolean isCBasedTarget() { - return (this.target == Target.C || this.target == Target.CCPP); - } - - /** - * Report whether a given imported reactor is used in this resource or not. - * - * @param reactor The imported reactor to check whether it is used. - */ - private boolean isUnused(ImportedReactor reactor) { - TreeIterator instantiations = reactor.eResource().getAllContents(); - TreeIterator subclasses = reactor.eResource().getAllContents(); - - boolean instantiationsCheck = true; - while (instantiations.hasNext() && instantiationsCheck) { - EObject obj = instantiations.next(); - if (!(obj instanceof Instantiation)) { - continue; - } - Instantiation inst = (Instantiation) obj; - instantiationsCheck &= - (inst.getReactorClass() != reactor - && inst.getReactorClass() != reactor.getReactorClass()); + if (init.getExprs().size() != 1) { + error("Expected exactly one time value.", feature); + } else { + checkExpressionIsTime(ASTUtils.asSingleExpr(init), feature); + } } - boolean subclassesCheck = true; - while (subclasses.hasNext() && subclassesCheck) { - EObject obj = subclasses.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor subclass = (Reactor) obj; - for (ReactorDecl decl : subclass.getSuperClasses()) { - subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); - } + private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { + if (value == null || value instanceof Time) { + return; + } + + if (value instanceof ParameterReference) { + if (!ASTUtils.isOfTimeType(((ParameterReference) value).getParameter()) + && target.requiresTypes) { + error("Referenced parameter is not of time type.", feature); + } + return; + } else if (value instanceof Literal) { + if (ASTUtils.isZero(((Literal) value).getLiteral())) { + return; + } + + if (ASTUtils.isInteger(((Literal) value).getLiteral())) { + error("Missing time unit.", feature); + return; + } + // fallthrough + } + + error("Invalid time value.", feature); } - return instantiationsCheck && subclassesCheck; - } - - /** - * Return true if the two types match. Unfortunately, xtext does not seem to create a suitable - * equals() method for Type, so we have to do this manually. - */ - private boolean sameType(Type type1, Type type2) { - if (type1 == null) { - return type2 == null; + + /** + * Return the number of main or federated reactors declared. + * + * @param iter An iterator over all objects in the resource. + */ + private int countMainOrFederated(TreeIterator iter) { + int nMain = 0; + while (iter.hasNext()) { + EObject obj = iter.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor r = (Reactor) obj; + if (r.isMain() || r.isFederated()) { + nMain++; + } + } + return nMain; + } + + /** + * Report whether a given reactor has dependencies on a cyclic + * instantiation pattern. This means the reactor has an instantiation + * in it -- directly or in one of its contained reactors -- that is + * self-referential. + * @param reactor The reactor definition to find out whether it has any + * dependencies on cyclic instantiations. + * @param cycleSet The set of all reactors that are part of an + * instantiation cycle. + * @param visited The set of nodes already visited in this graph traversal. + */ + private boolean dependsOnCycle( + Reactor reactor, Set cycleSet, Set visited + ) { + Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); + if (visited.contains(reactor)) { + return false; + } else { + visited.add(reactor); + for (Reactor it : origins) { + if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { + // Reached a cycle. + return true; + } + } + } + return false; + } + + /** + * Report whether the name of the given element matches any variable in + * the ones to check against. + * @param element The element to compare against all variables in the given iterable. + * @param toCheckAgainst Iterable variables to compare the given element against. + */ + private boolean hasNameConflict(Variable element, + Iterable toCheckAgainst) { + int numNameConflicts = 0; + for (Variable it : toCheckAgainst) { + if (it.getName().equals(element.getName())) { + numNameConflicts++; + } + } + return numNameConflicts > 0; } - if (type2 == null) { - return type1 == null; + + /** + * Return true if target is C or a C-based target like CCpp. + */ + private boolean isCBasedTarget() { + return (this.target == Target.C || this.target == Target.CCPP); } - // Most common case first. - if (type1.getId() != null) { - if (type1.getStars() != null) { - if (type2.getStars() == null) return false; - if (type1.getStars().size() != type2.getStars().size()) return false; - } - return (type1.getId().equals(type2.getId())); + + /** + * Report whether a given imported reactor is used in this resource or not. + * @param reactor The imported reactor to check whether it is used. + */ + private boolean isUnused(ImportedReactor reactor) { + TreeIterator instantiations = reactor.eResource().getAllContents(); + TreeIterator subclasses = reactor.eResource().getAllContents(); + + boolean instantiationsCheck = true; + while (instantiations.hasNext() && instantiationsCheck) { + EObject obj = instantiations.next(); + if (!(obj instanceof Instantiation)) { + continue; + } + Instantiation inst = (Instantiation) obj; + instantiationsCheck &= (inst.getReactorClass() != reactor && inst.getReactorClass() != reactor.getReactorClass()); + } + + boolean subclassesCheck = true; + while (subclasses.hasNext() && subclassesCheck) { + EObject obj = subclasses.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor subclass = (Reactor) obj; + for (ReactorDecl decl : subclass.getSuperClasses()) { + subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); + } + } + return instantiationsCheck && subclassesCheck; } - // Type specification in the grammar is: - // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' - // typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); - if (type1.isTime()) { - if (!type2.isTime()) return false; - // Ignore the arraySpec because that is checked when connection - // is checked for balance. - return true; + /** + * Return true if the two types match. Unfortunately, xtext does not + * seem to create a suitable equals() method for Type, so we have to + * do this manually. + */ + private boolean sameType(Type type1, Type type2) { + if (type1 == null) { + return type2 == null; + } + if (type2 == null) { + return type1 == null; + } + // Most common case first. + if (type1.getId() != null) { + if (type1.getStars() != null) { + if (type2.getStars() == null) return false; + if (type1.getStars().size() != type2.getStars().size()) return false; + } + return (type1.getId().equals(type2.getId())); + } + + // Type specification in the grammar is: + // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); + if (type1.isTime()) { + if (!type2.isTime()) return false; + // Ignore the arraySpec because that is checked when connection + // is checked for balance. + return true; + } + // Type must be given in a code body + return type1.getCode().getBody().equals(type2.getCode().getBody()); } - // Type must be given in a code body - return type1.getCode().getBody().equals(type2.getCode().getBody()); - } - - ////////////////////////////////////////////////////////////// - //// Private fields. - - /** The error reporter. */ - private ValidatorErrorReporter errorReporter = - new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); - - /** Helper class containing information about the model. */ - private ModelInfo info = new ModelInfo(); - - @Inject(optional = true) - private ValidationMessageAcceptor messageAcceptor; - - /** The declared target. */ - private Target target; - - private List targetPropertyErrors = new ArrayList<>(); - - private List targetPropertyWarnings = new ArrayList<>(); - - ////////////////////////////////////////////////////////////// - //// Private static constants. - - private static String ACTIONS_MESSAGE = - "\"actions\" is a reserved word for the TypeScript target for objects " - + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " - + "and reactor instantiation): "; - - private static String HOST_OR_FQN_REGEX = - "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; - - /** Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). */ - private static String IPV4_REGEX = - "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" - + "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; - - /** - * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), with minor - * adjustment to allow up to six IPV6 segments (without truncation) in front of an embedded - * IPv4-address. - */ - private static String IPV6_REGEX = - "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" - + "([0-9a-fA-F]{1,4}:){1,7}:|" - + "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" - + "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" - + "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" - + "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" - + "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" - + "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" - + ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" - + "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" - + "::(ffff(:0{1,4}){0,1}:){0,1}" - + IPV4_REGEX - + "|" - + "([0-9a-fA-F]{1,4}:){1,4}:" - + IPV4_REGEX - + "|" - + "([0-9a-fA-F]{1,4}:){1,6}" - + IPV4_REGEX - + ")"; - - private static String RESERVED_MESSAGE = - "Reserved words in the target language are not allowed for objects (inputs, outputs, actions," - + " timers, parameters, state, reactor definitions, and reactor instantiation): "; - - private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); - - private static String UNDERSCORE_MESSAGE = - "Names of objects (inputs, outputs, actions, timers, parameters, " - + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; - - private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; + + ////////////////////////////////////////////////////////////// + //// Private fields. + + /** The error reporter. */ + private ValidatorErrorReporter errorReporter + = new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); + + /** Helper class containing information about the model. */ + private ModelInfo info = new ModelInfo(); + + @Inject(optional = true) + private ValidationMessageAcceptor messageAcceptor; + + /** The declared target. */ + private Target target; + + private List targetPropertyErrors = new ArrayList<>(); + + private List targetPropertyWarnings = new ArrayList<>(); + + ////////////////////////////////////////////////////////////// + //// Private static constants. + + private static String ACTIONS_MESSAGE + = "\"actions\" is a reserved word for the TypeScript target for objects " + + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " + + "and reactor instantiation): "; + + private static String HOST_OR_FQN_REGEX + = "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; + + /** + * Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). + */ + private static String IPV4_REGEX = "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" + + "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; + + /** + * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), + * with minor adjustment to allow up to six IPV6 segments (without truncation) in front + * of an embedded IPv4-address. + **/ + private static String IPV6_REGEX = + "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,7}:|" + + "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" + + "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" + + "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" + + "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" + + "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" + + ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" + + "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" + + "::(ffff(:0{1,4}){0,1}:){0,1}" + IPV4_REGEX + "|" + + "([0-9a-fA-F]{1,4}:){1,4}:" + IPV4_REGEX + "|" + + "([0-9a-fA-F]{1,4}:){1,6}" + IPV4_REGEX + ")"; + + private static String RESERVED_MESSAGE = "Reserved words in the target language are not allowed for objects " + + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation): "; + + private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); + + private static String UNDERSCORE_MESSAGE = "Names of objects (inputs, outputs, actions, timers, parameters, " + + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; + + private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; + } From bf91bbd134ec26d0dca73962c8caa353821e817e Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 10:23:38 +0200 Subject: [PATCH 228/709] Aligned reactor-c to main --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 8eaf16fdc4..f762f01902 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 8eaf16fdc46df596cf85f7be7e901988cabcd873 +Subproject commit f762f01902745dff40b9170dce273d29b6df5212 From a42a6f079a5b7c1e0a4a4e464f131e6dd17bb84d Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 10:25:22 +0200 Subject: [PATCH 229/709] Formatted test --- test/C/src/Watchdog.lf | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/C/src/Watchdog.lf b/test/C/src/Watchdog.lf index a836c93c3f..3ee48afe9c 100644 --- a/test/C/src/Watchdog.lf +++ b/test/C/src/Watchdog.lf @@ -11,8 +11,9 @@ target C { reactor Watcher(timeout: time = 150 ms) { timer t(100 ms, 100 ms) // Offset ameliorates startup time. - // Period has to be smaller than watchdog timeout. - output d: int // Produced if the watchdog triggers. + // Period has to be smaller than watchdog timeout. Produced if the watchdog + // triggers. + output d: int state count: int = 0 watchdog poodle(timeout) {= From 47e99f78c12fda332aa0a0de918a49e983937119 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 10:31:15 +0200 Subject: [PATCH 230/709] Placeholder for when there are no watchdogs --- org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 695bd5eefa..311fe365fd 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -150,6 +150,7 @@ protected static String generateWatchdogTable(int count) { if (count == 0) { return String.join("\n", "// No watchdogs found.", + "typedef void watchdog_t;", "watchdog_t* _lf_watchdogs = NULL;", "int _lf_watchdog_number = 0;" ); From 2687e42d96fb71d7f5c1d40e6dc4cba26dd652f5 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 1 May 2023 11:03:09 +0200 Subject: [PATCH 231/709] Align reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 97466da394..ffe9a6a2e2 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 97466da394d9572e4ba905b2706759bef73c0af0 +Subproject commit ffe9a6a2e2bf79f45c1019d48f17b1b92eaf01a5 From 61f6d678bc2530ce14d2e7697b51ec04d8b5ab52 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 2 May 2023 11:17:38 +0200 Subject: [PATCH 232/709] CI: do not hardcode compiler version in c benchmark tests --- .github/workflows/ci.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f6dd56ae40..48110ac926 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -51,8 +51,6 @@ jobs: uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'C' - benchmarks-ref: main - compiler-ref: master needs: cancel # Run language server tests. From c605eeaf9bca94fb0c6c037f75d81bd8dea5b99f Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 2 May 2023 15:18:31 -0700 Subject: [PATCH 233/709] Bugfixes --- .github/workflows/ci.yml | 1 - .../org/lflang/generator/c/CGenerator.java | 12 +-- .../org/lflang/generator/cpp/CppGenerator.kt | 7 +- .../generator/python/PythonGenerator.java | 8 +- .../org/lflang/generator/ts/TSGenerator.kt | 2 +- org.lflang/src/org/lflang/util/FileUtil.java | 94 +++++++------------ 6 files changed, 45 insertions(+), 79 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f6dd56ae40..c2e1513fe7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -52,7 +52,6 @@ jobs: with: target: 'C' benchmarks-ref: main - compiler-ref: master needs: cancel # Run language server tests. diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index fbedb23253..bbd0007961 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -883,7 +883,7 @@ private void generateReactorDefinitions() throws IOException { /** Generate user-visible header files for all reactors instantiated. */ private void generateHeaders() throws IOException { FileUtil.deleteDirectory(fileConfig.getIncludePath()); - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( fileConfig.getRuntimeIncludePath(), fileConfig.getIncludePath(), false @@ -962,12 +962,12 @@ protected void copyTargetFiles() throws IOException { if (coreLib != null) { FileUtil.copyDirectory(Path.of(coreLib), dest, true); } else { - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( "/lib/c/reactor-c/core", dest.resolve("core"), true ); - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( "/lib/c/reactor-c/lib", dest.resolve("lib"), true @@ -976,18 +976,18 @@ protected void copyTargetFiles() throws IOException { // For the Zephyr target, copy default config and board files. if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( "/lib/platform/zephyr/boards", fileConfig.getSrcGenPath().resolve("boards"), false ); - FileUtil.copyFileFromClassPath( + FileUtil.copyFromClassPath( "/lib/platform/zephyr/prj_lf.conf", fileConfig.getSrcGenPath().resolve("prj_lf.conf"), true ); - FileUtil.copyFileFromClassPath( + FileUtil.copyFromClassPath( "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath().resolve("Kconfig"), true diff --git a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt index 5001fe9ac7..805846caec 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt @@ -27,7 +27,6 @@ package org.lflang.generator.cpp import org.eclipse.emf.ecore.resource.Resource -import org.lflang.ErrorReporter import org.lflang.Target import org.lflang.generator.CodeMap import org.lflang.generator.GeneratorBase @@ -127,9 +126,9 @@ class CppGenerator( // copy static library files over to the src-gen directory val genIncludeDir = srcGenPath.resolve("__include__") listOf("lfutil.hh", "time_parser.hh").forEach { - FileUtil.copyFileFromClassPath("$libDir/$it", genIncludeDir.resolve(it), true) + FileUtil.copyFromClassPath("$libDir/$it", genIncludeDir.resolve(it), true) } - FileUtil.copyFileFromClassPath( + FileUtil.copyFromClassPath( "$libDir/3rd-party/cxxopts.hpp", genIncludeDir.resolve("CLI").resolve("cxxopts.hpp"), true @@ -140,7 +139,7 @@ class CppGenerator( if (targetConfig.runtimeVersion != null) { fetchReactorCpp() } else { - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( "$libDir/reactor-cpp", fileConfig.srcGenBasePath.resolve("reactor-cpp-default"), true diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 020954be80..361e06e285 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -35,7 +35,6 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; @@ -56,7 +55,6 @@ import org.lflang.generator.c.CGenerator; import org.lflang.generator.c.CUtil; import org.lflang.lf.Action; -import org.lflang.lf.Code; import org.lflang.lf.Input; import org.lflang.lf.Model; import org.lflang.lf.Output; @@ -661,17 +659,17 @@ private static String generatePythonFileName(String lfModuleName) { @Override protected void copyTargetFiles() throws IOException { super.copyTargetFiles(); - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( "/lib/py/reactor-c-py/include", fileConfig.getSrcGenPath().resolve("include"), true ); - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( "/lib/py/reactor-c-py/lib", fileConfig.getSrcGenPath().resolve("lib"), true ); - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( "/lib/py/reactor-c-py/LinguaFrancaBase", fileConfig.getSrcGenPath().resolve("LinguaFrancaBase"), true diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index bd92a144ce..0514a46a9c 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -235,7 +235,7 @@ class TSGenerator( "No '" + configFile + "' exists in " + fileConfig.srcPath + ". Using default configuration." ) - FileUtil.copyFileFromClassPath("$LIB_PATH/$configFile", configFileDest) + FileUtil.copyFromClassPath("$LIB_PATH/$configFile", configFileDest, true) } } } diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index a2cfb81e4d..746835f7cb 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -38,7 +38,6 @@ import org.lflang.ErrorReporter; import org.lflang.FileConfig; -import org.lflang.generator.LFGeneratorContext; public class FileUtil { @@ -262,27 +261,26 @@ public static void copyFiles( var found = FileUtil.findInPackage(path, fileConfig); if (found != null) { try { - FileUtil.copyFileOrDirectory(found, destination.resolve(found.getFileName())); + FileUtil.copyFromFileSystem(found, destination.resolve(path.getFileName())); + System.out.println("Copied '" + fileOrDirectory + "' from the file system."); } catch (IOException e) { errorReporter.reportError( "Unable to copy '" + fileOrDirectory + "' from the file system." ); } } else { - // Attempt to copy from the classpath instead. - // If the filename is not a directory, it will - // just be copied without further recursion. try { - FileUtil.copyDirectoryFromClassPath( + FileUtil.copyFromClassPath( fileOrDirectory, destination, false ); - } catch (IOException e) { + } catch(IOException e) { errorReporter.reportError( "Unable to copy '" + fileOrDirectory + "' from the class path." ); } + System.out.println("Copied '" + fileOrDirectory + "' from the class path."); } } } @@ -294,7 +292,7 @@ public static void copyFiles( * @param destination A directory to copy the file(s) at the source to. * @throws IOException */ - public static void copyFileOrDirectory(Path source, Path destination) throws IOException { + public static void copyFromFileSystem(Path source, Path destination) throws IOException { if (Files.isDirectory(source)) { copyDirectory(source, destination); } else if (Files.isRegularFile(source)) { @@ -315,60 +313,26 @@ public static void copyFileOrDirectory(Path source, Path destination) throws IOE * @throws IOException if copy fails. */ private static void copyInputStream(InputStream source, Path destination, boolean skipIfUnchanged) throws IOException { - Files.createDirectories(destination.getParent()); - // Read the stream once and keep a copy of all bytes. This is required as a stream cannot be read twice. final var bytes = source.readAllBytes(); - // abort if the destination file does not change - if(skipIfUnchanged && Files.isRegularFile(destination)) { - if (Arrays.equals(bytes, Files.readAllBytes(destination))) { - return; + final var parent = destination.getParent(); + if (Files.isRegularFile(destination)) { + if (skipIfUnchanged) { + if (Arrays.equals(bytes, Files.readAllBytes(destination))) { + // Abort if the file contents are the same. + return; + } + } else { + // Delete the file exists but the contents don't match. + Files.delete(destination); } + } else if (!Files.exists(parent)) { + Files.createDirectories(parent); } Files.write(destination, bytes); } - /** - * Lookup a file in the classpath and copy its contents to a destination path - * in the filesystem. - * - * This also creates new directories for any directories on the destination - * path that do not yet exist. - * - * @param source The source file as a path relative to the classpath. - * @param destination The file system path that the source file is copied to. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not be changed - * @throws IOException If the given source cannot be copied. - */ - public static void copyFileFromClassPath(final String source, final Path destination, final boolean skipIfUnchanged) throws IOException { - InputStream sourceStream = FileConfig.class.getResourceAsStream(source); - - // Copy the file. - if (sourceStream == null) { - throw new TargetResourceNotFoundException(source); - } else { - try (sourceStream) { - copyInputStream(sourceStream, destination, skipIfUnchanged); - } - } - } - - /** - * Lookup a file in the classpath and copy its contents to a destination path - * in the filesystem. - * - * This also creates new directories for any directories on the destination - * path that do not yet exist. - * - * @param source The source file as a path relative to the classpath. - * @param destination The file system path that the source file is copied to. - * @throws IOException If the given source cannot be copied. - */ - public static void copyFileFromClassPath(final String source, final Path destination) throws IOException { - copyFileFromClassPath(source, destination, false); - } - /** * Lookup a directory in the classpath and copy its contents to a destination path * in the filesystem. @@ -381,22 +345,27 @@ public static void copyFileFromClassPath(final String source, final Path destina * @param skipIfUnchanged If true, don't overwrite the file if its content would not be changed * @throws IOException If the given source cannot be copied. */ - public static void copyDirectoryFromClassPath(final String source, final Path destination, final boolean skipIfUnchanged) throws IOException { + public static void copyFromClassPath(final String source, final Path destination, final boolean skipIfUnchanged) throws IOException { final URL resource = FileConfig.class.getResource(source); + if (resource == null) { throw new TargetResourceNotFoundException(source); } final URLConnection connection = resource.openConnection(); if (connection instanceof JarURLConnection) { - boolean copiedFiles = copyDirectoryFromJar((JarURLConnection) connection, destination, skipIfUnchanged); + boolean copiedFiles = copyFromJar((JarURLConnection) connection, destination, skipIfUnchanged); if (!copiedFiles) { throw new TargetResourceNotFoundException(source); } } else { try { Path dir = Paths.get(FileLocator.toFileURL(resource).toURI()); - copyDirectory(dir, destination, skipIfUnchanged); + if (dir.toFile().isDirectory()) { + copyFile(dir, destination, skipIfUnchanged); + } else { + copyDirectory(dir, destination, skipIfUnchanged); + } } catch(URISyntaxException e) { // This should never happen as toFileURL should always return a valid URL throw new IOException("Unexpected error while resolving " + source + " on the classpath"); @@ -418,7 +387,7 @@ public static void copyDirectoryFromClassPath(final String source, final Path de * @return true if any files were copied * @throws IOException If the given source cannot be copied. */ - private static boolean copyDirectoryFromJar(JarURLConnection connection, final Path destination, final boolean skipIfUnchanged) throws IOException { + private static boolean copyFromJar(JarURLConnection connection, final Path destination, final boolean skipIfUnchanged) throws IOException { final JarFile jar = connection.getJarFile(); final String connectionEntryName = connection.getEntryName(); @@ -431,9 +400,10 @@ private static boolean copyDirectoryFromJar(JarURLConnection connection, final P // Extract files only if they match the given source path. if (entryName.startsWith(connectionEntryName)) { - String filename = entryName.equals(connectionEntryName) ? - connectionEntryName : - entryName.substring(connectionEntryName.length() + 1); + // Gobble up the separator only if there is one. + String filename = entryName.equals(connectionEntryName) ? entryName : + entry.getName().substring(connectionEntryName.length() + 1); + Path currentFile = destination.resolve(filename); if (entry.isDirectory()) { Files.createDirectories(currentFile); @@ -610,7 +580,7 @@ public static Path findInPackage(Path fileOrDirectory, FileConfig fileConfig) { loc -> Files.exists(loc.resolve(relPath)) ).findFirst(); if (found.isPresent()) { - return found.get().resolve(relPath); + return found.get().resolve(relPath).toAbsolutePath(); } } return null; From c8c2bf08dd6209dad3da2cb88c33225879f81d1f Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 2 May 2023 23:24:20 -0700 Subject: [PATCH 234/709] More fixes --- org.lflang/src/org/lflang/util/FileUtil.java | 48 ++++++++++++++------ 1 file changed, 34 insertions(+), 14 deletions(-) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 746835f7cb..2cb66d6c67 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -261,7 +261,7 @@ public static void copyFiles( var found = FileUtil.findInPackage(path, fileConfig); if (found != null) { try { - FileUtil.copyFromFileSystem(found, destination.resolve(path.getFileName())); + FileUtil.copyFromFileSystem(found, destination); System.out.println("Copied '" + fileOrDirectory + "' from the file system."); } catch (IOException e) { errorReporter.reportError( @@ -296,7 +296,7 @@ public static void copyFromFileSystem(Path source, Path destination) throws IOEx if (Files.isDirectory(source)) { copyDirectory(source, destination); } else if (Files.isRegularFile(source)) { - copyFile(source, destination); + copyFile(source, destination.resolve(source.getFileName())); // FIXME: should copyFile have the same API and have a directory as the second argument? } else { throw new IllegalArgumentException("Source is neither a directory nor a regular file."); } @@ -360,11 +360,11 @@ public static void copyFromClassPath(final String source, final Path destination } } else { try { - Path dir = Paths.get(FileLocator.toFileURL(resource).toURI()); - if (dir.toFile().isDirectory()) { - copyFile(dir, destination, skipIfUnchanged); + Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); + if (path.toFile().isDirectory()) { + copyDirectory(path, destination, skipIfUnchanged); } else { - copyDirectory(dir, destination, skipIfUnchanged); + copyFile(path, destination.resolve(path.getFileName()), skipIfUnchanged); } } catch(URISyntaxException e) { // This should never happen as toFileURL should always return a valid URL @@ -373,6 +373,26 @@ public static void copyFromClassPath(final String source, final Path destination } } + /** + * Return true if the given connection points to a file. + * @param connection A connection to a JAR file. + * @throws IOException If the connection is faulty. + */ + private static boolean isFileInJar(JarURLConnection connection) throws IOException { + return connection.getJarFile().stream().filter( + it -> it.getName().equals(connection.getEntryName()) + ).findFirst().isPresent(); + } + + private static void copyFileFromJar(JarFile jar, String source, Path destination, boolean skipIfUnchanged) throws IOException { + var entry = jar.getJarEntry(source); + var filename = Paths.get(entry.getName()).getFileName(); + InputStream is = jar.getInputStream(entry); + try (is) { + copyInputStream(is, destination.resolve(filename), skipIfUnchanged); + } + } + /** * Copy a directory from a jar to a destination path in the filesystem. * @@ -389,7 +409,12 @@ public static void copyFromClassPath(final String source, final Path destination */ private static boolean copyFromJar(JarURLConnection connection, final Path destination, final boolean skipIfUnchanged) throws IOException { final JarFile jar = connection.getJarFile(); - final String connectionEntryName = connection.getEntryName(); + final String source = connection.getEntryName(); + + if (isFileInJar(connection)) { + copyFileFromJar(jar, source, destination, skipIfUnchanged); + return true; + } boolean copiedFiles = false; @@ -397,13 +422,8 @@ private static boolean copyFromJar(JarURLConnection connection, final Path desti for (Enumeration e = jar.entries(); e.hasMoreElements(); ) { final JarEntry entry = e.nextElement(); final String entryName = entry.getName(); - - // Extract files only if they match the given source path. - if (entryName.startsWith(connectionEntryName)) { - // Gobble up the separator only if there is one. - String filename = entryName.equals(connectionEntryName) ? entryName : - entry.getName().substring(connectionEntryName.length() + 1); - + if (entryName.startsWith(source)) { + String filename = entry.getName().substring(source.length() + 1); Path currentFile = destination.resolve(filename); if (entry.isDirectory()) { Files.createDirectories(currentFile); From e28065cf09021920b92dce929e1db733a11567b2 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Wed, 3 May 2023 19:45:28 +0500 Subject: [PATCH 235/709] Update in SubModule & Minor Changes in Pair<> --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/util/Pair.java | 22 +++++++++++----------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 8523f14b96..1d762fd8b3 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 8523f14b962ae56aad375dde22141a600821fdce +Subproject commit 1d762fd8b367c84cb92e6314591b3bcd650bae8b diff --git a/org.lflang/src/org/lflang/util/Pair.java b/org.lflang/src/org/lflang/util/Pair.java index 9e237104d3..ef2ac123c4 100644 --- a/org.lflang/src/org/lflang/util/Pair.java +++ b/org.lflang/src/org/lflang/util/Pair.java @@ -23,26 +23,26 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * @section DESCRIPTION * * This Class provides a Pair of Templated Types - * This provides the same facility as std::pair in C++ + * This provides the same facility as std::pair in C++ */ package org.lflang.util; -public final class Pair { - private final T first; - private final U second; - public Pair(final T t, final U u) +public final class Pair { + private final T1 first; + private final T2 second; + public Pair(final T1 t1, final T2 t2) { - this.first = t; - this.second = u; + this.first = t1; + this.second = t2; } - public T getFirst() + public T1 getFirst() { return this.first; } - public U getSecond() + public T2 getSecond() { return this.second; } @@ -54,7 +54,7 @@ public boolean equals(Object other) { if (this == other) return true; if (this.getClass().equals(other.getClass())) { - Pair otherPair = (Pair) other; + var otherPair = (Pair) other; boolean isEqual = (first == null) ? otherPair.getFirst() == null : first.equals(otherPair.getFirst()); if (!isEqual) @@ -72,6 +72,6 @@ public int hashCode() { @Override public String toString() { - return "Pair(" + first + ", " + second + ")"; + return "Pair<" + first + ", " + second + ">"; } } From b0de39de9b16a4d6e92b20ee105eea13e484ef65 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 3 May 2023 12:49:27 -0700 Subject: [PATCH 236/709] Clarifications in docs and API --- .../org/lflang/generator/GeneratorBase.java | 2 +- .../org/lflang/generator/c/CGenerator.java | 6 +- .../org/lflang/generator/rust/RustEmitter.kt | 2 +- org.lflang/src/org/lflang/util/FileUtil.java | 77 ++++++++++--------- 4 files changed, 45 insertions(+), 42 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 15d703bcbf..992ce5e1a5 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -350,7 +350,7 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * @param fileConfig The fileConfig used to make the copy and resolve paths. */ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - FileUtil.copyFiles(targetConfig.files, this.context.getFileConfig().getSrcGenPath(), fileConfig, errorReporter); + FileUtil.copyFilesOrDirectories(targetConfig.files, this.context.getFileConfig().getSrcGenPath(), fileConfig, errorReporter); } /** diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index bbd0007961..8bc7566608 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -830,7 +830,7 @@ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { // Must use class variable to determine destination! var destination = this.fileConfig.getSrcGenPath(); - FileUtil.copyFiles(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter); + FileUtil.copyFilesOrDirectories(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter); // FIXME: Unclear what the following does, but it does not appear to belong here. if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { @@ -904,7 +904,7 @@ private void generateHeaders() throws IOException { }, this::generateTopLevelPreambles); } - FileUtil.copyDirectory(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + FileUtil.copyDirectoryContents(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); } /** @@ -960,7 +960,7 @@ protected void copyTargetFiles() throws IOException { Path dest = fileConfig.getSrcGenPath(); if (targetConfig.platformOptions.platform == Platform.ARDUINO) dest = dest.resolve("src"); if (coreLib != null) { - FileUtil.copyDirectory(Path.of(coreLib), dest, true); + FileUtil.copyDirectoryContents(Path.of(coreLib), dest, true); } else { FileUtil.copyFromClassPath( "/lib/c/reactor-c/core", diff --git a/org.lflang/src/org/lflang/generator/rust/RustEmitter.kt b/org.lflang/src/org/lflang/generator/rust/RustEmitter.kt index 7a36bce23e..525acd3dc3 100644 --- a/org.lflang/src/org/lflang/generator/rust/RustEmitter.kt +++ b/org.lflang/src/org/lflang/generator/rust/RustEmitter.kt @@ -73,7 +73,7 @@ object RustEmitter : RustEmitterBase() { for (modPath in gen.crate.modulesToIncludeInMain) { val target = fileConfig.srcGenPath.resolve("src").resolve(modPath.fileName) if (Files.isDirectory(modPath)) { - FileUtil.copyDirectory(modPath, target) + FileUtil.copyDirectoryContents(modPath, target) } else { FileUtil.copyFile(modPath, target) } diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 2cb66d6c67..bec2118ecf 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -163,17 +163,16 @@ public static java.net.URI locateFile(String path, Resource resource) { } /** - * Recursively copies the contents of the given 'src' - * directory to 'dest'. Existing files of the destination - * may be overwritten. + * Recursively copy the contents of the given 'srcDir' into the given 'dstDir'. + * Existing files of the destination may be overwritten. * - * @param src The source directory path. - * @param dest The destination directory path. + * @param srcDir The source directory path. + * @param dstDir The destination directory path. * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not be changed * @throws IOException if copy fails. */ - public static void copyDirectory(final Path src, final Path dest, final boolean skipIfUnchanged) throws IOException { - try (Stream stream = Files.walk(src)) { + public static void copyDirectoryContents(final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + try (Stream stream = Files.walk(srcDir)) { stream.forEach(source -> { // Handling checked exceptions in lambda expressions is // hard. See @@ -182,7 +181,7 @@ public static void copyDirectory(final Path src, final Path dest, final boolean // here. if (Files.isRegularFile(source)) { // do not copy directories try { - Path target = dest.resolve(src.relativize(source)); + Path target = dstDir.resolve(srcDir.relativize(source)); Files.createDirectories(target.getParent()); copyFile(source, target, skipIfUnchanged); } catch (IOException e) { @@ -195,68 +194,72 @@ public static void copyDirectory(final Path src, final Path dest, final boolean } } + public static void copyDirectory(final Path srcDir, final Path dstDir) throws IOException { + copyDirectoryContents(srcDir, dstDir.resolve(srcDir.getFileName()), false); + } + /** - * Recursively copies the contents of the given 'src' - * directory to 'dest'. Existing files of the destination - * may be overwritten. + * Recursively copy the contents of the given 'srcDir' + * to 'dstDir'. + * Existing files of the destination may be overwritten. * - * @param src The source directory path. - * @param dest The destination directory path. + * @param srcDir The directory to copy files from. + * @param dstDir The directory to copy files to. * @throws IOException if copy fails. */ - public static void copyDirectory(final Path src, final Path dest) throws IOException { - copyDirectory(src, dest, false); + public static void copyDirectoryContents(final Path srcDir, final Path dstDir) throws IOException { + copyDirectoryContents(srcDir, dstDir, false); } /** - * Copy a given file from 'source' to 'destination'. + * Copy a given file from 'srcFile' to 'dstFile'. * - * This also creates new directories for any directories on the destination - * path that do not yet exist. + * This also creates new directories for any directories + * on the path to `dstFile` that do not yet exist. * - * @param source The source file path. - * @param destination The destination file path. + * @param srcFile The source file path. + * @param dstFile The destination file path. * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not be changed * @throws IOException if copy fails. */ - public static void copyFile(Path source, Path destination, boolean skipIfUnchanged) throws IOException { - BufferedInputStream stream = new BufferedInputStream(new FileInputStream(source.toFile())); + public static void copyFile(Path srcFile, Path dstFile, boolean skipIfUnchanged) throws IOException { + BufferedInputStream stream = new BufferedInputStream(new FileInputStream(srcFile.toFile())); try (stream) { - copyInputStream(stream, destination, skipIfUnchanged); + copyInputStream(stream, dstFile, skipIfUnchanged); } } /** - * Copy a given file from 'source' to 'destination'. + * Copy a 'srcFile' to 'dstFile'. * - * This also creates new directories for any directories on the destination - * path that do not yet exist. + * This also creates new directories for any directories + * on the path to `dstFile` that do not yet exist. * - * @param source The source file path. - * @param destination The destination file path. + * @param srcFile The source file path. + * @param dstFile The destination file path. * @throws IOException if copy fails. */ - public static void copyFile(Path source, Path destination) throws IOException { - copyFile(source, destination, false); + public static void copyFile(Path srcFile, Path dstFile) throws IOException { + copyFile(srcFile, dstFile, false); } /** * Given a list of files or directories, attempt to find them based on the given generator - * context, and copy then to the destination. Files are searched for in the file system first. - * Files that cannot be found in the file system are looked for on the class path. + * context, and copy them to the destination. Entries are searched for in the file system first. + * Entries that cannot be found in the file system are looked for on the class path. * - * @param filesOrDirectories The files or directories to copy. + * @param entries The files or directories to copy. * @param destination The location to copy them to. * @param fileConfig The file configuration that specifies where the files must be found. * @param errorReporter An error reporter to report problems. */ - public static void copyFiles( - List filesOrDirectories, + public static void copyFilesOrDirectories( + List entries, Path destination, FileConfig fileConfig, ErrorReporter errorReporter ) { - for (String fileOrDirectory : filesOrDirectories) { + for (String fileOrDirectory : entries) { var path = Paths.get(fileOrDirectory); var found = FileUtil.findInPackage(path, fileConfig); if (found != null) { @@ -362,7 +365,7 @@ public static void copyFromClassPath(final String source, final Path destination try { Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); if (path.toFile().isDirectory()) { - copyDirectory(path, destination, skipIfUnchanged); + copyDirectoryContents(path, destination, skipIfUnchanged); } else { copyFile(path, destination.resolve(path.getFileName()), skipIfUnchanged); } From 931ed6c003b9dd2d9b5b7a835997f215207e0284 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 3 May 2023 13:26:15 -0700 Subject: [PATCH 237/709] Fix and simplify TS file dealings --- .../org/lflang/generator/ts/TSGenerator.kt | 29 ++++--------------- org.lflang/src/org/lflang/util/FileUtil.java | 24 +++++++-------- 2 files changed, 18 insertions(+), 35 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 0514a46a9c..7e11b6597a 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -38,7 +38,6 @@ import org.lflang.scoping.LFGlobalScopeProvider import org.lflang.util.FileUtil import java.nio.file.Files import java.nio.file.Path -import java.nio.file.StandardCopyOption import java.util.* private const val NO_NPM_MESSAGE = "The TypeScript target requires npm >= 6.14.4. " + @@ -61,19 +60,13 @@ class TSGenerator( val fileConfig: TSFileConfig = context.fileConfig as TSFileConfig - var devMode = false; + private var devMode = false companion object { /** Path to the TS lib directory (relative to class path) */ const val LIB_PATH = "/lib/ts" - /** - * Names of the configuration files to check for and copy to the generated - * source package root if they cannot be found in the source directory. - */ - val CONFIG_FILES = arrayOf("package.json", "tsconfig.json", ".eslintrc.json") - const val RUNTIME_URL = "git://github.com/lf-lang/reactor-ts.git" fun timeInTargetLanguage(value: TimeValue): String { @@ -223,21 +216,11 @@ class TSGenerator( * as the source file, copy a default version from $LIB_PATH/. */ private fun copyConfigFiles() { - for (configFile in CONFIG_FILES) { - val configFileDest = fileConfig.srcGenPath.resolve(configFile) - val configFileInSrc = fileConfig.srcPath.resolve(configFile) - if (configFileInSrc.toFile().exists()) { - println("Copying $configFileInSrc to $configFileDest") - Files.createDirectories(configFileDest.parent) - Files.copy(configFileInSrc, configFileDest, StandardCopyOption.REPLACE_EXISTING) - } else { - println( - "No '" + configFile + "' exists in " + fileConfig.srcPath + - ". Using default configuration." - ) - FileUtil.copyFromClassPath("$LIB_PATH/$configFile", configFileDest, true) - } - } + FileUtil.copyFromClassPath( + LIB_PATH, + fileConfig.srcGenPath, + true + ) } diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index bec2118ecf..aff553c28e 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -337,41 +337,41 @@ private static void copyInputStream(InputStream source, Path destination, boolea } /** - * Lookup a directory in the classpath and copy its contents to a destination path - * in the filesystem. + * Look up the given entry in the classpath. If it is a file, copy it into the destination + * directory. If it is a directory, copy its contents to the destination directory. * * This also creates new directories for any directories on the destination * path that do not yet exist. * - * @param source The source directory as a path relative to the classpath. - * @param destination The file system path that the source directory is copied to. + * @param entry The entry to be found on the class path and copied to the given destination. + * @param dstDir The file system path that found files are to be copied to. * @param skipIfUnchanged If true, don't overwrite the file if its content would not be changed * @throws IOException If the given source cannot be copied. */ - public static void copyFromClassPath(final String source, final Path destination, final boolean skipIfUnchanged) throws IOException { - final URL resource = FileConfig.class.getResource(source); + public static void copyFromClassPath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + final URL resource = FileConfig.class.getResource(entry); if (resource == null) { - throw new TargetResourceNotFoundException(source); + throw new TargetResourceNotFoundException(entry); } final URLConnection connection = resource.openConnection(); if (connection instanceof JarURLConnection) { - boolean copiedFiles = copyFromJar((JarURLConnection) connection, destination, skipIfUnchanged); + boolean copiedFiles = copyFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged); if (!copiedFiles) { - throw new TargetResourceNotFoundException(source); + throw new TargetResourceNotFoundException(entry); } } else { try { Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); if (path.toFile().isDirectory()) { - copyDirectoryContents(path, destination, skipIfUnchanged); + copyDirectoryContents(path, dstDir, skipIfUnchanged); } else { - copyFile(path, destination.resolve(path.getFileName()), skipIfUnchanged); + copyFile(path, dstDir.resolve(path.getFileName()), skipIfUnchanged); } } catch(URISyntaxException e) { // This should never happen as toFileURL should always return a valid URL - throw new IOException("Unexpected error while resolving " + source + " on the classpath"); + throw new IOException("Unexpected error while resolving " + entry + " on the classpath"); } } } From d2e09ae8ea8203bf1462965f2702a9e2969b1990 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 3 May 2023 13:28:06 -0700 Subject: [PATCH 238/709] Remove FIXME associated with closed issue --- org.lflang/src/org/lflang/generator/ts/TSGenerator.kt | 2 -- 1 file changed, 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 7e11b6597a..7776c21d76 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -181,8 +181,6 @@ class TSGenerator( val manifest = fileConfig.srcGenPath.resolve("package.json"); val rtRegex = Regex("(\"@lf-lang/reactor-ts\")(.+)") if (rtPath != null) rtPath = formatRuntimePath(rtPath) - // FIXME: do better CLI arg validation upstream - // https://github.com/lf-lang/lingua-franca/issues/1429 if (rtPath != null || rtVersion != null) { devMode = true; } From 02311338f630d0eb839119a387e120375091b27e Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 3 May 2023 16:04:12 -0700 Subject: [PATCH 239/709] Get the Cpp tests to compile again --- .../org/lflang/generator/GeneratorBase.java | 2 +- .../org/lflang/generator/c/CGenerator.java | 2 +- .../org/lflang/generator/cpp/CppGenerator.kt | 4 ++-- org.lflang/src/org/lflang/util/FileUtil.java | 23 ++++++++++++++----- 4 files changed, 21 insertions(+), 10 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 992ce5e1a5..01a86b6d96 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -350,7 +350,7 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * @param fileConfig The fileConfig used to make the copy and resolve paths. */ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - FileUtil.copyFilesOrDirectories(targetConfig.files, this.context.getFileConfig().getSrcGenPath(), fileConfig, errorReporter); + FileUtil.copyFilesOrDirectoryContents(targetConfig.files, this.context.getFileConfig().getSrcGenPath(), fileConfig, errorReporter); } /** diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 8bc7566608..79349efe6d 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -830,7 +830,7 @@ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { // Must use class variable to determine destination! var destination = this.fileConfig.getSrcGenPath(); - FileUtil.copyFilesOrDirectories(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter); + FileUtil.copyFilesOrDirectoryContents(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter); // FIXME: Unclear what the following does, but it does not appear to belong here. if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { diff --git a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt index 805846caec..de600900bb 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt @@ -126,11 +126,11 @@ class CppGenerator( // copy static library files over to the src-gen directory val genIncludeDir = srcGenPath.resolve("__include__") listOf("lfutil.hh", "time_parser.hh").forEach { - FileUtil.copyFromClassPath("$libDir/$it", genIncludeDir.resolve(it), true) + FileUtil.copyFromClassPath("$libDir/$it", genIncludeDir, true) } FileUtil.copyFromClassPath( "$libDir/3rd-party/cxxopts.hpp", - genIncludeDir.resolve("CLI").resolve("cxxopts.hpp"), + genIncludeDir.resolve("CLI"), true ) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index aff553c28e..ed945a5a37 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -253,7 +253,7 @@ public static void copyFile(Path srcFile, Path dstFile) throws IOException { * @param fileConfig The file configuration that specifies where the files must be found. * @param errorReporter An error reporter to report problems. */ - public static void copyFilesOrDirectories( + public static void copyFilesOrDirectoryContents( List entries, Path destination, FileConfig fileConfig, @@ -297,9 +297,9 @@ public static void copyFilesOrDirectories( */ public static void copyFromFileSystem(Path source, Path destination) throws IOException { if (Files.isDirectory(source)) { - copyDirectory(source, destination); + copyDirectoryContents(source, destination); } else if (Files.isRegularFile(source)) { - copyFile(source, destination.resolve(source.getFileName())); // FIXME: should copyFile have the same API and have a directory as the second argument? + copyFile(source, destination.resolve(source.getFileName())); } else { throw new IllegalArgumentException("Source is neither a directory nor a regular file."); } @@ -329,6 +329,8 @@ private static void copyInputStream(InputStream source, Path destination, boolea // Delete the file exists but the contents don't match. Files.delete(destination); } + } else if (Files.isDirectory(destination)) { + deleteDirectory(destination); } else if (!Files.exists(parent)) { Files.createDirectories(parent); } @@ -387,12 +389,12 @@ private static boolean isFileInJar(JarURLConnection connection) throws IOExcepti ).findFirst().isPresent(); } - private static void copyFileFromJar(JarFile jar, String source, Path destination, boolean skipIfUnchanged) throws IOException { - var entry = jar.getJarEntry(source); + private static void copyFileFromJar(JarFile jar, String srcFile, Path dstDir, boolean skipIfUnchanged) throws IOException { + var entry = jar.getJarEntry(srcFile); var filename = Paths.get(entry.getName()).getFileName(); InputStream is = jar.getInputStream(entry); try (is) { - copyInputStream(is, destination.resolve(filename), skipIfUnchanged); + copyInputStream(is, dstDir.resolve(filename), skipIfUnchanged); } } @@ -553,6 +555,15 @@ public static void relativeIncludeHelper(Path dir, Path includePath) throws IOEx } } + public static void delete(Path fileOrDirectory) throws IOException { + if (Files.isRegularFile(fileOrDirectory)) { + Files.deleteIfExists(fileOrDirectory); + } + if (Files.isDirectory(fileOrDirectory)) { + deleteDirectory(fileOrDirectory); + } + } + /** * Recursively delete a directory if it exists. * From c77388e9d5a88e8acd5b16c279d7b81a5e505a5d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 3 May 2023 16:22:54 -0700 Subject: [PATCH 240/709] Fix Zephyr tests --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 79349efe6d..962ba6cfda 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -983,13 +983,13 @@ protected void copyTargetFiles() throws IOException { ); FileUtil.copyFromClassPath( "/lib/platform/zephyr/prj_lf.conf", - fileConfig.getSrcGenPath().resolve("prj_lf.conf"), + fileConfig.getSrcGenPath(), true ); FileUtil.copyFromClassPath( "/lib/platform/zephyr/Kconfig", - fileConfig.getSrcGenPath().resolve("Kconfig"), + fileConfig.getSrcGenPath(), true ); } From feb0d86001038e7e8df4a9abf628ebe940a24b9d Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 4 May 2023 13:22:39 +0200 Subject: [PATCH 241/709] produce an error if 'extends' is used in a target that does not support it --- org.lflang/src/org/lflang/Target.java | 10 ++++++++++ org.lflang/src/org/lflang/validation/LFValidator.java | 5 +++++ 2 files changed, 15 insertions(+) diff --git a/org.lflang/src/org/lflang/Target.java b/org.lflang/src/org/lflang/Target.java index 11247b6648..6a5c87c6f6 100644 --- a/org.lflang/src/org/lflang/Target.java +++ b/org.lflang/src/org/lflang/Target.java @@ -462,6 +462,16 @@ public boolean isReservedIdent(String ident) { return this.keywords.contains(ident); } + /** + * Return true if the target supports reactor inheritance (extends keyword). + */ + public boolean supportsInheritance() { + return switch (this) { + case C, CCPP, Python -> true; + default -> false; + }; + } + /** * Return true if the target supports multiports and banks * of reactors. diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 7f1aa5c808..77922c472e 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -971,6 +971,11 @@ public void checkReactor(Reactor reactor) throws IOException { if (reactor.isFederated()) { FedValidator.validateFederatedReactor(reactor, this.errorReporter); } + + if (!reactor.getSuperClasses().isEmpty() && !target.supportsInheritance()) { + error("The " + target.name() + " target does not support reactor inheritance.", + Literals.REACTOR__SUPER_CLASSES); + } } /** From ae20b1c1fd9fe2070892cf9202df0a3db5f69fed Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 4 May 2023 13:29:45 +0200 Subject: [PATCH 242/709] produce an error if 'federated' is used in a target that does not support it --- org.lflang/src/org/lflang/Target.java | 10 ++++++++++ org.lflang/src/org/lflang/validation/LFValidator.java | 7 ++++++- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/Target.java b/org.lflang/src/org/lflang/Target.java index 6a5c87c6f6..70dbe9d661 100644 --- a/org.lflang/src/org/lflang/Target.java +++ b/org.lflang/src/org/lflang/Target.java @@ -462,6 +462,16 @@ public boolean isReservedIdent(String ident) { return this.keywords.contains(ident); } + /** + * Return true if the target supports federated execution. + */ + public boolean supportsFederated() { + return switch (this) { + case C, CCPP, Python, TS -> true; + default -> false; + }; + } + /** * Return true if the target supports reactor inheritance (extends keyword). */ diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 77922c472e..db219e516f 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -969,11 +969,16 @@ public void checkReactor(Reactor reactor) throws IOException { } if (reactor.isFederated()) { + if(!target.supportsFederated()) { + error("The " + target.getDisplayName() + " target does not support federated execution.", + Literals.REACTOR__FEDERATED); + } + FedValidator.validateFederatedReactor(reactor, this.errorReporter); } if (!reactor.getSuperClasses().isEmpty() && !target.supportsInheritance()) { - error("The " + target.name() + " target does not support reactor inheritance.", + error("The " + target.getDisplayName() + " target does not support reactor inheritance.", Literals.REACTOR__SUPER_CLASSES); } } From f7c55f3bc94f4451d9735d12658012906b4b99a3 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 4 May 2023 14:29:28 +0200 Subject: [PATCH 243/709] add validation tests --- .../compiler/LinguaFrancaValidationTest.java | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java index 847a364193..e3ca78aaf2 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java @@ -812,6 +812,41 @@ public void testPreambleVisibility() throws Exception { } } + @Test + public void testInheritanceSupport() throws Exception { + for (Target target : Target.values()) { + Model model = parseWithoutError(""" + target %s + reactor A{} + reactor B extends A{} + """.formatted(target)); + + if(target.supportsInheritance()) { + validator.assertNoIssues(model); + } else { + validator.assertError(model, LfPackage.eINSTANCE.getReactor(), null, + "The " + target.getDisplayName() + " target does not support reactor inheritance."); + } + } + } + + @Test + public void testFederationSupport() throws Exception { + for (Target target : Target.values()) { + Model model = parseWithoutError(""" + target %s + federated reactor {} + """.formatted(target)); + + if(target.supportsFederated()) { + validator.assertNoIssues(model); + } else { + validator.assertError(model, LfPackage.eINSTANCE.getReactor(), null, + "The " + target.getDisplayName() + " target does not support federated execution."); + } + } + } + /** * Tests for state and parameter declarations, including native lists. From 6cb545448a827d098140acbec381f2a184351606 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 4 May 2023 14:30:08 +0200 Subject: [PATCH 244/709] fix exception during reactor validation --- .../org/lflang/validation/LFValidator.java | 86 +++++++++++-------- 1 file changed, 48 insertions(+), 38 deletions(-) diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index db219e516f..74a54f7435 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -852,29 +852,22 @@ public void checkReaction(Reaction reaction) { // FIXME: improve error message. } - @Check(CheckType.FAST) - public void checkReactor(Reactor reactor) throws IOException { - Set superClasses = ASTUtils.superClasses(reactor); - if (superClasses == null) { - error( - "Problem with superclasses: Either they form a cycle or are not defined", - Literals.REACTOR_DECL__NAME - ); - // Continue checks, but without any superclasses. - superClasses = new LinkedHashSet<>(); - } + public void checkReactorName(Reactor reactor) throws IOException { String name = FileUtil.nameWithoutExtension(reactor.eResource()); - if (reactor.getName() == null) { - if (!reactor.isFederated() && !reactor.isMain()) { + + // Check for illegal names. + if(reactor.getName() != null) { + checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); + + // C++ reactors may not be called 'preamble' + if (this.target == Target.CPP && name.equalsIgnoreCase("preamble")) { error( - "Reactor must be named.", + "Reactor cannot be named '" + name + "'", Literals.REACTOR_DECL__NAME ); - // Prevent NPE in tests below. - return; } } - TreeIterator iter = reactor.eResource().getAllContents(); + if (reactor.isFederated() || reactor.isMain()) { if(reactor.getName() != null && !reactor.getName().equals(name)) { // Make sure that if the name is given, it matches the expected name. @@ -883,38 +876,55 @@ public void checkReactor(Reactor reactor) throws IOException { Literals.REACTOR_DECL__NAME ); } + } else { + // Not federated or main. + if (reactor.getName() == null) { + error( + "Reactor must be named.", + Literals.REACTOR_DECL__NAME + ); + } else { + TreeIterator iter = reactor.eResource().getAllContents(); + int nMain = countMainOrFederated(iter); + if (nMain > 0 && reactor.getName().equals(name)) { + error( + "Name conflict with main reactor.", + Literals.REACTOR_DECL__NAME + ); + } + } + } + } + + @Check(CheckType.FAST) + public void checkReactor(Reactor reactor) throws IOException { + checkReactorName(reactor); + + if (reactor.isFederated() || reactor.isMain()) { // Do not allow multiple main/federated reactors. + TreeIterator iter = reactor.eResource().getAllContents(); int nMain = countMainOrFederated(iter); if (nMain > 1) { EAttribute attribute = Literals.REACTOR__MAIN; if (reactor.isFederated()) { - attribute = Literals.REACTOR__FEDERATED; + attribute = Literals.REACTOR__FEDERATED; } error( "Multiple definitions of main or federated reactor.", attribute ); } - } else { - // Not federated or main. - int nMain = countMainOrFederated(iter); - if (nMain > 0 && reactor.getName().equals(name)) { - error( - "Name conflict with main reactor.", - Literals.REACTOR_DECL__NAME - ); - } } - // Check for illegal names. - checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); - // C++ reactors may not be called 'preamble' - if (this.target == Target.CPP && reactor.getName().equalsIgnoreCase("preamble")) { + Set superClasses = ASTUtils.superClasses(reactor); + if (superClasses == null) { error( - "Reactor cannot be named '" + reactor.getName() + "'", - Literals.REACTOR_DECL__NAME + "Problem with superclasses: Either they form a cycle or are not defined", + Literals.REACTOR_DECL__NAME ); + // Continue checks, but without any superclasses. + superClasses = new LinkedHashSet<>(); } if (reactor.getHost() != null) { @@ -933,6 +943,11 @@ public void checkReactor(Reactor reactor) throws IOException { variables.addAll(reactor.getActions()); variables.addAll(reactor.getTimers()); + if (!reactor.getSuperClasses().isEmpty() && !target.supportsInheritance()) { + error("The " + target.getDisplayName() + " target does not support reactor inheritance.", + Literals.REACTOR__SUPER_CLASSES); + } + // Perform checks on super classes. for (Reactor superClass : superClasses) { HashSet conflicts = new HashSet<>(); @@ -976,11 +991,6 @@ public void checkReactor(Reactor reactor) throws IOException { FedValidator.validateFederatedReactor(reactor, this.errorReporter); } - - if (!reactor.getSuperClasses().isEmpty() && !target.supportsInheritance()) { - error("The " + target.getDisplayName() + " target does not support reactor inheritance.", - Literals.REACTOR__SUPER_CLASSES); - } } /** From 71ed7af63749a03d06b5247161fe80c9fe61f00f Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 13:40:26 -0700 Subject: [PATCH 245/709] Ready for CI run. Docs and cleanup will follow --- .../org/lflang/generator/GeneratorBase.java | 7 +- .../org/lflang/generator/c/CGenerator.java | 23 ++- .../org/lflang/generator/cpp/CppGenerator.kt | 8 +- .../generator/python/PythonGenerator.java | 15 +- .../org/lflang/generator/ts/TSGenerator.kt | 1 + org.lflang/src/org/lflang/util/FileUtil.java | 155 +++++++++++++----- 6 files changed, 149 insertions(+), 60 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 01a86b6d96..407b1c501a 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -350,7 +350,12 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * @param fileConfig The fileConfig used to make the copy and resolve paths. */ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - FileUtil.copyFilesOrDirectoryContents(targetConfig.files, this.context.getFileConfig().getSrcGenPath(), fileConfig, errorReporter); + FileUtil.copyFilesOrDirectories( + targetConfig.files, + this.context.getFileConfig().getSrcGenPath(), + fileConfig, + errorReporter, + false); } /** diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 962ba6cfda..6ec5e80226 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -830,7 +830,8 @@ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { // Must use class variable to determine destination! var destination = this.fileConfig.getSrcGenPath(); - FileUtil.copyFilesOrDirectoryContents(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter); + // NOTE: All entries should be files, but we are not checking this. + FileUtil.copyFilesOrDirectories(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter, true); // FIXME: Unclear what the following does, but it does not appear to belong here. if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { @@ -886,7 +887,8 @@ private void generateHeaders() throws IOException { FileUtil.copyFromClassPath( fileConfig.getRuntimeIncludePath(), fileConfig.getIncludePath(), - false + false, + true ); for (Reactor r : reactors) { CReactorHeaderFileGenerator.doGenerate( @@ -964,13 +966,15 @@ protected void copyTargetFiles() throws IOException { } else { FileUtil.copyFromClassPath( "/lib/c/reactor-c/core", - dest.resolve("core"), - true + dest, + true, + false ); FileUtil.copyFromClassPath( "/lib/c/reactor-c/lib", - dest.resolve("lib"), - true + dest, + true, + false ); } @@ -978,16 +982,17 @@ protected void copyTargetFiles() throws IOException { if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { FileUtil.copyFromClassPath( "/lib/platform/zephyr/boards", - fileConfig.getSrcGenPath().resolve("boards"), + fileConfig.getSrcGenPath(), + false, false ); - FileUtil.copyFromClassPath( + FileUtil.copySingleFileFromClasspath( "/lib/platform/zephyr/prj_lf.conf", fileConfig.getSrcGenPath(), true ); - FileUtil.copyFromClassPath( + FileUtil.copySingleFileFromClasspath( "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath(), true diff --git a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt index de600900bb..60b450d2c2 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt @@ -126,13 +126,12 @@ class CppGenerator( // copy static library files over to the src-gen directory val genIncludeDir = srcGenPath.resolve("__include__") listOf("lfutil.hh", "time_parser.hh").forEach { - FileUtil.copyFromClassPath("$libDir/$it", genIncludeDir, true) + FileUtil.copySingleFileFromClasspath("$libDir/$it", genIncludeDir, true) } - FileUtil.copyFromClassPath( + FileUtil.copySingleFileFromClasspath( "$libDir/3rd-party/cxxopts.hpp", genIncludeDir.resolve("CLI"), - true - ) + true) // copy or download reactor-cpp if (targetConfig.externalRuntimePath == null) { @@ -142,6 +141,7 @@ class CppGenerator( FileUtil.copyFromClassPath( "$libDir/reactor-cpp", fileConfig.srcGenBasePath.resolve("reactor-cpp-default"), + true, true ) } diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 361e06e285..2686c98539 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -661,18 +661,21 @@ protected void copyTargetFiles() throws IOException { super.copyTargetFiles(); FileUtil.copyFromClassPath( "/lib/py/reactor-c-py/include", - fileConfig.getSrcGenPath().resolve("include"), - true + fileConfig.getSrcGenPath(), + true, + false ); FileUtil.copyFromClassPath( "/lib/py/reactor-c-py/lib", - fileConfig.getSrcGenPath().resolve("lib"), - true + fileConfig.getSrcGenPath(), + true, + false ); FileUtil.copyFromClassPath( "/lib/py/reactor-c-py/LinguaFrancaBase", - fileConfig.getSrcGenPath().resolve("LinguaFrancaBase"), - true + fileConfig.getSrcGenPath(), + true, + false ); } diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 7776c21d76..49dd3444e1 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -217,6 +217,7 @@ class TSGenerator( FileUtil.copyFromClassPath( LIB_PATH, fileConfig.srcGenPath, + true, true ) } diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index ed945a5a37..bbd4a5439f 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -194,8 +194,8 @@ public static void copyDirectoryContents(final Path srcDir, final Path dstDir, f } } - public static void copyDirectory(final Path srcDir, final Path dstDir) throws IOException { - copyDirectoryContents(srcDir, dstDir.resolve(srcDir.getFileName()), false); + public static void copyDirectory(final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + copyDirectoryContents(srcDir, dstDir.resolve(srcDir.getFileName()), skipIfUnchanged); } /** @@ -243,28 +243,30 @@ public static void copyFile(Path srcFile, Path dstFile) throws IOException { copyFile(srcFile, dstFile, false); } + /** - * Given a list of files or directories, attempt to find them based on the given generator + * Given a list of files or directories, attempt to find them using the given generator * context, and copy them to the destination. Entries are searched for in the file system first. * Entries that cannot be found in the file system are looked for on the class path. * - * @param entries The files or directories to copy. - * @param destination The location to copy them to. + * @param entries The files or directory contents to copy. + * @param dstDir The location to copy the files to. * @param fileConfig The file configuration that specifies where the files must be found. * @param errorReporter An error reporter to report problems. */ - public static void copyFilesOrDirectoryContents( + public static void copyFilesOrDirectories( List entries, - Path destination, + Path dstDir, FileConfig fileConfig, - ErrorReporter errorReporter + ErrorReporter errorReporter, + boolean contentsOnly ) { for (String fileOrDirectory : entries) { var path = Paths.get(fileOrDirectory); var found = FileUtil.findInPackage(path, fileConfig); if (found != null) { try { - FileUtil.copyFromFileSystem(found, destination); + FileUtil.copyFromFileSystem(found, dstDir, contentsOnly); System.out.println("Copied '" + fileOrDirectory + "' from the file system."); } catch (IOException e) { errorReporter.reportError( @@ -275,8 +277,9 @@ public static void copyFilesOrDirectoryContents( try { FileUtil.copyFromClassPath( fileOrDirectory, - destination, - false + dstDir, + false, + contentsOnly ); } catch(IOException e) { errorReporter.reportError( @@ -295,11 +298,15 @@ public static void copyFilesOrDirectoryContents( * @param destination A directory to copy the file(s) at the source to. * @throws IOException */ - public static void copyFromFileSystem(Path source, Path destination) throws IOException { + public static void copyFromFileSystem(Path source, Path destination, boolean contentsOnly) throws IOException { if (Files.isDirectory(source)) { - copyDirectoryContents(source, destination); + if (contentsOnly) { + copyDirectoryContents(source, destination); + } else { + copyDirectory(source, destination, false); + } } else if (Files.isRegularFile(source)) { - copyFile(source, destination.resolve(source.getFileName())); + FileUtil.copyFile(source, destination.resolve(source.getFileName())); } else { throw new IllegalArgumentException("Source is neither a directory nor a regular file."); } @@ -338,19 +345,46 @@ private static void copyInputStream(InputStream source, Path destination, boolea Files.write(destination, bytes); } + public static void copySingleFileFromClasspath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + final URL resource = FileConfig.class.getResource(entry); + + if (resource == null) { + throw new TargetResourceNotFoundException(entry); + } + + final URLConnection connection = resource.openConnection(); + if (connection instanceof JarURLConnection) { + copySingleFileFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged); + } else { + try { + Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); + copyFile(path, dstDir.resolve(path.getFileName()), skipIfUnchanged); + } catch(URISyntaxException e) { + // This should never happen as toFileURL should always return a valid URL + throw new IOException("Unexpected error while resolving " + entry + " on the classpath"); + } + } + } + /** - * Look up the given entry in the classpath. If it is a file, copy it into the destination - * directory. If it is a directory, copy its contents to the destination directory. + * Look up the given entry in the classpath. If it is a file, copy it into the destination + * directory. If it is a directory, copy its contents to the destination directory. * - * This also creates new directories for any directories on the destination - * path that do not yet exist. + * This also creates new directories for any directories on the destination + * path that do not yet exist. * - * @param entry The entry to be found on the class path and copied to the given destination. - * @param dstDir The file system path that found files are to be copied to. - * @param skipIfUnchanged If true, don't overwrite the file if its content would not be changed - * @throws IOException If the given source cannot be copied. + * @param entry The entry to be found on the class path and copied to the given destination. + * @param dstDir The file system path that found files are to be copied to. + * @param skipIfUnchanged If true, don't overwrite the file or directory if its content would not be changed + * @param contentsOnly If true and the entry is a directory, then copy its contents but not the directory itself. + * @throws IOException If the given source cannot be copied. */ - public static void copyFromClassPath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + public static void copyFromClassPath( + final String entry, + final Path dstDir, + final boolean skipIfUnchanged, + final boolean contentsOnly + ) throws IOException { final URL resource = FileConfig.class.getResource(entry); if (resource == null) { @@ -359,7 +393,7 @@ public static void copyFromClassPath(final String entry, final Path dstDir, fina final URLConnection connection = resource.openConnection(); if (connection instanceof JarURLConnection) { - boolean copiedFiles = copyFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged); + boolean copiedFiles = copyFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged, contentsOnly); if (!copiedFiles) { throw new TargetResourceNotFoundException(entry); } @@ -367,7 +401,12 @@ public static void copyFromClassPath(final String entry, final Path dstDir, fina try { Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); if (path.toFile().isDirectory()) { - copyDirectoryContents(path, dstDir, skipIfUnchanged); + if (contentsOnly) { + copyDirectoryContents(path, dstDir, skipIfUnchanged); + } else { + copyDirectory(path, dstDir, skipIfUnchanged); + } + } else { copyFile(path, dstDir.resolve(path.getFileName()), skipIfUnchanged); } @@ -389,7 +428,7 @@ private static boolean isFileInJar(JarURLConnection connection) throws IOExcepti ).findFirst().isPresent(); } - private static void copyFileFromJar(JarFile jar, String srcFile, Path dstDir, boolean skipIfUnchanged) throws IOException { + private static void copySingleFileFromJar(JarFile jar, String srcFile, Path dstDir, boolean skipIfUnchanged) throws IOException { var entry = jar.getJarEntry(srcFile); var filename = Paths.get(entry.getName()).getFileName(); InputStream is = jar.getInputStream(entry); @@ -399,37 +438,57 @@ private static void copyFileFromJar(JarFile jar, String srcFile, Path dstDir, bo } /** - * Copy a directory from a jar to a destination path in the filesystem. + * Copy the contents from an entry in a JAR to destination directory in the filesystem. The entry + * may be a file, in which case it will be copied under the same name into the destination + * directory. If the entry is a directory, then if the 'contentsOnly' flag is set, only the + * contents of the directory will be copied into the destination directory (not the directory + * itself). A directory will be copied as a whole, including its contents, if 'contentsOnly' is + * set to false. * * This method should only be used in standalone mode (lfc). * - * This also creates new directories for any directories on the destination - * path that do not yet exist + * This also creates new directories for any directories on + * the destination path that do not yet exist. * - * @param connection a URLConnection to the source directory within the jar - * @param destination The file system path that the source directory is copied to. - * @param skipIfUnchanged If true, don't overwrite the file if its content would not be changed + * @param connection a URLConnection to the source entry within the jar + * @param dstDir The file system path that entries are copied to. + * @param skipIfUnchanged If true, don't overwrite the file if its content would not be changed. + * @param contentsOnly If true, and the connection points to a directory, copy its contents only + * (not the directory itself). * @return true if any files were copied * @throws IOException If the given source cannot be copied. */ - private static boolean copyFromJar(JarURLConnection connection, final Path destination, final boolean skipIfUnchanged) throws IOException { - final JarFile jar = connection.getJarFile(); - final String source = connection.getEntryName(); - - if (isFileInJar(connection)) { - copyFileFromJar(jar, source, destination, skipIfUnchanged); + private static boolean copyFromJar( + JarURLConnection connection, + Path dstDir, + final boolean skipIfUnchanged, + final boolean contentsOnly + ) throws IOException { + + if (copySingleFileFromJar(connection, dstDir, skipIfUnchanged)) { return true; } + return copyMultipleFilesFromJar(connection, dstDir, skipIfUnchanged, contentsOnly); + } - boolean copiedFiles = false; + private static boolean copyMultipleFilesFromJar(JarURLConnection connection, + Path dstDir, + final boolean skipIfUnchanged, + final boolean contentsOnly) throws IOException { + final JarFile jar = connection.getJarFile(); + final String source = connection.getEntryName(); + boolean copiedFiles = false; + if (!contentsOnly) { + dstDir = dstDir.resolve(Paths.get(source).getFileName()); + } // Iterate all entries in the jar file. for (Enumeration e = jar.entries(); e.hasMoreElements(); ) { final JarEntry entry = e.nextElement(); final String entryName = entry.getName(); if (entryName.startsWith(source)) { String filename = entry.getName().substring(source.length() + 1); - Path currentFile = destination.resolve(filename); + Path currentFile = dstDir.resolve(filename); if (entry.isDirectory()) { Files.createDirectories(currentFile); } else { @@ -444,6 +503,22 @@ private static boolean copyFromJar(JarURLConnection connection, final Path desti return copiedFiles; } + private static boolean copySingleFileFromJar( + JarURLConnection connection, + Path dstDir, + final boolean skipIfUnchanged + ) throws IOException { + final JarFile jar = connection.getJarFile(); + final String source = connection.getEntryName(); + + if (!isFileInJar(connection)) { + return false; + } + copySingleFileFromJar(jar, source, dstDir, skipIfUnchanged); + + return true; + } + /** * Delete unused Files from Arduino-CLI based compilation. * From 5f2c187bccffe6c282d9ecda865d8d473f176063 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 18:05:14 -0700 Subject: [PATCH 246/709] Again, mostly comments --- .../org/lflang/generator/GeneratorBase.java | 8 +- .../org/lflang/generator/c/CGenerator.java | 2 +- org.lflang/src/org/lflang/util/FileUtil.java | 161 +++++++++++++----- 3 files changed, 124 insertions(+), 47 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 407b1c501a..461f571333 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -350,12 +350,8 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * @param fileConfig The fileConfig used to make the copy and resolve paths. */ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - FileUtil.copyFilesOrDirectories( - targetConfig.files, - this.context.getFileConfig().getSrcGenPath(), - fileConfig, - errorReporter, - false); + var dst = this.context.getFileConfig().getSrcGenPath(); + FileUtil.copyFilesOrDirectories(targetConfig.files, dst, fileConfig, errorReporter, false); } /** diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 6ec5e80226..cdf6e4d2f6 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -906,7 +906,7 @@ private void generateHeaders() throws IOException { }, this::generateTopLevelPreambles); } - FileUtil.copyDirectoryContents(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + FileUtil.copyDirectory(fileConfig.getIncludePath(), fileConfig.getSrcGenPath(), false); } /** diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index bbd4a5439f..a876e90940 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -163,13 +163,14 @@ public static java.net.URI locateFile(String path, Resource resource) { } /** - * Recursively copy the contents of the given 'srcDir' into the given 'dstDir'. - * Existing files of the destination may be overwritten. + * Recursively copy the contents of the given source directory into the given destination + * directory. Existing files of the destination may be overwritten. * * @param srcDir The source directory path. * @param dstDir The destination directory path. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not be changed - * @throws IOException if copy fails. + * @param skipIfUnchanged If true, don't overwrite anything in the destination if its content + * would not be changed. + * @throws IOException If the operation fails. */ public static void copyDirectoryContents(final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { try (Stream stream = Files.walk(srcDir)) { @@ -194,14 +195,24 @@ public static void copyDirectoryContents(final Path srcDir, final Path dstDir, f } } - public static void copyDirectory(final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + /** + * Copy the given source directory into the given destination directory. For example, if the + * source directory is {@code foo/bar} and the destination is {@code baz}, then copies of the + * contents of {@code foo/bar} will be located in {@code baz/bar}. + * @param srcDir The source directory path. + * @param dstDir The destination directory path. + * @param skipIfUnchanged If true, don't overwrite anything in the destination if its content + * would not be changed. + * @throws IOException If the operation fails. + */ + public static void copyDirectory( + final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { copyDirectoryContents(srcDir, dstDir.resolve(srcDir.getFileName()), skipIfUnchanged); } /** - * Recursively copy the contents of the given 'srcDir' - * to 'dstDir'. - * Existing files of the destination may be overwritten. + * Recursively copy the contents of the given source directory into the given destination + * directory. Existing files of the destination may be overwritten. * * @param srcDir The directory to copy files from. * @param dstDir The directory to copy files to. @@ -212,15 +223,15 @@ public static void copyDirectoryContents(final Path srcDir, final Path dstDir) t } /** - * Copy a given file from 'srcFile' to 'dstFile'. + * Copy a given source file to a given destination file. * - * This also creates new directories for any directories - * on the path to `dstFile` that do not yet exist. + * This also creates new directories on the path to {@code dstFile} that do not yet exist. * * @param srcFile The source file path. * @param dstFile The destination file path. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not be changed - * @throws IOException if copy fails. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content + * would not be changed. + * @throws IOException If the operation fails. */ public static void copyFile(Path srcFile, Path dstFile, boolean skipIfUnchanged) throws IOException { BufferedInputStream stream = new BufferedInputStream(new FileInputStream(srcFile.toFile())); @@ -230,10 +241,10 @@ public static void copyFile(Path srcFile, Path dstFile, boolean skipIfUnchanged) } /** - * Copy a 'srcFile' to 'dstFile'. + * Copy a given source file to a given destination file. * * This also creates new directories for any directories - * on the path to `dstFile` that do not yet exist. + * on the path to {@code dstFile} that do not yet exist. * * @param srcFile The source file path. * @param dstFile The destination file path. @@ -245,13 +256,21 @@ public static void copyFile(Path srcFile, Path dstFile) throws IOException { /** - * Given a list of files or directories, attempt to find them using the given generator - * context, and copy them to the destination. Entries are searched for in the file system first. - * Entries that cannot be found in the file system are looked for on the class path. + * Given a list of files or directories, attempt to find each entry based on the given generator + * context and copy it to the destination directory. Entries are searched for in the file system + * first, relative to the source file and relative to the package root. Entries that cannot be + * found in the file system are looked for on the class path. + *

+ * If {@code contentsOnly} is true, then for each entry that is a directory, only its contents + * are copied, not the directory itself. + * For example, if the entry is a directory {@code foo/bar} and the destination is {@code baz}, + * then copies of the contents of {@code foo/bar} will be located directly in {@code baz}. + * If {@code contentsOnly} is false, then copies of the contents of {@code foo/bar} will be + * located in {@code baz/bar}. * - * @param entries The files or directory contents to copy. + * @param entries The files or directories to copy from. * @param dstDir The location to copy the files to. - * @param fileConfig The file configuration that specifies where the files must be found. + * @param fileConfig The file configuration that specifies where the find entries the given entries. * @param errorReporter An error reporter to report problems. */ public static void copyFilesOrDirectories( @@ -292,21 +311,26 @@ public static void copyFilesOrDirectories( } /** - * If the source is a directory, then copy the contents of the directory to the destination. - * If the source is a file, then copy the file to the destination. - * @param source A file or directory to copy to the destination. - * @param destination A directory to copy the file(s) at the source to. - * @throws IOException + * If the given {@code entry} is a file, then copy it into the destination. If the {@code entry} + * is a directory and {@code contentsOnly} is true, then copy its contents to the destination + * directory. If the {@code entry} is a directory and {@code contentsOnly} is true, then copy it + * including its contents to the destination directory. + * + * @param entry A file or directory to copy to the destination directory. + * @param dstDir A directory to copy the entry or its contents to. + * @param contentsOnly If true and {@code entry} is a directory, then copy its contents but not + * the directory itself. + * @throws IOException If the operation fails. */ - public static void copyFromFileSystem(Path source, Path destination, boolean contentsOnly) throws IOException { - if (Files.isDirectory(source)) { + public static void copyFromFileSystem(Path entry, Path dstDir, boolean contentsOnly) throws IOException { + if (Files.isDirectory(entry)) { if (contentsOnly) { - copyDirectoryContents(source, destination); + copyDirectoryContents(entry, dstDir); } else { - copyDirectory(source, destination, false); + copyDirectory(entry, dstDir, false); } - } else if (Files.isRegularFile(source)) { - FileUtil.copyFile(source, destination.resolve(source.getFileName())); + } else if (Files.isRegularFile(entry)) { + FileUtil.copyFile(entry, dstDir.resolve(entry.getFileName())); } else { throw new IllegalArgumentException("Source is neither a directory nor a regular file."); } @@ -319,8 +343,9 @@ public static void copyFromFileSystem(Path source, Path destination, boolean con * * @param source The source input stream. * @param destination The destination file path. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not be changed - * @throws IOException if copy fails. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content would + * not be changed. + * @throws IOException If the operation fails. */ private static void copyInputStream(InputStream source, Path destination, boolean skipIfUnchanged) throws IOException { // Read the stream once and keep a copy of all bytes. This is required as a stream cannot be read twice. @@ -345,6 +370,16 @@ private static void copyInputStream(InputStream source, Path destination, boolea Files.write(destination, bytes); } + /** + * Look up the given {@code entry} in the classpath. If it is found and is a file, copy it into + * the destination directory. If the entry is not found or not a file, throw an exception. + * + * @param entry A file copy to the destination directory. + * @param dstDir A directory to copy the entry to. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content would + * not be changed. + * @throws IOException If the operation failed. + */ public static void copySingleFileFromClasspath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { final URL resource = FileConfig.class.getResource(entry); @@ -354,7 +389,9 @@ public static void copySingleFileFromClasspath(final String entry, final Path ds final URLConnection connection = resource.openConnection(); if (connection instanceof JarURLConnection) { - copySingleFileFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged); + if (!copySingleFileFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged)) { + throw new IOException("'" + entry + "' is not a file"); + } } else { try { Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); @@ -367,8 +404,11 @@ public static void copySingleFileFromClasspath(final String entry, final Path ds } /** - * Look up the given entry in the classpath. If it is a file, copy it into the destination - * directory. If it is a directory, copy its contents to the destination directory. + * Look up the given {@code entry} in the classpath. If it is a file, copy it into the destination + * directory. + * If the {@code entry} is a directory and {@code contentsOnly} is true, then copy its contents + * to the destination directory. If the {@code entry} is a directory and {@code contentsOnly} is + * true, then copy it including its contents to the destination directory. * * This also creates new directories for any directories on the destination * path that do not yet exist. @@ -377,7 +417,7 @@ public static void copySingleFileFromClasspath(final String entry, final Path ds * @param dstDir The file system path that found files are to be copied to. * @param skipIfUnchanged If true, don't overwrite the file or directory if its content would not be changed * @param contentsOnly If true and the entry is a directory, then copy its contents but not the directory itself. - * @throws IOException If the given source cannot be copied. + * @throws IOException If the operation failed. */ public static void copyFromClassPath( final String entry, @@ -428,6 +468,16 @@ private static boolean isFileInJar(JarURLConnection connection) throws IOExcepti ).findFirst().isPresent(); } + /** + * Given a JAR file and a {@code srcFile} entry, copy it into the given destination directory. + * + * @param jar The JAR file from which to copy {@code srcFile}. + * @param srcFile The source file to copy from the given {@code jar}. + * @param dstDir The directory to top the source file into. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content would + * * not be changed. + * @throws IOException If the operation fails. + */ private static void copySingleFileFromJar(JarFile jar, String srcFile, Path dstDir, boolean skipIfUnchanged) throws IOException { var entry = jar.getJarEntry(srcFile); var filename = Paths.get(entry.getName()).getFileName(); @@ -440,10 +490,10 @@ private static void copySingleFileFromJar(JarFile jar, String srcFile, Path dstD /** * Copy the contents from an entry in a JAR to destination directory in the filesystem. The entry * may be a file, in which case it will be copied under the same name into the destination - * directory. If the entry is a directory, then if the 'contentsOnly' flag is set, only the + * directory. If the entry is a directory, then if {@code contentsOnly} is true, only the * contents of the directory will be copied into the destination directory (not the directory - * itself). A directory will be copied as a whole, including its contents, if 'contentsOnly' is - * set to false. + * itself). A directory will be copied as a whole, including its contents, if + * {@code contentsOnly} is false. * * This method should only be used in standalone mode (lfc). * @@ -471,6 +521,20 @@ private static boolean copyFromJar( return copyMultipleFilesFromJar(connection, dstDir, skipIfUnchanged, contentsOnly); } + /** + * Given a connection to a JAR file that points to an entry that is a directory, copy all entries + * located in that directory or its subdirectories into the given {@code dstDir}. + *

+ * If {@code contentsOnly} is true, only the contents of the directory will be copied into the + * destination directory (not the directory itself). The directory will be copied as a whole, + * including its contents, if {@code contentsOnly} is false. + * @param connection A connection to a JAR file that points to a directory entry. + * @param dstDir The destination directory to copy the matching entries to. + * @param skipIfUnchanged + * @param contentsOnly + * @return + * @throws IOException + */ private static boolean copyMultipleFilesFromJar(JarURLConnection connection, Path dstDir, final boolean skipIfUnchanged, @@ -503,6 +567,16 @@ private static boolean copyMultipleFilesFromJar(JarURLConnection connection, return copiedFiles; } + /** + * Given a connection to a JAR file that points to an entry that is a file, copy the file into the + * given {@code dstDir}. + * @param connection A connection to a JAR file that points to a directory entry. + * @param dstDir The destination directory to copy the file to. + * @param skipIfUnchanged + * @return {@code true} the connection entry is a file, and it was copied successfully; + * {@code false} if the connection entry is not a file and the copy operation was aborted. + * @throws IOException If the operation failed. + */ private static boolean copySingleFileFromJar( JarURLConnection connection, Path dstDir, @@ -630,6 +704,13 @@ public static void relativeIncludeHelper(Path dir, Path includePath) throws IOEx } } + /** + * Delete the given file or directory if it exists. If {@code fileOrDirectory} is a directory, + * deletion is recursive. + * + * @param fileOrDirectory The file or directory to delete. + * @throws IOException If the operation failed. + */ public static void delete(Path fileOrDirectory) throws IOException { if (Files.isRegularFile(fileOrDirectory)) { Files.deleteIfExists(fileOrDirectory); From d4d96662492f48d2372af88b11c50d66b8ae8fb2 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 18:32:39 -0700 Subject: [PATCH 247/709] Revert suspicious change --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index cdf6e4d2f6..6ec5e80226 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -906,7 +906,7 @@ private void generateHeaders() throws IOException { }, this::generateTopLevelPreambles); } - FileUtil.copyDirectory(fileConfig.getIncludePath(), fileConfig.getSrcGenPath(), false); + FileUtil.copyDirectoryContents(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); } /** From bf00460022b53df54d108f3defff01215811e780 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 18:36:37 -0700 Subject: [PATCH 248/709] Remove FIXME that is not a FIXME --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 6ec5e80226..259d146da5 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -425,8 +425,6 @@ protected boolean isOSCompatible() { "LF programs with a CCpp target are currently not supported on Windows. " + "Exiting code generation." ); - // FIXME: The incompatibility between our C runtime code and the - // Visual Studio compiler is extensive. return false; } } From 0a23a7615a2b0c838b6d660a6cb5888b82f33cef Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 19:30:08 -0700 Subject: [PATCH 249/709] Only allow files for cmake-include entries --- .../org/lflang/generator/c/CGenerator.java | 1 - org.lflang/src/org/lflang/util/FileUtil.java | 29 ++++++++++++------- 2 files changed, 19 insertions(+), 11 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 259d146da5..b5c82b5d3b 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -828,7 +828,6 @@ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { // Must use class variable to determine destination! var destination = this.fileConfig.getSrcGenPath(); - // NOTE: All entries should be files, but we are not checking this. FileUtil.copyFilesOrDirectories(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter, true); // FIXME: Unclear what the following does, but it does not appear to belong here. diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index a876e90940..2bd01cc6a9 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -278,31 +278,40 @@ public static void copyFilesOrDirectories( Path dstDir, FileConfig fileConfig, ErrorReporter errorReporter, - boolean contentsOnly + boolean fileEntriesOnly ) { for (String fileOrDirectory : entries) { var path = Paths.get(fileOrDirectory); var found = FileUtil.findInPackage(path, fileConfig); if (found != null) { try { - FileUtil.copyFromFileSystem(found, dstDir, contentsOnly); + if (fileEntriesOnly) { + FileUtil.copyFile(found, dstDir.resolve(path.getFileName())); + } else { + FileUtil.copyFromFileSystem(found, dstDir, false); + } System.out.println("Copied '" + fileOrDirectory + "' from the file system."); } catch (IOException e) { errorReporter.reportError( - "Unable to copy '" + fileOrDirectory + "' from the file system." + "Unable to copy '" + fileOrDirectory + "' from the file system. Reason: " + e.toString() ); } } else { try { - FileUtil.copyFromClassPath( - fileOrDirectory, - dstDir, - false, - contentsOnly - ); + if (fileEntriesOnly) { + copySingleFileFromClasspath(fileOrDirectory, dstDir, false); + } else { + FileUtil.copyFromClassPath( + fileOrDirectory, + dstDir, + false, + false + ); + } + } catch(IOException e) { errorReporter.reportError( - "Unable to copy '" + fileOrDirectory + "' from the class path." + "Unable to copy '" + fileOrDirectory + "' from the class path. Reason: " + e.toString() ); } System.out.println("Copied '" + fileOrDirectory + "' from the class path."); From d674900b0f1651f3ca3911ba5defb204955ca21b Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 19:49:59 -0700 Subject: [PATCH 250/709] Undo unncessary rename --- org.lflang/src/org/lflang/util/FileUtil.java | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 2bd01cc6a9..3ee2e6ce2d 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -398,7 +398,7 @@ public static void copySingleFileFromClasspath(final String entry, final Path ds final URLConnection connection = resource.openConnection(); if (connection instanceof JarURLConnection) { - if (!copySingleFileFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged)) { + if (!copyFileFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged)) { throw new IOException("'" + entry + "' is not a file"); } } else { @@ -487,7 +487,7 @@ private static boolean isFileInJar(JarURLConnection connection) throws IOExcepti * * not be changed. * @throws IOException If the operation fails. */ - private static void copySingleFileFromJar(JarFile jar, String srcFile, Path dstDir, boolean skipIfUnchanged) throws IOException { + private static void copyFileFromJar(JarFile jar, String srcFile, Path dstDir, boolean skipIfUnchanged) throws IOException { var entry = jar.getJarEntry(srcFile); var filename = Paths.get(entry.getName()).getFileName(); InputStream is = jar.getInputStream(entry); @@ -524,10 +524,10 @@ private static boolean copyFromJar( final boolean contentsOnly ) throws IOException { - if (copySingleFileFromJar(connection, dstDir, skipIfUnchanged)) { + if (copyFileFromJar(connection, dstDir, skipIfUnchanged)) { return true; } - return copyMultipleFilesFromJar(connection, dstDir, skipIfUnchanged, contentsOnly); + return copyDirectoryFromJar(connection, dstDir, skipIfUnchanged, contentsOnly); } /** @@ -544,7 +544,7 @@ private static boolean copyFromJar( * @return * @throws IOException */ - private static boolean copyMultipleFilesFromJar(JarURLConnection connection, + private static boolean copyDirectoryFromJar(JarURLConnection connection, Path dstDir, final boolean skipIfUnchanged, final boolean contentsOnly) throws IOException { @@ -586,7 +586,7 @@ private static boolean copyMultipleFilesFromJar(JarURLConnection connection, * {@code false} if the connection entry is not a file and the copy operation was aborted. * @throws IOException If the operation failed. */ - private static boolean copySingleFileFromJar( + private static boolean copyFileFromJar( JarURLConnection connection, Path dstDir, final boolean skipIfUnchanged @@ -597,7 +597,7 @@ private static boolean copySingleFileFromJar( if (!isFileInJar(connection)) { return false; } - copySingleFileFromJar(jar, source, dstDir, skipIfUnchanged); + copyFileFromJar(jar, source, dstDir, skipIfUnchanged); return true; } From 6fcad58151dd0441089227681b8f10a0a99b3a8c Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 20:11:13 -0700 Subject: [PATCH 251/709] Another rename undone --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 4 ++-- org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt | 4 ++-- org.lflang/src/org/lflang/util/FileUtil.java | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b5c82b5d3b..14af96038d 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -983,13 +983,13 @@ protected void copyTargetFiles() throws IOException { false, false ); - FileUtil.copySingleFileFromClasspath( + FileUtil.copyFileFromClasspath( "/lib/platform/zephyr/prj_lf.conf", fileConfig.getSrcGenPath(), true ); - FileUtil.copySingleFileFromClasspath( + FileUtil.copyFileFromClasspath( "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath(), true diff --git a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt index 60b450d2c2..d624cfac9d 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt @@ -126,9 +126,9 @@ class CppGenerator( // copy static library files over to the src-gen directory val genIncludeDir = srcGenPath.resolve("__include__") listOf("lfutil.hh", "time_parser.hh").forEach { - FileUtil.copySingleFileFromClasspath("$libDir/$it", genIncludeDir, true) + FileUtil.copyFileFromClasspath("$libDir/$it", genIncludeDir, true) } - FileUtil.copySingleFileFromClasspath( + FileUtil.copyFileFromClasspath( "$libDir/3rd-party/cxxopts.hpp", genIncludeDir.resolve("CLI"), true) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 3ee2e6ce2d..b2995950c2 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -299,7 +299,7 @@ public static void copyFilesOrDirectories( } else { try { if (fileEntriesOnly) { - copySingleFileFromClasspath(fileOrDirectory, dstDir, false); + copyFileFromClasspath(fileOrDirectory, dstDir, false); } else { FileUtil.copyFromClassPath( fileOrDirectory, @@ -389,7 +389,7 @@ private static void copyInputStream(InputStream source, Path destination, boolea * not be changed. * @throws IOException If the operation failed. */ - public static void copySingleFileFromClasspath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + public static void copyFileFromClasspath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { final URL resource = FileConfig.class.getResource(entry); if (resource == null) { From 6438a2c22e2771e32278ba6f1d46cf4b517713fb Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 20:19:41 -0700 Subject: [PATCH 252/709] Use proper camelCase --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 4 ++-- org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt | 4 ++-- org.lflang/src/org/lflang/util/FileUtil.java | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 14af96038d..c7e585e1ab 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -983,13 +983,13 @@ protected void copyTargetFiles() throws IOException { false, false ); - FileUtil.copyFileFromClasspath( + FileUtil.copyFileFromClassPath( "/lib/platform/zephyr/prj_lf.conf", fileConfig.getSrcGenPath(), true ); - FileUtil.copyFileFromClasspath( + FileUtil.copyFileFromClassPath( "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath(), true diff --git a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt index d624cfac9d..e739560ba8 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt @@ -126,9 +126,9 @@ class CppGenerator( // copy static library files over to the src-gen directory val genIncludeDir = srcGenPath.resolve("__include__") listOf("lfutil.hh", "time_parser.hh").forEach { - FileUtil.copyFileFromClasspath("$libDir/$it", genIncludeDir, true) + FileUtil.copyFileFromClassPath("$libDir/$it", genIncludeDir, true) } - FileUtil.copyFileFromClasspath( + FileUtil.copyFileFromClassPath( "$libDir/3rd-party/cxxopts.hpp", genIncludeDir.resolve("CLI"), true) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index b2995950c2..348bcd6658 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -299,7 +299,7 @@ public static void copyFilesOrDirectories( } else { try { if (fileEntriesOnly) { - copyFileFromClasspath(fileOrDirectory, dstDir, false); + copyFileFromClassPath(fileOrDirectory, dstDir, false); } else { FileUtil.copyFromClassPath( fileOrDirectory, @@ -389,7 +389,7 @@ private static void copyInputStream(InputStream source, Path destination, boolea * not be changed. * @throws IOException If the operation failed. */ - public static void copyFileFromClasspath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + public static void copyFileFromClassPath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { final URL resource = FileConfig.class.getResource(entry); if (resource == null) { From 93c9e5b524b1eaf487e70377ba2a23cd1c87b5ef Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 20:24:30 -0700 Subject: [PATCH 253/709] Fix comment --- org.lflang/src/org/lflang/util/FileUtil.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index 348bcd6658..a0f2e8eccc 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -531,8 +531,8 @@ private static boolean copyFromJar( } /** - * Given a connection to a JAR file that points to an entry that is a directory, copy all entries - * located in that directory or its subdirectories into the given {@code dstDir}. + * Given a connection to a JAR file that points to an entry that is a directory, recursively copy + * all entries located in that directory into the given {@code dstDir}. *

* If {@code contentsOnly} is true, only the contents of the directory will be copied into the * destination directory (not the directory itself). The directory will be copied as a whole, From 2a74c450449c7668b98b8932dea34d1f1ca4f07d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 20:51:05 -0700 Subject: [PATCH 254/709] Revive feature for copying user-specified config files --- .../org/lflang/generator/ts/TSGenerator.kt | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 49dd3444e1..9aae97d175 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -38,6 +38,7 @@ import org.lflang.scoping.LFGlobalScopeProvider import org.lflang.util.FileUtil import java.nio.file.Files import java.nio.file.Path +import java.nio.file.StandardCopyOption import java.util.* private const val NO_NPM_MESSAGE = "The TypeScript target requires npm >= 6.14.4. " + @@ -67,6 +68,12 @@ class TSGenerator( /** Path to the TS lib directory (relative to class path) */ const val LIB_PATH = "/lib/ts" + /** + * Names of the configuration files to check for and copy to the generated + * source package root if they cannot be found in the source directory. + */ + val CONFIG_FILES = arrayOf("package.json", "tsconfig.json", ".eslintrc.json") + const val RUNTIME_URL = "git://github.com/lf-lang/reactor-ts.git" fun timeInTargetLanguage(value: TimeValue): String { @@ -220,6 +227,20 @@ class TSGenerator( true, true ) + for (configFile in CONFIG_FILES) { + val configFileInSrc = fileConfig.srcPath.resolve(configFile) + if (configFileInSrc.toFile().exists()) { + val configFileDest = fileConfig.srcGenPath.resolve(configFile) + println("Copying $configFileInSrc to $configFileDest") + Files.copy(configFileInSrc, configFileDest, StandardCopyOption.REPLACE_EXISTING) + } else { + println( + "No '" + configFile + "' exists in " + fileConfig.srcPath + + ". Using default configuration." + ) + FileUtil.copyFileFromClassPath("$LIB_PATH/$configFile", fileConfig.srcGenPath, true) + } + } } From d4b8238cf0b3851b2f3e16d78bc40c9b9f21d14b Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 22:28:04 -0700 Subject: [PATCH 255/709] Nicer implementation of user-provided config files for TS and cleanups --- .../org/lflang/generator/ts/TSGenerator.kt | 15 ++----- org.lflang/src/org/lflang/util/FileUtil.java | 43 +++++++++++++++---- 2 files changed, 38 insertions(+), 20 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 9aae97d175..db5eb267a2 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -38,7 +38,6 @@ import org.lflang.scoping.LFGlobalScopeProvider import org.lflang.util.FileUtil import java.nio.file.Files import java.nio.file.Path -import java.nio.file.StandardCopyOption import java.util.* private const val NO_NPM_MESSAGE = "The TypeScript target requires npm >= 6.14.4. " + @@ -228,17 +227,11 @@ class TSGenerator( true ) for (configFile in CONFIG_FILES) { - val configFileInSrc = fileConfig.srcPath.resolve(configFile) - if (configFileInSrc.toFile().exists()) { - val configFileDest = fileConfig.srcGenPath.resolve(configFile) - println("Copying $configFileInSrc to $configFileDest") - Files.copy(configFileInSrc, configFileDest, StandardCopyOption.REPLACE_EXISTING) + var override = FileUtil.findAndCopyFile(configFile, fileConfig.srcGenPath, fileConfig); + if (override != null) { + System.out.println("Using user-provided '" + override + "'"); } else { - println( - "No '" + configFile + "' exists in " + fileConfig.srcPath + - ". Using default configuration." - ) - FileUtil.copyFileFromClassPath("$LIB_PATH/$configFile", fileConfig.srcGenPath, true) + System.out.println("Using default '" + configFile + "'"); } } } diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index a0f2e8eccc..eb2550127e 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -254,6 +254,33 @@ public static void copyFile(Path srcFile, Path dstFile) throws IOException { copyFile(srcFile, dstFile, false); } + /** + * Find the given {@code file} in the package and return the path to the file that was found; null + * if it was not found. + * + * @param file The file to look for. + * @param dstDir The directory to copy it to. + * @param fileConfig The file configuration that specifies where look for the file. + * @return The path to the file that was found, or null if it was not found. + */ + public static Path findAndCopyFile( + String file, + Path dstDir, + FileConfig fileConfig + ) { + var path = Paths.get(file); + var found = FileUtil.findInPackage(path, fileConfig); + if (found != null) { + try { + FileUtil.copyFile(found, dstDir.resolve(path.getFileName())); + return found; + } catch (IOException e) { + return null; + } + } else { + return null; + } + } /** * Given a list of files or directories, attempt to find each entry based on the given generator @@ -307,14 +334,13 @@ public static void copyFilesOrDirectories( false, false ); + System.out.println("Copied '" + fileOrDirectory + "' from the class path."); } - } catch(IOException e) { errorReporter.reportError( "Unable to copy '" + fileOrDirectory + "' from the class path. Reason: " + e.toString() ); } - System.out.println("Copied '" + fileOrDirectory + "' from the class path."); } } } @@ -472,9 +498,9 @@ public static void copyFromClassPath( * @throws IOException If the connection is faulty. */ private static boolean isFileInJar(JarURLConnection connection) throws IOException { - return connection.getJarFile().stream().filter( + return connection.getJarFile().stream().anyMatch( it -> it.getName().equals(connection.getEntryName()) - ).findFirst().isPresent(); + ); } /** @@ -625,7 +651,7 @@ public static void arduinoDeleteHelper(Path dir, boolean threadingOn) throws IOE List allPaths = Files.walk(dir) .sorted(Comparator.reverseOrder()) - .collect(Collectors.toList()); + .toList(); for (Path path : allPaths) { String toCheck = path.toString().toLowerCase(); if (toCheck.contains("cmake")) { @@ -680,12 +706,12 @@ public static void relativeIncludeHelper(Path dir, Path includePath) throws IOEx .filter(Files::isRegularFile) .filter(FileUtil::isCFile) .sorted(Comparator.reverseOrder()) - .collect(Collectors.toList()); + .toList(); List srcPaths = Files.walk(dir) .filter(Files::isRegularFile) .filter(FileUtil::isCFile) .sorted(Comparator.reverseOrder()) - .collect(Collectors.toList()); + .toList(); Map fileStringToFilePath = new HashMap(); for (Path path : includePaths) { String fileName = path.getFileName().toString(); @@ -696,7 +722,6 @@ public static void relativeIncludeHelper(Path dir, Path includePath) throws IOEx } Pattern regexExpression = Pattern.compile("#include\s+[\"]([^\"]+)*[\"]"); for (Path path : srcPaths) { - String fileName = path.getFileName().toString(); String fileContents = Files.readString(path); Matcher matcher = regexExpression.matcher(fileContents); int lastIndex = 0; @@ -739,7 +764,7 @@ public static void deleteDirectory(Path dir) throws IOException { System.out.println("Cleaning " + dir); List pathsToDelete = Files.walk(dir) .sorted(Comparator.reverseOrder()) - .collect(Collectors.toList()); + .toList(); for (Path path : pathsToDelete) { Files.deleteIfExists(path); } From d8a48c8b1380615dbfbddb08939a54b3e6d1c7b2 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 22:52:56 -0700 Subject: [PATCH 256/709] Minor formatting --- org.lflang/src/org/lflang/generator/ts/TSGenerator.kt | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index db5eb267a2..6bd0813531 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -220,12 +220,7 @@ class TSGenerator( * as the source file, copy a default version from $LIB_PATH/. */ private fun copyConfigFiles() { - FileUtil.copyFromClassPath( - LIB_PATH, - fileConfig.srcGenPath, - true, - true - ) + FileUtil.copyFromClassPath(LIB_PATH, fileConfig.srcGenPath, true, true) for (configFile in CONFIG_FILES) { var override = FileUtil.findAndCopyFile(configFile, fileConfig.srcGenPath, fileConfig); if (override != null) { From a42e04153729e73b751da10da4121014945cea2c Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 23:03:02 -0700 Subject: [PATCH 257/709] Update CUtil.java --- org.lflang/src/org/lflang/generator/c/CUtil.java | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 5e06881316..412f21b234 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -595,15 +595,15 @@ public interface ReportCommandErrors { /** * Run the custom build command specified with the "build" parameter. * This command is executed in the same directory as the source file. - * + *

* The following environment variables will be available to the command: - * - * * LF_CURRENT_WORKING_DIRECTORY: The directory in which the command is invoked. - * * LF_SOURCE_DIRECTORY: The directory containing the .lf file being compiled. - * * LF_PACKAGE_DIRECTORY: The directory for the root of the project. - * * LF_SOURCE_GEN_DIRECTORY: The directory in which generated files are placed. - * * LF_BIN_DIRECTORY: The directory into which to put binaries. - * + *

    + *
  • {@code: LF_CURRENT_WORKING_DIRECTORY}: The directory in which the command is invoked. + *
  • {@code:LF_SOURCE_DIRECTORY}: The directory containing the .lf file being compiled. + *
  • {@code:LF_PACKAGE_DIRECTORY}: The directory for the root of the project. + *
  • {@code:LF_SOURCE_GEN_DIRECTORY}: The directory in which generated files are placed. + *
  • {@code:LF_BIN_DIRECTORY}: The directory into which to put binaries. + *
*/ public static void runBuildCommand( FileConfig fileConfig, From 75976779c402251376cd961fbb93f9096a6969e0 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 23:04:32 -0700 Subject: [PATCH 258/709] Update org.lflang/src/org/lflang/generator/c/CUtil.java --- org.lflang/src/org/lflang/generator/c/CUtil.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 412f21b234..b5949f660b 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -600,7 +600,7 @@ public interface ReportCommandErrors { *
    *
  • {@code: LF_CURRENT_WORKING_DIRECTORY}: The directory in which the command is invoked. *
  • {@code:LF_SOURCE_DIRECTORY}: The directory containing the .lf file being compiled. - *
  • {@code:LF_PACKAGE_DIRECTORY}: The directory for the root of the project. + *
  • {@code:LF_PACKAGE_DIRECTORY}: The directory that is the root of the package. *
  • {@code:LF_SOURCE_GEN_DIRECTORY}: The directory in which generated files are placed. *
  • {@code:LF_BIN_DIRECTORY}: The directory into which to put binaries. *
From ea017aaec1198ab96605dfb9e7af3ab8355960ae Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 4 May 2023 23:10:44 -0700 Subject: [PATCH 259/709] Apply suggestions from code review --- .../org/lflang/tests/compiler/LinguaFrancaValidationTest.java | 4 ++-- org.lflang/src/org/lflang/validation/LFValidator.java | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java index e3ca78aaf2..3ae350d5fb 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java @@ -821,7 +821,7 @@ public void testInheritanceSupport() throws Exception { reactor B extends A{} """.formatted(target)); - if(target.supportsInheritance()) { + if (target.supportsInheritance()) { validator.assertNoIssues(model); } else { validator.assertError(model, LfPackage.eINSTANCE.getReactor(), null, @@ -838,7 +838,7 @@ public void testFederationSupport() throws Exception { federated reactor {} """.formatted(target)); - if(target.supportsFederated()) { + if (target.supportsFederated()) { validator.assertNoIssues(model); } else { validator.assertError(model, LfPackage.eINSTANCE.getReactor(), null, diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 74a54f7435..06d0010a88 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -984,7 +984,7 @@ public void checkReactor(Reactor reactor) throws IOException { } if (reactor.isFederated()) { - if(!target.supportsFederated()) { + if (!target.supportsFederated()) { error("The " + target.getDisplayName() + " target does not support federated execution.", Literals.REACTOR__FEDERATED); } From 128be9da3531ceed78c5ad7056f8dfed626dcf06 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 5 May 2023 15:26:50 +0200 Subject: [PATCH 260/709] fix unit tests --- .../compiler/LinguaFrancaValidationTest.java | 4 +- .../org/lflang/validation/LFValidator.java | 71 ++++++++++--------- 2 files changed, 39 insertions(+), 36 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java index 3ae350d5fb..8c6fa81759 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java @@ -137,7 +137,7 @@ public void disallowReactorCalledPreamble() throws Exception { Model model_error_1 = parser.parse(""" target Cpp; - main reactor Preamble { + reactor Preamble { } """); @@ -145,7 +145,7 @@ public void disallowReactorCalledPreamble() throws Exception { target Cpp; reactor Preamble { } - main reactor Main { + main reactor { } """); diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 06d0010a88..5f9d4764ac 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -852,30 +852,52 @@ public void checkReaction(Reaction reaction) { // FIXME: improve error message. } - public void checkReactorName(Reactor reactor) throws IOException { - String name = FileUtil.nameWithoutExtension(reactor.eResource()); - + public void checkReactorName(String name) throws IOException { // Check for illegal names. - if(reactor.getName() != null) { - checkName(reactor.getName(), Literals.REACTOR_DECL__NAME); + checkName(name, Literals.REACTOR_DECL__NAME); + + // C++ reactors may not be called 'preamble' + if (this.target == Target.CPP && name.equalsIgnoreCase("preamble")) { + error( + "Reactor cannot be named '" + name + "'", + Literals.REACTOR_DECL__NAME + ); + } + } - // C++ reactors may not be called 'preamble' - if (this.target == Target.CPP && name.equalsIgnoreCase("preamble")) { + @Check(CheckType.FAST) + public void checkReactor(Reactor reactor) throws IOException { + String fileName = FileUtil.nameWithoutExtension(reactor.eResource()); + + if (reactor.isFederated() || reactor.isMain()) { + // Do not allow multiple main/federated reactors. + TreeIterator iter = reactor.eResource().getAllContents(); + int nMain = countMainOrFederated(iter); + if (nMain > 1) { + EAttribute attribute = Literals.REACTOR__MAIN; + if (reactor.isFederated()) { + attribute = Literals.REACTOR__FEDERATED; + } error( - "Reactor cannot be named '" + name + "'", - Literals.REACTOR_DECL__NAME + "Multiple definitions of main or federated reactor.", + attribute ); } - } - if (reactor.isFederated() || reactor.isMain()) { - if(reactor.getName() != null && !reactor.getName().equals(name)) { + if(reactor.getName() != null && !reactor.getName().equals(fileName)) { // Make sure that if the name is given, it matches the expected name. error( "Name of main reactor must match the file name (or be omitted).", Literals.REACTOR_DECL__NAME ); } + + // check the reactor name indicated by the file name + // Skip this check if the file is named __synthetic0. This Name is used during testing, + // and we would get an unexpected error due to the '__' prefix otherwise. + if (!fileName.equals("__synthetic0")) { + checkReactorName(fileName); + } } else { // Not federated or main. if (reactor.getName() == null) { @@ -884,9 +906,11 @@ public void checkReactorName(Reactor reactor) throws IOException { Literals.REACTOR_DECL__NAME ); } else { + checkReactorName(reactor.getName()); + TreeIterator iter = reactor.eResource().getAllContents(); int nMain = countMainOrFederated(iter); - if (nMain > 0 && reactor.getName().equals(name)) { + if (nMain > 0 && reactor.getName().equals(fileName)) { error( "Name conflict with main reactor.", Literals.REACTOR_DECL__NAME @@ -894,27 +918,6 @@ public void checkReactorName(Reactor reactor) throws IOException { } } } - } - - @Check(CheckType.FAST) - public void checkReactor(Reactor reactor) throws IOException { - checkReactorName(reactor); - - if (reactor.isFederated() || reactor.isMain()) { - // Do not allow multiple main/federated reactors. - TreeIterator iter = reactor.eResource().getAllContents(); - int nMain = countMainOrFederated(iter); - if (nMain > 1) { - EAttribute attribute = Literals.REACTOR__MAIN; - if (reactor.isFederated()) { - attribute = Literals.REACTOR__FEDERATED; - } - error( - "Multiple definitions of main or federated reactor.", - attribute - ); - } - } Set superClasses = ASTUtils.superClasses(reactor); From 37abf64eb807aa05226f64988b05ae4bc2bd8508 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 5 May 2023 15:40:30 +0200 Subject: [PATCH 261/709] fix unit tests --- .../org/lflang/tests/compiler/LinguaFrancaValidationTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java index 8c6fa81759..aa285a2e32 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java @@ -281,7 +281,7 @@ public void disallowUnderscoreStates() throws Exception { public void disallowUnderscoreReactorDef() throws Exception { String testCase = """ target TypeScript; - main reactor __Foo { + reactor __Foo { } """; validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, From 7547acf9da075a52eedf98dddab568161776db7b Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 5 May 2023 10:36:35 -0700 Subject: [PATCH 262/709] Move watchdog test into concurrent --- test/C/src/{ => concurrent}/Watchdog.lf | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/C/src/{ => concurrent}/Watchdog.lf (100%) diff --git a/test/C/src/Watchdog.lf b/test/C/src/concurrent/Watchdog.lf similarity index 100% rename from test/C/src/Watchdog.lf rename to test/C/src/concurrent/Watchdog.lf From c54def7e9e162f0f78df813dd806a6138b1b04e1 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 5 May 2023 12:21:48 -0700 Subject: [PATCH 263/709] More lenient test --- test/C/src/concurrent/Watchdog.lf | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/C/src/concurrent/Watchdog.lf b/test/C/src/concurrent/Watchdog.lf index 3ee48afe9c..18250f89dc 100644 --- a/test/C/src/concurrent/Watchdog.lf +++ b/test/C/src/concurrent/Watchdog.lf @@ -36,7 +36,8 @@ reactor Watcher(timeout: time = 150 ms) { reaction(shutdown) -> poodle {= lf_watchdog_stop(poodle); - if (self->count != 2) { + // Watchdog may expire in tests even without the sleep, but it should at least expire twice. + if (self->count < 2) { lf_print_error_and_exit("Watchdog expired %d times. Expected 2.", self->count); } =} From 54fa3d00383f9158e35fa58d3cdc443df16616e9 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 6 May 2023 06:10:44 -0700 Subject: [PATCH 264/709] Aligned reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index ffe9a6a2e2..618fa07480 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit ffe9a6a2e2bf79f45c1019d48f17b1b92eaf01a5 +Subproject commit 618fa07480964d82ebd88e28378bbfd335adb27c From 836bb3ee41e07762f4409a50bc296dd06037883c Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 6 May 2023 07:00:34 -0700 Subject: [PATCH 265/709] Made test timing lenient. --- test/C/src/concurrent/Watchdog.lf | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/C/src/concurrent/Watchdog.lf b/test/C/src/concurrent/Watchdog.lf index 18250f89dc..bc8ab1387b 100644 --- a/test/C/src/concurrent/Watchdog.lf +++ b/test/C/src/concurrent/Watchdog.lf @@ -38,7 +38,7 @@ reactor Watcher(timeout: time = 150 ms) { lf_watchdog_stop(poodle); // Watchdog may expire in tests even without the sleep, but it should at least expire twice. if (self->count < 2) { - lf_print_error_and_exit("Watchdog expired %d times. Expected 2.", self->count); + lf_print_error_and_exit("Watchdog expired %d times. Expected at least 2.", self->count); } =} } @@ -59,8 +59,8 @@ main reactor { =} reaction(shutdown) {= - if (self->count != 12) { - lf_print_error_and_exit("Watchdog produced output %d times. Expected 12.", self->count); + if (self->count < 12) { + lf_print_error_and_exit("Watchdog produced output %d times. Expected at least 12.", self->count); } =} } From eb4272086856a7f3054883e2b178991f2ffb7dd6 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 6 May 2023 14:16:09 -0700 Subject: [PATCH 266/709] Inherit preambles --- org.lflang/src/org/lflang/ASTUtils.java | 13 +++++++++++++ .../src/org/lflang/generator/c/CGenerator.java | 2 +- test/C/src/PreambleInherited.lf | 17 +++++++++++++++++ 3 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 test/C/src/PreambleInherited.lf diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index afda11bb46..0129dfc1b0 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -81,6 +81,7 @@ import org.lflang.lf.Parameter; import org.lflang.lf.ParameterReference; import org.lflang.lf.Port; +import org.lflang.lf.Preamble; import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; @@ -377,6 +378,18 @@ public static List allPorts(Reactor definition) { return Stream.concat(ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()).toList(); } + /** + * Given a reactor class, return a list of all its preambles, + * which includes preambles of base classes that it extends. + * If the base classes include a cycle, where X extends Y and Y extends X, + * then return only the input defined in the base class. + * The returned list may be empty. + * @param definition Reactor class definition. + */ + public static List allPreambles(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Preambles()); + } + /** * Given a reactor class, return a list of all its instantiations, * which includes instantiations of base classes that it extends. diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index c7e585e1ab..b6e51876b0 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1078,7 +1078,7 @@ protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { * @param reactor The given reactor */ protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { - for (Preamble p : convertToEmptyListIfNull(reactor.getPreambles())) { + for (Preamble p : ASTUtils.allPreambles(reactor)) { src.pr("// *********** From the preamble, verbatim:"); src.prSourceLineNumber(p.getCode()); src.pr(toText(p.getCode())); diff --git a/test/C/src/PreambleInherited.lf b/test/C/src/PreambleInherited.lf new file mode 100644 index 0000000000..1f2e9e1cb5 --- /dev/null +++ b/test/C/src/PreambleInherited.lf @@ -0,0 +1,17 @@ +/** + * Check that preamble is inherited. + * Success is just compiling and running. + */ +target C +reactor A { + preamble {= + #define FOO 2 + =} + reaction(startup) {= + printf("FOO: %d\n", FOO); + =} +} +reactor B extends A {} +main reactor { + b = new B() +} From 7651e8c03a595a504835cbcd980242de831381a7 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 6 May 2023 14:29:02 -0700 Subject: [PATCH 267/709] Formated test --- test/C/src/PreambleInherited.lf | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/test/C/src/PreambleInherited.lf b/test/C/src/PreambleInherited.lf index 1f2e9e1cb5..c7db161962 100644 --- a/test/C/src/PreambleInherited.lf +++ b/test/C/src/PreambleInherited.lf @@ -1,17 +1,17 @@ -/** - * Check that preamble is inherited. - * Success is just compiling and running. - */ +/** Check that preamble is inherited. Success is just compiling and running. */ target C + reactor A { preamble {= #define FOO 2 =} - reaction(startup) {= - printf("FOO: %d\n", FOO); - =} + + reaction(startup) {= printf("FOO: %d\n", FOO); =} +} + +reactor B extends A { } -reactor B extends A {} + main reactor { b = new B() } From 5ef1eda9a12e7faec1fb9422782f744820e361ad Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 6 May 2023 16:03:09 -0700 Subject: [PATCH 268/709] Include file-level preambles for base classes --- org.lflang/src/org/lflang/ASTUtils.java | 46 +++++++++++++++++++ .../org/lflang/generator/c/CGenerator.java | 5 +- test/C/src/PreambleFileLevel.lf | 14 ++++++ test/C/src/lib/FileLevelPreamble.lf | 13 ++++++ 4 files changed, 77 insertions(+), 1 deletion(-) create mode 100644 test/C/src/PreambleFileLevel.lf create mode 100644 test/C/src/lib/FileLevelPreamble.lf diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 0129dfc1b0..2cb9dad397 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -401,6 +401,11 @@ public static List allInstantiations(Reactor definition) { return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); } + /** + * Given a reactor class, return a stream of reactor classes that it instantiates. + * @param definition Reactor class definition. + * @return A stream of reactor classes. + */ public static Stream allNestedClasses(Reactor definition) { return new HashSet<>(ASTUtils.allInstantiations(definition)).stream() .map(Instantiation::getReactorClass) @@ -500,6 +505,19 @@ public static LinkedHashSet superClasses(Reactor reactor) { return superClasses(reactor, new LinkedHashSet<>()); } + /** + * Return all the file-level preambles in the files that define the + * specified class and its superclasses in deepest-first order. + * Duplicates are removed. If there are no file-level preambles, + * then return an empty list. + * If a cycle is found, where X extends Y and Y extends X, or if + * a superclass is declared that is not found, then return null. + * @param reactor The specified reactor. + */ + public static LinkedHashSet allFileLevelPreambles(Reactor reactor) { + return allFileLevelPreambles(reactor, new LinkedHashSet<>()); + } + /** * Collect elements of type T from the class hierarchy and modes * defined by a given reactor definition. @@ -1781,6 +1799,34 @@ private static LinkedHashSet superClasses(Reactor reactor, Set return result; } + /** + * Return all the file-level preambles in the files that define the + * specified class and its superclasses in deepest-first order. + * Duplicates are removed. If there are no file-level preambles, + * then return an empty list. + * If a cycle is found, where X extends Y and Y extends X, or if + * a superclass is declared that is not found, then return null. + * @param reactor The specified reactor. + * @param extensions A set of reactors extending the specified reactor + * (used to detect circular extensions). + */ + private static LinkedHashSet allFileLevelPreambles(Reactor reactor, Set extensions) { + LinkedHashSet result = new LinkedHashSet<>(); + for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { + Reactor r = toDefinition(superDecl); + if (r == reactor || r == null) return null; + // If r is in the extensions, then we have a circular inheritance structure. + if (extensions.contains(r)) return null; + extensions.add(r); + LinkedHashSet basePreambles = allFileLevelPreambles(r, extensions); + extensions.remove(r); + if (basePreambles == null) return null; + result.addAll(basePreambles); + } + result.addAll(((Model) reactor.eContainer()).getPreambles()); + return result; + } + /** * We may be able to infer the width by examining the connections of * the enclosing reactor definition. This works, for example, with diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b6e51876b0..be931153f8 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1983,8 +1983,11 @@ protected String generateTopLevelPreambles(Reactor reactor) { var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; builder.pr("#ifndef " + guard); builder.pr("#define " + guard); + // Reactors that are instantiated by the specified reactor need to have + // their file-level preambles included. This needs to also include file-level + // preambles of base classes of those reactors. Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) - .flatMap(it -> ((Model) it.eContainer()).getPreambles().stream()) + .flatMap(it -> ASTUtils.allFileLevelPreambles(it).stream()) .collect(Collectors.toSet()) .forEach(it -> builder.pr(toText(it.getCode()))); for (String file : targetConfig.protoFiles) { diff --git a/test/C/src/PreambleFileLevel.lf b/test/C/src/PreambleFileLevel.lf new file mode 100644 index 0000000000..ed2def967a --- /dev/null +++ b/test/C/src/PreambleFileLevel.lf @@ -0,0 +1,14 @@ +/** + * Test for ensuring that file-level preambles are inherited when a file is + * imported. + */ +target C + +import FileLevelPreamble from "lib/FileLevelPreamble.lf" + +reactor B extends FileLevelPreamble { +} + +main reactor { + b = new B() +} diff --git a/test/C/src/lib/FileLevelPreamble.lf b/test/C/src/lib/FileLevelPreamble.lf new file mode 100644 index 0000000000..846ed66163 --- /dev/null +++ b/test/C/src/lib/FileLevelPreamble.lf @@ -0,0 +1,13 @@ +/** + * Test for ensuring that file-level preambles are inherited when a file is + * imported. + */ +target C + +preamble {= + #define FOO 2 +=} + +reactor FileLevelPreamble { + reaction(startup) {= printf("FOO: %d\n", FOO); =} +} From a36d8a3e872d95b80dadecb0113d9c8575029cfc Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 8 May 2023 14:08:27 +0200 Subject: [PATCH 269/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 6bdf8c9f05..4e75aec034 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 6bdf8c9f054e463359f46170eb073928aea33ff9 +Subproject commit 4e75aec034f709de1236381ac9dcd7dbd3c8affe From de0af0c4314bec1c06f6cef9aaa6235831fbde1b Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 8 May 2023 16:29:48 +0200 Subject: [PATCH 270/709] unify connection generation using a lambda function this simplifies the connection procedure. Instead of generating different code for normal, enclaved, or just delayed connections, we use the same code for all and insert a lambda that is called to instantiate the concrete connection. --- org.lflang/src/lib/cpp/lfutil.hh | 53 +++----------- .../cpp/CppAssembleMethodGenerator.kt | 73 ++++++++----------- .../generator/cpp/CppConnectionGenerator.kt | 30 ++++---- test/Cpp/src/enclave/EnclaveBroadcast.lf | 37 ++++++++++ .../Cpp/src/enclave/EnclaveMultiportToPort.lf | 49 +++++++++++++ test/Cpp/src/multiport/Broadcast.lf | 9 +++ 6 files changed, 151 insertions(+), 100 deletions(-) create mode 100644 test/Cpp/src/enclave/EnclaveBroadcast.lf create mode 100644 test/Cpp/src/enclave/EnclaveMultiportToPort.lf diff --git a/org.lflang/src/lib/cpp/lfutil.hh b/org.lflang/src/lib/cpp/lfutil.hh index 4ed850e571..292bd1db5e 100644 --- a/org.lflang/src/lib/cpp/lfutil.hh +++ b/org.lflang/src/lib/cpp/lfutil.hh @@ -65,12 +65,13 @@ class LFScope { void request_stop() const { return environment()->sync_shutdown(); } }; -template +template void bind_multiple_ports( - std::vector*>& left_ports, - std::vector*>& right_ports, - bool repeat_left) { - + std::vector& left_ports, + std::vector& right_ports, + bool repeat_left, + std::function connect) +{ if (repeat_left) { auto l_size = left_ports.size(); auto r_size = right_ports.size(); @@ -94,50 +95,14 @@ void bind_multiple_ports( << "Not all ports will be connected!"; } + std::size_t idx{0}; while (left_it != left_ports.end() && right_it != right_ports.end()) { auto left = *left_it; auto right = *right_it; - left->bind_to(right); - left_it++; - right_it++; - } -} - -template -void bind_multiple_connections_with_ports( - std::vector*>& connections, - std::vector*>& ports, - bool repeat_left) { - - if (repeat_left) { - auto l_size = connections.size(); - auto r_size = ports.size(); - // divide and round up - auto repetitions = r_size / l_size + (r_size % l_size != 0); - // repeat repetitions-1 times - connections.reserve(repetitions * l_size); - for (std::size_t i{1}; i < repetitions; i++) { - std::copy_n(connections.begin(), l_size, std::back_inserter(connections)); - } - } - - auto left_it = connections.begin(); - auto right_it = ports.begin(); - - if (connections.size() < ports.size()) { - reactor::log::Warn() << "There are more right ports than left ports. " - << "Not all ports will be connected!"; - } else if (connections.size() > ports.size()) { - reactor::log::Warn() << "There are more left ports than right ports. " - << "Not all ports will be connected!"; - } - - while (left_it != connections.end() && right_it != ports.end()) { - auto left = *left_it; - auto right = *right_it; - left->bind_downstream_port(right); + connect(left, right, idx); left_it++; right_it++; + idx++; } } diff --git a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt index 45112487bd..60f2ff62a7 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt @@ -186,47 +186,38 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { // within a bank, then we normally iterate over all banks in an outer loop and over all ports in an inner loop. However, // if the connection is an interleaved connection, than we change the order on the right side and iterate over ports before banks. return with(PrependOperator) { - if (!c.requiresConnectionClass) { - """ - |// connection $idx - |std::vector<$portType> __lf_left_ports_$idx; - ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }} - |std::vector<$portType> __lf_right_ports_$idx; - ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} - |lfutil::bind_multiple_ports(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated}); - """.trimMargin() - } else if (!c.isEnclaveConnection) { - """ - |// connection $idx - |std::vector<$portType> __lf_left_ports_$idx; - ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }} - |${c.name}.reserve(__lf_left_ports_$idx.size()); - |for(size_t __lf_idx{0}; __lf_idx < __lf_left_ports_$idx.size(); __lf_idx++) { - | ${c.name}.emplace_back("${c.name}" + std::to_string(__lf_idx), this, ${c.delay.toCppTime()}); - | ${c.name}.back().bind_upstream_port(__lf_left_ports_$idx[__lf_idx]); - |} - |std::vector*> __lf_connection_pointers_$idx; - |for (auto& connection : ${c.name}) { - | __lf_connection_pointers_$idx.push_back(&connection); - |} - |std::vector<$portType> __lf_right_ports_$idx; - ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} - |lfutil::bind_multiple_connections_with_ports(__lf_connection_pointers_$idx, __lf_right_ports_$idx, ${c.isIterated}); - """.trimMargin() - } else { - """ - |// connection $idx - |std::vector<$portType> __lf_left_ports_$idx; - ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }} - |std::vector<$portType> __lf_right_ports_$idx; - ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} - |for(size_t __lf_idx{0}; __lf_idx < std::min(__lf_right_ports_$idx.size(), __lf_left_ports_$idx.size()); __lf_idx++) { - | ${c.name}.emplace_back("${c.name}" + std::to_string(__lf_idx), __lf_right_ports_$idx[__lf_idx]->environment()${if(c.delay != null) ", ${c.delay.toCppTime()}" else ""}); - | ${c.name}.back().bind_upstream_port(__lf_left_ports_$idx[__lf_idx]); - | ${c.name}.back().bind_downstream_port(__lf_right_ports_$idx[__lf_idx]); - |} - """.trimMargin() - } + """ + |// connection $idx + |std::vector<$portType> __lf_left_ports_$idx; + ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }} + |std::vector<$portType> __lf_right_ports_$idx; + ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} + |lfutil::bind_multiple_ports<$portType>(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated}, + ${" |"..c.getConnectionLambda(portType)} + |); + """.trimMargin() + } + } + + private fun Connection.getConnectionLambda(portType: String): String { + return when { + isEnclaveConnection -> """ + [this]($portType left, $portType right, std::size_t idx) { + $name.emplace_back("$name" + std::to_string(idx), right->environment()${if (delay != null) ", ${delay.toCppTime()}" else ""}); + $name.back().bind_upstream_port(left); + $name.back().bind_downstream_port(right); + } + """.trimIndent() + + requiresConnectionClass -> """ + [this]($portType left, $portType right, std::size_t idx) { + $name.emplace_back("$name" + std::to_string(idx), this, ${delay.toCppTime()}); + $name.back().bind_upstream_port(left); + $name.back().bind_downstream_port(right); + } + """.trimIndent() + + else -> "[]($portType left, $portType right, [[maybe_unused]]std::size_t idx) { left->bind_to(right); }" } } diff --git a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt index 897fe01202..4be190314d 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt @@ -41,21 +41,19 @@ class CppConnectionGenerator(private val reactor: Reactor) { val Connection.isEnclaveConnection: Boolean get() { - if (leftPorts.size == 1 && rightPorts.size == 1) { - val leftIsEnclave = leftPorts[0].container?.isEnclave == true - val rightIsEnclave = rightPorts[0].container?.isEnclave == true - return when { - leftIsEnclave && rightIsEnclave -> true - !leftIsEnclave && !rightIsEnclave -> false - else -> TODO("Connections between enclaves and normal reactors are not supported") - } - } + var foundEnclave = false + var allEnclave = true for (port in leftPorts + rightPorts) { if (port.container?.isEnclave == true) { - TODO("Enclaves can only be used in simple connections") + foundEnclave = true + } else { + allEnclave = false } } - return false + if (foundEnclave && !allEnclave) { + TODO("Connections between enclaves and normal reactors are not supported") + } + return foundEnclave } val Connection.requiresConnectionClass: Boolean get() = isPhysical || delay != null || isEnclaveConnection; @@ -71,10 +69,12 @@ class CppConnectionGenerator(private val reactor: Reactor) { private fun generateDecleration(connection: Connection): String? = with(connection) { if (requiresConnectionClass) { - when { - hasMultipleConnections && isEnclaveConnection -> "std::list<${connection.cppType}> ${connection.name};" - hasMultipleConnections && !isEnclaveConnection -> "std::vector<${connection.cppType}> ${connection.name};" - else -> "${connection.cppType} ${connection.name};" + if (hasMultipleConnections) { + // We use an std::list here as connections currently cannot be safely moved and std::vector requires + // objects to be movable. + "std::list<${connection.cppType}> ${connection.name};" + } else { + "${connection.cppType} ${connection.name};" } } else null } diff --git a/test/Cpp/src/enclave/EnclaveBroadcast.lf b/test/Cpp/src/enclave/EnclaveBroadcast.lf new file mode 100644 index 0000000000..d00fbbf059 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveBroadcast.lf @@ -0,0 +1,37 @@ +target Cpp{timeout: 1 sec} + +reactor Source { + output out: unsigned + + reaction(startup) -> out {= out.set(42); =} +} + +reactor Sink(bank_index: size_t = 0) { + input in: unsigned + + state received: bool = false + + reaction(in) {= + received = true; + std::cout << "Received " << *in.get() << '\n'; + if (*in.get() != 42) { + std::cerr << "Error: expected " << 42 << "!\n"; + exit(1); + } + =} + + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: Sink " << bank_index << " didn't receive anything.\n"; + exit(2); + } + =} +} + +main reactor { + @enclave + source = new Source() + @enclave(each=true) + sink = new[4] Sink() + (source.out)+ -> sink.in +} diff --git a/test/Cpp/src/enclave/EnclaveMultiportToPort.lf b/test/Cpp/src/enclave/EnclaveMultiportToPort.lf new file mode 100644 index 0000000000..027de94bfb --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveMultiportToPort.lf @@ -0,0 +1,49 @@ +// Check multiport output to multiport input. Destination port is wider than +// sending port. +target Cpp { + timeout: 2 sec, + fast: true +} + +reactor Source { + output[2] out: int + + reaction(startup) -> out {= + for(int i = 0; i < out.size(); i++) { + std::cout << "Source sending " << i << ".\n"; + out[i].set(i); + } + =} +} + +reactor Destination(expected: int = 0) { + input in: int + state received: bool = false + + reaction(in) {= + std::cout << "Received: " << *in.get() << ".\n"; + received = true; + if (*in.get() != expected) { + std::cerr << "ERROR: Expected " << expected << ".\n"; + exit(1); + } + =} + + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} +} + +main reactor { + @enclave + a = new Source() + @enclave + b1 = new Destination() + @enclave + b2 = new Destination(expected = 1) + a.out -> b1.in, b2.in +} diff --git a/test/Cpp/src/multiport/Broadcast.lf b/test/Cpp/src/multiport/Broadcast.lf index 077ca75247..202a30c5f7 100644 --- a/test/Cpp/src/multiport/Broadcast.lf +++ b/test/Cpp/src/multiport/Broadcast.lf @@ -8,14 +8,23 @@ reactor Source { reactor Sink(bank_index: size_t = 0) { input in: unsigned + state received: bool = false reaction(in) {= + received = true; std::cout << "Received " << *in.get() << '\n'; if (*in.get() != 42) { std::cerr << "Error: expected " << 42 << "!\n"; exit(1); } =} + + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: Sink " << bank_index << " didn't receive anything.\n"; + exit(2); + } + =} } main reactor { From d6c4e5afa06ec8e143eec5d1e8452d3fee8ed132 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 8 May 2023 16:54:04 +0200 Subject: [PATCH 271/709] allow connections where not all ports belong to enclaves --- .../generator/cpp/CppConnectionGenerator.kt | 11 +--- test/Cpp/src/enclave/EnclaveCommunication2.lf | 43 ++++++++++++ .../enclave/EnclaveCommunicationDelayed2.lf | 43 ++++++++++++ test/Cpp/src/enclave/EnclaveCycle2lf | 66 +++++++++++++++++++ .../src/enclave/EnclaveMultiportToPort2.lf | 48 ++++++++++++++ 5 files changed, 202 insertions(+), 9 deletions(-) create mode 100644 test/Cpp/src/enclave/EnclaveCommunication2.lf create mode 100644 test/Cpp/src/enclave/EnclaveCommunicationDelayed2.lf create mode 100644 test/Cpp/src/enclave/EnclaveCycle2lf create mode 100644 test/Cpp/src/enclave/EnclaveMultiportToPort2.lf diff --git a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt index 4be190314d..83c3f5554a 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt @@ -41,19 +41,12 @@ class CppConnectionGenerator(private val reactor: Reactor) { val Connection.isEnclaveConnection: Boolean get() { - var foundEnclave = false - var allEnclave = true for (port in leftPorts + rightPorts) { if (port.container?.isEnclave == true) { - foundEnclave = true - } else { - allEnclave = false + return true } } - if (foundEnclave && !allEnclave) { - TODO("Connections between enclaves and normal reactors are not supported") - } - return foundEnclave + return false } val Connection.requiresConnectionClass: Boolean get() = isPhysical || delay != null || isEnclaveConnection; diff --git a/test/Cpp/src/enclave/EnclaveCommunication2.lf b/test/Cpp/src/enclave/EnclaveCommunication2.lf new file mode 100644 index 0000000000..648223fb0b --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunication2.lf @@ -0,0 +1,43 @@ +target Cpp { + timeout: 1 s, + workers: 1 +} + +reactor Src { + timer t(0, 100 ms) + output out: int + state counter: int = 0 + + reaction(t) -> out {= out.set(counter++); =} +} + +reactor Sink { + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +main reactor { + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in +} diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayed2.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayed2.lf new file mode 100644 index 0000000000..9cfa3f0a11 --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayed2.lf @@ -0,0 +1,43 @@ +target Cpp { + timeout: 1 s, + workers: 1 +} + +reactor Src { + timer t(0, 100 ms) + output out: int + state counter: int = 0 + + reaction(t) -> out {= out.set(counter++); =} +} + +reactor Sink { + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value + 50ms; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +main reactor { + src = new Src() + @enclave + sink = new Sink() + + src.out -> sink.in after 50 ms +} diff --git a/test/Cpp/src/enclave/EnclaveCycle2lf b/test/Cpp/src/enclave/EnclaveCycle2lf new file mode 100644 index 0000000000..34e0b2bdfa --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveCycle2lf @@ -0,0 +1,66 @@ +target Cpp { + timeout: 1 s, + workers: 1 +} + +reactor Ping { + timer t(0, 100 ms) + input in: int + output out: int + state counter: int = 0 + state received: bool = false + + reaction(t) -> out {= out.set(counter++); =} + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Ping Received " << value; + auto expected = 50ms + 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +reactor Pong { + input in: int + output out: int + state received: bool = false + + reaction(in) -> out {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Pong Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + out.set(value); + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} +} + +main reactor { + ping = new Ping() + @enclave + pong = new Pong() + + ping.out -> pong.in + pong.out -> ping.in after 50 ms +} diff --git a/test/Cpp/src/enclave/EnclaveMultiportToPort2.lf b/test/Cpp/src/enclave/EnclaveMultiportToPort2.lf new file mode 100644 index 0000000000..5d8d72494d --- /dev/null +++ b/test/Cpp/src/enclave/EnclaveMultiportToPort2.lf @@ -0,0 +1,48 @@ +// Check multiport output to multiport input. Destination port is wider than +// sending port. +target Cpp { + timeout: 2 sec, + fast: true +} + +reactor Source { + output[2] out: int + + reaction(startup) -> out {= + for(int i = 0; i < out.size(); i++) { + std::cout << "Source sending " << i << ".\n"; + out[i].set(i); + } + =} +} + +reactor Destination(expected: int = 0) { + input in: int + state received: bool = false + + reaction(in) {= + std::cout << "Received: " << *in.get() << ".\n"; + received = true; + if (*in.get() != expected) { + std::cerr << "ERROR: Expected " << expected << ".\n"; + exit(1); + } + =} + + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} +} + +main reactor { + @enclave + a = new Source() + @enclave + b1 = new Destination() + b2 = new Destination(expected = 1) + a.out -> b1.in, b2.in +} From 814e0bfec29c4d958f9a92b83fa0550709fd5fb6 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 8 May 2023 17:17:57 +0200 Subject: [PATCH 272/709] use vector of unique pointers to store connections --- org.lflang/src/lib/cpp/lfutil.hh | 2 -- .../generator/cpp/CppAssembleMethodGenerator.kt | 17 ++++++++++------- .../generator/cpp/CppConnectionGenerator.kt | 4 +--- 3 files changed, 11 insertions(+), 12 deletions(-) diff --git a/org.lflang/src/lib/cpp/lfutil.hh b/org.lflang/src/lib/cpp/lfutil.hh index 292bd1db5e..77116dcbe1 100644 --- a/org.lflang/src/lib/cpp/lfutil.hh +++ b/org.lflang/src/lib/cpp/lfutil.hh @@ -27,8 +27,6 @@ #include #include -#include - namespace lfutil { template diff --git a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt index 60f2ff62a7..0aef4a9b65 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt @@ -26,6 +26,7 @@ package org.lflang.generator.cpp import org.lflang.* import org.lflang.generator.PrependOperator +import org.lflang.generator.cpp.CppConnectionGenerator.Companion.cppType import org.lflang.generator.cpp.CppConnectionGenerator.Companion.isEnclaveConnection import org.lflang.generator.cpp.CppConnectionGenerator.Companion.name import org.lflang.generator.cpp.CppConnectionGenerator.Companion.requiresConnectionClass @@ -172,7 +173,7 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { * complex logic for finding the actual type, we return a decltype statement and let the C++ compiler do the job. */ private val VarRef.portType: String - get() = "reactor::Port<${dataType}>*" + get() = "reactor::Port*" private fun declareMultiportConnection(c: Connection, idx: Int): String { // It should be safe to assume that all ports have the same type. Thus we just pick the @@ -192,6 +193,7 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }} |std::vector<$portType> __lf_right_ports_$idx; ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} + |${c.name}.reserve(std::max(__lf_left_ports_$idx.size(), __lf_right_ports_$idx.size())); |lfutil::bind_multiple_ports<$portType>(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated}, ${" |"..c.getConnectionLambda(portType)} |); @@ -203,17 +205,18 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { return when { isEnclaveConnection -> """ [this]($portType left, $portType right, std::size_t idx) { - $name.emplace_back("$name" + std::to_string(idx), right->environment()${if (delay != null) ", ${delay.toCppTime()}" else ""}); - $name.back().bind_upstream_port(left); - $name.back().bind_downstream_port(right); + $name.push_back(std::make_unique<$cppType>( + "$name" + std::to_string(idx), right->environment()${if (delay != null) ", ${delay.toCppTime()}" else ""})); + $name.back()->bind_upstream_port(left); + $name.back()->bind_downstream_port(right); } """.trimIndent() requiresConnectionClass -> """ [this]($portType left, $portType right, std::size_t idx) { - $name.emplace_back("$name" + std::to_string(idx), this, ${delay.toCppTime()}); - $name.back().bind_upstream_port(left); - $name.back().bind_downstream_port(right); + $name.push_back(std::make_unique<$cppType>("$name" + std::to_string(idx), this, ${delay.toCppTime()})}); + $name.back()->bind_upstream_port(left); + $name.back()->bind_downstream_port(right); } """.trimIndent() diff --git a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt index 83c3f5554a..c9af656291 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt @@ -63,9 +63,7 @@ class CppConnectionGenerator(private val reactor: Reactor) { with(connection) { if (requiresConnectionClass) { if (hasMultipleConnections) { - // We use an std::list here as connections currently cannot be safely moved and std::vector requires - // objects to be movable. - "std::list<${connection.cppType}> ${connection.name};" + "std::vector> ${connection.name};" } else { "${connection.cppType} ${connection.name};" } From 3d84b6c9fd4ea781d9e5085ce7c453c79f84f0f7 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 8 May 2023 17:27:17 +0200 Subject: [PATCH 273/709] format test --- test/Cpp/src/enclave/EnclaveBroadcast.lf | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/test/Cpp/src/enclave/EnclaveBroadcast.lf b/test/Cpp/src/enclave/EnclaveBroadcast.lf index d00fbbf059..04a2a77941 100644 --- a/test/Cpp/src/enclave/EnclaveBroadcast.lf +++ b/test/Cpp/src/enclave/EnclaveBroadcast.lf @@ -1,4 +1,6 @@ -target Cpp{timeout: 1 sec} +target Cpp { + timeout: 1 sec +} reactor Source { output out: unsigned @@ -31,7 +33,7 @@ reactor Sink(bank_index: size_t = 0) { main reactor { @enclave source = new Source() - @enclave(each=true) + @enclave(each = true) sink = new[4] Sink() (source.out)+ -> sink.in } From c0b51270dbe41cfa468b951f69ae909c2d2e2562 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 10 May 2023 12:42:52 +0200 Subject: [PATCH 274/709] only reserve if we have a dedicated connection vector --- .../org/lflang/generator/cpp/CppAssembleMethodGenerator.kt | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt index 0aef4a9b65..f944af8d90 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt @@ -180,9 +180,6 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { // first left port to determine the type of the entire connection val portType = c.leftPorts[0].portType - val leftPort = c.leftPorts[0].variable as Port - val dataType = leftPort.inferredType.cppType - // Generate code which adds all left hand ports and all right hand ports to a vector each. If we are handling multiports // within a bank, then we normally iterate over all banks in an outer loop and over all ports in an inner loop. However, // if the connection is an interleaved connection, than we change the order on the right side and iterate over ports before banks. @@ -193,7 +190,7 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }} |std::vector<$portType> __lf_right_ports_$idx; ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} - |${c.name}.reserve(std::max(__lf_left_ports_$idx.size(), __lf_right_ports_$idx.size())); + ${" |"..if (c.requiresConnectionClass) "{c.name}.reserve(std::max(__lf_left_ports_$idx.size(), __lf_right_ports_$idx.size()))" else ""} |lfutil::bind_multiple_ports<$portType>(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated}, ${" |"..c.getConnectionLambda(portType)} |); From 3b49f12e5bd26419411de0d6e299e47e44c15300 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 10 May 2023 13:20:57 +0200 Subject: [PATCH 275/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 4e75aec034..b4c6963ea6 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 4e75aec034f709de1236381ac9dcd7dbd3c8affe +Subproject commit b4c6963ea6a5d951a5cf71b947f550117bd9f688 From fa0e05806e429cc1d8a0250b2d9a37c775a93376 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 10 May 2023 13:22:08 +0200 Subject: [PATCH 276/709] bugfix --- .../src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt index f944af8d90..503f5c950c 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt @@ -190,7 +190,7 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }} |std::vector<$portType> __lf_right_ports_$idx; ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }} - ${" |"..if (c.requiresConnectionClass) "{c.name}.reserve(std::max(__lf_left_ports_$idx.size(), __lf_right_ports_$idx.size()))" else ""} + ${" |"..if (c.requiresConnectionClass) "${c.name}.reserve(std::max(__lf_left_ports_$idx.size(), __lf_right_ports_$idx.size()));" else ""} |lfutil::bind_multiple_ports<$portType>(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated}, ${" |"..c.getConnectionLambda(portType)} |); From f7261ea522426b4f0136ad895ef0523ea1e57042 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 10 May 2023 14:08:44 +0200 Subject: [PATCH 277/709] another C++ syntax fix --- .../src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt index 503f5c950c..0bb63e24c3 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt @@ -211,7 +211,7 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) { requiresConnectionClass -> """ [this]($portType left, $portType right, std::size_t idx) { - $name.push_back(std::make_unique<$cppType>("$name" + std::to_string(idx), this, ${delay.toCppTime()})}); + $name.push_back(std::make_unique<$cppType>("$name" + std::to_string(idx), this, ${delay.toCppTime()})); $name.back()->bind_upstream_port(left); $name.back()->bind_downstream_port(right); } From aae5cae30fbf753ef74d76eb0825d4bb9d497d04 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 10 May 2023 15:04:11 +0200 Subject: [PATCH 278/709] relax deadline --- test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf index 3bade0f63e..58bd641387 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf @@ -1,12 +1,12 @@ // The purpose of this test is to check that the downstream enclave can // progress, even if there are only sparse upstream events. target Cpp { - timeout: 6 s, + timeout: 12 s, workers: 1 } -reactor Src { - timer t(0, 2 s) +reactor Src {s + timer t(0, 4 s) output out: int state counter: int = 0 @@ -36,7 +36,7 @@ reactor Sink { } =} - reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(1 s) {= + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= reactor::log::Error() << "Deadline violated."; exit(2); =} From aa409f84f8a59d2124790dc2d71932dee93d0486 Mon Sep 17 00:00:00 2001 From: mkhubaibumer Date: Thu, 11 May 2023 19:27:40 +0500 Subject: [PATCH 279/709] Update Reactor-C --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 1d762fd8b3..f1d41011e4 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 1d762fd8b367c84cb92e6314591b3bcd650bae8b +Subproject commit f1d41011e454a026741beb68bd9a3ec80101c8ee From 0554c99f93cf5176a4322844cf593e9a1164ff49 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 12 May 2023 09:55:48 +0200 Subject: [PATCH 280/709] fix test file --- test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf index 58bd641387..73a90dbd21 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf @@ -5,7 +5,7 @@ target Cpp { workers: 1 } -reactor Src {s +reactor Src { timer t(0, 4 s) output out: int state counter: int = 0 From a3055968837d34d8f8600adefdd0b65588bf5615 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 12 May 2023 10:37:30 +0200 Subject: [PATCH 281/709] relax more deadlines and update timings --- test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf | 2 +- .../Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf | 8 ++++---- .../src/enclave/EnclaveSparseUpstreamEventsPhysical.lf | 8 ++++---- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf index 73a90dbd21..431c2cd60a 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf @@ -22,7 +22,7 @@ reactor Sink { received = true; auto value = *in.get(); reactor::log::Info() << "Received " << value; - auto expected = 2s * value; + auto expected = 4s * value; if (get_elapsed_logical_time() != expected) { reactor::log::Error() << "Expected value at " << expected << " but received it at " << get_elapsed_logical_time(); exit(1); diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf index e299f921ad..691e80f4bf 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf @@ -1,12 +1,12 @@ // The purpose of this test is to check that the downstream enclave respects the // after delay when aquiring tags from its upstream. target Cpp { - timeout: 6 s, + timeout: 12 s, workers: 1 } reactor Src { - timer t(0, 2 s) + timer t(0, 4 s) output out: int state counter: int = 0 @@ -22,7 +22,7 @@ reactor Sink { received = true; auto value = *in.get(); reactor::log::Info() << "Received " << value; - auto expected = 2s + 2s * value; + auto expected = 2s + 4s * value; if (get_elapsed_logical_time() != expected) { reactor::log::Error() << "Expected value at " << expected << " but received it at " << get_elapsed_logical_time(); exit(1); @@ -36,7 +36,7 @@ reactor Sink { } =} - reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(1 s) {= + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= reactor::log::Error() << "Deadline violated."; exit(2); =} diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf index 6e1e579bd0..10b5a8c4af 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf @@ -1,12 +1,12 @@ // The purpose of this test is to check that the downstream enclave advances // time independenty of the upstraem if the connection is physical. target Cpp { - timeout: 6 s, + timeout: 12 s, workers: 1 } reactor Src { - timer t(0, 2 s) + timer t(0, 4 s) output out: int state counter: int = 0 @@ -22,7 +22,7 @@ reactor Sink { received = true; auto value = *in.get(); reactor::log::Info() << "Received " << value; - auto expected = 2s * value; + auto expected = 4s * value; if (get_elapsed_logical_time() < expected) { reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); exit(1); @@ -36,7 +36,7 @@ reactor Sink { } =} - reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(1 s) {= + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= reactor::log::Error() << "Deadline violated."; exit(2); =} From d311497fb1444041ee263d82daa47a76945f2855 Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Fri, 12 May 2023 22:04:02 +0200 Subject: [PATCH 282/709] Fix enum name after naming convention --- org.lflang/src/org/lflang/TargetProperty.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index d8058009bb..6dcb81ebe1 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -432,7 +432,7 @@ public enum TargetProperty { case PORT: pair.setValue(ASTUtils.toElement(config.platformOptions.port)); break; - case USERTHREADS: + case USER_THREADS: pair.setValue(ASTUtils.toElement(config.platformOptions.userThreads)); break; } @@ -475,7 +475,7 @@ public enum TargetProperty { case PORT: config.platformOptions.port = ASTUtils.elementToSingleString(entry.getValue()); break; - case USERTHREADS: + case USER_THREADS: config.platformOptions.userThreads = ASTUtils.toInteger(entry.getValue()); break; default: @@ -1666,7 +1666,7 @@ public enum PlatformOption implements DictionaryElement { BOARD("board", PrimitiveType.STRING), FLASH("flash", PrimitiveType.BOOLEAN), PORT("port", PrimitiveType.STRING), - USERTHREADS("user_threads", PrimitiveType.NON_NEGATIVE_INTEGER); + USER_THREADS("user-threads", PrimitiveType.NON_NEGATIVE_INTEGER); public final PrimitiveType type; From 62c39cd609accef0b1629623ef8731455a3d1385 Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Fri, 12 May 2023 22:04:36 +0200 Subject: [PATCH 283/709] Use enum for setting compile definition --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 2bec8857bf..d53b39a6fa 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -58,6 +58,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.TargetConfig; import org.lflang.TargetProperty; import org.lflang.TargetProperty.Platform; +import org.lflang.TargetProperty.PlatformOption; import org.lflang.federated.extensions.CExtensionUtils; @@ -1965,11 +1966,15 @@ protected void setUpGeneralParameters() { if (targetConfig.platformOptions.platform == Platform.ZEPHYR && targetConfig.platformOptions.userThreads >= 0) { targetConfig.compileDefinitions.put( - "USER_THREADS", + PlatformOption.USER_THREADS.name(), String.valueOf(targetConfig.platformOptions.userThreads) ); } + if (targetConfig.platformOptions.platform != Platform.ZEPHYR && targetConfig.platformOptions.userThreads >= 0) { + System.out.println("Specifying user threads is only for the Zephyr platform. This option will be ignored."); + } + if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake pickScheduler(); // FIXME: this and pickScheduler should be combined. From 166227a453dfb763b24a2cf7403b93525e192fd9 Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Fri, 12 May 2023 22:05:01 +0200 Subject: [PATCH 284/709] Add user thread test for Zephyr --- test/C/src/zephyr/UserThreads.lf | 36 ++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 test/C/src/zephyr/UserThreads.lf diff --git a/test/C/src/zephyr/UserThreads.lf b/test/C/src/zephyr/UserThreads.lf new file mode 100644 index 0000000000..dc54c9f3f6 --- /dev/null +++ b/test/C/src/zephyr/UserThreads.lf @@ -0,0 +1,36 @@ +// Test user threads platform option for Zephyr. The application should be able +// to create exactly three threads. +target C { + platform: { + name: Zephyr, + user-threads: 3 + }, + threading: true, + workers: 2, +} + +main reactor { + preamble {= + void func() {} + =} + reaction(startup) {= + int res; + int thread_id; + + for (int i = 0; i < 3; i++) { + res = lf_thread_create(&thread_id, &func, NULL); + if (res != 0) { + printf("FAILURE: Expected to be able to create thread.\n"); + exit(1); + } + } + + res = lf_thread_create(&thread_id, &func, NULL); + if (res == 0) { + printf("FAILURE: Expected to not be able to create thread.\n"); + exit(2); + } else { + printf("SUCCESS: Created exactly three user threads.\n"); + } + =} +} \ No newline at end of file From 48898a273cacaaee9360da69268c2da5bd3b9332 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 12 May 2023 14:02:54 +0200 Subject: [PATCH 285/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index b4c6963ea6..1b6b996af5 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit b4c6963ea6a5d951a5cf71b947f550117bd9f688 +Subproject commit 1b6b996af5a33e16665113d52311316e37825520 From 5bf8a003ba918426901a7bcf1561fdd1c42021f0 Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Mon, 15 May 2023 10:04:30 +0200 Subject: [PATCH 286/709] Fix error and warning reports --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 3 +-- test/C/src/zephyr/UserThreads.lf | 6 ++---- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index dfcdf1f445..401b380687 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1943,8 +1943,7 @@ protected void setUpGeneralParameters() { } if (targetConfig.platformOptions.platform != Platform.ZEPHYR && targetConfig.platformOptions.userThreads >= 0) { - System.out.println("Specifying user threads is only for the Zephyr platform. This option will be ignored."); - } + errorReporter.reportWarning("Specifying user threads is only for the Zephyr platform. This option will be ignored."); } if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake pickScheduler(); diff --git a/test/C/src/zephyr/UserThreads.lf b/test/C/src/zephyr/UserThreads.lf index dc54c9f3f6..105da11d01 100644 --- a/test/C/src/zephyr/UserThreads.lf +++ b/test/C/src/zephyr/UserThreads.lf @@ -20,15 +20,13 @@ main reactor { for (int i = 0; i < 3; i++) { res = lf_thread_create(&thread_id, &func, NULL); if (res != 0) { - printf("FAILURE: Expected to be able to create thread.\n"); - exit(1); + lf_print_error_and_exit("Could not create thread"); } } res = lf_thread_create(&thread_id, &func, NULL); if (res == 0) { - printf("FAILURE: Expected to not be able to create thread.\n"); - exit(2); + lf_print_error_and_exit("Could create more threads than specified."); } else { printf("SUCCESS: Created exactly three user threads.\n"); } From 1a3c07378fad0b959b65efc97d2bc6822a02cef5 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 15 May 2023 07:20:34 -0700 Subject: [PATCH 287/709] Include string.h --- util/tracing/trace_to_chrome.c | 1 + 1 file changed, 1 insertion(+) diff --git a/util/tracing/trace_to_chrome.c b/util/tracing/trace_to_chrome.c index 5cf979227a..8e0c29dba8 100644 --- a/util/tracing/trace_to_chrome.c +++ b/util/tracing/trace_to_chrome.c @@ -32,6 +32,7 @@ THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #define LF_TRACE #include +#include #include "reactor.h" #include "trace.h" #include "trace_util.h" From f8d38f0413d2aa324b3f1522e96fe480cfcb390e Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 15 May 2023 07:32:00 -0700 Subject: [PATCH 288/709] Align to watchdogs-eal2 of reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 618fa07480..cc3795695b 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 618fa07480964d82ebd88e28378bbfd335adb27c +Subproject commit cc3795695b18638512d5fe3c8ae8c021f044de9a From b7d0cd1b820c154ceebb80cf4fa9e0099258c51f Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 15 May 2023 17:43:45 +0200 Subject: [PATCH 289/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 1b6b996af5..1d17d9c543 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 1b6b996af5a33e16665113d52311316e37825520 +Subproject commit 1d17d9c5439d57e00145798e4dbd87d18342b891 From 749e332de1fb2e365909e52534803556427f71a7 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 15 May 2023 13:39:09 -0700 Subject: [PATCH 290/709] Closes #1701. --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index be931153f8..3c5d872f96 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -28,7 +28,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import static org.lflang.ASTUtils.allPorts; import static org.lflang.ASTUtils.allReactions; import static org.lflang.ASTUtils.allStateVars; -import static org.lflang.ASTUtils.convertToEmptyListIfNull; import static org.lflang.ASTUtils.getInferredType; import static org.lflang.ASTUtils.isInitialized; import static org.lflang.ASTUtils.toDefinition; @@ -51,6 +50,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.eclipse.xtext.xbase.lib.StringExtensions; import org.lflang.ASTUtils; +import org.lflang.generator.CodeMap; import org.lflang.generator.DockerComposeGenerator; import org.lflang.FileConfig; import org.lflang.Target; @@ -1029,10 +1029,10 @@ private void generateReactorClass(Reactor reactor) throws IOException { generateUserPreamblesForReactor(reactor, src); generateReactorClassBody(reactor, header, src); header.pr("#endif // " + guardMacro); - FileUtil.writeToFile(header.toString(), fileConfig.getSrcGenPath().resolve(headerName), true); + FileUtil.writeToFile(CodeMap.fromGeneratedCode(header.toString()).getGeneratedCode(), fileConfig.getSrcGenPath().resolve(headerName), true); var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" : CCppMode ? ".cpp" : ".c"; - FileUtil.writeToFile(src.toString(), fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), true); + FileUtil.writeToFile(CodeMap.fromGeneratedCode(src.toString()).getGeneratedCode(), fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), true); } protected void generateReactorClassHeaders(Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { From 036625c6a9759e40fb73e061d34455b0763562b0 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 16 May 2023 09:23:13 +0200 Subject: [PATCH 291/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 1d17d9c543..10a8055a65 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 1d17d9c5439d57e00145798e4dbd87d18342b891 +Subproject commit 10a8055a65ce4aec8b4c560b363046f08d46342f From 46a3738605d35bf73cf233e2b918bd0c9463f8ba Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 16 May 2023 18:31:07 +0200 Subject: [PATCH 292/709] update reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 10a8055a65..9a7b0a91ad 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 10a8055a65ce4aec8b4c560b363046f08d46342f +Subproject commit 9a7b0a91ad72bbf87702f2392ed2bebba528e831 From a84070a0a127e8b16471ee9434eb0dfe214019e1 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Tue, 16 May 2023 13:43:20 -0700 Subject: [PATCH 293/709] In response to review, renamed variables --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CGenerator.java | 4 ++-- .../src/org/lflang/generator/c/CWatchdogGenerator.java | 8 ++++---- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index cc3795695b..c2c6a54fa0 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit cc3795695b18638512d5fe3c8ae8c021f044de9a +Subproject commit c2c6a54fa023c638122a73a7c7f311cf381cea1e diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 4a7f29dabe..be6307943c 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -642,8 +642,8 @@ private void generateCodeFor( "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", "int bank_index;", "SUPPRESS_UNUSED_WARNING(bank_index);", - "int _lf_watchdog_number_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_watchdog_number_count);")); + "int watchdog_number = 0;", + "SUPPRESS_UNUSED_WARNING(watchdog_number);")); // Add counters for modal initialization initializeTriggerObjects.pr(CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 311fe365fd..28d9223ea8 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -62,7 +62,7 @@ protected static int generateInitializeWatchdogs(CodeBuilder code, ReactorInstan : ASTUtils.allWatchdogs(ASTUtils.toDefinition(instance.getDefinition().getReactorClass()))) { var watchdogField = reactorRef + "->_lf_watchdog_" + watchdog.getName(); temp.pr(String.join("\n", - "_lf_watchdogs[_lf_watchdog_number_count++] = &" + watchdogField + ";", + "_lf_watchdogs[watchdog_number++] = &" + watchdogField + ";", watchdogField + ".min_expiration = " + CTypes.getInstance().getTargetTimeExpr(instance.getTimeValue(watchdog.getTimeout())) + ";", @@ -78,7 +78,7 @@ protected static int generateInitializeWatchdogs(CodeBuilder code, ReactorInstan if (foundOne) { code.pr(temp.toString()); } - code.pr("SUPPRESS_UNUSED_WARNING(_lf_watchdog_number);"); + code.pr("SUPPRESS_UNUSED_WARNING(_lf_watchdog_count);"); return watchdogCount; } @@ -152,7 +152,7 @@ protected static String generateWatchdogTable(int count) { "// No watchdogs found.", "typedef void watchdog_t;", "watchdog_t* _lf_watchdogs = NULL;", - "int _lf_watchdog_number = 0;" + "int _lf_watchdog_count = 0;" ); } return String.join( @@ -160,7 +160,7 @@ protected static String generateWatchdogTable(int count) { List.of( "// Array of pointers to watchdog structs.", "watchdog_t* _lf_watchdogs[" + count + "];", - "int _lf_watchdog_number = " + count + ";" + "int _lf_watchdog_count = " + count + ";" ) ); } From 029f825201694b30a16156a0d352dd1cba20d6c0 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 16 May 2023 19:43:46 -0700 Subject: [PATCH 294/709] "fix" naming collision in fed-gen files. This is not really a fix because we still have the problem that we consider reactor classes to have distinct names using a **case-sensitive** comparison, but we want to generate files corresponding to the reactor classes that will be compared **case-insensitively** on macOS. However, it does make our generated code "less wrong." --- org.lflang/src/org/lflang/federated/generator/FedEmitter.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java index 9ae5c9d2cc..9cbffdbae2 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java @@ -52,7 +52,7 @@ Map generateFederate( + fileConfig.getSrcPath()); Path lfFilePath = fileConfig.getSrcPath().resolve( - fedName + ".lf"); + "__" + fedName + ".lf"); String federateCode = String.join( "\n", From c11dd2e9d5759cf9f780c1c4549aef0dfd09be4e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 16 May 2023 20:05:43 -0700 Subject: [PATCH 295/709] Check for case-insensitive name collisions. --- org.lflang/src/org/lflang/ModelInfo.java | 38 +++++++++++++++++------- 1 file changed, 28 insertions(+), 10 deletions(-) diff --git a/org.lflang/src/org/lflang/ModelInfo.java b/org.lflang/src/org/lflang/ModelInfo.java index 45e9995045..c447d381ac 100644 --- a/org.lflang/src/org/lflang/ModelInfo.java +++ b/org.lflang/src/org/lflang/ModelInfo.java @@ -11,15 +11,15 @@ this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +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. ***************/ @@ -28,6 +28,7 @@ import static org.eclipse.xtext.xbase.lib.IterableExtensions.filter; import static org.eclipse.xtext.xbase.lib.IteratorExtensions.toIterable; +import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.LinkedList; @@ -81,7 +82,7 @@ public class ModelInfo { * interval. */ public Set overflowingDeadlines; - + /** * The set of STP offsets that use a too-large constant to specify their time * interval. @@ -137,6 +138,23 @@ public void update(Model model, ErrorReporter reporter) { if (target == Target.C) { this.collectOverflowingNodes(); } + + checkCaseInsensitiveNameCollisions(model, reporter); + } + + public void checkCaseInsensitiveNameCollisions(Model model, ErrorReporter reporter) { + var reactorNames = new HashSet<>(); + var bad = new ArrayList<>(); + for (var reactor : model.getReactors()) { + var lowerName = reactor.getName().toLowerCase(); + if (reactorNames.contains(lowerName)) bad.add(lowerName); + reactorNames.add(lowerName); + } + for (var badName : bad) { + model.getReactors().stream().filter(it -> it.getName() + .toLowerCase().equals(badName)) + .forEach(it -> reporter.reportError(it, "Multiple reactors have the same name up to case differences.")); + } } public Set> topologyCycles() { @@ -223,7 +241,7 @@ private boolean detectOverflow(Set visited, Parameter current) { // Check for overflow in the referenced parameter. overflow = detectOverflow(visited, ((ParameterReference)expr).getParameter()) || overflow; } else { - // The right-hand side of the assignment is a + // The right-hand side of the assignment is a // constant; check whether it is too large. if (isTooLarge(ASTUtils.getLiteralTimeValue(expr))) { this.overflowingAssignments.add(assignment); From 4f85c270b64e0fa4634add3f92860def23100f54 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 16 May 2023 20:23:02 -0700 Subject: [PATCH 296/709] Refactor a bit. The file name of the fed-gen file should be specified in one place (DRY). --- .../src/org/lflang/federated/generator/FedEmitter.java | 9 ++++++--- .../src/org/lflang/federated/generator/FedGenerator.java | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java index 9cbffdbae2..ee44002306 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java @@ -51,9 +51,6 @@ Map generateFederate( + " in directory " + fileConfig.getSrcPath()); - Path lfFilePath = fileConfig.getSrcPath().resolve( - "__" + fedName + ".lf"); - String federateCode = String.join( "\n", new FedTargetEmitter().generateTarget(context, numOfFederates, federate, fileConfig, errorReporter, rtiConfig), @@ -67,6 +64,7 @@ Map generateFederate( ) ); Map codeMapMap = new HashMap<>(); + var lfFilePath = lfFilePath(fileConfig, federate); try (var srcWriter = Files.newBufferedWriter(lfFilePath)) { var codeMap = CodeMap.fromGeneratedCode(federateCode); codeMapMap.put(lfFilePath, codeMap); @@ -74,4 +72,9 @@ Map generateFederate( } return codeMapMap; } + + public static Path lfFilePath(FedFileConfig fileConfig, FederateInstance federate) { + return fileConfig.getSrcPath().resolve( + "__" + federate.name + ".lf"); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java index cd9c2e95d0..dddae562f7 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java +++ b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java @@ -286,7 +286,7 @@ private Map compileFederates( final int id = i; compileThreadPool.execute(() -> { Resource res = rs.getResource(URI.createFileURI( - fileConfig.getSrcPath().resolve(fed.name + ".lf").toAbsolutePath().toString() + FedEmitter.lfFilePath(fileConfig, fed).toAbsolutePath().toString() ), true); FileConfig subFileConfig = LFGenerator.createFileConfig(res, fileConfig.getSrcGenPath(), true); ErrorReporter subContextErrorReporter = new LineAdjustingErrorReporter(threadSafeErrorReporter, lf2lfCodeMapMap); From 0cbbacd36c424b21bca42b5711396fb9367d26a5 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 16 May 2023 21:13:03 -0700 Subject: [PATCH 297/709] Fix NPE in getting name of reactor. --- org.lflang/src/org/lflang/ModelInfo.java | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/ModelInfo.java b/org.lflang/src/org/lflang/ModelInfo.java index c447d381ac..22caf4a0dc 100644 --- a/org.lflang/src/org/lflang/ModelInfo.java +++ b/org.lflang/src/org/lflang/ModelInfo.java @@ -28,6 +28,7 @@ import static org.eclipse.xtext.xbase.lib.IterableExtensions.filter; import static org.eclipse.xtext.xbase.lib.IteratorExtensions.toIterable; +import java.nio.file.Path; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashSet; @@ -47,6 +48,7 @@ import org.lflang.lf.ParameterReference; import org.lflang.lf.Reactor; import org.lflang.lf.STP; +import org.lflang.util.FileUtil; /** @@ -146,17 +148,21 @@ public void checkCaseInsensitiveNameCollisions(Model model, ErrorReporter report var reactorNames = new HashSet<>(); var bad = new ArrayList<>(); for (var reactor : model.getReactors()) { - var lowerName = reactor.getName().toLowerCase(); + var lowerName = getName(reactor).toLowerCase(); if (reactorNames.contains(lowerName)) bad.add(lowerName); reactorNames.add(lowerName); } for (var badName : bad) { - model.getReactors().stream().filter(it -> it.getName() - .toLowerCase().equals(badName)) + model.getReactors().stream() + .filter(it -> getName(it).toLowerCase().equals(badName)) .forEach(it -> reporter.reportError(it, "Multiple reactors have the same name up to case differences.")); } } + private String getName(Reactor r) { + return r.getName() == null ? r.getName() : FileUtil.nameWithoutExtension(Path.of(model.eResource().getURI().toFileString())); + } + public Set> topologyCycles() { return this.topologyCycles; } From e1652694045e73f49c4d70d24003fb97846e4e7d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 16 May 2023 21:25:27 -0700 Subject: [PATCH 298/709] Update unit test. --- .../src/org/lflang/tests/compiler/TargetConfigTests.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java index 593e302d25..12b86996cb 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java @@ -94,7 +94,7 @@ public void testFederation() throws Exception { generator.doGenerate(resource, fileAccess, context); String lfSrc = Files.readAllLines( - ((FedFileConfig)context.getFileConfig()).getSrcPath().resolve("a.lf") + ((FedFileConfig)context.getFileConfig()).getSrcPath().resolve("__a.lf") ).stream().reduce("\n", String::concat); Model federate = parser.parse(lfSrc); assertHasTargetProperty(federate, "tracing"); From 47eb5c8ab58bce0e971f86c8c77d8d4541239a04 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 16 May 2023 21:28:15 -0700 Subject: [PATCH 299/709] Fix logical error. --- org.lflang/src/org/lflang/ModelInfo.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/ModelInfo.java b/org.lflang/src/org/lflang/ModelInfo.java index 22caf4a0dc..fbe5c2047c 100644 --- a/org.lflang/src/org/lflang/ModelInfo.java +++ b/org.lflang/src/org/lflang/ModelInfo.java @@ -160,7 +160,7 @@ public void checkCaseInsensitiveNameCollisions(Model model, ErrorReporter report } private String getName(Reactor r) { - return r.getName() == null ? r.getName() : FileUtil.nameWithoutExtension(Path.of(model.eResource().getURI().toFileString())); + return r.getName() != null ? r.getName() : FileUtil.nameWithoutExtension(Path.of(model.eResource().getURI().toFileString())); } public Set> topologyCycles() { From 05827f1119a9e2b9ab9f6eb42ea80e9b0f5a1473 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 16 May 2023 23:28:14 -0700 Subject: [PATCH 300/709] Attempt to pass failing TS docker tests. --- org.lflang/src/org/lflang/generator/DockerGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/DockerGenerator.java b/org.lflang/src/org/lflang/generator/DockerGenerator.java index 902d664631..851ee6c0be 100644 --- a/org.lflang/src/org/lflang/generator/DockerGenerator.java +++ b/org.lflang/src/org/lflang/generator/DockerGenerator.java @@ -43,7 +43,7 @@ public DockerData generateDockerData() { var dockerFilePath = context.getFileConfig().getSrcGenPath().resolve("Dockerfile"); var dockerFileContent = generateDockerFileContent(); - return new DockerData(name, dockerFilePath, dockerFileContent); + return new DockerData(name.replace("_", ""), dockerFilePath, dockerFileContent); } public static DockerGenerator dockerGeneratorFactory(LFGeneratorContext context) { From 3c52f30f82c2863a47eb980ea799b7fd0c7abef2 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 17 May 2023 11:02:16 -0700 Subject: [PATCH 301/709] Bugfix. The problem here is that we use the uniqueID of the federate both before and after we transform it into separate programs. After we transform it, the name of the instance depends on the name of the main reactor, which might be different (indeed, it must be different in order for us to eliminate the possibility of name collisions with other parts of the program). So this is a bit of a hack, but I'm not sure what else to do. --- org.lflang/src/org/lflang/generator/ReactorInstance.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index eb5163ade6..92d7d9ea3d 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -323,7 +323,8 @@ public String getName() { @Override public String uniqueID() { if (this.isMainOrFederated()) { - return super.uniqueID() + "_main"; + if (reactorDefinition.isFederated()) return "__" + super.uniqueID() + "_main"; + return super.uniqueID() + "_main"; } return super.uniqueID(); } From 2551a52142474be7a1c04183f4485b3e43595482 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 17 May 2023 15:08:11 -0700 Subject: [PATCH 302/709] Address federated test failures. It is bad that in order to make this change it is necessary to edit code in several places. But it isn't clear how to fix this because different parts of the code operate on the program at different stages in the compilation process, either before or after it has been split into many programs. --- .../federated/generator/FederateInstance.java | 84 +++++++++---------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index 7ca5a19bca..6dd7dc1de2 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -97,8 +97,8 @@ public class FederateInstance { // why does this not extend ReactorInstance? * @param errorReporter The error reporter */ public FederateInstance( - Instantiation instantiation, - int id, + Instantiation instantiation, + int id, int bankIndex, TargetConfig targetConfig, ErrorReporter errorReporter) { @@ -107,9 +107,9 @@ public FederateInstance( this.bankIndex = bankIndex; this.errorReporter = errorReporter; this.targetConfig = targetConfig; - + if (instantiation != null) { - this.name = instantiation.getName(); + this.name = "__" + instantiation.getName(); // If the instantiation is in a bank, then we have to append // the bank index to the name. if (instantiation.getWidthSpec() != null) { @@ -120,18 +120,18 @@ public FederateInstance( ///////////////////////////////////////////// //// Public Fields - + /** * The position within a bank of reactors for this federate. * This is 0 if the instantiation is not a bank of reactors. */ public int bankIndex = 0; - + /** * A list of outputs that can be triggered directly or indirectly by physical actions. */ public Set outputsConnectedToPhysicalActions = new LinkedHashSet<>(); - + /** * The host, if specified using the 'at' keyword. */ @@ -150,7 +150,7 @@ public Instantiation getInstantiation() { * A list of individual connections between federates */ public Set connections = new HashSet<>(); - + /** * Map from the federates that this federate receives messages from * to the delays on connections from that federate. The delay set @@ -158,17 +158,17 @@ public Instantiation getInstantiation() { * from the federate instance that has no delay. */ public Map> dependsOn = new LinkedHashMap<>(); - + /** * The directory, if specified using the 'at' keyword. */ public String dir = null; - + /** * The port, if specified using the 'at' keyword. */ public int port = 0; - + /** * Map from the federates that this federate sends messages to * to the delays on connections to that federate. The delay set @@ -176,12 +176,12 @@ public Instantiation getInstantiation() { * from the federate instance that has no delay. */ public Map> sendsTo = new LinkedHashMap<>(); - + /** * The user, if specified using the 'at' keyword. */ public String user = null; - + /** * The integer ID of this federate. */ @@ -194,7 +194,7 @@ public Instantiation getInstantiation() { * this instance if the instantiation is of a bank of reactors. */ public String name = "Unnamed"; - + /** * List of networkMessage actions. Each of these handles a message * received from another federate over the network. The ID of @@ -202,7 +202,7 @@ public Instantiation getInstantiation() { * The sending federate needs to specify this ID. */ public List networkMessageActions = new ArrayList<>(); - + /** * A set of federates with which this federate has an inbound connection * There will only be one physical connection even if federate A has defined multiple @@ -211,7 +211,7 @@ public Instantiation getInstantiation() { * to help the receiver distinguish different events. */ public Set inboundP2PConnections = new LinkedHashSet<>(); - + /** * A list of federate with which this federate has an outbound physical connection. * There will only be one physical connection even if federate A has defined multiple @@ -220,29 +220,29 @@ public Instantiation getInstantiation() { * scheduling the appropriate action. */ public Set outboundP2PConnections = new LinkedHashSet<>(); - + /** * A list of triggers for network input control reactions. This is used to trigger * all the input network control reactions that might be nested in a hierarchy. */ public List networkInputControlReactionsTriggers = new ArrayList<>(); - + /** * The trigger that triggers the output control reaction of this * federate. - * + * * The network output control reactions send a PORT_ABSENT message for a network output port, * if it is absent at the current tag, to notify all downstream federates that no value will * be present on the given network port, allowing input control reactions on those federates * to stop blocking. */ public Variable networkOutputControlReactionsTrigger = null; - + /** * Indicates whether the federate is remote or local */ public boolean isRemote = false; - + /** * List of generated network reactions (network receivers, * network input control reactions, network senders, and network output control @@ -389,16 +389,16 @@ private boolean contains(Action action) { } } } - - return false; + + return false; } - /** + /** * Return true if the specified reaction should be included in the code generated for this * federate at the top-level. This means that if the reaction is triggered by or * sends data to a port of a contained reactor, then that reaction * is in the federate. Otherwise, return false. - * + * * NOTE: This method assumes that it will not be called with reaction arguments * that are within other federates. It should only be called on reactions that are * either at the top level or within this federate. For this reason, for any reaction @@ -411,7 +411,7 @@ private boolean contains(Reaction reaction) { assert reactor != null; if (!reactor.getReactions().contains(reaction)) return false; - + if (networkReactions.contains(reaction)) { // Reaction is a network reaction that belongs to this federate return true; @@ -421,15 +421,15 @@ private boolean contains(Reaction reaction) { if (reactionBankIndex >= 0 && this.bankIndex >= 0 && reactionBankIndex != this.bankIndex) { return false; } - + // If this has been called before, then the result of the // following check is cached. if (excludeReactions != null) { return !excludeReactions.contains(reaction); } - + indexExcludedTopLevelReactions(reactor); - + return !excludeReactions.contains(reaction); } @@ -462,17 +462,17 @@ private boolean contains(Timer timer) { return false; } - /** + /** * Return true if the specified reactor instance or any parent * reactor instance is contained by this federate. * If the specified instance is the top-level reactor, return true * (the top-level reactor belongs to all federates). * If this federate instance is a singleton, then return true if the * instance is non null. - * + * * NOTE: If the instance is bank within the top level, then this * returns true even though only one of the bank members is in the federate. - * + * * @param instance The reactor instance. * @return True if this federate contains the reactor instance */ @@ -496,7 +496,7 @@ public boolean contains(ReactorInstance instance) { * federatedReactor) that don't belong to this federate * instance. This index is put in the excludeReactions * class variable. - * + * * @param federatedReactor The top-level federated reactor */ private void indexExcludedTopLevelReactions(Reactor federatedReactor) { @@ -537,7 +537,7 @@ private void indexExcludedTopLevelReactions(Reactor federatedReactor) { } } } - + /** * Return true if all members of 'varRefs' belong to this federate. * @@ -564,7 +564,7 @@ private boolean containsAllVarRefs(Iterable varRefs) { } return inFederate; } - + /** * Find output ports that are connected to a physical action trigger upstream * in the same reactor. Return a list of such outputs paired with the minimum delay @@ -596,7 +596,7 @@ public List getZeroDelayImmediateUpstreamFederates() { .filter(e -> e.getValue().contains(null)) .map(Map.Entry::getKey).toList(); } - + @Override public String toString() { return "Federate " + id + ": " @@ -605,21 +605,21 @@ public String toString() { ///////////////////////////////////////////// //// Private Fields - + /** * Cached result of analysis of which reactions to exclude from main. */ private Set excludeReactions = null; - + /** * An error reporter */ private final ErrorReporter errorReporter; - + /** * Find the nearest (shortest) path to a physical action trigger from this * 'reaction' in terms of minimum delay. - * + * * @param reaction The reaction to start with * @return The minimum delay found to the nearest physical action and * TimeValue.MAX_VALUE otherwise @@ -646,7 +646,7 @@ public TimeValue findNearestPhysicalActionTrigger(ReactionInstance reaction) { } } } - + } else if (trigger.getDefinition() instanceof Output) { // Outputs of contained reactions PortInstance outputInstance = (PortInstance) trigger; @@ -660,7 +660,7 @@ public TimeValue findNearestPhysicalActionTrigger(ReactionInstance reaction) { } return minDelay; } - + // TODO: Put this function into a utils file instead private List convertToEmptyListIfNull(List list) { return list == null ? new ArrayList<>() : list; From 13e9b291c9336779482f9fcf9fa50d59d690f199 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 17 May 2023 16:40:14 -0700 Subject: [PATCH 303/709] Do not doubly mark as federated. This is hacky. The problem is that the generated code does not have a federated reactor, but we do an AST transformation so that we can pretend that it is (I do not want to know why). So we end up running the code generator on a federated program, even though it is supposed to result on code for a single federate. So if the federate had its name prefixed once in the main run of the code generator, its name will be prefixed again in the nested run of the code generator. --- .../src/org/lflang/federated/generator/FedEmitter.java | 3 +-- .../org/lflang/federated/generator/FederateInstance.java | 7 +------ org.lflang/src/org/lflang/generator/ReactorInstance.java | 2 +- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java index ee44002306..2c9f32aad8 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java @@ -74,7 +74,6 @@ Map generateFederate( } public static Path lfFilePath(FedFileConfig fileConfig, FederateInstance federate) { - return fileConfig.getSrcPath().resolve( - "__" + federate.name + ".lf"); + return fileConfig.getSrcPath().resolve(federate.name + ".lf"); } } diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index 6dd7dc1de2..835ecca4dd 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -25,7 +25,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.federated.generator; -import java.io.File; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; @@ -40,17 +39,13 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.ASTUtils; import org.lflang.ErrorReporter; -import org.lflang.FileConfig; -import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TimeValue; import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.generator.ActionInstance; -import org.lflang.generator.GeneratorUtils; import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; -import org.lflang.generator.SubContext; import org.lflang.generator.TriggerInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; @@ -109,12 +104,12 @@ public FederateInstance( this.targetConfig = targetConfig; if (instantiation != null) { - this.name = "__" + instantiation.getName(); // If the instantiation is in a bank, then we have to append // the bank index to the name. if (instantiation.getWidthSpec() != null) { this.name = instantiation.getName() + "__" + bankIndex; } + name = "federate__" + name; } } diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 92d7d9ea3d..20f9718aea 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -323,7 +323,7 @@ public String getName() { @Override public String uniqueID() { if (this.isMainOrFederated()) { - if (reactorDefinition.isFederated()) return "__" + super.uniqueID() + "_main"; + if (reactorDefinition.isFederated() && !super.uniqueID().startsWith("federate__")) return "federate__" + super.uniqueID() + "_main"; return super.uniqueID() + "_main"; } return super.uniqueID(); From d4968e8800258ea19b0377b4e80683a91369f02e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 17 May 2023 16:53:35 -0700 Subject: [PATCH 304/709] More bugfixes. --- .../src/org/lflang/tests/compiler/TargetConfigTests.java | 2 +- .../src/org/lflang/federated/generator/FederateInstance.java | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java index 12b86996cb..eede6a6831 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java @@ -94,7 +94,7 @@ public void testFederation() throws Exception { generator.doGenerate(resource, fileAccess, context); String lfSrc = Files.readAllLines( - ((FedFileConfig)context.getFileConfig()).getSrcPath().resolve("__a.lf") + ((FedFileConfig)context.getFileConfig()).getSrcPath().resolve("federate__a.lf") ).stream().reduce("\n", String::concat); Model federate = parser.parse(lfSrc); assertHasTargetProperty(federate, "tracing"); diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index 835ecca4dd..cdd64f03b2 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -107,9 +107,10 @@ public FederateInstance( // If the instantiation is in a bank, then we have to append // the bank index to the name. if (instantiation.getWidthSpec() != null) { - this.name = instantiation.getName() + "__" + bankIndex; + this.name = "federate__" + instantiation.getName() + "__" + bankIndex; + } else { + this.name = "federate__" + instantiation.getName(); } - name = "federate__" + name; } } From def5022b94e2f145eda84c9ba40acc3612fc9907 Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Thu, 18 May 2023 10:00:07 +0200 Subject: [PATCH 305/709] Format test --- test/C/src/zephyr/UserThreads.lf | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/test/C/src/zephyr/UserThreads.lf b/test/C/src/zephyr/UserThreads.lf index 105da11d01..c16be556fc 100644 --- a/test/C/src/zephyr/UserThreads.lf +++ b/test/C/src/zephyr/UserThreads.lf @@ -1,18 +1,17 @@ -// Test user threads platform option for Zephyr. The application should be able +// Test user threads platform option for Zephyr. The application should be able // to create exactly three threads. target C { platform: { name: Zephyr, user-threads: 3 - }, - threading: true, - workers: 2, + }, + threading: true, + workers: 2 } main reactor { - preamble {= - void func() {} - =} + preamble {= void func() {} =} + reaction(startup) {= int res; int thread_id; @@ -31,4 +30,4 @@ main reactor { printf("SUCCESS: Created exactly three user threads.\n"); } =} -} \ No newline at end of file +} From 9e075e9456fcb179ad4f671646b2f32af1526b9e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 17 May 2023 22:03:54 -0700 Subject: [PATCH 306/709] Delete unnecessary complexity from build-lf-cli. --- lib/scripts/build.sh | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/lib/scripts/build.sh b/lib/scripts/build.sh index d342aa45cd..52cc403851 100755 --- a/lib/scripts/build.sh +++ b/lib/scripts/build.sh @@ -114,18 +114,4 @@ if [ "${OSTYPE}" = "msys" ]; then fi jar_path="$(get_jar_path)" - -if [ ! -f "${jar_path}" ] || ! "${find_cmd}" "${base}" \ - -path "${src_pkg_path}" \ - -prune -o \ - -type f \ - -newer "${jar_path}" \ - -exec false {} +; then - # Rebuild. - 1>&2 echo "Jar file is missing or out-of-date; starting rebuild..." - "${base}/gradlew" ${flags} -p "${base}" buildAll - # Update the timestamp in case the jar was not touched by Gradle. - touch -c -- "${jar_path}" -else - echo "Already up-to-date." -fi +"${base}/gradlew" ${flags} -p "${base}" buildAll From 73c52a510a92c19de9485024d18573b57a17550a Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 17 May 2023 13:05:33 +0200 Subject: [PATCH 307/709] Mechanism for printing execution statistics This adds the `print-statistics` target property and pulls in https://github.com/lf-lang/reactor-cpp/pull/47. If `print-statistics` is true, the compiled program will print an output like the following when the program terminates. ``` [INFO] ----------------------------------------------------------- [INFO] Program statistics: [INFO] - number of reactors: 4 [INFO] - number of connections: 4 [INFO] - number of reactions 9 [INFO] - number of actions: 11 [INFO] - number of ports: 8 [INFO] Execution statistics: [INFO] - processed events: 12000015 [INFO] - triggered actions: 12000021 [INFO] - processed reactions: 36000039 [INFO] - set ports: 24000024 [INFO] - scheduled actions: 12000021 [INFO] ----------------------------------------------------------- ``` --- .../src/org/lflang/tests/cli/LfcCliTest.java | 3 +++ org.lflang/src/lib/cpp/reactor-cpp | 2 +- org.lflang/src/org/lflang/TargetConfig.java | 9 +++++++++ org.lflang/src/org/lflang/TargetProperty.java | 10 ++++++++++ org.lflang/src/org/lflang/cli/Lfc.java | 10 ++++++++++ .../src/org/lflang/generator/LFGeneratorContext.java | 4 +--- .../org/lflang/generator/cpp/CppStandaloneGenerator.kt | 1 + 7 files changed, 35 insertions(+), 4 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java b/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java index 7143ba9375..d16193faad 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java +++ b/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java @@ -76,6 +76,7 @@ public class LfcCliTest { "logging": "info", "lint": true, "no-compile": true, + "print-statistics": true, "quiet": true, "rti": "path/to/rti", "runtime-version": "rs", @@ -228,6 +229,7 @@ public void verifyGeneratorArgs(Path tempDir, String[] args) { assertEquals(properties.getProperty(BuildParm.LOGGING.getKey()), "info"); assertEquals(properties.getProperty(BuildParm.LINT.getKey()), "true"); assertEquals(properties.getProperty(BuildParm.NO_COMPILE.getKey()), "true"); + assertEquals(properties.getProperty(BuildParm.PRINT_STATISTICS.getKey()), "true"); assertEquals(properties.getProperty(BuildParm.QUIET.getKey()), "true"); assertEquals(properties.getProperty(BuildParm.RTI.getKey()), "path" + File.separator + "to" + File.separator + "rti"); @@ -256,6 +258,7 @@ public void testGeneratorArgs(@TempDir Path tempDir) "--logging", "info", "--lint", "--no-compile", + "--print-statistics", "--quiet", "--rti", "path/to/rti", "--runtime-version", "rs", diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index 9a7b0a91ad..a13eda638f 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit 9a7b0a91ad72bbf87702f2392ed2bebba528e831 +Subproject commit a13eda638fd5a4a71c8d42ef5fa20ef692370f87 diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 845f214ec8..84770be5d1 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -40,6 +40,7 @@ import org.lflang.TargetProperty.Platform; import org.lflang.TargetProperty.SchedulerOption; import org.lflang.TargetProperty.UnionType; +import org.lflang.generator.LFGeneratorContext.BuildParm; import org.lflang.generator.rust.RustTargetConfig; import org.lflang.lf.KeyValuePair; import org.lflang.lf.TargetDecl; @@ -137,6 +138,9 @@ public TargetConfig( this.keepalive = Boolean.parseBoolean( cliArgs.getProperty(TargetProperty.KEEPALIVE.description)); } + if (cliArgs.containsKey(BuildParm.PRINT_STATISTICS.getKey())) { + this.printStatistics = true; + } } /** @@ -269,6 +273,11 @@ public TargetConfig( */ public PlatformOptions platformOptions = new PlatformOptions(); + /** + * If true, instruct the runtime to collect and print execution statistics. + */ + public boolean printStatistics = false; + /** * List of proto files to be processed by the code generator. */ diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index 61cda14431..25445a3e37 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -479,6 +479,16 @@ public enum TargetProperty { } }), + /** + * Directive to instruct the runtime to collect and print execution statistics. + */ + PRINT_STATISTICS("print-statistics", PrimitiveType.BOOLEAN, + Arrays.asList(Target.CPP), + (config) -> ASTUtils.toElement(config.printStatistics), + (config, value, err) -> { + config.printStatistics = ASTUtils.toBoolean(value); + }), + /** * Directive for specifying .proto files that need to be compiled and their * code included in the sources. diff --git a/org.lflang/src/org/lflang/cli/Lfc.java b/org.lflang/src/org/lflang/cli/Lfc.java index f0e88aef93..eb67768beb 100644 --- a/org.lflang/src/org/lflang/cli/Lfc.java +++ b/org.lflang/src/org/lflang/cli/Lfc.java @@ -97,6 +97,12 @@ public class Lfc extends CliBase { description = "Do not invoke target compiler.") private boolean noCompile; + @Option( + names = {"--print-statistics"}, + arity = "0", + description = "Instruct the runtime to collect and print statistics.") + private boolean printStatistics; + @Option( names = {"-q", "--quiet"}, arity = "0", @@ -265,6 +271,10 @@ public Properties getGeneratorArgs() { props.setProperty(BuildParm.LOGGING.getKey(), logging); } + if(printStatistics) { + props.setProperty(BuildParm.PRINT_STATISTICS.getKey(), "true"); + } + if (noCompile) { props.setProperty(BuildParm.NO_COMPILE.getKey(), "true"); } diff --git a/org.lflang/src/org/lflang/generator/LFGeneratorContext.java b/org.lflang/src/org/lflang/generator/LFGeneratorContext.java index 65ea702c39..5a5eddf178 100644 --- a/org.lflang/src/org/lflang/generator/LFGeneratorContext.java +++ b/org.lflang/src/org/lflang/generator/LFGeneratorContext.java @@ -1,15 +1,12 @@ package org.lflang.generator; -import java.io.IOException; import java.nio.file.Path; import java.util.Map; -import java.util.Objects; import java.util.Properties; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.IFileSystemAccess2; import org.eclipse.xtext.generator.IGeneratorContext; -import org.eclipse.xtext.util.RuntimeIOException; import org.lflang.ErrorReporter; import org.lflang.FileConfig; @@ -37,6 +34,7 @@ enum BuildParm { LINT("Enable or disable linting of generated code."), NO_COMPILE("Do not invoke target compiler."), OUTPUT_PATH("Specify the root output directory."), + PRINT_STATISTICS("Instruct the runtime to collect and print statistics."), QUIET("Suppress output of the target compiler and other commands"), RTI("Specify the location of the RTI."), RUNTIME_VERSION("Specify the version of the runtime library used for compiling LF programs."), diff --git a/org.lflang/src/org/lflang/generator/cpp/CppStandaloneGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppStandaloneGenerator.kt index bd4b58f3cd..f307559d9e 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppStandaloneGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppStandaloneGenerator.kt @@ -165,6 +165,7 @@ class CppStandaloneGenerator(generator: CppGenerator) : "-DCMAKE_INSTALL_PREFIX=${outPath.toUnixString()}", "-DCMAKE_INSTALL_BINDIR=${outPath.relativize(fileConfig.binPath).toUnixString()}", "-DREACTOR_CPP_VALIDATE=${if (targetConfig.noRuntimeValidation) "OFF" else "ON"}", + "-DREACTOR_CPP_PRINT_STATISTICS=${if (targetConfig.printStatistics) "ON" else "OFF"}", "-DREACTOR_CPP_TRACE=${if (targetConfig.tracing != null) "ON" else "OFF"}", "-DREACTOR_CPP_LOG_LEVEL=${targetConfig.logLevel.severity}", "-DLF_SRC_PKG_PATH=${fileConfig.srcPkgPath}", From 917ea837ea3be135c132c53f5453797807fcfb81 Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Thu, 18 May 2023 10:57:18 +0200 Subject: [PATCH 308/709] Fix always getting user thread warning --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 4215f015fa..a5dc78c2b0 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1942,7 +1942,7 @@ protected void setUpGeneralParameters() { ); } - if (targetConfig.platformOptions.platform != Platform.ZEPHYR && targetConfig.platformOptions.userThreads >= 0) { + if (targetConfig.platformOptions.platform != Platform.ZEPHYR && targetConfig.platformOptions.userThreads > 0) { errorReporter.reportWarning("Specifying user threads is only for the Zephyr platform. This option will be ignored."); } if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake From 2ef47cd3b82d9c99d2185d30f301bdb4d738070c Mon Sep 17 00:00:00 2001 From: erling Date: Thu, 18 May 2023 12:07:09 -0700 Subject: [PATCH 309/709] Zephyr CI fix (#1740) Fix current test failure in master. --- .github/actions/setup-zephyr/action.yml | 34 +++++++++++++++++++++++++ .github/workflows/c-zephyr-tests.yml | 22 ++-------------- 2 files changed, 36 insertions(+), 20 deletions(-) create mode 100644 .github/actions/setup-zephyr/action.yml diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml new file mode 100644 index 0000000000..64d85ec0f2 --- /dev/null +++ b/.github/actions/setup-zephyr/action.yml @@ -0,0 +1,34 @@ +name: Install Zephyr and dependencies (Linux only) +description: Install Zephyr and dependencies (Linux only) +runs: + using: "composite" + steps: + - name: Dependencies + run: | + sudo apt install -y --no-install-recommends git cmake ninja-build gperf \ + ccache dfu-util device-tree-compiler wget \ + python3-dev python3-pip python3-setuptools python3-tk python3-wheel xz-utils file \ + make gcc gcc-multilib g++-multilib libsdl2-dev libmagic1 + shell: bash + - name: Install West + run: pip install west + shell: bash + - name: Install Zephyr SDK + run : | + wget -q https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.15.2/zephyr-sdk-0.15.2_linux-x86_64.tar.gz + wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.15.2/sha256.sum | shasum --check --ignore-missing + sudo tar xf zephyr-sdk-0.15.2_linux-x86_64.tar.gz --directory /opt/ + cd /opt/zephyr-sdk-0.15.2 + sudo ./setup.sh -t all -h -c + shell: bash + - name: Download and install Zephyr RTOS + run: | + cd $HOME + west init zephyrproject --mr v3.2.0 + cd zephyrproject + west update + west zephyr-export + pip install -r zephyr/scripts/requirements.txt + echo "ZEPHYR_BASE=$HOME/zephyrproject/zephyr" >> $GITHUB_ENV + echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-0.15.2/" >> $GITHUB_ENV + shell: bash \ No newline at end of file diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 8af72a2f39..3b7a76feee 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -20,23 +20,7 @@ on: jobs: run: runs-on: ubuntu-latest - container: - image: zephyrprojectrtos/zephyr-build:v0.24.13 - options: -u root --entrypoint /bin/sh steps: - - name: Install Java 17, Maven and set JAVA_HOME - run: | - sudo apt-get update - sudo apt-get install -y openjdk-17-jdk - sudo apt-get install -y maven - echo "JAVA_HOME_17_X64=/usr/lib/jvm/java-17-openjdk-amd64" >> $GITHUB_ENV - - name: Initialize zephyr - run: | - west init /workdir/zephyrproject --mr v3.2.0 - cd /workdir/zephyrproject - west update - echo "ZEPHYR_BASE=/workdir/zephyrproject/zephyr" >> $GITHUB_ENV - echo "ZEPHYR_SDK_INSTALL_DIR=/opt/toolchains/zephyr-sdk-0.15.2/" >> $GITHUB_ENV - name: Check out lingua-franca repository uses: actions/checkout@v3 with: @@ -44,12 +28,10 @@ jobs: submodules: true ref: ${{ inputs.compiler-ref }} fetch-depth: 0 - - name: Try to get around git safe issues - run: | - git config --global --add safe.directory '/__w/lingua-franca/lingua-franca' - git config --global --add safe.directory '/__w/reactor-c/reactor-c' - name: Prepare build environment uses: ./.github/actions/prepare-build-env + - name: Setup Zephyr + uses: ./.github/actions/setup-zephyr - name: Check out specific ref of reactor-c uses: actions/checkout@v3 with: From 68afbc24bed2f11995ff32de8e550a08b19c3feb Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 18 May 2023 16:51:13 -0700 Subject: [PATCH 310/709] Address remaining FIXME to include errorReporter --- .../org/lflang/generator/c/CGenerator.java | 2 +- .../generator/c/CWatchdogGenerator.java | 31 ++++++++++++------- 2 files changed, 20 insertions(+), 13 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index e5e27c952a..32174be22c 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1067,7 +1067,7 @@ private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeB var constructorCode = new CodeBuilder(); generateAuxiliaryStructs(header, reactor, false); // The following must go before the self struct so the #include watchdog.h ends up in the header. - CWatchdogGenerator.generateWatchdogs(src, header, reactor); + CWatchdogGenerator.generateWatchdogs(src, header, reactor, errorReporter); generateSelfStruct(header, reactor, constructorCode); generateMethods(src, reactor); generateReactions(src, reactor); diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 28d9223ea8..9ab15ea98e 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -10,6 +10,7 @@ import java.util.List; import org.lflang.ASTUtils; +import org.lflang.ErrorReporter; import org.lflang.generator.CodeBuilder; import org.lflang.generator.ReactorInstance; import org.lflang.lf.Mode; @@ -91,12 +92,14 @@ protected static int generateInitializeWatchdogs(CodeBuilder code, ReactorInstan * @param header The place to put header code * @param decl The reactor declaration */ - protected static void generateWatchdogs(CodeBuilder src, CodeBuilder header, ReactorDecl decl) { + protected static void generateWatchdogs( + CodeBuilder src, CodeBuilder header, ReactorDecl decl, ErrorReporter errorReporter + ) { var reactor = ASTUtils.toDefinition(decl); if (hasWatchdogs(reactor)) { header.pr("#include \"core/threaded/watchdog.h\""); for (Watchdog watchdog : ASTUtils.allWatchdogs(reactor)) { - src.pr(generateWatchdogFunction(watchdog, decl)); + src.pr(generateWatchdogFunction(watchdog, decl, errorReporter)); } } } @@ -174,7 +177,11 @@ protected static String generateWatchdogTable(int count) { * @param watchdog The wotchdog * @param decl The declaration for the reactor that has the watchdog */ - private static String generateInitializationForWatchdog(Watchdog watchdog, ReactorDecl decl) { + private static String generateInitializationForWatchdog( + Watchdog watchdog, + ReactorDecl decl, + ErrorReporter errorReporter + ) { Reactor reactor = ASTUtils.toDefinition(decl); // Construct the reactionInitialization code to go into @@ -219,14 +226,12 @@ private static String generateInitializationForWatchdog(Watchdog watchdog, React ? "history_transition" : "reset_transition") + ";"); + } else { + errorReporter.reportError( + watchdog, + "In generateInitializationForWatchdog(): " + name + " not a valid mode of this reactor." + ); } - // FIXME: include error reporter - // else { - // errorReporter.reportError( - // watchdog, - // "In generateWatchdog(): " + name + " not a valid mode of this reactor." - // ); - // } } } } @@ -265,10 +270,12 @@ private static String generateFunction(String header, String init, Watchdog watc /** Generate the watchdog handler function. */ - private static String generateWatchdogFunction(Watchdog watchdog, ReactorDecl decl) { + private static String generateWatchdogFunction( + Watchdog watchdog, ReactorDecl decl, ErrorReporter errorReporter + ) { return generateFunction( generateWatchdogFunctionHeader(watchdog, decl), - generateInitializationForWatchdog(watchdog, decl), + generateInitializationForWatchdog(watchdog, decl, errorReporter), watchdog); } From 31d4b4dd2b3f86b8f51971b5a742d942a2134556 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 18 May 2023 16:53:48 -0700 Subject: [PATCH 311/709] Align to reactor-c main --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index c2c6a54fa0..843e147128 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit c2c6a54fa023c638122a73a7c7f311cf381cea1e +Subproject commit 843e147128315ffa5216fffd6cba36396c3cd084 From f0174827cc2cf92f322487b096f07a497ff23b5a Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Fri, 19 May 2023 09:33:30 +0200 Subject: [PATCH 312/709] Add threading check to validation of property --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index a5dc78c2b0..371581331b 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1935,16 +1935,16 @@ protected void setUpGeneralParameters() { targetConfig.noCompile = true; } - if (targetConfig.platformOptions.platform == Platform.ZEPHYR && targetConfig.platformOptions.userThreads >= 0) { + if (targetConfig.platformOptions.platform == Platform.ZEPHYR && targetConfig.threading + && targetConfig.platformOptions.userThreads >= 0) { targetConfig.compileDefinitions.put( PlatformOption.USER_THREADS.name(), String.valueOf(targetConfig.platformOptions.userThreads) ); + } else if (targetConfig.platformOptions.userThreads > 0) { + errorReporter.reportWarning("Specifying user threads is only for threaded Lingua Franca on the Zephyr platform. This option will be ignored."); } - if (targetConfig.platformOptions.platform != Platform.ZEPHYR && targetConfig.platformOptions.userThreads > 0) { - errorReporter.reportWarning("Specifying user threads is only for the Zephyr platform. This option will be ignored."); } - if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake pickScheduler(); // FIXME: this and pickScheduler should be combined. From 69258c4aada5669e1205d74a22bbc339c3b1c7fc Mon Sep 17 00:00:00 2001 From: Silje Susort Date: Fri, 19 May 2023 09:35:28 +0200 Subject: [PATCH 313/709] Add threaded Zephyr test functionality --- .../src/org/lflang/tests/Configurators.java | 11 ++++++++++- .../src/org/lflang/tests/runtime/CZephyrTest.java | 2 +- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/Configurators.java b/org.lflang.tests/src/org/lflang/tests/Configurators.java index e3fe6c5508..eaf7001f8c 100644 --- a/org.lflang.tests/src/org/lflang/tests/Configurators.java +++ b/org.lflang.tests/src/org/lflang/tests/Configurators.java @@ -65,7 +65,7 @@ public static boolean disableThreading(LFTest test) { return true; } - public static boolean makeZephyrCompatible(LFTest test) { + public static boolean makeZephyrCompatibleUnthreaded(LFTest test) { test.getContext().getArgs().setProperty("tracing", "false"); test.getContext().getTargetConfig().threading = false; test.getContext().getTargetConfig().setByUser.add(TargetProperty.THREADING); @@ -74,6 +74,15 @@ public static boolean makeZephyrCompatible(LFTest test) { test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; return true; } + + public static boolean makeZephyrCompatible(LFTest test) { + test.getContext().getArgs().setProperty("tracing", "false"); + test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; + test.getContext().getTargetConfig().platformOptions.flash = false; + test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; + return true; + } + /** * Make no changes to the configuration. * diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java index afe1646829..c1e2e5e3f5 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java @@ -62,7 +62,7 @@ public void buildGenericTests() { super.runTestsFor(List.of(Target.C), Message.DESC_GENERIC, TestCategory.GENERIC::equals, - Configurators::makeZephyrCompatible, + Configurators::makeZephyrCompatibleUnthreaded, TestLevel.BUILD, false); } From c8d7bb52cdabcc780ca4430701f2656945f92d2e Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Fri, 19 May 2023 16:56:20 +0900 Subject: [PATCH 314/709] Exit with 1 if the RTI is not installed --- .../org/lflang/federated/launcher/FedLauncherGenerator.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java index 3ad08e2450..d5873c1e05 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java +++ b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java @@ -342,7 +342,7 @@ private String getLaunchCode(String rtiLaunchCode) { "then", " echo \"RTI could not be found.\"", " echo \"The source code can be obtained from https://github.com/lf-lang/reactor-c/tree/main/core/federated/RTI\"", - " exit", + " exit 1", "fi ", "# The RTI is started first to allow proper boot-up", "# before federates will try to connect.", @@ -375,7 +375,7 @@ private String getRemoteLaunchCode(Object host, Object target, String logFileNam " then", " echo \"RTI could not be found.\"", " echo \"The source code can be found in org.lflang/src/lib/core/federated/RTI\"", - " exit", + " exit 1", " fi", " " + rtiLaunchString + " 2>&1 | tee -a " + logFileName + "' &", "# Store the PID of the channel to RTI", From ba3a8bc492b63ed1507366bc525247ade2223bdf Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Fri, 19 May 2023 17:05:19 +0900 Subject: [PATCH 315/709] Move failed tests to the failing folder --- test/TypeScript/src/federated/{ => failing}/ChainWithDelay.lf | 0 test/TypeScript/src/federated/{ => failing}/DistributedCount.lf | 0 .../src/federated/{ => failing}/DistributedCountPhysical.lf | 0 .../federated/{ => failing}/DistributedCountPhysicalAfterDelay.lf | 0 .../src/federated/{ => failing}/DistributedDoublePort.lf | 0 .../src/federated/{ => failing}/DistributedLoopedAction.lf | 0 .../federated/{ => failing}/DistributedLoopedPhysicalAction.lf | 0 test/TypeScript/src/federated/{ => failing}/DistributedStop.lf | 0 .../TypeScript/src/federated/{ => failing}/DistributedStopZero.lf | 0 test/TypeScript/src/federated/{ => failing}/HelloDistributed.lf | 0 .../src/federated/{ => failing}/LoopDistributedCentralized.lf | 0 .../src/federated/{ => failing}/LoopDistributedDouble.lf | 0 .../TypeScript/src/federated/{ => failing}/PingPongDistributed.lf | 0 .../src/federated/{ => failing}/PingPongDistributedPhysical.lf | 0 test/TypeScript/src/federated/{ => failing}/SimpleFederated.lf | 0 test/TypeScript/src/federated/{ => failing}/StopAtShutdown.lf | 0 test/TypeScript/src/federated/{ => failing}/TopLevelArtifacts.lf | 0 17 files changed, 0 insertions(+), 0 deletions(-) rename test/TypeScript/src/federated/{ => failing}/ChainWithDelay.lf (100%) rename test/TypeScript/src/federated/{ => failing}/DistributedCount.lf (100%) rename test/TypeScript/src/federated/{ => failing}/DistributedCountPhysical.lf (100%) rename test/TypeScript/src/federated/{ => failing}/DistributedCountPhysicalAfterDelay.lf (100%) rename test/TypeScript/src/federated/{ => failing}/DistributedDoublePort.lf (100%) rename test/TypeScript/src/federated/{ => failing}/DistributedLoopedAction.lf (100%) rename test/TypeScript/src/federated/{ => failing}/DistributedLoopedPhysicalAction.lf (100%) rename test/TypeScript/src/federated/{ => failing}/DistributedStop.lf (100%) rename test/TypeScript/src/federated/{ => failing}/DistributedStopZero.lf (100%) rename test/TypeScript/src/federated/{ => failing}/HelloDistributed.lf (100%) rename test/TypeScript/src/federated/{ => failing}/LoopDistributedCentralized.lf (100%) rename test/TypeScript/src/federated/{ => failing}/LoopDistributedDouble.lf (100%) rename test/TypeScript/src/federated/{ => failing}/PingPongDistributed.lf (100%) rename test/TypeScript/src/federated/{ => failing}/PingPongDistributedPhysical.lf (100%) rename test/TypeScript/src/federated/{ => failing}/SimpleFederated.lf (100%) rename test/TypeScript/src/federated/{ => failing}/StopAtShutdown.lf (100%) rename test/TypeScript/src/federated/{ => failing}/TopLevelArtifacts.lf (100%) diff --git a/test/TypeScript/src/federated/ChainWithDelay.lf b/test/TypeScript/src/federated/failing/ChainWithDelay.lf similarity index 100% rename from test/TypeScript/src/federated/ChainWithDelay.lf rename to test/TypeScript/src/federated/failing/ChainWithDelay.lf diff --git a/test/TypeScript/src/federated/DistributedCount.lf b/test/TypeScript/src/federated/failing/DistributedCount.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedCount.lf rename to test/TypeScript/src/federated/failing/DistributedCount.lf diff --git a/test/TypeScript/src/federated/DistributedCountPhysical.lf b/test/TypeScript/src/federated/failing/DistributedCountPhysical.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedCountPhysical.lf rename to test/TypeScript/src/federated/failing/DistributedCountPhysical.lf diff --git a/test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/TypeScript/src/federated/failing/DistributedCountPhysicalAfterDelay.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf rename to test/TypeScript/src/federated/failing/DistributedCountPhysicalAfterDelay.lf diff --git a/test/TypeScript/src/federated/DistributedDoublePort.lf b/test/TypeScript/src/federated/failing/DistributedDoublePort.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedDoublePort.lf rename to test/TypeScript/src/federated/failing/DistributedDoublePort.lf diff --git a/test/TypeScript/src/federated/DistributedLoopedAction.lf b/test/TypeScript/src/federated/failing/DistributedLoopedAction.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedLoopedAction.lf rename to test/TypeScript/src/federated/failing/DistributedLoopedAction.lf diff --git a/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf b/test/TypeScript/src/federated/failing/DistributedLoopedPhysicalAction.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf rename to test/TypeScript/src/federated/failing/DistributedLoopedPhysicalAction.lf diff --git a/test/TypeScript/src/federated/DistributedStop.lf b/test/TypeScript/src/federated/failing/DistributedStop.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedStop.lf rename to test/TypeScript/src/federated/failing/DistributedStop.lf diff --git a/test/TypeScript/src/federated/DistributedStopZero.lf b/test/TypeScript/src/federated/failing/DistributedStopZero.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedStopZero.lf rename to test/TypeScript/src/federated/failing/DistributedStopZero.lf diff --git a/test/TypeScript/src/federated/HelloDistributed.lf b/test/TypeScript/src/federated/failing/HelloDistributed.lf similarity index 100% rename from test/TypeScript/src/federated/HelloDistributed.lf rename to test/TypeScript/src/federated/failing/HelloDistributed.lf diff --git a/test/TypeScript/src/federated/LoopDistributedCentralized.lf b/test/TypeScript/src/federated/failing/LoopDistributedCentralized.lf similarity index 100% rename from test/TypeScript/src/federated/LoopDistributedCentralized.lf rename to test/TypeScript/src/federated/failing/LoopDistributedCentralized.lf diff --git a/test/TypeScript/src/federated/LoopDistributedDouble.lf b/test/TypeScript/src/federated/failing/LoopDistributedDouble.lf similarity index 100% rename from test/TypeScript/src/federated/LoopDistributedDouble.lf rename to test/TypeScript/src/federated/failing/LoopDistributedDouble.lf diff --git a/test/TypeScript/src/federated/PingPongDistributed.lf b/test/TypeScript/src/federated/failing/PingPongDistributed.lf similarity index 100% rename from test/TypeScript/src/federated/PingPongDistributed.lf rename to test/TypeScript/src/federated/failing/PingPongDistributed.lf diff --git a/test/TypeScript/src/federated/PingPongDistributedPhysical.lf b/test/TypeScript/src/federated/failing/PingPongDistributedPhysical.lf similarity index 100% rename from test/TypeScript/src/federated/PingPongDistributedPhysical.lf rename to test/TypeScript/src/federated/failing/PingPongDistributedPhysical.lf diff --git a/test/TypeScript/src/federated/SimpleFederated.lf b/test/TypeScript/src/federated/failing/SimpleFederated.lf similarity index 100% rename from test/TypeScript/src/federated/SimpleFederated.lf rename to test/TypeScript/src/federated/failing/SimpleFederated.lf diff --git a/test/TypeScript/src/federated/StopAtShutdown.lf b/test/TypeScript/src/federated/failing/StopAtShutdown.lf similarity index 100% rename from test/TypeScript/src/federated/StopAtShutdown.lf rename to test/TypeScript/src/federated/failing/StopAtShutdown.lf diff --git a/test/TypeScript/src/federated/TopLevelArtifacts.lf b/test/TypeScript/src/federated/failing/TopLevelArtifacts.lf similarity index 100% rename from test/TypeScript/src/federated/TopLevelArtifacts.lf rename to test/TypeScript/src/federated/failing/TopLevelArtifacts.lf From 67def09df97d649ee1ca7c77f4657678bf6030d1 Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Fri, 19 May 2023 17:54:06 +0900 Subject: [PATCH 316/709] Make the CI installs the RTI while tests reactor-ts --- .github/workflows/ts-tests.yml | 3 +++ test/TypeScript/src/federated/{failing => }/ChainWithDelay.lf | 0 .../TypeScript/src/federated/{failing => }/DistributedCount.lf | 0 .../src/federated/{failing => }/DistributedCountPhysical.lf | 0 .../{failing => }/DistributedCountPhysicalAfterDelay.lf | 0 .../src/federated/{failing => }/DistributedDoublePort.lf | 0 .../src/federated/{failing => }/DistributedLoopedAction.lf | 0 .../federated/{failing => }/DistributedLoopedPhysicalAction.lf | 0 test/TypeScript/src/federated/{failing => }/DistributedStop.lf | 0 .../src/federated/{failing => }/DistributedStopZero.lf | 0 .../TypeScript/src/federated/{failing => }/HelloDistributed.lf | 0 .../src/federated/{failing => }/LoopDistributedCentralized.lf | 0 .../src/federated/{failing => }/LoopDistributedDouble.lf | 0 .../src/federated/{failing => }/PingPongDistributed.lf | 0 .../src/federated/{failing => }/PingPongDistributedPhysical.lf | 0 test/TypeScript/src/federated/{failing => }/SimpleFederated.lf | 0 test/TypeScript/src/federated/{failing => }/StopAtShutdown.lf | 0 .../src/federated/{failing => }/TopLevelArtifacts.lf | 0 18 files changed, 3 insertions(+) rename test/TypeScript/src/federated/{failing => }/ChainWithDelay.lf (100%) rename test/TypeScript/src/federated/{failing => }/DistributedCount.lf (100%) rename test/TypeScript/src/federated/{failing => }/DistributedCountPhysical.lf (100%) rename test/TypeScript/src/federated/{failing => }/DistributedCountPhysicalAfterDelay.lf (100%) rename test/TypeScript/src/federated/{failing => }/DistributedDoublePort.lf (100%) rename test/TypeScript/src/federated/{failing => }/DistributedLoopedAction.lf (100%) rename test/TypeScript/src/federated/{failing => }/DistributedLoopedPhysicalAction.lf (100%) rename test/TypeScript/src/federated/{failing => }/DistributedStop.lf (100%) rename test/TypeScript/src/federated/{failing => }/DistributedStopZero.lf (100%) rename test/TypeScript/src/federated/{failing => }/HelloDistributed.lf (100%) rename test/TypeScript/src/federated/{failing => }/LoopDistributedCentralized.lf (100%) rename test/TypeScript/src/federated/{failing => }/LoopDistributedDouble.lf (100%) rename test/TypeScript/src/federated/{failing => }/PingPongDistributed.lf (100%) rename test/TypeScript/src/federated/{failing => }/PingPongDistributedPhysical.lf (100%) rename test/TypeScript/src/federated/{failing => }/SimpleFederated.lf (100%) rename test/TypeScript/src/federated/{failing => }/StopAtShutdown.lf (100%) rename test/TypeScript/src/federated/{failing => }/TopLevelArtifacts.lf (100%) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 83c04d8cf7..7a49192c14 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -26,6 +26,9 @@ jobs: run: | brew install coreutils if: ${{ runner.os == 'macOS' }} + - name: Install RTI + uses: ./.github/actions/install-rti + if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform TypeScript tests run: | ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#master" diff --git a/test/TypeScript/src/federated/failing/ChainWithDelay.lf b/test/TypeScript/src/federated/ChainWithDelay.lf similarity index 100% rename from test/TypeScript/src/federated/failing/ChainWithDelay.lf rename to test/TypeScript/src/federated/ChainWithDelay.lf diff --git a/test/TypeScript/src/federated/failing/DistributedCount.lf b/test/TypeScript/src/federated/DistributedCount.lf similarity index 100% rename from test/TypeScript/src/federated/failing/DistributedCount.lf rename to test/TypeScript/src/federated/DistributedCount.lf diff --git a/test/TypeScript/src/federated/failing/DistributedCountPhysical.lf b/test/TypeScript/src/federated/DistributedCountPhysical.lf similarity index 100% rename from test/TypeScript/src/federated/failing/DistributedCountPhysical.lf rename to test/TypeScript/src/federated/DistributedCountPhysical.lf diff --git a/test/TypeScript/src/federated/failing/DistributedCountPhysicalAfterDelay.lf b/test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf similarity index 100% rename from test/TypeScript/src/federated/failing/DistributedCountPhysicalAfterDelay.lf rename to test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf diff --git a/test/TypeScript/src/federated/failing/DistributedDoublePort.lf b/test/TypeScript/src/federated/DistributedDoublePort.lf similarity index 100% rename from test/TypeScript/src/federated/failing/DistributedDoublePort.lf rename to test/TypeScript/src/federated/DistributedDoublePort.lf diff --git a/test/TypeScript/src/federated/failing/DistributedLoopedAction.lf b/test/TypeScript/src/federated/DistributedLoopedAction.lf similarity index 100% rename from test/TypeScript/src/federated/failing/DistributedLoopedAction.lf rename to test/TypeScript/src/federated/DistributedLoopedAction.lf diff --git a/test/TypeScript/src/federated/failing/DistributedLoopedPhysicalAction.lf b/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf similarity index 100% rename from test/TypeScript/src/federated/failing/DistributedLoopedPhysicalAction.lf rename to test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf diff --git a/test/TypeScript/src/federated/failing/DistributedStop.lf b/test/TypeScript/src/federated/DistributedStop.lf similarity index 100% rename from test/TypeScript/src/federated/failing/DistributedStop.lf rename to test/TypeScript/src/federated/DistributedStop.lf diff --git a/test/TypeScript/src/federated/failing/DistributedStopZero.lf b/test/TypeScript/src/federated/DistributedStopZero.lf similarity index 100% rename from test/TypeScript/src/federated/failing/DistributedStopZero.lf rename to test/TypeScript/src/federated/DistributedStopZero.lf diff --git a/test/TypeScript/src/federated/failing/HelloDistributed.lf b/test/TypeScript/src/federated/HelloDistributed.lf similarity index 100% rename from test/TypeScript/src/federated/failing/HelloDistributed.lf rename to test/TypeScript/src/federated/HelloDistributed.lf diff --git a/test/TypeScript/src/federated/failing/LoopDistributedCentralized.lf b/test/TypeScript/src/federated/LoopDistributedCentralized.lf similarity index 100% rename from test/TypeScript/src/federated/failing/LoopDistributedCentralized.lf rename to test/TypeScript/src/federated/LoopDistributedCentralized.lf diff --git a/test/TypeScript/src/federated/failing/LoopDistributedDouble.lf b/test/TypeScript/src/federated/LoopDistributedDouble.lf similarity index 100% rename from test/TypeScript/src/federated/failing/LoopDistributedDouble.lf rename to test/TypeScript/src/federated/LoopDistributedDouble.lf diff --git a/test/TypeScript/src/federated/failing/PingPongDistributed.lf b/test/TypeScript/src/federated/PingPongDistributed.lf similarity index 100% rename from test/TypeScript/src/federated/failing/PingPongDistributed.lf rename to test/TypeScript/src/federated/PingPongDistributed.lf diff --git a/test/TypeScript/src/federated/failing/PingPongDistributedPhysical.lf b/test/TypeScript/src/federated/PingPongDistributedPhysical.lf similarity index 100% rename from test/TypeScript/src/federated/failing/PingPongDistributedPhysical.lf rename to test/TypeScript/src/federated/PingPongDistributedPhysical.lf diff --git a/test/TypeScript/src/federated/failing/SimpleFederated.lf b/test/TypeScript/src/federated/SimpleFederated.lf similarity index 100% rename from test/TypeScript/src/federated/failing/SimpleFederated.lf rename to test/TypeScript/src/federated/SimpleFederated.lf diff --git a/test/TypeScript/src/federated/failing/StopAtShutdown.lf b/test/TypeScript/src/federated/StopAtShutdown.lf similarity index 100% rename from test/TypeScript/src/federated/failing/StopAtShutdown.lf rename to test/TypeScript/src/federated/StopAtShutdown.lf diff --git a/test/TypeScript/src/federated/failing/TopLevelArtifacts.lf b/test/TypeScript/src/federated/TopLevelArtifacts.lf similarity index 100% rename from test/TypeScript/src/federated/failing/TopLevelArtifacts.lf rename to test/TypeScript/src/federated/TopLevelArtifacts.lf From c461cd70c531d7510769187651d9cb51af43c424 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 17 May 2023 22:03:54 -0700 Subject: [PATCH 317/709] Delete unnecessary complexity from build-lf-cli. --- lib/scripts/build.sh | 16 +--------------- 1 file changed, 1 insertion(+), 15 deletions(-) diff --git a/lib/scripts/build.sh b/lib/scripts/build.sh index d342aa45cd..52cc403851 100755 --- a/lib/scripts/build.sh +++ b/lib/scripts/build.sh @@ -114,18 +114,4 @@ if [ "${OSTYPE}" = "msys" ]; then fi jar_path="$(get_jar_path)" - -if [ ! -f "${jar_path}" ] || ! "${find_cmd}" "${base}" \ - -path "${src_pkg_path}" \ - -prune -o \ - -type f \ - -newer "${jar_path}" \ - -exec false {} +; then - # Rebuild. - 1>&2 echo "Jar file is missing or out-of-date; starting rebuild..." - "${base}/gradlew" ${flags} -p "${base}" buildAll - # Update the timestamp in case the jar was not touched by Gradle. - touch -c -- "${jar_path}" -else - echo "Already up-to-date." -fi +"${base}/gradlew" ${flags} -p "${base}" buildAll From 4fac0fe10d7383c2f988f51cda469ff9953439a8 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 12:53:40 -0700 Subject: [PATCH 318/709] More cleanups after merge. --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CGenerator.java | 2 +- .../generator/c/CReactorHeaderFileGenerator.java | 11 ++--------- 3 files changed, 4 insertions(+), 11 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 04193a7d9c..f1d41011e4 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 04193a7d9cf2e6b39aab652bef47ce583a84be2c +Subproject commit f1d41011e454a026741beb68bd9a3ec80101c8ee diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 80031c4cd9..be689cecd7 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1069,7 +1069,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String src.pr("}"); header.pr("}"); } - src.pr("#include \"include/" + headerName + "\""); + src.pr("#include \"" + headerName + "\""); tpr.typeArgs().forEach((literal, concreteType) -> src.pr( "#if defined " + literal + "\n" + "#undef " + literal + "\n" + diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index cf9f719967..33f652a8a4 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -94,8 +94,8 @@ private static void appendSignature(CodeBuilder builder, CTypes types, Reaction } private static String reactionParameters(CTypes types, Reaction r, TypeParameterizedReactor tpr) { - return Stream.concat(Stream.of(userFacingSelfType(tpr) + "* self"), inputVarRefStream(r) - .map(tv -> tpr.getName().toLowerCase() + "_" + tv.getVariable().getName() + "_t* " + tv.getVariable().getName())) + return Stream.concat(Stream.of(userFacingSelfType(tpr) + "* self"), portVariableStream(r, tpr) + .map(tv -> tpr.getName().toLowerCase() + "_" + tv.getName() + "_t* " + tv.getName())) .collect(Collectors.joining(", ")); } @@ -109,13 +109,6 @@ private static String getApiSelfStruct(TypeParameterizedReactor tpr) { return "(" + userFacingSelfType(tpr) + "*) (((char*) self) + sizeof(self_base_t))"; } - /** Return a string representation of the parameters of the reaction function of {@code r}. */ - private static String reactionParameters(Reaction r, TypeParameterizedReactor tpr) { - return Stream.concat(Stream.of(userFacingSelfType(tpr) + "* self"), portVariableStream(r, tpr) - .map(it -> it.getType(true) + " " + it.getName())) - .collect(Collectors.joining(", ")); - } - /** Generate initialization code that is needed if {@code r} is not inlined. */ public static String nonInlineInitialization(Reaction r, TypeParameterizedReactor reactor) { var mainDef = LfFactory.eINSTANCE.createInstantiation(); From 172b01fc6487954643ac12d17bee743de1195be0 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 13:02:04 -0700 Subject: [PATCH 319/709] Add back missing include. I'm not sure how this one disappeared from this branch, but it is in master already. --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index be689cecd7..a3bb69a702 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1069,6 +1069,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String src.pr("}"); header.pr("}"); } + src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(tpr) + "\""); src.pr("#include \"" + headerName + "\""); tpr.typeArgs().forEach((literal, concreteType) -> src.pr( "#if defined " + literal + "\n" + From c56adefae298898c39a80d95e8730d819f905b6f Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 13:58:05 -0700 Subject: [PATCH 320/709] Don't make ReactorInstance from insufficient data. --- org.lflang/src/org/lflang/ASTUtils.java | 9 --------- org.lflang/src/org/lflang/generator/c/CGenerator.java | 4 ++-- 2 files changed, 2 insertions(+), 11 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index c138aba4f5..d1fdb1b34d 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -419,15 +419,6 @@ public static HashSet allIncludes(Reactor r) { return set; } - public static List allChildInstances(Reactor definition, ErrorReporter reporter) { - return allInstantiations(definition).stream().map(it -> new ReactorInstance( - it, - null, - reporter, - 0 - )).collect(Collectors.toList()); - } - /* * Given a reactor class, return a stream of reactor classes that it instantiates. * @param definition Reactor class definition. diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index a3bb69a702..ffacf25e99 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -913,8 +913,8 @@ private void generateHeaders() throws IOException { (builder, rr, userFacing) -> { generateAuxiliaryStructs(builder, tpr, userFacing); if (userFacing) { - ASTUtils.allChildInstances(tpr.r(), errorReporter).stream() - .map(it -> new TypeParameterizedReactorWithDecl(it.tpr, it.reactorDeclaration)).collect(Collectors.toSet()).forEach(it -> { + tpr.r().getInstantiations().stream() + .map(it -> new TypeParameterizedReactorWithDecl(new TypeParameterizedReactor(it), it.getReactorClass())).collect(Collectors.toSet()).forEach(it -> { ASTUtils.allPorts(it.tpr.r()) .forEach(p -> builder.pr(CPortGenerator.generateAuxiliaryStruct( it.tpr, p, getTarget(), errorReporter, types, new CodeBuilder(), true, it.decl() From ec41b353f75e20e32025ccca7075dd2093c2d3e9 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 13:58:56 -0700 Subject: [PATCH 321/709] Self struct members are named after instance vars. Not after reactor classes. --- .../org/lflang/generator/c/CGenerator.java | 10 +++---- .../generator/c/CReactionGenerator.java | 26 +++++++++---------- .../src/org/lflang/generator/c/CUtil.java | 2 +- 3 files changed, 18 insertions(+), 20 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index ffacf25e99..c1d227087f 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1282,7 +1282,7 @@ private void generateInteractingContainedReactors( constructorCode.pr(String.join("\n", "// Set the _width variable for all cases. This will be -2", "// if the reactor is not a bank of reactors.", - "self->_lf_"+containedReactorType.tpr.getName()+"_width = "+width+";" + "self->_lf_"+containedReactor.getName()+"_width = "+width+";" )); // Generate one struct for each contained reactor that interacts. @@ -1323,10 +1323,10 @@ private void generateInteractingContainedReactors( var reactorIndex = ""; if (containedReactor.getWidthSpec() != null) { reactorIndex = "[reactor_index]"; - constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactorType.tpr.getName()+"_width; reactor_index++) {"); + constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactor.getName()+"_width; reactor_index++) {"); constructorCode.indent(); } - var portOnSelf = "self->_lf_"+containedReactorType.tpr.getName()+reactorIndex+"."+port.getName(); + var portOnSelf = "self->_lf_"+containedReactor.getName()+reactorIndex+"."+port.getName(); constructorCode.pr( port, @@ -1371,8 +1371,8 @@ private void generateInteractingContainedReactors( } body.unindent(); body.pr(String.join("\n", - "} _lf_"+containedReactorType.tpr.getName()+array+";", - "int _lf_"+containedReactorType.tpr.getName()+"_width;" + "} _lf_"+containedReactor.getName()+array+";", + "int _lf_"+containedReactor.getName()+"_width;" )); } } diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index a3da1f8462..2b7b08790b 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -208,7 +208,7 @@ public static String generateInitializationForReaction(String body, var containedReactorType = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(containedReactor.getReactorClass()), containedReactor.getName()); String array = ""; if (containedReactor.getWidthSpec() != null) { - String containedReactorWidthVar = generateWidthVariable(containedReactorType.tpr.getName()); + String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); code.pr("int "+containedReactorWidthVar+" = self->_lf_"+containedReactorWidthVar+";"); // Windows does not support variables in arrays declared on the stack, // so we use the maximum size over all bank members. @@ -356,7 +356,6 @@ private static void generateVariablesForSendingToContainedReactors( var reactorInstance = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(definition.getReactorClass()), definition.getName()); String inputStructType = CGenerator.variableStructType(input, reactorInstance.tpr, false); String defName = reactorInstance.getName(); - String subName = reactorInstance.tpr.getName(); String defWidth = generateWidthVariable(defName); String inputName = input.getName(); String inputWidth = generateWidthVariable(inputName); @@ -367,12 +366,12 @@ private static void generateVariablesForSendingToContainedReactors( // Contained reactor is a bank. builder.pr(String.join("\n", "for (int bankIndex = 0; bankIndex < self->_lf_"+defWidth+"; bankIndex++) {", - " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+subName+"[bankIndex]."+inputName+");", + " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+defName+"[bankIndex]."+inputName+");", "}" )); } else { // Contained reactor is not a bank. - builder.pr(defName+"."+inputName+" = &(self->_lf_"+subName+"."+inputName+");"); + builder.pr(defName+"."+inputName+" = &(self->_lf_"+defName+"."+inputName+");"); } } else { // Contained reactor's input is a multiport. @@ -385,14 +384,14 @@ private static void generateVariablesForSendingToContainedReactors( if (definition.getWidthSpec() != null) { builder.pr(String.join("\n", "for (int _i = 0; _i < self->_lf_"+defWidth+"; _i++) {", - " "+defName+"[_i]."+inputName+" = self->_lf_"+subName+"[_i]."+inputName+";", - " "+defName+"[_i]."+inputWidth+" = self->_lf_"+subName+"[_i]."+inputWidth+";", + " "+defName+"[_i]."+inputName+" = self->_lf_"+defName+"[_i]."+inputName+";", + " "+defName+"[_i]."+inputWidth+" = self->_lf_"+defName+"[_i]."+inputWidth+";", "}" )); } else { builder.pr(String.join("\n", - defName+"."+inputName+" = self->_lf_"+subName+"."+inputName+";", - defName+"."+inputWidth+" = self->_lf_"+subName+"."+inputWidth+";" + defName+"."+inputName+" = self->_lf_"+defName+"."+inputName+";", + defName+"."+inputWidth+" = self->_lf_"+defName+"."+inputWidth+";" )); } } @@ -429,9 +428,8 @@ private static void generatePortVariablesInReaction( structBuilder = new CodeBuilder(); structs.put(port.getContainer(), structBuilder); } - String reactorName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass()), port.getContainer().getName()).tpr.getName(); String subName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass()), port.getContainer().getName()).getName(); - String reactorWidth = generateWidthVariable(reactorName); + String reactorWidth = generateWidthVariable(subName); String outputName = output.getName(); String outputWidth = generateWidthVariable(outputName); // First define the struct containing the output value and indicator @@ -452,21 +450,21 @@ private static void generatePortVariablesInReaction( // Output is in a bank. builder.pr(String.join("\n", "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+subName+"[i]."+outputName+" = self->_lf_"+reactorName+"[i]."+outputName+";", + " "+subName+"[i]."+outputName+" = self->_lf_"+subName+"[i]."+outputName+";", "}" )); if (ASTUtils.isMultiport(output)) { builder.pr(String.join("\n", "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+subName+"[i]."+outputWidth+" = self->_lf_"+reactorName+"[i]."+outputWidth+";", + " "+subName+"[i]."+outputWidth+" = self->_lf_"+subName+"[i]."+outputWidth+";", "}" )); } } else { // Output is not in a bank. - builder.pr(subName+"."+outputName+" = self->_lf_"+reactorName+"."+outputName+";"); + builder.pr(subName+"."+outputName+" = self->_lf_"+subName+"."+outputName+";"); if (ASTUtils.isMultiport(output)) { - builder.pr(subName+"."+outputWidth+" = self->_lf_"+reactorName+"."+outputWidth+";"); + builder.pr(subName+"."+outputWidth+" = self->_lf_"+subName+"."+outputWidth+";"); } } } diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index bfa1a1b712..e06fcdfc3f 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -456,7 +456,7 @@ public static String reactorRefNested(ReactorInstance reactor) { * default, the string returned by {@link CUtil#bankIndex(ReactorInstance)}. */ public static String reactorRefNested(ReactorInstance reactor, String runtimeIndex, String bankIndex) { - String result = reactorRef(reactor.getParent(), runtimeIndex) + "->_lf_" + reactor.tpr.getName(); + String result = reactorRef(reactor.getParent(), runtimeIndex) + "->_lf_" + reactor.getName(); if (reactor.isBank()) { // Need the bank index not the runtimeIndex. if (bankIndex == null) bankIndex = bankIndex(reactor); From 8fa20b8e75ae4302427d92fdb21de970ff558a95 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 14:20:45 -0700 Subject: [PATCH 322/709] Update tests according to new test categories. --- .../src/org/lflang/tests/RuntimeTest.java | 23 ++++++++++---- .../src/org/lflang/tests/runtime/CTest.java | 30 +++++++++++-------- 2 files changed, 35 insertions(+), 18 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java b/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java index 1cbb799046..7011b5ed96 100644 --- a/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java +++ b/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java @@ -11,7 +11,7 @@ /** * A collection of JUnit tests to perform on a given set of targets. - * + * * @author Marten Lohstroh * */ @@ -135,12 +135,23 @@ public void runFederatedTests() { @Test public void runModalTests() { runTestsForTargets(Message.DESC_MODAL, - TestCategory.MODAL_MODELS::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); + TestCategory.MODAL_MODELS::equals, Configurators::noChanges, + TestLevel.EXECUTION, + false); } - /** + /** + * Run the tests for non-inlined reaction bodies. + */ + @Test + public void runNoInliningTests() { + runTestsForTargets(Message.DESC_MODAL, + TestCategory.NO_INLINING::equals, Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + /** * Run docker tests, provided that the platform is Linux and the target supports Docker. * Skip if platform is not Linux or target does not support Docker. */ @@ -154,7 +165,7 @@ public void runDockerTests() { false); } - /** + /** * Run federated docker tests, provided that the platform is Linux, the target supports Docker, * and the target supports federated execution. If any of these requirements are not met, skip * the tests. diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java index bc906b0d95..eba4f7bc71 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java @@ -11,29 +11,25 @@ this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +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. ***************/ package org.lflang.tests.runtime; -import java.util.List; - import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.lflang.Target; -import org.lflang.tests.Configurators; import org.lflang.tests.RuntimeTest; -import org.lflang.tests.TestRegistry.TestCategory; /** * Collection of tests for the C target. @@ -112,6 +108,16 @@ public void runFederatedTests() { super.runFederatedTests(); } + @Test + public void runModalTests() { + super.runModalTests(); + } + + @Test + public void runNoInliningTests() { + super.runNoInliningTests(); + } + @Test @Override public void runDockerTests() { From d9b56726b22265a7143986f9228154d4a4f3086c Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 14:21:25 -0700 Subject: [PATCH 323/709] Update py-tests.yml --- .github/workflows/py-tests.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index 3f6e521fd1..f21c5e69aa 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -29,6 +29,9 @@ jobs: fetch-depth: 0 - name: Prepare build environment uses: ./.github/actions/prepare-build-env + - name: Install RTI + uses: ./.github/actions/install-rti + if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Setup Python uses: actions/setup-python@v4 with: From 48542d3cf9094166657209c6118a2ed6e97083d9 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 14:21:55 -0700 Subject: [PATCH 324/709] Format test. --- test/C/src/generics/Template.lf | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/test/C/src/generics/Template.lf b/test/C/src/generics/Template.lf index 3d483098b9..5b735ce4f4 100644 --- a/test/C/src/generics/Template.lf +++ b/test/C/src/generics/Template.lf @@ -1,7 +1,8 @@ target C reactor Hello { - state count: T(0) + state count: T = 0 + reaction(startup) {= self->count = self->count + 1; printf("Hello World %d\n", (int) self->count); @@ -9,5 +10,5 @@ reactor Hello { } main reactor Template { - hello = new Hello(); + hello = new Hello() } From b68cf1943d7035c81789931448675e8906f42b55 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 14:24:10 -0700 Subject: [PATCH 325/709] Update serialization-tests.yml --- .github/workflows/serialization-tests.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 89f1ad735c..a2cd8f6fe0 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -20,6 +20,9 @@ jobs: fetch-depth: 0 - name: Prepare build environment uses: ./.github/actions/prepare-build-env + - name: Install RTI + uses: ./.github/actions/install-rti + if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Setup ROS2 uses: ./.github/actions/setup-ros2 - name: Install Protobuf Ubuntu From 9c3aa67823e1b2d369531a46cd08210d1ecb2abe Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 14:25:46 -0700 Subject: [PATCH 326/709] Merge in changes from reactor-c/main. This does not include the latest watchdog-related changes, which are not compatible with the current lingua-franca master. --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index f1d41011e4..a520d996a3 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit f1d41011e454a026741beb68bd9a3ec80101c8ee +Subproject commit a520d996a3c13c081b591aa67bf06afc39a7176d From e6c72685e3e719aee0dad09b88fa110863f99e6e Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 14:28:44 -0700 Subject: [PATCH 327/709] Update ts-tests.yml --- .github/workflows/ts-tests.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 7a49192c14..8e5576ced9 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -27,8 +27,8 @@ jobs: brew install coreutils if: ${{ runner.os == 'macOS' }} - name: Install RTI - uses: ./.github/actions/install-rti - if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} + uses: ./.github/actions/install-rti + if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform TypeScript tests run: | ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#master" From fadbf03f4919f0877eac7f098607969b63ae6263 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 19 May 2023 15:01:15 -0700 Subject: [PATCH 328/709] Added parent pointer to action structs --- org.lflang/src/lib/c/reactor-c | 2 +- .../src/org/lflang/generator/c/CActionGenerator.java | 9 +++++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 843e147128..10281fb32d 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 843e147128315ffa5216fffd6cba36396c3cd084 +Subproject commit 10281fb32d8636df0c6e571f3c27b1da9d45ade5 diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index af41440641..59f990ea47 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -104,7 +104,7 @@ public static void generateDeclarations( var actionName = action.getName(); body.pr(action, CGenerator.variableStructType(action, reactor, false)+" _lf_"+actionName+";"); // Initialize the trigger pointer in the action. - constructorCode.pr(action, "self->_lf_"+actionName+".trigger = &self->_lf__"+actionName+";"); + constructorCode.pr(action, "self->_lf_"+actionName+"._base.trigger = &self->_lf__"+actionName+";"); } } @@ -138,9 +138,10 @@ public static String generateAuxiliaryStruct( "token_type_t type;", // From token_template_t "lf_token_t* token;", // From token_template_t "size_t length;", // From token_template_t - "bool is_present;", // From lf_action_base_t - "bool has_value;", // From lf_action_base_t - "trigger_t* trigger;" // From lf_action_base_t + "bool is_present;", // From lf_port_or_action_t + "self_base_t* parent;",// From lf_port_or_action_t + "lf_action_internal_t _base;", // internal substruct + "bool has_value;" // From lf_action_base_t )); code.pr(valueDeclaration(action, target, types)); code.pr(federatedExtension.toString()); From 1dd92ebfb1d268c879f33a0c19c886e3337d4a94 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 15:13:42 -0700 Subject: [PATCH 329/709] Address failing no_inlining tests. --- .../c/CReactorHeaderFileGenerator.java | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 33f652a8a4..b98b5b959c 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -90,18 +90,12 @@ private static void appendSelfStruct(CodeBuilder builder, CTypes types, TypePara } private static void appendSignature(CodeBuilder builder, CTypes types, Reaction r, TypeParameterizedReactor tpr) { - if (r.getName() != null) builder.pr("void " + r.getName() + "(" + reactionParameters(types, r, tpr) + ");"); + if (r.getName() != null) builder.pr("void " + r.getName() + "(" + reactionParameters(r, tpr) + ");"); } - private static String reactionParameters(CTypes types, Reaction r, TypeParameterizedReactor tpr) { + private static String reactionParameters(Reaction r, TypeParameterizedReactor tpr) { return Stream.concat(Stream.of(userFacingSelfType(tpr) + "* self"), portVariableStream(r, tpr) - .map(tv -> tpr.getName().toLowerCase() + "_" + tv.getName() + "_t* " + tv.getName())) - .collect(Collectors.joining(", ")); - } - - public static String reactionArguments(CTypes types, Reaction r, TypeParameterizedReactor tpr) { - return Stream.concat(Stream.of(getApiSelfStruct(tpr)), inputVarRefStream(r) - .map(it -> String.format("((%s*) %s)", CGenerator.variableStructType(it.getVariable(), tpr, true), it.getVariable().getName()))) + .map(tv -> tv.getType(true) + tv.getName())) .collect(Collectors.joining(", ")); } @@ -146,12 +140,12 @@ public static String reactionArguments(Reaction r, TypeParameterizedReactor reac } /** Return a stream of all ports referenced by the signature of {@code r}. */ - private static Stream portVariableStream(Reaction r, TypeParameterizedReactor reactor) { + private static Stream portVariableStream(Reaction r, TypeParameterizedReactor reactorOfReaction) { return varRefStream(r) .map(it -> it.getVariable() instanceof TypedVariable tv ? new PortVariable( tv, - reactor, + it.getContainer() != null ? new TypeParameterizedReactor(it.getContainer()) : reactorOfReaction, it.getContainer()) : null) .filter(Objects::nonNull); @@ -160,7 +154,7 @@ private static Stream portVariableStream(Reaction r, TypeParameter /** * A variable that refers to a port. * @param tv The variable of the variable reference. - * @param r The reactor that contains the port. + * @param r The reactor in which the port is being used. * @param container The {@code Instantiation} referenced in the obtaining of {@code tv}, if * applicable; {@code null} otherwise. */ From 6bbee5cc1a0ec856280fd80b3891be4e35ebdbf4 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 15:16:35 -0700 Subject: [PATCH 330/709] Fix another mismatch between reactor and tpr. --- .../src/org/lflang/generator/c/CReactorHeaderFileGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index b98b5b959c..8fc60b78d7 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -121,7 +121,7 @@ public static String nonInlineInitialization(Reaction r, TypeParameterizedReacto it.getAlias(), CReactionGenerator.maxContainedReactorBankWidth( reactor.r().getInstantiations().stream() - .filter(instantiation -> ASTUtils.toDefinition(instantiation.getReactorClass()).equals(it.r)) + .filter(instantiation -> new TypeParameterizedReactor(instantiation).equals(it.r)) .findAny().orElseThrow(), null, 0, mainDef), "self->_lf_"+it.container.getName()+"_width", From 0e1285cab467980f8832bfab143d84c82de897ee Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 15:18:34 -0700 Subject: [PATCH 331/709] Update ci.yml --- .github/workflows/ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 48110ac926..457e231297 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -99,7 +99,7 @@ jobs: # Run the Python integration tests. py-tests: - uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@fix-ts-federated-tests needs: cancel # Run the Rust integration tests. @@ -116,10 +116,10 @@ jobs: # Run the TypeScript integration tests. ts-tests: - uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml@fix-ts-federated-tests needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@fix-ts-federated-tests needs: cancel From 8958cc55baed8f378f3b0ba9591f21f9b0b40005 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 19 May 2023 15:35:48 -0700 Subject: [PATCH 332/709] Added parent pointer for ports --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CPortGenerator.java | 7 +++---- .../org/lflang/generator/c/CTriggerObjectsGenerator.java | 4 ++-- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 10281fb32d..c5fd4b2741 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 10281fb32d8636df0c6e571f3c27b1da9d45ade5 +Subproject commit c5fd4b2741a3409d853658e82f1537190b2eeb37 diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index 1b22b41f9a..247bdc803e 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -77,10 +77,9 @@ public static String generateAuxiliaryStruct( "token_type_t type;", // From token_template_t "lf_token_t* token;", // From token_template_t "size_t length;", // From token_template_t - "bool is_present;", // From lf_port_base_t - "lf_sparse_io_record_t* sparse_record;", // From lf_port_base_t - "int destination_channel;", // From lf_port_base_t - "int num_destinations;" // From lf_port_base_t + "bool is_present;", // From lf_port_or_action_t + "self_base_t* parent;",// From lf_port_or_action_t + "lf_port_internal_t _base;" )); code.pr(valueDeclaration(port, target, errorReporter, types)); code.pr(federatedExtension.toString()); diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java index f653d3f997..d7be245cb1 100644 --- a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java @@ -664,7 +664,7 @@ private static String deferredInputNumDestinations( code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); // Syntax is slightly different for a multiport output vs. single port. var connector = (port.isMultiport())? "->" : "."; - code.pr(CUtil.portRefNested(port, sr, sb, sc)+connector+"num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); + code.pr(CUtil.portRefNested(port, sr, sb, sc)+connector+"_base.num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); // Initialize token types. var type = ASTUtils.getInferredType(port.getDefinition()); @@ -716,7 +716,7 @@ private static String deferredOutputNumDestinations( for (SendRange sendingRange : output.eventualDestinations()) { code.pr("// For reference counting, set num_destinations for port " + output.getFullName() + "."); code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); - code.pr(CUtil.portRef(output, sr, sb, sc)+".num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); + code.pr(CUtil.portRef(output, sr, sb, sc)+"._base.num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); code.endScopedRangeBlock(sendingRange); } } From d548f1987d765019c7504539c8af4ede2b89307e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 16:17:54 -0700 Subject: [PATCH 333/709] Update reactor-c to include watchdogs. --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index a520d996a3..abc273ec0e 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit a520d996a3c13c081b591aa67bf06afc39a7176d +Subproject commit abc273ec0ec0930252c55e2a106529d7cc4dc277 From 2a3095b1d3ca84381e4fe0418d253ecf4e1e5ffb Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 16:49:14 -0700 Subject: [PATCH 334/709] Fix error in serialization tests in master --- org.lflang/src/org/lflang/generator/ts/TSGenerator.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt index 6bd0813531..111a6d5b9a 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt @@ -334,7 +334,7 @@ class TSGenerator( // first build reactor-ts (pnpm does this automatically). if (devMode) { val rtPath = path.resolve("node_modules").resolve("@lf-lang").resolve("reactor-ts") - val buildRuntime = commandFactory.createCommand("npm", listOf("run", "prepublish"), rtPath) + val buildRuntime = commandFactory.createCommand("npm", listOf("run", "build"), rtPath) if (buildRuntime.run(context.cancelIndicator) != 0) { errorReporter.reportError( GeneratorUtils.findTargetDecl(resource), From 34c8bcb367cc9cea78be331322827e7fc840503d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 17:10:35 -0700 Subject: [PATCH 335/709] Fix ROS serialization. The problem was that the relevant #includes were behind an extern "C". --- .../src/org/lflang/federated/extensions/CExtension.java | 9 +++------ .../org/lflang/federated/extensions/CExtensionUtils.java | 3 +-- .../org/lflang/federated/extensions/PythonExtension.java | 2 +- 3 files changed, 5 insertions(+), 9 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index 8a69e979c6..a86d6fd1f0 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -32,7 +32,6 @@ import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; -import java.util.LinkedHashMap; import java.util.List; import org.lflang.ASTUtils; @@ -49,7 +48,6 @@ import org.lflang.federated.launcher.RtiConfig; import org.lflang.federated.serialization.FedROS2CPPSerialization; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.GeneratorUtils; import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; @@ -505,6 +503,7 @@ public String generatePreamble( includes.pr("#ifdef __cplusplus\n" + "}\n" + "#endif"); + includes.pr(generateSerializationIncludes(federate, fileConfig)); } return includes.toString(); @@ -537,8 +536,6 @@ protected String makePreamble( size_t _lf_action_table_size = %1$s; """.formatted(numOfNetworkActions)); - code.pr(generateSerializationPreamble(federate, fileConfig)); - code.pr(generateExecutablePreamble(federate, rtiConfig, errorReporter)); code.pr(generateInitializeTriggers(federate, errorReporter)); @@ -551,8 +548,8 @@ protected String makePreamble( /** * Generate preamble code needed for enabled serializers of the federate. */ - protected String generateSerializationPreamble(FederateInstance federate, FedFileConfig fileConfig) { - return CExtensionUtils.generateSerializationPreamble(federate, fileConfig); + protected String generateSerializationIncludes(FederateInstance federate, FedFileConfig fileConfig) { + return CExtensionUtils.generateSerializationIncludes(federate, fileConfig); } /** diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index 55a489ce51..7a03655923 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -20,7 +20,6 @@ import org.lflang.federated.serialization.FedROS2CPPSerialization; import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.GeneratorBase; import org.lflang.generator.ReactorInstance; import org.lflang.generator.c.CTypes; import org.lflang.generator.c.CUtil; @@ -547,7 +546,7 @@ public static String surroundWithIfFederatedDecentralized(String code) { /** * Generate preamble code needed for enabled serializers of the federate. */ - public static String generateSerializationPreamble( + public static String generateSerializationIncludes( FederateInstance federate, FedFileConfig fileConfig ) { diff --git a/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java b/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java index 73bed06f7b..c533a1f765 100644 --- a/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java @@ -57,7 +57,7 @@ public class PythonExtension extends CExtension { protected void generateCMakeInclude(FederateInstance federate, FedFileConfig fileConfig) throws IOException {} @Override - protected String generateSerializationPreamble(FederateInstance federate, FedFileConfig fileConfig) { + protected String generateSerializationIncludes(FederateInstance federate, FedFileConfig fileConfig) { CodeBuilder code = new CodeBuilder(); for (SupportedSerializers serialization : federate.enabledSerializers) { switch (serialization) { From 4281e7f16358b5ffef394652405c0439ec54c7ca Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 19 May 2023 17:19:28 -0700 Subject: [PATCH 336/709] Fixed trigger reference --- org.lflang/src/lib/c/reactor-c | 2 +- test/C/src/concurrent/ScheduleAt.lf | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index c5fd4b2741..78534983da 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit c5fd4b2741a3409d853658e82f1537190b2eeb37 +Subproject commit 78534983da36552822e8ba6f09af4923cd6d58cd diff --git a/test/C/src/concurrent/ScheduleAt.lf b/test/C/src/concurrent/ScheduleAt.lf index 2ef6af7af6..5c266cfc29 100644 --- a/test/C/src/concurrent/ScheduleAt.lf +++ b/test/C/src/concurrent/ScheduleAt.lf @@ -76,7 +76,7 @@ reactor Scheduler { reaction(startup) -> act {= for (int i=0; i < 16; i++) { - _lf_schedule_at_tag(act->trigger, + _lf_schedule_at_tag(act->_base.trigger, (tag_t) { .time = self->times[i] + lf_time_logical(), .microstep = self->microstep_delay_list[i]}, NULL); } From 54cbe37e5416c8e6ccbff63f11ce851884014835 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 19 May 2023 17:21:49 -0700 Subject: [PATCH 337/709] Aligned reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 78534983da..d9b9571a02 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 78534983da36552822e8ba6f09af4923cd6d58cd +Subproject commit d9b9571a0204550b316e365ed7e7dc83a6a71b72 From 1cb092fe5dd71d91a9f0288a27b83b697837663f Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 18:10:04 -0700 Subject: [PATCH 338/709] Update ts-tests.yml --- .github/workflows/ts-tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 83c04d8cf7..4342082868 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -28,7 +28,7 @@ jobs: if: ${{ runner.os == 'macOS' }} - name: Perform TypeScript tests run: | - ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#master" + ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#minor-reorg" - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: From 36e985e92f3df10822d98b99b0506ae53c325363 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 18:10:37 -0700 Subject: [PATCH 339/709] Update package.json --- org.lflang/src/lib/ts/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index fc063d791e..75c880bbc3 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -2,7 +2,7 @@ "name": "LinguaFrancaDefault", "type": "commonjs", "dependencies": { - "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#master", + "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#minor-reorg", "command-line-args": "^5.1.1", "command-line-usage": "^6.1.3" }, From af208478fb79587d9f0417108a037c45cb97426a Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Fri, 19 May 2023 18:24:34 -0700 Subject: [PATCH 340/709] Initialize the action's parent pointer --- org.lflang/src/org/lflang/generator/c/CActionGenerator.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index 59f990ea47..fd75df296b 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -105,6 +105,7 @@ public static void generateDeclarations( body.pr(action, CGenerator.variableStructType(action, reactor, false)+" _lf_"+actionName+";"); // Initialize the trigger pointer in the action. constructorCode.pr(action, "self->_lf_"+actionName+"._base.trigger = &self->_lf__"+actionName+";"); + constructorCode.pr(action, "self->_lf_"+actionName+".parent = (self_base_t*)self;"); } } From 96abdfeda847a3c21dc8b35ccc3a4e049678fdb1 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 18:31:17 -0700 Subject: [PATCH 341/709] Silence warning. The line I deleted here was doing nothing according to the compiler. --- org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt b/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt index 990ede56c6..a6bd81f548 100644 --- a/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt +++ b/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt @@ -47,7 +47,6 @@ class CppPortGenerator(private val reactor: Reactor) { val VarRef.dataType: String get() { val variableRef = when { - this == null -> "" container == null -> this.name container.isBank && container.isEnclave -> "${container.name}[0]->__lf_instance->${variable.name}" container.isBank && !container.isEnclave -> "${container.name}[0]->${variable.name}" From fed3e14b79a13a8c704612d0e546e378778ed306 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 18:31:44 -0700 Subject: [PATCH 342/709] Pass failing template test. There is only one test, so this is easy. I think that adding a more thorough test suite and getting it to pass should be left outside the scope of this PR since this PR has lingered too long already and already provides useful functionality. --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 6 +----- .../lflang/generator/c/CReactorHeaderFileGenerator.java | 1 + .../org/lflang/generator/c/TypeParameterizedReactor.java | 9 +++++++++ 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index aa34ddcdb5..cd89c36fd7 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1078,11 +1078,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String } src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(tpr) + "\""); src.pr("#include \"" + headerName + "\""); - tpr.typeArgs().forEach((literal, concreteType) -> src.pr( - "#if defined " + literal + "\n" + - "#undef " + literal + "\n" + - "#endif // " + literal + "\n" + - "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); + tpr.doDefines(src); ASTUtils.allIncludes(tpr.r()).stream().map(name -> "#include \"" + name + ".h\"").forEach(header::pr); } diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 8fc60b78d7..20d951b271 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -45,6 +45,7 @@ private static String generateHeaderFile(CTypes types, TypeParameterizedReactor appendIncludeGuard(builder, tpr); builder.pr(topLevelPreamble); appendPoundIncludes(builder); + tpr.doDefines(builder); appendSelfStruct(builder, types, tpr); generator.generate(builder, tpr, true); for (Reaction reaction : tpr.r().getReactions()) { diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 1a9ac13761..2b2e3e571c 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -6,6 +6,7 @@ import java.util.stream.Collectors; import org.lflang.ASTUtils; +import org.lflang.generator.CodeBuilder; import org.lflang.lf.Instantiation; import org.lflang.lf.Reactor; import org.lflang.lf.Type; @@ -32,6 +33,14 @@ public String getName() { return r.getName() + typeArgs.values().stream().map(ASTUtils::toOriginalText).collect(Collectors.joining("_")); } + public void doDefines(CodeBuilder b) { + typeArgs.forEach((literal, concreteType) -> b.pr( + "#if defined " + literal + "\n" + + "#undef " + literal + "\n" + + "#endif // " + literal + "\n" + + "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); + } + @Override public int hashCode() { return Math.abs(r.hashCode() * 31 + typeArgs.hashCode()); From a31f8f8485ef8618a5019895ce6d1bb074fa2edc Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 22:21:21 -0700 Subject: [PATCH 343/709] See if PR in reactor-c-py addresses test failure --- org.lflang/src/lib/py/reactor-c-py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/py/reactor-c-py b/org.lflang/src/lib/py/reactor-c-py index 80c24aa2e5..269c8184fb 160000 --- a/org.lflang/src/lib/py/reactor-c-py +++ b/org.lflang/src/lib/py/reactor-c-py @@ -1 +1 @@ -Subproject commit 80c24aa2e5bc814434893e9b6e4b183b4827c36a +Subproject commit 269c8184fbcae4700774fd04aaaa052c976f005b From 48f9c3932acfcadc9a58e73071f0802956d9fafc Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 19 May 2023 23:09:32 -0700 Subject: [PATCH 344/709] Update ts-tests.yml --- .github/workflows/ts-tests.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index fc43143177..888610917b 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -14,6 +14,7 @@ jobs: uses: actions/checkout@v3 with: fetch-depth: 0 + submodules: true - name: Prepare build environment uses: ./.github/actions/prepare-build-env - name: Setup Node.js environment From ce31b706946455670dadc4061e2554fdf85930ca Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 23:24:25 -0700 Subject: [PATCH 345/709] Do not use hashcodes as keys. There are a few reasons for this change * the key is everywhere being computed from an Instantiation, so this change reduces the total amount of code * hash codes can occasionally collide, and I was not sure that this particular hashcode was very effective at minimizing collision probability. * but more importantly, the hash codes were being computed from information that does not uniquely identify the Instantiation. It was being computed from the name of the variable that holds the instance and from the name of the reactor class being instantiated. So if the same reactor class were instantiated and stored in a variable of the same name in multiple places, this could result in bugs. This change means that we are using physical equality to check the keys to the hashmap because we don't have our own IR and we can't override the hashcode and equals functions of Instantiation. But I think that's OK. After AST transformations, which should happen as upstream as possible, we are working with one single object representation of the program. --- org.lflang/src/org/lflang/ASTUtils.java | 2 +- .../src/org/lflang/generator/ReactorInstance.java | 14 +++++--------- .../src/org/lflang/generator/c/CGenerator.java | 2 +- .../org/lflang/generator/c/CReactionGenerator.java | 11 +++++------ 4 files changed, 12 insertions(+), 17 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 9da1c4fdd3..3072c19148 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -411,7 +411,7 @@ public static HashSet allIncludes(Reactor r) { var set = new HashSet(); for (var i : allInstantiations(r)) { - set.add(CUtil.getName(ReactorInstance.getReactorInstance(ASTUtils.toDefinition(i.getReactorClass()), i.getName()).tpr)); + set.add(CUtil.getName(ReactorInstance.getReactorInstance(i).tpr)); } return set; } diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index d6c02eca64..dc5e8487b4 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -26,7 +26,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.generator; -import static org.lflang.ASTUtils.belongsTo; import static org.lflang.ASTUtils.getLiteralTimeValue; import java.util.ArrayList; @@ -170,7 +169,7 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re public TypeParameterizedReactor tpr; /** HashMap containing {@link ReactorInstance} against hashCode achievable from Reactor */ - private static final HashMap gReactorInstancesMap = new HashMap<>(); + private static final HashMap gReactorInstancesMap = new HashMap<>(); ////////////////////////////////////////////////////// //// Static methods. @@ -181,15 +180,12 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re * @param defName definition Name for the specified Reactor * */ public static void mapReactorInstance(Reactor reactor, ReactorInstance reactorInstance, final String defName) { - gReactorInstancesMap.put(computeHash(reactor, defName), reactorInstance); + gReactorInstancesMap.put(reactorInstance.definition, reactorInstance); } - /** Get {@link ReactorInstance} for supplied {@link Reactor} - * @param reactor The reactor - * @param defName definition Name for the specified reactor - * */ - public static ReactorInstance getReactorInstance(Reactor reactor, final String defName) { - return gReactorInstancesMap.get(computeHash(reactor, defName)); + /** Get {@link ReactorInstance} for supplied {@link Reactor} */ + public static ReactorInstance getReactorInstance(Instantiation i) { + return gReactorInstancesMap.get(i); } /** Clears out the cache of ReactorInstance for next LF processing */ diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index cd89c36fd7..d6c28fc08d 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1274,7 +1274,7 @@ private void generateInteractingContainedReactors( var contained = new InteractingContainedReactors(tpr.r()); // Next generate the relevant code. for (Instantiation containedReactor : contained.containedReactors()) { - var containedReactorType = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(containedReactor.getReactorClass()), containedReactor.getName()); + var containedReactorType = ReactorInstance.getReactorInstance(containedReactor); // First define an _width variable in case it is a bank. var array = ""; var width = -2; diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 760f1134d2..5a627055cc 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -207,7 +207,7 @@ public static String generateInitializationForReaction(String body, // Before the reaction initialization, // generate the structs used for communication to and from contained reactors. for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { - var containedReactorType = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(containedReactor.getReactorClass()), containedReactor.getName()); + var containedReactorType = ReactorInstance.getReactorInstance(containedReactor); String array = ""; if (containedReactor.getWidthSpec() != null) { String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); @@ -355,7 +355,7 @@ private static void generateVariablesForSendingToContainedReactors( structBuilder = new CodeBuilder(); structs.put(definition, structBuilder); } - var reactorInstance = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(definition.getReactorClass()), definition.getName()); + var reactorInstance = ReactorInstance.getReactorInstance(definition); String inputStructType = CGenerator.variableStructType(input, reactorInstance.tpr, false); String defName = reactorInstance.getName(); String defWidth = generateWidthVariable(defName); @@ -423,14 +423,14 @@ private static void generatePortVariablesInReaction( } else { // port is an output of a contained reactor. Output output = (Output) port.getVariable(); - String portStructType = CGenerator.variableStructType(output, ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass()), port.getContainer().getName()).getTypeParameterizedReactor(), false); + String portStructType = CGenerator.variableStructType(output, ReactorInstance.getReactorInstance(port.getContainer()).getTypeParameterizedReactor(), false); CodeBuilder structBuilder = structs.get(port.getContainer()); if (structBuilder == null) { structBuilder = new CodeBuilder(); structs.put(port.getContainer(), structBuilder); } - String subName = ReactorInstance.getReactorInstance(ASTUtils.toDefinition(port.getContainer().getReactorClass()), port.getContainer().getName()).getName(); + String subName = ReactorInstance.getReactorInstance(port.getContainer()).getName(); String reactorWidth = generateWidthVariable(subName); String outputName = output.getName(); String outputWidth = generateWidthVariable(outputName); @@ -645,8 +645,7 @@ public static String generateOutputVariablesInReaction( String outputStructType = (effect.getContainer() == null) ? CGenerator.variableStructType(output, tpr, false) : - CGenerator.variableStructType(output, ReactorInstance.getReactorInstance( - ASTUtils.toDefinition(effect.getContainer().getReactorClass()), effect.getContainer().getName()).getTypeParameterizedReactor(), false); + CGenerator.variableStructType(output, ReactorInstance.getReactorInstance(effect.getContainer()).getTypeParameterizedReactor(), false); if (!ASTUtils.isMultiport(output)) { // Output port is not a multiport. return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; From 4b5a7c5f9653a9f6ded7bd778c25945b311bd705 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 19 May 2023 23:53:46 -0700 Subject: [PATCH 346/709] Bugfix in CGenerator.java. The tests were all passing, but it looked wrong as-is. Maybe the tests were passing because we were not using the feature that lets the user use types in a reaction body that relate to contained reactors. --- org.lflang/src/org/lflang/ASTUtils.java | 2 +- .../src/org/lflang/generator/ReactorInstance.java | 1 - org.lflang/src/org/lflang/generator/c/CGenerator.java | 11 +++-------- 3 files changed, 4 insertions(+), 10 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index 3072c19148..e251557d1d 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -375,7 +375,7 @@ public static List allInputs(Reactor definition) { /** A list of all ports of {@code definition}, in an unspecified order. */ public static List allPorts(Reactor definition) { - return Stream.concat(ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()).collect(Collectors.toList()); + return Stream.concat(ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()).toList(); } /** diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index dc5e8487b4..432a1e7ee4 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -35,7 +35,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.LinkedList; import java.util.List; import java.util.Map; -import java.util.Objects; import java.util.Optional; import java.util.Set; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index d6c28fc08d..13af7e9dc7 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -37,9 +37,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.io.File; import java.io.IOException; import java.nio.file.Path; -import java.util.ArrayList; import java.util.HashMap; -import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; @@ -88,7 +86,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Mode; -import org.lflang.lf.Model; import org.lflang.lf.Port; import org.lflang.lf.Preamble; import org.lflang.lf.Reaction; @@ -100,8 +97,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; -import com.google.common.base.Objects; -import com.google.common.collect.ImmutableMap; import com.google.common.collect.Iterables; /** @@ -492,7 +487,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { var sources = allTypeParameterizedReactors() .map(CUtil::getName) .map(it -> it + (CCppMode ? ".cpp" : ".c")) - .collect(Collectors.toCollection(ArrayList::new)); + .toList(); sources.add(cFilename); var cmakeCode = cmakeGenerator.generateCMakeCode( sources, @@ -916,9 +911,9 @@ private void generateHeaders() throws IOException { CReactorHeaderFileGenerator.doGenerate( types, tpr, fileConfig, (builder, rr, userFacing) -> { - generateAuxiliaryStructs(builder, tpr, userFacing); + generateAuxiliaryStructs(builder, rr, userFacing); if (userFacing) { - tpr.r().getInstantiations().stream() + rr.r().getInstantiations().stream() .map(it -> new TypeParameterizedReactorWithDecl(new TypeParameterizedReactor(it), it.getReactorClass())).collect(Collectors.toSet()).forEach(it -> { ASTUtils.allPorts(it.tpr.r()) .forEach(p -> builder.pr(CPortGenerator.generateAuxiliaryStruct( From 0c0157b78e8bd4d47400d91d0d62184aae6f14fc Mon Sep 17 00:00:00 2001 From: Hokeun Kim Date: Sat, 20 May 2023 18:10:24 +0900 Subject: [PATCH 347/709] Minor fix to TS test PingPongDistributed.lf --- test/TypeScript/src/federated/PingPongDistributed.lf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/TypeScript/src/federated/PingPongDistributed.lf b/test/TypeScript/src/federated/PingPongDistributed.lf index 34a633aba4..1e121edba3 100644 --- a/test/TypeScript/src/federated/PingPongDistributed.lf +++ b/test/TypeScript/src/federated/PingPongDistributed.lf @@ -8,13 +8,13 @@ reactor Ping(count: number = 10) { logical action serve reaction(startup, serve) -> send {= - console.log(`At lo${util.getElapsedLogicalTime()}, Ping sending ${pingsLeft}`); + console.log(`At logical time ${util.getElapsedLogicalTime()}, Ping sending ${pingsLeft}`); send = pingsLeft; pingsLeft = pingsLeft - 1; =} reaction(receive) -> serve {= - if(pingsLeft > 0){ + if (pingsLeft > 0){ actions.serve.schedule(0, null); } else{ From 3b1ad06262bfbccb88a3088d1fa630b28a6af7d4 Mon Sep 17 00:00:00 2001 From: Hokeun Kim Date: Sat, 20 May 2023 18:19:10 +0900 Subject: [PATCH 348/709] Do not overwrite keepAlive of federateConfig with the app parameter (possibly coming from the TargetProperty). --- org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt index 0075950a1f..a1ec96c9ac 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt @@ -59,7 +59,6 @@ class TSConstructorGenerator( | } | federateConfig.federationID = __federationID; | federateConfig.fast = __fast; - | federateConfig.keepAlive = __keepAlive; | super(federateConfig, success, fail); """.trimMargin() } else { From 946ef5b4513a7c198ffd3cfeef586bc57cb19c83 Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Sat, 20 May 2023 18:41:51 +0900 Subject: [PATCH 349/709] Set the default keepAlive of federation to true --- org.lflang/src/org/lflang/federated/extensions/TSExtension.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java index 77d6203a93..8a9ef49e0d 100644 --- a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java @@ -102,7 +102,7 @@ public String generatePreamble(FederateInstance federate, FedFileConfig fileConf fast: false, federateID: %d, federationID: "Unidentified Federation", - keepAlive: false, + keepAlive: true, minOutputDelay: %s, networkMessageActions: [%s], rtiHost: "%s", From ddc654942e310b40275d87f83bae769d84543a09 Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Sat, 20 May 2023 22:18:42 +0900 Subject: [PATCH 350/709] Minor fix to TS TestCount.lf --- test/TypeScript/src/lib/TestCount.lf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/TypeScript/src/lib/TestCount.lf b/test/TypeScript/src/lib/TestCount.lf index 822b4c64b1..01cc5271bf 100644 --- a/test/TypeScript/src/lib/TestCount.lf +++ b/test/TypeScript/src/lib/TestCount.lf @@ -30,7 +30,7 @@ reactor TestCount( reaction(shutdown) {= console.log("Shutdown invoked."); if (inputsReceived != numInputs) { - console.log("ERROR: Expected to receive " + numInputs + " inputs, but got " + inputsReceived + "."); + util.requestErrorStop("ERROR: Expected to receive " + numInputs + " inputs, but got " + inputsReceived + "."); } =} } From 30689b64b3f27f5d609febec36c6537b006786fd Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 20 May 2023 08:43:32 -0700 Subject: [PATCH 351/709] Removed parent pointer from port because it is not the right parent --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CActionGenerator.java | 2 +- org.lflang/src/org/lflang/generator/c/CPortGenerator.java | 3 +-- 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index d9b9571a02..01f7957d02 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit d9b9571a0204550b316e365ed7e7dc83a6a71b72 +Subproject commit 01f7957d025306fb48a1d092f228467fd4acb722 diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index fd75df296b..5b85365c2b 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -140,8 +140,8 @@ public static String generateAuxiliaryStruct( "lf_token_t* token;", // From token_template_t "size_t length;", // From token_template_t "bool is_present;", // From lf_port_or_action_t - "self_base_t* parent;",// From lf_port_or_action_t "lf_action_internal_t _base;", // internal substruct + "self_base_t* parent;",// From lf_port_or_action_t "bool has_value;" // From lf_action_base_t )); code.pr(valueDeclaration(action, target, types)); diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index 247bdc803e..f7e3abc673 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -77,8 +77,7 @@ public static String generateAuxiliaryStruct( "token_type_t type;", // From token_template_t "lf_token_t* token;", // From token_template_t "size_t length;", // From token_template_t - "bool is_present;", // From lf_port_or_action_t - "self_base_t* parent;",// From lf_port_or_action_t + "bool is_present;", "lf_port_internal_t _base;" )); code.pr(valueDeclaration(port, target, errorReporter, types)); From e39792810ff7586157208dad237cd156e7cd61f0 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 20 May 2023 08:57:02 -0700 Subject: [PATCH 352/709] Marked src/federated/SimpleFederatedAuthenticated.lf as failing --- .../C/src/federated/{ => failing}/SimpleFederatedAuthenticated.lf | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/C/src/federated/{ => failing}/SimpleFederatedAuthenticated.lf (100%) diff --git a/test/C/src/federated/SimpleFederatedAuthenticated.lf b/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf similarity index 100% rename from test/C/src/federated/SimpleFederatedAuthenticated.lf rename to test/C/src/federated/failing/SimpleFederatedAuthenticated.lf From 6c59e70c9f86741c572014a4432f4b795d066766 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 20 May 2023 14:26:45 -0700 Subject: [PATCH 353/709] Aligned reactor-c-py --- org.lflang/src/lib/py/reactor-c-py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/py/reactor-c-py b/org.lflang/src/lib/py/reactor-c-py index 80c24aa2e5..a61f6474c8 160000 --- a/org.lflang/src/lib/py/reactor-c-py +++ b/org.lflang/src/lib/py/reactor-c-py @@ -1 +1 @@ -Subproject commit 80c24aa2e5bc814434893e9b6e4b183b4827c36a +Subproject commit a61f6474c845d5b5c0ac4f312093a474a8ff2a7d From dd6fd0c97d6bf6cc18598da8bc4fa8102622bfc2 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 20 May 2023 14:30:04 -0700 Subject: [PATCH 354/709] Fix bug introduced by previous commit. --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 13af7e9dc7..03b76b804b 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -37,6 +37,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.io.File; import java.io.IOException; import java.nio.file.Path; +import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; @@ -487,7 +488,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { var sources = allTypeParameterizedReactors() .map(CUtil::getName) .map(it -> it + (CCppMode ? ".cpp" : ".c")) - .toList(); + .collect(Collectors.toCollection(ArrayList::new)); sources.add(cFilename); var cmakeCode = cmakeGenerator.generateCMakeCode( sources, From cc0a86555824fe6e5439a249efa7e940189543c5 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 20 May 2023 17:47:43 -0700 Subject: [PATCH 355/709] Added generation of .vscode/settings.json file --- .../org/lflang/generator/c/CGenerator.java | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 32174be22c..adff5bc903 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -36,6 +36,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.io.File; import java.io.IOException; +import java.nio.file.Files; import java.nio.file.Path; import java.util.HashSet; import java.util.LinkedHashSet; @@ -538,7 +539,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { try { String compileDefs = targetConfig.compileDefinitions.keySet().stream() .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) - .collect(Collectors.joining("\n")); + .collect(Collectors.joining("\n")) + "\n"; FileUtil.writeToFile( compileDefs, Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt") @@ -547,6 +548,29 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { Exceptions.sneakyThrow(e); } + // Create a .vscode/settings.json file in the target directory so that VSCode can + // immediately compile the generated code. + try { + String compileDefs = targetConfig.compileDefinitions.keySet().stream() + .map(key -> "\"-D" + key + "=" + targetConfig.compileDefinitions.get(key) + "\"") + .collect(Collectors.joining(",\n")); + String settings = "{\n" + + "\"cmake.configureArgs\": [\n" + + compileDefs + + "\n]\n}\n"; + Path vscodePath = Path.of(fileConfig.getSrcGenPath() + File.separator + ".vscode"); + if (!Files.exists(vscodePath)) + Files.createDirectory(vscodePath); + FileUtil.writeToFile( + settings, + Path.of(fileConfig.getSrcGenPath() + + File.separator + ".vscode" + + File.separator + "settings.json") + ); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } + // If this code generator is directly compiling the code, compile it now so that we // clean it up after, removing the #line directives after errors have been reported. if ( From 6c3ce2517c29b333722983cb5a4da60dfd0c8740 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sat, 20 May 2023 18:41:57 -0700 Subject: [PATCH 356/709] C files for Python support retrieved from reactor-c repo (#1757) * Adjust paths * Update submodules --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/lib/py/reactor-c-py | 2 +- .../src/org/lflang/generator/python/PythonGenerator.java | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 843e147128..dc6b138746 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 843e147128315ffa5216fffd6cba36396c3cd084 +Subproject commit dc6b13874697315859cd75e26ddd82f9c0d83643 diff --git a/org.lflang/src/lib/py/reactor-c-py b/org.lflang/src/lib/py/reactor-c-py index 80c24aa2e5..d9fc25f24e 160000 --- a/org.lflang/src/lib/py/reactor-c-py +++ b/org.lflang/src/lib/py/reactor-c-py @@ -1 +1 @@ -Subproject commit 80c24aa2e5bc814434893e9b6e4b183b4827c36a +Subproject commit d9fc25f24eca93e581bcf9d5734d80e69243574d diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 2686c98539..0c0dfc5a38 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -660,13 +660,13 @@ private static String generatePythonFileName(String lfModuleName) { protected void copyTargetFiles() throws IOException { super.copyTargetFiles(); FileUtil.copyFromClassPath( - "/lib/py/reactor-c-py/include", + "/lib/c/reactor-c/python/include", fileConfig.getSrcGenPath(), true, false ); FileUtil.copyFromClassPath( - "/lib/py/reactor-c-py/lib", + "/lib/c/reactor-c/python/lib", fileConfig.getSrcGenPath(), true, false From e34cab762aeef29083b0c0300c46380c6e2ec595 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 20 May 2023 19:32:42 -0700 Subject: [PATCH 357/709] Update org.lflang/src/org/lflang/generator/c/CActionGenerator.java Co-authored-by: erling --- org.lflang/src/org/lflang/generator/c/CActionGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index 5b85365c2b..72647f5c0e 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -103,7 +103,7 @@ public static void generateDeclarations( for (Action action : ASTUtils.allActions(reactor)) { var actionName = action.getName(); body.pr(action, CGenerator.variableStructType(action, reactor, false)+" _lf_"+actionName+";"); - // Initialize the trigger pointer in the action. + // Initialize the trigger pointer and the parent pointer in the action. constructorCode.pr(action, "self->_lf_"+actionName+"._base.trigger = &self->_lf__"+actionName+";"); constructorCode.pr(action, "self->_lf_"+actionName+".parent = (self_base_t*)self;"); } From 87b0be59da6963dfe40b9ea120c102dde249f9f3 Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Sun, 21 May 2023 14:23:40 +0900 Subject: [PATCH 358/709] Update package.json --- org.lflang/src/lib/ts/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index 75c880bbc3..fc063d791e 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -2,7 +2,7 @@ "name": "LinguaFrancaDefault", "type": "commonjs", "dependencies": { - "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#minor-reorg", + "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#master", "command-line-args": "^5.1.1", "command-line-usage": "^6.1.3" }, From 3d51b1bc269e733ec8eeba0341305da3fb30d11a Mon Sep 17 00:00:00 2001 From: erling Date: Sat, 20 May 2023 23:07:46 -0700 Subject: [PATCH 359/709] Zephyr ci4 (#1758) * Update & upgrade before zephyr installation --- .github/actions/setup-zephyr/action.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 64d85ec0f2..7d835049dc 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -5,7 +5,8 @@ runs: steps: - name: Dependencies run: | - sudo apt install -y --no-install-recommends git cmake ninja-build gperf \ + sudo apt-get update && sudo apt-get upgrade + sudo apt-get install -y --no-install-recommends git cmake ninja-build gperf \ ccache dfu-util device-tree-compiler wget \ python3-dev python3-pip python3-setuptools python3-tk python3-wheel xz-utils file \ make gcc gcc-multilib g++-multilib libsdl2-dev libmagic1 From 959ab3cd79bbbf5fa4a7680e254cc320e093f8eb Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Sun, 21 May 2023 16:17:11 +0900 Subject: [PATCH 360/709] Point to the branch 'fix-federation' of reactor-ts --- .github/workflows/ts-tests.yml | 2 +- org.lflang/src/lib/ts/package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 888610917b..788a0695b7 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -32,7 +32,7 @@ jobs: if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform TypeScript tests run: | - ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#minor-reorg" + ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#fix-federation" - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index fc063d791e..cdb127813a 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -2,7 +2,7 @@ "name": "LinguaFrancaDefault", "type": "commonjs", "dependencies": { - "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#master", + "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#fix-federation", "command-line-args": "^5.1.1", "command-line-usage": "^6.1.3" }, From c44f91e234300b7a089145b8adf519d8d08d1ac6 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 21 May 2023 09:16:04 -0700 Subject: [PATCH 361/709] Fix line adjustment logic for federated programs. It is bad that I had to modify ToLf to do this since the logic isn't really in ToLf. The problem was that the line adjustment relies on tagging the target code (without the fat braces), and the target code is not recorded separately from the fat braces if they are entered into the MalleableString machinery as all one string. --- org.lflang/src/org/lflang/ast/ToLf.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index ce1cdca9fe..763ae8266c 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -219,7 +219,11 @@ public MalleableString caseCode(Code code) { .map(String::stripTrailing) .collect(Collectors.joining("\n")); MalleableString singleLineRepresentation = - MalleableString.anyOf(String.format("{= %s =}", content.strip())); + new Builder() + .append("{= ") + .append(content.strip()) + .append(" =}") + .get(); MalleableString multilineRepresentation = new Builder() .append(String.format("{=%n")) From e30dd0cbab503a50cdd1a8af233f1cc1baa5fb1e Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sun, 21 May 2023 15:30:38 -0700 Subject: [PATCH 362/709] Rename submodule to match repo name --- .gitmodules | 4 ++-- org.lflang/src/lib/py/{reactor-c-py => lf-python-support} | 0 .../src/org/lflang/generator/python/PythonGenerator.java | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) rename org.lflang/src/lib/py/{reactor-c-py => lf-python-support} (100%) diff --git a/.gitmodules b/.gitmodules index 3ccd9f3a7f..b2b2916982 100644 --- a/.gitmodules +++ b/.gitmodules @@ -2,8 +2,8 @@ path = org.lflang/src/lib/c/reactor-c url = https://github.com/lf-lang/reactor-c.git [submodule "org.lflang/src/lib/py/reactor-c-py"] - path = org.lflang/src/lib/py/reactor-c-py - url = https://github.com/lf-lang/reactor-c-py.git + path = org.lflang/src/lib/py/lf-python-support + url = https://github.com/lf-lang/lf-python-support.git [submodule "org.lflang/src/lib/cpp/reactor-cpp"] path = org.lflang/src/lib/cpp/reactor-cpp url = https://github.com/lf-lang/reactor-cpp diff --git a/org.lflang/src/lib/py/reactor-c-py b/org.lflang/src/lib/py/lf-python-support similarity index 100% rename from org.lflang/src/lib/py/reactor-c-py rename to org.lflang/src/lib/py/lf-python-support diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 0c0dfc5a38..3f8181d764 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -137,7 +137,7 @@ private PythonGenerator(LFGeneratorContext context, PythonTypes types, CCmakeGen * FEDERATED_GENERIC_EXTENSION * } generic_port_instance_struct; * - * See reactor-c-py/lib/pythontarget.h for details. + * See reactor-c/python/lib/pythontarget.h for details. */ String genericPortType = "generic_port_instance_struct"; @@ -153,7 +153,7 @@ private PythonGenerator(LFGeneratorContext context, PythonTypes types, CCmakeGen * FEDERATED_CAPSULE_EXTENSION * } generic_action_instance_struct; * - * See reactor-c-py/lib/pythontarget.h for details. + * See reactor-c/python/lib/pythontarget.h for details. */ String genericActionType = "generic_action_instance_struct"; @@ -672,7 +672,7 @@ protected void copyTargetFiles() throws IOException { false ); FileUtil.copyFromClassPath( - "/lib/py/reactor-c-py/LinguaFrancaBase", + "/lib/py/lf-python-support/LinguaFrancaBase", fileConfig.getSrcGenPath(), true, false From 4ec327ebbf930ad9ca5acbf963a688fbeb634e00 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sun, 21 May 2023 16:04:17 -0700 Subject: [PATCH 363/709] Fix submodule config --- .gitmodules | 3 +++ org.lflang/src/lib/lf-python-support | 1 + org.lflang/src/lib/py/reactor-c-py | 1 - 3 files changed, 4 insertions(+), 1 deletion(-) create mode 160000 org.lflang/src/lib/lf-python-support delete mode 160000 org.lflang/src/lib/py/reactor-c-py diff --git a/.gitmodules b/.gitmodules index c67b03b7fb..ee9c36f08f 100644 --- a/.gitmodules +++ b/.gitmodules @@ -7,3 +7,6 @@ [submodule "org.lflang/src/lib/rs/reactor-rs"] path = org.lflang/src/lib/rs/reactor-rs url = https://github.com/lf-lang/reactor-rs +[submodule "org.lflang/src/lib/lf-python-support"] + path = org.lflang/src/lib/lf-python-support + url = https://github.com/lf-lang/lf-python-support.git diff --git a/org.lflang/src/lib/lf-python-support b/org.lflang/src/lib/lf-python-support new file mode 160000 index 0000000000..f7be0cd729 --- /dev/null +++ b/org.lflang/src/lib/lf-python-support @@ -0,0 +1 @@ +Subproject commit f7be0cd729c840667a39c9b2087db4f7ec82ec3a diff --git a/org.lflang/src/lib/py/reactor-c-py b/org.lflang/src/lib/py/reactor-c-py deleted file mode 160000 index a61f6474c8..0000000000 --- a/org.lflang/src/lib/py/reactor-c-py +++ /dev/null @@ -1 +0,0 @@ -Subproject commit a61f6474c845d5b5c0ac4f312093a474a8ff2a7d From c75e818782170fc4bdbdf7eebc54f068a2252f44 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sun, 21 May 2023 16:07:57 -0700 Subject: [PATCH 364/709] Update .gitmodules --- .gitmodules | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitmodules b/.gitmodules index b2b2916982..3d26f4317d 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,7 +1,7 @@ [submodule "org.lflang/src/lib/c/reactor-c"] path = org.lflang/src/lib/c/reactor-c url = https://github.com/lf-lang/reactor-c.git -[submodule "org.lflang/src/lib/py/reactor-c-py"] +[submodule "org.lflang/src/lib/py/lf-python-support"] path = org.lflang/src/lib/py/lf-python-support url = https://github.com/lf-lang/lf-python-support.git [submodule "org.lflang/src/lib/cpp/reactor-cpp"] From 331a3151b1e7d9249453a8577b883def9e14a761 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 21 May 2023 17:23:50 -0700 Subject: [PATCH 365/709] Entirely delete the map from ReactorInstance. We do not need it. We can obtain a TPR from an Instantiation when all the concrete types are immediately available, and when they are not immediately available, we the map does not help us. --- org.lflang/src/org/lflang/ASTUtils.java | 2 +- org.lflang/src/org/lflang/cli/Lfc.java | 7 ++-- .../org/lflang/generator/ReactorInstance.java | 36 ------------------- .../org/lflang/generator/c/CGenerator.java | 10 +++--- .../generator/c/CReactionGenerator.java | 16 ++++----- 5 files changed, 16 insertions(+), 55 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index e251557d1d..b9cacd8f48 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -411,7 +411,7 @@ public static HashSet allIncludes(Reactor r) { var set = new HashSet(); for (var i : allInstantiations(r)) { - set.add(CUtil.getName(ReactorInstance.getReactorInstance(i).tpr)); + set.add(CUtil.getName(new TypeParameterizedReactor(i))); } return set; } diff --git a/org.lflang/src/org/lflang/cli/Lfc.java b/org.lflang/src/org/lflang/cli/Lfc.java index 38795137d5..74d9eac8da 100644 --- a/org.lflang/src/org/lflang/cli/Lfc.java +++ b/org.lflang/src/org/lflang/cli/Lfc.java @@ -107,7 +107,7 @@ public class Lfc extends CliBase { @Option( names = {"-q", "--quiet"}, arity = "0", - description = + description = "Suppress output of the target compiler and other commands") private boolean quiet; @@ -189,7 +189,7 @@ private void invokeGenerator( final Resource resource = getResource(path); if (resource == null) { - reporter.printFatalErrorAndExit(path + reporter.printFatalErrorAndExit(path + " is not an LF file. Use the .lf file extension to" + " denote LF files."); } else if (federated) { @@ -210,7 +210,6 @@ private void invokeGenerator( try { this.generator.generate(resource, this.fileAccess, context); - ReactorInstance.clearReactorInstanceMap(); } catch (Exception e) { reporter.printFatalErrorAndExit("Error running generator", e); } @@ -318,7 +317,7 @@ public Properties getGeneratorArgs() { if (workers != null) { props.setProperty(BuildParm.WORKERS.getKey(), workers.toString()); } - + return props; } } diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 432a1e7ee4..80629b81a0 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -167,39 +167,6 @@ public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter re public TypeParameterizedReactor tpr; - /** HashMap containing {@link ReactorInstance} against hashCode achievable from Reactor */ - private static final HashMap gReactorInstancesMap = new HashMap<>(); - - ////////////////////////////////////////////////////// - //// Static methods. - - /** Map {@link ReactorInstance} against achievable hashcode from {@link Reactor} - * @param reactor The Reactor - * @param reactorInstance The ReactorInstance for the specified Reactor - * @param defName definition Name for the specified Reactor - * */ - public static void mapReactorInstance(Reactor reactor, ReactorInstance reactorInstance, final String defName) { - gReactorInstancesMap.put(reactorInstance.definition, reactorInstance); - } - - /** Get {@link ReactorInstance} for supplied {@link Reactor} */ - public static ReactorInstance getReactorInstance(Instantiation i) { - return gReactorInstancesMap.get(i); - } - - /** Clears out the cache of ReactorInstance for next LF processing */ - public static void clearReactorInstanceMap() { - gReactorInstancesMap.clear(); - } - - /** Calculates Unique HashCode for the key of ReactorInstanceMap - * @param r The reactor - * @param n definition Name for the Reactor - * */ - private static Integer computeHash(Reactor r, final String n) { - return Math.abs(r.hashCode() * 37 + r.getTypeParms().hashCode() + n.hashCode()); - } - ////////////////////////////////////////////////////// //// Public methods. @@ -844,9 +811,6 @@ public ReactorInstance( this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); this.tpr = new TypeParameterizedReactor(definition); - // Add ReactorInstance against achievable hashcode from Reactor - ReactorInstance.mapReactorInstance(ASTUtils.toDefinition(definition.getReactorClass()), this, definition.getName()); - // check for recursive instantiation var currentParent = parent; var foundSelfAsParent = false; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 03b76b804b..b3bdac45bb 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1270,7 +1270,7 @@ private void generateInteractingContainedReactors( var contained = new InteractingContainedReactors(tpr.r()); // Next generate the relevant code. for (Instantiation containedReactor : contained.containedReactors()) { - var containedReactorType = ReactorInstance.getReactorInstance(containedReactor); + var containedTpr = new TypeParameterizedReactor(containedReactor); // First define an _width variable in case it is a bank. var array = ""; var width = -2; @@ -1298,12 +1298,12 @@ private void generateInteractingContainedReactors( // to be malloc'd at initialization. if (!ASTUtils.isMultiport(port)) { // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType.tpr, false)+" "+port.getName()+";"); + body.pr(port, variableStructType(port, containedTpr, false)+" "+port.getName()+";"); } else { // Is a multiport. // Memory will be malloc'd in initialization. body.pr(port, String.join("\n", - variableStructType(port, containedReactorType.tpr, false)+"** "+port.getName()+";", + variableStructType(port, containedTpr, false)+"** "+port.getName()+";", "int "+port.getName()+"_width;" )); } @@ -1313,13 +1313,13 @@ private void generateInteractingContainedReactors( // self struct of the container. if (!ASTUtils.isMultiport(port)) { // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType.tpr, false)+"* "+port.getName()+";"); + body.pr(port, variableStructType(port, containedTpr, false)+"* "+port.getName()+";"); } else { // Is a multiport. // Here, we will use an array of pointers. // Memory will be malloc'd in initialization. body.pr(port, String.join("\n", - variableStructType(port, containedReactorType.tpr, false)+"** "+port.getName()+";", + variableStructType(port, containedTpr, false)+"** "+port.getName()+";", "int "+port.getName()+"_width;" )); } diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 5a627055cc..95ea818c49 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -207,7 +207,6 @@ public static String generateInitializationForReaction(String body, // Before the reaction initialization, // generate the structs used for communication to and from contained reactors. for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { - var containedReactorType = ReactorInstance.getReactorInstance(containedReactor); String array = ""; if (containedReactor.getWidthSpec() != null) { String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); @@ -217,9 +216,9 @@ public static String generateInitializationForReaction(String body, array = "["+maxContainedReactorBankWidth(containedReactor, null, 0, mainDef)+"]"; } code.pr(String.join("\n", - "struct "+containedReactorType.getName()+" {", + "struct "+containedReactor.getName()+" {", " "+fieldsForStructsForContainedReactors.get(containedReactor), - "} "+containedReactorType.getName()+array+";" + "} "+containedReactor.getName()+array+";" )); } // Next generate all the collected setup code. @@ -355,9 +354,8 @@ private static void generateVariablesForSendingToContainedReactors( structBuilder = new CodeBuilder(); structs.put(definition, structBuilder); } - var reactorInstance = ReactorInstance.getReactorInstance(definition); - String inputStructType = CGenerator.variableStructType(input, reactorInstance.tpr, false); - String defName = reactorInstance.getName(); + String inputStructType = CGenerator.variableStructType(input, new TypeParameterizedReactor(definition), false); + String defName = definition.getName(); String defWidth = generateWidthVariable(defName); String inputName = input.getName(); String inputWidth = generateWidthVariable(inputName); @@ -423,14 +421,14 @@ private static void generatePortVariablesInReaction( } else { // port is an output of a contained reactor. Output output = (Output) port.getVariable(); - String portStructType = CGenerator.variableStructType(output, ReactorInstance.getReactorInstance(port.getContainer()).getTypeParameterizedReactor(), false); + String portStructType = CGenerator.variableStructType(output, new TypeParameterizedReactor(port.getContainer()), false); CodeBuilder structBuilder = structs.get(port.getContainer()); if (structBuilder == null) { structBuilder = new CodeBuilder(); structs.put(port.getContainer(), structBuilder); } - String subName = ReactorInstance.getReactorInstance(port.getContainer()).getName(); + String subName = port.getContainer().getName(); String reactorWidth = generateWidthVariable(subName); String outputName = output.getName(); String outputWidth = generateWidthVariable(outputName); @@ -645,7 +643,7 @@ public static String generateOutputVariablesInReaction( String outputStructType = (effect.getContainer() == null) ? CGenerator.variableStructType(output, tpr, false) : - CGenerator.variableStructType(output, ReactorInstance.getReactorInstance(effect.getContainer()).getTypeParameterizedReactor(), false); + CGenerator.variableStructType(output, new TypeParameterizedReactor(effect.getContainer()), false); if (!ASTUtils.isMultiport(output)) { // Output port is not a multiport. return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; From f497c2a027161738f54ab08265f7aaca128507ad Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 21 May 2023 17:30:01 -0700 Subject: [PATCH 366/709] Switch submodule ref to main. I am still not sure that we want to maintain this generics-related utility file. Let us not worry about it until later. --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index abc273ec0e..dc6b138746 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit abc273ec0ec0930252c55e2a106529d7cc4dc277 +Subproject commit dc6b13874697315859cd75e26ddd82f9c0d83643 From 40f007e14c70a7ac5067849daefda83dc9f351f2 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sun, 21 May 2023 18:40:41 -0700 Subject: [PATCH 367/709] Moved submodule to the right location --- .gitmodules | 4 ++-- org.lflang/src/lib/{ => py}/lf-python-support | 0 2 files changed, 2 insertions(+), 2 deletions(-) rename org.lflang/src/lib/{ => py}/lf-python-support (100%) diff --git a/.gitmodules b/.gitmodules index 9a655f8d1c..0fb2c73374 100644 --- a/.gitmodules +++ b/.gitmodules @@ -10,6 +10,6 @@ [submodule "org.lflang/src/lib/rs/reactor-rs"] path = org.lflang/src/lib/rs/reactor-rs url = https://github.com/lf-lang/reactor-rs -[submodule "org.lflang/src/lib/lf-python-support"] - path = org.lflang/src/lib/lf-python-support +[submodule "org.lflang/src/lib/py/lf-python-support"] + path = org.lflang/src/lib/py/lf-python-support url = https://github.com/lf-lang/lf-python-support.git diff --git a/org.lflang/src/lib/lf-python-support b/org.lflang/src/lib/py/lf-python-support similarity index 100% rename from org.lflang/src/lib/lf-python-support rename to org.lflang/src/lib/py/lf-python-support From 1cf725be4647441bc6671af942295464a4c1532c Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sun, 21 May 2023 18:42:45 -0700 Subject: [PATCH 368/709] Remove redundant submodule from .gitmodules --- .gitmodules | 3 --- 1 file changed, 3 deletions(-) diff --git a/.gitmodules b/.gitmodules index 0fb2c73374..c66506c2af 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,9 +1,6 @@ [submodule "org.lflang/src/lib/c/reactor-c"] path = org.lflang/src/lib/c/reactor-c url = https://github.com/lf-lang/reactor-c.git -[submodule "org.lflang/src/lib/py/lf-python-support"] - path = org.lflang/src/lib/py/lf-python-support - url = https://github.com/lf-lang/lf-python-support.git [submodule "org.lflang/src/lib/cpp/reactor-cpp"] path = org.lflang/src/lib/cpp/reactor-cpp url = https://github.com/lf-lang/reactor-cpp From c6f1a6366bc800e09ae06853cef5038acaa40157 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 21 May 2023 18:55:19 -0700 Subject: [PATCH 369/709] Update validator. --- .../generator/c/CReactionGenerator.java | 1 - .../generator/c/TypeParameterizedReactor.java | 6 ++++ .../org/lflang/validation/LFValidator.java | 28 ++++++++----------- 3 files changed, 17 insertions(+), 18 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 95ea818c49..2dbb1a1801 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -16,7 +16,6 @@ import org.lflang.TargetConfig; import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; import org.lflang.lf.BuiltinTriggerRef; diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 2b2e3e571c..69b245c36f 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -41,6 +41,12 @@ public void doDefines(CodeBuilder b) { "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); } + public Type resolveType(Type t) { + var arg = typeArgs.get(t.getCode().getBody()); + if (arg != null) return arg; + return t; + } + @Override public int hashCode() { return Math.abs(r.hashCode() * 31 + typeArgs.hashCode()); diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index c0e2a46e59..94fb578f72 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -45,6 +45,7 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; +import java.util.stream.Stream; import org.eclipse.emf.common.util.EList; import org.eclipse.emf.common.util.TreeIterator; @@ -65,6 +66,7 @@ import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.federated.validation.FedValidator; import org.lflang.generator.NamedInstance; +import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; import org.lflang.lf.Assignment; @@ -255,7 +257,10 @@ public void checkConnection(Connection connection) { // we leave type compatibility that language's compiler or interpreter. if (isCBasedTarget()) { Type type = (Type) null; - for (VarRef port : connection.getLeftPorts()) { + for (VarRef port : (Iterable) () -> Stream.concat( + connection.getLeftPorts().stream(), + connection.getRightPorts().stream() + ).iterator()) { // If the variable is not a port, then there is some other // error. Avoid a class cast exception. if (port.getVariable() instanceof Port) { @@ -264,22 +269,11 @@ public void checkConnection(Connection connection) { } else { // Unfortunately, xtext does not generate a suitable equals() // method for AST types, so we have to manually check the types. -// if (!sameType(type, ((Port) port.getVariable()).getType())) { -// error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); -// } - } - } - } - for (VarRef port : connection.getRightPorts()) { - // If the variable is not a port, then there is some other - // error. Avoid a class cast exception. - if (port.getVariable() instanceof Port) { - if (type == null) { - type = ((Port) port.getVariable()).getType(); - } else { -// if (!sameType(type, type = ((Port) port.getVariable()).getType())) { -// error("Types do not match.", Literals.CONNECTION__RIGHT_PORTS); -// } + var portType = ((Port) port.getVariable()).getType(); + portType = port.getContainer() == null ? portType : new TypeParameterizedReactor(port.getContainer()).resolveType(portType); + if (!sameType(type, portType)) { + error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); + } } } } From f13966ac008bf9e3036ac42ce94f49980ef50855 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 21 May 2023 22:17:10 -0700 Subject: [PATCH 370/709] Fix NPE. --- .../src/org/lflang/generator/c/TypeParameterizedReactor.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 69b245c36f..0ae657ed5c 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -42,6 +42,7 @@ public void doDefines(CodeBuilder b) { } public Type resolveType(Type t) { + if (t.getCode() == null) return t; var arg = typeArgs.get(t.getCode().getBody()); if (arg != null) return arg; return t; From 441ee025b63725c788ede03502b3ba257c15684c Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Mon, 22 May 2023 15:53:02 +0900 Subject: [PATCH 371/709] Move failed test to the failing folder --- .../federated/{ => failing}/DistributedCountPhysicalAfterDelay.lf | 0 .../src/federated/{ => failing}/LoopDistributedCentralized.lf | 0 .../src/federated/{ => failing}/LoopDistributedDouble.lf | 0 .../TypeScript/src/federated/{ => failing}/PingPongDistributed.lf | 0 .../src/federated/{ => failing}/PingPongDistributedPhysical.lf | 0 test/TypeScript/src/federated/{ => failing}/SimpleFederated.lf | 0 6 files changed, 0 insertions(+), 0 deletions(-) rename test/TypeScript/src/federated/{ => failing}/DistributedCountPhysicalAfterDelay.lf (100%) rename test/TypeScript/src/federated/{ => failing}/LoopDistributedCentralized.lf (100%) rename test/TypeScript/src/federated/{ => failing}/LoopDistributedDouble.lf (100%) rename test/TypeScript/src/federated/{ => failing}/PingPongDistributed.lf (100%) rename test/TypeScript/src/federated/{ => failing}/PingPongDistributedPhysical.lf (100%) rename test/TypeScript/src/federated/{ => failing}/SimpleFederated.lf (100%) diff --git a/test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/TypeScript/src/federated/failing/DistributedCountPhysicalAfterDelay.lf similarity index 100% rename from test/TypeScript/src/federated/DistributedCountPhysicalAfterDelay.lf rename to test/TypeScript/src/federated/failing/DistributedCountPhysicalAfterDelay.lf diff --git a/test/TypeScript/src/federated/LoopDistributedCentralized.lf b/test/TypeScript/src/federated/failing/LoopDistributedCentralized.lf similarity index 100% rename from test/TypeScript/src/federated/LoopDistributedCentralized.lf rename to test/TypeScript/src/federated/failing/LoopDistributedCentralized.lf diff --git a/test/TypeScript/src/federated/LoopDistributedDouble.lf b/test/TypeScript/src/federated/failing/LoopDistributedDouble.lf similarity index 100% rename from test/TypeScript/src/federated/LoopDistributedDouble.lf rename to test/TypeScript/src/federated/failing/LoopDistributedDouble.lf diff --git a/test/TypeScript/src/federated/PingPongDistributed.lf b/test/TypeScript/src/federated/failing/PingPongDistributed.lf similarity index 100% rename from test/TypeScript/src/federated/PingPongDistributed.lf rename to test/TypeScript/src/federated/failing/PingPongDistributed.lf diff --git a/test/TypeScript/src/federated/PingPongDistributedPhysical.lf b/test/TypeScript/src/federated/failing/PingPongDistributedPhysical.lf similarity index 100% rename from test/TypeScript/src/federated/PingPongDistributedPhysical.lf rename to test/TypeScript/src/federated/failing/PingPongDistributedPhysical.lf diff --git a/test/TypeScript/src/federated/SimpleFederated.lf b/test/TypeScript/src/federated/failing/SimpleFederated.lf similarity index 100% rename from test/TypeScript/src/federated/SimpleFederated.lf rename to test/TypeScript/src/federated/failing/SimpleFederated.lf From dd823e2bb6531fc7690c42c884e4a64fb30ab363 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 00:17:14 -0700 Subject: [PATCH 372/709] Update reactor-c submodule --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index dc6b138746..845daae394 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit dc6b13874697315859cd75e26ddd82f9c0d83643 +Subproject commit 845daae39479b8c06d15c1215aca575a4728a599 From f3c8ffa64cd47198cfaea6f746170311b79040bf Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 00:37:04 -0700 Subject: [PATCH 373/709] Remove getConcreteType. Prefer to work on InferredTypes or Types rather than raw strings. Our code base, esp. the C generator, has had multiple problems involving ad hoc matching of raw strings. --- .../lflang/generator/c/CActionGenerator.java | 2 +- .../org/lflang/generator/c/CGenerator.java | 3 +-- .../generator/c/CParameterGenerator.java | 2 +- .../lflang/generator/c/CStateGenerator.java | 4 +-- .../src/org/lflang/generator/c/CTypes.java | 2 +- .../src/org/lflang/generator/c/CUtil.java | 25 ------------------- .../generator/c/TypeParameterizedReactor.java | 6 +++++ 7 files changed, 12 insertions(+), 32 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index bc14c402a7..0fa79e94ca 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -171,6 +171,6 @@ private static String valueDeclaration( // will be a separate field pointing to the token. return action.getType() == null && target.requiresTypes ? "" : - CUtil.getConcreteType(tpr, types.getTargetType(action)) + " value;"; + types.getTargetType(tpr.resolveType(action.getType())) + " value;"; } } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b3bdac45bb..ea9de156e0 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1771,14 +1771,13 @@ private void generateInitializeActionToken(ReactorInstance reactor) { // Skip this step if the action is not in use. if (action.getParent().getTriggers().contains(action) ) { - var type = getInferredType(action.getDefinition()); + var type = reactor.tpr.resolveType(getInferredType(action.getDefinition())); var payloadSize = "0"; if (!type.isUndefined()) { var typeStr = types.getTargetType(type); if (CUtil.isTokenType(type, types)) { typeStr = CUtil.rootType(typeStr); } - typeStr = CUtil.getConcreteType(reactor.tpr, typeStr); if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { payloadSize = "sizeof("+typeStr+")"; } diff --git a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java index fb6a46bace..fc74f76d78 100644 --- a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java @@ -47,7 +47,7 @@ public static String generateDeclarations(TypeParameterizedReactor reactor, CTyp CodeBuilder code = new CodeBuilder(); for (Parameter parameter : ASTUtils.allParameters(reactor.r())) { code.prSourceLineNumber(parameter); - code.pr(CUtil.getConcreteType(reactor, types.getTargetType(parameter)) + " " + parameter.getName() + ";"); + code.pr(types.getTargetType(reactor.resolveType(ASTUtils.getInferredType(parameter))) + " " + parameter.getName() + ";"); } return code.toString(); } diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java index d3ced7fc65..1b75a73ab8 100644 --- a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java @@ -23,7 +23,7 @@ public static String generateDeclarations(TypeParameterizedReactor reactor, CTyp CodeBuilder code = new CodeBuilder(); for (StateVar stateVar : ASTUtils.allStateVars(reactor.r())) { code.prSourceLineNumber(stateVar); - code.pr(CUtil.getConcreteType(reactor, types.getTargetType(stateVar)) + " " + stateVar.getName() + ";"); + code.pr(types.getTargetType(reactor.resolveType(ASTUtils.getInferredType(stateVar))) + " " + stateVar.getName() + ";"); } return code.toString(); } @@ -93,7 +93,7 @@ private static String generateModalReset( return ""; } var modeRef = "&"+CUtil.reactorRef(mode.getParent())+"->_lf__modes["+mode.getParent().modes.indexOf(mode)+"]"; - var type = CUtil.getConcreteType(instance.tpr, types.getTargetType(ASTUtils.getInferredType(stateVar))); + var type = types.getTargetType(instance.tpr.resolveType(ASTUtils.getInferredType(stateVar))); if (ASTUtils.isOfTimeType(stateVar) || ASTUtils.isParameterized(stateVar) && diff --git a/org.lflang/src/org/lflang/generator/c/CTypes.java b/org.lflang/src/org/lflang/generator/c/CTypes.java index 1081912f24..45edd59bd5 100644 --- a/org.lflang/src/org/lflang/generator/c/CTypes.java +++ b/org.lflang/src/org/lflang/generator/c/CTypes.java @@ -125,7 +125,7 @@ public String getVariableDeclaration( String variableName, boolean initializer ) { - String t = CUtil.getConcreteType(tpr, TargetTypes.super.getTargetType(type)); + String t = TargetTypes.super.getTargetType(tpr.resolveType(type)); Matcher matcher = arrayPattern.matcher(t); String declaration = String.format("%s %s", t, variableName); if (matcher.find()) { diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index e06fcdfc3f..b4e88b42ad 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -781,31 +781,6 @@ public static Pair separateTokensFromTypes(String str) { return new Pair<>(str.substring(0, starIdx), str.substring(starIdx)); } - /** - * Given a type we need to check if the type is Generic Type literal and if - * it is we need to find the corresponding concrete type - * - * @param tpr {@link TypeParameterizedReactor} - * @param type Actual typename - */ - public static String getConcreteType(TypeParameterizedReactor tpr, final String type) { - if (tpr == null) - return type; - - var wrapper = new Object() { - String concreteType = ""; - final Pair inPair = separateTokensFromTypes(type); - }; - tpr.typeArgs().forEach((literal, concreteType) -> { - if (wrapper.inPair.getFirst().equals(literal)) - { - wrapper.concreteType = String.valueOf(concreteType.getId()); - } - }); - - return wrapper.concreteType.isEmpty() ? type : wrapper.concreteType + wrapper.inPair.getSecond(); - } - public static String generateWidthVariable(String var) { return var + "_width"; } diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 0ae657ed5c..2f70b10825 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -6,6 +6,7 @@ import java.util.stream.Collectors; import org.lflang.ASTUtils; +import org.lflang.InferredType; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Instantiation; import org.lflang.lf.Reactor; @@ -48,6 +49,11 @@ public Type resolveType(Type t) { return t; } + public InferredType resolveType(InferredType t) { + if (t.astType.getCode() != null) return InferredType.fromAST(resolveType(t.astType)); + return t; + } + @Override public int hashCode() { return Math.abs(r.hashCode() * 31 + typeArgs.hashCode()); From 957500d3fd4e458dfbae998ffdbacaa259c8a202 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 00:41:31 -0700 Subject: [PATCH 374/709] Delete Pair.java. It is usually recommended in the Java community to create objects specifically for the purpose at hand rather than using general tuple types. --- .../src/org/lflang/generator/c/CUtil.java | 16 ---- org.lflang/src/org/lflang/util/Pair.java | 77 ------------------- 2 files changed, 93 deletions(-) delete mode 100644 org.lflang/src/org/lflang/util/Pair.java diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index b4e88b42ad..aed904d0e6 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -53,7 +53,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.WidthTerm; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; -import org.lflang.util.Pair; /** * A collection of utilities for C code generation. @@ -766,21 +765,6 @@ public static boolean isTokenType(InferredType type, CTypes types) { return type.isVariableSizeList || targetType.trim().endsWith("*"); } - /** - * Given a String str separate the Typename from tokens (* OR []) - * - * @param str Input String - * @return {@link Pair} of Typename and Tokens - * */ - public static Pair separateTokensFromTypes(String str) { - var starIdx = str.indexOf("*"); - if (starIdx == -1) { - var idx = str.indexOf("["); - return idx == -1 ? new Pair<>(str, "") : new Pair<>(str.substring(0, idx), str.substring(idx)); - } - return new Pair<>(str.substring(0, starIdx), str.substring(starIdx)); - } - public static String generateWidthVariable(String var) { return var + "_width"; } diff --git a/org.lflang/src/org/lflang/util/Pair.java b/org.lflang/src/org/lflang/util/Pair.java deleted file mode 100644 index ef2ac123c4..0000000000 --- a/org.lflang/src/org/lflang/util/Pair.java +++ /dev/null @@ -1,77 +0,0 @@ -/** - * @file - * @author Muhammad Khubaib Umer (khubaib@magnition.io) - * - * @section LICENSE -Copyright (c) 2023, MagnitionIO -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. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. - * @section DESCRIPTION - * - * This Class provides a Pair of Templated Types - * This provides the same facility as std::pair in C++ - */ - -package org.lflang.util; - -public final class Pair { - private final T1 first; - private final T2 second; - public Pair(final T1 t1, final T2 t2) - { - this.first = t1; - this.second = t2; - } - - public T1 getFirst() - { - return this.first; - } - - public T2 getSecond() - { - return this.second; - } - - @Override - public boolean equals(Object other) { - if (other == null) - return false; - if (this == other) - return true; - if (this.getClass().equals(other.getClass())) { - var otherPair = (Pair) other; - boolean isEqual = (first == null) ? otherPair.getFirst() == null : first.equals(otherPair.getFirst()); - - if (!isEqual) - return false; - - return (second == null) ? otherPair.getSecond() == null : second.equals(otherPair.getSecond()); - } - return false; - } - - @Override - public int hashCode() { - return first == null ? 0 : first.hashCode() + 27 * (second == null ? 0 : second.hashCode()); - } - - @Override - public String toString() { - return "Pair<" + first + ", " + second + ">"; - } -} From fa738b10b494c5fb35c5444c04610144be4da8f6 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 00:45:16 -0700 Subject: [PATCH 375/709] Impl of equals must match impl of hashcode. --- .../src/org/lflang/generator/c/TypeParameterizedReactor.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 2f70b10825..689a2dcc72 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -58,4 +58,9 @@ public InferredType resolveType(InferredType t) { public int hashCode() { return Math.abs(r.hashCode() * 31 + typeArgs.hashCode()); } + + @Override + public boolean equals(Object obj) { + return obj instanceof TypeParameterizedReactor other && r.equals(other.r) && typeArgs.equals(other.typeArgs); + } } From 5f52ca9ffa1af04c4489d6c40cc38117c4f80580 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 00:54:06 -0700 Subject: [PATCH 376/709] Fix NPE and (slightly) dignify a hack. --- org.lflang/src/org/lflang/generator/c/CUtil.java | 3 +-- .../org/lflang/generator/c/InteractingContainedReactors.java | 4 ---- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index aed904d0e6..2c10edccf7 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -761,8 +761,7 @@ private static List multiportWidthTerms(Variable variable) { public static boolean isTokenType(InferredType type, CTypes types) { if (type.isUndefined()) return false; // This is a hacky way to do this. It is now considered to be a bug (#657) - String targetType = types.getVariableDeclaration(null, type, "", false); - return type.isVariableSizeList || targetType.trim().endsWith("*"); + return type.isVariableSizeList || !type.astType.getStars().isEmpty(); } public static String generateWidthVariable(String var) { diff --git a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java index ae6b37437f..26925b7486 100644 --- a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java +++ b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java @@ -7,15 +7,12 @@ import java.util.Set; import org.lflang.ASTUtils; -import org.lflang.federated.generator.FederateInstance; -import org.lflang.generator.NamedInstance; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Output; import org.lflang.lf.Port; import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; import org.lflang.lf.TriggerRef; import org.lflang.lf.VarRef; @@ -154,4 +151,3 @@ public List reactionsTriggered(Instantiation containedReactor, Port por return new LinkedList<>(); } } - From 5299ca5481e3514f37d613d179826e22e7d473e7 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 01:14:01 -0700 Subject: [PATCH 377/709] Fix another NPE. --- .../src/org/lflang/generator/c/TypeParameterizedReactor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 689a2dcc72..9a7a0758e4 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -50,7 +50,7 @@ public Type resolveType(Type t) { } public InferredType resolveType(InferredType t) { - if (t.astType.getCode() != null) return InferredType.fromAST(resolveType(t.astType)); + if (t.astType != null && t.astType.getCode() != null) return InferredType.fromAST(resolveType(t.astType)); return t; } From 7d7abec62fecb7e7b597aae9545e0d19ee257015 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 22 May 2023 06:02:25 -0700 Subject: [PATCH 378/709] Increased times by 10x to attempt to fix flaky tests --- test/C/src/concurrent/Watchdog.lf | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/test/C/src/concurrent/Watchdog.lf b/test/C/src/concurrent/Watchdog.lf index bc8ab1387b..e49b2fcec7 100644 --- a/test/C/src/concurrent/Watchdog.lf +++ b/test/C/src/concurrent/Watchdog.lf @@ -1,16 +1,16 @@ /** - * Test watchdog. This test starts a watchdog timer of 150ms every 100ms. Half + * Test watchdog. This test starts a watchdog timer of 1500ms every 1s. Half * the time, it then sleeps after starting the watchdog so that the watchdog - * expires. There should be a total of five watchdog expirations. + * expires. There should be a total of two watchdog expirations. * @author Benjamin Asch * @author Edward A. Lee */ target C { - timeout: 1100 ms + timeout: 11000 ms } -reactor Watcher(timeout: time = 150 ms) { - timer t(100 ms, 100 ms) // Offset ameliorates startup time. +reactor Watcher(timeout: time = 1500 ms) { + timer t(1s, 1s) // Offset ameliorates startup time. // Period has to be smaller than watchdog timeout. Produced if the watchdog // triggers. output d: int @@ -54,7 +54,7 @@ main reactor { self->count++; if (self->count % 4 == 0) { lf_print(">>>>>> Taking a long time to process that output!"); - lf_sleep(MSEC(160)); + lf_sleep(MSEC(1600)); } =} From 4e1076a89ab822013bc839bf93fbd15f025f7192 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 22 May 2023 06:03:35 -0700 Subject: [PATCH 379/709] Align to reactor-c main --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 843e147128..845daae394 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 843e147128315ffa5216fffd6cba36396c3cd084 +Subproject commit 845daae39479b8c06d15c1215aca575a4728a599 From 093bb69b29ab9d62a3f19a0cb4172fd00147e877 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 22 May 2023 06:06:23 -0700 Subject: [PATCH 380/709] Moved test that fails on mac to failing --- .../C/src/federated/{ => failing}/SimpleFederatedAuthenticated.lf | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/C/src/federated/{ => failing}/SimpleFederatedAuthenticated.lf (100%) diff --git a/test/C/src/federated/SimpleFederatedAuthenticated.lf b/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf similarity index 100% rename from test/C/src/federated/SimpleFederatedAuthenticated.lf rename to test/C/src/federated/failing/SimpleFederatedAuthenticated.lf From cccf2aa63526ca0bca4ce8d7e3dda04d44e4730a Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 08:02:57 -0700 Subject: [PATCH 381/709] Fix passing generics test. --- .../src/org/lflang/generator/c/TypeParameterizedReactor.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 9a7a0758e4..9c0a8787ab 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -43,6 +43,7 @@ public void doDefines(CodeBuilder b) { } public Type resolveType(Type t) { + if (t.getId() != null) return typeArgs.get(t.getId()); if (t.getCode() == null) return t; var arg = typeArgs.get(t.getCode().getBody()); if (arg != null) return arg; @@ -50,8 +51,8 @@ public Type resolveType(Type t) { } public InferredType resolveType(InferredType t) { - if (t.astType != null && t.astType.getCode() != null) return InferredType.fromAST(resolveType(t.astType)); - return t; + if (t.astType == null) return t; + return InferredType.fromAST(resolveType(t.astType)); } @Override From 0093be73441655298bc70c4c99604a0a4f700455 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 08:13:55 -0700 Subject: [PATCH 382/709] Fix NPE. --- .../src/org/lflang/generator/c/TypeParameterizedReactor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 9c0a8787ab..9145b70e6d 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -43,7 +43,7 @@ public void doDefines(CodeBuilder b) { } public Type resolveType(Type t) { - if (t.getId() != null) return typeArgs.get(t.getId()); + if (t.getId() != null && typeArgs.get(t.getId()) != null) return typeArgs.get(t.getId()); if (t.getCode() == null) return t; var arg = typeArgs.get(t.getCode().getBody()); if (arg != null) return arg; From 76c048c5c3f83c85c371ef945de34d2b108d1d61 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 08:58:06 -0700 Subject: [PATCH 383/709] More of the stars hack. --- org.lflang/src/org/lflang/generator/c/CUtil.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 2c10edccf7..c09f8c63ef 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -761,7 +761,8 @@ private static List multiportWidthTerms(Variable variable) { public static boolean isTokenType(InferredType type, CTypes types) { if (type.isUndefined()) return false; // This is a hacky way to do this. It is now considered to be a bug (#657) - return type.isVariableSizeList || !type.astType.getStars().isEmpty(); + return type.isVariableSizeList || type.astType != null && (!type.astType.getStars().isEmpty() || + type.astType.getCode() != null && type.astType.getCode().getBody().stripTrailing().endsWith("*")); } public static String generateWidthVariable(String var) { From 47e97d8222919196085abb42afb4e17d2395a901 Mon Sep 17 00:00:00 2001 From: Peter Donovan <33707478+petervdonovan@users.noreply.github.com> Date: Mon, 22 May 2023 12:29:58 -0700 Subject: [PATCH 384/709] Apply suggestions from code review Co-authored-by: Marten Lohstroh --- org.lflang/src/org/lflang/ASTUtils.java | 4 ++-- org.lflang/src/org/lflang/generator/c/CMethodGenerator.java | 2 +- org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java | 4 ++-- .../src/org/lflang/generator/python/PythonGenerator.java | 2 +- org.lflang/src/org/lflang/validation/LFValidator.java | 2 -- 5 files changed, 6 insertions(+), 8 deletions(-) diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ASTUtils.java index b9cacd8f48..7b747b0adb 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ASTUtils.java @@ -402,8 +402,8 @@ public static List allInstantiations(Reactor definition) { } /** - * Given a reactor Class, returns a set of include names for - * interacting reactors which includes all instantiations of base class that it extends + * Given a reactor Class, return a set of include names for + * interacting reactors which includes all instantiations of base class that it extends. * * @param r Reactor Class * */ diff --git a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java index 67576f4324..cac2eff8cb 100644 --- a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java @@ -56,7 +56,7 @@ public static void generateMacroUndefsForMethods( * This function will have a first argument that is a void* pointing to * the self struct, followed by any arguments given in its definition. * @param method The method. - * @param tpr The reactor declaration. + * @param tpr The concrete reactor class. * @param types The C-specific type conversion functions. */ public static String generateMethod( diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 1dac9d13a9..0f38c82c04 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -280,7 +280,7 @@ private static String generateWatchdogFunction( * Return the start of a C function definition for a watchdog. * * @param watchdog The watchdog - * @param tpr The reactor declaration + * @param tpr The concrete reactor class * @return The function name for the watchdog function. */ private static String generateWatchdogFunctionHeader(Watchdog watchdog, TypeParameterizedReactor tpr) { @@ -292,7 +292,7 @@ private static String generateWatchdogFunctionHeader(Watchdog watchdog, TypePara * Return the name of the watchdog expiration handler function. * * @param watchdog The watchdog - * @param tpr The reactor with the watchdog + * @param tpr The concrete reactor class that has the watchdog * @return Name of the watchdog handler function */ private static String watchdogFunctionName(Watchdog watchdog, TypeParameterizedReactor tpr) { diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index d71be3ebd1..4e41b700ed 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -348,7 +348,7 @@ public void processProtoFile(String filename) { /** * Generate the aliases for inputs, outputs, and struct type definitions for * actions of the specified reactor in the specified federate. - * @param tpr The parsed reactor data structure. + * @param tpr The concrete reactor class. */ @Override public void generateAuxiliaryStructs( diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 94fb578f72..fd37e5a3a7 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -267,8 +267,6 @@ public void checkConnection(Connection connection) { if (type == null) { type = ((Port) port.getVariable()).getType(); } else { - // Unfortunately, xtext does not generate a suitable equals() - // method for AST types, so we have to manually check the types. var portType = ((Port) port.getVariable()).getType(); portType = port.getContainer() == null ? portType : new TypeParameterizedReactor(port.getContainer()).resolveType(portType); if (!sameType(type, portType)) { From 882dd8382f3eed94d8d227b0ea99968a77234b0d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 12:30:55 -0700 Subject: [PATCH 385/709] Add comments. --- .../generator/c/TypeParameterizedReactor.java | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 9145b70e6d..a1375c61bb 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -12,7 +12,12 @@ import org.lflang.lf.Reactor; import org.lflang.lf.Type; -public record TypeParameterizedReactor(Reactor r, Map typeArgs) { +/** + * A reactor class combined with concrete type arguments bound to its type parameters. + * @param reactor The syntactic reactor class definition + * @param typeArgs The type arguments associated with this particular variant of the reactor class. + */ +public record TypeParameterizedReactor(Reactor reactor, Map typeArgs) { public TypeParameterizedReactor(Instantiation i) { this(ASTUtils.toDefinition(i.getReactorClass()), addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()))); @@ -29,11 +34,13 @@ private static Map addTypeArgs(Instantiation instantiation, Reacto return ret; } + /** Return the name of the reactor given its type arguments. */ public String getName() { // FIXME: Types that are not just a single token need to be escaped or hashed - return r.getName() + typeArgs.values().stream().map(ASTUtils::toOriginalText).collect(Collectors.joining("_")); + return reactor.getName() + typeArgs.values().stream().map(ASTUtils::toOriginalText).collect(Collectors.joining("_")); } + /** #define type names as concrete types. */ public void doDefines(CodeBuilder b) { typeArgs.forEach((literal, concreteType) -> b.pr( "#if defined " + literal + "\n" + @@ -42,6 +49,7 @@ public void doDefines(CodeBuilder b) { "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); } + /** Resolve type arguments if the given type is defined in terms of generics. */ public Type resolveType(Type t) { if (t.getId() != null && typeArgs.get(t.getId()) != null) return typeArgs.get(t.getId()); if (t.getCode() == null) return t; @@ -50,6 +58,7 @@ public Type resolveType(Type t) { return t; } + /** Resolve type arguments if the given type is defined in terms of generics. */ public InferredType resolveType(InferredType t) { if (t.astType == null) return t; return InferredType.fromAST(resolveType(t.astType)); @@ -57,11 +66,11 @@ public InferredType resolveType(InferredType t) { @Override public int hashCode() { - return Math.abs(r.hashCode() * 31 + typeArgs.hashCode()); + return Math.abs(reactor.hashCode() * 31 + typeArgs.hashCode()); } @Override public boolean equals(Object obj) { - return obj instanceof TypeParameterizedReactor other && r.equals(other.r) && typeArgs.equals(other.typeArgs); + return obj instanceof TypeParameterizedReactor other && reactor.equals(other.reactor) && typeArgs.equals(other.typeArgs); } } From 2138d7da8f7985022ceee1d29a00e942e6f67a35 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 12:33:20 -0700 Subject: [PATCH 386/709] Rename tpr.r() -> tpr.reactor(). --- .../lflang/generator/c/CActionGenerator.java | 5 ++--- .../org/lflang/generator/c/CGenerator.java | 22 +++++++++---------- .../lflang/generator/c/CMethodGenerator.java | 8 +++---- .../generator/c/CParameterGenerator.java | 9 +------- .../lflang/generator/c/CPortGenerator.java | 6 ++--- .../generator/c/CReactionGenerator.java | 18 +++++++-------- .../c/CReactorHeaderFileGenerator.java | 17 +++++++------- .../lflang/generator/c/CStateGenerator.java | 9 +------- .../src/org/lflang/generator/c/CUtil.java | 6 ++--- .../generator/c/CWatchdogGenerator.java | 9 ++++---- .../generator/python/PythonGenerator.java | 10 ++++----- 11 files changed, 48 insertions(+), 71 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index 0fa79e94ca..600100b41d 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -8,8 +8,7 @@ import org.lflang.generator.CodeBuilder; import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; -import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; + import static org.lflang.generator.c.CGenerator.variableStructType; /** * Generates code for actions (logical or physical) for the C and CCpp target. @@ -98,7 +97,7 @@ public static void generateDeclarations( CodeBuilder body, CodeBuilder constructorCode ) { - for (Action action : ASTUtils.allActions(tpr.r())) { + for (Action action : ASTUtils.allActions(tpr.reactor())) { var actionName = action.getName(); body.pr(action, CGenerator.variableStructType(action, tpr, false)+" _lf_"+actionName+";"); // Initialize the trigger pointer in the action. diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index ea9de156e0..9d17c6bc14 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -888,7 +888,7 @@ private void resolveTemplatedTypes(ReactorInstance reactorInstance, TypeParamete } }); if (!copy.isEmpty()) { // If we found some templated-types update the tpr with new map - child.tpr = new TypeParameterizedReactor(child.tpr.r(), copy); + child.tpr = new TypeParameterizedReactor(child.tpr.reactor(), copy); } resolveTemplatedTypes(child, child.tpr); } @@ -914,9 +914,9 @@ private void generateHeaders() throws IOException { (builder, rr, userFacing) -> { generateAuxiliaryStructs(builder, rr, userFacing); if (userFacing) { - rr.r().getInstantiations().stream() + rr.reactor().getInstantiations().stream() .map(it -> new TypeParameterizedReactorWithDecl(new TypeParameterizedReactor(it), it.getReactorClass())).collect(Collectors.toSet()).forEach(it -> { - ASTUtils.allPorts(it.tpr.r()) + ASTUtils.allPorts(it.tpr.reactor()) .forEach(p -> builder.pr(CPortGenerator.generateAuxiliaryStruct( it.tpr, p, getTarget(), errorReporter, types, new CodeBuilder(), true, it.decl() ))); @@ -1049,8 +1049,8 @@ private void generateReactorClass(TypeParameterizedReactor tpr) throws IOExcepti header.pr("#ifndef " + guardMacro); header.pr("#define " + guardMacro); generateReactorClassHeaders(tpr, headerName, header, src); - header.pr(generateTopLevelPreambles(tpr.r())); - generateUserPreamblesForReactor(tpr.r(), src); + header.pr(generateTopLevelPreambles(tpr.reactor())); + generateUserPreamblesForReactor(tpr.reactor(), src); generateReactorClassBody(tpr, header, src); header.pr("#endif // " + guardMacro); FileUtil.writeToFile(CodeMap.fromGeneratedCode(header.toString()).getGeneratedCode(), fileConfig.getSrcGenPath().resolve(headerName), true); @@ -1075,7 +1075,7 @@ protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(tpr) + "\""); src.pr("#include \"" + headerName + "\""); tpr.doDefines(src); - ASTUtils.allIncludes(tpr.r()).stream().map(name -> "#include \"" + ASTUtils.allIncludes(tpr.reactor()).stream().map(name -> "#include \"" + name + ".h\"").forEach(header::pr); } @@ -1154,7 +1154,7 @@ protected void generateAuxiliaryStructs(CodeBuilder builder, TypeParameterizedRe #endif """, types.getTargetTagType(), types.getTargetTimeType()) ); - for (Port p : allPorts(tpr.r())) { + for (Port p : allPorts(tpr.reactor())) { builder.pr(CPortGenerator.generateAuxiliaryStruct( tpr, p, @@ -1169,7 +1169,7 @@ protected void generateAuxiliaryStructs(CodeBuilder builder, TypeParameterizedRe // The very first item on this struct needs to be // a trigger_t* because the struct will be cast to (trigger_t*) // by the lf_schedule() functions to get to the trigger. - for (Action action : allActions(tpr.r())) { + for (Action action : allActions(tpr.reactor())) { builder.pr(CActionGenerator.generateAuxiliaryStruct( tpr, action, @@ -1188,7 +1188,7 @@ protected void generateAuxiliaryStructs(CodeBuilder builder, TypeParameterizedRe * go into the constructor. */ private void generateSelfStruct(CodeBuilder builder, TypeParameterizedReactor tpr, CodeBuilder constructorCode) { - var reactor = toDefinition(tpr.r()); + var reactor = toDefinition(tpr.reactor()); var selfType = CUtil.selfType(tpr); // Construct the typedef for the "self" struct. @@ -1267,7 +1267,7 @@ private void generateInteractingContainedReactors( ) { // The contents of the struct will be collected first so that // we avoid duplicate entries and then the struct will be constructed. - var contained = new InteractingContainedReactors(tpr.r()); + var contained = new InteractingContainedReactors(tpr.reactor()); // Next generate the relevant code. for (Instantiation containedReactor : contained.containedReactors()) { var containedTpr = new TypeParameterizedReactor(containedReactor); @@ -1403,7 +1403,7 @@ protected void generateSelfStructExtension( */ public void generateReactions(CodeBuilder src, TypeParameterizedReactor tpr) { var reactionIndex = 0; - var reactor = ASTUtils.toDefinition(tpr.r()); + var reactor = ASTUtils.toDefinition(tpr.reactor()); for (Reaction reaction : allReactions(reactor)) { generateReaction(src, reaction, tpr, reactionIndex); // Increment reaction index even if the reaction is not in the federate diff --git a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java index cac2eff8cb..691019b160 100644 --- a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java @@ -5,10 +5,8 @@ import org.lflang.ASTUtils; import org.lflang.InferredType; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.ReactorInstance; import org.lflang.lf.Method; import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; /** * Collection of functions to generate C code to declare methods. @@ -26,7 +24,7 @@ public static void generateMacrosForMethods( TypeParameterizedReactor tpr, CodeBuilder body ) { - for (Method method : allMethods(tpr.r())) { + for (Method method : allMethods(tpr.reactor())) { var functionName = methodFunctionName(tpr, method); // If the method has no arguments. Do not pass it any variadic arguments. if (method.getArguments().size() > 0) { @@ -103,7 +101,7 @@ public static void generateMethods( CodeBuilder code, CTypes types ) { - var reactor = tpr.r(); + var reactor = tpr.reactor(); code.prComment("***** Start of method declarations."); signatures(tpr, code, types); generateMacrosForMethods(tpr, code); @@ -127,7 +125,7 @@ public static void signatures( CodeBuilder body, CTypes types ) { - Reactor reactor = tpr.r(); + Reactor reactor = tpr.reactor(); for (Method method : allMethods(reactor)) { body.pr(generateMethodSignature(method, tpr, types) + ";"); } diff --git a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java index fc74f76d78..1d563b5de9 100644 --- a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java @@ -1,17 +1,10 @@ package org.lflang.generator.c; -import java.util.List; -import java.util.stream.Collectors; - -import org.lflang.InferredType; import org.lflang.generator.ParameterInstance; import org.lflang.ASTUtils; import org.lflang.generator.CodeBuilder; -import org.lflang.lf.Assignment; -import org.lflang.lf.Expression; import org.lflang.lf.Initializer; import org.lflang.lf.Parameter; -import org.lflang.lf.Reactor; /** * Generates C code to declare and initialize parameters. @@ -45,7 +38,7 @@ public static String getInitializer(ParameterInstance p) { */ public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { CodeBuilder code = new CodeBuilder(); - for (Parameter parameter : ASTUtils.allParameters(reactor.r())) { + for (Parameter parameter : ASTUtils.allParameters(reactor.reactor())) { code.prSourceLineNumber(parameter); code.pr(types.getTargetType(reactor.resolveType(ASTUtils.getInferredType(parameter))) + " " + parameter.getName() + ";"); } diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index 51ff72d919..9cdc20db8f 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -9,9 +9,7 @@ import org.lflang.lf.Input; import org.lflang.lf.Output; import org.lflang.lf.Port; -import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; -import org.lflang.lf.Type; import static org.lflang.generator.c.CGenerator.variableStructType; @@ -213,7 +211,7 @@ private static void generateInputDeclarations( CodeBuilder body, CodeBuilder constructorCode ) { - for (Input input : ASTUtils.allInputs(tpr.r())) { + for (Input input : ASTUtils.allInputs(tpr.reactor())) { var inputName = input.getName(); if (ASTUtils.isMultiport(input)) { body.pr(input, String.join("\n", @@ -251,7 +249,7 @@ private static void generateOutputDeclarations( CodeBuilder body, CodeBuilder constructorCode ) { - for (Output output : ASTUtils.allOutputs(tpr.r())) { + for (Output output : ASTUtils.allOutputs(tpr.reactor())) { // If the port is a multiport, create an array to be allocated // at instantiation. var outputName = output.getName(); diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 2dbb1a1801..797ab93beb 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -126,7 +126,7 @@ public static String generateInitializationForReaction(String body, // No triggers are given, which means react to any input. // Declare an argument for every input. // NOTE: this does not include contained outputs. - for (Input input : tpr.r().getInputs()) { + for (Input input : tpr.reactor().getInputs()) { reactionInitialization.pr(generateInputVariablesInReaction(input, tpr, types)); } } @@ -161,7 +161,7 @@ public static String generateInitializationForReaction(String body, } } else if (effect.getVariable() instanceof Mode) { // Mode change effect - int idx = ASTUtils.allModes(tpr.r()).indexOf((Mode)effect.getVariable()); + int idx = ASTUtils.allModes(tpr.reactor()).indexOf((Mode)effect.getVariable()); String name = effect.getVariable().getName(); if (idx >= 0) { reactionInitialization.pr( @@ -701,7 +701,7 @@ public static void generateReactionAndTriggerStructs( var startupReactions = new LinkedHashSet(); var shutdownReactions = new LinkedHashSet(); var resetReactions = new LinkedHashSet(); - for (Reaction reaction : ASTUtils.allReactions(tpr.r())) { + for (Reaction reaction : ASTUtils.allReactions(tpr.reactor())) { // Create the reaction_t struct. body.pr(reaction, "reaction_t _lf__reaction_"+reactionCount+";"); @@ -771,7 +771,7 @@ public static void generateReactionAndTriggerStructs( "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", reaction.eContainer() instanceof Mode ? - "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+tpr.r().getModes().indexOf((Mode) reaction.eContainer())+"];" : + "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+tpr.reactor().getModes().indexOf((Mode) reaction.eContainer())+"];" : "self->_lf__reaction_"+reactionCount+".mode = NULL;" )); // Increment the reactionCount even if the reaction is not in the federate @@ -781,7 +781,7 @@ public static void generateReactionAndTriggerStructs( // Next, create and initialize the trigger_t objects. // Start with the timers. - for (Timer timer : ASTUtils.allTimers(tpr.r())) { + for (Timer timer : ASTUtils.allTimers(tpr.reactor())) { createTriggerT(body, timer, triggerMap, constructorCode, types); // Since the self struct is allocated using calloc, there is no need to set falsy fields. constructorCode.pr("self->_lf__"+timer.getName()+".is_timer = true;"); @@ -802,7 +802,7 @@ public static void generateReactionAndTriggerStructs( } // Next handle actions. - for (Action action : ASTUtils.allActions(tpr.r())) { + for (Action action : ASTUtils.allActions(tpr.reactor())) { createTriggerT(body, action, triggerMap, constructorCode, types); var isPhysical = "true"; if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { @@ -832,12 +832,12 @@ public static void generateReactionAndTriggerStructs( } // Next handle inputs. - for (Input input : ASTUtils.allInputs(tpr.r())) { + for (Input input : ASTUtils.allInputs(tpr.reactor())) { createTriggerT(body, input, triggerMap, constructorCode, types); } // Next handle watchdogs. - for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.r())) { + for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.reactor())) { createTriggerT(body, watchdog, triggerMap, constructorCode, types); } } @@ -1092,7 +1092,7 @@ init, getCode(types, reaction, tpr) generateDeadlineFunctionHeader(tpr, reactionIndex), init, reaction.getDeadline().getCode())); } - CMethodGenerator.generateMacroUndefsForMethods(tpr.r(), code); + CMethodGenerator.generateMacroUndefsForMethods(tpr.reactor(), code); code.pr( "#include " + StringUtil.addDoubleQuotes( CCoreFilesUtils.getCTargetSetUndefHeader())); diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 20d951b271..00ef4c0faa 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -16,7 +16,6 @@ import org.lflang.lf.Reactor; import org.lflang.lf.StateVar; import org.lflang.lf.TriggerRef; -import org.lflang.lf.Type; import org.lflang.lf.TypedVariable; import org.lflang.lf.VarRef; import org.lflang.util.FileUtil; @@ -31,13 +30,13 @@ public interface GenerateAuxiliaryStructs { /** Return the path to the user-visible header file that would be generated for {@code r}. */ public static Path outputPath(TypeParameterizedReactor tpr) { - return Path.of(Path.of(tpr.r().eResource().getURI().toFileString()) + return Path.of(Path.of(tpr.reactor().eResource().getURI().toFileString()) .getFileName().toString().replaceFirst("[.][^.]+$", "")) .resolve(tpr.getName() + ".h"); } public static void doGenerate(CTypes types, TypeParameterizedReactor tpr, CFileConfig fileConfig, GenerateAuxiliaryStructs generator, Function topLevelPreamble) throws IOException { - String contents = generateHeaderFile(types, tpr, generator, topLevelPreamble.apply(tpr.r())); + String contents = generateHeaderFile(types, tpr, generator, topLevelPreamble.apply(tpr.reactor())); FileUtil.writeToFile(contents, fileConfig.getIncludePath().resolve(outputPath(tpr))); } private static String generateHeaderFile(CTypes types, TypeParameterizedReactor tpr, GenerateAuxiliaryStructs generator, String topLevelPreamble) { @@ -48,7 +47,7 @@ private static String generateHeaderFile(CTypes types, TypeParameterizedReactor tpr.doDefines(builder); appendSelfStruct(builder, types, tpr); generator.generate(builder, tpr, true); - for (Reaction reaction : tpr.r().getReactions()) { + for (Reaction reaction : tpr.reactor().getReactions()) { appendSignature(builder, types, reaction, tpr); } builder.pr("#endif"); @@ -80,10 +79,10 @@ private static String userFacingSelfType(TypeParameterizedReactor tpr) { private static void appendSelfStruct(CodeBuilder builder, CTypes types, TypeParameterizedReactor tpr) { builder.pr("typedef struct " + userFacingSelfType(tpr) + "{"); - for (Parameter p : tpr.r().getParameters()) { + for (Parameter p : tpr.reactor().getParameters()) { builder.pr(types.getTargetType(p) + " " + p.getName() + ";"); } - for (StateVar s : tpr.r().getStateVars()) { + for (StateVar s : tpr.reactor().getStateVars()) { builder.pr(types.getTargetType(s) + " " + s.getName() + ";"); } builder.pr("int end[0]; // placeholder; MSVC does not compile empty structs"); @@ -108,7 +107,7 @@ private static String getApiSelfStruct(TypeParameterizedReactor tpr) { public static String nonInlineInitialization(Reaction r, TypeParameterizedReactor reactor) { var mainDef = LfFactory.eINSTANCE.createInstantiation(); mainDef.setName(reactor.getName()); - mainDef.setReactorClass(ASTUtils.findMainReactor(reactor.r().eResource())); + mainDef.setReactorClass(ASTUtils.findMainReactor(reactor.reactor().eResource())); return portVariableStream(r, reactor) .map(it -> it.container == null ? "" : it.getWidth() == null ? String.format("%s %s = (%s) %s;", it.getType(false), it.getAlias(), it.getType(false), it.getRvalue()) @@ -121,7 +120,7 @@ public static String nonInlineInitialization(Reaction r, TypeParameterizedReacto it.getType(true).replaceFirst("\\*", ""), it.getAlias(), CReactionGenerator.maxContainedReactorBankWidth( - reactor.r().getInstantiations().stream() + reactor.reactor().getInstantiations().stream() .filter(instantiation -> new TypeParameterizedReactor(instantiation).equals(it.r)) .findAny().orElseThrow(), null, 0, mainDef), @@ -164,7 +163,7 @@ String getType(boolean userFacing) { var typeName = container == null ? CGenerator.variableStructType(tv, r, userFacing) : CPortGenerator.localPortName(container.getReactorClass(), getName()); - var isMultiport = ASTUtils.isMultiport(ASTUtils.allPorts(r.r()).stream() + var isMultiport = ASTUtils.isMultiport(ASTUtils.allPorts(r.reactor()).stream() .filter(it -> it.getName().equals(tv.getName())) .findAny().orElseThrow()); return typeName + "*" + (getWidth() != null ? "*" : "") + (isMultiport ? "*" : ""); diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java index 1b75a73ab8..d2e2a56ed8 100644 --- a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java @@ -1,16 +1,9 @@ package org.lflang.generator.c; -import java.util.LinkedList; - import org.lflang.ASTUtils; -import org.lflang.InferredType; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.GeneratorBase; import org.lflang.generator.ModeInstance; import org.lflang.generator.ReactorInstance; -import org.lflang.lf.Expression; -import org.lflang.lf.ParameterReference; -import org.lflang.lf.Reactor; import org.lflang.lf.StateVar; public class CStateGenerator { @@ -21,7 +14,7 @@ public class CStateGenerator { */ public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { CodeBuilder code = new CodeBuilder(); - for (StateVar stateVar : ASTUtils.allStateVars(reactor.r())) { + for (StateVar stateVar : ASTUtils.allStateVars(reactor.reactor())) { code.prSourceLineNumber(stateVar); code.pr(types.getTargetType(reactor.resolveType(ASTUtils.getInferredType(stateVar))) + " " + stateVar.getName() + ";"); } diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index c09f8c63ef..e6f6cbe990 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -141,8 +141,8 @@ public static String channelIndexName(PortInstance port) { * the main reactor or the .lf file). */ public static String getName(TypeParameterizedReactor reactor) { - String name = reactor.r().getName().toLowerCase() + reactor.hashCode(); - if (reactor.r().isMain()) { + String name = reactor.reactor().getName().toLowerCase() + reactor.hashCode(); + if (reactor.reactor().isMain()) { return name + "_main"; } return name; @@ -510,7 +510,7 @@ public static String runtimeIndex(ReactorInstance reactor) { * @return The type of a self struct for the specified reactor class. */ public static String selfType(TypeParameterizedReactor reactor) { - if (reactor.r().isMain()) { + if (reactor.reactor().isMain()) { return "_" + CUtil.getName(reactor) + "_main_self_t"; } return "_" + CUtil.getName(reactor) + "_self_t"; diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 0f38c82c04..856111b559 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -16,7 +16,6 @@ import org.lflang.lf.Mode; import org.lflang.lf.ModeTransition; import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; import org.lflang.lf.VarRef; import org.lflang.lf.Variable; import org.lflang.lf.Watchdog; @@ -95,9 +94,9 @@ protected static int generateInitializeWatchdogs(CodeBuilder code, ReactorInstan protected static void generateWatchdogs( CodeBuilder src, CodeBuilder header, TypeParameterizedReactor tpr, ErrorReporter errorReporter ) { - if (hasWatchdogs(tpr.r())) { + if (hasWatchdogs(tpr.reactor())) { header.pr("#include \"core/threaded/watchdog.h\""); - for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.r())) { + for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.reactor())) { src.pr(generateWatchdogFunction(watchdog, tpr, errorReporter)); } } @@ -112,7 +111,7 @@ protected static void generateWatchdogs( protected static void generateWatchdogStruct( CodeBuilder body, TypeParameterizedReactor tpr, CodeBuilder constructorCode) { - for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.r())) { + for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.reactor())) { String watchdogName = watchdog.getName(); body.pr(watchdog, "watchdog_t _lf_watchdog_" + watchdogName + ";"); @@ -207,7 +206,7 @@ private static String generateInitializationForWatchdog( Variable variable = effect.getVariable(); if (variable instanceof Mode) { // Mode change effect - int idx = ASTUtils.allModes(tpr.r()).indexOf((Mode) effect.getVariable()); + int idx = ASTUtils.allModes(tpr.reactor()).indexOf((Mode) effect.getVariable()); String name = effect.getVariable().getName(); if (idx >= 0) { watchdogInitialization.pr( diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 4e41b700ed..0a10338d56 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -62,8 +62,6 @@ import org.lflang.lf.Port; import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; -import org.lflang.lf.Type; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; import org.lflang.util.StringUtil; @@ -354,13 +352,13 @@ public void processProtoFile(String filename) { public void generateAuxiliaryStructs( CodeBuilder builder, TypeParameterizedReactor tpr, boolean userFacing ) { - for (Input input : ASTUtils.allInputs(tpr.r())) { + for (Input input : ASTUtils.allInputs(tpr.reactor())) { generateAuxiliaryStructsForPort(builder, tpr, input); } - for (Output output : ASTUtils.allOutputs(tpr.r())) { + for (Output output : ASTUtils.allOutputs(tpr.reactor())) { generateAuxiliaryStructsForPort(builder, tpr, output); } - for (Action action : ASTUtils.allActions(tpr.r())) { + for (Action action : ASTUtils.allActions(tpr.reactor())) { generateAuxiliaryStructsForAction(builder, tpr, action); } } @@ -457,7 +455,7 @@ protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { */ @Override protected void generateReaction(CodeBuilder src, Reaction reaction, TypeParameterizedReactor tpr, int reactionIndex) { - Reactor reactor = ASTUtils.toDefinition(tpr.r()); + Reactor reactor = ASTUtils.toDefinition(tpr.reactor()); // Reactions marked with a `@_c_body` attribute are generated in C if (AttributeUtils.hasCBody(reaction)) { From a5536587595035303d271b2653b153782d6d8592 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 12:35:47 -0700 Subject: [PATCH 387/709] Revert "Align to reactor-c main" This reverts commit 4e1076a89ab822013bc839bf93fbd15f025f7192. --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 845daae394..843e147128 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 845daae39479b8c06d15c1215aca575a4728a599 +Subproject commit 843e147128315ffa5216fffd6cba36396c3cd084 From 46b3ace3087b4f7c3f07967b99e04346aee0c325 Mon Sep 17 00:00:00 2001 From: Peter Donovan <33707478+petervdonovan@users.noreply.github.com> Date: Mon, 22 May 2023 12:37:07 -0700 Subject: [PATCH 388/709] Apply suggestions from code review Co-authored-by: Marten Lohstroh --- org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java | 4 ++-- .../src/org/lflang/generator/c/TypeParameterizedReactor.java | 1 - 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index 856111b559..b629684bf7 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -105,7 +105,7 @@ protected static void generateWatchdogs( /** * Generate watchdog definitions in the reactor's self struct. * @param body The place to put the definitions - * @param tpr The reactor declaration + * @param tpr The concrete reactor class * @param constructorCode The place to put initialization code. */ protected static void generateWatchdogStruct( @@ -172,7 +172,7 @@ protected static String generateWatchdogTable(int count) { * Generate necessary initialization code inside the body of a watchdog handler. * * @param watchdog The wotchdog - * @param tpr The declaration for the reactor that has the watchdog + * @param tpr The concrete reactor class that has the watchdog */ private static String generateInitializationForWatchdog( Watchdog watchdog, diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index a1375c61bb..0de272b7bf 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -23,7 +23,6 @@ public TypeParameterizedReactor(Instantiation i) { this(ASTUtils.toDefinition(i.getReactorClass()), addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()))); } - private static Map addTypeArgs(Instantiation instantiation, Reactor r) { HashMap ret = new HashMap<>(); if (instantiation.getTypeArgs() != null) { From 1fef9e6d19b6ca2d1f881fe95589538ae5cd65ac Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 14:42:13 -0700 Subject: [PATCH 389/709] Fix formatting --- test/C/src/concurrent/Watchdog.lf | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/C/src/concurrent/Watchdog.lf b/test/C/src/concurrent/Watchdog.lf index e49b2fcec7..a3c9609503 100644 --- a/test/C/src/concurrent/Watchdog.lf +++ b/test/C/src/concurrent/Watchdog.lf @@ -1,6 +1,6 @@ /** - * Test watchdog. This test starts a watchdog timer of 1500ms every 1s. Half - * the time, it then sleeps after starting the watchdog so that the watchdog + * Test watchdog. This test starts a watchdog timer of 1500ms every 1s. Half the + * time, it then sleeps after starting the watchdog so that the watchdog * expires. There should be a total of two watchdog expirations. * @author Benjamin Asch * @author Edward A. Lee @@ -10,7 +10,7 @@ target C { } reactor Watcher(timeout: time = 1500 ms) { - timer t(1s, 1s) // Offset ameliorates startup time. + timer t(1 s, 1 s) // Offset ameliorates startup time. // Period has to be smaller than watchdog timeout. Produced if the watchdog // triggers. output d: int From 779a08cac8d924dd2326488427336ba242bdfccd Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 14:45:13 -0700 Subject: [PATCH 390/709] Move SpuriousDependency.lf to failing. --- test/C/src/federated/{ => failing}/SpuriousDependency.lf | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/C/src/federated/{ => failing}/SpuriousDependency.lf (100%) diff --git a/test/C/src/federated/SpuriousDependency.lf b/test/C/src/federated/failing/SpuriousDependency.lf similarity index 100% rename from test/C/src/federated/SpuriousDependency.lf rename to test/C/src/federated/failing/SpuriousDependency.lf From 553e9227a5782990afcc15561daa7ba8295c1b31 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 22 May 2023 15:05:53 -0700 Subject: [PATCH 391/709] Added source_reactor pointer to port structs --- org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/org/lflang/generator/c/CPortGenerator.java | 4 ++++ .../src/org/lflang/generator/c/CTriggerObjectsGenerator.java | 1 + 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 1784274083..72da1e1e33 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 17842740830b1fa92eb012a6d007cc78653115b6 +Subproject commit 72da1e1e331a2c27adc53c5ac8739c172c68dfd3 diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index f7e3abc673..d315536139 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -242,6 +242,10 @@ private static void generateInputDeclarations( "self->_lf_"+inputName+" = &self->_lf_default__"+inputName+";" )); } + constructorCode.pr(input, String.join("\n", + "// Set the default source reactor pointer", + "self->_lf_default__"+inputName+"._base.source_reactor = (self_base_t*)self;" + )); } } diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java index d7be245cb1..0767b33bff 100644 --- a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java @@ -717,6 +717,7 @@ private static String deferredOutputNumDestinations( code.pr("// For reference counting, set num_destinations for port " + output.getFullName() + "."); code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); code.pr(CUtil.portRef(output, sr, sb, sc)+"._base.num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); + code.pr(CUtil.portRef(output, sr, sb, sc)+"._base.source_reactor = (self_base_t*)"+CUtil.reactorRef(reactor, sb)+";"); code.endScopedRangeBlock(sendingRange); } } From af0613df01492393020cdf1fd98b674083a99660 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 15:17:24 -0700 Subject: [PATCH 392/709] Fix JavaDoc in CUtil.java --- .../src/org/lflang/generator/c/CUtil.java | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index e6f6cbe990..51348915b9 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -152,23 +152,24 @@ public static String getName(TypeParameterizedReactor reactor) { * Return a reference to the specified port. * * The returned string will have one of the following forms: + *
    + *
  • {@code selfStructs[k]->_lf_portName}
    • + *
  • {@code selfStructs[k]->_lf_portName}
    • + *
  • {@code selfStructs[k]->_lf_portName[i]}
    • + *
  • {@code selfStructs[k]->_lf_parent.portName}
    • + *
  • {@code selfStructs[k]->_lf_parent.portName[i]}
    • + *
  • {@code selfStructs[k]->_lf_parent[j].portName}
    • + *
  • {@code selfStructs[k]->_lf_parent[j].portName[i]}
    • + *
* - * * selfStructs[k]->_lf_portName - * * selfStructs[k]->_lf_portName - * * selfStructs[k]->_lf_portName[i] - * * selfStructs[k]->_lf_parent.portName - * * selfStructs[k]->_lf_parent.portName[i] - * * selfStructs[k]->_lf_parent[j].portName - * * selfStructs[k]->_lf_parent[j].portName[i] - * - * where k is the runtime index of either the port's parent - * or the port's parent's parent, the latter when isNested is true. - * The index j is present if the parent is a bank, and - * the index i is present if the port is a multiport. + * where {@code k} is the runtime index of either the port's parent + * or the port's parent's parent, the latter when isNested is {@code true}. + * The index {@code j} is present if the parent is a bank, and + * the index {@code i} is present if the port is a multiport. * * The first two forms are used if isNested is false, * and the remaining four are used if isNested is true. - * Set isNested to true when referencing a port belonging + * Set {@code isNested} to {@code true} when referencing a port belonging * to a contained reactor. * * @param port The port. From d6417278ef983d781ae9b447b3c54d52e628a342 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 15:30:02 -0700 Subject: [PATCH 393/709] Fix JavaDoc in RuntimeRange.java --- .../org/lflang/generator/RuntimeRange.java | 48 +++++++++---------- 1 file changed, 23 insertions(+), 25 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/RuntimeRange.java b/org.lflang/src/org/lflang/generator/RuntimeRange.java index 219d24eb67..449e6dedf9 100644 --- a/org.lflang/src/org/lflang/generator/RuntimeRange.java +++ b/org.lflang/src/org/lflang/generator/RuntimeRange.java @@ -36,10 +36,11 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * (port channels, reactors, reactions, etc.). This class and its derived classes * have the most detailed information about the structure of a Lingua Franca * program. There are three levels of detail: - * - * * The abstract syntax tree (AST). - * * The compile-time instance graph (CIG). - * * The runtime instance graph (RIG). + *
    + *
  • The abstract syntax tree (AST).
    • + *
  • The compile-time instance graph (CIG).
    • + *
  • The runtime instance graph (RIG).
    • + *
* * In the AST, each reactor class is represented once. * In the CIG, each reactor class is represented as many times as it is @@ -340,38 +341,35 @@ public boolean overlaps(RuntimeRange range) { /** * Return a set of identifiers for runtime instances of a parent of this - * RuntimeRange's instance n levels above this RuntimeRange's instance. If n == 1, for + * {@link RuntimeRange}'s instance {@code n} levels above this {@link RuntimeRange}'s instance. If {@code n == 1}, for * example, then this return the identifiers for the parent ReactorInstance. * - * This returns a list of **natural identifiers**, + * This returns a list of natural identifiers, * as defined below, for the instances within the range. * * The resulting list can be used to count the number of distinct - * runtime instances of this RuntimeRange's instance (using n == 0) or any of its parents that + * runtime instances of this RuntimeRange's instance (using {@code n == 0}) or any of its parents that * lie within the range and to provide an index into an array of runtime * instances. * - * Each **natural identifier** is the integer value of a mixed-radix number + * Each natural identifier is the integer value of a mixed-radix number * defined as follows: - * - * * The low-order digit is the index of the runtime instance of i - * within its container. If the NamedInstance - * is a PortInstance, this will be the multiport channel or 0 if it is not a + *
    + *
  • The low-order digit is the index of the runtime instance of {@code i} within its container. + * If the {@link NamedInstance} is a {@code PortInstance}, this will be the multiport channel or {@code 0} if it is not a * multiport. If the NamedInstance is a ReactorInstance, then it will be the bank - * index or 0 if the reactor is not a bank. The radix for this digit will be + * index or {@code 0} if the reactor is not a bank. The radix for this digit will be * the multiport width or bank width or 1 if the NamedInstance is neither a - * multiport nor a bank. - * - * * The next digit will be the bank index of the container of the specified - * NamedInstance or 0 if it is not a bank. - * - * * The remaining digits will be bank indices of containers up to but not - * including the top-level reactor (there is no point in including the top-level - * reactor because it is never a bank). - * - * Each index that is returned can be used as an index into an array of - * runtime instances that is assumed to be in a **natural order**. - * + * multiport nor a bank.
    • + *
  • The next digit will be the bank index of the container of the specified + * {@link NamedInstance} or {@code 0} if it is not a bank.
    • + *
  • The remaining digits will be bank indices of containers up to but not + * including the top-level reactor (there is no point in including the top-level + * reactor because it is never a bank).
    • + *
  • Each index that is returned can be used as an index into an array of + * runtime instances that is assumed to be in a natural order.
    • + *
+ * * @param n The number of levels up of the parent. This is required to be * less than the depth of this RuntimeRange's instance or an exception will be thrown. */ From 3001a6816e16bdc171f231137e44bad47251d92d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 15:32:26 -0700 Subject: [PATCH 394/709] Fix JavaDoc in ReactionInstance.java --- .../src/org/lflang/generator/ReactionInstance.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/src/org/lflang/generator/ReactionInstance.java index cf9dce7013..c904a39127 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstance.java @@ -416,18 +416,18 @@ public String getName() { /** * Return an array of runtime instances of this reaction in a - * **natural order**, defined as follows. The position within the + * natural order, defined as follows. The position within the * returned list of the runtime instance is given by a mixed-radix * number where the low-order digit is the bank index within the - * container reactor (or 0 if it is not a bank), the second low order - * digit is the bank index of the container's container (or 0 if + * container reactor (or {@code 0} if it is not a bank), the second low order + * digit is the bank index of the container's container (or {@code 0} if * it is not a bank), etc., until the container that is directly * contained by the top level (the top-level reactor need not be - * included because its index is always 0). + * included because its index is always {@code 0}). * * The size of the returned array is the product of the widths of all of the - * container ReactorInstance objects. If none of these is a bank, - * then the size will be 1. + * container {@link ReactorInstance} objects. If none of these is a bank, + * then the size will be {@code 1}. * * This method creates this array the first time it is called, but then * holds on to it. The array is used by {@link ReactionInstanceGraph} From 0a02978ba0728b12302216911a0da3fd5d90ba0e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 15:32:46 -0700 Subject: [PATCH 395/709] Move AstUtils and AstExtensions. Edit JavaDoc in CGeneraor, CodeBuilder. --- .../src/org/lflang/tests/RuntimeTest.java | 2 +- .../tests/compiler/LetInferenceTests.java | 4 +- .../compiler/LinguaFrancaASTUtilsTest.java | 56 +-- .../LinguaFrancaDependencyAnalysisTest.java | 45 +- .../org/lflang/tests/runtime/CCppTest.java | 2 +- .../org/lflang/tests/runtime/CppRos2Test.java | 3 +- org.lflang/src/org/lflang/AttributeUtils.java | 1 + org.lflang/src/org/lflang/InferredType.java | 17 +- org.lflang/src/org/lflang/ModelInfo.java | 1 + org.lflang/src/org/lflang/TargetProperty.java | 3 +- .../src/org/lflang/{ => ast}/ASTUtils.java | 9 +- .../src/org/lflang/{ => ast}/AstExtensions.kt | 1 + .../ast/DelayedConnectionTransformation.java | 3 - .../src/org/lflang/ast/FormattingUtils.java | 2 - org.lflang/src/org/lflang/ast/ToLf.java | 2 +- org.lflang/src/org/lflang/ast/ToText.java | 4 - org.lflang/src/org/lflang/cli/Lfc.java | 3 +- .../synthesis/LinguaFrancaSynthesis.java | 397 +++++++++--------- .../styles/LinguaFrancaShapeExtensions.java | 384 ++++++++--------- .../federated/extensions/CExtension.java | 2 +- .../federated/extensions/CExtensionUtils.java | 2 +- .../federated/extensions/PythonExtension.java | 2 +- .../federated/extensions/TSExtension.java | 4 +- .../federated/generator/FedASTUtils.java | 2 +- .../federated/generator/FedGenerator.java | 2 +- .../federated/generator/FedMainEmitter.java | 11 +- .../generator/FedPreambleEmitter.java | 5 +- .../federated/generator/FedTargetConfig.java | 2 +- .../federated/generator/FederateInstance.java | 2 +- .../federated/validation/FedValidator.java | 2 +- .../src/org/lflang/generator/CodeBuilder.java | 33 +- .../org/lflang/generator/GeneratorBase.java | 2 +- .../org/lflang/generator/GeneratorUtils.java | 2 +- .../src/org/lflang/generator/LFGenerator.java | 2 +- .../lflang/generator/ParameterInstance.java | 42 +- .../lflang/generator/ReactionInstance.java | 54 +-- .../org/lflang/generator/ReactorInstance.java | 4 +- .../src/org/lflang/generator/TargetTypes.java | 2 +- .../lflang/generator/c/CActionGenerator.java | 2 +- .../generator/c/CDelayBodyGenerator.java | 4 +- .../org/lflang/generator/c/CGenerator.java | 311 ++++++-------- .../lflang/generator/c/CMethodGenerator.java | 4 +- .../lflang/generator/c/CModesGenerator.java | 2 +- .../generator/c/CParameterGenerator.java | 2 +- .../lflang/generator/c/CPortGenerator.java | 2 +- .../generator/c/CReactionGenerator.java | 2 +- .../c/CReactorHeaderFileGenerator.java | 2 +- .../lflang/generator/c/CStateGenerator.java | 2 +- .../generator/c/CTriggerObjectsGenerator.java | 5 +- .../generator/c/CWatchdogGenerator.java | 2 +- .../c/InteractingContainedReactors.java | 2 +- .../generator/c/TypeParameterizedReactor.java | 2 +- .../org/lflang/generator/python/PyUtil.java | 3 - .../python/PythonDelayBodyGenerator.java | 3 +- .../generator/python/PythonGenerator.java | 2 +- .../python/PythonMethodGenerator.java | 2 +- .../python/PythonParameterGenerator.java | 11 +- .../generator/python/PythonPortGenerator.java | 3 +- .../python/PythonPreambleGenerator.java | 2 +- .../python/PythonReactionGenerator.java | 3 +- .../python/PythonReactorGenerator.java | 4 +- .../python/PythonStateGenerator.java | 3 +- .../generator/rust/CargoDependencySpec.java | 2 +- .../org/lflang/generator/rust/RustModel.kt | 3 +- .../org/lflang/generator/rust/RustTypes.kt | 2 +- .../generator/ts/TSDelayBodyGenerator.kt | 3 +- .../generator/ts/TSReactionGenerator.kt | 6 +- .../lflang/generator/ts/TSStateGenerator.kt | 2 +- .../src/org/lflang/generator/ts/TSTypes.java | 2 +- .../org/lflang/graph/InstantiationGraph.java | 2 +- .../lflang/scoping/LFScopeProviderImpl.java | 2 +- .../org/lflang/validation/AttributeSpec.java | 2 +- .../lflang/validation/BaseLFValidator.java | 12 +- .../org/lflang/validation/LFValidator.java | 17 +- 74 files changed, 739 insertions(+), 812 deletions(-) rename org.lflang/src/org/lflang/{ => ast}/ASTUtils.java (99%) rename org.lflang/src/org/lflang/{ => ast}/AstExtensions.kt (99%) diff --git a/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java b/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java index 7011b5ed96..77bc6d8034 100644 --- a/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java +++ b/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java @@ -5,7 +5,7 @@ import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Test; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.Target; import org.lflang.tests.TestRegistry.TestCategory; diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java index a78d41ac4d..b3e7814f96 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java @@ -25,7 +25,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ***************/ -import static org.lflang.ASTUtils.toDefinition; +import static org.lflang.ast.ASTUtils.toDefinition; import javax.inject.Inject; @@ -38,7 +38,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.DefaultErrorReporter; import org.lflang.TimeUnit; import org.lflang.TimeValue; diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java index 918c2c56c2..9c020c0afa 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java @@ -13,21 +13,21 @@ this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +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. ***************/ package org.lflang.tests.compiler; -import static org.lflang.ASTUtils.isInitialized; +import static org.lflang.ast.ASTUtils.isInitialized; import static org.lflang.util.IteratorUtil.asStream; import java.util.List; @@ -42,7 +42,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Instantiation; import org.lflang.lf.Literal; import org.lflang.lf.Model; @@ -52,7 +52,7 @@ /** * Collection of unit tests on the ASTutils. - * + * * @author Christian Menard */ @@ -62,7 +62,7 @@ class LinguaFrancaASTUtilsTest { @Inject ParseHelper parser; - + /** * Test that isInititialized returns true for inititialized state variables */ @@ -82,7 +82,7 @@ public void initializedState() throws Exception { // Java 11: Model model = parser.parse(String.join( System.getProperty("line.separator"), - "target Cpp;", + "target Cpp;", "main reactor {", " state a();", " state b:int(3);", @@ -91,21 +91,21 @@ public void initializedState() throws Exception { " state e(1 sec, 2 sec, 3 sec);", "}" )); - + Assertions.assertNotNull(model); Assertions.assertTrue(model.eResource().getErrors().isEmpty(), "Encountered unexpected error while parsing: " + model.eResource().getErrors()); - + model.eAllContents().forEachRemaining((obj) -> { if (obj instanceof StateVar) { Assertions.assertTrue(isInitialized((StateVar)obj)); } }); } - + /** * Test that isInititialized returns false for uninititialized state variables */ @@ -125,7 +125,7 @@ public void uninitializedState() throws Exception { // Java 11: Model model = parser.parse(String.join( System.getProperty("line.separator"), - "target Cpp;", + "target Cpp;", "main reactor {", " state a;", " state b:int;", @@ -134,7 +134,7 @@ public void uninitializedState() throws Exception { " state e:time;", "}" )); - + Assertions.assertNotNull(model); Assertions.assertTrue(model.eResource().getErrors().isEmpty(), "Encountered unexpected error while parsing: " + @@ -149,7 +149,7 @@ public void uninitializedState() throws Exception { } /** * Return a map from strings to instantiations given a model. - * + * * @param model The model to discover instantiations in. */ private Map getInsts(Model model) { @@ -158,7 +158,7 @@ private Map getInsts(Model model) { .map(obj -> (Instantiation) obj) .collect(Collectors.toMap(Instantiation::getName, it -> it)); } - + /** * Test reading initial values of parameters. * This checks that the example given in the documentation of the @@ -167,7 +167,7 @@ private Map getInsts(Model model) { @Test public void initialValue() throws Exception { -// Java 17: +// Java 17: // Model model = parser.parse(""" // target C; // reactor A(x:int(1)) {} @@ -181,11 +181,11 @@ public void initialValue() throws Exception { // } // """ // Java 11: - + Model model = parser.parse(String.join( System.getProperty("line.separator"), "target C;", - "reactor A(x:int(1)) {}", + "reactor A(x:int(1)) {}", "reactor B(y:int(2)) {", " a1 = new A(x = y);", " a2 = new A(x = -1);", @@ -195,14 +195,14 @@ public void initialValue() throws Exception { " b2 = new B(y = -2);", "}" )); - + Assertions.assertNotNull(model); Assertions.assertTrue(model.eResource().getErrors().isEmpty(), "Encountered unexpected error while parsing: " + model.eResource().getErrors()); - + var map = getInsts(model); - + /* Check for this: * initialValue(x, null) returns 1 * initialValue(x, [a1]) returns 2 @@ -211,13 +211,13 @@ public void initialValue() throws Exception { * initialValue(x, [a2, b1]) returns -1 * initialValue(x, [a1, b2]) returns -2 * initialValue(x, [a2, b2]) returns -1 - * + * * initialValue(y, null) returns 2 * initialValue(y, [a1]) throws an IllegalArgumentException * initialValue(y, [b1]) returns 3 * initialValue(y, [b2]) returns -2 */ - + model.eAllContents().forEachRemaining((obj) -> { if (obj instanceof Parameter) { Parameter parameter = (Parameter)obj; diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java index ef41bd521b..d7e2af48fc 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java @@ -13,15 +13,15 @@ this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +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. ***************/ package org.lflang.tests.compiler; @@ -30,7 +30,6 @@ import org.eclipse.emf.common.util.TreeIterator; import org.eclipse.emf.ecore.EObject; -import org.eclipse.xtext.EOF; import org.eclipse.xtext.testing.InjectWith; import org.eclipse.xtext.testing.extensions.InjectionExtension; import org.eclipse.xtext.testing.util.ParseHelper; @@ -45,7 +44,7 @@ import org.lflang.lf.Model; import org.lflang.lf.Reactor; import org.lflang.tests.LFInjectorProvider; -import static org.lflang.ASTUtils.*; +import static org.lflang.ast.ASTUtils.*; @ExtendWith(InjectionExtension.class) @InjectWith(LFInjectorProvider.class) @@ -57,7 +56,7 @@ class LinguaFrancaDependencyAnalysisTest { @Inject ParseHelper parser; - + /** * Check that circular dependencies between reactions are detected. */ @@ -66,27 +65,27 @@ public void cyclicDependency() throws Exception { // Java 17: // String testCase = """ // target C; -// +// // reactor Clock { // timer t(0, 10 msec); // input x:int; // output y:int; // reaction(t) -> y {= -// +// // =} // reaction(x) -> y {= -// +// // =} // } -// +// // reactor A { // input x:int; // output y:int; // reaction(x) -> y {= -// +// // =} // } -// +// // main reactor Loop { // c = new Clock(); // a = new A(); @@ -126,7 +125,7 @@ public void cyclicDependency() throws Exception { "}" ); Model model = parser.parse(testCase); - + Assertions.assertNotNull(model); Instantiation mainDef = null; TreeIterator it = model.eResource().getAllContents(); @@ -137,7 +136,7 @@ public void cyclicDependency() throws Exception { } Reactor reactor = (Reactor) obj; if (reactor.isMain()) { - // Creating an definition for the main reactor because + // Creating an definition for the main reactor because // there isn't one. mainDef = LfFactory.eINSTANCE.createInstantiation(); mainDef.setName(reactor.getName()); @@ -169,13 +168,13 @@ public void circularInstantiation() throws Exception { } """; Model model = parser.parse(testCase); - + Assertions.assertNotNull(model); - + ModelInfo info = new ModelInfo(); info.update(model, new DefaultErrorReporter()); - Assertions.assertTrue(info.instantiationGraph.hasCycles() == true, + Assertions.assertTrue(info.instantiationGraph.hasCycles() == true, "Did not detect cyclic instantiation."); } - + } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java index 17fd386ad8..c8c2fc5b93 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java @@ -2,7 +2,7 @@ import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Test; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.Target; import org.lflang.tests.TestBase; import org.lflang.tests.TestRegistry.TestCategory; diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java b/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java index f3b20ee36f..2e4f6b78d3 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java @@ -3,12 +3,11 @@ import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Test; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.Target; import org.lflang.lf.Element; import org.lflang.lf.LfFactory; import org.lflang.tests.TestBase; -import org.lflang.tests.TestRegistry.TestCategory; /** * Run C++ tests using the ROS2 platform. diff --git a/org.lflang/src/org/lflang/AttributeUtils.java b/org.lflang/src/org/lflang/AttributeUtils.java index ec5edc4b9d..f5077f2d13 100644 --- a/org.lflang/src/org/lflang/AttributeUtils.java +++ b/org.lflang/src/org/lflang/AttributeUtils.java @@ -33,6 +33,7 @@ import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.eclipse.xtext.resource.XtextResource; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Action; import org.lflang.lf.AttrParm; import org.lflang.lf.Attribute; diff --git a/org.lflang/src/org/lflang/InferredType.java b/org.lflang/src/org/lflang/InferredType.java index 3a9a8712aa..41931e0e32 100644 --- a/org.lflang/src/org/lflang/InferredType.java +++ b/org.lflang/src/org/lflang/InferredType.java @@ -11,15 +11,15 @@ this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +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. ***************/ @@ -29,6 +29,7 @@ import org.eclipse.emf.ecore.EObject; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Type; /** diff --git a/org.lflang/src/org/lflang/ModelInfo.java b/org.lflang/src/org/lflang/ModelInfo.java index fbe5c2047c..24d5c447c2 100644 --- a/org.lflang/src/org/lflang/ModelInfo.java +++ b/org.lflang/src/org/lflang/ModelInfo.java @@ -36,6 +36,7 @@ import java.util.List; import java.util.Set; +import org.lflang.ast.ASTUtils; import org.lflang.generator.NamedInstance; import org.lflang.generator.ReactorInstance; import org.lflang.graph.InstantiationGraph; diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index 25445a3e37..ac3c183e3c 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -38,6 +38,7 @@ import org.lflang.TargetConfig.DockerOptions; import org.lflang.TargetConfig.PlatformOptions; import org.lflang.TargetConfig.TracingOptions; +import org.lflang.ast.ASTUtils; import org.lflang.generator.InvalidLfSourceException; import org.lflang.generator.rust.CargoDependencySpec; import org.lflang.generator.rust.CargoDependencySpec.CargoDependenciesPropertyType; @@ -407,7 +408,7 @@ public enum TargetProperty { /** * Directive to specify the platform for cross code generation. This is either a string of the platform - * or a dictionary of options that includes the string name. + * or a dictionary of options that includes the string name. */ PLATFORM("platform", UnionType.PLATFORM_STRING_OR_DICTIONARY, Target.ALL, (config) -> { diff --git a/org.lflang/src/org/lflang/ASTUtils.java b/org.lflang/src/org/lflang/ast/ASTUtils.java similarity index 99% rename from org.lflang/src/org/lflang/ASTUtils.java rename to org.lflang/src/org/lflang/ast/ASTUtils.java index 7b747b0adb..f6dba5bf4d 100644 --- a/org.lflang/src/org/lflang/ASTUtils.java +++ b/org.lflang/src/org/lflang/ast/ASTUtils.java @@ -23,7 +23,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package org.lflang; +package org.lflang.ast; import java.util.ArrayList; import java.util.Collection; @@ -54,10 +54,13 @@ import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.IteratorExtensions; import org.eclipse.xtext.xbase.lib.StringExtensions; -import org.lflang.ast.ToText; + +import org.lflang.InferredType; +import org.lflang.Target; +import org.lflang.TimeUnit; +import org.lflang.TimeValue; import org.lflang.generator.CodeMap; import org.lflang.generator.InvalidSourceException; -import org.lflang.generator.NamedInstance; import org.lflang.generator.ReactorInstance; import org.lflang.generator.c.CUtil; import org.lflang.generator.c.TypeParameterizedReactor; diff --git a/org.lflang/src/org/lflang/AstExtensions.kt b/org.lflang/src/org/lflang/ast/AstExtensions.kt similarity index 99% rename from org.lflang/src/org/lflang/AstExtensions.kt rename to org.lflang/src/org/lflang/ast/AstExtensions.kt index 8f065d530f..26678a2273 100644 --- a/org.lflang/src/org/lflang/AstExtensions.kt +++ b/org.lflang/src/org/lflang/ast/AstExtensions.kt @@ -27,6 +27,7 @@ package org.lflang import org.eclipse.emf.ecore.EObject import org.eclipse.emf.ecore.resource.Resource import org.eclipse.xtext.nodemodel.util.NodeModelUtils +import org.lflang.ast.ASTUtils import org.lflang.lf.* /** diff --git a/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java b/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java index 85793084d3..9a39b803a9 100644 --- a/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java +++ b/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java @@ -12,9 +12,7 @@ import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.IteratorExtensions; -import org.eclipse.xtext.xbase.lib.StringExtensions; -import org.lflang.ASTUtils; import org.lflang.InferredType; import org.lflang.generator.DelayBodyGenerator; import org.lflang.generator.TargetTypes; @@ -23,7 +21,6 @@ import org.lflang.lf.Assignment; import org.lflang.lf.Code; import org.lflang.lf.Connection; -import org.lflang.lf.Expression; import org.lflang.lf.Initializer; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; diff --git a/org.lflang/src/org/lflang/ast/FormattingUtils.java b/org.lflang/src/org/lflang/ast/FormattingUtils.java index 0e148f218b..860e3d6bb2 100644 --- a/org.lflang/src/org/lflang/ast/FormattingUtils.java +++ b/org.lflang/src/org/lflang/ast/FormattingUtils.java @@ -11,10 +11,8 @@ import org.eclipse.emf.ecore.EObject; -import org.lflang.ASTUtils; import org.lflang.Target; import org.lflang.lf.Model; -import org.lflang.lf.TargetDecl; /** * Utility functions that determine the specific behavior of the LF formatter. diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index 763ae8266c..7ecf04684f 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -20,7 +20,7 @@ import org.eclipse.xtext.nodemodel.INode; import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.eclipse.xtext.xbase.lib.StringExtensions; -import org.lflang.ASTUtils; + import org.lflang.Target; import org.lflang.ast.MalleableString.Builder; import org.lflang.ast.MalleableString.Joiner; diff --git a/org.lflang/src/org/lflang/ast/ToText.java b/org.lflang/src/org/lflang/ast/ToText.java index 0b703ccbe8..4d02d4ed08 100644 --- a/org.lflang/src/org/lflang/ast/ToText.java +++ b/org.lflang/src/org/lflang/ast/ToText.java @@ -1,14 +1,10 @@ package org.lflang.ast; -import java.util.regex.Pattern; - import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.nodemodel.ICompositeNode; import org.eclipse.xtext.nodemodel.ILeafNode; -import org.eclipse.xtext.nodemodel.INode; import org.eclipse.xtext.nodemodel.util.NodeModelUtils; -import org.lflang.ASTUtils; import org.lflang.lf.ArraySpec; import org.lflang.lf.BracedListExpression; import org.lflang.lf.Code; diff --git a/org.lflang/src/org/lflang/cli/Lfc.java b/org.lflang/src/org/lflang/cli/Lfc.java index 74d9eac8da..3ef52e54a0 100644 --- a/org.lflang/src/org/lflang/cli/Lfc.java +++ b/org.lflang/src/org/lflang/cli/Lfc.java @@ -13,14 +13,13 @@ import org.eclipse.xtext.generator.JavaIoFileSystemAccess; import org.eclipse.xtext.util.CancelIndicator; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.FileConfig; import org.lflang.TargetProperty.UnionType; import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFGeneratorContext.BuildParm; import org.lflang.generator.MainContext; -import org.lflang.generator.ReactorInstance; import com.google.inject.Inject; diff --git a/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java b/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java index 1497ee6644..2b1a2a1bf6 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java @@ -11,15 +11,15 @@ * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +* 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. ***************/ package org.lflang.diagram.synthesis; @@ -62,11 +62,10 @@ import org.eclipse.xtext.xbase.lib.ListExtensions; import org.eclipse.xtext.xbase.lib.Pair; import org.eclipse.xtext.xbase.lib.StringExtensions; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.InferredType; import org.lflang.ast.FormattingUtils; -import org.lflang.ast.ToText; import org.lflang.diagram.synthesis.action.CollapseAllReactorsAction; import org.lflang.diagram.synthesis.action.ExpandAllReactorsAction; import org.lflang.diagram.synthesis.action.FilterCycleAction; @@ -136,7 +135,7 @@ /** * Diagram synthesis for Lingua Franca programs. - * + * * @author Alexander Schulz-Rosengarten */ @ViewSynthesisShared @@ -157,9 +156,9 @@ public class LinguaFrancaSynthesis extends AbstractDiagramSynthesis { @Inject @Extension private ReactorIcons _reactorIcons; @Inject @Extension private ModeDiagrams _modeDiagrams; @Inject @Extension private LayoutPostProcessing _layoutPostProcessing; - + // ------------------------------------------------------------------------- - + public static final String ID = "org.lflang.diagram.synthesis.LinguaFrancaSynthesis"; // -- INTERNAL -- @@ -168,10 +167,10 @@ public class LinguaFrancaSynthesis extends AbstractDiagramSynthesis { public static final Property REACTOR_INPUT = new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.input", false); public static final Property REACTOR_OUTPUT = new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.output", false); public static final Property REACTION_SPECIAL_TRIGGER = new Property<>("org.lflang.linguafranca.diagram.synthesis.reaction.special.trigger", false); - - // -- STYLE -- + + // -- STYLE -- public static final List ALTERNATIVE_DASH_PATTERN = List.of(3.0f); - + // -- TEXT -- public static final String TEXT_ERROR_RECURSIVE = "Recursive reactor instantiation!"; public static final String TEXT_ERROR_CONTAINS_RECURSION = "Reactor contains recursive instantiation!"; @@ -184,18 +183,18 @@ public class LinguaFrancaSynthesis extends AbstractDiagramSynthesis { public static final String TEXT_REACTOR_NULL = "Reactor is null"; public static final String TEXT_HIDE_ACTION = "[Hide]"; public static final String TEXT_SHOW_ACTION = "[Details]"; - + // ------------------------------------------------------------------------- - + /** Synthesis category */ public static final SynthesisOption APPEARANCE = SynthesisOption.createCategory("Appearance", true); public static final SynthesisOption EXPERIMENTAL = SynthesisOption.createCategory("Experimental", true); public static final SynthesisOption LAYOUT = SynthesisOption.createCategory("Layout", false).setCategory(LinguaFrancaSynthesis.APPEARANCE); - + /** Synthesis options */ public static final SynthesisOption SHOW_ALL_REACTORS = SynthesisOption.createCheckOption("All Reactors", false); public static final SynthesisOption CYCLE_DETECTION = SynthesisOption.createCheckOption("Dependency Cycle Detection", true); - + public static final SynthesisOption SHOW_USER_LABELS = SynthesisOption.createCheckOption("User Labels (@label in JavaDoc)", true).setCategory(APPEARANCE); public static final SynthesisOption SHOW_HYPERLINKS = SynthesisOption.createCheckOption("Expand/Collapse Hyperlinks", false).setCategory(APPEARANCE); public static final SynthesisOption REACTIONS_USE_HYPEREDGES = SynthesisOption.createCheckOption("Bundled Dependencies", false).setCategory(APPEARANCE); @@ -210,13 +209,13 @@ public class LinguaFrancaSynthesis extends AbstractDiagramSynthesis { public static final SynthesisOption REACTOR_PARAMETER_MODE = SynthesisOption.createChoiceOption("Reactor Parameters", ((List)Conversions.doWrapArray(ReactorParameterDisplayModes.values())), ReactorParameterDisplayModes.NONE).setCategory(APPEARANCE); public static final SynthesisOption SHOW_STATE_VARIABLES = SynthesisOption.createCheckOption("Reactor State Variables", false).setCategory(APPEARANCE); public static final SynthesisOption REACTOR_BODY_TABLE_COLS = SynthesisOption.createRangeOption("Reactor Parameter/Variable Columns", 1, 10, 1).setCategory(APPEARANCE); - + public static final SynthesisOption SPACING = SynthesisOption.createRangeOption("Spacing (%)", 0, 150, 5, 75).setCategory(LAYOUT); - + /** Synthesis actions */ public static final DisplayedActionData COLLAPSE_ALL = DisplayedActionData.create(CollapseAllReactorsAction.ID, "Hide all Details"); public static final DisplayedActionData EXPAND_ALL = DisplayedActionData.create(ExpandAllReactorsAction.ID, "Show all Details"); - + @Override public List getDisplayedSynthesisOptions() { return List.of( @@ -247,14 +246,14 @@ public List getDisplayedSynthesisOptions() { SPACING ); } - + @Override public List getDisplayedActions() { return List.of(COLLAPSE_ALL, EXPAND_ALL); } - + // ------------------------------------------------------------------------- - + @Override public KNode transform(final Model model) { KNode rootNode = _kNodeExtensions.createNode(); @@ -273,22 +272,22 @@ public KNode transform(final Model model) { _linguaFrancaShapeExtensions.addErrorMessage(messageNode, TEXT_NO_MAIN_REACTOR, null); rootNode.getChildren().add(messageNode); } - + // Show all reactors if (main == null || getBooleanValue(SHOW_ALL_REACTORS)) { List reactorNodes = new ArrayList<>(); for (Reactor reactor : model.getReactors()) { if (reactor == main) continue; ReactorInstance reactorInstance = new ReactorInstance(reactor, new SynthesisErrorReporter()); - reactorNodes.addAll(createReactorNode(reactorInstance, main == null, - HashBasedTable.create(), - HashBasedTable.create(), + reactorNodes.addAll(createReactorNode(reactorInstance, main == null, + HashBasedTable.create(), + HashBasedTable.create(), new HashMap<>())); } if (!reactorNodes.isEmpty()) { // To allow ordering, we need box layout but we also need layered layout for ports thus wrap all node reactorNodes.add(0, IterableExtensions.head(rootNode.getChildren())); - + int index = 0; for (KNode node : reactorNodes) { // Element could be null if there is no main reactor and Show All Reactors is checked. @@ -310,23 +309,23 @@ public KNode transform(final Model model) { rootNode.getChildren().add(child); index++; } - + setLayoutOption(rootNode, CoreOptions.ALGORITHM, BoxLayouterOptions.ALGORITHM_ID); setLayoutOption(rootNode, CoreOptions.SPACING_NODE_NODE, 25.0); } } } catch (Exception e) { e.printStackTrace(); - + KNode messageNode = _kNodeExtensions.createNode(); - _linguaFrancaShapeExtensions.addErrorMessage(messageNode, "Error in Diagram Synthesis", + _linguaFrancaShapeExtensions.addErrorMessage(messageNode, "Error in Diagram Synthesis", e.getClass().getSimpleName() + " occurred. Could not create diagram."); rootNode.getChildren().add(messageNode); } return rootNode; } - + private Collection createReactorNode( ReactorInstance reactorInstance, boolean expandDefault, @@ -341,7 +340,7 @@ private Collection createReactorNode( _utilityExtensions.setID(node, reactorInstance.uniqueID()); // save to distinguish nodes associated with the same reactor NamedInstanceUtil.linkInstance(node, reactorInstance); - + List nodes = new ArrayList<>(); nodes.add(node); String label = createReactorLabel(reactorInstance); @@ -352,28 +351,28 @@ private Collection createReactorNode( // Mark root allReactorNodes.get(reactorInstance.root()).setProperty(REACTOR_RECURSIVE_INSTANTIATION, true); } - + if (reactor == null) { _linguaFrancaShapeExtensions.addErrorMessage(node, TEXT_REACTOR_NULL, null); } else if (reactorInstance.isMainOrFederated()) { KRoundedRectangle figure = _linguaFrancaShapeExtensions.addMainReactorFigure(node, reactorInstance, label); - - if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TABLE + + if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TABLE && !reactorInstance.parameters.isEmpty() ) { KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(figure); _kRenderingExtensions.setInvisible(rectangle, true); _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, 6, 0, + _kRenderingExtensions.TOP, 0, 0), + _kRenderingExtensions.RIGHT, 6, 0, _kRenderingExtensions.BOTTOM, 4, 0); _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); addParameterList(rectangle, reactorInstance.parameters); } - + if (getBooleanValue(SHOW_STATE_VARIABLES)) { var variables = ASTUtils.collectElements(reactor, LfPackage.eINSTANCE.getReactor_StateVars(), true, false); if (!variables.isEmpty()) { @@ -381,10 +380,10 @@ private Collection createReactorNode( _kRenderingExtensions.setInvisible(rectangle, true); _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, 6, 0, + _kRenderingExtensions.TOP, 0, 0), + _kRenderingExtensions.RIGHT, 6, 0, _kRenderingExtensions.BOTTOM, 4, 0); _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); addStateVariableList(rectangle, variables); @@ -396,9 +395,9 @@ private Collection createReactorNode( _linguaFrancaStyleExtensions.errorStyle(figure); } else { _kContainerRenderingExtensions.addChildArea(figure); - node.getChildren().addAll(transformReactorNetwork(reactorInstance, - new HashMap<>(), - new HashMap<>(), + node.getChildren().addAll(transformReactorNetwork(reactorInstance, + new HashMap<>(), + new HashMap<>(), allReactorNodes)); } Iterables.addAll(nodes, createUserComments(reactor, node)); @@ -406,7 +405,7 @@ private Collection createReactorNode( _layoutPostProcessing.configureMainReactor(node); } else { ReactorInstance instance = reactorInstance; - + // Expanded Rectangle ReactorFigureComponents comps = _linguaFrancaShapeExtensions.addReactorFigure(node, reactorInstance, label); comps.getOuter().setProperty(KlighdProperties.EXPANDED_RENDERING, true); @@ -415,46 +414,46 @@ private Collection createReactorNode( _kRenderingExtensions.addDoubleClickAction(figure, MemorizingExpandCollapseAction.ID); } _reactorIcons.handleIcon(comps.getReactor(), reactor, false); - + if (getBooleanValue(SHOW_HYPERLINKS)) { // Collapse button KText button = _linguaFrancaShapeExtensions.addTextButton(comps.getReactor(), TEXT_HIDE_ACTION); _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(button), - _kRenderingExtensions.LEFT, 8, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 8, 0, + _kRenderingExtensions.setGridPlacementData(button), + _kRenderingExtensions.LEFT, 8, 0, + _kRenderingExtensions.TOP, 0, 0), + _kRenderingExtensions.RIGHT, 8, 0, _kRenderingExtensions.BOTTOM, 0, 0); _kRenderingExtensions.addSingleClickAction(button, MemorizingExpandCollapseAction.ID); _kRenderingExtensions.addDoubleClickAction(button, MemorizingExpandCollapseAction.ID); } - - if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TABLE + + if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TABLE && !instance.parameters.isEmpty()) { KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(comps.getReactor()); _kRenderingExtensions.setInvisible(rectangle, true); if (!getBooleanValue(SHOW_HYPERLINKS)) { _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, 6, 0, + _kRenderingExtensions.TOP, 0, 0), + _kRenderingExtensions.RIGHT, 6, 0, _kRenderingExtensions.BOTTOM, 4, 0); } else { _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 4, 0), - _kRenderingExtensions.RIGHT, 6, 0, + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, 6, 0, + _kRenderingExtensions.TOP, 4, 0), + _kRenderingExtensions.RIGHT, 6, 0, _kRenderingExtensions.BOTTOM, 0, 0); } _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); addParameterList(rectangle, instance.parameters); } - + if (getBooleanValue(SHOW_STATE_VARIABLES)) { var variables = ASTUtils.collectElements(reactor, LfPackage.eINSTANCE.getReactor_StateVars(), true, false); if (!variables.isEmpty()) { @@ -463,25 +462,25 @@ private Collection createReactorNode( if (!getBooleanValue(SHOW_HYPERLINKS)) { _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, 6, 0, + _kRenderingExtensions.TOP, 0, 0), + _kRenderingExtensions.RIGHT, 6, 0, _kRenderingExtensions.BOTTOM, 4, 0); } else { _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 4, 0), - _kRenderingExtensions.RIGHT, 6, 0, + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, 6, 0, + _kRenderingExtensions.TOP, 4, 0), + _kRenderingExtensions.RIGHT, 6, 0, _kRenderingExtensions.BOTTOM, 0, 0); } _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); addStateVariableList(rectangle, variables); } } - + if (instance.recursive) { comps.getFigures().forEach(_linguaFrancaStyleExtensions::errorStyle); } else { @@ -498,28 +497,28 @@ private Collection createReactorNode( } } _reactorIcons.handleIcon(comps.getReactor(), reactor, true); - + if (getBooleanValue(SHOW_HYPERLINKS)) { // Expand button if (_utilityExtensions.hasContent(instance) && !instance.recursive) { KText button = _linguaFrancaShapeExtensions.addTextButton(comps.getReactor(), TEXT_SHOW_ACTION); _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(button), - _kRenderingExtensions.LEFT, 8, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 8, 0, + _kRenderingExtensions.setGridPlacementData(button), + _kRenderingExtensions.LEFT, 8, 0, + _kRenderingExtensions.TOP, 0, 0), + _kRenderingExtensions.RIGHT, 8, 0, _kRenderingExtensions.BOTTOM, 8, 0); _kRenderingExtensions.addSingleClickAction(button, MemorizingExpandCollapseAction.ID); _kRenderingExtensions.addDoubleClickAction(button, MemorizingExpandCollapseAction.ID); } } - + if (instance.recursive) { comps.getFigures().forEach(_linguaFrancaStyleExtensions::errorStyle); } - - + + // Create ports Map inputPorts = new HashMap<>(); Map outputPorts = new HashMap<>(); @@ -541,7 +540,7 @@ private Collection createReactorNode( if (_utilityExtensions.hasContent(instance) && !instance.recursive) { node.getChildren().addAll(transformReactorNetwork(instance, inputPorts, outputPorts, allReactorNodes)); } - + // Pass port to given tables if (!_utilityExtensions.isRoot(instance)) { if (inputPortsReg != null) { @@ -555,17 +554,17 @@ private Collection createReactorNode( } } } - + if (instance.recursive) { setLayoutOption(node, KlighdProperties.EXPAND, false); nodes.add(addErrorComment(node, TEXT_ERROR_RECURSIVE)); } else { setLayoutOption(node, KlighdProperties.EXPAND, expandDefault); - + // Interface Dependencies _interfaceDependenciesVisualization.addInterfaceDependencies(node, expandDefault); } - + if (!_utilityExtensions.isRoot(instance)) { // If all reactors are being shown, then only put the label on // the reactor definition, not on its instances. Otherwise, @@ -581,7 +580,7 @@ private Collection createReactorNode( } // Find and annotate cycles - if (getBooleanValue(CYCLE_DETECTION) && + if (getBooleanValue(CYCLE_DETECTION) && _utilityExtensions.isRoot(reactorInstance)) { KNode errNode = detectAndAnnotateCycles(node, reactorInstance, allReactorNodes); if (errNode != null) { @@ -591,7 +590,7 @@ private Collection createReactorNode( return nodes; } - + public KNode configureReactorNodeLayout(KNode node, boolean main) { // Set layered algorithm setLayoutOption(node, CoreOptions.ALGORITHM, LayeredOptions.ALGORITHM_ID); @@ -599,12 +598,12 @@ public KNode configureReactorNodeLayout(KNode node, boolean main) { setLayoutOption(node, CoreOptions.DIRECTION, Direction.RIGHT); // Center free floating children setLayoutOption(node, CoreOptions.CONTENT_ALIGNMENT, ContentAlignment.centerCenter()); - + // Balanced placement with straight long edges. setLayoutOption(node, LayeredOptions.NODE_PLACEMENT_STRATEGY, NodePlacementStrategy.NETWORK_SIMPLEX); // Do not shrink nodes below content setLayoutOption(node, CoreOptions.NODE_SIZE_CONSTRAINTS, EnumSet.of(SizeConstraint.MINIMUM_SIZE, SizeConstraint.PORTS)); - + // Allows to freely shuffle ports on each side setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); // Adjust port label spacing to be closer to edge but not overlap with port figure @@ -612,18 +611,18 @@ public KNode configureReactorNodeLayout(KNode node, boolean main) { setLayoutOption(node, CoreOptions.PORT_LABELS_PLACEMENT, EnumSet.of(PortLabelPlacement.ALWAYS_OTHER_SAME_SIDE, PortLabelPlacement.OUTSIDE)); setLayoutOption(node, CoreOptions.SPACING_LABEL_PORT_HORIZONTAL, 2.0); setLayoutOption(node, CoreOptions.SPACING_LABEL_PORT_VERTICAL, -3.0); - + // Configure spacing if (!getBooleanValue(SHOW_HYPERLINKS)) { // Hyperlink version is more relaxed in terms of space var factor = (double) getIntValue(SPACING) / 100; - + setLayoutOption(node, LayeredOptions.SPACING_COMPONENT_COMPONENT, LayeredOptions.SPACING_COMPONENT_COMPONENT.getDefault() * factor); - + setLayoutOption(node, LayeredOptions.SPACING_NODE_NODE, LayeredOptions.SPACING_NODE_NODE.getDefault() * factor); setLayoutOption(node, LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS, LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS.getDefault() * factor); setLayoutOption(node, LayeredOptions.SPACING_PORT_PORT, LayeredOptions.SPACING_PORT_PORT.getDefault() * factor); - + setLayoutOption(node, LayeredOptions.SPACING_EDGE_NODE, LayeredOptions.SPACING_EDGE_NODE.getDefault() * factor); setLayoutOption(node, LayeredOptions.SPACING_EDGE_NODE_BETWEEN_LAYERS, LayeredOptions.SPACING_EDGE_NODE_BETWEEN_LAYERS.getDefault() * factor); setLayoutOption(node, LayeredOptions.SPACING_EDGE_EDGE, LayeredOptions.SPACING_EDGE_EDGE.getDefault() * factor); @@ -631,7 +630,7 @@ public KNode configureReactorNodeLayout(KNode node, boolean main) { setLayoutOption(node, LayeredOptions.SPACING_EDGE_EDGE, LayeredOptions.SPACING_EDGE_EDGE.getDefault() * factor); setLayoutOption(node, LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS, LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS.getDefault() * factor); setLayoutOption(node, LayeredOptions.SPACING_EDGE_LABEL, LayeredOptions.SPACING_EDGE_LABEL.getDefault() * factor); - + // Padding for sub graph if (main) { // Special handing for main reactors setLayoutOption(node, CoreOptions.PADDING, new ElkPadding(-1, 6, 6, 6)); @@ -639,17 +638,17 @@ public KNode configureReactorNodeLayout(KNode node, boolean main) { setLayoutOption(node, CoreOptions.PADDING, new ElkPadding(2, 6, 6, 6)); } } - + return node; } - + private KNode detectAndAnnotateCycles(KNode node, ReactorInstance reactorInstance, Map allReactorNodes) { if (node.getProperty(REACTOR_RECURSIVE_INSTANTIATION)) { _filterCycleAction.resetCycleFiltering(node); return addErrorComment(node, TEXT_ERROR_CONTAINS_RECURSION); } else { // only detect dependency cycles if not recursive try { - boolean hasCycle = _cycleVisualization.detectAndHighlightCycles(reactorInstance, + boolean hasCycle = _cycleVisualization.detectAndHighlightCycles(reactorInstance, allReactorNodes, it -> { if (it instanceof KNode) { List renderings = IterableExtensions.toList( @@ -662,75 +661,75 @@ private KNode detectAndAnnotateCycles(KNode node, ReactorInstance reactorInstanc }).forEach(_linguaFrancaStyleExtensions::errorStyle); } } else if (it instanceof KEdge) { - Iterables.filter(((KEdge) it).getData(), + Iterables.filter(((KEdge) it).getData(), KRendering.class).forEach(_linguaFrancaStyleExtensions::errorStyle); // TODO initiallyHide does not work with incremental (https://github.com/kieler/KLighD/issues/37) // cycleEgde.initiallyShow() // Show hidden order dependencies _kRenderingExtensions.setInvisible(_kRenderingExtensions.getKRendering(it), false); } else if (it instanceof KPort) { - Iterables.filter(((KPort) it).getData(), + Iterables.filter(((KPort) it).getData(), KRendering.class).forEach(_linguaFrancaStyleExtensions::errorStyle); //it.reverseTrianglePort() } }); - + if (hasCycle) { KNode err = addErrorComment(node, TEXT_ERROR_CONTAINS_CYCLE); - + // Add to existing figure KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(_kRenderingExtensions.getKContainerRendering(err)); _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 3, 0, + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, 3, 0, _kRenderingExtensions.TOP, (-1), 0), - _kRenderingExtensions.RIGHT, 3, 0, + _kRenderingExtensions.RIGHT, 3, 0, _kRenderingExtensions.BOTTOM, 3, 0); _linguaFrancaStyleExtensions.noSelectionStyle(rectangle); _kRenderingExtensions.setInvisible(rectangle, true); _kContainerRenderingExtensions.setGridPlacement(rectangle, 2); - + KRectangle subrectangle = _kContainerRenderingExtensions.addRectangle(rectangle); _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(subrectangle), - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 2, 0, + _kRenderingExtensions.setGridPlacementData(subrectangle), + _kRenderingExtensions.LEFT, 0, 0, + _kRenderingExtensions.TOP, 0, 0), + _kRenderingExtensions.RIGHT, 2, 0, _kRenderingExtensions.BOTTOM, 0, 0); _linguaFrancaStyleExtensions.noSelectionStyle(subrectangle); _kRenderingExtensions.addSingleClickAction(subrectangle, ShowCycleAction.ID); - + KText subrectangleText = _kContainerRenderingExtensions.addText(subrectangle, TEXT_ERROR_CYCLE_BTN_SHOW); // Copy text style List styles = ListExtensions.map( IterableExtensions.head( - _kRenderingExtensions.getKContainerRendering(err).getChildren()).getStyles(), + _kRenderingExtensions.getKContainerRendering(err).getChildren()).getStyles(), EcoreUtil::copy); subrectangleText.getStyles().addAll(styles); _kRenderingExtensions.setFontSize(subrectangleText, 5); _kRenderingExtensions.setSurroundingSpace(subrectangleText, 1, 0); _linguaFrancaStyleExtensions.noSelectionStyle(subrectangleText); _kRenderingExtensions.addSingleClickAction(subrectangleText, ShowCycleAction.ID); - + subrectangle = _kContainerRenderingExtensions.addRectangle(rectangle); _kRenderingExtensions.to( _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(subrectangle), - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 0, 0, + _kRenderingExtensions.setGridPlacementData(subrectangle), + _kRenderingExtensions.LEFT, 0, 0, + _kRenderingExtensions.TOP, 0, 0), + _kRenderingExtensions.RIGHT, 0, 0, _kRenderingExtensions.BOTTOM, 0, 0); _linguaFrancaStyleExtensions.noSelectionStyle(subrectangle); _kRenderingExtensions.addSingleClickAction(subrectangle, FilterCycleAction.ID); - - subrectangleText = _kContainerRenderingExtensions.addText(subrectangle, - _filterCycleAction.isCycleFiltered(node) ? + + subrectangleText = _kContainerRenderingExtensions.addText(subrectangle, + _filterCycleAction.isCycleFiltered(node) ? TEXT_ERROR_CYCLE_BTN_UNFILTER : TEXT_ERROR_CYCLE_BTN_FILTER); // Copy text style styles = ListExtensions.map( IterableExtensions.head( - _kRenderingExtensions.getKContainerRendering(err).getChildren()).getStyles(), + _kRenderingExtensions.getKContainerRendering(err).getChildren()).getStyles(), EcoreUtil::copy); subrectangleText.getStyles().addAll(styles); _kRenderingExtensions.setFontSize(subrectangleText, 5); @@ -738,7 +737,7 @@ private KNode detectAndAnnotateCycles(KNode node, ReactorInstance reactorInstanc _linguaFrancaStyleExtensions.noSelectionStyle(subrectangleText); _kRenderingExtensions.addSingleClickAction(subrectangleText, FilterCycleAction.ID); _filterCycleAction.markCycleFilterText(subrectangleText, err); - + // if user interactively requested a filtered diagram keep it filtered during updates if (_filterCycleAction.isCycleFiltered(node)) { _filterCycleAction.filterCycle(node); @@ -780,15 +779,15 @@ private Collection transformReactorNetwork( for (ReactorInstance child : reactorInstance.children) { Boolean expansionState = MemorizingExpandCollapseAction.getExpansionState(child); Collection rNodes = createReactorNode( - child, - expansionState != null ? expansionState : false, - inputPorts, - outputPorts, + child, + expansionState != null ? expansionState : false, + inputPorts, + outputPorts, allReactorNodes); nodes.addAll(rNodes); index++; } - + // Create timers for (TimerInstance timer : reactorInstance.timers) { KNode node = associateWith(_kNodeExtensions.createNode(), timer.getDefinition()); @@ -810,11 +809,11 @@ private Collection transformReactorNetwork( nodes.add(node); Iterables.addAll(nodes, createUserComments(reaction.getDefinition(), node)); reactionNodes.put(reaction, node); - + setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); _layoutPostProcessing.configureReaction(node); setLayoutOption(node, LayeredOptions.POSITION, new KVector(0, idx + 1)); // try order reactions vertically if in one layer (+1 to account for startup) - + var figure = _linguaFrancaShapeExtensions.addReactionFigure(node, reaction); int inputSize = Stream.concat(reaction.triggers.stream(), reaction.sources.stream()).collect(Collectors.toSet()).size(); @@ -824,7 +823,7 @@ private Collection transformReactorNetwork( // pointy shape. However, this is only possible after the layout. ReactionPortAdjustment.apply(node, figure); } - + // connect input KPort port = null; for (TriggerInstance trigger : reaction.triggers) { @@ -832,27 +831,27 @@ private Collection transformReactorNetwork( if (port == null || !getBooleanValue(REACTIONS_USE_HYPEREDGES)) { port = addInvisiblePort(node); setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.WEST); - + if (getBooleanValue(REACTIONS_USE_HYPEREDGES) || inputSize == 1) { // manual adjustment disabling automatic one setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, (double) -LinguaFrancaShapeExtensions.REACTION_POINTINESS); } } - + if (trigger.isStartup()) { - connect(createDependencyEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), - startupNode, + connect(createDependencyEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), + startupNode, port); startup = trigger; } else if (trigger.isShutdown()) { - connect(createDelayEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), - shutdownNode, + connect(createDelayEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), + shutdownNode, port); shutdown = trigger; } else if (trigger.isReset()) { - connect(createDependencyEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), - resetNode, + connect(createDependencyEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), + resetNode, port); reset = trigger; } else if (trigger instanceof ActionInstance) { @@ -875,7 +874,7 @@ private Collection transformReactorNetwork( } } } - + // connect dependencies for (TriggerInstance dep : reaction.sources) { if (reaction.triggers.contains(dep)) continue; // skip @@ -884,14 +883,14 @@ private Collection transformReactorNetwork( if (port == null || !getBooleanValue(REACTIONS_USE_HYPEREDGES)) { port = addInvisiblePort(node); setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.WEST); - + if (getBooleanValue(REACTIONS_USE_HYPEREDGES) || inputSize == 1) { // manual adjustment disabling automatic one - setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, + setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, (double) -LinguaFrancaShapeExtensions.REACTION_POINTINESS); } } - + if (dep instanceof PortInstance) { KPort src = null; PortInstance depAsPort = (PortInstance) dep; @@ -905,7 +904,7 @@ private Collection transformReactorNetwork( } } } - + // connect outputs port = null; // enforce new ports for outputs Set> iterSet = reaction.effects != null ? reaction.effects : new HashSet<>(); @@ -915,7 +914,7 @@ private Collection transformReactorNetwork( port = addInvisiblePort(node); setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.EAST); } - + if (effect instanceof ActionInstance) { actionSources.put((ActionInstance) effect, port); } else if (effect instanceof PortInstance) { @@ -932,12 +931,12 @@ private Collection transformReactorNetwork( } } } - + // Connect actions Set actions = new HashSet<>(); actions.addAll(actionSources.keySet()); actions.addAll(actionDestinations.keySet()); - + for (ActionInstance action : actions) { KNode node = associateWith(_kNodeExtensions.createNode(), action.getDefinition()); NamedInstanceUtil.linkInstance(node, action); @@ -947,23 +946,23 @@ private Collection transformReactorNetwork( setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); _layoutPostProcessing.configureAction(node); Pair ports = _linguaFrancaShapeExtensions.addActionFigureAndPorts( - node, + node, action.isPhysical() ? "P" : "L"); // TODO handle variables? if (action.getMinDelay() != null && action.getMinDelay() != ActionInstance.DEFAULT_MIN_DELAY) { _kLabelExtensions.addOutsideBottomCenteredNodeLabel( - node, - String.format("min delay: %s", action.getMinDelay().toString()), + node, + String.format("min delay: %s", action.getMinDelay().toString()), 7); } // TODO default value? if (action.getDefinition().getMinSpacing() != null) { - _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, + _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, String.format("min spacing: %s", action.getMinSpacing().toString()), 7); } if (!StringExtensions.isNullOrEmpty(action.getDefinition().getPolicy())) { - _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, + _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, String.format("policy: %s", action.getPolicy().toString()), 7); } @@ -971,13 +970,13 @@ private Collection transformReactorNetwork( for (KPort source : actionSources.get(action)) { connect(createDelayEdge(action), source, ports.getKey()); } - + // connect targets for (KPort target : actionDestinations.get(action)) { connect(createDelayEdge(action), ports.getValue(), target); } } - + // Transform connections. // First, collect all the source ports. List sourcePorts = new LinkedList<>(reactorInstance.inputs); @@ -986,15 +985,15 @@ private Collection transformReactorNetwork( } for (PortInstance leftPort : sourcePorts) { - KPort source = leftPort.getParent() == reactorInstance ? - parentInputPorts.get(leftPort) : + KPort source = leftPort.getParent() == reactorInstance ? + parentInputPorts.get(leftPort) : outputPorts.get(leftPort.getParent(), leftPort); - + for (SendRange sendRange : leftPort.getDependentPorts()) { for (RuntimeRange rightRange : sendRange.destinations) { PortInstance rightPort = rightRange.instance; - KPort target = rightPort.getParent() == reactorInstance ? - parentOutputPorts.get(rightPort) : + KPort target = rightPort.getParent() == reactorInstance ? + parentOutputPorts.get(rightPort) : inputPorts.get(rightPort.getParent(), rightPort); // There should be a connection, but skip if not. Connection connection = sendRange.connection; @@ -1004,14 +1003,14 @@ private Collection transformReactorNetwork( KLabel delayLabel = _kLabelExtensions.addCenterEdgeLabel(edge, ASTUtils.toOriginalText(connection.getDelay())); associateWith(delayLabel, connection.getDelay()); if (connection.isPhysical()) { - _linguaFrancaStyleExtensions.applyOnEdgePysicalDelayStyle(delayLabel, + _linguaFrancaStyleExtensions.applyOnEdgePysicalDelayStyle(delayLabel, reactorInstance.isMainOrFederated() ? Colors.WHITE : Colors.GRAY_95); } else { _linguaFrancaStyleExtensions.applyOnEdgeDelayStyle(delayLabel); } } else if (connection.isPhysical()) { KLabel physicalConnectionLabel = _kLabelExtensions.addCenterEdgeLabel(edge, "---"); - _linguaFrancaStyleExtensions.applyOnEdgePysicalStyle(physicalConnectionLabel, + _linguaFrancaStyleExtensions.applyOnEdgePysicalStyle(physicalConnectionLabel, reactorInstance.isMainOrFederated() ? Colors.WHITE : Colors.GRAY_95); } if (source != null && target != null) { @@ -1028,7 +1027,7 @@ private Collection transformReactorNetwork( directConnectionDummyNodes.put(target, dummy); _kRenderingExtensions.addInvisibleContainerRendering(dummy); _kNodeExtensions.setNodeSize(dummy, 0, 0); - KEdge extraEdge = createIODependencyEdge(null, + KEdge extraEdge = createIODependencyEdge(null, (leftPort.isMultiport() || rightPort.isMultiport())); connect(extraEdge, dummy, target); } @@ -1053,7 +1052,7 @@ private Collection transformReactorNetwork( setLayoutOption(startupNode, LayeredOptions.POSITION, new KVector(0, 0)); setLayoutOption(startupNode, LayeredOptions.LAYERING_LAYER_CONSTRAINT, LayerConstraint.FIRST); _layoutPostProcessing.configureAction(startupNode); - + if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { KPort port = addInvisiblePort(startupNode); startupNode.getOutgoingEdges().forEach(it -> { @@ -1070,7 +1069,7 @@ private Collection transformReactorNetwork( // try to order with reactions vertically if in one layer _layoutPostProcessing.configureShutDown(shutdownNode); setLayoutOption(shutdownNode, LayeredOptions.POSITION, new KVector(0, reactorInstance.reactions.size() + 1)); - + if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port KPort port = addInvisiblePort(shutdownNode); shutdownNode.getOutgoingEdges().forEach(it -> { @@ -1087,7 +1086,7 @@ private Collection transformReactorNetwork( // try to order with reactions vertically if in one layer setLayoutOption(resetNode, LayeredOptions.POSITION, new KVector(0, 0.5)); setLayoutOption(resetNode, LayeredOptions.LAYERING_LAYER_CONSTRAINT, LayerConstraint.FIRST); - + if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port KPort port = addInvisiblePort(resetNode); resetNode.getOutgoingEdges().forEach(it -> { @@ -1095,7 +1094,7 @@ private Collection transformReactorNetwork( }); } } - + // Postprocess timer nodes if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port for (KNode timerNode : timerNodes.values()) { @@ -1105,36 +1104,36 @@ private Collection transformReactorNetwork( }); } } - + // Add reaction order edges (add last to have them on top of other edges) if (reactorInstance.reactions.size() > 1) { KNode prevNode = reactionNodes.get(IterableExtensions.head(reactorInstance.reactions)); Iterable iterList = IterableExtensions.map( - IterableExtensions.drop(reactorInstance.reactions, 1), + IterableExtensions.drop(reactorInstance.reactions, 1), reactionNodes::get); for (KNode node : iterList) { KEdge edge = createOrderEdge(); edge.setSource(prevNode); edge.setTarget(node); edge.setProperty(CoreOptions.NO_LAYOUT, true); - + // Do not remove them, as they are needed for cycle detection KRendering edgeRendering = _kRenderingExtensions.getKRendering(edge); _kRenderingExtensions.setInvisible(edgeRendering, !getBooleanValue(SHOW_REACTION_ORDER_EDGES)); _kRenderingExtensions.getInvisible(edgeRendering).setPropagateToChildren(true); // TODO this does not work work with incremental update (https://github.com/kieler/KLighD/issues/37) // if (!getBooleanValue(SHOW_REACTION_ORDER_EDGES)) edge.initiallyHide() - + prevNode = node; } } _layoutPostProcessing.orderChildren(nodes); _modeDiagrams.handleModes(nodes, reactorInstance); - + return nodes; } - + private String createReactorLabel(ReactorInstance reactorInstance) { StringBuilder b = new StringBuilder(); if (getBooleanValue(SHOW_INSTANCE_NAMES) && !_utilityExtensions.isRoot(reactorInstance)) { @@ -1158,7 +1157,7 @@ private String createReactorLabel(ReactorInstance reactorInstance) { if (reactorInstance.parameters.isEmpty()) { b.append("()"); } else { - b.append(IterableExtensions.join(reactorInstance.parameters, "(", ", ", ")", + b.append(IterableExtensions.join(reactorInstance.parameters, "(", ", ", ")", it -> { return createParameterLabel(it); })); @@ -1166,7 +1165,7 @@ private String createReactorLabel(ReactorInstance reactorInstance) { } return b.toString(); } - + private void addParameterList(KContainerRendering container, List parameters) { int cols = 1; try { @@ -1182,7 +1181,7 @@ private void addParameterList(KContainerRendering container, List variables) { int cols = 1; try { @@ -1213,7 +1212,7 @@ public void addStateVariableList(KContainerRendering container, List v _kRenderingExtensions.setHorizontalAlignment(entry, HorizontalAlignment.LEFT); } } - + private String createStateVariableLabel(StateVar variable) { StringBuilder b = new StringBuilder(); b.append(variable.getName()); @@ -1226,7 +1225,7 @@ private String createStateVariableLabel(StateVar variable) { } return b.toString(); } - + private KEdge createDelayEdge(Object associate) { KEdge edge = _kEdgeExtensions.createEdge(); associateWith(edge, associate); @@ -1241,7 +1240,7 @@ private KEdge createDelayEdge(Object associate) { } return edge; } - + private KEdge createIODependencyEdge(Object associate, boolean multiport) { KEdge edge = _kEdgeExtensions.createEdge(); if (associate != null) { @@ -1259,7 +1258,7 @@ private KEdge createIODependencyEdge(Object associate, boolean multiport) { } return edge; } - + private KEdge createDependencyEdge(Object associate) { KEdge edge = _kEdgeExtensions.createEdge(); if (associate != null) { @@ -1276,7 +1275,7 @@ private KEdge createDependencyEdge(Object associate) { } return edge; } - + private KEdge createOrderEdge() { KEdge edge = _kEdgeExtensions.createEdge(); KPolyline line = _kEdgeExtensions.addPolyline(edge); @@ -1288,27 +1287,27 @@ private KEdge createOrderEdge() { _kPolylineExtensions.addHeadArrowDecorator(line); return edge; } - + private KEdge connect(KEdge edge, KNode src, KNode dst) { edge.setSource(src); edge.setTarget(dst); return edge; } - + private KEdge connect(KEdge edge, KNode src, KPort dst) { edge.setSource(src); edge.setTargetPort(dst); edge.setTarget(dst != null ? dst.getNode() : null); return edge; } - + private KEdge connect(KEdge edge, KPort src, KNode dst) { edge.setSourcePort(src); edge.setSource(src != null ? src.getNode() : null); edge.setTarget(dst); return edge; } - + private KEdge connect(KEdge edge, KPort src, KPort dst) { edge.setSourcePort(src); edge.setSource(src != null ? src.getNode() : null); @@ -1316,7 +1315,7 @@ private KEdge connect(KEdge edge, KPort src, KPort dst) { edge.setTarget(dst != null ? dst.getNode() : null); return edge; } - + /** * Translate an input/output into a port. */ @@ -1326,7 +1325,7 @@ private KPort addIOPort(KNode node, PortInstance lfPort, boolean input, boolean associateWith(port, lfPort.getDefinition()); NamedInstanceUtil.linkInstance(port, lfPort); _kPortExtensions.setPortSize(port, 6, 6); - + if (input) { // multiports are smaller by an offset at the right, hence compensate in inputs double offset = multiport ? -3.4 : -3.3; @@ -1338,23 +1337,23 @@ private KPort addIOPort(KNode node, PortInstance lfPort, boolean input, boolean setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.EAST); setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, offset); } - + if (bank && !node.getProperty(REACTOR_HAS_BANK_PORT_OFFSET)) {// compensate bank figure height // https://github.com/eclipse/elk/issues/693 _utilityExtensions.getPortMarginsInitIfAbsent(node).add( new ElkMargin(0, 0, LinguaFrancaShapeExtensions.BANK_FIGURE_Y_OFFSET_SUM, 0)); node.setProperty(REACTOR_HAS_BANK_PORT_OFFSET, true); // only once } - + _linguaFrancaShapeExtensions.addTrianglePort(port, multiport); - + String label = lfPort.getName(); if (!getBooleanValue(SHOW_PORT_NAMES)) { label = ""; } if (getBooleanValue(SHOW_MULTIPORT_WIDTH)) { if (lfPort.isMultiport()) { - label += (lfPort.getWidth() >= 0) ? + label += (lfPort.getWidth() >= 0) ? "[" + lfPort.getWidth() + "]" : "[?]"; } @@ -1369,14 +1368,14 @@ private KPort addInvisiblePort(KNode node) { port.setSize(0, 0); // invisible return port; } - + private KNode addErrorComment(KNode node, String message) { KNode comment = _kNodeExtensions.createNode(); setLayoutOption(comment, CoreOptions.COMMENT_BOX, true); KRoundedRectangle commentFigure = _linguaFrancaShapeExtensions.addCommentFigure(comment, message); _linguaFrancaStyleExtensions.errorStyle(commentFigure); _kRenderingExtensions.setBackground(commentFigure, Colors.PEACH_PUFF_2); - + // connect KEdge edge = _kEdgeExtensions.createEdge(); edge.setSource(comment); @@ -1384,23 +1383,23 @@ private KNode addErrorComment(KNode node, String message) { _linguaFrancaStyleExtensions.errorStyle(_linguaFrancaShapeExtensions.addCommentPolyline(edge)); return comment; } - + private Iterable createUserComments(EObject element, KNode targetNode) { if (getBooleanValue(SHOW_USER_LABELS)) { String commentText = AttributeUtils.getLabel(element); - + if (!StringExtensions.isNullOrEmpty(commentText)) { KNode comment = _kNodeExtensions.createNode(); setLayoutOption(comment, CoreOptions.COMMENT_BOX, true); KRoundedRectangle commentFigure = _linguaFrancaShapeExtensions.addCommentFigure(comment, commentText); _linguaFrancaStyleExtensions.commentStyle(commentFigure); - + // connect KEdge edge = _kEdgeExtensions.createEdge(); edge.setSource(comment); edge.setTarget(targetNode); _linguaFrancaStyleExtensions.commentStyle(_linguaFrancaShapeExtensions.addCommentPolyline(edge)); - + return List.of(comment); } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java b/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java index 8dc4afd2d3..260e2c98db 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java @@ -11,15 +11,15 @@ * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +* 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. ***************/ package org.lflang.diagram.synthesis.styles; @@ -42,7 +42,7 @@ import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.Pair; import org.eclipse.xtext.xbase.lib.StringExtensions; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.diagram.synthesis.AbstractSynthesisExtensions; import org.lflang.diagram.synthesis.LinguaFrancaSynthesis; import org.lflang.diagram.synthesis.util.UtilityExtensions; @@ -90,17 +90,17 @@ /** * Extension class that provides shapes and figures for the Lingua France diagram synthesis. - * + * * @author Alexander Schulz-Rosengarten */ @ViewSynthesisShared public class LinguaFrancaShapeExtensions extends AbstractSynthesisExtensions { - - public static final float REACTION_POINTINESS = 6; // arrow point length + + public static final float REACTION_POINTINESS = 6; // arrow point length // Property for marking the KContainterRendering in Reactor figures that is supposed to hold the content public static final Property REACTOR_CONTENT_CONTAINER = new Property<>( "org.lflang.diagram.synthesis.shapes.reactor.content", false); - + @Inject @Extension private KNodeExtensions _kNodeExtensions; @@ -133,7 +133,7 @@ public class LinguaFrancaShapeExtensions extends AbstractSynthesisExtensions { private UtilityExtensions _utilityExtensions; @Extension private KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; - + public static final float BANK_FIGURE_X_OFFSET_SUM = 6.0f; public static final float BANK_FIGURE_Y_OFFSET_SUM = 9.0f; @@ -148,7 +148,7 @@ public KRoundedRectangle addMainReactorFigure(KNode node, ReactorInstance reacto _kRenderingExtensions.setForeground(figure, Colors.GRAY); _kRenderingExtensions.setBackground(figure, Colors.WHITE); _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - + // Create parent container KRectangle parentContainer = _kContainerRenderingExtensions.addRectangle(figure); _kRenderingExtensions.setInvisible(parentContainer, true); @@ -156,22 +156,22 @@ public KRoundedRectangle addMainReactorFigure(KNode node, ReactorInstance reacto LEFT, padding, 0, TOP, padding, 0, RIGHT, padding, 0, BOTTOM, 4, 0 ); - + // Create child container KRectangle childContainer = _kContainerRenderingExtensions.addRectangle(parentContainer); _kRenderingExtensions.setInvisible(childContainer, true); - _kRenderingExtensions.setPointPlacementData(childContainer, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, + _kRenderingExtensions.setPointPlacementData(childContainer, + _kRenderingExtensions.LEFT, 0, 0.5f, + _kRenderingExtensions.TOP, 0, 0.5f, + _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, 0, 0, 0); KGridPlacement placement = _kContainerRenderingExtensions.setGridPlacement(childContainer, 1); - + // Add text to the child container KText childText = _kContainerRenderingExtensions.addText(childContainer, text); DiagramSyntheses.suppressSelectability(childText); _linguaFrancaStyleExtensions.underlineSelectionStyle(childText); - + if (reactorInstance.reactorDefinition.isFederated()) { KContainerRendering cloudIcon = _linguaFrancaStyleExtensions.addCloudIcon(childContainer); setGridPlacementDataFromPointToPoint(cloudIcon, @@ -179,10 +179,10 @@ public KRoundedRectangle addMainReactorFigure(KNode node, ReactorInstance reacto RIGHT, 0, 0, BOTTOM, 0, 0 ); placement.setNumColumns(2); - - if (reactorInstance.reactorDefinition.getHost() != null && + + if (reactorInstance.reactorDefinition.getHost() != null && getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTOR_HOST)) { - KText hostNameText = _kContainerRenderingExtensions.addText(childContainer, + KText hostNameText = _kContainerRenderingExtensions.addText(childContainer, ASTUtils.toOriginalText(reactorInstance.reactorDefinition.getHost())); DiagramSyntheses.suppressSelectability(hostNameText); _linguaFrancaStyleExtensions.underlineSelectionStyle(hostNameText); @@ -192,7 +192,7 @@ public KRoundedRectangle addMainReactorFigure(KNode node, ReactorInstance reacto ); placement.setNumColumns(3); } - } + } return figure; } @@ -201,14 +201,14 @@ public KRoundedRectangle addMainReactorFigure(KNode node, ReactorInstance reacto */ public ReactorFigureComponents addReactorFigure(KNode node, ReactorInstance reactorInstance, String text) { int padding = getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS) ? 8 : 6; - + Function1 style = r -> { _kRenderingExtensions.setLineWidth(r, 1); _kRenderingExtensions.setForeground(r, Colors.GRAY); _kRenderingExtensions.setBackground(r, Colors.GRAY_95); return _linguaFrancaStyleExtensions.boldLineSelectionStyle(r); }; - + KRoundedRectangle figure = _kRenderingExtensions.addRoundedRectangle(node, 8, 8, 1); _kContainerRenderingExtensions.setGridPlacement(figure, 1); style.apply(figure); @@ -217,32 +217,32 @@ public ReactorFigureComponents addReactorFigure(KNode node, ReactorInstance reac // minimal node size is necessary if no text will be added List minSize = List.of(2 * figure.getCornerWidth(), 2 * figure.getCornerHeight()); _kNodeExtensions.setMinimalNodeSize(node, minSize.get(0), minSize.get(1)); - + // Add parent container KRectangle parentContainer = _kContainerRenderingExtensions.addRectangle(figure); _kRenderingExtensions.setInvisible(parentContainer, true); setGridPlacementDataFromPointToPoint(parentContainer, - LEFT, padding, 0, + LEFT, padding, 0, TOP, padding, 0, - RIGHT, padding, 0, BOTTOM, + RIGHT, padding, 0, BOTTOM, _utilityExtensions.hasContent(reactorInstance) ? 4 : padding, 0 ); - + // Add centered child container KRectangle childContainer = _kContainerRenderingExtensions.addRectangle(parentContainer); _kRenderingExtensions.setInvisible(childContainer, true); - _kRenderingExtensions.setPointPlacementData(childContainer, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, + _kRenderingExtensions.setPointPlacementData(childContainer, + _kRenderingExtensions.LEFT, 0, 0.5f, + _kRenderingExtensions.TOP, 0, 0.5f, + _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, 0, 0, 0); KGridPlacement placement = _kContainerRenderingExtensions.setGridPlacement(childContainer, 1); - + KText childText = _kContainerRenderingExtensions.addText(childContainer, text); DiagramSyntheses.suppressSelectability(childText); _linguaFrancaStyleExtensions.underlineSelectionStyle(childText); - - if (!_utilityExtensions.isRoot(reactorInstance) && + + if (!_utilityExtensions.isRoot(reactorInstance) && reactorInstance.getDefinition().getHost() != null) { KRendering cloudUploadIcon = _linguaFrancaStyleExtensions.addCloudUploadIcon(childContainer); setGridPlacementDataFromPointToPoint(cloudUploadIcon, @@ -250,9 +250,9 @@ public ReactorFigureComponents addReactorFigure(KNode node, ReactorInstance reac RIGHT, 0, 0, BOTTOM, 0, 0 ); placement.setNumColumns(2); - + if (getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTOR_HOST)) { - KText reactorHostText = _kContainerRenderingExtensions.addText(childContainer, + KText reactorHostText = _kContainerRenderingExtensions.addText(childContainer, ASTUtils.toOriginalText(reactorInstance.getDefinition().getHost())); DiagramSyntheses.suppressSelectability(reactorHostText); _linguaFrancaStyleExtensions.underlineSelectionStyle(reactorHostText); @@ -263,7 +263,7 @@ public ReactorFigureComponents addReactorFigure(KNode node, ReactorInstance reac placement.setNumColumns(3); } } - + if (reactorInstance.isBank()) { List bank = new ArrayList<>(); KContainerRendering container = _kRenderingExtensions.addInvisibleContainerRendering(node); @@ -289,7 +289,7 @@ public ReactorFigureComponents addReactorFigure(KNode node, ReactorInstance reac LEFT, 2 * BANK_FIGURE_X_OFFSET_SUM / 3, 0, TOP, 2 * BANK_FIGURE_Y_OFFSET_SUM / 3, 0, RIGHT, BANK_FIGURE_X_OFFSET_SUM / 3, 0, BOTTOM, BANK_FIGURE_Y_OFFSET_SUM / 3, 0 ); - + banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); style.apply(banks); setGridPlacementDataFromPointToPoint(banks, @@ -297,14 +297,14 @@ public ReactorFigureComponents addReactorFigure(KNode node, ReactorInstance reac RIGHT, 2 * BANK_FIGURE_X_OFFSET_SUM / 3, 0, BOTTOM, 2 * BANK_FIGURE_Y_OFFSET_SUM / 3, 0 ); } - + container.getChildren().add(figure); setGridPlacementDataFromPointToPoint(figure, LEFT, 0, 0, TOP, 0, 0, RIGHT, BANK_FIGURE_X_OFFSET_SUM, 0, BOTTOM, BANK_FIGURE_Y_OFFSET_SUM, 0 ); bank.addAll(container.getChildren()); - + KRectangle widthLabelContainer = _kContainerRenderingExtensions.addRectangle(container); _kRenderingExtensions.setInvisible(widthLabelContainer, true); setGridPlacementDataFromPointToPoint(widthLabelContainer, @@ -324,7 +324,7 @@ public ReactorFigureComponents addReactorFigure(KNode node, ReactorInstance reac return new ReactorFigureComponents(figure, figure, List.of(figure)); } } - + /** * Creates the visual representation of a reaction node */ @@ -333,7 +333,7 @@ public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { int minWidth = 45; ReactorInstance reactor = reaction.getParent(); _kNodeExtensions.setMinimalNodeSize(node, minWidth, minHeight); - + // Create base shape KPolygon baseShape = _kRenderingExtensions.addPolygon(node); associateWith(baseShape, reaction); @@ -351,19 +351,19 @@ public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { _kRenderingExtensions.createKPosition(LEFT, REACTION_POINTINESS, 0, BOTTOM, 0, 0.5f) ) ); - + KRectangle contentContainer = _kContainerRenderingExtensions.addRectangle(baseShape); associateWith(contentContainer, reaction); _kRenderingExtensions.setInvisible(contentContainer, true); - _kRenderingExtensions.setPointPlacementData(contentContainer, - _kRenderingExtensions.LEFT, REACTION_POINTINESS, 0, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, REACTION_POINTINESS, + _kRenderingExtensions.setPointPlacementData(contentContainer, + _kRenderingExtensions.LEFT, REACTION_POINTINESS, 0, + _kRenderingExtensions.TOP, 0, 0, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, REACTION_POINTINESS, 0, minWidth - REACTION_POINTINESS * 2, minHeight); _kContainerRenderingExtensions.setGridPlacement(contentContainer, 1); - + if (reactor.reactions.size() > 1) { - KText textToAdd = _kContainerRenderingExtensions.addText(contentContainer, + KText textToAdd = _kContainerRenderingExtensions.addText(contentContainer, Integer.toString(reactor.reactions.indexOf(reaction) + 1)); _kRenderingExtensions.setFontBold(textToAdd, true); _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); @@ -387,10 +387,10 @@ public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { } // optional code content - boolean hasCode = getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_CODE) && + boolean hasCode = getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_CODE) && !StringExtensions.isNullOrEmpty(reaction.getDefinition().getCode().getBody()); if (hasCode) { - KText hasCodeText = _kContainerRenderingExtensions.addText(contentContainer, + KText hasCodeText = _kContainerRenderingExtensions.addText(contentContainer, _utilityExtensions.trimCode(reaction.getDefinition().getCode())); associateWith(hasCodeText, reaction); _kRenderingExtensions.setFontSize(hasCodeText, 6); @@ -399,26 +399,26 @@ public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { _kRenderingExtensions.setHorizontalAlignment(hasCodeText, HorizontalAlignment.LEFT); _kRenderingExtensions.setVerticalAlignment(hasCodeText, VerticalAlignment.TOP); setGridPlacementDataFromPointToPoint(hasCodeText, - _kRenderingExtensions.LEFT, 5, 0, + _kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.TOP, 5, 0, - _kRenderingExtensions.RIGHT, 5, 0, + _kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.BOTTOM, 5, 0 ); } - + if (reaction.declaredDeadline != null) { - boolean hasDeadlineCode = getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_CODE) && + boolean hasDeadlineCode = getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_CODE) && !StringExtensions.isNullOrEmpty(reaction.getDefinition().getDeadline().getCode().getBody()); if (hasCode || hasDeadlineCode) { KPolyline line = _kContainerRenderingExtensions.addHorizontalLine(contentContainer, 0); setGridPlacementDataFromPointToPoint(line, - _kRenderingExtensions.LEFT, 5, 0, + _kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.TOP, 3, 0, - _kRenderingExtensions.RIGHT, 5, 0, + _kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.BOTTOM, 6, 0 ); } - + // delay with stopwatch KRectangle labelContainer = _kContainerRenderingExtensions.addRectangle(contentContainer); _kRenderingExtensions.setInvisible(labelContainer, true); @@ -429,11 +429,11 @@ public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { _kRenderingExtensions.BOTTOM, 0, 0 ); _kRenderingExtensions.setHorizontalAlignment(placement, HorizontalAlignment.LEFT); - + KRectangle stopWatchFigure = addStopwatchFigure(labelContainer); _kRenderingExtensions.setLeftTopAlignedPointPlacementData(stopWatchFigure, 0, 0, 0, 0); - - KText stopWatchText = _kContainerRenderingExtensions.addText(labelContainer, + + KText stopWatchText = _kContainerRenderingExtensions.addText(labelContainer, reaction.declaredDeadline.maxDelay.toString()); associateWith(stopWatchText, reaction.getDefinition().getDeadline().getDelay()); _kRenderingExtensions.setForeground(stopWatchText, Colors.BROWN); @@ -441,19 +441,19 @@ public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { _kRenderingExtensions.setFontSize(stopWatchText, 7); _linguaFrancaStyleExtensions.underlineSelectionStyle(stopWatchText); _kRenderingExtensions.setLeftTopAlignedPointPlacementData(stopWatchText, 15, 0, 0, 0); - + // optional code content if (hasDeadlineCode) { - KText contentContainerText = _kContainerRenderingExtensions.addText(contentContainer, + KText contentContainerText = _kContainerRenderingExtensions.addText(contentContainer, _utilityExtensions.trimCode(reaction.getDefinition().getDeadline().getCode())); associateWith(contentContainerText, reaction.declaredDeadline); _kRenderingExtensions.setForeground(contentContainerText, Colors.BROWN); _kRenderingExtensions.setFontSize(contentContainerText, 6); _kRenderingExtensions.setFontName(contentContainerText, KlighdConstants.DEFAULT_MONOSPACE_FONT_NAME); setGridPlacementDataFromPointToPoint(contentContainerText, - _kRenderingExtensions.LEFT, 5, 0, + _kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.RIGHT, 5, 0, + _kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.BOTTOM, 5, 0 ); _kRenderingExtensions.setHorizontalAlignment(contentContainerText, HorizontalAlignment.LEFT); @@ -463,7 +463,7 @@ public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { return baseShape; } - + /** * Stopwatch figure for deadlines. */ @@ -471,21 +471,21 @@ public KRectangle addStopwatchFigure(KContainerRendering parent) { final int size = 12; KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); _kRenderingExtensions.setInvisible(container, true); - _kRenderingExtensions.setPointPlacementData(container, - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, + _kRenderingExtensions.setPointPlacementData(container, + _kRenderingExtensions.LEFT, 0, 0, + _kRenderingExtensions.TOP, 0, 0, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, 0, size, size); - - KPolyline polyline = _kContainerRenderingExtensions.addPolyline(container, 2, + + KPolyline polyline = _kContainerRenderingExtensions.addPolyline(container, 2, List.of( _kRenderingExtensions.createKPosition(LEFT, 3, 0.5f, TOP, (-2), 0), _kRenderingExtensions.createKPosition(LEFT, (-3), 0.5f, TOP, (-2), 0) ) ); _kRenderingExtensions.setForeground(polyline, Colors.BROWN); - - polyline = _kContainerRenderingExtensions.addPolyline(container, 2, + + polyline = _kContainerRenderingExtensions.addPolyline(container, 2, List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, (-2), 0), _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 1, 0) @@ -496,41 +496,41 @@ public KRectangle addStopwatchFigure(KContainerRendering parent) { KEllipse body = _kContainerRenderingExtensions.addEllipse(container); _kRenderingExtensions.setLineWidth(body, 1); _kRenderingExtensions.setForeground(body, Colors.BROWN); - _kRenderingExtensions.setPointPlacementData(body, - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, + _kRenderingExtensions.setPointPlacementData(body, + _kRenderingExtensions.LEFT, 0, 0, + _kRenderingExtensions.TOP, 0, 0, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, 0, size, size); _linguaFrancaStyleExtensions.noSelectionStyle(body); - + KArc arc = _kContainerRenderingExtensions.addArc(body); arc.setStartAngle((-20)); arc.setArcAngle(110); arc.setArcType(Arc.PIE); _kRenderingExtensions.setLineWidth(arc, 0); _kRenderingExtensions.setBackground(arc, Colors.BROWN); - _kRenderingExtensions.setPointPlacementData(arc, - _kRenderingExtensions.LEFT, 2, 0, - _kRenderingExtensions.TOP, 2, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 2, + _kRenderingExtensions.setPointPlacementData(arc, + _kRenderingExtensions.LEFT, 2, 0, + _kRenderingExtensions.TOP, 2, 0, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 2, 2, size - 4, size - 4); _linguaFrancaStyleExtensions.noSelectionStyle(arc); - + return container; } - + /** * Creates the visual representation of a timer node */ public KEllipse addTimerFigure(KNode node, TimerInstance timer) { _kNodeExtensions.setMinimalNodeSize(node, 30, 30); - + KEllipse figure = _kRenderingExtensions.addEllipse(node); _kRenderingExtensions.setBackground(figure, Colors.GRAY_95); _linguaFrancaStyleExtensions.noSelectionStyle(figure); _kRenderingExtensions.setLineWidth(figure, 1); _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - + List polylinePoints = List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0.1f), _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0.5f), @@ -538,7 +538,7 @@ public KEllipse addTimerFigure(KNode node, TimerInstance timer) { ); KPolyline polyline = _kContainerRenderingExtensions.addPolyline(figure, 1, polylinePoints); _linguaFrancaStyleExtensions.boldLineSelectionStyle(polyline); - + List labelParts = new ArrayList<>(); if (timer.getOffset() != TimerInstance.DEFAULT_OFFSET && timer.getOffset() != null) { labelParts.add(timer.getOffset().toString()); @@ -550,12 +550,12 @@ public KEllipse addTimerFigure(KNode node, TimerInstance timer) { labelParts.add(timer.getPeriod().toString()); } if (!labelParts.isEmpty()) { - _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, + _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, "(" + String.join(", ", labelParts) + ")", 8); } return figure; } - + /** * Creates the visual representation of a startup trigger. */ @@ -568,7 +568,7 @@ public KEllipse addStartupFigure(KNode node) { _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); return figure; } - + /** * Creates the visual representation of a shutdown trigger. */ @@ -579,18 +579,18 @@ public KPolygon addShutdownFigure(KNode node) { _kRenderingExtensions.setBackground(figure, Colors.WHITE); _linguaFrancaStyleExtensions.noSelectionStyle(figure); _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - + List pointsToAdd = List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0), _kRenderingExtensions.createKPosition(RIGHT, 0, 0, TOP, 0, 0.5f), _kRenderingExtensions.createKPosition(RIGHT, 0, 0.5f, BOTTOM, 0, 0), _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0.5f) ); - + figure.getPoints().addAll(pointsToAdd); return figure; } - + /** * Creates the visual representation of a shutdown trigger. */ @@ -601,13 +601,13 @@ public KEllipse addResetFigure(KNode node) { _kRenderingExtensions.setBackground(figure, Colors.WHITE); _linguaFrancaStyleExtensions.noSelectionStyle(figure); _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - + KEllipse resetCircle = _kContainerRenderingExtensions.addEllipse(figure); _kRenderingExtensions.setSurroundingSpace(resetCircle, 3f, 0); _kRenderingExtensions.setLineWidth(resetCircle, 1.5f); _kRenderingExtensions.setBackground(resetCircle, Colors.WHITE); _linguaFrancaStyleExtensions.noSelectionStyle(resetCircle); - + var resetCycleGap = _kContainerRenderingExtensions.addPolygon(resetCircle); resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0)); resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.RIGHT, 0, 0, PositionReferenceY.TOP, 0.0f, 0)); @@ -617,12 +617,12 @@ public KEllipse addResetFigure(KNode node) { _kRenderingExtensions.setForeground(resetCycleGap, Colors.WHITE); _kRenderingExtensions.setBackground(resetCycleGap, Colors.WHITE); _linguaFrancaStyleExtensions.noSelectionStyle(resetCycleGap); - _kRenderingExtensions.setPointPlacementData(resetCycleGap, - _kRenderingExtensions.LEFT, -2, 0.5f, + _kRenderingExtensions.setPointPlacementData(resetCycleGap, + _kRenderingExtensions.LEFT, -2, 0.5f, _kRenderingExtensions.TOP, 1.5f, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 4.0f, 3.0f); - + var resetArrow = _kContainerRenderingExtensions.addPolygon(resetCircle); resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0.1f)); resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0.0f, 0.3f, PositionReferenceY.BOTTOM, 0, 0)); @@ -630,35 +630,35 @@ public KEllipse addResetFigure(KNode node) { _kRenderingExtensions.setLineWidth(resetArrow, 0.3f); _kRenderingExtensions.setBackground(resetArrow, Colors.BLACK); _linguaFrancaStyleExtensions.noSelectionStyle(resetArrow); - _kRenderingExtensions.setPointPlacementData(resetArrow, - _kRenderingExtensions.LEFT, 1.0f, 0.5f, - _kRenderingExtensions.TOP, 1.8f, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.setPointPlacementData(resetArrow, + _kRenderingExtensions.LEFT, 1.0f, 0.5f, + _kRenderingExtensions.TOP, 1.8f, 0, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 3.2f, 3.2f); - + return figure; } - + /** * Creates the visual representation of a reactor port. */ public KPolygon addTrianglePort(KPort port, boolean multiport) { port.setSize(8, 8); - + // Create triangle port KPolygon trianglePort = _kRenderingExtensions.addPolygon(port); - + // Set line width and background color according to multiport or not float lineWidth = multiport ? 2.2f : 1; _kRenderingExtensions.setLineWidth(trianglePort, lineWidth); _linguaFrancaStyleExtensions.boldLineSelectionStyle(trianglePort); Colors background = multiport ? Colors.WHITE : Colors.BLACK; _kRenderingExtensions.setBackground(trianglePort, background); - + List pointsToAdd; if (multiport) { // Compensate for line width by making triangle smaller - // Do not adjust by port size because this will affect port distribution and cause offsets between parallel connections + // Do not adjust by port size because this will affect port distribution and cause offsets between parallel connections pointsToAdd = List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0, TOP, 0.6f, 0), _kRenderingExtensions.createKPosition(RIGHT, 1.2f, 0, TOP, 0, 0.5f), @@ -674,7 +674,7 @@ public KPolygon addTrianglePort(KPort port, boolean multiport) { trianglePort.getPoints().addAll(pointsToAdd); return trianglePort; } - + /** * Added a text as collapse expand button. */ @@ -685,13 +685,13 @@ public KText addTextButton(KContainerRendering container, String text) { _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); return textToAdd; } - - /** + + /** * Creates the triangular line decorator with text. */ public KPolygon addActionDecorator(KPolyline line, String text) { final float size = 18; - + // Create action decorator KPolygon actionDecorator = _kContainerRenderingExtensions.addPolygon(line); _kRenderingExtensions.setBackground(actionDecorator, Colors.WHITE); @@ -701,7 +701,7 @@ public KPolygon addActionDecorator(KPolyline line, String text) { _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0) ); actionDecorator.getPoints().addAll(pointsToAdd); - + // Set placement data of the action decorator KDecoratorPlacementData placementData = _kRenderingFactory.createKDecoratorPlacementData(); placementData.setRelative(0.5f); @@ -711,21 +711,21 @@ public KPolygon addActionDecorator(KPolyline line, String text) { placementData.setYOffset(-size * 0.66f); placementData.setRotateWithLine(true); actionDecorator.setPlacementData(placementData); - + // Add text to the action decorator KText textToAdd = _kContainerRenderingExtensions.addText(actionDecorator, text); _kRenderingExtensions.setFontSize(textToAdd, 8); _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); DiagramSyntheses.suppressSelectability(textToAdd); - _kRenderingExtensions.setPointPlacementData(textToAdd, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, size * 0.15f, 0.5f, + _kRenderingExtensions.setPointPlacementData(textToAdd, + _kRenderingExtensions.LEFT, 0, 0.5f, + _kRenderingExtensions.TOP, size * 0.15f, 0.5f, _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, 0, size, size); - + return actionDecorator; } - + /** * Creates the triangular action node with text and ports. */ @@ -735,25 +735,25 @@ public Pair addActionFigureAndPorts(KNode node, String text) { KPolygon figure = _kRenderingExtensions.addPolygon(node); _kRenderingExtensions.setBackground(figure, Colors.WHITE); _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - + List pointsToAdd = List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0), _kRenderingExtensions.createKPosition(RIGHT, 0, 0, BOTTOM, 0, 0), _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0) ); figure.getPoints().addAll(pointsToAdd); - + // Add text to the action figure KText textToAdd = _kContainerRenderingExtensions.addText(figure, text); _kRenderingExtensions.setFontSize(textToAdd, 8); _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); DiagramSyntheses.suppressSelectability(textToAdd); - _kRenderingExtensions.setPointPlacementData(textToAdd, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, (size * 0.15f), 0.5f, - _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.setPointPlacementData(textToAdd, + _kRenderingExtensions.LEFT, 0, 0.5f, + _kRenderingExtensions.TOP, (size * 0.15f), 0.5f, + _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, 0, size, size); - + // Add input port KPort in = _kPortExtensions.createPort(); node.getPorts().add(in); @@ -768,7 +768,7 @@ public Pair addActionFigureAndPorts(KNode node, String text) { DiagramSyntheses.setLayoutOption(out, CoreOptions.PORT_BORDER_OFFSET, -size / ((double) 4)); return new Pair(in, out); } - + /** * Creates and adds an error message figure */ @@ -776,13 +776,13 @@ public KRectangle addErrorMessage(KNode node, String title, String message) { // Create figure for error message KRectangle figure = _kRenderingExtensions.addRectangle(node); _kRenderingExtensions.setInvisible(figure, true); - + // Add error message box KRoundedRectangle errMsgBox = _kContainerRenderingExtensions.addRoundedRectangle(figure, 7, 7); _kContainerRenderingExtensions.setGridPlacement(errMsgBox, 1); _kRenderingExtensions.setLineWidth(errMsgBox, 2); _linguaFrancaStyleExtensions.noSelectionStyle(errMsgBox); - + if (title != null) { // Add title to error message box KText titleText = _kContainerRenderingExtensions.addText(errMsgBox, title); @@ -790,126 +790,126 @@ public KRectangle addErrorMessage(KNode node, String title, String message) { _kRenderingExtensions.setFontBold(titleText, true); _kRenderingExtensions.setForeground(titleText, Colors.RED); setGridPlacementDataFromPointToPoint(titleText, - _kRenderingExtensions.LEFT, 8, 0, + _kRenderingExtensions.LEFT, 8, 0, _kRenderingExtensions.TOP, 8, 0, - _kRenderingExtensions.RIGHT, 8, 0, + _kRenderingExtensions.RIGHT, 8, 0, _kRenderingExtensions.BOTTOM, 4, 0); DiagramSyntheses.suppressSelectability(titleText); _linguaFrancaStyleExtensions.noSelectionStyle(titleText); } - + if (message != null) { // Add message to error message box KText msgText = _kContainerRenderingExtensions.addText(errMsgBox, message); if (title != null) { setGridPlacementDataFromPointToPoint(msgText, - _kRenderingExtensions.LEFT, 8, 0, + _kRenderingExtensions.LEFT, 8, 0, _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.RIGHT, 8, 0, + _kRenderingExtensions.RIGHT, 8, 0, _kRenderingExtensions.BOTTOM, 4, 0); } else { setGridPlacementDataFromPointToPoint(msgText, - _kRenderingExtensions.LEFT, 8, 0, + _kRenderingExtensions.LEFT, 8, 0, _kRenderingExtensions.TOP, 8, 0, - _kRenderingExtensions.RIGHT, 8, 0, + _kRenderingExtensions.RIGHT, 8, 0, _kRenderingExtensions.BOTTOM, 8, 0); } _linguaFrancaStyleExtensions.noSelectionStyle(msgText); } return figure; } - + public KRoundedRectangle addCommentFigure(KNode node, String message) { // Create rectangle for comment figure KRoundedRectangle commentFigure = _kRenderingExtensions.addRoundedRectangle(node, 1, 1, 1); _kContainerRenderingExtensions.setGridPlacement(commentFigure, 1); - + // Add message KText text = _kContainerRenderingExtensions.addText(commentFigure, message); _kRenderingExtensions.setFontSize(text, 6); setGridPlacementDataFromPointToPoint(text, _kRenderingExtensions.LEFT, 3, 0, _kRenderingExtensions.TOP, 3, 0, - _kRenderingExtensions.RIGHT, 3, 0, + _kRenderingExtensions.RIGHT, 3, 0, _kRenderingExtensions.BOTTOM, 3, 0); _linguaFrancaStyleExtensions.noSelectionStyle(text); return commentFigure; } - + private KRendering setGridPlacementDataFromPointToPoint(KRendering rendering, PositionReferenceX fPx, float fAbsoluteLR, float fRelativeLR, PositionReferenceY fPy, float fAbsoluteTB, float fRelativeTB, PositionReferenceX tPx, float tAbsoluteLR, float tRelativeLR, PositionReferenceY tPy, float tAbsoluteTB, float tRelativeTB) { KAreaPlacementData fromPoint = _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rendering), + _kRenderingExtensions.setGridPlacementData(rendering), fPx, fAbsoluteLR, fRelativeLR, fPy, fAbsoluteTB, fRelativeTB); - return _kRenderingExtensions.to(fromPoint, - tPx, tAbsoluteLR, tRelativeLR, + return _kRenderingExtensions.to(fromPoint, + tPx, tAbsoluteLR, tRelativeLR, tPy, tAbsoluteTB, tRelativeTB); } - - + + public KPolyline addCommentPolyline(KEdge edge) { KPolyline polyline = _kEdgeExtensions.addPolyline(edge); _kRenderingExtensions.setLineWidth(polyline, 1); _kRenderingExtensions.setLineStyle(polyline, LineStyle.DOT); return polyline; } - + public KContainerRendering addParameterEntry(KContainerRendering parent, Parameter associate, String text) { KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); _kRenderingExtensions.setInvisible(container, true); var ktext = _kContainerRenderingExtensions.addText(container, text); _kRenderingExtensions.setFontSize(ktext, 8); - _kRenderingExtensions.setPointPlacementData(ktext, - _kRenderingExtensions.LEFT, 10, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.setPointPlacementData(ktext, + _kRenderingExtensions.LEFT, 10, 0, + _kRenderingExtensions.TOP, 0, 0.5f, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 0, 0); associateWith(ktext, associate); - + var dot = _kContainerRenderingExtensions.addEllipse(container); _kRenderingExtensions.setLineWidth(dot, 1); _linguaFrancaStyleExtensions.noSelectionStyle(dot); - _kRenderingExtensions.setPointPlacementData(dot, - _kRenderingExtensions.LEFT, 2, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.setPointPlacementData(dot, + _kRenderingExtensions.LEFT, 2, 0, + _kRenderingExtensions.TOP, 0, 0.5f, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 5, 5); return container; } - - + + public KContainerRendering addStateEntry(KContainerRendering parent, StateVar associate, String text, boolean reset) { KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); _kRenderingExtensions.setInvisible(container, true); var ktext = _kContainerRenderingExtensions.addText(container, text); _kRenderingExtensions.setFontSize(ktext, 8); - _kRenderingExtensions.setPointPlacementData(ktext, - _kRenderingExtensions.LEFT, 10, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.setPointPlacementData(ktext, + _kRenderingExtensions.LEFT, 10, 0, + _kRenderingExtensions.TOP, 0, 0.5f, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 0, 0); associateWith(ktext, associate); - + KEllipse outerCircle; - + if (reset) { outerCircle = _kContainerRenderingExtensions.addEllipse(container); _kRenderingExtensions.setLineWidth(outerCircle, 0.9f); _kRenderingExtensions.setBackground(outerCircle, Colors.WHITE); _linguaFrancaStyleExtensions.noSelectionStyle(outerCircle); - _kRenderingExtensions.setPointPlacementData(outerCircle, - _kRenderingExtensions.LEFT, 1.5f, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.setPointPlacementData(outerCircle, + _kRenderingExtensions.LEFT, 1.5f, 0, + _kRenderingExtensions.TOP, 0, 0.5f, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 6.3f, 6.3f); - + var resetCycleGap = _kContainerRenderingExtensions.addPolygon(outerCircle); resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.26f, 0)); resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0.2f, PositionReferenceY.TOP, 0.1f, 0)); @@ -922,12 +922,12 @@ public KContainerRendering addStateEntry(KContainerRendering parent, StateVar as _kRenderingExtensions.setForeground(resetCycleGap, Colors.WHITE); _kRenderingExtensions.setBackground(resetCycleGap, Colors.WHITE); _linguaFrancaStyleExtensions.noSelectionStyle(resetCycleGap); - _kRenderingExtensions.setPointPlacementData(resetCycleGap, - _kRenderingExtensions.LEFT, -1.2f, 0.5f, + _kRenderingExtensions.setPointPlacementData(resetCycleGap, + _kRenderingExtensions.LEFT, -1.2f, 0.5f, _kRenderingExtensions.TOP, 0.75f, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 2.5f, 1.3f); - + var resetArrow = _kContainerRenderingExtensions.addPolygon(outerCircle); resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0.1f)); resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0.0f, 0.3f, PositionReferenceY.BOTTOM, 0, 0)); @@ -935,31 +935,31 @@ public KContainerRendering addStateEntry(KContainerRendering parent, StateVar as _kRenderingExtensions.setLineWidth(resetArrow, 0.3f); _kRenderingExtensions.setBackground(resetArrow, Colors.BLACK); _linguaFrancaStyleExtensions.noSelectionStyle(resetArrow); - _kRenderingExtensions.setPointPlacementData(resetArrow, - _kRenderingExtensions.LEFT, 0.8f, 0.5f, - _kRenderingExtensions.TOP, 1.1f, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.setPointPlacementData(resetArrow, + _kRenderingExtensions.LEFT, 0.8f, 0.5f, + _kRenderingExtensions.TOP, 1.1f, 0, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 1.5f, 1.5f); } else { outerCircle = _kContainerRenderingExtensions.addEllipse(container); _kRenderingExtensions.setLineWidth(outerCircle, 1); _kRenderingExtensions.setBackground(outerCircle, Colors.WHITE); _linguaFrancaStyleExtensions.noSelectionStyle(outerCircle); - _kRenderingExtensions.setPointPlacementData(outerCircle, - _kRenderingExtensions.LEFT, 1.5f, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.setPointPlacementData(outerCircle, + _kRenderingExtensions.LEFT, 1.5f, 0, + _kRenderingExtensions.TOP, 0, 0.5f, + _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, 0, 0, 6, 6); } - + var innerDot = _kContainerRenderingExtensions.addEllipse(outerCircle); _kRenderingExtensions.setLineWidth(innerDot, 0.5f); _kRenderingExtensions.setBackground(innerDot, Colors.BLACK); _linguaFrancaStyleExtensions.noSelectionStyle(innerDot); - _kRenderingExtensions.setPointPlacementData(innerDot, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, + _kRenderingExtensions.setPointPlacementData(innerDot, + _kRenderingExtensions.LEFT, 0, 0.5f, + _kRenderingExtensions.TOP, 0, 0.5f, + _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, 0, 2.5f, 2.5f); return container; diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index a86d6fd1f0..9252e93210 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -34,7 +34,7 @@ import java.nio.file.Path; import java.util.List; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.Target; diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index 7a03655923..c6f62fc8d6 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -8,7 +8,7 @@ import java.util.List; import java.util.regex.Pattern; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.InferredType; import org.lflang.TargetConfig.ClockSyncOptions; import org.lflang.TargetProperty; diff --git a/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java b/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java index c533a1f765..15606c6fa0 100644 --- a/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java @@ -28,7 +28,7 @@ import java.io.IOException; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetProperty.CoordinationType; diff --git a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java index 77d6203a93..4a70f4cc6b 100644 --- a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java @@ -5,10 +5,9 @@ import java.io.IOException; import java.util.ArrayList; import java.util.List; -import java.util.LinkedHashMap; import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetProperty.CoordinationType; @@ -18,7 +17,6 @@ import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; import org.lflang.federated.launcher.RtiConfig; -import org.lflang.generator.GeneratorBase; import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.ReactorInstance; import org.lflang.generator.ts.TSTypes; diff --git a/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java b/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java index 7a7eb1f183..cedb9da017 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java +++ b/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java @@ -43,7 +43,7 @@ import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.xtext.xbase.lib.IteratorExtensions; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.ModelInfo; diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java index dddae562f7..595a721c93 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java +++ b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java @@ -28,7 +28,7 @@ import org.eclipse.xtext.util.RuntimeIOException; import org.eclipse.xtext.xbase.lib.Exceptions; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.LFStandaloneSetup; diff --git a/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java index 54e215264f..65b9d4cd15 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java @@ -1,22 +1,13 @@ package org.lflang.federated.generator; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.Set; import java.util.function.Function; import java.util.stream.Collectors; import org.eclipse.emf.ecore.EObject; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.ast.FormattingUtils; -import org.lflang.generator.CodeBuilder; -import org.lflang.generator.ReactorInstance; -import org.lflang.lf.Instantiation; import org.lflang.lf.Reactor; import org.lflang.lf.Variable; diff --git a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java index 354cd33044..154919c816 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java @@ -1,11 +1,10 @@ package org.lflang.federated.generator; -import static org.lflang.ASTUtils.toText; +import static org.lflang.ast.ASTUtils.toText; import java.io.IOException; -import java.util.LinkedHashMap; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.federated.extensions.FedTargetExtensionFactory; import org.lflang.federated.launcher.RtiConfig; diff --git a/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java b/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java index 9af20347c2..af83d1f919 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java @@ -1,6 +1,6 @@ package org.lflang.federated.generator; -import static org.lflang.ASTUtils.convertToEmptyListIfNull; +import static org.lflang.ast.ASTUtils.convertToEmptyListIfNull; import org.lflang.ErrorReporter; import org.lflang.TargetConfig; diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index cdd64f03b2..0669b4f9dc 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -37,7 +37,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.eclipse.emf.ecore.EObject; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.TargetConfig; import org.lflang.TimeValue; diff --git a/org.lflang/src/org/lflang/federated/validation/FedValidator.java b/org.lflang/src/org/lflang/federated/validation/FedValidator.java index ce03b18964..49add78557 100644 --- a/org.lflang/src/org/lflang/federated/validation/FedValidator.java +++ b/org.lflang/src/org/lflang/federated/validation/FedValidator.java @@ -4,7 +4,7 @@ import java.util.List; import java.util.stream.Stream; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; diff --git a/org.lflang/src/org/lflang/generator/CodeBuilder.java b/org.lflang/src/org/lflang/generator/CodeBuilder.java index a921a47239..2b77239680 100644 --- a/org.lflang/src/org/lflang/generator/CodeBuilder.java +++ b/org.lflang/src/org/lflang/generator/CodeBuilder.java @@ -333,27 +333,30 @@ public void startScopedRangeBlock( * source range is reused until the destination range is filled. * The following integer variables will be defined within the scoped block: * - * * src_channel: The channel index for the source. - * * src_bank: The bank index of the source port's parent. - * * src_runtime: The runtime index of the source port's parent or - * the parent's parent (if the source is an input). + *
    + *
  • src_channel: The channel index for the source.
    • + *
  • src_bank: The bank index of the source port's parent.
    • + *
  • src_runtime: The runtime index of the source port's parent or + * the parent's parent (if the source is an input).
    • + *
+ *
    + *
  • dst_channel: The channel index for the destination.
    • + *
  • dst_bank: The bank index of the destination port's parent.
    • + *
  • dst_runtime: The runtime index of the destination port's parent or + * the parent's parent (if destination is an output).
    • + *
* - * * dst_channel: The channel index for the destination. - * * dst_bank: The bank index of the destination port's parent. - * * dst_runtime: The runtime index of the destination port's parent or - * the parent's parent (if destination is an output). + *

For convenience, the above variable names are defined in the private + * class variables sc, sb, sr, and dc, db, dr.

* - * For convenience, the above variable names are defined in the private - * class variables sc, sb, sr, and dc, db, dr. - * - * This block should NOT be nested, where each block is + *

This block should NOT be nested, where each block is * put within a similar block for the reactor's parent. * Within the created block, every use of * {@link CUtil#reactorRef(ReactorInstance, String)} - * and related functions must provide the above variable names. + * and related functions must provide the above variable names.

* - * This must be followed by a call to - * {@link #endScopedRangeBlock(SendRange, RuntimeRange)}. + *

This must be followed by a call to + * {@link #endScopedRangeBlock(SendRange, RuntimeRange)}.

x * * @param srcRange The send range. * @param dstRange The destination range. diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 16eb901676..2243729e09 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -41,7 +41,7 @@ import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.IteratorExtensions; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.MainConflictChecker; diff --git a/org.lflang/src/org/lflang/generator/GeneratorUtils.java b/org.lflang/src/org/lflang/generator/GeneratorUtils.java index 92a57fd424..b4563a6165 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorUtils.java +++ b/org.lflang/src/org/lflang/generator/GeneratorUtils.java @@ -12,7 +12,7 @@ import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.IteratorExtensions; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.TargetConfig; diff --git a/org.lflang/src/org/lflang/generator/LFGenerator.java b/org.lflang/src/org/lflang/generator/LFGenerator.java index 0c9a45dd7c..c8d985e80c 100644 --- a/org.lflang/src/org/lflang/generator/LFGenerator.java +++ b/org.lflang/src/org/lflang/generator/LFGenerator.java @@ -10,7 +10,7 @@ import org.eclipse.xtext.generator.IGeneratorContext; import org.eclipse.xtext.util.RuntimeIOException; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.Target; diff --git a/org.lflang/src/org/lflang/generator/ParameterInstance.java b/org.lflang/src/org/lflang/generator/ParameterInstance.java index 9287710e6b..851fcb627e 100644 --- a/org.lflang/src/org/lflang/generator/ParameterInstance.java +++ b/org.lflang/src/org/lflang/generator/ParameterInstance.java @@ -13,15 +13,15 @@ this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 +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. ***************/ @@ -30,17 +30,15 @@ import java.util.List; import java.util.Optional; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.InferredType; import org.lflang.lf.Assignment; -import org.lflang.lf.Expression; import org.lflang.lf.Initializer; -import org.lflang.lf.LfFactory; import org.lflang.lf.Parameter; -/** +/** * Representation of a compile-time instance of a parameter. - * Upon creation, it is checked whether this parameter is overridden by an + * Upon creation, it is checked whether this parameter is overridden by an * assignment in the instantiation that this parameter instance is a result of. * If it is overridden, the parameter gets initialized using the value looked up * in the instantiation hierarchy. @@ -48,8 +46,8 @@ * @author Edward A. Lee */ public class ParameterInstance extends NamedInstance { - - /** + + /** * Create a runtime instance from the specified definition * and with the specified parent that instantiated it. * @param definition The declaration in the AST. @@ -60,15 +58,15 @@ public ParameterInstance(Parameter definition, ReactorInstance parent) { if (parent == null) { throw new InvalidSourceException("Cannot create a ParameterInstance with no parent."); } - + this.type = ASTUtils.getInferredType(definition); } ///////////////////////////////////////////// //// Public Fields - + public InferredType type; - + ///////////////////////////////////////////// //// Public Methods @@ -94,15 +92,15 @@ public Initializer getActualValue() { } return init; } - + /** - * Return the name of this parameter. + * Return the name of this parameter. * @return The name of this parameter. */ public String getName() { return this.definition.getName(); } - + /** * Return the assignment that overrides this parameter in * the parent's instantiation or null if there is no override. @@ -114,7 +112,7 @@ public Assignment getOverride() { ).findFirst(); return assignment.orElse(null); } - + /** Return a descriptive string. */ @Override public String toString() { diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/src/org/lflang/generator/ReactionInstance.java index c904a39127..98e26c03de 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstance.java @@ -32,7 +32,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.List; import java.util.Set; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.TimeValue; import org.lflang.lf.Action; import org.lflang.lf.BuiltinTriggerRef; @@ -52,7 +52,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * inner class {@link ReactionInstance.Runtime}. Each runtime instance has a "level", which is * its depth an acyclic precedence graph representing the dependencies between * reactions at a tag. - * + * * @author Edward A. Lee * @author Marten Lohstroh */ @@ -69,15 +69,15 @@ public class ReactionInstance extends NamedInstance { * first reaction, 1 for the second, etc.). */ public ReactionInstance( - Reaction definition, - ReactorInstance parent, - boolean isUnordered, + Reaction definition, + ReactorInstance parent, + boolean isUnordered, int index ) { super(definition, parent); this.index = index; this.isUnordered = isUnordered; - + // If the reaction body starts with the magic string // UNORDERED_REACTION_MARKER, then mark it unordered, // overriding the argument. @@ -85,7 +85,7 @@ public ReactionInstance( if (body.contains(UNORDERED_REACTION_MARKER)) { this.isUnordered = true; } - + // Identify the dependencies for this reaction. // First handle the triggers. for (TriggerRef trigger : definition.getTriggers()) { @@ -102,7 +102,7 @@ public ReactionInstance( this.triggers.add(portInstance); } else if (((VarRef)trigger).getContainer() != null) { // Port belongs to a contained reactor or bank. - ReactorInstance containedReactor + ReactorInstance containedReactor = parent.lookupReactorInstance(((VarRef)trigger).getContainer()); if (containedReactor != null) { portInstance = containedReactor.lookupPortInstance((Port)variable); @@ -135,7 +135,7 @@ public ReactionInstance( Variable variable = source.getVariable(); if (variable instanceof Port) { var portInstance = parent.lookupPortInstance((Port)variable); - + // If the trigger is the port of a contained bank, then the // portInstance will be null and we have to instead search for // each port instance in the bank. @@ -157,7 +157,7 @@ public ReactionInstance( } } } - + // Finally, handle the effects. for (VarRef effect : definition.getEffects()) { Variable variable = effect.getVariable(); @@ -191,7 +191,7 @@ public ReactionInstance( ////////////////////////////////////////////////////// //// Public fields. - /** + /** * Indicates the chain this reaction is a part of. It is constructed * through a bit-wise or among all upstream chains. Each fork in the * dependency graph setting a new, unused bit to true in order to @@ -216,7 +216,7 @@ public ReactionInstance( // "sources" are only the inputs a reaction reads without being // triggered by them. The name "reads" used here would be a better // choice in the grammar. - + /** * Deadline for this reaction instance, if declared. */ @@ -269,7 +269,7 @@ public void clearCaches(boolean includingRuntimes) { dependsOnReactionsCache = null; if (includingRuntimes) runtimeInstances = null; } - + /** * Return the set of immediate downstream reactions, which are reactions * that receive data produced by this reaction plus @@ -280,13 +280,13 @@ public Set dependentReactions() { // Cache the result. if (dependentReactionsCache != null) return dependentReactionsCache; dependentReactionsCache = new LinkedHashSet<>(); - + // First, add the next lexical reaction, if appropriate. if (!isUnordered && parent.reactions.size() > index + 1) { // Find the next reaction in the parent's reaction list. dependentReactionsCache.add(parent.reactions.get(index + 1)); } - + // Next, add reactions that get data from this one via a port. for (TriggerInstance effect : effects) { if (effect instanceof PortInstance) { @@ -302,7 +302,7 @@ public Set dependentReactions() { } return dependentReactionsCache; } - + /** * Return the set of immediate upstream reactions, which are reactions * that send data to this one plus at most one reaction in the same @@ -313,7 +313,7 @@ public Set dependsOnReactions() { // Cache the result. if (dependsOnReactionsCache != null) return dependsOnReactionsCache; dependsOnReactionsCache = new LinkedHashSet<>(); - + // First, add the previous lexical reaction, if appropriate. if (!isUnordered && index > 0) { // Find the previous ordered reaction in the parent's reaction list. @@ -326,7 +326,7 @@ public Set dependsOnReactions() { dependsOnReactionsCache.add(parent.reactions.get(index - 1)); } } - + // Next, add reactions that send data to this one. for (TriggerInstance source : sources) { if (source instanceof PortInstance) { @@ -358,7 +358,7 @@ public Set getLevels() { } return result; } - + /** * Return a set of deadlines that runtime instances of this reaction have. * A ReactionInstance may have more than one deadline if it lies within. @@ -370,7 +370,7 @@ public Set getInferredDeadlines() { } return result; } - + /** * Return a list of levels that runtime instances of this reaction have. @@ -389,7 +389,7 @@ public List getLevelsList() { } return result; } - + /** * Return a list of the deadlines that runtime instances of this reaction have. * The size of this list is the total number of runtime instances. @@ -406,14 +406,14 @@ public List getInferredDeadlinesList() { /** * Return the name of this reaction, which is 'reaction_n', - * where n is replaced by the reaction index. + * where n is replaced by the reaction index. * @return The name of this reaction. */ @Override public String getName() { return "reaction_" + this.index; } - + /** * Return an array of runtime instances of this reaction in a * natural order, defined as follows. The position within the @@ -464,7 +464,7 @@ public void removePortInstance(PortInstance portInstance) { clearCaches(false); portInstance.clearCaches(); } - + /** * Return a descriptive string. */ @@ -500,7 +500,7 @@ public TimeValue assignLogicalExecutionTime() { return false; }).map(c -> c.actions.get(0).getMinDelay()) .min(TimeValue::compare); - + if (afters.isPresent()) { if (let == null) { let = afters.get(); @@ -532,7 +532,7 @@ public TimeValue assignLogicalExecutionTime() { /** Cache of the set of upstream reactions. */ private Set dependsOnReactionsCache; - + /** * Array of runtime instances of this reaction. * This has length 1 unless the reaction is contained @@ -563,7 +563,7 @@ public class Runtime { /** ID ranging from 0 to parent.getTotalWidth() - 1. */ public int id; public int level; - + public ReactionInstance getReaction() { return ReactionInstance.this; } diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 80629b81a0..ae5324fa3d 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -26,7 +26,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.generator; -import static org.lflang.ASTUtils.getLiteralTimeValue; +import static org.lflang.ast.ASTUtils.getLiteralTimeValue; import java.util.ArrayList; import java.util.HashMap; @@ -38,7 +38,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Optional; import java.util.Set; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; import org.lflang.TimeValue; diff --git a/org.lflang/src/org/lflang/generator/TargetTypes.java b/org.lflang/src/org/lflang/generator/TargetTypes.java index 8d9788e19e..585d65c96a 100644 --- a/org.lflang/src/org/lflang/generator/TargetTypes.java +++ b/org.lflang/src/org/lflang/generator/TargetTypes.java @@ -4,7 +4,7 @@ import java.util.Objects; import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.InferredType; import org.lflang.TimeValue; import org.lflang.lf.Action; diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index 600100b41d..6e4688af8c 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -2,7 +2,7 @@ import java.util.List; import java.util.ArrayList; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.Target; import org.lflang.generator.ActionInstance; import org.lflang.generator.CodeBuilder; diff --git a/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java b/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java index 72d4939714..f5aa244e60 100644 --- a/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java @@ -1,8 +1,8 @@ package org.lflang.generator.c; -import static org.lflang.ASTUtils.getInferredType; +import static org.lflang.ast.ASTUtils.getInferredType; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.generator.DelayBodyGenerator; import org.lflang.lf.Action; import org.lflang.lf.VarRef; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 31a285af5e..06fbb41427 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -24,14 +24,14 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY package org.lflang.generator.c; -import static org.lflang.ASTUtils.allActions; -import static org.lflang.ASTUtils.allPorts; -import static org.lflang.ASTUtils.allReactions; -import static org.lflang.ASTUtils.allStateVars; -import static org.lflang.ASTUtils.getInferredType; -import static org.lflang.ASTUtils.isInitialized; -import static org.lflang.ASTUtils.toDefinition; -import static org.lflang.ASTUtils.toText; +import static org.lflang.ast.ASTUtils.allActions; +import static org.lflang.ast.ASTUtils.allPorts; +import static org.lflang.ast.ASTUtils.allReactions; +import static org.lflang.ast.ASTUtils.allStateVars; +import static org.lflang.ast.ASTUtils.getInferredType; +import static org.lflang.ast.ASTUtils.isInitialized; +import static org.lflang.ast.ASTUtils.toDefinition; +import static org.lflang.ast.ASTUtils.toText; import static org.lflang.util.StringUtil.addDoubleQuotes; import java.io.File; @@ -52,7 +52,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.StringExtensions; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeMap; import org.lflang.generator.DockerComposeGenerator; import org.lflang.FileConfig; @@ -105,154 +105,123 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * Generator for C target. This class generates C code defining each reactor * class given in the input .lf file and imported .lf files. The generated code * has the following components: - * - * * A typedef for inputs, outputs, and actions of each reactor class. These - * define the types of the variables that reactions use to access inputs and - * action values and to set output values. - * - * * A typedef for a "self" struct for each reactor class. One instance of this - * struct will be created for each reactor instance. See below for details. - * - * * A function definition for each reaction in each reactor class. These - * functions take an instance of the self struct as an argument. - * - * * A constructor function for each reactor class. This is used to create - * a new instance of the reactor. - * - * After these, the main generated function is `_lf_initialize_trigger_objects()`. + *
    + *
  • A typedef for inputs, outputs, and actions of each reactor class. These + * define the types of the variables that reactions use to access inputs and + * action values and to set output values.
    • + *
  • A typedef for a "self" struct for each reactor class. One instance of this + * struct will be created for each reactor instance. See below for details.
    • + *
  • A function definition for each reaction in each reactor class. These + * functions take an instance of the self struct as an argument.
    • + *
  • A constructor function for each reactor class. This is used to create + * a new instance of the reactor. + * After these, the main generated function is _lf_initialize_trigger_objects(). * This function creates the instances of reactors (using their constructors) * and makes connections between them. - * - * A few other smaller functions are also generated. - * - * ## Self Struct - * - * The "self" struct has fields for each of the following: - * - * * parameter: the field name and type match the parameter. - * * state: the field name and type match the state. - * * action: the field name prepends the action name with "_lf_". - * A second field for the action is also created to house the trigger_t object. - * That second field prepends the action name with "_lf__". - * * output: the field name prepends the output name with "_lf_". - * * input: the field name prepends the output name with "_lf_". - * A second field for the input is also created to house the trigger_t object. - * That second field prepends the input name with "_lf__". - * + * A few other smaller functions are also generated.

    Self Struct

    + * The "self" struct has fields for each of the following:
    • + *
  • parameter: the field name and type match the parameter.
    • + *
  • state: the field name and type match the state.
    • + *
  • action: the field name prepends the action name with "lf". + * A second field for the action is also created to house the trigger_t object. + * That second field prepends the action name with "_lf__".
    • + *
  • output: the field name prepends the output name with "lf".
    • + *
  • input: the field name prepends the output name with "lf". + * A second field for the input is also created to house the trigger_t object. + * That second field prepends the input name with "_lf__". * If, in addition, the reactor contains other reactors and reacts to their outputs, * then there will be a struct within the self struct for each such contained reactor. - * The name of that self struct will be the name of the contained reactor prepended with "_lf_". + * The name of that self struct will be the name of the contained reactor prepended with "lf". * That inside struct will contain pointers the outputs of the contained reactors * that are read together with pointers to booleans indicating whether those outputs are present. - * * If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to * trigger_t object (see reactor.h) for the shutdown event and an action struct named - * _lf_shutdown on the self struct. - * - * ## Reaction Functions - * + * _lf_shutdown on the self struct.

    Reaction Functions

    * For each reaction in a reactor class, this generator will produce a C function - * that expects a pointer to an instance of the "self" struct as an argument. + * that expects a pointer to an instance of the "self" struct as an argument. * This function will contain verbatim the C code specified in the reaction, but * before that C code, the generator inserts a few lines of code that extract from the * self struct the variables that that code has declared it will use. For example, if - * the reaction declares that it is triggered by or uses an input named "x" of type - * int, the function will contain a line like this: - * ``` - * r_x_t* x = self->_lf_x; - * ``` - * where `r` is the full name of the reactor class and the struct type `r_x_t` - * has fields `is_present` and `value`, where the type of `value` matches the port type. + * the reaction declares that it is triggered by or uses an input named "x" of type + * int, the function will contain a line like this:
      r_x_t* x = self->_lf_x;
+ *
    where r is the full name of the reactor class and the struct type r_x_t + * has fields is_present and value, where the type of value matches the port type. * If the programmer fails to declare that it uses x, then the absence of the - * above code will trigger a compile error when the verbatim code attempts to read `x`. - * - * ## Constructor - * + * above code will trigger a compile error when the verbatim code attempts to read x.

    Constructor

    * For each reactor class, this generator will create a constructor function named - * `new_r`, where `r` is the reactor class name. This function will malloc and return - * a pointer to an instance of the "self" struct. This struct initially represents + * new_r, where r is the reactor class name. This function will malloc and return + * a pointer to an instance of the "self" struct. This struct initially represents * an unconnected reactor. To establish connections between reactors, additional * information needs to be inserted (see below). The self struct is made visible - * to the body of a reaction as a variable named "self". The self struct contains the - * following: - * - * * Parameters: For each parameter `p` of the reactor, there will be a field `p` - * with the type and value of the parameter. So C code in the body of a reaction - * can access parameter values as `self->p`. - * - * * State variables: For each state variable `s` of the reactor, there will be a field `s` - * with the type and value of the state variable. So C code in the body of a reaction - * can access state variables as `self->s`. - * + * to the body of a reaction as a variable named "self". The self struct contains the + * following:
    • + *
  • Parameters: For each parameter p of the reactor, there will be a field p + * with the type and value of the parameter. So C code in the body of a reaction + * can access parameter values as self->p.
    • + *
  • State variables: For each state variable s of the reactor, there will be a field s + * with the type and value of the state variable. So C code in the body of a reaction + * can access state variables as self->s. * The self struct also contains various fields that the user is not intended to - * use. The names of these fields begin with at least two underscores. They are: - * - * * Outputs: For each output named `out`, there will be a field `_lf_out` that is - * a struct containing a value field whose type matches that of the output. - * The output value is stored here. That struct also has a field `is_present` - * that is a boolean indicating whether the output has been set. - * This field is reset to false at the start of every time - * step. There is also a field `num_destinations` whose value matches the - * number of downstream reactors that use this variable. This field must be - * set when connections are made or changed. It is used to determine for - * a mutable input destination whether a copy needs to be made. - * - * * Inputs: For each input named `in` of type T, there is a field named `_lf_in` - * that is a pointer struct with a value field of type T. The struct pointed - * to also has an `is_present` field of type bool that indicates whether the - * input is present. - * - * * Outputs of contained reactors: If a reactor reacts to outputs of a - * contained reactor `r`, then the self struct will contain a nested struct - * named `_lf_r` that has fields pointing to those outputs. For example, - * if `r` has an output `out` of type T, then there will be field in `_lf_r` - * named `out` that points to a struct containing a value field - * of type T and a field named `is_present` of type bool. - * - * * Inputs of contained reactors: If a reactor sends to inputs of a - * contained reactor `r`, then the self struct will contain a nested struct - * named `_lf_r` that has fields for storing the values provided to those - * inputs. For example, if R has an input `in` of type T, then there will - * be field in _lf_R named `in` that is a struct with a value field - * of type T and a field named `is_present` of type bool. - * - * * Actions: If the reactor has an action a (logical or physical), then there - * will be a field in the self struct named `_lf_a` and another named `_lf__a`. - * The type of the first is specific to the action and contains a `value` - * field with the type and value of the action (if it has a value). That - * struct also has a `has_value` field, an `is_present` field, and a - * `token` field (which is NULL if the action carries no value). - * The `_lf__a` field is of type trigger_t. - * That struct contains various things, including an array of reactions - * sensitive to this trigger and a lf_token_t struct containing the value of - * the action, if it has a value. See reactor.h in the C library for - * details. - * - * * Reactions: Each reaction will have several fields in the self struct. - * Each of these has a name that begins with `_lf__reaction_i`, where i is - * the number of the reaction, starting with 0. The fields are: - * * _lf__reaction_i: The struct that is put onto the reaction queue to - * execute the reaction (see reactor.h in the C library). - * - * * Timers: For each timer t, there is are two fields in the self struct: - * * _lf__t: The trigger_t struct for this timer (see reactor.h). - * * _lf__t_reactions: An array of reactions (pointers to the - * reaction_t structs on this self struct) sensitive to this timer. - * - * * Triggers: For each Timer, Action, Input, and Output of a contained - * reactor that triggers reactions, there will be a trigger_t struct - * on the self struct with name `_lf__t`, where t is the name of the trigger. - * - * ## Connections Between Reactors - * + * use. The names of these fields begin with at least two underscores. They are:
    • + *
  • Outputs: For each output named out, there will be a field _lf_out that is + * a struct containing a value field whose type matches that of the output. + * The output value is stored here. That struct also has a field is_present + * that is a boolean indicating whether the output has been set. + * This field is reset to false at the start of every time + * step. There is also a field num_destinations whose value matches the + * number of downstream reactors that use this variable. This field must be + * set when connections are made or changed. It is used to determine for + * a mutable input destination whether a copy needs to be made.
    • + *
  • Inputs: For each input named in of type T, there is a field named _lf_in + * that is a pointer struct with a value field of type T. The struct pointed + * to also has an is_present field of type bool that indicates whether the + * input is present.
    • + *
  • Outputs of contained reactors: If a reactor reacts to outputs of a + * contained reactor r, then the self struct will contain a nested struct + * named _lf_r that has fields pointing to those outputs. For example, + * if r has an output out of type T, then there will be field in _lf_r + * named out that points to a struct containing a value field + * of type T and a field named is_present of type bool.
    • + *
  • Inputs of contained reactors: If a reactor sends to inputs of a + * contained reactor r, then the self struct will contain a nested struct + * named _lf_r that has fields for storing the values provided to those + * inputs. For example, if R has an input in of type T, then there will + * be field in _lf_R named in that is a struct with a value field + * of type T and a field named is_present of type bool.
    • + *
  • Actions: If the reactor has an action a (logical or physical), then there + * will be a field in the self struct named _lf_a and another named _lf__a. + * The type of the first is specific to the action and contains a value + * field with the type and value of the action (if it has a value). That + * struct also has a has_value field, an is_present field, and a + * token field (which is NULL if the action carries no value). + * The _lf__a field is of type trigger_t. + * That struct contains various things, including an array of reactions + * sensitive to this trigger and a lf_token_t struct containing the value of + * the action, if it has a value. See reactor.h in the C library for + * details.
    • + *
  • Reactions: Each reaction will have several fields in the self struct. + * Each of these has a name that begins with _lf__reaction_i, where i is + * the number of the reaction, starting with 0. The fields are:
      + *
    • _lf__reaction_i: The struct that is put onto the reaction queue to + * execute the reaction (see reactor.h in the C library).
      • + *
    • Timers: For each timer t, there is are two fields in the self struct:
        + *
      • _lf__t: The trigger_t struct for this timer (see reactor.h).
        • + *
      • _lf__t_reactions: An array of reactions (pointers to the + * reaction_t structs on this self struct) sensitive to this timer.
        • + *
      + *
      • + *
    + *
    • + *
  • Triggers: For each Timer, Action, Input, and Output of a contained + * reactor that triggers reactions, there will be a trigger_t struct + * on the self struct with name _lf__t, where t is the name of the trigger.

    Connections Between Reactors

    * Establishing connections between reactors involves two steps. * First, each destination (e.g. an input port) must have pointers to * the source (the output port). As explained above, for an input named - * `in`, the field `_lf_in->value` is a pointer to the output data being read. - * In addition, `_lf_in->is_present` is a pointer to the corresponding - * `out->is_present` field of the output reactor's self struct. - * - * In addition, the `reaction_i` struct on the self struct has a `triggers` + * in, the field _lf_in->value is a pointer to the output data being read. + * In addition, _lf_in->is_present is a pointer to the corresponding + * out->is_present field of the output reactor's self struct. + * In addition, the reaction_i struct on the self struct has a triggers * field that records all the trigger_t structs for ports and actions * that are triggered by the i-th reaction. The triggers field is * an array of arrays of pointers to trigger_t structs. @@ -266,34 +235,30 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * reaction_i struct gives the length of the triggered_sizes and * (outer) triggers arrays. The num_outputs field is equal to the * total number of single ports and multiport channels that the reaction - * writes to. - * - * ## Runtime Tables - * + * writes to.

    Runtime Tables

    * This generator creates an populates the following tables used at run time. - * These tables may have to be resized and adjusted when mutations occur. - * - * * _lf_is_present_fields: An array of pointers to booleans indicating whether an - * event is present. The _lf_start_time_step() function in reactor_common.c uses - * this to mark every event absent at the start of a time step. The size of this - * table is contained in the variable _lf_is_present_fields_size. - * * This table is accompanied by another list, _lf_is_present_fields_abbreviated, - * which only contains the is_present fields that have been set to true in the - * current tag. This list can allow a performance improvement if most ports are - * seldom present because only fields that have been set to true need to be - * reset to false. - * - * * _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown - * reactions. The length of this table is in the _lf_shutdown_triggers_size - * variable. - * - * * _lf_timer_triggers: An array of pointers to trigger_t structs for timers that - * need to be started when the program runs. The length of this table is in the - * _lf_timer_triggers_size variable. - * - * * _lf_action_table: For a federated execution, each federate will have this table - * that maps port IDs to the corresponding action struct, which can be cast to - * action_base_t. + * These tables may have to be resized and adjusted when mutations occur.
    • + *
  • _lf_is_present_fields: An array of pointers to booleans indicating whether an + * event is present. The _lf_start_time_step() function in reactor_common.c uses + * this to mark every event absent at the start of a time step. The size of this + * table is contained in the variable _lf_is_present_fields_size.
      + *
    • This table is accompanied by another list, _lf_is_present_fields_abbreviated, + * which only contains the is_present fields that have been set to true in the + * current tag. This list can allow a performance improvement if most ports are + * seldom present because only fields that have been set to true need to be + * reset to false.
      • + *
    + *
    • + *
  • _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown + * reactions. The length of this table is in the _lf_shutdown_triggers_size + * variable.
    • + *
  • _lf_timer_triggers: An array of pointers to trigger_t structs for timers that + * need to be started when the program runs. The length of this table is in the + * _lf_timer_triggers_size variable.
    • + *
  • _lf_action_table: For a federated execution, each federate will have this table + * that maps port IDs to the corresponding action struct, which can be cast to + * action_base_t.
    • + *
* * @author Edward A. Lee * @author Marten Lohstroh @@ -896,7 +861,7 @@ private void generateReactorDefinitions() throws IOException { * * @param reactorInstance The Reactor Class * @param parentTpr {@link TypeParameterizedReactor} of Parent - * */ + */ private void resolveTemplatedTypes(ReactorInstance reactorInstance, TypeParameterizedReactor parentTpr) { for (var child : reactorInstance.children) { if (parentTpr.typeArgs() != null) { @@ -1052,17 +1017,19 @@ protected void copyTargetFiles() throws IOException { * Generate a reactor class definition for the specified federate. * A class definition has four parts: * - * * Preamble code, if any, specified in the Lingua Franca file. - * * A "self" struct type definition (see the class documentation above). - * * A function for each reaction. - * * A constructor for creating an instance. - * for deleting an instance. + *
    + *
  • Preamble code, if any, specified in the Lingua Franca file.
    • + *
  • A "self" struct type definition (see the class documentation above).
    • + *
  • A function for each reaction.
    • + *
  • A constructor for creating an instance. + * for deleting an instance.
    • + *
* - * If the reactor is the main reactor, then + *

If the reactor is the main reactor, then * the generated code may be customized. Specifically, * if the main reactor has reactions, these reactions * will not be generated if they are triggered by or send - * data to contained reactors that are not in the federate. + * data to contained reactors that are not in the federate.

*/ private void generateReactorClass(TypeParameterizedReactor tpr) throws IOException { // FIXME: Currently we're not reusing definitions for declarations that point to the same definition. diff --git a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java index 691019b160..5da00ac70e 100644 --- a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java @@ -1,8 +1,8 @@ package org.lflang.generator.c; -import static org.lflang.ASTUtils.allMethods; +import static org.lflang.ast.ASTUtils.allMethods; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.InferredType; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Method; diff --git a/org.lflang/src/org/lflang/generator/c/CModesGenerator.java b/org.lflang/src/org/lflang/generator/c/CModesGenerator.java index 48198bbf09..6ff682d49f 100644 --- a/org.lflang/src/org/lflang/generator/c/CModesGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CModesGenerator.java @@ -2,7 +2,7 @@ import java.util.List; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; diff --git a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java index 1d563b5de9..786b4701de 100644 --- a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java @@ -1,7 +1,7 @@ package org.lflang.generator.c; import org.lflang.generator.ParameterInstance; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Initializer; import org.lflang.lf.Parameter; diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index 9cdc20db8f..619a2bd134 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -1,6 +1,6 @@ package org.lflang.generator.c; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; import org.lflang.Target; diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 797ab93beb..4b2d6678b0 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -10,7 +10,7 @@ import java.util.Map; import java.util.Set; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetConfig; diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 00ef4c0faa..993168cad9 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -7,7 +7,7 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Instantiation; import org.lflang.lf.LfFactory; diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java index d2e2a56ed8..f43d975632 100644 --- a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java @@ -1,6 +1,6 @@ package org.lflang.generator.c; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.ModeInstance; import org.lflang.generator.ReactorInstance; diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java index f653d3f997..3a0b1b88de 100644 --- a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java @@ -10,10 +10,9 @@ import java.util.Arrays; import java.util.HashSet; -import java.util.LinkedHashMap; import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.TargetConfig; @@ -685,7 +684,7 @@ private static String deferredInputNumDestinations( )); code.endChannelIteration(port); } - + code.endScopedRangeBlock(sendingRange); } } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index b629684bf7..d403c1cddc 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -9,7 +9,7 @@ package org.lflang.generator.c; import java.util.List; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.generator.CodeBuilder; import org.lflang.generator.ReactorInstance; diff --git a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java index 26925b7486..20ed65687b 100644 --- a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java +++ b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java @@ -6,7 +6,7 @@ import java.util.List; import java.util.Set; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Output; diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 0de272b7bf..5f832e692a 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -5,7 +5,7 @@ import java.util.Map; import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.InferredType; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Instantiation; diff --git a/org.lflang/src/org/lflang/generator/python/PyUtil.java b/org.lflang/src/org/lflang/generator/python/PyUtil.java index 9ca2f7222f..48cc8f9e10 100644 --- a/org.lflang/src/org/lflang/generator/python/PyUtil.java +++ b/org.lflang/src/org/lflang/generator/python/PyUtil.java @@ -28,11 +28,8 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.InferredType; import org.lflang.generator.ReactorInstance; -import org.lflang.generator.GeneratorBase; import org.lflang.generator.c.CUtil; import org.lflang.lf.Expression; -import org.lflang.lf.ParameterReference; -import org.lflang.ASTUtils; /** diff --git a/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java index fd47c4b66e..b69cfc7da0 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java @@ -1,8 +1,7 @@ package org.lflang.generator.python; -import org.lflang.ASTUtils; -import org.lflang.federated.generator.FedASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.generator.c.CDelayBodyGenerator; import org.lflang.generator.c.CUtil; import org.lflang.lf.Action; diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index afa33ac46a..d72f6d4dcd 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -38,7 +38,7 @@ import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.Target; import org.lflang.TargetProperty; diff --git a/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java index 7daba8d542..a2d1e240d1 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java @@ -2,7 +2,7 @@ import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Method; import org.lflang.lf.MethodArgument; import org.lflang.lf.Reactor; diff --git a/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java index fe78d8187f..838e7a27a3 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java @@ -1,20 +1,11 @@ package org.lflang.generator.python; import java.util.ArrayList; -import java.util.LinkedList; import java.util.List; -import java.util.stream.Collectors; -import com.google.common.base.Objects; - -import org.lflang.ASTUtils; -import org.lflang.InferredType; -import org.lflang.generator.GeneratorBase; +import org.lflang.ast.ASTUtils; import org.lflang.generator.ParameterInstance; -import org.lflang.lf.Expression; -import org.lflang.lf.ParameterReference; import org.lflang.lf.ReactorDecl; -import org.lflang.lf.Assignment; import org.lflang.lf.Parameter; diff --git a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java index a5308798d6..0c0c9b6cad 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java @@ -6,11 +6,10 @@ import org.lflang.lf.Output; import org.lflang.lf.Port; import org.lflang.lf.Action; -import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.VarRef; import java.util.List; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.c.CGenerator; import static org.lflang.generator.c.CUtil.generateWidthVariable; diff --git a/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java index e2fd7af86a..b69320f6af 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java @@ -3,7 +3,7 @@ import java.nio.file.Path; import java.util.ArrayList; import java.util.List; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.TargetConfig; import org.lflang.generator.CodeBuilder; import org.lflang.generator.c.CPreambleGenerator; diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java index 8ea44b2a2f..99f1b5c180 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java @@ -4,9 +4,8 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Set; -import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; import org.lflang.Target; diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java index e95e9766bd..49d95e4be9 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java @@ -2,10 +2,8 @@ import java.util.ArrayList; import java.util.List; -import org.lflang.ASTUtils; -import org.lflang.federated.generator.FederateInstance; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; -import org.lflang.generator.DelayBodyGenerator; import org.lflang.generator.ParameterInstance; import org.lflang.generator.ReactorInstance; import org.lflang.lf.Reaction; diff --git a/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java index c8c973f896..e318a8812c 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java @@ -2,9 +2,8 @@ import java.util.ArrayList; import java.util.List; -import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; diff --git a/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java b/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java index 7fc1c899a2..69efcd3fab 100644 --- a/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java +++ b/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java @@ -31,7 +31,7 @@ import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.TargetProperty; import org.lflang.TargetProperty.TargetPropertyType; import org.lflang.generator.InvalidLfSourceException; diff --git a/org.lflang/src/org/lflang/generator/rust/RustModel.kt b/org.lflang/src/org/lflang/generator/rust/RustModel.kt index 521d6fd2ea..82c0080d6e 100644 --- a/org.lflang/src/org/lflang/generator/rust/RustModel.kt +++ b/org.lflang/src/org/lflang/generator/rust/RustModel.kt @@ -27,6 +27,7 @@ package org.lflang.generator.rust import org.lflang.* import org.lflang.TargetProperty.BuildType +import org.lflang.ast.ASTUtils import org.lflang.generator.* import org.lflang.inBlock import org.lflang.indexInContainer @@ -34,12 +35,10 @@ import org.lflang.inferredType import org.lflang.isBank import org.lflang.isInput import org.lflang.isLogical -import org.lflang.isMultiport import org.lflang.lf.* import org.lflang.lf.Timer import java.nio.file.Path import java.util.* -import kotlin.text.capitalize private typealias Ident = String const val PARALLEL_RT_FEATURE = "parallel-runtime" diff --git a/org.lflang/src/org/lflang/generator/rust/RustTypes.kt b/org.lflang/src/org/lflang/generator/rust/RustTypes.kt index 4ff7c0593f..b45a67fcc3 100644 --- a/org.lflang/src/org/lflang/generator/rust/RustTypes.kt +++ b/org.lflang/src/org/lflang/generator/rust/RustTypes.kt @@ -24,7 +24,7 @@ package org.lflang.generator.rust -import org.lflang.ASTUtils.toText +import org.lflang.ast.ASTUtils.toText import org.lflang.InferredType import org.lflang.TimeValue import org.lflang.generator.TargetCode diff --git a/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt index 61aac6750e..e561696524 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt @@ -1,7 +1,6 @@ package org.lflang.generator.ts -import org.lflang.ASTUtils -import org.lflang.Target +import org.lflang.ast.ASTUtils import org.lflang.generator.DelayBodyGenerator import org.lflang.lf.Action import org.lflang.lf.VarRef diff --git a/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt index aca577aad0..b82e1d20af 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt @@ -1,10 +1,8 @@ package org.lflang.generator.ts import org.lflang.ErrorReporter -import org.lflang.ASTUtils -import org.lflang.federated.generator.FederateInstance +import org.lflang.ast.ASTUtils import org.lflang.generator.PrependOperator -import org.lflang.generator.getTargetTimeExpr import org.lflang.isBank import org.lflang.isMultiport import org.lflang.joinWithCommas @@ -12,7 +10,7 @@ import org.lflang.lf.* import org.lflang.lf.Timer import org.lflang.toText import kotlin.collections.HashSet -import java.util.StringJoiner +import java.util.StringJoiner import java.util.LinkedList diff --git a/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt b/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt index 6ac2d8b28a..6ac0d7b321 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt +++ b/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt @@ -1,6 +1,6 @@ package org.lflang.generator.ts -import org.lflang.ASTUtils +import org.lflang.ast.ASTUtils import org.lflang.generator.getTargetInitializer import org.lflang.lf.StateVar import java.util.* diff --git a/org.lflang/src/org/lflang/generator/ts/TSTypes.java b/org.lflang/src/org/lflang/generator/ts/TSTypes.java index e89fff00d4..2e2c6a6dff 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSTypes.java +++ b/org.lflang/src/org/lflang/generator/ts/TSTypes.java @@ -2,7 +2,7 @@ import java.util.List; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.TimeValue; import org.lflang.generator.TargetTypes; import org.lflang.generator.UnsupportedGeneratorFeatureException; diff --git a/org.lflang/src/org/lflang/graph/InstantiationGraph.java b/org.lflang/src/org/lflang/graph/InstantiationGraph.java index 993ae21b2a..53b59cbbb5 100644 --- a/org.lflang/src/org/lflang/graph/InstantiationGraph.java +++ b/org.lflang/src/org/lflang/graph/InstantiationGraph.java @@ -31,7 +31,7 @@ import java.util.Set; import org.eclipse.emf.ecore.resource.Resource; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Instantiation; import org.lflang.lf.Model; import org.lflang.lf.Reactor; diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java index 70a05a40f7..0e521e8cc4 100644 --- a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java +++ b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java @@ -26,7 +26,7 @@ package org.lflang.scoping; import static java.util.Collections.emptyList; -import static org.lflang.ASTUtils.*; +import static org.lflang.ast.ASTUtils.*; import com.google.inject.Inject; diff --git a/org.lflang/src/org/lflang/validation/AttributeSpec.java b/org.lflang/src/org/lflang/validation/AttributeSpec.java index c5a530581b..48b10a140a 100644 --- a/org.lflang/src/org/lflang/validation/AttributeSpec.java +++ b/org.lflang/src/org/lflang/validation/AttributeSpec.java @@ -32,7 +32,7 @@ import java.util.Set; import java.util.stream.Collectors; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.lf.AttrParm; import org.lflang.lf.Attribute; import org.lflang.lf.LfPackage.Literals; diff --git a/org.lflang/src/org/lflang/validation/BaseLFValidator.java b/org.lflang/src/org/lflang/validation/BaseLFValidator.java index 02b321bf10..34e184a720 100644 --- a/org.lflang/src/org/lflang/validation/BaseLFValidator.java +++ b/org.lflang/src/org/lflang/validation/BaseLFValidator.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2021, TU Dresden. - * + * * 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. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE @@ -34,7 +34,7 @@ import org.eclipse.xtext.validation.Check; import org.eclipse.xtext.validation.CheckMode; import org.eclipse.xtext.validation.CheckType; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.TimeUnit; import org.lflang.lf.LfPackage.Literals; import org.lflang.lf.Time; @@ -45,7 +45,7 @@ public class BaseLFValidator extends AbstractLFValidator { public void checkTime(Time time) { if (!ASTUtils.isValidTime(time)) { error("Invalid time unit. " + - "Should be one of " + + "Should be one of " + TimeUnit.list() + ".", Literals.TIME__UNIT); } } diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index fd37e5a3a7..d64eb5dc35 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -26,13 +26,13 @@ ***************/ package org.lflang.validation; -import static org.lflang.ASTUtils.inferPortWidth; -import static org.lflang.ASTUtils.isGeneric; -import static org.lflang.ASTUtils.isInteger; -import static org.lflang.ASTUtils.isOfTimeType; -import static org.lflang.ASTUtils.isZero; -import static org.lflang.ASTUtils.toDefinition; -import static org.lflang.ASTUtils.toOriginalText; +import static org.lflang.ast.ASTUtils.inferPortWidth; +import static org.lflang.ast.ASTUtils.isGeneric; +import static org.lflang.ast.ASTUtils.isInteger; +import static org.lflang.ast.ASTUtils.isOfTimeType; +import static org.lflang.ast.ASTUtils.isZero; +import static org.lflang.ast.ASTUtils.toDefinition; +import static org.lflang.ast.ASTUtils.toOriginalText; import java.io.File; import java.io.IOException; @@ -56,7 +56,7 @@ import org.eclipse.xtext.validation.Check; import org.eclipse.xtext.validation.CheckType; import org.eclipse.xtext.validation.ValidationMessageAcceptor; -import org.lflang.ASTUtils; +import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.InferredType; import org.lflang.ModelInfo; @@ -74,7 +74,6 @@ import org.lflang.lf.BracedListExpression; import org.lflang.lf.BuiltinTrigger; import org.lflang.lf.BuiltinTriggerRef; -import org.lflang.lf.CodeExpr; import org.lflang.lf.Connection; import org.lflang.lf.Deadline; import org.lflang.lf.Expression; From bcbfa449c4de745151bd26081d85ec1d0fdd4a1c Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 15:39:00 -0700 Subject: [PATCH 396/709] Fix JavaDoc in PortInstance.java --- .../src/org/lflang/generator/PortInstance.java | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/PortInstance.java b/org.lflang/src/org/lflang/generator/PortInstance.java index 15383b7676..57dbdcf73d 100644 --- a/org.lflang/src/org/lflang/generator/PortInstance.java +++ b/org.lflang/src/org/lflang/generator/PortInstance.java @@ -131,12 +131,14 @@ public void clearCaches() { * on the returned list. * * Each item in the returned list has the following fields: - * * startRange The starting channel index of this port. - * * rangeWidth The number of channels sent to the destinations. - * * destinations A list of port ranges for destination ports, each - * of which has the same width as rangeWidth. - * - * Each item also has a method, getNumberOfDestinationReactors(), + *
    + *
  • {@code startRange}: The starting channel index of this port.
    • + *
  • {@code rangeWidth}: The number of channels sent to the destinations.
    • + *
  • {@code destinations}: A list of port ranges for destination ports, each + * of which has the same width as {@code rangeWidth}.
    • + *
+ * + * Each item also has a method, {@link SendRange#getNumberOfDestinationReactors()}, * that returns the total number of unique destination reactors for * its range. This is not necessarily the same as the number * of ports in its destinations field because some of the ports may From 96aebff26d6c15a814cb36d1d7164a9cfff8ccaa Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 15:41:19 -0700 Subject: [PATCH 397/709] More MarkDown -> HTML. --- org.lflang/src/org/lflang/generator/ReactionInstance.java | 2 +- org.lflang/src/org/lflang/generator/RuntimeRange.java | 2 +- .../src/org/lflang/generator/c/CTriggerObjectsGenerator.java | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/src/org/lflang/generator/ReactionInstance.java index 98e26c03de..1d7cbab52a 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstance.java @@ -543,7 +543,7 @@ public TimeValue assignLogicalExecutionTime() { * of the containing reactors are w0, w1, and w2, and * we are interested in the instance at bank indexes * b0, b1, and b2. That instance is in this array at - * location given by the **natural ordering**, which + * location given by the natural ordering, which * is the mixed radix number b2%w2; b1%w1. */ private List runtimeInstances; diff --git a/org.lflang/src/org/lflang/generator/RuntimeRange.java b/org.lflang/src/org/lflang/generator/RuntimeRange.java index 449e6dedf9..36f132b27e 100644 --- a/org.lflang/src/org/lflang/generator/RuntimeRange.java +++ b/org.lflang/src/org/lflang/generator/RuntimeRange.java @@ -273,7 +273,7 @@ public RuntimeRange head(int newWidth) { } /** - * Return the list of **natural identifiers** for the runtime instances + * Return the list of natural identifiers for the runtime instances * in this range. Each returned identifier is an integer representation * of the mixed-radix number [d0, ... , dn] with radices [w0, ... , wn], * where d0 is the bank or channel index of this RuntimeRange's instance, which diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java index 3a0b1b88de..2871dbab96 100644 --- a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java @@ -178,7 +178,7 @@ public static String generateSchedulerInitializer( } /** - * * Set the reaction priorities based on dependency analysis. + * Set the reaction priorities based on dependency analysis. * * @param reactor The reactor on which to do this. */ @@ -191,7 +191,7 @@ private static String setReactionPriorities( } /** - * * Set the reaction priorities based on dependency analysis. + * Set the reaction priorities based on dependency analysis. * * @param reactor The reactor on which to do this. * @param builder Where to write the code. From e0dc33abd715e140c965b21ff3bd0a9743731425 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 15:42:51 -0700 Subject: [PATCH 398/709] Revert "Removed the advice to run the formatter" This reverts commit 11ccfad20c2e7fcd150de800e8e1e29d466b6843. --- CONTRIBUTING.md | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 55716f5b17..13d24c957c 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -25,7 +25,8 @@ Test categories are declared in the [TestCategory enum in TestRegistry.java](htt ### Workflow All code contributions must go through a pull request (PR), pass all tests run in CI, and get an approving review before it is merged. Pushing to the `master` branch is restricted. All code review is conducted using the Github review system on PRs. Before requesting a code review, ensure that you have: -- documented your code; +- applied the [code formatter](#code-style-and-formatting); +- [documented](#code-style-and-formatting) your code; - written [tests](#writing-tests) that cover your code; and - accompanied any remaining `TODO`s or `FIXME`s with a link to an active [issue](#reporting-issues). @@ -72,6 +73,18 @@ Perform merges to bring your feature branch up-to-date with master locally (do n #### Addressing reviews To address feedback from code review, implement changes and push to your feature branch. If you are certain that a reviewer's concern has been addressed by your new changes, hit the `Resolve conversation` button. If you are unsure, ask for follow up in the conversation and let the reviewer determine whether the feedback was addressed accordingly. +### Code style and formatting +The Lingua Franca compiler is implemented in Java and Kotlin. The overarching advice is to use each language's most widely used idioms and conventions, which are fortunately very similar. The code base is shipped with a [Spotless](https://github.com/diffplug/spotless) configuration to check and enforce style compliance. Lingua Franca code (e.g., tests) in this repository is also automatically formatted via Spotless. + +- To check that modified files are formatted correctly, run: +``` +./gradlew spotlessCheck +``` +- To apply the changes recommended by the formatter, run: +``` +./gradlew spotlessApply +``` + #### General guidelines - _Do not copy-paste code._ If you want to reuse code, factor it out into a method and call it. - _Keep methods concise._ As a rule of thumb, a method should fit on your screen so that it can be read without scrolling. We impose no hard limit on method length, but anything above 40 lines should be considered for breaking up. From d591db946429d4294b95650400f61bffcaebfc3e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 15:49:37 -0700 Subject: [PATCH 399/709] More MarkDown -> HTML. --- .../src/org/lflang/tests/TestRegistry.java | 22 ++++++++++-------- .../federated/extensions/CExtension.java | 8 ++++--- .../org/lflang/generator/c/CGenerator.java | 23 ++++++++++++------- 3 files changed, 32 insertions(+), 21 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/TestRegistry.java b/org.lflang.tests/src/org/lflang/tests/TestRegistry.java index 10fa68acaf..1249ea25be 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestRegistry.java +++ b/org.lflang.tests/src/org/lflang/tests/TestRegistry.java @@ -110,16 +110,18 @@ public Set getTests(Target t, TestCategory c) { * insensitive. * * For example, the following files will all map to THREADED: - * - C/threaded/Foo.lf - * - C/THREADED/Foo.lf - * - C/Threaded/Foo.lf - * - C/foo/threaded/Bar.lf - * - C/foo/bar/threaded/Threaded.lf - * - C/federated/threaded/bar.lf - * but the following will not: - * - C/Foo.lf (maps to COMMON) - * - C/Threaded.lf (maps to COMMON) - * - C/threaded/federated/foo.lf (maps to FEDERATED) + *
    + *
  • C/threaded/Foo.lf
    • + *
  • C/THREADED/Foo.lf
    • + *
  • C/Threaded/Foo.lf
    • + *
  • C/foo/threaded/Bar.lf
    • + *
  • C/foo/bar/threaded/Threaded.lf
    • + *
  • C/federated/threaded/bar.lf + * but the following will not:
    • + *
  • C/Foo.lf (maps to COMMON)
    • + *
  • C/Threaded.lf (maps to COMMON)
    • + *
  • C/threaded/federated/foo.lf (maps to FEDERATED)
    • + *
* * @author Marten Lohstroh */ diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index 9252e93210..32f06c71bc 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -62,10 +62,12 @@ * An extension class to the CGenerator that enables certain federated * functionalities. Currently, this class offers the following features: * - * - Allocating and initializing C structures for federated communication - - * Creating status field for network input ports that help the receiver logic in + *
    + *
  • Allocating and initializing C structures for federated communication
    • + *
  • Creating status field for network input ports that help the receiver logic in * federate.c communicate the status of a network input port with network input - * control reactions. + * control reactions.
    • + *
* * @author {Soroush Bateni } * @author {Hou Seng Wong } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 06fbb41427..9997b62302 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -780,8 +780,11 @@ private boolean hasDeadlines(List reactors) { * Look at the 'reactor' eResource. * If it is an imported .lf file, incorporate it into the current * program in the following manner: - * - Merge its target property with `targetConfig` - * - If there are any preambles, add them to the preambles of the reactor. + *
    + *
  • Merge its target property with {@code targetConfig}
    • + *
  • If there are any preambles, add them to the preambles of the reactor.
    • + *
+ * */ private void inspectReactorEResource(ReactorDecl reactor) { // If the reactor is imported, look at the @@ -841,9 +844,11 @@ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { * * Imported reactors' original .lf file is * incorporated in the following manner: - * - If there are any cmake-include files, add them to the current list - * of cmake-include files. - * - If there are any preambles, add them to the preambles of the reactor. + *
    + *
  • If there are any cmake-include files, add them to the current list + * of cmake-include files.
    • + *
  • If there are any preambles, add them to the preambles of the reactor.
    • + *
*/ private void generateReactorDefinitions() throws IOException { var generatedReactors = new LinkedHashSet(); @@ -923,9 +928,11 @@ it.tpr, p, getTarget(), errorReporter, types, new CodeBuilder(), true, it.decl() * * Imported reactors' original .lf file is * incorporated in the following manner: - * - If there are any cmake-include files, add them to the current list - * of cmake-include files. - * - If there are any preambles, add them to the preambles of the reactor. + *
    + *
  • If there are any cmake-include files, add them to the current list + * of cmake-include files.
    • + *
  • If there are any preambles, add them to the preambles of the reactor.
    • + *
* * @param reactor Used to extract children from */ From fe6b71aeebc940361c8725eefa5ea6231c7e9f8c Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 15:52:24 -0700 Subject: [PATCH 400/709] More MarkDown -> HTML. --- org.lflang/src/org/lflang/generator/c/CCompiler.java | 8 +++++--- .../org/lflang/generator/python/PythonModeGenerator.java | 6 ++++-- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index e609144b62..80df63fd0e 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -333,9 +333,11 @@ public LFCommand buildWestFlashCommand() { * is shown. * * Errors currently detected: - * - C++ compiler used to compile C files: This error shows up as - * '#error "The CMAKE_C_COMPILER is set to a C++ compiler"' in - * the 'CMakeOutput' string. + *
    + *
  • C++ compiler used to compile C files: This error shows up as + * '#error "The CMAKE_C_COMPILER is set to a C++ compiler"' in + * the 'CMakeOutput' string.
    • + *
* * @param CMakeOutput The captured output from CMake. * @return true if the provided 'CMakeOutput' contains a known error. diff --git a/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java index 638af02eff..90af635727 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java @@ -31,8 +31,10 @@ public static void generateResetReactionsIfNeeded(List reactors) { /** * Generate reset reactions that reset state variables in - * - the reactor, and, - * - the modes within the reactor. + *
    + *
  • the reactor, and,
    • + *
  • the modes within the reactor.
    • + *
* * @param reactor The reactor. */ From af4cabb89bf30cd6ba22c4b9f69b20c56cb78f10 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 15:57:03 -0700 Subject: [PATCH 401/709] More MarkDown -> HTML. --- org.lflang/src/org/lflang/TargetProperty.java | 8 +++++--- .../lflang/federated/extensions/CExtensionUtils.java | 10 ++++++---- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index ac3c183e3c..a974e17f03 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -1421,9 +1421,11 @@ public String toString() { /** * Enumeration of clock synchronization modes. * - * - OFF: The clock synchronization is universally off. - * - STARTUP: Clock synchronization occurs at startup only. - * - ON: Clock synchronization occurs at startup and at runtime. + *
    + *
  • OFF: The clock synchronization is universally off.
    • + *
  • STARTUP: Clock synchronization occurs at startup only.
    • + *
  • ON: Clock synchronization occurs at startup and at runtime.
    • + *
* * @author Edward A. Lee */ diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index c6f62fc8d6..a924403c08 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -39,15 +39,17 @@ public class CExtensionUtils { /** * Generate C code that allocates sufficient memory for the following two * critical data structures that support network control reactions: - * - triggers_for_network_input_control_reactions: These are triggers that + *
    + *
  • triggers_for_network_input_control_reactions: These are triggers that * are * used at runtime to insert network input control reactions into the - * reaction queue. - * - trigger_for_network_output_control_reactions: Triggers for + * reaction queue.
    • + *
  • trigger_for_network_output_control_reactions: Triggers for * network output control reactions, which are unique per each output port. * There could be multiple network output control reactions for each * network - * output port if it is connected to multiple downstream federates. + * output port if it is connected to multiple downstream federates.
    • + *
* * @param federate The top-level federate instance * @return A string that allocates memory for the aforementioned three From a4e9117bebebdd4bc2c6b8a32b45f0cc6c56d2e1 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 15:50:01 -0700 Subject: [PATCH 402/709] Fix JavaDoc in CExtensionUtils.java --- .../org/lflang/federated/extensions/CExtensionUtils.java | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index a924403c08..3eeee4b5cb 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -40,11 +40,10 @@ public class CExtensionUtils { * Generate C code that allocates sufficient memory for the following two * critical data structures that support network control reactions: *
    - *
  • triggers_for_network_input_control_reactions: These are triggers that - * are - * used at runtime to insert network input control reactions into the - * reaction queue.
    • - *
  • trigger_for_network_output_control_reactions: Triggers for + *
  • {@code triggers_for_network_input_control_reactions}: These are triggers that + * are used at runtime to insert network input control reactions into the + * reaction queue.
    • + *
  • {@code trigger_for_network_output_control_reactions}: Triggers for * network output control reactions, which are unique per each output port. * There could be multiple network output control reactions for each * network From f906cb5fee48f9273829b5336dc1c677f3a88abe Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 16:01:36 -0700 Subject: [PATCH 403/709] Backticks -> {@code } --- org.lflang/src/org/lflang/AttributeUtils.java | 4 ++-- org.lflang/src/org/lflang/FileConfig.java | 8 ++++---- org.lflang/src/org/lflang/TargetProperty.java | 2 +- org.lflang/src/org/lflang/ast/ASTUtils.java | 4 ++-- .../lflang/ast/DelayedConnectionTransformation.java | 4 ++-- .../federated/extensions/FedTargetExtension.java | 2 +- org.lflang/src/org/lflang/generator/GeneratorBase.java | 8 ++++---- .../src/org/lflang/generator/LFGeneratorContext.java | 2 +- .../org/lflang/generator/ReactionInstanceGraph.java | 2 +- .../src/org/lflang/generator/ReactorInstance.java | 8 ++++---- org.lflang/src/org/lflang/generator/c/CCompiler.java | 2 +- org.lflang/src/org/lflang/generator/c/CGenerator.java | 4 ++-- .../org/lflang/generator/c/CMainFunctionGenerator.java | 6 +++--- .../src/org/lflang/generator/c/CModesGenerator.java | 4 ++-- .../src/org/lflang/generator/c/CTimerGenerator.java | 2 +- .../org/lflang/generator/python/PythonGenerator.java | 10 +++++----- org.lflang/src/org/lflang/graph/PrecedenceGraph.java | 4 ++-- org.lflang/src/org/lflang/util/LFCommand.java | 2 +- org.lflang/src/org/lflang/util/StringUtil.java | 2 +- org.lflang/src/org/lflang/validation/LFValidator.java | 2 +- 20 files changed, 41 insertions(+), 41 deletions(-) diff --git a/org.lflang/src/org/lflang/AttributeUtils.java b/org.lflang/src/org/lflang/AttributeUtils.java index f5077f2d13..b6fddf0b0e 100644 --- a/org.lflang/src/org/lflang/AttributeUtils.java +++ b/org.lflang/src/org/lflang/AttributeUtils.java @@ -134,12 +134,12 @@ public static String getAttributeValue(EObject node, String attrName) { /** * Retrieve a specific annotation in a comment associated with the given model element in the AST. * - * This will look for a comment. If one is found, it searches for the given annotation `key`. + * This will look for a comment. If one is found, it searches for the given annotation {@code key}. * and extracts any string that follows the annotation marker. * * @param object the AST model element to search a comment for * @param key the specific annotation key to be extracted - * @return `null` if no JavaDoc style comment was found or if it does not contain the given key. + * @return {@code null} if no JavaDoc style comment was found or if it does not contain the given key. * The string immediately following the annotation marker otherwise. */ public static String findAnnotationInComments(EObject object, String key) { diff --git a/org.lflang/src/org/lflang/FileConfig.java b/org.lflang/src/org/lflang/FileConfig.java index 91d681046a..3628d1bde0 100644 --- a/org.lflang/src/org/lflang/FileConfig.java +++ b/org.lflang/src/org/lflang/FileConfig.java @@ -57,8 +57,8 @@ public abstract class FileConfig { * The directory that is the root of the package in which the .lf source file resides. This path is determined * differently depending on whether the compiler is invoked through the IDE or from the command line. In the former * case, the package is the project root that the source resides in. In the latter case, it is the parent directory - * of the nearest `src` directory up the hierarchy, if there is one, or just the `outPath` if there is none. It is - * recommended to always keep the sources in a `src` directory regardless of the workflow, in which case the + * of the nearest {@code src} directory up the hierarchy, if there is one, or just the {@code outPath} if there is none. It is + * recommended to always keep the sources in a {@code src} directory regardless of the workflow, in which case the * output behavior will be identical irrespective of the way the compiler is invoked. */ public final Path srcPkgPath; @@ -117,7 +117,7 @@ public abstract class FileConfig { /** * The parent of the directory designated for placing generated sources into (`./src-gen` by default). Additional - * directories (such as `bin` or `build`) should be created as siblings of the directory for generated sources, + * directories (such as {@code bin} or {@code build}) should be created as siblings of the directory for generated sources, * which means that such directories should be created relative to the path assigned to this class variable. *

    * The generated source directory is specified in the IDE (Project Properties->LF->Compiler->Output Folder). When @@ -164,7 +164,7 @@ public Path getDirectory(Resource r) throws IOException { /** * The parent of the directory designated for placing generated sources into (`./src-gen` by default). Additional - * directories (such as `bin` or `build`) should be created as siblings of the directory for generated sources, + * directories (such as {@code bin} or {@code build}) should be created as siblings of the directory for generated sources, * which means that such directories should be created relative to the path assigned to this class variable. *

    * The generated source directory is specified in the IDE (Project Properties->LF->Compiler->Output Folder). When diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index a974e17f03..e2f193cecd 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -886,7 +886,7 @@ private interface PropertyGetter { /** * Private constructor for target properties. This will take an additional - * `updater`, which will be used to merge target properties from imported resources. + * {@code updater}, which will be used to merge target properties from imported resources. * * @param description String representation of this property. * @param type The type that values assigned to this property diff --git a/org.lflang/src/org/lflang/ast/ASTUtils.java b/org.lflang/src/org/lflang/ast/ASTUtils.java index f6dba5bf4d..bf4efed8f7 100644 --- a/org.lflang/src/org/lflang/ast/ASTUtils.java +++ b/org.lflang/src/org/lflang/ast/ASTUtils.java @@ -895,7 +895,7 @@ public static String baseType(Type type) { /** * Report whether the given literal is zero or not. * @param literal AST node to inspect. - * @return True if the given literal denotes the constant `0`, false + * @return True if the given literal denotes the constant {@code 0}, false * otherwise. */ public static boolean isZero(String literal) { @@ -914,7 +914,7 @@ public static boolean isZero(String literal) { * Report whether the given expression is zero or not. * * @param expr AST node to inspect. - * @return True if the given value denotes the constant `0`, false otherwise. + * @return True if the given value denotes the constant {@code 0}, false otherwise. */ public static boolean isZero(Expression expr) { if (expr instanceof Literal) { diff --git a/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java b/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java index 9a39b803a9..953b9bdfdb 100644 --- a/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java +++ b/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java @@ -42,7 +42,7 @@ /** This class implements AST transformations for delayed connections. There are two types of delayed connections: - 1) Connections with `after`-delays + 1) Connections with {@code after}-delays 2) Physical connections */ public class DelayedConnectionTransformation implements AstTransformation { @@ -396,7 +396,7 @@ private void addDelayClass(Reactor generatedDelay) { /** * Return the generated delay reactor that corresponds to the given class - * name if it had been created already, `null` otherwise. + * name if it had been created already, {@code null} otherwise. */ private Reactor findDelayClass(String className) { return IterableExtensions.findFirst(delayClasses, it -> it.getName().equals(className)); diff --git a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java index 7aa13d6cfc..d50a801617 100644 --- a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java @@ -104,7 +104,7 @@ String generateNetworkOutputControlReactionBody( default void annotateReaction(Reaction reaction) {} /** - * Return the type for the raw network buffer in the target language (e.g., `uint_8` in C). This would be the type of the + * Return the type for the raw network buffer in the target language (e.g., {@code uint_8} in C). This would be the type of the * network messages after serialization and before deserialization. It is primarily used to determine the type for the * network action at the receiver. */ diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 2243729e09..087f4272e2 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -279,7 +279,7 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { targetConfig, errorReporter ); - // FIXME: Should the GeneratorBase pull in `files` from imported + // FIXME: Should the GeneratorBase pull in {@code files} from imported // resources? for (AstTransformation transformation : astTransformations) { @@ -332,8 +332,8 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { // Topologically sort the reactors such that all of a reactor's instantiation dependencies occur earlier in // the sorted list of reactors. This helps the code generator output code in the correct order. - // For example if `reactor Foo {bar = new Bar()}` then the definition of `Bar` has to be generated before - // the definition of `Foo`. + // For example if `reactor Foo {bar = new Bar()}` then the definition of {@code Bar} has to be generated before + // the definition of {@code Foo}. reactors = instantiationGraph.nodesInTopologicalOrder(); // If there is no main reactor or if all reactors in the file need to be validated, then make sure the reactors @@ -353,7 +353,7 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { * * This should be overridden by the target generators. * - * @param targetConfig The targetConfig to read the `files` from. + * @param targetConfig The targetConfig to read the {@code files} from. * @param fileConfig The fileConfig used to make the copy and resolve paths. */ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { diff --git a/org.lflang/src/org/lflang/generator/LFGeneratorContext.java b/org.lflang/src/org/lflang/generator/LFGeneratorContext.java index 5a5eddf178..84032ecdc6 100644 --- a/org.lflang/src/org/lflang/generator/LFGeneratorContext.java +++ b/org.lflang/src/org/lflang/generator/LFGeneratorContext.java @@ -58,7 +58,7 @@ public String getKey() { } /** - * Return the value corresponding to this parameter or `null` if there is none. + * Return the value corresponding to this parameter or {@code null} if there is none. * @param context The context passed to the code generator. */ public String getValue(LFGeneratorContext context) { diff --git a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java b/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java index a1598bff0c..4c5f3ec292 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java @@ -317,7 +317,7 @@ private void assignLevels() { /** * This function assigns inferred deadlines to all the reactions in the graph. - * It is modeled after `assignLevels` but it starts at the leaf nodes and uses + * It is modeled after {@code assignLevels} but it starts at the leaf nodes and uses * Kahns algorithm to build a reverse topologically sorted graph * */ diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index ae5324fa3d..b2f5de66c2 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -319,7 +319,7 @@ public String getName() { /** * @see NamedInstance#uniqueID() * - * Append `_main` to the name of the main reactor to allow instantiations + * Append {@code _main} to the name of the main reactor to allow instantiations * within that reactor to have the same name. */ @Override @@ -1047,11 +1047,11 @@ private boolean findPaths( * and may be ports of a contained bank (a port representing ports of the bank * members) so the returned list includes ranges of banks and channels. * - * If a given port reference has the form `interleaved(b.m)`, where `b` is - * a bank and `m` is a multiport, then the corresponding range in the returned + * If a given port reference has the form `interleaved(b.m)`, where {@code b} is + * a bank and {@code m} is a multiport, then the corresponding range in the returned * list is marked interleaved. * - * For example, if `b` and `m` have width 2, without the interleaved keyword, + * For example, if {@code b} and {@code m} have width 2, without the interleaved keyword, * the returned range represents the sequence `[b0.m0, b0.m1, b1.m0, b1.m1]`. * With the interleaved marking, the returned range represents the sequence * `[b0.m0, b1.m0, b0.m1, b1.m1]`. Both ranges will have width 4. diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 80df63fd0e..586cd05dfb 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -414,7 +414,7 @@ public LFCommand compileCCommand( } // If there is no main reactor, then use the -c flag to prevent linking from occurring. - // FIXME: we could add a `-c` flag to `lfc` to make this explicit in stand-alone mode. + // FIXME: we could add a `-c` flag to {@code lfc} to make this explicit in stand-alone mode. // Then again, I think this only makes sense when we can do linking. if (noBinary) { compileArgs.add("-c"); // FIXME: revisit diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 9997b62302..b25a8af87d 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -814,8 +814,8 @@ private void inspectReactorEResource(ReactorDecl reactor) { } /** - * Copy all files or directories listed in the target property `files`, `cmake-include`, - * and `_fed_setup` into the src-gen folder of the main .lf file + * Copy all files or directories listed in the target property {@code files}, `cmake-include`, + * and {@code _fed_setup} into the src-gen folder of the main .lf file * * @param targetConfig The targetConfig to read the target properties from. * @param fileConfig The fileConfig used to make the copy and resolve paths. diff --git a/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java b/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java index 6261686b8b..db40a88932 100644 --- a/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java @@ -34,7 +34,7 @@ public String generateCode() { } /** - * Generate the `main` function. + * Generate the {@code main} function. */ private String generateMainFunction() { if (targetConfig.platformOptions.platform == Platform.ARDUINO) { @@ -59,7 +59,7 @@ private String generateMainFunction() { ); } else if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { // The Zephyr "runtime" does not terminate when main returns. - // Rather, `exit` should be called explicitly. + // Rather, {@code exit} should be called explicitly. return String.join("\n", "void main(void) {", " int res = lf_reactor_c_main(0, NULL);", @@ -77,7 +77,7 @@ private String generateMainFunction() { /** * Generate code that is used to override the - * command line options to the `main` function + * command line options to the {@code main} function */ private String generateSetDefaultCliOption() { // Generate function to set default command-line options. diff --git a/org.lflang/src/org/lflang/generator/c/CModesGenerator.java b/org.lflang/src/org/lflang/generator/c/CModesGenerator.java index 6ff682d49f..2a6217de64 100644 --- a/org.lflang/src/org/lflang/generator/c/CModesGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CModesGenerator.java @@ -173,7 +173,7 @@ public static String generateStateResetStructure( } /** - * Generate code to call `_lf_process_mode_changes`. + * Generate code to call {@code _lf_process_mode_changes}. * * @param hasModalReactors True if there is modal model reactors, false otherwise * @param modalStateResetCount The number of modal model state resets @@ -200,7 +200,7 @@ public static String generateLfHandleModeChanges( } /** - * Generate code to call `_lf_initialize_modes`. + * Generate code to call {@code _lf_initialize_modes}. * * @param hasModalReactors True if there is modal model reactors, false otherwise */ diff --git a/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java b/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java index 75623fdfe7..57e7556dfe 100644 --- a/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java @@ -50,7 +50,7 @@ public static String generateDeclarations(int timerCount) { } /** - * Generate code to call `_lf_initialize_timer` on each timer. + * Generate code to call {@code _lf_initialize_timer} on each timer. * * @param timerCount The total number of timers in the program */ diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index d72f6d4dcd..3a37ef238b 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -621,12 +621,12 @@ private static String setUpMainTarget(boolean hasMain, String executableName, St } /** - * Generate a (`key`, `val`) tuple pair for the `define_macros` field + * Generate a ({@code key}, {@code val}) tuple pair for the {@code define_macros} field * of the Extension class constructor from setuptools. * * @param key The key of the macro entry * @param val The value of the macro entry - * @return A (`key`, `val`) tuple pair as String + * @return A ({@code key}, {@code val}) tuple pair as String */ private static String generateMacroEntry(String key, String val) { return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; @@ -635,7 +635,7 @@ private static String generateMacroEntry(String key, String val) { /** * Generate the name of the python module. * - * Ideally, this function would belong in a class like `PyFileConfig` + * Ideally, this function would belong in a class like {@code PyFileConfig} * that specifies all the paths to the generated code. * * @param lfModuleName The name of the LF module. @@ -646,9 +646,9 @@ private static String generatePythonModuleName(String lfModuleName) { } /** - * Generate the python file name given an `lfModuleName`. + * Generate the python file name given an {@code lfModuleName}. * - * Ideally, this function would belong in a class like `PyFileConfig` + * Ideally, this function would belong in a class like {@code PyFileConfig} * that specifies all the paths to the generated code. * * @param lfModuleName The name of the LF module diff --git a/org.lflang/src/org/lflang/graph/PrecedenceGraph.java b/org.lflang/src/org/lflang/graph/PrecedenceGraph.java index 6763fd1cb3..03fd266f6a 100644 --- a/org.lflang/src/org/lflang/graph/PrecedenceGraph.java +++ b/org.lflang/src/org/lflang/graph/PrecedenceGraph.java @@ -34,7 +34,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.ArrayList; /** - * Elaboration of `DirectedGraph` that is capable of identifying strongly + * Elaboration of {@code DirectedGraph} that is capable of identifying strongly * connected components and topologically sorting its nodes. * * @author Marten Lohstroh @@ -147,7 +147,7 @@ private void visit(T node) { /** * Run Tarjan's algorithm for finding strongly connected components. * After invoking this method, the detected cycles with be listed - * in the class variable `cycles`. + * in the class variable {@code cycles}. */ public void detectCycles() { if (!this.cycleAnalysisDone) { diff --git a/org.lflang/src/org/lflang/util/LFCommand.java b/org.lflang/src/org/lflang/util/LFCommand.java index 32e157e775..1d7fdf4aaf 100644 --- a/org.lflang/src/org/lflang/util/LFCommand.java +++ b/org.lflang/src/org/lflang/util/LFCommand.java @@ -276,7 +276,7 @@ public static LFCommand get(final String cmd, final List args, boolean q * This will check first if the command can actually be found and executed. If the command is not found, null is * returned. In order to find the command, different methods are applied in the following order: *

    - * 1. Check if the given command `cmd` is an executable file within `dir`. + * 1. Check if the given command {@code cmd} is an executable file within {@code dir}. * 2. If the above fails 'which ' (or 'where ' on Windows) is executed to see if the command is available * on the PATH. * 3. If both points above fail, a third attempt is started using bash to indirectly execute the command (see below diff --git a/org.lflang/src/org/lflang/util/StringUtil.java b/org.lflang/src/org/lflang/util/StringUtil.java index 9be21d46e8..31beef8a9b 100644 --- a/org.lflang/src/org/lflang/util/StringUtil.java +++ b/org.lflang/src/org/lflang/util/StringUtil.java @@ -48,7 +48,7 @@ private StringUtil() { /** * Convert a string in Camel case to snake case. E.g. - * `MinimalReactor` will be converted to `minimal_reactor`. + * {@code MinimalReactor} will be converted to {@code minimal_reactor}. * The string is assumed to be a single camel case identifier * (no whitespace). */ diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index d64eb5dc35..1586eb63d0 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -152,7 +152,7 @@ public void checkAction(Action action) { checkName(action.getName(), Literals.VARIABLE__NAME); if (action.getOrigin() == ActionOrigin.NONE) { error( - "Action must have modifier `logical` or `physical`.", + "Action must have modifier {@code logical} or {@code physical}.", Literals.ACTION__ORIGIN ); } From 617ca21b9ce3ba39967749b90150bc8a0def0977 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 16:05:00 -0700 Subject: [PATCH 404/709] More backticks -> {@code } --- org.lflang.tests/src/org/lflang/tests/TestBase.java | 2 +- org.lflang/src/org/lflang/FileConfig.java | 8 ++++---- org.lflang/src/org/lflang/TargetProperty.java | 4 ++-- .../org/lflang/federated/extensions/CExtension.java | 2 +- .../federated/launcher/FedLauncherGenerator.java | 2 +- .../src/org/lflang/generator/GeneratorBase.java | 12 ++++++------ .../src/org/lflang/generator/ReactorInstance.java | 6 +++--- org.lflang/src/org/lflang/generator/c/CCompiler.java | 4 ++-- .../src/org/lflang/generator/c/CGenerator.java | 2 +- .../lflang/generator/c/CMainFunctionGenerator.java | 2 +- .../org/lflang/generator/c/CReactionGenerator.java | 2 +- .../lflang/generator/c/CTriggerObjectsGenerator.java | 2 +- org.lflang/src/org/lflang/generator/c/CUtil.java | 12 ++++++------ .../org/lflang/generator/python/PythonGenerator.java | 2 +- .../generator/python/PythonReactionGenerator.java | 4 ++-- .../src/org/lflang/graph/InstantiationGraph.java | 4 ++-- org.lflang/src/org/lflang/util/LFCommand.java | 2 +- .../src/org/lflang/validation/LFValidator.java | 2 +- 18 files changed, 37 insertions(+), 37 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/TestBase.java b/org.lflang.tests/src/org/lflang/tests/TestBase.java index 101df920f0..192a531828 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestBase.java +++ b/org.lflang.tests/src/org/lflang/tests/TestBase.java @@ -381,7 +381,7 @@ private static void checkAndReportFailures(Set tests) { /** * Configure a test by applying the given configurator and return a * generator context. Also, if the given level is less than - * `TestLevel.BUILD`, add a `no-compile` flag to the generator context. If + * {@code TestLevel.BUILD}, add a {@code no-compile} flag to the generator context. If * the configurator was not applied successfully, throw an AssertionError. * * @param test the test to configure. diff --git a/org.lflang/src/org/lflang/FileConfig.java b/org.lflang/src/org/lflang/FileConfig.java index 3628d1bde0..e2d3313a61 100644 --- a/org.lflang/src/org/lflang/FileConfig.java +++ b/org.lflang/src/org/lflang/FileConfig.java @@ -116,12 +116,12 @@ public abstract class FileConfig { // private fields /** - * The parent of the directory designated for placing generated sources into (`./src-gen` by default). Additional + * The parent of the directory designated for placing generated sources into ({@code ./src-gen} by default). Additional * directories (such as {@code bin} or {@code build}) should be created as siblings of the directory for generated sources, * which means that such directories should be created relative to the path assigned to this class variable. *

    * The generated source directory is specified in the IDE (Project Properties->LF->Compiler->Output Folder). When - * invoking the standalone compiler, the output path is specified directly using the `-o` or `--output-path` option. + * invoking the standalone compiler, the output path is specified directly using the {@code -o} or {@code --output-path} option. */ private final Path outPath; @@ -163,12 +163,12 @@ public Path getDirectory(Resource r) throws IOException { } /** - * The parent of the directory designated for placing generated sources into (`./src-gen` by default). Additional + * The parent of the directory designated for placing generated sources into ({@code ./src-gen} by default). Additional * directories (such as {@code bin} or {@code build}) should be created as siblings of the directory for generated sources, * which means that such directories should be created relative to the path assigned to this class variable. *

    * The generated source directory is specified in the IDE (Project Properties->LF->Compiler->Output Folder). When - * invoking the standalone compiler, the output path is specified directly using the `-o` or `--output-path` option. + * invoking the standalone compiler, the output path is specified directly using the {@code -o} or {@code --output-path} option. */ public Path getOutPath() { return outPath; diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index e2f193cecd..fe5c7dd0b2 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -666,8 +666,8 @@ public enum TargetProperty { * List of module files to link into the crate as top-level. * For instance, a {@code target Rust { rust-modules: [ "foo.rs" ] }} * will cause the file to be copied into the generated project, - * and the generated `main.rs` will include it with a `mod foo;`. - * If one of the paths is a directory, it must contain a `mod.rs` + * and the generated {@code main.rs} will include it with a {@code mod foo;}. + * If one of the paths is a directory, it must contain a {@code mod.rs} * file, and all its contents are copied. */ RUST_INCLUDE("rust-include", diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index 32f06c71bc..18b5d9615a 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -482,7 +482,7 @@ public String generatePreamble( RtiConfig rtiConfig, ErrorReporter errorReporter ) throws IOException { - // Put the C preamble in a `include/_federate.name + _preamble.h` file + // Put the C preamble in a {@code include/_federate.name + _preamble.h} file String cPreamble = makePreamble(federate, fileConfig, rtiConfig, errorReporter); String relPath = getPreamblePath(federate); Path fedPreamblePath = fileConfig.getSrcPath().resolve(relPath); diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java index 3ad08e2450..4f544c5653 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java +++ b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java @@ -291,7 +291,7 @@ private String getSetupCode() { "", "# Create a random 48-byte text ID for this federation.", "# The likelihood of two federations having the same ID is 1/16,777,216 (1/2^24).", - "FEDERATION_ID=`openssl rand -hex 24`", + "FEDERATION_ID={@code openssl rand -hex 24}", "echo \"Federate " + fileConfig.name + " in Federation ID '$FEDERATION_ID'\"", "# Launch the federates:" ); diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 087f4272e2..8d57e4c522 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -116,7 +116,7 @@ public abstract class GeneratorBase extends AbstractLFValidator { * A list of Reactor definitions in the main resource, including non-main * reactors defined in imported resources. These are ordered in the list in * such a way that each reactor is preceded by any reactor that it instantiates - * using a command like `foo = new Foo();` + * using a command like {@code foo = new Foo();} */ protected List reactors = new ArrayList<>(); @@ -129,9 +129,9 @@ public abstract class GeneratorBase extends AbstractLFValidator { * Graph that tracks dependencies between instantiations. * This is a graph where each node is a Reactor (not a ReactorInstance) * and an arc from Reactor A to Reactor B means that B contains an instance of A, constructed with a statement - * like `a = new A();` After creating the graph, + * like {@code a = new A();} After creating the graph, * sort the reactors in topological order and assign them to the reactors class variable. - * Hence, after this method returns, `this.reactors` will be a list of Reactors such that any + * Hence, after this method returns, {@code this.reactors} will be a list of Reactors such that any * reactor is preceded in the list by reactors that it instantiates. */ protected InstantiationGraph instantiationGraph; @@ -321,9 +321,9 @@ protected void cleanIfNeeded(LFGeneratorContext context) { /** * Create a new instantiation graph. This is a graph where each node is a Reactor (not a ReactorInstance) * and an arc from Reactor A to Reactor B means that B contains an instance of A, constructed with a statement - * like `a = new A();` After creating the graph, + * like {@code a = new A();} After creating the graph, * sort the reactors in topological order and assign them to the reactors class variable. - * Hence, after this method returns, `this.reactors` will be a list of Reactors such that any + * Hence, after this method returns, {@code this.reactors} will be a list of Reactors such that any * reactor is preceded in the list by reactors that it instantiates. */ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { @@ -332,7 +332,7 @@ protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { // Topologically sort the reactors such that all of a reactor's instantiation dependencies occur earlier in // the sorted list of reactors. This helps the code generator output code in the correct order. - // For example if `reactor Foo {bar = new Bar()}` then the definition of {@code Bar} has to be generated before + // For example if {@code reactor Foo {bar = new Bar()}} then the definition of {@code Bar} has to be generated before // the definition of {@code Foo}. reactors = instantiationGraph.nodesInTopologicalOrder(); diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index b2f5de66c2..332c48b73f 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -1047,14 +1047,14 @@ private boolean findPaths( * and may be ports of a contained bank (a port representing ports of the bank * members) so the returned list includes ranges of banks and channels. * - * If a given port reference has the form `interleaved(b.m)`, where {@code b} is + * If a given port reference has the form {@code interleaved(b.m)}, where {@code b} is * a bank and {@code m} is a multiport, then the corresponding range in the returned * list is marked interleaved. * * For example, if {@code b} and {@code m} have width 2, without the interleaved keyword, - * the returned range represents the sequence `[b0.m0, b0.m1, b1.m0, b1.m1]`. + * the returned range represents the sequence {@code [b0.m0, b0.m1, b1.m0, b1.m1]}. * With the interleaved marking, the returned range represents the sequence - * `[b0.m0, b1.m0, b0.m1, b1.m1]`. Both ranges will have width 4. + * {@code [b0.m0, b1.m0, b0.m1, b1.m1]}. Both ranges will have width 4. * * @param references The variable references on one side of the connection. * @param connection The connection. diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 586cd05dfb..9fcb72b4a6 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -304,7 +304,7 @@ public LFCommand buildCmakeCommand() { * Return a flash/emulate command using west. * If board is null (defaults to qemu_cortex_m3) or qemu_* * Return a flash command which runs the target as an emulation - * If ordinary target, return `west flash` + * If ordinary target, return {@code west flash} */ public LFCommand buildWestFlashCommand() { // Set the build directory to be "build" @@ -414,7 +414,7 @@ public LFCommand compileCCommand( } // If there is no main reactor, then use the -c flag to prevent linking from occurring. - // FIXME: we could add a `-c` flag to {@code lfc} to make this explicit in stand-alone mode. + // FIXME: we could add a {@code -c} flag to {@code lfc} to make this explicit in stand-alone mode. // Then again, I think this only makes sense when we can do linking. if (noBinary) { compileArgs.add("-c"); // FIXME: revisit diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b25a8af87d..fce667067c 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -814,7 +814,7 @@ private void inspectReactorEResource(ReactorDecl reactor) { } /** - * Copy all files or directories listed in the target property {@code files}, `cmake-include`, + * Copy all files or directories listed in the target property {@code files}, {@code cmake-include}, * and {@code _fed_setup} into the src-gen folder of the main .lf file * * @param targetConfig The targetConfig to read the target properties from. diff --git a/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java b/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java index db40a88932..533611368a 100644 --- a/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java @@ -22,7 +22,7 @@ public CMainFunctionGenerator(TargetConfig targetConfig) { * Generate the code that is the entry point * of the program. * - * Ideally, this code would belong to its own `main.c` + * Ideally, this code would belong to its own {@code main.c} * file, but it currently lives in the same file * as all the code generated for reactors. */ diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 4b2d6678b0..26e6c8ab6f 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -1179,7 +1179,7 @@ public static String generateStpFunctionHeader(TypeParameterizedReactor tpr, /** * Return the start of a function declaration for a function that takes - * a `void*` argument and returns void. + * a {@code void*} argument and returns void. * * @param functionName * @return diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java index 2871dbab96..99df04e9d3 100644 --- a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java @@ -966,7 +966,7 @@ private static String deferredReactionMemory( * to a contained reactor, then generate code to allocate * memory to store the data produced by those reactions. * The allocated memory is pointed to by a field called - * `_lf_containername.portname` on the self struct of the reactor. + * {@code _lf_containername.portname} on the self struct of the reactor. * @param reactor The reactor. */ private static String deferredAllocationForEffectsOnInputs( diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 51348915b9..b2a34790b2 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -208,7 +208,7 @@ public static String portRef( * port's parent. This is used when an input port triggers a reaction * in the port's parent or when an output port is written to by * a reaction in the port's parent. - * This is equivalent to calling `portRef(port, false, true, null, null)`. + * This is equivalent to calling {@code portRef(port, false, true, null, null)}. * @param port An instance of the port to be referenced. */ public static String portRef(PortInstance port) { @@ -221,7 +221,7 @@ public static String portRef(PortInstance port) { * This is used when an input port triggers a reaction * in the port's parent or when an output port is written to by * a reaction in the port's parent. - * This is equivalent to calling `portRef(port, false, true, bankIndex, channelIndex)`. + * This is equivalent to calling {@code portRef(port, false, true, bankIndex, channelIndex)}. * @param port An instance of the port to be referenced. * @param runtimeIndex A variable name to use to index the runtime instance or * null to use the default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. @@ -269,7 +269,7 @@ public static String portRefName( * is written to by a reaction in the parent of the port's parent, * or when an output port triggers a reaction in the parent of the * port's parent. This is equivalent to calling - * `portRef(port, true, true, null, null, null)`. + * {@code portRef(port, true, true, null, null, null)}. * * @param port The port. */ @@ -283,7 +283,7 @@ public static String portRefNested(PortInstance port) { * is written to by a reaction in the parent of the port's parent, * or when an output port triggers a reaction in the parent of the * port's parent. This is equivalent to calling - * `portRef(port, true, true, runtimeIndex, bankIndex, channelIndex)`. + * {@code portRef(port, true, true, runtimeIndex, bankIndex, channelIndex)}. * * @param port The port. * @param runtimeIndex A variable name to use to index the runtime instance or @@ -306,7 +306,7 @@ public static String portRefNested( * is written to by a reaction in the parent of the port's parent, * or when an output port triggers a reaction in the parent of the * port's parent. - * This is equivalent to calling `portRef(port, true, false, null, null, null)`. + * This is equivalent to calling {@code portRef(port, true, false, null, null, null)}. * * @param port The port. */ @@ -321,7 +321,7 @@ public static String portRefNestedName(PortInstance port) { * is written to by a reaction in the parent of the port's parent, * or when an output port triggers a reaction in the parent of the * port's parent. This is equivalent to calling - * `portRefNested(port, true, false, runtimeIndex, bankIndex, channelIndex)`. + * {@code portRefNested(port, true, false, runtimeIndex, bankIndex, channelIndex)}. * * @param port The port. * @param runtimeIndex A variable name to use to index the runtime instance or diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 3a37ef238b..83053d6897 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -457,7 +457,7 @@ protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { protected void generateReaction(CodeBuilder src, Reaction reaction, TypeParameterizedReactor tpr, int reactionIndex) { Reactor reactor = ASTUtils.toDefinition(tpr.reactor()); - // Reactions marked with a `@_c_body` attribute are generated in C + // Reactions marked with a {@code @_c_body} attribute are generated in C if (AttributeUtils.hasCBody(reaction)) { super.generateReaction(src, reaction, tpr, reactionIndex); return; diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java index 99f1b5c180..3d307b6b52 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java @@ -380,7 +380,7 @@ public static String generateCPythonReactionLinkers( code.pr(nameOfSelfStruct+"->_lf_name = \""+instance.uniqueID()+"_lf\";"); for (ReactionInstance reaction : instance.reactions) { - // Reactions marked with a `@_c_body` attribute are generated in C + // Reactions marked with a {@code @_c_body} attribute are generated in C if (AttributeUtils.hasCBody(reaction.getDefinition())) continue; // Create a PyObject for each reaction code.pr(generateCPythonReactionLinker(instance, reaction, nameOfSelfStruct)); @@ -479,7 +479,7 @@ public static String generatePythonReactions(Reactor reactor, List rea * @param reaction The reaction of reactor */ public static String generatePythonReaction(Reactor reactor, Reaction reaction, int reactionIndex) { - // Reactions marked with a `@_c_body` attribute are generated in C + // Reactions marked with a {@code @_c_body} attribute are generated in C if (AttributeUtils.hasCBody(reaction)) return ""; CodeBuilder code = new CodeBuilder(); diff --git a/org.lflang/src/org/lflang/graph/InstantiationGraph.java b/org.lflang/src/org/lflang/graph/InstantiationGraph.java index 53b59cbbb5..b32c97e2f2 100644 --- a/org.lflang/src/org/lflang/graph/InstantiationGraph.java +++ b/org.lflang/src/org/lflang/graph/InstantiationGraph.java @@ -49,12 +49,12 @@ * confusing and subtle distinction here between an "instantiation" * and an "instance". They are not the same thing at all. An * "instantiation" is an AST node representing a statement like - * `a = new A();`. This can result in many instances of reactor + * {@code a = new A();}. This can result in many instances of reactor * class A (if the containing reactor class is instantiated multiple times). * * In addition to the graph, this class keeps track of the instantiations * that induce the dependencies. These can be retrieved using the method - * `getInstantiations(Reactor)`. + * {@code getInstantiations(Reactor)}. * * @author Marten Lohstroh */ diff --git a/org.lflang/src/org/lflang/util/LFCommand.java b/org.lflang/src/org/lflang/util/LFCommand.java index 1d7fdf4aaf..4f6927dcf0 100644 --- a/org.lflang/src/org/lflang/util/LFCommand.java +++ b/org.lflang/src/org/lflang/util/LFCommand.java @@ -156,7 +156,7 @@ private void poll(Process process, CancelIndicator cancelIndicator) { /** * Execute the command. *

    - * Executing a process directly with `processBuilder.start()` could + * Executing a process directly with {@code processBuilder.start()} could * lead to a deadlock as the subprocess blocks when output or error * buffers are full. This method ensures that output and error messages * are continuously read and forwards them to the system output and diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 1586eb63d0..36c09cf678 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -1259,7 +1259,7 @@ public void checkWidthSpec(WidthSpec widthSpec) { error("Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); } } else if (term.getPort() != null) { - // Widths given with `widthof()` are not supported (yet?). + // Widths given with {@code widthof()} are not supported (yet?). // This feature is currently only used for after delays. error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); } else if (term.getCode() != null) { From d58b27c23faa1b4fcb82f890c22883c1d8464e24 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 16:12:40 -0700 Subject: [PATCH 405/709] More backticks/triple backticks -> JavaDoc. --- org.lflang/src/org/lflang/ast/ASTUtils.java | 107 ++++++++---------- .../org/lflang/generator/ReactorInstance.java | 2 +- .../lflang/generator/c/CActionGenerator.java | 4 +- .../lflang/generator/c/CPortGenerator.java | 4 +- .../src/org/lflang/generator/c/CUtil.java | 2 +- 5 files changed, 52 insertions(+), 67 deletions(-) diff --git a/org.lflang/src/org/lflang/ast/ASTUtils.java b/org.lflang/src/org/lflang/ast/ASTUtils.java index bf4efed8f7..26d4e0d6b0 100644 --- a/org.lflang/src/org/lflang/ast/ASTUtils.java +++ b/org.lflang/src/org/lflang/ast/ASTUtils.java @@ -1229,69 +1229,54 @@ public static boolean isOfTimeType(Parameter param) { } /** - * Given a parameter, return its initial value. - * The initial value is a list of instances of Expressions. + * Given a parameter, return its initial value. + * The initial value is a list of instances of Expressions. * - * If the instantiations argument is null or an empty list, then the - * value returned is simply the default value given when the parameter - * is defined. - * - * If a list of instantiations is given, then the first instantiation - * is required to be an instantiation of the reactor class that is - * parameterized by the parameter. I.e., - * ``` - * parameter.eContainer == instantiations.get(0).reactorClass - * ``` - * If a second instantiation is given, then it is required to be an instantiation of a - * reactor class that contains the first instantiation. That is, - * ``` - * instantiations.get(0).eContainer == instantiations.get(1).reactorClass - * ``` - * More generally, for all 0 <= i < instantiations.size - 1, - * ``` - * instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass - * ``` - * If any of these conditions is not satisfied, then an IllegalArgumentException - * will be thrown. - * - * Note that this chain of reactions cannot be inferred from the parameter because - * in each of the predicates above, there may be more than one instantiation that - * can appear on the right hand side of the predicate. - * - * For example, consider the following program: - * ``` - * reactor A(x:int(1)) {} - * reactor B(y:int(2)) { - * a1 = new A(x = y); - * a2 = new A(x = -1); - * } - * reactor C(z:int(3)) { - * b1 = new B(y = z); - * b2 = new B(y = -2); - * } - * ``` - * Notice that there are a total of four instances of reactor class A. - * Then - * ``` - * initialValue(x, null) returns 1 - * initialValue(x, [a1]) returns 2 - * initialValue(x, [a2]) returns -1 - * initialValue(x, [a1, b1]) returns 3 - * initialValue(x, [a2, b1]) returns -1 - * initialValue(x, [a1, b2]) returns -2 - * initialValue(x, [a2, b2]) returns -1 - * ``` - * (Actually, in each of the above cases, the returned value is a list with - * one entry, a Literal, e.g. ["1"]). - * - * There are two instances of reactor class B. - * ``` - * initialValue(y, null) returns 2 - * initialValue(y, [a1]) throws an IllegalArgumentException - * initialValue(y, [b1]) returns 3 - * initialValue(y, [b2]) returns -2 - * ``` + * If the instantiations argument is null or an empty list, then the + * value returned is simply the default value given when the parameter + * is defined. * + * If a list of instantiations is given, then the first instantiation + * is required to be an instantiation of the reactor class that is + * parameterized by the parameter. I.e., + * 

         parameter.eContainer == instantiations.get(0).reactorClass
+     *

    If a second instantiation is given, then it is required to be an instantiation of a + * reactor class that contains the first instantiation. That is,

    + * 
         instantiations.get(0).eContainer == instantiations.get(1).reactorClass
+     *

    More generally, for all 0 <= i < instantiations.size - 1,

    + * 
         instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass
+     *

    If any of these conditions is not satisfied, then an IllegalArgumentException + * will be thrown.

    + *

    Note that this chain of reactions cannot be inferred from the parameter because + * in each of the predicates above, there may be more than one instantiation that + * can appear on the right hand side of the predicate.

    + *

    For example, consider the following program:

    + * 
         reactor A(x:int(1)) {}
+     *      reactor B(y:int(2)) {
+     *          a1 = new A(x = y);
+     *          a2 = new A(x = -1);
+     *      }
+     *      reactor C(z:int(3)) {
+     *          b1 = new B(y = z);
+     *          b2 = new B(y = -2);
+     *      }
+     *

    Notice that there are a total of four instances of reactor class A. + * Then

    + * 
         initialValue(x, null) returns 1
+     *      initialValue(x, [a1]) returns 2
+     *      initialValue(x, [a2]) returns -1
+     *      initialValue(x, [a1, b1]) returns 3
+     *      initialValue(x, [a2, b1]) returns -1
+     *      initialValue(x, [a1, b2]) returns -2
+     *      initialValue(x, [a2, b2]) returns -1
+     *

    (Actually, in each of the above cases, the returned value is a list with + * one entry, a Literal, e.g. ["1"]).

    + *

    There are two instances of reactor class B.

    + * 
         initialValue(y, null) returns 2
+     *      initialValue(y, [a1]) throws an IllegalArgumentException
+     *      initialValue(y, [b1]) returns 3
+     *      initialValue(y, [b2]) returns -2
+     *
    * @param parameter The parameter. * @param instantiations The (optional) list of instantiations. * diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 332c48b73f..e40c3f988a 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -194,7 +194,7 @@ public ReactionInstanceGraph assignLevels() { /** * This function assigns/propagates deadlines through the Reaction Instance Graph. - * It performs Kahn`s algorithm in reverse, starting from the leaf nodes and + * It performs Kahn's algorithm in reverse, starting from the leaf nodes and * propagates deadlines upstream. To reduce cost, it should only be invoked when * there are user-specified deadlines in the program. * @return diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index 6e4688af8c..5f81de89aa 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -149,9 +149,9 @@ public static String generateAuxiliaryStruct( * For the specified action, return a declaration for action struct to * contain the value of the action. An action of * type int[10], for example, will result in this: - * ``` + * 
    
      *     int* value;
-     * ```
+     *
    * This will return an empty string for an action with no type. * @param tpr {@link TypeParameterizedReactor} * @param action The action. diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index 619a2bd134..f82bad661c 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -172,9 +172,9 @@ public static String initializeOutputMultiport( * For the specified port, return a declaration for port struct to * contain the value of the port. A multiport output with width 4 and * type int[10], for example, will result in this: - * ``` + * 
    
      *     int value[10];
-     * ```
+     *
    * There will be an array of size 4 of structs, each containing this value * array. * @param port The port. diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index b2a34790b2..c598822bf8 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -136,7 +136,7 @@ public static String channelIndexName(PortInstance port) { } /** - * Return the name of the reactor. A '_main` is appended to the name if the + * Return the name of the reactor. A {@code _main} is appended to the name if the * reactor is main (to allow for instantiations that have the same name as * the main reactor or the .lf file). */ From 8e9ef2850e9beed4571ffd017f9793327f2b05b1 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 16:37:42 -0700 Subject: [PATCH 406/709] Undo changes to bash generator. --- .../src/org/lflang/federated/launcher/FedLauncherGenerator.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java index 4f544c5653..3ad08e2450 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java +++ b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java @@ -291,7 +291,7 @@ private String getSetupCode() { "", "# Create a random 48-byte text ID for this federation.", "# The likelihood of two federations having the same ID is 1/16,777,216 (1/2^24).", - "FEDERATION_ID={@code openssl rand -hex 24}", + "FEDERATION_ID=`openssl rand -hex 24`", "echo \"Federate " + fileConfig.name + " in Federation ID '$FEDERATION_ID'\"", "# Launch the federates:" ); From 3c87482ee62372a48343ed6962f2008a775fe0e2 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 16:38:07 -0700 Subject: [PATCH 407/709] More MarkDown -> HTML. --- .../src/org/lflang/generator/python/PythonPortGenerator.java | 2 +- org.lflang/src/org/lflang/util/CollectionUtil.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java index 0c0c9b6cad..5109c322c3 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java @@ -65,7 +65,7 @@ public static void generateOutputVariablesToSendToPythonReaction( Output output ) { // Unfortunately, for the lf_set macros to work out-of-the-box for - // multiports, we need an array of *pointers* to the output structs, + // multiports, we need an array of pointers to the output structs, // but what we have on the self struct is an array of output structs. // So we have to handle multiports specially here a construct that // array of pointers. diff --git a/org.lflang/src/org/lflang/util/CollectionUtil.java b/org.lflang/src/org/lflang/util/CollectionUtil.java index 11e642b095..221cbc68ec 100644 --- a/org.lflang/src/org/lflang/util/CollectionUtil.java +++ b/org.lflang/src/org/lflang/util/CollectionUtil.java @@ -81,7 +81,7 @@ public static Map plus(Map map, K k, V v) { * not just as a key, but it also needs to be removed * from the neighbors sets of any other keys that may contain it. * - * @param map A *modifiable* map + * @param map A modifiable map * @param valueToRemove Value to remove */ public static void removeFromValues(Map> map, V valueToRemove) { From 816265387870b456385ceb1c37a00b2865f4db29 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 16:49:47 -0700 Subject: [PATCH 408/709] More misc code cleanups. --- .../compiler/LinguaFrancaASTUtilsTest.java | 106 ++++++------------ .../lflang/generator/WatchdogInstance.java | 2 +- .../src/org/lflang/generator/c/CUtil.java | 2 + .../python/PythonReactorGenerator.java | 2 +- 4 files changed, 36 insertions(+), 76 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java index 9c020c0afa..dde0eba23f 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java @@ -68,29 +68,16 @@ class LinguaFrancaASTUtilsTest { */ @Test public void initializedState() throws Exception { -// Java 17: -// Model model = parser.parse(""" -// target Cpp; -// main reactor Foo { -// state a(); -// state b:int(3); -// state c:int[](1,2,3); -// state d(1 sec); -// state e(1 sec, 2 sec, 3 sec); -// } -// """); -// Java 11: - Model model = parser.parse(String.join( - System.getProperty("line.separator"), - "target Cpp;", - "main reactor {", - " state a();", - " state b:int(3);", - " state c:int[](1,2,3);", - " state d(1 sec);", - " state e(1 sec, 2 sec, 3 sec);", - "}" - )); + Model model = parser.parse(""" + target Cpp; + main reactor Foo { + state a(); + state b:int(3); + state c:int[](1,2,3); + state d(1 sec); + state e(1 sec, 2 sec, 3 sec); + } + """); @@ -111,29 +98,16 @@ public void initializedState() throws Exception { */ @Test public void uninitializedState() throws Exception { -// Java 17: -// Model model = parser.parse(""" -// target Cpp; -// main reactor Foo { -// state a; -// state b:int; -// state c:int[]; -// state d:time; -// state e:time[]; -// } -// ''' -// Java 11: - Model model = parser.parse(String.join( - System.getProperty("line.separator"), - "target Cpp;", - "main reactor {", - " state a;", - " state b:int;", - " state c:int[];", - " state d:time;", - " state e:time;", - "}" - )); + Model model = parser.parse(""" + target Cpp; + main reactor Foo { + state a; + state b:int; + state c:int[]; + state d:time; + state e:time[]; + } + """ Assertions.assertNotNull(model); Assertions.assertTrue(model.eResource().getErrors().isEmpty(), @@ -167,34 +141,18 @@ private Map getInsts(Model model) { @Test public void initialValue() throws Exception { -// Java 17: -// Model model = parser.parse(""" -// target C; -// reactor A(x:int(1)) {} -// reactor B(y:int(2)) { -// a1 = new A(x = y); -// a2 = new A(x = -1); -// } -// reactor C(z:int(3)) { -// b1 = new B(y = z); -// b2 = new B(y = -2); -// } -// """ -// Java 11: - - Model model = parser.parse(String.join( - System.getProperty("line.separator"), - "target C;", - "reactor A(x:int(1)) {}", - "reactor B(y:int(2)) {", - " a1 = new A(x = y);", - " a2 = new A(x = -1);", - "}", - "reactor C(z:int(3)) {", - " b1 = new B(y = z);", - " b2 = new B(y = -2);", - "}" - )); + Model model = parser.parse(""" + target C; + reactor A(x:int(1)) {} + reactor B(y:int(2)) { + a1 = new A(x = y); + a2 = new A(x = -1); + } + reactor C(z:int(3)) { + b1 = new B(y = z); + b2 = new B(y = -2); + } + """ Assertions.assertNotNull(model); Assertions.assertTrue(model.eResource().getErrors().isEmpty(), diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index 78c0c9bc81..90823102d6 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -3,7 +3,7 @@ * @author Benjamin Asch * @author Edward A. Lee * @copyright (c) 2023, The University of California at Berkeley - * License in [BSD 2-clause](https://github.com/lf-lang/lingua-franca/blob/master/LICENSE) + * License in BSD 2-clause * @brief Instance of a watchdog */ package org.lflang.generator; diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index c598822bf8..dbb365e189 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -478,7 +478,9 @@ public static String reactorRefNested(ReactorInstance reactor, String runtimeInd * by {@link #bankIndexName(ReactorInstance)} if the parent is a bank. * The returned expression, when evaluated, will yield the following value: * + * 
          *     d0 + w0 * (d1 + w1 * ( ... (dn-1 + wn-1 * dn) ... )
+     *
    * * @param reactor The reactor. */ diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java index 49d95e4be9..6e1a7f0183 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java @@ -115,7 +115,7 @@ public static String generatePythonClassInstantiations(ReactorInstance instance, if (instance.getWidth() > 0) { // For each reactor instance, create a list regardless of whether it is a bank or not. - // Non-bank reactor instances will be a list of size 1. var reactorClass = instance.definition.reactorClass + // Non-bank reactor instances will be a list of size 1. String fullName = instance.getFullName(); code.pr(String.join("\n", "# Start initializing "+fullName+" of class "+className, From 206ea18a2a1db108055a209254c66488ca82f516 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 16:57:16 -0700 Subject: [PATCH 409/709] Clean up syntax error from previous commit. --- build.gradle | 2 -- .../org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java | 4 ++-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/build.gradle b/build.gradle index fe3b8fca21..348949c01e 100644 --- a/build.gradle +++ b/build.gradle @@ -89,8 +89,6 @@ spotless { repositories { mavenCentral() } - // optional: limit format enforcement to just the files changed by this feature branch - ratchetFrom 'origin/master' format 'misc', { // define the files to apply `misc` to diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java index dde0eba23f..0122e03d8d 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java @@ -107,7 +107,7 @@ public void uninitializedState() throws Exception { state d:time; state e:time[]; } - """ + """); Assertions.assertNotNull(model); Assertions.assertTrue(model.eResource().getErrors().isEmpty(), @@ -152,7 +152,7 @@ reactor C(z:int(3)) { b1 = new B(y = z); b2 = new B(y = -2); } - """ + """); Assertions.assertNotNull(model); Assertions.assertTrue(model.eResource().getErrors().isEmpty(), From ed0472ae2002adf2393baf5c86d5487258a8d168 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 16:58:24 -0700 Subject: [PATCH 410/709] Google autoformatter applied to all files --- .../src/org/lflang/tests/Configurators.java | 107 +- .../src/org/lflang/tests/LFParsingTest.java | 227 +- .../src/org/lflang/tests/LFTest.java | 480 +- .../src/org/lflang/tests/LfParsingUtil.java | 129 +- .../org/lflang/tests/RunSingleTestMain.java | 77 +- .../src/org/lflang/tests/RuntimeTest.java | 391 +- .../src/org/lflang/tests/TestBase.java | 1193 ++--- .../src/org/lflang/tests/TestError.java | 44 +- .../src/org/lflang/tests/TestRegistry.java | 647 ++- .../src/org/lflang/tests/TestUtils.java | 242 +- .../lflang/tests/cli/CliToolTestFixture.java | 186 +- .../src/org/lflang/tests/cli/LfcCliTest.java | 439 +- .../src/org/lflang/tests/cli/LffCliTest.java | 167 +- .../tests/compiler/EquivalenceUnitTests.java | 97 +- .../tests/compiler/FormattingUnitTests.java | 89 +- .../tests/compiler/LetInferenceTests.java | 205 +- .../compiler/LinguaFrancaASTUtilsTest.java | 301 +- .../LinguaFrancaDependencyAnalysisTest.java | 206 +- .../compiler/LinguaFrancaParsingTest.java | 126 +- .../compiler/LinguaFrancaScopingTest.java | 302 +- .../compiler/LinguaFrancaValidationTest.java | 2665 ++++++----- .../tests/compiler/MixedRadixIntTest.java | 191 +- .../tests/compiler/PortInstanceTests.java | 398 +- .../org/lflang/tests/compiler/RangeTests.java | 169 +- .../lflang/tests/compiler/RoundTripTests.java | 74 +- .../tests/compiler/TargetConfigTests.java | 125 +- .../org/lflang/tests/lsp/ErrorInserter.java | 616 +-- .../src/org/lflang/tests/lsp/LspTests.java | 385 +- .../lflang/tests/lsp/MockLanguageClient.java | 79 +- .../lflang/tests/lsp/MockReportProgress.java | 43 +- .../lflang/tests/runtime/CArduinoTest.java | 28 +- .../org/lflang/tests/runtime/CCppTest.java | 64 +- .../lflang/tests/runtime/CSchedulerTest.java | 103 +- .../src/org/lflang/tests/runtime/CTest.java | 230 +- .../org/lflang/tests/runtime/CZephyrTest.java | 99 +- .../org/lflang/tests/runtime/CppRos2Test.java | 35 +- .../src/org/lflang/tests/runtime/CppTest.java | 138 +- .../org/lflang/tests/runtime/PythonTest.java | 213 +- .../org/lflang/tests/runtime/RustTest.java | 20 +- .../lflang/tests/runtime/TypeScriptTest.java | 110 +- .../serialization/SerializationTest.java | 59 +- .../org/lflang/tests/util/StringUtilTest.java | 38 +- org.lflang/src/org/lflang/AttributeUtils.java | 365 +- .../src/org/lflang/DefaultErrorReporter.java | 104 +- org.lflang/src/org/lflang/ErrorReporter.java | 311 +- org.lflang/src/org/lflang/FileConfig.java | 545 ++- org.lflang/src/org/lflang/InferredType.java | 349 +- .../lflang/LFResourceDescriptionStrategy.java | 118 +- .../src/org/lflang/LFResourceProvider.java | 30 +- .../src/org/lflang/LFRuntimeModule.java | 72 +- .../src/org/lflang/LFStandaloneSetup.java | 31 +- .../lflang/LFSyntaxErrorMessageProvider.java | 124 +- org.lflang/src/org/lflang/LocalStrings.java | 8 +- .../src/org/lflang/MainConflictChecker.java | 147 +- org.lflang/src/org/lflang/ModelInfo.java | 422 +- org.lflang/src/org/lflang/Target.java | 1131 +++-- org.lflang/src/org/lflang/TargetConfig.java | 716 ++- org.lflang/src/org/lflang/TargetProperty.java | 3332 +++++++------- org.lflang/src/org/lflang/TimeUnit.java | 127 +- org.lflang/src/org/lflang/TimeValue.java | 340 +- org.lflang/src/org/lflang/ast/ASTUtils.java | 3468 ++++++++------- .../src/org/lflang/ast/AstTransformation.java | 11 +- .../ast/DelayedConnectionTransformation.java | 690 +-- .../src/org/lflang/ast/FormattingUtils.java | 427 +- org.lflang/src/org/lflang/ast/IsEqual.java | 1201 +++-- org.lflang/src/org/lflang/ast/ToLf.java | 7 +- org.lflang/src/org/lflang/ast/ToText.java | 204 +- org.lflang/src/org/lflang/cli/CliBase.java | 582 ++- .../org/lflang/cli/LFStandaloneModule.java | 58 +- org.lflang/src/org/lflang/cli/Lfc.java | 515 +-- org.lflang/src/org/lflang/cli/Lff.java | 306 +- .../lflang/cli/StandaloneErrorReporter.java | 143 +- .../lflang/cli/StandaloneIssueAcceptor.java | 186 +- .../src/org/lflang/cli/VersionProvider.java | 30 +- .../lflang/diagram/lsp/LFLanguageServer.java | 36 +- .../lsp/LFLanguageServerExtension.java | 196 +- .../diagram/lsp/LanguageDiagramServer.java | 162 +- .../src/org/lflang/diagram/lsp/Progress.java | 156 +- .../AbstractSynthesisExtensions.java | 98 +- .../synthesis/LinguaFrancaSynthesis.java | 2773 ++++++------ .../ReactorParameterDisplayModes.java | 76 +- .../synthesis/SynthesisRegistration.java | 69 +- .../synthesis/action/AbstractAction.java | 79 +- .../action/CollapseAllReactorsAction.java | 88 +- .../action/ExpandAllReactorsAction.java | 84 +- .../synthesis/action/FilterCycleAction.java | 238 +- .../MemorizingExpandCollapseAction.java | 204 +- .../synthesis/action/ShowCycleAction.java | 131 +- .../postprocessor/ReactionPortAdjustment.java | 315 +- .../styles/LinguaFrancaShapeExtensions.java | 2091 +++++---- .../styles/LinguaFrancaStyleExtensions.java | 862 ++-- .../styles/ReactorFigureComponents.java | 170 +- .../synthesis/util/CycleVisualization.java | 243 +- .../InterfaceDependenciesVisualization.java | 340 +- .../synthesis/util/LayoutPostProcessing.java | 697 +-- .../diagram/synthesis/util/ModeDiagrams.java | 1206 ++--- .../synthesis/util/NamedInstanceUtil.java | 78 +- .../diagram/synthesis/util/ReactorIcons.java | 254 +- .../util/SynthesisErrorReporter.java | 138 +- .../synthesis/util/UtilityExtensions.java | 311 +- .../federated/extensions/CExtension.java | 1348 +++--- .../federated/extensions/CExtensionUtils.java | 1043 ++--- .../extensions/FedTargetExtension.java | 199 +- .../extensions/FedTargetExtensionFactory.java | 26 +- .../federated/extensions/PythonExtension.java | 279 +- .../federated/extensions/TSExtension.java | 277 +- .../federated/generator/FedASTUtils.java | 1436 +++--- .../generator/FedConnectionInstance.java | 140 +- .../federated/generator/FedEmitter.java | 104 +- .../federated/generator/FedFileConfig.java | 196 +- .../federated/generator/FedGenerator.java | 1049 +++-- .../federated/generator/FedImportEmitter.java | 77 +- .../federated/generator/FedMainEmitter.java | 131 +- .../generator/FedPreambleEmitter.java | 62 +- .../generator/FedReactorEmitter.java | 20 +- .../federated/generator/FedTargetConfig.java | 104 +- .../federated/generator/FedTargetEmitter.java | 48 +- .../lflang/federated/generator/FedUtils.java | 46 +- .../federated/generator/FederateInstance.java | 1123 +++-- .../generator/LineAdjustingErrorReporter.java | 210 +- .../generator/SynchronizedErrorReporter.java | 144 +- .../federated/launcher/BuildConfig.java | 93 +- .../federated/launcher/CBuildConfig.java | 68 +- .../launcher/FedLauncherGenerator.java | 898 ++-- .../federated/launcher/PyBuildConfig.java | 37 +- .../lflang/federated/launcher/RtiConfig.java | 115 +- .../federated/launcher/TsBuildConfig.java | 64 +- .../FedNativePythonSerialization.java | 172 +- .../FedROS2CPPSerialization.java | 348 +- .../serialization/FedSerialization.java | 133 +- .../serialization/SupportedSerializers.java | 32 +- .../federated/validation/FedValidator.java | 95 +- .../org/lflang/formatting2/LFFormatter.java | 48 +- .../org/lflang/generator/ActionInstance.java | 150 +- .../src/org/lflang/generator/CodeBuilder.java | 1018 ++--- .../src/org/lflang/generator/CodeMap.java | 554 ++- .../lflang/generator/DeadlineInstance.java | 100 +- .../lflang/generator/DelayBodyGenerator.java | 93 +- .../lflang/generator/DiagnosticReporting.java | 89 +- .../generator/DockerComposeGenerator.java | 156 +- .../src/org/lflang/generator/DockerData.java | 55 +- .../org/lflang/generator/DockerGenerator.java | 82 +- .../generator/FedDockerComposeGenerator.java | 79 +- .../lflang/generator/GenerationException.java | 68 +- .../org/lflang/generator/GeneratorBase.java | 1150 +++-- .../generator/GeneratorCommandFactory.java | 260 +- .../org/lflang/generator/GeneratorResult.java | 188 +- .../org/lflang/generator/GeneratorUtils.java | 299 +- .../HumanReadableReportingStrategy.java | 282 +- .../lflang/generator/IntegratedBuilder.java | 248 +- .../generator/InvalidLfSourceException.java | 37 +- .../generator/InvalidSourceException.java | 18 +- .../src/org/lflang/generator/LFGenerator.java | 320 +- .../lflang/generator/LFGeneratorContext.java | 258 +- .../src/org/lflang/generator/LFResource.java | 65 +- .../LanguageServerErrorReporter.java | 349 +- .../lflang/generator/LfExpressionVisitor.java | 209 +- .../src/org/lflang/generator/MainContext.java | 290 +- .../org/lflang/generator/MixedRadixInt.java | 418 +- .../org/lflang/generator/ModeInstance.java | 365 +- .../org/lflang/generator/NamedInstance.java | 600 ++- .../lflang/generator/ParameterInstance.java | 193 +- .../org/lflang/generator/PortInstance.java | 801 ++-- .../src/org/lflang/generator/Position.java | 435 +- .../src/org/lflang/generator/Range.java | 223 +- .../lflang/generator/ReactionInstance.java | 1033 +++-- .../generator/ReactionInstanceGraph.java | 755 ++-- .../org/lflang/generator/ReactorInstance.java | 2105 +++++---- .../org/lflang/generator/RuntimeRange.java | 839 ++-- .../src/org/lflang/generator/SendRange.java | 491 +-- .../src/org/lflang/generator/SubContext.java | 148 +- .../src/org/lflang/generator/TargetTypes.java | 457 +- .../org/lflang/generator/TimerInstance.java | 129 +- .../org/lflang/generator/TriggerInstance.java | 299 +- .../UnsupportedGeneratorFeatureException.java | 17 +- .../lflang/generator/ValidationStrategy.java | 67 +- .../src/org/lflang/generator/Validator.java | 329 +- .../lflang/generator/WatchdogInstance.java | 4 +- .../lflang/generator/c/CActionGenerator.java | 290 +- .../lflang/generator/c/CCmakeGenerator.java | 672 +-- .../src/org/lflang/generator/c/CCompiler.java | 729 ++- .../generator/c/CConstructorGenerator.java | 52 +- .../lflang/generator/c/CCoreFilesUtils.java | 34 +- .../generator/c/CDelayBodyGenerator.java | 97 +- .../lflang/generator/c/CDockerGenerator.java | 112 +- .../org/lflang/generator/c/CFileConfig.java | 33 +- .../org/lflang/generator/c/CGenerator.java | 3907 +++++++++-------- .../generator/c/CMainFunctionGenerator.java | 203 +- .../lflang/generator/c/CMethodGenerator.java | 280 +- .../generator/c/CMixedRadixGenerator.java | 24 +- .../lflang/generator/c/CModesGenerator.java | 386 +- .../generator/c/CParameterGenerator.java | 61 +- .../lflang/generator/c/CPortGenerator.java | 496 ++- .../generator/c/CPreambleGenerator.java | 137 +- .../generator/c/CReactionGenerator.java | 2326 +++++----- .../c/CReactorHeaderFileGenerator.java | 376 +- .../lflang/generator/c/CStateGenerator.java | 213 +- .../lflang/generator/c/CTimerGenerator.java | 111 +- .../lflang/generator/c/CTracingGenerator.java | 92 +- .../generator/c/CTriggerObjectsGenerator.java | 2005 +++++---- .../src/org/lflang/generator/c/CTypes.java | 286 +- .../src/org/lflang/generator/c/CUtil.java | 1510 ++++--- .../generator/c/CWatchdogGenerator.java | 98 +- .../c/InteractingContainedReactors.java | 229 +- .../generator/c/TypeParameterizedReactor.java | 111 +- .../lflang/generator/python/PyFileConfig.java | 38 +- .../org/lflang/generator/python/PyUtil.java | 262 +- .../python/PythonActionGenerator.java | 15 +- .../python/PythonDelayBodyGenerator.java | 126 +- .../python/PythonDockerGenerator.java | 41 +- .../generator/python/PythonGenerator.java | 1142 +++-- .../generator/python/PythonInfoGenerator.java | 90 +- .../python/PythonMainFunctionGenerator.java | 37 +- .../python/PythonMethodGenerator.java | 58 +- .../generator/python/PythonModeGenerator.java | 147 +- .../python/PythonParameterGenerator.java | 170 +- .../generator/python/PythonPortGenerator.java | 443 +- .../python/PythonPreambleGenerator.java | 71 +- .../python/PythonReactionGenerator.java | 1100 ++--- .../python/PythonReactorGenerator.java | 273 +- .../python/PythonStateGenerator.java | 50 +- .../lflang/generator/python/PythonTypes.java | 104 +- .../generator/python/PythonValidator.java | 647 +-- .../generator/rust/CargoDependencySpec.java | 16 +- .../generator/rust/RustTargetConfig.java | 142 +- .../generator/ts/TSDockerGenerator.java | 21 +- .../src/org/lflang/generator/ts/TSTypes.java | 118 +- .../src/org/lflang/graph/DirectedGraph.java | 556 ++- org.lflang/src/org/lflang/graph/Graph.java | 101 +- .../org/lflang/graph/InstantiationGraph.java | 251 +- .../src/org/lflang/graph/NodeAnnotation.java | 100 +- .../src/org/lflang/graph/NodeAnnotations.java | 52 +- .../src/org/lflang/graph/PrecedenceGraph.java | 413 +- .../src/org/lflang/graph/TopologyGraph.java | 244 +- .../src/org/lflang/ide/LFIdeModule.java | 8 +- org.lflang/src/org/lflang/ide/LFIdeSetup.java | 17 +- .../lflang/scoping/LFGlobalScopeProvider.java | 207 +- .../org/lflang/scoping/LFScopeProvider.java | 11 +- .../lflang/scoping/LFScopeProviderImpl.java | 425 +- .../src/org/lflang/util/ArduinoUtil.java | 224 +- org.lflang/src/org/lflang/util/Averager.java | 33 +- .../src/org/lflang/util/CollectionUtil.java | 307 +- org.lflang/src/org/lflang/util/FileUtil.java | 1744 ++++---- .../src/org/lflang/util/IteratorUtil.java | 96 +- org.lflang/src/org/lflang/util/LFCommand.java | 715 ++- .../src/org/lflang/util/StringUtil.java | 234 +- .../util/TargetResourceNotFoundException.java | 13 +- .../org/lflang/validation/AttributeSpec.java | 345 +- .../lflang/validation/BaseLFValidator.java | 64 +- .../LFNamesAreUniqueValidationHelper.java | 33 +- .../org/lflang/validation/LFValidator.java | 3325 +++++++------- .../validation/ValidatorErrorReporter.java | 297 +- 252 files changed, 47689 insertions(+), 47129 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/Configurators.java b/org.lflang.tests/src/org/lflang/tests/Configurators.java index e3fe6c5508..24ee6f38f3 100644 --- a/org.lflang.tests/src/org/lflang/tests/Configurators.java +++ b/org.lflang.tests/src/org/lflang/tests/Configurators.java @@ -26,7 +26,6 @@ import org.lflang.TargetProperty; import org.lflang.TargetProperty.Platform; -import org.lflang.generator.LFGeneratorContext.BuildParm; import org.lflang.tests.TestRegistry.TestCategory; /** @@ -37,62 +36,60 @@ */ public class Configurators { - /** Test configuration function. */ - @FunctionalInterface - public interface Configurator { - - /** - * Apply a side effect to the given test case to change its default configuration. - * Return true if configuration succeeded, false otherwise. - */ - boolean configure(LFTest test); - } + /** Test configuration function. */ + @FunctionalInterface + public interface Configurator { /** - * Configure the given test to use single-threaded execution. - * - * For targets that provide a threaded and an unthreaded runtime, - * this configures using the unthreaded runtime. For targets that - * do not distinguish threaded and unthreaded runtime, the number - * of workers is set to 1. - * - * @param test The test to configure. - * @return True if successful, false otherwise. + * Apply a side effect to the given test case to change its default configuration. Return true + * if configuration succeeded, false otherwise. */ - public static boolean disableThreading(LFTest test) { - test.getContext().getArgs().setProperty("threading", "false"); - test.getContext().getArgs().setProperty("workers", "1"); - return true; - } + boolean configure(LFTest test); + } - public static boolean makeZephyrCompatible(LFTest test) { - test.getContext().getArgs().setProperty("tracing", "false"); - test.getContext().getTargetConfig().threading = false; - test.getContext().getTargetConfig().setByUser.add(TargetProperty.THREADING); - test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; - test.getContext().getTargetConfig().platformOptions.flash = false; - test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; - return true; - } - /** - * Make no changes to the configuration. - * - * @param ignoredTest The test to configure. - * @return True - */ - public static boolean noChanges(LFTest ignoredTest) { - return true; - } + /** + * Configure the given test to use single-threaded execution. + * + *

    For targets that provide a threaded and an unthreaded runtime, this configures using the + * unthreaded runtime. For targets that do not distinguish threaded and unthreaded runtime, the + * number of workers is set to 1. + * + * @param test The test to configure. + * @return True if successful, false otherwise. + */ + public static boolean disableThreading(LFTest test) { + test.getContext().getArgs().setProperty("threading", "false"); + test.getContext().getArgs().setProperty("workers", "1"); + return true; + } - /** - * Given a test category, return true if it is compatible with single-threaded execution. - */ - public static boolean compatibleWithThreadingOff(TestCategory category) { + public static boolean makeZephyrCompatible(LFTest test) { + test.getContext().getArgs().setProperty("tracing", "false"); + test.getContext().getTargetConfig().threading = false; + test.getContext().getTargetConfig().setByUser.add(TargetProperty.THREADING); + test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; + test.getContext().getTargetConfig().platformOptions.flash = false; + test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; + return true; + } + /** + * Make no changes to the configuration. + * + * @param ignoredTest The test to configure. + * @return True + */ + public static boolean noChanges(LFTest ignoredTest) { + return true; + } + + /** Given a test category, return true if it is compatible with single-threaded execution. */ + public static boolean compatibleWithThreadingOff(TestCategory category) { - // CONCURRENT, FEDERATED, DOCKER_FEDERATED, DOCKER - // are not compatible with single-threaded execution. - // ARDUINO and ZEPHYR have their own test suites, so we don't need to rerun. - boolean excluded = category == TestCategory.CONCURRENT + // CONCURRENT, FEDERATED, DOCKER_FEDERATED, DOCKER + // are not compatible with single-threaded execution. + // ARDUINO and ZEPHYR have their own test suites, so we don't need to rerun. + boolean excluded = + category == TestCategory.CONCURRENT || category == TestCategory.SERIALIZATION || category == TestCategory.FEDERATED || category == TestCategory.DOCKER_FEDERATED @@ -100,8 +97,8 @@ public static boolean compatibleWithThreadingOff(TestCategory category) { || category == TestCategory.ARDUINO || category == TestCategory.ZEPHYR; - // SERIALIZATION and TARGET tests are excluded on Windows. - excluded |= TestBase.isWindows() && (category == TestCategory.TARGET); - return !excluded; - } + // SERIALIZATION and TARGET tests are excluded on Windows. + excluded |= TestBase.isWindows() && (category == TestCategory.TARGET); + return !excluded; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/LFParsingTest.java b/org.lflang.tests/src/org/lflang/tests/LFParsingTest.java index 487c3b21e5..f0e96ee7d0 100644 --- a/org.lflang.tests/src/org/lflang/tests/LFParsingTest.java +++ b/org.lflang.tests/src/org/lflang/tests/LFParsingTest.java @@ -3,8 +3,8 @@ */ package org.lflang.tests; +import com.google.inject.Inject; import java.util.List; - import org.eclipse.emf.ecore.resource.Resource.Diagnostic; import org.eclipse.xtext.testing.InjectWith; import org.eclipse.xtext.testing.extensions.InjectionExtension; @@ -13,127 +13,118 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.lf.Model; -import com.google.inject.Inject; - @ExtendWith(InjectionExtension.class) @InjectWith(LFInjectorProvider.class) public class LFParsingTest { - @Inject - private ParseHelper parseHelper; - - - @Test - public void testLexingEmptyTargetProperties() throws Exception { - assertNoParsingErrorsIn("target C { }; \nreactor Foo {}"); - assertNoParsingErrorsIn("target C {a:b,}; \nreactor Foo {}"); - expectParsingErrorIn("target C {,}; \nreactor Foo {}"); - - // array elements - // assertNoParsingErrorsIn("target C {x:[ ]}; \nreactor Foo {}"); - // assertNoParsingErrorsIn("target C {x:[]}; \nreactor Foo {}"); - // assertNoParsingErrorsIn("target C {x:[,]}; \nreactor Foo {}"); - } - - @Test - public void testLexingLifetimeAnnots() throws Exception { - assertNoParsingErrorsIn(makeLfTargetCode("Rust", - " struct Hello<'a> { \n" - + " r: &'a str,\n" - + " r2: &'a Box>,\n" - + " }")); - } - - - @Test - public void testLexingSingleLifetimeAnnot() throws Exception { - // just to be sure, have a single lifetime annot. - assertNoParsingErrorsIn(makeLfTargetCode("Rust", - " struct Hello { \n" - + " r: &'static str,\n" - + " }")); - } - - - @Test - public void testLexingNewlineCont() throws Exception { - /* - This example looks like this: - "a\ - bcde" - - This is valid C++ to escape a newline. - */ - - assertNoParsingErrorsIn(makeLfTargetCode("Cpp", - " \"a\\\n" - + " bcde\"\n" - )); - } - - - @Test - public void testLexingSquotedString() throws Exception { - // we can't do that anymore - expectParsingErrorIn(makeLfTargetCode("Python", "a = ' a string '")); - } - - - @Test - public void testLexingDquotedString() throws Exception { - assertNoParsingErrorsIn(makeLfTargetCode("Python", "a = \" a string \"")); - } - - @Test - public void testLexingMultilineString() throws Exception { - assertNoParsingErrorsIn(makeLfTargetCode("Python", "a = \"\"\" a 'string' \"\"\"")); - assertNoParsingErrorsIn(makeLfTargetCode("Python", "a = \"\"\" a 'strin\ng' \"\"\"")); - assertNoParsingErrorsIn(makeLfTargetCode("Python", "a = \"\"\" \na 'string'\n \"\"\"")); - } - - @Test - public void testLexingDquotedStringWithEscape() throws Exception { - assertNoParsingErrorsIn(makeLfTargetCode("C", "printf(\"Hello World.\\n\");\n")); - } - - - @Test - public void testLexingCharLiteral() throws Exception { - assertNoParsingErrorsIn(makeLfTargetCode("C", "char c0 = 'c';")); - } - - @Test - public void testLexingEscapedCharLiteral() throws Exception { - assertNoParsingErrorsIn(makeLfTargetCode("C", "char c0 = '\\n';")); - } - - private String makeLfTargetCode(final String target, final String code) { - return "target " + target + ";\n" - + "reactor Foo {\n" - + " preamble {=\n" - + " " + code + "\n" - + " =}\n" - + "}"; - } - - private void assertNoParsingErrorsIn(String source) throws Exception { - List errors = doParse(source); - Assertions.assertTrue(errors.isEmpty(), "Unexpected errors: " + IterableExtensions.join(errors, ", ")); - } - - - private void expectParsingErrorIn(String source) throws Exception { - List errors = doParse(source); - Assertions.assertFalse(errors.isEmpty(), "Expected a parsing error, none occurred"); - } - - - private List doParse(String source) throws Exception { - Model result = parseHelper.parse(source); - Assertions.assertNotNull(result); - return result.eResource().getErrors(); - } + @Inject private ParseHelper parseHelper; + + @Test + public void testLexingEmptyTargetProperties() throws Exception { + assertNoParsingErrorsIn("target C { }; \nreactor Foo {}"); + assertNoParsingErrorsIn("target C {a:b,}; \nreactor Foo {}"); + expectParsingErrorIn("target C {,}; \nreactor Foo {}"); + + // array elements + // assertNoParsingErrorsIn("target C {x:[ ]}; \nreactor Foo {}"); + // assertNoParsingErrorsIn("target C {x:[]}; \nreactor Foo {}"); + // assertNoParsingErrorsIn("target C {x:[,]}; \nreactor Foo {}"); + } + + @Test + public void testLexingLifetimeAnnots() throws Exception { + assertNoParsingErrorsIn( + makeLfTargetCode( + "Rust", + " struct Hello<'a> { \n" + + " r: &'a str,\n" + + " r2: &'a Box>,\n" + + " }")); + } + + @Test + public void testLexingSingleLifetimeAnnot() throws Exception { + // just to be sure, have a single lifetime annot. + assertNoParsingErrorsIn( + makeLfTargetCode( + "Rust", " struct Hello { \n" + " r: &'static str,\n" + " }")); + } + + @Test + public void testLexingNewlineCont() throws Exception { + /* + This example looks like this: + "a\ + bcde" + + This is valid C++ to escape a newline. + */ + + assertNoParsingErrorsIn(makeLfTargetCode("Cpp", " \"a\\\n" + " bcde\"\n")); + } + + @Test + public void testLexingSquotedString() throws Exception { + // we can't do that anymore + expectParsingErrorIn(makeLfTargetCode("Python", "a = ' a string '")); + } + + @Test + public void testLexingDquotedString() throws Exception { + assertNoParsingErrorsIn(makeLfTargetCode("Python", "a = \" a string \"")); + } + + @Test + public void testLexingMultilineString() throws Exception { + assertNoParsingErrorsIn(makeLfTargetCode("Python", "a = \"\"\" a 'string' \"\"\"")); + assertNoParsingErrorsIn(makeLfTargetCode("Python", "a = \"\"\" a 'strin\ng' \"\"\"")); + assertNoParsingErrorsIn(makeLfTargetCode("Python", "a = \"\"\" \na 'string'\n \"\"\"")); + } + + @Test + public void testLexingDquotedStringWithEscape() throws Exception { + assertNoParsingErrorsIn(makeLfTargetCode("C", "printf(\"Hello World.\\n\");\n")); + } + + @Test + public void testLexingCharLiteral() throws Exception { + assertNoParsingErrorsIn(makeLfTargetCode("C", "char c0 = 'c';")); + } + + @Test + public void testLexingEscapedCharLiteral() throws Exception { + assertNoParsingErrorsIn(makeLfTargetCode("C", "char c0 = '\\n';")); + } + + private String makeLfTargetCode(final String target, final String code) { + return "target " + + target + + ";\n" + + "reactor Foo {\n" + + " preamble {=\n" + + " " + + code + + "\n" + + " =}\n" + + "}"; + } + + private void assertNoParsingErrorsIn(String source) throws Exception { + List errors = doParse(source); + Assertions.assertTrue( + errors.isEmpty(), "Unexpected errors: " + IterableExtensions.join(errors, ", ")); + } + + private void expectParsingErrorIn(String source) throws Exception { + List errors = doParse(source); + Assertions.assertFalse(errors.isEmpty(), "Expected a parsing error, none occurred"); + } + + private List doParse(String source) throws Exception { + Model result = parseHelper.parse(source); + Assertions.assertNotNull(result); + return result.eResource().getErrors(); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/LFTest.java b/org.lflang.tests/src/org/lflang/tests/LFTest.java index cc69dea77a..58b3cbf846 100644 --- a/org.lflang.tests/src/org/lflang/tests/LFTest.java +++ b/org.lflang.tests/src/org/lflang/tests/LFTest.java @@ -8,286 +8,286 @@ import java.io.Reader; import java.nio.file.Path; import java.nio.file.Paths; - import org.eclipse.xtext.util.RuntimeIOException; - import org.lflang.FileConfig; import org.lflang.Target; import org.lflang.generator.LFGeneratorContext; /** * Information about an indexed Lingua Franca test program. - * - * @author Marten Lohstroh * + * @author Marten Lohstroh */ public class LFTest implements Comparable { - /** The path to the test. */ - private final Path srcPath; - - /** The name of the test. */ - private final String name; - - /** The result of the test. */ - private Result result = Result.UNKNOWN; - - /** Context provided to the code generators */ - private LFGeneratorContext context; - - /** Path of the test program relative to the package root. */ - private final Path relativePath; - - /** Records compilation stdout/stderr. */ - private final ByteArrayOutputStream compilationLog = new ByteArrayOutputStream(); - - /** Specialized object for capturing output streams while executing the test. */ - private final ExecutionLogger execLog = new ExecutionLogger(); - - /** String builder for collecting issues encountered during test execution. */ - private final StringBuilder issues = new StringBuilder(); - - /** The target of the test program. */ - private final Target target; - - /** - * Create a new test. - * - * @param target The target of the test program. - * @param srcFile The path to the file of the test program. - */ - public LFTest(Target target, Path srcFile) { - this.target = target; - this.srcPath = srcFile; - this.name = FileConfig.findPackageRoot(srcFile, s -> {}).relativize(srcFile).toString(); - this.relativePath = Paths.get(name); + /** The path to the test. */ + private final Path srcPath; + + /** The name of the test. */ + private final String name; + + /** The result of the test. */ + private Result result = Result.UNKNOWN; + + /** Context provided to the code generators */ + private LFGeneratorContext context; + + /** Path of the test program relative to the package root. */ + private final Path relativePath; + + /** Records compilation stdout/stderr. */ + private final ByteArrayOutputStream compilationLog = new ByteArrayOutputStream(); + + /** Specialized object for capturing output streams while executing the test. */ + private final ExecutionLogger execLog = new ExecutionLogger(); + + /** String builder for collecting issues encountered during test execution. */ + private final StringBuilder issues = new StringBuilder(); + + /** The target of the test program. */ + private final Target target; + + /** + * Create a new test. + * + * @param target The target of the test program. + * @param srcFile The path to the file of the test program. + */ + public LFTest(Target target, Path srcFile) { + this.target = target; + this.srcPath = srcFile; + this.name = FileConfig.findPackageRoot(srcFile, s -> {}).relativize(srcFile).toString(); + this.relativePath = Paths.get(name); + } + + /** Copy constructor */ + public LFTest(LFTest test) { + this(test.target, test.srcPath); + } + + /** Stream object for capturing standard and error output. */ + public OutputStream getOutputStream() { + return compilationLog; + } + + public FileConfig getFileConfig() { + return context.getFileConfig(); + } + + public LFGeneratorContext getContext() { + return context; + } + + public Path getSrcPath() { + return srcPath; + } + + /** + * Comparison implementation to allow for tests to be sorted (e.g., when added to a tree set) + * based on their path (relative to the root of the test directory). + */ + public int compareTo(LFTest t) { + return this.relativePath.compareTo(t.relativePath); + } + + /** + * Return true if the given object is an LFTest instance with a name identical to this test. + * + * @param o The object to test for equality with respect to this one. + * @return True if the given object is equal to this one, false otherwise. + */ + @Override + public boolean equals(Object o) { + return o instanceof LFTest && ((LFTest) o).name.equals(this.name); + } + + /** + * Return a string representing the name of this test. + * + * @return The name of this test. + */ + @Override + public String toString() { + return this.name; + } + + /** + * Identify tests uniquely on the basis of their name. + * + * @return The hash code of the name of this test. + */ + @Override + public int hashCode() { + return this.name.hashCode(); + } + + /** + * Report whether this test has failed. + * + * @return True if the test has failed, false otherwise. + */ + public boolean hasFailed() { + return result != Result.TEST_PASS; + } + + public boolean hasPassed() { + return result == Result.TEST_PASS; + } + + /** + * Compile a string that contains all collected errors and return it. + * + * @return A string that contains all collected errors. + */ + public void reportErrors() { + if (this.hasFailed()) { + System.out.println( + "+---------------------------------------------------------------------------+"); + System.out.println("Failed: " + this); + System.out.println( + "-----------------------------------------------------------------------------"); + System.out.println("Reason: " + this.result.message); + printIfNotEmpty("Reported issues", this.issues.toString()); + printIfNotEmpty("Compilation output", this.compilationLog.toString()); + printIfNotEmpty("Execution output", this.execLog.toString()); + System.out.println( + "+---------------------------------------------------------------------------+"); } + } - /** Copy constructor */ - public LFTest(LFTest test) { - this(test.target, test.srcPath); + public void handleTestError(TestError e) { + result = e.getResult(); + if (e.getMessage() != null) { + issues.append(e.getMessage()); } - - /** Stream object for capturing standard and error output. */ - public OutputStream getOutputStream() { - return compilationLog; + if (e.getException() != null) { + issues.append(System.lineSeparator()); + issues.append(TestBase.stackTraceToString(e.getException())); } - - public FileConfig getFileConfig() { return context.getFileConfig(); } - - public LFGeneratorContext getContext() { return context; } - - public Path getSrcPath() { return srcPath; } - - /** - * Comparison implementation to allow for tests to be sorted (e.g., when added to a - * tree set) based on their path (relative to the root of the test directory). - */ - public int compareTo(LFTest t) { - return this.relativePath.compareTo(t.relativePath); + } + + public void markPassed() { + result = Result.TEST_PASS; + // clear the execution log to free memory + execLog.clear(); + } + + void configure(LFGeneratorContext context) { + this.context = context; + } + + /** + * Print the message to the system output, but only if the message is not empty. + * + * @param header Header for the message to be printed. + * @param message The log message to print. + */ + private static void printIfNotEmpty(String header, String message) { + if (!message.isEmpty()) { + System.out.println(header + ":"); + System.out.println(message); } + } + + /** Enumeration of test outcomes. */ + public enum Result { + UNKNOWN("No information available."), + CONFIG_FAIL("Could not apply configuration."), + PARSE_FAIL("Unable to parse test."), + VALIDATE_FAIL("Unable to validate test."), + CODE_GEN_FAIL("Error while generating code for test."), + NO_EXEC_FAIL("Did not execute test."), + TEST_FAIL("Test did not pass."), + TEST_EXCEPTION("Test exited with an exception."), + TEST_TIMEOUT("Test timed out."), + TEST_PASS("Test passed."); + + /** Description of the outcome. */ + public final String message; /** - * Return true if the given object is an LFTest instance with a name identical to this test. - * @param o The object to test for equality with respect to this one. - * @return True if the given object is equal to this one, false otherwise. - */ - @Override - public boolean equals(Object o) { - return o instanceof LFTest && ((LFTest) o).name.equals(this.name); - } - - /** - * Return a string representing the name of this test. - * @return The name of this test. - */ - @Override - public String toString() { - return this.name; - } - - /** - * Identify tests uniquely on the basis of their name. + * Private constructor. * - * @return The hash code of the name of this test. + * @param message Description of the test outcome. */ - @Override - public int hashCode() { - return this.name.hashCode(); + Result(String message) { + this.message = message; } + } - /** - * Report whether this test has failed. - * @return True if the test has failed, false otherwise. - */ - public boolean hasFailed() { - return result != Result.TEST_PASS; - } - - public boolean hasPassed() { - return result == Result.TEST_PASS; - } + /** + * Inner class for capturing streams during execution of a test, capable of recording output + * streams up until the moment that a test is interrupted upon timing out. + * + * @author Marten Lohstroh + */ + public static final class ExecutionLogger { /** - * Compile a string that contains all collected errors and return it. - * @return A string that contains all collected errors. + * String buffer used to record the standard output and error streams from the input process. */ - public void reportErrors() { - if (this.hasFailed()) { - System.out.println("+---------------------------------------------------------------------------+"); - System.out.println("Failed: " + this); - System.out.println("-----------------------------------------------------------------------------"); - System.out.println("Reason: " + this.result.message); - printIfNotEmpty("Reported issues", this.issues.toString()); - printIfNotEmpty("Compilation output", this.compilationLog.toString()); - printIfNotEmpty("Execution output", this.execLog.toString()); - System.out.println("+---------------------------------------------------------------------------+"); - } - } - - public void handleTestError(TestError e) { - result = e.getResult(); - if (e.getMessage() != null) { - issues.append(e.getMessage()); - } - if (e.getException() != null) { - issues.append(System.lineSeparator()); - issues.append(TestBase.stackTraceToString(e.getException())); - } - } - - public void markPassed() { - result = Result.TEST_PASS; - // clear the execution log to free memory - execLog.clear(); - } - - void configure(LFGeneratorContext context) { - this.context = context; - } + StringBuffer buffer = new StringBuffer(); /** - * Print the message to the system output, but only if the message is not empty. - * - * @param header Header for the message to be printed. - * @param message The log message to print. + * Return a thread responsible for recording the standard output stream of the given process. A + * separate thread is used so that the activity can be preempted. */ - private static void printIfNotEmpty(String header, String message) { - if (!message.isEmpty()) { - System.out.println(header + ":"); - System.out.println(message); - } + public Thread recordStdOut(Process process) { + return recordStream(buffer, process.getInputStream()); } /** - * Enumeration of test outcomes. + * Return a thread responsible for recording the error stream of the given process. A separate + * thread is used so that the activity can be preempted. */ - public enum Result { - UNKNOWN("No information available."), - CONFIG_FAIL("Could not apply configuration."), - PARSE_FAIL("Unable to parse test."), - VALIDATE_FAIL("Unable to validate test."), - CODE_GEN_FAIL("Error while generating code for test."), - NO_EXEC_FAIL("Did not execute test."), - TEST_FAIL("Test did not pass."), - TEST_EXCEPTION("Test exited with an exception."), - TEST_TIMEOUT("Test timed out."), - TEST_PASS("Test passed."); - - /** - * Description of the outcome. - */ - public final String message; - - /** - * Private constructor. - * @param message Description of the test outcome. - */ - Result(String message) { - this.message = message; - } + public Thread recordStdErr(Process process) { + return recordStream(buffer, process.getErrorStream()); } - /** - * Inner class for capturing streams during execution of a test, capable of - * recording output streams up until the moment that a test is interrupted - * upon timing out. - * - * @author Marten Lohstroh + * Return a thread responsible for recording the given stream. * + * @param builder The builder to append to. + * @param inputStream The stream to read from. */ - public static final class ExecutionLogger { - - /** - * String buffer used to record the standard output and error - * streams from the input process. - */ - StringBuffer buffer = new StringBuffer(); - - /** - * Return a thread responsible for recording the standard output stream - * of the given process. - * A separate thread is used so that the activity can be preempted. - */ - public Thread recordStdOut(Process process) { - return recordStream(buffer, process.getInputStream()); - } - - /** - * Return a thread responsible for recording the error stream of the - * given process. - * A separate thread is used so that the activity can be preempted. - */ - public Thread recordStdErr(Process process) { - return recordStream(buffer, process.getErrorStream()); - } - - /** - * Return a thread responsible for recording the given stream. - * - * @param builder The builder to append to. - * @param inputStream The stream to read from. - */ - private Thread recordStream(StringBuffer builder, InputStream inputStream) { - return new Thread(() -> { - try (Reader reader = new InputStreamReader(inputStream)) { - int len; - char[] buf = new char[1024]; - while ((len = reader.read(buf)) > 0) { - builder.append(buf, 0, len); - } - } catch (IOException e) { - throw new RuntimeIOException(e); - } - - }); - } - - @Override - public String toString() { - return buffer.toString(); - } - - public void clear() { - buffer = null; - } + private Thread recordStream(StringBuffer builder, InputStream inputStream) { + return new Thread( + () -> { + try (Reader reader = new InputStreamReader(inputStream)) { + int len; + char[] buf = new char[1024]; + while ((len = reader.read(buf)) > 0) { + builder.append(buf, 0, len); + } + } catch (IOException e) { + throw new RuntimeIOException(e); + } + }); } - - /** - * Return a thread responsible for recording the standard output stream of the given process. - * A separate thread is used so that the activity can be preempted. - */ - public Thread recordStdOut(Process process) { - return execLog.recordStdOut(process); + @Override + public String toString() { + return buffer.toString(); } - /** - * Return a thread responsible for recording the error stream of the given process. - * A separate thread is used so that the activity can be preempted. - */ - public Thread recordStdErr(Process process) { - return execLog.recordStdErr(process); + public void clear() { + buffer = null; } + } + + /** + * Return a thread responsible for recording the standard output stream of the given process. A + * separate thread is used so that the activity can be preempted. + */ + public Thread recordStdOut(Process process) { + return execLog.recordStdOut(process); + } + + /** + * Return a thread responsible for recording the error stream of the given process. A separate + * thread is used so that the activity can be preempted. + */ + public Thread recordStdErr(Process process) { + return execLog.recordStdErr(process); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/LfParsingUtil.java b/org.lflang.tests/src/org/lflang/tests/LfParsingUtil.java index fd9ffa2a2e..ae45bf4e7c 100644 --- a/org.lflang.tests/src/org/lflang/tests/LfParsingUtil.java +++ b/org.lflang.tests/src/org/lflang/tests/LfParsingUtil.java @@ -1,100 +1,87 @@ package org.lflang.tests; +import com.google.inject.Injector; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.resource.XtextResource; import org.eclipse.xtext.resource.XtextResourceSet; import org.junit.jupiter.api.Assertions; - import org.lflang.LFStandaloneSetup; import org.lflang.lf.Model; -import com.google.inject.Injector; - /** * @author Clément Fournier */ public class LfParsingUtil { - /** - * Parse the given file, asserts that there are no parsing errors. - */ - public static Model parseValidModel( - String fileName, - String reformattedTestCase - ) { - Model resultingModel = parse(reformattedTestCase); - checkValid(fileName, resultingModel); - return resultingModel; - } + /** Parse the given file, asserts that there are no parsing errors. */ + public static Model parseValidModel(String fileName, String reformattedTestCase) { + Model resultingModel = parse(reformattedTestCase); + checkValid(fileName, resultingModel); + return resultingModel; + } - private static void checkValid(String fileName, Model resultingModel) { - Assertions.assertNotNull(resultingModel); - if (!resultingModel.eResource().getErrors().isEmpty()) { - resultingModel.eResource().getErrors().forEach(System.err::println); - Assertions.assertTrue(resultingModel.eResource().getErrors().isEmpty(), - "Parsing errors in " + fileName); - } + private static void checkValid(String fileName, Model resultingModel) { + Assertions.assertNotNull(resultingModel); + if (!resultingModel.eResource().getErrors().isEmpty()) { + resultingModel.eResource().getErrors().forEach(System.err::println); + Assertions.assertTrue( + resultingModel.eResource().getErrors().isEmpty(), "Parsing errors in " + fileName); } + } - public static Model parseSourceAsIfInDirectory( - Path directory, - String sourceText - ) { - int num = 0; - while (Files.exists(directory.resolve("file" + num + ".lf"))) { - num++; - } - Path file = directory.resolve("file" + num + ".lf"); - try { - Files.writeString(file, sourceText); - Model resultingModel = parse(file); - checkValid("file in " + directory, resultingModel); - return resultingModel; - } catch (IOException e) { - throw new RuntimeException(e); - } finally { - try { - Files.deleteIfExists(file); - } catch (IOException e) { - throw new RuntimeException(e); - } - } - + public static Model parseSourceAsIfInDirectory(Path directory, String sourceText) { + int num = 0; + while (Files.exists(directory.resolve("file" + num + ".lf"))) { + num++; + } + Path file = directory.resolve("file" + num + ".lf"); + try { + Files.writeString(file, sourceText); + Model resultingModel = parse(file); + checkValid("file in " + directory, resultingModel); + return resultingModel; + } catch (IOException e) { + throw new RuntimeException(e); + } finally { + try { + Files.deleteIfExists(file); + } catch (IOException e) { + throw new RuntimeException(e); + } } + } - public static Model parse(String fileContents) { - Path file = null; + public static Model parse(String fileContents) { + Path file = null; + try { + file = Files.createTempFile("lftests", ".lf"); + Files.writeString(file, fileContents); + return parse(file); + } catch (IOException e) { + throw new RuntimeException(e); + } finally { + if (file != null) { try { - file = Files.createTempFile("lftests", ".lf"); - Files.writeString(file, fileContents); - return parse(file); + Files.deleteIfExists(file); } catch (IOException e) { - throw new RuntimeException(e); - } finally { - if (file != null) { - try { - Files.deleteIfExists(file); - } catch (IOException e) { - throw new RuntimeException(e); - } - } + throw new RuntimeException(e); } + } } + } - public static Model parse(Path file) { - // Source: https://wiki.eclipse.org/Xtext/FAQ#How_do_I_load_my_model_in_a_standalone_Java_application_.3F - Injector injector = new LFStandaloneSetup().createInjectorAndDoEMFRegistration(); - XtextResourceSet resourceSet = injector.getInstance(XtextResourceSet.class); - resourceSet.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE); - Resource resource = resourceSet.getResource( - URI.createFileURI(file.toFile().getAbsolutePath()), - true - ); - return (Model) resource.getContents().get(0); - } + public static Model parse(Path file) { + // Source: + // https://wiki.eclipse.org/Xtext/FAQ#How_do_I_load_my_model_in_a_standalone_Java_application_.3F + Injector injector = new LFStandaloneSetup().createInjectorAndDoEMFRegistration(); + XtextResourceSet resourceSet = injector.getInstance(XtextResourceSet.class); + resourceSet.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE); + Resource resource = + resourceSet.getResource(URI.createFileURI(file.toFile().getAbsolutePath()), true); + return (Model) resource.getContents().get(0); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java b/org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java index 0f7e919174..fdb26de7f5 100644 --- a/org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java +++ b/org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java @@ -29,7 +29,6 @@ import java.nio.file.Paths; import java.util.regex.Matcher; import java.util.regex.Pattern; - import org.lflang.Target; import org.lflang.tests.runtime.CCppTest; import org.lflang.tests.runtime.CTest; @@ -39,55 +38,55 @@ import org.lflang.tests.runtime.TypeScriptTest; /** - * Execute a single test case. Use it with the gradle task - * {@code gradle runSingleTest --args test/Python/src/Minimal.lf} + * Execute a single test case. Use it with the gradle task {@code gradle runSingleTest --args + * test/Python/src/Minimal.lf} * * @author Clément Fournier */ public class RunSingleTestMain { + private static final Pattern TEST_FILE_PATTERN = + Pattern.compile("(test/(\\w+))/src/([^/]++/)*(\\w+.lf)"); - private static final Pattern TEST_FILE_PATTERN = Pattern.compile("(test/(\\w+))/src/([^/]++/)*(\\w+.lf)"); - - public static void main(String[] args) throws FileNotFoundException { - if (args.length != 1) { - throw new IllegalArgumentException("Expected 1 path to an LF file"); - } - var path = Paths.get(args[0]); - if (!Files.exists(path)) { - throw new FileNotFoundException("No such test file: " + path); - } + public static void main(String[] args) throws FileNotFoundException { + if (args.length != 1) { + throw new IllegalArgumentException("Expected 1 path to an LF file"); + } + var path = Paths.get(args[0]); + if (!Files.exists(path)) { + throw new FileNotFoundException("No such test file: " + path); + } - Matcher matcher = TEST_FILE_PATTERN.matcher(args[0]); - if (!matcher.matches()) { - throw new FileNotFoundException("Not a test: " + path); - } + Matcher matcher = TEST_FILE_PATTERN.matcher(args[0]); + if (!matcher.matches()) { + throw new FileNotFoundException("Not a test: " + path); + } - Target target = Target.forName(matcher.group(2)).get(); + Target target = Target.forName(matcher.group(2)).get(); - Class testClass = getTestInstance(target); + Class testClass = getTestInstance(target); - LFTest testCase = new LFTest(target, path.toAbsolutePath()); + LFTest testCase = new LFTest(target, path.toAbsolutePath()); - TestBase.runSingleTestAndPrintResults(testCase, testClass, TestBase.pathToLevel(path)); - } + TestBase.runSingleTestAndPrintResults(testCase, testClass, TestBase.pathToLevel(path)); + } - private static Class getTestInstance(Target target) { - switch (target) { - case C: - return CTest.class; - case CCPP: - return CCppTest.class; - case CPP: - return CppTest.class; - case TS: - return TypeScriptTest.class; - case Python: - return PythonTest.class; - case Rust: - return RustTest.class; - default: - throw new IllegalArgumentException(); - } + private static Class getTestInstance(Target target) { + switch (target) { + case C: + return CTest.class; + case CCPP: + return CCppTest.class; + case CPP: + return CppTest.class; + case TS: + return TypeScriptTest.class; + case Python: + return PythonTest.class; + case Rust: + return RustTest.class; + default: + throw new IllegalArgumentException(); } + } } diff --git a/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java b/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java index 77bc6d8034..2dfd42d38b 100644 --- a/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java +++ b/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java @@ -2,207 +2,216 @@ import java.util.EnumSet; import java.util.List; - import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Test; -import org.lflang.ast.ASTUtils; import org.lflang.Target; +import org.lflang.ast.ASTUtils; import org.lflang.tests.TestRegistry.TestCategory; /** * A collection of JUnit tests to perform on a given set of targets. * * @author Marten Lohstroh - * */ public abstract class RuntimeTest extends TestBase { - /** - * Construct a test instance that runs tests for a single target. - * - * @param target The target to run tests for. - */ - protected RuntimeTest(Target target) { - super(target); - } - - /** - * Construct a test instance that runs tests for a list of targets. - * @param targets The targets to run tests for. - */ - protected RuntimeTest(List targets) { - super(targets); - } - - /** - * Whether to enable {@link #runEnclaveTests()}. - */ - protected boolean supportsEnclaves() { return false; } - - /** - * Whether to enable {@link #runFederatedTests()}. - */ - protected boolean supportsFederatedExecution() { - return false; - } - - /** - * Whether to enable {@link #runTypeParameterTests()}. - */ - protected boolean supportsGenericTypes() { - return false; - } - - /** - * Whether to enable {@link #runDockerTests()} and {@link #runDockerFederatedTests()}. - */ - protected boolean supportsDockerOption() { - return false; - } - - @Test - public void runGenericTests() { - runTestsForTargets(Message.DESC_GENERIC, - TestCategory.GENERIC::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - @Test - public void runTargetSpecificTests() { - runTestsForTargets(Message.DESC_TARGET_SPECIFIC, - TestCategory.TARGET::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - @Test - public void runMultiportTests() { - runTestsForTargets(Message.DESC_MULTIPORT, - TestCategory.MULTIPORT::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - @Test - public void runTypeParameterTests() { - Assumptions.assumeTrue(supportsGenericTypes(), Message.NO_GENERICS_SUPPORT); - runTestsForTargets(Message.DESC_TYPE_PARMS, - TestCategory.GENERICS::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - @Test - public void runAsFederated() { - Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); - - EnumSet categories = EnumSet.allOf(TestCategory.class); - categories.removeAll(EnumSet.of(TestCategory.CONCURRENT, - TestCategory.FEDERATED, - // FIXME: also run the multiport tests once these are supported. - TestCategory.MULTIPORT)); - - runTestsFor(List.of(Target.C), - Message.DESC_AS_FEDERATED, - categories::contains, - it -> ASTUtils.makeFederated(it.getFileConfig().resource), - TestLevel.EXECUTION, - true); - } - - @Test - public void runConcurrentTests() { - runTestsForTargets(Message.DESC_CONCURRENT, - TestCategory.CONCURRENT::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - - } - - @Test - public void runFederatedTests() { - Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); - runTestsForTargets(Message.DESC_FEDERATED, - TestCategory.FEDERATED::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - /** - * Run the tests for modal reactors. - */ - @Test - public void runModalTests() { - runTestsForTargets(Message.DESC_MODAL, - TestCategory.MODAL_MODELS::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - /** - * Run the tests for non-inlined reaction bodies. - */ - @Test - public void runNoInliningTests() { - runTestsForTargets(Message.DESC_MODAL, - TestCategory.NO_INLINING::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - /** - * Run docker tests, provided that the platform is Linux and the target supports Docker. - * Skip if platform is not Linux or target does not support Docker. - */ - @Test - public void runDockerTests() { - Assumptions.assumeTrue(isLinux(), Message.NO_DOCKER_TEST_SUPPORT); - Assumptions.assumeTrue(supportsDockerOption(), Message.NO_DOCKER_SUPPORT); - runTestsForTargets(Message.DESC_DOCKER, - TestCategory.DOCKER::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - /** - * Run federated docker tests, provided that the platform is Linux, the target supports Docker, - * and the target supports federated execution. If any of these requirements are not met, skip - * the tests. - */ - @Test - public void runDockerFederatedTests() { - Assumptions.assumeTrue(isLinux(), Message.NO_DOCKER_TEST_SUPPORT); - Assumptions.assumeTrue(supportsDockerOption(), Message.NO_DOCKER_SUPPORT); - Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); - runTestsForTargets(Message.DESC_DOCKER_FEDERATED, - TestCategory.DOCKER_FEDERATED::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - - @Test - public void runWithThreadingOff() { - Assumptions.assumeTrue(supportsSingleThreadedExecution(), Message.NO_SINGLE_THREADED_SUPPORT); - this.runTestsForTargets( - Message.DESC_SINGLE_THREADED, - Configurators::compatibleWithThreadingOff, - Configurators::disableThreading, - TestLevel.EXECUTION, - true - ); - } - - /** - * Run enclave tests if the target supports enclaves. - */ - @Test - public void runEnclaveTests() { - Assumptions.assumeTrue(supportsEnclaves(), Message.NO_ENCLAVE_SUPPORT); - runTestsForTargets(Message.DESC_ENCLAVE, - TestCategory.ENCLAVE::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - + /** + * Construct a test instance that runs tests for a single target. + * + * @param target The target to run tests for. + */ + protected RuntimeTest(Target target) { + super(target); + } + + /** + * Construct a test instance that runs tests for a list of targets. + * + * @param targets The targets to run tests for. + */ + protected RuntimeTest(List targets) { + super(targets); + } + + /** Whether to enable {@link #runEnclaveTests()}. */ + protected boolean supportsEnclaves() { + return false; + } + + /** Whether to enable {@link #runFederatedTests()}. */ + protected boolean supportsFederatedExecution() { + return false; + } + + /** Whether to enable {@link #runTypeParameterTests()}. */ + protected boolean supportsGenericTypes() { + return false; + } + + /** Whether to enable {@link #runDockerTests()} and {@link #runDockerFederatedTests()}. */ + protected boolean supportsDockerOption() { + return false; + } + + @Test + public void runGenericTests() { + runTestsForTargets( + Message.DESC_GENERIC, + TestCategory.GENERIC::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + @Test + public void runTargetSpecificTests() { + runTestsForTargets( + Message.DESC_TARGET_SPECIFIC, + TestCategory.TARGET::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + @Test + public void runMultiportTests() { + runTestsForTargets( + Message.DESC_MULTIPORT, + TestCategory.MULTIPORT::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + @Test + public void runTypeParameterTests() { + Assumptions.assumeTrue(supportsGenericTypes(), Message.NO_GENERICS_SUPPORT); + runTestsForTargets( + Message.DESC_TYPE_PARMS, + TestCategory.GENERICS::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + @Test + public void runAsFederated() { + Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); + + EnumSet categories = EnumSet.allOf(TestCategory.class); + categories.removeAll( + EnumSet.of( + TestCategory.CONCURRENT, + TestCategory.FEDERATED, + // FIXME: also run the multiport tests once these are supported. + TestCategory.MULTIPORT)); + + runTestsFor( + List.of(Target.C), + Message.DESC_AS_FEDERATED, + categories::contains, + it -> ASTUtils.makeFederated(it.getFileConfig().resource), + TestLevel.EXECUTION, + true); + } + + @Test + public void runConcurrentTests() { + runTestsForTargets( + Message.DESC_CONCURRENT, + TestCategory.CONCURRENT::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + @Test + public void runFederatedTests() { + Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); + runTestsForTargets( + Message.DESC_FEDERATED, + TestCategory.FEDERATED::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + /** Run the tests for modal reactors. */ + @Test + public void runModalTests() { + runTestsForTargets( + Message.DESC_MODAL, + TestCategory.MODAL_MODELS::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + /** Run the tests for non-inlined reaction bodies. */ + @Test + public void runNoInliningTests() { + runTestsForTargets( + Message.DESC_MODAL, + TestCategory.NO_INLINING::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + /** + * Run docker tests, provided that the platform is Linux and the target supports Docker. Skip if + * platform is not Linux or target does not support Docker. + */ + @Test + public void runDockerTests() { + Assumptions.assumeTrue(isLinux(), Message.NO_DOCKER_TEST_SUPPORT); + Assumptions.assumeTrue(supportsDockerOption(), Message.NO_DOCKER_SUPPORT); + runTestsForTargets( + Message.DESC_DOCKER, + TestCategory.DOCKER::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + /** + * Run federated docker tests, provided that the platform is Linux, the target supports Docker, + * and the target supports federated execution. If any of these requirements are not met, skip the + * tests. + */ + @Test + public void runDockerFederatedTests() { + Assumptions.assumeTrue(isLinux(), Message.NO_DOCKER_TEST_SUPPORT); + Assumptions.assumeTrue(supportsDockerOption(), Message.NO_DOCKER_SUPPORT); + Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); + runTestsForTargets( + Message.DESC_DOCKER_FEDERATED, + TestCategory.DOCKER_FEDERATED::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + + @Test + public void runWithThreadingOff() { + Assumptions.assumeTrue(supportsSingleThreadedExecution(), Message.NO_SINGLE_THREADED_SUPPORT); + this.runTestsForTargets( + Message.DESC_SINGLE_THREADED, + Configurators::compatibleWithThreadingOff, + Configurators::disableThreading, + TestLevel.EXECUTION, + true); + } + + /** Run enclave tests if the target supports enclaves. */ + @Test + public void runEnclaveTests() { + Assumptions.assumeTrue(supportsEnclaves(), Message.NO_ENCLAVE_SUPPORT); + runTestsForTargets( + Message.DESC_ENCLAVE, + TestCategory.ENCLAVE::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/TestBase.java b/org.lflang.tests/src/org/lflang/tests/TestBase.java index 192a531828..9ae075780a 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestBase.java +++ b/org.lflang.tests/src/org/lflang/tests/TestBase.java @@ -3,7 +3,11 @@ import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; -import java.io.FileWriter; +import com.google.inject.Inject; +import com.google.inject.Injector; +import com.google.inject.Provider; +import java.io.BufferedWriter; +import java.io.File; import java.io.IOException; import java.io.PrintStream; import java.io.PrintWriter; @@ -12,8 +16,6 @@ import java.lang.reflect.InvocationTargetException; import java.nio.file.Files; import java.nio.file.Path; -import java.io.File; -import java.io.BufferedWriter; import java.util.Arrays; import java.util.Collections; import java.util.List; @@ -24,7 +26,6 @@ import java.util.concurrent.atomic.AtomicReference; import java.util.function.Predicate; import java.util.stream.Collectors; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource.Diagnostic; import org.eclipse.emf.ecore.resource.ResourceSet; @@ -37,7 +38,6 @@ import org.eclipse.xtext.validation.CheckMode; import org.eclipse.xtext.validation.IResourceValidator; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.DefaultErrorReporter; import org.lflang.FileConfig; import org.lflang.LFRuntimeModule; @@ -48,18 +48,11 @@ import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFGeneratorContext.BuildParm; import org.lflang.generator.MainContext; -import org.lflang.generator.GeneratorCommandFactory; import org.lflang.tests.Configurators.Configurator; import org.lflang.tests.LFTest.Result; import org.lflang.tests.TestRegistry.TestCategory; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; -import org.lflang.util.ArduinoUtil; - - -import com.google.inject.Inject; -import com.google.inject.Injector; -import com.google.inject.Provider; /** * Base class for test classes that define JUnit tests. @@ -70,501 +63,518 @@ @InjectWith(LFInjectorProvider.class) public abstract class TestBase { - @Inject - IResourceValidator validator; - @Inject - LFGenerator generator; - @Inject - JavaIoFileSystemAccess fileAccess; - @Inject - Provider resourceSetProvider; - - - /** Reference to System.out. */ - private static final PrintStream out = System.out; - - /** Reference to System.err. */ - private static final PrintStream err = System.err; - - /** Execution timeout enforced for all tests. */ - private static final long MAX_EXECUTION_TIME_SECONDS = 180; - - /** Content separator used in test output, 78 characters wide. */ - public static final String THIN_LINE = - "------------------------------------------------------------------------------" + - System.lineSeparator(); - - /** Content separator used in test output, 78 characters wide. */ - public static final String THICK_LINE = - "==============================================================================" + - System.lineSeparator(); - - /** The targets for which to run the tests. */ - private final List targets; - - /** - * An enumeration of test levels. - * @author Marten Lohstroh - * - */ - public enum TestLevel {VALIDATION, CODE_GEN, BUILD, EXECUTION} - - /** - * Static function for converting a path to its associated test level. - * @author Anirudh Rengarajan - */ - public static TestLevel pathToLevel(Path path) { - while(path.getParent() != null) { - String name = path.getFileName().toString(); - for (var category: TestCategory.values()) { - if (category.name().equalsIgnoreCase(name)) { - return category.level; - } - } - path = path.getParent(); + @Inject IResourceValidator validator; + @Inject LFGenerator generator; + @Inject JavaIoFileSystemAccess fileAccess; + @Inject Provider resourceSetProvider; + + /** Reference to System.out. */ + private static final PrintStream out = System.out; + + /** Reference to System.err. */ + private static final PrintStream err = System.err; + + /** Execution timeout enforced for all tests. */ + private static final long MAX_EXECUTION_TIME_SECONDS = 180; + + /** Content separator used in test output, 78 characters wide. */ + public static final String THIN_LINE = + "------------------------------------------------------------------------------" + + System.lineSeparator(); + + /** Content separator used in test output, 78 characters wide. */ + public static final String THICK_LINE = + "==============================================================================" + + System.lineSeparator(); + + /** The targets for which to run the tests. */ + private final List targets; + + /** + * An enumeration of test levels. + * + * @author Marten Lohstroh + */ + public enum TestLevel { + VALIDATION, + CODE_GEN, + BUILD, + EXECUTION + } + + /** + * Static function for converting a path to its associated test level. + * + * @author Anirudh Rengarajan + */ + public static TestLevel pathToLevel(Path path) { + while (path.getParent() != null) { + String name = path.getFileName().toString(); + for (var category : TestCategory.values()) { + if (category.name().equalsIgnoreCase(name)) { + return category.level; } - return TestLevel.EXECUTION; + } + path = path.getParent(); } - - /** - * A collection messages often used throughout the test package. - * - * @author Marten Lohstroh - * - */ - public static class Message { - /* Reasons for not running tests. */ - public static final String NO_WINDOWS_SUPPORT = "Not (yet) supported on Windows."; - public static final String NO_SINGLE_THREADED_SUPPORT = "Target does not support single-threaded execution."; - public static final String NO_FEDERATION_SUPPORT = "Target does not support federated execution."; - public static final String NO_ENCLAVE_SUPPORT = "Targeet does not support the enclave feature."; - public static final String NO_DOCKER_SUPPORT = "Target does not support the 'docker' property."; - public static final String NO_DOCKER_TEST_SUPPORT = "Docker tests are only supported on Linux."; - public static final String NO_GENERICS_SUPPORT = "Target does not support generic types."; - - /* Descriptions of collections of tests. */ - public static final String DESC_SERIALIZATION = "Run serialization tests."; - public static final String DESC_GENERIC = "Run generic tests."; - public static final String DESC_TYPE_PARMS = "Run tests for reactors with type parameters."; - public static final String DESC_MULTIPORT = "Run multiport tests."; - public static final String DESC_AS_FEDERATED = "Run non-federated tests in federated mode."; - public static final String DESC_FEDERATED = "Run federated tests."; - public static final String DESC_DOCKER = "Run docker tests."; - public static final String DESC_DOCKER_FEDERATED = "Run docker federated tests."; - public static final String DESC_ENCLAVE = "Run enclave tests."; - public static final String DESC_CONCURRENT = "Run concurrent tests."; - public static final String DESC_TARGET_SPECIFIC = "Run target-specific tests"; - public static final String DESC_ARDUINO = "Running Arduino tests."; - public static final String DESC_ZEPHYR = "Running Zephyr tests."; - public static final String DESC_AS_CCPP = "Running C tests as CCpp."; - public static final String DESC_SINGLE_THREADED = "Run non-concurrent and non-federated tests with threading = off."; - public static final String DESC_SCHED_SWAPPING = "Running with non-default runtime scheduler "; - public static final String DESC_ROS2 = "Running tests using ROS2."; - public static final String DESC_MODAL = "Run modal reactor tests."; - - /* Missing dependency messages */ - public static final String MISSING_DOCKER = "Executable 'docker' not found or 'docker' daemon thread not running"; - public static final String MISSING_ARDUINO_CLI = "Executable 'arduino-cli' not found"; + return TestLevel.EXECUTION; + } + + /** + * A collection messages often used throughout the test package. + * + * @author Marten Lohstroh + */ + public static class Message { + /* Reasons for not running tests. */ + public static final String NO_WINDOWS_SUPPORT = "Not (yet) supported on Windows."; + public static final String NO_SINGLE_THREADED_SUPPORT = + "Target does not support single-threaded execution."; + public static final String NO_FEDERATION_SUPPORT = + "Target does not support federated execution."; + public static final String NO_ENCLAVE_SUPPORT = "Targeet does not support the enclave feature."; + public static final String NO_DOCKER_SUPPORT = "Target does not support the 'docker' property."; + public static final String NO_DOCKER_TEST_SUPPORT = "Docker tests are only supported on Linux."; + public static final String NO_GENERICS_SUPPORT = "Target does not support generic types."; + + /* Descriptions of collections of tests. */ + public static final String DESC_SERIALIZATION = "Run serialization tests."; + public static final String DESC_GENERIC = "Run generic tests."; + public static final String DESC_TYPE_PARMS = "Run tests for reactors with type parameters."; + public static final String DESC_MULTIPORT = "Run multiport tests."; + public static final String DESC_AS_FEDERATED = "Run non-federated tests in federated mode."; + public static final String DESC_FEDERATED = "Run federated tests."; + public static final String DESC_DOCKER = "Run docker tests."; + public static final String DESC_DOCKER_FEDERATED = "Run docker federated tests."; + public static final String DESC_ENCLAVE = "Run enclave tests."; + public static final String DESC_CONCURRENT = "Run concurrent tests."; + public static final String DESC_TARGET_SPECIFIC = "Run target-specific tests"; + public static final String DESC_ARDUINO = "Running Arduino tests."; + public static final String DESC_ZEPHYR = "Running Zephyr tests."; + public static final String DESC_AS_CCPP = "Running C tests as CCpp."; + public static final String DESC_SINGLE_THREADED = + "Run non-concurrent and non-federated tests with threading = off."; + public static final String DESC_SCHED_SWAPPING = "Running with non-default runtime scheduler "; + public static final String DESC_ROS2 = "Running tests using ROS2."; + public static final String DESC_MODAL = "Run modal reactor tests."; + + /* Missing dependency messages */ + public static final String MISSING_DOCKER = + "Executable 'docker' not found or 'docker' daemon thread not running"; + public static final String MISSING_ARDUINO_CLI = "Executable 'arduino-cli' not found"; + } + + /** Constructor for test classes that test a single target. */ + protected TestBase(Target first) { + this(Collections.singletonList(first)); + } + + /** Special ctor for the code coverage test */ + protected TestBase(List targets) { + assertFalse(targets.isEmpty(), "empty target list"); + this.targets = Collections.unmodifiableList(targets); + TestRegistry.initialize(); + } + + /** + * Run selected tests for a given target and configurator up to the specified level. + * + * @param target The target to run tests for. + * @param selected A predicate that given a test category returns whether it should be included in + * this test run or not. + * @param configurator A procedure for configuring the tests. + * @param copy Whether or not to work on copies of tests in the test. registry. + */ + protected final void runTestsAndPrintResults( + Target target, + Predicate selected, + TestLevel level, + Configurator configurator, + boolean copy) { + var categories = Arrays.stream(TestCategory.values()).filter(selected).toList(); + for (var category : categories) { + System.out.println(category.getHeader()); + var tests = TestRegistry.getRegisteredTests(target, category, copy); + try { + validateAndRun(tests, configurator, level); + } catch (IOException e) { + throw new RuntimeIOException(e); + } + System.out.println(TestRegistry.getCoverageReport(target, category)); + checkAndReportFailures(tests); } - - /** Constructor for test classes that test a single target. */ - protected TestBase(Target first) { - this(Collections.singletonList(first)); + } + + /** + * Run tests in the given selection for all targets enabled in this class. + * + * @param description A string that describes the collection of tests. + * @param selected A predicate that given a test category returns whether it should be included in + * this test run or not. + * @param configurator A procedure for configuring the tests. + * @param copy Whether or not to work on copies of tests in the test. registry. + */ + protected void runTestsForTargets( + String description, + Predicate selected, + Configurator configurator, + TestLevel level, + boolean copy) { + for (Target target : this.targets) { + runTestsFor(List.of(target), description, selected, configurator, level, copy); } - - /** Special ctor for the code coverage test */ - protected TestBase(List targets) { - assertFalse(targets.isEmpty(), "empty target list"); - this.targets = Collections.unmodifiableList(targets); - TestRegistry.initialize(); + } + + /** + * Run tests in the given selection for a subset of given targets. + * + * @param subset The subset of targets to run the selected tests for. + * @param description A string that describes the collection of tests. + * @param selected A predicate that given a test category returns whether it should be included in + * this test run or not. + * @param configurator A procedure for configuring the tests. + * @param copy Whether to work on copies of tests in the test. registry. + */ + protected void runTestsFor( + List subset, + String description, + Predicate selected, + Configurator configurator, + TestLevel level, + boolean copy) { + for (Target target : subset) { + printTestHeader(target, description); + runTestsAndPrintResults(target, selected, level, configurator, copy); } - - /** - * Run selected tests for a given target and configurator up to the specified level. - * - * @param target The target to run tests for. - * @param selected A predicate that given a test category returns whether - * it should be included in this test run or not. - * @param configurator A procedure for configuring the tests. - * @param copy Whether or not to work on copies of tests in the test. - * registry. - */ - protected final void runTestsAndPrintResults(Target target, - Predicate selected, - TestLevel level, - Configurator configurator, - boolean copy) { - var categories = Arrays.stream(TestCategory.values()).filter(selected).toList(); - for (var category : categories) { - System.out.println(category.getHeader()); - var tests = TestRegistry.getRegisteredTests(target, category, copy); - try { - validateAndRun(tests, configurator, level); - } catch (IOException e) { - throw new RuntimeIOException(e); - } - System.out.println(TestRegistry.getCoverageReport(target, category)); - checkAndReportFailures(tests); - } + } + + /** Whether to enable threading. */ + protected boolean supportsSingleThreadedExecution() { + return false; + } + + /** + * Determine whether the current platform is Windows. + * + * @return true if the current platform is Windwos, false otherwise. + */ + protected static boolean isWindows() { + String OS = System.getProperty("os.name").toLowerCase(); + return OS.contains("win"); + } + + /** + * Determine whether the current platform is MacOS. + * + * @return true if the current platform is MacOS, false otherwise. + */ + protected static boolean isMac() { + String OS = System.getProperty("os.name").toLowerCase(); + return OS.contains("mac"); + } + + /** + * Determine whether the current platform is Linux. + * + * @return true if the current platform is Linux, false otherwise. + */ + protected static boolean isLinux() { + String OS = System.getProperty("os.name").toLowerCase(); + return OS.contains("linux"); + } + + /** End output redirection. */ + private static void restoreOutputs() { + System.out.flush(); + System.err.flush(); + System.setOut(out); + System.setErr(err); + } + + /** + * Redirect outputs to the given tests for recording. + * + * @param test The test to redirect outputs to. + */ + private static void redirectOutputs(LFTest test) { + System.setOut(new PrintStream(test.getOutputStream())); + System.setErr(new PrintStream(test.getOutputStream())); + } + + /** + * Run a test, print results on stderr. + * + * @param test Test case. + * @param testClass The test class that will execute the test. This is target-specific, it may + * provide some target-specific configuration. We pass a class and not a new instance because + * this method needs to ensure the object is properly injected, and so, it needs to control + * its entire lifecycle. + * @param level Level to which to run the test. + */ + public static void runSingleTestAndPrintResults( + LFTest test, Class testClass, TestLevel level) { + Injector injector = + new LFStandaloneSetup(new LFRuntimeModule()).createInjectorAndDoEMFRegistration(); + TestBase runner; + try { + @SuppressWarnings("unchecked") + Constructor constructor = + (Constructor) testClass.getConstructors()[0]; + runner = constructor.newInstance(); + } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) { + throw new IllegalStateException(e); } + injector.injectMembers(runner); - /** - * Run tests in the given selection for all targets enabled in this class. - * - * @param description A string that describes the collection of tests. - * @param selected A predicate that given a test category returns whether - * it should be included in this test run or not. - * @param configurator A procedure for configuring the tests. - * @param copy Whether or not to work on copies of tests in the test. - * registry. - */ - protected void runTestsForTargets(String description, - Predicate selected, - Configurator configurator, - TestLevel level, - boolean copy) { - for (Target target : this.targets) { - runTestsFor(List.of(target), description, selected, - configurator, level, copy); - } + Set tests = Set.of(test); + try { + runner.validateAndRun(tests, t -> true, level); + } catch (IOException e) { + throw new RuntimeIOException(e); } - - /** - * Run tests in the given selection for a subset of given targets. - * - * @param subset The subset of targets to run the selected tests for. - * @param description A string that describes the collection of tests. - * @param selected A predicate that given a test category returns whether - * it should be included in this test run or not. - * @param configurator A procedure for configuring the tests. - * @param copy Whether to work on copies of tests in the test. - * registry. - */ - protected void runTestsFor(List subset, - String description, - Predicate selected, - Configurator configurator, - TestLevel level, - boolean copy) { - for (Target target : subset) { - printTestHeader(target, description); - runTestsAndPrintResults(target, selected, level, configurator, copy); - } + checkAndReportFailures(tests); + } + + /** + * Print a header that describes a collection of tests. + * + * @param target The target for which the tests are being performed. + * @param description A string the describes the collection of tests. + */ + protected static void printTestHeader(Target target, String description) { + System.out.print(TestBase.THICK_LINE); + System.out.println("Target: " + target); + if (description.startsWith("Description: ")) { + System.out.println(description); + } else { + System.out.println("Description: " + description); } - - /** - * Whether to enable threading. - */ - protected boolean supportsSingleThreadedExecution() { - return false; + System.out.println(TestBase.THICK_LINE); + } + + /** + * Iterate over given tests and evaluate their outcome, report errors if there are any. + * + * @param tests The tests to inspect the results of. + */ + private static void checkAndReportFailures(Set tests) { + var passed = tests.stream().filter(it -> it.hasPassed()).collect(Collectors.toList()); + var s = new StringBuffer(); + s.append(THIN_LINE); + s.append("Passing: " + passed.size() + "/" + tests.size() + "\n"); + s.append(THIN_LINE); + passed.forEach(test -> s.append("Passed: ").append(test).append("\n")); + s.append(THIN_LINE); + System.out.print(s.toString()); + + for (var test : tests) { + test.reportErrors(); } - - /** - * Determine whether the current platform is Windows. - * @return true if the current platform is Windwos, false otherwise. - */ - protected static boolean isWindows() { - String OS = System.getProperty("os.name").toLowerCase(); - return OS.contains("win"); - } - - /** - * Determine whether the current platform is MacOS. - * @return true if the current platform is MacOS, false otherwise. - */ - protected static boolean isMac() { - String OS = System.getProperty("os.name").toLowerCase(); - return OS.contains("mac"); - } - - /** - * Determine whether the current platform is Linux. - * @return true if the current platform is Linux, false otherwise. - */ - protected static boolean isLinux() { - String OS = System.getProperty("os.name").toLowerCase(); - return OS.contains("linux"); + for (LFTest lfTest : tests) { + assertTrue(lfTest.hasPassed()); } - - /** - * End output redirection. - */ - private static void restoreOutputs() { - System.out.flush(); - System.err.flush(); - System.setOut(out); - System.setErr(err); + } + + /** + * Configure a test by applying the given configurator and return a generator context. Also, if + * the given level is less than {@code TestLevel.BUILD}, add a {@code no-compile} flag to the + * generator context. If the configurator was not applied successfully, throw an AssertionError. + * + * @param test the test to configure. + * @param configurator The configurator to apply to the test. + * @param level The level of testing in which the generator context will be used. + */ + private void configure(LFTest test, Configurator configurator, TestLevel level) + throws IOException, TestError { + var props = new Properties(); + props.setProperty("hierarchical-bin", "true"); + addExtraLfcArgs(props); + + var sysProps = System.getProperties(); + // Set the external-runtime-path property if it was specified. + if (sysProps.containsKey("runtime")) { + var rt = sysProps.get("runtime").toString(); + if (!rt.isEmpty()) { + props.setProperty(BuildParm.EXTERNAL_RUNTIME_PATH.getKey(), rt); + System.out.println("Using runtime: " + sysProps.get("runtime").toString()); + } + } else { + System.out.println("Using default runtime."); } - /** - * Redirect outputs to the given tests for recording. - * - * @param test The test to redirect outputs to. - */ - private static void redirectOutputs(LFTest test) { - System.setOut(new PrintStream(test.getOutputStream())); - System.setErr(new PrintStream(test.getOutputStream())); + var r = + resourceSetProvider + .get() + .getResource(URI.createFileURI(test.getSrcPath().toFile().getAbsolutePath()), true); + + if (r.getErrors().size() > 0) { + String message = + r.getErrors().stream() + .map(Diagnostic::toString) + .collect(Collectors.joining(System.lineSeparator())); + throw new TestError(message, Result.PARSE_FAIL); } - - /** - * Run a test, print results on stderr. - * - * @param test Test case. - * @param testClass The test class that will execute the test. This is target-specific, - * it may provide some target-specific configuration. We pass a class - * and not a new instance because this method needs to ensure the object - * is properly injected, and so, it needs to control its entire lifecycle. - * @param level Level to which to run the test. - */ - public static void runSingleTestAndPrintResults(LFTest test, Class testClass, TestLevel level) { - Injector injector = new LFStandaloneSetup(new LFRuntimeModule()).createInjectorAndDoEMFRegistration(); - TestBase runner; - try { - @SuppressWarnings("unchecked") - Constructor constructor = (Constructor) testClass.getConstructors()[0]; - runner = constructor.newInstance(); - } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) { - throw new IllegalStateException(e); - } - injector.injectMembers(runner); - - Set tests = Set.of(test); - try { - runner.validateAndRun(tests, t -> true, level); - } catch (IOException e) { - throw new RuntimeIOException(e); - } - checkAndReportFailures(tests); + fileAccess.setOutputPath( + FileConfig.findPackageRoot(test.getSrcPath(), s -> {}) + .resolve(FileConfig.DEFAULT_SRC_GEN_DIR) + .toString()); + var context = + new MainContext( + LFGeneratorContext.Mode.STANDALONE, + CancelIndicator.NullImpl, + (m, p) -> {}, + props, + r, + fileAccess, + fileConfig -> new DefaultErrorReporter()); + + test.configure(context); + + // Set the no-compile flag the test is not supposed to reach the build stage. + if (level.compareTo(TestLevel.BUILD) < 0) { + context.getArgs().setProperty("no-compile", ""); } - /** - * Print a header that describes a collection of tests. - * @param target The target for which the tests are being performed. - * @param description A string the describes the collection of tests. - */ - protected static void printTestHeader(Target target, String description) { - System.out.print(TestBase.THICK_LINE); - System.out.println("Target: " + target); - if (description.startsWith("Description: ")) { - System.out.println(description); - } else { - System.out.println("Description: " + description); - } - System.out.println(TestBase.THICK_LINE); + // Reload in case target properties have changed. + context.loadTargetConfig(); + // Update the test by applying the configuration. E.g., to carry out an AST transformation. + if (configurator != null) { + if (!configurator.configure(test)) { + throw new TestError("Test configuration unsuccessful.", Result.CONFIG_FAIL); + } } - - /** - * Iterate over given tests and evaluate their outcome, report errors if - * there are any. - * - * @param tests The tests to inspect the results of. - */ - private static void checkAndReportFailures(Set tests) { - var passed = tests.stream().filter(it -> it.hasPassed()).collect(Collectors.toList()); - var s = new StringBuffer(); - s.append(THIN_LINE); - s.append("Passing: " + passed.size() + "/" + tests.size() + "\n"); - s.append(THIN_LINE); - passed.forEach(test -> s.append("Passed: ").append(test).append("\n")); - s.append(THIN_LINE); - System.out.print(s.toString()); - - for (var test : tests) { - test.reportErrors(); - } - for (LFTest lfTest : tests) { - assertTrue(lfTest.hasPassed()); + } + + /** Validate the given test. Throw an TestError if validation failed. */ + private void validate(LFTest test) throws TestError { + // Validate the resource and store issues in the test object. + try { + var context = test.getContext(); + var issues = + validator.validate( + context.getFileConfig().resource, CheckMode.ALL, context.getCancelIndicator()); + if (issues != null && !issues.isEmpty()) { + if (issues.stream().anyMatch(it -> it.getSeverity() == Severity.ERROR)) { + String message = + issues.stream() + .map(Objects::toString) + .collect(Collectors.joining(System.lineSeparator())); + throw new TestError(message, Result.VALIDATE_FAIL); } + } + } catch (TestError e) { + throw e; + } catch (Throwable e) { + throw new TestError("Exception during validation.", Result.VALIDATE_FAIL, e); } - - /** - * Configure a test by applying the given configurator and return a - * generator context. Also, if the given level is less than - * {@code TestLevel.BUILD}, add a {@code no-compile} flag to the generator context. If - * the configurator was not applied successfully, throw an AssertionError. - * - * @param test the test to configure. - * @param configurator The configurator to apply to the test. - * @param level The level of testing in which the generator context will be - * used. - */ - private void configure(LFTest test, Configurator configurator, TestLevel level) throws IOException, TestError { - var props = new Properties(); - props.setProperty("hierarchical-bin", "true"); - addExtraLfcArgs(props); - - var sysProps = System.getProperties(); - // Set the external-runtime-path property if it was specified. - if (sysProps.containsKey("runtime")) { - var rt = sysProps.get("runtime").toString(); - if (!rt.isEmpty()) { - props.setProperty(BuildParm.EXTERNAL_RUNTIME_PATH.getKey(), rt); - System.out.println("Using runtime: " + sysProps.get("runtime").toString()); - } - } else { - System.out.println("Using default runtime."); - } - - var r = resourceSetProvider.get().getResource( - URI.createFileURI(test.getSrcPath().toFile().getAbsolutePath()), - true); - - if (r.getErrors().size() > 0) { - String message = r.getErrors().stream().map(Diagnostic::toString).collect(Collectors.joining(System.lineSeparator())); - throw new TestError(message, Result.PARSE_FAIL); - } - - fileAccess.setOutputPath(FileConfig.findPackageRoot(test.getSrcPath(), s -> {}).resolve(FileConfig.DEFAULT_SRC_GEN_DIR).toString()); - var context = new MainContext( - LFGeneratorContext.Mode.STANDALONE, CancelIndicator.NullImpl, (m, p) -> {}, props, r, fileAccess, - fileConfig -> new DefaultErrorReporter() - ); - - test.configure(context); - - // Set the no-compile flag the test is not supposed to reach the build stage. - if (level.compareTo(TestLevel.BUILD) < 0) { - context.getArgs().setProperty("no-compile", ""); - } - - // Reload in case target properties have changed. - context.loadTargetConfig(); - // Update the test by applying the configuration. E.g., to carry out an AST transformation. - if (configurator != null) { - if (!configurator.configure(test)) { - throw new TestError("Test configuration unsuccessful.", Result.CONFIG_FAIL); - } - } + } + + /** Override to add some LFC arguments to all runs of this test class. */ + protected void addExtraLfcArgs(Properties args) { + args.setProperty("build-type", "Test"); + args.setProperty("logging", "Debug"); + } + + /** + * Invoke the code generator for the given test. + * + * @param test The test to generate code for. + */ + private GeneratorResult generateCode(LFTest test) throws TestError { + if (test.getFileConfig().resource == null) { + return GeneratorResult.NOTHING; } - - /** - * Validate the given test. Throw an TestError if validation failed. - */ - private void validate(LFTest test) throws TestError { - // Validate the resource and store issues in the test object. - try { - var context = test.getContext(); - var issues = validator.validate(context.getFileConfig().resource, - CheckMode.ALL, context.getCancelIndicator()); - if (issues != null && !issues.isEmpty()) { - if (issues.stream().anyMatch(it -> it.getSeverity() == Severity.ERROR)) { - String message = issues.stream().map(Objects::toString).collect(Collectors.joining(System.lineSeparator())); - throw new TestError(message, Result.VALIDATE_FAIL); - } - } - } catch (TestError e) { - throw e; - } catch (Throwable e) { - throw new TestError("Exception during validation.", Result.VALIDATE_FAIL, e); - } + try { + generator.doGenerate(test.getFileConfig().resource, fileAccess, test.getContext()); + } catch (Throwable e) { + throw new TestError("Code generation unsuccessful.", Result.CODE_GEN_FAIL, e); } - - - /** - * Override to add some LFC arguments to all runs of this test class. - */ - protected void addExtraLfcArgs(Properties args) { - args.setProperty("build-type", "Test"); - args.setProperty("logging", "Debug"); + if (generator.errorsOccurred()) { + throw new TestError("Code generation unsuccessful.", Result.CODE_GEN_FAIL); } - /** - * Invoke the code generator for the given test. - * - * @param test The test to generate code for. - */ - private GeneratorResult generateCode(LFTest test) throws TestError { - if (test.getFileConfig().resource == null) { - return GeneratorResult.NOTHING; - } - try { - generator.doGenerate(test.getFileConfig().resource, fileAccess, test.getContext()); - } catch (Throwable e) { - throw new TestError("Code generation unsuccessful.", Result.CODE_GEN_FAIL, e); - } - if (generator.errorsOccurred()) { - throw new TestError("Code generation unsuccessful.", Result.CODE_GEN_FAIL); + return test.getContext().getResult(); + } + + /** + * Given an indexed test, execute it and label the test as failing if it did not execute, took too + * long to execute, or executed but exited with an error code. + */ + private void execute(LFTest test) throws TestError { + final var pb = getExecCommand(test); + try { + var p = pb.start(); + var stdout = test.recordStdOut(p); + var stderr = test.recordStdErr(p); + + var stdoutException = new AtomicReference(null); + var stderrException = new AtomicReference(null); + + stdout.setUncaughtExceptionHandler((thread, throwable) -> stdoutException.set(throwable)); + stderr.setUncaughtExceptionHandler((thread, throwable) -> stderrException.set(throwable)); + + stderr.start(); + stdout.start(); + + if (!p.waitFor(MAX_EXECUTION_TIME_SECONDS, TimeUnit.SECONDS)) { + stdout.interrupt(); + stderr.interrupt(); + p.destroyForcibly(); + throw new TestError(Result.TEST_TIMEOUT); + } else { + if (stdoutException.get() != null || stderrException.get() != null) { + StringBuffer sb = new StringBuffer(); + if (stdoutException.get() != null) { + sb.append("Error during stdout handling:" + System.lineSeparator()); + sb.append(stackTraceToString(stdoutException.get())); + } + if (stderrException.get() != null) { + sb.append("Error during stderr handling:" + System.lineSeparator()); + sb.append(stackTraceToString(stderrException.get())); + } + throw new TestError(sb.toString(), Result.TEST_EXCEPTION); } - - return test.getContext().getResult(); - } - - - /** - * Given an indexed test, execute it and label the test as failing if it - * did not execute, took too long to execute, or executed but exited with - * an error code. - */ - private void execute(LFTest test) throws TestError { - final var pb = getExecCommand(test); - try { - var p = pb.start(); - var stdout = test.recordStdOut(p); - var stderr = test.recordStdErr(p); - - var stdoutException = new AtomicReference(null); - var stderrException = new AtomicReference(null); - - stdout.setUncaughtExceptionHandler((thread, throwable) -> stdoutException.set(throwable)); - stderr.setUncaughtExceptionHandler((thread, throwable) -> stderrException.set(throwable)); - - stderr.start(); - stdout.start(); - - if (!p.waitFor(MAX_EXECUTION_TIME_SECONDS, TimeUnit.SECONDS)) { - stdout.interrupt(); - stderr.interrupt(); - p.destroyForcibly(); - throw new TestError(Result.TEST_TIMEOUT); - } else { - if (stdoutException.get() != null || stderrException.get() != null) { - StringBuffer sb = new StringBuffer(); - if (stdoutException.get() != null) { - sb.append("Error during stdout handling:" + System.lineSeparator()); - sb.append(stackTraceToString(stdoutException.get())); - } - if (stderrException.get() != null) { - sb.append("Error during stderr handling:" + System.lineSeparator()); - sb.append(stackTraceToString(stderrException.get())); - } - throw new TestError(sb.toString(), Result.TEST_EXCEPTION); - } - if (p.exitValue() != 0) { - String message = "Exit code: " + p.exitValue(); - if (p.exitValue() == 139) { - // The java ProcessBuilder and Process interface does not allow us to reliably retrieve stderr and stdout - // from a process that segfaults. We can only print a message indicating that the putput is incomplete. - message += System.lineSeparator() + - "This exit code typically indicates a segfault. In this case, the execution output is likely missing or incomplete."; - } - throw new TestError(message, Result.TEST_FAIL); - } - } - } catch (TestError e) { - throw e; - } catch (Throwable e) { - e.printStackTrace(); - throw new TestError("Exception during test execution.", Result.TEST_EXCEPTION, e); + if (p.exitValue() != 0) { + String message = "Exit code: " + p.exitValue(); + if (p.exitValue() == 139) { + // The java ProcessBuilder and Process interface does not allow us to reliably retrieve + // stderr and stdout + // from a process that segfaults. We can only print a message indicating that the putput + // is incomplete. + message += + System.lineSeparator() + + "This exit code typically indicates a segfault. In this case, the execution" + + " output is likely missing or incomplete."; + } + throw new TestError(message, Result.TEST_FAIL); } + } + } catch (TestError e) { + throw e; + } catch (Throwable e) { + e.printStackTrace(); + throw new TestError("Exception during test execution.", Result.TEST_EXCEPTION, e); } - - static public String stackTraceToString(Throwable t) { - StringWriter sw = new StringWriter(); - PrintWriter pw = new PrintWriter(sw); - t.printStackTrace(pw); - pw.flush(); - pw.close(); - return sw.toString(); - } - - /** Bash script that is used to execute docker tests. */ - static private String DOCKER_RUN_SCRIPT = """ + } + + public static String stackTraceToString(Throwable t) { + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw); + t.printStackTrace(pw); + pw.flush(); + pw.close(); + return sw.toString(); + } + + /** Bash script that is used to execute docker tests. */ + private static String DOCKER_RUN_SCRIPT = + """ #!/bin/bash # exit when any command fails set -e - + docker compose -f "$1" rm -f docker compose -f "$1" up --build | tee docker_log.txt docker compose -f "$1" down --rmi local @@ -583,129 +593,128 @@ static public String stackTraceToString(Throwable t) { exit 0 """; - /** - * Path to a bash script containing DOCKER_RUN_SCRIPT. - */ - private static Path dockerRunScript = null; - - /** - * Return the path to a bash script containing DOCKER_RUN_SCRIPT. - * - * If the script does not yet exist, it is created. - */ - private Path getDockerRunScript() throws TestError { - if (dockerRunScript != null) { - return dockerRunScript; - } - - try { - var file = File.createTempFile("run_docker_test", "sh"); - file.deleteOnExit(); - file.setExecutable(true); - var path = file.toPath(); - try (BufferedWriter writer = Files.newBufferedWriter(path)) { - writer.write(DOCKER_RUN_SCRIPT); - } - dockerRunScript = path; - } catch (IOException e) { - throw new TestError("IO Error during test preparation.", Result.TEST_EXCEPTION, e); - } - - return dockerRunScript; + /** Path to a bash script containing DOCKER_RUN_SCRIPT. */ + private static Path dockerRunScript = null; + + /** + * Return the path to a bash script containing DOCKER_RUN_SCRIPT. + * + *

    If the script does not yet exist, it is created. + */ + private Path getDockerRunScript() throws TestError { + if (dockerRunScript != null) { + return dockerRunScript; } - /** - * Throws TestError if docker does not exist. Does nothing otherwise. - */ - private void checkDockerExists() throws TestError { - if (LFCommand.get("docker", List.of()) == null) { - throw new TestError("Executable 'docker' not found" , Result.NO_EXEC_FAIL); - } - if (LFCommand.get("docker-compose", List.of()) == null) { - throw new TestError("Executable 'docker-compose' not found" , Result.NO_EXEC_FAIL); - } + try { + var file = File.createTempFile("run_docker_test", "sh"); + file.deleteOnExit(); + file.setExecutable(true); + var path = file.toPath(); + try (BufferedWriter writer = Files.newBufferedWriter(path)) { + writer.write(DOCKER_RUN_SCRIPT); + } + dockerRunScript = path; + } catch (IOException e) { + throw new TestError("IO Error during test preparation.", Result.TEST_EXCEPTION, e); } - /** - * Return a ProcessBuilder used to test the docker execution. - * @param test The test to get the execution command for. - */ - private ProcessBuilder getDockerExecCommand(LFTest test) throws TestError { - checkDockerExists(); - var srcGenPath = test.getFileConfig().getSrcGenPath(); - var dockerComposeFile = FileUtil.globFilesEndsWith(srcGenPath, "docker-compose.yml").get(0); - return new ProcessBuilder(getDockerRunScript().toString(), dockerComposeFile.toString()); - } + return dockerRunScript; + } - /** - * Return a preconfigured ProcessBuilder for executing the test program. - * @param test The test to get the execution command for. - */ - private ProcessBuilder getExecCommand(LFTest test) throws TestError { - - var srcBasePath = test.getFileConfig().srcPkgPath.resolve("src"); - var relativePathName = srcBasePath.relativize(test.getFileConfig().srcPath).toString(); - - // special case to test docker file generation - if (relativePathName.equalsIgnoreCase(TestCategory.DOCKER.getPath()) || - relativePathName.equalsIgnoreCase(TestCategory.DOCKER_FEDERATED.getPath())) { - return getDockerExecCommand(test); - } else { - LFCommand command = test.getFileConfig().getCommand(); - if (command == null) { - throw new TestError("File: " + test.getFileConfig().getExecutable(), Result.NO_EXEC_FAIL); - } - return new ProcessBuilder(command.command()).directory(command.directory()); - } + /** Throws TestError if docker does not exist. Does nothing otherwise. */ + private void checkDockerExists() throws TestError { + if (LFCommand.get("docker", List.of()) == null) { + throw new TestError("Executable 'docker' not found", Result.NO_EXEC_FAIL); } - - /** - * Validate and run the given tests, using the specified configuratator and level. - * - * While performing tests, this method prints a header that reaches completion - * once all tests have been run. - * - * @param tests A set of tests to run. - * @param configurator A procedure for configuring the tests. - * @param level The level of testing. - * @throws IOException If initial file configuration fails - */ - private void validateAndRun(Set tests, Configurator configurator, TestLevel level) throws IOException { - final var x = 78f / tests.size(); - var marks = 0; - var done = 0; - - for (var test : tests) { - try { - redirectOutputs(test); - configure(test, configurator, level); - validate(test); - if (level.compareTo(TestLevel.CODE_GEN) >= 0) { - generateCode(test); - } - if (level == TestLevel.EXECUTION) { - execute(test); - } - test.markPassed(); - } catch (TestError e) { - test.handleTestError(e); - } catch (Throwable e) { - test.handleTestError(new TestError( - "Unknown exception during test execution", Result.TEST_EXCEPTION, e)); - } finally { - restoreOutputs(); - } - done++; - while (Math.floor(done * x) >= marks && marks < 78) { - System.out.print("="); - marks++; - } + if (LFCommand.get("docker-compose", List.of()) == null) { + throw new TestError("Executable 'docker-compose' not found", Result.NO_EXEC_FAIL); + } + } + + /** + * Return a ProcessBuilder used to test the docker execution. + * + * @param test The test to get the execution command for. + */ + private ProcessBuilder getDockerExecCommand(LFTest test) throws TestError { + checkDockerExists(); + var srcGenPath = test.getFileConfig().getSrcGenPath(); + var dockerComposeFile = FileUtil.globFilesEndsWith(srcGenPath, "docker-compose.yml").get(0); + return new ProcessBuilder(getDockerRunScript().toString(), dockerComposeFile.toString()); + } + + /** + * Return a preconfigured ProcessBuilder for executing the test program. + * + * @param test The test to get the execution command for. + */ + private ProcessBuilder getExecCommand(LFTest test) throws TestError { + + var srcBasePath = test.getFileConfig().srcPkgPath.resolve("src"); + var relativePathName = srcBasePath.relativize(test.getFileConfig().srcPath).toString(); + + // special case to test docker file generation + if (relativePathName.equalsIgnoreCase(TestCategory.DOCKER.getPath()) + || relativePathName.equalsIgnoreCase(TestCategory.DOCKER_FEDERATED.getPath())) { + return getDockerExecCommand(test); + } else { + LFCommand command = test.getFileConfig().getCommand(); + if (command == null) { + throw new TestError("File: " + test.getFileConfig().getExecutable(), Result.NO_EXEC_FAIL); + } + return new ProcessBuilder(command.command()).directory(command.directory()); + } + } + + /** + * Validate and run the given tests, using the specified configuratator and level. + * + *

    While performing tests, this method prints a header that reaches completion once all tests + * have been run. + * + * @param tests A set of tests to run. + * @param configurator A procedure for configuring the tests. + * @param level The level of testing. + * @throws IOException If initial file configuration fails + */ + private void validateAndRun(Set tests, Configurator configurator, TestLevel level) + throws IOException { + final var x = 78f / tests.size(); + var marks = 0; + var done = 0; + + for (var test : tests) { + try { + redirectOutputs(test); + configure(test, configurator, level); + validate(test); + if (level.compareTo(TestLevel.CODE_GEN) >= 0) { + generateCode(test); } - while (marks < 78) { - System.out.print("="); - marks++; + if (level == TestLevel.EXECUTION) { + execute(test); } - - System.out.print(System.lineSeparator()); + test.markPassed(); + } catch (TestError e) { + test.handleTestError(e); + } catch (Throwable e) { + test.handleTestError( + new TestError("Unknown exception during test execution", Result.TEST_EXCEPTION, e)); + } finally { + restoreOutputs(); + } + done++; + while (Math.floor(done * x) >= marks && marks < 78) { + System.out.print("="); + marks++; + } } + while (marks < 78) { + System.out.print("="); + marks++; + } + + System.out.print(System.lineSeparator()); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/TestError.java b/org.lflang.tests/src/org/lflang/tests/TestError.java index 0c261c6865..efb7d50048 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestError.java +++ b/org.lflang.tests/src/org/lflang/tests/TestError.java @@ -5,24 +5,28 @@ /// Indicates an error during test execution public class TestError extends Exception { - private Throwable exception; - private Result result; - - public TestError(String errorMessage, Result result, Throwable exception) { - super(errorMessage); - this.exception = exception; - this.result = result; - } - - public TestError(String errorMessage, Result result) { - this(errorMessage, result, null); - } - - public TestError(Result result) { - this(null, result, null); - } - - public Result getResult() {return result;} - - public Throwable getException() {return exception;} + private Throwable exception; + private Result result; + + public TestError(String errorMessage, Result result, Throwable exception) { + super(errorMessage); + this.exception = exception; + this.result = result; + } + + public TestError(String errorMessage, Result result) { + this(errorMessage, result, null); + } + + public TestError(Result result) { + this(null, result, null); + } + + public Result getResult() { + return result; + } + + public Throwable getException() { + return exception; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/TestRegistry.java b/org.lflang.tests/src/org/lflang/tests/TestRegistry.java index 1249ea25be..2c59740e0a 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestRegistry.java +++ b/org.lflang.tests/src/org/lflang/tests/TestRegistry.java @@ -18,12 +18,10 @@ import java.util.Set; import java.util.Stack; import java.util.TreeSet; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.resource.ResourceSet; import org.eclipse.xtext.xbase.lib.IteratorExtensions; - import org.lflang.LFResourceProvider; import org.lflang.LFStandaloneSetup; import org.lflang.Target; @@ -37,378 +35,349 @@ */ public class TestRegistry { - static class TestMap { - /** - * Registry that maps targets to maps from categories to sets of tests. - */ - protected final Map>> map = new HashMap<>(); - - /** - * Create a new test map. - */ - public TestMap() { - // Populate the internal datastructures. - for (Target target : Target.values()) { - Map> categories = new HashMap<>(); - for (TestCategory cat : TestCategory.values()) { - categories.put(cat, new TreeSet<>()); - } - map.put(target, categories); - } - } - - /** - * Return a set of tests given a target and test category. - * @param t The target. - * @param c The test category. - * @return A set of tests for the given target and test category. - */ - public Set getTests(Target t, TestCategory c) { - return this.map.get(t).get(c); + static class TestMap { + /** Registry that maps targets to maps from categories to sets of tests. */ + protected final Map>> map = new HashMap<>(); + + /** Create a new test map. */ + public TestMap() { + // Populate the internal datastructures. + for (Target target : Target.values()) { + Map> categories = new HashMap<>(); + for (TestCategory cat : TestCategory.values()) { + categories.put(cat, new TreeSet<>()); } + map.put(target, categories); + } } /** - * List of directories that should be skipped when indexing test files. Any - * test file that has a directory in its path that matches an entry in this - * array will not be discovered. - */ - public static final String[] IGNORED_DIRECTORIES = {"failing", "knownfailed", "failed", "fed-gen"}; - - /** - * Path to the root of the repository. - */ - public static final Path LF_REPO_PATH = Paths.get("").toAbsolutePath(); - - /** - * Path to the test directory in the repository. + * Return a set of tests given a target and test category. + * + * @param t The target. + * @param c The test category. + * @return A set of tests for the given target and test category. */ - public static final Path LF_TEST_PATH = LF_REPO_PATH.resolve("test"); + public Set getTests(Target t, TestCategory c) { + return this.map.get(t).get(c); + } + } + + /** + * List of directories that should be skipped when indexing test files. Any test file that has a + * directory in its path that matches an entry in this array will not be discovered. + */ + public static final String[] IGNORED_DIRECTORIES = { + "failing", "knownfailed", "failed", "fed-gen" + }; + + /** Path to the root of the repository. */ + public static final Path LF_REPO_PATH = Paths.get("").toAbsolutePath(); + + /** Path to the test directory in the repository. */ + public static final Path LF_TEST_PATH = LF_REPO_PATH.resolve("test"); + + /** Internal data structure that stores registered tests. */ + protected static final TestMap registered = new TestMap(); + + /** + * Internal data structure that stores ignored tests. For instance, source files with no main + * reactor are indexed here. + */ + protected static final TestMap ignored = new TestMap(); + + /** + * A map from each test category to a set of tests that is the union of all registered tests in + * that category across all targets. + */ + protected static final Map> allTargets = new HashMap<>(); + + /** + * Enumeration of test categories, used to map tests to categories. The nearest containing + * directory that matches any of the categories will determine the category that the test is + * mapped to. Matching is case insensitive. + * + *

    For example, the following files will all map to THREADED: + * + *

      + *
    • C/threaded/Foo.lf + *
    • C/THREADED/Foo.lf + *
    • C/Threaded/Foo.lf + *
    • C/foo/threaded/Bar.lf + *
    • C/foo/bar/threaded/Threaded.lf + *
    • C/federated/threaded/bar.lf but the following will not: + *
    • C/Foo.lf (maps to COMMON) + *
    • C/Threaded.lf (maps to COMMON) + *
    • C/threaded/federated/foo.lf (maps to FEDERATED) + *
    + * + * @author Marten Lohstroh + */ + public enum TestCategory { + /** Tests about concurrent execution. */ + CONCURRENT(true), + /** Test about enclaves */ + ENCLAVE(false), + /** Generic tests, ie, tests that all targets are supposed to implement. */ + GENERIC(true), + /** Tests about generics, not to confuse with {@link #GENERIC}. */ + GENERICS(true), + /** Tests about multiports and banks of reactors. */ + MULTIPORT(true), + /** Tests about federated execution. */ + FEDERATED(true), + /** Tests about specific target properties. */ + PROPERTIES(true), + /** Tests concerning modal reactors */ + MODAL_MODELS(true), + NO_INLINING(false), + // non-shared tests + DOCKER(true), + DOCKER_FEDERATED(true, "docker" + File.separator + "federated"), + SERIALIZATION(false), + ARDUINO(false, TestLevel.BUILD), + ZEPHYR(false, TestLevel.BUILD), + TARGET(false); + + /** Whether we should compare coverage against other targets. */ + public final boolean isCommon; + + public final String path; + public final TestLevel level; + + /** Create a new test category. */ + TestCategory(boolean isCommon) { + this.isCommon = isCommon; + this.path = this.name().toLowerCase(); + this.level = TestLevel.EXECUTION; + } - /** - * Internal data structure that stores registered tests. - */ - protected static final TestMap registered = new TestMap(); + /** Create a new test category. */ + TestCategory(boolean isCommon, TestLevel level) { + this.isCommon = isCommon; + this.path = this.name().toLowerCase(); + this.level = level; + } - /** - * Internal data structure that stores ignored tests. For instance, - * source files with no main reactor are indexed here. - */ - protected static final TestMap ignored = new TestMap(); + /** Create a new test category. */ + TestCategory(boolean isCommon, String path) { + this.isCommon = isCommon; + this.path = path; + this.level = TestLevel.EXECUTION; + } - /** - * A map from each test category to a set of tests that is the union of - * all registered tests in that category across all targets. - */ - protected static final Map> allTargets = new HashMap<>(); + public String getPath() { + return path; + } /** - * Enumeration of test categories, used to map tests to categories. The - * nearest containing directory that matches any of the categories will - * determine the category that the test is mapped to. Matching is case - * insensitive. - * - * For example, the following files will all map to THREADED: - *
      - *
    • C/threaded/Foo.lf
      • - *
    • C/THREADED/Foo.lf
      • - *
    • C/Threaded/Foo.lf
      • - *
    • C/foo/threaded/Bar.lf
      • - *
    • C/foo/bar/threaded/Threaded.lf
      • - *
    • C/federated/threaded/bar.lf - * but the following will not:
      • - *
    • C/Foo.lf (maps to COMMON)
      • - *
    • C/Threaded.lf (maps to COMMON)
      • - *
    • C/threaded/federated/foo.lf (maps to FEDERATED)
      • - *
    + * Return a header associated with the category. * - * @author Marten Lohstroh + * @return A header to print in the test report. */ - public enum TestCategory { - /** Tests about concurrent execution. */ - CONCURRENT(true), - /** Test about enclaves */ - ENCLAVE(false), - /** Generic tests, ie, tests that all targets are supposed to implement. */ - GENERIC(true), - /** Tests about generics, not to confuse with {@link #GENERIC}. */ - GENERICS(true), - /** Tests about multiports and banks of reactors. */ - MULTIPORT(true), - /** Tests about federated execution. */ - FEDERATED(true), - /** Tests about specific target properties. */ - PROPERTIES(true), - /** Tests concerning modal reactors */ - MODAL_MODELS(true), - NO_INLINING(false), - // non-shared tests - DOCKER(true), - DOCKER_FEDERATED(true, "docker" + File.separator + "federated"), - SERIALIZATION(false), - ARDUINO(false, TestLevel.BUILD), - ZEPHYR(false, TestLevel.BUILD), - TARGET(false); - - /** - * Whether we should compare coverage against other targets. - */ - public final boolean isCommon; - public final String path; - public final TestLevel level ; - - /** - * Create a new test category. - */ - TestCategory(boolean isCommon) { - this.isCommon = isCommon; - this.path = this.name().toLowerCase(); - this.level = TestLevel.EXECUTION; - } - - /** - * Create a new test category. - */ - TestCategory(boolean isCommon, TestLevel level) { - this.isCommon = isCommon; - this.path = this.name().toLowerCase(); - this.level = level; - } - - /** - * Create a new test category. - */ - TestCategory(boolean isCommon, String path) { - this.isCommon = isCommon; - this.path = path; - this.level = TestLevel.EXECUTION; - } - - public String getPath() { - return path; - } - - /** - * Return a header associated with the category. - * - * @return A header to print in the test report. - */ - public String getHeader() { - return TestBase.THICK_LINE + "Category: " + this.name(); - } + public String getHeader() { + return TestBase.THICK_LINE + "Category: " + this.name(); } - - // Static code that performs the file system traversal and discovers - // all .lf files to be included in the registry. - static { - System.out.println("Indexing..."); - ResourceSet rs = new LFStandaloneSetup() + } + + // Static code that performs the file system traversal and discovers + // all .lf files to be included in the registry. + static { + System.out.println("Indexing..."); + ResourceSet rs = + new LFStandaloneSetup() .createInjectorAndDoEMFRegistration() - .getInstance(LFResourceProvider.class).getResourceSet(); + .getInstance(LFResourceProvider.class) + .getResourceSet(); - // Prepare for the collection of tests per category. - for (TestCategory t: TestCategory.values()) { - allTargets.put(t, new TreeSet<>()); - } - // Populate the registry. - for (Target target : Target.values()) { - - // Walk the tree. - try { - Path dir = LF_TEST_PATH.resolve(target.getDirectoryName()).resolve("src"); - if (Files.exists(dir)) { - new TestDirVisitor(rs, target, dir).walk(); - } else { - System.out.println("WARNING: No test directory for target " + target + "\n"); - } - - } catch (IOException e) { - System.err.println( - "ERROR: Caught exception while indexing tests for target " + target); - e.printStackTrace(); - } - // Record the tests for later use when reporting coverage. - Arrays.asList(TestCategory.values()).forEach( - c -> allTargets.get(c).addAll(getRegisteredTests(target, c, false))); + // Prepare for the collection of tests per category. + for (TestCategory t : TestCategory.values()) { + allTargets.put(t, new TreeSet<>()); + } + // Populate the registry. + for (Target target : Target.values()) { + + // Walk the tree. + try { + Path dir = LF_TEST_PATH.resolve(target.getDirectoryName()).resolve("src"); + if (Files.exists(dir)) { + new TestDirVisitor(rs, target, dir).walk(); + } else { + System.out.println("WARNING: No test directory for target " + target + "\n"); } + + } catch (IOException e) { + System.err.println("ERROR: Caught exception while indexing tests for target " + target); + e.printStackTrace(); + } + // Record the tests for later use when reporting coverage. + Arrays.asList(TestCategory.values()) + .forEach(c -> allTargets.get(c).addAll(getRegisteredTests(target, c, false))); + } + } + + /** + * Calling this function forces the lazy initialization of the static code that indexes all files. + * It is advisable to do this prior to executing other code that prints to standard out so that + * any error messages printed while indexing are printed first. + */ + public static void initialize() {} + + /** + * Return the tests that were indexed for a given target and category. + * + * @param target The target to get indexed tests for. + * @param category The category of tests to include in the returned tests. + * @param copy Whether to return copies of the indexed tests instead of the indexed tests + * themselves. + * @return A set of tests for the given target/category. + */ + public static Set getRegisteredTests(Target target, TestCategory category, boolean copy) { + if (copy) { + Set copies = new TreeSet<>(); + for (LFTest test : registered.getTests(target, category)) { + copies.add(new LFTest(test)); + } + return copies; + } else { + return registered.getTests(target, category); + } + } + + /** Return the test that were found but not indexed because they did not have a main reactor. */ + public static Set getIgnoredTests(Target target, TestCategory category) { + return ignored.getTests(target, category); + } + + public static String getCoverageReport(Target target, TestCategory category) { + StringBuilder s = new StringBuilder(); + Set ignored = TestRegistry.getIgnoredTests(target, category); + s.append(TestBase.THIN_LINE); + s.append("Ignored: ").append(ignored.size()).append("\n"); + s.append(TestBase.THIN_LINE); + + for (LFTest test : ignored) { + s.append("No main reactor in: ").append(test).append("\n"); } - /** - * Calling this function forces the lazy initialization of the static code - * that indexes all files. It is advisable to do this prior to executing - * other code that prints to standard out so that any error messages - * printed while indexing are printed first. - */ - public static void initialize() {} + Set own = getRegisteredTests(target, category, false); + if (category.isCommon) { + Set all = allTargets.get(category); + s.append("\n").append(TestBase.THIN_LINE); + s.append("Covered: ").append(own.size()).append("/").append(all.size()).append("\n"); + s.append(TestBase.THIN_LINE); + int missing = all.size() - own.size(); + if (missing > 0) { + all.stream() + .filter(test -> !own.contains(test)) + .forEach(test -> s.append("Missing: ").append(test).append("\n")); + } + } else { + s.append("\n").append(TestBase.THIN_LINE); + s.append("Covered: ").append(own.size()).append("/").append(own.size()).append("\n"); + s.append(TestBase.THIN_LINE); + } + return s.toString(); + } + + /** + * FileVisitor implementation that maintains a stack to map found tests to the appropriate + * category and excludes directories that are listed as "ignored" from walks. + * + *

    Specifically, when a directory is encountered that matches a category, this category is + * pushed onto the stack. Similarly, when the DFS leaves such a directory, its corresponding + * category is popped from the stack. Any test (*.lf) file that is encountered will be mapped to + * the category that is on top of the stack. Initially, the stack has one element that is + * TestCategory.COMMON, meaning that test files in the top-level test directory for a given target + * will be mapped to that category. + * + * @author Marten Lohstroh + */ + public static class TestDirVisitor extends SimpleFileVisitor { + + /** The stack of which the top element indicates the "current" category. */ + protected Stack stack = new Stack<>(); + + /** The target that all encountered tests belong to. */ + protected Target target; + + protected ResourceSet rs; + + protected Path srcBasePath; /** - * Return the tests that were indexed for a given target and category. + * Create a new file visitor based on a given target. * - * @param target The target to get indexed tests for. - * @param category The category of tests to include in the returned tests. - * @param copy Whether to return copies of the indexed tests instead of the indexed tests themselves. - * @return A set of tests for the given target/category. + * @param target The target that all encountered tests belong to. + * @param srcBasePath The test sources directory */ - public static Set getRegisteredTests(Target target, - TestCategory category, boolean copy) { - if (copy) { - Set copies = new TreeSet<>(); - for (LFTest test : registered.getTests(target, category)) { - copies.add(new LFTest(test)); - } - return copies; - } else { - return registered.getTests(target, category); - } + public TestDirVisitor(ResourceSet rs, Target target, Path srcBasePath) { + stack.push(TestCategory.GENERIC); + this.rs = rs; + this.target = target; + this.srcBasePath = srcBasePath; } /** - * Return the test that were found but not indexed because they did not - * have a main reactor. + * Push categories onto the stack as appropriate and skip directories that should be ignored. */ - public static Set getIgnoredTests(Target target, TestCategory category) { - return ignored.getTests(target, category); - } - - public static String getCoverageReport(Target target, TestCategory category) { - StringBuilder s = new StringBuilder(); - Set ignored = TestRegistry.getIgnoredTests(target, category); - s.append(TestBase.THIN_LINE); - s.append("Ignored: ").append(ignored.size()).append("\n"); - s.append(TestBase.THIN_LINE); - - for (LFTest test : ignored) { - s.append("No main reactor in: ").append(test).append("\n"); + @Override + public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) { + for (String ignored : IGNORED_DIRECTORIES) { + if (dir.getFileName().toString().equalsIgnoreCase(ignored)) { + return SKIP_SUBTREE; } + } + for (TestCategory category : TestCategory.values()) { + var relativePathName = srcBasePath.relativize(dir).toString(); + if (relativePathName.equalsIgnoreCase(category.getPath())) { + stack.push(category); + } + } + return CONTINUE; + } - Set own = getRegisteredTests(target, category, false); - if (category.isCommon) { - Set all = allTargets.get(category); - s.append("\n").append(TestBase.THIN_LINE); - s.append("Covered: ").append(own.size()).append("/").append(all.size()).append("\n"); - s.append(TestBase.THIN_LINE); - int missing = all.size() - own.size(); - if (missing > 0) { - all.stream().filter(test -> !own.contains(test)) - .forEach(test -> s.append("Missing: ").append(test).append("\n")); - } - } else { - s.append("\n").append(TestBase.THIN_LINE); - s.append("Covered: ").append(own.size()).append("/").append(own.size()).append("\n"); - s.append(TestBase.THIN_LINE); + /** Pop categories from the stack as appropriate. */ + @Override + public FileVisitResult postVisitDirectory(Path dir, IOException exc) { + for (TestCategory category : TestCategory.values()) { + var relativePathName = srcBasePath.relativize(dir).toString(); + if (relativePathName.equalsIgnoreCase(category.getPath())) { + this.stack.pop(); } - return s.toString(); + } + return CONTINUE; } /** - * FileVisitor implementation that maintains a stack to map found tests to - * the appropriate category and excludes directories that are listed as - * "ignored" from walks. - * - * Specifically, when a directory is encountered that matches a category, - * this category is pushed onto the stack. Similarly, when the DFS leaves - * such a directory, its corresponding category is popped from the stack. - * Any test (*.lf) file that is encountered will be mapped to the category - * that is on top of the stack. Initially, the stack has one element that - * is TestCategory.COMMON, meaning that test files in the top-level test - * directory for a given target will be mapped to that category. - * - * @author Marten Lohstroh + * Add test files to the registry if they end with ".lf", but only if they have a main reactor. */ - public static class TestDirVisitor extends SimpleFileVisitor { - - /** - * The stack of which the top element indicates the "current" category. - */ - protected Stack stack = new Stack<>(); - - /** - * The target that all encountered tests belong to. - */ - protected Target target; - - protected ResourceSet rs; - - protected Path srcBasePath; - - /** - * Create a new file visitor based on a given target. - * - * @param target The target that all encountered tests belong to. - * @param srcBasePath The test sources directory - */ - public TestDirVisitor(ResourceSet rs, Target target, Path srcBasePath) { - stack.push(TestCategory.GENERIC); - this.rs = rs; - this.target = target; - this.srcBasePath = srcBasePath; + @Override + public FileVisitResult visitFile(Path path, BasicFileAttributes attr) { + if (attr.isRegularFile() && path.toString().endsWith(".lf")) { + // Try to parse the file. + Resource r = rs.getResource(URI.createFileURI(path.toFile().getAbsolutePath()), true); + // FIXME: issue warning if target doesn't match! + LFTest test = new LFTest(target, path); + + Iterator reactors = IteratorExtensions.filter(r.getAllContents(), Reactor.class); + + if (r.getErrors().isEmpty() + && !IteratorExtensions.exists(reactors, it -> it.isMain() || it.isFederated())) { + // If the test compiles but doesn't have a main reactor, + // _do not add the file_. We assume it is a library + // file. + ignored.getTests(this.target, this.stack.peek()).add(test); + return CONTINUE; } - /** - * Push categories onto the stack as appropriate and skip directories - * that should be ignored. - */ - @Override - public FileVisitResult preVisitDirectory(Path dir, - BasicFileAttributes attrs) { - for (String ignored : IGNORED_DIRECTORIES) { - if (dir.getFileName().toString().equalsIgnoreCase(ignored)) { - return SKIP_SUBTREE; - } - } - for (TestCategory category : TestCategory.values()) { - var relativePathName = srcBasePath.relativize(dir).toString(); - if (relativePathName.equalsIgnoreCase(category.getPath())) { - stack.push(category); - } - } - return CONTINUE; - } - - /** - * Pop categories from the stack as appropriate. - */ - @Override - public FileVisitResult postVisitDirectory(Path dir, IOException exc) { - for (TestCategory category : TestCategory.values()) { - var relativePathName = srcBasePath.relativize(dir).toString(); - if (relativePathName.equalsIgnoreCase(category.getPath())) { - this.stack.pop(); - } - } - return CONTINUE; - } - - /** - * Add test files to the registry if they end with ".lf", but only if they have a main reactor. - */ - @Override - public FileVisitResult visitFile(Path path, BasicFileAttributes attr) { - if (attr.isRegularFile() && path.toString().endsWith(".lf")) { - // Try to parse the file. - Resource r = rs.getResource(URI.createFileURI(path.toFile().getAbsolutePath()),true); - // FIXME: issue warning if target doesn't match! - LFTest test = new LFTest(target, path); - - Iterator reactors = IteratorExtensions.filter(r.getAllContents(), Reactor.class); - - if (r.getErrors().isEmpty() && !IteratorExtensions.exists(reactors, - it -> it.isMain() || it.isFederated())) { - // If the test compiles but doesn't have a main reactor, - // _do not add the file_. We assume it is a library - // file. - ignored.getTests(this.target, this.stack.peek()).add(test); - return CONTINUE; - } - - registered.getTests(this.target, this.stack.peek()).add(test); - } - return CONTINUE; - } + registered.getTests(this.target, this.stack.peek()).add(test); + } + return CONTINUE; + } - public void walk() throws IOException { - Files.walkFileTree(srcBasePath, this); - } + public void walk() throws IOException { + Files.walkFileTree(srcBasePath, this); } + } } diff --git a/org.lflang.tests/src/org/lflang/tests/TestUtils.java b/org.lflang.tests/src/org/lflang/tests/TestUtils.java index c868acb771..9e7cb4218a 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestUtils.java +++ b/org.lflang.tests/src/org/lflang/tests/TestUtils.java @@ -31,7 +31,6 @@ import java.nio.file.Path; import java.nio.file.Paths; import java.util.function.Predicate; - import org.hamcrest.BaseMatcher; import org.hamcrest.Description; import org.hamcrest.Matcher; @@ -41,139 +40,136 @@ */ public class TestUtils { - private static Matcher pathMatcher(String description, Predicate predicate) { - return new BaseMatcher<>() { - @Override - public boolean matches(Object item) { - return item instanceof Path && predicate.test((Path) item); - } - - @Override - public void describeTo(Description describer) { - describer.appendText(description); - } - }; + private static Matcher pathMatcher(String description, Predicate predicate) { + return new BaseMatcher<>() { + @Override + public boolean matches(Object item) { + return item instanceof Path && predicate.test((Path) item); + } + + @Override + public void describeTo(Description describer) { + describer.appendText(description); + } + }; + } + + public static Matcher isDirectory() { + return pathMatcher("is a directory", Files::isDirectory); + } + + public static Matcher isRegularFile() { + return pathMatcher("is a regular file", Files::isRegularFile); + } + + public static Matcher exists() { + return pathMatcher("exists", Files::exists); + } + + /** Builder for a directory. Useful to create a fake LF project. */ + public static class TempDirBuilder { + + private final Path curDir; + + private TempDirBuilder(Path path) { + this.curDir = path; + if (!Files.isDirectory(path)) { + throw new IllegalArgumentException("Not a directory: " + path); + } } - public static Matcher isDirectory() { - return pathMatcher("is a directory", Files::isDirectory); + public static TempDirBuilder dirBuilder(Path path) { + return new TempDirBuilder(path); } - public static Matcher isRegularFile() { - return pathMatcher("is a regular file", Files::isRegularFile); + /** Create a directory at the given path. Return a new temp dir builder for that subdir. */ + public TempDirBuilder cd(String relativePath) throws IOException { + Path relPath = Paths.get(relativePath); + if (relPath.isAbsolute()) { + throw new IllegalArgumentException("Should be a relative path: " + relativePath); + } + Path dir = curDir.resolve(relPath); + Files.createDirectories(dir); + return new TempDirBuilder(dir); } - public static Matcher exists() { - return pathMatcher("exists", Files::exists); + /** Create a directory at the given path. Return this instance. */ + public TempDirBuilder mkdirs(String relativePath) throws IOException { + Path relPath = Paths.get(relativePath); + if (relPath.isAbsolute()) { + throw new IllegalArgumentException("Should be a relative path: " + relativePath); + } + Path dir = curDir.resolve(relPath); + Files.createDirectories(dir); + return this; } - /** - * Builder for a directory. Useful to create a fake LF project. - */ - public static class TempDirBuilder { - - private final Path curDir; - - private TempDirBuilder(Path path) { - this.curDir = path; - if (!Files.isDirectory(path)) { - throw new IllegalArgumentException("Not a directory: " + path); - } - } - - public static TempDirBuilder dirBuilder(Path path) { - return new TempDirBuilder(path); - } - - /** Create a directory at the given path. Return a new temp dir builder for that subdir. */ - public TempDirBuilder cd(String relativePath) throws IOException { - Path relPath = Paths.get(relativePath); - if (relPath.isAbsolute()) { - throw new IllegalArgumentException("Should be a relative path: " + relativePath); - } - Path dir = curDir.resolve(relPath); - Files.createDirectories(dir); - return new TempDirBuilder(dir); - } - - /** Create a directory at the given path. Return this instance. */ - public TempDirBuilder mkdirs(String relativePath) throws IOException { - Path relPath = Paths.get(relativePath); - if (relPath.isAbsolute()) { - throw new IllegalArgumentException("Should be a relative path: " + relativePath); - } - Path dir = curDir.resolve(relPath); - Files.createDirectories(dir); - return this; - } - - /** Create a file in the given subpath. Return this instance. */ - public TempDirBuilder file(String relativePath, String contents) throws IOException { - Path relPath = Paths.get(relativePath); - if (relPath.isAbsolute()) { - throw new IllegalArgumentException("Should be a relative path: " + relativePath); - } - Path filePath = curDir.resolve(relPath); - Files.createDirectories(filePath.getParent()); - Files.writeString(filePath, contents); - return this; - } + /** Create a file in the given subpath. Return this instance. */ + public TempDirBuilder file(String relativePath, String contents) throws IOException { + Path relPath = Paths.get(relativePath); + if (relPath.isAbsolute()) { + throw new IllegalArgumentException("Should be a relative path: " + relativePath); + } + Path filePath = curDir.resolve(relPath); + Files.createDirectories(filePath.getParent()); + Files.writeString(filePath, contents); + return this; + } + } + + /** Builder for a directory. Useful to create a fake LF project. */ + public static class TempDirChecker { + + private final Path curDir; + + private TempDirChecker(Path path) { + this.curDir = path; + if (!Files.isDirectory(path)) { + throw new IllegalArgumentException("Not a directory: " + path); + } + } + + public static TempDirChecker dirChecker(Path path) { + return new TempDirChecker(path); + } + + /** Create a directory at the given path. Return a new temp dir builder for that subdir. */ + public TempDirBuilder cd(String relativePath) throws IOException { + Path relPath = Paths.get(relativePath); + if (relPath.isAbsolute()) { + throw new IllegalArgumentException("Should be a relative path: " + relativePath); + } + Path dir = curDir.resolve(relPath); + Files.createDirectories(dir); + return new TempDirBuilder(dir); } /** - * Builder for a directory. Useful to create a fake LF project. + * Check the contents of the file match the matcher. The file should be a UTF-8 encoded text + * file. Return this instance. */ - public static class TempDirChecker { - - private final Path curDir; - - private TempDirChecker(Path path) { - this.curDir = path; - if (!Files.isDirectory(path)) { - throw new IllegalArgumentException("Not a directory: " + path); - } - } - - public static TempDirChecker dirChecker(Path path) { - return new TempDirChecker(path); - } - - /** Create a directory at the given path. Return a new temp dir builder for that subdir. */ - public TempDirBuilder cd(String relativePath) throws IOException { - Path relPath = Paths.get(relativePath); - if (relPath.isAbsolute()) { - throw new IllegalArgumentException("Should be a relative path: " + relativePath); - } - Path dir = curDir.resolve(relPath); - Files.createDirectories(dir); - return new TempDirBuilder(dir); - } - - /** - * Check the contents of the file match the matcher. - * The file should be a UTF-8 encoded text file. Return - * this instance. - */ - public TempDirChecker checkContentsOf(String relativePath, Matcher contentsMatcher) throws IOException { - Path relPath = Paths.get(relativePath); - if (relPath.isAbsolute()) { - throw new IllegalArgumentException("Should be a relative path: " + relativePath); - } - Path filePath = curDir.resolve(relPath); - - assertThat(Files.readString(filePath), contentsMatcher); - return this; - } - - public TempDirChecker check(String relativePath, Matcher pathMatcher) throws IOException { - Path relPath = Paths.get(relativePath); - if (relPath.isAbsolute()) { - throw new IllegalArgumentException("Should be a relative path: " + relativePath); - } - Path filePath = curDir.resolve(relPath); - - assertThat(filePath, pathMatcher); - return this; - } + public TempDirChecker checkContentsOf( + String relativePath, Matcher contentsMatcher) throws IOException { + Path relPath = Paths.get(relativePath); + if (relPath.isAbsolute()) { + throw new IllegalArgumentException("Should be a relative path: " + relativePath); + } + Path filePath = curDir.resolve(relPath); + + assertThat(Files.readString(filePath), contentsMatcher); + return this; + } + + public TempDirChecker check(String relativePath, Matcher pathMatcher) + throws IOException { + Path relPath = Paths.get(relativePath); + if (relPath.isAbsolute()) { + throw new IllegalArgumentException("Should be a relative path: " + relativePath); + } + Path filePath = curDir.resolve(relPath); + + assertThat(filePath, pathMatcher); + return this; } + } } diff --git a/org.lflang.tests/src/org/lflang/tests/cli/CliToolTestFixture.java b/org.lflang.tests/src/org/lflang/tests/cli/CliToolTestFixture.java index 83e7817618..257da7ad06 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/CliToolTestFixture.java +++ b/org.lflang.tests/src/org/lflang/tests/cli/CliToolTestFixture.java @@ -32,130 +32,108 @@ import java.io.ByteArrayOutputStream; import java.io.PrintStream; import java.nio.file.Path; -import java.util.concurrent.Callable; -import java.util.function.Consumer; - import org.hamcrest.Matcher; -import org.opentest4j.AssertionFailedError; - import org.lflang.cli.Io; +import org.opentest4j.AssertionFailedError; /** - * Test utilities for a CLI tool, eg {@link org.lflang.cli.Lfc}, - * {@link org.lflang.cli.Lff}. + * Test utilities for a CLI tool, eg {@link org.lflang.cli.Lfc}, {@link org.lflang.cli.Lff}. * * @author Clément Fournier */ abstract class CliToolTestFixture { - /** - * Override to call the relevant main. - */ - protected abstract void runCliProgram(Io io, String[] args); - - - /** - * Run the tool with the given arguments, in the system - * working directory. - * - * @param args Arguments - * @return The execution result - */ - public ExecutionResult run(String... args) { - return run(Io.SYSTEM.getWd(), args); + /** Override to call the relevant main. */ + protected abstract void runCliProgram(Io io, String[] args); + + /** + * Run the tool with the given arguments, in the system working directory. + * + * @param args Arguments + * @return The execution result + */ + public ExecutionResult run(String... args) { + return run(Io.SYSTEM.getWd(), args); + } + + /** + * Run the tool with the given arguments, in the given working directory. + * + * @param wd working directory + * @param args Arguments + * @return The execution result + */ + public ExecutionResult run(Path wd, String... args) { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ByteArrayOutputStream err = new ByteArrayOutputStream(); + + Io testIo = new Io(new PrintStream(err), new PrintStream(out), wd); + int exitCode = testIo.fakeSystemExit(io -> runCliProgram(io, args)); + + return new ExecutionResult(out, err, exitCode); + } + + /** + * The result of an execution of a CLI program like LFC. + * + * @param out Output stream + * @param err Error stream + * @param exitCode Exit code of the process + */ + record ExecutionResult(ByteArrayOutputStream out, ByteArrayOutputStream err, int exitCode) { + + public String getOut() { + return out.toString(); } - /** - * Run the tool with the given arguments, in the given - * working directory. - * - * @param wd working directory - * @param args Arguments - * @return The execution result - */ - public ExecutionResult run(Path wd, String... args) { - ByteArrayOutputStream out = new ByteArrayOutputStream(); - ByteArrayOutputStream err = new ByteArrayOutputStream(); - - Io testIo = new Io( - new PrintStream(err), - new PrintStream(out), - wd - ); - int exitCode = testIo.fakeSystemExit(io -> runCliProgram(io, args)); - - return new ExecutionResult(out, err, exitCode); + public String getErr() { + return err.toString(); } - /** - * The result of an execution of a CLI program like LFC. - * - * @param out Output stream - * @param err Error stream - * @param exitCode Exit code of the process - */ - record ExecutionResult( - ByteArrayOutputStream out, - ByteArrayOutputStream err, - int exitCode - ) { - - public String getOut() { - return out.toString(); - } - - public String getErr() { - return err.toString(); - } - - - public void checkOk() { - assertEquals(0, exitCode); - } + public void checkOk() { + assertEquals(0, exitCode); + } - public void checkFailed() { - assertTrue(exitCode > 0); - } + public void checkFailed() { + assertTrue(exitCode > 0); + } - public void checkNoErrorOutput() { - checkStdErr(equalTo("")); - } + public void checkNoErrorOutput() { + checkStdErr(equalTo("")); + } - public void checkStdOut(Matcher matcher) { - assertThat(getOut(), matcher); - } + public void checkStdOut(Matcher matcher) { + assertThat(getOut(), matcher); + } - public void checkStdErr(Matcher matcher) { - assertThat(getErr(), matcher); - } + public void checkStdErr(Matcher matcher) { + assertThat(getErr(), matcher); + } - /** - * Use this method to wrap assertions. - */ - public void verify(ThrowingConsumer actions) { - try { - actions.accept(this); - } catch (Exception | AssertionFailedError e) { - System.out.println("TEST FAILED"); - System.out.println("> Return code: " + exitCode); - System.out.println("> Standard output -------------------------"); - System.err.println(out.toString()); - System.out.println("> Standard error --------------------------"); - System.err.println(err.toString()); - System.out.println("> -----------------------------------------"); - - if (e instanceof Exception) { - throw new AssertionFailedError("Expected no exception to be thrown", e); - } - throw (AssertionFailedError) e; - } + /** Use this method to wrap assertions. */ + public void verify(ThrowingConsumer actions) { + try { + actions.accept(this); + } catch (Exception | AssertionFailedError e) { + System.out.println("TEST FAILED"); + System.out.println("> Return code: " + exitCode); + System.out.println("> Standard output -------------------------"); + System.err.println(out.toString()); + System.out.println("> Standard error --------------------------"); + System.err.println(err.toString()); + System.out.println("> -----------------------------------------"); + + if (e instanceof Exception) { + throw new AssertionFailedError("Expected no exception to be thrown", e); } + throw (AssertionFailedError) e; + } + } + @FunctionalInterface + interface ThrowingConsumer { - @FunctionalInterface - interface ThrowingConsumer { - - void accept(T t) throws Exception; - } + void accept(T t) throws Exception; } + } } diff --git a/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java b/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java index d16193faad..d9e81a0e68 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java +++ b/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java @@ -33,15 +33,12 @@ import static org.lflang.tests.TestUtils.isRegularFile; import com.google.inject.Injector; - import java.io.File; import java.io.IOException; import java.nio.file.Path; import java.util.Properties; - import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; - import org.lflang.LocalStrings; import org.lflang.cli.Io; import org.lflang.cli.Lfc; @@ -54,16 +51,18 @@ */ public class LfcCliTest { - LfcTestFixture lfcTester = new LfcTestFixture(); + LfcTestFixture lfcTester = new LfcTestFixture(); - static final String LF_PYTHON_FILE = """ + static final String LF_PYTHON_FILE = + """ target Python main reactor { reaction(startup) {==} } """; - static final String JSON_STRING = """ + static final String JSON_STRING = + """ { "src": "src/File.lf", "out": "src", @@ -87,230 +86,262 @@ public class LfcCliTest { } """; - @Test - public void testHelpArg() { - lfcTester.run("--help", "--version") - .verify(result -> { - result.checkOk(); - result.checkNoErrorOutput(); - result.checkStdOut(containsString("Usage: lfc")); + @Test + public void testHelpArg() { + lfcTester + .run("--help", "--version") + .verify( + result -> { + result.checkOk(); + result.checkNoErrorOutput(); + result.checkStdOut(containsString("Usage: lfc")); }); - } - - @Test - public void testMutuallyExclusiveCliArgs() { - lfcTester.run("File.lf", "--json", JSON_STRING) - .verify(result -> { - result.checkStdErr(containsString( - "are mutually exclusive (specify only one)")); - result.checkFailed(); + } + + @Test + public void testMutuallyExclusiveCliArgs() { + lfcTester + .run("File.lf", "--json", JSON_STRING) + .verify( + result -> { + result.checkStdErr(containsString("are mutually exclusive (specify only one)")); + result.checkFailed(); }); - lfcTester.run("File.lf", "--json-file", "test.json") - .verify(result -> { - result.checkStdErr(containsString( - "are mutually exclusive (specify only one)")); - result.checkFailed(); + lfcTester + .run("File.lf", "--json-file", "test.json") + .verify( + result -> { + result.checkStdErr(containsString("are mutually exclusive (specify only one)")); + result.checkFailed(); }); - lfcTester.run("--json", JSON_STRING, "--json-file", "test.json") - .verify(result -> { - result.checkStdErr(containsString( - "are mutually exclusive (specify only one)")); - result.checkFailed(); + lfcTester + .run("--json", JSON_STRING, "--json-file", "test.json") + .verify( + result -> { + result.checkStdErr(containsString("are mutually exclusive (specify only one)")); + result.checkFailed(); }); - } - - @Test - public void testVersion() { - lfcTester.run("--version") - .verify(result -> { - result.checkOk(); - result.checkNoErrorOutput(); - result.checkStdOut(equalTo( - "lfc " + LocalStrings.VERSION + System.lineSeparator())); + } + + @Test + public void testVersion() { + lfcTester + .run("--version") + .verify( + result -> { + result.checkOk(); + result.checkNoErrorOutput(); + result.checkStdOut(equalTo("lfc " + LocalStrings.VERSION + System.lineSeparator())); }); - } - - - @Test - public void testWrongCliArg() { - lfcTester.run("--notanargument", "File.lf") - .verify(result -> { - result.checkStdErr(containsString("Unknown option: '--notanargument'")); - result.checkFailed(); + } + + @Test + public void testWrongCliArg() { + lfcTester + .run("--notanargument", "File.lf") + .verify( + result -> { + result.checkStdErr(containsString("Unknown option: '--notanargument'")); + result.checkFailed(); }); - } - - @Test - public void testInvalidArgs(@TempDir Path tempDir) throws IOException { - dirBuilder(tempDir).file("src/File.lf", LF_PYTHON_FILE); - LfcOneShotTestFixture fixture = new LfcOneShotTestFixture(); - - // Invalid src file. - fixture.run(tempDir, "unknown.lf") - .verify(result -> { - result.checkStdErr(containsString("No such file or directory.")); - result.checkFailed(); + } + + @Test + public void testInvalidArgs(@TempDir Path tempDir) throws IOException { + dirBuilder(tempDir).file("src/File.lf", LF_PYTHON_FILE); + LfcOneShotTestFixture fixture = new LfcOneShotTestFixture(); + + // Invalid src file. + fixture + .run(tempDir, "unknown.lf") + .verify( + result -> { + result.checkStdErr(containsString("No such file or directory.")); + result.checkFailed(); }); - // Invalid output path. - fixture.run(tempDir, "--output-path", "unknown/output/path", "src/File.lf") - .verify(result -> { - result.checkStdErr(containsString("Output location does not exist.")); - result.checkFailed(); + // Invalid output path. + fixture + .run(tempDir, "--output-path", "unknown/output/path", "src/File.lf") + .verify( + result -> { + result.checkStdErr(containsString("Output location does not exist.")); + result.checkFailed(); }); - // Invalid build type. - fixture.run(tempDir, "--build-type", "unknown-build-type", "src/File.lf") - .verify(result -> { - result.checkStdErr(containsString("Invalid build type.")); - result.checkFailed(); + // Invalid build type. + fixture + .run(tempDir, "--build-type", "unknown-build-type", "src/File.lf") + .verify( + result -> { + result.checkStdErr(containsString("Invalid build type.")); + result.checkFailed(); }); - // Invalid logging level. - fixture.run(tempDir, "--logging", "unknown_level", "src/File.lf") - .verify(result -> { - result.checkStdErr(containsString("Invalid log level.")); - result.checkFailed(); + // Invalid logging level. + fixture + .run(tempDir, "--logging", "unknown_level", "src/File.lf") + .verify( + result -> { + result.checkStdErr(containsString("Invalid log level.")); + result.checkFailed(); }); - // Invalid RTI path. - fixture.run(tempDir, "--rti", "unknown/rti/path", "src/File.lf") - .verify(result -> { - result.checkStdErr(containsString("Invalid RTI path.")); - result.checkFailed(); + // Invalid RTI path. + fixture + .run(tempDir, "--rti", "unknown/rti/path", "src/File.lf") + .verify( + result -> { + result.checkStdErr(containsString("Invalid RTI path.")); + result.checkFailed(); }); - // Invalid scheduler. - fixture.run(tempDir, "--scheduler", "unknown-scheduler", "src/File.lf") - .verify(result -> { - result.checkStdErr(containsString("Invalid scheduler.")); - result.checkFailed(); + // Invalid scheduler. + fixture + .run(tempDir, "--scheduler", "unknown-scheduler", "src/File.lf") + .verify( + result -> { + result.checkStdErr(containsString("Invalid scheduler.")); + result.checkFailed(); }); - // Invalid workers. - fixture.run(tempDir, "--workers", "notaninteger", "src/File.lf") - .verify(result -> { - result.checkStdErr(containsString("Invalid value for option '--workers'")); - result.checkStdErr(containsString("is not an int")); - result.checkFailed(); + // Invalid workers. + fixture + .run(tempDir, "--workers", "notaninteger", "src/File.lf") + .verify( + result -> { + result.checkStdErr(containsString("Invalid value for option '--workers'")); + result.checkStdErr(containsString("is not an int")); + result.checkFailed(); }); - - } - - @Test - public void testGenInSrcDir(@TempDir Path tempDir) throws IOException { - dirBuilder(tempDir).file("src/File.lf", LF_PYTHON_FILE); - - lfcTester.run(tempDir, "src/File.lf", "--no-compile") - .verify(result -> { - result.checkOk(); - dirChecker(tempDir) - .check("src-gen", isDirectory()) - .check("bin", isDirectory()) - .check("src-gen/File/File.py", isRegularFile()); + } + + @Test + public void testGenInSrcDir(@TempDir Path tempDir) throws IOException { + dirBuilder(tempDir).file("src/File.lf", LF_PYTHON_FILE); + + lfcTester + .run(tempDir, "src/File.lf", "--no-compile") + .verify( + result -> { + result.checkOk(); + dirChecker(tempDir) + .check("src-gen", isDirectory()) + .check("bin", isDirectory()) + .check("src-gen/File/File.py", isRegularFile()); }); - } - - // Helper method for comparing argument values in tests testGeneratorArgs, - // testGeneratorArgsJsonString and testGeneratorArgsJsonFile. - public void verifyGeneratorArgs(Path tempDir, String[] args) { - LfcOneShotTestFixture fixture = new LfcOneShotTestFixture(); - - fixture.run(tempDir, args) - .verify(result -> { - // Don't validate execution because args are dummy args. - Properties properties = fixture.lfc.getGeneratorArgs(); - assertEquals(properties.getProperty(BuildParm.BUILD_TYPE.getKey()), "Release"); - assertEquals(properties.getProperty(BuildParm.CLEAN.getKey()), "true"); - assertEquals(properties.getProperty(BuildParm.TARGET_COMPILER.getKey()), "gcc"); - assertEquals(properties.getProperty(BuildParm.EXTERNAL_RUNTIME_PATH.getKey()), "src"); - assertEquals(properties.getProperty(BuildParm.LOGGING.getKey()), "info"); - assertEquals(properties.getProperty(BuildParm.LINT.getKey()), "true"); - assertEquals(properties.getProperty(BuildParm.NO_COMPILE.getKey()), "true"); - assertEquals(properties.getProperty(BuildParm.PRINT_STATISTICS.getKey()), "true"); - assertEquals(properties.getProperty(BuildParm.QUIET.getKey()), "true"); - assertEquals(properties.getProperty(BuildParm.RTI.getKey()), - "path" + File.separator + "to" + File.separator + "rti"); - assertEquals(properties.getProperty(BuildParm.RUNTIME_VERSION.getKey()), "rs"); - assertEquals(properties.getProperty(BuildParm.SCHEDULER.getKey()), "GEDF_NP"); - assertEquals(properties.getProperty(BuildParm.THREADING.getKey()), "false"); - assertEquals(properties.getProperty(BuildParm.WORKERS.getKey()), "1"); + } + + // Helper method for comparing argument values in tests testGeneratorArgs, + // testGeneratorArgsJsonString and testGeneratorArgsJsonFile. + public void verifyGeneratorArgs(Path tempDir, String[] args) { + LfcOneShotTestFixture fixture = new LfcOneShotTestFixture(); + + fixture + .run(tempDir, args) + .verify( + result -> { + // Don't validate execution because args are dummy args. + Properties properties = fixture.lfc.getGeneratorArgs(); + assertEquals(properties.getProperty(BuildParm.BUILD_TYPE.getKey()), "Release"); + assertEquals(properties.getProperty(BuildParm.CLEAN.getKey()), "true"); + assertEquals(properties.getProperty(BuildParm.TARGET_COMPILER.getKey()), "gcc"); + assertEquals(properties.getProperty(BuildParm.EXTERNAL_RUNTIME_PATH.getKey()), "src"); + assertEquals(properties.getProperty(BuildParm.LOGGING.getKey()), "info"); + assertEquals(properties.getProperty(BuildParm.LINT.getKey()), "true"); + assertEquals(properties.getProperty(BuildParm.NO_COMPILE.getKey()), "true"); + assertEquals(properties.getProperty(BuildParm.PRINT_STATISTICS.getKey()), "true"); + assertEquals(properties.getProperty(BuildParm.QUIET.getKey()), "true"); + assertEquals( + properties.getProperty(BuildParm.RTI.getKey()), + "path" + File.separator + "to" + File.separator + "rti"); + assertEquals(properties.getProperty(BuildParm.RUNTIME_VERSION.getKey()), "rs"); + assertEquals(properties.getProperty(BuildParm.SCHEDULER.getKey()), "GEDF_NP"); + assertEquals(properties.getProperty(BuildParm.THREADING.getKey()), "false"); + assertEquals(properties.getProperty(BuildParm.WORKERS.getKey()), "1"); }); + } + + @Test + public void testGeneratorArgs(@TempDir Path tempDir) throws IOException { + TempDirBuilder dir = dirBuilder(tempDir); + dir.file("src/File.lf", LF_PYTHON_FILE); + dir.mkdirs("path//to/rti"); + + String[] args = { + "src/File.lf", + "--output-path", + "src", + "--build-type", + "Release", + "--clean", + "--target-compiler", + "gcc", + "--external-runtime-path", + "src", + "--federated", + "--logging", + "info", + "--lint", + "--no-compile", + "--print-statistics", + "--quiet", + "--rti", + "path/to/rti", + "--runtime-version", + "rs", + "--scheduler", + "GEDF_NP", + "--threading", + "false", + "--workers", + "1", + }; + verifyGeneratorArgs(tempDir, args); + } + + @Test + public void testGeneratorArgsJsonString(@TempDir Path tempDir) throws IOException { + TempDirBuilder dir = dirBuilder(tempDir); + dir.file("src/File.lf", LF_PYTHON_FILE); + dir.mkdirs("path/to/rti"); + + String[] args = {"--json", JSON_STRING}; + verifyGeneratorArgs(tempDir, args); + } + + @Test + public void testGeneratorArgsJsonFile(@TempDir Path tempDir) throws IOException { + TempDirBuilder dir = dirBuilder(tempDir); + dir.file("src/File.lf", LF_PYTHON_FILE); + dir.file("src/test.json", JSON_STRING); + dir.mkdirs("path/to/rti"); + + String[] args = {"--json-file", "src/test.json"}; + verifyGeneratorArgs(tempDir, args); + } + + static class LfcTestFixture extends CliToolTestFixture { + + @Override + protected void runCliProgram(Io io, String[] args) { + Lfc.main(io, args); } + } - @Test - public void testGeneratorArgs(@TempDir Path tempDir) - throws IOException { - TempDirBuilder dir = dirBuilder(tempDir); - dir.file("src/File.lf", LF_PYTHON_FILE); - dir.mkdirs("path//to/rti"); - - String[] args = { - "src/File.lf", - "--output-path", "src", - "--build-type", "Release", - "--clean", - "--target-compiler", "gcc", - "--external-runtime-path", "src", - "--federated", - "--logging", "info", - "--lint", - "--no-compile", - "--print-statistics", - "--quiet", - "--rti", "path/to/rti", - "--runtime-version", "rs", - "--scheduler", "GEDF_NP", - "--threading", "false", - "--workers", "1", - }; - verifyGeneratorArgs(tempDir, args); - } - - @Test - public void testGeneratorArgsJsonString(@TempDir Path tempDir) - throws IOException { - TempDirBuilder dir = dirBuilder(tempDir); - dir.file("src/File.lf", LF_PYTHON_FILE); - dir.mkdirs("path/to/rti"); + static class LfcOneShotTestFixture extends CliToolTestFixture { - String[] args = {"--json", JSON_STRING}; - verifyGeneratorArgs(tempDir, args); - } - - @Test - public void testGeneratorArgsJsonFile(@TempDir Path tempDir) - throws IOException { - TempDirBuilder dir = dirBuilder(tempDir); - dir.file("src/File.lf", LF_PYTHON_FILE); - dir.file("src/test.json", JSON_STRING); - dir.mkdirs("path/to/rti"); - - String[] args = {"--json-file", "src/test.json"}; - verifyGeneratorArgs(tempDir, args); - } + private Lfc lfc; - static class LfcTestFixture extends CliToolTestFixture { - - @Override - protected void runCliProgram(Io io, String[] args) { - Lfc.main(io, args); - } - } - - static class LfcOneShotTestFixture extends CliToolTestFixture { - - private Lfc lfc; - - @Override - protected void runCliProgram(Io io, String[] args) { - // Injector used to obtain Main instance. - final Injector injector = Lfc.getInjector("lfc", io); - // Main instance. - this.lfc = injector.getInstance(Lfc.class); - lfc.doExecute(io, args); - } + @Override + protected void runCliProgram(Io io, String[] args) { + // Injector used to obtain Main instance. + final Injector injector = Lfc.getInjector("lfc", io); + // Main instance. + this.lfc = injector.getInstance(Lfc.class); + lfc.doExecute(io, args); } + } } diff --git a/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java b/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java index 16a4e9b32d..a9da20239f 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java +++ b/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java @@ -26,153 +26,136 @@ import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.MatcherAssert.assertThat; import static org.lflang.tests.TestUtils.TempDirBuilder.dirBuilder; import static org.lflang.tests.TestUtils.TempDirChecker.dirChecker; import java.io.File; import java.io.IOException; import java.nio.file.Path; - import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; - import org.lflang.LocalStrings; -import org.lflang.tests.cli.CliToolTestFixture.ExecutionResult; import org.lflang.cli.Io; import org.lflang.cli.Lff; +import org.lflang.tests.cli.CliToolTestFixture.ExecutionResult; /** * @author Clément Fournier */ public class LffCliTest { - private static final String FILE_BEFORE_REFORMAT = """ + private static final String FILE_BEFORE_REFORMAT = + """ target Python; main reactor { reaction(startup) {= =} } """; - private static final String FILE_AFTER_REFORMAT = """ + private static final String FILE_AFTER_REFORMAT = + """ target Python - + main reactor { reaction(startup) {= =} } """; - LffTestFixture lffTester = new LffTestFixture(); + LffTestFixture lffTester = new LffTestFixture(); + @Test + public void testHelpArg() { + ExecutionResult result = lffTester.run("--help", "--version"); + result.checkOk(); + result.checkNoErrorOutput(); + result.checkStdOut(containsString("Usage: lff")); + } - @Test - public void testHelpArg() { - ExecutionResult result = lffTester.run("--help", "--version"); - result.checkOk(); - result.checkNoErrorOutput(); - result.checkStdOut(containsString("Usage: lff")); - } + @Test + public void testVersion() { + ExecutionResult result = lffTester.run("--version"); + result.checkOk(); + result.checkNoErrorOutput(); + result.checkStdOut(equalTo("lff " + LocalStrings.VERSION + System.lineSeparator())); + } - @Test - public void testVersion() { - ExecutionResult result = lffTester.run("--version"); - result.checkOk(); - result.checkNoErrorOutput(); - result.checkStdOut( - equalTo("lff " + LocalStrings.VERSION + System.lineSeparator())); - } + @Test + public void testWrongCliArg() { + ExecutionResult result = lffTester.run("--notanargument", "File.lf"); + result.checkStdErr(containsString("Unknown option: '--notanargument'")); + result.checkFailed(); + } + @Test + public void testFormatSingleFileInPlace(@TempDir Path tempDir) throws IOException { + dirBuilder(tempDir).file("src/File.lf", FILE_BEFORE_REFORMAT); - @Test - public void testWrongCliArg() { - ExecutionResult result = lffTester.run("--notanargument", "File.lf"); - result.checkStdErr(containsString("Unknown option: '--notanargument'")); - result.checkFailed(); - } + ExecutionResult result = lffTester.run(tempDir, "src/File.lf"); - @Test - public void testFormatSingleFileInPlace(@TempDir Path tempDir) throws IOException { - dirBuilder(tempDir).file("src/File.lf", FILE_BEFORE_REFORMAT); + result.checkOk(); - ExecutionResult result = lffTester.run(tempDir, "src/File.lf"); + dirChecker(tempDir).checkContentsOf("src/File.lf", equalTo(FILE_AFTER_REFORMAT)); + } - result.checkOk(); + @Test + public void testFormatDirectory(@TempDir Path tempDir) throws IOException { + dirBuilder(tempDir).file("src/File.lf", FILE_BEFORE_REFORMAT); - dirChecker(tempDir).checkContentsOf("src/File.lf", equalTo(FILE_AFTER_REFORMAT)); - } + ExecutionResult result = lffTester.run(tempDir, "src"); + result.checkOk(); - @Test - public void testFormatDirectory(@TempDir Path tempDir) throws IOException { - dirBuilder(tempDir).file("src/File.lf", FILE_BEFORE_REFORMAT); + dirChecker(tempDir).checkContentsOf("src/File.lf", equalTo(FILE_AFTER_REFORMAT)); + } - ExecutionResult result = lffTester.run(tempDir, "src"); + @Test + public void testFormatDirectoryVerbose(@TempDir Path tempDir) throws IOException { + dirBuilder(tempDir).file("src/File.lf", FILE_BEFORE_REFORMAT); - result.checkOk(); + ExecutionResult result = lffTester.run(tempDir, "-v", "src"); - dirChecker(tempDir).checkContentsOf("src/File.lf", equalTo(FILE_AFTER_REFORMAT)); - } + result.checkOk(); + result.checkStdOut(containsString("Formatted src" + File.separator + "File.lf")); + dirChecker(tempDir).checkContentsOf("src/File.lf", equalTo(FILE_AFTER_REFORMAT)); + } - @Test - public void testFormatDirectoryVerbose(@TempDir Path tempDir) throws IOException { - dirBuilder(tempDir).file("src/File.lf", FILE_BEFORE_REFORMAT); + @Test + public void testNoSuchFile(@TempDir Path tempDir) { + ExecutionResult result = lffTester.run(tempDir, "-v", "nosuchdir"); - ExecutionResult result = lffTester.run(tempDir, "-v", "src"); + result.checkFailed(); - result.checkOk(); + result.checkStdErr( + containsString(tempDir.resolve("nosuchdir") + ": No such file or directory.")); + } - result.checkStdOut(containsString( - "Formatted src" + File.separator + "File.lf")); - dirChecker(tempDir).checkContentsOf("src/File.lf", equalTo(FILE_AFTER_REFORMAT)); - } + @Test + public void testOutputPathWithDirArg(@TempDir Path tempDir) throws IOException { + dirBuilder(tempDir).file("src/a/File.lf", FILE_BEFORE_REFORMAT).mkdirs("out/"); - @Test - public void testNoSuchFile(@TempDir Path tempDir) { - ExecutionResult result = lffTester.run(tempDir, "-v", "nosuchdir"); + ExecutionResult result = lffTester.run(tempDir, "src", "--output-path", "out"); - result.checkFailed(); + result.checkOk(); - result.checkStdErr(containsString( - tempDir.resolve("nosuchdir") + ": No such file or directory.")); - } + dirChecker(tempDir).checkContentsOf("out/a/File.lf", equalTo(FILE_AFTER_REFORMAT)); + } + @Test + public void testOutputPathWithFileArg(@TempDir Path tempDir) throws IOException { + dirBuilder(tempDir).file("src/a/File.lf", FILE_BEFORE_REFORMAT).mkdirs("out/"); - @Test - public void testOutputPathWithDirArg(@TempDir Path tempDir) throws IOException { - dirBuilder(tempDir) - .file("src/a/File.lf", FILE_BEFORE_REFORMAT) - .mkdirs("out/"); + ExecutionResult result = lffTester.run(tempDir, "src/a/File.lf", "--output-path", "out"); - ExecutionResult result = lffTester.run(tempDir, "src", "--output-path", "out"); + result.checkOk(); - result.checkOk(); + dirChecker(tempDir).checkContentsOf("out/File.lf", equalTo(FILE_AFTER_REFORMAT)); + } - dirChecker(tempDir) - .checkContentsOf("out/a/File.lf", equalTo(FILE_AFTER_REFORMAT)); - } - - @Test - public void testOutputPathWithFileArg(@TempDir Path tempDir) throws IOException { - dirBuilder(tempDir) - .file("src/a/File.lf", FILE_BEFORE_REFORMAT) - .mkdirs("out/"); - - ExecutionResult result = lffTester.run(tempDir, "src/a/File.lf", "--output-path", "out"); + static class LffTestFixture extends CliToolTestFixture { - result.checkOk(); - - dirChecker(tempDir) - .checkContentsOf("out/File.lf", equalTo(FILE_AFTER_REFORMAT)); + @Override + protected void runCliProgram(Io io, String[] args) { + Lff.main(io, args); } - - - static class LffTestFixture extends CliToolTestFixture { - - - @Override - protected void runCliProgram(Io io, String[] args) { - Lff.main(io, args); - } - } - + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/EquivalenceUnitTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/EquivalenceUnitTests.java index 931a0edae0..5d4fe9940c 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/EquivalenceUnitTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/EquivalenceUnitTests.java @@ -5,7 +5,6 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.ast.IsEqual; import org.lflang.lf.Model; import org.lflang.tests.LFInjectorProvider; @@ -15,10 +14,10 @@ @InjectWith(LFInjectorProvider.class) public class EquivalenceUnitTests { - @Test - public void testSimple() { - assertSelfEquivalence( - """ + @Test + public void testSimple() { + assertSelfEquivalence( + """ target C reactor Destination { @@ -26,14 +25,13 @@ public void testSimple() { input in: int state last_invoked: tag_t({= NEVER_TAG_INITIALIZER =}) } - """ - ); - } + """); + } - @Test - public void testCodeExprEqItselfModuloIndent() { - assertEquivalent( - """ + @Test + public void testCodeExprEqItselfModuloIndent() { + assertEquivalent( + """ target C reactor Destination { state s: tag_t({= @@ -41,67 +39,56 @@ public void testCodeExprEqItselfModuloIndent() { =}) } """, - """ + """ target C reactor Destination { state s: tag_t({= NEVER_TAG_INITIALIZER =}) } - """ - ); - } + """); + } - @Test - public void testInitializerParensAreIrrelevantInAssignment() { - assertEquivalent( - """ + @Test + public void testInitializerParensAreIrrelevantInAssignment() { + assertEquivalent( + """ target C reactor A(a: int(0)) {} main reactor { a = new A(a = 1) } """, - """ + """ target C reactor A(a: int(0)) {} main reactor { a = new A(a = (1)) // mind the parens here. } - """ - ); - } - - private void assertSelfEquivalence(String input) { - Model inputModel = LfParsingUtil.parseValidModel("test input", input); - // need to parse twice otherwise they are trivially equivalent - // because they're the same object. - Model otherModel = LfParsingUtil.parseValidModel("other", input); - - // test equivalence of the models. - Assertions.assertTrue( - new IsEqual(inputModel).doSwitch(otherModel), - String.format( - "Model is not equivalent to itself. Source:%n%s", - input - ) - ); - } + """); + } - private void assertEquivalent(String input, String other) { - Model inputModel = LfParsingUtil.parseValidModel("test input", input); - Model outputModel = LfParsingUtil.parseValidModel("other", other); + private void assertSelfEquivalence(String input) { + Model inputModel = LfParsingUtil.parseValidModel("test input", input); + // need to parse twice otherwise they are trivially equivalent + // because they're the same object. + Model otherModel = LfParsingUtil.parseValidModel("other", input); - // test equivalence of the models. - Assertions.assertTrue( - new IsEqual(inputModel).doSwitch(outputModel), - String.format( - "The reformatted model is not equivalent to the original file.%n" - + "Input file:%n%s%n%n" - + "Comparand file:%n%s%n%n", - input, - other - ) - ); - } + // test equivalence of the models. + Assertions.assertTrue( + new IsEqual(inputModel).doSwitch(otherModel), + String.format("Model is not equivalent to itself. Source:%n%s", input)); + } + private void assertEquivalent(String input, String other) { + Model inputModel = LfParsingUtil.parseValidModel("test input", input); + Model outputModel = LfParsingUtil.parseValidModel("other", other); + // test equivalence of the models. + Assertions.assertTrue( + new IsEqual(inputModel).doSwitch(outputModel), + String.format( + "The reformatted model is not equivalent to the original file.%n" + + "Input file:%n%s%n%n" + + "Comparand file:%n%s%n%n", + input, other)); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java index d7862e5d25..79aa6ac1f2 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java @@ -5,9 +5,7 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.ast.FormattingUtils; -import org.lflang.ast.IsEqual; import org.lflang.lf.Model; import org.lflang.tests.LFInjectorProvider; import org.lflang.tests.LfParsingUtil; @@ -16,26 +14,25 @@ @InjectWith(LFInjectorProvider.class) public class FormattingUnitTests { - @Test - public void testSimple() { - assertFormatsTo( - """ + @Test + public void testSimple() { + assertFormatsTo( + """ target C reactor Main{ } """, - """ + """ target C - + reactor Main { } - """ - ); - } + """); + } - @Test - public void testAssignments() { - assertFormatsTo( - """ + @Test + public void testAssignments() { + assertFormatsTo( + """ target C reactor Destination { @@ -44,7 +41,7 @@ public void testAssignments() { state last_invoked: tag_t({= NEVER_TAG_INITIALIZER =}) } """, - """ + """ target C reactor Destination { @@ -52,14 +49,13 @@ public void testAssignments() { input in: int state last_invoked: tag_t = {= NEVER_TAG_INITIALIZER =} } - """ - ); - } + """); + } - @Test - public void testState() { - assertFormatsTo( - """ + @Test + public void testState() { + assertFormatsTo( + """ target Python reactor Destination { @@ -68,7 +64,7 @@ public void testState() { state list_init(1,2) // this syntax is deprecated } """, - """ + """ target Python reactor Destination { @@ -76,14 +72,13 @@ state list_init(1,2) // this syntax is deprecated state no_init: tag_t state list_init(1, 2) # this syntax is deprecated } - """ - ); - } + """); + } - @Test - public void testCppInits() { - assertIsFormatted( - """ + @Test + public void testCppInits() { + assertIsFormatted( + """ target Cpp reactor Destination { @@ -94,23 +89,17 @@ public void testCppInits() { state brace: std::vector{1, 2} state paren_list: std::vector(1, 2) } - """ - ); - } - - private void assertIsFormatted(String input) { - assertFormatsTo(input, input); - } - - private void assertFormatsTo(String input, String expectedOutput) { - Model inputModel = LfParsingUtil.parseValidModel("test input", input); - String formattedString = FormattingUtils.render(inputModel); - Assertions.assertEquals( - expectedOutput, - formattedString, - "Formatted output is different from what was expected" - ); - } - - + """); + } + + private void assertIsFormatted(String input) { + assertFormatsTo(input, input); + } + + private void assertFormatsTo(String input, String expectedOutput) { + Model inputModel = LfParsingUtil.parseValidModel("test input", input); + String formattedString = FormattingUtils.render(inputModel); + Assertions.assertEquals( + expectedOutput, formattedString, "Formatted output is different from what was expected"); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java index b3e7814f96..38387ac8a4 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java @@ -1,34 +1,33 @@ -package org.lflang.tests.compiler;/* Parsing unit tests. */ +package org.lflang.tests.compiler; /* Parsing unit tests. */ /************* - Copyright (c) 2022, The University of California at Berkeley. - - 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. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * Copyright (c) 2022, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. ***************/ import static org.lflang.ast.ASTUtils.toDefinition; import javax.inject.Inject; - import org.eclipse.emf.common.util.TreeIterator; import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.testing.InjectWith; @@ -37,11 +36,10 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - -import org.lflang.ast.ASTUtils; import org.lflang.DefaultErrorReporter; import org.lflang.TimeUnit; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.ast.DelayedConnectionTransformation; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; @@ -49,7 +47,6 @@ import org.lflang.generator.c.CTypes; import org.lflang.lf.Instantiation; import org.lflang.lf.LfFactory; - import org.lflang.lf.Model; import org.lflang.lf.Reactor; import org.lflang.tests.LFInjectorProvider; @@ -58,89 +55,93 @@ @InjectWith(LFInjectorProvider.class) /** - * Test for getting minimum delay in reactions. - * Checking the actions and port's delay,then get the minimum reaction delay. + * Test for getting minimum delay in reactions. Checking the actions and port's delay,then get the + * minimum reaction delay. + * * @author Wonseo Choi * @author Yunsang Cho * @author Marten Lohstroh * @author Hokeun Kim */ -class LetInferenceTest { - - @Inject - ParseHelper parser; - - - @Test - public void testLet() throws Exception { - Model model = parser.parse(String.join( - System.getProperty("line.separator"), - "target C;", - "main reactor {", - " ramp = new Ramp();", - " print = new Print();", - " print2 = new Print();", - " ramp.y -> print.x after 20 msec;", - " ramp.y -> print2.x after 30 msec;", - "}", - "reactor Ramp {", - " logical action a(60 msec):int;", - " logical action b(100 msec):int;", - " input x:int;", - " output y:int;", - " output z:int;", - " reaction(startup) -> y, z, a, b{=", - " =}", - "}", - "reactor Print {", - " input x:int;", - " output z:int;", - " reaction(x) -> z {=", - " =}", - "}" - )); - - Assertions.assertNotNull(model); - final var ctypes = CTypes.getInstance(); - final var resource = model.eResource(); - final var transformation = new DelayedConnectionTransformation(new CDelayBodyGenerator(ctypes), ctypes, resource, true, true); - transformation.applyTransformation(ASTUtils.getAllReactors(resource)); - - Assertions.assertTrue(model.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + - model.eResource().getErrors()); +class LetInferenceTest { + + @Inject ParseHelper parser; + + @Test + public void testLet() throws Exception { + Model model = + parser.parse( + String.join( + System.getProperty("line.separator"), + "target C;", + "main reactor {", + " ramp = new Ramp();", + " print = new Print();", + " print2 = new Print();", + " ramp.y -> print.x after 20 msec;", + " ramp.y -> print2.x after 30 msec;", + "}", + "reactor Ramp {", + " logical action a(60 msec):int;", + " logical action b(100 msec):int;", + " input x:int;", + " output y:int;", + " output z:int;", + " reaction(startup) -> y, z, a, b{=", + " =}", + "}", + "reactor Print {", + " input x:int;", + " output z:int;", + " reaction(x) -> z {=", + " =}", + "}")); + + Assertions.assertNotNull(model); + final var ctypes = CTypes.getInstance(); + final var resource = model.eResource(); + final var transformation = + new DelayedConnectionTransformation( + new CDelayBodyGenerator(ctypes), ctypes, resource, true, true); + transformation.applyTransformation(ASTUtils.getAllReactors(resource)); + + Assertions.assertTrue( + model.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model.eResource().getErrors()); + + Instantiation mainDef = null; + + TreeIterator it = model.eResource().getAllContents(); + while (it.hasNext()) { + EObject obj = it.next(); + if (!(obj instanceof Reactor reactor)) { + continue; + } + if (reactor.isMain()) { + mainDef = LfFactory.eINSTANCE.createInstantiation(); + mainDef.setName(reactor.getName()); + mainDef.setReactorClass(reactor); + } + } - Instantiation mainDef = null; + ReactorInstance mainInstance = + new ReactorInstance(toDefinition(mainDef.getReactorClass()), new DefaultErrorReporter()); - TreeIterator it = model.eResource().getAllContents(); - while (it.hasNext()) { - EObject obj = it.next(); - if (!(obj instanceof Reactor reactor)) { - continue; - } - if (reactor.isMain()) { - mainDef = LfFactory.eINSTANCE.createInstantiation(); - mainDef.setName(reactor.getName()); - mainDef.setReactorClass(reactor); - } + for (ReactorInstance reactorInstance : mainInstance.children) { + if (reactorInstance.isGeneratedDelay()) { + for (ReactionInstance reactionInstance : reactorInstance.reactions) { + Assertions.assertEquals(reactionInstance.assignLogicalExecutionTime(), TimeValue.ZERO); } - - ReactorInstance mainInstance = new ReactorInstance(toDefinition(mainDef.getReactorClass()), new DefaultErrorReporter()); - - for (ReactorInstance reactorInstance : mainInstance.children) { - if (reactorInstance.isGeneratedDelay()) { - for (ReactionInstance reactionInstance : reactorInstance.reactions) { - Assertions.assertEquals(reactionInstance.assignLogicalExecutionTime(), TimeValue.ZERO); - } - } else if (reactorInstance.getName().contains("ramp")) { - for (ReactionInstance reactionInstance : reactorInstance.reactions) { - Assertions.assertEquals(new TimeValue(20L, TimeUnit.MILLI), reactionInstance.assignLogicalExecutionTime()); - } - } else if (reactorInstance.getName().contains("print")) { - for (ReactionInstance reactionInstance : reactorInstance.reactions) { - Assertions.assertEquals(TimeValue.ZERO, reactionInstance.assignLogicalExecutionTime()); - } - } + } else if (reactorInstance.getName().contains("ramp")) { + for (ReactionInstance reactionInstance : reactorInstance.reactions) { + Assertions.assertEquals( + new TimeValue(20L, TimeUnit.MILLI), reactionInstance.assignLogicalExecutionTime()); + } + } else if (reactorInstance.getName().contains("print")) { + for (ReactionInstance reactionInstance : reactorInstance.reactions) { + Assertions.assertEquals(TimeValue.ZERO, reactionInstance.assignLogicalExecutionTime()); } + } } + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java index 0122e03d8d..61fcf74328 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java @@ -1,29 +1,29 @@ /* ASTUtils Unit Tests. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.compiler; @@ -34,14 +34,12 @@ import java.util.Map; import java.util.stream.Collectors; import javax.inject.Inject; - import org.eclipse.xtext.testing.InjectWith; import org.eclipse.xtext.testing.extensions.InjectionExtension; import org.eclipse.xtext.testing.util.ParseHelper; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.ast.ASTUtils; import org.lflang.lf.Instantiation; import org.lflang.lf.Literal; @@ -55,20 +53,17 @@ * * @author Christian Menard */ - @ExtendWith(InjectionExtension.class) @InjectWith(LFInjectorProvider.class) - class LinguaFrancaASTUtilsTest { - @Inject - ParseHelper parser; - - /** - * Test that isInititialized returns true for inititialized state variables - */ - @Test - public void initializedState() throws Exception { - Model model = parser.parse(""" + @Inject ParseHelper parser; + + /** Test that isInititialized returns true for inititialized state variables */ + @Test + public void initializedState() throws Exception { + Model model = + parser.parse( + """ target Cpp; main reactor Foo { state a(); @@ -79,26 +74,27 @@ public void initializedState() throws Exception { } """); - - - Assertions.assertNotNull(model); - Assertions.assertTrue(model.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + - model.eResource().getErrors()); - - model.eAllContents().forEachRemaining((obj) -> { - if (obj instanceof StateVar) { - Assertions.assertTrue(isInitialized((StateVar)obj)); - } - }); - } - - /** - * Test that isInititialized returns false for uninititialized state variables - */ - @Test - public void uninitializedState() throws Exception { - Model model = parser.parse(""" + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model.eResource().getErrors()); + + model + .eAllContents() + .forEachRemaining( + (obj) -> { + if (obj instanceof StateVar) { + Assertions.assertTrue(isInitialized((StateVar) obj)); + } + }); + } + + /** Test that isInititialized returns false for uninititialized state variables */ + @Test + public void uninitializedState() throws Exception { + Model model = + parser.parse( + """ target Cpp; main reactor Foo { state a; @@ -109,39 +105,42 @@ public void uninitializedState() throws Exception { } """); - Assertions.assertNotNull(model); - Assertions.assertTrue(model.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + - model.eResource().getErrors()); - - model.eAllContents().forEachRemaining((obj) -> { - if (obj instanceof StateVar) { - Assertions.assertFalse(isInitialized((StateVar)obj)); - } - }); - - } - /** - * Return a map from strings to instantiations given a model. - * - * @param model The model to discover instantiations in. - */ - private Map getInsts(Model model) { - return asStream(model.eAllContents()) - .filter(obj -> obj instanceof Instantiation) - .map(obj -> (Instantiation) obj) - .collect(Collectors.toMap(Instantiation::getName, it -> it)); - } - - /** - * Test reading initial values of parameters. - * This checks that the example given in the documentation of the - * ASTUtils.initialValue() function behaves as stated in the docs. - */ - @Test - public void initialValue() throws Exception { - - Model model = parser.parse(""" + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model.eResource().getErrors()); + + model + .eAllContents() + .forEachRemaining( + (obj) -> { + if (obj instanceof StateVar) { + Assertions.assertFalse(isInitialized((StateVar) obj)); + } + }); + } + /** + * Return a map from strings to instantiations given a model. + * + * @param model The model to discover instantiations in. + */ + private Map getInsts(Model model) { + return asStream(model.eAllContents()) + .filter(obj -> obj instanceof Instantiation) + .map(obj -> (Instantiation) obj) + .collect(Collectors.toMap(Instantiation::getName, it -> it)); + } + + /** + * Test reading initial values of parameters. This checks that the example given in the + * documentation of the ASTUtils.initialValue() function behaves as stated in the docs. + */ + @Test + public void initialValue() throws Exception { + + Model model = + parser.parse( + """ target C; reactor A(x:int(1)) {} reactor B(y:int(2)) { @@ -154,76 +153,80 @@ reactor C(z:int(3)) { } """); - Assertions.assertNotNull(model); - Assertions.assertTrue(model.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + - model.eResource().getErrors()); - - var map = getInsts(model); - - /* Check for this: - * initialValue(x, null) returns 1 - * initialValue(x, [a1]) returns 2 - * initialValue(x, [a2]) returns -1 - * initialValue(x, [a1, b1]) returns 3 - * initialValue(x, [a2, b1]) returns -1 - * initialValue(x, [a1, b2]) returns -2 - * initialValue(x, [a2, b2]) returns -1 - * - * initialValue(y, null) returns 2 - * initialValue(y, [a1]) throws an IllegalArgumentException - * initialValue(y, [b1]) returns 3 - * initialValue(y, [b2]) returns -2 - */ - - model.eAllContents().forEachRemaining((obj) -> { - if (obj instanceof Parameter) { - Parameter parameter = (Parameter)obj; + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model.eResource().getErrors()); + + var map = getInsts(model); + + /* Check for this: + * initialValue(x, null) returns 1 + * initialValue(x, [a1]) returns 2 + * initialValue(x, [a2]) returns -1 + * initialValue(x, [a1, b1]) returns 3 + * initialValue(x, [a2, b1]) returns -1 + * initialValue(x, [a1, b2]) returns -2 + * initialValue(x, [a2, b2]) returns -1 + * + * initialValue(y, null) returns 2 + * initialValue(y, [a1]) throws an IllegalArgumentException + * initialValue(y, [b1]) returns 3 + * initialValue(y, [b2]) returns -2 + */ + + model + .eAllContents() + .forEachRemaining( + (obj) -> { + if (obj instanceof Parameter) { + Parameter parameter = (Parameter) obj; if (parameter.getName() == "x") { - var values = ASTUtils.initialValue(parameter, null); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "1"); + var values = ASTUtils.initialValue(parameter, null); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "1"); - values = ASTUtils.initialValue(parameter, List.of(map.get("a1"))); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "2"); + values = ASTUtils.initialValue(parameter, List.of(map.get("a1"))); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "2"); - values = ASTUtils.initialValue(parameter, List.of(map.get("a2"))); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "-1"); + values = ASTUtils.initialValue(parameter, List.of(map.get("a2"))); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "-1"); - values = ASTUtils.initialValue(parameter, List.of(map.get("a1"), map.get("b1"))); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "3"); + values = ASTUtils.initialValue(parameter, List.of(map.get("a1"), map.get("b1"))); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "3"); - values = ASTUtils.initialValue(parameter, List.of(map.get("a2"), map.get("b1"))); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "-1"); + values = ASTUtils.initialValue(parameter, List.of(map.get("a2"), map.get("b1"))); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "-1"); - values = ASTUtils.initialValue(parameter, List.of(map.get("a1"), map.get("b2"))); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "-2"); + values = ASTUtils.initialValue(parameter, List.of(map.get("a1"), map.get("b2"))); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "-2"); - values = ASTUtils.initialValue(parameter, List.of(map.get("a2"), map.get("b2"))); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "-1"); + values = ASTUtils.initialValue(parameter, List.of(map.get("a2"), map.get("b2"))); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "-1"); } else if (parameter.getName() == "y") { - var values = ASTUtils.initialValue(parameter, null); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "2"); + var values = ASTUtils.initialValue(parameter, null); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "2"); - Assertions.assertThrows(IllegalArgumentException.class, - () -> ASTUtils.initialValue(parameter, List.of(map.get("a1")))); + Assertions.assertThrows( + IllegalArgumentException.class, + () -> ASTUtils.initialValue(parameter, List.of(map.get("a1")))); - values = ASTUtils.initialValue(parameter, List.of(map.get("b1"))); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "3"); + values = ASTUtils.initialValue(parameter, List.of(map.get("b1"))); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "3"); - values = ASTUtils.initialValue(parameter, List.of(map.get("b2"))); - Assertions.assertInstanceOf(Literal.class, values.get(0)); - Assertions.assertEquals(((Literal)values.get(0)).getLiteral(), "-2"); + values = ASTUtils.initialValue(parameter, List.of(map.get("b2"))); + Assertions.assertInstanceOf(Literal.class, values.get(0)); + Assertions.assertEquals(((Literal) values.get(0)).getLiteral(), "-2"); } - } - }); - } + } + }); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java index d7e2af48fc..516c712498 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java @@ -1,33 +1,34 @@ /* Dependency analysis unit tests. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.compiler; -import com.google.inject.Inject; +import static org.lflang.ast.ASTUtils.*; +import com.google.inject.Inject; import org.eclipse.emf.common.util.TreeIterator; import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.testing.InjectWith; @@ -44,57 +45,56 @@ import org.lflang.lf.Model; import org.lflang.lf.Reactor; import org.lflang.tests.LFInjectorProvider; -import static org.lflang.ast.ASTUtils.*; @ExtendWith(InjectionExtension.class) @InjectWith(LFInjectorProvider.class) /** * A collection of tests to ensure dependency analysis is done correctly. + * * @author Marten Lohstroh */ class LinguaFrancaDependencyAnalysisTest { - @Inject - ParseHelper parser; - - /** - * Check that circular dependencies between reactions are detected. - */ - @Test - public void cyclicDependency() throws Exception { - // Java 17: -// String testCase = """ -// target C; -// -// reactor Clock { -// timer t(0, 10 msec); -// input x:int; -// output y:int; -// reaction(t) -> y {= -// -// =} -// reaction(x) -> y {= -// -// =} -// } -// -// reactor A { -// input x:int; -// output y:int; -// reaction(x) -> y {= -// -// =} -// } -// -// main reactor Loop { -// c = new Clock(); -// a = new A(); -// c.y -> a.x; -// a.y -> c.x; -// } -// """ -// Java 11: - String testCase = String.join(System.getProperty("line.separator"), + @Inject ParseHelper parser; + + /** Check that circular dependencies between reactions are detected. */ + @Test + public void cyclicDependency() throws Exception { + // Java 17: + // String testCase = """ + // target C; + // + // reactor Clock { + // timer t(0, 10 msec); + // input x:int; + // output y:int; + // reaction(t) -> y {= + // + // =} + // reaction(x) -> y {= + // + // =} + // } + // + // reactor A { + // input x:int; + // output y:int; + // reaction(x) -> y {= + // + // =} + // } + // + // main reactor Loop { + // c = new Clock(); + // a = new A(); + // c.y -> a.x; + // a.y -> c.x; + // } + // """ + // Java 11: + String testCase = + String.join( + System.getProperty("line.separator"), "target C;", "", "reactor Clock {", @@ -122,38 +122,37 @@ public void cyclicDependency() throws Exception { " a = new A();", " c.y -> a.x;", " a.y -> c.x;", - "}" - ); - Model model = parser.parse(testCase); - - Assertions.assertNotNull(model); - Instantiation mainDef = null; - TreeIterator it = model.eResource().getAllContents(); - while (it.hasNext()) { - EObject obj = it.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor reactor = (Reactor) obj; - if (reactor.isMain()) { - // Creating an definition for the main reactor because - // there isn't one. - mainDef = LfFactory.eINSTANCE.createInstantiation(); - mainDef.setName(reactor.getName()); - mainDef.setReactorClass(reactor); - } - } - - ReactorInstance instance = new ReactorInstance(toDefinition(mainDef.getReactorClass()), new DefaultErrorReporter()); - Assertions.assertFalse(instance.getCycles().isEmpty()); + "}"); + Model model = parser.parse(testCase); + + Assertions.assertNotNull(model); + Instantiation mainDef = null; + TreeIterator it = model.eResource().getAllContents(); + while (it.hasNext()) { + EObject obj = it.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor reactor = (Reactor) obj; + if (reactor.isMain()) { + // Creating an definition for the main reactor because + // there isn't one. + mainDef = LfFactory.eINSTANCE.createInstantiation(); + mainDef.setName(reactor.getName()); + mainDef.setReactorClass(reactor); + } } - /** - * Check that circular instantiations are detected. - */ - @Test - public void circularInstantiation() throws Exception { - String testCase = """ + ReactorInstance instance = + new ReactorInstance(toDefinition(mainDef.getReactorClass()), new DefaultErrorReporter()); + Assertions.assertFalse(instance.getCycles().isEmpty()); + } + + /** Check that circular instantiations are detected. */ + @Test + public void circularInstantiation() throws Exception { + String testCase = + """ target C; reactor X { @@ -167,14 +166,13 @@ public void circularInstantiation() throws Exception { q = new X(); } """; - Model model = parser.parse(testCase); - - Assertions.assertNotNull(model); + Model model = parser.parse(testCase); - ModelInfo info = new ModelInfo(); - info.update(model, new DefaultErrorReporter()); - Assertions.assertTrue(info.instantiationGraph.hasCycles() == true, - "Did not detect cyclic instantiation."); - } + Assertions.assertNotNull(model); + ModelInfo info = new ModelInfo(); + info.update(model, new DefaultErrorReporter()); + Assertions.assertTrue( + info.instantiationGraph.hasCycles() == true, "Did not detect cyclic instantiation."); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaParsingTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaParsingTest.java index fc66c7ed57..377e3e7a32 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaParsingTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaParsingTest.java @@ -1,66 +1,63 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.compiler; +import com.google.inject.Inject; import org.eclipse.xtext.testing.InjectWith; import org.eclipse.xtext.testing.extensions.InjectionExtension; import org.eclipse.xtext.testing.util.ParseHelper; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.lf.Model; import org.lflang.tests.LFInjectorProvider; -import com.google.inject.Inject; - -/** - * Test harness for ensuring that grammar captures - * all corner cases. - */ +/** Test harness for ensuring that grammar captures all corner cases. */ @ExtendWith(InjectionExtension.class) @InjectWith(LFInjectorProvider.class) class LinguaFrancaParsingTest { - @Inject - ParseHelper parser; + @Inject ParseHelper parser; - @Test - public void checkForTarget() throws Exception { - String testCase = """ + @Test + public void checkForTarget() throws Exception { + String testCase = + """ targett C; reactor Foo { } """; - Model result = parser.parse(testCase); - Assertions.assertNotNull(result); - Assertions.assertFalse(result.eResource().getErrors().isEmpty(), "Failed to catch misspelled target keyword."); - } + Model result = parser.parse(testCase); + Assertions.assertNotNull(result); + Assertions.assertFalse( + result.eResource().getErrors().isEmpty(), "Failed to catch misspelled target keyword."); + } - @Test - public void testAttributes() throws Exception { - String testCase = """ + @Test + public void testAttributes() throws Exception { + String testCase = + """ target C; @label("somethign", "else") @ohio() @@ -74,16 +71,17 @@ public void testAttributes() throws Exception { } """; - parseWithoutError(testCase); - } + parseWithoutError(testCase); + } - @Test - public void testAttributeContexts() throws Exception { - String testCase = """ + @Test + public void testAttributeContexts() throws Exception { + String testCase = + """ target C; @a main reactor(@b parm: int) { - + @ohio reaction() {==} @ohio logical action f; @ohio timer t; @@ -91,28 +89,28 @@ main reactor(@b parm: int) { @ohio output q2: int; } """; - parseWithoutError(testCase); - } + parseWithoutError(testCase); + } - @Test - public void testTokenizeEmptyWidth() throws Exception { - String testCase = """ + @Test + public void testTokenizeEmptyWidth() throws Exception { + String testCase = + """ target C; main reactor { state foo: int[]; state foo: int[ ]; //spaces are allowed } """; - parseWithoutError(testCase); - } - - private Model parseWithoutError(String s) throws Exception { - Model model = parser.parse(s); - Assertions.assertNotNull(model); - Assertions.assertTrue(model.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + - model.eResource().getErrors()); - return model; - } + parseWithoutError(testCase); + } + private Model parseWithoutError(String s) throws Exception { + Model model = parser.parse(s); + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model.eResource().getErrors()); + return model; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaScopingTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaScopingTest.java index 8587675479..404d948264 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaScopingTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaScopingTest.java @@ -1,129 +1,125 @@ /* Scoping unit tests. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.compiler; import com.google.inject.Inject; +import com.google.inject.Provider; +import org.eclipse.emf.ecore.resource.ResourceSet; +import org.eclipse.xtext.generator.JavaIoFileSystemAccess; +import org.eclipse.xtext.linking.impl.XtextLinkingDiagnostic; import org.eclipse.xtext.testing.InjectWith; import org.eclipse.xtext.testing.extensions.InjectionExtension; import org.eclipse.xtext.testing.util.ParseHelper; -import org.lflang.lf.Model; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.Assertions; import org.eclipse.xtext.testing.validation.ValidationTestHelper; -import org.lflang.lf.LfPackage; -import org.eclipse.xtext.linking.impl.XtextLinkingDiagnostic; -import org.lflang.tests.LFInjectorProvider; -import org.eclipse.emf.ecore.resource.ResourceSet; -import org.eclipse.xtext.generator.JavaIoFileSystemAccess; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.lflang.generator.LFGenerator; -import com.google.inject.Provider; +import org.lflang.lf.LfPackage; +import org.lflang.lf.Model; +import org.lflang.tests.LFInjectorProvider; @ExtendWith(InjectionExtension.class) @InjectWith(LFInjectorProvider.class) /** - * Test harness for ensuring that cross-references are - * established correctly and reported when faulty. + * Test harness for ensuring that cross-references are established correctly and reported when + * faulty. */ public class LinguaFrancaScopingTest { - @Inject - ParseHelper parser; - - @Inject - LFGenerator generator; - - @Inject - JavaIoFileSystemAccess fileAccess; - - @Inject - Provider resourceSetProvider; - - @Inject - ValidationTestHelper validator; - - /** - * Ensure that invalid references to contained reactors are reported. - */ - @Test - public void unresolvedReactorReference() throws Exception { -// Java 17: -// Model model = """ -// target C; -// reactor From { -// output y:int; -// } -// reactor To { -// input x:int; -// } -// -// main reactor { -// a = new From(); -// d = new To(); -// s.y -> d.x; -// } -// """; -// Java 11: - Model model = parser.parse(String.join( - System.getProperty("line.separator"), - "target C;", - "reactor From {", - " output y:int;", - "}", - "reactor To {", - " input x:int;", - "}", - "", - "main reactor {", - " a = new From();", - " d = new To();", - " s.y -> d.x;", - "}" - )); - - Assertions.assertNotNull(model); - Assertions.assertTrue(model.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing."); - validator.assertError(model, LfPackage.eINSTANCE.getVarRef(), - XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, - "Couldn't resolve reference to Instantiation 's'"); - validator.assertError(model, LfPackage.eINSTANCE.getVarRef(), - XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, - "Couldn't resolve reference to Variable 'y'"); - } - - - /** - * Ensure that invalid references to ports - * of contained reactors are reported. - */ - @Test - public void unresolvedHierarchicalPortReference() throws Exception { - Model model = parser.parse(""" + @Inject ParseHelper parser; + + @Inject LFGenerator generator; + + @Inject JavaIoFileSystemAccess fileAccess; + + @Inject Provider resourceSetProvider; + + @Inject ValidationTestHelper validator; + + /** Ensure that invalid references to contained reactors are reported. */ + @Test + public void unresolvedReactorReference() throws Exception { + // Java 17: + // Model model = """ + // target C; + // reactor From { + // output y:int; + // } + // reactor To { + // input x:int; + // } + // + // main reactor { + // a = new From(); + // d = new To(); + // s.y -> d.x; + // } + // """; + // Java 11: + Model model = + parser.parse( + String.join( + System.getProperty("line.separator"), + "target C;", + "reactor From {", + " output y:int;", + "}", + "reactor To {", + " input x:int;", + "}", + "", + "main reactor {", + " a = new From();", + " d = new To();", + " s.y -> d.x;", + "}")); + + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.eResource().getErrors().isEmpty(), "Encountered unexpected error while parsing."); + validator.assertError( + model, + LfPackage.eINSTANCE.getVarRef(), + XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, + "Couldn't resolve reference to Instantiation 's'"); + validator.assertError( + model, + LfPackage.eINSTANCE.getVarRef(), + XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, + "Couldn't resolve reference to Variable 'y'"); + } + + /** Ensure that invalid references to ports of contained reactors are reported. */ + @Test + public void unresolvedHierarchicalPortReference() throws Exception { + Model model = + parser.parse( + """ target C; reactor From { output y:int; @@ -138,59 +134,73 @@ public void unresolvedHierarchicalPortReference() throws Exception { a.x -> d.y; } """); - - Assertions.assertNotNull(model); - Assertions.assertTrue(model.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing."); - validator.assertError(model, LfPackage.eINSTANCE.getVarRef(), - XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, - "Couldn't resolve reference to Variable 'x'"); - validator.assertError(model, LfPackage.eINSTANCE.getVarRef(), - XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, - "Couldn't resolve reference to Variable 'y'"); - } - - @Test - public void unresolvedReferenceInTriggerClause() throws Exception { - Model model = parser.parse(""" + + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.eResource().getErrors().isEmpty(), "Encountered unexpected error while parsing."); + validator.assertError( + model, + LfPackage.eINSTANCE.getVarRef(), + XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, + "Couldn't resolve reference to Variable 'x'"); + validator.assertError( + model, + LfPackage.eINSTANCE.getVarRef(), + XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, + "Couldn't resolve reference to Variable 'y'"); + } + + @Test + public void unresolvedReferenceInTriggerClause() throws Exception { + Model model = + parser.parse( + """ target C; main reactor { reaction(unknown) {==} } """); - - validator.assertError(model, LfPackage.eINSTANCE.getVarRef(), - XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, - "Couldn't resolve reference to Variable 'unknown'."); - } - - @Test - public void unresolvedReferenceInUseClause() throws Exception { - Model model = parser.parse(""" + + validator.assertError( + model, + LfPackage.eINSTANCE.getVarRef(), + XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, + "Couldn't resolve reference to Variable 'unknown'."); + } + + @Test + public void unresolvedReferenceInUseClause() throws Exception { + Model model = + parser.parse( + """ target C; main reactor { reaction() unknown {==} } """); - - - validator.assertError(model, LfPackage.eINSTANCE.getVarRef(), - XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, - "Couldn't resolve reference to Variable 'unknown'."); - } - - @Test - public void unresolvedReferenceInEffectsClause() throws Exception { - Model model = parser.parse(""" + + validator.assertError( + model, + LfPackage.eINSTANCE.getVarRef(), + XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, + "Couldn't resolve reference to Variable 'unknown'."); + } + + @Test + public void unresolvedReferenceInEffectsClause() throws Exception { + Model model = + parser.parse( + """ target C; main reactor { reaction() -> unknown {==} } """); - validator.assertError(model, LfPackage.eINSTANCE.getVarRef(), - XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, - "Couldn't resolve reference to Variable 'unknown'."); - } - + validator.assertError( + model, + LfPackage.eINSTANCE.getVarRef(), + XtextLinkingDiagnostic.LINKING_DIAGNOSTIC, + "Couldn't resolve reference to Variable 'unknown'."); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java index aa285a2e32..72e3574b33 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java @@ -1,36 +1,36 @@ /* Scoping unit tests. */ /************* - Copyright (c) 2019, The University of California at Berkeley. - - 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. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. ***************/ package org.lflang.tests.compiler; +import com.google.inject.Inject; import java.util.LinkedList; import java.util.List; import java.util.Map; - import org.eclipse.xtext.testing.InjectWith; import org.eclipse.xtext.testing.extensions.InjectionExtension; import org.eclipse.xtext.testing.util.ParseHelper; @@ -39,7 +39,6 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.Target; import org.lflang.TargetProperty; import org.lflang.TargetProperty.ArrayType; @@ -56,12 +55,9 @@ import org.lflang.tests.LFInjectorProvider; import org.lflang.util.StringUtil; -import com.google.inject.Inject; - @ExtendWith(InjectionExtension.class) @InjectWith(LFInjectorProvider.class) - /** * Collection of unit tests to ensure validation is done correctly. * @@ -73,75 +69,76 @@ */ public class LinguaFrancaValidationTest { - @Inject - ParseHelper parser; - - @Inject - ValidationTestHelper validator; - - /** - * Helper function to parse a Lingua Franca program and expect no errors. - * - * @return A model representing the parsed string. - */ - private Model parseWithoutError(String s) throws Exception { - Model model = parser.parse(s); - Assertions.assertNotNull(model); - Assertions.assertTrue(model.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + - model.eResource().getErrors()); - return model; - } - - /** - * Helper function to parse a Lingua Franca program and expect errors. - * - * @return A model representing the parsed string. - */ - private Model parseWithError(String s) throws Exception { - Model model = parser.parse(s); - Assertions.assertNotNull(model); - Assertions.assertFalse(model.eResource().getErrors().isEmpty()); - return model; - } - - /** - * Ensure that duplicate identifiers for actions reported. - */ - @Test - public void duplicateVariable() throws Exception { - String testCase = """ + @Inject ParseHelper parser; + + @Inject ValidationTestHelper validator; + + /** + * Helper function to parse a Lingua Franca program and expect no errors. + * + * @return A model representing the parsed string. + */ + private Model parseWithoutError(String s) throws Exception { + Model model = parser.parse(s); + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model.eResource().getErrors()); + return model; + } + + /** + * Helper function to parse a Lingua Franca program and expect errors. + * + * @return A model representing the parsed string. + */ + private Model parseWithError(String s) throws Exception { + Model model = parser.parse(s); + Assertions.assertNotNull(model); + Assertions.assertFalse(model.eResource().getErrors().isEmpty()); + return model; + } + + /** Ensure that duplicate identifiers for actions reported. */ + @Test + public void duplicateVariable() throws Exception { + String testCase = + """ target TypeScript; main reactor Foo { logical action bar; physical action bar; } """; - validator.assertError(parseWithoutError(testCase), - LfPackage.eINSTANCE.getAction(), - null, - "Duplicate Variable 'bar' in Reactor 'Foo'"); - } - + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getAction(), + null, + "Duplicate Variable 'bar' in Reactor 'Foo'"); + } - /** - * Check that reactors in C++ cannot be named preamble - */ - @Test - public void disallowReactorCalledPreamble() throws Exception { - Model model_no_errors = parser.parse(""" + /** Check that reactors in C++ cannot be named preamble */ + @Test + public void disallowReactorCalledPreamble() throws Exception { + Model model_no_errors = + parser.parse( + """ target Cpp; main reactor { } """); - Model model_error_1 = parser.parse(""" + Model model_error_1 = + parser.parse( + """ target Cpp; reactor Preamble { } """); - Model model_error_2 = parser.parse(""" + Model model_error_2 = + parser.parse( + """ target Cpp; reactor Preamble { } @@ -149,151 +146,177 @@ public void disallowReactorCalledPreamble() throws Exception { } """); - Assertions.assertNotNull(model_no_errors); - Assertions.assertNotNull(model_error_1); - Assertions.assertNotNull(model_error_2); - Assertions.assertTrue(model_no_errors.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " - + model_no_errors.eResource().getErrors()); - Assertions.assertTrue(model_error_1.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + model_error_1.eResource().getErrors()); - Assertions.assertTrue(model_error_2.eResource().getErrors().isEmpty(), - "Encountered unexpected error while parsing: " + model_error_2.eResource().getErrors()); - - validator.assertNoIssues(model_no_errors); - validator.assertError(model_error_1, - LfPackage.eINSTANCE.getReactor(), - null, - "Reactor cannot be named 'Preamble'"); - validator.assertError(model_error_2, - LfPackage.eINSTANCE.getReactor(), - null, - "Reactor cannot be named 'Preamble'"); - } - - - /** - * Ensure that "__" is not allowed at the start of an input name. - */ - @Test - public void disallowUnderscoreInputs() throws Exception { - String testCase = """ + Assertions.assertNotNull(model_no_errors); + Assertions.assertNotNull(model_error_1); + Assertions.assertNotNull(model_error_2); + Assertions.assertTrue( + model_no_errors.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model_no_errors.eResource().getErrors()); + Assertions.assertTrue( + model_error_1.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model_error_1.eResource().getErrors()); + Assertions.assertTrue( + model_error_2.eResource().getErrors().isEmpty(), + "Encountered unexpected error while parsing: " + model_error_2.eResource().getErrors()); + + validator.assertNoIssues(model_no_errors); + validator.assertError( + model_error_1, + LfPackage.eINSTANCE.getReactor(), + null, + "Reactor cannot be named 'Preamble'"); + validator.assertError( + model_error_2, + LfPackage.eINSTANCE.getReactor(), + null, + "Reactor cannot be named 'Preamble'"); + } + + /** Ensure that "__" is not allowed at the start of an input name. */ + @Test + public void disallowUnderscoreInputs() throws Exception { + String testCase = + """ target TypeScript; main reactor { input __bar; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getInput(), + null, + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor" + + " definitions, and reactor instantiation) may not start with \"__\": __bar"); + } - @Test - public void disallowMainWithDifferentNameThanFile() throws Exception { - String testCase = """ + @Test + public void disallowMainWithDifferentNameThanFile() throws Exception { + String testCase = + """ target C; main reactor Foo {} """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Name of main reactor must match the file name (or be omitted)"); - } - + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "Name of main reactor must match the file name (or be omitted)"); + } - /** - * Ensure that "__" is not allowed at the start of an output name. - */ - @Test - public void disallowUnderscoreOutputs() throws Exception { - String testCase = """ + /** Ensure that "__" is not allowed at the start of an output name. */ + @Test + public void disallowUnderscoreOutputs() throws Exception { + String testCase = + """ target TypeScript; main reactor Foo { output __bar; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getOutput(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getOutput(), + null, + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor" + + " definitions, and reactor instantiation) may not start with \"__\": __bar"); + } - /** - * Ensure that "__" is not allowed at the start of an action name. - */ - @Test - public void disallowUnderscoreActions() throws Exception { - String testCase = """ + /** Ensure that "__" is not allowed at the start of an action name. */ + @Test + public void disallowUnderscoreActions() throws Exception { + String testCase = + """ target TypeScript; main reactor Foo { logical action __bar; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAction(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getAction(), + null, + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor" + + " definitions, and reactor instantiation) may not start with \"__\": __bar"); + } - /** - * Ensure that "__" is not allowed at the start of a timer name. - */ - @Test - public void disallowUnderscoreTimers() throws Exception { - String testCase = """ + /** Ensure that "__" is not allowed at the start of a timer name. */ + @Test + public void disallowUnderscoreTimers() throws Exception { + String testCase = + """ target TypeScript; main reactor Foo { timer __bar(0); } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getTimer(), + null, + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor" + + " definitions, and reactor instantiation) may not start with \"__\": __bar"); + } - /** - * Ensure that "__" is not allowed at the start of a parameter name. - */ - @Test - public void disallowUnderscoreParameters() throws Exception { - String testCase = """ + /** Ensure that "__" is not allowed at the start of a parameter name. */ + @Test + public void disallowUnderscoreParameters() throws Exception { + String testCase = + """ target TypeScript; main reactor Foo(__bar) { } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getParameter(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getParameter(), + null, + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor" + + " definitions, and reactor instantiation) may not start with \"__\": __bar"); + } - /** - * Ensure that "__" is not allowed at the start of an state name. - */ - @Test - public void disallowUnderscoreStates() throws Exception { - String testCase = """ + /** Ensure that "__" is not allowed at the start of an state name. */ + @Test + public void disallowUnderscoreStates() throws Exception { + String testCase = + """ target TypeScript; main reactor Foo { state __bar; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __bar"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getStateVar(), + null, + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor" + + " definitions, and reactor instantiation) may not start with \"__\": __bar"); + } - /** - * Ensure that "__" is not allowed at the start of a reactor definition name. - */ - @Test - public void disallowUnderscoreReactorDef() throws Exception { - String testCase = """ + /** Ensure that "__" is not allowed at the start of a reactor definition name. */ + @Test + public void disallowUnderscoreReactorDef() throws Exception { + String testCase = + """ target TypeScript; reactor __Foo { } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __Foo"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor" + + " definitions, and reactor instantiation) may not start with \"__\": __Foo"); + } - /** - * Ensure that "__" is not allowed at the start of a reactor instantiation name. - */ - @Test - public void disallowUnderscoreReactorInstantiation() throws Exception { - String testCase = """ + /** Ensure that "__" is not allowed at the start of a reactor instantiation name. */ + @Test + public void disallowUnderscoreReactorInstantiation() throws Exception { + String testCase = + """ target TypeScript; reactor Foo { } @@ -301,16 +324,19 @@ public void disallowUnderscoreReactorInstantiation() throws Exception { __x = new Foo(); } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInstantiation(), null, - "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation) may not start with \"__\": __x"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getInstantiation(), + null, + "Names of objects (inputs, outputs, actions, timers, parameters, state, reactor" + + " definitions, and reactor instantiation) may not start with \"__\": __x"); + } - /** - * Disallow connection to port that is effect of reaction. - */ - @Test - public void connectionToEffectPort() throws Exception { - String testCase = """ + /** Disallow connection to port that is effect of reaction. */ + @Test + public void connectionToEffectPort() throws Exception { + String testCase = + """ target C; reactor Foo { output out:int; @@ -319,20 +345,22 @@ public void connectionToEffectPort() throws Exception { output out:int; x = new Foo(); x.out -> out; - reaction(startup) -> out {= + reaction(startup) -> out {= =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, - "Cannot connect: Port named 'out' is already effect of a reaction."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getConnection(), + null, + "Cannot connect: Port named 'out' is already effect of a reaction."); + } - /** - * Disallow connection to port that is effect of reaction. - */ - @Test - public void connectionToEffectPort2() throws Exception { - String testCase = """ + /** Disallow connection to port that is effect of reaction. */ + @Test + public void connectionToEffectPort2() throws Exception { + String testCase = + """ target C; reactor Foo { input inp:int; @@ -344,21 +372,25 @@ public void connectionToEffectPort2() throws Exception { y = new Foo(); y.out -> x.inp; - reaction(startup) -> x.inp {= + reaction(startup) -> x.inp {= =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, - "Cannot connect: Port named 'inp' is already effect of a reaction."); - } - - /** - * Allow connection to the port of a contained reactor if another port with same name is effect - * of a reaction. - */ - @Test - public void connectionToEffectPort3() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getConnection(), + null, + "Cannot connect: Port named 'inp' is already effect of a reaction."); + } + + /** + * Allow connection to the port of a contained reactor if another port with same name is effect of + * a reaction. + */ + @Test + public void connectionToEffectPort3() throws Exception { + String testCase = + """ target C; reactor Foo { @@ -373,16 +405,17 @@ public void connectionToEffectPort3() throws Exception { =} } """; - validator.assertNoErrors(parseWithoutError(testCase)); - } + validator.assertNoErrors(parseWithoutError(testCase)); + } - /** - * Allow connection to the port of a contained reactor if another port with same name is effect - * of a reaction. - */ - @Test - public void connectionToEffectPort3_5() throws Exception { - String testCase = """ + /** + * Allow connection to the port of a contained reactor if another port with same name is effect of + * a reaction. + */ + @Test + public void connectionToEffectPort3_5() throws Exception { + String testCase = + """ target C; reactor Foo { @@ -397,19 +430,23 @@ public void connectionToEffectPort3_5() throws Exception { =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getVariable(), null, - "Main reactor cannot have inputs."); - } - - /** - * Disallow connection to the port of a contained reactor if the same port is effect of a - * reaction. - */ - @Test - public void connectionToEffectPort4() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getVariable(), + null, + "Main reactor cannot have inputs."); + } + + /** + * Disallow connection to the port of a contained reactor if the same port is effect of a + * reaction. + */ + @Test + public void connectionToEffectPort4() throws Exception { + String testCase = + """ target C; - + reactor Foo { input in:int; } @@ -421,16 +458,18 @@ public void connectionToEffectPort4() throws Exception { =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, - "Cannot connect: Port named 'in' is already effect of a reaction."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getConnection(), + null, + "Cannot connect: Port named 'in' is already effect of a reaction."); + } - /** - * Disallow connection of multiple ports to the same input port. - */ - @Test - public void multipleConnectionsToInputTest() throws Exception { - String testCase = """ + /** Disallow connection of multiple ports to the same input port. */ + @Test + public void multipleConnectionsToInputTest() throws Exception { + String testCase = + """ target C; reactor Source { output out:int; @@ -446,32 +485,35 @@ public void multipleConnectionsToInputTest() throws Exception { src.out -> sink.in; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), null, - "Cannot connect: Port named 'in' may only appear once on the right side of a connection."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getConnection(), + null, + "Cannot connect: Port named 'in' may only appear once on the right side of a connection."); + } - /** - * Detect cycles in the instantiation graph. - */ - @Test - public void detectInstantiationCycle() throws Exception { - String testCase = """ + /** Detect cycles in the instantiation graph. */ + @Test + public void detectInstantiationCycle() throws Exception { + String testCase = + """ target C; reactor Contained { x = new Contained(); } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInstantiation(), - null, "Instantiation is part of a cycle: Contained"); - } - + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getInstantiation(), + null, + "Instantiation is part of a cycle: Contained"); + } - /** - * Detect cycles in the instantiation graph. - */ - @Test - public void detectInstantiationCycle2() throws Exception { - String testCase = """ + /** Detect cycles in the instantiation graph. */ + @Test + public void detectInstantiationCycle2() throws Exception { + String testCase = + """ target C; reactor Intermediate { x = new Contained(); @@ -481,20 +523,25 @@ public void detectInstantiationCycle2() throws Exception { } """; - Model model = parseWithoutError(testCase); - validator.assertError(model, LfPackage.eINSTANCE.getInstantiation(), - null, "Instantiation is part of a cycle: Intermediate, Contained."); - validator.assertError(model, LfPackage.eINSTANCE.getInstantiation(), - null, "Instantiation is part of a cycle: Intermediate, Contained."); - } + Model model = parseWithoutError(testCase); + validator.assertError( + model, + LfPackage.eINSTANCE.getInstantiation(), + null, + "Instantiation is part of a cycle: Intermediate, Contained."); + validator.assertError( + model, + LfPackage.eINSTANCE.getInstantiation(), + null, + "Instantiation is part of a cycle: Intermediate, Contained."); + } - /** - * Detect causality loop. - */ - @Test - public void detectCausalityLoop() throws Exception { + /** Detect causality loop. */ + @Test + public void detectCausalityLoop() throws Exception { - String testCase = """ + String testCase = + """ target C; reactor X { @@ -511,19 +558,24 @@ public void detectCausalityLoop() throws Exception { b.y -> a.x } """; - Model model = parseWithoutError(testCase); - validator.assertError(model, LfPackage.eINSTANCE.getReaction(), - null, "Reaction triggers involved in cyclic dependency in reactor X: x."); - validator.assertError(model, LfPackage.eINSTANCE.getReaction(), - null, "Reaction effects involved in cyclic dependency in reactor X: y."); - } - - /** - * Let cyclic dependencies be broken by "after" clauses. - */ - @Test - public void afterBreaksCycle() throws Exception { - String testCase = """ + Model model = parseWithoutError(testCase); + validator.assertError( + model, + LfPackage.eINSTANCE.getReaction(), + null, + "Reaction triggers involved in cyclic dependency in reactor X: x."); + validator.assertError( + model, + LfPackage.eINSTANCE.getReaction(), + null, + "Reaction effects involved in cyclic dependency in reactor X: y."); + } + + /** Let cyclic dependencies be broken by "after" clauses. */ + @Test + public void afterBreaksCycle() throws Exception { + String testCase = + """ target C reactor X { @@ -541,16 +593,14 @@ public void afterBreaksCycle() throws Exception { } """; - validator.assertNoErrors(parseWithoutError(testCase)); - } - + validator.assertNoErrors(parseWithoutError(testCase)); + } - /** - * Let cyclic dependencies be broken by "after" clauses with zero delay. - */ - @Test - public void afterBreaksCycle2() throws Exception { - String testCase = """ + /** Let cyclic dependencies be broken by "after" clauses with zero delay. */ + @Test + public void afterBreaksCycle2() throws Exception { + String testCase = + """ target C reactor X { @@ -567,16 +617,14 @@ public void afterBreaksCycle2() throws Exception { b.y -> a.x } """; - validator.assertNoErrors(parseWithoutError(testCase)); - } + validator.assertNoErrors(parseWithoutError(testCase)); + } - - /** - * Let cyclic dependencies be broken by "after" clauses with zero delay and no units. - */ - @Test - public void afterBreaksCycle3() throws Exception { - String testCase = """ + /** Let cyclic dependencies be broken by "after" clauses with zero delay and no units. */ + @Test + public void afterBreaksCycle3() throws Exception { + String testCase = + """ target C reactor X { @@ -593,15 +641,14 @@ public void afterBreaksCycle3() throws Exception { b.y -> a.x } """; - validator.assertNoErrors(parseWithoutError(testCase)); - } + validator.assertNoErrors(parseWithoutError(testCase)); + } - /** - * Detect missing units in "after" clauses with delay greater than zero. - */ - @Test - public void nonzeroAfterMustHaveUnits() throws Exception { - String testCase = """ + /** Detect missing units in "after" clauses with delay greater than zero. */ + @Test + public void nonzeroAfterMustHaveUnits() throws Exception { + String testCase = + """ target C reactor X { @@ -617,17 +664,18 @@ public void nonzeroAfterMustHaveUnits() throws Exception { a.y -> b.x after 1 } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getConnection(), - null, "Missing time unit."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getConnection(), + null, + "Missing time unit."); + } - - /** - * Report non-zero time value without units. - */ - @Test - public void nonZeroTimeValueWithoutUnits() throws Exception { - String testCase = """ + /** Report non-zero time value without units. */ + @Test + public void nonZeroTimeValueWithoutUnits() throws Exception { + String testCase = + """ target C; main reactor { timer t(42, 1 sec); @@ -636,15 +684,15 @@ public void nonZeroTimeValueWithoutUnits() throws Exception { =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, "Missing time unit."); - } + validator.assertError( + parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, "Missing time unit."); + } - /** - * Report reference to non-time parameter in time argument. - */ - @Test - public void parameterTypeMismatch() throws Exception { - String testCase = """ + /** Report reference to non-time parameter in time argument. */ + @Test + public void parameterTypeMismatch() throws Exception { + String testCase = + """ target C; main reactor (p:int(0)) { timer t(p, 1 sec); @@ -653,16 +701,18 @@ main reactor (p:int(0)) { =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), - null, "Referenced parameter is not of time type."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getTimer(), + null, + "Referenced parameter is not of time type."); + } - /** - * Report inappropriate literal in time argument. - */ - @Test - public void targetCodeInTimeArgument() throws Exception { - String testCase = """ + /** Report inappropriate literal in time argument. */ + @Test + public void targetCodeInTimeArgument() throws Exception { + String testCase = + """ target C; main reactor { timer t({=foo()=}, 1 sec); @@ -671,17 +721,15 @@ public void targetCodeInTimeArgument() throws Exception { =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), - null, "Invalid time value."); - } - + validator.assertError( + parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, "Invalid time value."); + } - /** - * Report overflowing deadline. - */ - @Test - public void overflowingDeadlineC() throws Exception { - String testCase = """ + /** Report overflowing deadline. */ + @Test + public void overflowingDeadlineC() throws Exception { + String testCase = + """ target C; main reactor { timer t; @@ -691,18 +739,18 @@ public void overflowingDeadlineC() throws Exception { =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getDeadline(), null, - "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + - " nanoseconds."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getDeadline(), + null, + "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); + } - - /** - * Report overflowing parameter. - */ - @Test - public void overflowingParameterC() throws Exception { - String testCase = """ + /** Report overflowing parameter. */ + @Test + public void overflowingParameterC() throws Exception { + String testCase = + """ target C; main reactor(d:time(40 hours)) { timer t; @@ -712,18 +760,20 @@ main reactor(d:time(40 hours)) { =} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getParameter(), null, - "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); - } - - - /** - * Report overflowing assignment. - */ - @Test - public void overflowingAssignmentC() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getParameter(), + null, + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + + " nanoseconds."); + } + + /** Report overflowing assignment. */ + @Test + public void overflowingAssignmentC() throws Exception { + String testCase = + """ target C; reactor Print(d:time(39 hours)) { timer t; @@ -736,17 +786,20 @@ reactor Print(d:time(39 hours)) { p = new Print(d=40 hours); } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAssignment(), null, - "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); - } - - /** - * Report missing trigger. - */ - @Test - public void missingTrigger() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getAssignment(), + null, + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + + " nanoseconds."); + } + + /** Report missing trigger. */ + @Test + public void missingTrigger() throws Exception { + String testCase = + """ target C; reactor X { reaction() {= @@ -754,112 +807,148 @@ public void missingTrigger() throws Exception { =} } """; - validator.assertWarning(parseWithoutError(testCase), LfPackage.eINSTANCE.getReaction(), null, - "Reaction has no trigger."); - } + validator.assertWarning( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReaction(), + null, + "Reaction has no trigger."); + } - /** - * Test warnings and errors for the target dependent preamble visibility qualifiers - */ - @Test - public void testPreambleVisibility() throws Exception { - for (Target target : Target.values()) { - for (Visibility visibility : Visibility.values()) { - Model model_reactor_scope = parseWithoutError(""" + /** Test warnings and errors for the target dependent preamble visibility qualifiers */ + @Test + public void testPreambleVisibility() throws Exception { + for (Target target : Target.values()) { + for (Visibility visibility : Visibility.values()) { + Model model_reactor_scope = + parseWithoutError( + """ target %s; reactor Foo { %spreamble {==} } - """.formatted(target, visibility != Visibility.NONE ? visibility + " " : "")); + """ + .formatted(target, visibility != Visibility.NONE ? visibility + " " : "")); - Model model_file_scope = parseWithoutError(""" + Model model_file_scope = + parseWithoutError( + """ target %s; %spreamble {==} reactor Foo { } - """.formatted(target, visibility != Visibility.NONE ? visibility + " " : "")); + """ + .formatted(target, visibility != Visibility.NONE ? visibility + " " : "")); - Model model_no_preamble = parseWithoutError(""" + Model model_no_preamble = + parseWithoutError( + """ target %s; reactor Foo { } - """.formatted(target)); - - validator.assertNoIssues(model_no_preamble); - - if (target == Target.CPP) { - if (visibility == Visibility.NONE) { - validator.assertError(model_file_scope, LfPackage.eINSTANCE.getPreamble(), null, - "Preambles for the C++ target need a visibility qualifier (private or public)!"); - validator.assertError(model_reactor_scope, LfPackage.eINSTANCE.getPreamble(), null, - "Preambles for the C++ target need a visibility qualifier (private or public)!"); - } else { - validator.assertNoIssues(model_file_scope); - validator.assertNoIssues(model_reactor_scope); - } - } else { - if (visibility == Visibility.NONE) { - validator.assertNoIssues(model_file_scope); - validator.assertNoIssues(model_reactor_scope); - } else { - validator.assertWarning(model_file_scope, LfPackage.eINSTANCE.getPreamble(), null, - String.format("The %s qualifier has no meaning for the %s target. It should be removed.", visibility, target.name())); - validator.assertWarning(model_reactor_scope, LfPackage.eINSTANCE.getPreamble(), null, - String.format("The %s qualifier has no meaning for the %s target. It should be removed.", visibility, target.name())); - } - } - } + """ + .formatted(target)); + + validator.assertNoIssues(model_no_preamble); + + if (target == Target.CPP) { + if (visibility == Visibility.NONE) { + validator.assertError( + model_file_scope, + LfPackage.eINSTANCE.getPreamble(), + null, + "Preambles for the C++ target need a visibility qualifier (private or public)!"); + validator.assertError( + model_reactor_scope, + LfPackage.eINSTANCE.getPreamble(), + null, + "Preambles for the C++ target need a visibility qualifier (private or public)!"); + } else { + validator.assertNoIssues(model_file_scope); + validator.assertNoIssues(model_reactor_scope); + } + } else { + if (visibility == Visibility.NONE) { + validator.assertNoIssues(model_file_scope); + validator.assertNoIssues(model_reactor_scope); + } else { + validator.assertWarning( + model_file_scope, + LfPackage.eINSTANCE.getPreamble(), + null, + String.format( + "The %s qualifier has no meaning for the %s target. It should be removed.", + visibility, target.name())); + validator.assertWarning( + model_reactor_scope, + LfPackage.eINSTANCE.getPreamble(), + null, + String.format( + "The %s qualifier has no meaning for the %s target. It should be removed.", + visibility, target.name())); + } } + } } + } - @Test - public void testInheritanceSupport() throws Exception { - for (Target target : Target.values()) { - Model model = parseWithoutError(""" + @Test + public void testInheritanceSupport() throws Exception { + for (Target target : Target.values()) { + Model model = + parseWithoutError( + """ target %s reactor A{} reactor B extends A{} - """.formatted(target)); - - if (target.supportsInheritance()) { - validator.assertNoIssues(model); - } else { - validator.assertError(model, LfPackage.eINSTANCE.getReactor(), null, - "The " + target.getDisplayName() + " target does not support reactor inheritance."); - } - } + """ + .formatted(target)); + + if (target.supportsInheritance()) { + validator.assertNoIssues(model); + } else { + validator.assertError( + model, + LfPackage.eINSTANCE.getReactor(), + null, + "The " + target.getDisplayName() + " target does not support reactor inheritance."); + } } + } - @Test - public void testFederationSupport() throws Exception { - for (Target target : Target.values()) { - Model model = parseWithoutError(""" + @Test + public void testFederationSupport() throws Exception { + for (Target target : Target.values()) { + Model model = + parseWithoutError( + """ target %s federated reactor {} - """.formatted(target)); - - if (target.supportsFederated()) { - validator.assertNoIssues(model); - } else { - validator.assertError(model, LfPackage.eINSTANCE.getReactor(), null, - "The " + target.getDisplayName() + " target does not support federated execution."); - } - } + """ + .formatted(target)); + + if (target.supportsFederated()) { + validator.assertNoIssues(model); + } else { + validator.assertError( + model, + LfPackage.eINSTANCE.getReactor(), + null, + "The " + target.getDisplayName() + " target does not support federated execution."); + } } + } - - /** - * Tests for state and parameter declarations, including native lists. - */ - @Test - public void stateAndParameterDeclarationsInC() throws Exception { - String testCase = """ + /** Tests for state and parameter declarations, including native lists. */ + @Test + public void stateAndParameterDeclarationsInC() throws Exception { + String testCase = + """ target C; reactor Bar(a(0), // ERROR: type missing b:int, // ERROR: uninitialized t:time = 42, // ERROR: units missing x:int = 0, - h:time = "bla", // ERROR: not a type + h:time = "bla", // ERROR: not a type q:time(1 msec, 2 msec), // ERROR: not a list y:int = t // ERROR: init using parameter ) { @@ -870,878 +959,1039 @@ reactor Bar(a(0), // ERROR: type missing } """; - Model model = parseWithoutError(testCase); - - - validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null, - "Type declaration missing."); - validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null, - "Parameter must have a default value."); - validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null, - "Missing time unit."); - validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null, - "Invalid time value."); - validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null, - "Expected exactly one time value."); - validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null, - "Parameter cannot be initialized using parameter."); - validator.assertError(model, LfPackage.eINSTANCE.getStateVar(), null, - "Missing time unit."); - validator.assertError(model, LfPackage.eINSTANCE.getStateVar(), null, - "Referenced parameter is not of time type."); - validator.assertError(model, LfPackage.eINSTANCE.getStateVar(), null, - "Invalid time value."); - validator.assertError(model, LfPackage.eINSTANCE.getTimer(), null, - "Missing time unit."); - } - - - /** - * Recognize valid IPV4 addresses, report invalid ones. - */ - @Test - public void recognizeIPV4() throws Exception { - List correct = List.of("127.0.0.1", "10.0.0.1", "192.168.1.1", "0.0.0.0", "192.168.1.1"); - List parseError = List.of("10002.3.4", "1.2.3.4.5"); - List validationError = List.of("256.0.0.0", "260.0.0.0"); - - // Correct IP addresses. - for (String addr : correct) { - - String testCase = """ + Model model = parseWithoutError(testCase); + + validator.assertError( + model, LfPackage.eINSTANCE.getParameter(), null, "Type declaration missing."); + validator.assertError( + model, LfPackage.eINSTANCE.getParameter(), null, "Parameter must have a default value."); + validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null, "Missing time unit."); + validator.assertError(model, LfPackage.eINSTANCE.getParameter(), null, "Invalid time value."); + validator.assertError( + model, LfPackage.eINSTANCE.getParameter(), null, "Expected exactly one time value."); + validator.assertError( + model, + LfPackage.eINSTANCE.getParameter(), + null, + "Parameter cannot be initialized using parameter."); + validator.assertError(model, LfPackage.eINSTANCE.getStateVar(), null, "Missing time unit."); + validator.assertError( + model, + LfPackage.eINSTANCE.getStateVar(), + null, + "Referenced parameter is not of time type."); + validator.assertError(model, LfPackage.eINSTANCE.getStateVar(), null, "Invalid time value."); + validator.assertError(model, LfPackage.eINSTANCE.getTimer(), null, "Missing time unit."); + } + + /** Recognize valid IPV4 addresses, report invalid ones. */ + @Test + public void recognizeIPV4() throws Exception { + List correct = + List.of("127.0.0.1", "10.0.0.1", "192.168.1.1", "0.0.0.0", "192.168.1.1"); + List parseError = List.of("10002.3.4", "1.2.3.4.5"); + List validationError = List.of("256.0.0.0", "260.0.0.0"); + + // Correct IP addresses. + for (String addr : correct) { + + String testCase = + """ target C; reactor Y {} federated reactor X at foo@%s:4242 { - y = new Y() at %s:2424; + y = new Y() at %s:2424; } - """.formatted(addr, addr); - parseWithoutError( - testCase - ); - } + """ + .formatted(addr, addr); + parseWithoutError(testCase); + } - // IP addresses that don't parse. - for (String addr : parseError) { - String testCase = """ + // IP addresses that don't parse. + for (String addr : parseError) { + String testCase = + """ target C; reactor Y {} federated reactor X at foo@%s:4242 { - y = new Y() at %s:2424; + y = new Y() at %s:2424; } - """.formatted(addr, addr); - parseWithError(testCase); - } + """ + .formatted(addr, addr); + parseWithError(testCase); + } - // IP addresses that parse but are invalid. - for (String addr : validationError) { - Model model = parseWithoutError(""" + // IP addresses that parse but are invalid. + for (String addr : validationError) { + Model model = + parseWithoutError( + """ target C; reactor Y {} federated reactor X at foo@%s:4242 { - y = new Y() at %s:2424; + y = new Y() at %s:2424; } - """.formatted(addr, addr)); - validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, "Invalid IP address."); - } - } - - /** - * Recognize valid IPV6 addresses, report invalid ones. - */ - @Test - public void recognizeIPV6() throws Exception { - List correct = List.of("1:2:3:4:5:6:7:8", "1:2:3:4:5:6:7::", "1:2:3:4:5:6::8", - "1:2:3:4:5::8", "1:2:3:4::8", "1:2:3::8", "1:2::8", "1::8", "::8", - "::", "1::3:4:5:6:7:8", "1::4:5:6:7:8", "1::5:6:7:8", "1::6:7:8", - "1::7:8", "1::8", "1::", "1:2:3:4:5::7:8", "1:2:3:4::6:7:8", - "1:2:3::5:6:7:8", "1:2::4:5:6:7:8", "1::3:4:5:6:7:8", - "::2:3:4:5:6:7:8", "fe80::7:8", "fe80::7:8%eth0", "fe80::7:8%1", - "::255.255.255.255", "::ffff:255.255.255.255", - "::ffff:0:255.255.255.0", "::ffff:00:255.255.255.0", - "::ffff:000:255.255.255.0", "::ffff:0000:255.255.255.0", - "::ffff:0.0.0.0", "::ffff:1.2.3.4", "::ffff:10.0.0.1", - "1:2:3:4:5:6:77:88", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", - "2001:db8:3:4::192.0.2.33", "64:ff9b::192.0.2.33", "0:0:0:0:0:0:10.0.0.1"); - - List validationError = List.of("1:2:3:4:5:6:7:8:9", "1:2:3:4:5:6::7:8", - "1:2:3:4:5:6:7:8:", "::1:2:3:4:5:6:7:8", "1:2:3:4:5:6:7:8::", - "1:2:3:4:5:6:7:88888", "2001:db8:3:4:5::192.0.2.33", - "fe08::7:8interface", "fe08::7:8interface", "fe08::7:8i"); - - List parseError = List.of("fe08::7:8%", ":1:2:3:4:5:6:7:8"); - - // Correct IP addresses. - for (String addr : correct) { - String testCase = """ + """ + .formatted(addr, addr)); + validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, "Invalid IP address."); + } + } + + /** Recognize valid IPV6 addresses, report invalid ones. */ + @Test + public void recognizeIPV6() throws Exception { + List correct = + List.of( + "1:2:3:4:5:6:7:8", + "1:2:3:4:5:6:7::", + "1:2:3:4:5:6::8", + "1:2:3:4:5::8", + "1:2:3:4::8", + "1:2:3::8", + "1:2::8", + "1::8", + "::8", + "::", + "1::3:4:5:6:7:8", + "1::4:5:6:7:8", + "1::5:6:7:8", + "1::6:7:8", + "1::7:8", + "1::8", + "1::", + "1:2:3:4:5::7:8", + "1:2:3:4::6:7:8", + "1:2:3::5:6:7:8", + "1:2::4:5:6:7:8", + "1::3:4:5:6:7:8", + "::2:3:4:5:6:7:8", + "fe80::7:8", + "fe80::7:8%eth0", + "fe80::7:8%1", + "::255.255.255.255", + "::ffff:255.255.255.255", + "::ffff:0:255.255.255.0", + "::ffff:00:255.255.255.0", + "::ffff:000:255.255.255.0", + "::ffff:0000:255.255.255.0", + "::ffff:0.0.0.0", + "::ffff:1.2.3.4", + "::ffff:10.0.0.1", + "1:2:3:4:5:6:77:88", + "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", + "2001:db8:3:4::192.0.2.33", + "64:ff9b::192.0.2.33", + "0:0:0:0:0:0:10.0.0.1"); + + List validationError = + List.of( + "1:2:3:4:5:6:7:8:9", + "1:2:3:4:5:6::7:8", + "1:2:3:4:5:6:7:8:", + "::1:2:3:4:5:6:7:8", + "1:2:3:4:5:6:7:8::", + "1:2:3:4:5:6:7:88888", + "2001:db8:3:4:5::192.0.2.33", + "fe08::7:8interface", + "fe08::7:8interface", + "fe08::7:8i"); + + List parseError = List.of("fe08::7:8%", ":1:2:3:4:5:6:7:8"); + + // Correct IP addresses. + for (String addr : correct) { + String testCase = + """ target C; reactor Y {} federated reactor at [foo@%s]:4242 { - y = new Y() at [%s]:2424; + y = new Y() at [%s]:2424; } - """.formatted(addr, addr); - Model model = parseWithoutError(testCase); - validator.assertNoIssues(model); - } - + """ + .formatted(addr, addr); + Model model = parseWithoutError(testCase); + validator.assertNoIssues(model); + } - // IP addresses that don't parse. - for (String addr : parseError) { - String testCase = """ + // IP addresses that don't parse. + for (String addr : parseError) { + String testCase = + """ target C; reactor Y {} federated reactor X at [foo@%s]:4242 { - y = new Y() at [%s]:2424; + y = new Y() at [%s]:2424; } - """.formatted(addr, addr); - parseWithError(testCase); - } + """ + .formatted(addr, addr); + parseWithError(testCase); + } - // IP addresses that parse but are invalid. - for (String addr : validationError) { - String testCase = """ + // IP addresses that parse but are invalid. + for (String addr : validationError) { + String testCase = + """ target C; reactor Y {} federated reactor X at [foo@%s]:4242 { - y = new Y() at [%s]:2424; + y = new Y() at [%s]:2424; } - """.formatted(addr, addr); - Model model = parseWithoutError( - testCase - ); - validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, "Invalid IP address."); - } + """ + .formatted(addr, addr); + Model model = parseWithoutError(testCase); + validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, "Invalid IP address."); } + } - /** - * Recognize valid host names and fully qualified names, report invalid ones. - */ - @Test - public void recognizeHostNames() throws Exception { - - List correct = List.of("localhost"); // FIXME: add more + /** Recognize valid host names and fully qualified names, report invalid ones. */ + @Test + public void recognizeHostNames() throws Exception { - List validationError = List.of("x.y.z"); // FIXME: add more + List correct = List.of("localhost"); // FIXME: add more - List parseError = List.of("..xyz"); // FIXME: add more + List validationError = List.of("x.y.z"); // FIXME: add more + List parseError = List.of("..xyz"); // FIXME: add more - // Correct names. - for (String addr : correct) { - String testCase = """ + // Correct names. + for (String addr : correct) { + String testCase = + """ target C; reactor Y {} federated reactor X at foo@%s:4242 { - y = new Y() at %s:2424; + y = new Y() at %s:2424; } - """.formatted(addr, addr); - parseWithoutError( - testCase - ); - } + """ + .formatted(addr, addr); + parseWithoutError(testCase); + } - // Names that don't parse. - for (String addr : parseError) { - String testCase = """ + // Names that don't parse. + for (String addr : parseError) { + String testCase = + """ target C; reactor Y {} federated reactor X at foo@%s:4242 { - y = new Y() at %s:2424; + y = new Y() at %s:2424; } - """.formatted(addr, addr); - parseWithError( - testCase - ); - } + """ + .formatted(addr, addr); + parseWithError(testCase); + } - // Names that parse but are invalid. - for (String addr : validationError) { - String testCase = """ + // Names that parse but are invalid. + for (String addr : validationError) { + String testCase = + """ target C; reactor Y {} federated reactor X at foo@%s:4242 { - y = new Y() at %s:2424; + y = new Y() at %s:2424; } - """.formatted(addr, addr); - Model model = parseWithoutError( - testCase - ); - validator.assertWarning(model, LfPackage.eINSTANCE.getHost(), null, - "Invalid host name or fully qualified domain name."); - } - } - - /** - * Maps a type to a list of known good values. - */ - Map> primitiveTypeToKnownGood = Map.of( - PrimitiveType.BOOLEAN, List.of("true", "\"true\"", "false", "\"false\""), - PrimitiveType.INTEGER, List.of("0", "1", "\"42\"", "\"-1\"", "-2"), - PrimitiveType.NON_NEGATIVE_INTEGER, List.of("0", "1", "42"), - PrimitiveType.TIME_VALUE, List.of("1 msec", "2 sec"), - PrimitiveType.STRING, List.of("1", "\"foo\"", "bar"), - PrimitiveType.FILE, List.of("valid.file", "something.json", "\"foobar.proto\"") - ); - - /** - * Maps a type to a list of known bad values. - */ - Map> primitiveTypeToKnownBad = Map.of( - PrimitiveType.BOOLEAN, List.of("1 sec", "foo", "\"foo\"", "[1]", "{baz: 42}", "'c'"), - PrimitiveType.INTEGER, List.of("foo", "\"bar\"", "1 sec", "[1, 2]", "{foo: \"bar\"}", "'c'"), - PrimitiveType.NON_NEGATIVE_INTEGER, List.of("-42", "foo", "\"bar\"", "1 sec", "[1, 2]", "{foo: \"bar\"}", "'c'"), - PrimitiveType.TIME_VALUE, List.of("foo", "\"bar\"", "\"3 sec\"", "\"4 weeks\"", "[1, 2]", "{foo: \"bar\"}", "'c'"), - PrimitiveType.STRING, List.of("1 msec", "[1, 2]", "{foo: \"bar\"}", "'c'") - ); - - /** - * Maps a type to a list, each entry of which represents a list with - * three entries: a known wrong value, the suffix to add to the reported - * name, and the type that it should be. - */ - Map>> compositeTypeToKnownBad = Map.of( - ArrayType.STRING_ARRAY, List.of( - List.of("[1 msec]", "[0]", PrimitiveType.STRING), - List.of("[foo, {bar: baz}]", "[1]", PrimitiveType.STRING), - List.of("{bar: baz}", "", ArrayType.STRING_ARRAY) - ), - UnionType.STRING_OR_STRING_ARRAY, List.of( - List.of("[1 msec]", "[0]", PrimitiveType.STRING), - List.of("[foo, {bar: baz}]", "[1]", PrimitiveType.STRING), - List.of("{bar: baz}", "", UnionType.STRING_OR_STRING_ARRAY) - ), - UnionType.PLATFORM_STRING_OR_DICTIONARY, List.of( - List.of("[bar, baz]", "", UnionType.PLATFORM_STRING_OR_DICTIONARY), - List.of("{name: [1, 2, 3]}", ".name", PrimitiveType.STRING), - List.of("{name: {bar: baz}}", ".name", PrimitiveType.STRING), - List.of("{board: [1, 2, 3]}", ".board", PrimitiveType.STRING), - List.of("{board: {bar: baz}}", ".board", PrimitiveType.STRING), - List.of("{baud-rate: [1, 2, 3]}", ".baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER), - List.of("{baud-rate: {bar: baz}}", ".baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER) - ), - UnionType.FILE_OR_FILE_ARRAY, List.of( - List.of("[1 msec]", "[0]", PrimitiveType.FILE), - List.of("[foo, {bar: baz}]", "[1]", PrimitiveType.FILE), - List.of("{bar: baz}", "", UnionType.FILE_OR_FILE_ARRAY) - ), - UnionType.DOCKER_UNION, List.of( - List.of("foo", "", UnionType.DOCKER_UNION), - List.of("[1]", "", UnionType.DOCKER_UNION), - List.of("{bar: baz}", "", DictionaryType.DOCKER_DICT), - List.of("{FROM: [1, 2, 3]}", ".FROM", PrimitiveType.STRING) - ), - UnionType.TRACING_UNION, List.of( - List.of("foo", "", UnionType.TRACING_UNION), - List.of("[1]", "", UnionType.TRACING_UNION), - List.of("{bar: baz}", "", DictionaryType.TRACING_DICT), - List.of("{trace-file-name: [1, 2, 3]}", ".trace-file-name", PrimitiveType.STRING) - ) - ); - - /** - * Given an array type, return a list of good or bad examples, - * depending on the value of the second parameter. - */ - private List synthesizeExamples(ArrayType type, boolean correct) { - Map> values = correct ? primitiveTypeToKnownGood - : primitiveTypeToKnownBad; - List examples = new LinkedList<>(); - if (correct) { - // Produce an array that has an entry for each value. - List entries = values.get(type.type); - if (!(entries == null || entries.isEmpty())) { - examples.add(String.format("[%s]", String.join(", ", entries))); - } - } - return examples; - } - - /** - * Given an union type, return a list of good or bad examples, - * depending on the value of the second parameter. - */ - private List synthesizeExamples(UnionType type, boolean correct) { - List examples = new LinkedList<>(); - if (correct) { - for (Enum it : type.options) { - if (it instanceof TargetPropertyType) { - synthesizeExamples((TargetPropertyType) it, correct).forEach(ex -> examples.add(ex)); - } else { - examples.add(it.toString()); - } - } - } else { - // Return some obviously bad examples for the common - // case where the options are from an ordinary Enum. - if (!type.options.stream().anyMatch(it -> it instanceof TargetPropertyType)) { - return List.of("foo", "\"bar\"", "1", "-1", "{x: 42}", "[1, 2, 3]"); - } - } - return examples; - } - - /** - * Given an union type, return a list of good or bad examples, - * depending on the value of the second parameter. - */ - private List synthesizeExamples(DictionaryType type, boolean correct) { - List examples = new LinkedList<>(); - // Produce a set of singleton dictionaries. - // If incorrect examples are wanted, garble the key. - for (DictionaryElement option : type.options) { - synthesizeExamples(option.getType(), correct).forEach(it -> examples.add( - "{" + option + (!correct ? "iamwrong: " : ": ") + it + "}")); - } - return examples; - } - - private List synthesizeExamples(StringDictionaryType type, boolean correct) { - List examples = new LinkedList<>(); - // Produce a set of singleton dictionaries. - // If incorrect examples are wanted, use non-strings for values. - List goodStrs = synthesizeExamples(PrimitiveType.STRING, true); - List badStrs = synthesizeExamples(PrimitiveType.STRING, false); - List goodIDs = List.of("foo", "Bar", "__ab0_9fC", "f1o_O2B_a3r"); - if (correct) { - for (String gs : goodStrs) { - goodIDs.forEach(it -> examples.add("{" + it + ": " + gs + "}")); - } - } else { - for (String bs : badStrs) { - goodIDs.forEach(it -> examples.add("{" + it + ": " + bs + "}")); - } - } - return examples; - } - - /** - * Synthesize a list of values that either conform to the given type or - * do not, depending on whether the second argument 'correct' is true. - * Return an empty set if it is too complicated to generate examples - * (e.g., because the resulting errors are more sophisticated). - *

    - * Not all cases are covered by this function. Currently, the only cases not - * covered are known bad examples for composite types, which should be added - * to the compositeTypeToKnownBad map. - * - * @param correct True to synthesize correct examples automatically, otherwise - * synthesize incorrect examples. - */ - private List synthesizeExamples(TargetPropertyType type, boolean correct) { - if (type instanceof PrimitiveType) { - Map> values = correct ? primitiveTypeToKnownGood - : primitiveTypeToKnownBad; - List examples = values.get(type); - Assertions.assertNotNull(examples); - return examples; + """ + .formatted(addr, addr); + Model model = parseWithoutError(testCase); + validator.assertWarning( + model, + LfPackage.eINSTANCE.getHost(), + null, + "Invalid host name or fully qualified domain name."); + } + } + + /** Maps a type to a list of known good values. */ + Map> primitiveTypeToKnownGood = + Map.of( + PrimitiveType.BOOLEAN, List.of("true", "\"true\"", "false", "\"false\""), + PrimitiveType.INTEGER, List.of("0", "1", "\"42\"", "\"-1\"", "-2"), + PrimitiveType.NON_NEGATIVE_INTEGER, List.of("0", "1", "42"), + PrimitiveType.TIME_VALUE, List.of("1 msec", "2 sec"), + PrimitiveType.STRING, List.of("1", "\"foo\"", "bar"), + PrimitiveType.FILE, List.of("valid.file", "something.json", "\"foobar.proto\"")); + + /** Maps a type to a list of known bad values. */ + Map> primitiveTypeToKnownBad = + Map.of( + PrimitiveType.BOOLEAN, List.of("1 sec", "foo", "\"foo\"", "[1]", "{baz: 42}", "'c'"), + PrimitiveType.INTEGER, + List.of("foo", "\"bar\"", "1 sec", "[1, 2]", "{foo: \"bar\"}", "'c'"), + PrimitiveType.NON_NEGATIVE_INTEGER, + List.of("-42", "foo", "\"bar\"", "1 sec", "[1, 2]", "{foo: \"bar\"}", "'c'"), + PrimitiveType.TIME_VALUE, + List.of( + "foo", "\"bar\"", "\"3 sec\"", "\"4 weeks\"", "[1, 2]", "{foo: \"bar\"}", "'c'"), + PrimitiveType.STRING, List.of("1 msec", "[1, 2]", "{foo: \"bar\"}", "'c'")); + + /** + * Maps a type to a list, each entry of which represents a list with three entries: a known wrong + * value, the suffix to add to the reported name, and the type that it should be. + */ + Map>> compositeTypeToKnownBad = + Map.of( + ArrayType.STRING_ARRAY, + List.of( + List.of("[1 msec]", "[0]", PrimitiveType.STRING), + List.of("[foo, {bar: baz}]", "[1]", PrimitiveType.STRING), + List.of("{bar: baz}", "", ArrayType.STRING_ARRAY)), + UnionType.STRING_OR_STRING_ARRAY, + List.of( + List.of("[1 msec]", "[0]", PrimitiveType.STRING), + List.of("[foo, {bar: baz}]", "[1]", PrimitiveType.STRING), + List.of("{bar: baz}", "", UnionType.STRING_OR_STRING_ARRAY)), + UnionType.PLATFORM_STRING_OR_DICTIONARY, + List.of( + List.of("[bar, baz]", "", UnionType.PLATFORM_STRING_OR_DICTIONARY), + List.of("{name: [1, 2, 3]}", ".name", PrimitiveType.STRING), + List.of("{name: {bar: baz}}", ".name", PrimitiveType.STRING), + List.of("{board: [1, 2, 3]}", ".board", PrimitiveType.STRING), + List.of("{board: {bar: baz}}", ".board", PrimitiveType.STRING), + List.of( + "{baud-rate: [1, 2, 3]}", ".baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER), + List.of( + "{baud-rate: {bar: baz}}", ".baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER)), + UnionType.FILE_OR_FILE_ARRAY, + List.of( + List.of("[1 msec]", "[0]", PrimitiveType.FILE), + List.of("[foo, {bar: baz}]", "[1]", PrimitiveType.FILE), + List.of("{bar: baz}", "", UnionType.FILE_OR_FILE_ARRAY)), + UnionType.DOCKER_UNION, + List.of( + List.of("foo", "", UnionType.DOCKER_UNION), + List.of("[1]", "", UnionType.DOCKER_UNION), + List.of("{bar: baz}", "", DictionaryType.DOCKER_DICT), + List.of("{FROM: [1, 2, 3]}", ".FROM", PrimitiveType.STRING)), + UnionType.TRACING_UNION, + List.of( + List.of("foo", "", UnionType.TRACING_UNION), + List.of("[1]", "", UnionType.TRACING_UNION), + List.of("{bar: baz}", "", DictionaryType.TRACING_DICT), + List.of( + "{trace-file-name: [1, 2, 3]}", ".trace-file-name", PrimitiveType.STRING))); + + /** + * Given an array type, return a list of good or bad examples, depending on the value of the + * second parameter. + */ + private List synthesizeExamples(ArrayType type, boolean correct) { + Map> values = + correct ? primitiveTypeToKnownGood : primitiveTypeToKnownBad; + List examples = new LinkedList<>(); + if (correct) { + // Produce an array that has an entry for each value. + List entries = values.get(type.type); + if (!(entries == null || entries.isEmpty())) { + examples.add(String.format("[%s]", String.join(", ", entries))); + } + } + return examples; + } + + /** + * Given an union type, return a list of good or bad examples, depending on the value of the + * second parameter. + */ + private List synthesizeExamples(UnionType type, boolean correct) { + List examples = new LinkedList<>(); + if (correct) { + for (Enum it : type.options) { + if (it instanceof TargetPropertyType) { + synthesizeExamples((TargetPropertyType) it, correct).forEach(ex -> examples.add(ex)); } else { - if (type instanceof UnionType) { - return synthesizeExamples((UnionType) type, correct); - } else if (type instanceof ArrayType) { - return synthesizeExamples((ArrayType) type, correct); - } else if (type instanceof DictionaryType) { - return synthesizeExamples((DictionaryType) type, correct); - } else if (type instanceof StringDictionaryType) { - return synthesizeExamples((StringDictionaryType) type, correct); - } else { - Assertions.fail("Encountered an unknown type: " + type); - } + examples.add(it.toString()); } - return new LinkedList<>(); - } - - /** - * Create an LF program with the given key and value as a target property, - * parse it, and return the resulting model. - */ - private Model createModel(TargetProperty key, String value) throws Exception { - String target = key.supportedBy.get(0).getDisplayName(); - System.out.printf("%s: %s%n", key, value); - return parseWithoutError(""" + } + } else { + // Return some obviously bad examples for the common + // case where the options are from an ordinary Enum. + if (!type.options.stream().anyMatch(it -> it instanceof TargetPropertyType)) { + return List.of("foo", "\"bar\"", "1", "-1", "{x: 42}", "[1, 2, 3]"); + } + } + return examples; + } + + /** + * Given an union type, return a list of good or bad examples, depending on the value of the + * second parameter. + */ + private List synthesizeExamples(DictionaryType type, boolean correct) { + List examples = new LinkedList<>(); + // Produce a set of singleton dictionaries. + // If incorrect examples are wanted, garble the key. + for (DictionaryElement option : type.options) { + synthesizeExamples(option.getType(), correct) + .forEach(it -> examples.add("{" + option + (!correct ? "iamwrong: " : ": ") + it + "}")); + } + return examples; + } + + private List synthesizeExamples(StringDictionaryType type, boolean correct) { + List examples = new LinkedList<>(); + // Produce a set of singleton dictionaries. + // If incorrect examples are wanted, use non-strings for values. + List goodStrs = synthesizeExamples(PrimitiveType.STRING, true); + List badStrs = synthesizeExamples(PrimitiveType.STRING, false); + List goodIDs = List.of("foo", "Bar", "__ab0_9fC", "f1o_O2B_a3r"); + if (correct) { + for (String gs : goodStrs) { + goodIDs.forEach(it -> examples.add("{" + it + ": " + gs + "}")); + } + } else { + for (String bs : badStrs) { + goodIDs.forEach(it -> examples.add("{" + it + ": " + bs + "}")); + } + } + return examples; + } + + /** + * Synthesize a list of values that either conform to the given type or do not, depending on + * whether the second argument 'correct' is true. Return an empty set if it is too complicated to + * generate examples (e.g., because the resulting errors are more sophisticated). + * + *

    Not all cases are covered by this function. Currently, the only cases not covered are known + * bad examples for composite types, which should be added to the compositeTypeToKnownBad map. + * + * @param correct True to synthesize correct examples automatically, otherwise synthesize + * incorrect examples. + */ + private List synthesizeExamples(TargetPropertyType type, boolean correct) { + if (type instanceof PrimitiveType) { + Map> values = + correct ? primitiveTypeToKnownGood : primitiveTypeToKnownBad; + List examples = values.get(type); + Assertions.assertNotNull(examples); + return examples; + } else { + if (type instanceof UnionType) { + return synthesizeExamples((UnionType) type, correct); + } else if (type instanceof ArrayType) { + return synthesizeExamples((ArrayType) type, correct); + } else if (type instanceof DictionaryType) { + return synthesizeExamples((DictionaryType) type, correct); + } else if (type instanceof StringDictionaryType) { + return synthesizeExamples((StringDictionaryType) type, correct); + } else { + Assertions.fail("Encountered an unknown type: " + type); + } + } + return new LinkedList<>(); + } + + /** + * Create an LF program with the given key and value as a target property, parse it, and return + * the resulting model. + */ + private Model createModel(TargetProperty key, String value) throws Exception { + String target = key.supportedBy.get(0).getDisplayName(); + System.out.printf("%s: %s%n", key, value); + return parseWithoutError( + """ target %s {%s: %s}; reactor Y {} main reactor { - y = new Y() - } - """.formatted(target, key, value)); - } - - /** - * Perform checks on target properties. - */ - @Test - public void checkTargetProperties() throws Exception { - for (TargetProperty prop : TargetProperty.getOptions()) { - if (prop == TargetProperty.CARGO_DEPENDENCIES) { - // we test that separately as it has better error messages - return; - } - System.out.printf("Testing target property %s which is %s%n", prop, prop.type); - System.out.println("===="); - System.out.println("Known good assignments:"); - List knownCorrect = synthesizeExamples(prop.type, true); - - for (String it : knownCorrect) { - Model model = createModel(prop, it); - validator.assertNoErrors(model); - // Also make sure warnings are produced when files are not present. - if (prop.type == PrimitiveType.FILE) { - validator.assertWarning(model, LfPackage.eINSTANCE.getKeyValuePair(), - null, String.format("Could not find file: '%s'.", StringUtil.removeQuotes(it))); - } - } - - // Extra checks for filenames. (This piece of code was commented out in the original xtend file) - // Temporarily disabled because we need a more sophisticated check that looks for files in different places. -// if (prop.type == prop.type == ArrayType.FILE_ARRAY || -// prop.type == UnionType.FILE_OR_FILE_ARRAY) { -// val model = prop.createModel( -// synthesizeExamples(ArrayType.FILE_ARRAY, true).get(0)) -// primitiveTypeToKnownGood.get(PrimitiveType.FILE).forEach [ -// model.assertWarning( -// LfPackage.eINSTANCE.keyValuePair, -// null, '''Could not find file: '«it.withoutQuotes»'.''') -// ] -// } - - System.out.println("Known bad assignments:"); - List knownIncorrect = synthesizeExamples(prop.type, false); - if (!(knownIncorrect == null || knownIncorrect.isEmpty())) { - for (String it : knownIncorrect) { - if (prop.type instanceof StringDictionaryType) { - validator.assertError(createModel(prop, it), - LfPackage.eINSTANCE.getKeyValuePair(), null, - String.format("Target property '%s.", prop), "' is required to be a string."); - } else { - validator.assertError(createModel(prop, it), - LfPackage.eINSTANCE.getKeyValuePair(), null, - String.format("Target property '%s' is required to be %s.", prop, prop.type)); - } - } - } else { - // No type was synthesized. It must be a composite type. - List> list = compositeTypeToKnownBad.get(prop.type); - if (list == null) { - System.out.printf("No known incorrect values provided for target property '%s'. Aborting test.%n", prop); - Assertions.fail(); - } else { - for (List it : list) { - validator.assertError(createModel(prop, it.get(0).toString()), - LfPackage.eINSTANCE.getKeyValuePair(), null, - String.format("Target property '%s%s' is required to be %s.", prop, it.get(1), it.get(2))); - } - } - } - System.out.println("===="); + y = new Y() + } + """ + .formatted(target, key, value)); + } + + /** Perform checks on target properties. */ + @Test + public void checkTargetProperties() throws Exception { + for (TargetProperty prop : TargetProperty.getOptions()) { + if (prop == TargetProperty.CARGO_DEPENDENCIES) { + // we test that separately as it has better error messages + return; + } + System.out.printf("Testing target property %s which is %s%n", prop, prop.type); + System.out.println("===="); + System.out.println("Known good assignments:"); + List knownCorrect = synthesizeExamples(prop.type, true); + + for (String it : knownCorrect) { + Model model = createModel(prop, it); + validator.assertNoErrors(model); + // Also make sure warnings are produced when files are not present. + if (prop.type == PrimitiveType.FILE) { + validator.assertWarning( + model, + LfPackage.eINSTANCE.getKeyValuePair(), + null, + String.format("Could not find file: '%s'.", StringUtil.removeQuotes(it))); } - System.out.println("Done!"); - } - - - @Test - public void checkCargoDependencyProperty() throws Exception { - TargetProperty prop = TargetProperty.CARGO_DEPENDENCIES; - List knownCorrect = List.of("{}", "{ dep: \"8.2\" }", "{ dep: { version: \"8.2\"} }", "{ dep: { version: \"8.2\", features: [\"foo\"]} }"); - for (String it : knownCorrect) { - validator.assertNoErrors(createModel(prop, it)); + } + + // Extra checks for filenames. (This piece of code was commented out in the original xtend + // file) + // Temporarily disabled because we need a more sophisticated check that looks for files in + // different places. + // if (prop.type == prop.type == ArrayType.FILE_ARRAY || + // prop.type == UnionType.FILE_OR_FILE_ARRAY) { + // val model = prop.createModel( + // synthesizeExamples(ArrayType.FILE_ARRAY, true).get(0)) + // primitiveTypeToKnownGood.get(PrimitiveType.FILE).forEach [ + // model.assertWarning( + // LfPackage.eINSTANCE.keyValuePair, + // null, '''Could not find file: '«it.withoutQuotes»'.''') + // ] + // } + + System.out.println("Known bad assignments:"); + List knownIncorrect = synthesizeExamples(prop.type, false); + if (!(knownIncorrect == null || knownIncorrect.isEmpty())) { + for (String it : knownIncorrect) { + if (prop.type instanceof StringDictionaryType) { + validator.assertError( + createModel(prop, it), + LfPackage.eINSTANCE.getKeyValuePair(), + null, + String.format("Target property '%s.", prop), + "' is required to be a string."); + } else { + validator.assertError( + createModel(prop, it), + LfPackage.eINSTANCE.getKeyValuePair(), + null, + String.format("Target property '%s' is required to be %s.", prop, prop.type)); + } } - - // vvvvvvvvvvv - validator.assertError(createModel(prop, "{ dep: {/*empty*/} }"), - LfPackage.eINSTANCE.getKeyValuePairs(), null, "Must specify one of 'version', 'path', or 'git'" - ); - - // vvvvvvvvvvv - validator.assertError(createModel(prop, "{ dep: { unknown_key: \"\"} }"), - LfPackage.eINSTANCE.getKeyValuePair(), null, "Unknown key: 'unknown_key'" - ); - - // vvvv - validator.assertError(createModel(prop, "{ dep: { features: \"\" } }"), - LfPackage.eINSTANCE.getElement(), null, "Expected an array of strings for key 'features'" - ); - } - - @Test - public void testImportedCyclicReactor() throws Exception { - // File tempFile = File.createTempFile("lf-validation", ".lf"); - // tempFile.deleteOnExit(); - // // Java 17: - // // String fileToBeImported = """ - // // target C; - // // reactor A { - // // a = new A(); - // // } - // // """ - // // Java 11: - // String fileToBeImported = String.join(System.getProperty("line.separator"), - // "target C;", - // "reactor A {", - // " a = new A();", - // "}" - // ); - // BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile)); - // writer.write(fileToBeImported); - // writer.close(); - - // // Java 17: - // // String testCase = """ - // // target C; - // // import A from ... - // // main reactor { - // // } - // // """ - // // Java 11: - // String testCase = String.join(System.getProperty("line.separator"), - // "target C;", - // String.format("import A from \"%s\"", tempFile.getAbsolutePath()), - // "main reactor {", - // "}" - // ); - // Model model = parseWithoutError(testCase); - // TODO: Uncomment the lines below and resolve the weird error. (java.lang.IllegalArgumentException: resolve against non-hierarchical or relative base) - // validator.assertError(model, LfPackage.eINSTANCE.getImportedReactor(), null, "Imported reactor 'A' has cyclic instantiation in it."); - } - - @Test - public void testUnusedImport() throws Exception { - // File tempFile = File.createTempFile("lf-validation", ".lf"); - // tempFile.deleteOnExit(); - // // Java 17: - // // String fileToBeImported = """ - // // target C; - // // reactor A {} - // // """ - // // Java 11: - // String fileToBeImported = String.join(System.getProperty("line.separator"), - // "target C;", - // "reactor A{}" - // ); - // BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile)); - // writer.write(fileToBeImported); - // writer.close(); - - // // Java 17: - // // String testCase = """ - // // target C; - // // import A from ... - // // main reactor {} - // // """ - // // Java 11: - // String testCase = String.join(System.getProperty("line.separator"), - // "target C;", - // String.format("import A from \"%s\"", tempFile.getAbsolutePath()), - // "main reactor{}" - // ); - // Model model = parseWithoutError(testCase); - // TODO: Uncomment the lines below and resolve the weird error. (java.lang.IllegalArgumentException: resolve against non-hierarchical or relative base) - // validator.assertWarning(model, LfPackage.eINSTANCE.getImport(), null, "Unused import."); - // validator.assertWarning(parseWithoutError(testCase), LfPackage.eINSTANCE.getImportedReactor(), null, "Unused reactor class."); - } - - @Test - public void testMissingInputType() throws Exception { - String testCase = """ + } else { + // No type was synthesized. It must be a composite type. + List> list = compositeTypeToKnownBad.get(prop.type); + if (list == null) { + System.out.printf( + "No known incorrect values provided for target property '%s'. Aborting test.%n", + prop); + Assertions.fail(); + } else { + for (List it : list) { + validator.assertError( + createModel(prop, it.get(0).toString()), + LfPackage.eINSTANCE.getKeyValuePair(), + null, + String.format( + "Target property '%s%s' is required to be %s.", prop, it.get(1), it.get(2))); + } + } + } + System.out.println("===="); + } + System.out.println("Done!"); + } + + @Test + public void checkCargoDependencyProperty() throws Exception { + TargetProperty prop = TargetProperty.CARGO_DEPENDENCIES; + List knownCorrect = + List.of( + "{}", + "{ dep: \"8.2\" }", + "{ dep: { version: \"8.2\"} }", + "{ dep: { version: \"8.2\", features: [\"foo\"]} }"); + for (String it : knownCorrect) { + validator.assertNoErrors(createModel(prop, it)); + } + + // vvvvvvvvvvv + validator.assertError( + createModel(prop, "{ dep: {/*empty*/} }"), + LfPackage.eINSTANCE.getKeyValuePairs(), + null, + "Must specify one of 'version', 'path', or 'git'"); + + // vvvvvvvvvvv + validator.assertError( + createModel(prop, "{ dep: { unknown_key: \"\"} }"), + LfPackage.eINSTANCE.getKeyValuePair(), + null, + "Unknown key: 'unknown_key'"); + + // vvvv + validator.assertError( + createModel(prop, "{ dep: { features: \"\" } }"), + LfPackage.eINSTANCE.getElement(), + null, + "Expected an array of strings for key 'features'"); + } + + @Test + public void testImportedCyclicReactor() throws Exception { + // File tempFile = File.createTempFile("lf-validation", ".lf"); + // tempFile.deleteOnExit(); + // // Java 17: + // // String fileToBeImported = """ + // // target C; + // // reactor A { + // // a = new A(); + // // } + // // """ + // // Java 11: + // String fileToBeImported = String.join(System.getProperty("line.separator"), + // "target C;", + // "reactor A {", + // " a = new A();", + // "}" + // ); + // BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile)); + // writer.write(fileToBeImported); + // writer.close(); + + // // Java 17: + // // String testCase = """ + // // target C; + // // import A from ... + // // main reactor { + // // } + // // """ + // // Java 11: + // String testCase = String.join(System.getProperty("line.separator"), + // "target C;", + // String.format("import A from \"%s\"", tempFile.getAbsolutePath()), + // "main reactor {", + // "}" + // ); + // Model model = parseWithoutError(testCase); + // TODO: Uncomment the lines below and resolve the weird error. + // (java.lang.IllegalArgumentException: resolve against non-hierarchical or relative base) + // validator.assertError(model, LfPackage.eINSTANCE.getImportedReactor(), null, "Imported + // reactor 'A' has cyclic instantiation in it."); + } + + @Test + public void testUnusedImport() throws Exception { + // File tempFile = File.createTempFile("lf-validation", ".lf"); + // tempFile.deleteOnExit(); + // // Java 17: + // // String fileToBeImported = """ + // // target C; + // // reactor A {} + // // """ + // // Java 11: + // String fileToBeImported = String.join(System.getProperty("line.separator"), + // "target C;", + // "reactor A{}" + // ); + // BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile)); + // writer.write(fileToBeImported); + // writer.close(); + + // // Java 17: + // // String testCase = """ + // // target C; + // // import A from ... + // // main reactor {} + // // """ + // // Java 11: + // String testCase = String.join(System.getProperty("line.separator"), + // "target C;", + // String.format("import A from \"%s\"", tempFile.getAbsolutePath()), + // "main reactor{}" + // ); + // Model model = parseWithoutError(testCase); + // TODO: Uncomment the lines below and resolve the weird error. + // (java.lang.IllegalArgumentException: resolve against non-hierarchical or relative base) + // validator.assertWarning(model, LfPackage.eINSTANCE.getImport(), null, "Unused import."); + // validator.assertWarning(parseWithoutError(testCase), + // LfPackage.eINSTANCE.getImportedReactor(), null, "Unused reactor class."); + } + + @Test + public void testMissingInputType() throws Exception { + String testCase = + """ target C; main reactor { input i; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, - "Input must have a type."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getInput(), + null, + "Input must have a type."); + } - @Test - public void testMissingOutputType() throws Exception { - String testCase = """ + @Test + public void testMissingOutputType() throws Exception { + String testCase = + """ target C; main reactor { output i; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getOutput(), null, - "Output must have a type."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getOutput(), + null, + "Output must have a type."); + } - @Test - public void testMissingStateType() throws Exception { - String testCase = """ + @Test + public void testMissingStateType() throws Exception { + String testCase = + """ target C; main reactor { state i; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, - "State must have a type."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getStateVar(), + null, + "State must have a type."); + } - @Test - public void testListWithParam() throws Exception { - String testCase = """ + @Test + public void testListWithParam() throws Exception { + String testCase = + """ target C; main reactor (A:int(1)) { state i:int(A, 2, 3) } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, - "List items cannot refer to a parameter."); - } - - @Test - public void testCppMutableInput() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getStateVar(), + null, + "List items cannot refer to a parameter."); + } + + @Test + public void testCppMutableInput() throws Exception { + String testCase = + """ target Cpp; main reactor { mutable input i:int; } """; - validator.assertWarning(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, - "The mutable qualifier has no meaning for the C++ target and should be removed. " + - "In C++, any value can be made mutable by calling get_mutable_copy()."); - } + validator.assertWarning( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getInput(), + null, + "The mutable qualifier has no meaning for the C++ target and should be removed. " + + "In C++, any value can be made mutable by calling get_mutable_copy()."); + } - @Test - public void testOverflowingSTP() throws Exception { - String testCase = """ + @Test + public void testOverflowingSTP() throws Exception { + String testCase = + """ target C; main reactor { reaction(startup) {==} STP(2147483648) {==} } """; - // TODO: Uncomment and fix failing test. See issue #903 on Github. - // validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getSTP(), null, - // "STP offset exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); - } + // TODO: Uncomment and fix failing test. See issue #903 on Github. + // validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getSTP(), null, + // "STP offset exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); + } - @Test - public void testOverflowingDeadline() throws Exception { - String testCase = """ + @Test + public void testOverflowingDeadline() throws Exception { + String testCase = + """ target C; main reactor { reaction(startup) {==} STP(2147483648) {==} } """; - // TODO: Uncomment and fix failing test. See issue #903 on Github. - // validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getDeadline(), null, - // "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); - } + // TODO: Uncomment and fix failing test. See issue #903 on Github. + // validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getDeadline(), null, + // "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds."); + } - @Test - public void testInvalidTargetParam() throws Exception { - String testCase = """ + @Test + public void testInvalidTargetParam() throws Exception { + String testCase = + """ target C { beefyDesktop: true } main reactor {} """; - List issues = validator.validate(parseWithoutError(testCase)); - Assertions.assertTrue(issues.size() == 1 + List issues = validator.validate(parseWithoutError(testCase)); + Assertions.assertTrue( + issues.size() == 1 && issues.get(0).getMessage().contains("Unrecognized target parameter: beefyDesktop")); - } + } - @Test - public void testTargetParamNotSupportedForTarget() throws Exception { - String testCase = """ + @Test + public void testTargetParamNotSupportedForTarget() throws Exception { + String testCase = + """ target Python { build: "" } main reactor {} """; - List issues = validator.validate(parseWithoutError(testCase)); - Assertions.assertTrue(issues.size() == 1 && issues.get(0).getMessage().contains( - "The target parameter: build" + - " is not supported by the Python target and will thus be ignored.")); - } - - @Test - public void testUnnamedReactor() throws Exception { - String testCase = """ + List issues = validator.validate(parseWithoutError(testCase)); + Assertions.assertTrue( + issues.size() == 1 + && issues + .get(0) + .getMessage() + .contains( + "The target parameter: build" + + " is not supported by the Python target and will thus be ignored.")); + } + + @Test + public void testUnnamedReactor() throws Exception { + String testCase = """ target C; reactor {} """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Reactor must be named."); - } - - @Test - public void testMainHasInput() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "Reactor must be named."); + } + + @Test + public void testMainHasInput() throws Exception { + String testCase = + """ target C; main reactor { input x:int; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, - "Main reactor cannot have inputs."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getInput(), + null, + "Main reactor cannot have inputs."); + } - @Test - public void testFederatedHasInput() throws Exception { + @Test + public void testFederatedHasInput() throws Exception { - String testCase = """ + String testCase = + """ target C; federated reactor { input x:int; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInput(), null, - "Main reactor cannot have inputs."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getInput(), + null, + "Main reactor cannot have inputs."); + } - @Test - public void testMainHasOutput() throws Exception { + @Test + public void testMainHasOutput() throws Exception { - String testCase = """ + String testCase = + """ target C; main reactor { output x:int; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getOutput(), null, - "Main reactor cannot have outputs."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getOutput(), + null, + "Main reactor cannot have outputs."); + } - @Test - public void testFederatedHasOutput() throws Exception { + @Test + public void testFederatedHasOutput() throws Exception { - String testCase = """ + String testCase = + """ target C; federated reactor { output x:int; } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getOutput(), null, - "Main reactor cannot have outputs."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getOutput(), + null, + "Main reactor cannot have outputs."); + } - @Test - public void testMultipleMainReactor() throws Exception { + @Test + public void testMultipleMainReactor() throws Exception { - String testCase = """ + String testCase = + """ target C; main reactor A {} main reactor A {} """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Multiple definitions of main or federated reactor."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "Multiple definitions of main or federated reactor."); + } - @Test - public void testMultipleMainReactorUnnamed() throws Exception { + @Test + public void testMultipleMainReactorUnnamed() throws Exception { - String testCase = """ + String testCase = + """ target C; main reactor {} main reactor {} """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Multiple definitions of main or federated reactor."); - } - - @Test - public void testMultipleFederatedReactor() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "Multiple definitions of main or federated reactor."); + } + + @Test + public void testMultipleFederatedReactor() throws Exception { + String testCase = + """ target C; federated reactor A {} federated reactor A {} """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Multiple definitions of main or federated reactor."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "Multiple definitions of main or federated reactor."); + } - @Test - public void testMultipleMainOrFederatedReactor() throws Exception { + @Test + public void testMultipleMainOrFederatedReactor() throws Exception { - String testCase = """ + String testCase = + """ target C; federated reactor A {} federated reactor A {} """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Multiple definitions of main or federated reactor."); - } - - @Test - public void testMainReactorHasHost() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "Multiple definitions of main or federated reactor."); + } + + @Test + public void testMainReactorHasHost() throws Exception { + String testCase = + """ target C; main reactor at 127.0.0.1{} """; - // TODO: Uncomment and fix test - // List issues = validator.validate(parseWithoutError(testCase)); - // Assertions.assertTrue(issues.size() == 1 && - // issues.get(0).getMessage().contains("Cannot assign a host to reactor '") && - // issues.get(0).getMessage().contains("' because it is not federated.")); - } + // TODO: Uncomment and fix test + // List issues = validator.validate(parseWithoutError(testCase)); + // Assertions.assertTrue(issues.size() == 1 && + // issues.get(0).getMessage().contains("Cannot assign a host to reactor '") && + // issues.get(0).getMessage().contains("' because it is not federated.")); + } - @Test - public void testUnrecognizedTarget() throws Exception { + @Test + public void testUnrecognizedTarget() throws Exception { - String testCase = """ + String testCase = + """ target Pjthon; main reactor {} """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTargetDecl(), null, - "Unrecognized target: Pjthon"); - } - - - @Test - public void testWrongStructureForLabelAttribute() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getTargetDecl(), + null, + "Unrecognized target: Pjthon"); + } + + @Test + public void testWrongStructureForLabelAttribute() throws Exception { + String testCase = + """ target C; @label(name="something") main reactor { } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAttribute(), null, - "Unknown attribute parameter."); - } - - @Test - public void testMissingName() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getAttribute(), + null, + "Unknown attribute parameter."); + } + + @Test + public void testMissingName() throws Exception { + String testCase = + """ target C; @label("something", "else") main reactor { } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAttribute(), null, - "Missing name for attribute parameter."); - } - - @Test - public void testWrongParamType() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getAttribute(), + null, + "Missing name for attribute parameter."); + } + + @Test + public void testWrongParamType() throws Exception { + String testCase = + """ target C; @label(value=1) main reactor { } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAttribute(), null, - "Incorrect type: \"value\" should have type String."); - } - - @Test - public void testInitialMode() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getAttribute(), + null, + "Incorrect type: \"value\" should have type String."); + } + + @Test + public void testInitialMode() throws Exception { + String testCase = + """ target C; main reactor { mode M {} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "Every modal reactor requires one initial mode."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "Every modal reactor requires one initial mode."); + } - @Test - public void testInitialModes() throws Exception { - String testCase = """ + @Test + public void testInitialModes() throws Exception { + String testCase = + """ target C; main reactor { initial mode IM1 {} initial mode IM2 {} } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getReactor(), null, - "A modal reactor can only have one initial mode."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReactor(), + null, + "A modal reactor can only have one initial mode."); + } - @Test - public void testModeStateNamespace() throws Exception { - String testCase = """ + @Test + public void testModeStateNamespace() throws Exception { + String testCase = + """ target C; main reactor { initial mode IM { @@ -1752,13 +2002,18 @@ public void testModeStateNamespace() throws Exception { } } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, - "Duplicate state variable 's'. (State variables are currently scoped on reactor level not modes)"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getStateVar(), + null, + "Duplicate state variable 's'. (State variables are currently scoped on reactor level not" + + " modes)"); + } - @Test - public void testModeTimerNamespace() throws Exception { - String testCase = """ + @Test + public void testModeTimerNamespace() throws Exception { + String testCase = + """ target C; main reactor { initial mode IM { @@ -1769,13 +2024,17 @@ public void testModeTimerNamespace() throws Exception { } } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getTimer(), null, - "Duplicate Timer 't'. (Timers are currently scoped on reactor level not modes)"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getTimer(), + null, + "Duplicate Timer 't'. (Timers are currently scoped on reactor level not modes)"); + } - @Test - public void testModeActionNamespace() throws Exception { - String testCase = """ + @Test + public void testModeActionNamespace() throws Exception { + String testCase = + """ target C; main reactor { initial mode IM { @@ -1786,13 +2045,17 @@ public void testModeActionNamespace() throws Exception { } } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getAction(), null, - "Duplicate Action 'a'. (Actions are currently scoped on reactor level not modes)"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getAction(), + null, + "Duplicate Action 'a'. (Actions are currently scoped on reactor level not modes)"); + } - @Test - public void testModeInstanceNamespace() throws Exception { - String testCase = """ + @Test + public void testModeInstanceNamespace() throws Exception { + String testCase = + """ target C; reactor R {} main reactor { @@ -1804,13 +2067,18 @@ public void testModeInstanceNamespace() throws Exception { } } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getInstantiation(), null, - "Duplicate Instantiation 'r'. (Instantiations are currently scoped on reactor level not modes)"); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getInstantiation(), + null, + "Duplicate Instantiation 'r'. (Instantiations are currently scoped on reactor level not" + + " modes)"); + } - @Test - public void testMissingModeStateReset() throws Exception { - String testCase = """ + @Test + public void testMissingModeStateReset() throws Exception { + String testCase = + """ target C; main reactor { initial mode IM { @@ -1821,13 +2089,18 @@ public void testMissingModeStateReset() throws Exception { } } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getMode(), null, - "State variable is not reset upon mode entry. It is neither marked for automatic reset nor is there a reset reaction."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getMode(), + null, + "State variable is not reset upon mode entry. It is neither marked for automatic reset nor" + + " is there a reset reaction."); + } - @Test - public void testMissingModeStateResetInstance() throws Exception { - String testCase = """ + @Test + public void testMissingModeStateResetInstance() throws Exception { + String testCase = + """ target C; reactor R { state s:int = 0; @@ -1841,16 +2114,20 @@ public void testMissingModeStateResetInstance() throws Exception { } } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getMode(), null, - "This reactor contains state variables that are not reset upon mode entry: " - + "s in R" - + ".\nThe state variables are neither marked for automatic reset nor have a dedicated reset reaction. " - + "It is unsafe to instantiate this reactor inside a mode entered with reset."); - } - - @Test - public void testModeStateResetWithoutInitialValue() throws Exception { - String testCase = """ + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getMode(), + null, + "This reactor contains state variables that are not reset upon mode entry: s in R.\n" + + "The state variables are neither marked for automatic reset nor have a dedicated" + + " reset reaction. It is unsafe to instantiate this reactor inside a mode entered with" + + " reset."); + } + + @Test + public void testModeStateResetWithoutInitialValue() throws Exception { + String testCase = + """ target C; main reactor { initial mode IM { @@ -1858,13 +2135,17 @@ public void testModeStateResetWithoutInitialValue() throws Exception { } } """; - validator.assertError(parseWithoutError(testCase), LfPackage.eINSTANCE.getStateVar(), null, - "The state variable can not be automatically reset without an initial value."); - } + validator.assertError( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getStateVar(), + null, + "The state variable can not be automatically reset without an initial value."); + } - @Test - public void testUnspecifiedTransitionType() throws Exception { - String testCase = """ + @Test + public void testUnspecifiedTransitionType() throws Exception { + String testCase = + """ target C; main reactor { initial mode IM { @@ -1875,10 +2156,12 @@ public void testUnspecifiedTransitionType() throws Exception { } } """; - validator.assertWarning(parseWithoutError(testCase), LfPackage.eINSTANCE.getReaction(), null, - "You should specify a transition type! " - + "Reset and history transitions have different effects on this target mode. " - + "Currently, a reset type is implicitly assumed."); - } - + validator.assertWarning( + parseWithoutError(testCase), + LfPackage.eINSTANCE.getReaction(), + null, + "You should specify a transition type! " + + "Reset and history transitions have different effects on this target mode. " + + "Currently, a reset type is implicitly assumed."); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/MixedRadixIntTest.java b/org.lflang.tests/src/org/lflang/tests/compiler/MixedRadixIntTest.java index 2cee2468c8..b119da05c2 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/MixedRadixIntTest.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/MixedRadixIntTest.java @@ -2,111 +2,110 @@ import java.util.Arrays; import java.util.List; - import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.lflang.generator.MixedRadixInt; public class MixedRadixIntTest { - - // Constants used many times below. - List radixes = Arrays.asList(2, 3, 4, 5); - List digits = Arrays.asList(1, 2, 3, 4); - @Test - public void create() throws Exception { - MixedRadixInt num = new MixedRadixInt(digits, radixes, null); - Assertions.assertEquals("1%2, 2%3, 3%4, 4%5", num.toString()); - Assertions.assertEquals(1 + 2*2 + 3*6 + 4*24, num.get()); - - List altDigits = List.of(1, 2, 1); - MixedRadixInt altNum = new MixedRadixInt(altDigits, radixes, null); - Assertions.assertEquals(11, altNum.get()); - } + // Constants used many times below. + List radixes = Arrays.asList(2, 3, 4, 5); + List digits = Arrays.asList(1, 2, 3, 4); - @Test - public void createWithInfinity() throws Exception { - List radixes = List.of(2, 3, 4, 10000); - MixedRadixInt num = new MixedRadixInt(digits, radixes, null); - Assertions.assertEquals(1 + 2*2 + 3*6 + 4*24, num.get()); - } + @Test + public void create() throws Exception { + MixedRadixInt num = new MixedRadixInt(digits, radixes, null); + Assertions.assertEquals("1%2, 2%3, 3%4, 4%5", num.toString()); + Assertions.assertEquals(1 + 2 * 2 + 3 * 6 + 4 * 24, num.get()); - @Test - public void createWithError() throws Exception { - List radixes = List.of(2, 3); - try { - new MixedRadixInt(digits, radixes, null); - } catch (IllegalArgumentException ex) { - Assertions.assertTrue(ex.getMessage().startsWith("Invalid")); - return; - } - Assertions.assertTrue(false, "Expected exception did not occur."); - } - - @Test - public void createWithNullAndSet() throws Exception { - MixedRadixInt num = new MixedRadixInt(null, radixes, null); - Assertions.assertEquals(0, num.get()); - Assertions.assertEquals("0%2", num.toString()); - num.set(1 + 2*2 + 3*6 + 4*24); - Assertions.assertEquals(1 + 2*2 + 3*6 + 4*24, num.get()); - int mag = num.magnitude(); - Assertions.assertEquals(1 + 2*2 + 3*6 + 4*24, mag); - num.increment(); // wrap to zero. - Assertions.assertEquals(0, num.get()); - Assertions.assertEquals(0, num.magnitude()); - - num = new MixedRadixInt(null, radixes, null); - num.setMagnitude(mag); - Assertions.assertEquals(mag, num.magnitude()); - } - - @Test - public void testPermutation() throws Exception { - List radixes = Arrays.asList(2, 5); - List digits = Arrays.asList(1, 2); - List permutation = Arrays.asList(1, 0); - MixedRadixInt num = new MixedRadixInt(digits, radixes, permutation); - Assertions.assertEquals(5, num.get()); - Assertions.assertEquals(2, num.get(1)); - Assertions.assertEquals(7, num.magnitude()); - num.increment(); - Assertions.assertEquals(7, num.get()); - Assertions.assertEquals(8, num.magnitude()); - - num = new MixedRadixInt(null, radixes, permutation); - num.setMagnitude(8); - Assertions.assertEquals(8, num.magnitude()); - Assertions.assertEquals(7, num.get()); + List altDigits = List.of(1, 2, 1); + MixedRadixInt altNum = new MixedRadixInt(altDigits, radixes, null); + Assertions.assertEquals(11, altNum.get()); + } - // Test radix infinity digit (effectively). - digits = Arrays.asList(1, 2, 1); - radixes = Arrays.asList(2, 5, 1000000); - num = new MixedRadixInt(digits, radixes, null); - Assertions.assertEquals(15, num.get()); - Assertions.assertEquals(7, num.get(1)); - Assertions.assertEquals(15, num.magnitude()); - - permutation = Arrays.asList(1, 0, 2); - num = new MixedRadixInt(digits, radixes, permutation); - num.increment(); - Assertions.assertEquals(17, num.get()); - Assertions.assertEquals(18, num.magnitude()); + @Test + public void createWithInfinity() throws Exception { + List radixes = List.of(2, 3, 4, 10000); + MixedRadixInt num = new MixedRadixInt(digits, radixes, null); + Assertions.assertEquals(1 + 2 * 2 + 3 * 6 + 4 * 24, num.get()); + } - num = new MixedRadixInt(null, radixes, permutation); - num.setMagnitude(18); - Assertions.assertEquals(18, num.magnitude()); - Assertions.assertEquals(17, num.get()); - } - - @Test - public void testIncrement() throws Exception { - List radixes = Arrays.asList(2, 3); - List digits = Arrays.asList(0, 2); - MixedRadixInt num = new MixedRadixInt(digits, radixes, null); - num.increment(); - Assertions.assertEquals(5, num.get()); - num.increment(); // Wrap around to zero. - Assertions.assertEquals(0, num.get()); + @Test + public void createWithError() throws Exception { + List radixes = List.of(2, 3); + try { + new MixedRadixInt(digits, radixes, null); + } catch (IllegalArgumentException ex) { + Assertions.assertTrue(ex.getMessage().startsWith("Invalid")); + return; } + Assertions.assertTrue(false, "Expected exception did not occur."); + } + + @Test + public void createWithNullAndSet() throws Exception { + MixedRadixInt num = new MixedRadixInt(null, radixes, null); + Assertions.assertEquals(0, num.get()); + Assertions.assertEquals("0%2", num.toString()); + num.set(1 + 2 * 2 + 3 * 6 + 4 * 24); + Assertions.assertEquals(1 + 2 * 2 + 3 * 6 + 4 * 24, num.get()); + int mag = num.magnitude(); + Assertions.assertEquals(1 + 2 * 2 + 3 * 6 + 4 * 24, mag); + num.increment(); // wrap to zero. + Assertions.assertEquals(0, num.get()); + Assertions.assertEquals(0, num.magnitude()); + + num = new MixedRadixInt(null, radixes, null); + num.setMagnitude(mag); + Assertions.assertEquals(mag, num.magnitude()); + } + + @Test + public void testPermutation() throws Exception { + List radixes = Arrays.asList(2, 5); + List digits = Arrays.asList(1, 2); + List permutation = Arrays.asList(1, 0); + MixedRadixInt num = new MixedRadixInt(digits, radixes, permutation); + Assertions.assertEquals(5, num.get()); + Assertions.assertEquals(2, num.get(1)); + Assertions.assertEquals(7, num.magnitude()); + num.increment(); + Assertions.assertEquals(7, num.get()); + Assertions.assertEquals(8, num.magnitude()); + + num = new MixedRadixInt(null, radixes, permutation); + num.setMagnitude(8); + Assertions.assertEquals(8, num.magnitude()); + Assertions.assertEquals(7, num.get()); + + // Test radix infinity digit (effectively). + digits = Arrays.asList(1, 2, 1); + radixes = Arrays.asList(2, 5, 1000000); + num = new MixedRadixInt(digits, radixes, null); + Assertions.assertEquals(15, num.get()); + Assertions.assertEquals(7, num.get(1)); + Assertions.assertEquals(15, num.magnitude()); + + permutation = Arrays.asList(1, 0, 2); + num = new MixedRadixInt(digits, radixes, permutation); + num.increment(); + Assertions.assertEquals(17, num.get()); + Assertions.assertEquals(18, num.magnitude()); + + num = new MixedRadixInt(null, radixes, permutation); + num.setMagnitude(18); + Assertions.assertEquals(18, num.magnitude()); + Assertions.assertEquals(17, num.get()); + } + + @Test + public void testIncrement() throws Exception { + List radixes = Arrays.asList(2, 3); + List digits = Arrays.asList(0, 2); + MixedRadixInt num = new MixedRadixInt(digits, radixes, null); + num.increment(); + Assertions.assertEquals(5, num.get()); + num.increment(); // Wrap around to zero. + Assertions.assertEquals(0, num.get()); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/PortInstanceTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/PortInstanceTests.java index f5f2ba387b..8b8ef52a8f 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/PortInstanceTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/PortInstanceTests.java @@ -1,15 +1,14 @@ package org.lflang.tests.compiler; import java.util.List; - import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.lflang.DefaultErrorReporter; import org.lflang.ErrorReporter; import org.lflang.generator.PortInstance; -import org.lflang.generator.RuntimeRange; import org.lflang.generator.ReactionInstance; import org.lflang.generator.ReactorInstance; +import org.lflang.generator.RuntimeRange; import org.lflang.generator.SendRange; import org.lflang.lf.LfFactory; import org.lflang.lf.Port; @@ -18,204 +17,205 @@ public class PortInstanceTests { - private ErrorReporter reporter = new DefaultErrorReporter(); - private static LfFactory factory = LfFactory.eINSTANCE; - - @Test - public void createRange() throws Exception { - Reactor main = factory.createReactor(); - ReactorInstance maini = new ReactorInstance(main, reporter); - - ReactorInstance a = newReactor("A", maini); - ReactorInstance b = newReactor("B", maini); - ReactorInstance c = newReactor("C", maini); - - PortInstance p = newOutputPort("p", a); - PortInstance q = newInputPort("q", b); - PortInstance r = newInputPort("r", c); - - Assertions.assertEquals(".A.p", p.getFullName()); - - connect(p, q); - connect(p, r); - - List sr = p.eventualDestinations(); - // Destinations should be empty because there are no reactions. - Assertions.assertEquals("[]", sr.toString()); - - // Clear caches to make a mutation. - maini.clearCaches(); - newReaction(q); - // Re-retrieve destinations. - sr = p.eventualDestinations(); - Assertions.assertEquals("[.A.p(0,1)->[.B.q(0,1)]]", sr.toString()); - - maini.clearCaches(); - newReaction(r); - // Re-retrieve destinations. - sr = p.eventualDestinations(); - Assertions.assertEquals("[.A.p(0,1)->[.B.q(0,1), .C.r(0,1)]]", sr.toString()); - - // Now test multiports. - p.setWidth(3); - r.setWidth(2); - // Have to redo the connections. - clearConnections(maini); - maini.clearCaches(); - connect(p, 0, 1, q, 0, 1); - connect(p, 1, 2, r, 0, 2); - - // Re-retrieve destinations. - sr = p.eventualDestinations(); - Assertions.assertEquals("[.A.p(0,1)->[.B.q(0,1)], .A.p(1,2)->[.C.r(0,2)]]", sr.toString()); - - // More complicated multiport connection. - clearConnections(maini); - maini.clearCaches(); - - ReactorInstance d = newReactor("D", maini); - PortInstance v = newOutputPort("v", d); - v.setWidth(2); - q.setWidth(3); - connect(v, 0, 2, q, 0, 2); - connect(p, 0, 1, q, 2, 1); - connect(p, 1, 2, r, 0, 2); - - sr = p.eventualDestinations(); - Assertions.assertEquals("[.A.p(0,1)->[.B.q(2,1)], .A.p(1,2)->[.C.r(0,2)]]", sr.toString()); - - // Additional multicast connection. - maini.clearCaches(); - ReactorInstance e = newReactor("E", maini); - PortInstance s = newPort("s", e); - s.setWidth(3); - newReaction(s); - connect(p, s); - - sr = p.eventualDestinations(); - Assertions.assertEquals("[.A.p(0,1)->[.B.q(2,1), .E.s(0,1)], .A.p(1,2)->[.C.r(0,2), .E.s(1,2)]]", sr.toString()); - - // Add hierarchical reactors that further split the ranges. - maini.clearCaches(); - ReactorInstance f = newReactor("F", e); - PortInstance t = newPort("t", f); - newReaction(t); - ReactorInstance g = newReactor("G", e); - PortInstance u = newPort("u", g); - u.setWidth(2); - newReaction(u); - connect(s, 0, 1, t, 0, 1); - connect(s, 1, 2, u, 0, 2); - - sr = p.eventualDestinations(); - // FIXME: Multicast destinations should be able to be reported in arbitrary order. - Assertions.assertEquals("[.A.p(0,1)->[.E.F.t(0,1), .E.s(0,1), .B.q(2,1)], .A.p(1,2)->[.E.G.u(0,2), .E.s(1,2), .C.r(0,2)]]", sr.toString()); - } - - @Test - public void multiportDestination() throws Exception { - Reactor main = factory.createReactor(); - ReactorInstance maini = new ReactorInstance(main, reporter); - - ReactorInstance a = newReactor("A", maini); - ReactorInstance b = newReactor("B", maini); - b.setWidth(4); - - PortInstance p = newOutputPort("p", a); - PortInstance q = newInputPort("q", b); - - connect(p, 0, 1, q, 0, 4); - - List sr = p.eventualDestinations(); - // Destination has no reactions, so empty list is right. - Assertions.assertEquals("[]", sr.toString()); - - maini.clearCaches(); - newReaction(q); - sr = p.eventualDestinations(); - Assertions.assertEquals("[.A.p(0,1)->[.B.q(0,4)]]", sr.toString()); -} - - /** - * Clear connections. This recursively clears them for all contained reactors. - */ - protected void clearConnections(ReactorInstance r) { - for (PortInstance p: r.inputs) { - p.getDependentPorts().clear(); - } - for (PortInstance p: r.outputs) { - p.getDependentPorts().clear(); - } - for (ReactorInstance child: r.children) { - clearConnections(child); - } - } - - /** - * Simple connection of two ports. This should be used only - * for connections that would be allowed in the syntax (i.e., no - * cross-hierarchy connections), but this is not checked. - * @param src The sending port. - * @param dst The receiving port. - */ - protected void connect(PortInstance src, PortInstance dst) { - RuntimeRange srcRange = new RuntimeRange.Port(src); - RuntimeRange dstRange = new RuntimeRange.Port(dst); - ReactorInstance.connectPortInstances(srcRange, dstRange, null); + private ErrorReporter reporter = new DefaultErrorReporter(); + private static LfFactory factory = LfFactory.eINSTANCE; + + @Test + public void createRange() throws Exception { + Reactor main = factory.createReactor(); + ReactorInstance maini = new ReactorInstance(main, reporter); + + ReactorInstance a = newReactor("A", maini); + ReactorInstance b = newReactor("B", maini); + ReactorInstance c = newReactor("C", maini); + + PortInstance p = newOutputPort("p", a); + PortInstance q = newInputPort("q", b); + PortInstance r = newInputPort("r", c); + + Assertions.assertEquals(".A.p", p.getFullName()); + + connect(p, q); + connect(p, r); + + List sr = p.eventualDestinations(); + // Destinations should be empty because there are no reactions. + Assertions.assertEquals("[]", sr.toString()); + + // Clear caches to make a mutation. + maini.clearCaches(); + newReaction(q); + // Re-retrieve destinations. + sr = p.eventualDestinations(); + Assertions.assertEquals("[.A.p(0,1)->[.B.q(0,1)]]", sr.toString()); + + maini.clearCaches(); + newReaction(r); + // Re-retrieve destinations. + sr = p.eventualDestinations(); + Assertions.assertEquals("[.A.p(0,1)->[.B.q(0,1), .C.r(0,1)]]", sr.toString()); + + // Now test multiports. + p.setWidth(3); + r.setWidth(2); + // Have to redo the connections. + clearConnections(maini); + maini.clearCaches(); + connect(p, 0, 1, q, 0, 1); + connect(p, 1, 2, r, 0, 2); + + // Re-retrieve destinations. + sr = p.eventualDestinations(); + Assertions.assertEquals("[.A.p(0,1)->[.B.q(0,1)], .A.p(1,2)->[.C.r(0,2)]]", sr.toString()); + + // More complicated multiport connection. + clearConnections(maini); + maini.clearCaches(); + + ReactorInstance d = newReactor("D", maini); + PortInstance v = newOutputPort("v", d); + v.setWidth(2); + q.setWidth(3); + connect(v, 0, 2, q, 0, 2); + connect(p, 0, 1, q, 2, 1); + connect(p, 1, 2, r, 0, 2); + + sr = p.eventualDestinations(); + Assertions.assertEquals("[.A.p(0,1)->[.B.q(2,1)], .A.p(1,2)->[.C.r(0,2)]]", sr.toString()); + + // Additional multicast connection. + maini.clearCaches(); + ReactorInstance e = newReactor("E", maini); + PortInstance s = newPort("s", e); + s.setWidth(3); + newReaction(s); + connect(p, s); + + sr = p.eventualDestinations(); + Assertions.assertEquals( + "[.A.p(0,1)->[.B.q(2,1), .E.s(0,1)], .A.p(1,2)->[.C.r(0,2), .E.s(1,2)]]", sr.toString()); + + // Add hierarchical reactors that further split the ranges. + maini.clearCaches(); + ReactorInstance f = newReactor("F", e); + PortInstance t = newPort("t", f); + newReaction(t); + ReactorInstance g = newReactor("G", e); + PortInstance u = newPort("u", g); + u.setWidth(2); + newReaction(u); + connect(s, 0, 1, t, 0, 1); + connect(s, 1, 2, u, 0, 2); + + sr = p.eventualDestinations(); + // FIXME: Multicast destinations should be able to be reported in arbitrary order. + Assertions.assertEquals( + "[.A.p(0,1)->[.E.F.t(0,1), .E.s(0,1), .B.q(2,1)], .A.p(1,2)->[.E.G.u(0,2), .E.s(1,2)," + + " .C.r(0,2)]]", + sr.toString()); + } + + @Test + public void multiportDestination() throws Exception { + Reactor main = factory.createReactor(); + ReactorInstance maini = new ReactorInstance(main, reporter); + + ReactorInstance a = newReactor("A", maini); + ReactorInstance b = newReactor("B", maini); + b.setWidth(4); + + PortInstance p = newOutputPort("p", a); + PortInstance q = newInputPort("q", b); + + connect(p, 0, 1, q, 0, 4); + + List sr = p.eventualDestinations(); + // Destination has no reactions, so empty list is right. + Assertions.assertEquals("[]", sr.toString()); + + maini.clearCaches(); + newReaction(q); + sr = p.eventualDestinations(); + Assertions.assertEquals("[.A.p(0,1)->[.B.q(0,4)]]", sr.toString()); + } + + /** Clear connections. This recursively clears them for all contained reactors. */ + protected void clearConnections(ReactorInstance r) { + for (PortInstance p : r.inputs) { + p.getDependentPorts().clear(); } - - /** - * Connection between multiports. This should be used only - * for connections that would be allowed in the syntax (i.e., no - * cross-hierarchy connections), but this is not checked. - * @param src The sending port. - * @param dst The receiving port. - */ - protected void connect( - PortInstance src, int srcStart, int srcWidth, - PortInstance dst, int dstStart, int dstWidth - ) { - RuntimeRange srcRange = new RuntimeRange.Port(src, srcStart, srcWidth, null); - RuntimeRange dstRange = new RuntimeRange.Port(dst, dstStart, dstWidth, null); - ReactorInstance.connectPortInstances(srcRange, dstRange, null); + for (PortInstance p : r.outputs) { + p.getDependentPorts().clear(); } - - protected PortInstance newPort(String name, ReactorInstance container) { - Port p = factory.createPort(); - p.setName(name); - return new PortInstance(p, container, reporter); - } - - protected PortInstance newInputPort(String name, ReactorInstance container) { - PortInstance pi = newPort(name, container); - container.inputs.add(pi); - return pi; - } - - protected PortInstance newOutputPort(String name, ReactorInstance container) { - PortInstance pi = newPort(name, container); - container.outputs.add(pi); - return pi; - } - - /** - * Return a new reaction triggered by the specified port. - * @param trigger The triggering port. - */ - protected ReactionInstance newReaction(PortInstance trigger) { - Reaction r = factory.createReaction(); - ReactionInstance result = new ReactionInstance( - r, trigger.getParent(), false, trigger.getDependentReactions().size()); - trigger.getDependentReactions().add(result); - trigger.getParent().reactions.add(result); - return result; - } - - protected ReactorInstance newReactor(String name, ReactorInstance container) { - Reactor r = factory.createReactor(); - r.setName(name); - ReactorInstance ri = new ReactorInstance(r, container, reporter); - container.children.add(ri); - return ri; + for (ReactorInstance child : r.children) { + clearConnections(child); } + } + + /** + * Simple connection of two ports. This should be used only for connections that would be allowed + * in the syntax (i.e., no cross-hierarchy connections), but this is not checked. + * + * @param src The sending port. + * @param dst The receiving port. + */ + protected void connect(PortInstance src, PortInstance dst) { + RuntimeRange srcRange = new RuntimeRange.Port(src); + RuntimeRange dstRange = new RuntimeRange.Port(dst); + ReactorInstance.connectPortInstances(srcRange, dstRange, null); + } + + /** + * Connection between multiports. This should be used only for connections that would be allowed + * in the syntax (i.e., no cross-hierarchy connections), but this is not checked. + * + * @param src The sending port. + * @param dst The receiving port. + */ + protected void connect( + PortInstance src, int srcStart, int srcWidth, PortInstance dst, int dstStart, int dstWidth) { + RuntimeRange srcRange = new RuntimeRange.Port(src, srcStart, srcWidth, null); + RuntimeRange dstRange = new RuntimeRange.Port(dst, dstStart, dstWidth, null); + ReactorInstance.connectPortInstances(srcRange, dstRange, null); + } + + protected PortInstance newPort(String name, ReactorInstance container) { + Port p = factory.createPort(); + p.setName(name); + return new PortInstance(p, container, reporter); + } + + protected PortInstance newInputPort(String name, ReactorInstance container) { + PortInstance pi = newPort(name, container); + container.inputs.add(pi); + return pi; + } + + protected PortInstance newOutputPort(String name, ReactorInstance container) { + PortInstance pi = newPort(name, container); + container.outputs.add(pi); + return pi; + } + + /** + * Return a new reaction triggered by the specified port. + * + * @param trigger The triggering port. + */ + protected ReactionInstance newReaction(PortInstance trigger) { + Reaction r = factory.createReaction(); + ReactionInstance result = + new ReactionInstance(r, trigger.getParent(), false, trigger.getDependentReactions().size()); + trigger.getDependentReactions().add(result); + trigger.getParent().reactions.add(result); + return result; + } + + protected ReactorInstance newReactor(String name, ReactorInstance container) { + Reactor r = factory.createReactor(); + r.setName(name); + ReactorInstance ri = new ReactorInstance(r, container, reporter); + container.children.add(ri); + return ri; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/RangeTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/RangeTests.java index 5cd489d0f7..2c17145aaa 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/RangeTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/RangeTests.java @@ -2,14 +2,13 @@ import java.util.List; import java.util.Set; - import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.lflang.DefaultErrorReporter; import org.lflang.ErrorReporter; import org.lflang.generator.PortInstance; -import org.lflang.generator.RuntimeRange; import org.lflang.generator.ReactorInstance; +import org.lflang.generator.RuntimeRange; import org.lflang.generator.SendRange; import org.lflang.lf.LfFactory; import org.lflang.lf.Port; @@ -17,87 +16,87 @@ public class RangeTests { - private ErrorReporter reporter = new DefaultErrorReporter(); - private static LfFactory factory = LfFactory.eINSTANCE; - - @Test - public void createRange() throws Exception { - Reactor main = factory.createReactor(); - ReactorInstance maini = new ReactorInstance(main, reporter); - - Reactor a = factory.createReactor(); - a.setName("A"); - ReactorInstance ai = new ReactorInstance(a, maini, reporter); - ai.setWidth(2); - - Reactor b = factory.createReactor(); - b.setName("B"); - ReactorInstance bi = new ReactorInstance(b, ai, reporter); - bi.setWidth(2); - - Port p = factory.createPort(); - p.setName("P"); - PortInstance pi = new PortInstance(p, bi, reporter); - pi.setWidth(2); - - Assertions.assertEquals(".A.B.P", pi.getFullName()); - - RuntimeRange range = new RuntimeRange.Port(pi, 3, 4, null); - - Assertions.assertEquals(8, range.maxWidth); - - Assertions.assertEquals(".A.B.P(3,4)", range.toString()); - - // The results expected below are derived from the class comment for RuntimeRange, - // which includes this example. - List instances = range.instances(); - Assertions.assertEquals(List.of(3, 4, 5, 6), instances); - Set parents = range.parentInstances(1); - Assertions.assertEquals(Set.of(1, 2, 3), parents); - - parents = range.parentInstances(2); - Assertions.assertEquals(Set.of(0, 1), parents); - - // Test startMR().getDigits. - Assertions.assertEquals(List.of(1, 1, 0), range.startMR().getDigits()); - - // Create a SendRange sending from and to this range. - SendRange sendRange = new SendRange(pi, 3, 4, null, null); - sendRange.destinations.add(range); - - // Test getNumberOfDestinationReactors. - Assertions.assertEquals(3, sendRange.getNumberOfDestinationReactors()); - - // Make first interleaved version. - range = range.toggleInterleaved(bi); - instances = range.instances(); - Assertions.assertEquals(List.of(3, 4, 6, 5), instances); - - // Test startMR().getDigits. - Assertions.assertEquals(List.of(1, 1, 0), range.startMR().getDigits()); - - // Make second interleaved version. - range = range.toggleInterleaved(ai); - instances = range.instances(); - Assertions.assertEquals(List.of(6, 1, 5, 3), instances); - - // Test startMR().getDigits. - Assertions.assertEquals(List.of(0, 1, 1), range.startMR().getDigits()); - - // Test instances of the parent. - Assertions.assertEquals(Set.of(3, 0, 2, 1), range.parentInstances(1)); - - // Add this range to the sendRange destinations and verify - // that the number of destination reactors becomes 4. - sendRange.addDestination(range); - Assertions.assertEquals(4, sendRange.getNumberOfDestinationReactors()); - - // Make third interleaved version. - range = range.toggleInterleaved(bi); - instances = range.instances(); - Assertions.assertEquals(List.of(5, 2, 6, 3), instances); - - // Test startMR().getDigits. - Assertions.assertEquals(List.of(1, 0, 1), range.startMR().getDigits()); - } + private ErrorReporter reporter = new DefaultErrorReporter(); + private static LfFactory factory = LfFactory.eINSTANCE; + + @Test + public void createRange() throws Exception { + Reactor main = factory.createReactor(); + ReactorInstance maini = new ReactorInstance(main, reporter); + + Reactor a = factory.createReactor(); + a.setName("A"); + ReactorInstance ai = new ReactorInstance(a, maini, reporter); + ai.setWidth(2); + + Reactor b = factory.createReactor(); + b.setName("B"); + ReactorInstance bi = new ReactorInstance(b, ai, reporter); + bi.setWidth(2); + + Port p = factory.createPort(); + p.setName("P"); + PortInstance pi = new PortInstance(p, bi, reporter); + pi.setWidth(2); + + Assertions.assertEquals(".A.B.P", pi.getFullName()); + + RuntimeRange range = new RuntimeRange.Port(pi, 3, 4, null); + + Assertions.assertEquals(8, range.maxWidth); + + Assertions.assertEquals(".A.B.P(3,4)", range.toString()); + + // The results expected below are derived from the class comment for RuntimeRange, + // which includes this example. + List instances = range.instances(); + Assertions.assertEquals(List.of(3, 4, 5, 6), instances); + Set parents = range.parentInstances(1); + Assertions.assertEquals(Set.of(1, 2, 3), parents); + + parents = range.parentInstances(2); + Assertions.assertEquals(Set.of(0, 1), parents); + + // Test startMR().getDigits. + Assertions.assertEquals(List.of(1, 1, 0), range.startMR().getDigits()); + + // Create a SendRange sending from and to this range. + SendRange sendRange = new SendRange(pi, 3, 4, null, null); + sendRange.destinations.add(range); + + // Test getNumberOfDestinationReactors. + Assertions.assertEquals(3, sendRange.getNumberOfDestinationReactors()); + + // Make first interleaved version. + range = range.toggleInterleaved(bi); + instances = range.instances(); + Assertions.assertEquals(List.of(3, 4, 6, 5), instances); + + // Test startMR().getDigits. + Assertions.assertEquals(List.of(1, 1, 0), range.startMR().getDigits()); + + // Make second interleaved version. + range = range.toggleInterleaved(ai); + instances = range.instances(); + Assertions.assertEquals(List.of(6, 1, 5, 3), instances); + + // Test startMR().getDigits. + Assertions.assertEquals(List.of(0, 1, 1), range.startMR().getDigits()); + + // Test instances of the parent. + Assertions.assertEquals(Set.of(3, 0, 2, 1), range.parentInstances(1)); + + // Add this range to the sendRange destinations and verify + // that the number of destination reactors becomes 4. + sendRange.addDestination(range); + Assertions.assertEquals(4, sendRange.getNumberOfDestinationReactors()); + + // Make third interleaved version. + range = range.toggleInterleaved(bi); + instances = range.instances(); + Assertions.assertEquals(List.of(5, 2, 6, 3), instances); + + // Test startMR().getDigits. + Assertions.assertEquals(List.of(1, 0, 1), range.startMR().getDigits()); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java index 801211be23..8087d552a8 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java @@ -7,13 +7,11 @@ import java.nio.file.Files; import java.nio.file.Path; - import org.eclipse.xtext.testing.InjectWith; import org.eclipse.xtext.testing.extensions.InjectionExtension; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.Target; import org.lflang.ast.FormattingUtils; import org.lflang.ast.IsEqual; @@ -28,46 +26,42 @@ @InjectWith(LFInjectorProvider.class) public class RoundTripTests { - @Test - public void roundTripTest() { - for (Target target : Target.values()) { - for (TestCategory category : TestCategory.values()) { - for (LFTest test : TestRegistry.getRegisteredTests(target, category, false)) { - try { - run(test.getSrcPath()); - } catch (Throwable thrown) { - fail("Test case " + test.getSrcPath() + " failed", thrown); - } - } - } + @Test + public void roundTripTest() { + for (Target target : Target.values()) { + for (TestCategory category : TestCategory.values()) { + for (LFTest test : TestRegistry.getRegisteredTests(target, category, false)) { + try { + run(test.getSrcPath()); + } catch (Throwable thrown) { + fail("Test case " + test.getSrcPath() + " failed", thrown); + } } + } } + } - private void run(Path file) throws Exception { - Model originalModel = LfParsingUtil.parse(file); - System.out.println(file); - assertThat(originalModel.eResource().getErrors(), equalTo(emptyList())); - // TODO: Check that the output is a fixed point - final int smallLineLength = 20; - final String squishedTestCase = FormattingUtils.render(originalModel, smallLineLength); - final Model resultingModel = LfParsingUtil.parseSourceAsIfInDirectory(file.getParent(), squishedTestCase); - - assertThat(resultingModel.eResource().getErrors(), equalTo(emptyList())); - Assertions.assertTrue( - new IsEqual(originalModel).doSwitch(resultingModel), - String.format( - "The reformatted version of %s was not equivalent to the original file.%n" - + "Formatted file:%n%s%n%n", - file, - squishedTestCase - ) - ); - final String normalTestCase = FormattingUtils.render(originalModel); - Assertions.assertEquals( - Files.readString(file).replaceAll("\\r\\n?", "\n"), - normalTestCase, - "File is not formatted properly, or formatter is bugged. Check " + file - ); - } + private void run(Path file) throws Exception { + Model originalModel = LfParsingUtil.parse(file); + System.out.println(file); + assertThat(originalModel.eResource().getErrors(), equalTo(emptyList())); + // TODO: Check that the output is a fixed point + final int smallLineLength = 20; + final String squishedTestCase = FormattingUtils.render(originalModel, smallLineLength); + final Model resultingModel = + LfParsingUtil.parseSourceAsIfInDirectory(file.getParent(), squishedTestCase); + assertThat(resultingModel.eResource().getErrors(), equalTo(emptyList())); + Assertions.assertTrue( + new IsEqual(originalModel).doSwitch(resultingModel), + String.format( + "The reformatted version of %s was not equivalent to the original file.%n" + + "Formatted file:%n%s%n%n", + file, squishedTestCase)); + final String normalTestCase = FormattingUtils.render(originalModel); + Assertions.assertEquals( + Files.readString(file).replaceAll("\\r\\n?", "\n"), + normalTestCase, + "File is not formatted properly, or formatter is bugged. Check " + file); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java index eede6a6831..e949ab6f9f 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java @@ -12,7 +12,6 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; - import org.lflang.federated.generator.FedFileConfig; import org.lflang.generator.GeneratorUtils; import org.lflang.generator.LFGenerator; @@ -24,79 +23,81 @@ @ExtendWith(InjectionExtension.class) @InjectWith(LFInjectorProvider.class) -/** - * Tests for checking that target properties adequately translate into the target configuration. - */ +/** Tests for checking that target properties adequately translate into the target configuration. */ class TargetConfigTests { - @Inject - ParseHelper parser; - - @Inject - LFGenerator generator; - - @Inject - JavaIoFileSystemAccess fileAccess; - - @Inject - Provider resourceSetProvider; - - private void assertHasTargetProperty(Model model, String name) { - Assertions.assertNotNull(model); - Assertions.assertTrue( - model.getTarget().getConfig().getPairs().stream().anyMatch( - p -> p.getName().equals(name) - ) - ); - } - - /** - * Check that tracing target property affects the target configuration. - * @throws Exception - */ - @Test - public void testParsing() throws Exception { - assertHasTargetProperty(parser.parse(""" + @Inject ParseHelper parser; + + @Inject LFGenerator generator; + + @Inject JavaIoFileSystemAccess fileAccess; + + @Inject Provider resourceSetProvider; + + private void assertHasTargetProperty(Model model, String name) { + Assertions.assertNotNull(model); + Assertions.assertTrue( + model.getTarget().getConfig().getPairs().stream().anyMatch(p -> p.getName().equals(name))); + } + + /** + * Check that tracing target property affects the target configuration. + * + * @throws Exception + */ + @Test + public void testParsing() throws Exception { + assertHasTargetProperty( + parser.parse( + """ target C { tracing: true } - """), "tracing"); - } - - /** - * Check that when a federation has the "tracing" target property set, the generated federates - * will also have it set. - * @throws Exception - */ - @Test - public void testFederation() throws Exception { - fileAccess.setOutputPath("src-gen"); - - Model federation = parser.parse(""" + """), + "tracing"); + } + + /** + * Check that when a federation has the "tracing" target property set, the generated federates + * will also have it set. + * + * @throws Exception + */ + @Test + public void testFederation() throws Exception { + fileAccess.setOutputPath("src-gen"); + + Model federation = + parser.parse( + """ target C { tracing: true } reactor Foo { - + } federated reactor { a = new Foo() b = new Foo() } - """, URI.createFileURI("tmp/src/Federation.lf"), resourceSetProvider.get()); - assertHasTargetProperty(federation, "tracing"); - - var resource = federation.eResource(); - var context = new MainContext(Mode.STANDALONE, resource, fileAccess, () -> false); - - if (GeneratorUtils.isHostWindows()) return; - - generator.doGenerate(resource, fileAccess, context); - - String lfSrc = Files.readAllLines( - ((FedFileConfig)context.getFileConfig()).getSrcPath().resolve("federate__a.lf") - ).stream().reduce("\n", String::concat); - Model federate = parser.parse(lfSrc); - assertHasTargetProperty(federate, "tracing"); - } + """, + URI.createFileURI("tmp/src/Federation.lf"), + resourceSetProvider.get()); + assertHasTargetProperty(federation, "tracing"); + + var resource = federation.eResource(); + var context = new MainContext(Mode.STANDALONE, resource, fileAccess, () -> false); + + if (GeneratorUtils.isHostWindows()) return; + + generator.doGenerate(resource, fileAccess, context); + + String lfSrc = + Files.readAllLines( + ((FedFileConfig) context.getFileConfig()).getSrcPath().resolve("federate__a.lf")) + .stream() + .reduce("\n", String::concat); + Model federate = parser.parse(lfSrc); + assertHasTargetProperty(federate, "tracing"); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/ErrorInserter.java b/org.lflang.tests/src/org/lflang/tests/lsp/ErrorInserter.java index a7b1c9d8ec..a1948821eb 100644 --- a/org.lflang.tests/src/org/lflang/tests/lsp/ErrorInserter.java +++ b/org.lflang.tests/src/org/lflang/tests/lsp/ErrorInserter.java @@ -1,5 +1,6 @@ package org.lflang.tests.lsp; +import com.google.common.collect.ImmutableList; import java.io.Closeable; import java.io.IOException; import java.io.PrintWriter; @@ -17,339 +18,364 @@ import java.util.function.Predicate; import java.util.stream.Stream; -import com.google.common.collect.ImmutableList; - /** * Insert problems into integration tests. + * * @author Peter Donovan */ @SuppressWarnings("ClassCanBeRecord") class ErrorInserter { - /** A basic error inserter builder on which more specific error inserters can be built. */ - private static final Builder BASE_ERROR_INSERTER = new Builder() - .insertCondition((s0, s1) -> Stream.of(s0, s1).allMatch(it -> Stream.of(";", "}", "{").anyMatch(it::endsWith))) - .insertCondition((s0, s1) -> !s1.trim().startsWith("else")) - .insertable(" 0 = 1;").insertable("some_undeclared_var1524263 = 9;").insertable(" ++;"); - public static final Builder C = BASE_ERROR_INSERTER - .replacer("lf_set(", "UNDEFINED_NAME2828376(") - .replacer("lf_schedule(", "undefined_name15291838("); - public static final Builder CPP = BASE_ERROR_INSERTER - .replacer(".get", ".undefined_name15291838") - .replacer("std::", "undefined_name3286634::"); - public static final Builder PYTHON_SYNTAX_ONLY = new Builder() - .insertable(" +++++;").insertable(" .."); - public static final Builder PYTHON = PYTHON_SYNTAX_ONLY - .replacer("print(", "undefined_name15291838("); - public static final Builder RUST = BASE_ERROR_INSERTER - .replacer("println!", "undefined_name15291838!") - .replacer("ctx.", "undefined_name3286634."); - public static final Builder TYPESCRIPT = BASE_ERROR_INSERTER - .replacer("requestErrorStop(", "not_an_attribute_of_util9764(") - .replacer("const ", "var "); - - /** An {@code AlteredTest} represents an altered version of what was a valid LF file. */ - static class AlteredTest implements Closeable { - - /** A {@code OnceTrue} is randomly true once, and then never again. */ - private static class OnceTrue { - boolean beenTrue; - Random random; - private OnceTrue(Random random) { - this.beenTrue = false; - this.random = random; - } - private boolean get() { - if (beenTrue) return false; - return beenTrue = random.nextBoolean() && random.nextBoolean(); - } - } - - /** The zero-based indices of the touched lines. */ - private final List badLines; - /** The original test on which this is based. */ - private final Path srcFile; - /** The content of this test. */ - private final LinkedList lines; - /** Whether the error inserter is permitted to insert a line before the current line. */ - private final Predicate> insertCondition; - - /** - * Initialize a possibly altered copy of {@code originalTest}. - * @param originalTest A path to an LF file that serves as a test. - * @param insertCondition Whether the error inserter is permitted to insert a line between two given lines. - * @throws IOException if the content of {@code originalTest} cannot be read. - */ - private AlteredTest(Path originalTest, BiPredicate insertCondition) throws IOException { - this.badLines = new ArrayList<>(); - this.srcFile = originalTest; - this.lines = new LinkedList<>(); // Constant-time insertion during iteration is desired. - this.lines.addAll(Files.readAllLines(srcFile)); - this.insertCondition = it -> { - it.previous(); - String s0 = it.previous(); - it.next(); - String s1 = it.next(); - return insertCondition.test(s0, s1); - }; - } + /** A basic error inserter builder on which more specific error inserters can be built. */ + private static final Builder BASE_ERROR_INSERTER = + new Builder() + .insertCondition( + (s0, s1) -> + Stream.of(s0, s1).allMatch(it -> Stream.of(";", "}", "{").anyMatch(it::endsWith))) + .insertCondition((s0, s1) -> !s1.trim().startsWith("else")) + .insertable(" 0 = 1;") + .insertable("some_undeclared_var1524263 = 9;") + .insertable(" ++;"); + + public static final Builder C = + BASE_ERROR_INSERTER + .replacer("lf_set(", "UNDEFINED_NAME2828376(") + .replacer("lf_schedule(", "undefined_name15291838("); + public static final Builder CPP = + BASE_ERROR_INSERTER + .replacer(".get", ".undefined_name15291838") + .replacer("std::", "undefined_name3286634::"); + public static final Builder PYTHON_SYNTAX_ONLY = + new Builder().insertable(" +++++;").insertable(" .."); + public static final Builder PYTHON = + PYTHON_SYNTAX_ONLY.replacer("print(", "undefined_name15291838("); + public static final Builder RUST = + BASE_ERROR_INSERTER + .replacer("println!", "undefined_name15291838!") + .replacer("ctx.", "undefined_name3286634."); + public static final Builder TYPESCRIPT = + BASE_ERROR_INSERTER + .replacer("requestErrorStop(", "not_an_attribute_of_util9764(") + .replacer("const ", "var "); + + /** An {@code AlteredTest} represents an altered version of what was a valid LF file. */ + static class AlteredTest implements Closeable { + + /** A {@code OnceTrue} is randomly true once, and then never again. */ + private static class OnceTrue { + boolean beenTrue; + Random random; + + private OnceTrue(Random random) { + this.beenTrue = false; + this.random = random; + } - /** Return the location where the content of {@code this} lives. */ - public Path getSrcFile() { - return srcFile; - } + private boolean get() { + if (beenTrue) return false; + return beenTrue = random.nextBoolean() && random.nextBoolean(); + } + } - /** - * Write the altered version of the test to the file system. - * @throws IOException If an I/O error occurred. - */ - public void write() throws IOException { - Path src = srcFile; - if (!src.toFile().renameTo(swapFile(src).toFile())) { - throw new IOException("Failed to create a swap file."); - } - try (PrintWriter writer = new PrintWriter(src.toFile())) { - lines.forEach(writer::println); - } - } + /** The zero-based indices of the touched lines. */ + private final List badLines; + /** The original test on which this is based. */ + private final Path srcFile; + /** The content of this test. */ + private final LinkedList lines; + /** Whether the error inserter is permitted to insert a line before the current line. */ + private final Predicate> insertCondition; - /** - * Restore the file associated with this test to its original state. - */ - @Override - public void close() throws IOException { - Path src = srcFile; - if (!swapFile(src).toFile().exists()) throw new IllegalStateException("Swap file does not exist."); - if (!src.toFile().delete()) { - throw new IOException("Failed to delete the file associated with the original test."); - } - if (!swapFile(src).toFile().renameTo(src.toFile())) { - throw new IOException("Failed to restore the altered LF file to its original state."); - } - } + /** + * Initialize a possibly altered copy of {@code originalTest}. + * + * @param originalTest A path to an LF file that serves as a test. + * @param insertCondition Whether the error inserter is permitted to insert a line between two + * given lines. + * @throws IOException if the content of {@code originalTest} cannot be read. + */ + private AlteredTest(Path originalTest, BiPredicate insertCondition) + throws IOException { + this.badLines = new ArrayList<>(); + this.srcFile = originalTest; + this.lines = new LinkedList<>(); // Constant-time insertion during iteration is desired. + this.lines.addAll(Files.readAllLines(srcFile)); + this.insertCondition = + it -> { + it.previous(); + String s0 = it.previous(); + it.next(); + String s1 = it.next(); + return insertCondition.test(s0, s1); + }; + } - @Override - public String toString() { - int lengthOfPrefix = 6; - StringBuilder ret = new StringBuilder( - lines.stream().mapToInt(String::length).reduce(0, Integer::sum) - + lines.size() * lengthOfPrefix - ); - for (int i = 0; i < lines.size(); i++) { - ret.append(badLines.contains(i) ? "-> " : " ") - .append(String.format("%1$2s ", i)) - .append(lines.get(i)).append("\n"); - } - return ret.toString(); - } + /** Return the location where the content of {@code this} lives. */ + public Path getSrcFile() { + return srcFile; + } - /** Return the lines where this differs from the test from which it was derived. */ - public ImmutableList getBadLines() { - return ImmutableList.copyOf(badLines); - } + /** + * Write the altered version of the test to the file system. + * + * @throws IOException If an I/O error occurred. + */ + public void write() throws IOException { + Path src = srcFile; + if (!src.toFile().renameTo(swapFile(src).toFile())) { + throw new IOException("Failed to create a swap file."); + } + try (PrintWriter writer = new PrintWriter(src.toFile())) { + lines.forEach(writer::println); + } + } - /** - * Attempt to replace a line of this test with a different line of target language code. - * @param replacer A function that replaces lines of code with possibly different lines. - */ - public void replace(Function replacer, Random random) { - OnceTrue onceTrue = new OnceTrue(random); - alter((it, current) -> { - if (!onceTrue.get()) return false; - String newLine = replacer.apply(current); - it.remove(); - it.add(newLine); - return !newLine.equals(current); - }); - } + /** Restore the file associated with this test to its original state. */ + @Override + public void close() throws IOException { + Path src = srcFile; + if (!swapFile(src).toFile().exists()) + throw new IllegalStateException("Swap file does not exist."); + if (!src.toFile().delete()) { + throw new IOException("Failed to delete the file associated with the original test."); + } + if (!swapFile(src).toFile().renameTo(src.toFile())) { + throw new IOException("Failed to restore the altered LF file to its original state."); + } + } - /** - * Attempt to insert a new line of target language code into this test. - * @param line The line to be inserted. - */ - public void insert(String line, Random random) { - OnceTrue onceTrue = new OnceTrue(random); - alter((it, current) -> { - if (insertCondition.test(it) && onceTrue.get()) { - it.previous(); - it.add(line); - it.next(); - return true; - } - return false; - }); - } + @Override + public String toString() { + int lengthOfPrefix = 6; + StringBuilder ret = + new StringBuilder( + lines.stream().mapToInt(String::length).reduce(0, Integer::sum) + + lines.size() * lengthOfPrefix); + for (int i = 0; i < lines.size(); i++) { + ret.append(badLines.contains(i) ? "-> " : " ") + .append(String.format("%1$2s ", i)) + .append(lines.get(i)) + .append("\n"); + } + return ret.toString(); + } - /** - * Alter the content of this test. - * @param alterer A function whose first argument is an iterator over the lines of {@code this}, whose second - * argument is the line most recently returned by that iterator, and whose return value is - * whether an alteration was successfully performed. This function is only applied within - * multiline code blocks. - */ - private void alter(BiFunction, String, Boolean> alterer) { - ListIterator it = lines.listIterator(); - boolean inCodeBlock = false; - int lineNumber = 0; - while (it.hasNext()) { - String current = it.next(); - String uncommented = current.contains("//") ? - current.substring(0, current.indexOf("//")) : current; - uncommented = uncommented.contains("#") ? - uncommented.substring(0, uncommented.indexOf("#")) : current; - if (uncommented.contains("=}")) inCodeBlock = false; - if (inCodeBlock && alterer.apply(it, current)) badLines.add(lineNumber); - if (uncommented.contains("{=")) inCodeBlock = true; - if (uncommented.contains("{=") && uncommented.contains("=}")) { - inCodeBlock = uncommented.lastIndexOf("{=") > uncommented.lastIndexOf("=}"); - } - lineNumber++; - } - } + /** Return the lines where this differs from the test from which it was derived. */ + public ImmutableList getBadLines() { + return ImmutableList.copyOf(badLines); + } - /** Return the swap file associated with {@code f}. */ - private static Path swapFile(Path p) { - return p.getParent().resolve("." + p.getFileName() + ".swp"); - } + /** + * Attempt to replace a line of this test with a different line of target language code. + * + * @param replacer A function that replaces lines of code with possibly different lines. + */ + public void replace(Function replacer, Random random) { + OnceTrue onceTrue = new OnceTrue(random); + alter( + (it, current) -> { + if (!onceTrue.get()) return false; + String newLine = replacer.apply(current); + it.remove(); + it.add(newLine); + return !newLine.equals(current); + }); } - /** A builder for an error inserter. */ - public static class Builder { - private static class Node implements Iterable { - private final Node previous; - private final T item; - private Node(Node previous, T item) { - this.previous = previous; - this.item = item; + /** + * Attempt to insert a new line of target language code into this test. + * + * @param line The line to be inserted. + */ + public void insert(String line, Random random) { + OnceTrue onceTrue = new OnceTrue(random); + alter( + (it, current) -> { + if (insertCondition.test(it) && onceTrue.get()) { + it.previous(); + it.add(line); + it.next(); + return true; } + return false; + }); + } - @Override - public Iterator iterator() { - NodeIterator ret = new NodeIterator<>(); - ret.current = this; - return ret; - } + /** + * Alter the content of this test. + * + * @param alterer A function whose first argument is an iterator over the lines of {@code this}, + * whose second argument is the line most recently returned by that iterator, and whose + * return value is whether an alteration was successfully performed. This function is only + * applied within multiline code blocks. + */ + private void alter(BiFunction, String, Boolean> alterer) { + ListIterator it = lines.listIterator(); + boolean inCodeBlock = false; + int lineNumber = 0; + while (it.hasNext()) { + String current = it.next(); + String uncommented = + current.contains("//") ? current.substring(0, current.indexOf("//")) : current; + uncommented = + uncommented.contains("#") + ? uncommented.substring(0, uncommented.indexOf("#")) + : current; + if (uncommented.contains("=}")) inCodeBlock = false; + if (inCodeBlock && alterer.apply(it, current)) badLines.add(lineNumber); + if (uncommented.contains("{=")) inCodeBlock = true; + if (uncommented.contains("{=") && uncommented.contains("=}")) { + inCodeBlock = uncommented.lastIndexOf("{=") > uncommented.lastIndexOf("=}"); + } + lineNumber++; + } + } - private static class NodeIterator implements Iterator { - private Node current; + /** Return the swap file associated with {@code f}. */ + private static Path swapFile(Path p) { + return p.getParent().resolve("." + p.getFileName() + ".swp"); + } + } - @Override - public boolean hasNext() { - return current != null; - } + /** A builder for an error inserter. */ + public static class Builder { + private static class Node implements Iterable { + private final Node previous; + private final T item; - @Override - public T next() { - T ret = current.item; - current = current.previous; - return ret; - } - } - } - private final Node> replacers; - private final Node insertables; - private final BiPredicate insertCondition; + private Node(Node previous, T item) { + this.previous = previous; + this.item = item; + } - /** Initializes a builder for error inserters. */ - public Builder() { - this(null, null, (s0, s1) -> true); - } + @Override + public Iterator iterator() { + NodeIterator ret = new NodeIterator<>(); + ret.current = this; + return ret; + } - /** Construct a builder with the given replacers and insertables. */ - private Builder( - Node> replacers, - Node insertables, - BiPredicate insertCondition - ) { - this.replacers = replacers; - this.insertables = insertables; - this.insertCondition = insertCondition; - } + private static class NodeIterator implements Iterator { + private Node current; - /** - * Record that the resulting {@code ErrorInserter} may replace {@code phrase} with {@code alternativePhrase}. - * @param phrase A phrase in target language code. - * @param alternativePhrase A phrase that {@code phrase} may be replaced with in order to introduce an error. - * @return A {@code Builder} that knows about all the edits that {@code this} knows about, plus the edit that - * replaces {@code phrase} with {@code alternativePhrase}. - */ - public Builder replacer(String phrase, String alternativePhrase) { - return new Builder( - new Node<>( - replacers, - line -> { - int changeableEnd = line.length(); - for (String bad : new String[]{"#", "//", "\""}) { - if (line.contains(bad)) changeableEnd = Math.min(changeableEnd, line.indexOf(bad)); - } - return line.substring(0, changeableEnd).replace(phrase, alternativePhrase) - + line.substring(changeableEnd); - } - ), - insertables, - insertCondition - ); + @Override + public boolean hasNext() { + return current != null; } - /** Record that {@code} line may be inserted in order to introduce an error. */ - public Builder insertable(String line) { - return new Builder(replacers, new Node<>(insertables, line), insertCondition); + @Override + public T next() { + T ret = current.item; + current = current.previous; + return ret; } + } + } - /** - * Record that for any lines X, Y, insertCondition(X, Y) is a necessary condition that a line may be inserted - * between X and Y. - */ - public Builder insertCondition(BiPredicate insertCondition) { - return new Builder(replacers, insertables, this.insertCondition.and(insertCondition)); - } + private final Node> replacers; + private final Node insertables; + private final BiPredicate insertCondition; - /** Get the error inserter generated by {@code this}. */ - public ErrorInserter get(Random random) { - return new ErrorInserter( - random, - replacers == null ? ImmutableList.of() : ImmutableList.copyOf(replacers), - insertables == null ? ImmutableList.of() : ImmutableList.copyOf(insertables), - insertCondition - ); - } + /** Initializes a builder for error inserters. */ + public Builder() { + this(null, null, (s0, s1) -> true); } - private static final int MAX_ALTERATION_ATTEMPTS = 100; + /** Construct a builder with the given replacers and insertables. */ + private Builder( + Node> replacers, + Node insertables, + BiPredicate insertCondition) { + this.replacers = replacers; + this.insertables = insertables; + this.insertCondition = insertCondition; + } - private final Random random; - private final ImmutableList> replacers; - private final ImmutableList insertables; - private final BiPredicate insertCondition; + /** + * Record that the resulting {@code ErrorInserter} may replace {@code phrase} with {@code + * alternativePhrase}. + * + * @param phrase A phrase in target language code. + * @param alternativePhrase A phrase that {@code phrase} may be replaced with in order to + * introduce an error. + * @return A {@code Builder} that knows about all the edits that {@code this} knows about, plus + * the edit that replaces {@code phrase} with {@code alternativePhrase}. + */ + public Builder replacer(String phrase, String alternativePhrase) { + return new Builder( + new Node<>( + replacers, + line -> { + int changeableEnd = line.length(); + for (String bad : new String[] {"#", "//", "\""}) { + if (line.contains(bad)) + changeableEnd = Math.min(changeableEnd, line.indexOf(bad)); + } + return line.substring(0, changeableEnd).replace(phrase, alternativePhrase) + + line.substring(changeableEnd); + }), + insertables, + insertCondition); + } - private ErrorInserter( - Random random, - ImmutableList> replacers, - ImmutableList insertables, - BiPredicate insertCondition - ) { - this.random = random; - this.replacers = replacers; - this.insertables = insertables; - this.insertCondition = insertCondition; + /** Record that {@code} line may be inserted in order to introduce an error. */ + public Builder insertable(String line) { + return new Builder(replacers, new Node<>(insertables, line), insertCondition); } /** - * Alter the given test and return the altered version. - * @param test The path to the test. - * @return An {@code AlteredTest} that is based on {@code test}. + * Record that for any lines X, Y, insertCondition(X, Y) is a necessary condition that a line + * may be inserted between X and Y. */ - public AlteredTest alterTest(Path test) throws IOException { - AlteredTest alterable = new AlteredTest(test, insertCondition); - int remainingAlterationAttempts = MAX_ALTERATION_ATTEMPTS; - while (alterable.getBadLines().isEmpty() && remainingAlterationAttempts-- > 0) { - if (random.nextBoolean() && !replacers.isEmpty()) { - alterable.replace(replacers.get(random.nextInt(replacers.size())), random); - } else if (!insertables.isEmpty()) { - alterable.insert(insertables.get(random.nextInt(insertables.size())), random); - } - } - alterable.write(); - return alterable; + public Builder insertCondition(BiPredicate insertCondition) { + return new Builder(replacers, insertables, this.insertCondition.and(insertCondition)); + } + + /** Get the error inserter generated by {@code this}. */ + public ErrorInserter get(Random random) { + return new ErrorInserter( + random, + replacers == null ? ImmutableList.of() : ImmutableList.copyOf(replacers), + insertables == null ? ImmutableList.of() : ImmutableList.copyOf(insertables), + insertCondition); + } + } + + private static final int MAX_ALTERATION_ATTEMPTS = 100; + + private final Random random; + private final ImmutableList> replacers; + private final ImmutableList insertables; + private final BiPredicate insertCondition; + + private ErrorInserter( + Random random, + ImmutableList> replacers, + ImmutableList insertables, + BiPredicate insertCondition) { + this.random = random; + this.replacers = replacers; + this.insertables = insertables; + this.insertCondition = insertCondition; + } + + /** + * Alter the given test and return the altered version. + * + * @param test The path to the test. + * @return An {@code AlteredTest} that is based on {@code test}. + */ + public AlteredTest alterTest(Path test) throws IOException { + AlteredTest alterable = new AlteredTest(test, insertCondition); + int remainingAlterationAttempts = MAX_ALTERATION_ATTEMPTS; + while (alterable.getBadLines().isEmpty() && remainingAlterationAttempts-- > 0) { + if (random.nextBoolean() && !replacers.isEmpty()) { + alterable.replace(replacers.get(random.nextInt(replacers.size())), random); + } else if (!insertables.isEmpty()) { + alterable.insert(insertables.get(random.nextInt(insertables.size())), random); + } } + alterable.write(); + return alterable; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java b/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java index 99c1260d44..fe52d6016c 100644 --- a/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java +++ b/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java @@ -9,12 +9,10 @@ import java.util.Set; import java.util.function.Function; import java.util.function.Predicate; - -import org.eclipse.lsp4j.Diagnostic; import org.eclipse.emf.common.util.URI; +import org.eclipse.lsp4j.Diagnostic; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; - import org.lflang.LFRuntimeModule; import org.lflang.LFStandaloneSetup; import org.lflang.Target; @@ -33,188 +31,211 @@ */ class LspTests { - /** The test categories that should be excluded from LSP tests. */ - private static final TestCategory[] EXCLUDED_CATEGORIES = { - TestCategory.SERIALIZATION, TestCategory.DOCKER, TestCategory.DOCKER_FEDERATED - }; - private static final Predicate> NOT_SUPPORTED = diagnosticsHaveKeyword("supported"); - private static final Predicate> MISSING_DEPENDENCY = diagnosticsHaveKeyword("libprotoc") - .or(diagnosticsHaveKeyword("protoc-c")).or(diagnosticsIncludeText("could not be found")); - /** The number of samples to take from each test category (with replacement) when doing validation tests. */ - private static final int SAMPLES_PER_CATEGORY_VALIDATION_TESTS = 3; - - /** The {@code IntegratedBuilder} instance whose behavior is to be tested. */ - private static final IntegratedBuilder builder = new LFStandaloneSetup(new LFRuntimeModule()) - .createInjectorAndDoEMFRegistration().getInstance(IntegratedBuilder.class); - - /** Test for false negatives in Python syntax-only validation. */ - @Test - void pythonValidationTestSyntaxOnly() throws IOException { - targetLanguageValidationTest(Target.Python, ErrorInserter.PYTHON_SYNTAX_ONLY); - } - - /** Test for false negatives in C++ validation. */ - @Test - void cppValidationTest() throws IOException { - targetLanguageValidationTest(Target.CPP, ErrorInserter.CPP); - } - - /** Test for false negatives in Python validation. */ - @Test - void pythonValidationTest() throws IOException { - targetLanguageValidationTest(Target.Python, ErrorInserter.PYTHON); - } - - /** Test for false negatives in Rust validation. */ - @Test - void rustValidationTest() throws IOException { - targetLanguageValidationTest(Target.Rust, ErrorInserter.RUST); - } - - /** Test for false negatives in TypeScript validation. */ - @Test - void typescriptValidationTest() throws IOException { - targetLanguageValidationTest(Target.TS, ErrorInserter.TYPESCRIPT); - } - - /** - * Test for false negatives in the validation of LF files. - * @param target The target language of the LF files to be validated. - * @param builder A builder for the error inserter that will be used. - */ - private void targetLanguageValidationTest(Target target, ErrorInserter.Builder builder) throws IOException { - long seed = new Random().nextLong(); - System.out.printf("Running validation tests for %s with random seed %d.%n", target.getDisplayName(), seed); - Random random = new Random(seed); - int i = SAMPLES_PER_CATEGORY_VALIDATION_TESTS; - while (i-- > 0) checkDiagnostics( - target, - alteredTest -> MISSING_DEPENDENCY.or(diagnostics -> alteredTest.getBadLines().stream().allMatch( - badLine -> { - System.out.print("Expecting an error to be reported at line " + badLine + "..."); - boolean result = NOT_SUPPORTED.test(diagnostics) || diagnostics.stream().anyMatch( - diagnostic -> diagnostic.getRange().getStart().getLine() == badLine - ); - if (result) { - System.out.println(" Success."); - } else { - System.out.println(" but the expected error could not be found."); - System.out.printf( - "%s failed. Content of altered version of %s:%n%s%n", - alteredTest.getSrcFile(), - alteredTest.getSrcFile(), - TestBase.THIN_LINE - ); - System.out.println(alteredTest + "\n" + TestBase.THIN_LINE); - } - return result; - } - )), - builder.get(random), - random - ); - } - - /** - * Verify that the diagnostics that result from fully validating tests associated with {@code target} satisfy - * {@code requirementGetter}. - * @param target Any target language. - * @param requirementGetter A map from altered tests to the requirements that diagnostics regarding those tests - * must meet. - * @param alterer The means of inserting problems into the tests, or {@code null} if problems are not to be - * inserted. - * @param random The {@code Random} instance that determines which tests are selected. - * @throws IOException upon failure to write an altered copy of some test to storage. - */ - private void checkDiagnostics( - Target target, - Function>> requirementGetter, - ErrorInserter alterer, - Random random - ) throws IOException { - MockLanguageClient client = new MockLanguageClient(); - LanguageServerErrorReporter.setClient(client); - for (LFTest test : selectTests(target, random)) { - client.clearDiagnostics(); - if (alterer != null) { - try (AlteredTest altered = alterer.alterTest(test.getSrcPath())) { - runTest(altered.getSrcFile()); - Assertions.assertTrue(requirementGetter.apply(altered).test(client.getReceivedDiagnostics())); - } - } else { - runTest(test.getSrcPath()); - Assertions.assertTrue(requirementGetter.apply(null).test(client.getReceivedDiagnostics())); - } + /** The test categories that should be excluded from LSP tests. */ + private static final TestCategory[] EXCLUDED_CATEGORIES = { + TestCategory.SERIALIZATION, TestCategory.DOCKER, TestCategory.DOCKER_FEDERATED + }; + + private static final Predicate> NOT_SUPPORTED = + diagnosticsHaveKeyword("supported"); + private static final Predicate> MISSING_DEPENDENCY = + diagnosticsHaveKeyword("libprotoc") + .or(diagnosticsHaveKeyword("protoc-c")) + .or(diagnosticsIncludeText("could not be found")); + /** + * The number of samples to take from each test category (with replacement) when doing validation + * tests. + */ + private static final int SAMPLES_PER_CATEGORY_VALIDATION_TESTS = 3; + + /** The {@code IntegratedBuilder} instance whose behavior is to be tested. */ + private static final IntegratedBuilder builder = + new LFStandaloneSetup(new LFRuntimeModule()) + .createInjectorAndDoEMFRegistration() + .getInstance(IntegratedBuilder.class); + + /** Test for false negatives in Python syntax-only validation. */ + @Test + void pythonValidationTestSyntaxOnly() throws IOException { + targetLanguageValidationTest(Target.Python, ErrorInserter.PYTHON_SYNTAX_ONLY); + } + + /** Test for false negatives in C++ validation. */ + @Test + void cppValidationTest() throws IOException { + targetLanguageValidationTest(Target.CPP, ErrorInserter.CPP); + } + + /** Test for false negatives in Python validation. */ + @Test + void pythonValidationTest() throws IOException { + targetLanguageValidationTest(Target.Python, ErrorInserter.PYTHON); + } + + /** Test for false negatives in Rust validation. */ + @Test + void rustValidationTest() throws IOException { + targetLanguageValidationTest(Target.Rust, ErrorInserter.RUST); + } + + /** Test for false negatives in TypeScript validation. */ + @Test + void typescriptValidationTest() throws IOException { + targetLanguageValidationTest(Target.TS, ErrorInserter.TYPESCRIPT); + } + + /** + * Test for false negatives in the validation of LF files. + * + * @param target The target language of the LF files to be validated. + * @param builder A builder for the error inserter that will be used. + */ + private void targetLanguageValidationTest(Target target, ErrorInserter.Builder builder) + throws IOException { + long seed = new Random().nextLong(); + System.out.printf( + "Running validation tests for %s with random seed %d.%n", target.getDisplayName(), seed); + Random random = new Random(seed); + int i = SAMPLES_PER_CATEGORY_VALIDATION_TESTS; + while (i-- > 0) + checkDiagnostics( + target, + alteredTest -> + MISSING_DEPENDENCY.or( + diagnostics -> + alteredTest.getBadLines().stream() + .allMatch( + badLine -> { + System.out.print( + "Expecting an error to be reported at line " + badLine + "..."); + boolean result = + NOT_SUPPORTED.test(diagnostics) + || diagnostics.stream() + .anyMatch( + diagnostic -> + diagnostic.getRange().getStart().getLine() + == badLine); + if (result) { + System.out.println(" Success."); + } else { + System.out.println(" but the expected error could not be found."); + System.out.printf( + "%s failed. Content of altered version of %s:%n%s%n", + alteredTest.getSrcFile(), + alteredTest.getSrcFile(), + TestBase.THIN_LINE); + System.out.println(alteredTest + "\n" + TestBase.THIN_LINE); + } + return result; + })), + builder.get(random), + random); + } + + /** + * Verify that the diagnostics that result from fully validating tests associated with {@code + * target} satisfy {@code requirementGetter}. + * + * @param target Any target language. + * @param requirementGetter A map from altered tests to the requirements that diagnostics + * regarding those tests must meet. + * @param alterer The means of inserting problems into the tests, or {@code null} if problems are + * not to be inserted. + * @param random The {@code Random} instance that determines which tests are selected. + * @throws IOException upon failure to write an altered copy of some test to storage. + */ + private void checkDiagnostics( + Target target, + Function>> requirementGetter, + ErrorInserter alterer, + Random random) + throws IOException { + MockLanguageClient client = new MockLanguageClient(); + LanguageServerErrorReporter.setClient(client); + for (LFTest test : selectTests(target, random)) { + client.clearDiagnostics(); + if (alterer != null) { + try (AlteredTest altered = alterer.alterTest(test.getSrcPath())) { + runTest(altered.getSrcFile()); + Assertions.assertTrue( + requirementGetter.apply(altered).test(client.getReceivedDiagnostics())); } + } else { + runTest(test.getSrcPath()); + Assertions.assertTrue(requirementGetter.apply(null).test(client.getReceivedDiagnostics())); + } } - - /** - * Select a test from each test category. - * @param target The target language of the desired tests. - * @param random The {@code Random} instance that determines which tests are selected. - * @return A sample of one integration test per target, per category. - */ - private Set selectTests(Target target, Random random) { - Set ret = new HashSet<>(); - for (TestCategory category : selectedCategories()) { - Set registeredTests = TestRegistry.getRegisteredTests(target, category, false); - if (registeredTests.size() == 0) continue; - int relativeIndex = random.nextInt(registeredTests.size()); - for (LFTest t : registeredTests) { - if (relativeIndex-- == 0) { - ret.add(t); - break; - } - } + } + + /** + * Select a test from each test category. + * + * @param target The target language of the desired tests. + * @param random The {@code Random} instance that determines which tests are selected. + * @return A sample of one integration test per target, per category. + */ + private Set selectTests(Target target, Random random) { + Set ret = new HashSet<>(); + for (TestCategory category : selectedCategories()) { + Set registeredTests = TestRegistry.getRegisteredTests(target, category, false); + if (registeredTests.size() == 0) continue; + int relativeIndex = random.nextInt(registeredTests.size()); + for (LFTest t : registeredTests) { + if (relativeIndex-- == 0) { + ret.add(t); + break; } - return ret; - } - - /** Return the non-excluded categories. */ - private Iterable selectedCategories() { - return () -> Arrays.stream(TestCategory.values()).filter( - category -> Arrays.stream(EXCLUDED_CATEGORIES).noneMatch(category::equals) - ).iterator(); + } } - - /** - * Return the predicate that a list of diagnostics contains the given keyword. - * @param keyword A keyword that a list of diagnostics should be searched for. - * @return The predicate, "X mentions {@code keyword}." - */ - private static Predicate> diagnosticsHaveKeyword(String keyword) { - return diagnostics -> diagnostics.stream().anyMatch( - d -> Arrays.asList(d.getMessage().toLowerCase().split("\\b")).contains(keyword) - ); - } - - /** - * Return the predicate that a list of diagnostics contains the given text. - * @param requiredText A keyword that a list of diagnostics should be searched for. - * @return The predicate, "X includes {@code requiredText}." - */ - private static Predicate> diagnosticsIncludeText(@SuppressWarnings("SameParameterValue") String requiredText) { - return diagnostics -> diagnostics.stream().anyMatch( - d -> d.getMessage().toLowerCase().contains(requiredText) - ); - } - - /** - * Run the given test. - * @param test The test b - */ - private void runTest(Path test) { - MockReportProgress reportProgress = new MockReportProgress(); - try { - builder.run( - URI.createFileURI(test.toString()), - false, reportProgress, - () -> false - ); - } catch (Exception e) { - e.printStackTrace(); - throw e; - } - Assertions.assertFalse(reportProgress.failed()); + return ret; + } + + /** Return the non-excluded categories. */ + private Iterable selectedCategories() { + return () -> + Arrays.stream(TestCategory.values()) + .filter(category -> Arrays.stream(EXCLUDED_CATEGORIES).noneMatch(category::equals)) + .iterator(); + } + + /** + * Return the predicate that a list of diagnostics contains the given keyword. + * + * @param keyword A keyword that a list of diagnostics should be searched for. + * @return The predicate, "X mentions {@code keyword}." + */ + private static Predicate> diagnosticsHaveKeyword(String keyword) { + return diagnostics -> + diagnostics.stream() + .anyMatch( + d -> Arrays.asList(d.getMessage().toLowerCase().split("\\b")).contains(keyword)); + } + + /** + * Return the predicate that a list of diagnostics contains the given text. + * + * @param requiredText A keyword that a list of diagnostics should be searched for. + * @return The predicate, "X includes {@code requiredText}." + */ + private static Predicate> diagnosticsIncludeText( + @SuppressWarnings("SameParameterValue") String requiredText) { + return diagnostics -> + diagnostics.stream().anyMatch(d -> d.getMessage().toLowerCase().contains(requiredText)); + } + + /** + * Run the given test. + * + * @param test The test b + */ + private void runTest(Path test) { + MockReportProgress reportProgress = new MockReportProgress(); + try { + builder.run(URI.createFileURI(test.toString()), false, reportProgress, () -> false); + } catch (Exception e) { + e.printStackTrace(); + throw e; } + Assertions.assertFalse(reportProgress.failed()); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/MockLanguageClient.java b/org.lflang.tests/src/org/lflang/tests/lsp/MockLanguageClient.java index 8aad48c547..1e3e06ef05 100644 --- a/org.lflang.tests/src/org/lflang/tests/lsp/MockLanguageClient.java +++ b/org.lflang.tests/src/org/lflang/tests/lsp/MockLanguageClient.java @@ -4,7 +4,6 @@ import java.util.Collections; import java.util.List; import java.util.concurrent.CompletableFuture; - import org.eclipse.lsp4j.Diagnostic; import org.eclipse.lsp4j.DiagnosticSeverity; import org.eclipse.lsp4j.MessageActionItem; @@ -20,49 +19,53 @@ */ public class MockLanguageClient implements LanguageClient { - private List receivedDiagnostics = new ArrayList<>(); + private List receivedDiagnostics = new ArrayList<>(); - @Override - public void telemetryEvent(Object object) { - // Do nothing. - } + @Override + public void telemetryEvent(Object object) { + // Do nothing. + } - @Override - public void publishDiagnostics(PublishDiagnosticsParams diagnostics) { - receivedDiagnostics.addAll(diagnostics.getDiagnostics()); - for (Diagnostic d : diagnostics.getDiagnostics()) { - ( - (d.getSeverity() == DiagnosticSeverity.Error || d.getSeverity() == DiagnosticSeverity.Warning) ? - System.err : System.out - ).println( - "Test client received diagnostic at line " + d.getRange().getStart().getLine() + ": " + d.getMessage() - ); - } + @Override + public void publishDiagnostics(PublishDiagnosticsParams diagnostics) { + receivedDiagnostics.addAll(diagnostics.getDiagnostics()); + for (Diagnostic d : diagnostics.getDiagnostics()) { + ((d.getSeverity() == DiagnosticSeverity.Error + || d.getSeverity() == DiagnosticSeverity.Warning) + ? System.err + : System.out) + .println( + "Test client received diagnostic at line " + + d.getRange().getStart().getLine() + + ": " + + d.getMessage()); } + } - @Override - public void showMessage(MessageParams messageParams) { - System.out.println("Test client received message: " + messageParams.getMessage()); - } + @Override + public void showMessage(MessageParams messageParams) { + System.out.println("Test client received message: " + messageParams.getMessage()); + } - @Override - public CompletableFuture showMessageRequest(ShowMessageRequestParams requestParams) { - showMessage(requestParams); - return null; - } + @Override + public CompletableFuture showMessageRequest( + ShowMessageRequestParams requestParams) { + showMessage(requestParams); + return null; + } - @Override - public void logMessage(MessageParams message) { - showMessage(message); - } + @Override + public void logMessage(MessageParams message) { + showMessage(message); + } - /** Return the diagnostics that {@code this} has received. */ - public List getReceivedDiagnostics() { - return Collections.unmodifiableList(receivedDiagnostics); - } + /** Return the diagnostics that {@code this} has received. */ + public List getReceivedDiagnostics() { + return Collections.unmodifiableList(receivedDiagnostics); + } - /** Clear the diagnostics recorded by {@code this}. */ - public void clearDiagnostics() { - receivedDiagnostics.clear(); - } + /** Clear the diagnostics recorded by {@code this}. */ + public void clearDiagnostics() { + receivedDiagnostics.clear(); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java b/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java index 014fcc7276..f0cfb088c1 100644 --- a/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java +++ b/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java @@ -8,26 +8,29 @@ * @author Peter Donovan */ public class MockReportProgress implements IntegratedBuilder.ReportProgress { - private int previousPercentProgress; - private boolean failed; - public MockReportProgress() { - previousPercentProgress = 0; - failed = false; - } + private int previousPercentProgress; + private boolean failed; - @Override - public void apply(String message, Integer percentage) { - System.out.printf("MockReportProgress: %s [%d -> %d]%n", message, previousPercentProgress, percentage); - if (percentage == null) return; - if (percentage < previousPercentProgress || percentage < 0 || percentage > 100) failed = true; - previousPercentProgress = percentage; - } + public MockReportProgress() { + previousPercentProgress = 0; + failed = false; + } - /** - * Returns whether an invalid sequence of progress reports was received. - * @return whether an invalid sequence of progress reports was received - */ - public boolean failed() { - return failed; - } + @Override + public void apply(String message, Integer percentage) { + System.out.printf( + "MockReportProgress: %s [%d -> %d]%n", message, previousPercentProgress, percentage); + if (percentage == null) return; + if (percentage < previousPercentProgress || percentage < 0 || percentage > 100) failed = true; + previousPercentProgress = percentage; + } + + /** + * Returns whether an invalid sequence of progress reports was received. + * + * @return whether an invalid sequence of progress reports was received + */ + public boolean failed() { + return failed; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CArduinoTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CArduinoTest.java index e783c335a0..95363fd30b 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CArduinoTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CArduinoTest.java @@ -2,9 +2,7 @@ import java.util.List; import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; - import org.lflang.Target; import org.lflang.tests.Configurators; import org.lflang.tests.RuntimeTest; @@ -17,17 +15,19 @@ */ public class CArduinoTest extends RuntimeTest { - public CArduinoTest() { - super(Target.C); - } + public CArduinoTest() { + super(Target.C); + } - @Test - public void buildArduinoTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runTestsFor(List.of(Target.C), - Message.DESC_ARDUINO, - TestCategory.ARDUINO::equals, Configurators::noChanges, - TestLevel.BUILD, - false); - } + @Test + public void buildArduinoTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runTestsFor( + List.of(Target.C), + Message.DESC_ARDUINO, + TestCategory.ARDUINO::equals, + Configurators::noChanges, + TestLevel.BUILD, + false); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java index c8c2fc5b93..ba1865e870 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java @@ -2,51 +2,49 @@ import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Test; -import org.lflang.ast.ASTUtils; import org.lflang.Target; +import org.lflang.ast.ASTUtils; import org.lflang.tests.TestBase; import org.lflang.tests.TestRegistry.TestCategory; /** * Collection of tests for the CCpp target. * - * NOTE: This test does not inherit any tests because it directly extends TestBase. + *

    NOTE: This test does not inherit any tests because it directly extends TestBase. * * @author Marten Lohstroh */ public class CCppTest extends TestBase { - /** - * This target selects the C target it has no tests defined for it. - * Instead, it reconfigures existing C tests to adopt the CCpp target. - */ - public CCppTest() { - super(Target.C); - } + /** + * This target selects the C target it has no tests defined for it. Instead, it reconfigures + * existing C tests to adopt the CCpp target. + */ + public CCppTest() { + super(Target.C); + } - /** - * Run C tests with the target CCpp. - */ - @Test - public void runAsCCpp() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - runTestsForTargets(Message.DESC_AS_CCPP, CCppTest::isExcludedFromCCpp, - it -> ASTUtils.changeTargetName(it.getFileConfig().resource, - Target.CCPP.getDisplayName()), - TestLevel.EXECUTION, - true); - } + /** Run C tests with the target CCpp. */ + @Test + public void runAsCCpp() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + runTestsForTargets( + Message.DESC_AS_CCPP, + CCppTest::isExcludedFromCCpp, + it -> ASTUtils.changeTargetName(it.getFileConfig().resource, Target.CCPP.getDisplayName()), + TestLevel.EXECUTION, + true); + } - /** - * Exclusion function for runAsCCpp test - */ - private static boolean isExcludedFromCCpp(TestCategory category) { - boolean excluded = category == TestCategory.SERIALIZATION; - excluded |= isWindows() && (category == TestCategory.DOCKER_FEDERATED); - excluded |= isMac() && (category == TestCategory.DOCKER_FEDERATED || category == TestCategory.DOCKER); - excluded |= category == TestCategory.ZEPHYR; - excluded |= category == TestCategory.ARDUINO; - excluded |= category == TestCategory.NO_INLINING; - return !excluded; - } + /** Exclusion function for runAsCCpp test */ + private static boolean isExcludedFromCCpp(TestCategory category) { + boolean excluded = category == TestCategory.SERIALIZATION; + excluded |= isWindows() && (category == TestCategory.DOCKER_FEDERATED); + excluded |= + isMac() && (category == TestCategory.DOCKER_FEDERATED || category == TestCategory.DOCKER); + excluded |= category == TestCategory.ZEPHYR; + excluded |= category == TestCategory.ARDUINO; + excluded |= category == TestCategory.NO_INLINING; + return !excluded; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CSchedulerTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CSchedulerTest.java index fa387d8a00..fd2345723f 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CSchedulerTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CSchedulerTest.java @@ -1,74 +1,65 @@ package org.lflang.tests.runtime; import java.util.EnumSet; - import org.junit.jupiter.api.Test; - import org.lflang.Target; import org.lflang.TargetProperty.SchedulerOption; import org.lflang.tests.Configurators; import org.lflang.tests.TestBase; import org.lflang.tests.TestRegistry.TestCategory; -/** - */ +/** */ public class CSchedulerTest extends TestBase { + public CSchedulerTest() { + super(Target.C); + } - public CSchedulerTest() { - super(Target.C); - } - - /** - * Swap the default runtime scheduler with other supported versions and - * run all the supported tests. Only run tests for a specific non-default - * scheduler if specified using a system property (e.g., -Dscheduler=GEDF_NP). - */ - @Test - public void runWithNonDefaultSchedulers() { - EnumSet categories = EnumSet.of(TestCategory.CONCURRENT, - TestCategory.MULTIPORT); - - // Add federated and docker tests if supported - if (!isWindows()) { - categories.add(TestCategory.FEDERATED); - if (isLinux()) { - categories.add(TestCategory.DOCKER_FEDERATED); - } - } - var name = System.getProperty("scheduler"); + /** + * Swap the default runtime scheduler with other supported versions and run all the supported + * tests. Only run tests for a specific non-default scheduler if specified using a system property + * (e.g., -Dscheduler=GEDF_NP). + */ + @Test + public void runWithNonDefaultSchedulers() { + EnumSet categories = EnumSet.of(TestCategory.CONCURRENT, TestCategory.MULTIPORT); - if (name != null) { - var option = EnumSet.allOf(SchedulerOption.class).stream() - .filter(it -> it.name().equals(name)).findFirst(); - if (option.isPresent()) { - this.runTest(option.get(), categories); - } else { - throw new RuntimeException("Cannot find runtime scheduler called " + name); - } - } else { - for (SchedulerOption scheduler: EnumSet.allOf(SchedulerOption.class)) { - if (scheduler == SchedulerOption.getDefault()) continue; - this.runTest(scheduler, categories); - } - } + // Add federated and docker tests if supported + if (!isWindows()) { + categories.add(TestCategory.FEDERATED); + if (isLinux()) { + categories.add(TestCategory.DOCKER_FEDERATED); + } } + var name = System.getProperty("scheduler"); - private void runTest(SchedulerOption scheduler, EnumSet categories) { - this.runTestsForTargets( - Message.DESC_SCHED_SWAPPING + scheduler.toString() +".", - categories::contains, - test -> { - test.getContext().getArgs() - .setProperty( - "scheduler", - scheduler.toString() - ); - return Configurators.noChanges(test); - }, - TestLevel.EXECUTION, - true - ); + if (name != null) { + var option = + EnumSet.allOf(SchedulerOption.class).stream() + .filter(it -> it.name().equals(name)) + .findFirst(); + if (option.isPresent()) { + this.runTest(option.get(), categories); + } else { + throw new RuntimeException("Cannot find runtime scheduler called " + name); + } + } else { + for (SchedulerOption scheduler : EnumSet.allOf(SchedulerOption.class)) { + if (scheduler == SchedulerOption.getDefault()) continue; + this.runTest(scheduler, categories); + } } -} + } + private void runTest(SchedulerOption scheduler, EnumSet categories) { + this.runTestsForTargets( + Message.DESC_SCHED_SWAPPING + scheduler.toString() + ".", + categories::contains, + test -> { + test.getContext().getArgs().setProperty("scheduler", scheduler.toString()); + return Configurators.noChanges(test); + }, + TestLevel.EXECUTION, + true); + } +} diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java index eba4f7bc71..4902550661 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java @@ -1,133 +1,131 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.runtime; import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; - import org.lflang.Target; import org.lflang.tests.RuntimeTest; /** * Collection of tests for the C target. * - * Tests that are implemented in the base class are still overridden so that - * each test can be easily invoked individually from IDEs with JUnit support - * like Eclipse and IntelliJ. - * This is typically done by right-clicking on the name of the test method and - * then clicking "Run".* + *

    Tests that are implemented in the base class are still overridden so that each test can be + * easily invoked individually from IDEs with JUnit support like Eclipse and IntelliJ. This is + * typically done by right-clicking on the name of the test method and then clicking "Run".* + * * @author Marten Lohstroh */ public class CTest extends RuntimeTest { - public CTest() { - super(Target.C); - } - - @Override - protected boolean supportsSingleThreadedExecution() { - return true; - } - - @Override - protected boolean supportsFederatedExecution() { - return true; - } - - @Override - protected boolean supportsDockerOption() { - return true; - } - - @Test - @Override - public void runGenericTests() { - super.runGenericTests(); - } - - @Test - @Override - public void runTargetSpecificTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runTargetSpecificTests(); - } - - @Test - @Override - public void runMultiportTests() { - super.runMultiportTests(); - } - - @Test - @Override - public void runWithThreadingOff() { - super.runWithThreadingOff(); - } - - @Test - @Disabled("TODO only 27/96 tests pass") - @Override - public void runAsFederated() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runAsFederated(); - } - - @Test - @Override - public void runConcurrentTests() { - super.runConcurrentTests(); - } - - @Test - @Override - public void runFederatedTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runFederatedTests(); - } - - @Test - public void runModalTests() { - super.runModalTests(); - } - - @Test - public void runNoInliningTests() { - super.runNoInliningTests(); - } - - @Test - @Override - public void runDockerTests() { - super.runDockerTests(); - } - - @Test - @Override - public void runDockerFederatedTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runDockerFederatedTests(); - } + public CTest() { + super(Target.C); + } + + @Override + protected boolean supportsSingleThreadedExecution() { + return true; + } + + @Override + protected boolean supportsFederatedExecution() { + return true; + } + + @Override + protected boolean supportsDockerOption() { + return true; + } + + @Test + @Override + public void runGenericTests() { + super.runGenericTests(); + } + + @Test + @Override + public void runTargetSpecificTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runTargetSpecificTests(); + } + + @Test + @Override + public void runMultiportTests() { + super.runMultiportTests(); + } + + @Test + @Override + public void runWithThreadingOff() { + super.runWithThreadingOff(); + } + + @Test + @Disabled("TODO only 27/96 tests pass") + @Override + public void runAsFederated() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runAsFederated(); + } + + @Test + @Override + public void runConcurrentTests() { + super.runConcurrentTests(); + } + + @Test + @Override + public void runFederatedTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runFederatedTests(); + } + + @Test + public void runModalTests() { + super.runModalTests(); + } + + @Test + public void runNoInliningTests() { + super.runNoInliningTests(); + } + + @Test + @Override + public void runDockerTests() { + super.runDockerTests(); + } + + @Test + @Override + public void runDockerFederatedTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runDockerFederatedTests(); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java index afe1646829..c151c1bb76 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java @@ -1,35 +1,32 @@ /************* -Copyright (c) 2023, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2023, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.runtime; import java.util.List; - import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; - import org.lflang.Target; import org.lflang.tests.Configurators; import org.lflang.tests.RuntimeTest; @@ -42,29 +39,31 @@ */ public class CZephyrTest extends RuntimeTest { - public CZephyrTest() { - super(Target.C); - } + public CZephyrTest() { + super(Target.C); + } - @Test - public void buildZephyrTests() { - Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); - super.runTestsFor(List.of(Target.C), - Message.DESC_ZEPHYR, - TestCategory.ZEPHYR::equals, - Configurators::makeZephyrCompatible, - TestLevel.BUILD, - false); - } - @Test - public void buildGenericTests() { - Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); - super.runTestsFor(List.of(Target.C), - Message.DESC_GENERIC, - TestCategory.GENERIC::equals, - Configurators::makeZephyrCompatible, - TestLevel.BUILD, - false); - } -} + @Test + public void buildZephyrTests() { + Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); + super.runTestsFor( + List.of(Target.C), + Message.DESC_ZEPHYR, + TestCategory.ZEPHYR::equals, + Configurators::makeZephyrCompatible, + TestLevel.BUILD, + false); + } + @Test + public void buildGenericTests() { + Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); + super.runTestsFor( + List.of(Target.C), + Message.DESC_GENERIC, + TestCategory.GENERIC::equals, + Configurators::makeZephyrCompatible, + TestLevel.BUILD, + false); + } +} diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java b/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java index 2e4f6b78d3..dc2612c14b 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java @@ -2,9 +2,8 @@ import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Test; - -import org.lflang.ast.ASTUtils; import org.lflang.Target; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Element; import org.lflang.lf.LfFactory; import org.lflang.tests.TestBase; @@ -12,25 +11,27 @@ /** * Run C++ tests using the ROS2 platform. * - * NOTE: This test does not inherit any tests because it directly extends TestBase. + *

    NOTE: This test does not inherit any tests because it directly extends TestBase. * * @author Christian Menard */ public class CppRos2Test extends TestBase { - public CppRos2Test() { super(Target.CPP); } + public CppRos2Test() { + super(Target.CPP); + } - /** - * Run C++ tests with the ros2 target property set - */ - @Test - public void runWithRos2() { - Assumptions.assumeTrue(isLinux(), "Only supported on Linux"); - Element trueLiteral = LfFactory.eINSTANCE.createElement(); - trueLiteral.setLiteral("true"); - runTestsForTargets(Message.DESC_ROS2, it -> true, - it -> ASTUtils.addTargetProperty(it.getFileConfig().resource, "ros2", trueLiteral), - TestLevel.EXECUTION, - true); - } + /** Run C++ tests with the ros2 target property set */ + @Test + public void runWithRos2() { + Assumptions.assumeTrue(isLinux(), "Only supported on Linux"); + Element trueLiteral = LfFactory.eINSTANCE.createElement(); + trueLiteral.setLiteral("true"); + runTestsForTargets( + Message.DESC_ROS2, + it -> true, + it -> ASTUtils.addTargetProperty(it.getFileConfig().resource, "ros2", trueLiteral), + TestLevel.EXECUTION, + true); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CppTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CppTest.java index 77bf4e664a..20973189b9 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CppTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CppTest.java @@ -1,86 +1,84 @@ /* Integration tests for the C++ target. */ /************* -Copyright (c) 2021, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2021, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.runtime; -import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; /** - * Collection of tests for the Cpp target. - * Even though all tests are implemented in the base class, we override them - * here so that each test can be easily invoked individually from IDEs with - * JUnit support like Eclipse and IntelliJ. - * This is typically done by right-clicking on the name of the test method and - * then clicking "Run". + * Collection of tests for the Cpp target. Even though all tests are implemented in the base class, + * we override them here so that each test can be easily invoked individually from IDEs with JUnit + * support like Eclipse and IntelliJ. This is typically done by right-clicking on the name of the + * test method and then clicking "Run". * * @author Marten Lohstroh */ public class CppTest extends RuntimeTest { - public CppTest() { - super(Target.CPP); - } - - @Override - protected boolean supportsEnclaves() { return true; } - - @Test - @Override - public void runGenericTests() { - super.runGenericTests(); - } - - @Test - @Override - public void runTargetSpecificTests() { - super.runTargetSpecificTests(); - } - - @Test - @Override - public void runMultiportTests() { - super.runMultiportTests(); - } - - @Test - @Override - public void runConcurrentTests() { - super.runConcurrentTests(); - } - - @Test - @Override - public void runFederatedTests() { - super.runFederatedTests(); - } - - @Test - public void runRos2Tests() { } - + public CppTest() { + super(Target.CPP); + } + + @Override + protected boolean supportsEnclaves() { + return true; + } + + @Test + @Override + public void runGenericTests() { + super.runGenericTests(); + } + + @Test + @Override + public void runTargetSpecificTests() { + super.runTargetSpecificTests(); + } + + @Test + @Override + public void runMultiportTests() { + super.runMultiportTests(); + } + + @Test + @Override + public void runConcurrentTests() { + super.runConcurrentTests(); + } + + @Test + @Override + public void runFederatedTests() { + super.runFederatedTests(); + } + + @Test + public void runRos2Tests() {} } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/PythonTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/PythonTest.java index e028e6ac4d..1c258b7481 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/PythonTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/PythonTest.java @@ -1,31 +1,30 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.runtime; import java.util.Properties; - import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; @@ -35,94 +34,92 @@ /** * Collection of tests for the Python target. * - * Even though all tests are implemented in the base class, we override them - * here so that each test can be easily invoked individually from IDEs with - * JUnit support like Eclipse and IntelliJ. - * This is typically done by right-clicking on the name of the test method and - * then clicking "Run". + *

    Even though all tests are implemented in the base class, we override them here so that each + * test can be easily invoked individually from IDEs with JUnit support like Eclipse and IntelliJ. + * This is typically done by right-clicking on the name of the test method and then clicking "Run". * * @author Marten Lohstroh */ public class PythonTest extends RuntimeTest { - public PythonTest() { - super(Target.Python); - } - - @Override - protected void addExtraLfcArgs(Properties args) { - super.addExtraLfcArgs(args); - if (System.getProperty("os.name").startsWith("Windows")) { - // Use the RelWithDebInfo build type on Windows as the Debug/Test build type produces linker Errors in CI - args.setProperty("build-type", "RelWithDebInfo"); - } - } - - @Override - protected boolean supportsFederatedExecution() { - return true; - } - - @Override - protected boolean supportsSingleThreadedExecution() { - return true; - } - - @Override - protected boolean supportsDockerOption() { - return false; // FIXME: https://issues.lf-lang.org/1564 - } - - @Test - @Override - public void runGenericTests() { - super.runGenericTests(); - } - - @Test - @Override - public void runTargetSpecificTests() { - super.runTargetSpecificTests(); - } - - @Test - @Override - public void runMultiportTests() { - super.runMultiportTests(); - } - - @Test - @Disabled("TODO") - @Override - public void runAsFederated() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runAsFederated(); - } - - - @Test - @Override - public void runConcurrentTests() { - super.runConcurrentTests(); - } - - @Test - @Override - public void runFederatedTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runFederatedTests(); - } - - @Test - @Override - public void runDockerTests() { - super.runDockerTests(); - } - - @Test - @Override - public void runDockerFederatedTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runDockerFederatedTests(); + public PythonTest() { + super(Target.Python); + } + + @Override + protected void addExtraLfcArgs(Properties args) { + super.addExtraLfcArgs(args); + if (System.getProperty("os.name").startsWith("Windows")) { + // Use the RelWithDebInfo build type on Windows as the Debug/Test build type produces linker + // Errors in CI + args.setProperty("build-type", "RelWithDebInfo"); } + } + + @Override + protected boolean supportsFederatedExecution() { + return true; + } + + @Override + protected boolean supportsSingleThreadedExecution() { + return true; + } + + @Override + protected boolean supportsDockerOption() { + return false; // FIXME: https://issues.lf-lang.org/1564 + } + + @Test + @Override + public void runGenericTests() { + super.runGenericTests(); + } + + @Test + @Override + public void runTargetSpecificTests() { + super.runTargetSpecificTests(); + } + + @Test + @Override + public void runMultiportTests() { + super.runMultiportTests(); + } + + @Test + @Disabled("TODO") + @Override + public void runAsFederated() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runAsFederated(); + } + + @Test + @Override + public void runConcurrentTests() { + super.runConcurrentTests(); + } + + @Test + @Override + public void runFederatedTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runFederatedTests(); + } + + @Test + @Override + public void runDockerTests() { + super.runDockerTests(); + } + + @Test + @Override + public void runDockerFederatedTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runDockerFederatedTests(); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/RustTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/RustTest.java index 2601fe79d0..e41d358ac0 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/RustTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/RustTest.java @@ -24,22 +24,18 @@ package org.lflang.tests.runtime; -import java.util.Properties; - import org.lflang.Target; import org.lflang.tests.RuntimeTest; -/** - * - */ +/** */ public class RustTest extends RuntimeTest { - public RustTest() { - super(Target.Rust); - } + public RustTest() { + super(Target.Rust); + } - @Override - protected boolean supportsGenericTypes() { - return true; - } + @Override + protected boolean supportsGenericTypes() { + return true; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/TypeScriptTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/TypeScriptTest.java index 295a1961ed..036211607a 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/TypeScriptTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/TypeScriptTest.java @@ -8,74 +8,72 @@ /** * Collection of tests for the TypeScript target. * - * Even though all tests are implemented in the base class, we override them - * here so that each test can be easily invoked individually from IDEs with - * JUnit support like Eclipse and IntelliJ. - * This is typically done by right-clicking on the name of the test method and - * then clicking "Run". + *

    Even though all tests are implemented in the base class, we override them here so that each + * test can be easily invoked individually from IDEs with JUnit support like Eclipse and IntelliJ. + * This is typically done by right-clicking on the name of the test method and then clicking "Run". * * @author Marten Lohstroh */ public class TypeScriptTest extends RuntimeTest { - public TypeScriptTest() { - super(Target.TS); - } + public TypeScriptTest() { + super(Target.TS); + } - @Override - protected boolean supportsDockerOption() { - return true; - } + @Override + protected boolean supportsDockerOption() { + return true; + } - @Override - protected boolean supportsFederatedExecution() { - return true; - } + @Override + protected boolean supportsFederatedExecution() { + return true; + } - @Test - @Override - public void runGenericTests() { - super.runGenericTests(); - } + @Test + @Override + public void runGenericTests() { + super.runGenericTests(); + } - @Test - @Override - public void runTargetSpecificTests() { - super.runTargetSpecificTests(); - } + @Test + @Override + public void runTargetSpecificTests() { + super.runTargetSpecificTests(); + } - @Test - @Override - public void runMultiportTests() { - super.runMultiportTests(); - } + @Test + @Override + public void runMultiportTests() { + super.runMultiportTests(); + } - @Test - @Override - public void runConcurrentTests() { - super.runConcurrentTests(); - } + @Test + @Override + public void runConcurrentTests() { + super.runConcurrentTests(); + } - @Test - @Override - public void runFederatedTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runFederatedTests(); - } + @Test + @Override + public void runFederatedTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runFederatedTests(); + } - @Test - @Override - public void runDockerTests() { - super.runDockerTests(); - } + @Test + @Override + public void runDockerTests() { + super.runDockerTests(); + } - @Test - @Override - public void runDockerFederatedTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - super.runDockerFederatedTests(); - } + @Test + @Override + public void runDockerFederatedTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + super.runDockerFederatedTests(); + } - @Test - @Override - public void runAsFederated() {} + @Test + @Override + public void runAsFederated() {} } diff --git a/org.lflang.tests/src/org/lflang/tests/serialization/SerializationTest.java b/org.lflang.tests/src/org/lflang/tests/serialization/SerializationTest.java index 35dfa9f6de..26f3ec37af 100644 --- a/org.lflang.tests/src/org/lflang/tests/serialization/SerializationTest.java +++ b/org.lflang.tests/src/org/lflang/tests/serialization/SerializationTest.java @@ -1,7 +1,6 @@ package org.lflang.tests.serialization; import java.util.Properties; - import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Test; import org.lflang.Target; @@ -11,32 +10,36 @@ public class SerializationTest extends TestBase { - protected SerializationTest() { - super(Target.ALL); - } + protected SerializationTest() { + super(Target.ALL); + } + + @Override + protected void addExtraLfcArgs(Properties args) { + super.addExtraLfcArgs(args); + // Use the Debug build type as coverage generation does not work for the serialization tests + args.setProperty("build-type", "Debug"); + } + + @Test + public void runSerializationTestsWithThreadingOff() { + Assumptions.assumeTrue(supportsSingleThreadedExecution(), Message.NO_SINGLE_THREADED_SUPPORT); + runTestsForTargets( + Message.DESC_SERIALIZATION, + TestCategory.SERIALIZATION::equals, + Configurators::disableThreading, + TestLevel.EXECUTION, + false); + } - @Override - protected void addExtraLfcArgs(Properties args) { - super.addExtraLfcArgs(args); - // Use the Debug build type as coverage generation does not work for the serialization tests - args.setProperty("build-type", "Debug"); - } - - @Test - public void runSerializationTestsWithThreadingOff() { - Assumptions.assumeTrue(supportsSingleThreadedExecution(), Message.NO_SINGLE_THREADED_SUPPORT); - runTestsForTargets(Message.DESC_SERIALIZATION, - TestCategory.SERIALIZATION::equals, Configurators::disableThreading, - TestLevel.EXECUTION, - false); - } - - @Test - public void runSerializationTests() { - Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); - runTestsForTargets(Message.DESC_SERIALIZATION, - TestCategory.SERIALIZATION::equals, Configurators::noChanges, - TestLevel.EXECUTION, - false); - } + @Test + public void runSerializationTests() { + Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); + runTestsForTargets( + Message.DESC_SERIALIZATION, + TestCategory.SERIALIZATION::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } } diff --git a/org.lflang.tests/src/org/lflang/tests/util/StringUtilTest.java b/org.lflang.tests/src/org/lflang/tests/util/StringUtilTest.java index fb15cda64c..7c8ca60b83 100644 --- a/org.lflang.tests/src/org/lflang/tests/util/StringUtilTest.java +++ b/org.lflang.tests/src/org/lflang/tests/util/StringUtilTest.java @@ -33,24 +33,24 @@ public class StringUtilTest { - @Test - public void testRemoveQuotes() { - assertEquals("abc", removeQuotes("\"abc\"")); - assertEquals("a", removeQuotes("'a'")); - assertEquals("'a", removeQuotes("'a")); - assertEquals("a\"", removeQuotes("a\"")); - assertEquals("\"", removeQuotes("\"")); - assertEquals("'", removeQuotes("'")); - assertEquals("", removeQuotes("")); - assertNull(removeQuotes(null)); - } + @Test + public void testRemoveQuotes() { + assertEquals("abc", removeQuotes("\"abc\"")); + assertEquals("a", removeQuotes("'a'")); + assertEquals("'a", removeQuotes("'a")); + assertEquals("a\"", removeQuotes("a\"")); + assertEquals("\"", removeQuotes("\"")); + assertEquals("'", removeQuotes("'")); + assertEquals("", removeQuotes("")); + assertNull(removeQuotes(null)); + } - @Test - public void testCamelToSnakeCase() { - assertEquals("some_string", camelToSnakeCase("someString")); - assertEquals("abc_str", camelToSnakeCase("AbcStr")); - assertEquals("ast", camelToSnakeCase("AST")); - assertEquals("ast_builder", camelToSnakeCase("ASTBuilder")); - assertEquals("something_with_a_preamble", camelToSnakeCase("SomethingWithAPreamble")); - } + @Test + public void testCamelToSnakeCase() { + assertEquals("some_string", camelToSnakeCase("someString")); + assertEquals("abc_str", camelToSnakeCase("AbcStr")); + assertEquals("ast", camelToSnakeCase("AST")); + assertEquals("ast_builder", camelToSnakeCase("ASTBuilder")); + assertEquals("something_with_a_preamble", camelToSnakeCase("SomethingWithAPreamble")); + } } diff --git a/org.lflang/src/org/lflang/AttributeUtils.java b/org.lflang/src/org/lflang/AttributeUtils.java index b6fddf0b0e..6703df2d0e 100644 --- a/org.lflang/src/org/lflang/AttributeUtils.java +++ b/org.lflang/src/org/lflang/AttributeUtils.java @@ -27,12 +27,10 @@ import java.util.List; import java.util.Objects; - import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.nodemodel.ICompositeNode; import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.eclipse.xtext.resource.XtextResource; - import org.lflang.ast.ASTUtils; import org.lflang.lf.Action; import org.lflang.lf.AttrParm; @@ -56,197 +54,194 @@ */ public class AttributeUtils { - /** - * Return the attributes declared on the given node. Throws - * if the node does not support declaring attributes. - * - * @throws IllegalArgumentException If the node cannot have attributes - */ - public static List getAttributes(EObject node) { - if (node instanceof Reactor) { - return ((Reactor) node).getAttributes(); - } else if (node instanceof Reaction) { - return ((Reaction) node).getAttributes(); - } else if (node instanceof Action) { - return ((Action) node).getAttributes(); - } else if (node instanceof Timer) { - return ((Timer) node).getAttributes(); - } else if (node instanceof StateVar) { - return ((StateVar) node).getAttributes(); - } else if (node instanceof Parameter) { - return ((Parameter) node).getAttributes(); - } else if (node instanceof Input) { - return ((Input) node).getAttributes(); - } else if (node instanceof Output) { - return ((Output) node).getAttributes(); - } else if (node instanceof Instantiation) { - return ((Instantiation) node).getAttributes(); - } - throw new IllegalArgumentException("Not annotatable: " + node); - } - - /** - * Return the attribute with the given name - * if present, otherwise return null. - * - * @throws IllegalArgumentException If the node cannot have attributes - */ - public static Attribute findAttributeByName(EObject node, String name) { - List attrs = getAttributes(node); - return attrs.stream() - .filter(it -> it.getAttrName().equalsIgnoreCase(name)) // case-insensitive search (more user-friendly) - .findFirst() - .orElse(null); + /** + * Return the attributes declared on the given node. Throws if the node does not support declaring + * attributes. + * + * @throws IllegalArgumentException If the node cannot have attributes + */ + public static List getAttributes(EObject node) { + if (node instanceof Reactor) { + return ((Reactor) node).getAttributes(); + } else if (node instanceof Reaction) { + return ((Reaction) node).getAttributes(); + } else if (node instanceof Action) { + return ((Action) node).getAttributes(); + } else if (node instanceof Timer) { + return ((Timer) node).getAttributes(); + } else if (node instanceof StateVar) { + return ((StateVar) node).getAttributes(); + } else if (node instanceof Parameter) { + return ((Parameter) node).getAttributes(); + } else if (node instanceof Input) { + return ((Input) node).getAttributes(); + } else if (node instanceof Output) { + return ((Output) node).getAttributes(); + } else if (node instanceof Instantiation) { + return ((Instantiation) node).getAttributes(); } - - /** - * Return the first argument specified for the attribute. - * - * This should be used if the attribute is expected to have a single argument. - * If there is no argument, null is returned. - */ - public static String getFirstArgumentValue(Attribute attr) { - if (attr == null || attr.getAttrParms().isEmpty()) { - return null; - } - return StringUtil.removeQuotes(attr.getAttrParms().get(0).getValue()); - } - - /** - * Search for an attribute with the given name on the given AST node and return its first - * argument as a String. - * - * This should only be used on attributes that are expected to have a single argument. - * - * Returns null if the attribute is not found or if it does not have any arguments. - */ - public static String getAttributeValue(EObject node, String attrName) { - final var attr = findAttributeByName(node, attrName); - String value = getFirstArgumentValue(attr); - // Attribute annotations in comments are deprecated, but we still check for then for backwards - // compatibility - if (value == null) { - return findAnnotationInComments(node, "@" + attrName); - } - return value; + throw new IllegalArgumentException("Not annotatable: " + node); + } + + /** + * Return the attribute with the given name if present, otherwise return null. + * + * @throws IllegalArgumentException If the node cannot have attributes + */ + public static Attribute findAttributeByName(EObject node, String name) { + List attrs = getAttributes(node); + return attrs.stream() + .filter( + it -> + it.getAttrName() + .equalsIgnoreCase(name)) // case-insensitive search (more user-friendly) + .findFirst() + .orElse(null); + } + + /** + * Return the first argument specified for the attribute. + * + *

    This should be used if the attribute is expected to have a single argument. If there is no + * argument, null is returned. + */ + public static String getFirstArgumentValue(Attribute attr) { + if (attr == null || attr.getAttrParms().isEmpty()) { + return null; } - - /** - * Retrieve a specific annotation in a comment associated with the given model element in the AST. - * - * This will look for a comment. If one is found, it searches for the given annotation {@code key}. - * and extracts any string that follows the annotation marker. - * - * @param object the AST model element to search a comment for - * @param key the specific annotation key to be extracted - * @return {@code null} if no JavaDoc style comment was found or if it does not contain the given key. - * The string immediately following the annotation marker otherwise. - */ - public static String findAnnotationInComments(EObject object, String key) { - if (!(object.eResource() instanceof XtextResource)) return null; - ICompositeNode node = NodeModelUtils.findActualNodeFor(object); - return ASTUtils.getPrecedingComments(node, n -> true).flatMap(String::lines) - .filter(line -> line.contains(key)) - .map(String::trim) - .map(it -> it.substring(it.indexOf(key) + key.length())) - .map(it -> it.endsWith("*/") ? it.substring(0, it.length() - "*/".length()) : it) - .findFirst().orElse(null); + return StringUtil.removeQuotes(attr.getAttrParms().get(0).getValue()); + } + + /** + * Search for an attribute with the given name on the given AST node and return its first argument + * as a String. + * + *

    This should only be used on attributes that are expected to have a single argument. + * + *

    Returns null if the attribute is not found or if it does not have any arguments. + */ + public static String getAttributeValue(EObject node, String attrName) { + final var attr = findAttributeByName(node, attrName); + String value = getFirstArgumentValue(attr); + // Attribute annotations in comments are deprecated, but we still check for then for backwards + // compatibility + if (value == null) { + return findAnnotationInComments(node, "@" + attrName); } - - /** - * Return the parameter of the given attribute with the given name. - * - * Returns null if no such parameter is found. - */ - public static String getAttributeParameter(Attribute attribute, String parameterName) { - return (attribute == null) ? null : attribute.getAttrParms().stream() + return value; + } + + /** + * Retrieve a specific annotation in a comment associated with the given model element in the AST. + * + *

    This will look for a comment. If one is found, it searches for the given annotation {@code + * key}. and extracts any string that follows the annotation marker. + * + * @param object the AST model element to search a comment for + * @param key the specific annotation key to be extracted + * @return {@code null} if no JavaDoc style comment was found or if it does not contain the given + * key. The string immediately following the annotation marker otherwise. + */ + public static String findAnnotationInComments(EObject object, String key) { + if (!(object.eResource() instanceof XtextResource)) return null; + ICompositeNode node = NodeModelUtils.findActualNodeFor(object); + return ASTUtils.getPrecedingComments(node, n -> true) + .flatMap(String::lines) + .filter(line -> line.contains(key)) + .map(String::trim) + .map(it -> it.substring(it.indexOf(key) + key.length())) + .map(it -> it.endsWith("*/") ? it.substring(0, it.length() - "*/".length()) : it) + .findFirst() + .orElse(null); + } + + /** + * Return the parameter of the given attribute with the given name. + * + *

    Returns null if no such parameter is found. + */ + public static String getAttributeParameter(Attribute attribute, String parameterName) { + return (attribute == null) + ? null + : attribute.getAttrParms().stream() .filter(param -> Objects.equals(param.getName(), parameterName)) .map(AttrParm::getValue) .map(StringUtil::removeQuotes) .findFirst() .orElse(null); + } + + /** + * Return the parameter of the given attribute with the given name and interpret it as a boolean. + * + *

    Returns null if no such parameter is found. + */ + public static Boolean getBooleanAttributeParameter(Attribute attribute, String parameterName) { + if (attribute == null || parameterName == null) { + return null; } - - /** - * Return the parameter of the given attribute with the given name and interpret it as a boolean. - * - * Returns null if no such parameter is found. - */ - public static Boolean getBooleanAttributeParameter(Attribute attribute, String parameterName) { - if (attribute == null || parameterName == null) { - return null; - } - final var param = getAttributeParameter(attribute, parameterName); - if (param == null) { - return null; - } - return param.equalsIgnoreCase("true"); - } - - /** - * Return true if the specified node is an Input and has an {@code @sparse} - * attribute. - * @param node An AST node. - */ - public static boolean isSparse(EObject node) { - return findAttributeByName(node, "sparse") != null; - } - - /** - * Return true if the reaction is unordered. - * - * Currently, this is only used for synthesized reactions in the context of - * federated execution. - */ - public static boolean isUnordered(Reaction reaction) { - return findAttributeByName(reaction, "_unordered") != null; + final var param = getAttributeParameter(attribute, parameterName); + if (param == null) { + return null; } - - /** - * Return true if the reactor is marked to be a federate. - */ - public static boolean isFederate(Reactor reactor) { - return findAttributeByName(reactor, "_fed_config") != null; - } - - /** - * Return true if the reaction is marked to have a C code body. - * - * Currently, this is only used for synthesized reactions in the context of - * federated execution in Python. - */ - public static boolean hasCBody(Reaction reaction) { - return findAttributeByName(reaction, "_c_body") != null; - } - - /** - * Return the declared label of the node, as given by the @label annotation. - */ - public static String getLabel(EObject node) { - return getAttributeValue(node, "label"); - } - - /** - * Return the declared icon of the node, as given by the @icon annotation. - */ - public static String getIconPath(EObject node) { - return getAttributeValue(node, "icon"); - } - - /** - * Return the {@code @enclave} attribute annotated on the given node. - * - * Returns null if there is no such attribute. - */ - public static Attribute getEnclaveAttribute(Instantiation node) { - return findAttributeByName(node, "enclave"); - } - - /** - * Return true if the specified instance has an {@code @enclave} attribute. - */ - public static boolean isEnclave(Instantiation node) { - return getEnclaveAttribute(node) != null; - } - + return param.equalsIgnoreCase("true"); + } + + /** + * Return true if the specified node is an Input and has an {@code @sparse} attribute. + * + * @param node An AST node. + */ + public static boolean isSparse(EObject node) { + return findAttributeByName(node, "sparse") != null; + } + + /** + * Return true if the reaction is unordered. + * + *

    Currently, this is only used for synthesized reactions in the context of federated + * execution. + */ + public static boolean isUnordered(Reaction reaction) { + return findAttributeByName(reaction, "_unordered") != null; + } + + /** Return true if the reactor is marked to be a federate. */ + public static boolean isFederate(Reactor reactor) { + return findAttributeByName(reactor, "_fed_config") != null; + } + + /** + * Return true if the reaction is marked to have a C code body. + * + *

    Currently, this is only used for synthesized reactions in the context of federated execution + * in Python. + */ + public static boolean hasCBody(Reaction reaction) { + return findAttributeByName(reaction, "_c_body") != null; + } + + /** Return the declared label of the node, as given by the @label annotation. */ + public static String getLabel(EObject node) { + return getAttributeValue(node, "label"); + } + + /** Return the declared icon of the node, as given by the @icon annotation. */ + public static String getIconPath(EObject node) { + return getAttributeValue(node, "icon"); + } + + /** + * Return the {@code @enclave} attribute annotated on the given node. + * + *

    Returns null if there is no such attribute. + */ + public static Attribute getEnclaveAttribute(Instantiation node) { + return findAttributeByName(node, "enclave"); + } + + /** Return true if the specified instance has an {@code @enclave} attribute. */ + public static boolean isEnclave(Instantiation node) { + return getEnclaveAttribute(node) != null; + } } diff --git a/org.lflang/src/org/lflang/DefaultErrorReporter.java b/org.lflang/src/org/lflang/DefaultErrorReporter.java index 704e19951c..2698d2b582 100644 --- a/org.lflang/src/org/lflang/DefaultErrorReporter.java +++ b/org.lflang/src/org/lflang/DefaultErrorReporter.java @@ -1,72 +1,68 @@ package org.lflang; -import org.eclipse.emf.ecore.EObject; - import java.nio.file.Path; +import org.eclipse.emf.ecore.EObject; -/** - * Simple implementation of the ErrorReport interface that simply prints to - * standard out. - */ +/** Simple implementation of the ErrorReport interface that simply prints to standard out. */ public class DefaultErrorReporter implements ErrorReporter { - private boolean errorsOccurred = false; + private boolean errorsOccurred = false; - private String println(String s) { - System.out.println(s); - return s; - } + private String println(String s) { + System.out.println(s); + return s; + } - @Override - public String reportError(String message) { - errorsOccurred = true; - return println("ERROR: " + message); - } + @Override + public String reportError(String message) { + errorsOccurred = true; + return println("ERROR: " + message); + } - @Override - public String reportError(EObject object, String message) { - errorsOccurred = true; - return println("ERROR: " + message); - } + @Override + public String reportError(EObject object, String message) { + errorsOccurred = true; + return println("ERROR: " + message); + } - @Override - public String reportError(Path file, Integer line, String message) { - errorsOccurred = true; - return println("ERROR: " + message); - } + @Override + public String reportError(Path file, Integer line, String message) { + errorsOccurred = true; + return println("ERROR: " + message); + } - @Override - public String reportWarning(String message) { - return println("WARNING: " + message); - } + @Override + public String reportWarning(String message) { + return println("WARNING: " + message); + } - @Override - public String reportInfo(String message) { - return println("INFO: " + message); - } + @Override + public String reportInfo(String message) { + return println("INFO: " + message); + } - @Override - public String reportWarning(EObject object, String message) { - return println("WARNING: " + message); - } + @Override + public String reportWarning(EObject object, String message) { + return println("WARNING: " + message); + } - @Override - public String reportInfo(EObject object, String message) { - return println("INFO: " + message); - } + @Override + public String reportInfo(EObject object, String message) { + return println("INFO: " + message); + } - @Override - public String reportWarning(Path file, Integer line, String message) { - return println("WARNING: " + message); - } + @Override + public String reportWarning(Path file, Integer line, String message) { + return println("WARNING: " + message); + } - @Override - public String reportInfo(Path file, Integer line, String message) { - return println("INFO: " + message); - } + @Override + public String reportInfo(Path file, Integer line, String message) { + return println("INFO: " + message); + } - @Override - public boolean getErrorsOccurred() { - return errorsOccurred; - } + @Override + public boolean getErrorsOccurred() { + return errorsOccurred; + } } diff --git a/org.lflang/src/org/lflang/ErrorReporter.java b/org.lflang/src/org/lflang/ErrorReporter.java index 0a01e252ee..f7fe6dcb31 100644 --- a/org.lflang/src/org/lflang/ErrorReporter.java +++ b/org.lflang/src/org/lflang/ErrorReporter.java @@ -1,10 +1,8 @@ package org.lflang; import java.nio.file.Path; - import org.eclipse.emf.ecore.EObject; import org.eclipse.lsp4j.DiagnosticSeverity; - import org.lflang.generator.Position; /** @@ -16,164 +14,157 @@ */ public interface ErrorReporter { - /** - * Report an error. - * - * @param message The error message. - * @return a string that describes the error. - */ - String reportError(String message); - - - /** - * Report a warning. - * - * @param message The warning message. - * @return a string that describes the warning. - */ - String reportWarning(String message); - - /** - * Report an informational message. - * - * @param message The message to report - * @return a string that describes the error - */ - String reportInfo(String message); - - - /** - * Report an error on the specified parse tree object. - * - * @param object The parse tree object. - * @param message The error message. - * @return a string that describes the error. - */ - String reportError(EObject object, String message); - - - /** - * Report a warning on the specified parse tree object. - * - * @param object The parse tree object. - * @param message The error message. - * @return a string that describes the warning. - */ - String reportWarning(EObject object, String message); - - /** - * Report an informational message on the specified parse tree object. - * - * @param object The parse tree object. - * @param message The informational message - * @return a string that describes the info - */ - String reportInfo(EObject object, String message); - - - /** - * Report an error at the specified line within a file. - * - * @param message The error message. - * @param line The one-based line number to report at. - * @param file The file to report at. - * @return a string that describes the error. - */ - String reportError(Path file, Integer line, String message); - - - /** - * Report a warning at the specified line within a file. - * - * @param message The error message. - * @param line The one-based line number to report at. - * @param file The file to report at. - * @return a string that describes the warning. - */ - String reportWarning(Path file, Integer line, String message); - - - /** - * Report an informational message at the specified line within a file. - * - * @param file The file to report at. - * @param line The one-based line number to report at. - * @param message The error message. - * @return - */ - String reportInfo(Path file, Integer line, String message); - - /** - * Report a message of severity {@code severity}. - * @param file The file to which the message pertains, or {@code null} if the file is unknown. - * @param severity the severity of the message - * @param message the message to send to the IDE - * @return a string that describes the diagnostic - */ - default String report(Path file, DiagnosticSeverity severity, String message) { - switch (severity) { - case Error: - return reportError(message); - case Warning: - case Hint: - case Information: - return reportInfo(message); - default: - return reportWarning(message); - } - } - - /** - * Report a message of severity {@code severity} that - * pertains to line {@code line} of an LF source file. - * @param file The file to which the message pertains, or {@code null} if the file is unknown. - * @param severity the severity of the message - * @param message the message to send to the IDE - * @param line the one-based line number associated - * with the message - * @return a string that describes the diagnostic - */ - default String report(Path file, DiagnosticSeverity severity, String message, int line) { - switch (severity) { - case Error: - return reportError(file, line, message); - case Warning: - case Hint: - case Information: - return reportInfo(file, line, message); - default: - return reportWarning(file, line, message); - } + /** + * Report an error. + * + * @param message The error message. + * @return a string that describes the error. + */ + String reportError(String message); + + /** + * Report a warning. + * + * @param message The warning message. + * @return a string that describes the warning. + */ + String reportWarning(String message); + + /** + * Report an informational message. + * + * @param message The message to report + * @return a string that describes the error + */ + String reportInfo(String message); + + /** + * Report an error on the specified parse tree object. + * + * @param object The parse tree object. + * @param message The error message. + * @return a string that describes the error. + */ + String reportError(EObject object, String message); + + /** + * Report a warning on the specified parse tree object. + * + * @param object The parse tree object. + * @param message The error message. + * @return a string that describes the warning. + */ + String reportWarning(EObject object, String message); + + /** + * Report an informational message on the specified parse tree object. + * + * @param object The parse tree object. + * @param message The informational message + * @return a string that describes the info + */ + String reportInfo(EObject object, String message); + + /** + * Report an error at the specified line within a file. + * + * @param message The error message. + * @param line The one-based line number to report at. + * @param file The file to report at. + * @return a string that describes the error. + */ + String reportError(Path file, Integer line, String message); + + /** + * Report a warning at the specified line within a file. + * + * @param message The error message. + * @param line The one-based line number to report at. + * @param file The file to report at. + * @return a string that describes the warning. + */ + String reportWarning(Path file, Integer line, String message); + + /** + * Report an informational message at the specified line within a file. + * + * @param file The file to report at. + * @param line The one-based line number to report at. + * @param message The error message. + * @return + */ + String reportInfo(Path file, Integer line, String message); + + /** + * Report a message of severity {@code severity}. + * + * @param file The file to which the message pertains, or {@code null} if the file is unknown. + * @param severity the severity of the message + * @param message the message to send to the IDE + * @return a string that describes the diagnostic + */ + default String report(Path file, DiagnosticSeverity severity, String message) { + switch (severity) { + case Error: + return reportError(message); + case Warning: + case Hint: + case Information: + return reportInfo(message); + default: + return reportWarning(message); } - - /** - * Report a message of severity {@code severity} that - * pertains to the range [{@code startPos}, {@code endPos}) - * of an LF source file. - * @param file The file to which the message pertains, or {@code null} if the file is unknown. - * @param severity the severity of the message - * @param message the message to send to the IDE - * @param startPos the position of the first character - * of the range of interest - * @param endPos the position immediately AFTER the - * final character of the range of - * interest - * @return a string that describes the diagnostic - */ - default String report(Path file, DiagnosticSeverity severity, String message, Position startPos, Position endPos) { - return report(file, severity, message, startPos.getOneBasedLine()); + } + + /** + * Report a message of severity {@code severity} that pertains to line {@code line} of an LF + * source file. + * + * @param file The file to which the message pertains, or {@code null} if the file is unknown. + * @param severity the severity of the message + * @param message the message to send to the IDE + * @param line the one-based line number associated with the message + * @return a string that describes the diagnostic + */ + default String report(Path file, DiagnosticSeverity severity, String message, int line) { + switch (severity) { + case Error: + return reportError(file, line, message); + case Warning: + case Hint: + case Information: + return reportInfo(file, line, message); + default: + return reportWarning(file, line, message); } - - /** - * Check if errors where reported. - * - * @return true if errors where reported - */ - boolean getErrorsOccurred(); - - /** - * Clear error history, if exists. - * This is usually only the case for error markers in Epoch (Eclipse). - */ - default void clearHistory() {} + } + + /** + * Report a message of severity {@code severity} that pertains to the range [{@code startPos}, + * {@code endPos}) of an LF source file. + * + * @param file The file to which the message pertains, or {@code null} if the file is unknown. + * @param severity the severity of the message + * @param message the message to send to the IDE + * @param startPos the position of the first character of the range of interest + * @param endPos the position immediately AFTER the final character of the range of interest + * @return a string that describes the diagnostic + */ + default String report( + Path file, DiagnosticSeverity severity, String message, Position startPos, Position endPos) { + return report(file, severity, message, startPos.getOneBasedLine()); + } + + /** + * Check if errors where reported. + * + * @return true if errors where reported + */ + boolean getErrorsOccurred(); + + /** + * Clear error history, if exists. This is usually only the case for error markers in Epoch + * (Eclipse). + */ + default void clearHistory() {} } diff --git a/org.lflang/src/org/lflang/FileConfig.java b/org.lflang/src/org/lflang/FileConfig.java index e2d3313a61..831cb7957f 100644 --- a/org.lflang/src/org/lflang/FileConfig.java +++ b/org.lflang/src/org/lflang/FileConfig.java @@ -5,15 +5,12 @@ import java.nio.file.Paths; import java.util.List; import java.util.function.Consumer; - import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.IFileSystemAccess2; - - import org.lflang.generator.GeneratorUtils; import org.lflang.util.FileUtil; import org.lflang.util.LFCommand; @@ -22,297 +19,267 @@ * Base class that governs the interactions between code generators and the file system. * * @author Marten Lohstroh - * */ public abstract class FileConfig { - // Public static fields. - - public static final String DEFAULT_SRC_DIR = "src"; - - /** - * Default name of the directory to store binaries in. - */ - public static final String DEFAULT_BIN_DIR = "bin"; - - /** - * Default name of the directory to store generated sources in. - */ - public static final String DEFAULT_SRC_GEN_DIR = "src-gen"; - - // Public fields. - - /** - * The directory in which to put binaries, if the code generator produces any. - */ - public final Path binPath; - - /** - * The name of the main reactor, which has to match the file name (without - * the '.lf' extension). - */ - public final String name; - - /** - * The directory that is the root of the package in which the .lf source file resides. This path is determined - * differently depending on whether the compiler is invoked through the IDE or from the command line. In the former - * case, the package is the project root that the source resides in. In the latter case, it is the parent directory - * of the nearest {@code src} directory up the hierarchy, if there is one, or just the {@code outPath} if there is none. It is - * recommended to always keep the sources in a {@code src} directory regardless of the workflow, in which case the - * output behavior will be identical irrespective of the way the compiler is invoked. - */ - public final Path srcPkgPath; - - /** - * The file containing the main source code. - * This is the Eclipse eCore view of the file, which is distinct - * from the XText view of the file and the OS view of the file. - */ - public final Resource resource; - - /** - * If running in an Eclipse IDE, the iResource refers to the - * IFile representing the Lingua Franca program. - * This is the XText view of the file, which is distinct - * from the Eclipse eCore view of the file and the OS view of the file. - *

    - * This is null if running outside an Eclipse IDE. - */ - public final IResource iResource; - - /** - * The full path to the file containing the .lf file including the - * full filename with the .lf extension. - */ - public final Path srcFile; - - /** - * The directory in which the source .lf file was found. - */ - public final Path srcPath; // FIXME: rename this to srcDir? - - /** - * Indicate whether the bin directory should be hierarchical. - */ - public final boolean useHierarchicalBin; - - // Protected fields. - - /** - * Path representation of srcGenRoot, the root directory for generated - * sources. - */ - protected Path srcGenBasePath; - - /** - * The directory in which to put the generated sources. - * This takes into account the location of the source file relative to the - * package root. Specifically, if the source file is x/y/Z.lf relative - * to the package root, then the generated sources will be put in x/y/Z - * relative to srcGenBasePath. - */ - protected Path srcGenPath; - - // private fields - - /** - * The parent of the directory designated for placing generated sources into ({@code ./src-gen} by default). Additional - * directories (such as {@code bin} or {@code build}) should be created as siblings of the directory for generated sources, - * which means that such directories should be created relative to the path assigned to this class variable. - *

    - * The generated source directory is specified in the IDE (Project Properties->LF->Compiler->Output Folder). When - * invoking the standalone compiler, the output path is specified directly using the {@code -o} or {@code --output-path} option. - */ - private final Path outPath; - - /** - * The directory that denotes the root of the package to which the - * generated sources belong. Even if the target language does not have a - * notion of packages, this directory groups all files associated with a - * single main reactor. - * of packages. - */ - private final Path srcGenPkgPath; - - public FileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) throws IOException { - this.resource = resource; - this.useHierarchicalBin = useHierarchicalBin; - - this.srcFile = FileUtil.toPath(this.resource); - - this.srcPath = srcFile.getParent(); - this.srcPkgPath = getPkgPath(resource); - - this.srcGenBasePath = srcGenBasePath; - this.name = FileUtil.nameWithoutExtension(this.srcFile); - this.srcGenPath = srcGenBasePath.resolve(getSubPkgPath(srcPath)).resolve(name); - this.srcGenPkgPath = this.srcGenPath; - this.outPath = srcGenBasePath.getParent(); - - Path binRoot = outPath.resolve(DEFAULT_BIN_DIR); - this.binPath = useHierarchicalBin ? binRoot.resolve(getSubPkgPath(srcPath)) : binRoot; - - this.iResource = FileUtil.getIResource(resource); - } - - /** - * Get the directory a resource is located in relative to the root package - */ - public Path getDirectory(Resource r) throws IOException { - return getSubPkgPath(FileUtil.toPath(r).getParent()); - } - - /** - * The parent of the directory designated for placing generated sources into ({@code ./src-gen} by default). Additional - * directories (such as {@code bin} or {@code build}) should be created as siblings of the directory for generated sources, - * which means that such directories should be created relative to the path assigned to this class variable. - *

    - * The generated source directory is specified in the IDE (Project Properties->LF->Compiler->Output Folder). When - * invoking the standalone compiler, the output path is specified directly using the {@code -o} or {@code --output-path} option. - */ - public Path getOutPath() { - return outPath; + // Public static fields. + + public static final String DEFAULT_SRC_DIR = "src"; + + /** Default name of the directory to store binaries in. */ + public static final String DEFAULT_BIN_DIR = "bin"; + + /** Default name of the directory to store generated sources in. */ + public static final String DEFAULT_SRC_GEN_DIR = "src-gen"; + + // Public fields. + + /** The directory in which to put binaries, if the code generator produces any. */ + public final Path binPath; + + /** + * The name of the main reactor, which has to match the file name (without the '.lf' extension). + */ + public final String name; + + /** + * The directory that is the root of the package in which the .lf source file resides. This path + * is determined differently depending on whether the compiler is invoked through the IDE or from + * the command line. In the former case, the package is the project root that the source resides + * in. In the latter case, it is the parent directory of the nearest {@code src} directory up the + * hierarchy, if there is one, or just the {@code outPath} if there is none. It is recommended to + * always keep the sources in a {@code src} directory regardless of the workflow, in which case + * the output behavior will be identical irrespective of the way the compiler is invoked. + */ + public final Path srcPkgPath; + + /** + * The file containing the main source code. This is the Eclipse eCore view of the file, which is + * distinct from the XText view of the file and the OS view of the file. + */ + public final Resource resource; + + /** + * If running in an Eclipse IDE, the iResource refers to the IFile representing the Lingua Franca + * program. This is the XText view of the file, which is distinct from the Eclipse eCore view of + * the file and the OS view of the file. + * + *

    This is null if running outside an Eclipse IDE. + */ + public final IResource iResource; + + /** + * The full path to the file containing the .lf file including the full filename with the .lf + * extension. + */ + public final Path srcFile; + + /** The directory in which the source .lf file was found. */ + public final Path srcPath; // FIXME: rename this to srcDir? + + /** Indicate whether the bin directory should be hierarchical. */ + public final boolean useHierarchicalBin; + + // Protected fields. + + /** Path representation of srcGenRoot, the root directory for generated sources. */ + protected Path srcGenBasePath; + + /** + * The directory in which to put the generated sources. This takes into account the location of + * the source file relative to the package root. Specifically, if the source file is x/y/Z.lf + * relative to the package root, then the generated sources will be put in x/y/Z relative to + * srcGenBasePath. + */ + protected Path srcGenPath; + + // private fields + + /** + * The parent of the directory designated for placing generated sources into ({@code ./src-gen} by + * default). Additional directories (such as {@code bin} or {@code build}) should be created as + * siblings of the directory for generated sources, which means that such directories should be + * created relative to the path assigned to this class variable. + * + *

    The generated source directory is specified in the IDE (Project + * Properties->LF->Compiler->Output Folder). When invoking the standalone compiler, the output + * path is specified directly using the {@code -o} or {@code --output-path} option. + */ + private final Path outPath; + + /** + * The directory that denotes the root of the package to which the generated sources belong. Even + * if the target language does not have a notion of packages, this directory groups all files + * associated with a single main reactor. of packages. + */ + private final Path srcGenPkgPath; + + public FileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) + throws IOException { + this.resource = resource; + this.useHierarchicalBin = useHierarchicalBin; + + this.srcFile = FileUtil.toPath(this.resource); + + this.srcPath = srcFile.getParent(); + this.srcPkgPath = getPkgPath(resource); + + this.srcGenBasePath = srcGenBasePath; + this.name = FileUtil.nameWithoutExtension(this.srcFile); + this.srcGenPath = srcGenBasePath.resolve(getSubPkgPath(srcPath)).resolve(name); + this.srcGenPkgPath = this.srcGenPath; + this.outPath = srcGenBasePath.getParent(); + + Path binRoot = outPath.resolve(DEFAULT_BIN_DIR); + this.binPath = useHierarchicalBin ? binRoot.resolve(getSubPkgPath(srcPath)) : binRoot; + + this.iResource = FileUtil.getIResource(resource); + } + + /** Get the directory a resource is located in relative to the root package */ + public Path getDirectory(Resource r) throws IOException { + return getSubPkgPath(FileUtil.toPath(r).getParent()); + } + + /** + * The parent of the directory designated for placing generated sources into ({@code ./src-gen} by + * default). Additional directories (such as {@code bin} or {@code build}) should be created as + * siblings of the directory for generated sources, which means that such directories should be + * created relative to the path assigned to this class variable. + * + *

    The generated source directory is specified in the IDE (Project + * Properties->LF->Compiler->Output Folder). When invoking the standalone compiler, the output + * path is specified directly using the {@code -o} or {@code --output-path} option. + */ + public Path getOutPath() { + return outPath; + } + + /** + * The directory in which to put the generated sources. This takes into account the location of + * the source file relative to the package root. Specifically, if the source file is x/y/Z.lf + * relative to the package root, then the generated sources will be put in x/y/Z relative to + * srcGenBasePath. + */ + public Path getSrcGenPath() { + return srcGenPath; + } + + /** + * Path representation of srcGenRoot, the root directory for generated sources. This is the root, + * meaning that if the source file is x/y/Z.lf relative to the package root, then the generated + * sources will be put in x/y/Z relative to this URI. + */ + public Path getSrcGenBasePath() { + return srcGenBasePath; + } + + /** + * The directory that denotes the root of the package to which the generated sources belong. Even + * if the target language does not have a notion of packages, this directory groups all files + * associated with a single main reactor. + */ + public Path getSrcGenPkgPath() { + return srcGenPkgPath; + } + + /** Returns the root directory for generated sources. */ + public static Path getSrcGenRoot(IFileSystemAccess2 fsa) throws IOException { + URI srcGenURI = fsa.getURI(""); + if (srcGenURI.hasTrailingPathSeparator()) { + srcGenURI = srcGenURI.trimSegments(1); } - - /** - * The directory in which to put the generated sources. - * This takes into account the location of the source file relative to the - * package root. Specifically, if the source file is x/y/Z.lf relative - * to the package root, then the generated sources will be put in x/y/Z - * relative to srcGenBasePath. - */ - public Path getSrcGenPath() { - return srcGenPath; - } - - - /** - * Path representation of srcGenRoot, the root directory for generated - * sources. This is the root, meaning that if the source file is x/y/Z.lf - * relative to the package root, then the generated sources will be put in x/y/Z - * relative to this URI. - */ - public Path getSrcGenBasePath() { - return srcGenBasePath; + return FileUtil.toPath(srcGenURI); + } + + /** + * Given a path that denotes the full path to a source file (not including the file itself), + * return the relative path from the root of the 'src' directory, or, if there is no 'src' + * directory, the relative path from the root of the package. + * + * @param srcPath The path to the source. + * @return the relative path from the root of the 'src' directory, or, if there is no 'src' + * directory, the relative path from the root of the package + */ + protected Path getSubPkgPath(Path srcPath) { + Path relSrcPath = srcPkgPath.relativize(srcPath); + if (relSrcPath.startsWith(DEFAULT_SRC_DIR)) { + int segments = relSrcPath.getNameCount(); + if (segments == 1) { + return Paths.get(""); + } else { + relSrcPath = relSrcPath.subpath(1, segments); + } } - - /** - * The directory that denotes the root of the package to which the - * generated sources belong. Even if the target language does not have a - * notion of packages, this directory groups all files associated with a - * single main reactor. - */ - public Path getSrcGenPkgPath() { - return srcGenPkgPath; - } - - /** - * Returns the root directory for generated sources. - */ - public static Path getSrcGenRoot(IFileSystemAccess2 fsa) throws IOException { - URI srcGenURI = fsa.getURI(""); - if (srcGenURI.hasTrailingPathSeparator()) { - srcGenURI = srcGenURI.trimSegments(1); + return relSrcPath; + } + + /** + * Clean any artifacts produced by the code generator and target compilers. + * + *

    The base implementation deletes the bin and src-gen directories. If the target code + * generator creates additional files or directories, the corresponding generator should override + * this method. + * + * @throws IOException If an I/O error occurs. + */ + public void doClean() throws IOException { + FileUtil.deleteDirectory(binPath); + FileUtil.deleteDirectory(srcGenBasePath); + } + + private static Path getPkgPath(Resource resource) throws IOException { + if (resource.getURI().isPlatform()) { + // We are in the RCA. + Path srcFile = FileUtil.toPath(resource); + for (IProject r : ResourcesPlugin.getWorkspace().getRoot().getProjects()) { + Path p = Paths.get(r.getLocation().toFile().getAbsolutePath()); + Path f = srcFile.toAbsolutePath(); + if (f.startsWith(p)) { + return p; } - return FileUtil.toPath(srcGenURI); - } - - /** - * Given a path that denotes the full path to a source file (not including the - * file itself), return the relative path from the root of the 'src' - * directory, or, if there is no 'src' directory, the relative path - * from the root of the package. - * @param srcPath The path to the source. - * @return the relative path from the root of the 'src' - * directory, or, if there is no 'src' directory, the relative path - * from the root of the package - */ - protected Path getSubPkgPath(Path srcPath) { - Path relSrcPath = srcPkgPath.relativize(srcPath); - if (relSrcPath.startsWith(DEFAULT_SRC_DIR)) { - int segments = relSrcPath.getNameCount(); - if (segments == 1) { - return Paths.get(""); - } else { - relSrcPath = relSrcPath.subpath(1, segments); - } - } - return relSrcPath; - } - - /** - * Clean any artifacts produced by the code generator and target compilers. - *

    - * The base implementation deletes the bin and src-gen directories. If the - * target code generator creates additional files or directories, the - * corresponding generator should override this method. - * - * @throws IOException If an I/O error occurs. - */ - public void doClean() throws IOException { - FileUtil.deleteDirectory(binPath); - FileUtil.deleteDirectory(srcGenBasePath); - } - - private static Path getPkgPath(Resource resource) throws IOException { - if (resource.getURI().isPlatform()) { - // We are in the RCA. - Path srcFile = FileUtil.toPath(resource); - for (IProject r : ResourcesPlugin.getWorkspace().getRoot().getProjects()) { - Path p = Paths.get(r.getLocation().toFile().getAbsolutePath()); - Path f = srcFile.toAbsolutePath(); - if (f.startsWith(p)) { - return p; - } - } - } - return findPackageRoot(FileUtil.toPath(resource), s -> {}); - } - - /** - * Find the package root by looking for an 'src' - * directory. If none can be found, return the current - * working directory instead. - * - * @param input The *.lf file to find the package root - * for. - * @return The package root, or the current working - * directory if none exists. - */ - public static Path findPackageRoot(final Path input, final Consumer printWarning) { - Path p = input; - do { - p = p.getParent(); - if (p == null) { - printWarning.accept("File '" + input.getFileName() + "' is not located in an 'src' directory."); - printWarning.accept("Adopting the current working directory as the package root."); - return Paths.get(".").toAbsolutePath(); // todo #1478 replace with Io::getWd - } - } while (!p.toFile().getName().equals("src")); - return p.getParent(); - } - - /** - * Return an LFCommand instance that can be used to execute the program under compilation. - */ - public LFCommand getCommand() { - String cmd = GeneratorUtils.isHostWindows() ? - getExecutable().toString() : - srcPkgPath.relativize(getExecutable()).toString(); - return LFCommand.get(cmd, List.of(), true, srcPkgPath); - } - - /** - * Return the extension used for binaries on the platform on which compilation takes place. - */ - protected String getExecutableExtension() { - return GeneratorUtils.isHostWindows() ? ".exe" : ""; - } - - /** - * Return a path to an executable version of the program under compilation. - */ - public Path getExecutable() { - return binPath.resolve(name + getExecutableExtension()); + } } + return findPackageRoot(FileUtil.toPath(resource), s -> {}); + } + + /** + * Find the package root by looking for an 'src' directory. If none can be found, return the + * current working directory instead. + * + * @param input The *.lf file to find the package root for. + * @return The package root, or the current working directory if none exists. + */ + public static Path findPackageRoot(final Path input, final Consumer printWarning) { + Path p = input; + do { + p = p.getParent(); + if (p == null) { + printWarning.accept( + "File '" + input.getFileName() + "' is not located in an 'src' directory."); + printWarning.accept("Adopting the current working directory as the package root."); + return Paths.get(".").toAbsolutePath(); // todo #1478 replace with Io::getWd + } + } while (!p.toFile().getName().equals("src")); + return p.getParent(); + } + + /** Return an LFCommand instance that can be used to execute the program under compilation. */ + public LFCommand getCommand() { + String cmd = + GeneratorUtils.isHostWindows() + ? getExecutable().toString() + : srcPkgPath.relativize(getExecutable()).toString(); + return LFCommand.get(cmd, List.of(), true, srcPkgPath); + } + + /** Return the extension used for binaries on the platform on which compilation takes place. */ + protected String getExecutableExtension() { + return GeneratorUtils.isHostWindows() ? ".exe" : ""; + } + + /** Return a path to an executable version of the program under compilation. */ + public Path getExecutable() { + return binPath.resolve(name + getExecutableExtension()); + } } diff --git a/org.lflang/src/org/lflang/InferredType.java b/org.lflang/src/org/lflang/InferredType.java index 41931e0e32..5e9b4a8aa3 100644 --- a/org.lflang/src/org/lflang/InferredType.java +++ b/org.lflang/src/org/lflang/InferredType.java @@ -1,209 +1,184 @@ /************* -Copyright (c) 2020, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang; import java.util.function.Function; - import org.eclipse.emf.ecore.EObject; - import org.lflang.ast.ASTUtils; import org.lflang.lf.Type; /** * A helper class that represents an inferred type. * - *

    This class helps to separate the rules of type inference from code generation - * for types. It is particularly useful in cases when the type is not given directly - * in LF code, but is inferred from the context. In this case it could happen that - * no ASTNode representing the type does not exist. For instance when a - * parameter type is inferred from a time value. All in all, this class provides a - * clean interface between type inference in ASTUtils and code generation. + *

    This class helps to separate the rules of type inference from code generation for types. It is + * particularly useful in cases when the type is not given directly in LF code, but is inferred from + * the context. In this case it could happen that no ASTNode representing the type does not exist. + * For instance when a parameter type is inferred from a time value. All in all, this class provides + * a clean interface between type inference in ASTUtils and code generation. * - *

    ASTUtils provides functionality to create an inferred type from - * Lingua Franca variables (getInferredType). This inferred type can than be - * translated to target code using the code generators or be converted to a general - * textual representation using toText(). + *

    ASTUtils provides functionality to create an inferred type from Lingua Franca variables + * (getInferredType). This inferred type can than be translated to target code using the code + * generators or be converted to a general textual representation using toText(). * * @author Christian Menard */ public class InferredType { - /** - * The AST node representing the inferred type if such a node exists. - */ - public final Type astType; - /** - * A flag indicating whether the inferred type has the base type time. - */ - public final boolean isTime; - /** - * A flag indicating whether the inferred type is a list. - */ - public final boolean isList; - /** - * A flag indicating whether the inferred type is a list of variable size. - */ - public final boolean isVariableSizeList; - /** - * A flag indicating whether the inferred type is a list of fixed size. - */ - public final boolean isFixedSizeList; - /** - * The list size if the inferred type is a fixed size list. - * Otherwise, null. - */ - public final Integer listSize; - - - /** - * Private constructor - */ - private InferredType(Type astType, boolean isTime, boolean isVariableSizeList, - boolean isFixedSizeList, Integer listSize) { - this.astType = astType; - this.isTime = isTime; - this.isList = isVariableSizeList || isFixedSizeList; - this.isVariableSizeList = isVariableSizeList; - this.isFixedSizeList = isFixedSizeList; - this.listSize = listSize; + /** The AST node representing the inferred type if such a node exists. */ + public final Type astType; + /** A flag indicating whether the inferred type has the base type time. */ + public final boolean isTime; + /** A flag indicating whether the inferred type is a list. */ + public final boolean isList; + /** A flag indicating whether the inferred type is a list of variable size. */ + public final boolean isVariableSizeList; + /** A flag indicating whether the inferred type is a list of fixed size. */ + public final boolean isFixedSizeList; + /** The list size if the inferred type is a fixed size list. Otherwise, null. */ + public final Integer listSize; + + /** Private constructor */ + private InferredType( + Type astType, + boolean isTime, + boolean isVariableSizeList, + boolean isFixedSizeList, + Integer listSize) { + this.astType = astType; + this.isTime = isTime; + this.isList = isVariableSizeList || isFixedSizeList; + this.isVariableSizeList = isVariableSizeList; + this.isFixedSizeList = isFixedSizeList; + this.listSize = listSize; + } + + /** Check if the inferred type is undefined. */ + public boolean isUndefined() { + return astType == null && !isTime; + } + + /** + * Convert the inferred type to its textual representation as it would appear in LF code, with + * CodeMap tags inserted. + */ + public String toText() { + return toTextHelper(ASTUtils::toText); + } + + /** + * Convert the inferred type to its textual representation as it would appear in LF code, without + * CodeMap tags inserted. + */ + public String toOriginalText() { + return toTextHelper(ASTUtils::toOriginalText); + } + + private String toTextHelper(Function toText) { + if (astType != null) { + return toText.apply(astType); + } else if (isTime) { + if (isFixedSizeList) { + return "time[" + listSize + "]"; + } else if (isVariableSizeList) { + return "time[]"; + } else { + return "time"; + } } - - - /** - * Check if the inferred type is undefined. - */ - public boolean isUndefined() { - return astType == null && !isTime; - } - - /** - * Convert the inferred type to its textual representation as it would appear in LF code, - * with CodeMap tags inserted. - */ - public String toText() { return toTextHelper(ASTUtils::toText); } - - /** - * Convert the inferred type to its textual representation as it would appear in LF code, - * without CodeMap tags inserted. - */ - public String toOriginalText() { return toTextHelper(ASTUtils::toOriginalText); } - - private String toTextHelper(Function toText) { - if (astType != null) { - return toText.apply(astType); - } else if (isTime) { - if (isFixedSizeList) { - return "time[" + listSize + "]"; - } else if (isVariableSizeList) { - return "time[]"; - } else { - return "time"; - } - } - return ""; - } - - /** - * Convert the inferred type to its textual representation - * while ignoring any list qualifiers or type arguments. - * - * @return Textual representation of this inferred type without list qualifiers - */ - public String baseType() { - if (astType != null) { - return ASTUtils.baseType(astType); - } else if (isTime) { - return "time"; - } - return ""; + return ""; + } + + /** + * Convert the inferred type to its textual representation while ignoring any list qualifiers or + * type arguments. + * + * @return Textual representation of this inferred type without list qualifiers + */ + public String baseType() { + if (astType != null) { + return ASTUtils.baseType(astType); + } else if (isTime) { + return "time"; } - - /** - * Create an inferred type from an AST node. - * - * @param type an AST node - * @return A new inferred type representing the given AST node - */ - public static InferredType fromAST(Type type) { - if (type == null) { - return undefined(); - } - return new InferredType( - type, - type.isTime(), - type.getArraySpec() != null && type.getArraySpec().isOfVariableLength(), - type.getArraySpec() != null && !type.getArraySpec().isOfVariableLength(), - type.getArraySpec() != null ? type.getArraySpec().getLength() : null - ); - } - - /** - * Create an undefined inferred type. - */ - public static InferredType undefined() { - return new InferredType(null, false, false, false, null); - } - - /** - * Create an inferred type representing time. - */ - public static InferredType time() { - return new InferredType(null, true, false, false, null); - } - - /** - * Create an inferred type representing a list of time values. - * - *

    This creates a fixed size list if size is non-null, - * otherwise a variable size list. - * - * @param size The list size, may be null - */ - public static InferredType timeList(Integer size) { - return new InferredType(null, true, size == null, size != null, size); - } - - /** - * Create an inferred type representing a variable size time list. - */ - public static InferredType timeList() { - return timeList(null); - } - - /** - * Returns the component type, if this is a first-class - * list type. Eg returns {@code time} for the type {@code time[]}. - * If this is not a first-class list type, returns null. - * - *

    Todo this does not return int for int[], we need to - * make the parser production left-recursive. OTOH only - * time and time[] are first class in our framework so - * this doesn't contradict the contract of this method. - */ - public InferredType getComponentType() { - return isTime && isList ? time() : null; + return ""; + } + + /** + * Create an inferred type from an AST node. + * + * @param type an AST node + * @return A new inferred type representing the given AST node + */ + public static InferredType fromAST(Type type) { + if (type == null) { + return undefined(); } + return new InferredType( + type, + type.isTime(), + type.getArraySpec() != null && type.getArraySpec().isOfVariableLength(), + type.getArraySpec() != null && !type.getArraySpec().isOfVariableLength(), + type.getArraySpec() != null ? type.getArraySpec().getLength() : null); + } + + /** Create an undefined inferred type. */ + public static InferredType undefined() { + return new InferredType(null, false, false, false, null); + } + + /** Create an inferred type representing time. */ + public static InferredType time() { + return new InferredType(null, true, false, false, null); + } + + /** + * Create an inferred type representing a list of time values. + * + *

    This creates a fixed size list if size is non-null, otherwise a variable size list. + * + * @param size The list size, may be null + */ + public static InferredType timeList(Integer size) { + return new InferredType(null, true, size == null, size != null, size); + } + + /** Create an inferred type representing a variable size time list. */ + public static InferredType timeList() { + return timeList(null); + } + + /** + * Returns the component type, if this is a first-class list type. Eg returns {@code time} for the + * type {@code time[]}. If this is not a first-class list type, returns null. + * + *

    Todo this does not return int for int[], we need to make the parser production + * left-recursive. OTOH only time and time[] are first class in our framework so this doesn't + * contradict the contract of this method. + */ + public InferredType getComponentType() { + return isTime && isList ? time() : null; + } } diff --git a/org.lflang/src/org/lflang/LFResourceDescriptionStrategy.java b/org.lflang/src/org/lflang/LFResourceDescriptionStrategy.java index 548d5e0ea6..487e63374b 100644 --- a/org.lflang/src/org/lflang/LFResourceDescriptionStrategy.java +++ b/org.lflang/src/org/lflang/LFResourceDescriptionStrategy.java @@ -1,32 +1,32 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang; +import com.google.inject.Inject; import java.util.Map; import java.util.stream.Collectors; - import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.naming.QualifiedName; import org.eclipse.xtext.resource.EObjectDescription; @@ -34,56 +34,52 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.eclipse.xtext.resource.impl.DefaultResourceDescriptionStrategy; import org.eclipse.xtext.scoping.impl.ImportUriResolver; import org.eclipse.xtext.util.IAcceptor; - import org.lflang.lf.Model; -import com.google.inject.Inject; - /** - * Resource description strategy designed to limit global scope to only those - * files that were explicitly imported. - *

    - * Adapted from example provided by Itemis. + * Resource description strategy designed to limit global scope to only those files that were + * explicitly imported. + * + *

    Adapted from example provided by Itemis. * * @author Marten Lohstroh * @see "https://blogs.itemis.com/en/in-five-minutes-to-transitive-imports-within-a-dsl-with-xtext" */ public class LFResourceDescriptionStrategy extends DefaultResourceDescriptionStrategy { - /** - * Key used in user data attached to description of a Model. - */ - public static final String INCLUDES = "includes"; + /** Key used in user data attached to description of a Model. */ + public static final String INCLUDES = "includes"; - /** - * Delimiter used in the values associated with INCLUDES keys in the - * user-data descriptions of Models. - */ - public static final String DELIMITER = ","; + /** + * Delimiter used in the values associated with INCLUDES keys in the user-data descriptions of + * Models. + */ + public static final String DELIMITER = ","; - @Inject - private ImportUriResolver uriResolver; + @Inject private ImportUriResolver uriResolver; - @Override - public boolean createEObjectDescriptions(EObject eObject, IAcceptor acceptor) { - if (eObject instanceof Model) { - this.createEObjectDescriptionForModel((Model) eObject, acceptor); - return true; - } else { - return super.createEObjectDescriptions(eObject, acceptor); - } + @Override + public boolean createEObjectDescriptions( + EObject eObject, IAcceptor acceptor) { + if (eObject instanceof Model) { + this.createEObjectDescriptionForModel((Model) eObject, acceptor); + return true; + } else { + return super.createEObjectDescriptions(eObject, acceptor); } + } - /** - * Build an index containing the strings of the URIs imported resources. - *

    - * All the URIs are added to comma-separated string and stored under the - * key "includes" in the userData map of the object description. - **/ - private void createEObjectDescriptionForModel(Model model, IAcceptor acceptor) { - var uris = model.getImports().stream().map(uriResolver).collect(Collectors.joining(DELIMITER)); - var userData = Map.of(INCLUDES, uris); - QualifiedName qname = QualifiedName.create(model.eResource().getURI().toString()); - acceptor.accept(EObjectDescription.create(qname, model, userData)); - } + /** + * Build an index containing the strings of the URIs imported resources. + * + *

    All the URIs are added to comma-separated string and stored under the key "includes" in the + * userData map of the object description. + */ + private void createEObjectDescriptionForModel( + Model model, IAcceptor acceptor) { + var uris = model.getImports().stream().map(uriResolver).collect(Collectors.joining(DELIMITER)); + var userData = Map.of(INCLUDES, uris); + QualifiedName qname = QualifiedName.create(model.eResource().getURI().toString()); + acceptor.accept(EObjectDescription.create(qname, model, userData)); + } } diff --git a/org.lflang/src/org/lflang/LFResourceProvider.java b/org.lflang/src/org/lflang/LFResourceProvider.java index 51db96a6d5..03c7b9ea47 100644 --- a/org.lflang/src/org/lflang/LFResourceProvider.java +++ b/org.lflang/src/org/lflang/LFResourceProvider.java @@ -1,28 +1,24 @@ package org.lflang; -import org.eclipse.emf.ecore.resource.ResourceSet; - import com.google.inject.Inject; import com.google.inject.Provider; +import org.eclipse.emf.ecore.resource.ResourceSet; /** * Class that provides access to a resource set. - * - * @author Marten Lohstroh * + * @author Marten Lohstroh */ public class LFResourceProvider { - /** - * Injected resource set provider. - */ - @Inject - private Provider resourceSetProvider; - - /** - * Return a resource set obtained from the injected provider. - * @return - */ - public ResourceSet getResourceSet() { - return this.resourceSetProvider.get(); - } + /** Injected resource set provider. */ + @Inject private Provider resourceSetProvider; + + /** + * Return a resource set obtained from the injected provider. + * + * @return + */ + public ResourceSet getResourceSet() { + return this.resourceSetProvider.get(); + } } diff --git a/org.lflang/src/org/lflang/LFRuntimeModule.java b/org.lflang/src/org/lflang/LFRuntimeModule.java index a7c1e80a19..a01986dfb3 100644 --- a/org.lflang/src/org/lflang/LFRuntimeModule.java +++ b/org.lflang/src/org/lflang/LFRuntimeModule.java @@ -8,50 +8,50 @@ import org.eclipse.xtext.resource.IDefaultResourceDescriptionStrategy; import org.eclipse.xtext.scoping.IGlobalScopeProvider; import org.eclipse.xtext.validation.INamesAreUniqueValidationHelper; - import org.lflang.formatting2.LFFormatter; import org.lflang.scoping.LFGlobalScopeProvider; import org.lflang.validation.LFNamesAreUniqueValidationHelper; /** - * Binds services that are available both when running LFC - * standalone, and when running within the IDE. + * Binds services that are available both when running LFC standalone, and when running within the + * IDE. + * *

      - *
    • LfIdeModule overrides this module with additional - * bindings when running in the IDE. - *
    • {@code org.lflang.lfc.LFStandaloneModule} overrides this module when - * running LFC standalone. + *
    • LfIdeModule overrides this module with additional bindings when running in the IDE. + *
    • {@code org.lflang.lfc.LFStandaloneModule} overrides this module when running LFC + * standalone. *
    */ public class LFRuntimeModule extends AbstractLFRuntimeModule { - /** Establish a binding to our custom resource description strategy. */ - public Class bindIDefaultResourceDescriptionStrategy() { - return LFResourceDescriptionStrategy.class; - } - - /** Establish a binding to our custom global scope provider. */ - @Override - public Class bindIGlobalScopeProvider() { - return LFGlobalScopeProvider.class; - } - - /** Establish a binding to a helper that checks that names are unique. */ - public Class bindNamesAreUniqueValidationHelper() { - return LFNamesAreUniqueValidationHelper.class; - } - - public Class bindISyntaxErrorMessageProvider() { - return LFSyntaxErrorMessageProvider.class; - } - - /** The error reporter. {@code org.lflang.lfc.LFStandaloneModule} overrides this binding. */ - public Class bindErrorReporter() { - return DefaultErrorReporter.class; - } - - @Override - public Class bindIFormatter2() { - return LFFormatter.class; - } + /** Establish a binding to our custom resource description strategy. */ + public Class + bindIDefaultResourceDescriptionStrategy() { + return LFResourceDescriptionStrategy.class; + } + + /** Establish a binding to our custom global scope provider. */ + @Override + public Class bindIGlobalScopeProvider() { + return LFGlobalScopeProvider.class; + } + + /** Establish a binding to a helper that checks that names are unique. */ + public Class bindNamesAreUniqueValidationHelper() { + return LFNamesAreUniqueValidationHelper.class; + } + + public Class bindISyntaxErrorMessageProvider() { + return LFSyntaxErrorMessageProvider.class; + } + + /** The error reporter. {@code org.lflang.lfc.LFStandaloneModule} overrides this binding. */ + public Class bindErrorReporter() { + return DefaultErrorReporter.class; + } + + @Override + public Class bindIFormatter2() { + return LFFormatter.class; + } } diff --git a/org.lflang/src/org/lflang/LFStandaloneSetup.java b/org.lflang/src/org/lflang/LFStandaloneSetup.java index c1b5e85ecf..13264adabe 100644 --- a/org.lflang/src/org/lflang/LFStandaloneSetup.java +++ b/org.lflang/src/org/lflang/LFStandaloneSetup.java @@ -4,33 +4,30 @@ package org.lflang; - -import org.eclipse.xtext.util.Modules2; - import com.google.inject.Guice; import com.google.inject.Injector; import com.google.inject.Module; +import org.eclipse.xtext.util.Modules2; /** - * Initialization support for running Xtext languages without - * Equinox extension registry. + * Initialization support for running Xtext languages without Equinox extension registry. * - * See {@link LFRuntimeModule}, the base Guice module for LF services. + *

    See {@link LFRuntimeModule}, the base Guice module for LF services. */ public class LFStandaloneSetup extends LFStandaloneSetupGenerated { - private final Module module; + private final Module module; - public LFStandaloneSetup() { - this.module = new LFRuntimeModule(); - } + public LFStandaloneSetup() { + this.module = new LFRuntimeModule(); + } - public LFStandaloneSetup(Module... modules) { - this.module = Modules2.mixin(modules); - } + public LFStandaloneSetup(Module... modules) { + this.module = Modules2.mixin(modules); + } - @Override - public Injector createInjector() { - return Guice.createInjector(this.module); - } + @Override + public Injector createInjector() { + return Guice.createInjector(this.module); + } } diff --git a/org.lflang/src/org/lflang/LFSyntaxErrorMessageProvider.java b/org.lflang/src/org/lflang/LFSyntaxErrorMessageProvider.java index ac5511980a..d1ddb312e1 100644 --- a/org.lflang/src/org/lflang/LFSyntaxErrorMessageProvider.java +++ b/org.lflang/src/org/lflang/LFSyntaxErrorMessageProvider.java @@ -1,8 +1,8 @@ package org.lflang; +import com.google.inject.Inject; import java.util.Set; import java.util.stream.Collectors; - import org.antlr.runtime.RecognitionException; import org.antlr.runtime.Token; import org.eclipse.xtext.GrammarUtil; @@ -10,78 +10,70 @@ import org.eclipse.xtext.nodemodel.SyntaxErrorMessage; import org.eclipse.xtext.parser.antlr.SyntaxErrorMessageProvider; -import com.google.inject.Inject; - /** * Custom error message provider that intercepts syntax errors. - * + * * @author Marten Lohstroh */ public class LFSyntaxErrorMessageProvider extends SyntaxErrorMessageProvider { - - /** - * Issue code for syntax error due to misused keyword. - */ - public static String USED_RESERVED_KEYWORD = "USED_RESERVED_KEYWORD"; - - /** - * Issue code for syntax error due to misused single quotes. - */ - public static String SINGLY_QUOTED_STRING = "SINGLE_QUOTED_STRING"; - - /** - * Helper that provides access to the grammar. - */ - @Inject IGrammarAccess grammarAccess; - - /** - * Set of keywords that otherwise would be valid identifiers. - * For example, 'reaction' is part of this set, but '{=' is not. - */ - public Set keywords; - - /** - * Customize intercepted error messages. - * - * @Override - */ - public SyntaxErrorMessage getSyntaxErrorMessage(IParserErrorContext context) { - - if (context != null) { - String message = context.getDefaultMessage(); - - // Describe situation where an unexpected token was encountered where a closing single quote was expected. - if (message.contains("expecting '''")) { - return new SyntaxErrorMessage("Single quotes can only be used around single characters, not strings. " - + "Please use double quotes instead.", SINGLY_QUOTED_STRING); + + /** Issue code for syntax error due to misused keyword. */ + public static String USED_RESERVED_KEYWORD = "USED_RESERVED_KEYWORD"; + + /** Issue code for syntax error due to misused single quotes. */ + public static String SINGLY_QUOTED_STRING = "SINGLE_QUOTED_STRING"; + + /** Helper that provides access to the grammar. */ + @Inject IGrammarAccess grammarAccess; + + /** + * Set of keywords that otherwise would be valid identifiers. For example, 'reaction' is part of + * this set, but '{=' is not. + */ + public Set keywords; + + /** Customize intercepted error messages. @Override */ + public SyntaxErrorMessage getSyntaxErrorMessage(IParserErrorContext context) { + + if (context != null) { + String message = context.getDefaultMessage(); + + // Describe situation where an unexpected token was encountered where a closing single quote + // was expected. + if (message.contains("expecting '''")) { + return new SyntaxErrorMessage( + "Single quotes can only be used around single characters, not strings. " + + "Please use double quotes instead.", + SINGLY_QUOTED_STRING); + } + + RecognitionException e = context.getRecognitionException(); + if (e != null) { + Token token = e.token; + if (token != null) { + String text = token.getText(); + if (text != null) { + // Update keywords if not yet set. + if (keywords == null) { + // ('a'..'z'|'A'..'Z'|'_')('a'..'z'|'A'..'Z'|'_'|'0'..'9')* + this.keywords = + GrammarUtil.getAllKeywords(grammarAccess.getGrammar()).stream() + .filter(k -> k.matches("^([a-z]|[A-Z]|_)+(\\w|_)*$")) + .collect(Collectors.toSet()); } - - RecognitionException e = context.getRecognitionException(); - if (e != null) { - Token token = e.token; - if (token != null) { - String text = token.getText(); - if (text != null) { - // Update keywords if not yet set. - if (keywords == null) { - // ('a'..'z'|'A'..'Z'|'_')('a'..'z'|'A'..'Z'|'_'|'0'..'9')* - this.keywords = GrammarUtil - .getAllKeywords(grammarAccess.getGrammar()) - .stream() - .filter(k -> k - .matches("^([a-z]|[A-Z]|_)+(\\w|_)*$")) - .collect(Collectors.toSet()); - - } - // Describe situation where a keyword is used as an identifier. - if (keywords.contains(text)) { - return new SyntaxErrorMessage("'" + text + "' is a reserved keyword " - + "which cannot be used as an identifier.", USED_RESERVED_KEYWORD); - } - } - } + // Describe situation where a keyword is used as an identifier. + if (keywords.contains(text)) { + return new SyntaxErrorMessage( + "'" + + text + + "' is a reserved keyword " + + "which cannot be used as an identifier.", + USED_RESERVED_KEYWORD); } + } } - return super.getSyntaxErrorMessage(context); + } } + return super.getSyntaxErrorMessage(context); + } } diff --git a/org.lflang/src/org/lflang/LocalStrings.java b/org.lflang/src/org/lflang/LocalStrings.java index 79f338b39d..314839c3f1 100644 --- a/org.lflang/src/org/lflang/LocalStrings.java +++ b/org.lflang/src/org/lflang/LocalStrings.java @@ -2,10 +2,8 @@ import java.util.ResourceBundle; -/** - * Static class for managing strings. - */ +/** Static class for managing strings. */ public class LocalStrings { - public static final ResourceBundle res = ResourceBundle.getBundle("org.lflang.StringsBundle"); - public static final String VERSION = res.getString("VERSION"); + public static final ResourceBundle res = ResourceBundle.getBundle("org.lflang.StringsBundle"); + public static final String VERSION = res.getString("VERSION"); } diff --git a/org.lflang/src/org/lflang/MainConflictChecker.java b/org.lflang/src/org/lflang/MainConflictChecker.java index 6ee3ebf569..1805cda5d7 100644 --- a/org.lflang/src/org/lflang/MainConflictChecker.java +++ b/org.lflang/src/org/lflang/MainConflictChecker.java @@ -2,6 +2,7 @@ import static java.nio.file.FileVisitResult.CONTINUE; +import com.google.common.collect.Iterables; import java.io.IOException; import java.nio.file.FileVisitResult; import java.nio.file.Files; @@ -11,7 +12,6 @@ import java.util.Iterator; import java.util.LinkedList; import java.util.List; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; @@ -20,92 +20,79 @@ import org.lflang.lf.Reactor; import org.lflang.util.FileUtil; -import com.google.common.collect.Iterables; - /** - * Class that (upon instantiation) determines whether there are any conflicting main reactors in the current package. - * Conflicts are reported in the instance's conflicts list. - * - * @author Marten Lohstroh + * Class that (upon instantiation) determines whether there are any conflicting main reactors in the + * current package. Conflicts are reported in the instance's conflicts list. * + * @author Marten Lohstroh */ public class MainConflictChecker { - /** - * List of conflict encountered while traversing the package. - */ - public final List conflicts = new LinkedList(); - - /** - * The current file configuration. - */ - protected FileConfig fileConfig; - - /** - * Resource set used to obtain resources from. - */ - protected static final ResourceSet rs = new LFStandaloneSetup() - .createInjectorAndDoEMFRegistration() - .getInstance(LFResourceProvider.class).getResourceSet(); - - /** - * Create a new instance that walks the file tree of the package to find conflicts. - * - * @param fileConfig The current file configuration. - */ - public MainConflictChecker(FileConfig fileConfig) { - // FIXME: See if there is a faster way to do this check that does not involve parsing all - // files in the current package (which happens when we get the resources) - this.fileConfig = fileConfig; - try { - Files.walkFileTree(fileConfig.srcPkgPath, new PackageVisitor()); - } catch (IOException e) { - System.err.println("Error while checking for name conflicts in package."); - e.printStackTrace(); - } + /** List of conflict encountered while traversing the package. */ + public final List conflicts = new LinkedList(); + + /** The current file configuration. */ + protected FileConfig fileConfig; + + /** Resource set used to obtain resources from. */ + protected static final ResourceSet rs = + new LFStandaloneSetup() + .createInjectorAndDoEMFRegistration() + .getInstance(LFResourceProvider.class) + .getResourceSet(); + + /** + * Create a new instance that walks the file tree of the package to find conflicts. + * + * @param fileConfig The current file configuration. + */ + public MainConflictChecker(FileConfig fileConfig) { + // FIXME: See if there is a faster way to do this check that does not involve parsing all + // files in the current package (which happens when we get the resources) + this.fileConfig = fileConfig; + try { + Files.walkFileTree(fileConfig.srcPkgPath, new PackageVisitor()); + } catch (IOException e) { + System.err.println("Error while checking for name conflicts in package."); + e.printStackTrace(); } - - /** - * Extension of a SimpleFileVisitor that adds entries to the conflicts list in the outer class. - * - * Specifically, each visited file is checked against the name present in the current file configuration. - * If the name matches the current file (but is not the file itself), then parse that file and determine whether - * there is a main reactor declared. If there is one, report a conflict. - * - * @author Marten Lohstroh - * - */ - public class PackageVisitor extends SimpleFileVisitor { + } + + /** + * Extension of a SimpleFileVisitor that adds entries to the conflicts list in the outer class. + * + *

    Specifically, each visited file is checked against the name present in the current file + * configuration. If the name matches the current file (but is not the file itself), then parse + * that file and determine whether there is a main reactor declared. If there is one, report a + * conflict. + * + * @author Marten Lohstroh + */ + public class PackageVisitor extends SimpleFileVisitor { - /** - * Report a conflicting main reactors in visited files. - */ - @Override - public FileVisitResult visitFile(Path path, BasicFileAttributes attr) { - path = path.normalize(); - if (attr.isRegularFile() && path.toString().endsWith(".lf")) { - // Parse the file. - Resource r = rs.getResource( - URI.createFileURI(path.toFile().getAbsolutePath()), - true); - if (r.getErrors().isEmpty()) { - // No errors. Find the main reactor. - Iterator reactors = Iterables - .filter(IteratorExtensions - .toIterable(r.getAllContents()), - Reactor.class) - .iterator(); - // If this is not the same file, but it has a main reactor - // and the name matches, then report the conflict. - if (!fileConfig.srcFile.equals(path) - && IteratorExtensions.exists(reactors, it -> it.isMain() || it.isFederated()) - && fileConfig.name.equals(FileUtil.nameWithoutExtension(path))) { - conflicts.add( - fileConfig.srcPath.relativize(path).toString()); - } - } - } - return CONTINUE; + /** Report a conflicting main reactors in visited files. */ + @Override + public FileVisitResult visitFile(Path path, BasicFileAttributes attr) { + path = path.normalize(); + if (attr.isRegularFile() && path.toString().endsWith(".lf")) { + // Parse the file. + Resource r = rs.getResource(URI.createFileURI(path.toFile().getAbsolutePath()), true); + if (r.getErrors().isEmpty()) { + // No errors. Find the main reactor. + Iterator reactors = + Iterables.filter( + IteratorExtensions.toIterable(r.getAllContents()), Reactor.class) + .iterator(); + // If this is not the same file, but it has a main reactor + // and the name matches, then report the conflict. + if (!fileConfig.srcFile.equals(path) + && IteratorExtensions.exists(reactors, it -> it.isMain() || it.isFederated()) + && fileConfig.name.equals(FileUtil.nameWithoutExtension(path))) { + conflicts.add(fileConfig.srcPath.relativize(path).toString()); + } } + } + return CONTINUE; } + } } diff --git a/org.lflang/src/org/lflang/ModelInfo.java b/org.lflang/src/org/lflang/ModelInfo.java index 24d5c447c2..17ee7cfb76 100644 --- a/org.lflang/src/org/lflang/ModelInfo.java +++ b/org.lflang/src/org/lflang/ModelInfo.java @@ -1,27 +1,27 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang; @@ -35,7 +35,6 @@ import java.util.LinkedList; import java.util.List; import java.util.Set; - import org.lflang.ast.ASTUtils; import org.lflang.generator.NamedInstance; import org.lflang.generator.ReactorInstance; @@ -51,214 +50,209 @@ import org.lflang.lf.STP; import org.lflang.util.FileUtil; - /** * A helper class for analyzing the AST. This class is instantiated once for each compilation. - *

    - * NOTE: the validator used on imported files uses the same instance! Hence, this class should not contain any info - * specific to any particular resource that is involved in the compilation. + * + *

    NOTE: the validator used on imported files uses the same instance! Hence, this class should + * not contain any info specific to any particular resource that is involved in the compilation. * * @author Marten Lohstroh */ public class ModelInfo { - /** - * Data structure for tracking dependencies between reactor classes. An - * instantiation of class A inside of class B implies that B depends on A. - */ - public InstantiationGraph instantiationGraph; - - /** - * The AST that the info gathered in this class pertains to. - */ - public Model model; - - /** - * The set of assignments that assign a too-large constant to a parameter - * that is used to specify a deadline. These assignments are to be reported - * during validation. - */ - public Set overflowingAssignments; - - /** - * The set of deadlines that use a too-large constant to specify their time - * interval. - */ - public Set overflowingDeadlines; - - /** - * The set of STP offsets that use a too-large constant to specify their time - * interval. - */ - public Set overflowingSTP; - - /** - * The set of parameters used to specify a deadline while having been - * assigned a default value the is too large for this purpose. These - * parameters are to be reported during validation. - */ - public Set overflowingParameters; - - /** Cycles found during topology analysis. */ - private Set> topologyCycles = new LinkedHashSet>(); - - /** - * Whether or not the model information has been updated at least once. - */ - public boolean updated; - - /** - * Redo all analysis based on the given model. - * - * @param model the model to analyze. - */ - public void update(Model model, ErrorReporter reporter) { - this.updated = true; - this.model = model; - this.instantiationGraph = new InstantiationGraph(model, true); - - if (this.instantiationGraph.getCycles().size() == 0) { - List topLevelReactorInstances = new LinkedList<>(); - var main = model.getReactors().stream().filter(it -> it.isMain() || it.isFederated()).findFirst(); - if (main.isPresent()) { - var inst = new ReactorInstance(main.get(), reporter); - topLevelReactorInstances.add(inst); - } else { - model.getReactors().forEach( - it -> topLevelReactorInstances.add(new ReactorInstance(it, reporter)) - ); - } - // don't store the graph into a field, only the cycles. - for (ReactorInstance top : topLevelReactorInstances) { - this.topologyCycles.addAll(top.getCycles()); - } - } - - // may be null if the target is invalid - var target = Target.forName(model.getTarget().getName()).orElse(null); + /** + * Data structure for tracking dependencies between reactor classes. An instantiation of class A + * inside of class B implies that B depends on A. + */ + public InstantiationGraph instantiationGraph; + + /** The AST that the info gathered in this class pertains to. */ + public Model model; + + /** + * The set of assignments that assign a too-large constant to a parameter that is used to specify + * a deadline. These assignments are to be reported during validation. + */ + public Set overflowingAssignments; + + /** The set of deadlines that use a too-large constant to specify their time interval. */ + public Set overflowingDeadlines; + + /** The set of STP offsets that use a too-large constant to specify their time interval. */ + public Set overflowingSTP; + + /** + * The set of parameters used to specify a deadline while having been assigned a default value the + * is too large for this purpose. These parameters are to be reported during validation. + */ + public Set overflowingParameters; + + /** Cycles found during topology analysis. */ + private Set> topologyCycles = new LinkedHashSet>(); + + /** Whether or not the model information has been updated at least once. */ + public boolean updated; + + /** + * Redo all analysis based on the given model. + * + * @param model the model to analyze. + */ + public void update(Model model, ErrorReporter reporter) { + this.updated = true; + this.model = model; + this.instantiationGraph = new InstantiationGraph(model, true); + + if (this.instantiationGraph.getCycles().size() == 0) { + List topLevelReactorInstances = new LinkedList<>(); + var main = + model.getReactors().stream().filter(it -> it.isMain() || it.isFederated()).findFirst(); + if (main.isPresent()) { + var inst = new ReactorInstance(main.get(), reporter); + topLevelReactorInstances.add(inst); + } else { + model + .getReactors() + .forEach(it -> topLevelReactorInstances.add(new ReactorInstance(it, reporter))); + } + // don't store the graph into a field, only the cycles. + for (ReactorInstance top : topLevelReactorInstances) { + this.topologyCycles.addAll(top.getCycles()); + } + } - // Perform C-specific traversals. - if (target == Target.C) { - this.collectOverflowingNodes(); - } + // may be null if the target is invalid + var target = Target.forName(model.getTarget().getName()).orElse(null); - checkCaseInsensitiveNameCollisions(model, reporter); + // Perform C-specific traversals. + if (target == Target.C) { + this.collectOverflowingNodes(); } - public void checkCaseInsensitiveNameCollisions(Model model, ErrorReporter reporter) { - var reactorNames = new HashSet<>(); - var bad = new ArrayList<>(); - for (var reactor : model.getReactors()) { - var lowerName = getName(reactor).toLowerCase(); - if (reactorNames.contains(lowerName)) bad.add(lowerName); - reactorNames.add(lowerName); - } - for (var badName : bad) { - model.getReactors().stream() - .filter(it -> getName(it).toLowerCase().equals(badName)) - .forEach(it -> reporter.reportError(it, "Multiple reactors have the same name up to case differences.")); - } - } + checkCaseInsensitiveNameCollisions(model, reporter); + } - private String getName(Reactor r) { - return r.getName() != null ? r.getName() : FileUtil.nameWithoutExtension(Path.of(model.eResource().getURI().toFileString())); + public void checkCaseInsensitiveNameCollisions(Model model, ErrorReporter reporter) { + var reactorNames = new HashSet<>(); + var bad = new ArrayList<>(); + for (var reactor : model.getReactors()) { + var lowerName = getName(reactor).toLowerCase(); + if (reactorNames.contains(lowerName)) bad.add(lowerName); + reactorNames.add(lowerName); } - - public Set> topologyCycles() { - return this.topologyCycles; + for (var badName : bad) { + model.getReactors().stream() + .filter(it -> getName(it).toLowerCase().equals(badName)) + .forEach( + it -> + reporter.reportError( + it, "Multiple reactors have the same name up to case differences.")); } - - /** - * Collect all assignments, deadlines, and parameters that can cause the - * time interval of a deadline to overflow. In the C target, only 48 bits - * are allotted for deadline intervals, which are specified in nanosecond - * precision. - */ - private void collectOverflowingNodes() { - - this.overflowingAssignments = new HashSet<>(); - this.overflowingDeadlines = new HashSet<>(); - this.overflowingParameters = new HashSet<>(); - this.overflowingSTP = new HashSet<>(); - - // Visit all deadlines in the model; detect possible overflow. - for (var deadline : filter(toIterable(model.eAllContents()), Deadline.class)) { - // If the time value overflows, mark this deadline as overflowing. - if (isTooLarge(ASTUtils.getLiteralTimeValue(deadline.getDelay()))) { - this.overflowingDeadlines.add(deadline); - } - - // If any of the upstream parameters overflow, report this deadline. - final var delay = deadline.getDelay(); - if (delay instanceof ParameterReference - && detectOverflow(new HashSet<>(), ((ParameterReference) deadline.getDelay()).getParameter())) { - this.overflowingDeadlines.add(deadline); - } - } - // Visit all STP offsets in the model; detect possible overflow. - for (var stp : filter(toIterable(model.eAllContents()), STP.class)) { - // If the time value overflows, mark this deadline as overflowing. - if (isTooLarge(ASTUtils.getLiteralTimeValue(stp.getValue()))) { - this.overflowingSTP.add(stp); - } - } + } + + private String getName(Reactor r) { + return r.getName() != null + ? r.getName() + : FileUtil.nameWithoutExtension(Path.of(model.eResource().getURI().toFileString())); + } + + public Set> topologyCycles() { + return this.topologyCycles; + } + + /** + * Collect all assignments, deadlines, and parameters that can cause the time interval of a + * deadline to overflow. In the C target, only 48 bits are allotted for deadline intervals, which + * are specified in nanosecond precision. + */ + private void collectOverflowingNodes() { + + this.overflowingAssignments = new HashSet<>(); + this.overflowingDeadlines = new HashSet<>(); + this.overflowingParameters = new HashSet<>(); + this.overflowingSTP = new HashSet<>(); + + // Visit all deadlines in the model; detect possible overflow. + for (var deadline : filter(toIterable(model.eAllContents()), Deadline.class)) { + // If the time value overflows, mark this deadline as overflowing. + if (isTooLarge(ASTUtils.getLiteralTimeValue(deadline.getDelay()))) { + this.overflowingDeadlines.add(deadline); + } + + // If any of the upstream parameters overflow, report this deadline. + final var delay = deadline.getDelay(); + if (delay instanceof ParameterReference + && detectOverflow( + new HashSet<>(), ((ParameterReference) deadline.getDelay()).getParameter())) { + this.overflowingDeadlines.add(deadline); + } } - - /** - * In the C target, only 48 bits are allotted for deadline intervals, which - * are specified in nanosecond precision. Check whether the given time value - * exceeds the maximum specified value. - * - * @return true if the time value is greater than the specified maximum, - * false otherwise. - */ - private boolean isTooLarge(TimeValue time) { - return time != null && time.toNanoSeconds() > TimeValue.MAX_LONG_DEADLINE; + // Visit all STP offsets in the model; detect possible overflow. + for (var stp : filter(toIterable(model.eAllContents()), STP.class)) { + // If the time value overflows, mark this deadline as overflowing. + if (isTooLarge(ASTUtils.getLiteralTimeValue(stp.getValue()))) { + this.overflowingSTP.add(stp); + } + } + } + + /** + * In the C target, only 48 bits are allotted for deadline intervals, which are specified in + * nanosecond precision. Check whether the given time value exceeds the maximum specified value. + * + * @return true if the time value is greater than the specified maximum, false otherwise. + */ + private boolean isTooLarge(TimeValue time) { + return time != null && time.toNanoSeconds() > TimeValue.MAX_LONG_DEADLINE; + } + + /** + * Given a parameter that is used in a deadline specification, recursively track down its + * definition and check whether it is overflowing. Also detect and report overrides that are + * overflowing. + * + * @return true if there exists a parameter corresponding to a value that does not fit in the + * available bits. + */ + private boolean detectOverflow(Set visited, Parameter current) { + var overflow = false; + + // Determine whether the parameter's default value overflows or not. + if (isTooLarge(ASTUtils.getDefaultAsTimeValue(current))) { + this.overflowingParameters.add(current); + overflow = true; } - /** - * Given a parameter that is used in a deadline specification, recursively - * track down its definition and check whether it is overflowing. Also - * detect and report overrides that are overflowing. - * @return true if there exists a parameter corresponding to a value that - * does not fit in the available bits. - */ - private boolean detectOverflow(Set visited, Parameter current) { - var overflow = false; - - // Determine whether the parameter's default value overflows or not. - if (isTooLarge(ASTUtils.getDefaultAsTimeValue(current))) { - this.overflowingParameters.add(current); - overflow = true; - } - - // Iterate over the instantiations of the reactor in which the - // current parameter was found. - Set instantiations = this.instantiationGraph.getInstantiations((Reactor) current.eContainer()); - for (var instantiation : instantiations) { - // Only visit each instantiation once per deadline to avoid cycles. - if (!visited.contains(instantiation)) { - visited.add(instantiation); - // Find assignments that override the current parameter. - for (var assignment : instantiation.getParameters()) { - if (assignment.getLhs().equals(current)) { - if (assignment.getRhs().getExprs().isEmpty()) continue; // This error should be caught elsewhere. - Expression expr = ASTUtils.asSingleExpr(assignment.getRhs()); - if (expr instanceof ParameterReference) { - // Check for overflow in the referenced parameter. - overflow = detectOverflow(visited, ((ParameterReference)expr).getParameter()) || overflow; - } else { - // The right-hand side of the assignment is a - // constant; check whether it is too large. - if (isTooLarge(ASTUtils.getLiteralTimeValue(expr))) { - this.overflowingAssignments.add(assignment); - overflow = true; - } - } - } - } + // Iterate over the instantiations of the reactor in which the + // current parameter was found. + Set instantiations = + this.instantiationGraph.getInstantiations((Reactor) current.eContainer()); + for (var instantiation : instantiations) { + // Only visit each instantiation once per deadline to avoid cycles. + if (!visited.contains(instantiation)) { + visited.add(instantiation); + // Find assignments that override the current parameter. + for (var assignment : instantiation.getParameters()) { + if (assignment.getLhs().equals(current)) { + if (assignment.getRhs().getExprs().isEmpty()) + continue; // This error should be caught elsewhere. + Expression expr = ASTUtils.asSingleExpr(assignment.getRhs()); + if (expr instanceof ParameterReference) { + // Check for overflow in the referenced parameter. + overflow = + detectOverflow(visited, ((ParameterReference) expr).getParameter()) || overflow; + } else { + // The right-hand side of the assignment is a + // constant; check whether it is too large. + if (isTooLarge(ASTUtils.getLiteralTimeValue(expr))) { + this.overflowingAssignments.add(assignment); + overflow = true; + } } + } } - return overflow; + } } + return overflow; + } } diff --git a/org.lflang/src/org/lflang/Target.java b/org.lflang/src/org/lflang/Target.java index 2a0e0e8700..8f08e89fcc 100644 --- a/org.lflang/src/org/lflang/Target.java +++ b/org.lflang/src/org/lflang/Target.java @@ -1,22 +1,19 @@ /* Static information about targets. */ /** - * Copyright (c) 2019, The University of California at Berkeley. - * 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. - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * Copyright (c) 2019, The University of California at Berkeley. 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. THIS SOFTWARE IS PROVIDED BY + * THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. */ package org.lflang; @@ -27,574 +24,552 @@ import java.util.List; import java.util.Optional; import java.util.Set; - import org.lflang.lf.TargetDecl; -/** - * Enumeration of targets and their associated properties. These classes are - * written in Java, not Xtend, because the enum implementation in Xtend more - * primitive. It is safer to use enums rather than string values since it allows - * faulty references to be caught at compile time. Switch statements that take - * as input an enum but do not have cases for all members of the enum are also +/** + * Enumeration of targets and their associated properties. These classes are written in Java, not + * Xtend, because the enum implementation in Xtend more primitive. It is safer to use enums rather + * than string values since it allows faulty references to be caught at compile time. Switch + * statements that take as input an enum but do not have cases for all members of the enum are also * reported by Xtend with a warning message. - * + * * @author Marten Lohstroh */ public enum Target { - C("C", true, Arrays.asList( - // List via: https://en.cppreference.com/w/c/keyword - "auto", - "break", - "case", - "char", - "const", - "continue", - "default", - "do", - "double", - "else", - "enum", - "extern", - "float", - "for", - "goto", - "if", - "inline", // (since C99) - "int", - "long", - "register", - "restrict", // (since C99) - "return", - "short", - "signed", - "sizeof", - "static", - "struct", - "switch", - "typedef", - "union", - "unsigned", - "void", - "volatile", - "while", - "_Alignas", // (since C11) - "_Alignof", // (since C11) - "_Atomic", // (since C11) - "_Bool", // (since C99) - "_Complex", // (since C99) - "_Generic", // (since C11) - "_Imaginary", // (since C99) - "_Noreturn", // (since C11) - "_Static_assert", // (since C11) - "_Thread_local" // (since C11) - ) - ), - CCPP("CCpp", true, Target.C.keywords), - CPP("Cpp", true, "cpp", "Cpp", Arrays.asList( - // List via: https://en.cppreference.com/w/cpp/keyword - "alignas", // (since C++11) - "alignof", // (since C++11) - "and", - "and_eq", - "asm", - "atomic_cancel", // (TM TS) - "atomic_commit", // (TM TS) - "atomic_noexcept", // (TM TS) - "auto(1)", - "bitand", - "bitor", - "bool", - "break", - "case", - "catch", - "char", - "char8_t", // (since C++20) - "char16_t", // (since C++11) - "char32_t", // (since C++11) - "class(1)", - "compl", - "concept", // (since C++20) - "const", - "consteval", // (since C++20) - "constexpr", // (since C++11) - "constinit", // (since C++20) - "const_cast", - "continue", - "co_await", // (since C++20) - "co_return", // (since C++20) - "co_yield", // (since C++20) - "decltype", // (since C++11) - "default(1)", - "delete(1)", - "do", - "double", - "dynamic_cast", - "else", - "enum", - "explicit", - "export(1)(3)", - "extern(1)", - "false", - "float", - "for", - "friend", - "goto", - "if", - "inline(1)", - "int", - "long", - "mutable(1)", - "namespace", - "new", - "noexcept", // (since C++11) - "not", - "not_eq", - "nullptr", // (since C++11) - "operator", - "or", - "or_eq", - "private", - "protected", - "public", - "reflexpr", // (reflection TS) - "register(2)", - "reinterpret_cast", - "requires", // (since C++20) - "return", - "short", - "signed", - "sizeof(1)", - "static", - "static_assert", // (since C++11) - "static_cast", - "struct(1)", - "switch", - "synchronized", // (TM TS) - "template", - "this", - "thread_local", // (since C++11) - "throw", - "true", - "try", - "typedef", - "typeid", - "typename", - "union", - "unsigned", - "using(1)", - "virtual", - "void", - "volatile", - "wchar_t", - "while", - "xor", - "xor_eq" - ) - ), - TS("TypeScript", false, "ts", "TS", Arrays.asList( - // List via: https://github.com/Microsoft/TypeScript/issues/2536 - // Reserved words - "break", - "case", - "catch", - "class", - "const", - "continue", - "debugger", - "default", - "delete", - "do", - "else", - "enum", - "export", - "extends", - "false", - "finally", - "for", - "function", - "if", - "import", - "in", - "instanceof", - "new", - "null", - "return", - "super", - "switch", - "this", - "throw", - "true", - "try", - "typeof", - "var", - "void", - "while", - "with", - - // Strict Mode Reserved Words - "as", - "implements", - "interface", - "let", - "package", - "private", - "protected", - "public", - "static", - "yield", - - // Contextual Keywords - "any", - "boolean", - "constructor", - "declare", - "get", - "module", - "require", - "number", - "set", - "string", - "symbol", - "type", - "from", - "of", - - // Reactor-TS specific keywords (other classes, which are less user-facing, have double underscores) - "TimeUnit", - "TimeValue", - "Present", - "Sched", - "Read", - "Write", - "ReadWrite" - ) - ), - Python("Python", false, Arrays.asList( - // List via: https://www.w3schools.com/python/python_ref_keywords.asp - // and https://en.cppreference.com/w/c/keyword (due to reliance on the C lib). - "and", - "as", - "assert", - "auto", - "break", - "case", - "char", - "class", - "const", - "continue", - "def", - "default", - "del", - "do", - "double", - "elif", - "else", - "enum", - "except", - "extern", - "False", - "finally", - "float", - "for", - "from", - "global", - "goto", - "if", - "import", - "inline", // (since C99) - "int", - "in", - "is", - "lambda", - "long", - "None", - "nonlocal", - "not", - "or", - "pass", - "raise", - "register", - "restrict", // (since C99) - "return", - "short", - "signed", - "sizeof", - "static", - "struct", - "switch", - "True", - "try", - "typedef", - "union", - "unsigned", - "void", - "volatile", - "while", - "with", - "yield", - "_Alignas", // (since C11) - "_Alignof", // (since C11) - "_Atomic", // (since C11) - "_Bool", // (since C99) - "_Complex", // (since C99) - "_Generic", // (since C11) - "_Imaginary", // (since C99) - "_Noreturn", // (since C11) - "_Static_assert", // (since C11) - "_Thread_local" // (since C11) - ) - ), - Rust("Rust", true, - "rust", "Rust", - // In our Rust implementation, the only reserved keywords - // are those that are a valid expression. Others may be escaped - // with the syntax r#keyword. - Arrays.asList("self", "true", "false") - ); - - /** - * String representation of this target. - */ - private final String displayName; - - /** - * Name of package containing Kotlin classes for the target language. - */ - public final String packageName; - - /** - * Prefix of names of Kotlin classes for the target language. - */ - public final String classNamePrefix; - - /** - * Whether or not this target requires types. - */ - public final boolean requiresTypes; - - /** - * Reserved words in the target language. - */ - public final Set keywords; - - /** - *An unmodifiable list of all known targets. - */ - public static final List ALL = List.of(Target.values()); - - /** - * Private constructor for targets. - * - * @param displayName String representation of this target. - * @param requiresTypes Types Whether this target requires type annotations or not. - * @param packageName Name of package containing Kotlin classes for the target language. - * @param classNamePrefix Prefix of names of Kotlin classes for the target language. - * @param keywords List of reserved strings in the target language. - */ - Target(String displayName, boolean requiresTypes, String packageName, - String classNamePrefix, Collection keywords) { - this.displayName = displayName; - this.requiresTypes = requiresTypes; - this.keywords = Collections.unmodifiableSet(new LinkedHashSet<>(keywords)); - this.packageName = packageName; - this.classNamePrefix = classNamePrefix; - } - - - /** - * Private constructor for targets without packageName and classNamePrefix. - */ - Target(String displayName, boolean requiresTypes, Collection keywords) { - this(displayName, requiresTypes, "N/A", "N/A", keywords); // FIXME: prefix - } - - - /** - * Return the target whose {@linkplain #getDisplayName() display name} - * is the given string (modulo character case), or an empty - * optional if there is no such target. - */ - public static Optional forName(String name) { - return Arrays.stream(Target.values()) - .filter(it -> it.getDisplayName().equalsIgnoreCase(name)) - .findFirst(); - } - - /** - * Return the display name of the target, as it should be - * written in LF code. This is hence a single identifier. - * Eg for {@link #CPP} returns {@code "Cpp"}, for {@link #Python} - * returns {@code "Python"}. Avoid using either {@link #name()} - * or {@link #toString()}, which have unrelated contracts. - */ - public String getDisplayName() { - return displayName; - } - - /** - * Returns the conventional directory name for this target. - * This is used to divide e.g. the {@code test} and {@code example} - * directories by target language. For instance, {@code test/Cpp} - * is the path of {@link #CPP}'s test directory, and this - * method returns {@code "Cpp"}. - */ - public String getDirectoryName() { - return displayName; - } - - /** - * Return the description. Avoid depending on this, toString - * is supposed to be debug information. Prefer {@link #getDisplayName()}. - */ - @Override - public String toString() { - return displayName; - } - - /** - * Returns whether the given identifier is invalid as the - * name of an LF construct. This usually means that the identifier - * is a keyword in the target language. In Rust, many - * keywords may be escaped with the syntax {@code r#keyword}, - * and they are considered valid identifiers. - */ - public boolean isReservedIdent(String ident) { - return this.keywords.contains(ident); - } - - /** - * Return true if the target supports federated execution. - */ - public boolean supportsFederated() { - return switch (this) { - case C, CCPP, Python, TS -> true; - default -> false; - }; - } - - /** - * Return true if the target supports reactor inheritance (extends keyword). - */ - public boolean supportsInheritance() { - return switch (this) { - case C, CCPP, Python -> true; - default -> false; - }; - } - - /** - * Return true if the target supports multiports and banks - * of reactors. - */ - public boolean supportsMultiports() { - switch (this) { - case C: - case CCPP: - case CPP: - case Python: - case Rust: - case TS: - return true; - } - return false; - } - - - /** - * Return true if the target supports widths of banks and - * multiports that depend on reactor parameters (not only - * on constants). - */ - public boolean supportsParameterizedWidths() { + C( + "C", + true, + Arrays.asList( + // List via: https://en.cppreference.com/w/c/keyword + "auto", + "break", + "case", + "char", + "const", + "continue", + "default", + "do", + "double", + "else", + "enum", + "extern", + "float", + "for", + "goto", + "if", + "inline", // (since C99) + "int", + "long", + "register", + "restrict", // (since C99) + "return", + "short", + "signed", + "sizeof", + "static", + "struct", + "switch", + "typedef", + "union", + "unsigned", + "void", + "volatile", + "while", + "_Alignas", // (since C11) + "_Alignof", // (since C11) + "_Atomic", // (since C11) + "_Bool", // (since C99) + "_Complex", // (since C99) + "_Generic", // (since C11) + "_Imaginary", // (since C99) + "_Noreturn", // (since C11) + "_Static_assert", // (since C11) + "_Thread_local" // (since C11) + )), + CCPP("CCpp", true, Target.C.keywords), + CPP( + "Cpp", + true, + "cpp", + "Cpp", + Arrays.asList( + // List via: https://en.cppreference.com/w/cpp/keyword + "alignas", // (since C++11) + "alignof", // (since C++11) + "and", + "and_eq", + "asm", + "atomic_cancel", // (TM TS) + "atomic_commit", // (TM TS) + "atomic_noexcept", // (TM TS) + "auto(1)", + "bitand", + "bitor", + "bool", + "break", + "case", + "catch", + "char", + "char8_t", // (since C++20) + "char16_t", // (since C++11) + "char32_t", // (since C++11) + "class(1)", + "compl", + "concept", // (since C++20) + "const", + "consteval", // (since C++20) + "constexpr", // (since C++11) + "constinit", // (since C++20) + "const_cast", + "continue", + "co_await", // (since C++20) + "co_return", // (since C++20) + "co_yield", // (since C++20) + "decltype", // (since C++11) + "default(1)", + "delete(1)", + "do", + "double", + "dynamic_cast", + "else", + "enum", + "explicit", + "export(1)(3)", + "extern(1)", + "false", + "float", + "for", + "friend", + "goto", + "if", + "inline(1)", + "int", + "long", + "mutable(1)", + "namespace", + "new", + "noexcept", // (since C++11) + "not", + "not_eq", + "nullptr", // (since C++11) + "operator", + "or", + "or_eq", + "private", + "protected", + "public", + "reflexpr", // (reflection TS) + "register(2)", + "reinterpret_cast", + "requires", // (since C++20) + "return", + "short", + "signed", + "sizeof(1)", + "static", + "static_assert", // (since C++11) + "static_cast", + "struct(1)", + "switch", + "synchronized", // (TM TS) + "template", + "this", + "thread_local", // (since C++11) + "throw", + "true", + "try", + "typedef", + "typeid", + "typename", + "union", + "unsigned", + "using(1)", + "virtual", + "void", + "volatile", + "wchar_t", + "while", + "xor", + "xor_eq")), + TS( + "TypeScript", + false, + "ts", + "TS", + Arrays.asList( + // List via: https://github.com/Microsoft/TypeScript/issues/2536 + // Reserved words + "break", + "case", + "catch", + "class", + "const", + "continue", + "debugger", + "default", + "delete", + "do", + "else", + "enum", + "export", + "extends", + "false", + "finally", + "for", + "function", + "if", + "import", + "in", + "instanceof", + "new", + "null", + "return", + "super", + "switch", + "this", + "throw", + "true", + "try", + "typeof", + "var", + "void", + "while", + "with", + + // Strict Mode Reserved Words + "as", + "implements", + "interface", + "let", + "package", + "private", + "protected", + "public", + "static", + "yield", + + // Contextual Keywords + "any", + "boolean", + "constructor", + "declare", + "get", + "module", + "require", + "number", + "set", + "string", + "symbol", + "type", + "from", + "of", + + // Reactor-TS specific keywords (other classes, which are less user-facing, have double + // underscores) + "TimeUnit", + "TimeValue", + "Present", + "Sched", + "Read", + "Write", + "ReadWrite")), + Python( + "Python", + false, + Arrays.asList( + // List via: https://www.w3schools.com/python/python_ref_keywords.asp + // and https://en.cppreference.com/w/c/keyword (due to reliance on the C lib). + "and", + "as", + "assert", + "auto", + "break", + "case", + "char", + "class", + "const", + "continue", + "def", + "default", + "del", + "do", + "double", + "elif", + "else", + "enum", + "except", + "extern", + "False", + "finally", + "float", + "for", + "from", + "global", + "goto", + "if", + "import", + "inline", // (since C99) + "int", + "in", + "is", + "lambda", + "long", + "None", + "nonlocal", + "not", + "or", + "pass", + "raise", + "register", + "restrict", // (since C99) + "return", + "short", + "signed", + "sizeof", + "static", + "struct", + "switch", + "True", + "try", + "typedef", + "union", + "unsigned", + "void", + "volatile", + "while", + "with", + "yield", + "_Alignas", // (since C11) + "_Alignof", // (since C11) + "_Atomic", // (since C11) + "_Bool", // (since C99) + "_Complex", // (since C99) + "_Generic", // (since C11) + "_Imaginary", // (since C99) + "_Noreturn", // (since C11) + "_Static_assert", // (since C11) + "_Thread_local" // (since C11) + )), + Rust( + "Rust", + true, + "rust", + "Rust", + // In our Rust implementation, the only reserved keywords + // are those that are a valid expression. Others may be escaped + // with the syntax r#keyword. + Arrays.asList("self", "true", "false")); + + /** String representation of this target. */ + private final String displayName; + + /** Name of package containing Kotlin classes for the target language. */ + public final String packageName; + + /** Prefix of names of Kotlin classes for the target language. */ + public final String classNamePrefix; + + /** Whether or not this target requires types. */ + public final boolean requiresTypes; + + /** Reserved words in the target language. */ + public final Set keywords; + + /** An unmodifiable list of all known targets. */ + public static final List ALL = List.of(Target.values()); + + /** + * Private constructor for targets. + * + * @param displayName String representation of this target. + * @param requiresTypes Types Whether this target requires type annotations or not. + * @param packageName Name of package containing Kotlin classes for the target language. + * @param classNamePrefix Prefix of names of Kotlin classes for the target language. + * @param keywords List of reserved strings in the target language. + */ + Target( + String displayName, + boolean requiresTypes, + String packageName, + String classNamePrefix, + Collection keywords) { + this.displayName = displayName; + this.requiresTypes = requiresTypes; + this.keywords = Collections.unmodifiableSet(new LinkedHashSet<>(keywords)); + this.packageName = packageName; + this.classNamePrefix = classNamePrefix; + } + + /** Private constructor for targets without packageName and classNamePrefix. */ + Target(String displayName, boolean requiresTypes, Collection keywords) { + this(displayName, requiresTypes, "N/A", "N/A", keywords); // FIXME: prefix + } + + /** + * Return the target whose {@linkplain #getDisplayName() display name} is the given string (modulo + * character case), or an empty optional if there is no such target. + */ + public static Optional forName(String name) { + return Arrays.stream(Target.values()) + .filter(it -> it.getDisplayName().equalsIgnoreCase(name)) + .findFirst(); + } + + /** + * Return the display name of the target, as it should be written in LF code. This is hence a + * single identifier. Eg for {@link #CPP} returns {@code "Cpp"}, for {@link #Python} returns + * {@code "Python"}. Avoid using either {@link #name()} or {@link #toString()}, which have + * unrelated contracts. + */ + public String getDisplayName() { + return displayName; + } + + /** + * Returns the conventional directory name for this target. This is used to divide e.g. the {@code + * test} and {@code example} directories by target language. For instance, {@code test/Cpp} is the + * path of {@link #CPP}'s test directory, and this method returns {@code "Cpp"}. + */ + public String getDirectoryName() { + return displayName; + } + + /** + * Return the description. Avoid depending on this, toString is supposed to be debug information. + * Prefer {@link #getDisplayName()}. + */ + @Override + public String toString() { + return displayName; + } + + /** + * Returns whether the given identifier is invalid as the name of an LF construct. This usually + * means that the identifier is a keyword in the target language. In Rust, many keywords may be + * escaped with the syntax {@code r#keyword}, and they are considered valid identifiers. + */ + public boolean isReservedIdent(String ident) { + return this.keywords.contains(ident); + } + + /** Return true if the target supports federated execution. */ + public boolean supportsFederated() { + return switch (this) { + case C, CCPP, Python, TS -> true; + default -> false; + }; + } + + /** Return true if the target supports reactor inheritance (extends keyword). */ + public boolean supportsInheritance() { + return switch (this) { + case C, CCPP, Python -> true; + default -> false; + }; + } + + /** Return true if the target supports multiports and banks of reactors. */ + public boolean supportsMultiports() { + switch (this) { + case C: + case CCPP: + case CPP: + case Python: + case Rust: + case TS: return true; } - - /** - * Return true if this code for this target should be built using Docker if Docker is used. - * @return - */ - public boolean buildsUsingDocker() { - return switch (this) { - case TS -> false; - case C, CCPP, CPP, Python, Rust -> true; - }; - } - - /** - * Whether the target requires using an equal sign to assign a default value to a parameter, - * or initialize a state variable. All targets mandate an equal sign when passing - * arguments to a reactor constructor call, regardless of this method. - */ - public boolean mandatesEqualsInitializers() { - return this != CPP; + return false; + } + + /** + * Return true if the target supports widths of banks and multiports that depend on reactor + * parameters (not only on constants). + */ + public boolean supportsParameterizedWidths() { + return true; + } + + /** + * Return true if this code for this target should be built using Docker if Docker is used. + * + * @return + */ + public boolean buildsUsingDocker() { + return switch (this) { + case TS -> false; + case C, CCPP, CPP, Python, Rust -> true; + }; + } + + /** + * Whether the target requires using an equal sign to assign a default value to a parameter, or + * initialize a state variable. All targets mandate an equal sign when passing arguments to a + * reactor constructor call, regardless of this method. + */ + public boolean mandatesEqualsInitializers() { + return this != CPP; + } + + /** Allow expressions of the form {@code {a, b, c}}. */ + public boolean allowsBracedListExpressions() { + return this == C || this == CCPP || this == CPP; + } + + /** Return a string that demarcates the beginning of a single-line comment. */ + public String getSingleLineCommentPrefix() { + return this.equals(Target.Python) ? "#" : "//"; + } + + /** + * Return true if the keepalive option is set automatically for this target if physical actions + * are detected in the program (and keepalive was not explicitly unset by the user). + */ + public boolean setsKeepAliveOptionAutomatically() { + return this != Rust && this != CPP; + } + + /** + * Given a string and a list of candidate objects, return the first candidate that matches, or + * null if no candidate matches. + * + *

    todo move to CollectionUtil (introduced in #442) + * + * @param string The string to match against candidates. + * @param candidates The candidates to match the string against. + */ + public static T match(final String string, final Iterable candidates) { + // kotlin: candidates.firstOrNull { it.toString().equalsIgnoreCase(string) } + for (T candidate : candidates) { + if (candidate.toString().equalsIgnoreCase(string)) { + return candidate; + } } - - /** Allow expressions of the form {@code {a, b, c}}. */ - public boolean allowsBracedListExpressions() { - return this == C || this == CCPP || this == CPP; - } - - /** - * Return a string that demarcates the beginning of a single-line comment. - */ - public String getSingleLineCommentPrefix() { - return this.equals(Target.Python) ? "#" : "//"; - } - - /** - * Return true if the keepalive option is set automatically - * for this target if physical actions are detected in the - * program (and keepalive was not explicitly unset by the user). - */ - public boolean setsKeepAliveOptionAutomatically() { - return this != Rust && this != CPP; - } - - /** - * Given a string and a list of candidate objects, return the first - * candidate that matches, or null if no candidate matches. - * - * todo move to CollectionUtil (introduced in #442) - * - * @param string The string to match against candidates. - * @param candidates The candidates to match the string against. - */ - public static T match(final String string, final Iterable candidates) { - // kotlin: candidates.firstOrNull { it.toString().equalsIgnoreCase(string) } - for (T candidate : candidates) { - if (candidate.toString().equalsIgnoreCase(string)) { - return candidate; - } - } - return null; - } - - - /** - * Given a string and a list of candidate objects, return the first - * candidate that matches, or null if no candidate matches. - * - * todo move to CollectionUtil (introduced in #442) - * - * @param string The string to match against candidates. - * @param candidates The candidates to match the string against. - */ - public static T match(final String string, final T[] candidates) { - return match(string, Arrays.asList(candidates)); - } - - - /** - * Return the target constant corresponding to given target - * declaration among. Return a non-null result, will throw - * if invalid. - * - * @throws RuntimeException If no {@link TargetDecl} is present or if it is invalid. - */ - public static Target fromDecl(TargetDecl targetDecl) { - String name = targetDecl.getName(); - return Target.forName(name) - .orElseThrow(() -> new RuntimeException("Invalid target name '" + name + "'")); - } - + return null; + } + + /** + * Given a string and a list of candidate objects, return the first candidate that matches, or + * null if no candidate matches. + * + *

    todo move to CollectionUtil (introduced in #442) + * + * @param string The string to match against candidates. + * @param candidates The candidates to match the string against. + */ + public static T match(final String string, final T[] candidates) { + return match(string, Arrays.asList(candidates)); + } + + /** + * Return the target constant corresponding to given target declaration among. Return a non-null + * result, will throw if invalid. + * + * @throws RuntimeException If no {@link TargetDecl} is present or if it is invalid. + */ + public static Target fromDecl(TargetDecl targetDecl) { + String name = targetDecl.getName(); + return Target.forName(name) + .orElseThrow(() -> new RuntimeException("Invalid target name '" + name + "'")); + } } diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 84770be5d1..c4794b4b1a 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -1,27 +1,27 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang; import java.util.ArrayList; @@ -32,7 +32,6 @@ import java.util.Objects; import java.util.Properties; import java.util.Set; - import org.lflang.TargetProperty.BuildType; import org.lflang.TargetProperty.ClockSyncMode; import org.lflang.TargetProperty.CoordinationType; @@ -48,453 +47,376 @@ /** * A class for keeping the current target configuration. * - * Class members of type String are initialized as empty strings, - * unless otherwise stated. + *

    Class members of type String are initialized as empty strings, unless otherwise stated. + * * @author Marten Lohstroh */ public class TargetConfig { - /** - * The target of this configuration (e.g., C, TypeScript, Python). - */ - public final Target target; - - /** - * Create a new target configuration based on the given target declaration AST node only. - * @param target AST node of a target declaration. - */ - public TargetConfig(TargetDecl target) { // FIXME: eliminate this constructor if we can - this.target = Target.fromDecl(target); + /** The target of this configuration (e.g., C, TypeScript, Python). */ + public final Target target; + + /** + * Create a new target configuration based on the given target declaration AST node only. + * + * @param target AST node of a target declaration. + */ + public TargetConfig(TargetDecl target) { // FIXME: eliminate this constructor if we can + this.target = Target.fromDecl(target); + } + + /** + * Create a new target configuration based on the given commandline arguments and target + * declaration AST node. + * + * @param cliArgs Arguments passed on the commandline. + * @param target AST node of a target declaration. + * @param errorReporter An error reporter to report problems. + */ + public TargetConfig(Properties cliArgs, TargetDecl target, ErrorReporter errorReporter) { + this(target); + if (target.getConfig() != null) { + List pairs = target.getConfig().getPairs(); + TargetProperty.set(this, pairs != null ? pairs : List.of(), errorReporter); } - - /** - * Create a new target configuration based on the given commandline arguments and target - * declaration AST node. - * @param cliArgs Arguments passed on the commandline. - * @param target AST node of a target declaration. - * @param errorReporter An error reporter to report problems. - */ - public TargetConfig( - Properties cliArgs, - TargetDecl target, - ErrorReporter errorReporter - ) { - this(target); - if (target.getConfig() != null) { - List pairs = target.getConfig().getPairs(); - TargetProperty.set(this, pairs != null ? pairs : List.of(), errorReporter); - } - if (cliArgs.containsKey("no-compile")) { - this.noCompile = true; - } - if (cliArgs.containsKey("docker")) { - var arg = cliArgs.getProperty("docker"); - if (Boolean.parseBoolean(arg)) { - this.dockerOptions = new DockerOptions(); - } else { - this.dockerOptions = null; - } - // FIXME: this is pretty ad-hoc and does not account for more complex overrides yet. - } - if (cliArgs.containsKey("build-type")) { - this.cmakeBuildType = (BuildType) UnionType.BUILD_TYPE_UNION.forName(cliArgs.getProperty("build-type")); - } - if (cliArgs.containsKey("logging")) { - this.logLevel = LogLevel.valueOf(cliArgs.getProperty("logging").toUpperCase()); - } - if (cliArgs.containsKey("workers")) { - this.workers = Integer.parseInt(cliArgs.getProperty("workers")); - } - if (cliArgs.containsKey("threading")) { - this.threading = Boolean.parseBoolean(cliArgs.getProperty("threading")); - } - if (cliArgs.containsKey("target-compiler")) { - this.compiler = cliArgs.getProperty("target-compiler"); - } - if (cliArgs.containsKey("tracing")) { - this.tracing = new TracingOptions(); - } - if (cliArgs.containsKey("scheduler")) { - this.schedulerType = SchedulerOption.valueOf( - cliArgs.getProperty("scheduler") - ); - this.setByUser.add(TargetProperty.SCHEDULER); - } - if (cliArgs.containsKey("target-flags")) { - this.compilerFlags.clear(); - if (!cliArgs.getProperty("target-flags").isEmpty()) { - this.compilerFlags.addAll(List.of( - cliArgs.getProperty("target-flags").split(" ") - )); - } - } - if (cliArgs.containsKey("runtime-version")) { - this.runtimeVersion = cliArgs.getProperty("runtime-version"); - } - if (cliArgs.containsKey("external-runtime-path")) { - this.externalRuntimePath = cliArgs.getProperty("external-runtime-path"); - } - if (cliArgs.containsKey(TargetProperty.KEEPALIVE.description)) { - this.keepalive = Boolean.parseBoolean( - cliArgs.getProperty(TargetProperty.KEEPALIVE.description)); - } - if (cliArgs.containsKey(BuildParm.PRINT_STATISTICS.getKey())) { - this.printStatistics = true; - } + if (cliArgs.containsKey("no-compile")) { + this.noCompile = true; + } + if (cliArgs.containsKey("docker")) { + var arg = cliArgs.getProperty("docker"); + if (Boolean.parseBoolean(arg)) { + this.dockerOptions = new DockerOptions(); + } else { + this.dockerOptions = null; + } + // FIXME: this is pretty ad-hoc and does not account for more complex overrides yet. + } + if (cliArgs.containsKey("build-type")) { + this.cmakeBuildType = + (BuildType) UnionType.BUILD_TYPE_UNION.forName(cliArgs.getProperty("build-type")); + } + if (cliArgs.containsKey("logging")) { + this.logLevel = LogLevel.valueOf(cliArgs.getProperty("logging").toUpperCase()); + } + if (cliArgs.containsKey("workers")) { + this.workers = Integer.parseInt(cliArgs.getProperty("workers")); + } + if (cliArgs.containsKey("threading")) { + this.threading = Boolean.parseBoolean(cliArgs.getProperty("threading")); + } + if (cliArgs.containsKey("target-compiler")) { + this.compiler = cliArgs.getProperty("target-compiler"); + } + if (cliArgs.containsKey("tracing")) { + this.tracing = new TracingOptions(); + } + if (cliArgs.containsKey("scheduler")) { + this.schedulerType = SchedulerOption.valueOf(cliArgs.getProperty("scheduler")); + this.setByUser.add(TargetProperty.SCHEDULER); + } + if (cliArgs.containsKey("target-flags")) { + this.compilerFlags.clear(); + if (!cliArgs.getProperty("target-flags").isEmpty()) { + this.compilerFlags.addAll(List.of(cliArgs.getProperty("target-flags").split(" "))); + } + } + if (cliArgs.containsKey("runtime-version")) { + this.runtimeVersion = cliArgs.getProperty("runtime-version"); + } + if (cliArgs.containsKey("external-runtime-path")) { + this.externalRuntimePath = cliArgs.getProperty("external-runtime-path"); + } + if (cliArgs.containsKey(TargetProperty.KEEPALIVE.description)) { + this.keepalive = + Boolean.parseBoolean(cliArgs.getProperty(TargetProperty.KEEPALIVE.description)); } + if (cliArgs.containsKey(BuildParm.PRINT_STATISTICS.getKey())) { + this.printStatistics = true; + } + } - /** - * Keep track of every target property that is explicitly set by the user. - */ - public Set setByUser = new HashSet<>(); + /** Keep track of every target property that is explicitly set by the user. */ + public Set setByUser = new HashSet<>(); - /** - * A list of custom build commands that replace the default build process of - * directly invoking a designated compiler. A common usage of this target - * property is to set the command to build on the basis of a Makefile. - */ - public List buildCommands = new ArrayList<>(); + /** + * A list of custom build commands that replace the default build process of directly invoking a + * designated compiler. A common usage of this target property is to set the command to build on + * the basis of a Makefile. + */ + public List buildCommands = new ArrayList<>(); - /** - * The mode of clock synchronization to be used in federated programs. - * The default is 'initial'. - */ - public ClockSyncMode clockSync = ClockSyncMode.INIT; + /** + * The mode of clock synchronization to be used in federated programs. The default is 'initial'. + */ + public ClockSyncMode clockSync = ClockSyncMode.INIT; - /** - * Clock sync options. - */ - public ClockSyncOptions clockSyncOptions = new ClockSyncOptions(); + /** Clock sync options. */ + public ClockSyncOptions clockSyncOptions = new ClockSyncOptions(); - /** - * Parameter passed to cmake. The default is 'Release'. - */ - public BuildType cmakeBuildType = BuildType.RELEASE; + /** Parameter passed to cmake. The default is 'Release'. */ + public BuildType cmakeBuildType = BuildType.RELEASE; - /** - * Optional additional extensions to include in the generated CMakeLists.txt. - */ - public List cmakeIncludes = new ArrayList<>(); + /** Optional additional extensions to include in the generated CMakeLists.txt. */ + public List cmakeIncludes = new ArrayList<>(); - /** - * The compiler to invoke, unless a build command has been specified. - */ - public String compiler = ""; + /** The compiler to invoke, unless a build command has been specified. */ + public String compiler = ""; - /** - * Additional sources to add to the compile command if appropriate. - */ - public List compileAdditionalSources = new ArrayList<>(); + /** Additional sources to add to the compile command if appropriate. */ + public List compileAdditionalSources = new ArrayList<>(); - /** - * Additional (preprocessor) definitions to add to the compile command if appropriate. - * - * The first string is the definition itself, and the second string is the value to attribute to that definition, if any. - * The second value could be left empty. - */ - public Map compileDefinitions = new HashMap<>(); + /** + * Additional (preprocessor) definitions to add to the compile command if appropriate. + * + *

    The first string is the definition itself, and the second string is the value to attribute + * to that definition, if any. The second value could be left empty. + */ + public Map compileDefinitions = new HashMap<>(); - /** - * Additional libraries to add to the compile command using the "-l" command-line option. - */ - public List compileLibraries = new ArrayList<>(); + /** Additional libraries to add to the compile command using the "-l" command-line option. */ + public List compileLibraries = new ArrayList<>(); - /** - * Flags to pass to the compiler, unless a build command has been specified. - */ - public List compilerFlags = new ArrayList<>(); + /** Flags to pass to the compiler, unless a build command has been specified. */ + public List compilerFlags = new ArrayList<>(); - /** - * The type of coordination used during the execution of a federated program. - * The default is 'centralized'. - */ - public CoordinationType coordination = CoordinationType.CENTRALIZED; + /** + * The type of coordination used during the execution of a federated program. The default is + * 'centralized'. + */ + public CoordinationType coordination = CoordinationType.CENTRALIZED; + + /** Docker options. */ + public DockerOptions dockerOptions = null; - /** - * Docker options. - */ - public DockerOptions dockerOptions = null; + /** Coordination options. */ + public CoordinationOptions coordinationOptions = new CoordinationOptions(); - /** - * Coordination options. - */ - public CoordinationOptions coordinationOptions = new CoordinationOptions(); + /** Link to an external runtime library instead of the default one. */ + public String externalRuntimePath = null; - /** - * Link to an external runtime library instead of the default one. - */ - public String externalRuntimePath = null; + /** + * If true, configure the execution environment such that it does not wait for physical time to + * match logical time. The default is false. + */ + public boolean fastMode = false; - /** - * If true, configure the execution environment such that it does not - * wait for physical time to match logical time. The default is false. - */ - public boolean fastMode = false; + /** List of files to be copied to src-gen. */ + public List files = new ArrayList<>(); - /** - * List of files to be copied to src-gen. - */ - public List files = new ArrayList<>(); + /** + * If true, configure the execution environment to keep executing if there are no more events on + * the event queue. The default is false. + */ + public boolean keepalive = false; - /** - * If true, configure the execution environment to keep executing if there - * are no more events on the event queue. The default is false. - */ - public boolean keepalive = false; + /** The level of logging during execution. The default is INFO. */ + public LogLevel logLevel = LogLevel.INFO; - /** - * The level of logging during execution. The default is INFO. - */ - public LogLevel logLevel = LogLevel.INFO; + /** Flags to pass to the linker, unless a build command has been specified. */ + public String linkerFlags = ""; - /** - * Flags to pass to the linker, unless a build command has been specified. - */ - public String linkerFlags = ""; + /** If true, do not invoke the target compiler or build command. The default is false. */ + public boolean noCompile = false; - /** - * If true, do not invoke the target compiler or build command. - * The default is false. - */ - public boolean noCompile = false; + /** If true, do not perform runtime validation. The default is false. */ + public boolean noRuntimeValidation = false; - /** - * If true, do not perform runtime validation. The default is false. - */ - public boolean noRuntimeValidation = false; + /** + * Set the target platform config. This tells the build system what platform-specific support + * files it needs to incorporate at compile time. + * + *

    This is now a wrapped class to account for overloaded definitions of defining platform + * (either a string or dictionary of values) + */ + public PlatformOptions platformOptions = new PlatformOptions(); - /** - * Set the target platform config. - * This tells the build system what platform-specific support - * files it needs to incorporate at compile time. - * - * This is now a wrapped class to account for overloaded definitions - * of defining platform (either a string or dictionary of values) - */ - public PlatformOptions platformOptions = new PlatformOptions(); + /** If true, instruct the runtime to collect and print execution statistics. */ + public boolean printStatistics = false; - /** - * If true, instruct the runtime to collect and print execution statistics. - */ - public boolean printStatistics = false; + /** List of proto files to be processed by the code generator. */ + public List protoFiles = new ArrayList<>(); - /** - * List of proto files to be processed by the code generator. - */ - public List protoFiles = new ArrayList<>(); + /** If true, generate ROS2 specific code. */ + public boolean ros2 = false; - /** - * If true, generate ROS2 specific code. - */ - public boolean ros2 = false; + /** Additional ROS2 packages that the LF program depends on. */ + public List ros2Dependencies = null; - /** - * Additional ROS2 packages that the LF program depends on. - */ - public List ros2Dependencies = null; + /** The version of the runtime library to be used in the generated target. */ + public String runtimeVersion = null; - /** - * The version of the runtime library to be used in the generated target. - */ - public String runtimeVersion = null; + /** Whether all reactors are to be generated into a single target language file. */ + public boolean singleFileProject = false; + + /** What runtime scheduler to use. */ + public SchedulerOption schedulerType = SchedulerOption.getDefault(); + + /** + * The number of worker threads to deploy. The default is zero, which indicates that the runtime + * is allowed to freely choose the number of workers. + */ + public int workers = 0; + + /** Indicate whether HMAC authentication is used. */ + public boolean auth = false; + + /** Indicate whether the runtime should use multithreaded execution. */ + public boolean threading = true; + + /** The timeout to be observed during execution of the program. */ + public TimeValue timeout; + + /** If non-null, configure the runtime environment to perform tracing. The default is null. */ + public TracingOptions tracing = null; + + /** + * If true, the resulting binary will output a graph visualizing all reaction dependencies. + * + *

    This option is currently only used for C++ and Rust. This export function is a valuable tool + * for debugging LF programs and helps to understand the dependencies inferred by the runtime. + */ + public boolean exportDependencyGraph = false; - /** Whether all reactors are to be generated into a single target language file. */ - public boolean singleFileProject = false; + /** + * If true, the resulting binary will output a yaml file describing the whole reactor structure of + * the program. + * + *

    This option is currently only used for C++. This export function is a valuable tool for + * debugging LF programs and performing external analysis. + */ + public boolean exportToYaml = false; - /** What runtime scheduler to use. */ - public SchedulerOption schedulerType = SchedulerOption.getDefault(); + /** Rust-specific configuration. */ + public final RustTargetConfig rust = + new RustTargetConfig(); // FIXME: https://issue.lf-lang.org/1558 + + /** Path to a C file used by the Python target to setup federated execution. */ + public String fedSetupPreamble = null; // FIXME: https://issue.lf-lang.org/1558 + + /** Settings related to clock synchronization. */ + public static class ClockSyncOptions { /** - * The number of worker threads to deploy. The default is zero, which indicates that - * the runtime is allowed to freely choose the number of workers. + * Dampen the adjustments to the clock synchronization offset by this rate. The default is 10. */ - public int workers = 0; + public int attenuation = 10; /** - * Indicate whether HMAC authentication is used. + * Whether to collect statistics while performing clock synchronization. This setting is only + * considered when clock synchronization has been activated. The default is true. */ - public boolean auth = false; + public boolean collectStats = true; + + /** Enable clock synchronization for federates on the same machine. Default is false. */ + public boolean localFederatesOn = false; /** - * Indicate whether the runtime should use multithreaded execution. + * Interval at which clock synchronization is initiated by the RTI (will be passed to it as an + * argument on the command-line). The default is 5 milliseconds. */ - public boolean threading = true; + public TimeValue period = new TimeValue(5, TimeUnit.MILLI); /** - * The timeout to be observed during execution of the program. + * Indicate the number of exchanges to be had per each clock synchronization round. See + * /lib/core/federated/clock-sync.h for more details. The default is 10. */ - public TimeValue timeout; + public int trials = 10; /** - * If non-null, configure the runtime environment to perform tracing. - * The default is null. + * Used to create an artificial clock synchronization error for the purpose of testing. The + * default is null. */ - public TracingOptions tracing = null; + public TimeValue testOffset; + } + /** Settings related to coordination of federated execution. */ + public static class CoordinationOptions { /** - * If true, the resulting binary will output a graph visualizing all reaction dependencies. - * - * This option is currently only used for C++ and Rust. This export function is a valuable tool - * for debugging LF programs and helps to understand the dependencies inferred by the runtime. + * For centralized coordination, if a federate has a physical action that can trigger an output, + * directly or indirectly, then it will send NET (next event tag) messages to the RTI + * periodically as its physical clock advances. This option sets the amount of time to wait + * between sending such messages. Increasing this value results in downstream federates that lag + * further behind physical time (if the "after" delays are insufficient). The default is null, + * which means it is up the implementation to choose an interval. */ - public boolean exportDependencyGraph = false; - + public TimeValue advance_message_interval = null; + } + /** Settings related to Docker options. */ + public static class DockerOptions { /** - * If true, the resulting binary will output a yaml file describing the whole reactor structure - * of the program. - * - * This option is currently only used for C++. This export function is a valuable tool for debugging - * LF programs and performing external analysis. + * The base image and tag from which to build the Docker image. The default is "alpine:latest". */ - public boolean exportToYaml = false; + public String from = "alpine:latest"; - /** Rust-specific configuration. */ - public final RustTargetConfig rust = new RustTargetConfig(); // FIXME: https://issue.lf-lang.org/1558 + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + DockerOptions that = (DockerOptions) o; + return from.equals(that.from); + } + } - /** Path to a C file used by the Python target to setup federated execution. */ - public String fedSetupPreamble = null; // FIXME: https://issue.lf-lang.org/1558 + /** Settings related to Platform Options. */ + public static class PlatformOptions { /** - * Settings related to clock synchronization. + * The base platform we build our LF Files on. Should be set to AUTO by default unless + * developing for specific OS/Embedded Platform */ - public static class ClockSyncOptions { - - /** - * Dampen the adjustments to the clock synchronization offset by this rate. - * The default is 10. - */ - public int attenuation = 10; - - /** - * Whether to collect statistics while performing clock synchronization. - * This setting is only considered when clock synchronization has been activated. - * The default is true. - */ - public boolean collectStats = true; - - /** - * Enable clock synchronization for federates on the same machine. - * Default is false. - */ - public boolean localFederatesOn = false; - - - /** - * Interval at which clock synchronization is initiated by the RTI (will be passed - * to it as an argument on the command-line). - * The default is 5 milliseconds. - */ - public TimeValue period = new TimeValue(5, TimeUnit.MILLI); - - /** - * Indicate the number of exchanges to be had per each clock synchronization round. - * See /lib/core/federated/clock-sync.h for more details. - * The default is 10. - */ - public int trials = 10; - - /** - * Used to create an artificial clock synchronization error for the purpose of testing. - * The default is null. - */ - public TimeValue testOffset; - } + public Platform platform = Platform.AUTO; /** - * Settings related to coordination of federated execution. + * The string value used to determine what type of embedded board we work with and can be used + * to simplify the build process. For example, when we want to flash to an Arduino Nano 33 BLE + * board, we can use the string arduino:mbed_nano:nano33ble */ - public static class CoordinationOptions { - - /** - * For centralized coordination, if a federate has a physical action that can trigger - * an output, directly or indirectly, then it will send NET (next event tag) messages - * to the RTI periodically as its physical clock advances. This option sets the amount - * of time to wait between sending such messages. Increasing this value results in - * downstream federates that lag further behind physical time (if the "after" delays - * are insufficient). - * The default is null, which means it is up the implementation to choose an interval. - */ - public TimeValue advance_message_interval = null; - } + public String board = null; /** - * Settings related to Docker options. + * The string value used to determine the port on which to flash the compiled program (i.e. + * /dev/cu.usbmodem21301) */ - public static class DockerOptions { - /** - * The base image and tag from which to build the Docker image. The default is "alpine:latest". - */ - public String from = "alpine:latest"; - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - DockerOptions that = (DockerOptions) o; - return from.equals(that.from); - } - } + public String port = null; + + /** + * The baud rate used as a parameter to certain embedded platforms. 9600 is a standard rate + * amongst systems like Arduino, so it's the default value. + */ + public int baudRate = 9600; /** - * Settings related to Platform Options. + * The boolean statement used to determine whether we should automatically attempt to flash once + * we compile. This may require the use of board and port values depending on the infrastructure + * you use to flash the boards. */ - public static class PlatformOptions { - - /** - * The base platform we build our LF Files on. Should be set to AUTO by default unless developing for specific OS/Embedded Platform - */ - public Platform platform = Platform.AUTO; - - /** - * The string value used to determine what type of embedded board we work with and can be used to simplify the build process. For example, - * when we want to flash to an Arduino Nano 33 BLE board, we can use the string arduino:mbed_nano:nano33ble - */ - public String board = null; - - - /** - * The string value used to determine the port on which to flash the compiled program (i.e. /dev/cu.usbmodem21301) - */ - public String port = null; - - /** - * The baud rate used as a parameter to certain embedded platforms. 9600 is a standard rate amongst systems like Arduino, so it's the default value. - */ - public int baudRate = 9600; - - /** - * The boolean statement used to determine whether we should automatically attempt to flash once we compile. This may require the use of board and - * port values depending on the infrastructure you use to flash the boards. - */ - public boolean flash = false; - } + public boolean flash = false; + } + /** Settings related to tracing options. */ + public static class TracingOptions { /** - * Settings related to tracing options. + * The name to use as the root of the trace file produced. This defaults to the name of the .lf + * file. */ - public static class TracingOptions { - /** - * The name to use as the root of the trace file produced. - * This defaults to the name of the .lf file. - */ - public String traceFileName = null; - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - TracingOptions that = (TracingOptions) o; - return Objects.equals(traceFileName, that.traceFileName); // traceFileName may be null - } + public String traceFileName = null; + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + TracingOptions that = (TracingOptions) o; + return Objects.equals(traceFileName, that.traceFileName); // traceFileName may be null } + } } diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index fe5c7dd0b2..b3abf815a3 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -1,30 +1,31 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang; +import com.google.common.collect.ImmutableList; import java.io.IOException; import java.nio.file.Path; import java.util.Arrays; @@ -33,7 +34,6 @@ import java.util.Optional; import java.util.function.Predicate; import java.util.stream.Collectors; - import org.eclipse.xtext.util.RuntimeIOException; import org.lflang.TargetConfig.DockerOptions; import org.lflang.TargetConfig.PlatformOptions; @@ -52,1819 +52,1761 @@ import org.lflang.util.StringUtil; import org.lflang.validation.LFValidator; -import com.google.common.collect.ImmutableList; - /** - * A target properties along with a type and a list of supporting targets - * that supports it, as well as a function for configuration updates. + * A target properties along with a type and a list of supporting targets that supports it, as well + * as a function for configuration updates. * * @author Marten Lohstroh */ public enum TargetProperty { - /** - * Directive to allow including OpenSSL libraries and process HMAC authentication. - */ - AUTH("auth", PrimitiveType.BOOLEAN, - Arrays.asList(Target.C, Target.CCPP), - (config) -> ASTUtils.toElement(config.auth), - (config, value, err) -> { - config.auth = ASTUtils.toBoolean(value); - }), - /** - * Directive to let the generator use the custom build command. - */ - BUILD("build", UnionType.STRING_OR_STRING_ARRAY, - Arrays.asList(Target.C, Target.CCPP), - (config) -> ASTUtils.toElement(config.buildCommands), - (config, value, err) -> { - config.buildCommands = ASTUtils.elementToListOfStrings(value); - }), - - /** - * Directive to specify the target build type such as 'Release' or 'Debug'. - * This is also used in the Rust target to select a Cargo profile. - */ - BUILD_TYPE("build-type", UnionType.BUILD_TYPE_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Rust), - (config) -> ASTUtils.toElement(config.cmakeBuildType.toString()), - (config, value, err) -> { - config.cmakeBuildType = (BuildType) UnionType.BUILD_TYPE_UNION - .forName(ASTUtils.elementToSingleString(value)); - // set it there too, because the default is different. - config.rust.setBuildType(config.cmakeBuildType); - }), - - /** - * Directive to let the federate execution handle clock synchronization in software. - */ - CLOCK_SYNC("clock-sync", UnionType.CLOCK_SYNC_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.clockSync.toString()), - (config, value, err) -> { - config.clockSync = (ClockSyncMode) UnionType.CLOCK_SYNC_UNION - .forName(ASTUtils.elementToSingleString(value)); - }), - /** - * Key-value pairs giving options for clock synchronization. - */ - CLOCK_SYNC_OPTIONS("clock-sync-options", - DictionaryType.CLOCK_SYNC_OPTION_DICT, Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (ClockSyncOption opt : ClockSyncOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case ATTENUATION: - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.attenuation)); - break; - case COLLECT_STATS: - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.collectStats)); - break; - case LOCAL_FEDERATES_ON: - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.localFederatesOn)); - break; - case PERIOD: - if (config.clockSyncOptions.period == null) continue; // don't set if null - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.period)); - break; - case TEST_OFFSET: - if (config.clockSyncOptions.testOffset == null) continue; // don't set if null - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.testOffset)); - break; - case TRIALS: - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.trials)); - break; - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - // kvp will never be empty - return e; - }, - (config, value, err) -> { - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - ClockSyncOption option = (ClockSyncOption) DictionaryType.CLOCK_SYNC_OPTION_DICT - .forName(entry.getName()); - switch (option) { - case ATTENUATION: - config.clockSyncOptions.attenuation = ASTUtils - .toInteger(entry.getValue()); - break; - case COLLECT_STATS: - config.clockSyncOptions.collectStats = ASTUtils - .toBoolean(entry.getValue()); - break; - case LOCAL_FEDERATES_ON: - config.clockSyncOptions.localFederatesOn = ASTUtils - .toBoolean(entry.getValue()); - break; - case PERIOD: - config.clockSyncOptions.period = ASTUtils - .toTimeValue(entry.getValue()); - break; - case TEST_OFFSET: - config.clockSyncOptions.testOffset = ASTUtils - .toTimeValue(entry.getValue()); - break; - case TRIALS: - config.clockSyncOptions.trials = ASTUtils - .toInteger(entry.getValue()); - break; - default: - break; - } - } - }), - - /** - * Directive to specify a cmake to be included by the generated build - * systems. - * - * This gives full control over the C/C++ build as any cmake parameters - * can be adjusted in the included file. - */ - CMAKE_INCLUDE("cmake-include", UnionType.FILE_OR_FILE_ARRAY, - Arrays.asList(Target.CPP, Target.C, Target.CCPP), - (config) -> ASTUtils.toElement(config.cmakeIncludes), - (config, value, err) -> { - config.cmakeIncludes = ASTUtils.elementToListOfStrings(value); - }, - // FIXME: This merging of lists is potentially dangerous since - // the incoming list of cmake-includes can belong to a .lf file that is - // located in a different location, and keeping just filename - // strings like this without absolute paths is incorrect. - (config, value, err) -> { - config.cmakeIncludes.addAll(ASTUtils.elementToListOfStrings(value)); - }), - /** - * Directive to specify the target compiler. - */ - COMPILER("compiler", PrimitiveType.STRING, Target.ALL, - (config) -> ASTUtils.toElement(config.compiler), - (config, value, err) -> { - config.compiler = ASTUtils.elementToSingleString(value); - }), - - /** - * Directive to specify compile-time definitions. - */ - COMPILE_DEFINITIONS("compile-definitions", StringDictionaryType.COMPILE_DEFINITION, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.compileDefinitions), - (config, value, err) -> { - config.compileDefinitions = ASTUtils.elementToStringMaps(value); - }), - - /** - * Directive to generate a Dockerfile. This is either a boolean, - * true or false, or a dictionary of options. - */ - DOCKER("docker", UnionType.DOCKER_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS), - (config) -> { - if (config.dockerOptions == null) { - return null; - } else if(config.dockerOptions.equals(new DockerOptions())) { - // default configuration - return ASTUtils.toElement(true); - } else { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (DockerOption opt : DockerOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case FROM: - if (config.dockerOptions.from == null) continue; - pair.setValue(ASTUtils.toElement(config.dockerOptions.from)); - break; - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - if (kvp.getPairs().isEmpty()) return null; - return e; - } - }, - (config, value, err) -> setDockerProperty(config, value), - (config, value, err) -> setDockerProperty(config, value)), - - /** - * Directive for specifying a path to an external runtime to be used for the - * compiled binary. - */ - EXTERNAL_RUNTIME_PATH("external-runtime-path", PrimitiveType.STRING, - List.of(Target.CPP), - (config) -> ASTUtils.toElement(config.externalRuntimePath), - (config, value, err) -> { - config.externalRuntimePath = ASTUtils.elementToSingleString(value); - }), - - /** - * Directive to let the execution engine allow logical time to elapse - * faster than physical time. - */ - FAST("fast", PrimitiveType.BOOLEAN, Target.ALL, - (config) -> ASTUtils.toElement(config.fastMode), - (config, value, err) -> { - config.fastMode = ASTUtils.toBoolean(value); - }), - - /** - * Directive to stage particular files on the class path to be - * processed by the code generator. - */ - FILES("files", UnionType.FILE_OR_FILE_ARRAY, List.of(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.files), - (config, value, err) -> { - config.files = ASTUtils.elementToListOfStrings(value); - }, - // FIXME: This merging of lists is potentially dangerous since - // the incoming list of files can belong to a .lf file that is - // located in a different location, and keeping just filename - // strings like this without absolute paths is incorrect. - (config, value, err) -> { - config.files.addAll(ASTUtils.elementToListOfStrings(value)); - }), - - /** - * Flags to be passed on to the target compiler. - */ - FLAGS("flags", UnionType.STRING_OR_STRING_ARRAY, - Arrays.asList(Target.C, Target.CCPP), - (config) -> ASTUtils.toElement(config.compilerFlags), - (config, value, err) -> { - config.compilerFlags = ASTUtils.elementToListOfStrings(value); - }), - - /** - * Directive to specify the coordination mode - */ - COORDINATION("coordination", UnionType.COORDINATION_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.coordination.toString()), - (config, value, err) -> { - config.coordination = (CoordinationType) UnionType.COORDINATION_UNION - .forName(ASTUtils.elementToSingleString(value)); - }, - (config, value, err) -> { - config.coordination = (CoordinationType) UnionType.COORDINATION_UNION - .forName(ASTUtils.elementToSingleString(value)); - }), - - /** - * Key-value pairs giving options for clock synchronization. - */ - COORDINATION_OPTIONS("coordination-options", - DictionaryType.COORDINATION_OPTION_DICT, Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS), - (config) -> { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (CoordinationOption opt : CoordinationOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case ADVANCE_MESSAGE_INTERVAL: - if (config.coordinationOptions.advance_message_interval == null) continue; - pair.setValue(ASTUtils.toElement(config.coordinationOptions.advance_message_interval)); - break; - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - if (kvp.getPairs().isEmpty()) return null; - return e; - }, - (config, value, err) -> { - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - CoordinationOption option = (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT - .forName(entry.getName()); - switch (option) { - case ADVANCE_MESSAGE_INTERVAL: - config.coordinationOptions.advance_message_interval = ASTUtils - .toTimeValue(entry.getValue()); - break; - default: - break; - } - } - }, - (config, value, err) -> { - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - CoordinationOption option = (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT - .forName(entry.getName()); - switch (option) { - case ADVANCE_MESSAGE_INTERVAL: - config.coordinationOptions.advance_message_interval = ASTUtils - .toTimeValue(entry.getValue()); - break; - default: - break; - } - } - }), - - /** - * Directive to let the execution engine remain active also if there - * are no more events in the event queue. - */ - KEEPALIVE("keepalive", PrimitiveType.BOOLEAN, Target.ALL, - (config) -> ASTUtils.toElement(config.keepalive), - (config, value, err) -> { - config.keepalive = ASTUtils.toBoolean(value); - }), - - /** - * Directive to specify the grain at which to report log messages during execution. - */ - LOGGING("logging", UnionType.LOGGING_UNION, Target.ALL, - (config) -> ASTUtils.toElement(config.logLevel.toString()), - (config, value, err) -> { - config.logLevel = (LogLevel) UnionType.LOGGING_UNION - .forName(ASTUtils.elementToSingleString(value)); - }), - - /** - * Directive to not invoke the target compiler. - */ - NO_COMPILE("no-compile", PrimitiveType.BOOLEAN, - Arrays.asList(Target.C, Target.CPP, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.noCompile), - (config, value, err) -> { - config.noCompile = ASTUtils.toBoolean(value); - }), - - /** - * Directive to disable validation of reactor rules at runtime. - */ - NO_RUNTIME_VALIDATION("no-runtime-validation", PrimitiveType.BOOLEAN, - Arrays.asList(Target.CPP), - (config) -> ASTUtils.toElement(config.noRuntimeValidation), - (config, value, err) -> { - config.noRuntimeValidation = ASTUtils.toBoolean(value); - }), - - /** - * Directive to specify the platform for cross code generation. This is either a string of the platform - * or a dictionary of options that includes the string name. - */ - PLATFORM("platform", UnionType.PLATFORM_STRING_OR_DICTIONARY, Target.ALL, - (config) -> { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (PlatformOption opt : PlatformOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case NAME: - pair.setValue(ASTUtils.toElement(config.platformOptions.platform.toString())); - break; - case BAUDRATE: - pair.setValue(ASTUtils.toElement(config.platformOptions.baudRate)); - break; - case BOARD: - pair.setValue(ASTUtils.toElement(config.platformOptions.board)); - break; - case FLASH: - pair.setValue(ASTUtils.toElement(config.platformOptions.flash)); - break; - case PORT: - pair.setValue(ASTUtils.toElement(config.platformOptions.port)); - break; - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - if (kvp.getPairs().isEmpty()) return null; - return e; - }, - (config, value, err) -> { - if (value.getLiteral() != null) { - config.platformOptions = new PlatformOptions(); - config.platformOptions.platform = (Platform) UnionType.PLATFORM_UNION - .forName(ASTUtils.elementToSingleString(value)); - } else { - config.platformOptions= new PlatformOptions(); - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - PlatformOption option = (PlatformOption) DictionaryType.PLATFORM_DICT - .forName(entry.getName()); - switch (option) { - case NAME: - Platform p = (Platform) UnionType.PLATFORM_UNION - .forName(ASTUtils.elementToSingleString(entry.getValue())); - if(p == null) { - String s = "Unidentified Platform Type, LF supports the following platform types: " + Arrays.asList(Platform.values()).toString(); - err.reportError(s); - throw new AssertionError(s); - } - config.platformOptions.platform = p; - break; - case BAUDRATE: - config.platformOptions.baudRate = ASTUtils.toInteger(entry.getValue()); - break; - case BOARD: - config.platformOptions.board = ASTUtils.elementToSingleString(entry.getValue()); - break; - case FLASH: - config.platformOptions.flash = ASTUtils.toBoolean(entry.getValue()); - break; - case PORT: - config.platformOptions.port = ASTUtils.elementToSingleString(entry.getValue()); - break; - default: - break; - } - } - } - }), - - /** - * Directive to instruct the runtime to collect and print execution statistics. - */ - PRINT_STATISTICS("print-statistics", PrimitiveType.BOOLEAN, - Arrays.asList(Target.CPP), - (config) -> ASTUtils.toElement(config.printStatistics), - (config, value, err) -> { - config.printStatistics = ASTUtils.toBoolean(value); - }), - - /** - * Directive for specifying .proto files that need to be compiled and their - * code included in the sources. - */ - PROTOBUFS("protobufs", UnionType.FILE_OR_FILE_ARRAY, - Arrays.asList(Target.C, Target.CCPP, Target.TS, Target.Python), - (config) -> ASTUtils.toElement(config.protoFiles), - (config, value, err) -> { - config.protoFiles = ASTUtils.elementToListOfStrings(value); - }), - - - /** - * Directive to specify that ROS2 specific code is generated, - */ - ROS2("ros2", PrimitiveType.BOOLEAN, - List.of(Target.CPP), - (config) -> ASTUtils.toElement(config.ros2), - (config, value, err) -> { - config.ros2 = ASTUtils.toBoolean(value); - }), - - /** - * Directive to specify additional ROS2 packages that this LF program depends on. - */ - ROS2_DEPENDENCIES("ros2-dependencies", ArrayType.STRING_ARRAY, - List.of(Target.CPP), - (config) -> ASTUtils.toElement(config.ros2Dependencies), - (config, value, err) -> { - config.ros2Dependencies = ASTUtils.elementToListOfStrings(value); - }), - - /** - * Directive for specifying a specific version of the reactor runtime library. - */ - RUNTIME_VERSION("runtime-version", PrimitiveType.STRING, - Arrays.asList(Target.CPP), - (config) -> ASTUtils.toElement(config.runtimeVersion), - (config, value, err) -> { - config.runtimeVersion = ASTUtils.elementToSingleString(value); - }), - - - /** - * Directive for specifying a specific runtime scheduler, if supported. - */ - SCHEDULER("scheduler", UnionType.SCHEDULER_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.schedulerType.toString()), - (config, value, err) -> { - config.schedulerType = (SchedulerOption) UnionType.SCHEDULER_UNION - .forName(ASTUtils.elementToSingleString(value)); - }), - - /** - * Directive to specify that all code is generated in a single file. - */ - SINGLE_FILE_PROJECT("single-file-project", PrimitiveType.BOOLEAN, - List.of(Target.Rust), - (config) -> ASTUtils.toElement(config.singleFileProject), - (config, value, err) -> { - config.singleFileProject = ASTUtils.toBoolean(value); - }), - - /** - * Directive to indicate whether the runtime should use multi-threading. - */ - THREADING("threading", PrimitiveType.BOOLEAN, - List.of(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.threading), - (config, value, err) -> { - config.threading = ASTUtils.toBoolean(value); - }), - - /** - * Directive to specify the number of worker threads used by the runtime. - */ - WORKERS("workers", PrimitiveType.NON_NEGATIVE_INTEGER, - List.of(Target.C, Target.CCPP, Target.Python, Target.CPP, Target.Rust), - (config) -> ASTUtils.toElement(config.workers), - (config, value, err) -> { - config.workers = ASTUtils.toInteger(value); - }), - - /** - * Directive to specify the execution timeout. - */ - TIMEOUT("timeout", PrimitiveType.TIME_VALUE, Target.ALL, - (config) -> ASTUtils.toElement(config.timeout), - (config, value, err) -> { - config.timeout = ASTUtils.toTimeValue(value); - }, - (config, value, err) -> { - config.timeout = ASTUtils.toTimeValue(value); - }), - - /** - * Directive to enable tracing. - */ - TRACING("tracing", UnionType.TRACING_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Python), - (config) -> { - if (config.tracing == null) { - return null; - } else if (config.tracing.equals(new TracingOptions())) { - // default values - return ASTUtils.toElement(true); - } else { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (TracingOption opt : TracingOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case TRACE_FILE_NAME: - if (config.tracing.traceFileName == null) continue; - pair.setValue(ASTUtils.toElement(config.tracing.traceFileName)); - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - if (kvp.getPairs().isEmpty()) return null; - return e; - } - }, - (config, value, err) -> { - if (value.getLiteral() != null) { - if (ASTUtils.toBoolean(value)) { - config.tracing = new TracingOptions(); - } else { - config.tracing = null; - } - } else { - config.tracing = new TracingOptions(); - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - TracingOption option = (TracingOption) DictionaryType.TRACING_DICT - .forName(entry.getName()); - switch (option) { - case TRACE_FILE_NAME: - config.tracing.traceFileName = ASTUtils.elementToSingleString(entry.getValue()); - break; - default: - break; - } - } - } - }), - - /** - * Directive to let the runtime export its internal dependency graph. - * - * This is a debugging feature and currently only used for C++ and Rust programs. - */ - EXPORT_DEPENDENCY_GRAPH("export-dependency-graph", PrimitiveType.BOOLEAN, - List.of(Target.CPP, Target.Rust), - (config) -> ASTUtils.toElement(config.exportDependencyGraph), - (config, value, err) -> { - config.exportDependencyGraph = ASTUtils.toBoolean(value); - }), - - /** - * Directive to let the runtime export the program structure to a yaml file. - * - * This is a debugging feature and currently only used for C++ programs. - */ - EXPORT_TO_YAML("export-to-yaml", PrimitiveType.BOOLEAN, - List.of(Target.CPP), - (config) -> ASTUtils.toElement(config.exportToYaml), - (config, value, err) -> { - config.exportToYaml = ASTUtils.toBoolean(value); - }), - - /** - * List of module files to link into the crate as top-level. - * For instance, a {@code target Rust { rust-modules: [ "foo.rs" ] }} - * will cause the file to be copied into the generated project, - * and the generated {@code main.rs} will include it with a {@code mod foo;}. - * If one of the paths is a directory, it must contain a {@code mod.rs} - * file, and all its contents are copied. - */ - RUST_INCLUDE("rust-include", - UnionType.FILE_OR_FILE_ARRAY, - List.of(Target.Rust), - (config) -> { - // do not check paths here, and simply copy the absolute path over - List paths = config.rust.getRustTopLevelModules(); - if (paths.isEmpty()) return null; - else if (paths.size() == 1) { - return ASTUtils.toElement(paths.get(0).toString()); - } else { - Element e = LfFactory.eINSTANCE.createElement(); - Array arr = LfFactory.eINSTANCE.createArray(); - for (Path p : paths) { - arr.getElements().add(ASTUtils.toElement(p.toString())); - } - e.setArray(arr); - return e; - } - }, - (config, value, err) -> { - Path referencePath; - try { - referencePath = FileUtil.toPath(value.eResource().getURI()).toAbsolutePath(); - } catch (IOException e) { - err.reportError(value, "Invalid path? " + e.getMessage()); - throw new RuntimeIOException(e); - } - - // we'll resolve relative paths to check that the files - // are as expected. - - if (value.getLiteral() != null) { - Path resolved = referencePath.resolveSibling(StringUtil.removeQuotes(value.getLiteral())); - - config.rust.addAndCheckTopLevelModule(resolved, value, err); - } else if (value.getArray() != null) { - for (Element element : value.getArray().getElements()) { - String literal = StringUtil.removeQuotes(element.getLiteral()); - Path resolved = referencePath.resolveSibling(literal); - config.rust.addAndCheckTopLevelModule(resolved, element, err); - } - } - }), - - /** - * Directive for specifying Cargo features of the generated - * program to enable. - */ - CARGO_FEATURES("cargo-features", ArrayType.STRING_ARRAY, - List.of(Target.Rust), - (config) -> ASTUtils.toElement(config.rust.getCargoFeatures()), - (config, value, err) -> { - config.rust.setCargoFeatures(ASTUtils.elementToListOfStrings(value)); - }), - - /** - * Dependency specifications for Cargo. This property looks like this: - * 

    {@code
-     * cargo-dependencies: {
-     *    // Name-of-the-crate: "version"
-     *    rand: "0.8",
-     *    // Equivalent to using an explicit map:
-     *    rand: {
-     *      version: "0.8"
-     *    },
-     *    // The map allows specifying more details
-     *    rand: {
-     *      // A path to a local unpublished crate.
-     *      // Note 'path' is mutually exclusive with 'version'.
-     *      path: "/home/me/Git/local-rand-clone"
-     *    },
-     *    rand: {
-     *      version: "0.8",
-     *      // you can specify cargo features
-     *      features: ["some-cargo-feature",]
-     *    }
-     * }
-     * }
    - */ - CARGO_DEPENDENCIES("cargo-dependencies", - CargoDependenciesPropertyType.INSTANCE, - List.of(Target.Rust), - (config) -> { - var deps = config.rust.getCargoDependencies(); - if (deps.size() == 0) return null; - else { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (var ent : deps.entrySet()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(ent.getKey()); - pair.setValue(CargoDependencySpec.extractSpec(ent.getValue())); - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - return e; - } - }, - (config, value, err) -> { - config.rust.setCargoDependencies(CargoDependencySpec.parseAll(value)); - }), - - /** - * Directs the C or Python target to include the associated C file used for - * setting up federated execution before processing the first tag. - */ - FED_SETUP("_fed_setup", PrimitiveType.FILE, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.fedSetupPreamble), - (config, value, err) -> - config.fedSetupPreamble = StringUtil.removeQuotes(ASTUtils.elementToSingleString(value)) - ) - ; - - /** - * Update {@code config}.dockerOptions based on value. - */ - private static void setDockerProperty(TargetConfig config, Element value) { - if (value.getLiteral() != null) { - if (ASTUtils.toBoolean(value)) { - config.dockerOptions = new DockerOptions(); - } else { - config.dockerOptions = null; + /** Directive to allow including OpenSSL libraries and process HMAC authentication. */ + AUTH( + "auth", + PrimitiveType.BOOLEAN, + Arrays.asList(Target.C, Target.CCPP), + (config) -> ASTUtils.toElement(config.auth), + (config, value, err) -> { + config.auth = ASTUtils.toBoolean(value); + }), + /** Directive to let the generator use the custom build command. */ + BUILD( + "build", + UnionType.STRING_OR_STRING_ARRAY, + Arrays.asList(Target.C, Target.CCPP), + (config) -> ASTUtils.toElement(config.buildCommands), + (config, value, err) -> { + config.buildCommands = ASTUtils.elementToListOfStrings(value); + }), + + /** + * Directive to specify the target build type such as 'Release' or 'Debug'. This is also used in + * the Rust target to select a Cargo profile. + */ + BUILD_TYPE( + "build-type", + UnionType.BUILD_TYPE_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Rust), + (config) -> ASTUtils.toElement(config.cmakeBuildType.toString()), + (config, value, err) -> { + config.cmakeBuildType = + (BuildType) UnionType.BUILD_TYPE_UNION.forName(ASTUtils.elementToSingleString(value)); + // set it there too, because the default is different. + config.rust.setBuildType(config.cmakeBuildType); + }), + + /** Directive to let the federate execution handle clock synchronization in software. */ + CLOCK_SYNC( + "clock-sync", + UnionType.CLOCK_SYNC_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.clockSync.toString()), + (config, value, err) -> { + config.clockSync = + (ClockSyncMode) + UnionType.CLOCK_SYNC_UNION.forName(ASTUtils.elementToSingleString(value)); + }), + /** Key-value pairs giving options for clock synchronization. */ + CLOCK_SYNC_OPTIONS( + "clock-sync-options", + DictionaryType.CLOCK_SYNC_OPTION_DICT, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (ClockSyncOption opt : ClockSyncOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case ATTENUATION: + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.attenuation)); + break; + case COLLECT_STATS: + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.collectStats)); + break; + case LOCAL_FEDERATES_ON: + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.localFederatesOn)); + break; + case PERIOD: + if (config.clockSyncOptions.period == null) continue; // don't set if null + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.period)); + break; + case TEST_OFFSET: + if (config.clockSyncOptions.testOffset == null) continue; // don't set if null + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.testOffset)); + break; + case TRIALS: + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.trials)); + break; + } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + // kvp will never be empty + return e; + }, + (config, value, err) -> { + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + ClockSyncOption option = + (ClockSyncOption) DictionaryType.CLOCK_SYNC_OPTION_DICT.forName(entry.getName()); + switch (option) { + case ATTENUATION: + config.clockSyncOptions.attenuation = ASTUtils.toInteger(entry.getValue()); + break; + case COLLECT_STATS: + config.clockSyncOptions.collectStats = ASTUtils.toBoolean(entry.getValue()); + break; + case LOCAL_FEDERATES_ON: + config.clockSyncOptions.localFederatesOn = ASTUtils.toBoolean(entry.getValue()); + break; + case PERIOD: + config.clockSyncOptions.period = ASTUtils.toTimeValue(entry.getValue()); + break; + case TEST_OFFSET: + config.clockSyncOptions.testOffset = ASTUtils.toTimeValue(entry.getValue()); + break; + case TRIALS: + config.clockSyncOptions.trials = ASTUtils.toInteger(entry.getValue()); + break; + default: + break; + } + } + }), + + /** + * Directive to specify a cmake to be included by the generated build systems. + * + *

    This gives full control over the C/C++ build as any cmake parameters can be adjusted in the + * included file. + */ + CMAKE_INCLUDE( + "cmake-include", + UnionType.FILE_OR_FILE_ARRAY, + Arrays.asList(Target.CPP, Target.C, Target.CCPP), + (config) -> ASTUtils.toElement(config.cmakeIncludes), + (config, value, err) -> { + config.cmakeIncludes = ASTUtils.elementToListOfStrings(value); + }, + // FIXME: This merging of lists is potentially dangerous since + // the incoming list of cmake-includes can belong to a .lf file that is + // located in a different location, and keeping just filename + // strings like this without absolute paths is incorrect. + (config, value, err) -> { + config.cmakeIncludes.addAll(ASTUtils.elementToListOfStrings(value)); + }), + /** Directive to specify the target compiler. */ + COMPILER( + "compiler", + PrimitiveType.STRING, + Target.ALL, + (config) -> ASTUtils.toElement(config.compiler), + (config, value, err) -> { + config.compiler = ASTUtils.elementToSingleString(value); + }), + + /** Directive to specify compile-time definitions. */ + COMPILE_DEFINITIONS( + "compile-definitions", + StringDictionaryType.COMPILE_DEFINITION, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.compileDefinitions), + (config, value, err) -> { + config.compileDefinitions = ASTUtils.elementToStringMaps(value); + }), + + /** + * Directive to generate a Dockerfile. This is either a boolean, true or false, or a dictionary of + * options. + */ + DOCKER( + "docker", + UnionType.DOCKER_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS), + (config) -> { + if (config.dockerOptions == null) { + return null; + } else if (config.dockerOptions.equals(new DockerOptions())) { + // default configuration + return ASTUtils.toElement(true); + } else { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (DockerOption opt : DockerOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case FROM: + if (config.dockerOptions.from == null) continue; + pair.setValue(ASTUtils.toElement(config.dockerOptions.from)); + break; } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + if (kvp.getPairs().isEmpty()) return null; + return e; + } + }, + (config, value, err) -> setDockerProperty(config, value), + (config, value, err) -> setDockerProperty(config, value)), + + /** Directive for specifying a path to an external runtime to be used for the compiled binary. */ + EXTERNAL_RUNTIME_PATH( + "external-runtime-path", + PrimitiveType.STRING, + List.of(Target.CPP), + (config) -> ASTUtils.toElement(config.externalRuntimePath), + (config, value, err) -> { + config.externalRuntimePath = ASTUtils.elementToSingleString(value); + }), + + /** + * Directive to let the execution engine allow logical time to elapse faster than physical time. + */ + FAST( + "fast", + PrimitiveType.BOOLEAN, + Target.ALL, + (config) -> ASTUtils.toElement(config.fastMode), + (config, value, err) -> { + config.fastMode = ASTUtils.toBoolean(value); + }), + + /** + * Directive to stage particular files on the class path to be processed by the code generator. + */ + FILES( + "files", + UnionType.FILE_OR_FILE_ARRAY, + List.of(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.files), + (config, value, err) -> { + config.files = ASTUtils.elementToListOfStrings(value); + }, + // FIXME: This merging of lists is potentially dangerous since + // the incoming list of files can belong to a .lf file that is + // located in a different location, and keeping just filename + // strings like this without absolute paths is incorrect. + (config, value, err) -> { + config.files.addAll(ASTUtils.elementToListOfStrings(value)); + }), + + /** Flags to be passed on to the target compiler. */ + FLAGS( + "flags", + UnionType.STRING_OR_STRING_ARRAY, + Arrays.asList(Target.C, Target.CCPP), + (config) -> ASTUtils.toElement(config.compilerFlags), + (config, value, err) -> { + config.compilerFlags = ASTUtils.elementToListOfStrings(value); + }), + + /** Directive to specify the coordination mode */ + COORDINATION( + "coordination", + UnionType.COORDINATION_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.coordination.toString()), + (config, value, err) -> { + config.coordination = + (CoordinationType) + UnionType.COORDINATION_UNION.forName(ASTUtils.elementToSingleString(value)); + }, + (config, value, err) -> { + config.coordination = + (CoordinationType) + UnionType.COORDINATION_UNION.forName(ASTUtils.elementToSingleString(value)); + }), + + /** Key-value pairs giving options for clock synchronization. */ + COORDINATION_OPTIONS( + "coordination-options", + DictionaryType.COORDINATION_OPTION_DICT, + Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS), + (config) -> { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (CoordinationOption opt : CoordinationOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case ADVANCE_MESSAGE_INTERVAL: + if (config.coordinationOptions.advance_message_interval == null) continue; + pair.setValue( + ASTUtils.toElement(config.coordinationOptions.advance_message_interval)); + break; + } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + if (kvp.getPairs().isEmpty()) return null; + return e; + }, + (config, value, err) -> { + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + CoordinationOption option = + (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT.forName(entry.getName()); + switch (option) { + case ADVANCE_MESSAGE_INTERVAL: + config.coordinationOptions.advance_message_interval = + ASTUtils.toTimeValue(entry.getValue()); + break; + default: + break; + } + } + }, + (config, value, err) -> { + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + CoordinationOption option = + (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT.forName(entry.getName()); + switch (option) { + case ADVANCE_MESSAGE_INTERVAL: + config.coordinationOptions.advance_message_interval = + ASTUtils.toTimeValue(entry.getValue()); + break; + default: + break; + } + } + }), + + /** + * Directive to let the execution engine remain active also if there are no more events in the + * event queue. + */ + KEEPALIVE( + "keepalive", + PrimitiveType.BOOLEAN, + Target.ALL, + (config) -> ASTUtils.toElement(config.keepalive), + (config, value, err) -> { + config.keepalive = ASTUtils.toBoolean(value); + }), + + /** Directive to specify the grain at which to report log messages during execution. */ + LOGGING( + "logging", + UnionType.LOGGING_UNION, + Target.ALL, + (config) -> ASTUtils.toElement(config.logLevel.toString()), + (config, value, err) -> { + config.logLevel = + (LogLevel) UnionType.LOGGING_UNION.forName(ASTUtils.elementToSingleString(value)); + }), + + /** Directive to not invoke the target compiler. */ + NO_COMPILE( + "no-compile", + PrimitiveType.BOOLEAN, + Arrays.asList(Target.C, Target.CPP, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.noCompile), + (config, value, err) -> { + config.noCompile = ASTUtils.toBoolean(value); + }), + + /** Directive to disable validation of reactor rules at runtime. */ + NO_RUNTIME_VALIDATION( + "no-runtime-validation", + PrimitiveType.BOOLEAN, + Arrays.asList(Target.CPP), + (config) -> ASTUtils.toElement(config.noRuntimeValidation), + (config, value, err) -> { + config.noRuntimeValidation = ASTUtils.toBoolean(value); + }), + + /** + * Directive to specify the platform for cross code generation. This is either a string of the + * platform or a dictionary of options that includes the string name. + */ + PLATFORM( + "platform", + UnionType.PLATFORM_STRING_OR_DICTIONARY, + Target.ALL, + (config) -> { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (PlatformOption opt : PlatformOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case NAME: + pair.setValue(ASTUtils.toElement(config.platformOptions.platform.toString())); + break; + case BAUDRATE: + pair.setValue(ASTUtils.toElement(config.platformOptions.baudRate)); + break; + case BOARD: + pair.setValue(ASTUtils.toElement(config.platformOptions.board)); + break; + case FLASH: + pair.setValue(ASTUtils.toElement(config.platformOptions.flash)); + break; + case PORT: + pair.setValue(ASTUtils.toElement(config.platformOptions.port)); + break; + } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + if (kvp.getPairs().isEmpty()) return null; + return e; + }, + (config, value, err) -> { + if (value.getLiteral() != null) { + config.platformOptions = new PlatformOptions(); + config.platformOptions.platform = + (Platform) UnionType.PLATFORM_UNION.forName(ASTUtils.elementToSingleString(value)); } else { - config.dockerOptions = new DockerOptions(); - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - DockerOption option = (DockerOption) DictionaryType.DOCKER_DICT - .forName(entry.getName()); - switch (option) { - case FROM: - config.dockerOptions.from = ASTUtils.elementToSingleString(entry.getValue()); - break; - default: - break; + config.platformOptions = new PlatformOptions(); + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + PlatformOption option = + (PlatformOption) DictionaryType.PLATFORM_DICT.forName(entry.getName()); + switch (option) { + case NAME: + Platform p = + (Platform) + UnionType.PLATFORM_UNION.forName( + ASTUtils.elementToSingleString(entry.getValue())); + if (p == null) { + String s = + "Unidentified Platform Type, LF supports the following platform types: " + + Arrays.asList(Platform.values()).toString(); + err.reportError(s); + throw new AssertionError(s); } + config.platformOptions.platform = p; + break; + case BAUDRATE: + config.platformOptions.baudRate = ASTUtils.toInteger(entry.getValue()); + break; + case BOARD: + config.platformOptions.board = ASTUtils.elementToSingleString(entry.getValue()); + break; + case FLASH: + config.platformOptions.flash = ASTUtils.toBoolean(entry.getValue()); + break; + case PORT: + config.platformOptions.port = ASTUtils.elementToSingleString(entry.getValue()); + break; + default: + break; } + } + } + }), + + /** Directive to instruct the runtime to collect and print execution statistics. */ + PRINT_STATISTICS( + "print-statistics", + PrimitiveType.BOOLEAN, + Arrays.asList(Target.CPP), + (config) -> ASTUtils.toElement(config.printStatistics), + (config, value, err) -> { + config.printStatistics = ASTUtils.toBoolean(value); + }), + + /** + * Directive for specifying .proto files that need to be compiled and their code included in the + * sources. + */ + PROTOBUFS( + "protobufs", + UnionType.FILE_OR_FILE_ARRAY, + Arrays.asList(Target.C, Target.CCPP, Target.TS, Target.Python), + (config) -> ASTUtils.toElement(config.protoFiles), + (config, value, err) -> { + config.protoFiles = ASTUtils.elementToListOfStrings(value); + }), + + /** Directive to specify that ROS2 specific code is generated, */ + ROS2( + "ros2", + PrimitiveType.BOOLEAN, + List.of(Target.CPP), + (config) -> ASTUtils.toElement(config.ros2), + (config, value, err) -> { + config.ros2 = ASTUtils.toBoolean(value); + }), + + /** Directive to specify additional ROS2 packages that this LF program depends on. */ + ROS2_DEPENDENCIES( + "ros2-dependencies", + ArrayType.STRING_ARRAY, + List.of(Target.CPP), + (config) -> ASTUtils.toElement(config.ros2Dependencies), + (config, value, err) -> { + config.ros2Dependencies = ASTUtils.elementToListOfStrings(value); + }), + + /** Directive for specifying a specific version of the reactor runtime library. */ + RUNTIME_VERSION( + "runtime-version", + PrimitiveType.STRING, + Arrays.asList(Target.CPP), + (config) -> ASTUtils.toElement(config.runtimeVersion), + (config, value, err) -> { + config.runtimeVersion = ASTUtils.elementToSingleString(value); + }), + + /** Directive for specifying a specific runtime scheduler, if supported. */ + SCHEDULER( + "scheduler", + UnionType.SCHEDULER_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.schedulerType.toString()), + (config, value, err) -> { + config.schedulerType = + (SchedulerOption) + UnionType.SCHEDULER_UNION.forName(ASTUtils.elementToSingleString(value)); + }), + + /** Directive to specify that all code is generated in a single file. */ + SINGLE_FILE_PROJECT( + "single-file-project", + PrimitiveType.BOOLEAN, + List.of(Target.Rust), + (config) -> ASTUtils.toElement(config.singleFileProject), + (config, value, err) -> { + config.singleFileProject = ASTUtils.toBoolean(value); + }), + + /** Directive to indicate whether the runtime should use multi-threading. */ + THREADING( + "threading", + PrimitiveType.BOOLEAN, + List.of(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.threading), + (config, value, err) -> { + config.threading = ASTUtils.toBoolean(value); + }), + + /** Directive to specify the number of worker threads used by the runtime. */ + WORKERS( + "workers", + PrimitiveType.NON_NEGATIVE_INTEGER, + List.of(Target.C, Target.CCPP, Target.Python, Target.CPP, Target.Rust), + (config) -> ASTUtils.toElement(config.workers), + (config, value, err) -> { + config.workers = ASTUtils.toInteger(value); + }), + + /** Directive to specify the execution timeout. */ + TIMEOUT( + "timeout", + PrimitiveType.TIME_VALUE, + Target.ALL, + (config) -> ASTUtils.toElement(config.timeout), + (config, value, err) -> { + config.timeout = ASTUtils.toTimeValue(value); + }, + (config, value, err) -> { + config.timeout = ASTUtils.toTimeValue(value); + }), + + /** Directive to enable tracing. */ + TRACING( + "tracing", + UnionType.TRACING_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Python), + (config) -> { + if (config.tracing == null) { + return null; + } else if (config.tracing.equals(new TracingOptions())) { + // default values + return ASTUtils.toElement(true); + } else { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (TracingOption opt : TracingOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case TRACE_FILE_NAME: + if (config.tracing.traceFileName == null) continue; + pair.setValue(ASTUtils.toElement(config.tracing.traceFileName)); + } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + if (kvp.getPairs().isEmpty()) return null; + return e; + } + }, + (config, value, err) -> { + if (value.getLiteral() != null) { + if (ASTUtils.toBoolean(value)) { + config.tracing = new TracingOptions(); + } else { + config.tracing = null; + } + } else { + config.tracing = new TracingOptions(); + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + TracingOption option = + (TracingOption) DictionaryType.TRACING_DICT.forName(entry.getName()); + switch (option) { + case TRACE_FILE_NAME: + config.tracing.traceFileName = ASTUtils.elementToSingleString(entry.getValue()); + break; + default: + break; + } + } + } + }), + + /** + * Directive to let the runtime export its internal dependency graph. + * + *

    This is a debugging feature and currently only used for C++ and Rust programs. + */ + EXPORT_DEPENDENCY_GRAPH( + "export-dependency-graph", + PrimitiveType.BOOLEAN, + List.of(Target.CPP, Target.Rust), + (config) -> ASTUtils.toElement(config.exportDependencyGraph), + (config, value, err) -> { + config.exportDependencyGraph = ASTUtils.toBoolean(value); + }), + + /** + * Directive to let the runtime export the program structure to a yaml file. + * + *

    This is a debugging feature and currently only used for C++ programs. + */ + EXPORT_TO_YAML( + "export-to-yaml", + PrimitiveType.BOOLEAN, + List.of(Target.CPP), + (config) -> ASTUtils.toElement(config.exportToYaml), + (config, value, err) -> { + config.exportToYaml = ASTUtils.toBoolean(value); + }), + + /** + * List of module files to link into the crate as top-level. For instance, a {@code target Rust { + * rust-modules: [ "foo.rs" ] }} will cause the file to be copied into the generated project, and + * the generated {@code main.rs} will include it with a {@code mod foo;}. If one of the paths is a + * directory, it must contain a {@code mod.rs} file, and all its contents are copied. + */ + RUST_INCLUDE( + "rust-include", + UnionType.FILE_OR_FILE_ARRAY, + List.of(Target.Rust), + (config) -> { + // do not check paths here, and simply copy the absolute path over + List paths = config.rust.getRustTopLevelModules(); + if (paths.isEmpty()) return null; + else if (paths.size() == 1) { + return ASTUtils.toElement(paths.get(0).toString()); + } else { + Element e = LfFactory.eINSTANCE.createElement(); + Array arr = LfFactory.eINSTANCE.createArray(); + for (Path p : paths) { + arr.getElements().add(ASTUtils.toElement(p.toString())); + } + e.setArray(arr); + return e; + } + }, + (config, value, err) -> { + Path referencePath; + try { + referencePath = FileUtil.toPath(value.eResource().getURI()).toAbsolutePath(); + } catch (IOException e) { + err.reportError(value, "Invalid path? " + e.getMessage()); + throw new RuntimeIOException(e); } - } - - /** - * String representation of this target property. - */ - public final String description; - - /** - * List of targets that support this property. If a property is used for - * a target that does not support it, a warning reported during - * validation. - */ - public final List supportedBy; - - /** - * The type of values that can be assigned to this property. - */ - public final TargetPropertyType type; - /** - * Function that given a configuration object and an Element AST node - * sets the configuration. It is assumed that validation already - * occurred, so this code should be straightforward. - */ - public final PropertyParser setter; + // we'll resolve relative paths to check that the files + // are as expected. - /** - * Function that given a configuration object and an Element AST node - * sets the configuration. It is assumed that validation already - * occurred, so this code should be straightforward. - */ - public final PropertyParser updater; + if (value.getLiteral() != null) { + Path resolved = referencePath.resolveSibling(StringUtil.removeQuotes(value.getLiteral())); + + config.rust.addAndCheckTopLevelModule(resolved, value, err); + } else if (value.getArray() != null) { + for (Element element : value.getArray().getElements()) { + String literal = StringUtil.removeQuotes(element.getLiteral()); + Path resolved = referencePath.resolveSibling(literal); + config.rust.addAndCheckTopLevelModule(resolved, element, err); + } + } + }), + + /** Directive for specifying Cargo features of the generated program to enable. */ + CARGO_FEATURES( + "cargo-features", + ArrayType.STRING_ARRAY, + List.of(Target.Rust), + (config) -> ASTUtils.toElement(config.rust.getCargoFeatures()), + (config, value, err) -> { + config.rust.setCargoFeatures(ASTUtils.elementToListOfStrings(value)); + }), + + /** + * Dependency specifications for Cargo. This property looks like this: + * + * 

    {@code
+   * cargo-dependencies: {
+   *    // Name-of-the-crate: "version"
+   *    rand: "0.8",
+   *    // Equivalent to using an explicit map:
+   *    rand: {
+   *      version: "0.8"
+   *    },
+   *    // The map allows specifying more details
+   *    rand: {
+   *      // A path to a local unpublished crate.
+   *      // Note 'path' is mutually exclusive with 'version'.
+   *      path: "/home/me/Git/local-rand-clone"
+   *    },
+   *    rand: {
+   *      version: "0.8",
+   *      // you can specify cargo features
+   *      features: ["some-cargo-feature",]
+   *    }
+   * }
+   * }
    + */ + CARGO_DEPENDENCIES( + "cargo-dependencies", + CargoDependenciesPropertyType.INSTANCE, + List.of(Target.Rust), + (config) -> { + var deps = config.rust.getCargoDependencies(); + if (deps.size() == 0) return null; + else { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (var ent : deps.entrySet()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(ent.getKey()); + pair.setValue(CargoDependencySpec.extractSpec(ent.getValue())); + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + return e; + } + }, + (config, value, err) -> { + config.rust.setCargoDependencies(CargoDependencySpec.parseAll(value)); + }), + + /** + * Directs the C or Python target to include the associated C file used for setting up federated + * execution before processing the first tag. + */ + FED_SETUP( + "_fed_setup", + PrimitiveType.FILE, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.fedSetupPreamble), + (config, value, err) -> + config.fedSetupPreamble = StringUtil.removeQuotes(ASTUtils.elementToSingleString(value))); + + /** Update {@code config}.dockerOptions based on value. */ + private static void setDockerProperty(TargetConfig config, Element value) { + if (value.getLiteral() != null) { + if (ASTUtils.toBoolean(value)) { + config.dockerOptions = new DockerOptions(); + } else { + config.dockerOptions = null; + } + } else { + config.dockerOptions = new DockerOptions(); + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + DockerOption option = (DockerOption) DictionaryType.DOCKER_DICT.forName(entry.getName()); + switch (option) { + case FROM: + config.dockerOptions.from = ASTUtils.elementToSingleString(entry.getValue()); + break; + default: + break; + } + } + } + } + + /** String representation of this target property. */ + public final String description; + + /** + * List of targets that support this property. If a property is used for a target that does not + * support it, a warning reported during validation. + */ + public final List supportedBy; + + /** The type of values that can be assigned to this property. */ + public final TargetPropertyType type; + + /** + * Function that given a configuration object and an Element AST node sets the configuration. It + * is assumed that validation already occurred, so this code should be straightforward. + */ + public final PropertyParser setter; + + /** + * Function that given a configuration object and an Element AST node sets the configuration. It + * is assumed that validation already occurred, so this code should be straightforward. + */ + public final PropertyParser updater; + + @FunctionalInterface + private interface PropertyParser { + + /** + * Parse the given element into the given target config. May use the error reporter to report + * format errors. + */ + void parseIntoTargetConfig(TargetConfig config, Element element, ErrorReporter err); + } + + public final PropertyGetter getter; + + @FunctionalInterface + private interface PropertyGetter { + + /** + * Read this property from the target config and build an element which represents it for the + * AST. May return null if the given value of this property is the same as the default. + */ + Element getPropertyElement(TargetConfig config); + } + + /** + * Private constructor for target properties. + * + * @param description String representation of this property. + * @param type The type that values assigned to this property should conform to. + * @param supportedBy List of targets that support this property. + * @param setter Function for configuration updates. + */ + TargetProperty( + String description, + TargetPropertyType type, + List supportedBy, + PropertyGetter getter, + PropertyParser setter) { + this.description = description; + this.type = type; + this.supportedBy = supportedBy; + this.getter = getter; + this.setter = setter; + this.updater = setter; // (Re)set by default + } + + /** + * Private constructor for target properties. This will take an additional {@code updater}, which + * will be used to merge target properties from imported resources. + * + * @param description String representation of this property. + * @param type The type that values assigned to this property should conform to. + * @param supportedBy List of targets that support this property. + * @param setter Function for setting configuration values. + * @param updater Function for updating configuration values. + */ + TargetProperty( + String description, + TargetPropertyType type, + List supportedBy, + PropertyGetter getter, + PropertyParser setter, + PropertyParser updater) { + this.description = description; + this.type = type; + this.supportedBy = supportedBy; + this.getter = getter; + this.setter = setter; + this.updater = updater; + } + + /** + * Return the name of the property in lingua franca. This is suitable for use as a key in a target + * properties block. It may be an invalid identifier in other languages (may contains dashes + * {@code -}). + */ + public String getDisplayName() { + return description; + } + + /** + * Set the given configuration using the given target properties. + * + * @param config The configuration object to update. + * @param properties AST node that holds all the target properties. + * @param err Error reporter on which property format errors will be reported + */ + public static void set(TargetConfig config, List properties, ErrorReporter err) { + properties.forEach( + property -> { + TargetProperty p = forName(property.getName()); + if (p != null) { + // Mark the specified target property as set by the user + config.setByUser.add(p); + try { + p.setter.parseIntoTargetConfig(config, property.getValue(), err); + } catch (InvalidLfSourceException e) { + err.reportError(e.getNode(), e.getProblem()); + } + } + }); + } + + /** + * Extracts all properties as a list of key-value pairs from a TargetConfig. Only extracts + * properties explicitly set by user. + * + * @param config The TargetConfig to extract from. + * @return The extracted properties. + */ + public static List extractProperties(TargetConfig config) { + var res = new LinkedList(); + for (TargetProperty p : config.setByUser) { + KeyValuePair kv = LfFactory.eINSTANCE.createKeyValuePair(); + kv.setName(p.toString()); + kv.setValue(p.getter.getPropertyElement(config)); + if (kv.getValue() != null) res.add(kv); + } + return res; + } + + /** + * Constructs a TargetDecl by extracting the fields of the given TargetConfig. + * + * @param target The target to generate for. + * @param config The TargetConfig to extract from. + * @return A generated TargetDecl. + */ + public static TargetDecl extractTargetDecl(Target target, TargetConfig config) { + TargetDecl decl = LfFactory.eINSTANCE.createTargetDecl(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (KeyValuePair p : extractProperties(config)) { + kvp.getPairs().add(p); + } + decl.setName(target.toString()); + decl.setConfig(kvp); + return decl; + } + + /** + * Update the given configuration using the given target properties. + * + * @param config The configuration object to update. + * @param properties AST node that holds all the target properties. + */ + public static void update(TargetConfig config, List properties, ErrorReporter err) { + properties.forEach( + property -> { + TargetProperty p = forName(property.getName()); + if (p != null) { + // Mark the specified target property as set by the user + config.setByUser.add(p); + p.updater.parseIntoTargetConfig(config, property.getValue(), err); + } + }); + } + + /** + * Update one of the target properties, given by 'propertyName'. For convenience, a list of target + * properties (e.g., taken from a file or resource) can be passed without any filtering. This + * function will do nothing if the list of target properties doesn't include the property given by + * 'propertyName'. + * + * @param config The target config to apply the update to. + * @param property The target property. + * @param properties AST node that holds all the target properties. + * @param err Error reporter on which property format errors will be reported + */ + public static void updateOne( + TargetConfig config, + TargetProperty property, + List properties, + ErrorReporter err) { + properties.stream() + .filter(p -> p.getName().equals(property.getDisplayName())) + .findFirst() + .map(KeyValuePair::getValue) + .ifPresent(value -> property.updater.parseIntoTargetConfig(config, value, err)); + } + + /** + * Return the entry that matches the given string. + * + * @param name The string to match against. + */ + public static TargetProperty forName(String name) { + return Target.match(name, TargetProperty.values()); + } + + /** + * Return a list with all target properties. + * + * @return All existing target properties. + */ + public static List getOptions() { + return Arrays.asList(TargetProperty.values()); + } + + /** Return the description. */ + @Override + public String toString() { + return this.description; + } + + // Inner classes for the various supported types. + + /** Dictionary type that allows for keys that will be interpreted as strings and string values. */ + public enum StringDictionaryType implements TargetPropertyType { + COMPILE_DEFINITION(); - @FunctionalInterface - private interface PropertyParser { + @Override + public boolean validate(Element e) { + if (e.getKeyvalue() != null) { + return true; + } + return false; + } - /** - * Parse the given element into the given target config. - * May use the error reporter to report format errors. - */ - void parseIntoTargetConfig(TargetConfig config, Element element, ErrorReporter err); + @Override + public void check(Element e, String name, LFValidator v) { + KeyValuePairs kv = e.getKeyvalue(); + if (kv == null) { + TargetPropertyType.produceError(name, this.toString(), v); + } else { + for (KeyValuePair pair : kv.getPairs()) { + String key = pair.getName(); + Element val = pair.getValue(); + + // Make sure the type is string + PrimitiveType.STRING.check(val, name + "." + key, v); + } + } } + } - public final PropertyGetter getter; + /** Interface for dictionary elements. It associates an entry with a type. */ + public interface DictionaryElement { - @FunctionalInterface - private interface PropertyGetter { + TargetPropertyType getType(); + } - /** - * Read this property from the target config and build an element which represents it for the AST. - * May return null if the given value of this property is the same as the default. - */ - Element getPropertyElement(TargetConfig config); - } + /** + * A dictionary type with a predefined set of possible keys and assignable types. + * + * @author Marten Lohstroh + */ + public enum DictionaryType implements TargetPropertyType { + CLOCK_SYNC_OPTION_DICT(Arrays.asList(ClockSyncOption.values())), + DOCKER_DICT(Arrays.asList(DockerOption.values())), + PLATFORM_DICT(Arrays.asList(PlatformOption.values())), + COORDINATION_OPTION_DICT(Arrays.asList(CoordinationOption.values())), + TRACING_DICT(Arrays.asList(TracingOption.values())); - /** - * Private constructor for target properties. - * - * @param description String representation of this property. - * @param type The type that values assigned to this property - * should conform to. - * @param supportedBy List of targets that support this property. - * @param setter Function for configuration updates. - */ - TargetProperty(String description, TargetPropertyType type, - List supportedBy, - PropertyGetter getter, - PropertyParser setter) { - this.description = description; - this.type = type; - this.supportedBy = supportedBy; - this.getter = getter; - this.setter = setter; - this.updater = setter; // (Re)set by default - } + /** The keys and assignable types that are allowed in this dictionary. */ + public List options; /** - * Private constructor for target properties. This will take an additional - * {@code updater}, which will be used to merge target properties from imported resources. + * A dictionary type restricted to sets of predefined keys and types of values. * - * @param description String representation of this property. - * @param type The type that values assigned to this property - * should conform to. - * @param supportedBy List of targets that support this property. - * @param setter Function for setting configuration values. - * @param updater Function for updating configuration values. - */ - TargetProperty(String description, TargetPropertyType type, - List supportedBy, - PropertyGetter getter, - PropertyParser setter, - PropertyParser updater) { - this.description = description; - this.type = type; - this.supportedBy = supportedBy; - this.getter = getter; - this.setter = setter; - this.updater = updater; - } - - /** - * Return the name of the property in lingua franca. This - * is suitable for use as a key in a target properties block. - * It may be an invalid identifier in other languages (may - * contains dashes {@code -}). + * @param options The dictionary elements allowed by this type. */ - public String getDisplayName() { - return description; + private DictionaryType(List options) { + this.options = options; } /** - * Set the given configuration using the given target properties. + * Return the dictionary element of which the key matches the given string. * - * @param config The configuration object to update. - * @param properties AST node that holds all the target properties. - * @param err Error reporter on which property format errors will be reported + * @param name The string to match against. + * @return The matching dictionary element (or null if there is none). */ - public static void set(TargetConfig config, List properties, ErrorReporter err) { - properties.forEach(property -> { - TargetProperty p = forName(property.getName()); - if (p != null) { - // Mark the specified target property as set by the user - config.setByUser.add(p); - try { - p.setter.parseIntoTargetConfig(config, property.getValue(), err); - } catch (InvalidLfSourceException e) { - err.reportError(e.getNode(), e.getProblem()); - } - } - }); + public DictionaryElement forName(String name) { + return Target.match(name, options); } - /** - * Extracts all properties as a list of key-value pairs from a TargetConfig. Only extracts properties explicitly set by user. - * @param config The TargetConfig to extract from. - * @return The extracted properties. - */ - public static List extractProperties(TargetConfig config) { - var res = new LinkedList(); - for (TargetProperty p : config.setByUser) { - KeyValuePair kv = LfFactory.eINSTANCE.createKeyValuePair(); - kv.setName(p.toString()); - kv.setValue(p.getter.getPropertyElement(config)); - if (kv.getValue() != null) - res.add(kv); + /** Recursively check that the passed in element conforms to the rules of this dictionary. */ + @Override + public void check(Element e, String name, LFValidator v) { + KeyValuePairs kv = e.getKeyvalue(); + if (kv == null) { + TargetPropertyType.produceError(name, this.toString(), v); + } else { + for (KeyValuePair pair : kv.getPairs()) { + String key = pair.getName(); + Element val = pair.getValue(); + Optional match = + this.options.stream() + .filter(element -> key.equalsIgnoreCase(element.toString())) + .findAny(); + if (match.isPresent()) { + // Make sure the type is correct, too. + TargetPropertyType type = match.get().getType(); + type.check(val, name + "." + key, v); + } else { + // No match found; report error. + TargetPropertyType.produceError(name, this.toString(), v); + } } - return res; + } } - /** - * Constructs a TargetDecl by extracting the fields of the given TargetConfig. - * @param target The target to generate for. - * @param config The TargetConfig to extract from. - * @return A generated TargetDecl. - */ - public static TargetDecl extractTargetDecl(Target target, TargetConfig config) { - TargetDecl decl = LfFactory.eINSTANCE.createTargetDecl(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (KeyValuePair p : extractProperties(config)) { - kvp.getPairs().add(p); - } - decl.setName(target.toString()); - decl.setConfig(kvp); - return decl; + /** Return true if the given element represents a dictionary, false otherwise. */ + @Override + public boolean validate(Element e) { + if (e.getKeyvalue() != null) { + return true; + } + return false; } - /** - * Update the given configuration using the given target properties. - * - * @param config The configuration object to update. - * @param properties AST node that holds all the target properties. - */ - public static void update(TargetConfig config, List properties, ErrorReporter err) { - properties.forEach(property -> { - TargetProperty p = forName(property.getName()); - if (p != null) { - // Mark the specified target property as set by the user - config.setByUser.add(p); - p.updater.parseIntoTargetConfig(config, property.getValue(), err); - } - }); + /** Return a human-readable description of this type. */ + @Override + public String toString() { + return "a dictionary with one or more of the following keys: " + + options.stream().map(option -> option.toString()).collect(Collectors.joining(", ")); } - - /** - * Update one of the target properties, given by 'propertyName'. - * For convenience, a list of target properties (e.g., taken from - * a file or resource) can be passed without any filtering. This - * function will do nothing if the list of target properties doesn't - * include the property given by 'propertyName'. + } + /** + * A type that can assume one of several types. + * + * @author Marten Lohstroh + */ + public enum UnionType implements TargetPropertyType { + STRING_OR_STRING_ARRAY(Arrays.asList(PrimitiveType.STRING, ArrayType.STRING_ARRAY), null), + PLATFORM_STRING_OR_DICTIONARY( + Arrays.asList(PrimitiveType.STRING, DictionaryType.PLATFORM_DICT), null), + FILE_OR_FILE_ARRAY(Arrays.asList(PrimitiveType.FILE, ArrayType.FILE_ARRAY), null), + BUILD_TYPE_UNION(Arrays.asList(BuildType.values()), null), + COORDINATION_UNION(Arrays.asList(CoordinationType.values()), CoordinationType.CENTRALIZED), + SCHEDULER_UNION(Arrays.asList(SchedulerOption.values()), SchedulerOption.getDefault()), + LOGGING_UNION(Arrays.asList(LogLevel.values()), LogLevel.INFO), + PLATFORM_UNION(Arrays.asList(Platform.values()), Platform.AUTO), + CLOCK_SYNC_UNION(Arrays.asList(ClockSyncMode.values()), ClockSyncMode.INIT), + DOCKER_UNION(Arrays.asList(PrimitiveType.BOOLEAN, DictionaryType.DOCKER_DICT), null), + TRACING_UNION(Arrays.asList(PrimitiveType.BOOLEAN, DictionaryType.TRACING_DICT), null); + + /** The constituents of this type union. */ + public final List> options; + + /** The default type, if there is one. */ + private final Enum defaultOption; + + /** + * Private constructor for creating unions types. * - * @param config The target config to apply the update to. - * @param property The target property. - * @param properties AST node that holds all the target properties. - * @param err Error reporter on which property format errors will be reported + * @param options The types that that are part of the union. + * @param defaultOption The default type. */ - public static void updateOne(TargetConfig config, TargetProperty property, List properties, ErrorReporter err) { - properties.stream() - .filter(p -> p.getName().equals(property.getDisplayName())) - .findFirst() - .map(KeyValuePair::getValue) - .ifPresent(value -> property.updater.parseIntoTargetConfig( - config, - value, - err - )); + private UnionType(List> options, Enum defaultOption) { + this.options = options; + this.defaultOption = defaultOption; } /** - * Return the entry that matches the given string. - * @param name The string to match against. - */ - public static TargetProperty forName(String name) { - return Target.match(name, TargetProperty.values()); - } - - /** - * Return a list with all target properties. + * Return the type among those in this type union that matches the given name. * - * @return All existing target properties. + * @param name The string to match against. + * @return The matching dictionary element (or null if there is none). */ - public static List getOptions() { - return Arrays.asList(TargetProperty.values()); + public Enum forName(String name) { + return Target.match(name, options); } - /** - * Return the description. - */ + /** Recursively check that the passed in element conforms to the rules of this union. */ @Override - public String toString() { - return this.description; + public void check(Element e, String name, LFValidator v) { + Optional> match = this.match(e); + if (match.isPresent()) { + // Go deeper if the element is an array or dictionary. + Enum type = match.get(); + if (type instanceof DictionaryType) { + ((DictionaryType) type).check(e, name, v); + } else if (type instanceof ArrayType) { + ((ArrayType) type).check(e, name, v); + } else if (type instanceof PrimitiveType) { + ((PrimitiveType) type).check(e, name, v); + } else if (!(type instanceof Enum)) { + throw new RuntimeException("Encountered an unknown type."); + } + } else { + // No match found; report error. + TargetPropertyType.produceError(name, this.toString(), v); + } } - // Inner classes for the various supported types. - /** - * Dictionary type that allows for keys that will be interpreted as strings - * and string values. + * Internal method for matching a given element against the allowable types. + * + * @param e AST node that represents the value of a target property. + * @return The matching type wrapped in an Optional object. */ - public enum StringDictionaryType implements TargetPropertyType { - COMPILE_DEFINITION(); - @Override - public boolean validate(Element e) { - if (e.getKeyvalue() != null) { - return true; - } - return false; - } - - @Override - public void check(Element e, String name, LFValidator v) { - KeyValuePairs kv = e.getKeyvalue(); - if (kv == null) { - TargetPropertyType.produceError(name, this.toString(), v); - } else { - for (KeyValuePair pair : kv.getPairs()) { - String key = pair.getName(); - Element val = pair.getValue(); - - // Make sure the type is string - PrimitiveType.STRING.check(val, name + "." + key, v); + private Optional> match(Element e) { + return this.options.stream() + .filter( + option -> { + if (option instanceof TargetPropertyType) { + return ((TargetPropertyType) option).validate(e); + } else { + return ASTUtils.elementToSingleString(e).equalsIgnoreCase(option.toString()); } - } - - } + }) + .findAny(); } /** - * Interface for dictionary elements. It associates an entry with a type. + * Return true if this union has an option that matches the given element. + * + * @param e The element to match against this type. */ - public interface DictionaryElement { - - TargetPropertyType getType(); + @Override + public boolean validate(Element e) { + if (this.match(e).isPresent()) { + return true; + } + return false; } /** - * A dictionary type with a predefined set of possible keys and assignable - * types. - * - * @author Marten Lohstroh - * + * Return a human-readable description of this type. If three is a default option, then indicate + * it. */ - public enum DictionaryType implements TargetPropertyType { - CLOCK_SYNC_OPTION_DICT(Arrays.asList(ClockSyncOption.values())), - DOCKER_DICT(Arrays.asList(DockerOption.values())), - PLATFORM_DICT(Arrays.asList(PlatformOption.values())), - COORDINATION_OPTION_DICT(Arrays.asList(CoordinationOption.values())), - TRACING_DICT(Arrays.asList(TracingOption.values())); - - /** - * The keys and assignable types that are allowed in this dictionary. - */ - public List options; - - /** - * A dictionary type restricted to sets of predefined keys and types of - * values. - * - * @param options The dictionary elements allowed by this type. - */ - private DictionaryType(List options) { - this.options = options; - } - - /** - * Return the dictionary element of which the key matches the given - * string. - * - * @param name The string to match against. - * @return The matching dictionary element (or null if there is none). - */ - public DictionaryElement forName(String name) { - return Target.match(name, options); - } - - /** - * Recursively check that the passed in element conforms to the rules of - * this dictionary. - */ - @Override - public void check(Element e, String name, LFValidator v) { - KeyValuePairs kv = e.getKeyvalue(); - if (kv == null) { - TargetPropertyType.produceError(name, this.toString(), v); - } else { - for (KeyValuePair pair : kv.getPairs()) { - String key = pair.getName(); - Element val = pair.getValue(); - Optional match = this.options.stream() - .filter(element -> key.equalsIgnoreCase(element.toString())).findAny(); - if (match.isPresent()) { - // Make sure the type is correct, too. - TargetPropertyType type = match.get().getType(); - type.check(val, name + "." + key, v); + @Override + public String toString() { + return "one of the following: " + + options.stream() + .map( + option -> { + if (option == this.defaultOption) { + return option.toString() + " (default)"; } else { - // No match found; report error. - TargetPropertyType.produceError(name, - this.toString(), v); + return option.toString(); } - } - } - } - - /** - * Return true if the given element represents a dictionary, false - * otherwise. - */ - @Override - public boolean validate(Element e) { - if (e.getKeyvalue() != null) { - return true; - } - return false; - } - - /** - * Return a human-readable description of this type. - */ - @Override - public String toString() { - return "a dictionary with one or more of the following keys: " - + options.stream().map(option -> option.toString()) - .collect(Collectors.joining(", ")); - } + }) + .collect(Collectors.joining(", ")); } - /** - * A type that can assume one of several types. - * - * @author Marten Lohstroh - * - */ - public enum UnionType implements TargetPropertyType { - STRING_OR_STRING_ARRAY( - Arrays.asList(PrimitiveType.STRING, ArrayType.STRING_ARRAY), - null), - PLATFORM_STRING_OR_DICTIONARY( - Arrays.asList(PrimitiveType.STRING, DictionaryType.PLATFORM_DICT), - null), - FILE_OR_FILE_ARRAY( - Arrays.asList(PrimitiveType.FILE, ArrayType.FILE_ARRAY), null), - BUILD_TYPE_UNION(Arrays.asList(BuildType.values()), null), - COORDINATION_UNION(Arrays.asList(CoordinationType.values()), - CoordinationType.CENTRALIZED), - SCHEDULER_UNION(Arrays.asList(SchedulerOption.values()), SchedulerOption.getDefault()), - LOGGING_UNION(Arrays.asList(LogLevel.values()), LogLevel.INFO), - PLATFORM_UNION(Arrays.asList(Platform.values()), Platform.AUTO), - CLOCK_SYNC_UNION(Arrays.asList(ClockSyncMode.values()), - ClockSyncMode.INIT), - DOCKER_UNION(Arrays.asList(PrimitiveType.BOOLEAN, DictionaryType.DOCKER_DICT), - null), - TRACING_UNION(Arrays.asList(PrimitiveType.BOOLEAN, DictionaryType.TRACING_DICT), - null); - - /** - * The constituents of this type union. - */ - public final List> options; - - /** - * The default type, if there is one. - */ - private final Enum defaultOption; - - /** - * Private constructor for creating unions types. - * - * @param options The types that that are part of the union. - * @param defaultOption The default type. - */ - private UnionType(List> options, Enum defaultOption) { - this.options = options; - this.defaultOption = defaultOption; - } - - /** - * Return the type among those in this type union that matches the given - * name. - * - * @param name The string to match against. - * @return The matching dictionary element (or null if there is none). - */ - public Enum forName(String name) { - return Target.match(name, options); - } - - /** - * Recursively check that the passed in element conforms to the rules of - * this union. - */ - @Override - public void check(Element e, String name, LFValidator v) { - Optional> match = this.match(e); - if (match.isPresent()) { - // Go deeper if the element is an array or dictionary. - Enum type = match.get(); - if (type instanceof DictionaryType) { - ((DictionaryType) type).check(e, name, v); - } else if (type instanceof ArrayType) { - ((ArrayType) type).check(e, name, v); - } else if (type instanceof PrimitiveType) { - ((PrimitiveType) type).check(e, name, v); - } else if (!(type instanceof Enum)) { - throw new RuntimeException("Encountered an unknown type."); - } - } else { - // No match found; report error. - TargetPropertyType.produceError(name, this.toString(), v); - } - } - - /** - * Internal method for matching a given element against the allowable - * types. - * - * @param e AST node that represents the value of a target property. - * @return The matching type wrapped in an Optional object. - */ - private Optional> match(Element e) { - return this.options.stream().filter(option -> { - if (option instanceof TargetPropertyType) { - return ((TargetPropertyType) option).validate(e); - } else { - return ASTUtils.elementToSingleString(e) - .equalsIgnoreCase(option.toString()); - } - }).findAny(); - } + } - /** - * Return true if this union has an option that matches the given - * element. - * @param e The element to match against this type. - */ - @Override - public boolean validate(Element e) { - if (this.match(e).isPresent()) { - return true; - } - return false; - } - - /** - * Return a human-readable description of this type. If three is a - * default option, then indicate it. - */ - @Override - public String toString() { - return "one of the following: " + options.stream().map(option -> { - if (option == this.defaultOption) { - return option.toString() + " (default)"; - } else { - return option.toString(); - } - }).collect(Collectors.joining(", ")); - } + /** + * An array type of which the elements confirm to a given type. + * + * @author Marten Lohstroh + */ + public enum ArrayType implements TargetPropertyType { + STRING_ARRAY(PrimitiveType.STRING), + FILE_ARRAY(PrimitiveType.FILE); - } + /** Type parameter of this array type. */ + public TargetPropertyType type; /** - * An array type of which the elements confirm to a given type. - * - * @author Marten Lohstroh + * Private constructor to create a new array type. * + * @param type The type of elements in the array. */ - public enum ArrayType implements TargetPropertyType { - STRING_ARRAY(PrimitiveType.STRING), - FILE_ARRAY(PrimitiveType.FILE); - - /** - * Type parameter of this array type. - */ - public TargetPropertyType type; - - /** - * Private constructor to create a new array type. - * - * @param type The type of elements in the array. - */ - private ArrayType(TargetPropertyType type) { - this.type = type; - } - - /** - * Check that the passed in element represents an array and ensure that - * its elements are all of the correct type. - */ - @Override - public void check(Element e, String name, LFValidator v) { - Array array = e.getArray(); - if (array == null) { - TargetPropertyType.produceError(name, this.toString(), v); - } else { - List elements = array.getElements(); - for (int i = 0; i < elements.size(); i++) { - this.type.check(elements.get(i), name + "[" + i + "]", v); - } - } - } - - /** - * Return true of the given element is an array. - */ - @Override - public boolean validate(Element e) { - if (e.getArray() != null) { - return true; - } - return false; - } - - /** - * Return a human-readable description of this type. - */ - @Override - public String toString() { - return "an array of which each element is " + this.type.toString(); - } + private ArrayType(TargetPropertyType type) { + this.type = type; } /** - * Enumeration of Cmake build types. These are also mapped - * to Cargo profiles for the Rust target (see {@link org.lflang.generator.rust.RustTargetConfig}) - * - * @author Christian Menard + * Check that the passed in element represents an array and ensure that its elements are all of + * the correct type. */ - public enum BuildType { - RELEASE("Release"), - DEBUG("Debug"), - TEST("Test"), - REL_WITH_DEB_INFO("RelWithDebInfo"), - MIN_SIZE_REL("MinSizeRel"); - - /** - * Alias used in toString method. - */ - private final String alias; - - /** - * Private constructor for Cmake build types. - */ - BuildType(String alias) { - this.alias = alias; + @Override + public void check(Element e, String name, LFValidator v) { + Array array = e.getArray(); + if (array == null) { + TargetPropertyType.produceError(name, this.toString(), v); + } else { + List elements = array.getElements(); + for (int i = 0; i < elements.size(); i++) { + this.type.check(elements.get(i), name + "[" + i + "]", v); } + } + } - /** - * Return the alias. - */ - @Override - public String toString() { - return this.alias; - } + /** Return true of the given element is an array. */ + @Override + public boolean validate(Element e) { + if (e.getArray() != null) { + return true; + } + return false; } - /** - * Enumeration of coordination types. - * - * @author Marten Lohstroh - */ - public enum CoordinationType { - CENTRALIZED, DECENTRALIZED; - - /** - * Return the name in lower case. - */ - @Override - public String toString() { - return this.name().toLowerCase(); - } + /** Return a human-readable description of this type. */ + @Override + public String toString() { + return "an array of which each element is " + this.type.toString(); + } + } + + /** + * Enumeration of Cmake build types. These are also mapped to Cargo profiles for the Rust target + * (see {@link org.lflang.generator.rust.RustTargetConfig}) + * + * @author Christian Menard + */ + public enum BuildType { + RELEASE("Release"), + DEBUG("Debug"), + TEST("Test"), + REL_WITH_DEB_INFO("RelWithDebInfo"), + MIN_SIZE_REL("MinSizeRel"); + + /** Alias used in toString method. */ + private final String alias; + + /** Private constructor for Cmake build types. */ + BuildType(String alias) { + this.alias = alias; + } + + /** Return the alias. */ + @Override + public String toString() { + return this.alias; + } + } + + /** + * Enumeration of coordination types. + * + * @author Marten Lohstroh + */ + public enum CoordinationType { + CENTRALIZED, + DECENTRALIZED; + + /** Return the name in lower case. */ + @Override + public String toString() { + return this.name().toLowerCase(); + } + } + + /** + * Enumeration of clock synchronization modes. + * + *
      + *
    • OFF: The clock synchronization is universally off. + *
    • STARTUP: Clock synchronization occurs at startup only. + *
    • ON: Clock synchronization occurs at startup and at runtime. + *
    + * + * @author Edward A. Lee + */ + public enum ClockSyncMode { + OFF, + INIT, + ON; // TODO Discuss initial in now a mode keyword (same as startup) and cannot be used as target + // property value, thus changed it to init + // FIXME I could not test if this change breaks anything + + /** Return the name in lower case. */ + @Override + public String toString() { + return this.name().toLowerCase(); } + } + /** + * An interface for types associated with target properties. + * + * @author Marten Lohstroh + */ + public interface TargetPropertyType { /** - * Enumeration of clock synchronization modes. + * Return true if the the given Element is a valid instance of this type. * - *
      - *
    • OFF: The clock synchronization is universally off.
      • - *
    • STARTUP: Clock synchronization occurs at startup only.
      • - *
    • ON: Clock synchronization occurs at startup and at runtime.
      • - *
    - * - * @author Edward A. Lee + * @param e The Element to validate. + * @return True if the element conforms to this type, false otherwise. */ - public enum ClockSyncMode { - OFF, INIT, ON; // TODO Discuss initial in now a mode keyword (same as startup) and cannot be used as target property value, thus changed it to init - // FIXME I could not test if this change breaks anything - - /** - * Return the name in lower case. - */ - @Override - public String toString() { - return this.name().toLowerCase(); - } - } + public boolean validate(Element e); /** - * An interface for types associated with target properties. + * Check (recursively) the given Element against its associated type(s) and add found problems + * to the given list of errors. * - * @author Marten Lohstroh + * @param e The Element to type check. + * @param name The name of the target property. + * @param v A reference to the validator to report errors to. */ - public interface TargetPropertyType { - - /** - * Return true if the the given Element is a valid instance of this - * type. - * - * @param e The Element to validate. - * @return True if the element conforms to this type, false otherwise. - */ - public boolean validate(Element e); - - /** - * Check (recursively) the given Element against its associated type(s) - * and add found problems to the given list of errors. - * - * @param e The Element to type check. - * @param name The name of the target property. - * @param v A reference to the validator to report errors to. - */ - public void check(Element e, String name, LFValidator v); - - /** - * Helper function to produce an error during type checking. - * - * @param name The description of the target property. - * @param description The description of the type. - * @param v A reference to the validator to report errors to. - */ - public static void produceError(String name, String description, - LFValidator v) { - v.getTargetPropertyErrors().add("Target property '" + name - + "' is required to be " + description + "."); - } - } + public void check(Element e, String name, LFValidator v); /** - * Primitive types for target properties, each with a description used in - * error messages and predicate used for validating values. + * Helper function to produce an error during type checking. * - * @author Marten Lohstroh + * @param name The description of the target property. + * @param description The description of the type. + * @param v A reference to the validator to report errors to. */ - public enum PrimitiveType implements TargetPropertyType { - BOOLEAN("'true' or 'false'", - v -> ASTUtils.elementToSingleString(v).equalsIgnoreCase("true") - || ASTUtils.elementToSingleString(v).equalsIgnoreCase("false")), - INTEGER("an integer", v -> { - try { - Integer.parseInt(ASTUtils.elementToSingleString(v)); - } catch (NumberFormatException e) { - return false; - } - return true; + public static void produceError(String name, String description, LFValidator v) { + v.getTargetPropertyErrors() + .add("Target property '" + name + "' is required to be " + description + "."); + } + } + + /** + * Primitive types for target properties, each with a description used in error messages and + * predicate used for validating values. + * + * @author Marten Lohstroh + */ + public enum PrimitiveType implements TargetPropertyType { + BOOLEAN( + "'true' or 'false'", + v -> + ASTUtils.elementToSingleString(v).equalsIgnoreCase("true") + || ASTUtils.elementToSingleString(v).equalsIgnoreCase("false")), + INTEGER( + "an integer", + v -> { + try { + Integer.parseInt(ASTUtils.elementToSingleString(v)); + } catch (NumberFormatException e) { + return false; + } + return true; }), - NON_NEGATIVE_INTEGER("a non-negative integer", v -> { - try { - int result = Integer.parseInt(ASTUtils.elementToSingleString(v)); - if (result < 0) - return false; - } catch (NumberFormatException e) { - return false; - } - return true; + NON_NEGATIVE_INTEGER( + "a non-negative integer", + v -> { + try { + int result = Integer.parseInt(ASTUtils.elementToSingleString(v)); + if (result < 0) return false; + } catch (NumberFormatException e) { + return false; + } + return true; }), - TIME_VALUE("a time value with units", v -> - v.getKeyvalue() == null && v.getArray() == null - && v.getLiteral() == null && v.getId() == null + TIME_VALUE( + "a time value with units", + v -> + v.getKeyvalue() == null + && v.getArray() == null + && v.getLiteral() == null + && v.getId() == null && (v.getTime() == 0 || v.getUnit() != null)), - STRING("a string", v -> v.getLiteral() != null && !isCharLiteral(v.getLiteral()) || v.getId() != null), - FILE("a path to a file", STRING.validator); - - /** - * A description of this type, featured in error messages. - */ - private final String description; - - /** - * A predicate for determining whether a given Element conforms to this - * type. - */ - public final Predicate validator; - - /** - * Private constructor to create a new primitive type. - * @param description A textual description of the type that should - * start with "a/an". - * @param validator A predicate that returns true if a given Element - * conforms to this type. - */ - private PrimitiveType(String description, - Predicate validator) { - this.description = description; - this.validator = validator; - } + STRING( + "a string", + v -> v.getLiteral() != null && !isCharLiteral(v.getLiteral()) || v.getId() != null), + FILE("a path to a file", STRING.validator); - /** - * Return true if the the given Element is a valid instance of this type. - */ - public boolean validate(Element e) { - return this.validator.test(e); - } + /** A description of this type, featured in error messages. */ + private final String description; - /** - * Check (recursively) the given Element against its associated type(s) - * and add found problems to the given list of errors. - * - * @param e The element to type check. - * @param name The name of the target property. - * @param v The LFValidator to append errors to. - */ - public void check(Element e, String name, LFValidator v) { - if (!this.validate(e)) { - TargetPropertyType.produceError(name, this.description, v); - } - // If this is a file, perform an additional check to make sure - // the file actually exists. - // FIXME: premature because we first need a mechanism for looking up files! - // Looking in the same directory is too restrictive. Disabling this check for now. - /* - if (this == FILE) { - String file = ASTUtils.toSingleString(e); - - if (!FileConfig.fileExists(file, FileConfig.toPath(e.eResource().getURI()).toFile().getParent())) { - v.targetPropertyWarnings - .add("Could not find file: '" + file + "'."); - } - } - */ - } - - /** - * Return a textual description of this type. - */ - @Override - public String toString() { - return this.description; - } - - - private static boolean isCharLiteral(String s) { - return s.length() > 2 - && '\'' == s.charAt(0) - && '\'' == s.charAt(s.length() - 1); - } - } + /** A predicate for determining whether a given Element conforms to this type. */ + public final Predicate validator; /** - * Clock synchronization options. - * @author Marten Lohstroh + * Private constructor to create a new primitive type. + * + * @param description A textual description of the type that should start with "a/an". + * @param validator A predicate that returns true if a given Element conforms to this type. */ - public enum ClockSyncOption implements DictionaryElement { - ATTENUATION("attenuation", PrimitiveType.NON_NEGATIVE_INTEGER), - LOCAL_FEDERATES_ON("local-federates-on", PrimitiveType.BOOLEAN), - PERIOD("period", PrimitiveType.TIME_VALUE), - TEST_OFFSET("test-offset", PrimitiveType.TIME_VALUE), - TRIALS("trials", PrimitiveType.NON_NEGATIVE_INTEGER), - COLLECT_STATS("collect-stats", PrimitiveType.BOOLEAN); - - public final PrimitiveType type; - - private final String description; - - private ClockSyncOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } - - - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + private PrimitiveType(String description, Predicate validator) { + this.description = description; + this.validator = validator; + } - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + /** Return true if the the given Element is a valid instance of this type. */ + public boolean validate(Element e) { + return this.validator.test(e); } /** - * Docker options. - * @author Edward A. Lee - */ - public enum DockerOption implements DictionaryElement { - FROM("FROM", PrimitiveType.STRING); - - public final PrimitiveType type; - - private final String description; - - private DockerOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } - - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + * Check (recursively) the given Element against its associated type(s) and add found problems + * to the given list of errors. + * + * @param e The element to type check. + * @param name The name of the target property. + * @param v The LFValidator to append errors to. + */ + public void check(Element e, String name, LFValidator v) { + if (!this.validate(e)) { + TargetPropertyType.produceError(name, this.description, v); + } + // If this is a file, perform an additional check to make sure + // the file actually exists. + // FIXME: premature because we first need a mechanism for looking up files! + // Looking in the same directory is too restrictive. Disabling this check for now. + /* + if (this == FILE) { + String file = ASTUtils.toSingleString(e); + + if (!FileConfig.fileExists(file, FileConfig.toPath(e.eResource().getURI()).toFile().getParent())) { + v.targetPropertyWarnings + .add("Could not find file: '" + file + "'."); + } + } + */ + } - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + /** Return a textual description of this type. */ + @Override + public String toString() { + return this.description; } + private static boolean isCharLiteral(String s) { + return s.length() > 2 && '\'' == s.charAt(0) && '\'' == s.charAt(s.length() - 1); + } + } + + /** + * Clock synchronization options. + * + * @author Marten Lohstroh + */ + public enum ClockSyncOption implements DictionaryElement { + ATTENUATION("attenuation", PrimitiveType.NON_NEGATIVE_INTEGER), + LOCAL_FEDERATES_ON("local-federates-on", PrimitiveType.BOOLEAN), + PERIOD("period", PrimitiveType.TIME_VALUE), + TEST_OFFSET("test-offset", PrimitiveType.TIME_VALUE), + TRIALS("trials", PrimitiveType.NON_NEGATIVE_INTEGER), + COLLECT_STATS("collect-stats", PrimitiveType.BOOLEAN); + + public final PrimitiveType type; + + private final String description; + + private ClockSyncOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; + } - /** - * Platform options. - * @author Anirudh Rengarajan - */ - public enum PlatformOption implements DictionaryElement { - NAME("name", PrimitiveType.STRING), - BAUDRATE("baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER), - BOARD("board", PrimitiveType.STRING), - FLASH("flash", PrimitiveType.BOOLEAN), - PORT("port", PrimitiveType.STRING); + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; + } - public final PrimitiveType type; + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } - private final String description; + /** + * Docker options. + * + * @author Edward A. Lee + */ + public enum DockerOption implements DictionaryElement { + FROM("FROM", PrimitiveType.STRING); - private PlatformOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } + public final PrimitiveType type; + private final String description; - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + private DockerOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; + } - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; } - /** - * Coordination options. - * @author Edward A. Lee - */ - public enum CoordinationOption implements DictionaryElement { - ADVANCE_MESSAGE_INTERVAL("advance-message-interval", PrimitiveType.TIME_VALUE); + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } + + /** + * Platform options. + * + * @author Anirudh Rengarajan + */ + public enum PlatformOption implements DictionaryElement { + NAME("name", PrimitiveType.STRING), + BAUDRATE("baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER), + BOARD("board", PrimitiveType.STRING), + FLASH("flash", PrimitiveType.BOOLEAN), + PORT("port", PrimitiveType.STRING); + + public final PrimitiveType type; + + private final String description; + + private PlatformOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; + } - public final PrimitiveType type; + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; + } - private final String description; + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } - private CoordinationOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } + /** + * Coordination options. + * + * @author Edward A. Lee + */ + public enum CoordinationOption implements DictionaryElement { + ADVANCE_MESSAGE_INTERVAL("advance-message-interval", PrimitiveType.TIME_VALUE); + public final PrimitiveType type; - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + private final String description; - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + private CoordinationOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; } - /** - * Log levels in descending order of severity. - * @author Marten Lohstroh - */ - public enum LogLevel { - ERROR, WARN, INFO, LOG, DEBUG; - - /** - * Return the name in lower case. - */ - @Override - public String toString() { - return this.name().toLowerCase(); - } + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; } - /** - * Enumeration of supported platforms - */ - public enum Platform { - AUTO, - ARDUINO, - NRF52("Nrf52"), - LINUX("Linux"), - MAC("Darwin"), - ZEPHYR("Zephyr"), - WINDOWS("Windows"); - - String cMakeName; - Platform() { - this.cMakeName = this.toString(); - } - Platform(String cMakeName) { - this.cMakeName = cMakeName; - } + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } + + /** + * Log levels in descending order of severity. + * + * @author Marten Lohstroh + */ + public enum LogLevel { + ERROR, + WARN, + INFO, + LOG, + DEBUG; + + /** Return the name in lower case. */ + @Override + public String toString() { + return this.name().toLowerCase(); + } + } + + /** Enumeration of supported platforms */ + public enum Platform { + AUTO, + ARDUINO, + NRF52("Nrf52"), + LINUX("Linux"), + MAC("Darwin"), + ZEPHYR("Zephyr"), + WINDOWS("Windows"); + + String cMakeName; + + Platform() { + this.cMakeName = this.toString(); + } - /** - * Return the name in lower case. - */ - @Override - public String toString() { - return this.name().toLowerCase(); - } + Platform(String cMakeName) { + this.cMakeName = cMakeName; + } - /** - * Get the CMake name for the platform. - */ - public String getcMakeName() { - return this.cMakeName; - } + /** Return the name in lower case. */ + @Override + public String toString() { + return this.name().toLowerCase(); } - /** - * Supported schedulers. - * @author Soroush Bateni - */ - public enum SchedulerOption { - NP(false), // Non-preemptive - ADAPTIVE(false, List.of( + /** Get the CMake name for the platform. */ + public String getcMakeName() { + return this.cMakeName; + } + } + + /** + * Supported schedulers. + * + * @author Soroush Bateni + */ + public enum SchedulerOption { + NP(false), // Non-preemptive + ADAPTIVE( + false, + List.of( Path.of("scheduler_adaptive.c"), Path.of("worker_assignments.h"), Path.of("worker_states.h"), - Path.of("data_collection.h") - )), - GEDF_NP(true), // Global EDF non-preemptive - GEDF_NP_CI(true); // Global EDF non-preemptive with chain ID - // PEDF_NP(true); // Partitioned EDF non-preemptive (FIXME: To be re-added in a future PR) - - /** - * Indicate whether or not the scheduler prioritizes reactions by deadline. - */ - private final boolean prioritizesDeadline; - - /** Relative paths to files required by this scheduler. */ - private final List relativePaths; - - SchedulerOption(boolean prioritizesDeadline) { - this(prioritizesDeadline, null); - } + Path.of("data_collection.h"))), + GEDF_NP(true), // Global EDF non-preemptive + GEDF_NP_CI(true); // Global EDF non-preemptive with chain ID + // PEDF_NP(true); // Partitioned EDF non-preemptive (FIXME: To be re-added in a future PR) - SchedulerOption(boolean prioritizesDeadline, List relativePaths) { - this.prioritizesDeadline = prioritizesDeadline; - this.relativePaths = relativePaths; - } + /** Indicate whether or not the scheduler prioritizes reactions by deadline. */ + private final boolean prioritizesDeadline; - /** - * Return true if the scheduler prioritizes reactions by deadline. - */ - public boolean prioritizesDeadline() { - return this.prioritizesDeadline; - } + /** Relative paths to files required by this scheduler. */ + private final List relativePaths; - public List getRelativePaths() { - return relativePaths != null ? ImmutableList.copyOf(relativePaths) : - List.of(Path.of("scheduler_" + this + ".c")); - } + SchedulerOption(boolean prioritizesDeadline) { + this(prioritizesDeadline, null); + } - public static SchedulerOption getDefault() { - return NP; - } + SchedulerOption(boolean prioritizesDeadline, List relativePaths) { + this.prioritizesDeadline = prioritizesDeadline; + this.relativePaths = relativePaths; } - /** - * Tracing options. - * @author Edward A. Lee - */ - public enum TracingOption implements DictionaryElement { - TRACE_FILE_NAME("trace-file-name", PrimitiveType.STRING); + /** Return true if the scheduler prioritizes reactions by deadline. */ + public boolean prioritizesDeadline() { + return this.prioritizesDeadline; + } - public final PrimitiveType type; + public List getRelativePaths() { + return relativePaths != null + ? ImmutableList.copyOf(relativePaths) + : List.of(Path.of("scheduler_" + this + ".c")); + } - private final String description; + public static SchedulerOption getDefault() { + return NP; + } + } - private TracingOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } + /** + * Tracing options. + * + * @author Edward A. Lee + */ + public enum TracingOption implements DictionaryElement { + TRACE_FILE_NAME("trace-file-name", PrimitiveType.STRING); - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + public final PrimitiveType type; - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + private final String description; + + private TracingOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; } + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; + } + + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } } diff --git a/org.lflang/src/org/lflang/TimeUnit.java b/org.lflang/src/org/lflang/TimeUnit.java index 00c6314e51..a39bd505e8 100644 --- a/org.lflang/src/org/lflang/TimeUnit.java +++ b/org.lflang/src/org/lflang/TimeUnit.java @@ -38,82 +38,73 @@ * @author Clément Fournier, TU Dresden, INSA Rennes */ public enum TimeUnit { - /** Nanoseconds. */ - NANO("nsec", "ns", "nsecs"), - /** Microseconds. */ - MICRO("usec", "us", "usecs"), - /** Milliseconds. */ - MILLI("msec", "ms", "msecs"), - /** Seconds. */ - SECOND("sec", "s", "secs", "second", "seconds"), - /** Minute. */ // NOTE: Do not use MIN as the first entry. Common macro for minimum. - MINUTE("minute", "min", "mins", "minutes"), - /** Hour. */ - HOUR("hour", "h", "hours"), - /** Day. */ - DAY("day", "d", "days"), - WEEK("week", "weeks"), - ; + /** Nanoseconds. */ + NANO("nsec", "ns", "nsecs"), + /** Microseconds. */ + MICRO("usec", "us", "usecs"), + /** Milliseconds. */ + MILLI("msec", "ms", "msecs"), + /** Seconds. */ + SECOND("sec", "s", "secs", "second", "seconds"), + /** Minute. */ + // NOTE: Do not use MIN as the first entry. Common macro for minimum. + MINUTE("minute", "min", "mins", "minutes"), + /** Hour. */ + HOUR("hour", "h", "hours"), + /** Day. */ + DAY("day", "d", "days"), + WEEK("week", "weeks"), + ; - private final Set allNames; - private final String canonicalName; + private final Set allNames; + private final String canonicalName; - TimeUnit(String canonicalName, String... aliases) { - this.canonicalName = canonicalName; - this.allNames = immutableSetOf(canonicalName, aliases); - } + TimeUnit(String canonicalName, String... aliases) { + this.canonicalName = canonicalName; + this.allNames = immutableSetOf(canonicalName, aliases); + } + /** Returns the name that is preferred when displaying this unit. */ + public String getCanonicalName() { + return canonicalName; + } - /** - * Returns the name that is preferred when displaying this unit. - */ - public String getCanonicalName() { - return canonicalName; - } + /** Returns true if the given name is one of the aliases of this unit. */ + public boolean hasAlias(String name) { + return allNames.contains(name); + } - /** Returns true if the given name is one of the aliases of this unit. */ - public boolean hasAlias(String name) { - return allNames.contains(name); + /** + * Returns the constant corresponding to the given name. The comparison is case-sensitive. + * + * @return Null if the parameter is null, otherwise a non-null constant + * @throws IllegalArgumentException If the name doesn't correspond to any constant + */ + public static TimeUnit fromName(String name) { + if (name == null) { + return null; } + return Arrays.stream(values()) + .filter(it -> it.hasAlias(name)) + .findFirst() + .orElseThrow(() -> new IllegalArgumentException("invalid name '" + name + "'")); + } - - /** - * Returns the constant corresponding to the given name. - * The comparison is case-sensitive. - * - * @return Null if the parameter is null, otherwise a non-null constant - * @throws IllegalArgumentException If the name doesn't correspond to any constant - */ - public static TimeUnit fromName(String name) { - if (name == null) { - return null; - } - return Arrays.stream(values()) - .filter(it -> it.hasAlias(name)) - .findFirst() - .orElseThrow(() -> new IllegalArgumentException("invalid name '" + name + "'")); + /** Returns true if the parameter is null, or it is the alias of a valid time unit. */ + public static boolean isValidUnit(String name) { + if (name == null) { + return false; } + return Arrays.stream(values()).anyMatch(it -> it.hasAlias(name)); + } - /** - * Returns true if the parameter is null, or it is the - * alias of a valid time unit. - */ - public static boolean isValidUnit(String name) { - if (name == null) { - return false; - } - return Arrays.stream(values()).anyMatch(it -> it.hasAlias(name)); - } + /** Returns a list of all possible aliases for time values. */ + public static List list() { + return Arrays.stream(values()).flatMap(it -> it.allNames.stream()).collect(Collectors.toList()); + } - /** - * Returns a list of all possible aliases for time values. - */ - public static List list() { - return Arrays.stream(values()).flatMap(it -> it.allNames.stream()).collect(Collectors.toList()); - } - - @Override - public String toString() { - return this.canonicalName; - } + @Override + public String toString() { + return this.canonicalName; + } } diff --git a/org.lflang/src/org/lflang/TimeValue.java b/org.lflang/src/org/lflang/TimeValue.java index f008a0ae4b..f0bb94820c 100644 --- a/org.lflang/src/org/lflang/TimeValue.java +++ b/org.lflang/src/org/lflang/TimeValue.java @@ -1,27 +1,27 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang; @@ -33,172 +33,152 @@ */ public final class TimeValue implements Comparable { - /** - * The maximum value of this type. This is approximately equal to 292 years. - */ - public static final TimeValue MAX_VALUE = new TimeValue(Long.MAX_VALUE, TimeUnit.NANO); - /** - * A time value equal to zero. - */ - public static final TimeValue ZERO = new TimeValue(0, null); - - - /** - * Primitive numerical representation of this time value, - * to be interpreted in terms the associated time unit. - */ - public final long time; - - /** - * Units associated with this time value. May be null. - */ - public final TimeUnit unit; - - /** - * Maximum size of a deadline in primitive representation. - * NOTE: if we were to use an unsigned data type this would be - * 0xFFFFFFFFFFFF - */ - public static final long MAX_LONG_DEADLINE = Long.decode("0x7FFFFFFFFFFF"); - - /** - * Create a new time value. - * - * @throws IllegalArgumentException If time is non-zero and the unit is null - */ - public TimeValue(long time, TimeUnit unit) { - if (unit == null && time != 0) { - throw new IllegalArgumentException("Non-zero time values must have a unit"); - } - this.time = time; - this.unit = unit; - } - - @Override - public boolean equals(Object t1) { - if (t1 instanceof TimeValue) { - return this.compareTo((TimeValue) t1) == 0; - } - return false; - } - - public static int compare(TimeValue t1, TimeValue t2) { - if (t1.isEarlierThan(t2)) { - return -1; - } - if (t2.isEarlierThan(t1)) { - return 1; - } - return 0; - } - - private static long makeNanosecs(long time, TimeUnit unit) { - if (unit == null) { - return time; // == 0, see constructor. - } - switch (unit) { - case NANO: - return time; - case MICRO: - return time * 1000; - case MILLI: - return time * 1_000_000; - case SECOND: - return time * 1_000_000_000; - case MINUTE: - return time * 60_000_000_000L; - case HOUR: - return time * 3_600_000_000_000L; - case DAY: - return time * 86_400_000_000_000L; - case WEEK: - return time * 604_800_016_558_522L; - } - throw new AssertionError("unreachable"); - } - - /** - * Returns whether this time value is earlier than another. - */ - public boolean isEarlierThan(TimeValue other) { - return this.compareTo(other) < 0; + /** The maximum value of this type. This is approximately equal to 292 years. */ + public static final TimeValue MAX_VALUE = new TimeValue(Long.MAX_VALUE, TimeUnit.NANO); + /** A time value equal to zero. */ + public static final TimeValue ZERO = new TimeValue(0, null); + + /** + * Primitive numerical representation of this time value, to be interpreted in terms the + * associated time unit. + */ + public final long time; + + /** Units associated with this time value. May be null. */ + public final TimeUnit unit; + + /** + * Maximum size of a deadline in primitive representation. NOTE: if we were to use an unsigned + * data type this would be 0xFFFFFFFFFFFF + */ + public static final long MAX_LONG_DEADLINE = Long.decode("0x7FFFFFFFFFFF"); + + /** + * Create a new time value. + * + * @throws IllegalArgumentException If time is non-zero and the unit is null + */ + public TimeValue(long time, TimeUnit unit) { + if (unit == null && time != 0) { + throw new IllegalArgumentException("Non-zero time values must have a unit"); } - - @Override - public int compareTo(TimeValue o) { - return Long.compare(this.toNanoSeconds(), o.toNanoSeconds()); + this.time = time; + this.unit = unit; + } + + @Override + public boolean equals(Object t1) { + if (t1 instanceof TimeValue) { + return this.compareTo((TimeValue) t1) == 0; } + return false; + } - /** - * Return the magnitude of this value, as expressed in the - * {@linkplain #getUnit() unit} of this value. - */ - public long getMagnitude() { - return time; + public static int compare(TimeValue t1, TimeValue t2) { + if (t1.isEarlierThan(t2)) { + return -1; } - - /** - * Units associated with this time value. May be null, - * but only if the magnitude is zero. - */ - public TimeUnit getUnit() { - return unit; + if (t2.isEarlierThan(t1)) { + return 1; } + return 0; + } - /** - * Get this time value in number of nanoseconds. - */ - public long toNanoSeconds() { - return makeNanosecs(time, unit); + private static long makeNanosecs(long time, TimeUnit unit) { + if (unit == null) { + return time; // == 0, see constructor. } - - /** - * Return a string representation of this time value. - */ - public String toString() { - return unit != null ? time + " " + unit.getCanonicalName() - : Long.toString(time); + switch (unit) { + case NANO: + return time; + case MICRO: + return time * 1000; + case MILLI: + return time * 1_000_000; + case SECOND: + return time * 1_000_000_000; + case MINUTE: + return time * 60_000_000_000L; + case HOUR: + return time * 3_600_000_000_000L; + case DAY: + return time * 86_400_000_000_000L; + case WEEK: + return time * 604_800_016_558_522L; } - - /** Return the latest of both values. */ - public static TimeValue max(TimeValue t1, TimeValue t2) { - return t1.isEarlierThan(t2) ? t2 : t1; + throw new AssertionError("unreachable"); + } + + /** Returns whether this time value is earlier than another. */ + public boolean isEarlierThan(TimeValue other) { + return this.compareTo(other) < 0; + } + + @Override + public int compareTo(TimeValue o) { + return Long.compare(this.toNanoSeconds(), o.toNanoSeconds()); + } + + /** + * Return the magnitude of this value, as expressed in the {@linkplain #getUnit() unit} of this + * value. + */ + public long getMagnitude() { + return time; + } + + /** Units associated with this time value. May be null, but only if the magnitude is zero. */ + public TimeUnit getUnit() { + return unit; + } + + /** Get this time value in number of nanoseconds. */ + public long toNanoSeconds() { + return makeNanosecs(time, unit); + } + + /** Return a string representation of this time value. */ + public String toString() { + return unit != null ? time + " " + unit.getCanonicalName() : Long.toString(time); + } + + /** Return the latest of both values. */ + public static TimeValue max(TimeValue t1, TimeValue t2) { + return t1.isEarlierThan(t2) ? t2 : t1; + } + + /** Return the earliest of both values. */ + public static TimeValue min(TimeValue t1, TimeValue t2) { + return t1.isEarlierThan(t2) ? t1 : t2; + } + + /** + * Return the sum of this duration and the one represented by b. + * + *

    The unit of the returned TimeValue will be the minimum of the units of both operands except + * if only one of the units is TimeUnit.NONE. In that case, the unit of the other input is used. + * + * @param b The right operand + * @return A new TimeValue (the current value will not be affected) + */ + public TimeValue add(TimeValue b) { + // Figure out the actual sum + final long sumOfNumbers; + try { + sumOfNumbers = Math.addExact(this.toNanoSeconds(), b.toNanoSeconds()); + } catch (ArithmeticException overflow) { + return MAX_VALUE; } - /** Return the earliest of both values. */ - public static TimeValue min(TimeValue t1, TimeValue t2) { - return t1.isEarlierThan(t2) ? t1 : t2; + if (this.unit == null || b.unit == null) { + // A time value with no unit is necessarily zero. So + // if this is null, (this + b) == b, if b is none, (this+b) == this. + return b.unit == null ? this : b; } - - /** - * Return the sum of this duration and the one represented by b. - *

    - * The unit of the returned TimeValue will be the minimum - * of the units of both operands except if only one of the units - * is TimeUnit.NONE. In that case, the unit of the other input is used. - * - * @param b The right operand - * @return A new TimeValue (the current value will not be affected) - */ - public TimeValue add(TimeValue b) { - // Figure out the actual sum - final long sumOfNumbers; - try { - sumOfNumbers = Math.addExact(this.toNanoSeconds(), b.toNanoSeconds()); - } catch (ArithmeticException overflow) { - return MAX_VALUE; - } - - if (this.unit == null || b.unit == null) { - // A time value with no unit is necessarily zero. So - // if this is null, (this + b) == b, if b is none, (this+b) == this. - return b.unit == null ? this : b; - } - boolean isThisUnitSmallerThanBUnit = this.unit.compareTo(b.unit) <= 0; - TimeUnit smallestUnit = isThisUnitSmallerThanBUnit ? this.unit : b.unit; - // Find the appropriate divider to bring sumOfNumbers from nanoseconds to returnUnit - var unitDivider = makeNanosecs(1, smallestUnit); - return new TimeValue(sumOfNumbers / unitDivider, smallestUnit); - } - + boolean isThisUnitSmallerThanBUnit = this.unit.compareTo(b.unit) <= 0; + TimeUnit smallestUnit = isThisUnitSmallerThanBUnit ? this.unit : b.unit; + // Find the appropriate divider to bring sumOfNumbers from nanoseconds to returnUnit + var unitDivider = makeNanosecs(1, smallestUnit); + return new TimeValue(sumOfNumbers / unitDivider, smallestUnit); + } } diff --git a/org.lflang/src/org/lflang/ast/ASTUtils.java b/org.lflang/src/org/lflang/ast/ASTUtils.java index 26d4e0d6b0..91ff7ac69a 100644 --- a/org.lflang/src/org/lflang/ast/ASTUtils.java +++ b/org.lflang/src/org/lflang/ast/ASTUtils.java @@ -25,6 +25,9 @@ package org.lflang.ast; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Iterators; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; @@ -39,7 +42,6 @@ import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; - import org.eclipse.emf.common.util.EList; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EStructuralFeature; @@ -54,7 +56,6 @@ import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.IteratorExtensions; import org.eclipse.xtext.xbase.lib.StringExtensions; - import org.lflang.InferredType; import org.lflang.Target; import org.lflang.TimeUnit; @@ -100,1793 +101,1768 @@ import org.lflang.lf.WidthTerm; import org.lflang.util.StringUtil; -import com.google.common.collect.HashMultimap; -import com.google.common.collect.Iterables; -import com.google.common.collect.Iterators; - /** * A helper class for modifying and analyzing the AST. + * * @author Marten Lohstroh * @author Edward A. Lee * @author Christian Menard */ public class ASTUtils { - /** - * The Lingua Franca factory for creating new AST nodes. - */ - public static final LfFactory factory = LfFactory.eINSTANCE; - - /** - * The Lingua Franca feature package. - */ - public static final LfPackage featurePackage = LfPackage.eINSTANCE; - - /* Match an abbreviated form of a float literal. */ - private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); - - /** - * A mapping from Reactor features to corresponding Mode features for collecting contained elements. - */ - private static final Map reactorModeFeatureMap = Map.of( - featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), - featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), - featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), - featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), - featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), - featurePackage.getReactor_Timers(), featurePackage.getMode_Timers() - ); - - - /** - * Get all reactors defined in the given resource. - * @param resource the resource to extract reactors from - * @return An iterable over all reactors found in the resource - */ - public static List getAllReactors(Resource resource) { - return StreamSupport.stream(IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) - .filter(Reactor.class::isInstance) - .map(Reactor.class::cast) - .collect(Collectors.toList()); - } - - /** - * Find connections in the given resource that would be conflicting writes if they were not located in mutually - * exclusive modes. - * - * @param resource The AST. - * @return a list of connections being able to be transformed - */ - public static Collection findConflictingConnectionsInModalReactors(Resource resource) { - var transform = new HashSet(); - - for (Reactor reactor : getAllReactors(resource)) { - if (!reactor.getModes().isEmpty()) { // Only for modal reactors - var allWriters = HashMultimap., EObject>create(); - - // Collect destinations - for (var rea : allReactions(reactor)) { - for (var eff : rea.getEffects()) { - if (eff.getVariable() instanceof Port) { - allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); - } - } - } - for (var con : ASTUtils.collectElements(reactor, featurePackage.getReactor_Connections(), false, true)) { - for (var port : con.getRightPorts()) { - allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); - } - } - - // Handle conflicting writers - for (var key : allWriters.keySet()) { - var writers = allWriters.get(key); - if (writers.size() > 1) { // has multiple sources - var writerModes = HashMultimap.create(); - // find modes - for (var writer : writers) { - if (writer.eContainer() instanceof Mode) { - writerModes.put((Mode) writer.eContainer(), writer); - } else { - writerModes.put(null, writer); - } - } - // Conflicting connection can only be handled if.. - if (!writerModes.containsKey(null) && // no writer is on root level (outside of modes) and... - writerModes.keySet().stream().map(writerModes::get).allMatch(writersInMode -> // all writers in a mode are either... - writersInMode.size() == 1 || // the only writer or... - writersInMode.stream().allMatch(w -> w instanceof Reaction) // all are reactions and hence ordered - )) { - // Add connections to transform list - writers.stream().filter(w -> w instanceof Connection).forEach(c -> transform.add((Connection) c)); - } - } - } - } - } - - return transform; - } - - /** - * Return the enclosing reactor of an LF EObject in a reactor or mode. - * @param obj the LF model element - * @return the reactor or null - */ - public static Reactor getEnclosingReactor(EObject obj) { - if (obj.eContainer() instanceof Reactor) { - return (Reactor) obj.eContainer(); - } else if (obj.eContainer() instanceof Mode) { - return (Reactor) obj.eContainer().eContainer(); - } - return null; - } - - /** - * Return the main reactor in the given resource if there is one, null otherwise. - */ - public static Reactor findMainReactor(Resource resource) { - return IteratorExtensions.findFirst( - Iterators.filter(resource.getAllContents(), Reactor.class), - Reactor::isMain - ); - } - - /** - * Find the main reactor and change it to a federated reactor. - * Return true if the transformation was successful (or the given resource - * already had a federated reactor); return false otherwise. - */ - public static boolean makeFederated(Resource resource) { - // Find the main reactor - Reactor r = findMainReactor(resource); - if (r == null) { - return false; - } - r.setMain(false); - r.setFederated(true); - return true; - } - - /** - * Change the target name to 'newTargetName'. - * For example, change C to CCpp. - */ - public static boolean changeTargetName(Resource resource, String newTargetName) { - targetDecl(resource).setName(newTargetName); - return true; - } - - /** - * Return the target of the file in which the given node lives. - */ - public static Target getTarget(EObject object) { - TargetDecl targetDecl = targetDecl(object.eResource()); - return Target.fromDecl(targetDecl); - } - - /** - * Add a new target property to the given resource. - * This also creates a config object if the resource does not yey have one. - * - * @param resource The resource to modify - * @param name Name of the property to add - * @param value Value to be assigned to the property - */ - public static boolean addTargetProperty(final Resource resource, final String name, final Element value) { - var config = targetDecl(resource).getConfig(); - if (config == null) { - config = LfFactory.eINSTANCE.createKeyValuePairs(); - targetDecl(resource).setConfig(config); - } - final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); - newProperty.setName(name); - newProperty.setValue(value); - config.getPairs().add(newProperty); - return true; - } - - /** - * Return true if the connection involves multiple ports on the left or right side of the connection, or - * if the port on the left or right of the connection involves a bank of reactors or a multiport. - * @param connection The connection. - */ - public static boolean hasMultipleConnections(Connection connection) { - if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { - return true; - } - VarRef leftPort = connection.getLeftPorts().get(0); - VarRef rightPort = connection.getRightPorts().get(0); - Instantiation leftContainer = leftPort.getContainer(); - Instantiation rightContainer = rightPort.getContainer(); - Port leftPortAsPort = (Port) leftPort.getVariable(); - Port rightPortAsPort = (Port) rightPort.getVariable(); - return leftPortAsPort.getWidthSpec() != null - || leftContainer != null && leftContainer.getWidthSpec() != null - || rightPortAsPort.getWidthSpec() != null - || rightContainer != null && rightContainer.getWidthSpec() != null; - } - - /** - * Produce a unique identifier within a reactor based on a - * given based name. If the name does not exists, it is returned; - * if does exist, an index is appended that makes the name unique. - * @param reactor The reactor to find a unique identifier within. - * @param name The name to base the returned identifier on. - */ - public static String getUniqueIdentifier(Reactor reactor, String name) { - LinkedHashSet vars = new LinkedHashSet<>(); - allActions(reactor).forEach(it -> vars.add(it.getName())); - allTimers(reactor).forEach(it -> vars.add(it.getName())); - allParameters(reactor).forEach(it -> vars.add(it.getName())); - allInputs(reactor).forEach(it -> vars.add(it.getName())); - allOutputs(reactor).forEach(it -> vars.add(it.getName())); - allStateVars(reactor).forEach(it -> vars.add(it.getName())); - allInstantiations(reactor).forEach(it -> vars.add(it.getName())); - - int index = 0; - String suffix = ""; - boolean exists = true; - while (exists) { - String id = name + suffix; - if (IterableExtensions.exists(vars, it -> it.equals(id))) { - suffix = "_" + index; - index++; - } else { - exists = false; - } - } - return name + suffix; - } - - //////////////////////////////// - //// Utility functions for supporting inheritance and modes - - /** - * Given a reactor class, return a list of all its actions, - * which includes actions of base classes that it extends. - * This also includes actions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allActions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); - } - - /** - * Given a reactor class, return a list of all its connections, - * which includes connections of base classes that it extends. - * This also includes connections in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allConnections(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); - } - - /** - * Given a reactor class, return a list of all its inputs, - * which includes inputs of base classes that it extends. - * If the base classes include a cycle, where X extends Y and Y extends X, - * then return only the input defined in the base class. - * The returned list may be empty. - * @param definition Reactor class definition. - */ - public static List allInputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); - } - - /** A list of all ports of {@code definition}, in an unspecified order. */ - public static List allPorts(Reactor definition) { - return Stream.concat(ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()).toList(); - } - - /** - * Given a reactor class, return a list of all its preambles, - * which includes preambles of base classes that it extends. - * If the base classes include a cycle, where X extends Y and Y extends X, - * then return only the input defined in the base class. - * The returned list may be empty. - * @param definition Reactor class definition. - */ - public static List allPreambles(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Preambles()); - } - - /** - * Given a reactor class, return a list of all its instantiations, - * which includes instantiations of base classes that it extends. - * This also includes instantiations in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allInstantiations(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); - } - - /** - * Given a reactor Class, return a set of include names for - * interacting reactors which includes all instantiations of base class that it extends. - * - * @param r Reactor Class - * */ - public static HashSet allIncludes(Reactor r) { - var set = new HashSet(); - for (var i : allInstantiations(r)) - { - set.add(CUtil.getName(new TypeParameterizedReactor(i))); - } - return set; - } - - /* - * Given a reactor class, return a stream of reactor classes that it instantiates. - * @param definition Reactor class definition. - * @return A stream of reactor classes. - */ - public static Stream allNestedClasses(Reactor definition) { - return new HashSet<>(ASTUtils.allInstantiations(definition)).stream() - .map(Instantiation::getReactorClass) - .map(ASTUtils::toDefinition); - } - - /** - * Given a reactor class, return a list of all its methods, - * which includes methods of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allMethods(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); - } - - /** - * Given a reactor class, return a list of all its outputs, - * which includes outputs of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allOutputs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); - } - - /** - * Given a reactor class, return a list of all its parameters, - * which includes parameters of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allParameters(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); - } - - /** - * Given a reactor class, return a list of all its reactions, - * which includes reactions of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allReactions(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); - } - - /** - * Given a reactor class, return a list of all its watchdogs. - * - * @param definition Reactor class definition - * @return List - */ - public static List allWatchdogs(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); - } - - /** - * Given a reactor class, return a list of all its state variables, - * which includes state variables of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allStateVars(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); - } - - /** - * Given a reactor class, return a list of all its timers, - * which includes timers of base classes that it extends. - * This also includes reactions in modes, returning a flattened - * view over all modes. - * @param definition Reactor class definition. - */ - public static List allTimers(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); - } - - /** - * Given a reactor class, returns a list of all its modes, - * which includes modes of base classes that it extends. - * @param definition Reactor class definition. - */ - public static List allModes(Reactor definition) { - return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); - } - - public static List recursiveChildren(ReactorInstance r) { - List ret = new ArrayList<>(); - ret.add(r); - for (var child: r.children) { - ret.addAll(recursiveChildren(child)); - } - return ret; - } - - /** - * Return all the superclasses of the specified reactor - * in deepest-first order. For example, if A extends B and C, and - * B and C both extend D, this will return the list [D, B, C, A]. - * Duplicates are removed. If the specified reactor does not extend - * any other reactor, then return an empty list. - * If a cycle is found, where X extends Y and Y extends X, or if - * a superclass is declared that is not found, then return null. - * @param reactor The specified reactor. - */ - public static LinkedHashSet superClasses(Reactor reactor) { - return superClasses(reactor, new LinkedHashSet<>()); - } - - /** - * Return all the file-level preambles in the files that define the - * specified class and its superclasses in deepest-first order. - * Duplicates are removed. If there are no file-level preambles, - * then return an empty list. - * If a cycle is found, where X extends Y and Y extends X, or if - * a superclass is declared that is not found, then return null. - * @param reactor The specified reactor. - */ - public static LinkedHashSet allFileLevelPreambles(Reactor reactor) { - return allFileLevelPreambles(reactor, new LinkedHashSet<>()); - } - - /** - * Collect elements of type T from the class hierarchy and modes - * defined by a given reactor definition. - * @param definition The reactor definition. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - public static List collectElements(Reactor definition, EStructuralFeature feature) { - return ASTUtils.collectElements(definition, feature, true, true); - } - - /** - * Collect elements of type T contained in given reactor definition, including - * modes and the class hierarchy defined depending on configuration. - * @param definition The reactor definition. - * @param feature The structual model elements to collect. - * @param includeSuperClasses Whether to include elements in super classes. - * @param includeModes Whether to include elements in modes. - * @param The type of elements to collect (e.g., Port, Timer, etc.) - * @return A list of all elements of type T found - */ - @SuppressWarnings("unchecked") - public static List collectElements(Reactor definition, EStructuralFeature feature, boolean includeSuperClasses, boolean includeModes) { - List result = new ArrayList<>(); - - if (includeSuperClasses) { - // Add elements of elements defined in superclasses. - LinkedHashSet s = superClasses(definition); - if (s != null) { - for (Reactor superClass : s) { - result.addAll((EList) superClass.eGet(feature)); - } + /** The Lingua Franca factory for creating new AST nodes. */ + public static final LfFactory factory = LfFactory.eINSTANCE; + + /** The Lingua Franca feature package. */ + public static final LfPackage featurePackage = LfPackage.eINSTANCE; + + /* Match an abbreviated form of a float literal. */ + private static final Pattern ABBREVIATED_FLOAT = Pattern.compile("[+\\-]?\\.\\d+[\\deE+\\-]*"); + + /** + * A mapping from Reactor features to corresponding Mode features for collecting contained + * elements. + */ + private static final Map reactorModeFeatureMap = + Map.of( + featurePackage.getReactor_Actions(), featurePackage.getMode_Actions(), + featurePackage.getReactor_Connections(), featurePackage.getMode_Connections(), + featurePackage.getReactor_Instantiations(), featurePackage.getMode_Instantiations(), + featurePackage.getReactor_Reactions(), featurePackage.getMode_Reactions(), + featurePackage.getReactor_StateVars(), featurePackage.getMode_StateVars(), + featurePackage.getReactor_Timers(), featurePackage.getMode_Timers()); + + /** + * Get all reactors defined in the given resource. + * + * @param resource the resource to extract reactors from + * @return An iterable over all reactors found in the resource + */ + public static List getAllReactors(Resource resource) { + return StreamSupport.stream( + IteratorExtensions.toIterable(resource.getAllContents()).spliterator(), false) + .filter(Reactor.class::isInstance) + .map(Reactor.class::cast) + .collect(Collectors.toList()); + } + + /** + * Find connections in the given resource that would be conflicting writes if they were not + * located in mutually exclusive modes. + * + * @param resource The AST. + * @return a list of connections being able to be transformed + */ + public static Collection findConflictingConnectionsInModalReactors( + Resource resource) { + var transform = new HashSet(); + + for (Reactor reactor : getAllReactors(resource)) { + if (!reactor.getModes().isEmpty()) { // Only for modal reactors + var allWriters = HashMultimap., EObject>create(); + + // Collect destinations + for (var rea : allReactions(reactor)) { + for (var eff : rea.getEffects()) { + if (eff.getVariable() instanceof Port) { + allWriters.put(Tuples.pair(eff.getContainer(), eff.getVariable()), rea); } + } } - - // Add elements of the current reactor. - result.addAll((EList) definition.eGet(feature)); - - if (includeModes && reactorModeFeatureMap.containsKey(feature)) { - var modeFeature = reactorModeFeatureMap.get(feature); - // Add elements of elements defined in modes. - for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { - insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); - } - } - - return result; - } - - /** - * Adds the elements into the given list at a location matching to their textual position. - * - * When creating a flat view onto reactor elements including modes, the final list must be ordered according - * to the textual positions. - * - * Example: - * reactor R { - * reaction // -> is R.reactions[0] - * mode M { - * reaction // -> is R.mode[0].reactions[0] - * reaction // -> is R.mode[0].reactions[1] - * } - * reaction // -> is R.reactions[1] - * } - * In this example, it is important that the reactions in the mode are inserted between the top-level - * reactions to retain the correct global reaction ordering, which will be derived from this flattened view. - * - * @param list The list to add the elements into. - * @param elements The elements to add. - * @param mode The mode containing the elements. - * @param The type of elements to add (e.g., Port, Timer, etc.) - */ - private static void insertModeElementsAtTextualPosition(List list, List elements, Mode mode) { - if (elements.isEmpty()) { - return; // Nothing to add + for (var con : + ASTUtils.collectElements( + reactor, featurePackage.getReactor_Connections(), false, true)) { + for (var port : con.getRightPorts()) { + allWriters.put(Tuples.pair(port.getContainer(), port.getVariable()), con); + } } - var idx = list.size(); - if (idx > 0) { - // If there are elements in the list, first check if the last element has the same container as the mode. - // I.e. we don't want to compare textual positions of different reactors (super classes) - if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { - var modeAstNode = NodeModelUtils.getNode(mode); - if (modeAstNode != null) { - var modePos = modeAstNode.getOffset(); - // Now move the insertion index from the last element forward as long as this element has a textual - // position after the mode. - do { - var astNode = NodeModelUtils.getNode(list.get(idx - 1)); - if (astNode != null && astNode.getOffset() > modePos) { - idx--; - } else { - break; // Insertion index is ok. - } - } while (idx > 0); - } + // Handle conflicting writers + for (var key : allWriters.keySet()) { + var writers = allWriters.get(key); + if (writers.size() > 1) { // has multiple sources + var writerModes = HashMultimap.create(); + // find modes + for (var writer : writers) { + if (writer.eContainer() instanceof Mode) { + writerModes.put((Mode) writer.eContainer(), writer); + } else { + writerModes.put(null, writer); + } } - } - list.addAll(idx, elements); - } - - public static Iterable allElementsOfClass( - Resource resource, - Class elementClass - ) { - //noinspection StaticPseudoFunctionalStyleMethod - return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); - } - - //////////////////////////////// - //// Utility functions for translating AST nodes into text - - /** - * Translate the given code into its textual representation - * with {@code CodeMap.Correspondence} tags inserted, or - * return the empty string if {@code node} is {@code null}. - * This method should be used to generate code. - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toText(EObject node) { - if (node == null) return ""; - return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); - } - - /** - * Translate the given code into its textual representation - * without {@code CodeMap.Correspondence} tags, or return - * the empty string if {@code node} is {@code null}. - * This method should be used for analyzing AST nodes in - * cases where they are easiest to analyze as strings. - * @param node AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String toOriginalText(EObject node) { - if (node == null) return ""; - return ToText.instance.doSwitch(node); - } - - /** - * Return an integer representation of the given element. - * - * Internally, this method uses Integer.decode, so it will - * also understand hexadecimal, binary, etc. - * - * @param e The element to be rendered as an integer. - */ - public static Integer toInteger(Element e) { - return Integer.decode(e.getLiteral()); - } - - /** - * Return a time value based on the given element. - * - * @param e The element to be rendered as a time value. - */ - public static TimeValue toTimeValue(Element e) { - return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); - } - - /** - * Returns the time value represented by the given AST node. - */ - public static TimeValue toTimeValue(Time e) { - if (!isValidTime(e)) { - // invalid unit, will have been reported by validator - throw new IllegalArgumentException(); - } - return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); - } - - /** - * Return a boolean based on the given element. - * - * @param e The element to be rendered as a boolean. - */ - public static boolean toBoolean(Element e) { - return elementToSingleString(e).equalsIgnoreCase("true"); - } - - /** - * Given the right-hand side of a target property, return a string that - * represents the given value/ - * - * If the given value is not a literal or and id (but for instance and array or dict), - * an empty string is returned. If the element is a string, any quotes are removed. - * - * @param e The right-hand side of a target property. - */ - public static String elementToSingleString(Element e) { - if (e.getLiteral() != null) { - return StringUtil.removeQuotes(e.getLiteral()).trim(); - } else if (e.getId() != null) { - return e.getId(); - } - return ""; - } - - /** - * Given the right-hand side of a target property, return a list with all - * the strings that the property lists. - * - * Arrays are traversed, so strings are collected recursively. Empty strings - * are ignored; they are not added to the list. - * @param value The right-hand side of a target property. - */ - public static List elementToListOfStrings(Element value) { - List elements = new ArrayList<>(); - if (value.getArray() != null) { - for (Element element : value.getArray().getElements()) { - elements.addAll(elementToListOfStrings(element)); - } - return elements; - } else { - String v = elementToSingleString(value); - if (!v.isEmpty()) { - elements.add(v); + // Conflicting connection can only be handled if.. + if (!writerModes.containsKey(null) + && // no writer is on root level (outside of modes) and... + writerModes.keySet().stream() + .map(writerModes::get) + .allMatch( + writersInMode -> // all writers in a mode are either... + writersInMode.size() == 1 + || // the only writer or... + writersInMode.stream() + .allMatch( + w -> + w + instanceof + Reaction) // all are reactions and hence ordered + )) { + // Add connections to transform list + writers.stream() + .filter(w -> w instanceof Connection) + .forEach(c -> transform.add((Connection) c)); } + } } - return elements; - } - - /** - * Convert key-value pairs in an Element to a map, assuming that both the key - * and the value are strings. - */ - public static Map elementToStringMaps(Element value) { - Map elements = new HashMap<>(); - for (var element: value.getKeyvalue().getPairs()) { - elements.put( - element.getName().trim(), - StringUtil.removeQuotes(elementToSingleString(element.getValue())) - ); - } - return elements; - } - - // Various utility methods to convert various data types to Elements - - /** - * Convert a map to key-value pairs in an Element. - */ - public static Element toElement(Map map) { - Element e = LfFactory.eINSTANCE.createElement(); - if (map.size() == 0) return null; - else { - var kv = LfFactory.eINSTANCE.createKeyValuePairs(); - for (var entry : map.entrySet()) { - var pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(entry.getKey()); - var element = LfFactory.eINSTANCE.createElement(); - element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); - pair.setValue(element); - kv.getPairs().add(pair); - } - e.setKeyvalue(kv); - } - - return e; - } - - /** - * Given a single string, convert it into its AST representation. - * {@code addQuotes} controls if the generated representation should be - * accompanied by double quotes ("") or not. - */ - private static Element toElement(String str, boolean addQuotes) { - if (str == null) return null; - var strToReturn = addQuotes? StringUtil.addDoubleQuotes(str):str; - Element e = LfFactory.eINSTANCE.createElement(); - e.setLiteral(strToReturn); - return e; - } - - /** - * Given a single string, convert it into its AST representation. - */ - public static Element toElement(String str) { - return toElement(str, true); - } - - /** - * Given a list of strings, convert it into its AST representation. - * Stores the list in the Array field of the element, unless the list only has one string, - * in which case it is stored in the Literal field. Returns null if the provided list is empty. - */ - public static Element toElement(List list) { - Element e = LfFactory.eINSTANCE.createElement(); - if (list.size() == 0) return null; - else if (list.size() == 1) { - return toElement(list.get(0)); - } else { - var arr = LfFactory.eINSTANCE.createArray(); - for (String s : list) { - arr.getElements().add(ASTUtils.toElement(s)); - } - e.setArray(arr); + } + } + + return transform; + } + + /** + * Return the enclosing reactor of an LF EObject in a reactor or mode. + * + * @param obj the LF model element + * @return the reactor or null + */ + public static Reactor getEnclosingReactor(EObject obj) { + if (obj.eContainer() instanceof Reactor) { + return (Reactor) obj.eContainer(); + } else if (obj.eContainer() instanceof Mode) { + return (Reactor) obj.eContainer().eContainer(); + } + return null; + } + + /** Return the main reactor in the given resource if there is one, null otherwise. */ + public static Reactor findMainReactor(Resource resource) { + return IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), Reactor::isMain); + } + + /** + * Find the main reactor and change it to a federated reactor. Return true if the transformation + * was successful (or the given resource already had a federated reactor); return false otherwise. + */ + public static boolean makeFederated(Resource resource) { + // Find the main reactor + Reactor r = findMainReactor(resource); + if (r == null) { + return false; + } + r.setMain(false); + r.setFederated(true); + return true; + } + + /** Change the target name to 'newTargetName'. For example, change C to CCpp. */ + public static boolean changeTargetName(Resource resource, String newTargetName) { + targetDecl(resource).setName(newTargetName); + return true; + } + + /** Return the target of the file in which the given node lives. */ + public static Target getTarget(EObject object) { + TargetDecl targetDecl = targetDecl(object.eResource()); + return Target.fromDecl(targetDecl); + } + + /** + * Add a new target property to the given resource. This also creates a config object if the + * resource does not yey have one. + * + * @param resource The resource to modify + * @param name Name of the property to add + * @param value Value to be assigned to the property + */ + public static boolean addTargetProperty( + final Resource resource, final String name, final Element value) { + var config = targetDecl(resource).getConfig(); + if (config == null) { + config = LfFactory.eINSTANCE.createKeyValuePairs(); + targetDecl(resource).setConfig(config); + } + final var newProperty = LfFactory.eINSTANCE.createKeyValuePair(); + newProperty.setName(name); + newProperty.setValue(value); + config.getPairs().add(newProperty); + return true; + } + + /** + * Return true if the connection involves multiple ports on the left or right side of the + * connection, or if the port on the left or right of the connection involves a bank of reactors + * or a multiport. + * + * @param connection The connection. + */ + public static boolean hasMultipleConnections(Connection connection) { + if (connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1) { + return true; + } + VarRef leftPort = connection.getLeftPorts().get(0); + VarRef rightPort = connection.getRightPorts().get(0); + Instantiation leftContainer = leftPort.getContainer(); + Instantiation rightContainer = rightPort.getContainer(); + Port leftPortAsPort = (Port) leftPort.getVariable(); + Port rightPortAsPort = (Port) rightPort.getVariable(); + return leftPortAsPort.getWidthSpec() != null + || leftContainer != null && leftContainer.getWidthSpec() != null + || rightPortAsPort.getWidthSpec() != null + || rightContainer != null && rightContainer.getWidthSpec() != null; + } + + /** + * Produce a unique identifier within a reactor based on a given based name. If the name does not + * exists, it is returned; if does exist, an index is appended that makes the name unique. + * + * @param reactor The reactor to find a unique identifier within. + * @param name The name to base the returned identifier on. + */ + public static String getUniqueIdentifier(Reactor reactor, String name) { + LinkedHashSet vars = new LinkedHashSet<>(); + allActions(reactor).forEach(it -> vars.add(it.getName())); + allTimers(reactor).forEach(it -> vars.add(it.getName())); + allParameters(reactor).forEach(it -> vars.add(it.getName())); + allInputs(reactor).forEach(it -> vars.add(it.getName())); + allOutputs(reactor).forEach(it -> vars.add(it.getName())); + allStateVars(reactor).forEach(it -> vars.add(it.getName())); + allInstantiations(reactor).forEach(it -> vars.add(it.getName())); + + int index = 0; + String suffix = ""; + boolean exists = true; + while (exists) { + String id = name + suffix; + if (IterableExtensions.exists(vars, it -> it.equals(id))) { + suffix = "_" + index; + index++; + } else { + exists = false; + } + } + return name + suffix; + } + + //////////////////////////////// + //// Utility functions for supporting inheritance and modes + + /** + * Given a reactor class, return a list of all its actions, which includes actions of base classes + * that it extends. This also includes actions in modes, returning a flattened view over all + * modes. + * + * @param definition Reactor class definition. + */ + public static List allActions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Actions()); + } + + /** + * Given a reactor class, return a list of all its connections, which includes connections of base + * classes that it extends. This also includes connections in modes, returning a flattened view + * over all modes. + * + * @param definition Reactor class definition. + */ + public static List allConnections(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Connections()); + } + + /** + * Given a reactor class, return a list of all its inputs, which includes inputs of base classes + * that it extends. If the base classes include a cycle, where X extends Y and Y extends X, then + * return only the input defined in the base class. The returned list may be empty. + * + * @param definition Reactor class definition. + */ + public static List allInputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Inputs()); + } + + /** A list of all ports of {@code definition}, in an unspecified order. */ + public static List allPorts(Reactor definition) { + return Stream.concat( + ASTUtils.allInputs(definition).stream(), ASTUtils.allOutputs(definition).stream()) + .toList(); + } + + /** + * Given a reactor class, return a list of all its preambles, which includes preambles of base + * classes that it extends. If the base classes include a cycle, where X extends Y and Y extends + * X, then return only the input defined in the base class. The returned list may be empty. + * + * @param definition Reactor class definition. + */ + public static List allPreambles(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Preambles()); + } + + /** + * Given a reactor class, return a list of all its instantiations, which includes instantiations + * of base classes that it extends. This also includes instantiations in modes, returning a + * flattened view over all modes. + * + * @param definition Reactor class definition. + */ + public static List allInstantiations(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); + } + + /** + * Given a reactor Class, return a set of include names for interacting reactors which includes + * all instantiations of base class that it extends. + * + * @param r Reactor Class + */ + public static HashSet allIncludes(Reactor r) { + var set = new HashSet(); + for (var i : allInstantiations(r)) { + set.add(CUtil.getName(new TypeParameterizedReactor(i))); + } + return set; + } + + /* + * Given a reactor class, return a stream of reactor classes that it instantiates. + * @param definition Reactor class definition. + * @return A stream of reactor classes. + */ + public static Stream allNestedClasses(Reactor definition) { + return new HashSet<>(ASTUtils.allInstantiations(definition)) + .stream().map(Instantiation::getReactorClass).map(ASTUtils::toDefinition); + } + + /** + * Given a reactor class, return a list of all its methods, which includes methods of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allMethods(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Methods()); + } + + /** + * Given a reactor class, return a list of all its outputs, which includes outputs of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allOutputs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Outputs()); + } + + /** + * Given a reactor class, return a list of all its parameters, which includes parameters of base + * classes that it extends. + * + * @param definition Reactor class definition. + */ + public static List allParameters(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Parameters()); + } + + /** + * Given a reactor class, return a list of all its reactions, which includes reactions of base + * classes that it extends. This also includes reactions in modes, returning a flattened view over + * all modes. + * + * @param definition Reactor class definition. + */ + public static List allReactions(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Reactions()); + } + + /** + * Given a reactor class, return a list of all its watchdogs. + * + * @param definition Reactor class definition + * @return List + */ + public static List allWatchdogs(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Watchdogs()); + } + + /** + * Given a reactor class, return a list of all its state variables, which includes state variables + * of base classes that it extends. This also includes reactions in modes, returning a flattened + * view over all modes. + * + * @param definition Reactor class definition. + */ + public static List allStateVars(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_StateVars()); + } + + /** + * Given a reactor class, return a list of all its timers, which includes timers of base classes + * that it extends. This also includes reactions in modes, returning a flattened view over all + * modes. + * + * @param definition Reactor class definition. + */ + public static List allTimers(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Timers()); + } + + /** + * Given a reactor class, returns a list of all its modes, which includes modes of base classes + * that it extends. + * + * @param definition Reactor class definition. + */ + public static List allModes(Reactor definition) { + return ASTUtils.collectElements(definition, featurePackage.getReactor_Modes()); + } + + public static List recursiveChildren(ReactorInstance r) { + List ret = new ArrayList<>(); + ret.add(r); + for (var child : r.children) { + ret.addAll(recursiveChildren(child)); + } + return ret; + } + + /** + * Return all the superclasses of the specified reactor in deepest-first order. For example, if A + * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates + * are removed. If the specified reactor does not extend any other reactor, then return an empty + * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared + * that is not found, then return null. + * + * @param reactor The specified reactor. + */ + public static LinkedHashSet superClasses(Reactor reactor) { + return superClasses(reactor, new LinkedHashSet<>()); + } + + /** + * Return all the file-level preambles in the files that define the specified class and its + * superclasses in deepest-first order. Duplicates are removed. If there are no file-level + * preambles, then return an empty list. If a cycle is found, where X extends Y and Y extends X, + * or if a superclass is declared that is not found, then return null. + * + * @param reactor The specified reactor. + */ + public static LinkedHashSet allFileLevelPreambles(Reactor reactor) { + return allFileLevelPreambles(reactor, new LinkedHashSet<>()); + } + + /** + * Collect elements of type T from the class hierarchy and modes defined by a given reactor + * definition. + * + * @param definition The reactor definition. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + public static List collectElements( + Reactor definition, EStructuralFeature feature) { + return ASTUtils.collectElements(definition, feature, true, true); + } + + /** + * Collect elements of type T contained in given reactor definition, including modes and the class + * hierarchy defined depending on configuration. + * + * @param definition The reactor definition. + * @param feature The structual model elements to collect. + * @param includeSuperClasses Whether to include elements in super classes. + * @param includeModes Whether to include elements in modes. + * @param The type of elements to collect (e.g., Port, Timer, etc.) + * @return A list of all elements of type T found + */ + @SuppressWarnings("unchecked") + public static List collectElements( + Reactor definition, + EStructuralFeature feature, + boolean includeSuperClasses, + boolean includeModes) { + List result = new ArrayList<>(); + + if (includeSuperClasses) { + // Add elements of elements defined in superclasses. + LinkedHashSet s = superClasses(definition); + if (s != null) { + for (Reactor superClass : s) { + result.addAll((EList) superClass.eGet(feature)); } - return e; - } - - /** - * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit inside an Element. - */ - public static Element toElement(TimeValue tv) { - Element e = LfFactory.eINSTANCE.createElement(); - e.setTime((int)tv.time); - if (tv.unit != null) { - e.setUnit(tv.unit.toString()); - } - return e; - } - - public static Element toElement(boolean val) { - return toElement(Boolean.toString(val), false); - } - - public static Element toElement(int val) { - return toElement(Integer.toString(val), false); - } - - /** - * Translate the given type into its textual representation, but - * do not append any array specifications or type arguments. - * @param type AST node to render as string. - * @return Textual representation of the given argument. - */ - public static String baseType(Type type) { - if (type != null) { - if (type.getCode() != null) { - return toText(type.getCode()); + } + } + + // Add elements of the current reactor. + result.addAll((EList) definition.eGet(feature)); + + if (includeModes && reactorModeFeatureMap.containsKey(feature)) { + var modeFeature = reactorModeFeatureMap.get(feature); + // Add elements of elements defined in modes. + for (Mode mode : includeSuperClasses ? allModes(definition) : definition.getModes()) { + insertModeElementsAtTextualPosition(result, (EList) mode.eGet(modeFeature), mode); + } + } + + return result; + } + + /** + * Adds the elements into the given list at a location matching to their textual position. + * + *

    When creating a flat view onto reactor elements including modes, the final list must be + * ordered according to the textual positions. + * + *

    Example: reactor R { reaction // -> is R.reactions[0] mode M { reaction // -> is + * R.mode[0].reactions[0] reaction // -> is R.mode[0].reactions[1] } reaction // -> is + * R.reactions[1] } In this example, it is important that the reactions in the mode are inserted + * between the top-level reactions to retain the correct global reaction ordering, which will be + * derived from this flattened view. + * + * @param list The list to add the elements into. + * @param elements The elements to add. + * @param mode The mode containing the elements. + * @param The type of elements to add (e.g., Port, Timer, etc.) + */ + private static void insertModeElementsAtTextualPosition( + List list, List elements, Mode mode) { + if (elements.isEmpty()) { + return; // Nothing to add + } + + var idx = list.size(); + if (idx > 0) { + // If there are elements in the list, first check if the last element has the same container + // as the mode. + // I.e. we don't want to compare textual positions of different reactors (super classes) + if (mode.eContainer() == list.get(list.size() - 1).eContainer()) { + var modeAstNode = NodeModelUtils.getNode(mode); + if (modeAstNode != null) { + var modePos = modeAstNode.getOffset(); + // Now move the insertion index from the last element forward as long as this element has + // a textual + // position after the mode. + do { + var astNode = NodeModelUtils.getNode(list.get(idx - 1)); + if (astNode != null && astNode.getOffset() > modePos) { + idx--; } else { - if (type.isTime()) { - return "time"; - } else { - StringBuilder result = new StringBuilder(type.getId()); - - for (String s : convertToEmptyListIfNull(type.getStars())) { - result.append(s); - } - return result.toString(); - } - } - } - return ""; - } - - /** - * Report whether the given literal is zero or not. - * @param literal AST node to inspect. - * @return True if the given literal denotes the constant {@code 0}, false - * otherwise. - */ - public static boolean isZero(String literal) { - try { - if (literal != null && - Integer.parseInt(literal) == 0) { - return true; + break; // Insertion index is ok. } - } catch (NumberFormatException e) { - // Not an int. + } while (idx > 0); } - return false; - } - - /** - * Report whether the given expression is zero or not. - * - * @param expr AST node to inspect. - * @return True if the given value denotes the constant {@code 0}, false otherwise. - */ - public static boolean isZero(Expression expr) { - if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); - } - return false; - } - - /** - * Report whether the given string literal is an integer number or not. - * - * @param literal AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Integer.decode(literal); - } catch (NumberFormatException e) { - return false; - } - return true; - } - - /** - * Report whether the given string literal is a boolean value or not. - * @param literal AST node to inspect. - * @return True if the given value is a boolean, false otherwise. - */ - public static boolean isBoolean(String literal) { - return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); - } + } + } + list.addAll(idx, elements); + } + + public static Iterable allElementsOfClass( + Resource resource, Class elementClass) { + //noinspection StaticPseudoFunctionalStyleMethod + return Iterables.filter(IteratorExtensions.toIterable(resource.getAllContents()), elementClass); + } + + //////////////////////////////// + //// Utility functions for translating AST nodes into text + + /** + * Translate the given code into its textual representation with {@code CodeMap.Correspondence} + * tags inserted, or return the empty string if {@code node} is {@code null}. This method should + * be used to generate code. + * + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toText(EObject node) { + if (node == null) return ""; + return CodeMap.Correspondence.tag(node, toOriginalText(node), node instanceof Code); + } + + /** + * Translate the given code into its textual representation without {@code CodeMap.Correspondence} + * tags, or return the empty string if {@code node} is {@code null}. This method should be used + * for analyzing AST nodes in cases where they are easiest to analyze as strings. + * + * @param node AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String toOriginalText(EObject node) { + if (node == null) return ""; + return ToText.instance.doSwitch(node); + } + + /** + * Return an integer representation of the given element. + * + *

    Internally, this method uses Integer.decode, so it will also understand hexadecimal, binary, + * etc. + * + * @param e The element to be rendered as an integer. + */ + public static Integer toInteger(Element e) { + return Integer.decode(e.getLiteral()); + } + + /** + * Return a time value based on the given element. + * + * @param e The element to be rendered as a time value. + */ + public static TimeValue toTimeValue(Element e) { + return new TimeValue(e.getTime(), TimeUnit.fromName(e.getUnit())); + } + + /** Returns the time value represented by the given AST node. */ + public static TimeValue toTimeValue(Time e) { + if (!isValidTime(e)) { + // invalid unit, will have been reported by validator + throw new IllegalArgumentException(); + } + return new TimeValue(e.getInterval(), TimeUnit.fromName(e.getUnit())); + } + + /** + * Return a boolean based on the given element. + * + * @param e The element to be rendered as a boolean. + */ + public static boolean toBoolean(Element e) { + return elementToSingleString(e).equalsIgnoreCase("true"); + } + + /** + * Given the right-hand side of a target property, return a string that represents the given + * value/ + * + *

    If the given value is not a literal or and id (but for instance and array or dict), an empty + * string is returned. If the element is a string, any quotes are removed. + * + * @param e The right-hand side of a target property. + */ + public static String elementToSingleString(Element e) { + if (e.getLiteral() != null) { + return StringUtil.removeQuotes(e.getLiteral()).trim(); + } else if (e.getId() != null) { + return e.getId(); + } + return ""; + } + + /** + * Given the right-hand side of a target property, return a list with all the strings that the + * property lists. + * + *

    Arrays are traversed, so strings are collected recursively. Empty strings are ignored; they + * are not added to the list. + * + * @param value The right-hand side of a target property. + */ + public static List elementToListOfStrings(Element value) { + List elements = new ArrayList<>(); + if (value.getArray() != null) { + for (Element element : value.getArray().getElements()) { + elements.addAll(elementToListOfStrings(element)); + } + return elements; + } else { + String v = elementToSingleString(value); + if (!v.isEmpty()) { + elements.add(v); + } + } + return elements; + } + + /** + * Convert key-value pairs in an Element to a map, assuming that both the key and the value are + * strings. + */ + public static Map elementToStringMaps(Element value) { + Map elements = new HashMap<>(); + for (var element : value.getKeyvalue().getPairs()) { + elements.put( + element.getName().trim(), + StringUtil.removeQuotes(elementToSingleString(element.getValue()))); + } + return elements; + } + + // Various utility methods to convert various data types to Elements + + /** Convert a map to key-value pairs in an Element. */ + public static Element toElement(Map map) { + Element e = LfFactory.eINSTANCE.createElement(); + if (map.size() == 0) return null; + else { + var kv = LfFactory.eINSTANCE.createKeyValuePairs(); + for (var entry : map.entrySet()) { + var pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(entry.getKey()); + var element = LfFactory.eINSTANCE.createElement(); + element.setLiteral(StringUtil.addDoubleQuotes(entry.getValue())); + pair.setValue(element); + kv.getPairs().add(pair); + } + e.setKeyvalue(kv); + } + + return e; + } + + /** + * Given a single string, convert it into its AST representation. {@code addQuotes} controls if + * the generated representation should be accompanied by double quotes ("") or not. + */ + private static Element toElement(String str, boolean addQuotes) { + if (str == null) return null; + var strToReturn = addQuotes ? StringUtil.addDoubleQuotes(str) : str; + Element e = LfFactory.eINSTANCE.createElement(); + e.setLiteral(strToReturn); + return e; + } + + /** Given a single string, convert it into its AST representation. */ + public static Element toElement(String str) { + return toElement(str, true); + } + + /** + * Given a list of strings, convert it into its AST representation. Stores the list in the Array + * field of the element, unless the list only has one string, in which case it is stored in the + * Literal field. Returns null if the provided list is empty. + */ + public static Element toElement(List list) { + Element e = LfFactory.eINSTANCE.createElement(); + if (list.size() == 0) return null; + else if (list.size() == 1) { + return toElement(list.get(0)); + } else { + var arr = LfFactory.eINSTANCE.createArray(); + for (String s : list) { + arr.getElements().add(ASTUtils.toElement(s)); + } + e.setArray(arr); + } + return e; + } + + /** + * Convert a TimeValue to its AST representation. The value is type-cast to int in order to fit + * inside an Element. + */ + public static Element toElement(TimeValue tv) { + Element e = LfFactory.eINSTANCE.createElement(); + e.setTime((int) tv.time); + if (tv.unit != null) { + e.setUnit(tv.unit.toString()); + } + return e; + } + + public static Element toElement(boolean val) { + return toElement(Boolean.toString(val), false); + } + + public static Element toElement(int val) { + return toElement(Integer.toString(val), false); + } + + /** + * Translate the given type into its textual representation, but do not append any array + * specifications or type arguments. + * + * @param type AST node to render as string. + * @return Textual representation of the given argument. + */ + public static String baseType(Type type) { + if (type != null) { + if (type.getCode() != null) { + return toText(type.getCode()); + } else { + if (type.isTime()) { + return "time"; + } else { + StringBuilder result = new StringBuilder(type.getId()); - /** - * Report whether the given string literal is a float value or not. - * @param literal AST node to inspect. - * @return True if the given value is a float, false otherwise. - */ - public static boolean isFloat(String literal) { - try { - //noinspection ResultOfMethodCallIgnored - Float.parseFloat(literal); - } catch (NumberFormatException e) { - return false; + for (String s : convertToEmptyListIfNull(type.getStars())) { + result.append(s); + } + return result.toString(); } + } + } + return ""; + } + + /** + * Report whether the given literal is zero or not. + * + * @param literal AST node to inspect. + * @return True if the given literal denotes the constant {@code 0}, false otherwise. + */ + public static boolean isZero(String literal) { + try { + if (literal != null && Integer.parseInt(literal) == 0) { return true; - } - - /** - * Report whether the given code is an integer number or not. - * @param code AST node to inspect. - * @return True if the given code is an integer, false otherwise. - */ - public static boolean isInteger(Code code) { - return isInteger(toText(code)); - } - - /** - * Report whether the given expression is an integer number or not. - * @param expr AST node to inspect. - * @return True if the given value is an integer, false otherwise. - */ - public static boolean isInteger(Expression expr) { - if (expr instanceof Literal) { - return isInteger(((Literal) expr).getLiteral()); - } else if (expr instanceof Code) { - return isInteger((Code) expr); + } + } catch (NumberFormatException e) { + // Not an int. + } + return false; + } + + /** + * Report whether the given expression is zero or not. + * + * @param expr AST node to inspect. + * @return True if the given value denotes the constant {@code 0}, false otherwise. + */ + public static boolean isZero(Expression expr) { + if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; + } + + /** + * Report whether the given string literal is an integer number or not. + * + * @param literal AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Integer.decode(literal); + } catch (NumberFormatException e) { + return false; + } + return true; + } + + /** + * Report whether the given string literal is a boolean value or not. + * + * @param literal AST node to inspect. + * @return True if the given value is a boolean, false otherwise. + */ + public static boolean isBoolean(String literal) { + return literal.equalsIgnoreCase("true") || literal.equalsIgnoreCase("false"); + } + + /** + * Report whether the given string literal is a float value or not. + * + * @param literal AST node to inspect. + * @return True if the given value is a float, false otherwise. + */ + public static boolean isFloat(String literal) { + try { + //noinspection ResultOfMethodCallIgnored + Float.parseFloat(literal); + } catch (NumberFormatException e) { + return false; + } + return true; + } + + /** + * Report whether the given code is an integer number or not. + * + * @param code AST node to inspect. + * @return True if the given code is an integer, false otherwise. + */ + public static boolean isInteger(Code code) { + return isInteger(toText(code)); + } + + /** + * Report whether the given expression is an integer number or not. + * + * @param expr AST node to inspect. + * @return True if the given value is an integer, false otherwise. + */ + public static boolean isInteger(Expression expr) { + if (expr instanceof Literal) { + return isInteger(((Literal) expr).getLiteral()); + } else if (expr instanceof Code) { + return isInteger((Code) expr); + } + return false; + } + + /** + * Report whether the given expression denotes a valid time or not. + * + * @param expr AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Expression expr) { + if (expr instanceof ParameterReference) { + return isOfTimeType(((ParameterReference) expr).getParameter()); + } else if (expr instanceof Time) { + return isValidTime((Time) expr); + } else if (expr instanceof Literal) { + return isZero(((Literal) expr).getLiteral()); + } + return false; + } + + /** + * Report whether the given time denotes a valid time or not. + * + * @param t AST node to inspect. + * @return True if the argument denotes a valid time, false otherwise. + */ + public static boolean isValidTime(Time t) { + if (t == null) return false; + String unit = t.getUnit(); + return t.getInterval() == 0 || TimeUnit.isValidUnit(unit); + } + + /** If the initializer contains exactly one expression, return it. Otherwise, return null. */ + public static Expression asSingleExpr(Initializer init) { + if (init == null) { + return null; + } + var exprs = init.getExprs(); + return exprs.size() == 1 ? exprs.get(0) : null; + } + + public static boolean isSingleExpr(Initializer init) { + // todo expand that to = initialization + if (init == null) { + return false; + } + var exprs = init.getExprs(); + return exprs.size() == 1; + } + + public static boolean isListInitializer(Initializer init) { + return init != null && !isSingleExpr(init); + } + + /** + * Return the type of a declaration with the given (nullable) explicit type, and the given + * (nullable) initializer. If the explicit type is null, then the type is inferred from the + * initializer. Only two types can be inferred: "time" and "timeList". Return the "undefined" type + * if neither can be inferred. + * + * @param type Explicit type declared on the declaration + * @param init The initializer expression + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Type type, Initializer init) { + if (type != null) { + return InferredType.fromAST(type); + } else if (init == null) { + return InferredType.undefined(); + } + + var single = asSingleExpr(init); + if (single != null) { + // If there is a single element in the list, and it is a proper + // time value with units, we infer the type "time". + if (single instanceof ParameterReference) { + return getInferredType(((ParameterReference) single).getParameter()); + } else if (single instanceof Time) { + return InferredType.time(); + } + } else if (init.getExprs().size() > 1) { + // If there are multiple elements in the list, and there is at + // least one proper time value with units, and all other elements + // are valid times (including zero without units), we infer the + // type "time list". + var allValidTime = true; + var foundNonZero = false; + + for (var e : init.getExprs()) { + if (!ASTUtils.isValidTime(e)) { + allValidTime = false; } - return false; - } - - /** - * Report whether the given expression denotes a valid time or not. - * @param expr AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Expression expr) { - if (expr instanceof ParameterReference) { - return isOfTimeType(((ParameterReference) expr).getParameter()); - } else if (expr instanceof Time) { - return isValidTime((Time) expr); - } else if (expr instanceof Literal) { - return isZero(((Literal) expr).getLiteral()); + if (!ASTUtils.isZero(e)) { + foundNonZero = true; } - return false; - } - - /** - * Report whether the given time denotes a valid time or not. - * @param t AST node to inspect. - * @return True if the argument denotes a valid time, false otherwise. - */ - public static boolean isValidTime(Time t) { - if (t == null) return false; - String unit = t.getUnit(); - return t.getInterval() == 0 || - TimeUnit.isValidUnit(unit); - } - - /** - * If the initializer contains exactly one expression, - * return it. Otherwise, return null. - */ - public static Expression asSingleExpr(Initializer init) { - if (init == null) { - return null; + } + + if (allValidTime && foundNonZero) { + // Conservatively, no bounds are inferred; the returned type + // is a variable-size list. + return InferredType.timeList(); + } + } + return InferredType.undefined(); + } + + /** + * Given a parameter, return an inferred type. Only two types can be inferred: "time" and + * "timeList". Return the "undefined" type if neither can be inferred. + * + * @param p A parameter to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(Parameter p) { + return getInferredType(p.getType(), p.getInit()); + } + + /** + * Given a state variable, return an inferred type. Only two types can be inferred: "time" and + * "timeList". Return the "undefined" type if neither can be inferred. + * + * @param s A state variable to infer the type of. + * @return The inferred type, or "undefined" if none could be inferred. + */ + public static InferredType getInferredType(StateVar s) { + return getInferredType(s.getType(), s.getInit()); + } + + /** + * Construct an inferred type from an "action" AST node based on its declared type. If no type is + * declared, return the "undefined" type. + * + * @param a An action to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Action a) { + return getInferredType(a.getType(), null); + } + + /** + * Construct an inferred type from a "port" AST node based on its declared type. If no type is + * declared, return the "undefined" type. + * + * @param p A port to construct an inferred type object for. + * @return The inferred type, or "undefined" if none was declared. + */ + public static InferredType getInferredType(Port p) { + return getInferredType(p.getType(), null); + } + + /** + * If the given string can be recognized as a floating-point number that has a leading decimal + * point, prepend the string with a zero and return it. Otherwise, return the original string. + * + * @param literal A string might be recognizable as a floating point number with a leading decimal + * point. + * @return an equivalent representation of literal + * + */ + public static String addZeroToLeadingDot(String literal) { + Matcher m = ABBREVIATED_FLOAT.matcher(literal); + if (m.matches()) { + return literal.replace(".", "0."); + } + return literal; + } + + /** + * Return true if the specified port is a multiport. + * + * @param port The port. + * @return True if the port is a multiport. + */ + public static boolean isMultiport(Port port) { + return port.getWidthSpec() != null; + } + + //////////////////////////////// + //// Utility functions for translating AST nodes into text + // This is a continuation of a large section of ASTUtils.xtend + // with the same name. + + /** + * Generate code for referencing a port, action, or timer. + * + * @param reference The reference to the variable. + */ + public static String generateVarRef(VarRef reference) { + var prefix = ""; + if (reference.getContainer() != null) { + prefix = reference.getContainer().getName() + "."; + } + return prefix + reference.getVariable().getName(); + } + + /** Assuming that the given expression denotes a valid time literal, return a time value. */ + public static TimeValue getLiteralTimeValue(Expression expr) { + if (expr instanceof Time) { + return toTimeValue((Time) expr); + } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { + return TimeValue.ZERO; + } else { + return null; + } + } + + /** If the parameter is of time type, return its default value. Otherwise, return null. */ + public static TimeValue getDefaultAsTimeValue(Parameter p) { + if (isOfTimeType(p)) { + var init = asSingleExpr(p.getInit()); + if (init != null) { + return getLiteralTimeValue(init); + } + } + return null; + } + + /** Return whether the given state variable is inferred to a time type. */ + public static boolean isOfTimeType(StateVar state) { + InferredType t = getInferredType(state); + return t.isTime && !t.isList; + } + + /** Return whether the given parameter is inferred to a time type. */ + public static boolean isOfTimeType(Parameter param) { + InferredType t = getInferredType(param); + return t.isTime && !t.isList; + } + + /** + * Given a parameter, return its initial value. The initial value is a list of instances of + * Expressions. + * + *

    If the instantiations argument is null or an empty list, then the value returned is simply + * the default value given when the parameter is defined. + * + *

    If a list of instantiations is given, then the first instantiation is required to be an + * instantiation of the reactor class that is parameterized by the parameter. I.e., + * + * 

    +   *      parameter.eContainer == instantiations.get(0).reactorClass
+   *
    + * + *

    If a second instantiation is given, then it is required to be an instantiation of a reactor + * class that contains the first instantiation. That is, + * + * 

    +   *      instantiations.get(0).eContainer == instantiations.get(1).reactorClass
+   *
    + * + *

    More generally, for all 0 <= i < instantiations.size - 1, + * + * 

    +   *      instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass
+   *
    + * + *

    If any of these conditions is not satisfied, then an IllegalArgumentException will be + * thrown. + * + *

    Note that this chain of reactions cannot be inferred from the parameter because in each of + * the predicates above, there may be more than one instantiation that can appear on the right + * hand side of the predicate. + * + *

    For example, consider the following program: + * + * 

         reactor A(x:int(1)) {}
+   *      reactor B(y:int(2)) {
+   *          a1 = new A(x = y);
+   *          a2 = new A(x = -1);
+   *      }
+   *      reactor C(z:int(3)) {
+   *          b1 = new B(y = z);
+   *          b2 = new B(y = -2);
+   *      }
+   *
    + * + *

    Notice that there are a total of four instances of reactor class A. Then + * + * 

    +   *      initialValue(x, null) returns 1
+   *      initialValue(x, [a1]) returns 2
+   *      initialValue(x, [a2]) returns -1
+   *      initialValue(x, [a1, b1]) returns 3
+   *      initialValue(x, [a2, b1]) returns -1
+   *      initialValue(x, [a1, b2]) returns -2
+   *      initialValue(x, [a2, b2]) returns -1
+   *
    + * + *

    (Actually, in each of the above cases, the returned value is a list with one entry, a + * Literal, e.g. ["1"]). + * + *

    There are two instances of reactor class B. + * + * 

    +   *      initialValue(y, null) returns 2
+   *      initialValue(y, [a1]) throws an IllegalArgumentException
+   *      initialValue(y, [b1]) returns 3
+   *      initialValue(y, [b2]) returns -2
+   *
    + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * @return The value of the parameter. + * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the + * reactor class that is parameterized by the respective parameter or if the chain of + * instantiations is not nested. + */ + public static List initialValue( + Parameter parameter, List instantiations) { + // If instantiations are given, then check to see whether this parameter gets overridden in + // the first of those instantiations. + if (instantiations != null && instantiations.size() > 0) { + // Check to be sure that the instantiation is in fact an instantiation + // of the reactor class for which this is a parameter. + Instantiation instantiation = instantiations.get(0); + + if (!belongsTo(parameter, instantiation)) { + throw new IllegalArgumentException( + "Parameter " + + parameter.getName() + + " is not a parameter of reactor instance " + + instantiation.getName() + + "."); + } + // In case there is more than one assignment to this parameter, we need to + // find the last one. + Assignment lastAssignment = null; + for (Assignment assignment : instantiation.getParameters()) { + if (assignment.getLhs().equals(parameter)) { + lastAssignment = assignment; } - var exprs = init.getExprs(); - return exprs.size() == 1 ? exprs.get(0) : null; - } - - public static boolean isSingleExpr(Initializer init) { - // todo expand that to = initialization - if (init == null) { - return false; - } - var exprs = init.getExprs(); - return exprs.size() == 1; - } - - public static boolean isListInitializer(Initializer init) { - return init != null && !isSingleExpr(init); - } - - /** - * Return the type of a declaration with the given - * (nullable) explicit type, and the given (nullable) - * initializer. If the explicit type is null, then the - * type is inferred from the initializer. Only two types - * can be inferred: "time" and "timeList". Return the - * "undefined" type if neither can be inferred. - * - * @param type Explicit type declared on the declaration - * @param init The initializer expression - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Type type, Initializer init) { - if (type != null) { - return InferredType.fromAST(type); - } else if (init == null) { - return InferredType.undefined(); - } - - var single = asSingleExpr(init); - if (single != null) { - // If there is a single element in the list, and it is a proper - // time value with units, we infer the type "time". - if (single instanceof ParameterReference) { - return getInferredType(((ParameterReference) single).getParameter()); - } else if (single instanceof Time) { - return InferredType.time(); - } - } else if (init.getExprs().size() > 1) { - // If there are multiple elements in the list, and there is at - // least one proper time value with units, and all other elements - // are valid times (including zero without units), we infer the - // type "time list". - var allValidTime = true; - var foundNonZero = false; - - for (var e : init.getExprs()) { - if (!ASTUtils.isValidTime(e)) { - allValidTime = false; - } - if (!ASTUtils.isZero(e)) { - foundNonZero = true; - } - } - - if (allValidTime && foundNonZero) { - // Conservatively, no bounds are inferred; the returned type - // is a variable-size list. - return InferredType.timeList(); - } - } - return InferredType.undefined(); - } - - /** - * Given a parameter, return an inferred type. Only two types can be - * inferred: "time" and "timeList". Return the "undefined" type if - * neither can be inferred. - * - * @param p A parameter to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(Parameter p) { - return getInferredType(p.getType(), p.getInit()); - } - - /** - * Given a state variable, return an inferred type. Only two types can be - * inferred: "time" and "timeList". Return the "undefined" type if - * neither can be inferred. - * - * @param s A state variable to infer the type of. - * @return The inferred type, or "undefined" if none could be inferred. - */ - public static InferredType getInferredType(StateVar s) { - return getInferredType(s.getType(), s.getInit()); - } - - /** - * Construct an inferred type from an "action" AST node based - * on its declared type. If no type is declared, return the "undefined" - * type. - * - * @param a An action to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Action a) { - return getInferredType(a.getType(), null); - } - - /** - * Construct an inferred type from a "port" AST node based on its declared - * type. If no type is declared, return the "undefined" type. - * - * @param p A port to construct an inferred type object for. - * @return The inferred type, or "undefined" if none was declared. - */ - public static InferredType getInferredType(Port p) { - return getInferredType(p.getType(), null); - } - - /** - * If the given string can be recognized as a floating-point number that has a leading decimal point, - * prepend the string with a zero and return it. Otherwise, return the original string. - * - * @param literal A string might be recognizable as a floating point number with a leading decimal point. - * @return an equivalent representation of literal - * - */ - public static String addZeroToLeadingDot(String literal) { - Matcher m = ABBREVIATED_FLOAT.matcher(literal); - if (m.matches()) { - return literal.replace(".", "0."); - } - return literal; - } - - /** - * Return true if the specified port is a multiport. - * @param port The port. - * @return True if the port is a multiport. - */ - public static boolean isMultiport(Port port) { - return port.getWidthSpec() != null; - } - - //////////////////////////////// - //// Utility functions for translating AST nodes into text - // This is a continuation of a large section of ASTUtils.xtend - // with the same name. - - /** - * Generate code for referencing a port, action, or timer. - * @param reference The reference to the variable. - */ - public static String generateVarRef(VarRef reference) { - var prefix = ""; - if (reference.getContainer() != null) { - prefix = reference.getContainer().getName() + "."; - } - return prefix + reference.getVariable().getName(); - } - - /** - * Assuming that the given expression denotes a valid time literal, - * return a time value. - */ - public static TimeValue getLiteralTimeValue(Expression expr) { - if (expr instanceof Time) { - return toTimeValue((Time)expr); - } else if (expr instanceof Literal && isZero(((Literal) expr).getLiteral())) { - return TimeValue.ZERO; - } else { - return null; - } - } - - /** - * If the parameter is of time type, return its default value. - * Otherwise, return null. - */ - public static TimeValue getDefaultAsTimeValue(Parameter p) { - if (isOfTimeType(p)) { - var init = asSingleExpr(p.getInit()); - if (init != null) { - return getLiteralTimeValue(init); - } - } - return null; - } - - /** - * Return whether the given state variable is inferred - * to a time type. - */ - public static boolean isOfTimeType(StateVar state) { - InferredType t = getInferredType(state); - return t.isTime && !t.isList; - } - - /** - * Return whether the given parameter is inferred - * to a time type. - */ - public static boolean isOfTimeType(Parameter param) { - InferredType t = getInferredType(param); - return t.isTime && !t.isList; - } - - /** - * Given a parameter, return its initial value. - * The initial value is a list of instances of Expressions. - * - * If the instantiations argument is null or an empty list, then the - * value returned is simply the default value given when the parameter - * is defined. - * - * If a list of instantiations is given, then the first instantiation - * is required to be an instantiation of the reactor class that is - * parameterized by the parameter. I.e., - * 
         parameter.eContainer == instantiations.get(0).reactorClass
-     *

    If a second instantiation is given, then it is required to be an instantiation of a - * reactor class that contains the first instantiation. That is,

    - * 
         instantiations.get(0).eContainer == instantiations.get(1).reactorClass
-     *

    More generally, for all 0 <= i < instantiations.size - 1,

    - * 
         instantiations.get(i).eContainer == instantiations.get(i + 1).reactorClass
-     *

    If any of these conditions is not satisfied, then an IllegalArgumentException - * will be thrown.

    - *

    Note that this chain of reactions cannot be inferred from the parameter because - * in each of the predicates above, there may be more than one instantiation that - * can appear on the right hand side of the predicate.

    - *

    For example, consider the following program:

    - * 
         reactor A(x:int(1)) {}
-     *      reactor B(y:int(2)) {
-     *          a1 = new A(x = y);
-     *          a2 = new A(x = -1);
-     *      }
-     *      reactor C(z:int(3)) {
-     *          b1 = new B(y = z);
-     *          b2 = new B(y = -2);
-     *      }
-     *

    Notice that there are a total of four instances of reactor class A. - * Then

    - * 
         initialValue(x, null) returns 1
-     *      initialValue(x, [a1]) returns 2
-     *      initialValue(x, [a2]) returns -1
-     *      initialValue(x, [a1, b1]) returns 3
-     *      initialValue(x, [a2, b1]) returns -1
-     *      initialValue(x, [a1, b2]) returns -2
-     *      initialValue(x, [a2, b2]) returns -1
-     *

    (Actually, in each of the above cases, the returned value is a list with - * one entry, a Literal, e.g. ["1"]).

    - *

    There are two instances of reactor class B.

    - * 
         initialValue(y, null) returns 2
-     *      initialValue(y, [a1]) throws an IllegalArgumentException
-     *      initialValue(y, [b1]) returns 3
-     *      initialValue(y, [b2]) returns -2
-     *
    - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * - * @return The value of the parameter. - * - * @throws IllegalArgumentException If an instantiation provided is not an - * instantiation of the reactor class that is parameterized by the - * respective parameter or if the chain of instantiations is not nested. - */ - public static List initialValue(Parameter parameter, List instantiations) { - // If instantiations are given, then check to see whether this parameter gets overridden in - // the first of those instantiations. - if (instantiations != null && instantiations.size() > 0) { - // Check to be sure that the instantiation is in fact an instantiation - // of the reactor class for which this is a parameter. - Instantiation instantiation = instantiations.get(0); - - if (!belongsTo(parameter, instantiation)) { - throw new IllegalArgumentException("Parameter " - + parameter.getName() - + " is not a parameter of reactor instance " - + instantiation.getName() - + "." - ); - } - // In case there is more than one assignment to this parameter, we need to - // find the last one. - Assignment lastAssignment = null; - for (Assignment assignment: instantiation.getParameters()) { - if (assignment.getLhs().equals(parameter)) { - lastAssignment = assignment; - } - } - if (lastAssignment != null) { - // Right hand side can be a list. Collect the entries. - List result = new ArrayList<>(); - for (Expression expr: lastAssignment.getRhs().getExprs()) { - if (expr instanceof ParameterReference) { - if (instantiations.size() > 1 - && instantiation.eContainer() != instantiations.get(1).getReactorClass() - ) { - throw new IllegalArgumentException("Reactor instance " - + instantiation.getName() - + " is not contained by instance " - + instantiations.get(1).getName() - + "." - ); - } - result.addAll(initialValue(((ParameterReference)expr).getParameter(), - instantiations.subList(1, instantiations.size()))); - } else { - result.add(expr); - } - } - return result; - } - } - // If we reach here, then either no instantiation was supplied or - // there was no assignment in the instantiation. So just use the - // parameter's initial value. - return parameter.getInit().getExprs(); - } - - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) - * belongs to the specified instantiation, meaning that it is defined in - * the reactor class being instantiated or one of its base classes. - * @param eobject The object. - * @param instantiation The instantiation. - */ - public static boolean belongsTo(EObject eobject, Instantiation instantiation) { - Reactor reactor = toDefinition(instantiation.getReactorClass()); - return belongsTo(eobject, reactor); - } - - /** - * Return true if the specified object (a Parameter, Port, Action, or Timer) - * belongs to the specified reactor, meaning that it is defined in - * reactor class or one of its base classes. - * @param eobject The object. - * @param reactor The reactor. - */ - public static boolean belongsTo(EObject eobject, Reactor reactor) { - if (eobject.eContainer() == reactor) return true; - for (ReactorDecl baseClass : reactor.getSuperClasses()) { - if (belongsTo(eobject, toDefinition(baseClass))) { - return true; - } - } - return false; - } - - /** - * Given a parameter return its integer value or null - * if it does not have an integer value. - * If the value of the parameter is a list of integers, - * return the sum of value in the list. - * The instantiations parameter is as in - * {@link #initialValue(Parameter, List)}. - * - * @param parameter The parameter. - * @param instantiations The (optional) list of instantiations. - * - * @return The integer value of the parameter, or null if it does not have an integer value. - * - * @throws IllegalArgumentException If an instantiation provided is not an - * instantiation of the reactor class that is parameterized by the - * respective parameter or if the chain of instantiations is not nested. - */ - public static Integer initialValueInt(Parameter parameter, List instantiations) { - List expressions = initialValue(parameter, instantiations); - int result = 0; - for (Expression expr: expressions) { - if (!(expr instanceof Literal)) { - return null; - } - try { - result += Integer.decode(((Literal) expr).getLiteral()); - } catch (NumberFormatException ex) { - return null; + } + if (lastAssignment != null) { + // Right hand side can be a list. Collect the entries. + List result = new ArrayList<>(); + for (Expression expr : lastAssignment.getRhs().getExprs()) { + if (expr instanceof ParameterReference) { + if (instantiations.size() > 1 + && instantiation.eContainer() != instantiations.get(1).getReactorClass()) { + throw new IllegalArgumentException( + "Reactor instance " + + instantiation.getName() + + " is not contained by instance " + + instantiations.get(1).getName() + + "."); } + result.addAll( + initialValue( + ((ParameterReference) expr).getParameter(), + instantiations.subList(1, instantiations.size()))); + } else { + result.add(expr); + } } return result; - } - - /** - * Given the width specification of port or instantiation - * and an (optional) list of nested instantiations, return - * the width if it can be determined and -1 if not. - * It will not be able to be determined if either the - * width is variable (in which case you should use - * {@link #inferPortWidth(VarRef, Connection, List)} ) - * or the list of instantiations is incomplete or missing. - * If there are parameter references in the width, they are - * evaluated to the extent possible given the instantiations list. - * - * The instantiations list is as in - * {@link #initialValue(Parameter, List)}. - * If the spec belongs to an instantiation (for a bank of reactors), - * then the first element on this list should be the instantiation - * that contains this instantiation. If the spec belongs to a port, - * then the first element on the list should be the instantiation - * of the reactor that contains the port. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * - * @return The width, or -1 if the width could not be determined. - * - * @throws IllegalArgumentException If an instantiation provided is not as - * given above or if the chain of instantiations is not nested. - */ - public static int width(WidthSpec spec, List instantiations) { - if (spec == null) { - return 1; - } - if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { - return inferWidthFromConnections(spec, instantiations); - } - var result = 0; - for (WidthTerm term: spec.getTerms()) { - if (term.getParameter() != null) { - Integer termWidth = initialValueInt(term.getParameter(), instantiations); - if (termWidth != null) { - result += termWidth; - } else { - return -1; - } - } else if (term.getWidth() > 0) { - result += term.getWidth(); - } else { - // If the width cannot be determined because term's width <= 0, which means the term's width - // must be inferred, try to infer the width using connections. - if (spec.eContainer() instanceof Instantiation) { - try { - return inferWidthFromConnections(spec, instantiations); - } catch (InvalidSourceException e) { - // If the inference fails, return -1. - return -1; - } - } - } - } - return result; - } - - /** - * Infer the width of a port reference in a connection. - * The port reference one or two parts, a port and an (optional) container - * which is an Instantiation that may refer to a bank of reactors. - * The width will be the product of the bank width and the port width. - * The returned value will be 1 if the port is not in a bank and is not a multiport. - * - * If the width cannot be determined, this will return -1. - * The width cannot be determined if the list of instantiations is - * missing or incomplete. - * - * The instantiations list is as in - * {@link #initialValue(Parameter, List)}. - * The first element on this list should be the instantiation - * that contains the specified connection. - * - * @param reference A port reference. - * @param connection A connection, or null if not in the context of a connection. - * @param instantiations The (optional) list of instantiations. - * - * @return The width or -1 if it could not be determined. - * - * @throws IllegalArgumentException If an instantiation provided is not as - * given above or if the chain of instantiations is not nested. - */ - public static int inferPortWidth( - VarRef reference, Connection connection, List instantiations - ) { - if (reference.getVariable() instanceof Port) { - // If the port is given as a.b, then we want to prepend a to - // the list of instantiations to determine the width of this port. - List extended = instantiations; - if (reference.getContainer() != null) { - extended = new ArrayList<>(); - extended.add(reference.getContainer()); - if (instantiations != null) { - extended.addAll(instantiations); - } - } - - int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); - if (portWidth < 0) { - // Could not determine port width. - return -1; - } - - // Next determine the bank width. This may be unspecified, in which - // case it has to be inferred using the connection. - int bankWidth = 1; - if (reference.getContainer() != null) { - bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); - if (bankWidth < 0 && connection != null) { - // Try to infer the bank width from the connection. - if (reference.getContainer().getWidthSpec().isOfVariableLength()) { - // This occurs for a bank of delays. - int leftWidth = 0; - int rightWidth = 0; - int leftOrRight = 0; - for (VarRef leftPort : connection.getLeftPorts()) { - if (leftPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that this port is on the left. - leftOrRight = -1; - } else { - // The left port is not the same as this reference. - int otherWidth = inferPortWidth(leftPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; - } - leftWidth += otherWidth; - } - } - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort == reference) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that this port is on the right. - leftOrRight = 1; - } else { - int otherWidth = inferPortWidth(rightPort, connection, instantiations); - if (otherWidth < 0) { - // Cannot determine width. - return -1; - } - rightWidth += otherWidth; - } - } - int discrepancy = 0; - if (leftOrRight < 0) { - // This port is on the left. - discrepancy = rightWidth - leftWidth; - } else if (leftOrRight > 0) { - // This port is on the right. - discrepancy = leftWidth - rightWidth; - } - // Check that portWidth divides the discrepancy. - if (discrepancy % portWidth != 0) { - // This is an error. - return -1; - } - bankWidth = discrepancy / portWidth; - } else { - // Could not determine the bank width. - return -1; - } - } - } - return portWidth * bankWidth; - } - // Argument is not a port. - return -1; - } - - /** - * Given an instantiation of a reactor or bank of reactors, return - * the width. This will be 1 if this is not a reactor bank. Otherwise, - * this will attempt to determine the width. If the width is declared - * as a literal constant, it will return that constant. If the width - * is specified as a reference to a parameter, this will throw an - * exception. If the width is variable, this will find - * connections in the enclosing reactor and attempt to infer the - * width. If the width cannot be determined, it will throw an exception. - * - * IMPORTANT: This method should not be used you really need to - * determine the width! It will not evaluate parameter values. - * @see #width(WidthSpec, List) - * - * @param instantiation A reactor instantiation. - * - * @return The width, if it can be determined. - * @deprecated - */ - @Deprecated - public static int widthSpecification(Instantiation instantiation) { - int result = width(instantiation.getWidthSpec(), null); - if (result < 0) { - throw new InvalidSourceException("Cannot determine width for the instance " - + instantiation.getName()); - } - return result; - } - - /** - * Report whether a state variable has been initialized or not. - * @param v The state variable to be checked. - * @return True if the variable was initialized, false otherwise. - */ - public static boolean isInitialized(StateVar v) { - return v != null && v.getInit() != null; - } - - /** - * Report whether the given time state variable is initialized using a - * parameter or not. - * @param s A state variable. - * @return True if the argument is initialized using a parameter, false - * otherwise. - */ - public static boolean isParameterized(StateVar s) { - return s.getInit() != null && - IterableExtensions.exists(s.getInit().getExprs(), it -> it instanceof ParameterReference); - } - - /** - * Check if the reactor class uses generics - * @param r the reactor to check - * @return true if the reactor uses generics - */ - public static boolean isGeneric(Reactor r) { - if (r == null) { - return false; - } - return r.getTypeParms().size() != 0; - } - - /** - * If the specified reactor declaration is an import, then - * return the imported reactor class definition. Otherwise, - * just return the argument. - * @param r A Reactor or an ImportedReactor. - * @return The Reactor class definition or null if no definition is found. - */ - public static Reactor toDefinition(ReactorDecl r) { - if (r == null) - return null; - if (r instanceof Reactor) { - return (Reactor) r; - } else if (r instanceof ImportedReactor) { - return ((ImportedReactor) r).getReactorClass(); - } + } + } + // If we reach here, then either no instantiation was supplied or + // there was no assignment in the instantiation. So just use the + // parameter's initial value. + return parameter.getInit().getExprs(); + } + + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the + * specified instantiation, meaning that it is defined in the reactor class being instantiated or + * one of its base classes. + * + * @param eobject The object. + * @param instantiation The instantiation. + */ + public static boolean belongsTo(EObject eobject, Instantiation instantiation) { + Reactor reactor = toDefinition(instantiation.getReactorClass()); + return belongsTo(eobject, reactor); + } + + /** + * Return true if the specified object (a Parameter, Port, Action, or Timer) belongs to the + * specified reactor, meaning that it is defined in reactor class or one of its base classes. + * + * @param eobject The object. + * @param reactor The reactor. + */ + public static boolean belongsTo(EObject eobject, Reactor reactor) { + if (eobject.eContainer() == reactor) return true; + for (ReactorDecl baseClass : reactor.getSuperClasses()) { + if (belongsTo(eobject, toDefinition(baseClass))) { + return true; + } + } + return false; + } + + /** + * Given a parameter return its integer value or null if it does not have an integer value. If the + * value of the parameter is a list of integers, return the sum of value in the list. The + * instantiations parameter is as in {@link #initialValue(Parameter, List)}. + * + * @param parameter The parameter. + * @param instantiations The (optional) list of instantiations. + * @return The integer value of the parameter, or null if it does not have an integer value. + * @throws IllegalArgumentException If an instantiation provided is not an instantiation of the + * reactor class that is parameterized by the respective parameter or if the chain of + * instantiations is not nested. + */ + public static Integer initialValueInt(Parameter parameter, List instantiations) { + List expressions = initialValue(parameter, instantiations); + int result = 0; + for (Expression expr : expressions) { + if (!(expr instanceof Literal)) { return null; - } - - /** - * Return all single-line or multi-line comments immediately preceding the - * given EObject. - */ - public static Stream getPrecedingComments( - ICompositeNode compNode, - Predicate filter - ) { - return getPrecedingCommentNodes(compNode, filter).map(INode::getText); - } - - /** - * Return all single-line or multi-line comments immediately preceding the - * given EObject. - */ - public static Stream getPrecedingCommentNodes( - ICompositeNode compNode, - Predicate filter - ) { - if (compNode == null) return Stream.of(); - List ret = new ArrayList<>(); - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode)) { - if (isComment(node)) { - if (filter.test(node)) ret.add(node); - } else if (!node.getText().isBlank()) { - break; - } - } - } - return ret.stream(); - } - - /** Return whether {@code node} is a comment. */ - public static boolean isComment(INode node) { - return node instanceof HiddenLeafNode hlNode - && hlNode.getGrammarElement() instanceof TerminalRule tRule - && tRule.getName().endsWith("_COMMENT"); - } - - /** - * Return true if the given node starts on the same line as the given other - * node. - */ - public static Predicate sameLine(ICompositeNode compNode) { - return other -> { - for (INode node : compNode.getAsTreeIterable()) { - if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { - return node.getStartLine() == other.getStartLine(); - } - } - return false; - }; - } - - /** - * Find the main reactor and set its name if none was defined. - * @param resource The resource to find the main reactor in. - */ - public static void setMainName(Resource resource, String name) { - Reactor main = IteratorExtensions.findFirst(Iterators.filter(resource.getAllContents(), Reactor.class), - it -> it.isMain() || it.isFederated() - ); - if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { - main.setName(name); - } - } - - /** - * Create a new instantiation node with the given reactor as its defining class. - * @param reactor The reactor class to create an instantiation of. - */ - public static Instantiation createInstantiation(Reactor reactor) { - Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); - inst.setReactorClass(reactor); - // If the reactor is federated or at the top level, then it - // may not have a name. In the generator's doGenerate() - // method, the name gets set using setMainName(). - // But this may be called before that, e.g. during - // diagram synthesis. We assign a temporary name here. - if (reactor.getName() == null) { - if (reactor.isFederated() || reactor.isMain()) { - inst.setName("main"); - } else { - inst.setName(""); - } - + } + try { + result += Integer.decode(((Literal) expr).getLiteral()); + } catch (NumberFormatException ex) { + return null; + } + } + return result; + } + + /** + * Given the width specification of port or instantiation and an (optional) list of nested + * instantiations, return the width if it can be determined and -1 if not. It will not be able to + * be determined if either the width is variable (in which case you should use {@link + * #inferPortWidth(VarRef, Connection, List)} ) or the list of instantiations is incomplete or + * missing. If there are parameter references in the width, they are evaluated to the extent + * possible given the instantiations list. + * + *

    The instantiations list is as in {@link #initialValue(Parameter, List)}. If the spec belongs + * to an instantiation (for a bank of reactors), then the first element on this list should be the + * instantiation that contains this instantiation. If the spec belongs to a port, then the first + * element on the list should be the instantiation of the reactor that contains the port. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * @return The width, or -1 if the width could not be determined. + * @throws IllegalArgumentException If an instantiation provided is not as given above or if the + * chain of instantiations is not nested. + */ + public static int width(WidthSpec spec, List instantiations) { + if (spec == null) { + return 1; + } + if (spec.isOfVariableLength() && spec.eContainer() instanceof Instantiation) { + return inferWidthFromConnections(spec, instantiations); + } + var result = 0; + for (WidthTerm term : spec.getTerms()) { + if (term.getParameter() != null) { + Integer termWidth = initialValueInt(term.getParameter(), instantiations); + if (termWidth != null) { + result += termWidth; } else { - inst.setName(reactor.getName()); + return -1; } - return inst; - } - - /** - * Returns the target declaration in the given model. - * Non-null because it would cause a parse error. - */ - public static TargetDecl targetDecl(Model model) { - return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); - } - - /** - * Returns the target declaration in the given resource. - * Non-null because it would cause a parse error. - */ - public static TargetDecl targetDecl(Resource model) { - return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); - } - - ///////////////////////////////////////////////////////// - //// Private methods - - /** - * Returns the list if it is not null. Otherwise, return an empty list. - */ - public static List convertToEmptyListIfNull(List list) { - return list != null ? list : new ArrayList<>(); - } - - /** - * Return all the superclasses of the specified reactor - * in deepest-first order. For example, if A extends B and C, and - * B and C both extend D, this will return the list [D, B, C, A]. - * Duplicates are removed. If the specified reactor does not extend - * any other reactor, then return an empty list. - * If a cycle is found, where X extends Y and Y extends X, or if - * a superclass is declared that is not found, then return null. - * @param reactor The specified reactor. - * @param extensions A set of reactors extending the specified reactor - * (used to detect circular extensions). - */ - private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { - LinkedHashSet result = new LinkedHashSet<>(); - for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { - Reactor r = toDefinition(superDecl); - if (r == reactor || r == null) return null; - // If r is in the extensions, then we have a circular inheritance structure. - if (extensions.contains(r)) return null; - extensions.add(r); - LinkedHashSet baseExtends = superClasses(r, extensions); - extensions.remove(r); - if (baseExtends == null) return null; - result.addAll(baseExtends); - result.add(r); + } else if (term.getWidth() > 0) { + result += term.getWidth(); + } else { + // If the width cannot be determined because term's width <= 0, which means the term's width + // must be inferred, try to infer the width using connections. + if (spec.eContainer() instanceof Instantiation) { + try { + return inferWidthFromConnections(spec, instantiations); + } catch (InvalidSourceException e) { + // If the inference fails, return -1. + return -1; + } } - return result; - } - - /** - * Return all the file-level preambles in the files that define the - * specified class and its superclasses in deepest-first order. - * Duplicates are removed. If there are no file-level preambles, - * then return an empty list. - * If a cycle is found, where X extends Y and Y extends X, or if - * a superclass is declared that is not found, then return null. - * @param reactor The specified reactor. - * @param extensions A set of reactors extending the specified reactor - * (used to detect circular extensions). - */ - private static LinkedHashSet allFileLevelPreambles(Reactor reactor, Set extensions) { - LinkedHashSet result = new LinkedHashSet<>(); - for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { - Reactor r = toDefinition(superDecl); - if (r == reactor || r == null) return null; - // If r is in the extensions, then we have a circular inheritance structure. - if (extensions.contains(r)) return null; - extensions.add(r); - LinkedHashSet basePreambles = allFileLevelPreambles(r, extensions); - extensions.remove(r); - if (basePreambles == null) return null; - result.addAll(basePreambles); + } + } + return result; + } + + /** + * Infer the width of a port reference in a connection. The port reference one or two parts, a + * port and an (optional) container which is an Instantiation that may refer to a bank of + * reactors. The width will be the product of the bank width and the port width. The returned + * value will be 1 if the port is not in a bank and is not a multiport. + * + *

    If the width cannot be determined, this will return -1. The width cannot be determined if + * the list of instantiations is missing or incomplete. + * + *

    The instantiations list is as in {@link #initialValue(Parameter, List)}. The first element + * on this list should be the instantiation that contains the specified connection. + * + * @param reference A port reference. + * @param connection A connection, or null if not in the context of a connection. + * @param instantiations The (optional) list of instantiations. + * @return The width or -1 if it could not be determined. + * @throws IllegalArgumentException If an instantiation provided is not as given above or if the + * chain of instantiations is not nested. + */ + public static int inferPortWidth( + VarRef reference, Connection connection, List instantiations) { + if (reference.getVariable() instanceof Port) { + // If the port is given as a.b, then we want to prepend a to + // the list of instantiations to determine the width of this port. + List extended = instantiations; + if (reference.getContainer() != null) { + extended = new ArrayList<>(); + extended.add(reference.getContainer()); + if (instantiations != null) { + extended.addAll(instantiations); } - result.addAll(((Model) reactor.eContainer()).getPreambles()); - return result; - } + } - /** - * We may be able to infer the width by examining the connections of - * the enclosing reactor definition. This works, for example, with - * delays between multiports or banks of reactors. - * Attempt to infer the width from connections and return -1 if the width cannot be inferred. - * - * @param spec The width specification or null (to return 1). - * @param instantiations The (optional) list of instantiations. - * - * @return The width, or -1 if the width could not be inferred from connections. - */ - private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { - for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { + int portWidth = width(((Port) reference.getVariable()).getWidthSpec(), extended); + if (portWidth < 0) { + // Could not determine port width. + return -1; + } + + // Next determine the bank width. This may be unspecified, in which + // case it has to be inferred using the connection. + int bankWidth = 1; + if (reference.getContainer() != null) { + bankWidth = width(reference.getContainer().getWidthSpec(), instantiations); + if (bankWidth < 0 && connection != null) { + // Try to infer the bank width from the connection. + if (reference.getContainer().getWidthSpec().isOfVariableLength()) { + // This occurs for a bank of delays. int leftWidth = 0; int rightWidth = 0; int leftOrRight = 0; - for (VarRef leftPort : c.getLeftPorts()) { - if (leftPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the left. - leftOrRight = -1; - } else { - leftWidth += inferPortWidth(leftPort, c, instantiations); + for (VarRef leftPort : connection.getLeftPorts()) { + if (leftPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException( + "Multiple ports with variable width on a connection."); + } + // Indicate that this port is on the left. + leftOrRight = -1; + } else { + // The left port is not the same as this reference. + int otherWidth = inferPortWidth(leftPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; } + leftWidth += otherWidth; + } } - for (VarRef rightPort : c.getRightPorts()) { - if (rightPort.getContainer() == spec.eContainer()) { - if (leftOrRight != 0) { - throw new InvalidSourceException("Multiple ports with variable width on a connection."); - } - // Indicate that the port is on the right. - leftOrRight = 1; - } else { - rightWidth += inferPortWidth(rightPort, c, instantiations); + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort == reference) { + if (leftOrRight != 0) { + throw new InvalidSourceException( + "Multiple ports with variable width on a connection."); } + // Indicate that this port is on the right. + leftOrRight = 1; + } else { + int otherWidth = inferPortWidth(rightPort, connection, instantiations); + if (otherWidth < 0) { + // Cannot determine width. + return -1; + } + rightWidth += otherWidth; + } } + int discrepancy = 0; if (leftOrRight < 0) { - return rightWidth - leftWidth; + // This port is on the left. + discrepancy = rightWidth - leftWidth; } else if (leftOrRight > 0) { - return leftWidth - rightWidth; + // This port is on the right. + discrepancy = leftWidth - rightWidth; + } + // Check that portWidth divides the discrepancy. + if (discrepancy % portWidth != 0) { + // This is an error. + return -1; } + bankWidth = discrepancy / portWidth; + } else { + // Could not determine the bank width. + return -1; + } } - // A connection was not found with the instantiation. - return -1; - } - - public static void addReactionAttribute(Reaction reaction, String name) { - var fedAttr = factory.createAttribute(); - fedAttr.setAttrName(name); - reaction.getAttributes().add(fedAttr); - } + } + return portWidth * bankWidth; + } + // Argument is not a port. + return -1; + } + + /** + * Given an instantiation of a reactor or bank of reactors, return the width. This will be 1 if + * this is not a reactor bank. Otherwise, this will attempt to determine the width. If the width + * is declared as a literal constant, it will return that constant. If the width is specified as a + * reference to a parameter, this will throw an exception. If the width is variable, this will + * find connections in the enclosing reactor and attempt to infer the width. If the width cannot + * be determined, it will throw an exception. + * + *

    IMPORTANT: This method should not be used you really need to determine the width! It will + * not evaluate parameter values. + * + * @see #width(WidthSpec, List) + * @param instantiation A reactor instantiation. + * @return The width, if it can be determined. + * @deprecated + */ + @Deprecated + public static int widthSpecification(Instantiation instantiation) { + int result = width(instantiation.getWidthSpec(), null); + if (result < 0) { + throw new InvalidSourceException( + "Cannot determine width for the instance " + instantiation.getName()); + } + return result; + } + + /** + * Report whether a state variable has been initialized or not. + * + * @param v The state variable to be checked. + * @return True if the variable was initialized, false otherwise. + */ + public static boolean isInitialized(StateVar v) { + return v != null && v.getInit() != null; + } + + /** + * Report whether the given time state variable is initialized using a parameter or not. + * + * @param s A state variable. + * @return True if the argument is initialized using a parameter, false otherwise. + */ + public static boolean isParameterized(StateVar s) { + return s.getInit() != null + && IterableExtensions.exists( + s.getInit().getExprs(), it -> it instanceof ParameterReference); + } + + /** + * Check if the reactor class uses generics + * + * @param r the reactor to check + * @return true if the reactor uses generics + */ + public static boolean isGeneric(Reactor r) { + if (r == null) { + return false; + } + return r.getTypeParms().size() != 0; + } + + /** + * If the specified reactor declaration is an import, then return the imported reactor class + * definition. Otherwise, just return the argument. + * + * @param r A Reactor or an ImportedReactor. + * @return The Reactor class definition or null if no definition is found. + */ + public static Reactor toDefinition(ReactorDecl r) { + if (r == null) return null; + if (r instanceof Reactor) { + return (Reactor) r; + } else if (r instanceof ImportedReactor) { + return ((ImportedReactor) r).getReactorClass(); + } + return null; + } + + /** Return all single-line or multi-line comments immediately preceding the given EObject. */ + public static Stream getPrecedingComments( + ICompositeNode compNode, Predicate filter) { + return getPrecedingCommentNodes(compNode, filter).map(INode::getText); + } + + /** Return all single-line or multi-line comments immediately preceding the given EObject. */ + public static Stream getPrecedingCommentNodes( + ICompositeNode compNode, Predicate filter) { + if (compNode == null) return Stream.of(); + List ret = new ArrayList<>(); + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode)) { + if (isComment(node)) { + if (filter.test(node)) ret.add(node); + } else if (!node.getText().isBlank()) { + break; + } + } + } + return ret.stream(); + } + + /** Return whether {@code node} is a comment. */ + public static boolean isComment(INode node) { + return node instanceof HiddenLeafNode hlNode + && hlNode.getGrammarElement() instanceof TerminalRule tRule + && tRule.getName().endsWith("_COMMENT"); + } + + /** Return true if the given node starts on the same line as the given other node. */ + public static Predicate sameLine(ICompositeNode compNode) { + return other -> { + for (INode node : compNode.getAsTreeIterable()) { + if (!(node instanceof ICompositeNode) && !node.getText().isBlank() && !isComment(node)) { + return node.getStartLine() == other.getStartLine(); + } + } + return false; + }; + } + + /** + * Find the main reactor and set its name if none was defined. + * + * @param resource The resource to find the main reactor in. + */ + public static void setMainName(Resource resource, String name) { + Reactor main = + IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), + it -> it.isMain() || it.isFederated()); + if (main != null && StringExtensions.isNullOrEmpty(main.getName())) { + main.setName(name); + } + } + + /** + * Create a new instantiation node with the given reactor as its defining class. + * + * @param reactor The reactor class to create an instantiation of. + */ + public static Instantiation createInstantiation(Reactor reactor) { + Instantiation inst = LfFactory.eINSTANCE.createInstantiation(); + inst.setReactorClass(reactor); + // If the reactor is federated or at the top level, then it + // may not have a name. In the generator's doGenerate() + // method, the name gets set using setMainName(). + // But this may be called before that, e.g. during + // diagram synthesis. We assign a temporary name here. + if (reactor.getName() == null) { + if (reactor.isFederated() || reactor.isMain()) { + inst.setName("main"); + } else { + inst.setName(""); + } + + } else { + inst.setName(reactor.getName()); + } + return inst; + } + + /** + * Returns the target declaration in the given model. Non-null because it would cause a parse + * error. + */ + public static TargetDecl targetDecl(Model model) { + return IteratorExtensions.head(Iterators.filter(model.eAllContents(), TargetDecl.class)); + } + + /** + * Returns the target declaration in the given resource. Non-null because it would cause a parse + * error. + */ + public static TargetDecl targetDecl(Resource model) { + return IteratorExtensions.head(Iterators.filter(model.getAllContents(), TargetDecl.class)); + } + + ///////////////////////////////////////////////////////// + //// Private methods + + /** Returns the list if it is not null. Otherwise, return an empty list. */ + public static List convertToEmptyListIfNull(List list) { + return list != null ? list : new ArrayList<>(); + } + + /** + * Return all the superclasses of the specified reactor in deepest-first order. For example, if A + * extends B and C, and B and C both extend D, this will return the list [D, B, C, A]. Duplicates + * are removed. If the specified reactor does not extend any other reactor, then return an empty + * list. If a cycle is found, where X extends Y and Y extends X, or if a superclass is declared + * that is not found, then return null. + * + * @param reactor The specified reactor. + * @param extensions A set of reactors extending the specified reactor (used to detect circular + * extensions). + */ + private static LinkedHashSet superClasses(Reactor reactor, Set extensions) { + LinkedHashSet result = new LinkedHashSet<>(); + for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { + Reactor r = toDefinition(superDecl); + if (r == reactor || r == null) return null; + // If r is in the extensions, then we have a circular inheritance structure. + if (extensions.contains(r)) return null; + extensions.add(r); + LinkedHashSet baseExtends = superClasses(r, extensions); + extensions.remove(r); + if (baseExtends == null) return null; + result.addAll(baseExtends); + result.add(r); + } + return result; + } + + /** + * Return all the file-level preambles in the files that define the specified class and its + * superclasses in deepest-first order. Duplicates are removed. If there are no file-level + * preambles, then return an empty list. If a cycle is found, where X extends Y and Y extends X, + * or if a superclass is declared that is not found, then return null. + * + * @param reactor The specified reactor. + * @param extensions A set of reactors extending the specified reactor (used to detect circular + * extensions). + */ + private static LinkedHashSet allFileLevelPreambles( + Reactor reactor, Set extensions) { + LinkedHashSet result = new LinkedHashSet<>(); + for (ReactorDecl superDecl : convertToEmptyListIfNull(reactor.getSuperClasses())) { + Reactor r = toDefinition(superDecl); + if (r == reactor || r == null) return null; + // If r is in the extensions, then we have a circular inheritance structure. + if (extensions.contains(r)) return null; + extensions.add(r); + LinkedHashSet basePreambles = allFileLevelPreambles(r, extensions); + extensions.remove(r); + if (basePreambles == null) return null; + result.addAll(basePreambles); + } + result.addAll(((Model) reactor.eContainer()).getPreambles()); + return result; + } + + /** + * We may be able to infer the width by examining the connections of the enclosing reactor + * definition. This works, for example, with delays between multiports or banks of reactors. + * Attempt to infer the width from connections and return -1 if the width cannot be inferred. + * + * @param spec The width specification or null (to return 1). + * @param instantiations The (optional) list of instantiations. + * @return The width, or -1 if the width could not be inferred from connections. + */ + private static int inferWidthFromConnections(WidthSpec spec, List instantiations) { + for (Connection c : ((Reactor) spec.eContainer().eContainer()).getConnections()) { + int leftWidth = 0; + int rightWidth = 0; + int leftOrRight = 0; + for (VarRef leftPort : c.getLeftPorts()) { + if (leftPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the left. + leftOrRight = -1; + } else { + leftWidth += inferPortWidth(leftPort, c, instantiations); + } + } + for (VarRef rightPort : c.getRightPorts()) { + if (rightPort.getContainer() == spec.eContainer()) { + if (leftOrRight != 0) { + throw new InvalidSourceException("Multiple ports with variable width on a connection."); + } + // Indicate that the port is on the right. + leftOrRight = 1; + } else { + rightWidth += inferPortWidth(rightPort, c, instantiations); + } + } + if (leftOrRight < 0) { + return rightWidth - leftWidth; + } else if (leftOrRight > 0) { + return leftWidth - rightWidth; + } + } + // A connection was not found with the instantiation. + return -1; + } + + public static void addReactionAttribute(Reaction reaction, String name) { + var fedAttr = factory.createAttribute(); + fedAttr.setAttrName(name); + reaction.getAttributes().add(fedAttr); + } } diff --git a/org.lflang/src/org/lflang/ast/AstTransformation.java b/org.lflang/src/org/lflang/ast/AstTransformation.java index 80a93da4b9..cf5c5843ff 100644 --- a/org.lflang/src/org/lflang/ast/AstTransformation.java +++ b/org.lflang/src/org/lflang/ast/AstTransformation.java @@ -1,16 +1,11 @@ package org.lflang.ast; import java.util.List; - import org.lflang.lf.Reactor; -/** - * Interface for AST Transfomations - */ +/** Interface for AST Transfomations */ public interface AstTransformation { - /** - * Apply the AST transformation to all given reactors. - */ - void applyTransformation(List reactors); + /** Apply the AST transformation to all given reactors. */ + void applyTransformation(List reactors); } diff --git a/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java b/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java index 953b9bdfdb..882019ac44 100644 --- a/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java +++ b/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java @@ -6,13 +6,11 @@ import java.util.List; import java.util.Map; import java.util.Objects; - import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.IteratorExtensions; - import org.lflang.InferredType; import org.lflang.generator.DelayBodyGenerator; import org.lflang.generator.TargetTypes; @@ -40,365 +38,371 @@ import org.lflang.lf.WidthTerm; /** - This class implements AST transformations for delayed connections. - There are two types of delayed connections: - 1) Connections with {@code after}-delays - 2) Physical connections + * This class implements AST transformations for delayed connections. There are two types of delayed + * connections: 1) Connections with {@code after}-delays 2) Physical connections */ public class DelayedConnectionTransformation implements AstTransformation { - /** - * The Lingua Franca factory for creating new AST nodes. - */ - public static final LfFactory factory = ASTUtils.factory; - - /** - * A code generator used to insert reaction bodies for the generated delay reactors. - */ - private final DelayBodyGenerator generator; - - /** - * A target type instance that is used during the transformation to manage target specific types - */ - private final TargetTypes targetTypes; - - /** - * The Eclipse eCore view of the main LF file. - */ - private final Resource mainResource; - - private boolean transformAfterDelays = false; - private boolean transformPhysicalConnection = false; - /** - * Collection of generated delay classes. - */ - private final LinkedHashSet delayClasses = new LinkedHashSet<>(); - - public DelayedConnectionTransformation(DelayBodyGenerator generator, TargetTypes targetTypes, Resource mainResource, boolean transformAfterDelays, boolean transformPhysicalConnections) { - this.generator = generator; - this.targetTypes = targetTypes; - this.mainResource = mainResource; - this.transformAfterDelays = transformAfterDelays; - this.transformPhysicalConnection = transformPhysicalConnections; - } - - /** - * Transform all after delay connections by inserting generated delay reactors. - */ - @Override - public void applyTransformation(List reactors) { - insertGeneratedDelays(reactors); - } - - /** - * Find connections in the given resource that have a delay associated with them, - * and reroute them via a generated delay reactor. - * @param reactors A list of reactors to apply the transformation to. - */ - private void insertGeneratedDelays(List reactors) { - // The resulting changes to the AST are performed _after_ iterating - // in order to avoid concurrent modification problems. - List oldConnections = new ArrayList<>(); - Map> newConnections = new LinkedHashMap<>(); - Map> delayInstances = new LinkedHashMap<>(); - - // Iterate over the connections in the tree. - for (Reactor container : reactors) { - for (Connection connection : ASTUtils.allConnections(container)) { - if ( transformAfterDelays && connection.getDelay() != null || - transformPhysicalConnection && connection.isPhysical()) { - EObject parent = connection.eContainer(); - // Assume all the types are the same, so just use the first on the right. - Type type = ((Port) connection.getRightPorts().get(0).getVariable()).getType(); - Reactor delayClass = getDelayClass(type, connection.isPhysical()); - String generic = targetTypes.supportsGenerics() - ? targetTypes.getTargetType(type) : null; - - Instantiation delayInstance = getDelayInstance(delayClass, connection, generic, - !generator.generateAfterDelaysWithVariableWidth(), connection.isPhysical()); - - // Stage the new connections for insertion into the tree. - List connections = ASTUtils.convertToEmptyListIfNull(newConnections.get(parent)); - connections.addAll(rerouteViaDelay(connection, delayInstance)); - newConnections.put(parent, connections); - // Stage the original connection for deletion from the tree. - oldConnections.add(connection); - - // Stage the newly created delay reactor instance for insertion - List instances = ASTUtils.convertToEmptyListIfNull(delayInstances.get(parent)); - instances.add(delayInstance); - delayInstances.put(parent, instances); - } - } + /** The Lingua Franca factory for creating new AST nodes. */ + public static final LfFactory factory = ASTUtils.factory; + + /** A code generator used to insert reaction bodies for the generated delay reactors. */ + private final DelayBodyGenerator generator; + + /** + * A target type instance that is used during the transformation to manage target specific types + */ + private final TargetTypes targetTypes; + + /** The Eclipse eCore view of the main LF file. */ + private final Resource mainResource; + + private boolean transformAfterDelays = false; + private boolean transformPhysicalConnection = false; + /** Collection of generated delay classes. */ + private final LinkedHashSet delayClasses = new LinkedHashSet<>(); + + public DelayedConnectionTransformation( + DelayBodyGenerator generator, + TargetTypes targetTypes, + Resource mainResource, + boolean transformAfterDelays, + boolean transformPhysicalConnections) { + this.generator = generator; + this.targetTypes = targetTypes; + this.mainResource = mainResource; + this.transformAfterDelays = transformAfterDelays; + this.transformPhysicalConnection = transformPhysicalConnections; + } + + /** Transform all after delay connections by inserting generated delay reactors. */ + @Override + public void applyTransformation(List reactors) { + insertGeneratedDelays(reactors); + } + + /** + * Find connections in the given resource that have a delay associated with them, and reroute them + * via a generated delay reactor. + * + * @param reactors A list of reactors to apply the transformation to. + */ + private void insertGeneratedDelays(List reactors) { + // The resulting changes to the AST are performed _after_ iterating + // in order to avoid concurrent modification problems. + List oldConnections = new ArrayList<>(); + Map> newConnections = new LinkedHashMap<>(); + Map> delayInstances = new LinkedHashMap<>(); + + // Iterate over the connections in the tree. + for (Reactor container : reactors) { + for (Connection connection : ASTUtils.allConnections(container)) { + if (transformAfterDelays && connection.getDelay() != null + || transformPhysicalConnection && connection.isPhysical()) { + EObject parent = connection.eContainer(); + // Assume all the types are the same, so just use the first on the right. + Type type = ((Port) connection.getRightPorts().get(0).getVariable()).getType(); + Reactor delayClass = getDelayClass(type, connection.isPhysical()); + String generic = targetTypes.supportsGenerics() ? targetTypes.getTargetType(type) : null; + + Instantiation delayInstance = + getDelayInstance( + delayClass, + connection, + generic, + !generator.generateAfterDelaysWithVariableWidth(), + connection.isPhysical()); + + // Stage the new connections for insertion into the tree. + List connections = + ASTUtils.convertToEmptyListIfNull(newConnections.get(parent)); + connections.addAll(rerouteViaDelay(connection, delayInstance)); + newConnections.put(parent, connections); + // Stage the original connection for deletion from the tree. + oldConnections.add(connection); + + // Stage the newly created delay reactor instance for insertion + List instances = + ASTUtils.convertToEmptyListIfNull(delayInstances.get(parent)); + instances.add(delayInstance); + delayInstances.put(parent, instances); } + } + } - // Remove old connections; insert new ones. - oldConnections.forEach(connection -> { - var container = connection.eContainer(); - if (container instanceof Reactor) { - ((Reactor) container).getConnections().remove(connection); - } else if (container instanceof Mode) { - ((Mode) container).getConnections().remove(connection); - } + // Remove old connections; insert new ones. + oldConnections.forEach( + connection -> { + var container = connection.eContainer(); + if (container instanceof Reactor) { + ((Reactor) container).getConnections().remove(connection); + } else if (container instanceof Mode) { + ((Mode) container).getConnections().remove(connection); + } }); - newConnections.forEach((container, connections) -> { - if (container instanceof Reactor) { - ((Reactor) container).getConnections().addAll(connections); - } else if (container instanceof Mode) { - ((Mode) container).getConnections().addAll(connections); - } + newConnections.forEach( + (container, connections) -> { + if (container instanceof Reactor) { + ((Reactor) container).getConnections().addAll(connections); + } else if (container instanceof Mode) { + ((Mode) container).getConnections().addAll(connections); + } }); - // Finally, insert the instances and, before doing so, assign them a unique name. - delayInstances.forEach((container, instantiations) -> - instantiations.forEach(instantiation -> { - if (container instanceof Reactor) { - instantiation.setName(ASTUtils.getUniqueIdentifier((Reactor) container, "delay")); + // Finally, insert the instances and, before doing so, assign them a unique name. + delayInstances.forEach( + (container, instantiations) -> + instantiations.forEach( + instantiation -> { + if (container instanceof Reactor) { + instantiation.setName( + ASTUtils.getUniqueIdentifier((Reactor) container, "delay")); ((Reactor) container).getInstantiations().add(instantiation); - } else if (container instanceof Mode) { - instantiation.setName(ASTUtils.getUniqueIdentifier((Reactor) container.eContainer(), "delay")); + } else if (container instanceof Mode) { + instantiation.setName( + ASTUtils.getUniqueIdentifier((Reactor) container.eContainer(), "delay")); ((Mode) container).getInstantiations().add(instantiation); - } - }) - ); - } - - /** - * Take a connection and reroute it via an instance of a generated delay - * reactor. This method returns a list to new connections to substitute - * the original one. - * @param connection The connection to reroute. - * @param delayInstance The delay instance to route the connection through. - */ - private static List rerouteViaDelay(Connection connection, - Instantiation delayInstance) { - List connections = new ArrayList<>(); - Connection upstream = factory.createConnection(); - Connection downstream = factory.createConnection(); - VarRef input = factory.createVarRef(); - VarRef output = factory.createVarRef(); - - Reactor delayClass = ASTUtils.toDefinition(delayInstance.getReactorClass()); - - // Establish references to the involved ports. - input.setContainer(delayInstance); - input.setVariable(delayClass.getInputs().get(0)); - output.setContainer(delayInstance); - output.setVariable(delayClass.getOutputs().get(0)); - upstream.getLeftPorts().addAll(connection.getLeftPorts()); - upstream.getRightPorts().add(input); - downstream.getLeftPorts().add(output); - downstream.getRightPorts().addAll(connection.getRightPorts()); - downstream.setIterated(connection.isIterated()); - connections.add(upstream); - connections.add(downstream); - return connections; + } + })); + } + + /** + * Take a connection and reroute it via an instance of a generated delay reactor. This method + * returns a list to new connections to substitute the original one. + * + * @param connection The connection to reroute. + * @param delayInstance The delay instance to route the connection through. + */ + private static List rerouteViaDelay( + Connection connection, Instantiation delayInstance) { + List connections = new ArrayList<>(); + Connection upstream = factory.createConnection(); + Connection downstream = factory.createConnection(); + VarRef input = factory.createVarRef(); + VarRef output = factory.createVarRef(); + + Reactor delayClass = ASTUtils.toDefinition(delayInstance.getReactorClass()); + + // Establish references to the involved ports. + input.setContainer(delayInstance); + input.setVariable(delayClass.getInputs().get(0)); + output.setContainer(delayInstance); + output.setVariable(delayClass.getOutputs().get(0)); + upstream.getLeftPorts().addAll(connection.getLeftPorts()); + upstream.getRightPorts().add(input); + downstream.getLeftPorts().add(output); + downstream.getRightPorts().addAll(connection.getRightPorts()); + downstream.setIterated(connection.isIterated()); + connections.add(upstream); + connections.add(downstream); + return connections; + } + + /** + * Create a new instance delay instances using the given reactor class. The supplied time value is + * used to override the default interval (which is zero). If the target supports parametric + * polymorphism, then a single class may be used for each instantiation, in which case a non-empty + * string must be supplied to parameterize the instance. A default name ("delay") is assigned to + * the instantiation, but this name must be overridden at the call site, where checks can be done + * to avoid name collisions in the container in which the instantiation is to be placed. Such + * checks (or modifications of the AST) are not performed in this method in order to avoid causing + * concurrent modification exceptions. + * + * @param delayClass The class to create an instantiation for + * @param connection The connection to create a delay instantiation foe + * @param genericArg A string that denotes the appropriate type parameter, which should be null or + * empty if the target does not support generics. + * @param defineWidthFromConnection If this is true and if the connection is a wide connection, + * then instantiate a bank of delays where the width is given by ports involved in the + * connection. Otherwise, the width will be unspecified indicating a variable length. + * @param isPhysical Is this a delay instance using a physical action. These are used for + * implementing Physical Connections. If true we will accept zero delay on the connection. + */ + private static Instantiation getDelayInstance( + Reactor delayClass, + Connection connection, + String genericArg, + Boolean defineWidthFromConnection, + Boolean isPhysical) { + Instantiation delayInstance = factory.createInstantiation(); + delayInstance.setReactorClass(delayClass); + if (genericArg != null) { + Code code = factory.createCode(); + code.setBody(genericArg); + Type type = factory.createType(); + type.setCode(code); + delayInstance.getTypeArgs().add(type); } - - /** - * Create a new instance delay instances using the given reactor class. - * The supplied time value is used to override the default interval (which - * is zero). - * If the target supports parametric polymorphism, then a single class may - * be used for each instantiation, in which case a non-empty string must - * be supplied to parameterize the instance. - * A default name ("delay") is assigned to the instantiation, but this - * name must be overridden at the call site, where checks can be done to - * avoid name collisions in the container in which the instantiation is - * to be placed. Such checks (or modifications of the AST) are not - * performed in this method in order to avoid causing concurrent - * modification exceptions. - * @param delayClass The class to create an instantiation for - * @param connection The connection to create a delay instantiation foe - * @param genericArg A string that denotes the appropriate type parameter, - * which should be null or empty if the target does not support generics. - * @param defineWidthFromConnection If this is true and if the connection - * is a wide connection, then instantiate a bank of delays where the width - * is given by ports involved in the connection. Otherwise, the width will - * be unspecified indicating a variable length. - * @param isPhysical Is this a delay instance using a physical action. - * These are used for implementing Physical Connections. If true - * we will accept zero delay on the connection. - */ - private static Instantiation getDelayInstance(Reactor delayClass, - Connection connection, String genericArg, Boolean defineWidthFromConnection, Boolean isPhysical) { - Instantiation delayInstance = factory.createInstantiation(); - delayInstance.setReactorClass(delayClass); - if (genericArg != null) { - Code code = factory.createCode(); - code.setBody(genericArg); - Type type = factory.createType(); - type.setCode(code); - delayInstance.getTypeArgs().add(type); - } - if (ASTUtils.hasMultipleConnections(connection)) { - WidthSpec widthSpec = factory.createWidthSpec(); - if (defineWidthFromConnection) { - // Add all left ports of the connection to the WidthSpec of the generated delay instance. - // This allows the code generator to later infer the width from the involved ports. - // We only consider the left ports here, as they could be part of a broadcast. In this case, we want - // to delay the ports first, and then broadcast the output of the delays. - for (VarRef port : connection.getLeftPorts()) { - WidthTerm term = factory.createWidthTerm(); - term.setPort(EcoreUtil.copy(port)); - widthSpec.getTerms().add(term); - } - } else { - widthSpec.setOfVariableLength(true); - } - delayInstance.setWidthSpec(widthSpec); - } - // Allow physical connections with no after delay - // they will use the default min_delay of 0. - if (!isPhysical || connection.getDelay() != null) { - Assignment assignment = factory.createAssignment(); - assignment.setLhs(delayClass.getParameters().get(0)); - Initializer init = factory.createInitializer(); - init.getExprs().add(Objects.requireNonNull(connection.getDelay(), "null delay")); - assignment.setRhs(init); - delayInstance.getParameters().add(assignment); + if (ASTUtils.hasMultipleConnections(connection)) { + WidthSpec widthSpec = factory.createWidthSpec(); + if (defineWidthFromConnection) { + // Add all left ports of the connection to the WidthSpec of the generated delay instance. + // This allows the code generator to later infer the width from the involved ports. + // We only consider the left ports here, as they could be part of a broadcast. In this case, + // we want + // to delay the ports first, and then broadcast the output of the delays. + for (VarRef port : connection.getLeftPorts()) { + WidthTerm term = factory.createWidthTerm(); + term.setPort(EcoreUtil.copy(port)); + widthSpec.getTerms().add(term); } - - delayInstance.setName("delay"); // This has to be overridden. - return delayInstance; + } else { + widthSpec.setOfVariableLength(true); + } + delayInstance.setWidthSpec(widthSpec); + } + // Allow physical connections with no after delay + // they will use the default min_delay of 0. + if (!isPhysical || connection.getDelay() != null) { + Assignment assignment = factory.createAssignment(); + assignment.setLhs(delayClass.getParameters().get(0)); + Initializer init = factory.createInitializer(); + init.getExprs().add(Objects.requireNonNull(connection.getDelay(), "null delay")); + assignment.setRhs(init); + delayInstance.getParameters().add(assignment); } - /** - * Return a synthesized AST node that represents the definition of a delay - * reactor. Depending on whether the target supports generics, either this - * method will synthesize a generic definition and keep returning it upon - * subsequent calls, or otherwise, it will synthesize a new definition for - * each new type it hasn't yet created a compatible delay reactor for. - * @param type The type the delay class must be compatible with. - * @param isPhysical Is this delay reactor using a physical action. - */ - private Reactor getDelayClass(Type type, boolean isPhysical) { - String className; - if (targetTypes.supportsGenerics()) { - className = DelayBodyGenerator.GEN_DELAY_CLASS_NAME; - } else { - String id = Integer.toHexString(InferredType.fromAST(type).toText().hashCode()); - className = String.format("%s_%s", DelayBodyGenerator.GEN_DELAY_CLASS_NAME, id); - } - - // Only add class definition if it is not already there. - Reactor classDef = findDelayClass(className); - if (classDef != null) { - return classDef; - } - - Reactor delayClass = factory.createReactor(); - Parameter delayParameter = factory.createParameter(); - Action action = factory.createAction(); - VarRef triggerRef = factory.createVarRef(); - VarRef effectRef = factory.createVarRef(); - Input input = factory.createInput(); - Output output = factory.createOutput(); - VarRef inRef = factory.createVarRef(); - VarRef outRef = factory.createVarRef(); - - Reaction r1 = factory.createReaction(); - Reaction r2 = factory.createReaction(); - - delayParameter.setName("delay"); - delayParameter.setType(factory.createType()); - delayParameter.getType().setId("time"); - delayParameter.getType().setTime(true); - Time defaultTime = factory.createTime(); - defaultTime.setUnit(null); - defaultTime.setInterval(0); - Initializer init = factory.createInitializer(); - init.setParens(true); - init.setBraces(false); - init.getExprs().add(defaultTime); - delayParameter.setInit(init); - - // Name the newly created action; set its delay and type. - action.setName("act"); - var paramRef = factory.createParameterReference(); - paramRef.setParameter(delayParameter); - action.setMinDelay(paramRef); - if (isPhysical) { - action.setOrigin(ActionOrigin.PHYSICAL); - } else { - action.setOrigin(ActionOrigin.LOGICAL); - } + delayInstance.setName("delay"); // This has to be overridden. + return delayInstance; + } + + /** + * Return a synthesized AST node that represents the definition of a delay reactor. Depending on + * whether the target supports generics, either this method will synthesize a generic definition + * and keep returning it upon subsequent calls, or otherwise, it will synthesize a new definition + * for each new type it hasn't yet created a compatible delay reactor for. + * + * @param type The type the delay class must be compatible with. + * @param isPhysical Is this delay reactor using a physical action. + */ + private Reactor getDelayClass(Type type, boolean isPhysical) { + String className; + if (targetTypes.supportsGenerics()) { + className = DelayBodyGenerator.GEN_DELAY_CLASS_NAME; + } else { + String id = Integer.toHexString(InferredType.fromAST(type).toText().hashCode()); + className = String.format("%s_%s", DelayBodyGenerator.GEN_DELAY_CLASS_NAME, id); + } - if (targetTypes.supportsGenerics()) { - action.setType(factory.createType()); - action.getType().setId("T"); - } else { - action.setType(EcoreUtil.copy(type)); - } + // Only add class definition if it is not already there. + Reactor classDef = findDelayClass(className); + if (classDef != null) { + return classDef; + } - input.setName("inp"); - input.setType(EcoreUtil.copy(action.getType())); - - output.setName("out"); - output.setType(EcoreUtil.copy(action.getType())); - - // Establish references to the involved ports. - inRef.setVariable(input); - outRef.setVariable(output); - - // Establish references to the action. - triggerRef.setVariable(action); - effectRef.setVariable(action); - - // Add the action to the reactor. - delayClass.setName(className); - delayClass.getActions().add(action); - - // Configure the second reaction, which reads the input. - r1.getTriggers().add(inRef); - r1.getEffects().add(effectRef); - r1.setCode(factory.createCode()); - r1.getCode().setBody(generator.generateDelayBody(action, inRef)); - - // Configure the first reaction, which produces the output. - r2.getTriggers().add(triggerRef); - r2.getEffects().add(outRef); - r2.setCode(factory.createCode()); - r2.getCode().setBody(generator.generateForwardBody(action, outRef)); - - generator.finalizeReactions(r1, r2); - - // Add the reactions to the newly created reactor class. - // These need to go in the opposite order in case - // a new input arrives at the same time the delayed - // output is delivered! - delayClass.getReactions().add(r2); - delayClass.getReactions().add(r1); - - // Add a type parameter if the target supports it. - if (targetTypes.supportsGenerics()) { - TypeParm parm = factory.createTypeParm(); - parm.setLiteral(generator.generateDelayGeneric()); - delayClass.getTypeParms().add(parm); - } - delayClass.getInputs().add(input); - delayClass.getOutputs().add(output); - delayClass.getParameters().add(delayParameter); - addDelayClass(delayClass); - return delayClass; + Reactor delayClass = factory.createReactor(); + Parameter delayParameter = factory.createParameter(); + Action action = factory.createAction(); + VarRef triggerRef = factory.createVarRef(); + VarRef effectRef = factory.createVarRef(); + Input input = factory.createInput(); + Output output = factory.createOutput(); + VarRef inRef = factory.createVarRef(); + VarRef outRef = factory.createVarRef(); + + Reaction r1 = factory.createReaction(); + Reaction r2 = factory.createReaction(); + + delayParameter.setName("delay"); + delayParameter.setType(factory.createType()); + delayParameter.getType().setId("time"); + delayParameter.getType().setTime(true); + Time defaultTime = factory.createTime(); + defaultTime.setUnit(null); + defaultTime.setInterval(0); + Initializer init = factory.createInitializer(); + init.setParens(true); + init.setBraces(false); + init.getExprs().add(defaultTime); + delayParameter.setInit(init); + + // Name the newly created action; set its delay and type. + action.setName("act"); + var paramRef = factory.createParameterReference(); + paramRef.setParameter(delayParameter); + action.setMinDelay(paramRef); + if (isPhysical) { + action.setOrigin(ActionOrigin.PHYSICAL); + } else { + action.setOrigin(ActionOrigin.LOGICAL); } - /** - * Store the given reactor in the collection of generated delay classes - * and insert it in the AST under the top-level reactor's node. - */ - private void addDelayClass(Reactor generatedDelay) { - // Record this class, so it can be reused. - delayClasses.add(generatedDelay); - // And hook it into the AST. - EObject node = IteratorExtensions.findFirst(mainResource.getAllContents(), Model.class::isInstance); - ((Model) node).getReactors().add(generatedDelay); + if (targetTypes.supportsGenerics()) { + action.setType(factory.createType()); + action.getType().setId("T"); + } else { + action.setType(EcoreUtil.copy(type)); } - /** - * Return the generated delay reactor that corresponds to the given class - * name if it had been created already, {@code null} otherwise. - */ - private Reactor findDelayClass(String className) { - return IterableExtensions.findFirst(delayClasses, it -> it.getName().equals(className)); + input.setName("inp"); + input.setType(EcoreUtil.copy(action.getType())); + + output.setName("out"); + output.setType(EcoreUtil.copy(action.getType())); + + // Establish references to the involved ports. + inRef.setVariable(input); + outRef.setVariable(output); + + // Establish references to the action. + triggerRef.setVariable(action); + effectRef.setVariable(action); + + // Add the action to the reactor. + delayClass.setName(className); + delayClass.getActions().add(action); + + // Configure the second reaction, which reads the input. + r1.getTriggers().add(inRef); + r1.getEffects().add(effectRef); + r1.setCode(factory.createCode()); + r1.getCode().setBody(generator.generateDelayBody(action, inRef)); + + // Configure the first reaction, which produces the output. + r2.getTriggers().add(triggerRef); + r2.getEffects().add(outRef); + r2.setCode(factory.createCode()); + r2.getCode().setBody(generator.generateForwardBody(action, outRef)); + + generator.finalizeReactions(r1, r2); + + // Add the reactions to the newly created reactor class. + // These need to go in the opposite order in case + // a new input arrives at the same time the delayed + // output is delivered! + delayClass.getReactions().add(r2); + delayClass.getReactions().add(r1); + + // Add a type parameter if the target supports it. + if (targetTypes.supportsGenerics()) { + TypeParm parm = factory.createTypeParm(); + parm.setLiteral(generator.generateDelayGeneric()); + delayClass.getTypeParms().add(parm); } + delayClass.getInputs().add(input); + delayClass.getOutputs().add(output); + delayClass.getParameters().add(delayParameter); + addDelayClass(delayClass); + return delayClass; + } + + /** + * Store the given reactor in the collection of generated delay classes and insert it in the AST + * under the top-level reactor's node. + */ + private void addDelayClass(Reactor generatedDelay) { + // Record this class, so it can be reused. + delayClasses.add(generatedDelay); + // And hook it into the AST. + EObject node = + IteratorExtensions.findFirst(mainResource.getAllContents(), Model.class::isInstance); + ((Model) node).getReactors().add(generatedDelay); + } + + /** + * Return the generated delay reactor that corresponds to the given class name if it had been + * created already, {@code null} otherwise. + */ + private Reactor findDelayClass(String className) { + return IterableExtensions.findFirst(delayClasses, it -> it.getName().equals(className)); + } } diff --git a/org.lflang/src/org/lflang/ast/FormattingUtils.java b/org.lflang/src/org/lflang/ast/FormattingUtils.java index 860e3d6bb2..9b47440391 100644 --- a/org.lflang/src/org/lflang/ast/FormattingUtils.java +++ b/org.lflang/src/org/lflang/ast/FormattingUtils.java @@ -8,264 +8,241 @@ import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.EObject; - import org.lflang.Target; import org.lflang.lf.Model; /** * Utility functions that determine the specific behavior of the LF formatter. + * * @author Peter Donovan * @author Billy Bao */ public class FormattingUtils { - /** - * The minimum number of columns that should be allotted to a comment. - * This is relevant in case of high indentation/small wrapLength. - */ - private static final int MINIMUM_COMMENT_WIDTH_IN_COLUMNS = 15; + /** + * The minimum number of columns that should be allotted to a comment. This is relevant in case of + * high indentation/small wrapLength. + */ + private static final int MINIMUM_COMMENT_WIDTH_IN_COLUMNS = 15; - /** Match a multiline comment. */ - private static final Pattern MULTILINE_COMMENT = Pattern.compile( - "\\s*/\\*\\v?(\\V*\\v+)*\\V*" - ); + /** Match a multiline comment. */ + private static final Pattern MULTILINE_COMMENT = Pattern.compile("\\s*/\\*\\v?(\\V*\\v+)*\\V*"); - /** The number of spaces to prepend to a line per indentation level. */ - private static final int INDENTATION = 4; + /** The number of spaces to prepend to a line per indentation level. */ + private static final int INDENTATION = 4; - public static final int DEFAULT_LINE_LENGTH = 80; + public static final int DEFAULT_LINE_LENGTH = 80; - static final int MAX_WHITESPACE_USED_FOR_ALIGNMENT = 20; + static final int MAX_WHITESPACE_USED_FOR_ALIGNMENT = 20; - static final long BADNESS_PER_CHARACTER_VIOLATING_LINE_LENGTH = 20; + static final long BADNESS_PER_CHARACTER_VIOLATING_LINE_LENGTH = 20; - static final long BADNESS_PER_LEVEL_OF_COMMENT_DISPLACEMENT = 1000; + static final long BADNESS_PER_LEVEL_OF_COMMENT_DISPLACEMENT = 1000; - static final long BADNESS_PER_NEWLINE = 1; + static final long BADNESS_PER_NEWLINE = 1; - /** - * Return a String representation of {@code object}, with lines wrapped at - * {@code lineLength}. - */ - public static String render(EObject object, int lineLength) { - return render(object, lineLength, inferTarget(object), false); - } + /** Return a String representation of {@code object}, with lines wrapped at {@code lineLength}. */ + public static String render(EObject object, int lineLength) { + return render(object, lineLength, inferTarget(object), false); + } - /** Return a function that renders AST nodes for the given target. */ - public static Function renderer(Target target) { - return object -> render(object, DEFAULT_LINE_LENGTH, target, true); - } + /** Return a function that renders AST nodes for the given target. */ + public static Function renderer(Target target) { + return object -> render(object, DEFAULT_LINE_LENGTH, target, true); + } - /** - * Return a String representation of {@code object}, with lines wrapped at - * {@code lineLength}, with the assumption that the target language is - * {@code target}. - */ - public static String render(EObject object, int lineLength, Target target, boolean codeMapTags) { - MalleableString ms = ToLf.instance.doSwitch(object); - String singleLineCommentPrefix = target.getSingleLineCommentPrefix(); - ms.findBestRepresentation( - () -> ms.render(INDENTATION, singleLineCommentPrefix, codeMapTags, null), - r -> r.levelsOfCommentDisplacement() * BADNESS_PER_LEVEL_OF_COMMENT_DISPLACEMENT + /** + * Return a String representation of {@code object}, with lines wrapped at {@code lineLength}, + * with the assumption that the target language is {@code target}. + */ + public static String render(EObject object, int lineLength, Target target, boolean codeMapTags) { + MalleableString ms = ToLf.instance.doSwitch(object); + String singleLineCommentPrefix = target.getSingleLineCommentPrefix(); + ms.findBestRepresentation( + () -> ms.render(INDENTATION, singleLineCommentPrefix, codeMapTags, null), + r -> + r.levelsOfCommentDisplacement() * BADNESS_PER_LEVEL_OF_COMMENT_DISPLACEMENT + countCharactersViolatingLineLength(lineLength).applyAsLong(r.rendering()) * BADNESS_PER_CHARACTER_VIOLATING_LINE_LENGTH + countNewlines(r.rendering()) * BADNESS_PER_NEWLINE, - lineLength, - INDENTATION, - singleLineCommentPrefix - ); - var optimizedRendering = ms.render(INDENTATION, singleLineCommentPrefix, codeMapTags, null); - List comments = optimizedRendering.unplacedComments().toList(); - return comments.stream().allMatch(String::isBlank) ? optimizedRendering.rendering() - : lineWrapComments(comments, lineLength, singleLineCommentPrefix) - + "\n" + optimizedRendering.rendering(); + lineLength, + INDENTATION, + singleLineCommentPrefix); + var optimizedRendering = ms.render(INDENTATION, singleLineCommentPrefix, codeMapTags, null); + List comments = optimizedRendering.unplacedComments().toList(); + return comments.stream().allMatch(String::isBlank) + ? optimizedRendering.rendering() + : lineWrapComments(comments, lineLength, singleLineCommentPrefix) + + "\n" + + optimizedRendering.rendering(); + } + + /** Infer the target language of the object. */ + private static Target inferTarget(EObject object) { + if (object instanceof Model model) { + var targetDecl = ASTUtils.targetDecl(model); + if (targetDecl != null) { + return Target.fromDecl(targetDecl); + } } - - /** - * Infer the target language of the object. - */ - private static Target inferTarget(EObject object) { - if (object instanceof Model model) { - var targetDecl = ASTUtils.targetDecl(model); - if (targetDecl != null) { - return Target.fromDecl(targetDecl); - } - } - throw new IllegalArgumentException("Unable to determine target based on given EObject."); - } - - /** - * Return a String representation of {@code object} using a reasonable - * default line length. - */ - public static String render(EObject object) { return render(object, DEFAULT_LINE_LENGTH); } - - /** - * Return the number of characters appearing in columns exceeding {@code lineLength}. - */ - private static ToLongFunction countCharactersViolatingLineLength(int lineLength) { - return s -> s.lines().mapToInt(it -> Math.max(0, it.length() - lineLength)).sum(); - } - - private static long countNewlines(String s) { - return s.lines().count(); - } - - /** - * Break lines at spaces so that each line is no more than {@code width} - * columns long, if possible. Normalize whitespace. Merge consecutive - * single-line comments. - */ - static String lineWrapComments( - List comments, - int width, - String singleLineCommentPrefix - ) { - StringBuilder ret = new StringBuilder(); - StringBuilder current = new StringBuilder(); - for (String comment : comments) { - if (comment.stripLeading().startsWith("/*")) { - if (!ret.isEmpty() && !current.isEmpty()) ret.append("\n"); - ret.append(lineWrapComment(current.toString(), width, singleLineCommentPrefix)); - current.setLength(0); - if (!ret.isEmpty()) ret.append("\n"); - ret.append(lineWrapComment(comment.strip(), width, singleLineCommentPrefix)); - } else { - if (!current.isEmpty()) current.append("\n"); - current.append(comment.strip()); - } - } + throw new IllegalArgumentException("Unable to determine target based on given EObject."); + } + + /** Return a String representation of {@code object} using a reasonable default line length. */ + public static String render(EObject object) { + return render(object, DEFAULT_LINE_LENGTH); + } + + /** Return the number of characters appearing in columns exceeding {@code lineLength}. */ + private static ToLongFunction countCharactersViolatingLineLength(int lineLength) { + return s -> s.lines().mapToInt(it -> Math.max(0, it.length() - lineLength)).sum(); + } + + private static long countNewlines(String s) { + return s.lines().count(); + } + + /** + * Break lines at spaces so that each line is no more than {@code width} columns long, if + * possible. Normalize whitespace. Merge consecutive single-line comments. + */ + static String lineWrapComments(List comments, int width, String singleLineCommentPrefix) { + StringBuilder ret = new StringBuilder(); + StringBuilder current = new StringBuilder(); + for (String comment : comments) { + if (comment.stripLeading().startsWith("/*")) { if (!ret.isEmpty() && !current.isEmpty()) ret.append("\n"); ret.append(lineWrapComment(current.toString(), width, singleLineCommentPrefix)); - return ret.toString(); + current.setLength(0); + if (!ret.isEmpty()) ret.append("\n"); + ret.append(lineWrapComment(comment.strip(), width, singleLineCommentPrefix)); + } else { + if (!current.isEmpty()) current.append("\n"); + current.append(comment.strip()); + } } - /** Wrap lines. Do not merge lines that start with weird characters. */ - private static String lineWrapComment( - String comment, - int width, - String singleLineCommentPrefix - ) { - width = Math.max(width, MINIMUM_COMMENT_WIDTH_IN_COLUMNS); - List> paragraphs = Arrays.stream( - comment.strip() - .replaceAll("^/?((\\*|//|#)\\s*)+", "") - .replaceAll("\\s*\\*/$", "") - .replaceAll("(?<=(\\r\\n|\\r|\\n))\\h*(\\*|//|#)\\h*", "") - .split("(\n\\s*){2,}") - ).map(s -> Arrays.stream(s.split("(\\r\\n|\\r|\\n)\\h*(?=[@#$%^&*\\-+=:;<>/])"))) + if (!ret.isEmpty() && !current.isEmpty()) ret.append("\n"); + ret.append(lineWrapComment(current.toString(), width, singleLineCommentPrefix)); + return ret.toString(); + } + /** Wrap lines. Do not merge lines that start with weird characters. */ + private static String lineWrapComment(String comment, int width, String singleLineCommentPrefix) { + width = Math.max(width, MINIMUM_COMMENT_WIDTH_IN_COLUMNS); + List> paragraphs = + Arrays.stream( + comment + .strip() + .replaceAll("^/?((\\*|//|#)\\s*)+", "") + .replaceAll("\\s*\\*/$", "") + .replaceAll("(?<=(\\r\\n|\\r|\\n))\\h*(\\*|//|#)\\h*", "") + .split("(\n\\s*){2,}")) + .map(s -> Arrays.stream(s.split("(\\r\\n|\\r|\\n)\\h*(?=[@#$%^&*\\-+=:;<>/])"))) .map(stream -> stream.map(s -> s.replaceAll("\\s+", " "))) .map(Stream::toList) .toList(); - if (MULTILINE_COMMENT.matcher(comment).matches()) { - if (paragraphs.size() == 1 && paragraphs.get(0).size() == 1) { - String singleLineRepresentation = String.format( - "/** %s */", paragraphs.get(0).get(0) - ); - if (singleLineRepresentation.length() <= width) return singleLineRepresentation; - } - return String.format("/**\n%s\n */", lineWrapComment(paragraphs, width, " * ")); - } - return lineWrapComment(paragraphs, width, singleLineCommentPrefix + " "); - } - - /** - * Wrap lines. - * @param paragraphs A list of lists of subparagraphs. - * @param width The preferred maximum number of columns per line. - * @param linePrefix A string to prepend to each line of comment. - */ - private static String lineWrapComment( - List> paragraphs, - int width, - String linePrefix - ) { - int widthAfterPrefix = Math.max( - width - linePrefix.length(), - MINIMUM_COMMENT_WIDTH_IN_COLUMNS - ); - return paragraphs.stream() - .map(paragraph -> wrapLines(paragraph, widthAfterPrefix) - .map(s -> (linePrefix + s.stripLeading()).stripTrailing()) - .collect(Collectors.joining("\n")) - ).collect(Collectors.joining(String.format("\n%s\n", linePrefix.stripTrailing()))); + if (MULTILINE_COMMENT.matcher(comment).matches()) { + if (paragraphs.size() == 1 && paragraphs.get(0).size() == 1) { + String singleLineRepresentation = String.format("/** %s */", paragraphs.get(0).get(0)); + if (singleLineRepresentation.length() <= width) return singleLineRepresentation; + } + return String.format("/**\n%s\n */", lineWrapComment(paragraphs, width, " * ")); } - - /** Wrap a given paragraph. */ - private static Stream wrapLines(List subparagraphs, int width) { - var ret = new ArrayList(); - for (String s : subparagraphs) { - int numCharactersProcessed = 0; - while (numCharactersProcessed + width < s.length()) { - // try to wrap at space - int breakAt = s.lastIndexOf(' ', numCharactersProcessed + width); - // if unable to find space in limit, extend to the first space we find - if (breakAt < numCharactersProcessed) { - breakAt = s.indexOf(' ', numCharactersProcessed + width); - } - if (breakAt < numCharactersProcessed) breakAt = s.length(); - ret.add(s.substring(numCharactersProcessed, breakAt)); - numCharactersProcessed = breakAt + 1; - } - if (numCharactersProcessed < s.length()) ret.add(s.substring(numCharactersProcessed)); + return lineWrapComment(paragraphs, width, singleLineCommentPrefix + " "); + } + + /** + * Wrap lines. + * + * @param paragraphs A list of lists of subparagraphs. + * @param width The preferred maximum number of columns per line. + * @param linePrefix A string to prepend to each line of comment. + */ + private static String lineWrapComment( + List> paragraphs, int width, String linePrefix) { + int widthAfterPrefix = Math.max(width - linePrefix.length(), MINIMUM_COMMENT_WIDTH_IN_COLUMNS); + return paragraphs.stream() + .map( + paragraph -> + wrapLines(paragraph, widthAfterPrefix) + .map(s -> (linePrefix + s.stripLeading()).stripTrailing()) + .collect(Collectors.joining("\n"))) + .collect(Collectors.joining(String.format("\n%s\n", linePrefix.stripTrailing()))); + } + + /** Wrap a given paragraph. */ + private static Stream wrapLines(List subparagraphs, int width) { + var ret = new ArrayList(); + for (String s : subparagraphs) { + int numCharactersProcessed = 0; + while (numCharactersProcessed + width < s.length()) { + // try to wrap at space + int breakAt = s.lastIndexOf(' ', numCharactersProcessed + width); + // if unable to find space in limit, extend to the first space we find + if (breakAt < numCharactersProcessed) { + breakAt = s.indexOf(' ', numCharactersProcessed + width); } - return ret.stream(); + if (breakAt < numCharactersProcessed) breakAt = s.length(); + ret.add(s.substring(numCharactersProcessed, breakAt)); + numCharactersProcessed = breakAt + 1; + } + if (numCharactersProcessed < s.length()) ret.add(s.substring(numCharactersProcessed)); } - - /** - * Merge {@code comment} into the given list of strings without changing the - * length of the list, preferably in a place that indicates that - * {@code comment} is associated with the {@code i}th string. - * @param comment A comment associated with an element of - * {@code components}. - * @param components A list of strings that will be rendered in sequence. - * @param i The position of the component associated with {@code comment}. - * @param width The ideal number of columns available for comments that - * appear on their own line. - * @param keepCommentsOnSameLine Whether to make a best-effort attempt to - * keep the comment on the same line as the associated string. - * @param singleLineCommentPrefix The prefix that marks the start of a - * single-line comment. - * @param startColumn The ideal starting column of a comment - * @return Whether the comment placement succeeded. - */ - static boolean placeComment( - List comment, - List components, - int i, - int width, - boolean keepCommentsOnSameLine, - String singleLineCommentPrefix, - int startColumn - ) { - if (comment.stream().allMatch(String::isBlank)) return true; - String wrapped = FormattingUtils.lineWrapComments(comment, width, singleLineCommentPrefix); - if (keepCommentsOnSameLine && wrapped.lines().count() == 1 && !wrapped.startsWith("/**")) { - int sum = 0; - for (int j = 0; j < components.size(); j++) { - String current = components.get(j); - if (j >= i && current.contains("\n")) { - components.set(j, components.get(j).replaceFirst( - "\n", - " ".repeat(Math.max( - 2, - startColumn - sum - components.get(j).indexOf("\n") - )) + wrapped + "\n" - )); - return true; - } else if (current.contains("\n")) { - sum = current.length() - current.lastIndexOf("\n") - 1; - } else { - sum += current.length(); - } - } + return ret.stream(); + } + + /** + * Merge {@code comment} into the given list of strings without changing the length of the list, + * preferably in a place that indicates that {@code comment} is associated with the {@code i}th + * string. + * + * @param comment A comment associated with an element of {@code components}. + * @param components A list of strings that will be rendered in sequence. + * @param i The position of the component associated with {@code comment}. + * @param width The ideal number of columns available for comments that appear on their own line. + * @param keepCommentsOnSameLine Whether to make a best-effort attempt to keep the comment on the + * same line as the associated string. + * @param singleLineCommentPrefix The prefix that marks the start of a single-line comment. + * @param startColumn The ideal starting column of a comment + * @return Whether the comment placement succeeded. + */ + static boolean placeComment( + List comment, + List components, + int i, + int width, + boolean keepCommentsOnSameLine, + String singleLineCommentPrefix, + int startColumn) { + if (comment.stream().allMatch(String::isBlank)) return true; + String wrapped = FormattingUtils.lineWrapComments(comment, width, singleLineCommentPrefix); + if (keepCommentsOnSameLine && wrapped.lines().count() == 1 && !wrapped.startsWith("/**")) { + int sum = 0; + for (int j = 0; j < components.size(); j++) { + String current = components.get(j); + if (j >= i && current.contains("\n")) { + components.set( + j, + components + .get(j) + .replaceFirst( + "\n", + " ".repeat(Math.max(2, startColumn - sum - components.get(j).indexOf("\n"))) + + wrapped + + "\n")); + return true; + } else if (current.contains("\n")) { + sum = current.length() - current.lastIndexOf("\n") - 1; + } else { + sum += current.length(); } - for (int j = i - 1; j >= 0; j--) { - if (components.get(j).endsWith("\n")) { - components.set(j, String.format("%s%s\n", components.get(j), wrapped)); - return true; - } - } - return false; + } + } + for (int j = i - 1; j >= 0; j--) { + if (components.get(j).endsWith("\n")) { + components.set(j, String.format("%s%s\n", components.get(j), wrapped)); + return true; + } } + return false; + } } diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/src/org/lflang/ast/IsEqual.java index af0274ea2a..bc0fc31abf 100644 --- a/org.lflang/src/org/lflang/ast/IsEqual.java +++ b/org.lflang/src/org/lflang/ast/IsEqual.java @@ -6,9 +6,7 @@ import java.util.function.BiPredicate; import java.util.function.Function; import java.util.stream.Collectors; - import org.eclipse.emf.ecore.EObject; - import org.lflang.TimeUnit; import org.lflang.lf.Action; import org.lflang.lf.Array; @@ -66,620 +64,603 @@ import org.lflang.lf.util.LfSwitch; /** - * Switch class that checks if subtrees of the AST are semantically equivalent - * to each other. Return {@code false} if they are not equivalent; return - * {@code true} or {@code false} (but preferably {@code true}) if they are - * equivalent. + * Switch class that checks if subtrees of the AST are semantically equivalent to each other. Return + * {@code false} if they are not equivalent; return {@code true} or {@code false} (but preferably + * {@code true}) if they are equivalent. */ public class IsEqual extends LfSwitch { - private final EObject otherObject; - - public IsEqual(EObject other) { - this.otherObject = other; - } - - @Override - public Boolean doSwitch(EObject eObject) { - if (otherObject == eObject) return true; - if (eObject == null) return false; - return super.doSwitch(eObject); - } - - @Override - public Boolean caseModel(Model object) { - return new ComparisonMachine<>(object, Model.class) - .equivalent(Model::getTarget) - .listsEquivalent(Model::getImports) - .listsEquivalent(Model::getPreambles) - .listsEquivalent(Model::getReactors).conclusion; - } - - @Override - public Boolean caseImport(Import object) { - return new ComparisonMachine<>(object, Import.class) - .equalAsObjects(Import::getImportURI) - .listsEquivalent(Import::getReactorClasses).conclusion; - } - - @Override - public Boolean caseReactorDecl(ReactorDecl object) { - return new ComparisonMachine<>(object, ReactorDecl.class) - .equalAsObjects(ReactorDecl::getName) - .conclusion; - } - - @Override - public Boolean caseImportedReactor(ImportedReactor object) { - return new ComparisonMachine<>(object, ImportedReactor.class) - .equalAsObjects(ImportedReactor::getName) - .equivalent(ImportedReactor::getReactorClass) - .conclusion; - } - - @Override - public Boolean caseReactor(Reactor object) { - return new ComparisonMachine<>(object, Reactor.class) - .listsEquivalent(Reactor::getAttributes) - .equalAsObjects(Reactor::isFederated) - .equalAsObjects(Reactor::isRealtime) - .equalAsObjects(Reactor::isMain) - .equalAsObjects(Reactor::getName) - .listsEquivalent(Reactor::getTypeParms) - .listsEquivalent(Reactor::getParameters) - .equivalent(Reactor::getHost) - .listsEquivalent(Reactor::getSuperClasses) - .listsEquivalent(Reactor::getPreambles) - .listsEquivalent(Reactor::getInputs) - .listsEquivalent(Reactor::getOutputs) - .listsEquivalent(Reactor::getTimers) - .listsEquivalent(Reactor::getActions) - .listsEquivalent(Reactor::getInstantiations) - .listsEquivalent(Reactor::getConnections) - .listsEquivalent(Reactor::getStateVars) - .listsEquivalent(Reactor::getReactions) - .listsEquivalent(Reactor::getMethods) - .listsEquivalent(Reactor::getModes) - .conclusion; - } - - @Override - public Boolean caseTypeParm(TypeParm object) { - return new ComparisonMachine<>(object, TypeParm.class) - .equalAsObjects(TypeParm::getLiteral) - .equivalent(TypeParm::getCode) - .conclusion; - } - - @Override - public Boolean caseTargetDecl(TargetDecl object) { - return new ComparisonMachine<>(object, TargetDecl.class) - .equalAsObjects(TargetDecl::getName) - .equivalentModulo( - TargetDecl::getConfig, - (KeyValuePairs it) -> it != null && it.getPairs().isEmpty() ? null : it - ) - .conclusion; - } - - @Override - public Boolean caseStateVar(StateVar object) { - return new ComparisonMachine<>(object, StateVar.class) - .listsEquivalent(StateVar::getAttributes) - .equalAsObjects(StateVar::getName) - .equivalent(StateVar::getType) - .equivalent(StateVar::getInit) - .conclusion; - } - - @Override - public Boolean caseInitializer(Initializer object) { - // Empty braces are not equivalent to no init. - return new ComparisonMachine<>(object, Initializer.class) - .equalAsObjects(Initializer::isBraces) - // An initializer with no parens is equivalent to one with parens, - // if the list has a single element. This is probably going to change - // when we introduce equals initializers. - // .equalAsObjects(Initializer::isParens) - .listsEquivalent(Initializer::getExprs) - .conclusion; - } - - @Override - public Boolean caseMethod(Method object) { - return new ComparisonMachine<>(object, Method.class) - .equalAsObjects(Method::isConst) - .equalAsObjects(Method::getName) - .listsEquivalent(Method::getArguments) - .equivalent(Method::getReturn) - .equivalent(Method::getCode) - .conclusion; - } - - @Override - public Boolean caseMethodArgument(MethodArgument object) { - return new ComparisonMachine<>(object, MethodArgument.class) - .equalAsObjects(MethodArgument::getName) - .equivalent(MethodArgument::getType) - .conclusion; - } - - @Override - public Boolean caseInput(Input object) { - return new ComparisonMachine<>(object, Input.class) - .listsEquivalent(Input::getAttributes) - .equalAsObjects(Input::isMutable) - .equivalent(Input::getWidthSpec) - .equivalent(Input::getType) - .conclusion; - } - - @Override - public Boolean caseOutput(Output object) { - return new ComparisonMachine<>(object, Output.class) - .listsEquivalent(Output::getAttributes) - .equivalent(Output::getWidthSpec) - .equalAsObjects(Output::getName) - .equivalent(Output::getType) - .conclusion; - } - - @Override - public Boolean caseTimer(Timer object) { - return new ComparisonMachine<>(object, Timer.class) - .listsEquivalent(Timer::getAttributes) - .equalAsObjects(Timer::getName) - .equivalent(Timer::getOffset) - .equivalent(Timer::getPeriod) - .conclusion; - } - - @Override - public Boolean caseMode(Mode object) { - return new ComparisonMachine<>(object, Mode.class) - .equalAsObjects(Mode::isInitial) - .equalAsObjects(Mode::getName) - .listsEquivalent(Mode::getStateVars) - .listsEquivalent(Mode::getTimers) - .listsEquivalent(Mode::getActions) - .listsEquivalent(Mode::getInstantiations) - .listsEquivalent(Mode::getConnections) - .listsEquivalent(Mode::getReactions) - .conclusion; - } - - @Override - public Boolean caseAction(Action object) { - return new ComparisonMachine<>(object, Action.class) - .listsEquivalent(Action::getAttributes) - .equalAsObjects(Action::getOrigin) // This is an enum - .equalAsObjects(Action::getName) - .equivalent(Action::getMinDelay) - .equivalent(Action::getMinSpacing) - .equalAsObjects(Action::getPolicy) - .equivalent(Action::getType) - .conclusion; - } - - @Override - public Boolean caseAttribute(Attribute object) { - return new ComparisonMachine<>(object, Attribute.class) - .equalAsObjects(Attribute::getAttrName) - .listsEquivalent(Attribute::getAttrParms) - .conclusion; - } - - @Override - public Boolean caseAttrParm(AttrParm object) { - return new ComparisonMachine<>(object, AttrParm.class) - .equalAsObjects(AttrParm::getName) - .equalAsObjects(AttrParm::getValue) - .conclusion; - } - - @Override - public Boolean caseReaction(Reaction object) { - return new ComparisonMachine<>(object, Reaction.class) - .listsEquivalent(Reaction::getAttributes) - .listsEquivalent(Reaction::getTriggers) - .listsEquivalent(Reaction::getSources) - .listsEquivalent(Reaction::getEffects) - .equalAsObjects(Reaction::isMutation) - .equalAsObjects(Reaction::getName) - .equivalent(Reaction::getCode) - .equivalent(Reaction::getStp) - .equivalent(Reaction::getDeadline) - .conclusion; - } - - @Override - public Boolean caseTriggerRef(TriggerRef object) { - throw thereIsAMoreSpecificCase(TriggerRef.class, BuiltinTriggerRef.class, VarRef.class); - } - - @Override - public Boolean caseBuiltinTriggerRef(BuiltinTriggerRef object) { - return new ComparisonMachine<>(object, BuiltinTriggerRef.class) - .equalAsObjects(BuiltinTriggerRef::getType) // This is an enum - .conclusion; - } - - @Override - public Boolean caseDeadline(Deadline object) { - return new ComparisonMachine<>(object, Deadline.class) - .equivalent(Deadline::getDelay) - .equivalent(Deadline::getCode) - .conclusion; - } - - @Override - public Boolean caseSTP(STP object) { - return new ComparisonMachine<>(object, STP.class) - .equivalent(STP::getValue) - .equivalent(STP::getCode) - .conclusion; - } - - @Override - public Boolean casePreamble(Preamble object) { - return new ComparisonMachine<>(object, Preamble.class) - .equalAsObjects(Preamble::getVisibility) // This is an enum - .equivalent(Preamble::getCode) - .conclusion; - } - - @Override - public Boolean caseInstantiation(Instantiation object) { - return new ComparisonMachine<>(object, Instantiation.class) - .equalAsObjects(Instantiation::getName) - .equivalent(Instantiation::getWidthSpec) - .equivalent(Instantiation::getReactorClass) - .listsEquivalent(Instantiation::getTypeArgs) - .listsEquivalent(Instantiation::getParameters) - .equivalent(Instantiation::getHost) - .conclusion; - } - - @Override - public Boolean caseConnection(Connection object) { - return new ComparisonMachine<>(object, Connection.class) - .listsEquivalent(Connection::getLeftPorts) - .equalAsObjects(Connection::isIterated) - .equalAsObjects(Connection::isPhysical) - .listsEquivalent(Connection::getRightPorts) - .equivalent(Connection::getDelay) - .equivalent(Connection::getSerializer) - .conclusion; - } - - @Override - public Boolean caseSerializer(Serializer object) { - return new ComparisonMachine<>(object, Serializer.class) - .equalAsObjects(Serializer::getType) - .conclusion; - } - - @Override - public Boolean caseKeyValuePairs(KeyValuePairs object) { - return new ComparisonMachine<>(object, KeyValuePairs.class) - .listsEquivalent(KeyValuePairs::getPairs) - .conclusion; - } - - @Override - public Boolean caseKeyValuePair(KeyValuePair object) { - return new ComparisonMachine<>(object, KeyValuePair.class) - .equalAsObjects(KeyValuePair::getName) - .equivalent(KeyValuePair::getValue) - .conclusion; - } - - @Override - public Boolean caseArray(Array object) { - return new ComparisonMachine<>(object, Array.class) - .listsEquivalent(Array::getElements) - .conclusion; - } - - @Override - public Boolean caseElement(Element object) { - return new ComparisonMachine<>(object, Element.class) - .equivalent(Element::getKeyvalue) - .equivalent(Element::getArray) - .equalAsObjects(Element::getLiteral) - .equalAsObjects(Element::getId) - .equalAsObjects(Element::getUnit) - .conclusion; - } - - @Override - public Boolean caseTypedVariable(TypedVariable object) { - throw thereIsAMoreSpecificCase(TypedVariable.class, Port.class, Action.class); - } - - @Override - public Boolean caseVariable(Variable object) { - throw thereIsAMoreSpecificCase(Variable.class, TypedVariable.class, Timer.class, Mode.class); - } - - @Override - public Boolean caseVarRef(VarRef object) { - return new ComparisonMachine<>(object, VarRef.class) - .equalAsObjects(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable().getName()) - .equivalent(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable()) - .equalAsObjects(varRef -> varRef.getContainer() == null ? null : varRef.getContainer().getName()) - .equalAsObjects(VarRef::isInterleaved) - .equalAsObjects(VarRef::getTransition) - .conclusion; - } - - @Override - public Boolean caseAssignment(Assignment object) { - return new ComparisonMachine<>(object, Assignment.class) - .equivalent(Assignment::getLhs) - .equivalent(Assignment::getRhs) - .conclusion; - } - - @Override - public Boolean caseParameter(Parameter object) { - return new ComparisonMachine<>(object, Parameter.class) - .listsEquivalent(Parameter::getAttributes) - .equalAsObjects(Parameter::getName) - .equivalent(Parameter::getType) - .equivalent(Parameter::getInit) - .conclusion; - } - - @Override - public Boolean caseExpression(Expression object) { - throw thereIsAMoreSpecificCase( - Expression.class, - Literal.class, - Time.class, - ParameterReference.class, - Code.class, - BracedListExpression.class - ); - } - - @Override - public Boolean caseBracedListExpression(BracedListExpression object) { - return new ComparisonMachine<>(object, BracedListExpression.class) - .listsEquivalent(BracedListExpression::getItems) - .conclusion; - } - - @Override - public Boolean caseParameterReference(ParameterReference object) { - return new ComparisonMachine<>(object, ParameterReference.class) - .equivalent(ParameterReference::getParameter) - .conclusion; - } - - @Override - public Boolean caseTime(Time object) { - return new ComparisonMachine<>(object, Time.class) - .equalAsObjects(Time::getInterval) - .equalAsObjectsModulo( - Time::getUnit, - ((Function) TimeUnit::getCanonicalName) - .compose(TimeUnit::fromName) - ) - .conclusion; - } - - @Override - public Boolean casePort(Port object) { - throw thereIsAMoreSpecificCase(Port.class, Input.class, Output.class); - } - - @Override - public Boolean caseType(Type object) { - return new ComparisonMachine<>(object, Type.class) - .equivalent(Type::getCode) - .equalAsObjects(Type::isTime) - .equivalent(Type::getArraySpec) - .equalAsObjects(Type::getId) - .listsEquivalent(Type::getTypeArgs) - .listsEqualAsObjects(Type::getStars) - .equivalent(Type::getArraySpec) - .equivalent(Type::getCode) - .conclusion; - } - - @Override - public Boolean caseArraySpec(ArraySpec object) { - return new ComparisonMachine<>(object, ArraySpec.class) - .equalAsObjects(ArraySpec::isOfVariableLength) - .equalAsObjects(ArraySpec::getLength) - .conclusion; - } - - @Override - public Boolean caseWatchdog(Watchdog object) { - return new ComparisonMachine<>(object, Watchdog.class) - .equalAsObjects(Watchdog::getName) - .equivalent(Watchdog::getTimeout) - .listsEquivalent(Watchdog::getEffects) - .equivalent(Watchdog::getCode) - .conclusion; - } - - @Override - public Boolean caseWidthSpec(WidthSpec object) { - return new ComparisonMachine<>(object, WidthSpec.class) - .equalAsObjects(WidthSpec::isOfVariableLength) - .listsEquivalent(WidthSpec::getTerms) - .conclusion; - } - - @Override - public Boolean caseWidthTerm(WidthTerm object) { - return new ComparisonMachine<>(object, WidthTerm.class) - .equalAsObjects(WidthTerm::getWidth) - .equivalent(WidthTerm::getParameter) - .equivalent(WidthTerm::getPort) - .equivalent(WidthTerm::getCode) - .conclusion; - } - - @Override - public Boolean caseIPV4Host(IPV4Host object) { - return caseHost(object); - } - - @Override - public Boolean caseIPV6Host(IPV6Host object) { - return caseHost(object); - } - - @Override - public Boolean caseNamedHost(NamedHost object) { - return caseHost(object); - } - - @Override - public Boolean caseHost(Host object) { - return new ComparisonMachine<>(object, Host.class) - .equalAsObjects(Host::getUser) - .equalAsObjects(Host::getAddr) - .equalAsObjects(Host::getPort) - .conclusion; - } - - @Override - public Boolean caseCodeExpr(CodeExpr object) { - return new ComparisonMachine<>(object, CodeExpr.class).equivalent(CodeExpr::getCode).conclusion; - } - - @Override - public Boolean caseCode(Code object) { - return new ComparisonMachine<>(object, Code.class) - .equalAsObjectsModulo( - Code::getBody, - s -> s == null ? null : s.strip().stripIndent() - ) - .conclusion; - } - - @Override - public Boolean caseLiteral(Literal object) { - return new ComparisonMachine<>(object, Literal.class) - .equalAsObjects(Literal::getLiteral) - .conclusion; - } - - @Override - public Boolean defaultCase(EObject object) { - return super.defaultCase(object); - } - - @SafeVarargs - private UnsupportedOperationException thereIsAMoreSpecificCase( - Class thisCase, - Class... moreSpecificCases - ) { - return new UnsupportedOperationException(String.format( + private final EObject otherObject; + + public IsEqual(EObject other) { + this.otherObject = other; + } + + @Override + public Boolean doSwitch(EObject eObject) { + if (otherObject == eObject) return true; + if (eObject == null) return false; + return super.doSwitch(eObject); + } + + @Override + public Boolean caseModel(Model object) { + return new ComparisonMachine<>(object, Model.class) + .equivalent(Model::getTarget) + .listsEquivalent(Model::getImports) + .listsEquivalent(Model::getPreambles) + .listsEquivalent(Model::getReactors) + .conclusion; + } + + @Override + public Boolean caseImport(Import object) { + return new ComparisonMachine<>(object, Import.class) + .equalAsObjects(Import::getImportURI) + .listsEquivalent(Import::getReactorClasses) + .conclusion; + } + + @Override + public Boolean caseReactorDecl(ReactorDecl object) { + return new ComparisonMachine<>(object, ReactorDecl.class) + .equalAsObjects(ReactorDecl::getName) + .conclusion; + } + + @Override + public Boolean caseImportedReactor(ImportedReactor object) { + return new ComparisonMachine<>(object, ImportedReactor.class) + .equalAsObjects(ImportedReactor::getName) + .equivalent(ImportedReactor::getReactorClass) + .conclusion; + } + + @Override + public Boolean caseReactor(Reactor object) { + return new ComparisonMachine<>(object, Reactor.class) + .listsEquivalent(Reactor::getAttributes) + .equalAsObjects(Reactor::isFederated) + .equalAsObjects(Reactor::isRealtime) + .equalAsObjects(Reactor::isMain) + .equalAsObjects(Reactor::getName) + .listsEquivalent(Reactor::getTypeParms) + .listsEquivalent(Reactor::getParameters) + .equivalent(Reactor::getHost) + .listsEquivalent(Reactor::getSuperClasses) + .listsEquivalent(Reactor::getPreambles) + .listsEquivalent(Reactor::getInputs) + .listsEquivalent(Reactor::getOutputs) + .listsEquivalent(Reactor::getTimers) + .listsEquivalent(Reactor::getActions) + .listsEquivalent(Reactor::getInstantiations) + .listsEquivalent(Reactor::getConnections) + .listsEquivalent(Reactor::getStateVars) + .listsEquivalent(Reactor::getReactions) + .listsEquivalent(Reactor::getMethods) + .listsEquivalent(Reactor::getModes) + .conclusion; + } + + @Override + public Boolean caseTypeParm(TypeParm object) { + return new ComparisonMachine<>(object, TypeParm.class) + .equalAsObjects(TypeParm::getLiteral) + .equivalent(TypeParm::getCode) + .conclusion; + } + + @Override + public Boolean caseTargetDecl(TargetDecl object) { + return new ComparisonMachine<>(object, TargetDecl.class) + .equalAsObjects(TargetDecl::getName) + .equivalentModulo( + TargetDecl::getConfig, + (KeyValuePairs it) -> it != null && it.getPairs().isEmpty() ? null : it) + .conclusion; + } + + @Override + public Boolean caseStateVar(StateVar object) { + return new ComparisonMachine<>(object, StateVar.class) + .listsEquivalent(StateVar::getAttributes) + .equalAsObjects(StateVar::getName) + .equivalent(StateVar::getType) + .equivalent(StateVar::getInit) + .conclusion; + } + + @Override + public Boolean caseInitializer(Initializer object) { + // Empty braces are not equivalent to no init. + return new ComparisonMachine<>(object, Initializer.class) + .equalAsObjects(Initializer::isBraces) + // An initializer with no parens is equivalent to one with parens, + // if the list has a single element. This is probably going to change + // when we introduce equals initializers. + // .equalAsObjects(Initializer::isParens) + .listsEquivalent(Initializer::getExprs) + .conclusion; + } + + @Override + public Boolean caseMethod(Method object) { + return new ComparisonMachine<>(object, Method.class) + .equalAsObjects(Method::isConst) + .equalAsObjects(Method::getName) + .listsEquivalent(Method::getArguments) + .equivalent(Method::getReturn) + .equivalent(Method::getCode) + .conclusion; + } + + @Override + public Boolean caseMethodArgument(MethodArgument object) { + return new ComparisonMachine<>(object, MethodArgument.class) + .equalAsObjects(MethodArgument::getName) + .equivalent(MethodArgument::getType) + .conclusion; + } + + @Override + public Boolean caseInput(Input object) { + return new ComparisonMachine<>(object, Input.class) + .listsEquivalent(Input::getAttributes) + .equalAsObjects(Input::isMutable) + .equivalent(Input::getWidthSpec) + .equivalent(Input::getType) + .conclusion; + } + + @Override + public Boolean caseOutput(Output object) { + return new ComparisonMachine<>(object, Output.class) + .listsEquivalent(Output::getAttributes) + .equivalent(Output::getWidthSpec) + .equalAsObjects(Output::getName) + .equivalent(Output::getType) + .conclusion; + } + + @Override + public Boolean caseTimer(Timer object) { + return new ComparisonMachine<>(object, Timer.class) + .listsEquivalent(Timer::getAttributes) + .equalAsObjects(Timer::getName) + .equivalent(Timer::getOffset) + .equivalent(Timer::getPeriod) + .conclusion; + } + + @Override + public Boolean caseMode(Mode object) { + return new ComparisonMachine<>(object, Mode.class) + .equalAsObjects(Mode::isInitial) + .equalAsObjects(Mode::getName) + .listsEquivalent(Mode::getStateVars) + .listsEquivalent(Mode::getTimers) + .listsEquivalent(Mode::getActions) + .listsEquivalent(Mode::getInstantiations) + .listsEquivalent(Mode::getConnections) + .listsEquivalent(Mode::getReactions) + .conclusion; + } + + @Override + public Boolean caseAction(Action object) { + return new ComparisonMachine<>(object, Action.class) + .listsEquivalent(Action::getAttributes) + .equalAsObjects(Action::getOrigin) // This is an enum + .equalAsObjects(Action::getName) + .equivalent(Action::getMinDelay) + .equivalent(Action::getMinSpacing) + .equalAsObjects(Action::getPolicy) + .equivalent(Action::getType) + .conclusion; + } + + @Override + public Boolean caseAttribute(Attribute object) { + return new ComparisonMachine<>(object, Attribute.class) + .equalAsObjects(Attribute::getAttrName) + .listsEquivalent(Attribute::getAttrParms) + .conclusion; + } + + @Override + public Boolean caseAttrParm(AttrParm object) { + return new ComparisonMachine<>(object, AttrParm.class) + .equalAsObjects(AttrParm::getName) + .equalAsObjects(AttrParm::getValue) + .conclusion; + } + + @Override + public Boolean caseReaction(Reaction object) { + return new ComparisonMachine<>(object, Reaction.class) + .listsEquivalent(Reaction::getAttributes) + .listsEquivalent(Reaction::getTriggers) + .listsEquivalent(Reaction::getSources) + .listsEquivalent(Reaction::getEffects) + .equalAsObjects(Reaction::isMutation) + .equalAsObjects(Reaction::getName) + .equivalent(Reaction::getCode) + .equivalent(Reaction::getStp) + .equivalent(Reaction::getDeadline) + .conclusion; + } + + @Override + public Boolean caseTriggerRef(TriggerRef object) { + throw thereIsAMoreSpecificCase(TriggerRef.class, BuiltinTriggerRef.class, VarRef.class); + } + + @Override + public Boolean caseBuiltinTriggerRef(BuiltinTriggerRef object) { + return new ComparisonMachine<>(object, BuiltinTriggerRef.class) + .equalAsObjects(BuiltinTriggerRef::getType) // This is an enum + .conclusion; + } + + @Override + public Boolean caseDeadline(Deadline object) { + return new ComparisonMachine<>(object, Deadline.class) + .equivalent(Deadline::getDelay) + .equivalent(Deadline::getCode) + .conclusion; + } + + @Override + public Boolean caseSTP(STP object) { + return new ComparisonMachine<>(object, STP.class) + .equivalent(STP::getValue) + .equivalent(STP::getCode) + .conclusion; + } + + @Override + public Boolean casePreamble(Preamble object) { + return new ComparisonMachine<>(object, Preamble.class) + .equalAsObjects(Preamble::getVisibility) // This is an enum + .equivalent(Preamble::getCode) + .conclusion; + } + + @Override + public Boolean caseInstantiation(Instantiation object) { + return new ComparisonMachine<>(object, Instantiation.class) + .equalAsObjects(Instantiation::getName) + .equivalent(Instantiation::getWidthSpec) + .equivalent(Instantiation::getReactorClass) + .listsEquivalent(Instantiation::getTypeArgs) + .listsEquivalent(Instantiation::getParameters) + .equivalent(Instantiation::getHost) + .conclusion; + } + + @Override + public Boolean caseConnection(Connection object) { + return new ComparisonMachine<>(object, Connection.class) + .listsEquivalent(Connection::getLeftPorts) + .equalAsObjects(Connection::isIterated) + .equalAsObjects(Connection::isPhysical) + .listsEquivalent(Connection::getRightPorts) + .equivalent(Connection::getDelay) + .equivalent(Connection::getSerializer) + .conclusion; + } + + @Override + public Boolean caseSerializer(Serializer object) { + return new ComparisonMachine<>(object, Serializer.class) + .equalAsObjects(Serializer::getType) + .conclusion; + } + + @Override + public Boolean caseKeyValuePairs(KeyValuePairs object) { + return new ComparisonMachine<>(object, KeyValuePairs.class) + .listsEquivalent(KeyValuePairs::getPairs) + .conclusion; + } + + @Override + public Boolean caseKeyValuePair(KeyValuePair object) { + return new ComparisonMachine<>(object, KeyValuePair.class) + .equalAsObjects(KeyValuePair::getName) + .equivalent(KeyValuePair::getValue) + .conclusion; + } + + @Override + public Boolean caseArray(Array object) { + return new ComparisonMachine<>(object, Array.class) + .listsEquivalent(Array::getElements) + .conclusion; + } + + @Override + public Boolean caseElement(Element object) { + return new ComparisonMachine<>(object, Element.class) + .equivalent(Element::getKeyvalue) + .equivalent(Element::getArray) + .equalAsObjects(Element::getLiteral) + .equalAsObjects(Element::getId) + .equalAsObjects(Element::getUnit) + .conclusion; + } + + @Override + public Boolean caseTypedVariable(TypedVariable object) { + throw thereIsAMoreSpecificCase(TypedVariable.class, Port.class, Action.class); + } + + @Override + public Boolean caseVariable(Variable object) { + throw thereIsAMoreSpecificCase(Variable.class, TypedVariable.class, Timer.class, Mode.class); + } + + @Override + public Boolean caseVarRef(VarRef object) { + return new ComparisonMachine<>(object, VarRef.class) + .equalAsObjects( + varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable().getName()) + .equivalent(varRef -> varRef.getVariable() instanceof Mode ? null : varRef.getVariable()) + .equalAsObjects( + varRef -> varRef.getContainer() == null ? null : varRef.getContainer().getName()) + .equalAsObjects(VarRef::isInterleaved) + .equalAsObjects(VarRef::getTransition) + .conclusion; + } + + @Override + public Boolean caseAssignment(Assignment object) { + return new ComparisonMachine<>(object, Assignment.class) + .equivalent(Assignment::getLhs) + .equivalent(Assignment::getRhs) + .conclusion; + } + + @Override + public Boolean caseParameter(Parameter object) { + return new ComparisonMachine<>(object, Parameter.class) + .listsEquivalent(Parameter::getAttributes) + .equalAsObjects(Parameter::getName) + .equivalent(Parameter::getType) + .equivalent(Parameter::getInit) + .conclusion; + } + + @Override + public Boolean caseExpression(Expression object) { + throw thereIsAMoreSpecificCase( + Expression.class, + Literal.class, + Time.class, + ParameterReference.class, + Code.class, + BracedListExpression.class); + } + + @Override + public Boolean caseBracedListExpression(BracedListExpression object) { + return new ComparisonMachine<>(object, BracedListExpression.class) + .listsEquivalent(BracedListExpression::getItems) + .conclusion; + } + + @Override + public Boolean caseParameterReference(ParameterReference object) { + return new ComparisonMachine<>(object, ParameterReference.class) + .equivalent(ParameterReference::getParameter) + .conclusion; + } + + @Override + public Boolean caseTime(Time object) { + return new ComparisonMachine<>(object, Time.class) + .equalAsObjects(Time::getInterval) + .equalAsObjectsModulo( + Time::getUnit, + ((Function) TimeUnit::getCanonicalName).compose(TimeUnit::fromName)) + .conclusion; + } + + @Override + public Boolean casePort(Port object) { + throw thereIsAMoreSpecificCase(Port.class, Input.class, Output.class); + } + + @Override + public Boolean caseType(Type object) { + return new ComparisonMachine<>(object, Type.class) + .equivalent(Type::getCode) + .equalAsObjects(Type::isTime) + .equivalent(Type::getArraySpec) + .equalAsObjects(Type::getId) + .listsEquivalent(Type::getTypeArgs) + .listsEqualAsObjects(Type::getStars) + .equivalent(Type::getArraySpec) + .equivalent(Type::getCode) + .conclusion; + } + + @Override + public Boolean caseArraySpec(ArraySpec object) { + return new ComparisonMachine<>(object, ArraySpec.class) + .equalAsObjects(ArraySpec::isOfVariableLength) + .equalAsObjects(ArraySpec::getLength) + .conclusion; + } + + @Override + public Boolean caseWatchdog(Watchdog object) { + return new ComparisonMachine<>(object, Watchdog.class) + .equalAsObjects(Watchdog::getName) + .equivalent(Watchdog::getTimeout) + .listsEquivalent(Watchdog::getEffects) + .equivalent(Watchdog::getCode) + .conclusion; + } + + @Override + public Boolean caseWidthSpec(WidthSpec object) { + return new ComparisonMachine<>(object, WidthSpec.class) + .equalAsObjects(WidthSpec::isOfVariableLength) + .listsEquivalent(WidthSpec::getTerms) + .conclusion; + } + + @Override + public Boolean caseWidthTerm(WidthTerm object) { + return new ComparisonMachine<>(object, WidthTerm.class) + .equalAsObjects(WidthTerm::getWidth) + .equivalent(WidthTerm::getParameter) + .equivalent(WidthTerm::getPort) + .equivalent(WidthTerm::getCode) + .conclusion; + } + + @Override + public Boolean caseIPV4Host(IPV4Host object) { + return caseHost(object); + } + + @Override + public Boolean caseIPV6Host(IPV6Host object) { + return caseHost(object); + } + + @Override + public Boolean caseNamedHost(NamedHost object) { + return caseHost(object); + } + + @Override + public Boolean caseHost(Host object) { + return new ComparisonMachine<>(object, Host.class) + .equalAsObjects(Host::getUser) + .equalAsObjects(Host::getAddr) + .equalAsObjects(Host::getPort) + .conclusion; + } + + @Override + public Boolean caseCodeExpr(CodeExpr object) { + return new ComparisonMachine<>(object, CodeExpr.class).equivalent(CodeExpr::getCode).conclusion; + } + + @Override + public Boolean caseCode(Code object) { + return new ComparisonMachine<>(object, Code.class) + .equalAsObjectsModulo(Code::getBody, s -> s == null ? null : s.strip().stripIndent()) + .conclusion; + } + + @Override + public Boolean caseLiteral(Literal object) { + return new ComparisonMachine<>(object, Literal.class) + .equalAsObjects(Literal::getLiteral) + .conclusion; + } + + @Override + public Boolean defaultCase(EObject object) { + return super.defaultCase(object); + } + + @SafeVarargs + private UnsupportedOperationException thereIsAMoreSpecificCase( + Class thisCase, Class... moreSpecificCases) { + return new UnsupportedOperationException( + String.format( "%ss are %s, so the methods " + "corresponding to those types should be invoked instead.", thisCase.getName(), Arrays.stream(moreSpecificCases) - .map(Class::getName) - .map(it -> it + (it.endsWith("s") ? "es" : "s")) - .collect(Collectors.joining(" or ")) - )); - } - - /** Fluently compare a pair of parse tree nodes for equivalence. */ - private class ComparisonMachine { - private final E object; - private final E other; - private boolean conclusion; - - ComparisonMachine(E object, Class clz) { - this.object = object; - this.conclusion = clz.isInstance(otherObject); - this.other = conclusion ? clz.cast(otherObject) : null; - } - - /** - * Conclude false if the two given Lists are different as EObject - * sequences. Order matters. - */ - ComparisonMachine listsEquivalent(Function> listGetter) { - if (conclusion) conclusion = listsEqualish(listGetter, (T a, T b) -> new IsEqual(a).doSwitch(b)); - return this; - } - - /** - * Conclude false if the two given Lists are different as object - * sequences. Order matters. - */ - ComparisonMachine listsEqualAsObjects(Function> listGetter) { - if (conclusion) conclusion = listsEqualish(listGetter, Objects::equals); - return this; - } - - boolean listsEqualish(Function> listGetter, BiPredicate equalish) { - if (!conclusion) return false; - List list0 = listGetter.apply(object); - List list1 = listGetter.apply(other); - if (list0 == list1) return true; // e.g., they are both null - if (list0.size() != list1.size()) return false; - for (int i = 0; i < list0.size(); i++) { - if (!equalish.test(list0.get(i), list1.get(i))) { - return false; - } - } - return true; - } - - /** Conclude false if the two properties are not equal as objects. */ - ComparisonMachine equalAsObjects(Function propertyGetter) { - return equalAsObjectsModulo(propertyGetter, Function.identity()); - } - - /** - * Conclude false if the two properties are not equal as objects, - * given that {@code projectionToClassRepresentatives} maps each - * object to some semantically equivalent object. - */ - ComparisonMachine equalAsObjectsModulo( - Function propertyGetter, - Function projectionToClassRepresentatives - ) { - if (propertyGetter.apply(object) instanceof EObject) { - throw new IllegalArgumentException( - "EObjects should be compared for semantic equivalence, not object equality." - ); - } - propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); - if (conclusion) conclusion = Objects.equals(propertyGetter.apply(object), propertyGetter.apply(other)); - return this; - } - - /** - * Conclude false if the two properties are not semantically equivalent - * parse nodes. - */ - ComparisonMachine equivalent(Function propertyGetter) { - return equivalentModulo(propertyGetter, Function.identity()); - } - - /** - * Conclude false if the two properties are not semantically equivalent - * parse nodes, given that {@code projectionToClassRepresentatives} - * maps each parse node to some semantically equivalent node. - */ - ComparisonMachine equivalentModulo( - Function propertyGetter, - Function projectionToClassRepresentatives - ) { - propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); - if (conclusion) conclusion = new IsEqual(propertyGetter.apply(object)) - .doSwitch(propertyGetter.apply(other)); - return this; + .map(Class::getName) + .map(it -> it + (it.endsWith("s") ? "es" : "s")) + .collect(Collectors.joining(" or ")))); + } + + /** Fluently compare a pair of parse tree nodes for equivalence. */ + private class ComparisonMachine { + private final E object; + private final E other; + private boolean conclusion; + + ComparisonMachine(E object, Class clz) { + this.object = object; + this.conclusion = clz.isInstance(otherObject); + this.other = conclusion ? clz.cast(otherObject) : null; + } + + /** Conclude false if the two given Lists are different as EObject sequences. Order matters. */ + ComparisonMachine listsEquivalent(Function> listGetter) { + if (conclusion) + conclusion = listsEqualish(listGetter, (T a, T b) -> new IsEqual(a).doSwitch(b)); + return this; + } + + /** Conclude false if the two given Lists are different as object sequences. Order matters. */ + ComparisonMachine listsEqualAsObjects(Function> listGetter) { + if (conclusion) conclusion = listsEqualish(listGetter, Objects::equals); + return this; + } + + boolean listsEqualish( + Function> listGetter, BiPredicate equalish) { + if (!conclusion) return false; + List list0 = listGetter.apply(object); + List list1 = listGetter.apply(other); + if (list0 == list1) return true; // e.g., they are both null + if (list0.size() != list1.size()) return false; + for (int i = 0; i < list0.size(); i++) { + if (!equalish.test(list0.get(i), list1.get(i))) { + return false; } - } + } + return true; + } + + /** Conclude false if the two properties are not equal as objects. */ + ComparisonMachine equalAsObjects(Function propertyGetter) { + return equalAsObjectsModulo(propertyGetter, Function.identity()); + } + + /** + * Conclude false if the two properties are not equal as objects, given that {@code + * projectionToClassRepresentatives} maps each object to some semantically equivalent object. + */ + ComparisonMachine equalAsObjectsModulo( + Function propertyGetter, Function projectionToClassRepresentatives) { + if (propertyGetter.apply(object) instanceof EObject) { + throw new IllegalArgumentException( + "EObjects should be compared for semantic equivalence, not object equality."); + } + propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); + if (conclusion) + conclusion = Objects.equals(propertyGetter.apply(object), propertyGetter.apply(other)); + return this; + } + + /** Conclude false if the two properties are not semantically equivalent parse nodes. */ + ComparisonMachine equivalent(Function propertyGetter) { + return equivalentModulo(propertyGetter, Function.identity()); + } + + /** + * Conclude false if the two properties are not semantically equivalent parse nodes, given that + * {@code projectionToClassRepresentatives} maps each parse node to some semantically equivalent + * node. + */ + ComparisonMachine equivalentModulo( + Function propertyGetter, Function projectionToClassRepresentatives) { + propertyGetter = projectionToClassRepresentatives.compose(propertyGetter); + if (conclusion) + conclusion = + new IsEqual(propertyGetter.apply(object)).doSwitch(propertyGetter.apply(other)); + return this; + } + } } diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/src/org/lflang/ast/ToLf.java index 7ecf04684f..9505c57478 100644 --- a/org.lflang/src/org/lflang/ast/ToLf.java +++ b/org.lflang/src/org/lflang/ast/ToLf.java @@ -20,7 +20,6 @@ import org.eclipse.xtext.nodemodel.INode; import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.eclipse.xtext.xbase.lib.StringExtensions; - import org.lflang.Target; import org.lflang.ast.MalleableString.Builder; import org.lflang.ast.MalleableString.Joiner; @@ -219,11 +218,7 @@ public MalleableString caseCode(Code code) { .map(String::stripTrailing) .collect(Collectors.joining("\n")); MalleableString singleLineRepresentation = - new Builder() - .append("{= ") - .append(content.strip()) - .append(" =}") - .get(); + new Builder().append("{= ").append(content.strip()).append(" =}").get(); MalleableString multilineRepresentation = new Builder() .append(String.format("{=%n")) diff --git a/org.lflang/src/org/lflang/ast/ToText.java b/org.lflang/src/org/lflang/ast/ToText.java index 4d02d4ed08..f1d47b7c69 100644 --- a/org.lflang/src/org/lflang/ast/ToText.java +++ b/org.lflang/src/org/lflang/ast/ToText.java @@ -4,7 +4,6 @@ import org.eclipse.xtext.nodemodel.ICompositeNode; import org.eclipse.xtext.nodemodel.ILeafNode; import org.eclipse.xtext.nodemodel.util.NodeModelUtils; - import org.lflang.lf.ArraySpec; import org.lflang.lf.BracedListExpression; import org.lflang.lf.Code; @@ -19,112 +18,115 @@ import org.lflang.lf.util.LfSwitch; import org.lflang.util.StringUtil; - /** - * Switch class for converting AST nodes to some textual representation that seems likely - * to be useful for as many code generators as possible. + * Switch class for converting AST nodes to some textual representation that seems likely to be + * useful for as many code generators as possible. */ public class ToText extends LfSwitch { - /// public instance initialized when loading the class - public static final ToText instance = new ToText(); - - // private constructor - private ToText() { super(); } - - @Override - public String caseArraySpec(ArraySpec spec) { - return ToLf.instance.doSwitch(spec).toString(); - } - - @Override - public String caseCodeExpr(CodeExpr object) { - return caseCode(object.getCode()); + /// public instance initialized when loading the class + public static final ToText instance = new ToText(); + + // private constructor + private ToText() { + super(); + } + + @Override + public String caseArraySpec(ArraySpec spec) { + return ToLf.instance.doSwitch(spec).toString(); + } + + @Override + public String caseCodeExpr(CodeExpr object) { + return caseCode(object.getCode()); + } + + @Override + public String caseCode(Code code) { + ICompositeNode node = NodeModelUtils.getNode(code); + if (node != null) { + StringBuilder builder = new StringBuilder(Math.max(node.getTotalLength(), 1)); + for (ILeafNode leaf : node.getLeafNodes()) { + builder.append(leaf.getText()); + } + String str = builder.toString().trim(); + // Remove the code delimiters (and any surrounding comments). + // This assumes any comment before {= does not include {=. + int start = str.indexOf("{="); + int end = str.lastIndexOf("=}"); + if (start == -1 || end == -1) { + // Silent failure is needed here because toText is needed to create the intermediate + // representation, + // which the validator uses. + return str; + } + str = str.substring(start + 2, end); + if (str.split("\n").length > 1) { + // multi line code + return StringUtil.trimCodeBlock(str, 1); + } else { + // single line code + return str.trim(); + } + } else if (code.getBody() != null) { + // Code must have been added as a simple string. + return code.getBody(); } - - @Override - public String caseCode(Code code) { - ICompositeNode node = NodeModelUtils.getNode(code); - if (node != null) { - StringBuilder builder = new StringBuilder(Math.max(node.getTotalLength(), 1)); - for (ILeafNode leaf : node.getLeafNodes()) { - builder.append(leaf.getText()); - } - String str = builder.toString().trim(); - // Remove the code delimiters (and any surrounding comments). - // This assumes any comment before {= does not include {=. - int start = str.indexOf("{="); - int end = str.lastIndexOf("=}"); - if (start == -1 || end == -1) { - // Silent failure is needed here because toText is needed to create the intermediate representation, - // which the validator uses. - return str; - } - str = str.substring(start + 2, end); - if (str.split("\n").length > 1) { - // multi line code - return StringUtil.trimCodeBlock(str, 1); - } else { - // single line code - return str.trim(); - } - } else if (code.getBody() != null) { - // Code must have been added as a simple string. - return code.getBody(); - } - return ""; - } - - @Override - public String caseBracedListExpression(BracedListExpression object) { - return ToLf.instance.caseBracedListExpression(object).toString(); + return ""; + } + + @Override + public String caseBracedListExpression(BracedListExpression object) { + return ToLf.instance.caseBracedListExpression(object).toString(); + } + + @Override + public String caseHost(Host host) { + return ToLf.instance.caseHost(host).toString(); + } + + @Override + public String caseLiteral(Literal l) { + return ToLf.instance.caseLiteral(l).toString(); + } + + @Override + public String caseParameterReference(ParameterReference p) { + return ToLf.instance.caseParameterReference(p).toString(); + } + + @Override + public String caseTime(Time t) { + return ToLf.instance.caseTime(t).toString(); + } + + @Override + public String caseType(Type type) { + if (type.getCode() != null) { + return caseCode(type.getCode()); } - - @Override - public String caseHost(Host host) { - return ToLf.instance.caseHost(host).toString(); - } - - @Override - public String caseLiteral(Literal l) { - return ToLf.instance.caseLiteral(l).toString(); + return ToLf.instance.caseType(type).toString(); + } + + @Override + public String caseTypeParm(TypeParm t) { + if (t.getCode() != null) return doSwitch(t.getCode()); + return ToLf.instance.caseTypeParm(t).toString(); + } + + @Override + public String caseVarRef(VarRef v) { + if (v.getContainer() != null) { + return String.format("%s.%s", v.getContainer().getName(), v.getVariable().getName()); + } else { + return v.getVariable().getName(); } + } - @Override - public String caseParameterReference(ParameterReference p) { - return ToLf.instance.caseParameterReference(p).toString(); - } - - @Override - public String caseTime(Time t) { - return ToLf.instance.caseTime(t).toString(); - } - - @Override - public String caseType(Type type) { - if (type.getCode() != null) { - return caseCode(type.getCode()); - } - return ToLf.instance.caseType(type).toString(); - } - - @Override - public String caseTypeParm(TypeParm t) { - if (t.getCode() != null) return doSwitch(t.getCode()); - return ToLf.instance.caseTypeParm(t).toString(); - } - - @Override - public String caseVarRef(VarRef v) { - if (v.getContainer() != null) { - return String.format("%s.%s", v.getContainer().getName(), v.getVariable().getName()); - } else { - return v.getVariable().getName(); - } - } - - @Override - public String defaultCase(EObject object) { - throw new UnsupportedOperationException("ToText has no case for " + object.getClass().getName()); - } + @Override + public String defaultCase(EObject object) { + throw new UnsupportedOperationException( + "ToText has no case for " + object.getClass().getName()); + } } diff --git a/org.lflang/src/org/lflang/cli/CliBase.java b/org.lflang/src/org/lflang/cli/CliBase.java index 2f4a9d849c..a6c1c805ed 100644 --- a/org.lflang/src/org/lflang/cli/CliBase.java +++ b/org.lflang/src/org/lflang/cli/CliBase.java @@ -1,26 +1,21 @@ package org.lflang.cli; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParseException; +import com.google.gson.JsonParser; +import com.google.inject.Inject; +import com.google.inject.Injector; +import com.google.inject.Provider; import java.io.IOException; import java.io.PrintWriter; import java.nio.file.Files; import java.nio.file.Path; -import java.util.Arrays; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; import java.util.Map.Entry; -import java.util.Properties; import java.util.Set; import java.util.stream.Collectors; - -import picocli.CommandLine; -import picocli.CommandLine.ArgGroup; -import picocli.CommandLine.Command; -import picocli.CommandLine.Model.CommandSpec; -import picocli.CommandLine.Option; -import picocli.CommandLine.Parameters; -import picocli.CommandLine.Spec; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.resource.ResourceSet; @@ -28,18 +23,16 @@ import org.eclipse.xtext.validation.CheckMode; import org.eclipse.xtext.validation.IResourceValidator; import org.eclipse.xtext.validation.Issue; - import org.lflang.ErrorReporter; import org.lflang.LFRuntimeModule; import org.lflang.LFStandaloneSetup; import org.lflang.util.FileUtil; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.google.gson.JsonParser; -import com.google.gson.JsonParseException; -import com.google.inject.Inject; -import com.google.inject.Injector; -import com.google.inject.Provider; +import picocli.CommandLine; +import picocli.CommandLine.ArgGroup; +import picocli.CommandLine.Model.CommandSpec; +import picocli.CommandLine.Option; +import picocli.CommandLine.Parameters; +import picocli.CommandLine.Spec; /** * Base class for standalone CLI applications. @@ -50,318 +43,277 @@ * @author Atharva Patil */ public abstract class CliBase implements Runnable { - /** - * Models a command specification, including the options, positional - * parameters and subcommands supported by the command. - */ - @Spec CommandSpec spec; - - /** - * Options and parameters present in both Lfc and Lff. - */ - static class MutuallyExclusive { - @Parameters( - arity = "1..", - paramLabel = "FILES", - description = "Paths to one or more Lingua Franca programs.") - protected List files; - - @Option( - names="--json", - description="JSON object containing CLI arguments.") - private String jsonString; - - @Option( - names="--json-file", - description="JSON file containing CLI arguments.") - private Path jsonFile; - } - - @ArgGroup(exclusive = true, multiplicity = "1") - MutuallyExclusive topLevelArg; - - @Option( - names = {"-o", "--output-path"}, - defaultValue = "", - fallbackValue = "", - description = "Specify the root output directory.") - private Path outputPath; - - /** - * Used to collect all errors that happen during validation/generation. - */ - @Inject - protected IssueCollector issueCollector; - - /** - * Used to report error messages at the end. - */ - @Inject - protected ReportingBackend reporter; - - /** - * Used to report error messages at the end. - */ - @Inject - protected ErrorReporter errorReporter; - - /** - * IO context of this run. - */ - @Inject - protected Io io; - - /** - * Injected resource provider. - */ - @Inject - private Provider resourceSetProvider; - - /** - * Injected resource validator. - */ - @Inject - private IResourceValidator validator; - - protected static void cliMain( - String toolName, Class toolClass, - Io io, String[] args) { - // Injector used to obtain Main instance. - final Injector injector = getInjector(toolName, io); - // Main instance. - final CliBase main = injector.getInstance(toolClass); - // Parse arguments and execute main logic. - main.doExecute(io, args); - } - - public void doExecute(Io io, String[] args) { - CommandLine cmd = new CommandLine(this) + /** + * Models a command specification, including the options, positional parameters and subcommands + * supported by the command. + */ + @Spec CommandSpec spec; + + /** Options and parameters present in both Lfc and Lff. */ + static class MutuallyExclusive { + @Parameters( + arity = "1..", + paramLabel = "FILES", + description = "Paths to one or more Lingua Franca programs.") + protected List files; + + @Option(names = "--json", description = "JSON object containing CLI arguments.") + private String jsonString; + + @Option(names = "--json-file", description = "JSON file containing CLI arguments.") + private Path jsonFile; + } + + @ArgGroup(exclusive = true, multiplicity = "1") + MutuallyExclusive topLevelArg; + + @Option( + names = {"-o", "--output-path"}, + defaultValue = "", + fallbackValue = "", + description = "Specify the root output directory.") + private Path outputPath; + + /** Used to collect all errors that happen during validation/generation. */ + @Inject protected IssueCollector issueCollector; + + /** Used to report error messages at the end. */ + @Inject protected ReportingBackend reporter; + + /** Used to report error messages at the end. */ + @Inject protected ErrorReporter errorReporter; + + /** IO context of this run. */ + @Inject protected Io io; + + /** Injected resource provider. */ + @Inject private Provider resourceSetProvider; + + /** Injected resource validator. */ + @Inject private IResourceValidator validator; + + protected static void cliMain( + String toolName, Class toolClass, Io io, String[] args) { + // Injector used to obtain Main instance. + final Injector injector = getInjector(toolName, io); + // Main instance. + final CliBase main = injector.getInstance(toolClass); + // Parse arguments and execute main logic. + main.doExecute(io, args); + } + + public void doExecute(Io io, String[] args) { + CommandLine cmd = + new CommandLine(this) .setOut(new PrintWriter(io.getOut())) .setErr(new PrintWriter(io.getErr())); - int exitCode = cmd.execute(args); - io.callSystemExit(exitCode); + int exitCode = cmd.execute(args); + io.callSystemExit(exitCode); + } + + /** + * The entrypoint of Picocli applications - the first method called when CliBase, which implements + * the Runnable interface, is instantiated. + */ + public void run() { + // If args are given in a json file, store its contents in jsonString. + if (topLevelArg.jsonFile != null) { + try { + topLevelArg.jsonString = + new String(Files.readAllBytes(io.getWd().resolve(topLevelArg.jsonFile))); + } catch (IOException e) { + reporter.printFatalErrorAndExit("No such file: " + topLevelArg.jsonFile); + } } - - /** - * The entrypoint of Picocli applications - the first method called when - * CliBase, which implements the Runnable interface, is instantiated. - */ - public void run() { - // If args are given in a json file, store its contents in jsonString. - if (topLevelArg.jsonFile != null) { - try { - topLevelArg.jsonString = new String(Files.readAllBytes( - io.getWd().resolve(topLevelArg.jsonFile))); - } catch (IOException e) { - reporter.printFatalErrorAndExit( - "No such file: " + topLevelArg.jsonFile); - } - } - // If args are given in a json string, unpack them and re-run - // picocli argument validation. - if (topLevelArg.jsonString != null) { - // Unpack args from json string. - String[] args = jsonStringToArgs(topLevelArg.jsonString); - // Execute application on unpacked args. - CommandLine cmd = spec.commandLine(); - cmd.execute(args); - // If args are already unpacked, invoke tool-specific logic. - } else { - doRun(); - } + // If args are given in a json string, unpack them and re-run + // picocli argument validation. + if (topLevelArg.jsonString != null) { + // Unpack args from json string. + String[] args = jsonStringToArgs(topLevelArg.jsonString); + // Execute application on unpacked args. + CommandLine cmd = spec.commandLine(); + cmd.execute(args); + // If args are already unpacked, invoke tool-specific logic. + } else { + doRun(); } - - /* - * The entrypoint of tool-specific logic. - * Lfc and Lff have their own specific implementations for this method. - */ - public abstract void doRun(); - - public static Injector getInjector(String toolName, Io io) { - final ReportingBackend reporter - = new ReportingBackend(io, toolName + ": "); - - // Injector used to obtain Main instance. - return new LFStandaloneSetup( - new LFRuntimeModule(), - new LFStandaloneModule(reporter, io) - ).createInjectorAndDoEMFRegistration(); + } + + /* + * The entrypoint of tool-specific logic. + * Lfc and Lff have their own specific implementations for this method. + */ + public abstract void doRun(); + + public static Injector getInjector(String toolName, Io io) { + final ReportingBackend reporter = new ReportingBackend(io, toolName + ": "); + + // Injector used to obtain Main instance. + return new LFStandaloneSetup(new LFRuntimeModule(), new LFStandaloneModule(reporter, io)) + .createInjectorAndDoEMFRegistration(); + } + + /** Resolve to an absolute path, in the given {@link #io} context. */ + protected Path toAbsolutePath(Path other) { + return io.getWd().resolve(other).toAbsolutePath(); + } + + /** + * Returns the validated input paths. + * + * @return Validated input paths. + */ + protected List getInputPaths() { + List paths = + topLevelArg.files.stream().map(io.getWd()::resolve).collect(Collectors.toList()); + + for (Path path : paths) { + if (!Files.exists(path)) { + reporter.printFatalErrorAndExit(path + ": No such file or directory."); + } } - /** - * Resolve to an absolute path, in the given {@link #io} context. - */ - protected Path toAbsolutePath(Path other) { - return io.getWd().resolve(other).toAbsolutePath(); + return paths; + } + + /** + * Returns the validated, normalized output path. + * + * @return Validated, normalized output path. + */ + protected Path getOutputRoot() { + Path root = null; + if (!outputPath.toString().isEmpty()) { + root = io.getWd().resolve(outputPath).normalize(); + if (!Files.exists(root)) { // FIXME: Create it instead? + reporter.printFatalErrorAndExit(root + ": Output location does not exist."); + } + if (!Files.isDirectory(root)) { + reporter.printFatalErrorAndExit(root + ": Output location is not a directory."); + } } - /** - * Returns the validated input paths. - * - * @return Validated input paths. - */ - protected List getInputPaths() { - List paths = topLevelArg.files.stream() - .map(io.getWd()::resolve) - .collect(Collectors.toList()); - - for (Path path : paths) { - if (!Files.exists(path)) { - reporter.printFatalErrorAndExit( - path + ": No such file or directory."); - } - } - - return paths; + return root; + } + + /** If some errors were collected, print them and abort execution. Otherwise, return. */ + protected void exitIfCollectedErrors() { + if (issueCollector.getErrorsOccurred()) { + // if there are errors, don't print warnings. + List errors = printErrorsIfAny(); + String cause = errors.size() + " previous error"; + if (errors.size() > 1) { + cause += 's'; + } + reporter.printFatalErrorAndExit("Aborting due to " + cause + '.'); } - - /** - * Returns the validated, normalized output path. - * - * @return Validated, normalized output path. - */ - protected Path getOutputRoot() { - Path root = null; - if (!outputPath.toString().isEmpty()) { - root = io.getWd().resolve(outputPath).normalize(); - if (!Files.exists(root)) { // FIXME: Create it instead? - reporter.printFatalErrorAndExit( - root + ": Output location does not exist."); - } - if (!Files.isDirectory(root)) { - reporter.printFatalErrorAndExit( - root + ": Output location is not a directory."); - } + } + + /** + * If any errors were collected, print them, then return them. + * + * @return A list of collected errors. + */ + public List printErrorsIfAny() { + List errors = issueCollector.getErrors(); + errors.forEach(reporter::printIssue); + return errors; + } + + /** + * Validates a given resource. If issues arise during validation, these are recorded using the + * issue collector. + * + * @param resource The resource to validate. + */ + public void validateResource(Resource resource) { + assert resource != null; + + List issues = this.validator.validate(resource, CheckMode.ALL, CancelIndicator.NullImpl); + + for (Issue issue : issues) { + // Issues may also relate to imported resources. + URI uri = issue.getUriToProblem(); + Path path = null; + if (uri != null) { + try { + path = FileUtil.toPath(uri); + } catch (IOException e) { + reporter.printError("Unable to convert '" + uri + "' to path." + e); } - - return root; + } + issueCollector.accept( + new LfIssue( + issue.getMessage(), + issue.getSeverity(), + issue.getLineNumber(), + issue.getColumn(), + issue.getLineNumberEnd(), + issue.getColumnEnd(), + issue.getLength(), + path)); } - - /** - * If some errors were collected, print them and abort execution. - * Otherwise, return. - */ - protected void exitIfCollectedErrors() { - if (issueCollector.getErrorsOccurred()) { - // if there are errors, don't print warnings. - List errors = printErrorsIfAny(); - String cause = errors.size() + " previous error"; - if (errors.size() > 1) { - cause += 's'; - } - reporter.printFatalErrorAndExit("Aborting due to " + cause + '.'); - } + } + + /** + * Obtains a resource from a path. Returns null if path is not an LF file. + * + * @param path The path to obtain the resource from. + * @return The obtained resource. Set to null if path is not an LF file. + */ + public Resource getResource(Path path) { + final ResourceSet set = this.resourceSetProvider.get(); + try { + return set.getResource(URI.createFileURI(path.toString()), true); + } catch (RuntimeException e) { + return null; } + } - /** - * If any errors were collected, print them, then return them. - * @return A list of collected errors. - */ - public List printErrorsIfAny() { - List errors = issueCollector.getErrors(); - errors.forEach(reporter::printIssue); - return errors; - } + private String[] jsonStringToArgs(String jsonString) { + ArrayList argsList = new ArrayList<>(); + JsonObject jsonObject = new JsonObject(); - /** - * Validates a given resource. If issues arise during validation, - * these are recorded using the issue collector. - * - * @param resource The resource to validate. - */ - public void validateResource(Resource resource) { - assert resource != null; - - List issues = this.validator.validate( - resource, CheckMode.ALL, CancelIndicator.NullImpl); - - for (Issue issue : issues) { - // Issues may also relate to imported resources. - URI uri = issue.getUriToProblem(); - Path path = null; - if (uri != null) { - try { - path = FileUtil.toPath(uri); - } catch (IOException e) { - reporter.printError("Unable to convert '" + uri + "' to path." + e); - } - } - issueCollector.accept( - new LfIssue( - issue.getMessage(), - issue.getSeverity(), - issue.getLineNumber(), - issue.getColumn(), - issue.getLineNumberEnd(), - issue.getColumnEnd(), - issue.getLength(), - path)); - } + // Parse JSON string and get top-level JSON object. + try { + jsonObject = JsonParser.parseString(jsonString).getAsJsonObject(); + } catch (JsonParseException e) { + reporter.printFatalErrorAndExit(String.format("Invalid JSON string:%n %s", jsonString)); } - - /** - * Obtains a resource from a path. Returns null if path is not an LF file. - * - * @param path The path to obtain the resource from. - * @return The obtained resource. Set to null if path is not an LF file. - */ - public Resource getResource(Path path) { - final ResourceSet set = this.resourceSetProvider.get(); - try { - return set.getResource(URI.createFileURI(path.toString()), true); - } catch (RuntimeException e) { - return null; - } + // Append input paths. + JsonElement src = jsonObject.get("src"); + if (src == null) { + reporter.printFatalErrorAndExit("JSON Parse Exception: field \"src\" not found."); + } + argsList.add(src.getAsString()); + // Append output path if given. + JsonElement out = jsonObject.get("out"); + if (out != null) { + argsList.add("--output-path"); + argsList.add(out.getAsString()); } - private String[] jsonStringToArgs(String jsonString) { - ArrayList argsList = new ArrayList<>(); - JsonObject jsonObject = new JsonObject(); - - // Parse JSON string and get top-level JSON object. - try { - jsonObject = JsonParser.parseString(jsonString).getAsJsonObject(); - } catch (JsonParseException e) { - reporter.printFatalErrorAndExit( - String.format("Invalid JSON string:%n %s", jsonString)); - } - // Append input paths. - JsonElement src = jsonObject.get("src"); - if (src == null) { - reporter.printFatalErrorAndExit( - "JSON Parse Exception: field \"src\" not found."); - } - argsList.add(src.getAsString()); - // Append output path if given. - JsonElement out = jsonObject.get("out"); - if (out != null) { - argsList.add("--output-path"); - argsList.add(out.getAsString()); - } - - // If there are no other properties, return args array. - JsonElement properties = jsonObject.get("properties"); - if (properties != null) { - // Get the remaining properties. - Set> entrySet = properties - .getAsJsonObject() - .entrySet(); - // Append the remaining properties to the args array. - for(Entry entry : entrySet) { - String property = entry.getKey(); - String value = entry.getValue().getAsString(); - - // Append option. - argsList.add("--" + property); - // Append argument for non-boolean options. - if (value != "true" || property == "threading") { - argsList.add(value); - } - } + // If there are no other properties, return args array. + JsonElement properties = jsonObject.get("properties"); + if (properties != null) { + // Get the remaining properties. + Set> entrySet = properties.getAsJsonObject().entrySet(); + // Append the remaining properties to the args array. + for (Entry entry : entrySet) { + String property = entry.getKey(); + String value = entry.getValue().getAsString(); + + // Append option. + argsList.add("--" + property); + // Append argument for non-boolean options. + if (value != "true" || property == "threading") { + argsList.add(value); } - - // Return as String[]. - String[] args = argsList.toArray(new String[argsList.size()]); - return args; + } } + + // Return as String[]. + String[] args = argsList.toArray(new String[argsList.size()]); + return args; + } } diff --git a/org.lflang/src/org/lflang/cli/LFStandaloneModule.java b/org.lflang/src/org/lflang/cli/LFStandaloneModule.java index 8b85e49282..abf01bfcd3 100644 --- a/org.lflang/src/org/lflang/cli/LFStandaloneModule.java +++ b/org.lflang/src/org/lflang/cli/LFStandaloneModule.java @@ -28,49 +28,45 @@ package org.lflang.cli; +import com.google.inject.Binder; +import com.google.inject.Module; import java.util.Objects; - import org.eclipse.emf.ecore.EValidator; import org.eclipse.emf.ecore.impl.EValidatorRegistryImpl; import org.eclipse.xtext.validation.ValidationMessageAcceptor; - import org.lflang.ErrorReporter; import org.lflang.LFRuntimeModule; -import com.google.inject.Binder; -import com.google.inject.Module; - /** - * Module that is only available when running LFC as a - * standalone program. + * Module that is only available when running LFC as a standalone program. * * @see LFRuntimeModule */ public class LFStandaloneModule implements Module { - // Note that xtext's base module classes has broken support - // for @Provides, which would allow us to bind this field. - // So we directly implement Module, instead of extending eg LFRuntimeModule. - private final ReportingBackend helper; - private final Io io; + // Note that xtext's base module classes has broken support + // for @Provides, which would allow us to bind this field. + // So we directly implement Module, instead of extending eg LFRuntimeModule. + private final ReportingBackend helper; + private final Io io; - public LFStandaloneModule(ReportingBackend helper, Io io) { - this.helper = Objects.requireNonNull(helper); - this.io = Objects.requireNonNull(io); - } + public LFStandaloneModule(ReportingBackend helper, Io io) { + this.helper = Objects.requireNonNull(helper); + this.io = Objects.requireNonNull(io); + } - @Override - public void configure(Binder binder) { - binder.bind(ErrorReporter.class).to(StandaloneErrorReporter.class); - binder.bind(ReportingBackend.class).toInstance(helper); - binder.bind(Io.class).toInstance(io); - binder.bind(ValidationMessageAcceptor.class).to(StandaloneIssueAcceptor.class); - // This is required to force the ResourceValidator to - // use a new registry instance (which is reused by the injector as a singleton). - // Otherwise, it uses the static EValidator.Registry.INSTANCE which is bad - // as the first validator to be created would persist in that static instance. - // New injectors would reuse the existing instance, but - // its fields would have been injected by an older injector - // and be out of sync with the rest of the application. - binder.bind(EValidator.Registry.class).to(EValidatorRegistryImpl.class).asEagerSingleton(); - } + @Override + public void configure(Binder binder) { + binder.bind(ErrorReporter.class).to(StandaloneErrorReporter.class); + binder.bind(ReportingBackend.class).toInstance(helper); + binder.bind(Io.class).toInstance(io); + binder.bind(ValidationMessageAcceptor.class).to(StandaloneIssueAcceptor.class); + // This is required to force the ResourceValidator to + // use a new registry instance (which is reused by the injector as a singleton). + // Otherwise, it uses the static EValidator.Registry.INSTANCE which is bad + // as the first validator to be created would persist in that static instance. + // New injectors would reuse the existing instance, but + // its fields would have been injected by an older injector + // and be out of sync with the rest of the application. + binder.bind(EValidator.Registry.class).to(EValidatorRegistryImpl.class).asEagerSingleton(); + } } diff --git a/org.lflang/src/org/lflang/cli/Lfc.java b/org.lflang/src/org/lflang/cli/Lfc.java index 3ef52e54a0..19869f9394 100644 --- a/org.lflang/src/org/lflang/cli/Lfc.java +++ b/org.lflang/src/org/lflang/cli/Lfc.java @@ -1,27 +1,22 @@ package org.lflang.cli; - +import com.google.inject.Inject; import java.nio.file.Files; import java.nio.file.Path; import java.util.List; import java.util.Properties; - -import picocli.CommandLine.Command; -import picocli.CommandLine.Option; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.GeneratorDelegate; import org.eclipse.xtext.generator.JavaIoFileSystemAccess; import org.eclipse.xtext.util.CancelIndicator; - -import org.lflang.ast.ASTUtils; import org.lflang.FileConfig; import org.lflang.TargetProperty.UnionType; - +import org.lflang.ast.ASTUtils; import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFGeneratorContext.BuildParm; import org.lflang.generator.MainContext; - -import com.google.inject.Inject; +import picocli.CommandLine.Command; +import picocli.CommandLine.Option; /** * Standalone version of the Lingua Franca compiler (lfc). @@ -36,287 +31,261 @@ mixinStandardHelpOptions = true, versionProvider = VersionProvider.class) public class Lfc extends CliBase { - /** - * Injected code generator. - */ - @Inject - private GeneratorDelegate generator; - - /** - * Injected file access object. - */ - @Inject - private JavaIoFileSystemAccess fileAccess; - - /* - * Supported CLI options. - */ - - @Option( - names = "--build-type", - description = "The build type to use.") - private String buildType; - - @Option( - names = {"-c", "--clean"}, - arity = "0", - description = "Clean before building.") - private boolean clean; - - @Option( - names = "--target-compiler", - description = "Target compiler to invoke.") - private String targetCompiler; - - @Option( - names = "--external-runtime-path", - description = "Specify an external runtime library to be used by the" - + " compiled binary.") - private Path externalRuntimePath; - - @Option( - names = {"-f", "--federated"}, - arity = "0", - description = "Treat main reactor as federated.") - private boolean federated; - - @Option( - names = "--logging", - description = "The logging level to use by the generated binary") - private String logging; - - @Option( - names = {"-l", "--lint"}, - arity = "0", - description = "Enable linting of generated code.") - private boolean lint; - - @Option( - names = {"-n", "--no-compile"}, - arity = "0", - description = "Do not invoke target compiler.") - private boolean noCompile; - - @Option( - names = {"--print-statistics"}, - arity = "0", - description = "Instruct the runtime to collect and print statistics.") - private boolean printStatistics; - - @Option( - names = {"-q", "--quiet"}, - arity = "0", - description = - "Suppress output of the target compiler and other commands") - private boolean quiet; - - @Option( - names = {"-r", "--rti"}, - description = "Specify the location of the RTI.") - private Path rti; - - @Option( - names = "--runtime-version", - description = "Specify the version of the runtime library used for" - + " compiling LF programs.") - private String runtimeVersion; - - @Option( - names = {"-s", "--scheduler"}, - description = "Specify the runtime scheduler (if supported).") - private String scheduler; - - @Option( - names = {"-t", "--threading"}, - paramLabel = "", - description = "Specify whether the runtime should use multi-threading" - + " (true/false).") - private String threading; - - @Option( - names = {"-w", "--workers"}, - description = "Specify the default number of worker threads.") - private Integer workers; - - /** - * Main function of the stand-alone compiler. - * Caution: this will invoke System.exit. - * - * @param args CLI arguments - */ - public static void main(final String[] args) { - main(Io.SYSTEM, args); + /** Injected code generator. */ + @Inject private GeneratorDelegate generator; + + /** Injected file access object. */ + @Inject private JavaIoFileSystemAccess fileAccess; + + /* + * Supported CLI options. + */ + + @Option(names = "--build-type", description = "The build type to use.") + private String buildType; + + @Option( + names = {"-c", "--clean"}, + arity = "0", + description = "Clean before building.") + private boolean clean; + + @Option(names = "--target-compiler", description = "Target compiler to invoke.") + private String targetCompiler; + + @Option( + names = "--external-runtime-path", + description = "Specify an external runtime library to be used by the" + " compiled binary.") + private Path externalRuntimePath; + + @Option( + names = {"-f", "--federated"}, + arity = "0", + description = "Treat main reactor as federated.") + private boolean federated; + + @Option(names = "--logging", description = "The logging level to use by the generated binary") + private String logging; + + @Option( + names = {"-l", "--lint"}, + arity = "0", + description = "Enable linting of generated code.") + private boolean lint; + + @Option( + names = {"-n", "--no-compile"}, + arity = "0", + description = "Do not invoke target compiler.") + private boolean noCompile; + + @Option( + names = {"--print-statistics"}, + arity = "0", + description = "Instruct the runtime to collect and print statistics.") + private boolean printStatistics; + + @Option( + names = {"-q", "--quiet"}, + arity = "0", + description = "Suppress output of the target compiler and other commands") + private boolean quiet; + + @Option( + names = {"-r", "--rti"}, + description = "Specify the location of the RTI.") + private Path rti; + + @Option( + names = "--runtime-version", + description = + "Specify the version of the runtime library used for" + " compiling LF programs.") + private String runtimeVersion; + + @Option( + names = {"-s", "--scheduler"}, + description = "Specify the runtime scheduler (if supported).") + private String scheduler; + + @Option( + names = {"-t", "--threading"}, + paramLabel = "", + description = "Specify whether the runtime should use multi-threading" + " (true/false).") + private String threading; + + @Option( + names = {"-w", "--workers"}, + description = "Specify the default number of worker threads.") + private Integer workers; + + /** + * Main function of the stand-alone compiler. Caution: this will invoke System.exit. + * + * @param args CLI arguments + */ + public static void main(final String[] args) { + main(Io.SYSTEM, args); + } + + /** + * Main function of the standalone compiler, with a custom IO. + * + * @param io IO streams. + * @param args Command-line arguments. + */ + public static void main(Io io, final String... args) { + cliMain("lfc", Lfc.class, io, args); + } + + /** Load the resource, validate it, and, invoke the code generator. */ + @Override + public void doRun() { + List paths = getInputPaths(); + final Path outputRoot = getOutputRoot(); + // Hard code the props based on the options we want. + Properties properties = this.getGeneratorArgs(); + + try { + // Invoke the generator on all input file paths. + invokeGenerator(paths, outputRoot, properties); + } catch (RuntimeException e) { + reporter.printFatalErrorAndExit("An unexpected error occurred:", e); } - - /** - * Main function of the standalone compiler, with a custom IO. - * - * @param io IO streams. - * @param args Command-line arguments. - */ - public static void main(Io io, final String... args) { - cliMain("lfc", Lfc.class, io, args); - } - - /** - * Load the resource, validate it, and, invoke the code generator. - */ - @Override - public void doRun() { - List paths = getInputPaths(); - final Path outputRoot = getOutputRoot(); - // Hard code the props based on the options we want. - Properties properties = this.getGeneratorArgs(); - - try { - // Invoke the generator on all input file paths. - invokeGenerator(paths, outputRoot, properties); - } catch (RuntimeException e) { - reporter.printFatalErrorAndExit("An unexpected error occurred:", e); + } + + /** Invoke the code generator on the given validated file paths. */ + private void invokeGenerator(List files, Path root, Properties properties) { + for (Path path : files) { + path = toAbsolutePath(path); + String outputPath = getActualOutputPath(root, path).toString(); + this.fileAccess.setOutputPath(outputPath); + + final Resource resource = getResource(path); + if (resource == null) { + reporter.printFatalErrorAndExit( + path + " is not an LF file. Use the .lf file extension to" + " denote LF files."); + } else if (federated) { + if (!ASTUtils.makeFederated(resource)) { + reporter.printError("Unable to change main reactor to federated reactor."); } + } + + validateResource(resource); + exitIfCollectedErrors(); + + LFGeneratorContext context = + new MainContext( + LFGeneratorContext.Mode.STANDALONE, + CancelIndicator.NullImpl, + (m, p) -> {}, + properties, + resource, + this.fileAccess, + fileConfig -> errorReporter); + + try { + this.generator.generate(resource, this.fileAccess, context); + } catch (Exception e) { + reporter.printFatalErrorAndExit("Error running generator", e); + } + + exitIfCollectedErrors(); + // Print all other issues (not errors). + issueCollector.getAllIssues().forEach(reporter::printIssue); + + this.io.getOut().println("Code generation finished."); } - - /** - * Invoke the code generator on the given validated file paths. - */ - private void invokeGenerator( - List files, Path root, Properties properties) { - for (Path path : files) { - path = toAbsolutePath(path); - String outputPath = getActualOutputPath(root, path).toString(); - this.fileAccess.setOutputPath(outputPath); - - final Resource resource = getResource(path); - if (resource == null) { - reporter.printFatalErrorAndExit(path - + " is not an LF file. Use the .lf file extension to" - + " denote LF files."); - } else if (federated) { - if (!ASTUtils.makeFederated(resource)) { - reporter.printError( - "Unable to change main reactor to federated reactor."); - } - } - - validateResource(resource); - exitIfCollectedErrors(); - - LFGeneratorContext context = new MainContext( - LFGeneratorContext.Mode.STANDALONE, CancelIndicator.NullImpl, - (m, p) -> {}, properties, resource, this.fileAccess, - fileConfig -> errorReporter - ); - - try { - this.generator.generate(resource, this.fileAccess, context); - } catch (Exception e) { - reporter.printFatalErrorAndExit("Error running generator", e); - } - - exitIfCollectedErrors(); - // Print all other issues (not errors). - issueCollector.getAllIssues().forEach(reporter::printIssue); - - this.io.getOut().println("Code generation finished."); - } + } + + private Path getActualOutputPath(Path root, Path path) { + if (root != null) { + return root.resolve("src-gen"); + } else { + Path pkgRoot = FileConfig.findPackageRoot(path, reporter::printWarning); + return pkgRoot.resolve("src-gen"); } - - private Path getActualOutputPath(Path root, Path path) { - if (root != null) { - return root.resolve("src-gen"); - } else { - Path pkgRoot = FileConfig.findPackageRoot( - path, reporter::printWarning); - return pkgRoot.resolve("src-gen"); - } + } + + /** + * Filter the command-line arguments needed by the code generator, and return them as properties. + * + * @return Properties for the code generator. + */ + public Properties getGeneratorArgs() { + Properties props = new Properties(); + + if (buildType != null) { + // Validate build type. + if (UnionType.BUILD_TYPE_UNION.forName(buildType) == null) { + reporter.printFatalErrorAndExit(buildType + ": Invalid build type."); + } + props.setProperty(BuildParm.BUILD_TYPE.getKey(), buildType); } - /** - * Filter the command-line arguments needed by the code generator, and - * return them as properties. - * - * @return Properties for the code generator. - */ - public Properties getGeneratorArgs() { - Properties props = new Properties(); - - if (buildType != null) { - // Validate build type. - if (UnionType.BUILD_TYPE_UNION.forName(buildType) == null) { - reporter.printFatalErrorAndExit( - buildType + ": Invalid build type."); - } - props.setProperty(BuildParm.BUILD_TYPE.getKey(), buildType); - } - - if (clean) { - props.setProperty(BuildParm.CLEAN.getKey(), "true"); - } - - if (externalRuntimePath != null) { - props.setProperty(BuildParm.EXTERNAL_RUNTIME_PATH.getKey(), - externalRuntimePath.toString()); - } + if (clean) { + props.setProperty(BuildParm.CLEAN.getKey(), "true"); + } - if (lint) { - props.setProperty(BuildParm.LINT.getKey(), "true"); - } + if (externalRuntimePath != null) { + props.setProperty(BuildParm.EXTERNAL_RUNTIME_PATH.getKey(), externalRuntimePath.toString()); + } - if (logging != null) { - // Validate log level. - if (UnionType.LOGGING_UNION.forName(logging) == null) { - reporter.printFatalErrorAndExit( - logging + ": Invalid log level."); - } - props.setProperty(BuildParm.LOGGING.getKey(), logging); - } + if (lint) { + props.setProperty(BuildParm.LINT.getKey(), "true"); + } - if(printStatistics) { - props.setProperty(BuildParm.PRINT_STATISTICS.getKey(), "true"); - } + if (logging != null) { + // Validate log level. + if (UnionType.LOGGING_UNION.forName(logging) == null) { + reporter.printFatalErrorAndExit(logging + ": Invalid log level."); + } + props.setProperty(BuildParm.LOGGING.getKey(), logging); + } - if (noCompile) { - props.setProperty(BuildParm.NO_COMPILE.getKey(), "true"); - } + if (printStatistics) { + props.setProperty(BuildParm.PRINT_STATISTICS.getKey(), "true"); + } - if (targetCompiler != null) { - props.setProperty(BuildParm.TARGET_COMPILER.getKey(), targetCompiler); - } + if (noCompile) { + props.setProperty(BuildParm.NO_COMPILE.getKey(), "true"); + } - if (quiet) { - props.setProperty(BuildParm.QUIET.getKey(), "true"); - } + if (targetCompiler != null) { + props.setProperty(BuildParm.TARGET_COMPILER.getKey(), targetCompiler); + } - if (rti != null) { - // Validate RTI path. - if (!Files.exists(io.getWd().resolve(rti))) { - reporter.printFatalErrorAndExit( - rti + ": Invalid RTI path."); - } - props.setProperty(BuildParm.RTI.getKey(), rti.toString()); - } + if (quiet) { + props.setProperty(BuildParm.QUIET.getKey(), "true"); + } - if (runtimeVersion != null) { - props.setProperty(BuildParm.RUNTIME_VERSION.getKey(), runtimeVersion); - } + if (rti != null) { + // Validate RTI path. + if (!Files.exists(io.getWd().resolve(rti))) { + reporter.printFatalErrorAndExit(rti + ": Invalid RTI path."); + } + props.setProperty(BuildParm.RTI.getKey(), rti.toString()); + } - if (scheduler != null) { - // Validate scheduler. - if (UnionType.SCHEDULER_UNION.forName(scheduler) == null) { - reporter.printFatalErrorAndExit( - scheduler + ": Invalid scheduler."); - } - props.setProperty(BuildParm.SCHEDULER.getKey(), scheduler); - } + if (runtimeVersion != null) { + props.setProperty(BuildParm.RUNTIME_VERSION.getKey(), runtimeVersion); + } - if (threading != null) { - props.setProperty(BuildParm.THREADING.getKey(), threading); - } + if (scheduler != null) { + // Validate scheduler. + if (UnionType.SCHEDULER_UNION.forName(scheduler) == null) { + reporter.printFatalErrorAndExit(scheduler + ": Invalid scheduler."); + } + props.setProperty(BuildParm.SCHEDULER.getKey(), scheduler); + } - if (workers != null) { - props.setProperty(BuildParm.WORKERS.getKey(), workers.toString()); - } + if (threading != null) { + props.setProperty(BuildParm.THREADING.getKey(), threading); + } - return props; + if (workers != null) { + props.setProperty(BuildParm.WORKERS.getKey(), workers.toString()); } + + return props; + } } diff --git a/org.lflang/src/org/lflang/cli/Lff.java b/org.lflang/src/org/lflang/cli/Lff.java index 297bc5ad84..f4f7714119 100644 --- a/org.lflang/src/org/lflang/cli/Lff.java +++ b/org.lflang/src/org/lflang/cli/Lff.java @@ -8,13 +8,11 @@ import java.nio.file.SimpleFileVisitor; import java.nio.file.attribute.BasicFileAttributes; import java.util.List; - -import picocli.CommandLine.Command; -import picocli.CommandLine.Option; import org.eclipse.emf.ecore.resource.Resource; - import org.lflang.ast.FormattingUtils; import org.lflang.util.FileUtil; +import picocli.CommandLine.Command; +import picocli.CommandLine.Option; /** * Standalone version of the Lingua Franca formatter (lff). Based on lfc. @@ -31,169 +29,163 @@ versionProvider = VersionProvider.class) public class Lff extends CliBase { - /** - * Supported CLI options for Lff. - */ - @Option( - names = {"-d", "--dry-run"}, - description = "Send the formatted file contents to stdout" - + " without writing to the file system.") - private boolean dryRun = false; - - @Option( - names = {"-w", "--wrap"}, - description = "Causes the formatter to line wrap the files to a" - + " specified length.", - defaultValue = "" + FormattingUtils.DEFAULT_LINE_LENGTH, - fallbackValue = "" + FormattingUtils.DEFAULT_LINE_LENGTH) - private int lineLength; - - @Option( - names = "--no-recurse", - description = "Do not format files in subdirectories of the" - + " specified paths.") - private boolean noRecurse = false; - - @Option( - names = {"-v", "--verbose"}, - description = "Print more details on files affected.") - private boolean verbose = false; - - @Option( - names = {"--ignore-errors"}, - description = "Ignore validation errors in files and format them anyway.") - private boolean ignoreErrors = false; - - /** - * Main function of the formatter. - * Caution: this will invoke System.exit. - * - * @param args CLI arguments - */ - public static void main(String[] args) { - main(Io.SYSTEM, args); + /** Supported CLI options for Lff. */ + @Option( + names = {"-d", "--dry-run"}, + description = + "Send the formatted file contents to stdout" + " without writing to the file system.") + private boolean dryRun = false; + + @Option( + names = {"-w", "--wrap"}, + description = "Causes the formatter to line wrap the files to a" + " specified length.", + defaultValue = "" + FormattingUtils.DEFAULT_LINE_LENGTH, + fallbackValue = "" + FormattingUtils.DEFAULT_LINE_LENGTH) + private int lineLength; + + @Option( + names = "--no-recurse", + description = "Do not format files in subdirectories of the" + " specified paths.") + private boolean noRecurse = false; + + @Option( + names = {"-v", "--verbose"}, + description = "Print more details on files affected.") + private boolean verbose = false; + + @Option( + names = {"--ignore-errors"}, + description = "Ignore validation errors in files and format them anyway.") + private boolean ignoreErrors = false; + + /** + * Main function of the formatter. Caution: this will invoke System.exit. + * + * @param args CLI arguments + */ + public static void main(String[] args) { + main(Io.SYSTEM, args); + } + + /** + * Programmatic entry point, with a custom IO. + * + * @param io IO streams. + * @param args Command-line arguments. + */ + public static void main(Io io, final String... args) { + cliMain("lff", Lff.class, io, args); + } + + /** Validates all paths and invokes the formatter on the input paths. */ + @Override + public void doRun() { + List paths = getInputPaths(); + final Path outputRoot = getOutputRoot(); + + try { + // Format all files defined by the list of paths. + formatAllFiles(paths, outputRoot); + + exitIfCollectedErrors(); + if (!dryRun || verbose) { + reporter.printInfo("Done formatting."); + } + } catch (RuntimeException e) { + reporter.printFatalErrorAndExit("An unexpected error occurred:", e); } - - /** - * Programmatic entry point, with a custom IO. - * - * @param io IO streams. - * @param args Command-line arguments. - */ - public static void main(Io io, final String... args) { - cliMain("lff", Lff.class, io, args); - } - - /** - * Validates all paths and invokes the formatter on the input paths. - */ - @Override - public void doRun() { - List paths = getInputPaths(); - final Path outputRoot = getOutputRoot(); - + } + + /* + * Invokes the formatter on all files defined by the list of paths. + */ + private void formatAllFiles(List paths, Path outputRoot) { + for (Path relativePath : paths) { + if (verbose) { + reporter.printInfo("Formatting " + io.getWd().relativize(relativePath) + ":"); + } + + Path path = toAbsolutePath(relativePath); + if (Files.isDirectory(path) && !noRecurse) { + // Walk the contents of this directory. try { - // Format all files defined by the list of paths. - formatAllFiles(paths, outputRoot); - - exitIfCollectedErrors(); - if (!dryRun || verbose) { - reporter.printInfo("Done formatting."); - } - } catch (RuntimeException e) { - reporter.printFatalErrorAndExit("An unexpected error occurred:", e); - } - } - - /* - * Invokes the formatter on all files defined by the list of paths. - */ - private void formatAllFiles(List paths, Path outputRoot) { - for (Path relativePath : paths) { - if (verbose) { - reporter.printInfo("Formatting " - + io.getWd().relativize(relativePath) + ":"); - } - - Path path = toAbsolutePath(relativePath); - if (Files.isDirectory(path) && !noRecurse) { - // Walk the contents of this directory. - try { - Files.walkFileTree(path, new SimpleFileVisitor<>() { - @Override - public FileVisitResult visitFile( - Path file, BasicFileAttributes attrs) { - formatSingleFile(file, path, outputRoot); - return FileVisitResult.CONTINUE; - } - }); - } catch (IOException e) { - reporter.printError("IO error: " + e); + Files.walkFileTree( + path, + new SimpleFileVisitor<>() { + @Override + public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) { + formatSingleFile(file, path, outputRoot); + return FileVisitResult.CONTINUE; } - } else { - // Simple file. - formatSingleFile(path, path.getParent(), outputRoot); - } + }); + } catch (IOException e) { + reporter.printError("IO error: " + e); } + } else { + // Simple file. + formatSingleFile(path, path.getParent(), outputRoot); + } } - - /* - * Invokes the formatter on a single file defined by the given path. - */ - private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { - path = path.normalize(); - Path outputPath = outputRoot == null + } + + /* + * Invokes the formatter on a single file defined by the given path. + */ + private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { + path = path.normalize(); + Path outputPath = + outputRoot == null ? path // Format in place. : outputRoot.resolve(inputRoot.relativize(path)).normalize(); - final Resource resource = getResource(path); - // Skip file if not an LF file. - if (resource == null) { - if (verbose) { - reporter.printInfo("Skipped " + path + ": not an LF file"); - } - return; - } - validateResource(resource); + final Resource resource = getResource(path); + // Skip file if not an LF file. + if (resource == null) { + if (verbose) { + reporter.printInfo("Skipped " + path + ": not an LF file"); + } + return; + } + validateResource(resource); - if (!ignoreErrors) { - exitIfCollectedErrors(); - } - final String formattedFileContents = - FormattingUtils.render(resource.getContents().get(0), lineLength); - - if (dryRun) { - io.getOut().print(formattedFileContents); - } else { - try { - FileUtil.writeToFile(formattedFileContents, outputPath, true); - } catch (IOException e) { - if (e instanceof FileAlreadyExistsException) { - // Only happens if a subdirectory is named with - // ".lf" at the end. - reporter.printFatalErrorAndExit( - "Error writing to " - + outputPath - + ": file already exists. Make sure that no file or" - + " directory within provided input paths have the" - + " same relative paths."); - } - } + if (!ignoreErrors) { + exitIfCollectedErrors(); + } + final String formattedFileContents = + FormattingUtils.render(resource.getContents().get(0), lineLength); + + if (dryRun) { + io.getOut().print(formattedFileContents); + } else { + try { + FileUtil.writeToFile(formattedFileContents, outputPath, true); + } catch (IOException e) { + if (e instanceof FileAlreadyExistsException) { + // Only happens if a subdirectory is named with + // ".lf" at the end. + reporter.printFatalErrorAndExit( + "Error writing to " + + outputPath + + ": file already exists. Make sure that no file or" + + " directory within provided input paths have the" + + " same relative paths."); } + } + } - if (!ignoreErrors) { - exitIfCollectedErrors(); - } - // Only errors are printed. Warnings are not helpful for LFF - // and since they don't prevent the file from being formatted, - // the position of the issue may be wrong in the formatted file. - // issueCollector.getAllIssues().forEach(reporter::printIssue); - if (verbose) { - String msg = "Formatted " + io.getWd().relativize(path); - if (path != outputPath) { - msg += " -> " + io.getWd().relativize(outputPath); - } - reporter.printInfo(msg); - } + if (!ignoreErrors) { + exitIfCollectedErrors(); + } + // Only errors are printed. Warnings are not helpful for LFF + // and since they don't prevent the file from being formatted, + // the position of the issue may be wrong in the formatted file. + // issueCollector.getAllIssues().forEach(reporter::printIssue); + if (verbose) { + String msg = "Formatted " + io.getWd().relativize(path); + if (path != outputPath) { + msg += " -> " + io.getWd().relativize(outputPath); + } + reporter.printInfo(msg); } + } } diff --git a/org.lflang/src/org/lflang/cli/StandaloneErrorReporter.java b/org.lflang/src/org/lflang/cli/StandaloneErrorReporter.java index 2b4ae6fe46..83e58eb15c 100644 --- a/org.lflang/src/org/lflang/cli/StandaloneErrorReporter.java +++ b/org.lflang/src/org/lflang/cli/StandaloneErrorReporter.java @@ -27,90 +27,79 @@ package org.lflang.cli; +import com.google.inject.Inject; import java.nio.file.Path; - import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.diagnostics.Severity; - import org.lflang.ErrorReporter; -import com.google.inject.Inject; - /** - * An error reporter that forwards all messages to an {@link IssueCollector}. - * They'll be sorted out later. + * An error reporter that forwards all messages to an {@link IssueCollector}. They'll be sorted out + * later. */ public class StandaloneErrorReporter implements ErrorReporter { - @Inject - private StandaloneIssueAcceptor issueAcceptor; - - private String reportWithNode(String message, Severity severity, EObject obj) { - issueAcceptor.accept(severity, message, obj, null, 0, null); - return message; - } - - private String reportSimpleFileCtx(String message, Severity severity, Integer line, Path path) { - LfIssue issue = new LfIssue(message, severity, line, 1, line, 1, 0, path); - issueAcceptor.accept(issue); - // Return a string that can be inserted into the generated code. - return message; - } - - - @Override - public String reportError(String message) { - return reportSimpleFileCtx(message, Severity.ERROR, null, null); - } - - - @Override - public String reportWarning(String message) { - return reportSimpleFileCtx(message, Severity.WARNING, null, null); - } - - @Override - public String reportInfo(String message) { - return reportSimpleFileCtx(message, Severity.INFO, null, null); - } - - - @Override - public String reportError(EObject obj, String message) { - return reportWithNode(message, Severity.ERROR, obj); - } - - - @Override - public String reportWarning(EObject obj, String message) { - return reportWithNode(message, Severity.WARNING, obj); - } - - @Override - public String reportInfo(EObject obj, String message) { - return reportWithNode(message, Severity.INFO, obj); - } - - - @Override - public String reportError(Path file, Integer line, String message) { - return reportSimpleFileCtx(message, Severity.ERROR, line, file); - } - - - @Override - public String reportWarning(Path file, Integer line, String message) { - return reportSimpleFileCtx(message, Severity.WARNING, line, file); - } - - @Override - public String reportInfo(Path file, Integer line, String message) { - return reportSimpleFileCtx(message, Severity.INFO, line, file); - } - - - @Override - public boolean getErrorsOccurred() { - return issueAcceptor.getErrorsOccurred(); - } + @Inject private StandaloneIssueAcceptor issueAcceptor; + + private String reportWithNode(String message, Severity severity, EObject obj) { + issueAcceptor.accept(severity, message, obj, null, 0, null); + return message; + } + + private String reportSimpleFileCtx(String message, Severity severity, Integer line, Path path) { + LfIssue issue = new LfIssue(message, severity, line, 1, line, 1, 0, path); + issueAcceptor.accept(issue); + // Return a string that can be inserted into the generated code. + return message; + } + + @Override + public String reportError(String message) { + return reportSimpleFileCtx(message, Severity.ERROR, null, null); + } + + @Override + public String reportWarning(String message) { + return reportSimpleFileCtx(message, Severity.WARNING, null, null); + } + + @Override + public String reportInfo(String message) { + return reportSimpleFileCtx(message, Severity.INFO, null, null); + } + + @Override + public String reportError(EObject obj, String message) { + return reportWithNode(message, Severity.ERROR, obj); + } + + @Override + public String reportWarning(EObject obj, String message) { + return reportWithNode(message, Severity.WARNING, obj); + } + + @Override + public String reportInfo(EObject obj, String message) { + return reportWithNode(message, Severity.INFO, obj); + } + + @Override + public String reportError(Path file, Integer line, String message) { + return reportSimpleFileCtx(message, Severity.ERROR, line, file); + } + + @Override + public String reportWarning(Path file, Integer line, String message) { + return reportSimpleFileCtx(message, Severity.WARNING, line, file); + } + + @Override + public String reportInfo(Path file, Integer line, String message) { + return reportSimpleFileCtx(message, Severity.INFO, line, file); + } + + @Override + public boolean getErrorsOccurred() { + return issueAcceptor.getErrorsOccurred(); + } } diff --git a/org.lflang/src/org/lflang/cli/StandaloneIssueAcceptor.java b/org.lflang/src/org/lflang/cli/StandaloneIssueAcceptor.java index 73ca4bea9e..cb9712a7cb 100644 --- a/org.lflang/src/org/lflang/cli/StandaloneIssueAcceptor.java +++ b/org.lflang/src/org/lflang/cli/StandaloneIssueAcceptor.java @@ -1,42 +1,41 @@ package org.lflang.cli; +import com.google.inject.Inject; import java.io.IOException; import java.nio.file.Path; - import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EStructuralFeature; import org.eclipse.xtext.diagnostics.Severity; import org.eclipse.xtext.validation.EObjectDiagnosticImpl; import org.eclipse.xtext.validation.ValidationMessageAcceptor; - import org.lflang.util.FileUtil; -import com.google.inject.Inject; - -/** - * - */ +/** */ public class StandaloneIssueAcceptor implements ValidationMessageAcceptor { - @Inject - private IssueCollector collector; - - - boolean getErrorsOccurred() { - return collector.getErrorsOccurred(); - } - - - void accept(LfIssue lfIssue) { - collector.accept(lfIssue); - } - - - void accept(Severity severity, String message, EObject object, EStructuralFeature feature, int index, String code, String... issueData) { - EObjectDiagnosticImpl diagnostic = - new EObjectDiagnosticImpl(severity, code, message, object, feature, index, issueData); - - LfIssue lfIssue = new LfIssue( + @Inject private IssueCollector collector; + + boolean getErrorsOccurred() { + return collector.getErrorsOccurred(); + } + + void accept(LfIssue lfIssue) { + collector.accept(lfIssue); + } + + void accept( + Severity severity, + String message, + EObject object, + EStructuralFeature feature, + int index, + String code, + String... issueData) { + EObjectDiagnosticImpl diagnostic = + new EObjectDiagnosticImpl(severity, code, message, object, feature, index, issueData); + + LfIssue lfIssue = + new LfIssue( message, severity, diagnostic.getLine(), @@ -44,64 +43,81 @@ void accept(Severity severity, String message, EObject object, EStructuralFeatur diagnostic.getLineEnd(), diagnostic.getColumnEnd(), diagnostic.getLength(), - getPath(diagnostic) - ); - - accept(lfIssue); - } - - - /** - * Best effort to get a fileName. May return null. - */ - private Path getPath(EObjectDiagnosticImpl diagnostic) { - Path file = null; - try { - file = FileUtil.toPath(diagnostic.getUriToProblem()); - } catch (IOException e) { - // just continue with null - } - return file; - } - - - private void accept(Severity severity, String message, EObject object, int offset, int length, String code, String... issueData) { - throw new UnsupportedOperationException("not implemented: range based diagnostics"); - } - - - @Override - public void acceptError(String message, EObject object, EStructuralFeature feature, int index, String code, String... issueData) { - accept(Severity.ERROR, message, object, feature, index, code, issueData); - } - - - @Override - public void acceptError(String message, EObject object, int offset, int length, String code, String... issueData) { - accept(Severity.ERROR, message, object, offset, length, code, issueData); - } - - - @Override - public void acceptWarning(String message, EObject object, EStructuralFeature feature, int index, String code, String... issueData) { - accept(Severity.WARNING, message, object, feature, index, code, issueData); - } - - - @Override - public void acceptWarning(String message, EObject object, int offset, int length, String code, String... issueData) { - accept(Severity.WARNING, message, object, offset, length, code, issueData); - } - - - @Override - public void acceptInfo(String message, EObject object, EStructuralFeature feature, int index, String code, String... issueData) { - accept(Severity.INFO, message, object, feature, index, code, issueData); - } - - - @Override - public void acceptInfo(String message, EObject object, int offset, int length, String code, String... issueData) { - accept(Severity.INFO, message, object, offset, length, code, issueData); + getPath(diagnostic)); + + accept(lfIssue); + } + + /** Best effort to get a fileName. May return null. */ + private Path getPath(EObjectDiagnosticImpl diagnostic) { + Path file = null; + try { + file = FileUtil.toPath(diagnostic.getUriToProblem()); + } catch (IOException e) { + // just continue with null } + return file; + } + + private void accept( + Severity severity, + String message, + EObject object, + int offset, + int length, + String code, + String... issueData) { + throw new UnsupportedOperationException("not implemented: range based diagnostics"); + } + + @Override + public void acceptError( + String message, + EObject object, + EStructuralFeature feature, + int index, + String code, + String... issueData) { + accept(Severity.ERROR, message, object, feature, index, code, issueData); + } + + @Override + public void acceptError( + String message, EObject object, int offset, int length, String code, String... issueData) { + accept(Severity.ERROR, message, object, offset, length, code, issueData); + } + + @Override + public void acceptWarning( + String message, + EObject object, + EStructuralFeature feature, + int index, + String code, + String... issueData) { + accept(Severity.WARNING, message, object, feature, index, code, issueData); + } + + @Override + public void acceptWarning( + String message, EObject object, int offset, int length, String code, String... issueData) { + accept(Severity.WARNING, message, object, offset, length, code, issueData); + } + + @Override + public void acceptInfo( + String message, + EObject object, + EStructuralFeature feature, + int index, + String code, + String... issueData) { + accept(Severity.INFO, message, object, feature, index, code, issueData); + } + + @Override + public void acceptInfo( + String message, EObject object, int offset, int length, String code, String... issueData) { + accept(Severity.INFO, message, object, offset, length, code, issueData); + } } diff --git a/org.lflang/src/org/lflang/cli/VersionProvider.java b/org.lflang/src/org/lflang/cli/VersionProvider.java index ce9c8f6252..ca9c3d6bbb 100644 --- a/org.lflang/src/org/lflang/cli/VersionProvider.java +++ b/org.lflang/src/org/lflang/cli/VersionProvider.java @@ -1,11 +1,10 @@ package org.lflang.cli; +import org.lflang.LocalStrings; import picocli.CommandLine.IVersionProvider; import picocli.CommandLine.Model.CommandSpec; import picocli.CommandLine.Spec; -import org.lflang.LocalStrings; - /* * Dynamically provides version information to the Lingua Franca CLI. * Picocli will instantiate this class and invoke it to collect version @@ -14,19 +13,18 @@ * @author Atharva Patil */ class VersionProvider implements IVersionProvider { - /* - * Here, picocli will inject the CommandSpec (full command hierarchy) of the - * command that uses this version provider. This allows this version - * provider to be reused among multiple commands. - */ - @Spec CommandSpec spec; + /* + * Here, picocli will inject the CommandSpec (full command hierarchy) of the + * command that uses this version provider. This allows this version + * provider to be reused among multiple commands. + */ + @Spec CommandSpec spec; - // Method invoked by picocli to get the version info. - public String[] getVersion() { - return new String[] { - // "lfc", "lff", etc. - spec.qualifiedName() - + " " + LocalStrings.VERSION - }; - } + // Method invoked by picocli to get the version info. + public String[] getVersion() { + return new String[] { + // "lfc", "lff", etc. + spec.qualifiedName() + " " + LocalStrings.VERSION + }; + } } diff --git a/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServer.java b/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServer.java index 1971fbc081..405e322a88 100644 --- a/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServer.java +++ b/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServer.java @@ -1,10 +1,9 @@ package org.lflang.diagram.lsp; -import org.eclipse.lsp4j.WorkDoneProgressCancelParams; import de.cau.cs.kieler.klighd.lsp.KGraphLanguageServerExtension; - import org.eclipse.lsp4j.Hover; import org.eclipse.lsp4j.HoverParams; +import org.eclipse.lsp4j.WorkDoneProgressCancelParams; import org.eclipse.xtext.ide.server.hover.IHoverService; import org.eclipse.xtext.util.CancelIndicator; @@ -14,21 +13,24 @@ * @author Peter Donovan */ public class LFLanguageServer extends KGraphLanguageServerExtension { - @Override - public void cancelProgress(WorkDoneProgressCancelParams params) { - Progress.cancel(params.getToken().getRight().intValue()); - } + @Override + public void cancelProgress(WorkDoneProgressCancelParams params) { + Progress.cancel(params.getToken().getRight().intValue()); + } - @Override - protected Hover hover(HoverParams params, CancelIndicator cancelIndicator) { - // This override is just a hacky little patch that is being applied downstream of the original mistake and - // upstream of the ungraceful handling (IndexOutOfBoundsException) of said mistake. This patch is applied here - // simply because it is easy. This would be done differently were it not for the fact that we plan to rebuild - // this infrastructure from scratch anyway. - try { - return super.hover(params, cancelIndicator); - } catch (IndexOutOfBoundsException e) { - return IHoverService.EMPTY_HOVER; // Fail silently - } + @Override + protected Hover hover(HoverParams params, CancelIndicator cancelIndicator) { + // This override is just a hacky little patch that is being applied downstream of the original + // mistake and + // upstream of the ungraceful handling (IndexOutOfBoundsException) of said mistake. This patch + // is applied here + // simply because it is easy. This would be done differently were it not for the fact that we + // plan to rebuild + // this infrastructure from scratch anyway. + try { + return super.hover(params, cancelIndicator); + } catch (IndexOutOfBoundsException e) { + return IHoverService.EMPTY_HOVER; // Fail silently } + } } diff --git a/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServerExtension.java b/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServerExtension.java index fd25b0fc0a..18de51f482 100644 --- a/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServerExtension.java +++ b/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServerExtension.java @@ -1,125 +1,125 @@ package org.lflang.diagram.lsp; -import java.util.concurrent.CompletableFuture; import java.util.ArrayList; - +import java.util.concurrent.CompletableFuture; import org.eclipse.emf.common.util.URI; import org.eclipse.lsp4j.jsonrpc.services.JsonNotification; import org.eclipse.lsp4j.jsonrpc.services.JsonRequest; import org.eclipse.lsp4j.services.LanguageClient; -import org.eclipse.xtext.ide.server.ILanguageServerExtension; import org.eclipse.xtext.ide.server.ILanguageServerAccess; - +import org.eclipse.xtext.ide.server.ILanguageServerExtension; +import org.lflang.LFRuntimeModule; +import org.lflang.LFStandaloneSetup; +import org.lflang.generator.GeneratorResult; import org.lflang.generator.GeneratorResult.Status; import org.lflang.generator.IntegratedBuilder; -import org.lflang.generator.GeneratorResult; -import org.lflang.LFStandaloneSetup; -import org.lflang.LFRuntimeModule; import org.lflang.util.LFCommand; /** - * Provide Lingua-Franca-specific extensions to the - * language server's behavior. + * Provide Lingua-Franca-specific extensions to the language server's behavior. * * @author Peter Donovan */ class LFLanguageServerExtension implements ILanguageServerExtension { - /** The IntegratedBuilder instance that handles all build requests for the current session. */ - private static final IntegratedBuilder builder = new LFStandaloneSetup(new LFRuntimeModule()) - .createInjectorAndDoEMFRegistration().getInstance(IntegratedBuilder.class); + /** The IntegratedBuilder instance that handles all build requests for the current session. */ + private static final IntegratedBuilder builder = + new LFStandaloneSetup(new LFRuntimeModule()) + .createInjectorAndDoEMFRegistration() + .getInstance(IntegratedBuilder.class); - /** The access point for reading documents, communicating with the language client, etc. */ - private LanguageClient client; + /** The access point for reading documents, communicating with the language client, etc. */ + private LanguageClient client; - @Override - public void initialize(ILanguageServerAccess access) { - // This method is never invoked. - } + @Override + public void initialize(ILanguageServerAccess access) { + // This method is never invoked. + } - public void setClient(LanguageClient client) { - this.client = client; - } + public void setClient(LanguageClient client) { + this.client = client; + } - /** - * Handle a request for a complete build of the Lingua - * Franca file specified by {@code uri}. - * @param uri the URI of the LF file of interest - * @return A message describing the outcome of the build - * process. - */ - @JsonRequest("generator/build") - public CompletableFuture build(String uri) { - if (client == null) return CompletableFuture.completedFuture( - "Please wait for the Lingua Franca language server to be fully initialized." - ); - return CompletableFuture.supplyAsync( - () -> { - try { - return buildWithProgress(client, uri, true).getUserMessage(); - } catch (Exception e) { - return "An internal error occurred:\n" + e; - } - } - ); - } + /** + * Handle a request for a complete build of the Lingua Franca file specified by {@code uri}. + * + * @param uri the URI of the LF file of interest + * @return A message describing the outcome of the build process. + */ + @JsonRequest("generator/build") + public CompletableFuture build(String uri) { + if (client == null) + return CompletableFuture.completedFuture( + "Please wait for the Lingua Franca language server to be fully initialized."); + return CompletableFuture.supplyAsync( + () -> { + try { + return buildWithProgress(client, uri, true).getUserMessage(); + } catch (Exception e) { + return "An internal error occurred:\n" + e; + } + }); + } - /** - * Handles a request for the most complete build of the - * specified Lingua Franca file that can be done in a - * limited amount of time. - * @param uri the URI of the LF file of interest - */ - @JsonNotification("generator/partialBuild") - public void partialBuild(String uri) { - if (client == null) return; - buildWithProgress(client, uri, false); - } + /** + * Handles a request for the most complete build of the specified Lingua Franca file that can be + * done in a limited amount of time. + * + * @param uri the URI of the LF file of interest + */ + @JsonNotification("generator/partialBuild") + public void partialBuild(String uri) { + if (client == null) return; + buildWithProgress(client, uri, false); + } - /** - * Completely build the specified LF program and provide information that is sufficient to - * run it. - * @param uri The URI of the LF program to be built. - * @return An array consisting of the directory in which the execute command should be - * executed, the program of the execute command, and the arguments of the execute command. - */ - @JsonNotification("generator/buildAndRun") - public CompletableFuture buildAndRun(String uri) { - return new CompletableFuture().completeAsync(() -> { - var result = buildWithProgress(client, uri, true); - if (!result.getStatus().equals(Status.COMPILED)) return null; - LFCommand cmd = result.getContext().getFileConfig().getCommand(); - ArrayList ret = new ArrayList<>(); - ret.add(cmd.directory().toString()); - ret.addAll(cmd.command()); - return ret.toArray(new String[0]); - }); - } + /** + * Completely build the specified LF program and provide information that is sufficient to run it. + * + * @param uri The URI of the LF program to be built. + * @return An array consisting of the directory in which the execute command should be executed, + * the program of the execute command, and the arguments of the execute command. + */ + @JsonNotification("generator/buildAndRun") + public CompletableFuture buildAndRun(String uri) { + return new CompletableFuture() + .completeAsync( + () -> { + var result = buildWithProgress(client, uri, true); + if (!result.getStatus().equals(Status.COMPILED)) return null; + LFCommand cmd = result.getContext().getFileConfig().getCommand(); + ArrayList ret = new ArrayList<>(); + ret.add(cmd.directory().toString()); + ret.addAll(cmd.command()); + return ret.toArray(new String[0]); + }); + } - /** - * Describes a build process that has a progress. - */ - private GeneratorResult buildWithProgress(LanguageClient client, String uri, boolean mustComplete) { - URI parsedUri; - try { - parsedUri = URI.createFileURI(new java.net.URI(uri).getPath()); - } catch (java.net.URISyntaxException e) { - // This error will appear as a silent failure to most users, but that is acceptable because this error - // should be impossible. The URI is not the result of user input -- the language client provides it -- - // so it should be valid. - System.err.println(e); - return GeneratorResult.NOTHING; - } - Progress progress = new Progress(client, "Build \"" + parsedUri.lastSegment() + "\"", mustComplete); - progress.begin(); - GeneratorResult result = null; - try { - result = builder.run( - parsedUri, mustComplete, progress::report, progress.getCancelIndicator() - ); - } finally { - progress.end(result == null ? "An internal error occurred." : result.getUserMessage()); - } - return result; + /** Describes a build process that has a progress. */ + private GeneratorResult buildWithProgress( + LanguageClient client, String uri, boolean mustComplete) { + URI parsedUri; + try { + parsedUri = URI.createFileURI(new java.net.URI(uri).getPath()); + } catch (java.net.URISyntaxException e) { + // This error will appear as a silent failure to most users, but that is acceptable because + // this error + // should be impossible. The URI is not the result of user input -- the language client + // provides it -- + // so it should be valid. + System.err.println(e); + return GeneratorResult.NOTHING; + } + Progress progress = + new Progress(client, "Build \"" + parsedUri.lastSegment() + "\"", mustComplete); + progress.begin(); + GeneratorResult result = null; + try { + result = + builder.run(parsedUri, mustComplete, progress::report, progress.getCancelIndicator()); + } finally { + progress.end(result == null ? "An internal error occurred." : result.getUserMessage()); } + return result; + } } diff --git a/org.lflang/src/org/lflang/diagram/lsp/LanguageDiagramServer.java b/org.lflang/src/org/lflang/diagram/lsp/LanguageDiagramServer.java index c4d7804453..96e887d242 100644 --- a/org.lflang/src/org/lflang/diagram/lsp/LanguageDiagramServer.java +++ b/org.lflang/src/org/lflang/diagram/lsp/LanguageDiagramServer.java @@ -1,20 +1,8 @@ package org.lflang.diagram.lsp; -import java.util.List; - -import org.eclipse.xtext.Constants; -import org.eclipse.xtext.IGrammarAccess; -import org.eclipse.xtext.ide.server.ILanguageServerExtension; -import org.eclipse.xtext.ide.server.LanguageServerImpl; -import org.eclipse.xtext.service.AbstractGenericModule; -import org.eclipse.xtext.util.Modules2; -import org.lflang.generator.LanguageServerErrorReporter; -import org.lflang.ide.LFIdeSetup; - import com.google.inject.Module; import com.google.inject.name.Names; import com.google.inject.util.Modules; - import de.cau.cs.kieler.kgraph.text.services.KGraphGrammarAccess; import de.cau.cs.kieler.klighd.lsp.KGraphLanguageClient; import de.cau.cs.kieler.klighd.lsp.interactive.layered.LayeredInteractiveLanguageServerExtension; @@ -24,82 +12,102 @@ import de.cau.cs.kieler.klighd.lsp.launch.AbstractRegistrationLanguageServerExtension; import de.cau.cs.kieler.klighd.lsp.launch.ILanguageRegistration; import de.cau.cs.kieler.klighd.lsp.launch.Language; +import java.util.List; +import org.eclipse.xtext.Constants; +import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.ide.server.ILanguageServerExtension; +import org.eclipse.xtext.ide.server.LanguageServerImpl; +import org.eclipse.xtext.service.AbstractGenericModule; +import org.eclipse.xtext.util.Modules2; +import org.lflang.generator.LanguageServerErrorReporter; +import org.lflang.ide.LFIdeSetup; /** * Language server with extended diagram communication. - * + * * @author Alexander Schulz-Rosengarten */ public class LanguageDiagramServer extends AbstractLanguageServer { - - private static class LFLsCreator extends AbstractLsCreator { - @Override - public Module createLSModules(boolean socket) { - return Modules2.mixin(Modules.override(super.createLSModules(socket)).with(new AbstractGenericModule() { - public Class bindLanguageServerImpl() { - return LFLanguageServer.class; - } - }), it -> { - // Temporary fix for an issue of Klighd with Xtext 2.28 (https://github.com/kieler/KLighD/issues/144) - it.bind(IGrammarAccess.class).to(KGraphGrammarAccess.class); - it.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("de.cau.cs.kieler.kgraph.text.KGraph"); - }); - } - - LayeredInteractiveLanguageServerExtension constraints; - RectpackingInteractiveLanguageServerExtension rectPack; - LFLanguageServerExtension lfExtension; - - @Override - public List getLanguageServerExtensions() { - constraints = injector.getInstance(LayeredInteractiveLanguageServerExtension.class); - rectPack = injector.getInstance(RectpackingInteractiveLanguageServerExtension.class); - lfExtension = injector.getInstance(LFLanguageServerExtension.class); - return List.of( - injector.getInstance(LFRegistrationLanguageServerExtension.class), constraints, rectPack, lfExtension - ); - } - - @Override - public Class getRemoteInterface() { - return KGraphLanguageClient.class; - } - - @Override - public void onConnect() { - super.onConnect(); - constraints.setClient((KGraphLanguageClient) languageClient); - rectPack.setClient((KGraphLanguageClient) languageClient); - LanguageServerErrorReporter.setClient(languageClient); - lfExtension.setClient(languageClient); - // The following is needed because VS Code treats System.err like System.out and System.out like a shout - // into the void. - System.setOut(System.err); - } + private static class LFLsCreator extends AbstractLsCreator { + + @Override + public Module createLSModules(boolean socket) { + return Modules2.mixin( + Modules.override(super.createLSModules(socket)) + .with( + new AbstractGenericModule() { + public Class bindLanguageServerImpl() { + return LFLanguageServer.class; + } + }), + it -> { + // Temporary fix for an issue of Klighd with Xtext 2.28 + // (https://github.com/kieler/KLighD/issues/144) + it.bind(IGrammarAccess.class).to(KGraphGrammarAccess.class); + it.bind(String.class) + .annotatedWith(Names.named(Constants.LANGUAGE_NAME)) + .toInstance("de.cau.cs.kieler.kgraph.text.KGraph"); + }); + } + + LayeredInteractiveLanguageServerExtension constraints; + RectpackingInteractiveLanguageServerExtension rectPack; + LFLanguageServerExtension lfExtension; + + @Override + public List getLanguageServerExtensions() { + constraints = injector.getInstance(LayeredInteractiveLanguageServerExtension.class); + rectPack = injector.getInstance(RectpackingInteractiveLanguageServerExtension.class); + lfExtension = injector.getInstance(LFLanguageServerExtension.class); + return List.of( + injector.getInstance(LFRegistrationLanguageServerExtension.class), + constraints, + rectPack, + lfExtension); } - - private static class LFLanguageRegistration implements ILanguageRegistration { - - @Override - public void bindAndRegisterLanguages() { - LFIdeSetup.doSetup(); - } + + @Override + public Class getRemoteInterface() { + return KGraphLanguageClient.class; } - private static class LFRegistrationLanguageServerExtension extends AbstractRegistrationLanguageServerExtension { - - @Override - public List getLanguageExtensions() { - return List.of(new Language("lf", "Lingua Franca", List.of())); - } + @Override + public void onConnect() { + super.onConnect(); + constraints.setClient((KGraphLanguageClient) languageClient); + rectPack.setClient((KGraphLanguageClient) languageClient); + LanguageServerErrorReporter.setClient(languageClient); + lfExtension.setClient(languageClient); + // The following is needed because VS Code treats System.err like System.out and System.out + // like a shout + // into the void. + System.setOut(System.err); } - - public static void main(String[] args) { - new LanguageDiagramServer().start(); + } + + private static class LFLanguageRegistration implements ILanguageRegistration { + + @Override + public void bindAndRegisterLanguages() { + LFIdeSetup.doSetup(); } - - public void start() { - configureAndRun(new LFLanguageRegistration(), new LFLsCreator()); + } + + private static class LFRegistrationLanguageServerExtension + extends AbstractRegistrationLanguageServerExtension { + + @Override + public List getLanguageExtensions() { + return List.of(new Language("lf", "Lingua Franca", List.of())); } + } + + public static void main(String[] args) { + new LanguageDiagramServer().start(); + } + + public void start() { + configureAndRun(new LFLanguageRegistration(), new LFLsCreator()); + } } diff --git a/org.lflang/src/org/lflang/diagram/lsp/Progress.java b/org.lflang/src/org/lflang/diagram/lsp/Progress.java index 2c1bb2f7fe..56c6788ea8 100644 --- a/org.lflang/src/org/lflang/diagram/lsp/Progress.java +++ b/org.lflang/src/org/lflang/diagram/lsp/Progress.java @@ -2,15 +2,14 @@ import java.util.HashMap; import java.util.Map; - -import org.eclipse.lsp4j.jsonrpc.messages.Either; import org.eclipse.lsp4j.ProgressParams; -import org.eclipse.lsp4j.services.LanguageClient; -import org.eclipse.lsp4j.WorkDoneProgressCreateParams; import org.eclipse.lsp4j.WorkDoneProgressBegin; +import org.eclipse.lsp4j.WorkDoneProgressCreateParams; import org.eclipse.lsp4j.WorkDoneProgressEnd; import org.eclipse.lsp4j.WorkDoneProgressNotification; import org.eclipse.lsp4j.WorkDoneProgressReport; +import org.eclipse.lsp4j.jsonrpc.messages.Either; +import org.eclipse.lsp4j.services.LanguageClient; import org.eclipse.xtext.util.CancelIndicator; /** @@ -19,88 +18,85 @@ * @author Peter Donovan */ public class Progress { - private static int nextToken = 0; - private static final Map cancellations = new HashMap<>(); + private static int nextToken = 0; + private static final Map cancellations = new HashMap<>(); - private final LanguageClient client; - private final String title; - private final int token; - private final boolean cancellable; + private final LanguageClient client; + private final String title; + private final int token; + private final boolean cancellable; - /** - * Initialize the {@code Progress} of a task titled {@code title} that is - * triggered via {@code client}. - * @param client A language client through which a task was triggered. - * @param title The title of the task. - * @param cancellable Whether the task tracked by {@code this} can be - * cancelled. - */ - public Progress(LanguageClient client, String title, boolean cancellable) { - this.client = client; - this.title = title; - this.token = nextToken++; - this.cancellable = cancellable; - if (cancellable) cancellations.put(token, false); - client.createProgress(new WorkDoneProgressCreateParams(Either.forRight(token))); - } + /** + * Initialize the {@code Progress} of a task titled {@code title} that is triggered via {@code + * client}. + * + * @param client A language client through which a task was triggered. + * @param title The title of the task. + * @param cancellable Whether the task tracked by {@code this} can be cancelled. + */ + public Progress(LanguageClient client, String title, boolean cancellable) { + this.client = client; + this.title = title; + this.token = nextToken++; + this.cancellable = cancellable; + if (cancellable) cancellations.put(token, false); + client.createProgress(new WorkDoneProgressCreateParams(Either.forRight(token))); + } - /** - * Cancel the task tracked by the {@code Progress} that has token - * {@code token}. - */ - public static void cancel(int token) { - if (cancellations.containsKey(token)) cancellations.put(token, true); - } + /** Cancel the task tracked by the {@code Progress} that has token {@code token}. */ + public static void cancel(int token) { + if (cancellations.containsKey(token)) cancellations.put(token, true); + } - /** - * Returns the cancel indicator for the task tracked by this - * {@code Progress}. - * @return the cancel indicator for the task tracked by this - * {@code Progress} - */ - public CancelIndicator getCancelIndicator() { - if (cancellable) return () -> cancellations.get(token); - return () -> false; - } + /** + * Returns the cancel indicator for the task tracked by this {@code Progress}. + * + * @return the cancel indicator for the task tracked by this {@code Progress} + */ + public CancelIndicator getCancelIndicator() { + if (cancellable) return () -> cancellations.get(token); + return () -> false; + } - /** - * Report that the task tracked by {@code this} is done. - */ - public void begin() { - WorkDoneProgressBegin begin = new WorkDoneProgressBegin(); - begin.setTitle(title); - begin.setCancellable(cancellable); - begin.setPercentage(0); - notifyProgress(begin); - } + /** Report that the task tracked by {@code this} is done. */ + public void begin() { + WorkDoneProgressBegin begin = new WorkDoneProgressBegin(); + begin.setTitle(title); + begin.setCancellable(cancellable); + begin.setPercentage(0); + notifyProgress(begin); + } - /** - * Report the progress of the task tracked by {@code this}. - * @param message A message describing the progress of the task. - */ - public void report(String message, Integer percentage) { - WorkDoneProgressReport report = new WorkDoneProgressReport(); - report.setMessage(message); - report.setCancellable(cancellable); - report.setPercentage(percentage); - notifyProgress(report); - } + /** + * Report the progress of the task tracked by {@code this}. + * + * @param message A message describing the progress of the task. + */ + public void report(String message, Integer percentage) { + WorkDoneProgressReport report = new WorkDoneProgressReport(); + report.setMessage(message); + report.setCancellable(cancellable); + report.setPercentage(percentage); + notifyProgress(report); + } - /** - * Marks the task tracked by {@code this} as terminated. - * @param message A message describing the outcome of the task. - */ - public void end(String message) { - WorkDoneProgressEnd end = new WorkDoneProgressEnd(); - end.setMessage(message); - notifyProgress(end); - } + /** + * Marks the task tracked by {@code this} as terminated. + * + * @param message A message describing the outcome of the task. + */ + public void end(String message) { + WorkDoneProgressEnd end = new WorkDoneProgressEnd(); + end.setMessage(message); + notifyProgress(end); + } - /** - * Send the given progress notification to the client. - * @param notification - */ - private void notifyProgress(WorkDoneProgressNotification notification) { - client.notifyProgress(new ProgressParams(Either.forRight(token), Either.forLeft(notification))); - } + /** + * Send the given progress notification to the client. + * + * @param notification + */ + private void notifyProgress(WorkDoneProgressNotification notification) { + client.notifyProgress(new ProgressParams(Either.forRight(token), Either.forLeft(notification))); + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java b/org.lflang/src/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java index 1041af3ce7..4d32af61ef 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis; import de.cau.cs.kieler.klighd.SynthesisOption; @@ -30,33 +30,33 @@ import org.eclipse.emf.ecore.EObject; /** - * Abstract super class for extension classes used in for the diagram synthesis that provides some convince methods. - * + * Abstract super class for extension classes used in for the diagram synthesis that provides some + * convince methods. + * * @author Alexander Schulz-Rosengarten */ public abstract class AbstractSynthesisExtensions { - - @Inject - private AbstractDiagramSynthesis delegate; - - public boolean getBooleanValue(SynthesisOption option) { - return delegate.getBooleanValue(option); - } - - public float getFloatValue(SynthesisOption option) { - return delegate.getFloatValue(option); - } - - public Object getObjectValue(final SynthesisOption option) { - return delegate.getObjectValue(option); - } - - public T associateWith(T derived, Object source) { - return delegate.associateWith(derived, source); - } - - @SuppressWarnings("unchecked") - public > T getRootSynthesis() { - return (T) delegate; - } + + @Inject private AbstractDiagramSynthesis delegate; + + public boolean getBooleanValue(SynthesisOption option) { + return delegate.getBooleanValue(option); + } + + public float getFloatValue(SynthesisOption option) { + return delegate.getFloatValue(option); + } + + public Object getObjectValue(final SynthesisOption option) { + return delegate.getObjectValue(option); + } + + public T associateWith(T derived, Object source) { + return delegate.associateWith(derived, source); + } + + @SuppressWarnings("unchecked") + public > T getRootSynthesis() { + return (T) delegate; + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java b/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java index 2b1a2a1bf6..45f3342a0a 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java @@ -1,29 +1,61 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis; +import com.google.common.collect.HashBasedTable; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Iterables; +import com.google.common.collect.Multimap; +import com.google.common.collect.Table; +import de.cau.cs.kieler.klighd.DisplayedActionData; +import de.cau.cs.kieler.klighd.SynthesisOption; +import de.cau.cs.kieler.klighd.kgraph.KEdge; +import de.cau.cs.kieler.klighd.kgraph.KLabel; +import de.cau.cs.kieler.klighd.kgraph.KNode; +import de.cau.cs.kieler.klighd.kgraph.KPort; +import de.cau.cs.kieler.klighd.krendering.Colors; +import de.cau.cs.kieler.klighd.krendering.HorizontalAlignment; +import de.cau.cs.kieler.klighd.krendering.KContainerRendering; +import de.cau.cs.kieler.klighd.krendering.KPolyline; +import de.cau.cs.kieler.klighd.krendering.KRectangle; +import de.cau.cs.kieler.klighd.krendering.KRendering; +import de.cau.cs.kieler.klighd.krendering.KRoundedRectangle; +import de.cau.cs.kieler.klighd.krendering.KStyle; +import de.cau.cs.kieler.klighd.krendering.KText; +import de.cau.cs.kieler.klighd.krendering.LineCap; +import de.cau.cs.kieler.klighd.krendering.LineStyle; +import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; +import de.cau.cs.kieler.klighd.krendering.extensions.KContainerRenderingExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KEdgeExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KLabelExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KNodeExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KPolylineExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KPortExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KRenderingExtensions; +import de.cau.cs.kieler.klighd.syntheses.AbstractDiagramSynthesis; +import de.cau.cs.kieler.klighd.util.KlighdProperties; import java.util.ArrayList; import java.util.Collection; import java.util.EnumSet; @@ -35,9 +67,7 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; - import javax.inject.Inject; - import org.eclipse.elk.alg.layered.options.LayerConstraint; import org.eclipse.elk.alg.layered.options.LayeredOptions; import org.eclipse.elk.alg.layered.options.NodePlacementStrategy; @@ -62,9 +92,9 @@ import org.eclipse.xtext.xbase.lib.ListExtensions; import org.eclipse.xtext.xbase.lib.Pair; import org.eclipse.xtext.xbase.lib.StringExtensions; -import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.InferredType; +import org.lflang.ast.ASTUtils; import org.lflang.ast.FormattingUtils; import org.lflang.diagram.synthesis.action.CollapseAllReactorsAction; import org.lflang.diagram.synthesis.action.ExpandAllReactorsAction; @@ -99,40 +129,6 @@ import org.lflang.lf.StateVar; import org.lflang.util.FileUtil; -import com.google.common.collect.HashBasedTable; -import com.google.common.collect.HashMultimap; -import com.google.common.collect.Iterables; -import com.google.common.collect.Multimap; -import com.google.common.collect.Table; - -import de.cau.cs.kieler.klighd.DisplayedActionData; -import de.cau.cs.kieler.klighd.SynthesisOption; -import de.cau.cs.kieler.klighd.kgraph.KEdge; -import de.cau.cs.kieler.klighd.kgraph.KLabel; -import de.cau.cs.kieler.klighd.kgraph.KNode; -import de.cau.cs.kieler.klighd.kgraph.KPort; -import de.cau.cs.kieler.klighd.krendering.Colors; -import de.cau.cs.kieler.klighd.krendering.HorizontalAlignment; -import de.cau.cs.kieler.klighd.krendering.KContainerRendering; -import de.cau.cs.kieler.klighd.krendering.KPolyline; -import de.cau.cs.kieler.klighd.krendering.KRectangle; -import de.cau.cs.kieler.klighd.krendering.KRendering; -import de.cau.cs.kieler.klighd.krendering.KRoundedRectangle; -import de.cau.cs.kieler.klighd.krendering.KStyle; -import de.cau.cs.kieler.klighd.krendering.KText; -import de.cau.cs.kieler.klighd.krendering.LineCap; -import de.cau.cs.kieler.klighd.krendering.LineStyle; -import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; -import de.cau.cs.kieler.klighd.krendering.extensions.KContainerRenderingExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KEdgeExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KLabelExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KNodeExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KPolylineExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KPortExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KRenderingExtensions; -import de.cau.cs.kieler.klighd.syntheses.AbstractDiagramSynthesis; -import de.cau.cs.kieler.klighd.util.KlighdProperties; - /** * Diagram synthesis for Lingua Franca programs. * @@ -140,1270 +136,1537 @@ */ @ViewSynthesisShared public class LinguaFrancaSynthesis extends AbstractDiagramSynthesis { - @Inject @Extension private KNodeExtensions _kNodeExtensions; - @Inject @Extension private KEdgeExtensions _kEdgeExtensions; - @Inject @Extension private KPortExtensions _kPortExtensions; - @Inject @Extension private KLabelExtensions _kLabelExtensions; - @Inject @Extension private KRenderingExtensions _kRenderingExtensions; - @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; - @Inject @Extension private KPolylineExtensions _kPolylineExtensions; - @Inject @Extension private LinguaFrancaStyleExtensions _linguaFrancaStyleExtensions; - @Inject @Extension private LinguaFrancaShapeExtensions _linguaFrancaShapeExtensions; - @Inject @Extension private UtilityExtensions _utilityExtensions; - @Inject @Extension private CycleVisualization _cycleVisualization; - @Inject @Extension private InterfaceDependenciesVisualization _interfaceDependenciesVisualization; - @Inject @Extension private FilterCycleAction _filterCycleAction; - @Inject @Extension private ReactorIcons _reactorIcons; - @Inject @Extension private ModeDiagrams _modeDiagrams; - @Inject @Extension private LayoutPostProcessing _layoutPostProcessing; - - // ------------------------------------------------------------------------- - - public static final String ID = "org.lflang.diagram.synthesis.LinguaFrancaSynthesis"; - - // -- INTERNAL -- - public static final Property REACTOR_RECURSIVE_INSTANTIATION = new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.recursive.instantiation", false); - public static final Property REACTOR_HAS_BANK_PORT_OFFSET = new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.bank.offset", false); - public static final Property REACTOR_INPUT = new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.input", false); - public static final Property REACTOR_OUTPUT = new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.output", false); - public static final Property REACTION_SPECIAL_TRIGGER = new Property<>("org.lflang.linguafranca.diagram.synthesis.reaction.special.trigger", false); - - // -- STYLE -- - public static final List ALTERNATIVE_DASH_PATTERN = List.of(3.0f); - - // -- TEXT -- - public static final String TEXT_ERROR_RECURSIVE = "Recursive reactor instantiation!"; - public static final String TEXT_ERROR_CONTAINS_RECURSION = "Reactor contains recursive instantiation!"; - public static final String TEXT_ERROR_CONTAINS_CYCLE = "Reactor contains cyclic dependencies!"; - public static final String TEXT_ERROR_CYCLE_DETECTION = "Dependency cycle detection failed.\nCould not detect dependency cycles due to unexpected graph structure."; - public static final String TEXT_ERROR_CYCLE_BTN_SHOW = "Show Cycle"; - public static final String TEXT_ERROR_CYCLE_BTN_FILTER = "Filter Cycle"; - public static final String TEXT_ERROR_CYCLE_BTN_UNFILTER = "Remove Cycle Filter"; - public static final String TEXT_NO_MAIN_REACTOR = "No Main Reactor"; - public static final String TEXT_REACTOR_NULL = "Reactor is null"; - public static final String TEXT_HIDE_ACTION = "[Hide]"; - public static final String TEXT_SHOW_ACTION = "[Details]"; - - // ------------------------------------------------------------------------- - - /** Synthesis category */ - public static final SynthesisOption APPEARANCE = SynthesisOption.createCategory("Appearance", true); - public static final SynthesisOption EXPERIMENTAL = SynthesisOption.createCategory("Experimental", true); - public static final SynthesisOption LAYOUT = SynthesisOption.createCategory("Layout", false).setCategory(LinguaFrancaSynthesis.APPEARANCE); - - /** Synthesis options */ - public static final SynthesisOption SHOW_ALL_REACTORS = SynthesisOption.createCheckOption("All Reactors", false); - public static final SynthesisOption CYCLE_DETECTION = SynthesisOption.createCheckOption("Dependency Cycle Detection", true); - - public static final SynthesisOption SHOW_USER_LABELS = SynthesisOption.createCheckOption("User Labels (@label in JavaDoc)", true).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_HYPERLINKS = SynthesisOption.createCheckOption("Expand/Collapse Hyperlinks", false).setCategory(APPEARANCE); - public static final SynthesisOption REACTIONS_USE_HYPEREDGES = SynthesisOption.createCheckOption("Bundled Dependencies", false).setCategory(APPEARANCE); - public static final SynthesisOption USE_ALTERNATIVE_DASH_PATTERN = SynthesisOption.createCheckOption("Alternative Dependency Line Style", false).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_PORT_NAMES = SynthesisOption.createCheckOption("Port names", true).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_MULTIPORT_WIDTH = SynthesisOption.createCheckOption("Multiport Widths", false).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_REACTION_CODE = SynthesisOption.createCheckOption("Reaction Code", false).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_REACTION_LEVEL = SynthesisOption.createCheckOption("Reaction Level", false).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_REACTION_ORDER_EDGES = SynthesisOption.createCheckOption("Reaction Order Edges", false).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_REACTOR_HOST = SynthesisOption.createCheckOption("Reactor Host Addresses", true).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_INSTANCE_NAMES = SynthesisOption.createCheckOption("Reactor Instance Names", false).setCategory(APPEARANCE); - public static final SynthesisOption REACTOR_PARAMETER_MODE = SynthesisOption.createChoiceOption("Reactor Parameters", ((List)Conversions.doWrapArray(ReactorParameterDisplayModes.values())), ReactorParameterDisplayModes.NONE).setCategory(APPEARANCE); - public static final SynthesisOption SHOW_STATE_VARIABLES = SynthesisOption.createCheckOption("Reactor State Variables", false).setCategory(APPEARANCE); - public static final SynthesisOption REACTOR_BODY_TABLE_COLS = SynthesisOption.createRangeOption("Reactor Parameter/Variable Columns", 1, 10, 1).setCategory(APPEARANCE); - - public static final SynthesisOption SPACING = SynthesisOption.createRangeOption("Spacing (%)", 0, 150, 5, 75).setCategory(LAYOUT); - - /** Synthesis actions */ - public static final DisplayedActionData COLLAPSE_ALL = DisplayedActionData.create(CollapseAllReactorsAction.ID, "Hide all Details"); - public static final DisplayedActionData EXPAND_ALL = DisplayedActionData.create(ExpandAllReactorsAction.ID, "Show all Details"); - - @Override - public List getDisplayedSynthesisOptions() { - return List.of( - SHOW_ALL_REACTORS, - MemorizingExpandCollapseAction.MEMORIZE_EXPANSION_STATES, - CYCLE_DETECTION, - APPEARANCE, - ModeDiagrams.MODES_CATEGORY, - ModeDiagrams.SHOW_TRANSITION_LABELS, - ModeDiagrams.INITIALLY_COLLAPSE_MODES, - SHOW_USER_LABELS, - SHOW_HYPERLINKS, - //LinguaFrancaSynthesisInterfaceDependencies.SHOW_INTERFACE_DEPENDENCIES, - REACTIONS_USE_HYPEREDGES, - USE_ALTERNATIVE_DASH_PATTERN, - SHOW_PORT_NAMES, - SHOW_MULTIPORT_WIDTH, - SHOW_REACTION_CODE, - SHOW_REACTION_LEVEL, - SHOW_REACTION_ORDER_EDGES, - SHOW_REACTOR_HOST, - SHOW_INSTANCE_NAMES, - REACTOR_PARAMETER_MODE, - SHOW_STATE_VARIABLES, - REACTOR_BODY_TABLE_COLS, - LAYOUT, - LayoutPostProcessing.MODEL_ORDER, - SPACING - ); - } - - @Override - public List getDisplayedActions() { - return List.of(COLLAPSE_ALL, EXPAND_ALL); - } - - // ------------------------------------------------------------------------- - - @Override - public KNode transform(final Model model) { - KNode rootNode = _kNodeExtensions.createNode(); - setLayoutOption(rootNode, CoreOptions.ALGORITHM, LayeredOptions.ALGORITHM_ID); - setLayoutOption(rootNode, CoreOptions.DIRECTION, Direction.RIGHT); - setLayoutOption(rootNode, CoreOptions.PADDING, new ElkPadding(0)); - - try { - // Find main - Reactor main = IterableExtensions.findFirst(model.getReactors(), _utilityExtensions::isMainOrFederated); - if (main != null) { - ReactorInstance reactorInstance = new ReactorInstance(main, new SynthesisErrorReporter()); - rootNode.getChildren().addAll(createReactorNode(reactorInstance, true, null, null, new HashMap<>())); - } else if (!getBooleanValue(SHOW_ALL_REACTORS)) { - KNode messageNode = _kNodeExtensions.createNode(); - _linguaFrancaShapeExtensions.addErrorMessage(messageNode, TEXT_NO_MAIN_REACTOR, null); - rootNode.getChildren().add(messageNode); - } - - // Show all reactors - if (main == null || getBooleanValue(SHOW_ALL_REACTORS)) { - List reactorNodes = new ArrayList<>(); - for (Reactor reactor : model.getReactors()) { - if (reactor == main) continue; - ReactorInstance reactorInstance = new ReactorInstance(reactor, new SynthesisErrorReporter()); - reactorNodes.addAll(createReactorNode(reactorInstance, main == null, - HashBasedTable.create(), - HashBasedTable.create(), - new HashMap<>())); - } - if (!reactorNodes.isEmpty()) { - // To allow ordering, we need box layout but we also need layered layout for ports thus wrap all node - reactorNodes.add(0, IterableExtensions.head(rootNode.getChildren())); - - int index = 0; - for (KNode node : reactorNodes) { - // Element could be null if there is no main reactor and Show All Reactors is checked. - if (node == null) continue; - if (node.getProperty(CoreOptions.COMMENT_BOX)) continue; - KNode child = _kNodeExtensions.createNode(); - child.getChildren().add(node); - // Add comment nodes - for (KEdge edge : node.getIncomingEdges()) { - if (!edge.getSource().getProperty(CoreOptions.COMMENT_BOX)) continue; - child.getChildren().add(edge.getSource()); - } - _kRenderingExtensions.addInvisibleContainerRendering(child); - setLayoutOption(child, CoreOptions.ALGORITHM, LayeredOptions.ALGORITHM_ID); - setLayoutOption(child, CoreOptions.DIRECTION, Direction.RIGHT); - setLayoutOption(child, CoreOptions.PADDING, new ElkPadding(0)); - // Legacy ordering option. - setLayoutOption(child, CoreOptions.PRIORITY, reactorNodes.size() - index); // Order! - rootNode.getChildren().add(child); - index++; - } - - setLayoutOption(rootNode, CoreOptions.ALGORITHM, BoxLayouterOptions.ALGORITHM_ID); - setLayoutOption(rootNode, CoreOptions.SPACING_NODE_NODE, 25.0); - } + @Inject @Extension private KNodeExtensions _kNodeExtensions; + @Inject @Extension private KEdgeExtensions _kEdgeExtensions; + @Inject @Extension private KPortExtensions _kPortExtensions; + @Inject @Extension private KLabelExtensions _kLabelExtensions; + @Inject @Extension private KRenderingExtensions _kRenderingExtensions; + @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; + @Inject @Extension private KPolylineExtensions _kPolylineExtensions; + @Inject @Extension private LinguaFrancaStyleExtensions _linguaFrancaStyleExtensions; + @Inject @Extension private LinguaFrancaShapeExtensions _linguaFrancaShapeExtensions; + @Inject @Extension private UtilityExtensions _utilityExtensions; + @Inject @Extension private CycleVisualization _cycleVisualization; + @Inject @Extension private InterfaceDependenciesVisualization _interfaceDependenciesVisualization; + @Inject @Extension private FilterCycleAction _filterCycleAction; + @Inject @Extension private ReactorIcons _reactorIcons; + @Inject @Extension private ModeDiagrams _modeDiagrams; + @Inject @Extension private LayoutPostProcessing _layoutPostProcessing; + + // ------------------------------------------------------------------------- + + public static final String ID = "org.lflang.diagram.synthesis.LinguaFrancaSynthesis"; + + // -- INTERNAL -- + public static final Property REACTOR_RECURSIVE_INSTANTIATION = + new Property<>( + "org.lflang.linguafranca.diagram.synthesis.reactor.recursive.instantiation", false); + public static final Property REACTOR_HAS_BANK_PORT_OFFSET = + new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.bank.offset", false); + public static final Property REACTOR_INPUT = + new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.input", false); + public static final Property REACTOR_OUTPUT = + new Property<>("org.lflang.linguafranca.diagram.synthesis.reactor.output", false); + public static final Property REACTION_SPECIAL_TRIGGER = + new Property<>("org.lflang.linguafranca.diagram.synthesis.reaction.special.trigger", false); + + // -- STYLE -- + public static final List ALTERNATIVE_DASH_PATTERN = List.of(3.0f); + + // -- TEXT -- + public static final String TEXT_ERROR_RECURSIVE = "Recursive reactor instantiation!"; + public static final String TEXT_ERROR_CONTAINS_RECURSION = + "Reactor contains recursive instantiation!"; + public static final String TEXT_ERROR_CONTAINS_CYCLE = "Reactor contains cyclic dependencies!"; + public static final String TEXT_ERROR_CYCLE_DETECTION = + "Dependency cycle detection failed.\n" + + "Could not detect dependency cycles due to unexpected graph structure."; + public static final String TEXT_ERROR_CYCLE_BTN_SHOW = "Show Cycle"; + public static final String TEXT_ERROR_CYCLE_BTN_FILTER = "Filter Cycle"; + public static final String TEXT_ERROR_CYCLE_BTN_UNFILTER = "Remove Cycle Filter"; + public static final String TEXT_NO_MAIN_REACTOR = "No Main Reactor"; + public static final String TEXT_REACTOR_NULL = "Reactor is null"; + public static final String TEXT_HIDE_ACTION = "[Hide]"; + public static final String TEXT_SHOW_ACTION = "[Details]"; + + // ------------------------------------------------------------------------- + + /** Synthesis category */ + public static final SynthesisOption APPEARANCE = + SynthesisOption.createCategory("Appearance", true); + + public static final SynthesisOption EXPERIMENTAL = + SynthesisOption.createCategory("Experimental", true); + public static final SynthesisOption LAYOUT = + SynthesisOption.createCategory("Layout", false).setCategory(LinguaFrancaSynthesis.APPEARANCE); + + /** Synthesis options */ + public static final SynthesisOption SHOW_ALL_REACTORS = + SynthesisOption.createCheckOption("All Reactors", false); + + public static final SynthesisOption CYCLE_DETECTION = + SynthesisOption.createCheckOption("Dependency Cycle Detection", true); + + public static final SynthesisOption SHOW_USER_LABELS = + SynthesisOption.createCheckOption("User Labels (@label in JavaDoc)", true) + .setCategory(APPEARANCE); + public static final SynthesisOption SHOW_HYPERLINKS = + SynthesisOption.createCheckOption("Expand/Collapse Hyperlinks", false) + .setCategory(APPEARANCE); + public static final SynthesisOption REACTIONS_USE_HYPEREDGES = + SynthesisOption.createCheckOption("Bundled Dependencies", false).setCategory(APPEARANCE); + public static final SynthesisOption USE_ALTERNATIVE_DASH_PATTERN = + SynthesisOption.createCheckOption("Alternative Dependency Line Style", false) + .setCategory(APPEARANCE); + public static final SynthesisOption SHOW_PORT_NAMES = + SynthesisOption.createCheckOption("Port names", true).setCategory(APPEARANCE); + public static final SynthesisOption SHOW_MULTIPORT_WIDTH = + SynthesisOption.createCheckOption("Multiport Widths", false).setCategory(APPEARANCE); + public static final SynthesisOption SHOW_REACTION_CODE = + SynthesisOption.createCheckOption("Reaction Code", false).setCategory(APPEARANCE); + public static final SynthesisOption SHOW_REACTION_LEVEL = + SynthesisOption.createCheckOption("Reaction Level", false).setCategory(APPEARANCE); + public static final SynthesisOption SHOW_REACTION_ORDER_EDGES = + SynthesisOption.createCheckOption("Reaction Order Edges", false).setCategory(APPEARANCE); + public static final SynthesisOption SHOW_REACTOR_HOST = + SynthesisOption.createCheckOption("Reactor Host Addresses", true).setCategory(APPEARANCE); + public static final SynthesisOption SHOW_INSTANCE_NAMES = + SynthesisOption.createCheckOption("Reactor Instance Names", false).setCategory(APPEARANCE); + public static final SynthesisOption REACTOR_PARAMETER_MODE = + SynthesisOption.createChoiceOption( + "Reactor Parameters", + ((List) Conversions.doWrapArray(ReactorParameterDisplayModes.values())), + ReactorParameterDisplayModes.NONE) + .setCategory(APPEARANCE); + public static final SynthesisOption SHOW_STATE_VARIABLES = + SynthesisOption.createCheckOption("Reactor State Variables", false).setCategory(APPEARANCE); + public static final SynthesisOption REACTOR_BODY_TABLE_COLS = + SynthesisOption.createRangeOption("Reactor Parameter/Variable Columns", 1, 10, 1) + .setCategory(APPEARANCE); + + public static final SynthesisOption SPACING = + SynthesisOption.createRangeOption("Spacing (%)", 0, 150, 5, 75).setCategory(LAYOUT); + + /** Synthesis actions */ + public static final DisplayedActionData COLLAPSE_ALL = + DisplayedActionData.create(CollapseAllReactorsAction.ID, "Hide all Details"); + + public static final DisplayedActionData EXPAND_ALL = + DisplayedActionData.create(ExpandAllReactorsAction.ID, "Show all Details"); + + @Override + public List getDisplayedSynthesisOptions() { + return List.of( + SHOW_ALL_REACTORS, + MemorizingExpandCollapseAction.MEMORIZE_EXPANSION_STATES, + CYCLE_DETECTION, + APPEARANCE, + ModeDiagrams.MODES_CATEGORY, + ModeDiagrams.SHOW_TRANSITION_LABELS, + ModeDiagrams.INITIALLY_COLLAPSE_MODES, + SHOW_USER_LABELS, + SHOW_HYPERLINKS, + // LinguaFrancaSynthesisInterfaceDependencies.SHOW_INTERFACE_DEPENDENCIES, + REACTIONS_USE_HYPEREDGES, + USE_ALTERNATIVE_DASH_PATTERN, + SHOW_PORT_NAMES, + SHOW_MULTIPORT_WIDTH, + SHOW_REACTION_CODE, + SHOW_REACTION_LEVEL, + SHOW_REACTION_ORDER_EDGES, + SHOW_REACTOR_HOST, + SHOW_INSTANCE_NAMES, + REACTOR_PARAMETER_MODE, + SHOW_STATE_VARIABLES, + REACTOR_BODY_TABLE_COLS, + LAYOUT, + LayoutPostProcessing.MODEL_ORDER, + SPACING); + } + + @Override + public List getDisplayedActions() { + return List.of(COLLAPSE_ALL, EXPAND_ALL); + } + + // ------------------------------------------------------------------------- + + @Override + public KNode transform(final Model model) { + KNode rootNode = _kNodeExtensions.createNode(); + setLayoutOption(rootNode, CoreOptions.ALGORITHM, LayeredOptions.ALGORITHM_ID); + setLayoutOption(rootNode, CoreOptions.DIRECTION, Direction.RIGHT); + setLayoutOption(rootNode, CoreOptions.PADDING, new ElkPadding(0)); + + try { + // Find main + Reactor main = + IterableExtensions.findFirst(model.getReactors(), _utilityExtensions::isMainOrFederated); + if (main != null) { + ReactorInstance reactorInstance = new ReactorInstance(main, new SynthesisErrorReporter()); + rootNode + .getChildren() + .addAll(createReactorNode(reactorInstance, true, null, null, new HashMap<>())); + } else if (!getBooleanValue(SHOW_ALL_REACTORS)) { + KNode messageNode = _kNodeExtensions.createNode(); + _linguaFrancaShapeExtensions.addErrorMessage(messageNode, TEXT_NO_MAIN_REACTOR, null); + rootNode.getChildren().add(messageNode); + } + + // Show all reactors + if (main == null || getBooleanValue(SHOW_ALL_REACTORS)) { + List reactorNodes = new ArrayList<>(); + for (Reactor reactor : model.getReactors()) { + if (reactor == main) continue; + ReactorInstance reactorInstance = + new ReactorInstance(reactor, new SynthesisErrorReporter()); + reactorNodes.addAll( + createReactorNode( + reactorInstance, + main == null, + HashBasedTable.create(), + HashBasedTable.create(), + new HashMap<>())); + } + if (!reactorNodes.isEmpty()) { + // To allow ordering, we need box layout but we also need layered layout for ports thus + // wrap all node + reactorNodes.add(0, IterableExtensions.head(rootNode.getChildren())); + + int index = 0; + for (KNode node : reactorNodes) { + // Element could be null if there is no main reactor and Show All Reactors is checked. + if (node == null) continue; + if (node.getProperty(CoreOptions.COMMENT_BOX)) continue; + KNode child = _kNodeExtensions.createNode(); + child.getChildren().add(node); + // Add comment nodes + for (KEdge edge : node.getIncomingEdges()) { + if (!edge.getSource().getProperty(CoreOptions.COMMENT_BOX)) continue; + child.getChildren().add(edge.getSource()); } - } catch (Exception e) { - e.printStackTrace(); + _kRenderingExtensions.addInvisibleContainerRendering(child); + setLayoutOption(child, CoreOptions.ALGORITHM, LayeredOptions.ALGORITHM_ID); + setLayoutOption(child, CoreOptions.DIRECTION, Direction.RIGHT); + setLayoutOption(child, CoreOptions.PADDING, new ElkPadding(0)); + // Legacy ordering option. + setLayoutOption(child, CoreOptions.PRIORITY, reactorNodes.size() - index); // Order! + rootNode.getChildren().add(child); + index++; + } - KNode messageNode = _kNodeExtensions.createNode(); - _linguaFrancaShapeExtensions.addErrorMessage(messageNode, "Error in Diagram Synthesis", - e.getClass().getSimpleName() + " occurred. Could not create diagram."); - rootNode.getChildren().add(messageNode); + setLayoutOption(rootNode, CoreOptions.ALGORITHM, BoxLayouterOptions.ALGORITHM_ID); + setLayoutOption(rootNode, CoreOptions.SPACING_NODE_NODE, 25.0); } + } + } catch (Exception e) { + e.printStackTrace(); + + KNode messageNode = _kNodeExtensions.createNode(); + _linguaFrancaShapeExtensions.addErrorMessage( + messageNode, + "Error in Diagram Synthesis", + e.getClass().getSimpleName() + " occurred. Could not create diagram."); + rootNode.getChildren().add(messageNode); + } - return rootNode; + return rootNode; + } + + private Collection createReactorNode( + ReactorInstance reactorInstance, + boolean expandDefault, + Table inputPortsReg, + Table outputPortsReg, + Map allReactorNodes) { + Reactor reactor = reactorInstance.reactorDefinition; + KNode node = _kNodeExtensions.createNode(); + allReactorNodes.put(reactorInstance, node); + associateWith(node, reactor); + _utilityExtensions.setID(node, reactorInstance.uniqueID()); + // save to distinguish nodes associated with the same reactor + NamedInstanceUtil.linkInstance(node, reactorInstance); + + List nodes = new ArrayList<>(); + nodes.add(node); + String label = createReactorLabel(reactorInstance); + + if (reactorInstance.recursive) { + // Mark this node + node.setProperty(REACTOR_RECURSIVE_INSTANTIATION, true); + // Mark root + allReactorNodes + .get(reactorInstance.root()) + .setProperty(REACTOR_RECURSIVE_INSTANTIATION, true); } - private Collection createReactorNode( - ReactorInstance reactorInstance, - boolean expandDefault, - Table inputPortsReg, - Table outputPortsReg, - Map allReactorNodes - ) { - Reactor reactor = reactorInstance.reactorDefinition; - KNode node = _kNodeExtensions.createNode(); - allReactorNodes.put(reactorInstance, node); - associateWith(node, reactor); - _utilityExtensions.setID(node, reactorInstance.uniqueID()); - // save to distinguish nodes associated with the same reactor - NamedInstanceUtil.linkInstance(node, reactorInstance); - - List nodes = new ArrayList<>(); - nodes.add(node); - String label = createReactorLabel(reactorInstance); - - if (reactorInstance.recursive) { - // Mark this node - node.setProperty(REACTOR_RECURSIVE_INSTANTIATION, true); - // Mark root - allReactorNodes.get(reactorInstance.root()).setProperty(REACTOR_RECURSIVE_INSTANTIATION, true); + if (reactor == null) { + _linguaFrancaShapeExtensions.addErrorMessage(node, TEXT_REACTOR_NULL, null); + } else if (reactorInstance.isMainOrFederated()) { + KRoundedRectangle figure = + _linguaFrancaShapeExtensions.addMainReactorFigure(node, reactorInstance, label); + + if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TABLE + && !reactorInstance.parameters.isEmpty()) { + KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(figure); + _kRenderingExtensions.setInvisible(rectangle, true); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 6, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 6, + 0, + _kRenderingExtensions.BOTTOM, + 4, + 0); + _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); + addParameterList(rectangle, reactorInstance.parameters); + } + + if (getBooleanValue(SHOW_STATE_VARIABLES)) { + var variables = + ASTUtils.collectElements( + reactor, LfPackage.eINSTANCE.getReactor_StateVars(), true, false); + if (!variables.isEmpty()) { + KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(figure); + _kRenderingExtensions.setInvisible(rectangle, true); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 6, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 6, + 0, + _kRenderingExtensions.BOTTOM, + 4, + 0); + _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); + addStateVariableList(rectangle, variables); } - - if (reactor == null) { - _linguaFrancaShapeExtensions.addErrorMessage(node, TEXT_REACTOR_NULL, null); - } else if (reactorInstance.isMainOrFederated()) { - KRoundedRectangle figure = _linguaFrancaShapeExtensions.addMainReactorFigure(node, reactorInstance, label); - - if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TABLE - && !reactorInstance.parameters.isEmpty() - ) { - KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(figure); - _kRenderingExtensions.setInvisible(rectangle, true); - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, - _kRenderingExtensions.BOTTOM, 4, 0); - _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); - addParameterList(rectangle, reactorInstance.parameters); - } - - if (getBooleanValue(SHOW_STATE_VARIABLES)) { - var variables = ASTUtils.collectElements(reactor, LfPackage.eINSTANCE.getReactor_StateVars(), true, false); - if (!variables.isEmpty()) { - KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(figure); - _kRenderingExtensions.setInvisible(rectangle, true); - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, - _kRenderingExtensions.BOTTOM, 4, 0); - _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); - addStateVariableList(rectangle, variables); - } - } - - if (reactorInstance.recursive) { - nodes.add(addErrorComment(node, TEXT_ERROR_RECURSIVE)); - _linguaFrancaStyleExtensions.errorStyle(figure); - } else { - _kContainerRenderingExtensions.addChildArea(figure); - node.getChildren().addAll(transformReactorNetwork(reactorInstance, - new HashMap<>(), - new HashMap<>(), - allReactorNodes)); - } - Iterables.addAll(nodes, createUserComments(reactor, node)); - configureReactorNodeLayout(node, true); - _layoutPostProcessing.configureMainReactor(node); + } + + if (reactorInstance.recursive) { + nodes.add(addErrorComment(node, TEXT_ERROR_RECURSIVE)); + _linguaFrancaStyleExtensions.errorStyle(figure); + } else { + _kContainerRenderingExtensions.addChildArea(figure); + node.getChildren() + .addAll( + transformReactorNetwork( + reactorInstance, new HashMap<>(), new HashMap<>(), allReactorNodes)); + } + Iterables.addAll(nodes, createUserComments(reactor, node)); + configureReactorNodeLayout(node, true); + _layoutPostProcessing.configureMainReactor(node); + } else { + ReactorInstance instance = reactorInstance; + + // Expanded Rectangle + ReactorFigureComponents comps = + _linguaFrancaShapeExtensions.addReactorFigure(node, reactorInstance, label); + comps.getOuter().setProperty(KlighdProperties.EXPANDED_RENDERING, true); + for (KRendering figure : comps.getFigures()) { + associateWith(figure, reactor); + _kRenderingExtensions.addDoubleClickAction(figure, MemorizingExpandCollapseAction.ID); + } + _reactorIcons.handleIcon(comps.getReactor(), reactor, false); + + if (getBooleanValue(SHOW_HYPERLINKS)) { + // Collapse button + KText button = + _linguaFrancaShapeExtensions.addTextButton(comps.getReactor(), TEXT_HIDE_ACTION); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(button), + _kRenderingExtensions.LEFT, + 8, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 8, + 0, + _kRenderingExtensions.BOTTOM, + 0, + 0); + _kRenderingExtensions.addSingleClickAction(button, MemorizingExpandCollapseAction.ID); + _kRenderingExtensions.addDoubleClickAction(button, MemorizingExpandCollapseAction.ID); + } + + if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TABLE + && !instance.parameters.isEmpty()) { + KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(comps.getReactor()); + _kRenderingExtensions.setInvisible(rectangle, true); + if (!getBooleanValue(SHOW_HYPERLINKS)) { + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 6, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 6, + 0, + _kRenderingExtensions.BOTTOM, + 4, + 0); } else { - ReactorInstance instance = reactorInstance; - - // Expanded Rectangle - ReactorFigureComponents comps = _linguaFrancaShapeExtensions.addReactorFigure(node, reactorInstance, label); - comps.getOuter().setProperty(KlighdProperties.EXPANDED_RENDERING, true); - for (KRendering figure : comps.getFigures()) { - associateWith(figure, reactor); - _kRenderingExtensions.addDoubleClickAction(figure, MemorizingExpandCollapseAction.ID); - } - _reactorIcons.handleIcon(comps.getReactor(), reactor, false); - - if (getBooleanValue(SHOW_HYPERLINKS)) { - // Collapse button - KText button = _linguaFrancaShapeExtensions.addTextButton(comps.getReactor(), TEXT_HIDE_ACTION); - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(button), - _kRenderingExtensions.LEFT, 8, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 8, 0, - _kRenderingExtensions.BOTTOM, 0, 0); - _kRenderingExtensions.addSingleClickAction(button, MemorizingExpandCollapseAction.ID); - _kRenderingExtensions.addDoubleClickAction(button, MemorizingExpandCollapseAction.ID); - } - - if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TABLE - && !instance.parameters.isEmpty()) { - KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(comps.getReactor()); - _kRenderingExtensions.setInvisible(rectangle, true); - if (!getBooleanValue(SHOW_HYPERLINKS)) { - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, - _kRenderingExtensions.BOTTOM, 4, 0); - } else { - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 4, 0), - _kRenderingExtensions.RIGHT, 6, 0, - _kRenderingExtensions.BOTTOM, 0, 0); - } - _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); - addParameterList(rectangle, instance.parameters); - } - - if (getBooleanValue(SHOW_STATE_VARIABLES)) { - var variables = ASTUtils.collectElements(reactor, LfPackage.eINSTANCE.getReactor_StateVars(), true, false); - if (!variables.isEmpty()) { - KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(comps.getReactor()); - _kRenderingExtensions.setInvisible(rectangle, true); - if (!getBooleanValue(SHOW_HYPERLINKS)) { - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, - _kRenderingExtensions.BOTTOM, 4, 0); - } else { - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 4, 0), - _kRenderingExtensions.RIGHT, 6, 0, - _kRenderingExtensions.BOTTOM, 0, 0); - } - _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); - addStateVariableList(rectangle, variables); - } - } - - if (instance.recursive) { - comps.getFigures().forEach(_linguaFrancaStyleExtensions::errorStyle); - } else { - _kContainerRenderingExtensions.addChildArea(comps.getReactor()); - } - - // Collapse Rectangle - comps = _linguaFrancaShapeExtensions.addReactorFigure(node, reactorInstance, label); - comps.getOuter().setProperty(KlighdProperties.COLLAPSED_RENDERING, true); - for (KRendering figure : comps.getFigures()) { - associateWith(figure, reactor); - if (_utilityExtensions.hasContent(instance) && !instance.recursive) { - _kRenderingExtensions.addDoubleClickAction(figure, MemorizingExpandCollapseAction.ID); - } - } - _reactorIcons.handleIcon(comps.getReactor(), reactor, true); - - if (getBooleanValue(SHOW_HYPERLINKS)) { - // Expand button - if (_utilityExtensions.hasContent(instance) && !instance.recursive) { - KText button = _linguaFrancaShapeExtensions.addTextButton(comps.getReactor(), TEXT_SHOW_ACTION); - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(button), - _kRenderingExtensions.LEFT, 8, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 8, 0, - _kRenderingExtensions.BOTTOM, 8, 0); - _kRenderingExtensions.addSingleClickAction(button, MemorizingExpandCollapseAction.ID); - _kRenderingExtensions.addDoubleClickAction(button, MemorizingExpandCollapseAction.ID); - } - } - - if (instance.recursive) { - comps.getFigures().forEach(_linguaFrancaStyleExtensions::errorStyle); - } - - - // Create ports - Map inputPorts = new HashMap<>(); - Map outputPorts = new HashMap<>(); - List inputs = instance.inputs; - if (LayoutPostProcessing.LEGACY.equals((String) getObjectValue(LayoutPostProcessing.MODEL_ORDER))) { - inputs = ListExtensions.reverseView(instance.inputs); - } - for (PortInstance input : inputs) { - inputPorts.put(input, addIOPort(node, input, true, input.isMultiport(), reactorInstance.isBank())); - } - for (PortInstance output : instance.outputs) { - outputPorts.put(output, addIOPort(node, output, false, output.isMultiport(), reactorInstance.isBank())); - } - // Mark ports - inputPorts.values().forEach(it -> it.setProperty(REACTOR_INPUT, true)); - outputPorts.values().forEach(it -> it.setProperty(REACTOR_OUTPUT, true)); - - // Add content - if (_utilityExtensions.hasContent(instance) && !instance.recursive) { - node.getChildren().addAll(transformReactorNetwork(instance, inputPorts, outputPorts, allReactorNodes)); - } - - // Pass port to given tables - if (!_utilityExtensions.isRoot(instance)) { - if (inputPortsReg != null) { - for (Map.Entry entry : inputPorts.entrySet()) { - inputPortsReg.put(instance, entry.getKey(), entry.getValue()); - } - } - if (outputPortsReg != null) { - for (Map.Entry entry : outputPorts.entrySet()) { - outputPortsReg.put(instance, entry.getKey(), entry.getValue()); - } - } - } - - if (instance.recursive) { - setLayoutOption(node, KlighdProperties.EXPAND, false); - nodes.add(addErrorComment(node, TEXT_ERROR_RECURSIVE)); - } else { - setLayoutOption(node, KlighdProperties.EXPAND, expandDefault); - - // Interface Dependencies - _interfaceDependenciesVisualization.addInterfaceDependencies(node, expandDefault); - } - - if (!_utilityExtensions.isRoot(instance)) { - // If all reactors are being shown, then only put the label on - // the reactor definition, not on its instances. Otherwise, - // add the annotation now. - if (!getBooleanValue(SHOW_ALL_REACTORS)) { - Iterables.addAll(nodes, createUserComments(reactor, node)); - } - } else { - Iterables.addAll(nodes, createUserComments(reactor, node)); - } - configureReactorNodeLayout(node, false); - _layoutPostProcessing.configureReactor(node); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 6, + 0, + _kRenderingExtensions.TOP, + 4, + 0), + _kRenderingExtensions.RIGHT, + 6, + 0, + _kRenderingExtensions.BOTTOM, + 0, + 0); } - - // Find and annotate cycles - if (getBooleanValue(CYCLE_DETECTION) && - _utilityExtensions.isRoot(reactorInstance)) { - KNode errNode = detectAndAnnotateCycles(node, reactorInstance, allReactorNodes); - if (errNode != null) { - nodes.add(errNode); - } + _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); + addParameterList(rectangle, instance.parameters); + } + + if (getBooleanValue(SHOW_STATE_VARIABLES)) { + var variables = + ASTUtils.collectElements( + reactor, LfPackage.eINSTANCE.getReactor_StateVars(), true, false); + if (!variables.isEmpty()) { + KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(comps.getReactor()); + _kRenderingExtensions.setInvisible(rectangle, true); + if (!getBooleanValue(SHOW_HYPERLINKS)) { + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 6, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 6, + 0, + _kRenderingExtensions.BOTTOM, + 4, + 0); + } else { + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 6, + 0, + _kRenderingExtensions.TOP, + 4, + 0), + _kRenderingExtensions.RIGHT, + 6, + 0, + _kRenderingExtensions.BOTTOM, + 0, + 0); + } + _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); + addStateVariableList(rectangle, variables); } - - return nodes; - } - - public KNode configureReactorNodeLayout(KNode node, boolean main) { - // Set layered algorithm - setLayoutOption(node, CoreOptions.ALGORITHM, LayeredOptions.ALGORITHM_ID); - // Left to right layout - setLayoutOption(node, CoreOptions.DIRECTION, Direction.RIGHT); - // Center free floating children - setLayoutOption(node, CoreOptions.CONTENT_ALIGNMENT, ContentAlignment.centerCenter()); - - // Balanced placement with straight long edges. - setLayoutOption(node, LayeredOptions.NODE_PLACEMENT_STRATEGY, NodePlacementStrategy.NETWORK_SIMPLEX); - // Do not shrink nodes below content - setLayoutOption(node, CoreOptions.NODE_SIZE_CONSTRAINTS, EnumSet.of(SizeConstraint.MINIMUM_SIZE, SizeConstraint.PORTS)); - - // Allows to freely shuffle ports on each side - setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); - // Adjust port label spacing to be closer to edge but not overlap with port figure - // TODO: Add PortLabelPlacement.NEXT_TO_PORT_IF_POSSIBLE back into the configuration, as soon as ELK provides a fix for LF issue #1273 - setLayoutOption(node, CoreOptions.PORT_LABELS_PLACEMENT, EnumSet.of(PortLabelPlacement.ALWAYS_OTHER_SAME_SIDE, PortLabelPlacement.OUTSIDE)); - setLayoutOption(node, CoreOptions.SPACING_LABEL_PORT_HORIZONTAL, 2.0); - setLayoutOption(node, CoreOptions.SPACING_LABEL_PORT_VERTICAL, -3.0); - - // Configure spacing - if (!getBooleanValue(SHOW_HYPERLINKS)) { // Hyperlink version is more relaxed in terms of space - var factor = (double) getIntValue(SPACING) / 100; - - setLayoutOption(node, LayeredOptions.SPACING_COMPONENT_COMPONENT, LayeredOptions.SPACING_COMPONENT_COMPONENT.getDefault() * factor); - - setLayoutOption(node, LayeredOptions.SPACING_NODE_NODE, LayeredOptions.SPACING_NODE_NODE.getDefault() * factor); - setLayoutOption(node, LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS, LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS.getDefault() * factor); - - setLayoutOption(node, LayeredOptions.SPACING_PORT_PORT, LayeredOptions.SPACING_PORT_PORT.getDefault() * factor); - - setLayoutOption(node, LayeredOptions.SPACING_EDGE_NODE, LayeredOptions.SPACING_EDGE_NODE.getDefault() * factor); - setLayoutOption(node, LayeredOptions.SPACING_EDGE_NODE_BETWEEN_LAYERS, LayeredOptions.SPACING_EDGE_NODE_BETWEEN_LAYERS.getDefault() * factor); - setLayoutOption(node, LayeredOptions.SPACING_EDGE_EDGE, LayeredOptions.SPACING_EDGE_EDGE.getDefault() * factor); - setLayoutOption(node, LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS, LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS.getDefault() * factor); - setLayoutOption(node, LayeredOptions.SPACING_EDGE_EDGE, LayeredOptions.SPACING_EDGE_EDGE.getDefault() * factor); - setLayoutOption(node, LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS, LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS.getDefault() * factor); - setLayoutOption(node, LayeredOptions.SPACING_EDGE_LABEL, LayeredOptions.SPACING_EDGE_LABEL.getDefault() * factor); - - // Padding for sub graph - if (main) { // Special handing for main reactors - setLayoutOption(node, CoreOptions.PADDING, new ElkPadding(-1, 6, 6, 6)); - } else { - setLayoutOption(node, CoreOptions.PADDING, new ElkPadding(2, 6, 6, 6)); - } + } + + if (instance.recursive) { + comps.getFigures().forEach(_linguaFrancaStyleExtensions::errorStyle); + } else { + _kContainerRenderingExtensions.addChildArea(comps.getReactor()); + } + + // Collapse Rectangle + comps = _linguaFrancaShapeExtensions.addReactorFigure(node, reactorInstance, label); + comps.getOuter().setProperty(KlighdProperties.COLLAPSED_RENDERING, true); + for (KRendering figure : comps.getFigures()) { + associateWith(figure, reactor); + if (_utilityExtensions.hasContent(instance) && !instance.recursive) { + _kRenderingExtensions.addDoubleClickAction(figure, MemorizingExpandCollapseAction.ID); } - - return node; - } - - private KNode detectAndAnnotateCycles(KNode node, ReactorInstance reactorInstance, Map allReactorNodes) { - if (node.getProperty(REACTOR_RECURSIVE_INSTANTIATION)) { - _filterCycleAction.resetCycleFiltering(node); - return addErrorComment(node, TEXT_ERROR_CONTAINS_RECURSION); - } else { // only detect dependency cycles if not recursive - try { - boolean hasCycle = _cycleVisualization.detectAndHighlightCycles(reactorInstance, - allReactorNodes, it -> { - if (it instanceof KNode) { - List renderings = IterableExtensions.toList( - Iterables.filter(((KNode) it).getData(), KRendering.class)); - if (renderings.size() == 1) { - _linguaFrancaStyleExtensions.errorStyle(IterableExtensions.head(renderings)); - } else { - IterableExtensions.filter(renderings, rendering -> { - return rendering.getProperty(KlighdProperties.COLLAPSED_RENDERING); - }).forEach(_linguaFrancaStyleExtensions::errorStyle); - } - } else if (it instanceof KEdge) { - Iterables.filter(((KEdge) it).getData(), - KRendering.class).forEach(_linguaFrancaStyleExtensions::errorStyle); - // TODO initiallyHide does not work with incremental (https://github.com/kieler/KLighD/issues/37) - // cycleEgde.initiallyShow() // Show hidden order dependencies - _kRenderingExtensions.setInvisible(_kRenderingExtensions.getKRendering(it), false); - } else if (it instanceof KPort) { - Iterables.filter(((KPort) it).getData(), - KRendering.class).forEach(_linguaFrancaStyleExtensions::errorStyle); - //it.reverseTrianglePort() - } - }); - - if (hasCycle) { - KNode err = addErrorComment(node, TEXT_ERROR_CONTAINS_CYCLE); - - // Add to existing figure - KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(_kRenderingExtensions.getKContainerRendering(err)); - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 3, 0, - _kRenderingExtensions.TOP, (-1), 0), - _kRenderingExtensions.RIGHT, 3, 0, - _kRenderingExtensions.BOTTOM, 3, 0); - _linguaFrancaStyleExtensions.noSelectionStyle(rectangle); - _kRenderingExtensions.setInvisible(rectangle, true); - _kContainerRenderingExtensions.setGridPlacement(rectangle, 2); - - KRectangle subrectangle = _kContainerRenderingExtensions.addRectangle(rectangle); - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(subrectangle), - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 2, 0, - _kRenderingExtensions.BOTTOM, 0, 0); - _linguaFrancaStyleExtensions.noSelectionStyle(subrectangle); - _kRenderingExtensions.addSingleClickAction(subrectangle, ShowCycleAction.ID); - - KText subrectangleText = _kContainerRenderingExtensions.addText(subrectangle, TEXT_ERROR_CYCLE_BTN_SHOW); - // Copy text style - List styles = ListExtensions.map( - IterableExtensions.head( - _kRenderingExtensions.getKContainerRendering(err).getChildren()).getStyles(), - EcoreUtil::copy); - subrectangleText.getStyles().addAll(styles); - _kRenderingExtensions.setFontSize(subrectangleText, 5); - _kRenderingExtensions.setSurroundingSpace(subrectangleText, 1, 0); - _linguaFrancaStyleExtensions.noSelectionStyle(subrectangleText); - _kRenderingExtensions.addSingleClickAction(subrectangleText, ShowCycleAction.ID); - - subrectangle = _kContainerRenderingExtensions.addRectangle(rectangle); - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(subrectangle), - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 0, 0, - _kRenderingExtensions.BOTTOM, 0, 0); - _linguaFrancaStyleExtensions.noSelectionStyle(subrectangle); - _kRenderingExtensions.addSingleClickAction(subrectangle, FilterCycleAction.ID); - - subrectangleText = _kContainerRenderingExtensions.addText(subrectangle, - _filterCycleAction.isCycleFiltered(node) ? - TEXT_ERROR_CYCLE_BTN_UNFILTER : TEXT_ERROR_CYCLE_BTN_FILTER); - // Copy text style - styles = ListExtensions.map( - IterableExtensions.head( - _kRenderingExtensions.getKContainerRendering(err).getChildren()).getStyles(), - EcoreUtil::copy); - subrectangleText.getStyles().addAll(styles); - _kRenderingExtensions.setFontSize(subrectangleText, 5); - _kRenderingExtensions.setSurroundingSpace(subrectangleText, 1, 0); - _linguaFrancaStyleExtensions.noSelectionStyle(subrectangleText); - _kRenderingExtensions.addSingleClickAction(subrectangleText, FilterCycleAction.ID); - _filterCycleAction.markCycleFilterText(subrectangleText, err); - - // if user interactively requested a filtered diagram keep it filtered during updates - if (_filterCycleAction.isCycleFiltered(node)) { - _filterCycleAction.filterCycle(node); - } - return err; - } - } catch(Exception e) { - _filterCycleAction.resetCycleFiltering(node); - e.printStackTrace(); - return addErrorComment(node, TEXT_ERROR_CYCLE_DETECTION); - } + } + _reactorIcons.handleIcon(comps.getReactor(), reactor, true); + + if (getBooleanValue(SHOW_HYPERLINKS)) { + // Expand button + if (_utilityExtensions.hasContent(instance) && !instance.recursive) { + KText button = + _linguaFrancaShapeExtensions.addTextButton(comps.getReactor(), TEXT_SHOW_ACTION); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(button), + _kRenderingExtensions.LEFT, + 8, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 8, + 0, + _kRenderingExtensions.BOTTOM, + 8, + 0); + _kRenderingExtensions.addSingleClickAction(button, MemorizingExpandCollapseAction.ID); + _kRenderingExtensions.addDoubleClickAction(button, MemorizingExpandCollapseAction.ID); } - return null; - } - - private Collection transformReactorNetwork( - ReactorInstance reactorInstance, - Map parentInputPorts, - Map parentOutputPorts, - Map allReactorNodes - ) { - List nodes = new ArrayList<>(); - Table inputPorts = HashBasedTable.create(); - Table outputPorts = HashBasedTable.create(); - Map reactionNodes = new HashMap<>(); - Map directConnectionDummyNodes = new HashMap<>(); - Multimap actionDestinations = HashMultimap.create(); - Multimap actionSources = HashMultimap.create(); - Map timerNodes = new HashMap<>(); - KNode startupNode = _kNodeExtensions.createNode(); - TriggerInstance startup = null; - KNode shutdownNode = _kNodeExtensions.createNode(); - TriggerInstance shutdown = null; - KNode resetNode = _kNodeExtensions.createNode(); - TriggerInstance reset = null; - - // Transform instances - int index = 0; - for (ReactorInstance child : reactorInstance.children) { - Boolean expansionState = MemorizingExpandCollapseAction.getExpansionState(child); - Collection rNodes = createReactorNode( - child, - expansionState != null ? expansionState : false, - inputPorts, - outputPorts, - allReactorNodes); - nodes.addAll(rNodes); - index++; + } + + if (instance.recursive) { + comps.getFigures().forEach(_linguaFrancaStyleExtensions::errorStyle); + } + + // Create ports + Map inputPorts = new HashMap<>(); + Map outputPorts = new HashMap<>(); + List inputs = instance.inputs; + if (LayoutPostProcessing.LEGACY.equals( + (String) getObjectValue(LayoutPostProcessing.MODEL_ORDER))) { + inputs = ListExtensions.reverseView(instance.inputs); + } + for (PortInstance input : inputs) { + inputPorts.put( + input, addIOPort(node, input, true, input.isMultiport(), reactorInstance.isBank())); + } + for (PortInstance output : instance.outputs) { + outputPorts.put( + output, addIOPort(node, output, false, output.isMultiport(), reactorInstance.isBank())); + } + // Mark ports + inputPorts.values().forEach(it -> it.setProperty(REACTOR_INPUT, true)); + outputPorts.values().forEach(it -> it.setProperty(REACTOR_OUTPUT, true)); + + // Add content + if (_utilityExtensions.hasContent(instance) && !instance.recursive) { + node.getChildren() + .addAll(transformReactorNetwork(instance, inputPorts, outputPorts, allReactorNodes)); + } + + // Pass port to given tables + if (!_utilityExtensions.isRoot(instance)) { + if (inputPortsReg != null) { + for (Map.Entry entry : inputPorts.entrySet()) { + inputPortsReg.put(instance, entry.getKey(), entry.getValue()); + } } - - // Create timers - for (TimerInstance timer : reactorInstance.timers) { - KNode node = associateWith(_kNodeExtensions.createNode(), timer.getDefinition()); - NamedInstanceUtil.linkInstance(node, timer); - _utilityExtensions.setID(node, timer.uniqueID()); - nodes.add(node); - Iterables.addAll(nodes, createUserComments(timer.getDefinition(), node)); - timerNodes.put(timer, node); - _linguaFrancaShapeExtensions.addTimerFigure(node, timer); - _layoutPostProcessing.configureTimer(node); + if (outputPortsReg != null) { + for (Map.Entry entry : outputPorts.entrySet()) { + outputPortsReg.put(instance, entry.getKey(), entry.getValue()); + } } + } + + if (instance.recursive) { + setLayoutOption(node, KlighdProperties.EXPAND, false); + nodes.add(addErrorComment(node, TEXT_ERROR_RECURSIVE)); + } else { + setLayoutOption(node, KlighdProperties.EXPAND, expandDefault); + + // Interface Dependencies + _interfaceDependenciesVisualization.addInterfaceDependencies(node, expandDefault); + } + + if (!_utilityExtensions.isRoot(instance)) { + // If all reactors are being shown, then only put the label on + // the reactor definition, not on its instances. Otherwise, + // add the annotation now. + if (!getBooleanValue(SHOW_ALL_REACTORS)) { + Iterables.addAll(nodes, createUserComments(reactor, node)); + } + } else { + Iterables.addAll(nodes, createUserComments(reactor, node)); + } + configureReactorNodeLayout(node, false); + _layoutPostProcessing.configureReactor(node); + } - // Create reactions - for (ReactionInstance reaction : reactorInstance.reactions) { - int idx = reactorInstance.reactions.indexOf(reaction); - KNode node = associateWith(_kNodeExtensions.createNode(), reaction.getDefinition()); - NamedInstanceUtil.linkInstance(node, reaction); - _utilityExtensions.setID(node, reaction.uniqueID()); - nodes.add(node); - Iterables.addAll(nodes, createUserComments(reaction.getDefinition(), node)); - reactionNodes.put(reaction, node); - - setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); - _layoutPostProcessing.configureReaction(node); - setLayoutOption(node, LayeredOptions.POSITION, new KVector(0, idx + 1)); // try order reactions vertically if in one layer (+1 to account for startup) - - var figure = _linguaFrancaShapeExtensions.addReactionFigure(node, reaction); - - int inputSize = Stream.concat(reaction.triggers.stream(), reaction.sources.stream()).collect(Collectors.toSet()).size(); - int outputSize = reaction.effects.size(); - if (!getBooleanValue(REACTIONS_USE_HYPEREDGES) && (inputSize > 1 || outputSize > 1)) { - // If this node will have more than one input/output port, the port positions must be adjusted to the - // pointy shape. However, this is only possible after the layout. - ReactionPortAdjustment.apply(node, figure); - } - - // connect input - KPort port = null; - for (TriggerInstance trigger : reaction.triggers) { - // Create new port if there is no previous one or each dependency should have its own one - if (port == null || !getBooleanValue(REACTIONS_USE_HYPEREDGES)) { - port = addInvisiblePort(node); - setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.WEST); - - if (getBooleanValue(REACTIONS_USE_HYPEREDGES) || inputSize == 1) { - // manual adjustment disabling automatic one - setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, - (double) -LinguaFrancaShapeExtensions.REACTION_POINTINESS); - } - } - - if (trigger.isStartup()) { - connect(createDependencyEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), - startupNode, - port); - startup = trigger; - } else if (trigger.isShutdown()) { - connect(createDelayEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), - shutdownNode, - port); - shutdown = trigger; - } else if (trigger.isReset()) { - connect(createDependencyEdge(((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), - resetNode, - port); - reset = trigger; - } else if (trigger instanceof ActionInstance) { - actionDestinations.put(((ActionInstance) trigger), port); - } else if (trigger instanceof PortInstance) { - KPort src = null; - PortInstance triggerAsPort = (PortInstance) trigger; - if (triggerAsPort.getParent() == reactorInstance) { - src = parentInputPorts.get(trigger); - } else { - src = outputPorts.get(triggerAsPort.getParent(), trigger); - } - if (src != null) { - connect(createDependencyEdge(triggerAsPort.getDefinition()), src, port); - } - } else if (trigger instanceof TimerInstance) { - KNode src = timerNodes.get(trigger); - if (src != null) { - connect(createDependencyEdge(trigger.getDefinition()), src, port); - } - } - } - - // connect dependencies - for (TriggerInstance dep : reaction.sources) { - if (reaction.triggers.contains(dep)) continue; // skip - - // Create new port if there is no previous one or each dependency should have its own one - if (port == null || !getBooleanValue(REACTIONS_USE_HYPEREDGES)) { - port = addInvisiblePort(node); - setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.WEST); + // Find and annotate cycles + if (getBooleanValue(CYCLE_DETECTION) && _utilityExtensions.isRoot(reactorInstance)) { + KNode errNode = detectAndAnnotateCycles(node, reactorInstance, allReactorNodes); + if (errNode != null) { + nodes.add(errNode); + } + } - if (getBooleanValue(REACTIONS_USE_HYPEREDGES) || inputSize == 1) { - // manual adjustment disabling automatic one - setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, - (double) -LinguaFrancaShapeExtensions.REACTION_POINTINESS); - } - } + return nodes; + } + + public KNode configureReactorNodeLayout(KNode node, boolean main) { + // Set layered algorithm + setLayoutOption(node, CoreOptions.ALGORITHM, LayeredOptions.ALGORITHM_ID); + // Left to right layout + setLayoutOption(node, CoreOptions.DIRECTION, Direction.RIGHT); + // Center free floating children + setLayoutOption(node, CoreOptions.CONTENT_ALIGNMENT, ContentAlignment.centerCenter()); + + // Balanced placement with straight long edges. + setLayoutOption( + node, LayeredOptions.NODE_PLACEMENT_STRATEGY, NodePlacementStrategy.NETWORK_SIMPLEX); + // Do not shrink nodes below content + setLayoutOption( + node, + CoreOptions.NODE_SIZE_CONSTRAINTS, + EnumSet.of(SizeConstraint.MINIMUM_SIZE, SizeConstraint.PORTS)); + + // Allows to freely shuffle ports on each side + setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); + // Adjust port label spacing to be closer to edge but not overlap with port figure + // TODO: Add PortLabelPlacement.NEXT_TO_PORT_IF_POSSIBLE back into the configuration, as soon as + // ELK provides a fix for LF issue #1273 + setLayoutOption( + node, + CoreOptions.PORT_LABELS_PLACEMENT, + EnumSet.of(PortLabelPlacement.ALWAYS_OTHER_SAME_SIDE, PortLabelPlacement.OUTSIDE)); + setLayoutOption(node, CoreOptions.SPACING_LABEL_PORT_HORIZONTAL, 2.0); + setLayoutOption(node, CoreOptions.SPACING_LABEL_PORT_VERTICAL, -3.0); + + // Configure spacing + if (!getBooleanValue(SHOW_HYPERLINKS)) { // Hyperlink version is more relaxed in terms of space + var factor = (double) getIntValue(SPACING) / 100; + + setLayoutOption( + node, + LayeredOptions.SPACING_COMPONENT_COMPONENT, + LayeredOptions.SPACING_COMPONENT_COMPONENT.getDefault() * factor); + + setLayoutOption( + node, + LayeredOptions.SPACING_NODE_NODE, + LayeredOptions.SPACING_NODE_NODE.getDefault() * factor); + setLayoutOption( + node, + LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS, + LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS.getDefault() * factor); + + setLayoutOption( + node, + LayeredOptions.SPACING_PORT_PORT, + LayeredOptions.SPACING_PORT_PORT.getDefault() * factor); + + setLayoutOption( + node, + LayeredOptions.SPACING_EDGE_NODE, + LayeredOptions.SPACING_EDGE_NODE.getDefault() * factor); + setLayoutOption( + node, + LayeredOptions.SPACING_EDGE_NODE_BETWEEN_LAYERS, + LayeredOptions.SPACING_EDGE_NODE_BETWEEN_LAYERS.getDefault() * factor); + setLayoutOption( + node, + LayeredOptions.SPACING_EDGE_EDGE, + LayeredOptions.SPACING_EDGE_EDGE.getDefault() * factor); + setLayoutOption( + node, + LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS, + LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS.getDefault() * factor); + setLayoutOption( + node, + LayeredOptions.SPACING_EDGE_EDGE, + LayeredOptions.SPACING_EDGE_EDGE.getDefault() * factor); + setLayoutOption( + node, + LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS, + LayeredOptions.SPACING_EDGE_EDGE_BETWEEN_LAYERS.getDefault() * factor); + setLayoutOption( + node, + LayeredOptions.SPACING_EDGE_LABEL, + LayeredOptions.SPACING_EDGE_LABEL.getDefault() * factor); + + // Padding for sub graph + if (main) { // Special handing for main reactors + setLayoutOption(node, CoreOptions.PADDING, new ElkPadding(-1, 6, 6, 6)); + } else { + setLayoutOption(node, CoreOptions.PADDING, new ElkPadding(2, 6, 6, 6)); + } + } - if (dep instanceof PortInstance) { - KPort src = null; - PortInstance depAsPort = (PortInstance) dep; - if (dep.getParent() == reactorInstance) { - src = parentInputPorts.get(dep); + return node; + } + + private KNode detectAndAnnotateCycles( + KNode node, ReactorInstance reactorInstance, Map allReactorNodes) { + if (node.getProperty(REACTOR_RECURSIVE_INSTANTIATION)) { + _filterCycleAction.resetCycleFiltering(node); + return addErrorComment(node, TEXT_ERROR_CONTAINS_RECURSION); + } else { // only detect dependency cycles if not recursive + try { + boolean hasCycle = + _cycleVisualization.detectAndHighlightCycles( + reactorInstance, + allReactorNodes, + it -> { + if (it instanceof KNode) { + List renderings = + IterableExtensions.toList( + Iterables.filter(((KNode) it).getData(), KRendering.class)); + if (renderings.size() == 1) { + _linguaFrancaStyleExtensions.errorStyle(IterableExtensions.head(renderings)); } else { - src = outputPorts.get(depAsPort.getParent(), dep); + IterableExtensions.filter( + renderings, + rendering -> { + return rendering.getProperty(KlighdProperties.COLLAPSED_RENDERING); + }) + .forEach(_linguaFrancaStyleExtensions::errorStyle); } - if (src != null) { - connect(createDependencyEdge(dep.getDefinition()), src, port); - } - } - } - - // connect outputs - port = null; // enforce new ports for outputs - Set> iterSet = reaction.effects != null ? reaction.effects : new HashSet<>(); - for (TriggerInstance effect : iterSet) { - // Create new port if there is no previous one or each dependency should have its own one - if (port == null || !getBooleanValue(REACTIONS_USE_HYPEREDGES)) { - port = addInvisiblePort(node); - setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.EAST); - } + } else if (it instanceof KEdge) { + Iterables.filter(((KEdge) it).getData(), KRendering.class) + .forEach(_linguaFrancaStyleExtensions::errorStyle); + // TODO initiallyHide does not work with incremental + // (https://github.com/kieler/KLighD/issues/37) + // cycleEgde.initiallyShow() // Show hidden order dependencies + _kRenderingExtensions.setInvisible( + _kRenderingExtensions.getKRendering(it), false); + } else if (it instanceof KPort) { + Iterables.filter(((KPort) it).getData(), KRendering.class) + .forEach(_linguaFrancaStyleExtensions::errorStyle); + // it.reverseTrianglePort() + } + }); - if (effect instanceof ActionInstance) { - actionSources.put((ActionInstance) effect, port); - } else if (effect instanceof PortInstance) { - KPort dst = null; - PortInstance effectAsPort = (PortInstance) effect; - if (effectAsPort.isOutput()) { - dst = parentOutputPorts.get(effect); - } else { - dst = inputPorts.get(effectAsPort.getParent(), effect); - } - if (dst != null) { - connect(createDependencyEdge(effect), port, dst); - } - } - } + if (hasCycle) { + KNode err = addErrorComment(node, TEXT_ERROR_CONTAINS_CYCLE); + + // Add to existing figure + KRectangle rectangle = + _kContainerRenderingExtensions.addRectangle( + _kRenderingExtensions.getKContainerRendering(err)); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 3, + 0, + _kRenderingExtensions.TOP, + (-1), + 0), + _kRenderingExtensions.RIGHT, + 3, + 0, + _kRenderingExtensions.BOTTOM, + 3, + 0); + _linguaFrancaStyleExtensions.noSelectionStyle(rectangle); + _kRenderingExtensions.setInvisible(rectangle, true); + _kContainerRenderingExtensions.setGridPlacement(rectangle, 2); + + KRectangle subrectangle = _kContainerRenderingExtensions.addRectangle(rectangle); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(subrectangle), + _kRenderingExtensions.LEFT, + 0, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 2, + 0, + _kRenderingExtensions.BOTTOM, + 0, + 0); + _linguaFrancaStyleExtensions.noSelectionStyle(subrectangle); + _kRenderingExtensions.addSingleClickAction(subrectangle, ShowCycleAction.ID); + + KText subrectangleText = + _kContainerRenderingExtensions.addText(subrectangle, TEXT_ERROR_CYCLE_BTN_SHOW); + // Copy text style + List styles = + ListExtensions.map( + IterableExtensions.head( + _kRenderingExtensions.getKContainerRendering(err).getChildren()) + .getStyles(), + EcoreUtil::copy); + subrectangleText.getStyles().addAll(styles); + _kRenderingExtensions.setFontSize(subrectangleText, 5); + _kRenderingExtensions.setSurroundingSpace(subrectangleText, 1, 0); + _linguaFrancaStyleExtensions.noSelectionStyle(subrectangleText); + _kRenderingExtensions.addSingleClickAction(subrectangleText, ShowCycleAction.ID); + + subrectangle = _kContainerRenderingExtensions.addRectangle(rectangle); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(subrectangle), + _kRenderingExtensions.LEFT, + 0, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 0, + 0, + _kRenderingExtensions.BOTTOM, + 0, + 0); + _linguaFrancaStyleExtensions.noSelectionStyle(subrectangle); + _kRenderingExtensions.addSingleClickAction(subrectangle, FilterCycleAction.ID); + + subrectangleText = + _kContainerRenderingExtensions.addText( + subrectangle, + _filterCycleAction.isCycleFiltered(node) + ? TEXT_ERROR_CYCLE_BTN_UNFILTER + : TEXT_ERROR_CYCLE_BTN_FILTER); + // Copy text style + styles = + ListExtensions.map( + IterableExtensions.head( + _kRenderingExtensions.getKContainerRendering(err).getChildren()) + .getStyles(), + EcoreUtil::copy); + subrectangleText.getStyles().addAll(styles); + _kRenderingExtensions.setFontSize(subrectangleText, 5); + _kRenderingExtensions.setSurroundingSpace(subrectangleText, 1, 0); + _linguaFrancaStyleExtensions.noSelectionStyle(subrectangleText); + _kRenderingExtensions.addSingleClickAction(subrectangleText, FilterCycleAction.ID); + _filterCycleAction.markCycleFilterText(subrectangleText, err); + + // if user interactively requested a filtered diagram keep it filtered during updates + if (_filterCycleAction.isCycleFiltered(node)) { + _filterCycleAction.filterCycle(node); + } + return err; } + } catch (Exception e) { + _filterCycleAction.resetCycleFiltering(node); + e.printStackTrace(); + return addErrorComment(node, TEXT_ERROR_CYCLE_DETECTION); + } + } + return null; + } + + private Collection transformReactorNetwork( + ReactorInstance reactorInstance, + Map parentInputPorts, + Map parentOutputPorts, + Map allReactorNodes) { + List nodes = new ArrayList<>(); + Table inputPorts = HashBasedTable.create(); + Table outputPorts = HashBasedTable.create(); + Map reactionNodes = new HashMap<>(); + Map directConnectionDummyNodes = new HashMap<>(); + Multimap actionDestinations = HashMultimap.create(); + Multimap actionSources = HashMultimap.create(); + Map timerNodes = new HashMap<>(); + KNode startupNode = _kNodeExtensions.createNode(); + TriggerInstance startup = null; + KNode shutdownNode = _kNodeExtensions.createNode(); + TriggerInstance shutdown = null; + KNode resetNode = _kNodeExtensions.createNode(); + TriggerInstance reset = null; + + // Transform instances + int index = 0; + for (ReactorInstance child : reactorInstance.children) { + Boolean expansionState = MemorizingExpandCollapseAction.getExpansionState(child); + Collection rNodes = + createReactorNode( + child, + expansionState != null ? expansionState : false, + inputPorts, + outputPorts, + allReactorNodes); + nodes.addAll(rNodes); + index++; + } - // Connect actions - Set actions = new HashSet<>(); - actions.addAll(actionSources.keySet()); - actions.addAll(actionDestinations.keySet()); - - for (ActionInstance action : actions) { - KNode node = associateWith(_kNodeExtensions.createNode(), action.getDefinition()); - NamedInstanceUtil.linkInstance(node, action); - _utilityExtensions.setID(node, action.uniqueID()); - nodes.add(node); - Iterables.addAll(nodes, createUserComments(action.getDefinition(), node)); - setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); - _layoutPostProcessing.configureAction(node); - Pair ports = _linguaFrancaShapeExtensions.addActionFigureAndPorts( - node, - action.isPhysical() ? "P" : "L"); - // TODO handle variables? - if (action.getMinDelay() != null && action.getMinDelay() != ActionInstance.DEFAULT_MIN_DELAY) { - _kLabelExtensions.addOutsideBottomCenteredNodeLabel( - node, - String.format("min delay: %s", action.getMinDelay().toString()), - 7); - } - // TODO default value? - if (action.getDefinition().getMinSpacing() != null) { - _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, - String.format("min spacing: %s", action.getMinSpacing().toString()), - 7); - } - if (!StringExtensions.isNullOrEmpty(action.getDefinition().getPolicy())) { - _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, - String.format("policy: %s", action.getPolicy().toString()), - 7); - } - // connect source - for (KPort source : actionSources.get(action)) { - connect(createDelayEdge(action), source, ports.getKey()); - } + // Create timers + for (TimerInstance timer : reactorInstance.timers) { + KNode node = associateWith(_kNodeExtensions.createNode(), timer.getDefinition()); + NamedInstanceUtil.linkInstance(node, timer); + _utilityExtensions.setID(node, timer.uniqueID()); + nodes.add(node); + Iterables.addAll(nodes, createUserComments(timer.getDefinition(), node)); + timerNodes.put(timer, node); + _linguaFrancaShapeExtensions.addTimerFigure(node, timer); + _layoutPostProcessing.configureTimer(node); + } - // connect targets - for (KPort target : actionDestinations.get(action)) { - connect(createDelayEdge(action), ports.getValue(), target); - } + // Create reactions + for (ReactionInstance reaction : reactorInstance.reactions) { + int idx = reactorInstance.reactions.indexOf(reaction); + KNode node = associateWith(_kNodeExtensions.createNode(), reaction.getDefinition()); + NamedInstanceUtil.linkInstance(node, reaction); + _utilityExtensions.setID(node, reaction.uniqueID()); + nodes.add(node); + Iterables.addAll(nodes, createUserComments(reaction.getDefinition(), node)); + reactionNodes.put(reaction, node); + + setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); + _layoutPostProcessing.configureReaction(node); + setLayoutOption( + node, + LayeredOptions.POSITION, + new KVector( + 0, idx + 1)); // try order reactions vertically if in one layer (+1 to account for + // startup) + + var figure = _linguaFrancaShapeExtensions.addReactionFigure(node, reaction); + + int inputSize = + Stream.concat(reaction.triggers.stream(), reaction.sources.stream()) + .collect(Collectors.toSet()) + .size(); + int outputSize = reaction.effects.size(); + if (!getBooleanValue(REACTIONS_USE_HYPEREDGES) && (inputSize > 1 || outputSize > 1)) { + // If this node will have more than one input/output port, the port positions must be + // adjusted to the + // pointy shape. However, this is only possible after the layout. + ReactionPortAdjustment.apply(node, figure); + } + + // connect input + KPort port = null; + for (TriggerInstance trigger : reaction.triggers) { + // Create new port if there is no previous one or each dependency should have its own one + if (port == null || !getBooleanValue(REACTIONS_USE_HYPEREDGES)) { + port = addInvisiblePort(node); + setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.WEST); + + if (getBooleanValue(REACTIONS_USE_HYPEREDGES) || inputSize == 1) { + // manual adjustment disabling automatic one + setLayoutOption( + port, + CoreOptions.PORT_BORDER_OFFSET, + (double) -LinguaFrancaShapeExtensions.REACTION_POINTINESS); + } } - // Transform connections. - // First, collect all the source ports. - List sourcePorts = new LinkedList<>(reactorInstance.inputs); - for (ReactorInstance child : reactorInstance.children) { - sourcePorts.addAll(child.outputs); + if (trigger.isStartup()) { + connect( + createDependencyEdge( + ((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), + startupNode, + port); + startup = trigger; + } else if (trigger.isShutdown()) { + connect( + createDelayEdge( + ((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), + shutdownNode, + port); + shutdown = trigger; + } else if (trigger.isReset()) { + connect( + createDependencyEdge( + ((TriggerInstance.BuiltinTriggerVariable) trigger.getDefinition()).definition), + resetNode, + port); + reset = trigger; + } else if (trigger instanceof ActionInstance) { + actionDestinations.put(((ActionInstance) trigger), port); + } else if (trigger instanceof PortInstance) { + KPort src = null; + PortInstance triggerAsPort = (PortInstance) trigger; + if (triggerAsPort.getParent() == reactorInstance) { + src = parentInputPorts.get(trigger); + } else { + src = outputPorts.get(triggerAsPort.getParent(), trigger); + } + if (src != null) { + connect(createDependencyEdge(triggerAsPort.getDefinition()), src, port); + } + } else if (trigger instanceof TimerInstance) { + KNode src = timerNodes.get(trigger); + if (src != null) { + connect(createDependencyEdge(trigger.getDefinition()), src, port); + } } - - for (PortInstance leftPort : sourcePorts) { - KPort source = leftPort.getParent() == reactorInstance ? - parentInputPorts.get(leftPort) : - outputPorts.get(leftPort.getParent(), leftPort); - - for (SendRange sendRange : leftPort.getDependentPorts()) { - for (RuntimeRange rightRange : sendRange.destinations) { - PortInstance rightPort = rightRange.instance; - KPort target = rightPort.getParent() == reactorInstance ? - parentOutputPorts.get(rightPort) : - inputPorts.get(rightPort.getParent(), rightPort); - // There should be a connection, but skip if not. - Connection connection = sendRange.connection; - if (connection != null) { - KEdge edge = createIODependencyEdge(connection, (leftPort.isMultiport() || rightPort.isMultiport())); - if (connection.getDelay() != null) { - KLabel delayLabel = _kLabelExtensions.addCenterEdgeLabel(edge, ASTUtils.toOriginalText(connection.getDelay())); - associateWith(delayLabel, connection.getDelay()); - if (connection.isPhysical()) { - _linguaFrancaStyleExtensions.applyOnEdgePysicalDelayStyle(delayLabel, - reactorInstance.isMainOrFederated() ? Colors.WHITE : Colors.GRAY_95); - } else { - _linguaFrancaStyleExtensions.applyOnEdgeDelayStyle(delayLabel); - } - } else if (connection.isPhysical()) { - KLabel physicalConnectionLabel = _kLabelExtensions.addCenterEdgeLabel(edge, "---"); - _linguaFrancaStyleExtensions.applyOnEdgePysicalStyle(physicalConnectionLabel, - reactorInstance.isMainOrFederated() ? Colors.WHITE : Colors.GRAY_95); - } - if (source != null && target != null) { - // check for inside loop (direct in -> out connection with delay) - if (parentInputPorts.values().contains(source) && - parentOutputPorts.values().contains(target)) { - // edge.setLayoutOption(CoreOptions.INSIDE_SELF_LOOPS_YO, true) // Does not work as expected - // Introduce dummy node to enable direct connection (that is also hidden when collapsed) - KNode dummy = _kNodeExtensions.createNode(); - if (directConnectionDummyNodes.containsKey(target)) { - dummy = directConnectionDummyNodes.get(target); - } else { - nodes.add(dummy); - directConnectionDummyNodes.put(target, dummy); - _kRenderingExtensions.addInvisibleContainerRendering(dummy); - _kNodeExtensions.setNodeSize(dummy, 0, 0); - KEdge extraEdge = createIODependencyEdge(null, - (leftPort.isMultiport() || rightPort.isMultiport())); - connect(extraEdge, dummy, target); - } - connect(edge, source, dummy); - } else { - connect(edge, source, target); - } - } - } - } - } + } + + // connect dependencies + for (TriggerInstance dep : reaction.sources) { + if (reaction.triggers.contains(dep)) continue; // skip + + // Create new port if there is no previous one or each dependency should have its own one + if (port == null || !getBooleanValue(REACTIONS_USE_HYPEREDGES)) { + port = addInvisiblePort(node); + setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.WEST); + + if (getBooleanValue(REACTIONS_USE_HYPEREDGES) || inputSize == 1) { + // manual adjustment disabling automatic one + setLayoutOption( + port, + CoreOptions.PORT_BORDER_OFFSET, + (double) -LinguaFrancaShapeExtensions.REACTION_POINTINESS); + } } - // Add startup/shutdown - if (startup != null) { - _linguaFrancaShapeExtensions.addStartupFigure(startupNode); - _utilityExtensions.setID(startupNode, reactorInstance.uniqueID() + "_startup"); - NamedInstanceUtil.linkInstance(startupNode, startup); - startupNode.setProperty(REACTION_SPECIAL_TRIGGER, true); - nodes.add(0, startupNode); // add at the start (ordered first) - // try to order with reactions vertically if in one layer - setLayoutOption(startupNode, LayeredOptions.POSITION, new KVector(0, 0)); - setLayoutOption(startupNode, LayeredOptions.LAYERING_LAYER_CONSTRAINT, LayerConstraint.FIRST); - _layoutPostProcessing.configureAction(startupNode); - - if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { - KPort port = addInvisiblePort(startupNode); - startupNode.getOutgoingEdges().forEach(it -> { - it.setSourcePort(port); - }); - } + if (dep instanceof PortInstance) { + KPort src = null; + PortInstance depAsPort = (PortInstance) dep; + if (dep.getParent() == reactorInstance) { + src = parentInputPorts.get(dep); + } else { + src = outputPorts.get(depAsPort.getParent(), dep); + } + if (src != null) { + connect(createDependencyEdge(dep.getDefinition()), src, port); + } } - if (shutdown != null) { - _linguaFrancaShapeExtensions.addShutdownFigure(shutdownNode); - _utilityExtensions.setID(shutdownNode, reactorInstance.uniqueID() + "_shutdown"); - NamedInstanceUtil.linkInstance(shutdownNode, shutdown); - shutdownNode.setProperty(REACTION_SPECIAL_TRIGGER, true); - nodes.add(shutdownNode); // add at the end (ordered last) - // try to order with reactions vertically if in one layer - _layoutPostProcessing.configureShutDown(shutdownNode); - setLayoutOption(shutdownNode, LayeredOptions.POSITION, new KVector(0, reactorInstance.reactions.size() + 1)); - - if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port - KPort port = addInvisiblePort(shutdownNode); - shutdownNode.getOutgoingEdges().forEach(it -> { - it.setSourcePort(port); - }); - } - } - if (reset != null) { - _linguaFrancaShapeExtensions.addResetFigure(resetNode); - _utilityExtensions.setID(resetNode, reactorInstance.uniqueID() + "_reset"); - NamedInstanceUtil.linkInstance(resetNode, reset); - resetNode.setProperty(REACTION_SPECIAL_TRIGGER, true); - nodes.add(startup != null ? 1 : 0, resetNode); // after startup - // try to order with reactions vertically if in one layer - setLayoutOption(resetNode, LayeredOptions.POSITION, new KVector(0, 0.5)); - setLayoutOption(resetNode, LayeredOptions.LAYERING_LAYER_CONSTRAINT, LayerConstraint.FIRST); - - if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port - KPort port = addInvisiblePort(resetNode); - resetNode.getOutgoingEdges().forEach(it -> { - it.setSourcePort(port); - }); - } - } - - // Postprocess timer nodes - if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port - for (KNode timerNode : timerNodes.values()) { - KPort port = addInvisiblePort(timerNode); - timerNode.getOutgoingEdges().forEach(it -> { - it.setSourcePort(port); - }); - } + } + + // connect outputs + port = null; // enforce new ports for outputs + Set> iterSet = + reaction.effects != null ? reaction.effects : new HashSet<>(); + for (TriggerInstance effect : iterSet) { + // Create new port if there is no previous one or each dependency should have its own one + if (port == null || !getBooleanValue(REACTIONS_USE_HYPEREDGES)) { + port = addInvisiblePort(node); + setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.EAST); } - // Add reaction order edges (add last to have them on top of other edges) - if (reactorInstance.reactions.size() > 1) { - KNode prevNode = reactionNodes.get(IterableExtensions.head(reactorInstance.reactions)); - Iterable iterList = IterableExtensions.map( - IterableExtensions.drop(reactorInstance.reactions, 1), - reactionNodes::get); - for (KNode node : iterList) { - KEdge edge = createOrderEdge(); - edge.setSource(prevNode); - edge.setTarget(node); - edge.setProperty(CoreOptions.NO_LAYOUT, true); - - // Do not remove them, as they are needed for cycle detection - KRendering edgeRendering = _kRenderingExtensions.getKRendering(edge); - _kRenderingExtensions.setInvisible(edgeRendering, !getBooleanValue(SHOW_REACTION_ORDER_EDGES)); - _kRenderingExtensions.getInvisible(edgeRendering).setPropagateToChildren(true); - // TODO this does not work work with incremental update (https://github.com/kieler/KLighD/issues/37) - // if (!getBooleanValue(SHOW_REACTION_ORDER_EDGES)) edge.initiallyHide() - - prevNode = node; - } + if (effect instanceof ActionInstance) { + actionSources.put((ActionInstance) effect, port); + } else if (effect instanceof PortInstance) { + KPort dst = null; + PortInstance effectAsPort = (PortInstance) effect; + if (effectAsPort.isOutput()) { + dst = parentOutputPorts.get(effect); + } else { + dst = inputPorts.get(effectAsPort.getParent(), effect); + } + if (dst != null) { + connect(createDependencyEdge(effect), port, dst); + } } + } + } - _layoutPostProcessing.orderChildren(nodes); - _modeDiagrams.handleModes(nodes, reactorInstance); + // Connect actions + Set actions = new HashSet<>(); + actions.addAll(actionSources.keySet()); + actions.addAll(actionDestinations.keySet()); + + for (ActionInstance action : actions) { + KNode node = associateWith(_kNodeExtensions.createNode(), action.getDefinition()); + NamedInstanceUtil.linkInstance(node, action); + _utilityExtensions.setID(node, action.uniqueID()); + nodes.add(node); + Iterables.addAll(nodes, createUserComments(action.getDefinition(), node)); + setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FIXED_SIDE); + _layoutPostProcessing.configureAction(node); + Pair ports = + _linguaFrancaShapeExtensions.addActionFigureAndPorts( + node, action.isPhysical() ? "P" : "L"); + // TODO handle variables? + if (action.getMinDelay() != null + && action.getMinDelay() != ActionInstance.DEFAULT_MIN_DELAY) { + _kLabelExtensions.addOutsideBottomCenteredNodeLabel( + node, String.format("min delay: %s", action.getMinDelay().toString()), 7); + } + // TODO default value? + if (action.getDefinition().getMinSpacing() != null) { + _kLabelExtensions.addOutsideBottomCenteredNodeLabel( + node, String.format("min spacing: %s", action.getMinSpacing().toString()), 7); + } + if (!StringExtensions.isNullOrEmpty(action.getDefinition().getPolicy())) { + _kLabelExtensions.addOutsideBottomCenteredNodeLabel( + node, String.format("policy: %s", action.getPolicy().toString()), 7); + } + // connect source + for (KPort source : actionSources.get(action)) { + connect(createDelayEdge(action), source, ports.getKey()); + } + + // connect targets + for (KPort target : actionDestinations.get(action)) { + connect(createDelayEdge(action), ports.getValue(), target); + } + } - return nodes; + // Transform connections. + // First, collect all the source ports. + List sourcePorts = new LinkedList<>(reactorInstance.inputs); + for (ReactorInstance child : reactorInstance.children) { + sourcePorts.addAll(child.outputs); } - private String createReactorLabel(ReactorInstance reactorInstance) { - StringBuilder b = new StringBuilder(); - if (getBooleanValue(SHOW_INSTANCE_NAMES) && !_utilityExtensions.isRoot(reactorInstance)) { - if (!reactorInstance.isMainOrFederated()) { - b.append(reactorInstance.getName()).append(" : "); - } - } - if (reactorInstance.isMainOrFederated()) { - try { - b.append(FileUtil.nameWithoutExtension(reactorInstance.reactorDeclaration.eResource())); - } catch (Exception e) { - throw Exceptions.sneakyThrow(e); + for (PortInstance leftPort : sourcePorts) { + KPort source = + leftPort.getParent() == reactorInstance + ? parentInputPorts.get(leftPort) + : outputPorts.get(leftPort.getParent(), leftPort); + + for (SendRange sendRange : leftPort.getDependentPorts()) { + for (RuntimeRange rightRange : sendRange.destinations) { + PortInstance rightPort = rightRange.instance; + KPort target = + rightPort.getParent() == reactorInstance + ? parentOutputPorts.get(rightPort) + : inputPorts.get(rightPort.getParent(), rightPort); + // There should be a connection, but skip if not. + Connection connection = sendRange.connection; + if (connection != null) { + KEdge edge = + createIODependencyEdge( + connection, (leftPort.isMultiport() || rightPort.isMultiport())); + if (connection.getDelay() != null) { + KLabel delayLabel = + _kLabelExtensions.addCenterEdgeLabel( + edge, ASTUtils.toOriginalText(connection.getDelay())); + associateWith(delayLabel, connection.getDelay()); + if (connection.isPhysical()) { + _linguaFrancaStyleExtensions.applyOnEdgePysicalDelayStyle( + delayLabel, + reactorInstance.isMainOrFederated() ? Colors.WHITE : Colors.GRAY_95); + } else { + _linguaFrancaStyleExtensions.applyOnEdgeDelayStyle(delayLabel); + } + } else if (connection.isPhysical()) { + KLabel physicalConnectionLabel = _kLabelExtensions.addCenterEdgeLabel(edge, "---"); + _linguaFrancaStyleExtensions.applyOnEdgePysicalStyle( + physicalConnectionLabel, + reactorInstance.isMainOrFederated() ? Colors.WHITE : Colors.GRAY_95); } - } else if (reactorInstance.reactorDeclaration == null) { - // There is an error in the graph. - b.append(""); - } else { - b.append(reactorInstance.reactorDeclaration.getName()); - } - if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TITLE) { - if (reactorInstance.parameters.isEmpty()) { - b.append("()"); - } else { - b.append(IterableExtensions.join(reactorInstance.parameters, "(", ", ", ")", - it -> { - return createParameterLabel(it); - })); + if (source != null && target != null) { + // check for inside loop (direct in -> out connection with delay) + if (parentInputPorts.values().contains(source) + && parentOutputPorts.values().contains(target)) { + // edge.setLayoutOption(CoreOptions.INSIDE_SELF_LOOPS_YO, true) // Does not work as + // expected + // Introduce dummy node to enable direct connection (that is also hidden when + // collapsed) + KNode dummy = _kNodeExtensions.createNode(); + if (directConnectionDummyNodes.containsKey(target)) { + dummy = directConnectionDummyNodes.get(target); + } else { + nodes.add(dummy); + directConnectionDummyNodes.put(target, dummy); + _kRenderingExtensions.addInvisibleContainerRendering(dummy); + _kNodeExtensions.setNodeSize(dummy, 0, 0); + KEdge extraEdge = + createIODependencyEdge( + null, (leftPort.isMultiport() || rightPort.isMultiport())); + connect(extraEdge, dummy, target); + } + connect(edge, source, dummy); + } else { + connect(edge, source, target); + } } + } } - return b.toString(); + } } - private void addParameterList(KContainerRendering container, List parameters) { - int cols = 1; - try { - cols = getIntValue(REACTOR_BODY_TABLE_COLS); - } catch (Exception e) {} // ignore - if (cols > parameters.size()) { - cols = parameters.size(); - } - _kContainerRenderingExtensions.setGridPlacement(container, cols); - for (ParameterInstance param : parameters) { - var entry = _linguaFrancaShapeExtensions.addParameterEntry( - container, param.getDefinition(), createParameterLabel(param)); - _kRenderingExtensions.setHorizontalAlignment(entry, HorizontalAlignment.LEFT); - } + // Add startup/shutdown + if (startup != null) { + _linguaFrancaShapeExtensions.addStartupFigure(startupNode); + _utilityExtensions.setID(startupNode, reactorInstance.uniqueID() + "_startup"); + NamedInstanceUtil.linkInstance(startupNode, startup); + startupNode.setProperty(REACTION_SPECIAL_TRIGGER, true); + nodes.add(0, startupNode); // add at the start (ordered first) + // try to order with reactions vertically if in one layer + setLayoutOption(startupNode, LayeredOptions.POSITION, new KVector(0, 0)); + setLayoutOption(startupNode, LayeredOptions.LAYERING_LAYER_CONSTRAINT, LayerConstraint.FIRST); + _layoutPostProcessing.configureAction(startupNode); + + if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { + KPort port = addInvisiblePort(startupNode); + startupNode + .getOutgoingEdges() + .forEach( + it -> { + it.setSourcePort(port); + }); + } } - - private String createParameterLabel(ParameterInstance param) { - StringBuilder b = new StringBuilder(); - b.append(param.getName()); - String t = param.type.toOriginalText(); - if (!StringExtensions.isNullOrEmpty(t)) { - b.append(": ").append(t); - } - if (param.getOverride() != null) { - b.append(" = "); - var init = param.getActualValue(); - b.append(FormattingUtils.render(init)); - } - return b.toString(); + if (shutdown != null) { + _linguaFrancaShapeExtensions.addShutdownFigure(shutdownNode); + _utilityExtensions.setID(shutdownNode, reactorInstance.uniqueID() + "_shutdown"); + NamedInstanceUtil.linkInstance(shutdownNode, shutdown); + shutdownNode.setProperty(REACTION_SPECIAL_TRIGGER, true); + nodes.add(shutdownNode); // add at the end (ordered last) + // try to order with reactions vertically if in one layer + _layoutPostProcessing.configureShutDown(shutdownNode); + setLayoutOption( + shutdownNode, + LayeredOptions.POSITION, + new KVector(0, reactorInstance.reactions.size() + 1)); + + if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port + KPort port = addInvisiblePort(shutdownNode); + shutdownNode + .getOutgoingEdges() + .forEach( + it -> { + it.setSourcePort(port); + }); + } } - - public void addStateVariableList(KContainerRendering container, List variables) { - int cols = 1; - try { - cols = getIntValue(REACTOR_BODY_TABLE_COLS); - } catch (Exception e) {} // ignore - if (cols > variables.size()) { - cols = variables.size(); - } - _kContainerRenderingExtensions.setGridPlacement(container, cols); - for (var variable : variables) { - var entry = _linguaFrancaShapeExtensions.addStateEntry( - container, variable, createStateVariableLabel(variable), variable.isReset()); - _kRenderingExtensions.setHorizontalAlignment(entry, HorizontalAlignment.LEFT); - } + if (reset != null) { + _linguaFrancaShapeExtensions.addResetFigure(resetNode); + _utilityExtensions.setID(resetNode, reactorInstance.uniqueID() + "_reset"); + NamedInstanceUtil.linkInstance(resetNode, reset); + resetNode.setProperty(REACTION_SPECIAL_TRIGGER, true); + nodes.add(startup != null ? 1 : 0, resetNode); // after startup + // try to order with reactions vertically if in one layer + setLayoutOption(resetNode, LayeredOptions.POSITION, new KVector(0, 0.5)); + setLayoutOption(resetNode, LayeredOptions.LAYERING_LAYER_CONSTRAINT, LayerConstraint.FIRST); + + if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port + KPort port = addInvisiblePort(resetNode); + resetNode + .getOutgoingEdges() + .forEach( + it -> { + it.setSourcePort(port); + }); + } } - private String createStateVariableLabel(StateVar variable) { - StringBuilder b = new StringBuilder(); - b.append(variable.getName()); - if (variable.getType() != null) { - var t = InferredType.fromAST(variable.getType()); - b.append(":").append(t.toOriginalText()); - } - if (variable.getInit() != null) { - b.append(FormattingUtils.render(variable.getInit())); - } - return b.toString(); + // Postprocess timer nodes + if (getBooleanValue(REACTIONS_USE_HYPEREDGES)) { // connect all edges to one port + for (KNode timerNode : timerNodes.values()) { + KPort port = addInvisiblePort(timerNode); + timerNode + .getOutgoingEdges() + .forEach( + it -> { + it.setSourcePort(port); + }); + } } - private KEdge createDelayEdge(Object associate) { - KEdge edge = _kEdgeExtensions.createEdge(); - associateWith(edge, associate); - KPolyline line = _kEdgeExtensions.addPolyline(edge); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(line); - _kPolylineExtensions.addJunctionPointDecorator(line); - if (getBooleanValue(USE_ALTERNATIVE_DASH_PATTERN)) { - _kRenderingExtensions.setLineStyle(line, LineStyle.CUSTOM); - _kRenderingExtensions.getLineStyle(line).getDashPattern().addAll(ALTERNATIVE_DASH_PATTERN); - } else { - _kRenderingExtensions.setLineStyle(line, LineStyle.DASH); - } - return edge; + // Add reaction order edges (add last to have them on top of other edges) + if (reactorInstance.reactions.size() > 1) { + KNode prevNode = reactionNodes.get(IterableExtensions.head(reactorInstance.reactions)); + Iterable iterList = + IterableExtensions.map( + IterableExtensions.drop(reactorInstance.reactions, 1), reactionNodes::get); + for (KNode node : iterList) { + KEdge edge = createOrderEdge(); + edge.setSource(prevNode); + edge.setTarget(node); + edge.setProperty(CoreOptions.NO_LAYOUT, true); + + // Do not remove them, as they are needed for cycle detection + KRendering edgeRendering = _kRenderingExtensions.getKRendering(edge); + _kRenderingExtensions.setInvisible( + edgeRendering, !getBooleanValue(SHOW_REACTION_ORDER_EDGES)); + _kRenderingExtensions.getInvisible(edgeRendering).setPropagateToChildren(true); + // TODO this does not work work with incremental update + // (https://github.com/kieler/KLighD/issues/37) + // if (!getBooleanValue(SHOW_REACTION_ORDER_EDGES)) edge.initiallyHide() + + prevNode = node; + } } - private KEdge createIODependencyEdge(Object associate, boolean multiport) { - KEdge edge = _kEdgeExtensions.createEdge(); - if (associate != null) { - associateWith(edge, associate); - } - KPolyline line = _kEdgeExtensions.addPolyline(edge); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(line); - _kPolylineExtensions.addJunctionPointDecorator(line); - if (multiport) { - // Render multiport connections and bank connections in bold. - _kRenderingExtensions.setLineWidth(line, 2.2f); - _kRenderingExtensions.setLineCap(line, LineCap.CAP_SQUARE); - // Adjust junction point size - _kPolylineExtensions.setJunctionPointDecorator(line, line.getJunctionPointRendering(), 6, 6); - } - return edge; - } + _layoutPostProcessing.orderChildren(nodes); + _modeDiagrams.handleModes(nodes, reactorInstance); - private KEdge createDependencyEdge(Object associate) { - KEdge edge = _kEdgeExtensions.createEdge(); - if (associate != null) { - associateWith(edge, associate); - } - KPolyline line = _kEdgeExtensions.addPolyline(edge); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(line); - _kPolylineExtensions.addJunctionPointDecorator(line); - if (getBooleanValue(USE_ALTERNATIVE_DASH_PATTERN)) { - _kRenderingExtensions.setLineStyle(line, LineStyle.CUSTOM); - _kRenderingExtensions.getLineStyle(line).getDashPattern().addAll(ALTERNATIVE_DASH_PATTERN); - } else { - _kRenderingExtensions.setLineStyle(line, LineStyle.DASH); - } - return edge; - } + return nodes; + } - private KEdge createOrderEdge() { - KEdge edge = _kEdgeExtensions.createEdge(); - KPolyline line = _kEdgeExtensions.addPolyline(edge); - _kRenderingExtensions.setLineWidth(line, 1.5f); - _kRenderingExtensions.setLineStyle(line, LineStyle.DOT); - _kRenderingExtensions.setForeground(line, Colors.CHOCOLATE_1); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(line); - //addFixedTailArrowDecorator() // Fix for bug: https://github.com/kieler/KLighD/issues/38 - _kPolylineExtensions.addHeadArrowDecorator(line); - return edge; + private String createReactorLabel(ReactorInstance reactorInstance) { + StringBuilder b = new StringBuilder(); + if (getBooleanValue(SHOW_INSTANCE_NAMES) && !_utilityExtensions.isRoot(reactorInstance)) { + if (!reactorInstance.isMainOrFederated()) { + b.append(reactorInstance.getName()).append(" : "); + } } - - private KEdge connect(KEdge edge, KNode src, KNode dst) { - edge.setSource(src); - edge.setTarget(dst); - return edge; + if (reactorInstance.isMainOrFederated()) { + try { + b.append(FileUtil.nameWithoutExtension(reactorInstance.reactorDeclaration.eResource())); + } catch (Exception e) { + throw Exceptions.sneakyThrow(e); + } + } else if (reactorInstance.reactorDeclaration == null) { + // There is an error in the graph. + b.append(""); + } else { + b.append(reactorInstance.reactorDeclaration.getName()); } - - private KEdge connect(KEdge edge, KNode src, KPort dst) { - edge.setSource(src); - edge.setTargetPort(dst); - edge.setTarget(dst != null ? dst.getNode() : null); - return edge; + if (getObjectValue(REACTOR_PARAMETER_MODE) == ReactorParameterDisplayModes.TITLE) { + if (reactorInstance.parameters.isEmpty()) { + b.append("()"); + } else { + b.append( + IterableExtensions.join( + reactorInstance.parameters, + "(", + ", ", + ")", + it -> { + return createParameterLabel(it); + })); + } } - - private KEdge connect(KEdge edge, KPort src, KNode dst) { - edge.setSourcePort(src); - edge.setSource(src != null ? src.getNode() : null); - edge.setTarget(dst); - return edge; + return b.toString(); + } + + private void addParameterList(KContainerRendering container, List parameters) { + int cols = 1; + try { + cols = getIntValue(REACTOR_BODY_TABLE_COLS); + } catch (Exception e) { + } // ignore + if (cols > parameters.size()) { + cols = parameters.size(); + } + _kContainerRenderingExtensions.setGridPlacement(container, cols); + for (ParameterInstance param : parameters) { + var entry = + _linguaFrancaShapeExtensions.addParameterEntry( + container, param.getDefinition(), createParameterLabel(param)); + _kRenderingExtensions.setHorizontalAlignment(entry, HorizontalAlignment.LEFT); + } + } + + private String createParameterLabel(ParameterInstance param) { + StringBuilder b = new StringBuilder(); + b.append(param.getName()); + String t = param.type.toOriginalText(); + if (!StringExtensions.isNullOrEmpty(t)) { + b.append(": ").append(t); + } + if (param.getOverride() != null) { + b.append(" = "); + var init = param.getActualValue(); + b.append(FormattingUtils.render(init)); + } + return b.toString(); + } + + public void addStateVariableList(KContainerRendering container, List variables) { + int cols = 1; + try { + cols = getIntValue(REACTOR_BODY_TABLE_COLS); + } catch (Exception e) { + } // ignore + if (cols > variables.size()) { + cols = variables.size(); + } + _kContainerRenderingExtensions.setGridPlacement(container, cols); + for (var variable : variables) { + var entry = + _linguaFrancaShapeExtensions.addStateEntry( + container, variable, createStateVariableLabel(variable), variable.isReset()); + _kRenderingExtensions.setHorizontalAlignment(entry, HorizontalAlignment.LEFT); } + } + + private String createStateVariableLabel(StateVar variable) { + StringBuilder b = new StringBuilder(); + b.append(variable.getName()); + if (variable.getType() != null) { + var t = InferredType.fromAST(variable.getType()); + b.append(":").append(t.toOriginalText()); + } + if (variable.getInit() != null) { + b.append(FormattingUtils.render(variable.getInit())); + } + return b.toString(); + } + + private KEdge createDelayEdge(Object associate) { + KEdge edge = _kEdgeExtensions.createEdge(); + associateWith(edge, associate); + KPolyline line = _kEdgeExtensions.addPolyline(edge); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(line); + _kPolylineExtensions.addJunctionPointDecorator(line); + if (getBooleanValue(USE_ALTERNATIVE_DASH_PATTERN)) { + _kRenderingExtensions.setLineStyle(line, LineStyle.CUSTOM); + _kRenderingExtensions.getLineStyle(line).getDashPattern().addAll(ALTERNATIVE_DASH_PATTERN); + } else { + _kRenderingExtensions.setLineStyle(line, LineStyle.DASH); + } + return edge; + } - private KEdge connect(KEdge edge, KPort src, KPort dst) { - edge.setSourcePort(src); - edge.setSource(src != null ? src.getNode() : null); - edge.setTargetPort(dst); - edge.setTarget(dst != null ? dst.getNode() : null); - return edge; + private KEdge createIODependencyEdge(Object associate, boolean multiport) { + KEdge edge = _kEdgeExtensions.createEdge(); + if (associate != null) { + associateWith(edge, associate); + } + KPolyline line = _kEdgeExtensions.addPolyline(edge); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(line); + _kPolylineExtensions.addJunctionPointDecorator(line); + if (multiport) { + // Render multiport connections and bank connections in bold. + _kRenderingExtensions.setLineWidth(line, 2.2f); + _kRenderingExtensions.setLineCap(line, LineCap.CAP_SQUARE); + // Adjust junction point size + _kPolylineExtensions.setJunctionPointDecorator(line, line.getJunctionPointRendering(), 6, 6); } + return edge; + } - /** - * Translate an input/output into a port. - */ - private KPort addIOPort(KNode node, PortInstance lfPort, boolean input, boolean multiport, boolean bank) { - KPort port = _kPortExtensions.createPort(); - node.getPorts().add(port); - associateWith(port, lfPort.getDefinition()); - NamedInstanceUtil.linkInstance(port, lfPort); - _kPortExtensions.setPortSize(port, 6, 6); - - if (input) { - // multiports are smaller by an offset at the right, hence compensate in inputs - double offset = multiport ? -3.4 : -3.3; - setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.WEST); - setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, offset); - } else { - double offset = multiport ? -2.6 : -3.3; // multiports are smaller - offset = bank ? offset - LinguaFrancaShapeExtensions.BANK_FIGURE_X_OFFSET_SUM : offset; // compensate bank figure width - setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.EAST); - setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, offset); - } + private KEdge createDependencyEdge(Object associate) { + KEdge edge = _kEdgeExtensions.createEdge(); + if (associate != null) { + associateWith(edge, associate); + } + KPolyline line = _kEdgeExtensions.addPolyline(edge); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(line); + _kPolylineExtensions.addJunctionPointDecorator(line); + if (getBooleanValue(USE_ALTERNATIVE_DASH_PATTERN)) { + _kRenderingExtensions.setLineStyle(line, LineStyle.CUSTOM); + _kRenderingExtensions.getLineStyle(line).getDashPattern().addAll(ALTERNATIVE_DASH_PATTERN); + } else { + _kRenderingExtensions.setLineStyle(line, LineStyle.DASH); + } + return edge; + } + + private KEdge createOrderEdge() { + KEdge edge = _kEdgeExtensions.createEdge(); + KPolyline line = _kEdgeExtensions.addPolyline(edge); + _kRenderingExtensions.setLineWidth(line, 1.5f); + _kRenderingExtensions.setLineStyle(line, LineStyle.DOT); + _kRenderingExtensions.setForeground(line, Colors.CHOCOLATE_1); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(line); + // addFixedTailArrowDecorator() // Fix for bug: https://github.com/kieler/KLighD/issues/38 + _kPolylineExtensions.addHeadArrowDecorator(line); + return edge; + } + + private KEdge connect(KEdge edge, KNode src, KNode dst) { + edge.setSource(src); + edge.setTarget(dst); + return edge; + } + + private KEdge connect(KEdge edge, KNode src, KPort dst) { + edge.setSource(src); + edge.setTargetPort(dst); + edge.setTarget(dst != null ? dst.getNode() : null); + return edge; + } + + private KEdge connect(KEdge edge, KPort src, KNode dst) { + edge.setSourcePort(src); + edge.setSource(src != null ? src.getNode() : null); + edge.setTarget(dst); + return edge; + } + + private KEdge connect(KEdge edge, KPort src, KPort dst) { + edge.setSourcePort(src); + edge.setSource(src != null ? src.getNode() : null); + edge.setTargetPort(dst); + edge.setTarget(dst != null ? dst.getNode() : null); + return edge; + } + + /** Translate an input/output into a port. */ + private KPort addIOPort( + KNode node, PortInstance lfPort, boolean input, boolean multiport, boolean bank) { + KPort port = _kPortExtensions.createPort(); + node.getPorts().add(port); + associateWith(port, lfPort.getDefinition()); + NamedInstanceUtil.linkInstance(port, lfPort); + _kPortExtensions.setPortSize(port, 6, 6); + + if (input) { + // multiports are smaller by an offset at the right, hence compensate in inputs + double offset = multiport ? -3.4 : -3.3; + setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.WEST); + setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, offset); + } else { + double offset = multiport ? -2.6 : -3.3; // multiports are smaller + offset = + bank + ? offset - LinguaFrancaShapeExtensions.BANK_FIGURE_X_OFFSET_SUM + : offset; // compensate bank figure width + setLayoutOption(port, CoreOptions.PORT_SIDE, PortSide.EAST); + setLayoutOption(port, CoreOptions.PORT_BORDER_OFFSET, offset); + } - if (bank && !node.getProperty(REACTOR_HAS_BANK_PORT_OFFSET)) {// compensate bank figure height - // https://github.com/eclipse/elk/issues/693 - _utilityExtensions.getPortMarginsInitIfAbsent(node).add( - new ElkMargin(0, 0, LinguaFrancaShapeExtensions.BANK_FIGURE_Y_OFFSET_SUM, 0)); - node.setProperty(REACTOR_HAS_BANK_PORT_OFFSET, true); // only once - } + if (bank && !node.getProperty(REACTOR_HAS_BANK_PORT_OFFSET)) { // compensate bank figure height + // https://github.com/eclipse/elk/issues/693 + _utilityExtensions + .getPortMarginsInitIfAbsent(node) + .add(new ElkMargin(0, 0, LinguaFrancaShapeExtensions.BANK_FIGURE_Y_OFFSET_SUM, 0)); + node.setProperty(REACTOR_HAS_BANK_PORT_OFFSET, true); // only once + } - _linguaFrancaShapeExtensions.addTrianglePort(port, multiport); + _linguaFrancaShapeExtensions.addTrianglePort(port, multiport); - String label = lfPort.getName(); - if (!getBooleanValue(SHOW_PORT_NAMES)) { - label = ""; - } - if (getBooleanValue(SHOW_MULTIPORT_WIDTH)) { - if (lfPort.isMultiport()) { - label += (lfPort.getWidth() >= 0) ? - "[" + lfPort.getWidth() + "]" : - "[?]"; - } - } - associateWith(_kLabelExtensions.addOutsidePortLabel(port, label, 8), lfPort.getDefinition()); - return port; + String label = lfPort.getName(); + if (!getBooleanValue(SHOW_PORT_NAMES)) { + label = ""; } - - private KPort addInvisiblePort(KNode node) { - KPort port = _kPortExtensions.createPort(); - node.getPorts().add(port); - port.setSize(0, 0); // invisible - return port; + if (getBooleanValue(SHOW_MULTIPORT_WIDTH)) { + if (lfPort.isMultiport()) { + label += (lfPort.getWidth() >= 0) ? "[" + lfPort.getWidth() + "]" : "[?]"; + } } - - private KNode addErrorComment(KNode node, String message) { + associateWith(_kLabelExtensions.addOutsidePortLabel(port, label, 8), lfPort.getDefinition()); + return port; + } + + private KPort addInvisiblePort(KNode node) { + KPort port = _kPortExtensions.createPort(); + node.getPorts().add(port); + port.setSize(0, 0); // invisible + return port; + } + + private KNode addErrorComment(KNode node, String message) { + KNode comment = _kNodeExtensions.createNode(); + setLayoutOption(comment, CoreOptions.COMMENT_BOX, true); + KRoundedRectangle commentFigure = + _linguaFrancaShapeExtensions.addCommentFigure(comment, message); + _linguaFrancaStyleExtensions.errorStyle(commentFigure); + _kRenderingExtensions.setBackground(commentFigure, Colors.PEACH_PUFF_2); + + // connect + KEdge edge = _kEdgeExtensions.createEdge(); + edge.setSource(comment); + edge.setTarget(node); + _linguaFrancaStyleExtensions.errorStyle(_linguaFrancaShapeExtensions.addCommentPolyline(edge)); + return comment; + } + + private Iterable createUserComments(EObject element, KNode targetNode) { + if (getBooleanValue(SHOW_USER_LABELS)) { + String commentText = AttributeUtils.getLabel(element); + + if (!StringExtensions.isNullOrEmpty(commentText)) { KNode comment = _kNodeExtensions.createNode(); setLayoutOption(comment, CoreOptions.COMMENT_BOX, true); - KRoundedRectangle commentFigure = _linguaFrancaShapeExtensions.addCommentFigure(comment, message); - _linguaFrancaStyleExtensions.errorStyle(commentFigure); - _kRenderingExtensions.setBackground(commentFigure, Colors.PEACH_PUFF_2); + KRoundedRectangle commentFigure = + _linguaFrancaShapeExtensions.addCommentFigure(comment, commentText); + _linguaFrancaStyleExtensions.commentStyle(commentFigure); // connect KEdge edge = _kEdgeExtensions.createEdge(); edge.setSource(comment); - edge.setTarget(node); - _linguaFrancaStyleExtensions.errorStyle(_linguaFrancaShapeExtensions.addCommentPolyline(edge)); - return comment; - } - - private Iterable createUserComments(EObject element, KNode targetNode) { - if (getBooleanValue(SHOW_USER_LABELS)) { - String commentText = AttributeUtils.getLabel(element); - - if (!StringExtensions.isNullOrEmpty(commentText)) { - KNode comment = _kNodeExtensions.createNode(); - setLayoutOption(comment, CoreOptions.COMMENT_BOX, true); - KRoundedRectangle commentFigure = _linguaFrancaShapeExtensions.addCommentFigure(comment, commentText); - _linguaFrancaStyleExtensions.commentStyle(commentFigure); + edge.setTarget(targetNode); + _linguaFrancaStyleExtensions.commentStyle( + _linguaFrancaShapeExtensions.addCommentPolyline(edge)); - // connect - KEdge edge = _kEdgeExtensions.createEdge(); - edge.setSource(comment); - edge.setTarget(targetNode); - _linguaFrancaStyleExtensions.commentStyle(_linguaFrancaShapeExtensions.addCommentPolyline(edge)); - - return List.of(comment); - } - } - return List.of(); + return List.of(comment); + } } - + return List.of(); + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java b/org.lflang/src/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java index 23365eeff9..dba7c94dde 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java @@ -1,47 +1,51 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis; /** * Enumeration of different display options for reactor parameters. - * + * * @author Alexander Schulz-Rosengarten */ public enum ReactorParameterDisplayModes { - NONE, - TITLE, - TABLE; - - @Override - public String toString() { - switch(this) { - case NONE: return "None"; - case TITLE: return "List in Title"; - case TABLE: return "Table in Body"; - default: return ""; - } + NONE, + TITLE, + TABLE; + + @Override + public String toString() { + switch (this) { + case NONE: + return "None"; + case TITLE: + return "List in Title"; + case TABLE: + return "Table in Body"; + default: + return ""; } + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/SynthesisRegistration.java b/org.lflang/src/org/lflang/diagram/synthesis/SynthesisRegistration.java index f1e217b9f1..c48d2e59ee 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/SynthesisRegistration.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/SynthesisRegistration.java @@ -1,5 +1,7 @@ package org.lflang.diagram.synthesis; +import de.cau.cs.kieler.klighd.IKlighdStartupHook; +import de.cau.cs.kieler.klighd.KlighdDataManager; import org.lflang.diagram.synthesis.action.CollapseAllReactorsAction; import org.lflang.diagram.synthesis.action.ExpandAllReactorsAction; import org.lflang.diagram.synthesis.action.FilterCycleAction; @@ -10,43 +12,42 @@ import org.lflang.diagram.synthesis.styles.LinguaFrancaStyleExtensions; import org.lflang.diagram.synthesis.util.NamedInstanceUtil; -import de.cau.cs.kieler.klighd.IKlighdStartupHook; -import de.cau.cs.kieler.klighd.KlighdDataManager; - /** * Registration of all diagram synthesis related classes in Klighd. - * + * * @author Alexander Schulz-Rosengarten */ public class SynthesisRegistration implements IKlighdStartupHook { - - @Override - public void execute() { - KlighdDataManager reg = KlighdDataManager.getInstance(); - - // Synthesis - reg.registerDiagramSynthesisClass(LinguaFrancaSynthesis.ID, LinguaFrancaSynthesis.class); - - // Actions - reg.registerAction(MemorizingExpandCollapseAction.ID, new MemorizingExpandCollapseAction()); - reg.registerAction(ExpandAllReactorsAction.ID, new ExpandAllReactorsAction()); - reg.registerAction(CollapseAllReactorsAction.ID, new CollapseAllReactorsAction()); - reg.registerAction(ShowCycleAction.ID, new ShowCycleAction()); - reg.registerAction(FilterCycleAction.ID, new FilterCycleAction()); - - // Style Mod - reg.registerStyleModifier(ReactionPortAdjustment.ID, new ReactionPortAdjustment()); - - // Blacklist LF-specific properties that should be removed when a diagram is sent from the diagram server to a client. - reg.registerBlacklistedProperty(FilterCycleAction.FILTER_BUTTON); - reg.registerBlacklistedProperty(LinguaFrancaSynthesis.REACTOR_HAS_BANK_PORT_OFFSET); - reg.registerBlacklistedProperty(LinguaFrancaSynthesis.REACTOR_INPUT); - reg.registerBlacklistedProperty(LinguaFrancaSynthesis.REACTOR_OUTPUT); - reg.registerBlacklistedProperty(LinguaFrancaSynthesis.REACTION_SPECIAL_TRIGGER); - reg.registerBlacklistedProperty(ReactionPortAdjustment.PROCESSED); - reg.registerBlacklistedProperty(LinguaFrancaShapeExtensions.REACTOR_CONTENT_CONTAINER); - reg.registerBlacklistedProperty(LinguaFrancaStyleExtensions.LABEL_PARENT_BACKGROUND); - reg.registerBlacklistedProperty(NamedInstanceUtil.LINKED_INSTANCE); // Very important since its values can not be synthesized easily! - } - + + @Override + public void execute() { + KlighdDataManager reg = KlighdDataManager.getInstance(); + + // Synthesis + reg.registerDiagramSynthesisClass(LinguaFrancaSynthesis.ID, LinguaFrancaSynthesis.class); + + // Actions + reg.registerAction(MemorizingExpandCollapseAction.ID, new MemorizingExpandCollapseAction()); + reg.registerAction(ExpandAllReactorsAction.ID, new ExpandAllReactorsAction()); + reg.registerAction(CollapseAllReactorsAction.ID, new CollapseAllReactorsAction()); + reg.registerAction(ShowCycleAction.ID, new ShowCycleAction()); + reg.registerAction(FilterCycleAction.ID, new FilterCycleAction()); + + // Style Mod + reg.registerStyleModifier(ReactionPortAdjustment.ID, new ReactionPortAdjustment()); + + // Blacklist LF-specific properties that should be removed when a diagram is sent from the + // diagram server to a client. + reg.registerBlacklistedProperty(FilterCycleAction.FILTER_BUTTON); + reg.registerBlacklistedProperty(LinguaFrancaSynthesis.REACTOR_HAS_BANK_PORT_OFFSET); + reg.registerBlacklistedProperty(LinguaFrancaSynthesis.REACTOR_INPUT); + reg.registerBlacklistedProperty(LinguaFrancaSynthesis.REACTOR_OUTPUT); + reg.registerBlacklistedProperty(LinguaFrancaSynthesis.REACTION_SPECIAL_TRIGGER); + reg.registerBlacklistedProperty(ReactionPortAdjustment.PROCESSED); + reg.registerBlacklistedProperty(LinguaFrancaShapeExtensions.REACTOR_CONTENT_CONTAINER); + reg.registerBlacklistedProperty(LinguaFrancaStyleExtensions.LABEL_PARENT_BACKGROUND); + reg.registerBlacklistedProperty( + NamedInstanceUtil + .LINKED_INSTANCE); // Very important since its values can not be synthesized easily! + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/AbstractAction.java b/org.lflang/src/org/lflang/diagram/synthesis/action/AbstractAction.java index d665dff433..e840b99077 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/action/AbstractAction.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/action/AbstractAction.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.action; import de.cau.cs.kieler.klighd.IAction; @@ -32,24 +32,23 @@ /** * Abstract super class for diagram actions that provides some convince methods. - * + * * @author Alexander Schulz-Rosengarten */ public abstract class AbstractAction implements IAction { - public Object sourceElement(final KGraphElement elem) { - return elem.getProperty(KlighdInternalProperties.MODEL_ELEMEMT); - } - - public boolean sourceIs(KNode node, Class clazz) { - return clazz.isInstance(sourceElement(node)); - } - - public boolean sourceIsReactor(final KNode node) { - return sourceElement(node) instanceof Reactor; - } - - public Reactor sourceAsReactor(final KNode node) { - return sourceIsReactor(node) ? (Reactor) sourceElement(node) : null; - } + public Object sourceElement(final KGraphElement elem) { + return elem.getProperty(KlighdInternalProperties.MODEL_ELEMEMT); + } + + public boolean sourceIs(KNode node, Class clazz) { + return clazz.isInstance(sourceElement(node)); + } + + public boolean sourceIsReactor(final KNode node) { + return sourceElement(node) instanceof Reactor; + } + + public Reactor sourceAsReactor(final KNode node) { + return sourceIsReactor(node) ? (Reactor) sourceElement(node) : null; + } } - \ No newline at end of file diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java b/org.lflang/src/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java index 0927caeb37..712e9d9e66 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.action; import de.cau.cs.kieler.klighd.IAction; @@ -29,36 +29,32 @@ import de.cau.cs.kieler.klighd.kgraph.KNode; import de.cau.cs.kieler.klighd.util.ModelingUtil; import java.util.Iterator; -import org.eclipse.xtext.xbase.lib.IteratorExtensions; import org.lflang.diagram.synthesis.util.NamedInstanceUtil; import org.lflang.lf.Mode; /** * Action that expands (shows details) of all reactor nodes. - * + * * @author Alexander Schulz-Rosengarten */ public class CollapseAllReactorsAction extends AbstractAction { - - public static final String ID = "org.lflang.diagram.synthesis.action.CollapseAllReactorsAction"; - - @Override - public IAction.ActionResult execute(final IAction.ActionContext context) { - ViewContext vc = context.getViewContext(); - Iterator nodes = ModelingUtil.eAllContentsOfType(vc.getViewModel(), KNode.class); - - while(nodes.hasNext()) { - var node = nodes.next(); - if (sourceIs(node, Mode.class) || (sourceIsReactor(node) && - !(sourceAsReactor(node).isMain() || sourceAsReactor(node).isFederated()))) { - MemorizingExpandCollapseAction.setExpansionState( - node, - NamedInstanceUtil.getLinkedInstance(node), - vc.getViewer(), - false - ); - } - } - return IAction.ActionResult.createResult(true); + + public static final String ID = "org.lflang.diagram.synthesis.action.CollapseAllReactorsAction"; + + @Override + public IAction.ActionResult execute(final IAction.ActionContext context) { + ViewContext vc = context.getViewContext(); + Iterator nodes = ModelingUtil.eAllContentsOfType(vc.getViewModel(), KNode.class); + + while (nodes.hasNext()) { + var node = nodes.next(); + if (sourceIs(node, Mode.class) + || (sourceIsReactor(node) + && !(sourceAsReactor(node).isMain() || sourceAsReactor(node).isFederated()))) { + MemorizingExpandCollapseAction.setExpansionState( + node, NamedInstanceUtil.getLinkedInstance(node), vc.getViewer(), false); + } } + return IAction.ActionResult.createResult(true); + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java b/org.lflang/src/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java index 08f8b5a115..bdd7c173d6 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.action; import de.cau.cs.kieler.klighd.IAction; @@ -29,36 +29,30 @@ import de.cau.cs.kieler.klighd.kgraph.KNode; import de.cau.cs.kieler.klighd.util.ModelingUtil; import java.util.Iterator; -import org.eclipse.xtext.xbase.lib.IteratorExtensions; import org.lflang.diagram.synthesis.util.NamedInstanceUtil; import org.lflang.lf.Mode; /** * Action that collapses (hides details) of all reactor nodes. - * + * * @author Alexander Schulz-Rosengarten */ public class ExpandAllReactorsAction extends AbstractAction { - public static final String ID = "org.lflang.diagram.synthesis.action.ExpandAllReactorsAction"; - - @Override - public IAction.ActionResult execute(final IAction.ActionContext context) { - ViewContext vc = context.getViewContext(); - Iterator nodes = ModelingUtil.eAllContentsOfType(vc.getViewModel(), KNode.class); - - while(nodes.hasNext()) { - var node = nodes.next(); - if (sourceIs(node, Mode.class) || sourceIsReactor(node)) { - MemorizingExpandCollapseAction.setExpansionState( - node, - NamedInstanceUtil.getLinkedInstance(node), - vc.getViewer(), - true - ); - } - } - return IAction.ActionResult.createResult(true); + public static final String ID = "org.lflang.diagram.synthesis.action.ExpandAllReactorsAction"; + + @Override + public IAction.ActionResult execute(final IAction.ActionContext context) { + ViewContext vc = context.getViewContext(); + Iterator nodes = ModelingUtil.eAllContentsOfType(vc.getViewModel(), KNode.class); + + while (nodes.hasNext()) { + var node = nodes.next(); + if (sourceIs(node, Mode.class) || sourceIsReactor(node)) { + MemorizingExpandCollapseAction.setExpansionState( + node, NamedInstanceUtil.getLinkedInstance(node), vc.getViewer(), true); + } } + return IAction.ActionResult.createResult(true); + } } - \ No newline at end of file diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/FilterCycleAction.java b/org.lflang/src/org/lflang/diagram/synthesis/action/FilterCycleAction.java index 6daf07a1b3..bbe20806a3 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/action/FilterCycleAction.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/action/FilterCycleAction.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.action; import com.google.common.collect.Iterables; @@ -31,7 +31,6 @@ import de.cau.cs.kieler.klighd.kgraph.KEdge; import de.cau.cs.kieler.klighd.kgraph.KNode; import de.cau.cs.kieler.klighd.krendering.KText; - import java.util.Iterator; import java.util.List; import java.util.WeakHashMap; @@ -46,112 +45,115 @@ /** * Action that filters the diagram for only those elements included in a cycle. - * + * * @author Alexander Schulz-Rosengarten */ public class FilterCycleAction extends AbstractAction { - - public static final String ID = "org.lflang.diagram.synthesis.action.FilterCycleAction"; - - /** - * Memory-leak-free cache of filtered states - */ - private static final WeakHashMap FILTERING_STATES = new WeakHashMap<>(); - - /** - * INTERNAL property to mark filter button. - */ - public static final Property FILTER_BUTTON = new Property<>("org.lflang.diagram.synthesis.action.cyclefilter.button", false); - - @Override - public IAction.ActionResult execute(final IAction.ActionContext context) { - ViewContext vc = context.getViewContext(); - Object all = vc.getOptionValue(LinguaFrancaSynthesis.SHOW_ALL_REACTORS); - List nodes = vc.getViewModel().getChildren(); - - if (all instanceof Boolean && (Boolean) all) { - nodes = IterableExtensions.toList( - Iterables.concat( - ListExtensions.map( - nodes, it -> { return it.getChildren(); } - ) - ) - ); - } - if (IterableExtensions.exists(nodes, this::isCycleFiltered)) { - // undo - nodes.forEach(this::resetCycleFiltering); - - // re-synthesize everything - vc.getViewModel().getChildren().clear(); - vc.update(); - } else { - // filter - nodes.forEach(it -> { - this.markCycleFiltered(it); - this.filterCycle(it); - }); - - Function1 knodeFilterButton = it -> { - return it.getProperty(FILTER_BUTTON); - }; - - Function1 ktextFilterButton = it -> { - return it.getProperty(FILTER_BUTTON); - }; - - // switch filter label - for (KNode node : IterableExtensions.filter(nodes, knodeFilterButton)) { - Iterator ktexts = Iterators.filter(node.eAllContents(), KText.class); - KText text = IteratorExtensions.findFirst(ktexts, ktextFilterButton); - if (text != null) { - text.setText(LinguaFrancaSynthesis.TEXT_ERROR_CYCLE_BTN_UNFILTER); - } - } + public static final String ID = "org.lflang.diagram.synthesis.action.FilterCycleAction"; + + /** Memory-leak-free cache of filtered states */ + private static final WeakHashMap FILTERING_STATES = new WeakHashMap<>(); + + /** INTERNAL property to mark filter button. */ + public static final Property FILTER_BUTTON = + new Property<>("org.lflang.diagram.synthesis.action.cyclefilter.button", false); + + @Override + public IAction.ActionResult execute(final IAction.ActionContext context) { + ViewContext vc = context.getViewContext(); + Object all = vc.getOptionValue(LinguaFrancaSynthesis.SHOW_ALL_REACTORS); + List nodes = vc.getViewModel().getChildren(); + + if (all instanceof Boolean && (Boolean) all) { + nodes = + IterableExtensions.toList( + Iterables.concat( + ListExtensions.map( + nodes, + it -> { + return it.getChildren(); + }))); + } + + if (IterableExtensions.exists(nodes, this::isCycleFiltered)) { + // undo + nodes.forEach(this::resetCycleFiltering); + + // re-synthesize everything + vc.getViewModel().getChildren().clear(); + vc.update(); + } else { + // filter + nodes.forEach( + it -> { + this.markCycleFiltered(it); + this.filterCycle(it); + }); + + Function1 knodeFilterButton = + it -> { + return it.getProperty(FILTER_BUTTON); + }; + + Function1 ktextFilterButton = + it -> { + return it.getProperty(FILTER_BUTTON); + }; + + // switch filter label + for (KNode node : IterableExtensions.filter(nodes, knodeFilterButton)) { + Iterator ktexts = Iterators.filter(node.eAllContents(), KText.class); + KText text = IteratorExtensions.findFirst(ktexts, ktextFilterButton); + if (text != null) { + text.setText(LinguaFrancaSynthesis.TEXT_ERROR_CYCLE_BTN_UNFILTER); } - - return IAction.ActionResult.createResult(true); + } } - - public void filterCycle(KNode root) { - Predicate knodeNotInCycle = it -> { - return !it.getProperty(CycleVisualization.DEPENDENCY_CYCLE); + + return IAction.ActionResult.createResult(true); + } + + public void filterCycle(KNode root) { + Predicate knodeNotInCycle = + it -> { + return !it.getProperty(CycleVisualization.DEPENDENCY_CYCLE); }; - - Predicate kedgeNotInCycle = it -> { - return !it.getProperty(CycleVisualization.DEPENDENCY_CYCLE); + + Predicate kedgeNotInCycle = + it -> { + return !it.getProperty(CycleVisualization.DEPENDENCY_CYCLE); }; - - root.getChildren().removeIf(knodeNotInCycle); - for (KNode node : root.getChildren()) { - node.getOutgoingEdges().removeIf(kedgeNotInCycle); - this.filterCycle(node); - } - } - public void markCycleFiltered(KNode node) { - Object source = this.sourceElement(node); - if (source != null) { - FILTERING_STATES.put(source, true); - } - } - - public void resetCycleFiltering(KNode node) { - Object source = this.sourceElement(node); - if (source != null) { - FILTERING_STATES.remove(source); - } + root.getChildren().removeIf(knodeNotInCycle); + for (KNode node : root.getChildren()) { + node.getOutgoingEdges().removeIf(kedgeNotInCycle); + this.filterCycle(node); } + } - public boolean isCycleFiltered(KNode node) { - Object source = this.sourceElement(node); - Boolean result = FILTERING_STATES.get(source); - return result == null ? false : result; + public void markCycleFiltered(KNode node) { + Object source = this.sourceElement(node); + if (source != null) { + FILTERING_STATES.put(source, true); } + } - public void markCycleFilterText(KText text, KNode node) { - text.setProperty(FILTER_BUTTON, true); - node.setProperty(FILTER_BUTTON, true); + public void resetCycleFiltering(KNode node) { + Object source = this.sourceElement(node); + if (source != null) { + FILTERING_STATES.remove(source); } + } + + public boolean isCycleFiltered(KNode node) { + Object source = this.sourceElement(node); + Boolean result = FILTERING_STATES.get(source); + return result == null ? false : result; + } + + public void markCycleFilterText(KText text, KNode node) { + text.setProperty(FILTER_BUTTON, true); + node.setProperty(FILTER_BUTTON, true); + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java b/org.lflang/src/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java index 20347e2c22..b9a91fe08c 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java @@ -1,123 +1,119 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.action; -import java.util.WeakHashMap; - -import org.lflang.diagram.synthesis.util.InterfaceDependenciesVisualization; -import org.lflang.diagram.synthesis.util.NamedInstanceUtil; -import org.lflang.generator.NamedInstance; -import org.lflang.generator.ReactorInstance; - import com.google.common.base.Preconditions; - import de.cau.cs.kieler.klighd.IAction; import de.cau.cs.kieler.klighd.IViewer; import de.cau.cs.kieler.klighd.SynthesisOption; import de.cau.cs.kieler.klighd.ViewContext; import de.cau.cs.kieler.klighd.kgraph.KNode; +import java.util.WeakHashMap; +import org.lflang.diagram.synthesis.util.InterfaceDependenciesVisualization; +import org.lflang.diagram.synthesis.util.NamedInstanceUtil; +import org.lflang.generator.NamedInstance; +import org.lflang.generator.ReactorInstance; /** - * Action for toggling collapse/expand state of reactors that memorizes the state and - * allows correct initialization synthesis runs for the same model. - * Prevents automatic collapsing of manually expanded nodes. - * + * Action for toggling collapse/expand state of reactors that memorizes the state and allows correct + * initialization synthesis runs for the same model. Prevents automatic collapsing of manually + * expanded nodes. + * * @author Alexander Schulz-Rosengarten */ public class MemorizingExpandCollapseAction extends AbstractAction { - - public static final String ID = "org.lflang.diagram.synthesis.action.MemorizingExpandCollapseAction"; - - /** - * The related synthesis option - */ - public static final SynthesisOption MEMORIZE_EXPANSION_STATES = SynthesisOption.createCheckOption("Remember Collapsed/Expanded Reactors", true); - - /** - * Memory-leak-free cache of expansion states - */ - private static final WeakHashMap EXPANSION_STATES = new WeakHashMap<>(); - - /** - * Sets the expansion state of a node and saves it for future synthesis. - */ - public static void setExpansionState(final KNode node, final Object memorizableObj, final IViewer viewer, final boolean expand) { - Preconditions.checkNotNull(node); - - // Store new state if activated - if (((Boolean) viewer.getViewContext().getOptionValue(MEMORIZE_EXPANSION_STATES)) && memorizableObj != null) { - if (memorizableObj instanceof NamedInstance) { - EXPANSION_STATES.put(((NamedInstance) memorizableObj).uniqueID(), expand); - } else { - EXPANSION_STATES.put(memorizableObj, expand); - } - } - - // Apply state - if (expand) { - viewer.expand(node); - } else { - viewer.collapse(node); - } - - // Handle edges that should only appear for one of the renderings - InterfaceDependenciesVisualization.updateInterfaceDependencyVisibility(node, expand); + public static final String ID = + "org.lflang.diagram.synthesis.action.MemorizingExpandCollapseAction"; + + /** The related synthesis option */ + public static final SynthesisOption MEMORIZE_EXPANSION_STATES = + SynthesisOption.createCheckOption("Remember Collapsed/Expanded Reactors", true); + + /** Memory-leak-free cache of expansion states */ + private static final WeakHashMap EXPANSION_STATES = new WeakHashMap<>(); + + /** Sets the expansion state of a node and saves it for future synthesis. */ + public static void setExpansionState( + final KNode node, final Object memorizableObj, final IViewer viewer, final boolean expand) { + + Preconditions.checkNotNull(node); + + // Store new state if activated + if (((Boolean) viewer.getViewContext().getOptionValue(MEMORIZE_EXPANSION_STATES)) + && memorizableObj != null) { + if (memorizableObj instanceof NamedInstance) { + EXPANSION_STATES.put(((NamedInstance) memorizableObj).uniqueID(), expand); + } else { + EXPANSION_STATES.put(memorizableObj, expand); + } } - - /** - * @return the memorized expansion state of the given model element or null if not memorized - */ - public static Boolean getExpansionState(final Object obj) { - if (obj instanceof NamedInstance) { - return EXPANSION_STATES.get(((NamedInstance) obj).uniqueID()); - } - return EXPANSION_STATES.get(obj); + + // Apply state + if (expand) { + viewer.expand(node); + } else { + viewer.collapse(node); } - - //----------------------------------------------------------------------------------------------------------------- - - @Override - public IAction.ActionResult execute(final IAction.ActionContext context) { - ViewContext vc = context.getViewContext(); - IViewer v = vc.getViewer(); - KNode node = context.getKNode(); - NamedInstance linkedInstance = NamedInstanceUtil.getLinkedInstance(node); - - // Find node that is properly linked - while(node != null && linkedInstance == null) { - node = node.getParent(); - linkedInstance = NamedInstanceUtil.getLinkedInstance(node); - } - - if (node == null || (linkedInstance instanceof ReactorInstance && ((ReactorInstance) linkedInstance).isMainOrFederated())) { - return IAction.ActionResult.createResult(false); - } else { - setExpansionState(node, linkedInstance, v, !v.isExpanded(node)); // toggle - return IAction.ActionResult.createResult(true); - } + + // Handle edges that should only appear for one of the renderings + InterfaceDependenciesVisualization.updateInterfaceDependencyVisibility(node, expand); + } + + /** + * @return the memorized expansion state of the given model element or null if not memorized + */ + public static Boolean getExpansionState(final Object obj) { + if (obj instanceof NamedInstance) { + return EXPANSION_STATES.get(((NamedInstance) obj).uniqueID()); + } + return EXPANSION_STATES.get(obj); + } + + // ----------------------------------------------------------------------------------------------------------------- + + @Override + public IAction.ActionResult execute(final IAction.ActionContext context) { + ViewContext vc = context.getViewContext(); + IViewer v = vc.getViewer(); + KNode node = context.getKNode(); + NamedInstance linkedInstance = NamedInstanceUtil.getLinkedInstance(node); + + // Find node that is properly linked + while (node != null && linkedInstance == null) { + node = node.getParent(); + linkedInstance = NamedInstanceUtil.getLinkedInstance(node); + } + + if (node == null + || (linkedInstance instanceof ReactorInstance + && ((ReactorInstance) linkedInstance).isMainOrFederated())) { + return IAction.ActionResult.createResult(false); + } else { + setExpansionState(node, linkedInstance, v, !v.isExpanded(node)); // toggle + return IAction.ActionResult.createResult(true); } - + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/ShowCycleAction.java b/org.lflang/src/org/lflang/diagram/synthesis/action/ShowCycleAction.java index fb947511e4..5640adc424 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/action/ShowCycleAction.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/action/ShowCycleAction.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.action; import de.cau.cs.kieler.klighd.IAction; @@ -31,61 +31,58 @@ import java.util.Iterator; import java.util.LinkedList; import java.util.Set; - import org.eclipse.xtext.xbase.lib.IteratorExtensions; import org.lflang.diagram.synthesis.util.CycleVisualization; import org.lflang.diagram.synthesis.util.NamedInstanceUtil; /** * Action that expands all reactor nodes that are included in a cycle. - * + * * @author Alexander Schulz-Rosengarten */ public class ShowCycleAction extends AbstractAction { - - public static final String ID = "org.lflang.diagram.synthesis.action.ShowCycleAction"; - private static final CollapseAllReactorsAction collapseAll = new CollapseAllReactorsAction(); - - @Override - public IAction.ActionResult execute(final IAction.ActionContext context) { - ViewContext vc = context.getViewContext(); - - // Collapse all - collapseAll.execute(context); - - // Expand only errors - Iterator knodes = ModelingUtil.eAllContentsOfType(vc.getViewModel(), KNode.class); - - // Filter out nodes that are not in cycle or not a reactor - knodes = IteratorExtensions.filter(knodes, it -> { - return it.getProperty(CycleVisualization.DEPENDENCY_CYCLE) && sourceIsReactor(it); - }); - - // Remove duplicates - Set cycleNodes = IteratorExtensions.toSet(knodes); + public static final String ID = "org.lflang.diagram.synthesis.action.ShowCycleAction"; + + private static final CollapseAllReactorsAction collapseAll = new CollapseAllReactorsAction(); + + @Override + public IAction.ActionResult execute(final IAction.ActionContext context) { + ViewContext vc = context.getViewContext(); + + // Collapse all + collapseAll.execute(context); + + // Expand only errors + Iterator knodes = ModelingUtil.eAllContentsOfType(vc.getViewModel(), KNode.class); - // Include parents - LinkedList check = new LinkedList<>(cycleNodes); + // Filter out nodes that are not in cycle or not a reactor + knodes = + IteratorExtensions.filter( + knodes, + it -> { + return it.getProperty(CycleVisualization.DEPENDENCY_CYCLE) && sourceIsReactor(it); + }); + + // Remove duplicates + Set cycleNodes = IteratorExtensions.toSet(knodes); + + // Include parents + LinkedList check = new LinkedList<>(cycleNodes); + + while (!check.isEmpty()) { + KNode parent = check.pop().getParent(); + if (parent != null && !cycleNodes.contains(parent)) { + cycleNodes.add(parent); + check.add(parent); + } + } - while (!check.isEmpty()) { - KNode parent = check.pop().getParent(); - if (parent != null && !cycleNodes.contains(parent)) { - cycleNodes.add(parent); - check.add(parent); - } - } - - // Expand - for (KNode node : cycleNodes) { - MemorizingExpandCollapseAction.setExpansionState( - node, - NamedInstanceUtil.getLinkedInstance(node), - vc.getViewer(), - true - ); - } - return IAction.ActionResult.createResult(true); + // Expand + for (KNode node : cycleNodes) { + MemorizingExpandCollapseAction.setExpansionState( + node, NamedInstanceUtil.getLinkedInstance(node), vc.getViewer(), true); } - + return IAction.ActionResult.createResult(true); + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java b/org.lflang/src/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java index db3a42fd7a..4507039b28 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java @@ -1,39 +1,29 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.postprocessor; -import java.util.stream.Collectors; - -import org.eclipse.elk.core.options.CoreOptions; -import org.eclipse.elk.core.options.PortSide; -import org.eclipse.elk.graph.properties.Property; -import org.eclipse.xtext.xbase.lib.Extension; -import org.eclipse.xtext.xbase.lib.IterableExtensions; -import org.eclipse.xtext.xbase.lib.Pair; -import org.lflang.diagram.synthesis.styles.LinguaFrancaShapeExtensions; - import de.cau.cs.kieler.klighd.IStyleModifier; import de.cau.cs.kieler.klighd.IViewer; import de.cau.cs.kieler.klighd.internal.ILayoutRecorder; @@ -45,142 +35,159 @@ import de.cau.cs.kieler.klighd.kgraph.KPort; import de.cau.cs.kieler.klighd.krendering.KRendering; import de.cau.cs.kieler.klighd.krendering.KRenderingFactory; +import java.util.stream.Collectors; +import org.eclipse.elk.core.options.CoreOptions; +import org.eclipse.elk.core.options.PortSide; +import org.eclipse.elk.graph.properties.Property; +import org.eclipse.xtext.xbase.lib.Extension; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.Pair; +import org.lflang.diagram.synthesis.styles.LinguaFrancaShapeExtensions; /** - * Adjusts the port position of reactions node AFTER layout, to allow free port order but also adapt (snuggle) to pointy shape of reaction node. - * + * Adjusts the port position of reactions node AFTER layout, to allow free port order but also adapt + * (snuggle) to pointy shape of reaction node. + * * @author Alexander Schulz-Rosengarten */ public class ReactionPortAdjustment implements IStyleModifier { - public static final String ID = "org.lflang.diagram.synthesis.postprocessor.ReactionPortAdjustment"; - - /** - * INTERNAL property to mark node as processed. - */ - public static final Property PROCESSED = new Property<>("org.lflang.diagram.synthesis.postprocessor.reaction.ports.processed", false); - - @Extension - private KGraphFactory _kGraphFactory = KGraphFactory.eINSTANCE; - private static KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; - - /** - * Register this modifier on a reaction rendering. - */ - public static void apply(KNode node, KRendering rendering) { - // Add modifier that fixes port positions such that edges are properly attached to the shape - var invisible = _kRenderingFactory.createKInvisibility(); - invisible.setInvisible(false); // make it ineffective (just for purpose of holding modifier) - invisible.setModifierId(ReactionPortAdjustment.ID); // Add modifier to receive callback after layout - rendering.getStyles().add(invisible); - node.setProperty(PROCESSED, false); - } + public static final String ID = + "org.lflang.diagram.synthesis.postprocessor.ReactionPortAdjustment"; - @Override - public boolean modify(IStyleModifier.StyleModificationContext context) { - try { - KGraphElement node = context.getGraphElement(); - if (node instanceof KNode) { - KNode knode = (KNode) node; - - // Find root node - KNode parent = knode; - while (parent.eContainer() != null) { - parent = (KNode) parent.eContainer(); - } - - // Get viewer (this is a bit brittle because it fetches the viewer from some internal property) - Object viewer = - parent.getAllProperties().entrySet().stream().filter(entry -> - entry.getKey().getId().equals("de.cau.cs.kieler.klighd.viewer") - || entry.getKey().getId().equals("klighd.layout.viewer")) - .findAny().map(entry -> entry.getValue()).orElse(null); - - ILayoutRecorder recorder = null; - if (viewer instanceof IViewer) { - recorder = ((IViewer) viewer).getViewContext().getLayoutRecorder(); - } - - if (!knode.getPorts().isEmpty()) { - if (IterableExtensions.head(knode.getPorts()).getYpos() != 0 && - // Only adjust if layout is already applied important for incremental update animation - !knode.getProperty(ReactionPortAdjustment.PROCESSED)) { - if (recorder != null) { - recorder.startRecording(); - } - - var in = knode.getPorts().stream().filter(p -> - p.getProperty(CoreOptions.PORT_SIDE) == PortSide.WEST).sorted((p1, p2) -> - Float.compare(p1.getYpos(), p2.getYpos())).collect(Collectors.toList()); - - var out = knode.getPorts().stream().filter(p -> - p.getProperty(CoreOptions.PORT_SIDE) == PortSide.EAST).sorted((p1, p2) -> - Float.compare(p1.getYpos(), p2.getYpos())).collect(Collectors.toList()); - - // Adjust - if (in.stream().anyMatch(p -> !p.hasProperty(CoreOptions.PORT_BORDER_OFFSET))) { - adjustPositions(IterableExtensions.indexed(in), in.size(), true); - } - if (out.stream().anyMatch(p -> !p.hasProperty(CoreOptions.PORT_BORDER_OFFSET))) { - adjustPositions(IterableExtensions.indexed(out), out.size(), false); - } - knode.setProperty(ReactionPortAdjustment.PROCESSED, true); - - if (recorder!=null) { - recorder.stopRecording(0); - } - - } else if (IterableExtensions.head(knode.getPorts()).getYpos() == 0) { - knode.setProperty(PROCESSED, false); - } - } - } - } catch (Exception e) { - e.printStackTrace(); - // do not disturb rendering process + /** INTERNAL property to mark node as processed. */ + public static final Property PROCESSED = + new Property<>("org.lflang.diagram.synthesis.postprocessor.reaction.ports.processed", false); + + @Extension private KGraphFactory _kGraphFactory = KGraphFactory.eINSTANCE; + private static KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; + + /** Register this modifier on a reaction rendering. */ + public static void apply(KNode node, KRendering rendering) { + // Add modifier that fixes port positions such that edges are properly attached to the shape + var invisible = _kRenderingFactory.createKInvisibility(); + invisible.setInvisible(false); // make it ineffective (just for purpose of holding modifier) + invisible.setModifierId( + ReactionPortAdjustment.ID); // Add modifier to receive callback after layout + rendering.getStyles().add(invisible); + node.setProperty(PROCESSED, false); + } + + @Override + public boolean modify(IStyleModifier.StyleModificationContext context) { + try { + KGraphElement node = context.getGraphElement(); + if (node instanceof KNode) { + KNode knode = (KNode) node; + + // Find root node + KNode parent = knode; + while (parent.eContainer() != null) { + parent = (KNode) parent.eContainer(); } - return false; - } - public void adjustPositions(Iterable> indexedPorts, int count, boolean input) { - float segments = LinguaFrancaShapeExtensions.REACTION_POINTINESS * 2 / (count + 1); - for (Pair indexedPort : indexedPorts) { - KPort port = indexedPort.getValue(); - int idx = indexedPort.getKey(); - float offset = 0; - - if (count % 2 != 0 && idx == count / 2) { - offset += LinguaFrancaShapeExtensions.REACTION_POINTINESS; - } else if (idx < count / 2) { - offset += segments * (idx + 1); - } else { - offset += segments * (count - idx); + // Get viewer (this is a bit brittle because it fetches the viewer from some internal + // property) + Object viewer = + parent.getAllProperties().entrySet().stream() + .filter( + entry -> + entry.getKey().getId().equals("de.cau.cs.kieler.klighd.viewer") + || entry.getKey().getId().equals("klighd.layout.viewer")) + .findAny() + .map(entry -> entry.getValue()) + .orElse(null); + + ILayoutRecorder recorder = null; + if (viewer instanceof IViewer) { + recorder = ((IViewer) viewer).getViewContext().getLayoutRecorder(); + } + + if (!knode.getPorts().isEmpty()) { + if (IterableExtensions.head(knode.getPorts()).getYpos() != 0 + && + // Only adjust if layout is already applied important for incremental update animation + !knode.getProperty(ReactionPortAdjustment.PROCESSED)) { + if (recorder != null) { + recorder.startRecording(); } - - if (!input) { // reverse - offset -= LinguaFrancaShapeExtensions.REACTION_POINTINESS; + + var in = + knode.getPorts().stream() + .filter(p -> p.getProperty(CoreOptions.PORT_SIDE) == PortSide.WEST) + .sorted((p1, p2) -> Float.compare(p1.getYpos(), p2.getYpos())) + .collect(Collectors.toList()); + + var out = + knode.getPorts().stream() + .filter(p -> p.getProperty(CoreOptions.PORT_SIDE) == PortSide.EAST) + .sorted((p1, p2) -> Float.compare(p1.getYpos(), p2.getYpos())) + .collect(Collectors.toList()); + + // Adjust + if (in.stream().anyMatch(p -> !p.hasProperty(CoreOptions.PORT_BORDER_OFFSET))) { + adjustPositions(IterableExtensions.indexed(in), in.size(), true); + } + if (out.stream().anyMatch(p -> !p.hasProperty(CoreOptions.PORT_BORDER_OFFSET))) { + adjustPositions(IterableExtensions.indexed(out), out.size(), false); } - - // apply - port.setPos(port.getXpos() + offset, port.getYpos()); - for (KEdge edge : port.getEdges()) { - if (input) { - edge.setTargetPoint(adjustedKPoint(edge.getTargetPoint(), offset)); - } else { - edge.setSourcePoint(adjustedKPoint(edge.getSourcePoint(), offset)); - } + knode.setProperty(ReactionPortAdjustment.PROCESSED, true); + + if (recorder != null) { + recorder.stopRecording(0); } - - // Save for future layout - port.setProperty(CoreOptions.PORT_BORDER_OFFSET, (double) (input ? -offset : offset)); + + } else if (IterableExtensions.head(knode.getPorts()).getYpos() == 0) { + knode.setProperty(PROCESSED, false); + } } + } + } catch (Exception e) { + e.printStackTrace(); + // do not disturb rendering process } + return false; + } + + public void adjustPositions( + Iterable> indexedPorts, int count, boolean input) { + float segments = LinguaFrancaShapeExtensions.REACTION_POINTINESS * 2 / (count + 1); + for (Pair indexedPort : indexedPorts) { + KPort port = indexedPort.getValue(); + int idx = indexedPort.getKey(); + float offset = 0; + + if (count % 2 != 0 && idx == count / 2) { + offset += LinguaFrancaShapeExtensions.REACTION_POINTINESS; + } else if (idx < count / 2) { + offset += segments * (idx + 1); + } else { + offset += segments * (count - idx); + } + + if (!input) { // reverse + offset -= LinguaFrancaShapeExtensions.REACTION_POINTINESS; + } + + // apply + port.setPos(port.getXpos() + offset, port.getYpos()); + for (KEdge edge : port.getEdges()) { + if (input) { + edge.setTargetPoint(adjustedKPoint(edge.getTargetPoint(), offset)); + } else { + edge.setSourcePoint(adjustedKPoint(edge.getSourcePoint(), offset)); + } + } - public KPoint adjustedKPoint(KPoint point, float xOffset) { - KPoint kPoint = _kGraphFactory.createKPoint(); - kPoint.setX(point.getX() + xOffset); - kPoint.setY(point.getY()); - return kPoint; + // Save for future layout + port.setProperty(CoreOptions.PORT_BORDER_OFFSET, (double) (input ? -offset : offset)); } + } + public KPoint adjustedKPoint(KPoint point, float xOffset) { + KPoint kPoint = _kGraphFactory.createKPoint(); + kPoint.setX(point.getX() + xOffset); + kPoint.setY(point.getY()); + return kPoint; + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java b/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java index 260e2c98db..efdc2ff4d5 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.styles; import static de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceX.LEFT; @@ -29,29 +29,6 @@ import static de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceY.BOTTOM; import static de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceY.TOP; -import java.util.ArrayList; -import java.util.List; - -import javax.inject.Inject; - -import org.eclipse.elk.core.options.CoreOptions; -import org.eclipse.elk.core.options.PortSide; -import org.eclipse.elk.graph.properties.Property; -import org.eclipse.xtext.xbase.lib.Extension; -import org.eclipse.xtext.xbase.lib.Functions.Function1; -import org.eclipse.xtext.xbase.lib.IterableExtensions; -import org.eclipse.xtext.xbase.lib.Pair; -import org.eclipse.xtext.xbase.lib.StringExtensions; -import org.lflang.ast.ASTUtils; -import org.lflang.diagram.synthesis.AbstractSynthesisExtensions; -import org.lflang.diagram.synthesis.LinguaFrancaSynthesis; -import org.lflang.diagram.synthesis.util.UtilityExtensions; -import org.lflang.generator.ReactionInstance; -import org.lflang.generator.ReactorInstance; -import org.lflang.generator.TimerInstance; -import org.lflang.lf.Parameter; -import org.lflang.lf.StateVar; - import de.cau.cs.kieler.klighd.KlighdConstants; import de.cau.cs.kieler.klighd.kgraph.KEdge; import de.cau.cs.kieler.klighd.kgraph.KNode; @@ -87,6 +64,26 @@ import de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceX; import de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceY; import de.cau.cs.kieler.klighd.syntheses.DiagramSyntheses; +import java.util.ArrayList; +import java.util.List; +import javax.inject.Inject; +import org.eclipse.elk.core.options.CoreOptions; +import org.eclipse.elk.core.options.PortSide; +import org.eclipse.elk.graph.properties.Property; +import org.eclipse.xtext.xbase.lib.Extension; +import org.eclipse.xtext.xbase.lib.Functions.Function1; +import org.eclipse.xtext.xbase.lib.IterableExtensions; +import org.eclipse.xtext.xbase.lib.Pair; +import org.eclipse.xtext.xbase.lib.StringExtensions; +import org.lflang.ast.ASTUtils; +import org.lflang.diagram.synthesis.AbstractSynthesisExtensions; +import org.lflang.diagram.synthesis.LinguaFrancaSynthesis; +import org.lflang.diagram.synthesis.util.UtilityExtensions; +import org.lflang.generator.ReactionInstance; +import org.lflang.generator.ReactorInstance; +import org.lflang.generator.TimerInstance; +import org.lflang.lf.Parameter; +import org.lflang.lf.StateVar; /** * Extension class that provides shapes and figures for the Lingua France diagram synthesis. @@ -96,873 +93,1207 @@ @ViewSynthesisShared public class LinguaFrancaShapeExtensions extends AbstractSynthesisExtensions { - public static final float REACTION_POINTINESS = 6; // arrow point length - // Property for marking the KContainterRendering in Reactor figures that is supposed to hold the content - public static final Property REACTOR_CONTENT_CONTAINER = new Property<>( - "org.lflang.diagram.synthesis.shapes.reactor.content", false); - - @Inject - @Extension - private KNodeExtensions _kNodeExtensions; - @Inject - @Extension - private KEdgeExtensions _kEdgeExtensions; - @Inject - @Extension - private KPortExtensions _kPortExtensions; - @Inject - @Extension - private KLabelExtensions _kLabelExtensions; - @Inject - @Extension - private KRenderingExtensions _kRenderingExtensions; - @Inject - @Extension - private KContainerRenderingExtensions _kContainerRenderingExtensions; - @Inject - @Extension - private KPolylineExtensions _kPolylineExtensions; - @Inject - @Extension - private KColorExtensions _kColorExtensions; - @Inject - @Extension - private LinguaFrancaStyleExtensions _linguaFrancaStyleExtensions; - @Inject - @Extension - private UtilityExtensions _utilityExtensions; - @Extension - private KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; - - public static final float BANK_FIGURE_X_OFFSET_SUM = 6.0f; - public static final float BANK_FIGURE_Y_OFFSET_SUM = 9.0f; - - /** - * Creates the main reactor frame. - */ - public KRoundedRectangle addMainReactorFigure(KNode node, ReactorInstance reactorInstance, String text) { - int padding = getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS) ? 8 : 6; - KRoundedRectangle figure = _kRenderingExtensions.addRoundedRectangle(node, 8, 8, 1); - _kContainerRenderingExtensions.setGridPlacement(figure, 1); - _kRenderingExtensions.setLineWidth(figure, 1); - _kRenderingExtensions.setForeground(figure, Colors.GRAY); - _kRenderingExtensions.setBackground(figure, Colors.WHITE); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - - // Create parent container - KRectangle parentContainer = _kContainerRenderingExtensions.addRectangle(figure); - _kRenderingExtensions.setInvisible(parentContainer, true); - setGridPlacementDataFromPointToPoint(parentContainer, - LEFT, padding, 0, TOP, padding, 0, - RIGHT, padding, 0, BOTTOM, 4, 0 - ); - - // Create child container - KRectangle childContainer = _kContainerRenderingExtensions.addRectangle(parentContainer); - _kRenderingExtensions.setInvisible(childContainer, true); - _kRenderingExtensions.setPointPlacementData(childContainer, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, - 0, 0, 0); - KGridPlacement placement = _kContainerRenderingExtensions.setGridPlacement(childContainer, 1); - - // Add text to the child container - KText childText = _kContainerRenderingExtensions.addText(childContainer, text); - DiagramSyntheses.suppressSelectability(childText); - _linguaFrancaStyleExtensions.underlineSelectionStyle(childText); - - if (reactorInstance.reactorDefinition.isFederated()) { - KContainerRendering cloudIcon = _linguaFrancaStyleExtensions.addCloudIcon(childContainer); - setGridPlacementDataFromPointToPoint(cloudIcon, - LEFT, 3, 0, TOP, 0, 0, - RIGHT, 0, 0, BOTTOM, 0, 0 - ); - placement.setNumColumns(2); - - if (reactorInstance.reactorDefinition.getHost() != null && - getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTOR_HOST)) { - KText hostNameText = _kContainerRenderingExtensions.addText(childContainer, - ASTUtils.toOriginalText(reactorInstance.reactorDefinition.getHost())); - DiagramSyntheses.suppressSelectability(hostNameText); - _linguaFrancaStyleExtensions.underlineSelectionStyle(hostNameText); - setGridPlacementDataFromPointToPoint(hostNameText, - LEFT, 3, 0, TOP, 0, 0, - RIGHT, 0, 0, BOTTOM, 0, 0 - ); - placement.setNumColumns(3); - } - } - return figure; + public static final float REACTION_POINTINESS = 6; // arrow point length + // Property for marking the KContainterRendering in Reactor figures that is supposed to hold the + // content + public static final Property REACTOR_CONTENT_CONTAINER = + new Property<>("org.lflang.diagram.synthesis.shapes.reactor.content", false); + + @Inject @Extension private KNodeExtensions _kNodeExtensions; + @Inject @Extension private KEdgeExtensions _kEdgeExtensions; + @Inject @Extension private KPortExtensions _kPortExtensions; + @Inject @Extension private KLabelExtensions _kLabelExtensions; + @Inject @Extension private KRenderingExtensions _kRenderingExtensions; + @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; + @Inject @Extension private KPolylineExtensions _kPolylineExtensions; + @Inject @Extension private KColorExtensions _kColorExtensions; + @Inject @Extension private LinguaFrancaStyleExtensions _linguaFrancaStyleExtensions; + @Inject @Extension private UtilityExtensions _utilityExtensions; + @Extension private KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; + + public static final float BANK_FIGURE_X_OFFSET_SUM = 6.0f; + public static final float BANK_FIGURE_Y_OFFSET_SUM = 9.0f; + + /** Creates the main reactor frame. */ + public KRoundedRectangle addMainReactorFigure( + KNode node, ReactorInstance reactorInstance, String text) { + int padding = getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS) ? 8 : 6; + KRoundedRectangle figure = _kRenderingExtensions.addRoundedRectangle(node, 8, 8, 1); + _kContainerRenderingExtensions.setGridPlacement(figure, 1); + _kRenderingExtensions.setLineWidth(figure, 1); + _kRenderingExtensions.setForeground(figure, Colors.GRAY); + _kRenderingExtensions.setBackground(figure, Colors.WHITE); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); + + // Create parent container + KRectangle parentContainer = _kContainerRenderingExtensions.addRectangle(figure); + _kRenderingExtensions.setInvisible(parentContainer, true); + setGridPlacementDataFromPointToPoint( + parentContainer, LEFT, padding, 0, TOP, padding, 0, RIGHT, padding, 0, BOTTOM, 4, 0); + + // Create child container + KRectangle childContainer = _kContainerRenderingExtensions.addRectangle(parentContainer); + _kRenderingExtensions.setInvisible(childContainer, true); + _kRenderingExtensions.setPointPlacementData( + childContainer, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 0, + 0); + KGridPlacement placement = _kContainerRenderingExtensions.setGridPlacement(childContainer, 1); + + // Add text to the child container + KText childText = _kContainerRenderingExtensions.addText(childContainer, text); + DiagramSyntheses.suppressSelectability(childText); + _linguaFrancaStyleExtensions.underlineSelectionStyle(childText); + + if (reactorInstance.reactorDefinition.isFederated()) { + KContainerRendering cloudIcon = _linguaFrancaStyleExtensions.addCloudIcon(childContainer); + setGridPlacementDataFromPointToPoint( + cloudIcon, LEFT, 3, 0, TOP, 0, 0, RIGHT, 0, 0, BOTTOM, 0, 0); + placement.setNumColumns(2); + + if (reactorInstance.reactorDefinition.getHost() != null + && getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTOR_HOST)) { + KText hostNameText = + _kContainerRenderingExtensions.addText( + childContainer, + ASTUtils.toOriginalText(reactorInstance.reactorDefinition.getHost())); + DiagramSyntheses.suppressSelectability(hostNameText); + _linguaFrancaStyleExtensions.underlineSelectionStyle(hostNameText); + setGridPlacementDataFromPointToPoint( + hostNameText, LEFT, 3, 0, TOP, 0, 0, RIGHT, 0, 0, BOTTOM, 0, 0); + placement.setNumColumns(3); + } } - - /** - * Creates the visual representation of a reactor node - */ - public ReactorFigureComponents addReactorFigure(KNode node, ReactorInstance reactorInstance, String text) { - int padding = getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS) ? 8 : 6; - - Function1 style = r -> { - _kRenderingExtensions.setLineWidth(r, 1); - _kRenderingExtensions.setForeground(r, Colors.GRAY); - _kRenderingExtensions.setBackground(r, Colors.GRAY_95); - return _linguaFrancaStyleExtensions.boldLineSelectionStyle(r); + return figure; + } + + /** Creates the visual representation of a reactor node */ + public ReactorFigureComponents addReactorFigure( + KNode node, ReactorInstance reactorInstance, String text) { + int padding = getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS) ? 8 : 6; + + Function1 style = + r -> { + _kRenderingExtensions.setLineWidth(r, 1); + _kRenderingExtensions.setForeground(r, Colors.GRAY); + _kRenderingExtensions.setBackground(r, Colors.GRAY_95); + return _linguaFrancaStyleExtensions.boldLineSelectionStyle(r); }; - KRoundedRectangle figure = _kRenderingExtensions.addRoundedRectangle(node, 8, 8, 1); - _kContainerRenderingExtensions.setGridPlacement(figure, 1); - style.apply(figure); - figure.setProperty(REACTOR_CONTENT_CONTAINER, true); - - // minimal node size is necessary if no text will be added - List minSize = List.of(2 * figure.getCornerWidth(), 2 * figure.getCornerHeight()); - _kNodeExtensions.setMinimalNodeSize(node, minSize.get(0), minSize.get(1)); - - // Add parent container - KRectangle parentContainer = _kContainerRenderingExtensions.addRectangle(figure); - _kRenderingExtensions.setInvisible(parentContainer, true); - setGridPlacementDataFromPointToPoint(parentContainer, - LEFT, padding, 0, - TOP, padding, 0, - RIGHT, padding, 0, BOTTOM, - _utilityExtensions.hasContent(reactorInstance) ? 4 : padding, 0 - ); - - // Add centered child container - KRectangle childContainer = _kContainerRenderingExtensions.addRectangle(parentContainer); - _kRenderingExtensions.setInvisible(childContainer, true); - _kRenderingExtensions.setPointPlacementData(childContainer, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, - 0, 0, 0); - KGridPlacement placement = _kContainerRenderingExtensions.setGridPlacement(childContainer, 1); - - KText childText = _kContainerRenderingExtensions.addText(childContainer, text); - DiagramSyntheses.suppressSelectability(childText); - _linguaFrancaStyleExtensions.underlineSelectionStyle(childText); - - if (!_utilityExtensions.isRoot(reactorInstance) && - reactorInstance.getDefinition().getHost() != null) { - KRendering cloudUploadIcon = _linguaFrancaStyleExtensions.addCloudUploadIcon(childContainer); - setGridPlacementDataFromPointToPoint(cloudUploadIcon, - LEFT, 3, 0, TOP, 0, 0, - RIGHT, 0, 0, BOTTOM, 0, 0 - ); - placement.setNumColumns(2); - - if (getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTOR_HOST)) { - KText reactorHostText = _kContainerRenderingExtensions.addText(childContainer, - ASTUtils.toOriginalText(reactorInstance.getDefinition().getHost())); - DiagramSyntheses.suppressSelectability(reactorHostText); - _linguaFrancaStyleExtensions.underlineSelectionStyle(reactorHostText); - setGridPlacementDataFromPointToPoint(reactorHostText, - LEFT, 3, 0, TOP, 0, 0, - RIGHT, 0, 0, BOTTOM, 0, 0 - ); - placement.setNumColumns(3); - } - } - - if (reactorInstance.isBank()) { - List bank = new ArrayList<>(); - KContainerRendering container = _kRenderingExtensions.addInvisibleContainerRendering(node); - // TODO handle unresolved width - KRoundedRectangle banks; - banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); - style.apply(banks); - setGridPlacementDataFromPointToPoint(banks, - LEFT, BANK_FIGURE_X_OFFSET_SUM, 0, TOP, BANK_FIGURE_Y_OFFSET_SUM, 0, - RIGHT, 0, 0, BOTTOM, 0, 0 - ); - if (reactorInstance.getWidth() == 3) { - banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); - style.apply(banks); - setGridPlacementDataFromPointToPoint(banks, - LEFT, BANK_FIGURE_X_OFFSET_SUM / 2, 0, TOP, BANK_FIGURE_Y_OFFSET_SUM / 2, 0, - RIGHT, BANK_FIGURE_X_OFFSET_SUM / 2, 0, BOTTOM, BANK_FIGURE_Y_OFFSET_SUM / 2, 0 - ); - } else if (reactorInstance.getWidth() != 2 && reactorInstance.getWidth() != 3) { - banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); - style.apply(banks); - setGridPlacementDataFromPointToPoint(banks, - LEFT, 2 * BANK_FIGURE_X_OFFSET_SUM / 3, 0, TOP, 2 * BANK_FIGURE_Y_OFFSET_SUM / 3, 0, - RIGHT, BANK_FIGURE_X_OFFSET_SUM / 3, 0, BOTTOM, BANK_FIGURE_Y_OFFSET_SUM / 3, 0 - ); - - banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); - style.apply(banks); - setGridPlacementDataFromPointToPoint(banks, - LEFT, BANK_FIGURE_X_OFFSET_SUM / 3, 0, TOP, BANK_FIGURE_Y_OFFSET_SUM / 3, 0, - RIGHT, 2 * BANK_FIGURE_X_OFFSET_SUM / 3, 0, BOTTOM, 2 * BANK_FIGURE_Y_OFFSET_SUM / 3, 0 - ); - } - - container.getChildren().add(figure); - setGridPlacementDataFromPointToPoint(figure, - LEFT, 0, 0, TOP, 0, 0, - RIGHT, BANK_FIGURE_X_OFFSET_SUM, 0, BOTTOM, BANK_FIGURE_Y_OFFSET_SUM, 0 - ); - bank.addAll(container.getChildren()); - - KRectangle widthLabelContainer = _kContainerRenderingExtensions.addRectangle(container); - _kRenderingExtensions.setInvisible(widthLabelContainer, true); - setGridPlacementDataFromPointToPoint(widthLabelContainer, - LEFT, 12, 0, BOTTOM, 9, 0, - RIGHT, 6, 0, BOTTOM, 0.5f, 0 - ); - // Handle unresolved width. - String widthLabel = reactorInstance.getWidth() >= 0 ? Integer.toString(reactorInstance.getWidth()) : "?"; - KText widthLabelText = _kContainerRenderingExtensions.addText(widthLabelContainer, widthLabel); - _kRenderingExtensions.setHorizontalAlignment(widthLabelText, HorizontalAlignment.LEFT); - _kRenderingExtensions.setVerticalAlignment(widthLabelText, VerticalAlignment.BOTTOM); - _kRenderingExtensions.setFontSize(widthLabelText, 6); - _linguaFrancaStyleExtensions.noSelectionStyle(widthLabelText); - associateWith(widthLabelText, reactorInstance.getDefinition().getWidthSpec()); - return new ReactorFigureComponents(container, figure, bank); - } else { - return new ReactorFigureComponents(figure, figure, List.of(figure)); - } + KRoundedRectangle figure = _kRenderingExtensions.addRoundedRectangle(node, 8, 8, 1); + _kContainerRenderingExtensions.setGridPlacement(figure, 1); + style.apply(figure); + figure.setProperty(REACTOR_CONTENT_CONTAINER, true); + + // minimal node size is necessary if no text will be added + List minSize = List.of(2 * figure.getCornerWidth(), 2 * figure.getCornerHeight()); + _kNodeExtensions.setMinimalNodeSize(node, minSize.get(0), minSize.get(1)); + + // Add parent container + KRectangle parentContainer = _kContainerRenderingExtensions.addRectangle(figure); + _kRenderingExtensions.setInvisible(parentContainer, true); + setGridPlacementDataFromPointToPoint( + parentContainer, + LEFT, + padding, + 0, + TOP, + padding, + 0, + RIGHT, + padding, + 0, + BOTTOM, + _utilityExtensions.hasContent(reactorInstance) ? 4 : padding, + 0); + + // Add centered child container + KRectangle childContainer = _kContainerRenderingExtensions.addRectangle(parentContainer); + _kRenderingExtensions.setInvisible(childContainer, true); + _kRenderingExtensions.setPointPlacementData( + childContainer, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 0, + 0); + KGridPlacement placement = _kContainerRenderingExtensions.setGridPlacement(childContainer, 1); + + KText childText = _kContainerRenderingExtensions.addText(childContainer, text); + DiagramSyntheses.suppressSelectability(childText); + _linguaFrancaStyleExtensions.underlineSelectionStyle(childText); + + if (!_utilityExtensions.isRoot(reactorInstance) + && reactorInstance.getDefinition().getHost() != null) { + KRendering cloudUploadIcon = _linguaFrancaStyleExtensions.addCloudUploadIcon(childContainer); + setGridPlacementDataFromPointToPoint( + cloudUploadIcon, LEFT, 3, 0, TOP, 0, 0, RIGHT, 0, 0, BOTTOM, 0, 0); + placement.setNumColumns(2); + + if (getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTOR_HOST)) { + KText reactorHostText = + _kContainerRenderingExtensions.addText( + childContainer, ASTUtils.toOriginalText(reactorInstance.getDefinition().getHost())); + DiagramSyntheses.suppressSelectability(reactorHostText); + _linguaFrancaStyleExtensions.underlineSelectionStyle(reactorHostText); + setGridPlacementDataFromPointToPoint( + reactorHostText, LEFT, 3, 0, TOP, 0, 0, RIGHT, 0, 0, BOTTOM, 0, 0); + placement.setNumColumns(3); + } } - /** - * Creates the visual representation of a reaction node - */ - public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { - int minHeight = 22; - int minWidth = 45; - ReactorInstance reactor = reaction.getParent(); - _kNodeExtensions.setMinimalNodeSize(node, minWidth, minHeight); - - // Create base shape - KPolygon baseShape = _kRenderingExtensions.addPolygon(node); - associateWith(baseShape, reaction); - _kRenderingExtensions.setLineWidth(baseShape, 1); - _kRenderingExtensions.setForeground(baseShape, Colors.GRAY_45); - _kRenderingExtensions.setBackground(baseShape, Colors.GRAY_65); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(baseShape); - baseShape.getPoints().addAll( + if (reactorInstance.isBank()) { + List bank = new ArrayList<>(); + KContainerRendering container = _kRenderingExtensions.addInvisibleContainerRendering(node); + // TODO handle unresolved width + KRoundedRectangle banks; + banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); + style.apply(banks); + setGridPlacementDataFromPointToPoint( + banks, + LEFT, + BANK_FIGURE_X_OFFSET_SUM, + 0, + TOP, + BANK_FIGURE_Y_OFFSET_SUM, + 0, + RIGHT, + 0, + 0, + BOTTOM, + 0, + 0); + if (reactorInstance.getWidth() == 3) { + banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); + style.apply(banks); + setGridPlacementDataFromPointToPoint( + banks, + LEFT, + BANK_FIGURE_X_OFFSET_SUM / 2, + 0, + TOP, + BANK_FIGURE_Y_OFFSET_SUM / 2, + 0, + RIGHT, + BANK_FIGURE_X_OFFSET_SUM / 2, + 0, + BOTTOM, + BANK_FIGURE_Y_OFFSET_SUM / 2, + 0); + } else if (reactorInstance.getWidth() != 2 && reactorInstance.getWidth() != 3) { + banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); + style.apply(banks); + setGridPlacementDataFromPointToPoint( + banks, + LEFT, + 2 * BANK_FIGURE_X_OFFSET_SUM / 3, + 0, + TOP, + 2 * BANK_FIGURE_Y_OFFSET_SUM / 3, + 0, + RIGHT, + BANK_FIGURE_X_OFFSET_SUM / 3, + 0, + BOTTOM, + BANK_FIGURE_Y_OFFSET_SUM / 3, + 0); + + banks = _kContainerRenderingExtensions.addRoundedRectangle(container, 8, 8, 1); + style.apply(banks); + setGridPlacementDataFromPointToPoint( + banks, + LEFT, + BANK_FIGURE_X_OFFSET_SUM / 3, + 0, + TOP, + BANK_FIGURE_Y_OFFSET_SUM / 3, + 0, + RIGHT, + 2 * BANK_FIGURE_X_OFFSET_SUM / 3, + 0, + BOTTOM, + 2 * BANK_FIGURE_Y_OFFSET_SUM / 3, + 0); + } + + container.getChildren().add(figure); + setGridPlacementDataFromPointToPoint( + figure, + LEFT, + 0, + 0, + TOP, + 0, + 0, + RIGHT, + BANK_FIGURE_X_OFFSET_SUM, + 0, + BOTTOM, + BANK_FIGURE_Y_OFFSET_SUM, + 0); + bank.addAll(container.getChildren()); + + KRectangle widthLabelContainer = _kContainerRenderingExtensions.addRectangle(container); + _kRenderingExtensions.setInvisible(widthLabelContainer, true); + setGridPlacementDataFromPointToPoint( + widthLabelContainer, LEFT, 12, 0, BOTTOM, 9, 0, RIGHT, 6, 0, BOTTOM, 0.5f, 0); + // Handle unresolved width. + String widthLabel = + reactorInstance.getWidth() >= 0 ? Integer.toString(reactorInstance.getWidth()) : "?"; + KText widthLabelText = + _kContainerRenderingExtensions.addText(widthLabelContainer, widthLabel); + _kRenderingExtensions.setHorizontalAlignment(widthLabelText, HorizontalAlignment.LEFT); + _kRenderingExtensions.setVerticalAlignment(widthLabelText, VerticalAlignment.BOTTOM); + _kRenderingExtensions.setFontSize(widthLabelText, 6); + _linguaFrancaStyleExtensions.noSelectionStyle(widthLabelText); + associateWith(widthLabelText, reactorInstance.getDefinition().getWidthSpec()); + return new ReactorFigureComponents(container, figure, bank); + } else { + return new ReactorFigureComponents(figure, figure, List.of(figure)); + } + } + + /** Creates the visual representation of a reaction node */ + public KPolygon addReactionFigure(KNode node, ReactionInstance reaction) { + int minHeight = 22; + int minWidth = 45; + ReactorInstance reactor = reaction.getParent(); + _kNodeExtensions.setMinimalNodeSize(node, minWidth, minHeight); + + // Create base shape + KPolygon baseShape = _kRenderingExtensions.addPolygon(node); + associateWith(baseShape, reaction); + _kRenderingExtensions.setLineWidth(baseShape, 1); + _kRenderingExtensions.setForeground(baseShape, Colors.GRAY_45); + _kRenderingExtensions.setBackground(baseShape, Colors.GRAY_65); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(baseShape); + baseShape + .getPoints() + .addAll( List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0, TOP, 0, 0), _kRenderingExtensions.createKPosition(RIGHT, REACTION_POINTINESS, 0, TOP, 0, 0), _kRenderingExtensions.createKPosition(RIGHT, 0, 0, TOP, 0, 0.5f), _kRenderingExtensions.createKPosition(RIGHT, REACTION_POINTINESS, 0, BOTTOM, 0, 0), _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0), - _kRenderingExtensions.createKPosition(LEFT, REACTION_POINTINESS, 0, BOTTOM, 0, 0.5f) - ) - ); - - KRectangle contentContainer = _kContainerRenderingExtensions.addRectangle(baseShape); - associateWith(contentContainer, reaction); - _kRenderingExtensions.setInvisible(contentContainer, true); - _kRenderingExtensions.setPointPlacementData(contentContainer, - _kRenderingExtensions.LEFT, REACTION_POINTINESS, 0, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, REACTION_POINTINESS, - 0, minWidth - REACTION_POINTINESS * 2, minHeight); - _kContainerRenderingExtensions.setGridPlacement(contentContainer, 1); - - if (reactor.reactions.size() > 1) { - KText textToAdd = _kContainerRenderingExtensions.addText(contentContainer, - Integer.toString(reactor.reactions.indexOf(reaction) + 1)); - _kRenderingExtensions.setFontBold(textToAdd, true); - _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); - DiagramSyntheses.suppressSelectability(textToAdd); - } - - // optional reaction level - if (getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_LEVEL)) { - // Force calculation of levels for reactions. This calculation - // will only be done once. Note that if this fails due to a causality loop, - // then some reactions will have level -1. - try { - String levels = IterableExtensions.join(reaction.getLevels(), ", "); - KText levelsText = _kContainerRenderingExtensions.addText(contentContainer, ("level: " + levels)); - _kRenderingExtensions.setFontBold(levelsText, false); - _linguaFrancaStyleExtensions.noSelectionStyle(levelsText); - DiagramSyntheses.suppressSelectability(levelsText); - } catch (Exception ex) { - // If the graph has cycles, the above fails. Continue without showing levels. - } - } - - // optional code content - boolean hasCode = getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_CODE) && - !StringExtensions.isNullOrEmpty(reaction.getDefinition().getCode().getBody()); - if (hasCode) { - KText hasCodeText = _kContainerRenderingExtensions.addText(contentContainer, - _utilityExtensions.trimCode(reaction.getDefinition().getCode())); - associateWith(hasCodeText, reaction); - _kRenderingExtensions.setFontSize(hasCodeText, 6); - _kRenderingExtensions.setFontName(hasCodeText, KlighdConstants.DEFAULT_MONOSPACE_FONT_NAME); - _linguaFrancaStyleExtensions.noSelectionStyle(hasCodeText); - _kRenderingExtensions.setHorizontalAlignment(hasCodeText, HorizontalAlignment.LEFT); - _kRenderingExtensions.setVerticalAlignment(hasCodeText, VerticalAlignment.TOP); - setGridPlacementDataFromPointToPoint(hasCodeText, - _kRenderingExtensions.LEFT, 5, 0, - _kRenderingExtensions.TOP, 5, 0, - _kRenderingExtensions.RIGHT, 5, 0, - _kRenderingExtensions.BOTTOM, 5, 0 - ); - } - - if (reaction.declaredDeadline != null) { - boolean hasDeadlineCode = getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_CODE) && - !StringExtensions.isNullOrEmpty(reaction.getDefinition().getDeadline().getCode().getBody()); - if (hasCode || hasDeadlineCode) { - KPolyline line = _kContainerRenderingExtensions.addHorizontalLine(contentContainer, 0); - setGridPlacementDataFromPointToPoint(line, - _kRenderingExtensions.LEFT, 5, 0, - _kRenderingExtensions.TOP, 3, 0, - _kRenderingExtensions.RIGHT, 5, 0, - _kRenderingExtensions.BOTTOM, 6, 0 - ); - } - - // delay with stopwatch - KRectangle labelContainer = _kContainerRenderingExtensions.addRectangle(contentContainer); - _kRenderingExtensions.setInvisible(labelContainer, true); - KRendering placement = setGridPlacementDataFromPointToPoint(labelContainer, - _kRenderingExtensions.LEFT, hasDeadlineCode ? 0 : -REACTION_POINTINESS * 0.5f, 0, - _kRenderingExtensions.TOP, 0, reactor.reactions.size() > 1 || hasCode || hasDeadlineCode ? 0 : 0.5f, - _kRenderingExtensions.RIGHT, 0, 0, - _kRenderingExtensions.BOTTOM, 0, 0 - ); - _kRenderingExtensions.setHorizontalAlignment(placement, HorizontalAlignment.LEFT); - - KRectangle stopWatchFigure = addStopwatchFigure(labelContainer); - _kRenderingExtensions.setLeftTopAlignedPointPlacementData(stopWatchFigure, 0, 0, 0, 0); - - KText stopWatchText = _kContainerRenderingExtensions.addText(labelContainer, - reaction.declaredDeadline.maxDelay.toString()); - associateWith(stopWatchText, reaction.getDefinition().getDeadline().getDelay()); - _kRenderingExtensions.setForeground(stopWatchText, Colors.BROWN); - _kRenderingExtensions.setFontBold(stopWatchText, true); - _kRenderingExtensions.setFontSize(stopWatchText, 7); - _linguaFrancaStyleExtensions.underlineSelectionStyle(stopWatchText); - _kRenderingExtensions.setLeftTopAlignedPointPlacementData(stopWatchText, 15, 0, 0, 0); - - // optional code content - if (hasDeadlineCode) { - KText contentContainerText = _kContainerRenderingExtensions.addText(contentContainer, - _utilityExtensions.trimCode(reaction.getDefinition().getDeadline().getCode())); - associateWith(contentContainerText, reaction.declaredDeadline); - _kRenderingExtensions.setForeground(contentContainerText, Colors.BROWN); - _kRenderingExtensions.setFontSize(contentContainerText, 6); - _kRenderingExtensions.setFontName(contentContainerText, KlighdConstants.DEFAULT_MONOSPACE_FONT_NAME); - setGridPlacementDataFromPointToPoint(contentContainerText, - _kRenderingExtensions.LEFT, 5, 0, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.RIGHT, 5, 0, - _kRenderingExtensions.BOTTOM, 5, 0 - ); - _kRenderingExtensions.setHorizontalAlignment(contentContainerText, HorizontalAlignment.LEFT); - _linguaFrancaStyleExtensions.noSelectionStyle(contentContainerText); - } - } - - return baseShape; + _kRenderingExtensions.createKPosition( + LEFT, REACTION_POINTINESS, 0, BOTTOM, 0, 0.5f))); + + KRectangle contentContainer = _kContainerRenderingExtensions.addRectangle(baseShape); + associateWith(contentContainer, reaction); + _kRenderingExtensions.setInvisible(contentContainer, true); + _kRenderingExtensions.setPointPlacementData( + contentContainer, + _kRenderingExtensions.LEFT, + REACTION_POINTINESS, + 0, + _kRenderingExtensions.TOP, + 0, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_TOP, + REACTION_POINTINESS, + 0, + minWidth - REACTION_POINTINESS * 2, + minHeight); + _kContainerRenderingExtensions.setGridPlacement(contentContainer, 1); + + if (reactor.reactions.size() > 1) { + KText textToAdd = + _kContainerRenderingExtensions.addText( + contentContainer, Integer.toString(reactor.reactions.indexOf(reaction) + 1)); + _kRenderingExtensions.setFontBold(textToAdd, true); + _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); + DiagramSyntheses.suppressSelectability(textToAdd); } - /** - * Stopwatch figure for deadlines. - */ - public KRectangle addStopwatchFigure(KContainerRendering parent) { - final int size = 12; - KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); - _kRenderingExtensions.setInvisible(container, true); - _kRenderingExtensions.setPointPlacementData(container, - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, - 0, size, size); - - KPolyline polyline = _kContainerRenderingExtensions.addPolyline(container, 2, - List.of( - _kRenderingExtensions.createKPosition(LEFT, 3, 0.5f, TOP, (-2), 0), - _kRenderingExtensions.createKPosition(LEFT, (-3), 0.5f, TOP, (-2), 0) - ) - ); - _kRenderingExtensions.setForeground(polyline, Colors.BROWN); + // optional reaction level + if (getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_LEVEL)) { + // Force calculation of levels for reactions. This calculation + // will only be done once. Note that if this fails due to a causality loop, + // then some reactions will have level -1. + try { + String levels = IterableExtensions.join(reaction.getLevels(), ", "); + KText levelsText = + _kContainerRenderingExtensions.addText(contentContainer, ("level: " + levels)); + _kRenderingExtensions.setFontBold(levelsText, false); + _linguaFrancaStyleExtensions.noSelectionStyle(levelsText); + DiagramSyntheses.suppressSelectability(levelsText); + } catch (Exception ex) { + // If the graph has cycles, the above fails. Continue without showing levels. + } + } - polyline = _kContainerRenderingExtensions.addPolyline(container, 2, - List.of( - _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, (-2), 0), - _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 1, 0) - ) - ); - _kRenderingExtensions.setForeground(polyline, Colors.BROWN); - - KEllipse body = _kContainerRenderingExtensions.addEllipse(container); - _kRenderingExtensions.setLineWidth(body, 1); - _kRenderingExtensions.setForeground(body, Colors.BROWN); - _kRenderingExtensions.setPointPlacementData(body, - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, - 0, size, size); - _linguaFrancaStyleExtensions.noSelectionStyle(body); - - KArc arc = _kContainerRenderingExtensions.addArc(body); - arc.setStartAngle((-20)); - arc.setArcAngle(110); - arc.setArcType(Arc.PIE); - _kRenderingExtensions.setLineWidth(arc, 0); - _kRenderingExtensions.setBackground(arc, Colors.BROWN); - _kRenderingExtensions.setPointPlacementData(arc, - _kRenderingExtensions.LEFT, 2, 0, - _kRenderingExtensions.TOP, 2, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 2, - 2, size - 4, size - 4); - _linguaFrancaStyleExtensions.noSelectionStyle(arc); - - return container; + // optional code content + boolean hasCode = + getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_CODE) + && !StringExtensions.isNullOrEmpty(reaction.getDefinition().getCode().getBody()); + if (hasCode) { + KText hasCodeText = + _kContainerRenderingExtensions.addText( + contentContainer, _utilityExtensions.trimCode(reaction.getDefinition().getCode())); + associateWith(hasCodeText, reaction); + _kRenderingExtensions.setFontSize(hasCodeText, 6); + _kRenderingExtensions.setFontName(hasCodeText, KlighdConstants.DEFAULT_MONOSPACE_FONT_NAME); + _linguaFrancaStyleExtensions.noSelectionStyle(hasCodeText); + _kRenderingExtensions.setHorizontalAlignment(hasCodeText, HorizontalAlignment.LEFT); + _kRenderingExtensions.setVerticalAlignment(hasCodeText, VerticalAlignment.TOP); + setGridPlacementDataFromPointToPoint( + hasCodeText, + _kRenderingExtensions.LEFT, + 5, + 0, + _kRenderingExtensions.TOP, + 5, + 0, + _kRenderingExtensions.RIGHT, + 5, + 0, + _kRenderingExtensions.BOTTOM, + 5, + 0); } - /** - * Creates the visual representation of a timer node - */ - public KEllipse addTimerFigure(KNode node, TimerInstance timer) { - _kNodeExtensions.setMinimalNodeSize(node, 30, 30); + if (reaction.declaredDeadline != null) { + boolean hasDeadlineCode = + getBooleanValue(LinguaFrancaSynthesis.SHOW_REACTION_CODE) + && !StringExtensions.isNullOrEmpty( + reaction.getDefinition().getDeadline().getCode().getBody()); + if (hasCode || hasDeadlineCode) { + KPolyline line = _kContainerRenderingExtensions.addHorizontalLine(contentContainer, 0); + setGridPlacementDataFromPointToPoint( + line, + _kRenderingExtensions.LEFT, + 5, + 0, + _kRenderingExtensions.TOP, + 3, + 0, + _kRenderingExtensions.RIGHT, + 5, + 0, + _kRenderingExtensions.BOTTOM, + 6, + 0); + } + + // delay with stopwatch + KRectangle labelContainer = _kContainerRenderingExtensions.addRectangle(contentContainer); + _kRenderingExtensions.setInvisible(labelContainer, true); + KRendering placement = + setGridPlacementDataFromPointToPoint( + labelContainer, + _kRenderingExtensions.LEFT, + hasDeadlineCode ? 0 : -REACTION_POINTINESS * 0.5f, + 0, + _kRenderingExtensions.TOP, + 0, + reactor.reactions.size() > 1 || hasCode || hasDeadlineCode ? 0 : 0.5f, + _kRenderingExtensions.RIGHT, + 0, + 0, + _kRenderingExtensions.BOTTOM, + 0, + 0); + _kRenderingExtensions.setHorizontalAlignment(placement, HorizontalAlignment.LEFT); + + KRectangle stopWatchFigure = addStopwatchFigure(labelContainer); + _kRenderingExtensions.setLeftTopAlignedPointPlacementData(stopWatchFigure, 0, 0, 0, 0); + + KText stopWatchText = + _kContainerRenderingExtensions.addText( + labelContainer, reaction.declaredDeadline.maxDelay.toString()); + associateWith(stopWatchText, reaction.getDefinition().getDeadline().getDelay()); + _kRenderingExtensions.setForeground(stopWatchText, Colors.BROWN); + _kRenderingExtensions.setFontBold(stopWatchText, true); + _kRenderingExtensions.setFontSize(stopWatchText, 7); + _linguaFrancaStyleExtensions.underlineSelectionStyle(stopWatchText); + _kRenderingExtensions.setLeftTopAlignedPointPlacementData(stopWatchText, 15, 0, 0, 0); + + // optional code content + if (hasDeadlineCode) { + KText contentContainerText = + _kContainerRenderingExtensions.addText( + contentContainer, + _utilityExtensions.trimCode(reaction.getDefinition().getDeadline().getCode())); + associateWith(contentContainerText, reaction.declaredDeadline); + _kRenderingExtensions.setForeground(contentContainerText, Colors.BROWN); + _kRenderingExtensions.setFontSize(contentContainerText, 6); + _kRenderingExtensions.setFontName( + contentContainerText, KlighdConstants.DEFAULT_MONOSPACE_FONT_NAME); + setGridPlacementDataFromPointToPoint( + contentContainerText, + _kRenderingExtensions.LEFT, + 5, + 0, + _kRenderingExtensions.TOP, + 0, + 0, + _kRenderingExtensions.RIGHT, + 5, + 0, + _kRenderingExtensions.BOTTOM, + 5, + 0); + _kRenderingExtensions.setHorizontalAlignment( + contentContainerText, HorizontalAlignment.LEFT); + _linguaFrancaStyleExtensions.noSelectionStyle(contentContainerText); + } + } - KEllipse figure = _kRenderingExtensions.addEllipse(node); - _kRenderingExtensions.setBackground(figure, Colors.GRAY_95); - _linguaFrancaStyleExtensions.noSelectionStyle(figure); - _kRenderingExtensions.setLineWidth(figure, 1); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); + return baseShape; + } + + /** Stopwatch figure for deadlines. */ + public KRectangle addStopwatchFigure(KContainerRendering parent) { + final int size = 12; + KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); + _kRenderingExtensions.setInvisible(container, true); + _kRenderingExtensions.setPointPlacementData( + container, + _kRenderingExtensions.LEFT, + 0, + 0, + _kRenderingExtensions.TOP, + 0, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_TOP, + 0, + 0, + size, + size); + + KPolyline polyline = + _kContainerRenderingExtensions.addPolyline( + container, + 2, + List.of( + _kRenderingExtensions.createKPosition(LEFT, 3, 0.5f, TOP, (-2), 0), + _kRenderingExtensions.createKPosition(LEFT, (-3), 0.5f, TOP, (-2), 0))); + _kRenderingExtensions.setForeground(polyline, Colors.BROWN); - List polylinePoints = List.of( + polyline = + _kContainerRenderingExtensions.addPolyline( + container, + 2, + List.of( + _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, (-2), 0), + _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 1, 0))); + _kRenderingExtensions.setForeground(polyline, Colors.BROWN); + + KEllipse body = _kContainerRenderingExtensions.addEllipse(container); + _kRenderingExtensions.setLineWidth(body, 1); + _kRenderingExtensions.setForeground(body, Colors.BROWN); + _kRenderingExtensions.setPointPlacementData( + body, + _kRenderingExtensions.LEFT, + 0, + 0, + _kRenderingExtensions.TOP, + 0, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_TOP, + 0, + 0, + size, + size); + _linguaFrancaStyleExtensions.noSelectionStyle(body); + + KArc arc = _kContainerRenderingExtensions.addArc(body); + arc.setStartAngle((-20)); + arc.setArcAngle(110); + arc.setArcType(Arc.PIE); + _kRenderingExtensions.setLineWidth(arc, 0); + _kRenderingExtensions.setBackground(arc, Colors.BROWN); + _kRenderingExtensions.setPointPlacementData( + arc, + _kRenderingExtensions.LEFT, + 2, + 0, + _kRenderingExtensions.TOP, + 2, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_TOP, + 2, + 2, + size - 4, + size - 4); + _linguaFrancaStyleExtensions.noSelectionStyle(arc); + + return container; + } + + /** Creates the visual representation of a timer node */ + public KEllipse addTimerFigure(KNode node, TimerInstance timer) { + _kNodeExtensions.setMinimalNodeSize(node, 30, 30); + + KEllipse figure = _kRenderingExtensions.addEllipse(node); + _kRenderingExtensions.setBackground(figure, Colors.GRAY_95); + _linguaFrancaStyleExtensions.noSelectionStyle(figure); + _kRenderingExtensions.setLineWidth(figure, 1); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); + + List polylinePoints = + List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0.1f), _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0.5f), - _kRenderingExtensions.createKPosition(LEFT, 0, 0.7f, TOP, 0, 0.7f) - ); - KPolyline polyline = _kContainerRenderingExtensions.addPolyline(figure, 1, polylinePoints); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(polyline); - - List labelParts = new ArrayList<>(); - if (timer.getOffset() != TimerInstance.DEFAULT_OFFSET && timer.getOffset() != null) { - labelParts.add(timer.getOffset().toString()); - } - if (timer.getPeriod() != TimerInstance.DEFAULT_PERIOD && timer.getPeriod() != null) { - if (timer.getOffset() == TimerInstance.DEFAULT_OFFSET) { - labelParts.add(timer.getOffset().toString()); - } - labelParts.add(timer.getPeriod().toString()); - } - if (!labelParts.isEmpty()) { - _kLabelExtensions.addOutsideBottomCenteredNodeLabel(node, - "(" + String.join(", ", labelParts) + ")", 8); - } - return figure; - } + _kRenderingExtensions.createKPosition(LEFT, 0, 0.7f, TOP, 0, 0.7f)); + KPolyline polyline = _kContainerRenderingExtensions.addPolyline(figure, 1, polylinePoints); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(polyline); - /** - * Creates the visual representation of a startup trigger. - */ - public KEllipse addStartupFigure(KNode node) { - _kNodeExtensions.setMinimalNodeSize(node, 18, 18); - KEllipse figure = _kRenderingExtensions.addEllipse(node); - _kRenderingExtensions.setLineWidth(figure, 1); - _kRenderingExtensions.setBackground(figure, Colors.WHITE); - _linguaFrancaStyleExtensions.noSelectionStyle(figure); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - return figure; + List labelParts = new ArrayList<>(); + if (timer.getOffset() != TimerInstance.DEFAULT_OFFSET && timer.getOffset() != null) { + labelParts.add(timer.getOffset().toString()); } - - /** - * Creates the visual representation of a shutdown trigger. - */ - public KPolygon addShutdownFigure(KNode node) { - _kNodeExtensions.setMinimalNodeSize(node, 18, 18); - KPolygon figure = _kRenderingExtensions.addPolygon(node); - _kRenderingExtensions.setLineWidth(figure, 1); - _kRenderingExtensions.setBackground(figure, Colors.WHITE); - _linguaFrancaStyleExtensions.noSelectionStyle(figure); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - - List pointsToAdd = List.of( + if (timer.getPeriod() != TimerInstance.DEFAULT_PERIOD && timer.getPeriod() != null) { + if (timer.getOffset() == TimerInstance.DEFAULT_OFFSET) { + labelParts.add(timer.getOffset().toString()); + } + labelParts.add(timer.getPeriod().toString()); + } + if (!labelParts.isEmpty()) { + _kLabelExtensions.addOutsideBottomCenteredNodeLabel( + node, "(" + String.join(", ", labelParts) + ")", 8); + } + return figure; + } + + /** Creates the visual representation of a startup trigger. */ + public KEllipse addStartupFigure(KNode node) { + _kNodeExtensions.setMinimalNodeSize(node, 18, 18); + KEllipse figure = _kRenderingExtensions.addEllipse(node); + _kRenderingExtensions.setLineWidth(figure, 1); + _kRenderingExtensions.setBackground(figure, Colors.WHITE); + _linguaFrancaStyleExtensions.noSelectionStyle(figure); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); + return figure; + } + + /** Creates the visual representation of a shutdown trigger. */ + public KPolygon addShutdownFigure(KNode node) { + _kNodeExtensions.setMinimalNodeSize(node, 18, 18); + KPolygon figure = _kRenderingExtensions.addPolygon(node); + _kRenderingExtensions.setLineWidth(figure, 1); + _kRenderingExtensions.setBackground(figure, Colors.WHITE); + _linguaFrancaStyleExtensions.noSelectionStyle(figure); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); + + List pointsToAdd = + List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0), _kRenderingExtensions.createKPosition(RIGHT, 0, 0, TOP, 0, 0.5f), _kRenderingExtensions.createKPosition(RIGHT, 0, 0.5f, BOTTOM, 0, 0), - _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0.5f) - ); - - figure.getPoints().addAll(pointsToAdd); - return figure; - } - - /** - * Creates the visual representation of a shutdown trigger. - */ - public KEllipse addResetFigure(KNode node) { - _kNodeExtensions.setMinimalNodeSize(node, 18, 18); - KEllipse figure = _kRenderingExtensions.addEllipse(node); - _kRenderingExtensions.setLineWidth(figure, 1); - _kRenderingExtensions.setBackground(figure, Colors.WHITE); - _linguaFrancaStyleExtensions.noSelectionStyle(figure); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - - KEllipse resetCircle = _kContainerRenderingExtensions.addEllipse(figure); - _kRenderingExtensions.setSurroundingSpace(resetCircle, 3f, 0); - _kRenderingExtensions.setLineWidth(resetCircle, 1.5f); - _kRenderingExtensions.setBackground(resetCircle, Colors.WHITE); - _linguaFrancaStyleExtensions.noSelectionStyle(resetCircle); - - var resetCycleGap = _kContainerRenderingExtensions.addPolygon(resetCircle); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.RIGHT, 0, 0, PositionReferenceY.TOP, 0.0f, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.RIGHT, 1.1f, 0, PositionReferenceY.BOTTOM, 0, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 1.1f, 0, PositionReferenceY.BOTTOM, 0, 0)); - _kRenderingExtensions.setLineWidth(resetCycleGap, 0.3f); - _kRenderingExtensions.setForeground(resetCycleGap, Colors.WHITE); - _kRenderingExtensions.setBackground(resetCycleGap, Colors.WHITE); - _linguaFrancaStyleExtensions.noSelectionStyle(resetCycleGap); - _kRenderingExtensions.setPointPlacementData(resetCycleGap, - _kRenderingExtensions.LEFT, -2, 0.5f, - _kRenderingExtensions.TOP, 1.5f, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 4.0f, 3.0f); - - var resetArrow = _kContainerRenderingExtensions.addPolygon(resetCircle); - resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0.1f)); - resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0.0f, 0.3f, PositionReferenceY.BOTTOM, 0, 0)); - resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.RIGHT, 0.0f, 0, PositionReferenceY.TOP, 0.0f, 0.0f)); - _kRenderingExtensions.setLineWidth(resetArrow, 0.3f); - _kRenderingExtensions.setBackground(resetArrow, Colors.BLACK); - _linguaFrancaStyleExtensions.noSelectionStyle(resetArrow); - _kRenderingExtensions.setPointPlacementData(resetArrow, - _kRenderingExtensions.LEFT, 1.0f, 0.5f, - _kRenderingExtensions.TOP, 1.8f, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 3.2f, 3.2f); - - return figure; + _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0.5f)); + + figure.getPoints().addAll(pointsToAdd); + return figure; + } + + /** Creates the visual representation of a shutdown trigger. */ + public KEllipse addResetFigure(KNode node) { + _kNodeExtensions.setMinimalNodeSize(node, 18, 18); + KEllipse figure = _kRenderingExtensions.addEllipse(node); + _kRenderingExtensions.setLineWidth(figure, 1); + _kRenderingExtensions.setBackground(figure, Colors.WHITE); + _linguaFrancaStyleExtensions.noSelectionStyle(figure); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); + + KEllipse resetCircle = _kContainerRenderingExtensions.addEllipse(figure); + _kRenderingExtensions.setSurroundingSpace(resetCircle, 3f, 0); + _kRenderingExtensions.setLineWidth(resetCircle, 1.5f); + _kRenderingExtensions.setBackground(resetCircle, Colors.WHITE); + _linguaFrancaStyleExtensions.noSelectionStyle(resetCircle); + + var resetCycleGap = _kContainerRenderingExtensions.addPolygon(resetCircle); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.RIGHT, 0, 0, PositionReferenceY.TOP, 0.0f, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.RIGHT, 1.1f, 0, PositionReferenceY.BOTTOM, 0, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 1.1f, 0, PositionReferenceY.BOTTOM, 0, 0)); + _kRenderingExtensions.setLineWidth(resetCycleGap, 0.3f); + _kRenderingExtensions.setForeground(resetCycleGap, Colors.WHITE); + _kRenderingExtensions.setBackground(resetCycleGap, Colors.WHITE); + _linguaFrancaStyleExtensions.noSelectionStyle(resetCycleGap); + _kRenderingExtensions.setPointPlacementData( + resetCycleGap, + _kRenderingExtensions.LEFT, + -2, + 0.5f, + _kRenderingExtensions.TOP, + 1.5f, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 4.0f, + 3.0f); + + var resetArrow = _kContainerRenderingExtensions.addPolygon(resetCircle); + resetArrow + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0.1f)); + resetArrow + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0.0f, 0.3f, PositionReferenceY.BOTTOM, 0, 0)); + resetArrow + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.RIGHT, 0.0f, 0, PositionReferenceY.TOP, 0.0f, 0.0f)); + _kRenderingExtensions.setLineWidth(resetArrow, 0.3f); + _kRenderingExtensions.setBackground(resetArrow, Colors.BLACK); + _linguaFrancaStyleExtensions.noSelectionStyle(resetArrow); + _kRenderingExtensions.setPointPlacementData( + resetArrow, + _kRenderingExtensions.LEFT, + 1.0f, + 0.5f, + _kRenderingExtensions.TOP, + 1.8f, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 3.2f, + 3.2f); + + return figure; + } + + /** Creates the visual representation of a reactor port. */ + public KPolygon addTrianglePort(KPort port, boolean multiport) { + port.setSize(8, 8); + + // Create triangle port + KPolygon trianglePort = _kRenderingExtensions.addPolygon(port); + + // Set line width and background color according to multiport or not + float lineWidth = multiport ? 2.2f : 1; + _kRenderingExtensions.setLineWidth(trianglePort, lineWidth); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(trianglePort); + Colors background = multiport ? Colors.WHITE : Colors.BLACK; + _kRenderingExtensions.setBackground(trianglePort, background); + + List pointsToAdd; + if (multiport) { + // Compensate for line width by making triangle smaller + // Do not adjust by port size because this will affect port distribution and cause offsets + // between parallel connections + pointsToAdd = + List.of( + _kRenderingExtensions.createKPosition(LEFT, 0, 0, TOP, 0.6f, 0), + _kRenderingExtensions.createKPosition(RIGHT, 1.2f, 0, TOP, 0, 0.5f), + _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0.6f, 0)); + } else { + pointsToAdd = + List.of( + _kRenderingExtensions.createKPosition(LEFT, 0, 0, TOP, 0, 0), + _kRenderingExtensions.createKPosition(RIGHT, 0, 0, TOP, 0, 0.5f), + _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0)); } - - /** - * Creates the visual representation of a reactor port. - */ - public KPolygon addTrianglePort(KPort port, boolean multiport) { - port.setSize(8, 8); - - // Create triangle port - KPolygon trianglePort = _kRenderingExtensions.addPolygon(port); - - // Set line width and background color according to multiport or not - float lineWidth = multiport ? 2.2f : 1; - _kRenderingExtensions.setLineWidth(trianglePort, lineWidth); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(trianglePort); - Colors background = multiport ? Colors.WHITE : Colors.BLACK; - _kRenderingExtensions.setBackground(trianglePort, background); - - List pointsToAdd; - if (multiport) { - // Compensate for line width by making triangle smaller - // Do not adjust by port size because this will affect port distribution and cause offsets between parallel connections - pointsToAdd = List.of( - _kRenderingExtensions.createKPosition(LEFT, 0, 0, TOP, 0.6f, 0), - _kRenderingExtensions.createKPosition(RIGHT, 1.2f, 0, TOP, 0, 0.5f), - _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0.6f, 0) - ); - } else { - pointsToAdd = List.of( - _kRenderingExtensions.createKPosition(LEFT, 0, 0, TOP, 0, 0), - _kRenderingExtensions.createKPosition(RIGHT, 0, 0, TOP, 0, 0.5f), - _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0) - ); - } - trianglePort.getPoints().addAll(pointsToAdd); - return trianglePort; - } - - /** - * Added a text as collapse expand button. - */ - public KText addTextButton(KContainerRendering container, String text) { - KText textToAdd = _kContainerRenderingExtensions.addText(container, text); - _kRenderingExtensions.setForeground(textToAdd, Colors.BLUE); - _kRenderingExtensions.setFontSize(textToAdd, 8); - _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); - return textToAdd; - } - - /** - * Creates the triangular line decorator with text. - */ - public KPolygon addActionDecorator(KPolyline line, String text) { - final float size = 18; - - // Create action decorator - KPolygon actionDecorator = _kContainerRenderingExtensions.addPolygon(line); - _kRenderingExtensions.setBackground(actionDecorator, Colors.WHITE); - List pointsToAdd = List.of( + trianglePort.getPoints().addAll(pointsToAdd); + return trianglePort; + } + + /** Added a text as collapse expand button. */ + public KText addTextButton(KContainerRendering container, String text) { + KText textToAdd = _kContainerRenderingExtensions.addText(container, text); + _kRenderingExtensions.setForeground(textToAdd, Colors.BLUE); + _kRenderingExtensions.setFontSize(textToAdd, 8); + _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); + return textToAdd; + } + + /** Creates the triangular line decorator with text. */ + public KPolygon addActionDecorator(KPolyline line, String text) { + final float size = 18; + + // Create action decorator + KPolygon actionDecorator = _kContainerRenderingExtensions.addPolygon(line); + _kRenderingExtensions.setBackground(actionDecorator, Colors.WHITE); + List pointsToAdd = + List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0), _kRenderingExtensions.createKPosition(RIGHT, 0, 0, BOTTOM, 0, 0), - _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0) - ); - actionDecorator.getPoints().addAll(pointsToAdd); - - // Set placement data of the action decorator - KDecoratorPlacementData placementData = _kRenderingFactory.createKDecoratorPlacementData(); - placementData.setRelative(0.5f); - placementData.setAbsolute(-size / 2); - placementData.setWidth(size); - placementData.setHeight(size); - placementData.setYOffset(-size * 0.66f); - placementData.setRotateWithLine(true); - actionDecorator.setPlacementData(placementData); - - // Add text to the action decorator - KText textToAdd = _kContainerRenderingExtensions.addText(actionDecorator, text); - _kRenderingExtensions.setFontSize(textToAdd, 8); - _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); - DiagramSyntheses.suppressSelectability(textToAdd); - _kRenderingExtensions.setPointPlacementData(textToAdd, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, size * 0.15f, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, - 0, size, size); - - return actionDecorator; - } - - /** - * Creates the triangular action node with text and ports. - */ - public Pair addActionFigureAndPorts(KNode node, String text) { - final float size = 18; - _kNodeExtensions.setMinimalNodeSize(node, size, size); - KPolygon figure = _kRenderingExtensions.addPolygon(node); - _kRenderingExtensions.setBackground(figure, Colors.WHITE); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - - List pointsToAdd = List.of( + _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0)); + actionDecorator.getPoints().addAll(pointsToAdd); + + // Set placement data of the action decorator + KDecoratorPlacementData placementData = _kRenderingFactory.createKDecoratorPlacementData(); + placementData.setRelative(0.5f); + placementData.setAbsolute(-size / 2); + placementData.setWidth(size); + placementData.setHeight(size); + placementData.setYOffset(-size * 0.66f); + placementData.setRotateWithLine(true); + actionDecorator.setPlacementData(placementData); + + // Add text to the action decorator + KText textToAdd = _kContainerRenderingExtensions.addText(actionDecorator, text); + _kRenderingExtensions.setFontSize(textToAdd, 8); + _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); + DiagramSyntheses.suppressSelectability(textToAdd); + _kRenderingExtensions.setPointPlacementData( + textToAdd, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.TOP, + size * 0.15f, + 0.5f, + _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + size, + size); + + return actionDecorator; + } + + /** Creates the triangular action node with text and ports. */ + public Pair addActionFigureAndPorts(KNode node, String text) { + final float size = 18; + _kNodeExtensions.setMinimalNodeSize(node, size, size); + KPolygon figure = _kRenderingExtensions.addPolygon(node); + _kRenderingExtensions.setBackground(figure, Colors.WHITE); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); + + List pointsToAdd = + List.of( _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0), _kRenderingExtensions.createKPosition(RIGHT, 0, 0, BOTTOM, 0, 0), - _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0) - ); - figure.getPoints().addAll(pointsToAdd); - - // Add text to the action figure - KText textToAdd = _kContainerRenderingExtensions.addText(figure, text); - _kRenderingExtensions.setFontSize(textToAdd, 8); - _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); - DiagramSyntheses.suppressSelectability(textToAdd); - _kRenderingExtensions.setPointPlacementData(textToAdd, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, (size * 0.15f), 0.5f, - _kRenderingExtensions.H_CENTRAL, - _kRenderingExtensions.V_CENTRAL, 0, 0, size, size); - - // Add input port - KPort in = _kPortExtensions.createPort(); - node.getPorts().add(in); - in.setSize(0, 0); - DiagramSyntheses.setLayoutOption(in, CoreOptions.PORT_SIDE, PortSide.WEST); - DiagramSyntheses.setLayoutOption(in, CoreOptions.PORT_BORDER_OFFSET, -size / ((double) 4)); - - // Add output port - KPort out = _kPortExtensions.createPort(); - node.getPorts().add(out); - DiagramSyntheses.setLayoutOption(out, CoreOptions.PORT_SIDE, PortSide.EAST); - DiagramSyntheses.setLayoutOption(out, CoreOptions.PORT_BORDER_OFFSET, -size / ((double) 4)); - return new Pair(in, out); + _kRenderingExtensions.createKPosition(LEFT, 0, 0, BOTTOM, 0, 0)); + figure.getPoints().addAll(pointsToAdd); + + // Add text to the action figure + KText textToAdd = _kContainerRenderingExtensions.addText(figure, text); + _kRenderingExtensions.setFontSize(textToAdd, 8); + _linguaFrancaStyleExtensions.noSelectionStyle(textToAdd); + DiagramSyntheses.suppressSelectability(textToAdd); + _kRenderingExtensions.setPointPlacementData( + textToAdd, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.TOP, + (size * 0.15f), + 0.5f, + _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + size, + size); + + // Add input port + KPort in = _kPortExtensions.createPort(); + node.getPorts().add(in); + in.setSize(0, 0); + DiagramSyntheses.setLayoutOption(in, CoreOptions.PORT_SIDE, PortSide.WEST); + DiagramSyntheses.setLayoutOption(in, CoreOptions.PORT_BORDER_OFFSET, -size / ((double) 4)); + + // Add output port + KPort out = _kPortExtensions.createPort(); + node.getPorts().add(out); + DiagramSyntheses.setLayoutOption(out, CoreOptions.PORT_SIDE, PortSide.EAST); + DiagramSyntheses.setLayoutOption(out, CoreOptions.PORT_BORDER_OFFSET, -size / ((double) 4)); + return new Pair(in, out); + } + + /** Creates and adds an error message figure */ + public KRectangle addErrorMessage(KNode node, String title, String message) { + // Create figure for error message + KRectangle figure = _kRenderingExtensions.addRectangle(node); + _kRenderingExtensions.setInvisible(figure, true); + + // Add error message box + KRoundedRectangle errMsgBox = _kContainerRenderingExtensions.addRoundedRectangle(figure, 7, 7); + _kContainerRenderingExtensions.setGridPlacement(errMsgBox, 1); + _kRenderingExtensions.setLineWidth(errMsgBox, 2); + _linguaFrancaStyleExtensions.noSelectionStyle(errMsgBox); + + if (title != null) { + // Add title to error message box + KText titleText = _kContainerRenderingExtensions.addText(errMsgBox, title); + _kRenderingExtensions.setFontSize(titleText, 12); + _kRenderingExtensions.setFontBold(titleText, true); + _kRenderingExtensions.setForeground(titleText, Colors.RED); + setGridPlacementDataFromPointToPoint( + titleText, + _kRenderingExtensions.LEFT, + 8, + 0, + _kRenderingExtensions.TOP, + 8, + 0, + _kRenderingExtensions.RIGHT, + 8, + 0, + _kRenderingExtensions.BOTTOM, + 4, + 0); + DiagramSyntheses.suppressSelectability(titleText); + _linguaFrancaStyleExtensions.noSelectionStyle(titleText); } - /** - * Creates and adds an error message figure - */ - public KRectangle addErrorMessage(KNode node, String title, String message) { - // Create figure for error message - KRectangle figure = _kRenderingExtensions.addRectangle(node); - _kRenderingExtensions.setInvisible(figure, true); - - // Add error message box - KRoundedRectangle errMsgBox = _kContainerRenderingExtensions.addRoundedRectangle(figure, 7, 7); - _kContainerRenderingExtensions.setGridPlacement(errMsgBox, 1); - _kRenderingExtensions.setLineWidth(errMsgBox, 2); - _linguaFrancaStyleExtensions.noSelectionStyle(errMsgBox); - - if (title != null) { - // Add title to error message box - KText titleText = _kContainerRenderingExtensions.addText(errMsgBox, title); - _kRenderingExtensions.setFontSize(titleText, 12); - _kRenderingExtensions.setFontBold(titleText, true); - _kRenderingExtensions.setForeground(titleText, Colors.RED); - setGridPlacementDataFromPointToPoint(titleText, - _kRenderingExtensions.LEFT, 8, 0, - _kRenderingExtensions.TOP, 8, 0, - _kRenderingExtensions.RIGHT, 8, 0, - _kRenderingExtensions.BOTTOM, 4, 0); - DiagramSyntheses.suppressSelectability(titleText); - _linguaFrancaStyleExtensions.noSelectionStyle(titleText); - } - - if (message != null) { - // Add message to error message box - KText msgText = _kContainerRenderingExtensions.addText(errMsgBox, message); - if (title != null) { - setGridPlacementDataFromPointToPoint(msgText, - _kRenderingExtensions.LEFT, 8, 0, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.RIGHT, 8, 0, - _kRenderingExtensions.BOTTOM, 4, 0); - } else { - setGridPlacementDataFromPointToPoint(msgText, - _kRenderingExtensions.LEFT, 8, 0, - _kRenderingExtensions.TOP, 8, 0, - _kRenderingExtensions.RIGHT, 8, 0, - _kRenderingExtensions.BOTTOM, 8, 0); - } - _linguaFrancaStyleExtensions.noSelectionStyle(msgText); - } - return figure; + if (message != null) { + // Add message to error message box + KText msgText = _kContainerRenderingExtensions.addText(errMsgBox, message); + if (title != null) { + setGridPlacementDataFromPointToPoint( + msgText, + _kRenderingExtensions.LEFT, + 8, + 0, + _kRenderingExtensions.TOP, + 0, + 0, + _kRenderingExtensions.RIGHT, + 8, + 0, + _kRenderingExtensions.BOTTOM, + 4, + 0); + } else { + setGridPlacementDataFromPointToPoint( + msgText, + _kRenderingExtensions.LEFT, + 8, + 0, + _kRenderingExtensions.TOP, + 8, + 0, + _kRenderingExtensions.RIGHT, + 8, + 0, + _kRenderingExtensions.BOTTOM, + 8, + 0); + } + _linguaFrancaStyleExtensions.noSelectionStyle(msgText); } - - public KRoundedRectangle addCommentFigure(KNode node, String message) { - // Create rectangle for comment figure - KRoundedRectangle commentFigure = _kRenderingExtensions.addRoundedRectangle(node, 1, 1, 1); - _kContainerRenderingExtensions.setGridPlacement(commentFigure, 1); - - // Add message - KText text = _kContainerRenderingExtensions.addText(commentFigure, message); - _kRenderingExtensions.setFontSize(text, 6); - setGridPlacementDataFromPointToPoint(text, - _kRenderingExtensions.LEFT, 3, 0, - _kRenderingExtensions.TOP, 3, 0, - _kRenderingExtensions.RIGHT, 3, 0, - _kRenderingExtensions.BOTTOM, 3, 0); - _linguaFrancaStyleExtensions.noSelectionStyle(text); - return commentFigure; - } - - private KRendering setGridPlacementDataFromPointToPoint(KRendering rendering, - PositionReferenceX fPx, float fAbsoluteLR, float fRelativeLR, - PositionReferenceY fPy, float fAbsoluteTB, float fRelativeTB, - PositionReferenceX tPx, float tAbsoluteLR, float tRelativeLR, - PositionReferenceY tPy, float tAbsoluteTB, float tRelativeTB) { - KAreaPlacementData fromPoint = _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rendering), - fPx, fAbsoluteLR, fRelativeLR, - fPy, fAbsoluteTB, fRelativeTB); - return _kRenderingExtensions.to(fromPoint, - tPx, tAbsoluteLR, tRelativeLR, - tPy, tAbsoluteTB, tRelativeTB); - } - - - public KPolyline addCommentPolyline(KEdge edge) { - KPolyline polyline = _kEdgeExtensions.addPolyline(edge); - _kRenderingExtensions.setLineWidth(polyline, 1); - _kRenderingExtensions.setLineStyle(polyline, LineStyle.DOT); - return polyline; - } - - public KContainerRendering addParameterEntry(KContainerRendering parent, Parameter associate, String text) { - KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); - _kRenderingExtensions.setInvisible(container, true); - - var ktext = _kContainerRenderingExtensions.addText(container, text); - _kRenderingExtensions.setFontSize(ktext, 8); - _kRenderingExtensions.setPointPlacementData(ktext, - _kRenderingExtensions.LEFT, 10, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 0, 0); - associateWith(ktext, associate); - - var dot = _kContainerRenderingExtensions.addEllipse(container); - _kRenderingExtensions.setLineWidth(dot, 1); - _linguaFrancaStyleExtensions.noSelectionStyle(dot); - _kRenderingExtensions.setPointPlacementData(dot, - _kRenderingExtensions.LEFT, 2, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 5, 5); - - return container; - } - - - public KContainerRendering addStateEntry(KContainerRendering parent, StateVar associate, String text, boolean reset) { - KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); - _kRenderingExtensions.setInvisible(container, true); - - var ktext = _kContainerRenderingExtensions.addText(container, text); - _kRenderingExtensions.setFontSize(ktext, 8); - _kRenderingExtensions.setPointPlacementData(ktext, - _kRenderingExtensions.LEFT, 10, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 0, 0); - associateWith(ktext, associate); - - KEllipse outerCircle; - - if (reset) { - outerCircle = _kContainerRenderingExtensions.addEllipse(container); - _kRenderingExtensions.setLineWidth(outerCircle, 0.9f); - _kRenderingExtensions.setBackground(outerCircle, Colors.WHITE); - _linguaFrancaStyleExtensions.noSelectionStyle(outerCircle); - _kRenderingExtensions.setPointPlacementData(outerCircle, - _kRenderingExtensions.LEFT, 1.5f, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 6.3f, 6.3f); - - var resetCycleGap = _kContainerRenderingExtensions.addPolygon(outerCircle); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.26f, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0.2f, PositionReferenceY.TOP, 0.1f, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0.5f, PositionReferenceY.TOP, 0.0f, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.RIGHT, 0, 0.2f, PositionReferenceY.TOP, 0.1f, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.RIGHT, 0, 0, PositionReferenceY.TOP, 0.26f, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.RIGHT, 0.5f, 0, PositionReferenceY.BOTTOM, 0, 0)); - resetCycleGap.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0.5f, 0, PositionReferenceY.BOTTOM, 0, 0)); - _kRenderingExtensions.setLineWidth(resetCycleGap, 0.3f); - _kRenderingExtensions.setForeground(resetCycleGap, Colors.WHITE); - _kRenderingExtensions.setBackground(resetCycleGap, Colors.WHITE); - _linguaFrancaStyleExtensions.noSelectionStyle(resetCycleGap); - _kRenderingExtensions.setPointPlacementData(resetCycleGap, - _kRenderingExtensions.LEFT, -1.2f, 0.5f, - _kRenderingExtensions.TOP, 0.75f, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 2.5f, 1.3f); - - var resetArrow = _kContainerRenderingExtensions.addPolygon(outerCircle); - resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0.1f)); - resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.LEFT, 0.0f, 0.3f, PositionReferenceY.BOTTOM, 0, 0)); - resetArrow.getPoints().add(_kRenderingExtensions.createKPosition(PositionReferenceX.RIGHT, 0.0f, 0, PositionReferenceY.TOP, 0.0f, 0.0f)); - _kRenderingExtensions.setLineWidth(resetArrow, 0.3f); - _kRenderingExtensions.setBackground(resetArrow, Colors.BLACK); - _linguaFrancaStyleExtensions.noSelectionStyle(resetArrow); - _kRenderingExtensions.setPointPlacementData(resetArrow, - _kRenderingExtensions.LEFT, 0.8f, 0.5f, - _kRenderingExtensions.TOP, 1.1f, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 1.5f, 1.5f); - } else { - outerCircle = _kContainerRenderingExtensions.addEllipse(container); - _kRenderingExtensions.setLineWidth(outerCircle, 1); - _kRenderingExtensions.setBackground(outerCircle, Colors.WHITE); - _linguaFrancaStyleExtensions.noSelectionStyle(outerCircle); - _kRenderingExtensions.setPointPlacementData(outerCircle, - _kRenderingExtensions.LEFT, 1.5f, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_CENTRAL, - 0, 0, 6, 6); - } - - var innerDot = _kContainerRenderingExtensions.addEllipse(outerCircle); - _kRenderingExtensions.setLineWidth(innerDot, 0.5f); - _kRenderingExtensions.setBackground(innerDot, Colors.BLACK); - _linguaFrancaStyleExtensions.noSelectionStyle(innerDot); - _kRenderingExtensions.setPointPlacementData(innerDot, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, - 0, 0, 2.5f, 2.5f); - - return container; + return figure; + } + + public KRoundedRectangle addCommentFigure(KNode node, String message) { + // Create rectangle for comment figure + KRoundedRectangle commentFigure = _kRenderingExtensions.addRoundedRectangle(node, 1, 1, 1); + _kContainerRenderingExtensions.setGridPlacement(commentFigure, 1); + + // Add message + KText text = _kContainerRenderingExtensions.addText(commentFigure, message); + _kRenderingExtensions.setFontSize(text, 6); + setGridPlacementDataFromPointToPoint( + text, + _kRenderingExtensions.LEFT, + 3, + 0, + _kRenderingExtensions.TOP, + 3, + 0, + _kRenderingExtensions.RIGHT, + 3, + 0, + _kRenderingExtensions.BOTTOM, + 3, + 0); + _linguaFrancaStyleExtensions.noSelectionStyle(text); + return commentFigure; + } + + private KRendering setGridPlacementDataFromPointToPoint( + KRendering rendering, + PositionReferenceX fPx, + float fAbsoluteLR, + float fRelativeLR, + PositionReferenceY fPy, + float fAbsoluteTB, + float fRelativeTB, + PositionReferenceX tPx, + float tAbsoluteLR, + float tRelativeLR, + PositionReferenceY tPy, + float tAbsoluteTB, + float tRelativeTB) { + KAreaPlacementData fromPoint = + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rendering), + fPx, + fAbsoluteLR, + fRelativeLR, + fPy, + fAbsoluteTB, + fRelativeTB); + return _kRenderingExtensions.to( + fromPoint, tPx, tAbsoluteLR, tRelativeLR, tPy, tAbsoluteTB, tRelativeTB); + } + + public KPolyline addCommentPolyline(KEdge edge) { + KPolyline polyline = _kEdgeExtensions.addPolyline(edge); + _kRenderingExtensions.setLineWidth(polyline, 1); + _kRenderingExtensions.setLineStyle(polyline, LineStyle.DOT); + return polyline; + } + + public KContainerRendering addParameterEntry( + KContainerRendering parent, Parameter associate, String text) { + KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); + _kRenderingExtensions.setInvisible(container, true); + + var ktext = _kContainerRenderingExtensions.addText(container, text); + _kRenderingExtensions.setFontSize(ktext, 8); + _kRenderingExtensions.setPointPlacementData( + ktext, + _kRenderingExtensions.LEFT, + 10, + 0, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 0, + 0); + associateWith(ktext, associate); + + var dot = _kContainerRenderingExtensions.addEllipse(container); + _kRenderingExtensions.setLineWidth(dot, 1); + _linguaFrancaStyleExtensions.noSelectionStyle(dot); + _kRenderingExtensions.setPointPlacementData( + dot, + _kRenderingExtensions.LEFT, + 2, + 0, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 5, + 5); + + return container; + } + + public KContainerRendering addStateEntry( + KContainerRendering parent, StateVar associate, String text, boolean reset) { + KRectangle container = _kContainerRenderingExtensions.addRectangle(parent); + _kRenderingExtensions.setInvisible(container, true); + + var ktext = _kContainerRenderingExtensions.addText(container, text); + _kRenderingExtensions.setFontSize(ktext, 8); + _kRenderingExtensions.setPointPlacementData( + ktext, + _kRenderingExtensions.LEFT, + 10, + 0, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 0, + 0); + associateWith(ktext, associate); + + KEllipse outerCircle; + + if (reset) { + outerCircle = _kContainerRenderingExtensions.addEllipse(container); + _kRenderingExtensions.setLineWidth(outerCircle, 0.9f); + _kRenderingExtensions.setBackground(outerCircle, Colors.WHITE); + _linguaFrancaStyleExtensions.noSelectionStyle(outerCircle); + _kRenderingExtensions.setPointPlacementData( + outerCircle, + _kRenderingExtensions.LEFT, + 1.5f, + 0, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 6.3f, + 6.3f); + + var resetCycleGap = _kContainerRenderingExtensions.addPolygon(outerCircle); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.26f, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0, 0.2f, PositionReferenceY.TOP, 0.1f, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0, 0.5f, PositionReferenceY.TOP, 0.0f, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.RIGHT, 0, 0.2f, PositionReferenceY.TOP, 0.1f, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.RIGHT, 0, 0, PositionReferenceY.TOP, 0.26f, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.RIGHT, 0.5f, 0, PositionReferenceY.BOTTOM, 0, 0)); + resetCycleGap + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0.5f, 0, PositionReferenceY.BOTTOM, 0, 0)); + _kRenderingExtensions.setLineWidth(resetCycleGap, 0.3f); + _kRenderingExtensions.setForeground(resetCycleGap, Colors.WHITE); + _kRenderingExtensions.setBackground(resetCycleGap, Colors.WHITE); + _linguaFrancaStyleExtensions.noSelectionStyle(resetCycleGap); + _kRenderingExtensions.setPointPlacementData( + resetCycleGap, + _kRenderingExtensions.LEFT, + -1.2f, + 0.5f, + _kRenderingExtensions.TOP, + 0.75f, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 2.5f, + 1.3f); + + var resetArrow = _kContainerRenderingExtensions.addPolygon(outerCircle); + resetArrow + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0, 0, PositionReferenceY.TOP, 0.0f, 0.1f)); + resetArrow + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.LEFT, 0.0f, 0.3f, PositionReferenceY.BOTTOM, 0, 0)); + resetArrow + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + PositionReferenceX.RIGHT, 0.0f, 0, PositionReferenceY.TOP, 0.0f, 0.0f)); + _kRenderingExtensions.setLineWidth(resetArrow, 0.3f); + _kRenderingExtensions.setBackground(resetArrow, Colors.BLACK); + _linguaFrancaStyleExtensions.noSelectionStyle(resetArrow); + _kRenderingExtensions.setPointPlacementData( + resetArrow, + _kRenderingExtensions.LEFT, + 0.8f, + 0.5f, + _kRenderingExtensions.TOP, + 1.1f, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 1.5f, + 1.5f); + } else { + outerCircle = _kContainerRenderingExtensions.addEllipse(container); + _kRenderingExtensions.setLineWidth(outerCircle, 1); + _kRenderingExtensions.setBackground(outerCircle, Colors.WHITE); + _linguaFrancaStyleExtensions.noSelectionStyle(outerCircle); + _kRenderingExtensions.setPointPlacementData( + outerCircle, + _kRenderingExtensions.LEFT, + 1.5f, + 0, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 6, + 6); } + var innerDot = _kContainerRenderingExtensions.addEllipse(outerCircle); + _kRenderingExtensions.setLineWidth(innerDot, 0.5f); + _kRenderingExtensions.setBackground(innerDot, Colors.BLACK); + _linguaFrancaStyleExtensions.noSelectionStyle(innerDot); + _kRenderingExtensions.setPointPlacementData( + innerDot, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 2.5f, + 2.5f); + + return container; + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java b/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java index f4c0aefd98..6eb2cfd7f0 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java @@ -1,29 +1,32 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.styles; +import static de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceX.*; +import static de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceY.*; + import de.cau.cs.kieler.klighd.internal.util.KlighdInternalProperties; import de.cau.cs.kieler.klighd.kgraph.KEdge; import de.cau.cs.kieler.klighd.kgraph.KLabel; @@ -48,7 +51,6 @@ import de.cau.cs.kieler.klighd.labels.decoration.IDecoratorRenderingProvider; import de.cau.cs.kieler.klighd.labels.decoration.LabelDecorationConfigurator; import java.util.List; - import javax.inject.Inject; import org.eclipse.elk.core.math.ElkPadding; import org.eclipse.elk.graph.properties.Property; @@ -56,415 +58,469 @@ import org.eclipse.xtext.xbase.lib.Extension; import org.lflang.diagram.synthesis.AbstractSynthesisExtensions; -import static de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceX.*; -import static de.cau.cs.kieler.klighd.krendering.extensions.PositionReferenceY.*; - /** * Extension class that provides styles and coloring for the Lingua France diagram synthesis. - * + * * @author Alexander Schulz-Rosengarten */ @ViewSynthesisShared public class LinguaFrancaStyleExtensions extends AbstractSynthesisExtensions { - - /** - * INTERNAL property to communicate a node's background color. - */ - public static final Property LABEL_PARENT_BACKGROUND = new Property<>( - "org.lflang.linguafranca.diagram.synthesis.styles.label.parent.background", Colors.WHITE); - - @Inject - @Extension - private KRenderingExtensions _kRenderingExtensions; - @Inject - @Extension - private KContainerRenderingExtensions _kContainerRenderingExtensions; - @Inject - @Extension - private KPolylineExtensions _kPolylineExtensions; - @Extension - private KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; - - public KRendering noSelectionStyle(KRendering r) { - return _kRenderingExtensions.setSelectionTextStrikeout(r, false); - } - - public KRendering underlineSelectionStyle(KRendering r) { - return _kRenderingExtensions.setSelectionTextUnderline(r, Underline.SINGLE); - } - - public KRendering boldLineSelectionStyle(KRendering r) { - float lineWidthValue = _kRenderingExtensions.getLineWidthValue(r); - return _kRenderingExtensions.setSelectionLineWidth(r, lineWidthValue * 2); - } - - public KText boldTextSelectionStyle(KText t) { - return _kRenderingExtensions.setSelectionFontBold(t, true); - } - - public void errorStyle(KRendering r) { - _kRenderingExtensions.setForeground(r, Colors.RED); - _kRenderingExtensions.setLineWidth(r, 2); - _kRenderingExtensions.setSelectionLineWidth(r, 3); - - // Set background color the body if its a port or an line decorator - if (r.eContainer() instanceof KPort || r.eContainer() instanceof KPolyline) { - _kRenderingExtensions.setBackground(r, Colors.RED); - _kRenderingExtensions.getBackground(r).setPropagateToChildren(true); - _kRenderingExtensions.getForeground(r).setPropagateToChildren(true); - _kRenderingExtensions.getLineWidth(r).setPropagateToChildren(true); - } else if (r.eContainer() instanceof KEdge && r instanceof KPolyline) { - // As a workaround for a rendering issue in Klighd VSCode, the style is applied to polyline - // children directly because a propagated background would lead to a filled edge area. - // See https://github.com/kieler/klighd-vscode/issues/67 - // If fixed this commit can be reverted - ((KPolyline) r).getChildren().stream().forEach(c -> errorStyle(c)); - } - } - - public void commentStyle(KRendering r) { - _kRenderingExtensions.setForeground(r, Colors.LIGHT_GOLDENROD); - _kRenderingExtensions.setBackground(r, Colors.PALE_GOLDENROD); - _kRenderingExtensions.setLineWidth(r, 1); - _kRenderingExtensions.setSelectionLineWidth(r, 2); - - if (r.eContainer() instanceof KEdge) { // also color potential arrow heads - _kRenderingExtensions.setBackground(r, Colors.LIGHT_GOLDENROD); - _kRenderingExtensions.getBackground(r).setPropagateToChildren(true); - _kRenderingExtensions.getForeground(r).setPropagateToChildren(true); - _kRenderingExtensions.getLineWidth(r).setPropagateToChildren(true); - } + + /** INTERNAL property to communicate a node's background color. */ + public static final Property LABEL_PARENT_BACKGROUND = + new Property<>( + "org.lflang.linguafranca.diagram.synthesis.styles.label.parent.background", Colors.WHITE); + + @Inject @Extension private KRenderingExtensions _kRenderingExtensions; + @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; + @Inject @Extension private KPolylineExtensions _kPolylineExtensions; + @Extension private KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; + + public KRendering noSelectionStyle(KRendering r) { + return _kRenderingExtensions.setSelectionTextStrikeout(r, false); + } + + public KRendering underlineSelectionStyle(KRendering r) { + return _kRenderingExtensions.setSelectionTextUnderline(r, Underline.SINGLE); + } + + public KRendering boldLineSelectionStyle(KRendering r) { + float lineWidthValue = _kRenderingExtensions.getLineWidthValue(r); + return _kRenderingExtensions.setSelectionLineWidth(r, lineWidthValue * 2); + } + + public KText boldTextSelectionStyle(KText t) { + return _kRenderingExtensions.setSelectionFontBold(t, true); + } + + public void errorStyle(KRendering r) { + _kRenderingExtensions.setForeground(r, Colors.RED); + _kRenderingExtensions.setLineWidth(r, 2); + _kRenderingExtensions.setSelectionLineWidth(r, 3); + + // Set background color the body if its a port or an line decorator + if (r.eContainer() instanceof KPort || r.eContainer() instanceof KPolyline) { + _kRenderingExtensions.setBackground(r, Colors.RED); + _kRenderingExtensions.getBackground(r).setPropagateToChildren(true); + _kRenderingExtensions.getForeground(r).setPropagateToChildren(true); + _kRenderingExtensions.getLineWidth(r).setPropagateToChildren(true); + } else if (r.eContainer() instanceof KEdge && r instanceof KPolyline) { + // As a workaround for a rendering issue in Klighd VSCode, the style is applied to polyline + // children directly because a propagated background would lead to a filled edge area. + // See https://github.com/kieler/klighd-vscode/issues/67 + // If fixed this commit can be reverted + ((KPolyline) r).getChildren().stream().forEach(c -> errorStyle(c)); } - - private static final int CLOUD_WIDTH = 20; - public KContainerRendering addCloudIcon(final KContainerRendering parent) { - KRectangle figure = _kContainerRenderingExtensions.addRectangle(parent); - _kRenderingExtensions.setInvisible(figure, true); - - KRoundedRectangle roundRectangle = _kContainerRenderingExtensions.addRoundedRectangle( - figure, - CLOUD_WIDTH / 7, - CLOUD_WIDTH / 7 - ); - _kRenderingExtensions.setBackground(roundRectangle, Colors.GRAY); - _kRenderingExtensions.setForeground(roundRectangle, Colors.GRAY); - _kRenderingExtensions.setPointPlacementData(roundRectangle, - _kRenderingExtensions.LEFT, 2, 0, - _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, - 0, CLOUD_WIDTH, CLOUD_WIDTH / 3); - - KEllipse childEllipse = _kContainerRenderingExtensions.addEllipse(figure); - _kRenderingExtensions.setBackground(childEllipse, Colors.GRAY); - _kRenderingExtensions.setForeground(childEllipse, Colors.GRAY); - _kRenderingExtensions.setPointPlacementData(childEllipse, - _kRenderingExtensions.LEFT, 0, 0f, - _kRenderingExtensions.TOP, 0, 0.38f, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, - 0, CLOUD_WIDTH / 2.5f, CLOUD_WIDTH / 2.5f); - - childEllipse = _kContainerRenderingExtensions.addEllipse(figure); - _kRenderingExtensions.setBackground(childEllipse, Colors.GRAY); - _kRenderingExtensions.setForeground(childEllipse, Colors.GRAY); - _kRenderingExtensions.setPointPlacementData(childEllipse, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, 0, 0.25f, - _kRenderingExtensions.H_RIGHT, _kRenderingExtensions.V_TOP, 0, - 0, CLOUD_WIDTH / 3f, CLOUD_WIDTH / 3f); - - childEllipse = _kContainerRenderingExtensions.addEllipse(figure); - _kRenderingExtensions.setBackground(childEllipse, Colors.GRAY); - _kRenderingExtensions.setForeground(childEllipse, Colors.GRAY); - _kRenderingExtensions.setPointPlacementData(childEllipse, - _kRenderingExtensions.LEFT, 0, 0.4f, - _kRenderingExtensions.TOP, CLOUD_WIDTH / 10, 0, - _kRenderingExtensions.H_LEFT, _kRenderingExtensions.V_TOP, 0, - 0, CLOUD_WIDTH / 2, CLOUD_WIDTH / 2); - - return figure; + } + + public void commentStyle(KRendering r) { + _kRenderingExtensions.setForeground(r, Colors.LIGHT_GOLDENROD); + _kRenderingExtensions.setBackground(r, Colors.PALE_GOLDENROD); + _kRenderingExtensions.setLineWidth(r, 1); + _kRenderingExtensions.setSelectionLineWidth(r, 2); + + if (r.eContainer() instanceof KEdge) { // also color potential arrow heads + _kRenderingExtensions.setBackground(r, Colors.LIGHT_GOLDENROD); + _kRenderingExtensions.getBackground(r).setPropagateToChildren(true); + _kRenderingExtensions.getForeground(r).setPropagateToChildren(true); + _kRenderingExtensions.getLineWidth(r).setPropagateToChildren(true); } - - public KRendering addCloudUploadIcon(KContainerRendering parent) { - KContainerRendering cloudIcon = addCloudIcon(parent); - KPolygon cloudPolygon = _kContainerRenderingExtensions.addPolygon(cloudIcon); - _kRenderingExtensions.setBackground(cloudPolygon, Colors.WHITE); - _kRenderingExtensions.setForeground(cloudPolygon, Colors.WHITE); - cloudPolygon.getPoints().addAll( + } + + private static final int CLOUD_WIDTH = 20; + + public KContainerRendering addCloudIcon(final KContainerRendering parent) { + KRectangle figure = _kContainerRenderingExtensions.addRectangle(parent); + _kRenderingExtensions.setInvisible(figure, true); + + KRoundedRectangle roundRectangle = + _kContainerRenderingExtensions.addRoundedRectangle( + figure, CLOUD_WIDTH / 7, CLOUD_WIDTH / 7); + _kRenderingExtensions.setBackground(roundRectangle, Colors.GRAY); + _kRenderingExtensions.setForeground(roundRectangle, Colors.GRAY); + _kRenderingExtensions.setPointPlacementData( + roundRectangle, + _kRenderingExtensions.LEFT, + 2, + 0, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_TOP, + 0, + 0, + CLOUD_WIDTH, + CLOUD_WIDTH / 3); + + KEllipse childEllipse = _kContainerRenderingExtensions.addEllipse(figure); + _kRenderingExtensions.setBackground(childEllipse, Colors.GRAY); + _kRenderingExtensions.setForeground(childEllipse, Colors.GRAY); + _kRenderingExtensions.setPointPlacementData( + childEllipse, + _kRenderingExtensions.LEFT, + 0, + 0f, + _kRenderingExtensions.TOP, + 0, + 0.38f, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_TOP, + 0, + 0, + CLOUD_WIDTH / 2.5f, + CLOUD_WIDTH / 2.5f); + + childEllipse = _kContainerRenderingExtensions.addEllipse(figure); + _kRenderingExtensions.setBackground(childEllipse, Colors.GRAY); + _kRenderingExtensions.setForeground(childEllipse, Colors.GRAY); + _kRenderingExtensions.setPointPlacementData( + childEllipse, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.TOP, + 0, + 0.25f, + _kRenderingExtensions.H_RIGHT, + _kRenderingExtensions.V_TOP, + 0, + 0, + CLOUD_WIDTH / 3f, + CLOUD_WIDTH / 3f); + + childEllipse = _kContainerRenderingExtensions.addEllipse(figure); + _kRenderingExtensions.setBackground(childEllipse, Colors.GRAY); + _kRenderingExtensions.setForeground(childEllipse, Colors.GRAY); + _kRenderingExtensions.setPointPlacementData( + childEllipse, + _kRenderingExtensions.LEFT, + 0, + 0.4f, + _kRenderingExtensions.TOP, + CLOUD_WIDTH / 10, + 0, + _kRenderingExtensions.H_LEFT, + _kRenderingExtensions.V_TOP, + 0, + 0, + CLOUD_WIDTH / 2, + CLOUD_WIDTH / 2); + + return figure; + } + + public KRendering addCloudUploadIcon(KContainerRendering parent) { + KContainerRendering cloudIcon = addCloudIcon(parent); + KPolygon cloudPolygon = _kContainerRenderingExtensions.addPolygon(cloudIcon); + _kRenderingExtensions.setBackground(cloudPolygon, Colors.WHITE); + _kRenderingExtensions.setForeground(cloudPolygon, Colors.WHITE); + cloudPolygon + .getPoints() + .addAll( List.of( - _kRenderingExtensions.createKPosition(LEFT, -1.5f, 0.5f, TOP, CLOUD_WIDTH / 3, 0.5f), + _kRenderingExtensions.createKPosition( + LEFT, -1.5f, 0.5f, TOP, CLOUD_WIDTH / 3, 0.5f), _kRenderingExtensions.createKPosition(LEFT, -1.5f, 0.5f, TOP, 0, 0.58f), _kRenderingExtensions.createKPosition(LEFT, (-4), 0.5f, TOP, 0, 0.58f), _kRenderingExtensions.createKPosition(LEFT, 0, 0.5f, TOP, 0, 0.35f), _kRenderingExtensions.createKPosition(LEFT, 4, 0.5f, TOP, 0, 0.58f), _kRenderingExtensions.createKPosition(LEFT, 1.5f, 0.5f, TOP, 0, 0.58f), - _kRenderingExtensions.createKPosition(LEFT, 1.5f, 0.5f, TOP, CLOUD_WIDTH / 3, 0.5f) - ) - ); - return cloudIcon; - } - - private static LabelDecorationConfigurator _onEdgeLabelConfigurator; // ONLY for use in applyOnEdgeStyle - public void applyOnEdgeStyle(KLabel label) { - if (_onEdgeLabelConfigurator == null) { - LabelDecorationConfigurator configurator = LabelDecorationConfigurator.create().withInlineLabels(true); - _onEdgeLabelConfigurator = configurator.withLabelTextRenderingProvider( - (KContainerRendering container, KLabel klabel) -> { + _kRenderingExtensions.createKPosition( + LEFT, 1.5f, 0.5f, TOP, CLOUD_WIDTH / 3, 0.5f))); + return cloudIcon; + } + + private static LabelDecorationConfigurator + _onEdgeLabelConfigurator; // ONLY for use in applyOnEdgeStyle + + public void applyOnEdgeStyle(KLabel label) { + if (_onEdgeLabelConfigurator == null) { + LabelDecorationConfigurator configurator = + LabelDecorationConfigurator.create().withInlineLabels(true); + _onEdgeLabelConfigurator = + configurator.withLabelTextRenderingProvider( + (KContainerRendering container, KLabel klabel) -> { KText kText = _kRenderingFactory.createKText(); _kRenderingExtensions.setFontSize(kText, 9); container.getChildren().add(kText); return kText; - }); - } - _onEdgeLabelConfigurator.applyTo(label); + }); } - - private static LabelDecorationConfigurator _onEdgeDelayLabelConfigurator; // ONLY for use in applyOnEdgeDelayStyle - public void applyOnEdgeDelayStyle(KLabel label) { - if (_onEdgeDelayLabelConfigurator == null) { - LabelDecorationConfigurator configurator = LabelDecorationConfigurator.create().withInlineLabels(true); - configurator = configurator.withLabelTextRenderingProvider( - (KContainerRendering container, KLabel klabel) -> { - KText kText = _kRenderingFactory.createKText(); - _kRenderingExtensions.setFontSize(kText, 8); - boldTextSelectionStyle(kText); - kText.setProperty(KlighdInternalProperties.MODEL_ELEMEMT, - klabel.getProperty(KlighdInternalProperties.MODEL_ELEMEMT)); - container.getChildren().add(kText); - return kText; - } - ); - configurator = configurator.addDecoratorRenderingProvider(new IDecoratorRenderingProvider() { + _onEdgeLabelConfigurator.applyTo(label); + } + + private static LabelDecorationConfigurator + _onEdgeDelayLabelConfigurator; // ONLY for use in applyOnEdgeDelayStyle + + public void applyOnEdgeDelayStyle(KLabel label) { + if (_onEdgeDelayLabelConfigurator == null) { + LabelDecorationConfigurator configurator = + LabelDecorationConfigurator.create().withInlineLabels(true); + configurator = + configurator.withLabelTextRenderingProvider( + (KContainerRendering container, KLabel klabel) -> { + KText kText = _kRenderingFactory.createKText(); + _kRenderingExtensions.setFontSize(kText, 8); + boldTextSelectionStyle(kText); + kText.setProperty( + KlighdInternalProperties.MODEL_ELEMEMT, + klabel.getProperty(KlighdInternalProperties.MODEL_ELEMEMT)); + container.getChildren().add(kText); + return kText; + }); + configurator = + configurator.addDecoratorRenderingProvider( + new IDecoratorRenderingProvider() { @Override public ElkPadding createDecoratorRendering( - KContainerRendering container, KLabel label, - LabelDecorationConfigurator.LayoutMode layoutMode) { - ElkPadding padding = new ElkPadding(); - padding.top = 1; - padding.bottom = 1; - padding.left = 2; - padding.right = 2; - - KPolygon polygon = _kRenderingFactory.createKPolygon(); - _kRenderingExtensions.from(polygon, LEFT, (-2), 0, BOTTOM, 0, 0); - _kRenderingExtensions.to(polygon, LEFT, 2, 0, TOP, 0, 0); - _kRenderingExtensions.to(polygon, RIGHT, (-2), 0, TOP, 0, 0); - _kRenderingExtensions.to(polygon, RIGHT, 2, 0, BOTTOM, 0, 0); - _kRenderingExtensions.setBackground(polygon, Colors.WHITE); - _kRenderingExtensions.setForeground(polygon, Colors.WHITE); - container.getChildren().add(polygon); - - KPolyline polyline = _kRenderingFactory.createKPolyline(); - _kRenderingExtensions.from(polyline, LEFT, (-2), 0, BOTTOM, 0, 0); - _kRenderingExtensions.to(polyline, LEFT, 2, 0, TOP, 0, 0); - container.getChildren().add(polyline); - - polyline = _kRenderingFactory.createKPolyline(); - _kRenderingExtensions.from(polyline, RIGHT, 2, 0, BOTTOM, 0, 0); - _kRenderingExtensions.to(polyline, RIGHT, (-2), 0, TOP, 0, 0); - container.getChildren().add(polyline); - - return padding; + KContainerRendering container, + KLabel label, + LabelDecorationConfigurator.LayoutMode layoutMode) { + ElkPadding padding = new ElkPadding(); + padding.top = 1; + padding.bottom = 1; + padding.left = 2; + padding.right = 2; + + KPolygon polygon = _kRenderingFactory.createKPolygon(); + _kRenderingExtensions.from(polygon, LEFT, (-2), 0, BOTTOM, 0, 0); + _kRenderingExtensions.to(polygon, LEFT, 2, 0, TOP, 0, 0); + _kRenderingExtensions.to(polygon, RIGHT, (-2), 0, TOP, 0, 0); + _kRenderingExtensions.to(polygon, RIGHT, 2, 0, BOTTOM, 0, 0); + _kRenderingExtensions.setBackground(polygon, Colors.WHITE); + _kRenderingExtensions.setForeground(polygon, Colors.WHITE); + container.getChildren().add(polygon); + + KPolyline polyline = _kRenderingFactory.createKPolyline(); + _kRenderingExtensions.from(polyline, LEFT, (-2), 0, BOTTOM, 0, 0); + _kRenderingExtensions.to(polyline, LEFT, 2, 0, TOP, 0, 0); + container.getChildren().add(polyline); + + polyline = _kRenderingFactory.createKPolyline(); + _kRenderingExtensions.from(polyline, RIGHT, 2, 0, BOTTOM, 0, 0); + _kRenderingExtensions.to(polyline, RIGHT, (-2), 0, TOP, 0, 0); + container.getChildren().add(polyline); + + return padding; } - }); - _onEdgeDelayLabelConfigurator = configurator; - } - _onEdgeDelayLabelConfigurator.applyTo(label); + }); + _onEdgeDelayLabelConfigurator = configurator; } + _onEdgeDelayLabelConfigurator.applyTo(label); + } - private static LabelDecorationConfigurator _onEdgePysicalDelayLabelConfigurator; // ONLY for use in applyOnEdgePysicalDelayStyle - public void applyOnEdgePysicalDelayStyle(KLabel label, Colors parentBackgroundColor) { - if (_onEdgePysicalDelayLabelConfigurator == null) { - LabelDecorationConfigurator configurator = LabelDecorationConfigurator.create().withInlineLabels(true); - configurator = configurator.withLabelTextRenderingProvider( - (KContainerRendering container, KLabel klabel) -> { - KText kText = _kRenderingFactory.createKText(); - _kRenderingExtensions.setFontSize(kText, 8); - boldTextSelectionStyle(kText); - kText.setProperty(KlighdInternalProperties.MODEL_ELEMEMT, - klabel.getProperty(KlighdInternalProperties.MODEL_ELEMEMT)); - container.getChildren().add(kText); - return kText; - } - ); - configurator = configurator.addDecoratorRenderingProvider(new IDecoratorRenderingProvider() { + private static LabelDecorationConfigurator + _onEdgePysicalDelayLabelConfigurator; // ONLY for use in applyOnEdgePysicalDelayStyle + + public void applyOnEdgePysicalDelayStyle(KLabel label, Colors parentBackgroundColor) { + if (_onEdgePysicalDelayLabelConfigurator == null) { + LabelDecorationConfigurator configurator = + LabelDecorationConfigurator.create().withInlineLabels(true); + configurator = + configurator.withLabelTextRenderingProvider( + (KContainerRendering container, KLabel klabel) -> { + KText kText = _kRenderingFactory.createKText(); + _kRenderingExtensions.setFontSize(kText, 8); + boldTextSelectionStyle(kText); + kText.setProperty( + KlighdInternalProperties.MODEL_ELEMEMT, + klabel.getProperty(KlighdInternalProperties.MODEL_ELEMEMT)); + container.getChildren().add(kText); + return kText; + }); + configurator = + configurator.addDecoratorRenderingProvider( + new IDecoratorRenderingProvider() { @Override public ElkPadding createDecoratorRendering( - KContainerRendering container, - KLabel label, - LabelDecorationConfigurator.LayoutMode layoutMode) { - ElkPadding padding = new ElkPadding(); - padding.top = 1; - padding.bottom = 1; - padding.left = 8; - padding.right = 16; - - KPolygon polygon = _kRenderingFactory.createKPolygon(); - _kRenderingExtensions.from(polygon, LEFT, 0, 0, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(polygon, LEFT, 0, 0, TOP, 1, 0.5f); - _kRenderingExtensions.to(polygon, RIGHT, 0, 0, TOP, 1, 0.5f); - _kRenderingExtensions.to(polygon, RIGHT, 0, 0, BOTTOM, 0, 0.5f); - _kRenderingExtensions.setBackground(polygon, label.getProperty(LABEL_PARENT_BACKGROUND)); - _kRenderingExtensions.setForeground(polygon, label.getProperty(LABEL_PARENT_BACKGROUND)); - container.getChildren().add(polygon); - - KSpline kSpline = _kRenderingFactory.createKSpline(); - _kRenderingExtensions.from(kSpline, LEFT, -0.66f, 0, BOTTOM, -0.5f, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 1, 0, BOTTOM, -0.5f, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 3, 0, BOTTOM, 8, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 5, 0, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 5.5f, 0, BOTTOM, -1.5f, 0.5f); - container.getChildren().add(kSpline); - - kSpline = _kRenderingFactory.createKSpline(); - _kRenderingExtensions.from(kSpline, RIGHT, 15f, 0, BOTTOM, 3.5f, 0.5f); - _kRenderingExtensions.to(kSpline, RIGHT, 14f, 0, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(kSpline, RIGHT, 11, 0, BOTTOM, -8, 0.5f); - _kRenderingExtensions.to(kSpline, RIGHT, 9, 0, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(kSpline, RIGHT, 7, 0, BOTTOM, 8, 0.5f); - _kRenderingExtensions.to(kSpline, RIGHT, 4f, 0, BOTTOM, 2, 0.5f); - _kRenderingExtensions.to(kSpline, RIGHT, 1.5f, 0, BOTTOM, 0.5f, 0.5f); - _kRenderingExtensions.to(kSpline, RIGHT, 0.2f, 0, BOTTOM, -0.5f, 0.5f); - _kRenderingExtensions.to(kSpline, RIGHT, -0.7f, 0, BOTTOM, -0.5f, 0.5f); - container.getChildren().add(kSpline); - - polygon = _kRenderingFactory.createKPolygon(); - _kRenderingExtensions.from(polygon, LEFT, 4, 0, BOTTOM, 0, 0); - _kRenderingExtensions.to(polygon, LEFT, 8, 0, TOP, 0, 0); - _kRenderingExtensions.to(polygon, RIGHT, 12, 0, TOP, 0, 0); - _kRenderingExtensions.to(polygon, RIGHT, 16, 0, BOTTOM, 0, 0); - _kRenderingExtensions.setBackground(polygon, Colors.WHITE); - _kRenderingExtensions.setForeground(polygon, Colors.WHITE); - container.getChildren().add(polygon); - - KPolyline polyline = _kRenderingFactory.createKPolyline(); - _kRenderingExtensions.from(polyline, LEFT, 4, 0, BOTTOM, 0, 0); - _kRenderingExtensions.to(polyline, LEFT, 8, 0, TOP, 0, 0); - container.getChildren().add(polyline); - - polyline = _kRenderingFactory.createKPolyline(); - _kRenderingExtensions.from(polyline, RIGHT, 16, 0, BOTTOM, 0, 0); - _kRenderingExtensions.to(polyline, RIGHT, 12, 0, TOP, 0, 0); - container.getChildren().add(polyline); - - return padding; + KContainerRendering container, + KLabel label, + LabelDecorationConfigurator.LayoutMode layoutMode) { + ElkPadding padding = new ElkPadding(); + padding.top = 1; + padding.bottom = 1; + padding.left = 8; + padding.right = 16; + + KPolygon polygon = _kRenderingFactory.createKPolygon(); + _kRenderingExtensions.from(polygon, LEFT, 0, 0, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(polygon, LEFT, 0, 0, TOP, 1, 0.5f); + _kRenderingExtensions.to(polygon, RIGHT, 0, 0, TOP, 1, 0.5f); + _kRenderingExtensions.to(polygon, RIGHT, 0, 0, BOTTOM, 0, 0.5f); + _kRenderingExtensions.setBackground( + polygon, label.getProperty(LABEL_PARENT_BACKGROUND)); + _kRenderingExtensions.setForeground( + polygon, label.getProperty(LABEL_PARENT_BACKGROUND)); + container.getChildren().add(polygon); + + KSpline kSpline = _kRenderingFactory.createKSpline(); + _kRenderingExtensions.from(kSpline, LEFT, -0.66f, 0, BOTTOM, -0.5f, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 1, 0, BOTTOM, -0.5f, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 3, 0, BOTTOM, 8, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 5, 0, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 5.5f, 0, BOTTOM, -1.5f, 0.5f); + container.getChildren().add(kSpline); + + kSpline = _kRenderingFactory.createKSpline(); + _kRenderingExtensions.from(kSpline, RIGHT, 15f, 0, BOTTOM, 3.5f, 0.5f); + _kRenderingExtensions.to(kSpline, RIGHT, 14f, 0, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(kSpline, RIGHT, 11, 0, BOTTOM, -8, 0.5f); + _kRenderingExtensions.to(kSpline, RIGHT, 9, 0, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(kSpline, RIGHT, 7, 0, BOTTOM, 8, 0.5f); + _kRenderingExtensions.to(kSpline, RIGHT, 4f, 0, BOTTOM, 2, 0.5f); + _kRenderingExtensions.to(kSpline, RIGHT, 1.5f, 0, BOTTOM, 0.5f, 0.5f); + _kRenderingExtensions.to(kSpline, RIGHT, 0.2f, 0, BOTTOM, -0.5f, 0.5f); + _kRenderingExtensions.to(kSpline, RIGHT, -0.7f, 0, BOTTOM, -0.5f, 0.5f); + container.getChildren().add(kSpline); + + polygon = _kRenderingFactory.createKPolygon(); + _kRenderingExtensions.from(polygon, LEFT, 4, 0, BOTTOM, 0, 0); + _kRenderingExtensions.to(polygon, LEFT, 8, 0, TOP, 0, 0); + _kRenderingExtensions.to(polygon, RIGHT, 12, 0, TOP, 0, 0); + _kRenderingExtensions.to(polygon, RIGHT, 16, 0, BOTTOM, 0, 0); + _kRenderingExtensions.setBackground(polygon, Colors.WHITE); + _kRenderingExtensions.setForeground(polygon, Colors.WHITE); + container.getChildren().add(polygon); + + KPolyline polyline = _kRenderingFactory.createKPolyline(); + _kRenderingExtensions.from(polyline, LEFT, 4, 0, BOTTOM, 0, 0); + _kRenderingExtensions.to(polyline, LEFT, 8, 0, TOP, 0, 0); + container.getChildren().add(polyline); + + polyline = _kRenderingFactory.createKPolyline(); + _kRenderingExtensions.from(polyline, RIGHT, 16, 0, BOTTOM, 0, 0); + _kRenderingExtensions.to(polyline, RIGHT, 12, 0, TOP, 0, 0); + container.getChildren().add(polyline); + + return padding; } - }); - _onEdgePysicalDelayLabelConfigurator = configurator; - } - label.setProperty(LABEL_PARENT_BACKGROUND, parentBackgroundColor); - _onEdgePysicalDelayLabelConfigurator.applyTo(label); + }); + _onEdgePysicalDelayLabelConfigurator = configurator; } - - private static LabelDecorationConfigurator _onEdgePysicalLabelConfigurator; // ONLY for use in applyOnEdgePysicalStyle - public void applyOnEdgePysicalStyle(KLabel label, Colors parentBackgroundColor) { - if (_onEdgePysicalLabelConfigurator == null) { - LabelDecorationConfigurator configurator = LabelDecorationConfigurator.create().withInlineLabels(true); - configurator = configurator.withLabelTextRenderingProvider( - (KContainerRendering container, KLabel klabel) -> { - KText kText = _kRenderingFactory.createKText(); - _kRenderingExtensions.setInvisible(kText, true); - container.getChildren().add(kText); - return kText; - } - ); - configurator = configurator.addDecoratorRenderingProvider(new IDecoratorRenderingProvider() { + label.setProperty(LABEL_PARENT_BACKGROUND, parentBackgroundColor); + _onEdgePysicalDelayLabelConfigurator.applyTo(label); + } + + private static LabelDecorationConfigurator + _onEdgePysicalLabelConfigurator; // ONLY for use in applyOnEdgePysicalStyle + + public void applyOnEdgePysicalStyle(KLabel label, Colors parentBackgroundColor) { + if (_onEdgePysicalLabelConfigurator == null) { + LabelDecorationConfigurator configurator = + LabelDecorationConfigurator.create().withInlineLabels(true); + configurator = + configurator.withLabelTextRenderingProvider( + (KContainerRendering container, KLabel klabel) -> { + KText kText = _kRenderingFactory.createKText(); + _kRenderingExtensions.setInvisible(kText, true); + container.getChildren().add(kText); + return kText; + }); + configurator = + configurator.addDecoratorRenderingProvider( + new IDecoratorRenderingProvider() { @Override - public ElkPadding createDecoratorRendering(final KContainerRendering container, final KLabel label, final LabelDecorationConfigurator.LayoutMode layoutMode) { - ElkPadding padding = new ElkPadding(); - padding.top = 1; - padding.bottom = 1; - padding.left = 3; - padding.right = 3; - - KPolygon polygon = _kRenderingFactory.createKPolygon(); - _kRenderingExtensions.from(polygon, LEFT, 0, 0, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(polygon, LEFT, 0, 0, TOP, 1, 0.5f); - _kRenderingExtensions.to(polygon, RIGHT, 0, 0, TOP, 1, 0.5f); - _kRenderingExtensions.to(polygon, RIGHT, 0, 0, BOTTOM, 0, 0.5f); - _kRenderingExtensions.setBackground(polygon, label.getProperty(LABEL_PARENT_BACKGROUND)); - _kRenderingExtensions.setForeground(polygon, label.getProperty(LABEL_PARENT_BACKGROUND)); - container.getChildren().add(polygon); - - KSpline kSpline = _kRenderingFactory.createKSpline(); - _kRenderingExtensions.from(kSpline, LEFT, (-0.66f), 0, BOTTOM, (-0.5f), 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 1, 0, BOTTOM, (-0.5f), 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.1f, BOTTOM, 8, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.2f, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.3f, BOTTOM, (-8), 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.4f, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.45f, BOTTOM, 4f, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.5f, BOTTOM, 8, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.55f, BOTTOM, 4f, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.6f, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.65f, BOTTOM, (-4), 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.7f, BOTTOM, (-8), 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.8f, BOTTOM, (-4), 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0, 0.9f, BOTTOM, 0, 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, (-1), 1, BOTTOM, (-0.5f), 0.5f); - _kRenderingExtensions.to(kSpline, LEFT, 0.66f, 1, BOTTOM, (-0.5f), 0.5f); - container.getChildren().add(kSpline); - return padding; + public ElkPadding createDecoratorRendering( + final KContainerRendering container, + final KLabel label, + final LabelDecorationConfigurator.LayoutMode layoutMode) { + ElkPadding padding = new ElkPadding(); + padding.top = 1; + padding.bottom = 1; + padding.left = 3; + padding.right = 3; + + KPolygon polygon = _kRenderingFactory.createKPolygon(); + _kRenderingExtensions.from(polygon, LEFT, 0, 0, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(polygon, LEFT, 0, 0, TOP, 1, 0.5f); + _kRenderingExtensions.to(polygon, RIGHT, 0, 0, TOP, 1, 0.5f); + _kRenderingExtensions.to(polygon, RIGHT, 0, 0, BOTTOM, 0, 0.5f); + _kRenderingExtensions.setBackground( + polygon, label.getProperty(LABEL_PARENT_BACKGROUND)); + _kRenderingExtensions.setForeground( + polygon, label.getProperty(LABEL_PARENT_BACKGROUND)); + container.getChildren().add(polygon); + + KSpline kSpline = _kRenderingFactory.createKSpline(); + _kRenderingExtensions.from(kSpline, LEFT, (-0.66f), 0, BOTTOM, (-0.5f), 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 1, 0, BOTTOM, (-0.5f), 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.1f, BOTTOM, 8, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.2f, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.3f, BOTTOM, (-8), 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.4f, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.45f, BOTTOM, 4f, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.5f, BOTTOM, 8, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.55f, BOTTOM, 4f, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.6f, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.65f, BOTTOM, (-4), 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.7f, BOTTOM, (-8), 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.8f, BOTTOM, (-4), 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0, 0.9f, BOTTOM, 0, 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, (-1), 1, BOTTOM, (-0.5f), 0.5f); + _kRenderingExtensions.to(kSpline, LEFT, 0.66f, 1, BOTTOM, (-0.5f), 0.5f); + container.getChildren().add(kSpline); + return padding; } - }); - _onEdgePysicalLabelConfigurator = configurator; - } - label.setProperty(LABEL_PARENT_BACKGROUND, parentBackgroundColor); - _onEdgePysicalLabelConfigurator.applyTo(label); + }); + _onEdgePysicalLabelConfigurator = configurator; } + label.setProperty(LABEL_PARENT_BACKGROUND, parentBackgroundColor); + _onEdgePysicalLabelConfigurator.applyTo(label); + } - public KRendering addFixedTailArrowDecorator(KPolyline pl) { - KRendering head = _kPolylineExtensions.addTailArrowDecorator(pl); - KDecoratorPlacementData placement = _kRenderingFactory.createKDecoratorPlacementData(); - placement.setRotateWithLine(true); - placement.setRelative(0f); - placement.setAbsolute(2f); - placement.setWidth(8); - placement.setHeight(6); - placement.setXOffset(-3f); - placement.setYOffset(-4f); - head.setPlacementData(placement); - return head; - } - - public void addArrayDecorator(KEdge edge, Integer size) { - final KRendering line = _kRenderingExtensions.getKRendering(edge); - if (line instanceof KPolyline) { - KDecoratorPlacementData placement = _kRenderingFactory.createKDecoratorPlacementData(); - placement.setRotateWithLine(true); - placement.setRelative(0f); - placement.setAbsolute(6f); - - KPolyline slash = _kContainerRenderingExtensions.addChild( - (KContainerRendering) line, - _kRenderingFactory.createKPolyline()); - slash.getPoints().add( - _kRenderingExtensions.createKPosition( - _kRenderingExtensions.RIGHT, 0, 0, - _kRenderingExtensions.TOP, 0, 0) - ); - slash.getPoints().add( - _kRenderingExtensions.createKPosition( - _kRenderingExtensions.LEFT, 0, 0, - _kRenderingExtensions.BOTTOM, 0, 0) - ); - KDecoratorPlacementData slashPlacement = EcoreUtil.copy(placement); - slashPlacement.setWidth(5); - slashPlacement.setHeight(10); - slashPlacement.setYOffset(-5f); - slash.setPlacementData(slashPlacement); - - if (size != null) { - KText num = _kContainerRenderingExtensions.addChild( - (KContainerRendering) line, - _kRenderingFactory.createKText() - ); - num.setText(size.toString()); - _kRenderingExtensions.setFontSize(num, 5); - noSelectionStyle(num); - KDecoratorPlacementData numPlacement = EcoreUtil.copy(placement); - numPlacement.setXOffset(2f); - num.setPlacementData(numPlacement); - } - } + public KRendering addFixedTailArrowDecorator(KPolyline pl) { + KRendering head = _kPolylineExtensions.addTailArrowDecorator(pl); + KDecoratorPlacementData placement = _kRenderingFactory.createKDecoratorPlacementData(); + placement.setRotateWithLine(true); + placement.setRelative(0f); + placement.setAbsolute(2f); + placement.setWidth(8); + placement.setHeight(6); + placement.setXOffset(-3f); + placement.setYOffset(-4f); + head.setPlacementData(placement); + return head; + } + + public void addArrayDecorator(KEdge edge, Integer size) { + final KRendering line = _kRenderingExtensions.getKRendering(edge); + if (line instanceof KPolyline) { + KDecoratorPlacementData placement = _kRenderingFactory.createKDecoratorPlacementData(); + placement.setRotateWithLine(true); + placement.setRelative(0f); + placement.setAbsolute(6f); + + KPolyline slash = + _kContainerRenderingExtensions.addChild( + (KContainerRendering) line, _kRenderingFactory.createKPolyline()); + slash + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + _kRenderingExtensions.RIGHT, 0, 0, _kRenderingExtensions.TOP, 0, 0)); + slash + .getPoints() + .add( + _kRenderingExtensions.createKPosition( + _kRenderingExtensions.LEFT, 0, 0, _kRenderingExtensions.BOTTOM, 0, 0)); + KDecoratorPlacementData slashPlacement = EcoreUtil.copy(placement); + slashPlacement.setWidth(5); + slashPlacement.setHeight(10); + slashPlacement.setYOffset(-5f); + slash.setPlacementData(slashPlacement); + + if (size != null) { + KText num = + _kContainerRenderingExtensions.addChild( + (KContainerRendering) line, _kRenderingFactory.createKText()); + num.setText(size.toString()); + _kRenderingExtensions.setFontSize(num, 5); + noSelectionStyle(num); + KDecoratorPlacementData numPlacement = EcoreUtil.copy(placement); + numPlacement.setXOffset(2f); + num.setPlacementData(numPlacement); + } } -} \ No newline at end of file + } +} diff --git a/org.lflang/src/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java b/org.lflang/src/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java index a7ca735f29..aab539926b 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java @@ -1,26 +1,24 @@ /** * Copyright (c) 2020, Kiel University. - * - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * + *

    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. + * + *

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR + * CONTRIBUTORS 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. */ package org.lflang.diagram.synthesis.styles; @@ -31,81 +29,77 @@ import org.eclipse.xtext.xbase.lib.util.ToStringBuilder; public class ReactorFigureComponents { - private final KContainerRendering outer; + private final KContainerRendering outer; - private final KContainerRendering reactor; + private final KContainerRendering reactor; - private final List figures; + private final List figures; - public ReactorFigureComponents(KContainerRendering outer, - KContainerRendering reactor, - List figures) { - super(); - this.outer = outer; - this.reactor = reactor; - this.figures = figures; - } + public ReactorFigureComponents( + KContainerRendering outer, KContainerRendering reactor, List figures) { + super(); + this.outer = outer; + this.reactor = reactor; + this.figures = figures; + } - @Override - @Pure - public int hashCode() { - final int prime = 31; - int result = 1; - result = prime * result + ((this.outer== null) ? 0 : this.outer.hashCode()); - result = prime * result + ((this.reactor== null) ? 0 : this.reactor.hashCode()); - return prime * result + ((this.figures== null) ? 0 : this.figures.hashCode()); - } + @Override + @Pure + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((this.outer == null) ? 0 : this.outer.hashCode()); + result = prime * result + ((this.reactor == null) ? 0 : this.reactor.hashCode()); + return prime * result + ((this.figures == null) ? 0 : this.figures.hashCode()); + } - @Override - @Pure - public boolean equals(final Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (getClass() != obj.getClass()) - return false; - ReactorFigureComponents other = (ReactorFigureComponents) obj; - if (this.outer == null && other.outer != null) { - return false; - } else if (!this.outer.equals(other.outer)) { - return false; - } - if (this.reactor == null && other.reactor != null) { - return false; - } else if (!this.reactor.equals(other.reactor)) { - return false; - } - if (this.figures == null && other.figures != null) { - return false; - } else if (!this.figures.equals(other.figures)) { - return false; - } - return true; + @Override + @Pure + public boolean equals(final Object obj) { + if (this == obj) return true; + if (obj == null) return false; + if (getClass() != obj.getClass()) return false; + ReactorFigureComponents other = (ReactorFigureComponents) obj; + if (this.outer == null && other.outer != null) { + return false; + } else if (!this.outer.equals(other.outer)) { + return false; } - - @Override - @Pure - public String toString() { - ToStringBuilder b = new ToStringBuilder(this); - b.add("outer", this.outer); - b.add("reactor", this.reactor); - b.add("figures", this.figures); - return b.toString(); + if (this.reactor == null && other.reactor != null) { + return false; + } else if (!this.reactor.equals(other.reactor)) { + return false; } - - @Pure - public KContainerRendering getOuter() { - return this.outer; + if (this.figures == null && other.figures != null) { + return false; + } else if (!this.figures.equals(other.figures)) { + return false; } + return true; + } - @Pure - public KContainerRendering getReactor() { - return this.reactor; - } + @Override + @Pure + public String toString() { + ToStringBuilder b = new ToStringBuilder(this); + b.add("outer", this.outer); + b.add("reactor", this.reactor); + b.add("figures", this.figures); + return b.toString(); + } - @Pure - public List getFigures() { - return this.figures; - } + @Pure + public KContainerRendering getOuter() { + return this.outer; + } + + @Pure + public KContainerRendering getReactor() { + return this.reactor; + } + + @Pure + public List getFigures() { + return this.figures; + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/CycleVisualization.java b/org.lflang/src/org/lflang/diagram/synthesis/util/CycleVisualization.java index 0fc52b0665..4fb313fe4b 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/util/CycleVisualization.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/util/CycleVisualization.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.util; import com.google.common.collect.HashMultimap; @@ -43,115 +43,114 @@ /** * Dependency cycle detection for Lingua Franca diagrams. - * + * * @author Alexander Schulz-Rosengarten */ @ViewSynthesisShared public class CycleVisualization extends AbstractSynthesisExtensions { - - // Properties for marking diagram elements - public static final Property DEPENDENCY_CYCLE = new Property<>("org.lflang.diagram.synthesis.dependency.cycle", false); - @Inject @Extension private UtilityExtensions _utilityExtensions; - - /** - * Performs cycle detection based on the diagram's graph structure and applies given highlighting to the included elements - */ - public boolean detectAndHighlightCycles(ReactorInstance rootReactorInstance, - Map allReactorNodes, - Consumer highlighter) { - - if (rootReactorInstance.hasCycles() && highlighter != null) { - // Highlight cycles - // A cycle consists of reactions and ports. - HashMultimap> cycleElementsByReactor = HashMultimap.create(); - Set> cycles = rootReactorInstance.getCycles(); - for (NamedInstance element : cycles) { - // First find the involved reactor instances - if (element instanceof ReactorInstance) { - cycleElementsByReactor.put((ReactorInstance) element, element); - } else { - cycleElementsByReactor.put(element.getParent(), element); - } - } - - for (ReactorInstance reactor : cycleElementsByReactor.keySet()) { - KNode node = allReactorNodes.get(reactor); - if (node != null) { - node.setProperty(DEPENDENCY_CYCLE, true); - highlighter.accept(node); + // Properties for marking diagram elements + public static final Property DEPENDENCY_CYCLE = + new Property<>("org.lflang.diagram.synthesis.dependency.cycle", false); + + @Inject @Extension private UtilityExtensions _utilityExtensions; - Set> reactorContentInCycle = cycleElementsByReactor.get(reactor); - - // Reactor edges - for (KEdge edge : node.getOutgoingEdges()) { - if (connectsCycleElements(edge, cycles)) { - edge.setProperty(DEPENDENCY_CYCLE, true); - highlighter.accept(edge); - } - } + /** + * Performs cycle detection based on the diagram's graph structure and applies given highlighting + * to the included elements + */ + public boolean detectAndHighlightCycles( + ReactorInstance rootReactorInstance, + Map allReactorNodes, + Consumer highlighter) { - // Reactor ports - for (KPort port : node.getPorts()) { - if (reactorContentInCycle.contains(NamedInstanceUtil.getLinkedInstance(port))) { - port.setProperty(DEPENDENCY_CYCLE, true); - highlighter.accept(port); - } - } + if (rootReactorInstance.hasCycles() && highlighter != null) { + // Highlight cycles + // A cycle consists of reactions and ports. + HashMultimap> cycleElementsByReactor = + HashMultimap.create(); + Set> cycles = rootReactorInstance.getCycles(); + for (NamedInstance element : cycles) { + // First find the involved reactor instances + if (element instanceof ReactorInstance) { + cycleElementsByReactor.put((ReactorInstance) element, element); + } else { + cycleElementsByReactor.put(element.getParent(), element); + } + } - // Child Nodes - for (KNode childNode : node.getChildren()) { - if (reactorContentInCycle.contains(NamedInstanceUtil.getLinkedInstance(childNode)) && - !_utilityExtensions.sourceIsReactor(childNode)) { - childNode.setProperty(DEPENDENCY_CYCLE, true); - highlighter.accept(childNode); + for (ReactorInstance reactor : cycleElementsByReactor.keySet()) { + KNode node = allReactorNodes.get(reactor); + if (node != null) { + node.setProperty(DEPENDENCY_CYCLE, true); + highlighter.accept(node); + + Set> reactorContentInCycle = cycleElementsByReactor.get(reactor); + + // Reactor edges + for (KEdge edge : node.getOutgoingEdges()) { + if (connectsCycleElements(edge, cycles)) { + edge.setProperty(DEPENDENCY_CYCLE, true); + highlighter.accept(edge); + } + } - for (KEdge edge : childNode.getOutgoingEdges()) { - if (connectsCycleElements(edge, cycles)) { - edge.setProperty(DEPENDENCY_CYCLE, true); - highlighter.accept(edge); - } - } - } - } + // Reactor ports + for (KPort port : node.getPorts()) { + if (reactorContentInCycle.contains(NamedInstanceUtil.getLinkedInstance(port))) { + port.setProperty(DEPENDENCY_CYCLE, true); + highlighter.accept(port); + } + } + + // Child Nodes + for (KNode childNode : node.getChildren()) { + if (reactorContentInCycle.contains(NamedInstanceUtil.getLinkedInstance(childNode)) + && !_utilityExtensions.sourceIsReactor(childNode)) { + childNode.setProperty(DEPENDENCY_CYCLE, true); + highlighter.accept(childNode); + + for (KEdge edge : childNode.getOutgoingEdges()) { + if (connectsCycleElements(edge, cycles)) { + edge.setProperty(DEPENDENCY_CYCLE, true); + highlighter.accept(edge); } + } } - return true; - } - return false; - } - - /** - * Checks whether an edge connects two elements that are part of the cycle. - * Assumes that the source node is always part of the cycle! - */ - private boolean connectsCycleElements(KEdge edge, Set> cycle) { - return ( - // if source is not a reactor, there is nothing to check - !_utilityExtensions.sourceIsReactor(edge.getSource()) - || - // otherwise, the source port must be on the cycle - cycle.contains(NamedInstanceUtil.getLinkedInstance(edge.getSourcePort())) - ) && ( - // leads to reactor port in cycle - _utilityExtensions.sourceIsReactor(edge.getTarget()) - && - cycle.contains(NamedInstanceUtil.getLinkedInstance(edge.getTargetPort())) - || - // leads to reaction in cycle - !_utilityExtensions.sourceIsReactor(edge.getTarget()) - && - cycle.contains(NamedInstanceUtil.getLinkedInstance(edge.getTarget())) - ) && ( - // Special case only for connections - !(_utilityExtensions.sourceElement(edge) instanceof Connection) - || ( - // If the edge represents a connections between two ports in the cycle (checked before), - // then it is only included in the actual cycle, if it is neither delayed nor physical. - ((Connection) _utilityExtensions.sourceElement(edge)).getDelay() == null - && - !((Connection) _utilityExtensions.sourceElement(edge)).isPhysical() - ) - ); + } + } + } + return true; } + return false; + } + + /** + * Checks whether an edge connects two elements that are part of the cycle. Assumes that the + * source node is always part of the cycle! + */ + private boolean connectsCycleElements(KEdge edge, Set> cycle) { + return ( + // if source is not a reactor, there is nothing to check + !_utilityExtensions.sourceIsReactor(edge.getSource()) + || + // otherwise, the source port must be on the cycle + cycle.contains(NamedInstanceUtil.getLinkedInstance(edge.getSourcePort()))) + && ( + // leads to reactor port in cycle + _utilityExtensions.sourceIsReactor(edge.getTarget()) + && cycle.contains(NamedInstanceUtil.getLinkedInstance(edge.getTargetPort())) + || + // leads to reaction in cycle + !_utilityExtensions.sourceIsReactor(edge.getTarget()) + && cycle.contains(NamedInstanceUtil.getLinkedInstance(edge.getTarget()))) + && ( + // Special case only for connections + !(_utilityExtensions.sourceElement(edge) instanceof Connection) + || ( + // If the edge represents a connections between two ports in the cycle (checked before), + // then it is only included in the actual cycle, if it is neither delayed nor physical. + ((Connection) _utilityExtensions.sourceElement(edge)).getDelay() == null + && !((Connection) _utilityExtensions.sourceElement(edge)).isPhysical())); + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java b/org.lflang/src/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java index 41635fb7c7..e3de923847 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.util; import com.google.common.collect.ImmutableList; @@ -64,143 +64,177 @@ /** * Utility class to handle dependency edges for collapsed reactors in Lingua Franca diagrams. - * + * * @author Alexander Schulz-Rosengarten */ @ViewSynthesisShared public class InterfaceDependenciesVisualization extends AbstractSynthesisExtensions { - - // Related synthesis option - public static final SynthesisOption SHOW_INTERFACE_DEPENDENCIES = SynthesisOption.createCheckOption("Port Dependencies in Collapsed Reactors", false).setCategory(LinguaFrancaSynthesis.APPEARANCE); - - // Properties for marking diagram elements - public static final Property INTERFACE_DEPENDENCY = new Property<>("org.lflang.linguafranca.diagram.synthesis.dependency.interface", false); - - @Inject @Extension private KEdgeExtensions _kEdgeExtensions; - @Inject @Extension private KRenderingExtensions _kRenderingExtensions; - @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; - @Inject @Extension private LinguaFrancaStyleExtensions _linguaFrancaStyleExtensions; - @Inject @Extension private UtilityExtensions _utilityExtensions; - - /** - * Updates the visibility of interface dependencies edges based on the expansion state. - */ - public static void updateInterfaceDependencyVisibility(KNode node, boolean expanded) { - Iterable edges = IterableExtensions.filter(node.getOutgoingEdges(), it -> { - return it.getProperty(INTERFACE_DEPENDENCY); - }); - - Iterable> renders = IterableExtensions.map(edges, (KEdge it) -> { - return Iterables.filter(it.getData(), KRendering.class); - }); - - Iterables.concat(renders).forEach( + + // Related synthesis option + public static final SynthesisOption SHOW_INTERFACE_DEPENDENCIES = + SynthesisOption.createCheckOption("Port Dependencies in Collapsed Reactors", false) + .setCategory(LinguaFrancaSynthesis.APPEARANCE); + + // Properties for marking diagram elements + public static final Property INTERFACE_DEPENDENCY = + new Property<>("org.lflang.linguafranca.diagram.synthesis.dependency.interface", false); + + @Inject @Extension private KEdgeExtensions _kEdgeExtensions; + @Inject @Extension private KRenderingExtensions _kRenderingExtensions; + @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; + @Inject @Extension private LinguaFrancaStyleExtensions _linguaFrancaStyleExtensions; + @Inject @Extension private UtilityExtensions _utilityExtensions; + + /** Updates the visibility of interface dependencies edges based on the expansion state. */ + public static void updateInterfaceDependencyVisibility(KNode node, boolean expanded) { + Iterable edges = + IterableExtensions.filter( + node.getOutgoingEdges(), it -> { - KInvisibility inv = IterableExtensions.last(Iterables.filter(it.getStyles(), KInvisibility.class)); - if (inv == null) { - inv = KRenderingFactory.eINSTANCE.createKInvisibility(); - it.getStyles().add(inv); - } - inv.setInvisible(expanded); - } - ); - } + return it.getProperty(INTERFACE_DEPENDENCY); + }); + + Iterable> renders = + IterableExtensions.map( + edges, + (KEdge it) -> { + return Iterables.filter(it.getData(), KRendering.class); + }); + + Iterables.concat(renders) + .forEach( + it -> { + KInvisibility inv = + IterableExtensions.last(Iterables.filter(it.getStyles(), KInvisibility.class)); + if (inv == null) { + inv = KRenderingFactory.eINSTANCE.createKInvisibility(); + it.getStyles().add(inv); + } + inv.setInvisible(expanded); + }); + } + + /** + * Adds interface dependencies to the node if this option is active. Visibility will be adjusted + * based on expansion state. + */ + public Spacing addInterfaceDependencies(KNode node, boolean expanded) { + Spacing marginInit = null; + if (getBooleanValue(SHOW_INTERFACE_DEPENDENCIES)) { + List> deps = getPortDependencies(node); + if (!deps.isEmpty()) { + for (Pair pair : deps) { + createDependencyEdge(pair, expanded); + } - /** - * Adds interface dependencies to the node if this option is active. - * Visibility will be adjusted based on expansion state. - */ - public Spacing addInterfaceDependencies(KNode node, boolean expanded) { - Spacing marginInit = null; - if (getBooleanValue(SHOW_INTERFACE_DEPENDENCIES)) { - List> deps = getPortDependencies(node); - if (!deps.isEmpty()) { - for (Pair pair : deps) { - createDependencyEdge(pair, expanded); - } - - // Fix content (label) of collapsed rendering - KContainerRendering contentContainer = IterableExtensions.findFirst( - Iterables.filter(node.getData(), KContainerRendering.class), - it -> { return it.getProperty(KlighdProperties.COLLAPSED_RENDERING); } - ); - if (contentContainer != null) { - if (!contentContainer.getProperty(LinguaFrancaShapeExtensions.REACTOR_CONTENT_CONTAINER)) { - contentContainer = IteratorExtensions.findFirst( - Iterators.filter(contentContainer.eAllContents(), KContainerRendering.class), - it -> { return it.getProperty(LinguaFrancaShapeExtensions.REACTOR_CONTENT_CONTAINER); } - ); - } - if (contentContainer != null) { - List content = ImmutableList.copyOf(contentContainer.getChildren()); - // Put into two new containers such that they are not centered/maximized - KRectangle firstContainer = _kContainerRenderingExtensions.addRectangle(contentContainer); - _kRenderingExtensions.setInvisible(firstContainer, true); - - KRectangle secondContainer = _kContainerRenderingExtensions.addRectangle(firstContainer); - _kRenderingExtensions.setInvisible(secondContainer, true); - _kContainerRenderingExtensions.setGridPlacement(secondContainer, 1); - Iterables.addAll(secondContainer.getChildren(), content); - _kRenderingExtensions.setPointPlacementData(secondContainer, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.TOP, 0, 0, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_TOP, 0, - 0, 0, 0); - - - // Adjust ports separate dependency edges from label/content - if (content.size() > 0) { - marginInit = _utilityExtensions.getPortMarginsInitIfAbsent(node).add( - new ElkMargin((content.size() * 20) - 8, 0, 0, 0) - ); - } - } - } + // Fix content (label) of collapsed rendering + KContainerRendering contentContainer = + IterableExtensions.findFirst( + Iterables.filter(node.getData(), KContainerRendering.class), + it -> { + return it.getProperty(KlighdProperties.COLLAPSED_RENDERING); + }); + if (contentContainer != null) { + if (!contentContainer.getProperty( + LinguaFrancaShapeExtensions.REACTOR_CONTENT_CONTAINER)) { + contentContainer = + IteratorExtensions.findFirst( + Iterators.filter(contentContainer.eAllContents(), KContainerRendering.class), + it -> { + return it.getProperty(LinguaFrancaShapeExtensions.REACTOR_CONTENT_CONTAINER); + }); + } + if (contentContainer != null) { + List content = ImmutableList.copyOf(contentContainer.getChildren()); + // Put into two new containers such that they are not centered/maximized + KRectangle firstContainer = + _kContainerRenderingExtensions.addRectangle(contentContainer); + _kRenderingExtensions.setInvisible(firstContainer, true); + + KRectangle secondContainer = + _kContainerRenderingExtensions.addRectangle(firstContainer); + _kRenderingExtensions.setInvisible(secondContainer, true); + _kContainerRenderingExtensions.setGridPlacement(secondContainer, 1); + Iterables.addAll(secondContainer.getChildren(), content); + _kRenderingExtensions.setPointPlacementData( + secondContainer, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.TOP, + 0, + 0, + _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.V_TOP, + 0, + 0, + 0, + 0); + + // Adjust ports separate dependency edges from label/content + if (content.size() > 0) { + marginInit = + _utilityExtensions + .getPortMarginsInitIfAbsent(node) + .add(new ElkMargin((content.size() * 20) - 8, 0, 0, 0)); } + } } - return marginInit; - } - - /** - * Find dependencies between ports. - */ - private List> getPortDependencies(KNode node) { - Set inputPorts = IterableExtensions.toSet(IterableExtensions.filter( - node.getPorts(), - it -> { return it.getProperty(LinguaFrancaSynthesis.REACTOR_INPUT); }) - ); - Set outputPorts = IterableExtensions.toSet(IterableExtensions.filter( - node.getPorts(), - it -> { return it.getProperty(LinguaFrancaSynthesis.REACTOR_OUTPUT); }) - ); - - // FIXME Replace with real logic - Random rand = new Random(); - return IterableExtensions.toList( - IterableExtensions.map(IterableExtensions.filter( - Sets.cartesianProduct(inputPorts, outputPorts), - it -> { return rand.nextBoolean(); }), - it -> { return new Pair(it.get(0), it.get(1)); })); - } - - /** - * Create an edges for interface dependencies and adjust visibility based on the expansion state of the node. - */ - private KEdge createDependencyEdge(final Pair connection, final boolean expanded) { - KEdge depEdge = _kEdgeExtensions.createEdge(); - depEdge.setSource(connection.getKey().getNode()); - depEdge.setSourcePort(connection.getKey()); - depEdge.setTarget(connection.getValue().getNode()); - depEdge.setTargetPort(connection.getValue()); - depEdge.setProperty(InterfaceDependenciesVisualization.INTERFACE_DEPENDENCY, true); - depEdge.setProperty(CoreOptions.NO_LAYOUT, true); // no routing! - DiagramSyntheses.suppressSelectability(depEdge); - - KPolyline polyline = _kEdgeExtensions.addPolyline(depEdge); - _kRenderingExtensions.setLineStyle(polyline, LineStyle.DOT); - _linguaFrancaStyleExtensions.noSelectionStyle(polyline); - _kRenderingExtensions.setInvisible(polyline, expanded); // make sure there is a style to toggle! - - return depEdge; + } } + return marginInit; + } + + /** Find dependencies between ports. */ + private List> getPortDependencies(KNode node) { + Set inputPorts = + IterableExtensions.toSet( + IterableExtensions.filter( + node.getPorts(), + it -> { + return it.getProperty(LinguaFrancaSynthesis.REACTOR_INPUT); + })); + Set outputPorts = + IterableExtensions.toSet( + IterableExtensions.filter( + node.getPorts(), + it -> { + return it.getProperty(LinguaFrancaSynthesis.REACTOR_OUTPUT); + })); + + // FIXME Replace with real logic + Random rand = new Random(); + return IterableExtensions.toList( + IterableExtensions.map( + IterableExtensions.filter( + Sets.cartesianProduct(inputPorts, outputPorts), + it -> { + return rand.nextBoolean(); + }), + it -> { + return new Pair(it.get(0), it.get(1)); + })); + } + + /** + * Create an edges for interface dependencies and adjust visibility based on the expansion state + * of the node. + */ + private KEdge createDependencyEdge(final Pair connection, final boolean expanded) { + KEdge depEdge = _kEdgeExtensions.createEdge(); + depEdge.setSource(connection.getKey().getNode()); + depEdge.setSourcePort(connection.getKey()); + depEdge.setTarget(connection.getValue().getNode()); + depEdge.setTargetPort(connection.getValue()); + depEdge.setProperty(InterfaceDependenciesVisualization.INTERFACE_DEPENDENCY, true); + depEdge.setProperty(CoreOptions.NO_LAYOUT, true); // no routing! + DiagramSyntheses.suppressSelectability(depEdge); + + KPolyline polyline = _kEdgeExtensions.addPolyline(depEdge); + _kRenderingExtensions.setLineStyle(polyline, LineStyle.DOT); + _linguaFrancaStyleExtensions.noSelectionStyle(polyline); + _kRenderingExtensions.setInvisible(polyline, expanded); // make sure there is a style to toggle! + + return depEdge; + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java b/org.lflang/src/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java index e3264c4b75..33a9b02167 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java @@ -1,33 +1,36 @@ /************* -* Copyright (c) 2022, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2022, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.util; +import de.cau.cs.kieler.klighd.SynthesisOption; +import de.cau.cs.kieler.klighd.kgraph.KNode; +import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; +import de.cau.cs.kieler.klighd.syntheses.DiagramSyntheses; import java.util.Arrays; import java.util.Comparator; import java.util.List; - import org.eclipse.elk.alg.layered.components.ComponentOrderingStrategy; import org.eclipse.elk.alg.layered.options.CrossingMinimizationStrategy; import org.eclipse.elk.alg.layered.options.CycleBreakingStrategy; @@ -41,326 +44,392 @@ import org.lflang.diagram.synthesis.LinguaFrancaSynthesis; import org.lflang.generator.TriggerInstance.BuiltinTriggerVariable; -import de.cau.cs.kieler.klighd.SynthesisOption; -import de.cau.cs.kieler.klighd.kgraph.KNode; -import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; -import de.cau.cs.kieler.klighd.syntheses.DiagramSyntheses; - /** * Set layout configuration options for the Lingua Franca diagram synthesis. - * + * * @author Sören Domrös */ @ViewSynthesisShared public class LayoutPostProcessing extends AbstractSynthesisExtensions { - /** Synthesis option to control the order of nodes and edges by model order. */ - public static final String MODEL_ORDER_OPTION = "Model Order"; - /** Uses semi-automatic layout. */ - public static final String LEGACY = "Legacy"; - /** Only reactions are strictly ordered by their model order. */ - public static final String STRICT_REACTION_ONLY = "Reactions Only"; - /** Reactions and reactor are strictly ordered by their model order. */ - public static final String STRICT = "Reactions and Reactors"; - /** Reactions and reactors are ordered by their model order if no additional crossing are created. */ - public static final String TIE_BREAKER = "Optimize Crossings"; - /** - * No crossing minimization is done at all. This requires that actions and timers are sorted based on their model - * order. - */ - public static final String FULL_CONTROL = "Full Control"; - - - public static final SynthesisOption MODEL_ORDER = - SynthesisOption.createChoiceOption( - MODEL_ORDER_OPTION, - Arrays.asList(TIE_BREAKER, STRICT_REACTION_ONLY, STRICT, FULL_CONTROL), - STRICT_REACTION_ONLY).setCategory(LinguaFrancaSynthesis.LAYOUT); + /** Synthesis option to control the order of nodes and edges by model order. */ + public static final String MODEL_ORDER_OPTION = "Model Order"; + /** Uses semi-automatic layout. */ + public static final String LEGACY = "Legacy"; + /** Only reactions are strictly ordered by their model order. */ + public static final String STRICT_REACTION_ONLY = "Reactions Only"; + /** Reactions and reactor are strictly ordered by their model order. */ + public static final String STRICT = "Reactions and Reactors"; + /** + * Reactions and reactors are ordered by their model order if no additional crossing are created. + */ + public static final String TIE_BREAKER = "Optimize Crossings"; + /** + * No crossing minimization is done at all. This requires that actions and timers are sorted based + * on their model order. + */ + public static final String FULL_CONTROL = "Full Control"; - /** - * Comparator to sort KNodes based on the textual order of their linked instances. - * - * Startup, reset and shutdown actions are not in the model and are handled separately: - * Startup actions will always be first. - * Reset actions follow after the startup action. - * Shutdown is always sorted last. However, shutdown actions will not have a model order set and are, therefore, - * implicitly ordered by their connection. - */ - public static final Comparator TEXTUAL_ORDER = new Comparator() { + public static final SynthesisOption MODEL_ORDER = + SynthesisOption.createChoiceOption( + MODEL_ORDER_OPTION, + Arrays.asList(TIE_BREAKER, STRICT_REACTION_ONLY, STRICT, FULL_CONTROL), + STRICT_REACTION_ONLY) + .setCategory(LinguaFrancaSynthesis.LAYOUT); + + /** + * Comparator to sort KNodes based on the textual order of their linked instances. + * + *

    Startup, reset and shutdown actions are not in the model and are handled separately: Startup + * actions will always be first. Reset actions follow after the startup action. Shutdown is always + * sorted last. However, shutdown actions will not have a model order set and are, therefore, + * implicitly ordered by their connection. + */ + public static final Comparator TEXTUAL_ORDER = + new Comparator() { @Override public int compare(KNode node1, KNode node2) { - var pos1 = getTextPosition(node1); - var pos2 = getTextPosition(node2); - if (pos1 >= 0 && pos1 >= 0) { - return Integer.compare(pos1, pos2); // textual order - } else if (pos1 >= 0) { - return -1; // unassociated elements last - } else if (pos2 >= 0) { - return 1; // unassociated elements last - } - return Integer.compare(node1.hashCode(), node2.hashCode()); // any stable order between unassociated elements + var pos1 = getTextPosition(node1); + var pos2 = getTextPosition(node2); + if (pos1 >= 0 && pos1 >= 0) { + return Integer.compare(pos1, pos2); // textual order + } else if (pos1 >= 0) { + return -1; // unassociated elements last + } else if (pos2 >= 0) { + return 1; // unassociated elements last + } + return Integer.compare( + node1.hashCode(), node2.hashCode()); // any stable order between unassociated elements } - + private int getTextPosition(KNode node) { - var instance = NamedInstanceUtil.getLinkedInstance(node); - if (instance != null) { - var definition = instance.getDefinition(); - if (definition instanceof BuiltinTriggerVariable) { - // special handling for built-in triggers - switch(((BuiltinTriggerVariable)definition).type) { - case STARTUP: return 0; // first - case RESET: return 1; // second - case SHUTDOWN: return Integer.MAX_VALUE; // last - } - } else if (definition instanceof EObject) { - var ast = NodeModelUtils.getNode((EObject) definition); - if (ast != null) { - return ast.getOffset(); - } - } + var instance = NamedInstanceUtil.getLinkedInstance(node); + if (instance != null) { + var definition = instance.getDefinition(); + if (definition instanceof BuiltinTriggerVariable) { + // special handling for built-in triggers + switch (((BuiltinTriggerVariable) definition).type) { + case STARTUP: + return 0; // first + case RESET: + return 1; // second + case SHUTDOWN: + return Integer.MAX_VALUE; // last + } + } else if (definition instanceof EObject) { + var ast = NodeModelUtils.getNode((EObject) definition); + if (ast != null) { + return ast.getOffset(); + } } - return -1; + } + return -1; } - }; + }; - /** - * Configures layout options for main reactor. - * - * @param node The KNode of the main reactor. - */ - public void configureMainReactor(KNode node) { - configureReactor(node); - } + /** + * Configures layout options for main reactor. + * + * @param node The KNode of the main reactor. + */ + public void configureMainReactor(KNode node) { + configureReactor(node); + } - /** - * Configures layout options for a reactor. - * - * @param node The KNode of a reactor. - */ - public void configureReactor(KNode node) { - String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); - - switch (modelOrderStrategy) { - case LEGACY: - // Otherwise nodes are not sorted if they are not connected - DiagramSyntheses.setLayoutOption(node, CoreOptions.SEPARATE_CONNECTED_COMPONENTS, false); - // Needed to enforce node positions. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CROSSING_MINIMIZATION_SEMI_INTERACTIVE, true); - // Costs a little more time but layout is quick, therefore, we can do that. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.THOROUGHNESS, 100); - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CROSSING_MINIMIZATION_GREEDY_SWITCH_TYPE, GreedySwitchType.TWO_SIDED); - break; - case STRICT_REACTION_ONLY: - // Only set model order for reactions. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); - // Do tie-breaking model order cycle breaking. - // Minimize number of backward edges but make decisions based on the model order if no greedy best alternative exists. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CYCLE_BREAKING_STRATEGY, CycleBreakingStrategy.GREEDY_MODEL_ORDER); - // Before crossing minimization sort all nodes and edges/ports but also consider the node model order. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_STRATEGY, OrderingStrategy.NODES_AND_EDGES); - // Separate connected components should be drawn separately. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.SEPARATE_CONNECTED_COMPONENTS, true); - // Component order is enforced by looking at the minimum element with respect to model order of each component. - // Remember that the startUp action is always the first node. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_COMPONENTS, ComponentOrderingStrategy.FORCE_MODEL_ORDER); - DiagramSyntheses.setLayoutOption(node, LayeredOptions.COMPACTION_CONNECTED_COMPONENTS, true); + /** + * Configures layout options for a reactor. + * + * @param node The KNode of a reactor. + */ + public void configureReactor(KNode node) { + String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); - // Node order should not change during crossing minimization. - // Since only reactions will have a model order set in this approach the order of reactions in their respective - // separate connected components always respects the model order. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CROSSING_MINIMIZATION_FORCE_NODE_MODEL_ORDER, true); - // Disable greedy switch since this does otherwise change the node order after crossing minimization. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CROSSING_MINIMIZATION_GREEDY_SWITCH_TYPE, GreedySwitchType.OFF); - break; - case STRICT: - // Do tie-breaking model order cycle breaking. - // Minimize number of backward edges but make decisions based on the model order if no greedy best alternative exists. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CYCLE_BREAKING_STRATEGY, CycleBreakingStrategy.GREEDY_MODEL_ORDER); - // Before crossing minimization sort all nodes and edges/ports but also consider the node model order. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_STRATEGY, OrderingStrategy.NODES_AND_EDGES); - // Separate connected components should be drawn separately. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.SEPARATE_CONNECTED_COMPONENTS, true); - // Component order is enforced by looking at the minimum element with respect to model order of each component. - // Remember that the startUp action is always the first node. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_COMPONENTS, ComponentOrderingStrategy.FORCE_MODEL_ORDER); - DiagramSyntheses.setLayoutOption(node, LayeredOptions.COMPACTION_CONNECTED_COMPONENTS, true); - - // Node order should not change during crossing minimization. - // Since only reactions and reactors will have a model order set in this approach the order of reactions and reactors in their respective - // separate connected components always respects the model order. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CROSSING_MINIMIZATION_FORCE_NODE_MODEL_ORDER, true); - // Disable greedy switch since this does otherwise change the node order after crossing minimization. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CROSSING_MINIMIZATION_GREEDY_SWITCH_TYPE, GreedySwitchType.OFF); - break; - case TIE_BREAKER: - // Do tie-breaking model order cycle breaking. - // Minimize number of backward edges but make decisions based on the model order if no greedy best alternative exists. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CYCLE_BREAKING_STRATEGY, CycleBreakingStrategy.GREEDY_MODEL_ORDER); - // Before crossing minimization sort all nodes and edges/ports but also consider the node model order. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_STRATEGY, OrderingStrategy.NODES_AND_EDGES); - // Separate connected components should be drawn separately. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.SEPARATE_CONNECTED_COMPONENTS, true); - // Component order is enforced by looking at the minimum element with respect to model order of each component. - // Remember that the startUp action is always the first node. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_COMPONENTS, ComponentOrderingStrategy.FORCE_MODEL_ORDER); - DiagramSyntheses.setLayoutOption(node, LayeredOptions.COMPACTION_CONNECTED_COMPONENTS, true); - // During crossing minimization 10 node order violations are regarded as important as 1 edge crossing. - // In reality this chooses the best node order from all tries. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_CROSSING_COUNTER_NODE_INFLUENCE, 0.1); - // Increase the number of tries with different starting configurations. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.THOROUGHNESS, 100); + switch (modelOrderStrategy) { + case LEGACY: + // Otherwise nodes are not sorted if they are not connected + DiagramSyntheses.setLayoutOption(node, CoreOptions.SEPARATE_CONNECTED_COMPONENTS, false); + // Needed to enforce node positions. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CROSSING_MINIMIZATION_SEMI_INTERACTIVE, true); + // Costs a little more time but layout is quick, therefore, we can do that. + DiagramSyntheses.setLayoutOption(node, LayeredOptions.THOROUGHNESS, 100); + DiagramSyntheses.setLayoutOption( + node, + LayeredOptions.CROSSING_MINIMIZATION_GREEDY_SWITCH_TYPE, + GreedySwitchType.TWO_SIDED); + break; + case STRICT_REACTION_ONLY: + // Only set model order for reactions. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); + // Do tie-breaking model order cycle breaking. + // Minimize number of backward edges but make decisions based on the model order if no + // greedy best alternative exists. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CYCLE_BREAKING_STRATEGY, CycleBreakingStrategy.GREEDY_MODEL_ORDER); + // Before crossing minimization sort all nodes and edges/ports but also consider the node + // model order. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_STRATEGY, OrderingStrategy.NODES_AND_EDGES); + // Separate connected components should be drawn separately. + DiagramSyntheses.setLayoutOption(node, LayeredOptions.SEPARATE_CONNECTED_COMPONENTS, true); + // Component order is enforced by looking at the minimum element with respect to model order + // of each component. + // Remember that the startUp action is always the first node. + DiagramSyntheses.setLayoutOption( + node, + LayeredOptions.CONSIDER_MODEL_ORDER_COMPONENTS, + ComponentOrderingStrategy.FORCE_MODEL_ORDER); + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.COMPACTION_CONNECTED_COMPONENTS, true); - break; - case FULL_CONTROL: - // Do strict model order cycle breaking. This may introduce unnecessary backward edges. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CYCLE_BREAKING_STRATEGY, CycleBreakingStrategy.MODEL_ORDER); - // Before crossing minimization sort all nodes and edges/ports but also consider the node model order. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_STRATEGY, OrderingStrategy.NODES_AND_EDGES); - // Separate connected components should be drawn separately. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.SEPARATE_CONNECTED_COMPONENTS, true); - // Component order is enforced by looking at the minimum element with respect to model order of each component. - // Remember that the startUp action is always the first node. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_COMPONENTS, ComponentOrderingStrategy.FORCE_MODEL_ORDER); - DiagramSyntheses.setLayoutOption(node, LayeredOptions.COMPACTION_CONNECTED_COMPONENTS, true); - // Disable all kinds of crossing minimization entirely. Just take what is in the model and just do it. - // This requires that the list of nodes is not ordered by type, e.g. first all reactions, then all reactors, then all actions, ... - // but by their model order. In other approaches ordering actions between the reactions has no effect. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CROSSING_MINIMIZATION_STRATEGY, CrossingMinimizationStrategy.NONE); - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CROSSING_MINIMIZATION_GREEDY_SWITCH_TYPE, GreedySwitchType.OFF); - - break; - default: - // Do nothing. - } - } + // Node order should not change during crossing minimization. + // Since only reactions will have a model order set in this approach the order of reactions + // in their respective + // separate connected components always respects the model order. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CROSSING_MINIMIZATION_FORCE_NODE_MODEL_ORDER, true); + // Disable greedy switch since this does otherwise change the node order after crossing + // minimization. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CROSSING_MINIMIZATION_GREEDY_SWITCH_TYPE, GreedySwitchType.OFF); + break; + case STRICT: + // Do tie-breaking model order cycle breaking. + // Minimize number of backward edges but make decisions based on the model order if no + // greedy best alternative exists. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CYCLE_BREAKING_STRATEGY, CycleBreakingStrategy.GREEDY_MODEL_ORDER); + // Before crossing minimization sort all nodes and edges/ports but also consider the node + // model order. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_STRATEGY, OrderingStrategy.NODES_AND_EDGES); + // Separate connected components should be drawn separately. + DiagramSyntheses.setLayoutOption(node, LayeredOptions.SEPARATE_CONNECTED_COMPONENTS, true); + // Component order is enforced by looking at the minimum element with respect to model order + // of each component. + // Remember that the startUp action is always the first node. + DiagramSyntheses.setLayoutOption( + node, + LayeredOptions.CONSIDER_MODEL_ORDER_COMPONENTS, + ComponentOrderingStrategy.FORCE_MODEL_ORDER); + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.COMPACTION_CONNECTED_COMPONENTS, true); - /** - * Configures layout options for an action. - * - * @param node The KNode of an action. - */ - public void configureAction(KNode node) { - String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); - - switch (modelOrderStrategy) { - case STRICT_REACTION_ONLY: - case STRICT: - case TIE_BREAKER: - // Actions have no model order since their ordering in the model cannot be compared to the order of - // for example reactions since they are generally defined below in inputs/outputs and above the reactions. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); - break; - case FULL_CONTROL: - // Give actions a model order since they should be controllable too. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, false); - break; - default: - // Do nothing. - } - } + // Node order should not change during crossing minimization. + // Since only reactions and reactors will have a model order set in this approach the order + // of reactions and reactors in their respective + // separate connected components always respects the model order. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CROSSING_MINIMIZATION_FORCE_NODE_MODEL_ORDER, true); + // Disable greedy switch since this does otherwise change the node order after crossing + // minimization. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CROSSING_MINIMIZATION_GREEDY_SWITCH_TYPE, GreedySwitchType.OFF); + break; + case TIE_BREAKER: + // Do tie-breaking model order cycle breaking. + // Minimize number of backward edges but make decisions based on the model order if no + // greedy best alternative exists. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CYCLE_BREAKING_STRATEGY, CycleBreakingStrategy.GREEDY_MODEL_ORDER); + // Before crossing minimization sort all nodes and edges/ports but also consider the node + // model order. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_STRATEGY, OrderingStrategy.NODES_AND_EDGES); + // Separate connected components should be drawn separately. + DiagramSyntheses.setLayoutOption(node, LayeredOptions.SEPARATE_CONNECTED_COMPONENTS, true); + // Component order is enforced by looking at the minimum element with respect to model order + // of each component. + // Remember that the startUp action is always the first node. + DiagramSyntheses.setLayoutOption( + node, + LayeredOptions.CONSIDER_MODEL_ORDER_COMPONENTS, + ComponentOrderingStrategy.FORCE_MODEL_ORDER); + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.COMPACTION_CONNECTED_COMPONENTS, true); + // During crossing minimization 10 node order violations are regarded as important as 1 edge + // crossing. + // In reality this chooses the best node order from all tries. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_CROSSING_COUNTER_NODE_INFLUENCE, 0.1); + // Increase the number of tries with different starting configurations. + DiagramSyntheses.setLayoutOption(node, LayeredOptions.THOROUGHNESS, 100); - /** - * Configures layout options for a timer. - * - * @param node The KNode of a timer. - */ - public void configureTimer(KNode node) { - String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); - - switch (modelOrderStrategy) { - case STRICT_REACTION_ONLY: - case STRICT: - case TIE_BREAKER: - // Timers have no model order since their ordering in the model cannot be compared to the order of - // for example reactions since they are generally defined below in inputs/outputs and above the reactions. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); - break; - case FULL_CONTROL: - // Give timers a model order since they should be controllable too. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, false); - break; - default: - // Do nothing. - } + break; + case FULL_CONTROL: + // Do strict model order cycle breaking. This may introduce unnecessary backward edges. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CYCLE_BREAKING_STRATEGY, CycleBreakingStrategy.MODEL_ORDER); + // Before crossing minimization sort all nodes and edges/ports but also consider the node + // model order. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_STRATEGY, OrderingStrategy.NODES_AND_EDGES); + // Separate connected components should be drawn separately. + DiagramSyntheses.setLayoutOption(node, LayeredOptions.SEPARATE_CONNECTED_COMPONENTS, true); + // Component order is enforced by looking at the minimum element with respect to model order + // of each component. + // Remember that the startUp action is always the first node. + DiagramSyntheses.setLayoutOption( + node, + LayeredOptions.CONSIDER_MODEL_ORDER_COMPONENTS, + ComponentOrderingStrategy.FORCE_MODEL_ORDER); + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.COMPACTION_CONNECTED_COMPONENTS, true); + // Disable all kinds of crossing minimization entirely. Just take what is in the model and + // just do it. + // This requires that the list of nodes is not ordered by type, e.g. first all reactions, + // then all reactors, then all actions, ... + // but by their model order. In other approaches ordering actions between the reactions has + // no effect. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CROSSING_MINIMIZATION_STRATEGY, CrossingMinimizationStrategy.NONE); + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CROSSING_MINIMIZATION_GREEDY_SWITCH_TYPE, GreedySwitchType.OFF); + + break; + default: + // Do nothing. } + } + + /** + * Configures layout options for an action. + * + * @param node The KNode of an action. + */ + public void configureAction(KNode node) { + String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); - /** - * Configures layout options for a startup action. - * - * @param node The KNode of a startup action. - */ - public void configureStartUp(KNode node) { - // Nothing should be done. Model order is considered per default value. - // The actual ordering of this node has to be done in the synthesis. + switch (modelOrderStrategy) { + case STRICT_REACTION_ONLY: + case STRICT: + case TIE_BREAKER: + // Actions have no model order since their ordering in the model cannot be compared to the + // order of + // for example reactions since they are generally defined below in inputs/outputs and above + // the reactions. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); + break; + case FULL_CONTROL: + // Give actions a model order since they should be controllable too. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, false); + break; + default: + // Do nothing. } + } - /** - * Configures layout options for a shutdown action. - * - * @param node The KNode of a shutdown action. - */ - public void configureShutDown(KNode node) { - String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); - - switch (modelOrderStrategy) { - case STRICT_REACTION_ONLY: - case STRICT: - case TIE_BREAKER: - case FULL_CONTROL: - // The shutdown node cannot have a high model order, since this would confuse cycle breaking. - // It also cannot have a low model order. - // It should have none at all and the other nodes should define its position. - // This is no problem since the shutdown node has only outgoing edges. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); - break; - default: - // Do nothing. - } + /** + * Configures layout options for a timer. + * + * @param node The KNode of a timer. + */ + public void configureTimer(KNode node) { + String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); + + switch (modelOrderStrategy) { + case STRICT_REACTION_ONLY: + case STRICT: + case TIE_BREAKER: + // Timers have no model order since their ordering in the model cannot be compared to the + // order of + // for example reactions since they are generally defined below in inputs/outputs and above + // the reactions. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); + break; + case FULL_CONTROL: + // Give timers a model order since they should be controllable too. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, false); + break; + default: + // Do nothing. } + } + + /** + * Configures layout options for a startup action. + * + * @param node The KNode of a startup action. + */ + public void configureStartUp(KNode node) { + // Nothing should be done. Model order is considered per default value. + // The actual ordering of this node has to be done in the synthesis. + } - /** - * Configures layout options for a reaction. - * Currently a reaction does not have internal behavior that is visualized and its order is always considered, - * therefore, nothing needs to be done. - * - * @param node The KNode of a reaction. - */ - public void configureReaction(KNode node) { - // Has no internal behavior and model order is set by default. + /** + * Configures layout options for a shutdown action. + * + * @param node The KNode of a shutdown action. + */ + public void configureShutDown(KNode node) { + String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); + + switch (modelOrderStrategy) { + case STRICT_REACTION_ONLY: + case STRICT: + case TIE_BREAKER: + case FULL_CONTROL: + // The shutdown node cannot have a high model order, since this would confuse cycle + // breaking. + // It also cannot have a low model order. + // It should have none at all and the other nodes should define its position. + // This is no problem since the shutdown node has only outgoing edges. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); + break; + default: + // Do nothing. } + } - /** - * Configures layout options for a dummy node. - * - * @param node The KNode of a dummy node. - */ - public void configureDummy(KNode node) { - String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); - - switch (modelOrderStrategy) { - case STRICT_REACTION_ONLY: - case STRICT: - case TIE_BREAKER: - case FULL_CONTROL: - // A dummy node has no model order. - DiagramSyntheses.setLayoutOption(node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); - break; - default: - // Do nothing. - } + /** + * Configures layout options for a reaction. Currently a reaction does not have internal behavior + * that is visualized and its order is always considered, therefore, nothing needs to be done. + * + * @param node The KNode of a reaction. + */ + public void configureReaction(KNode node) { + // Has no internal behavior and model order is set by default. + } + + /** + * Configures layout options for a dummy node. + * + * @param node The KNode of a dummy node. + */ + public void configureDummy(KNode node) { + String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); + + switch (modelOrderStrategy) { + case STRICT_REACTION_ONLY: + case STRICT: + case TIE_BREAKER: + case FULL_CONTROL: + // A dummy node has no model order. + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); + break; + default: + // Do nothing. } + } - /** - * Orders a list of nodes by their corresponding linked instance if synthesis option for full control is enabled. - * Ordering is done by the {@link #TEXTUAL_ORDER} comparator. - * - * @param nodes List of KNodes to be ordered. - */ - public void orderChildren(List nodes) { - String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); - if (FULL_CONTROL.equals(modelOrderStrategy)) { - nodes.sort(TEXTUAL_ORDER); - } + /** + * Orders a list of nodes by their corresponding linked instance if synthesis option for full + * control is enabled. Ordering is done by the {@link #TEXTUAL_ORDER} comparator. + * + * @param nodes List of KNodes to be ordered. + */ + public void orderChildren(List nodes) { + String modelOrderStrategy = (String) getObjectValue(MODEL_ORDER); + if (FULL_CONTROL.equals(modelOrderStrategy)) { + nodes.sort(TEXTUAL_ORDER); } + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/ModeDiagrams.java b/org.lflang/src/org/lflang/diagram/synthesis/util/ModeDiagrams.java index 7222df3cf1..18c13e2b1f 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/util/ModeDiagrams.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/util/ModeDiagrams.java @@ -1,30 +1,62 @@ /************* -* Copyright (c) 2021, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2021, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.util; - +import com.google.common.collect.LinkedHashMultimap; +import com.google.inject.Inject; +import de.cau.cs.kieler.klighd.SynthesisOption; +import de.cau.cs.kieler.klighd.kgraph.KEdge; +import de.cau.cs.kieler.klighd.kgraph.KIdentifier; +import de.cau.cs.kieler.klighd.kgraph.KLabel; +import de.cau.cs.kieler.klighd.kgraph.KNode; +import de.cau.cs.kieler.klighd.kgraph.KPort; +import de.cau.cs.kieler.klighd.krendering.Colors; +import de.cau.cs.kieler.klighd.krendering.HorizontalAlignment; +import de.cau.cs.kieler.klighd.krendering.KContainerRendering; +import de.cau.cs.kieler.klighd.krendering.KDecoratorPlacementData; +import de.cau.cs.kieler.klighd.krendering.KEllipse; +import de.cau.cs.kieler.klighd.krendering.KPolyline; +import de.cau.cs.kieler.klighd.krendering.KRectangle; +import de.cau.cs.kieler.klighd.krendering.KRendering; +import de.cau.cs.kieler.klighd.krendering.KRenderingFactory; +import de.cau.cs.kieler.klighd.krendering.KText; +import de.cau.cs.kieler.klighd.krendering.LineStyle; +import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; +import de.cau.cs.kieler.klighd.krendering.extensions.KContainerRenderingExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KEdgeExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KLabelExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KNodeExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KPolylineExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KPortExtensions; +import de.cau.cs.kieler.klighd.krendering.extensions.KRenderingExtensions; +import de.cau.cs.kieler.klighd.labels.decoration.ITextRenderingProvider; +import de.cau.cs.kieler.klighd.labels.decoration.LabelDecorationConfigurator; +import de.cau.cs.kieler.klighd.labels.decoration.LinesDecorator; +import de.cau.cs.kieler.klighd.labels.decoration.RectangleDecorator; +import de.cau.cs.kieler.klighd.syntheses.DiagramSyntheses; +import de.cau.cs.kieler.klighd.util.KlighdProperties; import java.awt.Color; import java.util.EnumSet; import java.util.HashMap; @@ -33,7 +65,6 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.stream.Collectors; - import org.eclipse.elk.alg.layered.options.CenterEdgeLabelPlacementStrategy; import org.eclipse.elk.alg.layered.options.EdgeStraighteningStrategy; import org.eclipse.elk.alg.layered.options.FixedAlignment; @@ -57,8 +88,8 @@ import org.lflang.diagram.synthesis.styles.LinguaFrancaShapeExtensions; import org.lflang.diagram.synthesis.styles.LinguaFrancaStyleExtensions; import org.lflang.generator.ModeInstance; -import org.lflang.generator.NamedInstance; import org.lflang.generator.ModeInstance.Transition; +import org.lflang.generator.NamedInstance; import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.Mode; @@ -66,531 +97,648 @@ import org.lflang.lf.Reactor; import org.lflang.lf.Timer; -import com.google.common.collect.LinkedHashMultimap; -import com.google.inject.Inject; - -import de.cau.cs.kieler.klighd.SynthesisOption; -import de.cau.cs.kieler.klighd.kgraph.KEdge; -import de.cau.cs.kieler.klighd.kgraph.KIdentifier; -import de.cau.cs.kieler.klighd.kgraph.KLabel; -import de.cau.cs.kieler.klighd.kgraph.KNode; -import de.cau.cs.kieler.klighd.kgraph.KPort; -import de.cau.cs.kieler.klighd.krendering.Colors; -import de.cau.cs.kieler.klighd.krendering.HorizontalAlignment; -import de.cau.cs.kieler.klighd.krendering.KContainerRendering; -import de.cau.cs.kieler.klighd.krendering.KDecoratorPlacementData; -import de.cau.cs.kieler.klighd.krendering.KEllipse; -import de.cau.cs.kieler.klighd.krendering.KPolyline; -import de.cau.cs.kieler.klighd.krendering.KRectangle; -import de.cau.cs.kieler.klighd.krendering.KRendering; -import de.cau.cs.kieler.klighd.krendering.KRenderingFactory; -import de.cau.cs.kieler.klighd.krendering.KText; -import de.cau.cs.kieler.klighd.krendering.LineStyle; -import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; -import de.cau.cs.kieler.klighd.krendering.extensions.KContainerRenderingExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KEdgeExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KLabelExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KNodeExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KPolylineExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KPortExtensions; -import de.cau.cs.kieler.klighd.krendering.extensions.KRenderingExtensions; -import de.cau.cs.kieler.klighd.labels.decoration.ITextRenderingProvider; -import de.cau.cs.kieler.klighd.labels.decoration.LabelDecorationConfigurator; -import de.cau.cs.kieler.klighd.labels.decoration.LinesDecorator; -import de.cau.cs.kieler.klighd.labels.decoration.RectangleDecorator; -import de.cau.cs.kieler.klighd.syntheses.DiagramSyntheses; -import de.cau.cs.kieler.klighd.util.KlighdProperties; - /** * Transformations to support modes in the Lingua Franca diagram synthesis. - * + * * @author Alexander Schulz-Rosengarten */ @ViewSynthesisShared public class ModeDiagrams extends AbstractSynthesisExtensions { - - // Related synthesis option - public static final SynthesisOption MODES_CATEGORY = - SynthesisOption.createCategory("Modes", false).setCategory(LinguaFrancaSynthesis.APPEARANCE); - public static final SynthesisOption SHOW_TRANSITION_LABELS = - SynthesisOption.createCheckOption("Transition Labels", true).setCategory(MODES_CATEGORY); - public static final SynthesisOption INITIALLY_COLLAPSE_MODES = - SynthesisOption.createCheckOption("Initially Collapse Modes", true).setCategory(MODES_CATEGORY); - - private static final Colors MODE_FG = Colors.SLATE_GRAY; - private static final Colors MODE_BG = Colors.SLATE_GRAY_3; - private static final int MODE_BG_ALPHA = 50; - - @Inject @Extension private KNodeExtensions _kNodeExtensions; - @Inject @Extension private KEdgeExtensions _kEdgeExtensions; - @Inject @Extension private KPortExtensions _kPortExtensions; - @Inject @Extension private KLabelExtensions _kLabelExtensions; - @Inject @Extension private KPolylineExtensions _kPolylineExtensions; - @Inject @Extension private KRenderingExtensions _kRenderingExtensions; - @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; - @Inject @Extension private LinguaFrancaShapeExtensions _linguaFrancaShapeExtensions; - @Inject @Extension private LinguaFrancaStyleExtensions _linguaFrancaStyleExtensions; - @Inject @Extension private UtilityExtensions _utilityExtensions; - @Inject @Extension private LayoutPostProcessing _layoutPostProcessing; - - @Extension private KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; - - public void handleModes(List nodes, ReactorInstance reactor) { - if (!reactor.modes.isEmpty()) { - var modeNodes = new LinkedHashMap(); - var modeDefinitionMap = new LinkedHashMap(); - for (ModeInstance mode : reactor.modes) { - var node = _kNodeExtensions.createNode(); - associateWith(node, mode.getDefinition()); - NamedInstanceUtil.linkInstance(node, mode); - _utilityExtensions.setID(node, mode.uniqueID()); - - modeNodes.put(mode, node); - modeDefinitionMap.put(mode.getDefinition(), mode); - - // Layout - if (mode.isInitial()) { - DiagramSyntheses.setLayoutOption(node, LayeredOptions.LAYERING_LAYER_CONSTRAINT, LayerConstraint.FIRST); - } - // Use general layout configuration of reactors - this.getRootSynthesis().configureReactorNodeLayout(node, false); - _layoutPostProcessing.configureReactor(node); - // Adjust for modes - DiagramSyntheses.setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FREE); - - var expansionState = MemorizingExpandCollapseAction.getExpansionState(mode); - DiagramSyntheses.setLayoutOption(node, KlighdProperties.EXPAND, - expansionState != null ? expansionState : !this.getBooleanValue(INITIALLY_COLLAPSE_MODES)); - - // Expanded Rectangle - var expandFigure = addModeFigure(node, mode, true); - expandFigure.setProperty(KlighdProperties.EXPANDED_RENDERING, true); - _kRenderingExtensions.addDoubleClickAction(expandFigure, MemorizingExpandCollapseAction.ID); - - if (getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS)) { - // Collapse button - KText textButton = _linguaFrancaShapeExtensions.addTextButton(expandFigure, LinguaFrancaSynthesis.TEXT_HIDE_ACTION); - _kRenderingExtensions.to( - _kRenderingExtensions.from(_kRenderingExtensions.setGridPlacementData(textButton), - _kRenderingExtensions.LEFT, 8, 0, _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 8, 0, _kRenderingExtensions.BOTTOM, 0, 0); - _kRenderingExtensions.addSingleClickAction(textButton, MemorizingExpandCollapseAction.ID); - _kRenderingExtensions.addDoubleClickAction(textButton, MemorizingExpandCollapseAction.ID); - } - - if (getBooleanValue(LinguaFrancaSynthesis.SHOW_STATE_VARIABLES)) { - // Add mode-local state variables - var variables = mode.getDefinition().getStateVars(); - if (!variables.isEmpty()) { - KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(expandFigure); - _kRenderingExtensions.setInvisible(rectangle, true); - if (!getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS)) { - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 6, 0, - _kRenderingExtensions.BOTTOM, 4, 0); - } else { - _kRenderingExtensions.to( - _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(rectangle), - _kRenderingExtensions.LEFT, 6, 0, - _kRenderingExtensions.TOP, 4, 0), - _kRenderingExtensions.RIGHT, 6, 0, - _kRenderingExtensions.BOTTOM, 0, 0); - } - _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); - this.getRootSynthesis().addStateVariableList(rectangle, variables); - } - } - - _kContainerRenderingExtensions.addChildArea(expandFigure); - - // Collapse Rectangle - var collapseFigure = addModeFigure(node, mode, false); - collapseFigure.setProperty(KlighdProperties.COLLAPSED_RENDERING, true); - if (this.hasContent(mode)) { - _kRenderingExtensions.addDoubleClickAction(collapseFigure, MemorizingExpandCollapseAction.ID); - - if (getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS)) { - // Expand button - KText textButton = _linguaFrancaShapeExtensions.addTextButton(collapseFigure, LinguaFrancaSynthesis.TEXT_SHOW_ACTION); - _kRenderingExtensions.to(_kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(textButton), - _kRenderingExtensions.LEFT, 8, 0, _kRenderingExtensions.TOP, 0, 0), - _kRenderingExtensions.RIGHT, 8, 0, _kRenderingExtensions.BOTTOM, 8, 0); - _kRenderingExtensions.addSingleClickAction(textButton, MemorizingExpandCollapseAction.ID); - _kRenderingExtensions.addDoubleClickAction(textButton, MemorizingExpandCollapseAction.ID); - } - } + + // Related synthesis option + public static final SynthesisOption MODES_CATEGORY = + SynthesisOption.createCategory("Modes", false).setCategory(LinguaFrancaSynthesis.APPEARANCE); + public static final SynthesisOption SHOW_TRANSITION_LABELS = + SynthesisOption.createCheckOption("Transition Labels", true).setCategory(MODES_CATEGORY); + public static final SynthesisOption INITIALLY_COLLAPSE_MODES = + SynthesisOption.createCheckOption("Initially Collapse Modes", true) + .setCategory(MODES_CATEGORY); + + private static final Colors MODE_FG = Colors.SLATE_GRAY; + private static final Colors MODE_BG = Colors.SLATE_GRAY_3; + private static final int MODE_BG_ALPHA = 50; + + @Inject @Extension private KNodeExtensions _kNodeExtensions; + @Inject @Extension private KEdgeExtensions _kEdgeExtensions; + @Inject @Extension private KPortExtensions _kPortExtensions; + @Inject @Extension private KLabelExtensions _kLabelExtensions; + @Inject @Extension private KPolylineExtensions _kPolylineExtensions; + @Inject @Extension private KRenderingExtensions _kRenderingExtensions; + @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; + @Inject @Extension private LinguaFrancaShapeExtensions _linguaFrancaShapeExtensions; + @Inject @Extension private LinguaFrancaStyleExtensions _linguaFrancaStyleExtensions; + @Inject @Extension private UtilityExtensions _utilityExtensions; + @Inject @Extension private LayoutPostProcessing _layoutPostProcessing; + + @Extension private KRenderingFactory _kRenderingFactory = KRenderingFactory.eINSTANCE; + + public void handleModes(List nodes, ReactorInstance reactor) { + if (!reactor.modes.isEmpty()) { + var modeNodes = new LinkedHashMap(); + var modeDefinitionMap = new LinkedHashMap(); + for (ModeInstance mode : reactor.modes) { + var node = _kNodeExtensions.createNode(); + associateWith(node, mode.getDefinition()); + NamedInstanceUtil.linkInstance(node, mode); + _utilityExtensions.setID(node, mode.uniqueID()); + + modeNodes.put(mode, node); + modeDefinitionMap.put(mode.getDefinition(), mode); + + // Layout + if (mode.isInitial()) { + DiagramSyntheses.setLayoutOption( + node, LayeredOptions.LAYERING_LAYER_CONSTRAINT, LayerConstraint.FIRST); + } + // Use general layout configuration of reactors + this.getRootSynthesis().configureReactorNodeLayout(node, false); + _layoutPostProcessing.configureReactor(node); + // Adjust for modes + DiagramSyntheses.setLayoutOption(node, CoreOptions.PORT_CONSTRAINTS, PortConstraints.FREE); + + var expansionState = MemorizingExpandCollapseAction.getExpansionState(mode); + DiagramSyntheses.setLayoutOption( + node, + KlighdProperties.EXPAND, + expansionState != null + ? expansionState + : !this.getBooleanValue(INITIALLY_COLLAPSE_MODES)); + + // Expanded Rectangle + var expandFigure = addModeFigure(node, mode, true); + expandFigure.setProperty(KlighdProperties.EXPANDED_RENDERING, true); + _kRenderingExtensions.addDoubleClickAction(expandFigure, MemorizingExpandCollapseAction.ID); + + if (getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS)) { + // Collapse button + KText textButton = + _linguaFrancaShapeExtensions.addTextButton( + expandFigure, LinguaFrancaSynthesis.TEXT_HIDE_ACTION); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(textButton), + _kRenderingExtensions.LEFT, + 8, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 8, + 0, + _kRenderingExtensions.BOTTOM, + 0, + 0); + _kRenderingExtensions.addSingleClickAction(textButton, MemorizingExpandCollapseAction.ID); + _kRenderingExtensions.addDoubleClickAction(textButton, MemorizingExpandCollapseAction.ID); + } + + if (getBooleanValue(LinguaFrancaSynthesis.SHOW_STATE_VARIABLES)) { + // Add mode-local state variables + var variables = mode.getDefinition().getStateVars(); + if (!variables.isEmpty()) { + KRectangle rectangle = _kContainerRenderingExtensions.addRectangle(expandFigure); + _kRenderingExtensions.setInvisible(rectangle, true); + if (!getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS)) { + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 6, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 6, + 0, + _kRenderingExtensions.BOTTOM, + 4, + 0); + } else { + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(rectangle), + _kRenderingExtensions.LEFT, + 6, + 0, + _kRenderingExtensions.TOP, + 4, + 0), + _kRenderingExtensions.RIGHT, + 6, + 0, + _kRenderingExtensions.BOTTOM, + 0, + 0); } - - var modeChildren = LinkedHashMultimap.create(); - var nodeModes = new HashMap(); - for (var node : nodes) { - var instance = NamedInstanceUtil.getLinkedInstance(node); - if (instance == null && node.getProperty(CoreOptions.COMMENT_BOX)) { - var firstEdge = IterableExtensions.head(node.getOutgoingEdges()); - if (firstEdge != null && firstEdge.getTarget() != null) { - instance = NamedInstanceUtil.getLinkedInstance(firstEdge.getTarget()); - } - } - if (instance != null) { - var mode = instance.getMode(true); - modeChildren.put(mode, node); - nodeModes.put(node, mode); - } else { - modeChildren.put(null, node); - } + _kRenderingExtensions.setHorizontalAlignment(rectangle, HorizontalAlignment.LEFT); + this.getRootSynthesis() + .addStateVariableList(rectangle, variables); + } + } + + _kContainerRenderingExtensions.addChildArea(expandFigure); + + // Collapse Rectangle + var collapseFigure = addModeFigure(node, mode, false); + collapseFigure.setProperty(KlighdProperties.COLLAPSED_RENDERING, true); + if (this.hasContent(mode)) { + _kRenderingExtensions.addDoubleClickAction( + collapseFigure, MemorizingExpandCollapseAction.ID); + + if (getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS)) { + // Expand button + KText textButton = + _linguaFrancaShapeExtensions.addTextButton( + collapseFigure, LinguaFrancaSynthesis.TEXT_SHOW_ACTION); + _kRenderingExtensions.to( + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(textButton), + _kRenderingExtensions.LEFT, + 8, + 0, + _kRenderingExtensions.TOP, + 0, + 0), + _kRenderingExtensions.RIGHT, + 8, + 0, + _kRenderingExtensions.BOTTOM, + 8, + 0); + _kRenderingExtensions.addSingleClickAction( + textButton, MemorizingExpandCollapseAction.ID); + _kRenderingExtensions.addDoubleClickAction( + textButton, MemorizingExpandCollapseAction.ID); + } + } + } + + var modeChildren = LinkedHashMultimap.create(); + var nodeModes = new HashMap(); + for (var node : nodes) { + var instance = NamedInstanceUtil.getLinkedInstance(node); + if (instance == null && node.getProperty(CoreOptions.COMMENT_BOX)) { + var firstEdge = IterableExtensions.head(node.getOutgoingEdges()); + if (firstEdge != null && firstEdge.getTarget() != null) { + instance = NamedInstanceUtil.getLinkedInstance(firstEdge.getTarget()); + } + } + if (instance != null) { + var mode = instance.getMode(true); + modeChildren.put(mode, node); + nodeModes.put(node, mode); + } else { + modeChildren.put(null, node); + } + } + + var modeContainer = _kNodeExtensions.createNode(); + modeContainer.getChildren().addAll(modeNodes.values()); + var modeContainerFigure = addModeContainerFigure(modeContainer); + _kRenderingExtensions.addDoubleClickAction( + modeContainerFigure, MemorizingExpandCollapseAction.ID); + + // Use general layout configuration of reactors + this.getRootSynthesis() + .configureReactorNodeLayout(modeContainer, false); + _layoutPostProcessing.configureReactor(modeContainer); + // Adjust for state machine style + // Create alternating directions to make the model more compact + DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.DIRECTION, Direction.DOWN); + // More state machine like node placement + DiagramSyntheses.setLayoutOption( + modeContainer, + LayeredOptions.NODE_PLACEMENT_STRATEGY, + NodePlacementStrategy.BRANDES_KOEPF); + DiagramSyntheses.setLayoutOption( + modeContainer, LayeredOptions.NODE_PLACEMENT_BK_FIXED_ALIGNMENT, FixedAlignment.BALANCED); + DiagramSyntheses.setLayoutOption( + modeContainer, + LayeredOptions.NODE_PLACEMENT_BK_EDGE_STRAIGHTENING, + EdgeStraighteningStrategy.IMPROVE_STRAIGHTNESS); + // Splines + DiagramSyntheses.setLayoutOption( + modeContainer, CoreOptions.EDGE_ROUTING, EdgeRouting.SPLINES); + DiagramSyntheses.setLayoutOption( + modeContainer, + LayeredOptions.EDGE_LABELS_CENTER_LABEL_PLACEMENT_STRATEGY, + CenterEdgeLabelPlacementStrategy.TAIL_LAYER); + DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.SPACING_NODE_SELF_LOOP, 18.0); + // Unreachable states are unlikely + DiagramSyntheses.setLayoutOption( + modeContainer, CoreOptions.SEPARATE_CONNECTED_COMPONENTS, false); + // Equal padding + DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.PADDING, new ElkPadding(6)); + if (reactor.modes.stream() + .anyMatch(m -> m.transitions.stream().anyMatch(t -> t.type == ModeTransition.HISTORY))) { + // Make additional space for history indicator + DiagramSyntheses.setLayoutOption( + modeContainer, + LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS, + modeContainer.getProperty(LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS) + + (getBooleanValue(SHOW_TRANSITION_LABELS) ? 6.0 : 10.0)); + } + + var modeContainerPorts = new HashMap(); + for (var mode : reactor.modes) { + var modeNode = modeNodes.get(mode); + var edges = new LinkedHashSet(); + // add children + for (var child : modeChildren.get(mode)) { + nodes.remove(child); + modeNode.getChildren().add(child); + + edges.addAll(child.getIncomingEdges()); + edges.addAll(child.getOutgoingEdges()); + } + + // add transitions + var representedTargets = new HashSet>(); + for (var transition : mode.transitions) { + if (!representedTargets.contains( + new Pair(transition.target, transition.type))) { + var edge = _kEdgeExtensions.createEdge(); + edge.setSource(modeNode); + edge.setTarget(modeNodes.get(transition.target)); + addTransitionFigure(edge, transition); + + if (getBooleanValue(SHOW_TRANSITION_LABELS)) { + associateWith(edge, transition.getDefinition()); + } else { + // Bundle similar transitions + representedTargets.add( + new Pair(transition.target, transition.type)); + } + } + } + + // handle cross hierarchy edges + var portCopies = new HashMap(); + var triggerCopies = new HashMap(); + for (var edge : edges) { + if (!edge.getProperty(CoreOptions.NO_LAYOUT)) { + var sourceNodeMode = nodeModes.get(edge.getSource()); + if (sourceNodeMode == null) { + sourceNodeMode = nodeModes.get(edge.getSource().getParent()); } - - var modeContainer = _kNodeExtensions.createNode(); - modeContainer.getChildren().addAll(modeNodes.values()); - var modeContainerFigure = addModeContainerFigure(modeContainer); - _kRenderingExtensions.addDoubleClickAction(modeContainerFigure, MemorizingExpandCollapseAction.ID); - - // Use general layout configuration of reactors - this.getRootSynthesis().configureReactorNodeLayout(modeContainer, false); - _layoutPostProcessing.configureReactor(modeContainer); - // Adjust for state machine style - // Create alternating directions to make the model more compact - DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.DIRECTION, Direction.DOWN); - // More state machine like node placement - DiagramSyntheses.setLayoutOption(modeContainer, LayeredOptions.NODE_PLACEMENT_STRATEGY, NodePlacementStrategy.BRANDES_KOEPF); - DiagramSyntheses.setLayoutOption(modeContainer, LayeredOptions.NODE_PLACEMENT_BK_FIXED_ALIGNMENT, FixedAlignment.BALANCED); - DiagramSyntheses.setLayoutOption(modeContainer, LayeredOptions.NODE_PLACEMENT_BK_EDGE_STRAIGHTENING, EdgeStraighteningStrategy.IMPROVE_STRAIGHTNESS); - // Splines - DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.EDGE_ROUTING, EdgeRouting.SPLINES); - DiagramSyntheses.setLayoutOption(modeContainer, LayeredOptions.EDGE_LABELS_CENTER_LABEL_PLACEMENT_STRATEGY, CenterEdgeLabelPlacementStrategy.TAIL_LAYER); - DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.SPACING_NODE_SELF_LOOP, 18.0); - // Unreachable states are unlikely - DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.SEPARATE_CONNECTED_COMPONENTS, false); - // Equal padding - DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.PADDING, new ElkPadding(6)); - if (reactor.modes.stream().anyMatch(m -> m.transitions.stream().anyMatch(t -> t.type == ModeTransition.HISTORY))) { - // Make additional space for history indicator - DiagramSyntheses.setLayoutOption(modeContainer, LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS, - modeContainer.getProperty(LayeredOptions.SPACING_NODE_NODE_BETWEEN_LAYERS) - + (getBooleanValue(SHOW_TRANSITION_LABELS) ? 6.0 : 10.0)); + var sourceIsInMode = sourceNodeMode != null; + var targetNodeMode = nodeModes.get(edge.getTarget()); + if (targetNodeMode == null) { + targetNodeMode = nodeModes.get(edge.getTarget().getParent()); } + var targetIsInMode = targetNodeMode != null; + + if (!sourceIsInMode || !targetIsInMode) { + var node = sourceIsInMode ? edge.getTarget() : edge.getSource(); + + if (node.getProperty(LinguaFrancaSynthesis.REACTION_SPECIAL_TRIGGER)) { + // Duplicate trigger node + if (!triggerCopies.containsKey(node)) { + var copy = EcoreUtil.copy(node); + modeNode + .getChildren() + .add(modeNode.getChildren().indexOf(edge.getTarget()), copy); + triggerCopies.put(node, copy); - var modeContainerPorts = new HashMap(); - for (var mode : reactor.modes) { - var modeNode = modeNodes.get(mode); - var edges = new LinkedHashSet(); - // add children - for (var child : modeChildren.get(mode)) { - nodes.remove(child); - modeNode.getChildren().add(child); - - edges.addAll(child.getIncomingEdges()); - edges.addAll(child.getOutgoingEdges()); + // Adjust copy + copy.getOutgoingEdges() + .forEach( + e -> { + e.setTarget(null); + e.setTargetPort(null); + }); + copy.getOutgoingEdges().clear(); + copy.getData().stream() + .filter(d -> d instanceof KIdentifier) + .forEach( + d -> { + var kid = (KIdentifier) d; + kid.setId(kid.getId() + "_" + mode.getName()); + }); } - - // add transitions - var representedTargets = new HashSet>(); - for (var transition : mode.transitions) { - if (!representedTargets.contains(new Pair(transition.target, transition.type))) { - var edge = _kEdgeExtensions.createEdge(); - edge.setSource(modeNode); - edge.setTarget(modeNodes.get(transition.target)); - addTransitionFigure(edge, transition); - - if (getBooleanValue(SHOW_TRANSITION_LABELS)) { - associateWith(edge, transition.getDefinition()); - } else { - // Bundle similar transitions - representedTargets.add(new Pair(transition.target, transition.type)); - } - } + + var newNode = triggerCopies.get(node); + edge.setSource(newNode); + + // Remove trigger on top level if only used in modes + if (node.getOutgoingEdges().isEmpty()) { + nodes.remove(node); } - - // handle cross hierarchy edges - var portCopies = new HashMap(); - var triggerCopies = new HashMap(); - for (var edge : edges) { - if (!edge.getProperty(CoreOptions.NO_LAYOUT)) { - var sourceNodeMode = nodeModes.get(edge.getSource()); - if (sourceNodeMode == null) { - sourceNodeMode = nodeModes.get(edge.getSource().getParent()); - } - var sourceIsInMode = sourceNodeMode != null; - var targetNodeMode = nodeModes.get(edge.getTarget()); - if (targetNodeMode == null) { - targetNodeMode = nodeModes.get(edge.getTarget().getParent()); - } - var targetIsInMode = targetNodeMode != null; - - if (!sourceIsInMode || !targetIsInMode) { - var node = sourceIsInMode ? edge.getTarget() : edge.getSource(); - - if (node.getProperty(LinguaFrancaSynthesis.REACTION_SPECIAL_TRIGGER)) { - // Duplicate trigger node - if (!triggerCopies.containsKey(node)) { - var copy = EcoreUtil.copy(node); - modeNode.getChildren().add(modeNode.getChildren().indexOf(edge.getTarget()), copy); - triggerCopies.put(node, copy); - - // Adjust copy - copy.getOutgoingEdges().forEach(e -> {e.setTarget(null);e.setTargetPort(null);}); - copy.getOutgoingEdges().clear(); - copy.getData().stream().filter(d -> d instanceof KIdentifier).forEach(d -> { - var kid = (KIdentifier) d; - kid.setId(kid.getId() + "_" + mode.getName()); - }); - } - - var newNode = triggerCopies.get(node); - edge.setSource(newNode); - - // Remove trigger on top level if only used in modes - if (node.getOutgoingEdges().isEmpty()) { - nodes.remove(node); - } - } else { - var port = sourceIsInMode ? edge.getTargetPort() : edge.getSourcePort(); - var isLocal = modeChildren.get(null).contains(node); - if (isLocal) { - // Add port to mode container - if (modeContainerPorts.containsKey(port)) { - node = modeContainer; - port = modeContainerPorts.get(port); - } else { - var containerPort = _kPortExtensions.createPort(); - modeContainerPorts.put(port, containerPort); - modeContainer.getPorts().add(containerPort); - - _kPortExtensions.setPortSize(containerPort, 8, 8); - KRectangle rect = _kRenderingExtensions.addRectangle(containerPort); - _kRenderingExtensions.setPointPlacementData(rect, - _kRenderingExtensions.LEFT, 0, 0.5f, - _kRenderingExtensions.BOTTOM, 0, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, - 0, 0, 8, 4); - _kRenderingExtensions.setBackground(rect, Colors.BLACK); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(rect); - - DiagramSyntheses.setLayoutOption(containerPort, CoreOptions.PORT_BORDER_OFFSET, -4.0); - DiagramSyntheses.setLayoutOption(containerPort, CoreOptions.PORT_SIDE, sourceIsInMode ? PortSide.EAST : PortSide.WEST); - - var source = _utilityExtensions.sourceElement(node); - var label = ""; - if (source instanceof Action) { - label = ((Action) source).getName(); - } else if (source instanceof Timer) { - label = ((Timer) source).getName(); - } else if (!port.getLabels().isEmpty()) { - label = port.getLabels().get(0).getText(); - if (source instanceof Reactor && getBooleanValue(LinguaFrancaSynthesis.SHOW_INSTANCE_NAMES)) { - NamedInstance linkedInstance = NamedInstanceUtil.getLinkedInstance(node); - if (linkedInstance instanceof ReactorInstance) { - label = ((ReactorInstance) linkedInstance).getName() + "." + label; - } - } - } - var portLabel = _kLabelExtensions.createLabel(containerPort); - portLabel.setText(label); - var portLabelKText = _kRenderingFactory.createKText(); - _kRenderingExtensions.setFontSize(portLabelKText, 8); - portLabel.getData().add(portLabelKText); - - // new connection - var copy = EcoreUtil.copy(edge); - if (sourceIsInMode) { - copy.setSource(modeContainer); - copy.setSourcePort(containerPort); - copy.setTarget(edge.getTarget()); - } else { - copy.setTarget(modeContainer); - copy.setTargetPort(containerPort); - copy.setSource(edge.getSource()); - } - - node = modeContainer; - port = containerPort; - } - } - - // Duplicate port - if (!portCopies.containsKey(port)) { - var copy = EcoreUtil.copy(port); - portCopies.put(port, copy); - - var dummyNode = _kNodeExtensions.createNode(); - var newID = mode.uniqueID() + "_"; - if (!port.getLabels().isEmpty()) { - newID += IterableExtensions.head(port.getLabels()).getText(); - } - _utilityExtensions.setID(dummyNode, newID); - _kRenderingExtensions.addInvisibleContainerRendering(dummyNode); - dummyNode.getPorts().add(copy); - // Assign layer - DiagramSyntheses.setLayoutOption(dummyNode, LayeredOptions.LAYERING_LAYER_CONSTRAINT, - port.getProperty(CoreOptions.PORT_SIDE) == PortSide.WEST ? LayerConstraint.FIRST : LayerConstraint.LAST); - // Configure port spacing - DiagramSyntheses.setLayoutOption(dummyNode, CoreOptions.PORT_LABELS_PLACEMENT, EnumSet.of(PortLabelPlacement.ALWAYS_OTHER_SAME_SIDE, PortLabelPlacement.OUTSIDE)); - // Place freely - DiagramSyntheses.setLayoutOption(dummyNode, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); - // Switch port side - DiagramSyntheses.setLayoutOption(copy, CoreOptions.PORT_SIDE, - port.getProperty(CoreOptions.PORT_SIDE) == PortSide.WEST ? PortSide.EAST : PortSide.WEST); - - modeNode.getChildren().add(dummyNode); - } - var newPort = portCopies.get(port); - if (sourceIsInMode) { - edge.setTarget(newPort.getNode()); - edge.setTargetPort(newPort); - } else { - edge.setSource(newPort.getNode()); - edge.setSourcePort(newPort); - } - } + } else { + var port = sourceIsInMode ? edge.getTargetPort() : edge.getSourcePort(); + var isLocal = modeChildren.get(null).contains(node); + if (isLocal) { + // Add port to mode container + if (modeContainerPorts.containsKey(port)) { + node = modeContainer; + port = modeContainerPorts.get(port); + } else { + var containerPort = _kPortExtensions.createPort(); + modeContainerPorts.put(port, containerPort); + modeContainer.getPorts().add(containerPort); + + _kPortExtensions.setPortSize(containerPort, 8, 8); + KRectangle rect = _kRenderingExtensions.addRectangle(containerPort); + _kRenderingExtensions.setPointPlacementData( + rect, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.BOTTOM, + 0, + 0.5f, + _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 8, + 4); + _kRenderingExtensions.setBackground(rect, Colors.BLACK); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(rect); + + DiagramSyntheses.setLayoutOption( + containerPort, CoreOptions.PORT_BORDER_OFFSET, -4.0); + DiagramSyntheses.setLayoutOption( + containerPort, + CoreOptions.PORT_SIDE, + sourceIsInMode ? PortSide.EAST : PortSide.WEST); + + var source = _utilityExtensions.sourceElement(node); + var label = ""; + if (source instanceof Action) { + label = ((Action) source).getName(); + } else if (source instanceof Timer) { + label = ((Timer) source).getName(); + } else if (!port.getLabels().isEmpty()) { + label = port.getLabels().get(0).getText(); + if (source instanceof Reactor + && getBooleanValue(LinguaFrancaSynthesis.SHOW_INSTANCE_NAMES)) { + NamedInstance linkedInstance = NamedInstanceUtil.getLinkedInstance(node); + if (linkedInstance instanceof ReactorInstance) { + label = ((ReactorInstance) linkedInstance).getName() + "." + label; } + } + } + var portLabel = _kLabelExtensions.createLabel(containerPort); + portLabel.setText(label); + var portLabelKText = _kRenderingFactory.createKText(); + _kRenderingExtensions.setFontSize(portLabelKText, 8); + portLabel.getData().add(portLabelKText); + + // new connection + var copy = EcoreUtil.copy(edge); + if (sourceIsInMode) { + copy.setSource(modeContainer); + copy.setSourcePort(containerPort); + copy.setTarget(edge.getTarget()); + } else { + copy.setTarget(modeContainer); + copy.setTargetPort(containerPort); + copy.setSource(edge.getSource()); } + + node = modeContainer; + port = containerPort; + } } - } - - // If mode container is unused (no ports for local connections) -> hide it - if (modeContainer.getPorts().isEmpty()) { - _kRenderingExtensions.setInvisible(modeContainerFigure, true); - DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.PADDING, new ElkPadding(2)); - } else if (getBooleanValue(LinguaFrancaSynthesis.SHOW_INSTANCE_NAMES)) { - // Remove mode container port labels of ports representing internal connections - // because their association to reactor instances is unambiguous due to instance names - for (var p : modeContainer.getPorts()) { - p.getLabels().removeIf(l -> l.getText().contains(".")); + + // Duplicate port + if (!portCopies.containsKey(port)) { + var copy = EcoreUtil.copy(port); + portCopies.put(port, copy); + + var dummyNode = _kNodeExtensions.createNode(); + var newID = mode.uniqueID() + "_"; + if (!port.getLabels().isEmpty()) { + newID += IterableExtensions.head(port.getLabels()).getText(); + } + _utilityExtensions.setID(dummyNode, newID); + _kRenderingExtensions.addInvisibleContainerRendering(dummyNode); + dummyNode.getPorts().add(copy); + // Assign layer + DiagramSyntheses.setLayoutOption( + dummyNode, + LayeredOptions.LAYERING_LAYER_CONSTRAINT, + port.getProperty(CoreOptions.PORT_SIDE) == PortSide.WEST + ? LayerConstraint.FIRST + : LayerConstraint.LAST); + // Configure port spacing + DiagramSyntheses.setLayoutOption( + dummyNode, + CoreOptions.PORT_LABELS_PLACEMENT, + EnumSet.of( + PortLabelPlacement.ALWAYS_OTHER_SAME_SIDE, PortLabelPlacement.OUTSIDE)); + // Place freely + DiagramSyntheses.setLayoutOption( + dummyNode, LayeredOptions.CONSIDER_MODEL_ORDER_NO_MODEL_ORDER, true); + // Switch port side + DiagramSyntheses.setLayoutOption( + copy, + CoreOptions.PORT_SIDE, + port.getProperty(CoreOptions.PORT_SIDE) == PortSide.WEST + ? PortSide.EAST + : PortSide.WEST); + + modeNode.getChildren().add(dummyNode); + } + var newPort = portCopies.get(port); + if (sourceIsInMode) { + edge.setTarget(newPort.getNode()); + edge.setTargetPort(newPort); + } else { + edge.setSource(newPort.getNode()); + edge.setSourcePort(newPort); } + } } - - nodes.add(modeContainer); + } } - } - - private boolean hasContent(ModeInstance mode) { - return !mode.reactions.isEmpty() || !mode.instantiations.isEmpty(); - } - - private KContainerRendering addModeFigure(KNode node, ModeInstance mode, boolean expanded) { - int padding = getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS) ? 8 : 6; - - var figure = _kRenderingExtensions.addRoundedRectangle(node, 13, 13, 1); - _kContainerRenderingExtensions.setGridPlacement(figure, 1); - _kRenderingExtensions.setLineWidth(figure, mode.isInitial() ? 3f : 1.5f); - _kRenderingExtensions.setForeground(figure, MODE_FG); - _kRenderingExtensions.setBackground(figure, MODE_BG); - var background = _kRenderingExtensions.getBackground(figure); - background.setAlpha(MODE_BG_ALPHA); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); - - // Invisible container - KRectangle container = _kContainerRenderingExtensions.addRectangle(figure); - _kRenderingExtensions.setInvisible(container, true); - int bottomPadding = this.hasContent(mode) && expanded ? 4 : padding; - var from = _kRenderingExtensions.from( - _kRenderingExtensions.setGridPlacementData(container), - _kRenderingExtensions.LEFT, padding, 0, _kRenderingExtensions.TOP, padding, 0); - _kRenderingExtensions.to(from, _kRenderingExtensions.RIGHT, padding, 0, _kRenderingExtensions.BOTTOM, bottomPadding, 0); - - // Centered child container - KRectangle childContainer = _kContainerRenderingExtensions.addRectangle(container); - this._kRenderingExtensions.setInvisible(childContainer, true); - this._kRenderingExtensions.setPointPlacementData(childContainer, - _kRenderingExtensions.LEFT, 0, 0.5f, _kRenderingExtensions.TOP, 0, 0.5f, - _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, 0, 0, 0); - this._kContainerRenderingExtensions.setGridPlacement(childContainer, 1); - - KText text = _kContainerRenderingExtensions.addText(childContainer, mode.getName()); - DiagramSyntheses.suppressSelectability(text); - _linguaFrancaStyleExtensions.underlineSelectionStyle(text); - - return figure; - } - - private KContainerRendering addModeContainerFigure(KNode node) { - var rect = _kRenderingExtensions.addRectangle(node); - _kRenderingExtensions.setLineWidth(rect, 1); - _kRenderingExtensions.setLineStyle(rect, LineStyle.DOT); - _kRenderingExtensions.setForeground(rect, MODE_FG); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(rect); - return rect; - } - - private void addTransitionFigure(KEdge edge, Transition transition) { - var spline = _kEdgeExtensions.addSpline(edge); - _kRenderingExtensions.setLineWidth(spline, 1.5f); - _kRenderingExtensions.setForeground(spline, MODE_FG); - _linguaFrancaStyleExtensions.boldLineSelectionStyle(spline); - - if (transition.type == ModeTransition.HISTORY) { - addHistoryDecorator(spline); - } else { - KRendering arrowDecorator = _kPolylineExtensions.addHeadArrowDecorator(spline); - this._kRenderingExtensions.setForeground(arrowDecorator, MODE_FG); - this._kRenderingExtensions.setBackground(arrowDecorator, MODE_FG); - } - - if (getBooleanValue(SHOW_TRANSITION_LABELS)) { - associateWith(spline, transition.getDefinition()); - - KLabel centerEdgeLabel = _kLabelExtensions.addCenterEdgeLabel(edge, this.toTransitionLabel(transition)); - associateWith(centerEdgeLabel, transition.getDefinition()); - applyTransitionOnEdgeStyle(centerEdgeLabel); + } + + // If mode container is unused (no ports for local connections) -> hide it + if (modeContainer.getPorts().isEmpty()) { + _kRenderingExtensions.setInvisible(modeContainerFigure, true); + DiagramSyntheses.setLayoutOption(modeContainer, CoreOptions.PADDING, new ElkPadding(2)); + } else if (getBooleanValue(LinguaFrancaSynthesis.SHOW_INSTANCE_NAMES)) { + // Remove mode container port labels of ports representing internal connections + // because their association to reactor instances is unambiguous due to instance names + for (var p : modeContainer.getPorts()) { + p.getLabels().removeIf(l -> l.getText().contains(".")); } + } + + nodes.add(modeContainer); } - - private String toTransitionLabel(Transition transition) { - var text = new StringBuilder(); - - text.append(transition.reaction.triggers.stream().map(t -> t.getDefinition().getName()).collect(Collectors.joining(", "))); - return text.toString(); + } + + private boolean hasContent(ModeInstance mode) { + return !mode.reactions.isEmpty() || !mode.instantiations.isEmpty(); + } + + private KContainerRendering addModeFigure(KNode node, ModeInstance mode, boolean expanded) { + int padding = getBooleanValue(LinguaFrancaSynthesis.SHOW_HYPERLINKS) ? 8 : 6; + + var figure = _kRenderingExtensions.addRoundedRectangle(node, 13, 13, 1); + _kContainerRenderingExtensions.setGridPlacement(figure, 1); + _kRenderingExtensions.setLineWidth(figure, mode.isInitial() ? 3f : 1.5f); + _kRenderingExtensions.setForeground(figure, MODE_FG); + _kRenderingExtensions.setBackground(figure, MODE_BG); + var background = _kRenderingExtensions.getBackground(figure); + background.setAlpha(MODE_BG_ALPHA); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(figure); + + // Invisible container + KRectangle container = _kContainerRenderingExtensions.addRectangle(figure); + _kRenderingExtensions.setInvisible(container, true); + int bottomPadding = this.hasContent(mode) && expanded ? 4 : padding; + var from = + _kRenderingExtensions.from( + _kRenderingExtensions.setGridPlacementData(container), + _kRenderingExtensions.LEFT, + padding, + 0, + _kRenderingExtensions.TOP, + padding, + 0); + _kRenderingExtensions.to( + from, + _kRenderingExtensions.RIGHT, + padding, + 0, + _kRenderingExtensions.BOTTOM, + bottomPadding, + 0); + + // Centered child container + KRectangle childContainer = _kContainerRenderingExtensions.addRectangle(container); + this._kRenderingExtensions.setInvisible(childContainer, true); + this._kRenderingExtensions.setPointPlacementData( + childContainer, + _kRenderingExtensions.LEFT, + 0, + 0.5f, + _kRenderingExtensions.TOP, + 0, + 0.5f, + _kRenderingExtensions.H_CENTRAL, + _kRenderingExtensions.V_CENTRAL, + 0, + 0, + 0, + 0); + this._kContainerRenderingExtensions.setGridPlacement(childContainer, 1); + + KText text = _kContainerRenderingExtensions.addText(childContainer, mode.getName()); + DiagramSyntheses.suppressSelectability(text); + _linguaFrancaStyleExtensions.underlineSelectionStyle(text); + + return figure; + } + + private KContainerRendering addModeContainerFigure(KNode node) { + var rect = _kRenderingExtensions.addRectangle(node); + _kRenderingExtensions.setLineWidth(rect, 1); + _kRenderingExtensions.setLineStyle(rect, LineStyle.DOT); + _kRenderingExtensions.setForeground(rect, MODE_FG); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(rect); + return rect; + } + + private void addTransitionFigure(KEdge edge, Transition transition) { + var spline = _kEdgeExtensions.addSpline(edge); + _kRenderingExtensions.setLineWidth(spline, 1.5f); + _kRenderingExtensions.setForeground(spline, MODE_FG); + _linguaFrancaStyleExtensions.boldLineSelectionStyle(spline); + + if (transition.type == ModeTransition.HISTORY) { + addHistoryDecorator(spline); + } else { + KRendering arrowDecorator = _kPolylineExtensions.addHeadArrowDecorator(spline); + this._kRenderingExtensions.setForeground(arrowDecorator, MODE_FG); + this._kRenderingExtensions.setBackground(arrowDecorator, MODE_FG); + } + + if (getBooleanValue(SHOW_TRANSITION_LABELS)) { + associateWith(spline, transition.getDefinition()); + + KLabel centerEdgeLabel = + _kLabelExtensions.addCenterEdgeLabel(edge, this.toTransitionLabel(transition)); + associateWith(centerEdgeLabel, transition.getDefinition()); + applyTransitionOnEdgeStyle(centerEdgeLabel); } - - private static LabelDecorationConfigurator _onEdgeTransitionLabelConfigurator; // ONLY for use in applyTransitionOnEdgeStyle - private void applyTransitionOnEdgeStyle(KLabel label) { - if (_onEdgeTransitionLabelConfigurator == null) { - var foreground = new Color(MODE_FG.getRed(), MODE_FG.getGreen(), MODE_FG.getBlue()); - var background = new Color(Colors.GRAY_95.getRed(), Colors.GRAY_95.getGreen(), Colors.GRAY_95.getBlue()); - _onEdgeTransitionLabelConfigurator = LabelDecorationConfigurator.create() - .withInlineLabels(true) - .withLabelTextRenderingProvider(new ITextRenderingProvider() { + } + + private String toTransitionLabel(Transition transition) { + var text = new StringBuilder(); + + text.append( + transition.reaction.triggers.stream() + .map(t -> t.getDefinition().getName()) + .collect(Collectors.joining(", "))); + return text.toString(); + } + + private static LabelDecorationConfigurator + _onEdgeTransitionLabelConfigurator; // ONLY for use in applyTransitionOnEdgeStyle + + private void applyTransitionOnEdgeStyle(KLabel label) { + if (_onEdgeTransitionLabelConfigurator == null) { + var foreground = new Color(MODE_FG.getRed(), MODE_FG.getGreen(), MODE_FG.getBlue()); + var background = + new Color(Colors.GRAY_95.getRed(), Colors.GRAY_95.getGreen(), Colors.GRAY_95.getBlue()); + _onEdgeTransitionLabelConfigurator = + LabelDecorationConfigurator.create() + .withInlineLabels(true) + .withLabelTextRenderingProvider( + new ITextRenderingProvider() { @Override public KRendering createTextRendering( - KContainerRendering container, KLabel llabel) { - var kText = _kRenderingFactory.createKText(); - _kRenderingExtensions.setFontSize(kText, 8); - container.getChildren().add(kText); - return kText; + KContainerRendering container, KLabel llabel) { + var kText = _kRenderingFactory.createKText(); + _kRenderingExtensions.setFontSize(kText, 8); + container.getChildren().add(kText); + return kText; } - }) - .addDecoratorRenderingProvider(RectangleDecorator.create().withBackground(background)) - .addDecoratorRenderingProvider(LinesDecorator.create().withColor(foreground)); - } - _onEdgeTransitionLabelConfigurator.applyTo(label); - } - - private void addHistoryDecorator(KPolyline line) { - var decorator = _kPolylineExtensions.addHeadArrowDecorator(line); - ((KDecoratorPlacementData) decorator.getPlacementData()).setAbsolute((-15.0f)); - - var ellipse = _kContainerRenderingExtensions.addEllipse(line); - _kRenderingExtensions.setDecoratorPlacementData(ellipse, 16, 16, (-6), 1, false); - _kRenderingExtensions.setLineWidth(ellipse, 0.8f); - _kRenderingExtensions.setForeground(ellipse, MODE_FG); - _kRenderingExtensions.setBackground(ellipse, Colors.WHITE); - - var innerLine = _kContainerRenderingExtensions.addPolyline(ellipse); - _kRenderingExtensions.setLineWidth(innerLine, 2); - var points = innerLine.getPoints(); - points.add(_kRenderingExtensions.createKPosition(_kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.TOP, 4, 0)); - points.add(_kRenderingExtensions.createKPosition(_kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.BOTTOM, 4, 0)); - points.add(_kRenderingExtensions.createKPosition(_kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.TOP, 0, 0.5f)); - points.add(_kRenderingExtensions.createKPosition(_kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.TOP, 0, 0.5f)); - points.add(_kRenderingExtensions.createKPosition(_kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.BOTTOM, 4, 0)); - points.add(_kRenderingExtensions.createKPosition(_kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.TOP, 4, 0)); - _kRenderingExtensions.setForeground(innerLine, MODE_FG); + }) + .addDecoratorRenderingProvider(RectangleDecorator.create().withBackground(background)) + .addDecoratorRenderingProvider(LinesDecorator.create().withColor(foreground)); } - -} \ No newline at end of file + _onEdgeTransitionLabelConfigurator.applyTo(label); + } + + private void addHistoryDecorator(KPolyline line) { + var decorator = _kPolylineExtensions.addHeadArrowDecorator(line); + ((KDecoratorPlacementData) decorator.getPlacementData()).setAbsolute((-15.0f)); + + var ellipse = _kContainerRenderingExtensions.addEllipse(line); + _kRenderingExtensions.setDecoratorPlacementData(ellipse, 16, 16, (-6), 1, false); + _kRenderingExtensions.setLineWidth(ellipse, 0.8f); + _kRenderingExtensions.setForeground(ellipse, MODE_FG); + _kRenderingExtensions.setBackground(ellipse, Colors.WHITE); + + var innerLine = _kContainerRenderingExtensions.addPolyline(ellipse); + _kRenderingExtensions.setLineWidth(innerLine, 2); + var points = innerLine.getPoints(); + points.add( + _kRenderingExtensions.createKPosition( + _kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.TOP, 4, 0)); + points.add( + _kRenderingExtensions.createKPosition( + _kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.BOTTOM, 4, 0)); + points.add( + _kRenderingExtensions.createKPosition( + _kRenderingExtensions.LEFT, 5, 0, _kRenderingExtensions.TOP, 0, 0.5f)); + points.add( + _kRenderingExtensions.createKPosition( + _kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.TOP, 0, 0.5f)); + points.add( + _kRenderingExtensions.createKPosition( + _kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.BOTTOM, 4, 0)); + points.add( + _kRenderingExtensions.createKPosition( + _kRenderingExtensions.RIGHT, 5, 0, _kRenderingExtensions.TOP, 4, 0)); + _kRenderingExtensions.setForeground(innerLine, MODE_FG); + } +} diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java b/org.lflang/src/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java index e7143b44fc..ab2edc658a 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.util; import de.cau.cs.kieler.klighd.kgraph.KGraphElement; @@ -31,28 +31,24 @@ /** * Utility class to link KGraphElements to NamedInstances. - * + * * @author Alexander Schulz-Rosengarten */ public class NamedInstanceUtil { - public static final Property> LINKED_INSTANCE = new Property<>( - "org.lflang.linguafranca.diagram.synthesis.graph.instance"); + public static final Property> LINKED_INSTANCE = + new Property<>("org.lflang.linguafranca.diagram.synthesis.graph.instance"); - /** - * Establishes a link between KGraphElement and NamedInstance. - */ - public static IPropertyHolder linkInstance(KGraphElement elem, NamedInstance instance) { - return elem.setProperty(LINKED_INSTANCE, instance); - } + /** Establishes a link between KGraphElement and NamedInstance. */ + public static IPropertyHolder linkInstance(KGraphElement elem, NamedInstance instance) { + return elem.setProperty(LINKED_INSTANCE, instance); + } - /** - * Returns the linked NamedInstance for the given KGraphElement. - */ - public static NamedInstance getLinkedInstance(KGraphElement elem) { - var instance = elem.getProperty(LINKED_INSTANCE); - if (instance != null) { - return instance; - } - return null; + /** Returns the linked NamedInstance for the given KGraphElement. */ + public static NamedInstance getLinkedInstance(KGraphElement elem) { + var instance = elem.getProperty(LINKED_INSTANCE); + if (instance != null) { + return instance; } + return null; + } } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/ReactorIcons.java b/org.lflang/src/org/lflang/diagram/synthesis/util/ReactorIcons.java index e740ebf653..a69b7d3e4f 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/util/ReactorIcons.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/util/ReactorIcons.java @@ -1,146 +1,148 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.util; -//import org.eclipse.swt.graphics.ImageData; -//import org.eclipse.swt.graphics.ImageLoader; -import org.eclipse.xtext.xbase.lib.Extension; -import org.lflang.AttributeUtils; -import org.lflang.diagram.synthesis.AbstractSynthesisExtensions; -import org.lflang.lf.ReactorDecl; -import org.lflang.util.FileUtil; - +// import org.eclipse.swt.graphics.ImageData; +// import org.eclipse.swt.graphics.ImageLoader; import com.google.inject.Inject; - import de.cau.cs.kieler.klighd.krendering.KContainerRendering; import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; import de.cau.cs.kieler.klighd.krendering.extensions.KContainerRenderingExtensions; import de.cau.cs.kieler.klighd.krendering.extensions.KRenderingExtensions; +import org.eclipse.xtext.xbase.lib.Extension; +import org.lflang.AttributeUtils; +import org.lflang.diagram.synthesis.AbstractSynthesisExtensions; +import org.lflang.lf.ReactorDecl; +import org.lflang.util.FileUtil; /** * Utility class to handle icons for reactors in Lingua Franca diagrams. - * + * * @author Alexander Schulz-Rosengarten */ @ViewSynthesisShared public class ReactorIcons extends AbstractSynthesisExtensions { - @Inject @Extension private KRenderingExtensions _kRenderingExtensions; - @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; - -// private static final ImageLoader LOADER = new ImageLoader(); - - // Image cache during synthesis -// private final HashMap cache = new HashMap<>(); - - // Error message - private String error = null; + @Inject @Extension private KRenderingExtensions _kRenderingExtensions; + @Inject @Extension private KContainerRenderingExtensions _kContainerRenderingExtensions; + + // private static final ImageLoader LOADER = new ImageLoader(); + + // Image cache during synthesis + // private final HashMap cache = new HashMap<>(); + + // Error message + private String error = null; - public void handleIcon(KContainerRendering rendering, ReactorDecl reactor, boolean collapsed) { - if (!collapsed) { - return; - } - - // Reset error - error = null; - - // Get annotation - var iconPath = AttributeUtils.getIconPath(reactor); - if (iconPath != null && !iconPath.isEmpty()) { - var iconLocation = FileUtil.locateFile(iconPath, reactor.eResource()); - if (iconLocation == null) { - error = "Cannot find given icon file."; - } else { - /* - * This code was disabled because it cannot be compiled for the language server with Gradle. - * As soon as the Klighd API is extended to support URI-based images in both Eclipse and VSCode, - * this code should be reactivated and adapted. - * See: https://github.com/kieler/KLighD/issues/146 - */ -// ImageData data = loadImage(iconLocation); -// if (data != null) { -// KRectangle figure = _kContainerRenderingExtensions.addRectangle(rendering); -// _kRenderingExtensions.setInvisible(figure, true); -// KGridPlacementData figurePlacement = _kRenderingExtensions.setGridPlacementData(figure, data.width, data.height); -// _kRenderingExtensions.to( -// _kRenderingExtensions.from( -// figurePlacement, -// _kRenderingExtensions.LEFT, 3, 0, -// _kRenderingExtensions.TOP, 0, 0), -// _kRenderingExtensions.RIGHT, 3, 0, -// _kRenderingExtensions.BOTTOM, 3, 0); -// -// KRectangle icon = _kContainerRenderingExtensions.addRectangle(figure); -// _kRenderingExtensions.setInvisible(icon, true); -// _kContainerRenderingExtensions.addImage(icon, data); -// _kRenderingExtensions.setPointPlacementData(icon, -// _kRenderingExtensions.createKPosition( -// _kRenderingExtensions.LEFT, 0, 0.5f, -// _kRenderingExtensions.TOP, 0, 0.5f), -// _kRenderingExtensions.H_CENTRAL, _kRenderingExtensions.V_CENTRAL, 0, -// 0, data.width, data.height); -// } -// if (error != null) { -// var errorText = _kContainerRenderingExtensions.addText(rendering, "Icon not found!\n"+error); -// _kRenderingExtensions.setForeground(errorText, Colors.RED); -// _kRenderingExtensions.setFontBold(errorText, true); -// _kRenderingExtensions.setSurroundingSpaceGrid(errorText, 8, 0); -// } - } - } + public void handleIcon(KContainerRendering rendering, ReactorDecl reactor, boolean collapsed) { + if (!collapsed) { + return; } -// private ImageData loadImage(final java.net.URI uri) { -// try { -// if (cache.containsKey(uri)) { -// return cache.get(uri); -// } -// synchronized (LOADER) { -// InputStream inStream = null; -// try { -// inStream = uri.toURL().openStream(); -// ImageData[] data = LOADER.load(inStream); -// if (data != null && data.length > 0) { -// ImageData img = data[0]; -// cache.put(uri, img); -// return img; -// } else { -// error = "Could not load icon image."; -// return null; -// } -// } finally { -// if (inStream != null) { -// inStream.close(); -// } -// } -// } -// } catch (Exception ex) { -// ex.printStackTrace(); -// error = "Could not load icon image."; -// return null; -// } -// } - + // Reset error + error = null; + + // Get annotation + var iconPath = AttributeUtils.getIconPath(reactor); + if (iconPath != null && !iconPath.isEmpty()) { + var iconLocation = FileUtil.locateFile(iconPath, reactor.eResource()); + if (iconLocation == null) { + error = "Cannot find given icon file."; + } else { + /* + * This code was disabled because it cannot be compiled for the language server with Gradle. + * As soon as the Klighd API is extended to support URI-based images in both Eclipse and VSCode, + * this code should be reactivated and adapted. + * See: https://github.com/kieler/KLighD/issues/146 + */ + // ImageData data = loadImage(iconLocation); + // if (data != null) { + // KRectangle figure = + // _kContainerRenderingExtensions.addRectangle(rendering); + // _kRenderingExtensions.setInvisible(figure, true); + // KGridPlacementData figurePlacement = + // _kRenderingExtensions.setGridPlacementData(figure, data.width, data.height); + // _kRenderingExtensions.to( + // _kRenderingExtensions.from( + // figurePlacement, + // _kRenderingExtensions.LEFT, 3, 0, + // _kRenderingExtensions.TOP, 0, 0), + // _kRenderingExtensions.RIGHT, 3, 0, + // _kRenderingExtensions.BOTTOM, 3, 0); + // + // KRectangle icon = _kContainerRenderingExtensions.addRectangle(figure); + // _kRenderingExtensions.setInvisible(icon, true); + // _kContainerRenderingExtensions.addImage(icon, data); + // _kRenderingExtensions.setPointPlacementData(icon, + // _kRenderingExtensions.createKPosition( + // _kRenderingExtensions.LEFT, 0, 0.5f, + // _kRenderingExtensions.TOP, 0, 0.5f), + // _kRenderingExtensions.H_CENTRAL, + // _kRenderingExtensions.V_CENTRAL, 0, + // 0, data.width, data.height); + // } + // if (error != null) { + // var errorText = _kContainerRenderingExtensions.addText(rendering, + // "Icon not found!\n"+error); + // _kRenderingExtensions.setForeground(errorText, Colors.RED); + // _kRenderingExtensions.setFontBold(errorText, true); + // _kRenderingExtensions.setSurroundingSpaceGrid(errorText, 8, 0); + // } + } + } + } + + // private ImageData loadImage(final java.net.URI uri) { + // try { + // if (cache.containsKey(uri)) { + // return cache.get(uri); + // } + // synchronized (LOADER) { + // InputStream inStream = null; + // try { + // inStream = uri.toURL().openStream(); + // ImageData[] data = LOADER.load(inStream); + // if (data != null && data.length > 0) { + // ImageData img = data[0]; + // cache.put(uri, img); + // return img; + // } else { + // error = "Could not load icon image."; + // return null; + // } + // } finally { + // if (inStream != null) { + // inStream.close(); + // } + // } + // } + // } catch (Exception ex) { + // ex.printStackTrace(); + // error = "Could not load icon image."; + // return null; + // } + // } + } diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java b/org.lflang/src/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java index fdf5070713..a249c009fd 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java @@ -1,27 +1,27 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.util; import java.nio.file.Path; @@ -32,53 +32,53 @@ * @author Alexander Schulz-Rosengarten */ public class SynthesisErrorReporter implements ErrorReporter { - @Override - public String reportError(String message) { - return null; - } - - @Override - public String reportError(EObject object, String message) { - return null; - } - - @Override - public String reportError(Path file, Integer line, String message) { - return null; - } - - @Override - public String reportWarning(String message) { - return null; - } - - @Override - public String reportWarning(EObject object, String message) { - return null; - } - - @Override - public String reportWarning(Path file, Integer line, String message) { - return null; - } + @Override + public String reportError(String message) { + return null; + } - @Override - public String reportInfo(String message) { - return null; - } + @Override + public String reportError(EObject object, String message) { + return null; + } - @Override - public String reportInfo(EObject object, String message) { - return null; - } + @Override + public String reportError(Path file, Integer line, String message) { + return null; + } - @Override - public String reportInfo(Path file, Integer line, String message) { - return null; - } + @Override + public String reportWarning(String message) { + return null; + } - @Override - public boolean getErrorsOccurred() { - return false; - } -} \ No newline at end of file + @Override + public String reportWarning(EObject object, String message) { + return null; + } + + @Override + public String reportWarning(Path file, Integer line, String message) { + return null; + } + + @Override + public String reportInfo(String message) { + return null; + } + + @Override + public String reportInfo(EObject object, String message) { + return null; + } + + @Override + public String reportInfo(Path file, Integer line, String message) { + return null; + } + + @Override + public boolean getErrorsOccurred() { + return false; + } +} diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/UtilityExtensions.java b/org.lflang/src/org/lflang/diagram/synthesis/util/UtilityExtensions.java index fb97bd1449..ca83da41a8 100644 --- a/org.lflang/src/org/lflang/diagram/synthesis/util/UtilityExtensions.java +++ b/org.lflang/src/org/lflang/diagram/synthesis/util/UtilityExtensions.java @@ -1,33 +1,38 @@ /************* -* Copyright (c) 2020, Kiel University. -* -* 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. -* -* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.diagram.synthesis.util; +import de.cau.cs.kieler.klighd.internal.util.KlighdInternalProperties; +import de.cau.cs.kieler.klighd.kgraph.KGraphElement; +import de.cau.cs.kieler.klighd.kgraph.KGraphFactory; +import de.cau.cs.kieler.klighd.kgraph.KIdentifier; +import de.cau.cs.kieler.klighd.kgraph.KNode; +import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; import java.util.ArrayList; import java.util.Arrays; import java.util.List; - import org.eclipse.elk.core.math.ElkMargin; import org.eclipse.elk.core.options.CoreOptions; import org.eclipse.elk.core.util.IndividualSpacings; @@ -39,163 +44,133 @@ import org.lflang.diagram.synthesis.AbstractSynthesisExtensions; import org.lflang.generator.ReactorInstance; import org.lflang.lf.Code; -import org.lflang.lf.Expression; -import org.lflang.lf.Host; -import org.lflang.lf.Literal; -import org.lflang.lf.ParameterReference; import org.lflang.lf.Reactor; -import org.lflang.lf.Time; -import org.lflang.util.StringUtil; - -import de.cau.cs.kieler.klighd.internal.util.KlighdInternalProperties; -import de.cau.cs.kieler.klighd.kgraph.KGraphElement; -import de.cau.cs.kieler.klighd.kgraph.KGraphFactory; -import de.cau.cs.kieler.klighd.kgraph.KIdentifier; -import de.cau.cs.kieler.klighd.kgraph.KNode; -import de.cau.cs.kieler.klighd.krendering.ViewSynthesisShared; /** * Extension class that provides various utility methods for the synthesis. - * + * * @author Alexander Schulz-Rosengarten */ @ViewSynthesisShared public class UtilityExtensions extends AbstractSynthesisExtensions { - - @Extension - private KGraphFactory _kGraphFactory = KGraphFactory.eINSTANCE; - - - /** - * Returns true if the reactor is the primary reactor - */ - public boolean isMainOrFederated(Reactor reactor) { - return reactor.isMain() || reactor.isFederated(); - } - - /** - * Returns true if the instance is a bank of reactors - */ -// def boolean isBank(Instantiation ins) { -// return ins?.widthSpec !== null ? ins.widthSpec.width !== 1 : false -// } - - /** - * Returns true if the reactor as has inner reactions or instances - */ - public boolean hasContent(final ReactorInstance reactor) { - return !reactor.reactions.isEmpty() || !reactor.instantiations().isEmpty(); - } - - /** - * - */ - public boolean isRoot(final ReactorInstance ri) { - return ri.getParent() == null; + + @Extension private KGraphFactory _kGraphFactory = KGraphFactory.eINSTANCE; + + /** Returns true if the reactor is the primary reactor */ + public boolean isMainOrFederated(Reactor reactor) { + return reactor.isMain() || reactor.isFederated(); + } + + /** Returns true if the instance is a bank of reactors */ + // def boolean isBank(Instantiation ins) { + // return ins?.widthSpec !== null ? ins.widthSpec.width !== 1 : false + // } + + /** Returns true if the reactor as has inner reactions or instances */ + public boolean hasContent(final ReactorInstance reactor) { + return !reactor.reactions.isEmpty() || !reactor.instantiations().isEmpty(); + } + + /** */ + public boolean isRoot(final ReactorInstance ri) { + return ri.getParent() == null; + } + + /** Trims the hostcode of reactions. */ + public String trimCode(final Code tokenizedCode) { + if (tokenizedCode == null || StringExtensions.isNullOrEmpty(tokenizedCode.getBody())) { + return ""; } - - /** - * Trims the hostcode of reactions. - */ - public String trimCode(final Code tokenizedCode) { - if (tokenizedCode == null || StringExtensions.isNullOrEmpty(tokenizedCode.getBody())) { - return ""; + try { + ICompositeNode node = NodeModelUtils.findActualNodeFor(tokenizedCode); + String code = node != null ? node.getText() : null; + int contentStart = 0; + List lines = new ArrayList<>(); + Arrays.stream(code.split("\n")) + .dropWhile(line -> !line.contains("{=")) + .forEachOrdered(lines::add); + + // Remove start pattern + if (!lines.isEmpty()) { + if (IterableExtensions.head(lines).trim().equals("{=")) { + lines.remove(0); // skip + } else { + lines.set(0, IterableExtensions.head(lines).replace("{=", "").trim()); + contentStart = 1; } - try { - ICompositeNode node = NodeModelUtils.findActualNodeFor(tokenizedCode); - String code = node != null ? node.getText() : null; - int contentStart = 0; - List lines = new ArrayList<>(); - Arrays.stream(code.split("\n")).dropWhile(line -> !line.contains("{=")).forEachOrdered(lines::add); - - // Remove start pattern - if (!lines.isEmpty()) { - if (IterableExtensions.head(lines).trim().equals("{=")) { - lines.remove(0); // skip - } else { - lines.set(0, IterableExtensions.head(lines).replace("{=", "").trim()); - contentStart = 1; - } - } - - // Remove end pattern - if (!lines.isEmpty()) { - if (IterableExtensions.last(lines).trim().equals("=}")) { - lines.remove(lines.size() - 1); // skip - } else { - lines.set(lines.size() - 1, IterableExtensions.last(lines).replace("=}", "")); - } - } - - // Find indentation - String indentation = null; - while (indentation == null && lines.size() > contentStart) { - String firstLine = lines.get(contentStart); - String trimmed = firstLine.trim(); - if (trimmed.isEmpty()) { - lines.set(contentStart, ""); - contentStart++; - } else { - int firstCharIdx = firstLine.indexOf(trimmed.charAt(0)); - indentation = firstLine.substring(0, firstCharIdx); - } - } - - // Remove root indentation - if (!lines.isEmpty()) { - for (int i = 0; i < lines.size(); i++) { - if (lines.get(i).startsWith(indentation)) { - lines.set(i, lines.get(i).substring(indentation.length())); - } - } - } - - return String.join("\n", lines); - } catch(Exception e) { - e.printStackTrace(); - return tokenizedCode.getBody(); + } + + // Remove end pattern + if (!lines.isEmpty()) { + if (IterableExtensions.last(lines).trim().equals("=}")) { + lines.remove(lines.size() - 1); // skip + } else { + lines.set(lines.size() - 1, IterableExtensions.last(lines).replace("=}", "")); } - } - - /** - * Sets KGE ID. - */ - public boolean setID(KGraphElement kge, String id) { - KIdentifier identifier = _kGraphFactory.createKIdentifier(); - identifier.setId(id); - return kge.getData().add(identifier); - } - - /** - * Retrieves the source element of the given diagram element - */ - public Object sourceElement(KGraphElement elem) { - return elem.getProperty(KlighdInternalProperties.MODEL_ELEMEMT); - } - - /** - * Checks if the source element of the given diagram element is a reactor - */ - public boolean sourceIsReactor(KNode node) { - return sourceElement(node) instanceof Reactor; - } + } - /** - * Returns the port placement margins for the node. - * If this spacing does not yet exist, the properties are initialized. - */ - public ElkMargin getPortMarginsInitIfAbsent(KNode node) { - IndividualSpacings spacing = node.getProperty(CoreOptions.SPACING_INDIVIDUAL); - if (spacing == null) { - spacing = new IndividualSpacings(); - node.setProperty(CoreOptions.SPACING_INDIVIDUAL, spacing); + // Find indentation + String indentation = null; + while (indentation == null && lines.size() > contentStart) { + String firstLine = lines.get(contentStart); + String trimmed = firstLine.trim(); + if (trimmed.isEmpty()) { + lines.set(contentStart, ""); + contentStart++; + } else { + int firstCharIdx = firstLine.indexOf(trimmed.charAt(0)); + indentation = firstLine.substring(0, firstCharIdx); } - ElkMargin margin = spacing.getProperty(CoreOptions.SPACING_PORTS_SURROUNDING); - if (margin == null) { - margin = new ElkMargin(); - node.setProperty(CoreOptions.SPACING_PORTS_SURROUNDING, margin); + } + + // Remove root indentation + if (!lines.isEmpty()) { + for (int i = 0; i < lines.size(); i++) { + if (lines.get(i).startsWith(indentation)) { + lines.set(i, lines.get(i).substring(indentation.length())); + } } - return margin; - } + } + + return String.join("\n", lines); + } catch (Exception e) { + e.printStackTrace(); + return tokenizedCode.getBody(); + } + } + + /** Sets KGE ID. */ + public boolean setID(KGraphElement kge, String id) { + KIdentifier identifier = _kGraphFactory.createKIdentifier(); + identifier.setId(id); + return kge.getData().add(identifier); + } + /** Retrieves the source element of the given diagram element */ + public Object sourceElement(KGraphElement elem) { + return elem.getProperty(KlighdInternalProperties.MODEL_ELEMEMT); + } + + /** Checks if the source element of the given diagram element is a reactor */ + public boolean sourceIsReactor(KNode node) { + return sourceElement(node) instanceof Reactor; + } + + /** + * Returns the port placement margins for the node. If this spacing does not yet exist, the + * properties are initialized. + */ + public ElkMargin getPortMarginsInitIfAbsent(KNode node) { + IndividualSpacings spacing = node.getProperty(CoreOptions.SPACING_INDIVIDUAL); + if (spacing == null) { + spacing = new IndividualSpacings(); + node.setProperty(CoreOptions.SPACING_INDIVIDUAL, spacing); + } + ElkMargin margin = spacing.getProperty(CoreOptions.SPACING_PORTS_SURROUNDING); + if (margin == null) { + margin = new ElkMargin(); + node.setProperty(CoreOptions.SPACING_PORTS_SURROUNDING, margin); + } + return margin; + } } diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/src/org/lflang/federated/extensions/CExtension.java index 18b5d9615a..121cf5d817 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtension.java @@ -33,14 +33,13 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.List; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.Target; import org.lflang.TargetProperty; import org.lflang.TargetProperty.CoordinationType; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.federated.generator.FedASTUtils; import org.lflang.federated.generator.FedConnectionInstance; import org.lflang.federated.generator.FedFileConfig; @@ -59,708 +58,763 @@ import org.lflang.lf.VarRef; /** - * An extension class to the CGenerator that enables certain federated - * functionalities. Currently, this class offers the following features: + * An extension class to the CGenerator that enables certain federated functionalities. Currently, + * this class offers the following features: * *

      - *
    • Allocating and initializing C structures for federated communication
      • - *
    • Creating status field for network input ports that help the receiver logic in - * federate.c communicate the status of a network input port with network input - * control reactions.
      • + *
    • Allocating and initializing C structures for federated communication + *
    • Creating status field for network input ports that help the receiver logic in federate.c + * communicate the status of a network input port with network input control reactions. *
    * * @author {Soroush Bateni } * @author {Hou Seng Wong } * @author {Billy Bao } - * */ public class CExtension implements FedTargetExtension { - @Override - public void initializeTargetConfig( - LFGeneratorContext context, - int numOfFederates, FederateInstance federate, - FedFileConfig fileConfig, - ErrorReporter errorReporter, - RtiConfig rtiConfig - ) throws IOException { - - CExtensionUtils.handleCompileDefinitions(federate, numOfFederates, rtiConfig); - - generateCMakeInclude(federate, fileConfig); - - federate.targetConfig.keepalive = true; - federate.targetConfig.setByUser.add(TargetProperty.KEEPALIVE); - - // If there are federates, copy the required files for that. - // Also, create the RTI C file and the launcher script. - // Handle target parameters. - // If the program is federated, then ensure that threading is enabled. - federate.targetConfig.threading = true; - federate.targetConfig.setByUser.add(TargetProperty.THREADING); - - // Include the fed setup file for this federate in the target property - String relPath = getPreamblePath(federate); - federate.targetConfig.fedSetupPreamble = relPath; - federate.targetConfig.setByUser.add(TargetProperty.FED_SETUP); + @Override + public void initializeTargetConfig( + LFGeneratorContext context, + int numOfFederates, + FederateInstance federate, + FedFileConfig fileConfig, + ErrorReporter errorReporter, + RtiConfig rtiConfig) + throws IOException { + + CExtensionUtils.handleCompileDefinitions(federate, numOfFederates, rtiConfig); + + generateCMakeInclude(federate, fileConfig); + + federate.targetConfig.keepalive = true; + federate.targetConfig.setByUser.add(TargetProperty.KEEPALIVE); + + // If there are federates, copy the required files for that. + // Also, create the RTI C file and the launcher script. + // Handle target parameters. + // If the program is federated, then ensure that threading is enabled. + federate.targetConfig.threading = true; + federate.targetConfig.setByUser.add(TargetProperty.THREADING); + + // Include the fed setup file for this federate in the target property + String relPath = getPreamblePath(federate); + federate.targetConfig.fedSetupPreamble = relPath; + federate.targetConfig.setByUser.add(TargetProperty.FED_SETUP); + } + + /** Generate a cmake-include file for {@code federate} if needed. */ + protected void generateCMakeInclude(FederateInstance federate, FedFileConfig fileConfig) + throws IOException { + CExtensionUtils.generateCMakeInclude(federate, fileConfig); + } + + /** + * Generate code for the body of a reaction that handles the action that is triggered by receiving + * a message from a remote federate. + * + * @param action The action. + * @param sendingPort The output port providing the data to send. + * @param receivingPort The ID of the destination port. + * @param connection FIXME + * @param type FIXME + * @param coordinationType The coordination type + * @param errorReporter + */ + public String generateNetworkReceiverBody( + Action action, + VarRef sendingPort, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + CoordinationType coordinationType, + ErrorReporter errorReporter) { + var receiveRef = + CUtil.portRefInReaction(receivingPort, connection.getDstBank(), connection.getDstChannel()); + var result = new CodeBuilder(); + // We currently have no way to mark a reaction "unordered" + // in the AST, so we use a magic string at the start of the body. + result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER); + // Transfer the physical time of arrival from the action to the port + result.pr( + receiveRef + + "->physical_time_of_arrival = self->_lf__" + + action.getName() + + ".physical_time_of_arrival;"); + if (coordinationType == CoordinationType.DECENTRALIZED + && !connection.getDefinition().isPhysical()) { + // Transfer the intended tag. + result.pr( + receiveRef + "->intended_tag = self->_lf__" + action.getName() + ".intended_tag;\n"); } - /** - * Generate a cmake-include file for {@code federate} if needed. - */ - protected void generateCMakeInclude(FederateInstance federate, FedFileConfig fileConfig) throws IOException { - CExtensionUtils.generateCMakeInclude(federate, fileConfig); + deserialize(action, receivingPort, connection, type, receiveRef, result, errorReporter); + return result.toString(); + } + + /** + * Generate code to deserialize a message received over the network. + * + * @param action The network action that is mapped to the {@code receivingPort} + * @param receivingPort The receiving port + * @param connection The connection used to receive the message + * @param type Type for the port + * @param receiveRef A target language reference to the receiving port + * @param result Used to put generated code in + * @param errorReporter Used to report errors, if any + */ + protected void deserialize( + Action action, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + String receiveRef, + CodeBuilder result, + ErrorReporter errorReporter) { + CTypes types = new CTypes(); + // Adjust the type of the action and the receivingPort. + // If it is "string", then change it to "char*". + // This string is dynamically allocated, and type 'string' is to be + // used only for statically allocated strings. This would force the + // CGenerator to treat the port and action as token types. + if (types.getTargetType(action).equals("string")) { + action.getType().setCode(null); + action.getType().setId("char*"); } - - /** - * Generate code for the body of a reaction that handles the - * action that is triggered by receiving a message from a remote - * federate. - * @param action The action. - * @param sendingPort The output port providing the data to send. - * @param receivingPort The ID of the destination port. - * @param connection FIXME - * @param type FIXME - * @param coordinationType The coordination type - * @param errorReporter - */ - public String generateNetworkReceiverBody( - Action action, - VarRef sendingPort, - VarRef receivingPort, - FedConnectionInstance connection, - InferredType type, - CoordinationType coordinationType, - ErrorReporter errorReporter - ) { - var receiveRef = CUtil.portRefInReaction(receivingPort, connection.getDstBank(), connection.getDstChannel()); - var result = new CodeBuilder(); - // We currently have no way to mark a reaction "unordered" - // in the AST, so we use a magic string at the start of the body. - result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER); - // Transfer the physical time of arrival from the action to the port - result.pr(receiveRef+"->physical_time_of_arrival = self->_lf__"+action.getName()+".physical_time_of_arrival;"); - if (coordinationType == CoordinationType.DECENTRALIZED && !connection.getDefinition().isPhysical()) { - // Transfer the intended tag. - result.pr(receiveRef+"->intended_tag = self->_lf__"+action.getName()+".intended_tag;\n"); - } - - deserialize(action, receivingPort, connection, type, receiveRef, result, errorReporter); - return result.toString(); + if (types.getTargetType((Port) receivingPort.getVariable()).equals("string")) { + ((Port) receivingPort.getVariable()).getType().setCode(null); + ((Port) receivingPort.getVariable()).getType().setId("char*"); } - - /** - * Generate code to deserialize a message received over the network. - * @param action The network action that is mapped to the {@code receivingPort} - * @param receivingPort The receiving port - * @param connection The connection used to receive the message - * @param type Type for the port - * @param receiveRef A target language reference to the receiving port - * @param result Used to put generated code in - * @param errorReporter Used to report errors, if any - */ - protected void deserialize( - Action action, - VarRef receivingPort, - FedConnectionInstance connection, - InferredType type, - String receiveRef, - CodeBuilder result, - ErrorReporter errorReporter - ) { - CTypes types = new CTypes(); - // Adjust the type of the action and the receivingPort. - // If it is "string", then change it to "char*". - // This string is dynamically allocated, and type 'string' is to be - // used only for statically allocated strings. This would force the - // CGenerator to treat the port and action as token types. - if (types.getTargetType(action).equals("string")) { - action.getType().setCode(null); - action.getType().setId("char*"); + var value = ""; + switch (connection.getSerializer()) { + case NATIVE: + { + // NOTE: Docs say that malloc'd char* is freed on conclusion of the time step. + // So passing it downstream should be OK. + value = action.getName() + "->value"; + if (CUtil.isTokenType(type, types)) { + result.pr("lf_set_token(" + receiveRef + ", " + action.getName() + "->token);"); + } else { + result.pr("lf_set(" + receiveRef + ", " + value + ");"); + } + break; } - if (types.getTargetType((Port) receivingPort.getVariable()).equals("string")) { - ((Port) receivingPort.getVariable()).getType().setCode(null); - ((Port) receivingPort.getVariable()).getType().setId("char*"); + case PROTO: + { + throw new UnsupportedOperationException("Protobuf serialization is not supported yet."); } - var value = ""; - switch (connection.getSerializer()) { - case NATIVE: { - // NOTE: Docs say that malloc'd char* is freed on conclusion of the time step. - // So passing it downstream should be OK. - value = action.getName()+"->value"; - if (CUtil.isTokenType(type, types)) { - result.pr("lf_set_token("+ receiveRef +", "+ action.getName()+"->token);"); - } else { - result.pr("lf_set("+ receiveRef +", "+value+");"); + case ROS2: + { + var portType = ASTUtils.getInferredType(((Port) receivingPort.getVariable())); + var portTypeStr = types.getTargetType(portType); + if (CUtil.isTokenType(portType, types)) { + throw new UnsupportedOperationException( + "Cannot handle ROS serialization when ports are pointers."); + } else if (CExtensionUtils.isSharedPtrType(portType, types)) { + var matcher = CExtensionUtils.sharedPointerVariable.matcher(portTypeStr); + if (matcher.find()) { + portTypeStr = matcher.group("type"); } - break; - } - case PROTO: { - throw new UnsupportedOperationException("Protobuf serialization is not supported yet."); - } - case ROS2: { - var portType = ASTUtils.getInferredType(((Port) receivingPort.getVariable())); - var portTypeStr = types.getTargetType(portType); - if (CUtil.isTokenType(portType, types)) { - throw new UnsupportedOperationException("Cannot handle ROS serialization when ports are pointers."); - } else if (CExtensionUtils.isSharedPtrType(portType, types)) { - var matcher = CExtensionUtils.sharedPointerVariable.matcher(portTypeStr); - if (matcher.find()) { - portTypeStr = matcher.group("type"); - } - } - var ROSDeserializer = new FedROS2CPPSerialization(); - value = FedROS2CPPSerialization.deserializedVarName; + } + var ROSDeserializer = new FedROS2CPPSerialization(); + value = FedROS2CPPSerialization.deserializedVarName; + result.pr( + ROSDeserializer.generateNetworkDeserializerCode( + "self->_lf__" + action.getName(), portTypeStr)); + if (CExtensionUtils.isSharedPtrType(portType, types)) { result.pr( - ROSDeserializer.generateNetworkDeserializerCode( - "self->_lf__"+ action.getName(), - portTypeStr - ) - ); - if (CExtensionUtils.isSharedPtrType(portType, types)) { - result.pr("auto msg_shared_ptr = std::make_shared<"+portTypeStr+">("+value+");"); - result.pr("lf_set("+ receiveRef +", msg_shared_ptr);"); - } else { - result.pr("lf_set("+ receiveRef +", std::move("+value+"));"); - } - break; - } + "auto msg_shared_ptr = std::make_shared<" + portTypeStr + ">(" + value + ");"); + result.pr("lf_set(" + receiveRef + ", msg_shared_ptr);"); + } else { + result.pr("lf_set(" + receiveRef + ", std::move(" + value + "));"); + } + break; } } + } + + /** + * Generate code for the body of a reaction that handles an output that is to be sent over the + * network. + * + * @param sendingPort The output port providing the data to send. + * @param receivingPort The variable reference to the destination port. + * @param connection + * @param type + * @param coordinationType + * @param errorReporter FIXME + */ + public String generateNetworkSenderBody( + VarRef sendingPort, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + CoordinationType coordinationType, + ErrorReporter errorReporter) { + var sendRef = + CUtil.portRefInReaction(sendingPort, connection.getSrcBank(), connection.getSrcChannel()); + var receiveRef = + ASTUtils.generateVarRef( + receivingPort); // Used for comments only, so no need for bank/multiport index. + var result = new CodeBuilder(); + // The ID of the receiving port (rightPort) is the position + // of the action in this list. + int receivingPortID = connection.getDstFederate().networkMessageActions.size(); + + // We currently have no way to mark a reaction "unordered" + // in the AST, so we use a magic string at the start of the body. + result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); + + result.pr( + "// Sending from " + + sendRef + + " in federate " + + connection.getSrcFederate().name + + " to " + + receiveRef + + " in federate " + + connection.getDstFederate().name); + + // In case sendRef is a multiport or is in a bank, this reaction will be triggered when any + // channel or bank index of sendRef is present + // ex. if a.out[i] is present, the entire output a.out is triggered. + if (connection.getSrcBank() != -1 || connection.getSrcChannel() != -1) { + result.pr("if (!" + sendRef + "->is_present) return;"); + } - /** - * Generate code for the body of a reaction that handles an output - * that is to be sent over the network. - * @param sendingPort The output port providing the data to send. - * @param receivingPort The variable reference to the destination port. - * @param connection - * @param type - * @param coordinationType - * @param errorReporter FIXME - */ - public String generateNetworkSenderBody( - VarRef sendingPort, - VarRef receivingPort, - FedConnectionInstance connection, - InferredType type, - CoordinationType coordinationType, - ErrorReporter errorReporter - ) { - var sendRef = CUtil.portRefInReaction(sendingPort, connection.getSrcBank(), connection.getSrcChannel()); - var receiveRef = ASTUtils.generateVarRef(receivingPort); // Used for comments only, so no need for bank/multiport index. - var result = new CodeBuilder(); - // The ID of the receiving port (rightPort) is the position - // of the action in this list. - int receivingPortID = connection.getDstFederate().networkMessageActions.size(); - - // We currently have no way to mark a reaction "unordered" - // in the AST, so we use a magic string at the start of the body. - result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); - - result.pr("// Sending from " + sendRef + " in federate " - + connection.getSrcFederate().name + " to " + receiveRef - + " in federate " + connection.getDstFederate().name); - - // In case sendRef is a multiport or is in a bank, this reaction will be triggered when any channel or bank index of sendRef is present - // ex. if a.out[i] is present, the entire output a.out is triggered. - if (connection.getSrcBank() != -1 || connection.getSrcChannel() != -1) { - result.pr("if (!"+sendRef+"->is_present) return;"); - } - - // If the connection is physical and the receiving federate is remote, send it directly on a socket. - // If the connection is logical and the coordination mode is centralized, send via RTI. - // If the connection is logical and the coordination mode is decentralized, send directly - String messageType; - // Name of the next immediate destination of this message - var next_destination_name = "\"federate "+connection.getDstFederate().id+"\""; - - // Get the delay literal - String additionalDelayString = CExtensionUtils.getNetworkDelayLiteral(connection.getDefinition().getDelay()); - - if (connection.getDefinition().isPhysical()) { - messageType = "MSG_TYPE_P2P_MESSAGE"; - } else if (coordinationType == CoordinationType.DECENTRALIZED) { - messageType = "MSG_TYPE_P2P_TAGGED_MESSAGE"; - } else { - // Logical connection - // Send the message via rti - messageType = "MSG_TYPE_TAGGED_MESSAGE"; - next_destination_name = "\"federate "+connection.getDstFederate().id+" via the RTI\""; - } - - - String sendingFunction = "send_timed_message"; - String commonArgs = String.join(", ", - additionalDelayString, - messageType, - receivingPortID + "", - connection.getDstFederate().id + "", - next_destination_name, - "message_length" - ); - if (connection.getDefinition().isPhysical()) { - // Messages going on a physical connection do not - // carry a timestamp or require the delay; - sendingFunction = "send_message"; - commonArgs = messageType+", "+receivingPortID+", "+connection.getDstFederate().id+", "+next_destination_name+", message_length"; - } + // If the connection is physical and the receiving federate is remote, send it directly on a + // socket. + // If the connection is logical and the coordination mode is centralized, send via RTI. + // If the connection is logical and the coordination mode is decentralized, send directly + String messageType; + // Name of the next immediate destination of this message + var next_destination_name = "\"federate " + connection.getDstFederate().id + "\""; + + // Get the delay literal + String additionalDelayString = + CExtensionUtils.getNetworkDelayLiteral(connection.getDefinition().getDelay()); + + if (connection.getDefinition().isPhysical()) { + messageType = "MSG_TYPE_P2P_MESSAGE"; + } else if (coordinationType == CoordinationType.DECENTRALIZED) { + messageType = "MSG_TYPE_P2P_TAGGED_MESSAGE"; + } else { + // Logical connection + // Send the message via rti + messageType = "MSG_TYPE_TAGGED_MESSAGE"; + next_destination_name = "\"federate " + connection.getDstFederate().id + " via the RTI\""; + } - serializeAndSend( - connection, - type, - sendRef, - result, - sendingFunction, - commonArgs, - errorReporter - ); - return result.toString(); + String sendingFunction = "send_timed_message"; + String commonArgs = + String.join( + ", ", + additionalDelayString, + messageType, + receivingPortID + "", + connection.getDstFederate().id + "", + next_destination_name, + "message_length"); + if (connection.getDefinition().isPhysical()) { + // Messages going on a physical connection do not + // carry a timestamp or require the delay; + sendingFunction = "send_message"; + commonArgs = + messageType + + ", " + + receivingPortID + + ", " + + connection.getDstFederate().id + + ", " + + next_destination_name + + ", message_length"; } - /** - * FIXME - * @param connection - * @param type - * @param sendRef - * @param result - * @param sendingFunction - * @param commonArgs - * @param errorReporter - */ - protected void serializeAndSend( - FedConnectionInstance connection, - InferredType type, - String sendRef, - CodeBuilder result, - String sendingFunction, - String commonArgs, - ErrorReporter errorReporter - ) { - CTypes types = new CTypes(); - var lengthExpression = ""; - var pointerExpression = ""; - switch (connection.getSerializer()) { - case NATIVE: { - // Handle native types. - if (CUtil.isTokenType(type, types)) { - // NOTE: Transporting token types this way is likely to only work if the sender and receiver - // both have the same endianness. Otherwise, you have to use protobufs or some other serialization scheme. - result.pr("size_t message_length = "+ sendRef +"->token->length * "+ sendRef - +"->token->type->element_size;"); - result.pr(sendingFunction +"("+ commonArgs +", (unsigned char*) "+ sendRef - +"->value);"); - } else { - // string types need to be dealt with specially because they are hidden pointers. - // void type is odd, but it avoids generating non-standard expression sizeof(void), - // which some compilers reject. - lengthExpression = "sizeof("+ types.getTargetType(type)+")"; - pointerExpression = "(unsigned char*)&"+ sendRef +"->value"; - var targetType = types.getTargetType(type); - if (targetType.equals("string")) { - lengthExpression = "strlen("+ sendRef +"->value) + 1"; - pointerExpression = "(unsigned char*) "+ sendRef +"->value"; - } else if (targetType.equals("void")) { - lengthExpression = "0"; - } - result.pr("size_t message_length = "+lengthExpression+";"); - result.pr( - sendingFunction +"("+ commonArgs +", "+pointerExpression+");"); + serializeAndSend(connection, type, sendRef, result, sendingFunction, commonArgs, errorReporter); + return result.toString(); + } + + /** + * FIXME + * + * @param connection + * @param type + * @param sendRef + * @param result + * @param sendingFunction + * @param commonArgs + * @param errorReporter + */ + protected void serializeAndSend( + FedConnectionInstance connection, + InferredType type, + String sendRef, + CodeBuilder result, + String sendingFunction, + String commonArgs, + ErrorReporter errorReporter) { + CTypes types = new CTypes(); + var lengthExpression = ""; + var pointerExpression = ""; + switch (connection.getSerializer()) { + case NATIVE: + { + // Handle native types. + if (CUtil.isTokenType(type, types)) { + // NOTE: Transporting token types this way is likely to only work if the sender and + // receiver + // both have the same endianness. Otherwise, you have to use protobufs or some other + // serialization scheme. + result.pr( + "size_t message_length = " + + sendRef + + "->token->length * " + + sendRef + + "->token->type->element_size;"); + result.pr( + sendingFunction + "(" + commonArgs + ", (unsigned char*) " + sendRef + "->value);"); + } else { + // string types need to be dealt with specially because they are hidden pointers. + // void type is odd, but it avoids generating non-standard expression sizeof(void), + // which some compilers reject. + lengthExpression = "sizeof(" + types.getTargetType(type) + ")"; + pointerExpression = "(unsigned char*)&" + sendRef + "->value"; + var targetType = types.getTargetType(type); + if (targetType.equals("string")) { + lengthExpression = "strlen(" + sendRef + "->value) + 1"; + pointerExpression = "(unsigned char*) " + sendRef + "->value"; + } else if (targetType.equals("void")) { + lengthExpression = "0"; } - break; + result.pr("size_t message_length = " + lengthExpression + ";"); + result.pr(sendingFunction + "(" + commonArgs + ", " + pointerExpression + ");"); + } + break; } - case PROTO: { - throw new UnsupportedOperationException("Protobuf serialization is not supported yet."); + case PROTO: + { + throw new UnsupportedOperationException("Protobuf serialization is not supported yet."); } - case ROS2: { - var variableToSerialize = sendRef; - var typeStr = types.getTargetType(type); - if (CUtil.isTokenType(type, types)) { - throw new UnsupportedOperationException("Cannot handle ROS serialization when ports are pointers."); - } else if (CExtensionUtils.isSharedPtrType(type, types)) { - var matcher = CExtensionUtils.sharedPointerVariable.matcher(typeStr); - if (matcher.find()) { - typeStr = matcher.group("type"); - } + case ROS2: + { + var variableToSerialize = sendRef; + var typeStr = types.getTargetType(type); + if (CUtil.isTokenType(type, types)) { + throw new UnsupportedOperationException( + "Cannot handle ROS serialization when ports are pointers."); + } else if (CExtensionUtils.isSharedPtrType(type, types)) { + var matcher = CExtensionUtils.sharedPointerVariable.matcher(typeStr); + if (matcher.find()) { + typeStr = matcher.group("type"); } - var ROSSerializer = new FedROS2CPPSerialization(); - lengthExpression = ROSSerializer.serializedBufferLength(); - pointerExpression = ROSSerializer.seializedBufferVar(); - result.pr( - ROSSerializer.generateNetworkSerializerCode(variableToSerialize, typeStr, CExtensionUtils.isSharedPtrType(type, types)) - ); - result.pr("size_t message_length = "+lengthExpression+";"); - result.pr(sendingFunction +"("+ commonArgs +", "+pointerExpression+");"); - break; - } - + } + var ROSSerializer = new FedROS2CPPSerialization(); + lengthExpression = ROSSerializer.serializedBufferLength(); + pointerExpression = ROSSerializer.seializedBufferVar(); + result.pr( + ROSSerializer.generateNetworkSerializerCode( + variableToSerialize, typeStr, CExtensionUtils.isSharedPtrType(type, types))); + result.pr("size_t message_length = " + lengthExpression + ";"); + result.pr(sendingFunction + "(" + commonArgs + ", " + pointerExpression + ");"); + break; } } - - /** - * Generate code for the body of a reaction that decides whether the trigger for the given - * port is going to be present or absent for the current logical time. - * This reaction is put just before the first reaction that is triggered by the network - * input port "port" or has it in its sources. If there are only connections to contained - * reactors, in the top-level reactor. - * - * @param receivingPortID The port to generate the control reaction for - * @param maxSTP The maximum value of STP is assigned to reactions (if any) - * that have port as their trigger or source - */ - public String generateNetworkInputControlReactionBody( - int receivingPortID, - TimeValue maxSTP, - CoordinationType coordination - ) { - // Store the code - var result = new CodeBuilder(); - - // We currently have no way to mark a reaction "unordered" - // in the AST, so we use a magic string at the start of the body. - result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); - result.pr("interval_t max_STP = 0LL;"); - - // Find the maximum STP for decentralized coordination - if(coordination == CoordinationType.DECENTRALIZED) { - result.pr("max_STP = "+ CTypes.getInstance().getTargetTimeExpr(maxSTP) +";"); - } - result.pr("// Wait until the port status is known"); - result.pr("wait_until_port_status_known("+receivingPortID+", max_STP);"); - return result.toString(); - } - - /** - * Generate code for the body of a reaction that sends a port status message for the given - * port if it is absent. - * - * @oaram srcOutputPort FIXME - * @param connection FIXME - */ - public String generateNetworkOutputControlReactionBody( - VarRef srcOutputPort, - FedConnectionInstance connection - ) { - // Store the code - var result = new CodeBuilder(); - // The ID of the receiving port (rightPort) is the position - // of the networkAction (see below) in this list. - int receivingPortID = connection.getDstFederate().networkMessageActions.size(); - - // We currently have no way to mark a reaction "unordered" - // in the AST, so we use a magic string at the start of the body. - result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); - var sendRef = CUtil.portRefInReaction(srcOutputPort, connection.getSrcBank(), connection.getSrcChannel()); - // Get the delay literal - var additionalDelayString = CExtensionUtils.getNetworkDelayLiteral(connection.getDefinition().getDelay()); - result.pr(String.join("\n", - "// If the output port has not been lf_set for the current logical time,", - "// send an ABSENT message to the receiving federate ", - "LF_PRINT_LOG(\"Contemplating whether to send port \"", - " \"absent for port %d to federate %d.\", ", - " "+receivingPortID+", "+connection.getDstFederate().id+");", - "if ("+sendRef+" == NULL || !"+sendRef+"->is_present) {", - " // The output port is NULL or it is not present.", - " send_port_absent_to_federate("+additionalDelayString+", "+receivingPortID+", "+connection.getDstFederate().id+");", - "}" - )); - return result.toString(); + } + + /** + * Generate code for the body of a reaction that decides whether the trigger for the given port is + * going to be present or absent for the current logical time. This reaction is put just before + * the first reaction that is triggered by the network input port "port" or has it in its sources. + * If there are only connections to contained reactors, in the top-level reactor. + * + * @param receivingPortID The port to generate the control reaction for + * @param maxSTP The maximum value of STP is assigned to reactions (if any) that have port as + * their trigger or source + */ + public String generateNetworkInputControlReactionBody( + int receivingPortID, TimeValue maxSTP, CoordinationType coordination) { + // Store the code + var result = new CodeBuilder(); + + // We currently have no way to mark a reaction "unordered" + // in the AST, so we use a magic string at the start of the body. + result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); + result.pr("interval_t max_STP = 0LL;"); + + // Find the maximum STP for decentralized coordination + if (coordination == CoordinationType.DECENTRALIZED) { + result.pr("max_STP = " + CTypes.getInstance().getTargetTimeExpr(maxSTP) + ";"); } - - - public String getNetworkBufferType() { - return "uint8_t*"; + result.pr("// Wait until the port status is known"); + result.pr("wait_until_port_status_known(" + receivingPortID + ", max_STP);"); + return result.toString(); + } + + /** + * Generate code for the body of a reaction that sends a port status message for the given port if + * it is absent. + * + * @oaram srcOutputPort FIXME + * @param connection FIXME + */ + public String generateNetworkOutputControlReactionBody( + VarRef srcOutputPort, FedConnectionInstance connection) { + // Store the code + var result = new CodeBuilder(); + // The ID of the receiving port (rightPort) is the position + // of the networkAction (see below) in this list. + int receivingPortID = connection.getDstFederate().networkMessageActions.size(); + + // We currently have no way to mark a reaction "unordered" + // in the AST, so we use a magic string at the start of the body. + result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); + var sendRef = + CUtil.portRefInReaction(srcOutputPort, connection.getSrcBank(), connection.getSrcChannel()); + // Get the delay literal + var additionalDelayString = + CExtensionUtils.getNetworkDelayLiteral(connection.getDefinition().getDelay()); + result.pr( + String.join( + "\n", + "// If the output port has not been lf_set for the current logical time,", + "// send an ABSENT message to the receiving federate ", + "LF_PRINT_LOG(\"Contemplating whether to send port \"", + " \"absent for port %d to federate %d.\", ", + " " + receivingPortID + ", " + connection.getDstFederate().id + ");", + "if (" + sendRef + " == NULL || !" + sendRef + "->is_present) {", + " // The output port is NULL or it is not present.", + " send_port_absent_to_federate(" + + additionalDelayString + + ", " + + receivingPortID + + ", " + + connection.getDstFederate().id + + ");", + "}")); + return result.toString(); + } + + public String getNetworkBufferType() { + return "uint8_t*"; + } + + /** + * Add preamble to a separate file to set up federated execution. Return an empty string since no + * code generated needs to go in the source. + */ + @Override + public String generatePreamble( + FederateInstance federate, + FedFileConfig fileConfig, + RtiConfig rtiConfig, + ErrorReporter errorReporter) + throws IOException { + // Put the C preamble in a {@code include/_federate.name + _preamble.h} file + String cPreamble = makePreamble(federate, fileConfig, rtiConfig, errorReporter); + String relPath = getPreamblePath(federate); + Path fedPreamblePath = fileConfig.getSrcPath().resolve(relPath); + Files.createDirectories(fedPreamblePath.getParent()); + try (var writer = Files.newBufferedWriter(fedPreamblePath)) { + writer.write(cPreamble); } - - /** - * Add preamble to a separate file to set up federated execution. - * Return an empty string since no code generated needs to go in the source. - */ - @Override - public String generatePreamble( - FederateInstance federate, - FedFileConfig fileConfig, - RtiConfig rtiConfig, - ErrorReporter errorReporter - ) throws IOException { - // Put the C preamble in a {@code include/_federate.name + _preamble.h} file - String cPreamble = makePreamble(federate, fileConfig, rtiConfig, errorReporter); - String relPath = getPreamblePath(federate); - Path fedPreamblePath = fileConfig.getSrcPath().resolve(relPath); - Files.createDirectories(fedPreamblePath.getParent()); - try (var writer = Files.newBufferedWriter(fedPreamblePath)) { - writer.write(cPreamble); - } - var includes = new CodeBuilder(); - if (federate.targetConfig.target != Target.Python) { - includes.pr("#ifdef __cplusplus\n" - + "extern \"C\" {\n" - + "#endif"); - includes.pr("#include \"core/federated/federate.h\""); - includes.pr("#include \"core/federated/net_common.h\""); - includes.pr("#include \"core/federated/net_util.h\""); - includes.pr("#include \"core/federated/clock-sync.h\""); - includes.pr("#include \"core/threaded/reactor_threaded.h\""); - includes.pr("#include \"core/utils/util.h\""); - includes.pr("extern federate_instance_t _fed;"); - includes.pr("#ifdef __cplusplus\n" - + "}\n" - + "#endif"); - includes.pr(generateSerializationIncludes(federate, fileConfig)); - } - - return includes.toString(); + var includes = new CodeBuilder(); + if (federate.targetConfig.target != Target.Python) { + includes.pr("#ifdef __cplusplus\n" + "extern \"C\" {\n" + "#endif"); + includes.pr("#include \"core/federated/federate.h\""); + includes.pr("#include \"core/federated/net_common.h\""); + includes.pr("#include \"core/federated/net_util.h\""); + includes.pr("#include \"core/federated/clock-sync.h\""); + includes.pr("#include \"core/threaded/reactor_threaded.h\""); + includes.pr("#include \"core/utils/util.h\""); + includes.pr("extern federate_instance_t _fed;"); + includes.pr("#ifdef __cplusplus\n" + "}\n" + "#endif"); + includes.pr(generateSerializationIncludes(federate, fileConfig)); } - /** - * Generate the preamble to setup federated execution in C. - */ - protected String makePreamble( - FederateInstance federate, - FedFileConfig fileConfig, - RtiConfig rtiConfig, - ErrorReporter errorReporter) { - - var code = new CodeBuilder(); - - code.pr("#include \"core/federated/federate.h\""); - code.pr("#include \"core/federated/net_common.h\""); - code.pr("#include \"core/federated/net_util.h\""); - code.pr("#include \"core/threaded/reactor_threaded.h\""); - code.pr("#include \"core/utils/util.h\""); - code.pr("extern federate_instance_t _fed;"); - - // Generate function to return a pointer to the action trigger_t - // that handles incoming network messages destined to the specified - // port. This will only be used if there are federates. - int numOfNetworkActions = federate.networkMessageActions.size(); - code.pr(""" + return includes.toString(); + } + + /** Generate the preamble to setup federated execution in C. */ + protected String makePreamble( + FederateInstance federate, + FedFileConfig fileConfig, + RtiConfig rtiConfig, + ErrorReporter errorReporter) { + + var code = new CodeBuilder(); + + code.pr("#include \"core/federated/federate.h\""); + code.pr("#include \"core/federated/net_common.h\""); + code.pr("#include \"core/federated/net_util.h\""); + code.pr("#include \"core/threaded/reactor_threaded.h\""); + code.pr("#include \"core/utils/util.h\""); + code.pr("extern federate_instance_t _fed;"); + + // Generate function to return a pointer to the action trigger_t + // that handles incoming network messages destined to the specified + // port. This will only be used if there are federates. + int numOfNetworkActions = federate.networkMessageActions.size(); + code.pr( + """ lf_action_base_t* _lf_action_table[%1$s]; size_t _lf_action_table_size = %1$s; - """.formatted(numOfNetworkActions)); - - code.pr(generateExecutablePreamble(federate, rtiConfig, errorReporter)); - - code.pr(generateInitializeTriggers(federate, errorReporter)); - - code.pr(CExtensionUtils.generateFederateNeighborStructure(federate)); - - return code.getCode(); - } - - /** - * Generate preamble code needed for enabled serializers of the federate. - */ - protected String generateSerializationIncludes(FederateInstance federate, FedFileConfig fileConfig) { - return CExtensionUtils.generateSerializationIncludes(federate, fileConfig); - } - - /** - * Create a function that initializes necessary triggers for federated execution, - * which are the triggers for control reactions and references to all network - * actions (which are triggered upon receiving network messages). - * - * @param federate The federate to initialize triggers for. - * @param errorReporter Used to report errors. - * @return The generated code for the macro. - */ - private String generateInitializeTriggers(FederateInstance federate, ErrorReporter errorReporter) { - CodeBuilder code = new CodeBuilder(); - // Temporarily change the original federate reactor's name in the AST to - // the federate's name so that trigger references are accurate. - var federatedReactor = FedASTUtils.findFederatedReactor(federate.instantiation.eResource()); - var oldFederatedReactorName = federatedReactor.getName(); - federatedReactor.setName(federate.name); - var main = new ReactorInstance(federatedReactor, errorReporter, 1); - code.pr(CExtensionUtils.initializeTriggersForNetworkActions(federate, main)); - code.pr(CExtensionUtils.initializeTriggerForControlReactions(main, main, federate)); - federatedReactor.setName(oldFederatedReactorName); - - return """ + """ + .formatted(numOfNetworkActions)); + + code.pr(generateExecutablePreamble(federate, rtiConfig, errorReporter)); + + code.pr(generateInitializeTriggers(federate, errorReporter)); + + code.pr(CExtensionUtils.generateFederateNeighborStructure(federate)); + + return code.getCode(); + } + + /** Generate preamble code needed for enabled serializers of the federate. */ + protected String generateSerializationIncludes( + FederateInstance federate, FedFileConfig fileConfig) { + return CExtensionUtils.generateSerializationIncludes(federate, fileConfig); + } + + /** + * Create a function that initializes necessary triggers for federated execution, which are the + * triggers for control reactions and references to all network actions (which are triggered upon + * receiving network messages). + * + * @param federate The federate to initialize triggers for. + * @param errorReporter Used to report errors. + * @return The generated code for the macro. + */ + private String generateInitializeTriggers( + FederateInstance federate, ErrorReporter errorReporter) { + CodeBuilder code = new CodeBuilder(); + // Temporarily change the original federate reactor's name in the AST to + // the federate's name so that trigger references are accurate. + var federatedReactor = FedASTUtils.findFederatedReactor(federate.instantiation.eResource()); + var oldFederatedReactorName = federatedReactor.getName(); + federatedReactor.setName(federate.name); + var main = new ReactorInstance(federatedReactor, errorReporter, 1); + code.pr(CExtensionUtils.initializeTriggersForNetworkActions(federate, main)); + code.pr(CExtensionUtils.initializeTriggerForControlReactions(main, main, federate)); + federatedReactor.setName(oldFederatedReactorName); + + return """ #define initialize_triggers_for_federate() \\ do { \\ %s } \\ while (0) - """.formatted((code.getCode().isBlank() ? "\\" : code.getCode()).indent(4).stripTrailing()); - } + """ + .formatted((code.getCode().isBlank() ? "\\" : code.getCode()).indent(4).stripTrailing()); + } - /** - * Generate code for an executed preamble. - * - */ - private String generateExecutablePreamble(FederateInstance federate, RtiConfig rtiConfig, ErrorReporter errorReporter) { - CodeBuilder code = new CodeBuilder(); + /** Generate code for an executed preamble. */ + private String generateExecutablePreamble( + FederateInstance federate, RtiConfig rtiConfig, ErrorReporter errorReporter) { + CodeBuilder code = new CodeBuilder(); - code.pr(generateCodeForPhysicalActions(federate, errorReporter)); + code.pr(generateCodeForPhysicalActions(federate, errorReporter)); - code.pr(generateCodeToInitializeFederate(federate, rtiConfig)); + code.pr(generateCodeToInitializeFederate(federate, rtiConfig)); - code.pr(CExtensionUtils.allocateTriggersForFederate(federate)); + code.pr(CExtensionUtils.allocateTriggersForFederate(federate)); - return """ + return """ void _lf_executable_preamble() { %s } - """.formatted(code.toString().indent(4).stripTrailing()); + """ + .formatted(code.toString().indent(4).stripTrailing()); + } + + /** + * Generate code to initialize the {@code federate}. + * + * @param rtiConfig + * @return The generated code + */ + private String generateCodeToInitializeFederate(FederateInstance federate, RtiConfig rtiConfig) { + CodeBuilder code = new CodeBuilder(); + code.pr("// ***** Start initializing the federated execution. */"); + code.pr( + String.join( + "\n", + "// Initialize the socket mutex", + "lf_mutex_init(&outbound_socket_mutex);", + "lf_cond_init(&port_status_changed, &mutex);")); + + // Find the STA (A.K.A. the global STP offset) for this federate. + if (federate.targetConfig.coordination == CoordinationType.DECENTRALIZED) { + var reactor = ASTUtils.toDefinition(federate.instantiation.getReactorClass()); + var stpParam = + reactor.getParameters().stream() + .filter( + param -> + param.getName().equalsIgnoreCase("STP_offset") + && (param.getType() == null || param.getType().isTime())) + .findFirst(); + + if (stpParam.isPresent()) { + var globalSTP = + ASTUtils.initialValue(stpParam.get(), List.of(federate.instantiation)).get(0); + var globalSTPTV = ASTUtils.getLiteralTimeValue(globalSTP); + code.pr("lf_set_stp_offset(" + CTypes.getInstance().getTargetTimeExpr(globalSTPTV) + ");"); + } } - /** - * Generate code to initialize the {@code federate}. - * @param rtiConfig - * @return The generated code - */ - private String generateCodeToInitializeFederate(FederateInstance federate, RtiConfig rtiConfig) { - CodeBuilder code = new CodeBuilder(); - code.pr("// ***** Start initializing the federated execution. */"); - code.pr(String.join("\n", - "// Initialize the socket mutex", - "lf_mutex_init(&outbound_socket_mutex);", - "lf_cond_init(&port_status_changed, &mutex);" - )); - - // Find the STA (A.K.A. the global STP offset) for this federate. - if (federate.targetConfig.coordination == CoordinationType.DECENTRALIZED) { - var reactor = ASTUtils.toDefinition(federate.instantiation.getReactorClass()); - var stpParam = reactor.getParameters().stream().filter( - param -> - param.getName().equalsIgnoreCase("STP_offset") - && (param.getType() == null || param.getType().isTime()) - ).findFirst(); - - if (stpParam.isPresent()) { - var globalSTP = ASTUtils.initialValue(stpParam.get(), List.of(federate.instantiation)).get(0); - var globalSTPTV = ASTUtils.getLiteralTimeValue(globalSTP); - code.pr("lf_set_stp_offset("+ CTypes.getInstance().getTargetTimeExpr(globalSTPTV) +");"); - } - } - - // Set indicator variables that specify whether the federate has - // upstream logical connections. - if (federate.dependsOn.size() > 0) { - code.pr("_fed.has_upstream = true;"); - } - if (federate.sendsTo.size() > 0) { - code.pr("_fed.has_downstream = true;"); - } - // Set global variable identifying the federate. - code.pr("_lf_my_fed_id = "+ federate.id+";"); - - // We keep separate record for incoming and outgoing p2p connections to allow incoming traffic to be processed in a separate - // thread without requiring a mutex lock. - var numberOfInboundConnections = federate.inboundP2PConnections.size(); - var numberOfOutboundConnections = federate.outboundP2PConnections.size(); - - code.pr(String.join("\n", - "_fed.number_of_inbound_p2p_connections = "+numberOfInboundConnections+";", - "_fed.number_of_outbound_p2p_connections = "+numberOfOutboundConnections+";" - )); - if (numberOfInboundConnections > 0) { - code.pr(String.join("\n", - "// Initialize the array of socket for incoming connections to -1.", - "for (int i = 0; i < NUMBER_OF_FEDERATES; i++) {", - " _fed.sockets_for_inbound_p2p_connections[i] = -1;", - "}" - )); - } - if (numberOfOutboundConnections > 0) { - code.pr(String.join("\n", - "// Initialize the array of socket for outgoing connections to -1.", - "for (int i = 0; i < NUMBER_OF_FEDERATES; i++) {", - " _fed.sockets_for_outbound_p2p_connections[i] = -1;", - "}" - )); - } + // Set indicator variables that specify whether the federate has + // upstream logical connections. + if (federate.dependsOn.size() > 0) { + code.pr("_fed.has_upstream = true;"); + } + if (federate.sendsTo.size() > 0) { + code.pr("_fed.has_downstream = true;"); + } + // Set global variable identifying the federate. + code.pr("_lf_my_fed_id = " + federate.id + ";"); + + // We keep separate record for incoming and outgoing p2p connections to allow incoming traffic + // to be processed in a separate + // thread without requiring a mutex lock. + var numberOfInboundConnections = federate.inboundP2PConnections.size(); + var numberOfOutboundConnections = federate.outboundP2PConnections.size(); + + code.pr( + String.join( + "\n", + "_fed.number_of_inbound_p2p_connections = " + numberOfInboundConnections + ";", + "_fed.number_of_outbound_p2p_connections = " + numberOfOutboundConnections + ";")); + if (numberOfInboundConnections > 0) { + code.pr( + String.join( + "\n", + "// Initialize the array of socket for incoming connections to -1.", + "for (int i = 0; i < NUMBER_OF_FEDERATES; i++) {", + " _fed.sockets_for_inbound_p2p_connections[i] = -1;", + "}")); + } + if (numberOfOutboundConnections > 0) { + code.pr( + String.join( + "\n", + "// Initialize the array of socket for outgoing connections to -1.", + "for (int i = 0; i < NUMBER_OF_FEDERATES; i++) {", + " _fed.sockets_for_outbound_p2p_connections[i] = -1;", + "}")); + } - // If a test clock offset has been specified, insert code to set it here. - if (federate.targetConfig.clockSyncOptions.testOffset != null) { - code.pr("lf_set_physical_clock_offset((1 + "+ federate.id+") * "+ federate.targetConfig.clockSyncOptions.testOffset.toNanoSeconds()+"LL);"); - } + // If a test clock offset has been specified, insert code to set it here. + if (federate.targetConfig.clockSyncOptions.testOffset != null) { + code.pr( + "lf_set_physical_clock_offset((1 + " + + federate.id + + ") * " + + federate.targetConfig.clockSyncOptions.testOffset.toNanoSeconds() + + "LL);"); + } - code.pr(String.join("\n", - "// Connect to the RTI. This sets _fed.socket_TCP_RTI and _lf_rti_socket_UDP.", - "connect_to_rti("+addDoubleQuotes(rtiConfig.getHost())+", "+ rtiConfig.getPort()+");" - )); + code.pr( + String.join( + "\n", + "// Connect to the RTI. This sets _fed.socket_TCP_RTI and _lf_rti_socket_UDP.", + "connect_to_rti(" + + addDoubleQuotes(rtiConfig.getHost()) + + ", " + + rtiConfig.getPort() + + ");")); + + // Disable clock synchronization for the federate if it resides on the same host as the RTI, + // unless that is overridden with the clock-sync-options target property. + if (CExtensionUtils.clockSyncIsOn(federate, rtiConfig)) { + code.pr("synchronize_initial_physical_clock_with_rti(_fed.socket_TCP_RTI);"); + } - // Disable clock synchronization for the federate if it resides on the same host as the RTI, - // unless that is overridden with the clock-sync-options target property. - if (CExtensionUtils.clockSyncIsOn(federate, rtiConfig)) { - code.pr("synchronize_initial_physical_clock_with_rti(_fed.socket_TCP_RTI);"); - } + if (numberOfInboundConnections > 0) { + code.pr( + String.join( + "\n", + "// Create a socket server to listen to other federates.", + "// If a port is specified by the user, that will be used", + "// as the only possibility for the server. If not, the port", + "// will start from STARTING_PORT. The function will", + "// keep incrementing the port until the number of tries reaches PORT_RANGE_LIMIT.", + "create_server(" + federate.port + ");", + "// Connect to remote federates for each physical connection.", + "// This is done in a separate thread because this thread will call", + "// connect_to_federate for each outbound physical connection at the same", + "// time that the new thread is listening for such connections for inbound", + "// physical connections. The thread will live until all connections", + "// have been established.", + "lf_thread_create(&_fed.inbound_p2p_handling_thread_id," + + " handle_p2p_connections_from_federates, NULL);")); + } - if (numberOfInboundConnections > 0) { - code.pr(String.join("\n", - "// Create a socket server to listen to other federates.", - "// If a port is specified by the user, that will be used", - "// as the only possibility for the server. If not, the port", - "// will start from STARTING_PORT. The function will", - "// keep incrementing the port until the number of tries reaches PORT_RANGE_LIMIT.", - "create_server("+ federate.port+");", - "// Connect to remote federates for each physical connection.", - "// This is done in a separate thread because this thread will call", - "// connect_to_federate for each outbound physical connection at the same", - "// time that the new thread is listening for such connections for inbound", - "// physical connections. The thread will live until all connections", - "// have been established.", - "lf_thread_create(&_fed.inbound_p2p_handling_thread_id, handle_p2p_connections_from_federates, NULL);" - )); + for (FederateInstance remoteFederate : federate.outboundP2PConnections) { + code.pr("connect_to_federate(" + remoteFederate.id + ");"); + } + return code.getCode(); + } + + /** + * Generate code to handle physical actions in the {@code federate}. + * + * @param errorReporter Used to report errors. + * @return Generated code. + */ + private String generateCodeForPhysicalActions( + FederateInstance federate, ErrorReporter errorReporter) { + CodeBuilder code = new CodeBuilder(); + if (federate.targetConfig.coordination.equals(CoordinationType.CENTRALIZED)) { + // If this program uses centralized coordination then check + // for outputs that depend on physical actions so that null messages can be + // sent to the RTI. + var federateClass = ASTUtils.toDefinition(federate.instantiation.getReactorClass()); + var main = + new ReactorInstance( + FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), + errorReporter, + 1); + var instance = new ReactorInstance(federateClass, main, errorReporter); + var outputDelayMap = federate.findOutputsConnectedToPhysicalActions(instance); + var minDelay = TimeValue.MAX_VALUE; + Output outputFound = null; + for (Output output : outputDelayMap.keySet()) { + var outputDelay = outputDelayMap.get(output); + if (outputDelay.isEarlierThan(minDelay)) { + minDelay = outputDelay; + outputFound = output; } - - for (FederateInstance remoteFederate : federate.outboundP2PConnections) { - code.pr("connect_to_federate("+remoteFederate.id+");"); + } + if (minDelay != TimeValue.MAX_VALUE) { + // Unless silenced, issue a warning. + if (federate.targetConfig.coordinationOptions.advance_message_interval == null) { + errorReporter.reportWarning( + outputFound, + String.join( + "\n", + "Found a path from a physical action to output for reactor " + + addDoubleQuotes(instance.getName()) + + ". ", + "The amount of delay is " + minDelay + ".", + "With centralized coordination, this can result in a large number of messages to" + + " the RTI.", + "Consider refactoring the code so that the output does not depend on the physical" + + " action,", + "or consider using decentralized coordination. To silence this warning, set the" + + " target", + "parameter coordination-options with a value like {advance-message-interval: 10" + + " msec}")); } - return code.getCode(); + code.pr( + "_fed.min_delay_from_physical_action_to_federate_output = " + + CTypes.getInstance().getTargetTimeExpr(minDelay) + + ";"); + } } + return code.getCode(); + } - /** - * Generate code to handle physical actions in the {@code federate}. - * @param errorReporter Used to report errors. - * @return Generated code. - */ - private String generateCodeForPhysicalActions(FederateInstance federate, ErrorReporter errorReporter) { - CodeBuilder code = new CodeBuilder(); - if (federate.targetConfig.coordination.equals(CoordinationType.CENTRALIZED)) { - // If this program uses centralized coordination then check - // for outputs that depend on physical actions so that null messages can be - // sent to the RTI. - var federateClass = ASTUtils.toDefinition(federate.instantiation.getReactorClass()); - var main = new ReactorInstance(FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), errorReporter, 1); - var instance = new ReactorInstance(federateClass, main, errorReporter); - var outputDelayMap = federate - .findOutputsConnectedToPhysicalActions(instance); - var minDelay = TimeValue.MAX_VALUE; - Output outputFound = null; - for (Output output : outputDelayMap.keySet()) { - var outputDelay = outputDelayMap.get(output); - if (outputDelay.isEarlierThan(minDelay)) { - minDelay = outputDelay; - outputFound = output; - } - } - if (minDelay != TimeValue.MAX_VALUE) { - // Unless silenced, issue a warning. - if (federate.targetConfig.coordinationOptions.advance_message_interval - == null) { - errorReporter.reportWarning(outputFound, String.join("\n", - "Found a path from a physical action to output for reactor " - + addDoubleQuotes(instance.getName()) - + ". ", - "The amount of delay is " - + minDelay - + ".", - "With centralized coordination, this can result in a large number of messages to the RTI.", - "Consider refactoring the code so that the output does not depend on the physical action,", - "or consider using decentralized coordination. To silence this warning, set the target", - "parameter coordination-options with a value like {advance-message-interval: 10 msec}" - )); - } - code.pr( - "_fed.min_delay_from_physical_action_to_federate_output = " - + CTypes.getInstance().getTargetTimeExpr(minDelay) + ";"); - } - } - return code.getCode(); - } - private String getPreamblePath(FederateInstance f) { - return "include" + File.separator + "_" + f.name + "_preamble.h"; - } + private String getPreamblePath(FederateInstance f) { + return "include" + File.separator + "_" + f.name + "_preamble.h"; + } } diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java index 3eeee4b5cb..391204fdb5 100644 --- a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java +++ b/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java @@ -7,13 +7,12 @@ import java.util.LinkedList; import java.util.List; import java.util.regex.Pattern; - -import org.lflang.ast.ASTUtils; import org.lflang.InferredType; import org.lflang.TargetConfig.ClockSyncOptions; import org.lflang.TargetProperty; import org.lflang.TargetProperty.ClockSyncMode; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; import org.lflang.federated.launcher.RtiConfig; @@ -33,563 +32,573 @@ public class CExtensionUtils { - // Regular expression pattern for shared_ptr types. - static final Pattern sharedPointerVariable = Pattern.compile("^(/\\*.*?\\*/)?std::shared_ptr<(?((/\\*.*?\\*/)?(\\S+))+)>$"); - - /** - * Generate C code that allocates sufficient memory for the following two - * critical data structures that support network control reactions: - *
      - *
    • {@code triggers_for_network_input_control_reactions}: These are triggers that - * are used at runtime to insert network input control reactions into the - * reaction queue.
      • - *
    • {@code trigger_for_network_output_control_reactions}: Triggers for - * network output control reactions, which are unique per each output port. - * There could be multiple network output control reactions for each - * network - * output port if it is connected to multiple downstream federates.
      • - *
    - * - * @param federate The top-level federate instance - * @return A string that allocates memory for the aforementioned three - * structures. - */ - public static String allocateTriggersForFederate( - FederateInstance federate - ) { - - CodeBuilder builder = new CodeBuilder(); - if (federate.networkInputControlReactionsTriggers.size() > 0) { - // Proliferate the network input control reaction trigger array - builder.pr( - """ + // Regular expression pattern for shared_ptr types. + static final Pattern sharedPointerVariable = + Pattern.compile("^(/\\*.*?\\*/)?std::shared_ptr<(?((/\\*.*?\\*/)?(\\S+))+)>$"); + + /** + * Generate C code that allocates sufficient memory for the following two critical data structures + * that support network control reactions: + * + *
      + *
    • {@code triggers_for_network_input_control_reactions}: These are triggers that are used at + * runtime to insert network input control reactions into the reaction queue. + *
    • {@code trigger_for_network_output_control_reactions}: Triggers for network output control + * reactions, which are unique per each output port. There could be multiple network output + * control reactions for each network output port if it is connected to multiple downstream + * federates. + *
    + * + * @param federate The top-level federate instance + * @return A string that allocates memory for the aforementioned three structures. + */ + public static String allocateTriggersForFederate(FederateInstance federate) { + + CodeBuilder builder = new CodeBuilder(); + if (federate.networkInputControlReactionsTriggers.size() > 0) { + // Proliferate the network input control reaction trigger array + builder.pr( + """ // Initialize the array of pointers to network input port triggers _fed.triggers_for_network_input_control_reactions_size = %s; _fed.triggers_for_network_input_control_reactions = (trigger_t**)malloc( _fed.triggers_for_network_input_control_reactions_size * sizeof(trigger_t*)); - """.formatted(federate.networkInputControlReactionsTriggers.size())); - - } - return builder.getCode(); + """ + .formatted(federate.networkInputControlReactionsTriggers.size())); } - - /** - * Generate C code that initializes network actions. - * - * These network actions will be triggered by federate.c whenever a message - * is received from the network. - * @param federate The federate. - * @param main The main reactor that contains the federate (used to lookup references). - * @return - */ - public static String initializeTriggersForNetworkActions(FederateInstance federate, ReactorInstance main) { - CodeBuilder code = new CodeBuilder(); - if (federate.networkMessageActions.size() > 0) { - // Create a static array of trigger_t pointers. - // networkMessageActions is a list of Actions, but we - // need a list of trigger struct names for ActionInstances. - // There should be exactly one ActionInstance in the - // main reactor for each Action. - var triggers = new LinkedList(); - for (Action action : federate.networkMessageActions) { - // Find the corresponding ActionInstance. - var actionInstance = main.lookupActionInstance(action); - triggers.add(CUtil.actionRef(actionInstance, null)); - } - var actionTableCount = 0; - for (String trigger : triggers) { - code.pr("_lf_action_table[" + (actionTableCount++) + "] = (lf_action_base_t*)&" - + trigger + "; \\"); - } - } - return code.getCode(); + return builder.getCode(); + } + + /** + * Generate C code that initializes network actions. + * + *

    These network actions will be triggered by federate.c whenever a message is received from + * the network. + * + * @param federate The federate. + * @param main The main reactor that contains the federate (used to lookup references). + * @return + */ + public static String initializeTriggersForNetworkActions( + FederateInstance federate, ReactorInstance main) { + CodeBuilder code = new CodeBuilder(); + if (federate.networkMessageActions.size() > 0) { + // Create a static array of trigger_t pointers. + // networkMessageActions is a list of Actions, but we + // need a list of trigger struct names for ActionInstances. + // There should be exactly one ActionInstance in the + // main reactor for each Action. + var triggers = new LinkedList(); + for (Action action : federate.networkMessageActions) { + // Find the corresponding ActionInstance. + var actionInstance = main.lookupActionInstance(action); + triggers.add(CUtil.actionRef(actionInstance, null)); + } + var actionTableCount = 0; + for (String trigger : triggers) { + code.pr( + "_lf_action_table[" + + (actionTableCount++) + + "] = (lf_action_base_t*)&" + + trigger + + "; \\"); + } + } + return code.getCode(); + } + + /** + * Generate C code that initializes three critical structures that support network control + * reactions: - triggers_for_network_input_control_reactions: These are triggers that are used at + * runtime to insert network input control reactions into the reaction queue. There could be + * multiple network input control reactions for one network input at multiple levels in the + * hierarchy. - trigger_for_network_output_control_reactions: Triggers for network output control + * reactions, which are unique per each output port. There could be multiple network output + * control reactions for each network output port if it is connected to multiple downstream + * federates. + * + * @param instance The reactor instance that is at any level of the hierarchy within the federate. + * @param federate The top-level federate + * @return A string that initializes the aforementioned three structures. + */ + public static String initializeTriggerForControlReactions( + ReactorInstance instance, ReactorInstance main, FederateInstance federate) { + CodeBuilder builder = new CodeBuilder(); + // The network control reactions are always in the main federated + // reactor + if (instance != main) { + return ""; } - /** - * Generate C code that initializes three critical structures that support - * network control reactions: - * - triggers_for_network_input_control_reactions: These are triggers that are - * used at runtime to insert network input control reactions into the - * reaction queue. There could be multiple network input control reactions - * for one network input at multiple levels in the hierarchy. - * - trigger_for_network_output_control_reactions: Triggers for - * network output control reactions, which are unique per each output port. - * There could be multiple network output control reactions for each network - * output port if it is connected to multiple downstream federates. - * - * @param instance The reactor instance that is at any level of the - * hierarchy within the federate. - * @param federate The top-level federate - * @return A string that initializes the aforementioned three structures. - */ - public static String initializeTriggerForControlReactions( - ReactorInstance instance, - ReactorInstance main, - FederateInstance federate - ) { - CodeBuilder builder = new CodeBuilder(); - // The network control reactions are always in the main federated - // reactor - if (instance != main) { - return ""; - } - - ReactorDecl reactorClass = instance.getDefinition().getReactorClass(); - Reactor reactor = ASTUtils.toDefinition(reactorClass); - String nameOfSelfStruct = CUtil.reactorRef(instance); - - // Initialize triggers for network input control reactions - for (Action trigger : federate.networkInputControlReactionsTriggers) { - // Check if the trigger belongs to this reactor instance - if (ASTUtils.allReactions(reactor).stream().anyMatch(r -> { - return r.getTriggers().stream().anyMatch(t -> { - if (t instanceof VarRef) { - return ((VarRef) t).getVariable().equals(trigger); - } else { - return false; - } - }); - })) { - // Initialize the triggers_for_network_input_control_reactions for the input - builder.pr( - String.join("\n", - "/* Add trigger " + nameOfSelfStruct + "->_lf__"+trigger.getName()+" to the global list of network input ports. */ \\", - "_fed.triggers_for_network_input_control_reactions["+federate.networkInputControlReactionsTriggers.indexOf(trigger)+"]= \\", - " &"+nameOfSelfStruct+"->_lf__"+trigger.getName()+"; \\" - ) - ); - } - } - - nameOfSelfStruct = CUtil.reactorRef(instance); - - // Initialize the trigger for network output control reactions if it doesn't exist. - if (federate.networkOutputControlReactionsTrigger != null) { - builder.pr("_fed.trigger_for_network_output_control_reactions=&" + ReactorDecl reactorClass = instance.getDefinition().getReactorClass(); + Reactor reactor = ASTUtils.toDefinition(reactorClass); + String nameOfSelfStruct = CUtil.reactorRef(instance); + + // Initialize triggers for network input control reactions + for (Action trigger : federate.networkInputControlReactionsTriggers) { + // Check if the trigger belongs to this reactor instance + if (ASTUtils.allReactions(reactor).stream() + .anyMatch( + r -> { + return r.getTriggers().stream() + .anyMatch( + t -> { + if (t instanceof VarRef) { + return ((VarRef) t).getVariable().equals(trigger); + } else { + return false; + } + }); + })) { + // Initialize the triggers_for_network_input_control_reactions for the input + builder.pr( + String.join( + "\n", + "/* Add trigger " + nameOfSelfStruct - + "->_lf__outputControlReactionTrigger; \\"); - } - - return builder.getCode(); + + "->_lf__" + + trigger.getName() + + " to the global list of network input ports. */ \\", + "_fed.triggers_for_network_input_control_reactions[" + + federate.networkInputControlReactionsTriggers.indexOf(trigger) + + "]= \\", + " &" + nameOfSelfStruct + "->_lf__" + trigger.getName() + "; \\")); + } } - /** - * Create a port status field variable for a network input port "input" in - * the self struct of a reactor. - * - * @param input The network input port - * @return A string containing the appropriate variable - */ - public static String createPortStatusFieldForInput(Input input) { - StringBuilder builder = new StringBuilder(); - // Check if the port is a multiport - if (ASTUtils.isMultiport(input)) { - // If it is a multiport, then create an auxiliary list of port - // triggers for each channel of - // the multiport to keep track of the status of each channel - // individually - builder.append("trigger_t* _lf__" + input.getName() - + "_network_port_status;\n"); - } else { - // If it is not a multiport, then we could re-use the port trigger, - // and nothing needs to be - // done - } - return builder.toString(); - } + nameOfSelfStruct = CUtil.reactorRef(instance); - /** - * Given a connection 'delay' predicate, return a string that represents the - * interval_t value of the additional delay that needs to be applied to the - * outgoing message. - * - * The returned additional delay in absence of after on network connection - * (i.e., if delay is passed as a null) is NEVER. This has a special - * meaning in C library functions that send network messages that carry - * timestamps (@see send_timed_message and send_port_absent_to_federate - * in lib/core/federate.c). In this case, the sender will send its current - * tag as the timestamp of the outgoing message without adding a microstep delay. - * If the user has assigned an after delay to the network connection (that - * can be zero) either as a time value (e.g., 200 msec) or as a literal - * (e.g., a parameter), that delay in nsec will be returned. - * - * @param delay - * @return - */ - public static String getNetworkDelayLiteral(Expression delay) { - String additionalDelayString = "NEVER"; - if (delay != null) { - TimeValue tv; - if (delay instanceof ParameterReference) { - // The parameter has to be parameter of the main reactor. - // And that value has to be a Time. - tv = ASTUtils.getDefaultAsTimeValue(((ParameterReference)delay).getParameter()); - } else { - tv = ASTUtils.getLiteralTimeValue(delay); - } - additionalDelayString = Long.toString(tv.toNanoSeconds()); - } - return additionalDelayString; + // Initialize the trigger for network output control reactions if it doesn't exist. + if (federate.networkOutputControlReactionsTrigger != null) { + builder.pr( + "_fed.trigger_for_network_output_control_reactions=&" + + nameOfSelfStruct + + "->_lf__outputControlReactionTrigger; \\"); } - static boolean isSharedPtrType(InferredType type, CTypes types) { - return !type.isUndefined() && sharedPointerVariable.matcher(types.getTargetType(type)).find(); + return builder.getCode(); + } + + /** + * Create a port status field variable for a network input port "input" in the self struct of a + * reactor. + * + * @param input The network input port + * @return A string containing the appropriate variable + */ + public static String createPortStatusFieldForInput(Input input) { + StringBuilder builder = new StringBuilder(); + // Check if the port is a multiport + if (ASTUtils.isMultiport(input)) { + // If it is a multiport, then create an auxiliary list of port + // triggers for each channel of + // the multiport to keep track of the status of each channel + // individually + builder.append("trigger_t* _lf__" + input.getName() + "_network_port_status;\n"); + } else { + // If it is not a multiport, then we could re-use the port trigger, + // and nothing needs to be + // done } - - public static void handleCompileDefinitions( - FederateInstance federate, - int numOfFederates, - RtiConfig rtiConfig - ) { - federate.targetConfig.setByUser.add(TargetProperty.COMPILE_DEFINITIONS); - federate.targetConfig.compileDefinitions.put("FEDERATED", ""); - federate.targetConfig.compileDefinitions.put("FEDERATED_"+federate.targetConfig.coordination.toString().toUpperCase(), ""); - if (federate.targetConfig.auth) { - federate.targetConfig.compileDefinitions.put("FEDERATED_AUTHENTICATED", ""); - } - federate.targetConfig.compileDefinitions.put("NUMBER_OF_FEDERATES", String.valueOf(numOfFederates)); - federate.targetConfig.compileDefinitions.put("EXECUTABLE_PREAMBLE", ""); - federate.targetConfig.compileDefinitions.put("WORKERS_NEEDED_FOR_FEDERATE", String.valueOf(minThreadsToHandleInputPorts(federate))); - - handleAdvanceMessageInterval(federate); - - initializeClockSynchronization(federate, rtiConfig); + return builder.toString(); + } + + /** + * Given a connection 'delay' predicate, return a string that represents the interval_t value of + * the additional delay that needs to be applied to the outgoing message. + * + *

    The returned additional delay in absence of after on network connection (i.e., if delay is + * passed as a null) is NEVER. This has a special meaning in C library functions that send network + * messages that carry timestamps (@see send_timed_message and send_port_absent_to_federate in + * lib/core/federate.c). In this case, the sender will send its current tag as the timestamp of + * the outgoing message without adding a microstep delay. If the user has assigned an after delay + * to the network connection (that can be zero) either as a time value (e.g., 200 msec) or as a + * literal (e.g., a parameter), that delay in nsec will be returned. + * + * @param delay + * @return + */ + public static String getNetworkDelayLiteral(Expression delay) { + String additionalDelayString = "NEVER"; + if (delay != null) { + TimeValue tv; + if (delay instanceof ParameterReference) { + // The parameter has to be parameter of the main reactor. + // And that value has to be a Time. + tv = ASTUtils.getDefaultAsTimeValue(((ParameterReference) delay).getParameter()); + } else { + tv = ASTUtils.getLiteralTimeValue(delay); + } + additionalDelayString = Long.toString(tv.toNanoSeconds()); } - - /** - * The number of threads needs to be at least one larger than the input ports - * to allow the federate to wait on all input ports while allowing an additional - * worker thread to process incoming messages. - * @return The minimum number of threads needed. - */ - public static int minThreadsToHandleInputPorts(FederateInstance federate) { - int nthreads = 1; - nthreads = Math.max(nthreads, federate.networkMessageActions.size() + 1); - return nthreads; + return additionalDelayString; + } + + static boolean isSharedPtrType(InferredType type, CTypes types) { + return !type.isUndefined() && sharedPointerVariable.matcher(types.getTargetType(type)).find(); + } + + public static void handleCompileDefinitions( + FederateInstance federate, int numOfFederates, RtiConfig rtiConfig) { + federate.targetConfig.setByUser.add(TargetProperty.COMPILE_DEFINITIONS); + federate.targetConfig.compileDefinitions.put("FEDERATED", ""); + federate.targetConfig.compileDefinitions.put( + "FEDERATED_" + federate.targetConfig.coordination.toString().toUpperCase(), ""); + if (federate.targetConfig.auth) { + federate.targetConfig.compileDefinitions.put("FEDERATED_AUTHENTICATED", ""); } - - private static void handleAdvanceMessageInterval(FederateInstance federate) { - var advanceMessageInterval = federate.targetConfig.coordinationOptions.advance_message_interval; - federate.targetConfig.setByUser.remove(TargetProperty.COORDINATION_OPTIONS); - if (advanceMessageInterval != null) { - federate.targetConfig.compileDefinitions.put( - "ADVANCE_MESSAGE_INTERVAL", - String.valueOf(advanceMessageInterval.toNanoSeconds()) - ); - } + federate.targetConfig.compileDefinitions.put( + "NUMBER_OF_FEDERATES", String.valueOf(numOfFederates)); + federate.targetConfig.compileDefinitions.put("EXECUTABLE_PREAMBLE", ""); + federate.targetConfig.compileDefinitions.put( + "WORKERS_NEEDED_FOR_FEDERATE", String.valueOf(minThreadsToHandleInputPorts(federate))); + + handleAdvanceMessageInterval(federate); + + initializeClockSynchronization(federate, rtiConfig); + } + + /** + * The number of threads needs to be at least one larger than the input ports to allow the + * federate to wait on all input ports while allowing an additional worker thread to process + * incoming messages. + * + * @return The minimum number of threads needed. + */ + public static int minThreadsToHandleInputPorts(FederateInstance federate) { + int nthreads = 1; + nthreads = Math.max(nthreads, federate.networkMessageActions.size() + 1); + return nthreads; + } + + private static void handleAdvanceMessageInterval(FederateInstance federate) { + var advanceMessageInterval = federate.targetConfig.coordinationOptions.advance_message_interval; + federate.targetConfig.setByUser.remove(TargetProperty.COORDINATION_OPTIONS); + if (advanceMessageInterval != null) { + federate.targetConfig.compileDefinitions.put( + "ADVANCE_MESSAGE_INTERVAL", String.valueOf(advanceMessageInterval.toNanoSeconds())); } + } - static boolean clockSyncIsOn(FederateInstance federate, RtiConfig rtiConfig) { - return federate.targetConfig.clockSync != ClockSyncMode.OFF - && (!rtiConfig.getHost().equals(federate.host) + static boolean clockSyncIsOn(FederateInstance federate, RtiConfig rtiConfig) { + return federate.targetConfig.clockSync != ClockSyncMode.OFF + && (!rtiConfig.getHost().equals(federate.host) || federate.targetConfig.clockSyncOptions.localFederatesOn); - } - - /** - * Initialize clock synchronization (if enabled) and its related options for a given federate. - * - * Clock synchronization can be enabled using the clock-sync target property. - * @see Documentation - */ - public static void initializeClockSynchronization( - FederateInstance federate, - RtiConfig rtiConfig - ) { - // Check if clock synchronization should be enabled for this federate in the first place - if (clockSyncIsOn(federate, rtiConfig)) { - System.out.println("Initial clock synchronization is enabled for federate " - + federate.id - ); - if (federate.targetConfig.clockSync == ClockSyncMode.ON) { - if (federate.targetConfig.clockSyncOptions.collectStats) { - System.out.println("Will collect clock sync statistics for federate " + federate.id); - // Add libm to the compiler flags - // FIXME: This is a linker flag not compile flag but we don't have a way to add linker flags - // FIXME: This is probably going to fail on MacOS (especially using clang) - // because libm functions are builtin - federate.targetConfig.compilerFlags.add("-lm"); - federate.targetConfig.setByUser.add(TargetProperty.FLAGS); - } - System.out.println("Runtime clock synchronization is enabled for federate " - + federate.id - ); - } - - addClockSyncCompileDefinitions(federate); + } + + /** + * Initialize clock synchronization (if enabled) and its related options for a given federate. + * + *

    Clock synchronization can be enabled using the clock-sync target property. + * + * @see Documentation + */ + public static void initializeClockSynchronization( + FederateInstance federate, RtiConfig rtiConfig) { + // Check if clock synchronization should be enabled for this federate in the first place + if (clockSyncIsOn(federate, rtiConfig)) { + System.out.println("Initial clock synchronization is enabled for federate " + federate.id); + if (federate.targetConfig.clockSync == ClockSyncMode.ON) { + if (federate.targetConfig.clockSyncOptions.collectStats) { + System.out.println("Will collect clock sync statistics for federate " + federate.id); + // Add libm to the compiler flags + // FIXME: This is a linker flag not compile flag but we don't have a way to add linker + // flags + // FIXME: This is probably going to fail on MacOS (especially using clang) + // because libm functions are builtin + federate.targetConfig.compilerFlags.add("-lm"); + federate.targetConfig.setByUser.add(TargetProperty.FLAGS); } - } - - - /** - * Initialize clock synchronization (if enabled) and its related options for a given federate. - * - * Clock synchronization can be enabled using the clock-sync target property. - * @see Documentation - */ - public static void addClockSyncCompileDefinitions(FederateInstance federate) { + System.out.println("Runtime clock synchronization is enabled for federate " + federate.id); + } - ClockSyncMode mode = federate.targetConfig.clockSync; - ClockSyncOptions options = federate.targetConfig.clockSyncOptions; - - - federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_INITIAL", ""); - federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_PERIOD_NS", String.valueOf(options.period.toNanoSeconds())); - federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_EXCHANGES_PER_INTERVAL", String.valueOf(options.trials)); - federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_ATTENUATION", String.valueOf(options.attenuation)); - - if (mode == ClockSyncMode.ON) { - federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_ON", ""); - if (options.collectStats) { - federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_COLLECT_STATS", ""); - } - } + addClockSyncCompileDefinitions(federate); + } + } + + /** + * Initialize clock synchronization (if enabled) and its related options for a given federate. + * + *

    Clock synchronization can be enabled using the clock-sync target property. + * + * @see Documentation + */ + public static void addClockSyncCompileDefinitions(FederateInstance federate) { + + ClockSyncMode mode = federate.targetConfig.clockSync; + ClockSyncOptions options = federate.targetConfig.clockSyncOptions; + + federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_INITIAL", ""); + federate.targetConfig.compileDefinitions.put( + "_LF_CLOCK_SYNC_PERIOD_NS", String.valueOf(options.period.toNanoSeconds())); + federate.targetConfig.compileDefinitions.put( + "_LF_CLOCK_SYNC_EXCHANGES_PER_INTERVAL", String.valueOf(options.trials)); + federate.targetConfig.compileDefinitions.put( + "_LF_CLOCK_SYNC_ATTENUATION", String.valueOf(options.attenuation)); + + if (mode == ClockSyncMode.ON) { + federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_ON", ""); + if (options.collectStats) { + federate.targetConfig.compileDefinitions.put("_LF_CLOCK_SYNC_COLLECT_STATS", ""); + } } + } + /** Generate a file to be included by CMake. */ + public static void generateCMakeInclude(FederateInstance federate, FedFileConfig fileConfig) + throws IOException { + Files.createDirectories(fileConfig.getSrcPath().resolve("include")); - /** - * Generate a file to be included by CMake. - */ - public static void generateCMakeInclude( - FederateInstance federate, - FedFileConfig fileConfig - ) throws IOException { - Files.createDirectories(fileConfig.getSrcPath().resolve("include")); - - Path cmakeIncludePath = fileConfig.getSrcPath() - .resolve("include" + File.separator + federate.name + "_extension.cmake"); - - CodeBuilder cmakeIncludeCode = new CodeBuilder(); - - cmakeIncludeCode.pr(generateSerializationCMakeExtension(federate)); - cmakeIncludeCode.pr( - "add_compile_definitions(LF_SOURCE_DIRECTORY=\"" - + fileConfig.srcPath - + "\")" - ); - cmakeIncludeCode.pr( - "add_compile_definitions(LF_PACKAGE_DIRECTORY=\"" - + fileConfig.srcPkgPath - + "\")" - ); - - try (var srcWriter = Files.newBufferedWriter(cmakeIncludePath)) { - srcWriter.write(cmakeIncludeCode.getCode()); - } + Path cmakeIncludePath = + fileConfig + .getSrcPath() + .resolve("include" + File.separator + federate.name + "_extension.cmake"); - federate.targetConfig.cmakeIncludes.add(fileConfig.getSrcPath().relativize(cmakeIncludePath).toString()); - federate.targetConfig.setByUser.add(TargetProperty.CMAKE_INCLUDE); - } + CodeBuilder cmakeIncludeCode = new CodeBuilder(); + cmakeIncludeCode.pr(generateSerializationCMakeExtension(federate)); + cmakeIncludeCode.pr( + "add_compile_definitions(LF_SOURCE_DIRECTORY=\"" + fileConfig.srcPath + "\")"); + cmakeIncludeCode.pr( + "add_compile_definitions(LF_PACKAGE_DIRECTORY=\"" + fileConfig.srcPkgPath + "\")"); - /** - * Generate code that sends the neighbor structure message to the RTI. - * See {@code MSG_TYPE_NEIGHBOR_STRUCTURE} in {@code federated/net_common.h}. - * - * @param federate The federate that is sending its neighbor structure - */ - public static String generateFederateNeighborStructure(FederateInstance federate) { - var code = new CodeBuilder(); - code.pr(String.join("\n", - "/**", - "* Generated function that sends information about connections between this federate and", - "* other federates where messages are routed through the RTI. Currently, this", - "* only includes logical connections when the coordination is centralized. This", - "* information is needed for the RTI to perform the centralized coordination.", - "* @see MSG_TYPE_NEIGHBOR_STRUCTURE in net_common.h", - "*/", - "void send_neighbor_structure_to_RTI(int rti_socket) {" - )); - code.indent(); - // Initialize the array of information about the federate's immediate upstream - // and downstream relayed (through the RTI) logical connections, to send to the - // RTI. - code.pr(String.join("\n", - "interval_t candidate_tmp;", - "size_t buffer_size = 1 + 8 + ", - " "+federate.dependsOn.keySet().size()+" * ( sizeof(uint16_t) + sizeof(int64_t) ) +", - " "+federate.sendsTo.keySet().size()+" * sizeof(uint16_t);", - "unsigned char buffer_to_send[buffer_size];", - "", - "size_t message_head = 0;", - "buffer_to_send[message_head] = MSG_TYPE_NEIGHBOR_STRUCTURE;", - "message_head++;", - "encode_int32((int32_t)"+federate.dependsOn.keySet().size()+", &(buffer_to_send[message_head]));", - "message_head+=sizeof(int32_t);", - "encode_int32((int32_t)"+federate.sendsTo.keySet().size()+", &(buffer_to_send[message_head]));", - "message_head+=sizeof(int32_t);" - )); - - if (!federate.dependsOn.keySet().isEmpty()) { - // Next, populate these arrays. - // Find the minimum delay in the process. - // FIXME: Zero delay is not really the same as a microstep delay. - for (FederateInstance upstreamFederate : federate.dependsOn.keySet()) { - code.pr(String.join("\n", - "encode_uint16((uint16_t)"+upstreamFederate.id+", &(buffer_to_send[message_head]));", - "message_head += sizeof(uint16_t);" - )); - // The minimum delay calculation needs to be made in the C code because it - // may depend on parameter values. - // FIXME: These would have to be top-level parameters, which don't really - // have any support yet. Ideally, they could be overridden on the command line. - // When that is done, they will need to be in scope here. - var delays = federate.dependsOn.get(upstreamFederate); - if (delays != null) { - // There is at least one delay, so find the minimum. - // If there is no delay at all, this is encoded as NEVER. - code.pr("candidate_tmp = FOREVER;"); - for (Expression delay : delays) { - if (delay == null) { - // Use NEVER to encode no delay at all. - code.pr("candidate_tmp = NEVER;"); - } else { - var delayTime = - delay instanceof ParameterReference - // In that case use the default value. - ? CTypes.getInstance().getTargetTimeExpr(ASTUtils.getDefaultAsTimeValue(((ParameterReference) delay).getParameter())) - : CTypes.getInstance().getTargetExpr(delay, InferredType.time()); - - code.pr(String.join("\n", - "if (" + delayTime + " < candidate_tmp) {", - " candidate_tmp = " + delayTime + ";", - "}" - )); - } - } - code.pr(String.join("\n", - "encode_int64((int64_t)candidate_tmp, &(buffer_to_send[message_head]));", - "message_head += sizeof(int64_t);" - )); - } else { - // Use NEVER to encode no delay at all. - code.pr(String.join("\n", - "encode_int64(NEVER, &(buffer_to_send[message_head]));", - "message_head += sizeof(int64_t);" - )); - } - } - } + try (var srcWriter = Files.newBufferedWriter(cmakeIncludePath)) { + srcWriter.write(cmakeIncludeCode.getCode()); + } - // Next, set up the downstream array. - if (!federate.sendsTo.keySet().isEmpty()) { - // Next, populate the array. - // Find the minimum delay in the process. - // FIXME: Zero delay is not really the same as a microstep delay. - for (FederateInstance downstreamFederate : federate.sendsTo.keySet()) { - code.pr(String.join("\n", - "encode_uint16("+downstreamFederate.id+", &(buffer_to_send[message_head]));", - "message_head += sizeof(uint16_t);" - )); + federate.targetConfig.cmakeIncludes.add( + fileConfig.getSrcPath().relativize(cmakeIncludePath).toString()); + federate.targetConfig.setByUser.add(TargetProperty.CMAKE_INCLUDE); + } + + /** + * Generate code that sends the neighbor structure message to the RTI. See {@code + * MSG_TYPE_NEIGHBOR_STRUCTURE} in {@code federated/net_common.h}. + * + * @param federate The federate that is sending its neighbor structure + */ + public static String generateFederateNeighborStructure(FederateInstance federate) { + var code = new CodeBuilder(); + code.pr( + String.join( + "\n", + "/**", + "* Generated function that sends information about connections between this federate" + + " and", + "* other federates where messages are routed through the RTI. Currently, this", + "* only includes logical connections when the coordination is centralized. This", + "* information is needed for the RTI to perform the centralized coordination.", + "* @see MSG_TYPE_NEIGHBOR_STRUCTURE in net_common.h", + "*/", + "void send_neighbor_structure_to_RTI(int rti_socket) {")); + code.indent(); + // Initialize the array of information about the federate's immediate upstream + // and downstream relayed (through the RTI) logical connections, to send to the + // RTI. + code.pr( + String.join( + "\n", + "interval_t candidate_tmp;", + "size_t buffer_size = 1 + 8 + ", + " " + + federate.dependsOn.keySet().size() + + " * ( sizeof(uint16_t) + sizeof(int64_t) ) +", + " " + federate.sendsTo.keySet().size() + " * sizeof(uint16_t);", + "unsigned char buffer_to_send[buffer_size];", + "", + "size_t message_head = 0;", + "buffer_to_send[message_head] = MSG_TYPE_NEIGHBOR_STRUCTURE;", + "message_head++;", + "encode_int32((int32_t)" + + federate.dependsOn.keySet().size() + + ", &(buffer_to_send[message_head]));", + "message_head+=sizeof(int32_t);", + "encode_int32((int32_t)" + + federate.sendsTo.keySet().size() + + ", &(buffer_to_send[message_head]));", + "message_head+=sizeof(int32_t);")); + + if (!federate.dependsOn.keySet().isEmpty()) { + // Next, populate these arrays. + // Find the minimum delay in the process. + // FIXME: Zero delay is not really the same as a microstep delay. + for (FederateInstance upstreamFederate : federate.dependsOn.keySet()) { + code.pr( + String.join( + "\n", + "encode_uint16((uint16_t)" + + upstreamFederate.id + + ", &(buffer_to_send[message_head]));", + "message_head += sizeof(uint16_t);")); + // The minimum delay calculation needs to be made in the C code because it + // may depend on parameter values. + // FIXME: These would have to be top-level parameters, which don't really + // have any support yet. Ideally, they could be overridden on the command line. + // When that is done, they will need to be in scope here. + var delays = federate.dependsOn.get(upstreamFederate); + if (delays != null) { + // There is at least one delay, so find the minimum. + // If there is no delay at all, this is encoded as NEVER. + code.pr("candidate_tmp = FOREVER;"); + for (Expression delay : delays) { + if (delay == null) { + // Use NEVER to encode no delay at all. + code.pr("candidate_tmp = NEVER;"); + } else { + var delayTime = + delay instanceof ParameterReference + // In that case use the default value. + ? CTypes.getInstance() + .getTargetTimeExpr( + ASTUtils.getDefaultAsTimeValue( + ((ParameterReference) delay).getParameter())) + : CTypes.getInstance().getTargetExpr(delay, InferredType.time()); + + code.pr( + String.join( + "\n", + "if (" + delayTime + " < candidate_tmp) {", + " candidate_tmp = " + delayTime + ";", + "}")); } + } + code.pr( + String.join( + "\n", + "encode_int64((int64_t)candidate_tmp, &(buffer_to_send[message_head]));", + "message_head += sizeof(int64_t);")); + } else { + // Use NEVER to encode no delay at all. + code.pr( + String.join( + "\n", + "encode_int64(NEVER, &(buffer_to_send[message_head]));", + "message_head += sizeof(int64_t);")); } - code.pr(String.join("\n", - "write_to_socket_errexit(", - " rti_socket, ", - " buffer_size,", - " buffer_to_send,", - " \"Failed to send the neighbor structure message to the RTI.\"", - ");" - )); - code.unindent(); - code.pr("}"); - return code.toString(); + } } - - public static List getFederatedFiles() { - return List.of( - "federated/net_util.c", - "federated/net_util.h", - "federated/net_common.h", - "federated/federate.c", - "federated/federate.h", - "federated/clock-sync.h", - "federated/clock-sync.c" - ); + // Next, set up the downstream array. + if (!federate.sendsTo.keySet().isEmpty()) { + // Next, populate the array. + // Find the minimum delay in the process. + // FIXME: Zero delay is not really the same as a microstep delay. + for (FederateInstance downstreamFederate : federate.sendsTo.keySet()) { + code.pr( + String.join( + "\n", + "encode_uint16(" + downstreamFederate.id + ", &(buffer_to_send[message_head]));", + "message_head += sizeof(uint16_t);")); + } } - - /** - * Surround {@code code} with blocks to ensure that code only executes - * if the program is federated. - */ - public static String surroundWithIfFederated(String code) { - return """ + code.pr( + String.join( + "\n", + "write_to_socket_errexit(", + " rti_socket, ", + " buffer_size,", + " buffer_to_send,", + " \"Failed to send the neighbor structure message to the RTI.\"", + ");")); + code.unindent(); + code.pr("}"); + return code.toString(); + } + + public static List getFederatedFiles() { + return List.of( + "federated/net_util.c", + "federated/net_util.h", + "federated/net_common.h", + "federated/federate.c", + "federated/federate.h", + "federated/clock-sync.h", + "federated/clock-sync.c"); + } + + /** + * Surround {@code code} with blocks to ensure that code only executes if the program is + * federated. + */ + public static String surroundWithIfFederated(String code) { + return """ #ifdef FEDERATED %s #endif // FEDERATED - """.formatted(code); - } - - /** - * Surround {@code code} with blocks to ensure that code only executes - * if the program is federated and has a centralized coordination. - */ - public static String surroundWithIfFederatedCentralized(String code) { - return """ + """ + .formatted(code); + } + + /** + * Surround {@code code} with blocks to ensure that code only executes if the program is federated + * and has a centralized coordination. + */ + public static String surroundWithIfFederatedCentralized(String code) { + return """ #ifdef FEDERATED_CENTRALIZED %s #endif // FEDERATED_CENTRALIZED - """.formatted(code); - } - - /** - * Surround {@code code} with blocks to ensure that code only executes - * if the program is federated and has a decentralized coordination. - */ - public static String surroundWithIfFederatedDecentralized(String code) { - return """ + """ + .formatted(code); + } + + /** + * Surround {@code code} with blocks to ensure that code only executes if the program is federated + * and has a decentralized coordination. + */ + public static String surroundWithIfFederatedDecentralized(String code) { + return """ #ifdef FEDERATED_DECENTRALIZED %s #endif // FEDERATED_DECENTRALIZED - """.formatted(code); + """ + .formatted(code); + } + + /** Generate preamble code needed for enabled serializers of the federate. */ + public static String generateSerializationIncludes( + FederateInstance federate, FedFileConfig fileConfig) { + CodeBuilder code = new CodeBuilder(); + for (SupportedSerializers serializer : federate.enabledSerializers) { + switch (serializer) { + case NATIVE: + case PROTO: + { + // No need to do anything at this point. + break; + } + case ROS2: + { + var ROSSerializer = new FedROS2CPPSerialization(); + code.pr(ROSSerializer.generatePreambleForSupport().toString()); + break; + } + } } - - /** - * Generate preamble code needed for enabled serializers of the federate. - */ - public static String generateSerializationIncludes( - FederateInstance federate, - FedFileConfig fileConfig - ) { - CodeBuilder code = new CodeBuilder(); - for (SupportedSerializers serializer : federate.enabledSerializers) { - switch (serializer) { - case NATIVE: - case PROTO: { - // No need to do anything at this point. - break; - } - case ROS2: { - var ROSSerializer = new FedROS2CPPSerialization(); - code.pr(ROSSerializer.generatePreambleForSupport().toString()); - break; - } - } - } - return code.getCode(); - } - - /** - * Generate cmake-include code needed for enabled serializers of the federate. - */ - public static String generateSerializationCMakeExtension( - FederateInstance federate - ) { - CodeBuilder code = new CodeBuilder(); - for (SupportedSerializers serializer : federate.enabledSerializers) { - switch (serializer) { - case NATIVE: - case PROTO: { - // No CMake code is needed for now - break; - } - case ROS2: { - var ROSSerializer = new FedROS2CPPSerialization(); - code.pr(ROSSerializer.generateCompilerExtensionForSupport()); - break; - } - } - } - return code.getCode(); + return code.getCode(); + } + + /** Generate cmake-include code needed for enabled serializers of the federate. */ + public static String generateSerializationCMakeExtension(FederateInstance federate) { + CodeBuilder code = new CodeBuilder(); + for (SupportedSerializers serializer : federate.enabledSerializers) { + switch (serializer) { + case NATIVE: + case PROTO: + { + // No CMake code is needed for now + break; + } + case ROS2: + { + var ROSSerializer = new FedROS2CPPSerialization(); + code.pr(ROSSerializer.generateCompilerExtensionForSupport()); + break; + } + } } + return code.getCode(); + } } diff --git a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java index d50a801617..17ac198781 100644 --- a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java @@ -1,7 +1,6 @@ package org.lflang.federated.extensions; import java.io.IOException; - import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetProperty.CoordinationType; @@ -17,110 +16,110 @@ public interface FedTargetExtension { - /** - * Perform necessary actions to initialize the target config. - * - * @param context - * @param numOfFederates - * @param federate The federate instance. - * @param fileConfig An instance of {@code FedFileConfig}. - * @param errorReporter Used to report errors. - */ - void initializeTargetConfig(LFGeneratorContext context, int numOfFederates, FederateInstance federate, FedFileConfig fileConfig, - ErrorReporter errorReporter, RtiConfig rtiConfig) throws IOException; + /** + * Perform necessary actions to initialize the target config. + * + * @param context + * @param numOfFederates + * @param federate The federate instance. + * @param fileConfig An instance of {@code FedFileConfig}. + * @param errorReporter Used to report errors. + */ + void initializeTargetConfig( + LFGeneratorContext context, + int numOfFederates, + FederateInstance federate, + FedFileConfig fileConfig, + ErrorReporter errorReporter, + RtiConfig rtiConfig) + throws IOException; - /** - * Generate code for the body of a reaction that handles the - * action that is triggered by receiving a message from a remote - * federate. - * @param action The action. - * @param sendingPort The output port providing the data to send. - * @param receivingPort The ID of the destination port. - * @param connection FIXME - * @param type FIXME - * @param coordinationType The coordination type - * @param errorReporter - */ - String generateNetworkReceiverBody( - Action action, - VarRef sendingPort, - VarRef receivingPort, - FedConnectionInstance connection, - InferredType type, - CoordinationType coordinationType, - ErrorReporter errorReporter - ); + /** + * Generate code for the body of a reaction that handles the action that is triggered by receiving + * a message from a remote federate. + * + * @param action The action. + * @param sendingPort The output port providing the data to send. + * @param receivingPort The ID of the destination port. + * @param connection FIXME + * @param type FIXME + * @param coordinationType The coordination type + * @param errorReporter + */ + String generateNetworkReceiverBody( + Action action, + VarRef sendingPort, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + CoordinationType coordinationType, + ErrorReporter errorReporter); - /** - * Generate code for the body of a reaction that handles an output - * that is to be sent over the network. - * @param sendingPort The output port providing the data to send. - * @param receivingPort The variable reference to the destination port. - * @param connection - * @param type - * @param coordinationType - * @param errorReporter FIXME - */ - String generateNetworkSenderBody( - VarRef sendingPort, - VarRef receivingPort, - FedConnectionInstance connection, - InferredType type, - CoordinationType coordinationType, - ErrorReporter errorReporter - ); + /** + * Generate code for the body of a reaction that handles an output that is to be sent over the + * network. + * + * @param sendingPort The output port providing the data to send. + * @param receivingPort The variable reference to the destination port. + * @param connection + * @param type + * @param coordinationType + * @param errorReporter FIXME + */ + String generateNetworkSenderBody( + VarRef sendingPort, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + CoordinationType coordinationType, + ErrorReporter errorReporter); - /** - * Generate code for the body of a reaction that decides whether the trigger for the given - * port is going to be present or absent for the current logical time. - * This reaction is put just before the first reaction that is triggered by the network - * input port "port" or has it in its sources. If there are only connections to contained - * reactors, in the top-level reactor. - * - * @param receivingPortID The port to generate the control reaction for - * @param maxSTP The maximum value of STP is assigned to reactions (if any) - * that have port as their trigger or source - * @param coordination FIXME - */ - String generateNetworkInputControlReactionBody( - int receivingPortID, - TimeValue maxSTP, - CoordinationType coordination - ); + /** + * Generate code for the body of a reaction that decides whether the trigger for the given port is + * going to be present or absent for the current logical time. This reaction is put just before + * the first reaction that is triggered by the network input port "port" or has it in its sources. + * If there are only connections to contained reactors, in the top-level reactor. + * + * @param receivingPortID The port to generate the control reaction for + * @param maxSTP The maximum value of STP is assigned to reactions (if any) that have port as + * their trigger or source + * @param coordination FIXME + */ + String generateNetworkInputControlReactionBody( + int receivingPortID, TimeValue maxSTP, CoordinationType coordination); - /** - * Generate code for the body of a reaction that sends a port status message for the given - * port if it is absent. - * - * @oaram srcOutputPort FIXME - * @param connection FIXME - */ - String generateNetworkOutputControlReactionBody( - VarRef srcOutputPort, - FedConnectionInstance connection - ); + /** + * Generate code for the body of a reaction that sends a port status message for the given port if + * it is absent. + * + * @oaram srcOutputPort FIXME + * @param connection FIXME + */ + String generateNetworkOutputControlReactionBody( + VarRef srcOutputPort, FedConnectionInstance connection); - /** Optionally apply additional annotations to the reaction. */ - default void annotateReaction(Reaction reaction) {} + /** Optionally apply additional annotations to the reaction. */ + default void annotateReaction(Reaction reaction) {} - /** - * Return the type for the raw network buffer in the target language (e.g., {@code uint_8} in C). This would be the type of the - * network messages after serialization and before deserialization. It is primarily used to determine the type for the - * network action at the receiver. - */ - String getNetworkBufferType(); + /** + * Return the type for the raw network buffer in the target language (e.g., {@code uint_8} in C). + * This would be the type of the network messages after serialization and before deserialization. + * It is primarily used to determine the type for the network action at the receiver. + */ + String getNetworkBufferType(); - /** - * Add necessary preamble to the source to set up federated execution. - * - * @param federate - * @param rtiConfig - * @param errorReporter - * @return - */ - String generatePreamble(FederateInstance federate, - FedFileConfig fileConfig, - RtiConfig rtiConfig, - ErrorReporter errorReporter) - throws IOException; + /** + * Add necessary preamble to the source to set up federated execution. + * + * @param federate + * @param rtiConfig + * @param errorReporter + * @return + */ + String generatePreamble( + FederateInstance federate, + FedFileConfig fileConfig, + RtiConfig rtiConfig, + ErrorReporter errorReporter) + throws IOException; } diff --git a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java index 5caafc1c0c..ca16d1d445 100644 --- a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java +++ b/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java @@ -1,24 +1,26 @@ package org.lflang.federated.extensions; import org.lflang.Target; -import org.lflang.lf.TargetDecl; /** * Class for instantiating target extensions. + * * @author Soroush Bateni */ public class FedTargetExtensionFactory { - /** - * Given a target, return the appropriate extension. - */ - public static FedTargetExtension getExtension(Target target) { - switch (target) { - case CCPP: - case C: return new CExtension(); - case Python: return new PythonExtension(); - case TS: return new TSExtension(); - default: throw new RuntimeException("Target not supported"); - } + /** Given a target, return the appropriate extension. */ + public static FedTargetExtension getExtension(Target target) { + switch (target) { + case CCPP: + case C: + return new CExtension(); + case Python: + return new PythonExtension(); + case TS: + return new TSExtension(); + default: + throw new RuntimeException("Target not supported"); } + } } diff --git a/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java b/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java index 15606c6fa0..6fd1cb3dc9 100644 --- a/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java @@ -27,11 +27,10 @@ package org.lflang.federated.extensions; import java.io.IOException; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetProperty.CoordinationType; +import org.lflang.ast.ASTUtils; import org.lflang.federated.generator.FedConnectionInstance; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; @@ -46,165 +45,149 @@ import org.lflang.lf.VarRef; /** - * An extension class to the PythonGenerator that enables certain federated - * functionalities. + * An extension class to the PythonGenerator that enables certain federated functionalities. * * @author Soroush Bateni */ public class PythonExtension extends CExtension { - @Override - protected void generateCMakeInclude(FederateInstance federate, FedFileConfig fileConfig) throws IOException {} - - @Override - protected String generateSerializationIncludes(FederateInstance federate, FedFileConfig fileConfig) { - CodeBuilder code = new CodeBuilder(); - for (SupportedSerializers serialization : federate.enabledSerializers) { - switch (serialization) { - case NATIVE: { - FedNativePythonSerialization pickler = new FedNativePythonSerialization(); - code.pr(pickler.generatePreambleForSupport().toString()); - } - case PROTO: { - // Nothing needs to be done - } - case ROS2: { - // FIXME: Not supported yet - } - } - } - return code.getCode(); - } - - @Override - public String generateNetworkSenderBody( - VarRef sendingPort, - VarRef receivingPort, - FedConnectionInstance connection, - InferredType type, - CoordinationType coordinationType, - ErrorReporter errorReporter - ) { - var result = new CodeBuilder(); - - // We currently have no way to mark a reaction "unordered" - // in the AST, so we use a magic string at the start of the body. - result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); - result.pr(PyUtil.generateGILAcquireCode() + "\n"); - result.pr( - super.generateNetworkSenderBody( - sendingPort, - receivingPort, - connection, - type, - coordinationType, - errorReporter - ) - ); - result.pr(PyUtil.generateGILReleaseCode() + "\n"); - return result.getCode(); - } - - @Override - public String generateNetworkReceiverBody( - Action action, - VarRef sendingPort, - VarRef receivingPort, - FedConnectionInstance connection, - InferredType type, - CoordinationType coordinationType, - ErrorReporter errorReporter - ) { - var result = new CodeBuilder(); - - // We currently have no way to mark a reaction "unordered" - // in the AST, so we use a magic string at the start of the body. - result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); - result.pr(PyUtil.generateGILAcquireCode() + "\n"); - result.pr( - super.generateNetworkReceiverBody( - action, - sendingPort, - receivingPort, - connection, - type, - coordinationType, - errorReporter - ) - ); - result.pr(PyUtil.generateGILReleaseCode() + "\n"); - return result.getCode(); - - } - - @Override - protected void deserialize( - Action action, - VarRef receivingPort, - FedConnectionInstance connection, - InferredType type, - String receiveRef, - CodeBuilder result, - ErrorReporter errorReporter - ) { - String value = ""; - switch (connection.getSerializer()) { - case NATIVE: { - value = action.getName(); + @Override + protected void generateCMakeInclude(FederateInstance federate, FedFileConfig fileConfig) + throws IOException {} + + @Override + protected String generateSerializationIncludes( + FederateInstance federate, FedFileConfig fileConfig) { + CodeBuilder code = new CodeBuilder(); + for (SupportedSerializers serialization : federate.enabledSerializers) { + switch (serialization) { + case NATIVE: + { FedNativePythonSerialization pickler = new FedNativePythonSerialization(); - result.pr(pickler.generateNetworkDeserializerCode(value, null)); - result.pr("lf_set(" + receiveRef + ", " - + FedSerialization.deserializedVarName + ");\n"); - break; - } - case PROTO: { - throw new UnsupportedOperationException("Protobuf serialization is not supported yet."); + code.pr(pickler.generatePreambleForSupport().toString()); + } + case PROTO: + { + // Nothing needs to be done + } + case ROS2: + { + // FIXME: Not supported yet + } + } + } + return code.getCode(); + } + + @Override + public String generateNetworkSenderBody( + VarRef sendingPort, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + CoordinationType coordinationType, + ErrorReporter errorReporter) { + var result = new CodeBuilder(); + + // We currently have no way to mark a reaction "unordered" + // in the AST, so we use a magic string at the start of the body. + result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); + result.pr(PyUtil.generateGILAcquireCode() + "\n"); + result.pr( + super.generateNetworkSenderBody( + sendingPort, receivingPort, connection, type, coordinationType, errorReporter)); + result.pr(PyUtil.generateGILReleaseCode() + "\n"); + return result.getCode(); + } + + @Override + public String generateNetworkReceiverBody( + Action action, + VarRef sendingPort, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + CoordinationType coordinationType, + ErrorReporter errorReporter) { + var result = new CodeBuilder(); + + // We currently have no way to mark a reaction "unordered" + // in the AST, so we use a magic string at the start of the body. + result.pr("// " + ReactionInstance.UNORDERED_REACTION_MARKER + "\n"); + result.pr(PyUtil.generateGILAcquireCode() + "\n"); + result.pr( + super.generateNetworkReceiverBody( + action, sendingPort, receivingPort, connection, type, coordinationType, errorReporter)); + result.pr(PyUtil.generateGILReleaseCode() + "\n"); + return result.getCode(); + } + + @Override + protected void deserialize( + Action action, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + String receiveRef, + CodeBuilder result, + ErrorReporter errorReporter) { + String value = ""; + switch (connection.getSerializer()) { + case NATIVE: + { + value = action.getName(); + FedNativePythonSerialization pickler = new FedNativePythonSerialization(); + result.pr(pickler.generateNetworkDeserializerCode(value, null)); + result.pr("lf_set(" + receiveRef + ", " + FedSerialization.deserializedVarName + ");\n"); + break; } - case ROS2: { - throw new UnsupportedOperationException("ROS2 serialization is not supported yet."); + case PROTO: + { + throw new UnsupportedOperationException("Protobuf serialization is not supported yet."); } - + case ROS2: + { + throw new UnsupportedOperationException("ROS2 serialization is not supported yet."); } } - - @Override - protected void serializeAndSend( - FedConnectionInstance connection, - InferredType type, - String sendRef, - CodeBuilder result, - String sendingFunction, - String commonArgs, - ErrorReporter errorReporter - ) { - String lengthExpression = ""; - String pointerExpression = ""; - switch (connection.getSerializer()) { - case NATIVE: { - var variableToSerialize = sendRef + "->value"; - FedNativePythonSerialization pickler = new FedNativePythonSerialization(); - lengthExpression = pickler.serializedBufferLength(); - pointerExpression = pickler.seializedBufferVar(); - result.pr(pickler.generateNetworkSerializerCode(variableToSerialize, null)); - result.pr( - "size_t message_length = " + lengthExpression + ";"); - result.pr( - sendingFunction + "(" + commonArgs + ", " + pointerExpression - + ");\n"); - break; + } + + @Override + protected void serializeAndSend( + FedConnectionInstance connection, + InferredType type, + String sendRef, + CodeBuilder result, + String sendingFunction, + String commonArgs, + ErrorReporter errorReporter) { + String lengthExpression = ""; + String pointerExpression = ""; + switch (connection.getSerializer()) { + case NATIVE: + { + var variableToSerialize = sendRef + "->value"; + FedNativePythonSerialization pickler = new FedNativePythonSerialization(); + lengthExpression = pickler.serializedBufferLength(); + pointerExpression = pickler.seializedBufferVar(); + result.pr(pickler.generateNetworkSerializerCode(variableToSerialize, null)); + result.pr("size_t message_length = " + lengthExpression + ";"); + result.pr(sendingFunction + "(" + commonArgs + ", " + pointerExpression + ");\n"); + break; } - case PROTO: { - throw new UnsupportedOperationException("Protbuf serialization is not supported yet."); + case PROTO: + { + throw new UnsupportedOperationException("Protbuf serialization is not supported yet."); } - case ROS2: { - throw new UnsupportedOperationException("ROS2 serialization is not supported yet."); - } - + case ROS2: + { + throw new UnsupportedOperationException("ROS2 serialization is not supported yet."); } } + } - @Override - public void annotateReaction(Reaction reaction) { - ASTUtils.addReactionAttribute(reaction, "_c_body"); - } + @Override + public void annotateReaction(Reaction reaction) { + ASTUtils.addReactionAttribute(reaction, "_c_body"); + } } diff --git a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java index 4a70f4cc6b..b52b739803 100644 --- a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java +++ b/org.lflang/src/org/lflang/federated/extensions/TSExtension.java @@ -6,12 +6,11 @@ import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetProperty.CoordinationType; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.federated.generator.FedASTUtils; import org.lflang.federated.generator.FedConnectionInstance; import org.lflang.federated.generator.FedFileConfig; @@ -27,73 +26,94 @@ import org.lflang.lf.Variable; public class TSExtension implements FedTargetExtension { - @Override - public void initializeTargetConfig(LFGeneratorContext context, int numOfFederates, FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter, RtiConfig rtiConfig) throws IOException { - - } + @Override + public void initializeTargetConfig( + LFGeneratorContext context, + int numOfFederates, + FederateInstance federate, + FedFileConfig fileConfig, + ErrorReporter errorReporter, + RtiConfig rtiConfig) + throws IOException {} - @Override - public String generateNetworkReceiverBody(Action action, VarRef sendingPort, VarRef receivingPort, FedConnectionInstance connection, InferredType type, CoordinationType coordinationType, ErrorReporter errorReporter) { - return """ + @Override + public String generateNetworkReceiverBody( + Action action, + VarRef sendingPort, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + CoordinationType coordinationType, + ErrorReporter errorReporter) { + return """ // generateNetworkReceiverBody if (%1$s !== undefined) { %2$s.%3$s = %1$s; } - """.formatted( + """ + .formatted( action.getName(), receivingPort.getContainer().getName(), - receivingPort.getVariable().getName() - ); - } + receivingPort.getVariable().getName()); + } - @Override - public String generateNetworkSenderBody(VarRef sendingPort, VarRef receivingPort, FedConnectionInstance connection, InferredType type, CoordinationType coordinationType, ErrorReporter errorReporter) { - return""" + @Override + public String generateNetworkSenderBody( + VarRef sendingPort, + VarRef receivingPort, + FedConnectionInstance connection, + InferredType type, + CoordinationType coordinationType, + ErrorReporter errorReporter) { + return """ if (%1$s.%2$s !== undefined) { this.util.sendRTITimedMessage(%1$s.%2$s, %3$s, %4$s, %5$s); } - """.formatted( + """ + .formatted( sendingPort.getContainer().getName(), sendingPort.getVariable().getName(), connection.getDstFederate().id, connection.getDstFederate().networkMessageActions.size(), - getNetworkDelayLiteral(connection.getDefinition().getDelay()) - ); - } + getNetworkDelayLiteral(connection.getDefinition().getDelay())); + } - private String getNetworkDelayLiteral(Expression e) { - var cLiteral = CExtensionUtils.getNetworkDelayLiteral(e); - return cLiteral.equals("NEVER") ? "0" : cLiteral; - } + private String getNetworkDelayLiteral(Expression e) { + var cLiteral = CExtensionUtils.getNetworkDelayLiteral(e); + return cLiteral.equals("NEVER") ? "0" : cLiteral; + } - @Override - public String generateNetworkInputControlReactionBody(int receivingPortID, TimeValue maxSTP, CoordinationType coordination) { - return "// TODO(hokeun): Figure out what to do for generateNetworkInputControlReactionBody"; - } + @Override + public String generateNetworkInputControlReactionBody( + int receivingPortID, TimeValue maxSTP, CoordinationType coordination) { + return "// TODO(hokeun): Figure out what to do for generateNetworkInputControlReactionBody"; + } - @Override - public String generateNetworkOutputControlReactionBody(VarRef srcOutputPort, FedConnectionInstance connection) { - return "// TODO(hokeun): Figure out what to do for generateNetworkOutputControlReactionBody"; - } + @Override + public String generateNetworkOutputControlReactionBody( + VarRef srcOutputPort, FedConnectionInstance connection) { + return "// TODO(hokeun): Figure out what to do for generateNetworkOutputControlReactionBody"; + } - @Override - public String getNetworkBufferType() { - return ""; - } + @Override + public String getNetworkBufferType() { + return ""; + } - /** - * Add necessary preamble to the source to set up federated execution. - * - * @return - */ - @Override - public String generatePreamble(FederateInstance federate, FedFileConfig fileConfig, - RtiConfig rtiConfig, - ErrorReporter errorReporter) { - var minOutputDelay = getMinOutputDelay(federate, fileConfig, errorReporter); - var upstreamConnectionDelays = getUpstreamConnectionDelays(federate); - return - """ + /** + * Add necessary preamble to the source to set up federated execution. + * + * @return + */ + @Override + public String generatePreamble( + FederateInstance federate, + FedFileConfig fileConfig, + RtiConfig rtiConfig, + ErrorReporter errorReporter) { + var minOutputDelay = getMinOutputDelay(federate, fileConfig, errorReporter); + var upstreamConnectionDelays = getUpstreamConnectionDelays(federate); + return """ const defaultFederateConfig: __FederateConfig = { dependsOn: [%s], executionTimeout: undefined, @@ -108,94 +128,101 @@ public String generatePreamble(FederateInstance federate, FedFileConfig fileConf sendsTo: [%s], upstreamConnectionDelays: [%s] } - """.formatted( + """ + .formatted( federate.dependsOn.keySet().stream() - .map(e->String.valueOf(e.id)) - .collect(Collectors.joining(",")), + .map(e -> String.valueOf(e.id)) + .collect(Collectors.joining(",")), federate.id, - minOutputDelay == null ? "undefined" - : "%s".formatted(TSTypes.getInstance().getTargetTimeExpr(minOutputDelay)), - federate.networkMessageActions - .stream() + minOutputDelay == null + ? "undefined" + : "%s".formatted(TSTypes.getInstance().getTargetTimeExpr(minOutputDelay)), + federate.networkMessageActions.stream() .map(Variable::getName) .collect(Collectors.joining(",", "\"", "\"")), rtiConfig.getHost(), rtiConfig.getPort(), federate.sendsTo.keySet().stream() - .map(e->String.valueOf(e.id)) - .collect(Collectors.joining(",")), - upstreamConnectionDelays.stream().collect(Collectors.joining(",")) - ); - } + .map(e -> String.valueOf(e.id)) + .collect(Collectors.joining(",")), + upstreamConnectionDelays.stream().collect(Collectors.joining(","))); + } - private TimeValue getMinOutputDelay(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { - if (federate.targetConfig.coordination.equals(CoordinationType.CENTRALIZED)) { - // If this program uses centralized coordination then check - // for outputs that depend on physical actions so that null messages can be - // sent to the RTI. - var federateClass = ASTUtils.toDefinition(federate.instantiation.getReactorClass()); - var main = new ReactorInstance(FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), errorReporter, 1); - var instance = new ReactorInstance(federateClass, main, errorReporter); - var outputDelayMap = federate - .findOutputsConnectedToPhysicalActions(instance); - var minOutputDelay = TimeValue.MAX_VALUE; - Output outputFound = null; - for (Output output : outputDelayMap.keySet()) { - var outputDelay = outputDelayMap.get(output); - if (outputDelay.isEarlierThan(minOutputDelay)) { - minOutputDelay = outputDelay; - outputFound = output; - } - } - if (minOutputDelay != TimeValue.MAX_VALUE) { - // Unless silenced, issue a warning. - if (federate.targetConfig.coordinationOptions.advance_message_interval - == null) { - errorReporter.reportWarning(outputFound, String.join("\n", - "Found a path from a physical action to output for reactor " - + addDoubleQuotes(instance.getName()) - + ". ", - "The amount of delay is " - + minOutputDelay - + ".", - "With centralized coordination, this can result in a large number of messages to the RTI.", - "Consider refactoring the code so that the output does not depend on the physical action,", - "or consider using decentralized coordination. To silence this warning, set the target", - "parameter coordination-options with a value like {advance-message-interval: 10 msec}" - )); - } - return minOutputDelay; - } + private TimeValue getMinOutputDelay( + FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + if (federate.targetConfig.coordination.equals(CoordinationType.CENTRALIZED)) { + // If this program uses centralized coordination then check + // for outputs that depend on physical actions so that null messages can be + // sent to the RTI. + var federateClass = ASTUtils.toDefinition(federate.instantiation.getReactorClass()); + var main = + new ReactorInstance( + FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), + errorReporter, + 1); + var instance = new ReactorInstance(federateClass, main, errorReporter); + var outputDelayMap = federate.findOutputsConnectedToPhysicalActions(instance); + var minOutputDelay = TimeValue.MAX_VALUE; + Output outputFound = null; + for (Output output : outputDelayMap.keySet()) { + var outputDelay = outputDelayMap.get(output); + if (outputDelay.isEarlierThan(minOutputDelay)) { + minOutputDelay = outputDelay; + outputFound = output; } - return null; + } + if (minOutputDelay != TimeValue.MAX_VALUE) { + // Unless silenced, issue a warning. + if (federate.targetConfig.coordinationOptions.advance_message_interval == null) { + errorReporter.reportWarning( + outputFound, + String.join( + "\n", + "Found a path from a physical action to output for reactor " + + addDoubleQuotes(instance.getName()) + + ". ", + "The amount of delay is " + minOutputDelay + ".", + "With centralized coordination, this can result in a large number of messages to" + + " the RTI.", + "Consider refactoring the code so that the output does not depend on the physical" + + " action,", + "or consider using decentralized coordination. To silence this warning, set the" + + " target", + "parameter coordination-options with a value like {advance-message-interval: 10" + + " msec}")); + } + return minOutputDelay; + } } + return null; + } - private List getUpstreamConnectionDelays(FederateInstance federate) { - List candidates = new ArrayList<>(); - if (!federate.dependsOn.keySet().isEmpty()) { - for (FederateInstance upstreamFederate: federate.dependsOn.keySet()) { - String element = "["; - var delays = federate.dependsOn.get(upstreamFederate); - int cnt = 0; - if (delays != null) { - for (Expression delay : delays) { - if (delay == null) { - element += "TimeValue.NEVER()"; - } else { - element += "TimeValue.nsec(" + getNetworkDelayLiteral(delay) + ")"; - } - cnt++; - if (cnt != delays.size()) { - element += ", "; - } - } - } else { - element += "TimeValue.NEVER()"; - } - element += "]"; - candidates.add(element); + private List getUpstreamConnectionDelays(FederateInstance federate) { + List candidates = new ArrayList<>(); + if (!federate.dependsOn.keySet().isEmpty()) { + for (FederateInstance upstreamFederate : federate.dependsOn.keySet()) { + String element = "["; + var delays = federate.dependsOn.get(upstreamFederate); + int cnt = 0; + if (delays != null) { + for (Expression delay : delays) { + if (delay == null) { + element += "TimeValue.NEVER()"; + } else { + element += "TimeValue.nsec(" + getNetworkDelayLiteral(delay) + ")"; + } + cnt++; + if (cnt != delays.size()) { + element += ", "; } + } + } else { + element += "TimeValue.NEVER()"; } - return candidates; + element += "]"; + candidates.add(element); + } } + return candidates; + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java b/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java index cedb9da017..338fbff242 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java +++ b/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java @@ -27,6 +27,7 @@ package org.lflang.federated.generator; +import com.google.common.collect.Iterators; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; @@ -38,17 +39,15 @@ import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.xtext.xbase.lib.IteratorExtensions; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.ModelInfo; import org.lflang.TargetProperty.CoordinationType; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.federated.extensions.FedTargetExtensionFactory; import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.generator.PortInstance; @@ -68,795 +67,740 @@ import org.lflang.lf.VarRef; import org.lflang.lf.Variable; -import com.google.common.collect.Iterators; - /** - * A helper class for AST transformations needed for federated - * execution. + * A helper class for AST transformations needed for federated execution. * * @author Soroush Bateni * @author Edward A. Lee */ public class FedASTUtils { - /** - * Map from reactions to bank indices - */ - private static Map reactionBankIndices = null; - - /** - * Mark the specified reaction to belong to only the specified - * bank index. This is needed because reactions cannot declare - * a specific bank index as an effect or trigger. Reactions that - * send messages between federates, including absent messages, - * need to be specific to a bank member. - * @param reaction The reaction. - * @param bankIndex The bank index, or -1 if there is no bank. - */ - public static void setReactionBankIndex(Reaction reaction, int bankIndex) { - if (bankIndex < 0) { - return; - } - if (reactionBankIndices == null) { - reactionBankIndices = new LinkedHashMap<>(); - } - reactionBankIndices.put(reaction, bankIndex); + /** Map from reactions to bank indices */ + private static Map reactionBankIndices = null; + + /** + * Mark the specified reaction to belong to only the specified bank index. This is needed because + * reactions cannot declare a specific bank index as an effect or trigger. Reactions that send + * messages between federates, including absent messages, need to be specific to a bank member. + * + * @param reaction The reaction. + * @param bankIndex The bank index, or -1 if there is no bank. + */ + public static void setReactionBankIndex(Reaction reaction, int bankIndex) { + if (bankIndex < 0) { + return; } - - /** - * Return the reaction bank index. - * @see #setReactionBankIndex(Reaction reaction, int bankIndex) - * @param reaction The reaction. - * @return The reaction bank index, if one has been set, and -1 otherwise. - */ - public static int getReactionBankIndex(Reaction reaction) { - if (reactionBankIndices == null) return -1; - if (reactionBankIndices.get(reaction) == null) return -1; - return reactionBankIndices.get(reaction); - } - - /** - * Find the federated reactor in a .lf file. - * - * @param resource Resource representing a .lf file. - * @return The federated reactor if found. - */ - public static Reactor findFederatedReactor(Resource resource) { - return IteratorExtensions.findFirst( - Iterators.filter(resource.getAllContents(), Reactor.class), - Reactor::isFederated - ); + if (reactionBankIndices == null) { + reactionBankIndices = new LinkedHashMap<>(); } - - /** - * Replace the specified connection with communication between federates. - * - * @param connection Network connection between two federates. - * @param coordination One of CoordinationType.DECENTRALIZED or - * CoordinationType.CENTRALIZED. - * @param errorReporter Used to report errors encountered. - */ - public static void makeCommunication( - FedConnectionInstance connection, - CoordinationType coordination, - ErrorReporter errorReporter + reactionBankIndices.put(reaction, bankIndex); + } + + /** + * Return the reaction bank index. + * + * @see #setReactionBankIndex(Reaction reaction, int bankIndex) + * @param reaction The reaction. + * @return The reaction bank index, if one has been set, and -1 otherwise. + */ + public static int getReactionBankIndex(Reaction reaction) { + if (reactionBankIndices == null) return -1; + if (reactionBankIndices.get(reaction) == null) return -1; + return reactionBankIndices.get(reaction); + } + + /** + * Find the federated reactor in a .lf file. + * + * @param resource Resource representing a .lf file. + * @return The federated reactor if found. + */ + public static Reactor findFederatedReactor(Resource resource) { + return IteratorExtensions.findFirst( + Iterators.filter(resource.getAllContents(), Reactor.class), Reactor::isFederated); + } + + /** + * Replace the specified connection with communication between federates. + * + * @param connection Network connection between two federates. + * @param coordination One of CoordinationType.DECENTRALIZED or CoordinationType.CENTRALIZED. + * @param errorReporter Used to report errors encountered. + */ + public static void makeCommunication( + FedConnectionInstance connection, + CoordinationType coordination, + ErrorReporter errorReporter) { + + // Add the sender reaction. + addNetworkSenderReaction(connection, coordination, errorReporter); + + // Next, generate control reactions + if (!connection.getDefinition().isPhysical() + && + // Connections that are physical don't need control reactions + connection.getDefinition().getDelay() + == null // Connections that have delays don't need control reactions ) { + // Add the network output control reaction to the parent + FedASTUtils.addNetworkOutputControlReaction(connection); - // Add the sender reaction. - addNetworkSenderReaction( - connection, - coordination, - errorReporter - ); - - // Next, generate control reactions - if ( - !connection.getDefinition().isPhysical() && - // Connections that are physical don't need control reactions - connection.getDefinition().getDelay() - == null // Connections that have delays don't need control reactions - ) { - // Add the network output control reaction to the parent - FedASTUtils.addNetworkOutputControlReaction(connection); - - // Add the network input control reaction to the parent - FedASTUtils.addNetworkInputControlReaction(connection, coordination, errorReporter); - } - - // Create the network action (@see createNetworkAction) - Action networkAction = createNetworkAction(connection); - - // Keep track of this action in the destination federate. - connection.dstFederate.networkMessageActions.add(networkAction); - - // Add the action definition to the parent reactor. - ((Reactor) connection.getDefinition().eContainer()).getActions().add(networkAction); - - // Add the network receiver reaction in the destinationFederate - addNetworkReceiverReaction( - networkAction, - connection, - coordination, - errorReporter - ); + // Add the network input control reaction to the parent + FedASTUtils.addNetworkInputControlReaction(connection, coordination, errorReporter); } - /** - * Create a "network action" in the reactor that contains the given - * connection and return it. - * - * The purpose of this action is to serve as a trigger for a "network - * input reaction" that is responsible for relaying messages to the - * port that is on the receiving side of the given connection. The - * connection is assumed to be between two reactors that reside in - * distinct federates. Hence, the container of the connection is - * assumed to be top-level. - * - * @param connection A connection between two federates - * @return The newly created action. - */ - private static Action createNetworkAction(FedConnectionInstance connection) { - Reactor top = (Reactor) connection.getDefinition().eContainer(); - LfFactory factory = LfFactory.eINSTANCE; - - Action action = factory.createAction(); - // Name the newly created action; set its delay and type. - action.setName(ASTUtils.getUniqueIdentifier(top, "networkMessage")); - if (connection.serializer == SupportedSerializers.NATIVE) { - action.setType(EcoreUtil.copy(connection.getSourcePortInstance().getDefinition().getType())); - } else { - Type action_type = factory.createType(); - action_type.setId( - FedTargetExtensionFactory.getExtension( - connection.srcFederate.targetConfig.target - ).getNetworkBufferType() - ); - action.setType(action_type); - } - - // The connection is 'physical' if it uses the ~> notation. - if (connection.getDefinition().isPhysical()) { - action.setOrigin(ActionOrigin.PHYSICAL); - // Messages sent on physical connections do not - // carry a timestamp, or a delay. The delay - // provided using after is enforced by setting - // the minDelay. - if (connection.getDefinition().getDelay() != null) { - action.setMinDelay(connection.getDefinition().getDelay()); - } - } else { - action.setOrigin(ActionOrigin.LOGICAL); - } + // Create the network action (@see createNetworkAction) + Action networkAction = createNetworkAction(connection); + + // Keep track of this action in the destination federate. + connection.dstFederate.networkMessageActions.add(networkAction); + + // Add the action definition to the parent reactor. + ((Reactor) connection.getDefinition().eContainer()).getActions().add(networkAction); + + // Add the network receiver reaction in the destinationFederate + addNetworkReceiverReaction(networkAction, connection, coordination, errorReporter); + } + + /** + * Create a "network action" in the reactor that contains the given connection and return it. + * + *

    The purpose of this action is to serve as a trigger for a "network input reaction" that is + * responsible for relaying messages to the port that is on the receiving side of the given + * connection. The connection is assumed to be between two reactors that reside in distinct + * federates. Hence, the container of the connection is assumed to be top-level. + * + * @param connection A connection between two federates + * @return The newly created action. + */ + private static Action createNetworkAction(FedConnectionInstance connection) { + Reactor top = (Reactor) connection.getDefinition().eContainer(); + LfFactory factory = LfFactory.eINSTANCE; + + Action action = factory.createAction(); + // Name the newly created action; set its delay and type. + action.setName(ASTUtils.getUniqueIdentifier(top, "networkMessage")); + if (connection.serializer == SupportedSerializers.NATIVE) { + action.setType(EcoreUtil.copy(connection.getSourcePortInstance().getDefinition().getType())); + } else { + Type action_type = factory.createType(); + action_type.setId( + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) + .getNetworkBufferType()); + action.setType(action_type); + } - return action; + // The connection is 'physical' if it uses the ~> notation. + if (connection.getDefinition().isPhysical()) { + action.setOrigin(ActionOrigin.PHYSICAL); + // Messages sent on physical connections do not + // carry a timestamp, or a delay. The delay + // provided using after is enforced by setting + // the minDelay. + if (connection.getDefinition().getDelay() != null) { + action.setMinDelay(connection.getDefinition().getDelay()); + } + } else { + action.setOrigin(ActionOrigin.LOGICAL); } - /** - * Add a network receiver reaction for a given input port 'destination' to - * destination's parent reactor. This reaction will react to a generated - * 'networkAction' (triggered asynchronously, e.g., by federate.c). This - * 'networkAction' will contain the actual message that is sent by the - * sender - * in 'action->value'. This value is forwarded to 'destination' in the - * network - * receiver reaction. - * - * @param networkAction The network action (also, @see createNetworkAction) - * @param connection FIXME - * @param coordination One of CoordinationType.DECENTRALIZED or - * CoordinationType.CENTRALIZED. - * @note: Used in federated execution - */ - private static void addNetworkReceiverReaction( - Action networkAction, - FedConnectionInstance connection, - CoordinationType coordination, - ErrorReporter errorReporter - ) { - LfFactory factory = LfFactory.eINSTANCE; - VarRef sourceRef = factory.createVarRef(); - VarRef destRef = factory.createVarRef(); - Reactor parent = (Reactor) connection.getDefinition().eContainer(); - Reaction networkReceiverReaction = factory.createReaction(); - - // If the sender or receiver is in a bank of reactors, then we want - // these reactions to appear only in the federate whose bank ID matches. - setReactionBankIndex(networkReceiverReaction, connection.getDstBank()); - - // FIXME: do not create a new extension every time it is used - FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) - .annotateReaction(networkReceiverReaction); - - // The connection is 'physical' if it uses the ~> notation. - if (connection.getDefinition().isPhysical()) { - connection.dstFederate.inboundP2PConnections.add(connection.srcFederate); - } else { - // If the connection is logical but coordination - // is decentralized, we would need - // to make P2P connections - if (coordination == CoordinationType.DECENTRALIZED) { - connection.dstFederate.inboundP2PConnections.add(connection.srcFederate); - } - } + return action; + } + + /** + * Add a network receiver reaction for a given input port 'destination' to destination's parent + * reactor. This reaction will react to a generated 'networkAction' (triggered asynchronously, + * e.g., by federate.c). This 'networkAction' will contain the actual message that is sent by the + * sender in 'action->value'. This value is forwarded to 'destination' in the network receiver + * reaction. + * + * @param networkAction The network action (also, @see createNetworkAction) + * @param connection FIXME + * @param coordination One of CoordinationType.DECENTRALIZED or CoordinationType.CENTRALIZED. + * @note: Used in federated execution + */ + private static void addNetworkReceiverReaction( + Action networkAction, + FedConnectionInstance connection, + CoordinationType coordination, + ErrorReporter errorReporter) { + LfFactory factory = LfFactory.eINSTANCE; + VarRef sourceRef = factory.createVarRef(); + VarRef destRef = factory.createVarRef(); + Reactor parent = (Reactor) connection.getDefinition().eContainer(); + Reaction networkReceiverReaction = factory.createReaction(); + + // If the sender or receiver is in a bank of reactors, then we want + // these reactions to appear only in the federate whose bank ID matches. + setReactionBankIndex(networkReceiverReaction, connection.getDstBank()); + + // FIXME: do not create a new extension every time it is used + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) + .annotateReaction(networkReceiverReaction); + + // The connection is 'physical' if it uses the ~> notation. + if (connection.getDefinition().isPhysical()) { + connection.dstFederate.inboundP2PConnections.add(connection.srcFederate); + } else { + // If the connection is logical but coordination + // is decentralized, we would need + // to make P2P connections + if (coordination == CoordinationType.DECENTRALIZED) { + connection.dstFederate.inboundP2PConnections.add(connection.srcFederate); + } + } - // Establish references to the involved ports. - sourceRef.setContainer(connection.getSourcePortInstance().getParent().getDefinition()); - sourceRef.setVariable(connection.getSourcePortInstance().getDefinition()); - destRef.setContainer(connection.getDestinationPortInstance().getParent().getDefinition()); - destRef.setVariable(connection.getDestinationPortInstance().getDefinition()); - - // Add the input port at the receiver federate reactor as an effect - networkReceiverReaction.getEffects().add(destRef); - - VarRef triggerRef = factory.createVarRef(); - // Establish references to the action. - triggerRef.setVariable(networkAction); - // Add the action as a trigger to the receiver reaction - networkReceiverReaction.getTriggers().add(triggerRef); - - // Generate code for the network receiver reaction - networkReceiverReaction.setCode(factory.createCode()); - networkReceiverReaction.getCode().setBody( - FedTargetExtensionFactory.getExtension( - connection.dstFederate.targetConfig.target).generateNetworkReceiverBody( + // Establish references to the involved ports. + sourceRef.setContainer(connection.getSourcePortInstance().getParent().getDefinition()); + sourceRef.setVariable(connection.getSourcePortInstance().getDefinition()); + destRef.setContainer(connection.getDestinationPortInstance().getParent().getDefinition()); + destRef.setVariable(connection.getDestinationPortInstance().getDefinition()); + + // Add the input port at the receiver federate reactor as an effect + networkReceiverReaction.getEffects().add(destRef); + + VarRef triggerRef = factory.createVarRef(); + // Establish references to the action. + triggerRef.setVariable(networkAction); + // Add the action as a trigger to the receiver reaction + networkReceiverReaction.getTriggers().add(triggerRef); + + // Generate code for the network receiver reaction + networkReceiverReaction.setCode(factory.createCode()); + networkReceiverReaction + .getCode() + .setBody( + FedTargetExtensionFactory.getExtension(connection.dstFederate.targetConfig.target) + .generateNetworkReceiverBody( networkAction, sourceRef, destRef, connection, ASTUtils.getInferredType(networkAction), coordination, - errorReporter - )); - - - ASTUtils.addReactionAttribute(networkReceiverReaction, "_unordered"); - - // Add the receiver reaction to the parent - parent.getReactions().add(networkReceiverReaction); - - // Add the network receiver reaction to the federate instance's list - // of network reactions - connection.dstFederate.networkReactions.add(networkReceiverReaction); - - - if ( - !connection.getDefinition().isPhysical() && - // Connections that are physical don't need control reactions - connection.getDefinition().getDelay() - == null // Connections that have delays don't need control reactions - ) { - // Add necessary dependencies to reaction to ensure that it executes correctly - // relative to other network input control reactions in the federate. - addRelativeDependency(connection, networkReceiverReaction, errorReporter); - } - } + errorReporter)); - /** - * Add a network control reaction for a given input port 'destination' to - * destination's parent reactor. This reaction will block for - * any valid logical time until it is known whether the trigger for the - * action corresponding to the given port is present or absent. - * - * @param connection FIXME - * @param coordination FIXME - * @param errorReporter - * @note Used in federated execution - */ - private static void addNetworkInputControlReaction( - FedConnectionInstance connection, - CoordinationType coordination, - ErrorReporter errorReporter) { - - LfFactory factory = LfFactory.eINSTANCE; - Reaction reaction = factory.createReaction(); - VarRef destRef = factory.createVarRef(); - int receivingPortID = connection.dstFederate.networkMessageActions.size(); - - // If the sender or receiver is in a bank of reactors, then we want - // these reactions to appear only in the federate whose bank ID matches. - setReactionBankIndex(reaction, connection.getDstBank()); - - // FIXME: do not create a new extension every time it is used - FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) - .annotateReaction(reaction); - - // Create a new action that will be used to trigger the - // input control reactions. - Action newTriggerForControlReactionInput = factory.createAction(); - newTriggerForControlReactionInput.setOrigin(ActionOrigin.LOGICAL); - - // Set the container and variable according to the network port - destRef.setContainer(connection.getDestinationPortInstance().getParent().getDefinition()); - destRef.setVariable(connection.getDestinationPortInstance().getDefinition()); - - Reactor top = connection.getDestinationPortInstance() - .getParent() - .getParent().reactorDefinition; - - newTriggerForControlReactionInput.setName( - ASTUtils.getUniqueIdentifier(top, "inputControlReactionTrigger")); - - // Add the newly created Action to the action list of the federated reactor. - top.getActions().add(newTriggerForControlReactionInput); - - // Create the trigger for the reaction - VarRef newTriggerForControlReaction = factory.createVarRef(); - newTriggerForControlReaction.setVariable(newTriggerForControlReactionInput); - - // Add the appropriate triggers to the list of triggers of the reaction - reaction.getTriggers().add(newTriggerForControlReaction); - - // Add the destination port as an effect of the reaction - reaction.getEffects().add(destRef); - - // Generate code for the network input control reaction - reaction.setCode(factory.createCode()); - - TimeValue maxSTP = findMaxSTP(connection, coordination); - - reaction.getCode() - .setBody( - FedTargetExtensionFactory - .getExtension(connection.dstFederate.targetConfig.target) - .generateNetworkInputControlReactionBody( - receivingPortID, - maxSTP, - coordination - ) - ); - - ASTUtils.addReactionAttribute(reaction, "_unordered"); - - // Insert the reaction - top.getReactions().add(reaction); - - // Add the trigger for this reaction to the list of triggers, used to actually - // trigger the reaction at the beginning of each logical time. - connection.dstFederate.networkInputControlReactionsTriggers.add(newTriggerForControlReactionInput); - - // Add the network input control reaction to the federate instance's list - // of network reactions - connection.dstFederate.networkReactions.add(reaction); - - // Add necessary dependencies to reaction to ensure that it executes correctly - // relative to other network input control reactions in the federate. - addRelativeDependency(connection, reaction, errorReporter); - } + ASTUtils.addReactionAttribute(networkReceiverReaction, "_unordered"); - /** - * Add necessary dependency information to the signature of {@code networkInputReaction} so that - * it can execute in the correct order relative to other network reactions in the federate. - * - * In particular, we want to avoid a deadlock if multiple network input control reactions in federate - * are in a zero-delay cycle through other federates in the federation. To avoid the deadlock, we encode the - * zero-delay cycle inside the federate by adding an artificial dependency from the output port of this federate - * that is involved in the cycle to the signature of {@code networkInputReaction} as a source. - */ - private static void addRelativeDependency( - FedConnectionInstance connection, - Reaction networkInputReaction, - ErrorReporter errorReporter) { - var upstreamOutputPortsInFederate = - findUpstreamPortsInFederate( - connection.dstFederate, - connection.getSourcePortInstance(), - new HashSet<>(), - new HashSet<>() - ); - - ModelInfo info = new ModelInfo(); - for (var port: upstreamOutputPortsInFederate) { - VarRef sourceRef = ASTUtils.factory.createVarRef(); - - sourceRef.setContainer(port.getParent().getDefinition()); - sourceRef.setVariable(port.getDefinition()); - networkInputReaction.getSources().add(sourceRef); - - // Remove the port if it introduces cycles - info.update( - (Model)networkInputReaction.eContainer().eContainer(), - errorReporter - ); - if (!info.topologyCycles().isEmpty()) { - networkInputReaction.getSources().remove(sourceRef); - } - } + // Add the receiver reaction to the parent + parent.getReactions().add(networkReceiverReaction); - } + // Add the network receiver reaction to the federate instance's list + // of network reactions + connection.dstFederate.networkReactions.add(networkReceiverReaction); - /** - * Go upstream from input port {@code port} until we reach one or more output - * ports that belong to the same federate. - * - * Along the path, we follow direct connections, as well as reactions, as long - * as there is no logical delay. When following reactions, we also follow - * dependant reactions (because we are traversing a potential cycle backwards). - * - * @return A set of {@link PortInstance}. If no port exist that match the - * criteria, return an empty set. - */ - private static Set findUpstreamPortsInFederate( - FederateInstance federate, - PortInstance port, - Set visitedPorts, - Set reactionVisited + if (!connection.getDefinition().isPhysical() + && + // Connections that are physical don't need control reactions + connection.getDefinition().getDelay() + == null // Connections that have delays don't need control reactions ) { - Set toReturn = new HashSet<>(); - if (port == null) return toReturn; - else if (federate.contains(port.getParent())) { - // Reached the requested federate - toReturn.add(port); - visitedPorts.add(port); - } else if (visitedPorts.contains(port)) { - return toReturn; - } else { - visitedPorts.add(port); - // Follow depends on reactions - port.getDependsOnReactions().forEach( - reaction -> { - followReactionUpstream(federate, visitedPorts, toReturn, reaction, reactionVisited); - } - ); - // Follow depends on ports - port.getDependsOnPorts().forEach( - it -> toReturn.addAll( - findUpstreamPortsInFederate(federate, it.instance, visitedPorts, reactionVisited) - ) - ); - } - return toReturn; + // Add necessary dependencies to reaction to ensure that it executes correctly + // relative to other network input control reactions in the federate. + addRelativeDependency(connection, networkReceiverReaction, errorReporter); } - - /** - * Follow reactions upstream. This is part of the algorithm of - * {@link #findUpstreamPortsInFederate(FederateInstance, PortInstance, Set)}. - */ - private static void followReactionUpstream( - FederateInstance federate, - Set visitedPorts, - Set toReturn, - ReactionInstance reaction, - Set reactionVisited - ) { - if (reactionVisited.contains(reaction)) return; - reactionVisited.add(reaction); - // Add triggers - Set varRefsToFollow = new HashSet<>(); - varRefsToFollow.addAll( - reaction.getDefinition() - .getTriggers() - .stream() - .filter( - trigger -> !(trigger instanceof BuiltinTriggerRef) - ) - .map(VarRef.class::cast).toList()); - // Add sources - varRefsToFollow.addAll(reaction.getDefinition().getSources()); - - // Follow everything upstream - varRefsToFollow.forEach( - varRef -> - toReturn.addAll( - findUpstreamPortsInFederate( - federate, - reaction.getParent() - .lookupPortInstance(varRef), - visitedPorts, - reactionVisited - ) - ) - ); - - reaction.dependsOnReactions() - .stream() - .filter( - // Stay within the reactor - it -> it.getParent().equals(reaction.getParent()) - ) - .forEach( - it -> followReactionUpstream(federate, visitedPorts, toReturn, it, reactionVisited) - ); - - // FIXME: This is most certainly wrong. Please fix it. - reaction.dependentReactions() - .stream() - .filter( - // Stay within the reactor - it -> it.getParent().equals(reaction.getParent()) - ) - .forEach( - it -> followReactionUpstream(federate, visitedPorts, toReturn, it, reactionVisited) - ); + } + + /** + * Add a network control reaction for a given input port 'destination' to destination's parent + * reactor. This reaction will block for any valid logical time until it is known whether the + * trigger for the action corresponding to the given port is present or absent. + * + * @param connection FIXME + * @param coordination FIXME + * @param errorReporter + * @note Used in federated execution + */ + private static void addNetworkInputControlReaction( + FedConnectionInstance connection, + CoordinationType coordination, + ErrorReporter errorReporter) { + + LfFactory factory = LfFactory.eINSTANCE; + Reaction reaction = factory.createReaction(); + VarRef destRef = factory.createVarRef(); + int receivingPortID = connection.dstFederate.networkMessageActions.size(); + + // If the sender or receiver is in a bank of reactors, then we want + // these reactions to appear only in the federate whose bank ID matches. + setReactionBankIndex(reaction, connection.getDstBank()); + + // FIXME: do not create a new extension every time it is used + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) + .annotateReaction(reaction); + + // Create a new action that will be used to trigger the + // input control reactions. + Action newTriggerForControlReactionInput = factory.createAction(); + newTriggerForControlReactionInput.setOrigin(ActionOrigin.LOGICAL); + + // Set the container and variable according to the network port + destRef.setContainer(connection.getDestinationPortInstance().getParent().getDefinition()); + destRef.setVariable(connection.getDestinationPortInstance().getDefinition()); + + Reactor top = connection.getDestinationPortInstance().getParent().getParent().reactorDefinition; + + newTriggerForControlReactionInput.setName( + ASTUtils.getUniqueIdentifier(top, "inputControlReactionTrigger")); + + // Add the newly created Action to the action list of the federated reactor. + top.getActions().add(newTriggerForControlReactionInput); + + // Create the trigger for the reaction + VarRef newTriggerForControlReaction = factory.createVarRef(); + newTriggerForControlReaction.setVariable(newTriggerForControlReactionInput); + + // Add the appropriate triggers to the list of triggers of the reaction + reaction.getTriggers().add(newTriggerForControlReaction); + + // Add the destination port as an effect of the reaction + reaction.getEffects().add(destRef); + + // Generate code for the network input control reaction + reaction.setCode(factory.createCode()); + + TimeValue maxSTP = findMaxSTP(connection, coordination); + + reaction + .getCode() + .setBody( + FedTargetExtensionFactory.getExtension(connection.dstFederate.targetConfig.target) + .generateNetworkInputControlReactionBody(receivingPortID, maxSTP, coordination)); + + ASTUtils.addReactionAttribute(reaction, "_unordered"); + + // Insert the reaction + top.getReactions().add(reaction); + + // Add the trigger for this reaction to the list of triggers, used to actually + // trigger the reaction at the beginning of each logical time. + connection.dstFederate.networkInputControlReactionsTriggers.add( + newTriggerForControlReactionInput); + + // Add the network input control reaction to the federate instance's list + // of network reactions + connection.dstFederate.networkReactions.add(reaction); + + // Add necessary dependencies to reaction to ensure that it executes correctly + // relative to other network input control reactions in the federate. + addRelativeDependency(connection, reaction, errorReporter); + } + + /** + * Add necessary dependency information to the signature of {@code networkInputReaction} so that + * it can execute in the correct order relative to other network reactions in the federate. + * + *

    In particular, we want to avoid a deadlock if multiple network input control reactions in + * federate are in a zero-delay cycle through other federates in the federation. To avoid the + * deadlock, we encode the zero-delay cycle inside the federate by adding an artificial dependency + * from the output port of this federate that is involved in the cycle to the signature of {@code + * networkInputReaction} as a source. + */ + private static void addRelativeDependency( + FedConnectionInstance connection, + Reaction networkInputReaction, + ErrorReporter errorReporter) { + var upstreamOutputPortsInFederate = + findUpstreamPortsInFederate( + connection.dstFederate, + connection.getSourcePortInstance(), + new HashSet<>(), + new HashSet<>()); + + ModelInfo info = new ModelInfo(); + for (var port : upstreamOutputPortsInFederate) { + VarRef sourceRef = ASTUtils.factory.createVarRef(); + + sourceRef.setContainer(port.getParent().getDefinition()); + sourceRef.setVariable(port.getDefinition()); + networkInputReaction.getSources().add(sourceRef); + + // Remove the port if it introduces cycles + info.update((Model) networkInputReaction.eContainer().eContainer(), errorReporter); + if (!info.topologyCycles().isEmpty()) { + networkInputReaction.getSources().remove(sourceRef); + } } - - /** - * Find the maximum STP offset for the given 'port'. - * - * An STP offset predicate can be nested in contained reactors in - * the federate. - * - * @param connection The connection to find the max STP offset for. - * @param coordination The coordination scheme. - * @return The maximum STP as a TimeValue - */ - private static TimeValue findMaxSTP(FedConnectionInstance connection, - CoordinationType coordination) { - Variable port = connection.getDestinationPortInstance().getDefinition(); - FederateInstance instance = connection.dstFederate; - Reactor reactor = connection.getDestinationPortInstance().getParent().reactorDefinition; - - // Find a list of STP offsets (if any exists) - List STPList = new LinkedList<>(); - - // First, check if there are any connections to contained reactors that - // need to be handled - List connectionsWithPort = ASTUtils - .allConnections(reactor).stream().filter(c -> c.getLeftPorts() - .stream() - .anyMatch((VarRef v) -> v - .getVariable().equals(port))) + } + + /** + * Go upstream from input port {@code port} until we reach one or more output ports that belong to + * the same federate. + * + *

    Along the path, we follow direct connections, as well as reactions, as long as there is no + * logical delay. When following reactions, we also follow dependant reactions (because we are + * traversing a potential cycle backwards). + * + * @return A set of {@link PortInstance}. If no port exist that match the criteria, return an + * empty set. + */ + private static Set findUpstreamPortsInFederate( + FederateInstance federate, + PortInstance port, + Set visitedPorts, + Set reactionVisited) { + Set toReturn = new HashSet<>(); + if (port == null) return toReturn; + else if (federate.contains(port.getParent())) { + // Reached the requested federate + toReturn.add(port); + visitedPorts.add(port); + } else if (visitedPorts.contains(port)) { + return toReturn; + } else { + visitedPorts.add(port); + // Follow depends on reactions + port.getDependsOnReactions() + .forEach( + reaction -> { + followReactionUpstream(federate, visitedPorts, toReturn, reaction, reactionVisited); + }); + // Follow depends on ports + port.getDependsOnPorts() + .forEach( + it -> + toReturn.addAll( + findUpstreamPortsInFederate( + federate, it.instance, visitedPorts, reactionVisited))); + } + return toReturn; + } + + /** + * Follow reactions upstream. This is part of the algorithm of {@link + * #findUpstreamPortsInFederate(FederateInstance, PortInstance, Set)}. + */ + private static void followReactionUpstream( + FederateInstance federate, + Set visitedPorts, + Set toReturn, + ReactionInstance reaction, + Set reactionVisited) { + if (reactionVisited.contains(reaction)) return; + reactionVisited.add(reaction); + // Add triggers + Set varRefsToFollow = new HashSet<>(); + varRefsToFollow.addAll( + reaction.getDefinition().getTriggers().stream() + .filter(trigger -> !(trigger instanceof BuiltinTriggerRef)) + .map(VarRef.class::cast) + .toList()); + // Add sources + varRefsToFollow.addAll(reaction.getDefinition().getSources()); + + // Follow everything upstream + varRefsToFollow.forEach( + varRef -> + toReturn.addAll( + findUpstreamPortsInFederate( + federate, + reaction.getParent().lookupPortInstance(varRef), + visitedPorts, + reactionVisited))); + + reaction.dependsOnReactions().stream() + .filter( + // Stay within the reactor + it -> it.getParent().equals(reaction.getParent())) + .forEach( + it -> followReactionUpstream(federate, visitedPorts, toReturn, it, reactionVisited)); + + // FIXME: This is most certainly wrong. Please fix it. + reaction.dependentReactions().stream() + .filter( + // Stay within the reactor + it -> it.getParent().equals(reaction.getParent())) + .forEach( + it -> followReactionUpstream(federate, visitedPorts, toReturn, it, reactionVisited)); + } + + /** + * Find the maximum STP offset for the given 'port'. + * + *

    An STP offset predicate can be nested in contained reactors in the federate. + * + * @param connection The connection to find the max STP offset for. + * @param coordination The coordination scheme. + * @return The maximum STP as a TimeValue + */ + private static TimeValue findMaxSTP( + FedConnectionInstance connection, CoordinationType coordination) { + Variable port = connection.getDestinationPortInstance().getDefinition(); + FederateInstance instance = connection.dstFederate; + Reactor reactor = connection.getDestinationPortInstance().getParent().reactorDefinition; + + // Find a list of STP offsets (if any exists) + List STPList = new LinkedList<>(); + + // First, check if there are any connections to contained reactors that + // need to be handled + List connectionsWithPort = + ASTUtils.allConnections(reactor).stream() + .filter( + c -> c.getLeftPorts().stream().anyMatch((VarRef v) -> v.getVariable().equals(port))) .collect(Collectors.toList()); + // Find the list of reactions that have the port as trigger or source + // (could be a variable name) + List reactionsWithPort = + ASTUtils.allReactions(reactor).stream() + .filter( + r -> { + // Check the triggers of reaction r first + return r.getTriggers().stream() + .anyMatch( + t -> { + if (t instanceof VarRef) { + // Check if the variables match + return ((VarRef) t).getVariable() == port; + } else { + // Not a network port (startup or shutdown) + return false; + } + }) + || // Then check the sources of reaction r + r.getSources().stream().anyMatch(s -> s.getVariable() == port); + }) + .collect(Collectors.toList()); - // Find the list of reactions that have the port as trigger or source - // (could be a variable name) - List reactionsWithPort = ASTUtils - .allReactions(reactor).stream().filter(r -> { - // Check the triggers of reaction r first - return r.getTriggers().stream().anyMatch(t -> { - if (t instanceof VarRef) { - // Check if the variables match - return ((VarRef) t).getVariable() == port; - } else { - // Not a network port (startup or shutdown) - return false; - } - }) || // Then check the sources of reaction r - r.getSources().stream().anyMatch(s -> s.getVariable() - == port); - }).collect(Collectors.toList()); - - // Find a list of STP offsets (if any exists) - if (coordination == CoordinationType.DECENTRALIZED) { - for (Reaction r : safe(reactionsWithPort)) { - // If STP offset is determined, add it - // If not, assume it is zero - if (r.getStp() != null) { - if (r.getStp().getValue() instanceof ParameterReference) { - List instantList = new ArrayList<>(); - instantList.add(instance.instantiation); - final var param = ((ParameterReference) r.getStp().getValue()).getParameter(); - STPList.addAll(ASTUtils.initialValue(param, instantList)); - } else { - STPList.add(r.getStp().getValue()); - } - } - } - // Check the children for STPs as well - for (Connection c : safe(connectionsWithPort)) { - VarRef childPort = c.getRightPorts().get(0); - Reactor childReactor = (Reactor) childPort.getVariable() - .eContainer(); - // Find the list of reactions that have the port as trigger or - // source (could be a variable name) - List childReactionsWithPort = - ASTUtils.allReactions(childReactor) - .stream() - .filter(r -> - r.getTriggers().stream().anyMatch(t -> { - if (t instanceof VarRef) { - // Check if the variables match - return - ((VarRef) t).getVariable() - == childPort.getVariable(); - } else { - // Not a network port (startup or shutdown) - return false; - } - }) || - r.getSources() - .stream() - .anyMatch(s -> - s.getVariable() - == childPort.getVariable()) - ).collect(Collectors.toList()); - - for (Reaction r : safe(childReactionsWithPort)) { - // If STP offset is determined, add it - // If not, assume it is zero - if (r.getStp() != null) { - if (r.getStp().getValue() instanceof ParameterReference) { - List instantList = new ArrayList<>(); - instantList.add(childPort.getContainer()); - final var param = ((ParameterReference) r.getStp().getValue()).getParameter(); - STPList.addAll(ASTUtils.initialValue(param, instantList)); - } else { - STPList.add(r.getStp().getValue()); - } - } - } + // Find a list of STP offsets (if any exists) + if (coordination == CoordinationType.DECENTRALIZED) { + for (Reaction r : safe(reactionsWithPort)) { + // If STP offset is determined, add it + // If not, assume it is zero + if (r.getStp() != null) { + if (r.getStp().getValue() instanceof ParameterReference) { + List instantList = new ArrayList<>(); + instantList.add(instance.instantiation); + final var param = ((ParameterReference) r.getStp().getValue()).getParameter(); + STPList.addAll(ASTUtils.initialValue(param, instantList)); + } else { + STPList.add(r.getStp().getValue()); + } + } + } + // Check the children for STPs as well + for (Connection c : safe(connectionsWithPort)) { + VarRef childPort = c.getRightPorts().get(0); + Reactor childReactor = (Reactor) childPort.getVariable().eContainer(); + // Find the list of reactions that have the port as trigger or + // source (could be a variable name) + List childReactionsWithPort = + ASTUtils.allReactions(childReactor).stream() + .filter( + r -> + r.getTriggers().stream() + .anyMatch( + t -> { + if (t instanceof VarRef) { + // Check if the variables match + return ((VarRef) t).getVariable() + == childPort.getVariable(); + } else { + // Not a network port (startup or shutdown) + return false; + } + }) + || r.getSources().stream() + .anyMatch(s -> s.getVariable() == childPort.getVariable())) + .collect(Collectors.toList()); + + for (Reaction r : safe(childReactionsWithPort)) { + // If STP offset is determined, add it + // If not, assume it is zero + if (r.getStp() != null) { + if (r.getStp().getValue() instanceof ParameterReference) { + List instantList = new ArrayList<>(); + instantList.add(childPort.getContainer()); + final var param = ((ParameterReference) r.getStp().getValue()).getParameter(); + STPList.addAll(ASTUtils.initialValue(param, instantList)); + } else { + STPList.add(r.getStp().getValue()); } + } } - - return STPList.stream() - .map(ASTUtils::getLiteralTimeValue) - .filter(Objects::nonNull) - .reduce(TimeValue.ZERO, TimeValue::max); + } } - /** - * Return a null-safe List - * - * @param The type of the list - * @param list The potentially null List - * @return Empty list or the original list - */ - public static List safe(List list) { - return list == null ? Collections.emptyList() : list; + return STPList.stream() + .map(ASTUtils::getLiteralTimeValue) + .filter(Objects::nonNull) + .reduce(TimeValue.ZERO, TimeValue::max); + } + + /** + * Return a null-safe List + * + * @param The type of the list + * @param list The potentially null List + * @return Empty list or the original list + */ + public static List safe(List list) { + return list == null ? Collections.emptyList() : list; + } + + /** + * Add a network sender reaction for a given input port 'source' to source's parent reactor. This + * reaction will react to the 'source' and then send a message on the network destined for the + * destinationFederate. + * + * @param connection Network connection between two federates. + * @param coordination One of CoordinationType.DECENTRALIZED or CoordinationType.CENTRALIZED. + * @param errorReporter FIXME + * @note Used in federated execution + */ + private static void addNetworkSenderReaction( + FedConnectionInstance connection, + CoordinationType coordination, + ErrorReporter errorReporter) { + LfFactory factory = LfFactory.eINSTANCE; + // Assume all the types are the same, so just use the first on the right. + Type type = EcoreUtil.copy(connection.getSourcePortInstance().getDefinition().getType()); + VarRef sourceRef = factory.createVarRef(); + VarRef destRef = factory.createVarRef(); + Reactor parent = (Reactor) connection.getDefinition().eContainer(); + Reaction networkSenderReaction = factory.createReaction(); + + // FIXME: do not create a new extension every time it is used + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) + .annotateReaction(networkSenderReaction); + + // If the sender or receiver is in a bank of reactors, then we want + // these reactions to appear only in the federate whose bank ID matches. + setReactionBankIndex(networkSenderReaction, connection.getSrcBank()); + + // The connection is 'physical' if it uses the ~> notation. + if (connection.getDefinition().isPhysical()) { + connection.srcFederate.outboundP2PConnections.add(connection.dstFederate); + } else { + // If the connection is logical but coordination + // is decentralized, we would need + // to make P2P connections + if (coordination == CoordinationType.DECENTRALIZED) { + connection.srcFederate.outboundP2PConnections.add(connection.dstFederate); + } } - /** - * Add a network sender reaction for a given input port 'source' to - * source's parent reactor. This reaction will react to the 'source' - * and then send a message on the network destined for the - * destinationFederate. - * - * @param connection Network connection between two federates. - * @param coordination One of CoordinationType.DECENTRALIZED or - * CoordinationType.CENTRALIZED. - * @param errorReporter FIXME - * @note Used in federated execution - */ - private static void addNetworkSenderReaction( - FedConnectionInstance connection, - CoordinationType coordination, - ErrorReporter errorReporter - ) { - LfFactory factory = LfFactory.eINSTANCE; - // Assume all the types are the same, so just use the first on the right. - Type type = EcoreUtil.copy(connection.getSourcePortInstance().getDefinition().getType()); - VarRef sourceRef = factory.createVarRef(); - VarRef destRef = factory.createVarRef(); - Reactor parent = (Reactor) connection.getDefinition().eContainer(); - Reaction networkSenderReaction = factory.createReaction(); - - // FIXME: do not create a new extension every time it is used - FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) - .annotateReaction(networkSenderReaction); - - // If the sender or receiver is in a bank of reactors, then we want - // these reactions to appear only in the federate whose bank ID matches. - setReactionBankIndex(networkSenderReaction, connection.getSrcBank()); - - // The connection is 'physical' if it uses the ~> notation. - if (connection.getDefinition().isPhysical()) { - connection.srcFederate.outboundP2PConnections.add(connection.dstFederate); - } else { - // If the connection is logical but coordination - // is decentralized, we would need - // to make P2P connections - if (coordination == CoordinationType.DECENTRALIZED) { - connection.srcFederate.outboundP2PConnections.add(connection.dstFederate); - } - } - - // Establish references to the involved ports. - sourceRef.setContainer(connection.getSourcePortInstance().getParent().getDefinition()); - sourceRef.setVariable(connection.getSourcePortInstance().getDefinition()); - destRef.setContainer(connection.getDestinationPortInstance().getParent().getDefinition()); - destRef.setVariable(connection.getDestinationPortInstance().getDefinition()); - - // Configure the sending reaction. - networkSenderReaction.getTriggers().add(sourceRef); - networkSenderReaction.setCode(factory.createCode()); - networkSenderReaction.getCode().setBody( + // Establish references to the involved ports. + sourceRef.setContainer(connection.getSourcePortInstance().getParent().getDefinition()); + sourceRef.setVariable(connection.getSourcePortInstance().getDefinition()); + destRef.setContainer(connection.getDestinationPortInstance().getParent().getDefinition()); + destRef.setVariable(connection.getDestinationPortInstance().getDefinition()); + + // Configure the sending reaction. + networkSenderReaction.getTriggers().add(sourceRef); + networkSenderReaction.setCode(factory.createCode()); + networkSenderReaction + .getCode() + .setBody( FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) - .generateNetworkSenderBody( - sourceRef, - destRef, - connection, - InferredType.fromAST(type), - coordination, - errorReporter - )); - - ASTUtils.addReactionAttribute(networkSenderReaction, "_unordered"); - - // Add the sending reaction to the parent. - parent.getReactions().add(networkSenderReaction); - - // Add the network sender reaction to the federate instance's list - // of network reactions - connection.srcFederate.networkReactions.add(networkSenderReaction); + .generateNetworkSenderBody( + sourceRef, + destRef, + connection, + InferredType.fromAST(type), + coordination, + errorReporter)); + + ASTUtils.addReactionAttribute(networkSenderReaction, "_unordered"); + + // Add the sending reaction to the parent. + parent.getReactions().add(networkSenderReaction); + + // Add the network sender reaction to the federate instance's list + // of network reactions + connection.srcFederate.networkReactions.add(networkSenderReaction); + } + + /** + * Add a network control reaction for a given output port 'source' to source's parent reactor. + * This reaction will send a port absent message if the status of the output port is absent. + * + * @param connection FIXME + * @note Used in federated execution + */ + private static void addNetworkOutputControlReaction(FedConnectionInstance connection) { + LfFactory factory = LfFactory.eINSTANCE; + Reaction reaction = factory.createReaction(); + Reactor top = + connection + .getSourcePortInstance() + .getParent() + .getParent() + .reactorDefinition; // Top-level reactor. + + // Add the output from the contained reactor as a source to + // the reaction to preserve precedence order. + VarRef newPortRef = factory.createVarRef(); + newPortRef.setContainer(connection.getSourcePortInstance().getParent().getDefinition()); + newPortRef.setVariable(connection.getSourcePortInstance().getDefinition()); + reaction.getSources().add(newPortRef); + + // If the sender or receiver is in a bank of reactors, then we want + // these reactions to appear only in the federate whose bank ID matches. + setReactionBankIndex(reaction, connection.getSrcBank()); + + // FIXME: do not create a new extension every time it is used + FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) + .annotateReaction(reaction); + + // We use an action at the top-level to manually + // trigger output control reactions. That action is created once + // and recorded in the federate instance. + // Check whether the action already has been created. + if (connection.srcFederate.networkOutputControlReactionsTrigger == null) { + // The port has not been created. + String triggerName = "outputControlReactionTrigger"; + + // Find the trigger definition in the reactor definition, which could have been + // generated for another federate instance if there are multiple instances + // of the same reactor that are each distinct federates. + Optional optTriggerInput = + top.getActions().stream().filter(I -> I.getName().equals(triggerName)).findFirst(); + + if (optTriggerInput.isEmpty()) { + // If no trigger with the name "outputControlReactionTrigger" is + // already added to the reactor definition, we need to create it + // for the first time. The trigger is a logical action. + Action newTriggerForControlReactionVariable = factory.createAction(); + newTriggerForControlReactionVariable.setName(triggerName); + newTriggerForControlReactionVariable.setOrigin(ActionOrigin.LOGICAL); + top.getActions().add(newTriggerForControlReactionVariable); + + // Now that the variable is created, store it in the federate instance + connection.srcFederate.networkOutputControlReactionsTrigger = + newTriggerForControlReactionVariable; + } else { + // If the "outputControlReactionTrigger" trigger is already + // there, we can re-use it for this new reaction since a single trigger + // will trigger + // all network output control reactions. + connection.srcFederate.networkOutputControlReactionsTrigger = optTriggerInput.get(); + } } - /** - * Add a network control reaction for a given output port 'source' to - * source's parent reactor. This reaction will send a port absent - * message if the status of the output port is absent. - * - * @param connection FIXME - * @note Used in federated execution - */ - private static void addNetworkOutputControlReaction(FedConnectionInstance connection) { - LfFactory factory = LfFactory.eINSTANCE; - Reaction reaction = factory.createReaction(); - Reactor top = connection.getSourcePortInstance() - .getParent() - .getParent().reactorDefinition; // Top-level reactor. - - // Add the output from the contained reactor as a source to - // the reaction to preserve precedence order. - VarRef newPortRef = factory.createVarRef(); - newPortRef.setContainer(connection.getSourcePortInstance().getParent().getDefinition()); - newPortRef.setVariable(connection.getSourcePortInstance().getDefinition()); - reaction.getSources().add(newPortRef); - - // If the sender or receiver is in a bank of reactors, then we want - // these reactions to appear only in the federate whose bank ID matches. - setReactionBankIndex(reaction, connection.getSrcBank()); - - // FIXME: do not create a new extension every time it is used - FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) - .annotateReaction(reaction); - - // We use an action at the top-level to manually - // trigger output control reactions. That action is created once - // and recorded in the federate instance. - // Check whether the action already has been created. - if (connection.srcFederate.networkOutputControlReactionsTrigger == null) { - // The port has not been created. - String triggerName = "outputControlReactionTrigger"; - - // Find the trigger definition in the reactor definition, which could have been - // generated for another federate instance if there are multiple instances - // of the same reactor that are each distinct federates. - Optional optTriggerInput - = top.getActions().stream().filter( - I -> I.getName().equals(triggerName)).findFirst(); - - if (optTriggerInput.isEmpty()) { - // If no trigger with the name "outputControlReactionTrigger" is - // already added to the reactor definition, we need to create it - // for the first time. The trigger is a logical action. - Action newTriggerForControlReactionVariable = factory.createAction(); - newTriggerForControlReactionVariable.setName(triggerName); - newTriggerForControlReactionVariable.setOrigin(ActionOrigin.LOGICAL); - top.getActions().add(newTriggerForControlReactionVariable); - - // Now that the variable is created, store it in the federate instance - connection.srcFederate.networkOutputControlReactionsTrigger - = newTriggerForControlReactionVariable; - } else { - // If the "outputControlReactionTrigger" trigger is already - // there, we can re-use it for this new reaction since a single trigger - // will trigger - // all network output control reactions. - connection.srcFederate.networkOutputControlReactionsTrigger = optTriggerInput.get(); - } - } - - // Add the trigger for all output control reactions to the list of triggers - VarRef triggerRef = factory.createVarRef(); - triggerRef.setVariable(connection.srcFederate.networkOutputControlReactionsTrigger); - reaction.getTriggers().add(triggerRef); + // Add the trigger for all output control reactions to the list of triggers + VarRef triggerRef = factory.createVarRef(); + triggerRef.setVariable(connection.srcFederate.networkOutputControlReactionsTrigger); + reaction.getTriggers().add(triggerRef); - // Generate the code - reaction.setCode(factory.createCode()); + // Generate the code + reaction.setCode(factory.createCode()); - reaction.getCode().setBody( + reaction + .getCode() + .setBody( FedTargetExtensionFactory.getExtension(connection.srcFederate.targetConfig.target) - .generateNetworkOutputControlReactionBody(newPortRef, connection)); + .generateNetworkOutputControlReactionBody(newPortRef, connection)); - ASTUtils.addReactionAttribute(reaction, "_unordered"); + ASTUtils.addReactionAttribute(reaction, "_unordered"); + // Insert the newly generated reaction after the generated sender and + // receiver top-level reactions. + top.getReactions().add(reaction); - // Insert the newly generated reaction after the generated sender and - // receiver top-level reactions. - top.getReactions().add(reaction); - - // Add the network output control reaction to the federate instance's list - // of network reactions - connection.srcFederate.networkReactions.add(reaction); - } + // Add the network output control reaction to the federate instance's list + // of network reactions + connection.srcFederate.networkReactions.add(reaction); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedConnectionInstance.java b/org.lflang/src/org/lflang/federated/generator/FedConnectionInstance.java index a82e1d2dfa..d08aa5f850 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedConnectionInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FedConnectionInstance.java @@ -9,102 +9,100 @@ /** * Class representing a federated connection. * - * This is an undocumented class written by a previous contributor who is no longer active. - * It merely serves as a record, presumably to make it easier to pass around information - * around. + *

    This is an undocumented class written by a previous contributor who is no longer active. It + * merely serves as a record, presumably to make it easier to pass around information around. * * @author Soroush Bateni */ public class FedConnectionInstance { - SendRange srcRange; + SendRange srcRange; - RuntimeRange dstRange; + RuntimeRange dstRange; - int srcChannel; + int srcChannel; - int srcBank; + int srcBank; - int dstChannel; + int dstChannel; - int dstBank; + int dstBank; - FederateInstance srcFederate; + FederateInstance srcFederate; - FederateInstance dstFederate; + FederateInstance dstFederate; - SupportedSerializers serializer; + SupportedSerializers serializer; - public FedConnectionInstance( - SendRange srcRange, - RuntimeRange dstRange, - int srcChannel, - int srcBank, - int dstChannel, - int dstBank, - FederateInstance srcFederate, - FederateInstance dstFederate, - SupportedSerializers serializer - ) { - this.srcRange = srcRange; - this.srcChannel = srcChannel; - this.srcBank = srcBank; - this.dstChannel = dstChannel; - this.dstBank = dstBank; - this.srcFederate = srcFederate; - this.dstFederate = dstFederate; - this.dstRange = dstRange; - this.serializer = serializer; + public FedConnectionInstance( + SendRange srcRange, + RuntimeRange dstRange, + int srcChannel, + int srcBank, + int dstChannel, + int dstBank, + FederateInstance srcFederate, + FederateInstance dstFederate, + SupportedSerializers serializer) { + this.srcRange = srcRange; + this.srcChannel = srcChannel; + this.srcBank = srcBank; + this.dstChannel = dstChannel; + this.dstBank = dstBank; + this.srcFederate = srcFederate; + this.dstFederate = dstFederate; + this.dstRange = dstRange; + this.serializer = serializer; - this.srcFederate.connections.add(this); - this.dstFederate.connections.add(this); - } + this.srcFederate.connections.add(this); + this.dstFederate.connections.add(this); + } - public SendRange getSrcRange() { - return srcRange; - } + public SendRange getSrcRange() { + return srcRange; + } - public RuntimeRange getDstRange() { - return dstRange; - } + public RuntimeRange getDstRange() { + return dstRange; + } - public int getSrcChannel() { - return srcChannel; - } + public int getSrcChannel() { + return srcChannel; + } - public int getSrcBank() { - return srcBank; - } + public int getSrcBank() { + return srcBank; + } - public int getDstChannel() { - return dstChannel; - } + public int getDstChannel() { + return dstChannel; + } - public int getDstBank() { - return dstBank; - } + public int getDstBank() { + return dstBank; + } - public FederateInstance getSrcFederate() { - return srcFederate; - } + public FederateInstance getSrcFederate() { + return srcFederate; + } - public FederateInstance getDstFederate() { - return dstFederate; - } + public FederateInstance getDstFederate() { + return dstFederate; + } - public SupportedSerializers getSerializer() { - return serializer; - } + public SupportedSerializers getSerializer() { + return serializer; + } - public Connection getDefinition() { - return srcRange.connection; - } + public Connection getDefinition() { + return srcRange.connection; + } - public PortInstance getSourcePortInstance() { - return srcRange.instance; - } + public PortInstance getSourcePortInstance() { + return srcRange.instance; + } - public PortInstance getDestinationPortInstance() { - return dstRange.instance; - } + public PortInstance getDestinationPortInstance() { + return dstRange.instance; + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java index 2c9f32aad8..bdf912d0c8 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedEmitter.java @@ -4,76 +4,70 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.HashMap; -import java.util.LinkedHashMap; import java.util.Map; - import org.lflang.ErrorReporter; import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.CodeMap; import org.lflang.generator.LFGeneratorContext; import org.lflang.lf.Reactor; -/** - * Helper class to generate code for federates. - */ +/** Helper class to generate code for federates. */ public class FedEmitter { - private final FedFileConfig fileConfig; - private final Reactor originalMainReactor; - private final ErrorReporter errorReporter; - private final RtiConfig rtiConfig; + private final FedFileConfig fileConfig; + private final Reactor originalMainReactor; + private final ErrorReporter errorReporter; + private final RtiConfig rtiConfig; - public FedEmitter( - FedFileConfig fileConfig, - Reactor originalMainReactor, - ErrorReporter errorReporter, - RtiConfig rtiConfig - ) { - this.fileConfig = fileConfig; - this.originalMainReactor = originalMainReactor; - this.errorReporter = errorReporter; - this.rtiConfig = rtiConfig; - } + public FedEmitter( + FedFileConfig fileConfig, + Reactor originalMainReactor, + ErrorReporter errorReporter, + RtiConfig rtiConfig) { + this.fileConfig = fileConfig; + this.originalMainReactor = originalMainReactor; + this.errorReporter = errorReporter; + this.rtiConfig = rtiConfig; + } - /** - * Generate a .lf file for federate {@code federate}. - * - * @throws IOException - */ - Map generateFederate( - LFGeneratorContext context, - FederateInstance federate, - int numOfFederates - ) throws IOException { - String fedName = federate.name; - Files.createDirectories(fileConfig.getSrcPath()); - System.out.println("##### Generating code for federate " + fedName - + " in directory " - + fileConfig.getSrcPath()); + /** + * Generate a .lf file for federate {@code federate}. + * + * @throws IOException + */ + Map generateFederate( + LFGeneratorContext context, FederateInstance federate, int numOfFederates) + throws IOException { + String fedName = federate.name; + Files.createDirectories(fileConfig.getSrcPath()); + System.out.println( + "##### Generating code for federate " + + fedName + + " in directory " + + fileConfig.getSrcPath()); - String federateCode = String.join( + String federateCode = + String.join( "\n", - new FedTargetEmitter().generateTarget(context, numOfFederates, federate, fileConfig, errorReporter, rtiConfig), + new FedTargetEmitter() + .generateTarget( + context, numOfFederates, federate, fileConfig, errorReporter, rtiConfig), new FedImportEmitter().generateImports(federate, fileConfig), - new FedPreambleEmitter().generatePreamble(federate, fileConfig, rtiConfig, errorReporter), + new FedPreambleEmitter() + .generatePreamble(federate, fileConfig, rtiConfig, errorReporter), new FedReactorEmitter().generateReactorDefinitions(federate), - new FedMainEmitter().generateMainReactor( - federate, - originalMainReactor, - errorReporter - ) - ); - Map codeMapMap = new HashMap<>(); - var lfFilePath = lfFilePath(fileConfig, federate); - try (var srcWriter = Files.newBufferedWriter(lfFilePath)) { - var codeMap = CodeMap.fromGeneratedCode(federateCode); - codeMapMap.put(lfFilePath, codeMap); - srcWriter.write(codeMap.getGeneratedCode()); - } - return codeMapMap; + new FedMainEmitter().generateMainReactor(federate, originalMainReactor, errorReporter)); + Map codeMapMap = new HashMap<>(); + var lfFilePath = lfFilePath(fileConfig, federate); + try (var srcWriter = Files.newBufferedWriter(lfFilePath)) { + var codeMap = CodeMap.fromGeneratedCode(federateCode); + codeMapMap.put(lfFilePath, codeMap); + srcWriter.write(codeMap.getGeneratedCode()); } + return codeMapMap; + } - public static Path lfFilePath(FedFileConfig fileConfig, FederateInstance federate) { - return fileConfig.getSrcPath().resolve(federate.name + ".lf"); - } + public static Path lfFilePath(FedFileConfig fileConfig, FederateInstance federate) { + return fileConfig.getSrcPath().resolve(federate.name + ".lf"); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java index e434501825..cb12c90a7d 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2019-2021, The University of California at Berkeley. - + * * 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. - + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -30,113 +30,105 @@ import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; - import org.eclipse.emf.ecore.resource.Resource; - import org.lflang.FileConfig; import org.lflang.util.FileUtil; /** - * A subclass of @see FileConfig that extends the base functionality to add support - * for compiling federated LF programs. The code generator should create one instance - * of this class for each federate. + * A subclass of @see FileConfig that extends the base functionality to add support for compiling + * federated LF programs. The code generator should create one instance of this class for each + * federate. * * @author Soroush Bateni - * */ public class FedFileConfig extends FileConfig { - public FedFileConfig( - Resource resource, - Path srcGenBasePath, - boolean useHierarchicalBin - ) throws IOException { - super(resource, srcGenBasePath, useHierarchicalBin); - } - - public FedFileConfig(FileConfig fileConfig) throws IOException { - super(fileConfig.resource, fileConfig.getSrcGenBasePath(), fileConfig.useHierarchicalBin); - } - - /** - * Return the path to the root of a LF project generated on the basis of a - * federated LF program currently under compilation. - */ - public Path getGenPath() { - return srcPkgPath.resolve("fed-gen").resolve(name); - } - - /** - * Return the path for storing generated LF sources that jointly constitute a - * federation. - */ - public Path getSrcPath() { - return getGenPath().resolve("src"); - } - - /** - * The directory in which to put the generated sources. - * This takes into account the location of the source file relative to the - * package root. Specifically, if the source file is x/y/Z.lf relative - * to the package root, then the generated sources will be put in x/y/Z - * relative to srcGenBasePath. - */ - @Override - public Path getSrcGenPath() { - return getGenPath().resolve("src-gen"); - } - - /** - * Return the path to the root of a LF project generated on the basis of a - * federated LF program currently under compilation. - */ - public Path getFedGenPath() { - return srcPkgPath.resolve("fed-gen").resolve(this.name); - } - - /** - * Return the path to the directory in which the executables of compiled federates are stored. - */ - public Path getFedBinPath() { return getFedGenPath().resolve("bin"); } - - @Override - public void doClean() throws IOException { - super.doClean(); - FileUtil.deleteDirectory(this.getFedGenPath()); - } - - /** - * Relativize target properties that involve paths like files and cmake-include to be - * relative to the generated .lf file for the federate. - */ - public void relativizePaths(FedTargetConfig targetConfig) { - relativizePathList(targetConfig.protoFiles); - relativizePathList(targetConfig.files); - relativizePathList(targetConfig.cmakeIncludes); - } - - /** - * Relativize each path in the given list. - * @param paths The paths to relativize. - */ - private void relativizePathList(List paths) { - List tempList = new ArrayList<>(); - paths.forEach(f -> tempList.add(relativizePath(Paths.get(f)))); - paths.clear(); - paths.addAll(tempList); - } - - /** - * Relativize a single path, but only if it points to a local resource in the project (i.e., not - * on the class path). - * @param path The path to relativize. - */ - private String relativizePath(Path path) { - if (FileUtil.findInPackage(path, this) == null) { - return String.valueOf(path); - } else { - Path resolvedPath = this.srcPath.resolve(path).toAbsolutePath(); - return this.getSrcPath().relativize(resolvedPath).toString(); - } + public FedFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) + throws IOException { + super(resource, srcGenBasePath, useHierarchicalBin); + } + + public FedFileConfig(FileConfig fileConfig) throws IOException { + super(fileConfig.resource, fileConfig.getSrcGenBasePath(), fileConfig.useHierarchicalBin); + } + + /** + * Return the path to the root of a LF project generated on the basis of a federated LF program + * currently under compilation. + */ + public Path getGenPath() { + return srcPkgPath.resolve("fed-gen").resolve(name); + } + + /** Return the path for storing generated LF sources that jointly constitute a federation. */ + public Path getSrcPath() { + return getGenPath().resolve("src"); + } + + /** + * The directory in which to put the generated sources. This takes into account the location of + * the source file relative to the package root. Specifically, if the source file is x/y/Z.lf + * relative to the package root, then the generated sources will be put in x/y/Z relative to + * srcGenBasePath. + */ + @Override + public Path getSrcGenPath() { + return getGenPath().resolve("src-gen"); + } + + /** + * Return the path to the root of a LF project generated on the basis of a federated LF program + * currently under compilation. + */ + public Path getFedGenPath() { + return srcPkgPath.resolve("fed-gen").resolve(this.name); + } + + /** Return the path to the directory in which the executables of compiled federates are stored. */ + public Path getFedBinPath() { + return getFedGenPath().resolve("bin"); + } + + @Override + public void doClean() throws IOException { + super.doClean(); + FileUtil.deleteDirectory(this.getFedGenPath()); + } + + /** + * Relativize target properties that involve paths like files and cmake-include to be relative to + * the generated .lf file for the federate. + */ + public void relativizePaths(FedTargetConfig targetConfig) { + relativizePathList(targetConfig.protoFiles); + relativizePathList(targetConfig.files); + relativizePathList(targetConfig.cmakeIncludes); + } + + /** + * Relativize each path in the given list. + * + * @param paths The paths to relativize. + */ + private void relativizePathList(List paths) { + List tempList = new ArrayList<>(); + paths.forEach(f -> tempList.add(relativizePath(Paths.get(f)))); + paths.clear(); + paths.addAll(tempList); + } + + /** + * Relativize a single path, but only if it points to a local resource in the project (i.e., not + * on the class path). + * + * @param path The path to relativize. + */ + private String relativizePath(Path path) { + if (FileUtil.findInPackage(path, this) == null) { + return String.valueOf(path); + } else { + Path resolvedPath = this.srcPath.resolve(path).toAbsolutePath(); + return this.getSrcPath().relativize(resolvedPath).toString(); } + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java index 595a721c93..08a1fcf6e8 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java +++ b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java @@ -2,6 +2,7 @@ import static org.lflang.generator.DockerGenerator.dockerGeneratorFactory; +import com.google.inject.Injector; import java.io.IOException; import java.nio.file.Path; import java.util.ArrayList; @@ -19,7 +20,6 @@ import java.util.function.Consumer; import java.util.regex.Matcher; import java.util.regex.Pattern; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.JavaIoFileSystemAccess; @@ -27,14 +27,13 @@ import org.eclipse.xtext.resource.XtextResourceSet; import org.eclipse.xtext.util.RuntimeIOException; import org.eclipse.xtext.xbase.lib.Exceptions; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.LFStandaloneSetup; import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty.CoordinationType; +import org.lflang.ast.ASTUtils; import org.lflang.federated.launcher.FedLauncherGenerator; import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.CodeMap; @@ -58,569 +57,539 @@ import org.lflang.lf.Reactor; import org.lflang.util.Averager; -import com.google.inject.Injector; - public class FedGenerator { - - /** - * - */ - private final ErrorReporter errorReporter; - - /** - * A list of federate instances. - */ - private final List federates = new ArrayList<>(); - - /** - * File configuration to be used during the LF code generation stage (not the target code - * generation stage of individual federates). - */ - private final FedFileConfig fileConfig; - - /** - * Configuration of the RTI. - */ - final RtiConfig rtiConfig = new RtiConfig(); - - /** - * Target configuration of the federation; drawn from the file - * in which the federated reactor is defined. - */ - private final TargetConfig targetConfig; - - /** - * A map from instantiations to the federate instances for that - * instantiation. - * If the instantiation has a width, there may be more than one federate - * instance. - */ - private Map> federatesByInstantiation; - - /** - * Definition of the main (top-level) reactor. - * This is an automatically generated AST node for the top-level - * reactor. - */ - private Instantiation mainDef; - - /** - * Create a new generator and initialize a file configuration, target configuration, and error - * reporter. - * @param context - */ - public FedGenerator(LFGeneratorContext context) { - this.fileConfig = (FedFileConfig) context.getFileConfig(); - this.targetConfig = context.getTargetConfig(); - this.errorReporter = context.getErrorReporter(); + /** */ + private final ErrorReporter errorReporter; + + /** A list of federate instances. */ + private final List federates = new ArrayList<>(); + + /** + * File configuration to be used during the LF code generation stage (not the target code + * generation stage of individual federates). + */ + private final FedFileConfig fileConfig; + + /** Configuration of the RTI. */ + final RtiConfig rtiConfig = new RtiConfig(); + + /** + * Target configuration of the federation; drawn from the file in which the federated reactor is + * defined. + */ + private final TargetConfig targetConfig; + + /** + * A map from instantiations to the federate instances for that instantiation. If the + * instantiation has a width, there may be more than one federate instance. + */ + private Map> federatesByInstantiation; + + /** + * Definition of the main (top-level) reactor. This is an automatically generated AST node for the + * top-level reactor. + */ + private Instantiation mainDef; + + /** + * Create a new generator and initialize a file configuration, target configuration, and error + * reporter. + * + * @param context + */ + public FedGenerator(LFGeneratorContext context) { + this.fileConfig = (FedFileConfig) context.getFileConfig(); + this.targetConfig = context.getTargetConfig(); + this.errorReporter = context.getErrorReporter(); + } + + /** + * Produce LF code for each federate in a separate file, then invoke a target-specific code + * generator for each of those files. + * + * @param resource The resource that has the federated main reactor in it + * @param context The context in which to carry out the code generation. + * @return False if no errors have occurred, true otherwise. + * @throws IOException + */ + public boolean doGenerate(Resource resource, LFGeneratorContext context) throws IOException { + if (!federatedExecutionIsSupported(resource)) return true; + cleanIfNeeded(context); + + // In a federated execution, we need keepalive to be true, + // otherwise a federate could exit simply because it hasn't received + // any messages. + targetConfig.keepalive = true; + + // Process command-line arguments + processCLIArguments(context); + + // Find the federated reactor + Reactor federation = FedASTUtils.findFederatedReactor(resource); + + // Extract some useful information about the federation + analyzeFederates(federation, context); + + // Find all the connections between federates. + // For each connection between federates, replace it in the + // AST with an action (which inherits the delay) and four reactions. + // The action will be physical for physical connections and logical + // for logical connections. + replaceFederateConnectionsWithProxies(federation); + + FedEmitter fedEmitter = + new FedEmitter( + fileConfig, ASTUtils.toDefinition(mainDef.getReactorClass()), errorReporter, rtiConfig); + + // Generate LF code for each federate. + Map lf2lfCodeMapMap = new HashMap<>(); + for (FederateInstance federate : federates) { + lf2lfCodeMapMap.putAll(fedEmitter.generateFederate(context, federate, federates.size())); } - /** - * Produce LF code for each federate in a separate file, then invoke a target-specific code - * generator for each of those files. - * - * @param resource The resource that has the federated main reactor in it - * @param context The context in which to carry out the code generation. - * @return False if no errors have occurred, true otherwise. - * @throws IOException - */ - public boolean doGenerate(Resource resource, LFGeneratorContext context) throws IOException { - if (!federatedExecutionIsSupported(resource)) return true; - cleanIfNeeded(context); - - // In a federated execution, we need keepalive to be true, - // otherwise a federate could exit simply because it hasn't received - // any messages. - targetConfig.keepalive = true; - - // Process command-line arguments - processCLIArguments(context); - - // Find the federated reactor - Reactor federation = FedASTUtils.findFederatedReactor(resource); - - // Extract some useful information about the federation - analyzeFederates(federation, context); - - // Find all the connections between federates. - // For each connection between federates, replace it in the - // AST with an action (which inherits the delay) and four reactions. - // The action will be physical for physical connections and logical - // for logical connections. - replaceFederateConnectionsWithProxies(federation); - - FedEmitter fedEmitter = new FedEmitter( - fileConfig, - ASTUtils.toDefinition(mainDef.getReactorClass()), - errorReporter, - rtiConfig - ); - - // Generate LF code for each federate. - Map lf2lfCodeMapMap = new HashMap<>(); - for (FederateInstance federate : federates) { - lf2lfCodeMapMap.putAll(fedEmitter.generateFederate( - context, federate, federates.size() - )); - } - - // Do not invoke target code generators if --no-compile flag is used. - if (context.getTargetConfig().noCompile) { - context.finish(Status.GENERATED, lf2lfCodeMapMap); - return false; - } + // Do not invoke target code generators if --no-compile flag is used. + if (context.getTargetConfig().noCompile) { + context.finish(Status.GENERATED, lf2lfCodeMapMap); + return false; + } - Map codeMapMap = compileFederates(context, lf2lfCodeMapMap, subContexts -> { - createDockerFiles(context, subContexts); - generateLaunchScript(); - }); + Map codeMapMap = + compileFederates( + context, + lf2lfCodeMapMap, + subContexts -> { + createDockerFiles(context, subContexts); + generateLaunchScript(); + }); - context.finish(Status.COMPILED, codeMapMap); - return false; + context.finish(Status.COMPILED, codeMapMap); + return false; + } + + private void generateLaunchScript() { + new FedLauncherGenerator(this.targetConfig, this.fileConfig, this.errorReporter) + .doGenerate(federates, rtiConfig); + } + + /** + * Generate a Dockerfile for each federate and a docker-compose.yml for the federation. + * + * @param context The main context in which the federation has been compiled. + * @param subContexts The subcontexts in which the federates have been compiled. + */ + private void createDockerFiles(LFGeneratorContext context, List subContexts) { + if (context.getTargetConfig().dockerOptions == null) return; + final List services = new ArrayList<>(); + // 1. create a Dockerfile for each federate + for (SubContext subContext : subContexts) { // Inherit Docker options from main context + subContext.getTargetConfig().dockerOptions = context.getTargetConfig().dockerOptions; + var dockerGenerator = dockerGeneratorFactory(subContext); + var dockerData = dockerGenerator.generateDockerData(); + try { + dockerData.writeDockerFile(); + } catch (IOException e) { + throw new RuntimeIOException(e); + } + services.add(dockerData); } - - private void generateLaunchScript() { - new FedLauncherGenerator( - this.targetConfig, - this.fileConfig, - this.errorReporter - ).doGenerate(federates, rtiConfig); + // 2. create a docker-compose.yml for the federation + try { + new FedDockerComposeGenerator(context, rtiConfig.getHost()).writeDockerComposeFile(services); + } catch (IOException e) { + throw new RuntimeIOException(e); } - - /** - * Generate a Dockerfile for each federate and a docker-compose.yml for the federation. - * @param context The main context in which the federation has been compiled. - * @param subContexts The subcontexts in which the federates have been compiled. - */ - private void createDockerFiles(LFGeneratorContext context, List subContexts) { - if (context.getTargetConfig().dockerOptions == null) return; - final List services = new ArrayList<>(); - // 1. create a Dockerfile for each federate - for (SubContext subContext : subContexts) {// Inherit Docker options from main context - subContext.getTargetConfig().dockerOptions = context.getTargetConfig().dockerOptions; - var dockerGenerator = dockerGeneratorFactory(subContext); - var dockerData = dockerGenerator.generateDockerData(); - try { - dockerData.writeDockerFile(); - } catch (IOException e) { - throw new RuntimeIOException(e); - } - services.add(dockerData); - } - // 2. create a docker-compose.yml for the federation - try { - new FedDockerComposeGenerator( - context, - rtiConfig.getHost() - ).writeDockerComposeFile(services); - } catch (IOException e) { - throw new RuntimeIOException(e); - } + } + + /** + * Check if a clean was requested from the standalone compiler and perform the clean step. + * + * @param context Context in which the generator operates + */ + private void cleanIfNeeded(LFGeneratorContext context) { + if (context.getArgs().containsKey(BuildParm.CLEAN.getKey())) { + try { + fileConfig.doClean(); + } catch (IOException e) { + System.err.println("WARNING: IO Error during clean"); + } } - - /** - * Check if a clean was requested from the standalone compiler and perform - * the clean step. - * @param context Context in which the generator operates - */ - private void cleanIfNeeded(LFGeneratorContext context) { - if (context.getArgs().containsKey(BuildParm.CLEAN.getKey())) { - try { - fileConfig.doClean(); - } catch (IOException e) { - System.err.println("WARNING: IO Error during clean"); - } - } + } + + /** Return whether federated execution is supported for {@code resource}. */ + private boolean federatedExecutionIsSupported(Resource resource) { + var target = Target.fromDecl(GeneratorUtils.findTargetDecl(resource)); + var targetOK = + List.of(Target.C, Target.Python, Target.TS, Target.CPP, Target.CCPP).contains(target); + if (!targetOK) { + errorReporter.reportError("Federated execution is not supported with target " + target + "."); } - - /** Return whether federated execution is supported for {@code resource}. */ - private boolean federatedExecutionIsSupported(Resource resource) { - var target = Target.fromDecl(GeneratorUtils.findTargetDecl(resource)); - var targetOK = List.of( - Target.C, Target.Python, Target.TS, Target.CPP, Target.CCPP - ).contains(target); - if (!targetOK) { - errorReporter.reportError( - "Federated execution is not supported with target " + target + "." - ); - } - if(target.equals(Target.C) && GeneratorUtils.isHostWindows()) { - errorReporter.reportError( - "Federated LF programs with a C target are currently not supported on Windows." - ); - targetOK = false; - } - - return targetOK; + if (target.equals(Target.C) && GeneratorUtils.isHostWindows()) { + errorReporter.reportError( + "Federated LF programs with a C target are currently not supported on Windows."); + targetOK = false; } - private Map compileFederates( - LFGeneratorContext context, - Map lf2lfCodeMapMap, - Consumer> finalizer) { - - // FIXME: Use the appropriate resource set instead of always using standalone - Injector inj = new LFStandaloneSetup() - .createInjectorAndDoEMFRegistration(); - XtextResourceSet rs = inj.getInstance(XtextResourceSet.class); - rs.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE); - // define output path here - JavaIoFileSystemAccess fsa = inj.getInstance(JavaIoFileSystemAccess.class); - fsa.setOutputPath("DEFAULT_OUTPUT", fileConfig.getSrcGenPath().toString()); - - var numOfCompileThreads = Math.min(6, - Math.min( - Math.max(federates.size(), 1), - Runtime.getRuntime().availableProcessors() - ) - ); - var compileThreadPool = Executors.newFixedThreadPool(numOfCompileThreads); - System.out.println("******** Using "+numOfCompileThreads+" threads to compile the program."); - Map codeMapMap = new ConcurrentHashMap<>(); - List subContexts = Collections.synchronizedList(new ArrayList<>()); - Averager averager = new Averager(federates.size()); - final var threadSafeErrorReporter = new SynchronizedErrorReporter(errorReporter); - for (int i = 0; i < federates.size(); i++) { - FederateInstance fed = federates.get(i); - final int id = i; - compileThreadPool.execute(() -> { - Resource res = rs.getResource(URI.createFileURI( - FedEmitter.lfFilePath(fileConfig, fed).toAbsolutePath().toString() - ), true); - FileConfig subFileConfig = LFGenerator.createFileConfig(res, fileConfig.getSrcGenPath(), true); - ErrorReporter subContextErrorReporter = new LineAdjustingErrorReporter(threadSafeErrorReporter, lf2lfCodeMapMap); - - var props = new Properties(); - if (targetConfig.dockerOptions != null && targetConfig.target.buildsUsingDocker()) { - props.put("no-compile", "true"); - } - props.put("docker", "false"); - - TargetConfig subConfig = new TargetConfig( - props, GeneratorUtils.findTargetDecl(subFileConfig.resource), subContextErrorReporter - ); - SubContext subContext = new SubContext(context, IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, 100) { - @Override - public ErrorReporter getErrorReporter() { - return subContextErrorReporter; - } - - @Override - public void reportProgress(String message, int percentage) { - averager.report(id, percentage, meanPercentage -> super.reportProgress(message, meanPercentage)); - } - - @Override - public FileConfig getFileConfig() { - return subFileConfig; - } - - @Override - public TargetConfig getTargetConfig() { - return subConfig; - } + return targetOK; + } + + private Map compileFederates( + LFGeneratorContext context, + Map lf2lfCodeMapMap, + Consumer> finalizer) { + + // FIXME: Use the appropriate resource set instead of always using standalone + Injector inj = new LFStandaloneSetup().createInjectorAndDoEMFRegistration(); + XtextResourceSet rs = inj.getInstance(XtextResourceSet.class); + rs.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE); + // define output path here + JavaIoFileSystemAccess fsa = inj.getInstance(JavaIoFileSystemAccess.class); + fsa.setOutputPath("DEFAULT_OUTPUT", fileConfig.getSrcGenPath().toString()); + + var numOfCompileThreads = + Math.min( + 6, Math.min(Math.max(federates.size(), 1), Runtime.getRuntime().availableProcessors())); + var compileThreadPool = Executors.newFixedThreadPool(numOfCompileThreads); + System.out.println( + "******** Using " + numOfCompileThreads + " threads to compile the program."); + Map codeMapMap = new ConcurrentHashMap<>(); + List subContexts = Collections.synchronizedList(new ArrayList<>()); + Averager averager = new Averager(federates.size()); + final var threadSafeErrorReporter = new SynchronizedErrorReporter(errorReporter); + for (int i = 0; i < federates.size(); i++) { + FederateInstance fed = federates.get(i); + final int id = i; + compileThreadPool.execute( + () -> { + Resource res = + rs.getResource( + URI.createFileURI( + FedEmitter.lfFilePath(fileConfig, fed).toAbsolutePath().toString()), + true); + FileConfig subFileConfig = + LFGenerator.createFileConfig(res, fileConfig.getSrcGenPath(), true); + ErrorReporter subContextErrorReporter = + new LineAdjustingErrorReporter(threadSafeErrorReporter, lf2lfCodeMapMap); + + var props = new Properties(); + if (targetConfig.dockerOptions != null && targetConfig.target.buildsUsingDocker()) { + props.put("no-compile", "true"); + } + props.put("docker", "false"); + + TargetConfig subConfig = + new TargetConfig( + props, + GeneratorUtils.findTargetDecl(subFileConfig.resource), + subContextErrorReporter); + SubContext subContext = + new SubContext(context, IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, 100) { + @Override + public ErrorReporter getErrorReporter() { + return subContextErrorReporter; + } + + @Override + public void reportProgress(String message, int percentage) { + averager.report( + id, + percentage, + meanPercentage -> super.reportProgress(message, meanPercentage)); + } + + @Override + public FileConfig getFileConfig() { + return subFileConfig; + } + + @Override + public TargetConfig getTargetConfig() { + return subConfig; + } }; - inj.getInstance(LFGenerator.class).doGenerate(res, fsa, subContext); - codeMapMap.putAll(subContext.getResult().getCodeMaps()); - subContexts.add(subContext); - }); - } - // Initiate an orderly shutdown in which previously submitted tasks are - // executed, but no new tasks will be accepted. - compileThreadPool.shutdown(); - - // Wait for all compile threads to finish (NOTE: Can block forever) - try { - compileThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS); - } catch (Exception e) { - Exceptions.sneakyThrow(e); - } finally { - finalizer.accept(subContexts); - } - return codeMapMap; + inj.getInstance(LFGenerator.class).doGenerate(res, fsa, subContext); + codeMapMap.putAll(subContext.getResult().getCodeMaps()); + subContexts.add(subContext); + }); } - - /** - * Process command-line arguments passed on to the generator. - * - * @param context Context of the build process. - */ - private void processCLIArguments(LFGeneratorContext context) { - if (context.getArgs().containsKey("rti")) { - setFederationRTIProperties(context); - } + // Initiate an orderly shutdown in which previously submitted tasks are + // executed, but no new tasks will be accepted. + compileThreadPool.shutdown(); + + // Wait for all compile threads to finish (NOTE: Can block forever) + try { + compileThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS); + } catch (Exception e) { + Exceptions.sneakyThrow(e); + } finally { + finalizer.accept(subContexts); } - - /** - * Set the RTI hostname, port and username if given as compiler arguments - * - * @param context Context of the build process. - */ - private void setFederationRTIProperties(LFGeneratorContext context) { - String rtiAddr = context.getArgs().getProperty("rti"); - Pattern pattern = Pattern.compile("([a-zA-Z0-9]+@)?([a-zA-Z0-9]+\\.?[a-z]{2,}|[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+):?([0-9]+)?"); - Matcher matcher = pattern.matcher(rtiAddr); - - if (!matcher.find()) { - return; - } - - // the user match group contains a trailing "@" which needs to be removed. - String userWithAt = matcher.group(1); - String user = (userWithAt == null) ? null : userWithAt.substring(0, - userWithAt.length() - - 1); - String host = matcher.group(2); - String port = matcher.group(3); - - if (host != null) { - rtiConfig.setHost(host); - } - if (port != null) { - rtiConfig.setPort(Integer.parseInt(port)); - } - if (user != null) { - rtiConfig.setUser(user); - } + return codeMapMap; + } + + /** + * Process command-line arguments passed on to the generator. + * + * @param context Context of the build process. + */ + private void processCLIArguments(LFGeneratorContext context) { + if (context.getArgs().containsKey("rti")) { + setFederationRTIProperties(context); + } + } + + /** + * Set the RTI hostname, port and username if given as compiler arguments + * + * @param context Context of the build process. + */ + private void setFederationRTIProperties(LFGeneratorContext context) { + String rtiAddr = context.getArgs().getProperty("rti"); + Pattern pattern = + Pattern.compile( + "([a-zA-Z0-9]+@)?([a-zA-Z0-9]+\\.?[a-z]{2,}|[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+):?([0-9]+)?"); + Matcher matcher = pattern.matcher(rtiAddr); + + if (!matcher.find()) { + return; } - /** - * Analyze the federation and record various properties of it. - * - * @param federation The federated reactor that contains all federates' instances. - */ - private void analyzeFederates(Reactor federation, LFGeneratorContext context) { - // Create an instantiation for the fed reactor because there isn't one. - // Creating a definition for the main reactor because there isn't one. - mainDef = LfFactory.eINSTANCE.createInstantiation(); - mainDef.setName(federation.getName()); - mainDef.setReactorClass(federation); - - // Make sure that if no federation RTI properties were given in the - // cmdline, then those specified in the lf file are not lost - if (rtiConfig.getHost().equals("localhost") && - federation.getHost() != null && - !federation.getHost().getAddr().equals("localhost")) { - rtiConfig.setHost(federation.getHost().getAddr()); - } + // the user match group contains a trailing "@" which needs to be removed. + String userWithAt = matcher.group(1); + String user = (userWithAt == null) ? null : userWithAt.substring(0, userWithAt.length() - 1); + String host = matcher.group(2); + String port = matcher.group(3); - // Since federates are always within the main (federated) reactor, - // create a list containing just that one containing instantiation. - // This will be used to look up parameter values. - List mainReactorContext = new ArrayList<>(); - mainReactorContext.add(mainDef); - - // Create a FederateInstance for each instance in the top-level reactor. - for (Instantiation instantiation : ASTUtils.allInstantiations(federation)) { - int bankWidth = ASTUtils.width(instantiation.getWidthSpec(), mainReactorContext); - if (bankWidth < 0) { - errorReporter.reportError(instantiation, "Cannot determine bank width! Assuming width of 1."); - // Continue with a bank width of 1. - bankWidth = 1; - } - List federateInstances = getFederateInstances(instantiation, bankWidth, context); - if (federatesByInstantiation == null) { - federatesByInstantiation = new LinkedHashMap<>(); - } - federatesByInstantiation.put(instantiation, federateInstances); - } + if (host != null) { + rtiConfig.setHost(host); } - - /** - * Get federate instances for a given {@code instantiation}. A bank will - * result in the creation of multiple federate instances (one for each - * member of the bank). - * - * @param instantiation An instantiation that corresponds to a federate. - * @param bankWidth The width specified for the instantiation. - * @return A list of federate instance (of type @see FederateInstance). - */ - private List getFederateInstances(Instantiation instantiation, int bankWidth, LFGeneratorContext context) { - // Create one federate instance for each instance in a bank of reactors. - List federateInstances = new ArrayList<>(bankWidth); - - for (int i = 0; i < bankWidth; i++) { - // Assign an integer ID to the federate. - int federateID = federates.size(); - var resource = instantiation.getReactorClass().eResource(); - var federateTargetConfig = new FedTargetConfig(context, resource); - FederateInstance federateInstance = new FederateInstance( - instantiation, - federateID, - i, - federateTargetConfig, - errorReporter); - federates.add(federateInstance); - federateInstances.add(federateInstance); - - if (instantiation.getHost() != null) { - federateInstance.host = instantiation.getHost().getAddr(); - // The following could be 0. - federateInstance.port = instantiation.getHost().getPort(); - // The following could be null. - federateInstance.user = instantiation.getHost().getUser(); - /* FIXME: The at keyword should support a directory component. - * federateInstance.dir = instantiation.getHost().dir - */ - if (federateInstance.host != null - && !federateInstance.host.equals("localhost") - && !federateInstance.host.equals("0.0.0.0")) { - federateInstance.isRemote = true; - } - } - } - return federateInstances; + if (port != null) { + rtiConfig.setPort(Integer.parseInt(port)); } - - /** - * Replace connections between federates in the AST with proxies that - * handle sending and receiving data. - * - * @param federation Reactor class of the federation. - */ - private void replaceFederateConnectionsWithProxies(Reactor federation) { - // Each connection in the AST may represent more than one connection between - // federation instances because of banks and multiports. We need to generate communication - // for each of these. To do this, we create a ReactorInstance so that we don't have - // to duplicate the rather complicated logic in that class. We specify a depth of 1, - // so it only creates the reactors immediately within the top level, not reactors - // that those contain. - ReactorInstance mainInstance = new ReactorInstance(federation, errorReporter); - - for (ReactorInstance child : mainInstance.children) { - for (PortInstance output : child.outputs) { - replaceConnectionFromOutputPort(output); - } - } - - // Remove the connections at the top level - federation.getConnections().clear(); - - // There will be AST transformations that invalidate some info - // cached in ReactorInstance. FIXME: most likely not needed anymore - mainInstance.clearCaches(false); + if (user != null) { + rtiConfig.setUser(user); } - - /** - * Replace the connections from the specified output port. - * - * @param output The output port instance. - */ - private void replaceConnectionFromOutputPort(PortInstance output) { - // Iterate through ranges of the output port - for (SendRange srcRange : output.getDependentPorts()) { - if (srcRange.connection == null) { - // This should not happen. - errorReporter.reportError( - output.getDefinition(), - "Unexpected error. Cannot find output connection for port" - ); - continue; - } - // Iterate through destinations - for (RuntimeRange dstRange : srcRange.destinations) { - replaceOneToManyConnection( - srcRange, - dstRange - ); - } - } + } + + /** + * Analyze the federation and record various properties of it. + * + * @param federation The federated reactor that contains all federates' instances. + */ + private void analyzeFederates(Reactor federation, LFGeneratorContext context) { + // Create an instantiation for the fed reactor because there isn't one. + // Creating a definition for the main reactor because there isn't one. + mainDef = LfFactory.eINSTANCE.createInstantiation(); + mainDef.setName(federation.getName()); + mainDef.setReactorClass(federation); + + // Make sure that if no federation RTI properties were given in the + // cmdline, then those specified in the lf file are not lost + if (rtiConfig.getHost().equals("localhost") + && federation.getHost() != null + && !federation.getHost().getAddr().equals("localhost")) { + rtiConfig.setHost(federation.getHost().getAddr()); } - /** - * Replace (potentially multiple) connection(s) that originate from an - * output port to multiple destinations. - * - * @param srcRange A range of an output port that sources data for this - * connection. - * @param dstRange A range of input ports that receive the data. - */ - private void replaceOneToManyConnection( - SendRange srcRange, - RuntimeRange dstRange - ) { - MixedRadixInt srcID = srcRange.startMR(); - MixedRadixInt dstID = dstRange.startMR(); - int dstCount = 0; - int srcCount = 0; - - while (dstCount++ < dstRange.width) { - int srcChannel = srcID.getDigits().get(0); - int srcBank = srcID.get(1); - int dstChannel = dstID.getDigits().get(0); - int dstBank = dstID.get(1); - - FederateInstance srcFederate = federatesByInstantiation.get( - srcRange.instance.getParent().getDefinition() - ).get(srcBank); - FederateInstance dstFederate = federatesByInstantiation.get( - dstRange.instance.getParent().getDefinition() - ).get(dstBank); - - // Clear banks - srcFederate.instantiation.setWidthSpec(null); - dstFederate.instantiation.setWidthSpec(null); - - FedConnectionInstance fedConnection = new FedConnectionInstance( - srcRange, - dstRange, - srcChannel, - srcBank, - dstChannel, - dstBank, - srcFederate, - dstFederate, - FedUtils.getSerializer(srcRange.connection, srcFederate, dstFederate) - ); - - replaceFedConnection(fedConnection); - - dstID.increment(); - srcID.increment(); - srcCount++; - if (srcCount == srcRange.width) { - srcID = srcRange.startMR(); // Multicast. Start over. - } - } + // Since federates are always within the main (federated) reactor, + // create a list containing just that one containing instantiation. + // This will be used to look up parameter values. + List mainReactorContext = new ArrayList<>(); + mainReactorContext.add(mainDef); + + // Create a FederateInstance for each instance in the top-level reactor. + for (Instantiation instantiation : ASTUtils.allInstantiations(federation)) { + int bankWidth = ASTUtils.width(instantiation.getWidthSpec(), mainReactorContext); + if (bankWidth < 0) { + errorReporter.reportError( + instantiation, "Cannot determine bank width! Assuming width of 1."); + // Continue with a bank width of 1. + bankWidth = 1; + } + List federateInstances = + getFederateInstances(instantiation, bankWidth, context); + if (federatesByInstantiation == null) { + federatesByInstantiation = new LinkedHashMap<>(); + } + federatesByInstantiation.put(instantiation, federateInstances); } - - /** - * Replace a one-to-one federated connection with proxies. - * - * @param connection A connection between two federates. - */ - private void replaceFedConnection(FedConnectionInstance connection) { - if (!connection.getDefinition().isPhysical() - && targetConfig.coordination != CoordinationType.DECENTRALIZED) { - // Map the delays on connections between federates. - Set dependsOnDelays = - connection.dstFederate.dependsOn.computeIfAbsent( - connection.srcFederate, - k -> new LinkedHashSet<>() - ); - // Put the delay on the cache. - if (connection.getDefinition().getDelay() != null) { - dependsOnDelays.add(connection.getDefinition().getDelay()); - } else { - // To indicate that at least one connection has no delay, add a null entry. - dependsOnDelays.add(null); - } - // Map the connections between federates. - Set sendsToDelays = - connection.srcFederate.sendsTo.computeIfAbsent( - connection.dstFederate, - k -> new LinkedHashSet<>() - ); - if (connection.getDefinition().getDelay() != null) { - sendsToDelays.add(connection.getDefinition().getDelay()); - } else { - // To indicate that at least one connection has no delay, add a null entry. - sendsToDelays.add(null); - } + } + + /** + * Get federate instances for a given {@code instantiation}. A bank will result in the creation of + * multiple federate instances (one for each member of the bank). + * + * @param instantiation An instantiation that corresponds to a federate. + * @param bankWidth The width specified for the instantiation. + * @return A list of federate instance (of type @see FederateInstance). + */ + private List getFederateInstances( + Instantiation instantiation, int bankWidth, LFGeneratorContext context) { + // Create one federate instance for each instance in a bank of reactors. + List federateInstances = new ArrayList<>(bankWidth); + + for (int i = 0; i < bankWidth; i++) { + // Assign an integer ID to the federate. + int federateID = federates.size(); + var resource = instantiation.getReactorClass().eResource(); + var federateTargetConfig = new FedTargetConfig(context, resource); + FederateInstance federateInstance = + new FederateInstance(instantiation, federateID, i, federateTargetConfig, errorReporter); + federates.add(federateInstance); + federateInstances.add(federateInstance); + + if (instantiation.getHost() != null) { + federateInstance.host = instantiation.getHost().getAddr(); + // The following could be 0. + federateInstance.port = instantiation.getHost().getPort(); + // The following could be null. + federateInstance.user = instantiation.getHost().getUser(); + /* FIXME: The at keyword should support a directory component. + * federateInstance.dir = instantiation.getHost().dir + */ + if (federateInstance.host != null + && !federateInstance.host.equals("localhost") + && !federateInstance.host.equals("0.0.0.0")) { + federateInstance.isRemote = true; } + } + } + return federateInstances; + } + + /** + * Replace connections between federates in the AST with proxies that handle sending and receiving + * data. + * + * @param federation Reactor class of the federation. + */ + private void replaceFederateConnectionsWithProxies(Reactor federation) { + // Each connection in the AST may represent more than one connection between + // federation instances because of banks and multiports. We need to generate communication + // for each of these. To do this, we create a ReactorInstance so that we don't have + // to duplicate the rather complicated logic in that class. We specify a depth of 1, + // so it only creates the reactors immediately within the top level, not reactors + // that those contain. + ReactorInstance mainInstance = new ReactorInstance(federation, errorReporter); + + for (ReactorInstance child : mainInstance.children) { + for (PortInstance output : child.outputs) { + replaceConnectionFromOutputPort(output); + } + } - FedASTUtils.makeCommunication(connection, targetConfig.coordination, errorReporter); + // Remove the connections at the top level + federation.getConnections().clear(); + + // There will be AST transformations that invalidate some info + // cached in ReactorInstance. FIXME: most likely not needed anymore + mainInstance.clearCaches(false); + } + + /** + * Replace the connections from the specified output port. + * + * @param output The output port instance. + */ + private void replaceConnectionFromOutputPort(PortInstance output) { + // Iterate through ranges of the output port + for (SendRange srcRange : output.getDependentPorts()) { + if (srcRange.connection == null) { + // This should not happen. + errorReporter.reportError( + output.getDefinition(), "Unexpected error. Cannot find output connection for port"); + continue; + } + // Iterate through destinations + for (RuntimeRange dstRange : srcRange.destinations) { + replaceOneToManyConnection(srcRange, dstRange); + } + } + } + + /** + * Replace (potentially multiple) connection(s) that originate from an output port to multiple + * destinations. + * + * @param srcRange A range of an output port that sources data for this connection. + * @param dstRange A range of input ports that receive the data. + */ + private void replaceOneToManyConnection(SendRange srcRange, RuntimeRange dstRange) { + MixedRadixInt srcID = srcRange.startMR(); + MixedRadixInt dstID = dstRange.startMR(); + int dstCount = 0; + int srcCount = 0; + + while (dstCount++ < dstRange.width) { + int srcChannel = srcID.getDigits().get(0); + int srcBank = srcID.get(1); + int dstChannel = dstID.getDigits().get(0); + int dstBank = dstID.get(1); + + FederateInstance srcFederate = + federatesByInstantiation.get(srcRange.instance.getParent().getDefinition()).get(srcBank); + FederateInstance dstFederate = + federatesByInstantiation.get(dstRange.instance.getParent().getDefinition()).get(dstBank); + + // Clear banks + srcFederate.instantiation.setWidthSpec(null); + dstFederate.instantiation.setWidthSpec(null); + + FedConnectionInstance fedConnection = + new FedConnectionInstance( + srcRange, + dstRange, + srcChannel, + srcBank, + dstChannel, + dstBank, + srcFederate, + dstFederate, + FedUtils.getSerializer(srcRange.connection, srcFederate, dstFederate)); + + replaceFedConnection(fedConnection); + + dstID.increment(); + srcID.increment(); + srcCount++; + if (srcCount == srcRange.width) { + srcID = srcRange.startMR(); // Multicast. Start over. + } } + } + + /** + * Replace a one-to-one federated connection with proxies. + * + * @param connection A connection between two federates. + */ + private void replaceFedConnection(FedConnectionInstance connection) { + if (!connection.getDefinition().isPhysical() + && targetConfig.coordination != CoordinationType.DECENTRALIZED) { + // Map the delays on connections between federates. + Set dependsOnDelays = + connection.dstFederate.dependsOn.computeIfAbsent( + connection.srcFederate, k -> new LinkedHashSet<>()); + // Put the delay on the cache. + if (connection.getDefinition().getDelay() != null) { + dependsOnDelays.add(connection.getDefinition().getDelay()); + } else { + // To indicate that at least one connection has no delay, add a null entry. + dependsOnDelays.add(null); + } + // Map the connections between federates. + Set sendsToDelays = + connection.srcFederate.sendsTo.computeIfAbsent( + connection.dstFederate, k -> new LinkedHashSet<>()); + if (connection.getDefinition().getDelay() != null) { + sendsToDelays.add(connection.getDefinition().getDelay()); + } else { + // To indicate that at least one connection has no delay, add a null entry. + sendsToDelays.add(null); + } + } + + FedASTUtils.makeCommunication(connection, targetConfig.coordination, errorReporter); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java index 95351237a7..baf13d6a0a 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java @@ -4,9 +4,7 @@ import java.util.HashSet; import java.util.Set; import java.util.stream.Collectors; - import org.eclipse.emf.ecore.util.EcoreUtil; - import org.lflang.ast.FormattingUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Import; @@ -19,44 +17,41 @@ */ public class FedImportEmitter { - private static Set visitedImports = new HashSet<>(); - - /** - * Generate import statements for {@code federate}. - */ - String generateImports(FederateInstance federate, FedFileConfig fileConfig) { - var imports = ((Model) federate.instantiation.eContainer().eContainer()) - .getImports() - .stream() - .filter(federate::contains).toList(); - - // Transform the URIs + private static Set visitedImports = new HashSet<>(); + + /** Generate import statements for {@code federate}. */ + String generateImports(FederateInstance federate, FedFileConfig fileConfig) { + var imports = + ((Model) federate.instantiation.eContainer().eContainer()) + .getImports().stream().filter(federate::contains).toList(); + + // Transform the URIs + imports.stream() + .filter(i -> !visitedImports.contains(i)) + .forEach( + i -> { + visitedImports.add(i); + Path importPath = fileConfig.srcPath.resolve(i.getImportURI()).toAbsolutePath(); + i.setImportURI( + fileConfig.getSrcPath().relativize(importPath).toString().replace('\\', '/')); + }); + + var importStatements = new CodeBuilder(); + + // Add import statements needed for the ordinary functionality of the federate + importStatements.pr( imports.stream() - .filter(i -> !visitedImports.contains(i)) - .forEach(i -> { - visitedImports.add(i); - Path importPath = - fileConfig.srcPath - .resolve(i.getImportURI()).toAbsolutePath(); - i.setImportURI(fileConfig.getSrcPath().relativize(importPath) - .toString().replace('\\', '/') - ); - }); - - var importStatements = new CodeBuilder(); - - // Add import statements needed for the ordinary functionality of the federate - importStatements.pr(imports.stream() - .map(i -> { - var new_import = EcoreUtil.copy(i); - new_import.getReactorClasses().removeIf( - importedReactor -> !federate.contains(importedReactor) - ); - return new_import; - }) - .map(FormattingUtils.renderer(federate.targetConfig.target)) - .collect(Collectors.joining("\n"))); - - return importStatements.getCode(); - } + .map( + i -> { + var new_import = EcoreUtil.copy(i); + new_import + .getReactorClasses() + .removeIf(importedReactor -> !federate.contains(importedReactor)); + return new_import; + }) + .map(FormattingUtils.renderer(federate.targetConfig.target)) + .collect(Collectors.joining("\n"))); + + return importStatements.getCode(); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java index 65b9d4cd15..86ce4f02b9 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java @@ -2,83 +2,90 @@ import java.util.function.Function; import java.util.stream.Collectors; - import org.eclipse.emf.ecore.EObject; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; +import org.lflang.ast.ASTUtils; import org.lflang.ast.FormattingUtils; import org.lflang.lf.Reactor; import org.lflang.lf.Variable; -/** - * Helper class to generate a main reactor - */ +/** Helper class to generate a main reactor */ public class FedMainEmitter { - /** - * Generate a main reactor for {@code federate}. - * - * @param federate - * @param originalMainReactor The original main reactor. - * @param errorReporter Used to report errors. - * @return The main reactor. - */ - String generateMainReactor(FederateInstance federate, Reactor originalMainReactor, ErrorReporter errorReporter) { - // FIXME: Handle modes at the top-level - if (!ASTUtils.allModes(originalMainReactor).isEmpty()) { - errorReporter.reportError( - ASTUtils.allModes(originalMainReactor).stream().findFirst().get(), - "Modes at the top level are not supported under federated execution." - ); - } - var renderer = FormattingUtils.renderer(federate.targetConfig.target); + /** + * Generate a main reactor for {@code federate}. + * + * @param federate + * @param originalMainReactor The original main reactor. + * @param errorReporter Used to report errors. + * @return The main reactor. + */ + String generateMainReactor( + FederateInstance federate, Reactor originalMainReactor, ErrorReporter errorReporter) { + // FIXME: Handle modes at the top-level + if (!ASTUtils.allModes(originalMainReactor).isEmpty()) { + errorReporter.reportError( + ASTUtils.allModes(originalMainReactor).stream().findFirst().get(), + "Modes at the top level are not supported under federated execution."); + } + var renderer = FormattingUtils.renderer(federate.targetConfig.target); - return String - .join( + return String.join( + "\n", + generateMainSignature(federate, originalMainReactor, renderer), + String.join( "\n", - generateMainSignature(federate, originalMainReactor, renderer), - String.join( - "\n", - renderer.apply(federate.instantiation), - ASTUtils.allStateVars(originalMainReactor).stream().filter(federate::contains).map(renderer).collect(Collectors.joining("\n")), - ASTUtils.allActions(originalMainReactor).stream().filter(federate::contains).map(renderer).collect(Collectors.joining("\n")), - ASTUtils.allTimers(originalMainReactor).stream().filter(federate::contains).map(renderer).collect(Collectors.joining("\n")), - ASTUtils.allMethods(originalMainReactor).stream().filter(federate::contains).map(renderer).collect(Collectors.joining("\n")), - ASTUtils.allReactions(originalMainReactor).stream().filter(federate::contains).map(renderer).collect(Collectors.joining("\n")) - ).indent(4).stripTrailing(), - "}" - ); - } + renderer.apply(federate.instantiation), + ASTUtils.allStateVars(originalMainReactor).stream() + .filter(federate::contains) + .map(renderer) + .collect(Collectors.joining("\n")), + ASTUtils.allActions(originalMainReactor).stream() + .filter(federate::contains) + .map(renderer) + .collect(Collectors.joining("\n")), + ASTUtils.allTimers(originalMainReactor).stream() + .filter(federate::contains) + .map(renderer) + .collect(Collectors.joining("\n")), + ASTUtils.allMethods(originalMainReactor).stream() + .filter(federate::contains) + .map(renderer) + .collect(Collectors.joining("\n")), + ASTUtils.allReactions(originalMainReactor).stream() + .filter(federate::contains) + .map(renderer) + .collect(Collectors.joining("\n"))) + .indent(4) + .stripTrailing(), + "}"); + } - /** - * Generate the signature of the main reactor. - * @param federate The federate. - * @param originalMainReactor The original main reactor of the original .lf file. - * @param renderer Used to render EObjects (in String representation). - */ - private CharSequence generateMainSignature(FederateInstance federate, Reactor originalMainReactor, Function renderer) { - var paramList = ASTUtils.allParameters(originalMainReactor) - .stream() - .filter(federate::contains) - .map(renderer) - .collect( - Collectors.joining( - ",", "(", ")" - ) - ); - // Empty "()" is currently not allowed by the syntax + /** + * Generate the signature of the main reactor. + * + * @param federate The federate. + * @param originalMainReactor The original main reactor of the original .lf file. + * @param renderer Used to render EObjects (in String representation). + */ + private CharSequence generateMainSignature( + FederateInstance federate, Reactor originalMainReactor, Function renderer) { + var paramList = + ASTUtils.allParameters(originalMainReactor).stream() + .filter(federate::contains) + .map(renderer) + .collect(Collectors.joining(",", "(", ")")); + // Empty "()" is currently not allowed by the syntax - var networkMessageActionsListString = federate.networkMessageActions - .stream() + var networkMessageActionsListString = + federate.networkMessageActions.stream() .map(Variable::getName) .collect(Collectors.joining(",")); - return - """ + return """ @_fed_config(network_message_actions="%s") main reactor %s { - """.formatted(networkMessageActionsListString, - paramList.equals("()") ? "" : paramList); - } + """ + .formatted(networkMessageActionsListString, paramList.equals("()") ? "" : paramList); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java index 154919c816..9cb35b2949 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java @@ -3,9 +3,8 @@ import static org.lflang.ast.ASTUtils.toText; import java.io.IOException; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; +import org.lflang.ast.ASTUtils; import org.lflang.federated.extensions.FedTargetExtensionFactory; import org.lflang.federated.launcher.RtiConfig; import org.lflang.generator.CodeBuilder; @@ -14,38 +13,43 @@ public class FedPreambleEmitter { - public FedPreambleEmitter() {} - - /** - * Add necessary code to the source and necessary build support to - * enable the requested serializations in 'enabledSerializations' - */ - String generatePreamble(FederateInstance federate, FedFileConfig fileConfig, RtiConfig rtiConfig, ErrorReporter errorReporter) - throws IOException { - CodeBuilder preambleCode = new CodeBuilder(); - - // Transfer top-level preambles - var mainModel = (Model) ASTUtils.toDefinition(federate.instantiation.getReactorClass()).eContainer(); - for (Preamble p : mainModel.getPreambles()) { - preambleCode.pr( - """ + public FedPreambleEmitter() {} + + /** + * Add necessary code to the source and necessary build support to enable the requested + * serializations in 'enabledSerializations' + */ + String generatePreamble( + FederateInstance federate, + FedFileConfig fileConfig, + RtiConfig rtiConfig, + ErrorReporter errorReporter) + throws IOException { + CodeBuilder preambleCode = new CodeBuilder(); + + // Transfer top-level preambles + var mainModel = + (Model) ASTUtils.toDefinition(federate.instantiation.getReactorClass()).eContainer(); + for (Preamble p : mainModel.getPreambles()) { + preambleCode.pr( + """ %spreamble {= %s =} - """.formatted( - p.getVisibility() == null ? "" : p.getVisibility() + " ", - toText(p.getCode()) - )); - } + """ + .formatted( + p.getVisibility() == null ? "" : p.getVisibility() + " ", toText(p.getCode()))); + } - preambleCode.pr(""" + preambleCode.pr( + """ preamble {= %s - =}""".formatted(FedTargetExtensionFactory.getExtension(federate.targetConfig.target).generatePreamble( - federate, fileConfig, rtiConfig, errorReporter - )) - ); + =}""" + .formatted( + FedTargetExtensionFactory.getExtension(federate.targetConfig.target) + .generatePreamble(federate, fileConfig, rtiConfig, errorReporter))); - return preambleCode.getCode(); - } + return preambleCode.getCode(); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java index 976049601c..69a6342486 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java @@ -1,24 +1,22 @@ package org.lflang.federated.generator; import java.util.stream.Collectors; - import org.lflang.ast.FormattingUtils; import org.lflang.lf.Model; public class FedReactorEmitter { - public FedReactorEmitter() {} + public FedReactorEmitter() {} - /** - * @param federate - * @return - */ - String generateReactorDefinitions(FederateInstance federate) { - return ((Model) federate.instantiation.eContainer().eContainer()) - .getReactors() - .stream() + /** + * @param federate + * @return + */ + String generateReactorDefinitions(FederateInstance federate) { + return ((Model) federate.instantiation.eContainer().eContainer()) + .getReactors().stream() .filter(federate::contains) .map(FormattingUtils.renderer(federate.targetConfig.target)) .collect(Collectors.joining("\n")); - } + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java b/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java index af83d1f919..3252f31a39 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java @@ -2,77 +2,69 @@ import static org.lflang.ast.ASTUtils.convertToEmptyListIfNull; +import org.eclipse.emf.ecore.resource.Resource; import org.lflang.ErrorReporter; import org.lflang.TargetConfig; import org.lflang.TargetProperty; import org.lflang.generator.GeneratorUtils; import org.lflang.generator.LFGeneratorContext; -import org.eclipse.emf.ecore.resource.Resource; /** - * Subclass of TargetConfig with a specialized constructor for creating configurations for federates. + * Subclass of TargetConfig with a specialized constructor for creating configurations for + * federates. + * * @author Marten Lohstroh */ public class FedTargetConfig extends TargetConfig { - /** - * Create a configuration for a federate given a main context and the resource in which the class - * of the federate is specified. - * @param context The generator context. - * @param federateResource The resource in which to find the reactor class of the federate. - */ - public FedTargetConfig(LFGeneratorContext context, Resource federateResource) { - // Create target config based on the main .lf file - super( - context.getArgs(), - GeneratorUtils.findTargetDecl(context.getFileConfig().resource), - context.getErrorReporter() - ); + /** + * Create a configuration for a federate given a main context and the resource in which the class + * of the federate is specified. + * + * @param context The generator context. + * @param federateResource The resource in which to find the reactor class of the federate. + */ + public FedTargetConfig(LFGeneratorContext context, Resource federateResource) { + // Create target config based on the main .lf file + super( + context.getArgs(), + GeneratorUtils.findTargetDecl(context.getFileConfig().resource), + context.getErrorReporter()); - mergeImportedConfig( - federateResource, - context.getFileConfig().resource, - context.getErrorReporter() - ); + mergeImportedConfig( + federateResource, context.getFileConfig().resource, context.getErrorReporter()); - clearPropertiesToIgnore(); + clearPropertiesToIgnore(); - ((FedFileConfig)context.getFileConfig()).relativizePaths(this); + ((FedFileConfig) context.getFileConfig()).relativizePaths(this); + } + /** + * If the federate that target configuration applies to is imported, merge target properties + * declared in the file that it was imported from. + * + * @param federateResource The resource where the class of the federate is specified. + * @param mainResource The resource in which the federation (i.e., main reactor) is specified. + * @param errorReporter An error reporter to use when problems are encountered. + */ + private void mergeImportedConfig( + Resource federateResource, Resource mainResource, ErrorReporter errorReporter) { + // If the federate is imported, then update the configuration based on target properties + // in the imported file. + if (!federateResource.equals(mainResource)) { + var importedTargetDecl = GeneratorUtils.findTargetDecl(federateResource); + var targetProperties = importedTargetDecl.getConfig(); + if (targetProperties != null) { + // Merge properties + TargetProperty.update( + this, convertToEmptyListIfNull(targetProperties.getPairs()), errorReporter); + } } + } - /** - * If the federate that target configuration applies to is imported, merge target properties - * declared in the file that it was imported from. - * @param federateResource The resource where the class of the federate is specified. - * @param mainResource The resource in which the federation (i.e., main reactor) is specified. - * @param errorReporter An error reporter to use when problems are encountered. - */ - private void mergeImportedConfig( - Resource federateResource, - Resource mainResource, - ErrorReporter errorReporter) { - // If the federate is imported, then update the configuration based on target properties - // in the imported file. - if (!federateResource.equals(mainResource)) { - var importedTargetDecl = GeneratorUtils.findTargetDecl(federateResource); - var targetProperties = importedTargetDecl.getConfig(); - if (targetProperties != null) { - // Merge properties - TargetProperty.update( - this, - convertToEmptyListIfNull(targetProperties.getPairs()), - errorReporter - ); - } - } - } - - /** - * Method for the removal of things that should not appear in the target config of a federate. - */ - private void clearPropertiesToIgnore() { - this.setByUser.remove(TargetProperty.CLOCK_SYNC); - this.setByUser.remove(TargetProperty.CLOCK_SYNC_OPTIONS); - } + /** Method for the removal of things that should not appear in the target config of a federate. */ + private void clearPropertiesToIgnore() { + this.setByUser.remove(TargetProperty.CLOCK_SYNC); + this.setByUser.remove(TargetProperty.CLOCK_SYNC_OPTIONS); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java b/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java index 1616286048..402138f283 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java +++ b/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java @@ -1,7 +1,6 @@ package org.lflang.federated.generator; import java.io.IOException; - import org.lflang.ErrorReporter; import org.lflang.TargetProperty; import org.lflang.ast.FormattingUtils; @@ -11,34 +10,25 @@ public class FedTargetEmitter { - String generateTarget( - LFGeneratorContext context, - int numOfFederates, - FederateInstance federate, - FedFileConfig fileConfig, - ErrorReporter errorReporter, - RtiConfig rtiConfig - ) throws IOException { + String generateTarget( + LFGeneratorContext context, + int numOfFederates, + FederateInstance federate, + FedFileConfig fileConfig, + ErrorReporter errorReporter, + RtiConfig rtiConfig) + throws IOException { - // FIXME: First of all, this is not an initialization; there is all sorts of stuff happening - // in the C implementation of this method. Second, true initialization stuff should happen - // when the target config is constructed, not when we're doing code generation. - // See https://issues.lf-lang.org/1667 - FedTargetExtensionFactory.getExtension(federate.targetConfig.target) - .initializeTargetConfig( - context, - numOfFederates, - federate, - fileConfig, - errorReporter, - rtiConfig - ); + // FIXME: First of all, this is not an initialization; there is all sorts of stuff happening + // in the C implementation of this method. Second, true initialization stuff should happen + // when the target config is constructed, not when we're doing code generation. + // See https://issues.lf-lang.org/1667 + FedTargetExtensionFactory.getExtension(federate.targetConfig.target) + .initializeTargetConfig( + context, numOfFederates, federate, fileConfig, errorReporter, rtiConfig); - return FormattingUtils.renderer(federate.targetConfig.target).apply( - TargetProperty.extractTargetDecl( - federate.targetConfig.target, - federate.targetConfig - ) - ); - } + return FormattingUtils.renderer(federate.targetConfig.target) + .apply( + TargetProperty.extractTargetDecl(federate.targetConfig.target, federate.targetConfig)); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FedUtils.java b/org.lflang/src/org/lflang/federated/generator/FedUtils.java index dd5ee6a9b3..2970be7c2a 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedUtils.java +++ b/org.lflang/src/org/lflang/federated/generator/FedUtils.java @@ -1,38 +1,24 @@ package org.lflang.federated.generator; -import java.util.List; - import org.lflang.federated.serialization.SupportedSerializers; -import org.lflang.generator.PortInstance; -import org.lflang.generator.ReactionInstance; -import org.lflang.generator.ReactorInstance; import org.lflang.lf.Connection; -import org.lflang.lf.Reaction; -import org.lflang.lf.VarRef; -/** - * A collection of utility methods for the federated generator. - */ +/** A collection of utility methods for the federated generator. */ public class FedUtils { - /** - * Get the serializer for the {@code connection} between {@code srcFederate} and {@code dstFederate}. - */ - public static SupportedSerializers getSerializer( - Connection connection, - FederateInstance srcFederate, - FederateInstance dstFederate - ) { - // Get the serializer - SupportedSerializers serializer = SupportedSerializers.NATIVE; - if (connection.getSerializer() != null) { - serializer = SupportedSerializers.valueOf( - connection.getSerializer().getType().toUpperCase() - ); - } - // Add it to the list of enabled serializers for the source and destination federates - srcFederate.enabledSerializers.add(serializer); - dstFederate.enabledSerializers.add(serializer); - return serializer; + /** + * Get the serializer for the {@code connection} between {@code srcFederate} and {@code + * dstFederate}. + */ + public static SupportedSerializers getSerializer( + Connection connection, FederateInstance srcFederate, FederateInstance dstFederate) { + // Get the serializer + SupportedSerializers serializer = SupportedSerializers.NATIVE; + if (connection.getSerializer() != null) { + serializer = SupportedSerializers.valueOf(connection.getSerializer().getType().toUpperCase()); } - + // Add it to the list of enabled serializers for the source and destination federates + srcFederate.enabledSerializers.add(serializer); + dstFederate.enabledSerializers.add(serializer); + return serializer; + } } diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java index 0669b4f9dc..ee3c0a46f0 100644 --- a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java +++ b/org.lflang/src/org/lflang/federated/generator/FederateInstance.java @@ -1,30 +1,31 @@ -/** Instance of a federate specification. +/** + * Instance of a federate specification. * -Copyright (c) 2020, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ - + *

    Copyright (c) 2020, The University of California at Berkeley. + * + *

    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. + * + *

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR + * CONTRIBUTORS 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. + * ************* + */ package org.lflang.federated.generator; +import com.google.common.base.Objects; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; @@ -34,13 +35,11 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.EObject; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.TargetConfig; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.generator.ActionInstance; import org.lflang.generator.PortInstance; @@ -66,599 +65,559 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.VarRef; import org.lflang.lf.Variable; -import com.google.common.base.Objects; - - /** - * Instance of a federate, or marker that no federation has been defined - * (if isSingleton() returns true) FIXME: this comment makes no sense. - * Every top-level reactor (contained - * directly by the main reactor) is a federate, so there will be one - * instance of this class for each top-level reactor. + * Instance of a federate, or marker that no federation has been defined (if isSingleton() returns + * true) FIXME: this comment makes no sense. Every top-level reactor (contained directly by the main + * reactor) is a federate, so there will be one instance of this class for each top-level reactor. * * @author Edward A. Lee * @author Soroush Bateni */ public class FederateInstance { // why does this not extend ReactorInstance? - /** - * Construct a new instance with the specified instantiation of - * of a top-level reactor. The federate will be given the specified - * integer ID. - * @param instantiation The instantiation of a top-level reactor, - * or null if no federation has been defined. - * @param id The federate ID. - * @param bankIndex If instantiation.widthSpec !== null, this gives the bank position. - * @param errorReporter The error reporter - */ - public FederateInstance( - Instantiation instantiation, - int id, - int bankIndex, - TargetConfig targetConfig, - ErrorReporter errorReporter) { - this.instantiation = instantiation; - this.id = id; - this.bankIndex = bankIndex; - this.errorReporter = errorReporter; - this.targetConfig = targetConfig; - - if (instantiation != null) { - // If the instantiation is in a bank, then we have to append - // the bank index to the name. - if (instantiation.getWidthSpec() != null) { - this.name = "federate__" + instantiation.getName() + "__" + bankIndex; - } else { - this.name = "federate__" + instantiation.getName(); - } - } + /** + * Construct a new instance with the specified instantiation of of a top-level reactor. The + * federate will be given the specified integer ID. + * + * @param instantiation The instantiation of a top-level reactor, or null if no federation has + * been defined. + * @param id The federate ID. + * @param bankIndex If instantiation.widthSpec !== null, this gives the bank position. + * @param errorReporter The error reporter + */ + public FederateInstance( + Instantiation instantiation, + int id, + int bankIndex, + TargetConfig targetConfig, + ErrorReporter errorReporter) { + this.instantiation = instantiation; + this.id = id; + this.bankIndex = bankIndex; + this.errorReporter = errorReporter; + this.targetConfig = targetConfig; + + if (instantiation != null) { + // If the instantiation is in a bank, then we have to append + // the bank index to the name. + if (instantiation.getWidthSpec() != null) { + this.name = "federate__" + instantiation.getName() + "__" + bankIndex; + } else { + this.name = "federate__" + instantiation.getName(); + } } - - ///////////////////////////////////////////// - //// Public Fields - - /** - * The position within a bank of reactors for this federate. - * This is 0 if the instantiation is not a bank of reactors. - */ - public int bankIndex = 0; - - /** - * A list of outputs that can be triggered directly or indirectly by physical actions. - */ - public Set outputsConnectedToPhysicalActions = new LinkedHashSet<>(); - - /** - * The host, if specified using the 'at' keyword. - */ - public String host = "localhost"; - - - /** - * The instantiation of the top-level reactor, or null if there is no federation. - */ - public Instantiation instantiation; - public Instantiation getInstantiation() { - return instantiation; + } + + ///////////////////////////////////////////// + //// Public Fields + + /** + * The position within a bank of reactors for this federate. This is 0 if the instantiation is not + * a bank of reactors. + */ + public int bankIndex = 0; + + /** A list of outputs that can be triggered directly or indirectly by physical actions. */ + public Set outputsConnectedToPhysicalActions = new LinkedHashSet<>(); + + /** The host, if specified using the 'at' keyword. */ + public String host = "localhost"; + + /** The instantiation of the top-level reactor, or null if there is no federation. */ + public Instantiation instantiation; + + public Instantiation getInstantiation() { + return instantiation; + } + + /** A list of individual connections between federates */ + public Set connections = new HashSet<>(); + + /** + * Map from the federates that this federate receives messages from to the delays on connections + * from that federate. The delay set may include null, meaning that there is a connection from the + * federate instance that has no delay. + */ + public Map> dependsOn = new LinkedHashMap<>(); + + /** The directory, if specified using the 'at' keyword. */ + public String dir = null; + + /** The port, if specified using the 'at' keyword. */ + public int port = 0; + + /** + * Map from the federates that this federate sends messages to to the delays on connections to + * that federate. The delay set may may include null, meaning that there is a connection from the + * federate instance that has no delay. + */ + public Map> sendsTo = new LinkedHashMap<>(); + + /** The user, if specified using the 'at' keyword. */ + public String user = null; + + /** The integer ID of this federate. */ + public int id = 0; + + /** + * The name of this federate instance. This will be the instantiation name, possibly appended with + * "__n", where n is the bank position of this instance if the instantiation is of a bank of + * reactors. + */ + public String name = "Unnamed"; + + /** + * List of networkMessage actions. Each of these handles a message received from another federate + * over the network. The ID of receiving port is simply the position of the action in the list. + * The sending federate needs to specify this ID. + */ + public List networkMessageActions = new ArrayList<>(); + + /** + * A set of federates with which this federate has an inbound connection There will only be one + * physical connection even if federate A has defined multiple physical connections to federate B. + * The message handler on federate A will be responsible for including the appropriate information + * in the message header (such as port ID) to help the receiver distinguish different events. + */ + public Set inboundP2PConnections = new LinkedHashSet<>(); + + /** + * A list of federate with which this federate has an outbound physical connection. There will + * only be one physical connection even if federate A has defined multiple physical connections to + * federate B. The message handler on federate B will be responsible for distinguishing the + * incoming messages by parsing their header and scheduling the appropriate action. + */ + public Set outboundP2PConnections = new LinkedHashSet<>(); + + /** + * A list of triggers for network input control reactions. This is used to trigger all the input + * network control reactions that might be nested in a hierarchy. + */ + public List networkInputControlReactionsTriggers = new ArrayList<>(); + + /** + * The trigger that triggers the output control reaction of this federate. + * + *

    The network output control reactions send a PORT_ABSENT message for a network output port, + * if it is absent at the current tag, to notify all downstream federates that no value will be + * present on the given network port, allowing input control reactions on those federates to stop + * blocking. + */ + public Variable networkOutputControlReactionsTrigger = null; + + /** Indicates whether the federate is remote or local */ + public boolean isRemote = false; + + /** + * List of generated network reactions (network receivers, network input control reactions, + * network senders, and network output control reactions) that belong to this federate instance. + */ + public List networkReactions = new ArrayList<>(); + + /** Parsed target config of the federate. */ + public TargetConfig targetConfig; + + /** Keep a unique list of enabled serializers */ + public HashSet enabledSerializers = new HashSet<>(); + + /** + * Return true if the specified EObject should be included in the code generated for this + * federate. + * + * @param object An {@code EObject} + * @return True if this federate contains the EObject. + */ + public boolean contains(EObject object) { + if (object instanceof Action) { + return contains((Action) object); + } else if (object instanceof Reaction) { + return contains((Reaction) object); + } else if (object instanceof Timer) { + return contains((Timer) object); + } else if (object instanceof ReactorDecl) { + return contains(this.instantiation, (ReactorDecl) object); + } else if (object instanceof Import) { + return contains((Import) object); + } else if (object instanceof Parameter) { + return contains((Parameter) object); + } else if (object instanceof StateVar) { + return true; // FIXME: Should we disallow state vars at the top level? } - - /** - * A list of individual connections between federates - */ - public Set connections = new HashSet<>(); - - /** - * Map from the federates that this federate receives messages from - * to the delays on connections from that federate. The delay set - * may include null, meaning that there is a connection - * from the federate instance that has no delay. - */ - public Map> dependsOn = new LinkedHashMap<>(); - - /** - * The directory, if specified using the 'at' keyword. - */ - public String dir = null; - - /** - * The port, if specified using the 'at' keyword. - */ - public int port = 0; - - /** - * Map from the federates that this federate sends messages to - * to the delays on connections to that federate. The delay set - * may may include null, meaning that there is a connection - * from the federate instance that has no delay. - */ - public Map> sendsTo = new LinkedHashMap<>(); - - /** - * The user, if specified using the 'at' keyword. - */ - public String user = null; - - /** - * The integer ID of this federate. - */ - public int id = 0; - - - /** - * The name of this federate instance. This will be the instantiation - * name, possibly appended with "__n", where n is the bank position of - * this instance if the instantiation is of a bank of reactors. - */ - public String name = "Unnamed"; - - /** - * List of networkMessage actions. Each of these handles a message - * received from another federate over the network. The ID of - * receiving port is simply the position of the action in the list. - * The sending federate needs to specify this ID. - */ - public List networkMessageActions = new ArrayList<>(); - - /** - * A set of federates with which this federate has an inbound connection - * There will only be one physical connection even if federate A has defined multiple - * physical connections to federate B. The message handler on federate A will be - * responsible for including the appropriate information in the message header (such as port ID) - * to help the receiver distinguish different events. - */ - public Set inboundP2PConnections = new LinkedHashSet<>(); - - /** - * A list of federate with which this federate has an outbound physical connection. - * There will only be one physical connection even if federate A has defined multiple - * physical connections to federate B. The message handler on federate B will be - * responsible for distinguishing the incoming messages by parsing their header and - * scheduling the appropriate action. - */ - public Set outboundP2PConnections = new LinkedHashSet<>(); - - /** - * A list of triggers for network input control reactions. This is used to trigger - * all the input network control reactions that might be nested in a hierarchy. - */ - public List networkInputControlReactionsTriggers = new ArrayList<>(); - - /** - * The trigger that triggers the output control reaction of this - * federate. - * - * The network output control reactions send a PORT_ABSENT message for a network output port, - * if it is absent at the current tag, to notify all downstream federates that no value will - * be present on the given network port, allowing input control reactions on those federates - * to stop blocking. - */ - public Variable networkOutputControlReactionsTrigger = null; - - /** - * Indicates whether the federate is remote or local - */ - public boolean isRemote = false; - - /** - * List of generated network reactions (network receivers, - * network input control reactions, network senders, and network output control - * reactions) that belong to this federate instance. - */ - public List networkReactions = new ArrayList<>(); - - /** - * Parsed target config of the federate. - */ - public TargetConfig targetConfig; - - /** - * Keep a unique list of enabled serializers - */ - public HashSet enabledSerializers = new HashSet<>(); - - /** - * Return true if the specified EObject should be included in the code - * generated for this federate. - * - * @param object An {@code EObject} - * @return True if this federate contains the EObject. - */ - public boolean contains(EObject object) { - if (object instanceof Action) { - return contains((Action)object); - } else if (object instanceof Reaction) { - return contains((Reaction)object); - } else if (object instanceof Timer) { - return contains((Timer)object); - } else if (object instanceof ReactorDecl) { - return contains(this.instantiation, (ReactorDecl)object); - } else if (object instanceof Import) { - return contains((Import)object); - } else if (object instanceof Parameter) { - return contains((Parameter)object); - } else if (object instanceof StateVar) { - return true; // FIXME: Should we disallow state vars at the top level? - } - throw new UnsupportedOperationException("EObject class "+object.eClass().getName()+" not supported."); + throw new UnsupportedOperationException( + "EObject class " + object.eClass().getName() + " not supported."); + } + + /** + * Return true if the specified reactor belongs to this federate. + * + * @param instantiation The instantiation to look inside + * @param reactor The reactor declaration to find + */ + private boolean contains(Instantiation instantiation, ReactorDecl reactor) { + if (instantiation.getReactorClass().equals(ASTUtils.toDefinition(reactor))) { + return true; } - /** - * Return true if the specified reactor belongs to this federate. - * @param instantiation The instantiation to look inside - * @param reactor The reactor declaration to find - */ - private boolean contains( - Instantiation instantiation, - ReactorDecl reactor - ) { - if (instantiation.getReactorClass().equals(ASTUtils.toDefinition(reactor))) { - return true; - } - - boolean instantiationsCheck = false; - // For a federate, we don't need to look inside imported reactors. - if (instantiation.getReactorClass() instanceof Reactor reactorDef) { - for (Instantiation child : reactorDef.getInstantiations()) { - instantiationsCheck |= contains(child, reactor); - } - } - - return instantiationsCheck; + boolean instantiationsCheck = false; + // For a federate, we don't need to look inside imported reactors. + if (instantiation.getReactorClass() instanceof Reactor reactorDef) { + for (Instantiation child : reactorDef.getInstantiations()) { + instantiationsCheck |= contains(child, reactor); + } } - /** - * Return true if the specified import should be included in the code generated for this federate. - * @param imp The import - */ - private boolean contains(Import imp) { - for (ImportedReactor reactor : imp.getReactorClasses()) { - if (contains(reactor)) { - return true; - } - } - return false; + return instantiationsCheck; + } + + /** + * Return true if the specified import should be included in the code generated for this federate. + * + * @param imp The import + */ + private boolean contains(Import imp) { + for (ImportedReactor reactor : imp.getReactorClasses()) { + if (contains(reactor)) { + return true; + } } - - /** - * Return true if the specified parameter should be included in the code generated for this federate. - * @param param The parameter - */ - private boolean contains(Parameter param) { - boolean returnValue = false; - // Check if param is referenced in this federate's instantiation - returnValue = instantiation.getParameters().stream().anyMatch( - assignment -> assignment.getRhs() - .getExprs() - .stream() - .filter( - it -> it instanceof ParameterReference - ) - .map(it -> ((ParameterReference) it).getParameter()) - .toList() - .contains(param) - ); - // If there are any user-defined top-level reactions, they could access - // the parameters, so we need to include the parameter. - var topLevelUserDefinedReactions = ((Reactor) instantiation.eContainer()) - .getReactions().stream().filter( - r -> !networkReactions.contains(r) && contains(r) - ).collect(Collectors.toCollection(ArrayList::new)); - returnValue |= !topLevelUserDefinedReactions.isEmpty(); - return returnValue; - } - - /** - * Return true if the specified action should be included in the code generated - * for this federate. This means that either the action is used as a trigger, - * a source, or an effect in a top-level reaction that belongs to this federate. - * This returns true if the program is not federated. - * - * @param action The action - * @return True if this federate contains the action. - */ - private boolean contains(Action action) { - Reactor reactor = ASTUtils.getEnclosingReactor(action); - - // If the action is used as a trigger, a source, or an effect for a top-level reaction - // that belongs to this federate, then generate it. - for (Reaction react : ASTUtils.allReactions(reactor)) { - if (contains(react)) { - // Look in triggers - for (TriggerRef trigger : convertToEmptyListIfNull(react.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (Objects.equal(triggerAsVarRef.getVariable(), action)) { - return true; - } - } - } - // Look in sources - for (VarRef source : convertToEmptyListIfNull(react.getSources())) { - if (Objects.equal(source.getVariable(), action)) { - return true; - } - } - // Look in effects - for (VarRef effect : convertToEmptyListIfNull(react.getEffects())) { - if (Objects.equal(effect.getVariable(), action)) { - return true; - } - } + return false; + } + + /** + * Return true if the specified parameter should be included in the code generated for this + * federate. + * + * @param param The parameter + */ + private boolean contains(Parameter param) { + boolean returnValue = false; + // Check if param is referenced in this federate's instantiation + returnValue = + instantiation.getParameters().stream() + .anyMatch( + assignment -> + assignment.getRhs().getExprs().stream() + .filter(it -> it instanceof ParameterReference) + .map(it -> ((ParameterReference) it).getParameter()) + .toList() + .contains(param)); + // If there are any user-defined top-level reactions, they could access + // the parameters, so we need to include the parameter. + var topLevelUserDefinedReactions = + ((Reactor) instantiation.eContainer()) + .getReactions().stream() + .filter(r -> !networkReactions.contains(r) && contains(r)) + .collect(Collectors.toCollection(ArrayList::new)); + returnValue |= !topLevelUserDefinedReactions.isEmpty(); + return returnValue; + } + + /** + * Return true if the specified action should be included in the code generated for this federate. + * This means that either the action is used as a trigger, a source, or an effect in a top-level + * reaction that belongs to this federate. This returns true if the program is not federated. + * + * @param action The action + * @return True if this federate contains the action. + */ + private boolean contains(Action action) { + Reactor reactor = ASTUtils.getEnclosingReactor(action); + + // If the action is used as a trigger, a source, or an effect for a top-level reaction + // that belongs to this federate, then generate it. + for (Reaction react : ASTUtils.allReactions(reactor)) { + if (contains(react)) { + // Look in triggers + for (TriggerRef trigger : convertToEmptyListIfNull(react.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (Objects.equal(triggerAsVarRef.getVariable(), action)) { + return true; } + } } - - return false; - } - - /** - * Return true if the specified reaction should be included in the code generated for this - * federate at the top-level. This means that if the reaction is triggered by or - * sends data to a port of a contained reactor, then that reaction - * is in the federate. Otherwise, return false. - * - * NOTE: This method assumes that it will not be called with reaction arguments - * that are within other federates. It should only be called on reactions that are - * either at the top level or within this federate. For this reason, for any reaction - * not at the top level, it returns true. - * - * @param reaction The reaction. - */ - private boolean contains(Reaction reaction) { - Reactor reactor = ASTUtils.getEnclosingReactor(reaction); - - assert reactor != null; - if (!reactor.getReactions().contains(reaction)) return false; - - if (networkReactions.contains(reaction)) { - // Reaction is a network reaction that belongs to this federate + // Look in sources + for (VarRef source : convertToEmptyListIfNull(react.getSources())) { + if (Objects.equal(source.getVariable(), action)) { return true; + } } - - int reactionBankIndex = FedASTUtils.getReactionBankIndex(reaction); - if (reactionBankIndex >= 0 && this.bankIndex >= 0 && reactionBankIndex != this.bankIndex) { - return false; - } - - // If this has been called before, then the result of the - // following check is cached. - if (excludeReactions != null) { - return !excludeReactions.contains(reaction); + // Look in effects + for (VarRef effect : convertToEmptyListIfNull(react.getEffects())) { + if (Objects.equal(effect.getVariable(), action)) { + return true; + } } + } + } - indexExcludedTopLevelReactions(reactor); - - return !excludeReactions.contains(reaction); + return false; + } + + /** + * Return true if the specified reaction should be included in the code generated for this + * federate at the top-level. This means that if the reaction is triggered by or sends data to a + * port of a contained reactor, then that reaction is in the federate. Otherwise, return false. + * + *

    NOTE: This method assumes that it will not be called with reaction arguments that are within + * other federates. It should only be called on reactions that are either at the top level or + * within this federate. For this reason, for any reaction not at the top level, it returns true. + * + * @param reaction The reaction. + */ + private boolean contains(Reaction reaction) { + Reactor reactor = ASTUtils.getEnclosingReactor(reaction); + + assert reactor != null; + if (!reactor.getReactions().contains(reaction)) return false; + + if (networkReactions.contains(reaction)) { + // Reaction is a network reaction that belongs to this federate + return true; } - /** - * Return true if the specified timer should be included in the code generated - * for the federate. This means that the timer is used as a trigger - * in a top-level reaction that belongs to this federate. - * This also returns true if the program is not federated. - * - * @return True if this federate contains the action in the specified reactor - */ - private boolean contains(Timer timer) { - Reactor reactor = ASTUtils.getEnclosingReactor(timer); - - // If the action is used as a trigger, a source, or an effect for a top-level reaction - // that belongs to this federate, then generate it. - for (Reaction r : ASTUtils.allReactions(reactor)) { - if (contains(r)) { - // Look in triggers - for (TriggerRef trigger : convertToEmptyListIfNull(r.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (Objects.equal(triggerAsVarRef.getVariable(), timer)) { - return true; - } - } - } - } - } + int reactionBankIndex = FedASTUtils.getReactionBankIndex(reaction); + if (reactionBankIndex >= 0 && this.bankIndex >= 0 && reactionBankIndex != this.bankIndex) { + return false; + } - return false; + // If this has been called before, then the result of the + // following check is cached. + if (excludeReactions != null) { + return !excludeReactions.contains(reaction); } - /** - * Return true if the specified reactor instance or any parent - * reactor instance is contained by this federate. - * If the specified instance is the top-level reactor, return true - * (the top-level reactor belongs to all federates). - * If this federate instance is a singleton, then return true if the - * instance is non null. - * - * NOTE: If the instance is bank within the top level, then this - * returns true even though only one of the bank members is in the federate. - * - * @param instance The reactor instance. - * @return True if this federate contains the reactor instance - */ - public boolean contains(ReactorInstance instance) { - if (instance.getParent() == null) { - return true; // Top-level reactor - } - // Start with this instance, then check its parents. - ReactorInstance i = instance; - while (i != null) { - if (i.getDefinition() == instantiation) { - return true; + indexExcludedTopLevelReactions(reactor); + + return !excludeReactions.contains(reaction); + } + + /** + * Return true if the specified timer should be included in the code generated for the federate. + * This means that the timer is used as a trigger in a top-level reaction that belongs to this + * federate. This also returns true if the program is not federated. + * + * @return True if this federate contains the action in the specified reactor + */ + private boolean contains(Timer timer) { + Reactor reactor = ASTUtils.getEnclosingReactor(timer); + + // If the action is used as a trigger, a source, or an effect for a top-level reaction + // that belongs to this federate, then generate it. + for (Reaction r : ASTUtils.allReactions(reactor)) { + if (contains(r)) { + // Look in triggers + for (TriggerRef trigger : convertToEmptyListIfNull(r.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (Objects.equal(triggerAsVarRef.getVariable(), timer)) { + return true; } - i = i.getParent(); + } } - return false; + } } - /** - * Build an index of reactions at the top-level (in the - * federatedReactor) that don't belong to this federate - * instance. This index is put in the excludeReactions - * class variable. - * - * @param federatedReactor The top-level federated reactor - */ - private void indexExcludedTopLevelReactions(Reactor federatedReactor) { - boolean inFederate = false; - if (excludeReactions != null) { - throw new IllegalStateException("The index for excluded reactions at the top level is already built."); - } + return false; + } + + /** + * Return true if the specified reactor instance or any parent reactor instance is contained by + * this federate. If the specified instance is the top-level reactor, return true (the top-level + * reactor belongs to all federates). If this federate instance is a singleton, then return true + * if the instance is non null. + * + *

    NOTE: If the instance is bank within the top level, then this returns true even though only + * one of the bank members is in the federate. + * + * @param instance The reactor instance. + * @return True if this federate contains the reactor instance + */ + public boolean contains(ReactorInstance instance) { + if (instance.getParent() == null) { + return true; // Top-level reactor + } + // Start with this instance, then check its parents. + ReactorInstance i = instance; + while (i != null) { + if (i.getDefinition() == instantiation) { + return true; + } + i = i.getParent(); + } + return false; + } + + /** + * Build an index of reactions at the top-level (in the federatedReactor) that don't belong to + * this federate instance. This index is put in the excludeReactions class variable. + * + * @param federatedReactor The top-level federated reactor + */ + private void indexExcludedTopLevelReactions(Reactor federatedReactor) { + boolean inFederate = false; + if (excludeReactions != null) { + throw new IllegalStateException( + "The index for excluded reactions at the top level is already built."); + } - excludeReactions = new LinkedHashSet<>(); - - // Construct the set of excluded reactions for this federate. - // If a reaction is a network reaction that belongs to this federate, we - // don't need to perform this analysis. - Iterable reactions = ASTUtils.allReactions(federatedReactor).stream().filter(it -> !networkReactions.contains(it)).collect(Collectors.toList()); - for (Reaction react : reactions) { - // Create a collection of all the VarRefs (i.e., triggers, sources, and effects) in the react - // signature that are ports that reference federates. - // We then later check that all these VarRefs reference this federate. If not, we will add this - // react to the list of reactions that have to be excluded (note that mixing VarRefs from - // different federates is not allowed). - List allVarRefsReferencingFederates = new ArrayList<>(); - // Add all the triggers that are outputs - Stream triggersAsVarRef = react.getTriggers().stream().filter(it -> it instanceof VarRef).map(it -> (VarRef) it); - allVarRefsReferencingFederates.addAll( - triggersAsVarRef.filter(it -> it.getVariable() instanceof Output).toList() - ); - // Add all the sources that are outputs - allVarRefsReferencingFederates.addAll( - react.getSources().stream().filter(it -> it.getVariable() instanceof Output).toList() - ); - // Add all the effects that are inputs - allVarRefsReferencingFederates.addAll( - react.getEffects().stream().filter(it -> it.getVariable() instanceof Input).toList() - ); - inFederate = containsAllVarRefs(allVarRefsReferencingFederates); - if (!inFederate) { - excludeReactions.add(react); - } + excludeReactions = new LinkedHashSet<>(); + + // Construct the set of excluded reactions for this federate. + // If a reaction is a network reaction that belongs to this federate, we + // don't need to perform this analysis. + Iterable reactions = + ASTUtils.allReactions(federatedReactor).stream() + .filter(it -> !networkReactions.contains(it)) + .collect(Collectors.toList()); + for (Reaction react : reactions) { + // Create a collection of all the VarRefs (i.e., triggers, sources, and effects) in the react + // signature that are ports that reference federates. + // We then later check that all these VarRefs reference this federate. If not, we will add + // this + // react to the list of reactions that have to be excluded (note that mixing VarRefs from + // different federates is not allowed). + List allVarRefsReferencingFederates = new ArrayList<>(); + // Add all the triggers that are outputs + Stream triggersAsVarRef = + react.getTriggers().stream().filter(it -> it instanceof VarRef).map(it -> (VarRef) it); + allVarRefsReferencingFederates.addAll( + triggersAsVarRef.filter(it -> it.getVariable() instanceof Output).toList()); + // Add all the sources that are outputs + allVarRefsReferencingFederates.addAll( + react.getSources().stream().filter(it -> it.getVariable() instanceof Output).toList()); + // Add all the effects that are inputs + allVarRefsReferencingFederates.addAll( + react.getEffects().stream().filter(it -> it.getVariable() instanceof Input).toList()); + inFederate = containsAllVarRefs(allVarRefsReferencingFederates); + if (!inFederate) { + excludeReactions.add(react); + } + } + } + + /** + * Return true if all members of 'varRefs' belong to this federate. + * + *

    As a convenience measure, if some members of 'varRefs' are from different federates, also + * report an error. + * + * @param varRefs A collection of VarRefs + */ + private boolean containsAllVarRefs(Iterable varRefs) { + var referencesFederate = false; + var inFederate = true; + for (VarRef varRef : varRefs) { + if (varRef.getContainer() == this.instantiation) { + referencesFederate = true; + } else { + if (referencesFederate) { + errorReporter.reportError( + varRef, + "Mixed triggers and effects from" + " different federates. This is not permitted"); } + inFederate = false; + } } - - /** - * Return true if all members of 'varRefs' belong to this federate. - * - * As a convenience measure, if some members of 'varRefs' are from - * different federates, also report an error. - * - * @param varRefs A collection of VarRefs - */ - private boolean containsAllVarRefs(Iterable varRefs) { - var referencesFederate = false; - var inFederate = true; - for (VarRef varRef : varRefs) { - if (varRef.getContainer() == this.instantiation) { - referencesFederate = true; - } else { - if (referencesFederate) { - errorReporter.reportError(varRef, - "Mixed triggers and effects from" - + - " different federates. This is not permitted"); - } - inFederate = false; - } + return inFederate; + } + + /** + * Find output ports that are connected to a physical action trigger upstream in the same reactor. + * Return a list of such outputs paired with the minimum delay from the nearest physical action. + * + * @param instance The reactor instance containing the output ports + * @return A LinkedHashMap + */ + public LinkedHashMap findOutputsConnectedToPhysicalActions( + ReactorInstance instance) { + LinkedHashMap physicalActionToOutputMinDelay = new LinkedHashMap<>(); + // Find reactions that write to the output port of the reactor + for (PortInstance output : instance.outputs) { + for (ReactionInstance reaction : output.getDependsOnReactions()) { + TimeValue minDelay = findNearestPhysicalActionTrigger(reaction); + if (!Objects.equal(minDelay, TimeValue.MAX_VALUE)) { + physicalActionToOutputMinDelay.put((Output) output.getDefinition(), minDelay); } - return inFederate; + } } - - /** - * Find output ports that are connected to a physical action trigger upstream - * in the same reactor. Return a list of such outputs paired with the minimum delay - * from the nearest physical action. - * @param instance The reactor instance containing the output ports - * @return A LinkedHashMap - */ - public LinkedHashMap findOutputsConnectedToPhysicalActions(ReactorInstance instance) { - LinkedHashMap physicalActionToOutputMinDelay = new LinkedHashMap<>(); - // Find reactions that write to the output port of the reactor - for (PortInstance output : instance.outputs) { - for (ReactionInstance reaction : output.getDependsOnReactions()) { - TimeValue minDelay = findNearestPhysicalActionTrigger(reaction); - if (!Objects.equal(minDelay, TimeValue.MAX_VALUE)) { - physicalActionToOutputMinDelay.put((Output) output.getDefinition(), minDelay); - } + return physicalActionToOutputMinDelay; + } + + /** + * Return a list of federates that are upstream of this federate and have a zero-delay (direct) + * connection to this federate. + */ + public List getZeroDelayImmediateUpstreamFederates() { + return this.dependsOn.entrySet().stream() + .filter(e -> e.getValue().contains(null)) + .map(Map.Entry::getKey) + .toList(); + } + + @Override + public String toString() { + return "Federate " + + id + + ": " + + ((instantiation != null) ? instantiation.getName() : "no name"); + } + + ///////////////////////////////////////////// + //// Private Fields + + /** Cached result of analysis of which reactions to exclude from main. */ + private Set excludeReactions = null; + + /** An error reporter */ + private final ErrorReporter errorReporter; + + /** + * Find the nearest (shortest) path to a physical action trigger from this 'reaction' in terms of + * minimum delay. + * + * @param reaction The reaction to start with + * @return The minimum delay found to the nearest physical action and TimeValue.MAX_VALUE + * otherwise + */ + public TimeValue findNearestPhysicalActionTrigger(ReactionInstance reaction) { + TimeValue minDelay = TimeValue.MAX_VALUE; + for (TriggerInstance trigger : reaction.triggers) { + if (trigger.getDefinition() instanceof Action action) { + ActionInstance actionInstance = (ActionInstance) trigger; + if (action.getOrigin() == ActionOrigin.PHYSICAL) { + if (actionInstance.getMinDelay().isEarlierThan(minDelay)) { + minDelay = actionInstance.getMinDelay(); + } + } else if (action.getOrigin() == ActionOrigin.LOGICAL) { + // Logical action + // Follow it upstream inside the reactor + for (ReactionInstance uReaction : actionInstance.getDependsOnReactions()) { + // Avoid a loop + if (!Objects.equal(uReaction, reaction)) { + TimeValue uMinDelay = + actionInstance.getMinDelay().add(findNearestPhysicalActionTrigger(uReaction)); + if (uMinDelay.isEarlierThan(minDelay)) { + minDelay = uMinDelay; + } } + } } - return physicalActionToOutputMinDelay; - } - - /** - * Return a list of federates that are upstream of this federate and have a - * zero-delay (direct) connection to this federate. - */ - public List getZeroDelayImmediateUpstreamFederates() { - return this.dependsOn.entrySet() - .stream() - .filter(e -> e.getValue().contains(null)) - .map(Map.Entry::getKey).toList(); - } - @Override - public String toString() { - return "Federate " + id + ": " - + ((instantiation != null) ? instantiation.getName() : "no name"); - } - - ///////////////////////////////////////////// - //// Private Fields - - /** - * Cached result of analysis of which reactions to exclude from main. - */ - private Set excludeReactions = null; - - /** - * An error reporter - */ - private final ErrorReporter errorReporter; - - /** - * Find the nearest (shortest) path to a physical action trigger from this - * 'reaction' in terms of minimum delay. - * - * @param reaction The reaction to start with - * @return The minimum delay found to the nearest physical action and - * TimeValue.MAX_VALUE otherwise - */ - public TimeValue findNearestPhysicalActionTrigger(ReactionInstance reaction) { - TimeValue minDelay = TimeValue.MAX_VALUE; - for (TriggerInstance trigger : reaction.triggers) { - if (trigger.getDefinition() instanceof Action action) { - ActionInstance actionInstance = (ActionInstance) trigger; - if (action.getOrigin() == ActionOrigin.PHYSICAL) { - if (actionInstance.getMinDelay().isEarlierThan(minDelay)) { - minDelay = actionInstance.getMinDelay(); - } - } else if (action.getOrigin() == ActionOrigin.LOGICAL) { - // Logical action - // Follow it upstream inside the reactor - for (ReactionInstance uReaction: actionInstance.getDependsOnReactions()) { - // Avoid a loop - if (!Objects.equal(uReaction, reaction)) { - TimeValue uMinDelay = actionInstance.getMinDelay().add(findNearestPhysicalActionTrigger(uReaction)); - if (uMinDelay.isEarlierThan(minDelay)) { - minDelay = uMinDelay; - } - } - } - } - - } else if (trigger.getDefinition() instanceof Output) { - // Outputs of contained reactions - PortInstance outputInstance = (PortInstance) trigger; - for (ReactionInstance uReaction: outputInstance.getDependsOnReactions()) { - TimeValue uMinDelay = findNearestPhysicalActionTrigger(uReaction); - if (uMinDelay.isEarlierThan(minDelay)) { - minDelay = uMinDelay; - } - } - } + } else if (trigger.getDefinition() instanceof Output) { + // Outputs of contained reactions + PortInstance outputInstance = (PortInstance) trigger; + for (ReactionInstance uReaction : outputInstance.getDependsOnReactions()) { + TimeValue uMinDelay = findNearestPhysicalActionTrigger(uReaction); + if (uMinDelay.isEarlierThan(minDelay)) { + minDelay = uMinDelay; + } } - return minDelay; + } } + return minDelay; + } - // TODO: Put this function into a utils file instead - private List convertToEmptyListIfNull(List list) { - return list == null ? new ArrayList<>() : list; - } + // TODO: Put this function into a utils file instead + private List convertToEmptyListIfNull(List list) { + return list == null ? new ArrayList<>() : list; + } } diff --git a/org.lflang/src/org/lflang/federated/generator/LineAdjustingErrorReporter.java b/org.lflang/src/org/lflang/federated/generator/LineAdjustingErrorReporter.java index f483c228db..aa2f49b6da 100644 --- a/org.lflang/src/org/lflang/federated/generator/LineAdjustingErrorReporter.java +++ b/org.lflang/src/org/lflang/federated/generator/LineAdjustingErrorReporter.java @@ -2,10 +2,8 @@ import java.nio.file.Path; import java.util.Map; - import org.eclipse.emf.ecore.EObject; import org.eclipse.lsp4j.DiagnosticSeverity; - import org.lflang.ErrorReporter; import org.lflang.generator.CodeMap; import org.lflang.generator.Position; @@ -13,116 +11,102 @@ public class LineAdjustingErrorReporter implements ErrorReporter { - private final ErrorReporter parent; - private final Map codeMapMap; - - public LineAdjustingErrorReporter(ErrorReporter parent, Map codeMapMap) { - this.parent = parent; - this.codeMapMap = codeMapMap; - } - - @Override - public String reportError(String message) { - return parent.reportError(message); - } - - @Override - public String reportWarning(String message) { - return parent.reportWarning(message); - } - - @Override - public String reportInfo(String message) { - return parent.reportInfo(message); - } - - @Override - public String reportError(EObject object, String message) { - return parent.reportError(object, message); - } - - @Override - public String reportWarning(EObject object, String message) { - return parent.reportWarning(object, message); - } - - @Override - public String reportInfo(EObject object, String message) { - return parent.reportInfo(object, message); - } - - @Override - public String reportError(Path file, Integer line, String message) { - return report(file, line, message, DiagnosticSeverity.Error); - } - - @Override - public String reportWarning(Path file, Integer line, String message) { - return report(file, line, message, DiagnosticSeverity.Warning); - } - - @Override - public String reportInfo(Path file, Integer line, String message) { - return report(file, line, message, DiagnosticSeverity.Information); - } - - private String report(Path file, Integer line, String message, DiagnosticSeverity severity) { - if (line == null) return report(file, severity, message); - var position = Position.fromOneBased(line, Integer.MAX_VALUE); - return report( - file, - severity, - message, - Position.fromZeroBased(position.getZeroBasedLine(), 0), - position - ); - } - - @Override - public String report(Path file, DiagnosticSeverity severity, String message) { - return ErrorReporter.super.report(file, severity, message); - } - - @Override - public String report(Path file, DiagnosticSeverity severity, String message, int line) { - return ErrorReporter.super.report(file, severity, message, line); - } - - @Override - public String report( - Path file, - DiagnosticSeverity severity, - String message, - Position startPos, - Position endPos - ) { - String ret = null; - if (codeMapMap.containsKey(file)) { - var relevantMap = codeMapMap.get(file); - for (Path lfSource : relevantMap.lfSourcePaths()) { - var adjustedRange = relevantMap.adjusted( - lfSource, - new Range(startPos, endPos) - ); - ret = parent.report( - lfSource, - severity, - message, - adjustedRange.getStartInclusive().equals(Position.ORIGIN) ? - Position.fromZeroBased( - adjustedRange.getEndExclusive().getZeroBasedLine(), - 0 - ) : adjustedRange.getStartInclusive(), - adjustedRange.getEndExclusive() - ); - } - } - if (ret == null) return severity == DiagnosticSeverity.Error ? reportError(message) : reportWarning(message); - return ret; - } - - @Override - public boolean getErrorsOccurred() { - return parent.getErrorsOccurred(); + private final ErrorReporter parent; + private final Map codeMapMap; + + public LineAdjustingErrorReporter(ErrorReporter parent, Map codeMapMap) { + this.parent = parent; + this.codeMapMap = codeMapMap; + } + + @Override + public String reportError(String message) { + return parent.reportError(message); + } + + @Override + public String reportWarning(String message) { + return parent.reportWarning(message); + } + + @Override + public String reportInfo(String message) { + return parent.reportInfo(message); + } + + @Override + public String reportError(EObject object, String message) { + return parent.reportError(object, message); + } + + @Override + public String reportWarning(EObject object, String message) { + return parent.reportWarning(object, message); + } + + @Override + public String reportInfo(EObject object, String message) { + return parent.reportInfo(object, message); + } + + @Override + public String reportError(Path file, Integer line, String message) { + return report(file, line, message, DiagnosticSeverity.Error); + } + + @Override + public String reportWarning(Path file, Integer line, String message) { + return report(file, line, message, DiagnosticSeverity.Warning); + } + + @Override + public String reportInfo(Path file, Integer line, String message) { + return report(file, line, message, DiagnosticSeverity.Information); + } + + private String report(Path file, Integer line, String message, DiagnosticSeverity severity) { + if (line == null) return report(file, severity, message); + var position = Position.fromOneBased(line, Integer.MAX_VALUE); + return report( + file, severity, message, Position.fromZeroBased(position.getZeroBasedLine(), 0), position); + } + + @Override + public String report(Path file, DiagnosticSeverity severity, String message) { + return ErrorReporter.super.report(file, severity, message); + } + + @Override + public String report(Path file, DiagnosticSeverity severity, String message, int line) { + return ErrorReporter.super.report(file, severity, message, line); + } + + @Override + public String report( + Path file, DiagnosticSeverity severity, String message, Position startPos, Position endPos) { + String ret = null; + if (codeMapMap.containsKey(file)) { + var relevantMap = codeMapMap.get(file); + for (Path lfSource : relevantMap.lfSourcePaths()) { + var adjustedRange = relevantMap.adjusted(lfSource, new Range(startPos, endPos)); + ret = + parent.report( + lfSource, + severity, + message, + adjustedRange.getStartInclusive().equals(Position.ORIGIN) + ? Position.fromZeroBased(adjustedRange.getEndExclusive().getZeroBasedLine(), 0) + : adjustedRange.getStartInclusive(), + adjustedRange.getEndExclusive()); + } } + if (ret == null) + return severity == DiagnosticSeverity.Error ? reportError(message) : reportWarning(message); + return ret; + } + + @Override + public boolean getErrorsOccurred() { + return parent.getErrorsOccurred(); + } } diff --git a/org.lflang/src/org/lflang/federated/generator/SynchronizedErrorReporter.java b/org.lflang/src/org/lflang/federated/generator/SynchronizedErrorReporter.java index 571d2de5c7..08c47c4cd3 100644 --- a/org.lflang/src/org/lflang/federated/generator/SynchronizedErrorReporter.java +++ b/org.lflang/src/org/lflang/federated/generator/SynchronizedErrorReporter.java @@ -1,83 +1,83 @@ package org.lflang.federated.generator; import java.nio.file.Path; - import org.eclipse.emf.ecore.EObject; import org.eclipse.lsp4j.DiagnosticSeverity; - import org.lflang.ErrorReporter; import org.lflang.generator.Position; public class SynchronizedErrorReporter implements ErrorReporter { - private final ErrorReporter parent; - - public SynchronizedErrorReporter(ErrorReporter parent) { - this.parent = parent; - } - - @Override - public synchronized String reportError(String message) { - return parent.reportError(message); - } - - @Override - public synchronized String reportWarning(String message) { - return parent.reportWarning(message); - } - - @Override - public synchronized String reportInfo(String message) { - return parent.reportInfo(message); - } - - @Override - public synchronized String reportError(EObject object, String message) { - return parent.reportError(object, message); - } - - @Override - public synchronized String reportWarning(EObject object, String message) { - return parent.reportWarning(object, message); - } - - @Override - public synchronized String reportInfo(EObject object, String message) { - return parent.reportInfo(object, message); - } - - @Override - public synchronized String reportError(Path file, Integer line, String message) { - return parent.reportError(file, line, message); - } - - @Override - public synchronized String reportWarning(Path file, Integer line, String message) { - return parent.reportWarning(file, line, message); - } - - @Override - public synchronized String reportInfo(Path file, Integer line, String message) { - return parent.reportInfo(file, line, message); - } - - @Override - public synchronized String report(Path file, DiagnosticSeverity severity, String message) { - return parent.report(file, severity, message); - } - - @Override - public synchronized String report(Path file, DiagnosticSeverity severity, String message, int line) { - return parent.report(file, severity, message, line); - } - - @Override - public synchronized String report(Path file, DiagnosticSeverity severity, String message, Position startPos, Position endPos) { - return parent.report(file, severity, message, startPos, endPos); - } - - @Override - public synchronized boolean getErrorsOccurred() { - return parent.getErrorsOccurred(); - } + private final ErrorReporter parent; + + public SynchronizedErrorReporter(ErrorReporter parent) { + this.parent = parent; + } + + @Override + public synchronized String reportError(String message) { + return parent.reportError(message); + } + + @Override + public synchronized String reportWarning(String message) { + return parent.reportWarning(message); + } + + @Override + public synchronized String reportInfo(String message) { + return parent.reportInfo(message); + } + + @Override + public synchronized String reportError(EObject object, String message) { + return parent.reportError(object, message); + } + + @Override + public synchronized String reportWarning(EObject object, String message) { + return parent.reportWarning(object, message); + } + + @Override + public synchronized String reportInfo(EObject object, String message) { + return parent.reportInfo(object, message); + } + + @Override + public synchronized String reportError(Path file, Integer line, String message) { + return parent.reportError(file, line, message); + } + + @Override + public synchronized String reportWarning(Path file, Integer line, String message) { + return parent.reportWarning(file, line, message); + } + + @Override + public synchronized String reportInfo(Path file, Integer line, String message) { + return parent.reportInfo(file, line, message); + } + + @Override + public synchronized String report(Path file, DiagnosticSeverity severity, String message) { + return parent.report(file, severity, message); + } + + @Override + public synchronized String report( + Path file, DiagnosticSeverity severity, String message, int line) { + return parent.report(file, severity, message, line); + } + + @Override + public synchronized String report( + Path file, DiagnosticSeverity severity, String message, Position startPos, Position endPos) { + return parent.report(file, severity, message, startPos, endPos); + } + + @Override + public synchronized boolean getErrorsOccurred() { + return parent.getErrorsOccurred(); + } } diff --git a/org.lflang/src/org/lflang/federated/launcher/BuildConfig.java b/org.lflang/src/org/lflang/federated/launcher/BuildConfig.java index c1a01bfa47..47345af147 100644 --- a/org.lflang/src/org/lflang/federated/launcher/BuildConfig.java +++ b/org.lflang/src/org/lflang/federated/launcher/BuildConfig.java @@ -4,57 +4,48 @@ import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; -/** - * A collection of methods used for building target code for federates. - */ +/** A collection of methods used for building target code for federates. */ public abstract class BuildConfig { - /** - * The federate that this configuration applies to. - */ - protected final FederateInstance federate; - - /** - * An error reporter to report problems. - */ - protected final ErrorReporter errorReporter; - - /** - * The file configuration of the federation that the federate belongs to. - */ - protected final FedFileConfig fileConfig; - - /** - * Create a new build configuration. - * - * @param federate The federate that this configuration applies to. - * @param fileConfig The file configuration of the federation that the federate belongs to. - * @param errorReporter An error reporter to report problems. - */ - public BuildConfig(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { - this.errorReporter = errorReporter; - this.federate = federate; - this.fileConfig = fileConfig; - } - - /** - * Return the compile command for the federate that this build configuration belongs to. - */ - public String compileCommand() { - throw new UnsupportedOperationException(); - } - - /** - * Return the command that will execute the federate that this build configuration belongs to - * locally, assuming that the current directory is the top-level project folder. - */ - public abstract String localExecuteCommand(); - - /** - * Return the command that will execute the federate that this build configuration belongs to - * remotely, assuming that the current directory is the top-level project folder. - */ - public String remoteExecuteCommand() { - throw new UnsupportedOperationException(); - } + /** The federate that this configuration applies to. */ + protected final FederateInstance federate; + + /** An error reporter to report problems. */ + protected final ErrorReporter errorReporter; + + /** The file configuration of the federation that the federate belongs to. */ + protected final FedFileConfig fileConfig; + + /** + * Create a new build configuration. + * + * @param federate The federate that this configuration applies to. + * @param fileConfig The file configuration of the federation that the federate belongs to. + * @param errorReporter An error reporter to report problems. + */ + public BuildConfig( + FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + this.errorReporter = errorReporter; + this.federate = federate; + this.fileConfig = fileConfig; + } + + /** Return the compile command for the federate that this build configuration belongs to. */ + public String compileCommand() { + throw new UnsupportedOperationException(); + } + + /** + * Return the command that will execute the federate that this build configuration belongs to + * locally, assuming that the current directory is the top-level project folder. + */ + public abstract String localExecuteCommand(); + + /** + * Return the command that will execute the federate that this build configuration belongs to + * remotely, assuming that the current directory is the top-level project folder. + */ + public String remoteExecuteCommand() { + throw new UnsupportedOperationException(); + } } diff --git a/org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java b/org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java index bd88a719b4..d77ea3988c 100644 --- a/org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java +++ b/org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2019-2021, The University of California at Berkeley. - + * * 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. - + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -26,51 +26,51 @@ package org.lflang.federated.launcher; import java.io.File; - import org.lflang.ErrorReporter; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; import org.lflang.generator.c.CCompiler; /** - * Utility class that can be used to create a launcher for federated LF programs - * that are written in C. + * Utility class that can be used to create a launcher for federated LF programs that are written in + * C. * * @author Soroush Bateni * @author Marten Lohstroh */ public class CBuildConfig extends BuildConfig { - public CBuildConfig(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { - super(federate, fileConfig, errorReporter); - } + public CBuildConfig( + FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + super(federate, fileConfig, errorReporter); + } - @Override - public String compileCommand() { + @Override + public String compileCommand() { - String commandToReturn = ""; - // FIXME: Hack to add platform support only for linux systems. - // We need to fix the CMake build command for remote federates. - String linuxPlatformSupport = "core" + File.separator + "platform" + File.separator + "lf_linux_support.c"; - if (!federate.targetConfig.compileAdditionalSources.contains(linuxPlatformSupport)) { - federate.targetConfig.compileAdditionalSources.add(linuxPlatformSupport); - } - CCompiler cCompiler= new CCompiler(federate.targetConfig, fileConfig, errorReporter, false); - commandToReturn = String.join(" ", - cCompiler.compileCCommand( - fileConfig.name+"_"+federate.name, - false - ).toString()); - return commandToReturn; + String commandToReturn = ""; + // FIXME: Hack to add platform support only for linux systems. + // We need to fix the CMake build command for remote federates. + String linuxPlatformSupport = + "core" + File.separator + "platform" + File.separator + "lf_linux_support.c"; + if (!federate.targetConfig.compileAdditionalSources.contains(linuxPlatformSupport)) { + federate.targetConfig.compileAdditionalSources.add(linuxPlatformSupport); } + CCompiler cCompiler = new CCompiler(federate.targetConfig, fileConfig, errorReporter, false); + commandToReturn = + String.join( + " ", + cCompiler.compileCCommand(fileConfig.name + "_" + federate.name, false).toString()); + return commandToReturn; + } - @Override - public String remoteExecuteCommand() { - return "bin/"+fileConfig.name+"_"+federate.name+" -i '$FEDERATION_ID'"; - } + @Override + public String remoteExecuteCommand() { + return "bin/" + fileConfig.name + "_" + federate.name + " -i '$FEDERATION_ID'"; + } - @Override - public String localExecuteCommand() { - return fileConfig.getFedBinPath().resolve(federate.name)+" -i $FEDERATION_ID"; - } + @Override + public String localExecuteCommand() { + return fileConfig.getFedBinPath().resolve(federate.name) + " -i $FEDERATION_ID"; + } } diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java index 3ad08e2450..23547ca1d0 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java +++ b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java @@ -1,25 +1,25 @@ /************* * Copyright (c) 2019-2021, The University of California at Berkeley. - + * * 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. - - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 + * 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. ***************/ @@ -33,9 +33,7 @@ import java.nio.file.Path; import java.util.ArrayList; import java.util.List; - import org.lflang.ErrorReporter; -import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty.ClockSyncMode; import org.lflang.federated.generator.FedFileConfig; @@ -43,453 +41,477 @@ /** * Utility class that can be used to create a launcher for federated LF programs. - * + * * @author Edward A. Lee * @author Soroush Bateni */ public class FedLauncherGenerator { - protected TargetConfig targetConfig; - protected FedFileConfig fileConfig; - protected ErrorReporter errorReporter; - - /** - * @param targetConfig The current target configuration. - * @param fileConfig The current file configuration. - * @param errorReporter A error reporter for reporting any errors or warnings during the code generation - */ - public FedLauncherGenerator(TargetConfig targetConfig, FedFileConfig fileConfig, ErrorReporter errorReporter) { - this.targetConfig = targetConfig; - this.fileConfig = fileConfig; - this.errorReporter = errorReporter; + protected TargetConfig targetConfig; + protected FedFileConfig fileConfig; + protected ErrorReporter errorReporter; + + /** + * @param targetConfig The current target configuration. + * @param fileConfig The current file configuration. + * @param errorReporter A error reporter for reporting any errors or warnings during the code + * generation + */ + public FedLauncherGenerator( + TargetConfig targetConfig, FedFileConfig fileConfig, ErrorReporter errorReporter) { + this.targetConfig = targetConfig; + this.fileConfig = fileConfig; + this.errorReporter = errorReporter; + } + + /** + * Create the launcher shell scripts. This will create one or two files in the output path (bin + * directory). The first has name equal to the filename of the source file without the ".lf" + * extension. This will be a shell script that launches the RTI and the federates. If, in + * addition, either the RTI or any federate is mapped to a particular machine (anything other than + * the default "localhost" or "0.0.0.0"), then this will generate a shell script in the bin + * directory with name filename_distribute.sh that copies the relevant source files to the remote + * host and compiles them so that they are ready to execute using the launcher. + * + *

    A precondition for this to work is that the user invoking this code generator can log into + * the remote host without supplying a password. Specifically, you have to have installed your + * public key (typically found in ~/.ssh/id_rsa.pub) in ~/.ssh/authorized_keys on the remote host. + * In addition, the remote host must be running an ssh service. On an Arch Linux system using + * systemd, for example, this means running: + * + *

    sudo systemctl ssh.service + * + *

    Enable means to always start the service at startup, whereas start means to just start it + * this once. + * + *

    On macOS, open System Preferences from the Apple menu and click on the "Sharing" preference + * panel. Select the checkbox next to "Remote Login" to enable it. + * + *

    In addition, every host must have OpenSSL installed, with at least version 1.1.1a. You can + * check the version with + * + *

    openssl version + * + * @param federates A list of federate instances in the federation + * @param rtiConfig Can have values for 'host', 'dir', and 'user' + */ + public void doGenerate(List federates, RtiConfig rtiConfig) { + // NOTE: It might be good to use screen when invoking the RTI + // or federates remotely, so you can detach and the process keeps running. + // However, I was unable to get it working properly. + // What this means is that the shell that invokes the launcher + // needs to remain live for the duration of the federation. + // If that shell is killed, the federation will die. + // Hence, it is reasonable to launch the federation on a + // machine that participates in the federation, for example, + // on the machine that runs the RTI. The command I tried + // to get screen to work looks like this: + // ssh -t «target» cd «path»; screen -S «filename»_«federate.name» -L + // bin/«filename»_«federate.name» 2>&1 + // var outPath = binGenPath + StringBuilder shCode = new StringBuilder(); + StringBuilder distCode = new StringBuilder(); + shCode.append(getSetupCode() + "\n"); + String distHeader = getDistHeader(); + String host = rtiConfig.getHost(); + String target = host; + + String user = rtiConfig.getUser(); + if (user != null) { + target = user + "@" + host; } - /** - * Create the launcher shell scripts. This will create one or two files - * in the output path (bin directory). The first has name equal to - * the filename of the source file without the ".lf" extension. - * This will be a shell script that launches the - * RTI and the federates. If, in addition, either the RTI or any - * federate is mapped to a particular machine (anything other than - * the default "localhost" or "0.0.0.0"), then this will generate - * a shell script in the bin directory with name filename_distribute.sh - * that copies the relevant source files to the remote host and compiles - * them so that they are ready to execute using the launcher. - * - * A precondition for this to work is that the user invoking this - * code generator can log into the remote host without supplying - * a password. Specifically, you have to have installed your - * public key (typically found in ~/.ssh/id_rsa.pub) in - * ~/.ssh/authorized_keys on the remote host. In addition, the - * remote host must be running an ssh service. - * On an Arch Linux system using systemd, for example, this means - * running: - * - * sudo systemctl ssh.service - * - * Enable means to always start the service at startup, whereas - * start means to just start it this once. - * - * On macOS, open System Preferences from the Apple menu and - * click on the "Sharing" preference panel. Select the checkbox - * next to "Remote Login" to enable it. - * - * In addition, every host must have OpenSSL installed, with at least - * version 1.1.1a. You can check the version with - * - * openssl version - * - * @param federates A list of federate instances in the federation - * @param rtiConfig - * Can have values for 'host', 'dir', and 'user' - */ - public void doGenerate( - List federates, - RtiConfig rtiConfig - ) { - // NOTE: It might be good to use screen when invoking the RTI - // or federates remotely, so you can detach and the process keeps running. - // However, I was unable to get it working properly. - // What this means is that the shell that invokes the launcher - // needs to remain live for the duration of the federation. - // If that shell is killed, the federation will die. - // Hence, it is reasonable to launch the federation on a - // machine that participates in the federation, for example, - // on the machine that runs the RTI. The command I tried - // to get screen to work looks like this: - // ssh -t «target» cd «path»; screen -S «filename»_«federate.name» -L bin/«filename»_«federate.name» 2>&1 - // var outPath = binGenPath - StringBuilder shCode = new StringBuilder(); - StringBuilder distCode = new StringBuilder(); - shCode.append(getSetupCode() + "\n"); - String distHeader = getDistHeader(); - String host = rtiConfig.getHost(); - String target = host; - - String user = rtiConfig.getUser(); - if (user != null) { - target = user + "@" + host; - } - - shCode.append("#### Host is " + host); - - // Launch the RTI in the foreground. - if (host.equals("localhost") || host.equals("0.0.0.0")) { - // FIXME: the paths below will not work on Windows - shCode.append(getLaunchCode(getRtiCommand(federates, false)) + "\n"); - } else { - // Start the RTI on the remote machine. - // FIXME: Should $FEDERATION_ID be used to ensure unique directories, executables, on the remote host? - // Copy the source code onto the remote machine and compile it there. - if(distCode.length() == 0) distCode.append(distHeader + "\n"); - - String logFileName = String.format("log/%s_RTI.log", fileConfig.name); - - // Launch the RTI on the remote machine using ssh and screen. - // The -t argument to ssh creates a virtual terminal, which is needed by screen. - // The -S gives the session a name. - // The -L option turns on logging. Unfortunately, the -Logfile giving the log file name - // is not standardized in screen. Logs go to screenlog.0 (or screenlog.n). - // FIXME: Remote errors are not reported back via ssh from screen. - // How to get them back to the local machine? - // Perhaps use -c and generate a screen command file to control the logfile name, - // but screen apparently doesn't write anything to the log file! - // - // The cryptic 2>&1 reroutes stderr to stdout so that both are returned. - // The sleep at the end prevents screen from exiting before outgoing messages from - // the federate have had time to go out to the RTI through the socket. - - shCode.append(getRemoteLaunchCode(host, target, logFileName, - getRtiCommand(federates, true)) + "\n"); - } - - // Index used for storing pids of federates - int federateIndex = 0; - for (FederateInstance federate : federates) { - var buildConfig = getBuildConfig(federate, fileConfig, errorReporter); - if (federate.isRemote) { - Path fedRelSrcGenPath = fileConfig.getOutPath().relativize(fileConfig.getSrcGenPath()).resolve(federate.name); - if(distCode.length() == 0) distCode.append(distHeader + "\n"); - String logFileName = String.format("log/%s_%s.log", fileConfig.name, federate.name); - String compileCommand = buildConfig.compileCommand(); - // FIXME: Should $FEDERATION_ID be used to ensure unique directories, executables, on the remote host? - distCode.append(getDistCode(rtiConfig.getDirectory(), federate, fedRelSrcGenPath, logFileName, fileConfig.getSrcGenPath(), compileCommand) + "\n"); - String executeCommand = buildConfig.remoteExecuteCommand(); - shCode.append(getFedRemoteLaunchCode(federate, rtiConfig.getDirectory(), logFileName, executeCommand, federateIndex++) + "\n"); - } else { - String executeCommand = buildConfig.localExecuteCommand(); - shCode.append(getFedLocalLaunchCode(federate, executeCommand, federateIndex++) + "\n"); - } - } - if (host.equals("localhost") || host.equals("0.0.0.0")) { - // Local PID managements - shCode.append("echo \"#### Bringing the RTI back to foreground so it can receive Control-C.\"" + "\n"); - shCode.append("fg %1" + "\n"); - } - // Wait for launched processes to finish - shCode.append(String.join("\n", - "echo \"RTI has exited. Wait for federates to exit.\"", - "# Wait for launched processes to finish.", - "# The errors are handled separately via trap.", - "for pid in \"${pids[@]}\"", - "do", - " wait $pid", - "done", - "echo \"All done.\"" - ) + "\n"); - - // Create bin directory for the script. - if (!Files.exists(fileConfig.binPath)) { - try { - Files.createDirectories(fileConfig.binPath); - } catch (IOException e) { - errorReporter.reportError("Unable to create directory: " + fileConfig.binPath); - } - } - - System.out.println("##### Generating launcher for federation " - + " in directory " - + fileConfig.binPath); - - // Write the launcher file. - // Delete file previously produced, if any. - File file = fileConfig.binPath.resolve(fileConfig.name).toFile(); - if (file.exists()) { - file.delete(); - } + shCode.append("#### Host is " + host); + + // Launch the RTI in the foreground. + if (host.equals("localhost") || host.equals("0.0.0.0")) { + // FIXME: the paths below will not work on Windows + shCode.append(getLaunchCode(getRtiCommand(federates, false)) + "\n"); + } else { + // Start the RTI on the remote machine. + // FIXME: Should $FEDERATION_ID be used to ensure unique directories, executables, on the + // remote host? + // Copy the source code onto the remote machine and compile it there. + if (distCode.length() == 0) distCode.append(distHeader + "\n"); + + String logFileName = String.format("log/%s_RTI.log", fileConfig.name); + + // Launch the RTI on the remote machine using ssh and screen. + // The -t argument to ssh creates a virtual terminal, which is needed by screen. + // The -S gives the session a name. + // The -L option turns on logging. Unfortunately, the -Logfile giving the log file name + // is not standardized in screen. Logs go to screenlog.0 (or screenlog.n). + // FIXME: Remote errors are not reported back via ssh from screen. + // How to get them back to the local machine? + // Perhaps use -c and generate a screen command file to control the logfile name, + // but screen apparently doesn't write anything to the log file! + // + // The cryptic 2>&1 reroutes stderr to stdout so that both are returned. + // The sleep at the end prevents screen from exiting before outgoing messages from + // the federate have had time to go out to the RTI through the socket. + + shCode.append( + getRemoteLaunchCode(host, target, logFileName, getRtiCommand(federates, true)) + "\n"); + } - FileOutputStream fOut = null; - try { - fOut = new FileOutputStream(file); - } catch (FileNotFoundException e) { - errorReporter.reportError("Unable to find file: " + file); - } - try { - fOut.write(shCode.toString().getBytes()); - fOut.close(); - } catch (IOException e) { - errorReporter.reportError("Unable to write to file: " + file); - } + // Index used for storing pids of federates + int federateIndex = 0; + for (FederateInstance federate : federates) { + var buildConfig = getBuildConfig(federate, fileConfig, errorReporter); + if (federate.isRemote) { + Path fedRelSrcGenPath = + fileConfig.getOutPath().relativize(fileConfig.getSrcGenPath()).resolve(federate.name); + if (distCode.length() == 0) distCode.append(distHeader + "\n"); + String logFileName = String.format("log/%s_%s.log", fileConfig.name, federate.name); + String compileCommand = buildConfig.compileCommand(); + // FIXME: Should $FEDERATION_ID be used to ensure unique directories, executables, on the + // remote host? + distCode.append( + getDistCode( + rtiConfig.getDirectory(), + federate, + fedRelSrcGenPath, + logFileName, + fileConfig.getSrcGenPath(), + compileCommand) + + "\n"); + String executeCommand = buildConfig.remoteExecuteCommand(); + shCode.append( + getFedRemoteLaunchCode( + federate, + rtiConfig.getDirectory(), + logFileName, + executeCommand, + federateIndex++) + + "\n"); + } else { + String executeCommand = buildConfig.localExecuteCommand(); + shCode.append(getFedLocalLaunchCode(federate, executeCommand, federateIndex++) + "\n"); + } + } + if (host.equals("localhost") || host.equals("0.0.0.0")) { + // Local PID managements + shCode.append( + "echo \"#### Bringing the RTI back to foreground so it can receive Control-C.\"" + "\n"); + shCode.append("fg %1" + "\n"); + } + // Wait for launched processes to finish + shCode.append( + String.join( + "\n", + "echo \"RTI has exited. Wait for federates to exit.\"", + "# Wait for launched processes to finish.", + "# The errors are handled separately via trap.", + "for pid in \"${pids[@]}\"", + "do", + " wait $pid", + "done", + "echo \"All done.\"") + + "\n"); + + // Create bin directory for the script. + if (!Files.exists(fileConfig.binPath)) { + try { + Files.createDirectories(fileConfig.binPath); + } catch (IOException e) { + errorReporter.reportError("Unable to create directory: " + fileConfig.binPath); + } + } - if (!file.setExecutable(true, false)) { - errorReporter.reportWarning("Unable to make launcher script executable."); - } + System.out.println( + "##### Generating launcher for federation " + " in directory " + fileConfig.binPath); - // Write the distributor file. - // Delete the file even if it does not get generated. - file = fileConfig.binPath.resolve(fileConfig.name + "_distribute.sh").toFile(); - if (file.exists()) { - file.delete(); - } - if (distCode.length() > 0) { - try { - fOut = new FileOutputStream(file); - fOut.write(distCode.toString().getBytes()); - fOut.close(); - if (!file.setExecutable(true, false)) { - errorReporter.reportWarning("Unable to make file executable: " + file); - } - } catch (FileNotFoundException e) { - errorReporter.reportError("Unable to find file: " + file); - } catch (IOException e) { - errorReporter.reportError("Unable to write to file " + file); - } - } + // Write the launcher file. + // Delete file previously produced, if any. + File file = fileConfig.binPath.resolve(fileConfig.name).toFile(); + if (file.exists()) { + file.delete(); } - private String getSetupCode() { - return String.join("\n", - "#!/bin/bash", - "# Launcher for federated " + fileConfig.name + ".lf Lingua Franca program.", - "# Uncomment to specify to behave as close as possible to the POSIX standard.", - "# set -o posix", - "", - "# Enable job control", - "set -m", - "shopt -s huponexit", - "", - "# Set a trap to kill all background jobs on error or control-C", - "# Use two distinct traps so we can see which signal causes this.", - "cleanup() {", - " printf \"Killing federate %s.\\n\" ${pids[*]}", - " # The || true clause means this is not an error if kill fails.", - " kill ${pids[@]} || true", - " printf \"#### Killing RTI %s.\\n\" ${RTI}", - " kill ${RTI} || true", - " exit 1", - "}", - "cleanup_err() {", - " echo \"#### Received ERR signal on line $1. Invoking cleanup().\"", - " cleanup", - "}", - "cleanup_sigint() {", - " echo \"#### Received SIGINT signal on line $1. Invoking cleanup().\"", - " cleanup", - "}", - "", - "trap 'cleanup_err $LINENO' ERR", - "trap 'cleanup_sigint $LINENO' SIGINT", - "", - "# Create a random 48-byte text ID for this federation.", - "# The likelihood of two federations having the same ID is 1/16,777,216 (1/2^24).", - "FEDERATION_ID=`openssl rand -hex 24`", - "echo \"Federate " + fileConfig.name + " in Federation ID '$FEDERATION_ID'\"", - "# Launch the federates:" - ); + FileOutputStream fOut = null; + try { + fOut = new FileOutputStream(file); + } catch (FileNotFoundException e) { + errorReporter.reportError("Unable to find file: " + file); + } + try { + fOut.write(shCode.toString().getBytes()); + fOut.close(); + } catch (IOException e) { + errorReporter.reportError("Unable to write to file: " + file); } - private String getDistHeader() { - return String.join("\n", - "#!/bin/bash", - "# Distributor for federated "+ fileConfig.name + ".lf Lingua Franca program.", - "# Uncomment to specify to behave as close as possible to the POSIX standard.", - "# set -o posix" - ); + if (!file.setExecutable(true, false)) { + errorReporter.reportWarning("Unable to make launcher script executable."); } - private String getRtiCommand(List federates, boolean isRemote) { - List commands = new ArrayList<>(); - if (isRemote) { - commands.add("RTI -i '${FEDERATION_ID}' \\"); - } else { - commands.add("RTI -i ${FEDERATION_ID} \\"); - } - if (targetConfig.auth) { - commands.add(" -a \\"); - } - if (targetConfig.tracing != null) { - commands.add(" -t \\"); - } - commands.addAll(List.of( - " -n "+federates.size()+" \\", - " -c "+targetConfig.clockSync.toString()+" \\" - )); - if (targetConfig.clockSync.equals(ClockSyncMode.ON)) { - commands.add("period " + targetConfig.clockSyncOptions.period.toNanoSeconds()+" \\"); - } - if (targetConfig.clockSync.equals(ClockSyncMode.ON) || - targetConfig.clockSync.equals(ClockSyncMode.INIT)) { - commands.add("exchanges-per-interval "+targetConfig.clockSyncOptions.trials+" \\"); + // Write the distributor file. + // Delete the file even if it does not get generated. + file = fileConfig.binPath.resolve(fileConfig.name + "_distribute.sh").toFile(); + if (file.exists()) { + file.delete(); + } + if (distCode.length() > 0) { + try { + fOut = new FileOutputStream(file); + fOut.write(distCode.toString().getBytes()); + fOut.close(); + if (!file.setExecutable(true, false)) { + errorReporter.reportWarning("Unable to make file executable: " + file); } - commands.add("&"); - return String.join("\n", commands); + } catch (FileNotFoundException e) { + errorReporter.reportError("Unable to find file: " + file); + } catch (IOException e) { + errorReporter.reportError("Unable to write to file " + file); + } } - - private String getLaunchCode(String rtiLaunchCode) { - return String.join("\n", - "echo \"#### Launching the runtime infrastructure (RTI).\"", - "# First, check if the RTI is on the PATH", - "if ! command -v RTI &> /dev/null", - "then", - " echo \"RTI could not be found.\"", - " echo \"The source code can be obtained from https://github.com/lf-lang/reactor-c/tree/main/core/federated/RTI\"", - " exit", - "fi ", - "# The RTI is started first to allow proper boot-up", - "# before federates will try to connect.", - "# The RTI will be brought back to foreground", - "# to be responsive to user inputs after all federates", - "# are launched.", - rtiLaunchCode, - "# Store the PID of the RTI", - "RTI=$!", - "# Wait for the RTI to boot up before", - "# starting federates (this could be done by waiting for a specific output", - "# from the RTI, but here we use sleep)", - "sleep 1" - ); + } + + private String getSetupCode() { + return String.join( + "\n", + "#!/bin/bash", + "# Launcher for federated " + fileConfig.name + ".lf Lingua Franca program.", + "# Uncomment to specify to behave as close as possible to the POSIX standard.", + "# set -o posix", + "", + "# Enable job control", + "set -m", + "shopt -s huponexit", + "", + "# Set a trap to kill all background jobs on error or control-C", + "# Use two distinct traps so we can see which signal causes this.", + "cleanup() {", + " printf \"Killing federate %s.\\n\" ${pids[*]}", + " # The || true clause means this is not an error if kill fails.", + " kill ${pids[@]} || true", + " printf \"#### Killing RTI %s.\\n\" ${RTI}", + " kill ${RTI} || true", + " exit 1", + "}", + "cleanup_err() {", + " echo \"#### Received ERR signal on line $1. Invoking cleanup().\"", + " cleanup", + "}", + "cleanup_sigint() {", + " echo \"#### Received SIGINT signal on line $1. Invoking cleanup().\"", + " cleanup", + "}", + "", + "trap 'cleanup_err $LINENO' ERR", + "trap 'cleanup_sigint $LINENO' SIGINT", + "", + "# Create a random 48-byte text ID for this federation.", + "# The likelihood of two federations having the same ID is 1/16,777,216 (1/2^24).", + "FEDERATION_ID=`openssl rand -hex 24`", + "echo \"Federate " + fileConfig.name + " in Federation ID '$FEDERATION_ID'\"", + "# Launch the federates:"); + } + + private String getDistHeader() { + return String.join( + "\n", + "#!/bin/bash", + "# Distributor for federated " + fileConfig.name + ".lf Lingua Franca program.", + "# Uncomment to specify to behave as close as possible to the POSIX standard.", + "# set -o posix"); + } + + private String getRtiCommand(List federates, boolean isRemote) { + List commands = new ArrayList<>(); + if (isRemote) { + commands.add("RTI -i '${FEDERATION_ID}' \\"); + } else { + commands.add("RTI -i ${FEDERATION_ID} \\"); } - - private String getRemoteLaunchCode(Object host, Object target, String logFileName, String rtiLaunchString) { - return String.join("\n", - "echo \"#### Launching the runtime infrastructure (RTI) on remote host " + host + ".\"", - "# FIXME: Killing this ssh does not kill the remote process.", - "# A double -t -t option to ssh forces creation of a virtual terminal, which", - "# fixes the problem, but then the ssh command does not execute. The remote", - "# federate does not start!", - "ssh " + target + " 'mkdir -p log; \\", - " echo \"-------------- Federation ID: \"'$FEDERATION_ID' >> " + logFileName + "; \\", - " date >> " + logFileName + "; \\", - " echo \"Executing RTI: " + rtiLaunchString + "\" 2>&1 | tee -a " + logFileName + "; \\", - " # First, check if the RTI is on the PATH", - " if ! command -v RTI &> /dev/null", - " then", - " echo \"RTI could not be found.\"", - " echo \"The source code can be found in org.lflang/src/lib/core/federated/RTI\"", - " exit", - " fi", - " " + rtiLaunchString + " 2>&1 | tee -a " + logFileName + "' &", - "# Store the PID of the channel to RTI", - "RTI=$!", - "# Wait for the RTI to boot up before", - "# starting federates (this could be done by waiting for a specific output", - "# from the RTI, but here we use sleep)", - "sleep 5" - ); + if (targetConfig.auth) { + commands.add(" -a \\"); } - - private String getDistCode( - Path remoteBase, - FederateInstance federate, - Path remoteRelSrcGenPath, - String logFileName, - Path localAbsSrcGenPath, - String compileCommand) { - return String.join("\n", - "echo \"Making directory " + remoteBase - + " and subdirectories src-gen, bin, and log on host " - + getUserHost(federate.user, federate.host) - + "\"", - "# The >> syntax appends stdout to a file. The 2>&1 appends stderr to the same file.", - "ssh " + getUserHost(federate.user, federate.host) - + " '\\", - " mkdir -p " + remoteBase.resolve(remoteRelSrcGenPath).resolve("core") - + " " + remoteBase.resolve("bin") + " " - + remoteBase + "/log; \\", - " echo \"--------------\" >> " + remoteBase + "/" - + logFileName + "; \\", - " date >> " + remoteBase + "/" + logFileName + ";", - "'", - "pushd " + localAbsSrcGenPath - + " > /dev/null", - "echo \"Copying source files to host " - + getUserHost(federate.user, federate.host) - + "\"", - "scp -r * " - + getUserHost(federate.user, federate.host) + ":" - + remoteBase.resolve(remoteRelSrcGenPath), - "popd > /dev/null", - "echo \"Compiling on host " - + getUserHost(federate.user, federate.host) - + " using: " + compileCommand + "\"", - "ssh " + getUserHost(federate.user, federate.host) - + " 'cd " + remoteBase + "; \\", - " echo \"In " + remoteBase + " compiling with: " - + compileCommand + "\" >> " + logFileName - + " 2>&1; \\", - " # Capture the output in the log file and stdout. \\", - " " + compileCommand + " 2>&1 | tee -a " - + logFileName + ";' " - ); + if (targetConfig.tracing != null) { + commands.add(" -t \\"); } - - private String getUserHost(Object user, Object host) { - if (user == null) { - return host.toString(); - } - return user + "@" + host; + commands.addAll( + List.of( + " -n " + federates.size() + " \\", + " -c " + targetConfig.clockSync.toString() + " \\")); + if (targetConfig.clockSync.equals(ClockSyncMode.ON)) { + commands.add("period " + targetConfig.clockSyncOptions.period.toNanoSeconds() + " \\"); } - - private String getFedRemoteLaunchCode( - FederateInstance federate, - Path path, - String logFileName, - String executeCommand, - int federateIndex - ) { - return String.join("\n", - "echo \"#### Launching the federate "+federate.name+" on host "+getUserHost(federate.user, federate.host)+"\"", - "# FIXME: Killing this ssh does not kill the remote process.", - "# A double -t -t option to ssh forces creation of a virtual terminal, which", - "# fixes the problem, but then the ssh command does not execute. The remote", - "# federate does not start!", - "ssh "+getUserHost(federate.user, federate.host)+" '\\", - " cd "+path+"; \\", - " echo \"-------------- Federation ID: \"'$FEDERATION_ID' >> "+logFileName+"; \\", - " date >> "+logFileName+"; \\", - " echo \"In "+path+", executing: "+executeCommand+"\" 2>&1 | tee -a "+logFileName+"; \\", - " "+executeCommand+" 2>&1 | tee -a "+logFileName+"' &", - "pids["+federateIndex+"]=$!" - ); + if (targetConfig.clockSync.equals(ClockSyncMode.ON) + || targetConfig.clockSync.equals(ClockSyncMode.INIT)) { + commands.add("exchanges-per-interval " + targetConfig.clockSyncOptions.trials + " \\"); } - - private String getFedLocalLaunchCode(FederateInstance federate, String executeCommand, int federateIndex) { - return String.format(String.join("\n", - "echo \"#### Launching the federate %s.\"", - "%s &", - "pids[%s]=$!" - ), + commands.add("&"); + return String.join("\n", commands); + } + + private String getLaunchCode(String rtiLaunchCode) { + return String.join( + "\n", + "echo \"#### Launching the runtime infrastructure (RTI).\"", + "# First, check if the RTI is on the PATH", + "if ! command -v RTI &> /dev/null", + "then", + " echo \"RTI could not be found.\"", + " echo \"The source code can be obtained from" + + " https://github.com/lf-lang/reactor-c/tree/main/core/federated/RTI\"", + " exit", + "fi ", + "# The RTI is started first to allow proper boot-up", + "# before federates will try to connect.", + "# The RTI will be brought back to foreground", + "# to be responsive to user inputs after all federates", + "# are launched.", + rtiLaunchCode, + "# Store the PID of the RTI", + "RTI=$!", + "# Wait for the RTI to boot up before", + "# starting federates (this could be done by waiting for a specific output", + "# from the RTI, but here we use sleep)", + "sleep 1"); + } + + private String getRemoteLaunchCode( + Object host, Object target, String logFileName, String rtiLaunchString) { + return String.join( + "\n", + "echo \"#### Launching the runtime infrastructure (RTI) on remote host " + host + ".\"", + "# FIXME: Killing this ssh does not kill the remote process.", + "# A double -t -t option to ssh forces creation of a virtual terminal, which", + "# fixes the problem, but then the ssh command does not execute. The remote", + "# federate does not start!", + "ssh " + target + " 'mkdir -p log; \\", + " echo \"-------------- Federation ID: \"'$FEDERATION_ID' >> " + logFileName + "; \\", + " date >> " + logFileName + "; \\", + " echo \"Executing RTI: " + rtiLaunchString + "\" 2>&1 | tee -a " + logFileName + "; \\", + " # First, check if the RTI is on the PATH", + " if ! command -v RTI &> /dev/null", + " then", + " echo \"RTI could not be found.\"", + " echo \"The source code can be found in org.lflang/src/lib/core/federated/RTI\"", + " exit", + " fi", + " " + rtiLaunchString + " 2>&1 | tee -a " + logFileName + "' &", + "# Store the PID of the channel to RTI", + "RTI=$!", + "# Wait for the RTI to boot up before", + "# starting federates (this could be done by waiting for a specific output", + "# from the RTI, but here we use sleep)", + "sleep 5"); + } + + private String getDistCode( + Path remoteBase, + FederateInstance federate, + Path remoteRelSrcGenPath, + String logFileName, + Path localAbsSrcGenPath, + String compileCommand) { + return String.join( + "\n", + "echo \"Making directory " + + remoteBase + + " and subdirectories src-gen, bin, and log on host " + + getUserHost(federate.user, federate.host) + + "\"", + "# The >> syntax appends stdout to a file. The 2>&1 appends stderr to the same file.", + "ssh " + getUserHost(federate.user, federate.host) + " '\\", + " mkdir -p " + + remoteBase.resolve(remoteRelSrcGenPath).resolve("core") + + " " + + remoteBase.resolve("bin") + + " " + + remoteBase + + "/log; \\", + " echo \"--------------\" >> " + remoteBase + "/" + logFileName + "; \\", + " date >> " + remoteBase + "/" + logFileName + ";", + "'", + "pushd " + localAbsSrcGenPath + " > /dev/null", + "echo \"Copying source files to host " + getUserHost(federate.user, federate.host) + "\"", + "scp -r * " + + getUserHost(federate.user, federate.host) + + ":" + + remoteBase.resolve(remoteRelSrcGenPath), + "popd > /dev/null", + "echo \"Compiling on host " + + getUserHost(federate.user, federate.host) + + " using: " + + compileCommand + + "\"", + "ssh " + getUserHost(federate.user, federate.host) + " 'cd " + remoteBase + "; \\", + " echo \"In " + + remoteBase + + " compiling with: " + + compileCommand + + "\" >> " + + logFileName + + " 2>&1; \\", + " # Capture the output in the log file and stdout. \\", + " " + compileCommand + " 2>&1 | tee -a " + logFileName + ";' "); + } + + private String getUserHost(Object user, Object host) { + if (user == null) { + return host.toString(); + } + return user + "@" + host; + } + + private String getFedRemoteLaunchCode( + FederateInstance federate, + Path path, + String logFileName, + String executeCommand, + int federateIndex) { + return String.join( + "\n", + "echo \"#### Launching the federate " + + federate.name + + " on host " + + getUserHost(federate.user, federate.host) + + "\"", + "# FIXME: Killing this ssh does not kill the remote process.", + "# A double -t -t option to ssh forces creation of a virtual terminal, which", + "# fixes the problem, but then the ssh command does not execute. The remote", + "# federate does not start!", + "ssh " + getUserHost(federate.user, federate.host) + " '\\", + " cd " + path + "; \\", + " echo \"-------------- Federation ID: \"'$FEDERATION_ID' >> " + logFileName + "; \\", + " date >> " + logFileName + "; \\", + " echo \"In " + + path + + ", executing: " + + executeCommand + + "\" 2>&1 | tee -a " + + logFileName + + "; \\", + " " + executeCommand + " 2>&1 | tee -a " + logFileName + "' &", + "pids[" + federateIndex + "]=$!"); + } + + private String getFedLocalLaunchCode( + FederateInstance federate, String executeCommand, int federateIndex) { + return String.format( + String.join("\n", "echo \"#### Launching the federate %s.\"", "%s &", "pids[%s]=$!"), federate.name, executeCommand, federateIndex); - } - - /** - * Create a build configuration of the appropriate target. - * - * @param federate The federate to which the build configuration applies. - * @param fileConfig The file configuration of the federation to which the federate belongs. - * @param errorReporter An error reporter to report problems. - * @return - */ - private BuildConfig getBuildConfig( - FederateInstance federate, - FedFileConfig fileConfig, - ErrorReporter errorReporter) { - return switch(federate.targetConfig.target) { - case C, CCPP -> new CBuildConfig(federate, fileConfig, errorReporter); - case Python -> new PyBuildConfig(federate, fileConfig, errorReporter); - case TS -> new TsBuildConfig(federate, fileConfig, errorReporter); - case CPP, Rust -> throw new UnsupportedOperationException(); - }; - } + } + + /** + * Create a build configuration of the appropriate target. + * + * @param federate The federate to which the build configuration applies. + * @param fileConfig The file configuration of the federation to which the federate belongs. + * @param errorReporter An error reporter to report problems. + * @return + */ + private BuildConfig getBuildConfig( + FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + return switch (federate.targetConfig.target) { + case C, CCPP -> new CBuildConfig(federate, fileConfig, errorReporter); + case Python -> new PyBuildConfig(federate, fileConfig, errorReporter); + case TS -> new TsBuildConfig(federate, fileConfig, errorReporter); + case CPP, Rust -> throw new UnsupportedOperationException(); + }; + } } diff --git a/org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java b/org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java index 85d6dc4a0f..1a8a996349 100644 --- a/org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java +++ b/org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java @@ -6,17 +6,32 @@ public class PyBuildConfig extends BuildConfig { - public PyBuildConfig(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { - super(federate, fileConfig, errorReporter); - } + public PyBuildConfig( + FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + super(federate, fileConfig, errorReporter); + } - @Override - public String localExecuteCommand() { - return "python3 " + fileConfig.getSrcGenPath() + "/" + federate.name + "/" + federate.name+".py -i $FEDERATION_ID"; - } + @Override + public String localExecuteCommand() { + return "python3 " + + fileConfig.getSrcGenPath() + + "/" + + federate.name + + "/" + + federate.name + + ".py -i $FEDERATION_ID"; + } - @Override - public String remoteExecuteCommand() { - return "python3 src-gen/"+fileConfig.name+"/"+federate.name+"/"+fileConfig.name+"_"+federate.name+" -i '$FEDERATION_ID'"; - } + @Override + public String remoteExecuteCommand() { + return "python3 src-gen/" + + fileConfig.name + + "/" + + federate.name + + "/" + + fileConfig.name + + "_" + + federate.name + + " -i '$FEDERATION_ID'"; + } } diff --git a/org.lflang/src/org/lflang/federated/launcher/RtiConfig.java b/org.lflang/src/org/lflang/federated/launcher/RtiConfig.java index 81c608d5b3..60e07c9f53 100644 --- a/org.lflang/src/org/lflang/federated/launcher/RtiConfig.java +++ b/org.lflang/src/org/lflang/federated/launcher/RtiConfig.java @@ -4,89 +4,66 @@ /** * Class for storing configuration settings pertaining to the RTI. + * * @author Marten Lohstroh */ public class RtiConfig { - private Path directory; + private Path directory; - /** - * The host on which the RTI process is to be spawned. - */ - private String host; + /** The host on which the RTI process is to be spawned. */ + private String host; - /** - * The port on which to connect to the RTI process. - */ - private int port; + /** The port on which to connect to the RTI process. */ + private int port; - /** - * The username used to gain access to the host where the RTI is to be spawned. - */ - private String user; + /** The username used to gain access to the host where the RTI is to be spawned. */ + private String user; - /** - * Construct a new RTI configuration with all options set to their defaults. - */ - public RtiConfig() { - this.directory = Path.of("LinguaFrancaRemote"); - this.host = "localhost"; - this.port = 0; - } + /** Construct a new RTI configuration with all options set to their defaults. */ + public RtiConfig() { + this.directory = Path.of("LinguaFrancaRemote"); + this.host = "localhost"; + this.port = 0; + } - /** - * Return the directory to create on the remote host. - */ - public Path getDirectory() { - return directory; - } + /** Return the directory to create on the remote host. */ + public Path getDirectory() { + return directory; + } - /** - * Return the host on which the RTI process is to be spawned. - */ - public String getHost() { - return host; - } + /** Return the host on which the RTI process is to be spawned. */ + public String getHost() { + return host; + } - /** - * Return the port on which to connect to the RTI process. - */ - public int getPort() { - return port; - } + /** Return the port on which to connect to the RTI process. */ + public int getPort() { + return port; + } - /** - * Return the username used to gain access to the host where the RTI is to be spawned. - */ - public String getUser() { - return user; - } + /** Return the username used to gain access to the host where the RTI is to be spawned. */ + public String getUser() { + return user; + } - /** - * Set the directory to create on the remote host. - */ - public void setDirectory(Path directory) { - this.directory = directory; - } + /** Set the directory to create on the remote host. */ + public void setDirectory(Path directory) { + this.directory = directory; + } - /** - * Set the host on which the RTI process is to be spawned. - */ - public void setHost(String host) { - this.host = host; - } + /** Set the host on which the RTI process is to be spawned. */ + public void setHost(String host) { + this.host = host; + } - /** - * Set the port on which to connect to the RTI process. - */ - public void setPort(int port) { - this.port = port; - } + /** Set the port on which to connect to the RTI process. */ + public void setPort(int port) { + this.port = port; + } - /** - * Set the username used to gain access to the host where the RTI is to be spawned. - */ - public void setUser(String user) { - this.user = user; - } + /** Set the username used to gain access to the host where the RTI is to be spawned. */ + public void setUser(String user) { + this.user = user; + } } diff --git a/org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java b/org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java index 87b7ffaeb1..97f40c767a 100644 --- a/org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java +++ b/org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java @@ -1,59 +1,59 @@ /************* * Copyright (c) 2019-2021, The University of California at Berkeley. - + * * 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. - - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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 + * 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. ***************/ package org.lflang.federated.launcher; import org.lflang.ErrorReporter; -import org.lflang.TargetConfig; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FederateInstance; /** - * Utility class that can be used to create a launcher for federated LF programs - * that are written in TypeScript. - * + * Utility class that can be used to create a launcher for federated LF programs that are written in + * TypeScript. + * * @author Soroush Bateni * @author Hokeun Kim * @author Marten Lohstroh */ public class TsBuildConfig extends BuildConfig { - - public TsBuildConfig(FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { - super(federate, fileConfig, errorReporter); - } - - @Override - public String compileCommand() { - return null; - } - - @Override - public String localExecuteCommand() { - String jsFilename = federate.name + ".js"; - return "node "+fileConfig.getSrcGenPath().resolve(federate.name).resolve("dist").resolve(jsFilename)+" -i $FEDERATION_ID"; - } - + public TsBuildConfig( + FederateInstance federate, FedFileConfig fileConfig, ErrorReporter errorReporter) { + super(federate, fileConfig, errorReporter); + } + + @Override + public String compileCommand() { + return null; + } + + @Override + public String localExecuteCommand() { + String jsFilename = federate.name + ".js"; + return "node " + + fileConfig.getSrcGenPath().resolve(federate.name).resolve("dist").resolve(jsFilename) + + " -i $FEDERATION_ID"; + } } diff --git a/org.lflang/src/org/lflang/federated/serialization/FedNativePythonSerialization.java b/org.lflang/src/org/lflang/federated/serialization/FedNativePythonSerialization.java index e20588d62d..3947b1bd92 100644 --- a/org.lflang/src/org/lflang/federated/serialization/FedNativePythonSerialization.java +++ b/org.lflang/src/org/lflang/federated/serialization/FedNativePythonSerialization.java @@ -1,17 +1,17 @@ /************* * Copyright (c) 2021, The University of California at Berkeley. * Copyright (c) 2021, The University of Texas at Dallas. - * + * * 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. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE @@ -32,91 +32,105 @@ /** * Enables support for Python pickle serialization. - * - * @author Soroush Bateni * + * @author Soroush Bateni */ public class FedNativePythonSerialization implements FedSerialization { - @Override - public boolean isCompatible(GeneratorBase generator) { - if (generator.getTarget() != Target.Python ) { - throw new UnsupportedOperationException("This class only support Python serialization."); - } - return true; + @Override + public boolean isCompatible(GeneratorBase generator) { + if (generator.getTarget() != Target.Python) { + throw new UnsupportedOperationException("This class only support Python serialization."); } + return true; + } - @Override - public String serializedBufferLength() { - return serializedVarName+".len"; - } + @Override + public String serializedBufferLength() { + return serializedVarName + ".len"; + } - @Override - public String seializedBufferVar() { - return serializedVarName+".buf"; - } + @Override + public String seializedBufferVar() { + return serializedVarName + ".buf"; + } - @Override - public StringBuilder generateNetworkSerializerCode(String varName, - String originalType) { - StringBuilder serializerCode = new StringBuilder(); - - // Check that global_pickler is not null - serializerCode.append("if (global_pickler == NULL) lf_print_error_and_exit(\"The pickle module is not loaded.\");\n"); - // Define the serialized PyObject - serializerCode.append("PyObject* serialized_pyobject = PyObject_CallMethod(global_pickler, \"dumps\", \"O\", "+varName+");\n"); - - // Error check - serializerCode.append("if (serialized_pyobject == NULL) {\n"); - serializerCode.append(" if (PyErr_Occurred()) PyErr_Print();\n"); - serializerCode.append(" lf_print_error_and_exit(\"Could not serialize serialized_pyobject.\");\n"); - serializerCode.append("}\n"); - - serializerCode.append("Py_buffer "+serializedVarName+";\n"); - serializerCode.append("int returnValue = PyBytes_AsStringAndSize(serialized_pyobject, &"+serializedVarName+".buf, &"+serializedVarName+".len);\n"); - // Error check - serializerCode.append("if (returnValue == -1) {\n"); - serializerCode.append(" if (PyErr_Occurred()) PyErr_Print();\n"); - serializerCode.append(" lf_print_error_and_exit(\"Could not serialize "+serializedVarName+".\");\n"); - serializerCode.append("}\n"); - - - - return serializerCode; - } + @Override + public StringBuilder generateNetworkSerializerCode(String varName, String originalType) { + StringBuilder serializerCode = new StringBuilder(); - @Override - public StringBuilder generateNetworkDeserializerCode(String varName, - String targetType) { - StringBuilder deserializerCode = new StringBuilder(); - - // Convert the network message to a Python ByteArray - deserializerCode.append("PyObject* message_byte_array = "+ - "PyBytes_FromStringAndSize((char*)"+varName+"->token->value, "+varName+"->token->length);\n"); - // Deserialize using Pickle - deserializerCode.append("Py_XINCREF(message_byte_array);\n"); - deserializerCode.append("PyObject* "+deserializedVarName+ - " = PyObject_CallMethod(global_pickler, \"loads\", \"O\", message_byte_array);\n"); - // Error check - deserializerCode.append("if ("+deserializedVarName+" == NULL) {\n"); - deserializerCode.append(" if (PyErr_Occurred()) PyErr_Print();\n"); - deserializerCode.append(" lf_print_error_and_exit(\"Could not deserialize "+deserializedVarName+".\");\n"); - deserializerCode.append("}\n"); - - // Decrment the reference count - deserializerCode.append("Py_XDECREF(message_byte_array);\n"); - - return deserializerCode; - } + // Check that global_pickler is not null + serializerCode.append( + "if (global_pickler == NULL) lf_print_error_and_exit(\"The pickle module is not" + + " loaded.\");\n"); + // Define the serialized PyObject + serializerCode.append( + "PyObject* serialized_pyobject = PyObject_CallMethod(global_pickler, \"dumps\", \"O\", " + + varName + + ");\n"); - @Override - public StringBuilder generatePreambleForSupport() { - return new StringBuilder(""); - } + // Error check + serializerCode.append("if (serialized_pyobject == NULL) {\n"); + serializerCode.append(" if (PyErr_Occurred()) PyErr_Print();\n"); + serializerCode.append( + " lf_print_error_and_exit(\"Could not serialize serialized_pyobject.\");\n"); + serializerCode.append("}\n"); - @Override - public StringBuilder generateCompilerExtensionForSupport() { - return new StringBuilder(""); - } + serializerCode.append("Py_buffer " + serializedVarName + ";\n"); + serializerCode.append( + "int returnValue = PyBytes_AsStringAndSize(serialized_pyobject, &" + + serializedVarName + + ".buf, &" + + serializedVarName + + ".len);\n"); + // Error check + serializerCode.append("if (returnValue == -1) {\n"); + serializerCode.append(" if (PyErr_Occurred()) PyErr_Print();\n"); + serializerCode.append( + " lf_print_error_and_exit(\"Could not serialize " + serializedVarName + ".\");\n"); + serializerCode.append("}\n"); + + return serializerCode; + } + + @Override + public StringBuilder generateNetworkDeserializerCode(String varName, String targetType) { + StringBuilder deserializerCode = new StringBuilder(); + + // Convert the network message to a Python ByteArray + deserializerCode.append( + "PyObject* message_byte_array = " + + "PyBytes_FromStringAndSize((char*)" + + varName + + "->token->value, " + + varName + + "->token->length);\n"); + // Deserialize using Pickle + deserializerCode.append("Py_XINCREF(message_byte_array);\n"); + deserializerCode.append( + "PyObject* " + + deserializedVarName + + " = PyObject_CallMethod(global_pickler, \"loads\", \"O\", message_byte_array);\n"); + // Error check + deserializerCode.append("if (" + deserializedVarName + " == NULL) {\n"); + deserializerCode.append(" if (PyErr_Occurred()) PyErr_Print();\n"); + deserializerCode.append( + " lf_print_error_and_exit(\"Could not deserialize " + deserializedVarName + ".\");\n"); + deserializerCode.append("}\n"); + + // Decrment the reference count + deserializerCode.append("Py_XDECREF(message_byte_array);\n"); + + return deserializerCode; + } + + @Override + public StringBuilder generatePreambleForSupport() { + return new StringBuilder(""); + } + @Override + public StringBuilder generateCompilerExtensionForSupport() { + return new StringBuilder(""); + } } diff --git a/org.lflang/src/org/lflang/federated/serialization/FedROS2CPPSerialization.java b/org.lflang/src/org/lflang/federated/serialization/FedROS2CPPSerialization.java index d116489dca..1384d11517 100644 --- a/org.lflang/src/org/lflang/federated/serialization/FedROS2CPPSerialization.java +++ b/org.lflang/src/org/lflang/federated/serialization/FedROS2CPPSerialization.java @@ -1,17 +1,17 @@ /************* * Copyright (c) 2021, The University of California at Berkeley. * Copyright (c) 2021, The University of Texas at Dallas. - * + * * 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. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE @@ -32,179 +32,191 @@ /** * Enables support for ROS 2 serialization in C/C++ code. - * - * @author Soroush Bateni * + * @author Soroush Bateni */ public class FedROS2CPPSerialization implements FedSerialization { - /** - * Check whether the current generator is compatible with the given - * serialization technique or not. - * - * @param generator The current generator. - * @return true if compatible, false if not. - */ - @Override - public boolean isCompatible(GeneratorBase generator) { - if (generator.getTarget() != Target.C) { - generator.errorReporter.reportError("ROS serialization is currently only supported for the C target."); - return false; - } else if (!generator.getTargetConfig().compiler.equalsIgnoreCase("g++")) { - generator.errorReporter.reportError( - "Please use the 'compiler: \"g++\"' target property \n"+ - "for ROS serialization" - ); - return false; - } - return true; - } - - /** - * @return Expression in target language that corresponds to the length - * of the serialized buffer. - */ - @Override - public String serializedBufferLength() { - return serializedVarName+".size()"; + /** + * Check whether the current generator is compatible with the given serialization technique or + * not. + * + * @param generator The current generator. + * @return true if compatible, false if not. + */ + @Override + public boolean isCompatible(GeneratorBase generator) { + if (generator.getTarget() != Target.C) { + generator.errorReporter.reportError( + "ROS serialization is currently only supported for the C target."); + return false; + } else if (!generator.getTargetConfig().compiler.equalsIgnoreCase("g++")) { + generator.errorReporter.reportError( + "Please use the 'compiler: \"g++\"' target property \n" + "for ROS serialization"); + return false; } + return true; + } - /** - * @return Expression in target language that is the buffer variable - * itself. - */ - @Override - public String seializedBufferVar() { - return serializedVarName+".get_rcl_serialized_message().buffer"; - } - - /** - * Generate code in C++ that serializes 'varName'. This code - * will convert the data in 'varName' from its 'originalType' into an - * uint8_t. The serialized data will be put in a variable called - * 'serialized_message', defined by @see serializedVarName. - * - * @param varName The variable to be serialized. - * @param originalType The original type of the variable. - * @return Target code that serializes the 'varName' from 'type' - * to an unsigned byte array. - */ - @Override - public StringBuilder generateNetworkSerializerCode(String varName, String originalType) { - StringBuilder serializerCode = new StringBuilder(); - - serializerCode.append("rclcpp::SerializedMessage "+serializedVarName+"(0u);\n"); - // Use the port type verbatim here, which can result - // in compile error if it is not a valid ROS type - serializerCode.append("using MessageT = "+originalType+";\n"); - serializerCode.append("static rclcpp::Serialization _lf_serializer;\n"); - serializerCode.append("_lf_serializer.serialize_message(&"+varName+"->value , &"+serializedVarName+");\n"); - - return serializerCode; - } - - /** - * Variant of @see generateNetworkSerializerCode(String varName, String originalType) - * that also supports shared pointer (i.e., std::shared_ptr<>) definitions of ROS port - * types. - * @param isSharedPtrType Indicates whether the port type is a shared pointer or not. - */ - public StringBuilder generateNetworkSerializerCode(String varName, String originalType, boolean isSharedPtrType) { - StringBuilder serializerCode = new StringBuilder(); - - serializerCode.append("rclcpp::SerializedMessage "+serializedVarName+"(0u);\n"); - // Use the port type verbatim here, which can result - // in compile error if it is not a valid ROS type - serializerCode.append("using MessageT = "+originalType+";\n"); - serializerCode.append("static rclcpp::Serialization _lf_serializer;\n"); - if (isSharedPtrType) { - serializerCode.append("_lf_serializer.serialize_message("+varName+"->value.get() , &"+serializedVarName+");\n"); - } else { - serializerCode.append("_lf_serializer.serialize_message(&"+varName+"->value , &"+serializedVarName+");\n"); - } - - return serializerCode; - } + /** + * @return Expression in target language that corresponds to the length of the serialized buffer. + */ + @Override + public String serializedBufferLength() { + return serializedVarName + ".size()"; + } + /** + * @return Expression in target language that is the buffer variable itself. + */ + @Override + public String seializedBufferVar() { + return serializedVarName + ".get_rcl_serialized_message().buffer"; + } - - /** - * Generate code in C++ that deserializes 'varName'. This code will - * convert the data in 'varName' from a uint8_t into the 'targetType'. - * The deserialized data will be put in a variable called deserialized_message - * defined by @see deserializedVarName. - * - * @param varName The variable to deserialize. - * @param targetType The type to deserialize into. - * @return Target code that deserializes 'varName' from an unsigned byte array - * to 'type'. - */ - @Override - public StringBuilder generateNetworkDeserializerCode(String varName, String targetType) { - StringBuilder deserializerCode = new StringBuilder(); - - deserializerCode.append( - "auto message = std::make_unique( rcl_serialized_message_t{\n" - + " .buffer = (uint8_t*)"+varName+".tmplt.token->value,\n" - + " .buffer_length = "+varName+".tmplt.token->length,\n" - + " .buffer_capacity = "+varName+".tmplt.token->length,\n" - + " .allocator = rcl_get_default_allocator()\n" - + "});\n" - ); - deserializerCode.append("auto msg = std::make_unique(std::move(*message.get()));\n"); - deserializerCode.append(varName+".tmplt.token->value = NULL; // Manually move the data\n"); - // Use the port type verbatim here, which can result - // in compile error if it is not a valid ROS type - deserializerCode.append("using MessageT = "+targetType+";\n"); - deserializerCode.append( - "MessageT "+deserializedVarName+" = MessageT();\n" - + "auto _lf_serializer = rclcpp::Serialization();\n" - + "_lf_serializer.deserialize_message(msg.get(), &"+deserializedVarName+");\n" - ); - - return deserializerCode; - } + /** + * Generate code in C++ that serializes 'varName'. This code will convert the data in 'varName' + * from its 'originalType' into an uint8_t. The serialized data will be put in a variable called + * 'serialized_message', defined by @see serializedVarName. + * + * @param varName The variable to be serialized. + * @param originalType The original type of the variable. + * @return Target code that serializes the 'varName' from 'type' to an unsigned byte array. + */ + @Override + public StringBuilder generateNetworkSerializerCode(String varName, String originalType) { + StringBuilder serializerCode = new StringBuilder(); - /** - * @return Code in C that includes all the necessary preamble to enable - * support for ROS 2 serialization. - */ - @Override - public StringBuilder generatePreambleForSupport() { - StringBuilder preamble = new StringBuilder(); - - preamble.append( - "#include \"rcutils/allocator.h\"\n" - + "#include \"rclcpp/rclcpp.hpp\"\n" - + "#include \"rclcpp/serialization.hpp\"\n" - + "#include \"rclcpp/serialized_message.hpp\"\n" - ); - - return preamble; - } - - /** - * @return Code that should be appended to the CMakeLists.txt to enable - * support for ROS 2 serialization. - */ - @Override - public StringBuilder generateCompilerExtensionForSupport() { - StringBuilder cMakeExtension = new StringBuilder(); - - cMakeExtension.append( - "enable_language(CXX)\n" - + "set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-write-strings -O2\")\n" - + "\n" - + "find_package(ament_cmake REQUIRED)\n" - + "find_package(rclcpp REQUIRED)\n" - + "find_package(rclcpp_components REQUIRED)\n" - + "find_package(rcutils)\n" - + "find_package(rmw REQUIRED)\n" - + "\n" - + "ament_target_dependencies( ${LF_MAIN_TARGET} rclcpp rmw)" - ); - - return cMakeExtension; + serializerCode.append("rclcpp::SerializedMessage " + serializedVarName + "(0u);\n"); + // Use the port type verbatim here, which can result + // in compile error if it is not a valid ROS type + serializerCode.append("using MessageT = " + originalType + ";\n"); + serializerCode.append("static rclcpp::Serialization _lf_serializer;\n"); + serializerCode.append( + "_lf_serializer.serialize_message(&" + + varName + + "->value , &" + + serializedVarName + + ");\n"); + + return serializerCode; + } + + /** + * Variant of @see generateNetworkSerializerCode(String varName, String originalType) that also + * supports shared pointer (i.e., std::shared_ptr<>) definitions of ROS port types. + * + * @param isSharedPtrType Indicates whether the port type is a shared pointer or not. + */ + public StringBuilder generateNetworkSerializerCode( + String varName, String originalType, boolean isSharedPtrType) { + StringBuilder serializerCode = new StringBuilder(); + + serializerCode.append("rclcpp::SerializedMessage " + serializedVarName + "(0u);\n"); + // Use the port type verbatim here, which can result + // in compile error if it is not a valid ROS type + serializerCode.append("using MessageT = " + originalType + ";\n"); + serializerCode.append("static rclcpp::Serialization _lf_serializer;\n"); + if (isSharedPtrType) { + serializerCode.append( + "_lf_serializer.serialize_message(" + + varName + + "->value.get() , &" + + serializedVarName + + ");\n"); + } else { + serializerCode.append( + "_lf_serializer.serialize_message(&" + + varName + + "->value , &" + + serializedVarName + + ");\n"); } + return serializerCode; + } + + /** + * Generate code in C++ that deserializes 'varName'. This code will convert the data in 'varName' + * from a uint8_t into the 'targetType'. The deserialized data will be put in a variable called + * deserialized_message defined by @see deserializedVarName. + * + * @param varName The variable to deserialize. + * @param targetType The type to deserialize into. + * @return Target code that deserializes 'varName' from an unsigned byte array to 'type'. + */ + @Override + public StringBuilder generateNetworkDeserializerCode(String varName, String targetType) { + StringBuilder deserializerCode = new StringBuilder(); + + deserializerCode.append( + "auto message = std::make_unique( rcl_serialized_message_t{\n" + + " .buffer = (uint8_t*)" + + varName + + ".tmplt.token->value,\n" + + " .buffer_length = " + + varName + + ".tmplt.token->length,\n" + + " .buffer_capacity = " + + varName + + ".tmplt.token->length,\n" + + " .allocator = rcl_get_default_allocator()\n" + + "});\n"); + deserializerCode.append( + "auto msg = std::make_unique(std::move(*message.get()));\n"); + deserializerCode.append(varName + ".tmplt.token->value = NULL; // Manually move the data\n"); + // Use the port type verbatim here, which can result + // in compile error if it is not a valid ROS type + deserializerCode.append("using MessageT = " + targetType + ";\n"); + deserializerCode.append( + "MessageT " + + deserializedVarName + + " = MessageT();\n" + + "auto _lf_serializer = rclcpp::Serialization();\n" + + "_lf_serializer.deserialize_message(msg.get(), &" + + deserializedVarName + + ");\n"); + + return deserializerCode; + } + + /** + * @return Code in C that includes all the necessary preamble to enable support for ROS 2 + * serialization. + */ + @Override + public StringBuilder generatePreambleForSupport() { + StringBuilder preamble = new StringBuilder(); + + preamble.append( + "#include \"rcutils/allocator.h\"\n" + + "#include \"rclcpp/rclcpp.hpp\"\n" + + "#include \"rclcpp/serialization.hpp\"\n" + + "#include \"rclcpp/serialized_message.hpp\"\n"); + + return preamble; + } + + /** + * @return Code that should be appended to the CMakeLists.txt to enable support for ROS 2 + * serialization. + */ + @Override + public StringBuilder generateCompilerExtensionForSupport() { + StringBuilder cMakeExtension = new StringBuilder(); + + cMakeExtension.append( + "enable_language(CXX)\n" + + "set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-write-strings -O2\")\n" + + "\n" + + "find_package(ament_cmake REQUIRED)\n" + + "find_package(rclcpp REQUIRED)\n" + + "find_package(rclcpp_components REQUIRED)\n" + + "find_package(rcutils)\n" + + "find_package(rmw REQUIRED)\n" + + "\n" + + "ament_target_dependencies( ${LF_MAIN_TARGET} rclcpp rmw)"); + + return cMakeExtension; + } } diff --git a/org.lflang/src/org/lflang/federated/serialization/FedSerialization.java b/org.lflang/src/org/lflang/federated/serialization/FedSerialization.java index 9b7ba0b2eb..fab7201c21 100644 --- a/org.lflang/src/org/lflang/federated/serialization/FedSerialization.java +++ b/org.lflang/src/org/lflang/federated/serialization/FedSerialization.java @@ -3,80 +3,69 @@ import org.lflang.generator.GeneratorBase; /** - * Interface to enable support for automatic data serialization - * in target code. - * - * @author Soroush Bateni + * Interface to enable support for automatic data serialization in target code. * + * @author Soroush Bateni */ public interface FedSerialization { - - /** - * Variable name in the target language for the serialized data. - */ - final static String serializedVarName = "serialized_message"; - - /** - * Variable name in the target language for the deserialized data. - */ - final static String deserializedVarName = "deserialized_message"; - - /** - * Check whether the current generator is compatible with the given - * serialization technique or not. - * - * @param generator The current generator. - * @return true if compatible, false if not. - */ - public boolean isCompatible(GeneratorBase generator); - /** - * @return Expression in target language that corresponds to the length - * of the serialized buffer. - */ - public String serializedBufferLength(); - - /** - * @return Expression in target language that is the buffer variable - * itself. - */ - public String seializedBufferVar(); - - /** - * Generate code in target language that serializes 'varName'. This code - * will convert the data in 'varName' from its 'originalType' into an - * unsigned byte array. The serialized data will be put in a variable - * with the name defined by @see serializedVarName. - * - * @param varName The variable to be serialized. - * @param originalType The original type of the variable. - * @return Target code that serializes the 'varName' from 'type' - * to an unsigned byte array. - */ - public StringBuilder generateNetworkSerializerCode(String varName, String originalType); - - /** - * Generate code in target language that deserializes 'varName'. This code will - * convert the data in 'varName' from an unsigned byte array into the 'targetType'. - * The deserialized data will be put in a variable with the name defined by - * @see deserializedVarName. - * - * @param varName The variable to deserialize. - * @param targetType The type to deserialize into. - * @return Target code that deserializes 'varName' from an unsigned byte array - * to 'type'. - */ - public StringBuilder generateNetworkDeserializerCode(String varName, String targetType); - - /** - * @return Code in target language that includes all the necessary preamble to enable - * support for the current serializer. - */ - public StringBuilder generatePreambleForSupport(); - - /** - * @return Code that should be appended to the compiler instructions (e.g., flags to gcc or - * additional lines to a CMakeLists.txt) to enable support for the current serializer. - */ - public StringBuilder generateCompilerExtensionForSupport(); + /** Variable name in the target language for the serialized data. */ + static final String serializedVarName = "serialized_message"; + + /** Variable name in the target language for the deserialized data. */ + static final String deserializedVarName = "deserialized_message"; + + /** + * Check whether the current generator is compatible with the given serialization technique or + * not. + * + * @param generator The current generator. + * @return true if compatible, false if not. + */ + public boolean isCompatible(GeneratorBase generator); + + /** + * @return Expression in target language that corresponds to the length of the serialized buffer. + */ + public String serializedBufferLength(); + + /** + * @return Expression in target language that is the buffer variable itself. + */ + public String seializedBufferVar(); + + /** + * Generate code in target language that serializes 'varName'. This code will convert the data in + * 'varName' from its 'originalType' into an unsigned byte array. The serialized data will be put + * in a variable with the name defined by @see serializedVarName. + * + * @param varName The variable to be serialized. + * @param originalType The original type of the variable. + * @return Target code that serializes the 'varName' from 'type' to an unsigned byte array. + */ + public StringBuilder generateNetworkSerializerCode(String varName, String originalType); + + /** + * Generate code in target language that deserializes 'varName'. This code will convert the data + * in 'varName' from an unsigned byte array into the 'targetType'. The deserialized data will be + * put in a variable with the name defined by + * + * @see deserializedVarName. + * @param varName The variable to deserialize. + * @param targetType The type to deserialize into. + * @return Target code that deserializes 'varName' from an unsigned byte array to 'type'. + */ + public StringBuilder generateNetworkDeserializerCode(String varName, String targetType); + + /** + * @return Code in target language that includes all the necessary preamble to enable support for + * the current serializer. + */ + public StringBuilder generatePreambleForSupport(); + + /** + * @return Code that should be appended to the compiler instructions (e.g., flags to gcc or + * additional lines to a CMakeLists.txt) to enable support for the current serializer. + */ + public StringBuilder generateCompilerExtensionForSupport(); } diff --git a/org.lflang/src/org/lflang/federated/serialization/SupportedSerializers.java b/org.lflang/src/org/lflang/federated/serialization/SupportedSerializers.java index 332ab6152c..4767f3f4d7 100644 --- a/org.lflang/src/org/lflang/federated/serialization/SupportedSerializers.java +++ b/org.lflang/src/org/lflang/federated/serialization/SupportedSerializers.java @@ -2,23 +2,25 @@ /** * The supported serializers. + * * @author Soroush Bateni */ public enum SupportedSerializers { - NATIVE("native"), // Dangerous: just copies the memory layout of the sender - ROS2("ros2"), - PROTO("proto"); + NATIVE("native"), // Dangerous: just copies the memory layout of the sender + ROS2("ros2"), + PROTO("proto"); - private String serializer; - SupportedSerializers(String serializer) { - this.serializer = serializer; - } - - public String getSerializer() { - return serializer; - } - - public void setSerializer(String serializer) { - this.serializer = serializer; - } + private String serializer; + + SupportedSerializers(String serializer) { + this.serializer = serializer; + } + + public String getSerializer() { + return serializer; + } + + public void setSerializer(String serializer) { + this.serializer = serializer; + } } diff --git a/org.lflang/src/org/lflang/federated/validation/FedValidator.java b/org.lflang/src/org/lflang/federated/validation/FedValidator.java index 49add78557..9aeb535d2f 100644 --- a/org.lflang/src/org/lflang/federated/validation/FedValidator.java +++ b/org.lflang/src/org/lflang/federated/validation/FedValidator.java @@ -3,9 +3,8 @@ import java.util.ArrayList; import java.util.List; import java.util.stream.Stream; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Output; @@ -13,57 +12,55 @@ import org.lflang.lf.Reactor; import org.lflang.lf.VarRef; -/** - * Helper class that is used to validate a federated reactor. - */ +/** Helper class that is used to validate a federated reactor. */ public class FedValidator { - public static void validateFederatedReactor(Reactor reactor, ErrorReporter errorReporter) { - if (!reactor.isFederated()) return; + public static void validateFederatedReactor(Reactor reactor, ErrorReporter errorReporter) { + if (!reactor.isFederated()) return; - // Construct the set of excluded reactions for this federate. - // If a reaction is a network reaction that belongs to this federate, we - // don't need to perform this analysis. - Iterable reactions = ASTUtils.allReactions(reactor); - for (Reaction react : reactions) { - // Create a collection of all the VarRefs (i.e., triggers, sources, and effects) in the react - // signature that are ports that reference federates. - // We then later check that all these VarRefs reference this federate. If not, we will add this - // react to the list of reactions that have to be excluded (note that mixing VarRefs from - // different federates is not allowed). - List allVarRefsReferencingFederates = new ArrayList<>(); - // Add all the triggers that are outputs - Stream triggersAsVarRef = react.getTriggers().stream().filter(it -> it instanceof VarRef).map(it -> (VarRef) it); - allVarRefsReferencingFederates.addAll( - triggersAsVarRef.filter(it -> it.getVariable() instanceof Output).toList() - ); - // Add all the sources that are outputs - allVarRefsReferencingFederates.addAll( - react.getSources().stream().filter(it -> it.getVariable() instanceof Output).toList() - ); - // Add all the effects that are inputs - allVarRefsReferencingFederates.addAll( - react.getEffects().stream().filter(it -> it.getVariable() instanceof Input).toList() - ); - containsAllVarRefs(allVarRefsReferencingFederates, errorReporter); - } + // Construct the set of excluded reactions for this federate. + // If a reaction is a network reaction that belongs to this federate, we + // don't need to perform this analysis. + Iterable reactions = ASTUtils.allReactions(reactor); + for (Reaction react : reactions) { + // Create a collection of all the VarRefs (i.e., triggers, sources, and effects) in the react + // signature that are ports that reference federates. + // We then later check that all these VarRefs reference this federate. If not, we will add + // this + // react to the list of reactions that have to be excluded (note that mixing VarRefs from + // different federates is not allowed). + List allVarRefsReferencingFederates = new ArrayList<>(); + // Add all the triggers that are outputs + Stream triggersAsVarRef = + react.getTriggers().stream().filter(it -> it instanceof VarRef).map(it -> (VarRef) it); + allVarRefsReferencingFederates.addAll( + triggersAsVarRef.filter(it -> it.getVariable() instanceof Output).toList()); + // Add all the sources that are outputs + allVarRefsReferencingFederates.addAll( + react.getSources().stream().filter(it -> it.getVariable() instanceof Output).toList()); + // Add all the effects that are inputs + allVarRefsReferencingFederates.addAll( + react.getEffects().stream().filter(it -> it.getVariable() instanceof Input).toList()); + containsAllVarRefs(allVarRefsReferencingFederates, errorReporter); } + } - /** - * Check if this federate contains all the {@code varRefs}. If not, report an error using {@code errorReporter}. - */ - private static void containsAllVarRefs(List varRefs, ErrorReporter errorReporter) { - var referencesFederate = false; - Instantiation instantiation = null; - for (VarRef varRef : varRefs) { - if (instantiation == null) { - instantiation = varRef.getContainer(); - referencesFederate = true; - } else if (!varRef.getContainer().equals(instantiation)) { - errorReporter.reportError(varRef, "Mixed triggers and effects from" + - " different federates. This is not permitted"); - } - } - + /** + * Check if this federate contains all the {@code varRefs}. If not, report an error using {@code + * errorReporter}. + */ + private static void containsAllVarRefs(List varRefs, ErrorReporter errorReporter) { + var referencesFederate = false; + Instantiation instantiation = null; + for (VarRef varRef : varRefs) { + if (instantiation == null) { + instantiation = varRef.getContainer(); + referencesFederate = true; + } else if (!varRef.getContainer().equals(instantiation)) { + errorReporter.reportError( + varRef, + "Mixed triggers and effects from" + " different federates. This is not permitted"); + } } + } } diff --git a/org.lflang/src/org/lflang/formatting2/LFFormatter.java b/org.lflang/src/org/lflang/formatting2/LFFormatter.java index 2a5e60cdc8..7df4053eef 100644 --- a/org.lflang/src/org/lflang/formatting2/LFFormatter.java +++ b/org.lflang/src/org/lflang/formatting2/LFFormatter.java @@ -4,8 +4,8 @@ package org.lflang.formatting2; +import com.google.inject.Inject; import java.util.List; - import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.formatting2.FormatterRequest; import org.eclipse.xtext.formatting2.IFormatter2; @@ -15,38 +15,32 @@ import org.eclipse.xtext.util.CancelIndicator; import org.eclipse.xtext.validation.CheckMode; import org.eclipse.xtext.validation.IResourceValidator; - import org.lflang.ast.FormattingUtils; -import com.google.inject.Inject; - public class LFFormatter implements IFormatter2 { - @Inject - private IResourceValidator validator; + @Inject private IResourceValidator validator; - @Override - public List format(FormatterRequest request) { - // TODO: Use a CancelIndicator that actually cancels? - if (!request.getTextRegionAccess().getResource().getErrors().isEmpty() - || !validator.validate( + @Override + public List format(FormatterRequest request) { + // TODO: Use a CancelIndicator that actually cancels? + if (!request.getTextRegionAccess().getResource().getErrors().isEmpty() + || !validator + .validate( request.getTextRegionAccess().getResource(), CheckMode.ALL, - CancelIndicator.NullImpl - ).isEmpty() - ) { - return List.of(); - } - ITextSegment documentRegion = request.getTextRegionAccess().regionForDocument(); - List documentContents = request.getTextRegionAccess().getResource().getContents(); - if (documentContents.isEmpty()) return List.of(); - return List.of( - new TextReplacement( - request.getTextRegionAccess(), - documentRegion.getOffset(), - documentRegion.getLength(), - FormattingUtils.render(documentContents.get(0)) - ) - ); + CancelIndicator.NullImpl) + .isEmpty()) { + return List.of(); } + ITextSegment documentRegion = request.getTextRegionAccess().regionForDocument(); + List documentContents = request.getTextRegionAccess().getResource().getContents(); + if (documentContents.isEmpty()) return List.of(); + return List.of( + new TextReplacement( + request.getTextRegionAccess(), + documentRegion.getOffset(), + documentRegion.getLength(), + FormattingUtils.render(documentContents.get(0)))); + } } diff --git a/org.lflang/src/org/lflang/generator/ActionInstance.java b/org.lflang/src/org/lflang/generator/ActionInstance.java index bdc8793383..b749a26426 100644 --- a/org.lflang/src/org/lflang/generator/ActionInstance.java +++ b/org.lflang/src/org/lflang/generator/ActionInstance.java @@ -1,28 +1,28 @@ /* Instance of an action. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; @@ -32,69 +32,69 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY /** * Instance of an action. + * * @author Edward A. Lee * @author Marten Lohstroh */ public class ActionInstance extends TriggerInstance { - /** The constant default for a minimum delay. */ - public static final TimeValue DEFAULT_MIN_DELAY = TimeValue.ZERO; + /** The constant default for a minimum delay. */ + public static final TimeValue DEFAULT_MIN_DELAY = TimeValue.ZERO; - /** The minimum delay for this action. */ - private TimeValue minDelay = DEFAULT_MIN_DELAY; + /** The minimum delay for this action. */ + private TimeValue minDelay = DEFAULT_MIN_DELAY; - /** The minimum spacing between action events. */ - private TimeValue minSpacing = null; + /** The minimum spacing between action events. */ + private TimeValue minSpacing = null; - /** The replacement policy for when minimum spacing is violated. */ - private String policy = null; + /** The replacement policy for when minimum spacing is violated. */ + private String policy = null; - /** Indicator of whether the action is physical. */ - private boolean physical; + /** Indicator of whether the action is physical. */ + private boolean physical; - /** - * Create a new action instance. - * If the definition is null, then this is a shutdown action. - * @param definition The AST definition, or null for startup. - * @param parent The parent reactor. - */ - public ActionInstance(Action definition, ReactorInstance parent) { - super(definition, parent); - if (parent == null) { - throw new InvalidSourceException("Cannot create an ActionInstance with no parent."); - } - if (definition != null) { - if (definition.getMinDelay() != null) { - this.minDelay = parent.getTimeValue(definition.getMinDelay()); - } - if (definition.getMinSpacing() != null) { - this.minSpacing = parent.getTimeValue(definition.getMinSpacing()); - } - if (definition.getOrigin() == ActionOrigin.PHYSICAL) { - physical = true; - } - policy = definition.getPolicy(); - } + /** + * Create a new action instance. If the definition is null, then this is a shutdown action. + * + * @param definition The AST definition, or null for startup. + * @param parent The parent reactor. + */ + public ActionInstance(Action definition, ReactorInstance parent) { + super(definition, parent); + if (parent == null) { + throw new InvalidSourceException("Cannot create an ActionInstance with no parent."); } - - /** Return the minimum delay for this action. */ - public TimeValue getMinDelay() { - return minDelay; + if (definition != null) { + if (definition.getMinDelay() != null) { + this.minDelay = parent.getTimeValue(definition.getMinDelay()); + } + if (definition.getMinSpacing() != null) { + this.minSpacing = parent.getTimeValue(definition.getMinSpacing()); + } + if (definition.getOrigin() == ActionOrigin.PHYSICAL) { + physical = true; + } + policy = definition.getPolicy(); } - - /** Return the minimum spacing between action events. */ - public TimeValue getMinSpacing() { - return minSpacing; - } - - /** Return the replacement policy for when minimum spacing is violated. */ - public String getPolicy() { - return policy; - } - - /** Return the indicator of whether the action is physical. */ - public boolean isPhysical() { - return physical; - } - + } + + /** Return the minimum delay for this action. */ + public TimeValue getMinDelay() { + return minDelay; + } + + /** Return the minimum spacing between action events. */ + public TimeValue getMinSpacing() { + return minSpacing; + } + + /** Return the replacement policy for when minimum spacing is violated. */ + public String getPolicy() { + return policy; + } + + /** Return the indicator of whether the action is physical. */ + public boolean isPhysical() { + return physical; + } } diff --git a/org.lflang/src/org/lflang/generator/CodeBuilder.java b/org.lflang/src/org/lflang/generator/CodeBuilder.java index 2b77239680..e4e92294fb 100644 --- a/org.lflang/src/org/lflang/generator/CodeBuilder.java +++ b/org.lflang/src/org/lflang/generator/CodeBuilder.java @@ -1,533 +1,555 @@ package org.lflang.generator; -import java.nio.file.Path; -import java.io.IOException; +import static org.lflang.generator.c.CMixedRadixGenerator.*; +import static org.lflang.util.StringUtil.joinObjects; +import java.io.IOException; +import java.nio.file.Path; import org.eclipse.emf.common.CommonPlugin; import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.nodemodel.util.NodeModelUtils; -import org.lflang.federated.generator.FederateInstance; import org.lflang.generator.c.CUtil; import org.lflang.lf.Code; import org.lflang.util.FileUtil; -import static org.lflang.generator.c.CMixedRadixGenerator.*; -import static org.lflang.util.StringUtil.joinObjects; /** - * Helper class for printing code with indentation. - * This class is backed by a StringBuilder and is used to accumulate - * code to be printed to a file. Its main function is to handle indentation. + * Helper class for printing code with indentation. This class is backed by a StringBuilder and is + * used to accumulate code to be printed to a file. Its main function is to handle indentation. * * @author Edward A. Lee * @author Peter Donovan */ public class CodeBuilder { - /** - * Construct a new empty code emitter. - */ - public CodeBuilder() {} - - /** - * Construct a new code emitter with the text and indentation - * of the specified code emitter. - * @param model The model code emitter. - */ - public CodeBuilder(CodeBuilder model) { - indentation = model.indentation; - code.append(model); - } - - ///////////////////////////////////////////// - ///// Public methods. - - /** - * Get the code produced so far. - * @return The code produced so far as a String. - */ - public String getCode() { - return code.toString(); - } - - /** - * Increase the indentation of the output code produced. - */ - public void indent() { - indentation += " "; - } - - /** - * Insert the specified text at the specified position. - * @param position The position. - * @param text The text. - */ - public void insert(int position, String text) { - code.insert(position, text); - } - - /** - * Return the length of the code in characters. - */ - public int length() { - return code.length(); - } - - /** - * Add a new line. - */ - public void newLine() { - this.pr(""); - } - - /** - * Append the specified text plus a final newline. - * @param format A format string to be used by {@code String.format} or - * the text to append if no further arguments are given. - * @param args Additional arguments to pass to the formatter. - */ - public void pr(String format, Object... args) { - pr( - (args != null && args.length > 0) ? String.format(format, args) : format - ); - } - - /** - * Append the given text to the code buffer at the current indentation level. - */ - public void pr(CharSequence text) { - for (String line : (Iterable) () -> text.toString().lines().iterator()) { - code.append(indentation).append(line).append("\n"); - } + /** Construct a new empty code emitter. */ + public CodeBuilder() {} + + /** + * Construct a new code emitter with the text and indentation of the specified code emitter. + * + * @param model The model code emitter. + */ + public CodeBuilder(CodeBuilder model) { + indentation = model.indentation; + code.append(model); + } + + ///////////////////////////////////////////// + ///// Public methods. + + /** + * Get the code produced so far. + * + * @return The code produced so far as a String. + */ + public String getCode() { + return code.toString(); + } + + /** Increase the indentation of the output code produced. */ + public void indent() { + indentation += " "; + } + + /** + * Insert the specified text at the specified position. + * + * @param position The position. + * @param text The text. + */ + public void insert(int position, String text) { + code.insert(position, text); + } + + /** Return the length of the code in characters. */ + public int length() { + return code.length(); + } + + /** Add a new line. */ + public void newLine() { + this.pr(""); + } + + /** + * Append the specified text plus a final newline. + * + * @param format A format string to be used by {@code String.format} or the text to append if no + * further arguments are given. + * @param args Additional arguments to pass to the formatter. + */ + public void pr(String format, Object... args) { + pr((args != null && args.length > 0) ? String.format(format, args) : format); + } + + /** Append the given text to the code buffer at the current indentation level. */ + public void pr(CharSequence text) { + for (String line : (Iterable) () -> text.toString().lines().iterator()) { + code.append(indentation).append(line).append("\n"); } - - /** - * Version of pr() that prints a source line number using a #line - * prior to each line of the output. Use this when multiple lines of - * output code are all due to the same source line in the .lf file. - * @param eObject The AST node that this source line is based on. - * @param text The text to append. - */ - public void pr(EObject eObject, Object text) { - var split = text.toString().split("\n"); - for (String line : split) { - prSourceLineNumber(eObject); - pr(line); - } + } + + /** + * Version of pr() that prints a source line number using a #line prior to each line of the + * output. Use this when multiple lines of output code are all due to the same source line in the + * .lf file. + * + * @param eObject The AST node that this source line is based on. + * @param text The text to append. + */ + public void pr(EObject eObject, Object text) { + var split = text.toString().split("\n"); + for (String line : split) { + prSourceLineNumber(eObject); + pr(line); } - - /** Print the #line compiler directive with the line number of - * the specified object. - * @param eObject The node. - */ - public void prSourceLineNumber(EObject eObject) { - var node = NodeModelUtils.getNode(eObject); - if (node != null) { - // For code blocks (delimited by {= ... =}, unfortunately, - // we have to adjust the offset by the number of newlines before {=. - // Unfortunately, this is complicated because the code has been - // tokenized. - var offset = 0; - if (eObject instanceof Code) { - offset += 1; - } - // Extract the filename from eResource, an astonishingly difficult thing to do. - String filePath = CommonPlugin.resolve(eObject.eResource().getURI()).path(); - pr("#line " + (node.getStartLine() + offset) + " \"" + filePath + "\""); - } + } + + /** + * Print the #line compiler directive with the line number of the specified object. + * + * @param eObject The node. + */ + public void prSourceLineNumber(EObject eObject) { + var node = NodeModelUtils.getNode(eObject); + if (node != null) { + // For code blocks (delimited by {= ... =}, unfortunately, + // we have to adjust the offset by the number of newlines before {=. + // Unfortunately, this is complicated because the code has been + // tokenized. + var offset = 0; + if (eObject instanceof Code) { + offset += 1; + } + // Extract the filename from eResource, an astonishingly difficult thing to do. + String filePath = CommonPlugin.resolve(eObject.eResource().getURI()).path(); + pr("#line " + (node.getStartLine() + offset) + " \"" + filePath + "\""); } - - /** - * Append a single-line, C-style comment to the code. - * @param comment The comment. - */ - public void prComment(String comment) { - pr("// " + comment); + } + + /** + * Append a single-line, C-style comment to the code. + * + * @param comment The comment. + */ + public void prComment(String comment) { + pr("// " + comment); + } + + /** + * Remove all lines that start with the specified prefix and return a new CodeBuilder with the + * result. + * + * @param prefix The prefix. + */ + public CodeBuilder removeLines(String prefix) { + String separator = "\n"; + String[] lines = toString().split(separator); + + CodeBuilder builder = new CodeBuilder(); + + for (String line : lines) { + String trimmedLine = line.trim(); + if (!trimmedLine.startsWith(prefix)) { + builder.pr(line); + } } - - /** - * Remove all lines that start with the specified prefix - * and return a new CodeBuilder with the result. - * @param prefix The prefix. - */ - public CodeBuilder removeLines(String prefix) { - String separator = "\n"; - String[] lines = toString().split(separator); - - CodeBuilder builder = new CodeBuilder(); - - for(String line : lines) { - String trimmedLine = line.trim(); - if(!trimmedLine.startsWith(prefix)) { - builder.pr(line); - } - } - return builder; + return builder; + } + + /** + * Start a scoped block, which is a section of code surrounded by curley braces and indented. This + * must be followed by an {@link #endScopedBlock()}. + */ + public void startScopedBlock() { + pr("{"); + indent(); + } + + /** + * Start a scoped block for the specified reactor. If the reactor is a bank, then this starts a + * for loop that iterates over the bank members using a standard index variable whose name is that + * returned by {@link CUtil#bankIndex(ReactorInstance)}. If the reactor is null or is not a bank, + * then this simply starts a scoped block by printing an opening curly brace. This also adds a + * declaration of a pointer to the self struct of the reactor or bank member. + * + *

    This block is intended to be nested, where each block is put within a similar block for the + * reactor's parent. This ensures that all (possibly nested) bank index variables are defined + * within the block. + * + *

    This must be followed by an {@link #endScopedBlock()}. + * + * @param reactor The reactor instance. + */ + public void startScopedBlock(ReactorInstance reactor) { + if (reactor != null && reactor.isBank()) { + var index = CUtil.bankIndexName(reactor); + pr("// Reactor is a bank. Iterate over bank members."); + pr("for (int " + index + " = 0; " + index + " < " + reactor.width + "; " + index + "++) {"); + indent(); + } else { + startScopedBlock(); } - - /** - * Start a scoped block, which is a section of code - * surrounded by curley braces and indented. - * This must be followed by an {@link #endScopedBlock()}. - */ - public void startScopedBlock() { - pr("{"); - indent(); + } + + /** + * If the specified port is a multiport, then start a specified iteration over the channels of the + * multiport using as the channel index the variable name returned by {@link + * CUtil#channelIndex(PortInstance)}. If the port is not a multiport, do nothing. This is required + * to be followed by {@link #endChannelIteration(PortInstance)}. + * + * @param port The port. + */ + public void startChannelIteration(PortInstance port) { + if (port.isMultiport) { + var channel = CUtil.channelIndexName(port); + pr("// Port " + port.getFullName() + " is a multiport. Iterate over its channels."); + pr( + "for (int " + + channel + + " = 0; " + + channel + + " < " + + port.width + + "; " + + channel + + "++) {"); + indent(); } - - /** - * Start a scoped block for the specified reactor. - * If the reactor is a bank, then this starts a for loop - * that iterates over the bank members using a standard index - * variable whose name is that returned by {@link CUtil#bankIndex(ReactorInstance)}. - * If the reactor is null or is not a bank, then this simply - * starts a scoped block by printing an opening curly brace. - * This also adds a declaration of a pointer to the self - * struct of the reactor or bank member. - * - * This block is intended to be nested, where each block is - * put within a similar block for the reactor's parent. - * This ensures that all (possibly nested) bank index variables - * are defined within the block. - * - * This must be followed by an {@link #endScopedBlock()}. - * - * @param reactor The reactor instance. - */ - public void startScopedBlock( - ReactorInstance reactor - ) { - if (reactor != null && reactor.isBank()) { - var index = CUtil.bankIndexName(reactor); - pr("// Reactor is a bank. Iterate over bank members."); - pr("for (int "+index+" = 0; "+index+" < "+reactor.width+"; "+index+"++) {"); - indent(); - } else { - startScopedBlock(); - } + } + + /** + * Start a scoped block to iterate over bank members and channels for the specified port with a + * variable with the name given by count counting the iterations. If this port is a multiport, + * then the channel index variable name is that returned by {@link + * CUtil#channelIndex(PortInstance)}. + * + *

    This block is intended to be nested, where each block is put within a similar block for the + * reactor's parent. + * + *

    This is required to be followed by a call to {@link + * #endScopedBankChannelIteration(PortInstance, String)}. + * + * @param port The port. + * @param count The variable name to use for the counter, or null to not provide a counter. + */ + public void startScopedBankChannelIteration(PortInstance port, String count) { + if (count != null) { + startScopedBlock(); + pr("int " + count + " = 0;"); } - - /** - * If the specified port is a multiport, then start a specified iteration - * over the channels of the multiport using as the channel index the - * variable name returned by {@link CUtil#channelIndex(PortInstance)}. - * If the port is not a multiport, do nothing. - * This is required to be followed by {@link #endChannelIteration(PortInstance)}. - * @param port The port. - */ - public void startChannelIteration(PortInstance port) { - if (port.isMultiport) { - var channel = CUtil.channelIndexName(port); - pr("// Port "+port.getFullName()+" is a multiport. Iterate over its channels."); - pr("for (int "+channel+" = 0; "+channel+" < "+port.width+"; "+channel+"++) {"); - indent(); - } + startScopedBlock(port.parent); + startChannelIteration(port); + } + + /** + * Start a scoped block that iterates over the specified range of port channels. + * + *

    This must be followed by a call to {@link #endScopedRangeBlock(RuntimeRange)}. + * + *

    This block should NOT be nested, where each block is put within a similar block for the + * reactor's parent. Within the created block, every use of {@link + * CUtil#reactorRef(ReactorInstance, String)} must provide the second argument, a runtime index + * variable name, that must match the runtimeIndex parameter given here. + * + * @param range The range of port channels. + * @param runtimeIndex A variable name to use to index the runtime instance of either port's + * parent or the port's parent's parent (if nested is true), or null to use the default, + * "runtime_index". + * @param bankIndex A variable name to use to index the bank of the port's parent or null to use + * the default, the string returned by {@link CUtil#bankIndexName(ReactorInstance)}. + * @param channelIndex A variable name to use to index the channel or null to use the default, the + * string returned by {@link CUtil#channelIndexName(PortInstance)}. + * @param nested If true, then the runtimeIndex variable will be set to the bank index of the + * port's parent's parent rather than the port's parent. + */ + public void startScopedRangeBlock( + RuntimeRange range, + String runtimeIndex, + String bankIndex, + String channelIndex, + boolean nested) { + + pr("// Iterate over range " + range.toString() + "."); + var ri = (runtimeIndex == null) ? "runtime_index" : runtimeIndex; + var ci = (channelIndex == null) ? CUtil.channelIndexName(range.instance) : channelIndex; + var bi = (bankIndex == null) ? CUtil.bankIndexName(range.instance.parent) : bankIndex; + var rangeMR = range.startMR(); + var sizeMR = rangeMR.getDigits().size(); + var nestedLevel = (nested) ? 2 : 1; + + startScopedBlock(); + if (range.width > 1) { + pr( + String.join( + "\n", + "int range_start[] = { " + joinObjects(rangeMR.getDigits(), ", ") + " };", + "int range_radixes[] = { " + joinObjects(rangeMR.getRadixes(), ", ") + " };", + "int permutation[] = { " + joinObjects(range.permutation(), ", ") + " };", + "mixed_radix_int_t range_mr = {", + " " + sizeMR + ",", + " range_start,", + " range_radixes,", + " permutation", + "};", + "for (int range_count = " + + range.start + + "; range_count < " + + range.start + + " + " + + range.width + + "; range_count++) {")); + indent(); + pr( + String.join( + "\n", + "int " + + ri + + " = mixed_radix_parent(&range_mr, " + + nestedLevel + + "); // Runtime index.", + "SUPPRESS_UNUSED_WARNING(" + ri + ");", + "int " + ci + " = range_mr.digits[0]; // Channel index.", + "SUPPRESS_UNUSED_WARNING(" + ci + ");", + "int " + bi + " = " + (sizeMR <= 1 ? "0" : "range_mr.digits[1]") + "; // Bank index.", + "SUPPRESS_UNUSED_WARNING(" + bi + ");")); + + } else { + var ciValue = rangeMR.getDigits().get(0); + var riValue = rangeMR.get(nestedLevel); + var biValue = (sizeMR > 1) ? rangeMR.getDigits().get(1) : 0; + pr( + String.join( + "\n", + "int " + + ri + + " = " + + riValue + + "; SUPPRESS_UNUSED_WARNING(" + + ri + + "); // Runtime index.", + "int " + + ci + + " = " + + ciValue + + "; SUPPRESS_UNUSED_WARNING(" + + ci + + "); // Channel index.", + "int " + + bi + + " = " + + biValue + + "; SUPPRESS_UNUSED_WARNING(" + + bi + + "); // Bank index.", + "int range_count = 0; SUPPRESS_UNUSED_WARNING(range_count);")); } - - /** - * Start a scoped block to iterate over bank members and - * channels for the specified port with a variable with - * the name given by count counting the iterations. - * If this port is a multiport, then the channel index - * variable name is that returned by {@link CUtil#channelIndex(PortInstance)}. - * - * This block is intended to be nested, where each block is - * put within a similar block for the reactor's parent. - * - * This is required to be followed by a call to - * {@link #endScopedBankChannelIteration(PortInstance, String)}. - * @param port The port. - * @param count The variable name to use for the counter, or - * null to not provide a counter. - */ - public void startScopedBankChannelIteration(PortInstance port, - String count) { - if (count != null) { - startScopedBlock(); - pr("int "+count+" = 0;"); - } - startScopedBlock(port.parent); - startChannelIteration(port); + } + + /** + * Start a scoped block that iterates over the specified pair of ranges. The destination range can + * be wider than the source range, in which case the source range is reused until the destination + * range is filled. The following integer variables will be defined within the scoped block: + * + *

      + *
    • src_channel: The channel index for the source. + *
    • src_bank: The bank index of the source port's parent. + *
    • src_runtime: The runtime index of the source port's parent or the parent's parent + * (if the source is an input). + *
    + * + *
      + *
    • dst_channel: The channel index for the destination. + *
    • dst_bank: The bank index of the destination port's parent. + *
    • dst_runtime: The runtime index of the destination port's parent or the parent's + * parent (if destination is an output). + *
    + * + *

    For convenience, the above variable names are defined in the private class variables sc, sb, + * sr, and dc, db, dr. + * + *

    This block should NOT be nested, where each block is put within a similar block for the + * reactor's parent. Within the created block, every use of {@link + * CUtil#reactorRef(ReactorInstance, String)} and related functions must provide the above + * variable names. + * + *

    This must be followed by a call to {@link #endScopedRangeBlock(SendRange, RuntimeRange)}.x + * + * @param srcRange The send range. + * @param dstRange The destination range. + */ + public void startScopedRangeBlock(SendRange srcRange, RuntimeRange dstRange) { + var srcRangeMR = srcRange.startMR(); + var srcSizeMR = srcRangeMR.getRadixes().size(); + var srcNestedLevel = (srcRange.instance.isInput()) ? 2 : 1; + var dstNested = dstRange.instance.isOutput(); + + pr("// Iterate over ranges " + srcRange + " and " + dstRange + "."); + startScopedBlock(); + if (srcRange.width > 1) { + pr( + String.join( + "\n", + "int src_start[] = { " + joinObjects(srcRangeMR.getDigits(), ", ") + " };", + "int src_value[] = { " + + joinObjects(srcRangeMR.getDigits(), ", ") + + " }; // Will be incremented.", + "int src_radixes[] = { " + joinObjects(srcRangeMR.getRadixes(), ", ") + " };", + "int src_permutation[] = { " + joinObjects(srcRange.permutation(), ", ") + " };", + "mixed_radix_int_t src_range_mr = {", + " " + srcSizeMR + ",", + " src_value,", + " src_radixes,", + " src_permutation", + "};")); + } else { + var ciValue = srcRangeMR.getDigits().get(0); + var biValue = (srcSizeMR > 1) ? srcRangeMR.getDigits().get(1) : 0; + var riValue = srcRangeMR.get(srcNestedLevel); + pr( + String.join( + "\n", + "int " + sr + " = " + riValue + "; // Runtime index.", + "SUPPRESS_UNUSED_WARNING(" + sr + ");", + "int " + sc + " = " + ciValue + "; // Channel index.", + "SUPPRESS_UNUSED_WARNING(" + sc + ");", + "int " + sb + " = " + biValue + "; // Bank index.", + "SUPPRESS_UNUSED_WARNING(" + sb + ");")); } - /** - * Start a scoped block that iterates over the specified range of port channels. - * - * This must be followed by a call to - * {@link #endScopedRangeBlock(RuntimeRange)}. - * - * This block should NOT be nested, where each block is - * put within a similar block for the reactor's parent. - * Within the created block, every use of - * {@link CUtil#reactorRef(ReactorInstance, String)} - * must provide the second argument, a runtime index variable name, - * that must match the runtimeIndex parameter given here. - * - * @param range The range of port channels. - * @param runtimeIndex A variable name to use to index the runtime instance of - * either port's parent or the port's parent's parent (if nested is true), or - * null to use the default, "runtime_index". - * @param bankIndex A variable name to use to index the bank of the port's parent or null to use the - * default, the string returned by {@link CUtil#bankIndexName(ReactorInstance)}. - * @param channelIndex A variable name to use to index the channel or null to - * use the default, the string returned by {@link CUtil#channelIndexName(PortInstance)}. - * @param nested If true, then the runtimeIndex variable will be set - * to the bank index of the port's parent's parent rather than the - * port's parent. - */ - public void startScopedRangeBlock( - RuntimeRange range, - String runtimeIndex, - String bankIndex, - String channelIndex, - boolean nested - ) { - - pr("// Iterate over range "+range.toString()+"."); - var ri = (runtimeIndex == null)? "runtime_index" : runtimeIndex; - var ci = (channelIndex == null)? CUtil.channelIndexName(range.instance) : channelIndex; - var bi = (bankIndex == null)? CUtil.bankIndexName(range.instance.parent) : bankIndex; - var rangeMR = range.startMR(); - var sizeMR = rangeMR.getDigits().size(); - var nestedLevel = (nested) ? 2 : 1; - - startScopedBlock(); - if (range.width > 1) { - pr(String.join("\n", - "int range_start[] = { "+joinObjects(rangeMR.getDigits(), ", ")+" };", - "int range_radixes[] = { "+joinObjects(rangeMR.getRadixes(), ", ")+" };", - "int permutation[] = { "+joinObjects(range.permutation(), ", ")+" };", - "mixed_radix_int_t range_mr = {", - " "+sizeMR+",", - " range_start,", - " range_radixes,", - " permutation", - "};", - "for (int range_count = "+range.start+"; range_count < "+range.start+" + "+range.width+"; range_count++) {" - )); - indent(); - pr(String.join("\n", - "int "+ri+" = mixed_radix_parent(&range_mr, "+nestedLevel+"); // Runtime index.", - "SUPPRESS_UNUSED_WARNING("+ri+");", - "int "+ci+" = range_mr.digits[0]; // Channel index.", - "SUPPRESS_UNUSED_WARNING("+ci+");", - "int "+bi+" = "+(sizeMR <= 1 ? "0" : "range_mr.digits[1]")+"; // Bank index.", - "SUPPRESS_UNUSED_WARNING("+bi+");" - )); - - } else { - var ciValue = rangeMR.getDigits().get(0); - var riValue = rangeMR.get(nestedLevel); - var biValue = (sizeMR > 1)? rangeMR.getDigits().get(1) : 0; - pr(String.join("\n", - "int "+ri+" = "+riValue+"; SUPPRESS_UNUSED_WARNING("+ri+"); // Runtime index.", - "int "+ci+" = "+ciValue+"; SUPPRESS_UNUSED_WARNING("+ci+"); // Channel index.", - "int "+bi+" = "+biValue+"; SUPPRESS_UNUSED_WARNING("+bi+"); // Bank index.", - "int range_count = 0; SUPPRESS_UNUSED_WARNING(range_count);" - )); - } + startScopedRangeBlock(dstRange, dr, db, dc, dstNested); + + if (srcRange.width > 1) { + pr( + String.join( + "\n", + "int " + + sr + + " = mixed_radix_parent(&src_range_mr, " + + srcNestedLevel + + "); // Runtime index.", + "SUPPRESS_UNUSED_WARNING(" + sr + ");", + "int " + sc + " = src_range_mr.digits[0]; // Channel index.", + "SUPPRESS_UNUSED_WARNING(" + sc + ");", + "int " + + sb + + " = " + + (srcSizeMR <= 1 ? "0" : "src_range_mr.digits[1]") + + "; // Bank index.", + "SUPPRESS_UNUSED_WARNING(" + sb + ");")); } - - /** - * Start a scoped block that iterates over the specified pair of ranges. - * The destination range can be wider than the source range, in which case the - * source range is reused until the destination range is filled. - * The following integer variables will be defined within the scoped block: - * - *

      - *
    • src_channel: The channel index for the source.
      • - *
    • src_bank: The bank index of the source port's parent.
      • - *
    • src_runtime: The runtime index of the source port's parent or - * the parent's parent (if the source is an input).
      • - *
    - *
      - *
    • dst_channel: The channel index for the destination.
      • - *
    • dst_bank: The bank index of the destination port's parent.
      • - *
    • dst_runtime: The runtime index of the destination port's parent or - * the parent's parent (if destination is an output).
      • - *
    - * - *

    For convenience, the above variable names are defined in the private - * class variables sc, sb, sr, and dc, db, dr.

    - * - *

    This block should NOT be nested, where each block is - * put within a similar block for the reactor's parent. - * Within the created block, every use of - * {@link CUtil#reactorRef(ReactorInstance, String)} - * and related functions must provide the above variable names.

    - * - *

    This must be followed by a call to - * {@link #endScopedRangeBlock(SendRange, RuntimeRange)}.

    x - * - * @param srcRange The send range. - * @param dstRange The destination range. - */ - public void startScopedRangeBlock( - SendRange srcRange, - RuntimeRange dstRange - ) { - var srcRangeMR = srcRange.startMR(); - var srcSizeMR = srcRangeMR.getRadixes().size(); - var srcNestedLevel = (srcRange.instance.isInput()) ? 2 : 1; - var dstNested = dstRange.instance.isOutput(); - - pr("// Iterate over ranges "+srcRange+" and "+dstRange+"."); - startScopedBlock(); - if (srcRange.width > 1) { - pr(String.join("\n", - "int src_start[] = { "+joinObjects(srcRangeMR.getDigits(), ", ")+" };", - "int src_value[] = { "+joinObjects(srcRangeMR.getDigits(), ", ")+" }; // Will be incremented.", - "int src_radixes[] = { "+joinObjects(srcRangeMR.getRadixes(), ", ")+" };", - "int src_permutation[] = { "+joinObjects(srcRange.permutation(), ", ")+" };", - "mixed_radix_int_t src_range_mr = {", - " "+srcSizeMR+",", - " src_value,", - " src_radixes,", - " src_permutation", - "};" - )); - } else { - var ciValue = srcRangeMR.getDigits().get(0); - var biValue = (srcSizeMR > 1)? srcRangeMR.getDigits().get(1) : 0; - var riValue = srcRangeMR.get(srcNestedLevel); - pr(String.join("\n", - "int "+sr+" = "+riValue+"; // Runtime index.", - "SUPPRESS_UNUSED_WARNING("+sr+");", - "int "+sc+" = "+ciValue+"; // Channel index.", - "SUPPRESS_UNUSED_WARNING("+sc+");", - "int "+sb+" = "+biValue+"; // Bank index.", - "SUPPRESS_UNUSED_WARNING("+sb+");" - )); - } - - startScopedRangeBlock(dstRange, dr, db, dc, dstNested); - - if (srcRange.width > 1) { - pr(String.join("\n", - "int "+sr+" = mixed_radix_parent(&src_range_mr, "+srcNestedLevel+"); // Runtime index.", - "SUPPRESS_UNUSED_WARNING("+sr+");", - "int "+sc+" = src_range_mr.digits[0]; // Channel index.", - "SUPPRESS_UNUSED_WARNING("+sc+");", - "int "+sb+" = "+(srcSizeMR <= 1 ? "0" : "src_range_mr.digits[1]")+"; // Bank index.", - "SUPPRESS_UNUSED_WARNING("+sb+");" - )); - } + } + + public void endScopedBlock() { + unindent(); + pr("}"); + } + + /** + * If the specified port is a multiport, then start a specified iteration over the channels of the + * multiport using as the channel index the variable name returned by {@link + * CUtil#channelIndex(PortInstance)}. If the port is not a multiport, do nothing. + * + * @param port The port. + */ + public void endChannelIteration(PortInstance port) { + if (port.isMultiport) { + unindent(); + pr("}"); } - - public void endScopedBlock() { - unindent(); - pr("}"); + } + + /** + * End a scoped block to iterate over bank members and channels for the specified port with a + * variable with the name given by count counting the iterations. + * + * @param port The port. + * @param count The variable name to use for the counter, or null to not provide a counter. + */ + public void endScopedBankChannelIteration(PortInstance port, String count) { + if (count != null) { + pr(count + "++;"); } - - /** - * If the specified port is a multiport, then start a specified iteration - * over the channels of the multiport using as the channel index the - * variable name returned by {@link CUtil#channelIndex(PortInstance)}. - * If the port is not a multiport, do nothing. - * @param port The port. - */ - public void endChannelIteration(PortInstance port) { - if (port.isMultiport) { - unindent(); - pr("}"); - } + endChannelIteration(port); + endScopedBlock(); + if (count != null) { + endScopedBlock(); } - - /** - * End a scoped block to iterate over bank members and - * channels for the specified port with a variable with - * the name given by count counting the iterations. - * @param port The port. - * @param count The variable name to use for the counter, or - * null to not provide a counter. - */ - public void endScopedBankChannelIteration( - PortInstance port, String count - ) { - if (count != null) { - pr(count + "++;"); - } - endChannelIteration(port); - endScopedBlock(); - if (count != null) { - endScopedBlock(); - } + } + + /** + * End a scoped block for the specified range. + * + * @param range The send range. + */ + public void endScopedRangeBlock(RuntimeRange range) { + if (range.width > 1) { + pr("mixed_radix_incr(&range_mr);"); + endScopedBlock(); // Terminate for loop. } - - /** - * End a scoped block for the specified range. - * @param range The send range. - */ - public void endScopedRangeBlock( - RuntimeRange range - ) { - if (range.width > 1) { - pr("mixed_radix_incr(&range_mr);"); - endScopedBlock(); // Terminate for loop. - } - endScopedBlock(); - } - - /** - * End a scoped block that iterates over the specified pair of ranges. - * - * @param srcRange The send range. - * @param dstRange The destination range. - */ - public void endScopedRangeBlock( - SendRange srcRange, - RuntimeRange dstRange - ) { - if (srcRange.width > 1) { - pr(String.join("\n", - "mixed_radix_incr(&src_range_mr);", - "if (mixed_radix_to_int(&src_range_mr) >= "+srcRange.start+" + "+srcRange.width+") {", - " // Start over with the source.", - " for (int i = 0; i < src_range_mr.size; i++) {", - " src_range_mr.digits[i] = src_start[i];", - " }", - "}" - )); - } - if (dstRange.width > 1) { - pr("mixed_radix_incr(&range_mr);"); - endScopedBlock(); // Terminate for loop. - } - // Terminate unconditional scope block in startScopedRangeBlock calls. - endScopedBlock(); - endScopedBlock(); + endScopedBlock(); + } + + /** + * End a scoped block that iterates over the specified pair of ranges. + * + * @param srcRange The send range. + * @param dstRange The destination range. + */ + public void endScopedRangeBlock(SendRange srcRange, RuntimeRange dstRange) { + if (srcRange.width > 1) { + pr( + String.join( + "\n", + "mixed_radix_incr(&src_range_mr);", + "if (mixed_radix_to_int(&src_range_mr) >= " + + srcRange.start + + " + " + + srcRange.width + + ") {", + " // Start over with the source.", + " for (int i = 0; i < src_range_mr.size; i++) {", + " src_range_mr.digits[i] = src_start[i];", + " }", + "}")); } - - /** - * Return the code as a string. - */ - @Override - public String toString() { - return code.toString(); - } - - /** - * Reduce the indentation by one level for generated code/ - */ - public void unindent() { - indentation = indentation.substring(0, Math.max(0, indentation.length() - 4)); + if (dstRange.width > 1) { + pr("mixed_radix_incr(&range_mr);"); + endScopedBlock(); // Terminate for loop. } - - /** - * Write the text to a file. - * @param path The file to write the code to. - */ - public CodeMap writeToFile(String path) throws IOException { - CodeMap ret = CodeMap.fromGeneratedCode(code.toString()); - FileUtil.writeToFile(ret.getGeneratedCode(), Path.of(path), true); - return ret; - } - - //////////////////////////////////////////// - //// Private fields. - - /** Place to store the code. */ - private final StringBuilder code = new StringBuilder(); - - /** Current indentation. */ - private String indentation = ""; + // Terminate unconditional scope block in startScopedRangeBlock calls. + endScopedBlock(); + endScopedBlock(); + } + + /** Return the code as a string. */ + @Override + public String toString() { + return code.toString(); + } + + /** Reduce the indentation by one level for generated code/ */ + public void unindent() { + indentation = indentation.substring(0, Math.max(0, indentation.length() - 4)); + } + + /** + * Write the text to a file. + * + * @param path The file to write the code to. + */ + public CodeMap writeToFile(String path) throws IOException { + CodeMap ret = CodeMap.fromGeneratedCode(code.toString()); + FileUtil.writeToFile(ret.getGeneratedCode(), Path.of(path), true); + return ret; + } + + //////////////////////////////////////////// + //// Private fields. + + /** Place to store the code. */ + private final StringBuilder code = new StringBuilder(); + + /** Current indentation. */ + private String indentation = ""; } diff --git a/org.lflang/src/org/lflang/generator/CodeMap.java b/org.lflang/src/org/lflang/generator/CodeMap.java index d00fe9bc9a..9d196c7daa 100644 --- a/org.lflang/src/org/lflang/generator/CodeMap.java +++ b/org.lflang/src/org/lflang/generator/CodeMap.java @@ -1,348 +1,320 @@ package org.lflang.generator; import java.nio.file.Path; +import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.NavigableMap; import java.util.Set; import java.util.TreeMap; -import java.util.HashMap; import java.util.regex.Matcher; import java.util.regex.Pattern; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.nodemodel.INode; import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.eclipse.xtext.util.LineAndColumn; - import org.lflang.lf.ParameterReference; -import org.lflang.lf.impl.ParameterReferenceImpl; /** - * Encapsulates data about the correspondence between - * ranges of generated code and ranges of a Lingua Franca - * file. + * Encapsulates data about the correspondence between ranges of generated code and ranges of a + * Lingua Franca file. */ public class CodeMap { - public static class Correspondence { - // This pattern has the markers "/* */", which some languages use as line comments. This does not - // represent any serious effort to embed the string representation of this object in generated code - // without introducing a syntax error. Instead, it is done simply because it is easy. - private static final Pattern PATTERN = Pattern.compile(String.format( - "/\\*Correspondence: (?%s) \\-> (?%s) \\(verbatim=(?true|false); src=(?%s)\\)\\*/", - Position.removeNamedCapturingGroups(Range.PATTERN), - Position.removeNamedCapturingGroups(Range.PATTERN), - ".*?" - )); - - private final Path path; - private final Range lfRange; - private final Range generatedRange; - private final boolean verbatim; - - /** - * Instantiates a Correspondence between - * {@code lfRange} at {@code path} and - * {@code generatedRange} in the generated file - * associated with this Correspondence. - * @param path a path to an LF source file - * @param lfRange a range in the given LF file - * @param generatedRange the range of generated code - * associated with - * {@code lfRange} - */ - private Correspondence(Path path, Range lfRange, Range generatedRange, boolean verbatim) { - this.path = path; - this.lfRange = lfRange; - this.generatedRange = generatedRange; - this.verbatim = verbatim; - } - - /** - * Returns a path to the LF source file described by - * this Correspondence. - * @return a path to the LF source file described by - * this Correspondence - */ - public Path getPath() { - return path; - } - - /** - * Returns a range in an LF source file. - * @return a range in an LF source file - */ - public Range getLfRange() { - return lfRange; - } + public static class Correspondence { + // This pattern has the markers "/* */", which some languages use as line comments. This does + // not + // represent any serious effort to embed the string representation of this object in generated + // code + // without introducing a syntax error. Instead, it is done simply because it is easy. + private static final Pattern PATTERN = + Pattern.compile( + String.format( + "/\\*Correspondence: (?%s) \\-> (?%s)" + + " \\(verbatim=(?true|false); src=(?%s)\\)\\*/", + Position.removeNamedCapturingGroups(Range.PATTERN), + Position.removeNamedCapturingGroups(Range.PATTERN), + ".*?")); - /** - * Returns a range in a generated file that - * corresponds to a range in an LF file. - * @return a range in a generated file that - * corresponds to a range in an LF file - */ - public Range getGeneratedRange() { - return generatedRange; - } + private final Path path; + private final Range lfRange; + private final Range generatedRange; + private final boolean verbatim; - @Override - public String toString() { - return String.format( - "/*Correspondence: %s -> %s (verbatim=%b; src=%s)*/", - lfRange.toString(), generatedRange.toString(), verbatim, path.toString() - ); - } - - /** - * Returns the Correspondence represented by - * {@code s}. - * @param s a String that represents a - * Correspondence, formatted like the - * output of Correspondence::toString - * @param relativeTo the offset relative to which - * the offsets given are given - * @return the Correspondence represented by - * {@code s} - */ - public static Correspondence fromString(String s, Position relativeTo) { - Matcher matcher = PATTERN.matcher(s); - if (matcher.matches()) { - Range lfRange = Range.fromString(matcher.group("lfRange")); - Range generatedRange = Range.fromString(matcher.group("generatedRange"), relativeTo); - return new Correspondence( - Path.of(matcher.group("path")), - lfRange, - generatedRange, - Boolean.parseBoolean(matcher.group("verbatim")) - ); - } - throw new IllegalArgumentException(String.format("Could not parse %s as a Correspondence.", s)); - } - - /** - * Returns {@code representation}, tagged with - * a Correspondence to the source code associated - * with {@code astNode}. - * @param astNode an arbitrary AST node - * @param representation the code generated from - * that AST node - * @param verbatim whether {@code representation} - * is copied verbatim from the - * part of the source code - * associated with {@code astNode} - * @return {@code representation}, tagged with - * a Correspondence to the source code associated - * with {@code astNode} - */ - public static String tag(EObject astNode, String representation, boolean verbatim) { - final INode node = NodeModelUtils.getNode(astNode); - // If the EObject originates from an AST transformation, then it does not correspond directly - // to any LF code, and it need not be tagged at all. - if (node == null) return representation; - final LineAndColumn oneBasedLfLineAndColumn = NodeModelUtils.getLineAndColumn(node, node.getTotalOffset()); - Position lfStart = Position.fromOneBased( - oneBasedLfLineAndColumn.getLine(), oneBasedLfLineAndColumn.getColumn() - ); - final URI uri = bestEffortGetEResource(astNode).getURI(); - if (uri == null) { - // no EResource, no correspondence can be found - return representation; - } - final Path lfPath = Path.of(uri.isFile() ? uri.toFileString() : uri.path()); - if (verbatim) lfStart = lfStart.plus(node.getText().substring(0, indexOf(node.getText(), representation))); - return new Correspondence( - lfPath, - new Range(lfStart, lfStart.plus(verbatim ? representation : node.getText())), - new Range(Position.ORIGIN, Position.displacementOf(representation)), - verbatim - ) + representation; - } - - /** - * Return the {@code eResource} associated with the given AST node. - * This is a dangerous operation which can cause an unrecoverable error. - */ - private static Resource bestEffortGetEResource(EObject astNode) { - if (astNode instanceof ParameterReference pri) { - return pri.getParameter().eResource(); - } - return astNode.eResource(); - } - - /** - * Make a best-effort attempt to find the index of - * a near substring whose first line is expected to - * be an exact substring of {@code s}. Return 0 - * upon failure. - * @param s an arbitrary string - * @param imperfectSubstring an approximate - * substring of {@code s} - * @return the index of {@code imperfectSubstring} - * within {@code s} - */ - private static int indexOf(String s, String imperfectSubstring) { - String firstLine = imperfectSubstring.lines().findFirst().orElse(""); - return Math.max(0, s.indexOf(firstLine)); - } + /** + * Instantiates a Correspondence between {@code lfRange} at {@code path} and {@code + * generatedRange} in the generated file associated with this Correspondence. + * + * @param path a path to an LF source file + * @param lfRange a range in the given LF file + * @param generatedRange the range of generated code associated with {@code lfRange} + */ + private Correspondence(Path path, Range lfRange, Range generatedRange, boolean verbatim) { + this.path = path; + this.lfRange = lfRange; + this.generatedRange = generatedRange; + this.verbatim = verbatim; } /** - * The content of the generated file represented by - * this. + * Returns a path to the LF source file described by this Correspondence. + * + * @return a path to the LF source file described by this Correspondence */ - private final String generatedCode; + public Path getPath() { + return path; + } + /** - * A mapping from Lingua Franca source paths to mappings - * from ranges in the generated file represented by this - * to ranges in Lingua Franca files. + * Returns a range in an LF source file. + * + * @return a range in an LF source file */ - private final Map> map; + public Range getLfRange() { + return lfRange; + } + /** - * A mapping from Lingua Franca source paths to mappings - * from ranges in the generated file represented by this - * to whether those ranges are copied verbatim from the - * source. + * Returns a range in a generated file that corresponds to a range in an LF file. + * + * @return a range in a generated file that corresponds to a range in an LF file */ - private final Map> isVerbatimByLfSourceByRange; + public Range getGeneratedRange() { + return generatedRange; + } - /* ------------------------- PUBLIC METHODS -------------------------- */ + @Override + public String toString() { + return String.format( + "/*Correspondence: %s -> %s (verbatim=%b; src=%s)*/", + lfRange.toString(), generatedRange.toString(), verbatim, path.toString()); + } /** - * Instantiates a {@code CodeMap} from - * {@code internalGeneratedCode}. - * {@code internalGeneratedCode} may be invalid - * code that is different from the final generated code - * because it should contain deserializable - * representations of {@code Correspondences}. - * @param internalGeneratedCode code from a code - * generator that contains - * serialized - * Correspondences - * @return a CodeMap documenting the provided code + * Returns the Correspondence represented by {@code s}. + * + * @param s a String that represents a Correspondence, formatted like the output of + * Correspondence::toString + * @param relativeTo the offset relative to which the offsets given are given + * @return the Correspondence represented by {@code s} */ - public static CodeMap fromGeneratedCode(String internalGeneratedCode) { - Map> map = new HashMap<>(); - Map> isVerbatimByLfSourceByRange = new HashMap<>(); - StringBuilder generatedCode = new StringBuilder(); - Iterator it = internalGeneratedCode.lines().iterator(); - int zeroBasedLine = 0; - while (it.hasNext()) { - generatedCode.append(processGeneratedLine(it.next(), zeroBasedLine++, map, isVerbatimByLfSourceByRange)).append('\n'); - } - return new CodeMap(generatedCode.toString(), map, isVerbatimByLfSourceByRange); + public static Correspondence fromString(String s, Position relativeTo) { + Matcher matcher = PATTERN.matcher(s); + if (matcher.matches()) { + Range lfRange = Range.fromString(matcher.group("lfRange")); + Range generatedRange = Range.fromString(matcher.group("generatedRange"), relativeTo); + return new Correspondence( + Path.of(matcher.group("path")), + lfRange, + generatedRange, + Boolean.parseBoolean(matcher.group("verbatim"))); + } + throw new IllegalArgumentException( + String.format("Could not parse %s as a Correspondence.", s)); } /** - * Returns the generated code (without Correspondences). - * @return the generated code (without Correspondences) + * Returns {@code representation}, tagged with a Correspondence to the source code associated + * with {@code astNode}. + * + * @param astNode an arbitrary AST node + * @param representation the code generated from that AST node + * @param verbatim whether {@code representation} is copied verbatim from the part of the source + * code associated with {@code astNode} + * @return {@code representation}, tagged with a Correspondence to the source code associated + * with {@code astNode} */ - public String getGeneratedCode() { - return generatedCode; + public static String tag(EObject astNode, String representation, boolean verbatim) { + final INode node = NodeModelUtils.getNode(astNode); + // If the EObject originates from an AST transformation, then it does not correspond directly + // to any LF code, and it need not be tagged at all. + if (node == null) return representation; + final LineAndColumn oneBasedLfLineAndColumn = + NodeModelUtils.getLineAndColumn(node, node.getTotalOffset()); + Position lfStart = + Position.fromOneBased( + oneBasedLfLineAndColumn.getLine(), oneBasedLfLineAndColumn.getColumn()); + final URI uri = bestEffortGetEResource(astNode).getURI(); + if (uri == null) { + // no EResource, no correspondence can be found + return representation; + } + final Path lfPath = Path.of(uri.isFile() ? uri.toFileString() : uri.path()); + if (verbatim) + lfStart = + lfStart.plus(node.getText().substring(0, indexOf(node.getText(), representation))); + return new Correspondence( + lfPath, + new Range(lfStart, lfStart.plus(verbatim ? representation : node.getText())), + new Range(Position.ORIGIN, Position.displacementOf(representation)), + verbatim) + + representation; } /** - * Returns the set of all paths to Lingua Franca files - * that are known to contain code that corresponds to - * code in the generated file represented by this. + * Return the {@code eResource} associated with the given AST node. This is a dangerous + * operation which can cause an unrecoverable error. */ - public Set lfSourcePaths() { - return map.keySet(); + private static Resource bestEffortGetEResource(EObject astNode) { + if (astNode instanceof ParameterReference pri) { + return pri.getParameter().eResource(); + } + return astNode.eResource(); } /** - * Returns the position in {@code lfFile} - * corresponding to {@code generatedFilePosition} - * if such a position is known, or the zero Position - * otherwise. - * @param lfFile the path to an arbitrary Lingua Franca - * source file - * @param generatedFilePosition a position in a - * generated file - * @return the position in {@code lfFile} - * corresponding to {@code generatedFilePosition} + * Make a best-effort attempt to find the index of a near substring whose first line is expected + * to be an exact substring of {@code s}. Return 0 upon failure. + * + * @param s an arbitrary string + * @param imperfectSubstring an approximate substring of {@code s} + * @return the index of {@code imperfectSubstring} within {@code s} */ - public Position adjusted(Path lfFile, Position generatedFilePosition) { - NavigableMap mapOfInterest = map.get(lfFile); - Map isVerbatimByRange = isVerbatimByLfSourceByRange.get(lfFile); - Map.Entry nearestEntry = mapOfInterest.floorEntry(Range.degenerateRange(generatedFilePosition)); - if (nearestEntry == null) return Position.ORIGIN; - if (!isVerbatimByRange.get(nearestEntry.getKey())) { - return nearestEntry.getValue().getStartInclusive(); - } - if (nearestEntry.getKey().contains(generatedFilePosition)) { - return nearestEntry.getValue().getStartInclusive().plus( - generatedFilePosition.minus(nearestEntry.getKey().getStartInclusive()) - ); - } - return Position.ORIGIN; + private static int indexOf(String s, String imperfectSubstring) { + String firstLine = imperfectSubstring.lines().findFirst().orElse(""); + return Math.max(0, s.indexOf(firstLine)); } + } - /** - * Returns the range in {@code lfFile} - * corresponding to {@code generatedFileRange} - * if such a range is known, or a degenerate Range - * otherwise. - * @param lfFile the path to an arbitrary Lingua Franca - * source file - * @param generatedFileRange a position in a - * generated file - * @return the range in {@code lfFile} - * corresponding to {@code generatedFileRange} - */ - public Range adjusted(Path lfFile, Range generatedFileRange) { - final Position start = adjusted(lfFile, generatedFileRange.getStartInclusive()); - final Position end = adjusted(lfFile, generatedFileRange.getEndExclusive()); - return start.compareTo(end) <= 0 ? new Range(start, end) : new Range(start, start); + /** The content of the generated file represented by this. */ + private final String generatedCode; + /** + * A mapping from Lingua Franca source paths to mappings from ranges in the generated file + * represented by this to ranges in Lingua Franca files. + */ + private final Map> map; + /** + * A mapping from Lingua Franca source paths to mappings from ranges in the generated file + * represented by this to whether those ranges are copied verbatim from the source. + */ + private final Map> isVerbatimByLfSourceByRange; + + /* ------------------------- PUBLIC METHODS -------------------------- */ + + /** + * Instantiates a {@code CodeMap} from {@code internalGeneratedCode}. {@code + * internalGeneratedCode} may be invalid code that is different from the final generated code + * because it should contain deserializable representations of {@code Correspondences}. + * + * @param internalGeneratedCode code from a code generator that contains serialized + * Correspondences + * @return a CodeMap documenting the provided code + */ + public static CodeMap fromGeneratedCode(String internalGeneratedCode) { + Map> map = new HashMap<>(); + Map> isVerbatimByLfSourceByRange = new HashMap<>(); + StringBuilder generatedCode = new StringBuilder(); + Iterator it = internalGeneratedCode.lines().iterator(); + int zeroBasedLine = 0; + while (it.hasNext()) { + generatedCode + .append( + processGeneratedLine(it.next(), zeroBasedLine++, map, isVerbatimByLfSourceByRange)) + .append('\n'); } + return new CodeMap(generatedCode.toString(), map, isVerbatimByLfSourceByRange); + } - /* ------------------------- PRIVATE METHODS ------------------------- */ + /** + * Returns the generated code (without Correspondences). + * + * @return the generated code (without Correspondences) + */ + public String getGeneratedCode() { + return generatedCode; + } - private CodeMap( - String generatedCode, Map> map, - Map> isVerbatimByLfSourceByRange - ) { - this.generatedCode = generatedCode; - this.map = map; - this.isVerbatimByLfSourceByRange = isVerbatimByLfSourceByRange; + /** + * Returns the set of all paths to Lingua Franca files that are known to contain code that + * corresponds to code in the generated file represented by this. + */ + public Set lfSourcePaths() { + return map.keySet(); + } + + /** + * Returns the position in {@code lfFile} corresponding to {@code generatedFilePosition} if such a + * position is known, or the zero Position otherwise. + * + * @param lfFile the path to an arbitrary Lingua Franca source file + * @param generatedFilePosition a position in a generated file + * @return the position in {@code lfFile} corresponding to {@code generatedFilePosition} + */ + public Position adjusted(Path lfFile, Position generatedFilePosition) { + NavigableMap mapOfInterest = map.get(lfFile); + Map isVerbatimByRange = isVerbatimByLfSourceByRange.get(lfFile); + Map.Entry nearestEntry = + mapOfInterest.floorEntry(Range.degenerateRange(generatedFilePosition)); + if (nearestEntry == null) return Position.ORIGIN; + if (!isVerbatimByRange.get(nearestEntry.getKey())) { + return nearestEntry.getValue().getStartInclusive(); + } + if (nearestEntry.getKey().contains(generatedFilePosition)) { + return nearestEntry + .getValue() + .getStartInclusive() + .plus(generatedFilePosition.minus(nearestEntry.getKey().getStartInclusive())); } + return Position.ORIGIN; + } - /** - * Removes serialized Correspondences from {@code line} - * and updates {@code map} according to those - * Correspondences. - * @param line a line of generated code - * @param zeroBasedLineIndex the index of the given line - * @param map a map that stores Correspondences - * @return the line of generated code with all - * Correspondences removed - */ - private static String processGeneratedLine( - String line, - int zeroBasedLineIndex, - Map> map, - Map> isVerbatimByLfSourceByRange - ) { - Matcher matcher = Correspondence.PATTERN.matcher(line); - StringBuilder cleanedLine = new StringBuilder(); - int lastEnd = 0; - while (matcher.find()) { - cleanedLine.append(line, lastEnd, matcher.start()); - Correspondence c = Correspondence.fromString( - matcher.group(), - Position.fromZeroBased(zeroBasedLineIndex, cleanedLine.length()) - ); - if (!map.containsKey(c.path)) map.put(c.path, new TreeMap<>()); - map.get(c.path).put(c.generatedRange, c.lfRange); - if (!isVerbatimByLfSourceByRange.containsKey(c.path)) isVerbatimByLfSourceByRange.put(c.path, new HashMap<>()); - isVerbatimByLfSourceByRange.get(c.path).put(c.generatedRange, c.verbatim); - lastEnd = matcher.end(); - } - cleanedLine.append(line.substring(lastEnd)); - return cleanedLine.toString(); + /** + * Returns the range in {@code lfFile} corresponding to {@code generatedFileRange} if such a range + * is known, or a degenerate Range otherwise. + * + * @param lfFile the path to an arbitrary Lingua Franca source file + * @param generatedFileRange a position in a generated file + * @return the range in {@code lfFile} corresponding to {@code generatedFileRange} + */ + public Range adjusted(Path lfFile, Range generatedFileRange) { + final Position start = adjusted(lfFile, generatedFileRange.getStartInclusive()); + final Position end = adjusted(lfFile, generatedFileRange.getEndExclusive()); + return start.compareTo(end) <= 0 ? new Range(start, end) : new Range(start, start); + } + + /* ------------------------- PRIVATE METHODS ------------------------- */ + + private CodeMap( + String generatedCode, + Map> map, + Map> isVerbatimByLfSourceByRange) { + this.generatedCode = generatedCode; + this.map = map; + this.isVerbatimByLfSourceByRange = isVerbatimByLfSourceByRange; + } + + /** + * Removes serialized Correspondences from {@code line} and updates {@code map} according to those + * Correspondences. + * + * @param line a line of generated code + * @param zeroBasedLineIndex the index of the given line + * @param map a map that stores Correspondences + * @return the line of generated code with all Correspondences removed + */ + private static String processGeneratedLine( + String line, + int zeroBasedLineIndex, + Map> map, + Map> isVerbatimByLfSourceByRange) { + Matcher matcher = Correspondence.PATTERN.matcher(line); + StringBuilder cleanedLine = new StringBuilder(); + int lastEnd = 0; + while (matcher.find()) { + cleanedLine.append(line, lastEnd, matcher.start()); + Correspondence c = + Correspondence.fromString( + matcher.group(), Position.fromZeroBased(zeroBasedLineIndex, cleanedLine.length())); + if (!map.containsKey(c.path)) map.put(c.path, new TreeMap<>()); + map.get(c.path).put(c.generatedRange, c.lfRange); + if (!isVerbatimByLfSourceByRange.containsKey(c.path)) + isVerbatimByLfSourceByRange.put(c.path, new HashMap<>()); + isVerbatimByLfSourceByRange.get(c.path).put(c.generatedRange, c.verbatim); + lastEnd = matcher.end(); } + cleanedLine.append(line.substring(lastEnd)); + return cleanedLine.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/DeadlineInstance.java b/org.lflang/src/org/lflang/generator/DeadlineInstance.java index 208c116791..e73f6b8f9b 100644 --- a/org.lflang/src/org/lflang/generator/DeadlineInstance.java +++ b/org.lflang/src/org/lflang/generator/DeadlineInstance.java @@ -1,29 +1,29 @@ /** A data structure for a deadline instance. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; @@ -31,41 +31,37 @@ import org.lflang.lf.Deadline; /** - * Instance of a deadline. Upon creation the actual delay is converted into - * a proper time value. If a parameter is referenced, it is looked up in the - * given (grand)parent reactor instance. - * + * Instance of a deadline. Upon creation the actual delay is converted into a proper time value. If + * a parameter is referenced, it is looked up in the given (grand)parent reactor instance. + * * @author Marten Lohstroh * @author Edward A. Lee */ public class DeadlineInstance { - - /** - * Create a new deadline instance associated with the given reaction - * instance. - */ - public DeadlineInstance(Deadline definition, ReactionInstance reaction) { - if (definition.getDelay() != null) { - this.maxDelay = reaction.parent.getTimeValue(definition.getDelay()); - } else { - this.maxDelay = TimeValue.ZERO; - } + + /** Create a new deadline instance associated with the given reaction instance. */ + public DeadlineInstance(Deadline definition, ReactionInstance reaction) { + if (definition.getDelay() != null) { + this.maxDelay = reaction.parent.getTimeValue(definition.getDelay()); + } else { + this.maxDelay = TimeValue.ZERO; } + } - ////////////////////////////////////////////////////// - //// Public fields. + ////////////////////////////////////////////////////// + //// Public fields. - /** - * The delay D associated with this deadline. If physical time T < logical - * time t + D, the deadline is met, otherwise, it is violated. - */ - public final TimeValue maxDelay; + /** + * The delay D associated with this deadline. If physical time T < logical time t + D, the + * deadline is met, otherwise, it is violated. + */ + public final TimeValue maxDelay; - ////////////////////////////////////////////////////// - //// Public methods. - - @Override - public String toString() { - return "DeadlineInstance " + maxDelay.toString(); - } + ////////////////////////////////////////////////////// + //// Public methods. + + @Override + public String toString() { + return "DeadlineInstance " + maxDelay.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/DelayBodyGenerator.java b/org.lflang/src/org/lflang/generator/DelayBodyGenerator.java index 39742a3488..240eba7bc1 100644 --- a/org.lflang/src/org/lflang/generator/DelayBodyGenerator.java +++ b/org.lflang/src/org/lflang/generator/DelayBodyGenerator.java @@ -6,54 +6,47 @@ public interface DelayBodyGenerator { - /** - * Constant that specifies how to name generated delay reactors. - */ - String GEN_DELAY_CLASS_NAME = "_lf_GenDelay"; - - /** - * Generate code for the body of a reaction that takes an input and - * schedules an action with the value of that input. - * - * @param action the action to schedule - * @param port the port to read from - */ - String generateDelayBody(Action action, VarRef port); - - /** - * Generate code for the body of a reaction that is triggered by the - * given action and writes its value to the given port. - * - * @param action the action that triggers the reaction - * @param port the port to write to - */ - String generateForwardBody(Action action, VarRef port); - - /** - * Generate code for the generic type to be used in the class definition - * of a generated delay reactor. - */ - String generateDelayGeneric(); - - /** - * Indicates whether delay banks generated from after delays should have a variable length - * width. - *

    - * If this is true, any delay reactors that are inserted for after delays on multiport - * connections - * will have an unspecified variable length width. The code generator is then responsible for - * inferring the - * correct width of the delay bank, which is only possible if the precise connection width is - * known at compile time. - *

    - * If this is false, the width specification of the generated bank will list all the ports - * listed on the right - * side of the connection. This gives the code generator the information needed to infer the - * correct width at - * runtime. - */ - boolean generateAfterDelaysWithVariableWidth(); - - /** Used to optionally apply additional transformations to the generated reactions */ - default void finalizeReactions(Reaction delayReaction, Reaction forwardReaction) { } + /** Constant that specifies how to name generated delay reactors. */ + String GEN_DELAY_CLASS_NAME = "_lf_GenDelay"; + + /** + * Generate code for the body of a reaction that takes an input and schedules an action with the + * value of that input. + * + * @param action the action to schedule + * @param port the port to read from + */ + String generateDelayBody(Action action, VarRef port); + + /** + * Generate code for the body of a reaction that is triggered by the given action and writes its + * value to the given port. + * + * @param action the action that triggers the reaction + * @param port the port to write to + */ + String generateForwardBody(Action action, VarRef port); + + /** + * Generate code for the generic type to be used in the class definition of a generated delay + * reactor. + */ + String generateDelayGeneric(); + + /** + * Indicates whether delay banks generated from after delays should have a variable length width. + * + *

    If this is true, any delay reactors that are inserted for after delays on multiport + * connections will have an unspecified variable length width. The code generator is then + * responsible for inferring the correct width of the delay bank, which is only possible if the + * precise connection width is known at compile time. + * + *

    If this is false, the width specification of the generated bank will list all the ports + * listed on the right side of the connection. This gives the code generator the information + * needed to infer the correct width at runtime. + */ + boolean generateAfterDelaysWithVariableWidth(); + + /** Used to optionally apply additional transformations to the generated reactions */ + default void finalizeReactions(Reaction delayReaction, Reaction forwardReaction) {} } diff --git a/org.lflang/src/org/lflang/generator/DiagnosticReporting.java b/org.lflang/src/org/lflang/generator/DiagnosticReporting.java index 82d3535444..871f417a0d 100644 --- a/org.lflang/src/org/lflang/generator/DiagnosticReporting.java +++ b/org.lflang/src/org/lflang/generator/DiagnosticReporting.java @@ -2,59 +2,62 @@ import java.nio.file.Path; import java.util.Map; - import org.eclipse.lsp4j.DiagnosticSeverity; - import org.lflang.ErrorReporter; /** - * {@code DiagnosticReporting} provides utilities for - * reporting validation output. + * {@code DiagnosticReporting} provides utilities for reporting validation output. * * @author Peter Donovan */ public class DiagnosticReporting { - private DiagnosticReporting() { - // utility class - } - - /** - * A means of parsing the output of a validator. - */ - @FunctionalInterface public interface Strategy { - /** - * Parse the validation output and report any errors - * that it contains. - * @param validationOutput any validation output - * @param errorReporter any error reporter - * @param map the map from generated files to CodeMaps - */ - void report(String validationOutput, ErrorReporter errorReporter, Map map); - } - - /** - * Format the given data as a human-readable message. - * @param message An error message. - * @param path The path of the source of the message. - * @param position The position where the message originates. - * @return The given data as a human-readable message. - */ - public static String messageOf(String message, Path path, Position position) { - return String.format("%s [%s:%s:%s]", message, path.getFileName().toString(), position.getOneBasedLine(), position.getOneBasedColumn()); - } + private DiagnosticReporting() { + // utility class + } + /** A means of parsing the output of a validator. */ + @FunctionalInterface + public interface Strategy { /** - * Convert {@code severity} into a {@code DiagnosticSeverity} using a heuristic that should be - * compatible with many tools. - * @param severity The string representation of a diagnostic severity. - * @return The {@code DiagnosticSeverity} representation of {@code severity}. + * Parse the validation output and report any errors that it contains. + * + * @param validationOutput any validation output + * @param errorReporter any error reporter + * @param map the map from generated files to CodeMaps */ - public static DiagnosticSeverity severityOf(String severity) { - severity = severity.toLowerCase(); - if (severity.contains("error")) return DiagnosticSeverity.Error; - else if (severity.contains("warning")) return DiagnosticSeverity.Warning; - else if (severity.contains("hint") || severity.contains("help")) return DiagnosticSeverity.Hint; - else return DiagnosticSeverity.Information; - } + void report(String validationOutput, ErrorReporter errorReporter, Map map); + } + + /** + * Format the given data as a human-readable message. + * + * @param message An error message. + * @param path The path of the source of the message. + * @param position The position where the message originates. + * @return The given data as a human-readable message. + */ + public static String messageOf(String message, Path path, Position position) { + return String.format( + "%s [%s:%s:%s]", + message, + path.getFileName().toString(), + position.getOneBasedLine(), + position.getOneBasedColumn()); + } + + /** + * Convert {@code severity} into a {@code DiagnosticSeverity} using a heuristic that should be + * compatible with many tools. + * + * @param severity The string representation of a diagnostic severity. + * @return The {@code DiagnosticSeverity} representation of {@code severity}. + */ + public static DiagnosticSeverity severityOf(String severity) { + severity = severity.toLowerCase(); + if (severity.contains("error")) return DiagnosticSeverity.Error; + else if (severity.contains("warning")) return DiagnosticSeverity.Warning; + else if (severity.contains("hint") || severity.contains("help")) return DiagnosticSeverity.Hint; + else return DiagnosticSeverity.Information; + } } diff --git a/org.lflang/src/org/lflang/generator/DockerComposeGenerator.java b/org.lflang/src/org/lflang/generator/DockerComposeGenerator.java index 040d925614..a3e5028317 100644 --- a/org.lflang/src/org/lflang/generator/DockerComposeGenerator.java +++ b/org.lflang/src/org/lflang/generator/DockerComposeGenerator.java @@ -4,7 +4,6 @@ import java.nio.file.Path; import java.util.List; import java.util.stream.Collectors; - import org.lflang.util.FileUtil; /** @@ -15,109 +14,104 @@ */ public class DockerComposeGenerator { - /** - * Path to the docker-compose.yml file. - */ - protected final Path path; + /** Path to the docker-compose.yml file. */ + protected final Path path; - public DockerComposeGenerator(LFGeneratorContext context) { - this.path = context.getFileConfig().getSrcGenPath().resolve("docker-compose.yml"); - } + public DockerComposeGenerator(LFGeneratorContext context) { + this.path = context.getFileConfig().getSrcGenPath().resolve("docker-compose.yml"); + } - /** - * Return a string that represents the network portion of the docker-compose configuration. - * @param networkName Name of the default network - */ - protected String generateDockerNetwork(String networkName) { - return """ + /** + * Return a string that represents the network portion of the docker-compose configuration. + * + * @param networkName Name of the default network + */ + protected String generateDockerNetwork(String networkName) { + return """ networks: default: name: "%s" - """.formatted(networkName); - } + """ + .formatted(networkName); + } - /** - * Return a string that represents the services portion of the docker-compose configuration. - * @param services A list of docker data representing the services to render - */ - protected String generateDockerServices(List services) { - return """ - version: "3.9" + /** + * Return a string that represents the services portion of the docker-compose configuration. + * + * @param services A list of docker data representing the services to render + */ + protected String generateDockerServices(List services) { + return """ + version: "3.9" services: %s - """.formatted(services.stream().map( - data -> getServiceDescription(data) - ).collect(Collectors.joining("\n"))); - } + """ + .formatted( + services.stream() + .map(data -> getServiceDescription(data)) + .collect(Collectors.joining("\n"))); + } - /** - * Return the command to build and run using the docker-compose configuration. - */ - public String getUsageInstructions() { - return """ + /** Return the command to build and run using the docker-compose configuration. */ + public String getUsageInstructions() { + return """ ##################################### To build and run: pushd %s && docker compose up --build To return to the current working directory afterwards: popd ##################################### - """.formatted(path.getParent()); - } + """ + .formatted(path.getParent()); + } - /** - * Turn given docker data into a string. - */ - protected String getServiceDescription(DockerData data) { - return """ + /** Turn given docker data into a string. */ + protected String getServiceDescription(DockerData data) { + return """ %s: build: context: "%s" container_name: "%s" - """.formatted(getServiceName(data), getBuildContext(data), getContainerName(data)); - } + """ + .formatted(getServiceName(data), getBuildContext(data), getContainerName(data)); + } - /** - * Return the name of the service represented by the given data. - */ - protected String getServiceName(DockerData data) { - return "main"; - } + /** Return the name of the service represented by the given data. */ + protected String getServiceName(DockerData data) { + return "main"; + } - /** - * Return the name of the service represented by the given data. - */ - protected String getBuildContext(DockerData data) { - return "."; - } + /** Return the name of the service represented by the given data. */ + protected String getBuildContext(DockerData data) { + return "."; + } - /** - * Return the name of the container for the given data. - */ - protected String getContainerName(DockerData data) { - return data.serviceName; - } + /** Return the name of the container for the given data. */ + protected String getContainerName(DockerData data) { + return data.serviceName; + } - /** - * Write the docker-compose.yml file with a default network called "lf". - * @param services A list of all the services. - */ - public void writeDockerComposeFile(List services) throws IOException { - writeDockerComposeFile(services, "lf"); - } + /** + * Write the docker-compose.yml file with a default network called "lf". + * + * @param services A list of all the services. + */ + public void writeDockerComposeFile(List services) throws IOException { + writeDockerComposeFile(services, "lf"); + } - /** - * Write the docker-compose.yml file. - * @param services A list of all the services to include. - * @param networkName The name of the network to which docker will connect the services. - */ - public void writeDockerComposeFile( - List services, - String networkName - ) throws IOException { - var contents = String.join("\n", - this.generateDockerServices(services), - this.generateDockerNetwork(networkName)); - FileUtil.writeToFile(contents, path); - System.out.println(getUsageInstructions()); - } + /** + * Write the docker-compose.yml file. + * + * @param services A list of all the services to include. + * @param networkName The name of the network to which docker will connect the services. + */ + public void writeDockerComposeFile(List services, String networkName) + throws IOException { + var contents = + String.join( + "\n", this.generateDockerServices(services), this.generateDockerNetwork(networkName)); + FileUtil.writeToFile(contents, path); + System.out.println(getUsageInstructions()); + } } diff --git a/org.lflang/src/org/lflang/generator/DockerData.java b/org.lflang/src/org/lflang/generator/DockerData.java index a2b1927125..af29e9e1d5 100644 --- a/org.lflang/src/org/lflang/generator/DockerData.java +++ b/org.lflang/src/org/lflang/generator/DockerData.java @@ -2,7 +2,6 @@ import java.io.IOException; import java.nio.file.Path; - import org.lflang.util.FileUtil; /** @@ -11,43 +10,31 @@ * @author Marten Lohstroh */ public class DockerData { - /** - * The absolute path to the docker file. - */ - private final Path dockerFilePath; + /** The absolute path to the docker file. */ + private final Path dockerFilePath; - /** - * The content of the docker file to be generated. - */ - private final String dockerFileContent; + /** The content of the docker file to be generated. */ + private final String dockerFileContent; - /** - * The name of the service. - */ - public final String serviceName; + /** The name of the service. */ + public final String serviceName; - public DockerData( - String serviceName, - Path dockerFilePath, - String dockerFileContent - ) { + public DockerData(String serviceName, Path dockerFilePath, String dockerFileContent) { - if (!dockerFilePath.toFile().isAbsolute()) { - throw new RuntimeException("Cannot use relative docker file path in DockerData instance"); - } - this.serviceName = serviceName; - this.dockerFilePath = dockerFilePath; - this.dockerFileContent = dockerFileContent; + if (!dockerFilePath.toFile().isAbsolute()) { + throw new RuntimeException("Cannot use relative docker file path in DockerData instance"); } - - /** - * Write a docker file based on this data. - */ - public void writeDockerFile() throws IOException { - if (dockerFilePath.toFile().exists()) { - dockerFilePath.toFile().delete(); - } - FileUtil.writeToFile(dockerFileContent, dockerFilePath); - System.out.println("Dockerfile written to " + dockerFilePath); + this.serviceName = serviceName; + this.dockerFilePath = dockerFilePath; + this.dockerFileContent = dockerFileContent; + } + + /** Write a docker file based on this data. */ + public void writeDockerFile() throws IOException { + if (dockerFilePath.toFile().exists()) { + dockerFilePath.toFile().delete(); } + FileUtil.writeToFile(dockerFileContent, dockerFilePath); + System.out.println("Dockerfile written to " + dockerFilePath); + } } diff --git a/org.lflang/src/org/lflang/generator/DockerGenerator.java b/org.lflang/src/org/lflang/generator/DockerGenerator.java index 851ee6c0be..cf6044f14f 100644 --- a/org.lflang/src/org/lflang/generator/DockerGenerator.java +++ b/org.lflang/src/org/lflang/generator/DockerGenerator.java @@ -4,7 +4,6 @@ import org.lflang.generator.python.PythonDockerGenerator; import org.lflang.generator.ts.TSDockerGenerator; - /** * A class for generating docker files. * @@ -13,46 +12,43 @@ */ public abstract class DockerGenerator { - /** - * Configuration for interactions with the filesystem. - */ - protected final LFGeneratorContext context; - - /** - * The constructor for the base docker file generation class. - * @param context The context of the code generator. - */ - public DockerGenerator(LFGeneratorContext context) { - this.context = context; - - } - - /** - * Generate the contents of a Dockerfile. - */ - protected abstract String generateDockerFileContent(); - - /** - * Produce a DockerData object. - * If the returned object is to be used in a federated context, - * pass in the file configuration of the federated generator, null otherwise. - * @return docker data created based on the context in this instance - */ - public DockerData generateDockerData() { - var name = context.getFileConfig().name; - var dockerFilePath = context.getFileConfig().getSrcGenPath().resolve("Dockerfile"); - var dockerFileContent = generateDockerFileContent(); - - return new DockerData(name.replace("_", ""), dockerFilePath, dockerFileContent); - } - - public static DockerGenerator dockerGeneratorFactory(LFGeneratorContext context) { - var target = context.getTargetConfig().target; - return switch (target) { - case C, CCPP -> new CDockerGenerator(context); - case TS -> new TSDockerGenerator(context); - case Python -> new PythonDockerGenerator(context); - case CPP, Rust -> throw new IllegalArgumentException("No Docker support for " + target + " yet."); - }; - } + /** Configuration for interactions with the filesystem. */ + protected final LFGeneratorContext context; + + /** + * The constructor for the base docker file generation class. + * + * @param context The context of the code generator. + */ + public DockerGenerator(LFGeneratorContext context) { + this.context = context; + } + + /** Generate the contents of a Dockerfile. */ + protected abstract String generateDockerFileContent(); + + /** + * Produce a DockerData object. If the returned object is to be used in a federated context, pass + * in the file configuration of the federated generator, null otherwise. + * + * @return docker data created based on the context in this instance + */ + public DockerData generateDockerData() { + var name = context.getFileConfig().name; + var dockerFilePath = context.getFileConfig().getSrcGenPath().resolve("Dockerfile"); + var dockerFileContent = generateDockerFileContent(); + + return new DockerData(name.replace("_", ""), dockerFilePath, dockerFileContent); + } + + public static DockerGenerator dockerGeneratorFactory(LFGeneratorContext context) { + var target = context.getTargetConfig().target; + return switch (target) { + case C, CCPP -> new CDockerGenerator(context); + case TS -> new TSDockerGenerator(context); + case Python -> new PythonDockerGenerator(context); + case CPP, Rust -> throw new IllegalArgumentException( + "No Docker support for " + target + " yet."); + }; + } } diff --git a/org.lflang/src/org/lflang/generator/FedDockerComposeGenerator.java b/org.lflang/src/org/lflang/generator/FedDockerComposeGenerator.java index d666abba2d..18896f03a0 100644 --- a/org.lflang/src/org/lflang/generator/FedDockerComposeGenerator.java +++ b/org.lflang/src/org/lflang/generator/FedDockerComposeGenerator.java @@ -1,6 +1,5 @@ package org.lflang.generator; - import java.util.List; /** @@ -10,57 +9,55 @@ */ public class FedDockerComposeGenerator extends DockerComposeGenerator { - /** - * The host on which to run the rti. - */ - private String rtiHost; + /** The host on which to run the rti. */ + private String rtiHost; - /** - * The name of this federation. - */ - private String containerName; + /** The name of this federation. */ + private String containerName; - public FedDockerComposeGenerator(LFGeneratorContext context, String rtiHost) { - super(context); - this.rtiHost = rtiHost; - this.containerName = context.getFileConfig().name; - } + public FedDockerComposeGenerator(LFGeneratorContext context, String rtiHost) { + super(context); + this.rtiHost = rtiHost; + this.containerName = context.getFileConfig().name; + } - @Override - protected String generateDockerServices(List services) { - return """ + @Override + protected String generateDockerServices(List services) { + return """ %s\ rti: image: "lflang/rti:rti" hostname: "%s" command: "-i 1 -n %s" container_name: "%s-rti" - """.formatted(super.generateDockerServices(services), - this.rtiHost, services.size(), containerName); - } - - @Override - protected String getServiceDescription(DockerData data) { - return """ + """ + .formatted( + super.generateDockerServices(services), this.rtiHost, services.size(), containerName); + } + + @Override + protected String getServiceDescription(DockerData data) { + return """ %s\ command: "-i 1" depends_on: - rti - """.formatted(super.getServiceDescription(data)); - } - - @Override - protected String getServiceName(DockerData data) { - return data.serviceName; - } - - @Override - protected String getBuildContext(DockerData data) { - return data.serviceName; - } - - @Override - protected String getContainerName(DockerData data) { - return this.containerName + "-" + data.serviceName; - } + """ + .formatted(super.getServiceDescription(data)); + } + + @Override + protected String getServiceName(DockerData data) { + return data.serviceName; + } + + @Override + protected String getBuildContext(DockerData data) { + return data.serviceName; + } + + @Override + protected String getContainerName(DockerData data) { + return this.containerName + "-" + data.serviceName; + } } diff --git a/org.lflang/src/org/lflang/generator/GenerationException.java b/org.lflang/src/org/lflang/generator/GenerationException.java index 1920e9aca8..1bc7985ee7 100644 --- a/org.lflang/src/org/lflang/generator/GenerationException.java +++ b/org.lflang/src/org/lflang/generator/GenerationException.java @@ -27,40 +27,36 @@ import org.eclipse.emf.ecore.EObject; // import org.jetbrains.annotations.Nullable; -/** - * An exception that occurred during code generation. May also - * wrap another exception. - */ -public class GenerationException extends RuntimeException { // note that this is an unchecked exception. - - /* @Nullable */ - private final EObject location; - - public GenerationException(String message) { - this(null, message, null); - } - - public GenerationException(/* @Nullable */ EObject location, String message) { - this(location, message, null); - } - - public GenerationException(String message, Throwable cause) { - this(null, message, cause); - - } - - public GenerationException(/* @Nullable */ EObject location, String message, Throwable cause) { - super(message, cause); - this.location = location; - } - - public GenerationException(Throwable cause) { - this(null, null, cause); - } - - /* @Nullable */ - public EObject getLocation() { - return location; - } +/** An exception that occurred during code generation. May also wrap another exception. */ +public class GenerationException + extends RuntimeException { // note that this is an unchecked exception. + + /* @Nullable */ + private final EObject location; + + public GenerationException(String message) { + this(null, message, null); + } + + public GenerationException(/* @Nullable */ EObject location, String message) { + this(location, message, null); + } + + public GenerationException(String message, Throwable cause) { + this(null, message, cause); + } + + public GenerationException(/* @Nullable */ EObject location, String message, Throwable cause) { + super(message, cause); + this.location = location; + } + + public GenerationException(Throwable cause) { + this(null, null, cause); + } + + /* @Nullable */ + public EObject getLocation() { + return location; + } } - diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/src/org/lflang/generator/GeneratorBase.java index 8d57e4c522..c8ebbc38a2 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorBase.java +++ b/org.lflang/src/org/lflang/generator/GeneratorBase.java @@ -24,47 +24,42 @@ ***************/ package org.lflang.generator; +import com.google.common.base.Objects; +import com.google.common.collect.Iterables; import java.io.IOException; import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; -import java.util.LinkedHashSet; import java.util.LinkedHashMap; +import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; - import org.eclipse.core.resources.IMarker; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.util.EcoreUtil; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.IteratorExtensions; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.MainConflictChecker; import org.lflang.Target; import org.lflang.TargetConfig; +import org.lflang.ast.ASTUtils; import org.lflang.ast.AstTransformation; import org.lflang.graph.InstantiationGraph; import org.lflang.lf.Connection; import org.lflang.lf.Instantiation; import org.lflang.lf.LfFactory; import org.lflang.lf.Mode; - import org.lflang.lf.Reaction; import org.lflang.lf.Reactor; import org.lflang.util.FileUtil; import org.lflang.validation.AbstractLFValidator; -import com.google.common.base.Objects; -import com.google.common.collect.Iterables; - /** - * Generator base class for specifying core functionality - * that all code generators should have. + * Generator base class for specifying core functionality that all code generators should have. * * @author Edward A. Lee * @author Marten Lohstroh @@ -74,598 +69,599 @@ */ public abstract class GeneratorBase extends AbstractLFValidator { - //////////////////////////////////////////// - //// Public fields. - - /** - * The main (top-level) reactor instance. - */ - public ReactorInstance main; - - /** An error reporter for reporting any errors or warnings during the code generation */ - public ErrorReporter errorReporter; - - //////////////////////////////////////////// - //// Protected fields. - - /** - * The current target configuration. - */ - protected final TargetConfig targetConfig; - - public TargetConfig getTargetConfig() { return this.targetConfig;} - - public final LFGeneratorContext context; - - /** - * A factory for compiler commands. - */ - protected GeneratorCommandFactory commandFactory; - - public GeneratorCommandFactory getCommandFactory() { return commandFactory; } - - /** - * Definition of the main (top-level) reactor. - * This is an automatically generated AST node for the top-level - * reactor. - */ - protected Instantiation mainDef; - public Instantiation getMainDef() { return mainDef; } - - /** - * A list of Reactor definitions in the main resource, including non-main - * reactors defined in imported resources. These are ordered in the list in - * such a way that each reactor is preceded by any reactor that it instantiates - * using a command like {@code foo = new Foo();} - */ - protected List reactors = new ArrayList<>(); - - /** - * The set of resources referenced reactor classes reside in. - */ - protected Set resources = new LinkedHashSet<>(); // FIXME: Why do we need this? - - /** - * Graph that tracks dependencies between instantiations. - * This is a graph where each node is a Reactor (not a ReactorInstance) - * and an arc from Reactor A to Reactor B means that B contains an instance of A, constructed with a statement - * like {@code a = new A();} After creating the graph, - * sort the reactors in topological order and assign them to the reactors class variable. - * Hence, after this method returns, {@code this.reactors} will be a list of Reactors such that any - * reactor is preceded in the list by reactors that it instantiates. - */ - protected InstantiationGraph instantiationGraph; - - /** - * The set of unordered reactions. An unordered reaction is one that does - * not have any dependency on other reactions in the containing reactor, - * and where no other reaction in the containing reactor depends on it. - * There is currently no way in the syntax of LF to make a reaction - * unordered, deliberately, because it can introduce unexpected - * nondeterminacy. However, certain automatically generated reactions are - * known to be safe to be unordered because they do not interact with the - * state of the containing reactor. To make a reaction unordered, when - * the Reaction instance is created, add that instance to this set. - */ - protected Set unorderedReactions = null; - - /** - * Map from reactions to bank indices - */ - protected Map reactionBankIndices = null; - - /** - * Indicates whether the current Lingua Franca program - * contains model reactors. - */ - public boolean hasModalReactors = false; - - /** - * Indicates whether the program has any deadlines and thus - * needs to propagate deadlines through the reaction instance graph - */ - public boolean hasDeadlines = false; - - /** Indicates whether the program has any watchdogs. This is used to check for support. */ - public boolean hasWatchdogs = false; - - // ////////////////////////////////////////// - // // Private fields. - - /** - * A list ot AST transformations to apply before code generation - */ - private final List astTransformations = new ArrayList<>(); - - /** - * Create a new GeneratorBase object. - */ - public GeneratorBase(LFGeneratorContext context) { - this.context = context; - this.targetConfig = context.getTargetConfig(); - this.errorReporter = context.getErrorReporter(); - this.commandFactory = new GeneratorCommandFactory(errorReporter, context.getFileConfig()); + //////////////////////////////////////////// + //// Public fields. + + /** The main (top-level) reactor instance. */ + public ReactorInstance main; + + /** An error reporter for reporting any errors or warnings during the code generation */ + public ErrorReporter errorReporter; + + //////////////////////////////////////////// + //// Protected fields. + + /** The current target configuration. */ + protected final TargetConfig targetConfig; + + public TargetConfig getTargetConfig() { + return this.targetConfig; + } + + public final LFGeneratorContext context; + + /** A factory for compiler commands. */ + protected GeneratorCommandFactory commandFactory; + + public GeneratorCommandFactory getCommandFactory() { + return commandFactory; + } + + /** + * Definition of the main (top-level) reactor. This is an automatically generated AST node for the + * top-level reactor. + */ + protected Instantiation mainDef; + + public Instantiation getMainDef() { + return mainDef; + } + + /** + * A list of Reactor definitions in the main resource, including non-main reactors defined in + * imported resources. These are ordered in the list in such a way that each reactor is preceded + * by any reactor that it instantiates using a command like {@code foo = new Foo();} + */ + protected List reactors = new ArrayList<>(); + + /** The set of resources referenced reactor classes reside in. */ + protected Set resources = new LinkedHashSet<>(); // FIXME: Why do we need this? + + /** + * Graph that tracks dependencies between instantiations. This is a graph where each node is a + * Reactor (not a ReactorInstance) and an arc from Reactor A to Reactor B means that B contains an + * instance of A, constructed with a statement like {@code a = new A();} After creating the graph, + * sort the reactors in topological order and assign them to the reactors class variable. Hence, + * after this method returns, {@code this.reactors} will be a list of Reactors such that any + * reactor is preceded in the list by reactors that it instantiates. + */ + protected InstantiationGraph instantiationGraph; + + /** + * The set of unordered reactions. An unordered reaction is one that does not have any dependency + * on other reactions in the containing reactor, and where no other reaction in the containing + * reactor depends on it. There is currently no way in the syntax of LF to make a reaction + * unordered, deliberately, because it can introduce unexpected nondeterminacy. However, certain + * automatically generated reactions are known to be safe to be unordered because they do not + * interact with the state of the containing reactor. To make a reaction unordered, when the + * Reaction instance is created, add that instance to this set. + */ + protected Set unorderedReactions = null; + + /** Map from reactions to bank indices */ + protected Map reactionBankIndices = null; + + /** Indicates whether the current Lingua Franca program contains model reactors. */ + public boolean hasModalReactors = false; + + /** + * Indicates whether the program has any deadlines and thus needs to propagate deadlines through + * the reaction instance graph + */ + public boolean hasDeadlines = false; + + /** Indicates whether the program has any watchdogs. This is used to check for support. */ + public boolean hasWatchdogs = false; + + // ////////////////////////////////////////// + // // Private fields. + + /** A list ot AST transformations to apply before code generation */ + private final List astTransformations = new ArrayList<>(); + + /** Create a new GeneratorBase object. */ + public GeneratorBase(LFGeneratorContext context) { + this.context = context; + this.targetConfig = context.getTargetConfig(); + this.errorReporter = context.getErrorReporter(); + this.commandFactory = new GeneratorCommandFactory(errorReporter, context.getFileConfig()); + } + + /** + * Register an AST transformation to be applied to the AST. + * + *

    The transformations will be applied in the order that they are registered in. + */ + protected void registerTransformation(AstTransformation transformation) { + astTransformations.add(transformation); + } + + // ////////////////////////////////////////// + // // Code generation functions to override for a concrete code generator. + + /** + * If there is a main or federated reactor, then create a synthetic Instantiation for that + * top-level reactor and set the field mainDef to refer to it. + */ + private void createMainInstantiation() { + // Find the main reactor and create an AST node for its instantiation. + Iterable nodes = + IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); + for (Reactor reactor : Iterables.filter(nodes, Reactor.class)) { + if (reactor.isMain()) { + // Creating a definition for the main reactor because there isn't one. + this.mainDef = LfFactory.eINSTANCE.createInstantiation(); + this.mainDef.setName(reactor.getName()); + this.mainDef.setReactorClass(reactor); + } } - - /** - * Register an AST transformation to be applied to the AST. - * - * The transformations will be applied in the order that they are registered in. - */ - protected void registerTransformation(AstTransformation transformation) { - astTransformations.add(transformation); + } + + /** + * Generate code from the Lingua Franca model contained by the specified resource. + * + *

    This is the main entry point for code generation. This base class finds all reactor class + * definitions, including any reactors defined in imported .lf files (except any main reactors in + * those imported files), and adds them to the {@link GeneratorBase#reactors reactors} list. If + * errors occur during generation, then a subsequent call to errorsOccurred() will return true. + * + * @param resource The resource containing the source code. + * @param context Context relating to invocation of the code generator. In standalone mode, this + * object is also used to relay CLI arguments. + */ + public void doGenerate(Resource resource, LFGeneratorContext context) { + + // FIXME: the signature can be reduced to only take context. + // The constructor also need not take a file config because this is tied to the context as well. + cleanIfNeeded(context); + + printInfo(context.getMode()); + + // Clear any IDE markers that may have been created by a previous build. + // Markers mark problems in the Eclipse IDE when running in integrated mode. + errorReporter.clearHistory(); + + ASTUtils.setMainName(context.getFileConfig().resource, context.getFileConfig().name); + + createMainInstantiation(); + + // Check if there are any conflicting main reactors elsewhere in the package. + if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && mainDef != null) { + for (String conflict : new MainConflictChecker(context.getFileConfig()).conflicts) { + errorReporter.reportError( + this.mainDef.getReactorClass(), "Conflicting main reactor in " + conflict); + } } - // ////////////////////////////////////////// - // // Code generation functions to override for a concrete code generator. - - /** - * If there is a main or federated reactor, then create a synthetic Instantiation - * for that top-level reactor and set the field mainDef to refer to it. - */ - private void createMainInstantiation() { - // Find the main reactor and create an AST node for its instantiation. - Iterable nodes = IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); - for (Reactor reactor : Iterables.filter(nodes, Reactor.class)) { - if (reactor.isMain()) { - // Creating a definition for the main reactor because there isn't one. - this.mainDef = LfFactory.eINSTANCE.createInstantiation(); - this.mainDef.setName(reactor.getName()); - this.mainDef.setReactorClass(reactor); - } - } + // Configure the command factory + commandFactory.setVerbose(); + if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) + && context.getArgs().containsKey("quiet")) { + commandFactory.setQuiet(); } - /** - * Generate code from the Lingua Franca model contained by the specified resource. - * - * This is the main entry point for code generation. This base class finds all - * reactor class definitions, including any reactors defined in imported .lf files - * (except any main reactors in those imported files), and adds them to the - * {@link GeneratorBase#reactors reactors} list. If errors occur during - * generation, then a subsequent call to errorsOccurred() will return true. - * @param resource The resource containing the source code. - * @param context Context relating to invocation of the code generator. - * In standalone mode, this object is also used to relay CLI arguments. - */ - public void doGenerate(Resource resource, LFGeneratorContext context) { - - // FIXME: the signature can be reduced to only take context. - // The constructor also need not take a file config because this is tied to the context as well. - cleanIfNeeded(context); - - printInfo(context.getMode()); - - // Clear any IDE markers that may have been created by a previous build. - // Markers mark problems in the Eclipse IDE when running in integrated mode. - errorReporter.clearHistory(); - - ASTUtils.setMainName(context.getFileConfig().resource, context.getFileConfig().name); - - createMainInstantiation(); - - // Check if there are any conflicting main reactors elsewhere in the package. - if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && mainDef != null) { - for (String conflict : new MainConflictChecker(context.getFileConfig()).conflicts) { - errorReporter.reportError(this.mainDef.getReactorClass(), "Conflicting main reactor in " + conflict); - } - } - - // Configure the command factory - commandFactory.setVerbose(); - if (Objects.equal(context.getMode(), LFGeneratorContext.Mode.STANDALONE) && context.getArgs().containsKey("quiet")) { - commandFactory.setQuiet(); - } - - // Process target files. Copy each of them into the src-gen dir. - // FIXME: Should we do this here? This doesn't make sense for federates the way it is - // done here. - copyUserFiles(this.targetConfig, context.getFileConfig()); - - // Collect reactors and create an instantiation graph. - // These are needed to figure out which resources we need - // to validate, which happens in setResources(). - setReactorsAndInstantiationGraph(context.getMode()); - - List allResources = GeneratorUtils.getResources(reactors); - resources.addAll(allResources.stream() // FIXME: This filter reproduces the behavior of the method it replaces. But why must it be so complicated? Why are we worried about weird corner cases like this? - .filter(it -> !Objects.equal(it, context.getFileConfig().resource) || mainDef != null && it == mainDef.getReactorClass().eResource()) - .map(it -> GeneratorUtils.getLFResource(it, context.getFileConfig().getSrcGenBasePath(), context, errorReporter)) - .toList() - ); - GeneratorUtils.accommodatePhysicalActionsIfPresent( - allResources, - getTarget().setsKeepAliveOptionAutomatically(), - targetConfig, - errorReporter - ); - // FIXME: Should the GeneratorBase pull in {@code files} from imported - // resources? - - for (AstTransformation transformation : astTransformations) { - transformation.applyTransformation(reactors); - } - - // Transform connections that reside in mutually exclusive modes and are otherwise conflicting - // This should be done before creating the instantiation graph - transformConflictingConnectionsInModalReactors(); - - // Invoke these functions a second time because transformations - // may have introduced new reactors! - setReactorsAndInstantiationGraph(context.getMode()); - - // Check for existence and support of modes - hasModalReactors = IterableExtensions.exists(reactors, it -> !it.getModes().isEmpty()); - checkModalReactorSupport(false); - - // Check for the existence and support of watchdogs - hasWatchdogs = IterableExtensions.exists(reactors, it -> !it.getWatchdogs().isEmpty()); - checkWatchdogSupport(targetConfig.threading && getTarget() == Target.C); - additionalPostProcessingForModes(); + // Process target files. Copy each of them into the src-gen dir. + // FIXME: Should we do this here? This doesn't make sense for federates the way it is + // done here. + copyUserFiles(this.targetConfig, context.getFileConfig()); + + // Collect reactors and create an instantiation graph. + // These are needed to figure out which resources we need + // to validate, which happens in setResources(). + setReactorsAndInstantiationGraph(context.getMode()); + + List allResources = GeneratorUtils.getResources(reactors); + resources.addAll( + allResources + .stream() // FIXME: This filter reproduces the behavior of the method it replaces. But + // why must it be so complicated? Why are we worried about weird corner cases + // like this? + .filter( + it -> + !Objects.equal(it, context.getFileConfig().resource) + || mainDef != null && it == mainDef.getReactorClass().eResource()) + .map( + it -> + GeneratorUtils.getLFResource( + it, context.getFileConfig().getSrcGenBasePath(), context, errorReporter)) + .toList()); + GeneratorUtils.accommodatePhysicalActionsIfPresent( + allResources, getTarget().setsKeepAliveOptionAutomatically(), targetConfig, errorReporter); + // FIXME: Should the GeneratorBase pull in {@code files} from imported + // resources? + + for (AstTransformation transformation : astTransformations) { + transformation.applyTransformation(reactors); } - /** - * Check if a clean was requested from the standalone compiler and perform - * the clean step. - */ - protected void cleanIfNeeded(LFGeneratorContext context) { - if (context.getArgs().containsKey("clean")) { - try { - context.getFileConfig().doClean(); - } catch (IOException e) { - System.err.println("WARNING: IO Error during clean"); - } - } + // Transform connections that reside in mutually exclusive modes and are otherwise conflicting + // This should be done before creating the instantiation graph + transformConflictingConnectionsInModalReactors(); + + // Invoke these functions a second time because transformations + // may have introduced new reactors! + setReactorsAndInstantiationGraph(context.getMode()); + + // Check for existence and support of modes + hasModalReactors = IterableExtensions.exists(reactors, it -> !it.getModes().isEmpty()); + checkModalReactorSupport(false); + + // Check for the existence and support of watchdogs + hasWatchdogs = IterableExtensions.exists(reactors, it -> !it.getWatchdogs().isEmpty()); + checkWatchdogSupport(targetConfig.threading && getTarget() == Target.C); + additionalPostProcessingForModes(); + } + + /** Check if a clean was requested from the standalone compiler and perform the clean step. */ + protected void cleanIfNeeded(LFGeneratorContext context) { + if (context.getArgs().containsKey("clean")) { + try { + context.getFileConfig().doClean(); + } catch (IOException e) { + System.err.println("WARNING: IO Error during clean"); + } } - - /** - * Create a new instantiation graph. This is a graph where each node is a Reactor (not a ReactorInstance) - * and an arc from Reactor A to Reactor B means that B contains an instance of A, constructed with a statement - * like {@code a = new A();} After creating the graph, - * sort the reactors in topological order and assign them to the reactors class variable. - * Hence, after this method returns, {@code this.reactors} will be a list of Reactors such that any - * reactor is preceded in the list by reactors that it instantiates. - */ - protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { - // Build the instantiation graph . - instantiationGraph = new InstantiationGraph(context.getFileConfig().resource, false); - - // Topologically sort the reactors such that all of a reactor's instantiation dependencies occur earlier in - // the sorted list of reactors. This helps the code generator output code in the correct order. - // For example if {@code reactor Foo {bar = new Bar()}} then the definition of {@code Bar} has to be generated before - // the definition of {@code Foo}. - reactors = instantiationGraph.nodesInTopologicalOrder(); - - // If there is no main reactor or if all reactors in the file need to be validated, then make sure the reactors - // list includes even reactors that are not instantiated anywhere. - if (mainDef == null || Objects.equal(mode, LFGeneratorContext.Mode.LSP_MEDIUM)) { - Iterable nodes = IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); - for (Reactor r : IterableExtensions.filter(nodes, Reactor.class)) { - if (!reactors.contains(r)) { - reactors.add(r); - } - } + } + + /** + * Create a new instantiation graph. This is a graph where each node is a Reactor (not a + * ReactorInstance) and an arc from Reactor A to Reactor B means that B contains an instance of A, + * constructed with a statement like {@code a = new A();} After creating the graph, sort the + * reactors in topological order and assign them to the reactors class variable. Hence, after this + * method returns, {@code this.reactors} will be a list of Reactors such that any reactor is + * preceded in the list by reactors that it instantiates. + */ + protected void setReactorsAndInstantiationGraph(LFGeneratorContext.Mode mode) { + // Build the instantiation graph . + instantiationGraph = new InstantiationGraph(context.getFileConfig().resource, false); + + // Topologically sort the reactors such that all of a reactor's instantiation dependencies occur + // earlier in + // the sorted list of reactors. This helps the code generator output code in the correct order. + // For example if {@code reactor Foo {bar = new Bar()}} then the definition of {@code Bar} has + // to be generated before + // the definition of {@code Foo}. + reactors = instantiationGraph.nodesInTopologicalOrder(); + + // If there is no main reactor or if all reactors in the file need to be validated, then make + // sure the reactors + // list includes even reactors that are not instantiated anywhere. + if (mainDef == null || Objects.equal(mode, LFGeneratorContext.Mode.LSP_MEDIUM)) { + Iterable nodes = + IteratorExtensions.toIterable(context.getFileConfig().resource.getAllContents()); + for (Reactor r : IterableExtensions.filter(nodes, Reactor.class)) { + if (!reactors.contains(r)) { + reactors.add(r); } + } } - - /** - * Copy user specific files to the src-gen folder. - * - * This should be overridden by the target generators. - * - * @param targetConfig The targetConfig to read the {@code files} from. - * @param fileConfig The fileConfig used to make the copy and resolve paths. - */ - protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - var dst = this.context.getFileConfig().getSrcGenPath(); - FileUtil.copyFilesOrDirectories(targetConfig.files, dst, fileConfig, errorReporter, false); - } - - /** - * Return true if errors occurred in the last call to doGenerate(). - * This will return true if any of the reportError methods was called. - * @return True if errors occurred. - */ - public boolean errorsOccurred() { - return errorReporter.getErrorsOccurred(); + } + + /** + * Copy user specific files to the src-gen folder. + * + *

    This should be overridden by the target generators. + * + * @param targetConfig The targetConfig to read the {@code files} from. + * @param fileConfig The fileConfig used to make the copy and resolve paths. + */ + protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + var dst = this.context.getFileConfig().getSrcGenPath(); + FileUtil.copyFilesOrDirectories(targetConfig.files, dst, fileConfig, errorReporter, false); + } + + /** + * Return true if errors occurred in the last call to doGenerate(). This will return true if any + * of the reportError methods was called. + * + * @return True if errors occurred. + */ + public boolean errorsOccurred() { + return errorReporter.getErrorsOccurred(); + } + + /* + * Return the TargetTypes instance associated with this. + */ + public abstract TargetTypes getTargetTypes(); + + /** + * Mark the reaction unordered. An unordered reaction is one that does not have any dependency on + * other reactions in the containing reactor, and where no other reaction in the containing + * reactor depends on it. There is currently no way in the syntax of LF to make a reaction + * unordered, deliberately, because it can introduce unexpected nondeterminacy. However, certain + * automatically generated reactions are known to be safe to be unordered because they do not + * interact with the state of the containing reactor. To make a reaction unordered, when the + * Reaction instance is created, add that instance to this set. + * + * @param reaction The reaction to make unordered. + */ + public void makeUnordered(Reaction reaction) { + if (unorderedReactions == null) { + unorderedReactions = new LinkedHashSet<>(); } - - /* - * Return the TargetTypes instance associated with this. - */ - public abstract TargetTypes getTargetTypes(); - - /** - * Mark the reaction unordered. An unordered reaction is one that does not - * have any dependency on other reactions in the containing reactor, and - * where no other reaction in the containing reactor depends on it. There - * is currently no way in the syntax of LF to make a reaction unordered, - * deliberately, because it can introduce unexpected nondeterminacy. - * However, certain automatically generated reactions are known to be safe - * to be unordered because they do not interact with the state of the - * containing reactor. To make a reaction unordered, when the Reaction - * instance is created, add that instance to this set. - * @param reaction The reaction to make unordered. - */ - public void makeUnordered(Reaction reaction) { - if (unorderedReactions == null) { - unorderedReactions = new LinkedHashSet<>(); - } - unorderedReactions.add(reaction); + unorderedReactions.add(reaction); + } + + /** + * Mark the specified reaction to belong to only the specified bank index. This is needed because + * reactions cannot declare a specific bank index as an effect or trigger. Reactions that send + * messages between federates, including absent messages, need to be specific to a bank member. + * + * @param reaction The reaction. + * @param bankIndex The bank index, or -1 if there is no bank. + */ + public void setReactionBankIndex(Reaction reaction, int bankIndex) { + if (bankIndex < 0) { + return; } - - /** - * Mark the specified reaction to belong to only the specified - * bank index. This is needed because reactions cannot declare - * a specific bank index as an effect or trigger. Reactions that - * send messages between federates, including absent messages, - * need to be specific to a bank member. - * @param reaction The reaction. - * @param bankIndex The bank index, or -1 if there is no bank. - */ - public void setReactionBankIndex(Reaction reaction, int bankIndex) { - if (bankIndex < 0) { - return; - } - if (reactionBankIndices == null) { - reactionBankIndices = new LinkedHashMap<>(); - } - reactionBankIndices.put(reaction, bankIndex); + if (reactionBankIndices == null) { + reactionBankIndices = new LinkedHashMap<>(); } - - /** - * Return the reaction bank index. - * @see #setReactionBankIndex(Reaction reaction, int bankIndex) - * @param reaction The reaction. - * @return The reaction bank index, if one has been set, and -1 otherwise. - */ - public int getReactionBankIndex(Reaction reaction) { - if (reactionBankIndices == null) return -1; - if (reactionBankIndices.get(reaction) == null) return -1; - return reactionBankIndices.get(reaction); + reactionBankIndices.put(reaction, bankIndex); + } + + /** + * Return the reaction bank index. + * + * @see #setReactionBankIndex(Reaction reaction, int bankIndex) + * @param reaction The reaction. + * @return The reaction bank index, if one has been set, and -1 otherwise. + */ + public int getReactionBankIndex(Reaction reaction) { + if (reactionBankIndices == null) return -1; + if (reactionBankIndices.get(reaction) == null) return -1; + return reactionBankIndices.get(reaction); + } + + // ////////////////////////////////////////// + // // Protected methods. + + /** + * Checks whether modal reactors are present and require appropriate code generation. This will + * set the hasModalReactors variable. + * + * @param isSupported indicates if modes are supported by this code generation. + */ + protected void checkModalReactorSupport(boolean isSupported) { + if (hasModalReactors && !isSupported) { + errorReporter.reportError( + "The currently selected code generation or " + + "target configuration does not support modal reactors!"); } - - // ////////////////////////////////////////// - // // Protected methods. - - /** - * Checks whether modal reactors are present and require appropriate code generation. - * This will set the hasModalReactors variable. - * @param isSupported indicates if modes are supported by this code generation. - */ - protected void checkModalReactorSupport(boolean isSupported) { - if (hasModalReactors && !isSupported) { - errorReporter.reportError("The currently selected code generation or " + - "target configuration does not support modal reactors!"); - } + } + + /** + * Check whether watchdogs are present and are supported. + * + * @param isSupported indicates whether or not this is a supported target and whether or not it is + * a threaded runtime. + */ + protected void checkWatchdogSupport(boolean isSupported) { + if (hasWatchdogs && !isSupported) { + errorReporter.reportError( + "Watchdogs are currently only supported for threaded programs in the C target."); } - - /** - * Check whether watchdogs are present and are supported. - * - * @param isSupported indicates whether or not this is a supported target and whether or not it - * is - * a threaded runtime. - */ - protected void checkWatchdogSupport(boolean isSupported) { - if (hasWatchdogs && !isSupported) { + } + + /** + * Finds and transforms connections into forwarding reactions iff the connections have the same + * destination as other connections or reaction in mutually exclusive modes. + */ + private void transformConflictingConnectionsInModalReactors() { + for (LFResource r : resources) { + var transform = ASTUtils.findConflictingConnectionsInModalReactors(r.eResource); + if (!transform.isEmpty()) { + var factory = LfFactory.eINSTANCE; + for (Connection connection : transform) { + // Currently only simple transformations are supported + if (connection.isPhysical() + || connection.getDelay() != null + || connection.isIterated() + || connection.getLeftPorts().size() > 1 + || connection.getRightPorts().size() > 1) { errorReporter.reportError( - "Watchdogs are currently only supported for threaded programs in the C target."); + connection, + "Cannot transform connection in modal reactor. Connection uses currently not" + + " supported features."); + } else { + var reaction = factory.createReaction(); + ((Mode) connection.eContainer()).getReactions().add(reaction); + + var sourceRef = connection.getLeftPorts().get(0); + var destRef = connection.getRightPorts().get(0); + reaction.getTriggers().add(sourceRef); + reaction.getEffects().add(destRef); + + var code = factory.createCode(); + var source = + (sourceRef.getContainer() != null ? sourceRef.getContainer().getName() + "." : "") + + sourceRef.getVariable().getName(); + var dest = + (destRef.getContainer() != null ? destRef.getContainer().getName() + "." : "") + + destRef.getVariable().getName(); + code.setBody(getConflictingConnectionsInModalReactorsBody(source, dest)); + reaction.setCode(code); + + EcoreUtil.remove(connection); + } } + } } - - /** - * Finds and transforms connections into forwarding reactions iff the connections have the same - * destination as other connections or reaction in mutually exclusive modes. - */ - private void transformConflictingConnectionsInModalReactors() { - for (LFResource r : resources) { - var transform = ASTUtils.findConflictingConnectionsInModalReactors(r.eResource); - if (!transform.isEmpty()) { - var factory = LfFactory.eINSTANCE; - for (Connection connection : transform) { - // Currently only simple transformations are supported - if (connection.isPhysical() || connection.getDelay() != null || connection.isIterated() || - connection.getLeftPorts().size() > 1 || connection.getRightPorts().size() > 1 - ) { - errorReporter.reportError(connection, "Cannot transform connection in modal reactor. Connection uses currently not supported features."); - } else { - var reaction = factory.createReaction(); - ((Mode)connection.eContainer()).getReactions().add(reaction); - - var sourceRef = connection.getLeftPorts().get(0); - var destRef = connection.getRightPorts().get(0); - reaction.getTriggers().add(sourceRef); - reaction.getEffects().add(destRef); - - var code = factory.createCode(); - var source = (sourceRef.getContainer() != null ? - sourceRef.getContainer().getName() + "." : "") + sourceRef.getVariable().getName(); - var dest = (destRef.getContainer() != null ? - destRef.getContainer().getName() + "." : "") + destRef.getVariable().getName(); - code.setBody(getConflictingConnectionsInModalReactorsBody(source, dest)); - reaction.setCode(code); - - EcoreUtil.remove(connection); - } - } - } - } - } - - /** - * Return target code for forwarding reactions iff the connections have the - * same destination as other connections or reaction in mutually exclusive modes. - * - * This method needs to be overridden in target specific code generators that - * support modal reactors. - */ - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - errorReporter.reportError("The currently selected code generation " + - "is missing an implementation for conflicting " + - "transforming connections in modal reactors."); - return "MODAL MODELS NOT SUPPORTED"; + } + + /** + * Return target code for forwarding reactions iff the connections have the same destination as + * other connections or reaction in mutually exclusive modes. + * + *

    This method needs to be overridden in target specific code generators that support modal + * reactors. + */ + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + errorReporter.reportError( + "The currently selected code generation " + + "is missing an implementation for conflicting " + + "transforming connections in modal reactors."); + return "MODAL MODELS NOT SUPPORTED"; + } + + /** Hook for additional post-processing of the model. */ + protected void additionalPostProcessingForModes() { + // Do nothing + } + + /** Parsed error message from a compiler is returned here. */ + public static class ErrorFileAndLine { + public String filepath = null; + public String line = "1"; + public String character = "0"; + public String message = ""; + public boolean isError = true; // false for a warning. + + @Override + public String toString() { + return (isError ? "Error" : "Non-error") + + " at " + + line + + ":" + + character + + " of file " + + filepath + + ": " + + message; } - - /** - * Hook for additional post-processing of the model. - */ - protected void additionalPostProcessingForModes() { - // Do nothing - } - - /** - * Parsed error message from a compiler is returned here. - */ - public static class ErrorFileAndLine { - public String filepath = null; - public String line = "1"; - public String character = "0"; - public String message = ""; - public boolean isError = true; // false for a warning. - - @Override - public String toString() { - return (isError ? "Error" : "Non-error") + " at " + line + ":" + character + " of file " + filepath + ": " + message; - } - } - - /** - * Given a line of text from the output of a compiler, return - * an instance of ErrorFileAndLine if the line is recognized as - * the first line of an error message. Otherwise, return null. - * This base class simply returns null. - * @param line A line of output from a compiler or other external - * tool that might generate errors. - * @return If the line is recognized as the start of an error message, - * then return a class containing the path to the file on which the - * error occurred (or null if there is none), the line number (or the - * string "1" if there is none), the character position (or the string - * "0" if there is none), and the message (or an empty string if there - * is none). - */ - protected ErrorFileAndLine parseCommandOutput(String line) { - return null; - } - - /** - * Parse the specified string for command errors that can be reported - * using marks in the Eclipse IDE. In this class, we attempt to parse - * the messages to look for file and line information, thereby generating - * marks on the appropriate lines. This should not be called in standalone - * mode. - * - * @param stderr The output on standard error of executing a command. - */ - public void reportCommandErrors(String stderr) { - // NOTE: If the VS Code branch passes code review, then this function, - // parseCommandOutput, and ErrorFileAndLine will be deleted soon after. - // First, split the message into lines. - String[] lines = stderr.split("\\r?\\n"); - StringBuilder message = new StringBuilder(); - Integer lineNumber = null; - Path path = context.getFileConfig().srcFile; - // In case errors occur within an imported file, record the original path. - Path originalPath = path; - - int severity = IMarker.SEVERITY_ERROR; - for (String line : lines) { - ErrorFileAndLine parsed = parseCommandOutput(line); - if (parsed != null) { - // Found a new line number designator. - // If there is a previously accumulated message, report it. - if (message.length() > 0) { - if (severity == IMarker.SEVERITY_ERROR) - errorReporter.reportError(path, lineNumber, message.toString()); - else - errorReporter.reportWarning(path, lineNumber, message.toString()); - - if (!Objects.equal(originalPath.toFile(), path.toFile())) { - // Report an error also in the top-level resource. - // FIXME: It should be possible to descend through the import - // statements to find which one matches and mark all the - // import statements down the chain. But what a pain! - if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); - } else { - errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); - } - } - } - if (parsed.isError) { - severity = IMarker.SEVERITY_ERROR; - } else { - severity = IMarker.SEVERITY_WARNING; - } - - // Start accumulating a new message. - message = new StringBuilder(); - // Append the message on the line number designator line. - message.append(parsed.message); - - // Set the new line number. - try { - lineNumber = Integer.decode(parsed.line); - } catch (Exception ex) { - // Set the line number unknown. - lineNumber = null; - } - // FIXME: Ignoring the position within the line. - // Determine the path within which the error occurred. - path = Paths.get(parsed.filepath); - } else { - // No line designator. - if (message.length() > 0) { - message.append("\n"); - } else { - if (!line.toLowerCase().contains("error:")) { - severity = IMarker.SEVERITY_WARNING; - } - } - message.append(line); - } - } + } + + /** + * Given a line of text from the output of a compiler, return an instance of ErrorFileAndLine if + * the line is recognized as the first line of an error message. Otherwise, return null. This base + * class simply returns null. + * + * @param line A line of output from a compiler or other external tool that might generate errors. + * @return If the line is recognized as the start of an error message, then return a class + * containing the path to the file on which the error occurred (or null if there is none), the + * line number (or the string "1" if there is none), the character position (or the string "0" + * if there is none), and the message (or an empty string if there is none). + */ + protected ErrorFileAndLine parseCommandOutput(String line) { + return null; + } + + /** + * Parse the specified string for command errors that can be reported using marks in the Eclipse + * IDE. In this class, we attempt to parse the messages to look for file and line information, + * thereby generating marks on the appropriate lines. This should not be called in standalone + * mode. + * + * @param stderr The output on standard error of executing a command. + */ + public void reportCommandErrors(String stderr) { + // NOTE: If the VS Code branch passes code review, then this function, + // parseCommandOutput, and ErrorFileAndLine will be deleted soon after. + // First, split the message into lines. + String[] lines = stderr.split("\\r?\\n"); + StringBuilder message = new StringBuilder(); + Integer lineNumber = null; + Path path = context.getFileConfig().srcFile; + // In case errors occur within an imported file, record the original path. + Path originalPath = path; + + int severity = IMarker.SEVERITY_ERROR; + for (String line : lines) { + ErrorFileAndLine parsed = parseCommandOutput(line); + if (parsed != null) { + // Found a new line number designator. + // If there is a previously accumulated message, report it. if (message.length() > 0) { + if (severity == IMarker.SEVERITY_ERROR) + errorReporter.reportError(path, lineNumber, message.toString()); + else errorReporter.reportWarning(path, lineNumber, message.toString()); + + if (!Objects.equal(originalPath.toFile(), path.toFile())) { + // Report an error also in the top-level resource. + // FIXME: It should be possible to descend through the import + // statements to find which one matches and mark all the + // import statements down the chain. But what a pain! if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(path, lineNumber, message.toString()); + errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); } else { - errorReporter.reportWarning(path, lineNumber, message.toString()); + errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); } + } + } + if (parsed.isError) { + severity = IMarker.SEVERITY_ERROR; + } else { + severity = IMarker.SEVERITY_WARNING; + } - if (originalPath.toFile() != path.toFile()) { - // Report an error also in the top-level resource. - // FIXME: It should be possible to descend through the import - // statements to find which one matches and mark all the - // import statements down the chain. But what a pain! - if (severity == IMarker.SEVERITY_ERROR) { - errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); - } else { - errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); - } - } + // Start accumulating a new message. + message = new StringBuilder(); + // Append the message on the line number designator line. + message.append(parsed.message); + + // Set the new line number. + try { + lineNumber = Integer.decode(parsed.line); + } catch (Exception ex) { + // Set the line number unknown. + lineNumber = null; + } + // FIXME: Ignoring the position within the line. + // Determine the path within which the error occurred. + path = Paths.get(parsed.filepath); + } else { + // No line designator. + if (message.length() > 0) { + message.append("\n"); + } else { + if (!line.toLowerCase().contains("error:")) { + severity = IMarker.SEVERITY_WARNING; + } } + message.append(line); + } } - - // ////////////////////////////////////////////////// - // // Private functions - - /** - * Print to stdout information about what source file is being generated, - * what mode the generator is in, and where the generated sources are to be put. - */ - public void printInfo(LFGeneratorContext.Mode mode) { - System.out.println("Generating code for: " + context.getFileConfig().resource.getURI().toString()); - System.out.println("******** mode: " + mode); - System.out.println("******** generated sources: " + context.getFileConfig().getSrcGenPath()); + if (message.length() > 0) { + if (severity == IMarker.SEVERITY_ERROR) { + errorReporter.reportError(path, lineNumber, message.toString()); + } else { + errorReporter.reportWarning(path, lineNumber, message.toString()); + } + + if (originalPath.toFile() != path.toFile()) { + // Report an error also in the top-level resource. + // FIXME: It should be possible to descend through the import + // statements to find which one matches and mark all the + // import statements down the chain. But what a pain! + if (severity == IMarker.SEVERITY_ERROR) { + errorReporter.reportError(originalPath, 1, "Error in imported file: " + path); + } else { + errorReporter.reportWarning(originalPath, 1, "Warning in imported file: " + path); + } + } } - - /** - * Get the buffer type used for network messages - */ - public String getNetworkBufferType() { return ""; } - - /** - * Return the Targets enum for the current target - */ - public abstract Target getTarget(); + } + + // ////////////////////////////////////////////////// + // // Private functions + + /** + * Print to stdout information about what source file is being generated, what mode the generator + * is in, and where the generated sources are to be put. + */ + public void printInfo(LFGeneratorContext.Mode mode) { + System.out.println( + "Generating code for: " + context.getFileConfig().resource.getURI().toString()); + System.out.println("******** mode: " + mode); + System.out.println("******** generated sources: " + context.getFileConfig().getSrcGenPath()); + } + + /** Get the buffer type used for network messages */ + public String getNetworkBufferType() { + return ""; + } + + /** Return the Targets enum for the current target */ + public abstract Target getTarget(); } diff --git a/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java b/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java index 081f07320b..b1dc44e094 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java +++ b/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java @@ -1,26 +1,26 @@ /************* - Copyright (c) 2019-2021 TU Dresden - Copyright (c) 2019-2021 UC Berkeley - - 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. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * Copyright (c) 2019-2021 TU Dresden + * Copyright (c) 2019-2021 UC Berkeley + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. ***************/ package org.lflang.generator; @@ -29,120 +29,128 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.nio.file.Paths; import java.util.List; import java.util.Objects; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.util.LFCommand; /** * A factory class responsible for creating commands for use by the LF code generators. - *

    - * In addition to the basic functionality of LFCommand, this class additionally ensures that error messages (or - * optionally warnings) are shown when a command is not found and that certain environment variables are set (see - * {@link #createCommand(String, List, Path, boolean) createCommand}). + * + *

    In addition to the basic functionality of LFCommand, this class additionally ensures that + * error messages (or optionally warnings) are shown when a command is not found and that certain + * environment variables are set (see {@link #createCommand(String, List, Path, boolean) + * createCommand}). */ public class GeneratorCommandFactory { - protected final ErrorReporter errorReporter; - protected final FileConfig fileConfig; - protected boolean quiet = false; - - public GeneratorCommandFactory(ErrorReporter errorReporter, FileConfig fileConfig) { - this.errorReporter = Objects.requireNonNull(errorReporter); - this.fileConfig = Objects.requireNonNull(fileConfig); - } - - /// enable quiet mode (command output is not printed) - public void setQuiet() { quiet = true; } - - /// enable verbose mode (command output is printed) - public void setVerbose() { quiet = false; } - - /** - * Create a LFCommand instance from a given command and an argument list. - *

    - * The command will be executed in the CWD and if the command cannot be found an error message is shown. - * - * @param cmd the command to look up - * @param args a list of arguments - * @return an LFCommand object or null if the command could not be found - * @see #createCommand(String, List, Path, boolean) - */ - public LFCommand createCommand(String cmd, List args) { - return createCommand(cmd, args, null, true); + protected final ErrorReporter errorReporter; + protected final FileConfig fileConfig; + protected boolean quiet = false; + + public GeneratorCommandFactory(ErrorReporter errorReporter, FileConfig fileConfig) { + this.errorReporter = Objects.requireNonNull(errorReporter); + this.fileConfig = Objects.requireNonNull(fileConfig); + } + + /// enable quiet mode (command output is not printed) + public void setQuiet() { + quiet = true; + } + + /// enable verbose mode (command output is printed) + public void setVerbose() { + quiet = false; + } + + /** + * Create a LFCommand instance from a given command and an argument list. + * + *

    The command will be executed in the CWD and if the command cannot be found an error message + * is shown. + * + * @param cmd the command to look up + * @param args a list of arguments + * @return an LFCommand object or null if the command could not be found + * @see #createCommand(String, List, Path, boolean) + */ + public LFCommand createCommand(String cmd, List args) { + return createCommand(cmd, args, null, true); + } + + /** + * Create a LFCommand instance from a given command, an argument list and a directory. + * + * @param cmd the command to look up + * @param args a list of arguments + * @param failOnError If true, an error is shown if the command cannot be found. Otherwise, only a + * warning is displayed. + * @return an LFCommand object or null if the command could not be found + * @see #createCommand(String, List, Path, boolean) + */ + public LFCommand createCommand(String cmd, List args, boolean failOnError) { + return createCommand(cmd, args, null, failOnError); + } + + /** + * Create a LFCommand instance from a given command, an argument list and a directory. + * + *

    The command will be executed in the CWD and if the command cannot be found an error message + * is shown. + * + * @param cmd the command to look up + * @param args a list of arguments + * @param dir the directory to execute the command in. If null, this will default to the CWD + * @return an LFCommand object or null if the command could not be found + * @see #createCommand(String, List, Path, boolean) + */ + public LFCommand createCommand(String cmd, List args, Path dir) { + return createCommand(cmd, args, dir, true); + } + + /** + * Create a LFCommand instance from a given command, an argument list and a directory. + * + *

    This will check first if the command can actually be found and executed. If the command is + * not found, null is returned. In addition, an error message will be shown if failOnError is + * true. Otherwise, a warning will be displayed. + * + * @param cmd the command to look up + * @param args a list of arguments + * @param dir the directory to execute the command in. If null, this will default to the CWD + * @param failOnError If true, an error is shown if the command cannot be found. Otherwise, only a + * warning is displayed. + * @return an LFCommand object or null if the command could not be found + * @see LFCommand#get(String, List, boolean, Path) + */ + public LFCommand createCommand(String cmd, List args, Path dir, boolean failOnError) { + assert cmd != null && args != null; + if (dir == null) { + dir = Paths.get(""); } - - - /** - * Create a LFCommand instance from a given command, an argument list and a directory. - * - * @param cmd the command to look up - * @param args a list of arguments - * @param failOnError If true, an error is shown if the command cannot be found. Otherwise, only a warning is - * displayed. - * @return an LFCommand object or null if the command could not be found - * @see #createCommand(String, List, Path, boolean) - */ - public LFCommand createCommand(String cmd, List args, boolean failOnError) { - return createCommand(cmd, args, null, failOnError); + LFCommand command = LFCommand.get(cmd, args, quiet, dir); + if (command != null) { + command.setEnvironmentVariable("LF_CURRENT_WORKING_DIRECTORY", dir.toString()); + command.setEnvironmentVariable("LF_SOURCE_DIRECTORY", fileConfig.srcPath.toString()); + command.setEnvironmentVariable("LF_PACKAGE_DIRECTORY", fileConfig.srcPkgPath.toString()); + command.setEnvironmentVariable( + "LF_SOURCE_GEN_DIRECTORY", fileConfig.getSrcGenPath().toString()); + command.setEnvironmentVariable("LF_BIN_DIRECTORY", fileConfig.binPath.toString()); + } else { + final String message = + "The command " + + cmd + + " could not be found in the current working directory or in your PATH. " + + "Make sure that your PATH variable includes the directory where " + + cmd + + " is installed. " + + "You can set PATH in ~/.bash_profile on Linux or Mac."; + if (failOnError) { + errorReporter.reportError(message); + } else { + errorReporter.reportWarning(message); + } } - - /** - * Create a LFCommand instance from a given command, an argument list and a directory. - *

    - * The command will be executed in the CWD and if the command cannot be found an error message is shown. - * - * @param cmd the command to look up - * @param args a list of arguments - * @param dir the directory to execute the command in. If null, this will default to the CWD - * @return an LFCommand object or null if the command could not be found - * @see #createCommand(String, List, Path, boolean) - */ - public LFCommand createCommand(String cmd, List args, Path dir) { - return createCommand(cmd, args, dir, true); - } - - - /** - * Create a LFCommand instance from a given command, an argument list and a directory. - *

    - * This will check first if the command can actually be found and executed. If the command is not found, null is - * returned. In addition, an error message will be shown if failOnError is true. Otherwise, a warning will be - * displayed. - * - * @param cmd the command to look up - * @param args a list of arguments - * @param dir the directory to execute the command in. If null, this will default to the CWD - * @param failOnError If true, an error is shown if the command cannot be found. Otherwise, only a warning is - * displayed. - * @return an LFCommand object or null if the command could not be found - * @see LFCommand#get(String, List, boolean, Path) - */ - public LFCommand createCommand(String cmd, List args, Path dir, boolean failOnError) { - assert cmd != null && args != null; - if (dir == null) { - dir = Paths.get(""); - } - LFCommand command = LFCommand.get(cmd, args, quiet, dir); - if (command != null) { - command.setEnvironmentVariable("LF_CURRENT_WORKING_DIRECTORY", dir.toString()); - command.setEnvironmentVariable("LF_SOURCE_DIRECTORY", fileConfig.srcPath.toString()); - command.setEnvironmentVariable("LF_PACKAGE_DIRECTORY", fileConfig.srcPkgPath.toString()); - command.setEnvironmentVariable("LF_SOURCE_GEN_DIRECTORY", fileConfig.getSrcGenPath().toString()); - command.setEnvironmentVariable("LF_BIN_DIRECTORY", fileConfig.binPath.toString()); - } else { - final String message = - "The command " + cmd + " could not be found in the current working directory or in your PATH. " + - "Make sure that your PATH variable includes the directory where " + cmd + " is installed. " + - "You can set PATH in ~/.bash_profile on Linux or Mac."; - if (failOnError) { - errorReporter.reportError(message); - } else { - errorReporter.reportWarning(message); - } - } - - return command; - } + return command; + } } diff --git a/org.lflang/src/org/lflang/generator/GeneratorResult.java b/org.lflang/src/org/lflang/generator/GeneratorResult.java index 2b42e17f34..b882510d50 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorResult.java +++ b/org.lflang/src/org/lflang/generator/GeneratorResult.java @@ -1,19 +1,9 @@ package org.lflang.generator; -import java.io.File; import java.nio.file.Path; import java.util.Collections; -import java.util.List; import java.util.Map; import java.util.function.BiFunction; -import java.util.function.Function; - -import org.eclipse.xtext.generator.GeneratorContext; - -import org.lflang.FileConfig; -import org.lflang.Target; -import org.lflang.TargetConfig; -import org.lflang.util.LFCommand; /** * A {@code GeneratorResult} is the outcome of a code generation task. @@ -21,101 +11,99 @@ * @author Peter Donovan */ public class GeneratorResult { - public static GeneratorResult NOTHING = incompleteGeneratorResult(Status.NOTHING); - public static GeneratorResult CANCELLED = incompleteGeneratorResult(Status.CANCELLED); - public static GeneratorResult FAILED = incompleteGeneratorResult(Status.FAILED); - public static BiFunction, GeneratorResult> GENERATED_NO_EXECUTABLE - = (context, codeMaps) -> new GeneratorResult(Status.GENERATED, context, codeMaps); - - /** - * A {@code Status} is a level of completion of a code generation task. - */ - public enum Status { - NOTHING(result -> ""), // Code generation was not performed. - CANCELLED(result -> "Code generation was cancelled."), - FAILED(result -> ""), // This may be due to a failed validation check, in which case the error should have been - // sent to the error reporter and handled there. This makes a message unnecessary. - GENERATED(GetUserMessage.COMPLETED), - COMPILED(GetUserMessage.COMPLETED); - - /** - * A {@code GetUserMessage} is a function that translates a - * {@code GeneratorResult} into a human-readable report for the end user. - */ - public interface GetUserMessage { - GetUserMessage COMPLETED = result -> { - return String.format( - "Code generation complete. The executable is at \"%s\".", - result.getContext().getFileConfig().getExecutable() - ); - }; - String apply(GeneratorResult result); - } - - /** The {@code GetUserMessage} associated with this {@code Status}. */ - private final GetUserMessage gum; - - /** Initializes a {@code Status} whose {@code GetUserMessage} is {@code gum}. */ - Status(GetUserMessage gum) { - this.gum = gum; - } - } - - private final Status status; - - private final LFGeneratorContext context; - - private final Map codeMaps; + public static GeneratorResult NOTHING = incompleteGeneratorResult(Status.NOTHING); + public static GeneratorResult CANCELLED = incompleteGeneratorResult(Status.CANCELLED); + public static GeneratorResult FAILED = incompleteGeneratorResult(Status.FAILED); + public static BiFunction, GeneratorResult> + GENERATED_NO_EXECUTABLE = + (context, codeMaps) -> new GeneratorResult(Status.GENERATED, context, codeMaps); + + /** A {@code Status} is a level of completion of a code generation task. */ + public enum Status { + NOTHING(result -> ""), // Code generation was not performed. + CANCELLED(result -> "Code generation was cancelled."), + FAILED( + result -> + ""), // This may be due to a failed validation check, in which case the error should + // have been + // sent to the error reporter and handled there. This makes a message unnecessary. + GENERATED(GetUserMessage.COMPLETED), + COMPILED(GetUserMessage.COMPLETED); /** - * Initialize a GeneratorResult. - * @param status The level of completion of a code generation task. - * @param context The context within which the result was produced. - * @param codeMaps A mapping from generated files to their CodeMaps. + * A {@code GetUserMessage} is a function that translates a {@code GeneratorResult} into a + * human-readable report for the end user. */ - public GeneratorResult(Status status, LFGeneratorContext context, Map codeMaps) { - this.status = status != null ? status : Status.NOTHING; - this.context = context; - this.codeMaps = codeMaps != null ? codeMaps : Collections.emptyMap(); + public interface GetUserMessage { + GetUserMessage COMPLETED = + result -> { + return String.format( + "Code generation complete. The executable is at \"%s\".", + result.getContext().getFileConfig().getExecutable()); + }; + + String apply(GeneratorResult result); } - /** - * Return the result of an incomplete generation task that terminated - * with status {@code status}. - * @return the result of an incomplete generation task that terminated - * with status {@code status} - */ - private static GeneratorResult incompleteGeneratorResult(Status status) { - return new GeneratorResult(status, null, Collections.emptyMap()); - } + /** The {@code GetUserMessage} associated with this {@code Status}. */ + private final GetUserMessage gum; - /** Return the status of {@code this}. */ - public Status getStatus() { - return status; + /** Initializes a {@code Status} whose {@code GetUserMessage} is {@code gum}. */ + Status(GetUserMessage gum) { + this.gum = gum; } - - /** - * Return a message that can be relayed to the end user about this - * {@code GeneratorResult}. - */ - public String getUserMessage() { - return status.gum.apply(this); - } - - /** - * Return a map from generated sources to their code maps. The - * completeness of this resulting map is given on a best-effort - * basis, but those mappings that it does contain are guaranteed - * to be correct. - * @return An unmodifiable map from generated sources to their - * code maps. - */ - public Map getCodeMaps() { - return Collections.unmodifiableMap(codeMaps); - } - - public LFGeneratorContext getContext() { - return context; - } - + } + + private final Status status; + + private final LFGeneratorContext context; + + private final Map codeMaps; + + /** + * Initialize a GeneratorResult. + * + * @param status The level of completion of a code generation task. + * @param context The context within which the result was produced. + * @param codeMaps A mapping from generated files to their CodeMaps. + */ + public GeneratorResult(Status status, LFGeneratorContext context, Map codeMaps) { + this.status = status != null ? status : Status.NOTHING; + this.context = context; + this.codeMaps = codeMaps != null ? codeMaps : Collections.emptyMap(); + } + + /** + * Return the result of an incomplete generation task that terminated with status {@code status}. + * + * @return the result of an incomplete generation task that terminated with status {@code status} + */ + private static GeneratorResult incompleteGeneratorResult(Status status) { + return new GeneratorResult(status, null, Collections.emptyMap()); + } + + /** Return the status of {@code this}. */ + public Status getStatus() { + return status; + } + + /** Return a message that can be relayed to the end user about this {@code GeneratorResult}. */ + public String getUserMessage() { + return status.gum.apply(this); + } + + /** + * Return a map from generated sources to their code maps. The completeness of this resulting map + * is given on a best-effort basis, but those mappings that it does contain are guaranteed to be + * correct. + * + * @return An unmodifiable map from generated sources to their code maps. + */ + public Map getCodeMaps() { + return Collections.unmodifiableMap(codeMaps); + } + + public LFGeneratorContext getContext() { + return context; + } } diff --git a/org.lflang/src/org/lflang/generator/GeneratorUtils.java b/org.lflang/src/org/lflang/generator/GeneratorUtils.java index b4563a6165..04ae33ba0c 100644 --- a/org.lflang/src/org/lflang/generator/GeneratorUtils.java +++ b/org.lflang/src/org/lflang/generator/GeneratorUtils.java @@ -4,19 +4,17 @@ import java.util.ArrayList; import java.util.HashSet; import java.util.List; - import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.IteratorExtensions; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.TargetConfig; import org.lflang.TargetProperty; +import org.lflang.ast.ASTUtils; import org.lflang.generator.LFGeneratorContext.Mode; import org.lflang.lf.Action; import org.lflang.lf.ActionOrigin; @@ -27,177 +25,162 @@ import org.lflang.lf.TargetDecl; /** - * A helper class with functions that may be useful for code - * generators. - * This is created to ease our transition from Xtend and - * possibly Eclipse. All functions in this class should - * instead be in GeneratorUtils.kt, but Eclipse cannot - * handle Kotlin files. + * A helper class with functions that may be useful for code generators. This is created to ease our + * transition from Xtend and possibly Eclipse. All functions in this class should instead be in + * GeneratorUtils.kt, but Eclipse cannot handle Kotlin files. */ public class GeneratorUtils { - private GeneratorUtils() { - // utility class - } + private GeneratorUtils() { + // utility class + } - /** - * Return the target declaration found in the given resource. - */ - public static TargetDecl findTargetDecl(Resource resource) { - return findAll(resource, TargetDecl.class).iterator().next(); - } + /** Return the target declaration found in the given resource. */ + public static TargetDecl findTargetDecl(Resource resource) { + return findAll(resource, TargetDecl.class).iterator().next(); + } - /** - * Look for physical actions in 'resource'. - * If appropriate, set keepalive to true in - * {@code targetConfig}. - * This is a helper function for setTargetConfig. It - * should not be used elsewhere. - */ - public static void accommodatePhysicalActionsIfPresent( - List resources, - boolean setsKeepAliveOptionAutomatically, - TargetConfig targetConfig, - ErrorReporter errorReporter - ) { - if (!setsKeepAliveOptionAutomatically) { - return; - } - for (Resource resource : resources) { - for (Action action : findAll(resource, Action.class)) { - if (action.getOrigin() == ActionOrigin.PHYSICAL && - // Check if the user has explicitly set keepalive to false - !targetConfig.setByUser.contains(TargetProperty.KEEPALIVE) && - !targetConfig.keepalive - ) { - // If not, set it to true - targetConfig.keepalive = true; - errorReporter.reportWarning( - action, - String.format( - "Setting %s to true because of the physical action %s.", - TargetProperty.KEEPALIVE.getDisplayName(), - action.getName() - ) - ); - return; - } - } + /** + * Look for physical actions in 'resource'. If appropriate, set keepalive to true in {@code + * targetConfig}. This is a helper function for setTargetConfig. It should not be used elsewhere. + */ + public static void accommodatePhysicalActionsIfPresent( + List resources, + boolean setsKeepAliveOptionAutomatically, + TargetConfig targetConfig, + ErrorReporter errorReporter) { + if (!setsKeepAliveOptionAutomatically) { + return; + } + for (Resource resource : resources) { + for (Action action : findAll(resource, Action.class)) { + if (action.getOrigin() == ActionOrigin.PHYSICAL + && + // Check if the user has explicitly set keepalive to false + !targetConfig.setByUser.contains(TargetProperty.KEEPALIVE) + && !targetConfig.keepalive) { + // If not, set it to true + targetConfig.keepalive = true; + errorReporter.reportWarning( + action, + String.format( + "Setting %s to true because of the physical action %s.", + TargetProperty.KEEPALIVE.getDisplayName(), action.getName())); + return; } + } } + } - /** - * Return all instances of {@code eObjectType} in - * {@code resource}. - * @param resource A resource to be searched. - * @param nodeType The type of the desired parse tree - * nodes. - * @param The type of the desired parse tree nodes. - * @return all instances of {@code eObjectType} in - * {@code resource} - */ - public static Iterable findAll(Resource resource, Class nodeType) { - return () -> IteratorExtensions.filter(resource.getAllContents(), nodeType); - } + /** + * Return all instances of {@code eObjectType} in {@code resource}. + * + * @param resource A resource to be searched. + * @param nodeType The type of the desired parse tree nodes. + * @param The type of the desired parse tree nodes. + * @return all instances of {@code eObjectType} in {@code resource} + */ + public static Iterable findAll(Resource resource, Class nodeType) { + return () -> IteratorExtensions.filter(resource.getAllContents(), nodeType); + } - /** - * Return the resources that provide the given - * reactors. - * @param reactors The reactors for which to find - * containing resources. - * @return the resources that provide the given - * reactors. - */ - public static List getResources(Iterable reactors) { - HashSet visited = new HashSet<>(); - List resources = new ArrayList<>(); - for (Reactor r : reactors) { - Resource resource = r.eResource(); - if (!visited.contains(resource)) { - visited.add(resource); - resources.add(resource); - } - } - return resources; + /** + * Return the resources that provide the given reactors. + * + * @param reactors The reactors for which to find containing resources. + * @return the resources that provide the given reactors. + */ + public static List getResources(Iterable reactors) { + HashSet visited = new HashSet<>(); + List resources = new ArrayList<>(); + for (Reactor r : reactors) { + Resource resource = r.eResource(); + if (!visited.contains(resource)) { + visited.add(resource); + resources.add(resource); + } } + return resources; + } - /** - * Return the {@code LFResource} representation of the - * given resource. - * @param resource The {@code Resource} to be - * represented as an {@code LFResource} - * @param srcGenBasePath The root directory for any - * generated sources associated with the resource. - * @param context The generator invocation context. - * @param errorReporter An error message acceptor. - * @return the {@code LFResource} representation of the - * given resource. - */ - public static LFResource getLFResource( - Resource resource, - Path srcGenBasePath, - LFGeneratorContext context, - ErrorReporter errorReporter - ) { - var target = ASTUtils.targetDecl(resource); - KeyValuePairs config = target.getConfig(); - var targetConfig = new TargetConfig(target); - if (config != null) { - List pairs = config.getPairs(); - TargetProperty.set(targetConfig, pairs != null ? pairs : List.of(), errorReporter); - } - FileConfig fc = LFGenerator.createFileConfig(resource, srcGenBasePath, context.getFileConfig().useHierarchicalBin); - return new LFResource(resource, fc, targetConfig); + /** + * Return the {@code LFResource} representation of the given resource. + * + * @param resource The {@code Resource} to be represented as an {@code LFResource} + * @param srcGenBasePath The root directory for any generated sources associated with the + * resource. + * @param context The generator invocation context. + * @param errorReporter An error message acceptor. + * @return the {@code LFResource} representation of the given resource. + */ + public static LFResource getLFResource( + Resource resource, + Path srcGenBasePath, + LFGeneratorContext context, + ErrorReporter errorReporter) { + var target = ASTUtils.targetDecl(resource); + KeyValuePairs config = target.getConfig(); + var targetConfig = new TargetConfig(target); + if (config != null) { + List pairs = config.getPairs(); + TargetProperty.set(targetConfig, pairs != null ? pairs : List.of(), errorReporter); } + FileConfig fc = + LFGenerator.createFileConfig( + resource, srcGenBasePath, context.getFileConfig().useHierarchicalBin); + return new LFResource(resource, fc, targetConfig); + } - /** - * If the mode is Mode.EPOCH (the code generator is running in an - * Eclipse IDE), then refresh the project. This will ensure that - * any generated files become visible in the project. - * @param resource The resource. - * @param compilerMode An indicator of whether Epoch is running. - */ - public static void refreshProject(Resource resource, Mode compilerMode) { - if (compilerMode == LFGeneratorContext.Mode.EPOCH) { - URI uri = resource.getURI(); - if (uri.isPlatformResource()) { // This condition should normally be met when running Epoch - IResource member = ResourcesPlugin.getWorkspace().getRoot().findMember(uri.toPlatformString(true)); - try { - member.getProject().refreshLocal(IResource.DEPTH_INFINITE, null); - } catch (CoreException e) { - System.err.println("Unable to refresh workspace: " + e); - } - } + /** + * If the mode is Mode.EPOCH (the code generator is running in an Eclipse IDE), then refresh the + * project. This will ensure that any generated files become visible in the project. + * + * @param resource The resource. + * @param compilerMode An indicator of whether Epoch is running. + */ + public static void refreshProject(Resource resource, Mode compilerMode) { + if (compilerMode == LFGeneratorContext.Mode.EPOCH) { + URI uri = resource.getURI(); + if (uri.isPlatformResource()) { // This condition should normally be met when running Epoch + IResource member = + ResourcesPlugin.getWorkspace().getRoot().findMember(uri.toPlatformString(true)); + try { + member.getProject().refreshLocal(IResource.DEPTH_INFINITE, null); + } catch (CoreException e) { + System.err.println("Unable to refresh workspace: " + e); } + } } + } - /** Return whether the operating system is Windows. */ - public static boolean isHostWindows() { - return System.getProperty("os.name").toLowerCase().contains("win"); - } + /** Return whether the operating system is Windows. */ + public static boolean isHostWindows() { + return System.getProperty("os.name").toLowerCase().contains("win"); + } - /** - * Check whether code can be generated; report any problems - * and inform the context accordingly. - * @return Whether it is possible to generate code. - */ - public static boolean canGenerate( - Boolean errorsOccurred, - Instantiation mainDef, - ErrorReporter errorReporter, - LFGeneratorContext context - ) { - // stop if there are any errors found in the program by doGenerate() in GeneratorBase - if (errorsOccurred) { - context.finish(GeneratorResult.FAILED); - return false; - } - // abort if there is no main reactor - if (mainDef == null) { - errorReporter.reportInfo("INFO: The given Lingua Franca program does not define a main reactor. Therefore, no code was generated."); - context.finish(GeneratorResult.NOTHING); - return false; - } - return true; + /** + * Check whether code can be generated; report any problems and inform the context accordingly. + * + * @return Whether it is possible to generate code. + */ + public static boolean canGenerate( + Boolean errorsOccurred, + Instantiation mainDef, + ErrorReporter errorReporter, + LFGeneratorContext context) { + // stop if there are any errors found in the program by doGenerate() in GeneratorBase + if (errorsOccurred) { + context.finish(GeneratorResult.FAILED); + return false; + } + // abort if there is no main reactor + if (mainDef == null) { + errorReporter.reportInfo( + "INFO: The given Lingua Franca program does not define a main reactor. Therefore, no code" + + " was generated."); + context.finish(GeneratorResult.NOTHING); + return false; } + return true; + } } diff --git a/org.lflang/src/org/lflang/generator/HumanReadableReportingStrategy.java b/org.lflang/src/org/lflang/generator/HumanReadableReportingStrategy.java index f6ecd0a991..8c1dd1e547 100644 --- a/org.lflang/src/org/lflang/generator/HumanReadableReportingStrategy.java +++ b/org.lflang/src/org/lflang/generator/HumanReadableReportingStrategy.java @@ -6,171 +6,163 @@ import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; - import org.eclipse.lsp4j.DiagnosticSeverity; import org.eclipse.xtext.xbase.lib.Procedures.Procedure0; import org.eclipse.xtext.xbase.lib.Procedures.Procedure2; - import org.lflang.ErrorReporter; /** - * An error reporting strategy that parses human-readable - * output. + * An error reporting strategy that parses human-readable output. * * @author Peter Donovan */ public class HumanReadableReportingStrategy implements DiagnosticReporting.Strategy { - /** A pattern that matches lines that should be reported via this strategy. */ - private final Pattern diagnosticMessagePattern; - /** A pattern that matches labels that show the exact range to which the diagnostic pertains. */ - private final Pattern labelPattern; - /** The path against which any paths should be resolved. */ - private final Path relativeTo; - /** The next line to be processed, or {@code null}. */ - private String bufferedLine; + /** A pattern that matches lines that should be reported via this strategy. */ + private final Pattern diagnosticMessagePattern; + /** A pattern that matches labels that show the exact range to which the diagnostic pertains. */ + private final Pattern labelPattern; + /** The path against which any paths should be resolved. */ + private final Path relativeTo; + /** The next line to be processed, or {@code null}. */ + private String bufferedLine; - /** - * Instantiate a reporting strategy for lines of - * validator output that match {@code diagnosticMessagePattern}. - * @param diagnosticMessagePattern A pattern that matches lines that should be - * reported via this strategy. This pattern - * must contain named capturing groups called - * "path", "line", "column", "message", and - * "severity". - * @param labelPattern A pattern that matches lines that act as labels, showing - * the location of the relevant piece of text. This pattern - * must contain two groups, the first of which must match - * characters that precede the location given by the "line" - * and "column" groups. - */ - public HumanReadableReportingStrategy(Pattern diagnosticMessagePattern, Pattern labelPattern) { - this(diagnosticMessagePattern, labelPattern, null); - } + /** + * Instantiate a reporting strategy for lines of validator output that match {@code + * diagnosticMessagePattern}. + * + * @param diagnosticMessagePattern A pattern that matches lines that should be reported via this + * strategy. This pattern must contain named capturing groups called "path", "line", "column", + * "message", and "severity". + * @param labelPattern A pattern that matches lines that act as labels, showing the location of + * the relevant piece of text. This pattern must contain two groups, the first of which must + * match characters that precede the location given by the "line" and "column" groups. + */ + public HumanReadableReportingStrategy(Pattern diagnosticMessagePattern, Pattern labelPattern) { + this(diagnosticMessagePattern, labelPattern, null); + } - /** - * Instantiate a reporting strategy for lines of - * validator output that match {@code diagnosticMessagePattern}. - * @param diagnosticMessagePattern a pattern that matches lines that should be - * reported via this strategy. This pattern - * must contain named capturing groups called - * "path", "line", "column", "message", and - * "severity". - * @param labelPattern A pattern that matches lines that act as labels, showing - * the location of the relevant piece of text. This pattern - * must contain two groups, the first of which must match - * characters that precede the location given by the "line" - * and "column" groups. - * @param relativeTo The path against which any paths should be resolved. - */ - public HumanReadableReportingStrategy(Pattern diagnosticMessagePattern, Pattern labelPattern, Path relativeTo) { - for (String groupName : new String[]{"path", "line", "column", "message", "severity"}) { - assert diagnosticMessagePattern.pattern().contains(groupName) : String.format( - "Error line patterns must have a named capturing group called %s", groupName - ); - } - this.diagnosticMessagePattern = diagnosticMessagePattern; - this.labelPattern = labelPattern; - this.relativeTo = relativeTo; - this.bufferedLine = null; + /** + * Instantiate a reporting strategy for lines of validator output that match {@code + * diagnosticMessagePattern}. + * + * @param diagnosticMessagePattern a pattern that matches lines that should be reported via this + * strategy. This pattern must contain named capturing groups called "path", "line", "column", + * "message", and "severity". + * @param labelPattern A pattern that matches lines that act as labels, showing the location of + * the relevant piece of text. This pattern must contain two groups, the first of which must + * match characters that precede the location given by the "line" and "column" groups. + * @param relativeTo The path against which any paths should be resolved. + */ + public HumanReadableReportingStrategy( + Pattern diagnosticMessagePattern, Pattern labelPattern, Path relativeTo) { + for (String groupName : new String[] {"path", "line", "column", "message", "severity"}) { + assert diagnosticMessagePattern.pattern().contains(groupName) + : String.format( + "Error line patterns must have a named capturing group called %s", groupName); } + this.diagnosticMessagePattern = diagnosticMessagePattern; + this.labelPattern = labelPattern; + this.relativeTo = relativeTo; + this.bufferedLine = null; + } - @Override - public void report(String validationOutput, ErrorReporter errorReporter, Map map) { - Iterator it = validationOutput.lines().iterator(); - while (it.hasNext() || bufferedLine != null) { - if (bufferedLine != null) { - reportErrorLine(bufferedLine, it, errorReporter, map); - bufferedLine = null; - } else { - reportErrorLine(it.next(), it, errorReporter, map); - } - } + @Override + public void report(String validationOutput, ErrorReporter errorReporter, Map map) { + Iterator it = validationOutput.lines().iterator(); + while (it.hasNext() || bufferedLine != null) { + if (bufferedLine != null) { + reportErrorLine(bufferedLine, it, errorReporter, map); + bufferedLine = null; + } else { + reportErrorLine(it.next(), it, errorReporter, map); + } } + } - /** - * Report the validation message contained in the given line of text. - * @param line The current line. - * @param it An iterator over the lines that follow the current line. - * @param errorReporter An arbitrary ErrorReporter. - * @param maps A mapping from generated file paths to - * CodeMaps. - */ - private void reportErrorLine(String line, Iterator it, ErrorReporter errorReporter, Map maps) { - Matcher matcher = diagnosticMessagePattern.matcher(stripEscaped(line)); - if (matcher.matches()) { - final Path path = Paths.get(matcher.group("path")); - final Position generatedFilePosition = Position.fromOneBased( - Integer.parseInt(matcher.group("line")), - Integer.parseInt(matcher.group("column") != null ? matcher.group("column") : "0") // FIXME: Unreliable heuristic - ); - final String message = DiagnosticReporting.messageOf( - matcher.group("message"), path, generatedFilePosition - ); - final CodeMap map = maps.get(relativeTo != null ? relativeTo.resolve(path) : path); - final DiagnosticSeverity severity = DiagnosticReporting.severityOf(matcher.group("severity")); - if (map == null) { - errorReporter.report(null, severity, message); - return; - } - for (Path srcFile : map.lfSourcePaths()) { - Position lfFilePosition = map.adjusted(srcFile, generatedFilePosition); - if (matcher.group("column") != null) { - reportAppropriateRange( - (p0, p1) -> errorReporter.report(srcFile, severity, message, p0, p1), lfFilePosition, it - ); - } else { - errorReporter.report(srcFile, severity, message, lfFilePosition.getOneBasedLine()); - } - } + /** + * Report the validation message contained in the given line of text. + * + * @param line The current line. + * @param it An iterator over the lines that follow the current line. + * @param errorReporter An arbitrary ErrorReporter. + * @param maps A mapping from generated file paths to CodeMaps. + */ + private void reportErrorLine( + String line, Iterator it, ErrorReporter errorReporter, Map maps) { + Matcher matcher = diagnosticMessagePattern.matcher(stripEscaped(line)); + if (matcher.matches()) { + final Path path = Paths.get(matcher.group("path")); + final Position generatedFilePosition = + Position.fromOneBased( + Integer.parseInt(matcher.group("line")), + Integer.parseInt( + matcher.group("column") != null + ? matcher.group("column") + : "0") // FIXME: Unreliable heuristic + ); + final String message = + DiagnosticReporting.messageOf(matcher.group("message"), path, generatedFilePosition); + final CodeMap map = maps.get(relativeTo != null ? relativeTo.resolve(path) : path); + final DiagnosticSeverity severity = DiagnosticReporting.severityOf(matcher.group("severity")); + if (map == null) { + errorReporter.report(null, severity, message); + return; + } + for (Path srcFile : map.lfSourcePaths()) { + Position lfFilePosition = map.adjusted(srcFile, generatedFilePosition); + if (matcher.group("column") != null) { + reportAppropriateRange( + (p0, p1) -> errorReporter.report(srcFile, severity, message, p0, p1), + lfFilePosition, + it); + } else { + errorReporter.report(srcFile, severity, message, lfFilePosition.getOneBasedLine()); } + } } + } - /** - * Report the appropriate range to {@code report}. - * @param report A reporting method whose first and - * second parameters are the (included) - * start and (excluded) end of the - * relevant range. - * @param lfFilePosition The point about which the - * relevant range is anchored. - * @param it An iterator over the lines immediately - * following a diagnostic message. - */ - private void reportAppropriateRange( - Procedure2 report, Position lfFilePosition, Iterator it - ) { - Procedure0 failGracefully = () -> report.apply(lfFilePosition, lfFilePosition.plus(" ")); - if (!it.hasNext()) { - failGracefully.apply(); - return; - } - String line = it.next(); - Matcher labelMatcher = labelPattern.matcher(line); - if (labelMatcher.find()) { - report.apply( - Position.fromZeroBased( - lfFilePosition.getZeroBasedLine(), - lfFilePosition.getZeroBasedColumn() - labelMatcher.group(1).length() - ), - lfFilePosition.plus(labelMatcher.group(2)) - ); - return; - } - if (diagnosticMessagePattern.matcher(line).find()) { - failGracefully.apply(); - bufferedLine = line; - return; - } - reportAppropriateRange(report, lfFilePosition, it); + /** + * Report the appropriate range to {@code report}. + * + * @param report A reporting method whose first and second parameters are the (included) start and + * (excluded) end of the relevant range. + * @param lfFilePosition The point about which the relevant range is anchored. + * @param it An iterator over the lines immediately following a diagnostic message. + */ + private void reportAppropriateRange( + Procedure2 report, Position lfFilePosition, Iterator it) { + Procedure0 failGracefully = () -> report.apply(lfFilePosition, lfFilePosition.plus(" ")); + if (!it.hasNext()) { + failGracefully.apply(); + return; } - - /** - * Strip the ANSI escape sequences from {@code s}. - * @param s Any string. - * @return {@code s}, with any escape sequences removed. - */ - private static String stripEscaped(String s) { - return s.replaceAll("\u001B\\[[;\\d]*[ -/]*[@-~]", ""); + String line = it.next(); + Matcher labelMatcher = labelPattern.matcher(line); + if (labelMatcher.find()) { + report.apply( + Position.fromZeroBased( + lfFilePosition.getZeroBasedLine(), + lfFilePosition.getZeroBasedColumn() - labelMatcher.group(1).length()), + lfFilePosition.plus(labelMatcher.group(2))); + return; } + if (diagnosticMessagePattern.matcher(line).find()) { + failGracefully.apply(); + bufferedLine = line; + return; + } + reportAppropriateRange(report, lfFilePosition, it); + } + + /** + * Strip the ANSI escape sequences from {@code s}. + * + * @param s Any string. + * @return {@code s}, with any escape sequences removed. + */ + private static String stripEscaped(String s) { + return s.replaceAll("\u001B\\[[;\\d]*[ -/]*[@-~]", ""); + } } diff --git a/org.lflang/src/org/lflang/generator/IntegratedBuilder.java b/org.lflang/src/org/lflang/generator/IntegratedBuilder.java index d6a2d3d681..f87c81728d 100644 --- a/org.lflang/src/org/lflang/generator/IntegratedBuilder.java +++ b/org.lflang/src/org/lflang/generator/IntegratedBuilder.java @@ -1,9 +1,10 @@ package org.lflang.generator; +import com.google.inject.Inject; +import com.google.inject.Provider; import java.nio.file.Path; import java.util.List; import java.util.Properties; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.resource.Resource; @@ -15,142 +16,133 @@ import org.eclipse.xtext.validation.CheckMode; import org.eclipse.xtext.validation.IResourceValidator; import org.eclipse.xtext.validation.Issue; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.generator.LFGeneratorContext.Mode; -import com.google.inject.Inject; -import com.google.inject.Provider; - /** - * Manages Lingua Franca build processes that are requested - * from the language server. + * Manages Lingua Franca build processes that are requested from the language server. * * @author Peter Donovan */ public class IntegratedBuilder { - public static final int START_PERCENT_PROGRESS = 0; - public static final int VALIDATED_PERCENT_PROGRESS = 33; - public static final int GENERATED_PERCENT_PROGRESS = 67; - public static final int COMPILED_PERCENT_PROGRESS = 100; - - /** - * A {@code ProgressReporter} reports the progress of a build. - */ - public interface ReportProgress { - void apply(String message, Integer percentage); - } - - // Note: This class is not currently used in response to - // document edits, even though the validator and code - // generator are invoked by Xtext in response to - // document edits. - /** - * A {@code ReportMethod} is a way of reporting issues. - */ - private interface ReportMethod { - void apply(Path file, Integer line, String message); - } - - /* ---------------------- INJECTED DEPENDENCIES ---------------------- */ - - @Inject - private IResourceValidator validator; - @Inject - private GeneratorDelegate generator; - @Inject - private JavaIoFileSystemAccess fileAccess; - @Inject - private Provider resourceSetProvider; - - /* ------------------------- PUBLIC METHODS -------------------------- */ - - /** - * Generates code from the Lingua Franca file {@code f}. - * @param uri The URI of a Lingua Franca file. - * @param mustComplete Whether the build must be taken to completion. - * @return The result of the build. - */ - public GeneratorResult run( - URI uri, - boolean mustComplete, - ReportProgress reportProgress, - CancelIndicator cancelIndicator - ) { - fileAccess.setOutputPath( - FileConfig.findPackageRoot(Path.of(uri.path()), s -> {}).resolve(FileConfig.DEFAULT_SRC_GEN_DIR).toString() - ); - List parseRoots = getResource(uri).getContents(); - if (parseRoots.isEmpty()) return GeneratorResult.NOTHING; - ErrorReporter errorReporter = new LanguageServerErrorReporter(parseRoots.get(0)); - reportProgress.apply("Validating...", START_PERCENT_PROGRESS); - validate(uri, errorReporter); - reportProgress.apply("Code validation complete.", VALIDATED_PERCENT_PROGRESS); - if (cancelIndicator.isCanceled()) return GeneratorResult.CANCELLED; - if (errorReporter.getErrorsOccurred()) return GeneratorResult.FAILED; - reportProgress.apply("Generating code...", VALIDATED_PERCENT_PROGRESS); - return doGenerate(uri, mustComplete, reportProgress, cancelIndicator); - } - - /* ------------------------- PRIVATE METHODS ------------------------- */ - - /** - * Validates the Lingua Franca file {@code f}. - * @param uri The URI of a Lingua Franca file. - * @param errorReporter The error reporter. - */ - private void validate(URI uri, ErrorReporter errorReporter) { - for (Issue issue : validator.validate(getResource(uri), CheckMode.ALL, CancelIndicator.NullImpl)) { - getReportMethod(errorReporter, issue.getSeverity()).apply( - Path.of(uri.path()), issue.getLineNumber(), issue.getMessage() - ); - } + public static final int START_PERCENT_PROGRESS = 0; + public static final int VALIDATED_PERCENT_PROGRESS = 33; + public static final int GENERATED_PERCENT_PROGRESS = 67; + public static final int COMPILED_PERCENT_PROGRESS = 100; + + /** A {@code ProgressReporter} reports the progress of a build. */ + public interface ReportProgress { + void apply(String message, Integer percentage); + } + + // Note: This class is not currently used in response to + // document edits, even though the validator and code + // generator are invoked by Xtext in response to + // document edits. + /** A {@code ReportMethod} is a way of reporting issues. */ + private interface ReportMethod { + void apply(Path file, Integer line, String message); + } + + /* ---------------------- INJECTED DEPENDENCIES ---------------------- */ + + @Inject private IResourceValidator validator; + @Inject private GeneratorDelegate generator; + @Inject private JavaIoFileSystemAccess fileAccess; + @Inject private Provider resourceSetProvider; + + /* ------------------------- PUBLIC METHODS -------------------------- */ + + /** + * Generates code from the Lingua Franca file {@code f}. + * + * @param uri The URI of a Lingua Franca file. + * @param mustComplete Whether the build must be taken to completion. + * @return The result of the build. + */ + public GeneratorResult run( + URI uri, + boolean mustComplete, + ReportProgress reportProgress, + CancelIndicator cancelIndicator) { + fileAccess.setOutputPath( + FileConfig.findPackageRoot(Path.of(uri.path()), s -> {}) + .resolve(FileConfig.DEFAULT_SRC_GEN_DIR) + .toString()); + List parseRoots = getResource(uri).getContents(); + if (parseRoots.isEmpty()) return GeneratorResult.NOTHING; + ErrorReporter errorReporter = new LanguageServerErrorReporter(parseRoots.get(0)); + reportProgress.apply("Validating...", START_PERCENT_PROGRESS); + validate(uri, errorReporter); + reportProgress.apply("Code validation complete.", VALIDATED_PERCENT_PROGRESS); + if (cancelIndicator.isCanceled()) return GeneratorResult.CANCELLED; + if (errorReporter.getErrorsOccurred()) return GeneratorResult.FAILED; + reportProgress.apply("Generating code...", VALIDATED_PERCENT_PROGRESS); + return doGenerate(uri, mustComplete, reportProgress, cancelIndicator); + } + + /* ------------------------- PRIVATE METHODS ------------------------- */ + + /** + * Validates the Lingua Franca file {@code f}. + * + * @param uri The URI of a Lingua Franca file. + * @param errorReporter The error reporter. + */ + private void validate(URI uri, ErrorReporter errorReporter) { + for (Issue issue : + validator.validate(getResource(uri), CheckMode.ALL, CancelIndicator.NullImpl)) { + getReportMethod(errorReporter, issue.getSeverity()) + .apply(Path.of(uri.path()), issue.getLineNumber(), issue.getMessage()); } - - /** - * Generates code from the contents of {@code f}. - * @param uri The URI of a Lingua Franca file. - * @param mustComplete Whether the build must be taken to completion. - * @param cancelIndicator An indicator that returns true when the build is - * cancelled. - * @return The result of the build. - */ - private GeneratorResult doGenerate( - URI uri, - boolean mustComplete, - ReportProgress reportProgress, - CancelIndicator cancelIndicator - ) { - var resource = getResource(uri); - LFGeneratorContext context = new MainContext( + } + + /** + * Generates code from the contents of {@code f}. + * + * @param uri The URI of a Lingua Franca file. + * @param mustComplete Whether the build must be taken to completion. + * @param cancelIndicator An indicator that returns true when the build is cancelled. + * @return The result of the build. + */ + private GeneratorResult doGenerate( + URI uri, + boolean mustComplete, + ReportProgress reportProgress, + CancelIndicator cancelIndicator) { + var resource = getResource(uri); + LFGeneratorContext context = + new MainContext( mustComplete ? Mode.LSP_SLOW : LFGeneratorContext.Mode.LSP_MEDIUM, - cancelIndicator, reportProgress, new Properties(), - resource, fileAccess, - fileConfig -> new LanguageServerErrorReporter(resource.getContents().get(0)) - ); - generator.generate(getResource(uri), fileAccess, context); - return context.getResult(); - } - - /** - * Returns the resource corresponding to {@code uri}. - * @param uri The URI of a Lingua Franca file. - * @return The resource corresponding to {@code uri}. - */ - private Resource getResource(URI uri) { - return resourceSetProvider.get().getResource(uri, true); - } - - /** - * Returns the appropriate reporting method for the - * given {@code Severity}. - * @param severity An arbitrary {@code Severity}. - * @return The appropriate reporting method for - * {@code severity}. - */ - private ReportMethod getReportMethod(ErrorReporter errorReporter, Severity severity) { - if (severity == Severity.ERROR) return errorReporter::reportError; - return errorReporter::reportWarning; - } + cancelIndicator, + reportProgress, + new Properties(), + resource, + fileAccess, + fileConfig -> new LanguageServerErrorReporter(resource.getContents().get(0))); + generator.generate(getResource(uri), fileAccess, context); + return context.getResult(); + } + + /** + * Returns the resource corresponding to {@code uri}. + * + * @param uri The URI of a Lingua Franca file. + * @return The resource corresponding to {@code uri}. + */ + private Resource getResource(URI uri) { + return resourceSetProvider.get().getResource(uri, true); + } + + /** + * Returns the appropriate reporting method for the given {@code Severity}. + * + * @param severity An arbitrary {@code Severity}. + * @return The appropriate reporting method for {@code severity}. + */ + private ReportMethod getReportMethod(ErrorReporter errorReporter, Severity severity) { + if (severity == Severity.ERROR) return errorReporter::reportError; + return errorReporter::reportWarning; + } } diff --git a/org.lflang/src/org/lflang/generator/InvalidLfSourceException.java b/org.lflang/src/org/lflang/generator/InvalidLfSourceException.java index 515bdbb8a0..61cf9632f2 100644 --- a/org.lflang/src/org/lflang/generator/InvalidLfSourceException.java +++ b/org.lflang/src/org/lflang/generator/InvalidLfSourceException.java @@ -27,32 +27,31 @@ import org.eclipse.emf.ecore.EObject; /** - * An exception that indicates invalid source, which should - * be reported to the user. This is an error, it should not - * be used for warnings. + * An exception that indicates invalid source, which should be reported to the user. This is an + * error, it should not be used for warnings. * * @author Clément Fournier */ public class InvalidLfSourceException extends RuntimeException { - private final EObject node; - private final String problem; + private final EObject node; + private final String problem; - public InvalidLfSourceException(EObject node, String problem) { - super(problem); - this.node = node; - this.problem = problem; - } + public InvalidLfSourceException(EObject node, String problem) { + super(problem); + this.node = node; + this.problem = problem; + } - public InvalidLfSourceException(String problem, EObject node) { - this(node, problem); - } + public InvalidLfSourceException(String problem, EObject node) { + this(node, problem); + } - public EObject getNode() { - return node; - } + public EObject getNode() { + return node; + } - public String getProblem() { - return problem; - } + public String getProblem() { + return problem; + } } diff --git a/org.lflang/src/org/lflang/generator/InvalidSourceException.java b/org.lflang/src/org/lflang/generator/InvalidSourceException.java index 11bedabce2..88b65d0c24 100644 --- a/org.lflang/src/org/lflang/generator/InvalidSourceException.java +++ b/org.lflang/src/org/lflang/generator/InvalidSourceException.java @@ -25,19 +25,17 @@ package org.lflang.generator; /** - * - * This exception is thrown when a program fails a validity check - * performed by a code generator (and not the validator). This should - * be thrown only when local control flow cannot recover, otherwise - * using {@link GeneratorBase#errorReporter} should be preferred, - * in order to collect more errors before failing. + * This exception is thrown when a program fails a validity check performed by a code generator (and + * not the validator). This should be thrown only when local control flow cannot recover, otherwise + * using {@link GeneratorBase#errorReporter} should be preferred, in order to collect more errors + * before failing. * * @author Clément Fournier */ public class InvalidSourceException extends RuntimeException { - /** Create a new instance of the exception with the given message. */ - public InvalidSourceException(String message) { - super(message); - } + /** Create a new instance of the exception with the given message. */ + public InvalidSourceException(String message) { + super(message); + } } diff --git a/org.lflang/src/org/lflang/generator/LFGenerator.java b/org.lflang/src/org/lflang/generator/LFGenerator.java index c8d985e80c..f2881c9fb8 100644 --- a/org.lflang/src/org/lflang/generator/LFGenerator.java +++ b/org.lflang/src/org/lflang/generator/LFGenerator.java @@ -1,19 +1,18 @@ package org.lflang.generator; +import com.google.inject.Inject; import java.io.IOException; import java.lang.reflect.Constructor; import java.nio.file.Path; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.AbstractGenerator; import org.eclipse.xtext.generator.IFileSystemAccess2; import org.eclipse.xtext.generator.IGeneratorContext; import org.eclipse.xtext.util.RuntimeIOException; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.Target; +import org.lflang.ast.ASTUtils; import org.lflang.federated.generator.FedASTUtils; import org.lflang.federated.generator.FedFileConfig; import org.lflang.federated.generator.FedGenerator; @@ -23,170 +22,179 @@ import org.lflang.generator.python.PythonGenerator; import org.lflang.scoping.LFGlobalScopeProvider; -import com.google.inject.Inject; - /** * Generates code from your model files on save. * - * See - * https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation + *

    See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation */ public class LFGenerator extends AbstractGenerator { - @Inject - private LFGlobalScopeProvider scopeProvider; - - // Indicator of whether generator errors occurred. - protected boolean generatorErrorsOccurred = false; - - /** - * Create a target-specific FileConfig object in Kotlin - *

    - * Since the CppFileConfig and TSFileConfig class are implemented in Kotlin, the classes are - * not visible from all contexts. If the RCA is run from within Eclipse via - * "Run as Eclipse Application", the Kotlin classes are unfortunately not - * available at runtime due to bugs in the Eclipse Kotlin plugin. (See - * https://stackoverflow.com/questions/68095816/is-ist-possible-to-build-mixed-kotlin-and-java-applications-with-a-recent-eclips) - *

    - * If the FileConfig class is found, this method returns an instance. - * Otherwise, it returns an Instance of FileConfig. - * - * @return A FileConfig object in Kotlin if the class can be found. - * @throws IOException If the file config could not be created properly - */ - public static FileConfig createFileConfig(Resource resource, Path srcGenBasePath, - boolean useHierarchicalBin) { - - final Target target = Target.fromDecl(ASTUtils.targetDecl(resource)); - assert target != null; - - // Since our Eclipse Plugin uses code injection via guice, we need to - // play a few tricks here so that FileConfig does not appear as an - // import. Instead, we look the class up at runtime and instantiate it if - // found. - try { - if (FedASTUtils.findFederatedReactor(resource) != null) { - return new FedFileConfig(resource, srcGenBasePath, useHierarchicalBin); - } - switch (target) { - case CCPP: - case C: return new CFileConfig(resource, srcGenBasePath, useHierarchicalBin); - case Python: return new PyFileConfig(resource, srcGenBasePath, useHierarchicalBin); - case CPP: - case Rust: - case TS: - String className = "org.lflang.generator." + target.packageName + "." + target.classNamePrefix + "FileConfig"; - try { - return (FileConfig) Class.forName(className) - .getDeclaredConstructor(Resource.class, Path.class, boolean.class) - .newInstance(resource, srcGenBasePath, useHierarchicalBin); - } catch (ReflectiveOperationException e) { - throw new RuntimeException( - "Exception instantiating " + className, e.getCause()); - } - default: - throw new RuntimeException("Could not find FileConfig implementation for target " + target); - } - } catch (IOException e) { - throw new RuntimeException("Unable to create FileConfig object for target " + target + ": " + e.getStackTrace()); - } + @Inject private LFGlobalScopeProvider scopeProvider; + + // Indicator of whether generator errors occurred. + protected boolean generatorErrorsOccurred = false; + + /** + * Create a target-specific FileConfig object in Kotlin + * + *

    Since the CppFileConfig and TSFileConfig class are implemented in Kotlin, the classes are + * not visible from all contexts. If the RCA is run from within Eclipse via "Run as Eclipse + * Application", the Kotlin classes are unfortunately not available at runtime due to bugs in the + * Eclipse Kotlin plugin. (See + * https://stackoverflow.com/questions/68095816/is-ist-possible-to-build-mixed-kotlin-and-java-applications-with-a-recent-eclips) + * + *

    If the FileConfig class is found, this method returns an instance. Otherwise, it returns an + * Instance of FileConfig. + * + * @return A FileConfig object in Kotlin if the class can be found. + * @throws IOException If the file config could not be created properly + */ + public static FileConfig createFileConfig( + Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) { + + final Target target = Target.fromDecl(ASTUtils.targetDecl(resource)); + assert target != null; + + // Since our Eclipse Plugin uses code injection via guice, we need to + // play a few tricks here so that FileConfig does not appear as an + // import. Instead, we look the class up at runtime and instantiate it if + // found. + try { + if (FedASTUtils.findFederatedReactor(resource) != null) { + return new FedFileConfig(resource, srcGenBasePath, useHierarchicalBin); + } + switch (target) { + case CCPP: + case C: + return new CFileConfig(resource, srcGenBasePath, useHierarchicalBin); + case Python: + return new PyFileConfig(resource, srcGenBasePath, useHierarchicalBin); + case CPP: + case Rust: + case TS: + String className = + "org.lflang.generator." + + target.packageName + + "." + + target.classNamePrefix + + "FileConfig"; + try { + return (FileConfig) + Class.forName(className) + .getDeclaredConstructor(Resource.class, Path.class, boolean.class) + .newInstance(resource, srcGenBasePath, useHierarchicalBin); + } catch (ReflectiveOperationException e) { + throw new RuntimeException("Exception instantiating " + className, e.getCause()); + } + default: + throw new RuntimeException( + "Could not find FileConfig implementation for target " + target); + } + } catch (IOException e) { + throw new RuntimeException( + "Unable to create FileConfig object for target " + target + ": " + e.getStackTrace()); } - - /** - * Create a generator object for the given target. - * Returns null if the generator could not be created. - */ - private GeneratorBase createGenerator(LFGeneratorContext context) { - final Target target = Target.fromDecl(ASTUtils.targetDecl(context.getFileConfig().resource)); - assert target != null; - return switch (target) { - case C -> new CGenerator(context, false); - case CCPP -> new CGenerator(context, true); - case Python -> new PythonGenerator(context); - case CPP, TS, Rust -> - createKotlinBaseGenerator(target, context); - // If no case matched, then throw a runtime exception. - default -> throw new RuntimeException("Unexpected target!"); - }; + } + + /** + * Create a generator object for the given target. Returns null if the generator could not be + * created. + */ + private GeneratorBase createGenerator(LFGeneratorContext context) { + final Target target = Target.fromDecl(ASTUtils.targetDecl(context.getFileConfig().resource)); + assert target != null; + return switch (target) { + case C -> new CGenerator(context, false); + case CCPP -> new CGenerator(context, true); + case Python -> new PythonGenerator(context); + case CPP, TS, Rust -> createKotlinBaseGenerator(target, context); + // If no case matched, then throw a runtime exception. + default -> throw new RuntimeException("Unexpected target!"); + }; + } + + /** + * Create a code generator in Kotlin. + * + *

    Since the CppGenerator and TSGenerator class are implemented in Kotlin, the classes are not + * visible from all contexts. If the RCA is run from within Eclipse via "Run as Eclipse + * Application", the Kotlin classes are unfortunately not available at runtime due to bugs in the + * Eclipse Kotlin plugin. (See + * https://stackoverflow.com/questions/68095816/is-ist-possible-to-build-mixed-kotlin-and-java-applications-with-a-recent-eclips) + * In this case, the method returns null + * + * @return A Kotlin Generator object if the class can be found + */ + private GeneratorBase createKotlinBaseGenerator(Target target, LFGeneratorContext context) { + // Since our Eclipse Plugin uses code injection via guice, we need to + // play a few tricks here so that Kotlin FileConfig and + // Kotlin Generator do not appear as an import. Instead, we look the + // class up at runtime and instantiate it if found. + String classPrefix = + "org.lflang.generator." + target.packageName + "." + target.classNamePrefix; + try { + Class generatorClass = Class.forName(classPrefix + "Generator"); + Constructor ctor = + generatorClass.getDeclaredConstructor( + LFGeneratorContext.class, LFGlobalScopeProvider.class); + + return (GeneratorBase) ctor.newInstance(context, scopeProvider); + } catch (ReflectiveOperationException e) { + generatorErrorsOccurred = true; + context + .getErrorReporter() + .reportError( + "The code generator for the " + + target + + " target could not be found. " + + "This is likely because you built Epoch using " + + "Eclipse. The " + + target + + " code generator is written in Kotlin and, unfortunately, the plugin that" + + " Eclipse uses for compiling Kotlin code is broken. Please consider building" + + " Epoch using Maven.\n" + + "For step-by-step instructions, see: " + + "https://github.com/icyphy/lingua-franca/wiki/Running-Lingua-Franca-IDE-%28Epoch%29-with-Kotlin-based-Code-Generators-Enabled-%28without-Eclipse-Environment%29"); + return null; + } + } + + @Override + public void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { + final LFGeneratorContext lfContext; + if (context instanceof LFGeneratorContext) { + lfContext = (LFGeneratorContext) context; + } else { + lfContext = LFGeneratorContext.lfGeneratorContextOf(resource, fsa, context); } + // The fastest way to generate code is to not generate any code. + if (lfContext.getMode() == LFGeneratorContext.Mode.LSP_FAST) return; - /** - * Create a code generator in Kotlin. - *

    - * Since the CppGenerator and TSGenerator class are implemented in Kotlin, the classes are - * not visible from all contexts. If the RCA is run from within Eclipse via - * "Run as Eclipse Application", the Kotlin classes are unfortunately not - * available at runtime due to bugs in the Eclipse Kotlin plugin. (See - * https://stackoverflow.com/questions/68095816/is-ist-possible-to-build-mixed-kotlin-and-java-applications-with-a-recent-eclips) - * In this case, the method returns null - * - * @return A Kotlin Generator object if the class can be found - */ - private GeneratorBase createKotlinBaseGenerator(Target target, LFGeneratorContext context) { - // Since our Eclipse Plugin uses code injection via guice, we need to - // play a few tricks here so that Kotlin FileConfig and - // Kotlin Generator do not appear as an import. Instead, we look the - // class up at runtime and instantiate it if found. - String classPrefix = "org.lflang.generator." + target.packageName + "." + target.classNamePrefix; - try { - Class generatorClass = Class.forName(classPrefix + "Generator"); - Constructor ctor = generatorClass - .getDeclaredConstructor(LFGeneratorContext.class, LFGlobalScopeProvider.class); - - return (GeneratorBase) ctor.newInstance(context, scopeProvider); - } catch (ReflectiveOperationException e) { - generatorErrorsOccurred = true; - context.getErrorReporter().reportError( - "The code generator for the " + target + " target could not be found. " - + "This is likely because you built Epoch using " - + "Eclipse. The " + target + " code generator is written in Kotlin " - + "and, unfortunately, the plugin that Eclipse uses " - + "for compiling Kotlin code is broken. " - + "Please consider building Epoch using Maven.\n" - + "For step-by-step instructions, see: " - + "https://github.com/icyphy/lingua-franca/wiki/Running-Lingua-Franca-IDE-%28Epoch%29-with-Kotlin-based-Code-Generators-Enabled-%28without-Eclipse-Environment%29"); - return null; - } - } + if (FedASTUtils.findFederatedReactor(resource) != null) { + try { + generatorErrorsOccurred = (new FedGenerator(lfContext)).doGenerate(resource, lfContext); + } catch (IOException e) { + throw new RuntimeIOException("Error during federated code generation", e); + } - @Override - public void doGenerate(Resource resource, IFileSystemAccess2 fsa, - IGeneratorContext context) { - final LFGeneratorContext lfContext; - if (context instanceof LFGeneratorContext) { - lfContext = (LFGeneratorContext)context; - } else { - lfContext = LFGeneratorContext.lfGeneratorContextOf(resource, fsa, context); - } - - // The fastest way to generate code is to not generate any code. - if (lfContext.getMode() == LFGeneratorContext.Mode.LSP_FAST) return; - - if (FedASTUtils.findFederatedReactor(resource) != null) { - try { - generatorErrorsOccurred = (new FedGenerator(lfContext)).doGenerate(resource, lfContext); - } catch (IOException e) { - throw new RuntimeIOException("Error during federated code generation", e); - } - - } else { - - final GeneratorBase generator = createGenerator(lfContext); - - if (generator != null) { - generator.doGenerate(resource, lfContext); - generatorErrorsOccurred = generator.errorsOccurred(); - } - } - final ErrorReporter errorReporter = lfContext.getErrorReporter(); - if (errorReporter instanceof LanguageServerErrorReporter) { - ((LanguageServerErrorReporter) errorReporter).publishDiagnostics(); - } - } + } else { - /** Return true if errors occurred in the last call to doGenerate(). */ - public boolean errorsOccurred() { - return generatorErrorsOccurred; + final GeneratorBase generator = createGenerator(lfContext); + + if (generator != null) { + generator.doGenerate(resource, lfContext); + generatorErrorsOccurred = generator.errorsOccurred(); + } + } + final ErrorReporter errorReporter = lfContext.getErrorReporter(); + if (errorReporter instanceof LanguageServerErrorReporter) { + ((LanguageServerErrorReporter) errorReporter).publishDiagnostics(); } + } + + /** Return true if errors occurred in the last call to doGenerate(). */ + public boolean errorsOccurred() { + return generatorErrorsOccurred; + } } diff --git a/org.lflang/src/org/lflang/generator/LFGeneratorContext.java b/org.lflang/src/org/lflang/generator/LFGeneratorContext.java index 84032ecdc6..727ce229b9 100644 --- a/org.lflang/src/org/lflang/generator/LFGeneratorContext.java +++ b/org.lflang/src/org/lflang/generator/LFGeneratorContext.java @@ -3,160 +3,146 @@ import java.nio.file.Path; import java.util.Map; import java.util.Properties; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.IFileSystemAccess2; import org.eclipse.xtext.generator.IGeneratorContext; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.TargetConfig; /** - * An {@code LFGeneratorContext} is the context of a Lingua Franca build process. - * It is the point of communication between a build process and the environment - * in which it is executed. + * An {@code LFGeneratorContext} is the context of a Lingua Franca build process. It is the point of + * communication between a build process and the environment in which it is executed. * * @author Peter Donovan */ public interface LFGeneratorContext extends IGeneratorContext { - /** - * Enumeration of keys used to parameterize the build process. - */ - enum BuildParm { - BUILD_TYPE("The build type to use"), - CLEAN("Clean before building."), - EXTERNAL_RUNTIME_PATH("Specify an external runtime library to be used by the compiled binary."), - FEDERATED("Treat main reactor as federated."), - HELP("Display this information."), - LOGGING("The logging level to use by the generated binary"), - LINT("Enable or disable linting of generated code."), - NO_COMPILE("Do not invoke target compiler."), - OUTPUT_PATH("Specify the root output directory."), - PRINT_STATISTICS("Instruct the runtime to collect and print statistics."), - QUIET("Suppress output of the target compiler and other commands"), - RTI("Specify the location of the RTI."), - RUNTIME_VERSION("Specify the version of the runtime library used for compiling LF programs."), - SCHEDULER("Specify the runtime scheduler (if supported)."), - TARGET_COMPILER("Target compiler to invoke."), - THREADING("Specify whether the runtime should use multi-threading (true/false)."), - VERSION("Print version information."), - WORKERS("Specify the default number of worker threads."); - - public final String description; - - BuildParm(String description) { - this.description = description; - } - - /** - * Return the string to use as the key to store a value relating to this parameter. - */ - public String getKey() { - return this.name().toLowerCase().replace('_', '-'); - } - - /** - * Return the value corresponding to this parameter or {@code null} if there is none. - * @param context The context passed to the code generator. - */ - public String getValue(LFGeneratorContext context) { - return context.getArgs().getProperty(this.getKey()); - } + /** Enumeration of keys used to parameterize the build process. */ + enum BuildParm { + BUILD_TYPE("The build type to use"), + CLEAN("Clean before building."), + EXTERNAL_RUNTIME_PATH("Specify an external runtime library to be used by the compiled binary."), + FEDERATED("Treat main reactor as federated."), + HELP("Display this information."), + LOGGING("The logging level to use by the generated binary"), + LINT("Enable or disable linting of generated code."), + NO_COMPILE("Do not invoke target compiler."), + OUTPUT_PATH("Specify the root output directory."), + PRINT_STATISTICS("Instruct the runtime to collect and print statistics."), + QUIET("Suppress output of the target compiler and other commands"), + RTI("Specify the location of the RTI."), + RUNTIME_VERSION("Specify the version of the runtime library used for compiling LF programs."), + SCHEDULER("Specify the runtime scheduler (if supported)."), + TARGET_COMPILER("Target compiler to invoke."), + THREADING("Specify whether the runtime should use multi-threading (true/false)."), + VERSION("Print version information."), + WORKERS("Specify the default number of worker threads."); + + public final String description; + + BuildParm(String description) { + this.description = description; } - - enum Mode { - STANDALONE, - EPOCH, - LSP_FAST, - LSP_MEDIUM, - LSP_SLOW, - UNDEFINED + /** Return the string to use as the key to store a value relating to this parameter. */ + public String getKey() { + return this.name().toLowerCase().replace('_', '-'); } /** - * Return the mode of operation, which indicates how the compiler has been invoked - * (e.g., from within Epoch, from the command line, or via a Language Server). - */ - Mode getMode(); - - /** - * Return any arguments that will override target properties. - */ - Properties getArgs(); - - /** - * Get the error reporter for this context; construct one if it hasn't been - * constructed yet. - */ - ErrorReporter getErrorReporter(); - - /** - * Mark the code generation process performed in this - * context as finished with the result {@code result}. - * @param result The result of the code generation - * process that was performed in this - * context. + * Return the value corresponding to this parameter or {@code null} if there is none. + * + * @param context The context passed to the code generator. */ - void finish(GeneratorResult result); - - /** - * Return the result of the code generation process that was performed in - * this context. - * @return the result of the code generation process that was performed in - * this context - */ - GeneratorResult getResult(); - - FileConfig getFileConfig(); - - TargetConfig getTargetConfig(); - - /** - * Report the progress of a build. - * @param message A message for the LF programmer to read. - * @param percentage The approximate percent completion of the build. - */ - void reportProgress(String message, int percentage); - - /** - * Conclude this build and record the result if necessary. - * @param status The status of the result. - * @param codeMaps The generated files and their corresponding code maps. - */ - default void finish( - GeneratorResult.Status status, - Map codeMaps - ) { - finish(new GeneratorResult(status, this, codeMaps)); - } - - /** - * Conclude this build and record that it was unsuccessful. - */ - default void unsuccessfulFinish() { - finish( - getCancelIndicator() != null && getCancelIndicator().isCanceled() ? - GeneratorResult.CANCELLED : GeneratorResult.FAILED - ); - } - - /** - * Return the {@code LFGeneratorContext} that best describes the given {@code context} when - * building {@code Resource}. - * @param resource - * @param fsa - * @param context The context of a Lingua Franca build process. - * @return The {@code LFGeneratorContext} that best describes the given {@code context} when - * building {@code Resource}. - */ - static LFGeneratorContext lfGeneratorContextOf(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { - if (context instanceof LFGeneratorContext) return (LFGeneratorContext) context; - - if (resource.getURI().isPlatform()) return new MainContext(Mode.EPOCH, resource, fsa, context.getCancelIndicator()); - - return new MainContext(Mode.LSP_FAST, resource, fsa, context.getCancelIndicator()); + public String getValue(LFGeneratorContext context) { + return context.getArgs().getProperty(this.getKey()); } + } + + enum Mode { + STANDALONE, + EPOCH, + LSP_FAST, + LSP_MEDIUM, + LSP_SLOW, + UNDEFINED + } + + /** + * Return the mode of operation, which indicates how the compiler has been invoked (e.g., from + * within Epoch, from the command line, or via a Language Server). + */ + Mode getMode(); + + /** Return any arguments that will override target properties. */ + Properties getArgs(); + + /** Get the error reporter for this context; construct one if it hasn't been constructed yet. */ + ErrorReporter getErrorReporter(); + + /** + * Mark the code generation process performed in this context as finished with the result {@code + * result}. + * + * @param result The result of the code generation process that was performed in this context. + */ + void finish(GeneratorResult result); + + /** + * Return the result of the code generation process that was performed in this context. + * + * @return the result of the code generation process that was performed in this context + */ + GeneratorResult getResult(); + + FileConfig getFileConfig(); + + TargetConfig getTargetConfig(); + + /** + * Report the progress of a build. + * + * @param message A message for the LF programmer to read. + * @param percentage The approximate percent completion of the build. + */ + void reportProgress(String message, int percentage); + + /** + * Conclude this build and record the result if necessary. + * + * @param status The status of the result. + * @param codeMaps The generated files and their corresponding code maps. + */ + default void finish(GeneratorResult.Status status, Map codeMaps) { + finish(new GeneratorResult(status, this, codeMaps)); + } + + /** Conclude this build and record that it was unsuccessful. */ + default void unsuccessfulFinish() { + finish( + getCancelIndicator() != null && getCancelIndicator().isCanceled() + ? GeneratorResult.CANCELLED + : GeneratorResult.FAILED); + } + + /** + * Return the {@code LFGeneratorContext} that best describes the given {@code context} when + * building {@code Resource}. + * + * @param resource + * @param fsa + * @param context The context of a Lingua Franca build process. + * @return The {@code LFGeneratorContext} that best describes the given {@code context} when + * building {@code Resource}. + */ + static LFGeneratorContext lfGeneratorContextOf( + Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { + if (context instanceof LFGeneratorContext) return (LFGeneratorContext) context; + + if (resource.getURI().isPlatform()) + return new MainContext(Mode.EPOCH, resource, fsa, context.getCancelIndicator()); + + return new MainContext(Mode.LSP_FAST, resource, fsa, context.getCancelIndicator()); + } } diff --git a/org.lflang/src/org/lflang/generator/LFResource.java b/org.lflang/src/org/lflang/generator/LFResource.java index bc59c418ee..42367dd24f 100644 --- a/org.lflang/src/org/lflang/generator/LFResource.java +++ b/org.lflang/src/org/lflang/generator/LFResource.java @@ -5,36 +5,43 @@ import org.lflang.TargetConfig; /** - * A class that keeps metadata for discovered resources - * during code generation and the supporting structures - * associated with that resource. - * + * A class that keeps metadata for discovered resources during code generation and the supporting + * structures associated with that resource. + * * @author Soroush Bateni */ public class LFResource { - LFResource(Resource resource, FileConfig fileConfig, TargetConfig targetConfig) { - this.eResource = resource; // FIXME: this is redundant because fileConfig already has the resource. - this.fileConfig = fileConfig; - this.targetConfig = targetConfig; - } - - /** - * Resource associated with a file either from the main .lf - * file or one of the imported ones. - */ - Resource eResource; - public Resource getEResource() { return this.eResource; }; - - /** - * The file config associated with 'resource' that can be - * used to discover files relative to that resource. - */ - FileConfig fileConfig; - public FileConfig getFileConfig() { return this.fileConfig; }; - - /** - * The target config read from the resource. - */ - TargetConfig targetConfig; - public TargetConfig getTargetConfig() { return this.targetConfig; }; + LFResource(Resource resource, FileConfig fileConfig, TargetConfig targetConfig) { + this.eResource = + resource; // FIXME: this is redundant because fileConfig already has the resource. + this.fileConfig = fileConfig; + this.targetConfig = targetConfig; + } + + /** Resource associated with a file either from the main .lf file or one of the imported ones. */ + Resource eResource; + + public Resource getEResource() { + return this.eResource; + } + ; + + /** + * The file config associated with 'resource' that can be used to discover files relative to that + * resource. + */ + FileConfig fileConfig; + + public FileConfig getFileConfig() { + return this.fileConfig; + } + ; + + /** The target config read from the resource. */ + TargetConfig targetConfig; + + public TargetConfig getTargetConfig() { + return this.targetConfig; + } + ; } diff --git a/org.lflang/src/org/lflang/generator/LanguageServerErrorReporter.java b/org.lflang/src/org/lflang/generator/LanguageServerErrorReporter.java index 5ce5da28dc..31304f43c9 100644 --- a/org.lflang/src/org/lflang/generator/LanguageServerErrorReporter.java +++ b/org.lflang/src/org/lflang/generator/LanguageServerErrorReporter.java @@ -6,16 +6,14 @@ import java.util.List; import java.util.Map; import java.util.Optional; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.EObject; import org.eclipse.lsp4j.Diagnostic; import org.eclipse.lsp4j.DiagnosticSeverity; import org.eclipse.lsp4j.PublishDiagnosticsParams; import org.eclipse.lsp4j.Range; -import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.eclipse.lsp4j.services.LanguageClient; - +import org.eclipse.xtext.nodemodel.util.NodeModelUtils; import org.lflang.ErrorReporter; /** @@ -25,179 +23,174 @@ */ public class LanguageServerErrorReporter implements ErrorReporter { - /** - * The language client to which errors should be - * reported, if such a client is available. - * FIXME: This is a de facto global, and it is a hack. - */ - private static LanguageClient client; - - /** The document for which this is a diagnostic acceptor. */ - private final EObject parseRoot; - /** The list of all diagnostics since the last reset. */ - private final Map> diagnostics; - - /* ------------------------ CONSTRUCTORS -------------------------- */ - - /** - * Initialize a {@code DiagnosticAcceptor} for the - * document whose parse tree root node is - * {@code parseRoot}. - * @param parseRoot the root of the AST of the document - * for which this is an error reporter - */ - public LanguageServerErrorReporter(EObject parseRoot) { - this.parseRoot = parseRoot; - this.diagnostics = new HashMap<>(); - } - - /* ----------------------- PUBLIC METHODS ------------------------- */ - - @Override - public String reportError(String message) { - return report(getMainFile(), DiagnosticSeverity.Error, message); - } - - @Override - public String reportWarning(String message) { - return report(getMainFile(), DiagnosticSeverity.Warning, message); - } - - @Override - public String reportInfo(String message) { - return report(getMainFile(), DiagnosticSeverity.Information, message); - } - - @Override - public String reportError(EObject object, String message) { - return reportError(message); - } - - @Override - public String reportWarning(EObject object, String message) { - return reportWarning(message); - } - - @Override - public String reportInfo(EObject object, String message) { - return reportInfo(message); - } - - @Override - public String reportError(Path file, Integer line, String message) { - return report(file, DiagnosticSeverity.Error, message, line != null ? line : 1); - } - - @Override - public String reportWarning(Path file, Integer line, String message) { - return report(file, DiagnosticSeverity.Warning, message, line != null ? line : 1); - } - - @Override - public String reportInfo(Path file, Integer line, String message) { - return report(file, DiagnosticSeverity.Information, message, line != null ? line : 1); - } - - @Override - public boolean getErrorsOccurred() { - return diagnostics.values().stream().anyMatch( - it -> it.stream().anyMatch(diagnostic -> diagnostic.getSeverity() == DiagnosticSeverity.Error) - ); - } - - @Override - public String report(Path file, DiagnosticSeverity severity, String message) { - return report(file, severity, message, 1); - } - - @Override - public String report(Path file, DiagnosticSeverity severity, String message, int line) { - Optional text = getLine(line - 1); - return report( - file, - severity, - message, - Position.fromOneBased(line, 1), - Position.fromOneBased(line, 1 + (text.isEmpty() ? 0 : text.get().length())) - ); - } - - @Override - public String report(Path file, DiagnosticSeverity severity, String message, Position startPos, Position endPos) { - if (file == null) file = getMainFile(); - diagnostics.putIfAbsent(file, new ArrayList<>()); - diagnostics.get(file).add(new Diagnostic( - toRange(startPos, endPos), message, severity, "LF Language Server" - )); - return "" + severity + ": " + message; - } - - /** - * Save a reference to the language client. - * @param client the language client - */ - public static void setClient(LanguageClient client) { - LanguageServerErrorReporter.client = client; - } - - /** - * Publish diagnostics by forwarding them to the - * language client. - */ - public void publishDiagnostics() { - if (client == null) { - System.err.println( - "WARNING: Cannot publish diagnostics because the language client has not yet been found." - ); - return; - } - for (Path file : diagnostics.keySet()) { - PublishDiagnosticsParams publishDiagnosticsParams = new PublishDiagnosticsParams(); - publishDiagnosticsParams.setUri(URI.createFileURI(file.toString()).toString()); - publishDiagnosticsParams.setDiagnostics(diagnostics.get(file)); - client.publishDiagnostics(publishDiagnosticsParams); - } - } - - /* ----------------------- PRIVATE METHODS ------------------------ */ - - /** Return the file on which the current validation process was triggered. */ - private Path getMainFile() { - return Path.of(parseRoot.eResource().getURI().toFileString()); - } - - /** - * Return the text of the document for which this is an - * error reporter. - * @return the text of the document for which this is an - * error reporter - */ - private String getText() { - return NodeModelUtils.getNode(parseRoot).getText(); - } - - /** - * Return the line at index {@code line} in the - * document for which this is an error reporter. - * @param line the zero-based line index - * @return the line located at the given index - */ - private Optional getLine(int line) { - return getText().lines().skip(line).findFirst(); - } - - /** - * Return the Range that starts at {@code p0} and ends - * at {@code p1}. - * @param p0 an arbitrary Position - * @param p1 a Position that is greater than {@code p0} - * @return the Range that starts at {@code p0} and ends - * at {@code p1} - */ - private Range toRange(Position p0, Position p1) { - return new Range( - new org.eclipse.lsp4j.Position(p0.getZeroBasedLine(), p0.getZeroBasedColumn()), - new org.eclipse.lsp4j.Position(p1.getZeroBasedLine(), p1.getZeroBasedColumn()) - ); - } + /** + * The language client to which errors should be reported, if such a client is available. FIXME: + * This is a de facto global, and it is a hack. + */ + private static LanguageClient client; + + /** The document for which this is a diagnostic acceptor. */ + private final EObject parseRoot; + /** The list of all diagnostics since the last reset. */ + private final Map> diagnostics; + + /* ------------------------ CONSTRUCTORS -------------------------- */ + + /** + * Initialize a {@code DiagnosticAcceptor} for the document whose parse tree root node is {@code + * parseRoot}. + * + * @param parseRoot the root of the AST of the document for which this is an error reporter + */ + public LanguageServerErrorReporter(EObject parseRoot) { + this.parseRoot = parseRoot; + this.diagnostics = new HashMap<>(); + } + + /* ----------------------- PUBLIC METHODS ------------------------- */ + + @Override + public String reportError(String message) { + return report(getMainFile(), DiagnosticSeverity.Error, message); + } + + @Override + public String reportWarning(String message) { + return report(getMainFile(), DiagnosticSeverity.Warning, message); + } + + @Override + public String reportInfo(String message) { + return report(getMainFile(), DiagnosticSeverity.Information, message); + } + + @Override + public String reportError(EObject object, String message) { + return reportError(message); + } + + @Override + public String reportWarning(EObject object, String message) { + return reportWarning(message); + } + + @Override + public String reportInfo(EObject object, String message) { + return reportInfo(message); + } + + @Override + public String reportError(Path file, Integer line, String message) { + return report(file, DiagnosticSeverity.Error, message, line != null ? line : 1); + } + + @Override + public String reportWarning(Path file, Integer line, String message) { + return report(file, DiagnosticSeverity.Warning, message, line != null ? line : 1); + } + + @Override + public String reportInfo(Path file, Integer line, String message) { + return report(file, DiagnosticSeverity.Information, message, line != null ? line : 1); + } + + @Override + public boolean getErrorsOccurred() { + return diagnostics.values().stream() + .anyMatch( + it -> + it.stream() + .anyMatch(diagnostic -> diagnostic.getSeverity() == DiagnosticSeverity.Error)); + } + + @Override + public String report(Path file, DiagnosticSeverity severity, String message) { + return report(file, severity, message, 1); + } + + @Override + public String report(Path file, DiagnosticSeverity severity, String message, int line) { + Optional text = getLine(line - 1); + return report( + file, + severity, + message, + Position.fromOneBased(line, 1), + Position.fromOneBased(line, 1 + (text.isEmpty() ? 0 : text.get().length()))); + } + + @Override + public String report( + Path file, DiagnosticSeverity severity, String message, Position startPos, Position endPos) { + if (file == null) file = getMainFile(); + diagnostics.putIfAbsent(file, new ArrayList<>()); + diagnostics + .get(file) + .add(new Diagnostic(toRange(startPos, endPos), message, severity, "LF Language Server")); + return "" + severity + ": " + message; + } + + /** + * Save a reference to the language client. + * + * @param client the language client + */ + public static void setClient(LanguageClient client) { + LanguageServerErrorReporter.client = client; + } + + /** Publish diagnostics by forwarding them to the language client. */ + public void publishDiagnostics() { + if (client == null) { + System.err.println( + "WARNING: Cannot publish diagnostics because the language client has not yet been" + + " found."); + return; + } + for (Path file : diagnostics.keySet()) { + PublishDiagnosticsParams publishDiagnosticsParams = new PublishDiagnosticsParams(); + publishDiagnosticsParams.setUri(URI.createFileURI(file.toString()).toString()); + publishDiagnosticsParams.setDiagnostics(diagnostics.get(file)); + client.publishDiagnostics(publishDiagnosticsParams); + } + } + + /* ----------------------- PRIVATE METHODS ------------------------ */ + + /** Return the file on which the current validation process was triggered. */ + private Path getMainFile() { + return Path.of(parseRoot.eResource().getURI().toFileString()); + } + + /** + * Return the text of the document for which this is an error reporter. + * + * @return the text of the document for which this is an error reporter + */ + private String getText() { + return NodeModelUtils.getNode(parseRoot).getText(); + } + + /** + * Return the line at index {@code line} in the document for which this is an error reporter. + * + * @param line the zero-based line index + * @return the line located at the given index + */ + private Optional getLine(int line) { + return getText().lines().skip(line).findFirst(); + } + + /** + * Return the Range that starts at {@code p0} and ends at {@code p1}. + * + * @param p0 an arbitrary Position + * @param p1 a Position that is greater than {@code p0} + * @return the Range that starts at {@code p0} and ends at {@code p1} + */ + private Range toRange(Position p0, Position p1) { + return new Range( + new org.eclipse.lsp4j.Position(p0.getZeroBasedLine(), p0.getZeroBasedColumn()), + new org.eclipse.lsp4j.Position(p1.getZeroBasedLine(), p1.getZeroBasedColumn())); + } } diff --git a/org.lflang/src/org/lflang/generator/LfExpressionVisitor.java b/org.lflang/src/org/lflang/generator/LfExpressionVisitor.java index 2bb72789ff..15f0e8ddad 100644 --- a/org.lflang/src/org/lflang/generator/LfExpressionVisitor.java +++ b/org.lflang/src/org/lflang/generator/LfExpressionVisitor.java @@ -40,121 +40,120 @@ */ public interface LfExpressionVisitor { - - R visitLiteral(Literal expr, P param); - - R visitBracedListExpr(BracedListExpression expr, P param); - - R visitTimeLiteral(Time expr, P param); - - R visitCodeExpr(CodeExpr expr, P param); - - R visitParameterRef(ParameterReference expr, P param); - - /** - * Dispatch the visitor on the given expression type. - * - * @param e An expression that will be visited - * @param arg Argument for the visitor - * @param visitor Visitor - * @param

    Type of parameter expected by the visitor - * @param Return type of the visitor - * @return The return value of the visitor - */ - static R dispatch(Expression e, P arg, LfExpressionVisitor visitor) { - if (e instanceof Literal) { - return visitor.visitLiteral((Literal) e, arg); - } else if (e instanceof BracedListExpression) { - return visitor.visitBracedListExpr((BracedListExpression) e, arg); - } else if (e instanceof Time) { - return visitor.visitTimeLiteral((Time) e, arg); - } else if (e instanceof CodeExpr) { - return visitor.visitCodeExpr((CodeExpr) e, arg); - } else if (e instanceof ParameterReference) { - return visitor.visitParameterRef((ParameterReference) e, arg); - } - - throw new IllegalArgumentException("Expression of type " + e.getClass() + " not handled"); + R visitLiteral(Literal expr, P param); + + R visitBracedListExpr(BracedListExpression expr, P param); + + R visitTimeLiteral(Time expr, P param); + + R visitCodeExpr(CodeExpr expr, P param); + + R visitParameterRef(ParameterReference expr, P param); + + /** + * Dispatch the visitor on the given expression type. + * + * @param e An expression that will be visited + * @param arg Argument for the visitor + * @param visitor Visitor + * @param

    Type of parameter expected by the visitor + * @param Return type of the visitor + * @return The return value of the visitor + */ + static R dispatch( + Expression e, P arg, LfExpressionVisitor visitor) { + if (e instanceof Literal) { + return visitor.visitLiteral((Literal) e, arg); + } else if (e instanceof BracedListExpression) { + return visitor.visitBracedListExpr((BracedListExpression) e, arg); + } else if (e instanceof Time) { + return visitor.visitTimeLiteral((Time) e, arg); + } else if (e instanceof CodeExpr) { + return visitor.visitCodeExpr((CodeExpr) e, arg); + } else if (e instanceof ParameterReference) { + return visitor.visitParameterRef((ParameterReference) e, arg); } - /** Base visitor class where methods are defaulted to a common one. */ - abstract class DefaultLfVisitor implements LfExpressionVisitor { + throw new IllegalArgumentException("Expression of type " + e.getClass() + " not handled"); + } + + /** Base visitor class where methods are defaulted to a common one. */ + abstract class DefaultLfVisitor implements LfExpressionVisitor { + + abstract R visitExpression(Expression expr, P param); - abstract R visitExpression(Expression expr, P param); + @Override + public R visitLiteral(Literal expr, P param) { + return visitExpression(expr, param); + } + + @Override + public R visitBracedListExpr(BracedListExpression expr, P param) { + return visitExpression(expr, param); + } - @Override - public R visitLiteral(Literal expr, P param) { - return visitExpression(expr, param); - } + @Override + public R visitTimeLiteral(Time expr, P param) { + return visitExpression(expr, param); + } - @Override - public R visitBracedListExpr(BracedListExpression expr, P param) { - return visitExpression(expr, param); - } + @Override + public R visitCodeExpr(CodeExpr expr, P param) { + return visitExpression(expr, param); + } - @Override - public R visitTimeLiteral(Time expr, P param) { - return visitExpression(expr, param); - } + @Override + public R visitParameterRef(ParameterReference expr, P param) { + return visitExpression(expr, param); + } + } + + /** + * A visitor that deep copies the expression. Can be extended to replace certain expressions + * during the copy. + * + * @param

    Parameter type + */ + class LfExpressionDeepCopyVisitor

    implements LfExpressionVisitor { + + @Override + public Expression visitLiteral(Literal expr, P param) { + Literal clone = LfFactory.eINSTANCE.createLiteral(); + clone.setLiteral(expr.getLiteral()); + return clone; + } - @Override - public R visitCodeExpr(CodeExpr expr, P param) { - return visitExpression(expr, param); - } + @Override + public Expression visitBracedListExpr(BracedListExpression expr, P param) { + BracedListExpression clone = LfFactory.eINSTANCE.createBracedListExpression(); + for (Expression item : expr.getItems()) { + clone.getItems().add(dispatch(item, param, this)); + } + return clone; + } - @Override - public R visitParameterRef(ParameterReference expr, P param) { - return visitExpression(expr, param); - } + @Override + public Expression visitTimeLiteral(Time expr, P param) { + Time clone = LfFactory.eINSTANCE.createTime(); + clone.setUnit(expr.getUnit()); + clone.setInterval(expr.getInterval()); + return clone; } - /** - * A visitor that deep copies the expression. Can be extended - * to replace certain expressions during the copy. - * - * @param

    Parameter type - */ - class LfExpressionDeepCopyVisitor

    implements LfExpressionVisitor { - - @Override - public Expression visitLiteral(Literal expr, P param) { - Literal clone = LfFactory.eINSTANCE.createLiteral(); - clone.setLiteral(expr.getLiteral()); - return clone; - } - - @Override - public Expression visitBracedListExpr(BracedListExpression expr, P param) { - BracedListExpression clone = LfFactory.eINSTANCE.createBracedListExpression(); - for (Expression item : expr.getItems()) { - clone.getItems().add(dispatch(item, param, this)); - } - return clone; - } - - @Override - public Expression visitTimeLiteral(Time expr, P param) { - Time clone = LfFactory.eINSTANCE.createTime(); - clone.setUnit(expr.getUnit()); - clone.setInterval(expr.getInterval()); - return clone; - } - - @Override - public Expression visitParameterRef(ParameterReference expr, P param) { - ParameterReference clone = LfFactory.eINSTANCE.createParameterReference(); - clone.setParameter(expr.getParameter()); - return clone; - } - - @Override - public Expression visitCodeExpr(CodeExpr expr, P param) { - CodeExpr codeExpr = LfFactory.eINSTANCE.createCodeExpr(); - Code code = LfFactory.eINSTANCE.createCode(); - code.setBody(expr.getCode().getBody()); - codeExpr.setCode(code); - return codeExpr; - } + @Override + public Expression visitParameterRef(ParameterReference expr, P param) { + ParameterReference clone = LfFactory.eINSTANCE.createParameterReference(); + clone.setParameter(expr.getParameter()); + return clone; } + @Override + public Expression visitCodeExpr(CodeExpr expr, P param) { + CodeExpr codeExpr = LfFactory.eINSTANCE.createCodeExpr(); + Code code = LfFactory.eINSTANCE.createCode(); + code.setBody(expr.getCode().getBody()); + codeExpr.setCode(code); + return codeExpr; + } + } } diff --git a/org.lflang/src/org/lflang/generator/MainContext.java b/org.lflang/src/org/lflang/generator/MainContext.java index 5ee53e5f83..4a60c4d6a8 100644 --- a/org.lflang/src/org/lflang/generator/MainContext.java +++ b/org.lflang/src/org/lflang/generator/MainContext.java @@ -4,12 +4,10 @@ import java.util.Objects; import java.util.Properties; import java.util.function.Function; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.IFileSystemAccess2; import org.eclipse.xtext.util.CancelIndicator; import org.eclipse.xtext.util.RuntimeIOException; - import org.lflang.DefaultErrorReporter; import org.lflang.ErrorReporter; import org.lflang.FileConfig; @@ -17,154 +15,156 @@ import org.lflang.generator.IntegratedBuilder.ReportProgress; /** - * A {@code MainContext} is an {@code LFGeneratorContext} that is - * not nested in any other generator context. There is one - * {@code MainContext} for every build process. + * A {@code MainContext} is an {@code LFGeneratorContext} that is not nested in any other generator + * context. There is one {@code MainContext} for every build process. * * @author Peter Donovan */ public class MainContext implements LFGeneratorContext { - - /** - * This constructor will be set by the LF plugin, if the generator is running in Epoch. - */ - public static Function EPOCH_ERROR_REPORTER_CONSTRUCTOR = null; - - /** - * The indicator that shows whether this build - * process is canceled. - */ - private final CancelIndicator cancelIndicator; - /** The {@code ReportProgress} function of {@code this}. */ - private final ReportProgress reportProgress; - - private final FileConfig fileConfig; - - /** Whether the requested build is required to be complete. */ - private final Mode mode; - - private TargetConfig targetConfig; - - /** The result of the code generation process. */ - private GeneratorResult result = null; - private final Properties args; - private final ErrorReporter errorReporter; - - /** - * Initialize the context of a build process whose cancellation is - * indicated by {@code cancelIndicator} - * @param mode The mode of this build process. - * @param cancelIndicator The cancel indicator of the code generation - * process to which this corresponds. - */ - public MainContext(Mode mode, Resource resource, IFileSystemAccess2 fsa, CancelIndicator cancelIndicator) { - this( - mode, cancelIndicator, (message, completion) -> {}, new Properties(), resource, fsa, - (mode == Mode.EPOCH && EPOCH_ERROR_REPORTER_CONSTRUCTOR != null) ? - EPOCH_ERROR_REPORTER_CONSTRUCTOR : - fileConfig -> new DefaultErrorReporter() - ); - } - - /** - * Initialize the context of a build process whose cancellation is - * indicated by {@code cancelIndicator} - * @param mode The mode of this build process. - * @param cancelIndicator The cancel indicator of the code generation - * process to which this corresponds. - * @param reportProgress The {@code ReportProgress} function of - * {@code this}. - * @param args Any arguments that may be used to affect the product of the - * build. - * @param resource ... - * @param fsa ... - * @param constructErrorReporter A function that constructs the appropriate - * error reporter for the given FileConfig. - */ - public MainContext( - Mode mode, - CancelIndicator cancelIndicator, - ReportProgress reportProgress, - Properties args, - Resource resource, - IFileSystemAccess2 fsa, - Function constructErrorReporter - ) { - this.mode = mode; - this.cancelIndicator = cancelIndicator == null ? () -> false : cancelIndicator; - this.reportProgress = reportProgress; - this.args = args; - - try { - var useHierarchicalBin = args.containsKey("hierarchical-bin") && Boolean.parseBoolean(args.getProperty("hierarchical-bin")); - fileConfig = Objects.requireNonNull(LFGenerator.createFileConfig(resource, FileConfig.getSrcGenRoot(fsa), useHierarchicalBin)); - } catch (IOException e) { - throw new RuntimeIOException("Error during FileConfig instantiation", e); - } - - this.errorReporter = constructErrorReporter.apply(this.fileConfig); - - loadTargetConfig(); - } - - @Override - public CancelIndicator getCancelIndicator() { - return cancelIndicator; - } - - @Override - public Mode getMode() { - return mode; - } - - @Override - public Properties getArgs() { - return args; - } - - @Override - public ErrorReporter getErrorReporter() { - return errorReporter; + /** This constructor will be set by the LF plugin, if the generator is running in Epoch. */ + public static Function EPOCH_ERROR_REPORTER_CONSTRUCTOR = null; + + /** The indicator that shows whether this build process is canceled. */ + private final CancelIndicator cancelIndicator; + /** The {@code ReportProgress} function of {@code this}. */ + private final ReportProgress reportProgress; + + private final FileConfig fileConfig; + + /** Whether the requested build is required to be complete. */ + private final Mode mode; + + private TargetConfig targetConfig; + + /** The result of the code generation process. */ + private GeneratorResult result = null; + + private final Properties args; + private final ErrorReporter errorReporter; + + /** + * Initialize the context of a build process whose cancellation is indicated by {@code + * cancelIndicator} + * + * @param mode The mode of this build process. + * @param cancelIndicator The cancel indicator of the code generation process to which this + * corresponds. + */ + public MainContext( + Mode mode, Resource resource, IFileSystemAccess2 fsa, CancelIndicator cancelIndicator) { + this( + mode, + cancelIndicator, + (message, completion) -> {}, + new Properties(), + resource, + fsa, + (mode == Mode.EPOCH && EPOCH_ERROR_REPORTER_CONSTRUCTOR != null) + ? EPOCH_ERROR_REPORTER_CONSTRUCTOR + : fileConfig -> new DefaultErrorReporter()); + } + + /** + * Initialize the context of a build process whose cancellation is indicated by {@code + * cancelIndicator} + * + * @param mode The mode of this build process. + * @param cancelIndicator The cancel indicator of the code generation process to which this + * corresponds. + * @param reportProgress The {@code ReportProgress} function of {@code this}. + * @param args Any arguments that may be used to affect the product of the build. + * @param resource ... + * @param fsa ... + * @param constructErrorReporter A function that constructs the appropriate error reporter for the + * given FileConfig. + */ + public MainContext( + Mode mode, + CancelIndicator cancelIndicator, + ReportProgress reportProgress, + Properties args, + Resource resource, + IFileSystemAccess2 fsa, + Function constructErrorReporter) { + this.mode = mode; + this.cancelIndicator = cancelIndicator == null ? () -> false : cancelIndicator; + this.reportProgress = reportProgress; + this.args = args; + + try { + var useHierarchicalBin = + args.containsKey("hierarchical-bin") + && Boolean.parseBoolean(args.getProperty("hierarchical-bin")); + fileConfig = + Objects.requireNonNull( + LFGenerator.createFileConfig( + resource, FileConfig.getSrcGenRoot(fsa), useHierarchicalBin)); + } catch (IOException e) { + throw new RuntimeIOException("Error during FileConfig instantiation", e); } - @Override - public void finish(GeneratorResult result) { - if (this.result != null) throw new IllegalStateException("A code generation process can only have one result."); - this.result = result; - reportProgress(result.getUserMessage(), 100); - } - - @Override - public GeneratorResult getResult() { - return result != null ? result : GeneratorResult.NOTHING; - } - - @Override - public FileConfig getFileConfig() { - return this.fileConfig; - } - - @Override - public TargetConfig getTargetConfig() { - return this.targetConfig; - } - - @Override - public void reportProgress(String message, int percentage) { - reportProgress.apply(message, percentage); - } - - /** - * Load the target configuration based on the contents of the resource. - * This is done automatically upon instantiation of the context, but - * in case the resource changes (e.g., due to an AST transformation), - * this method can be called to reload to ensure that the changes are - * reflected in the target configuration. - */ - public void loadTargetConfig() { - this.targetConfig = new TargetConfig( - args, GeneratorUtils.findTargetDecl(fileConfig.resource), errorReporter - ); - } + this.errorReporter = constructErrorReporter.apply(this.fileConfig); + + loadTargetConfig(); + } + + @Override + public CancelIndicator getCancelIndicator() { + return cancelIndicator; + } + + @Override + public Mode getMode() { + return mode; + } + + @Override + public Properties getArgs() { + return args; + } + + @Override + public ErrorReporter getErrorReporter() { + return errorReporter; + } + + @Override + public void finish(GeneratorResult result) { + if (this.result != null) + throw new IllegalStateException("A code generation process can only have one result."); + this.result = result; + reportProgress(result.getUserMessage(), 100); + } + + @Override + public GeneratorResult getResult() { + return result != null ? result : GeneratorResult.NOTHING; + } + + @Override + public FileConfig getFileConfig() { + return this.fileConfig; + } + + @Override + public TargetConfig getTargetConfig() { + return this.targetConfig; + } + + @Override + public void reportProgress(String message, int percentage) { + reportProgress.apply(message, percentage); + } + + /** + * Load the target configuration based on the contents of the resource. This is done automatically + * upon instantiation of the context, but in case the resource changes (e.g., due to an AST + * transformation), this method can be called to reload to ensure that the changes are reflected + * in the target configuration. + */ + public void loadTargetConfig() { + this.targetConfig = + new TargetConfig(args, GeneratorUtils.findTargetDecl(fileConfig.resource), errorReporter); + } } diff --git a/org.lflang/src/org/lflang/generator/MixedRadixInt.java b/org.lflang/src/org/lflang/generator/MixedRadixInt.java index 700012385c..c75ebd5864 100644 --- a/org.lflang/src/org/lflang/generator/MixedRadixInt.java +++ b/org.lflang/src/org/lflang/generator/MixedRadixInt.java @@ -34,241 +34,223 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Set; /** - * Representation of a permuted mixed radix (PMR) integer. - * A mixed radix number is a number representation where each digit can have - * a distinct radix. The radixes are given by a list of numbers, r0, r1, ... , rn, - * where r0 is the radix of the lowest-order digit and rn is the radix of the - * highest order digit that has a specified radix. + * Representation of a permuted mixed radix (PMR) integer. A mixed radix number is a number + * representation where each digit can have a distinct radix. The radixes are given by a list of + * numbers, r0, r1, ... , rn, where r0 is the radix of the lowest-order digit and rn is the radix of + * the highest order digit that has a specified radix. + * + *

    A PMR is a mixed radix number that, when incremented, increments the digits in the order given + * by the permutation matrix. For an ordinary mixed radix number, the permutation matrix is [0, 1, + * ..., n-1]. The permutation matrix may be any permutation of these digits, [d0, d1, ..., dn-1], in + * which case, when incremented, the d0 digit will be incremented first. If it overflows, it will be + * set to 0 and the d1 digit will be incremented. If it overflows, the next digit is incremented. If + * the last digit overflows, then the number wraps around so that all digits become zero. + * + *

    This implementation realizes a finite set of numbers, where incrementing past the end of the + * range wraps around to the beginning. As a consequence, the increment() function from any starting + * point is guaranteed to eventually cover all possible values. + * + *

    The {@link #toString()} method gives a string representation of the number where each digit is + * represented by the string "d%r", where d is the digit and r is the radix. For example, the number + * "1%2, 2%3, 1%4" has value 11, 1 + (2*2) + (1*2*3). * - * A PMR is a mixed radix number that, when incremented, - * increments the digits in the order given by the permutation matrix. - * For an ordinary mixed radix number, the permutation matrix is - * [0, 1, ..., n-1]. The permutation matrix may be any permutation of - * these digits, [d0, d1, ..., dn-1], in which case, when incremented, - * the d0 digit will be incremented first. If it overflows, it will be - * set to 0 and the d1 digit will be incremented. If it overflows, the - * next digit is incremented. If the last digit overflows, then the - * number wraps around so that all digits become zero. - * - * This implementation realizes a finite set of numbers, where incrementing - * past the end of the range wraps around to the beginning. As a consequence, - * the increment() function from any starting point is guaranteed to eventually - * cover all possible values. - * - * The {@link #toString()} method gives a string representation of the number - * where each digit is represented by the string "d%r", where d is the digit - * and r is the radix. For example, the number "1%2, 2%3, 1%4" has value 11, - * 1 + (2*2) + (1*2*3). - * * @author Edward A. Lee */ public class MixedRadixInt { - - /** - * Create a mixed radix number with the specified digits and radixes, - * which are given low-order digits first. - * If there is one more digit than radixes, throw an exception. - * @param digits The digits, or null to get a zero-valued number. - * @param radixes The radixes. - * @param permutation The permutation matrix, or null for the default permutation. - */ - public MixedRadixInt( - List digits, List radixes, List permutation - ) { - if (radixes == null - || (digits != null && digits.size() > radixes.size()) - || (permutation != null && permutation.size() != radixes.size()) - || radixes.contains(0)) { - throw new IllegalArgumentException("Invalid constructor arguments."); - } - this.radixes = radixes; - if (digits != null) { - this.digits = digits; - } else { - this.digits = new ArrayList(1); - this.digits.add(0); - } - if (permutation != null) { - // Check the permutation matrix. - Set indices = new HashSet(); - for (int p : permutation) { - if (p < 0 || p >= radixes.size() || indices.contains(p)) { - throw new IllegalArgumentException( - "Permutation list is required to be a permutation of [0, 1, ... , n-1]."); - } - indices.add(p); - } - this.permutation = permutation; - } - } - - /** - * A zero-valued mixed radix number with just one digit will radix 1. - */ - public final static MixedRadixInt ZERO = new MixedRadixInt(null, List.of(1), null); - - ////////////////////////////////////////////////////////// - //// Public methods - /** - * Get the value as an integer. - */ - public int get() { - return get(0); + /** + * Create a mixed radix number with the specified digits and radixes, which are given low-order + * digits first. If there is one more digit than radixes, throw an exception. + * + * @param digits The digits, or null to get a zero-valued number. + * @param radixes The radixes. + * @param permutation The permutation matrix, or null for the default permutation. + */ + public MixedRadixInt(List digits, List radixes, List permutation) { + if (radixes == null + || (digits != null && digits.size() > radixes.size()) + || (permutation != null && permutation.size() != radixes.size()) + || radixes.contains(0)) { + throw new IllegalArgumentException("Invalid constructor arguments."); } - - /** - * Get the value as an integer after dropping the first n digits. - * @param n The number of digits to drop. - */ - public int get(int n) { - int result = 0; - int scale = 1; - if (n < 0) n = 0; - for (int i = n; i < radixes.size(); i++) { - if (i >= digits.size()) return result; - result += digits.get(i) * scale; - scale *= radixes.get(i); - } - return result; + this.radixes = radixes; + if (digits != null) { + this.digits = digits; + } else { + this.digits = new ArrayList(1); + this.digits.add(0); } - - /** - * Return the digits. This is assured of returning as many - * digits as there are radixes. - */ - public List getDigits() { - while (digits.size() < radixes.size()) { - digits.add(0); + if (permutation != null) { + // Check the permutation matrix. + Set indices = new HashSet(); + for (int p : permutation) { + if (p < 0 || p >= radixes.size() || indices.contains(p)) { + throw new IllegalArgumentException( + "Permutation list is required to be a permutation of [0, 1, ... , n-1]."); } - return digits; + indices.add(p); + } + this.permutation = permutation; } - - /** - * Return the permutation list. - */ - public List getPermutation() { - if (permutation == null) { - // Construct a default permutation. - permutation = new ArrayList(radixes.size()); - for (int i = 0; i < radixes.size(); i++) { - permutation.add(i); - } - } - return permutation; + } + + /** A zero-valued mixed radix number with just one digit will radix 1. */ + public static final MixedRadixInt ZERO = new MixedRadixInt(null, List.of(1), null); + + ////////////////////////////////////////////////////////// + //// Public methods + + /** Get the value as an integer. */ + public int get() { + return get(0); + } + + /** + * Get the value as an integer after dropping the first n digits. + * + * @param n The number of digits to drop. + */ + public int get(int n) { + int result = 0; + int scale = 1; + if (n < 0) n = 0; + for (int i = n; i < radixes.size(); i++) { + if (i >= digits.size()) return result; + result += digits.get(i) * scale; + scale *= radixes.get(i); } - - /** - * Return the radixes. - */ - public List getRadixes() { - return radixes; + return result; + } + + /** Return the digits. This is assured of returning as many digits as there are radixes. */ + public List getDigits() { + while (digits.size() < radixes.size()) { + digits.add(0); } - - /** - * Increment the number by one, using the permutation vector to - * determine the order in which the digits are incremented. - * If an overflow occurs, then a radix-infinity digit will be added - * to the digits array if there isn't one there already. - */ - public void increment() { - int i = 0; - while (i < radixes.size()) { - int digit_to_increment = getPermutation().get(i); - while (digit_to_increment >= digits.size()) { - digits.add(0); - } - digits.set(digit_to_increment, digits.get(digit_to_increment) + 1); - if (digits.get(digit_to_increment) >= radixes.get(digit_to_increment)) { - digits.set(digit_to_increment, 0); - i++; - } else { - return; // All done. - } - } + return digits; + } + + /** Return the permutation list. */ + public List getPermutation() { + if (permutation == null) { + // Construct a default permutation. + permutation = new ArrayList(radixes.size()); + for (int i = 0; i < radixes.size(); i++) { + permutation.add(i); + } } - - /** - * Return the magnitude of this PMR, which is defined to be the number - * of times that increment() would need to invoked starting with zero - * before the value returned by {@link #get()} would be reached. - */ - public int magnitude() { - int factor = 1; - int result = 0; - List p = getPermutation(); - for (int i = 0; i < radixes.size(); i++) { - if (digits.size() <= i) return result; - result += factor * digits.get(p.get(i)); - factor *= radixes.get(p.get(i)); - } - return result; + return permutation; + } + + /** Return the radixes. */ + public List getRadixes() { + return radixes; + } + + /** + * Increment the number by one, using the permutation vector to determine the order in which the + * digits are incremented. If an overflow occurs, then a radix-infinity digit will be added to the + * digits array if there isn't one there already. + */ + public void increment() { + int i = 0; + while (i < radixes.size()) { + int digit_to_increment = getPermutation().get(i); + while (digit_to_increment >= digits.size()) { + digits.add(0); + } + digits.set(digit_to_increment, digits.get(digit_to_increment) + 1); + if (digits.get(digit_to_increment) >= radixes.get(digit_to_increment)) { + digits.set(digit_to_increment, 0); + i++; + } else { + return; // All done. + } } - - /** - * Return the number of digits in this mixed radix number. - * This is the size of the radixes list. - */ - public int numDigits() { - return radixes.size(); + } + + /** + * Return the magnitude of this PMR, which is defined to be the number of times that increment() + * would need to invoked starting with zero before the value returned by {@link #get()} would be + * reached. + */ + public int magnitude() { + int factor = 1; + int result = 0; + List p = getPermutation(); + for (int i = 0; i < radixes.size(); i++) { + if (digits.size() <= i) return result; + result += factor * digits.get(p.get(i)); + factor *= radixes.get(p.get(i)); } - - /** - * Set the value of this number to equal that of the specified integer. - * @param v The ordinary integer value of this number. - */ - public void set(int v) { - int temp = v; - int count = 0; - for (int radix : radixes) { - if (count >= digits.size()) { - digits.add(temp % radix); - } else { - digits.set(count, temp % radix); - } - count++; - temp = temp / radix; - } + return result; + } + + /** + * Return the number of digits in this mixed radix number. This is the size of the radixes list. + */ + public int numDigits() { + return radixes.size(); + } + + /** + * Set the value of this number to equal that of the specified integer. + * + * @param v The ordinary integer value of this number. + */ + public void set(int v) { + int temp = v; + int count = 0; + for (int radix : radixes) { + if (count >= digits.size()) { + digits.add(temp % radix); + } else { + digits.set(count, temp % radix); + } + count++; + temp = temp / radix; } - - /** - * Set the magnitude of this number to equal that of the specified integer, - * which is the number of times that increment must be invoked from zero - * for the value returned by {@link #get()} to equal v. - * @param v The new magnitude of this number. - */ - public void setMagnitude(int v) { - int temp = v; - for (int i = 0; i < radixes.size(); i++) { - int p = getPermutation().get(i); - while (digits.size() < p + 1) digits.add(0); - digits.set(p, temp % radixes.get(p)); - temp = temp / radixes.get(p); - } + } + + /** + * Set the magnitude of this number to equal that of the specified integer, which is the number of + * times that increment must be invoked from zero for the value returned by {@link #get()} to + * equal v. + * + * @param v The new magnitude of this number. + */ + public void setMagnitude(int v) { + int temp = v; + for (int i = 0; i < radixes.size(); i++) { + int p = getPermutation().get(i); + while (digits.size() < p + 1) digits.add(0); + digits.set(p, temp % radixes.get(p)); + temp = temp / radixes.get(p); } - - /** - * Give a string representation of the number, where each digit is - * represented as n%r, where r is the radix. - */ - @Override - public String toString() { - List pieces = new LinkedList(); - Iterator radixIterator = radixes.iterator(); - for (int digit : digits) { - if (! radixIterator.hasNext()) { - pieces.add(digit + "%infinity"); - } else { - pieces.add(digit + "%" + radixIterator.next()); - } - } - return String.join(", ", pieces); + } + + /** + * Give a string representation of the number, where each digit is represented as n%r, where r is + * the radix. + */ + @Override + public String toString() { + List pieces = new LinkedList(); + Iterator radixIterator = radixes.iterator(); + for (int digit : digits) { + if (!radixIterator.hasNext()) { + pieces.add(digit + "%infinity"); + } else { + pieces.add(digit + "%" + radixIterator.next()); + } } + return String.join(", ", pieces); + } - ////////////////////////////////////////////////////////// - //// Private variables + ////////////////////////////////////////////////////////// + //// Private variables - private List radixes; - private List digits; - private List permutation; + private List radixes; + private List digits; + private List permutation; } diff --git a/org.lflang/src/org/lflang/generator/ModeInstance.java b/org.lflang/src/org/lflang/generator/ModeInstance.java index 1f30f25802..932683f0ed 100644 --- a/org.lflang/src/org/lflang/generator/ModeInstance.java +++ b/org.lflang/src/org/lflang/generator/ModeInstance.java @@ -1,215 +1,206 @@ /************* -Copyright (c) 2021, Kiel University. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2021, Kiel University. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; import java.util.LinkedList; import java.util.List; - import org.lflang.lf.Mode; import org.lflang.lf.ModeTransition; import org.lflang.lf.VarRef; /** * Representation of a runtime instance of a mode. - * + * * @author Alexander Schulz-Rosengarten */ public class ModeInstance extends NamedInstance { - /** - * Create a new reaction instance from the specified definition - * within the specified parent. This constructor should be called - * only by the ReactorInstance class after all other contents - * (reactions, etc.) are registered because this constructor call - * will look them up. - * @param definition A mode definition. - * @param parent The parent reactor instance, which cannot be null. - */ - protected ModeInstance(Mode definition, ReactorInstance parent) { - super(definition, parent); - - collectMembers(); + /** + * Create a new reaction instance from the specified definition within the specified parent. This + * constructor should be called only by the ReactorInstance class after all other contents + * (reactions, etc.) are registered because this constructor call will look them up. + * + * @param definition A mode definition. + * @param parent The parent reactor instance, which cannot be null. + */ + protected ModeInstance(Mode definition, ReactorInstance parent) { + super(definition, parent); + + collectMembers(); + } + + //////////////////////////////////////////////////// + // Member fields. + + /** The action instances belonging to this mode instance. */ + public List actions = new LinkedList(); + + /** The reactor instances belonging to this mode instance, in order of declaration. */ + public List instantiations = new LinkedList(); + + /** List of reaction instances for this reactor instance. */ + public List reactions = new LinkedList(); + + /** The timer instances belonging to this reactor instance. */ + public List timers = new LinkedList(); + + /** The outgoing transitions of this mode. */ + public List transitions = new LinkedList(); + + //////////////////////////////////////////////////// + // Public methods. + + /** + * Return the name of this mode. + * + * @return The name of this mode. + */ + @Override + public String getName() { + return this.definition.getName(); + } + + /** {@inheritDoc} */ + @Override + public ReactorInstance root() { + return parent.root(); + } + + /** Return a descriptive string. */ + @Override + public String toString() { + return getName() + " of " + parent.getFullName(); + } + + /** Returns true iff this mode is the initial mode of this reactor instance. */ + public boolean isInitial() { + return definition.isInitial(); + } + + /** + * Sets up all transitions that leave this mode. Requires that all mode instances and other + * contents (reactions, etc.) of the parent reactor are created. + */ + public void setupTranstions() { + transitions.clear(); + for (var reaction : reactions) { + for (var effect : reaction.definition.getEffects()) { + if (effect instanceof VarRef) { + var target = effect.getVariable(); + if (target instanceof Mode) { + transitions.add( + new Transition(this, parent.lookupModeInstance((Mode) target), reaction, effect)); + } + } + } } - - //////////////////////////////////////////////////// - // Member fields. - - /** The action instances belonging to this mode instance. */ - public List actions = new LinkedList(); - - /** The reactor instances belonging to this mode instance, in order of declaration. */ - public List instantiations = new LinkedList(); - - /** List of reaction instances for this reactor instance. */ - public List reactions = new LinkedList(); - - /** The timer instances belonging to this reactor instance. */ - public List timers = new LinkedList(); - - /** The outgoing transitions of this mode. */ - public List transitions = new LinkedList(); - - //////////////////////////////////////////////////// - // Public methods. - - /** - * Return the name of this mode. - * @return The name of this mode. - */ - @Override - public String getName() { - return this.definition.getName(); + } + + /** Returns true iff this mode contains the given instance. */ + public boolean contains(NamedInstance instance) { + if (instance instanceof TimerInstance) { + return timers.contains(instance); + } else if (instance instanceof ActionInstance) { + return actions.contains(instance); + } else if (instance instanceof ReactorInstance) { + return instantiations.contains(instance); + } else if (instance instanceof ReactionInstance) { + return reactions.contains(instance); + } else { + return false; } - - /** - * {@inheritDoc} - */ - @Override - public ReactorInstance root() { - return parent.root(); + } + + //////////////////////////////////////////////////// + // Private methods. + + private void collectMembers() { + // Collect timers + for (var decl : definition.getTimers()) { + var instance = parent.lookupTimerInstance(decl); + if (instance != null) { + this.timers.add(instance); + } } - /** - * Return a descriptive string. - */ - @Override - public String toString() { - return getName() + " of " + parent.getFullName(); + // Collect actions + for (var decl : definition.getActions()) { + var instance = parent.lookupActionInstance(decl); + if (instance != null) { + this.actions.add(instance); + } } - - /** - * Returns true iff this mode is the initial mode of this reactor instance. - */ - public boolean isInitial() { - return definition.isInitial(); + + // Collect reactor instantiation + for (var decl : definition.getInstantiations()) { + var instance = parent.lookupReactorInstance(decl); + if (instance != null) { + this.instantiations.add(instance); + } } - - /** - * Sets up all transitions that leave this mode. - * Requires that all mode instances and other contents - * (reactions, etc.) of the parent reactor are created. - */ - public void setupTranstions() { - transitions.clear(); - for (var reaction : reactions) { - for (var effect : reaction.definition.getEffects()) { - if (effect instanceof VarRef) { - var target = effect.getVariable(); - if (target instanceof Mode) { - transitions.add(new Transition(this, parent.lookupModeInstance((Mode) target), reaction, effect)); - } - } - } - } + + // Collect reactions + for (var decl : definition.getReactions()) { + var instance = parent.lookupReactionInstance(decl); + if (instance != null) { + this.reactions.add(instance); + } } - - /** - * Returns true iff this mode contains the given instance. - */ - public boolean contains(NamedInstance instance) { - if (instance instanceof TimerInstance) { - return timers.contains(instance); - } else if (instance instanceof ActionInstance) { - return actions.contains(instance); - } else if (instance instanceof ReactorInstance) { - return instantiations.contains(instance); - } else if (instance instanceof ReactionInstance) { - return reactions.contains(instance); - } else { - return false; - } + } + + //////////////////////////////////////////////////// + // Data class. + + public static class Transition extends NamedInstance { + public final ModeInstance source; + public final ModeInstance target; + public final ReactionInstance reaction; + public final ModeTransition type; + + Transition( + ModeInstance source, ModeInstance target, ReactionInstance reaction, VarRef definition) { + super(definition, source.parent); + this.source = source; + this.target = target; + this.reaction = reaction; + this.type = + definition.getTransition() == null ? ModeTransition.RESET : definition.getTransition(); } - //////////////////////////////////////////////////// - // Private methods. - - private void collectMembers() { - // Collect timers - for (var decl : definition.getTimers()) { - var instance = parent.lookupTimerInstance(decl); - if (instance != null) { - this.timers.add(instance); - } - } - - // Collect actions - for (var decl : definition.getActions()) { - var instance = parent.lookupActionInstance(decl); - if (instance != null) { - this.actions.add(instance); - } - } - - // Collect reactor instantiation - for (var decl : definition.getInstantiations()) { - var instance = parent.lookupReactorInstance(decl); - if (instance != null) { - this.instantiations.add(instance); - } - } - - // Collect reactions - for (var decl : definition.getReactions()) { - var instance = parent.lookupReactionInstance(decl); - if (instance != null) { - this.reactions.add(instance); - } - } + @Override + public String getName() { + return this.source.getName() + " -> " + this.target + " by " + this.reaction.getName(); } - - //////////////////////////////////////////////////// - // Data class. - - public static class Transition extends NamedInstance { - public final ModeInstance source; - public final ModeInstance target; - public final ReactionInstance reaction; - public final ModeTransition type; - - Transition(ModeInstance source, ModeInstance target, ReactionInstance reaction, VarRef definition) { - super(definition, source.parent); - this.source = source; - this.target = target; - this.reaction = reaction; - this.type = definition.getTransition() == null ? ModeTransition.RESET : definition.getTransition(); - } - - @Override - public String getName() { - return this.source.getName() + " -> " + this.target + " by " + this.reaction.getName(); - } - - @Override - public ReactorInstance root() { - return this.parent.root(); - } - - public ModeTransition getType() { - return type; - } - + + @Override + public ReactorInstance root() { + return this.parent.root(); + } + + public ModeTransition getType() { + return type; } - + } } diff --git a/org.lflang/src/org/lflang/generator/NamedInstance.java b/org.lflang/src/org/lflang/generator/NamedInstance.java index 1d8c37321f..3455bcdf40 100644 --- a/org.lflang/src/org/lflang/generator/NamedInstance.java +++ b/org.lflang/src/org/lflang/generator/NamedInstance.java @@ -1,337 +1,319 @@ /* Base class for instances with names in Lingua Franca. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; import java.util.ArrayList; import java.util.HashMap; import java.util.List; - import org.eclipse.emf.ecore.EObject; -/** - * Base class for compile-time instances with names in Lingua Franca. - * An instance of concrete subclasses of this class represents one or - * more runtime instances of a reactor, port, reaction, etc. There - * will be more than one runtime instance if the object or any of its - * parents is a bank of reactors. - * +/** + * Base class for compile-time instances with names in Lingua Franca. An instance of concrete + * subclasses of this class represents one or more runtime instances of a reactor, port, reaction, + * etc. There will be more than one runtime instance if the object or any of its parents is a bank + * of reactors. + * * @author Marten Lohstroh * @author Edward A. Lee */ public abstract class NamedInstance { - - /** - * Construct a new instance with the specified definition - * and parent. E.g., for a reactor instance, the definition - * is Instantiation, and for a port instance, it is Port. These are - * nodes in the AST. This is protected because only subclasses - * should be constructed. - * @param definition The definition in the AST for this instance. - * @param parent The reactor instance that creates this instance. - */ - protected NamedInstance(T definition, ReactorInstance parent) { - this.definition = definition; - this.parent = parent; - - // Calculate the depth. - this.depth = 0; - ReactorInstance p = parent; - while (p != null) { - p = p.parent; - this.depth++; - } - } - - ////////////////////////////////////////////////////// - //// Public fields. - - /** A limit on the number of characters returned by uniqueID. */ - public static int identifierLengthLimit = 40; - - ////////////////////////////////////////////////////// - //// Public methods. - - /** - * Return the definition, which is the AST node for this object. - */ - public T getDefinition() { - return definition; - } - - /** - * Get the depth of the reactor instance. This is 0 for the main reactor, - * 1 for reactors immediately contained therein, etc. - */ - public int getDepth() { - return depth; - } - - /** - * Return the full name of this instance, which has the form - * "a.b.c", where "c" is the name of this instance, "b" is the name - * of its container, and "a" is the name of its container, stopping - * at the container in main. If any reactor in the hierarchy is - * in a bank of reactors then, it will appear as a[index]. - * Similarly, if c is a port in a multiport, it will appear as - * c[index]. - * @return The full name of this instance. - */ - public String getFullName() { - return getFullNameWithJoiner("."); - } - - /** - * Return the name of this instance as given in its definition. - * Note that this is unique only relative to other instances with - * the same parent. - * @return The name of this instance within its parent. - */ - public abstract String getName(); - - /** - * Return the parent or null if this is a top-level reactor. - */ - public ReactorInstance getParent() { - return parent; - } - - /** - * Return the parent at the given depth or null if there is - * no parent at the given depth. - * @param d The depth. - */ - public ReactorInstance getParent(int d) { - if (d >= depth || d < 0) return null; - ReactorInstance p = parent; - while (p != null) { - if (p.depth == d) return p; - p = p.parent; - } - return null; + + /** + * Construct a new instance with the specified definition and parent. E.g., for a reactor + * instance, the definition is Instantiation, and for a port instance, it is Port. These are nodes + * in the AST. This is protected because only subclasses should be constructed. + * + * @param definition The definition in the AST for this instance. + * @param parent The reactor instance that creates this instance. + */ + protected NamedInstance(T definition, ReactorInstance parent) { + this.definition = definition; + this.parent = parent; + + // Calculate the depth. + this.depth = 0; + ReactorInstance p = parent; + while (p != null) { + p = p.parent; + this.depth++; } + } + + ////////////////////////////////////////////////////// + //// Public fields. + + /** A limit on the number of characters returned by uniqueID. */ + public static int identifierLengthLimit = 40; + + ////////////////////////////////////////////////////// + //// Public methods. + + /** Return the definition, which is the AST node for this object. */ + public T getDefinition() { + return definition; + } - /** - * Return the width of this instance, which in this base class is 1. - * Subclasses PortInstance and ReactorInstance change this to the - * multiport and bank widths respectively. - */ - public int getWidth() { - return width; + /** + * Get the depth of the reactor instance. This is 0 for the main reactor, 1 for reactors + * immediately contained therein, etc. + */ + public int getDepth() { + return depth; + } + + /** + * Return the full name of this instance, which has the form "a.b.c", where "c" is the name of + * this instance, "b" is the name of its container, and "a" is the name of its container, stopping + * at the container in main. If any reactor in the hierarchy is in a bank of reactors then, it + * will appear as a[index]. Similarly, if c is a port in a multiport, it will appear as c[index]. + * + * @return The full name of this instance. + */ + public String getFullName() { + return getFullNameWithJoiner("."); + } + + /** + * Return the name of this instance as given in its definition. Note that this is unique only + * relative to other instances with the same parent. + * + * @return The name of this instance within its parent. + */ + public abstract String getName(); + + /** Return the parent or null if this is a top-level reactor. */ + public ReactorInstance getParent() { + return parent; + } + + /** + * Return the parent at the given depth or null if there is no parent at the given depth. + * + * @param d The depth. + */ + public ReactorInstance getParent(int d) { + if (d >= depth || d < 0) return null; + ReactorInstance p = parent; + while (p != null) { + if (p.depth == d) return p; + p = p.parent; } - - /** - * Return true if this instance has the specified parent - * (possibly indirectly, anywhere up the hierarchy). - */ - public boolean hasParent(ReactorInstance container) { - - ReactorInstance p = parent; - - while (p != null) { - if (p == container) return true; - p = p.parent; - } - return false; + return null; + } + + /** + * Return the width of this instance, which in this base class is 1. Subclasses PortInstance and + * ReactorInstance change this to the multiport and bank widths respectively. + */ + public int getWidth() { + return width; + } + + /** + * Return true if this instance has the specified parent (possibly indirectly, anywhere up the + * hierarchy). + */ + public boolean hasParent(ReactorInstance container) { + + ReactorInstance p = parent; + + while (p != null) { + if (p == container) return true; + p = p.parent; } - - /** - * Return a list of all the parents starting with the root(). - */ - public List parents() { - List result = new ArrayList(depth + 1); - if (this instanceof ReactorInstance && parent == null) { - // This is the top level, so it must be a reactor. - result.add((ReactorInstance) this); - } - ReactorInstance container = parent; - while (container != null) { - result.add(container); - container = container.parent; - } - return result; + return false; + } + + /** Return a list of all the parents starting with the root(). */ + public List parents() { + List result = new ArrayList(depth + 1); + if (this instanceof ReactorInstance && parent == null) { + // This is the top level, so it must be a reactor. + result.add((ReactorInstance) this); } - - /** - * Return the root reactor, which is the top-level parent. - * @return The top-level parent. - */ - public ReactorInstance root() { - if (parent != null) { - return parent.root(); - } else { - return (ReactorInstance)this; - } + ReactorInstance container = parent; + while (container != null) { + result.add(container); + container = container.parent; } - - /** - * Set the width. This method is here for testing only and should - * not be used for any other purpose. - * @param width The new width. - */ - public void setWidth(int width) { - this.width = width; + return result; + } + + /** + * Return the root reactor, which is the top-level parent. + * + * @return The top-level parent. + */ + public ReactorInstance root() { + if (parent != null) { + return parent.root(); + } else { + return (ReactorInstance) this; } + } - /** - * Return an identifier for this instance, which has the form "a_b_c" - * or "a_b_c_n", where "c" is the name of this instance, "b" is the name - * of its container, and "a" is the name of its container, stopping - * at the container in main. All names are converted to lower case. - * The suffix _n is usually omitted, but it is possible to get name - * collisions using the above scheme, in which case _n will be an - * increasing integer until there is no collision. - * If the length of the root of the name as calculated above (the root - * is without the _n suffix) is longer than - * the static variable identifierLengthLimit, then the name will be - * truncated. The returned name will be the tail of the name calculated - * above with the prefix '_'. - * @return An identifier for this instance that is guaranteed to be - * unique within the top-level parent. - */ - public String uniqueID() { - if (_uniqueID == null) { - // Construct the unique ID only if it has not been - // previously constructed. - String prefix = getFullNameWithJoiner("_").toLowerCase(); - - // Replace all non-alphanumeric (Latin) characters with underscore. - prefix = prefix.replaceAll("[^A-Za-z0-9]", "_"); - - // Truncate, if necessary. - if (prefix.length() > identifierLengthLimit) { - prefix = '_' - + prefix.substring(prefix.length() - identifierLengthLimit + 1); - } - - // Ensure uniqueness. - ReactorInstance toplevel = root(); - if (toplevel.uniqueIDCount == null) { - toplevel.uniqueIDCount = new HashMap(); - } - var count = toplevel.uniqueIDCount.get(prefix); - if (count == null) { - toplevel.uniqueIDCount.put(prefix, 1); - _uniqueID = prefix; - } else { - toplevel.uniqueIDCount.put(prefix, count + 1); - // NOTE: The length of this name could exceed - // identifierLengthLimit. Is this OK? - _uniqueID = prefix + '_' + (count + 1); - } - } - return _uniqueID; + /** + * Set the width. This method is here for testing only and should not be used for any other + * purpose. + * + * @param width The new width. + */ + public void setWidth(int width) { + this.width = width; + } + + /** + * Return an identifier for this instance, which has the form "a_b_c" or "a_b_c_n", where "c" is + * the name of this instance, "b" is the name of its container, and "a" is the name of its + * container, stopping at the container in main. All names are converted to lower case. The suffix + * _n is usually omitted, but it is possible to get name collisions using the above scheme, in + * which case _n will be an increasing integer until there is no collision. If the length of the + * root of the name as calculated above (the root is without the _n suffix) is longer than the + * static variable identifierLengthLimit, then the name will be truncated. The returned name will + * be the tail of the name calculated above with the prefix '_'. + * + * @return An identifier for this instance that is guaranteed to be unique within the top-level + * parent. + */ + public String uniqueID() { + if (_uniqueID == null) { + // Construct the unique ID only if it has not been + // previously constructed. + String prefix = getFullNameWithJoiner("_").toLowerCase(); + + // Replace all non-alphanumeric (Latin) characters with underscore. + prefix = prefix.replaceAll("[^A-Za-z0-9]", "_"); + + // Truncate, if necessary. + if (prefix.length() > identifierLengthLimit) { + prefix = '_' + prefix.substring(prefix.length() - identifierLengthLimit + 1); + } + + // Ensure uniqueness. + ReactorInstance toplevel = root(); + if (toplevel.uniqueIDCount == null) { + toplevel.uniqueIDCount = new HashMap(); + } + var count = toplevel.uniqueIDCount.get(prefix); + if (count == null) { + toplevel.uniqueIDCount.put(prefix, 1); + _uniqueID = prefix; + } else { + toplevel.uniqueIDCount.put(prefix, count + 1); + // NOTE: The length of this name could exceed + // identifierLengthLimit. Is this OK? + _uniqueID = prefix + '_' + (count + 1); + } } - - /** - * Returns the directly/indirectly enclosing mode. - * @param direct flag whether to check only for direct enclosing mode - * or also consider modes of parent reactor instances. - * @return The mode, if any, null otherwise. - */ - public ModeInstance getMode(boolean direct) { - ModeInstance mode = null; - if (parent != null) { - if (!parent.modes.isEmpty()) { - mode = parent.modes.stream().filter(it -> it.contains(this)).findFirst().orElse(null); - } - if (mode == null && !direct) { - mode = parent.getMode(false); - } - } - return mode; + return _uniqueID; + } + + /** + * Returns the directly/indirectly enclosing mode. + * + * @param direct flag whether to check only for direct enclosing mode or also consider modes of + * parent reactor instances. + * @return The mode, if any, null otherwise. + */ + public ModeInstance getMode(boolean direct) { + ModeInstance mode = null; + if (parent != null) { + if (!parent.modes.isEmpty()) { + mode = parent.modes.stream().filter(it -> it.contains(this)).findFirst().orElse(null); + } + if (mode == null && !direct) { + mode = parent.getMode(false); + } } + return mode; + } - ////////////////////////////////////////////////////// - //// Protected fields. - - /** The Instantiation AST object from which this was created. */ - T definition; - - /** The reactor instance that creates this instance. */ - ReactorInstance parent; - - /** - * Map from a name of the form a_b_c to the number of - * unique IDs with that prefix that have been already - * assigned. If none have been assigned, then there is - * no entry in this map. This map should be non-null only - * for the main reactor (the top level). - */ - HashMap uniqueIDCount; - - /** - * The width of this instance. This is 1 for everything - * except a PortInstance representing a multiport and a - * ReactorInstance representing a bank. - */ - int width = 1; - - ////////////////////////////////////////////////////// - //// Protected methods. - - /** - * Return a string of the form - * "a.b.c", where "." is replaced by the specified joiner, - * "c" is the name of this instance, "b" is the name - * of its container, and "a" is the name of its container, stopping - * at the container in main. - * @return A string representing this instance. - */ - protected String getFullNameWithJoiner(String joiner) { - // This is not cached because _uniqueID is cached. - if (parent == null) { - return this.getName(); - } else if (getMode(true) != null) { - return parent.getFullNameWithJoiner(joiner) + joiner + getMode(true).getName() + joiner + this.getName(); - } else { - return parent.getFullNameWithJoiner(joiner) + joiner + this.getName(); - } + ////////////////////////////////////////////////////// + //// Protected fields. + + /** The Instantiation AST object from which this was created. */ + T definition; + + /** The reactor instance that creates this instance. */ + ReactorInstance parent; + + /** + * Map from a name of the form a_b_c to the number of unique IDs with that prefix that have been + * already assigned. If none have been assigned, then there is no entry in this map. This map + * should be non-null only for the main reactor (the top level). + */ + HashMap uniqueIDCount; + + /** + * The width of this instance. This is 1 for everything except a PortInstance representing a + * multiport and a ReactorInstance representing a bank. + */ + int width = 1; + + ////////////////////////////////////////////////////// + //// Protected methods. + + /** + * Return a string of the form "a.b.c", where "." is replaced by the specified joiner, "c" is the + * name of this instance, "b" is the name of its container, and "a" is the name of its container, + * stopping at the container in main. + * + * @return A string representing this instance. + */ + protected String getFullNameWithJoiner(String joiner) { + // This is not cached because _uniqueID is cached. + if (parent == null) { + return this.getName(); + } else if (getMode(true) != null) { + return parent.getFullNameWithJoiner(joiner) + + joiner + + getMode(true).getName() + + joiner + + this.getName(); + } else { + return parent.getFullNameWithJoiner(joiner) + joiner + this.getName(); } + } + + ////////////////////////////////////////////////////// + //// Protected fields. + + /** + * The depth in the hierarchy of this instance. This is 0 for main or federated, 1 for the + * reactors immediately contained, etc. + */ + protected int depth = 0; + + ////////////////////////////////////////////////////// + //// Private fields. + + /** The full name of this instance. */ + private String _fullName = null; - ////////////////////////////////////////////////////// - //// Protected fields. - - /** - * The depth in the hierarchy of this instance. - * This is 0 for main or federated, 1 for the reactors immediately contained, etc. - */ - protected int depth = 0; - - ////////////////////////////////////////////////////// - //// Private fields. - - /** - * The full name of this instance. - */ - private String _fullName = null; - - /** - * Unique ID for this instance. This is null until - * uniqueID() is called. - */ - private String _uniqueID = null; -} \ No newline at end of file + /** Unique ID for this instance. This is null until uniqueID() is called. */ + private String _uniqueID = null; +} diff --git a/org.lflang/src/org/lflang/generator/ParameterInstance.java b/org.lflang/src/org/lflang/generator/ParameterInstance.java index 851fcb627e..92a1b03ed4 100644 --- a/org.lflang/src/org/lflang/generator/ParameterInstance.java +++ b/org.lflang/src/org/lflang/generator/ParameterInstance.java @@ -1,121 +1,118 @@ /** A data structure for a parameter instance. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; import java.util.List; import java.util.Optional; - -import org.lflang.ast.ASTUtils; import org.lflang.InferredType; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Assignment; import org.lflang.lf.Initializer; import org.lflang.lf.Parameter; /** - * Representation of a compile-time instance of a parameter. - * Upon creation, it is checked whether this parameter is overridden by an - * assignment in the instantiation that this parameter instance is a result of. - * If it is overridden, the parameter gets initialized using the value looked up - * in the instantiation hierarchy. + * Representation of a compile-time instance of a parameter. Upon creation, it is checked whether + * this parameter is overridden by an assignment in the instantiation that this parameter instance + * is a result of. If it is overridden, the parameter gets initialized using the value looked up in + * the instantiation hierarchy. + * * @author Marten Lohstroh * @author Edward A. Lee */ public class ParameterInstance extends NamedInstance { - /** - * Create a runtime instance from the specified definition - * and with the specified parent that instantiated it. - * @param definition The declaration in the AST. - * @param parent The reactor instance this parameter is a part of. - */ - public ParameterInstance(Parameter definition, ReactorInstance parent) { - super(definition, parent); - if (parent == null) { - throw new InvalidSourceException("Cannot create a ParameterInstance with no parent."); - } - - this.type = ASTUtils.getInferredType(definition); - } - - ///////////////////////////////////////////// - //// Public Fields - - public InferredType type; - - ///////////////////////////////////////////// - //// Public Methods - - /** - * Get the initial value of this parameter. - */ - private Initializer getInitialValue() { - return definition.getInit(); - } - - /** - * Return the (possibly overridden) value of this parameter - * in the containing instance. Parameter references are resolved - * to actual expressions. - */ - public Initializer getActualValue() { - Assignment override = getOverride(); - Initializer init; - if (override != null) { - init = override.getRhs(); - } else { - init = getInitialValue(); - } - return init; - } - - /** - * Return the name of this parameter. - * @return The name of this parameter. - */ - public String getName() { - return this.definition.getName(); - } - - /** - * Return the assignment that overrides this parameter in - * the parent's instantiation or null if there is no override. - */ - public Assignment getOverride() { - List assignments = parent.definition.getParameters(); - Optional assignment = assignments.stream().filter( - it -> it.getLhs() == definition - ).findFirst(); - return assignment.orElse(null); + /** + * Create a runtime instance from the specified definition and with the specified parent that + * instantiated it. + * + * @param definition The declaration in the AST. + * @param parent The reactor instance this parameter is a part of. + */ + public ParameterInstance(Parameter definition, ReactorInstance parent) { + super(definition, parent); + if (parent == null) { + throw new InvalidSourceException("Cannot create a ParameterInstance with no parent."); } - /** Return a descriptive string. */ - @Override - public String toString() { - return "ParameterInstance " + getFullName(); + this.type = ASTUtils.getInferredType(definition); + } + + ///////////////////////////////////////////// + //// Public Fields + + public InferredType type; + + ///////////////////////////////////////////// + //// Public Methods + + /** Get the initial value of this parameter. */ + private Initializer getInitialValue() { + return definition.getInit(); + } + + /** + * Return the (possibly overridden) value of this parameter in the containing instance. Parameter + * references are resolved to actual expressions. + */ + public Initializer getActualValue() { + Assignment override = getOverride(); + Initializer init; + if (override != null) { + init = override.getRhs(); + } else { + init = getInitialValue(); } + return init; + } + + /** + * Return the name of this parameter. + * + * @return The name of this parameter. + */ + public String getName() { + return this.definition.getName(); + } + + /** + * Return the assignment that overrides this parameter in the parent's instantiation or null if + * there is no override. + */ + public Assignment getOverride() { + List assignments = parent.definition.getParameters(); + Optional assignment = + assignments.stream().filter(it -> it.getLhs() == definition).findFirst(); + return assignment.orElse(null); + } + + /** Return a descriptive string. */ + @Override + public String toString() { + return "ParameterInstance " + getFullName(); + } } diff --git a/org.lflang/src/org/lflang/generator/PortInstance.java b/org.lflang/src/org/lflang/generator/PortInstance.java index 57dbdcf73d..60a904ef5b 100644 --- a/org.lflang/src/org/lflang/generator/PortInstance.java +++ b/org.lflang/src/org/lflang/generator/PortInstance.java @@ -1,35 +1,34 @@ /** A data structure for a port instance. */ /************* -Copyright (c) 2019-2022, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2022, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.PriorityQueue; - import org.lflang.ErrorReporter; import org.lflang.lf.Input; import org.lflang.lf.Output; @@ -38,422 +37,404 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.WidthSpec; import org.lflang.lf.WidthTerm; -/** - * Representation of a compile-time instance of a port. - * Like {@link ReactorInstance}, if one or more parents of this port - * is a bank of reactors, then there will be more than one runtime instance +/** + * Representation of a compile-time instance of a port. Like {@link ReactorInstance}, if one or more + * parents of this port is a bank of reactors, then there will be more than one runtime instance * corresponding to this compile-time instance. - * - * This may be a single port or a multiport. If it is a multiport, then - * one instance of this PortInstance class represents all channels. - * If in addition any parent is a bank, then it represents all channels of all - * bank members. The {@link #eventualDestinations()} and {@link #eventualSources()} - * functions report the connectivity of all such channels as lists of - * {@link SendRange} and {@link RuntimeRange} objects. - * + * + *

    This may be a single port or a multiport. If it is a multiport, then one instance of this + * PortInstance class represents all channels. If in addition any parent is a bank, then it + * represents all channels of all bank members. The {@link #eventualDestinations()} and {@link + * #eventualSources()} functions report the connectivity of all such channels as lists of {@link + * SendRange} and {@link RuntimeRange} objects. + * * @author Marten Lohstroh * @author Edward A. Lee */ public class PortInstance extends TriggerInstance { - /** - * Create a runtime instance from the specified definition - * and with the specified parent that instantiated it. - * @param definition The declaration in the AST. - * @param parent The parent. - */ - public PortInstance(Port definition, ReactorInstance parent) { - this(definition, parent, null); - } + /** + * Create a runtime instance from the specified definition and with the specified parent that + * instantiated it. + * + * @param definition The declaration in the AST. + * @param parent The parent. + */ + public PortInstance(Port definition, ReactorInstance parent) { + this(definition, parent, null); + } - /** - * Create a port instance from the specified definition - * and with the specified parent that instantiated it. - * @param definition The declaration in the AST. - * @param parent The parent. - * @param errorReporter An error reporter, or null to throw exceptions. - */ - public PortInstance(Port definition, ReactorInstance parent, ErrorReporter errorReporter) { - super(definition, parent); - - if (parent == null) { - throw new NullPointerException("Cannot create a PortInstance with no parent."); - } - - setInitialWidth(errorReporter); - } + /** + * Create a port instance from the specified definition and with the specified parent that + * instantiated it. + * + * @param definition The declaration in the AST. + * @param parent The parent. + * @param errorReporter An error reporter, or null to throw exceptions. + */ + public PortInstance(Port definition, ReactorInstance parent, ErrorReporter errorReporter) { + super(definition, parent); - ////////////////////////////////////////////////////// - //// Public methods - - /** - * Clear cached information about the connectivity of this port. - * In particular, {@link #eventualDestinations()} and {@link #eventualSources()} - * cache the lists they return. To force those methods to recompute - * their lists, call this method. This method also clears the caches - * of any ports that are listed as eventual destinations and sources. - */ - public void clearCaches() { - if (clearingCaches) return; // Prevent stack overflow. - clearingCaches = true; - try { - if (eventualSourceRanges != null) { - for (RuntimeRange sourceRange : eventualSourceRanges) { - sourceRange.instance.clearCaches(); - } - } - if (eventualDestinationRanges != null) { - for (SendRange sendRange : eventualDestinationRanges) { - for (RuntimeRange destinationRange : sendRange.destinations) { - destinationRange.instance.clearCaches(); - } - } - } - eventualDestinationRanges = null; - eventualSourceRanges = null; - } finally { - clearingCaches = false; - } + if (parent == null) { + throw new NullPointerException("Cannot create a PortInstance with no parent."); } - /** - * Return a list of ranges of this port, where each range sends - * to a list of destination ports that receive data from the range of - * this port. Each destination port is annotated with the channel - * range on which it receives data. - * The ports listed are only ports that are sources for reactions, - * not relay ports that the data may go through on the way. - * Also, if there is an "after" delay anywhere along the path, - * then the destination is not in the resulting list. - * - * If this port itself has dependent reactions, - * then this port will be included as a destination in all items - * on the returned list. - * - * Each item in the returned list has the following fields: - *

      - *
    • {@code startRange}: The starting channel index of this port.
      • - *
    • {@code rangeWidth}: The number of channels sent to the destinations.
      • - *
    • {@code destinations}: A list of port ranges for destination ports, each - * of which has the same width as {@code rangeWidth}.
      • - *
    - * - * Each item also has a method, {@link SendRange#getNumberOfDestinationReactors()}, - * that returns the total number of unique destination reactors for - * its range. This is not necessarily the same as the number - * of ports in its destinations field because some of the ports may - * share the same container reactor. - */ - public List eventualDestinations() { - if (eventualDestinationRanges != null) { - return eventualDestinationRanges; + setInitialWidth(errorReporter); + } + + ////////////////////////////////////////////////////// + //// Public methods + + /** + * Clear cached information about the connectivity of this port. In particular, {@link + * #eventualDestinations()} and {@link #eventualSources()} cache the lists they return. To force + * those methods to recompute their lists, call this method. This method also clears the caches of + * any ports that are listed as eventual destinations and sources. + */ + public void clearCaches() { + if (clearingCaches) return; // Prevent stack overflow. + clearingCaches = true; + try { + if (eventualSourceRanges != null) { + for (RuntimeRange sourceRange : eventualSourceRanges) { + sourceRange.instance.clearCaches(); } - - // Construct the full range for this port. - RuntimeRange range = new RuntimeRange.Port(this); - eventualDestinationRanges = eventualDestinations(range); - return eventualDestinationRanges; - } - - /** - * Return a list of ranges of ports that send data to this port. - * If this port is directly written to by one more more reactions, - * then it is its own eventual source and only this port - * will be represented in the result. - * - * If this is not a multiport and is not within a bank, then the list will have - * only one item and the range will have a total width of one. Otherwise, it will - * have enough items so that the range widths add up to the width of this - * multiport multiplied by the total number of instances within containing banks. - * - * The ports listed are only ports that are written to by reactions, - * not relay ports that the data may go through on the way. - */ - public List> eventualSources() { - return eventualSources(new RuntimeRange.Port(this)); + } + if (eventualDestinationRanges != null) { + for (SendRange sendRange : eventualDestinationRanges) { + for (RuntimeRange destinationRange : sendRange.destinations) { + destinationRange.instance.clearCaches(); + } + } + } + eventualDestinationRanges = null; + eventualSourceRanges = null; + } finally { + clearingCaches = false; } + } - /** - * Return the list of ranges of this port together with the - * downstream ports that are connected to this port. - * The total with of the ranges in the returned list is a - * multiple N >= 0 of the total width of this port. - */ - public List getDependentPorts() { - return dependentPorts; + /** + * Return a list of ranges of this port, where each range sends to a list of destination ports + * that receive data from the range of this port. Each destination port is annotated with the + * channel range on which it receives data. The ports listed are only ports that are sources for + * reactions, not relay ports that the data may go through on the way. Also, if there is an + * "after" delay anywhere along the path, then the destination is not in the resulting list. + * + *

    If this port itself has dependent reactions, then this port will be included as a + * destination in all items on the returned list. + * + *

    Each item in the returned list has the following fields: + * + *

      + *
    • {@code startRange}: The starting channel index of this port. + *
    • {@code rangeWidth}: The number of channels sent to the destinations. + *
    • {@code destinations}: A list of port ranges for destination ports, each of which has the + * same width as {@code rangeWidth}. + *
    + * + * Each item also has a method, {@link SendRange#getNumberOfDestinationReactors()}, that returns + * the total number of unique destination reactors for its range. This is not necessarily the same + * as the number of ports in its destinations field because some of the ports may share the same + * container reactor. + */ + public List eventualDestinations() { + if (eventualDestinationRanges != null) { + return eventualDestinationRanges; } - /** - * Return the list of upstream ports that are connected to this port, - * or an empty set if there are none. - * For an ordinary port, this list will have length 0 or 1. - * For a multiport, it can have a larger size. - */ - public List> getDependsOnPorts() { - return dependsOnPorts; - } - - /** - * Return true if the port is an input. - */ - public boolean isInput() { - return (definition instanceof Input); - } - - /** - * Return true if this is a multiport. - */ - public boolean isMultiport() { - return isMultiport; - } + // Construct the full range for this port. + RuntimeRange range = new RuntimeRange.Port(this); + eventualDestinationRanges = eventualDestinations(range); + return eventualDestinationRanges; + } + + /** + * Return a list of ranges of ports that send data to this port. If this port is directly written + * to by one more more reactions, then it is its own eventual source and only this port will be + * represented in the result. + * + *

    If this is not a multiport and is not within a bank, then the list will have only one item + * and the range will have a total width of one. Otherwise, it will have enough items so that the + * range widths add up to the width of this multiport multiplied by the total number of instances + * within containing banks. + * + *

    The ports listed are only ports that are written to by reactions, not relay ports that the + * data may go through on the way. + */ + public List> eventualSources() { + return eventualSources(new RuntimeRange.Port(this)); + } + + /** + * Return the list of ranges of this port together with the downstream ports that are connected to + * this port. The total with of the ranges in the returned list is a multiple N >= 0 of the total + * width of this port. + */ + public List getDependentPorts() { + return dependentPorts; + } + + /** + * Return the list of upstream ports that are connected to this port, or an empty set if there are + * none. For an ordinary port, this list will have length 0 or 1. For a multiport, it can have a + * larger size. + */ + public List> getDependsOnPorts() { + return dependsOnPorts; + } + + /** Return true if the port is an input. */ + public boolean isInput() { + return (definition instanceof Input); + } + + /** Return true if this is a multiport. */ + public boolean isMultiport() { + return isMultiport; + } + + /** Return true if the port is an output. */ + public boolean isOutput() { + return (definition instanceof Output); + } + + @Override + public String toString() { + return "PortInstance " + getFullName(); + } + + ////////////////////////////////////////////////////// + //// Protected fields. + + /** + * Ranges of this port together with downstream ports that are connected directly to this port. + * When there are multiple destinations, the destinations are listed in the order they appear in + * connections in the parent reactor instance of this port (inside connections), followed by the + * order in which they appear in the parent's parent (outside connections). The total of the + * widths of these SendRanges is an integer multiple N >= 0 of the width of this port (this is + * checked by the validator). Each channel of this port will be broadcast to N recipients (or, if + * there are no connections to zero recipients). + */ + List dependentPorts = new ArrayList(); + + /** + * Upstream ports that are connected directly to this port, if there are any. For an ordinary + * port, this set will have size 0 or 1. For a multiport, it can have a larger size. This + * initially has capacity 1 because that is by far the most common case. + */ + List> dependsOnPorts = new ArrayList>(1); + + /** Indicator of whether this is a multiport. */ + boolean isMultiport = false; - /** - * Return true if the port is an output. - */ - public boolean isOutput() { - return (definition instanceof Output); + ////////////////////////////////////////////////////// + //// Private methods. + + /** + * Given a RuntimeRange, return a list of SendRange that describes the eventual destinations of + * the given range. The sum of the total widths of the send ranges on the returned list will be an + * integer multiple N of the total width of the specified range. Each returned SendRange has a + * list of destination RuntimeRanges, each of which represents a port that has dependent + * reactions. Intermediate ports with no dependent reactions are not listed. + * + * @param srcRange The source range. + */ + private static List eventualDestinations(RuntimeRange srcRange) { + + // Getting the destinations is more complex than getting the sources + // because of multicast, where there is more than one connection statement + // for a source of data. The strategy we follow here is to first get all + // the ports that this port eventually sends to. Then, if needed, split + // the resulting ranges so that the resulting list covers exactly + // srcRange, possibly in pieces. We make two passes. First, we build + // a queue of ranges that may overlap, then we split those ranges + // and consolidate their destinations. + + List result = new ArrayList(); + PriorityQueue queue = new PriorityQueue(); + PortInstance srcPort = srcRange.instance; + + // Start with, if this port has dependent reactions, then add it to + // every range of the result. + if (!srcRange.instance.dependentReactions.isEmpty()) { + // This will be the final result if there are no connections. + SendRange candidate = + new SendRange( + srcRange.instance, + srcRange.start, + srcRange.width, + null, // No interleaving for this range. + null // No connection for this range. + ); + candidate.destinations.add(srcRange); + queue.add(candidate); } - - @Override - public String toString() { - return "PortInstance " + getFullName(); - } - - ////////////////////////////////////////////////////// - //// Protected fields. - - /** - * Ranges of this port together with downstream ports that - * are connected directly to this port. When there are multiple destinations, - * the destinations are listed in the order they appear in connections - * in the parent reactor instance of this port (inside connections), - * followed by the order in which they appear in the parent's parent (outside - * connections). The total of the widths of these SendRanges is an integer - * multiple N >= 0 of the width of this port (this is checked - * by the validator). Each channel of this port will be broadcast - * to N recipients (or, if there are no connections to zero recipients). - */ - List dependentPorts = new ArrayList(); - - /** - * Upstream ports that are connected directly to this port, if there are any. - * For an ordinary port, this set will have size 0 or 1. - * For a multiport, it can have a larger size. - * This initially has capacity 1 because that is by far the most common case. - */ - List> dependsOnPorts = new ArrayList>(1); - - /** Indicator of whether this is a multiport. */ - boolean isMultiport = false; - - ////////////////////////////////////////////////////// - //// Private methods. - - /** - * Given a RuntimeRange, return a list of SendRange that describes - * the eventual destinations of the given range. - * The sum of the total widths of the send ranges on the returned list - * will be an integer multiple N of the total width of the specified range. - * Each returned SendRange has a list - * of destination RuntimeRanges, each of which represents a port that - * has dependent reactions. Intermediate ports with no dependent - * reactions are not listed. - * @param srcRange The source range. - */ - private static List eventualDestinations(RuntimeRange srcRange) { - - // Getting the destinations is more complex than getting the sources - // because of multicast, where there is more than one connection statement - // for a source of data. The strategy we follow here is to first get all - // the ports that this port eventually sends to. Then, if needed, split - // the resulting ranges so that the resulting list covers exactly - // srcRange, possibly in pieces. We make two passes. First, we build - // a queue of ranges that may overlap, then we split those ranges - // and consolidate their destinations. - - List result = new ArrayList(); - PriorityQueue queue = new PriorityQueue(); - PortInstance srcPort = srcRange.instance; - - // Start with, if this port has dependent reactions, then add it to - // every range of the result. - if (!srcRange.instance.dependentReactions.isEmpty()) { - // This will be the final result if there are no connections. - SendRange candidate = new SendRange( - srcRange.instance, - srcRange.start, - srcRange.width, - null, // No interleaving for this range. - null // No connection for this range. - ); - candidate.destinations.add(srcRange); - queue.add(candidate); - } - // Need to find send ranges that overlap with this srcRange. - Iterator sendRanges = srcPort.dependentPorts.iterator(); - while (sendRanges.hasNext()) { - - SendRange wSendRange = sendRanges.next(); - - if (wSendRange.connection != null && wSendRange.connection.getDelay() != null) { - continue; - } - - wSendRange = wSendRange.overlap(srcRange); - if (wSendRange == null) { - // This send range does not overlap with the desired range. Try the next one. - continue; - } - for (RuntimeRange dstRange : wSendRange.destinations) { - // Recursively get the send ranges of that destination port. - List dstSendRanges = eventualDestinations(dstRange); - int sendRangeStart = 0; - for (SendRange dstSend : dstSendRanges) { - queue.add(dstSend.newSendRange(wSendRange, sendRangeStart)); - sendRangeStart += dstSend.width; - } - } + // Need to find send ranges that overlap with this srcRange. + Iterator sendRanges = srcPort.dependentPorts.iterator(); + while (sendRanges.hasNext()) { + + SendRange wSendRange = sendRanges.next(); + + if (wSendRange.connection != null && wSendRange.connection.getDelay() != null) { + continue; + } + + wSendRange = wSendRange.overlap(srcRange); + if (wSendRange == null) { + // This send range does not overlap with the desired range. Try the next one. + continue; + } + for (RuntimeRange dstRange : wSendRange.destinations) { + // Recursively get the send ranges of that destination port. + List dstSendRanges = eventualDestinations(dstRange); + int sendRangeStart = 0; + for (SendRange dstSend : dstSendRanges) { + queue.add(dstSend.newSendRange(wSendRange, sendRangeStart)); + sendRangeStart += dstSend.width; } + } + } - // Now check for overlapping ranges, constructing a new result. - SendRange candidate = queue.poll(); - SendRange next = queue.poll(); - while (candidate != null) { - if (next == null) { - // No more candidates. We are done. - result.add(candidate); - break; - } - if (candidate.start == next.start) { - // Ranges have the same starting point. Need to merge them. - if (candidate.width <= next.width) { - // Can use all of the channels of candidate. - // Import the destinations of next and split it. - for (RuntimeRange destination : next.destinations) { - candidate.destinations.add(destination.head(candidate.width)); - } - if (candidate.width < next.width) { - // The next range has more channels connected to this sender. - // Put it back on the queue an poll for a new next. - queue.add(next.tail(candidate.width)); - next = queue.poll(); - } else { - // We are done with next and can discard it. - next = queue.poll(); - } - } else { - // candidate is wider than next. Switch them and continue. - SendRange temp = candidate; - candidate = next; - next = temp; - } - } else { - // Because the result list is sorted, next starts at - // a higher channel than candidate. - if (candidate.start + candidate.width <= next.start) { - // Can use candidate as is and make next the new candidate. - result.add(candidate); - candidate = next; - next = queue.poll(); - } else { - // Ranges overlap. Can use a truncated candidate and make its - // truncated version the new candidate. - result.add(candidate.head(next.start)); - candidate = (SendRange)candidate.tail(next.start); - } - } + // Now check for overlapping ranges, constructing a new result. + SendRange candidate = queue.poll(); + SendRange next = queue.poll(); + while (candidate != null) { + if (next == null) { + // No more candidates. We are done. + result.add(candidate); + break; + } + if (candidate.start == next.start) { + // Ranges have the same starting point. Need to merge them. + if (candidate.width <= next.width) { + // Can use all of the channels of candidate. + // Import the destinations of next and split it. + for (RuntimeRange destination : next.destinations) { + candidate.destinations.add(destination.head(candidate.width)); + } + if (candidate.width < next.width) { + // The next range has more channels connected to this sender. + // Put it back on the queue an poll for a new next. + queue.add(next.tail(candidate.width)); + next = queue.poll(); + } else { + // We are done with next and can discard it. + next = queue.poll(); + } + } else { + // candidate is wider than next. Switch them and continue. + SendRange temp = candidate; + candidate = next; + next = temp; + } + } else { + // Because the result list is sorted, next starts at + // a higher channel than candidate. + if (candidate.start + candidate.width <= next.start) { + // Can use candidate as is and make next the new candidate. + result.add(candidate); + candidate = next; + next = queue.poll(); + } else { + // Ranges overlap. Can use a truncated candidate and make its + // truncated version the new candidate. + result.add(candidate.head(next.start)); + candidate = (SendRange) candidate.tail(next.start); } - - return result; + } } - /** - * Return a list of ranges of ports that send data to this port within the - * specified range. If this port is directly written to by one more more reactions, - * then it is its own eventual source and only this port - * will be represented in the result. - * - * If this is not a multiport and is not within a bank, then the list will have - * only one item and the range will have a total width of one. Otherwise, it will - * have enough items so that the range widths add up to the width of this - * multiport multiplied by the total number of instances within containing banks. - * - * The ports listed are only ports that are written to by reactions, - * not relay ports that the data may go through on the way. - */ - private List> eventualSources(RuntimeRange range) { - if (eventualSourceRanges == null) { - // Cached result has not been created. - eventualSourceRanges = new ArrayList>(); - - if (!dependsOnReactions.isEmpty()) { - eventualSourceRanges.add(new RuntimeRange.Port(this)); - } else { - var channelsCovered = 0; - for (RuntimeRange sourceRange : dependsOnPorts) { - // Check whether the sourceRange overlaps with the range. - if (channelsCovered + sourceRange.width >= range.start - && channelsCovered < range.start + range.width) { - eventualSourceRanges.addAll(sourceRange.instance.eventualSources(sourceRange)); - } - channelsCovered += sourceRange.width; - } - } + return result; + } + + /** + * Return a list of ranges of ports that send data to this port within the specified range. If + * this port is directly written to by one more more reactions, then it is its own eventual source + * and only this port will be represented in the result. + * + *

    If this is not a multiport and is not within a bank, then the list will have only one item + * and the range will have a total width of one. Otherwise, it will have enough items so that the + * range widths add up to the width of this multiport multiplied by the total number of instances + * within containing banks. + * + *

    The ports listed are only ports that are written to by reactions, not relay ports that the + * data may go through on the way. + */ + private List> eventualSources(RuntimeRange range) { + if (eventualSourceRanges == null) { + // Cached result has not been created. + eventualSourceRanges = new ArrayList>(); + + if (!dependsOnReactions.isEmpty()) { + eventualSourceRanges.add(new RuntimeRange.Port(this)); + } else { + var channelsCovered = 0; + for (RuntimeRange sourceRange : dependsOnPorts) { + // Check whether the sourceRange overlaps with the range. + if (channelsCovered + sourceRange.width >= range.start + && channelsCovered < range.start + range.width) { + eventualSourceRanges.addAll(sourceRange.instance.eventualSources(sourceRange)); + } + channelsCovered += sourceRange.width; } - return eventualSourceRanges; + } } + return eventualSourceRanges; + } + + /** + * Set the initial multiport width, if this is a multiport, from the widthSpec in the definition. + * This will be set to -1 if the width cannot be determined. + * + * @param errorReporter For reporting errors. + */ + private void setInitialWidth(ErrorReporter errorReporter) { + // If this is a multiport, determine the width. + WidthSpec widthSpec = definition.getWidthSpec(); + + if (widthSpec != null) { + if (widthSpec.isOfVariableLength()) { + errorReporter.reportError( + definition, "Variable-width multiports not supported (yet): " + definition.getName()); + } else { + isMultiport = true; - /** - * Set the initial multiport width, if this is a multiport, from the widthSpec - * in the definition. This will be set to -1 if the width cannot be determined. - * @param errorReporter For reporting errors. - */ - private void setInitialWidth(ErrorReporter errorReporter) { - // If this is a multiport, determine the width. - WidthSpec widthSpec = definition.getWidthSpec(); - - if (widthSpec != null) { - if (widthSpec.isOfVariableLength()) { - errorReporter.reportError(definition, - "Variable-width multiports not supported (yet): " + definition.getName()); + // Determine the initial width, if possible. + // The width may be given by a parameter or even sum of parameters. + width = 0; + for (WidthTerm term : widthSpec.getTerms()) { + Parameter parameter = term.getParameter(); + if (parameter != null) { + Integer parameterValue = parent.initialIntParameterValue(parameter); + // Only a Literal is supported. + if (parameterValue != null) { + width += parameterValue; } else { - isMultiport = true; - - // Determine the initial width, if possible. - // The width may be given by a parameter or even sum of parameters. - width = 0; - for (WidthTerm term : widthSpec.getTerms()) { - Parameter parameter = term.getParameter(); - if (parameter != null) { - Integer parameterValue = parent.initialIntParameterValue(parameter); - // Only a Literal is supported. - if (parameterValue != null) { - width += parameterValue; - } else { - width = -1; - return; - } - } else if (term.getWidth() != 0){ - width += term.getWidth(); - } else { - width = -1; - return; - } - } + width = -1; + return; } + } else if (term.getWidth() != 0) { + width += term.getWidth(); + } else { + width = -1; + return; + } } + } } + } + + ////////////////////////////////////////////////////// + //// Private fields. + + /** Cached list of destination ports with channel ranges. */ + private List eventualDestinationRanges; + + /** Cached list of source ports with channel ranges. */ + private List> eventualSourceRanges; - ////////////////////////////////////////////////////// - //// Private fields. - - /** Cached list of destination ports with channel ranges. */ - private List eventualDestinationRanges; - - /** Cached list of source ports with channel ranges. */ - private List> eventualSourceRanges; - - /** Indicator that we are clearing the caches. */ - private boolean clearingCaches = false; + /** Indicator that we are clearing the caches. */ + private boolean clearingCaches = false; } diff --git a/org.lflang/src/org/lflang/generator/Position.java b/org.lflang/src/org/lflang/generator/Position.java index 872b09a24e..80e3976365 100644 --- a/org.lflang/src/org/lflang/generator/Position.java +++ b/org.lflang/src/org/lflang/generator/Position.java @@ -4,234 +4,219 @@ import java.util.regex.Pattern; /** - * A position in a document, including line and - * column. This position may be relative to some + * A position in a document, including line and column. This position may be relative to some * position other than the origin. * * @author Peter Donovan */ public class Position implements Comparable { - public static final Pattern PATTERN = Pattern.compile("\\((?[0-9]+), (?[0-9]+)\\)"); - - public static final Position ORIGIN = Position.fromZeroBased(0, 0); - - private static final Pattern LINE_SEPARATOR = Pattern.compile("(\n)|(\r)|(\r\n)"); - - private final int line; - private final int column; - - /* ------------------------ CONSTRUCTORS -------------------------- */ - - /** - * Return the Position that describes the given - * zero-based line and column numbers. - * @param line the zero-based line number - * @param column the zero-based column number - * @return a Position describing the position described - * by {@code line} and {@code column}. - */ - public static Position fromZeroBased(int line, int column) { - return new Position(line, column); - } - - /** - * Return the Position that describes the given - * one-based line and column numbers. - * @param line the one-based line number - * @param column the one-based column number - * @return a Position describing the position described - * by {@code line} and {@code column}. - */ - public static Position fromOneBased(int line, int column) { - return new Position(line - 1, column - 1); - } - - /** - * Return the Position that equals the displacement - * caused by {@code text}, assuming that {@code text} - * starts in column 0. - * @param text an arbitrary string - * @return the Position that equals the displacement - * caused by {@code text} - */ - public static Position displacementOf(String text) { - String[] lines = text.lines().toArray(String[]::new); - if (lines.length == 0) return ORIGIN; - return Position.fromZeroBased(lines.length - 1, lines[lines.length - 1].length()); - } - - /** - * Return the Position that describes the same location - * in {@code content} as {@code offset}. - * @param offset a location, expressed as an offset from - * the beginning of {@code content} - * @param content the content of a document - * @return the Position that describes the same location - * in {@code content} as {@code offset} - */ - public static Position fromOffset(int offset, String content) { - int lineNumber = 0; - Matcher matcher = LINE_SEPARATOR.matcher(content); - int start = 0; - while (matcher.find(start)) { - if (matcher.start() > offset) return Position.fromZeroBased(lineNumber, offset - start); - start = matcher.end(); - lineNumber++; - } - return Position.fromZeroBased(lineNumber, offset); - } - - /** - * Create a new Position with the given line and column - * numbers. - * @param line the zero-based line number - * @param column the zero-based column number - */ - private Position(int line, int column) { - // Assertions about whether line and column are - // non-negative are deliberately omitted. Positions - // can be relative. - this.line = line; - this.column = column; - } - - /* ----------------------- PUBLIC METHODS ------------------------- */ - - /** - * Return the one-based line number described by this - * {@code Position}. - * @return the one-based line number described by this - * {@code Position} - */ - public int getOneBasedLine() { - return line + 1; - } - - /** - * Return the one-based column number described by this - * {@code Position}. - * @return the one-based column number described by this - * {@code Position} - */ - public int getOneBasedColumn() { - return column + 1; - } - - /** - * Return the zero-based line number described by this - * {@code Position}. - * @return the zero-based line number described by this - * {@code Position} - */ - public int getZeroBasedLine() { - return line; - } - - /** - * Return the zero-based column number described by this - * {@code Position}. - * @return the zero-based column number described by this - * {@code Position} - */ - public int getZeroBasedColumn() { - return column; - } - - /** - * Return the Position that equals the displacement of - * ((text whose displacement equals {@code this}) - * concatenated with {@code text}). Note that this is - * not necessarily equal to - * ({@code this} + displacementOf(text)). - * @param text an arbitrary string - * @return the Position that equals the displacement - * caused by {@code text} - */ - public Position plus(String text) { - text += "\n"; // Turn line separators into line terminators. - String[] lines = text.lines().toArray(String[]::new); - if (lines.length == 0) return this; // OK not to copy because Positions are immutable - int lastLineLength = lines[lines.length - 1].length(); - return new Position(line + lines.length - 1, lines.length > 1 ? lastLineLength : column + lastLineLength); - } - - /** - * Return the sum of this and another {@code Position}. - * The result has meaning because Positions are - * relative. - * @param other another {@code Position} - * @return the sum of this and {@code other} - */ - public Position plus(Position other) { - return new Position(line + other.line, column + other.column); - } - - /** - * Return the difference of this and another {@code - * Position}. The result has meaning because - * Positions are relative. - * @param other another {@code Position} - * @return the difference of this and {@code other} - */ - public Position minus(Position other) { - return new Position(line - other.line, column - other.column); - } - - /** - * Compare two positions according to their order of - * appearance in a document (first according to line, - * then according to column). - */ - @Override - public int compareTo(Position o) { - if (line != o.line) { - return line - o.line; - } - return column - o.column; - } - - @Override - public boolean equals(Object obj) { - return obj instanceof Position && ((Position) obj).compareTo(this) == 0; - } - - @Override - public String toString() { - return String.format("(%d, %d)", getZeroBasedLine(), getZeroBasedColumn()); - } - - /** - * Return the Position represented by {@code s}. - * @param s a String that represents a Position, - * formatted like the output of - * {@code Position::toString}. - * @return the Position represented by {@code s} - */ - public static Position fromString(String s) { - Matcher matcher = PATTERN.matcher(s); - if (matcher.matches()) { - return Position.fromZeroBased( - Integer.parseInt(matcher.group("line")), - Integer.parseInt(matcher.group("column")) - ); - } - throw new IllegalArgumentException(String.format("Could not parse %s as a Position.", s)); - } - - @Override - public int hashCode() { - return line * 31 + column; - } - - /** - * Remove the names from the named capturing groups - * that appear in {@code regex}. - * @param regex an arbitrary regular expression - * @return a string representation of {@code regex} - * with the names removed from the named capturing - * groups - */ - public static String removeNamedCapturingGroups(Pattern regex) { // FIXME: Does this belong here? - return regex.toString().replaceAll("\\(\\?<\\w+>", "("); - } + public static final Pattern PATTERN = Pattern.compile("\\((?[0-9]+), (?[0-9]+)\\)"); + + public static final Position ORIGIN = Position.fromZeroBased(0, 0); + + private static final Pattern LINE_SEPARATOR = Pattern.compile("(\n)|(\r)|(\r\n)"); + + private final int line; + private final int column; + + /* ------------------------ CONSTRUCTORS -------------------------- */ + + /** + * Return the Position that describes the given zero-based line and column numbers. + * + * @param line the zero-based line number + * @param column the zero-based column number + * @return a Position describing the position described by {@code line} and {@code column}. + */ + public static Position fromZeroBased(int line, int column) { + return new Position(line, column); + } + + /** + * Return the Position that describes the given one-based line and column numbers. + * + * @param line the one-based line number + * @param column the one-based column number + * @return a Position describing the position described by {@code line} and {@code column}. + */ + public static Position fromOneBased(int line, int column) { + return new Position(line - 1, column - 1); + } + + /** + * Return the Position that equals the displacement caused by {@code text}, assuming that {@code + * text} starts in column 0. + * + * @param text an arbitrary string + * @return the Position that equals the displacement caused by {@code text} + */ + public static Position displacementOf(String text) { + String[] lines = text.lines().toArray(String[]::new); + if (lines.length == 0) return ORIGIN; + return Position.fromZeroBased(lines.length - 1, lines[lines.length - 1].length()); + } + + /** + * Return the Position that describes the same location in {@code content} as {@code offset}. + * + * @param offset a location, expressed as an offset from the beginning of {@code content} + * @param content the content of a document + * @return the Position that describes the same location in {@code content} as {@code offset} + */ + public static Position fromOffset(int offset, String content) { + int lineNumber = 0; + Matcher matcher = LINE_SEPARATOR.matcher(content); + int start = 0; + while (matcher.find(start)) { + if (matcher.start() > offset) return Position.fromZeroBased(lineNumber, offset - start); + start = matcher.end(); + lineNumber++; + } + return Position.fromZeroBased(lineNumber, offset); + } + + /** + * Create a new Position with the given line and column numbers. + * + * @param line the zero-based line number + * @param column the zero-based column number + */ + private Position(int line, int column) { + // Assertions about whether line and column are + // non-negative are deliberately omitted. Positions + // can be relative. + this.line = line; + this.column = column; + } + + /* ----------------------- PUBLIC METHODS ------------------------- */ + + /** + * Return the one-based line number described by this {@code Position}. + * + * @return the one-based line number described by this {@code Position} + */ + public int getOneBasedLine() { + return line + 1; + } + + /** + * Return the one-based column number described by this {@code Position}. + * + * @return the one-based column number described by this {@code Position} + */ + public int getOneBasedColumn() { + return column + 1; + } + + /** + * Return the zero-based line number described by this {@code Position}. + * + * @return the zero-based line number described by this {@code Position} + */ + public int getZeroBasedLine() { + return line; + } + + /** + * Return the zero-based column number described by this {@code Position}. + * + * @return the zero-based column number described by this {@code Position} + */ + public int getZeroBasedColumn() { + return column; + } + + /** + * Return the Position that equals the displacement of ((text whose displacement equals {@code + * this}) concatenated with {@code text}). Note that this is not necessarily equal to ({@code + * this} + displacementOf(text)). + * + * @param text an arbitrary string + * @return the Position that equals the displacement caused by {@code text} + */ + public Position plus(String text) { + text += "\n"; // Turn line separators into line terminators. + String[] lines = text.lines().toArray(String[]::new); + if (lines.length == 0) return this; // OK not to copy because Positions are immutable + int lastLineLength = lines[lines.length - 1].length(); + return new Position( + line + lines.length - 1, lines.length > 1 ? lastLineLength : column + lastLineLength); + } + + /** + * Return the sum of this and another {@code Position}. The result has meaning because Positions + * are relative. + * + * @param other another {@code Position} + * @return the sum of this and {@code other} + */ + public Position plus(Position other) { + return new Position(line + other.line, column + other.column); + } + + /** + * Return the difference of this and another {@code Position}. The result has meaning because + * Positions are relative. + * + * @param other another {@code Position} + * @return the difference of this and {@code other} + */ + public Position minus(Position other) { + return new Position(line - other.line, column - other.column); + } + + /** + * Compare two positions according to their order of appearance in a document (first according to + * line, then according to column). + */ + @Override + public int compareTo(Position o) { + if (line != o.line) { + return line - o.line; + } + return column - o.column; + } + + @Override + public boolean equals(Object obj) { + return obj instanceof Position && ((Position) obj).compareTo(this) == 0; + } + + @Override + public String toString() { + return String.format("(%d, %d)", getZeroBasedLine(), getZeroBasedColumn()); + } + + /** + * Return the Position represented by {@code s}. + * + * @param s a String that represents a Position, formatted like the output of {@code + * Position::toString}. + * @return the Position represented by {@code s} + */ + public static Position fromString(String s) { + Matcher matcher = PATTERN.matcher(s); + if (matcher.matches()) { + return Position.fromZeroBased( + Integer.parseInt(matcher.group("line")), Integer.parseInt(matcher.group("column"))); + } + throw new IllegalArgumentException(String.format("Could not parse %s as a Position.", s)); + } + + @Override + public int hashCode() { + return line * 31 + column; + } + + /** + * Remove the names from the named capturing groups that appear in {@code regex}. + * + * @param regex an arbitrary regular expression + * @return a string representation of {@code regex} with the names removed from the named + * capturing groups + */ + public static String removeNamedCapturingGroups(Pattern regex) { // FIXME: Does this belong here? + return regex.toString().replaceAll("\\(\\?<\\w+>", "("); + } } diff --git a/org.lflang/src/org/lflang/generator/Range.java b/org.lflang/src/org/lflang/generator/Range.java index ffca1104d9..9300127d36 100644 --- a/org.lflang/src/org/lflang/generator/Range.java +++ b/org.lflang/src/org/lflang/generator/Range.java @@ -4,136 +4,129 @@ import java.util.regex.Pattern; /** - * Represents a range in a document. Ranges have a - * natural ordering that respects their start + * Represents a range in a document. Ranges have a natural ordering that respects their start * position(s) only. */ public class Range implements Comparable { - public static final Pattern PATTERN = Pattern.compile(String.format( - "Range: \\[(?%s), (?%s)\\)", - Position.removeNamedCapturingGroups(Position.PATTERN), - Position.removeNamedCapturingGroups(Position.PATTERN) - )); + public static final Pattern PATTERN = + Pattern.compile( + String.format( + "Range: \\[(?%s), (?%s)\\)", + Position.removeNamedCapturingGroups(Position.PATTERN), + Position.removeNamedCapturingGroups(Position.PATTERN))); - /** The start of the Range (INCLUSIVE). */ - private final Position start; - /** The end of the Range (EXCLUSIVE). */ - private final Position end; + /** The start of the Range (INCLUSIVE). */ + private final Position start; + /** The end of the Range (EXCLUSIVE). */ + private final Position end; - /* ------------------------- PUBLIC METHODS -------------------------- */ + /* ------------------------- PUBLIC METHODS -------------------------- */ - /** - * Initializes a Range that starts at - * {@code startInclusive} and ends at, but does not - * include, {@code endExclusive}. - * @param startInclusive the start of the range - * (inclusive) - * @param endExclusive the end of the range (exclusive) - */ - public Range(Position startInclusive, Position endExclusive) { - assert startInclusive.compareTo(endExclusive) <= 0: "endExclusive cannot precede startInclusive"; - start = startInclusive; - end = endExclusive; - } + /** + * Initializes a Range that starts at {@code startInclusive} and ends at, but does not include, + * {@code endExclusive}. + * + * @param startInclusive the start of the range (inclusive) + * @param endExclusive the end of the range (exclusive) + */ + public Range(Position startInclusive, Position endExclusive) { + assert startInclusive.compareTo(endExclusive) <= 0 + : "endExclusive cannot precede startInclusive"; + start = startInclusive; + end = endExclusive; + } - /** - * Returns the first Position that is included in this - * Range. - * @return the first Position that is included in this - * Range - */ - public Position getStartInclusive() { - return start; - } + /** + * Returns the first Position that is included in this Range. + * + * @return the first Position that is included in this Range + */ + public Position getStartInclusive() { + return start; + } - /** - * Returns the Position that immediately follows the - * last Position in this Range. - * @return the Position that immediately follows the - * last Position in this Range - */ - public Position getEndExclusive() { - return end; - } + /** + * Returns the Position that immediately follows the last Position in this Range. + * + * @return the Position that immediately follows the last Position in this Range + */ + public Position getEndExclusive() { + return end; + } - @Override - public boolean equals(Object o) { - if (!(o instanceof Range r)) return false; - return start.equals(r.start); - } + @Override + public boolean equals(Object o) { + if (!(o instanceof Range r)) return false; + return start.equals(r.start); + } - @Override - public int hashCode() { - return start.hashCode(); - } + @Override + public int hashCode() { + return start.hashCode(); + } - /** - * Compares this to {@code o}. - * @param o another Range - * @return an integer indicating how this compares to - * {@code o} - */ - @Override - public int compareTo(Range o) { - return this.start.compareTo(o.start); - } + /** + * Compares this to {@code o}. + * + * @param o another Range + * @return an integer indicating how this compares to {@code o} + */ + @Override + public int compareTo(Range o) { + return this.start.compareTo(o.start); + } - /** - * Returns whether this contains {@code p}. - * @param p an arbitrary Position - * @return whether this contains {@code p} - */ - public boolean contains(Position p) { - return start.compareTo(p) <= 0 && p.compareTo(end) < 0; - } + /** + * Returns whether this contains {@code p}. + * + * @param p an arbitrary Position + * @return whether this contains {@code p} + */ + public boolean contains(Position p) { + return start.compareTo(p) <= 0 && p.compareTo(end) < 0; + } - @Override - public String toString() { - return String.format("Range: [%s, %s)", start, end); - } + @Override + public String toString() { + return String.format("Range: [%s, %s)", start, end); + } - /** - * Converts {@code s} to a Range. - * @param s a String that represents a Range, formatted - * like the output of {@code Range::toString} - * @return the Range r such that {@code r.toString()} - * equals {@code s} - */ - public static Range fromString(String s) { - return fromString(s, Position.fromZeroBased(0, 0)); - } + /** + * Converts {@code s} to a Range. + * + * @param s a String that represents a Range, formatted like the output of {@code Range::toString} + * @return the Range r such that {@code r.toString()} equals {@code s} + */ + public static Range fromString(String s) { + return fromString(s, Position.fromZeroBased(0, 0)); + } - /** - * Converts {@code s} to a Range, with the - * assumption that the positions expressed in {@code s} - * are given relative to {@code relativeTo}. - * @param s a String that represents a Range, formatted - * like the output of {@code Range::toString} - * @param relativeTo the position relative to which the - * positions in {@code s} are - * represented - * @return the Range represented by {@code s}, - * expressed relative to the Position relative to which - * the Position {@code relativeTo} is expressed - */ - public static Range fromString(String s, Position relativeTo) { - Matcher matcher = PATTERN.matcher(s); - if (matcher.matches()) { - Position start = Position.fromString(matcher.group("start")); - Position end = Position.fromString(matcher.group("end")); - return new Range(start.plus(relativeTo), end.plus(relativeTo)); - } - throw new IllegalArgumentException(String.format("Could not parse %s as a Range.", s)); + /** + * Converts {@code s} to a Range, with the assumption that the positions expressed in {@code s} + * are given relative to {@code relativeTo}. + * + * @param s a String that represents a Range, formatted like the output of {@code Range::toString} + * @param relativeTo the position relative to which the positions in {@code s} are represented + * @return the Range represented by {@code s}, expressed relative to the Position relative to + * which the Position {@code relativeTo} is expressed + */ + public static Range fromString(String s, Position relativeTo) { + Matcher matcher = PATTERN.matcher(s); + if (matcher.matches()) { + Position start = Position.fromString(matcher.group("start")); + Position end = Position.fromString(matcher.group("end")); + return new Range(start.plus(relativeTo), end.plus(relativeTo)); } + throw new IllegalArgumentException(String.format("Could not parse %s as a Range.", s)); + } - /** - * Returns the degenerate range that simply - * describes the exact location specified by {@code p}. - * @param p an arbitrary Position - * @return a Range that starts and ends immediately - * before {@code p} - */ - public static Range degenerateRange(Position p) { - return new Range(p, p); - } + /** + * Returns the degenerate range that simply describes the exact location specified by {@code p}. + * + * @param p an arbitrary Position + * @return a Range that starts and ends immediately before {@code p} + */ + public static Range degenerateRange(Position p) { + return new Range(p, p); + } } diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/src/org/lflang/generator/ReactionInstance.java index 1d7cbab52a..a1e35ffb19 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstance.java @@ -1,28 +1,28 @@ /** Representation of a runtime instance of a reaction. */ /************* -Copyright (c) 2019-2022, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2022, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; @@ -31,9 +31,8 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.LinkedList; import java.util.List; import java.util.Set; - -import org.lflang.ast.ASTUtils; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Action; import org.lflang.lf.BuiltinTriggerRef; import org.lflang.lf.Port; @@ -44,551 +43,519 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Variable; /** - * Representation of a compile-time instance of a reaction. - * Like {@link ReactorInstance}, if one or more parents of this reaction - * is a bank of reactors, then there will be more than one runtime instance - * corresponding to this compile-time instance. The {@link #getRuntimeInstances()} - * method returns a list of these runtime instances, each an instance of the - * inner class {@link ReactionInstance.Runtime}. Each runtime instance has a "level", which is - * its depth an acyclic precedence graph representing the dependencies between - * reactions at a tag. + * Representation of a compile-time instance of a reaction. Like {@link ReactorInstance}, if one or + * more parents of this reaction is a bank of reactors, then there will be more than one runtime + * instance corresponding to this compile-time instance. The {@link #getRuntimeInstances()} method + * returns a list of these runtime instances, each an instance of the inner class {@link + * ReactionInstance.Runtime}. Each runtime instance has a "level", which is its depth an acyclic + * precedence graph representing the dependencies between reactions at a tag. * * @author Edward A. Lee * @author Marten Lohstroh */ public class ReactionInstance extends NamedInstance { - /** - * Create a new reaction instance from the specified definition - * within the specified parent. This constructor should be called - * only by the ReactorInstance class, but it is public to enable unit tests. - * @param definition A reaction definition. - * @param parent The parent reactor instance, which cannot be null. - * @param isUnordered Indicator that this reaction is unordered w.r.t. other reactions. - * @param index The index of the reaction within the reactor (0 for the - * first reaction, 1 for the second, etc.). - */ - public ReactionInstance( - Reaction definition, - ReactorInstance parent, - boolean isUnordered, - int index - ) { - super(definition, parent); - this.index = index; - this.isUnordered = isUnordered; - - // If the reaction body starts with the magic string - // UNORDERED_REACTION_MARKER, then mark it unordered, - // overriding the argument. - String body = ASTUtils.toText(definition.getCode()); - if (body.contains(UNORDERED_REACTION_MARKER)) { - this.isUnordered = true; - } + /** + * Create a new reaction instance from the specified definition within the specified parent. This + * constructor should be called only by the ReactorInstance class, but it is public to enable unit + * tests. + * + * @param definition A reaction definition. + * @param parent The parent reactor instance, which cannot be null. + * @param isUnordered Indicator that this reaction is unordered w.r.t. other reactions. + * @param index The index of the reaction within the reactor (0 for the first reaction, 1 for the + * second, etc.). + */ + public ReactionInstance( + Reaction definition, ReactorInstance parent, boolean isUnordered, int index) { + super(definition, parent); + this.index = index; + this.isUnordered = isUnordered; + + // If the reaction body starts with the magic string + // UNORDERED_REACTION_MARKER, then mark it unordered, + // overriding the argument. + String body = ASTUtils.toText(definition.getCode()); + if (body.contains(UNORDERED_REACTION_MARKER)) { + this.isUnordered = true; + } - // Identify the dependencies for this reaction. - // First handle the triggers. - for (TriggerRef trigger : definition.getTriggers()) { - if (trigger instanceof VarRef) { - Variable variable = ((VarRef)trigger).getVariable(); - if (variable instanceof Port) { - PortInstance portInstance = parent.lookupPortInstance((Port)variable); - // If the trigger is the port of a contained bank, then the - // portInstance will be null and we have to instead search for - // each port instance in the bank. - if (portInstance != null) { - this.sources.add(portInstance); - portInstance.dependentReactions.add(this); - this.triggers.add(portInstance); - } else if (((VarRef)trigger).getContainer() != null) { - // Port belongs to a contained reactor or bank. - ReactorInstance containedReactor - = parent.lookupReactorInstance(((VarRef)trigger).getContainer()); - if (containedReactor != null) { - portInstance = containedReactor.lookupPortInstance((Port)variable); - if (portInstance != null) { - this.sources.add(portInstance); - portInstance.dependentReactions.add(this); - this.triggers.add(portInstance); - } - } - } - } else if (variable instanceof Action) { - var actionInstance = parent.lookupActionInstance( - (Action)((VarRef)trigger).getVariable()); - this.triggers.add(actionInstance); - actionInstance.dependentReactions.add(this); - this.sources.add(actionInstance); - } else if (variable instanceof Timer) { - var timerInstance = parent.lookupTimerInstance( - (Timer)((VarRef)trigger).getVariable()); - this.triggers.add(timerInstance); - timerInstance.dependentReactions.add(this); - this.sources.add(timerInstance); - } - } else if (trigger instanceof BuiltinTriggerRef) { - this.triggers.add(parent.getOrCreateBuiltinTrigger((BuiltinTriggerRef) trigger)); + // Identify the dependencies for this reaction. + // First handle the triggers. + for (TriggerRef trigger : definition.getTriggers()) { + if (trigger instanceof VarRef) { + Variable variable = ((VarRef) trigger).getVariable(); + if (variable instanceof Port) { + PortInstance portInstance = parent.lookupPortInstance((Port) variable); + // If the trigger is the port of a contained bank, then the + // portInstance will be null and we have to instead search for + // each port instance in the bank. + if (portInstance != null) { + this.sources.add(portInstance); + portInstance.dependentReactions.add(this); + this.triggers.add(portInstance); + } else if (((VarRef) trigger).getContainer() != null) { + // Port belongs to a contained reactor or bank. + ReactorInstance containedReactor = + parent.lookupReactorInstance(((VarRef) trigger).getContainer()); + if (containedReactor != null) { + portInstance = containedReactor.lookupPortInstance((Port) variable); + if (portInstance != null) { + this.sources.add(portInstance); + portInstance.dependentReactions.add(this); + this.triggers.add(portInstance); + } } + } + } else if (variable instanceof Action) { + var actionInstance = + parent.lookupActionInstance((Action) ((VarRef) trigger).getVariable()); + this.triggers.add(actionInstance); + actionInstance.dependentReactions.add(this); + this.sources.add(actionInstance); + } else if (variable instanceof Timer) { + var timerInstance = parent.lookupTimerInstance((Timer) ((VarRef) trigger).getVariable()); + this.triggers.add(timerInstance); + timerInstance.dependentReactions.add(this); + this.sources.add(timerInstance); } - // Next handle the ports that this reaction reads. - for (VarRef source : definition.getSources()) { - Variable variable = source.getVariable(); - if (variable instanceof Port) { - var portInstance = parent.lookupPortInstance((Port)variable); - - // If the trigger is the port of a contained bank, then the - // portInstance will be null and we have to instead search for - // each port instance in the bank. - if (portInstance != null) { - this.sources.add(portInstance); - this.reads.add(portInstance); - portInstance.dependentReactions.add(this); - } else if (source.getContainer() != null) { - ReactorInstance containedReactor - = parent.lookupReactorInstance(source.getContainer()); - if (containedReactor != null) { - portInstance = containedReactor.lookupPortInstance((Port)variable); - if (portInstance != null) { - this.sources.add(portInstance); - portInstance.dependentReactions.add(this); - this.triggers.add(portInstance); - } - } - } + } else if (trigger instanceof BuiltinTriggerRef) { + this.triggers.add(parent.getOrCreateBuiltinTrigger((BuiltinTriggerRef) trigger)); + } + } + // Next handle the ports that this reaction reads. + for (VarRef source : definition.getSources()) { + Variable variable = source.getVariable(); + if (variable instanceof Port) { + var portInstance = parent.lookupPortInstance((Port) variable); + + // If the trigger is the port of a contained bank, then the + // portInstance will be null and we have to instead search for + // each port instance in the bank. + if (portInstance != null) { + this.sources.add(portInstance); + this.reads.add(portInstance); + portInstance.dependentReactions.add(this); + } else if (source.getContainer() != null) { + ReactorInstance containedReactor = parent.lookupReactorInstance(source.getContainer()); + if (containedReactor != null) { + portInstance = containedReactor.lookupPortInstance((Port) variable); + if (portInstance != null) { + this.sources.add(portInstance); + portInstance.dependentReactions.add(this); + this.triggers.add(portInstance); } + } } + } + } - // Finally, handle the effects. - for (VarRef effect : definition.getEffects()) { - Variable variable = effect.getVariable(); - if (variable instanceof Port) { - var portInstance = parent.lookupPortInstance(effect); - if (portInstance != null) { - this.effects.add(portInstance); - portInstance.dependsOnReactions.add(this); - } else { - throw new InvalidSourceException( - "Unexpected effect. Cannot find port " + variable.getName()); - } - } else if (variable instanceof Action) { - // Effect is an Action. - var actionInstance = parent.lookupActionInstance( - (Action)variable); - this.effects.add(actionInstance); - actionInstance.dependsOnReactions.add(this); - } else { - // Effect is either a mode or an unresolved reference. - // Do nothing, transitions will be set up by the ModeInstance. - } - } - // Create a deadline instance if one has been defined. - if (this.definition.getDeadline() != null) { - this.declaredDeadline = new DeadlineInstance( - this.definition.getDeadline(), this); + // Finally, handle the effects. + for (VarRef effect : definition.getEffects()) { + Variable variable = effect.getVariable(); + if (variable instanceof Port) { + var portInstance = parent.lookupPortInstance(effect); + if (portInstance != null) { + this.effects.add(portInstance); + portInstance.dependsOnReactions.add(this); + } else { + throw new InvalidSourceException( + "Unexpected effect. Cannot find port " + variable.getName()); } + } else if (variable instanceof Action) { + // Effect is an Action. + var actionInstance = parent.lookupActionInstance((Action) variable); + this.effects.add(actionInstance); + actionInstance.dependsOnReactions.add(this); + } else { + // Effect is either a mode or an unresolved reference. + // Do nothing, transitions will be set up by the ModeInstance. + } } - - ////////////////////////////////////////////////////// - //// Public fields. - - /** - * Indicates the chain this reaction is a part of. It is constructed - * through a bit-wise or among all upstream chains. Each fork in the - * dependency graph setting a new, unused bit to true in order to - * disambiguate it from parallel chains. Note that zero results in - * no overlap with any other reaction, which means the reaction can - * execute in parallel with any other reaction. The default is 1L. - * If left at the default, parallel execution will be based purely - * on levels. - */ - public long chainID = 1L; - - /** - * The ports or actions that this reaction may write to. - */ - public Set> effects = new LinkedHashSet<>(); - - /** - * The ports, actions, or timers that this reaction is triggered by or uses. - */ - public Set> sources = new LinkedHashSet<>(); - // FIXME: Above sources is misnamed because in the grammar, - // "sources" are only the inputs a reaction reads without being - // triggered by them. The name "reads" used here would be a better - // choice in the grammar. - - /** - * Deadline for this reaction instance, if declared. - */ - public DeadlineInstance declaredDeadline; - - /** - * Sadly, we have no way to mark reaction "unordered" in the AST, - * so instead, we use a magic comment at the start of the reaction body. - * This is that magic comment. - */ - public static String UNORDERED_REACTION_MARKER - = "**** This reaction is unordered."; - - /** - * Index of order of occurrence within the reactor definition. - * The first reaction has index 0, the second index 1, etc. - */ - public int index; - - /** - * Whether or not this reaction is ordered with respect to other - * reactions in the same reactor. - */ - public boolean isUnordered; - - /** - * The ports that this reaction reads but that do not trigger it. - */ - public Set> reads = new LinkedHashSet<>(); - - /** - * The trigger instances (input ports, timers, and actions - * that trigger reactions) that trigger this reaction. - */ - public Set> triggers = new LinkedHashSet<>(); - - ////////////////////////////////////////////////////// - //// Public methods. - - /** - * Clear caches used in reporting dependentReactions() and dependsOnReactions(). - * This method should be called if any changes are made to triggers, sources, - * or effects. - * @param includingRuntimes If false, leave the runtime instances intact. - * This is useful for federated execution where levels are computed using - * the top-level connections, but then those connections are discarded. - */ - public void clearCaches(boolean includingRuntimes) { - dependentReactionsCache = null; - dependsOnReactionsCache = null; - if (includingRuntimes) runtimeInstances = null; + // Create a deadline instance if one has been defined. + if (this.definition.getDeadline() != null) { + this.declaredDeadline = new DeadlineInstance(this.definition.getDeadline(), this); } - - /** - * Return the set of immediate downstream reactions, which are reactions - * that receive data produced by this reaction plus - * at most one reaction in the same reactor whose definition - * lexically follows this one (unless this reaction is unordered). - */ - public Set dependentReactions() { - // Cache the result. - if (dependentReactionsCache != null) return dependentReactionsCache; - dependentReactionsCache = new LinkedHashSet<>(); - - // First, add the next lexical reaction, if appropriate. - if (!isUnordered && parent.reactions.size() > index + 1) { - // Find the next reaction in the parent's reaction list. - dependentReactionsCache.add(parent.reactions.get(index + 1)); - } - - // Next, add reactions that get data from this one via a port. - for (TriggerInstance effect : effects) { - if (effect instanceof PortInstance) { - for (SendRange senderRange - : ((PortInstance)effect).eventualDestinations()) { - for (RuntimeRange destinationRange - : senderRange.destinations) { - dependentReactionsCache.addAll( - destinationRange.instance.dependentReactions); - } - } - } - } - return dependentReactionsCache; + } + + ////////////////////////////////////////////////////// + //// Public fields. + + /** + * Indicates the chain this reaction is a part of. It is constructed through a bit-wise or among + * all upstream chains. Each fork in the dependency graph setting a new, unused bit to true in + * order to disambiguate it from parallel chains. Note that zero results in no overlap with any + * other reaction, which means the reaction can execute in parallel with any other reaction. The + * default is 1L. If left at the default, parallel execution will be based purely on levels. + */ + public long chainID = 1L; + + /** The ports or actions that this reaction may write to. */ + public Set> effects = new LinkedHashSet<>(); + + /** The ports, actions, or timers that this reaction is triggered by or uses. */ + public Set> sources = new LinkedHashSet<>(); + // FIXME: Above sources is misnamed because in the grammar, + // "sources" are only the inputs a reaction reads without being + // triggered by them. The name "reads" used here would be a better + // choice in the grammar. + + /** Deadline for this reaction instance, if declared. */ + public DeadlineInstance declaredDeadline; + + /** + * Sadly, we have no way to mark reaction "unordered" in the AST, so instead, we use a magic + * comment at the start of the reaction body. This is that magic comment. + */ + public static String UNORDERED_REACTION_MARKER = "**** This reaction is unordered."; + + /** + * Index of order of occurrence within the reactor definition. The first reaction has index 0, the + * second index 1, etc. + */ + public int index; + + /** + * Whether or not this reaction is ordered with respect to other reactions in the same reactor. + */ + public boolean isUnordered; + + /** The ports that this reaction reads but that do not trigger it. */ + public Set> reads = new LinkedHashSet<>(); + + /** + * The trigger instances (input ports, timers, and actions that trigger reactions) that trigger + * this reaction. + */ + public Set> triggers = new LinkedHashSet<>(); + + ////////////////////////////////////////////////////// + //// Public methods. + + /** + * Clear caches used in reporting dependentReactions() and dependsOnReactions(). This method + * should be called if any changes are made to triggers, sources, or effects. + * + * @param includingRuntimes If false, leave the runtime instances intact. This is useful for + * federated execution where levels are computed using the top-level connections, but then + * those connections are discarded. + */ + public void clearCaches(boolean includingRuntimes) { + dependentReactionsCache = null; + dependsOnReactionsCache = null; + if (includingRuntimes) runtimeInstances = null; + } + + /** + * Return the set of immediate downstream reactions, which are reactions that receive data + * produced by this reaction plus at most one reaction in the same reactor whose definition + * lexically follows this one (unless this reaction is unordered). + */ + public Set dependentReactions() { + // Cache the result. + if (dependentReactionsCache != null) return dependentReactionsCache; + dependentReactionsCache = new LinkedHashSet<>(); + + // First, add the next lexical reaction, if appropriate. + if (!isUnordered && parent.reactions.size() > index + 1) { + // Find the next reaction in the parent's reaction list. + dependentReactionsCache.add(parent.reactions.get(index + 1)); } - /** - * Return the set of immediate upstream reactions, which are reactions - * that send data to this one plus at most one reaction in the same - * reactor whose definition immediately precedes the definition of this one - * (unless this reaction is unordered). - */ - public Set dependsOnReactions() { - // Cache the result. - if (dependsOnReactionsCache != null) return dependsOnReactionsCache; - dependsOnReactionsCache = new LinkedHashSet<>(); - - // First, add the previous lexical reaction, if appropriate. - if (!isUnordered && index > 0) { - // Find the previous ordered reaction in the parent's reaction list. - int earlierIndex = index - 1; - ReactionInstance earlierOrderedReaction = parent.reactions.get(earlierIndex); - while (earlierOrderedReaction.isUnordered && --earlierIndex >= 0) { - earlierOrderedReaction = parent.reactions.get(earlierIndex); - } - if (earlierIndex >= 0) { - dependsOnReactionsCache.add(parent.reactions.get(index - 1)); - } - } - - // Next, add reactions that send data to this one. - for (TriggerInstance source : sources) { - if (source instanceof PortInstance) { - // First, add reactions that send data through an intermediate port. - for (RuntimeRange senderRange - : ((PortInstance)source).eventualSources()) { - dependsOnReactionsCache.addAll(senderRange.instance.dependsOnReactions); - } - // Then, add reactions that send directly to this port. - dependsOnReactionsCache.addAll(source.dependsOnReactions); - } + // Next, add reactions that get data from this one via a port. + for (TriggerInstance effect : effects) { + if (effect instanceof PortInstance) { + for (SendRange senderRange : ((PortInstance) effect).eventualDestinations()) { + for (RuntimeRange destinationRange : senderRange.destinations) { + dependentReactionsCache.addAll(destinationRange.instance.dependentReactions); + } } - return dependsOnReactionsCache; + } } - - /** - * Return a set of levels that runtime instances of this reaction have. - * A ReactionInstance may have more than one level if it lies within - * a bank and its dependencies on other reactions pass through multiports. - */ - public Set getLevels() { - Set result = new LinkedHashSet<>(); - // Force calculation of levels if it has not been done. - // FIXME: Comment out this as I think it is redundant. - // If it is NOT redundant then deadline propagation is not correct - // parent.assignLevels(); - for (Runtime runtime : runtimeInstances) { - result.add(runtime.level); - } - return result; + return dependentReactionsCache; + } + + /** + * Return the set of immediate upstream reactions, which are reactions that send data to this one + * plus at most one reaction in the same reactor whose definition immediately precedes the + * definition of this one (unless this reaction is unordered). + */ + public Set dependsOnReactions() { + // Cache the result. + if (dependsOnReactionsCache != null) return dependsOnReactionsCache; + dependsOnReactionsCache = new LinkedHashSet<>(); + + // First, add the previous lexical reaction, if appropriate. + if (!isUnordered && index > 0) { + // Find the previous ordered reaction in the parent's reaction list. + int earlierIndex = index - 1; + ReactionInstance earlierOrderedReaction = parent.reactions.get(earlierIndex); + while (earlierOrderedReaction.isUnordered && --earlierIndex >= 0) { + earlierOrderedReaction = parent.reactions.get(earlierIndex); + } + if (earlierIndex >= 0) { + dependsOnReactionsCache.add(parent.reactions.get(index - 1)); + } } - /** - * Return a set of deadlines that runtime instances of this reaction have. - * A ReactionInstance may have more than one deadline if it lies within. - */ - public Set getInferredDeadlines() { - Set result = new LinkedHashSet<>(); - for (Runtime runtime : runtimeInstances) { - result.add(runtime.deadline); + // Next, add reactions that send data to this one. + for (TriggerInstance source : sources) { + if (source instanceof PortInstance) { + // First, add reactions that send data through an intermediate port. + for (RuntimeRange senderRange : ((PortInstance) source).eventualSources()) { + dependsOnReactionsCache.addAll(senderRange.instance.dependsOnReactions); } - return result; + // Then, add reactions that send directly to this port. + dependsOnReactionsCache.addAll(source.dependsOnReactions); + } } - - - /** - * Return a list of levels that runtime instances of this reaction have. - * The size of this list is the total number of runtime instances. - * A ReactionInstance may have more than one level if it lies within - * a bank and its dependencies on other reactions pass through multiports. - */ - public List getLevelsList() { - List result = new LinkedList<>(); - // Force calculation of levels if it has not been done. - // FIXME: Comment out this as I think it is redundant. - // If it is NOT redundant then deadline propagation is not correct - // parent.assignLevels(); - for (Runtime runtime : runtimeInstances) { - result.add(runtime.level); - } - return result; + return dependsOnReactionsCache; + } + + /** + * Return a set of levels that runtime instances of this reaction have. A ReactionInstance may + * have more than one level if it lies within a bank and its dependencies on other reactions pass + * through multiports. + */ + public Set getLevels() { + Set result = new LinkedHashSet<>(); + // Force calculation of levels if it has not been done. + // FIXME: Comment out this as I think it is redundant. + // If it is NOT redundant then deadline propagation is not correct + // parent.assignLevels(); + for (Runtime runtime : runtimeInstances) { + result.add(runtime.level); } - - /** - * Return a list of the deadlines that runtime instances of this reaction have. - * The size of this list is the total number of runtime instances. - * A ReactionInstance may have more than one deadline if it lies within - */ - public List getInferredDeadlinesList() { - List result = new LinkedList<>(); - for (Runtime runtime : runtimeInstances) { - result.add(runtime.deadline); - } - return result; + return result; + } + + /** + * Return a set of deadlines that runtime instances of this reaction have. A ReactionInstance may + * have more than one deadline if it lies within. + */ + public Set getInferredDeadlines() { + Set result = new LinkedHashSet<>(); + for (Runtime runtime : runtimeInstances) { + result.add(runtime.deadline); } - - - /** - * Return the name of this reaction, which is 'reaction_n', - * where n is replaced by the reaction index. - * @return The name of this reaction. - */ - @Override - public String getName() { - return "reaction_" + this.index; + return result; + } + + /** + * Return a list of levels that runtime instances of this reaction have. The size of this list is + * the total number of runtime instances. A ReactionInstance may have more than one level if it + * lies within a bank and its dependencies on other reactions pass through multiports. + */ + public List getLevelsList() { + List result = new LinkedList<>(); + // Force calculation of levels if it has not been done. + // FIXME: Comment out this as I think it is redundant. + // If it is NOT redundant then deadline propagation is not correct + // parent.assignLevels(); + for (Runtime runtime : runtimeInstances) { + result.add(runtime.level); } - - /** - * Return an array of runtime instances of this reaction in a - * natural order, defined as follows. The position within the - * returned list of the runtime instance is given by a mixed-radix - * number where the low-order digit is the bank index within the - * container reactor (or {@code 0} if it is not a bank), the second low order - * digit is the bank index of the container's container (or {@code 0} if - * it is not a bank), etc., until the container that is directly - * contained by the top level (the top-level reactor need not be - * included because its index is always {@code 0}). - * - * The size of the returned array is the product of the widths of all of the - * container {@link ReactorInstance} objects. If none of these is a bank, - * then the size will be {@code 1}. - * - * This method creates this array the first time it is called, but then - * holds on to it. The array is used by {@link ReactionInstanceGraph} - * to determine and record levels and deadline for runtime instances - * of reactors. - */ - public List getRuntimeInstances() { - if (runtimeInstances != null) return runtimeInstances; - int size = parent.getTotalWidth(); - // If the width cannot be determined, assume there is only one instance. - if (size < 0) size = 1; - runtimeInstances = new ArrayList<>(size); - for (int i = 0; i < size; i++) { - Runtime r = new Runtime(); - r.id = i; - if (declaredDeadline != null) { - r.deadline = declaredDeadline.maxDelay; - } - runtimeInstances.add(r); - } - return runtimeInstances; + return result; + } + + /** + * Return a list of the deadlines that runtime instances of this reaction have. The size of this + * list is the total number of runtime instances. A ReactionInstance may have more than one + * deadline if it lies within + */ + public List getInferredDeadlinesList() { + List result = new LinkedList<>(); + for (Runtime runtime : runtimeInstances) { + result.add(runtime.deadline); } - - /** - * Purge 'portInstance' from this reaction, removing it from the list - * of triggers, sources, effects, and reads. Note that this leaves - * the runtime instances intact, including their level information. - */ - public void removePortInstance(PortInstance portInstance) { - this.triggers.remove(portInstance); - this.sources.remove(portInstance); - this.effects.remove(portInstance); - this.reads.remove(portInstance); - clearCaches(false); - portInstance.clearCaches(); + return result; + } + + /** + * Return the name of this reaction, which is 'reaction_n', where n is replaced by the reaction + * index. + * + * @return The name of this reaction. + */ + @Override + public String getName() { + return "reaction_" + this.index; + } + + /** + * Return an array of runtime instances of this reaction in a natural order, defined as + * follows. The position within the returned list of the runtime instance is given by a + * mixed-radix number where the low-order digit is the bank index within the container reactor (or + * {@code 0} if it is not a bank), the second low order digit is the bank index of the container's + * container (or {@code 0} if it is not a bank), etc., until the container that is directly + * contained by the top level (the top-level reactor need not be included because its index is + * always {@code 0}). + * + *

    The size of the returned array is the product of the widths of all of the container {@link + * ReactorInstance} objects. If none of these is a bank, then the size will be {@code 1}. + * + *

    This method creates this array the first time it is called, but then holds on to it. The + * array is used by {@link ReactionInstanceGraph} to determine and record levels and deadline for + * runtime instances of reactors. + */ + public List getRuntimeInstances() { + if (runtimeInstances != null) return runtimeInstances; + int size = parent.getTotalWidth(); + // If the width cannot be determined, assume there is only one instance. + if (size < 0) size = 1; + runtimeInstances = new ArrayList<>(size); + for (int i = 0; i < size; i++) { + Runtime r = new Runtime(); + r.id = i; + if (declaredDeadline != null) { + r.deadline = declaredDeadline.maxDelay; + } + runtimeInstances.add(r); } - - /** - * Return a descriptive string. - */ - @Override - public String toString() { - return getName() + " of " + parent.getFullName(); + return runtimeInstances; + } + + /** + * Purge 'portInstance' from this reaction, removing it from the list of triggers, sources, + * effects, and reads. Note that this leaves the runtime instances intact, including their level + * information. + */ + public void removePortInstance(PortInstance portInstance) { + this.triggers.remove(portInstance); + this.sources.remove(portInstance); + this.effects.remove(portInstance); + this.reads.remove(portInstance); + clearCaches(false); + portInstance.clearCaches(); + } + + /** Return a descriptive string. */ + @Override + public String toString() { + return getName() + " of " + parent.getFullName(); + } + + /** + * Determine logical execution time for each reaction during compile time based on immediate + * downstream logical delays (after delays and actions) and label each reaction with the minimum + * of all such delays. + */ + public TimeValue assignLogicalExecutionTime() { + if (this.let != null) { + return this.let; } - /** - * Determine logical execution time for each reaction during compile - * time based on immediate downstream logical delays (after delays and actions) - * and label each reaction with the minimum of all such delays. - */ - public TimeValue assignLogicalExecutionTime() { - if (this.let != null) { - return this.let; - } - - if (this.parent.isGeneratedDelay()) { - return this.let = TimeValue.ZERO; - } + if (this.parent.isGeneratedDelay()) { + return this.let = TimeValue.ZERO; + } - TimeValue let = null; - - // Iterate over effect and find minimum delay. - for (TriggerInstance effect : effects) { - if (effect instanceof PortInstance) { - var afters = this.parent.getParent().children.stream().filter(c -> { - if (c.isGeneratedDelay()) { - return c.inputs.get(0).getDependsOnPorts().get(0).instance - .equals((PortInstance) effect); - } - return false; - }).map(c -> c.actions.get(0).getMinDelay()) - .min(TimeValue::compare); - - if (afters.isPresent()) { - if (let == null) { - let = afters.get(); - } else { - let = TimeValue.min(afters.get(), let); - } - } - } else if (effect instanceof ActionInstance) { - var action = ((ActionInstance) effect).getMinDelay(); - if (let == null) { - let = action; - } else { - let = TimeValue.min(action, let); - } - } + TimeValue let = null; + + // Iterate over effect and find minimum delay. + for (TriggerInstance effect : effects) { + if (effect instanceof PortInstance) { + var afters = + this.parent.getParent().children.stream() + .filter( + c -> { + if (c.isGeneratedDelay()) { + return c.inputs + .get(0) + .getDependsOnPorts() + .get(0) + .instance + .equals((PortInstance) effect); + } + return false; + }) + .map(c -> c.actions.get(0).getMinDelay()) + .min(TimeValue::compare); + + if (afters.isPresent()) { + if (let == null) { + let = afters.get(); + } else { + let = TimeValue.min(afters.get(), let); + } } - + } else if (effect instanceof ActionInstance) { + var action = ((ActionInstance) effect).getMinDelay(); if (let == null) { - let = TimeValue.ZERO; + let = action; + } else { + let = TimeValue.min(action, let); } - return this.let = let; + } } - ////////////////////////////////////////////////////// - //// Private variables. - - /** Cache of the set of downstream reactions. */ - private Set dependentReactionsCache; - - /** Cache of the set of upstream reactions. */ - private Set dependsOnReactionsCache; - - /** - * Array of runtime instances of this reaction. - * This has length 1 unless the reaction is contained - * by one or more banks. Suppose that this reaction - * has depth 3, with full name r0.r1.r2.r. The top-level - * reactor is r0, which contains r1, which contains r2, - * which contains this reaction r. Suppose the widths - * of the containing reactors are w0, w1, and w2, and - * we are interested in the instance at bank indexes - * b0, b1, and b2. That instance is in this array at - * location given by the natural ordering, which - * is the mixed radix number b2%w2; b1%w1. - */ - private List runtimeInstances; - - private TimeValue let = null; - - /////////////////////////////////////////////////////////// - //// Inner classes - - /** Inner class representing a runtime instance of a reaction. */ - public class Runtime { - public TimeValue deadline; - // If this reaction instance depends on exactly one upstream - // reaction (via a port), then the "dominating" field will - // point to that upstream reaction. - public Runtime dominating; - /** ID ranging from 0 to parent.getTotalWidth() - 1. */ - public int id; - public int level; - - public ReactionInstance getReaction() { - return ReactionInstance.this; - } - @Override - public String toString() { - String result = ReactionInstance.this + "(level: " + level; - if (deadline != null && deadline != TimeValue.MAX_VALUE) { - result += ", deadline: " + deadline; - } - if (dominating != null) { - result += ", dominating: " + dominating.getReaction(); - } - result += ")"; - return result; - } + if (let == null) { + let = TimeValue.ZERO; + } + return this.let = let; + } + + ////////////////////////////////////////////////////// + //// Private variables. + + /** Cache of the set of downstream reactions. */ + private Set dependentReactionsCache; + + /** Cache of the set of upstream reactions. */ + private Set dependsOnReactionsCache; + + /** + * Array of runtime instances of this reaction. This has length 1 unless the reaction is contained + * by one or more banks. Suppose that this reaction has depth 3, with full name r0.r1.r2.r. The + * top-level reactor is r0, which contains r1, which contains r2, which contains this reaction r. + * Suppose the widths of the containing reactors are w0, w1, and w2, and we are interested in the + * instance at bank indexes b0, b1, and b2. That instance is in this array at location given by + * the natural ordering, which is the mixed radix number b2%w2; b1%w1. + */ + private List runtimeInstances; + + private TimeValue let = null; + + /////////////////////////////////////////////////////////// + //// Inner classes + + /** Inner class representing a runtime instance of a reaction. */ + public class Runtime { + public TimeValue deadline; + // If this reaction instance depends on exactly one upstream + // reaction (via a port), then the "dominating" field will + // point to that upstream reaction. + public Runtime dominating; + /** ID ranging from 0 to parent.getTotalWidth() - 1. */ + public int id; + + public int level; + + public ReactionInstance getReaction() { + return ReactionInstance.this; + } - public Runtime() { - this.dominating = null; - this.id = 0; - this.level = 0; - if (ReactionInstance.this.declaredDeadline != null) { - this.deadline = ReactionInstance.this.declaredDeadline.maxDelay; - } else { - this.deadline = TimeValue.MAX_VALUE; - } - } + @Override + public String toString() { + String result = ReactionInstance.this + "(level: " + level; + if (deadline != null && deadline != TimeValue.MAX_VALUE) { + result += ", deadline: " + deadline; + } + if (dominating != null) { + result += ", dominating: " + dominating.getReaction(); + } + result += ")"; + return result; + } + + public Runtime() { + this.dominating = null; + this.id = 0; + this.level = 0; + if (ReactionInstance.this.declaredDeadline != null) { + this.deadline = ReactionInstance.this.declaredDeadline.maxDelay; + } else { + this.deadline = TimeValue.MAX_VALUE; + } } + } } diff --git a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java b/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java index 4c5f3ec292..57d171e327 100644 --- a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java +++ b/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java @@ -1,28 +1,28 @@ /** A graph that represents causality cycles formed by reaction instances. */ /************* -Copyright (c) 2021, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2021, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; @@ -31,359 +31,347 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.List; import java.util.Set; import java.util.stream.Collectors; - import org.lflang.generator.ReactionInstance.Runtime; import org.lflang.generator.c.CUtil; import org.lflang.graph.PrecedenceGraph; import org.lflang.lf.Variable; /** - * This class analyzes the dependencies between reaction runtime instances. - * For each ReactionInstance, there may be more than one runtime instance because - * the ReactionInstance may be nested within one or more banks. - * In the worst case, of these runtime instances may have distinct dependencies, - * and hence distinct levels in the graph. Moreover, some of these instances - * may be involved in cycles while others are not. + * This class analyzes the dependencies between reaction runtime instances. For each + * ReactionInstance, there may be more than one runtime instance because the ReactionInstance may be + * nested within one or more banks. In the worst case, of these runtime instances may have distinct + * dependencies, and hence distinct levels in the graph. Moreover, some of these instances may be + * involved in cycles while others are not. * - * Upon construction of this class, the runtime instances are created if necessary, - * stored each ReactionInstance, and assigned levels (maximum number of - * upstream reaction instances), deadlines, and single dominating reactions. + *

    Upon construction of this class, the runtime instances are created if necessary, stored each + * ReactionInstance, and assigned levels (maximum number of upstream reaction instances), deadlines, + * and single dominating reactions. * - * After creation, the resulting graph will be empty unless there are causality - * cycles, in which case, the resulting graph is a graph of runtime reaction - * instances that form cycles. + *

    After creation, the resulting graph will be empty unless there are causality cycles, in which + * case, the resulting graph is a graph of runtime reaction instances that form cycles. * * @author Marten Lohstroh * @author Edward A. Lee */ public class ReactionInstanceGraph extends PrecedenceGraph { - /** - * Create a new graph by traversing the maps in the named instances - * embedded in the hierarchy of the program. - */ - public ReactionInstanceGraph(ReactorInstance main) { - this.main = main; - rebuild(); - } - - /////////////////////////////////////////////////////////// - //// Public fields - - /** - * The main reactor instance that this graph is associated with. - */ - public final ReactorInstance main; - - /////////////////////////////////////////////////////////// - //// Public methods - - /** - * Rebuild this graph by clearing and repeating the traversal that - * adds all the nodes and edges. - */ - public void rebuild() { - this.clear(); - addNodesAndEdges(main); - - // FIXME: Use {@link TargetProperty#EXPORT_DEPENDENCY_GRAPH}. - // System.out.println(toDOT()); - - // Assign a level to each reaction. - // If there are cycles present in the graph, it will be detected here. - assignLevels(); - if (nodeCount() != 0) { - // The graph has cycles. - // main.reporter.reportError("Reactions form a cycle! " + toString()); - // Do not throw an exception so that cycle visualization can proceed. - // throw new InvalidSourceException("Reactions form a cycle!"); - } + /** + * Create a new graph by traversing the maps in the named instances embedded in the hierarchy of + * the program. + */ + public ReactionInstanceGraph(ReactorInstance main) { + this.main = main; + rebuild(); + } + + /////////////////////////////////////////////////////////// + //// Public fields + + /** The main reactor instance that this graph is associated with. */ + public final ReactorInstance main; + + /////////////////////////////////////////////////////////// + //// Public methods + + /** + * Rebuild this graph by clearing and repeating the traversal that adds all the nodes and edges. + */ + public void rebuild() { + this.clear(); + addNodesAndEdges(main); + + // FIXME: Use {@link TargetProperty#EXPORT_DEPENDENCY_GRAPH}. + // System.out.println(toDOT()); + + // Assign a level to each reaction. + // If there are cycles present in the graph, it will be detected here. + assignLevels(); + if (nodeCount() != 0) { + // The graph has cycles. + // main.reporter.reportError("Reactions form a cycle! " + toString()); + // Do not throw an exception so that cycle visualization can proceed. + // throw new InvalidSourceException("Reactions form a cycle!"); } - /** - * This function rebuilds the graph and propagates and assigns deadlines - * to all reactions. - */ - public void rebuildAndAssignDeadlines() { - this.clear(); - addNodesAndEdges(main); - assignInferredDeadlines(); - this.clear(); - } - - /* - * Get an array of non-negative integers representing the number of reactions - * per each level, where levels are indices of the array. - */ - public Integer[] getNumReactionsPerLevel() { - return numReactionsPerLevel.toArray(new Integer[0]); + } + /** This function rebuilds the graph and propagates and assigns deadlines to all reactions. */ + public void rebuildAndAssignDeadlines() { + this.clear(); + addNodesAndEdges(main); + assignInferredDeadlines(); + this.clear(); + } + + /* + * Get an array of non-negative integers representing the number of reactions + * per each level, where levels are indices of the array. + */ + public Integer[] getNumReactionsPerLevel() { + return numReactionsPerLevel.toArray(new Integer[0]); + } + + /** Return the max breadth of the reaction dependency graph */ + public int getBreadth() { + var maxBreadth = 0; + for (Integer breadth : numReactionsPerLevel) { + if (breadth > maxBreadth) { + maxBreadth = breadth; + } } + return maxBreadth; + } + + /////////////////////////////////////////////////////////// + //// Protected methods + + /** + * Add to the graph edges between the given reaction and all the reactions that depend on the + * specified port. + * + * @param port The port that the given reaction has as an effect. + * @param reaction The reaction to relate downstream reactions to. + */ + protected void addDownstreamReactions(PortInstance port, ReactionInstance reaction) { + // Use mixed-radix numbers to increment over the ranges. + List srcRuntimes = reaction.getRuntimeInstances(); + List eventualDestinations = port.eventualDestinations(); + + int srcDepth = (port.isInput()) ? 2 : 1; + + for (SendRange sendRange : eventualDestinations) { + for (RuntimeRange dstRange : sendRange.destinations) { + + int dstDepth = (dstRange.instance.isOutput()) ? 2 : 1; + MixedRadixInt dstRangePosition = dstRange.startMR(); + int dstRangeCount = 0; + + MixedRadixInt sendRangePosition = sendRange.startMR(); + int sendRangeCount = 0; + + while (dstRangeCount++ < dstRange.width) { + int srcIndex = sendRangePosition.get(srcDepth); + int dstIndex = dstRangePosition.get(dstDepth); + for (ReactionInstance dstReaction : dstRange.instance.dependentReactions) { + List dstRuntimes = dstReaction.getRuntimeInstances(); + Runtime srcRuntime = srcRuntimes.get(srcIndex); + Runtime dstRuntime = dstRuntimes.get(dstIndex); + // Only add this dependency if the reactions are not in modes at all or in the same mode + // or in modes of separate reactors + // This allows modes to break cycles since modes are always mutually exclusive. + if (srcRuntime.getReaction().getMode(true) == null + || dstRuntime.getReaction().getMode(true) == null + || srcRuntime.getReaction().getMode(true) == dstRuntime.getReaction().getMode(true) + || srcRuntime.getReaction().getParent() != dstRuntime.getReaction().getParent()) { + addEdge(dstRuntime, srcRuntime); + } - /** - * Return the max breadth of the reaction dependency graph - */ - public int getBreadth() { - var maxBreadth = 0; - for (Integer breadth: numReactionsPerLevel ) { - if (breadth > maxBreadth) { - maxBreadth = breadth; + // Propagate the deadlines, if any. + if (srcRuntime.deadline.compareTo(dstRuntime.deadline) > 0) { + srcRuntime.deadline = dstRuntime.deadline; } - } - return maxBreadth; - } - /////////////////////////////////////////////////////////// - //// Protected methods - - /** - * Add to the graph edges between the given reaction and all the reactions - * that depend on the specified port. - * @param port The port that the given reaction has as an effect. - * @param reaction The reaction to relate downstream reactions to. - */ - protected void addDownstreamReactions(PortInstance port, ReactionInstance reaction) { - // Use mixed-radix numbers to increment over the ranges. - List srcRuntimes = reaction.getRuntimeInstances(); - List eventualDestinations = port.eventualDestinations(); - - int srcDepth = (port.isInput())? 2 : 1; - - for (SendRange sendRange : eventualDestinations) { - for (RuntimeRange dstRange : sendRange.destinations) { - - int dstDepth = (dstRange.instance.isOutput())? 2 : 1; - MixedRadixInt dstRangePosition = dstRange.startMR(); - int dstRangeCount = 0; - - MixedRadixInt sendRangePosition = sendRange.startMR(); - int sendRangeCount = 0; - - while (dstRangeCount++ < dstRange.width) { - int srcIndex = sendRangePosition.get(srcDepth); - int dstIndex = dstRangePosition.get(dstDepth); - for (ReactionInstance dstReaction : dstRange.instance.dependentReactions) { - List dstRuntimes = dstReaction.getRuntimeInstances(); - Runtime srcRuntime = srcRuntimes.get(srcIndex); - Runtime dstRuntime = dstRuntimes.get(dstIndex); - // Only add this dependency if the reactions are not in modes at all or in the same mode or in modes of separate reactors - // This allows modes to break cycles since modes are always mutually exclusive. - if (srcRuntime.getReaction().getMode(true) == null || - dstRuntime.getReaction().getMode(true) == null || - srcRuntime.getReaction().getMode(true) == dstRuntime.getReaction().getMode(true) || - srcRuntime.getReaction().getParent() != dstRuntime.getReaction().getParent()) { - addEdge(dstRuntime, srcRuntime); - } - - // Propagate the deadlines, if any. - if (srcRuntime.deadline.compareTo(dstRuntime.deadline) > 0) { - srcRuntime.deadline = dstRuntime.deadline; - } - - // If this seems to be a single dominating reaction, set it. - // If another upstream reaction shows up, then this will be - // reset to null. - if (this.getUpstreamAdjacentNodes(dstRuntime).size() == 1 - && (dstRuntime.getReaction().isUnordered - || dstRuntime.getReaction().index == 0)) { - dstRuntime.dominating = srcRuntime; - } else { - dstRuntime.dominating = null; - } - } - dstRangePosition.increment(); - sendRangePosition.increment(); - sendRangeCount++; - if (sendRangeCount >= sendRange.width) { - // Reset to multicast. - sendRangeCount = 0; - sendRangePosition = sendRange.startMR(); - } - } + // If this seems to be a single dominating reaction, set it. + // If another upstream reaction shows up, then this will be + // reset to null. + if (this.getUpstreamAdjacentNodes(dstRuntime).size() == 1 + && (dstRuntime.getReaction().isUnordered || dstRuntime.getReaction().index == 0)) { + dstRuntime.dominating = srcRuntime; + } else { + dstRuntime.dominating = null; } + } + dstRangePosition.increment(); + sendRangePosition.increment(); + sendRangeCount++; + if (sendRangeCount >= sendRange.width) { + // Reset to multicast. + sendRangeCount = 0; + sendRangePosition = sendRange.startMR(); + } } + } } - - /** - * Build the graph by adding nodes and edges based on the given reactor - * instance. - * @param reactor The reactor on the basis of which to add nodes and edges. - */ - protected void addNodesAndEdges(ReactorInstance reactor) { - ReactionInstance previousReaction = null; - for (ReactionInstance reaction : reactor.reactions) { - List runtimes = reaction.getRuntimeInstances(); - - // Add reactions of this reactor. - for (Runtime runtime : runtimes) { - this.addNode(runtime); - } - - // If this is not an unordered reaction, then create a dependency - // on any previously defined reaction. - if (!reaction.isUnordered) { - // If there is an earlier reaction in this same reactor, then - // create a link in the reaction graph for all runtime instances. - if (previousReaction != null) { - List previousRuntimes = previousReaction.getRuntimeInstances(); - int count = 0; - for (Runtime runtime : runtimes) { - // Only add the reaction order edge if previous reaction is outside of a mode or both are in the same mode - // This allows modes to break cycles since modes are always mutually exclusive. - if (runtime.getReaction().getMode(true) == null || runtime.getReaction().getMode(true) == reaction.getMode(true)) { - this.addEdge(runtime, previousRuntimes.get(count)); - count++; - } - } - } - previousReaction = reaction; - } - - // Add downstream reactions. Note that this is sufficient. - // We don't need to also add upstream reactions because this reaction - // will be downstream of those upstream reactions. - for (TriggerInstance effect : reaction.effects) { - if (effect instanceof PortInstance) { - addDownstreamReactions((PortInstance)effect, reaction); - } + } + + /** + * Build the graph by adding nodes and edges based on the given reactor instance. + * + * @param reactor The reactor on the basis of which to add nodes and edges. + */ + protected void addNodesAndEdges(ReactorInstance reactor) { + ReactionInstance previousReaction = null; + for (ReactionInstance reaction : reactor.reactions) { + List runtimes = reaction.getRuntimeInstances(); + + // Add reactions of this reactor. + for (Runtime runtime : runtimes) { + this.addNode(runtime); + } + + // If this is not an unordered reaction, then create a dependency + // on any previously defined reaction. + if (!reaction.isUnordered) { + // If there is an earlier reaction in this same reactor, then + // create a link in the reaction graph for all runtime instances. + if (previousReaction != null) { + List previousRuntimes = previousReaction.getRuntimeInstances(); + int count = 0; + for (Runtime runtime : runtimes) { + // Only add the reaction order edge if previous reaction is outside of a mode or both + // are in the same mode + // This allows modes to break cycles since modes are always mutually exclusive. + if (runtime.getReaction().getMode(true) == null + || runtime.getReaction().getMode(true) == reaction.getMode(true)) { + this.addEdge(runtime, previousRuntimes.get(count)); + count++; } + } } - // Recursively add nodes and edges from contained reactors. - for (ReactorInstance child : reactor.children) { - addNodesAndEdges(child); + previousReaction = reaction; + } + + // Add downstream reactions. Note that this is sufficient. + // We don't need to also add upstream reactions because this reaction + // will be downstream of those upstream reactions. + for (TriggerInstance effect : reaction.effects) { + if (effect instanceof PortInstance) { + addDownstreamReactions((PortInstance) effect, reaction); } + } + } + // Recursively add nodes and edges from contained reactors. + for (ReactorInstance child : reactor.children) { + addNodesAndEdges(child); + } + } + + /////////////////////////////////////////////////////////// + //// Private fields + + /** + * Number of reactions per level, represented as a list of integers where the indices are the + * levels. + */ + private List numReactionsPerLevel = new ArrayList<>(List.of(0)); + + /////////////////////////////////////////////////////////// + //// Private methods + + /** + * Analyze the dependencies between reactions and assign each reaction instance a level. This + * method removes nodes from this graph as it assigns levels. Any remaining nodes are part of + * causality cycles. + * + *

    This procedure is based on Kahn's algorithm for topological sorting. Rather than + * establishing a total order, we establish a partial order. In this order, the level of each + * reaction is the least upper bound of the levels of the reactions it depends on. + */ + private void assignLevels() { + List start = new ArrayList<>(rootNodes()); + + // All root nodes start with level 0. + for (Runtime origin : start) { + origin.level = 0; } - /////////////////////////////////////////////////////////// - //// Private fields - - /** - * Number of reactions per level, represented as a list of - * integers where the indices are the levels. - */ - private List numReactionsPerLevel = new ArrayList<>(List.of(0)); - - /////////////////////////////////////////////////////////// - //// Private methods - - /** - * Analyze the dependencies between reactions and assign each reaction - * instance a level. This method removes nodes from this graph as it - * assigns levels. Any remaining nodes are part of causality cycles. - * - * This procedure is based on Kahn's algorithm for topological sorting. - * Rather than establishing a total order, we establish a partial order. - * In this order, the level of each reaction is the least upper bound of - * the levels of the reactions it depends on. - */ - private void assignLevels() { - List start = new ArrayList<>(rootNodes()); - - // All root nodes start with level 0. - for (Runtime origin : start) { - origin.level = 0; + // No need to do any of this if there are no root nodes; + // the graph must be cyclic. + while (!start.isEmpty()) { + Runtime origin = start.remove(0); + Set toRemove = new LinkedHashSet<>(); + Set downstreamAdjacentNodes = getDownstreamAdjacentNodes(origin); + + // Visit effect nodes. + for (Runtime effect : downstreamAdjacentNodes) { + // Stage edge between origin and effect for removal. + toRemove.add(effect); + + // Update level of downstream node. + effect.level = origin.level + 1; + } + // Remove visited edges. + for (Runtime effect : toRemove) { + removeEdge(effect, origin); + // If the effect node has no more incoming edges, + // then move it in the start set. + if (getUpstreamAdjacentNodes(effect).size() == 0) { + start.add(effect); } + } - // No need to do any of this if there are no root nodes; - // the graph must be cyclic. - while (!start.isEmpty()) { - Runtime origin = start.remove(0); - Set toRemove = new LinkedHashSet<>(); - Set downstreamAdjacentNodes = getDownstreamAdjacentNodes(origin); - - // Visit effect nodes. - for (Runtime effect : downstreamAdjacentNodes) { - // Stage edge between origin and effect for removal. - toRemove.add(effect); + // Remove visited origin. + removeNode(origin); - // Update level of downstream node. - effect.level = origin.level + 1; - } - // Remove visited edges. - for (Runtime effect : toRemove) { - removeEdge(effect, origin); - // If the effect node has no more incoming edges, - // then move it in the start set. - if (getUpstreamAdjacentNodes(effect).size() == 0) { - start.add(effect); - } - } - - // Remove visited origin. - removeNode(origin); - - // Update numReactionsPerLevel info - adjustNumReactionsPerLevel(origin.level, 1); - } + // Update numReactionsPerLevel info + adjustNumReactionsPerLevel(origin.level, 1); } - - /** - * This function assigns inferred deadlines to all the reactions in the graph. - * It is modeled after {@code assignLevels} but it starts at the leaf nodes and uses - * Kahns algorithm to build a reverse topologically sorted graph - * - */ - private void assignInferredDeadlines() { - List start = new ArrayList<>(leafNodes()); - - // All leaf nodes have deadline initialized to their declared deadline or MAX_VALUE - while (!start.isEmpty()) { - Runtime origin = start.remove(0); - Set toRemove = new LinkedHashSet<>(); - Set upstreamAdjacentNodes = getUpstreamAdjacentNodes(origin); - - // Visit effect nodes. - for (Runtime upstream : upstreamAdjacentNodes) { - // Stage edge between origin and upstream for removal. - toRemove.add(upstream); - - // Update deadline of upstream node if origins deadline is earlier. - if (origin.deadline.isEarlierThan(upstream.deadline)) { - upstream.deadline = origin.deadline; - } - } - // Remove visited edges. - for (Runtime upstream : toRemove) { - removeEdge(origin, upstream); - // If the upstream node has no more outgoing edges, - // then move it in the start set. - if (getDownstreamAdjacentNodes(upstream).size() == 0) { - start.add(upstream); - } - } - - // Remove visited origin. - removeNode(origin); + } + + /** + * This function assigns inferred deadlines to all the reactions in the graph. It is modeled after + * {@code assignLevels} but it starts at the leaf nodes and uses Kahns algorithm to build a + * reverse topologically sorted graph + */ + private void assignInferredDeadlines() { + List start = new ArrayList<>(leafNodes()); + + // All leaf nodes have deadline initialized to their declared deadline or MAX_VALUE + while (!start.isEmpty()) { + Runtime origin = start.remove(0); + Set toRemove = new LinkedHashSet<>(); + Set upstreamAdjacentNodes = getUpstreamAdjacentNodes(origin); + + // Visit effect nodes. + for (Runtime upstream : upstreamAdjacentNodes) { + // Stage edge between origin and upstream for removal. + toRemove.add(upstream); + + // Update deadline of upstream node if origins deadline is earlier. + if (origin.deadline.isEarlierThan(upstream.deadline)) { + upstream.deadline = origin.deadline; } - } - - /** - * Adjust {@link #numReactionsPerLevel} at index level by - * adding to the previously recorded number valueToAdd. - * If there is no previously recorded number for this level, then - * create one with index level and value valueToAdd. - * @param level The level. - * @param valueToAdd The value to add to the number of levels. - */ - private void adjustNumReactionsPerLevel(int level, int valueToAdd) { - if (numReactionsPerLevel.size() > level) { - numReactionsPerLevel.set(level, numReactionsPerLevel.get(level) + valueToAdd); - } else { - while (numReactionsPerLevel.size() < level) { - numReactionsPerLevel.add(0); - } - numReactionsPerLevel.add(valueToAdd); + } + // Remove visited edges. + for (Runtime upstream : toRemove) { + removeEdge(origin, upstream); + // If the upstream node has no more outgoing edges, + // then move it in the start set. + if (getDownstreamAdjacentNodes(upstream).size() == 0) { + start.add(upstream); } + } + + // Remove visited origin. + removeNode(origin); } + } + + /** + * Adjust {@link #numReactionsPerLevel} at index level by + * adding to the previously recorded number valueToAdd. + * If there is no previously recorded number for this level, then + * create one with index level and value valueToAdd. + * @param level The level. + * @param valueToAdd The value to add to the number of levels. + */ + private void adjustNumReactionsPerLevel(int level, int valueToAdd) { + if (numReactionsPerLevel.size() > level) { + numReactionsPerLevel.set(level, numReactionsPerLevel.get(level) + valueToAdd); + } else { + while (numReactionsPerLevel.size() < level) { + numReactionsPerLevel.add(0); + } + numReactionsPerLevel.add(valueToAdd); + } + } - /** - * Return the DOT (GraphViz) representation of the graph. - */ - @Override - public String toDOT() { - var dotRepresentation = new CodeBuilder(); - var edges = new StringBuilder(); + /** Return the DOT (GraphViz) representation of the graph. */ + @Override + public String toDOT() { + var dotRepresentation = new CodeBuilder(); + var edges = new StringBuilder(); - // Start the digraph with a left-write rank - dotRepresentation.pr( + // Start the digraph with a left-write rank + dotRepresentation.pr( """ digraph { rankdir=LF; @@ -392,49 +380,52 @@ public String toDOT() { edge [fontname=Times]; """); - var nodes = nodes(); - // Group nodes by levels - var groupedNodes = - nodes.stream() - .collect( - Collectors.groupingBy(it -> it.level) - ); - - dotRepresentation.indent(); - // For each level - for (var level : groupedNodes.keySet()) { - // Create a subgraph - dotRepresentation.pr("subgraph cluster_level_" + level + " {"); - dotRepresentation.pr(" graph [compound=True, label = \"level " + level + "\"];"); - - // Get the nodes at the current level - var currentLevelNodes = groupedNodes.get(level); - for (var node: currentLevelNodes) { - // Draw the node - var label = CUtil.getName(node.getReaction().getParent().tpr) + "." + node.getReaction().getName(); - // Need a positive number to name the nodes in GraphViz - var labelHashCode = label.hashCode() & 0xfffffff; - dotRepresentation.pr(" node_" + labelHashCode + " [label=\""+ label +"\"];"); - - // Draw the edges - var downstreamNodes = getDownstreamAdjacentNodes(node); - for (var downstreamNode: downstreamNodes) { - var downstreamLabel = CUtil.getName(downstreamNode.getReaction().getParent().tpr) + "." + downstreamNode.getReaction().getName(); - edges.append(" node_" + labelHashCode + " -> node_" + - (downstreamLabel.hashCode() & 0xfffffff) + ";\n" - ); - } - } - // Close the subgraph - dotRepresentation.pr("}"); + var nodes = nodes(); + // Group nodes by levels + var groupedNodes = nodes.stream().collect(Collectors.groupingBy(it -> it.level)); + + dotRepresentation.indent(); + // For each level + for (var level : groupedNodes.keySet()) { + // Create a subgraph + dotRepresentation.pr("subgraph cluster_level_" + level + " {"); + dotRepresentation.pr(" graph [compound=True, label = \"level " + level + "\"];"); + + // Get the nodes at the current level + var currentLevelNodes = groupedNodes.get(level); + for (var node : currentLevelNodes) { + // Draw the node + var label = + CUtil.getName(node.getReaction().getParent().tpr) + "." + node.getReaction().getName(); + // Need a positive number to name the nodes in GraphViz + var labelHashCode = label.hashCode() & 0xfffffff; + dotRepresentation.pr(" node_" + labelHashCode + " [label=\"" + label + "\"];"); + + // Draw the edges + var downstreamNodes = getDownstreamAdjacentNodes(node); + for (var downstreamNode : downstreamNodes) { + var downstreamLabel = + CUtil.getName(downstreamNode.getReaction().getParent().tpr) + + "." + + downstreamNode.getReaction().getName(); + edges.append( + " node_" + + labelHashCode + + " -> node_" + + (downstreamLabel.hashCode() & 0xfffffff) + + ";\n"); } - dotRepresentation.unindent(); - // Add the edges to the definition of the graph at the bottom - dotRepresentation.pr(edges); - // Close the digraph - dotRepresentation.pr("}"); - - // Return the DOT representation - return dotRepresentation.toString(); + } + // Close the subgraph + dotRepresentation.pr("}"); } + dotRepresentation.unindent(); + // Add the edges to the definition of the graph at the bottom + dotRepresentation.pr(edges); + // Close the digraph + dotRepresentation.pr("}"); + + // Return the DOT representation + return dotRepresentation.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index e40c3f988a..3bb132ce01 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -1,28 +1,28 @@ /** A data structure for a reactor instance. */ /************* -Copyright (c) 2019-2022, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2022, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; @@ -37,11 +37,10 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Map; import java.util.Optional; import java.util.Set; - -import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.generator.TriggerInstance.BuiltinTriggerVariable; import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; @@ -68,1122 +67,1092 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.WidthSpec; /** - * Representation of a compile-time instance of a reactor. - * If the reactor is instantiated as a bank of reactors, or if any - * of its parents is instantiated as a bank of reactors, then one instance - * of this ReactorInstance class represents all the runtime instances within - * these banks. The {@link #getTotalWidth()} method returns the number of such - * runtime instances, which is the product of the bank width of this reactor - * instance and the bank widths of all of its parents. - * There is exactly one instance of this ReactorInstance class for each - * graphical rendition of a reactor in the diagram view. + * Representation of a compile-time instance of a reactor. If the reactor is instantiated as a bank + * of reactors, or if any of its parents is instantiated as a bank of reactors, then one instance of + * this ReactorInstance class represents all the runtime instances within these banks. The {@link + * #getTotalWidth()} method returns the number of such runtime instances, which is the product of + * the bank width of this reactor instance and the bank widths of all of its parents. There is + * exactly one instance of this ReactorInstance class for each graphical rendition of a reactor in + * the diagram view. * - * For the main reactor, which has no parent, once constructed, - * this object represents the entire Lingua Franca program. - * If the program has causality loops (a programming error), then - * {@link #hasCycles()} will return true and {@link #getCycles()} will - * return the ports and reaction instances involved in the cycles. + *

    For the main reactor, which has no parent, once constructed, this object represents the entire + * Lingua Franca program. If the program has causality loops (a programming error), then {@link + * #hasCycles()} will return true and {@link #getCycles()} will return the ports and reaction + * instances involved in the cycles. * * @author Marten Lohstroh * @author Edward A. Lee */ public class ReactorInstance extends NamedInstance { - /** - * Create a new instantiation hierarchy that starts with the given top-level reactor. - * @param reactor The top-level reactor. - * @param reporter The error reporter. - */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter) { - this(ASTUtils.createInstantiation(reactor), null, reporter, -1); + /** + * Create a new instantiation hierarchy that starts with the given top-level reactor. + * + * @param reactor The top-level reactor. + * @param reporter The error reporter. + */ + public ReactorInstance(Reactor reactor, ErrorReporter reporter) { + this(ASTUtils.createInstantiation(reactor), null, reporter, -1); + } + + /** + * Create a new instantiation hierarchy that starts with the given top-level reactor but only + * creates contained reactors up to the specified depth. + * + * @param reactor The top-level reactor. + * @param reporter The error reporter. + * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. + */ + public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth) { + this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth); + } + + /** + * Create a new instantiation with the specified parent. This constructor is here to allow for + * unit tests. It should not be used for any other purpose. + * + * @param reactor The top-level reactor. + * @param parent The parent reactor instance. + * @param reporter The error reporter. + */ + public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter) { + this(ASTUtils.createInstantiation(reactor), parent, reporter, -1); + } + + ////////////////////////////////////////////////////// + //// Public fields. + + /** The action instances belonging to this reactor instance. */ + public List actions = new ArrayList<>(); + + /** + * The contained reactor instances, in order of declaration. For banks of reactors, this includes + * both the bank definition Reactor (which has bankIndex == -2) followed by each of the bank + * members (which have bankIndex >= 0). + */ + public final List children = new ArrayList<>(); + + /** The input port instances belonging to this reactor instance. */ + public final List inputs = new ArrayList<>(); + + /** The output port instances belonging to this reactor instance. */ + public final List outputs = new ArrayList<>(); + + /** The parameters of this instance. */ + public final List parameters = new ArrayList<>(); + + /** List of reaction instances for this reactor instance. */ + public final List reactions = new ArrayList<>(); + + /** List of watchdog instances for this reactor instance. */ + public final List watchdogs = new ArrayList<>(); + + /** The timer instances belonging to this reactor instance. */ + public final List timers = new ArrayList<>(); + + /** The mode instances belonging to this reactor instance. */ + public final List modes = new ArrayList<>(); + + /** The reactor declaration in the AST. This is either an import or Reactor declaration. */ + public final ReactorDecl reactorDeclaration; + + /** The reactor after imports are resolve. */ + public final Reactor reactorDefinition; + + /** Indicator that this reactor has itself as a parent, an error condition. */ + public final boolean recursive; + + public TypeParameterizedReactor tpr; + + ////////////////////////////////////////////////////// + //// Public methods. + + /** + * Assign levels to all reactions within the same root as this reactor. The level of a reaction r + * is equal to the length of the longest chain of reactions that must have the opportunity to + * execute before r at each logical tag. This fails and returns false if a causality cycle exists. + * + *

    This method uses a variant of Kahn's algorithm, which is linear in V + E, where V is the + * number of vertices (reactions) and E is the number of edges (dependencies between reactions). + * + * @return An empty graph if successful and otherwise a graph with runtime reaction instances that + * form cycles. + */ + public ReactionInstanceGraph assignLevels() { + if (depth != 0) return root().assignLevels(); + if (cachedReactionLoopGraph == null) { + cachedReactionLoopGraph = new ReactionInstanceGraph(this); } - - /** - * Create a new instantiation hierarchy that starts with the given top-level reactor - * but only creates contained reactors up to the specified depth. - * @param reactor The top-level reactor. - * @param reporter The error reporter. - * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. - */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth) { - this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth); + return cachedReactionLoopGraph; + } + + /** + * This function assigns/propagates deadlines through the Reaction Instance Graph. It performs + * Kahn's algorithm in reverse, starting from the leaf nodes and propagates deadlines upstream. To + * reduce cost, it should only be invoked when there are user-specified deadlines in the program. + * + * @return + */ + public ReactionInstanceGraph assignDeadlines() { + if (depth != 0) return root().assignDeadlines(); + if (cachedReactionLoopGraph == null) { + cachedReactionLoopGraph = new ReactionInstanceGraph(this); } - - /** - * Create a new instantiation with the specified parent. - * This constructor is here to allow for unit tests. - * It should not be used for any other purpose. - * @param reactor The top-level reactor. - * @param parent The parent reactor instance. - * @param reporter The error reporter. - */ - public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter) { - this(ASTUtils.createInstantiation(reactor), parent, reporter, -1); + cachedReactionLoopGraph.rebuildAndAssignDeadlines(); + return cachedReactionLoopGraph; + } + + /** + * Return the instance of a child rector created by the specified definition or null if there is + * none. + * + * @param definition The definition of the child reactor ("new" statement). + */ + public ReactorInstance getChildReactorInstance(Instantiation definition) { + for (ReactorInstance child : this.children) { + if (child.definition == definition) { + return child; + } } - - ////////////////////////////////////////////////////// - //// Public fields. - - /** The action instances belonging to this reactor instance. */ - public List actions = new ArrayList<>(); - - /** - * The contained reactor instances, in order of declaration. - * For banks of reactors, this includes both the bank definition - * Reactor (which has bankIndex == -2) followed by each of the - * bank members (which have bankIndex >= 0). - */ - public final List children = new ArrayList<>(); - - /** The input port instances belonging to this reactor instance. */ - public final List inputs = new ArrayList<>(); - - /** The output port instances belonging to this reactor instance. */ - public final List outputs = new ArrayList<>(); - - /** The parameters of this instance. */ - public final List parameters = new ArrayList<>(); - - /** List of reaction instances for this reactor instance. */ - public final List reactions = new ArrayList<>(); - - /** List of watchdog instances for this reactor instance. */ - public final List watchdogs = new ArrayList<>(); - - /** The timer instances belonging to this reactor instance. */ - public final List timers = new ArrayList<>(); - - /** The mode instances belonging to this reactor instance. */ - public final List modes = new ArrayList<>(); - - /** The reactor declaration in the AST. This is either an import or Reactor declaration. */ - public final ReactorDecl reactorDeclaration; - - /** The reactor after imports are resolve. */ - public final Reactor reactorDefinition; - - /** Indicator that this reactor has itself as a parent, an error condition. */ - public final boolean recursive; - - public TypeParameterizedReactor tpr; - - ////////////////////////////////////////////////////// - //// Public methods. - - /** - * Assign levels to all reactions within the same root as this - * reactor. The level of a reaction r is equal to the length of the - * longest chain of reactions that must have the opportunity to - * execute before r at each logical tag. This fails and returns - * false if a causality cycle exists. - * - * This method uses a variant of Kahn's algorithm, which is linear - * in V + E, where V is the number of vertices (reactions) and E - * is the number of edges (dependencies between reactions). - * - * @return An empty graph if successful and otherwise a graph - * with runtime reaction instances that form cycles. - */ - public ReactionInstanceGraph assignLevels() { - if (depth != 0) return root().assignLevels(); - if (cachedReactionLoopGraph == null) { - cachedReactionLoopGraph = new ReactionInstanceGraph(this); - } - return cachedReactionLoopGraph; - } - - /** - * This function assigns/propagates deadlines through the Reaction Instance Graph. - * It performs Kahn's algorithm in reverse, starting from the leaf nodes and - * propagates deadlines upstream. To reduce cost, it should only be invoked when - * there are user-specified deadlines in the program. - * @return - */ - public ReactionInstanceGraph assignDeadlines() { - if (depth != 0) return root().assignDeadlines(); - if (cachedReactionLoopGraph == null) { - cachedReactionLoopGraph = new ReactionInstanceGraph(this); - } - cachedReactionLoopGraph.rebuildAndAssignDeadlines(); - return cachedReactionLoopGraph; + return null; + } + + /** + * Clear any cached data in this reactor and its children. This is useful if a mutation has been + * realized. + */ + public void clearCaches() { + clearCaches(true); + } + + /** + * Clear any cached data in this reactor and its children. This is useful if a mutation has been + * realized. + * + * @param includingRuntimes If false, leave the runtime instances of reactions intact. This is + * useful for federated execution where levels are computed using the top-level connections, + * but then those connections are discarded. + */ + public void clearCaches(boolean includingRuntimes) { + if (includingRuntimes) cachedReactionLoopGraph = null; + for (ReactorInstance child : children) { + child.clearCaches(includingRuntimes); } - - /** - * Return the instance of a child rector created by the specified - * definition or null if there is none. - * @param definition The definition of the child reactor ("new" statement). - */ - public ReactorInstance getChildReactorInstance(Instantiation definition) { - for (ReactorInstance child : this.children) { - if (child.definition == definition) { - return child; - } - } - return null; + for (PortInstance port : inputs) { + port.clearCaches(); } - - /** - * Clear any cached data in this reactor and its children. - * This is useful if a mutation has been realized. - */ - public void clearCaches() { - clearCaches(true); + for (PortInstance port : outputs) { + port.clearCaches(); } - - /** - * Clear any cached data in this reactor and its children. - * This is useful if a mutation has been realized. - * @param includingRuntimes If false, leave the runtime instances of reactions intact. - * This is useful for federated execution where levels are computed using - * the top-level connections, but then those connections are discarded. - */ - public void clearCaches(boolean includingRuntimes) { - if (includingRuntimes) cachedReactionLoopGraph = null; - for (ReactorInstance child : children) { - child.clearCaches(includingRuntimes); - } - for (PortInstance port : inputs) { - port.clearCaches(); - } - for (PortInstance port : outputs) { - port.clearCaches(); - } - for (ReactionInstance reaction : reactions) { - reaction.clearCaches(includingRuntimes); - } - cachedCycles = null; + for (ReactionInstance reaction : reactions) { + reaction.clearCaches(includingRuntimes); } - - /** - * Return the set of ReactionInstance and PortInstance that form causality - * loops in the topmost parent reactor in the instantiation hierarchy. This will return an - * empty set if there are no causality loops. - */ - public Set> getCycles() { - if (depth != 0) return root().getCycles(); - if (cachedCycles != null) return cachedCycles; - cachedCycles = new LinkedHashSet<>(); - - ReactionInstanceGraph reactionRuntimes = assignLevels(); - if (reactionRuntimes.nodes().size() > 0) { - Set reactions = new LinkedHashSet<>(); - Set ports = new LinkedHashSet<>(); - // There are cycles. But the nodes set includes not - // just the cycles, but also nodes that are downstream of the - // cycles. Use Tarjan's algorithm to get just the cycles. - var cycleNodes = reactionRuntimes.getCycles(); - for (var cycle : cycleNodes) { - for (ReactionInstance.Runtime runtime : cycle) { - reactions.add(runtime.getReaction()); - } - } - // Need to figure out which ports are involved in the cycles. - // It may not be all ports that depend on this reaction. - for (ReactionInstance r : reactions) { - for (TriggerInstance p : r.effects) { - if (p instanceof PortInstance) { - findPaths((PortInstance)p, reactions, ports); - } - } - } - cachedCycles.addAll(reactions); - cachedCycles.addAll(ports); + cachedCycles = null; + } + + /** + * Return the set of ReactionInstance and PortInstance that form causality loops in the topmost + * parent reactor in the instantiation hierarchy. This will return an empty set if there are no + * causality loops. + */ + public Set> getCycles() { + if (depth != 0) return root().getCycles(); + if (cachedCycles != null) return cachedCycles; + cachedCycles = new LinkedHashSet<>(); + + ReactionInstanceGraph reactionRuntimes = assignLevels(); + if (reactionRuntimes.nodes().size() > 0) { + Set reactions = new LinkedHashSet<>(); + Set ports = new LinkedHashSet<>(); + // There are cycles. But the nodes set includes not + // just the cycles, but also nodes that are downstream of the + // cycles. Use Tarjan's algorithm to get just the cycles. + var cycleNodes = reactionRuntimes.getCycles(); + for (var cycle : cycleNodes) { + for (ReactionInstance.Runtime runtime : cycle) { + reactions.add(runtime.getReaction()); } - - return cachedCycles; - } - - /** - * Return the specified input by name or null if there is no such input. - * @param name The input name. - */ - public PortInstance getInput(String name) { - for (PortInstance port: inputs) { - if (port.getName().equals(name)) { - return port; - } + } + // Need to figure out which ports are involved in the cycles. + // It may not be all ports that depend on this reaction. + for (ReactionInstance r : reactions) { + for (TriggerInstance p : r.effects) { + if (p instanceof PortInstance) { + findPaths((PortInstance) p, reactions, ports); + } } - return null; + } + cachedCycles.addAll(reactions); + cachedCycles.addAll(ports); } - /** - * Override the base class to append [i_d], where d is the depth, - * if this reactor is in a bank of reactors. - * @return The name of this instance. - */ - @Override - public String getName() { - return this.definition.getName(); + return cachedCycles; + } + + /** + * Return the specified input by name or null if there is no such input. + * + * @param name The input name. + */ + public PortInstance getInput(String name) { + for (PortInstance port : inputs) { + if (port.getName().equals(name)) { + return port; + } } - - /** - * @see NamedInstance#uniqueID() - * - * Append {@code _main} to the name of the main reactor to allow instantiations - * within that reactor to have the same name. - */ - @Override - public String uniqueID() { - if (this.isMainOrFederated()) { - if (reactorDefinition.isFederated() && !super.uniqueID().startsWith("federate__")) return "federate__" + super.uniqueID() + "_main"; - return super.uniqueID() + "_main"; - } - return super.uniqueID(); + return null; + } + + /** + * Override the base class to append [i_d], where d is the depth, if this reactor is in a bank of + * reactors. + * + * @return The name of this instance. + */ + @Override + public String getName() { + return this.definition.getName(); + } + + /** + * @see NamedInstance#uniqueID() + *

    Append {@code _main} to the name of the main reactor to allow instantiations within that + * reactor to have the same name. + */ + @Override + public String uniqueID() { + if (this.isMainOrFederated()) { + if (reactorDefinition.isFederated() && !super.uniqueID().startsWith("federate__")) + return "federate__" + super.uniqueID() + "_main"; + return super.uniqueID() + "_main"; } - - /** - * Return the specified output by name or null if there is no such output. - * @param name The output name. - */ - public PortInstance getOutput(String name) { - for (PortInstance port: outputs) { - if (port.getName().equals(name)) { - return port; - } - } - return null; + return super.uniqueID(); + } + + /** + * Return the specified output by name or null if there is no such output. + * + * @param name The output name. + */ + public PortInstance getOutput(String name) { + for (PortInstance port : outputs) { + if (port.getName().equals(name)) { + return port; + } } - - /** - * Return a parameter matching the specified name if the reactor has one - * and otherwise return null. - * @param name The parameter name. - */ - public ParameterInstance getParameter(String name) { - for (ParameterInstance parameter: parameters) { - if (parameter.getName().equals(name)) { - return parameter; - } - } - return null; + return null; + } + + /** + * Return a parameter matching the specified name if the reactor has one and otherwise return + * null. + * + * @param name The parameter name. + */ + public ParameterInstance getParameter(String name) { + for (ParameterInstance parameter : parameters) { + if (parameter.getName().equals(name)) { + return parameter; + } } - - /** - * Return the startup trigger or null if not used in any reaction. - */ - public TriggerInstance getStartupTrigger() { - return builtinTriggers.get(BuiltinTrigger.STARTUP); + return null; + } + + /** Return the startup trigger or null if not used in any reaction. */ + public TriggerInstance getStartupTrigger() { + return builtinTriggers.get(BuiltinTrigger.STARTUP); + } + + /** Return the shutdown trigger or null if not used in any reaction. */ + public TriggerInstance getShutdownTrigger() { + return builtinTriggers.get(BuiltinTrigger.SHUTDOWN); + } + + /** + * If this reactor is a bank or any of its parents is a bank, return the total number of runtime + * instances, which is the product of the widths of all the parents. Return -1 if the width cannot + * be determined. + */ + public int getTotalWidth() { + return getTotalWidth(0); + } + + /** + * If this reactor is a bank or any of its parents is a bank, return the total number of runtime + * instances, which is the product of the widths of all the parents. Return -1 if the width cannot + * be determined. + * + * @param atDepth The depth at which to determine the width. Use 0 to get the total number of + * instances. Use 1 to get the number of instances within a single top-level bank member (this + * is useful for federates). + */ + public int getTotalWidth(int atDepth) { + if (width <= 0) return -1; + if (depth <= atDepth) return 1; + int result = width; + ReactorInstance p = parent; + while (p != null && p.depth > atDepth) { + if (p.width <= 0) return -1; + result *= p.width; + p = p.parent; } - - /** - * Return the shutdown trigger or null if not used in any reaction. - */ - public TriggerInstance getShutdownTrigger() { - return builtinTriggers.get(BuiltinTrigger.SHUTDOWN); + return result; + } + + /** + * Return the trigger instances (input ports, timers, and actions that trigger reactions) + * belonging to this reactor instance. + */ + public Set> getTriggers() { + // FIXME: Cache this. + var triggers = new LinkedHashSet>(); + for (ReactionInstance reaction : this.reactions) { + triggers.addAll(reaction.triggers); } - - /** - * If this reactor is a bank or any of its parents is a bank, - * return the total number of runtime instances, which is the product - * of the widths of all the parents. - * Return -1 if the width cannot be determined. - */ - public int getTotalWidth() { - return getTotalWidth(0); + return triggers; + } + + /** + * Return the trigger instances (input ports, timers, and actions that trigger reactions) together + * the ports that the reaction reads but that don't trigger it. + * + * @return The trigger instances belonging to this reactor instance. + */ + public Set> getTriggersAndReads() { + // FIXME: Cache this. + var triggers = new LinkedHashSet>(); + for (ReactionInstance reaction : this.reactions) { + triggers.addAll(reaction.triggers); + triggers.addAll(reaction.reads); } + return triggers; + } + + /** Return true if the top-level parent of this reactor has causality cycles. */ + public boolean hasCycles() { + return assignLevels().nodeCount() != 0; + } + + /** + * Given a parameter definition for this reactor, return the initial integer value of the + * parameter. If the parameter is overridden when instantiating this reactor or any of its + * containing reactors, use that value. Otherwise, use the default value in the reactor + * definition. If the parameter cannot be found or its value is not an integer, return null. + * + * @param parameter The parameter definition (a syntactic object in the AST). + * @return An integer value or null. + */ + public Integer initialIntParameterValue(Parameter parameter) { + return ASTUtils.initialValueInt(parameter, instantiations()); + } + + public Expression resolveParameters(Expression e) { + return LfExpressionVisitor.dispatch(e, this, ParameterInliner.INSTANCE); + } + + private static final class ParameterInliner + extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { + static final ParameterInliner INSTANCE = new ParameterInliner(); - /** - * If this reactor is a bank or any of its parents is a bank, - * return the total number of runtime instances, which is the product - * of the widths of all the parents. - * Return -1 if the width cannot be determined. - * @param atDepth The depth at which to determine the width. - * Use 0 to get the total number of instances. - * Use 1 to get the number of instances within a single top-level - * bank member (this is useful for federates). - */ - public int getTotalWidth(int atDepth) { - if (width <= 0) return -1; - if (depth <= atDepth) return 1; - int result = width; - ReactorInstance p = parent; - while (p != null && p.depth > atDepth) { - if (p.width <= 0) return -1; - result *= p.width; - p = p.parent; + @Override + public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { + if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { + throw new IllegalArgumentException( + "Parameter " + + expr.getParameter().getName() + + " is not a parameter of reactor instance " + + instance.getName() + + "."); + } + + Optional assignment = + instance.definition.getParameters().stream() + .filter(it -> it.getLhs().equals(expr.getParameter())) + .findAny(); // There is at most one + + if (assignment.isPresent()) { + // replace the parameter with its value. + Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); + // recursively resolve parameters + return instance.getParent().resolveParameters(value); + } else { + // In that case use the default value. Default values + // cannot use parameter values, so they don't need to + // be recursively resolved. + Initializer init = expr.getParameter().getInit(); + Expression defaultValue = ASTUtils.asSingleExpr(init); + if (defaultValue == null) { + // this is a problem + return super.visitParameterRef(expr, instance); } - return result; + return defaultValue; + } } - - /** - * Return the trigger instances (input ports, timers, and actions - * that trigger reactions) belonging to this reactor instance. - */ - public Set> getTriggers() { - // FIXME: Cache this. - var triggers = new LinkedHashSet>(); - for (ReactionInstance reaction : this.reactions) { - triggers.addAll(reaction.triggers); + } + + /** + * Return a list of Instantiation objects for evaluating parameter values. The first object in the + * list is the AST Instantiation that created this reactor instance, the second is the AST + * instantiation that created the containing reactor instance, and so on until there are no more + * containing reactor instances. This will return an empty list if this reactor instance is at the + * top level (is main). + */ + public List instantiations() { + if (_instantiations == null) { + _instantiations = new ArrayList<>(); + if (definition != null) { + _instantiations.add(definition); + if (parent != null) { + _instantiations.addAll(parent.instantiations()); } - return triggers; + } } - - /** - * Return the trigger instances (input ports, timers, and actions - * that trigger reactions) together the ports that the reaction reads - * but that don't trigger it. - * - * @return The trigger instances belonging to this reactor instance. - */ - public Set> getTriggersAndReads() { - // FIXME: Cache this. - var triggers = new LinkedHashSet>(); - for (ReactionInstance reaction : this.reactions) { - triggers.addAll(reaction.triggers); - triggers.addAll(reaction.reads); - } - return triggers; + return _instantiations; + } + + /** + * Returns true if this is a bank of reactors. + * + * @return true if a reactor is a bank, false otherwise + */ + public boolean isBank() { + return definition.getWidthSpec() != null; + } + + /** + * Returns whether this is a main or federated reactor. + * + * @return true if reactor definition is marked as main or federated, false otherwise. + */ + public boolean isMainOrFederated() { + return reactorDefinition != null + && (reactorDefinition.isMain() || reactorDefinition.isFederated()); + } + + /** + * Return true if the specified reactor instance is either equal to this reactor instance or a + * parent of it. + * + * @param r The reactor instance. + */ + public boolean isParent(ReactorInstance r) { + ReactorInstance p = this; + while (p != null) { + if (p == r) return true; + p = p.getParent(); } - - /** - * Return true if the top-level parent of this reactor has causality cycles. - */ - public boolean hasCycles() { - return assignLevels().nodeCount() != 0; + return false; + } + + /////////////////////////////////////////////////// + //// Methods for finding instances in this reactor given an AST node. + + /** + * Return the action instance within this reactor instance corresponding to the specified action + * reference. + * + * @param action The action as an AST node. + * @return The corresponding action instance or null if the action does not belong to this + * reactor. + */ + public ActionInstance lookupActionInstance(Action action) { + for (ActionInstance actionInstance : actions) { + if (actionInstance.definition == action) { + return actionInstance; + } } - - /** - * Given a parameter definition for this reactor, return the initial integer - * value of the parameter. If the parameter is overridden when instantiating - * this reactor or any of its containing reactors, use that value. - * Otherwise, use the default value in the reactor definition. - * If the parameter cannot be found or its value is not an integer, return null. - * - * @param parameter The parameter definition (a syntactic object in the AST). - * - * @return An integer value or null. - */ - public Integer initialIntParameterValue(Parameter parameter) { - return ASTUtils.initialValueInt(parameter, instantiations()); + return null; + } + + /** + * Given a parameter definition, return the parameter instance corresponding to that definition, + * or null if there is no such instance. + * + * @param parameter The parameter definition (a syntactic object in the AST). + * @return A parameter instance, or null if there is none. + */ + public ParameterInstance lookupParameterInstance(Parameter parameter) { + for (ParameterInstance param : parameters) { + if (param.definition == parameter) { + return param; + } } - - public Expression resolveParameters(Expression e) { - return LfExpressionVisitor.dispatch(e, this, ParameterInliner.INSTANCE); + return null; + } + + /** + * Given a port definition, return the port instance corresponding to that definition, or null if + * there is no such instance. + * + * @param port The port definition (a syntactic object in the AST). + * @return A port instance, or null if there is none. + */ + public PortInstance lookupPortInstance(Port port) { + // Search one of the inputs and outputs sets. + List ports = null; + if (port instanceof Input) { + ports = this.inputs; + } else if (port instanceof Output) { + ports = this.outputs; } - - - private static final class ParameterInliner extends LfExpressionVisitor.LfExpressionDeepCopyVisitor { - static final ParameterInliner INSTANCE = new ParameterInliner(); - - @Override - public Expression visitParameterRef(ParameterReference expr, ReactorInstance instance) { - if (!ASTUtils.belongsTo(expr.getParameter(), instance.definition)) { - throw new IllegalArgumentException("Parameter " - + expr.getParameter().getName() - + " is not a parameter of reactor instance " - + instance.getName() - + "." - ); - } - - Optional assignment = - instance.definition.getParameters().stream() - .filter(it -> it.getLhs().equals(expr.getParameter())) - .findAny(); // There is at most one - - if (assignment.isPresent()) { - // replace the parameter with its value. - Expression value = ASTUtils.asSingleExpr(assignment.get().getRhs()); - // recursively resolve parameters - return instance.getParent().resolveParameters(value); - } else { - // In that case use the default value. Default values - // cannot use parameter values, so they don't need to - // be recursively resolved. - Initializer init = expr.getParameter().getInit(); - Expression defaultValue = ASTUtils.asSingleExpr(init); - if (defaultValue == null) { - // this is a problem - return super.visitParameterRef(expr, instance); - } - return defaultValue; - } - } + for (PortInstance portInstance : ports) { + if (portInstance.definition == port) { + return portInstance; + } } - - /** - * Return a list of Instantiation objects for evaluating parameter - * values. The first object in the list is the AST Instantiation - * that created this reactor instance, the second is the AST instantiation - * that created the containing reactor instance, and so on until there - * are no more containing reactor instances. This will return an empty - * list if this reactor instance is at the top level (is main). - */ - public List instantiations() { - if (_instantiations == null) { - _instantiations = new ArrayList<>(); - if (definition != null) { - _instantiations.add(definition); - if (parent != null) { - _instantiations.addAll(parent.instantiations()); - } - } - } - return _instantiations; + return null; + } + + /** + * Given a reference to a port belonging to this reactor instance, return the port instance. + * Return null if there is no such instance. + * + * @param reference The port reference. + * @return A port instance, or null if there is none. + */ + public PortInstance lookupPortInstance(VarRef reference) { + if (!(reference.getVariable() instanceof Port)) { + // Trying to resolve something that is not a port + return null; } - - /** - * Returns true if this is a bank of reactors. - * @return true if a reactor is a bank, false otherwise - */ - public boolean isBank() { - return definition.getWidthSpec() != null; + if (reference.getContainer() == null) { + // Handle local reference + return lookupPortInstance((Port) reference.getVariable()); + } else { + // Handle hierarchical reference + var containerInstance = getChildReactorInstance(reference.getContainer()); + if (containerInstance == null) return null; + return containerInstance.lookupPortInstance((Port) reference.getVariable()); } - - /** - * Returns whether this is a main or federated reactor. - * @return true if reactor definition is marked as main or federated, false otherwise. - */ - public boolean isMainOrFederated() { - return reactorDefinition != null - && (reactorDefinition.isMain() || reactorDefinition.isFederated()); + } + + /** + * Return the reaction instance within this reactor instance corresponding to the specified + * reaction. + * + * @param reaction The reaction as an AST node. + * @return The corresponding reaction instance or null if the reaction does not belong to this + * reactor. + */ + public ReactionInstance lookupReactionInstance(Reaction reaction) { + for (ReactionInstance reactionInstance : reactions) { + if (reactionInstance.definition == reaction) { + return reactionInstance; + } } - - /** - * Return true if the specified reactor instance is either equal to this - * reactor instance or a parent of it. - * @param r The reactor instance. - */ - public boolean isParent(ReactorInstance r) { - ReactorInstance p = this; - while (p != null) { - if (p == r) return true; - p = p.getParent(); - } - return false; + return null; + } + + /** + * Return the reactor instance within this reactor that has the specified instantiation. Note that + * this may be a bank of reactors. Return null if there is no such reactor instance. + */ + public ReactorInstance lookupReactorInstance(Instantiation instantiation) { + for (ReactorInstance reactorInstance : children) { + if (reactorInstance.definition == instantiation) { + return reactorInstance; + } } - - /////////////////////////////////////////////////// - //// Methods for finding instances in this reactor given an AST node. - - /** - * Return the action instance within this reactor - * instance corresponding to the specified action reference. - * @param action The action as an AST node. - * @return The corresponding action instance or null if the - * action does not belong to this reactor. - */ - public ActionInstance lookupActionInstance(Action action) { - for (ActionInstance actionInstance : actions) { - if (actionInstance.definition == action) { - return actionInstance; - } - } - return null; + return null; + } + + /** + * Return the timer instance within this reactor instance corresponding to the specified timer + * reference. + * + * @param timer The timer as an AST node. + * @return The corresponding timer instance or null if the timer does not belong to this reactor. + */ + public TimerInstance lookupTimerInstance(Timer timer) { + for (TimerInstance timerInstance : timers) { + if (timerInstance.definition == timer) { + return timerInstance; + } } - - /** - * Given a parameter definition, return the parameter instance - * corresponding to that definition, or null if there is - * no such instance. - * @param parameter The parameter definition (a syntactic object in the AST). - * @return A parameter instance, or null if there is none. - */ - public ParameterInstance lookupParameterInstance(Parameter parameter) { - for (ParameterInstance param : parameters) { - if (param.definition == parameter) { - return param; - } - } - return null; + return null; + } + + /** + * Returns the mode instance within this reactor instance corresponding to the specified mode + * reference. + * + * @param mode The mode as an AST node. + * @return The corresponding mode instance or null if the mode does not belong to this reactor. + */ + public ModeInstance lookupModeInstance(Mode mode) { + for (ModeInstance modeInstance : modes) { + if (modeInstance.definition == mode) { + return modeInstance; + } } - - /** - * Given a port definition, return the port instance - * corresponding to that definition, or null if there is - * no such instance. - * @param port The port definition (a syntactic object in the AST). - * @return A port instance, or null if there is none. - */ - public PortInstance lookupPortInstance(Port port) { - // Search one of the inputs and outputs sets. - List ports = null; - if (port instanceof Input) { - ports = this.inputs; - } else if (port instanceof Output) { - ports = this.outputs; + return null; + } + + /** Return a descriptive string. */ + @Override + public String toString() { + return "ReactorInstance " + getFullName(); + } + + /** + * Assuming that the given expression denotes a valid time, return a time value. + * + *

    If the value is given as a parameter reference, this will look up the precise time value + * assigned to this reactor instance. + */ + public TimeValue getTimeValue(Expression expr) { + Expression resolved = resolveParameters(expr); + return getLiteralTimeValue(resolved); + } + + ////////////////////////////////////////////////////// + //// Protected fields. + + /** The generator that created this reactor instance. */ + protected ErrorReporter reporter; // FIXME: This accumulates a lot of redundant references + + /** The map of used built-in triggers. */ + protected Map> builtinTriggers = + new HashMap<>(); + + /** + * The LF syntax does not currently support declaring reactions unordered, but unordered reactions + * are created in the AST transformations handling federated communication and after delays. + * Unordered reactions can execute in any order and concurrently even though they are in the same + * reactor. FIXME: Remove this when the language provides syntax. + */ + protected Set unorderedReactions = new LinkedHashSet<>(); + + /** The nested list of instantiations that created this reactor instance. */ + protected List _instantiations; + + ////////////////////////////////////////////////////// + //// Protected methods. + + /** + * Create all the reaction instances of this reactor instance and record the dependencies and + * antidependencies between ports, actions, and timers and reactions. This also records the + * dependencies between reactions that follows from the order in which they are defined. + */ + protected void createReactionInstances() { + List reactions = ASTUtils.allReactions(reactorDefinition); + if (reactions != null) { + int count = 0; + + // Check for startup and shutdown triggers. + for (Reaction reaction : reactions) { + if (AttributeUtils.isUnordered(reaction)) { + unorderedReactions.add(reaction); } - for (PortInstance portInstance : ports) { - if (portInstance.definition == port) { - return portInstance; - } - } - return null; + // Create the reaction instance. + var reactionInstance = + new ReactionInstance(reaction, this, unorderedReactions.contains(reaction), count++); + + // Add the reaction instance to the map of reactions for this + // reactor. + this.reactions.add(reactionInstance); + } } - - /** - * Given a reference to a port belonging to this reactor - * instance, return the port instance. - * Return null if there is no such instance. - * @param reference The port reference. - * @return A port instance, or null if there is none. - */ - public PortInstance lookupPortInstance(VarRef reference) { - if (!(reference.getVariable() instanceof Port)) { - // Trying to resolve something that is not a port - return null; - } - if (reference.getContainer() == null) { - // Handle local reference - return lookupPortInstance((Port) reference.getVariable()); + } + + /** Returns the built-in trigger or create a new one if none exists. */ + protected TriggerInstance getOrCreateBuiltinTrigger( + BuiltinTriggerRef trigger) { + return builtinTriggers.computeIfAbsent( + trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); + } + + /** Create all the watchdog instances of this reactor instance. */ + protected void createWatchdogInstances() { + List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); + if (watchdogs != null) { + for (Watchdog watchdog : watchdogs) { + // Create the watchdog instance. + var watchdogInstance = new WatchdogInstance(watchdog, this); + + // Add the watchdog instance to the list of watchdogs for this + // reactor. + this.watchdogs.add(watchdogInstance); + } + } + } + + //////////////////////////////////////// + //// Private constructors + + /** + * Create a runtime instance from the specified definition and with the specified parent that + * instantiated it. + * + * @param definition The instantiation statement in the AST. + * @param parent The parent, or null for the main rector. + * @param reporter An error reporter. + * @param desiredDepth The depth to which to expand the hierarchy. + */ + public ReactorInstance( + Instantiation definition, ReactorInstance parent, ErrorReporter reporter, int desiredDepth) { + super(definition, parent); + this.reporter = reporter; + this.reactorDeclaration = definition.getReactorClass(); + this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); + this.tpr = new TypeParameterizedReactor(definition); + + // check for recursive instantiation + var currentParent = parent; + var foundSelfAsParent = false; + do { + if (currentParent != null) { + if (currentParent.reactorDefinition == this.reactorDefinition) { + foundSelfAsParent = true; + currentParent = null; // break } else { - // Handle hierarchical reference - var containerInstance = getChildReactorInstance(reference.getContainer()); - if (containerInstance == null) return null; - return containerInstance.lookupPortInstance((Port) reference.getVariable()); + currentParent = currentParent.parent; } - } + } + } while (currentParent != null); - /** - * Return the reaction instance within this reactor - * instance corresponding to the specified reaction. - * @param reaction The reaction as an AST node. - * @return The corresponding reaction instance or null if the - * reaction does not belong to this reactor. - */ - public ReactionInstance lookupReactionInstance(Reaction reaction) { - for (ReactionInstance reactionInstance : reactions) { - if (reactionInstance.definition == reaction) { - return reactionInstance; - } - } - return null; + this.recursive = foundSelfAsParent; + if (recursive) { + reporter.reportError(definition, "Recursive reactor instantiation."); } - /** - * Return the reactor instance within this reactor - * that has the specified instantiation. Note that this - * may be a bank of reactors. Return null if there - * is no such reactor instance. - */ - public ReactorInstance lookupReactorInstance(Instantiation instantiation) { - for (ReactorInstance reactorInstance : children) { - if (reactorInstance.definition == instantiation) { - return reactorInstance; - } - } - return null; - } - - /** - * Return the timer instance within this reactor - * instance corresponding to the specified timer reference. - * @param timer The timer as an AST node. - * @return The corresponding timer instance or null if the - * timer does not belong to this reactor. - */ - public TimerInstance lookupTimerInstance(Timer timer) { - for (TimerInstance timerInstance : timers) { - if (timerInstance.definition == timer) { - return timerInstance; - } - } - return null; + // If the reactor definition is null, give up here. Otherwise, diagram generation + // will fail an NPE. + if (reactorDefinition == null) { + reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); + return; } - /** Returns the mode instance within this reactor - * instance corresponding to the specified mode reference. - * @param mode The mode as an AST node. - * @return The corresponding mode instance or null if the - * mode does not belong to this reactor. - */ - public ModeInstance lookupModeInstance(Mode mode) { - for (ModeInstance modeInstance : modes) { - if (modeInstance.definition == mode) { - return modeInstance; - } - } - return null; - } + setInitialWidth(); - /** - * Return a descriptive string. - */ - @Override - public String toString() { - return "ReactorInstance " + getFullName(); + // Apply overrides and instantiate parameters for this reactor instance. + for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { + this.parameters.add(new ParameterInstance(parameter, this)); } - /** - * Assuming that the given expression denotes a valid time, return a time value. - * - * If the value is given as a parameter reference, this will look up the - * precise time value assigned to this reactor instance. - */ - public TimeValue getTimeValue(Expression expr) { - Expression resolved = resolveParameters(expr); - return getLiteralTimeValue(resolved); + // Instantiate inputs for this reactor instance + for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { + this.inputs.add(new PortInstance(inputDecl, this, reporter)); } - ////////////////////////////////////////////////////// - //// Protected fields. - - /** The generator that created this reactor instance. */ - protected ErrorReporter reporter; // FIXME: This accumulates a lot of redundant references - - /** The map of used built-in triggers. */ - protected Map> builtinTriggers = new HashMap<>(); - - /** - * The LF syntax does not currently support declaring reactions unordered, - * but unordered reactions are created in the AST transformations handling - * federated communication and after delays. Unordered reactions can execute - * in any order and concurrently even though they are in the same reactor. - * FIXME: Remove this when the language provides syntax. - */ - protected Set unorderedReactions = new LinkedHashSet<>(); - - /** The nested list of instantiations that created this reactor instance. */ - protected List _instantiations; - - ////////////////////////////////////////////////////// - //// Protected methods. - - /** - * Create all the reaction instances of this reactor instance - * and record the dependencies and antidependencies - * between ports, actions, and timers and reactions. - * This also records the dependencies between reactions - * that follows from the order in which they are defined. - */ - protected void createReactionInstances() { - List reactions = ASTUtils.allReactions(reactorDefinition); - if (reactions != null) { - int count = 0; - - // Check for startup and shutdown triggers. - for (Reaction reaction : reactions) { - if (AttributeUtils.isUnordered(reaction)) { - unorderedReactions.add(reaction); - } - // Create the reaction instance. - var reactionInstance = new ReactionInstance(reaction, this, - unorderedReactions.contains(reaction), count++); - - // Add the reaction instance to the map of reactions for this - // reactor. - this.reactions.add(reactionInstance); - } - } + // Instantiate outputs for this reactor instance + for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { + this.outputs.add(new PortInstance(outputDecl, this, reporter)); } - /** - * Returns the built-in trigger or create a new one if none exists. - */ - protected TriggerInstance getOrCreateBuiltinTrigger(BuiltinTriggerRef trigger) { - return builtinTriggers.computeIfAbsent(trigger.getType(), ref -> TriggerInstance.builtinTrigger(trigger, this)); + // Do not process content (except interface above) if recursive + if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { + // Instantiate children for this reactor instance. + // While doing this, assign an index offset to each. + for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { + var childInstance = new ReactorInstance(child, this, reporter, desiredDepth); + this.children.add(childInstance); + } + + // Instantiate timers for this reactor instance + for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { + this.timers.add(new TimerInstance(timerDecl, this)); + } + + // Instantiate actions for this reactor instance + for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { + this.actions.add(new ActionInstance(actionDecl, this)); + } + + establishPortConnections(); + + // Create the reaction instances in this reactor instance. + // This also establishes all the implied dependencies. + // Note that this can only happen _after_ the children, + // port, action, and timer instances have been created. + createReactionInstances(); + + // Instantiate modes for this reactor instance + // This must come after the child elements (reactions, etc) of this reactor + // are created in order to allow their association with modes + for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { + this.modes.add(new ModeInstance(modeDecl, this)); + } + for (ModeInstance mode : this.modes) { + mode.setupTranstions(); + } } - - /** Create all the watchdog instances of this reactor instance. */ - protected void createWatchdogInstances() { - List watchdogs = ASTUtils.allWatchdogs(reactorDefinition); - if (watchdogs != null) { - for (Watchdog watchdog : watchdogs) { - // Create the watchdog instance. - var watchdogInstance = new WatchdogInstance(watchdog, this); - - // Add the watchdog instance to the list of watchdogs for this - // reactor. - this.watchdogs.add(watchdogInstance); - } + } + + public TypeParameterizedReactor getTypeParameterizedReactor() { + return this.tpr; + } + + ////////////////////////////////////////////////////// + //// Private methods. + + /** + * Connect the given left port range to the given right port range. + * + *

    NOTE: This method is public to enable its use in unit tests. Otherwise, it should be + * private. This is why it is defined here, in the section labeled "Private methods." + * + * @param src The source range. + * @param dst The destination range. + * @param connection The connection establishing this relationship. + */ + public static void connectPortInstances( + RuntimeRange src, RuntimeRange dst, Connection connection) { + SendRange range = new SendRange(src, dst, src._interleaved, connection); + src.instance.dependentPorts.add(range); + dst.instance.dependsOnPorts.add(src); + } + + /** + * Populate connectivity information in the port instances. Note that this can only happen _after_ + * the children and port instances have been created. Unfortunately, we have to do some + * complicated things here to support multiport-to-multiport, multiport-to-bank, and + * bank-to-multiport communication. The principle being followed is: in each connection statement, + * for each port instance on the left, connect to the next available port on the right. + */ + private void establishPortConnections() { + for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { + List> leftPorts = + listPortInstances(connection.getLeftPorts(), connection); + Iterator> srcRanges = leftPorts.iterator(); + List> rightPorts = + listPortInstances(connection.getRightPorts(), connection); + Iterator> dstRanges = rightPorts.iterator(); + + // Check for empty lists. + if (!srcRanges.hasNext()) { + if (dstRanges.hasNext()) { + reporter.reportWarning(connection, "No sources to provide inputs."); } - } - - //////////////////////////////////////// - //// Private constructors - - /** - * Create a runtime instance from the specified definition - * and with the specified parent that instantiated it. - * @param definition The instantiation statement in the AST. - * @param parent The parent, or null for the main rector. - * @param reporter An error reporter. - * @param desiredDepth The depth to which to expand the hierarchy. - */ - public ReactorInstance( - Instantiation definition, - ReactorInstance parent, - ErrorReporter reporter, - int desiredDepth) { - super(definition, parent); - this.reporter = reporter; - this.reactorDeclaration = definition.getReactorClass(); - this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); - this.tpr = new TypeParameterizedReactor(definition); - - // check for recursive instantiation - var currentParent = parent; - var foundSelfAsParent = false; - do { - if (currentParent != null) { - if (currentParent.reactorDefinition == this.reactorDefinition) { - foundSelfAsParent = true; - currentParent = null; // break - } else { - currentParent = currentParent.parent; - } + return; + } else if (!dstRanges.hasNext()) { + reporter.reportWarning(connection, "No destination. Outputs will be lost."); + return; + } + + RuntimeRange src = srcRanges.next(); + RuntimeRange dst = dstRanges.next(); + + while (true) { + if (dst.width == src.width) { + connectPortInstances(src, dst, connection); + if (!dstRanges.hasNext()) { + if (srcRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Source is wider than the destination. Outputs will be lost."); } - } while(currentParent != null); - - this.recursive = foundSelfAsParent; - if (recursive) { - reporter.reportError(definition, "Recursive reactor instantiation."); - } - - // If the reactor definition is null, give up here. Otherwise, diagram generation - // will fail an NPE. - if (reactorDefinition == null) { - reporter.reportError(definition, "Reactor instantiation has no matching reactor definition."); - return; - } - - setInitialWidth(); - - // Apply overrides and instantiate parameters for this reactor instance. - for (Parameter parameter : ASTUtils.allParameters(reactorDefinition)) { - this.parameters.add(new ParameterInstance(parameter, this)); - } - - // Instantiate inputs for this reactor instance - for (Input inputDecl : ASTUtils.allInputs(reactorDefinition)) { - this.inputs.add(new PortInstance(inputDecl, this, reporter)); - } - - // Instantiate outputs for this reactor instance - for (Output outputDecl : ASTUtils.allOutputs(reactorDefinition)) { - this.outputs.add(new PortInstance(outputDecl, this, reporter)); - } - - // Do not process content (except interface above) if recursive - if (!recursive && (desiredDepth < 0 || this.depth < desiredDepth)) { - // Instantiate children for this reactor instance. - // While doing this, assign an index offset to each. - for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { - var childInstance = new ReactorInstance( - child, - this, - reporter, - desiredDepth - ); - this.children.add(childInstance); - } - - // Instantiate timers for this reactor instance - for (Timer timerDecl : ASTUtils.allTimers(reactorDefinition)) { - this.timers.add(new TimerInstance(timerDecl, this)); - } - - // Instantiate actions for this reactor instance - for (Action actionDecl : ASTUtils.allActions(reactorDefinition)) { - this.actions.add(new ActionInstance(actionDecl, this)); - } - - establishPortConnections(); - - // Create the reaction instances in this reactor instance. - // This also establishes all the implied dependencies. - // Note that this can only happen _after_ the children, - // port, action, and timer instances have been created. - createReactionInstances(); - - // Instantiate modes for this reactor instance - // This must come after the child elements (reactions, etc) of this reactor - // are created in order to allow their association with modes - for (Mode modeDecl : ASTUtils.allModes(reactorDefinition)) { - this.modes.add(new ModeInstance(modeDecl, this)); + break; + } + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + if (dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Destination is wider than the source. Inputs will be missing."); + } + break; } - for (ModeInstance mode : this.modes) { - mode.setupTranstions(); + } + dst = dstRanges.next(); + src = srcRanges.next(); + } else if (dst.width < src.width) { + // Split the left (src) range in two. + connectPortInstances(src.head(dst.width), dst, connection); + src = src.tail(dst.width); + if (!dstRanges.hasNext()) { + // Should not happen (checked by the validator). + reporter.reportWarning( + connection, "Source is wider than the destination. Outputs will be lost."); + break; + } + dst = dstRanges.next(); + } else if (src.width < dst.width) { + // Split the right (dst) range in two. + connectPortInstances(src, dst.head(src.width), connection); + dst = dst.tail(src.width); + if (!srcRanges.hasNext()) { + if (connection.isIterated()) { + srcRanges = leftPorts.iterator(); + } else { + reporter.reportWarning( + connection, "Destination is wider than the source. Inputs will be missing."); + break; } + } + src = srcRanges.next(); } + } } - - public TypeParameterizedReactor getTypeParameterizedReactor() { - return this.tpr; - } - - ////////////////////////////////////////////////////// - //// Private methods. - - /** - * Connect the given left port range to the given right port range. - * - * NOTE: This method is public to enable its use in unit tests. - * Otherwise, it should be private. This is why it is defined here, - * in the section labeled "Private methods." - * - * @param src The source range. - * @param dst The destination range. - * @param connection The connection establishing this relationship. - */ - public static void connectPortInstances( - RuntimeRange src, - RuntimeRange dst, - Connection connection - ) { - SendRange range = new SendRange(src, dst, src._interleaved, connection); - src.instance.dependentPorts.add(range); - dst.instance.dependsOnPorts.add(src); + } + + /** + * If path exists from the specified port to any reaction in the specified set of reactions, then + * add the specified port and all ports along the path to the specified set of ports. + * + * @return True if the specified port was added. + */ + private boolean findPaths( + PortInstance port, Set reactions, Set ports) { + if (ports.contains(port)) return false; + boolean result = false; + for (ReactionInstance d : port.getDependentReactions()) { + if (reactions.contains(d)) ports.add(port); + result = true; } - - /** - * Populate connectivity information in the port instances. - * Note that this can only happen _after_ the children and port instances have been created. - * Unfortunately, we have to do some complicated things here - * to support multiport-to-multiport, multiport-to-bank, - * and bank-to-multiport communication. The principle being followed is: - * in each connection statement, for each port instance on the left, - * connect to the next available port on the right. - */ - private void establishPortConnections() { - for (Connection connection : ASTUtils.allConnections(reactorDefinition)) { - List> leftPorts = listPortInstances(connection.getLeftPorts(), connection); - Iterator> srcRanges = leftPorts.iterator(); - List> rightPorts = listPortInstances(connection.getRightPorts(), connection); - Iterator> dstRanges = rightPorts.iterator(); - - // Check for empty lists. - if (!srcRanges.hasNext()) { - if (dstRanges.hasNext()) { - reporter.reportWarning(connection, "No sources to provide inputs."); - } - return; - } else if (!dstRanges.hasNext()) { - reporter.reportWarning(connection, "No destination. Outputs will be lost."); - return; - } - - RuntimeRange src = srcRanges.next(); - RuntimeRange dst = dstRanges.next(); - - while(true) { - if (dst.width == src.width) { - connectPortInstances(src, dst, connection); - if (!dstRanges.hasNext()) { - if (srcRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Source is wider than the destination. Outputs will be lost."); - } - break; - } - if (!srcRanges.hasNext()) { - if (connection.isIterated()) { - srcRanges = leftPorts.iterator(); - } else { - if (dstRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Destination is wider than the source. Inputs will be missing."); - } - break; - } - } - dst = dstRanges.next(); - src = srcRanges.next(); - } else if (dst.width < src.width) { - // Split the left (src) range in two. - connectPortInstances(src.head(dst.width), dst, connection); - src = src.tail(dst.width); - if (!dstRanges.hasNext()) { - // Should not happen (checked by the validator). - reporter.reportWarning(connection, - "Source is wider than the destination. Outputs will be lost."); - break; - } - dst = dstRanges.next(); - } else if (src.width < dst.width) { - // Split the right (dst) range in two. - connectPortInstances(src, dst.head(src.width), connection); - dst = dst.tail(src.width); - if (!srcRanges.hasNext()) { - if (connection.isIterated()) { - srcRanges = leftPorts.iterator(); - } else { - reporter.reportWarning(connection, - "Destination is wider than the source. Inputs will be missing."); - break; - } - } - src = srcRanges.next(); - } - } + // Perform a depth-first search. + for (SendRange r : port.dependentPorts) { + for (RuntimeRange p : r.destinations) { + boolean added = findPaths(p.instance, reactions, ports); + if (added) { + result = true; + ports.add(port); } + } } - - /** - * If path exists from the specified port to any reaction in the specified - * set of reactions, then add the specified port and all ports along the path - * to the specified set of ports. - * @return True if the specified port was added. - */ - private boolean findPaths( - PortInstance port, - Set reactions, - Set ports - ) { - if (ports.contains(port)) return false; - boolean result = false; - for (ReactionInstance d : port.getDependentReactions()) { - if (reactions.contains(d)) ports.add(port); - result = true; - } - // Perform a depth-first search. - for (SendRange r : port.dependentPorts) { - for (RuntimeRange p : r.destinations) { - boolean added = findPaths(p.instance, reactions, ports); - if (added) { - result = true; - ports.add(port); - } - } - } + return result; + } + + /** + * Given a list of port references, as found on either side of a connection, return a list of the + * port instance ranges referenced. These may be multiports, and may be ports of a contained bank + * (a port representing ports of the bank members) so the returned list includes ranges of banks + * and channels. + * + *

    If a given port reference has the form {@code interleaved(b.m)}, where {@code b} is a bank + * and {@code m} is a multiport, then the corresponding range in the returned list is marked + * interleaved. + * + *

    For example, if {@code b} and {@code m} have width 2, without the interleaved keyword, the + * returned range represents the sequence {@code [b0.m0, b0.m1, b1.m0, b1.m1]}. With the + * interleaved marking, the returned range represents the sequence {@code [b0.m0, b1.m0, b0.m1, + * b1.m1]}. Both ranges will have width 4. + * + * @param references The variable references on one side of the connection. + * @param connection The connection. + */ + private List> listPortInstances( + List references, Connection connection) { + List> result = new ArrayList<>(); + List> tails = new LinkedList<>(); + int count = 0; + for (VarRef portRef : references) { + // Simple error checking first. + if (!(portRef.getVariable() instanceof Port)) { + reporter.reportError(portRef, "Not a port."); return result; - } - - /** - * Given a list of port references, as found on either side of a connection, - * return a list of the port instance ranges referenced. These may be multiports, - * and may be ports of a contained bank (a port representing ports of the bank - * members) so the returned list includes ranges of banks and channels. - * - * If a given port reference has the form {@code interleaved(b.m)}, where {@code b} is - * a bank and {@code m} is a multiport, then the corresponding range in the returned - * list is marked interleaved. - * - * For example, if {@code b} and {@code m} have width 2, without the interleaved keyword, - * the returned range represents the sequence {@code [b0.m0, b0.m1, b1.m0, b1.m1]}. - * With the interleaved marking, the returned range represents the sequence - * {@code [b0.m0, b1.m0, b0.m1, b1.m1]}. Both ranges will have width 4. - * - * @param references The variable references on one side of the connection. - * @param connection The connection. - */ - private List> listPortInstances( - List references, Connection connection - ) { - List> result = new ArrayList<>(); - List> tails = new LinkedList<>(); - int count = 0; - for (VarRef portRef : references) { - // Simple error checking first. - if (!(portRef.getVariable() instanceof Port)) { - reporter.reportError(portRef, "Not a port."); - return result; - } - // First, figure out which reactor we are dealing with. - // The reactor we want is the container of the port. - // If the port reference has no container, then the reactor is this one. - var reactor = this; - if (portRef.getContainer() != null) { - reactor = getChildReactorInstance(portRef.getContainer()); - } - // The reactor can be null only if there is an error in the code. - // Skip this portRef so that diagram synthesis can complete. - if (reactor != null) { - PortInstance portInstance = reactor.lookupPortInstance( - (Port) portRef.getVariable()); - - Set interleaved = new LinkedHashSet<>(); - if (portRef.isInterleaved()) { - // NOTE: Here, we are assuming that the interleaved() - // keyword is only allowed on the multiports contained by - // contained reactors. - interleaved.add(portInstance.parent); - } - RuntimeRange range = new RuntimeRange.Port( - portInstance, interleaved); - // If this portRef is not the last one in the references list - // then we have to check whether the range can be incremented at - // the lowest two levels (port and container). If not, - // split the range and add the tail to list to iterate over again. - // The reason for this is that the connection has only local visibility, - // but the range width may be reflective of bank structure higher - // in the hierarchy. - if (count < references.size() - 1) { - int portWidth = portInstance.width; - int portParentWidth = portInstance.parent.width; - // If the port is being connected on the inside and there is - // more than one port in the list, then we can only connect one - // bank member at a time. - if (reactor == this && references.size() > 1) { - portParentWidth = 1; - } - int widthBound = portWidth * portParentWidth; - - // If either of these widths cannot be determined, assume infinite. - if (portWidth < 0) widthBound = Integer.MAX_VALUE; - if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; - - if (widthBound < range.width) { - // Need to split the range. - tails.add(range.tail(widthBound)); - range = range.head(widthBound); - } - } - result.add(range); - } + } + // First, figure out which reactor we are dealing with. + // The reactor we want is the container of the port. + // If the port reference has no container, then the reactor is this one. + var reactor = this; + if (portRef.getContainer() != null) { + reactor = getChildReactorInstance(portRef.getContainer()); + } + // The reactor can be null only if there is an error in the code. + // Skip this portRef so that diagram synthesis can complete. + if (reactor != null) { + PortInstance portInstance = reactor.lookupPortInstance((Port) portRef.getVariable()); + + Set interleaved = new LinkedHashSet<>(); + if (portRef.isInterleaved()) { + // NOTE: Here, we are assuming that the interleaved() + // keyword is only allowed on the multiports contained by + // contained reactors. + interleaved.add(portInstance.parent); } - // Iterate over the tails. - while(tails.size() > 0) { - List> moreTails = new LinkedList<>(); - count = 0; - for (RuntimeRange tail : tails) { - if (count < tails.size() - 1) { - int widthBound = tail.instance.width; - if (tail._interleaved.contains(tail.instance.parent)) { - widthBound = tail.instance.parent.width; - } - // If the width cannot be determined, assume infinite. - if (widthBound < 0) widthBound = Integer.MAX_VALUE; - - if (widthBound < tail.width) { - // Need to split the range again - moreTails.add(tail.tail(widthBound)); - tail = tail.head(widthBound); - } - } - result.add(tail); - } - tails = moreTails; + RuntimeRange range = new RuntimeRange.Port(portInstance, interleaved); + // If this portRef is not the last one in the references list + // then we have to check whether the range can be incremented at + // the lowest two levels (port and container). If not, + // split the range and add the tail to list to iterate over again. + // The reason for this is that the connection has only local visibility, + // but the range width may be reflective of bank structure higher + // in the hierarchy. + if (count < references.size() - 1) { + int portWidth = portInstance.width; + int portParentWidth = portInstance.parent.width; + // If the port is being connected on the inside and there is + // more than one port in the list, then we can only connect one + // bank member at a time. + if (reactor == this && references.size() > 1) { + portParentWidth = 1; + } + int widthBound = portWidth * portParentWidth; + + // If either of these widths cannot be determined, assume infinite. + if (portWidth < 0) widthBound = Integer.MAX_VALUE; + if (portParentWidth < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < range.width) { + // Need to split the range. + tails.add(range.tail(widthBound)); + range = range.head(widthBound); + } } - return result; + result.add(range); + } } - - /** - * If this is a bank of reactors, set the width. - * It will be set to -1 if it cannot be determined. - */ - private void setInitialWidth() { - WidthSpec widthSpec = definition.getWidthSpec(); - if (widthSpec != null) { - // We need the instantiations list of the containing reactor, - // not this one. - width = ASTUtils.width(widthSpec, parent.instantiations()); + // Iterate over the tails. + while (tails.size() > 0) { + List> moreTails = new LinkedList<>(); + count = 0; + for (RuntimeRange tail : tails) { + if (count < tails.size() - 1) { + int widthBound = tail.instance.width; + if (tail._interleaved.contains(tail.instance.parent)) { + widthBound = tail.instance.parent.width; + } + // If the width cannot be determined, assume infinite. + if (widthBound < 0) widthBound = Integer.MAX_VALUE; + + if (widthBound < tail.width) { + // Need to split the range again + moreTails.add(tail.tail(widthBound)); + tail = tail.head(widthBound); + } } + result.add(tail); + } + tails = moreTails; } - - ////////////////////////////////////////////////////// - //// Private fields. - - /** - * Cached set of reactions and ports that form a causality loop. - */ - private Set> cachedCycles; - - /** - * Cached reaction graph containing reactions that form a causality loop. - */ - private ReactionInstanceGraph cachedReactionLoopGraph = null; - - /** - * Return true if this is a generated delay reactor that originates from - * an "after" delay on a connection. - * - * @return True if this is a generated delay, false otherwise. - */ - public boolean isGeneratedDelay() { - // FIXME: hacky string matching again... - return this.definition.getReactorClass().getName().contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME); + return result; + } + + /** + * If this is a bank of reactors, set the width. It will be set to -1 if it cannot be determined. + */ + private void setInitialWidth() { + WidthSpec widthSpec = definition.getWidthSpec(); + if (widthSpec != null) { + // We need the instantiations list of the containing reactor, + // not this one. + width = ASTUtils.width(widthSpec, parent.instantiations()); } + } + + ////////////////////////////////////////////////////// + //// Private fields. + + /** Cached set of reactions and ports that form a causality loop. */ + private Set> cachedCycles; + + /** Cached reaction graph containing reactions that form a causality loop. */ + private ReactionInstanceGraph cachedReactionLoopGraph = null; + + /** + * Return true if this is a generated delay reactor that originates from an "after" delay on a + * connection. + * + * @return True if this is a generated delay, false otherwise. + */ + public boolean isGeneratedDelay() { + // FIXME: hacky string matching again... + return this.definition + .getReactorClass() + .getName() + .contains(DelayBodyGenerator.GEN_DELAY_CLASS_NAME); + } } diff --git a/org.lflang/src/org/lflang/generator/RuntimeRange.java b/org.lflang/src/org/lflang/generator/RuntimeRange.java index 36f132b27e..d684a41bd9 100644 --- a/org.lflang/src/org/lflang/generator/RuntimeRange.java +++ b/org.lflang/src/org/lflang/generator/RuntimeRange.java @@ -32,478 +32,419 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.Set; /** - * Class representing a range of runtime instance objects - * (port channels, reactors, reactions, etc.). This class and its derived classes - * have the most detailed information about the structure of a Lingua Franca - * program. There are three levels of detail: + * Class representing a range of runtime instance objects (port channels, reactors, reactions, + * etc.). This class and its derived classes have the most detailed information about the structure + * of a Lingua Franca program. There are three levels of detail: + * *

      - *
    • The abstract syntax tree (AST).
      • - *
    • The compile-time instance graph (CIG).
      • - *
    • The runtime instance graph (RIG).
      • + *
    • The abstract syntax tree (AST). + *
    • The compile-time instance graph (CIG). + *
    • The runtime instance graph (RIG). *
    - * - * In the AST, each reactor class is represented once. - * In the CIG, each reactor class is represented as many times as it is - * instantiated, except that a bank has only one representation (as - * in the graphical rendition). Equivalently, each CIG node has a unique - * full name, even though it may represent many runtime instances. - * The CIG is represented by - * {@link NamedInstance} and its derived classes. - * In the RIG, each bank is expanded so each bank member and - * each port channel is represented. - * - * In general, determining dependencies between reactions requires analysis - * at the level of the RIG. But a brute-force representation of the RIG - * can get very large, and for most programs it has a great deal of - * redundancy. In a fully detailed representation of the RIG, for example, - * a bank of width N that contains a bank of width M within which there - * is a reactor R with port P will have N*M runtime instances of the port. - * If the port is a multiport with width L, then there are N*M*L - * edges connected to instances of that port, each of which may go - * to a distinct set of other remote runtime port instances. - * - * This class and its subclasses give a more compact representation of the - * RIG in most common cases where collections of runtime instances all have - * the same dependencies or dependencies form a range that can be represented - * compactly. - * - * A RuntimeRange represents an adjacent set of RIG objects (port channels, reactions - * reactors). For example, it can represent port channels 2 through 5 in a multiport - * of width 10. The width in this case is 4. If such a port is - * contained by one or more banks of reactors, then channels 2 through 5 - * of one bank member form a contiguous range. If you want channels 2 through 5 - * of all bank members, then this needs to be represented with multiple ranges. - * - * The maxWidth is the width of the instance multiplied by the widths of - * each of its containers. For example, if a port of width 4 is contained by - * a bank of width 2 that is then contained by a bank of width 3, then - * the maxWidth will be 2*3*4 = 24. - * - * The function iterationOrder returns a list that includes the instance - * of this range and all its containers, except the top-level reactor (main - * or federated). The order of this list is the order in which an - * iteration over the RIG objects represented by this range should be - * iterated. If the instance is a PortInstance, then this order will - * depend on whether connections at any level of the hierarchy are - * interleaved. - * - * The simplest Ranges are those where the corresponding CIG node represents - * only one runtime instance (its instance is not (deeply) within a bank - * and is not a multiport). In this case, the RuntimeRange and all the objects - * returned by iterationOrder will have width 1. - * - * In a more complex instance, consider a bank A of width 2 that contains a - * bank B of width 2 that contains a port instance P with width 2. . - * There are a total of 8 instances of P, which we can name: - * - * A0.B0.P0 - * A0.B0.P1 - * A0.B1.P0 - * A0.B1.P1 - * A1.B0.P0 - * A1.B0.P1 - * A1.B1.P0 - * A1.B1.P1 - * - * If there is no interleaving, iterationOrder() returns [P, B, A], - * indicating that they should be iterated by incrementing the index of P - * first, then the index of B, then the index of A, as done above. - * - * If the connection within B to port P is interleaved, then the order - * of iteration order will be [B, P, A], resulting in the list: - * - * A0.B0.P0 - * A0.B1.P0 - * A0.B0.P1 - * A0.B1.P1 - * A1.B0.P0 - * A1.B1.P0 - * A1.B0.P1 - * A1.B1.P1 - * - * If the connection within A to B is also interleaved, then the order - * will be [A, B, P], resulting in the list: - * - * A0.B0.P0 - * A1.B0.P0 - * A0.B1.P0 - * A1.B1.P0 - * A0.B0.P1 - * A1.B0.P1 - * A0.B1.P1 - * A1.B1.P1 - * - * Finally, if the connection within A to B is interleaved, but not the - * connection within B to P, then the order will be [A, P, B], resulting in - * the list: - * - * A0.B0.P0 - * A1.B0.P0 - * A0.B0.P1 - * A1.B0.P1 - * A0.B1.P0 - * A1.B1.P0 - * A0.B1.P1 - * A1.B1.P1 - * - * A RuntimeRange is a contiguous subset of one of the above lists, given by - * a start offset and a width that is less than or equal to maxWidth. - * - * Each element of the above lists can be represented as a permuted mixed-radix (PMR) number, - * where the low-order digit has radix equal to the width of P, the second digit - * has radix equal to the width of B, and the final digit has radix equal to the - * width of A. Each PMR has a permutation vector that defines how to increment - * PMR number. This permutation vector is derived from the iteration order as - * follows. When there is no interleaving, the iteration order is [P, B, A], - * and the permutation vector is [0, 1, 2]. When there is interleaving, the permutation - * vector simply specifies the iteration order. For example, if the iteration order - * is [A, P, B], then the permutation vector is [2, 0, 1], indicating that digit 2 - * of the PMR (corresponding to A) should be incremented first, then digit 0 (for P), - * then digit 1 (for B). - * - * For a RuntimeRange with width greater than 1, - * the head() and tail() functions split the range. - * - * This class and subclasses are designed to be immutable. - * Modifications always return a new RuntimeRange. + * + * In the AST, each reactor class is represented once. In the CIG, each reactor class is represented + * as many times as it is instantiated, except that a bank has only one representation (as in the + * graphical rendition). Equivalently, each CIG node has a unique full name, even though it may + * represent many runtime instances. The CIG is represented by {@link NamedInstance} and its derived + * classes. In the RIG, each bank is expanded so each bank member and each port channel is + * represented. + * + *

    In general, determining dependencies between reactions requires analysis at the level of the + * RIG. But a brute-force representation of the RIG can get very large, and for most programs it has + * a great deal of redundancy. In a fully detailed representation of the RIG, for example, a bank of + * width N that contains a bank of width M within which there is a reactor R with port P will have + * N*M runtime instances of the port. If the port is a multiport with width L, then there are N*M*L + * edges connected to instances of that port, each of which may go to a distinct set of other remote + * runtime port instances. + * + *

    This class and its subclasses give a more compact representation of the RIG in most common + * cases where collections of runtime instances all have the same dependencies or dependencies form + * a range that can be represented compactly. + * + *

    A RuntimeRange represents an adjacent set of RIG objects (port channels, reactions reactors). + * For example, it can represent port channels 2 through 5 in a multiport of width 10. The width in + * this case is 4. If such a port is contained by one or more banks of reactors, then channels 2 + * through 5 of one bank member form a contiguous range. If you want channels 2 through 5 of all + * bank members, then this needs to be represented with multiple ranges. + * + *

    The maxWidth is the width of the instance multiplied by the widths of each of its containers. + * For example, if a port of width 4 is contained by a bank of width 2 that is then contained by a + * bank of width 3, then the maxWidth will be 2*3*4 = 24. + * + *

    The function iterationOrder returns a list that includes the instance of this range and all + * its containers, except the top-level reactor (main or federated). The order of this list is the + * order in which an iteration over the RIG objects represented by this range should be iterated. If + * the instance is a PortInstance, then this order will depend on whether connections at any level + * of the hierarchy are interleaved. + * + *

    The simplest Ranges are those where the corresponding CIG node represents only one runtime + * instance (its instance is not (deeply) within a bank and is not a multiport). In this case, the + * RuntimeRange and all the objects returned by iterationOrder will have width 1. + * + *

    In a more complex instance, consider a bank A of width 2 that contains a bank B of width 2 + * that contains a port instance P with width 2. . There are a total of 8 instances of P, which we + * can name: + * + *

    A0.B0.P0 A0.B0.P1 A0.B1.P0 A0.B1.P1 A1.B0.P0 A1.B0.P1 A1.B1.P0 A1.B1.P1 + * + *

    If there is no interleaving, iterationOrder() returns [P, B, A], indicating that they should + * be iterated by incrementing the index of P first, then the index of B, then the index of A, as + * done above. + * + *

    If the connection within B to port P is interleaved, then the order of iteration order will be + * [B, P, A], resulting in the list: + * + *

    A0.B0.P0 A0.B1.P0 A0.B0.P1 A0.B1.P1 A1.B0.P0 A1.B1.P0 A1.B0.P1 A1.B1.P1 + * + *

    If the connection within A to B is also interleaved, then the order will be [A, B, P], + * resulting in the list: + * + *

    A0.B0.P0 A1.B0.P0 A0.B1.P0 A1.B1.P0 A0.B0.P1 A1.B0.P1 A0.B1.P1 A1.B1.P1 + * + *

    Finally, if the connection within A to B is interleaved, but not the connection within B to P, + * then the order will be [A, P, B], resulting in the list: + * + *

    A0.B0.P0 A1.B0.P0 A0.B0.P1 A1.B0.P1 A0.B1.P0 A1.B1.P0 A0.B1.P1 A1.B1.P1 + * + *

    A RuntimeRange is a contiguous subset of one of the above lists, given by a start offset and a + * width that is less than or equal to maxWidth. + * + *

    Each element of the above lists can be represented as a permuted mixed-radix (PMR) number, + * where the low-order digit has radix equal to the width of P, the second digit has radix equal to + * the width of B, and the final digit has radix equal to the width of A. Each PMR has a permutation + * vector that defines how to increment PMR number. This permutation vector is derived from the + * iteration order as follows. When there is no interleaving, the iteration order is [P, B, A], and + * the permutation vector is [0, 1, 2]. When there is interleaving, the permutation vector simply + * specifies the iteration order. For example, if the iteration order is [A, P, B], then the + * permutation vector is [2, 0, 1], indicating that digit 2 of the PMR (corresponding to A) should + * be incremented first, then digit 0 (for P), then digit 1 (for B). + * + *

    For a RuntimeRange with width greater than 1, the head() and tail() functions split the range. + * + *

    This class and subclasses are designed to be immutable. Modifications always return a new + * RuntimeRange. * * @author Edward A. Lee */ public class RuntimeRange> implements Comparable> { - - /** - * Create a new range representing the full width of the specified instance - * with no interleaving. The instances will be a list with the specified instance - * first, its parent next, and on up the hierarchy until the depth 1 parent (the - * top-level reactor is not included because it can never be a bank). - * @param instance The instance. - * @param interleaved A list of parents that are interleaved or null if none. - */ - public RuntimeRange( - T instance, - Set interleaved - ) { - this(instance, 0, 0, interleaved); - } - /** - * Create a new range representing a range of the specified instance - * with no interleaving. The instances will be a list with the specified instance - * first, its parent next, and on up the hierarchy until the depth 1 parent (the - * top-level reactor is not included because it can never be a bank). - * @param instance The instance over which this is a range (port, reaction, etc.) - * @param start The starting index for the range. - * @param width The width of the range or 0 to specify the maximum possible width. - * @param interleaved A list of parents that are interleaved or null if none. - */ - public RuntimeRange( - T instance, - int start, - int width, - Set interleaved - ) { - this.instance = instance; - this.start = start; - if (interleaved != null) { - this._interleaved.addAll(interleaved); - } - - int maxWidth = instance.width; // Initial value. - NamedInstance parent = instance.parent; - while (parent.depth > 0) { - maxWidth *= parent.width; - parent = parent.parent; - } - this.maxWidth = maxWidth; - - if (width > 0 && width + start < maxWidth) { - this.width = width; - } else { - this.width = maxWidth - start; - } - } - - ////////////////////////////////////////////////////////// - //// Public variables - - /** The instance that this is a range of. */ - public final T instance; - - /** The start offset of this range. */ - public final int start; - - /** The maximum width of any range with this instance. */ - public final int maxWidth; - - /** The width of this range. */ - public final int width; - - ////////////////////////////////////////////////////////// - //// Public methods - - /** - * Compare ranges by first comparing their start offset, and then, - * if these are equal, comparing their widths. This comparison is - * meaningful only for ranges that have the same instances. - * Note that this can return 0 even if equals() does not return true. - */ - @Override - public int compareTo(RuntimeRange o) { - if (start < o.start) { - return -1; - } else if (start == o.start) { - return Integer.compare(width, o.width); - } else { - return 1; - } + /** + * Create a new range representing the full width of the specified instance with no interleaving. + * The instances will be a list with the specified instance first, its parent next, and on up the + * hierarchy until the depth 1 parent (the top-level reactor is not included because it can never + * be a bank). + * + * @param instance The instance. + * @param interleaved A list of parents that are interleaved or null if none. + */ + public RuntimeRange(T instance, Set interleaved) { + this(instance, 0, 0, interleaved); + } + + /** + * Create a new range representing a range of the specified instance with no interleaving. The + * instances will be a list with the specified instance first, its parent next, and on up the + * hierarchy until the depth 1 parent (the top-level reactor is not included because it can never + * be a bank). + * + * @param instance The instance over which this is a range (port, reaction, etc.) + * @param start The starting index for the range. + * @param width The width of the range or 0 to specify the maximum possible width. + * @param interleaved A list of parents that are interleaved or null if none. + */ + public RuntimeRange(T instance, int start, int width, Set interleaved) { + this.instance = instance; + this.start = start; + if (interleaved != null) { + this._interleaved.addAll(interleaved); } - - /** - * Return a new RuntimeRange that is identical to this range but - * with width reduced to the specified width. - * If the new width is greater than or equal to the width - * of this range, then return this range. - * If the newWidth is 0 or negative, return null. - * @param newWidth The new width. - */ - public RuntimeRange head(int newWidth) { - if (newWidth >= width) return this; - if (newWidth <= 0) return null; - return new RuntimeRange<>(instance, start, newWidth, _interleaved); + + int maxWidth = instance.width; // Initial value. + NamedInstance parent = instance.parent; + while (parent.depth > 0) { + maxWidth *= parent.width; + parent = parent.parent; } - - /** - * Return the list of natural identifiers for the runtime instances - * in this range. Each returned identifier is an integer representation - * of the mixed-radix number [d0, ... , dn] with radices [w0, ... , wn], - * where d0 is the bank or channel index of this RuntimeRange's instance, which - * has width w0, and dn is the bank index of its topmost parent below the - * top-level (main) reactor, which has width wn. The depth of this RuntimeRange's - * instance, therefore, is n - 1. The order of the returned list is the order - * in which the runtime instances should be iterated. - */ - public List instances() { - List result = new ArrayList<>(width); - MixedRadixInt mr = startMR(); - int count = 0; - while (count++ < width) { - result.add(mr.get()); - mr.increment(); - } - return result; + this.maxWidth = maxWidth; + + if (width > 0 && width + start < maxWidth) { + this.width = width; + } else { + this.width = maxWidth - start; } - - /** - * Return a list containing the instance for this range and all of its - * parents, not including the top level reactor, in the order in which - * their banks and multiport channels should be iterated. - * For each depth at which the connection is interleaved, that parent - * will appear before this instance in depth order (shallower to deeper). - * For each depth at which the connection is not interleaved, that parent - * will appear after this instance in reverse depth order (deeper to - * shallower). - */ - public List> iterationOrder() { - ArrayList> result = new ArrayList<>(); - result.add(instance); - ReactorInstance parent = instance.parent; - while (parent.depth > 0) { - if (_interleaved.contains(parent)) { - // Put the parent at the head of the list. - result.add(0, parent); - } else { - result.add(parent); - } - parent = parent.parent; - } - return result; + } + + ////////////////////////////////////////////////////////// + //// Public variables + + /** The instance that this is a range of. */ + public final T instance; + + /** The start offset of this range. */ + public final int start; + + /** The maximum width of any range with this instance. */ + public final int maxWidth; + + /** The width of this range. */ + public final int width; + + ////////////////////////////////////////////////////////// + //// Public methods + + /** + * Compare ranges by first comparing their start offset, and then, if these are equal, comparing + * their widths. This comparison is meaningful only for ranges that have the same instances. Note + * that this can return 0 even if equals() does not return true. + */ + @Override + public int compareTo(RuntimeRange o) { + if (start < o.start) { + return -1; + } else if (start == o.start) { + return Integer.compare(width, o.width); + } else { + return 1; } - - /** - * Return a range that is the subset of this range that overlaps with the - * specified range or null if there is no overlap. - */ - public RuntimeRange overlap(RuntimeRange range) { - if (!overlaps(range)) return null; - int newStart = Math.max(start, range.start); - int newEnd = Math.min(start + width, range.start + range.width); - return tail(newStart - start).head(newEnd - newStart); + } + + /** + * Return a new RuntimeRange that is identical to this range but with width reduced to the + * specified width. If the new width is greater than or equal to the width of this range, then + * return this range. If the newWidth is 0 or negative, return null. + * + * @param newWidth The new width. + */ + public RuntimeRange head(int newWidth) { + if (newWidth >= width) return this; + if (newWidth <= 0) return null; + return new RuntimeRange<>(instance, start, newWidth, _interleaved); + } + + /** + * Return the list of natural identifiers for the runtime instances in this + * range. Each returned identifier is an integer representation of the mixed-radix number [d0, ... + * , dn] with radices [w0, ... , wn], where d0 is the bank or channel index of this RuntimeRange's + * instance, which has width w0, and dn is the bank index of its topmost parent below the + * top-level (main) reactor, which has width wn. The depth of this RuntimeRange's instance, + * therefore, is n - 1. The order of the returned list is the order in which the runtime instances + * should be iterated. + */ + public List instances() { + List result = new ArrayList<>(width); + MixedRadixInt mr = startMR(); + int count = 0; + while (count++ < width) { + result.add(mr.get()); + mr.increment(); } - - /** - * Return true if the specified range has the same instance as this range - * and the ranges overlap. - */ - public boolean overlaps(RuntimeRange range) { - if (!instance.equals(range.instance)) return false; - return start < range.start + range.width && start + width > range.start; + return result; + } + + /** + * Return a list containing the instance for this range and all of its parents, not including the + * top level reactor, in the order in which their banks and multiport channels should be iterated. + * For each depth at which the connection is interleaved, that parent will appear before this + * instance in depth order (shallower to deeper). For each depth at which the connection is not + * interleaved, that parent will appear after this instance in reverse depth order (deeper to + * shallower). + */ + public List> iterationOrder() { + ArrayList> result = new ArrayList<>(); + result.add(instance); + ReactorInstance parent = instance.parent; + while (parent.depth > 0) { + if (_interleaved.contains(parent)) { + // Put the parent at the head of the list. + result.add(0, parent); + } else { + result.add(parent); + } + parent = parent.parent; } - - /** - * Return a set of identifiers for runtime instances of a parent of this - * {@link RuntimeRange}'s instance {@code n} levels above this {@link RuntimeRange}'s instance. If {@code n == 1}, for - * example, then this return the identifiers for the parent ReactorInstance. - * - * This returns a list of natural identifiers, - * as defined below, for the instances within the range. - * - * The resulting list can be used to count the number of distinct - * runtime instances of this RuntimeRange's instance (using {@code n == 0}) or any of its parents that - * lie within the range and to provide an index into an array of runtime - * instances. - * - * Each natural identifier is the integer value of a mixed-radix number - * defined as follows: - *

      - *
    • The low-order digit is the index of the runtime instance of {@code i} within its container. - * If the {@link NamedInstance} is a {@code PortInstance}, this will be the multiport channel or {@code 0} if it is not a - * multiport. If the NamedInstance is a ReactorInstance, then it will be the bank - * index or {@code 0} if the reactor is not a bank. The radix for this digit will be - * the multiport width or bank width or 1 if the NamedInstance is neither a - * multiport nor a bank.
      • - *
    • The next digit will be the bank index of the container of the specified - * {@link NamedInstance} or {@code 0} if it is not a bank.
      • - *
    • The remaining digits will be bank indices of containers up to but not - * including the top-level reactor (there is no point in including the top-level - * reactor because it is never a bank).
      • - *
    • Each index that is returned can be used as an index into an array of - * runtime instances that is assumed to be in a natural order.
      • - *
    - * - * @param n The number of levels up of the parent. This is required to be - * less than the depth of this RuntimeRange's instance or an exception will be thrown. - */ - public Set parentInstances(int n) { - Set result = new LinkedHashSet<>(width); - MixedRadixInt mr = startMR(); - int count = 0; - while (count++ < width) { - result.add(mr.get(n)); - mr.increment(); - } - return result; + return result; + } + + /** + * Return a range that is the subset of this range that overlaps with the specified range or null + * if there is no overlap. + */ + public RuntimeRange overlap(RuntimeRange range) { + if (!overlaps(range)) return null; + int newStart = Math.max(start, range.start); + int newEnd = Math.min(start + width, range.start + range.width); + return tail(newStart - start).head(newEnd - newStart); + } + + /** + * Return true if the specified range has the same instance as this range and the ranges overlap. + */ + public boolean overlaps(RuntimeRange range) { + if (!instance.equals(range.instance)) return false; + return start < range.start + range.width && start + width > range.start; + } + + /** + * Return a set of identifiers for runtime instances of a parent of this {@link RuntimeRange}'s + * instance {@code n} levels above this {@link RuntimeRange}'s instance. If {@code n == 1}, for + * example, then this return the identifiers for the parent ReactorInstance. + * + *

    This returns a list of natural identifiers, as defined below, for the instances + * within the range. + * + *

    The resulting list can be used to count the number of distinct runtime instances of this + * RuntimeRange's instance (using {@code n == 0}) or any of its parents that lie within the range + * and to provide an index into an array of runtime instances. + * + *

    Each natural identifier is the integer value of a mixed-radix number defined as + * follows: + * + *

      + *
    • The low-order digit is the index of the runtime instance of {@code i} within its + * container. If the {@link NamedInstance} is a {@code PortInstance}, this will be the + * multiport channel or {@code 0} if it is not a multiport. If the NamedInstance is a + * ReactorInstance, then it will be the bank index or {@code 0} if the reactor is not a + * bank. The radix for this digit will be the multiport width or bank width or 1 if the + * NamedInstance is neither a multiport nor a bank. + *
    • The next digit will be the bank index of the container of the specified {@link + * NamedInstance} or {@code 0} if it is not a bank. + *
    • The remaining digits will be bank indices of containers up to but not including the + * top-level reactor (there is no point in including the top-level reactor because it is + * never a bank). + *
    • Each index that is returned can be used as an index into an array of runtime instances + * that is assumed to be in a natural order. + *
    + * + * @param n The number of levels up of the parent. This is required to be less than the depth of + * this RuntimeRange's instance or an exception will be thrown. + */ + public Set parentInstances(int n) { + Set result = new LinkedHashSet<>(width); + MixedRadixInt mr = startMR(); + int count = 0; + while (count++ < width) { + result.add(mr.get(n)); + mr.increment(); } + return result; + } - /** - * Return the nearest containing ReactorInstance for this instance. - * If this instance is a ReactorInstance, then return it. - * Otherwise, return its parent. - */ - public ReactorInstance parentReactor() { - if (instance instanceof ReactorInstance) { - return (ReactorInstance)instance; - } else { - return instance.getParent(); - } + /** + * Return the nearest containing ReactorInstance for this instance. If this instance is a + * ReactorInstance, then return it. Otherwise, return its parent. + */ + public ReactorInstance parentReactor() { + if (instance instanceof ReactorInstance) { + return (ReactorInstance) instance; + } else { + return instance.getParent(); } - - /** - * Return the permutation vector that indicates the order in which the digits - * of the permuted mixed-radix representations of indices in this range should - * be incremented. - */ - public List permutation() { - List result = new ArrayList<>(instance.depth); - // Populate the result with default zeros. - for (int i = 0; i < instance.depth; i++) { - result.add(0); - } - int count = 0; - for (NamedInstance i : iterationOrder()) { - result.set(count++, instance.depth - i.depth); - } - return result; + } + + /** + * Return the permutation vector that indicates the order in which the digits of the permuted + * mixed-radix representations of indices in this range should be incremented. + */ + public List permutation() { + List result = new ArrayList<>(instance.depth); + // Populate the result with default zeros. + for (int i = 0; i < instance.depth; i++) { + result.add(0); } - - /** - * Return the radixes vector containing the width of this instance followed - * by the widths of its containers, not including the top level, which always - * has radix 1 and value 0. - */ - public List radixes() { - List result = new ArrayList<>(instance.depth); - int width = instance.width; - // If the width cannot be determined, assume 1. - if (width < 0) width = 1; - result.add(width); - ReactorInstance p = instance.getParent(); - while (p != null && p.getDepth() > 0) { - width = p.getWidth(); - // If the width cannot be determined, assume 1. - if (width < 0) width = 1; - result.add(width); - p = p.getParent(); - } - return result; + int count = 0; + for (NamedInstance i : iterationOrder()) { + result.set(count++, instance.depth - i.depth); } + return result; + } - /** - * Return the start as a new permuted mixed-radix number. - * For any instance that is neither a multiport nor a bank, the - * corresponding digit will be 0. - */ - public MixedRadixInt startMR() { - MixedRadixInt result = new MixedRadixInt(null, radixes(), permutation()); - result.setMagnitude(start); - return result; + /** + * Return the radixes vector containing the width of this instance followed by the widths of its + * containers, not including the top level, which always has radix 1 and value 0. + */ + public List radixes() { + List result = new ArrayList<>(instance.depth); + int width = instance.width; + // If the width cannot be determined, assume 1. + if (width < 0) width = 1; + result.add(width); + ReactorInstance p = instance.getParent(); + while (p != null && p.getDepth() > 0) { + width = p.getWidth(); + // If the width cannot be determined, assume 1. + if (width < 0) width = 1; + result.add(width); + p = p.getParent(); } + return result; + } - /** - * Return a new range that represents the leftover elements - * starting at the specified offset relative to start. - * If start + offset is greater than or equal to the width, then this returns null. - * If this offset is 0 then this returns this range unmodified. - * @param offset The number of elements to consume. - */ - public RuntimeRange tail(int offset) { - if (offset == 0) return this; - if (offset >= width) return null; - return new RuntimeRange<>(instance, start + offset, width - offset, _interleaved); + /** + * Return the start as a new permuted mixed-radix number. For any instance that is neither a + * multiport nor a bank, the corresponding digit will be 0. + */ + public MixedRadixInt startMR() { + MixedRadixInt result = new MixedRadixInt(null, radixes(), permutation()); + result.setMagnitude(start); + return result; + } + + /** + * Return a new range that represents the leftover elements starting at the specified offset + * relative to start. If start + offset is greater than or equal to the width, then this returns + * null. If this offset is 0 then this returns this range unmodified. + * + * @param offset The number of elements to consume. + */ + public RuntimeRange tail(int offset) { + if (offset == 0) return this; + if (offset >= width) return null; + return new RuntimeRange<>(instance, start + offset, width - offset, _interleaved); + } + + /** + * Toggle the interleaved status of the specified reactor, which is assumed to be a parent of the + * instance of this range. If it was previously interleaved, make it not interleaved and vice + * versa. This returns a new RuntimeRange. + * + * @param reactor The parent reactor at which to toggle interleaving. + */ + public RuntimeRange toggleInterleaved(ReactorInstance reactor) { + Set newInterleaved = new HashSet<>(_interleaved); + if (_interleaved.contains(reactor)) { + newInterleaved.remove(reactor); + } else { + newInterleaved.add(reactor); } - - /** - * Toggle the interleaved status of the specified reactor, which is assumed - * to be a parent of the instance of this range. - * If it was previously interleaved, make it not interleaved - * and vice versa. This returns a new RuntimeRange. - * @param reactor The parent reactor at which to toggle interleaving. - */ - public RuntimeRange toggleInterleaved(ReactorInstance reactor) { - Set newInterleaved = new HashSet<>(_interleaved); - if (_interleaved.contains(reactor)) { - newInterleaved.remove(reactor); - } else { - newInterleaved.add(reactor); - } - return new RuntimeRange<>(instance, start, width, newInterleaved); + return new RuntimeRange<>(instance, start, width, newInterleaved); + } + + @Override + public String toString() { + return instance.getFullName() + "(" + start + "," + width + ")"; + } + + ////////////////////////////////////////////////////////// + //// Protected variables + + /** Record of which levels are interleaved. */ + Set _interleaved = new HashSet<>(); + + ////////////////////////////////////////////////////////// + //// Public inner classes + + /** Special case of RuntimeRange for PortInstance. */ + public static class Port extends RuntimeRange { + public Port(PortInstance instance) { + super(instance, null); } - - @Override - public String toString() { - return instance.getFullName() + "(" + start + "," + width + ")"; + + public Port(PortInstance instance, Set interleaved) { + super(instance, interleaved); } - - ////////////////////////////////////////////////////////// - //// Protected variables - - /** Record of which levels are interleaved. */ - Set _interleaved = new HashSet<>(); - - ////////////////////////////////////////////////////////// - //// Public inner classes - - /** - * Special case of RuntimeRange for PortInstance. - */ - public static class Port extends RuntimeRange { - public Port(PortInstance instance) { - super(instance, null); - } - public Port(PortInstance instance, Set interleaved) { - super(instance, interleaved); - } - public Port(PortInstance instance, int start, int width, Set interleaved) { - super(instance, start, width, interleaved); - } + + public Port(PortInstance instance, int start, int width, Set interleaved) { + super(instance, start, width, interleaved); } + } } diff --git a/org.lflang/src/org/lflang/generator/SendRange.java b/org.lflang/src/org/lflang/generator/SendRange.java index c6f6221b5f..5e7f406f1e 100644 --- a/org.lflang/src/org/lflang/generator/SendRange.java +++ b/org.lflang/src/org/lflang/generator/SendRange.java @@ -32,286 +32,277 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.List; import java.util.Map; import java.util.Set; - import org.lflang.lf.Connection; /** - * Class representing a range of a port that sources data - * together with a list of destination ranges of other ports that should all - * receive the same data sent in this range. - * All ranges in the destinations list have widths that are an integer - * multiple N of this range but not necessarily the same start offsets. - * - * This class and subclasses are designed to be immutable. - * Modifications always return a new RuntimeRange. + * Class representing a range of a port that sources data together with a list of destination ranges + * of other ports that should all receive the same data sent in this range. All ranges in the + * destinations list have widths that are an integer multiple N of this range but not necessarily + * the same start offsets. + * + *

    This class and subclasses are designed to be immutable. Modifications always return a new + * RuntimeRange. * * @author Edward A. Lee -*/ + */ public class SendRange extends RuntimeRange.Port { - - /** - * Create a new send range. - * @param instance The instance over which this is a range of. - * @param start The starting index. - * @param width The width. - * @param interleaved A list of parents that are interleaved or null if none. - * @param connection The connection that establishes this send or null if not unique or none. - */ - public SendRange( - PortInstance instance, - int start, - int width, - Set interleaved, - Connection connection - ) { - super(instance, start, width, interleaved); - this.connection = connection; - } - /** - * Create a new send range representing sending from the specified - * src to the specified dst. This preserves the interleaved status - * of both the src and dst. - * @param src The source range. - * @param dst The destination range. - * @param interleaved A list of parents that are interleaved or null if none. - * @param connection The connection that establishes this send or null if not unique or none. - */ - public SendRange( - RuntimeRange src, - RuntimeRange dst, - Set interleaved, - Connection connection - ) { - super(src.instance, src.start, src.width, interleaved); - destinations.add(dst); - _interleaved.addAll(src._interleaved); - this.connection = connection; - } + /** + * Create a new send range. + * + * @param instance The instance over which this is a range of. + * @param start The starting index. + * @param width The width. + * @param interleaved A list of parents that are interleaved or null if none. + * @param connection The connection that establishes this send or null if not unique or none. + */ + public SendRange( + PortInstance instance, + int start, + int width, + Set interleaved, + Connection connection) { + super(instance, start, width, interleaved); + this.connection = connection; + } - ////////////////////////////////////////////////////////// - //// Public variables + /** + * Create a new send range representing sending from the specified src to the specified dst. This + * preserves the interleaved status of both the src and dst. + * + * @param src The source range. + * @param dst The destination range. + * @param interleaved A list of parents that are interleaved or null if none. + * @param connection The connection that establishes this send or null if not unique or none. + */ + public SendRange( + RuntimeRange src, + RuntimeRange dst, + Set interleaved, + Connection connection) { + super(src.instance, src.start, src.width, interleaved); + destinations.add(dst); + _interleaved.addAll(src._interleaved); + this.connection = connection; + } - /** The connection that establishes this relationship or null if not unique or none. */ - public final Connection connection; - - /** The list of destination ranges to which this broadcasts. */ - public final List> destinations = new ArrayList<>(); + ////////////////////////////////////////////////////////// + //// Public variables - ////////////////////////////////////////////////////////// - //// Public methods + /** The connection that establishes this relationship or null if not unique or none. */ + public final Connection connection; - /** - * Add a destination to the list of destinations of this range. - * If the width of the destination is not a multiple of the width - * of this range, throw an exception. - * @throws IllegalArgumentException If the width doesn't match. - */ - public void addDestination(RuntimeRange dst) { - if (dst.width % width != 0) { - throw new IllegalArgumentException( - "Destination range width is not a multiple of sender's width"); - } - destinations.add(dst); - // Void any precomputed number of destinations. - _numberOfDestinationReactors = -1; + /** The list of destination ranges to which this broadcasts. */ + public final List> destinations = new ArrayList<>(); + + ////////////////////////////////////////////////////////// + //// Public methods + + /** + * Add a destination to the list of destinations of this range. If the width of the destination is + * not a multiple of the width of this range, throw an exception. + * + * @throws IllegalArgumentException If the width doesn't match. + */ + public void addDestination(RuntimeRange dst) { + if (dst.width % width != 0) { + throw new IllegalArgumentException( + "Destination range width is not a multiple of sender's width"); } - - /** - * Override the base class to add additional comparisons so that - * ordering is never ambiguous. This means that sorting will be deterministic. - * Note that this can return 0 even if equals() does not return true. - */ - @Override - public int compareTo(RuntimeRange o) { - int result = super.compareTo(o); - if (result == 0) { - // Longer destination lists come first. - if (destinations.size() > ((SendRange)o).destinations.size()) { - return -1; - } else if (destinations.size() == ((SendRange)o).destinations.size()) { - return instance.getFullName().compareTo(o.instance.getFullName()); - } else { - return 1; - } - } - return result; + destinations.add(dst); + // Void any precomputed number of destinations. + _numberOfDestinationReactors = -1; + } + + /** + * Override the base class to add additional comparisons so that ordering is never ambiguous. This + * means that sorting will be deterministic. Note that this can return 0 even if equals() does not + * return true. + */ + @Override + public int compareTo(RuntimeRange o) { + int result = super.compareTo(o); + if (result == 0) { + // Longer destination lists come first. + if (destinations.size() > ((SendRange) o).destinations.size()) { + return -1; + } else if (destinations.size() == ((SendRange) o).destinations.size()) { + return instance.getFullName().compareTo(o.instance.getFullName()); + } else { + return 1; + } } + return result; + } - /** - * Return the total number of destination reactors for this range. - * Specifically, this is the number of distinct runtime reactor instances - * that react to messages from this send range. - */ - public int getNumberOfDestinationReactors() { - if (_numberOfDestinationReactors < 0) { - // Has not been calculated before. Calculate now. - _numberOfDestinationReactors = 0; - Map> result = new HashMap<>(); - for (RuntimeRange destination : this.destinations) { - // The following set contains unique identifiers the parent reactors - // of destination ports. - Set parentIDs = destination.parentInstances(1); - Set previousParentIDs = result.get(destination.instance.parent); - if (previousParentIDs == null) { - result.put(destination.instance.parent, parentIDs); - } else { - previousParentIDs.addAll(parentIDs); - } - } - for (ReactorInstance parent : result.keySet()) { - _numberOfDestinationReactors += result.get(parent).size(); - } + /** + * Return the total number of destination reactors for this range. Specifically, this is the + * number of distinct runtime reactor instances that react to messages from this send range. + */ + public int getNumberOfDestinationReactors() { + if (_numberOfDestinationReactors < 0) { + // Has not been calculated before. Calculate now. + _numberOfDestinationReactors = 0; + Map> result = new HashMap<>(); + for (RuntimeRange destination : this.destinations) { + // The following set contains unique identifiers the parent reactors + // of destination ports. + Set parentIDs = destination.parentInstances(1); + Set previousParentIDs = result.get(destination.instance.parent); + if (previousParentIDs == null) { + result.put(destination.instance.parent, parentIDs); + } else { + previousParentIDs.addAll(parentIDs); } - return _numberOfDestinationReactors; + } + for (ReactorInstance parent : result.keySet()) { + _numberOfDestinationReactors += result.get(parent).size(); + } } + return _numberOfDestinationReactors; + } - /** - * Return a new SendRange that is identical to this range but - * with width reduced to the specified width. - * If the new width is greater than or equal to the width - * of this range, then return this range. - * If the newWidth is 0 or negative, return null. - * This overrides the base class to also apply head() - * to the destination list. - * @param newWidth The new width. - */ - @Override - public SendRange head(int newWidth) { - // NOTE: Cannot use the superclass because it returns a RuntimeRange, not a SendRange. - // Also, cannot return this without applying head() to the destinations. - if (newWidth <= 0) return null; + /** + * Return a new SendRange that is identical to this range but with width reduced to the specified + * width. If the new width is greater than or equal to the width of this range, then return this + * range. If the newWidth is 0 or negative, return null. This overrides the base class to also + * apply head() to the destination list. + * + * @param newWidth The new width. + */ + @Override + public SendRange head(int newWidth) { + // NOTE: Cannot use the superclass because it returns a RuntimeRange, not a SendRange. + // Also, cannot return this without applying head() to the destinations. + if (newWidth <= 0) return null; - SendRange result = new SendRange(instance, start, newWidth, _interleaved, connection); - - for (RuntimeRange destination : destinations) { - result.destinations.add(destination.head(newWidth)); - } - return result; + SendRange result = new SendRange(instance, start, newWidth, _interleaved, connection); + + for (RuntimeRange destination : destinations) { + result.destinations.add(destination.head(newWidth)); } + return result; + } - /** - * Return a range that is the subset of this range that overlaps with the - * specified range or null if there is no overlap. - */ - @Override - public SendRange overlap(RuntimeRange range) { - if (!overlaps(range)) return null; - if (range.start == start && range.width == width) return this; - int newStart = Math.max(start, range.start); - int newEnd = Math.min(start + width, range.start + range.width); - int newWidth = newEnd - newStart; - SendRange result = new SendRange(instance, newStart, newWidth, _interleaved, connection); - result._interleaved.addAll(_interleaved); - for (RuntimeRange destination : destinations) { - // The destination width is a multiple of this range's width. - // If the multiple is greater than 1, then the destination needs to - // split into multiple destinations. - while (destination != null) { - int dstStart = destination.start + (newStart - start); - RuntimeRange.Port dst = new RuntimeRange.Port( - destination.instance, - dstStart, - newWidth, - destination._interleaved - ); - result.addDestination(dst); - destination = destination.tail(width); - } - } - return result; + /** + * Return a range that is the subset of this range that overlaps with the specified range or null + * if there is no overlap. + */ + @Override + public SendRange overlap(RuntimeRange range) { + if (!overlaps(range)) return null; + if (range.start == start && range.width == width) return this; + int newStart = Math.max(start, range.start); + int newEnd = Math.min(start + width, range.start + range.width); + int newWidth = newEnd - newStart; + SendRange result = new SendRange(instance, newStart, newWidth, _interleaved, connection); + result._interleaved.addAll(_interleaved); + for (RuntimeRange destination : destinations) { + // The destination width is a multiple of this range's width. + // If the multiple is greater than 1, then the destination needs to + // split into multiple destinations. + while (destination != null) { + int dstStart = destination.start + (newStart - start); + RuntimeRange.Port dst = + new RuntimeRange.Port( + destination.instance, dstStart, newWidth, destination._interleaved); + result.addDestination(dst); + destination = destination.tail(width); + } } + return result; + } - /** - * Return a new SendRange that represents the leftover elements - * starting at the specified offset. If the offset is greater - * than or equal to the width, then this returns null. - * If this offset is 0 then this returns this range unmodified. - * This overrides the base class to also apply tail() - * to the destination list. - * @param offset The number of elements to consume. - */ - @Override - public SendRange tail(int offset) { - // NOTE: Cannot use the superclass because it returns a RuntimeRange, not a SendRange. - // Also, cannot return this without applying tail() to the destinations. - if (offset >= width) return null; - SendRange result = new SendRange( - instance, start + offset, width - offset, _interleaved, connection); + /** + * Return a new SendRange that represents the leftover elements starting at the specified offset. + * If the offset is greater than or equal to the width, then this returns null. If this offset is + * 0 then this returns this range unmodified. This overrides the base class to also apply tail() + * to the destination list. + * + * @param offset The number of elements to consume. + */ + @Override + public SendRange tail(int offset) { + // NOTE: Cannot use the superclass because it returns a RuntimeRange, not a SendRange. + // Also, cannot return this without applying tail() to the destinations. + if (offset >= width) return null; + SendRange result = + new SendRange(instance, start + offset, width - offset, _interleaved, connection); - for (RuntimeRange destination : destinations) { - result.destinations.add(destination.tail(offset)); - } - return result; + for (RuntimeRange destination : destinations) { + result.destinations.add(destination.tail(offset)); } + return result; + } - @Override - public String toString() { - StringBuilder result = new StringBuilder(); - result.append(super.toString()); - result.append("->["); - List dsts = new LinkedList<>(); - for (RuntimeRange dst : destinations) { - dsts.add(dst.toString()); - } - result.append(String.join(", ", dsts)); - result.append("]"); - return result.toString(); + @Override + public String toString() { + StringBuilder result = new StringBuilder(); + result.append(super.toString()); + result.append("->["); + List dsts = new LinkedList<>(); + for (RuntimeRange dst : destinations) { + dsts.add(dst.toString()); } + result.append(String.join(", ", dsts)); + result.append("]"); + return result.toString(); + } + + ////////////////////////////////////////////////////////// + //// Protected methods - ////////////////////////////////////////////////////////// - //// Protected methods + /** + * Assuming that this SendRange is completely contained by one of the destinations of the + * specified srcRange, return a new SendRange where the send range is the subrange of the + * specified srcRange that overlaps with this SendRange and the destinations include all the + * destinations of this SendRange. If the assumption is not satisfied, throw an + * IllegalArgumentException. + * + *

    If any parent of this range is marked interleaved and is also a parent of the specified + * srcRange, then that parent will be marked interleaved in the result. + * + * @param srcRange A new source range. + * @param srcRangeOffset An offset into the source range. + */ + protected SendRange newSendRange(SendRange srcRange, int srcRangeOffset) { + // Every destination of srcRange receives all channels of srcRange (multicast). + // Find which multicast destination overlaps with this srcRange. + for (RuntimeRange srcDestination : srcRange.destinations) { + RuntimeRange overlap = srcDestination.overlap(this); + if (overlap == null) continue; // Not this one. - /** - * Assuming that this SendRange is completely contained by one - * of the destinations of the specified srcRange, return a new SendRange - * where the send range is the subrange of the specified srcRange that - * overlaps with this SendRange and the destinations include all the - * destinations of this SendRange. If the assumption is not satisfied, - * throw an IllegalArgumentException. - * - * If any parent of this range is marked interleaved and is also a parent of the - * specified srcRange, then that parent will be marked interleaved - * in the result. - * - * @param srcRange A new source range. - * @param srcRangeOffset An offset into the source range. - */ - protected SendRange newSendRange(SendRange srcRange, int srcRangeOffset) { - // Every destination of srcRange receives all channels of srcRange (multicast). - // Find which multicast destination overlaps with this srcRange. - for (RuntimeRange srcDestination : srcRange.destinations) { - RuntimeRange overlap = srcDestination.overlap(this); - if (overlap == null) continue; // Not this one. - - if (overlap.width == width) { - // Found an overlap that is completely contained. - // If this width is greater than the srcRange width, - // then assume srcRange is multicasting via this. - int newWidth = Math.min(width, srcRange.width); - // The interleaving of the result is the union of the two interleavings. - Set interleaving = new LinkedHashSet<>(); - interleaving.addAll(_interleaved); - interleaving.addAll(srcRange._interleaved); - SendRange result = new SendRange( - srcRange.instance, - srcRange.start + srcRangeOffset, - newWidth, - interleaving, - connection); - for (RuntimeRange dst : destinations) { - result.addDestination(dst); - } - return result; - } + if (overlap.width == width) { + // Found an overlap that is completely contained. + // If this width is greater than the srcRange width, + // then assume srcRange is multicasting via this. + int newWidth = Math.min(width, srcRange.width); + // The interleaving of the result is the union of the two interleavings. + Set interleaving = new LinkedHashSet<>(); + interleaving.addAll(_interleaved); + interleaving.addAll(srcRange._interleaved); + SendRange result = + new SendRange( + srcRange.instance, + srcRange.start + srcRangeOffset, + newWidth, + interleaving, + connection); + for (RuntimeRange dst : destinations) { + result.addDestination(dst); } - throw new IllegalArgumentException( - "Expected this SendRange " + this - + " to be completely contained by a destination of " + srcRange); + return result; + } } + throw new IllegalArgumentException( + "Expected this SendRange " + + this + + " to be completely contained by a destination of " + + srcRange); + } - ////////////////////////////////////////////////////////// - //// Private variables + ////////////////////////////////////////////////////////// + //// Private variables - private int _numberOfDestinationReactors = -1; // Never access this directly. + private int _numberOfDestinationReactors = -1; // Never access this directly. } diff --git a/org.lflang/src/org/lflang/generator/SubContext.java b/org.lflang/src/org/lflang/generator/SubContext.java index 5e7a981ab8..cf90cb1fda 100644 --- a/org.lflang/src/org/lflang/generator/SubContext.java +++ b/org.lflang/src/org/lflang/generator/SubContext.java @@ -1,90 +1,88 @@ package org.lflang.generator; -import java.io.File; import java.util.Properties; - import org.eclipse.xtext.util.CancelIndicator; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.TargetConfig; /** - * A {@code SubContext} is the context of a process within a build process. For example, - * compilation of generated code may optionally be given a {@code SubContext} because - * compilation is part of a complete build. + * A {@code SubContext} is the context of a process within a build process. For example, compilation + * of generated code may optionally be given a {@code SubContext} because compilation is part of a + * complete build. * * @author Peter Donovan */ public class SubContext implements LFGeneratorContext { - private final LFGeneratorContext containingContext; - private final int startPercentProgress; - private final int endPercentProgress; - private GeneratorResult result = null; - - protected ErrorReporter errorReporter; - - /** - * Initializes the context within {@code containingContext} of the process that extends from - * {@code startPercentProgress} to {@code endPercentProgress}. - * @param containingContext The context of the containing build process. - * @param startPercentProgress The percent progress of the containing build process when this - * nested process starts. - * @param endPercentProgress The percent progress of the containing build process when this - * nested process ends. - */ - public SubContext(LFGeneratorContext containingContext, int startPercentProgress, int endPercentProgress) { - this.containingContext = containingContext; - this.startPercentProgress = startPercentProgress; - this.endPercentProgress = endPercentProgress; - } - - @Override - public CancelIndicator getCancelIndicator() { - return containingContext.getCancelIndicator(); - } - - @Override - public Mode getMode() { - return containingContext.getMode(); - } - - @Override - public Properties getArgs() { - return containingContext.getArgs(); - } - - @Override - public ErrorReporter getErrorReporter() { - return containingContext.getErrorReporter(); - } - - @Override - public void finish(GeneratorResult result) { - this.result = result; - } - - @Override - public GeneratorResult getResult() { - return result; - } - - @Override - public FileConfig getFileConfig() { - return containingContext.getFileConfig(); - } - - @Override - public TargetConfig getTargetConfig() { - return containingContext.getTargetConfig(); - } - - @Override - public void reportProgress(String message, int percentage) { - containingContext.reportProgress( - message, - startPercentProgress * (100 - percentage) / 100 + endPercentProgress * percentage / 100 - ); - } + private final LFGeneratorContext containingContext; + private final int startPercentProgress; + private final int endPercentProgress; + private GeneratorResult result = null; + + protected ErrorReporter errorReporter; + + /** + * Initializes the context within {@code containingContext} of the process that extends from + * {@code startPercentProgress} to {@code endPercentProgress}. + * + * @param containingContext The context of the containing build process. + * @param startPercentProgress The percent progress of the containing build process when this + * nested process starts. + * @param endPercentProgress The percent progress of the containing build process when this nested + * process ends. + */ + public SubContext( + LFGeneratorContext containingContext, int startPercentProgress, int endPercentProgress) { + this.containingContext = containingContext; + this.startPercentProgress = startPercentProgress; + this.endPercentProgress = endPercentProgress; + } + + @Override + public CancelIndicator getCancelIndicator() { + return containingContext.getCancelIndicator(); + } + + @Override + public Mode getMode() { + return containingContext.getMode(); + } + + @Override + public Properties getArgs() { + return containingContext.getArgs(); + } + + @Override + public ErrorReporter getErrorReporter() { + return containingContext.getErrorReporter(); + } + + @Override + public void finish(GeneratorResult result) { + this.result = result; + } + + @Override + public GeneratorResult getResult() { + return result; + } + + @Override + public FileConfig getFileConfig() { + return containingContext.getFileConfig(); + } + + @Override + public TargetConfig getTargetConfig() { + return containingContext.getTargetConfig(); + } + + @Override + public void reportProgress(String message, int percentage) { + containingContext.reportProgress( + message, + startPercentProgress * (100 - percentage) / 100 + endPercentProgress * percentage / 100); + } } diff --git a/org.lflang/src/org/lflang/generator/TargetTypes.java b/org.lflang/src/org/lflang/generator/TargetTypes.java index 585d65c96a..eda5cffd11 100644 --- a/org.lflang/src/org/lflang/generator/TargetTypes.java +++ b/org.lflang/src/org/lflang/generator/TargetTypes.java @@ -3,10 +3,9 @@ import java.util.List; import java.util.Objects; import java.util.stream.Collectors; - -import org.lflang.ast.ASTUtils; import org.lflang.InferredType; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.lf.Action; import org.lflang.lf.BracedListExpression; import org.lflang.lf.CodeExpr; @@ -21,257 +20,217 @@ import org.lflang.lf.Type; /** - * Information about the types of a target language. Contains - * utilities to convert LF expressions and types to the target - * language. Each code generator is expected to use at least one + * Information about the types of a target language. Contains utilities to convert LF expressions + * and types to the target language. Each code generator is expected to use at least one * language-specific instance of this interface. - *

    - * TODO currently, {@link GeneratorBase} implements this interface, - * it should instead contain an instance. + * + *

    TODO currently, {@link GeneratorBase} implements this interface, it should instead contain an + * instance. * * @author Clément Fournier - TU Dresden, INSA Rennes */ public interface TargetTypes { - - /** - * Return true if the target supports generics (i.e., parametric - * polymorphism), false otherwise. - */ - boolean supportsGenerics(); - - - /** - * Return the type of time durations. - */ - String getTargetTimeType(); - - - /** - * Return the type of tags. - */ - String getTargetTagType(); - - - /** - * Return the type of fixed sized lists (or arrays). - */ - String getTargetFixedSizeListType(String baseType, int size); - - - /** - * Return the type of variable sized lists (eg {@code std::vector}). - */ - String getTargetVariableSizeListType(String baseType); - - - default String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { - return escapeIdentifier(expr.getParameter().getName()); - } - - /** Translate the braced list expression into target language syntax. */ - default String getTargetBracedListExpr(BracedListExpression expr, InferredType typeOrNull) { - InferredType t = typeOrNull == null ? InferredType.undefined() : typeOrNull; - return expr.getItems().stream().map(e -> getTargetExpr(e, t)) - .collect(Collectors.joining(",", "{", "}")); - } - - /** - * Return an "undefined" type which is used as a default - * when a type cannot be inferred. - */ - String getTargetUndefinedType(); - - /** - * Returns a version of the given LF identifier that is - * escaped properly for insertion into a piece of target - * code. - */ - default String escapeIdentifier(String ident) { - return ident; - } - - /** - * Returns an expression in the target language that corresponds - * to the given time value ({@link #getTargetTimeType()}). - */ - default String getTargetTimeExpr(TimeValue timeValue) { - // todo make non-default when we reuse this for all generators, - // all targets should support this. - Objects.requireNonNull(timeValue); - throw new UnsupportedGeneratorFeatureException("Time expressions"); - } - - /** - * Returns an expression in the target language that corresponds - * to a variable-size list expression. - * - * @throws UnsupportedGeneratorFeatureException If the target does not support this - */ - default String getVariableSizeListInitExpression(List contents, boolean withBraces) { - throw new UnsupportedGeneratorFeatureException("Variable size lists"); - } - - /** - * Returns an expression in the target language that corresponds - * to a fixed-size list expression. - * - * @throws UnsupportedGeneratorFeatureException If the target does not support this - */ - default String getFixedSizeListInitExpression(List contents, int listSize, boolean withBraces) { - throw new UnsupportedGeneratorFeatureException("Fixed size lists"); - } - - - /** - * Returns the expression that is used to replace a - * missing expression in the source language. The expression - * may for instance be a type-agnostic default value - * (e.g. Rust's {@code Default::default()}), or produce - * a compiler error (e.g. Rust's {@code compiler_error!("missing initializer")}). - * - * @throws UnsupportedGeneratorFeatureException If the target does not support this - */ - default String getMissingExpr(InferredType type) { - throw new UnsupportedGeneratorFeatureException("Missing initializers"); - } - - - /** - * Returns a target type inferred from the type node, or the - * initializer list. If both are absent, then the undefined - * type is returned. - */ - default String getTargetType(Type type, Initializer init) { - return getTargetType(ASTUtils.getInferredType(type, init)); - } - - /** - * Returns the target type of the type node. This just provides - * a default parameter for {@link #getTargetType(Type, Initializer)}. - * If the parameter is null, then the undefined type is returned. - */ - default String getTargetType(Type type) { - return getTargetType(type, null); - } - - /** - * Return a string representing the specified type in the - * target language. - */ - default String getTargetType(InferredType type) { - if (type.isUndefined()) { - return getTargetUndefinedType(); - } else if (type.isTime) { - if (type.isFixedSizeList) { - return getTargetFixedSizeListType(getTargetTimeType(), type.listSize); - } else if (type.isVariableSizeList) { - return getTargetVariableSizeListType(getTargetTimeType()); - } else { - return getTargetTimeType(); - } - } else if (type.isFixedSizeList) { - return getTargetFixedSizeListType(type.baseType(), type.listSize); - } else if (type.isVariableSizeList) { - return getTargetVariableSizeListType(type.baseType()); - } else if (!type.astType.getTypeArgs().isEmpty()) { - List args = type.astType.getTypeArgs().stream().map(this::getTargetType).toList(); - return getGenericType(type.baseType(), args); - } - return type.toOriginalText(); - } - - /** Build a generic type. The type args list must not be empty. */ - default String getGenericType(String base, List args) { - assert !args.isEmpty() : "Empty type arguments for " + base; - return base + "<" + String.join(", ", args) + ">"; - } - - /** - * Return a string representing the type of the given - * parameter. - */ - default String getTargetType(Parameter p) { - return getTargetType(ASTUtils.getInferredType(p)); - } - - /** - * Return a string representing the type of the given - * state variable. - */ - default String getTargetType(StateVar s) { - return getTargetType(ASTUtils.getInferredType(s)); - } - - /** - * Return a string representing the type of the given - * action. - */ - default String getTargetType(Action a) { - return getTargetType(ASTUtils.getInferredType(a)); - } - - /** - * Return a string representing the type of the given - * port. - */ - default String getTargetType(Port p) { - return getTargetType(ASTUtils.getInferredType(p)); - } - - /** - * Returns the representation of the given initializer - * expression in target code. The given type, if non-null, - * may inform the code generation. - * - * @param init Initializer node (nullable) - * @param type Declared type of the expression (nullable) - */ - default String getTargetInitializer(Initializer init, Type type) { - var inferredType = ASTUtils.getInferredType(type, init); - if (init == null) { - return getMissingExpr(inferredType); - } - var single = ASTUtils.asSingleExpr(init); - if (single != null) { - return getTargetExpr(single, inferredType); - } - var targetValues = init.getExprs().stream().map(it -> getTargetExpr(it, inferredType)).collect(Collectors.toList()); - if (inferredType.isFixedSizeList) { - return getFixedSizeListInitExpression(targetValues, inferredType.listSize, init.isBraces()); - } else { - return getVariableSizeListInitExpression(targetValues, init.isBraces()); - } - } - - - /** - * Returns the representation of the given expression in target code. - * The given type, if non-null, may inform the code generation. - */ - default String getTargetExpr(Expression expr, InferredType type) { - if (ASTUtils.isZero(expr) && type != null && type.isTime) { - return getTargetTimeExpr(TimeValue.ZERO); - } else if (expr instanceof ParameterReference) { - return getTargetParamRef((ParameterReference) expr, type); - } else if (expr instanceof Time) { - return getTargetTimeExpr((Time) expr); - } else if (expr instanceof Literal) { - return ASTUtils.addZeroToLeadingDot(((Literal) expr).getLiteral()); // here we don't escape - } else if (expr instanceof CodeExpr) { - return ASTUtils.toText(((CodeExpr) expr).getCode()); - } else if (expr instanceof BracedListExpression) { - return getTargetBracedListExpr((BracedListExpression) expr, type); - } else { - throw new IllegalStateException("Invalid value " + expr); - } - } - - /** - * Returns the representation of the given time value in - * target code. - */ - default String getTargetTimeExpr(Time t) { - return getTargetTimeExpr(ASTUtils.toTimeValue(t)); - } + /** + * Return true if the target supports generics (i.e., parametric polymorphism), false otherwise. + */ + boolean supportsGenerics(); + + /** Return the type of time durations. */ + String getTargetTimeType(); + + /** Return the type of tags. */ + String getTargetTagType(); + + /** Return the type of fixed sized lists (or arrays). */ + String getTargetFixedSizeListType(String baseType, int size); + + /** Return the type of variable sized lists (eg {@code std::vector}). */ + String getTargetVariableSizeListType(String baseType); + + default String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + return escapeIdentifier(expr.getParameter().getName()); + } + + /** Translate the braced list expression into target language syntax. */ + default String getTargetBracedListExpr(BracedListExpression expr, InferredType typeOrNull) { + InferredType t = typeOrNull == null ? InferredType.undefined() : typeOrNull; + return expr.getItems().stream() + .map(e -> getTargetExpr(e, t)) + .collect(Collectors.joining(",", "{", "}")); + } + + /** Return an "undefined" type which is used as a default when a type cannot be inferred. */ + String getTargetUndefinedType(); + + /** + * Returns a version of the given LF identifier that is escaped properly for insertion into a + * piece of target code. + */ + default String escapeIdentifier(String ident) { + return ident; + } + + /** + * Returns an expression in the target language that corresponds to the given time value ({@link + * #getTargetTimeType()}). + */ + default String getTargetTimeExpr(TimeValue timeValue) { + // todo make non-default when we reuse this for all generators, + // all targets should support this. + Objects.requireNonNull(timeValue); + throw new UnsupportedGeneratorFeatureException("Time expressions"); + } + + /** + * Returns an expression in the target language that corresponds to a variable-size list + * expression. + * + * @throws UnsupportedGeneratorFeatureException If the target does not support this + */ + default String getVariableSizeListInitExpression(List contents, boolean withBraces) { + throw new UnsupportedGeneratorFeatureException("Variable size lists"); + } + + /** + * Returns an expression in the target language that corresponds to a fixed-size list expression. + * + * @throws UnsupportedGeneratorFeatureException If the target does not support this + */ + default String getFixedSizeListInitExpression( + List contents, int listSize, boolean withBraces) { + throw new UnsupportedGeneratorFeatureException("Fixed size lists"); + } + + /** + * Returns the expression that is used to replace a missing expression in the source language. The + * expression may for instance be a type-agnostic default value (e.g. Rust's {@code + * Default::default()}), or produce a compiler error (e.g. Rust's {@code compiler_error!("missing + * initializer")}). + * + * @throws UnsupportedGeneratorFeatureException If the target does not support this + */ + default String getMissingExpr(InferredType type) { + throw new UnsupportedGeneratorFeatureException("Missing initializers"); + } + + /** + * Returns a target type inferred from the type node, or the initializer list. If both are absent, + * then the undefined type is returned. + */ + default String getTargetType(Type type, Initializer init) { + return getTargetType(ASTUtils.getInferredType(type, init)); + } + + /** + * Returns the target type of the type node. This just provides a default parameter for {@link + * #getTargetType(Type, Initializer)}. If the parameter is null, then the undefined type is + * returned. + */ + default String getTargetType(Type type) { + return getTargetType(type, null); + } + + /** Return a string representing the specified type in the target language. */ + default String getTargetType(InferredType type) { + if (type.isUndefined()) { + return getTargetUndefinedType(); + } else if (type.isTime) { + if (type.isFixedSizeList) { + return getTargetFixedSizeListType(getTargetTimeType(), type.listSize); + } else if (type.isVariableSizeList) { + return getTargetVariableSizeListType(getTargetTimeType()); + } else { + return getTargetTimeType(); + } + } else if (type.isFixedSizeList) { + return getTargetFixedSizeListType(type.baseType(), type.listSize); + } else if (type.isVariableSizeList) { + return getTargetVariableSizeListType(type.baseType()); + } else if (!type.astType.getTypeArgs().isEmpty()) { + List args = type.astType.getTypeArgs().stream().map(this::getTargetType).toList(); + return getGenericType(type.baseType(), args); + } + return type.toOriginalText(); + } + + /** Build a generic type. The type args list must not be empty. */ + default String getGenericType(String base, List args) { + assert !args.isEmpty() : "Empty type arguments for " + base; + return base + "<" + String.join(", ", args) + ">"; + } + + /** Return a string representing the type of the given parameter. */ + default String getTargetType(Parameter p) { + return getTargetType(ASTUtils.getInferredType(p)); + } + + /** Return a string representing the type of the given state variable. */ + default String getTargetType(StateVar s) { + return getTargetType(ASTUtils.getInferredType(s)); + } + + /** Return a string representing the type of the given action. */ + default String getTargetType(Action a) { + return getTargetType(ASTUtils.getInferredType(a)); + } + + /** Return a string representing the type of the given port. */ + default String getTargetType(Port p) { + return getTargetType(ASTUtils.getInferredType(p)); + } + + /** + * Returns the representation of the given initializer expression in target code. The given type, + * if non-null, may inform the code generation. + * + * @param init Initializer node (nullable) + * @param type Declared type of the expression (nullable) + */ + default String getTargetInitializer(Initializer init, Type type) { + var inferredType = ASTUtils.getInferredType(type, init); + if (init == null) { + return getMissingExpr(inferredType); + } + var single = ASTUtils.asSingleExpr(init); + if (single != null) { + return getTargetExpr(single, inferredType); + } + var targetValues = + init.getExprs().stream() + .map(it -> getTargetExpr(it, inferredType)) + .collect(Collectors.toList()); + if (inferredType.isFixedSizeList) { + return getFixedSizeListInitExpression(targetValues, inferredType.listSize, init.isBraces()); + } else { + return getVariableSizeListInitExpression(targetValues, init.isBraces()); + } + } + + /** + * Returns the representation of the given expression in target code. The given type, if non-null, + * may inform the code generation. + */ + default String getTargetExpr(Expression expr, InferredType type) { + if (ASTUtils.isZero(expr) && type != null && type.isTime) { + return getTargetTimeExpr(TimeValue.ZERO); + } else if (expr instanceof ParameterReference) { + return getTargetParamRef((ParameterReference) expr, type); + } else if (expr instanceof Time) { + return getTargetTimeExpr((Time) expr); + } else if (expr instanceof Literal) { + return ASTUtils.addZeroToLeadingDot(((Literal) expr).getLiteral()); // here we don't escape + } else if (expr instanceof CodeExpr) { + return ASTUtils.toText(((CodeExpr) expr).getCode()); + } else if (expr instanceof BracedListExpression) { + return getTargetBracedListExpr((BracedListExpression) expr, type); + } else { + throw new IllegalStateException("Invalid value " + expr); + } + } + + /** Returns the representation of the given time value in target code. */ + default String getTargetTimeExpr(Time t) { + return getTargetTimeExpr(ASTUtils.toTimeValue(t)); + } } diff --git a/org.lflang/src/org/lflang/generator/TimerInstance.java b/org.lflang/src/org/lflang/generator/TimerInstance.java index 492398998c..b25552bb6c 100644 --- a/org.lflang/src/org/lflang/generator/TimerInstance.java +++ b/org.lflang/src/org/lflang/generator/TimerInstance.java @@ -1,28 +1,28 @@ /** Instance of a timer. */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; @@ -31,63 +31,58 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY /** * Instance of a timer. - * + * * @author Marten Lohstroh * @author Edward A. Lee */ public class TimerInstance extends TriggerInstance { - /** The global default for offset. */ - public static final TimeValue DEFAULT_OFFSET = TimeValue.ZERO; + /** The global default for offset. */ + public static final TimeValue DEFAULT_OFFSET = TimeValue.ZERO; - /** The global default for period. */ - public static final TimeValue DEFAULT_PERIOD = TimeValue.ZERO; + /** The global default for period. */ + public static final TimeValue DEFAULT_PERIOD = TimeValue.ZERO; - private TimeValue offset = DEFAULT_OFFSET; + private TimeValue offset = DEFAULT_OFFSET; - private TimeValue period = DEFAULT_PERIOD; + private TimeValue period = DEFAULT_PERIOD; - /** - * Create a new timer instance. - * If the definition is null, then this is a startup timer. - * @param definition The AST definition, or null for startup. - * @param parent The parent reactor. - */ - public TimerInstance(Timer definition, ReactorInstance parent) { - super(definition, parent); - if (parent == null) { - throw new InvalidSourceException("Cannot create an TimerInstance with no parent."); + /** + * Create a new timer instance. If the definition is null, then this is a startup timer. + * + * @param definition The AST definition, or null for startup. + * @param parent The parent reactor. + */ + public TimerInstance(Timer definition, ReactorInstance parent) { + super(definition, parent); + if (parent == null) { + throw new InvalidSourceException("Cannot create an TimerInstance with no parent."); + } + if (definition != null) { + if (definition.getOffset() != null) { + try { + this.offset = parent.getTimeValue(definition.getOffset()); + } catch (IllegalArgumentException ex) { + parent.reporter.reportError(definition.getOffset(), "Invalid time."); } - if (definition != null) { - if (definition.getOffset() != null) { - try { - this.offset = parent.getTimeValue(definition.getOffset()); - } catch (IllegalArgumentException ex) { - parent.reporter.reportError(definition.getOffset(), "Invalid time."); - } - } - if (definition.getPeriod() != null) { - try { - this.period = parent.getTimeValue(definition.getPeriod()); - } catch (IllegalArgumentException ex) { - parent.reporter.reportError(definition.getPeriod(), "Invalid time."); - } - } + } + if (definition.getPeriod() != null) { + try { + this.period = parent.getTimeValue(definition.getPeriod()); + } catch (IllegalArgumentException ex) { + parent.reporter.reportError(definition.getPeriod(), "Invalid time."); } + } } + } - /** - * Get the value of the offset parameter. - */ - public TimeValue getOffset() { - return offset; - } - - /** - * Get the value of the offset parameter. - */ - public TimeValue getPeriod() { - return period; - } + /** Get the value of the offset parameter. */ + public TimeValue getOffset() { + return offset; + } + /** Get the value of the offset parameter. */ + public TimeValue getPeriod() { + return period; + } } diff --git a/org.lflang/src/org/lflang/generator/TriggerInstance.java b/org.lflang/src/org/lflang/generator/TriggerInstance.java index 47212ff0e8..b4ddc35a15 100644 --- a/org.lflang/src/org/lflang/generator/TriggerInstance.java +++ b/org.lflang/src/org/lflang/generator/TriggerInstance.java @@ -1,181 +1,170 @@ /** Instance of a trigger (port, action, or timer). */ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator; import java.util.LinkedHashSet; import java.util.Set; - import org.lflang.lf.BuiltinTrigger; import org.lflang.lf.BuiltinTriggerRef; import org.lflang.lf.TriggerRef; import org.lflang.lf.Variable; import org.lflang.lf.impl.VariableImpl; -/** Instance of a trigger (port, action, or timer). +/** + * Instance of a trigger (port, action, or timer). * - * @author Marten Lohstroh - * @author Edward A. Lee - * @author Alexander Schulz-Rosengarten + * @author Marten Lohstroh + * @author Edward A. Lee + * @author Alexander Schulz-Rosengarten */ public class TriggerInstance extends NamedInstance { - /** Construct a new instance with the specified definition - * and parent. E.g., for a action instance, the definition - * is Action, and for a port instance, it is Port. These are - * nodes in the AST. This is protected because only subclasses - * should be constructed. - * @param definition The definition in the AST for this instance. - * @param parent The reactor instance that creates this instance. - */ - protected TriggerInstance(T definition, ReactorInstance parent) { - super(definition, parent); - } - - /** - * Construct a new instance for a special builtin trigger. - * - * @param trigger The actual trigger definition. - * @param parent The reactor instance that creates this instance. - */ - static TriggerInstance builtinTrigger(BuiltinTriggerRef trigger, ReactorInstance parent) { - return new TriggerInstance<>(new BuiltinTriggerVariable(trigger), parent); - } - - ///////////////////////////////////////////// - //// Public Methods - - /** - * Return the reaction instances that are triggered or read by this trigger. - * If this port is an output, then the reaction instances - * belong to the parent of the port's parent. If the port - * is an input, then the reaction instances belong to the - * port's parent. - */ - public Set getDependentReactions() { - return dependentReactions; + /** + * Construct a new instance with the specified definition and parent. E.g., for a action instance, + * the definition is Action, and for a port instance, it is Port. These are nodes in the AST. This + * is protected because only subclasses should be constructed. + * + * @param definition The definition in the AST for this instance. + * @param parent The reactor instance that creates this instance. + */ + protected TriggerInstance(T definition, ReactorInstance parent) { + super(definition, parent); + } + + /** + * Construct a new instance for a special builtin trigger. + * + * @param trigger The actual trigger definition. + * @param parent The reactor instance that creates this instance. + */ + static TriggerInstance builtinTrigger( + BuiltinTriggerRef trigger, ReactorInstance parent) { + return new TriggerInstance<>(new BuiltinTriggerVariable(trigger), parent); + } + + ///////////////////////////////////////////// + //// Public Methods + + /** + * Return the reaction instances that are triggered or read by this trigger. If this port is an + * output, then the reaction instances belong to the parent of the port's parent. If the port is + * an input, then the reaction instances belong to the port's parent. + */ + public Set getDependentReactions() { + return dependentReactions; + } + + /** + * Return the reaction instances that may send data via this port. If this port is an input, then + * the reaction instance belongs to parent of the port's parent. If it is an output, the reaction + * instance belongs to the port's parent. + */ + public Set getDependsOnReactions() { + return dependsOnReactions; + } + + /** + * Return the name of this trigger. + * + * @return The name of this trigger. + */ + @Override + public String getName() { + return definition.getName(); + } + + /** Return true if this trigger is "shutdown". */ + public boolean isShutdown() { + return isBuiltInType(BuiltinTrigger.SHUTDOWN); + } + + /** Return true if this trigger is "startup"./ */ + public boolean isStartup() { + return isBuiltInType(BuiltinTrigger.STARTUP); + } + + /** Return true if this trigger is "startup"./ */ + public boolean isReset() { + return isBuiltInType(BuiltinTrigger.RESET); + } + + ///////////////////////////////////////////// + //// Private Methods + + private boolean isBuiltInType(BuiltinTrigger type) { + return this.definition instanceof BuiltinTriggerVariable + && ((BuiltinTriggerRef) ((BuiltinTriggerVariable) this.definition).definition) + .getType() + .equals(type); + } + + ///////////////////////////////////////////// + //// Protected Fields + + /** + * Reaction instances that are triggered or read by this trigger. If this port is an output, then + * the reaction instances belong to the parent of the port's parent. If the port is an input, then + * the reaction instances belong to the port's parent. + */ + Set dependentReactions = new LinkedHashSet<>(); + + /** + * Reaction instances that may send data via this port. If this port is an input, then the + * reaction instance belongs to parent of the port's parent. If it is an output, the reaction + * instance belongs to the port's parent. + */ + Set dependsOnReactions = new LinkedHashSet<>(); + + ///////////////////////////////////////////// + //// Special class for builtin triggers + + /** This class allows to have BuiltinTriggers represented by a Variable type. */ + public static class BuiltinTriggerVariable extends VariableImpl { + + /** The builtin trigger type represented by this variable. */ + public final BuiltinTrigger type; + + /** The actual TriggerRef definition in the AST. */ + public final TriggerRef definition; + + public BuiltinTriggerVariable(BuiltinTriggerRef trigger) { + this.type = trigger.getType(); + this.definition = trigger; } - /** - * Return the reaction instances that may send data via this port. - * If this port is an input, then the reaction instance - * belongs to parent of the port's parent. If it is an output, - * the reaction instance belongs to the port's parent. - */ - public Set getDependsOnReactions() { - return dependsOnReactions; - } - - /** - * Return the name of this trigger. - * @return The name of this trigger. - */ @Override public String getName() { - return definition.getName(); - } - - /** - * Return true if this trigger is "shutdown". - */ - public boolean isShutdown() { - return isBuiltInType(BuiltinTrigger.SHUTDOWN); - } - - /** - * Return true if this trigger is "startup"./ - */ - public boolean isStartup() { - return isBuiltInType(BuiltinTrigger.STARTUP); + return this.type.name().toLowerCase(); } - /** - * Return true if this trigger is "startup"./ - */ - public boolean isReset() { - return isBuiltInType(BuiltinTrigger.RESET); - } - - ///////////////////////////////////////////// - //// Private Methods - - private boolean isBuiltInType(BuiltinTrigger type) { - return this.definition instanceof BuiltinTriggerVariable - && ((BuiltinTriggerRef) ((BuiltinTriggerVariable) this.definition).definition).getType().equals(type); - } - - ///////////////////////////////////////////// - //// Protected Fields - - - /** - * Reaction instances that are triggered or read by this trigger. - * If this port is an output, then the reaction instances - * belong to the parent of the port's parent. If the port - * is an input, then the reaction instances belong to the - * port's parent. - */ - Set dependentReactions = new LinkedHashSet<>(); - - /** - * Reaction instances that may send data via this port. - * If this port is an input, then the reaction instance - * belongs to parent of the port's parent. If it is an output, - * the reaction instance belongs to the port's parent. - */ - Set dependsOnReactions = new LinkedHashSet<>(); - - ///////////////////////////////////////////// - //// Special class for builtin triggers - - /** - * This class allows to have BuiltinTriggers represented by a Variable type. - */ - static public class BuiltinTriggerVariable extends VariableImpl { - - /** The builtin trigger type represented by this variable. */ - public final BuiltinTrigger type; - - /** The actual TriggerRef definition in the AST. */ - public final TriggerRef definition; - - public BuiltinTriggerVariable(BuiltinTriggerRef trigger) { - this.type = trigger.getType(); - this.definition = trigger; - } - - @Override - public String getName() { - return this.type.name().toLowerCase(); - } - - @Override - public void setName(String newName) { - throw new UnsupportedOperationException( - this.getClass().getName() + " has an immutable name."); - } + @Override + public void setName(String newName) { + throw new UnsupportedOperationException( + this.getClass().getName() + " has an immutable name."); } + } } diff --git a/org.lflang/src/org/lflang/generator/UnsupportedGeneratorFeatureException.java b/org.lflang/src/org/lflang/generator/UnsupportedGeneratorFeatureException.java index 59fe20386c..c1519a161a 100644 --- a/org.lflang/src/org/lflang/generator/UnsupportedGeneratorFeatureException.java +++ b/org.lflang/src/org/lflang/generator/UnsupportedGeneratorFeatureException.java @@ -26,17 +26,14 @@ import org.eclipse.emf.ecore.EObject; -/** - * Signals that the code generator does not support a particular - * feature of the source language. - */ +/** Signals that the code generator does not support a particular feature of the source language. */ public class UnsupportedGeneratorFeatureException extends GenerationException { - public UnsupportedGeneratorFeatureException(String feature) { - super("Unsupported generator feature: " + feature); - } + public UnsupportedGeneratorFeatureException(String feature) { + super("Unsupported generator feature: " + feature); + } - public UnsupportedGeneratorFeatureException(EObject location, String feature) { - super(location, "Unsupported generator feature: " + feature); - } + public UnsupportedGeneratorFeatureException(EObject location, String feature) { + super(location, "Unsupported generator feature: " + feature); + } } diff --git a/org.lflang/src/org/lflang/generator/ValidationStrategy.java b/org.lflang/src/org/lflang/generator/ValidationStrategy.java index 7adff29527..674634ef7f 100644 --- a/org.lflang/src/org/lflang/generator/ValidationStrategy.java +++ b/org.lflang/src/org/lflang/generator/ValidationStrategy.java @@ -1,7 +1,6 @@ package org.lflang.generator; import java.nio.file.Path; - import org.lflang.util.LFCommand; /** @@ -11,36 +10,38 @@ */ public interface ValidationStrategy { - /** - * Return the command that produces validation output in association - * with {@code generatedFile}, or {@code null} if this strategy has no - * command that will successfully produce validation output. - */ - LFCommand getCommand(Path generatedFile); - - /** - * Return a strategy for parsing the stderr of the validation command. - * @return A strategy for parsing the stderr of the validation command. - */ - DiagnosticReporting.Strategy getErrorReportingStrategy(); - - /** - * Return a strategy for parsing the stdout of the validation command. - * @return A strategy for parsing the stdout of the validation command. - */ - DiagnosticReporting.Strategy getOutputReportingStrategy(); - - /** - * Return whether this strategy validates all generated files, as - * opposed to just the given one. - * @return whether this strategy validates all generated files - */ - boolean isFullBatch(); - - /** - * Return the priority of this. Strategies with higher - * priorities are more likely to be used. - * @return The priority of this. - */ - int getPriority(); + /** + * Return the command that produces validation output in association with {@code generatedFile}, + * or {@code null} if this strategy has no command that will successfully produce validation + * output. + */ + LFCommand getCommand(Path generatedFile); + + /** + * Return a strategy for parsing the stderr of the validation command. + * + * @return A strategy for parsing the stderr of the validation command. + */ + DiagnosticReporting.Strategy getErrorReportingStrategy(); + + /** + * Return a strategy for parsing the stdout of the validation command. + * + * @return A strategy for parsing the stdout of the validation command. + */ + DiagnosticReporting.Strategy getOutputReportingStrategy(); + + /** + * Return whether this strategy validates all generated files, as opposed to just the given one. + * + * @return whether this strategy validates all generated files + */ + boolean isFullBatch(); + + /** + * Return the priority of this. Strategies with higher priorities are more likely to be used. + * + * @return The priority of this. + */ + int getPriority(); } diff --git a/org.lflang/src/org/lflang/generator/Validator.java b/org.lflang/src/org/lflang/generator/Validator.java index 7a9b85c453..f9ae61f854 100644 --- a/org.lflang/src/org/lflang/generator/Validator.java +++ b/org.lflang/src/org/lflang/generator/Validator.java @@ -1,9 +1,6 @@ package org.lflang.generator; -import org.eclipse.xtext.util.CancelIndicator; - -import org.lflang.ErrorReporter; -import org.lflang.util.LFCommand; +import com.google.common.collect.ImmutableMap; import java.nio.file.Path; import java.util.ArrayList; import java.util.Collection; @@ -17,8 +14,9 @@ import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.stream.Collectors; - -import com.google.common.collect.ImmutableMap; +import org.eclipse.xtext.util.CancelIndicator; +import org.lflang.ErrorReporter; +import org.lflang.util.LFCommand; /** * Validate generated code. @@ -27,159 +25,180 @@ */ public abstract class Validator { - /** - * Files older than {@code FILE_AGE_THRESHOLD_MILLIS} may be skipped in validation on the - * grounds that they probably have not been updated since the last validator pass. - */ - // This will cause silent validation failures if it takes too long to write all generated code to the file system. - private static final long FILE_AGE_THRESHOLD_MILLIS = 10000; - - protected static class Pair { - public final S first; - public final T second; - public Pair(S first, T second) { - this.first = first; - this.second = second; - } - } - - protected final ErrorReporter errorReporter; - protected final ImmutableMap codeMaps; - - /** - * Initialize a {@code Validator} that reports errors to {@code errorReporter} and adjusts - * document positions using {@code codeMaps}. - */ - protected Validator(ErrorReporter errorReporter, Map codeMaps) { - this.errorReporter = errorReporter; - this.codeMaps = ImmutableMap.copyOf(codeMaps); + /** + * Files older than {@code FILE_AGE_THRESHOLD_MILLIS} may be skipped in validation on the grounds + * that they probably have not been updated since the last validator pass. + */ + // This will cause silent validation failures if it takes too long to write all generated code to + // the file system. + private static final long FILE_AGE_THRESHOLD_MILLIS = 10000; + + protected static class Pair { + public final S first; + public final T second; + + public Pair(S first, T second) { + this.first = first; + this.second = second; } - - /** - * Validate this Validator's group of generated files. - * @param context The context of the current build. - */ - public final void doValidate(LFGeneratorContext context) throws ExecutionException, InterruptedException { - if (!validationEnabled(context)) return; - final List>> tasks = getValidationStrategies().stream().map( - it -> (Callable>) () -> { - it.second.run(context.getCancelIndicator()); - return it; - } - ).collect(Collectors.toList()); - for (Future> f : getFutures(tasks)) { - f.get().first.getErrorReportingStrategy().report(f.get().second.getErrors().toString(), errorReporter, codeMaps); - f.get().first.getOutputReportingStrategy().report(f.get().second.getOutput().toString(), errorReporter, codeMaps); - } - } - - /** - * Return whether generated code validation is enabled for this build. - * @param context The context of the current build. - */ - private boolean validationEnabled(LFGeneratorContext context) { - return context.getArgs().containsKey("lint") || validationEnabledByDefault(context); + } + + protected final ErrorReporter errorReporter; + protected final ImmutableMap codeMaps; + + /** + * Initialize a {@code Validator} that reports errors to {@code errorReporter} and adjusts + * document positions using {@code codeMaps}. + */ + protected Validator(ErrorReporter errorReporter, Map codeMaps) { + this.errorReporter = errorReporter; + this.codeMaps = ImmutableMap.copyOf(codeMaps); + } + + /** + * Validate this Validator's group of generated files. + * + * @param context The context of the current build. + */ + public final void doValidate(LFGeneratorContext context) + throws ExecutionException, InterruptedException { + if (!validationEnabled(context)) return; + final List>> tasks = + getValidationStrategies().stream() + .map( + it -> + (Callable>) + () -> { + it.second.run(context.getCancelIndicator()); + return it; + }) + .collect(Collectors.toList()); + for (Future> f : getFutures(tasks)) { + f.get() + .first + .getErrorReportingStrategy() + .report(f.get().second.getErrors().toString(), errorReporter, codeMaps); + f.get() + .first + .getOutputReportingStrategy() + .report(f.get().second.getOutput().toString(), errorReporter, codeMaps); } - - /** - * Return whether validation of generated code is enabled by default. - * @param context The context of the current build. - * @return Whether validation of generated code is enabled by default. - */ - protected boolean validationEnabledByDefault(LFGeneratorContext context) { - return context.getMode() != LFGeneratorContext.Mode.STANDALONE; - } - - /** - * Invoke all the given tasks. - * @param tasks Any set of tasks. - * @param The return type of the tasks. - * @return Futures corresponding to each task, or an empty list upon failure. - * @throws InterruptedException If interrupted while waiting. - */ - private static List> getFutures(List> tasks) throws InterruptedException { - List> futures = List.of(); - switch (tasks.size()) { - case 0: - break; - case 1: - try { - futures = List.of(CompletableFuture.completedFuture(tasks.get(0).call())); - } catch (Exception e) { - System.err.println(e.getMessage()); // This should never happen - } - break; - default: - ExecutorService service = Executors.newFixedThreadPool( - Math.min(Runtime.getRuntime().availableProcessors(), tasks.size()) - ); - futures = service.invokeAll(tasks); - service.shutdown(); + } + + /** + * Return whether generated code validation is enabled for this build. + * + * @param context The context of the current build. + */ + private boolean validationEnabled(LFGeneratorContext context) { + return context.getArgs().containsKey("lint") || validationEnabledByDefault(context); + } + + /** + * Return whether validation of generated code is enabled by default. + * + * @param context The context of the current build. + * @return Whether validation of generated code is enabled by default. + */ + protected boolean validationEnabledByDefault(LFGeneratorContext context) { + return context.getMode() != LFGeneratorContext.Mode.STANDALONE; + } + + /** + * Invoke all the given tasks. + * + * @param tasks Any set of tasks. + * @param The return type of the tasks. + * @return Futures corresponding to each task, or an empty list upon failure. + * @throws InterruptedException If interrupted while waiting. + */ + private static List> getFutures(List> tasks) + throws InterruptedException { + List> futures = List.of(); + switch (tasks.size()) { + case 0: + break; + case 1: + try { + futures = List.of(CompletableFuture.completedFuture(tasks.get(0).call())); + } catch (Exception e) { + System.err.println(e.getMessage()); // This should never happen } - return futures; + break; + default: + ExecutorService service = + Executors.newFixedThreadPool( + Math.min(Runtime.getRuntime().availableProcessors(), tasks.size())); + futures = service.invokeAll(tasks); + service.shutdown(); } - - /** - * Run the given command, report any messages produced using the reporting strategies - * given by {@code getBuildReportingStrategies}, and return its return code. - */ - public final int run(LFCommand command, CancelIndicator cancelIndicator) { - final int returnCode = command.run(cancelIndicator); - getBuildReportingStrategies().first.report(command.getErrors().toString(), errorReporter, codeMaps); - getBuildReportingStrategies().second.report(command.getOutput().toString(), errorReporter, codeMaps); - return returnCode; + return futures; + } + + /** + * Run the given command, report any messages produced using the reporting strategies given by + * {@code getBuildReportingStrategies}, and return its return code. + */ + public final int run(LFCommand command, CancelIndicator cancelIndicator) { + final int returnCode = command.run(cancelIndicator); + getBuildReportingStrategies() + .first + .report(command.getErrors().toString(), errorReporter, codeMaps); + getBuildReportingStrategies() + .second + .report(command.getOutput().toString(), errorReporter, codeMaps); + return returnCode; + } + + /** + * Return the validation strategies and validation commands corresponding to each generated file. + * + * @return the validation strategies and validation commands corresponding to each generated file + */ + private List> getValidationStrategies() { + final List> commands = new ArrayList<>(); + long mostRecentDateModified = + codeMaps.keySet().stream().map(it -> it.toFile().lastModified()).reduce(0L, Math::max); + for (Path generatedFile : codeMaps.keySet()) { + if (generatedFile.toFile().lastModified() + > mostRecentDateModified - FILE_AGE_THRESHOLD_MILLIS) { + final Pair p = getValidationStrategy(generatedFile); + if (p.first == null || p.second == null) continue; + commands.add(p); + if (p.first.isFullBatch()) break; + } } - - /** - * Return the validation strategies and validation - * commands corresponding to each generated file. - * @return the validation strategies and validation - * commands corresponding to each generated file - */ - private List> getValidationStrategies() { - final List> commands = new ArrayList<>(); - long mostRecentDateModified = codeMaps.keySet().stream() - .map(it -> it.toFile().lastModified()).reduce(0L, Math::max); - for (Path generatedFile : codeMaps.keySet()) { - if (generatedFile.toFile().lastModified() > mostRecentDateModified - FILE_AGE_THRESHOLD_MILLIS) { - final Pair p = getValidationStrategy(generatedFile); - if (p.first == null || p.second == null) continue; - commands.add(p); - if (p.first.isFullBatch()) break; - } - } - return commands; + return commands; + } + + /** + * Return the validation strategy and command corresponding to the given file if such a strategy + * and command are available. + * + * @return the validation strategy and command corresponding to the given file if such a strategy + * and command are available + */ + private Pair getValidationStrategy(Path generatedFile) { + List sorted = + getPossibleStrategies().stream() + .sorted(Comparator.comparingInt(vs -> -vs.getPriority())) + .toList(); + for (ValidationStrategy strategy : sorted) { + LFCommand validateCommand = strategy.getCommand(generatedFile); + if (validateCommand != null) { + return new Pair<>(strategy, validateCommand); + } } - - /** - * Return the validation strategy and command - * corresponding to the given file if such a strategy - * and command are available. - * @return the validation strategy and command - * corresponding to the given file if such a strategy - * and command are available - */ - private Pair getValidationStrategy(Path generatedFile) { - List sorted = getPossibleStrategies().stream() - .sorted(Comparator.comparingInt(vs -> -vs.getPriority())).toList(); - for (ValidationStrategy strategy : sorted) { - LFCommand validateCommand = strategy.getCommand(generatedFile); - if (validateCommand != null) { - return new Pair<>(strategy, validateCommand); - } - } - return new Pair<>(null, null); - } - - /** - * List all validation strategies that exist for the implementor - * without filtering by platform or availability. - */ - protected abstract Collection getPossibleStrategies(); - - /** - * Return the appropriate output and error reporting - * strategies for the main build process. - */ - protected abstract Pair getBuildReportingStrategies(); + return new Pair<>(null, null); + } + + /** + * List all validation strategies that exist for the implementor without filtering by platform or + * availability. + */ + protected abstract Collection getPossibleStrategies(); + + /** Return the appropriate output and error reporting strategies for the main build process. */ + protected abstract Pair + getBuildReportingStrategies(); } diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/src/org/lflang/generator/WatchdogInstance.java index 90823102d6..ac51f389cb 100644 --- a/org.lflang/src/org/lflang/generator/WatchdogInstance.java +++ b/org.lflang/src/org/lflang/generator/WatchdogInstance.java @@ -2,8 +2,8 @@ * @file * @author Benjamin Asch * @author Edward A. Lee - * @copyright (c) 2023, The University of California at Berkeley - * License in BSD 2-clause + * @copyright (c) 2023, The University of California at Berkeley License in BSD 2-clause * @brief Instance of a watchdog */ package org.lflang.generator; diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index 5f81de89aa..1a99c1b3e2 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -1,15 +1,16 @@ package org.lflang.generator.c; -import java.util.List; +import static org.lflang.generator.c.CGenerator.variableStructType; + import java.util.ArrayList; -import org.lflang.ast.ASTUtils; +import java.util.List; import org.lflang.Target; +import org.lflang.ast.ASTUtils; import org.lflang.generator.ActionInstance; import org.lflang.generator.CodeBuilder; import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; -import static org.lflang.generator.c.CGenerator.variableStructType; /** * Generates code for actions (logical or physical) for the C and CCpp target. * @@ -23,153 +24,156 @@ * @author Hou Seng Wong */ public class CActionGenerator { - /** - * For each action of the specified reactor instance, generate initialization code - * for the offset and period fields. - * @param instance The reactor. - */ - public static String generateInitializers( - ReactorInstance instance - ) { - List code = new ArrayList<>(); - for (ActionInstance action : instance.actions) { - if (!action.isShutdown()) { - var triggerStructName = CUtil.reactorRef(action.getParent()) + "->_lf__" + action.getName(); - var minDelay = action.getMinDelay(); - var minSpacing = action.getMinSpacing(); - var offsetInitializer = triggerStructName+".offset = " + CTypes.getInstance().getTargetTimeExpr(minDelay) - + ";"; - var periodInitializer = triggerStructName+".period = " + (minSpacing != null ? - CTypes.getInstance().getTargetTimeExpr(minSpacing) : - CGenerator.UNDEFINED_MIN_SPACING) + ";"; - code.addAll(List.of( - "// Initializing action "+action.getFullName(), - offsetInitializer, - periodInitializer - )); + /** + * For each action of the specified reactor instance, generate initialization code for the offset + * and period fields. + * + * @param instance The reactor. + */ + public static String generateInitializers(ReactorInstance instance) { + List code = new ArrayList<>(); + for (ActionInstance action : instance.actions) { + if (!action.isShutdown()) { + var triggerStructName = CUtil.reactorRef(action.getParent()) + "->_lf__" + action.getName(); + var minDelay = action.getMinDelay(); + var minSpacing = action.getMinSpacing(); + var offsetInitializer = + triggerStructName + + ".offset = " + + CTypes.getInstance().getTargetTimeExpr(minDelay) + + ";"; + var periodInitializer = + triggerStructName + + ".period = " + + (minSpacing != null + ? CTypes.getInstance().getTargetTimeExpr(minSpacing) + : CGenerator.UNDEFINED_MIN_SPACING) + + ";"; + code.addAll( + List.of( + "// Initializing action " + action.getFullName(), + offsetInitializer, + periodInitializer)); - var mode = action.getMode(false); - if (mode != null) { - var modeParent = mode.getParent(); - var modeRef = "&"+CUtil.reactorRef(modeParent)+"->_lf__modes["+modeParent.modes.indexOf(mode)+"];"; - code.add(triggerStructName+".mode = "+modeRef+";"); - } else { - code.add(triggerStructName+".mode = NULL;"); - } - } + var mode = action.getMode(false); + if (mode != null) { + var modeParent = mode.getParent(); + var modeRef = + "&" + + CUtil.reactorRef(modeParent) + + "->_lf__modes[" + + modeParent.modes.indexOf(mode) + + "];"; + code.add(triggerStructName + ".mode = " + modeRef + ";"); + } else { + code.add(triggerStructName + ".mode = NULL;"); } - return String.join("\n", code); + } } + return String.join("\n", code); + } - /** - * Create a template token initialized to the payload size. - * This token is marked to not be freed so that the trigger_t struct - * always has a template token. - * At the start of each time step, we need to initialize the is_present field - * of each action's trigger object to false and free a previously - * allocated token if appropriate. This code sets up the table that does that. - * - * @param selfStruct The variable name of the self struct - * @param actionName The action name - * @param payloadSize The code that returns the size of the action's payload in C. - */ - public static String generateTokenInitializer( - String selfStruct, - String actionName, - String payloadSize - ) { - return String.join("\n", - "_lf_initialize_template((token_template_t*)", - " &("+selfStruct+"->_lf__"+actionName+"),", - payloadSize+");", - selfStruct+"->_lf__"+actionName+".status = absent;" - ); - } + /** + * Create a template token initialized to the payload size. This token is marked to not be freed + * so that the trigger_t struct always has a template token. At the start of each time step, we + * need to initialize the is_present field of each action's trigger object to false and free a + * previously allocated token if appropriate. This code sets up the table that does that. + * + * @param selfStruct The variable name of the self struct + * @param actionName The action name + * @param payloadSize The code that returns the size of the action's payload in C. + */ + public static String generateTokenInitializer( + String selfStruct, String actionName, String payloadSize) { + return String.join( + "\n", + "_lf_initialize_template((token_template_t*)", + " &(" + selfStruct + "->_lf__" + actionName + "),", + payloadSize + ");", + selfStruct + "->_lf__" + actionName + ".status = absent;"); + } - /** - * Generate the declarations of actions in the self struct - * - * @param body The content of the self struct - * @param constructorCode The constructor code of the reactor - */ - public static void generateDeclarations( - TypeParameterizedReactor tpr, - CodeBuilder body, - CodeBuilder constructorCode - ) { - for (Action action : ASTUtils.allActions(tpr.reactor())) { - var actionName = action.getName(); - body.pr(action, CGenerator.variableStructType(action, tpr, false)+" _lf_"+actionName+";"); - // Initialize the trigger pointer in the action. - constructorCode.pr(action, "self->_lf_"+actionName+".trigger = &self->_lf__"+actionName+";"); - } + /** + * Generate the declarations of actions in the self struct + * + * @param body The content of the self struct + * @param constructorCode The constructor code of the reactor + */ + public static void generateDeclarations( + TypeParameterizedReactor tpr, CodeBuilder body, CodeBuilder constructorCode) { + for (Action action : ASTUtils.allActions(tpr.reactor())) { + var actionName = action.getName(); + body.pr( + action, CGenerator.variableStructType(action, tpr, false) + " _lf_" + actionName + ";"); + // Initialize the trigger pointer in the action. + constructorCode.pr( + action, "self->_lf_" + actionName + ".trigger = &self->_lf__" + actionName + ";"); } + } - /** - * Generate the struct type definitions for the action of the - * reactor - * - * @param action The action to generate the struct for - * @param target The target of the code generation (C, CCpp or Python) - * @param types The helper object for types related stuff - * @param federatedExtension The code needed to support federated execution - * @return The auxiliary struct for the port as a string - */ - public static String generateAuxiliaryStruct( - TypeParameterizedReactor tpr, - Action action, - Target target, - CTypes types, - CodeBuilder federatedExtension, - boolean userFacing - ) { - var code = new CodeBuilder(); - code.pr("typedef struct {"); - code.indent(); - // NOTE: The following fields are required to be the first ones so that - // pointer to this struct can be cast to a (lf_action_base_t*) or to - // (token_template_t*) to access these fields for any port. - // IMPORTANT: These must match exactly the fields defined in port.h!! - code.pr(String.join("\n", - "token_type_t type;", // From token_template_t - "lf_token_t* token;", // From token_template_t - "size_t length;", // From token_template_t - "bool is_present;", // From lf_action_base_t - "bool has_value;", // From lf_action_base_t - "trigger_t* trigger;" // From lf_action_base_t - )); - code.pr(valueDeclaration(tpr, action, target, types)); - code.pr(federatedExtension.toString()); - code.unindent(); - code.pr("} " + variableStructType(action, tpr, userFacing) + ";"); - return code.toString(); - } + /** + * Generate the struct type definitions for the action of the reactor + * + * @param action The action to generate the struct for + * @param target The target of the code generation (C, CCpp or Python) + * @param types The helper object for types related stuff + * @param federatedExtension The code needed to support federated execution + * @return The auxiliary struct for the port as a string + */ + public static String generateAuxiliaryStruct( + TypeParameterizedReactor tpr, + Action action, + Target target, + CTypes types, + CodeBuilder federatedExtension, + boolean userFacing) { + var code = new CodeBuilder(); + code.pr("typedef struct {"); + code.indent(); + // NOTE: The following fields are required to be the first ones so that + // pointer to this struct can be cast to a (lf_action_base_t*) or to + // (token_template_t*) to access these fields for any port. + // IMPORTANT: These must match exactly the fields defined in port.h!! + code.pr( + String.join( + "\n", + "token_type_t type;", // From token_template_t + "lf_token_t* token;", // From token_template_t + "size_t length;", // From token_template_t + "bool is_present;", // From lf_action_base_t + "bool has_value;", // From lf_action_base_t + "trigger_t* trigger;" // From lf_action_base_t + )); + code.pr(valueDeclaration(tpr, action, target, types)); + code.pr(federatedExtension.toString()); + code.unindent(); + code.pr("} " + variableStructType(action, tpr, userFacing) + ";"); + return code.toString(); + } - /** - * For the specified action, return a declaration for action struct to - * contain the value of the action. An action of - * type int[10], for example, will result in this: - * 

    
-     *     int* value;
-     *
    - * This will return an empty string for an action with no type. - * @param tpr {@link TypeParameterizedReactor} - * @param action The action. - * @return A string providing the value field of the action struct. - */ - private static String valueDeclaration( - TypeParameterizedReactor tpr, - Action action, - Target target, - CTypes types - ) { - if (target == Target.Python) { - return "PyObject* value;"; - } - // Do not convert to lf_token_t* using lfTypeToTokenType because there - // will be a separate field pointing to the token. - return action.getType() == null && target.requiresTypes ? - "" : - types.getTargetType(tpr.resolveType(action.getType())) + " value;"; + /** + * For the specified action, return a declaration for action struct to contain the value of the + * action. An action of type int[10], for example, will result in this: + * + * 
    
+   *     int* value;
+   *
    + * + * This will return an empty string for an action with no type. + * + * @param tpr {@link TypeParameterizedReactor} + * @param action The action. + * @return A string providing the value field of the action struct. + */ + private static String valueDeclaration( + TypeParameterizedReactor tpr, Action action, Target target, CTypes types) { + if (target == Target.Python) { + return "PyObject* value;"; } + // Do not convert to lf_token_t* using lfTypeToTokenType because there + // will be a separate field pointing to the token. + return action.getType() == null && target.requiresTypes + ? "" + : types.getTargetType(tpr.resolveType(action.getType())) + " value;"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java index d158f7491b..860c85a75d 100644 --- a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2019-2021, The University of California at Berkeley. - + * * 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. - + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -31,7 +31,6 @@ import java.util.List; import java.util.Objects; import java.util.stream.Stream; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.TargetConfig; @@ -42,357 +41,364 @@ /** * A helper class that generates a CMakefile that can be used to compile the generated C code. * - * Adapted from @see org.lflang.generator.CppCmakeGenerator.kt + *

    Adapted from @see org.lflang.generator.CppCmakeGenerator.kt * * @author Soroush Bateni * @author Peter Donovan */ public class CCmakeGenerator { - private static final String DEFAULT_INSTALL_CODE = """ + private static final String DEFAULT_INSTALL_CODE = + """ install( TARGETS ${LF_MAIN_TARGET} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ) """; - public static final String MIN_CMAKE_VERSION = "3.19"; - - private final FileConfig fileConfig; - private final List additionalSources; - private final SetUpMainTarget setUpMainTarget; - private final String installCode; - - public CCmakeGenerator( - FileConfig fileConfig, - List additionalSources - ) { - this.fileConfig = fileConfig; - this.additionalSources = additionalSources; - this.setUpMainTarget = CCmakeGenerator::setUpMainTarget; - this.installCode = DEFAULT_INSTALL_CODE; + public static final String MIN_CMAKE_VERSION = "3.19"; + + private final FileConfig fileConfig; + private final List additionalSources; + private final SetUpMainTarget setUpMainTarget; + private final String installCode; + + public CCmakeGenerator(FileConfig fileConfig, List additionalSources) { + this.fileConfig = fileConfig; + this.additionalSources = additionalSources; + this.setUpMainTarget = CCmakeGenerator::setUpMainTarget; + this.installCode = DEFAULT_INSTALL_CODE; + } + + public CCmakeGenerator( + FileConfig fileConfig, + List additionalSources, + SetUpMainTarget setUpMainTarget, + String installCode) { + this.fileConfig = fileConfig; + this.additionalSources = additionalSources; + this.setUpMainTarget = setUpMainTarget; + this.installCode = installCode; + } + + /** + * Generate the contents of a CMakeLists.txt that builds the provided LF C 'sources'. Any error + * will be reported in the 'errorReporter'. + * + * @param sources A list of .c files to build. + * @param executableName The name of the output executable. + * @param errorReporter Used to report errors. + * @param CppMode Indicate if the compilation should happen in C++ mode + * @param hasMain Indicate if the .lf file has a main reactor or not. If not, a library target + * will be created instead of an executable. + * @param cMakeExtras CMake-specific code that should be appended to the CMakeLists.txt. + * @param targetConfig The TargetConfig instance to use. + * @return The content of the CMakeLists.txt. + */ + CodeBuilder generateCMakeCode( + List sources, + String executableName, + ErrorReporter errorReporter, + boolean CppMode, + boolean hasMain, + String cMakeExtras, + TargetConfig targetConfig) { + CodeBuilder cMakeCode = new CodeBuilder(); + + List additionalSources = new ArrayList<>(); + for (String file : targetConfig.compileAdditionalSources) { + var relativePath = + fileConfig + .getSrcGenPath() + .relativize(fileConfig.getSrcGenPath().resolve(Paths.get(file))); + additionalSources.add(FileUtil.toUnixString(relativePath)); } - - public CCmakeGenerator( - FileConfig fileConfig, - List additionalSources, - SetUpMainTarget setUpMainTarget, - String installCode - ) { - this.fileConfig = fileConfig; - this.additionalSources = additionalSources; - this.setUpMainTarget = setUpMainTarget; - this.installCode = installCode; + additionalSources.addAll(this.additionalSources); + cMakeCode.newLine(); + + cMakeCode.pr("cmake_minimum_required(VERSION " + MIN_CMAKE_VERSION + ")"); + + if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + cMakeCode.pr("# Set default configuration file. To add custom configurations,"); + cMakeCode.pr("# pass -- -DOVERLAY_CONFIG=my_config.prj to either cmake or west"); + cMakeCode.pr("set(CONF_FILE prj_lf.conf)"); + if (targetConfig.platformOptions.board != null) { + cMakeCode.pr("# Selecting board specified in target property"); + cMakeCode.pr("set(BOARD " + targetConfig.platformOptions.board + ")"); + } else { + cMakeCode.pr("# Selecting default board"); + cMakeCode.pr("set(BOARD qemu_cortex_m3)"); + } + cMakeCode.pr("# We require Zephyr version 3.2.0"); + cMakeCode.pr("find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE} 3.2.0)"); + cMakeCode.newLine(); } - /** - * Generate the contents of a CMakeLists.txt that builds the provided LF C 'sources'. Any error will be - * reported in the 'errorReporter'. - * - * @param sources A list of .c files to build. - * @param executableName The name of the output executable. - * @param errorReporter Used to report errors. - * @param CppMode Indicate if the compilation should happen in C++ mode - * @param hasMain Indicate if the .lf file has a main reactor or not. If not, - * a library target will be created instead of an executable. - * @param cMakeExtras CMake-specific code that should be appended to the CMakeLists.txt. - * @param targetConfig The TargetConfig instance to use. - * @return The content of the CMakeLists.txt. - */ - CodeBuilder generateCMakeCode( - List sources, - String executableName, - ErrorReporter errorReporter, - boolean CppMode, - boolean hasMain, - String cMakeExtras, - TargetConfig targetConfig - ) { - CodeBuilder cMakeCode = new CodeBuilder(); - - List additionalSources = new ArrayList<>(); - for (String file: targetConfig.compileAdditionalSources) { - var relativePath = fileConfig.getSrcGenPath().relativize( - fileConfig.getSrcGenPath().resolve(Paths.get(file))); - additionalSources.add(FileUtil.toUnixString(relativePath)); - } - additionalSources.addAll(this.additionalSources); - cMakeCode.newLine(); - - cMakeCode.pr("cmake_minimum_required(VERSION " + MIN_CMAKE_VERSION + ")"); - - if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - cMakeCode.pr("# Set default configuration file. To add custom configurations,"); - cMakeCode.pr("# pass -- -DOVERLAY_CONFIG=my_config.prj to either cmake or west"); - cMakeCode.pr("set(CONF_FILE prj_lf.conf)"); - if (targetConfig.platformOptions.board != null) { - cMakeCode.pr("# Selecting board specified in target property"); - cMakeCode.pr("set(BOARD "+targetConfig.platformOptions.board+")"); - } else { - cMakeCode.pr("# Selecting default board"); - cMakeCode.pr("set(BOARD qemu_cortex_m3)"); - } - cMakeCode.pr("# We require Zephyr version 3.2.0"); - cMakeCode.pr("find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE} 3.2.0)"); - cMakeCode.newLine(); - } - - cMakeCode.pr("project("+executableName+" LANGUAGES C)"); - cMakeCode.newLine(); - - // The Test build type is the Debug type plus coverage generation - cMakeCode.pr("if(CMAKE_BUILD_TYPE STREQUAL \"Test\")"); - cMakeCode.pr(" set(CMAKE_BUILD_TYPE \"Debug\")"); - cMakeCode.pr(" if(CMAKE_C_COMPILER_ID STREQUAL \"GNU\")"); - cMakeCode.pr(" find_program(LCOV_BIN lcov)"); - cMakeCode.pr(" if(LCOV_BIN MATCHES \"lcov$\")"); - cMakeCode.pr(" set(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} --coverage -fprofile-arcs -ftest-coverage\")"); - cMakeCode.pr(" else()"); - cMakeCode.pr(" message(\"Not producing code coverage information since lcov was not found\")"); - cMakeCode.pr(" endif()"); - cMakeCode.pr(" else()"); - cMakeCode.pr(" message(\"Not producing code coverage information since the selected compiler is no gcc\")"); - cMakeCode.pr(" endif()"); - cMakeCode.pr("endif()"); - - cMakeCode.pr("# Require C11"); - cMakeCode.pr("set(CMAKE_C_STANDARD 11)"); - cMakeCode.pr("set(CMAKE_C_STANDARD_REQUIRED ON)"); - cMakeCode.newLine(); - - cMakeCode.pr("# Require C++17"); - cMakeCode.pr("set(CMAKE_CXX_STANDARD 17)"); - cMakeCode.pr("set(CMAKE_CXX_STANDARD_REQUIRED ON)"); - cMakeCode.newLine(); - if (!targetConfig.cmakeIncludes.isEmpty()) { - // The user might be using the non-keyword form of - // target_link_libraries. Ideally we would detect whether they are - // doing that, but it is easier to just always have a deprecation - // warning. - cMakeCode.pr(""" + cMakeCode.pr("project(" + executableName + " LANGUAGES C)"); + cMakeCode.newLine(); + + // The Test build type is the Debug type plus coverage generation + cMakeCode.pr("if(CMAKE_BUILD_TYPE STREQUAL \"Test\")"); + cMakeCode.pr(" set(CMAKE_BUILD_TYPE \"Debug\")"); + cMakeCode.pr(" if(CMAKE_C_COMPILER_ID STREQUAL \"GNU\")"); + cMakeCode.pr(" find_program(LCOV_BIN lcov)"); + cMakeCode.pr(" if(LCOV_BIN MATCHES \"lcov$\")"); + cMakeCode.pr( + " set(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS} --coverage -fprofile-arcs -ftest-coverage\")"); + cMakeCode.pr(" else()"); + cMakeCode.pr( + " message(\"Not producing code coverage information since lcov was not found\")"); + cMakeCode.pr(" endif()"); + cMakeCode.pr(" else()"); + cMakeCode.pr( + " message(\"Not producing code coverage information since the selected compiler is no" + + " gcc\")"); + cMakeCode.pr(" endif()"); + cMakeCode.pr("endif()"); + + cMakeCode.pr("# Require C11"); + cMakeCode.pr("set(CMAKE_C_STANDARD 11)"); + cMakeCode.pr("set(CMAKE_C_STANDARD_REQUIRED ON)"); + cMakeCode.newLine(); + + cMakeCode.pr("# Require C++17"); + cMakeCode.pr("set(CMAKE_CXX_STANDARD 17)"); + cMakeCode.pr("set(CMAKE_CXX_STANDARD_REQUIRED ON)"); + cMakeCode.newLine(); + if (!targetConfig.cmakeIncludes.isEmpty()) { + // The user might be using the non-keyword form of + // target_link_libraries. Ideally we would detect whether they are + // doing that, but it is easier to just always have a deprecation + // warning. + cMakeCode.pr( + """ cmake_policy(SET CMP0023 OLD) # This causes deprecation warnings - """ - ); - } - - // Set the build type - cMakeCode.pr("set(DEFAULT_BUILD_TYPE " + targetConfig.cmakeBuildType + ")\n"); - cMakeCode.pr("if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)\n"); - cMakeCode.pr(" set(CMAKE_BUILD_TYPE ${DEFAULT_BUILD_TYPE} CACHE STRING \"Choose the type of build.\" FORCE)\n"); - cMakeCode.pr("endif()\n"); - cMakeCode.newLine(); - - cMakeCode.pr("# do not print install messages\n"); - cMakeCode.pr("set(CMAKE_INSTALL_MESSAGE NEVER)\n"); - cMakeCode.newLine(); - - if (CppMode) { - // Suppress warnings about const char*. - cMakeCode.pr("set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-write-strings\")"); - cMakeCode.newLine(); - } - - if (targetConfig.platformOptions.platform != Platform.AUTO) { - cMakeCode.pr("set(CMAKE_SYSTEM_NAME "+targetConfig.platformOptions.platform.getcMakeName()+")"); - } - cMakeCode.newLine(); - - if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - cMakeCode.pr(setUpMainTargetZephyr( - hasMain, - executableName, - Stream.concat(additionalSources.stream(), sources.stream()) - )); - } else { - cMakeCode.pr(setUpMainTarget.getCmakeCode( - hasMain, - executableName, - Stream.concat(additionalSources.stream(), sources.stream()) - )); - } - - cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE core)"); - - cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC .)"); - cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/)"); - cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/api)"); - cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core)"); - cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core/platform)"); - cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core/modal_models)"); - cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core/utils)"); - - if(targetConfig.auth) { - // If security is requested, add the auth option. - var osName = System.getProperty("os.name").toLowerCase(); - // if platform target was set, use given platform instead - if (targetConfig.platformOptions.platform != Platform.AUTO) { - osName = targetConfig.platformOptions.platform.toString(); - } - if (osName.contains("mac")) { - cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)"); - } - cMakeCode.pr("# Find OpenSSL and link to it"); - cMakeCode.pr("find_package(OpenSSL REQUIRED)"); - cMakeCode.pr("target_link_libraries( ${LF_MAIN_TARGET} PRIVATE OpenSSL::SSL)"); - cMakeCode.newLine(); - } - - if (targetConfig.threading || targetConfig.tracing != null) { - // If threaded computation is requested, add the threads option. - cMakeCode.pr("# Find threads and link to it"); - cMakeCode.pr("find_package(Threads REQUIRED)"); - cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE Threads::Threads)"); - cMakeCode.newLine(); - - // If the LF program itself is threaded or if tracing is enabled, we need to define - // NUMBER_OF_WORKERS so that platform-specific C files will contain the appropriate functions - cMakeCode.pr("# Set the number of workers to enable threading/tracing"); - cMakeCode.pr("target_compile_definitions(${LF_MAIN_TARGET} PUBLIC NUMBER_OF_WORKERS="+targetConfig.workers+")"); - cMakeCode.newLine(); - } - - // Add additional flags so runtime can distinguish between multi-threaded and single-threaded mode - if (targetConfig.threading) { - cMakeCode.pr("# Set flag to indicate a multi-threaded runtime"); - cMakeCode.pr("target_compile_definitions( ${LF_MAIN_TARGET} PUBLIC LF_THREADED=1)"); - } else { - cMakeCode.pr("# Set flag to indicate a single-threaded runtime"); - cMakeCode.pr("target_compile_definitions( ${LF_MAIN_TARGET} PUBLIC LF_UNTHREADED=1)"); - } - cMakeCode.newLine(); - - - if (CppMode) cMakeCode.pr("enable_language(CXX)"); - - if (targetConfig.compiler != null && !targetConfig.compiler.isBlank()) { - if (CppMode) { - // Set the CXX compiler to what the user has requested. - cMakeCode.pr("set(CMAKE_CXX_COMPILER "+targetConfig.compiler+")"); - } else { - cMakeCode.pr("set(CMAKE_C_COMPILER "+targetConfig.compiler+")"); - } - cMakeCode.newLine(); - } - - // Set the compiler flags - // We can detect a few common libraries and use the proper target_link_libraries to find them - for (String compilerFlag : targetConfig.compilerFlags) { - switch(compilerFlag.trim()) { - case "-lm": - cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE m)"); - break; - case "-lprotobuf-c": - cMakeCode.pr("include(FindPackageHandleStandardArgs)"); - cMakeCode.pr("FIND_PATH( PROTOBUF_INCLUDE_DIR protobuf-c/protobuf-c.h)"); - cMakeCode.pr(""" + """); + } + + // Set the build type + cMakeCode.pr("set(DEFAULT_BUILD_TYPE " + targetConfig.cmakeBuildType + ")\n"); + cMakeCode.pr("if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)\n"); + cMakeCode.pr( + " set(CMAKE_BUILD_TYPE ${DEFAULT_BUILD_TYPE} CACHE STRING \"Choose the type of build.\"" + + " FORCE)\n"); + cMakeCode.pr("endif()\n"); + cMakeCode.newLine(); + + cMakeCode.pr("# do not print install messages\n"); + cMakeCode.pr("set(CMAKE_INSTALL_MESSAGE NEVER)\n"); + cMakeCode.newLine(); + + if (CppMode) { + // Suppress warnings about const char*. + cMakeCode.pr("set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-write-strings\")"); + cMakeCode.newLine(); + } + + if (targetConfig.platformOptions.platform != Platform.AUTO) { + cMakeCode.pr( + "set(CMAKE_SYSTEM_NAME " + targetConfig.platformOptions.platform.getcMakeName() + ")"); + } + cMakeCode.newLine(); + + if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + cMakeCode.pr( + setUpMainTargetZephyr( + hasMain, + executableName, + Stream.concat(additionalSources.stream(), sources.stream()))); + } else { + cMakeCode.pr( + setUpMainTarget.getCmakeCode( + hasMain, + executableName, + Stream.concat(additionalSources.stream(), sources.stream()))); + } + + cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE core)"); + + cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC .)"); + cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/)"); + cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/api)"); + cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core)"); + cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core/platform)"); + cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core/modal_models)"); + cMakeCode.pr("target_include_directories(${LF_MAIN_TARGET} PUBLIC include/core/utils)"); + + if (targetConfig.auth) { + // If security is requested, add the auth option. + var osName = System.getProperty("os.name").toLowerCase(); + // if platform target was set, use given platform instead + if (targetConfig.platformOptions.platform != Platform.AUTO) { + osName = targetConfig.platformOptions.platform.toString(); + } + if (osName.contains("mac")) { + cMakeCode.pr("set(OPENSSL_ROOT_DIR /usr/local/opt/openssl)"); + } + cMakeCode.pr("# Find OpenSSL and link to it"); + cMakeCode.pr("find_package(OpenSSL REQUIRED)"); + cMakeCode.pr("target_link_libraries( ${LF_MAIN_TARGET} PRIVATE OpenSSL::SSL)"); + cMakeCode.newLine(); + } + + if (targetConfig.threading || targetConfig.tracing != null) { + // If threaded computation is requested, add the threads option. + cMakeCode.pr("# Find threads and link to it"); + cMakeCode.pr("find_package(Threads REQUIRED)"); + cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE Threads::Threads)"); + cMakeCode.newLine(); + + // If the LF program itself is threaded or if tracing is enabled, we need to define + // NUMBER_OF_WORKERS so that platform-specific C files will contain the appropriate functions + cMakeCode.pr("# Set the number of workers to enable threading/tracing"); + cMakeCode.pr( + "target_compile_definitions(${LF_MAIN_TARGET} PUBLIC NUMBER_OF_WORKERS=" + + targetConfig.workers + + ")"); + cMakeCode.newLine(); + } + + // Add additional flags so runtime can distinguish between multi-threaded and single-threaded + // mode + if (targetConfig.threading) { + cMakeCode.pr("# Set flag to indicate a multi-threaded runtime"); + cMakeCode.pr("target_compile_definitions( ${LF_MAIN_TARGET} PUBLIC LF_THREADED=1)"); + } else { + cMakeCode.pr("# Set flag to indicate a single-threaded runtime"); + cMakeCode.pr("target_compile_definitions( ${LF_MAIN_TARGET} PUBLIC LF_UNTHREADED=1)"); + } + cMakeCode.newLine(); + + if (CppMode) cMakeCode.pr("enable_language(CXX)"); + + if (targetConfig.compiler != null && !targetConfig.compiler.isBlank()) { + if (CppMode) { + // Set the CXX compiler to what the user has requested. + cMakeCode.pr("set(CMAKE_CXX_COMPILER " + targetConfig.compiler + ")"); + } else { + cMakeCode.pr("set(CMAKE_C_COMPILER " + targetConfig.compiler + ")"); + } + cMakeCode.newLine(); + } + + // Set the compiler flags + // We can detect a few common libraries and use the proper target_link_libraries to find them + for (String compilerFlag : targetConfig.compilerFlags) { + switch (compilerFlag.trim()) { + case "-lm": + cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE m)"); + break; + case "-lprotobuf-c": + cMakeCode.pr("include(FindPackageHandleStandardArgs)"); + cMakeCode.pr("FIND_PATH( PROTOBUF_INCLUDE_DIR protobuf-c/protobuf-c.h)"); + cMakeCode.pr( + """ find_library(PROTOBUF_LIBRARY\s NAMES libprotobuf-c.a libprotobuf-c.so libprotobuf-c.dylib protobuf-c.lib protobuf-c.dll )"""); - cMakeCode.pr("find_package_handle_standard_args(libprotobuf-c DEFAULT_MSG PROTOBUF_INCLUDE_DIR PROTOBUF_LIBRARY)"); - cMakeCode.pr("target_include_directories( ${LF_MAIN_TARGET} PUBLIC ${PROTOBUF_INCLUDE_DIR} )"); - cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE ${PROTOBUF_LIBRARY})"); - break; - case "-O2": - if (Objects.equals(targetConfig.compiler, "gcc") || CppMode) { - // Workaround for the pre-added -O2 option in the CGenerator. - // This flag is specific to gcc/g++ and the clang compiler - cMakeCode.pr("add_compile_options(-O2)"); - cMakeCode.pr("add_link_options(-O2)"); - break; - } - default: - errorReporter.reportWarning("Using the flags target property with cmake is dangerous.\n"+ - " Use cmake-include instead."); - cMakeCode.pr("add_compile_options( "+compilerFlag+" )"); - cMakeCode.pr("add_link_options( "+compilerFlag+")"); - } - } - cMakeCode.newLine(); - - // Add the install option - cMakeCode.pr(installCode); - cMakeCode.newLine(); - - // Add the include file - for (String includeFile : targetConfig.cmakeIncludes) { - cMakeCode.pr("include(\""+ Path.of(includeFile).getFileName()+"\")"); - } - cMakeCode.newLine(); - - cMakeCode.pr(cMakeExtras); - cMakeCode.newLine(); - - return cMakeCode; + cMakeCode.pr( + "find_package_handle_standard_args(libprotobuf-c DEFAULT_MSG PROTOBUF_INCLUDE_DIR" + + " PROTOBUF_LIBRARY)"); + cMakeCode.pr( + "target_include_directories( ${LF_MAIN_TARGET} PUBLIC ${PROTOBUF_INCLUDE_DIR} )"); + cMakeCode.pr("target_link_libraries(${LF_MAIN_TARGET} PRIVATE ${PROTOBUF_LIBRARY})"); + break; + case "-O2": + if (Objects.equals(targetConfig.compiler, "gcc") || CppMode) { + // Workaround for the pre-added -O2 option in the CGenerator. + // This flag is specific to gcc/g++ and the clang compiler + cMakeCode.pr("add_compile_options(-O2)"); + cMakeCode.pr("add_link_options(-O2)"); + break; + } + default: + errorReporter.reportWarning( + "Using the flags target property with cmake is dangerous.\n" + + " Use cmake-include instead."); + cMakeCode.pr("add_compile_options( " + compilerFlag + " )"); + cMakeCode.pr("add_link_options( " + compilerFlag + ")"); + } } + cMakeCode.newLine(); - /** Provide a strategy for configuring the main target of the CMake build. */ - public interface SetUpMainTarget { - // Implementation note: This indirection is necessary because the Python - // target produces a shared object file, not an executable. - String getCmakeCode(boolean hasMain, String executableName, Stream cSources); - } + // Add the install option + cMakeCode.pr(installCode); + cMakeCode.newLine(); - /** Generate the C-target-specific code for configuring the executable produced by the build. */ - private static String setUpMainTarget( - boolean hasMain, - String executableName, - Stream cSources - ) { - var code = new CodeBuilder(); - code.pr("add_subdirectory(core)"); - code.newLine(); - code.pr("set(LF_MAIN_TARGET "+executableName+")"); - code.newLine(); - - if (hasMain) { - code.pr("# Declare a new executable target and list all its sources"); - code.pr("add_executable("); - } else { - code.pr("# Declare a new library target and list all its sources"); - code.pr("add_library("); - } - code.indent(); - code.pr("${LF_MAIN_TARGET}"); - cSources.forEach(code::pr); - code.unindent(); - code.pr(")"); - code.newLine(); - return code.toString(); + // Add the include file + for (String includeFile : targetConfig.cmakeIncludes) { + cMakeCode.pr("include(\"" + Path.of(includeFile).getFileName() + "\")"); } + cMakeCode.newLine(); + + cMakeCode.pr(cMakeExtras); + cMakeCode.newLine(); + + return cMakeCode; + } + + /** Provide a strategy for configuring the main target of the CMake build. */ + public interface SetUpMainTarget { + // Implementation note: This indirection is necessary because the Python + // target produces a shared object file, not an executable. + String getCmakeCode(boolean hasMain, String executableName, Stream cSources); + } + + /** Generate the C-target-specific code for configuring the executable produced by the build. */ + private static String setUpMainTarget( + boolean hasMain, String executableName, Stream cSources) { + var code = new CodeBuilder(); + code.pr("add_subdirectory(core)"); + code.newLine(); + code.pr("set(LF_MAIN_TARGET " + executableName + ")"); + code.newLine(); + + if (hasMain) { + code.pr("# Declare a new executable target and list all its sources"); + code.pr("add_executable("); + } else { + code.pr("# Declare a new library target and list all its sources"); + code.pr("add_library("); + } + code.indent(); + code.pr("${LF_MAIN_TARGET}"); + cSources.forEach(code::pr); + code.unindent(); + code.pr(")"); + code.newLine(); + return code.toString(); + } + + private static String setUpMainTargetZephyr( + boolean hasMain, String executableName, Stream cSources) { + var code = new CodeBuilder(); + code.pr("add_subdirectory(core)"); + code.pr("target_link_libraries(core PUBLIC zephyr_interface)"); + // FIXME: Linking the reactor-c corelib with the zephyr kernel lib + // resolves linker issues but I am not yet sure if it is safe + code.pr("target_link_libraries(core PRIVATE kernel)"); + code.newLine(); + + if (hasMain) { + code.pr("# Declare a new executable target and list all its sources"); + code.pr("set(LF_MAIN_TARGET app)"); + code.pr("target_sources("); + } else { + code.pr("# Declare a new library target and list all its sources"); + code.pr("set(LF_MAIN_TARGET" + executableName + ")"); + code.pr("add_library("); + } + code.indent(); + code.pr("${LF_MAIN_TARGET}"); - private static String setUpMainTargetZephyr( - boolean hasMain, - String executableName, - Stream cSources - ) { - var code = new CodeBuilder(); - code.pr("add_subdirectory(core)"); - code.pr("target_link_libraries(core PUBLIC zephyr_interface)"); - // FIXME: Linking the reactor-c corelib with the zephyr kernel lib - // resolves linker issues but I am not yet sure if it is safe - code.pr("target_link_libraries(core PRIVATE kernel)"); - code.newLine(); - - if (hasMain) { - code.pr("# Declare a new executable target and list all its sources"); - code.pr("set(LF_MAIN_TARGET app)"); - code.pr("target_sources("); - } else { - code.pr("# Declare a new library target and list all its sources"); - code.pr("set(LF_MAIN_TARGET"+executableName+")"); - code.pr("add_library("); - } - code.indent(); - code.pr("${LF_MAIN_TARGET}"); - - if (hasMain) { - code.pr("PRIVATE"); - } - - cSources.forEach(code::pr); - code.unindent(); - code.pr(")"); - code.newLine(); - return code.toString(); + if (hasMain) { + code.pr("PRIVATE"); } + + cSources.forEach(code::pr); + code.unindent(); + code.pr(")"); + code.newLine(); + return code.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/src/org/lflang/generator/c/CCompiler.java index 9fcb72b4a6..f919977ba5 100644 --- a/org.lflang/src/org/lflang/generator/c/CCompiler.java +++ b/org.lflang/src/org/lflang/generator/c/CCompiler.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2019-2021, The University of California at Berkeley. - + * * 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. - + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -33,7 +33,6 @@ import java.util.ArrayList; import java.util.List; import java.util.stream.Stream; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.TargetConfig; @@ -47,8 +46,8 @@ import org.lflang.util.LFCommand; /** - * Responsible for creating and executing the necessary CMake command to compile - * code that is generated by the CGenerator. This class uses CMake to compile. + * Responsible for creating and executing the necessary CMake command to compile code that is + * generated by the CGenerator. This class uses CMake to compile. * * @author Soroush Bateni * @author Edward A. Lee @@ -59,392 +58,386 @@ */ public class CCompiler { - FileConfig fileConfig; - TargetConfig targetConfig; - ErrorReporter errorReporter; - - /** - * Indicate whether the compiler is in C++ mode. - * In C++ mode, the compiler produces .cpp files instead - * of .c files and uses a C++ compiler to compiler the code. - */ - private final boolean cppMode; - - /** - * A factory for compiler commands. - */ - GeneratorCommandFactory commandFactory; - - /** - * Create an instance of CCompiler. - * - * @param targetConfig The current target configuration. - * @param fileConfig The current file configuration. - * @param errorReporter Used to report errors. - * @param cppMode Whether the generated code should be compiled as if it - * were C++. - */ - public CCompiler( - TargetConfig targetConfig, - FileConfig fileConfig, - ErrorReporter errorReporter, - boolean cppMode - ) { - this.fileConfig = fileConfig; - this.targetConfig = targetConfig; - this.errorReporter = errorReporter; - this.commandFactory = new GeneratorCommandFactory(errorReporter, fileConfig); - this.cppMode = cppMode; + FileConfig fileConfig; + TargetConfig targetConfig; + ErrorReporter errorReporter; + + /** + * Indicate whether the compiler is in C++ mode. In C++ mode, the compiler produces .cpp files + * instead of .c files and uses a C++ compiler to compiler the code. + */ + private final boolean cppMode; + + /** A factory for compiler commands. */ + GeneratorCommandFactory commandFactory; + + /** + * Create an instance of CCompiler. + * + * @param targetConfig The current target configuration. + * @param fileConfig The current file configuration. + * @param errorReporter Used to report errors. + * @param cppMode Whether the generated code should be compiled as if it were C++. + */ + public CCompiler( + TargetConfig targetConfig, + FileConfig fileConfig, + ErrorReporter errorReporter, + boolean cppMode) { + this.fileConfig = fileConfig; + this.targetConfig = targetConfig; + this.errorReporter = errorReporter; + this.commandFactory = new GeneratorCommandFactory(errorReporter, fileConfig); + this.cppMode = cppMode; + } + + /** + * Run the C compiler by invoking cmake and make. + * + * @param generator An instance of GeneratorBase, only used to report error line numbers in the + * Eclipse IDE. + * @return true if compilation succeeds, false otherwise. + */ + public boolean runCCompiler(GeneratorBase generator, LFGeneratorContext context) + throws IOException { + // Set the build directory to be "build" + Path buildPath = fileConfig.getSrcGenPath().resolve("build"); + // Remove the previous build directory if it exists to + // avoid any error residue that can occur in CMake from + // a previous build. + // FIXME: This is slow and only needed if an error + // has previously occurred. Deleting the build directory + // if no prior errors have occurred can prolong the compilation + // substantially. See #1416 for discussion. + FileUtil.deleteDirectory(buildPath); + // Make sure the build directory exists + Files.createDirectories(buildPath); + + LFCommand compile = compileCmakeCommand(); + if (compile == null) { + return false; } - /** - * Run the C compiler by invoking cmake and make. - * @param generator An instance of GeneratorBase, only used to report error line numbers - * in the Eclipse IDE. - * - * @return true if compilation succeeds, false otherwise. - */ - public boolean runCCompiler( - GeneratorBase generator, - LFGeneratorContext context - ) throws IOException { - // Set the build directory to be "build" - Path buildPath = fileConfig.getSrcGenPath().resolve("build"); - // Remove the previous build directory if it exists to - // avoid any error residue that can occur in CMake from - // a previous build. - // FIXME: This is slow and only needed if an error - // has previously occurred. Deleting the build directory - // if no prior errors have occurred can prolong the compilation - // substantially. See #1416 for discussion. - FileUtil.deleteDirectory(buildPath); - // Make sure the build directory exists - Files.createDirectories(buildPath); - - LFCommand compile = compileCmakeCommand(); - if (compile == null) { - return false; - } - - // Use the user-specified compiler if any - if (targetConfig.compiler != null) { - if (cppMode) { - // Set the CXX environment variable to change the C++ compiler. - compile.replaceEnvironmentVariable("CXX", targetConfig.compiler); - } else { - // Set the CC environment variable to change the C compiler. - compile.replaceEnvironmentVariable("CC", targetConfig.compiler); - } - } - - int cMakeReturnCode = compile.run(context.getCancelIndicator()); - - if (cMakeReturnCode != 0 && - context.getMode() == LFGeneratorContext.Mode.STANDALONE && - !outputContainsKnownCMakeErrors(compile.getErrors().toString())) { - errorReporter.reportError(targetConfig.compiler + " failed with error code " + cMakeReturnCode); - } - - // For warnings (vs. errors), the return code is 0. - // But we still want to mark the IDE. - if (compile.getErrors().toString().length() > 0 && - context.getMode() != LFGeneratorContext.Mode.STANDALONE && - !outputContainsKnownCMakeErrors(compile.getErrors().toString())) { - generator.reportCommandErrors(compile.getErrors().toString()); - } - - int makeReturnCode = 0; - - if (cMakeReturnCode == 0) { - LFCommand build = buildCmakeCommand(); - - makeReturnCode = build.run(context.getCancelIndicator()); - - if (makeReturnCode != 0 && - context.getMode() == LFGeneratorContext.Mode.STANDALONE && - !outputContainsKnownCMakeErrors(build.getErrors().toString())) { - errorReporter.reportError(targetConfig.compiler + " failed with error code " + makeReturnCode); - } - - // For warnings (vs. errors), the return code is 0. - // But we still want to mark the IDE. - if (build.getErrors().toString().length() > 0 && - context.getMode() != LFGeneratorContext.Mode.STANDALONE && - !outputContainsKnownCMakeErrors(build.getErrors().toString())) { - generator.reportCommandErrors(build.getErrors().toString()); - } - - - if (makeReturnCode == 0 && build.getErrors().toString().length() == 0) { - System.out.println("SUCCESS: Compiling generated code for " + fileConfig.name + " finished with no errors."); - } - - if (targetConfig.platformOptions.platform == Platform.ZEPHYR && targetConfig.platformOptions.flash) { - System.out.println("Invoking flash command for Zephyr"); - LFCommand flash = buildWestFlashCommand(); - int flashRet = flash.run(); - if (flashRet != 0) { - errorReporter.reportError("West flash command failed with error code " + flashRet); - } else { - System.out.println("SUCCESS: Flashed application with west"); - } - } - - } - return cMakeReturnCode == 0 && makeReturnCode == 0; + // Use the user-specified compiler if any + if (targetConfig.compiler != null) { + if (cppMode) { + // Set the CXX environment variable to change the C++ compiler. + compile.replaceEnvironmentVariable("CXX", targetConfig.compiler); + } else { + // Set the CC environment variable to change the C compiler. + compile.replaceEnvironmentVariable("CC", targetConfig.compiler); + } } + int cMakeReturnCode = compile.run(context.getCancelIndicator()); - /** - * Return a command to compile the specified C file using CMake. - * This produces a C-specific compile command. - */ - public LFCommand compileCmakeCommand() { - // Set the build directory to be "build" - Path buildPath = fileConfig.getSrcGenPath().resolve("build"); - - LFCommand command = commandFactory.createCommand( - "cmake", cmakeOptions(targetConfig, fileConfig), - buildPath); - if (command == null) { - errorReporter.reportError( - "The C/CCpp target requires CMAKE >= " + CCmakeGenerator.MIN_CMAKE_VERSION - + " to compile the generated code. " + - "Auto-compiling can be disabled using the \"no-compile: true\" target property."); - } - return command; + if (cMakeReturnCode != 0 + && context.getMode() == LFGeneratorContext.Mode.STANDALONE + && !outputContainsKnownCMakeErrors(compile.getErrors().toString())) { + errorReporter.reportError( + targetConfig.compiler + " failed with error code " + cMakeReturnCode); } - static Stream cmakeCompileDefinitions(TargetConfig targetConfig) { - return targetConfig.compileDefinitions.entrySet().stream() - .map(entry -> "-D" + entry.getKey() + "=" + entry.getValue()); + // For warnings (vs. errors), the return code is 0. + // But we still want to mark the IDE. + if (compile.getErrors().toString().length() > 0 + && context.getMode() != LFGeneratorContext.Mode.STANDALONE + && !outputContainsKnownCMakeErrors(compile.getErrors().toString())) { + generator.reportCommandErrors(compile.getErrors().toString()); } - private static List cmakeOptions(TargetConfig targetConfig, FileConfig fileConfig) { - List arguments = new ArrayList<>(); - cmakeCompileDefinitions(targetConfig).forEachOrdered(arguments::add); - String separator = File.separator; - String maybeQuote = ""; // Windows seems to require extra level of quoting. - String srcPath = fileConfig.srcPath.toString(); // Windows requires escaping the backslashes. - String rootPath = fileConfig.srcPkgPath.toString(); - if (separator.equals("\\")) { - separator = "\\\\\\\\"; - maybeQuote = "\\\""; - srcPath = srcPath.replaceAll("\\\\", "\\\\\\\\"); - rootPath = rootPath.replaceAll("\\\\", "\\\\\\\\"); + int makeReturnCode = 0; + + if (cMakeReturnCode == 0) { + LFCommand build = buildCmakeCommand(); + + makeReturnCode = build.run(context.getCancelIndicator()); + + if (makeReturnCode != 0 + && context.getMode() == LFGeneratorContext.Mode.STANDALONE + && !outputContainsKnownCMakeErrors(build.getErrors().toString())) { + errorReporter.reportError( + targetConfig.compiler + " failed with error code " + makeReturnCode); + } + + // For warnings (vs. errors), the return code is 0. + // But we still want to mark the IDE. + if (build.getErrors().toString().length() > 0 + && context.getMode() != LFGeneratorContext.Mode.STANDALONE + && !outputContainsKnownCMakeErrors(build.getErrors().toString())) { + generator.reportCommandErrors(build.getErrors().toString()); + } + + if (makeReturnCode == 0 && build.getErrors().toString().length() == 0) { + System.out.println( + "SUCCESS: Compiling generated code for " + + fileConfig.name + + " finished with no errors."); + } + + if (targetConfig.platformOptions.platform == Platform.ZEPHYR + && targetConfig.platformOptions.flash) { + System.out.println("Invoking flash command for Zephyr"); + LFCommand flash = buildWestFlashCommand(); + int flashRet = flash.run(); + if (flashRet != 0) { + errorReporter.reportError("West flash command failed with error code " + flashRet); + } else { + System.out.println("SUCCESS: Flashed application with west"); } - arguments.addAll(List.of( - "-DCMAKE_BUILD_TYPE=" + ((targetConfig.cmakeBuildType!=null) ? targetConfig.cmakeBuildType.toString() : "Release"), + } + } + return cMakeReturnCode == 0 && makeReturnCode == 0; + } + + /** + * Return a command to compile the specified C file using CMake. This produces a C-specific + * compile command. + */ + public LFCommand compileCmakeCommand() { + // Set the build directory to be "build" + Path buildPath = fileConfig.getSrcGenPath().resolve("build"); + + LFCommand command = + commandFactory.createCommand("cmake", cmakeOptions(targetConfig, fileConfig), buildPath); + if (command == null) { + errorReporter.reportError( + "The C/CCpp target requires CMAKE >= " + + CCmakeGenerator.MIN_CMAKE_VERSION + + " to compile the generated code. " + + "Auto-compiling can be disabled using the \"no-compile: true\" target property."); + } + return command; + } + + static Stream cmakeCompileDefinitions(TargetConfig targetConfig) { + return targetConfig.compileDefinitions.entrySet().stream() + .map(entry -> "-D" + entry.getKey() + "=" + entry.getValue()); + } + + private static List cmakeOptions(TargetConfig targetConfig, FileConfig fileConfig) { + List arguments = new ArrayList<>(); + cmakeCompileDefinitions(targetConfig).forEachOrdered(arguments::add); + String separator = File.separator; + String maybeQuote = ""; // Windows seems to require extra level of quoting. + String srcPath = fileConfig.srcPath.toString(); // Windows requires escaping the backslashes. + String rootPath = fileConfig.srcPkgPath.toString(); + if (separator.equals("\\")) { + separator = "\\\\\\\\"; + maybeQuote = "\\\""; + srcPath = srcPath.replaceAll("\\\\", "\\\\\\\\"); + rootPath = rootPath.replaceAll("\\\\", "\\\\\\\\"); + } + arguments.addAll( + List.of( + "-DCMAKE_BUILD_TYPE=" + + ((targetConfig.cmakeBuildType != null) + ? targetConfig.cmakeBuildType.toString() + : "Release"), "-DCMAKE_INSTALL_PREFIX=" + FileUtil.toUnixString(fileConfig.getOutPath()), - "-DCMAKE_INSTALL_BINDIR=" + FileUtil.toUnixString( - fileConfig.getOutPath().relativize( - fileConfig.binPath - ) - ), - "-DLF_FILE_SEPARATOR=\"" + maybeQuote + separator + maybeQuote + "\"" - )); - // Add #define for source file directory. - // Do not do this for federated programs because for those, the definition is put - // into the cmake file (and fileConfig.srcPath is the wrong directory anyway). - if (!fileConfig.srcPath.toString().contains("fed-gen")) { - // Do not convert to Unix path - arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + srcPath + maybeQuote + "\""); - arguments.add("-DLF_PACKAGE_DIRECTORY=\"" + maybeQuote + rootPath + maybeQuote + "\""); - } - arguments.add(FileUtil.toUnixString(fileConfig.getSrcGenPath())); - - if (GeneratorUtils.isHostWindows()) { - arguments.add("-DCMAKE_SYSTEM_VERSION=\"10.0\""); - } - return arguments; + "-DCMAKE_INSTALL_BINDIR=" + + FileUtil.toUnixString(fileConfig.getOutPath().relativize(fileConfig.binPath)), + "-DLF_FILE_SEPARATOR=\"" + maybeQuote + separator + maybeQuote + "\"")); + // Add #define for source file directory. + // Do not do this for federated programs because for those, the definition is put + // into the cmake file (and fileConfig.srcPath is the wrong directory anyway). + if (!fileConfig.srcPath.toString().contains("fed-gen")) { + // Do not convert to Unix path + arguments.add("-DLF_SOURCE_DIRECTORY=\"" + maybeQuote + srcPath + maybeQuote + "\""); + arguments.add("-DLF_PACKAGE_DIRECTORY=\"" + maybeQuote + rootPath + maybeQuote + "\""); } + arguments.add(FileUtil.toUnixString(fileConfig.getSrcGenPath())); - /** - * Return the cmake config name correspnding to a given build type. - */ - private String buildTypeToCmakeConfig(TargetProperty.BuildType type) { - if (type == null) { - return "Release"; - } - switch (type) { - case TEST: - return "Debug"; - default: - return type.toString(); - } + if (GeneratorUtils.isHostWindows()) { + arguments.add("-DCMAKE_SYSTEM_VERSION=\"10.0\""); } + return arguments; + } - /** - * Return a command to build the specified C file using CMake. - * This produces a C-specific build command. - * - *

    Note: It appears that configuration and build cannot happen in one command. - * Therefore, this is separated into a compile command and a build command.

    - */ - public LFCommand buildCmakeCommand() { - // Set the build directory to be "build" - Path buildPath = fileConfig.getSrcGenPath().resolve("build"); - String cores = String.valueOf(Runtime.getRuntime().availableProcessors()); - LFCommand command = commandFactory.createCommand( - "cmake", List.of( - "--build", ".", "--target", "install", "--parallel", cores, "--config", - buildTypeToCmakeConfig(targetConfig.cmakeBuildType) - ), - buildPath); - if (command == null) { - errorReporter.reportError( - "The C/CCpp target requires CMAKE >= 3.5 to compile the generated code. " - + "Auto-compiling can be disabled using the \"no-compile: true\" target property." - ); - } - return command; + /** Return the cmake config name correspnding to a given build type. */ + private String buildTypeToCmakeConfig(TargetProperty.BuildType type) { + if (type == null) { + return "Release"; } - - /** - * Return a flash/emulate command using west. - * If board is null (defaults to qemu_cortex_m3) or qemu_* - * Return a flash command which runs the target as an emulation - * If ordinary target, return {@code west flash} - */ - public LFCommand buildWestFlashCommand() { - // Set the build directory to be "build" - Path buildPath = fileConfig.getSrcGenPath().resolve("build"); - String board = targetConfig.platformOptions.board; - LFCommand cmd; - if (board == null || board.startsWith("qemu")) { - cmd = commandFactory.createCommand( - "west", List.of("build", "-t", "run"), buildPath); - } else { - cmd = commandFactory.createCommand( - "west", List.of("flash"), buildPath); - } - if (cmd == null) { - errorReporter.reportError( - "Could not create west flash command." - ); - } - - return cmd; + switch (type) { + case TEST: + return "Debug"; + default: + return type.toString(); } - - /** - * Check if the output produced by CMake has any known and common errors. - * If a known error is detected, a specialized, more informative message - * is shown. - * - * Errors currently detected: - *
      - *
    • C++ compiler used to compile C files: This error shows up as - * '#error "The CMAKE_C_COMPILER is set to a C++ compiler"' in - * the 'CMakeOutput' string.
      • - *
    - * - * @param CMakeOutput The captured output from CMake. - * @return true if the provided 'CMakeOutput' contains a known error. - * false otherwise. - */ - @SuppressWarnings("BooleanMethodIsAlwaysInverted") - private boolean outputContainsKnownCMakeErrors(String CMakeOutput) { - // Check if the error thrown is due to the wrong compiler - if (CMakeOutput.contains("The CMAKE_C_COMPILER is set to a C++ compiler")) { - // If so, print an appropriate error message - if (targetConfig.compiler != null) { - errorReporter.reportError( - "A C++ compiler was requested in the compiler target property." - + " Use the CCpp or the Cpp target instead."); - } else { - errorReporter.reportError("\"A C++ compiler was detected." - + " The C target works best with a C compiler." - + " Use the CCpp or the Cpp target instead.\""); - } - return true; - } - return false; + } + + /** + * Return a command to build the specified C file using CMake. This produces a C-specific build + * command. + * + *

    Note: It appears that configuration and build cannot happen in one command. Therefore, this + * is separated into a compile command and a build command. + */ + public LFCommand buildCmakeCommand() { + // Set the build directory to be "build" + Path buildPath = fileConfig.getSrcGenPath().resolve("build"); + String cores = String.valueOf(Runtime.getRuntime().availableProcessors()); + LFCommand command = + commandFactory.createCommand( + "cmake", + List.of( + "--build", + ".", + "--target", + "install", + "--parallel", + cores, + "--config", + buildTypeToCmakeConfig(targetConfig.cmakeBuildType)), + buildPath); + if (command == null) { + errorReporter.reportError( + "The C/CCpp target requires CMAKE >= 3.5 to compile the generated code. " + + "Auto-compiling can be disabled using the \"no-compile: true\" target property."); + } + return command; + } + + /** + * Return a flash/emulate command using west. If board is null (defaults to qemu_cortex_m3) or + * qemu_* Return a flash command which runs the target as an emulation If ordinary target, return + * {@code west flash} + */ + public LFCommand buildWestFlashCommand() { + // Set the build directory to be "build" + Path buildPath = fileConfig.getSrcGenPath().resolve("build"); + String board = targetConfig.platformOptions.board; + LFCommand cmd; + if (board == null || board.startsWith("qemu")) { + cmd = commandFactory.createCommand("west", List.of("build", "-t", "run"), buildPath); + } else { + cmd = commandFactory.createCommand("west", List.of("flash"), buildPath); + } + if (cmd == null) { + errorReporter.reportError("Could not create west flash command."); } - /** - * Return a command to compile the specified C file using a native compiler - * (generally gcc unless overridden by the user). - * This produces a C specific compile command. - * - * @param fileToCompile The C filename without the .c extension. - * @param noBinary If true, the compiler will create a .o output instead of a binary. - * If false, the compile command will produce a binary. - */ - public LFCommand compileCCommand( - String fileToCompile, - boolean noBinary - ) { - String cFilename = getTargetFileName(fileToCompile, cppMode, targetConfig); - - Path relativeSrcPath = fileConfig.getOutPath().relativize( - fileConfig.getSrcGenPath().resolve(Paths.get(cFilename))); - Path relativeBinPath = fileConfig.getOutPath().relativize( - fileConfig.binPath.resolve(Paths.get(fileToCompile))); - - // NOTE: we assume that any C compiler takes Unix paths as arguments. - String relSrcPathString = FileUtil.toUnixString(relativeSrcPath); - String relBinPathString = FileUtil.toUnixString(relativeBinPath); - - // If there is no main reactor, then generate a .o file not an executable. - if (noBinary) { - relBinPathString += ".o"; - } - - ArrayList compileArgs = new ArrayList<>(); - compileArgs.add(relSrcPathString); - for (String file: targetConfig.compileAdditionalSources) { - var relativePath = fileConfig.getOutPath().relativize( - fileConfig.getSrcGenPath().resolve(Paths.get(file))); - compileArgs.add(FileUtil.toUnixString(relativePath)); - } - compileArgs.addAll(targetConfig.compileLibraries); + return cmd; + } + + /** + * Check if the output produced by CMake has any known and common errors. If a known error is + * detected, a specialized, more informative message is shown. + * + *

    Errors currently detected: + * + *

      + *
    • C++ compiler used to compile C files: This error shows up as '#error "The + * CMAKE_C_COMPILER is set to a C++ compiler"' in the 'CMakeOutput' string. + *
    + * + * @param CMakeOutput The captured output from CMake. + * @return true if the provided 'CMakeOutput' contains a known error. false otherwise. + */ + @SuppressWarnings("BooleanMethodIsAlwaysInverted") + private boolean outputContainsKnownCMakeErrors(String CMakeOutput) { + // Check if the error thrown is due to the wrong compiler + if (CMakeOutput.contains("The CMAKE_C_COMPILER is set to a C++ compiler")) { + // If so, print an appropriate error message + if (targetConfig.compiler != null) { + errorReporter.reportError( + "A C++ compiler was requested in the compiler target property." + + " Use the CCpp or the Cpp target instead."); + } else { + errorReporter.reportError( + "\"A C++ compiler was detected." + + " The C target works best with a C compiler." + + " Use the CCpp or the Cpp target instead.\""); + } + return true; + } + return false; + } + + /** + * Return a command to compile the specified C file using a native compiler (generally gcc unless + * overridden by the user). This produces a C specific compile command. + * + * @param fileToCompile The C filename without the .c extension. + * @param noBinary If true, the compiler will create a .o output instead of a binary. If false, + * the compile command will produce a binary. + */ + public LFCommand compileCCommand(String fileToCompile, boolean noBinary) { + String cFilename = getTargetFileName(fileToCompile, cppMode, targetConfig); + + Path relativeSrcPath = + fileConfig + .getOutPath() + .relativize(fileConfig.getSrcGenPath().resolve(Paths.get(cFilename))); + Path relativeBinPath = + fileConfig.getOutPath().relativize(fileConfig.binPath.resolve(Paths.get(fileToCompile))); + + // NOTE: we assume that any C compiler takes Unix paths as arguments. + String relSrcPathString = FileUtil.toUnixString(relativeSrcPath); + String relBinPathString = FileUtil.toUnixString(relativeBinPath); + + // If there is no main reactor, then generate a .o file not an executable. + if (noBinary) { + relBinPathString += ".o"; + } - // Add compile definitions - targetConfig.compileDefinitions.forEach((key,value) -> compileArgs.add("-D"+key+"="+value)); + ArrayList compileArgs = new ArrayList<>(); + compileArgs.add(relSrcPathString); + for (String file : targetConfig.compileAdditionalSources) { + var relativePath = + fileConfig.getOutPath().relativize(fileConfig.getSrcGenPath().resolve(Paths.get(file))); + compileArgs.add(FileUtil.toUnixString(relativePath)); + } + compileArgs.addAll(targetConfig.compileLibraries); - // Finally, add the compiler flags in target parameters (if any) - compileArgs.addAll(targetConfig.compilerFlags); + // Add compile definitions + targetConfig.compileDefinitions.forEach( + (key, value) -> compileArgs.add("-D" + key + "=" + value)); - // Only set the output file name if it hasn't already been set - // using a target property or Args line flag. - if (!compileArgs.contains("-o")) { - compileArgs.add("-o"); - compileArgs.add(relBinPathString); - } + // Finally, add the compiler flags in target parameters (if any) + compileArgs.addAll(targetConfig.compilerFlags); - // If there is no main reactor, then use the -c flag to prevent linking from occurring. - // FIXME: we could add a {@code -c} flag to {@code lfc} to make this explicit in stand-alone mode. - // Then again, I think this only makes sense when we can do linking. - if (noBinary) { - compileArgs.add("-c"); // FIXME: revisit - } + // Only set the output file name if it hasn't already been set + // using a target property or Args line flag. + if (!compileArgs.contains("-o")) { + compileArgs.add("-o"); + compileArgs.add(relBinPathString); + } - LFCommand command = commandFactory.createCommand(targetConfig.compiler, compileArgs, fileConfig.getOutPath()); - if (command == null) { - errorReporter.reportError( - "The C/CCpp target requires GCC >= 7 to compile the generated code. " + - "Auto-compiling can be disabled using the \"no-compile: true\" target property."); - } - return command; + // If there is no main reactor, then use the -c flag to prevent linking from occurring. + // FIXME: we could add a {@code -c} flag to {@code lfc} to make this explicit in stand-alone + // mode. + // Then again, I think this only makes sense when we can do linking. + if (noBinary) { + compileArgs.add("-c"); // FIXME: revisit } - /** - * Produces the filename including the target-specific extension - * - * @param fileName The base name of the file without any extensions - * @param cppMode Indicate whether the compiler is in C++ mode - * In C++ mode, the compiler produces .cpp files instead - * of .c files and uses a C++ compiler to compiler the code. - */ - static String getTargetFileName(String fileName, boolean cppMode, TargetConfig targetConfig) { - if (targetConfig.platformOptions.platform == Platform.ARDUINO) { - return fileName + ".ino"; - } - if (cppMode) { - // If the C++ mode is enabled, use a .cpp extension - return fileName + ".cpp"; - } - return fileName + ".c"; + LFCommand command = + commandFactory.createCommand(targetConfig.compiler, compileArgs, fileConfig.getOutPath()); + if (command == null) { + errorReporter.reportError( + "The C/CCpp target requires GCC >= 7 to compile the generated code. " + + "Auto-compiling can be disabled using the \"no-compile: true\" target property."); + } + return command; + } + + /** + * Produces the filename including the target-specific extension + * + * @param fileName The base name of the file without any extensions + * @param cppMode Indicate whether the compiler is in C++ mode In C++ mode, the compiler produces + * .cpp files instead of .c files and uses a C++ compiler to compiler the code. + */ + static String getTargetFileName(String fileName, boolean cppMode, TargetConfig targetConfig) { + if (targetConfig.platformOptions.platform == Platform.ARDUINO) { + return fileName + ".ino"; + } + if (cppMode) { + // If the C++ mode is enabled, use a .cpp extension + return fileName + ".cpp"; } + return fileName + ".c"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java b/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java index 41731106c3..529e37a975 100644 --- a/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java @@ -1,36 +1,30 @@ package org.lflang.generator.c; import org.lflang.generator.CodeBuilder; -import org.lflang.lf.Reactor; -/** - * Generates C constructor code for a reactor. - * - */ +/** Generates C constructor code for a reactor. */ public class CConstructorGenerator { - /** - * Generate a constructor for the specified reactor in the specified federate. - * @param reactor The parsed reactor data structure. - * @param constructorCode Lines of code previously generated that need to - * go into the constructor. - */ - public static String generateConstructor( - TypeParameterizedReactor tpr, - String constructorCode - ) { - var structType = CUtil.selfType(tpr); - var code = new CodeBuilder(); - code.pr(structType+"* new_"+CUtil.getName(tpr)+"() {"); - code.indent(); - code.pr(structType+"* self = ("+structType+"*)_lf_new_reactor(sizeof("+structType+"));"); - code.pr(constructorCode); - code.pr("return self;"); - code.unindent(); - code.pr("}"); - return code.toString(); - } + /** + * Generate a constructor for the specified reactor in the specified federate. + * + * @param reactor The parsed reactor data structure. + * @param constructorCode Lines of code previously generated that need to go into the constructor. + */ + public static String generateConstructor(TypeParameterizedReactor tpr, String constructorCode) { + var structType = CUtil.selfType(tpr); + var code = new CodeBuilder(); + code.pr(structType + "* new_" + CUtil.getName(tpr) + "() {"); + code.indent(); + code.pr( + structType + "* self = (" + structType + "*)_lf_new_reactor(sizeof(" + structType + "));"); + code.pr(constructorCode); + code.pr("return self;"); + code.unindent(); + code.pr("}"); + return code.toString(); + } - public static String generateConstructorPrototype(TypeParameterizedReactor tpr) { - return CUtil.selfType(tpr)+"* new_"+CUtil.getName(tpr)+"();"; - } + public static String generateConstructorPrototype(TypeParameterizedReactor tpr) { + return CUtil.selfType(tpr) + "* new_" + CUtil.getName(tpr) + "();"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java index 46503d87cc..2d83a105da 100644 --- a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java +++ b/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java @@ -1,32 +1,28 @@ package org.lflang.generator.c; + import java.util.List; /** - * Generates the list of files to be included in the - * core library for each reactor given conditions listed - * as arguments of each function. + * Generates the list of files to be included in the core library for each reactor given conditions + * listed as arguments of each function. * * @author Hou Seng Wong */ public class CCoreFilesUtils { - public static List getCTargetSrc() { - return List.of( - "lib/schedule.c" - ); - } + public static List getCTargetSrc() { + return List.of("lib/schedule.c"); + } - public static List getCTargetHeader() { - return List.of( - "include/api/api.h" - ); - } + public static List getCTargetHeader() { + return List.of("include/api/api.h"); + } - public static String getCTargetSetHeader() { - return "include/api/set.h"; - } + public static String getCTargetSetHeader() { + return "include/api/set.h"; + } - public static String getCTargetSetUndefHeader() { - return "include/api/set_undef.h"; - } + public static String getCTargetSetUndefHeader() { + return "include/api/set_undef.h"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java b/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java index f5aa244e60..ec75412b42 100644 --- a/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java @@ -9,54 +9,51 @@ public class CDelayBodyGenerator implements DelayBodyGenerator { - protected CTypes types; - - public CDelayBodyGenerator(CTypes types) { - this.types = types; - } - - /** - * Generate code for the body of a reaction that takes an input and - * schedules an action with the value of that input. - * @param action The action to schedule - * @param port The port to read from - */ - @Override - public String generateDelayBody(Action action, VarRef port) { - var ref = ASTUtils.generateVarRef(port); - return CReactionGenerator.generateDelayBody( - ref, - action.getName(), - CUtil.isTokenType(getInferredType(action), types) - ); - } - - /** - * Generate code for the body of a reaction that is triggered by the - * given action and writes its value to the given port. This realizes - * the receiving end of a logical delay specified with the 'after' - * keyword. - * @param action The action that triggers the reaction - * @param port The port to write to. - */ - @Override - public String generateForwardBody(Action action, VarRef port) { - var outputName = ASTUtils.generateVarRef(port); - return CReactionGenerator.generateForwardBody( - outputName, - types.getTargetType(action), - action.getName(), - CUtil.isTokenType(getInferredType(action), types) - ); - } - - @Override - public String generateDelayGeneric() { - throw new UnsupportedOperationException("TODO: auto-generated method stub"); - } - - @Override - public boolean generateAfterDelaysWithVariableWidth() { - return true; - } + protected CTypes types; + + public CDelayBodyGenerator(CTypes types) { + this.types = types; + } + + /** + * Generate code for the body of a reaction that takes an input and schedules an action with the + * value of that input. + * + * @param action The action to schedule + * @param port The port to read from + */ + @Override + public String generateDelayBody(Action action, VarRef port) { + var ref = ASTUtils.generateVarRef(port); + return CReactionGenerator.generateDelayBody( + ref, action.getName(), CUtil.isTokenType(getInferredType(action), types)); + } + + /** + * Generate code for the body of a reaction that is triggered by the given action and writes its + * value to the given port. This realizes the receiving end of a logical delay specified with the + * 'after' keyword. + * + * @param action The action that triggers the reaction + * @param port The port to write to. + */ + @Override + public String generateForwardBody(Action action, VarRef port) { + var outputName = ASTUtils.generateVarRef(port); + return CReactionGenerator.generateForwardBody( + outputName, + types.getTargetType(action), + action.getName(), + CUtil.isTokenType(getInferredType(action), types)); + } + + @Override + public String generateDelayGeneric() { + throw new UnsupportedOperationException("TODO: auto-generated method stub"); + } + + @Override + public boolean generateAfterDelaysWithVariableWidth() { + return true; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CDockerGenerator.java b/org.lflang/src/org/lflang/generator/c/CDockerGenerator.java index ae9058dcbb..f52e23a949 100644 --- a/org.lflang/src/org/lflang/generator/c/CDockerGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CDockerGenerator.java @@ -1,9 +1,7 @@ package org.lflang.generator.c; import java.util.stream.Collectors; - import org.eclipse.xtext.xbase.lib.IterableExtensions; - import org.lflang.Target; import org.lflang.generator.DockerGenerator; import org.lflang.generator.LFGeneratorContext; @@ -15,62 +13,66 @@ * @author Hou Seng Wong */ public class CDockerGenerator extends DockerGenerator { - private static final String DEFAULT_BASE_IMAGE = "alpine:latest"; + private static final String DEFAULT_BASE_IMAGE = "alpine:latest"; - /** - * The constructor for the base docker file generation class. - * - * @param context The context of the code generator. - */ - public CDockerGenerator(LFGeneratorContext context) { - super(context); - } + /** + * The constructor for the base docker file generation class. + * + * @param context The context of the code generator. + */ + public CDockerGenerator(LFGeneratorContext context) { + super(context); + } - - /** - * Generate the contents of the docker file. - */ - @Override - protected String generateDockerFileContent() { - var lfModuleName = context.getFileConfig().name; - var config = context.getTargetConfig(); - var compileCommand = IterableExtensions.isNullOrEmpty(config.buildCommands) ? - generateDefaultCompileCommand() : - StringUtil.joinObjects(config.buildCommands, " "); - var compiler = config.target == Target.CCPP ? "g++" : "gcc"; - var baseImage = DEFAULT_BASE_IMAGE; - if (config.dockerOptions != null && config.dockerOptions.from != null) { - baseImage = config.dockerOptions.from; - } - return String.join("\n", - "# For instructions, see: https://www.lf-lang.org/docs/handbook/containerized-execution", - "FROM "+baseImage+" AS builder", - "WORKDIR /lingua-franca/"+lfModuleName, - "RUN set -ex && apk add --no-cache "+compiler+" musl-dev cmake make", - "COPY . src-gen", - compileCommand, - "", - "FROM "+baseImage, - "WORKDIR /lingua-franca", - "RUN mkdir bin", - "COPY --from=builder /lingua-franca/"+lfModuleName+"/bin/"+lfModuleName+" ./bin/"+lfModuleName, - "", - "# Use ENTRYPOINT not CMD so that command-line arguments go through", - "ENTRYPOINT [\"./bin/"+lfModuleName+"\"]", - "" - ); + /** Generate the contents of the docker file. */ + @Override + protected String generateDockerFileContent() { + var lfModuleName = context.getFileConfig().name; + var config = context.getTargetConfig(); + var compileCommand = + IterableExtensions.isNullOrEmpty(config.buildCommands) + ? generateDefaultCompileCommand() + : StringUtil.joinObjects(config.buildCommands, " "); + var compiler = config.target == Target.CCPP ? "g++" : "gcc"; + var baseImage = DEFAULT_BASE_IMAGE; + if (config.dockerOptions != null && config.dockerOptions.from != null) { + baseImage = config.dockerOptions.from; } + return String.join( + "\n", + "# For instructions, see: https://www.lf-lang.org/docs/handbook/containerized-execution", + "FROM " + baseImage + " AS builder", + "WORKDIR /lingua-franca/" + lfModuleName, + "RUN set -ex && apk add --no-cache " + compiler + " musl-dev cmake make", + "COPY . src-gen", + compileCommand, + "", + "FROM " + baseImage, + "WORKDIR /lingua-franca", + "RUN mkdir bin", + "COPY --from=builder /lingua-franca/" + + lfModuleName + + "/bin/" + + lfModuleName + + " ./bin/" + + lfModuleName, + "", + "# Use ENTRYPOINT not CMD so that command-line arguments go through", + "ENTRYPOINT [\"./bin/" + lfModuleName + "\"]", + ""); + } - /** Return the default compile command for the C docker container. */ - protected String generateDefaultCompileCommand() { - return String.join("\n", - "RUN set -ex && \\", - "mkdir bin && \\", - "cmake " + CCompiler.cmakeCompileDefinitions(context.getTargetConfig()) + /** Return the default compile command for the C docker container. */ + protected String generateDefaultCompileCommand() { + return String.join( + "\n", + "RUN set -ex && \\", + "mkdir bin && \\", + "cmake " + + CCompiler.cmakeCompileDefinitions(context.getTargetConfig()) .collect(Collectors.joining(" ")) - + " -S src-gen -B bin && \\", - "cd bin && \\", - "make all" - ); - } + + " -S src-gen -B bin && \\", + "cd bin && \\", + "make all"); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CFileConfig.java b/org.lflang/src/org/lflang/generator/c/CFileConfig.java index 362b8645b5..db9447a833 100644 --- a/org.lflang/src/org/lflang/generator/c/CFileConfig.java +++ b/org.lflang/src/org/lflang/generator/c/CFileConfig.java @@ -2,24 +2,29 @@ import java.io.IOException; import java.nio.file.Path; - import org.eclipse.emf.ecore.resource.Resource; - import org.lflang.FileConfig; public class CFileConfig extends FileConfig { - private final Path includePath; - public CFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) throws IOException { - super(resource, srcGenBasePath, useHierarchicalBin); - var includeDir = getOutPath().resolve("include"); - includePath = !useHierarchicalBin ? includeDir : includeDir.resolve(getOutPath().relativize(srcPath)).resolve(srcFile.getFileName().toString().split("\\.")[0]); - } + private final Path includePath; + + public CFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) + throws IOException { + super(resource, srcGenBasePath, useHierarchicalBin); + var includeDir = getOutPath().resolve("include"); + includePath = + !useHierarchicalBin + ? includeDir + : includeDir + .resolve(getOutPath().relativize(srcPath)) + .resolve(srcFile.getFileName().toString().split("\\.")[0]); + } - public Path getIncludePath() { - return includePath; - } + public Path getIncludePath() { + return includePath; + } - public String getRuntimeIncludePath() { - return "/lib/c/reactor-c/include"; - } + public String getRuntimeIncludePath() { + return "/lib/c/reactor-c/include"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index fce667067c..e8606eee9a 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1,26 +1,26 @@ /************* -Copyright (c) 2019-2021, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2021, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator.c; @@ -34,6 +34,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import static org.lflang.ast.ASTUtils.toText; import static org.lflang.util.StringUtil.addDoubleQuotes; +import com.google.common.collect.Iterables; import java.io.File; import java.io.IOException; import java.nio.file.Files; @@ -46,34 +47,27 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.StringExtensions; - -import org.lflang.ast.ASTUtils; -import org.lflang.generator.CodeMap; -import org.lflang.generator.DockerComposeGenerator; import org.lflang.FileConfig; import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty; import org.lflang.TargetProperty.Platform; - -import org.lflang.federated.extensions.CExtensionUtils; - +import org.lflang.ast.ASTUtils; import org.lflang.ast.DelayedConnectionTransformation; - +import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.ActionInstance; import org.lflang.generator.CodeBuilder; +import org.lflang.generator.CodeMap; +import org.lflang.generator.DelayBodyGenerator; +import org.lflang.generator.DockerComposeGenerator; import org.lflang.generator.DockerGenerator; import org.lflang.generator.GeneratorBase; import org.lflang.generator.GeneratorResult; import org.lflang.generator.GeneratorUtils; - -import org.lflang.generator.DelayBodyGenerator; - import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFResource; import org.lflang.generator.ParameterInstance; @@ -99,165 +93,156 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; -import com.google.common.collect.Iterables; - /** - * Generator for C target. This class generates C code defining each reactor - * class given in the input .lf file and imported .lf files. The generated code - * has the following components: + * Generator for C target. This class generates C code defining each reactor class given in the + * input .lf file and imported .lf files. The generated code has the following components: + * *
      - *
    • A typedef for inputs, outputs, and actions of each reactor class. These - * define the types of the variables that reactions use to access inputs and - * action values and to set output values.
      • - *
    • A typedef for a "self" struct for each reactor class. One instance of this - * struct will be created for each reactor instance. See below for details.
      • - *
    • A function definition for each reaction in each reactor class. These - * functions take an instance of the self struct as an argument.
      • - *
    • A constructor function for each reactor class. This is used to create - * a new instance of the reactor. - * After these, the main generated function is _lf_initialize_trigger_objects(). - * This function creates the instances of reactors (using their constructors) - * and makes connections between them. - * A few other smaller functions are also generated.

      Self Struct

      - * The "self" struct has fields for each of the following:
      • - *
    • parameter: the field name and type match the parameter.
      • - *
    • state: the field name and type match the state.
      • - *
    • action: the field name prepends the action name with "lf". - * A second field for the action is also created to house the trigger_t object. - * That second field prepends the action name with "_lf__".
      • - *
    • output: the field name prepends the output name with "lf".
      • - *
    • input: the field name prepends the output name with "lf". - * A second field for the input is also created to house the trigger_t object. - * That second field prepends the input name with "_lf__". - * If, in addition, the reactor contains other reactors and reacts to their outputs, - * then there will be a struct within the self struct for each such contained reactor. - * The name of that self struct will be the name of the contained reactor prepended with "lf". - * That inside struct will contain pointers the outputs of the contained reactors - * that are read together with pointers to booleans indicating whether those outputs are present. - * If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to - * trigger_t object (see reactor.h) for the shutdown event and an action struct named - * _lf_shutdown on the self struct.

      Reaction Functions

      - * For each reaction in a reactor class, this generator will produce a C function - * that expects a pointer to an instance of the "self" struct as an argument. - * This function will contain verbatim the C code specified in the reaction, but - * before that C code, the generator inserts a few lines of code that extract from the - * self struct the variables that that code has declared it will use. For example, if - * the reaction declares that it is triggered by or uses an input named "x" of type - * int, the function will contain a line like this:
        r_x_t* x = self->_lf_x;
- *
      where r is the full name of the reactor class and the struct type r_x_t - * has fields is_present and value, where the type of value matches the port type. - * If the programmer fails to declare that it uses x, then the absence of the - * above code will trigger a compile error when the verbatim code attempts to read x.

      Constructor

      - * For each reactor class, this generator will create a constructor function named - * new_r, where r is the reactor class name. This function will malloc and return - * a pointer to an instance of the "self" struct. This struct initially represents - * an unconnected reactor. To establish connections between reactors, additional - * information needs to be inserted (see below). The self struct is made visible - * to the body of a reaction as a variable named "self". The self struct contains the - * following:
      • - *
    • Parameters: For each parameter p of the reactor, there will be a field p - * with the type and value of the parameter. So C code in the body of a reaction - * can access parameter values as self->p.
      • - *
    • State variables: For each state variable s of the reactor, there will be a field s - * with the type and value of the state variable. So C code in the body of a reaction - * can access state variables as self->s. - * The self struct also contains various fields that the user is not intended to - * use. The names of these fields begin with at least two underscores. They are:
      • - *
    • Outputs: For each output named out, there will be a field _lf_out that is - * a struct containing a value field whose type matches that of the output. - * The output value is stored here. That struct also has a field is_present - * that is a boolean indicating whether the output has been set. - * This field is reset to false at the start of every time - * step. There is also a field num_destinations whose value matches the - * number of downstream reactors that use this variable. This field must be - * set when connections are made or changed. It is used to determine for - * a mutable input destination whether a copy needs to be made.
      • - *
    • Inputs: For each input named in of type T, there is a field named _lf_in - * that is a pointer struct with a value field of type T. The struct pointed - * to also has an is_present field of type bool that indicates whether the - * input is present.
      • - *
    • Outputs of contained reactors: If a reactor reacts to outputs of a - * contained reactor r, then the self struct will contain a nested struct - * named _lf_r that has fields pointing to those outputs. For example, - * if r has an output out of type T, then there will be field in _lf_r - * named out that points to a struct containing a value field - * of type T and a field named is_present of type bool.
      • - *
    • Inputs of contained reactors: If a reactor sends to inputs of a - * contained reactor r, then the self struct will contain a nested struct - * named _lf_r that has fields for storing the values provided to those - * inputs. For example, if R has an input in of type T, then there will - * be field in _lf_R named in that is a struct with a value field - * of type T and a field named is_present of type bool.
      • - *
    • Actions: If the reactor has an action a (logical or physical), then there - * will be a field in the self struct named _lf_a and another named _lf__a. - * The type of the first is specific to the action and contains a value - * field with the type and value of the action (if it has a value). That - * struct also has a has_value field, an is_present field, and a - * token field (which is NULL if the action carries no value). - * The _lf__a field is of type trigger_t. - * That struct contains various things, including an array of reactions - * sensitive to this trigger and a lf_token_t struct containing the value of - * the action, if it has a value. See reactor.h in the C library for - * details.
      • - *
    • Reactions: Each reaction will have several fields in the self struct. - * Each of these has a name that begins with _lf__reaction_i, where i is - * the number of the reaction, starting with 0. The fields are:
        - *
      • _lf__reaction_i: The struct that is put onto the reaction queue to - * execute the reaction (see reactor.h in the C library).
        • - *
      • Timers: For each timer t, there is are two fields in the self struct:
          - *
        • _lf__t: The trigger_t struct for this timer (see reactor.h).
          • - *
        • _lf__t_reactions: An array of reactions (pointers to the - * reaction_t structs on this self struct) sensitive to this timer.
          • - *
        - *
        • - *
      - *
      • - *
    • Triggers: For each Timer, Action, Input, and Output of a contained - * reactor that triggers reactions, there will be a trigger_t struct - * on the self struct with name _lf__t, where t is the name of the trigger.

      Connections Between Reactors

      - * Establishing connections between reactors involves two steps. - * First, each destination (e.g. an input port) must have pointers to - * the source (the output port). As explained above, for an input named - * in, the field _lf_in->value is a pointer to the output data being read. - * In addition, _lf_in->is_present is a pointer to the corresponding - * out->is_present field of the output reactor's self struct. - * In addition, the reaction_i struct on the self struct has a triggers - * field that records all the trigger_t structs for ports and actions - * that are triggered by the i-th reaction. The triggers field is - * an array of arrays of pointers to trigger_t structs. - * The length of the outer array is the number of output channels - * (single ports plus multiport widths) that the reaction effects - * plus the number of input port channels of contained - * reactors that it effects. Each inner array has a length equal to the - * number of final destinations of that output channel or input channel. - * The reaction_i struct has an array triggered_sizes that indicates - * the sizes of these inner arrays. The num_outputs field of the - * reaction_i struct gives the length of the triggered_sizes and - * (outer) triggers arrays. The num_outputs field is equal to the - * total number of single ports and multiport channels that the reaction - * writes to.

      Runtime Tables

      - * This generator creates an populates the following tables used at run time. - * These tables may have to be resized and adjusted when mutations occur.
      • - *
    • _lf_is_present_fields: An array of pointers to booleans indicating whether an - * event is present. The _lf_start_time_step() function in reactor_common.c uses - * this to mark every event absent at the start of a time step. The size of this - * table is contained in the variable _lf_is_present_fields_size.
        - *
      • This table is accompanied by another list, _lf_is_present_fields_abbreviated, - * which only contains the is_present fields that have been set to true in the - * current tag. This list can allow a performance improvement if most ports are - * seldom present because only fields that have been set to true need to be - * reset to false.
        • - *
      - *
      • - *
    • _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown - * reactions. The length of this table is in the _lf_shutdown_triggers_size - * variable.
      • - *
    • _lf_timer_triggers: An array of pointers to trigger_t structs for timers that - * need to be started when the program runs. The length of this table is in the - * _lf_timer_triggers_size variable.
      • - *
    • _lf_action_table: For a federated execution, each federate will have this table - * that maps port IDs to the corresponding action struct, which can be cast to - * action_base_t.
      • + *
    • A typedef for inputs, outputs, and actions of each reactor class. These define the types of + * the variables that reactions use to access inputs and action values and to set output + * values. + *
    • A typedef for a "self" struct for each reactor class. One instance of this struct + * will be created for each reactor instance. See below for details. + *
    • A function definition for each reaction in each reactor class. These functions take an + * instance of the self struct as an argument. + *
    • A constructor function for each reactor class. This is used to create a new instance of the + * reactor. After these, the main generated function is _lf_initialize_trigger_objects() + * . This function creates the instances of reactors (using their constructors) and + * makes connections between them. A few other smaller functions are also generated. + *

      Self Struct

      + * The "self" struct has fields for each of the following: + *
    • parameter: the field name and type match the parameter. + *
    • state: the field name and type match the state. + *
    • action: the field name prepends the action name with "lf". A second + * field for the action is also created to house the trigger_t object. That second field + * prepends the action name with "_lf__". + *
    • output: the field name prepends the output name with "lf". + *
    • input: the field name prepends the output name with "lf". A second field + * for the input is also created to house the trigger_t object. That second field prepends the + * input name with "_lf__". If, in addition, the reactor contains other reactors and + * reacts to their outputs, then there will be a struct within the self struct for each such + * contained reactor. The name of that self struct will be the name of the contained reactor + * prepended with "lf". That inside struct will contain pointers the + * outputs of the contained reactors that are read together with pointers to booleans + * indicating whether those outputs are present. If, in addition, the reactor has a reaction + * to shutdown, then there will be a pointer to trigger_t object (see reactor.h) for the + * shutdown event and an action struct named _lf_shutdown on the self struct. + *

      Reaction Functions

      + * For each reaction in a reactor class, this generator will produce a C function that expects + * a pointer to an instance of the "self" struct as an argument. This function will + * contain verbatim the C code specified in the reaction, but before that C code, the + * generator inserts a few lines of code that extract from the self struct the variables that + * that code has declared it will use. For example, if the reaction declares that it is + * triggered by or uses an input named "x" of type int, the function will contain a + * line like this: + * 
        r_x_t* x = self->_lf_x;
+ *
      + * where r is the full name of the reactor class and the struct type r_x_t + * has fields is_present and value, where the type of + * value matches the port type. If the programmer fails to declare that it uses x, then + * the absence of the above code will trigger a compile error when the verbatim code attempts + * to read x. + *

      Constructor

      + * For each reactor class, this generator will create a constructor function named new_r + * , where r is the reactor class name. This function will malloc and + * return a pointer to an instance of the "self" struct. This struct initially + * represents an unconnected reactor. To establish connections between reactors, additional + * information needs to be inserted (see below). The self struct is made visible to the body + * of a reaction as a variable named "self". The self struct contains the following: + *
    • Parameters: For each parameter p of the reactor, there will be a field p + * with the type and value of the parameter. So C code in the body of a reaction can + * access parameter values as self->p. + *
    • State variables: For each state variable s of the reactor, there will be a + * field s with the type and value of the state variable. So C code in the body + * of a reaction can access state variables as self->s. The self struct also + * contains various fields that the user is not intended to use. The names of these fields + * begin with at least two underscores. They are: + *
    • Outputs: For each output named out, there will be a field _lf_out + * that is a struct containing a value field whose type matches that of the output. The output + * value is stored here. That struct also has a field is_present that is a + * boolean indicating whether the output has been set. This field is reset to false at the + * start of every time step. There is also a field num_destinations whose value + * matches the number of downstream reactors that use this variable. This field must be set + * when connections are made or changed. It is used to determine for a mutable input + * destination whether a copy needs to be made. + *
    • Inputs: For each input named in of type T, there is a field named _lf_in + * that is a pointer struct with a value field of type T. The struct pointed to also + * has an is_present field of type bool that indicates whether the input is + * present. + *
    • Outputs of contained reactors: If a reactor reacts to outputs of a contained reactor + * r, then the self struct will contain a nested struct named _lf_r that + * has fields pointing to those outputs. For example, if r has an output + * out of type T, then there will be field in _lf_r named out + * that points to a struct containing a value field of type T and a field named + * is_present of type bool. + *
    • Inputs of contained reactors: If a reactor sends to inputs of a contained reactor r + * , then the self struct will contain a nested struct named _lf_r that + * has fields for storing the values provided to those inputs. For example, if R has an input + * in of type T, then there will be field in _lf_R named in that is + * a struct with a value field of type T and a field named is_present of type + * bool. + *
    • Actions: If the reactor has an action a (logical or physical), then there will be a field + * in the self struct named _lf_a and another named _lf__a. The type + * of the first is specific to the action and contains a value field with the + * type and value of the action (if it has a value). That struct also has a has_value + * field, an is_present field, and a token field (which is + * NULL if the action carries no value). The _lf__a field is of type trigger_t. + * That struct contains various things, including an array of reactions sensitive to this + * trigger and a lf_token_t struct containing the value of the action, if it has a value. See + * reactor.h in the C library for details. + *
    • Reactions: Each reaction will have several fields in the self struct. Each of these has a + * name that begins with _lf__reaction_i, where i is the number of the reaction, + * starting with 0. The fields are: + *
        + *
      • _lf__reaction_i: The struct that is put onto the reaction queue to execute the + * reaction (see reactor.h in the C library). + *
      • Timers: For each timer t, there is are two fields in the self struct: + *
          + *
        • _lf__t: The trigger_t struct for this timer (see reactor.h). + *
        • _lf__t_reactions: An array of reactions (pointers to the reaction_t structs on + * this self struct) sensitive to this timer. + *
        + *
      + *
    • Triggers: For each Timer, Action, Input, and Output of a contained reactor that triggers + * reactions, there will be a trigger_t struct on the self struct with name _lf__t + * , where t is the name of the trigger. + *

      Connections Between Reactors

      + * Establishing connections between reactors involves two steps. First, each destination (e.g. + * an input port) must have pointers to the source (the output port). As explained above, for + * an input named in, the field _lf_in->value is a pointer to the + * output data being read. In addition, _lf_in->is_present is a pointer to the + * corresponding out->is_present field of the output reactor's self + * struct. In addition, the reaction_i struct on the self struct has a + * triggers field that records all the trigger_t structs for ports and actions that are + * triggered by the i-th reaction. The triggers field is an array of arrays of pointers to + * trigger_t structs. The length of the outer array is the number of output channels (single + * ports plus multiport widths) that the reaction effects plus the number of input port + * channels of contained reactors that it effects. Each inner array has a length equal to the + * number of final destinations of that output channel or input channel. The reaction_i struct + * has an array triggered_sizes that indicates the sizes of these inner arrays. The + * num_outputs field of the reaction_i struct gives the length of the triggered_sizes and + * (outer) triggers arrays. The num_outputs field is equal to the total number of single ports + * and multiport channels that the reaction writes to. + *

      Runtime Tables

      + * This generator creates an populates the following tables used at run time. These tables may + * have to be resized and adjusted when mutations occur. + *
    • _lf_is_present_fields: An array of pointers to booleans indicating whether an event is + * present. The _lf_start_time_step() function in reactor_common.c uses this to mark every + * event absent at the start of a time step. The size of this table is contained in the + * variable _lf_is_present_fields_size. + *
        + *
      • This table is accompanied by another list, _lf_is_present_fields_abbreviated, which + * only contains the is_present fields that have been set to true in the current tag. + * This list can allow a performance improvement if most ports are seldom present + * because only fields that have been set to true need to be reset to false. + *
      + *
    • _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown reactions. + * The length of this table is in the _lf_shutdown_triggers_size variable. + *
    • _lf_timer_triggers: An array of pointers to trigger_t structs for timers that need to be + * started when the program runs. The length of this table is in the _lf_timer_triggers_size + * variable. + *
    • _lf_action_table: For a federated execution, each federate will have this table that maps + * port IDs to the corresponding action struct, which can be cast to action_base_t. *
    * * @author Edward A. Lee @@ -273,1153 +258,1164 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY @SuppressWarnings("StaticPseudoFunctionalStyleMethod") public class CGenerator extends GeneratorBase { - // Regular expression pattern for compiler error messages with resource - // and line number information. The first match will a resource URI in the - // form of "file:/path/file.lf". The second match will be a line number. - // The third match is a character position within the line. - // The fourth match will be the error message. - static final Pattern compileErrorPattern = Pattern.compile( - "^(?.*):(?\\d+):(?\\d+):(?.*)$" - ); - - public static int UNDEFINED_MIN_SPACING = -1; - - //////////////////////////////////////////// - //// Protected fields - - /** The main place to put generated code. */ - protected CodeBuilder code = new CodeBuilder(); - - /** Place to collect code to initialize the trigger objects for all reactor instances. */ - protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); - - protected final CFileConfig fileConfig; - - /** - * Count of the number of is_present fields of the self struct that - * need to be reinitialized in _lf_start_time_step(). - */ - protected int startTimeStepIsPresentCount = 0; - - //////////////////////////////////////////// - //// Private fields - /** - * Extra lines that need to go into the generated CMakeLists.txt. - */ - private final String cMakeExtras = ""; - - /** Place to collect code to execute at the start of a time step. */ - private final CodeBuilder startTimeStep = new CodeBuilder(); - - /** Count of the number of token pointers that need to have their - * reference count decremented in _lf_start_time_step(). - */ - private int timerCount = 0; - private int startupReactionCount = 0; - private int shutdownReactionCount = 0; - private int resetReactionCount = 0; - private int modalReactorCount = 0; - private int modalStateResetCount = 0; - private int watchdogCount = 0; - - // Indicate whether the generator is in Cpp mode or not - private final boolean CCppMode; - - private final CTypes types; - - private final CCmakeGenerator cmakeGenerator; - - protected CGenerator( - LFGeneratorContext context, - boolean CCppMode, - CTypes types, - CCmakeGenerator cmakeGenerator, - DelayBodyGenerator delayBodyGenerator - ) { - super(context); - this.fileConfig = (CFileConfig) context.getFileConfig(); - this.CCppMode = CCppMode; - this.types = types; - this.cmakeGenerator = cmakeGenerator; - - // Register the delayed connection transformation to be applied by GeneratorBase. - // transform both after delays and physical connections - registerTransformation(new DelayedConnectionTransformation(delayBodyGenerator, types, fileConfig.resource, true, true)); + // Regular expression pattern for compiler error messages with resource + // and line number information. The first match will a resource URI in the + // form of "file:/path/file.lf". The second match will be a line number. + // The third match is a character position within the line. + // The fourth match will be the error message. + static final Pattern compileErrorPattern = + Pattern.compile("^(?.*):(?\\d+):(?\\d+):(?.*)$"); + + public static int UNDEFINED_MIN_SPACING = -1; + + //////////////////////////////////////////// + //// Protected fields + + /** The main place to put generated code. */ + protected CodeBuilder code = new CodeBuilder(); + + /** Place to collect code to initialize the trigger objects for all reactor instances. */ + protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); + + protected final CFileConfig fileConfig; + + /** + * Count of the number of is_present fields of the self struct that need to be reinitialized in + * _lf_start_time_step(). + */ + protected int startTimeStepIsPresentCount = 0; + + //////////////////////////////////////////// + //// Private fields + /** Extra lines that need to go into the generated CMakeLists.txt. */ + private final String cMakeExtras = ""; + + /** Place to collect code to execute at the start of a time step. */ + private final CodeBuilder startTimeStep = new CodeBuilder(); + + /** + * Count of the number of token pointers that need to have their reference count decremented in + * _lf_start_time_step(). + */ + private int timerCount = 0; + + private int startupReactionCount = 0; + private int shutdownReactionCount = 0; + private int resetReactionCount = 0; + private int modalReactorCount = 0; + private int modalStateResetCount = 0; + private int watchdogCount = 0; + + // Indicate whether the generator is in Cpp mode or not + private final boolean CCppMode; + + private final CTypes types; + + private final CCmakeGenerator cmakeGenerator; + + protected CGenerator( + LFGeneratorContext context, + boolean CCppMode, + CTypes types, + CCmakeGenerator cmakeGenerator, + DelayBodyGenerator delayBodyGenerator) { + super(context); + this.fileConfig = (CFileConfig) context.getFileConfig(); + this.CCppMode = CCppMode; + this.types = types; + this.cmakeGenerator = cmakeGenerator; + + // Register the delayed connection transformation to be applied by GeneratorBase. + // transform both after delays and physical connections + registerTransformation( + new DelayedConnectionTransformation( + delayBodyGenerator, types, fileConfig.resource, true, true)); + } + + public CGenerator(LFGeneratorContext context, boolean ccppMode) { + this( + context, + ccppMode, + new CTypes(), + new CCmakeGenerator(context.getFileConfig(), List.of()), + new CDelayBodyGenerator(new CTypes())); + } + + /** + * Look for physical actions in all resources. If found, set threads to be at least one to allow + * asynchronous schedule calls. + */ + public void accommodatePhysicalActionsIfPresent() { + // If there are any physical actions, ensure the threaded engine is used and that + // keepalive is set to true, unless the user has explicitly set it to false. + for (Resource resource : GeneratorUtils.getResources(reactors)) { + for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { + if (ActionOrigin.PHYSICAL.equals(action.getOrigin())) { + // If the unthreaded runtime is not requested by the user, use the threaded runtime + // instead + // because it is the only one currently capable of handling asynchronous events. + if (!targetConfig.threading + && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = true; + errorReporter.reportWarning( + action, + "Using the threaded C runtime to allow for asynchronous handling of physical action" + + " " + + action.getName()); + return; + } + } + } } - - public CGenerator(LFGeneratorContext context, boolean ccppMode) { - this( - context, - ccppMode, - new CTypes(), - new CCmakeGenerator(context.getFileConfig(), List.of()), - new CDelayBodyGenerator(new CTypes()) - ); + } + + /** + * Return true if the host operating system is compatible and otherwise report an error and return + * false. + */ + protected boolean isOSCompatible() { + if (GeneratorUtils.isHostWindows()) { + if (CCppMode) { + errorReporter.reportError( + "LF programs with a CCpp target are currently not supported on Windows. " + + "Exiting code generation."); + return false; + } } + return true; + } + + /** + * Generate C code from the Lingua Franca model contained by the specified resource. This is the + * main entry point for code generation. + * + * @param resource The resource containing the source code. + * @param context The context in which the generator is invoked, including whether it is cancelled + * and whether it is a standalone context + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + super.doGenerate(resource, context); + if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; + if (!isOSCompatible()) return; // Incompatible OS and configuration - /** - * Look for physical actions in all resources. - * If found, set threads to be at least one to allow asynchronous schedule calls. - */ - public void accommodatePhysicalActionsIfPresent() { - // If there are any physical actions, ensure the threaded engine is used and that - // keepalive is set to true, unless the user has explicitly set it to false. - for (Resource resource : GeneratorUtils.getResources(reactors)) { - for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { - if (ActionOrigin.PHYSICAL.equals(action.getOrigin())) { - // If the unthreaded runtime is not requested by the user, use the threaded runtime instead - // because it is the only one currently capable of handling asynchronous events. - if (!targetConfig.threading && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = true; - errorReporter.reportWarning( - action, - "Using the threaded C runtime to allow for asynchronous handling of physical action " + - action.getName() - ); - return; - } - } - } - } + // Perform set up that does not generate code + setUpGeneralParameters(); + + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); + handleProtoFiles(); + + // Derive target filename from the .lf filename. + var lfModuleName = fileConfig.name; + var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); + var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; + try { + generateCodeFor(lfModuleName); + copyTargetFiles(); + generateHeaders(); + code.writeToFile(targetFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); } - /** - * Return true if the host operating system is compatible and - * otherwise report an error and return false. - */ - protected boolean isOSCompatible() { - if (GeneratorUtils.isHostWindows()) { - if (CCppMode) { - errorReporter.reportError( - "LF programs with a CCpp target are currently not supported on Windows. " + - "Exiting code generation." - ); - return false; - } - } - return true; + // Create docker file. + if (targetConfig.dockerOptions != null && mainDef != null) { + try { + var dockerData = getDockerGenerator(context).generateDockerData(); + dockerData.writeDockerFile(); + (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); + } catch (IOException e) { + throw new RuntimeException("Error while writing Docker files", e); + } } - /** - * Generate C code from the Lingua Franca model contained by the - * specified resource. This is the main entry point for code - * generation. - * @param resource The resource containing the source code. - * @param context The context in which the generator is - * invoked, including whether it is cancelled and - * whether it is a standalone context - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - super.doGenerate(resource, context); - if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; - if (!isOSCompatible()) return; // Incompatible OS and configuration - - // Perform set up that does not generate code - setUpGeneralParameters(); - - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); - handleProtoFiles(); - - // Derive target filename from the .lf filename. - var lfModuleName = fileConfig.name; - var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); - var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; - try { - generateCodeFor(lfModuleName); - copyTargetFiles(); - generateHeaders(); - code.writeToFile(targetFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - - // Create docker file. - if (targetConfig.dockerOptions != null && mainDef != null) { - try { - var dockerData = getDockerGenerator(context).generateDockerData(); - dockerData.writeDockerFile(); - (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); - } catch (IOException e) { - throw new RuntimeException("Error while writing Docker files", e); - } - } - - // If cmake is requested, generate the CMakeLists.txt - if (targetConfig.platformOptions.platform != Platform.ARDUINO) { - var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; - var sources = allTypeParameterizedReactors() - .map(CUtil::getName) - .map(it -> it + (CCppMode ? ".cpp" : ".c")) - .collect(Collectors.toCollection(ArrayList::new)); - sources.add(cFilename); - var cmakeCode = cmakeGenerator.generateCMakeCode( - sources, - lfModuleName, - errorReporter, - CCppMode, - mainDef != null, - cMakeExtras, - targetConfig - ); - try { - cmakeCode.writeToFile(cmakeFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - } else { - try { - Path include = fileConfig.getSrcGenPath().resolve("include/"); - Path src = fileConfig.getSrcGenPath().resolve("src/"); - FileUtil.arduinoDeleteHelper(src, targetConfig.threading); - FileUtil.relativeIncludeHelper(src, include); - FileUtil.relativeIncludeHelper(include, include); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - if (!targetConfig.noCompile) { - ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); - arduinoUtil.buildArduino(fileConfig, targetConfig); - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } else { - System.out.println("********"); - System.out.println("To compile your program, run the following command to see information about the board you plugged in:\n\n\tarduino-cli board list\n\nGrab the FQBN and PORT from the command and run the following command in the generated sources directory:\n\n\tarduino-cli compile -b --build-property compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\nTo flash/upload your generated sketch to the board, run the following command in the generated sources directory:\n\n\tarduino-cli upload -b -p \n"); - // System.out.println("For a list of all boards installed on your computer, you can use the following command:\n\n\tarduino-cli board listall\n"); - context.finish( - GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null) - ); - } - GeneratorUtils.refreshProject(resource, context.getMode()); - return; - } - - // Dump the additional compile definitions to a file to keep the generated project - // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can - // take over and do the rest of compilation. - try { - String compileDefs = targetConfig.compileDefinitions.keySet().stream() - .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) - .collect(Collectors.joining("\n")) + "\n"; - FileUtil.writeToFile( - compileDefs, - Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt") - ); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + // If cmake is requested, generate the CMakeLists.txt + if (targetConfig.platformOptions.platform != Platform.ARDUINO) { + var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; + var sources = + allTypeParameterizedReactors() + .map(CUtil::getName) + .map(it -> it + (CCppMode ? ".cpp" : ".c")) + .collect(Collectors.toCollection(ArrayList::new)); + sources.add(cFilename); + var cmakeCode = + cmakeGenerator.generateCMakeCode( + sources, + lfModuleName, + errorReporter, + CCppMode, + mainDef != null, + cMakeExtras, + targetConfig); + try { + cmakeCode.writeToFile(cmakeFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + } else { + try { + Path include = fileConfig.getSrcGenPath().resolve("include/"); + Path src = fileConfig.getSrcGenPath().resolve("src/"); + FileUtil.arduinoDeleteHelper(src, targetConfig.threading); + FileUtil.relativeIncludeHelper(src, include); + FileUtil.relativeIncludeHelper(include, include); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + if (!targetConfig.noCompile) { + ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); + arduinoUtil.buildArduino(fileConfig, targetConfig); + context.finish(GeneratorResult.Status.COMPILED, null); + } else { + System.out.println("********"); + System.out.println( + "To compile your program, run the following command to see information about the board" + + " you plugged in:\n\n" + + "\tarduino-cli board list\n\n" + + "Grab the FQBN and PORT from the command and run the following command in the" + + " generated sources directory:\n\n" + + "\tarduino-cli compile -b --build-property" + + " compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" + + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property" + + " compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" + + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\n" + + "To flash/upload your generated sketch to the board, run the following command in" + + " the generated sources directory:\n\n" + + "\tarduino-cli upload -b -p \n"); + // System.out.println("For a list of all boards installed on your computer, you can use the + // following command:\n\n\tarduino-cli board listall\n"); + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + } + GeneratorUtils.refreshProject(resource, context.getMode()); + return; + } - // Create a .vscode/settings.json file in the target directory so that VSCode can - // immediately compile the generated code. - try { - String compileDefs = targetConfig.compileDefinitions.keySet().stream() - .map(key -> "\"-D" + key + "=" + targetConfig.compileDefinitions.get(key) + "\"") - .collect(Collectors.joining(",\n")); - String settings = "{\n" - + "\"cmake.configureArgs\": [\n" - + compileDefs - + "\n]\n}\n"; - Path vscodePath = Path.of(fileConfig.getSrcGenPath() + File.separator + ".vscode"); - if (!Files.exists(vscodePath)) - Files.createDirectory(vscodePath); - FileUtil.writeToFile( - settings, - Path.of(fileConfig.getSrcGenPath() - + File.separator + ".vscode" - + File.separator + "settings.json") - ); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + // Dump the additional compile definitions to a file to keep the generated project + // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can + // take over and do the rest of compilation. + try { + String compileDefs = + targetConfig.compileDefinitions.keySet().stream() + .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) + .collect(Collectors.joining("\n")) + + "\n"; + FileUtil.writeToFile( + compileDefs, + Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt")); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } - // If this code generator is directly compiling the code, compile it now so that we - // clean it up after, removing the #line directives after errors have been reported. - if ( - !targetConfig.noCompile && targetConfig.dockerOptions == null - && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) - // This code is unreachable in LSP_FAST mode, so that check is omitted. - && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM - ) { - // FIXME: Currently, a lack of main is treated as a request to not produce - // a binary and produce a .o file instead. There should be a way to control - // this. - // Create an anonymous Runnable class and add it to the compileThreadPool - // so that compilation can happen in parallel. - var cleanCode = code.removeLines("#line"); - - var execName = lfModuleName; - var threadFileConfig = fileConfig; - var generator = this; // FIXME: currently only passed to report errors with line numbers in the Eclipse IDE - var CppMode = CCppMode; - // generatingContext.reportProgress( - // String.format("Generated code for %d/%d executables. Compiling...", federateCount, federates.size()), - // 100 * federateCount / federates.size() - // ); // FIXME: Move to FedGenerator - // Create the compiler to be used later - - var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); - try { - if (!cCompiler.runCCompiler(generator, context)) { - // If compilation failed, remove any bin files that may have been created. - CUtil.deleteBinFiles(threadFileConfig); - // If finish has already been called, it is illegal and makes no sense. However, - // if finish has already been called, then this must be a federated execution. - context.unsuccessfulFinish(); - } else { - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } - cleanCode.writeToFile(targetFile); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } - } + // Create a .vscode/settings.json file in the target directory so that VSCode can + // immediately compile the generated code. + try { + String compileDefs = + targetConfig.compileDefinitions.keySet().stream() + .map(key -> "\"-D" + key + "=" + targetConfig.compileDefinitions.get(key) + "\"") + .collect(Collectors.joining(",\n")); + String settings = "{\n" + "\"cmake.configureArgs\": [\n" + compileDefs + "\n]\n}\n"; + Path vscodePath = Path.of(fileConfig.getSrcGenPath() + File.separator + ".vscode"); + if (!Files.exists(vscodePath)) Files.createDirectory(vscodePath); + FileUtil.writeToFile( + settings, + Path.of( + fileConfig.getSrcGenPath() + + File.separator + + ".vscode" + + File.separator + + "settings.json")); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } - // If a build directive has been given, invoke it now. - // Note that the code does not get cleaned in this case. - if (!targetConfig.noCompile) { - if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { - CUtil.runBuildCommand( - fileConfig, - targetConfig, - commandFactory, - errorReporter, - this::reportCommandErrors, - context.getMode() - ); - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } - if (!errorsOccurred()){ - System.out.println("Compiled binary is in " + fileConfig.binPath); - } + // If this code generator is directly compiling the code, compile it now so that we + // clean it up after, removing the #line directives after errors have been reported. + if (!targetConfig.noCompile + && targetConfig.dockerOptions == null + && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) + // This code is unreachable in LSP_FAST mode, so that check is omitted. + && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM) { + // FIXME: Currently, a lack of main is treated as a request to not produce + // a binary and produce a .o file instead. There should be a way to control + // this. + // Create an anonymous Runnable class and add it to the compileThreadPool + // so that compilation can happen in parallel. + var cleanCode = code.removeLines("#line"); + + var execName = lfModuleName; + var threadFileConfig = fileConfig; + var generator = + this; // FIXME: currently only passed to report errors with line numbers in the Eclipse + // IDE + var CppMode = CCppMode; + // generatingContext.reportProgress( + // String.format("Generated code for %d/%d executables. Compiling...", federateCount, + // federates.size()), + // 100 * federateCount / federates.size() + // ); // FIXME: Move to FedGenerator + // Create the compiler to be used later + + var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); + try { + if (!cCompiler.runCCompiler(generator, context)) { + // If compilation failed, remove any bin files that may have been created. + CUtil.deleteBinFiles(threadFileConfig); + // If finish has already been called, it is illegal and makes no sense. However, + // if finish has already been called, then this must be a federated execution. + context.unsuccessfulFinish(); } else { - context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + context.finish(GeneratorResult.Status.COMPILED, null); } + cleanCode.writeToFile(targetFile); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } + } - // In case we are in Eclipse, make sure the generated code is visible. - GeneratorUtils.refreshProject(resource, context.getMode()); + // If a build directive has been given, invoke it now. + // Note that the code does not get cleaned in this case. + if (!targetConfig.noCompile) { + if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { + CUtil.runBuildCommand( + fileConfig, + targetConfig, + commandFactory, + errorReporter, + this::reportCommandErrors, + context.getMode()); + context.finish(GeneratorResult.Status.COMPILED, null); + } + if (!errorsOccurred()) { + System.out.println("Compiled binary is in " + fileConfig.binPath); + } + } else { + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); } - private void generateCodeFor( - String lfModuleName - ) throws IOException { - startTimeStepIsPresentCount = 0; - code.pr(generateDirectives()); - code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); - // Generate code for each reactor. - generateReactorDefinitions(); - - // Generate main instance, if there is one. - // Note that any main reactors in imported files are ignored. - // Skip generation if there are cycles. - if (main != null) { - initializeTriggerObjects.pr(String.join("\n", - "int _lf_startup_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", - "int _lf_shutdown_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", - "int _lf_reset_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", - "int _lf_timer_triggers_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", - "int bank_index;", - "SUPPRESS_UNUSED_WARNING(bank_index);", - "int watchdog_number = 0;", - "SUPPRESS_UNUSED_WARNING(watchdog_number);")); - // Add counters for modal initialization - initializeTriggerObjects.pr(CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); - - // Create an array of arrays to store all self structs. - // This is needed because connections cannot be established until - // all reactor instances have self structs because ports that - // receive data reference the self structs of the originating - // reactors, which are arbitarily far away in the program graph. - generateSelfStructs(main); - generateReactorInstance(main); - - if (targetConfig.fedSetupPreamble != null) { - if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); - code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); - if (targetLanguageIsCpp()) code.pr("}"); - } + // In case we are in Eclipse, make sure the generated code is visible. + GeneratorUtils.refreshProject(resource, context.getMode()); + } + + private void generateCodeFor(String lfModuleName) throws IOException { + startTimeStepIsPresentCount = 0; + code.pr(generateDirectives()); + code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); + // Generate code for each reactor. + generateReactorDefinitions(); + + // Generate main instance, if there is one. + // Note that any main reactors in imported files are ignored. + // Skip generation if there are cycles. + if (main != null) { + initializeTriggerObjects.pr( + String.join( + "\n", + "int _lf_startup_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", + "int _lf_shutdown_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", + "int _lf_reset_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", + "int _lf_timer_triggers_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", + "int bank_index;", + "SUPPRESS_UNUSED_WARNING(bank_index);", + "int watchdog_number = 0;", + "SUPPRESS_UNUSED_WARNING(watchdog_number);")); + // Add counters for modal initialization + initializeTriggerObjects.pr( + CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); + + // Create an array of arrays to store all self structs. + // This is needed because connections cannot be established until + // all reactor instances have self structs because ports that + // receive data reference the self structs of the originating + // reactors, which are arbitarily far away in the program graph. + generateSelfStructs(main); + generateReactorInstance(main); + + if (targetConfig.fedSetupPreamble != null) { + if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); + code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); + if (targetLanguageIsCpp()) code.pr("}"); + } - // If there are timers, create a table of timers to be initialized. - code.pr(CTimerGenerator.generateDeclarations(timerCount)); - - // If there are startup reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); - - // If there are shutdown reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); - - // If there are reset reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); - - // If there are watchdogs, create a table of triggers. - code.pr(CWatchdogGenerator.generateWatchdogTable(watchdogCount)); - - // If there are modes, create a table of mode state to be checked for transitions. - code.pr(CModesGenerator.generateModeStatesTable( - hasModalReactors, - modalReactorCount, - modalStateResetCount - )); - - // Generate function to initialize the trigger objects for all reactors. - code.pr(CTriggerObjectsGenerator.generateInitializeTriggerObjects( - main, - targetConfig, - initializeTriggerObjects, - startTimeStep, - types, - lfModuleName, - startTimeStepIsPresentCount - )); - - // Generate function to trigger startup reactions for all reactors. - code.pr(CReactionGenerator.generateLfTriggerStartupReactions(startupReactionCount, hasModalReactors)); - - // Generate function to schedule timers for all reactors. - code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); - - // Generate a function that will either do nothing - // (if there is only one federate or the coordination - // is set to decentralized) or, if there are - // downstream federates, will notify the RTI - // that the specified logical time is complete. - if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) code.pr("extern \"C\""); - code.pr(String.join("\n", - "void logical_tag_complete(tag_t tag_to_send) {", - CExtensionUtils.surroundWithIfFederatedCentralized( - " _lf_logical_tag_complete(tag_to_send);" - ), - "}" - )); - - // Generate function to schedule shutdown reactions if any - // reactors have reactions to shutdown. - code.pr(CReactionGenerator.generateLfTriggerShutdownReactions(shutdownReactionCount, hasModalReactors)); - - // Generate an empty termination function for non-federated - // execution. For federated execution, an implementation is - // provided in federate.c. That implementation will resign - // from the federation and close any open sockets. - code.pr(""" + // If there are timers, create a table of timers to be initialized. + code.pr(CTimerGenerator.generateDeclarations(timerCount)); + + // If there are startup reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); + + // If there are shutdown reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); + + // If there are reset reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); + + // If there are watchdogs, create a table of triggers. + code.pr(CWatchdogGenerator.generateWatchdogTable(watchdogCount)); + + // If there are modes, create a table of mode state to be checked for transitions. + code.pr( + CModesGenerator.generateModeStatesTable( + hasModalReactors, modalReactorCount, modalStateResetCount)); + + // Generate function to initialize the trigger objects for all reactors. + code.pr( + CTriggerObjectsGenerator.generateInitializeTriggerObjects( + main, + targetConfig, + initializeTriggerObjects, + startTimeStep, + types, + lfModuleName, + startTimeStepIsPresentCount)); + + // Generate function to trigger startup reactions for all reactors. + code.pr( + CReactionGenerator.generateLfTriggerStartupReactions( + startupReactionCount, hasModalReactors)); + + // Generate function to schedule timers for all reactors. + code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); + + // Generate a function that will either do nothing + // (if there is only one federate or the coordination + // is set to decentralized) or, if there are + // downstream federates, will notify the RTI + // that the specified logical time is complete. + if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) + code.pr("extern \"C\""); + code.pr( + String.join( + "\n", + "void logical_tag_complete(tag_t tag_to_send) {", + CExtensionUtils.surroundWithIfFederatedCentralized( + " _lf_logical_tag_complete(tag_to_send);"), + "}")); + + // Generate function to schedule shutdown reactions if any + // reactors have reactions to shutdown. + code.pr( + CReactionGenerator.generateLfTriggerShutdownReactions( + shutdownReactionCount, hasModalReactors)); + + // Generate an empty termination function for non-federated + // execution. For federated execution, an implementation is + // provided in federate.c. That implementation will resign + // from the federation and close any open sockets. + code.pr( + """ #ifndef FEDERATED void terminate_execution() {} - #endif""" - ); - - - // Generate functions for modes - code.pr(CModesGenerator.generateLfInitializeModes( - hasModalReactors - )); - code.pr(CModesGenerator.generateLfHandleModeChanges( - hasModalReactors, - modalStateResetCount - )); - code.pr(CReactionGenerator.generateLfModeTriggeredReactions( - startupReactionCount, - resetReactionCount, - hasModalReactors - )); - } - } - - @Override - public void checkModalReactorSupport(boolean __) { - // Modal reactors are currently only supported for non federated applications - super.checkModalReactorSupport(true); + #endif"""); + + // Generate functions for modes + code.pr(CModesGenerator.generateLfInitializeModes(hasModalReactors)); + code.pr(CModesGenerator.generateLfHandleModeChanges(hasModalReactors, modalStateResetCount)); + code.pr( + CReactionGenerator.generateLfModeTriggeredReactions( + startupReactionCount, resetReactionCount, hasModalReactors)); } - - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - return String.join("\n", - "// Generated forwarding reaction for connections with the same destination", - "// but located in mutually exclusive modes.", - "lf_set("+dest+", "+source+"->value);" - ); - } - - /** Set the scheduler type in the target config as needed. */ - private void pickScheduler() { - // Don't use a scheduler that does not prioritize reactions based on deadlines - // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. - if (!targetConfig.schedulerType.prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - if (hasDeadlines(reactors)) { - if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { - targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; - } - } + } + + @Override + public void checkModalReactorSupport(boolean __) { + // Modal reactors are currently only supported for non federated applications + super.checkModalReactorSupport(true); + } + + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + return String.join( + "\n", + "// Generated forwarding reaction for connections with the same destination", + "// but located in mutually exclusive modes.", + "lf_set(" + dest + ", " + source + "->value);"); + } + + /** Set the scheduler type in the target config as needed. */ + private void pickScheduler() { + // Don't use a scheduler that does not prioritize reactions based on deadlines + // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. + if (!targetConfig.schedulerType.prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + if (hasDeadlines(reactors)) { + if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { + targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; } + } } + } - private boolean hasDeadlines(List reactors) { - for (Reactor reactor : reactors) { - for (Reaction reaction : allReactions(reactor)) { - if (reaction.getDeadline() != null) { - return true; - } - } + private boolean hasDeadlines(List reactors) { + for (Reactor reactor : reactors) { + for (Reaction reaction : allReactions(reactor)) { + if (reaction.getDeadline() != null) { + return true; } - return false; + } } - - /** - * Look at the 'reactor' eResource. - * If it is an imported .lf file, incorporate it into the current - * program in the following manner: - *
      - *
    • Merge its target property with {@code targetConfig}
      • - *
    • If there are any preambles, add them to the preambles of the reactor.
      • - *
    - * - */ - private void inspectReactorEResource(ReactorDecl reactor) { - // If the reactor is imported, look at the - // target definition of the .lf file in which the reactor is imported from and - // append any cmake-include. - // Check if the reactor definition is imported - if (reactor.eResource() != mainDef.getReactorClass().eResource()) { - // Find the LFResource corresponding to this eResource - LFResource lfResource = null; - for (var resource : resources) { - if (resource.getEResource() == reactor.eResource()) { - lfResource = resource; - break; - } - } - if (lfResource != null) { - // Copy the user files and cmake-includes to the src-gen path of the main .lf file - copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); - // Merge the CMake includes from the imported file into the target config - lfResource.getTargetConfig().cmakeIncludes.forEach(incl -> { - if (!this.targetConfig.cmakeIncludes.contains(incl)) { - this.targetConfig.cmakeIncludes.add(incl); - } - }); - } + return false; + } + + /** + * Look at the 'reactor' eResource. If it is an imported .lf file, incorporate it into the current + * program in the following manner: + * + *
      + *
    • Merge its target property with {@code targetConfig} + *
    • If there are any preambles, add them to the preambles of the reactor. + *
    + */ + private void inspectReactorEResource(ReactorDecl reactor) { + // If the reactor is imported, look at the + // target definition of the .lf file in which the reactor is imported from and + // append any cmake-include. + // Check if the reactor definition is imported + if (reactor.eResource() != mainDef.getReactorClass().eResource()) { + // Find the LFResource corresponding to this eResource + LFResource lfResource = null; + for (var resource : resources) { + if (resource.getEResource() == reactor.eResource()) { + lfResource = resource; + break; } + } + if (lfResource != null) { + // Copy the user files and cmake-includes to the src-gen path of the main .lf file + copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); + // Merge the CMake includes from the imported file into the target config + lfResource + .getTargetConfig() + .cmakeIncludes + .forEach( + incl -> { + if (!this.targetConfig.cmakeIncludes.contains(incl)) { + this.targetConfig.cmakeIncludes.add(incl); + } + }); + } } - - /** - * Copy all files or directories listed in the target property {@code files}, {@code cmake-include}, - * and {@code _fed_setup} into the src-gen folder of the main .lf file - * - * @param targetConfig The targetConfig to read the target properties from. - * @param fileConfig The fileConfig used to make the copy and resolve paths. - */ - @Override - protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - super.copyUserFiles(targetConfig, fileConfig); - // Must use class variable to determine destination! - var destination = this.fileConfig.getSrcGenPath(); - - FileUtil.copyFilesOrDirectories(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter, true); - - // FIXME: Unclear what the following does, but it does not appear to belong here. - if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { - try { - FileUtil.copyFile(fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), - destination.resolve(targetConfig.fedSetupPreamble)); - } catch (IOException e) { - errorReporter.reportError("Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); - } - } + } + + /** + * Copy all files or directories listed in the target property {@code files}, {@code + * cmake-include}, and {@code _fed_setup} into the src-gen folder of the main .lf file + * + * @param targetConfig The targetConfig to read the target properties from. + * @param fileConfig The fileConfig used to make the copy and resolve paths. + */ + @Override + protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + super.copyUserFiles(targetConfig, fileConfig); + // Must use class variable to determine destination! + var destination = this.fileConfig.getSrcGenPath(); + + FileUtil.copyFilesOrDirectories( + targetConfig.cmakeIncludes, destination, fileConfig, errorReporter, true); + + // FIXME: Unclear what the following does, but it does not appear to belong here. + if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { + try { + FileUtil.copyFile( + fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), + destination.resolve(targetConfig.fedSetupPreamble)); + } catch (IOException e) { + errorReporter.reportError( + "Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); + } } - - /** - * Generate code for defining all instantiated reactors. - * - * Imported reactors' original .lf file is - * incorporated in the following manner: - *
      - *
    • If there are any cmake-include files, add them to the current list - * of cmake-include files.
      • - *
    • If there are any preambles, add them to the preambles of the reactor.
      • - *
    - */ - private void generateReactorDefinitions() throws IOException { - var generatedReactors = new LinkedHashSet(); - if (this.main != null) { - resolveTemplatedTypes(this.main, this.main.tpr); - generateReactorChildren(this.main, generatedReactors); - generateReactorClass(this.main.getTypeParameterizedReactor()); - } - // do not generate code for reactors that are not instantiated + } + + /** + * Generate code for defining all instantiated reactors. + * + *

    Imported reactors' original .lf file is incorporated in the following manner: + * + *

      + *
    • If there are any cmake-include files, add them to the current list of cmake-include + * files. + *
    • If there are any preambles, add them to the preambles of the reactor. + *
    + */ + private void generateReactorDefinitions() throws IOException { + var generatedReactors = new LinkedHashSet(); + if (this.main != null) { + resolveTemplatedTypes(this.main, this.main.tpr); + generateReactorChildren(this.main, generatedReactors); + generateReactorClass(this.main.getTypeParameterizedReactor()); } - - /** - * Recursively Resolve all Templated Types of child Reactors to their respective - * concrete types - * - * @param reactorInstance The Reactor Class - * @param parentTpr {@link TypeParameterizedReactor} of Parent - */ - private void resolveTemplatedTypes(ReactorInstance reactorInstance, TypeParameterizedReactor parentTpr) { - for (var child : reactorInstance.children) { - if (parentTpr.typeArgs() != null) { - Map copy = new HashMap<>(); - child.tpr.typeArgs().forEach((literal, typename) -> { - var type = typename.getId(); - if (parentTpr.typeArgs().containsKey(type)) { - var basicType = parentTpr.typeArgs().get(type); - copy.put(literal, basicType); - } else { - // Typename is not inherited from Parent Reactor. Keep As Is! - copy.put(literal, typename); - } + // do not generate code for reactors that are not instantiated + } + + /** + * Recursively Resolve all Templated Types of child Reactors to their respective concrete types + * + * @param reactorInstance The Reactor Class + * @param parentTpr {@link TypeParameterizedReactor} of Parent + */ + private void resolveTemplatedTypes( + ReactorInstance reactorInstance, TypeParameterizedReactor parentTpr) { + for (var child : reactorInstance.children) { + if (parentTpr.typeArgs() != null) { + Map copy = new HashMap<>(); + child + .tpr + .typeArgs() + .forEach( + (literal, typename) -> { + var type = typename.getId(); + if (parentTpr.typeArgs().containsKey(type)) { + var basicType = parentTpr.typeArgs().get(type); + copy.put(literal, basicType); + } else { + // Typename is not inherited from Parent Reactor. Keep As Is! + copy.put(literal, typename); + } }); - if (!copy.isEmpty()) { // If we found some templated-types update the tpr with new map - child.tpr = new TypeParameterizedReactor(child.tpr.reactor(), copy); - } - resolveTemplatedTypes(child, child.tpr); - } - } - } - - private record TypeParameterizedReactorWithDecl(TypeParameterizedReactor tpr, ReactorDecl decl) {} - - /** Generate user-visible header files for all reactors instantiated. */ - private void generateHeaders() throws IOException { - FileUtil.deleteDirectory(fileConfig.getIncludePath()); - FileUtil.copyFromClassPath( - fileConfig.getRuntimeIncludePath(), - fileConfig.getIncludePath(), - false, - true - ); - for (TypeParameterizedReactor tpr : - (Iterable) () -> allTypeParameterizedReactors().iterator() - ) { - CReactorHeaderFileGenerator.doGenerate( - types, tpr, fileConfig, - (builder, rr, userFacing) -> { - generateAuxiliaryStructs(builder, rr, userFacing); - if (userFacing) { - rr.reactor().getInstantiations().stream() - .map(it -> new TypeParameterizedReactorWithDecl(new TypeParameterizedReactor(it), it.getReactorClass())).collect(Collectors.toSet()).forEach(it -> { - ASTUtils.allPorts(it.tpr.reactor()) - .forEach(p -> builder.pr(CPortGenerator.generateAuxiliaryStruct( - it.tpr, p, getTarget(), errorReporter, types, new CodeBuilder(), true, it.decl() - ))); - }); - } - }, - this::generateTopLevelPreambles); + if (!copy.isEmpty()) { // If we found some templated-types update the tpr with new map + child.tpr = new TypeParameterizedReactor(child.tpr.reactor(), copy); } - FileUtil.copyDirectoryContents(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + resolveTemplatedTypes(child, child.tpr); + } } - - /** - * Generate code for the children of 'reactor' that belong to 'federate'. - * Duplicates are avoided. - * - * Imported reactors' original .lf file is - * incorporated in the following manner: - *
      - *
    • If there are any cmake-include files, add them to the current list - * of cmake-include files.
      • - *
    • If there are any preambles, add them to the preambles of the reactor.
      • - *
    - * - * @param reactor Used to extract children from - */ - private void generateReactorChildren( - ReactorInstance reactor, - LinkedHashSet generatedReactors - ) throws IOException { - for (ReactorInstance r : reactor.children) { - var newTpr = r.tpr; - if (r.reactorDeclaration != null && - !generatedReactors.contains(newTpr)) { - generatedReactors.add(newTpr); - generateReactorChildren(r, generatedReactors); - inspectReactorEResource(r.reactorDeclaration); - generateReactorClass(newTpr); + } + + private record TypeParameterizedReactorWithDecl(TypeParameterizedReactor tpr, ReactorDecl decl) {} + + /** Generate user-visible header files for all reactors instantiated. */ + private void generateHeaders() throws IOException { + FileUtil.deleteDirectory(fileConfig.getIncludePath()); + FileUtil.copyFromClassPath( + fileConfig.getRuntimeIncludePath(), fileConfig.getIncludePath(), false, true); + for (TypeParameterizedReactor tpr : + (Iterable) () -> allTypeParameterizedReactors().iterator()) { + CReactorHeaderFileGenerator.doGenerate( + types, + tpr, + fileConfig, + (builder, rr, userFacing) -> { + generateAuxiliaryStructs(builder, rr, userFacing); + if (userFacing) { + rr.reactor().getInstantiations().stream() + .map( + it -> + new TypeParameterizedReactorWithDecl( + new TypeParameterizedReactor(it), it.getReactorClass())) + .collect(Collectors.toSet()) + .forEach( + it -> { + ASTUtils.allPorts(it.tpr.reactor()) + .forEach( + p -> + builder.pr( + CPortGenerator.generateAuxiliaryStruct( + it.tpr, + p, + getTarget(), + errorReporter, + types, + new CodeBuilder(), + true, + it.decl()))); + }); } - } - } - - /** - * Choose which platform files to compile with according to the OS. - * If there is no main reactor, then compilation will produce a .o file requiring further linking. - * Also, if useCmake is set to true, we don't need to add platform files. The CMakeLists.txt file - * will detect and use the appropriate platform file based on the platform that cmake is invoked on. - */ - private void pickCompilePlatform() { - var osName = System.getProperty("os.name").toLowerCase(); - // if platform target was set, use given platform instead - if (targetConfig.platformOptions.platform != Platform.AUTO) { - osName = targetConfig.platformOptions.platform.toString(); - } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { - errorReporter.reportError("Platform " + osName + " is not supported"); - } + }, + this::generateTopLevelPreambles); } - - /** - * Copy target-specific header file to the src-gen directory. - */ - protected void copyTargetFiles() throws IOException { - // Copy the core lib - String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); - Path dest = fileConfig.getSrcGenPath(); - if (targetConfig.platformOptions.platform == Platform.ARDUINO) { - dest = dest.resolve("src"); + FileUtil.copyDirectoryContents( + fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + } + + /** + * Generate code for the children of 'reactor' that belong to 'federate'. Duplicates are avoided. + * + *

    Imported reactors' original .lf file is incorporated in the following manner: + * + *

      + *
    • If there are any cmake-include files, add them to the current list of cmake-include + * files. + *
    • If there are any preambles, add them to the preambles of the reactor. + *
    + * + * @param reactor Used to extract children from + */ + private void generateReactorChildren( + ReactorInstance reactor, LinkedHashSet generatedReactors) + throws IOException { + for (ReactorInstance r : reactor.children) { + var newTpr = r.tpr; + if (r.reactorDeclaration != null && !generatedReactors.contains(newTpr)) { + generatedReactors.add(newTpr); + generateReactorChildren(r, generatedReactors); + inspectReactorEResource(r.reactorDeclaration); + generateReactorClass(newTpr); } - if (coreLib != null) { - FileUtil.copyDirectoryContents(Path.of(coreLib), dest, true); - } else { - FileUtil.copyFromClassPath( - "/lib/c/reactor-c/core", - dest, - true, - false - ); - FileUtil.copyFromClassPath( - "/lib/c/reactor-c/lib", - dest, - true, - false - ); - } - - // For the Zephyr target, copy default config and board files. - if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - FileUtil.copyFromClassPath( - "/lib/platform/zephyr/boards", - fileConfig.getSrcGenPath(), - false, - false - ); - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/prj_lf.conf", - fileConfig.getSrcGenPath(), - true - ); - - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/Kconfig", - fileConfig.getSrcGenPath(), - true - ); - } } - - //////////////////////////////////////////// - //// Code generators. - - /** - * Generate a reactor class definition for the specified federate. - * A class definition has four parts: - * - *
      - *
    • Preamble code, if any, specified in the Lingua Franca file.
      • - *
    • A "self" struct type definition (see the class documentation above).
      • - *
    • A function for each reaction.
      • - *
    • A constructor for creating an instance. - * for deleting an instance.
      • - *
    - * - *

    If the reactor is the main reactor, then - * the generated code may be customized. Specifically, - * if the main reactor has reactions, these reactions - * will not be generated if they are triggered by or send - * data to contained reactors that are not in the federate.

    - */ - private void generateReactorClass(TypeParameterizedReactor tpr) throws IOException { - // FIXME: Currently we're not reusing definitions for declarations that point to the same definition. - CodeBuilder header = new CodeBuilder(); - CodeBuilder src = new CodeBuilder(); - final String headerName = CUtil.getName(tpr) + ".h"; - var guardMacro = headerName.toUpperCase().replace(".", "_"); - header.pr("#ifndef " + guardMacro); - header.pr("#define " + guardMacro); - generateReactorClassHeaders(tpr, headerName, header, src); - header.pr(generateTopLevelPreambles(tpr.reactor())); - generateUserPreamblesForReactor(tpr.reactor(), src); - generateReactorClassBody(tpr, header, src); - header.pr("#endif // " + guardMacro); - FileUtil.writeToFile(CodeMap.fromGeneratedCode(header.toString()).getGeneratedCode(), fileConfig.getSrcGenPath().resolve(headerName), true); - var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" : - CCppMode ? ".cpp" : ".c"; - FileUtil.writeToFile(CodeMap.fromGeneratedCode(src.toString()).getGeneratedCode(), fileConfig.getSrcGenPath().resolve(CUtil.getName(tpr) + extension), true); + } + + /** + * Choose which platform files to compile with according to the OS. If there is no main reactor, + * then compilation will produce a .o file requiring further linking. Also, if useCmake is set to + * true, we don't need to add platform files. The CMakeLists.txt file will detect and use the + * appropriate platform file based on the platform that cmake is invoked on. + */ + private void pickCompilePlatform() { + var osName = System.getProperty("os.name").toLowerCase(); + // if platform target was set, use given platform instead + if (targetConfig.platformOptions.platform != Platform.AUTO) { + osName = targetConfig.platformOptions.platform.toString(); + } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { + errorReporter.reportError("Platform " + osName + " is not supported"); } - - protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String headerName, CodeBuilder header, CodeBuilder src) { - if (CCppMode) { - src.pr("extern \"C\" {"); - header.pr("extern \"C\" {"); - } - header.pr("#include \"include/core/reactor.h\""); - src.pr("#include \"include/api/api.h\""); - src.pr("#include \"include/api/set.h\""); - generateIncludes(tpr); - if (CCppMode) { - src.pr("}"); - header.pr("}"); - } - src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(tpr) + "\""); - src.pr("#include \"" + headerName + "\""); - tpr.doDefines(src); - ASTUtils.allIncludes(tpr.reactor()).stream().map(name -> "#include \"" - + name + ".h\"").forEach(header::pr); + } + + /** Copy target-specific header file to the src-gen directory. */ + protected void copyTargetFiles() throws IOException { + // Copy the core lib + String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); + Path dest = fileConfig.getSrcGenPath(); + if (targetConfig.platformOptions.platform == Platform.ARDUINO) { + dest = dest.resolve("src"); } - - private void generateReactorClassBody(TypeParameterizedReactor tpr, CodeBuilder header, CodeBuilder src) { - // Some of the following methods create lines of code that need to - // go into the constructor. Collect those lines of code here: - var constructorCode = new CodeBuilder(); - generateAuxiliaryStructs(header, tpr, false); - // The following must go before the self struct so the #include watchdog.h ends up in the header. - CWatchdogGenerator.generateWatchdogs(src, header, tpr, errorReporter); - generateSelfStruct(header, tpr, constructorCode); - generateMethods(src, tpr); - generateReactions(src, tpr); - generateConstructor(src, header, tpr, constructorCode); + if (coreLib != null) { + FileUtil.copyDirectoryContents(Path.of(coreLib), dest, true); + } else { + FileUtil.copyFromClassPath("/lib/c/reactor-c/core", dest, true, false); + FileUtil.copyFromClassPath("/lib/c/reactor-c/lib", dest, true, false); } - /** - * Generate methods for {@code reactor}. - */ - protected void generateMethods(CodeBuilder src, TypeParameterizedReactor tpr) { - CMethodGenerator.generateMethods(tpr, src, types); - } + // For the Zephyr target, copy default config and board files. + if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + FileUtil.copyFromClassPath( + "/lib/platform/zephyr/boards", fileConfig.getSrcGenPath(), false, false); + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/prj_lf.conf", fileConfig.getSrcGenPath(), true); - /** - * Generates preambles defined by user for a given reactor - * @param reactor The given reactor - */ - protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { - for (Preamble p : ASTUtils.allPreambles(reactor)) { - src.pr("// *********** From the preamble, verbatim:"); - src.prSourceLineNumber(p.getCode()); - src.pr(toText(p.getCode())); - src.pr("\n// *********** End of preamble."); - } + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath(), true); } - - /** - * Generate a constructor for the specified reactor in the specified federate. - * @param tpr The parsed reactor data structure. - * @param constructorCode Lines of code previously generated that need to - * go into the constructor. - */ - protected void generateConstructor( - CodeBuilder src, CodeBuilder header, TypeParameterizedReactor tpr, CodeBuilder constructorCode - ) { - header.pr(CConstructorGenerator.generateConstructorPrototype(tpr)); - src.pr(CConstructorGenerator.generateConstructor( - tpr, - constructorCode.toString() - )); + } + + //////////////////////////////////////////// + //// Code generators. + + /** + * Generate a reactor class definition for the specified federate. A class definition has four + * parts: + * + *
      + *
    • Preamble code, if any, specified in the Lingua Franca file. + *
    • A "self" struct type definition (see the class documentation above). + *
    • A function for each reaction. + *
    • A constructor for creating an instance. for deleting an instance. + *
    + * + *

    If the reactor is the main reactor, then the generated code may be customized. Specifically, + * if the main reactor has reactions, these reactions will not be generated if they are triggered + * by or send data to contained reactors that are not in the federate. + */ + private void generateReactorClass(TypeParameterizedReactor tpr) throws IOException { + // FIXME: Currently we're not reusing definitions for declarations that point to the same + // definition. + CodeBuilder header = new CodeBuilder(); + CodeBuilder src = new CodeBuilder(); + final String headerName = CUtil.getName(tpr) + ".h"; + var guardMacro = headerName.toUpperCase().replace(".", "_"); + header.pr("#ifndef " + guardMacro); + header.pr("#define " + guardMacro); + generateReactorClassHeaders(tpr, headerName, header, src); + header.pr(generateTopLevelPreambles(tpr.reactor())); + generateUserPreamblesForReactor(tpr.reactor(), src); + generateReactorClassBody(tpr, header, src); + header.pr("#endif // " + guardMacro); + FileUtil.writeToFile( + CodeMap.fromGeneratedCode(header.toString()).getGeneratedCode(), + fileConfig.getSrcGenPath().resolve(headerName), + true); + var extension = + targetConfig.platformOptions.platform == Platform.ARDUINO + ? ".ino" + : CCppMode ? ".cpp" : ".c"; + FileUtil.writeToFile( + CodeMap.fromGeneratedCode(src.toString()).getGeneratedCode(), + fileConfig.getSrcGenPath().resolve(CUtil.getName(tpr) + extension), + true); + } + + protected void generateReactorClassHeaders( + TypeParameterizedReactor tpr, String headerName, CodeBuilder header, CodeBuilder src) { + if (CCppMode) { + src.pr("extern \"C\" {"); + header.pr("extern \"C\" {"); } - - protected void generateIncludes(TypeParameterizedReactor tpr) { - code.pr("#include \"" + CUtil.getName(tpr) + ".h\""); + header.pr("#include \"include/core/reactor.h\""); + src.pr("#include \"include/api/api.h\""); + src.pr("#include \"include/api/set.h\""); + generateIncludes(tpr); + if (CCppMode) { + src.pr("}"); + header.pr("}"); } - - /** - * Generate the struct type definitions for inputs, outputs, and - * actions of the specified reactor. - */ - protected void generateAuxiliaryStructs(CodeBuilder builder, TypeParameterizedReactor tpr, boolean userFacing) { - // In the case where there are incoming - // p2p logical connections in decentralized - // federated execution, there will be an - // intended_tag field added to accommodate - // the case where a reaction triggered by a - // port or action is late due to network - // latency, etc.. - var federatedExtension = new CodeBuilder(); - federatedExtension.pr(String.format(""" + src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(tpr) + "\""); + src.pr("#include \"" + headerName + "\""); + tpr.doDefines(src); + ASTUtils.allIncludes(tpr.reactor()).stream() + .map(name -> "#include \"" + name + ".h\"") + .forEach(header::pr); + } + + private void generateReactorClassBody( + TypeParameterizedReactor tpr, CodeBuilder header, CodeBuilder src) { + // Some of the following methods create lines of code that need to + // go into the constructor. Collect those lines of code here: + var constructorCode = new CodeBuilder(); + generateAuxiliaryStructs(header, tpr, false); + // The following must go before the self struct so the #include watchdog.h ends up in the + // header. + CWatchdogGenerator.generateWatchdogs(src, header, tpr, errorReporter); + generateSelfStruct(header, tpr, constructorCode); + generateMethods(src, tpr); + generateReactions(src, tpr); + generateConstructor(src, header, tpr, constructorCode); + } + + /** Generate methods for {@code reactor}. */ + protected void generateMethods(CodeBuilder src, TypeParameterizedReactor tpr) { + CMethodGenerator.generateMethods(tpr, src, types); + } + + /** + * Generates preambles defined by user for a given reactor + * + * @param reactor The given reactor + */ + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + for (Preamble p : ASTUtils.allPreambles(reactor)) { + src.pr("// *********** From the preamble, verbatim:"); + src.prSourceLineNumber(p.getCode()); + src.pr(toText(p.getCode())); + src.pr("\n// *********** End of preamble."); + } + } + + /** + * Generate a constructor for the specified reactor in the specified federate. + * + * @param tpr The parsed reactor data structure. + * @param constructorCode Lines of code previously generated that need to go into the constructor. + */ + protected void generateConstructor( + CodeBuilder src, + CodeBuilder header, + TypeParameterizedReactor tpr, + CodeBuilder constructorCode) { + header.pr(CConstructorGenerator.generateConstructorPrototype(tpr)); + src.pr(CConstructorGenerator.generateConstructor(tpr, constructorCode.toString())); + } + + protected void generateIncludes(TypeParameterizedReactor tpr) { + code.pr("#include \"" + CUtil.getName(tpr) + ".h\""); + } + + /** + * Generate the struct type definitions for inputs, outputs, and actions of the specified reactor. + */ + protected void generateAuxiliaryStructs( + CodeBuilder builder, TypeParameterizedReactor tpr, boolean userFacing) { + // In the case where there are incoming + // p2p logical connections in decentralized + // federated execution, there will be an + // intended_tag field added to accommodate + // the case where a reaction triggered by a + // port or action is late due to network + // latency, etc.. + var federatedExtension = new CodeBuilder(); + federatedExtension.pr( + String.format( + """ #ifdef FEDERATED #ifdef FEDERATED_DECENTRALIZED %s intended_tag; #endif %s physical_time_of_arrival; #endif - """, types.getTargetTagType(), types.getTargetTimeType()) - ); - for (Port p : allPorts(tpr.reactor())) { - builder.pr(CPortGenerator.generateAuxiliaryStruct( - tpr, - p, - getTarget(), - errorReporter, - types, - federatedExtension, - userFacing, - null - )); - } - // The very first item on this struct needs to be - // a trigger_t* because the struct will be cast to (trigger_t*) - // by the lf_schedule() functions to get to the trigger. - for (Action action : allActions(tpr.reactor())) { - builder.pr(CActionGenerator.generateAuxiliaryStruct( - tpr, - action, - getTarget(), - types, - federatedExtension, - userFacing - )); - } + """, + types.getTargetTagType(), types.getTargetTimeType())); + for (Port p : allPorts(tpr.reactor())) { + builder.pr( + CPortGenerator.generateAuxiliaryStruct( + tpr, p, getTarget(), errorReporter, types, federatedExtension, userFacing, null)); } - - /** - * Generate the self struct type definition for the specified reactor - * in the specified federate. - * @param constructorCode Place to put lines of code that need to - * go into the constructor. - */ - private void generateSelfStruct(CodeBuilder builder, TypeParameterizedReactor tpr, CodeBuilder constructorCode) { - var reactor = toDefinition(tpr.reactor()); - var selfType = CUtil.selfType(tpr); - - // Construct the typedef for the "self" struct. - // Create a type name for the self struct. - var body = new CodeBuilder(); - - // Extensions can add functionality to the CGenerator - generateSelfStructExtension(body, reactor, constructorCode); - - // Next handle parameters. - body.pr(CParameterGenerator.generateDeclarations(tpr, types)); - - // Next handle states. - body.pr(CStateGenerator.generateDeclarations(tpr, types)); - - // Next handle actions. - CActionGenerator.generateDeclarations(tpr, body, constructorCode); - - // Next handle inputs and outputs. - CPortGenerator.generateDeclarations(tpr, reactor, body, constructorCode); - - // If there are contained reactors that either receive inputs - // from reactions of this reactor or produce outputs that trigger - // reactions of this reactor, then we need to create a struct - // inside the self struct for each contained reactor. That - // struct has a place to hold the data produced by this reactor's - // reactions and a place to put pointers to data produced by - // the contained reactors. - generateInteractingContainedReactors(tpr, body, constructorCode); - - // Next, generate the fields needed for each reaction. - CReactionGenerator.generateReactionAndTriggerStructs( - body, - tpr, - constructorCode, - types - ); - - // Generate the fields needed for each watchdog. - CWatchdogGenerator.generateWatchdogStruct(body, tpr, constructorCode); - - // Next, generate fields for modes - CModesGenerator.generateDeclarations(reactor, body, constructorCode); - - // The first field has to always be a pointer to the list of - // of allocated memory that must be freed when the reactor is freed. - // This means that the struct can be safely cast to self_base_t. - builder.pr("typedef struct {"); - builder.indent(); - builder.pr("struct self_base_t base;"); - builder.pr(body.toString()); - builder.unindent(); - builder.pr("} " + selfType + ";"); + // The very first item on this struct needs to be + // a trigger_t* because the struct will be cast to (trigger_t*) + // by the lf_schedule() functions to get to the trigger. + for (Action action : allActions(tpr.reactor())) { + builder.pr( + CActionGenerator.generateAuxiliaryStruct( + tpr, action, getTarget(), types, federatedExtension, userFacing)); } - - /** - * Generate structs and associated code for contained reactors that - * send or receive data to or from the container's reactions. - * - * If there are contained reactors that either receive inputs - * from reactions of this reactor or produce outputs that trigger - * reactions of this reactor, then we need to create a struct - * inside the self struct of the container for each contained reactor. - * That struct has a place to hold the data produced by the container reactor's - * reactions and a place to put pointers to data produced by - * the contained reactors. - * - * @param tpr {@link TypeParameterizedReactor} - * @param body The place to put the struct definition for the contained reactors. - * @param constructorCode The place to put matching code that goes in the container's constructor. - */ - private void generateInteractingContainedReactors( - TypeParameterizedReactor tpr, - CodeBuilder body, - CodeBuilder constructorCode - ) { - // The contents of the struct will be collected first so that - // we avoid duplicate entries and then the struct will be constructed. - var contained = new InteractingContainedReactors(tpr.reactor()); - // Next generate the relevant code. - for (Instantiation containedReactor : contained.containedReactors()) { - var containedTpr = new TypeParameterizedReactor(containedReactor); - // First define an _width variable in case it is a bank. - var array = ""; - var width = -2; - // If the instantiation is a bank, find the maximum bank width - // to define an array. - if (containedReactor.getWidthSpec() != null) { - width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); - array = "[" + width + "]"; - } - // NOTE: The following needs to be done for each instance - // so that the width can be parameter, not in the constructor. - // Here, we conservatively use a width that is the largest of all instances. - constructorCode.pr(String.join("\n", - "// Set the _width variable for all cases. This will be -2", - "// if the reactor is not a bank of reactors.", - "self->_lf_"+containedReactor.getName()+"_width = "+width+";" - )); - - // Generate one struct for each contained reactor that interacts. - body.pr("struct {"); - body.indent(); - for (Port port : contained.portsOfInstance(containedReactor)) { - if (port instanceof Input) { - // If the variable is a multiport, then the place to store the data has - // to be malloc'd at initialization. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr(port, variableStructType(port, containedTpr, false)+" "+port.getName()+";"); - } else { - // Is a multiport. - // Memory will be malloc'd in initialization. - body.pr(port, String.join("\n", - variableStructType(port, containedTpr, false)+"** "+port.getName()+";", - "int "+port.getName()+"_width;" - )); - } - } else { - // Must be an output port. - // Outputs of contained reactors are pointers to the source of data on the - // self struct of the container. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr(port, variableStructType(port, containedTpr, false)+"* "+port.getName()+";"); - } else { - // Is a multiport. - // Here, we will use an array of pointers. - // Memory will be malloc'd in initialization. - body.pr(port, String.join("\n", - variableStructType(port, containedTpr, false)+"** "+port.getName()+";", - "int "+port.getName()+"_width;" - )); - } - body.pr(port, "trigger_t "+port.getName()+"_trigger;"); - var reactorIndex = ""; - if (containedReactor.getWidthSpec() != null) { - reactorIndex = "[reactor_index]"; - constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactor.getName()+"_width; reactor_index++) {"); - constructorCode.indent(); - } - var portOnSelf = "self->_lf_"+containedReactor.getName()+reactorIndex+"."+port.getName(); - - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederatedDecentralized( - portOnSelf+"_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};" - ) - ); - - var triggered = contained.reactionsTriggered(containedReactor, port); - //noinspection StatementWithEmptyBody - if (triggered.size() > 0) { - body.pr(port, "reaction_t* "+port.getName()+"_reactions["+triggered.size()+"];"); - var triggeredCount = 0; - for (Integer index : triggered) { - constructorCode.pr(port, portOnSelf+"_reactions["+triggeredCount+++"] = &self->_lf__reaction_"+index+";"); - } - constructorCode.pr(port, portOnSelf+"_trigger.reactions = "+portOnSelf+"_reactions;"); - } else { - // Since the self struct is created using calloc, there is no need to set - // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL - } - // Since the self struct is created using calloc, there is no need to set falsy fields. - constructorCode.pr(port, String.join("\n", - portOnSelf+"_trigger.last = NULL;", - portOnSelf+"_trigger.number_of_reactions = "+triggered.size()+";" - )); - - - // Set the physical_time_of_arrival - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederated( - portOnSelf+"_trigger.physical_time_of_arrival = NEVER;" - ) - ); - - if (containedReactor.getWidthSpec() != null) { - constructorCode.unindent(); - constructorCode.pr("}"); - } - } + } + + /** + * Generate the self struct type definition for the specified reactor in the specified federate. + * + * @param constructorCode Place to put lines of code that need to go into the constructor. + */ + private void generateSelfStruct( + CodeBuilder builder, TypeParameterizedReactor tpr, CodeBuilder constructorCode) { + var reactor = toDefinition(tpr.reactor()); + var selfType = CUtil.selfType(tpr); + + // Construct the typedef for the "self" struct. + // Create a type name for the self struct. + var body = new CodeBuilder(); + + // Extensions can add functionality to the CGenerator + generateSelfStructExtension(body, reactor, constructorCode); + + // Next handle parameters. + body.pr(CParameterGenerator.generateDeclarations(tpr, types)); + + // Next handle states. + body.pr(CStateGenerator.generateDeclarations(tpr, types)); + + // Next handle actions. + CActionGenerator.generateDeclarations(tpr, body, constructorCode); + + // Next handle inputs and outputs. + CPortGenerator.generateDeclarations(tpr, reactor, body, constructorCode); + + // If there are contained reactors that either receive inputs + // from reactions of this reactor or produce outputs that trigger + // reactions of this reactor, then we need to create a struct + // inside the self struct for each contained reactor. That + // struct has a place to hold the data produced by this reactor's + // reactions and a place to put pointers to data produced by + // the contained reactors. + generateInteractingContainedReactors(tpr, body, constructorCode); + + // Next, generate the fields needed for each reaction. + CReactionGenerator.generateReactionAndTriggerStructs(body, tpr, constructorCode, types); + + // Generate the fields needed for each watchdog. + CWatchdogGenerator.generateWatchdogStruct(body, tpr, constructorCode); + + // Next, generate fields for modes + CModesGenerator.generateDeclarations(reactor, body, constructorCode); + + // The first field has to always be a pointer to the list of + // of allocated memory that must be freed when the reactor is freed. + // This means that the struct can be safely cast to self_base_t. + builder.pr("typedef struct {"); + builder.indent(); + builder.pr("struct self_base_t base;"); + builder.pr(body.toString()); + builder.unindent(); + builder.pr("} " + selfType + ";"); + } + + /** + * Generate structs and associated code for contained reactors that send or receive data to or + * from the container's reactions. + * + *

    If there are contained reactors that either receive inputs from reactions of this reactor or + * produce outputs that trigger reactions of this reactor, then we need to create a struct inside + * the self struct of the container for each contained reactor. That struct has a place to hold + * the data produced by the container reactor's reactions and a place to put pointers to data + * produced by the contained reactors. + * + * @param tpr {@link TypeParameterizedReactor} + * @param body The place to put the struct definition for the contained reactors. + * @param constructorCode The place to put matching code that goes in the container's constructor. + */ + private void generateInteractingContainedReactors( + TypeParameterizedReactor tpr, CodeBuilder body, CodeBuilder constructorCode) { + // The contents of the struct will be collected first so that + // we avoid duplicate entries and then the struct will be constructed. + var contained = new InteractingContainedReactors(tpr.reactor()); + // Next generate the relevant code. + for (Instantiation containedReactor : contained.containedReactors()) { + var containedTpr = new TypeParameterizedReactor(containedReactor); + // First define an _width variable in case it is a bank. + var array = ""; + var width = -2; + // If the instantiation is a bank, find the maximum bank width + // to define an array. + if (containedReactor.getWidthSpec() != null) { + width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); + array = "[" + width + "]"; + } + // NOTE: The following needs to be done for each instance + // so that the width can be parameter, not in the constructor. + // Here, we conservatively use a width that is the largest of all instances. + constructorCode.pr( + String.join( + "\n", + "// Set the _width variable for all cases. This will be -2", + "// if the reactor is not a bank of reactors.", + "self->_lf_" + containedReactor.getName() + "_width = " + width + ";")); + + // Generate one struct for each contained reactor that interacts. + body.pr("struct {"); + body.indent(); + for (Port port : contained.portsOfInstance(containedReactor)) { + if (port instanceof Input) { + // If the variable is a multiport, then the place to store the data has + // to be malloc'd at initialization. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr( + port, variableStructType(port, containedTpr, false) + " " + port.getName() + ";"); + } else { + // Is a multiport. + // Memory will be malloc'd in initialization. + body.pr( + port, + String.join( + "\n", + variableStructType(port, containedTpr, false) + "** " + port.getName() + ";", + "int " + port.getName() + "_width;")); + } + } else { + // Must be an output port. + // Outputs of contained reactors are pointers to the source of data on the + // self struct of the container. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr( + port, variableStructType(port, containedTpr, false) + "* " + port.getName() + ";"); + } else { + // Is a multiport. + // Here, we will use an array of pointers. + // Memory will be malloc'd in initialization. + body.pr( + port, + String.join( + "\n", + variableStructType(port, containedTpr, false) + "** " + port.getName() + ";", + "int " + port.getName() + "_width;")); + } + body.pr(port, "trigger_t " + port.getName() + "_trigger;"); + var reactorIndex = ""; + if (containedReactor.getWidthSpec() != null) { + reactorIndex = "[reactor_index]"; + constructorCode.pr( + "for (int reactor_index = 0; reactor_index < self->_lf_" + + containedReactor.getName() + + "_width; reactor_index++) {"); + constructorCode.indent(); + } + var portOnSelf = + "self->_lf_" + containedReactor.getName() + reactorIndex + "." + port.getName(); + + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederatedDecentralized( + portOnSelf + + "_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + + var triggered = contained.reactionsTriggered(containedReactor, port); + //noinspection StatementWithEmptyBody + if (triggered.size() > 0) { + body.pr( + port, "reaction_t* " + port.getName() + "_reactions[" + triggered.size() + "];"); + var triggeredCount = 0; + for (Integer index : triggered) { + constructorCode.pr( + port, + portOnSelf + + "_reactions[" + + triggeredCount++ + + "] = &self->_lf__reaction_" + + index + + ";"); } - body.unindent(); - body.pr(String.join("\n", - "} _lf_"+containedReactor.getName()+array+";", - "int _lf_"+containedReactor.getName()+"_width;" - )); + constructorCode.pr( + port, portOnSelf + "_trigger.reactions = " + portOnSelf + "_reactions;"); + } else { + // Since the self struct is created using calloc, there is no need to set + // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL + } + // Since the self struct is created using calloc, there is no need to set falsy fields. + constructorCode.pr( + port, + String.join( + "\n", + portOnSelf + "_trigger.last = NULL;", + portOnSelf + "_trigger.number_of_reactions = " + triggered.size() + ";")); + + // Set the physical_time_of_arrival + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederated( + portOnSelf + "_trigger.physical_time_of_arrival = NEVER;")); + + if (containedReactor.getWidthSpec() != null) { + constructorCode.unindent(); + constructorCode.pr("}"); + } } + } + body.unindent(); + body.pr( + String.join( + "\n", + "} _lf_" + containedReactor.getName() + array + ";", + "int _lf_" + containedReactor.getName() + "_width;")); } - - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the self struct - * @param body The body of the self struct - * @param reactor The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - protected void generateSelfStructExtension( - CodeBuilder body, - Reactor reactor, - CodeBuilder constructorCode - ) { - // Do nothing - } - - /** Generate reaction functions definition for a reactor. - * These functions have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param tpr The reactor. - */ - public void generateReactions(CodeBuilder src, TypeParameterizedReactor tpr) { - var reactionIndex = 0; - var reactor = ASTUtils.toDefinition(tpr.reactor()); - for (Reaction reaction : allReactions(reactor)) { - generateReaction(src, reaction, tpr, reactionIndex); - // Increment reaction index even if the reaction is not in the federate - // so that across federates, the reaction indices are consistent. - reactionIndex++; - } + } + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the + * self struct + * + * @param body The body of the self struct + * @param reactor The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + protected void generateSelfStructExtension( + CodeBuilder body, Reactor reactor, CodeBuilder constructorCode) { + // Do nothing + } + + /** + * Generate reaction functions definition for a reactor. These functions have a single argument + * that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param tpr The reactor. + */ + public void generateReactions(CodeBuilder src, TypeParameterizedReactor tpr) { + var reactionIndex = 0; + var reactor = ASTUtils.toDefinition(tpr.reactor()); + for (Reaction reaction : allReactions(reactor)) { + generateReaction(src, reaction, tpr, reactionIndex); + // Increment reaction index even if the reaction is not in the federate + // so that across federates, the reaction indices are consistent. + reactionIndex++; } - - /** Generate a reaction function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param tpr The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - protected void generateReaction(CodeBuilder src, Reaction reaction, TypeParameterizedReactor tpr, int reactionIndex) { - src.pr(CReactionGenerator.generateReaction( + } + + /** + * Generate a reaction function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param tpr The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + protected void generateReaction( + CodeBuilder src, Reaction reaction, TypeParameterizedReactor tpr, int reactionIndex) { + src.pr( + CReactionGenerator.generateReaction( reaction, tpr, reactionIndex, @@ -1427,702 +1423,737 @@ protected void generateReaction(CodeBuilder src, Reaction reaction, TypeParamete errorReporter, types, targetConfig, - getTarget().requiresTypes - )); - } - - /** - * Record startup, shutdown, and reset reactions. - * @param instance A reactor instance. - */ - private void recordBuiltinTriggers(ReactorInstance instance) { - // For each reaction instance, allocate the arrays that will be used to - // trigger downstream reactions. - for (ReactionInstance reaction : instance.reactions) { - var reactor = reaction.getParent(); - var temp = new CodeBuilder(); - var foundOne = false; - - var reactionRef = CUtil.reactionRef(reaction); - - // Next handle triggers of the reaction that come from a multiport output - // of a contained reactor. Also, handle startup and shutdown triggers. - for (TriggerInstance trigger : reaction.triggers) { - if (trigger.isStartup()) { - temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &"+reactionRef+";"); - startupReactionCount += reactor.getTotalWidth(); - foundOne = true; - } else if (trigger.isShutdown()) { - temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &"+reactionRef+";"); - foundOne = true; - shutdownReactionCount += reactor.getTotalWidth(); - - if (targetConfig.tracing != null) { - var description = CUtil.getShortenedName(reactor); - var reactorRef = CUtil.reactorRef(reactor); - temp.pr(String.join("\n", - "_lf_register_trace_event("+reactorRef+", &("+reactorRef+"->_lf__shutdown),", - "trace_trigger, "+addDoubleQuotes(description+".shutdown")+");" - )); - } - } else if (trigger.isReset()) { - temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &"+reactionRef+";"); - resetReactionCount += reactor.getTotalWidth(); - foundOne = true; - } - } - if (foundOne) initializeTriggerObjects.pr(temp.toString()); + getTarget().requiresTypes)); + } + + /** + * Record startup, shutdown, and reset reactions. + * + * @param instance A reactor instance. + */ + private void recordBuiltinTriggers(ReactorInstance instance) { + // For each reaction instance, allocate the arrays that will be used to + // trigger downstream reactions. + for (ReactionInstance reaction : instance.reactions) { + var reactor = reaction.getParent(); + var temp = new CodeBuilder(); + var foundOne = false; + + var reactionRef = CUtil.reactionRef(reaction); + + // Next handle triggers of the reaction that come from a multiport output + // of a contained reactor. Also, handle startup and shutdown triggers. + for (TriggerInstance trigger : reaction.triggers) { + if (trigger.isStartup()) { + temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &" + reactionRef + ";"); + startupReactionCount += reactor.getTotalWidth(); + foundOne = true; + } else if (trigger.isShutdown()) { + temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &" + reactionRef + ";"); + foundOne = true; + shutdownReactionCount += reactor.getTotalWidth(); + + if (targetConfig.tracing != null) { + var description = CUtil.getShortenedName(reactor); + var reactorRef = CUtil.reactorRef(reactor); + temp.pr( + String.join( + "\n", + "_lf_register_trace_event(" + + reactorRef + + ", &(" + + reactorRef + + "->_lf__shutdown),", + "trace_trigger, " + addDoubleQuotes(description + ".shutdown") + ");")); + } + } else if (trigger.isReset()) { + temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &" + reactionRef + ";"); + resetReactionCount += reactor.getTotalWidth(); + foundOne = true; } + } + if (foundOne) initializeTriggerObjects.pr(temp.toString()); } - - /** - * Generate code to set up the tables used in _lf_start_time_step to decrement reference - * counts and mark outputs absent between time steps. This function puts the code - * into startTimeStep. - */ - private void generateStartTimeStep(ReactorInstance instance) { - // Avoid generating dead code if nothing is relevant. - var foundOne = false; - var temp = new CodeBuilder(); - var containerSelfStructName = CUtil.reactorRef(instance); - - // Handle inputs that get sent data from a reaction rather than from - // another contained reactor and reactions that are triggered by an - // output of a contained reactor. - // Note that there may be more than one reaction reacting to the same - // port so we have to avoid listing the port more than once. - var portsSeen = new LinkedHashSet(); - for (ReactionInstance reaction : instance.reactions) { - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { - portsSeen.add(port); - // This reaction is sending to an input. Must be - // the input of a contained reactor in the federate. - // NOTE: If instance == main and the federate is within a bank, - // this assumes that the reaction writes only to the bank member in the federate. - foundOne = true; - - temp.pr("// Add port "+port.getFullName()+" to array of is_present fields."); - - if (!instance.equals(port.getParent())) { - // The port belongs to contained reactor, so we also have - // iterate over the instance bank members. - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(instance); - temp.startScopedBankChannelIteration(port, null); - } else { - temp.startScopedBankChannelIteration(port, "count"); - } - var portRef = CUtil.portRefNested(port); - var con = (port.isMultiport()) ? "->" : "."; - - temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"is_present;"); - // Intended_tag is only applicable to ports in federated execution. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"intended_tag;" - ) - ); - - startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); - - if (!instance.equals(port.getParent())) { - temp.pr("count++;"); - temp.endScopedBlock(); - temp.endScopedBlock(); - temp.endScopedBankChannelIteration(port, null); - } else { - temp.endScopedBankChannelIteration(port, "count"); - } - } - } + } + + /** + * Generate code to set up the tables used in _lf_start_time_step to decrement reference counts + * and mark outputs absent between time steps. This function puts the code into startTimeStep. + */ + private void generateStartTimeStep(ReactorInstance instance) { + // Avoid generating dead code if nothing is relevant. + var foundOne = false; + var temp = new CodeBuilder(); + var containerSelfStructName = CUtil.reactorRef(instance); + + // Handle inputs that get sent data from a reaction rather than from + // another contained reactor and reactions that are triggered by an + // output of a contained reactor. + // Note that there may be more than one reaction reacting to the same + // port so we have to avoid listing the port more than once. + var portsSeen = new LinkedHashSet(); + for (ReactionInstance reaction : instance.reactions) { + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { + portsSeen.add(port); + // This reaction is sending to an input. Must be + // the input of a contained reactor in the federate. + // NOTE: If instance == main and the federate is within a bank, + // this assumes that the reaction writes only to the bank member in the federate. + foundOne = true; + + temp.pr("// Add port " + port.getFullName() + " to array of is_present fields."); + + if (!instance.equals(port.getParent())) { + // The port belongs to contained reactor, so we also have + // iterate over the instance bank members. + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(instance); + temp.startScopedBankChannelIteration(port, null); + } else { + temp.startScopedBankChannelIteration(port, "count"); + } + var portRef = CUtil.portRefNested(port); + var con = (port.isMultiport()) ? "->" : "."; + + temp.pr( + "_lf_is_present_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + portRef + + con + + "is_present;"); + // Intended_tag is only applicable to ports in federated execution. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + portRef + + con + + "intended_tag;")); + + startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); + + if (!instance.equals(port.getParent())) { + temp.pr("count++;"); + temp.endScopedBlock(); + temp.endScopedBlock(); + temp.endScopedBankChannelIteration(port, null); + } else { + temp.endScopedBankChannelIteration(port, "count"); + } } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; + } + } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; + + for (ActionInstance action : instance.actions) { + foundOne = true; + temp.startScopedBlock(instance); + + temp.pr( + String.join( + "\n", + "// Add action " + action.getFullName() + " to array of is_present fields.", + "_lf_is_present_fields[" + startTimeStepIsPresentCount + "] ", + " = &" + + containerSelfStructName + + "->_lf_" + + action.getName() + + ".is_present;")); + + // Intended_tag is only applicable to actions in federated execution with decentralized + // coordination. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + String.join( + "\n", + "// Add action " + action.getFullName() + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + startTimeStepIsPresentCount + "] ", + " = &" + + containerSelfStructName + + "->_lf_" + + action.getName() + + ".intended_tag;"))); + + startTimeStepIsPresentCount += action.getParent().getTotalWidth(); + temp.endScopedBlock(); + } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; - for (ActionInstance action : instance.actions) { - foundOne = true; - temp.startScopedBlock(instance); + // Next, set up the table to mark each output of each contained reactor absent. + for (ReactorInstance child : instance.children) { + if (child.outputs.size() > 0) { - temp.pr(String.join("\n", - "// Add action "+action.getFullName()+" to array of is_present fields.", - "_lf_is_present_fields["+startTimeStepIsPresentCount+"] ", - " = &"+containerSelfStructName+"->_lf_"+action.getName()+".is_present;" - )); + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(child); - // Intended_tag is only applicable to actions in federated execution with decentralized coordination. + var channelCount = 0; + for (PortInstance output : child.outputs) { + if (!output.getDependsOnReactions().isEmpty()) { + foundOne = true; + temp.pr("// Add port " + output.getFullName() + " to array of is_present fields."); + temp.startChannelIteration(output); + temp.pr( + "_lf_is_present_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + CUtil.portRef(output) + + ".is_present;"); + + // Intended_tag is only applicable to ports in federated execution with decentralized + // coordination. temp.pr( CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join("\n", - "// Add action " + action.getFullName() - + " to array of intended_tag fields.", - "_lf_intended_tag_fields[" - + startTimeStepIsPresentCount + "] ", - " = &" + containerSelfStructName - + "->_lf_" + action.getName() - + ".intended_tag;" - ))); - - startTimeStepIsPresentCount += action.getParent().getTotalWidth(); - temp.endScopedBlock(); + String.join( + "\n", + "// Add port " + output.getFullName() + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + CUtil.portRef(output) + + ".intended_tag;"))); + + temp.pr("count++;"); + channelCount += output.getWidth(); + temp.endChannelIteration(output); + } } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; - - // Next, set up the table to mark each output of each contained reactor absent. - for (ReactorInstance child : instance.children) { - if (child.outputs.size() > 0) { - - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(child); - - var channelCount = 0; - for (PortInstance output : child.outputs) { - if (!output.getDependsOnReactions().isEmpty()){ - foundOne = true; - temp.pr("// Add port "+output.getFullName()+" to array of is_present fields."); - temp.startChannelIteration(output); - temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".is_present;"); - - // Intended_tag is only applicable to ports in federated execution with decentralized coordination. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join("\n", - "// Add port "+output.getFullName()+" to array of intended_tag fields.", - "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".intended_tag;" - ))); - - temp.pr("count++;"); - channelCount += output.getWidth(); - temp.endChannelIteration(output); - } - } - startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); - temp.endScopedBlock(); - temp.endScopedBlock(); - } - } - if (foundOne) startTimeStep.pr(temp.toString()); + startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); + temp.endScopedBlock(); + temp.endScopedBlock(); + } } - - /** - * For each timer in the given reactor, generate initialization code for the offset - * and period fields. - * - * This method will also populate the global _lf_timer_triggers array, which is - * used to start all timers at the start of execution. - * - * @param instance A reactor instance. - */ - private void generateTimerInitializations(ReactorInstance instance) { - for (TimerInstance timer : instance.timers) { - if (!timer.isStartup()) { - initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); - timerCount += timer.getParent().getTotalWidth(); - } - } + if (foundOne) startTimeStep.pr(temp.toString()); + } + + /** + * For each timer in the given reactor, generate initialization code for the offset and period + * fields. + * + *

    This method will also populate the global _lf_timer_triggers array, which is used to start + * all timers at the start of execution. + * + * @param instance A reactor instance. + */ + private void generateTimerInitializations(ReactorInstance instance) { + for (TimerInstance timer : instance.timers) { + if (!timer.isStartup()) { + initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); + timerCount += timer.getParent().getTotalWidth(); + } } - - /** - * Process a given .proto file. - * - * Run, if possible, the proto-c protocol buffer code generator to produce - * the required .h and .c files. - * @param filename Name of the file to process. - */ - public void processProtoFile(String filename) { - var protoc = commandFactory.createCommand( + } + + /** + * Process a given .proto file. + * + *

    Run, if possible, the proto-c protocol buffer code generator to produce the required .h and + * .c files. + * + * @param filename Name of the file to process. + */ + public void processProtoFile(String filename) { + var protoc = + commandFactory.createCommand( "protoc-c", - List.of("--c_out="+this.fileConfig.getSrcGenPath(), filename), + List.of("--c_out=" + this.fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); - return; - } - var returnCode = protoc.run(); - if (returnCode == 0) { - var nameSansProto = filename.substring(0, filename.length() - 6); - targetConfig.compileAdditionalSources.add( - fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString() - ); - - targetConfig.compileLibraries.add("-l"); - targetConfig.compileLibraries.add("protobuf-c"); - targetConfig.compilerFlags.add("-lprotobuf-c"); - } else { - errorReporter.reportError("protoc-c returns error code " + returnCode); - } + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); + return; } - - /** - * Construct a unique type for the struct of the specified - * typed variable (port or action) of the specified reactor class. - * This is required to be the same as the type name returned by - * {@link #variableStructType(TriggerInstance)}. - */ - public static String variableStructType(Variable variable, TypeParameterizedReactor tpr, boolean userFacing) { - return (userFacing ? tpr.getName().toLowerCase() : CUtil.getName(tpr)) +"_"+variable.getName()+"_t"; + var returnCode = protoc.run(); + if (returnCode == 0) { + var nameSansProto = filename.substring(0, filename.length() - 6); + targetConfig.compileAdditionalSources.add( + fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString()); + + targetConfig.compileLibraries.add("-l"); + targetConfig.compileLibraries.add("protobuf-c"); + targetConfig.compilerFlags.add("-lprotobuf-c"); + } else { + errorReporter.reportError("protoc-c returns error code " + returnCode); } - - /** - * Construct a unique type for the struct of the specified - * instance (port or action). - * This is required to be the same as the type name returned by - * {@link #variableStructType(Variable, TypeParameterizedReactor, boolean)}. - * @param portOrAction The port or action instance. - * @return The name of the self struct. - */ - public static String variableStructType(TriggerInstance portOrAction) { - return CUtil.getName(portOrAction.getParent().tpr)+"_"+portOrAction.getName()+"_t"; + } + + /** + * Construct a unique type for the struct of the specified typed variable (port or action) of the + * specified reactor class. This is required to be the same as the type name returned by {@link + * #variableStructType(TriggerInstance)}. + */ + public static String variableStructType( + Variable variable, TypeParameterizedReactor tpr, boolean userFacing) { + return (userFacing ? tpr.getName().toLowerCase() : CUtil.getName(tpr)) + + "_" + + variable.getName() + + "_t"; + } + + /** + * Construct a unique type for the struct of the specified instance (port or action). This is + * required to be the same as the type name returned by {@link #variableStructType(Variable, + * TypeParameterizedReactor, boolean)}. + * + * @param portOrAction The port or action instance. + * @return The name of the self struct. + */ + public static String variableStructType(TriggerInstance portOrAction) { + return CUtil.getName(portOrAction.getParent().tpr) + "_" + portOrAction.getName() + "_t"; + } + + /** + * If tracing is turned on, then generate code that records the full name of the specified reactor + * instance in the trace table. If tracing is not turned on, do nothing. + * + * @param instance The reactor instance. + */ + private void generateTraceTableEntries(ReactorInstance instance) { + if (targetConfig.tracing != null) { + initializeTriggerObjects.pr(CTracingGenerator.generateTraceTableEntries(instance)); } - - /** - * If tracing is turned on, then generate code that records - * the full name of the specified reactor instance in the - * trace table. If tracing is not turned on, do nothing. - * @param instance The reactor instance. - */ - private void generateTraceTableEntries(ReactorInstance instance) { - if (targetConfig.tracing != null) { - initializeTriggerObjects.pr( - CTracingGenerator.generateTraceTableEntries(instance) - ); - } + } + + /** + * Generate code to instantiate the specified reactor instance and initialize it. + * + * @param instance A reactor instance. + */ + public void generateReactorInstance(ReactorInstance instance) { + var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); + var fullName = instance.getFullName(); + initializeTriggerObjects.pr( + "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); + // Generate the instance self struct containing parameters, state variables, + // and outputs (the "self" struct). + initializeTriggerObjects.pr( + CUtil.reactorRefName(instance) + + "[" + + CUtil.runtimeIndex(instance) + + "] = new_" + + CUtil.getName(instance.tpr) + + "();"); + // Generate code to initialize the "self" struct in the + // _lf_initialize_trigger_objects function. + generateTraceTableEntries(instance); + generateReactorInstanceExtension(instance); + generateParameterInitialization(instance); + initializeOutputMultiports(instance); + initializeInputMultiports(instance); + recordBuiltinTriggers(instance); + watchdogCount += + CWatchdogGenerator.generateInitializeWatchdogs(initializeTriggerObjects, instance); + + // Next, initialize the "self" struct with state variables. + // These values may be expressions that refer to the parameter values defined above. + generateStateVariableInitializations(instance); + + // Generate trigger objects for the instance. + generateTimerInitializations(instance); + generateActionInitializations(instance); + generateInitializeActionToken(instance); + generateSetDeadline(instance); + generateModeStructure(instance); + + // Recursively generate code for the children. + for (ReactorInstance child : instance.children) { + // If this reactor is a placeholder for a bank of reactors, then generate + // an array of instances of reactors and create an enclosing for loop. + // Need to do this for each of the builders into which the code writes. + startTimeStep.startScopedBlock(child); + initializeTriggerObjects.startScopedBlock(child); + generateReactorInstance(child); + initializeTriggerObjects.endScopedBlock(); + startTimeStep.endScopedBlock(); } - /** - * Generate code to instantiate the specified reactor instance and - * initialize it. - * @param instance A reactor instance. - */ - public void generateReactorInstance(ReactorInstance instance) { - var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); - var fullName = instance.getFullName(); - initializeTriggerObjects.pr( - "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); - // Generate the instance self struct containing parameters, state variables, - // and outputs (the "self" struct). - initializeTriggerObjects.pr(CUtil.reactorRefName(instance)+"["+CUtil.runtimeIndex(instance)+"] = new_"+CUtil.getName(instance.tpr)+"();"); - // Generate code to initialize the "self" struct in the - // _lf_initialize_trigger_objects function. - generateTraceTableEntries(instance); - generateReactorInstanceExtension(instance); - generateParameterInitialization(instance); - initializeOutputMultiports(instance); - initializeInputMultiports(instance); - recordBuiltinTriggers(instance); - watchdogCount += CWatchdogGenerator.generateInitializeWatchdogs(initializeTriggerObjects, instance); - - // Next, initialize the "self" struct with state variables. - // These values may be expressions that refer to the parameter values defined above. - generateStateVariableInitializations(instance); - - // Generate trigger objects for the instance. - generateTimerInitializations(instance); - generateActionInitializations(instance); - generateInitializeActionToken(instance); - generateSetDeadline(instance); - generateModeStructure(instance); - - // Recursively generate code for the children. - for (ReactorInstance child : instance.children) { - // If this reactor is a placeholder for a bank of reactors, then generate - // an array of instances of reactors and create an enclosing for loop. - // Need to do this for each of the builders into which the code writes. - startTimeStep.startScopedBlock(child); - initializeTriggerObjects.startScopedBlock(child); - generateReactorInstance(child); - initializeTriggerObjects.endScopedBlock(); - startTimeStep.endScopedBlock(); + // For this instance, define what must be done at the start of + // each time step. This sets up the tables that are used by the + // _lf_start_time_step() function in reactor_common.c. + // Note that this function is also run once at the end + // so that it can deallocate any memory. + generateStartTimeStep(instance); + initializeTriggerObjects.pr("//***** End initializing " + fullName); + } + + /** + * For each action of the specified reactor instance, generate initialization code for the offset + * and period fields. + * + * @param instance The reactor. + */ + private void generateActionInitializations(ReactorInstance instance) { + initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + } + + /** + * Initialize actions by creating a lf_token_t in the self struct. This has the information + * required to allocate memory for the action payload. Skip any action that is not actually used + * as a trigger. + * + * @param reactor The reactor containing the actions. + */ + private void generateInitializeActionToken(ReactorInstance reactor) { + for (ActionInstance action : reactor.actions) { + // Skip this step if the action is not in use. + if (action.getParent().getTriggers().contains(action)) { + var type = reactor.tpr.resolveType(getInferredType(action.getDefinition())); + var payloadSize = "0"; + if (!type.isUndefined()) { + var typeStr = types.getTargetType(type); + if (CUtil.isTokenType(type, types)) { + typeStr = CUtil.rootType(typeStr); + } + if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { + payloadSize = "sizeof(" + typeStr + ")"; + } } - // For this instance, define what must be done at the start of - // each time step. This sets up the tables that are used by the - // _lf_start_time_step() function in reactor_common.c. - // Note that this function is also run once at the end - // so that it can deallocate any memory. - generateStartTimeStep(instance); - initializeTriggerObjects.pr("//***** End initializing " + fullName); - } - - /** - * For each action of the specified reactor instance, generate initialization code - * for the offset and period fields. - * @param instance The reactor. - */ - private void generateActionInitializations(ReactorInstance instance) { - initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + var selfStruct = CUtil.reactorRef(action.getParent()); + initializeTriggerObjects.pr( + CActionGenerator.generateTokenInitializer(selfStruct, action.getName(), payloadSize)); + } } - - /** - * Initialize actions by creating a lf_token_t in the self struct. - * This has the information required to allocate memory for the action payload. - * Skip any action that is not actually used as a trigger. - * @param reactor The reactor containing the actions. - */ - private void generateInitializeActionToken(ReactorInstance reactor) { - for (ActionInstance action : reactor.actions) { - // Skip this step if the action is not in use. - if (action.getParent().getTriggers().contains(action) - ) { - var type = reactor.tpr.resolveType(getInferredType(action.getDefinition())); - var payloadSize = "0"; - if (!type.isUndefined()) { - var typeStr = types.getTargetType(type); - if (CUtil.isTokenType(type, types)) { - typeStr = CUtil.rootType(typeStr); - } - if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { - payloadSize = "sizeof("+typeStr+")"; - } - } - - var selfStruct = CUtil.reactorRef(action.getParent()); - initializeTriggerObjects.pr( - CActionGenerator.generateTokenInitializer( - selfStruct, action.getName(), payloadSize - ) - ); - } + } + + /** + * Generate code that is executed while the reactor instance is being initialized. This is + * provided as an extension point for subclasses. Normally, the reactions argument is the full + * list of reactions, but for the top-level of a federate, will be a subset of reactions that is + * relevant to the federate. + * + * @param instance The reactor instance. + */ + protected void generateReactorInstanceExtension(ReactorInstance instance) { + // Do nothing + } + + /** + * Generate code that initializes the state variables for a given instance. Unlike parameters, + * state variables are uniformly initialized for all instances of the same reactor. + * + * @param instance The reactor class instance + */ + protected void generateStateVariableInitializations(ReactorInstance instance) { + var reactorClass = instance.getDefinition().getReactorClass(); + var selfRef = CUtil.reactorRef(instance); + for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { + if (isInitialized(stateVar)) { + var mode = + stateVar.eContainer() instanceof Mode + ? instance.lookupModeInstance((Mode) stateVar.eContainer()) + : instance.getMode(false); + initializeTriggerObjects.pr( + CStateGenerator.generateInitializer(instance, selfRef, stateVar, mode, types)); + if (mode != null && stateVar.isReset()) { + modalStateResetCount += instance.getTotalWidth(); } + } } - - /** - * Generate code that is executed while the reactor instance is being initialized. - * This is provided as an extension point for subclasses. - * Normally, the reactions argument is the full list of reactions, - * but for the top-level of a federate, will be a subset of reactions that - * is relevant to the federate. - * @param instance The reactor instance. - */ - protected void generateReactorInstanceExtension(ReactorInstance instance) { - // Do nothing + } + + /** + * Generate code to set the deadline field of the reactions in the specified reactor instance. + * + * @param instance The reactor instance. + */ + private void generateSetDeadline(ReactorInstance instance) { + for (ReactionInstance reaction : instance.reactions) { + var selfRef = CUtil.reactorRef(reaction.getParent()) + "->_lf__reaction_" + reaction.index; + if (reaction.declaredDeadline != null) { + var deadline = reaction.declaredDeadline.maxDelay; + initializeTriggerObjects.pr( + selfRef + ".deadline = " + types.getTargetTimeExpr(deadline) + ";"); + } else { // No deadline. + initializeTriggerObjects.pr(selfRef + ".deadline = NEVER;"); + } } - - /** - * Generate code that initializes the state variables for a given instance. - * Unlike parameters, state variables are uniformly initialized for all instances - * of the same reactor. - * @param instance The reactor class instance - */ - protected void generateStateVariableInitializations(ReactorInstance instance) { - var reactorClass = instance.getDefinition().getReactorClass(); - var selfRef = CUtil.reactorRef(instance); - for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { - if (isInitialized(stateVar)) { - var mode = stateVar.eContainer() instanceof Mode ? - instance.lookupModeInstance((Mode) stateVar.eContainer()) : - instance.getMode(false); - initializeTriggerObjects.pr(CStateGenerator.generateInitializer( - instance, - selfRef, - stateVar, - mode, - types - )); - if (mode != null && stateVar.isReset()) { - modalStateResetCount += instance.getTotalWidth(); - } - } - } + } + + /** + * Generate code to initialize modes. + * + * @param instance The reactor instance. + */ + private void generateModeStructure(ReactorInstance instance) { + CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); + if (!instance.modes.isEmpty()) { + modalReactorCount += instance.getTotalWidth(); } - - /** - * Generate code to set the deadline field of the reactions in the - * specified reactor instance. - * @param instance The reactor instance. - */ - private void generateSetDeadline(ReactorInstance instance) { - for (ReactionInstance reaction : instance.reactions) { - var selfRef = CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+reaction.index; - if (reaction.declaredDeadline != null) { - var deadline = reaction.declaredDeadline.maxDelay; - initializeTriggerObjects.pr(selfRef+".deadline = "+types.getTargetTimeExpr(deadline)+";"); - } else { // No deadline. - initializeTriggerObjects.pr(selfRef+".deadline = NEVER;"); - } - } + } + + /** + * Generate runtime initialization code for parameters of a given reactor instance + * + * @param instance The reactor instance. + */ + protected void generateParameterInitialization(ReactorInstance instance) { + var selfRef = CUtil.reactorRef(instance); + // Set the local bank_index variable so that initializers can use it. + initializeTriggerObjects.pr( + "bank_index = " + + CUtil.bankIndex(instance) + + ";" + + " SUPPRESS_UNUSED_WARNING(bank_index);"); + for (ParameterInstance parameter : instance.parameters) { + // NOTE: we now use the resolved literal value. For better efficiency, we could + // store constants in a global array and refer to its elements to avoid duplicate + // memory allocations. + // NOTE: If the parameter is initialized with a static initializer for an array + // or struct (the initialization expression is surrounded by { ... }), then we + // have to declare a static variable to ensure that the memory is put in data space + // and not on the stack. + // FIXME: Is there a better way to determine this than the string comparison? + var initializer = CParameterGenerator.getInitializer(parameter); + if (initializer.startsWith("{")) { + var temporaryVariableName = parameter.uniqueID(); + initializeTriggerObjects.pr( + String.join( + "\n", + "static " + + types.getVariableDeclaration( + instance.tpr, parameter.type, temporaryVariableName, true) + + " = " + + initializer + + ";", + selfRef + "->" + parameter.getName() + " = " + temporaryVariableName + ";")); + } else { + initializeTriggerObjects.pr( + selfRef + "->" + parameter.getName() + " = " + initializer + ";"); + } } - - /** - * Generate code to initialize modes. - * @param instance The reactor instance. - */ - private void generateModeStructure(ReactorInstance instance) { - CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); - if (!instance.modes.isEmpty()) { - modalReactorCount += instance.getTotalWidth(); - } + } + + /** + * Generate code that mallocs memory for any output multiports. + * + * @param reactor The reactor instance. + */ + private void initializeOutputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance output : reactor.outputs) { + initializeTriggerObjects.pr( + CPortGenerator.initializeOutputMultiport(output, reactorSelfStruct)); } - - /** - * Generate runtime initialization code for parameters of a given reactor instance - * @param instance The reactor instance. - */ - protected void generateParameterInitialization(ReactorInstance instance) { - var selfRef = CUtil.reactorRef(instance); - // Set the local bank_index variable so that initializers can use it. - initializeTriggerObjects.pr("bank_index = "+CUtil.bankIndex(instance)+";" - + " SUPPRESS_UNUSED_WARNING(bank_index);"); - for (ParameterInstance parameter : instance.parameters) { - // NOTE: we now use the resolved literal value. For better efficiency, we could - // store constants in a global array and refer to its elements to avoid duplicate - // memory allocations. - // NOTE: If the parameter is initialized with a static initializer for an array - // or struct (the initialization expression is surrounded by { ... }), then we - // have to declare a static variable to ensure that the memory is put in data space - // and not on the stack. - // FIXME: Is there a better way to determine this than the string comparison? - var initializer = CParameterGenerator.getInitializer(parameter); - if (initializer.startsWith("{")) { - var temporaryVariableName = parameter.uniqueID(); - initializeTriggerObjects.pr(String.join("\n", - "static "+types.getVariableDeclaration(instance.tpr, parameter.type, temporaryVariableName, true)+" = "+initializer+";", - selfRef+"->"+parameter.getName()+" = "+temporaryVariableName+";" - )); - } else { - initializeTriggerObjects.pr(selfRef+"->"+parameter.getName()+" = "+initializer+";"); - } - } + } + + /** + * Allocate memory for inputs. + * + * @param reactor The reactor. + */ + private void initializeInputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance input : reactor.inputs) { + initializeTriggerObjects.pr( + CPortGenerator.initializeInputMultiport(input, reactorSelfStruct)); } - - /** - * Generate code that mallocs memory for any output multiports. - * @param reactor The reactor instance. - */ - private void initializeOutputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance output : reactor.outputs) { - initializeTriggerObjects.pr(CPortGenerator.initializeOutputMultiport( - output, - reactorSelfStruct - )); - } + } + + @Override + public TargetTypes getTargetTypes() { + return types; + } + + /** + * Get the Docker generator. + * + * @param context + * @return + */ + protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new CDockerGenerator(context); + } + + // ////////////////////////////////////////// + // // Protected methods. + + // Perform set up that does not generate code + protected void setUpGeneralParameters() { + accommodatePhysicalActionsIfPresent(); + targetConfig.compileDefinitions.put( + "LOG_LEVEL", String.valueOf(targetConfig.logLevel.ordinal())); + targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); + // Create the main reactor instance if there is a main reactor. + createMainReactorInstance(); + if (hasModalReactors) { + // So that each separate compile knows about modal reactors, do this: + targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); } - - /** - * Allocate memory for inputs. - * @param reactor The reactor. - */ - private void initializeInputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance input : reactor.inputs) { - initializeTriggerObjects.pr(CPortGenerator.initializeInputMultiport( - input, - reactorSelfStruct - )); - } + if (targetConfig.threading + && targetConfig.platformOptions.platform == Platform.ARDUINO + && (targetConfig.platformOptions.board == null + || !targetConfig.platformOptions.board.contains("mbed"))) { + // non-MBED boards should not use threading + System.out.println( + "Threading is incompatible on your current Arduino flavor. Setting threading to false."); + targetConfig.threading = false; } - @Override - public TargetTypes getTargetTypes() { - return types; + if (targetConfig.platformOptions.platform == Platform.ARDUINO + && !targetConfig.noCompile + && targetConfig.platformOptions.board == null) { + System.out.println( + "To enable compilation for the Arduino platform, you must specify the fully-qualified" + + " board name (FQBN) in the target property. For example, platform: {name: arduino," + + " board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target" + + " code only."); + targetConfig.noCompile = true; } - - /** - * Get the Docker generator. - * @param context - * @return - */ - protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new CDockerGenerator(context); + if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake + pickScheduler(); + // FIXME: this and pickScheduler should be combined. + targetConfig.compileDefinitions.put("SCHEDULER", targetConfig.schedulerType.name()); + targetConfig.compileDefinitions.put( + "NUMBER_OF_WORKERS", String.valueOf(targetConfig.workers)); } + pickCompilePlatform(); + } - // ////////////////////////////////////////// - // // Protected methods. - - // Perform set up that does not generate code - protected void setUpGeneralParameters() { - accommodatePhysicalActionsIfPresent(); - targetConfig.compileDefinitions.put("LOG_LEVEL", String.valueOf(targetConfig.logLevel.ordinal())); - targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); - // Create the main reactor instance if there is a main reactor. - createMainReactorInstance(); - if (hasModalReactors) { - // So that each separate compile knows about modal reactors, do this: - targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); - } - if (targetConfig.threading && targetConfig.platformOptions.platform == Platform.ARDUINO - && (targetConfig.platformOptions.board == null || !targetConfig.platformOptions.board.contains("mbed"))) { - //non-MBED boards should not use threading - System.out.println("Threading is incompatible on your current Arduino flavor. Setting threading to false."); - targetConfig.threading = false; - } - - if (targetConfig.platformOptions.platform == Platform.ARDUINO && !targetConfig.noCompile - && targetConfig.platformOptions.board == null) { - System.out.println("To enable compilation for the Arduino platform, you must specify the fully-qualified board name (FQBN) in the target property. For example, platform: {name: arduino, board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target code only."); - targetConfig.noCompile = true; - } - if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake - pickScheduler(); - // FIXME: this and pickScheduler should be combined. - targetConfig.compileDefinitions.put( - "SCHEDULER", - targetConfig.schedulerType.name() - ); - targetConfig.compileDefinitions.put( - "NUMBER_OF_WORKERS", - String.valueOf(targetConfig.workers) - ); - } - pickCompilePlatform(); + protected void handleProtoFiles() { + // Handle .proto files. + for (String file : targetConfig.protoFiles) { + this.processProtoFile(file); } - - protected void handleProtoFiles() { - // Handle .proto files. - for (String file : targetConfig.protoFiles) { - this.processProtoFile(file); - } + } + + /** + * Generate code that needs to appear at the top of the generated C file, such as #define and + * #include statements. + */ + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr( + CPreambleGenerator.generateDefineDirectives( + targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); + code.pr(CPreambleGenerator.generateIncludeStatements(targetConfig, CCppMode)); + return code.toString(); + } + + /** Generate top-level preamble code. */ + protected String generateTopLevelPreambles(Reactor reactor) { + CodeBuilder builder = new CodeBuilder(); + var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; + builder.pr("#ifndef " + guard); + builder.pr("#define " + guard); + // Reactors that are instantiated by the specified reactor need to have + // their file-level preambles included. This needs to also include file-level + // preambles of base classes of those reactors. + Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) + .flatMap(it -> ASTUtils.allFileLevelPreambles(it).stream()) + .collect(Collectors.toSet()) + .forEach(it -> builder.pr(toText(it.getCode()))); + for (String file : targetConfig.protoFiles) { + var dotIndex = file.lastIndexOf("."); + var rootFilename = file; + if (dotIndex > 0) { + rootFilename = file.substring(0, dotIndex); + } + code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); + builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); } - - /** - * Generate code that needs to appear at the top of the generated - * C file, such as #define and #include statements. - */ - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr(CPreambleGenerator.generateDefineDirectives( - targetConfig, - fileConfig.getSrcGenPath(), - hasModalReactors - )); - code.pr(CPreambleGenerator.generateIncludeStatements( - targetConfig, - CCppMode - )); - return code.toString(); + builder.pr("#endif"); + return builder.toString(); + } + + protected boolean targetLanguageIsCpp() { + return CCppMode; + } + + /** + * Given a line of text from the output of a compiler, return an instance of ErrorFileAndLine if + * the line is recognized as the first line of an error message. Otherwise, return null. + * + * @param line A line of output from a compiler or other external tool that might generate errors. + * @return If the line is recognized as the start of an error message, then return a class + * containing the path to the file on which the error occurred (or null if there is none), the + * line number (or the string "1" if there is none), the character position (or the string "0" + * if there is none), and the message (or an empty string if there is none). + */ + @Override + public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { + var matcher = compileErrorPattern.matcher(line); + if (matcher.find()) { + var result = new ErrorFileAndLine(); + result.filepath = matcher.group("path"); + result.line = matcher.group("line"); + result.character = matcher.group("column"); + result.message = matcher.group("message"); + + if (!result.message.toLowerCase().contains("error:")) { + result.isError = false; + } + return result; } - - /** - * Generate top-level preamble code. - */ - protected String generateTopLevelPreambles(Reactor reactor) { - CodeBuilder builder = new CodeBuilder(); - var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; - builder.pr("#ifndef " + guard); - builder.pr("#define " + guard); - // Reactors that are instantiated by the specified reactor need to have - // their file-level preambles included. This needs to also include file-level - // preambles of base classes of those reactors. - Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) - .flatMap(it -> ASTUtils.allFileLevelPreambles(it).stream()) - .collect(Collectors.toSet()) - .forEach(it -> builder.pr(toText(it.getCode()))); - for (String file : targetConfig.protoFiles) { - var dotIndex = file.lastIndexOf("."); - var rootFilename = file; - if (dotIndex > 0) { - rootFilename = file.substring(0, dotIndex); - } - code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); - builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); + return null; + } + + //////////////////////////////////////////// + //// Private methods. + + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.C; + } + + //////////////////////////////////////////////////////////// + //// Private methods + + /** + * If a main or federated reactor has been declared, create a ReactorInstance for this top level. + * This will also assign levels to reactions, then, if the program is federated, perform an AST + * transformation to disconnect connections between federates. + */ + private void createMainReactorInstance() { + if (this.mainDef != null) { + if (this.main == null) { + // Recursively build instances. + this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); + var reactionInstanceGraph = this.main.assignLevels(); + if (reactionInstanceGraph.nodeCount() > 0) { + errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); + return; } - builder.pr("#endif"); - return builder.toString(); - } - - protected boolean targetLanguageIsCpp() { - return CCppMode; - } - - /** Given a line of text from the output of a compiler, return - * an instance of ErrorFileAndLine if the line is recognized as - * the first line of an error message. Otherwise, return null. - * @param line A line of output from a compiler or other external - * tool that might generate errors. - * @return If the line is recognized as the start of an error message, - * then return a class containing the path to the file on which the - * error occurred (or null if there is none), the line number (or the - * string "1" if there is none), the character position (or the string - * "0" if there is none), and the message (or an empty string if there - * is none). - */ - @Override - public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { - var matcher = compileErrorPattern.matcher(line); - if (matcher.find()) { - var result = new ErrorFileAndLine(); - result.filepath = matcher.group("path"); - result.line = matcher.group("line"); - result.character = matcher.group("column"); - result.message = matcher.group("message"); - - if (!result.message.toLowerCase().contains("error:")) { - result.isError = false; - } - return result; + if (hasDeadlines) { + this.main.assignDeadlines(); } - return null; - } - - //////////////////////////////////////////// - //// Private methods. - - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.C; - } - - //////////////////////////////////////////////////////////// - //// Private methods - - /** - * If a main or federated reactor has been declared, create a ReactorInstance - * for this top level. This will also assign levels to reactions, then, - * if the program is federated, perform an AST transformation to disconnect - * connections between federates. - */ - private void createMainReactorInstance() { - if (this.mainDef != null) { - if (this.main == null) { - // Recursively build instances. - this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); - var reactionInstanceGraph = this.main.assignLevels(); - if (reactionInstanceGraph.nodeCount() > 0) { - errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); - return; - } - if (hasDeadlines) { - this.main.assignDeadlines(); - } - // Inform the run-time of the breadth/parallelism of the reaction graph - var breadth = reactionInstanceGraph.getBreadth(); - if (breadth == 0) { - errorReporter.reportWarning("The program has no reactions"); - } else { - targetConfig.compileDefinitions.put( - "LF_REACTION_GRAPH_BREADTH", - String.valueOf(reactionInstanceGraph.getBreadth()) - ); - } - } + // Inform the run-time of the breadth/parallelism of the reaction graph + var breadth = reactionInstanceGraph.getBreadth(); + if (breadth == 0) { + errorReporter.reportWarning("The program has no reactions"); + } else { + targetConfig.compileDefinitions.put( + "LF_REACTION_GRAPH_BREADTH", String.valueOf(reactionInstanceGraph.getBreadth())); } + } } - - /** - * Generate an array of self structs for the reactor - * and one for each of its children. - * @param r The reactor instance. - */ - private void generateSelfStructs(ReactorInstance r) { - initializeTriggerObjects.pr(CUtil.selfType(r)+"* "+CUtil.reactorRefName(r)+"["+r.getTotalWidth()+"];"); - initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING("+CUtil.reactorRefName(r)+");"); - for (ReactorInstance child : r.children) { - generateSelfStructs(child); - } + } + + /** + * Generate an array of self structs for the reactor and one for each of its children. + * + * @param r The reactor instance. + */ + private void generateSelfStructs(ReactorInstance r) { + initializeTriggerObjects.pr( + CUtil.selfType(r) + "* " + CUtil.reactorRefName(r) + "[" + r.getTotalWidth() + "];"); + initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING(" + CUtil.reactorRefName(r) + ");"); + for (ReactorInstance child : r.children) { + generateSelfStructs(child); } + } - private Stream allTypeParameterizedReactors() { - return ASTUtils.recursiveChildren(main).stream() - .map(it -> it.tpr) - .distinct(); - } + private Stream allTypeParameterizedReactors() { + return ASTUtils.recursiveChildren(main).stream().map(it -> it.tpr).distinct(); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java b/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java index 533611368a..044874029f 100644 --- a/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java @@ -3,120 +3,113 @@ import java.util.ArrayList; import java.util.List; import org.lflang.TargetConfig; +import org.lflang.TargetProperty.Platform; import org.lflang.generator.CodeBuilder; import org.lflang.util.StringUtil; -import org.lflang.TargetProperty.Platform; public class CMainFunctionGenerator { - private TargetConfig targetConfig; - /** The command to run the generated code if specified in the target directive. */ - private List runCommand; + private TargetConfig targetConfig; + /** The command to run the generated code if specified in the target directive. */ + private List runCommand; - public CMainFunctionGenerator(TargetConfig targetConfig) { - this.targetConfig = targetConfig; - runCommand = new ArrayList<>(); - parseTargetParameters(); - } + public CMainFunctionGenerator(TargetConfig targetConfig) { + this.targetConfig = targetConfig; + runCommand = new ArrayList<>(); + parseTargetParameters(); + } - /** - * Generate the code that is the entry point - * of the program. - * - * Ideally, this code would belong to its own {@code main.c} - * file, but it currently lives in the same file - * as all the code generated for reactors. - */ - public String generateCode() { - CodeBuilder code = new CodeBuilder(); - code.pr(generateMainFunction()); - code.pr(generateSetDefaultCliOption()); - return code.toString(); - } + /** + * Generate the code that is the entry point of the program. + * + *

    Ideally, this code would belong to its own {@code main.c} file, but it currently lives in + * the same file as all the code generated for reactors. + */ + public String generateCode() { + CodeBuilder code = new CodeBuilder(); + code.pr(generateMainFunction()); + code.pr(generateSetDefaultCliOption()); + return code.toString(); + } - /** - * Generate the {@code main} function. - */ - private String generateMainFunction() { - if (targetConfig.platformOptions.platform == Platform.ARDUINO) { - /** - By default, we must have a serial begin line prior to calling lf_reactor_c_main due to internal debugging messages requiring a print buffer. - For the future, we can check whether internal LF logging is enabled or not before removing this line. - - Logging - */ - return String.join("\n", - "\nvoid _lf_arduino_print_message_function(const char* format, va_list args) {", - "\tchar buf[128];", - "\tvsnprintf(buf, 128, format, args);", - "\tSerial.print(buf);", - "}\n", - "// Arduino setup() and loop() functions", - "void setup() {", - "\tSerial.begin(" + targetConfig.platformOptions.baudRate + ");", - "\tlf_register_print_function(&_lf_arduino_print_message_function, LOG_LEVEL);", - "\tlf_reactor_c_main(0, NULL);", - "}\n", - "void loop() {}" - ); - } else if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - // The Zephyr "runtime" does not terminate when main returns. - // Rather, {@code exit} should be called explicitly. - return String.join("\n", - "void main(void) {", - " int res = lf_reactor_c_main(0, NULL);", - " exit(res);", - "}" - ); - } else { - return String.join("\n", - "int main(int argc, const char* argv[]) {", - " return lf_reactor_c_main(argc, argv);", - "}" - ); - } + /** Generate the {@code main} function. */ + private String generateMainFunction() { + if (targetConfig.platformOptions.platform == Platform.ARDUINO) { + /** + * By default, we must have a serial begin line prior to calling lf_reactor_c_main due to + * internal debugging messages requiring a print buffer. For the future, we can check whether + * internal LF logging is enabled or not before removing this line. - Logging + */ + return String.join( + "\n", + "\nvoid _lf_arduino_print_message_function(const char* format, va_list args) {", + "\tchar buf[128];", + "\tvsnprintf(buf, 128, format, args);", + "\tSerial.print(buf);", + "}\n", + "// Arduino setup() and loop() functions", + "void setup() {", + "\tSerial.begin(" + targetConfig.platformOptions.baudRate + ");", + "\tlf_register_print_function(&_lf_arduino_print_message_function, LOG_LEVEL);", + "\tlf_reactor_c_main(0, NULL);", + "}\n", + "void loop() {}"); + } else if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + // The Zephyr "runtime" does not terminate when main returns. + // Rather, {@code exit} should be called explicitly. + return String.join( + "\n", + "void main(void) {", + " int res = lf_reactor_c_main(0, NULL);", + " exit(res);", + "}"); + } else { + return String.join( + "\n", + "int main(int argc, const char* argv[]) {", + " return lf_reactor_c_main(argc, argv);", + "}"); } + } - /** - * Generate code that is used to override the - * command line options to the {@code main} function - */ - private String generateSetDefaultCliOption() { - // Generate function to set default command-line options. - // A literal array needs to be given outside any function definition, - // so start with that. - return runCommand.size() > 0 ? - String.join("\n", - "const char* _lf_default_argv[] = { " + - StringUtil.addDoubleQuotes( - StringUtil.joinObjects(runCommand, - StringUtil.addDoubleQuotes(", ")))+" };", - "void _lf_set_default_command_line_options() {", - " default_argc = "+runCommand.size()+";", - " default_argv = _lf_default_argv;", - "}") - : "void _lf_set_default_command_line_options() {}"; - } + /** + * Generate code that is used to override the command line options to the {@code main} function + */ + private String generateSetDefaultCliOption() { + // Generate function to set default command-line options. + // A literal array needs to be given outside any function definition, + // so start with that. + return runCommand.size() > 0 + ? String.join( + "\n", + "const char* _lf_default_argv[] = { " + + StringUtil.addDoubleQuotes( + StringUtil.joinObjects(runCommand, StringUtil.addDoubleQuotes(", "))) + + " };", + "void _lf_set_default_command_line_options() {", + " default_argc = " + runCommand.size() + ";", + " default_argv = _lf_default_argv;", + "}") + : "void _lf_set_default_command_line_options() {}"; + } - /** - * Parse the target parameters and set flags to the runCommand - * accordingly. - */ - private void parseTargetParameters() { - if (targetConfig.fastMode) { - runCommand.add("-f"); - runCommand.add("true"); - } - if (targetConfig.keepalive) { - runCommand.add("-k"); - runCommand.add("true"); - } - if (targetConfig.timeout != null) { - runCommand.add("-o"); - runCommand.add(targetConfig.timeout.getMagnitude() + ""); - runCommand.add(targetConfig.timeout.unit.getCanonicalName()); - } - // The runCommand has a first entry that is ignored but needed. - if (runCommand.size() > 0) { - runCommand.add(0, "dummy"); - } + /** Parse the target parameters and set flags to the runCommand accordingly. */ + private void parseTargetParameters() { + if (targetConfig.fastMode) { + runCommand.add("-f"); + runCommand.add("true"); + } + if (targetConfig.keepalive) { + runCommand.add("-k"); + runCommand.add("true"); + } + if (targetConfig.timeout != null) { + runCommand.add("-o"); + runCommand.add(targetConfig.timeout.getMagnitude() + ""); + runCommand.add(targetConfig.timeout.unit.getCanonicalName()); + } + // The runCommand has a first entry that is ignored but needed. + if (runCommand.size() > 0) { + runCommand.add(0, "dummy"); } + } } diff --git a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java index 5da00ac70e..1950e8df82 100644 --- a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java @@ -2,8 +2,8 @@ import static org.lflang.ast.ASTUtils.allMethods; -import org.lflang.ast.ASTUtils; import org.lflang.InferredType; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Method; import org.lflang.lf.Reactor; @@ -15,165 +15,151 @@ */ public class CMethodGenerator { - /** - * Generate macro definitions for methods. - * @param tpr The reactor. - * @param body The place to put the macro definitions. - */ - public static void generateMacrosForMethods( - TypeParameterizedReactor tpr, - CodeBuilder body - ) { - for (Method method : allMethods(tpr.reactor())) { - var functionName = methodFunctionName(tpr, method); - // If the method has no arguments. Do not pass it any variadic arguments. - if (method.getArguments().size() > 0) { - body.pr("#define "+method.getName()+"(...) "+functionName+"(self, ##__VA_ARGS__)"); - } else { - body.pr("#define "+method.getName()+"() "+functionName+"(self)"); - } - } + /** + * Generate macro definitions for methods. + * + * @param tpr The reactor. + * @param body The place to put the macro definitions. + */ + public static void generateMacrosForMethods(TypeParameterizedReactor tpr, CodeBuilder body) { + for (Method method : allMethods(tpr.reactor())) { + var functionName = methodFunctionName(tpr, method); + // If the method has no arguments. Do not pass it any variadic arguments. + if (method.getArguments().size() > 0) { + body.pr("#define " + method.getName() + "(...) " + functionName + "(self, ##__VA_ARGS__)"); + } else { + body.pr("#define " + method.getName() + "() " + functionName + "(self)"); + } } + } - /** - * Generate macro undefinitions for methods. - * @param reactor The reactor. - * @param body The place to put the macro definitions. - */ - public static void generateMacroUndefsForMethods( - Reactor reactor, - CodeBuilder body - ) { - for (Method method : allMethods(reactor)) { - body.pr("#undef "+method.getName()); - } + /** + * Generate macro undefinitions for methods. + * + * @param reactor The reactor. + * @param body The place to put the macro definitions. + */ + public static void generateMacroUndefsForMethods(Reactor reactor, CodeBuilder body) { + for (Method method : allMethods(reactor)) { + body.pr("#undef " + method.getName()); } + } - /** - * Generate a method function definition for a reactor. - * This function will have a first argument that is a void* pointing to - * the self struct, followed by any arguments given in its definition. - * @param method The method. - * @param tpr The concrete reactor class. - * @param types The C-specific type conversion functions. - */ - public static String generateMethod( - Method method, - TypeParameterizedReactor tpr, - CTypes types - ) { - var code = new CodeBuilder(); - var body = ASTUtils.toText(method.getCode()); - - code.prSourceLineNumber(method); - code.prComment("Implementation of method "+method.getName()+"()"); - code.pr(generateMethodSignature(method, tpr, types) + " {"); - code.indent(); + /** + * Generate a method function definition for a reactor. This function will have a first argument + * that is a void* pointing to the self struct, followed by any arguments given in its definition. + * + * @param method The method. + * @param tpr The concrete reactor class. + * @param types The C-specific type conversion functions. + */ + public static String generateMethod(Method method, TypeParameterizedReactor tpr, CTypes types) { + var code = new CodeBuilder(); + var body = ASTUtils.toText(method.getCode()); - // Define the "self" struct. - String structType = CUtil.selfType(tpr); - // A null structType means there are no inputs, state, - // or anything else. No need to declare it. - if (structType != null) { - code.pr(String.join("\n", - structType+"* self = ("+structType+"*)instance_args;" - + " SUPPRESS_UNUSED_WARNING(self);" - )); - } + code.prSourceLineNumber(method); + code.prComment("Implementation of method " + method.getName() + "()"); + code.pr(generateMethodSignature(method, tpr, types) + " {"); + code.indent(); - code.prSourceLineNumber(method.getCode()); - code.pr(body); - code.unindent(); - code.pr("}"); - return code.toString(); + // Define the "self" struct. + String structType = CUtil.selfType(tpr); + // A null structType means there are no inputs, state, + // or anything else. No need to declare it. + if (structType != null) { + code.pr( + String.join( + "\n", + structType + + "* self = (" + + structType + + "*)instance_args;" + + " SUPPRESS_UNUSED_WARNING(self);")); } - /** - * Generate method functions definition for a reactor. - * These functions have a first argument that is a void* pointing to - * the self struct. - * @param tpr The reactor. - * @param code The place to put the code. - * @param types The C-specific type conversion functions. - */ - public static void generateMethods( - TypeParameterizedReactor tpr, - CodeBuilder code, - CTypes types - ) { - var reactor = tpr.reactor(); - code.prComment("***** Start of method declarations."); - signatures(tpr, code, types); - generateMacrosForMethods(tpr, code); - for (Method method : allMethods(reactor)) { - code.pr(CMethodGenerator.generateMethod(method, tpr, types)); - } - generateMacroUndefsForMethods(reactor, code); - code.prComment("***** End of method declarations."); - } + code.prSourceLineNumber(method.getCode()); + code.pr(body); + code.unindent(); + code.pr("}"); + return code.toString(); + } - /** - * Generate function signatures for methods. - * This can be used to declare all the methods with signatures only - * before giving the full definition so that methods may call each other - * (and themselves) regardless of the order of definition. - * @param tpr The reactor declaration. - * @param types The C-specific type conversion functions. - */ - public static void signatures( - TypeParameterizedReactor tpr, - CodeBuilder body, - CTypes types - ) { - Reactor reactor = tpr.reactor(); - for (Method method : allMethods(reactor)) { - body.pr(generateMethodSignature(method, tpr, types) + ";"); - } + /** + * Generate method functions definition for a reactor. These functions have a first argument that + * is a void* pointing to the self struct. + * + * @param tpr The reactor. + * @param code The place to put the code. + * @param types The C-specific type conversion functions. + */ + public static void generateMethods(TypeParameterizedReactor tpr, CodeBuilder code, CTypes types) { + var reactor = tpr.reactor(); + code.prComment("***** Start of method declarations."); + signatures(tpr, code, types); + generateMacrosForMethods(tpr, code); + for (Method method : allMethods(reactor)) { + code.pr(CMethodGenerator.generateMethod(method, tpr, types)); } + generateMacroUndefsForMethods(reactor, code); + code.prComment("***** End of method declarations."); + } - /** - * Return the function name for specified method of the specified reactor. - * @param tpr The reactor - * @param method The method. - * @return The function name for the method. - */ - private static String methodFunctionName(TypeParameterizedReactor tpr, Method method) { - return CUtil.getName(tpr) + "_method_" + method.getName(); + /** + * Generate function signatures for methods. This can be used to declare all the methods with + * signatures only before giving the full definition so that methods may call each other (and + * themselves) regardless of the order of definition. + * + * @param tpr The reactor declaration. + * @param types The C-specific type conversion functions. + */ + public static void signatures(TypeParameterizedReactor tpr, CodeBuilder body, CTypes types) { + Reactor reactor = tpr.reactor(); + for (Method method : allMethods(reactor)) { + body.pr(generateMethodSignature(method, tpr, types) + ";"); } + } + + /** + * Return the function name for specified method of the specified reactor. + * + * @param tpr The reactor + * @param method The method. + * @return The function name for the method. + */ + private static String methodFunctionName(TypeParameterizedReactor tpr, Method method) { + return CUtil.getName(tpr) + "_method_" + method.getName(); + } - /** - * Generate a method function signature for a reactor. - * This function will have a first argument that is a void* pointing to - * the self struct, followed by any arguments given in its definition. - * @param method The method. - * @param tpr The reactor declaration. - * @param types The C-specific type conversion functions. - */ - public static String generateMethodSignature( - Method method, - TypeParameterizedReactor tpr, - CTypes types - ) { - var functionName = methodFunctionName(tpr, method); + /** + * Generate a method function signature for a reactor. This function will have a first argument + * that is a void* pointing to the self struct, followed by any arguments given in its definition. + * + * @param method The method. + * @param tpr The reactor declaration. + * @param types The C-specific type conversion functions. + */ + public static String generateMethodSignature( + Method method, TypeParameterizedReactor tpr, CTypes types) { + var functionName = methodFunctionName(tpr, method); - StringBuilder result = new StringBuilder(); - if (method.getReturn() != null) { - result.append(types.getTargetType(InferredType.fromAST(method.getReturn()))); - result.append(" "); - } else { - result.append("void "); - } - result.append(functionName); - result.append("(void* instance_args"); - if (method.getArguments() != null) { - for (var arg : method.getArguments()) { - result.append(", "); - result.append(types.getTargetType(InferredType.fromAST(arg.getType()))); - result.append(" "); - result.append(arg.getName()); - } - } - result.append(")"); - return result.toString(); + StringBuilder result = new StringBuilder(); + if (method.getReturn() != null) { + result.append(types.getTargetType(InferredType.fromAST(method.getReturn()))); + result.append(" "); + } else { + result.append("void "); + } + result.append(functionName); + result.append("(void* instance_args"); + if (method.getArguments() != null) { + for (var arg : method.getArguments()) { + result.append(", "); + result.append(types.getTargetType(InferredType.fromAST(arg.getType()))); + result.append(" "); + result.append(arg.getName()); + } } + result.append(")"); + return result.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CMixedRadixGenerator.java b/org.lflang/src/org/lflang/generator/c/CMixedRadixGenerator.java index 40717f3c4d..f2bf71ef66 100644 --- a/org.lflang/src/org/lflang/generator/c/CMixedRadixGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CMixedRadixGenerator.java @@ -1,16 +1,16 @@ package org.lflang.generator.c; public class CMixedRadixGenerator { - /** Standardized name for channel index variable for a source. */ - public static String sc = "src_channel"; - /** Standardized name for bank index variable for a source. */ - public static String sb = "src_bank"; - /** Standardized name for runtime index variable for a source. */ - public static String sr = "src_runtime"; - /** Standardized name for channel index variable for a destination. */ - public static String dc = "dst_channel"; - /** Standardized name for bank index variable for a destination. */ - public static String db = "dst_bank"; - /** Standardized name for runtime index variable for a destination. */ - public static String dr = "dst_runtime"; + /** Standardized name for channel index variable for a source. */ + public static String sc = "src_channel"; + /** Standardized name for bank index variable for a source. */ + public static String sb = "src_bank"; + /** Standardized name for runtime index variable for a source. */ + public static String sr = "src_runtime"; + /** Standardized name for channel index variable for a destination. */ + public static String dc = "dst_channel"; + /** Standardized name for bank index variable for a destination. */ + public static String db = "dst_bank"; + /** Standardized name for runtime index variable for a destination. */ + public static String dr = "dst_runtime"; } diff --git a/org.lflang/src/org/lflang/generator/c/CModesGenerator.java b/org.lflang/src/org/lflang/generator/c/CModesGenerator.java index 2a6217de64..7d72890639 100644 --- a/org.lflang/src/org/lflang/generator/c/CModesGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CModesGenerator.java @@ -1,7 +1,6 @@ package org.lflang.generator.c; import java.util.List; - import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.ReactionInstance; @@ -17,203 +16,228 @@ * @author Hou Seng Wong */ public class CModesGenerator { - /** - * Generate fields in the self struct for mode instances - * - * @param reactor - * @param body - * @param constructorCode - */ - public static void generateDeclarations( - Reactor reactor, - CodeBuilder body, - CodeBuilder constructorCode - ) { - List allModes = ASTUtils.allModes(reactor); - if (!allModes.isEmpty()) { - // Reactor's mode instances and its state. - body.pr(String.join("\n", - "reactor_mode_t _lf__modes["+reactor.getModes().size()+"];" - )); + /** + * Generate fields in the self struct for mode instances + * + * @param reactor + * @param body + * @param constructorCode + */ + public static void generateDeclarations( + Reactor reactor, CodeBuilder body, CodeBuilder constructorCode) { + List allModes = ASTUtils.allModes(reactor); + if (!allModes.isEmpty()) { + // Reactor's mode instances and its state. + body.pr(String.join("\n", "reactor_mode_t _lf__modes[" + reactor.getModes().size() + "];")); - // Initialize the mode instances - constructorCode.pr("// Initialize modes"); - constructorCode.pr("self_base_t* _lf_self_base = (self_base_t*)self;"); - int initialMode = -1; + // Initialize the mode instances + constructorCode.pr("// Initialize modes"); + constructorCode.pr("self_base_t* _lf_self_base = (self_base_t*)self;"); + int initialMode = -1; - for (int i = 0; i < allModes.size(); i++){ - var mode = allModes.get(i); - constructorCode.pr(mode, String.join("\n", - "self->_lf__modes["+i+"].state = &_lf_self_base->_lf__mode_state;", - "self->_lf__modes["+i+"].name = \""+mode.getName()+"\";", - "self->_lf__modes["+i+"].deactivation_time = 0;", - "self->_lf__modes["+i+"].flags = 0;" - )); - if (initialMode < 0 && mode.isInitial()) { - initialMode = i; - } - } + for (int i = 0; i < allModes.size(); i++) { + var mode = allModes.get(i); + constructorCode.pr( + mode, + String.join( + "\n", + "self->_lf__modes[" + i + "].state = &_lf_self_base->_lf__mode_state;", + "self->_lf__modes[" + i + "].name = \"" + mode.getName() + "\";", + "self->_lf__modes[" + i + "].deactivation_time = 0;", + "self->_lf__modes[" + i + "].flags = 0;")); + if (initialMode < 0 && mode.isInitial()) { + initialMode = i; + } + } - assert initialMode >= 0 : "initial mode must be non-negative!!"; + assert initialMode >= 0 : "initial mode must be non-negative!!"; - // Initialize mode state with initial mode active upon start - constructorCode.pr(String.join("\n", - "// Initialize mode state", - "_lf_self_base->_lf__mode_state.parent_mode = NULL;", - "_lf_self_base->_lf__mode_state.initial_mode = &self->_lf__modes["+initialMode+"];", - "_lf_self_base->_lf__mode_state.current_mode = _lf_self_base->_lf__mode_state.initial_mode;", - "_lf_self_base->_lf__mode_state.next_mode = NULL;", - "_lf_self_base->_lf__mode_state.mode_change = no_transition;" - )); - } + // Initialize mode state with initial mode active upon start + constructorCode.pr( + String.join( + "\n", + "// Initialize mode state", + "_lf_self_base->_lf__mode_state.parent_mode = NULL;", + "_lf_self_base->_lf__mode_state.initial_mode = &self->_lf__modes[" + + initialMode + + "];", + "_lf_self_base->_lf__mode_state.current_mode =" + + " _lf_self_base->_lf__mode_state.initial_mode;", + "_lf_self_base->_lf__mode_state.next_mode = NULL;", + "_lf_self_base->_lf__mode_state.mode_change = no_transition;")); } + } - /** - * Generate the declaration of modal models state table. - * - * @param hasModalReactors True if there is modal model reactors, false otherwise - * @param modalReactorCount The number of modal model reactors - * @param modalStateResetCount The number of modal model state resets - */ - public static String generateModeStatesTable( - boolean hasModalReactors, - int modalReactorCount, - int modalStateResetCount - ) { - if (hasModalReactors) { - return String.join("\n", - "// Array of pointers to mode states to be handled in _lf_handle_mode_changes().", - "reactor_mode_state_t* _lf_modal_reactor_states["+modalReactorCount+"];", - "int _lf_modal_reactor_states_size = "+modalReactorCount+";", - (modalStateResetCount > 0 ? - String.join("\n", - "// Array of reset data for state variables nested in modes. Used in _lf_handle_mode_changes().", - "mode_state_variable_reset_data_t _lf_modal_state_reset["+modalStateResetCount+"];", - "int _lf_modal_state_reset_size = "+modalStateResetCount+";") - : "" - )); - } - return ""; + /** + * Generate the declaration of modal models state table. + * + * @param hasModalReactors True if there is modal model reactors, false otherwise + * @param modalReactorCount The number of modal model reactors + * @param modalStateResetCount The number of modal model state resets + */ + public static String generateModeStatesTable( + boolean hasModalReactors, int modalReactorCount, int modalStateResetCount) { + if (hasModalReactors) { + return String.join( + "\n", + "// Array of pointers to mode states to be handled in _lf_handle_mode_changes().", + "reactor_mode_state_t* _lf_modal_reactor_states[" + modalReactorCount + "];", + "int _lf_modal_reactor_states_size = " + modalReactorCount + ";", + (modalStateResetCount > 0 + ? String.join( + "\n", + "// Array of reset data for state variables nested in modes. Used in" + + " _lf_handle_mode_changes().", + "mode_state_variable_reset_data_t _lf_modal_state_reset[" + + modalStateResetCount + + "];", + "int _lf_modal_state_reset_size = " + modalStateResetCount + ";") + : "")); } + return ""; + } - /** - * Generate counter variable declarations used for registering modal reactors. - * - * @param hasModalReactors True if there is modal model reactors, false otherwise - */ - public static String generateModalInitalizationCounters(boolean hasModalReactors) { - if (hasModalReactors) { - return String.join("\n", - "int _lf_modal_reactor_states_count = 0;", - "int _lf_modal_state_reset_count = 0;" - ); - } - return ""; + /** + * Generate counter variable declarations used for registering modal reactors. + * + * @param hasModalReactors True if there is modal model reactors, false otherwise + */ + public static String generateModalInitalizationCounters(boolean hasModalReactors) { + if (hasModalReactors) { + return String.join( + "\n", "int _lf_modal_reactor_states_count = 0;", "int _lf_modal_state_reset_count = 0;"); } + return ""; + } - /** - * Generate code for modal reactor registration and hierarchy. - * - * @param instance The reactor instance. - * @param code The code builder. - */ - public static void generateModeStructure(ReactorInstance instance, CodeBuilder code) { - var parentMode = instance.getMode(false); - var nameOfSelfStruct = CUtil.reactorRef(instance); - // If this instance is enclosed in another mode - if (parentMode != null) { - var parentModeRef = "&"+CUtil.reactorRef(parentMode.getParent())+"->_lf__modes["+parentMode.getParent().modes.indexOf(parentMode)+"]"; - code.pr("// Setup relation to enclosing mode"); + /** + * Generate code for modal reactor registration and hierarchy. + * + * @param instance The reactor instance. + * @param code The code builder. + */ + public static void generateModeStructure(ReactorInstance instance, CodeBuilder code) { + var parentMode = instance.getMode(false); + var nameOfSelfStruct = CUtil.reactorRef(instance); + // If this instance is enclosed in another mode + if (parentMode != null) { + var parentModeRef = + "&" + + CUtil.reactorRef(parentMode.getParent()) + + "->_lf__modes[" + + parentMode.getParent().modes.indexOf(parentMode) + + "]"; + code.pr("// Setup relation to enclosing mode"); - // If this reactor does not have its own modes, all reactions must be linked to enclosing mode - if (instance.modes.isEmpty()) { - int i = 0; - for (ReactionInstance reaction : instance.reactions) { - code.pr(CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+i+".mode = "+parentModeRef+";"); - i++; - } - } else { // Otherwise, only reactions outside modes must be linked and the mode state itself gets a parent relation - code.pr("((self_base_t*)"+nameOfSelfStruct+")->_lf__mode_state.parent_mode = "+parentModeRef+";"); - for (var reaction : (Iterable) instance.reactions.stream().filter(it -> it.getMode(true) == null)::iterator) { - code.pr(CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+instance.reactions.indexOf(reaction)+".mode = "+parentModeRef+";"); - } - } + // If this reactor does not have its own modes, all reactions must be linked to enclosing mode + if (instance.modes.isEmpty()) { + int i = 0; + for (ReactionInstance reaction : instance.reactions) { + code.pr( + CUtil.reactorRef(reaction.getParent()) + + "->_lf__reaction_" + + i + + ".mode = " + + parentModeRef + + ";"); + i++; } - // If this reactor has modes, register for mode change handling - if (!instance.modes.isEmpty()) { - code.pr("// Register for transition handling"); - code.pr("_lf_modal_reactor_states[_lf_modal_reactor_states_count++] = &((self_base_t*)"+nameOfSelfStruct+")->_lf__mode_state;"); + } else { // Otherwise, only reactions outside modes must be linked and the mode state itself + // gets a parent relation + code.pr( + "((self_base_t*)" + + nameOfSelfStruct + + ")->_lf__mode_state.parent_mode = " + + parentModeRef + + ";"); + for (var reaction : + (Iterable) + instance.reactions.stream().filter(it -> it.getMode(true) == null)::iterator) { + code.pr( + CUtil.reactorRef(reaction.getParent()) + + "->_lf__reaction_" + + instance.reactions.indexOf(reaction) + + ".mode = " + + parentModeRef + + ";"); } + } } + // If this reactor has modes, register for mode change handling + if (!instance.modes.isEmpty()) { + code.pr("// Register for transition handling"); + code.pr( + "_lf_modal_reactor_states[_lf_modal_reactor_states_count++] = &((self_base_t*)" + + nameOfSelfStruct + + ")->_lf__mode_state;"); + } + } - /** - * Generate code registering a state variable for automatic reset. - * - * @param modeRef The code to refer to the mode - * @param selfRef The code to refer to the self struct - * @param varName The variable name in the self struct - * @param source The variable that stores the initial value - * @param type The size of the initial value - */ - public static String generateStateResetStructure( - String modeRef, - String selfRef, - String varName, - String source, - String type - ) { - return String.join("\n", - "// Register for automatic reset", - "_lf_modal_state_reset[_lf_modal_state_reset_count].mode = "+modeRef+";", - "_lf_modal_state_reset[_lf_modal_state_reset_count].target = &("+selfRef+"->"+varName+");", - "_lf_modal_state_reset[_lf_modal_state_reset_count].source = &"+source+";", - "_lf_modal_state_reset[_lf_modal_state_reset_count].size = sizeof("+type+");", - "_lf_modal_state_reset_count++;" - ); - } + /** + * Generate code registering a state variable for automatic reset. + * + * @param modeRef The code to refer to the mode + * @param selfRef The code to refer to the self struct + * @param varName The variable name in the self struct + * @param source The variable that stores the initial value + * @param type The size of the initial value + */ + public static String generateStateResetStructure( + String modeRef, String selfRef, String varName, String source, String type) { + return String.join( + "\n", + "// Register for automatic reset", + "_lf_modal_state_reset[_lf_modal_state_reset_count].mode = " + modeRef + ";", + "_lf_modal_state_reset[_lf_modal_state_reset_count].target = &(" + + selfRef + + "->" + + varName + + ");", + "_lf_modal_state_reset[_lf_modal_state_reset_count].source = &" + source + ";", + "_lf_modal_state_reset[_lf_modal_state_reset_count].size = sizeof(" + type + ");", + "_lf_modal_state_reset_count++;"); + } - /** - * Generate code to call {@code _lf_process_mode_changes}. - * - * @param hasModalReactors True if there is modal model reactors, false otherwise - * @param modalStateResetCount The number of modal model state resets - */ - public static String generateLfHandleModeChanges( - boolean hasModalReactors, - int modalStateResetCount - ) { - if (!hasModalReactors) { - return ""; - } - return String.join("\n", - "void _lf_handle_mode_changes() {", - " _lf_process_mode_changes(", - " _lf_modal_reactor_states, ", - " _lf_modal_reactor_states_size, ", - " " + (modalStateResetCount > 0 ? "_lf_modal_state_reset" : "NULL") + ", ", - " " + (modalStateResetCount > 0 ? "_lf_modal_state_reset_size" : "0") + ", ", - " _lf_timer_triggers, ", - " _lf_timer_triggers_size", - " );", - "}" - ); + /** + * Generate code to call {@code _lf_process_mode_changes}. + * + * @param hasModalReactors True if there is modal model reactors, false otherwise + * @param modalStateResetCount The number of modal model state resets + */ + public static String generateLfHandleModeChanges( + boolean hasModalReactors, int modalStateResetCount) { + if (!hasModalReactors) { + return ""; } + return String.join( + "\n", + "void _lf_handle_mode_changes() {", + " _lf_process_mode_changes(", + " _lf_modal_reactor_states, ", + " _lf_modal_reactor_states_size, ", + " " + (modalStateResetCount > 0 ? "_lf_modal_state_reset" : "NULL") + ", ", + " " + (modalStateResetCount > 0 ? "_lf_modal_state_reset_size" : "0") + ", ", + " _lf_timer_triggers, ", + " _lf_timer_triggers_size", + " );", + "}"); + } - /** - * Generate code to call {@code _lf_initialize_modes}. - * - * @param hasModalReactors True if there is modal model reactors, false otherwise - */ - public static String generateLfInitializeModes(boolean hasModalReactors) { - if (!hasModalReactors) { - return ""; - } - return String.join("\n", - "void _lf_initialize_modes() {", - " _lf_initialize_mode_states(", - " _lf_modal_reactor_states, ", - " _lf_modal_reactor_states_size);", - "}" - ); + /** + * Generate code to call {@code _lf_initialize_modes}. + * + * @param hasModalReactors True if there is modal model reactors, false otherwise + */ + public static String generateLfInitializeModes(boolean hasModalReactors) { + if (!hasModalReactors) { + return ""; } + return String.join( + "\n", + "void _lf_initialize_modes() {", + " _lf_initialize_mode_states(", + " _lf_modal_reactor_states, ", + " _lf_modal_reactor_states_size);", + "}"); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java index 786b4701de..caaa375056 100644 --- a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java @@ -1,8 +1,8 @@ package org.lflang.generator.c; -import org.lflang.generator.ParameterInstance; import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; +import org.lflang.generator.ParameterInstance; import org.lflang.lf.Initializer; import org.lflang.lf.Parameter; @@ -14,34 +14,39 @@ * @author Hou Seng Wong */ public class CParameterGenerator { - /** - * Return a C expression that can be used to initialize the specified - * parameter instance. If the parameter initializer refers to other - * parameters, then those parameter references are replaced with - * accesses to the self struct of the parents of those parameters. - */ - public static String getInitializer(ParameterInstance p) { - // Handle the bank_index parameter. - if (p.getName().equals("bank_index")) { - return CUtil.bankIndex(p.getParent()); - } - - CTypes ctypes = CTypes.generateParametersIn(p.getParent().getParent()); - Initializer values = p.getActualValue(); - return ctypes.getTargetInitializer(values, p.getDefinition().getType()); + /** + * Return a C expression that can be used to initialize the specified parameter instance. If the + * parameter initializer refers to other parameters, then those parameter references are replaced + * with accesses to the self struct of the parents of those parameters. + */ + public static String getInitializer(ParameterInstance p) { + // Handle the bank_index parameter. + if (p.getName().equals("bank_index")) { + return CUtil.bankIndex(p.getParent()); } - /** - * Generate code for parameters variables of a reactor in the form "parameter.type parameter.name;" - * @param reactor {@link TypeParameterizedReactor} - * @param types A helper class for types - */ - public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { - CodeBuilder code = new CodeBuilder(); - for (Parameter parameter : ASTUtils.allParameters(reactor.reactor())) { - code.prSourceLineNumber(parameter); - code.pr(types.getTargetType(reactor.resolveType(ASTUtils.getInferredType(parameter))) + " " + parameter.getName() + ";"); - } - return code.toString(); + CTypes ctypes = CTypes.generateParametersIn(p.getParent().getParent()); + Initializer values = p.getActualValue(); + return ctypes.getTargetInitializer(values, p.getDefinition().getType()); + } + + /** + * Generate code for parameters variables of a reactor in the form "parameter.type + * parameter.name;" + * + * @param reactor {@link TypeParameterizedReactor} + * @param types A helper class for types + */ + public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { + CodeBuilder code = new CodeBuilder(); + for (Parameter parameter : ASTUtils.allParameters(reactor.reactor())) { + code.prSourceLineNumber(parameter); + code.pr( + types.getTargetType(reactor.resolveType(ASTUtils.getInferredType(parameter))) + + " " + + parameter.getName() + + ";"); } + return code.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index f82bad661c..02697f4a85 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -1,9 +1,11 @@ package org.lflang.generator.c; -import org.lflang.ast.ASTUtils; +import static org.lflang.generator.c.CGenerator.variableStructType; + import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; import org.lflang.Target; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.PortInstance; import org.lflang.lf.Input; @@ -11,9 +13,6 @@ import org.lflang.lf.Port; import org.lflang.lf.ReactorDecl; -import static org.lflang.generator.c.CGenerator.variableStructType; - - /** * Generates C code to declare and initialize ports. * @@ -22,256 +21,267 @@ * @author Hou Seng Wong */ public class CPortGenerator { - /** - * Generate fields in the self struct for input and output ports - */ - public static void generateDeclarations( - TypeParameterizedReactor tpr, - ReactorDecl decl, - CodeBuilder body, - CodeBuilder constructorCode - ) { - generateInputDeclarations(tpr, body, constructorCode); - generateOutputDeclarations(tpr, body, constructorCode); - } + /** Generate fields in the self struct for input and output ports */ + public static void generateDeclarations( + TypeParameterizedReactor tpr, + ReactorDecl decl, + CodeBuilder body, + CodeBuilder constructorCode) { + generateInputDeclarations(tpr, body, constructorCode); + generateOutputDeclarations(tpr, body, constructorCode); + } - /** - * Generate the struct type definitions for the port of the - * reactor - * - * @param port The port to generate the struct - * @param target The target of the code generation (C, CCpp or Python) - * @param errorReporter The error reporter - * @param types The helper object for types related stuff - * @param federatedExtension The code needed to support federated execution - * @param userFacing Whether this struct is to be presented in a user-facing header - * @param decl The reactorDecl if this struct is for the header of this reactor's container; - * null otherwise - * @return The auxiliary struct for the port as a string - */ - public static String generateAuxiliaryStruct( - TypeParameterizedReactor tpr, - Port port, - Target target, - ErrorReporter errorReporter, - CTypes types, - CodeBuilder federatedExtension, - boolean userFacing, - ReactorDecl decl - ) { - assert decl == null || userFacing; - var code = new CodeBuilder(); - code.pr("typedef struct {"); - code.indent(); - // NOTE: The following fields are required to be the first ones so that - // pointer to this struct can be cast to a (lf_port_base_t*) or to - // (token_template_t*) to access these fields for any port. - // IMPORTANT: These must match exactly the fields defined in port.h!! - code.pr(String.join("\n", - "token_type_t type;", // From token_template_t - "lf_token_t* token;", // From token_template_t - "size_t length;", // From token_template_t - "bool is_present;", // From lf_port_base_t - "lf_sparse_io_record_t* sparse_record;", // From lf_port_base_t - "int destination_channel;", // From lf_port_base_t - "int num_destinations;" // From lf_port_base_t - )); - code.pr(valueDeclaration(tpr, port, target, errorReporter, types)); - code.pr(federatedExtension.toString()); - code.unindent(); - var name = decl != null ? localPortName(decl, port.getName()) + /** + * Generate the struct type definitions for the port of the reactor + * + * @param port The port to generate the struct + * @param target The target of the code generation (C, CCpp or Python) + * @param errorReporter The error reporter + * @param types The helper object for types related stuff + * @param federatedExtension The code needed to support federated execution + * @param userFacing Whether this struct is to be presented in a user-facing header + * @param decl The reactorDecl if this struct is for the header of this reactor's container; null + * otherwise + * @return The auxiliary struct for the port as a string + */ + public static String generateAuxiliaryStruct( + TypeParameterizedReactor tpr, + Port port, + Target target, + ErrorReporter errorReporter, + CTypes types, + CodeBuilder federatedExtension, + boolean userFacing, + ReactorDecl decl) { + assert decl == null || userFacing; + var code = new CodeBuilder(); + code.pr("typedef struct {"); + code.indent(); + // NOTE: The following fields are required to be the first ones so that + // pointer to this struct can be cast to a (lf_port_base_t*) or to + // (token_template_t*) to access these fields for any port. + // IMPORTANT: These must match exactly the fields defined in port.h!! + code.pr( + String.join( + "\n", + "token_type_t type;", // From token_template_t + "lf_token_t* token;", // From token_template_t + "size_t length;", // From token_template_t + "bool is_present;", // From lf_port_base_t + "lf_sparse_io_record_t* sparse_record;", // From lf_port_base_t + "int destination_channel;", // From lf_port_base_t + "int num_destinations;" // From lf_port_base_t + )); + code.pr(valueDeclaration(tpr, port, target, errorReporter, types)); + code.pr(federatedExtension.toString()); + code.unindent(); + var name = + decl != null + ? localPortName(decl, port.getName()) : variableStructType(port, tpr, userFacing); - code.pr("} " + name + ";"); - return code.toString(); - } + code.pr("} " + name + ";"); + return code.toString(); + } - public static String localPortName(ReactorDecl decl, String portName) { - return decl.getName().toLowerCase() + "_" + portName + "_t"; - } + public static String localPortName(ReactorDecl decl, String portName) { + return decl.getName().toLowerCase() + "_" + portName + "_t"; + } - /** - * Allocate memory for the input port. - * @param input The input port - * @param reactorSelfStruct The name of the self struct - */ - public static String initializeInputMultiport( - PortInstance input, - String reactorSelfStruct - ) { - var portRefName = CUtil.portRefName(input); - // If the port is a multiport, create an array. - if (input.isMultiport()) { - String result = String.join("\n", - portRefName+"_width = "+input.getWidth()+";", - "// Allocate memory for multiport inputs.", - portRefName+" = ("+variableStructType(input)+"**)_lf_allocate(", - " "+input.getWidth()+", sizeof("+variableStructType(input)+"*),", - " &"+reactorSelfStruct+"->base.allocations); ", - "// Set inputs by default to an always absent default input.", - "for (int i = 0; i < "+input.getWidth()+"; i++) {", - " "+portRefName+"[i] = &"+reactorSelfStruct+"->_lf_default__"+input.getName()+";", - "}" - ); - if (AttributeUtils.isSparse(input.getDefinition())) { - return String.join("\n", result, - "if ("+input.getWidth()+" >= LF_SPARSE_WIDTH_THRESHOLD) {", - " "+portRefName+"__sparse = (lf_sparse_io_record_t*)_lf_allocate(1,", - " sizeof(lf_sparse_io_record_t) + sizeof(size_t) * "+input.getWidth()+"/LF_SPARSE_CAPACITY_DIVIDER,", - " &"+reactorSelfStruct+"->base.allocations);", - " "+portRefName+"__sparse->capacity = "+input.getWidth()+"/LF_SPARSE_CAPACITY_DIVIDER;", - " if (_lf_sparse_io_record_sizes.start == NULL) {", - " _lf_sparse_io_record_sizes = vector_new(1);", - " }", - " vector_push(&_lf_sparse_io_record_sizes, (void*)&"+portRefName+"__sparse->size);", - "}" - ); - } - return result; - } else { - return String.join("\n", - "// width of -2 indicates that it is not a multiport.", - portRefName+"_width = -2;" - ); - } + /** + * Allocate memory for the input port. + * + * @param input The input port + * @param reactorSelfStruct The name of the self struct + */ + public static String initializeInputMultiport(PortInstance input, String reactorSelfStruct) { + var portRefName = CUtil.portRefName(input); + // If the port is a multiport, create an array. + if (input.isMultiport()) { + String result = + String.join( + "\n", + portRefName + "_width = " + input.getWidth() + ";", + "// Allocate memory for multiport inputs.", + portRefName + " = (" + variableStructType(input) + "**)_lf_allocate(", + " " + input.getWidth() + ", sizeof(" + variableStructType(input) + "*),", + " &" + reactorSelfStruct + "->base.allocations); ", + "// Set inputs by default to an always absent default input.", + "for (int i = 0; i < " + input.getWidth() + "; i++) {", + " " + + portRefName + + "[i] = &" + + reactorSelfStruct + + "->_lf_default__" + + input.getName() + + ";", + "}"); + if (AttributeUtils.isSparse(input.getDefinition())) { + return String.join( + "\n", + result, + "if (" + input.getWidth() + " >= LF_SPARSE_WIDTH_THRESHOLD) {", + " " + portRefName + "__sparse = (lf_sparse_io_record_t*)_lf_allocate(1,", + " sizeof(lf_sparse_io_record_t) + sizeof(size_t) * " + + input.getWidth() + + "/LF_SPARSE_CAPACITY_DIVIDER,", + " &" + reactorSelfStruct + "->base.allocations);", + " " + + portRefName + + "__sparse->capacity = " + + input.getWidth() + + "/LF_SPARSE_CAPACITY_DIVIDER;", + " if (_lf_sparse_io_record_sizes.start == NULL) {", + " _lf_sparse_io_record_sizes = vector_new(1);", + " }", + " vector_push(&_lf_sparse_io_record_sizes, (void*)&" + + portRefName + + "__sparse->size);", + "}"); + } + return result; + } else { + return String.join( + "\n", + "// width of -2 indicates that it is not a multiport.", + portRefName + "_width = -2;"); } + } - /** - * Allocate memory for the output port. - * @param output The output port - * @param reactorSelfStruct The name of the self struct - */ - public static String initializeOutputMultiport( - PortInstance output, - String reactorSelfStruct - ) { - var portRefName = CUtil.portRefName(output); - var portStructType = variableStructType(output); - return output.isMultiport() ? - String.join("\n", - portRefName+"_width = "+output.getWidth()+";", - "// Allocate memory for multiport output.", - portRefName+" = ("+portStructType+"*)_lf_allocate(", - " "+output.getWidth()+", sizeof("+portStructType+"),", - " &"+reactorSelfStruct+"->base.allocations); ", - portRefName+"_pointers = ("+portStructType+"**)_lf_allocate(", - " "+output.getWidth()+", sizeof("+portStructType+"*),", - " &"+reactorSelfStruct+"->base.allocations); ", - "// Assign each output port pointer to be used in", - "// reactions to facilitate user access to output ports", - "for(int i=0; i < "+output.getWidth()+"; i++) {", - " "+portRefName+"_pointers[i] = &("+portRefName+"[i]);", - "}" - ) : - String.join("\n", - "// width of -2 indicates that it is not a multiport.", - portRefName+"_width = -2;" - ); - } + /** + * Allocate memory for the output port. + * + * @param output The output port + * @param reactorSelfStruct The name of the self struct + */ + public static String initializeOutputMultiport(PortInstance output, String reactorSelfStruct) { + var portRefName = CUtil.portRefName(output); + var portStructType = variableStructType(output); + return output.isMultiport() + ? String.join( + "\n", + portRefName + "_width = " + output.getWidth() + ";", + "// Allocate memory for multiport output.", + portRefName + " = (" + portStructType + "*)_lf_allocate(", + " " + output.getWidth() + ", sizeof(" + portStructType + "),", + " &" + reactorSelfStruct + "->base.allocations); ", + portRefName + "_pointers = (" + portStructType + "**)_lf_allocate(", + " " + output.getWidth() + ", sizeof(" + portStructType + "*),", + " &" + reactorSelfStruct + "->base.allocations); ", + "// Assign each output port pointer to be used in", + "// reactions to facilitate user access to output ports", + "for(int i=0; i < " + output.getWidth() + "; i++) {", + " " + portRefName + "_pointers[i] = &(" + portRefName + "[i]);", + "}") + : String.join( + "\n", + "// width of -2 indicates that it is not a multiport.", + portRefName + "_width = -2;"); + } - /** - * For the specified port, return a declaration for port struct to - * contain the value of the port. A multiport output with width 4 and - * type int[10], for example, will result in this: - * 

    
-     *     int value[10];
-     *
    - * There will be an array of size 4 of structs, each containing this value - * array. - * @param port The port. - * @return A string providing the value field of the port struct. - */ - private static String valueDeclaration( - TypeParameterizedReactor tpr, - Port port, - Target target, - ErrorReporter errorReporter, - CTypes types - ) { - if (port.getType() == null && target.requiresTypes) { - // This should have been caught by the validator. - errorReporter.reportError(port, "Port is required to have a type: " + port.getName()); - return ""; - } - // Do not convert to lf_token_t* using lfTypeToTokenType because there - // will be a separate field pointing to the token. - return types.getVariableDeclaration(tpr, ASTUtils.getInferredType(port), "value", false) + ";"; + /** + * For the specified port, return a declaration for port struct to contain the value of the port. + * A multiport output with width 4 and type int[10], for example, will result in this: + * + * 
    
+   *     int value[10];
+   *
    + * + * There will be an array of size 4 of structs, each containing this value array. + * + * @param port The port. + * @return A string providing the value field of the port struct. + */ + private static String valueDeclaration( + TypeParameterizedReactor tpr, + Port port, + Target target, + ErrorReporter errorReporter, + CTypes types) { + if (port.getType() == null && target.requiresTypes) { + // This should have been caught by the validator. + errorReporter.reportError(port, "Port is required to have a type: " + port.getName()); + return ""; } + // Do not convert to lf_token_t* using lfTypeToTokenType because there + // will be a separate field pointing to the token. + return types.getVariableDeclaration(tpr, ASTUtils.getInferredType(port), "value", false) + ";"; + } - /** - * Generate fields in the self struct for input ports - * - * If the port is a multiport, the input field is an array of - * pointers that will be allocated separately for each instance - * because the sizes may be different. Otherwise, it is a simple - * pointer. - * - */ - private static void generateInputDeclarations( - TypeParameterizedReactor tpr, - CodeBuilder body, - CodeBuilder constructorCode - ) { - for (Input input : ASTUtils.allInputs(tpr.reactor())) { - var inputName = input.getName(); - if (ASTUtils.isMultiport(input)) { - body.pr(input, String.join("\n", - "// Multiport input array will be malloc'd later.", - variableStructType(input, tpr, false)+"** _lf_"+inputName+";", - "int _lf_"+inputName+"_width;", - "// Default input (in case it does not get connected)", - variableStructType(input, tpr, false)+" _lf_default__"+inputName+";", - "// Struct to support efficiently reading sparse inputs.", - "lf_sparse_io_record_t* _lf_"+inputName+"__sparse;" - )); - } else { - // input is not a multiport. - body.pr(input, String.join("\n", - variableStructType(input, tpr, false)+"* _lf_"+inputName+";", - "// width of -2 indicates that it is not a multiport.", - "int _lf_"+inputName+"_width;", - "// Default input (in case it does not get connected)", - variableStructType(input, tpr, false)+" _lf_default__"+inputName+";" - )); + /** + * Generate fields in the self struct for input ports + * + *

    If the port is a multiport, the input field is an array of pointers that will be allocated + * separately for each instance because the sizes may be different. Otherwise, it is a simple + * pointer. + */ + private static void generateInputDeclarations( + TypeParameterizedReactor tpr, CodeBuilder body, CodeBuilder constructorCode) { + for (Input input : ASTUtils.allInputs(tpr.reactor())) { + var inputName = input.getName(); + if (ASTUtils.isMultiport(input)) { + body.pr( + input, + String.join( + "\n", + "// Multiport input array will be malloc'd later.", + variableStructType(input, tpr, false) + "** _lf_" + inputName + ";", + "int _lf_" + inputName + "_width;", + "// Default input (in case it does not get connected)", + variableStructType(input, tpr, false) + " _lf_default__" + inputName + ";", + "// Struct to support efficiently reading sparse inputs.", + "lf_sparse_io_record_t* _lf_" + inputName + "__sparse;")); + } else { + // input is not a multiport. + body.pr( + input, + String.join( + "\n", + variableStructType(input, tpr, false) + "* _lf_" + inputName + ";", + "// width of -2 indicates that it is not a multiport.", + "int _lf_" + inputName + "_width;", + "// Default input (in case it does not get connected)", + variableStructType(input, tpr, false) + " _lf_default__" + inputName + ";")); - constructorCode.pr(input, String.join("\n", - "// Set input by default to an always absent default input.", - "self->_lf_"+inputName+" = &self->_lf_default__"+inputName+";" - )); - } - } + constructorCode.pr( + input, + String.join( + "\n", + "// Set input by default to an always absent default input.", + "self->_lf_" + inputName + " = &self->_lf_default__" + inputName + ";")); + } } + } - /** - * Generate fields in the self struct for output ports - */ - private static void generateOutputDeclarations( - TypeParameterizedReactor tpr, - CodeBuilder body, - CodeBuilder constructorCode - ) { - for (Output output : ASTUtils.allOutputs(tpr.reactor())) { - // If the port is a multiport, create an array to be allocated - // at instantiation. - var outputName = output.getName(); - if (ASTUtils.isMultiport(output)) { - body.pr(output, String.join("\n", - "// Array of output ports.", - variableStructType(output, tpr, false)+"* _lf_"+outputName+";", - "int _lf_"+outputName+"_width;", - "// An array of pointers to the individual ports. Useful", - "// for the lf_set macros to work out-of-the-box for", - "// multiports in the body of reactions because their ", - "// value can be accessed via a -> operator (e.g.,foo[i]->value).", - "// So we have to handle multiports specially here a construct that", - "// array of pointers.", - variableStructType(output, tpr, false)+"** _lf_"+outputName+"_pointers;" - )); - } else { - body.pr(output, String.join("\n", - variableStructType(output, tpr, false)+" _lf_"+outputName+";", - "int _lf_"+outputName+"_width;" - )); - } - } + /** Generate fields in the self struct for output ports */ + private static void generateOutputDeclarations( + TypeParameterizedReactor tpr, CodeBuilder body, CodeBuilder constructorCode) { + for (Output output : ASTUtils.allOutputs(tpr.reactor())) { + // If the port is a multiport, create an array to be allocated + // at instantiation. + var outputName = output.getName(); + if (ASTUtils.isMultiport(output)) { + body.pr( + output, + String.join( + "\n", + "// Array of output ports.", + variableStructType(output, tpr, false) + "* _lf_" + outputName + ";", + "int _lf_" + outputName + "_width;", + "// An array of pointers to the individual ports. Useful", + "// for the lf_set macros to work out-of-the-box for", + "// multiports in the body of reactions because their ", + "// value can be accessed via a -> operator (e.g.,foo[i]->value).", + "// So we have to handle multiports specially here a construct that", + "// array of pointers.", + variableStructType(output, tpr, false) + "** _lf_" + outputName + "_pointers;")); + } else { + body.pr( + output, + String.join( + "\n", + variableStructType(output, tpr, false) + " _lf_" + outputName + ";", + "int _lf_" + outputName + "_width;")); + } } + } } diff --git a/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java b/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java index 8ca0404d75..45b81caab6 100644 --- a/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java @@ -1,18 +1,16 @@ package org.lflang.generator.c; -import java.nio.file.Path; +import static org.lflang.util.StringUtil.addDoubleQuotes; +import java.nio.file.Path; import org.lflang.TargetConfig; import org.lflang.TargetProperty.Platform; import org.lflang.generator.CodeBuilder; import org.lflang.util.StringUtil; -import static org.lflang.util.StringUtil.addDoubleQuotes; - /** - * Generates code for preambles for the C and CCpp target. - * This includes #include and #define directives at the top - * of each generated ".c" file. + * Generates code for preambles for the C and CCpp target. This includes #include and #define + * directives at the top of each generated ".c" file. * * @author Edward A. Lee * @author Marten Lohstroh @@ -26,76 +24,69 @@ * @author Anirudh Rengarajan */ public class CPreambleGenerator { - /** Add necessary source files specific to the target language. */ - public static String generateIncludeStatements( - TargetConfig targetConfig, - boolean cppMode - ) { - var tracing = targetConfig.tracing; - CodeBuilder code = new CodeBuilder(); - if (cppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) { - code.pr("extern \"C\" {"); - } - code.pr("#include "); - code.pr("#include \"include/core/platform.h\""); - CCoreFilesUtils.getCTargetHeader().forEach( - it -> code.pr("#include " + StringUtil.addDoubleQuotes(it)) - ); - code.pr("#include \"include/core/reactor.h\""); - code.pr("#include \"include/core/reactor_common.h\""); - if (targetConfig.threading) { - code.pr("#include \"include/core/threaded/scheduler.h\""); - } + /** Add necessary source files specific to the target language. */ + public static String generateIncludeStatements(TargetConfig targetConfig, boolean cppMode) { + var tracing = targetConfig.tracing; + CodeBuilder code = new CodeBuilder(); + if (cppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) { + code.pr("extern \"C\" {"); + } + code.pr("#include "); + code.pr("#include \"include/core/platform.h\""); + CCoreFilesUtils.getCTargetHeader() + .forEach(it -> code.pr("#include " + StringUtil.addDoubleQuotes(it))); + code.pr("#include \"include/core/reactor.h\""); + code.pr("#include \"include/core/reactor_common.h\""); + if (targetConfig.threading) { + code.pr("#include \"include/core/threaded/scheduler.h\""); + } - if (tracing != null) { - code.pr("#include \"include/core/trace.h\""); - } - code.pr("#include \"include/core/mixed_radix.h\""); - code.pr("#include \"include/core/port.h\""); - code.pr("int lf_reactor_c_main(int argc, const char* argv[]);"); - if(targetConfig.fedSetupPreamble != null) { - code.pr("#include \"include/core/federated/federate.h\""); - code.pr("#include \"include/core/federated/net_common.h\""); - } - if (cppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) { - code.pr("}"); - } - return code.toString(); + if (tracing != null) { + code.pr("#include \"include/core/trace.h\""); + } + code.pr("#include \"include/core/mixed_radix.h\""); + code.pr("#include \"include/core/port.h\""); + code.pr("int lf_reactor_c_main(int argc, const char* argv[]);"); + if (targetConfig.fedSetupPreamble != null) { + code.pr("#include \"include/core/federated/federate.h\""); + code.pr("#include \"include/core/federated/net_common.h\""); + } + if (cppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) { + code.pr("}"); } + return code.toString(); + } - public static String generateDefineDirectives( - TargetConfig targetConfig, - Path srcGenPath, - boolean hasModalReactors - ) { - int logLevel = targetConfig.logLevel.ordinal(); - var coordinationType = targetConfig.coordination; - var tracing = targetConfig.tracing; - CodeBuilder code = new CodeBuilder(); - // TODO: Get rid of all of these - code.pr("#define LOG_LEVEL " + logLevel); - code.pr("#define TARGET_FILES_DIRECTORY " + addDoubleQuotes(srcGenPath.toString())); + public static String generateDefineDirectives( + TargetConfig targetConfig, Path srcGenPath, boolean hasModalReactors) { + int logLevel = targetConfig.logLevel.ordinal(); + var coordinationType = targetConfig.coordination; + var tracing = targetConfig.tracing; + CodeBuilder code = new CodeBuilder(); + // TODO: Get rid of all of these + code.pr("#define LOG_LEVEL " + logLevel); + code.pr("#define TARGET_FILES_DIRECTORY " + addDoubleQuotes(srcGenPath.toString())); - if (tracing != null) { - targetConfig.compileDefinitions.put("LF_TRACE", tracing.traceFileName); - } - // if (clockSyncIsOn) { - // code.pr(generateClockSyncDefineDirective( - // targetConfig.clockSync, - // targetConfig.clockSyncOptions - // )); - // } - if (targetConfig.threading) { - targetConfig.compileDefinitions.put("LF_THREADED", "1"); - } else { - targetConfig.compileDefinitions.put("LF_UNTHREADED", "1"); - } - if (targetConfig.threading) { - targetConfig.compileDefinitions.put("LF_THREADED", "1"); - } else { - targetConfig.compileDefinitions.put("LF_UNTHREADED", "1"); - } - code.newLine(); - return code.toString(); + if (tracing != null) { + targetConfig.compileDefinitions.put("LF_TRACE", tracing.traceFileName); + } + // if (clockSyncIsOn) { + // code.pr(generateClockSyncDefineDirective( + // targetConfig.clockSync, + // targetConfig.clockSyncOptions + // )); + // } + if (targetConfig.threading) { + targetConfig.compileDefinitions.put("LF_THREADED", "1"); + } else { + targetConfig.compileDefinitions.put("LF_UNTHREADED", "1"); + } + if (targetConfig.threading) { + targetConfig.compileDefinitions.put("LF_THREADED", "1"); + } else { + targetConfig.compileDefinitions.put("LF_UNTHREADED", "1"); } + code.newLine(); + return code.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 26e6c8ab6f..6fcef92dd6 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -9,11 +9,10 @@ import java.util.List; import java.util.Map; import java.util.Set; - -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; import org.lflang.InferredType; import org.lflang.TargetConfig; +import org.lflang.ast.ASTUtils; import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Action; @@ -37,1154 +36,1335 @@ import org.lflang.util.StringUtil; public class CReactionGenerator { - protected static String DISABLE_REACTION_INITIALIZATION_MARKER - = "// **** Do not include initialization code in this reaction."; // FIXME: Such markers should not exist (#1687) + protected static String DISABLE_REACTION_INITIALIZATION_MARKER = + "// **** Do not include initialization code in this reaction."; // FIXME: Such markers should + // not exist (#1687) - /** - * Generate necessary initialization code inside the body of the reaction that belongs to reactor decl. - * @param body The body of the reaction. Used to check for the DISABLE_REACTION_INITIALIZATION_MARKER. - * @param reaction The initialization code will be generated for this specific reaction - * @param tpr The reactor that has the reaction - * @param reactionIndex The index of the reaction relative to other reactions in the reactor, starting from 0 - */ - public static String generateInitializationForReaction(String body, - Reaction reaction, - TypeParameterizedReactor tpr, - int reactionIndex, - CTypes types, - ErrorReporter errorReporter, - Instantiation mainDef, - boolean requiresTypes) { - // Construct the reactionInitialization code to go into - // the body of the function before the verbatim code. - CodeBuilder reactionInitialization = new CodeBuilder(); + /** + * Generate necessary initialization code inside the body of the reaction that belongs to reactor + * decl. + * + * @param body The body of the reaction. Used to check for the + * DISABLE_REACTION_INITIALIZATION_MARKER. + * @param reaction The initialization code will be generated for this specific reaction + * @param tpr The reactor that has the reaction + * @param reactionIndex The index of the reaction relative to other reactions in the reactor, + * starting from 0 + */ + public static String generateInitializationForReaction( + String body, + Reaction reaction, + TypeParameterizedReactor tpr, + int reactionIndex, + CTypes types, + ErrorReporter errorReporter, + Instantiation mainDef, + boolean requiresTypes) { + // Construct the reactionInitialization code to go into + // the body of the function before the verbatim code. + CodeBuilder reactionInitialization = new CodeBuilder(); - CodeBuilder code = new CodeBuilder(); + CodeBuilder code = new CodeBuilder(); - // Define the "self" struct. - String structType = CUtil.selfType(tpr); - // A null structType means there are no inputs, state, - // or anything else. No need to declare it. - if (structType != null) { - code.pr(String.join("\n", - structType+"* self = ("+structType+"*)instance_args; SUPPRESS_UNUSED_WARNING(self);" - )); - } - - // Do not generate the initialization code if the body is marked - // to not generate it. - if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { - return code.toString(); - } + // Define the "self" struct. + String structType = CUtil.selfType(tpr); + // A null structType means there are no inputs, state, + // or anything else. No need to declare it. + if (structType != null) { + code.pr( + String.join( + "\n", + structType + + "* self = (" + + structType + + "*)instance_args; SUPPRESS_UNUSED_WARNING(self);")); + } - // A reaction may send to or receive from multiple ports of - // a contained reactor. The variables for these ports need to - // all be declared as fields of the same struct. Hence, we first - // collect the fields to be defined in the structs and then - // generate the structs. - Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); + // Do not generate the initialization code if the body is marked + // to not generate it. + if (body.startsWith(DISABLE_REACTION_INITIALIZATION_MARKER)) { + return code.toString(); + } - // Actions may appear twice, first as a trigger, then with the outputs. - // But we need to declare it only once. Collect in this data structure - // the actions that are declared as triggered so that if they appear - // again with the outputs, they are not defined a second time. - // That second redefinition would trigger a compile error. - Set actionsAsTriggers = new LinkedHashSet<>(); + // A reaction may send to or receive from multiple ports of + // a contained reactor. The variables for these ports need to + // all be declared as fields of the same struct. Hence, we first + // collect the fields to be defined in the structs and then + // generate the structs. + Map fieldsForStructsForContainedReactors = new LinkedHashMap<>(); - // Next, add the triggers (input and actions; timers are not needed). - // This defines a local variable in the reaction function whose - // name matches that of the trigger. The value of the local variable - // is a struct with a value and is_present field, the latter a boolean - // that indicates whether the input/action is present. - // If the trigger is an output, then it is an output of a - // contained reactor. In this case, a struct with the name - // of the contained reactor is created with one field that is - // a pointer to a struct with a value and is_present field. - // E.g., if the contained reactor is named 'c' and its output - // port is named 'out', then c.out->value c.out->is_present are - // defined so that they can be used in the verbatim code. - for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - if (triggerAsVarRef.getVariable() instanceof Port) { - generatePortVariablesInReaction( - reactionInitialization, - fieldsForStructsForContainedReactors, - triggerAsVarRef, - tpr, - types); - } else if (triggerAsVarRef.getVariable() instanceof Action) { - reactionInitialization.pr(generateActionVariablesInReaction( - (Action) triggerAsVarRef.getVariable(), - tpr, - types - )); - actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); - } - } - } - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - // No triggers are given, which means react to any input. - // Declare an argument for every input. - // NOTE: this does not include contained outputs. - for (Input input : tpr.reactor().getInputs()) { - reactionInitialization.pr(generateInputVariablesInReaction(input, tpr, types)); - } - } - // Define argument for non-triggering inputs. - for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { - if (src.getVariable() instanceof Port) { - generatePortVariablesInReaction(reactionInitialization, fieldsForStructsForContainedReactors, src, tpr, types); - } else if (src.getVariable() instanceof Action) { - // It's a bit odd to read but not be triggered by an action, but - // OK, I guess we allow it. - reactionInitialization.pr(generateActionVariablesInReaction( - (Action) src.getVariable(), - tpr, - types - )); - actionsAsTriggers.add((Action) src.getVariable()); - } - } + // Actions may appear twice, first as a trigger, then with the outputs. + // But we need to declare it only once. Collect in this data structure + // the actions that are declared as triggered so that if they appear + // again with the outputs, they are not defined a second time. + // That second redefinition would trigger a compile error. + Set actionsAsTriggers = new LinkedHashSet<>(); - // Define variables for each declared output or action. - // In the case of outputs, the variable is a pointer to where the - // output is stored. This gives the reaction code access to any previous - // value that may have been written to that output in an earlier reaction. - if (reaction.getEffects() != null) { - for (VarRef effect : reaction.getEffects()) { - Variable variable = effect.getVariable(); - if (variable instanceof Action) { - // It is an action, not an output. - // If it has already appeared as trigger, do not redefine it. - if (!actionsAsTriggers.contains(effect.getVariable())) { - reactionInitialization.pr(CGenerator.variableStructType(variable, tpr, false)+"* "+variable.getName()+" = &self->_lf_"+variable.getName()+";"); - } - } else if (effect.getVariable() instanceof Mode) { - // Mode change effect - int idx = ASTUtils.allModes(tpr.reactor()).indexOf((Mode)effect.getVariable()); - String name = effect.getVariable().getName(); - if (idx >= 0) { - reactionInitialization.pr( - "reactor_mode_t* " + name + " = &self->_lf__modes[" + idx + "];\n" - + "lf_mode_change_type_t _lf_" + name + "_change_type = " - + (effect.getTransition() == ModeTransition.HISTORY ? - "history_transition" : "reset_transition") - + ";" - ); - } else { - errorReporter.reportError( - reaction, - "In generateReaction(): " + name + " not a valid mode of this reactor." - ); - } - } else { - if (variable instanceof Output) { - reactionInitialization.pr(generateOutputVariablesInReaction( - effect, - tpr, - errorReporter, - requiresTypes - )); - } else if (variable instanceof Input) { - // It is the input of a contained reactor. - generateVariablesForSendingToContainedReactors( - reactionInitialization, - fieldsForStructsForContainedReactors, - effect.getContainer(), - (Input) variable); - } else if (variable instanceof Watchdog) { - reactionInitialization.pr(generateWatchdogVariablesInReaction(effect)); - } else { - errorReporter.reportError( - reaction, - "In generateReaction(): effect is not an input, output, or watchdog." - ); - } - } - } - } - // Before the reaction initialization, - // generate the structs used for communication to and from contained reactors. - for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { - String array = ""; - if (containedReactor.getWidthSpec() != null) { - String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); - code.pr("int "+containedReactorWidthVar+" = self->_lf_"+containedReactorWidthVar+";"); - // Windows does not support variables in arrays declared on the stack, - // so we use the maximum size over all bank members. - array = "["+maxContainedReactorBankWidth(containedReactor, null, 0, mainDef)+"]"; - } - code.pr(String.join("\n", - "struct "+containedReactor.getName()+" {", - " "+fieldsForStructsForContainedReactors.get(containedReactor), - "} "+containedReactor.getName()+array+";" - )); + // Next, add the triggers (input and actions; timers are not needed). + // This defines a local variable in the reaction function whose + // name matches that of the trigger. The value of the local variable + // is a struct with a value and is_present field, the latter a boolean + // that indicates whether the input/action is present. + // If the trigger is an output, then it is an output of a + // contained reactor. In this case, a struct with the name + // of the contained reactor is created with one field that is + // a pointer to a struct with a value and is_present field. + // E.g., if the contained reactor is named 'c' and its output + // port is named 'out', then c.out->value c.out->is_present are + // defined so that they can be used in the verbatim code. + for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + if (triggerAsVarRef.getVariable() instanceof Port) { + generatePortVariablesInReaction( + reactionInitialization, + fieldsForStructsForContainedReactors, + triggerAsVarRef, + tpr, + types); + } else if (triggerAsVarRef.getVariable() instanceof Action) { + reactionInitialization.pr( + generateActionVariablesInReaction( + (Action) triggerAsVarRef.getVariable(), tpr, types)); + actionsAsTriggers.add((Action) triggerAsVarRef.getVariable()); } - // Next generate all the collected setup code. - code.pr(reactionInitialization.toString()); - return code.toString(); + } + } + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + // No triggers are given, which means react to any input. + // Declare an argument for every input. + // NOTE: this does not include contained outputs. + for (Input input : tpr.reactor().getInputs()) { + reactionInitialization.pr(generateInputVariablesInReaction(input, tpr, types)); + } + } + // Define argument for non-triggering inputs. + for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { + if (src.getVariable() instanceof Port) { + generatePortVariablesInReaction( + reactionInitialization, fieldsForStructsForContainedReactors, src, tpr, types); + } else if (src.getVariable() instanceof Action) { + // It's a bit odd to read but not be triggered by an action, but + // OK, I guess we allow it. + reactionInitialization.pr( + generateActionVariablesInReaction((Action) src.getVariable(), tpr, types)); + actionsAsTriggers.add((Action) src.getVariable()); + } } - /** - * Return the maximum bank width for the given instantiation within all - * instantiations of its parent reactor. - * On the first call to this method, the breadcrumbs should be null and the max - * argument should be zero. On recursive calls, breadcrumbs is a list of nested - * instantiations, the max is the maximum width found so far. The search for - * instances of the parent reactor will begin with the last instantiation - * in the specified list. - * - * This rather complicated method is used when a reaction sends or receives data - * to or from a bank of contained reactors. There will be an array of structs on - * the self struct of the parent, and the size of the array is conservatively set - * to the maximum of all the identified bank widths. This is a bit wasteful of - * memory, but it avoids having to malloc the array for each instance, and in - * typical usage, there will be few instances or instances that are all the same - * width. - * - * @param containedReactor The contained reactor instantiation. - * @param breadcrumbs null on first call (non-recursive). - * @param max 0 on first call. - */ - public static int maxContainedReactorBankWidth( - Instantiation containedReactor, - LinkedList breadcrumbs, - int max, - Instantiation mainDef - ) { - // If the instantiation is not a bank, return 1. - if (containedReactor.getWidthSpec() == null) { - return 1; - } - // If there is no main, then we just use the default width. - if (mainDef == null) { - return ASTUtils.width(containedReactor.getWidthSpec(), null); - } - LinkedList nestedBreadcrumbs = breadcrumbs; - if (nestedBreadcrumbs == null) { - nestedBreadcrumbs = new LinkedList<>(); - nestedBreadcrumbs.add(mainDef); - } - int result = max; - Reactor parent = (Reactor) containedReactor.eContainer(); - if (parent == ASTUtils.toDefinition(mainDef.getReactorClass())) { - // The parent is main, so there can't be any other instantiations of it. - return ASTUtils.width(containedReactor.getWidthSpec(), null); - } - // Search for instances of the parent within the tail of the breadcrumbs list. - Reactor container = ASTUtils.toDefinition(nestedBreadcrumbs.get(0).getReactorClass()); - for (Instantiation instantiation : container.getInstantiations()) { - // Put this new instantiation at the head of the list. - nestedBreadcrumbs.add(0, instantiation); - if (ASTUtils.toDefinition(instantiation.getReactorClass()) == parent) { - // Found a matching instantiation of the parent. - // Evaluate the original width specification in this context. - int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); - if (candidate > result) { - result = candidate; - } - } else { - // Found some other instantiation, not the parent. - // Search within it for instantiations of the parent. - // Note that we assume here that the parent cannot contain - // instances of itself. - int candidate = maxContainedReactorBankWidth(containedReactor, nestedBreadcrumbs, result, mainDef); - if (candidate > result) { - result = candidate; - } - } - nestedBreadcrumbs.remove(); + // Define variables for each declared output or action. + // In the case of outputs, the variable is a pointer to where the + // output is stored. This gives the reaction code access to any previous + // value that may have been written to that output in an earlier reaction. + if (reaction.getEffects() != null) { + for (VarRef effect : reaction.getEffects()) { + Variable variable = effect.getVariable(); + if (variable instanceof Action) { + // It is an action, not an output. + // If it has already appeared as trigger, do not redefine it. + if (!actionsAsTriggers.contains(effect.getVariable())) { + reactionInitialization.pr( + CGenerator.variableStructType(variable, tpr, false) + + "* " + + variable.getName() + + " = &self->_lf_" + + variable.getName() + + ";"); + } + } else if (effect.getVariable() instanceof Mode) { + // Mode change effect + int idx = ASTUtils.allModes(tpr.reactor()).indexOf((Mode) effect.getVariable()); + String name = effect.getVariable().getName(); + if (idx >= 0) { + reactionInitialization.pr( + "reactor_mode_t* " + + name + + " = &self->_lf__modes[" + + idx + + "];\n" + + "lf_mode_change_type_t _lf_" + + name + + "_change_type = " + + (effect.getTransition() == ModeTransition.HISTORY + ? "history_transition" + : "reset_transition") + + ";"); + } else { + errorReporter.reportError( + reaction, "In generateReaction(): " + name + " not a valid mode of this reactor."); + } + } else { + if (variable instanceof Output) { + reactionInitialization.pr( + generateOutputVariablesInReaction(effect, tpr, errorReporter, requiresTypes)); + } else if (variable instanceof Input) { + // It is the input of a contained reactor. + generateVariablesForSendingToContainedReactors( + reactionInitialization, + fieldsForStructsForContainedReactors, + effect.getContainer(), + (Input) variable); + } else if (variable instanceof Watchdog) { + reactionInitialization.pr(generateWatchdogVariablesInReaction(effect)); + } else { + errorReporter.reportError( + reaction, "In generateReaction(): effect is not an input, output, or watchdog."); + } } - return result; + } } - - /** - * Generate code for the body of a reaction that takes an input and - * schedules an action with the value of that input. - * @param actionName The action to schedule - */ - public static String generateDelayBody(String ref, String actionName, boolean isTokenType) { - // Note that the action.type set by the base class is actually - // the port type. - return isTokenType ? - String.join("\n", - "if ("+ref+"->is_present) {", - " // Put the whole token on the event queue, not just the payload.", - " // This way, the length and element_size are transported.", - " lf_schedule_token("+actionName+", 0, "+ref+"->token);", - "}" - ) : - "lf_schedule_copy("+actionName+", 0, &"+ref+"->value, 1); // Length is 1."; + // Before the reaction initialization, + // generate the structs used for communication to and from contained reactors. + for (Instantiation containedReactor : fieldsForStructsForContainedReactors.keySet()) { + String array = ""; + if (containedReactor.getWidthSpec() != null) { + String containedReactorWidthVar = generateWidthVariable(containedReactor.getName()); + code.pr( + "int " + containedReactorWidthVar + " = self->_lf_" + containedReactorWidthVar + ";"); + // Windows does not support variables in arrays declared on the stack, + // so we use the maximum size over all bank members. + array = "[" + maxContainedReactorBankWidth(containedReactor, null, 0, mainDef) + "]"; + } + code.pr( + String.join( + "\n", + "struct " + containedReactor.getName() + " {", + " " + fieldsForStructsForContainedReactors.get(containedReactor), + "} " + containedReactor.getName() + array + ";")); } + // Next generate all the collected setup code. + code.pr(reactionInitialization.toString()); + return code.toString(); + } - public static String generateForwardBody(String outputName, String targetType, String actionName, boolean isTokenType) { - return isTokenType ? - String.join("\n", - DISABLE_REACTION_INITIALIZATION_MARKER, - "self->_lf_"+outputName+".value = ("+targetType+")self->_lf__"+actionName+".tmplt.token->value;", - "_lf_replace_template_token((token_template_t*)&self->_lf_"+outputName+", (lf_token_t*)self->_lf__"+actionName+".tmplt.token);", - "self->_lf_"+outputName+".is_present = true;" - ) : - "lf_set("+outputName+", "+actionName+"->value);"; + /** + * Return the maximum bank width for the given instantiation within all instantiations of its + * parent reactor. On the first call to this method, the breadcrumbs should be null and the max + * argument should be zero. On recursive calls, breadcrumbs is a list of nested instantiations, + * the max is the maximum width found so far. The search for instances of the parent reactor will + * begin with the last instantiation in the specified list. + * + *

    This rather complicated method is used when a reaction sends or receives data to or from a + * bank of contained reactors. There will be an array of structs on the self struct of the parent, + * and the size of the array is conservatively set to the maximum of all the identified bank + * widths. This is a bit wasteful of memory, but it avoids having to malloc the array for each + * instance, and in typical usage, there will be few instances or instances that are all the same + * width. + * + * @param containedReactor The contained reactor instantiation. + * @param breadcrumbs null on first call (non-recursive). + * @param max 0 on first call. + */ + public static int maxContainedReactorBankWidth( + Instantiation containedReactor, + LinkedList breadcrumbs, + int max, + Instantiation mainDef) { + // If the instantiation is not a bank, return 1. + if (containedReactor.getWidthSpec() == null) { + return 1; } - - /** - * Generate into the specified string builder the code to - * initialize local variables for sending data to an input - * of a contained reactor. This will also, if necessary, - * generate entries for local struct definitions into the - * struct argument. These entries point to where the data - * is stored. - * - * @param builder The string builder. - * @param structs A map from reactor instantiations to a place to write - * struct fields. - * @param definition AST node defining the reactor within which this occurs - * @param input Input of the contained reactor. - */ - private static void generateVariablesForSendingToContainedReactors( - CodeBuilder builder, - Map structs, - Instantiation definition, - Input input - ) { - CodeBuilder structBuilder = structs.get(definition); - if (structBuilder == null) { - structBuilder = new CodeBuilder(); - structs.put(definition, structBuilder); + // If there is no main, then we just use the default width. + if (mainDef == null) { + return ASTUtils.width(containedReactor.getWidthSpec(), null); + } + LinkedList nestedBreadcrumbs = breadcrumbs; + if (nestedBreadcrumbs == null) { + nestedBreadcrumbs = new LinkedList<>(); + nestedBreadcrumbs.add(mainDef); + } + int result = max; + Reactor parent = (Reactor) containedReactor.eContainer(); + if (parent == ASTUtils.toDefinition(mainDef.getReactorClass())) { + // The parent is main, so there can't be any other instantiations of it. + return ASTUtils.width(containedReactor.getWidthSpec(), null); + } + // Search for instances of the parent within the tail of the breadcrumbs list. + Reactor container = ASTUtils.toDefinition(nestedBreadcrumbs.get(0).getReactorClass()); + for (Instantiation instantiation : container.getInstantiations()) { + // Put this new instantiation at the head of the list. + nestedBreadcrumbs.add(0, instantiation); + if (ASTUtils.toDefinition(instantiation.getReactorClass()) == parent) { + // Found a matching instantiation of the parent. + // Evaluate the original width specification in this context. + int candidate = ASTUtils.width(containedReactor.getWidthSpec(), nestedBreadcrumbs); + if (candidate > result) { + result = candidate; } - String inputStructType = CGenerator.variableStructType(input, new TypeParameterizedReactor(definition), false); - String defName = definition.getName(); - String defWidth = generateWidthVariable(defName); - String inputName = input.getName(); - String inputWidth = generateWidthVariable(inputName); - if (!ASTUtils.isMultiport(input)) { - // Contained reactor's input is not a multiport. - structBuilder.pr(inputStructType+"* "+inputName+";"); - if (definition.getWidthSpec() != null) { - // Contained reactor is a bank. - builder.pr(String.join("\n", - "for (int bankIndex = 0; bankIndex < self->_lf_"+defWidth+"; bankIndex++) {", - " "+defName+"[bankIndex]."+inputName+" = &(self->_lf_"+defName+"[bankIndex]."+inputName+");", - "}" - )); - } else { - // Contained reactor is not a bank. - builder.pr(defName+"."+inputName+" = &(self->_lf_"+defName+"."+inputName+");"); - } - } else { - // Contained reactor's input is a multiport. - structBuilder.pr(String.join("\n", - inputStructType+"** "+inputName+";", - "int "+inputWidth+";" - )); - // If the contained reactor is a bank, then we have to set the - // pointer for each element of the bank. - if (definition.getWidthSpec() != null) { - builder.pr(String.join("\n", - "for (int _i = 0; _i < self->_lf_"+defWidth+"; _i++) {", - " "+defName+"[_i]."+inputName+" = self->_lf_"+defName+"[_i]."+inputName+";", - " "+defName+"[_i]."+inputWidth+" = self->_lf_"+defName+"[_i]."+inputWidth+";", - "}" - )); - } else { - builder.pr(String.join("\n", - defName+"."+inputName+" = self->_lf_"+defName+"."+inputName+";", - defName+"."+inputWidth+" = self->_lf_"+defName+"."+inputWidth+";" - )); - } + } else { + // Found some other instantiation, not the parent. + // Search within it for instantiations of the parent. + // Note that we assume here that the parent cannot contain + // instances of itself. + int candidate = + maxContainedReactorBankWidth(containedReactor, nestedBreadcrumbs, result, mainDef); + if (candidate > result) { + result = candidate; } + } + nestedBreadcrumbs.remove(); } + return result; + } - /** - * Generate into the specified string builder the code to - * initialize local variables for ports in a reaction function - * from the "self" struct. The port may be an input of the - * reactor or an output of a contained reactor. The second - * argument provides, for each contained reactor, a place to - * write the declaration of the output of that reactor that - * is triggering reactions. - * @param builder The place into which to write the code. - * @param structs A map from reactor instantiations to a place to write - * struct fields. - */ - private static void generatePortVariablesInReaction( - CodeBuilder builder, - Map structs, - VarRef port, - TypeParameterizedReactor tpr, - CTypes types - ) { - if (port.getVariable() instanceof Input) { - builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), tpr, types)); - } else { - // port is an output of a contained reactor. - Output output = (Output) port.getVariable(); - String portStructType = CGenerator.variableStructType(output, new TypeParameterizedReactor(port.getContainer()), false); + /** + * Generate code for the body of a reaction that takes an input and schedules an action with the + * value of that input. + * + * @param actionName The action to schedule + */ + public static String generateDelayBody(String ref, String actionName, boolean isTokenType) { + // Note that the action.type set by the base class is actually + // the port type. + return isTokenType + ? String.join( + "\n", + "if (" + ref + "->is_present) {", + " // Put the whole token on the event queue, not just the payload.", + " // This way, the length and element_size are transported.", + " lf_schedule_token(" + actionName + ", 0, " + ref + "->token);", + "}") + : "lf_schedule_copy(" + actionName + ", 0, &" + ref + "->value, 1); // Length is 1."; + } - CodeBuilder structBuilder = structs.get(port.getContainer()); - if (structBuilder == null) { - structBuilder = new CodeBuilder(); - structs.put(port.getContainer(), structBuilder); - } - String subName = port.getContainer().getName(); - String reactorWidth = generateWidthVariable(subName); - String outputName = output.getName(); - String outputWidth = generateWidthVariable(outputName); - // First define the struct containing the output value and indicator - // of its presence. - if (!ASTUtils.isMultiport(output)) { - // Output is not a multiport. - structBuilder.pr(portStructType+"* "+outputName+";"); - } else { - // Output is a multiport. - structBuilder.pr(String.join("\n", - portStructType+"** "+outputName+";", - "int "+outputWidth+";" - )); - } + public static String generateForwardBody( + String outputName, String targetType, String actionName, boolean isTokenType) { + return isTokenType + ? String.join( + "\n", + DISABLE_REACTION_INITIALIZATION_MARKER, + "self->_lf_" + + outputName + + ".value = (" + + targetType + + ")self->_lf__" + + actionName + + ".tmplt.token->value;", + "_lf_replace_template_token((token_template_t*)&self->_lf_" + + outputName + + ", (lf_token_t*)self->_lf__" + + actionName + + ".tmplt.token);", + "self->_lf_" + outputName + ".is_present = true;") + : "lf_set(" + outputName + ", " + actionName + "->value);"; + } - // Next, initialize the struct with the current values. - if (port.getContainer().getWidthSpec() != null) { - // Output is in a bank. - builder.pr(String.join("\n", - "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+subName+"[i]."+outputName+" = self->_lf_"+subName+"[i]."+outputName+";", - "}" - )); - if (ASTUtils.isMultiport(output)) { - builder.pr(String.join("\n", - "for (int i = 0; i < "+reactorWidth+"; i++) {", - " "+subName+"[i]."+outputWidth+" = self->_lf_"+subName+"[i]."+outputWidth+";", - "}" - )); - } - } else { - // Output is not in a bank. - builder.pr(subName+"."+outputName+" = self->_lf_"+subName+"."+outputName+";"); - if (ASTUtils.isMultiport(output)) { - builder.pr(subName+"."+outputWidth+" = self->_lf_"+subName+"."+outputWidth+";"); - } - } - } + /** + * Generate into the specified string builder the code to initialize local variables for sending + * data to an input of a contained reactor. This will also, if necessary, generate entries for + * local struct definitions into the struct argument. These entries point to where the data is + * stored. + * + * @param builder The string builder. + * @param structs A map from reactor instantiations to a place to write struct fields. + * @param definition AST node defining the reactor within which this occurs + * @param input Input of the contained reactor. + */ + private static void generateVariablesForSendingToContainedReactors( + CodeBuilder builder, + Map structs, + Instantiation definition, + Input input) { + CodeBuilder structBuilder = structs.get(definition); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(definition, structBuilder); } + String inputStructType = + CGenerator.variableStructType(input, new TypeParameterizedReactor(definition), false); + String defName = definition.getName(); + String defWidth = generateWidthVariable(defName); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); + if (!ASTUtils.isMultiport(input)) { + // Contained reactor's input is not a multiport. + structBuilder.pr(inputStructType + "* " + inputName + ";"); + if (definition.getWidthSpec() != null) { + // Contained reactor is a bank. + builder.pr( + String.join( + "\n", + "for (int bankIndex = 0; bankIndex < self->_lf_" + defWidth + "; bankIndex++) {", + " " + + defName + + "[bankIndex]." + + inputName + + " = &(self->_lf_" + + defName + + "[bankIndex]." + + inputName + + ");", + "}")); + } else { + // Contained reactor is not a bank. + builder.pr( + defName + "." + inputName + " = &(self->_lf_" + defName + "." + inputName + ");"); + } + } else { + // Contained reactor's input is a multiport. + structBuilder.pr( + String.join("\n", inputStructType + "** " + inputName + ";", "int " + inputWidth + ";")); + // If the contained reactor is a bank, then we have to set the + // pointer for each element of the bank. + if (definition.getWidthSpec() != null) { + builder.pr( + String.join( + "\n", + "for (int _i = 0; _i < self->_lf_" + defWidth + "; _i++) {", + " " + + defName + + "[_i]." + + inputName + + " = self->_lf_" + + defName + + "[_i]." + + inputName + + ";", + " " + + defName + + "[_i]." + + inputWidth + + " = self->_lf_" + + defName + + "[_i]." + + inputWidth + + ";", + "}")); + } else { + builder.pr( + String.join( + "\n", + defName + "." + inputName + " = self->_lf_" + defName + "." + inputName + ";", + defName + "." + inputWidth + " = self->_lf_" + defName + "." + inputWidth + ";")); + } + } + } + + /** + * Generate into the specified string builder the code to initialize local variables for ports in + * a reaction function from the "self" struct. The port may be an input of the reactor or an + * output of a contained reactor. The second argument provides, for each contained reactor, a + * place to write the declaration of the output of that reactor that is triggering reactions. + * + * @param builder The place into which to write the code. + * @param structs A map from reactor instantiations to a place to write struct fields. + */ + private static void generatePortVariablesInReaction( + CodeBuilder builder, + Map structs, + VarRef port, + TypeParameterizedReactor tpr, + CTypes types) { + if (port.getVariable() instanceof Input) { + builder.pr(generateInputVariablesInReaction((Input) port.getVariable(), tpr, types)); + } else { + // port is an output of a contained reactor. + Output output = (Output) port.getVariable(); + String portStructType = + CGenerator.variableStructType( + output, new TypeParameterizedReactor(port.getContainer()), false); - /** Generate action variables for a reaction. - * @param action The action. - */ - private static String generateActionVariablesInReaction( - Action action, - TypeParameterizedReactor tpr, - CTypes types - ) { - String structType = CGenerator.variableStructType(action, tpr, false); - // If the action has a type, create variables for accessing the value. - InferredType type = ASTUtils.getInferredType(action); - // Pointer to the lf_token_t sent as the payload in the trigger. - String tokenPointer = "(self->_lf__"+action.getName()+".tmplt.token)"; - CodeBuilder builder = new CodeBuilder(); + CodeBuilder structBuilder = structs.get(port.getContainer()); + if (structBuilder == null) { + structBuilder = new CodeBuilder(); + structs.put(port.getContainer(), structBuilder); + } + String subName = port.getContainer().getName(); + String reactorWidth = generateWidthVariable(subName); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + // First define the struct containing the output value and indicator + // of its presence. + if (!ASTUtils.isMultiport(output)) { + // Output is not a multiport. + structBuilder.pr(portStructType + "* " + outputName + ";"); + } else { + // Output is a multiport. + structBuilder.pr( + String.join( + "\n", portStructType + "** " + outputName + ";", "int " + outputWidth + ";")); + } + // Next, initialize the struct with the current values. + if (port.getContainer().getWidthSpec() != null) { + // Output is in a bank. builder.pr( - String.join("\n", - "// Expose the action struct as a local variable whose name matches the action name.", - structType+"* "+action.getName()+" = &self->_lf_"+action.getName()+";", - "// Set the fields of the action struct to match the current trigger.", - action.getName()+"->is_present = (bool)self->_lf__"+action.getName()+".status;", - action.getName()+"->has_value = ("+tokenPointer+" != NULL && "+tokenPointer+"->value != NULL);", - "_lf_replace_template_token((token_template_t*)"+action.getName()+", "+tokenPointer+");") - ); - // Set the value field only if there is a type. - if (!type.isUndefined()) { - // The value field will either be a copy (for primitive types) - // or a pointer (for types ending in *). - builder.pr("if ("+action.getName()+"->has_value) {"); - builder.indent(); - if (CUtil.isTokenType(type, types)) { - builder.pr(action.getName()+"->value = ("+types.getTargetType(type)+")"+tokenPointer+"->value;"); - } else { - builder.pr(action.getName()+"->value = *("+types.getTargetType(type)+"*)"+tokenPointer+"->value;"); - } - builder.unindent(); - builder.pr("}"); + String.join( + "\n", + "for (int i = 0; i < " + reactorWidth + "; i++) {", + " " + + subName + + "[i]." + + outputName + + " = self->_lf_" + + subName + + "[i]." + + outputName + + ";", + "}")); + if (ASTUtils.isMultiport(output)) { + builder.pr( + String.join( + "\n", + "for (int i = 0; i < " + reactorWidth + "; i++) {", + " " + + subName + + "[i]." + + outputWidth + + " = self->_lf_" + + subName + + "[i]." + + outputWidth + + ";", + "}")); } - return builder.toString(); + } else { + // Output is not in a bank. + builder.pr(subName + "." + outputName + " = self->_lf_" + subName + "." + outputName + ";"); + if (ASTUtils.isMultiport(output)) { + builder.pr( + subName + "." + outputWidth + " = self->_lf_" + subName + "." + outputWidth + ";"); + } + } } + } - /** Generate into the specified string builder the code to - * initialize local variables for the specified input port - * in a reaction function from the "self" struct. - * @param input The input statement from the AST. - * @param tpr The reactor. - */ - private static String generateInputVariablesInReaction( - Input input, - TypeParameterizedReactor tpr, - CTypes types - ) { - String structType = CGenerator.variableStructType(input, tpr, false); - InferredType inputType = ASTUtils.getInferredType(input); - CodeBuilder builder = new CodeBuilder(); - String inputName = input.getName(); - String inputWidth = generateWidthVariable(inputName); + /** + * Generate action variables for a reaction. + * + * @param action The action. + */ + private static String generateActionVariablesInReaction( + Action action, TypeParameterizedReactor tpr, CTypes types) { + String structType = CGenerator.variableStructType(action, tpr, false); + // If the action has a type, create variables for accessing the value. + InferredType type = ASTUtils.getInferredType(action); + // Pointer to the lf_token_t sent as the payload in the trigger. + String tokenPointer = "(self->_lf__" + action.getName() + ".tmplt.token)"; + CodeBuilder builder = new CodeBuilder(); - // Create the local variable whose name matches the input name. - // If the input has not been declared mutable, then this is a pointer - // to the upstream output. Otherwise, it is a copy of the upstream output, - // which nevertheless points to the same token and value (hence, as done - // below, we have to use lf_writable_copy()). There are 8 cases, - // depending on whether the input is mutable, whether it is a multiport, - // and whether it is a token type. - // Easy case first. - if (!input.isMutable() && !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, primitive type. - builder.pr(structType+"* "+inputName+" = self->_lf_"+inputName+";"); - } else if (input.isMutable()&& !CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, primitive type. - builder.pr(String.join("\n", - "// Mutable input, so copy the input into a temporary variable.", - "// The input value on the struct is a copy.", - structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", - structType+"* "+inputName+" = &_lf_tmp_"+inputName+";" - )); - } else if (!input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, token type. - builder.pr(String.join("\n", - structType+"* "+inputName+" = self->_lf_"+inputName+";", - "if ("+inputName+"->is_present) {", - " "+inputName+"->length = "+inputName+"->token->length;", - " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", - "} else {", - " "+inputName+"->length = 0;", - "}" - )); - } else if (input.isMutable()&& CUtil.isTokenType(inputType, types) && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, token type. - builder.pr(String.join("\n", - "// Mutable input, so copy the input struct into a temporary variable.", - structType+" _lf_tmp_"+inputName+" = *(self->_lf_"+inputName+");", - structType+"* "+inputName+" = &_lf_tmp_"+inputName+";", - inputName+"->value = NULL;", // Prevent payload from being freed. - "if ("+inputName+"->is_present) {", - " "+inputName+"->length = "+inputName+"->token->length;", - " "+inputName+"->token = lf_writable_copy((lf_port_base_t*)self->_lf_"+inputName+");", - " "+inputName+"->value = ("+types.getTargetType(inputType)+")"+inputName+"->token->value;", - "} else {", - " "+inputName+"->length = 0;", - "}" - )); - } else if (!input.isMutable()&& ASTUtils.isMultiport(input)) { - // Non-mutable, multiport, primitive or token type. - builder.pr(structType+"** "+inputName+" = self->_lf_"+inputName+";"); - } else if (CUtil.isTokenType(inputType, types)) { - // Mutable, multiport, token type - builder.pr(String.join("\n", - "// Mutable multiport input, so copy the input structs", - "// into an array of temporary variables on the stack.", - structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", - " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", - " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", - " // If necessary, copy the tokens.", - " if ("+inputName+"[i]->is_present) {", - " "+inputName+"[i]->length = "+inputName+"[i]->token->length;", - " token_template_t* _lf_input = (token_template_t*)self->_lf_"+inputName+"[i];", - " "+inputName+"[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", - " "+inputName+"[i]->value = ("+types.getTargetType(inputType)+")"+inputName+"[i]->token->value;", - " } else {", - " "+inputName+"[i]->length = 0;", - " }", - "}" - )); - } else { - // Mutable, multiport, primitive type - builder.pr(String.join("\n", - "// Mutable multiport input, so copy the input structs", - "// into an array of temporary variables on the stack.", - structType+" _lf_tmp_"+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - structType+"* "+inputName+"["+CUtil.multiportWidthExpression(input)+"];", - "for (int i = 0; i < "+CUtil.multiportWidthExpression(input)+"; i++) {", - " "+inputName+"[i] = &_lf_tmp_"+inputName+"[i];", - " // Copy the struct, which includes the value.", - " _lf_tmp_"+inputName+"[i] = *(self->_lf_"+inputName+"[i]);", - "}" - )); - } - // Set the _width variable for all cases. This will be -1 - // for a variable-width multiport, which is not currently supported. - // It will be -2 if it is not multiport. - builder.pr("int "+inputWidth+" = self->_lf_"+inputWidth+"; SUPPRESS_UNUSED_WARNING("+inputWidth+");"); - return builder.toString(); + builder.pr( + String.join( + "\n", + "// Expose the action struct as a local variable whose name matches the action name.", + structType + "* " + action.getName() + " = &self->_lf_" + action.getName() + ";", + "// Set the fields of the action struct to match the current trigger.", + action.getName() + "->is_present = (bool)self->_lf__" + action.getName() + ".status;", + action.getName() + + "->has_value = (" + + tokenPointer + + " != NULL && " + + tokenPointer + + "->value != NULL);", + "_lf_replace_template_token((token_template_t*)" + + action.getName() + + ", " + + tokenPointer + + ");")); + // Set the value field only if there is a type. + if (!type.isUndefined()) { + // The value field will either be a copy (for primitive types) + // or a pointer (for types ending in *). + builder.pr("if (" + action.getName() + "->has_value) {"); + builder.indent(); + if (CUtil.isTokenType(type, types)) { + builder.pr( + action.getName() + + "->value = (" + + types.getTargetType(type) + + ")" + + tokenPointer + + "->value;"); + } else { + builder.pr( + action.getName() + + "->value = *(" + + types.getTargetType(type) + + "*)" + + tokenPointer + + "->value;"); + } + builder.unindent(); + builder.pr("}"); } + return builder.toString(); + } - /** - * Generate into the specified string builder the code to - * initialize local variables for outputs in a reaction function - * from the "self" struct. - * @param effect The effect declared by the reaction. This must refer to an output. - * @param tpr The reactor containing the reaction. - */ - public static String generateOutputVariablesInReaction( - VarRef effect, - TypeParameterizedReactor tpr, - ErrorReporter errorReporter, - boolean requiresTypes - ) { - Output output = (Output) effect.getVariable(); - String outputName = output.getName(); - String outputWidth = generateWidthVariable(outputName); - if (output.getType() == null && requiresTypes) { - errorReporter.reportError(output, "Output is required to have a type: " + outputName); - return ""; - } else { - // The container of the output may be a contained reactor or - // the reactor containing the reaction. - String outputStructType = (effect.getContainer() == null) ? - CGenerator.variableStructType(output, tpr, false) - : - CGenerator.variableStructType(output, new TypeParameterizedReactor(effect.getContainer()), false); - if (!ASTUtils.isMultiport(output)) { - // Output port is not a multiport. - return outputStructType+"* "+outputName+" = &self->_lf_"+outputName+";"; - } else { - // Output port is a multiport. - // Set the _width variable. - return String.join("\n", - "int "+outputWidth+" = self->_lf_"+outputWidth+"; SUPPRESS_UNUSED_WARNING("+outputWidth+");", - outputStructType+"** "+outputName+" = self->_lf_"+outputName+"_pointers;" - ); + /** + * Generate into the specified string builder the code to initialize local variables for the + * specified input port in a reaction function from the "self" struct. + * + * @param input The input statement from the AST. + * @param tpr The reactor. + */ + private static String generateInputVariablesInReaction( + Input input, TypeParameterizedReactor tpr, CTypes types) { + String structType = CGenerator.variableStructType(input, tpr, false); + InferredType inputType = ASTUtils.getInferredType(input); + CodeBuilder builder = new CodeBuilder(); + String inputName = input.getName(); + String inputWidth = generateWidthVariable(inputName); - } - } + // Create the local variable whose name matches the input name. + // If the input has not been declared mutable, then this is a pointer + // to the upstream output. Otherwise, it is a copy of the upstream output, + // which nevertheless points to the same token and value (hence, as done + // below, we have to use lf_writable_copy()). There are 8 cases, + // depending on whether the input is mutable, whether it is a multiport, + // and whether it is a token type. + // Easy case first. + if (!input.isMutable() + && !CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, primitive type. + builder.pr(structType + "* " + inputName + " = self->_lf_" + inputName + ";"); + } else if (input.isMutable() + && !CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, primitive type. + builder.pr( + String.join( + "\n", + "// Mutable input, so copy the input into a temporary variable.", + "// The input value on the struct is a copy.", + structType + " _lf_tmp_" + inputName + " = *(self->_lf_" + inputName + ");", + structType + "* " + inputName + " = &_lf_tmp_" + inputName + ";")); + } else if (!input.isMutable() + && CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, token type. + builder.pr( + String.join( + "\n", + structType + "* " + inputName + " = self->_lf_" + inputName + ";", + "if (" + inputName + "->is_present) {", + " " + inputName + "->length = " + inputName + "->token->length;", + " " + + inputName + + "->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "->token->value;", + "} else {", + " " + inputName + "->length = 0;", + "}")); + } else if (input.isMutable() + && CUtil.isTokenType(inputType, types) + && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, token type. + builder.pr( + String.join( + "\n", + "// Mutable input, so copy the input struct into a temporary variable.", + structType + " _lf_tmp_" + inputName + " = *(self->_lf_" + inputName + ");", + structType + "* " + inputName + " = &_lf_tmp_" + inputName + ";", + inputName + "->value = NULL;", // Prevent payload from being freed. + "if (" + inputName + "->is_present) {", + " " + inputName + "->length = " + inputName + "->token->length;", + " " + + inputName + + "->token = lf_writable_copy((lf_port_base_t*)self->_lf_" + + inputName + + ");", + " " + + inputName + + "->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "->token->value;", + "} else {", + " " + inputName + "->length = 0;", + "}")); + } else if (!input.isMutable() && ASTUtils.isMultiport(input)) { + // Non-mutable, multiport, primitive or token type. + builder.pr(structType + "** " + inputName + " = self->_lf_" + inputName + ";"); + } else if (CUtil.isTokenType(inputType, types)) { + // Mutable, multiport, token type + builder.pr( + String.join( + "\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType + + " _lf_tmp_" + + inputName + + "[" + + CUtil.multiportWidthExpression(input) + + "];", + structType + "* " + inputName + "[" + CUtil.multiportWidthExpression(input) + "];", + "for (int i = 0; i < " + CUtil.multiportWidthExpression(input) + "; i++) {", + " " + inputName + "[i] = &_lf_tmp_" + inputName + "[i];", + " _lf_tmp_" + inputName + "[i] = *(self->_lf_" + inputName + "[i]);", + " // If necessary, copy the tokens.", + " if (" + inputName + "[i]->is_present) {", + " " + inputName + "[i]->length = " + inputName + "[i]->token->length;", + " token_template_t* _lf_input = (token_template_t*)self->_lf_" + + inputName + + "[i];", + " " + inputName + "[i]->token = lf_writable_copy((lf_port_base_t*)_lf_input);", + " " + + inputName + + "[i]->value = (" + + types.getTargetType(inputType) + + ")" + + inputName + + "[i]->token->value;", + " } else {", + " " + inputName + "[i]->length = 0;", + " }", + "}")); + } else { + // Mutable, multiport, primitive type + builder.pr( + String.join( + "\n", + "// Mutable multiport input, so copy the input structs", + "// into an array of temporary variables on the stack.", + structType + + " _lf_tmp_" + + inputName + + "[" + + CUtil.multiportWidthExpression(input) + + "];", + structType + "* " + inputName + "[" + CUtil.multiportWidthExpression(input) + "];", + "for (int i = 0; i < " + CUtil.multiportWidthExpression(input) + "; i++) {", + " " + inputName + "[i] = &_lf_tmp_" + inputName + "[i];", + " // Copy the struct, which includes the value.", + " _lf_tmp_" + inputName + "[i] = *(self->_lf_" + inputName + "[i]);", + "}")); } + // Set the _width variable for all cases. This will be -1 + // for a variable-width multiport, which is not currently supported. + // It will be -2 if it is not multiport. + builder.pr( + "int " + + inputWidth + + " = self->_lf_" + + inputWidth + + "; SUPPRESS_UNUSED_WARNING(" + + inputWidth + + ");"); + return builder.toString(); + } - /** - * Generate into the specified string builder the code to initialize local variables for watchdogs - * in a reaction function from the "self" struct. - * - * @param effect The effect declared by the reaction. This must refer to a watchdog. - */ - public static String generateWatchdogVariablesInReaction(VarRef effect) { - Watchdog watchdog = (Watchdog) effect.getVariable(); - String watchdogName = watchdog.getName(); + /** + * Generate into the specified string builder the code to initialize local variables for outputs + * in a reaction function from the "self" struct. + * + * @param effect The effect declared by the reaction. This must refer to an output. + * @param tpr The reactor containing the reaction. + */ + public static String generateOutputVariablesInReaction( + VarRef effect, + TypeParameterizedReactor tpr, + ErrorReporter errorReporter, + boolean requiresTypes) { + Output output = (Output) effect.getVariable(); + String outputName = output.getName(); + String outputWidth = generateWidthVariable(outputName); + if (output.getType() == null && requiresTypes) { + errorReporter.reportError(output, "Output is required to have a type: " + outputName); + return ""; + } else { + // The container of the output may be a contained reactor or + // the reactor containing the reaction. + String outputStructType = + (effect.getContainer() == null) + ? CGenerator.variableStructType(output, tpr, false) + : CGenerator.variableStructType( + output, new TypeParameterizedReactor(effect.getContainer()), false); + if (!ASTUtils.isMultiport(output)) { + // Output port is not a multiport. + return outputStructType + "* " + outputName + " = &self->_lf_" + outputName + ";"; + } else { + // Output port is a multiport. + // Set the _width variable. return String.join( "\n", - List.of("watchdog_t* " + watchdogName + " = &(self->_lf_watchdog_" + watchdogName + ");") - ); + "int " + + outputWidth + + " = self->_lf_" + + outputWidth + + "; SUPPRESS_UNUSED_WARNING(" + + outputWidth + + ");", + outputStructType + "** " + outputName + " = self->_lf_" + outputName + "_pointers;"); + } } + } - /** - * Generate the fields of the self struct and statements for the constructor - * to create and initialize a reaction_t struct for each reaction in the - * specified reactor and a trigger_t struct for each trigger (input, action, - * timer, or output of a contained reactor). - * @param body The place to put the code for the self struct. - * @param tpr {@link TypeParameterizedReactor} - * @param constructorCode The place to put the constructor code. - */ - public static void generateReactionAndTriggerStructs( - CodeBuilder body, - TypeParameterizedReactor tpr, - CodeBuilder constructorCode, - CTypes types - ) { - var reactionCount = 0; - // Iterate over reactions and create initialize the reaction_t struct - // on the self struct. Also, collect a map from triggers to the reactions - // that are triggered by that trigger. Also, collect a set of sources - // that are read by reactions but do not trigger reactions. - // Finally, collect a set of triggers and sources that are outputs - // of contained reactors. - var triggerMap = new LinkedHashMap>(); - var sourceSet = new LinkedHashSet(); - var outputsOfContainedReactors = new LinkedHashMap(); - var startupReactions = new LinkedHashSet(); - var shutdownReactions = new LinkedHashSet(); - var resetReactions = new LinkedHashSet(); - for (Reaction reaction : ASTUtils.allReactions(tpr.reactor())) { - // Create the reaction_t struct. - body.pr(reaction, "reaction_t _lf__reaction_"+reactionCount+";"); + /** + * Generate into the specified string builder the code to initialize local variables for watchdogs + * in a reaction function from the "self" struct. + * + * @param effect The effect declared by the reaction. This must refer to a watchdog. + */ + public static String generateWatchdogVariablesInReaction(VarRef effect) { + Watchdog watchdog = (Watchdog) effect.getVariable(); + String watchdogName = watchdog.getName(); + return String.join( + "\n", + List.of("watchdog_t* " + watchdogName + " = &(self->_lf_watchdog_" + watchdogName + ");")); + } - // Create the map of triggers to reactions. - for (TriggerRef trigger : reaction.getTriggers()) { - // trigger may not be a VarRef (it could be "startup" or "shutdown"). - if (trigger instanceof VarRef triggerAsVarRef) { - var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); - if (reactionList == null) { - reactionList = new LinkedList<>(); - triggerMap.put(triggerAsVarRef.getVariable(), reactionList); - } - reactionList.add(reactionCount); - if (triggerAsVarRef.getContainer() != null) { - outputsOfContainedReactors.put(triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); - } - } else if (trigger instanceof BuiltinTriggerRef) { - switch(((BuiltinTriggerRef) trigger).getType()) { - case STARTUP: - startupReactions.add(reactionCount); - break; - case SHUTDOWN: - shutdownReactions.add(reactionCount); - break; - case RESET: - resetReactions.add(reactionCount); - break; - } - } - } - // Create the set of sources read but not triggering. - for (VarRef source : reaction.getSources()) { - sourceSet.add(source.getVariable()); - if (source.getContainer() != null) { - outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); - } - } + /** + * Generate the fields of the self struct and statements for the constructor to create and + * initialize a reaction_t struct for each reaction in the specified reactor and a trigger_t + * struct for each trigger (input, action, timer, or output of a contained reactor). + * + * @param body The place to put the code for the self struct. + * @param tpr {@link TypeParameterizedReactor} + * @param constructorCode The place to put the constructor code. + */ + public static void generateReactionAndTriggerStructs( + CodeBuilder body, TypeParameterizedReactor tpr, CodeBuilder constructorCode, CTypes types) { + var reactionCount = 0; + // Iterate over reactions and create initialize the reaction_t struct + // on the self struct. Also, collect a map from triggers to the reactions + // that are triggered by that trigger. Also, collect a set of sources + // that are read by reactions but do not trigger reactions. + // Finally, collect a set of triggers and sources that are outputs + // of contained reactors. + var triggerMap = new LinkedHashMap>(); + var sourceSet = new LinkedHashSet(); + var outputsOfContainedReactors = new LinkedHashMap(); + var startupReactions = new LinkedHashSet(); + var shutdownReactions = new LinkedHashSet(); + var resetReactions = new LinkedHashSet(); + for (Reaction reaction : ASTUtils.allReactions(tpr.reactor())) { + // Create the reaction_t struct. + body.pr(reaction, "reaction_t _lf__reaction_" + reactionCount + ";"); - var deadlineFunctionPointer = "NULL"; - if (reaction.getDeadline() != null) { - // The following has to match the name chosen in generateReactions - var deadlineFunctionName = generateDeadlineFunctionName(tpr, reactionCount); - deadlineFunctionPointer = "&" + deadlineFunctionName; - } + // Create the map of triggers to reactions. + for (TriggerRef trigger : reaction.getTriggers()) { + // trigger may not be a VarRef (it could be "startup" or "shutdown"). + if (trigger instanceof VarRef triggerAsVarRef) { + var reactionList = triggerMap.get(triggerAsVarRef.getVariable()); + if (reactionList == null) { + reactionList = new LinkedList<>(); + triggerMap.put(triggerAsVarRef.getVariable(), reactionList); + } + reactionList.add(reactionCount); + if (triggerAsVarRef.getContainer() != null) { + outputsOfContainedReactors.put( + triggerAsVarRef.getVariable(), triggerAsVarRef.getContainer()); + } + } else if (trigger instanceof BuiltinTriggerRef) { + switch (((BuiltinTriggerRef) trigger).getType()) { + case STARTUP: + startupReactions.add(reactionCount); + break; + case SHUTDOWN: + shutdownReactions.add(reactionCount); + break; + case RESET: + resetReactions.add(reactionCount); + break; + } + } + } + // Create the set of sources read but not triggering. + for (VarRef source : reaction.getSources()) { + sourceSet.add(source.getVariable()); + if (source.getContainer() != null) { + outputsOfContainedReactors.put(source.getVariable(), source.getContainer()); + } + } - // Assign the STP handler - var STPFunctionPointer = "NULL"; - if (reaction.getStp() != null) { - // The following has to match the name chosen in generateReactions - var STPFunctionName = generateStpFunctionName(tpr, reactionCount); - STPFunctionPointer = "&" + STPFunctionName; - } + var deadlineFunctionPointer = "NULL"; + if (reaction.getDeadline() != null) { + // The following has to match the name chosen in generateReactions + var deadlineFunctionName = generateDeadlineFunctionName(tpr, reactionCount); + deadlineFunctionPointer = "&" + deadlineFunctionName; + } - // Set the defaults of the reaction_t struct in the constructor. - // Since the self struct is allocated using calloc, there is no need to set: - // self->_lf__reaction_"+reactionCount+".index = 0; - // self->_lf__reaction_"+reactionCount+".chain_id = 0; - // self->_lf__reaction_"+reactionCount+".pos = 0; - // self->_lf__reaction_"+reactionCount+".status = inactive; - // self->_lf__reaction_"+reactionCount+".deadline = 0LL; - // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; - constructorCode.pr(reaction, String.join("\n", - "self->_lf__reaction_"+reactionCount+".number = "+reactionCount+";", - "self->_lf__reaction_"+reactionCount+".function = "+CReactionGenerator.generateReactionFunctionName(tpr, reactionCount)+";", - "self->_lf__reaction_"+reactionCount+".self = self;", - "self->_lf__reaction_"+reactionCount+".deadline_violation_handler = "+deadlineFunctionPointer+";", - "self->_lf__reaction_"+reactionCount+".STP_handler = "+STPFunctionPointer+";", - "self->_lf__reaction_"+reactionCount+".name = "+addDoubleQuotes("?")+";", - reaction.eContainer() instanceof Mode ? - "self->_lf__reaction_"+reactionCount+".mode = &self->_lf__modes["+tpr.reactor().getModes().indexOf((Mode) reaction.eContainer())+"];" : - "self->_lf__reaction_"+reactionCount+".mode = NULL;" - )); - // Increment the reactionCount even if the reaction is not in the federate - // so that reaction indices are consistent across federates. - reactionCount++; - } + // Assign the STP handler + var STPFunctionPointer = "NULL"; + if (reaction.getStp() != null) { + // The following has to match the name chosen in generateReactions + var STPFunctionName = generateStpFunctionName(tpr, reactionCount); + STPFunctionPointer = "&" + STPFunctionName; + } - // Next, create and initialize the trigger_t objects. - // Start with the timers. - for (Timer timer : ASTUtils.allTimers(tpr.reactor())) { - createTriggerT(body, timer, triggerMap, constructorCode, types); - // Since the self struct is allocated using calloc, there is no need to set falsy fields. - constructorCode.pr("self->_lf__"+timer.getName()+".is_timer = true;"); - constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+timer.getName()+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - } + // Set the defaults of the reaction_t struct in the constructor. + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__reaction_"+reactionCount+".index = 0; + // self->_lf__reaction_"+reactionCount+".chain_id = 0; + // self->_lf__reaction_"+reactionCount+".pos = 0; + // self->_lf__reaction_"+reactionCount+".status = inactive; + // self->_lf__reaction_"+reactionCount+".deadline = 0LL; + // self->_lf__reaction_"+reactionCount+".is_STP_violated = false; + constructorCode.pr( + reaction, + String.join( + "\n", + "self->_lf__reaction_" + reactionCount + ".number = " + reactionCount + ";", + "self->_lf__reaction_" + + reactionCount + + ".function = " + + CReactionGenerator.generateReactionFunctionName(tpr, reactionCount) + + ";", + "self->_lf__reaction_" + reactionCount + ".self = self;", + "self->_lf__reaction_" + + reactionCount + + ".deadline_violation_handler = " + + deadlineFunctionPointer + + ";", + "self->_lf__reaction_" + reactionCount + ".STP_handler = " + STPFunctionPointer + ";", + "self->_lf__reaction_" + reactionCount + ".name = " + addDoubleQuotes("?") + ";", + reaction.eContainer() instanceof Mode + ? "self->_lf__reaction_" + + reactionCount + + ".mode = &self->_lf__modes[" + + tpr.reactor().getModes().indexOf((Mode) reaction.eContainer()) + + "];" + : "self->_lf__reaction_" + reactionCount + ".mode = NULL;")); + // Increment the reactionCount even if the reaction is not in the federate + // so that reaction indices are consistent across federates. + reactionCount++; + } - // Handle builtin triggers. - if (startupReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); - } - // Handle shutdown triggers. - if (shutdownReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); - } - if (resetReactions.size() > 0) { - generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); - } + // Next, create and initialize the trigger_t objects. + // Start with the timers. + for (Timer timer : ASTUtils.allTimers(tpr.reactor())) { + createTriggerT(body, timer, triggerMap, constructorCode, types); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + constructorCode.pr("self->_lf__" + timer.getName() + ".is_timer = true;"); + constructorCode.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + + timer.getName() + + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + } - // Next handle actions. - for (Action action : ASTUtils.allActions(tpr.reactor())) { - createTriggerT(body, action, triggerMap, constructorCode, types); - var isPhysical = "true"; - if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { - isPhysical = "false"; - } - var elementSize = "0"; - // If the action type is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) - : null; - if (rootType != null && !rootType.equals("void")) { - elementSize = "sizeof(" + rootType + ")"; - } + // Handle builtin triggers. + if (startupReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(startupReactions, "startup", body, constructorCode); + } + // Handle shutdown triggers. + if (shutdownReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(shutdownReactions, "shutdown", body, constructorCode); + } + if (resetReactions.size() > 0) { + generateBuiltinTriggeredReactionsArray(resetReactions, "reset", body, constructorCode); + } - // Since the self struct is allocated using calloc, there is no need to set: - // self->_lf__"+action.getName()+".is_timer = false; - constructorCode.pr(String.join("\n", - "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", - !(action.getPolicy() == null || action.getPolicy().isEmpty()) ? - "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" : - "", - // Need to set the element_size in the trigger_t and the action struct. - "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize - + ";", - "self->_lf_" + action.getName() + ".type.element_size = " + elementSize + ";" - )); - } + // Next handle actions. + for (Action action : ASTUtils.allActions(tpr.reactor())) { + createTriggerT(body, action, triggerMap, constructorCode, types); + var isPhysical = "true"; + if (action.getOrigin().equals(ActionOrigin.LOGICAL)) { + isPhysical = "false"; + } + var elementSize = "0"; + // If the action type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var rootType = action.getType() != null ? CUtil.rootType(types.getTargetType(action)) : null; + if (rootType != null && !rootType.equals("void")) { + elementSize = "sizeof(" + rootType + ")"; + } - // Next handle inputs. - for (Input input : ASTUtils.allInputs(tpr.reactor())) { - createTriggerT(body, input, triggerMap, constructorCode, types); - } + // Since the self struct is allocated using calloc, there is no need to set: + // self->_lf__"+action.getName()+".is_timer = false; + constructorCode.pr( + String.join( + "\n", + "self->_lf__" + action.getName() + ".is_physical = " + isPhysical + ";", + !(action.getPolicy() == null || action.getPolicy().isEmpty()) + ? "self->_lf__" + action.getName() + ".policy = " + action.getPolicy() + ";" + : "", + // Need to set the element_size in the trigger_t and the action struct. + "self->_lf__" + action.getName() + ".tmplt.type.element_size = " + elementSize + ";", + "self->_lf_" + action.getName() + ".type.element_size = " + elementSize + ";")); + } - // Next handle watchdogs. - for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.reactor())) { - createTriggerT(body, watchdog, triggerMap, constructorCode, types); - } + // Next handle inputs. + for (Input input : ASTUtils.allInputs(tpr.reactor())) { + createTriggerT(body, input, triggerMap, constructorCode, types); } - /** - * Define the trigger_t object on the self struct, an array of - * reaction_t pointers pointing to reactions triggered by this variable, - * and initialize the pointers in the array in the constructor. - * @param body The place to write the self struct entries. - * @param variable The trigger variable (Timer, Action, Watchdog, or Input). - * @param triggerMap A map from Variables to a list of the reaction indices triggered by the - * variable. - * @param constructorCode The place to write the constructor code. - */ - private static void createTriggerT( - CodeBuilder body, - Variable variable, - LinkedHashMap> triggerMap, - CodeBuilder constructorCode, - CTypes types - ) { - var varName = variable.getName(); - // variable is a port, a timer, or an action. - body.pr(variable, "trigger_t _lf__"+varName+";"); - constructorCode.pr(variable, "self->_lf__"+varName+".last = NULL;"); - constructorCode.pr(variable, CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+varName+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + // Next handle watchdogs. + for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.reactor())) { + createTriggerT(body, watchdog, triggerMap, constructorCode, types); + } + } - // Generate the reactions triggered table. - var reactionsTriggered = triggerMap.get(variable); - if (reactionsTriggered != null) { - body.pr(variable, "reaction_t* _lf__"+varName+"_reactions["+reactionsTriggered.size()+"];"); - var count = 0; - for (Integer reactionTriggered : reactionsTriggered) { - constructorCode.prSourceLineNumber(variable); - constructorCode.pr(variable, "self->_lf__"+varName+"_reactions["+count+"] = &self->_lf__reaction_"+reactionTriggered+";"); - count++; - } - // Set up the trigger_t struct's pointer to the reactions. - constructorCode.pr(variable, String.join("\n", - "self->_lf__"+varName+".reactions = &self->_lf__"+varName+"_reactions[0];", - "self->_lf__"+varName+".number_of_reactions = "+count+";" - )); + /** + * Define the trigger_t object on the self struct, an array of reaction_t pointers pointing to + * reactions triggered by this variable, and initialize the pointers in the array in the + * constructor. + * + * @param body The place to write the self struct entries. + * @param variable The trigger variable (Timer, Action, Watchdog, or Input). + * @param triggerMap A map from Variables to a list of the reaction indices triggered by the + * variable. + * @param constructorCode The place to write the constructor code. + */ + private static void createTriggerT( + CodeBuilder body, + Variable variable, + LinkedHashMap> triggerMap, + CodeBuilder constructorCode, + CTypes types) { + var varName = variable.getName(); + // variable is a port, a timer, or an action. + body.pr(variable, "trigger_t _lf__" + varName + ";"); + constructorCode.pr(variable, "self->_lf__" + varName + ".last = NULL;"); + constructorCode.pr( + variable, + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + + varName + + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - // If federated, set the physical_time_of_arrival - constructorCode.pr(variable, CExtensionUtils.surroundWithIfFederated( - "self->_lf__"+varName+".physical_time_of_arrival = NEVER;")); - } - if (variable instanceof Input) { - var rootType = CUtil.rootType(types.getTargetType((Input) variable)); - // Since the self struct is allocated using calloc, there is no need to set falsy fields. - // If the input type is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var size = (rootType.equals("void")) ? "0" : "sizeof("+rootType+")"; + // Generate the reactions triggered table. + var reactionsTriggered = triggerMap.get(variable); + if (reactionsTriggered != null) { + body.pr( + variable, + "reaction_t* _lf__" + varName + "_reactions[" + reactionsTriggered.size() + "];"); + var count = 0; + for (Integer reactionTriggered : reactionsTriggered) { + constructorCode.prSourceLineNumber(variable); + constructorCode.pr( + variable, + "self->_lf__" + + varName + + "_reactions[" + + count + + "] = &self->_lf__reaction_" + + reactionTriggered + + ";"); + count++; + } + // Set up the trigger_t struct's pointer to the reactions. + constructorCode.pr( + variable, + String.join( + "\n", + "self->_lf__" + varName + ".reactions = &self->_lf__" + varName + "_reactions[0];", + "self->_lf__" + varName + ".number_of_reactions = " + count + ";")); - constructorCode.pr("self->_lf__"+varName+".tmplt.type.element_size = "+size+";"); - body.pr( - CExtensionUtils.surroundWithIfFederated( - CExtensionUtils.createPortStatusFieldForInput((Input) variable) - ) - ); - } + // If federated, set the physical_time_of_arrival + constructorCode.pr( + variable, + CExtensionUtils.surroundWithIfFederated( + "self->_lf__" + varName + ".physical_time_of_arrival = NEVER;")); } + if (variable instanceof Input) { + var rootType = CUtil.rootType(types.getTargetType((Input) variable)); + // Since the self struct is allocated using calloc, there is no need to set falsy fields. + // If the input type is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var size = (rootType.equals("void")) ? "0" : "sizeof(" + rootType + ")"; - public static void generateBuiltinTriggeredReactionsArray( - Set reactions, - String name, - CodeBuilder body, - CodeBuilder constructorCode - ) { - body.pr(String.join("\n", - "trigger_t _lf__"+name+";", - "reaction_t* _lf__"+name+"_reactions["+reactions.size()+"];" - )); - constructorCode.pr(CExtensionUtils.surroundWithIfFederatedDecentralized( - "self->_lf__"+name+".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); - var i = 0; - for (Integer reactionIndex : reactions) { - constructorCode.pr("self->_lf__"+name+"_reactions["+i+++"] = &self->_lf__reaction_"+reactionIndex+";"); - } - constructorCode.pr(String.join("\n", - "self->_lf__"+name+".last = NULL;", - "self->_lf__"+name+".reactions = &self->_lf__"+name+"_reactions[0];", - "self->_lf__"+name+".number_of_reactions = "+reactions.size()+";", - "self->_lf__"+name+".is_timer = false;" - )); + constructorCode.pr("self->_lf__" + varName + ".tmplt.type.element_size = " + size + ";"); + body.pr( + CExtensionUtils.surroundWithIfFederated( + CExtensionUtils.createPortStatusFieldForInput((Input) variable))); } + } - public static String generateBuiltinTriggersTable(int reactionCount, String name) { - return String.join("\n", List.of( - "// Array of pointers to "+name+" triggers.", - (reactionCount > 0 ? - "reaction_t* _lf_"+name+"_reactions["+reactionCount+"]" : - "reaction_t** _lf_"+name+"_reactions = NULL") + ";", - "int _lf_"+name+"_reactions_size = "+reactionCount+";" - )); + public static void generateBuiltinTriggeredReactionsArray( + Set reactions, String name, CodeBuilder body, CodeBuilder constructorCode) { + body.pr( + String.join( + "\n", + "trigger_t _lf__" + name + ";", + "reaction_t* _lf__" + name + "_reactions[" + reactions.size() + "];")); + constructorCode.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "self->_lf__" + name + ".intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + var i = 0; + for (Integer reactionIndex : reactions) { + constructorCode.pr( + "self->_lf__" + + name + + "_reactions[" + + i++ + + "] = &self->_lf__reaction_" + + reactionIndex + + ";"); } + constructorCode.pr( + String.join( + "\n", + "self->_lf__" + name + ".last = NULL;", + "self->_lf__" + name + ".reactions = &self->_lf__" + name + "_reactions[0];", + "self->_lf__" + name + ".number_of_reactions = " + reactions.size() + ";", + "self->_lf__" + name + ".is_timer = false;")); + } - /** - * Generate the _lf_trigger_startup_reactions function. - */ - public static String generateLfTriggerStartupReactions(int startupReactionCount, boolean hasModalReactors) { - var s = new StringBuilder(); - s.append("void _lf_trigger_startup_reactions() {"); - if (startupReactionCount > 0) { - s.append("\n"); - if (hasModalReactors) { - s.append(String.join("\n", - " for (int i = 0; i < _lf_startup_reactions_size; i++) {", - " if (_lf_startup_reactions[i] != NULL) {", - " if (_lf_startup_reactions[i]->mode != NULL) {", - " // Skip reactions in modes", - " continue;", - " }", - " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", - " }", - " }", - " _lf_handle_mode_startup_reset_reactions(", - " _lf_startup_reactions, _lf_startup_reactions_size,", - " NULL, 0,", - " _lf_modal_reactor_states, _lf_modal_reactor_states_size);" - )); - } else { - s.append(String.join("\n", - " for (int i = 0; i < _lf_startup_reactions_size; i++) {", - " if (_lf_startup_reactions[i] != NULL) {", - " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", - " }", - " }" - )); - } - s.append("\n"); - } - s.append("}\n"); - return s.toString(); + public static String generateBuiltinTriggersTable(int reactionCount, String name) { + return String.join( + "\n", + List.of( + "// Array of pointers to " + name + " triggers.", + (reactionCount > 0 + ? "reaction_t* _lf_" + name + "_reactions[" + reactionCount + "]" + : "reaction_t** _lf_" + name + "_reactions = NULL") + + ";", + "int _lf_" + name + "_reactions_size = " + reactionCount + ";")); + } + + /** Generate the _lf_trigger_startup_reactions function. */ + public static String generateLfTriggerStartupReactions( + int startupReactionCount, boolean hasModalReactors) { + var s = new StringBuilder(); + s.append("void _lf_trigger_startup_reactions() {"); + if (startupReactionCount > 0) { + s.append("\n"); + if (hasModalReactors) { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_startup_reactions_size; i++) {", + " if (_lf_startup_reactions[i] != NULL) {", + " if (_lf_startup_reactions[i]->mode != NULL) {", + " // Skip reactions in modes", + " continue;", + " }", + " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", + " }", + " }", + " _lf_handle_mode_startup_reset_reactions(", + " _lf_startup_reactions, _lf_startup_reactions_size,", + " NULL, 0,", + " _lf_modal_reactor_states, _lf_modal_reactor_states_size);")); + } else { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_startup_reactions_size; i++) {", + " if (_lf_startup_reactions[i] != NULL) {", + " _lf_trigger_reaction(_lf_startup_reactions[i], -1);", + " }", + " }")); + } + s.append("\n"); } + s.append("}\n"); + return s.toString(); + } - /** - * Generate the _lf_trigger_shutdown_reactions function. - */ - public static String generateLfTriggerShutdownReactions(int shutdownReactionCount, boolean hasModalReactors) { - var s = new StringBuilder(); - s.append("bool _lf_trigger_shutdown_reactions() {\n"); - if (shutdownReactionCount > 0) { - if (hasModalReactors) { - s.append(String.join("\n", - " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", - " if (_lf_shutdown_reactions[i] != NULL) {", - " if (_lf_shutdown_reactions[i]->mode != NULL) {", - " // Skip reactions in modes", - " continue;", - " }", - " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", - " }", - " }", - " _lf_handle_mode_shutdown_reactions(_lf_shutdown_reactions, _lf_shutdown_reactions_size);", - " return true;" - )); - } else { - s.append(String.join("\n", - " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", - " if (_lf_shutdown_reactions[i] != NULL) {", - " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", - " }", - " }", - " return true;" - )); - } - s.append("\n"); - } else { - s.append(" return false;\n"); - } - s.append("}\n"); - return s.toString(); + /** Generate the _lf_trigger_shutdown_reactions function. */ + public static String generateLfTriggerShutdownReactions( + int shutdownReactionCount, boolean hasModalReactors) { + var s = new StringBuilder(); + s.append("bool _lf_trigger_shutdown_reactions() {\n"); + if (shutdownReactionCount > 0) { + if (hasModalReactors) { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", + " if (_lf_shutdown_reactions[i] != NULL) {", + " if (_lf_shutdown_reactions[i]->mode != NULL) {", + " // Skip reactions in modes", + " continue;", + " }", + " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", + " }", + " }", + " _lf_handle_mode_shutdown_reactions(_lf_shutdown_reactions," + + " _lf_shutdown_reactions_size);", + " return true;")); + } else { + s.append( + String.join( + "\n", + " for (int i = 0; i < _lf_shutdown_reactions_size; i++) {", + " if (_lf_shutdown_reactions[i] != NULL) {", + " _lf_trigger_reaction(_lf_shutdown_reactions[i], -1);", + " }", + " }", + " return true;")); + } + s.append("\n"); + } else { + s.append(" return false;\n"); } + s.append("}\n"); + return s.toString(); + } - /** - * Generate the _lf_handle_mode_triggered_reactions function. - */ - public static String generateLfModeTriggeredReactions( - int startupReactionCount, - int resetReactionCount, - boolean hasModalReactors - ) { - if (!hasModalReactors) { - return ""; - } - var s = new StringBuilder(); - s.append("void _lf_handle_mode_triggered_reactions() {\n"); - s.append(" _lf_handle_mode_startup_reset_reactions(\n"); - if (startupReactionCount > 0) { - s.append(" _lf_startup_reactions, _lf_startup_reactions_size,\n"); - } else { - s.append(" NULL, 0,\n"); - } - if (resetReactionCount > 0) { - s.append(" _lf_reset_reactions, _lf_reset_reactions_size,\n"); - } else { - s.append(" NULL, 0,\n"); - } - s.append(" _lf_modal_reactor_states, _lf_modal_reactor_states_size);\n"); - s.append("}\n"); - return s.toString(); + /** Generate the _lf_handle_mode_triggered_reactions function. */ + public static String generateLfModeTriggeredReactions( + int startupReactionCount, int resetReactionCount, boolean hasModalReactors) { + if (!hasModalReactors) { + return ""; + } + var s = new StringBuilder(); + s.append("void _lf_handle_mode_triggered_reactions() {\n"); + s.append(" _lf_handle_mode_startup_reset_reactions(\n"); + if (startupReactionCount > 0) { + s.append(" _lf_startup_reactions, _lf_startup_reactions_size,\n"); + } else { + s.append(" NULL, 0,\n"); } + if (resetReactionCount > 0) { + s.append(" _lf_reset_reactions, _lf_reset_reactions_size,\n"); + } else { + s.append(" NULL, 0,\n"); + } + s.append(" _lf_modal_reactor_states, _lf_modal_reactor_states_size);\n"); + s.append("}\n"); + return s.toString(); + } - /** Generate a reaction function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param tpr The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - public static String generateReaction( - Reaction reaction, - TypeParameterizedReactor tpr, - int reactionIndex, - Instantiation mainDef, - ErrorReporter errorReporter, - CTypes types, - TargetConfig targetConfig, - boolean requiresType - ) { - var code = new CodeBuilder(); - var body = ASTUtils.toText(getCode(types, reaction, tpr)); - String init = generateInitializationForReaction( - body, reaction, tpr, reactionIndex, - types, errorReporter, mainDef, - requiresType); + /** + * Generate a reaction function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param tpr The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + public static String generateReaction( + Reaction reaction, + TypeParameterizedReactor tpr, + int reactionIndex, + Instantiation mainDef, + ErrorReporter errorReporter, + CTypes types, + TargetConfig targetConfig, + boolean requiresType) { + var code = new CodeBuilder(); + var body = ASTUtils.toText(getCode(types, reaction, tpr)); + String init = + generateInitializationForReaction( + body, reaction, tpr, reactionIndex, types, errorReporter, mainDef, requiresType); - code.pr( - "#include " + StringUtil.addDoubleQuotes( - CCoreFilesUtils.getCTargetSetHeader())); + code.pr("#include " + StringUtil.addDoubleQuotes(CCoreFilesUtils.getCTargetSetHeader())); - CMethodGenerator.generateMacrosForMethods(tpr, code); - code.pr(generateFunction( + CMethodGenerator.generateMacrosForMethods(tpr, code); + code.pr( + generateFunction( generateReactionFunctionHeader(tpr, reactionIndex), - init, getCode(types, reaction, tpr) - )); - // Now generate code for the late function, if there is one - // Note that this function can only be defined on reactions - // in federates that have inputs from a logical connection. - if (reaction.getStp() != null) { - code.pr(generateFunction( - generateStpFunctionHeader(tpr, reactionIndex), - init, reaction.getStp().getCode())); - } - - // Now generate code for the deadline violation function, if there is one. - if (reaction.getDeadline() != null) { - code.pr(generateFunction( - generateDeadlineFunctionHeader(tpr, reactionIndex), - init, reaction.getDeadline().getCode())); - } - CMethodGenerator.generateMacroUndefsForMethods(tpr.reactor(), code); - code.pr( - "#include " + StringUtil.addDoubleQuotes( - CCoreFilesUtils.getCTargetSetUndefHeader())); - return code.toString(); + init, + getCode(types, reaction, tpr))); + // Now generate code for the late function, if there is one + // Note that this function can only be defined on reactions + // in federates that have inputs from a logical connection. + if (reaction.getStp() != null) { + code.pr( + generateFunction( + generateStpFunctionHeader(tpr, reactionIndex), init, reaction.getStp().getCode())); } - private static Code getCode(CTypes types, Reaction r, TypeParameterizedReactor tpr) { - if (r.getCode() != null) return r.getCode(); - Code ret = LfFactory.eINSTANCE.createCode(); - ret.setBody( - CReactorHeaderFileGenerator.nonInlineInitialization(r, tpr) + "\n" - + r.getName() + "( " + CReactorHeaderFileGenerator.reactionArguments(r, tpr) + " );"); - return ret; + // Now generate code for the deadline violation function, if there is one. + if (reaction.getDeadline() != null) { + code.pr( + generateFunction( + generateDeadlineFunctionHeader(tpr, reactionIndex), + init, + reaction.getDeadline().getCode())); } + CMethodGenerator.generateMacroUndefsForMethods(tpr.reactor(), code); + code.pr("#include " + StringUtil.addDoubleQuotes(CCoreFilesUtils.getCTargetSetUndefHeader())); + return code.toString(); + } - public static String generateFunction(String header, String init, Code code) { - var function = new CodeBuilder(); - function.pr(header + " {"); - function.indent(); - function.pr(init); - function.prSourceLineNumber(code); - function.pr(ASTUtils.toText(code)); - function.unindent(); - function.pr("}"); - return function.toString(); - } + private static Code getCode(CTypes types, Reaction r, TypeParameterizedReactor tpr) { + if (r.getCode() != null) return r.getCode(); + Code ret = LfFactory.eINSTANCE.createCode(); + ret.setBody( + CReactorHeaderFileGenerator.nonInlineInitialization(r, tpr) + + "\n" + + r.getName() + + "( " + + CReactorHeaderFileGenerator.reactionArguments(r, tpr) + + " );"); + return ret; + } - /** - * Returns the name of the deadline function for reaction. - * @param tpr The reactor with the deadline - * @param reactionIndex The number assigned to this reaction deadline - */ - public static String generateDeadlineFunctionName(TypeParameterizedReactor tpr, int reactionIndex) { - return CUtil.getName(tpr).toLowerCase() + "_deadline_function" + reactionIndex; - } + public static String generateFunction(String header, String init, Code code) { + var function = new CodeBuilder(); + function.pr(header + " {"); + function.indent(); + function.pr(init); + function.prSourceLineNumber(code); + function.pr(ASTUtils.toText(code)); + function.unindent(); + function.pr("}"); + return function.toString(); + } - /** - * Return the function name for specified reaction of the - * specified reactor. - * @param tpr The reactor - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateReactionFunctionName(TypeParameterizedReactor tpr, int reactionIndex) { - return CUtil.getName(tpr).toLowerCase() + "reaction_function_" + reactionIndex; - } + /** + * Returns the name of the deadline function for reaction. + * + * @param tpr The reactor with the deadline + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateDeadlineFunctionName( + TypeParameterizedReactor tpr, int reactionIndex) { + return CUtil.getName(tpr).toLowerCase() + "_deadline_function" + reactionIndex; + } - /** - * Returns the name of the stp function for reaction. - * @param tpr The reactor with the stp - * @param reactionIndex The number assigned to this reaction deadline - */ - public static String generateStpFunctionName(TypeParameterizedReactor tpr, int reactionIndex) { - return CUtil.getName(tpr).toLowerCase() + "_STP_function" + reactionIndex; - } + /** + * Return the function name for specified reaction of the specified reactor. + * + * @param tpr The reactor + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionName( + TypeParameterizedReactor tpr, int reactionIndex) { + return CUtil.getName(tpr).toLowerCase() + "reaction_function_" + reactionIndex; + } - /** Return the top level C function header for the deadline function numbered "reactionIndex" in "r" - * @param tpr The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the deadline function. - */ - public static String generateDeadlineFunctionHeader(TypeParameterizedReactor tpr, - int reactionIndex) { - String functionName = generateDeadlineFunctionName(tpr, reactionIndex); - return generateFunctionHeader(functionName); - } + /** + * Returns the name of the stp function for reaction. + * + * @param tpr The reactor with the stp + * @param reactionIndex The number assigned to this reaction deadline + */ + public static String generateStpFunctionName(TypeParameterizedReactor tpr, int reactionIndex) { + return CUtil.getName(tpr).toLowerCase() + "_STP_function" + reactionIndex; + } - /** Return the top level C function header for the reaction numbered "reactionIndex" in "r" - * @param tpr The reactor declaration - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateReactionFunctionHeader(TypeParameterizedReactor tpr, - int reactionIndex) { - String functionName = generateReactionFunctionName(tpr, reactionIndex); - return generateFunctionHeader(functionName); - } + /** + * Return the top level C function header for the deadline function numbered "reactionIndex" in + * "r" + * + * @param tpr The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the deadline function. + */ + public static String generateDeadlineFunctionHeader( + TypeParameterizedReactor tpr, int reactionIndex) { + String functionName = generateDeadlineFunctionName(tpr, reactionIndex); + return generateFunctionHeader(functionName); + } - public static String generateStpFunctionHeader(TypeParameterizedReactor tpr, - int reactionIndex) { - String functionName = generateStpFunctionName(tpr, reactionIndex); - return generateFunctionHeader(functionName); - } + /** + * Return the top level C function header for the reaction numbered "reactionIndex" in "r" + * + * @param tpr The reactor declaration + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateReactionFunctionHeader( + TypeParameterizedReactor tpr, int reactionIndex) { + String functionName = generateReactionFunctionName(tpr, reactionIndex); + return generateFunctionHeader(functionName); + } - /** - * Return the start of a function declaration for a function that takes - * a {@code void*} argument and returns void. - * - * @param functionName - * @return - */ - public static String generateFunctionHeader(String functionName) { - return "void " + functionName + "(void* instance_args)"; - } + public static String generateStpFunctionHeader(TypeParameterizedReactor tpr, int reactionIndex) { + String functionName = generateStpFunctionName(tpr, reactionIndex); + return generateFunctionHeader(functionName); + } + + /** + * Return the start of a function declaration for a function that takes a {@code void*} argument + * and returns void. + * + * @param functionName + * @return + */ + public static String generateFunctionHeader(String functionName) { + return "void " + functionName + "(void* instance_args)"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 993168cad9..4f6a29b405 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -6,7 +6,6 @@ import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Instantiation; @@ -23,44 +22,61 @@ /** Generate user-visible header files. */ public class CReactorHeaderFileGenerator { - /** Functional interface for generating auxiliary structs such as port structs. */ - public interface GenerateAuxiliaryStructs { - void generate(CodeBuilder b, TypeParameterizedReactor r, boolean userFacing); - } - - /** Return the path to the user-visible header file that would be generated for {@code r}. */ - public static Path outputPath(TypeParameterizedReactor tpr) { - return Path.of(Path.of(tpr.reactor().eResource().getURI().toFileString()) - .getFileName().toString().replaceFirst("[.][^.]+$", "")) - .resolve(tpr.getName() + ".h"); - } - - public static void doGenerate(CTypes types, TypeParameterizedReactor tpr, CFileConfig fileConfig, GenerateAuxiliaryStructs generator, Function topLevelPreamble) throws IOException { - String contents = generateHeaderFile(types, tpr, generator, topLevelPreamble.apply(tpr.reactor())); - FileUtil.writeToFile(contents, fileConfig.getIncludePath().resolve(outputPath(tpr))); - } - private static String generateHeaderFile(CTypes types, TypeParameterizedReactor tpr, GenerateAuxiliaryStructs generator, String topLevelPreamble) { - CodeBuilder builder = new CodeBuilder(); - appendIncludeGuard(builder, tpr); - builder.pr(topLevelPreamble); - appendPoundIncludes(builder); - tpr.doDefines(builder); - appendSelfStruct(builder, types, tpr); - generator.generate(builder, tpr, true); - for (Reaction reaction : tpr.reactor().getReactions()) { - appendSignature(builder, types, reaction, tpr); - } - builder.pr("#endif"); - return builder.getCode(); - } - - private static void appendIncludeGuard(CodeBuilder builder, TypeParameterizedReactor r) { - String macro = CUtil.getName(r) + "_H"; - builder.pr("#ifndef " + macro); - builder.pr("#define " + macro); - } - private static void appendPoundIncludes(CodeBuilder builder) { - builder.pr(""" + /** Functional interface for generating auxiliary structs such as port structs. */ + public interface GenerateAuxiliaryStructs { + void generate(CodeBuilder b, TypeParameterizedReactor r, boolean userFacing); + } + + /** Return the path to the user-visible header file that would be generated for {@code r}. */ + public static Path outputPath(TypeParameterizedReactor tpr) { + return Path.of( + Path.of(tpr.reactor().eResource().getURI().toFileString()) + .getFileName() + .toString() + .replaceFirst("[.][^.]+$", "")) + .resolve(tpr.getName() + ".h"); + } + + public static void doGenerate( + CTypes types, + TypeParameterizedReactor tpr, + CFileConfig fileConfig, + GenerateAuxiliaryStructs generator, + Function topLevelPreamble) + throws IOException { + String contents = + generateHeaderFile(types, tpr, generator, topLevelPreamble.apply(tpr.reactor())); + FileUtil.writeToFile(contents, fileConfig.getIncludePath().resolve(outputPath(tpr))); + } + + private static String generateHeaderFile( + CTypes types, + TypeParameterizedReactor tpr, + GenerateAuxiliaryStructs generator, + String topLevelPreamble) { + CodeBuilder builder = new CodeBuilder(); + appendIncludeGuard(builder, tpr); + builder.pr(topLevelPreamble); + appendPoundIncludes(builder); + tpr.doDefines(builder); + appendSelfStruct(builder, types, tpr); + generator.generate(builder, tpr, true); + for (Reaction reaction : tpr.reactor().getReactions()) { + appendSignature(builder, types, reaction, tpr); + } + builder.pr("#endif"); + return builder.getCode(); + } + + private static void appendIncludeGuard(CodeBuilder builder, TypeParameterizedReactor r) { + String macro = CUtil.getName(r) + "_H"; + builder.pr("#ifndef " + macro); + builder.pr("#define " + macro); + } + + private static void appendPoundIncludes(CodeBuilder builder) { + builder.pr( + """ #ifdef __cplusplus extern "C" { #endif @@ -71,135 +87,167 @@ private static void appendPoundIncludes(CodeBuilder builder) { } #endif """); - } - - private static String userFacingSelfType(TypeParameterizedReactor tpr) { - return tpr.getName().toLowerCase() + "_self_t"; - } - - private static void appendSelfStruct(CodeBuilder builder, CTypes types, TypeParameterizedReactor tpr) { - builder.pr("typedef struct " + userFacingSelfType(tpr) + "{"); - for (Parameter p : tpr.reactor().getParameters()) { - builder.pr(types.getTargetType(p) + " " + p.getName() + ";"); - } - for (StateVar s : tpr.reactor().getStateVars()) { - builder.pr(types.getTargetType(s) + " " + s.getName() + ";"); - } - builder.pr("int end[0]; // placeholder; MSVC does not compile empty structs"); - builder.pr("} " + userFacingSelfType(tpr) + ";"); - } - - private static void appendSignature(CodeBuilder builder, CTypes types, Reaction r, TypeParameterizedReactor tpr) { - if (r.getName() != null) builder.pr("void " + r.getName() + "(" + reactionParameters(r, tpr) + ");"); - } - - private static String reactionParameters(Reaction r, TypeParameterizedReactor tpr) { - return Stream.concat(Stream.of(userFacingSelfType(tpr) + "* self"), portVariableStream(r, tpr) - .map(tv -> tv.getType(true) + tv.getName())) - .collect(Collectors.joining(", ")); - } - - private static String getApiSelfStruct(TypeParameterizedReactor tpr) { - return "(" + userFacingSelfType(tpr) + "*) (((char*) self) + sizeof(self_base_t))"; - } - - /** Generate initialization code that is needed if {@code r} is not inlined. */ - public static String nonInlineInitialization(Reaction r, TypeParameterizedReactor reactor) { - var mainDef = LfFactory.eINSTANCE.createInstantiation(); - mainDef.setName(reactor.getName()); - mainDef.setReactorClass(ASTUtils.findMainReactor(reactor.reactor().eResource())); - return portVariableStream(r, reactor) - .map(it -> it.container == null ? "" : it.getWidth() == null ? - String.format("%s %s = (%s) %s;", it.getType(false), it.getAlias(), it.getType(false), it.getRvalue()) - : String.format(""" + } + + private static String userFacingSelfType(TypeParameterizedReactor tpr) { + return tpr.getName().toLowerCase() + "_self_t"; + } + + private static void appendSelfStruct( + CodeBuilder builder, CTypes types, TypeParameterizedReactor tpr) { + builder.pr("typedef struct " + userFacingSelfType(tpr) + "{"); + for (Parameter p : tpr.reactor().getParameters()) { + builder.pr(types.getTargetType(p) + " " + p.getName() + ";"); + } + for (StateVar s : tpr.reactor().getStateVars()) { + builder.pr(types.getTargetType(s) + " " + s.getName() + ";"); + } + builder.pr("int end[0]; // placeholder; MSVC does not compile empty structs"); + builder.pr("} " + userFacingSelfType(tpr) + ";"); + } + + private static void appendSignature( + CodeBuilder builder, CTypes types, Reaction r, TypeParameterizedReactor tpr) { + if (r.getName() != null) + builder.pr("void " + r.getName() + "(" + reactionParameters(r, tpr) + ");"); + } + + private static String reactionParameters(Reaction r, TypeParameterizedReactor tpr) { + return Stream.concat( + Stream.of(userFacingSelfType(tpr) + "* self"), + portVariableStream(r, tpr).map(tv -> tv.getType(true) + tv.getName())) + .collect(Collectors.joining(", ")); + } + + private static String getApiSelfStruct(TypeParameterizedReactor tpr) { + return "(" + userFacingSelfType(tpr) + "*) (((char*) self) + sizeof(self_base_t))"; + } + + /** Generate initialization code that is needed if {@code r} is not inlined. */ + public static String nonInlineInitialization(Reaction r, TypeParameterizedReactor reactor) { + var mainDef = LfFactory.eINSTANCE.createInstantiation(); + mainDef.setName(reactor.getName()); + mainDef.setReactorClass(ASTUtils.findMainReactor(reactor.reactor().eResource())); + return portVariableStream(r, reactor) + .map( + it -> + it.container == null + ? "" + : it.getWidth() == null + ? String.format( + "%s %s = (%s) %s;", + it.getType(false), it.getAlias(), it.getType(false), it.getRvalue()) + : String.format( + """ %s %s[%s]; for (int i = 0; i < %s; i++) { %s[i] = (%s) self->_lf_%s[i].%s; } """, - it.getType(true).replaceFirst("\\*", ""), - it.getAlias(), - CReactionGenerator.maxContainedReactorBankWidth( - reactor.reactor().getInstantiations().stream() - .filter(instantiation -> new TypeParameterizedReactor(instantiation).equals(it.r)) - .findAny().orElseThrow(), - null, 0, mainDef), - "self->_lf_"+it.container.getName()+"_width", - it.getAlias(), - it.getType(true).replaceFirst("\\*", ""), - it.container.getName(), - it.getName())) - .collect(Collectors.joining("\n")); - } - - /** Return a string representation of the arguments passed to the function for {@code r}. */ - public static String reactionArguments(Reaction r, TypeParameterizedReactor reactor) { - return Stream.concat(Stream.of(getApiSelfStruct(reactor)), portVariableStream(r, reactor) + it.getType(true).replaceFirst("\\*", ""), + it.getAlias(), + CReactionGenerator.maxContainedReactorBankWidth( + reactor.reactor().getInstantiations().stream() + .filter( + instantiation -> + new TypeParameterizedReactor(instantiation) + .equals(it.r)) + .findAny() + .orElseThrow(), + null, + 0, + mainDef), + "self->_lf_" + it.container.getName() + "_width", + it.getAlias(), + it.getType(true).replaceFirst("\\*", ""), + it.container.getName(), + it.getName())) + .collect(Collectors.joining("\n")); + } + + /** Return a string representation of the arguments passed to the function for {@code r}. */ + public static String reactionArguments(Reaction r, TypeParameterizedReactor reactor) { + return Stream.concat( + Stream.of(getApiSelfStruct(reactor)), + portVariableStream(r, reactor) .map(it -> String.format("((%s) %s)", it.getType(true), it.getAlias()))) - .collect(Collectors.joining(", ")); - } - - /** Return a stream of all ports referenced by the signature of {@code r}. */ - private static Stream portVariableStream(Reaction r, TypeParameterizedReactor reactorOfReaction) { - return varRefStream(r) - .map(it -> it.getVariable() instanceof TypedVariable tv ? - new PortVariable( - tv, - it.getContainer() != null ? new TypeParameterizedReactor(it.getContainer()) : reactorOfReaction, - it.getContainer()) - : null) - .filter(Objects::nonNull); - } - - /** - * A variable that refers to a port. - * @param tv The variable of the variable reference. - * @param r The reactor in which the port is being used. - * @param container The {@code Instantiation} referenced in the obtaining of {@code tv}, if - * applicable; {@code null} otherwise. - */ - private record PortVariable(TypedVariable tv, TypeParameterizedReactor r, Instantiation container) { - String getType(boolean userFacing) { - var typeName = container == null ? - CGenerator.variableStructType(tv, r, userFacing) - : CPortGenerator.localPortName(container.getReactorClass(), getName()); - var isMultiport = ASTUtils.isMultiport(ASTUtils.allPorts(r.reactor()).stream() - .filter(it -> it.getName().equals(tv.getName())) - .findAny().orElseThrow()); - return typeName + "*" + (getWidth() != null ? "*" : "") + (isMultiport ? "*" : ""); - } - /** The name of the variable as it appears in the LF source. */ - String getName() { - return tv.getName(); - } - /** The alias of the variable that should be used in code generation. */ - String getAlias() { - return getName(); // TODO: avoid naming conflicts - } - /** The width of the container, if applicable. */ - String getWidth() { - return container == null || container.getWidthSpec() == null ? null : "self->_lf_"+r.getName()+"_width"; - } - /** The representation of this port as used by the LF programmer. */ - String getRvalue() { - return container == null ? getName() : container.getName() + "." + getName(); - } - } - - private static Stream inputVarRefStream(Reaction reaction) { - return varRefStream(Stream.concat(reaction.getTriggers().stream(), reaction.getSources().stream())); - } - - private static Stream varRefStream(Stream toFilter) { - return toFilter.map(it -> it instanceof VarRef v ? v : null) - .filter(Objects::nonNull); - } - - private static Stream outputVarRefStream(Reaction reaction) { - return reaction.getEffects().stream(); - } - - private static Stream varRefStream(Reaction reaction) { - return Stream.concat(inputVarRefStream(reaction), outputVarRefStream(reaction)); - } + .collect(Collectors.joining(", ")); + } + + /** Return a stream of all ports referenced by the signature of {@code r}. */ + private static Stream portVariableStream( + Reaction r, TypeParameterizedReactor reactorOfReaction) { + return varRefStream(r) + .map( + it -> + it.getVariable() instanceof TypedVariable tv + ? new PortVariable( + tv, + it.getContainer() != null + ? new TypeParameterizedReactor(it.getContainer()) + : reactorOfReaction, + it.getContainer()) + : null) + .filter(Objects::nonNull); + } + + /** + * A variable that refers to a port. + * + * @param tv The variable of the variable reference. + * @param r The reactor in which the port is being used. + * @param container The {@code Instantiation} referenced in the obtaining of {@code tv}, if + * applicable; {@code null} otherwise. + */ + private record PortVariable( + TypedVariable tv, TypeParameterizedReactor r, Instantiation container) { + String getType(boolean userFacing) { + var typeName = + container == null + ? CGenerator.variableStructType(tv, r, userFacing) + : CPortGenerator.localPortName(container.getReactorClass(), getName()); + var isMultiport = + ASTUtils.isMultiport( + ASTUtils.allPorts(r.reactor()).stream() + .filter(it -> it.getName().equals(tv.getName())) + .findAny() + .orElseThrow()); + return typeName + "*" + (getWidth() != null ? "*" : "") + (isMultiport ? "*" : ""); + } + /** The name of the variable as it appears in the LF source. */ + String getName() { + return tv.getName(); + } + /** The alias of the variable that should be used in code generation. */ + String getAlias() { + return getName(); // TODO: avoid naming conflicts + } + /** The width of the container, if applicable. */ + String getWidth() { + return container == null || container.getWidthSpec() == null + ? null + : "self->_lf_" + r.getName() + "_width"; + } + /** The representation of this port as used by the LF programmer. */ + String getRvalue() { + return container == null ? getName() : container.getName() + "." + getName(); + } + } + + private static Stream inputVarRefStream(Reaction reaction) { + return varRefStream( + Stream.concat(reaction.getTriggers().stream(), reaction.getSources().stream())); + } + + private static Stream varRefStream(Stream toFilter) { + return toFilter.map(it -> it instanceof VarRef v ? v : null).filter(Objects::nonNull); + } + + private static Stream outputVarRefStream(Reaction reaction) { + return reaction.getEffects().stream(); + } + + private static Stream varRefStream(Reaction reaction) { + return Stream.concat(inputVarRefStream(reaction), outputVarRefStream(reaction)); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java index f43d975632..69e41d1008 100644 --- a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CStateGenerator.java @@ -7,121 +7,116 @@ import org.lflang.lf.StateVar; public class CStateGenerator { - /** - * Generate code for state variables of a reactor in the form "stateVar.type stateVar.name;" - * @param reactor {@link TypeParameterizedReactor} - * @param types A helper object for types - */ - public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { - CodeBuilder code = new CodeBuilder(); - for (StateVar stateVar : ASTUtils.allStateVars(reactor.reactor())) { - code.prSourceLineNumber(stateVar); - code.pr(types.getTargetType(reactor.resolveType(ASTUtils.getInferredType(stateVar))) + " " + stateVar.getName() + ";"); - } - return code.toString(); + /** + * Generate code for state variables of a reactor in the form "stateVar.type stateVar.name;" + * + * @param reactor {@link TypeParameterizedReactor} + * @param types A helper object for types + */ + public static String generateDeclarations(TypeParameterizedReactor reactor, CTypes types) { + CodeBuilder code = new CodeBuilder(); + for (StateVar stateVar : ASTUtils.allStateVars(reactor.reactor())) { + code.prSourceLineNumber(stateVar); + code.pr( + types.getTargetType(reactor.resolveType(ASTUtils.getInferredType(stateVar))) + + " " + + stateVar.getName() + + ";"); } + return code.toString(); + } - /** - * If the state is initialized with a parameter, then do not use - * a temporary variable. Otherwise, do, because - * static initializers for arrays and structs have to be handled - * this way, and there is no way to tell whether the type of the array - * is a struct. - * - * @param instance {@link ReactorInstance} - * @param stateVar {@link StateVar} - * @param mode {@link ModeInstance} - * @return String - */ - public static String generateInitializer( - ReactorInstance instance, - String selfRef, - StateVar stateVar, - ModeInstance mode, - CTypes types - ) { - var initExpr = getInitializerExpr(stateVar, instance); - String baseInitializer = generateBaseInitializer(instance.tpr, selfRef, stateVar, initExpr, types); - String modalReset = generateModalReset(instance, selfRef, stateVar, initExpr, mode, types); - return String.join("\n", - baseInitializer, - modalReset - ); - } + /** + * If the state is initialized with a parameter, then do not use a temporary variable. Otherwise, + * do, because static initializers for arrays and structs have to be handled this way, and there + * is no way to tell whether the type of the array is a struct. + * + * @param instance {@link ReactorInstance} + * @param stateVar {@link StateVar} + * @param mode {@link ModeInstance} + * @return String + */ + public static String generateInitializer( + ReactorInstance instance, + String selfRef, + StateVar stateVar, + ModeInstance mode, + CTypes types) { + var initExpr = getInitializerExpr(stateVar, instance); + String baseInitializer = + generateBaseInitializer(instance.tpr, selfRef, stateVar, initExpr, types); + String modalReset = generateModalReset(instance, selfRef, stateVar, initExpr, mode, types); + return String.join("\n", baseInitializer, modalReset); + } - private static String generateBaseInitializer( - TypeParameterizedReactor tpr, - String selfRef, - StateVar stateVar, - String initExpr, - CTypes types - ) { - if (ASTUtils.isOfTimeType(stateVar) || - ASTUtils.isParameterized(stateVar) && - !stateVar.getInit().getExprs().isEmpty() - ) { - return selfRef + "->" + stateVar.getName() + " = " + initExpr + ";"; - } else { - var declaration = types.getVariableDeclaration(tpr, - ASTUtils.getInferredType(stateVar), - "_initial", true); - return String.join("\n", - "{ // For scoping", - " static "+declaration+" = "+initExpr+";", - " "+selfRef+"->"+stateVar.getName()+" = _initial;", - "} // End scoping." - ); - } + private static String generateBaseInitializer( + TypeParameterizedReactor tpr, + String selfRef, + StateVar stateVar, + String initExpr, + CTypes types) { + if (ASTUtils.isOfTimeType(stateVar) + || ASTUtils.isParameterized(stateVar) && !stateVar.getInit().getExprs().isEmpty()) { + return selfRef + "->" + stateVar.getName() + " = " + initExpr + ";"; + } else { + var declaration = + types.getVariableDeclaration(tpr, ASTUtils.getInferredType(stateVar), "_initial", true); + return String.join( + "\n", + "{ // For scoping", + " static " + declaration + " = " + initExpr + ";", + " " + selfRef + "->" + stateVar.getName() + " = _initial;", + "} // End scoping."); } + } - private static String generateModalReset( - ReactorInstance instance, - String selfRef, - StateVar stateVar, - String initExpr, - ModeInstance mode, - CTypes types - ) { - if (mode == null || !stateVar.isReset()) { - return ""; - } - var modeRef = "&"+CUtil.reactorRef(mode.getParent())+"->_lf__modes["+mode.getParent().modes.indexOf(mode)+"]"; - var type = types.getTargetType(instance.tpr.resolveType(ASTUtils.getInferredType(stateVar))); - - if (ASTUtils.isOfTimeType(stateVar) || - ASTUtils.isParameterized(stateVar) && - !stateVar.getInit().getExprs().isEmpty()) { - return CModesGenerator.generateStateResetStructure( - modeRef, selfRef, - stateVar.getName(), - initExpr, type); - } else { - CodeBuilder code = new CodeBuilder(); - var source = "_initial"; - var declaration = types.getVariableDeclaration(instance.tpr, - ASTUtils.getInferredType(stateVar), - source, true); - code.pr("{ // For scoping"); - code.indent(); - code.pr("static "+declaration+" = "+initExpr+";"); - code.pr(CModesGenerator.generateStateResetStructure( - modeRef, selfRef, - stateVar.getName(), - source, type)); - code.unindent(); - code.pr("} // End scoping."); - return code.toString(); - } + private static String generateModalReset( + ReactorInstance instance, + String selfRef, + StateVar stateVar, + String initExpr, + ModeInstance mode, + CTypes types) { + if (mode == null || !stateVar.isReset()) { + return ""; } + var modeRef = + "&" + + CUtil.reactorRef(mode.getParent()) + + "->_lf__modes[" + + mode.getParent().modes.indexOf(mode) + + "]"; + var type = types.getTargetType(instance.tpr.resolveType(ASTUtils.getInferredType(stateVar))); - /** - * Return a C expression that can be used to initialize the specified - * state variable within the specified parent. If the state variable - * initializer refers to parameters of the parent, then those parameter - * references are replaced with accesses to the self struct of the parent. - */ - private static String getInitializerExpr(StateVar state, ReactorInstance parent) { - var ctypes = CTypes.generateParametersIn(parent); - return ctypes.getTargetInitializer(state.getInit(), state.getType()); + if (ASTUtils.isOfTimeType(stateVar) + || ASTUtils.isParameterized(stateVar) && !stateVar.getInit().getExprs().isEmpty()) { + return CModesGenerator.generateStateResetStructure( + modeRef, selfRef, stateVar.getName(), initExpr, type); + } else { + CodeBuilder code = new CodeBuilder(); + var source = "_initial"; + var declaration = + types.getVariableDeclaration( + instance.tpr, ASTUtils.getInferredType(stateVar), source, true); + code.pr("{ // For scoping"); + code.indent(); + code.pr("static " + declaration + " = " + initExpr + ";"); + code.pr( + CModesGenerator.generateStateResetStructure( + modeRef, selfRef, stateVar.getName(), source, type)); + code.unindent(); + code.pr("} // End scoping."); + return code.toString(); } + } + + /** + * Return a C expression that can be used to initialize the specified state variable within the + * specified parent. If the state variable initializer refers to parameters of the parent, then + * those parameter references are replaced with accesses to the self struct of the parent. + */ + private static String getInitializerExpr(StateVar state, ReactorInstance parent) { + var ctypes = CTypes.generateParametersIn(parent); + return ctypes.getTargetInitializer(state.getInit(), state.getType()); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java b/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java index 57e7556dfe..f0c55389f6 100644 --- a/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java @@ -1,7 +1,6 @@ package org.lflang.generator.c; import java.util.List; - import org.lflang.generator.TimerInstance; /** @@ -11,61 +10,71 @@ * @author {Soroush Bateni */ public class CTimerGenerator { - /** - * Generate code to initialize the given timer. - * - * @param timer The timer to initialize for. - */ - public static String generateInitializer(TimerInstance timer) { - var triggerStructName = CUtil.reactorRef(timer.getParent()) + "->_lf__" + timer.getName(); - var offset = CTypes.getInstance().getTargetTimeExpr(timer.getOffset()); - var period = CTypes.getInstance().getTargetTimeExpr(timer.getPeriod()); - var mode = timer.getMode(false); - var modeRef = mode != null ? - "&"+CUtil.reactorRef(mode.getParent())+"->_lf__modes["+mode.getParent().modes.indexOf(mode)+"];" : - "NULL"; + /** + * Generate code to initialize the given timer. + * + * @param timer The timer to initialize for. + */ + public static String generateInitializer(TimerInstance timer) { + var triggerStructName = CUtil.reactorRef(timer.getParent()) + "->_lf__" + timer.getName(); + var offset = CTypes.getInstance().getTargetTimeExpr(timer.getOffset()); + var period = CTypes.getInstance().getTargetTimeExpr(timer.getPeriod()); + var mode = timer.getMode(false); + var modeRef = + mode != null + ? "&" + + CUtil.reactorRef(mode.getParent()) + + "->_lf__modes[" + + mode.getParent().modes.indexOf(mode) + + "];" + : "NULL"; - return String.join("\n", List.of( - "// Initializing timer "+timer.getFullName()+".", - triggerStructName+".offset = "+offset+";", - triggerStructName+".period = "+period+";", - "_lf_timer_triggers[_lf_timer_triggers_count++] = &"+triggerStructName+";", - triggerStructName+".mode = "+modeRef+";" - )); - } + return String.join( + "\n", + List.of( + "// Initializing timer " + timer.getFullName() + ".", + triggerStructName + ".offset = " + offset + ";", + triggerStructName + ".period = " + period + ";", + "_lf_timer_triggers[_lf_timer_triggers_count++] = &" + triggerStructName + ";", + triggerStructName + ".mode = " + modeRef + ";")); + } - /** - * Generate code to declare the timer table. - * - * @param timerCount The total number of timers in the program - */ - public static String generateDeclarations(int timerCount) { - return String.join("\n", List.of( - "// Array of pointers to timer triggers to be scheduled in _lf_initialize_timers().", - (timerCount > 0 ? - "trigger_t* _lf_timer_triggers["+timerCount+"]" : - "trigger_t** _lf_timer_triggers = NULL") + ";", - "int _lf_timer_triggers_size = "+timerCount+";" - )); - } + /** + * Generate code to declare the timer table. + * + * @param timerCount The total number of timers in the program + */ + public static String generateDeclarations(int timerCount) { + return String.join( + "\n", + List.of( + "// Array of pointers to timer triggers to be scheduled in _lf_initialize_timers().", + (timerCount > 0 + ? "trigger_t* _lf_timer_triggers[" + timerCount + "]" + : "trigger_t** _lf_timer_triggers = NULL") + + ";", + "int _lf_timer_triggers_size = " + timerCount + ";")); + } - /** - * Generate code to call {@code _lf_initialize_timer} on each timer. - * - * @param timerCount The total number of timers in the program - */ - public static String generateLfInitializeTimer(int timerCount) { - return String.join("\n", - "void _lf_initialize_timers() {", - timerCount > 0 ? - """ + /** + * Generate code to call {@code _lf_initialize_timer} on each timer. + * + * @param timerCount The total number of timers in the program + */ + public static String generateLfInitializeTimer(int timerCount) { + return String.join( + "\n", + "void _lf_initialize_timers() {", + timerCount > 0 + ? """ for (int i = 0; i < _lf_timer_triggers_size; i++) { if (_lf_timer_triggers[i] != NULL) { _lf_initialize_timer(_lf_timer_triggers[i]); } - }""".indent(4).stripTrailing() : - "", - "}" - ); - } + }""" + .indent(4) + .stripTrailing() + : "", + "}"); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CTracingGenerator.java b/org.lflang/src/org/lflang/generator/c/CTracingGenerator.java index f999d14b3e..8439d562b0 100644 --- a/org.lflang/src/org/lflang/generator/c/CTracingGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTracingGenerator.java @@ -1,13 +1,12 @@ package org.lflang.generator.c; +import static org.lflang.util.StringUtil.addDoubleQuotes; + import java.util.ArrayList; import java.util.List; - -import org.lflang.federated.generator.FederateInstance; import org.lflang.generator.ActionInstance; import org.lflang.generator.ReactorInstance; import org.lflang.generator.TimerInstance; -import static org.lflang.util.StringUtil.addDoubleQuotes; /** * Generates C code to support tracing. @@ -17,47 +16,54 @@ * @author Hou Seng Wong */ public class CTracingGenerator { - /** - * If tracing is turned on, then generate code that records - * the full name of the specified reactor instance in the - * trace table. If tracing is not turned on, do nothing. - * - * If tracing is turned on, record the address of this reaction - * in the _lf_trace_object_descriptions table that is used to generate - * the header information in the trace file. - * - * @param instance The reactor instance. - */ - public static String generateTraceTableEntries( - ReactorInstance instance - ) { - List code = new ArrayList<>(); - var description = CUtil.getShortenedName(instance); - var selfStruct = CUtil.reactorRef(instance); - code.add(registerTraceEvent( - selfStruct, "NULL", - "trace_reactor", description) - ); - for (ActionInstance action : instance.actions) { - code.add(registerTraceEvent( - selfStruct, getTrigger(selfStruct, action.getName()), - "trace_trigger", description + "." + action.getName()) - ); - } - for (TimerInstance timer : instance.timers) { - code.add(registerTraceEvent( - selfStruct, getTrigger(selfStruct, timer.getName()), - "trace_trigger", description + "." + timer.getName()) - ); - } - return String.join("\n", code); + /** + * If tracing is turned on, then generate code that records the full name of the specified reactor + * instance in the trace table. If tracing is not turned on, do nothing. + * + *

    If tracing is turned on, record the address of this reaction in the + * _lf_trace_object_descriptions table that is used to generate the header information in the + * trace file. + * + * @param instance The reactor instance. + */ + public static String generateTraceTableEntries(ReactorInstance instance) { + List code = new ArrayList<>(); + var description = CUtil.getShortenedName(instance); + var selfStruct = CUtil.reactorRef(instance); + code.add(registerTraceEvent(selfStruct, "NULL", "trace_reactor", description)); + for (ActionInstance action : instance.actions) { + code.add( + registerTraceEvent( + selfStruct, + getTrigger(selfStruct, action.getName()), + "trace_trigger", + description + "." + action.getName())); } - - private static String registerTraceEvent(String obj, String trigger, String type, String description) { - return "_lf_register_trace_event("+obj+", "+trigger+", "+type+", "+addDoubleQuotes(description)+");"; + for (TimerInstance timer : instance.timers) { + code.add( + registerTraceEvent( + selfStruct, + getTrigger(selfStruct, timer.getName()), + "trace_trigger", + description + "." + timer.getName())); } + return String.join("\n", code); + } - private static String getTrigger(String obj, String triggerName) { - return "&("+obj+"->_lf__"+triggerName+")"; - } + private static String registerTraceEvent( + String obj, String trigger, String type, String description) { + return "_lf_register_trace_event(" + + obj + + ", " + + trigger + + ", " + + type + + ", " + + addDoubleQuotes(description) + + ");"; + } + + private static String getTrigger(String obj, String triggerName) { + return "&(" + obj + "->_lf__" + triggerName + ")"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java index 99df04e9d3..5f4d8d60ef 100644 --- a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java @@ -1,4 +1,5 @@ package org.lflang.generator.c; + import static org.lflang.generator.c.CMixedRadixGenerator.db; import static org.lflang.generator.c.CMixedRadixGenerator.dc; import static org.lflang.generator.c.CMixedRadixGenerator.dr; @@ -8,15 +9,14 @@ import static org.lflang.util.StringUtil.addDoubleQuotes; import static org.lflang.util.StringUtil.joinObjects; +import com.google.common.collect.Iterables; import java.util.Arrays; import java.util.HashSet; import java.util.stream.Collectors; - -import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.TargetConfig; - import org.lflang.TargetProperty.LogLevel; +import org.lflang.ast.ASTUtils; import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.PortInstance; @@ -25,8 +25,6 @@ import org.lflang.generator.RuntimeRange; import org.lflang.generator.SendRange; -import com.google.common.collect.Iterables; - /** * Generate code for the "_lf_initialize_trigger_objects" function * @@ -35,1027 +33,1088 @@ * @author Hou Seng Wong */ public class CTriggerObjectsGenerator { - /** - * Generate the _lf_initialize_trigger_objects function for 'federate'. - */ - public static String generateInitializeTriggerObjects( - ReactorInstance main, - TargetConfig targetConfig, - CodeBuilder initializeTriggerObjects, - CodeBuilder startTimeStep, - CTypes types, - String lfModuleName, - int startTimeStepIsPresentCount - ) { - var code = new CodeBuilder(); - code.pr("void _lf_initialize_trigger_objects() {"); - code.indent(); - // Initialize the LF clock. - code.pr(String.join("\n", - "// Initialize the _lf_clock", - "lf_initialize_clock();" - )); - - // Initialize tracing if it is enabled - if (targetConfig.tracing != null) { - var traceFileName = lfModuleName; - if (targetConfig.tracing.traceFileName != null) { - traceFileName = targetConfig.tracing.traceFileName; - } - code.pr(String.join("\n", - "// Initialize tracing", - "start_trace("+ addDoubleQuotes(traceFileName + ".lft") + ");" - )); // .lft is for Lingua Franca trace - } + /** Generate the _lf_initialize_trigger_objects function for 'federate'. */ + public static String generateInitializeTriggerObjects( + ReactorInstance main, + TargetConfig targetConfig, + CodeBuilder initializeTriggerObjects, + CodeBuilder startTimeStep, + CTypes types, + String lfModuleName, + int startTimeStepIsPresentCount) { + var code = new CodeBuilder(); + code.pr("void _lf_initialize_trigger_objects() {"); + code.indent(); + // Initialize the LF clock. + code.pr(String.join("\n", "// Initialize the _lf_clock", "lf_initialize_clock();")); + + // Initialize tracing if it is enabled + if (targetConfig.tracing != null) { + var traceFileName = lfModuleName; + if (targetConfig.tracing.traceFileName != null) { + traceFileName = targetConfig.tracing.traceFileName; + } + code.pr( + String.join( + "\n", + "// Initialize tracing", + "start_trace(" + + addDoubleQuotes(traceFileName + ".lft") + + ");")); // .lft is for Lingua Franca trace + } - // Create the table to initialize is_present fields to false between time steps. - if (startTimeStepIsPresentCount > 0) { - // Allocate the initial (before mutations) array of pointers to _is_present fields. - code.pr(String.join("\n", - "// Create the array that will contain pointers to is_present fields to reset on each step.", - "_lf_is_present_fields_size = "+startTimeStepIsPresentCount+";", - "_lf_is_present_fields = (bool**)calloc("+startTimeStepIsPresentCount+", sizeof(bool*));", - "if (_lf_is_present_fields == NULL) lf_print_error_and_exit(" + addDoubleQuotes("Out of memory!") + ");", - "_lf_is_present_fields_abbreviated = (bool**)calloc("+startTimeStepIsPresentCount+", sizeof(bool*));", - "if (_lf_is_present_fields_abbreviated == NULL) lf_print_error_and_exit(" + addDoubleQuotes("Out of memory!") + ");", - "_lf_is_present_fields_abbreviated_size = 0;" - )); - } + // Create the table to initialize is_present fields to false between time steps. + if (startTimeStepIsPresentCount > 0) { + // Allocate the initial (before mutations) array of pointers to _is_present fields. + code.pr( + String.join( + "\n", + "// Create the array that will contain pointers to is_present fields to reset on each" + + " step.", + "_lf_is_present_fields_size = " + startTimeStepIsPresentCount + ";", + "_lf_is_present_fields = (bool**)calloc(" + + startTimeStepIsPresentCount + + ", sizeof(bool*));", + "if (_lf_is_present_fields == NULL) lf_print_error_and_exit(" + + addDoubleQuotes("Out of memory!") + + ");", + "_lf_is_present_fields_abbreviated = (bool**)calloc(" + + startTimeStepIsPresentCount + + ", sizeof(bool*));", + "if (_lf_is_present_fields_abbreviated == NULL) lf_print_error_and_exit(" + + addDoubleQuotes("Out of memory!") + + ");", + "_lf_is_present_fields_abbreviated_size = 0;")); + } - // Create the table to initialize intended tag fields to 0 between time - // steps. - if (startTimeStepIsPresentCount > 0) { - // Allocate the initial (before mutations) array of pointers to - // intended_tag fields. - // There is a 1-1 map between structs containing is_present and - // intended_tag fields, - // thus, we reuse startTimeStepIsPresentCount as the counter. - code.pr(String.join("\n", - CExtensionUtils.surroundWithIfFederatedDecentralized(""" + // Create the table to initialize intended tag fields to 0 between time + // steps. + if (startTimeStepIsPresentCount > 0) { + // Allocate the initial (before mutations) array of pointers to + // intended_tag fields. + // There is a 1-1 map between structs containing is_present and + // intended_tag fields, + // thus, we reuse startTimeStepIsPresentCount as the counter. + code.pr( + String.join( + "\n", + CExtensionUtils.surroundWithIfFederatedDecentralized( + """ // Create the array that will contain pointers to intended_tag fields to reset on each step. _lf_intended_tag_fields_size = %s; _lf_intended_tag_fields = (tag_t**)malloc(_lf_intended_tag_fields_size * sizeof(tag_t*)); - """.formatted(startTimeStepIsPresentCount) - ) - )); - } - + """ + .formatted(startTimeStepIsPresentCount)))); + } - code.pr(initializeTriggerObjects.toString()); - - code.pr(deferredInitialize( - main, - main.reactions, - targetConfig, - types - )); - code.pr(deferredInitializeNonNested( - main, - main, - main.reactions, - types - )); - // Next, for every input port, populate its "self" struct - // fields with pointers to the output port that sends it data. - code.pr(deferredConnectInputsToOutputs( - main - )); - // Put the code here to set up the tables that drive resetting is_present and - // decrementing reference counts between time steps. This code has to appear - // in _lf_initialize_trigger_objects() after the code that makes connections - // between inputs and outputs. - code.pr(startTimeStep.toString()); - code.pr(setReactionPriorities( - main - )); - code.pr(generateSchedulerInitializer( - main, - targetConfig - )); - - code.pr(""" + code.pr(initializeTriggerObjects.toString()); + + code.pr(deferredInitialize(main, main.reactions, targetConfig, types)); + code.pr(deferredInitializeNonNested(main, main, main.reactions, types)); + // Next, for every input port, populate its "self" struct + // fields with pointers to the output port that sends it data. + code.pr(deferredConnectInputsToOutputs(main)); + // Put the code here to set up the tables that drive resetting is_present and + // decrementing reference counts between time steps. This code has to appear + // in _lf_initialize_trigger_objects() after the code that makes connections + // between inputs and outputs. + code.pr(startTimeStep.toString()); + code.pr(setReactionPriorities(main)); + code.pr(generateSchedulerInitializer(main, targetConfig)); + + code.pr( + """ #ifdef EXECUTABLE_PREAMBLE _lf_executable_preamble(); #endif """); - // Initialize triggers for federated execution. - code.pr(CExtensionUtils.surroundWithIfFederated("initialize_triggers_for_federate();")); + // Initialize triggers for federated execution. + code.pr(CExtensionUtils.surroundWithIfFederated("initialize_triggers_for_federate();")); - code.unindent(); - code.pr("}\n"); - return code.toString(); - } + code.unindent(); + code.pr("}\n"); + return code.toString(); + } - /** - * Generate code to initialize the scheduler for the threaded C runtime. - */ - public static String generateSchedulerInitializer( - ReactorInstance main, - TargetConfig targetConfig - ) { - if (!targetConfig.threading) { - return ""; - } - var code = new CodeBuilder(); - var numReactionsPerLevel = main.assignLevels().getNumReactionsPerLevel(); - var numReactionsPerLevelJoined = Arrays.stream(numReactionsPerLevel) - .map(String::valueOf) - .collect(Collectors.joining(", ")); - code.pr(String.join("\n", + /** Generate code to initialize the scheduler for the threaded C runtime. */ + public static String generateSchedulerInitializer( + ReactorInstance main, TargetConfig targetConfig) { + if (!targetConfig.threading) { + return ""; + } + var code = new CodeBuilder(); + var numReactionsPerLevel = main.assignLevels().getNumReactionsPerLevel(); + var numReactionsPerLevelJoined = + Arrays.stream(numReactionsPerLevel).map(String::valueOf).collect(Collectors.joining(", ")); + code.pr( + String.join( + "\n", "// Initialize the scheduler", - "size_t num_reactions_per_level["+numReactionsPerLevel.length+"] = ", + "size_t num_reactions_per_level[" + numReactionsPerLevel.length + "] = ", " {" + numReactionsPerLevelJoined + "};", "sched_params_t sched_params = (sched_params_t) {", " .num_reactions_per_level = &num_reactions_per_level[0],", - " .num_reactions_per_level_size = (size_t) "+numReactionsPerLevel.length+"};", + " .num_reactions_per_level_size = (size_t) " + + numReactionsPerLevel.length + + "};", "lf_sched_init(", " (size_t)_lf_number_of_workers,", " &sched_params", - ");" - )); - return code.toString(); + ");")); + return code.toString(); + } + + /** + * Set the reaction priorities based on dependency analysis. + * + * @param reactor The reactor on which to do this. + */ + private static String setReactionPriorities(ReactorInstance reactor) { + var code = new CodeBuilder(); + setReactionPriorities(reactor, code); + return code.toString(); + } + + /** + * Set the reaction priorities based on dependency analysis. + * + * @param reactor The reactor on which to do this. + * @param builder Where to write the code. + */ + private static boolean setReactionPriorities(ReactorInstance reactor, CodeBuilder builder) { + var foundOne = false; + // Force calculation of levels if it has not been done. + // FIXME: Comment out this as I think it is redundant. + // If it is NOT redundant then deadline propagation is not correct + // reactor.assignLevels(); + + // We handle four different scenarios + // 1) A reactionInstance has 1 level and 1 deadline + // 2) A reactionInstance has 1 level but multiple deadlines + // 3) A reaction instance has multiple levels but all have the same deadline + // 4) Multiple deadlines and levels + + var prolog = new CodeBuilder(); + var epilog = new CodeBuilder(); + + for (ReactionInstance r : reactor.reactions) { + var levelSet = r.getLevels(); + var deadlineSet = r.getInferredDeadlines(); + + if (levelSet.size() > 1 || deadlineSet.size() > 1) { + // Scenario 2-4 + if (prolog.length() == 0) { + prolog.startScopedBlock(); + epilog.endScopedBlock(); + } + } + if (deadlineSet.size() > 1) { + // Scenario (2) or (4) + var deadlines = + r.getInferredDeadlinesList().stream() + .map(elt -> ("0x" + Long.toString(elt.toNanoSeconds(), 16) + "LL")) + .collect(Collectors.toList()); + + prolog.pr( + "interval_t " + + r.uniqueID() + + "_inferred_deadlines[] = { " + + joinObjects(deadlines, ", ") + + " };"); + } + + if (levelSet.size() > 1) { + // Scenario (3) or (4) + // Cannot use the above set of levels because it is a set, not a list. + prolog.pr( + "int " + + r.uniqueID() + + "_levels[] = { " + + joinObjects(r.getLevelsList(), ", ") + + " };"); + } } - /** - * Set the reaction priorities based on dependency analysis. - * - * @param reactor The reactor on which to do this. - */ - private static String setReactionPriorities( - ReactorInstance reactor - ) { - var code = new CodeBuilder(); - setReactionPriorities(reactor, code); - return code.toString(); + var temp = new CodeBuilder(); + temp.pr("// Set reaction priorities for " + reactor); + temp.startScopedBlock(reactor); + for (ReactionInstance r : reactor.reactions) { + // if (currentFederate.contains(r.getDefinition())) { + foundOne = true; + var levelSet = r.getLevels(); + var deadlineSet = r.getInferredDeadlines(); + + // Get the head of the associated lists. To avoid duplication in + // several of the following cases + var level = r.getLevelsList().get(0); + var inferredDeadline = r.getInferredDeadlinesList().get(0); + var runtimeIdx = CUtil.runtimeIndex(r.getParent()); + + if (levelSet.size() == 1 && deadlineSet.size() == 1) { + // Scenario (1) + + var indexValue = inferredDeadline.toNanoSeconds() << 16 | level; + + var reactionIndex = "0x" + Long.toUnsignedString(indexValue, 16) + "LL"; + + temp.pr( + String.join( + "\n", + CUtil.reactionRef(r) + ".chain_id = " + r.chainID + ";", + "// index is the OR of level " + level + " and ", + "// deadline " + inferredDeadline.toNanoSeconds() + " shifted left 16 bits.", + CUtil.reactionRef(r) + ".index = " + reactionIndex + ";")); + } else if (levelSet.size() == 1 && deadlineSet.size() > 1) { + // Scenario 2 + temp.pr( + String.join( + "\n", + CUtil.reactionRef(r) + ".chain_id = " + r.chainID + ";", + "// index is the OR of levels[" + runtimeIdx + "] and ", + "// deadlines[" + runtimeIdx + "] shifted left 16 bits.", + CUtil.reactionRef(r) + + ".index = (" + + r.uniqueID() + + "_inferred_deadlines[" + + runtimeIdx + + "] << 16) | " + + level + + ";")); + + } else if (levelSet.size() > 1 && deadlineSet.size() == 1) { + // Scenarion (3) + temp.pr( + String.join( + "\n", + CUtil.reactionRef(r) + ".chain_id = " + r.chainID + ";", + "// index is the OR of levels[" + runtimeIdx + "] and ", + "// deadlines[" + runtimeIdx + "] shifted left 16 bits.", + CUtil.reactionRef(r) + + ".index = (" + + inferredDeadline.toNanoSeconds() + + " << 16) | " + + r.uniqueID() + + "_levels[" + + runtimeIdx + + "];")); + + } else if (levelSet.size() > 1 && deadlineSet.size() > 1) { + // Scenario (4) + temp.pr( + String.join( + "\n", + CUtil.reactionRef(r) + ".chain_id = " + r.chainID + ";", + "// index is the OR of levels[" + runtimeIdx + "] and ", + "// deadlines[" + runtimeIdx + "] shifted left 16 bits.", + CUtil.reactionRef(r) + + ".index = (" + + r.uniqueID() + + "_inferred_deadlines[" + + runtimeIdx + + "] << 16) | " + + r.uniqueID() + + "_levels[" + + runtimeIdx + + "];")); + } } - - /** - * Set the reaction priorities based on dependency analysis. - * - * @param reactor The reactor on which to do this. - * @param builder Where to write the code. - */ - private static boolean setReactionPriorities( - ReactorInstance reactor, - CodeBuilder builder - ) { - var foundOne = false; - // Force calculation of levels if it has not been done. - // FIXME: Comment out this as I think it is redundant. - // If it is NOT redundant then deadline propagation is not correct - // reactor.assignLevels(); - - // We handle four different scenarios - // 1) A reactionInstance has 1 level and 1 deadline - // 2) A reactionInstance has 1 level but multiple deadlines - // 3) A reaction instance has multiple levels but all have the same deadline - // 4) Multiple deadlines and levels - - var prolog = new CodeBuilder(); - var epilog = new CodeBuilder(); - - for (ReactionInstance r : reactor.reactions) { - var levelSet = r.getLevels(); - var deadlineSet = r.getInferredDeadlines(); - - if (levelSet.size() > 1 || deadlineSet.size() > 1) { - // Scenario 2-4 - if (prolog.length() == 0) { - prolog.startScopedBlock(); - epilog.endScopedBlock(); - } - } - if (deadlineSet.size() > 1) { - // Scenario (2) or (4) - var deadlines = r.getInferredDeadlinesList().stream() - .map(elt -> ("0x" + Long.toString(elt.toNanoSeconds(), 16) + "LL")) - .collect(Collectors.toList()); - - prolog.pr("interval_t "+r.uniqueID()+"_inferred_deadlines[] = { "+joinObjects(deadlines, ", ")+" };"); - } - - if (levelSet.size() > 1) { - // Scenario (3) or (4) - // Cannot use the above set of levels because it is a set, not a list. - prolog.pr("int "+r.uniqueID()+"_levels[] = { "+joinObjects(r.getLevelsList(), ", ")+" };"); - } - } - - - var temp = new CodeBuilder(); - temp.pr("// Set reaction priorities for " + reactor); - temp.startScopedBlock(reactor); - for (ReactionInstance r : reactor.reactions) { - //if (currentFederate.contains(r.getDefinition())) { - foundOne = true; - var levelSet = r.getLevels(); - var deadlineSet = r.getInferredDeadlines(); - - // Get the head of the associated lists. To avoid duplication in - // several of the following cases - var level = r.getLevelsList().get(0); - var inferredDeadline = r.getInferredDeadlinesList().get(0); - var runtimeIdx =CUtil.runtimeIndex(r.getParent()); - - if (levelSet.size() == 1 && deadlineSet.size() == 1) { - // Scenario (1) - - var indexValue = inferredDeadline.toNanoSeconds() << 16 | level; - - var reactionIndex = "0x" + Long.toUnsignedString(indexValue, 16) + "LL"; - - temp.pr(String.join("\n", - CUtil.reactionRef(r)+".chain_id = "+r.chainID+";", - "// index is the OR of level "+level+" and ", - "// deadline "+ inferredDeadline.toNanoSeconds()+" shifted left 16 bits.", - CUtil.reactionRef(r)+".index = "+reactionIndex+";" - )); - } else if (levelSet.size() == 1 && deadlineSet.size() > 1) { - // Scenario 2 - temp.pr(String.join("\n", - CUtil.reactionRef(r)+".chain_id = "+r.chainID+";", - "// index is the OR of levels["+runtimeIdx+"] and ", - "// deadlines["+runtimeIdx+"] shifted left 16 bits.", - CUtil.reactionRef(r)+".index = ("+r.uniqueID()+"_inferred_deadlines["+runtimeIdx+"] << 16) | " + - level+";" - )); - - } else if (levelSet.size() > 1 && deadlineSet.size() == 1) { - // Scenarion (3) - temp.pr(String.join("\n", - CUtil.reactionRef(r)+".chain_id = "+r.chainID+";", - "// index is the OR of levels["+runtimeIdx+"] and ", - "// deadlines["+runtimeIdx+"] shifted left 16 bits.", - CUtil.reactionRef(r)+".index = ("+inferredDeadline.toNanoSeconds()+" << 16) | " + - r.uniqueID()+"_levels["+runtimeIdx+"];" - )); - - } else if (levelSet.size() > 1 && deadlineSet.size() > 1) { - // Scenario (4) - temp.pr(String.join("\n", - CUtil.reactionRef(r)+".chain_id = "+r.chainID+";", - "// index is the OR of levels["+runtimeIdx+"] and ", - "// deadlines["+runtimeIdx+"] shifted left 16 bits.", - CUtil.reactionRef(r)+".index = ("+r.uniqueID()+"_inferred_deadlines["+runtimeIdx+"] << 16) | " + - r.uniqueID()+"_levels["+runtimeIdx+"];" - )); - } - - } - for (ReactorInstance child : reactor.children) { - foundOne = setReactionPriorities(child, temp) || foundOne; - } - temp.endScopedBlock(); - - if (foundOne) { - builder.pr(prolog.toString()); - builder.pr(temp.toString()); - builder.pr(epilog.toString()); - } - return foundOne; + for (ReactorInstance child : reactor.children) { + foundOne = setReactionPriorities(child, temp) || foundOne; } + temp.endScopedBlock(); - /** - * Generate assignments of pointers in the "self" struct of a destination - * port's reactor to the appropriate entries in the "self" struct of the - * source reactor. This has to be done after all reactors have been created - * because inputs point to outputs that are arbitrarily far away. - * @param instance The reactor instance. - */ - private static String deferredConnectInputsToOutputs( - ReactorInstance instance - ) { - var code = new CodeBuilder(); - code.pr("// Connect inputs and outputs for reactor "+instance.getFullName()+"."); - // Iterate over all ports of this reactor that depend on reactions. - for (PortInstance input : instance.inputs) { - if (!input.getDependsOnReactions().isEmpty()) { - // Input is written to by reactions in the parent of the port's parent. - code.pr(connectPortToEventualDestinations(input)); - } - } - for (PortInstance output : instance.outputs) { - if (!output.getDependsOnReactions().isEmpty()) { - // Output is written to by reactions in the port's parent. - code.pr(connectPortToEventualDestinations(output)); - } - } - for (ReactorInstance child: instance.children) { - code.pr(deferredConnectInputsToOutputs(child)); - } - return code.toString(); + if (foundOne) { + builder.pr(prolog.toString()); + builder.pr(temp.toString()); + builder.pr(epilog.toString()); } - - /** - * Generate assignments of pointers in the "self" struct of a destination - * port's reactor to the appropriate entries in the "self" struct of the - * source reactor. If this port is an input, then it is being written - * to by a reaction belonging to the parent of the port's parent. - * If it is an output, then it is being written to by a reaction belonging - * to the port's parent. - * @param src A port that is written to by reactions. - */ - private static String connectPortToEventualDestinations( - PortInstance src - ) { - var code = new CodeBuilder(); - for (SendRange srcRange: src.eventualDestinations()) { - for (RuntimeRange dstRange : srcRange.destinations) { - var dst = dstRange.instance; - var destStructType = CGenerator.variableStructType(dst); - - // NOTE: For federated execution, dst.getParent() should always be contained - // by the currentFederate because an AST transformation removes connections - // between ports of distinct federates. So the following check is not - // really necessary. - var mod = (dst.isMultiport() || (src.isInput() && src.isMultiport()))? "" : "&"; - code.pr("// Connect "+srcRange+" to port "+dstRange); - code.startScopedRangeBlock(srcRange, dstRange); - if (src.isInput()) { - // Source port is written to by reaction in port's parent's parent - // and ultimate destination is further downstream. - code.pr(CUtil.portRef(dst, dr, db, dc)+" = ("+destStructType+"*)"+mod+CUtil.portRefNested(src, sr, sb, sc)+";"); - } else if (dst.isOutput()) { - // An output port of a contained reactor is triggering a reaction. - code.pr(CUtil.portRefNested(dst, dr, db, dc)+" = ("+destStructType+"*)&"+CUtil.portRef(src, sr, sb, sc)+";"); - } else { - // An output port is triggering an input port. - code.pr(CUtil.portRef(dst, dr, db, dc)+" = ("+destStructType+"*)&"+CUtil.portRef(src, sr, sb, sc)+";"); - if (AttributeUtils.isSparse(dst.getDefinition())) { - code.pr(CUtil.portRef(dst, dr, db, dc)+"->sparse_record = "+CUtil.portRefName(dst, dr, db, dc)+"__sparse;"); - code.pr(CUtil.portRef(dst, dr, db, dc)+"->destination_channel = "+dc+";"); - } - } - code.endScopedRangeBlock(srcRange, dstRange); - } - } - return code.toString(); + return foundOne; + } + + /** + * Generate assignments of pointers in the "self" struct of a destination port's reactor to the + * appropriate entries in the "self" struct of the source reactor. This has to be done after all + * reactors have been created because inputs point to outputs that are arbitrarily far away. + * + * @param instance The reactor instance. + */ + private static String deferredConnectInputsToOutputs(ReactorInstance instance) { + var code = new CodeBuilder(); + code.pr("// Connect inputs and outputs for reactor " + instance.getFullName() + "."); + // Iterate over all ports of this reactor that depend on reactions. + for (PortInstance input : instance.inputs) { + if (!input.getDependsOnReactions().isEmpty()) { + // Input is written to by reactions in the parent of the port's parent. + code.pr(connectPortToEventualDestinations(input)); + } } - - /** - * For each reaction of the specified reactor, - * set the last_enabling_reaction field of the reaction struct to point - * to the single dominating upstream reaction if there is one, or to be - * NULL if there is none. - * - * @param r The reactor. - */ - private static String deferredOptimizeForSingleDominatingReaction( - ReactorInstance r - ) { - var code = new CodeBuilder(); - for (ReactionInstance reaction : r.reactions) { - // The following code attempts to gather into a loop assignments of successive - // bank members relations between reactions to avoid large chunks of inline code - // when a large bank sends to a large bank or when a large bank receives from - // one reaction that is either multicasting or sending through a multiport. - var start = 0; - var end = 0; - var domStart = 0; - var same = false; // Set to true when finding a string of identical dominating reactions. - ReactionInstance.Runtime previousRuntime = null; - var first = true; //First time through the loop. - for (ReactionInstance.Runtime runtime : reaction.getRuntimeInstances()) { - if (!first) { // Not the first time through the loop. - if (same) { // Previously seen at least two identical dominating. - if (runtime.dominating != previousRuntime.dominating) { - // End of streak of same dominating reaction runtime instance. - code.pr(printOptimizeForSingleDominatingReaction( - previousRuntime, start, end, domStart, same - )); - same = false; - start = runtime.id; - domStart = (runtime.dominating != null) ? runtime.dominating.id : 0; - } - } else if (runtime.dominating == previousRuntime.dominating) { - // Start of a streak of identical dominating reaction runtime instances. - same = true; - } else if (runtime.dominating != null && previousRuntime.dominating != null - && runtime.dominating.getReaction() == previousRuntime.dominating.getReaction() - ) { - // Same dominating reaction even if not the same dominating runtime. - if (runtime.dominating.id != previousRuntime.dominating.id + 1) { - // End of a streak of contiguous runtimes. - printOptimizeForSingleDominatingReaction( - previousRuntime, start, end, domStart, same - ); - same = false; - start = runtime.id; - domStart = runtime.dominating.id; - } - } else { - // Different dominating reaction. - printOptimizeForSingleDominatingReaction( - previousRuntime, start, end, domStart, same - ); - same = false; - start = runtime.id; - domStart = (runtime.dominating != null) ? runtime.dominating.id : 0; - } - } - first = false; - previousRuntime = runtime; - end++; - } - if (end > start) { - printOptimizeForSingleDominatingReaction( - previousRuntime, start, end, domStart, same - ); - } - } - return code.toString(); + for (PortInstance output : instance.outputs) { + if (!output.getDependsOnReactions().isEmpty()) { + // Output is written to by reactions in the port's parent. + code.pr(connectPortToEventualDestinations(output)); + } } - - /** - * Print statement that sets the last_enabling_reaction field of a reaction. - */ - private static String printOptimizeForSingleDominatingReaction( - ReactionInstance.Runtime runtime, - int start, - int end, - int domStart, - boolean same - ) { - var code = new CodeBuilder(); - var dominatingRef = "NULL"; - - if (end > start + 1) { - code.startScopedBlock(); - var reactionRef = CUtil.reactionRef(runtime.getReaction(), "i"); - if (runtime.dominating != null) { - if (same) { - dominatingRef = "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "" + domStart) + ")"; - } else { - dominatingRef = "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "j++") + ")"; - } - } - code.pr(String.join("\n", - "// "+runtime.getReaction().getFullName()+" dominating upstream reaction.", - "int j = "+domStart+";", - "for (int i = "+start+"; i < "+end+"; i++) {", - " "+reactionRef+".last_enabling_reaction = "+dominatingRef+";", - "}" - )); - code.endScopedBlock(); - } else if (end == start + 1) { - var reactionRef = CUtil.reactionRef(runtime.getReaction(), "" + start); - if (runtime.dominating != null) { - dominatingRef = "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "" + domStart) + ")"; - } - code.pr(String.join("\n", - "// "+runtime.getReaction().getFullName()+" dominating upstream reaction.", - reactionRef+".last_enabling_reaction = "+dominatingRef+";" - )); - } - return code.toString(); + for (ReactorInstance child : instance.children) { + code.pr(deferredConnectInputsToOutputs(child)); } - - /** - * For the specified reaction, for ports that it writes to, - * fill the trigger table for triggering downstream reactions. - * - * @param reactions The reactions. - */ - private static String deferredFillTriggerTable( - Iterable reactions - ) { - var code = new CodeBuilder(); - for (ReactionInstance reaction : reactions) { - var name = reaction.getParent().getFullName(); - - var reactorSelfStruct = CUtil.reactorRef(reaction.getParent(), sr); - - var foundPort = false; - - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (!foundPort) { - // Need a separate index for the triggers array for each bank member. - code.startScopedBlock(); - code.pr("int triggers_index["+reaction.getParent().getTotalWidth()+"] = { 0 }; // Number of bank members with the reaction."); - foundPort = true; - } - // If the port is a multiport, then its channels may have different sets - // of destinations. For ordinary ports, there will be only one range and - // its width will be 1. - // We generate the code to fill the triggers array first in a temporary code buffer, - // so that we can simultaneously calculate the size of the total array. - for (SendRange srcRange : port.eventualDestinations()) { - var srcNested = port.isInput(); - code.startScopedRangeBlock(srcRange, sr, sb, sc, srcNested); - - var triggerArray = CUtil.reactionRef(reaction, sr)+".triggers[triggers_index["+sr+"]++]"; - // Skip ports whose parent is not in the federation. - // This can happen with reactions in the top-level that have - // as an effect a port in a bank. - code.pr(String.join("\n", - "// Reaction "+reaction.index+" of "+name+" triggers "+srcRange.destinations.size()+" downstream reactions", - "// through port "+port.getFullName()+".", - CUtil.reactionRef(reaction, sr)+".triggered_sizes[triggers_index["+sr+"]] = "+srcRange.destinations.size()+";", - "// For reaction "+reaction.index+" of "+name+", allocate an", - "// array of trigger pointers for downstream reactions through port "+port.getFullName(), - "trigger_t** trigger_array = (trigger_t**)_lf_allocate(", - " "+srcRange.destinations.size()+", sizeof(trigger_t*),", - " &"+reactorSelfStruct+"->base.allocations); ", - triggerArray+" = trigger_array;" - )); - code.endScopedRangeBlock(srcRange); - } - } - var cumulativePortWidth = 0; - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - // If this port does not have any destinations, do not generate code for it. - if (port.eventualDestinations().isEmpty()) continue; - - code.pr("for (int i = 0; i < "+reaction.getParent().getTotalWidth()+"; i++) triggers_index[i] = "+cumulativePortWidth+";"); - for (SendRange srcRange : port.eventualDestinations()) { - var srcNested = srcRange.instance.isInput(); - var multicastCount = 0; - for (RuntimeRange dstRange : srcRange.destinations) { - var dst = dstRange.instance; - - code.startScopedRangeBlock(srcRange, dstRange); - - // If the source is nested, need to take into account the parent's bank index - // when indexing into the triggers array. - var triggerArray = ""; - if (srcNested && port.getParent().getWidth() > 1) { - triggerArray = CUtil.reactionRef(reaction, sr)+".triggers[triggers_index["+sr+"] + "+sc+" + src_range_mr.digits[1] * src_range_mr.radixes[0]]"; - } else { - triggerArray = CUtil.reactionRef(reaction, sr)+".triggers[triggers_index["+sr+"] + "+sc+"]"; - } - - if (dst.isOutput()) { - // Include this destination port only if it has at least one - // reaction in the federation. - var belongs = false; - for (ReactionInstance destinationReaction : dst.getDependentReactions()) { - belongs = true; - } - if (belongs) { - code.pr(String.join("\n", - "// Port "+port.getFullName()+" has reactions in its parent's parent.", - "// Point to the trigger struct for those reactions.", - triggerArray+"["+multicastCount+"] = &"+CUtil.triggerRefNested(dst, dr, db)+";" - )); - } else { - // Put in a NULL pointer. - code.pr(String.join("\n", - "// Port "+port.getFullName()+" has reactions in its parent's parent.", - "// But those are not in the federation.", - triggerArray+"["+multicastCount+"] = NULL;" - )); - } - } else { - // Destination is an input port. - code.pr(String.join("\n", - "// Point to destination port "+dst.getFullName()+"'s trigger struct.", - triggerArray+"["+multicastCount+"] = &"+CUtil.triggerRef(dst, dr)+";" - )); - } - code.endScopedRangeBlock(srcRange, dstRange); - multicastCount++; - } - } - // If the port is an input of a contained reactor, then we have to take - // into account the bank width of the contained reactor. - if (port.getParent() != reaction.getParent()) { - cumulativePortWidth += port.getWidth() * port.getParent().getWidth(); - } else { - cumulativePortWidth += port.getWidth(); - } - } - if (foundPort) code.endScopedBlock(); + return code.toString(); + } + + /** + * Generate assignments of pointers in the "self" struct of a destination port's reactor to the + * appropriate entries in the "self" struct of the source reactor. If this port is an input, then + * it is being written to by a reaction belonging to the parent of the port's parent. If it is an + * output, then it is being written to by a reaction belonging to the port's parent. + * + * @param src A port that is written to by reactions. + */ + private static String connectPortToEventualDestinations(PortInstance src) { + var code = new CodeBuilder(); + for (SendRange srcRange : src.eventualDestinations()) { + for (RuntimeRange dstRange : srcRange.destinations) { + var dst = dstRange.instance; + var destStructType = CGenerator.variableStructType(dst); + + // NOTE: For federated execution, dst.getParent() should always be contained + // by the currentFederate because an AST transformation removes connections + // between ports of distinct federates. So the following check is not + // really necessary. + var mod = (dst.isMultiport() || (src.isInput() && src.isMultiport())) ? "" : "&"; + code.pr("// Connect " + srcRange + " to port " + dstRange); + code.startScopedRangeBlock(srcRange, dstRange); + if (src.isInput()) { + // Source port is written to by reaction in port's parent's parent + // and ultimate destination is further downstream. + code.pr( + CUtil.portRef(dst, dr, db, dc) + + " = (" + + destStructType + + "*)" + + mod + + CUtil.portRefNested(src, sr, sb, sc) + + ";"); + } else if (dst.isOutput()) { + // An output port of a contained reactor is triggering a reaction. + code.pr( + CUtil.portRefNested(dst, dr, db, dc) + + " = (" + + destStructType + + "*)&" + + CUtil.portRef(src, sr, sb, sc) + + ";"); + } else { + // An output port is triggering an input port. + code.pr( + CUtil.portRef(dst, dr, db, dc) + + " = (" + + destStructType + + "*)&" + + CUtil.portRef(src, sr, sb, sc) + + ";"); + if (AttributeUtils.isSparse(dst.getDefinition())) { + code.pr( + CUtil.portRef(dst, dr, db, dc) + + "->sparse_record = " + + CUtil.portRefName(dst, dr, db, dc) + + "__sparse;"); + code.pr(CUtil.portRef(dst, dr, db, dc) + "->destination_channel = " + dc + ";"); + } } - return code.toString(); + code.endScopedRangeBlock(srcRange, dstRange); + } } - - /** - * For each input port of a contained reactor that receives data - * from one or more of the specified reactions, set the num_destinations - * field of the corresponding port structs on the self struct of - * the reaction's parent reactor equal to the total number of - * destination reactors. - * If the port has a token type, this also initializes it with a token. - * @param reactions The reactions. - * @param types The C types. - */ - private static String deferredInputNumDestinations( - Iterable reactions, - CTypes types - ) { - // We need the number of destination _reactors_, not the - // number of destination ports nor the number of destination reactions. - // One of the destination reactors may be the container of this - // instance because it may have a reaction to an output of this instance. - // Since a port may be written to by multiple reactions, - // ensure that this is done only once. - var portsHandled = new HashSet(); - var code = new CodeBuilder(); - for (ReactionInstance reaction : reactions) { - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (port.isInput() && !portsHandled.contains(port)) { - // Port is an input of a contained reactor that gets data from a reaction of this reactor. - portsHandled.add(port); - code.pr("// Set number of destination reactors for port "+port.getParent().getName()+"."+port.getName()+"."); - // The input port may itself have multiple destinations. - for (SendRange sendingRange : port.eventualDestinations()) { - code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); - // Syntax is slightly different for a multiport output vs. single port. - var connector = (port.isMultiport())? "->" : "."; - code.pr(CUtil.portRefNested(port, sr, sb, sc)+connector+"num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); - - // Initialize token types. - var type = ASTUtils.getInferredType(port.getDefinition()); - if (CUtil.isTokenType(type, types)) { - // Create the template token that goes in the port struct. - var rootType = CUtil.rootType(types.getTargetType(type)); - // If the rootType is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var size = (rootType.equals("void")) ? "0" : "sizeof("+rootType+")"; - // If the port is a multiport, then the portRefNested is itself a pointer - // so we want its value, not its address. - var indirection = (port.isMultiport())? "" : "&"; - code.startChannelIteration(port); - code.pr(String.join("\n", - "_lf_initialize_template((token_template_t*)", - " "+indirection+"("+CUtil.portRefNested(port, sr, sb, sc)+"),", - size+");" - )); - code.endChannelIteration(port); - } - - code.endScopedRangeBlock(sendingRange); - } - } + return code.toString(); + } + + /** + * For each reaction of the specified reactor, set the last_enabling_reaction field of the + * reaction struct to point to the single dominating upstream reaction if there is one, or to be + * NULL if there is none. + * + * @param r The reactor. + */ + private static String deferredOptimizeForSingleDominatingReaction(ReactorInstance r) { + var code = new CodeBuilder(); + for (ReactionInstance reaction : r.reactions) { + // The following code attempts to gather into a loop assignments of successive + // bank members relations between reactions to avoid large chunks of inline code + // when a large bank sends to a large bank or when a large bank receives from + // one reaction that is either multicasting or sending through a multiport. + var start = 0; + var end = 0; + var domStart = 0; + var same = false; // Set to true when finding a string of identical dominating reactions. + ReactionInstance.Runtime previousRuntime = null; + var first = true; // First time through the loop. + for (ReactionInstance.Runtime runtime : reaction.getRuntimeInstances()) { + if (!first) { // Not the first time through the loop. + if (same) { // Previously seen at least two identical dominating. + if (runtime.dominating != previousRuntime.dominating) { + // End of streak of same dominating reaction runtime instance. + code.pr( + printOptimizeForSingleDominatingReaction( + previousRuntime, start, end, domStart, same)); + same = false; + start = runtime.id; + domStart = (runtime.dominating != null) ? runtime.dominating.id : 0; } - } - return code.toString(); - } - - /** - * For each output port of the specified reactor, - * set the num_destinations field of port structs on its self struct - * equal to the total number of destination reactors. This is used - * to initialize reference counts in dynamically allocated tokens - * sent to other reactors. - * @param reactor The reactor instance. - */ - private static String deferredOutputNumDestinations( - ReactorInstance reactor - ) { - // Reference counts are decremented by each destination reactor - // at the conclusion of a time step. Hence, the initial reference - // count should equal the number of destination _reactors_, not the - // number of destination ports nor the number of destination reactions. - // One of the destination reactors may be the container of this - // instance because it may have a reaction to an output of this instance. - var code = new CodeBuilder(); - for (PortInstance output : reactor.outputs) { - for (SendRange sendingRange : output.eventualDestinations()) { - code.pr("// For reference counting, set num_destinations for port " + output.getFullName() + "."); - code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); - code.pr(CUtil.portRef(output, sr, sb, sc)+".num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); - code.endScopedRangeBlock(sendingRange); + } else if (runtime.dominating == previousRuntime.dominating) { + // Start of a streak of identical dominating reaction runtime instances. + same = true; + } else if (runtime.dominating != null + && previousRuntime.dominating != null + && runtime.dominating.getReaction() == previousRuntime.dominating.getReaction()) { + // Same dominating reaction even if not the same dominating runtime. + if (runtime.dominating.id != previousRuntime.dominating.id + 1) { + // End of a streak of contiguous runtimes. + printOptimizeForSingleDominatingReaction(previousRuntime, start, end, domStart, same); + same = false; + start = runtime.id; + domStart = runtime.dominating.id; } + } else { + // Different dominating reaction. + printOptimizeForSingleDominatingReaction(previousRuntime, start, end, domStart, same); + same = false; + start = runtime.id; + domStart = (runtime.dominating != null) ? runtime.dominating.id : 0; + } } - return code.toString(); + first = false; + previousRuntime = runtime; + end++; + } + if (end > start) { + printOptimizeForSingleDominatingReaction(previousRuntime, start, end, domStart, same); + } } - - /** - * Perform initialization functions that must be performed after - * all reactor runtime instances have been created. - * This function does not create nested loops over nested banks, - * so each function it calls must handle its own iteration - * over all runtime instance. - * @param reactor The container. - * @param main The top-level reactor. - * @param reactions The list of reactions to consider. - * @param types The C types. - */ - private static String deferredInitializeNonNested( - ReactorInstance reactor, - ReactorInstance main, - Iterable reactions, - CTypes types - ) { - var code = new CodeBuilder(); - code.pr("// **** Start non-nested deferred initialize for "+reactor.getFullName()); - // Initialize the num_destinations fields of port structs on the self struct. - // This needs to be outside the above scoped block because it performs - // its own iteration over ranges. - code.pr(deferredInputNumDestinations( - reactions, - types - )); - - // Second batch of initializes cannot be within a for loop - // iterating over bank members because they iterate over send - // ranges which may span bank members. - if (reactor != main) { - code.pr(deferredOutputNumDestinations( - reactor - )); - } - code.pr(deferredFillTriggerTable( - reactions - )); - code.pr(deferredOptimizeForSingleDominatingReaction( - reactor - )); - for (ReactorInstance child: reactor.children) { - code.pr(deferredInitializeNonNested( - child, - main, - child.reactions, - types - )); + return code.toString(); + } + + /** Print statement that sets the last_enabling_reaction field of a reaction. */ + private static String printOptimizeForSingleDominatingReaction( + ReactionInstance.Runtime runtime, int start, int end, int domStart, boolean same) { + var code = new CodeBuilder(); + var dominatingRef = "NULL"; + + if (end > start + 1) { + code.startScopedBlock(); + var reactionRef = CUtil.reactionRef(runtime.getReaction(), "i"); + if (runtime.dominating != null) { + if (same) { + dominatingRef = + "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "" + domStart) + ")"; + } else { + dominatingRef = "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "j++") + ")"; } - code.pr("// **** End of non-nested deferred initialize for "+reactor.getFullName()); - return code.toString(); + } + code.pr( + String.join( + "\n", + "// " + runtime.getReaction().getFullName() + " dominating upstream reaction.", + "int j = " + domStart + ";", + "for (int i = " + start + "; i < " + end + "; i++) {", + " " + reactionRef + ".last_enabling_reaction = " + dominatingRef + ";", + "}")); + code.endScopedBlock(); + } else if (end == start + 1) { + var reactionRef = CUtil.reactionRef(runtime.getReaction(), "" + start); + if (runtime.dominating != null) { + dominatingRef = + "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "" + domStart) + ")"; + } + code.pr( + String.join( + "\n", + "// " + runtime.getReaction().getFullName() + " dominating upstream reaction.", + reactionRef + ".last_enabling_reaction = " + dominatingRef + ";")); } - - /** - * For each output of the specified reactor that has a token type - * (type* or type[]), create a template token and put it on the self struct. - * @param reactor The reactor. - */ - private static String deferredCreateTemplateTokens( - ReactorInstance reactor, - CTypes types - ) { - var code = new CodeBuilder(); - // Look for outputs with token types. - for (PortInstance output : reactor.outputs) { - var type = ASTUtils.getInferredType(output.getDefinition()); - if (CUtil.isTokenType(type, types)) { - // Create the template token that goes in the trigger struct. - // Its reference count is zero, enabling it to be used immediately. - var rootType = CUtil.rootType(types.getTargetType(type)); - // If the rootType is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var size = (rootType.equals("void")) ? "0" : "sizeof("+rootType+")"; - code.startChannelIteration(output); - code.pr(String.join("\n", - "_lf_initialize_template((token_template_t*)", - " &("+CUtil.portRef(output)+"),", - size+");" - )); - code.endChannelIteration(output); - } + return code.toString(); + } + + /** + * For the specified reaction, for ports that it writes to, fill the trigger table for triggering + * downstream reactions. + * + * @param reactions The reactions. + */ + private static String deferredFillTriggerTable(Iterable reactions) { + var code = new CodeBuilder(); + for (ReactionInstance reaction : reactions) { + var name = reaction.getParent().getFullName(); + + var reactorSelfStruct = CUtil.reactorRef(reaction.getParent(), sr); + + var foundPort = false; + + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (!foundPort) { + // Need a separate index for the triggers array for each bank member. + code.startScopedBlock(); + code.pr( + "int triggers_index[" + + reaction.getParent().getTotalWidth() + + "] = { 0 }; // Number of bank members with the reaction."); + foundPort = true; } - return code.toString(); - } - - /** - * For the specified reaction, for ports that it writes to, - * set up the arrays that store the results (if necessary) and - * that are used to trigger downstream reactions if an effect is actually - * produced. The port may be an output of the reaction's parent - * or an input to a reactor contained by the parent. - * - * @param reaction The reaction instance. - */ - private static String deferredReactionOutputs( - ReactionInstance reaction, - TargetConfig targetConfig - ) { - var code = new CodeBuilder(); - // val selfRef = CUtil.reactorRef(reaction.getParent()); - var name = reaction.getParent().getFullName(); - // Insert a string name to facilitate debugging. - if (targetConfig.logLevel.compareTo(LogLevel.LOG) >= 0) { - code.pr(CUtil.reactionRef(reaction)+".name = "+addDoubleQuotes(name+" reaction "+reaction.index)+";"); + // If the port is a multiport, then its channels may have different sets + // of destinations. For ordinary ports, there will be only one range and + // its width will be 1. + // We generate the code to fill the triggers array first in a temporary code buffer, + // so that we can simultaneously calculate the size of the total array. + for (SendRange srcRange : port.eventualDestinations()) { + var srcNested = port.isInput(); + code.startScopedRangeBlock(srcRange, sr, sb, sc, srcNested); + + var triggerArray = + CUtil.reactionRef(reaction, sr) + ".triggers[triggers_index[" + sr + "]++]"; + // Skip ports whose parent is not in the federation. + // This can happen with reactions in the top-level that have + // as an effect a port in a bank. + code.pr( + String.join( + "\n", + "// Reaction " + + reaction.index + + " of " + + name + + " triggers " + + srcRange.destinations.size() + + " downstream reactions", + "// through port " + port.getFullName() + ".", + CUtil.reactionRef(reaction, sr) + + ".triggered_sizes[triggers_index[" + + sr + + "]] = " + + srcRange.destinations.size() + + ";", + "// For reaction " + reaction.index + " of " + name + ", allocate an", + "// array of trigger pointers for downstream reactions through port " + + port.getFullName(), + "trigger_t** trigger_array = (trigger_t**)_lf_allocate(", + " " + srcRange.destinations.size() + ", sizeof(trigger_t*),", + " &" + reactorSelfStruct + "->base.allocations); ", + triggerArray + " = trigger_array;")); + code.endScopedRangeBlock(srcRange); } - - var reactorSelfStruct = CUtil.reactorRef(reaction.getParent()); - - // Count the output ports and inputs of contained reactors that - // may be set by this reaction. This ignores actions in the effects. - // Collect initialization statements for the output_produced array for the reaction - // to point to the is_present field of the appropriate output. - // These statements must be inserted after the array is malloc'd, - // but we construct them while we are counting outputs. - var outputCount = 0; - var init = new CodeBuilder(); - - init.startScopedBlock(); - init.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - for (PortInstance effect : Iterables.filter(reaction.effects, PortInstance.class)) { - // Create the entry in the output_produced array for this port. - // If the port is a multiport, then we need to create an entry for each - // individual channel. - - // If the port is an input of a contained reactor, then, if that - // contained reactor is a bank, we will have to iterate over bank - // members. - var bankWidth = 1; - var portRef = ""; - if (effect.isInput()) { - init.pr("// Reaction writes to an input of a contained reactor."); - bankWidth = effect.getParent().getWidth(); - init.startScopedBlock(effect.getParent()); - portRef = CUtil.portRefNestedName(effect); + } + var cumulativePortWidth = 0; + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + // If this port does not have any destinations, do not generate code for it. + if (port.eventualDestinations().isEmpty()) continue; + + code.pr( + "for (int i = 0; i < " + + reaction.getParent().getTotalWidth() + + "; i++) triggers_index[i] = " + + cumulativePortWidth + + ";"); + for (SendRange srcRange : port.eventualDestinations()) { + var srcNested = srcRange.instance.isInput(); + var multicastCount = 0; + for (RuntimeRange dstRange : srcRange.destinations) { + var dst = dstRange.instance; + + code.startScopedRangeBlock(srcRange, dstRange); + + // If the source is nested, need to take into account the parent's bank index + // when indexing into the triggers array. + var triggerArray = ""; + if (srcNested && port.getParent().getWidth() > 1) { + triggerArray = + CUtil.reactionRef(reaction, sr) + + ".triggers[triggers_index[" + + sr + + "] + " + + sc + + " + src_range_mr.digits[1] * src_range_mr.radixes[0]]"; } else { - init.startScopedBlock(); - portRef = CUtil.portRefName(effect); + triggerArray = + CUtil.reactionRef(reaction, sr) + + ".triggers[triggers_index[" + + sr + + "] + " + + sc + + "]"; } - if (effect.isMultiport()) { - // Form is slightly different for inputs vs. outputs. - var connector = "."; - if (effect.isInput()) connector = "->"; - - // Point the output_produced field to where the is_present field of the port is. - init.pr(String.join("\n", - "for (int i = 0; i < "+effect.getWidth()+"; i++) {", - " "+CUtil.reactionRef(reaction)+".output_produced[i + count]", - " = &"+portRef+"[i]"+connector+"is_present;", - "}", - "count += "+effect.getWidth()+";" - )); - outputCount += effect.getWidth() * bankWidth; + if (dst.isOutput()) { + // Include this destination port only if it has at least one + // reaction in the federation. + var belongs = false; + for (ReactionInstance destinationReaction : dst.getDependentReactions()) { + belongs = true; + } + if (belongs) { + code.pr( + String.join( + "\n", + "// Port " + port.getFullName() + " has reactions in its parent's parent.", + "// Point to the trigger struct for those reactions.", + triggerArray + + "[" + + multicastCount + + "] = &" + + CUtil.triggerRefNested(dst, dr, db) + + ";")); + } else { + // Put in a NULL pointer. + code.pr( + String.join( + "\n", + "// Port " + port.getFullName() + " has reactions in its parent's parent.", + "// But those are not in the federation.", + triggerArray + "[" + multicastCount + "] = NULL;")); + } } else { - // The effect is not a multiport. - init.pr(CUtil.reactionRef(reaction)+".output_produced[count++] = &"+portRef+".is_present;"); - outputCount += bankWidth; + // Destination is an input port. + code.pr( + String.join( + "\n", + "// Point to destination port " + dst.getFullName() + "'s trigger struct.", + triggerArray + + "[" + + multicastCount + + "] = &" + + CUtil.triggerRef(dst, dr) + + ";")); } - init.endScopedBlock(); + code.endScopedRangeBlock(srcRange, dstRange); + multicastCount++; + } } - init.endScopedBlock(); - code.pr(String.join("\n", - "// Total number of outputs (single ports and multiport channels)", - "// produced by "+reaction+".", - CUtil.reactionRef(reaction)+".num_outputs = "+outputCount+";" - )); - if (outputCount > 0) { - code.pr(String.join("\n", - "// Allocate memory for triggers[] and triggered_sizes[] on the reaction_t", - "// struct for this reaction.", - CUtil.reactionRef(reaction)+".triggers = (trigger_t***)_lf_allocate(", - " "+outputCount+", sizeof(trigger_t**),", - " &"+reactorSelfStruct+"->base.allocations);", - CUtil.reactionRef(reaction)+".triggered_sizes = (int*)_lf_allocate(", - " "+outputCount+", sizeof(int),", - " &"+reactorSelfStruct+"->base.allocations);", - CUtil.reactionRef(reaction)+".output_produced = (bool**)_lf_allocate(", - " "+outputCount+", sizeof(bool*),", - " &"+reactorSelfStruct+"->base.allocations);" - )); + // If the port is an input of a contained reactor, then we have to take + // into account the bank width of the contained reactor. + if (port.getParent() != reaction.getParent()) { + cumulativePortWidth += port.getWidth() * port.getParent().getWidth(); + } else { + cumulativePortWidth += port.getWidth(); } - - code.pr(String.join("\n", - init.toString(), - "// ** End initialization for reaction "+reaction.index+" of "+name - )); - return code.toString(); + } + if (foundPort) code.endScopedBlock(); } - - /** - * Generate code to allocate the memory needed by reactions for triggering - * downstream reactions. - * @param reactions A list of reactions. - */ - private static String deferredReactionMemory( - Iterable reactions, - TargetConfig targetConfig - ) { - var code = new CodeBuilder(); - // For each reaction instance, allocate the arrays that will be used to - // trigger downstream reactions. - for (ReactionInstance reaction : reactions) { - code.pr(deferredReactionOutputs( - reaction, - targetConfig - )); - var reactorSelfStruct = CUtil.reactorRef(reaction.getParent()); - - // Next handle triggers of the reaction that come from a multiport output - // of a contained reactor. Also, handle startup and shutdown triggers. - for (PortInstance trigger : Iterables.filter(reaction.triggers, PortInstance.class)) { - // If the port is a multiport, then we need to create an entry for each - // individual port. - if (trigger.isMultiport() && trigger.getParent() != null && trigger.isOutput()) { - // Trigger is an output of a contained reactor or bank. - code.pr(String.join("\n", - "// Allocate memory to store pointers to the multiport output "+trigger.getName()+" ", - "// of a contained reactor "+trigger.getParent().getFullName() - )); - code.startScopedBlock(trigger.getParent()); - - var width = trigger.getWidth(); - var portStructType = CGenerator.variableStructType(trigger); - - code.pr(String.join("\n", - CUtil.reactorRefNested(trigger.getParent())+"."+trigger.getName()+"_width = "+width+";", - CUtil.reactorRefNested(trigger.getParent())+"."+trigger.getName(), - " = ("+portStructType+"**)_lf_allocate(", - " "+width+", sizeof("+portStructType+"*),", - " &"+reactorSelfStruct+"->base.allocations); " - )); - - code.endScopedBlock(); - } + return code.toString(); + } + + /** + * For each input port of a contained reactor that receives data from one or more of the specified + * reactions, set the num_destinations field of the corresponding port structs on the self struct + * of the reaction's parent reactor equal to the total number of destination reactors. If the port + * has a token type, this also initializes it with a token. + * + * @param reactions The reactions. + * @param types The C types. + */ + private static String deferredInputNumDestinations( + Iterable reactions, CTypes types) { + // We need the number of destination _reactors_, not the + // number of destination ports nor the number of destination reactions. + // One of the destination reactors may be the container of this + // instance because it may have a reaction to an output of this instance. + // Since a port may be written to by multiple reactions, + // ensure that this is done only once. + var portsHandled = new HashSet(); + var code = new CodeBuilder(); + for (ReactionInstance reaction : reactions) { + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (port.isInput() && !portsHandled.contains(port)) { + // Port is an input of a contained reactor that gets data from a reaction of this reactor. + portsHandled.add(port); + code.pr( + "// Set number of destination reactors for port " + + port.getParent().getName() + + "." + + port.getName() + + "."); + // The input port may itself have multiple destinations. + for (SendRange sendingRange : port.eventualDestinations()) { + code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); + // Syntax is slightly different for a multiport output vs. single port. + var connector = (port.isMultiport()) ? "->" : "."; + code.pr( + CUtil.portRefNested(port, sr, sb, sc) + + connector + + "num_destinations = " + + sendingRange.getNumberOfDestinationReactors() + + ";"); + + // Initialize token types. + var type = ASTUtils.getInferredType(port.getDefinition()); + if (CUtil.isTokenType(type, types)) { + // Create the template token that goes in the port struct. + var rootType = CUtil.rootType(types.getTargetType(type)); + // If the rootType is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var size = (rootType.equals("void")) ? "0" : "sizeof(" + rootType + ")"; + // If the port is a multiport, then the portRefNested is itself a pointer + // so we want its value, not its address. + var indirection = (port.isMultiport()) ? "" : "&"; + code.startChannelIteration(port); + code.pr( + String.join( + "\n", + "_lf_initialize_template((token_template_t*)", + " " + indirection + "(" + CUtil.portRefNested(port, sr, sb, sc) + "),", + size + ");")); + code.endChannelIteration(port); } + + code.endScopedRangeBlock(sendingRange); + } } - return code.toString(); + } + } + return code.toString(); + } + + /** + * For each output port of the specified reactor, set the num_destinations field of port structs + * on its self struct equal to the total number of destination reactors. This is used to + * initialize reference counts in dynamically allocated tokens sent to other reactors. + * + * @param reactor The reactor instance. + */ + private static String deferredOutputNumDestinations(ReactorInstance reactor) { + // Reference counts are decremented by each destination reactor + // at the conclusion of a time step. Hence, the initial reference + // count should equal the number of destination _reactors_, not the + // number of destination ports nor the number of destination reactions. + // One of the destination reactors may be the container of this + // instance because it may have a reaction to an output of this instance. + var code = new CodeBuilder(); + for (PortInstance output : reactor.outputs) { + for (SendRange sendingRange : output.eventualDestinations()) { + code.pr( + "// For reference counting, set num_destinations for port " + + output.getFullName() + + "."); + code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); + code.pr( + CUtil.portRef(output, sr, sb, sc) + + ".num_destinations = " + + sendingRange.getNumberOfDestinationReactors() + + ";"); + code.endScopedRangeBlock(sendingRange); + } + } + return code.toString(); + } + + /** + * Perform initialization functions that must be performed after all reactor runtime instances + * have been created. This function does not create nested loops over nested banks, so each + * function it calls must handle its own iteration over all runtime instance. + * + * @param reactor The container. + * @param main The top-level reactor. + * @param reactions The list of reactions to consider. + * @param types The C types. + */ + private static String deferredInitializeNonNested( + ReactorInstance reactor, + ReactorInstance main, + Iterable reactions, + CTypes types) { + var code = new CodeBuilder(); + code.pr("// **** Start non-nested deferred initialize for " + reactor.getFullName()); + // Initialize the num_destinations fields of port structs on the self struct. + // This needs to be outside the above scoped block because it performs + // its own iteration over ranges. + code.pr(deferredInputNumDestinations(reactions, types)); + + // Second batch of initializes cannot be within a for loop + // iterating over bank members because they iterate over send + // ranges which may span bank members. + if (reactor != main) { + code.pr(deferredOutputNumDestinations(reactor)); + } + code.pr(deferredFillTriggerTable(reactions)); + code.pr(deferredOptimizeForSingleDominatingReaction(reactor)); + for (ReactorInstance child : reactor.children) { + code.pr(deferredInitializeNonNested(child, main, child.reactions, types)); + } + code.pr("// **** End of non-nested deferred initialize for " + reactor.getFullName()); + return code.toString(); + } + + /** + * For each output of the specified reactor that has a token type (type* or type[]), create a + * template token and put it on the self struct. + * + * @param reactor The reactor. + */ + private static String deferredCreateTemplateTokens(ReactorInstance reactor, CTypes types) { + var code = new CodeBuilder(); + // Look for outputs with token types. + for (PortInstance output : reactor.outputs) { + var type = ASTUtils.getInferredType(output.getDefinition()); + if (CUtil.isTokenType(type, types)) { + // Create the template token that goes in the trigger struct. + // Its reference count is zero, enabling it to be used immediately. + var rootType = CUtil.rootType(types.getTargetType(type)); + // If the rootType is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var size = (rootType.equals("void")) ? "0" : "sizeof(" + rootType + ")"; + code.startChannelIteration(output); + code.pr( + String.join( + "\n", + "_lf_initialize_template((token_template_t*)", + " &(" + CUtil.portRef(output) + "),", + size + ");")); + code.endChannelIteration(output); + } + } + return code.toString(); + } + + /** + * For the specified reaction, for ports that it writes to, set up the arrays that store the + * results (if necessary) and that are used to trigger downstream reactions if an effect is + * actually produced. The port may be an output of the reaction's parent or an input to a reactor + * contained by the parent. + * + * @param reaction The reaction instance. + */ + private static String deferredReactionOutputs( + ReactionInstance reaction, TargetConfig targetConfig) { + var code = new CodeBuilder(); + // val selfRef = CUtil.reactorRef(reaction.getParent()); + var name = reaction.getParent().getFullName(); + // Insert a string name to facilitate debugging. + if (targetConfig.logLevel.compareTo(LogLevel.LOG) >= 0) { + code.pr( + CUtil.reactionRef(reaction) + + ".name = " + + addDoubleQuotes(name + " reaction " + reaction.index) + + ";"); } - /** - * If any reaction of the specified reactor provides input - * to a contained reactor, then generate code to allocate - * memory to store the data produced by those reactions. - * The allocated memory is pointed to by a field called - * {@code _lf_containername.portname} on the self struct of the reactor. - * @param reactor The reactor. - */ - private static String deferredAllocationForEffectsOnInputs( - ReactorInstance reactor - ) { - var code = new CodeBuilder(); - // Keep track of ports already handled. There may be more than one reaction - // in the container writing to the port, but we want only one memory allocation. - var portsHandled = new HashSet(); - var reactorSelfStruct = CUtil.reactorRef(reactor); - // Find parent reactions that mention multiport inputs of this reactor. - for (ReactionInstance reaction : reactor.reactions) { - for (PortInstance effect : Iterables.filter(reaction.effects, PortInstance.class)) { - if (effect.getParent().getDepth() > reactor.getDepth() // port of a contained reactor. - && effect.isMultiport() - && !portsHandled.contains(effect) - ) { - code.pr("// A reaction writes to a multiport of a child. Allocate memory."); - portsHandled.add(effect); - code.startScopedBlock(effect.getParent()); - var portStructType = CGenerator.variableStructType(effect); - var effectRef = CUtil.portRefNestedName(effect); - code.pr(String.join("\n", - effectRef+"_width = "+effect.getWidth()+";", - "// Allocate memory to store output of reaction feeding ", - "// a multiport input of a contained reactor.", - effectRef+" = ("+portStructType+"**)_lf_allocate(", - " "+effect.getWidth()+", sizeof("+portStructType+"*),", - " &"+reactorSelfStruct+"->base.allocations); ", - "for (int i = 0; i < "+effect.getWidth()+"; i++) {", - " "+effectRef+"[i] = ("+portStructType+"*)_lf_allocate(", - " 1, sizeof("+portStructType+"),", - " &"+reactorSelfStruct+"->base.allocations); ", - "}" - )); - code.endScopedBlock(); - } - } - } - return code.toString(); + var reactorSelfStruct = CUtil.reactorRef(reaction.getParent()); + + // Count the output ports and inputs of contained reactors that + // may be set by this reaction. This ignores actions in the effects. + // Collect initialization statements for the output_produced array for the reaction + // to point to the is_present field of the appropriate output. + // These statements must be inserted after the array is malloc'd, + // but we construct them while we are counting outputs. + var outputCount = 0; + var init = new CodeBuilder(); + + init.startScopedBlock(); + init.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + for (PortInstance effect : Iterables.filter(reaction.effects, PortInstance.class)) { + // Create the entry in the output_produced array for this port. + // If the port is a multiport, then we need to create an entry for each + // individual channel. + + // If the port is an input of a contained reactor, then, if that + // contained reactor is a bank, we will have to iterate over bank + // members. + var bankWidth = 1; + var portRef = ""; + if (effect.isInput()) { + init.pr("// Reaction writes to an input of a contained reactor."); + bankWidth = effect.getParent().getWidth(); + init.startScopedBlock(effect.getParent()); + portRef = CUtil.portRefNestedName(effect); + } else { + init.startScopedBlock(); + portRef = CUtil.portRefName(effect); + } + + if (effect.isMultiport()) { + // Form is slightly different for inputs vs. outputs. + var connector = "."; + if (effect.isInput()) connector = "->"; + + // Point the output_produced field to where the is_present field of the port is. + init.pr( + String.join( + "\n", + "for (int i = 0; i < " + effect.getWidth() + "; i++) {", + " " + CUtil.reactionRef(reaction) + ".output_produced[i + count]", + " = &" + portRef + "[i]" + connector + "is_present;", + "}", + "count += " + effect.getWidth() + ";")); + outputCount += effect.getWidth() * bankWidth; + } else { + // The effect is not a multiport. + init.pr( + CUtil.reactionRef(reaction) + + ".output_produced[count++] = &" + + portRef + + ".is_present;"); + outputCount += bankWidth; + } + init.endScopedBlock(); + } + init.endScopedBlock(); + code.pr( + String.join( + "\n", + "// Total number of outputs (single ports and multiport channels)", + "// produced by " + reaction + ".", + CUtil.reactionRef(reaction) + ".num_outputs = " + outputCount + ";")); + if (outputCount > 0) { + code.pr( + String.join( + "\n", + "// Allocate memory for triggers[] and triggered_sizes[] on the reaction_t", + "// struct for this reaction.", + CUtil.reactionRef(reaction) + ".triggers = (trigger_t***)_lf_allocate(", + " " + outputCount + ", sizeof(trigger_t**),", + " &" + reactorSelfStruct + "->base.allocations);", + CUtil.reactionRef(reaction) + ".triggered_sizes = (int*)_lf_allocate(", + " " + outputCount + ", sizeof(int),", + " &" + reactorSelfStruct + "->base.allocations);", + CUtil.reactionRef(reaction) + ".output_produced = (bool**)_lf_allocate(", + " " + outputCount + ", sizeof(bool*),", + " &" + reactorSelfStruct + "->base.allocations);")); } - /** - * Perform initialization functions that must be performed after - * all reactor runtime instances have been created. - * This function creates nested loops over nested banks. - * @param reactor The container. - */ - private static String deferredInitialize( - ReactorInstance reactor, - Iterable reactions, - TargetConfig targetConfig, - CTypes types - ) { - var code = new CodeBuilder(); - code.pr("// **** Start deferred initialize for "+reactor.getFullName()); - // First batch of initializations is within a for loop iterating - // over bank members for the reactor's parent. - code.startScopedBlock(reactor); - - // If the child has a multiport that is an effect of some reaction in its container, - // then we have to generate code to allocate memory for arrays pointing to - // its data. If the child is a bank, then memory is allocated for the entire - // bank width because a reaction cannot specify which bank members it writes - // to so we have to assume it can write to any. - code.pr(deferredAllocationForEffectsOnInputs( - reactor - )); - code.pr(deferredReactionMemory( - reactions, - targetConfig - )); - - // For outputs that are not primitive types (of form type* or type[]), - // create a default token on the self struct. - code.pr(deferredCreateTemplateTokens( - reactor, - types - )); - for (ReactorInstance child: reactor.children) { - code.pr(deferredInitialize( - child, - child.reactions, - targetConfig, - types) - ); + code.pr( + String.join( + "\n", + init.toString(), + "// ** End initialization for reaction " + reaction.index + " of " + name)); + return code.toString(); + } + + /** + * Generate code to allocate the memory needed by reactions for triggering downstream reactions. + * + * @param reactions A list of reactions. + */ + private static String deferredReactionMemory( + Iterable reactions, TargetConfig targetConfig) { + var code = new CodeBuilder(); + // For each reaction instance, allocate the arrays that will be used to + // trigger downstream reactions. + for (ReactionInstance reaction : reactions) { + code.pr(deferredReactionOutputs(reaction, targetConfig)); + var reactorSelfStruct = CUtil.reactorRef(reaction.getParent()); + + // Next handle triggers of the reaction that come from a multiport output + // of a contained reactor. Also, handle startup and shutdown triggers. + for (PortInstance trigger : Iterables.filter(reaction.triggers, PortInstance.class)) { + // If the port is a multiport, then we need to create an entry for each + // individual port. + if (trigger.isMultiport() && trigger.getParent() != null && trigger.isOutput()) { + // Trigger is an output of a contained reactor or bank. + code.pr( + String.join( + "\n", + "// Allocate memory to store pointers to the multiport output " + + trigger.getName() + + " ", + "// of a contained reactor " + trigger.getParent().getFullName())); + code.startScopedBlock(trigger.getParent()); + + var width = trigger.getWidth(); + var portStructType = CGenerator.variableStructType(trigger); + + code.pr( + String.join( + "\n", + CUtil.reactorRefNested(trigger.getParent()) + + "." + + trigger.getName() + + "_width = " + + width + + ";", + CUtil.reactorRefNested(trigger.getParent()) + "." + trigger.getName(), + " = (" + portStructType + "**)_lf_allocate(", + " " + width + ", sizeof(" + portStructType + "*),", + " &" + reactorSelfStruct + "->base.allocations); ")); + + code.endScopedBlock(); } - code.endScopedBlock(); - code.pr("// **** End of deferred initialize for "+reactor.getFullName()); - return code.toString(); + } + } + return code.toString(); + } + + /** + * If any reaction of the specified reactor provides input to a contained reactor, then generate + * code to allocate memory to store the data produced by those reactions. The allocated memory is + * pointed to by a field called {@code _lf_containername.portname} on the self struct of the + * reactor. + * + * @param reactor The reactor. + */ + private static String deferredAllocationForEffectsOnInputs(ReactorInstance reactor) { + var code = new CodeBuilder(); + // Keep track of ports already handled. There may be more than one reaction + // in the container writing to the port, but we want only one memory allocation. + var portsHandled = new HashSet(); + var reactorSelfStruct = CUtil.reactorRef(reactor); + // Find parent reactions that mention multiport inputs of this reactor. + for (ReactionInstance reaction : reactor.reactions) { + for (PortInstance effect : Iterables.filter(reaction.effects, PortInstance.class)) { + if (effect.getParent().getDepth() > reactor.getDepth() // port of a contained reactor. + && effect.isMultiport() + && !portsHandled.contains(effect)) { + code.pr("// A reaction writes to a multiport of a child. Allocate memory."); + portsHandled.add(effect); + code.startScopedBlock(effect.getParent()); + var portStructType = CGenerator.variableStructType(effect); + var effectRef = CUtil.portRefNestedName(effect); + code.pr( + String.join( + "\n", + effectRef + "_width = " + effect.getWidth() + ";", + "// Allocate memory to store output of reaction feeding ", + "// a multiport input of a contained reactor.", + effectRef + " = (" + portStructType + "**)_lf_allocate(", + " " + effect.getWidth() + ", sizeof(" + portStructType + "*),", + " &" + reactorSelfStruct + "->base.allocations); ", + "for (int i = 0; i < " + effect.getWidth() + "; i++) {", + " " + effectRef + "[i] = (" + portStructType + "*)_lf_allocate(", + " 1, sizeof(" + portStructType + "),", + " &" + reactorSelfStruct + "->base.allocations); ", + "}")); + code.endScopedBlock(); + } + } + } + return code.toString(); + } + + /** + * Perform initialization functions that must be performed after all reactor runtime instances + * have been created. This function creates nested loops over nested banks. + * + * @param reactor The container. + */ + private static String deferredInitialize( + ReactorInstance reactor, + Iterable reactions, + TargetConfig targetConfig, + CTypes types) { + var code = new CodeBuilder(); + code.pr("// **** Start deferred initialize for " + reactor.getFullName()); + // First batch of initializations is within a for loop iterating + // over bank members for the reactor's parent. + code.startScopedBlock(reactor); + + // If the child has a multiport that is an effect of some reaction in its container, + // then we have to generate code to allocate memory for arrays pointing to + // its data. If the child is a bank, then memory is allocated for the entire + // bank width because a reaction cannot specify which bank members it writes + // to so we have to assume it can write to any. + code.pr(deferredAllocationForEffectsOnInputs(reactor)); + code.pr(deferredReactionMemory(reactions, targetConfig)); + + // For outputs that are not primitive types (of form type* or type[]), + // create a default token on the self struct. + code.pr(deferredCreateTemplateTokens(reactor, types)); + for (ReactorInstance child : reactor.children) { + code.pr(deferredInitialize(child, child.reactions, targetConfig, types)); } + code.endScopedBlock(); + code.pr("// **** End of deferred initialize for " + reactor.getFullName()); + return code.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/c/CTypes.java b/org.lflang/src/org/lflang/generator/c/CTypes.java index 45edd59bd5..97ea482d83 100644 --- a/org.lflang/src/org/lflang/generator/c/CTypes.java +++ b/org.lflang/src/org/lflang/generator/c/CTypes.java @@ -4,162 +4,150 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; - import org.lflang.InferredType; import org.lflang.TimeUnit; import org.lflang.TimeValue; import org.lflang.generator.ReactorInstance; import org.lflang.generator.TargetTypes; -import org.lflang.lf.Initializer; import org.lflang.lf.ParameterReference; -import org.lflang.lf.Type; public class CTypes implements TargetTypes { - // Regular expression pattern for array types. - // For example, for "foo[10]", the first match will be "foo" and the second "[10]". - // For "foo[]", the first match will be "foo" and the second "". - static final Pattern arrayPattern = Pattern.compile("^\\s*(?:/\\*.*?\\*/)?\\s*(\\w+)\\s*\\[([0-9]*)]\\s*$"); - private static final CTypes INSTANCE = new CTypes(); - - public CTypes() { - } - - @Override - public boolean supportsGenerics() { - return false; - } - - @Override - public String getTargetTimeType() { - return "interval_t"; - } - - @Override - public String getTargetTagType() { - return "tag_t"; - } - - @Override - public String getTargetFixedSizeListType(String baseType, int size) { - return String.format("%s[%d]", baseType, size); - } - - @Override - public String getTargetVariableSizeListType(String baseType) { - return String.format("%s[]", baseType); - } - - @Override - public String getTargetUndefinedType() { - return "/*undefined*/"; - } - - /** - * Given a type, return a C representation of the type. Note that - * C types are very idiosyncratic. For example, {@code int[]} is not always accepted - * as a type, and {@code int*} must be used instead, except when initializing - * a variable using a static initializer, as in {@code int[] foo = {1, 2, 3};}. - * When initializing a variable using a static initializer, use - * {@link #getVariableDeclaration(TypeParameterizedReactor, InferredType, String, boolean)} instead. - * @param type The type. - */ - @Override - public String getTargetType(InferredType type) { - var result = TargetTypes.super.getTargetType(type); - Matcher matcher = arrayPattern.matcher(result); - if (matcher.find()) { - return matcher.group(1) + '*'; - } - return result; - } - - @Override - public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { - throw new UnsupportedOperationException("No context defined"); - } - - @Override - public String getTargetTimeExpr(TimeValue time) { - if (time != null) { - if (time.unit != null) { - return cMacroName(time.unit) + "(" + time.getMagnitude() + ")"; - } else { - return Long.valueOf(time.getMagnitude()).toString(); - } - } - return "0"; // FIXME: do this or throw exception? - } - - @Override - public String getFixedSizeListInitExpression(List contents, int listSize, boolean withBraces) { - return contents.stream().collect(Collectors.joining(", ", "{ ", " }")); - } - - @Override - public String getVariableSizeListInitExpression(List contents, boolean withBraces) { - return contents.stream().collect(Collectors.joining(", ", "{ ", " }")); - } - - /** - * Return a variable declaration of the form "{@code type name}". - * The type is as returned by {@link #getTargetType(InferredType)}, except with - * the array syntax {@code [size]} preferred over the pointer syntax - * {@code *} (if applicable). This also includes the variable name - * because C requires the array type specification to be placed after - * the variable name rather than with the type. - * The result is of the form {@code type variable_name[size]} or - * {@code type variable_name} depending on whether the given type - * is an array type, unless the array type has no size (it is given - * as {@code []}. In that case, the returned form depends on the - * third argument, initializer. If true, the then the returned - * declaration will have the form {@code type variable_name[]}, - * and otherwise it will have the form {@code type* variable_name}. - * @param type The type. - * @param variableName The name of the variable. - * @param initializer True to return a form usable in a static initializer. - */ - public String getVariableDeclaration( - TypeParameterizedReactor tpr, - InferredType type, - String variableName, - boolean initializer - ) { - String t = TargetTypes.super.getTargetType(tpr.resolveType(type)); - Matcher matcher = arrayPattern.matcher(t); - String declaration = String.format("%s %s", t, variableName); - if (matcher.find()) { - // For array types, we have to move the [] - // because C is very picky about where this goes. It has to go - // after the variable name. Also, in an initializer, it has to have - // form [], and in a struct definition, it has to use *. - if (matcher.group(2).equals("") && !initializer) { - declaration = String.format("%s* %s", - matcher.group(1), variableName); - } else { - declaration = String.format("%s %s[%s]", - matcher.group(1), variableName, matcher.group(2)); - } - } - return declaration; - } - - // note that this is moved out by #544 - public static String cMacroName(TimeUnit unit) { - return unit.getCanonicalName().toUpperCase(); - } - - public static CTypes getInstance() { - return INSTANCE; - } - - - public static CTypes generateParametersIn(ReactorInstance instance) { - return new CTypes() { - @Override - public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { - return CUtil.reactorRef(instance) + "->" + expr.getParameter().getName(); - } - }; - } + // Regular expression pattern for array types. + // For example, for "foo[10]", the first match will be "foo" and the second "[10]". + // For "foo[]", the first match will be "foo" and the second "". + static final Pattern arrayPattern = + Pattern.compile("^\\s*(?:/\\*.*?\\*/)?\\s*(\\w+)\\s*\\[([0-9]*)]\\s*$"); + private static final CTypes INSTANCE = new CTypes(); + + public CTypes() {} + + @Override + public boolean supportsGenerics() { + return false; + } + + @Override + public String getTargetTimeType() { + return "interval_t"; + } + + @Override + public String getTargetTagType() { + return "tag_t"; + } + + @Override + public String getTargetFixedSizeListType(String baseType, int size) { + return String.format("%s[%d]", baseType, size); + } + + @Override + public String getTargetVariableSizeListType(String baseType) { + return String.format("%s[]", baseType); + } + + @Override + public String getTargetUndefinedType() { + return "/*undefined*/"; + } + + /** + * Given a type, return a C representation of the type. Note that C types are very idiosyncratic. + * For example, {@code int[]} is not always accepted as a type, and {@code int*} must be used + * instead, except when initializing a variable using a static initializer, as in {@code int[] foo + * = {1, 2, 3};}. When initializing a variable using a static initializer, use {@link + * #getVariableDeclaration(TypeParameterizedReactor, InferredType, String, boolean)} instead. + * + * @param type The type. + */ + @Override + public String getTargetType(InferredType type) { + var result = TargetTypes.super.getTargetType(type); + Matcher matcher = arrayPattern.matcher(result); + if (matcher.find()) { + return matcher.group(1) + '*'; + } + return result; + } + + @Override + public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + throw new UnsupportedOperationException("No context defined"); + } + + @Override + public String getTargetTimeExpr(TimeValue time) { + if (time != null) { + if (time.unit != null) { + return cMacroName(time.unit) + "(" + time.getMagnitude() + ")"; + } else { + return Long.valueOf(time.getMagnitude()).toString(); + } + } + return "0"; // FIXME: do this or throw exception? + } + + @Override + public String getFixedSizeListInitExpression( + List contents, int listSize, boolean withBraces) { + return contents.stream().collect(Collectors.joining(", ", "{ ", " }")); + } + + @Override + public String getVariableSizeListInitExpression(List contents, boolean withBraces) { + return contents.stream().collect(Collectors.joining(", ", "{ ", " }")); + } + + /** + * Return a variable declaration of the form "{@code type name}". The type is as returned by + * {@link #getTargetType(InferredType)}, except with the array syntax {@code [size]} preferred + * over the pointer syntax {@code *} (if applicable). This also includes the variable name because + * C requires the array type specification to be placed after the variable name rather than with + * the type. The result is of the form {@code type variable_name[size]} or {@code type + * variable_name} depending on whether the given type is an array type, unless the array type has + * no size (it is given as {@code []}. In that case, the returned form depends on the third + * argument, initializer. If true, the then the returned declaration will have the form {@code + * type variable_name[]}, and otherwise it will have the form {@code type* variable_name}. + * + * @param type The type. + * @param variableName The name of the variable. + * @param initializer True to return a form usable in a static initializer. + */ + public String getVariableDeclaration( + TypeParameterizedReactor tpr, InferredType type, String variableName, boolean initializer) { + String t = TargetTypes.super.getTargetType(tpr.resolveType(type)); + Matcher matcher = arrayPattern.matcher(t); + String declaration = String.format("%s %s", t, variableName); + if (matcher.find()) { + // For array types, we have to move the [] + // because C is very picky about where this goes. It has to go + // after the variable name. Also, in an initializer, it has to have + // form [], and in a struct definition, it has to use *. + if (matcher.group(2).equals("") && !initializer) { + declaration = String.format("%s* %s", matcher.group(1), variableName); + } else { + declaration = String.format("%s %s[%s]", matcher.group(1), variableName, matcher.group(2)); + } + } + return declaration; + } + + // note that this is moved out by #544 + public static String cMacroName(TimeUnit unit) { + return unit.getCanonicalName().toUpperCase(); + } + + public static CTypes getInstance() { + return INSTANCE; + } + + public static CTypes generateParametersIn(ReactorInstance instance) { + return new CTypes() { + @Override + public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + return CUtil.reactorRef(instance) + "->" + expr.getParameter().getName(); + } + }; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index dbb365e189..3a7f151a2c 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -1,28 +1,28 @@ /* Utilities for C code generation. */ /************* -Copyright (c) 2019-2021, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2021, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator.c; @@ -32,12 +32,10 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.List; import java.util.Objects; import java.util.stream.Collectors; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.InferredType; import org.lflang.TargetConfig; - import org.lflang.generator.ActionInstance; import org.lflang.generator.GeneratorCommandFactory; import org.lflang.generator.LFGeneratorContext; @@ -55,751 +53,741 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.util.LFCommand; /** - * A collection of utilities for C code generation. - * This class codifies the coding conventions for the C target code generator. - * I.e., it defines how variables are named and referenced. + * A collection of utilities for C code generation. This class codifies the coding conventions for + * the C target code generator. I.e., it defines how variables are named and referenced. + * * @author Edward A. Lee */ public class CUtil { - /** - * Suffix that when appended to the name of a federated reactor yields - * the name of its corresponding RTI executable. - */ - public static final String RTI_BIN_SUFFIX = "_RTI"; - - /** - * Suffix that when appended to the name of a federated reactor yields - * the name of its corresponding distribution script. - */ - public static final String RTI_DISTRIBUTION_SCRIPT_SUFFIX = "_distribute.sh"; - - ////////////////////////////////////////////////////// - //// Public methods. - - /** - * Return a reference to the action struct of the specified - * action instance. This action_base_t struct is on the self struct. - * @param instance The action instance. - * @param runtimeIndex An optional index variable name to use to address runtime instances. - */ - public static String actionRef(ActionInstance instance, String runtimeIndex) { - return reactorRef(instance.getParent(), runtimeIndex) - + "->_lf_" - + instance.getName(); - } - - /** - * Return a default name of a variable to refer to the bank index of a reactor - * in a bank. This is has the form uniqueID_i where uniqueID - * is an identifier for the instance that is guaranteed to be different - * from the ID of any other instance in the program. - * If the instance is not a bank, return "0". - * @param instance A reactor instance. - */ - public static String bankIndex(ReactorInstance instance) { - if (!instance.isBank()) return "0"; - return bankIndexName(instance); - } - - /** - * Return a default name of a variable to refer to the bank index of a reactor - * in a bank. This is has the form uniqueID_i where uniqueID - * is an identifier for the instance that is guaranteed to be different - * from the ID of any other instance in the program. - * @param instance A reactor instance. - */ - public static String bankIndexName(ReactorInstance instance) { - return instance.uniqueID() + "_i"; - } - - /** - * Return a default name of a variable to refer to the channel index of a port - * in a bank. This has the form uniqueID_c where uniqueID - * is an identifier for the instance that is guaranteed to be different - * from the ID of any other instance in the program. - * If the port is not a multiport, then return the string "0". - */ - public static String channelIndex(PortInstance port) { - if (!port.isMultiport()) return "0"; - return channelIndexName(port); - } - - /** - * Return a default name of a variable to refer to the channel index of a port - * in a bank. This is has the form uniqueID_c where uniqueID - * is an identifier for the instance that is guaranteed to be different - * from the ID of any other instance in the program. - */ - public static String channelIndexName(PortInstance port) { - return port.uniqueID() + "_c"; - } - - /** - * Return the name of the reactor. A {@code _main} is appended to the name if the - * reactor is main (to allow for instantiations that have the same name as - * the main reactor or the .lf file). - */ - public static String getName(TypeParameterizedReactor reactor) { - String name = reactor.reactor().getName().toLowerCase() + reactor.hashCode(); - if (reactor.reactor().isMain()) { - return name + "_main"; - } - return name; - } - - /** - * Return a reference to the specified port. - * - * The returned string will have one of the following forms: - *

      - *
    • {@code selfStructs[k]->_lf_portName}
      • - *
    • {@code selfStructs[k]->_lf_portName}
      • - *
    • {@code selfStructs[k]->_lf_portName[i]}
      • - *
    • {@code selfStructs[k]->_lf_parent.portName}
      • - *
    • {@code selfStructs[k]->_lf_parent.portName[i]}
      • - *
    • {@code selfStructs[k]->_lf_parent[j].portName}
      • - *
    • {@code selfStructs[k]->_lf_parent[j].portName[i]}
      • - *
    - * - * where {@code k} is the runtime index of either the port's parent - * or the port's parent's parent, the latter when isNested is {@code true}. - * The index {@code j} is present if the parent is a bank, and - * the index {@code i} is present if the port is a multiport. - * - * The first two forms are used if isNested is false, - * and the remaining four are used if isNested is true. - * Set {@code isNested} to {@code true} when referencing a port belonging - * to a contained reactor. - * - * @param port The port. - * @param isNested True to return a reference relative to the parent's parent. - * @param includeChannelIndex True to include the channel index at the end. - * @param runtimeIndex A variable name to use to index the runtime instance or - * null to use the default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. - * @param bankIndex A variable name to use to index the bank or null to use the - * default, the string returned by {@link CUtil#bankIndex(ReactorInstance)}. - * @param channelIndex A variable name to use to index the channel or null to - * use the default, the string returned by {@link CUtil#channelIndex(PortInstance)}. - */ - public static String portRef( - PortInstance port, - boolean isNested, - boolean includeChannelIndex, - String runtimeIndex, - String bankIndex, - String channelIndex - ) { - String channel = ""; - if (channelIndex == null) channelIndex = channelIndex(port); - if (port.isMultiport() && includeChannelIndex) { - channel = "[" + channelIndex + "]"; - } - if (isNested) { - return reactorRefNested(port.getParent(), runtimeIndex, bankIndex) + "." + port.getName() + channel; - } else { - String sourceStruct = CUtil.reactorRef(port.getParent(), runtimeIndex); - return sourceStruct + "->_lf_" + port.getName() + channel; - } - } - - /** - * Return a reference to the port on the self struct of the - * port's parent. This is used when an input port triggers a reaction - * in the port's parent or when an output port is written to by - * a reaction in the port's parent. - * This is equivalent to calling {@code portRef(port, false, true, null, null)}. - * @param port An instance of the port to be referenced. - */ - public static String portRef(PortInstance port) { - return portRef(port, false, true, null, null, null); - } - - /** - * Return a reference to the port on the self struct of the - * port's parent using the specified index variables. - * This is used when an input port triggers a reaction - * in the port's parent or when an output port is written to by - * a reaction in the port's parent. - * This is equivalent to calling {@code portRef(port, false, true, bankIndex, channelIndex)}. - * @param port An instance of the port to be referenced. - * @param runtimeIndex A variable name to use to index the runtime instance or - * null to use the default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. - * @param bankIndex A variable name to use to index the bank or null to use the - * default, the string returned by {@link CUtil#bankIndex(ReactorInstance)}. - * @param channelIndex A variable name to use to index the channel or null to - * use the default, the string returned by {@link CUtil#channelIndex(PortInstance)}. - */ - public static String portRef( - PortInstance port, String runtimeIndex, String bankIndex, String channelIndex - ) { - return portRef(port, false, true, runtimeIndex, bankIndex, channelIndex); - } - - /** - * Return a reference to a port without any channel indexing. - * This is useful for deriving a reference to the _width variable. - * @param port An instance of the port to be referenced. - */ - public static String portRefName(PortInstance port) { - return portRef(port, false, false, null, null, null); - } - - /** - * Return the portRef without the channel indexing. - * This is useful for deriving a reference to the _width variable. - * - * @param port An instance of the port to be referenced. - * @param runtimeIndex A variable name to use to index the runtime instance or - * null to use the default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. - * @param bankIndex A variable name to use to index the bank or null to use the - * default, the string returned by {@link CUtil#bankIndex(ReactorInstance)}. - * @param channelIndex A variable name to use to index the channel or null to - * use the default, the string returned by {@link CUtil#channelIndex(PortInstance)}. - */ - public static String portRefName( - PortInstance port, String runtimeIndex, String bankIndex, String channelIndex - ) { - return portRef(port, false, false, runtimeIndex, bankIndex, channelIndex); - } - - /** - * Return a port reference to a port on the self struct of the - * parent of the port's parent. This is used when an input port - * is written to by a reaction in the parent of the port's parent, - * or when an output port triggers a reaction in the parent of the - * port's parent. This is equivalent to calling - * {@code portRef(port, true, true, null, null, null)}. - * - * @param port The port. - */ - public static String portRefNested(PortInstance port) { - return portRef(port, true, true, null, null, null); - } - - /** - * Return a reference to the port on the self struct of the - * parent of the port's parent. This is used when an input port - * is written to by a reaction in the parent of the port's parent, - * or when an output port triggers a reaction in the parent of the - * port's parent. This is equivalent to calling - * {@code portRef(port, true, true, runtimeIndex, bankIndex, channelIndex)}. - * - * @param port The port. - * @param runtimeIndex A variable name to use to index the runtime instance or - * null to use the default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. - * @param bankIndex A variable name to use to index the bank or null to use the - * default, the string returned by {@link CUtil#bankIndex(ReactorInstance)}. - * @param channelIndex A variable name to use to index the channel or null to - * use the default, the string returned by {@link CUtil#channelIndex(PortInstance)}. - */ - public static String portRefNested( - PortInstance port, String runtimeIndex, String bankIndex, String channelIndex - ) { - return portRef(port, true, true, runtimeIndex, bankIndex, channelIndex); - } - - /** - * Return a reference to the port on the self struct of the - * parent of the port's parent, but without the channel indexing, - * even if it is a multiport. This is used when an input port - * is written to by a reaction in the parent of the port's parent, - * or when an output port triggers a reaction in the parent of the - * port's parent. - * This is equivalent to calling {@code portRef(port, true, false, null, null, null)}. - * - * @param port The port. - */ - public static String portRefNestedName(PortInstance port) { - return portRef(port, true, false, null, null, null); - } - - /** - * Return a reference to the port on the self struct of the - * parent of the port's parent, but without the channel indexing, - * even if it is a multiport. This is used when an input port - * is written to by a reaction in the parent of the port's parent, - * or when an output port triggers a reaction in the parent of the - * port's parent. This is equivalent to calling - * {@code portRefNested(port, true, false, runtimeIndex, bankIndex, channelIndex)}. - * - * @param port The port. - * @param runtimeIndex A variable name to use to index the runtime instance or - * null to use the default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. - * @param bankIndex A variable name to use to index the bank or null to use the - * default, the string returned by {@link CUtil#bankIndex(ReactorInstance)}. - * @param channelIndex A variable name to use to index the channel or null to - * use the default, the string returned by {@link CUtil#channelIndex(PortInstance)}. - */ - public static String portRefNestedName( - PortInstance port, String runtimeIndex, String bankIndex, String channelIndex - ) { - return portRef(port, true, false, runtimeIndex, bankIndex, channelIndex); - } - - /** - * Return code for referencing a port within a reaction body possibly indexed by - * a bank index and/or a multiport index. If the provided reference is - * not a port, then this returns the string "ERROR: not a port." - * @param reference The reference to the port. - * @param bankIndex A bank index or null or negative if not in a bank. - * @param multiportIndex A multiport index or null or negative if not in a multiport. - */ - public static String portRefInReaction(VarRef reference, Integer bankIndex, Integer multiportIndex) { - if (!(reference.getVariable() instanceof Port)) { - return "ERROR: not a port."; // FIXME: This is not the fail-fast approach, and it seems arbitrary. - } - var prefix = ""; - if (reference.getContainer() != null) { - var bank = ""; - if (reference.getContainer().getWidthSpec() != null && bankIndex != null && bankIndex >= 0) { - bank = "[" + bankIndex + "]"; - } - prefix = reference.getContainer().getName() + bank + "."; - } - var multiport = ""; - if (((Port) reference.getVariable()).getWidthSpec() != null && multiportIndex != null && multiportIndex >= 0) { - multiport = "[" + multiportIndex + "]"; + /** + * Suffix that when appended to the name of a federated reactor yields the name of its + * corresponding RTI executable. + */ + public static final String RTI_BIN_SUFFIX = "_RTI"; + + /** + * Suffix that when appended to the name of a federated reactor yields the name of its + * corresponding distribution script. + */ + public static final String RTI_DISTRIBUTION_SCRIPT_SUFFIX = "_distribute.sh"; + + ////////////////////////////////////////////////////// + //// Public methods. + + /** + * Return a reference to the action struct of the specified action instance. This action_base_t + * struct is on the self struct. + * + * @param instance The action instance. + * @param runtimeIndex An optional index variable name to use to address runtime instances. + */ + public static String actionRef(ActionInstance instance, String runtimeIndex) { + return reactorRef(instance.getParent(), runtimeIndex) + "->_lf_" + instance.getName(); + } + + /** + * Return a default name of a variable to refer to the bank index of a reactor in a bank. This is + * has the form uniqueID_i where uniqueID is an identifier for the instance that is guaranteed to + * be different from the ID of any other instance in the program. If the instance is not a bank, + * return "0". + * + * @param instance A reactor instance. + */ + public static String bankIndex(ReactorInstance instance) { + if (!instance.isBank()) return "0"; + return bankIndexName(instance); + } + + /** + * Return a default name of a variable to refer to the bank index of a reactor in a bank. This is + * has the form uniqueID_i where uniqueID is an identifier for the instance that is guaranteed to + * be different from the ID of any other instance in the program. + * + * @param instance A reactor instance. + */ + public static String bankIndexName(ReactorInstance instance) { + return instance.uniqueID() + "_i"; + } + + /** + * Return a default name of a variable to refer to the channel index of a port in a bank. This has + * the form uniqueID_c where uniqueID is an identifier for the instance that is guaranteed to be + * different from the ID of any other instance in the program. If the port is not a multiport, + * then return the string "0". + */ + public static String channelIndex(PortInstance port) { + if (!port.isMultiport()) return "0"; + return channelIndexName(port); + } + + /** + * Return a default name of a variable to refer to the channel index of a port in a bank. This is + * has the form uniqueID_c where uniqueID is an identifier for the instance that is guaranteed to + * be different from the ID of any other instance in the program. + */ + public static String channelIndexName(PortInstance port) { + return port.uniqueID() + "_c"; + } + + /** + * Return the name of the reactor. A {@code _main} is appended to the name if the reactor is main + * (to allow for instantiations that have the same name as the main reactor or the .lf file). + */ + public static String getName(TypeParameterizedReactor reactor) { + String name = reactor.reactor().getName().toLowerCase() + reactor.hashCode(); + if (reactor.reactor().isMain()) { + return name + "_main"; + } + return name; + } + + /** + * Return a reference to the specified port. + * + *

    The returned string will have one of the following forms: + * + *

      + *
    • {@code selfStructs[k]->_lf_portName} + *
    • {@code selfStructs[k]->_lf_portName} + *
    • {@code selfStructs[k]->_lf_portName[i]} + *
    • {@code selfStructs[k]->_lf_parent.portName} + *
    • {@code selfStructs[k]->_lf_parent.portName[i]} + *
    • {@code selfStructs[k]->_lf_parent[j].portName} + *
    • {@code selfStructs[k]->_lf_parent[j].portName[i]} + *
    + * + * where {@code k} is the runtime index of either the port's parent or the port's parent's parent, + * the latter when isNested is {@code true}. The index {@code j} is present if the parent is a + * bank, and the index {@code i} is present if the port is a multiport. + * + *

    The first two forms are used if isNested is false, and the remaining four are used if + * isNested is true. Set {@code isNested} to {@code true} when referencing a port belonging to a + * contained reactor. + * + * @param port The port. + * @param isNested True to return a reference relative to the parent's parent. + * @param includeChannelIndex True to include the channel index at the end. + * @param runtimeIndex A variable name to use to index the runtime instance or null to use the + * default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. + * @param bankIndex A variable name to use to index the bank or null to use the default, the + * string returned by {@link CUtil#bankIndex(ReactorInstance)}. + * @param channelIndex A variable name to use to index the channel or null to use the default, the + * string returned by {@link CUtil#channelIndex(PortInstance)}. + */ + public static String portRef( + PortInstance port, + boolean isNested, + boolean includeChannelIndex, + String runtimeIndex, + String bankIndex, + String channelIndex) { + String channel = ""; + if (channelIndex == null) channelIndex = channelIndex(port); + if (port.isMultiport() && includeChannelIndex) { + channel = "[" + channelIndex + "]"; + } + if (isNested) { + return reactorRefNested(port.getParent(), runtimeIndex, bankIndex) + + "." + + port.getName() + + channel; + } else { + String sourceStruct = CUtil.reactorRef(port.getParent(), runtimeIndex); + return sourceStruct + "->_lf_" + port.getName() + channel; + } + } + + /** + * Return a reference to the port on the self struct of the port's parent. This is used when an + * input port triggers a reaction in the port's parent or when an output port is written to by a + * reaction in the port's parent. This is equivalent to calling {@code portRef(port, false, true, + * null, null)}. + * + * @param port An instance of the port to be referenced. + */ + public static String portRef(PortInstance port) { + return portRef(port, false, true, null, null, null); + } + + /** + * Return a reference to the port on the self struct of the port's parent using the specified + * index variables. This is used when an input port triggers a reaction in the port's parent or + * when an output port is written to by a reaction in the port's parent. This is equivalent to + * calling {@code portRef(port, false, true, bankIndex, channelIndex)}. + * + * @param port An instance of the port to be referenced. + * @param runtimeIndex A variable name to use to index the runtime instance or null to use the + * default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. + * @param bankIndex A variable name to use to index the bank or null to use the default, the + * string returned by {@link CUtil#bankIndex(ReactorInstance)}. + * @param channelIndex A variable name to use to index the channel or null to use the default, the + * string returned by {@link CUtil#channelIndex(PortInstance)}. + */ + public static String portRef( + PortInstance port, String runtimeIndex, String bankIndex, String channelIndex) { + return portRef(port, false, true, runtimeIndex, bankIndex, channelIndex); + } + + /** + * Return a reference to a port without any channel indexing. This is useful for deriving a + * reference to the _width variable. + * + * @param port An instance of the port to be referenced. + */ + public static String portRefName(PortInstance port) { + return portRef(port, false, false, null, null, null); + } + + /** + * Return the portRef without the channel indexing. This is useful for deriving a reference to the + * _width variable. + * + * @param port An instance of the port to be referenced. + * @param runtimeIndex A variable name to use to index the runtime instance or null to use the + * default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. + * @param bankIndex A variable name to use to index the bank or null to use the default, the + * string returned by {@link CUtil#bankIndex(ReactorInstance)}. + * @param channelIndex A variable name to use to index the channel or null to use the default, the + * string returned by {@link CUtil#channelIndex(PortInstance)}. + */ + public static String portRefName( + PortInstance port, String runtimeIndex, String bankIndex, String channelIndex) { + return portRef(port, false, false, runtimeIndex, bankIndex, channelIndex); + } + + /** + * Return a port reference to a port on the self struct of the parent of the port's parent. This + * is used when an input port is written to by a reaction in the parent of the port's parent, or + * when an output port triggers a reaction in the parent of the port's parent. This is equivalent + * to calling {@code portRef(port, true, true, null, null, null)}. + * + * @param port The port. + */ + public static String portRefNested(PortInstance port) { + return portRef(port, true, true, null, null, null); + } + + /** + * Return a reference to the port on the self struct of the parent of the port's parent. This is + * used when an input port is written to by a reaction in the parent of the port's parent, or when + * an output port triggers a reaction in the parent of the port's parent. This is equivalent to + * calling {@code portRef(port, true, true, runtimeIndex, bankIndex, channelIndex)}. + * + * @param port The port. + * @param runtimeIndex A variable name to use to index the runtime instance or null to use the + * default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. + * @param bankIndex A variable name to use to index the bank or null to use the default, the + * string returned by {@link CUtil#bankIndex(ReactorInstance)}. + * @param channelIndex A variable name to use to index the channel or null to use the default, the + * string returned by {@link CUtil#channelIndex(PortInstance)}. + */ + public static String portRefNested( + PortInstance port, String runtimeIndex, String bankIndex, String channelIndex) { + return portRef(port, true, true, runtimeIndex, bankIndex, channelIndex); + } + + /** + * Return a reference to the port on the self struct of the parent of the port's parent, but + * without the channel indexing, even if it is a multiport. This is used when an input port is + * written to by a reaction in the parent of the port's parent, or when an output port triggers a + * reaction in the parent of the port's parent. This is equivalent to calling {@code portRef(port, + * true, false, null, null, null)}. + * + * @param port The port. + */ + public static String portRefNestedName(PortInstance port) { + return portRef(port, true, false, null, null, null); + } + + /** + * Return a reference to the port on the self struct of the parent of the port's parent, but + * without the channel indexing, even if it is a multiport. This is used when an input port is + * written to by a reaction in the parent of the port's parent, or when an output port triggers a + * reaction in the parent of the port's parent. This is equivalent to calling {@code + * portRefNested(port, true, false, runtimeIndex, bankIndex, channelIndex)}. + * + * @param port The port. + * @param runtimeIndex A variable name to use to index the runtime instance or null to use the + * default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. + * @param bankIndex A variable name to use to index the bank or null to use the default, the + * string returned by {@link CUtil#bankIndex(ReactorInstance)}. + * @param channelIndex A variable name to use to index the channel or null to use the default, the + * string returned by {@link CUtil#channelIndex(PortInstance)}. + */ + public static String portRefNestedName( + PortInstance port, String runtimeIndex, String bankIndex, String channelIndex) { + return portRef(port, true, false, runtimeIndex, bankIndex, channelIndex); + } + + /** + * Return code for referencing a port within a reaction body possibly indexed by a bank index + * and/or a multiport index. If the provided reference is not a port, then this returns the string + * "ERROR: not a port." + * + * @param reference The reference to the port. + * @param bankIndex A bank index or null or negative if not in a bank. + * @param multiportIndex A multiport index or null or negative if not in a multiport. + */ + public static String portRefInReaction( + VarRef reference, Integer bankIndex, Integer multiportIndex) { + if (!(reference.getVariable() instanceof Port)) { + return "ERROR: not a port."; // FIXME: This is not the fail-fast approach, and it seems + // arbitrary. + } + var prefix = ""; + if (reference.getContainer() != null) { + var bank = ""; + if (reference.getContainer().getWidthSpec() != null && bankIndex != null && bankIndex >= 0) { + bank = "[" + bankIndex + "]"; + } + prefix = reference.getContainer().getName() + bank + "."; + } + var multiport = ""; + if (((Port) reference.getVariable()).getWidthSpec() != null + && multiportIndex != null + && multiportIndex >= 0) { + multiport = "[" + multiportIndex + "]"; + } + return prefix + reference.getVariable().getName() + multiport; + } + + /** + * Return a reference to the reaction entry on the self struct of the parent of the specified + * reaction. + * + * @param reaction The reaction. + */ + public static String reactionRef(ReactionInstance reaction) { + return reactionRef(reaction, null); + } + + /** + * Return a reference to the reaction entry on the self struct of the parent of the specified + * reaction. + * + * @param reaction The reaction. + * @param runtimeIndex An index into the array of self structs for the parent. + */ + public static String reactionRef(ReactionInstance reaction, String runtimeIndex) { + return reactorRef(reaction.getParent(), runtimeIndex) + "->_lf__reaction_" + reaction.index; + } + + /** + * Return a reference to the "self" struct of the specified reactor instance. The returned string + * has the form self[j], where self is the name of the array of self structs for this reactor + * instance and j is the expression returned by {@link #runtimeIndex(ReactorInstance)} or 0 if + * there are no banks. + * + * @param instance The reactor instance. + */ + public static String reactorRef(ReactorInstance instance) { + return reactorRef(instance, null); + } + + /** + * Return the name of the array of "self" structs of the specified reactor instance. This is + * similar to {@link #reactorRef(ReactorInstance)} except that it does not index into the array. + * + * @param instance The reactor instance. + */ + public static String reactorRefName(ReactorInstance instance) { + return instance.uniqueID() + "_self"; + } + + /** + * Return a reference to the "self" struct of the specified reactor instance. The returned string + * has the form self[runtimeIndex], where self is the name of the array of self structs for this + * reactor instance. If runtimeIndex is null, then it is replaced by the expression returned by + * {@link #runtimeIndex(ReactorInstance)} or 0 if there are no banks. + * + * @param instance The reactor instance. + * @param runtimeIndex An optional expression to use to address bank members. If this is null, the + * expression used will be that returned by {@link #runtimeIndex(ReactorInstance)}. + */ + public static String reactorRef(ReactorInstance instance, String runtimeIndex) { + if (runtimeIndex == null) runtimeIndex = runtimeIndex(instance); + return reactorRefName(instance) + "[" + runtimeIndex + "]"; + } + + /** + * For situations where a reaction reacts to or reads from an output of a contained reactor or + * sends to an input of a contained reactor, then the container's self struct will have a field + * (or an array of fields if the contained reactor is a bank) that is a struct with fields + * corresponding to those inputs and outputs. This method returns a reference to that struct or + * array of structs. Note that the returned reference is not to the self struct of the contained + * reactor. Use {@link #reactorRef(ReactorInstance)} for that. + * + * @param reactor The contained reactor. + */ + public static String reactorRefNested(ReactorInstance reactor) { + return reactorRefNested(reactor, null, null); + } + + /** + * For situations where a reaction reacts to or reads from an output of a contained reactor or + * sends to an input of a contained reactor, then the container's self struct will have a field + * (or an array of fields if the contained reactor is a bank) that is a struct with fields + * corresponding to those inputs and outputs. This method returns a reference to that struct or + * array of structs. Note that the returned reference is not to the self struct of the contained + * reactor. Use {@link CUtil#reactorRef(ReactorInstance)} for that. + * + * @param reactor The contained reactor. + * @param runtimeIndex A variable name to use to index the runtime instance or null to use the + * default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. + * @param bankIndex A variable name to use to index the bank or null to use the default, the + * string returned by {@link CUtil#bankIndex(ReactorInstance)}. + */ + public static String reactorRefNested( + ReactorInstance reactor, String runtimeIndex, String bankIndex) { + String result = reactorRef(reactor.getParent(), runtimeIndex) + "->_lf_" + reactor.getName(); + if (reactor.isBank()) { + // Need the bank index not the runtimeIndex. + if (bankIndex == null) bankIndex = bankIndex(reactor); + result += "[" + bankIndex + "]"; + } + return result; + } + + /** + * Return an expression that, when evaluated, gives the index of a runtime instance of the + * specified ReactorInstance. If the reactor is not within any banks, then this will return "0". + * Otherwise, it will return an expression that evaluates a mixed-radix number d0%w0, d1%w1, ... , + * dn%wn, where n is the depth minus one of the reactor. The radixes, w0 to wn, are the widths of + * this reactor, its parent reactor, on up to the top-level reactor. Since the top-level reactor + * is never a bank, dn = 0 and wn = 1. The digits, di, are either 0 (of the parent is not a bank) + * or the variable name returned by {@link #bankIndexName(ReactorInstance)} if the parent is a + * bank. The returned expression, when evaluated, will yield the following value: + * + * 

    +   *     d0 + w0 * (d1 + w1 * ( ... (dn-1 + wn-1 * dn) ... )
+   *
    + * + * @param reactor The reactor. + */ + public static String runtimeIndex(ReactorInstance reactor) { + StringBuilder result = new StringBuilder(); + int width = 0; + int parens = 0; + while (reactor != null) { + if (reactor.isBank() && reactor.getWidth() > 1) { + if (width > 0) { + result.append(" + " + width + " * ("); + parens++; } - return prefix + reference.getVariable().getName() + multiport; - } - - /** - * Return a reference to the reaction entry on the self struct - * of the parent of the specified reaction. - * @param reaction The reaction. - */ - public static String reactionRef(ReactionInstance reaction) { - return reactionRef(reaction, null); - } - - /** - * Return a reference to the reaction entry on the self struct - * of the parent of the specified reaction. - * @param reaction The reaction. - * @param runtimeIndex An index into the array of self structs for the parent. - */ - public static String reactionRef(ReactionInstance reaction, String runtimeIndex) { - return reactorRef(reaction.getParent(), runtimeIndex) - + "->_lf__reaction_" + reaction.index; - } - - /** - * Return a reference to the "self" struct of the specified - * reactor instance. The returned string has the form - * self[j], where self is the name of the array of self structs - * for this reactor instance and j is the expression returned - * by {@link #runtimeIndex(ReactorInstance)} or 0 if there are no banks. - * @param instance The reactor instance. - */ - public static String reactorRef(ReactorInstance instance) { - return reactorRef(instance, null); - } - - /** - * Return the name of the array of "self" structs of the specified - * reactor instance. This is similar to {@link #reactorRef(ReactorInstance)} - * except that it does not index into the array. - * @param instance The reactor instance. - */ - public static String reactorRefName(ReactorInstance instance) { - return instance.uniqueID() + "_self"; - } - - /** - * Return a reference to the "self" struct of the specified - * reactor instance. The returned string has the form - * self[runtimeIndex], where self is the name of the array of self structs - * for this reactor instance. If runtimeIndex is null, then it is replaced by - * the expression returned - * by {@link #runtimeIndex(ReactorInstance)} or 0 if there are no banks. - * @param instance The reactor instance. - * @param runtimeIndex An optional expression to use to address bank members. - * If this is null, the expression used will be that returned by - * {@link #runtimeIndex(ReactorInstance)}. - */ - public static String reactorRef(ReactorInstance instance, String runtimeIndex) { - if (runtimeIndex == null) runtimeIndex = runtimeIndex(instance); - return reactorRefName(instance) + "[" + runtimeIndex + "]"; - } - - /** - * For situations where a reaction reacts to or reads from an output - * of a contained reactor or sends to an input of a contained reactor, - * then the container's self struct will have a field - * (or an array of fields if the contained reactor is a bank) that is - * a struct with fields corresponding to those inputs and outputs. - * This method returns a reference to that struct or array of structs. - * Note that the returned reference is not to the self struct of the - * contained reactor. Use {@link #reactorRef(ReactorInstance)} for that. - * - * @param reactor The contained reactor. - */ - public static String reactorRefNested(ReactorInstance reactor) { - return reactorRefNested(reactor, null, null); - } - - /** - * For situations where a reaction reacts to or reads from an output - * of a contained reactor or sends to an input of a contained reactor, - * then the container's self struct will have a field - * (or an array of fields if the contained reactor is a bank) that is - * a struct with fields corresponding to those inputs and outputs. - * This method returns a reference to that struct or array of structs. - * Note that the returned reference is not to the self struct of the - * contained reactor. Use {@link CUtil#reactorRef(ReactorInstance)} for that. - * - * @param reactor The contained reactor. - * @param runtimeIndex A variable name to use to index the runtime instance or - * null to use the default, the string returned by {@link CUtil#runtimeIndex(ReactorInstance)}. - * @param bankIndex A variable name to use to index the bank or null to use the - * default, the string returned by {@link CUtil#bankIndex(ReactorInstance)}. - */ - public static String reactorRefNested(ReactorInstance reactor, String runtimeIndex, String bankIndex) { - String result = reactorRef(reactor.getParent(), runtimeIndex) + "->_lf_" + reactor.getName(); - if (reactor.isBank()) { - // Need the bank index not the runtimeIndex. - if (bankIndex == null) bankIndex = bankIndex(reactor); - result += "[" + bankIndex + "]"; - } - return result; - } - - /** - * Return an expression that, when evaluated, gives the index of - * a runtime instance of the specified ReactorInstance. If the reactor - * is not within any banks, then this will return "0". Otherwise, it - * will return an expression that evaluates a mixed-radix number - * d0%w0, d1%w1, ... , dn%wn, where n is the depth minus one of the - * reactor. The radixes, w0 to wn, are the widths of this reactor, - * its parent reactor, on up to the top-level reactor. Since the top-level - * reactor is never a bank, dn = 0 and wn = 1. The digits, di, are - * either 0 (of the parent is not a bank) or the variable name returned - * by {@link #bankIndexName(ReactorInstance)} if the parent is a bank. - * The returned expression, when evaluated, will yield the following value: - * - * 
    -     *     d0 + w0 * (d1 + w1 * ( ... (dn-1 + wn-1 * dn) ... )
-     *
    - * - * @param reactor The reactor. - */ - public static String runtimeIndex(ReactorInstance reactor) { - StringBuilder result = new StringBuilder(); - int width = 0; - int parens = 0; - while (reactor != null) { - if (reactor.isBank() && reactor.getWidth() > 1) { - if (width > 0) { - result.append(" + " + width + " * ("); - parens++; - } - result.append(bankIndexName(reactor)); - width = reactor.getWidth(); - } - reactor = reactor.getParent(); - } - while (parens-- > 0) { - result.append(")"); - } - if (result.length() == 0) return "0"; - return result.toString(); - } - - /** - * Return a unique type for the "self" struct of the specified - * reactor class from the reactor class. - * @param reactor The reactor class. - * @return The type of a self struct for the specified reactor class. - */ - public static String selfType(TypeParameterizedReactor reactor) { - if (reactor.reactor().isMain()) { - return "_" + CUtil.getName(reactor) + "_main_self_t"; - } - return "_" + CUtil.getName(reactor) + "_self_t"; - } - - /** Construct a unique type for the "self" struct of the class of the given reactor. */ - public static String selfType(ReactorInstance instance) { - return selfType(instance.tpr); - } - - /** - * Return a reference to the trigger_t struct of the specified - * trigger instance (input port or action). This trigger_t struct - * is on the self struct. - * @param instance The port or action instance. - */ - public static String triggerRef(TriggerInstance instance) { - return triggerRef(instance, null); - } - - /** - * Return a reference to the trigger_t struct of the specified - * trigger instance (input port or action). This trigger_t struct - * is on the self struct. - * @param instance The port or action instance. - * @param runtimeIndex An optional index variable name to use to address runtime instances. - */ - public static String triggerRef(TriggerInstance instance, String runtimeIndex) { - return reactorRef(instance.getParent(), runtimeIndex) - + "->_lf__" - + instance.getName(); - } - - /** - * Return a reference to the trigger_t struct for the specified - * port of a contained reactor. - * @param port The output port of a contained reactor. - */ - public static String triggerRefNested(PortInstance port) { - return triggerRefNested(port, null, null); - } - - /** - * Return a reference to the trigger_t struct for the specified - * port of a contained reactor. - * @param port The output port of a contained reactor. - * @param runtimeIndex An optional index variable name to use to index - * the runtime instance of the port's parent's parent, or null to get the - * default returned by {@link CUtil#runtimeIndex(ReactorInstance)}. - * @param bankIndex An optional index variable name to use to index - * the the bank of the port's parent, or null to get the default returned by - * {@link CUtil#bankIndex(ReactorInstance)}. - */ - public static String triggerRefNested(PortInstance port, String runtimeIndex, String bankIndex) { - return reactorRefNested(port.getParent(), runtimeIndex, bankIndex) + "." + port.getName() + "_trigger"; - } - - - ////////////////////////////////////////////////////// - //// FIXME: Not clear what the strategy is with the following inner interface. - // The {@code ReportCommandErrors} interface allows the - // method runBuildCommand to call a protected - // method from the CGenerator if that method is passed - // using a method reference. The method that is passed - // is then interpreted as a ReportCommandErrors instance. - // This is a convenient way to factor out part of the - // internals of the CGenerator while maintaining - // encapsulation, even though the internals of the CGenerator - // might seem to be tightly coupled. FIXME: Delete this comment - - /** - * A {@code ReportCommandErrors} is a way to analyze command - * output and report any errors that it describes. - * FIXME: If the VSCode branch passes code review - * without significant revision, this mechanism will probably be replaced. - */ - public interface ReportCommandErrors { - void report(String errors); - } - - /** - * Run the custom build command specified with the "build" parameter. - * This command is executed in the same directory as the source file. - *

    - * The following environment variables will be available to the command: - *

      - *
    • {@code: LF_CURRENT_WORKING_DIRECTORY}: The directory in which the command is invoked. - *
    • {@code:LF_SOURCE_DIRECTORY}: The directory containing the .lf file being compiled. - *
    • {@code:LF_PACKAGE_DIRECTORY}: The directory that is the root of the package. - *
    • {@code:LF_SOURCE_GEN_DIRECTORY}: The directory in which generated files are placed. - *
    • {@code:LF_BIN_DIRECTORY}: The directory into which to put binaries. - *
    - */ - public static void runBuildCommand( - FileConfig fileConfig, - TargetConfig targetConfig, - GeneratorCommandFactory commandFactory, - ErrorReporter errorReporter, - ReportCommandErrors reportCommandErrors, - LFGeneratorContext.Mode mode - ) { - List commands = getCommands(targetConfig.buildCommands, commandFactory, fileConfig.srcPath); - // If the build command could not be found, abort. - // An error has already been reported in createCommand. - if (commands.stream().anyMatch(Objects::isNull)) return; - - for (LFCommand cmd : commands) { - int returnCode = cmd.run(); - if (returnCode != 0 && mode != LFGeneratorContext.Mode.EPOCH) { - errorReporter.reportError(String.format( - // FIXME: Why is the content of stderr not provided to the user in this error message? - "Build command \"%s\" failed with error code %d.", - targetConfig.buildCommands, returnCode - )); - return; - } - // For warnings (vs. errors), the return code is 0. - // But we still want to mark the IDE. - if (!cmd.getErrors().toString().isEmpty() && mode == LFGeneratorContext.Mode.EPOCH) { - reportCommandErrors.report(cmd.getErrors().toString()); - return; // FIXME: Why do we return here? Even if there are warnings, the build process should proceed. - } - } - } - - - /** - * Remove files in the bin directory that may have been created. - * Call this if a compilation occurs so that files from a previous - * version do not accidentally get executed. - * @param fileConfig - */ - public static void deleteBinFiles(FileConfig fileConfig) { - String name = FileUtil.nameWithoutExtension(fileConfig.srcFile); - String[] files = fileConfig.binPath.toFile().list(); - List federateNames = new LinkedList<>(); // FIXME: put this in ASTUtils? - fileConfig.resource.getAllContents().forEachRemaining(node -> { - if (node instanceof Reactor r) { + result.append(bankIndexName(reactor)); + width = reactor.getWidth(); + } + reactor = reactor.getParent(); + } + while (parens-- > 0) { + result.append(")"); + } + if (result.length() == 0) return "0"; + return result.toString(); + } + + /** + * Return a unique type for the "self" struct of the specified reactor class from the reactor + * class. + * + * @param reactor The reactor class. + * @return The type of a self struct for the specified reactor class. + */ + public static String selfType(TypeParameterizedReactor reactor) { + if (reactor.reactor().isMain()) { + return "_" + CUtil.getName(reactor) + "_main_self_t"; + } + return "_" + CUtil.getName(reactor) + "_self_t"; + } + + /** Construct a unique type for the "self" struct of the class of the given reactor. */ + public static String selfType(ReactorInstance instance) { + return selfType(instance.tpr); + } + + /** + * Return a reference to the trigger_t struct of the specified trigger instance (input port or + * action). This trigger_t struct is on the self struct. + * + * @param instance The port or action instance. + */ + public static String triggerRef(TriggerInstance instance) { + return triggerRef(instance, null); + } + + /** + * Return a reference to the trigger_t struct of the specified trigger instance (input port or + * action). This trigger_t struct is on the self struct. + * + * @param instance The port or action instance. + * @param runtimeIndex An optional index variable name to use to address runtime instances. + */ + public static String triggerRef( + TriggerInstance instance, String runtimeIndex) { + return reactorRef(instance.getParent(), runtimeIndex) + "->_lf__" + instance.getName(); + } + + /** + * Return a reference to the trigger_t struct for the specified port of a contained reactor. + * + * @param port The output port of a contained reactor. + */ + public static String triggerRefNested(PortInstance port) { + return triggerRefNested(port, null, null); + } + + /** + * Return a reference to the trigger_t struct for the specified port of a contained reactor. + * + * @param port The output port of a contained reactor. + * @param runtimeIndex An optional index variable name to use to index the runtime instance of the + * port's parent's parent, or null to get the default returned by {@link + * CUtil#runtimeIndex(ReactorInstance)}. + * @param bankIndex An optional index variable name to use to index the the bank of the port's + * parent, or null to get the default returned by {@link CUtil#bankIndex(ReactorInstance)}. + */ + public static String triggerRefNested(PortInstance port, String runtimeIndex, String bankIndex) { + return reactorRefNested(port.getParent(), runtimeIndex, bankIndex) + + "." + + port.getName() + + "_trigger"; + } + + ////////////////////////////////////////////////////// + //// FIXME: Not clear what the strategy is with the following inner interface. + // The {@code ReportCommandErrors} interface allows the + // method runBuildCommand to call a protected + // method from the CGenerator if that method is passed + // using a method reference. The method that is passed + // is then interpreted as a ReportCommandErrors instance. + // This is a convenient way to factor out part of the + // internals of the CGenerator while maintaining + // encapsulation, even though the internals of the CGenerator + // might seem to be tightly coupled. FIXME: Delete this comment + + /** + * A {@code ReportCommandErrors} is a way to analyze command output and report any errors that it + * describes. FIXME: If the VSCode branch passes code review without significant revision, this + * mechanism will probably be replaced. + */ + public interface ReportCommandErrors { + void report(String errors); + } + + /** + * Run the custom build command specified with the "build" parameter. This command is executed in + * the same directory as the source file. + * + *

    The following environment variables will be available to the command: + * + *

      + *
    • {@code: LF_CURRENT_WORKING_DIRECTORY}: The directory in which the command is invoked. + *
    • {@code:LF_SOURCE_DIRECTORY}: The directory containing the .lf file being compiled. + *
    • {@code:LF_PACKAGE_DIRECTORY}: The directory that is the root of the package. + *
    • {@code:LF_SOURCE_GEN_DIRECTORY}: The directory in which generated files are placed. + *
    • {@code:LF_BIN_DIRECTORY}: The directory into which to put binaries. + *
    + */ + public static void runBuildCommand( + FileConfig fileConfig, + TargetConfig targetConfig, + GeneratorCommandFactory commandFactory, + ErrorReporter errorReporter, + ReportCommandErrors reportCommandErrors, + LFGeneratorContext.Mode mode) { + List commands = + getCommands(targetConfig.buildCommands, commandFactory, fileConfig.srcPath); + // If the build command could not be found, abort. + // An error has already been reported in createCommand. + if (commands.stream().anyMatch(Objects::isNull)) return; + + for (LFCommand cmd : commands) { + int returnCode = cmd.run(); + if (returnCode != 0 && mode != LFGeneratorContext.Mode.EPOCH) { + errorReporter.reportError( + String.format( + // FIXME: Why is the content of stderr not provided to the user in this error + // message? + "Build command \"%s\" failed with error code %d.", + targetConfig.buildCommands, returnCode)); + return; + } + // For warnings (vs. errors), the return code is 0. + // But we still want to mark the IDE. + if (!cmd.getErrors().toString().isEmpty() && mode == LFGeneratorContext.Mode.EPOCH) { + reportCommandErrors.report(cmd.getErrors().toString()); + return; // FIXME: Why do we return here? Even if there are warnings, the build process + // should proceed. + } + } + } + + /** + * Remove files in the bin directory that may have been created. Call this if a compilation occurs + * so that files from a previous version do not accidentally get executed. + * + * @param fileConfig + */ + public static void deleteBinFiles(FileConfig fileConfig) { + String name = FileUtil.nameWithoutExtension(fileConfig.srcFile); + String[] files = fileConfig.binPath.toFile().list(); + List federateNames = new LinkedList<>(); // FIXME: put this in ASTUtils? + fileConfig + .resource + .getAllContents() + .forEachRemaining( + node -> { + if (node instanceof Reactor r) { if (r.isFederated()) { - r.getInstantiations().forEach(inst -> federateNames - .add(inst.getName())); + r.getInstantiations().forEach(inst -> federateNames.add(inst.getName())); } - } - }); - for (String f : files) { - // Delete executable file or launcher script, if any. - // Delete distribution file, if any. - // Delete RTI file, if any. - if (f.equals(name) || f.equals(name + RTI_BIN_SUFFIX) - || f.equals(name + RTI_DISTRIBUTION_SCRIPT_SUFFIX)) { - //noinspection ResultOfMethodCallIgnored - fileConfig.binPath.resolve(f).toFile().delete(); - } - // Delete federate executable files, if any. - for (String federateName : federateNames) { - if (f.equals(name + "_" + federateName)) { - //noinspection ResultOfMethodCallIgnored - fileConfig.binPath.resolve(f).toFile().delete(); - } - } + } + }); + for (String f : files) { + // Delete executable file or launcher script, if any. + // Delete distribution file, if any. + // Delete RTI file, if any. + if (f.equals(name) + || f.equals(name + RTI_BIN_SUFFIX) + || f.equals(name + RTI_DISTRIBUTION_SCRIPT_SUFFIX)) { + //noinspection ResultOfMethodCallIgnored + fileConfig.binPath.resolve(f).toFile().delete(); + } + // Delete federate executable files, if any. + for (String federateName : federateNames) { + if (f.equals(name + "_" + federateName)) { + //noinspection ResultOfMethodCallIgnored + fileConfig.binPath.resolve(f).toFile().delete(); } - } - - ////////////////////////////////////////////////////// - //// Private functions. - - /** - * If the argument is a multiport, then return a string that - * gives the width as an expression, and otherwise, return null. - * The string will be empty if the width is variable (specified - * as '[]'). Otherwise, if is a single term or a sum of terms - * (separated by '+'), where each term is either an integer - * or a parameter reference in the target language. - */ - public static String multiportWidthExpression(Variable variable) { - List spec = multiportWidthTerms(variable); - return spec == null ? null : String.join(" + ", spec); - } - - ////////////////////////////////////////////////////// - //// Private methods. - - /** - * Convert the given commands from strings to their LFCommand - * representation and return a list of LFCommand. - * @param commands A list of commands as strings. - * @param factory A command factory. - * @param dir The directory in which the commands should be executed. - * @return The LFCommand representations of the given commands, - * where {@code null} is a placeholder for commands that cannot be - * executed. - */ - private static List getCommands(List commands, GeneratorCommandFactory factory, Path dir) { - return commands.stream() - .map(cmd -> List.of(cmd.split("\\s+"))) - .filter(tokens -> tokens.size() > 0) - .map(tokens -> factory.createCommand(tokens.get(0), tokens.subList(1, tokens.size()), dir)) - .collect(Collectors.toList()); - } - - /** - * Return target code for a parameter reference, which in - * this case is just the parameter name. - * - * @param param The parameter to generate code for. - * @return Parameter reference in target code. - */ - private static String getTargetReference(Parameter param) { - return param.getName(); - } - - /** - * If the argument is a multiport, return a list of strings - * describing the width of the port, and otherwise, return null. - * If the list is empty, then the width is variable (specified - * as '[]'). Otherwise, it is a list of integers and/or parameter - * references. - * @param variable The port. - * @return The width specification for a multiport or null if it is - * not a multiport. - */ - private static List multiportWidthTerms(Variable variable) { - List result = null; - if (variable instanceof Port) { - if (((Port) variable).getWidthSpec() != null) { - result = new ArrayList<>(); - if (!((Port) variable).getWidthSpec().isOfVariableLength()) { - for (WidthTerm term : ((Port) variable).getWidthSpec().getTerms()) { - if (term.getParameter() != null) { - result.add(getTargetReference(term.getParameter())); - } else { - result.add(String.valueOf(term.getWidth())); - } - } - } + } + } + } + + ////////////////////////////////////////////////////// + //// Private functions. + + /** + * If the argument is a multiport, then return a string that gives the width as an expression, and + * otherwise, return null. The string will be empty if the width is variable (specified as '[]'). + * Otherwise, if is a single term or a sum of terms (separated by '+'), where each term is either + * an integer or a parameter reference in the target language. + */ + public static String multiportWidthExpression(Variable variable) { + List spec = multiportWidthTerms(variable); + return spec == null ? null : String.join(" + ", spec); + } + + ////////////////////////////////////////////////////// + //// Private methods. + + /** + * Convert the given commands from strings to their LFCommand representation and return a list of + * LFCommand. + * + * @param commands A list of commands as strings. + * @param factory A command factory. + * @param dir The directory in which the commands should be executed. + * @return The LFCommand representations of the given commands, where {@code null} is a + * placeholder for commands that cannot be executed. + */ + private static List getCommands( + List commands, GeneratorCommandFactory factory, Path dir) { + return commands.stream() + .map(cmd -> List.of(cmd.split("\\s+"))) + .filter(tokens -> tokens.size() > 0) + .map(tokens -> factory.createCommand(tokens.get(0), tokens.subList(1, tokens.size()), dir)) + .collect(Collectors.toList()); + } + + /** + * Return target code for a parameter reference, which in this case is just the parameter name. + * + * @param param The parameter to generate code for. + * @return Parameter reference in target code. + */ + private static String getTargetReference(Parameter param) { + return param.getName(); + } + + /** + * If the argument is a multiport, return a list of strings describing the width of the port, and + * otherwise, return null. If the list is empty, then the width is variable (specified as '[]'). + * Otherwise, it is a list of integers and/or parameter references. + * + * @param variable The port. + * @return The width specification for a multiport or null if it is not a multiport. + */ + private static List multiportWidthTerms(Variable variable) { + List result = null; + if (variable instanceof Port) { + if (((Port) variable).getWidthSpec() != null) { + result = new ArrayList<>(); + if (!((Port) variable).getWidthSpec().isOfVariableLength()) { + for (WidthTerm term : ((Port) variable).getWidthSpec().getTerms()) { + if (term.getParameter() != null) { + result.add(getTargetReference(term.getParameter())); + } else { + result.add(String.valueOf(term.getWidth())); } + } } - return result; - } - - /** - * Given a type for an input or output, return true if it should be - * carried by a lf_token_t struct rather than the type itself. - * It should be carried by such a struct if the type ends with * - * (it is a pointer) or [] (it is a array with unspecified length). - * @param type The type specification. - */ - public static boolean isTokenType(InferredType type, CTypes types) { - if (type.isUndefined()) return false; - // This is a hacky way to do this. It is now considered to be a bug (#657) - return type.isVariableSizeList || type.astType != null && (!type.astType.getStars().isEmpty() || - type.astType.getCode() != null && type.astType.getCode().getBody().stripTrailing().endsWith("*")); - } - - public static String generateWidthVariable(String var) { - return var + "_width"; - } - - /** If the type specification of the form {@code type[]}, - * {@code type*}, or {@code type}, return the type. - * @param type A string describing the type. - */ - public static String rootType(String type) { - if (type.endsWith("]")) { - return type.substring(0, type.indexOf("[")).trim(); - } else if (type.endsWith("*")) { - return type.substring(0, type.length() - 1).trim(); - } else { - return type.trim(); - } - } - - /** - * Return the full name of the specified instance without - * the leading name of the top-level reactor, unless this - * is the top-level reactor, in which case return its name. - * @param instance The instance. - * @return A shortened instance name. - */ - public static String getShortenedName(ReactorInstance instance) { - var description = instance.getFullName(); - // If not at the top level, strip off the name of the top level. - var period = description.indexOf("."); - if (period > 0) { - description = description.substring(period + 1); - } - return description; - } + } + } + return result; + } + + /** + * Given a type for an input or output, return true if it should be carried by a lf_token_t struct + * rather than the type itself. It should be carried by such a struct if the type ends with * (it + * is a pointer) or [] (it is a array with unspecified length). + * + * @param type The type specification. + */ + public static boolean isTokenType(InferredType type, CTypes types) { + if (type.isUndefined()) return false; + // This is a hacky way to do this. It is now considered to be a bug (#657) + return type.isVariableSizeList + || type.astType != null + && (!type.astType.getStars().isEmpty() + || type.astType.getCode() != null + && type.astType.getCode().getBody().stripTrailing().endsWith("*")); + } + + public static String generateWidthVariable(String var) { + return var + "_width"; + } + + /** + * If the type specification of the form {@code type[]}, {@code type*}, or {@code type}, return + * the type. + * + * @param type A string describing the type. + */ + public static String rootType(String type) { + if (type.endsWith("]")) { + return type.substring(0, type.indexOf("[")).trim(); + } else if (type.endsWith("*")) { + return type.substring(0, type.length() - 1).trim(); + } else { + return type.trim(); + } + } + + /** + * Return the full name of the specified instance without the leading name of the top-level + * reactor, unless this is the top-level reactor, in which case return its name. + * + * @param instance The instance. + * @return A shortened instance name. + */ + public static String getShortenedName(ReactorInstance instance) { + var description = instance.getFullName(); + // If not at the top level, strip off the name of the top level. + var period = description.indexOf("."); + if (period > 0) { + description = description.substring(period + 1); + } + return description; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java index d403c1cddc..f864ca2661 100644 --- a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java @@ -2,15 +2,15 @@ * @file * @author Benjamin Asch * @author Edward A. Lee - * @copyright (c) 2023, The University of California at Berkeley. - * License: BSD 2-clause + * @copyright (c) 2023, The University of California at Berkeley. License: BSD 2-clause * @brief Code generation methods for watchdogs in C. */ package org.lflang.generator.c; import java.util.List; -import org.lflang.ast.ASTUtils; import org.lflang.ErrorReporter; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.ReactorInstance; import org.lflang.lf.Mode; @@ -21,11 +21,9 @@ import org.lflang.lf.Watchdog; /** - * @brief Generate C code for watchdogs. - * This class contains a collection of static methods supporting code generation in C - * for watchdogs. These methods are protected because they are intended to be used - * only within the same package. - * + * @brief Generate C code for watchdogs. This class contains a collection of static methods + * supporting code generation in C for watchdogs. These methods are protected because they are + * intended to be used only within the same package. * @author Benjamin Asch * @author Edward A. Lee */ @@ -33,6 +31,7 @@ public class CWatchdogGenerator { /** * Return true if the given reactor has one or more watchdogs. + * * @param reactor The reactor. * @return True if the given reactor has watchdogs. */ @@ -46,9 +45,10 @@ public static boolean hasWatchdogs(Reactor reactor) { // Protected methods /** - * For the specified reactor instance, generate initialization code for each watchdog - * in the reactor. This code initializes the watchdog-related fields on the self struct - * of the reactor instance. + * For the specified reactor instance, generate initialization code for each watchdog in the + * reactor. This code initializes the watchdog-related fields on the self struct of the reactor + * instance. + * * @param code The place to put the code * @param instance The reactor instance * @return The count of watchdogs found in the reactor @@ -58,19 +58,24 @@ protected static int generateInitializeWatchdogs(CodeBuilder code, ReactorInstan var temp = new CodeBuilder(); var reactorRef = CUtil.reactorRef(instance); int watchdogCount = 0; - for (Watchdog watchdog - : ASTUtils.allWatchdogs(ASTUtils.toDefinition(instance.getDefinition().getReactorClass()))) { + for (Watchdog watchdog : + ASTUtils.allWatchdogs(ASTUtils.toDefinition(instance.getDefinition().getReactorClass()))) { var watchdogField = reactorRef + "->_lf_watchdog_" + watchdog.getName(); - temp.pr(String.join("\n", - "_lf_watchdogs[watchdog_number++] = &" + watchdogField + ";", - watchdogField + ".min_expiration = " - + CTypes.getInstance().getTargetTimeExpr(instance.getTimeValue(watchdog.getTimeout())) - + ";", - watchdogField + ".thread_active = false;", - "if (" + watchdogField + ".base->reactor_mutex == NULL) {", - " " + watchdogField + ".base->reactor_mutex = (lf_mutex_t*)calloc(1, sizeof(lf_mutex_t));", - "}" - )); + temp.pr( + String.join( + "\n", + "_lf_watchdogs[watchdog_number++] = &" + watchdogField + ";", + watchdogField + + ".min_expiration = " + + CTypes.getInstance() + .getTargetTimeExpr(instance.getTimeValue(watchdog.getTimeout())) + + ";", + watchdogField + ".thread_active = false;", + "if (" + watchdogField + ".base->reactor_mutex == NULL) {", + " " + + watchdogField + + ".base->reactor_mutex = (lf_mutex_t*)calloc(1, sizeof(lf_mutex_t));", + "}")); watchdogCount += 1; foundOne = true; } @@ -92,8 +97,10 @@ protected static int generateInitializeWatchdogs(CodeBuilder code, ReactorInstan * @param tpr The reactor declaration */ protected static void generateWatchdogs( - CodeBuilder src, CodeBuilder header, TypeParameterizedReactor tpr, ErrorReporter errorReporter - ) { + CodeBuilder src, + CodeBuilder header, + TypeParameterizedReactor tpr, + ErrorReporter errorReporter) { if (hasWatchdogs(tpr.reactor())) { header.pr("#include \"core/threaded/watchdog.h\""); for (Watchdog watchdog : ASTUtils.allWatchdogs(tpr.reactor())) { @@ -104,6 +111,7 @@ protected static void generateWatchdogs( /** * Generate watchdog definitions in the reactor's self struct. + * * @param body The place to put the definitions * @param tpr The concrete reactor class * @param constructorCode The place to put initialization code. @@ -135,34 +143,31 @@ protected static void generateWatchdogStruct( + watchdogName + ".trigger = &(self->_lf__" + watchdogName - + ");" - ) - ); + + ");")); } } /** * Generate a global table of watchdog structs. + * * @param count The number of watchdogs found. * @return The code that defines the table or a comment if count is 0. */ protected static String generateWatchdogTable(int count) { if (count == 0) { - return String.join("\n", + return String.join( + "\n", "// No watchdogs found.", "typedef void watchdog_t;", "watchdog_t* _lf_watchdogs = NULL;", - "int _lf_watchdog_count = 0;" - ); + "int _lf_watchdog_count = 0;"); } return String.join( "\n", List.of( "// Array of pointers to watchdog structs.", "watchdog_t* _lf_watchdogs[" + count + "];", - "int _lf_watchdog_count = " + count + ";" - ) - ); + "int _lf_watchdog_count = " + count + ";")); } ///////////////////////////////////////////////////////////////// @@ -175,10 +180,7 @@ protected static String generateWatchdogTable(int count) { * @param tpr The concrete reactor class that has the watchdog */ private static String generateInitializationForWatchdog( - Watchdog watchdog, - TypeParameterizedReactor tpr, - ErrorReporter errorReporter - ) { + Watchdog watchdog, TypeParameterizedReactor tpr, ErrorReporter errorReporter) { // Construct the reactionInitialization code to go into // the body of the function before the verbatim code. @@ -219,14 +221,15 @@ private static String generateInitializationForWatchdog( + name + "_change_type = " + (effect.getTransition() == ModeTransition.HISTORY - ? "history_transition" - : "reset_transition") + ? "history_transition" + : "reset_transition") + ";"); } else { - errorReporter.reportError( - watchdog, - "In generateInitializationForWatchdog(): " + name + " not a valid mode of this reactor." - ); + errorReporter.reportError( + watchdog, + "In generateInitializationForWatchdog(): " + + name + + " not a valid mode of this reactor."); } } } @@ -264,11 +267,9 @@ private static String generateFunction(String header, String init, Watchdog watc return function.toString(); } - /** Generate the watchdog handler function. */ private static String generateWatchdogFunction( - Watchdog watchdog, TypeParameterizedReactor tpr, ErrorReporter errorReporter - ) { + Watchdog watchdog, TypeParameterizedReactor tpr, ErrorReporter errorReporter) { return generateFunction( generateWatchdogFunctionHeader(watchdog, tpr), generateInitializationForWatchdog(watchdog, tpr, errorReporter), @@ -282,7 +283,8 @@ private static String generateWatchdogFunction( * @param tpr The concrete reactor class * @return The function name for the watchdog function. */ - private static String generateWatchdogFunctionHeader(Watchdog watchdog, TypeParameterizedReactor tpr) { + private static String generateWatchdogFunctionHeader( + Watchdog watchdog, TypeParameterizedReactor tpr) { String functionName = watchdogFunctionName(watchdog, tpr); return CReactionGenerator.generateFunctionHeader(functionName); } diff --git a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java index 20ed65687b..16f5ceb565 100644 --- a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java +++ b/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java @@ -5,7 +5,6 @@ import java.util.LinkedList; import java.util.List; import java.util.Set; - import org.lflang.ast.ASTUtils; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; @@ -23,131 +22,125 @@ * @author Soroush Bateni * @author Hou Seng Wong */ - public class InteractingContainedReactors { - /** - * Data structure that for each instantiation of a contained - * reactor. This provides a set of input and output ports that trigger - * reactions of the container, are read by a reaction of the - * container, or that receive data from a reaction of the container. - * For each port, this provides a list of reaction indices that - * are triggered by the port, or an empty list if there are no - * reactions triggered by the port. - */ - // This horrible data structure is a collection, indexed by instantiation - // of a contained reactor, of lists, indexed by ports of the contained reactor - // that are referenced by reactions of the container, of reactions that are - // triggered by the port of the contained reactor. The list is empty if - // the port does not trigger reactions but is read by the reaction or - // is written to by the reaction. - LinkedHashMap< - Instantiation, LinkedHashMap< - Port, LinkedList - > - > portsByContainedReactor = new LinkedHashMap<>(); + /** + * Data structure that for each instantiation of a contained reactor. This provides a set of input + * and output ports that trigger reactions of the container, are read by a reaction of the + * container, or that receive data from a reaction of the container. For each port, this provides + * a list of reaction indices that are triggered by the port, or an empty list if there are no + * reactions triggered by the port. + */ + // This horrible data structure is a collection, indexed by instantiation + // of a contained reactor, of lists, indexed by ports of the contained reactor + // that are referenced by reactions of the container, of reactions that are + // triggered by the port of the contained reactor. The list is empty if + // the port does not trigger reactions but is read by the reaction or + // is written to by the reaction. + LinkedHashMap>> portsByContainedReactor = + new LinkedHashMap<>(); - /** - * Scan the reactions of the specified reactor and record which ports are - * referenced by reactions and which reactions are triggered by such ports. - */ - public InteractingContainedReactors(Reactor reactor) { - var reactionCount = 0; - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - // First, handle reactions that produce data sent to inputs - // of contained reactors. - for (VarRef effect : ASTUtils.convertToEmptyListIfNull(reaction.getEffects())) { - // If an effect is an input, then it must be an input - // of a contained reactor. - if (effect.getVariable() instanceof Input) { - // This reaction is not triggered by the port, so - // we do not add it to the list returned by the following. - addPort(effect.getContainer(), (Input) effect.getVariable()); - } - } - // Second, handle reactions that are triggered by outputs - // of contained reactors. - for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - // If an trigger is an output, then it must be an output - // of a contained reactor. - if (triggerAsVarRef.getVariable() instanceof Output) { - var list = addPort(triggerAsVarRef.getContainer(), (Output) triggerAsVarRef.getVariable()); - list.add(reactionCount); - } - } - } - // Third, handle reading (but not triggered by) - // outputs of contained reactors. - for (VarRef source : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { - if (source.getVariable() instanceof Output) { - // If an source is an output, then it must be an output - // of a contained reactor. - // This reaction is not triggered by the port, so - // we do not add it to the list returned by the following. - addPort(source.getContainer(), (Output) source.getVariable()); - } - } - // Increment the reaction count even if not in the federate for consistency. - reactionCount++; + /** + * Scan the reactions of the specified reactor and record which ports are referenced by reactions + * and which reactions are triggered by such ports. + */ + public InteractingContainedReactors(Reactor reactor) { + var reactionCount = 0; + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // First, handle reactions that produce data sent to inputs + // of contained reactors. + for (VarRef effect : ASTUtils.convertToEmptyListIfNull(reaction.getEffects())) { + // If an effect is an input, then it must be an input + // of a contained reactor. + if (effect.getVariable() instanceof Input) { + // This reaction is not triggered by the port, so + // we do not add it to the list returned by the following. + addPort(effect.getContainer(), (Input) effect.getVariable()); + } + } + // Second, handle reactions that are triggered by outputs + // of contained reactors. + for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { + // If an trigger is an output, then it must be an output + // of a contained reactor. + if (triggerAsVarRef.getVariable() instanceof Output) { + var list = + addPort(triggerAsVarRef.getContainer(), (Output) triggerAsVarRef.getVariable()); + list.add(reactionCount); + } + } + } + // Third, handle reading (but not triggered by) + // outputs of contained reactors. + for (VarRef source : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { + if (source.getVariable() instanceof Output) { + // If an source is an output, then it must be an output + // of a contained reactor. + // This reaction is not triggered by the port, so + // we do not add it to the list returned by the following. + addPort(source.getContainer(), (Output) source.getVariable()); } + } + // Increment the reaction count even if not in the federate for consistency. + reactionCount++; } + } - /** - * Return or create the list to which reactions triggered by the specified port - * are to be added. This also records that the port is referenced by the - * container's reactions. - * @param containedReactor The contained reactor. - * @param port The port. - */ - private List addPort(Instantiation containedReactor, Port port) { - // Get or create the entry for the containedReactor. - var containedReactorEntry = portsByContainedReactor.computeIfAbsent( - containedReactor, - k -> new LinkedHashMap<>() - ); - // Get or create the entry for the port. - return containedReactorEntry.computeIfAbsent(port, k -> new LinkedList<>()); - } + /** + * Return or create the list to which reactions triggered by the specified port are to be added. + * This also records that the port is referenced by the container's reactions. + * + * @param containedReactor The contained reactor. + * @param port The port. + */ + private List addPort(Instantiation containedReactor, Port port) { + // Get or create the entry for the containedReactor. + var containedReactorEntry = + portsByContainedReactor.computeIfAbsent(containedReactor, k -> new LinkedHashMap<>()); + // Get or create the entry for the port. + return containedReactorEntry.computeIfAbsent(port, k -> new LinkedList<>()); + } - /** - * Return the set of contained reactors that have ports that are referenced - * by reactions of the container reactor. - */ - public Set containedReactors() { - return portsByContainedReactor.keySet(); - } + /** + * Return the set of contained reactors that have ports that are referenced by reactions of the + * container reactor. + */ + public Set containedReactors() { + return portsByContainedReactor.keySet(); + } - /** - * Return the set of ports of the specified contained reactor that are - * referenced by reactions of the container reactor. Return an empty - * set if there are none. - * @param containedReactor The contained reactor. - */ - public Set portsOfInstance(Instantiation containedReactor) { - Set result = null; - var ports = portsByContainedReactor.get(containedReactor); - if (ports == null) { - result = new LinkedHashSet<>(); - } else { - result = ports.keySet(); - } - return result; + /** + * Return the set of ports of the specified contained reactor that are referenced by reactions of + * the container reactor. Return an empty set if there are none. + * + * @param containedReactor The contained reactor. + */ + public Set portsOfInstance(Instantiation containedReactor) { + Set result = null; + var ports = portsByContainedReactor.get(containedReactor); + if (ports == null) { + result = new LinkedHashSet<>(); + } else { + result = ports.keySet(); } + return result; + } - /** - * Return the indices of the reactions triggered by the specified port - * of the specified contained reactor or an empty list if there are none. - * @param containedReactor The contained reactor. - * @param port The port. - */ - public List reactionsTriggered(Instantiation containedReactor, Port port) { - var ports = portsByContainedReactor.get(containedReactor); - if (ports != null) { - var list = ports.get(port); - if (list != null) { - return list; - } - } - return new LinkedList<>(); + /** + * Return the indices of the reactions triggered by the specified port of the specified contained + * reactor or an empty list if there are none. + * + * @param containedReactor The contained reactor. + * @param port The port. + */ + public List reactionsTriggered(Instantiation containedReactor, Port port) { + var ports = portsByContainedReactor.get(containedReactor); + if (ports != null) { + var list = ports.get(port); + if (list != null) { + return list; + } } + return new LinkedList<>(); + } } diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 5f832e692a..c5e062399b 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -1,12 +1,10 @@ package org.lflang.generator.c; - import java.util.HashMap; import java.util.Map; import java.util.stream.Collectors; - -import org.lflang.ast.ASTUtils; import org.lflang.InferredType; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.Instantiation; import org.lflang.lf.Reactor; @@ -14,62 +12,79 @@ /** * A reactor class combined with concrete type arguments bound to its type parameters. + * * @param reactor The syntactic reactor class definition * @param typeArgs The type arguments associated with this particular variant of the reactor class. */ public record TypeParameterizedReactor(Reactor reactor, Map typeArgs) { - public TypeParameterizedReactor(Instantiation i) { - this(ASTUtils.toDefinition(i.getReactorClass()), addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()))); - } + public TypeParameterizedReactor(Instantiation i) { + this( + ASTUtils.toDefinition(i.getReactorClass()), + addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()))); + } - private static Map addTypeArgs(Instantiation instantiation, Reactor r) { - HashMap ret = new HashMap<>(); - if (instantiation.getTypeArgs() != null) { - for (int i = 0; i < r.getTypeParms().size(); i++) { - ret.put(r.getTypeParms().get(i).getLiteral(), instantiation.getTypeArgs().get(i)); - } - } - return ret; + private static Map addTypeArgs(Instantiation instantiation, Reactor r) { + HashMap ret = new HashMap<>(); + if (instantiation.getTypeArgs() != null) { + for (int i = 0; i < r.getTypeParms().size(); i++) { + ret.put(r.getTypeParms().get(i).getLiteral(), instantiation.getTypeArgs().get(i)); + } } + return ret; + } - /** Return the name of the reactor given its type arguments. */ - public String getName() { - // FIXME: Types that are not just a single token need to be escaped or hashed - return reactor.getName() + typeArgs.values().stream().map(ASTUtils::toOriginalText).collect(Collectors.joining("_")); - } + /** Return the name of the reactor given its type arguments. */ + public String getName() { + // FIXME: Types that are not just a single token need to be escaped or hashed + return reactor.getName() + + typeArgs.values().stream().map(ASTUtils::toOriginalText).collect(Collectors.joining("_")); + } - /** #define type names as concrete types. */ - public void doDefines(CodeBuilder b) { - typeArgs.forEach((literal, concreteType) -> b.pr( - "#if defined " + literal + "\n" + - "#undef " + literal + "\n" + - "#endif // " + literal + "\n" + - "#define " + literal + " " + ASTUtils.toOriginalText(concreteType))); - } + /** #define type names as concrete types. */ + public void doDefines(CodeBuilder b) { + typeArgs.forEach( + (literal, concreteType) -> + b.pr( + "#if defined " + + literal + + "\n" + + "#undef " + + literal + + "\n" + + "#endif // " + + literal + + "\n" + + "#define " + + literal + + " " + + ASTUtils.toOriginalText(concreteType))); + } - /** Resolve type arguments if the given type is defined in terms of generics. */ - public Type resolveType(Type t) { - if (t.getId() != null && typeArgs.get(t.getId()) != null) return typeArgs.get(t.getId()); - if (t.getCode() == null) return t; - var arg = typeArgs.get(t.getCode().getBody()); - if (arg != null) return arg; - return t; - } + /** Resolve type arguments if the given type is defined in terms of generics. */ + public Type resolveType(Type t) { + if (t.getId() != null && typeArgs.get(t.getId()) != null) return typeArgs.get(t.getId()); + if (t.getCode() == null) return t; + var arg = typeArgs.get(t.getCode().getBody()); + if (arg != null) return arg; + return t; + } - /** Resolve type arguments if the given type is defined in terms of generics. */ - public InferredType resolveType(InferredType t) { - if (t.astType == null) return t; - return InferredType.fromAST(resolveType(t.astType)); - } + /** Resolve type arguments if the given type is defined in terms of generics. */ + public InferredType resolveType(InferredType t) { + if (t.astType == null) return t; + return InferredType.fromAST(resolveType(t.astType)); + } - @Override - public int hashCode() { - return Math.abs(reactor.hashCode() * 31 + typeArgs.hashCode()); - } + @Override + public int hashCode() { + return Math.abs(reactor.hashCode() * 31 + typeArgs.hashCode()); + } - @Override - public boolean equals(Object obj) { - return obj instanceof TypeParameterizedReactor other && reactor.equals(other.reactor) && typeArgs.equals(other.typeArgs); - } + @Override + public boolean equals(Object obj) { + return obj instanceof TypeParameterizedReactor other + && reactor.equals(other.reactor) + && typeArgs.equals(other.typeArgs); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PyFileConfig.java b/org.lflang/src/org/lflang/generator/python/PyFileConfig.java index bb6a9e9796..7c67b92493 100644 --- a/org.lflang/src/org/lflang/generator/python/PyFileConfig.java +++ b/org.lflang/src/org/lflang/generator/python/PyFileConfig.java @@ -3,33 +3,29 @@ import java.io.IOException; import java.nio.file.Path; import java.util.List; - import org.eclipse.emf.ecore.resource.Resource; - -import org.lflang.FileConfig; import org.lflang.generator.c.CFileConfig; import org.lflang.util.LFCommand; public class PyFileConfig extends CFileConfig { - public PyFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) throws IOException { - super(resource, srcGenBasePath, useHierarchicalBin); - } + public PyFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) + throws IOException { + super(resource, srcGenBasePath, useHierarchicalBin); + } - @Override - public LFCommand getCommand() { - return LFCommand.get("python3", - List.of(srcPkgPath.relativize(getExecutable()).toString()), - true, - srcPkgPath); - } + @Override + public LFCommand getCommand() { + return LFCommand.get( + "python3", List.of(srcPkgPath.relativize(getExecutable()).toString()), true, srcPkgPath); + } - @Override - public Path getExecutable() { - return srcGenPath.resolve(name + getExecutableExtension()); - } + @Override + public Path getExecutable() { + return srcGenPath.resolve(name + getExecutableExtension()); + } - @Override - protected String getExecutableExtension() { - return ".py"; - } + @Override + protected String getExecutableExtension() { + return ".py"; + } } diff --git a/org.lflang/src/org/lflang/generator/python/PyUtil.java b/org.lflang/src/org/lflang/generator/python/PyUtil.java index 48cc8f9e10..35aeed6fbb 100644 --- a/org.lflang/src/org/lflang/generator/python/PyUtil.java +++ b/org.lflang/src/org/lflang/generator/python/PyUtil.java @@ -1,28 +1,28 @@ /* Utilities for Python code generation. */ /************* -Copyright (c) 2019-2021, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2021, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator.python; @@ -31,116 +31,126 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.generator.c.CUtil; import org.lflang.lf.Expression; - /** - * A collection of utilities for Python code generation. - * This class inherits from CUtil but overrides a few methods to - * codify the coding conventions for the Python target code generator. + * A collection of utilities for Python code generation. This class inherits from CUtil but + * overrides a few methods to codify the coding conventions for the Python target code generator. * I.e., it defines how some variables are named and referenced. + * * @author Edward A. Lee * @author Soroush Bateni */ public class PyUtil extends CUtil { - /** - * Return the name of the list of Python class instances that contains the - * specified reactor instance. This is similar to - * {@link #reactorRef(ReactorInstance)} except that it does not index into - * the list. - * - * @param instance The reactor instance. - */ - public static String reactorRefName(ReactorInstance instance) { - return instance.uniqueID() + "_lf"; - } - - /** - * Return a reference to the list of Python class instances that contains - * the specified reactor instance. The returned string has the form - * list_name[runtimeIndex], where list_name is the name of the list of - * Python class instances that contains this reactor instance. If - * runtimeIndex is null, then it is replaced by the expression returned by - * {@link runtimeIndex(ReactorInstance)} or 0 if there are no banks. - * - * @param instance The reactor instance. - * @param runtimeIndex An optional expression to use to address bank - * members. If this is null, the expression used will be - * that returned by - * {@link #runtimeIndex(ReactorInstance)}. - */ - public static String reactorRef(ReactorInstance instance, String runtimeIndex) { - if (runtimeIndex == null) runtimeIndex = runtimeIndex(instance); - return PyUtil.reactorRefName(instance) + "[" + runtimeIndex + "]"; - } - - /** - * Return a reference to the list of Python class instances that contains - * the specified reactor instance. The returned string has the form - * list_name[j], where list_name is the name of the list of of Python class - * instances that contains this reactor instance and j is the expression - * returned by {@link #runtimeIndex(ReactorInstance)} or 0 if there are no - * banks. - * - * @param instance The reactor instance. - */ - public static String reactorRef(ReactorInstance instance) { - return PyUtil.reactorRef(instance, null); - } - - /** - * Convert C types to formats used in Py_BuildValue and PyArg_PurseTuple. - * This is unused but will be useful to enable inter-compatibility between - * C and Python reactors. - * @param type C type - */ - public static String pyBuildValueArgumentType(String type) { - switch (type) { - case "int": return "i"; - case "string": return "s"; - case "char": return "b"; - case "short int": return "h"; - case "long": return "l"; - case "unsigned char": return "B"; - case "unsigned short int": return "H"; - case "unsigned int": return "I"; - case "unsigned long": return "k"; - case "long long": return "L"; - case "interval_t": return "L"; - case "unsigned long long": return "K"; - case "double": return "d"; - case "float": return "f"; - case "Py_complex": return "D"; - case "Py_complex*": return "D"; - case "Py_Object": return "O"; - case "Py_Object*": return "O"; - default: return "O"; - } - } - - public static String generateGILAcquireCode() { - return String.join("\n", - "// Acquire the GIL (Global Interpreter Lock) to be able to call Python APIs.", - "PyGILState_STATE gstate;", - "gstate = PyGILState_Ensure();" - ); - } - - public static String generateGILReleaseCode() { - return String.join("\n", - "/* Release the thread. No Python API allowed beyond this point. */", - "PyGILState_Release(gstate);" - ); - } - - /** - * Override to convert some C types to their - * Python equivalent. - * Examples: - * true/false -> True/False - * @param expr A value - * @return A value string in the target language - */ - protected static String getPythonTargetValue(Expression expr) { - return PythonTypes.getInstance().getTargetExpr(expr, InferredType.undefined()); + /** + * Return the name of the list of Python class instances that contains the specified reactor + * instance. This is similar to {@link #reactorRef(ReactorInstance)} except that it does not index + * into the list. + * + * @param instance The reactor instance. + */ + public static String reactorRefName(ReactorInstance instance) { + return instance.uniqueID() + "_lf"; + } + + /** + * Return a reference to the list of Python class instances that contains the specified reactor + * instance. The returned string has the form list_name[runtimeIndex], where list_name is the name + * of the list of Python class instances that contains this reactor instance. If runtimeIndex is + * null, then it is replaced by the expression returned by {@link runtimeIndex(ReactorInstance)} + * or 0 if there are no banks. + * + * @param instance The reactor instance. + * @param runtimeIndex An optional expression to use to address bank members. If this is null, the + * expression used will be that returned by {@link #runtimeIndex(ReactorInstance)}. + */ + public static String reactorRef(ReactorInstance instance, String runtimeIndex) { + if (runtimeIndex == null) runtimeIndex = runtimeIndex(instance); + return PyUtil.reactorRefName(instance) + "[" + runtimeIndex + "]"; + } + + /** + * Return a reference to the list of Python class instances that contains the specified reactor + * instance. The returned string has the form list_name[j], where list_name is the name of the + * list of of Python class instances that contains this reactor instance and j is the expression + * returned by {@link #runtimeIndex(ReactorInstance)} or 0 if there are no banks. + * + * @param instance The reactor instance. + */ + public static String reactorRef(ReactorInstance instance) { + return PyUtil.reactorRef(instance, null); + } + + /** + * Convert C types to formats used in Py_BuildValue and PyArg_PurseTuple. This is unused but will + * be useful to enable inter-compatibility between C and Python reactors. + * + * @param type C type + */ + public static String pyBuildValueArgumentType(String type) { + switch (type) { + case "int": + return "i"; + case "string": + return "s"; + case "char": + return "b"; + case "short int": + return "h"; + case "long": + return "l"; + case "unsigned char": + return "B"; + case "unsigned short int": + return "H"; + case "unsigned int": + return "I"; + case "unsigned long": + return "k"; + case "long long": + return "L"; + case "interval_t": + return "L"; + case "unsigned long long": + return "K"; + case "double": + return "d"; + case "float": + return "f"; + case "Py_complex": + return "D"; + case "Py_complex*": + return "D"; + case "Py_Object": + return "O"; + case "Py_Object*": + return "O"; + default: + return "O"; } + } + + public static String generateGILAcquireCode() { + return String.join( + "\n", + "// Acquire the GIL (Global Interpreter Lock) to be able to call Python APIs.", + "PyGILState_STATE gstate;", + "gstate = PyGILState_Ensure();"); + } + + public static String generateGILReleaseCode() { + return String.join( + "\n", + "/* Release the thread. No Python API allowed beyond this point. */", + "PyGILState_Release(gstate);"); + } + + /** + * Override to convert some C types to their Python equivalent. Examples: true/false -> True/False + * + * @param expr A value + * @return A value string in the target language + */ + protected static String getPythonTargetValue(Expression expr) { + return PythonTypes.getInstance().getTargetExpr(expr, InferredType.undefined()); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java index 13dbed0f0f..5270a4d69e 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java @@ -1,14 +1,17 @@ package org.lflang.generator.python; +import org.lflang.generator.c.CGenerator; import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; -import org.lflang.lf.Reactor; -import org.lflang.generator.c.CGenerator; public class PythonActionGenerator { - public static String generateAliasTypeDef(TypeParameterizedReactor tpr, Action action, - String genericActionType) { + public static String generateAliasTypeDef( + TypeParameterizedReactor tpr, Action action, String genericActionType) { - return "typedef "+genericActionType+" "+CGenerator.variableStructType(action, tpr, false)+";"; - } + return "typedef " + + genericActionType + + " " + + CGenerator.variableStructType(action, tpr, false) + + ";"; + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java index b69cfc7da0..6171f3ca40 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java @@ -1,6 +1,5 @@ package org.lflang.generator.python; - import org.lflang.ast.ASTUtils; import org.lflang.generator.c.CDelayBodyGenerator; import org.lflang.generator.c.CUtil; @@ -10,69 +9,74 @@ public class PythonDelayBodyGenerator extends CDelayBodyGenerator { - public PythonDelayBodyGenerator(PythonTypes types) { - super(types); - } + public PythonDelayBodyGenerator(PythonTypes types) { + super(types); + } - /** - * Generate code for the body of a reaction that takes an input and - * schedules an action with the value of that input. - * @param action The action to schedule - * @param port The port to read from - */ - @Override - public String generateDelayBody(Action action, VarRef port) { - boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(action), types); - String ref = ASTUtils.generateVarRef(port); - // Note that the action.type set by the base class is actually - // the port type. - if (isTokenType) { - return String.join("\n", - "if ("+ref+"->is_present) {", - " // Put the whole token on the event queue, not just the payload.", - " // This way, the length and element_size are transported.", - " lf_schedule_token("+action.getName()+", 0, "+ref+"->token);", - "}" - ); - } else { - return String.join("\n", - "// Create a token.", - "#if NUMBER_OF_WORKERS > 0", - "// Need to lock the mutex first.", - "lf_mutex_lock(&mutex);", - "#endif", - "lf_token_t* t = _lf_new_token((token_type_t*)"+action.getName()+", self->_lf_"+ref+"->value, 1);", - "#if NUMBER_OF_WORKERS > 0", - "lf_mutex_unlock(&mutex);", - "#endif", - "", - "// Pass the token along", - "lf_schedule_token("+action.getName()+", 0, t);" - ); - } + /** + * Generate code for the body of a reaction that takes an input and schedules an action with the + * value of that input. + * + * @param action The action to schedule + * @param port The port to read from + */ + @Override + public String generateDelayBody(Action action, VarRef port) { + boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(action), types); + String ref = ASTUtils.generateVarRef(port); + // Note that the action.type set by the base class is actually + // the port type. + if (isTokenType) { + return String.join( + "\n", + "if (" + ref + "->is_present) {", + " // Put the whole token on the event queue, not just the payload.", + " // This way, the length and element_size are transported.", + " lf_schedule_token(" + action.getName() + ", 0, " + ref + "->token);", + "}"); + } else { + return String.join( + "\n", + "// Create a token.", + "#if NUMBER_OF_WORKERS > 0", + "// Need to lock the mutex first.", + "lf_mutex_lock(&mutex);", + "#endif", + "lf_token_t* t = _lf_new_token((token_type_t*)" + + action.getName() + + ", self->_lf_" + + ref + + "->value, 1);", + "#if NUMBER_OF_WORKERS > 0", + "lf_mutex_unlock(&mutex);", + "#endif", + "", + "// Pass the token along", + "lf_schedule_token(" + action.getName() + ", 0, t);"); } + } - /** - * Generate code for the body of a reaction that is triggered by the - * given action and writes its value to the given port. This realizes - * the receiving end of a logical delay specified with the 'after' - * keyword. - * @param action The action that triggers the reaction - * @param port The port to write to. - */ - @Override - public String generateForwardBody(Action action, VarRef port) { - String outputName = ASTUtils.generateVarRef(port); - if (CUtil.isTokenType(ASTUtils.getInferredType(action), types)) { - return super.generateForwardBody(action, port); - } else { - return "lf_set("+outputName+", "+action.getName()+"->token->value);"; - } + /** + * Generate code for the body of a reaction that is triggered by the given action and writes its + * value to the given port. This realizes the receiving end of a logical delay specified with the + * 'after' keyword. + * + * @param action The action that triggers the reaction + * @param port The port to write to. + */ + @Override + public String generateForwardBody(Action action, VarRef port) { + String outputName = ASTUtils.generateVarRef(port); + if (CUtil.isTokenType(ASTUtils.getInferredType(action), types)) { + return super.generateForwardBody(action, port); + } else { + return "lf_set(" + outputName + ", " + action.getName() + "->token->value);"; } + } - @Override - public void finalizeReactions(Reaction delayReaction, Reaction forwardReaction) { - ASTUtils.addReactionAttribute(delayReaction, "_c_body"); - ASTUtils.addReactionAttribute(forwardReaction, "_c_body"); - } + @Override + public void finalizeReactions(Reaction delayReaction, Reaction forwardReaction) { + ASTUtils.addReactionAttribute(delayReaction, "_c_body"); + ASTUtils.addReactionAttribute(forwardReaction, "_c_body"); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonDockerGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonDockerGenerator.java index ed69ac01fc..9d1bf0fcd4 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonDockerGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonDockerGenerator.java @@ -1,7 +1,5 @@ - package org.lflang.generator.python; -import org.lflang.TargetConfig; import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.c.CDockerGenerator; @@ -11,26 +9,25 @@ * @author Hou Seng Wong */ public class PythonDockerGenerator extends CDockerGenerator { - final String defaultBaseImage = "python:slim"; + final String defaultBaseImage = "python:slim"; - public PythonDockerGenerator(LFGeneratorContext context) { - super(context); - } + public PythonDockerGenerator(LFGeneratorContext context) { + super(context); + } - /** - * Generates the contents of the docker file. - */ - @Override - protected String generateDockerFileContent() { - var baseImage = defaultBaseImage; - return String.join("\n", - "# For instructions, see: https://www.lf-lang.org/docs/handbook/containerized-execution?target=py", - "FROM "+baseImage, - "WORKDIR /lingua-franca/"+context.getFileConfig().name, - "RUN set -ex && apt-get update && apt-get install -y python3-pip && pip install cmake", - "COPY . src-gen", - super.generateDefaultCompileCommand(), - "ENTRYPOINT [\"python3\", \"src-gen/"+context.getFileConfig().name+".py\"]" - ); - } + /** Generates the contents of the docker file. */ + @Override + protected String generateDockerFileContent() { + var baseImage = defaultBaseImage; + return String.join( + "\n", + "# For instructions, see:" + + " https://www.lf-lang.org/docs/handbook/containerized-execution?target=py", + "FROM " + baseImage, + "WORKDIR /lingua-franca/" + context.getFileConfig().name, + "RUN set -ex && apt-get update && apt-get install -y python3-pip && pip install cmake", + "COPY . src-gen", + super.generateDefaultCompileCommand(), + "ENTRYPOINT [\"python3\", \"src-gen/" + context.getFileConfig().name + ".py\"]"); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java index 83053d6897..91fdfaffad 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonGenerator.java @@ -34,17 +34,14 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; - -import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.Target; import org.lflang.TargetProperty; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.CodeMap; - import org.lflang.generator.GeneratorResult; import org.lflang.generator.IntegratedBuilder; import org.lflang.generator.LFGeneratorContext; @@ -66,530 +63,516 @@ import org.lflang.util.LFCommand; import org.lflang.util.StringUtil; - /** - * Generator for Python target. This class generates Python code defining each - * reactor - * class given in the input .lf file and imported .lf files. + * Generator for Python target. This class generates Python code defining each reactor class given + * in the input .lf file and imported .lf files. * - * Each class will contain all the reaction functions defined by the user in - * order, with the necessary ports/actions given as parameters. - * Moreover, each class will contain all state variables in native Python - * format. + *

    Each class will contain all the reaction functions defined by the user in order, with the + * necessary ports/actions given as parameters. Moreover, each class will contain all state + * variables in native Python format. * - * A backend is also generated using the CGenerator that interacts with the C - * code library (see CGenerator.xtend). - * The backend is responsible for passing arguments to the Python reactor + *

    A backend is also generated using the CGenerator that interacts with the C code library (see + * CGenerator.xtend). The backend is responsible for passing arguments to the Python reactor * functions. * * @author Soroush Bateni */ public class PythonGenerator extends CGenerator { - // Used to add statements that come before reactor classes and user code - private final CodeBuilder pythonPreamble = new CodeBuilder(); - - // Used to add module requirements to setup.py (delimited with ,) - private final List pythonRequiredModules = new ArrayList<>(); - - private final PythonTypes types; - - public PythonGenerator(LFGeneratorContext context) { - this(context, - new PythonTypes(), - new CCmakeGenerator( - context.getFileConfig(), - List.of("lib/python_action.c", - "lib/python_port.c", - "lib/python_tag.c", - "lib/python_time.c", - "lib/pythontarget.c" - ), - PythonGenerator::setUpMainTarget, - "install(TARGETS)" // No-op - ) - ); - } - - - private PythonGenerator(LFGeneratorContext context, PythonTypes types, CCmakeGenerator cmakeGenerator) { - super(context, false, types, cmakeGenerator, new PythonDelayBodyGenerator(types)); - this.targetConfig.compiler = "gcc"; - this.targetConfig.compilerFlags = new ArrayList<>(); - this.targetConfig.linkerFlags = ""; - this.types = types; - } - - /** - * Generic struct for ports with primitive types and - * statically allocated arrays in Lingua Franca. - * This template is defined as - * typedef struct { - * bool is_present; - * lf_sparse_io_record_t* sparse_record; // NULL if there is no sparse record. - * int destination_channel; // -1 if there is no destination. - * PyObject* value; - * int num_destinations; - * lf_token_t* token; - * int length; - * void (*destructor) (void* value); - * void* (*copy_constructor) (void* value); - * FEDERATED_GENERIC_EXTENSION - * } generic_port_instance_struct; - * - * See reactor-c/python/lib/pythontarget.h for details. - */ - String genericPortType = "generic_port_instance_struct"; - - /** - * Generic struct for actions. - * This template is defined as - * typedef struct { - * trigger_t* trigger; - * PyObject* value; - * bool is_present; - * bool has_value; - * lf_token_t* token; - * FEDERATED_CAPSULE_EXTENSION - * } generic_action_instance_struct; - * - * See reactor-c/python/lib/pythontarget.h for details. - */ - String genericActionType = "generic_action_instance_struct"; - - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.Python; - } - - private final Set protoNames = new HashSet<>(); - - // ////////////////////////////////////////// - // // Public methods - @Override - public TargetTypes getTargetTypes() { - return types; - } - - // ////////////////////////////////////////// - // // Protected methods - - /** - * Generate all Python classes if they have a reaction - * - */ - public String generatePythonReactorClasses() { - CodeBuilder pythonClasses = new CodeBuilder(); - CodeBuilder pythonClassesInstantiation = new CodeBuilder(); - - // Generate reactor classes in Python - pythonClasses.pr(PythonReactorGenerator.generatePythonClass(main, main, types)); - - // Create empty lists to hold reactor instances - pythonClassesInstantiation.pr(PythonReactorGenerator.generateListsToHoldClassInstances(main)); - - // Instantiate generated classes - pythonClassesInstantiation.pr(PythonReactorGenerator.generatePythonClassInstantiations(main, main)); - - return String.join("\n", - pythonClasses.toString(), - "", - "# Instantiate classes", - pythonClassesInstantiation.toString() - ); - } - - /** - * Generate the Python code constructed from reactor classes and - * user-written classes. - * - * @return the code body - */ - public String generatePythonCode(String pyModuleName) { - return String.join("\n", - "import os", - "import sys", - "sys.path.append(os.path.dirname(__file__))", - "# List imported names, but do not use pylint's --extension-pkg-allow-list option", - "# so that these names will be assumed present without having to compile and install.", - "# pylint: disable=no-name-in-module, import-error", - "from "+pyModuleName+" import (", - " Tag, action_capsule_t, port_capsule, request_stop, schedule_copy, start", - ")", - "# pylint: disable=c-extension-no-member", - "import "+pyModuleName+" as lf", - "try:", - " from LinguaFrancaBase.constants import BILLION, FOREVER, NEVER, instant_t, interval_t", - " from LinguaFrancaBase.functions import (", - " DAY, DAYS, HOUR, HOURS, MINUTE, MINUTES, MSEC, MSECS, NSEC, NSECS, SEC, SECS, USEC,", - " USECS, WEEK, WEEKS", - " )", - " from LinguaFrancaBase.classes import Make", - "except ModuleNotFoundError:", - " print(\"No module named 'LinguaFrancaBase'. \"", - " \"Install using \\\"pip3 install LinguaFrancaBase\\\".\")", - " sys.exit(1)", - "import copy", - "", - pythonPreamble.toString(), - "", - generatePythonReactorClasses(), - "", - PythonMainFunctionGenerator.generateCode() - ); - } - - /** - * Generate the necessary Python files. - */ - public Map generatePythonFiles( - String lfModuleName, - String pyModuleName, - String pyFileName - ) throws IOException { - Path filePath = fileConfig.getSrcGenPath().resolve(pyFileName); - File file = filePath.toFile(); - Files.deleteIfExists(filePath); - // Create the necessary directories - if (!file.getParentFile().exists()) { - if (!file.getParentFile().mkdirs()) { - throw new IOException( - "Failed to create directories required for the Python code generator." - ); - } - } - Map codeMaps = new HashMap<>(); - codeMaps.put(filePath, CodeMap.fromGeneratedCode( - generatePythonCode(pyModuleName))); - FileUtil.writeToFile(codeMaps.get(filePath).getGeneratedCode(), filePath); - return codeMaps; - } - - /** - * Generate code that needs to appear at the top of the generated - * C file, such as #define and #include statements. - */ - @Override - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr(PythonPreambleGenerator.generateCDefineDirectives( + // Used to add statements that come before reactor classes and user code + private final CodeBuilder pythonPreamble = new CodeBuilder(); + + // Used to add module requirements to setup.py (delimited with ,) + private final List pythonRequiredModules = new ArrayList<>(); + + private final PythonTypes types; + + public PythonGenerator(LFGeneratorContext context) { + this( + context, + new PythonTypes(), + new CCmakeGenerator( + context.getFileConfig(), + List.of( + "lib/python_action.c", + "lib/python_port.c", + "lib/python_tag.c", + "lib/python_time.c", + "lib/pythontarget.c"), + PythonGenerator::setUpMainTarget, + "install(TARGETS)" // No-op + )); + } + + private PythonGenerator( + LFGeneratorContext context, PythonTypes types, CCmakeGenerator cmakeGenerator) { + super(context, false, types, cmakeGenerator, new PythonDelayBodyGenerator(types)); + this.targetConfig.compiler = "gcc"; + this.targetConfig.compilerFlags = new ArrayList<>(); + this.targetConfig.linkerFlags = ""; + this.types = types; + } + + /** + * Generic struct for ports with primitive types and statically allocated arrays in Lingua Franca. + * This template is defined as typedef struct { bool is_present; lf_sparse_io_record_t* + * sparse_record; // NULL if there is no sparse record. int destination_channel; // -1 if there is + * no destination. PyObject* value; int num_destinations; lf_token_t* token; int length; void + * (*destructor) (void* value); void* (*copy_constructor) (void* value); + * FEDERATED_GENERIC_EXTENSION } generic_port_instance_struct; + * + *

    See reactor-c/python/lib/pythontarget.h for details. + */ + String genericPortType = "generic_port_instance_struct"; + + /** + * Generic struct for actions. This template is defined as typedef struct { trigger_t* trigger; + * PyObject* value; bool is_present; bool has_value; lf_token_t* token; + * FEDERATED_CAPSULE_EXTENSION } generic_action_instance_struct; + * + *

    See reactor-c/python/lib/pythontarget.h for details. + */ + String genericActionType = "generic_action_instance_struct"; + + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.Python; + } + + private final Set protoNames = new HashSet<>(); + + // ////////////////////////////////////////// + // // Public methods + @Override + public TargetTypes getTargetTypes() { + return types; + } + + // ////////////////////////////////////////// + // // Protected methods + + /** Generate all Python classes if they have a reaction */ + public String generatePythonReactorClasses() { + CodeBuilder pythonClasses = new CodeBuilder(); + CodeBuilder pythonClassesInstantiation = new CodeBuilder(); + + // Generate reactor classes in Python + pythonClasses.pr(PythonReactorGenerator.generatePythonClass(main, main, types)); + + // Create empty lists to hold reactor instances + pythonClassesInstantiation.pr(PythonReactorGenerator.generateListsToHoldClassInstances(main)); + + // Instantiate generated classes + pythonClassesInstantiation.pr( + PythonReactorGenerator.generatePythonClassInstantiations(main, main)); + + return String.join( + "\n", + pythonClasses.toString(), + "", + "# Instantiate classes", + pythonClassesInstantiation.toString()); + } + + /** + * Generate the Python code constructed from reactor classes and user-written classes. + * + * @return the code body + */ + public String generatePythonCode(String pyModuleName) { + return String.join( + "\n", + "import os", + "import sys", + "sys.path.append(os.path.dirname(__file__))", + "# List imported names, but do not use pylint's --extension-pkg-allow-list option", + "# so that these names will be assumed present without having to compile and install.", + "# pylint: disable=no-name-in-module, import-error", + "from " + pyModuleName + " import (", + " Tag, action_capsule_t, port_capsule, request_stop, schedule_copy, start", + ")", + "# pylint: disable=c-extension-no-member", + "import " + pyModuleName + " as lf", + "try:", + " from LinguaFrancaBase.constants import BILLION, FOREVER, NEVER, instant_t, interval_t", + " from LinguaFrancaBase.functions import (", + " DAY, DAYS, HOUR, HOURS, MINUTE, MINUTES, MSEC, MSECS, NSEC, NSECS, SEC, SECS," + + " USEC,", + " USECS, WEEK, WEEKS", + " )", + " from LinguaFrancaBase.classes import Make", + "except ModuleNotFoundError:", + " print(\"No module named 'LinguaFrancaBase'. \"", + " \"Install using \\\"pip3 install LinguaFrancaBase\\\".\")", + " sys.exit(1)", + "import copy", + "", + pythonPreamble.toString(), + "", + generatePythonReactorClasses(), + "", + PythonMainFunctionGenerator.generateCode()); + } + + /** Generate the necessary Python files. */ + public Map generatePythonFiles( + String lfModuleName, String pyModuleName, String pyFileName) throws IOException { + Path filePath = fileConfig.getSrcGenPath().resolve(pyFileName); + File file = filePath.toFile(); + Files.deleteIfExists(filePath); + // Create the necessary directories + if (!file.getParentFile().exists()) { + if (!file.getParentFile().mkdirs()) { + throw new IOException( + "Failed to create directories required for the Python code generator."); + } + } + Map codeMaps = new HashMap<>(); + codeMaps.put(filePath, CodeMap.fromGeneratedCode(generatePythonCode(pyModuleName))); + FileUtil.writeToFile(codeMaps.get(filePath).getGeneratedCode(), filePath); + return codeMaps; + } + + /** + * Generate code that needs to appear at the top of the generated C file, such as #define and + * #include statements. + */ + @Override + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr( + PythonPreambleGenerator.generateCDefineDirectives( targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); - return code.toString(); - } - - /** - * Override generate top-level preambles, but put the user preambles in the - * .py file rather than the C file. Also handles including the federated - * execution setup preamble specified in the target config. - */ - @Override - protected String generateTopLevelPreambles(Reactor ignored) { - // user preambles - Set models = new LinkedHashSet<>(); - for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { - // The following assumes all reactors have a container. - // This means that generated reactors **have** to be - // added to a resource; not doing so will result in a NPE. - models.add((Model) ASTUtils.toDefinition(r).eContainer()); - } - // Add the main reactor if it is defined - if (this.mainDef != null) { - models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); + return code.toString(); + } + + /** + * Override generate top-level preambles, but put the user preambles in the .py file rather than + * the C file. Also handles including the federated execution setup preamble specified in the + * target config. + */ + @Override + protected String generateTopLevelPreambles(Reactor ignored) { + // user preambles + Set models = new LinkedHashSet<>(); + for (Reactor r : ASTUtils.convertToEmptyListIfNull(reactors)) { + // The following assumes all reactors have a container. + // This means that generated reactors **have** to be + // added to a resource; not doing so will result in a NPE. + models.add((Model) ASTUtils.toDefinition(r).eContainer()); + } + // Add the main reactor if it is defined + if (this.mainDef != null) { + models.add((Model) ASTUtils.toDefinition(this.mainDef.getReactorClass()).eContainer()); + } + for (Model m : models) { + pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); + } + return PythonPreambleGenerator.generateCIncludeStatements( + targetConfig, targetLanguageIsCpp(), hasModalReactors); + } + + @Override + protected void handleProtoFiles() { + for (String name : targetConfig.protoFiles) { + this.processProtoFile(name); + int dotIndex = name.lastIndexOf("."); + String rootFilename = dotIndex > 0 ? name.substring(0, dotIndex) : name; + pythonPreamble.pr("import " + rootFilename + "_pb2 as " + rootFilename); + protoNames.add(rootFilename); + } + } + + /** + * Process a given .proto file. + * + *

    Run, if possible, the proto-c protocol buffer code generator to produce the required .h and + * .c files. + * + * @param filename Name of the file to process. + */ + @Override + public void processProtoFile(String filename) { + LFCommand protoc = + commandFactory.createCommand( + "protoc", + List.of("--python_out=" + fileConfig.getSrcGenPath(), filename), + fileConfig.srcPath); + + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires libprotoc >= 3.6.1"); + return; + } + int returnCode = protoc.run(); + if (returnCode == 0) { + pythonRequiredModules.add("google-api-python-client"); + } else { + errorReporter.reportError("protoc returns error code " + returnCode); + } + } + + /** + * Generate the aliases for inputs, outputs, and struct type definitions for actions of the + * specified reactor in the specified federate. + * + * @param tpr The concrete reactor class. + */ + @Override + public void generateAuxiliaryStructs( + CodeBuilder builder, TypeParameterizedReactor tpr, boolean userFacing) { + for (Input input : ASTUtils.allInputs(tpr.reactor())) { + generateAuxiliaryStructsForPort(builder, tpr, input); + } + for (Output output : ASTUtils.allOutputs(tpr.reactor())) { + generateAuxiliaryStructsForPort(builder, tpr, output); + } + for (Action action : ASTUtils.allActions(tpr.reactor())) { + generateAuxiliaryStructsForAction(builder, tpr, action); + } + } + + private void generateAuxiliaryStructsForPort( + CodeBuilder builder, TypeParameterizedReactor tpr, Port port) { + boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); + builder.pr( + port, PythonPortGenerator.generateAliasTypeDef(tpr, port, isTokenType, genericPortType)); + } + + private void generateAuxiliaryStructsForAction( + CodeBuilder builder, TypeParameterizedReactor tpr, Action action) { + builder.pr(action, PythonActionGenerator.generateAliasTypeDef(tpr, action, genericActionType)); + } + + /** + * Return true if the host operating system is compatible and otherwise report an error and return + * false. + */ + @Override + public boolean isOSCompatible() { + return true; + } + + /** + * Generate C code from the Lingua Franca model contained by the specified resource. This is the + * main entry point for code generation. + * + * @param resource The resource containing the source code. + * @param context Context relating to invocation of the code generator. + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + // Set the threading to false by default, unless the user has + // specifically asked for it. + if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = false; + } + int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; + code.pr( + PythonPreambleGenerator.generateCIncludeStatements( + targetConfig, targetLanguageIsCpp(), hasModalReactors)); + super.doGenerate( + resource, + new SubContext( + context, IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, cGeneratedPercentProgress)); + + if (errorsOccurred()) { + context.unsuccessfulFinish(); + return; + } + + Map codeMaps = new HashMap<>(); + var lfModuleName = fileConfig.name; + // Don't generate code if there is no main reactor + if (this.main != null) { + try { + Map codeMapsForFederate = + generatePythonFiles( + lfModuleName, + generatePythonModuleName(lfModuleName), + generatePythonFileName(lfModuleName)); + codeMaps.putAll(codeMapsForFederate); + copyTargetFiles(); + new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); + if (targetConfig.noCompile) { + System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); } - for (Model m : models) { - pythonPreamble.pr(PythonPreambleGenerator.generatePythonPreambles(m.getPreambles())); - } - return PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors); - } - - @Override - protected void handleProtoFiles() { - for (String name : targetConfig.protoFiles) { - this.processProtoFile(name); - int dotIndex = name.lastIndexOf("."); - String rootFilename = dotIndex > 0 ? name.substring(0, dotIndex) : name; - pythonPreamble.pr("import "+rootFilename+"_pb2 as "+rootFilename); - protoNames.add(rootFilename); - } - } - - /** - * Process a given .proto file. - * - * Run, if possible, the proto-c protocol buffer code generator to produce - * the required .h and .c files. - * - * @param filename Name of the file to process. - */ - @Override - public void processProtoFile(String filename) { - LFCommand protoc = commandFactory.createCommand( - "protoc", List.of("--python_out=" - + fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); - - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires libprotoc >= 3.6.1"); - return; - } - int returnCode = protoc.run(); - if (returnCode == 0) { - pythonRequiredModules.add("google-api-python-client"); - } else { - errorReporter.reportError( - "protoc returns error code " + returnCode); - } - } - - /** - * Generate the aliases for inputs, outputs, and struct type definitions for - * actions of the specified reactor in the specified federate. - * @param tpr The concrete reactor class. - */ - @Override - public void generateAuxiliaryStructs( - CodeBuilder builder, TypeParameterizedReactor tpr, boolean userFacing - ) { - for (Input input : ASTUtils.allInputs(tpr.reactor())) { - generateAuxiliaryStructsForPort(builder, tpr, input); - } - for (Output output : ASTUtils.allOutputs(tpr.reactor())) { - generateAuxiliaryStructsForPort(builder, tpr, output); - } - for (Action action : ASTUtils.allActions(tpr.reactor())) { - generateAuxiliaryStructsForAction(builder, tpr, action); - } - } - - private void generateAuxiliaryStructsForPort(CodeBuilder builder, TypeParameterizedReactor tpr, - Port port) { - boolean isTokenType = CUtil.isTokenType(ASTUtils.getInferredType(port), types); - builder.pr(port, - PythonPortGenerator.generateAliasTypeDef(tpr, port, isTokenType, - genericPortType)); - } - - private void generateAuxiliaryStructsForAction(CodeBuilder builder, TypeParameterizedReactor tpr, - Action action) { - builder.pr(action, PythonActionGenerator.generateAliasTypeDef(tpr, action, genericActionType)); - } - - /** - * Return true if the host operating system is compatible and - * otherwise report an error and return false. - */ - @Override - public boolean isOSCompatible() { - return true; - } - - /** - * Generate C code from the Lingua Franca model contained by the - * specified resource. This is the main entry point for code - * generation. - * - * @param resource The resource containing the source code. - * @param context Context relating to invocation of the code generator. - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - // Set the threading to false by default, unless the user has - // specifically asked for it. - if (!targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = false; - } - int cGeneratedPercentProgress = (IntegratedBuilder.VALIDATED_PERCENT_PROGRESS + 100) / 2; - code.pr(PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors)); - super.doGenerate(resource, new SubContext( - context, - IntegratedBuilder.VALIDATED_PERCENT_PROGRESS, - cGeneratedPercentProgress - )); - - if (errorsOccurred()) { - context.unsuccessfulFinish(); - return; - } - - Map codeMaps = new HashMap<>(); - var lfModuleName = fileConfig.name; - // Don't generate code if there is no main reactor - if (this.main != null) { - try { - Map codeMapsForFederate = generatePythonFiles(lfModuleName, generatePythonModuleName(lfModuleName), generatePythonFileName(lfModuleName)); - codeMaps.putAll(codeMapsForFederate); - copyTargetFiles(); - new PythonValidator(fileConfig, errorReporter, codeMaps, protoNames).doValidate(context); - if (targetConfig.noCompile) { - System.out.println(PythonInfoGenerator.generateSetupInfo(fileConfig)); - } - } catch (Exception e) { - //noinspection ConstantConditions - throw Exceptions.sneakyThrow(e); - } - - System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); - } - - if (errorReporter.getErrorsOccurred()) { - context.unsuccessfulFinish(); - } else { - context.finish(GeneratorResult.Status.COMPILED, codeMaps); - } - } - - @Override - protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new PythonDockerGenerator(context); - } - - /** Generate a reaction function definition for a reactor. - * This function has a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param tpr The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - @Override - protected void generateReaction(CodeBuilder src, Reaction reaction, TypeParameterizedReactor tpr, int reactionIndex) { - Reactor reactor = ASTUtils.toDefinition(tpr.reactor()); - - // Reactions marked with a {@code @_c_body} attribute are generated in C - if (AttributeUtils.hasCBody(reaction)) { - super.generateReaction(src, reaction, tpr, reactionIndex); - return; - } - src.pr(PythonReactionGenerator.generateCReaction(reaction, tpr, reactor, reactionIndex, mainDef, errorReporter, types)); - } - - /** - * Generate code that initializes the state variables for a given instance. - * Unlike parameters, state variables are uniformly initialized for all - * instances - * of the same reactor. This task is left to Python code to allow for more - * liberal - * state variable assignments. - * - * @param instance The reactor class instance - * @return Initialization code fore state variables of instance - */ - @Override - protected void generateStateVariableInitializations(ReactorInstance instance) { - // Do nothing - } - - /** - * Generate runtime initialization code in C for parameters of a given - * reactor instance - * - * @param instance The reactor instance. - */ - @Override - protected void generateParameterInitialization(ReactorInstance instance) { - // Do nothing - // Parameters are initialized in Python - } - - /** - * Do nothing. - * Methods are generated in Python not C. - * @see PythonMethodGenerator - */ - @Override - protected void generateMethods(CodeBuilder src, TypeParameterizedReactor reactor) { } - - /** - * Generate C preambles defined by user for a given reactor - * Since the Python generator expects preambles written in C, - * this function is overridden and does nothing. - * - * @param reactor The given reactor - */ - @Override - protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { - // Do nothing - } - - @Override - protected void generateReactorClassHeaders(TypeParameterizedReactor tpr, String headerName, CodeBuilder header, CodeBuilder src) { - header.pr(PythonPreambleGenerator.generateCIncludeStatements(targetConfig, targetLanguageIsCpp(), hasModalReactors)); - super.generateReactorClassHeaders(tpr, headerName, header, src); - } - - /** - * Generate code that is executed while the reactor instance is being - * initialized. - * This wraps the reaction functions in a Python function. - * @param instance The reactor instance. - */ - @Override - protected void generateReactorInstanceExtension( - ReactorInstance instance - ) { - initializeTriggerObjects.pr(PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); - } - - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the self struct - * @param selfStructBody The body of the self struct - * @param reactor The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - @Override - protected void generateSelfStructExtension( - CodeBuilder selfStructBody, - Reactor reactor, - CodeBuilder constructorCode - ) { - // Add the name field - selfStructBody.pr("char *_lf_name;"); - int reactionIndex = 0; - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - // Create a PyObject for each reaction - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex)+";"); - if (reaction.getStp() != null) { - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex)+";"); - } - if (reaction.getDeadline() != null) { - selfStructBody.pr("PyObject* "+ PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex)+";"); - } - reactionIndex++; - } - } - - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - // NOTE: Strangely, a newline is needed at the beginning or indentation - // gets swallowed. - return String.join("\n", - "\n# Generated forwarding reaction for connections with the same destination", - "# but located in mutually exclusive modes.", - dest + ".set(" + source + ".value)\n" - ); - } - - @Override - protected void setUpGeneralParameters() { - super.setUpGeneralParameters(); - if (hasModalReactors) { - targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); - } - } - - @Override - protected void additionalPostProcessingForModes() { - if (!hasModalReactors) { - return; - } - PythonModeGenerator.generateResetReactionsIfNeeded(reactors); - } - - private static String setUpMainTarget(boolean hasMain, String executableName, Stream cSources) { - return ( - """ + } catch (Exception e) { + //noinspection ConstantConditions + throw Exceptions.sneakyThrow(e); + } + + System.out.println(PythonInfoGenerator.generateRunInfo(fileConfig, lfModuleName)); + } + + if (errorReporter.getErrorsOccurred()) { + context.unsuccessfulFinish(); + } else { + context.finish(GeneratorResult.Status.COMPILED, codeMaps); + } + } + + @Override + protected PythonDockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new PythonDockerGenerator(context); + } + + /** + * Generate a reaction function definition for a reactor. This function has a single argument that + * is a void* pointing to a struct that contains parameters, state variables, inputs (triggering + * or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param tpr The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + @Override + protected void generateReaction( + CodeBuilder src, Reaction reaction, TypeParameterizedReactor tpr, int reactionIndex) { + Reactor reactor = ASTUtils.toDefinition(tpr.reactor()); + + // Reactions marked with a {@code @_c_body} attribute are generated in C + if (AttributeUtils.hasCBody(reaction)) { + super.generateReaction(src, reaction, tpr, reactionIndex); + return; + } + src.pr( + PythonReactionGenerator.generateCReaction( + reaction, tpr, reactor, reactionIndex, mainDef, errorReporter, types)); + } + + /** + * Generate code that initializes the state variables for a given instance. Unlike parameters, + * state variables are uniformly initialized for all instances of the same reactor. This task is + * left to Python code to allow for more liberal state variable assignments. + * + * @param instance The reactor class instance + * @return Initialization code fore state variables of instance + */ + @Override + protected void generateStateVariableInitializations(ReactorInstance instance) { + // Do nothing + } + + /** + * Generate runtime initialization code in C for parameters of a given reactor instance + * + * @param instance The reactor instance. + */ + @Override + protected void generateParameterInitialization(ReactorInstance instance) { + // Do nothing + // Parameters are initialized in Python + } + + /** + * Do nothing. Methods are generated in Python not C. + * + * @see PythonMethodGenerator + */ + @Override + protected void generateMethods(CodeBuilder src, TypeParameterizedReactor reactor) {} + + /** + * Generate C preambles defined by user for a given reactor Since the Python generator expects + * preambles written in C, this function is overridden and does nothing. + * + * @param reactor The given reactor + */ + @Override + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + // Do nothing + } + + @Override + protected void generateReactorClassHeaders( + TypeParameterizedReactor tpr, String headerName, CodeBuilder header, CodeBuilder src) { + header.pr( + PythonPreambleGenerator.generateCIncludeStatements( + targetConfig, targetLanguageIsCpp(), hasModalReactors)); + super.generateReactorClassHeaders(tpr, headerName, header, src); + } + + /** + * Generate code that is executed while the reactor instance is being initialized. This wraps the + * reaction functions in a Python function. + * + * @param instance The reactor instance. + */ + @Override + protected void generateReactorInstanceExtension(ReactorInstance instance) { + initializeTriggerObjects.pr( + PythonReactionGenerator.generateCPythonReactionLinkers(instance, mainDef)); + } + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the + * self struct + * + * @param selfStructBody The body of the self struct + * @param reactor The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + @Override + protected void generateSelfStructExtension( + CodeBuilder selfStructBody, Reactor reactor, CodeBuilder constructorCode) { + // Add the name field + selfStructBody.pr("char *_lf_name;"); + int reactionIndex = 0; + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + // Create a PyObject for each reaction + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonReactionFunctionName(reactionIndex) + + ";"); + if (reaction.getStp() != null) { + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonSTPFunctionName(reactionIndex) + + ";"); + } + if (reaction.getDeadline() != null) { + selfStructBody.pr( + "PyObject* " + + PythonReactionGenerator.generateCPythonDeadlineFunctionName(reactionIndex) + + ";"); + } + reactionIndex++; + } + } + + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + // NOTE: Strangely, a newline is needed at the beginning or indentation + // gets swallowed. + return String.join( + "\n", + "\n# Generated forwarding reaction for connections with the same destination", + "# but located in mutually exclusive modes.", + dest + ".set(" + source + ".value)\n"); + } + + @Override + protected void setUpGeneralParameters() { + super.setUpGeneralParameters(); + if (hasModalReactors) { + targetConfig.compileAdditionalSources.add("lib/modal_models/impl.c"); + } + } + + @Override + protected void additionalPostProcessingForModes() { + if (!hasModalReactors) { + return; + } + PythonModeGenerator.generateResetReactionsIfNeeded(reactors); + } + + private static String setUpMainTarget( + boolean hasMain, String executableName, Stream cSources) { + return (""" set(CMAKE_POSITION_INDEPENDENT_CODE ON) add_compile_definitions(_LF_GARBAGE_COLLECTED) add_subdirectory(core) @@ -614,74 +597,59 @@ private static String setUpMainTarget(boolean hasMain, String executableName, St include_directories(${Python_INCLUDE_DIRS}) target_link_libraries(${LF_MAIN_TARGET} PRIVATE ${Python_LIBRARIES}) target_compile_definitions(${LF_MAIN_TARGET} PUBLIC MODULE_NAME=) - """ - ).replace("", generatePythonModuleName(executableName)) - .replace("executableName", executableName); - // The use of fileConfig.name will break federated execution, but that's fine - } - - /** - * Generate a ({@code key}, {@code val}) tuple pair for the {@code define_macros} field - * of the Extension class constructor from setuptools. - * - * @param key The key of the macro entry - * @param val The value of the macro entry - * @return A ({@code key}, {@code val}) tuple pair as String - */ - private static String generateMacroEntry(String key, String val) { - return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; - } - - /** - * Generate the name of the python module. - * - * Ideally, this function would belong in a class like {@code PyFileConfig} - * that specifies all the paths to the generated code. - * - * @param lfModuleName The name of the LF module. - * @return The name of the python module. - */ - private static String generatePythonModuleName(String lfModuleName) { - return "LinguaFranca" + lfModuleName; - } - - /** - * Generate the python file name given an {@code lfModuleName}. - * - * Ideally, this function would belong in a class like {@code PyFileConfig} - * that specifies all the paths to the generated code. - * - * @param lfModuleName The name of the LF module - * @return The name of the generated python file. - */ - private static String generatePythonFileName(String lfModuleName) { - return lfModuleName + ".py"; - } - - /** - * Copy Python specific target code to the src-gen directory - */ - @Override - protected void copyTargetFiles() throws IOException { - super.copyTargetFiles(); - FileUtil.copyFromClassPath( - "/lib/c/reactor-c/python/include", - fileConfig.getSrcGenPath(), - true, - false - ); - FileUtil.copyFromClassPath( - "/lib/c/reactor-c/python/lib", - fileConfig.getSrcGenPath(), - true, - false - ); - FileUtil.copyFromClassPath( - "/lib/py/lf-python-support/LinguaFrancaBase", - fileConfig.getSrcGenPath(), - true, - false - ); - } - + """) + .replace("", generatePythonModuleName(executableName)) + .replace("executableName", executableName); + // The use of fileConfig.name will break federated execution, but that's fine + } + + /** + * Generate a ({@code key}, {@code val}) tuple pair for the {@code define_macros} field of the + * Extension class constructor from setuptools. + * + * @param key The key of the macro entry + * @param val The value of the macro entry + * @return A ({@code key}, {@code val}) tuple pair as String + */ + private static String generateMacroEntry(String key, String val) { + return "(" + StringUtil.addDoubleQuotes(key) + ", " + StringUtil.addDoubleQuotes(val) + ")"; + } + + /** + * Generate the name of the python module. + * + *

    Ideally, this function would belong in a class like {@code PyFileConfig} that specifies all + * the paths to the generated code. + * + * @param lfModuleName The name of the LF module. + * @return The name of the python module. + */ + private static String generatePythonModuleName(String lfModuleName) { + return "LinguaFranca" + lfModuleName; + } + + /** + * Generate the python file name given an {@code lfModuleName}. + * + *

    Ideally, this function would belong in a class like {@code PyFileConfig} that specifies all + * the paths to the generated code. + * + * @param lfModuleName The name of the LF module + * @return The name of the generated python file. + */ + private static String generatePythonFileName(String lfModuleName) { + return lfModuleName + ".py"; + } + + /** Copy Python specific target code to the src-gen directory */ + @Override + protected void copyTargetFiles() throws IOException { + super.copyTargetFiles(); + FileUtil.copyFromClassPath( + "/lib/c/reactor-c/python/include", fileConfig.getSrcGenPath(), true, false); + FileUtil.copyFromClassPath( + "/lib/c/reactor-c/python/lib", fileConfig.getSrcGenPath(), true, false); + FileUtil.copyFromClassPath( + "/lib/py/lf-python-support/LinguaFrancaBase", fileConfig.getSrcGenPath(), true, false); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonInfoGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonInfoGenerator.java index 23512f447a..01cadbcc5c 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonInfoGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonInfoGenerator.java @@ -4,53 +4,49 @@ import org.lflang.FileConfig; public class PythonInfoGenerator { - /** - * Print information about necessary steps to install the supporting - * Python C extension for the generated program. - * - * @note Only needed if no-compile is set to true - */ - public static String generateSetupInfo(FileConfig fileConfig) { - return String.join("\n", - "", - "#####################################", - "To compile and install the generated code, do:", - " ", - " cd "+fileConfig.getSrcGenPath()+File.separator, - " python3 -m pip install --force-reinstall .", - "" - ); - } + /** + * Print information about necessary steps to install the supporting Python C extension for the + * generated program. + * + * @note Only needed if no-compile is set to true + */ + public static String generateSetupInfo(FileConfig fileConfig) { + return String.join( + "\n", + "", + "#####################################", + "To compile and install the generated code, do:", + " ", + " cd " + fileConfig.getSrcGenPath() + File.separator, + " python3 -m pip install --force-reinstall .", + ""); + } - /** - * Print information on how to execute the generated program. - */ - public static String generateRunInfo(FileConfig fileConfig, String lfModuleName) { - return String.join("\n", - "", - "#####################################", - "To run the generated program, use:", - " ", - " python3 "+fileConfig.getSrcGenPath()+File.separator+lfModuleName+".py", - "", - "#####################################", - "" - ); - } + /** Print information on how to execute the generated program. */ + public static String generateRunInfo(FileConfig fileConfig, String lfModuleName) { + return String.join( + "\n", + "", + "#####################################", + "To run the generated program, use:", + " ", + " python3 " + fileConfig.getSrcGenPath() + File.separator + lfModuleName + ".py", + "", + "#####################################", + ""); + } - /** - * Print information on how to execute the generated federation. - */ - public static String generateFedRunInfo(FileConfig fileConfig) { - return String.join("\n", - "", - "#####################################", - "To run the generated program, run:", - " ", - " bash "+fileConfig.binPath+"/"+fileConfig.name, - "", - "#####################################", - "" - ); - } + /** Print information on how to execute the generated federation. */ + public static String generateFedRunInfo(FileConfig fileConfig) { + return String.join( + "\n", + "", + "#####################################", + "To run the generated program, run:", + " ", + " bash " + fileConfig.binPath + "/" + fileConfig.name, + "", + "#####################################", + ""); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonMainFunctionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonMainFunctionGenerator.java index a655402408..5a43788138 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonMainFunctionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonMainFunctionGenerator.java @@ -26,29 +26,26 @@ package org.lflang.generator.python; /** - * Responsible for creating the main function for - * the generated Python target programs. + * Responsible for creating the main function for the generated Python target programs. * * @author Soroush Bateni - * */ public final class PythonMainFunctionGenerator { - /* - * Generate the main function code - */ - public static String generateCode() { - StringBuilder code = new StringBuilder(); - code.append( - "# The main function\n" - + "def main(argv):\n" - + " start(argv)\n" - + "\n" - + "# As is customary in Python programs, the main() function\n" - + "# should only be executed if the main module is active.\n" - + "if __name__==\"__main__\":\n" - + " main(sys.argv)\n" - ); - return code.toString(); - } + /* + * Generate the main function code + */ + public static String generateCode() { + StringBuilder code = new StringBuilder(); + code.append( + "# The main function\n" + + "def main(argv):\n" + + " start(argv)\n" + + "\n" + + "# As is customary in Python programs, the main() function\n" + + "# should only be executed if the main module is active.\n" + + "if __name__==\"__main__\":\n" + + " main(sys.argv)\n"); + return code.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java index a2d1e240d1..e2d2e85a6b 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java @@ -1,7 +1,6 @@ package org.lflang.generator.python; import java.util.stream.Collectors; - import org.lflang.ast.ASTUtils; import org.lflang.lf.Method; import org.lflang.lf.MethodArgument; @@ -14,39 +13,30 @@ */ public class PythonMethodGenerator { - /** - * Generate a Python method definition for {@code method}. - */ - public static String generateMethod(Method method) { - return String.join("\n", - "# Implementation of method "+method.getName()+"().", - "def "+method.getName()+"(self, "+generateMethodArgumentList(method)+"):", - ASTUtils.toText(method.getCode()).indent(4) - ); - } + /** Generate a Python method definition for {@code method}. */ + public static String generateMethod(Method method) { + return String.join( + "\n", + "# Implementation of method " + method.getName() + "().", + "def " + method.getName() + "(self, " + generateMethodArgumentList(method) + "):", + ASTUtils.toText(method.getCode()).indent(4)); + } - /** - * Generate methods for a reactor class. - * - * @param reactor The reactor. - */ - public static String generateMethods( - Reactor reactor - ) { - return ASTUtils.allMethods(reactor) - .stream() - .map(m -> generateMethod(m)) - .collect(Collectors.joining()); - } + /** + * Generate methods for a reactor class. + * + * @param reactor The reactor. + */ + public static String generateMethods(Reactor reactor) { + return ASTUtils.allMethods(reactor).stream() + .map(m -> generateMethod(m)) + .collect(Collectors.joining()); + } - /** - * Generate a list of arguments for {@code method} delimited with ', '. - */ - private static String generateMethodArgumentList(Method method) { - return String.join(", ", - method.getArguments() - .stream() - .map(MethodArgument::getName) - .collect(Collectors.toList())); - } + /** Generate a list of arguments for {@code method} delimited with ', '. */ + private static String generateMethodArgumentList(Method method) { + return String.join( + ", ", + method.getArguments().stream().map(MethodArgument::getName).collect(Collectors.toList())); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java index 90af635727..9bcbe6607d 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java @@ -1,7 +1,6 @@ package org.lflang.generator.python; import java.util.List; - import org.eclipse.emf.ecore.util.EcoreUtil; import org.lflang.generator.CodeBuilder; import org.lflang.lf.BuiltinTrigger; @@ -15,86 +14,94 @@ * Helper class to handle modes in Python programs. * * @author Soroush Bateni - * */ public class PythonModeGenerator { - /** - * Generate reset reactions in modes to reset state variables. - * - * @param reactors A list of reactors in the program, some of which could contain modes. - */ - public static void generateResetReactionsIfNeeded(List reactors) { - for (Reactor reactor : reactors) { - generateStartupReactionsInReactor(reactor); - } + /** + * Generate reset reactions in modes to reset state variables. + * + * @param reactors A list of reactors in the program, some of which could contain modes. + */ + public static void generateResetReactionsIfNeeded(List reactors) { + for (Reactor reactor : reactors) { + generateStartupReactionsInReactor(reactor); } + } - /** - * Generate reset reactions that reset state variables in - *

      - *
    • the reactor, and,
      • - *
    • the modes within the reactor.
      • - *
    - * - * @param reactor The reactor. - */ - private static void generateStartupReactionsInReactor(Reactor reactor) { - - // Create a reaction with a reset trigger - BuiltinTriggerRef resetTrigger = LfFactory.eINSTANCE.createBuiltinTriggerRef(); - resetTrigger.setType(BuiltinTrigger.RESET); - Reaction baseReaction = LfFactory.eINSTANCE.createReaction(); - baseReaction.getTriggers().add(resetTrigger); + /** + * Generate reset reactions that reset state variables in + * + *
      + *
    • the reactor, and, + *
    • the modes within the reactor. + *
    + * + * @param reactor The reactor. + */ + private static void generateStartupReactionsInReactor(Reactor reactor) { - if (!reactor.getStateVars().isEmpty() && reactor.getStateVars().stream().anyMatch(s -> s.isReset())) { - // Create a reaction body that resets all state variables (that are not in a mode) - // to their initial value. - var reactionBody = LfFactory.eINSTANCE.createCode(); - CodeBuilder code = new CodeBuilder(); - code.pr("# Reset the following state variables to their initial value."); - for (var state: reactor.getStateVars()) { - if (state.isReset()) { - code.pr("self."+state.getName()+" = "+ PythonStateGenerator.generatePythonInitializer(state)); - } - } - reactionBody.setBody(code.toString()); - baseReaction.setCode(reactionBody); + // Create a reaction with a reset trigger + BuiltinTriggerRef resetTrigger = LfFactory.eINSTANCE.createBuiltinTriggerRef(); + resetTrigger.setType(BuiltinTrigger.RESET); + Reaction baseReaction = LfFactory.eINSTANCE.createReaction(); + baseReaction.getTriggers().add(resetTrigger); - reactor.getReactions().add(0, baseReaction); + if (!reactor.getStateVars().isEmpty() + && reactor.getStateVars().stream().anyMatch(s -> s.isReset())) { + // Create a reaction body that resets all state variables (that are not in a mode) + // to their initial value. + var reactionBody = LfFactory.eINSTANCE.createCode(); + CodeBuilder code = new CodeBuilder(); + code.pr("# Reset the following state variables to their initial value."); + for (var state : reactor.getStateVars()) { + if (state.isReset()) { + code.pr( + "self." + + state.getName() + + " = " + + PythonStateGenerator.generatePythonInitializer(state)); } + } + reactionBody.setBody(code.toString()); + baseReaction.setCode(reactionBody); + reactor.getReactions().add(0, baseReaction); + } - var reactorModes = reactor.getModes(); - if (!reactorModes.isEmpty()) { - for (Mode mode : reactorModes) { - if (mode.getStateVars().isEmpty() || mode.getStateVars().stream().allMatch(s -> !s.isReset())) { - continue; - } - Reaction reaction = EcoreUtil.copy(baseReaction); - - // Create a reaction body that resets all state variables to their initial value. - var reactionBody = LfFactory.eINSTANCE.createCode(); - CodeBuilder code = new CodeBuilder(); - code.pr("# Reset the following state variables to their initial value."); - for (var state: mode.getStateVars()) { - if (state.isReset()) { - code.pr("self."+state.getName()+" = "+ PythonStateGenerator.generatePythonInitializer(state)); - } - } - reactionBody.setBody(code.toString()); - reaction.setCode(reactionBody); + var reactorModes = reactor.getModes(); + if (!reactorModes.isEmpty()) { + for (Mode mode : reactorModes) { + if (mode.getStateVars().isEmpty() + || mode.getStateVars().stream().allMatch(s -> !s.isReset())) { + continue; + } + Reaction reaction = EcoreUtil.copy(baseReaction); - try { - mode.getReactions().add(0, reaction); - } catch (IndexOutOfBoundsException e) { - // There are no scoping for state variables. - // We add this reaction for now so that it - // still resets state variables even if there - // are no reactions in this mode. - mode.getReactions().add(reaction); - } + // Create a reaction body that resets all state variables to their initial value. + var reactionBody = LfFactory.eINSTANCE.createCode(); + CodeBuilder code = new CodeBuilder(); + code.pr("# Reset the following state variables to their initial value."); + for (var state : mode.getStateVars()) { + if (state.isReset()) { + code.pr( + "self." + + state.getName() + + " = " + + PythonStateGenerator.generatePythonInitializer(state)); + } + } + reactionBody.setBody(code.toString()); + reaction.setCode(reactionBody); - } + try { + mode.getReactions().add(0, reaction); + } catch (IndexOutOfBoundsException e) { + // There are no scoping for state variables. + // We add this reaction for now so that it + // still resets state variables even if there + // are no reactions in this mode. + mode.getReactions().add(reaction); } + } } + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java index 838e7a27a3..0c13b111f7 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java @@ -2,107 +2,103 @@ import java.util.ArrayList; import java.util.List; - import org.lflang.ast.ASTUtils; import org.lflang.generator.ParameterInstance; -import org.lflang.lf.ReactorDecl; import org.lflang.lf.Parameter; - +import org.lflang.lf.ReactorDecl; public class PythonParameterGenerator { - /** - * Generate Python code that instantiates and initializes parameters for a reactor 'decl'. - * - * @param decl The reactor declaration - * @return The generated code as a StringBuilder - */ - public static String generatePythonInstantiations(ReactorDecl decl, PythonTypes types) { - List lines = new ArrayList<>(); - lines.add("# Define parameters and their default values"); + /** + * Generate Python code that instantiates and initializes parameters for a reactor 'decl'. + * + * @param decl The reactor declaration + * @return The generated code as a StringBuilder + */ + public static String generatePythonInstantiations(ReactorDecl decl, PythonTypes types) { + List lines = new ArrayList<>(); + lines.add("# Define parameters and their default values"); - for (Parameter param : getAllParameters(decl)) { - if (!types.getTargetType(param).equals("PyObject*")) { - // If type is given, use it - String type = types.getPythonType(ASTUtils.getInferredType(param)); - lines.add("self._"+param.getName()+":"+type+" = "+generatePythonInitializer(param)); - } else { - // If type is not given, just pass along the initialization - lines.add("self._"+param.getName()+" = "+generatePythonInitializer(param)); - } - } - // Handle parameters that are set in instantiation - lines.addAll(List.of( + for (Parameter param : getAllParameters(decl)) { + if (!types.getTargetType(param).equals("PyObject*")) { + // If type is given, use it + String type = types.getPythonType(ASTUtils.getInferredType(param)); + lines.add( + "self._" + param.getName() + ":" + type + " = " + generatePythonInitializer(param)); + } else { + // If type is not given, just pass along the initialization + lines.add("self._" + param.getName() + " = " + generatePythonInitializer(param)); + } + } + // Handle parameters that are set in instantiation + lines.addAll( + List.of( "# Handle parameters that are set in instantiation", "self.__dict__.update(kwargs)", - "" - )); - return String.join("\n", lines); - } + "")); + return String.join("\n", lines); + } - /** - * Generate Python code getters for parameters of reactor 'decl'. - * - * @param decl The reactor declaration - * @return The generated code as a StringBuilder - */ - public static String generatePythonGetters(ReactorDecl decl) { - List lines = new ArrayList<>(); - for (Parameter param : getAllParameters(decl)) { - if (!param.getName().equals("bank_index")) { - lines.addAll(List.of( - "", - "@property", - "def "+param.getName()+"(self):", - " return self._"+param.getName()+" # pylint: disable=no-member", - "" - )); - } - } - // Create a special property for bank_index - lines.addAll(List.of( + /** + * Generate Python code getters for parameters of reactor 'decl'. + * + * @param decl The reactor declaration + * @return The generated code as a StringBuilder + */ + public static String generatePythonGetters(ReactorDecl decl) { + List lines = new ArrayList<>(); + for (Parameter param : getAllParameters(decl)) { + if (!param.getName().equals("bank_index")) { + lines.addAll( + List.of( + "", + "@property", + "def " + param.getName() + "(self):", + " return self._" + param.getName() + " # pylint: disable=no-member", + "")); + } + } + // Create a special property for bank_index + lines.addAll( + List.of( "", "@property", "def bank_index(self):", " return self._bank_index # pylint: disable=no-member", - "" - )); - lines.add("\n"); - return String.join("\n", lines); - } - - /** - * Return a list of all parameters of reactor 'decl'. - * - * @param decl The reactor declaration - * @return The list of all parameters of 'decl' - */ - private static List getAllParameters(ReactorDecl decl) { - return ASTUtils.allParameters(ASTUtils.toDefinition(decl)); - } + "")); + lines.add("\n"); + return String.join("\n", lines); + } - /** - * Create a Python list for parameter initialization in target code. - * - * @param p The parameter to create initializers for - * @return Initialization code - */ - private static String generatePythonInitializer(Parameter p) { - return PythonTypes.getInstance().getTargetInitializer(p.getInit(), p.getType()); - } + /** + * Return a list of all parameters of reactor 'decl'. + * + * @param decl The reactor declaration + * @return The list of all parameters of 'decl' + */ + private static List getAllParameters(ReactorDecl decl) { + return ASTUtils.allParameters(ASTUtils.toDefinition(decl)); + } - /** - * Return a Python expression that can be used to initialize the specified - * parameter instance. If the parameter initializer refers to other - * parameters, then those parameter references are replaced with - * accesses to the Python reactor instance class of the parents of - * those parameters. - * - * @param p The parameter instance to create initializer for - * @return Initialization code - */ - public static String generatePythonInitializer(ParameterInstance p) { - PythonTypes pyTypes = PythonTypes.generateParametersIn(p.getParent().getParent()); - return pyTypes.getTargetInitializer(p.getActualValue(), p.getDefinition().getType()); - } + /** + * Create a Python list for parameter initialization in target code. + * + * @param p The parameter to create initializers for + * @return Initialization code + */ + private static String generatePythonInitializer(Parameter p) { + return PythonTypes.getInstance().getTargetInitializer(p.getInit(), p.getType()); + } + /** + * Return a Python expression that can be used to initialize the specified parameter instance. If + * the parameter initializer refers to other parameters, then those parameter references are + * replaced with accesses to the Python reactor instance class of the parents of those parameters. + * + * @param p The parameter instance to create initializer for + * @return Initialization code + */ + public static String generatePythonInitializer(ParameterInstance p) { + PythonTypes pyTypes = PythonTypes.generateParametersIn(p.getParent().getParent()); + return pyTypes.getTargetInitializer(p.getActualValue(), p.getDefinition().getType()); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java index 5109c322c3..d8ece7d206 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java @@ -1,237 +1,260 @@ package org.lflang.generator.python; +import static org.lflang.generator.c.CUtil.generateWidthVariable; + +import java.util.List; +import org.lflang.ast.ASTUtils; +import org.lflang.generator.CodeBuilder; +import org.lflang.generator.c.CGenerator; import org.lflang.generator.c.TypeParameterizedReactor; +import org.lflang.lf.Action; import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Output; import org.lflang.lf.Port; -import org.lflang.lf.Action; import org.lflang.lf.ReactorDecl; import org.lflang.lf.VarRef; -import java.util.List; -import org.lflang.ast.ASTUtils; -import org.lflang.generator.CodeBuilder; -import org.lflang.generator.c.CGenerator; -import static org.lflang.generator.c.CUtil.generateWidthVariable; public class PythonPortGenerator { - public static final String NONMULTIPORT_WIDTHSPEC = "-2"; + public static final String NONMULTIPORT_WIDTHSPEC = "-2"; - /** - * Generate code to convert C actions to Python action capsules. See - * pythontarget.h for details. - * @param pyObjects A string containing a list of comma-separated expressions that will create the - * action capsules. - * @param action The action itself. - * @param decl The reactor decl that contains the action. - */ - public static void generateActionVariableToSendToPythonReaction(List pyObjects, - Action action, ReactorDecl decl) { - // Values passed to an action are always stored in the token->value. - // However, sometimes token might not be initialized. Therefore, this function has an internal check for NULL in case token is not initialized. - pyObjects.add(String.format("convert_C_action_to_py(%s)", action.getName())); - } + /** + * Generate code to convert C actions to Python action capsules. See pythontarget.h for details. + * + * @param pyObjects A string containing a list of comma-separated expressions that will create the + * action capsules. + * @param action The action itself. + * @param decl The reactor decl that contains the action. + */ + public static void generateActionVariableToSendToPythonReaction( + List pyObjects, Action action, ReactorDecl decl) { + // Values passed to an action are always stored in the token->value. + // However, sometimes token might not be initialized. Therefore, this function has an internal + // check for NULL in case token is not initialized. + pyObjects.add(String.format("convert_C_action_to_py(%s)", action.getName())); + } - /** - * Generate code to convert C ports to Python ports capsules (@see pythontarget.h). - * - * The port may be an input of the reactor or an output of a contained reactor. - * @param pyObjects A string containing a list of comma-separated expressions that will create the - * port capsules. - * @param port The port itself. - * @param decl The reactor decl that contains the port. - */ - public static String generatePortVariablesToSendToPythonReaction( - List pyObjects, - VarRef port, - ReactorDecl decl - ) { - if (port.getVariable() instanceof Input) { - generateInputVariablesToSendToPythonReaction(pyObjects, (Input) port.getVariable(), decl); - return ""; - } else { - // port is an output of a contained reactor. - return generateVariablesForSendingToContainedReactors(pyObjects, port.getContainer(), (Port) port.getVariable()); - } + /** + * Generate code to convert C ports to Python ports capsules (@see pythontarget.h). + * + *

    The port may be an input of the reactor or an output of a contained reactor. + * + * @param pyObjects A string containing a list of comma-separated expressions that will create the + * port capsules. + * @param port The port itself. + * @param decl The reactor decl that contains the port. + */ + public static String generatePortVariablesToSendToPythonReaction( + List pyObjects, VarRef port, ReactorDecl decl) { + if (port.getVariable() instanceof Input) { + generateInputVariablesToSendToPythonReaction(pyObjects, (Input) port.getVariable(), decl); + return ""; + } else { + // port is an output of a contained reactor. + return generateVariablesForSendingToContainedReactors( + pyObjects, port.getContainer(), (Port) port.getVariable()); } + } - /** Generate into the specified string builder the code to - * send local variables for output ports to a Python reaction function - * from the "self" struct. - * @param output The output port. - */ - public static void generateOutputVariablesToSendToPythonReaction( - List pyObjects, - Output output - ) { - // Unfortunately, for the lf_set macros to work out-of-the-box for - // multiports, we need an array of pointers to the output structs, - // but what we have on the self struct is an array of output structs. - // So we have to handle multiports specially here a construct that - // array of pointers. - // FIXME: The C Generator also has this awkwardness. It makes the code generators - // unnecessarily difficult to maintain, and it may have performance consequences as well. - // Maybe we should change the lf_set macros. - if (!ASTUtils.isMultiport(output)) { - pyObjects.add(generateConvertCPortToPy(output.getName(), NONMULTIPORT_WIDTHSPEC)); - } else { - pyObjects.add(generateConvertCPortToPy(output.getName())); - } + /** + * Generate into the specified string builder the code to send local variables for output ports to + * a Python reaction function from the "self" struct. + * + * @param output The output port. + */ + public static void generateOutputVariablesToSendToPythonReaction( + List pyObjects, Output output) { + // Unfortunately, for the lf_set macros to work out-of-the-box for + // multiports, we need an array of pointers to the output structs, + // but what we have on the self struct is an array of output structs. + // So we have to handle multiports specially here a construct that + // array of pointers. + // FIXME: The C Generator also has this awkwardness. It makes the code generators + // unnecessarily difficult to maintain, and it may have performance consequences as well. + // Maybe we should change the lf_set macros. + if (!ASTUtils.isMultiport(output)) { + pyObjects.add(generateConvertCPortToPy(output.getName(), NONMULTIPORT_WIDTHSPEC)); + } else { + pyObjects.add(generateConvertCPortToPy(output.getName())); } + } - /** Generate into the specified string builder the code to - * send local variables for input ports to a Python reaction function - * from the "self" struct. - * @param input The input port. - */ - public static void generateInputVariablesToSendToPythonReaction( - List pyObjects, - Input input, - ReactorDecl decl - ) { - // Create the local variable whose name matches the input.getName(). - // If the input has not been declared mutable, then this is a pointer - // to the upstream output. Otherwise, it is a copy of the upstream output, - // which nevertheless points to the same token and value. There are 8 cases, - // depending on whether the input is mutable, whether it is a multiport, - // and whether it is a token type. - // Easy case first. - if (!input.isMutable() && !ASTUtils.isMultiport(input)) { - // Non-mutable, non-multiport, primitive type. - pyObjects.add(generateConvertCPortToPy(input.getName())); - } else if (input.isMutable() && !ASTUtils.isMultiport(input)) { - // Mutable, non-multiport, primitive type. - // TODO: handle mutable - pyObjects.add(generateConvertCPortToPy(input.getName())); - } else if (!input.isMutable() && ASTUtils.isMultiport(input)) { - // Non-mutable, multiport, primitive. - // TODO: support multiports - pyObjects.add(generateConvertCPortToPy(input.getName())); - } else { - // Mutable, multiport, primitive type - // TODO: support mutable multiports - pyObjects.add(generateConvertCPortToPy(input.getName())); - } + /** + * Generate into the specified string builder the code to send local variables for input ports to + * a Python reaction function from the "self" struct. + * + * @param input The input port. + */ + public static void generateInputVariablesToSendToPythonReaction( + List pyObjects, Input input, ReactorDecl decl) { + // Create the local variable whose name matches the input.getName(). + // If the input has not been declared mutable, then this is a pointer + // to the upstream output. Otherwise, it is a copy of the upstream output, + // which nevertheless points to the same token and value. There are 8 cases, + // depending on whether the input is mutable, whether it is a multiport, + // and whether it is a token type. + // Easy case first. + if (!input.isMutable() && !ASTUtils.isMultiport(input)) { + // Non-mutable, non-multiport, primitive type. + pyObjects.add(generateConvertCPortToPy(input.getName())); + } else if (input.isMutable() && !ASTUtils.isMultiport(input)) { + // Mutable, non-multiport, primitive type. + // TODO: handle mutable + pyObjects.add(generateConvertCPortToPy(input.getName())); + } else if (!input.isMutable() && ASTUtils.isMultiport(input)) { + // Non-mutable, multiport, primitive. + // TODO: support multiports + pyObjects.add(generateConvertCPortToPy(input.getName())); + } else { + // Mutable, multiport, primitive type + // TODO: support mutable multiports + pyObjects.add(generateConvertCPortToPy(input.getName())); } + } - /** Generate into the specified string builder the code to - * pass local variables for sending data to an input - * of a contained reaction (e.g. for a deadline violation). - * @param definition AST node defining the reactor within which this occurs - * @param port Input of the contained reactor. - */ - public static String generateVariablesForSendingToContainedReactors( - List pyObjects, - Instantiation definition, - Port port - ) { - CodeBuilder code = new CodeBuilder(); - if (definition.getWidthSpec() != null) { - String widthSpec = NONMULTIPORT_WIDTHSPEC; - if (ASTUtils.isMultiport(port)) { - widthSpec = "self->_lf_"+definition.getName()+"[i]."+generateWidthVariable(port.getName()); - } - // Contained reactor is a bank. - // Create a Python list - code.pr(generatePythonListForContainedBank(definition.getName(), port, widthSpec)); - pyObjects.add(definition.getName()+"_py_list"); - } - else { - if (ASTUtils.isMultiport(port)) { - pyObjects.add(generateConvertCPortToPy(definition.getName()+"."+port.getName())); - } else { - pyObjects.add(generateConvertCPortToPy(definition.getName()+"."+port.getName(), NONMULTIPORT_WIDTHSPEC)); - } - } - return code.toString(); + /** + * Generate into the specified string builder the code to pass local variables for sending data to + * an input of a contained reaction (e.g. for a deadline violation). + * + * @param definition AST node defining the reactor within which this occurs + * @param port Input of the contained reactor. + */ + public static String generateVariablesForSendingToContainedReactors( + List pyObjects, Instantiation definition, Port port) { + CodeBuilder code = new CodeBuilder(); + if (definition.getWidthSpec() != null) { + String widthSpec = NONMULTIPORT_WIDTHSPEC; + if (ASTUtils.isMultiport(port)) { + widthSpec = + "self->_lf_" + definition.getName() + "[i]." + generateWidthVariable(port.getName()); + } + // Contained reactor is a bank. + // Create a Python list + code.pr(generatePythonListForContainedBank(definition.getName(), port, widthSpec)); + pyObjects.add(definition.getName() + "_py_list"); + } else { + if (ASTUtils.isMultiport(port)) { + pyObjects.add(generateConvertCPortToPy(definition.getName() + "." + port.getName())); + } else { + pyObjects.add( + generateConvertCPortToPy( + definition.getName() + "." + port.getName(), NONMULTIPORT_WIDTHSPEC)); + } } + return code.toString(); + } + /** + * Generate code that creates a Python list (i.e., []) for contained banks to be passed to Python reactions. + * The Python reaction will then subsequently be able to address each individual bank member of the contained + * bank using an index or an iterator. Each list member will contain the given port + * (which could be a multiport with a width determined by widthSpec). + * + * This is to accommodate reactions like reaction() -> s.out where s is a bank. In this example, + * the generated Python function will have the signature reaction_function_0(self, s_out), where + * s_out is a list of out ports. This will later be turned into the proper s.out format using the + * Python code generated in {@link #generatePythonPortVariableInReaction}. + * + * @param reactorName The name of the bank of reactors (which is the name of the reactor class). + * @param port The port that should be put in the Python list. + * @param widthSpec A string that should be -2 for non-multiports and the width expression for multiports. + */ + public static String generatePythonListForContainedBank( + String reactorName, Port port, String widthSpec) { + return String.join( + "\n", + "PyObject* " + + reactorName + + "_py_list = PyList_New(" + + generateWidthVariable(reactorName) + + ");", + "if(" + reactorName + "_py_list == NULL) {", + " lf_print_error(\"Could not create the list needed for " + reactorName + ".\");", + " if (PyErr_Occurred()) {", + " PyErr_PrintEx(0);", + " PyErr_Clear(); // this will reset the error indicator so we can run Python code" + + " again", + " }", + " /* Release the thread. No Python API allowed beyond this point. */", + " PyGILState_Release(gstate);", + " Py_FinalizeEx();", + " exit(1);", + "}", + "for (int i = 0; i < " + generateWidthVariable(reactorName) + "; i++) {", + " if (PyList_SetItem(" + reactorName + "_py_list,", + " i,", + " " + generateConvertCPortToPy(reactorName + "[i]." + port.getName(), widthSpec), + " ) != 0) {", + " lf_print_error(\"Could not add elements to the list for " + reactorName + ".\");", + " if (PyErr_Occurred()) {", + " PyErr_PrintEx(0);", + " PyErr_Clear(); // this will reset the error indicator so we can run Python" + + " code again", + " }", + " /* Release the thread. No Python API allowed beyond this point. */", + " PyGILState_Release(gstate);", + " Py_FinalizeEx();", + " exit(1);", + " }", + "}"); + } - /** - * Generate code that creates a Python list (i.e., []) for contained banks to be passed to Python reactions. - * The Python reaction will then subsequently be able to address each individual bank member of the contained - * bank using an index or an iterator. Each list member will contain the given port - * (which could be a multiport with a width determined by widthSpec). - * - * This is to accommodate reactions like reaction() -> s.out where s is a bank. In this example, - * the generated Python function will have the signature reaction_function_0(self, s_out), where - * s_out is a list of out ports. This will later be turned into the proper s.out format using the - * Python code generated in {@link #generatePythonPortVariableInReaction}. - * - * @param reactorName The name of the bank of reactors (which is the name of the reactor class). - * @param port The port that should be put in the Python list. - * @param widthSpec A string that should be -2 for non-multiports and the width expression for multiports. - */ - public static String generatePythonListForContainedBank(String reactorName, Port port, String widthSpec) { - return String.join("\n", - "PyObject* "+reactorName+"_py_list = PyList_New("+generateWidthVariable(reactorName)+");", - "if("+reactorName+"_py_list == NULL) {", - " lf_print_error(\"Could not create the list needed for "+reactorName+".\");", - " if (PyErr_Occurred()) {", - " PyErr_PrintEx(0);", - " PyErr_Clear(); // this will reset the error indicator so we can run Python code again", - " }", - " /* Release the thread. No Python API allowed beyond this point. */", - " PyGILState_Release(gstate);", - " Py_FinalizeEx();", - " exit(1);", - "}", - "for (int i = 0; i < "+generateWidthVariable(reactorName)+"; i++) {", - " if (PyList_SetItem("+reactorName+"_py_list,", - " i,", - " "+generateConvertCPortToPy(reactorName + "[i]." + port.getName(), widthSpec), - " ) != 0) {", - " lf_print_error(\"Could not add elements to the list for "+reactorName+".\");", - " if (PyErr_Occurred()) {", - " PyErr_PrintEx(0);", - " PyErr_Clear(); // this will reset the error indicator so we can run Python code again", - " }", - " /* Release the thread. No Python API allowed beyond this point. */", - " PyGILState_Release(gstate);", - " Py_FinalizeEx();", - " exit(1);", - " }", - "}" - ); - } + public static String generateAliasTypeDef( + TypeParameterizedReactor tpr, Port port, boolean isTokenType, String genericPortType) { + return "typedef " + + genericPortType + + " " + + CGenerator.variableStructType(port, tpr, false) + + ";"; + } - public static String generateAliasTypeDef(TypeParameterizedReactor tpr, Port port, boolean isTokenType, String genericPortType) { - return "typedef "+genericPortType+" "+CGenerator.variableStructType(port, tpr, false)+";"; - } - - private static String generateConvertCPortToPy(String port) { - return String.format("convert_C_port_to_py(%s, %s)", port, generateWidthVariable(port)); - } + private static String generateConvertCPortToPy(String port) { + return String.format("convert_C_port_to_py(%s, %s)", port, generateWidthVariable(port)); + } - private static String generateConvertCPortToPy(String port, String widthSpec) { - return String.format("convert_C_port_to_py(%s, %s)", port, widthSpec); - } + private static String generateConvertCPortToPy(String port, String widthSpec) { + return String.format("convert_C_port_to_py(%s, %s)", port, widthSpec); + } - /** - * Generate into the specified string builder (inits) the code to - * initialize local variable for port so that it can be used in the body of - * the Python reaction. - * @param port The port to generate code for. - */ - public static String generatePythonPortVariableInReaction(VarRef port) { - String containerName = port.getContainer().getName(); - String variableName = port.getVariable().getName(); - String tryStatement = "try: "+containerName+" # pylint: disable=used-before-assignment"; - if (port.getContainer().getWidthSpec() != null) { - // It's a bank - return String.join("\n", - tryStatement, - "except NameError: "+containerName+" = [None] * len("+containerName+"_"+variableName+")", - "for i in range(len("+containerName+"_"+variableName+")):", - " if "+containerName+"[i] is None: "+containerName+"[i] = Make()", - " "+containerName+"[i]."+variableName+" = "+containerName+"_"+variableName+"[i]" - ); - } else { - return String.join("\n", - tryStatement, - "except NameError: "+containerName+" = Make()", - containerName+"."+variableName+" = "+containerName+"_"+variableName - ); - } + /** + * Generate into the specified string builder (inits) the code to + * initialize local variable for port so that it can be used in the body of + * the Python reaction. + * @param port The port to generate code for. + */ + public static String generatePythonPortVariableInReaction(VarRef port) { + String containerName = port.getContainer().getName(); + String variableName = port.getVariable().getName(); + String tryStatement = "try: " + containerName + " # pylint: disable=used-before-assignment"; + if (port.getContainer().getWidthSpec() != null) { + // It's a bank + return String.join( + "\n", + tryStatement, + "except NameError: " + + containerName + + " = [None] * len(" + + containerName + + "_" + + variableName + + ")", + "for i in range(len(" + containerName + "_" + variableName + ")):", + " if " + containerName + "[i] is None: " + containerName + "[i] = Make()", + " " + + containerName + + "[i]." + + variableName + + " = " + + containerName + + "_" + + variableName + + "[i]"); + } else { + return String.join( + "\n", + tryStatement, + "except NameError: " + containerName + " = Make()", + containerName + "." + variableName + " = " + containerName + "_" + variableName); } + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java index b69320f6af..bd1291425f 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java @@ -3,60 +3,53 @@ import java.nio.file.Path; import java.util.ArrayList; import java.util.List; -import org.lflang.ast.ASTUtils; import org.lflang.TargetConfig; +import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.generator.c.CPreambleGenerator; import org.lflang.lf.Preamble; - /** - * Generates user-defined preambles and #define and #include directives - * for the Python target. + * Generates user-defined preambles and #define and #include directives for the Python target. * * @author Edward A. Lee * @author Soroush Bateni * @author Hou Seng Wong */ public class PythonPreambleGenerator { - /** - * Generates preambles defined by user for a given reactor. - * The preamble code is put inside the reactor class. - */ - public static String generatePythonPreambles(List preambles) { - List preamblesCode = new ArrayList<>(); - preambles.forEach(p -> preamblesCode.add(ASTUtils.toText(p.getCode()))); - return preamblesCode.size() > 0 ? String.join("\n", + /** + * Generates preambles defined by user for a given reactor. The preamble code is put inside the + * reactor class. + */ + public static String generatePythonPreambles(List preambles) { + List preamblesCode = new ArrayList<>(); + preambles.forEach(p -> preamblesCode.add(ASTUtils.toText(p.getCode()))); + return preamblesCode.size() > 0 + ? String.join( + "\n", "# From the preamble, verbatim:", String.join("\n", preamblesCode), - "# End of preamble." - ) : ""; - } + "# End of preamble.") + : ""; + } - public static String generateCDefineDirectives( - TargetConfig targetConfig, - Path srcGenPath, - boolean hasModalReactors - ) { - // TODO: Delete all of this. It is not used. - CodeBuilder code = new CodeBuilder(); - code.pr(CPreambleGenerator.generateDefineDirectives( - targetConfig, srcGenPath, hasModalReactors) - ); - return code.toString(); - } + public static String generateCDefineDirectives( + TargetConfig targetConfig, Path srcGenPath, boolean hasModalReactors) { + // TODO: Delete all of this. It is not used. + CodeBuilder code = new CodeBuilder(); + code.pr( + CPreambleGenerator.generateDefineDirectives(targetConfig, srcGenPath, hasModalReactors)); + return code.toString(); + } - public static String generateCIncludeStatements( - TargetConfig targetConfig, - boolean CCppMode, - boolean hasModalReactors - ) { - CodeBuilder code = new CodeBuilder(); - code.pr(CPreambleGenerator.generateIncludeStatements(targetConfig, CCppMode)); - code.pr("#include \"pythontarget.h\""); - if (hasModalReactors) { - code.pr("#include \"include/modal_models/definitions.h\""); - } - return code.toString(); + public static String generateCIncludeStatements( + TargetConfig targetConfig, boolean CCppMode, boolean hasModalReactors) { + CodeBuilder code = new CodeBuilder(); + code.pr(CPreambleGenerator.generateIncludeStatements(targetConfig, CCppMode)); + code.pr("#include \"pythontarget.h\""); + if (hasModalReactors) { + code.pr("#include \"include/modal_models/definitions.h\""); } + return code.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java index 3d307b6b52..87f594a71a 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java @@ -4,560 +4,632 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Set; - -import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; import org.lflang.Target; - +import org.lflang.ast.ASTUtils; +import org.lflang.generator.CodeBuilder; +import org.lflang.generator.ReactionInstance; +import org.lflang.generator.ReactorInstance; +import org.lflang.generator.c.CCoreFilesUtils; import org.lflang.generator.c.CReactionGenerator; +import org.lflang.generator.c.CTypes; +import org.lflang.generator.c.CUtil; import org.lflang.generator.c.TypeParameterizedReactor; -import org.lflang.lf.ReactorDecl; -import org.lflang.lf.Reaction; -import org.lflang.lf.Reactor; import org.lflang.lf.Action; import org.lflang.lf.Code; +import org.lflang.lf.Input; +import org.lflang.lf.Instantiation; +import org.lflang.lf.Mode; +import org.lflang.lf.Output; +import org.lflang.lf.Port; +import org.lflang.lf.Reaction; +import org.lflang.lf.Reactor; +import org.lflang.lf.ReactorDecl; import org.lflang.lf.TriggerRef; import org.lflang.lf.VarRef; import org.lflang.util.StringUtil; -import org.lflang.lf.Instantiation; -import org.lflang.lf.Port; -import org.lflang.lf.Input; -import org.lflang.lf.Output; -import org.lflang.generator.c.CCoreFilesUtils; -import org.lflang.generator.c.CTypes; -import org.lflang.generator.c.CUtil; -import org.lflang.generator.CodeBuilder; -import org.lflang.generator.ReactionInstance; -import org.lflang.generator.ReactorInstance; -import org.lflang.lf.Mode; public class PythonReactionGenerator { - /** - * Generate code to call reaction numbered "reactionIndex" in reactor "reactor". - * @param reactor The reactor containing the reaction - * @param reactionIndex The index of the reaction - * @param pyObjects CPython related objects - */ - public static String generateCPythonReactionCaller(TypeParameterizedReactor reactor, - int reactionIndex, - List pyObjects, - String inits) { - String pythonFunctionName = generatePythonReactionFunctionName(reactionIndex); - String cpythonFunctionName = generateCPythonReactionFunctionName(reactionIndex); - return generateCPythonFunctionCaller(CUtil.getName(reactor), pythonFunctionName, cpythonFunctionName, pyObjects, inits); - } - - /** - * Generate code to call deadline function numbered "reactionIndex" in reactor "r". - * @param r The reactor containing the reaction - * @param reactionIndex The index of the reaction - * @param pyObjects CPython related objects - */ - public static String generateCPythonDeadlineCaller(TypeParameterizedReactor r, - int reactionIndex, - List pyObjects) { - String pythonFunctionName = generatePythonDeadlineFunctionName(reactionIndex); - String cpythonFunctionName = generateCPythonDeadlineFunctionName(reactionIndex); - return generateCPythonFunctionCaller(CUtil.getName(r), pythonFunctionName, cpythonFunctionName, pyObjects, ""); - } - - /** - * Generate code to call deadline function numbered "reactionIndex" in reactor "r". - * @param r The reactor containing the reaction - * @param reactionIndex The index of the reaction - * @param pyObjects CPython related objects - */ - public static String generateCPythonSTPCaller(TypeParameterizedReactor r, - int reactionIndex, - List pyObjects) { - String pythonFunctionName = generatePythonSTPFunctionName(reactionIndex); - String cpythonFunctionName = generateCPythonSTPFunctionName(reactionIndex); - return generateCPythonFunctionCaller(CUtil.getName(r), pythonFunctionName, cpythonFunctionName, pyObjects, ""); + /** + * Generate code to call reaction numbered "reactionIndex" in reactor "reactor". + * + * @param reactor The reactor containing the reaction + * @param reactionIndex The index of the reaction + * @param pyObjects CPython related objects + */ + public static String generateCPythonReactionCaller( + TypeParameterizedReactor reactor, int reactionIndex, List pyObjects, String inits) { + String pythonFunctionName = generatePythonReactionFunctionName(reactionIndex); + String cpythonFunctionName = generateCPythonReactionFunctionName(reactionIndex); + return generateCPythonFunctionCaller( + CUtil.getName(reactor), pythonFunctionName, cpythonFunctionName, pyObjects, inits); + } + + /** + * Generate code to call deadline function numbered "reactionIndex" in reactor "r". + * + * @param r The reactor containing the reaction + * @param reactionIndex The index of the reaction + * @param pyObjects CPython related objects + */ + public static String generateCPythonDeadlineCaller( + TypeParameterizedReactor r, int reactionIndex, List pyObjects) { + String pythonFunctionName = generatePythonDeadlineFunctionName(reactionIndex); + String cpythonFunctionName = generateCPythonDeadlineFunctionName(reactionIndex); + return generateCPythonFunctionCaller( + CUtil.getName(r), pythonFunctionName, cpythonFunctionName, pyObjects, ""); + } + + /** + * Generate code to call deadline function numbered "reactionIndex" in reactor "r". + * + * @param r The reactor containing the reaction + * @param reactionIndex The index of the reaction + * @param pyObjects CPython related objects + */ + public static String generateCPythonSTPCaller( + TypeParameterizedReactor r, int reactionIndex, List pyObjects) { + String pythonFunctionName = generatePythonSTPFunctionName(reactionIndex); + String cpythonFunctionName = generateCPythonSTPFunctionName(reactionIndex); + return generateCPythonFunctionCaller( + CUtil.getName(r), pythonFunctionName, cpythonFunctionName, pyObjects, ""); + } + + /** + * Generate code to call a CPython function. + * + * @param reactorDeclName The name of the reactor for debugging purposes + * @param pythonFunctionName The name of the function in the .py file. + * @param cpythonFunctionName The name of the function in self struct of the .c file. + * @param pyObjects CPython related objects + */ + private static String generateCPythonFunctionCaller( + String reactorDeclName, + String pythonFunctionName, + String cpythonFunctionName, + List pyObjects, + String inits) { + String pyObjectsJoined = pyObjects.size() > 0 ? ", " + String.join(", ", pyObjects) : ""; + CodeBuilder code = new CodeBuilder(); + code.pr(PyUtil.generateGILAcquireCode()); + code.pr(inits); + code.pr( + String.join( + "\n", + "LF_PRINT_DEBUG(\"Calling reaction function " + + reactorDeclName + + "." + + pythonFunctionName + + "\");", + "PyObject *rValue = PyObject_CallObject(", + " self->" + cpythonFunctionName + ", ", + " Py_BuildValue(\"(" + "O".repeat(pyObjects.size()) + ")\"" + pyObjectsJoined + ")", + ");", + "if (rValue == NULL) {", + " lf_print_error(\"FATAL: Calling reaction " + + reactorDeclName + + "." + + pythonFunctionName + + " failed.\");", + " if (PyErr_Occurred()) {", + " PyErr_PrintEx(0);", + " PyErr_Clear(); // this will reset the error indicator so we can run Python" + + " code again", + " }", + " " + PyUtil.generateGILReleaseCode(), + " Py_FinalizeEx();", + " exit(1);", + "}", + "", + "/* Release the thread. No Python API allowed beyond this point. */", + PyUtil.generateGILReleaseCode())); + return code.toString(); + } + + /** + * Generate the reaction in the .c file, which calls the Python reaction through the CPython interface. + * + * @param reaction The reaction to generate Python-specific initialization for. + * @param r The reactor to which reaction belongs to. + * @param reactionIndex The index number of the reaction in decl. + * @param mainDef The main reactor. + * @param errorReporter An error reporter. + * @param types A helper class for type-related stuff. + */ + public static String generateCReaction( + Reaction reaction, + TypeParameterizedReactor tpr, + Reactor r, + int reactionIndex, + Instantiation mainDef, + ErrorReporter errorReporter, + CTypes types) { + // Contains the actual comma separated list of inputs to the reaction of type + // generic_port_instance_struct. + // Each input must be cast to (PyObject *) (aka their descriptors for Py_BuildValue are "O") + List pyObjects = new ArrayList<>(); + CodeBuilder code = new CodeBuilder(); + String cPyInit = generateCPythonInitializers(reaction, r, pyObjects, errorReporter); + String cInit = + CReactionGenerator.generateInitializationForReaction( + "", + reaction, + tpr, + reactionIndex, + types, + errorReporter, + mainDef, + Target.Python.requiresTypes); + code.pr("#include " + StringUtil.addDoubleQuotes(CCoreFilesUtils.getCTargetSetHeader())); + code.pr( + generateFunction( + CReactionGenerator.generateReactionFunctionHeader(tpr, reactionIndex), + cInit, + reaction.getCode(), + generateCPythonReactionCaller(tpr, reactionIndex, pyObjects, cPyInit))); + + // Generate code for the STP violation handler, if there is one. + if (reaction.getStp() != null) { + code.pr( + generateFunction( + CReactionGenerator.generateStpFunctionHeader(tpr, reactionIndex), + cInit, + reaction.getStp().getCode(), + generateCPythonSTPCaller(tpr, reactionIndex, pyObjects))); } - - /** - * Generate code to call a CPython function. - * @param reactorDeclName The name of the reactor for debugging purposes - * @param pythonFunctionName The name of the function in the .py file. - * @param cpythonFunctionName The name of the function in self struct of the .c file. - * @param pyObjects CPython related objects - */ - private static String generateCPythonFunctionCaller(String reactorDeclName, - String pythonFunctionName, - String cpythonFunctionName, - List pyObjects, - String inits) { - String pyObjectsJoined = pyObjects.size() > 0 ? ", " + String.join(", ", pyObjects) : ""; - CodeBuilder code = new CodeBuilder(); - code.pr(PyUtil.generateGILAcquireCode()); - code.pr(inits); - code.pr(String.join("\n", - "LF_PRINT_DEBUG(\"Calling reaction function "+reactorDeclName+"."+pythonFunctionName+"\");", - "PyObject *rValue = PyObject_CallObject(", - " self->"+cpythonFunctionName+", ", - " Py_BuildValue(\"("+"O".repeat(pyObjects.size())+")\""+pyObjectsJoined+")", - ");", - "if (rValue == NULL) {", - " lf_print_error(\"FATAL: Calling reaction "+reactorDeclName+"."+pythonFunctionName+" failed.\");", - " if (PyErr_Occurred()) {", - " PyErr_PrintEx(0);", - " PyErr_Clear(); // this will reset the error indicator so we can run Python code again", - " }", - " "+PyUtil.generateGILReleaseCode(), - " Py_FinalizeEx();", - " exit(1);", - "}", - "", - "/* Release the thread. No Python API allowed beyond this point. */", - PyUtil.generateGILReleaseCode() - )); - return code.toString(); + // Generate code for the deadline violation function, if there is one. + if (reaction.getDeadline() != null) { + code.pr( + generateFunction( + CReactionGenerator.generateDeadlineFunctionHeader(tpr, reactionIndex), + cInit, + reaction.getDeadline().getCode(), + generateCPythonDeadlineCaller(tpr, reactionIndex, pyObjects))); } - - /** - * Generate the reaction in the .c file, which calls the Python reaction through the CPython interface. - * - * @param reaction The reaction to generate Python-specific initialization for. - * @param r The reactor to which reaction belongs to. - * @param reactionIndex The index number of the reaction in decl. - * @param mainDef The main reactor. - * @param errorReporter An error reporter. - * @param types A helper class for type-related stuff. - */ - public static String generateCReaction( - Reaction reaction, - TypeParameterizedReactor tpr, - Reactor r, - int reactionIndex, - Instantiation mainDef, - ErrorReporter errorReporter, - CTypes types - ) { - // Contains the actual comma separated list of inputs to the reaction of type generic_port_instance_struct. - // Each input must be cast to (PyObject *) (aka their descriptors for Py_BuildValue are "O") - List pyObjects = new ArrayList<>(); - CodeBuilder code = new CodeBuilder(); - String cPyInit = generateCPythonInitializers(reaction, r, pyObjects, errorReporter); - String cInit = CReactionGenerator.generateInitializationForReaction( - "", reaction, tpr, reactionIndex, - types, errorReporter, mainDef, - Target.Python.requiresTypes); + code.pr("#include " + StringUtil.addDoubleQuotes(CCoreFilesUtils.getCTargetSetUndefHeader())); + return code.toString(); + } + + public static String generateFunction(String header, String init, Code code, String pyCaller) { + var function = new CodeBuilder(); + function.pr(header + "{"); + function.indent(); + function.pr(init); + function.prSourceLineNumber(code); + function.pr(pyCaller); + function.unindent(); + function.pr("}"); + return function.toString(); + } + + /** + * Generate necessary Python-specific initialization code for reaction that belongs to reactor + * decl. + * + * @param reaction The reaction to generate Python-specific initialization for. + * @param decl The reactor to which reaction belongs to. + * @param pyObjects A list of expressions that can be used as additional arguments to Py_BuildValue + * (@see docs.python.org/3/c-api). + * We will use as a format string, "(O...O)" where the number of O's is equal to the length of the list. + */ + private static String generateCPythonInitializers( + Reaction reaction, ReactorDecl decl, List pyObjects, ErrorReporter errorReporter) { + Set actionsAsTriggers = new LinkedHashSet<>(); + Reactor reactor = ASTUtils.toDefinition(decl); + CodeBuilder code = new CodeBuilder(); + // Next, add the triggers (input and actions; timers are not needed). + // TODO: handle triggers + for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { + if (trigger instanceof VarRef triggerAsVarRef) { code.pr( - "#include " + StringUtil.addDoubleQuotes( - CCoreFilesUtils.getCTargetSetHeader())); - code.pr(generateFunction( - CReactionGenerator.generateReactionFunctionHeader(tpr, reactionIndex), - cInit, reaction.getCode(), - generateCPythonReactionCaller(tpr, reactionIndex, pyObjects, cPyInit) - )); - - // Generate code for the STP violation handler, if there is one. - if (reaction.getStp() != null) { - code.pr(generateFunction( - CReactionGenerator.generateStpFunctionHeader(tpr, reactionIndex), - cInit, reaction.getStp().getCode(), - generateCPythonSTPCaller(tpr, reactionIndex, pyObjects) - )); - } - // Generate code for the deadline violation function, if there is one. - if (reaction.getDeadline() != null) { - code.pr(generateFunction( - CReactionGenerator.generateDeadlineFunctionHeader(tpr, reactionIndex), - cInit, reaction.getDeadline().getCode(), - generateCPythonDeadlineCaller(tpr, reactionIndex, pyObjects) - )); - } - code.pr( - "#include " + StringUtil.addDoubleQuotes( - CCoreFilesUtils.getCTargetSetUndefHeader())); - return code.toString(); + generateVariableToSendPythonReaction( + triggerAsVarRef, actionsAsTriggers, decl, pyObjects)); + } } - - public static String generateFunction( - String header, String init, Code code, String pyCaller - ) { - var function = new CodeBuilder(); - function.pr(header + "{"); - function.indent(); - function.pr(init); - function.prSourceLineNumber(code); - function.pr(pyCaller); - function.unindent(); - function.pr("}"); - return function.toString(); + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + // No triggers are given, which means react to any input. + // Declare an argument for every input. + // NOTE: this does not include contained outputs. + for (Input input : reactor.getInputs()) { + PythonPortGenerator.generateInputVariablesToSendToPythonReaction(pyObjects, input, decl); + } } - /** - * Generate necessary Python-specific initialization code for reaction that belongs to reactor - * decl. - * - * @param reaction The reaction to generate Python-specific initialization for. - * @param decl The reactor to which reaction belongs to. - * @param pyObjects A list of expressions that can be used as additional arguments to Py_BuildValue - * (@see docs.python.org/3/c-api). - * We will use as a format string, "(O...O)" where the number of O's is equal to the length of the list. - */ - private static String generateCPythonInitializers(Reaction reaction, - ReactorDecl decl, - List pyObjects, - ErrorReporter errorReporter) { - Set actionsAsTriggers = new LinkedHashSet<>(); - Reactor reactor = ASTUtils.toDefinition(decl); - CodeBuilder code = new CodeBuilder(); - // Next, add the triggers (input and actions; timers are not needed). - // TODO: handle triggers - for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { - if (trigger instanceof VarRef triggerAsVarRef) { - code.pr(generateVariableToSendPythonReaction(triggerAsVarRef, actionsAsTriggers, decl, pyObjects)); - } - } - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - // No triggers are given, which means react to any input. - // Declare an argument for every input. - // NOTE: this does not include contained outputs. - for (Input input : reactor.getInputs()) { - PythonPortGenerator.generateInputVariablesToSendToPythonReaction(pyObjects, input, decl); - } - } - - // Next add non-triggering inputs. - for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { - code.pr(generateVariableToSendPythonReaction(src, actionsAsTriggers, decl, pyObjects)); - } - - // Next, handle effects - if (reaction.getEffects() != null) { - for (VarRef effect : reaction.getEffects()) { - if (effect.getVariable() instanceof Action) { - // It is an action, not an output. - // If it has already appeared as trigger, do not redefine it. - if (!actionsAsTriggers.contains(effect.getVariable())) { - PythonPortGenerator.generateActionVariableToSendToPythonReaction(pyObjects, - (Action) effect.getVariable(), decl); - } - } else if (effect.getVariable() instanceof Mode) { - String name = effect.getVariable().getName(); - pyObjects.add("convert_C_mode_to_py("+name+",(self_base_t*)self, _lf_"+name+"_change_type)"); - } else { - if (effect.getVariable() instanceof Output) { - PythonPortGenerator.generateOutputVariablesToSendToPythonReaction(pyObjects, (Output) effect.getVariable()); - } else if (effect.getVariable() instanceof Input) { - // It is the input of a contained reactor. - code.pr(PythonPortGenerator.generateVariablesForSendingToContainedReactors(pyObjects, effect.getContainer(), (Input) effect.getVariable())); - } else { - errorReporter.reportError( - reaction, - "In generateReaction(): " + effect.getVariable().getName() + " is neither an input nor an output." - ); - } - } - } - } - return code.toString(); + // Next add non-triggering inputs. + for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { + code.pr(generateVariableToSendPythonReaction(src, actionsAsTriggers, decl, pyObjects)); } - /** - * Generate parameters and their respective initialization code for a reaction function - * The initialization code is put at the beginning of the reaction before user code - * @param parameters The parameters used for function definition - * @param inits The initialization code for those paramters - * @param decl Reactor declaration - * @param reaction The reaction to be used to generate parameters for - */ - public static void generatePythonReactionParametersAndInitializations(List parameters, CodeBuilder inits, - ReactorDecl decl, Reaction reaction) { - Reactor reactor = ASTUtils.toDefinition(decl); - LinkedHashSet generatedParams = new LinkedHashSet<>(); - - // Handle triggers - for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { - if (!(trigger instanceof VarRef triggerAsVarRef)) { - continue; - } - if (triggerAsVarRef.getVariable() instanceof Port) { - if (triggerAsVarRef.getVariable() instanceof Input) { - if (((Input) triggerAsVarRef.getVariable()).isMutable()) { - generatedParams.add("mutable_"+triggerAsVarRef.getVariable().getName()); - - // Create a deep copy - if (ASTUtils.isMultiport((Input) triggerAsVarRef.getVariable())) { - inits. - pr(triggerAsVarRef.getVariable().getName()+" = [Make() for i in range(len(mutable_"+triggerAsVarRef.getVariable().getName()+"))]"); - inits.pr("for i in range(len(mutable_"+triggerAsVarRef.getVariable().getName()+")):"); - inits.pr(" "+triggerAsVarRef.getVariable().getName()+"[i].value = copy.deepcopy(mutable_"+triggerAsVarRef.getVariable().getName()+"[i].value)"); - } else { - inits.pr(triggerAsVarRef.getVariable().getName()+" = Make()"); - inits. - pr(triggerAsVarRef.getVariable().getName()+".value = copy.deepcopy(mutable_"+triggerAsVarRef.getVariable().getName()+".value)"); - } - } else { - generatedParams.add(triggerAsVarRef.getVariable().getName()); - } - } else { - // Handle contained reactors' ports - generatedParams.add(triggerAsVarRef.getContainer().getName()+"_"+triggerAsVarRef.getVariable().getName()); - inits.pr(PythonPortGenerator.generatePythonPortVariableInReaction(triggerAsVarRef)); - } - } else if (triggerAsVarRef.getVariable() instanceof Action) { - generatedParams.add(triggerAsVarRef.getVariable().getName()); - } - } - - // Handle non-triggering inputs - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - for (Input input : ASTUtils.convertToEmptyListIfNull(reactor.getInputs())) { - generatedParams.add(input.getName()); - if (input.isMutable()) { - // Create a deep copy - inits.pr(input.getName()+" = copy.deepcopy("+input.getName()+")"); - } - } - } - for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { - if (src.getVariable() instanceof Output) { - // Output of a contained reactor - generatedParams.add(src.getContainer().getName()+"_"+src.getVariable().getName()); - inits.pr(PythonPortGenerator.generatePythonPortVariableInReaction(src)); - } else { - generatedParams.add(src.getVariable().getName()); - if (src.getVariable() instanceof Input) { - if (((Input) src.getVariable()).isMutable()) { - // Create a deep copy - inits.pr(src.getVariable().getName()+" = copy.deepcopy("+src.getVariable().getName()+")"); - } - } - } + // Next, handle effects + if (reaction.getEffects() != null) { + for (VarRef effect : reaction.getEffects()) { + if (effect.getVariable() instanceof Action) { + // It is an action, not an output. + // If it has already appeared as trigger, do not redefine it. + if (!actionsAsTriggers.contains(effect.getVariable())) { + PythonPortGenerator.generateActionVariableToSendToPythonReaction( + pyObjects, (Action) effect.getVariable(), decl); + } + } else if (effect.getVariable() instanceof Mode) { + String name = effect.getVariable().getName(); + pyObjects.add( + "convert_C_mode_to_py(" + + name + + ",(self_base_t*)self, _lf_" + + name + + "_change_type)"); + } else { + if (effect.getVariable() instanceof Output) { + PythonPortGenerator.generateOutputVariablesToSendToPythonReaction( + pyObjects, (Output) effect.getVariable()); + } else if (effect.getVariable() instanceof Input) { + // It is the input of a contained reactor. + code.pr( + PythonPortGenerator.generateVariablesForSendingToContainedReactors( + pyObjects, effect.getContainer(), (Input) effect.getVariable())); + } else { + errorReporter.reportError( + reaction, + "In generateReaction(): " + + effect.getVariable().getName() + + " is neither an input nor an output."); + } } - - // Handle effects - for (VarRef effect : ASTUtils.convertToEmptyListIfNull(reaction.getEffects())) { - if (effect.getVariable() instanceof Input) { - generatedParams.add(effect.getContainer().getName()+"_"+effect.getVariable().getName()); - inits.pr(PythonPortGenerator.generatePythonPortVariableInReaction(effect)); + } + } + return code.toString(); + } + + /** + * Generate parameters and their respective initialization code for a reaction function The + * initialization code is put at the beginning of the reaction before user code + * + * @param parameters The parameters used for function definition + * @param inits The initialization code for those paramters + * @param decl Reactor declaration + * @param reaction The reaction to be used to generate parameters for + */ + public static void generatePythonReactionParametersAndInitializations( + List parameters, CodeBuilder inits, ReactorDecl decl, Reaction reaction) { + Reactor reactor = ASTUtils.toDefinition(decl); + LinkedHashSet generatedParams = new LinkedHashSet<>(); + + // Handle triggers + for (TriggerRef trigger : ASTUtils.convertToEmptyListIfNull(reaction.getTriggers())) { + if (!(trigger instanceof VarRef triggerAsVarRef)) { + continue; + } + if (triggerAsVarRef.getVariable() instanceof Port) { + if (triggerAsVarRef.getVariable() instanceof Input) { + if (((Input) triggerAsVarRef.getVariable()).isMutable()) { + generatedParams.add("mutable_" + triggerAsVarRef.getVariable().getName()); + + // Create a deep copy + if (ASTUtils.isMultiport((Input) triggerAsVarRef.getVariable())) { + inits.pr( + triggerAsVarRef.getVariable().getName() + + " = [Make() for i in range(len(mutable_" + + triggerAsVarRef.getVariable().getName() + + "))]"); + inits.pr( + "for i in range(len(mutable_" + triggerAsVarRef.getVariable().getName() + ")):"); + inits.pr( + " " + + triggerAsVarRef.getVariable().getName() + + "[i].value = copy.deepcopy(mutable_" + + triggerAsVarRef.getVariable().getName() + + "[i].value)"); } else { - generatedParams.add(effect.getVariable().getName()); - if (effect.getVariable() instanceof Port) { - if (ASTUtils.isMultiport((Port) effect.getVariable())) { - // Handle multiports - } - } + inits.pr(triggerAsVarRef.getVariable().getName() + " = Make()"); + inits.pr( + triggerAsVarRef.getVariable().getName() + + ".value = copy.deepcopy(mutable_" + + triggerAsVarRef.getVariable().getName() + + ".value)"); } + } else { + generatedParams.add(triggerAsVarRef.getVariable().getName()); + } + } else { + // Handle contained reactors' ports + generatedParams.add( + triggerAsVarRef.getContainer().getName() + + "_" + + triggerAsVarRef.getVariable().getName()); + inits.pr(PythonPortGenerator.generatePythonPortVariableInReaction(triggerAsVarRef)); } - - for (String s : generatedParams) { - parameters.add(s); - } + } else if (triggerAsVarRef.getVariable() instanceof Action) { + generatedParams.add(triggerAsVarRef.getVariable().getName()); + } } - private static String generateVariableToSendPythonReaction(VarRef varRef, - Set actionsAsTriggers, - ReactorDecl decl, - List pyObjects) { - if (varRef.getVariable() instanceof Port) { - return PythonPortGenerator.generatePortVariablesToSendToPythonReaction(pyObjects, varRef, decl); - } else if (varRef.getVariable() instanceof Action) { - actionsAsTriggers.add((Action) varRef.getVariable()); - PythonPortGenerator.generateActionVariableToSendToPythonReaction(pyObjects, (Action) varRef.getVariable(), decl); + // Handle non-triggering inputs + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + for (Input input : ASTUtils.convertToEmptyListIfNull(reactor.getInputs())) { + generatedParams.add(input.getName()); + if (input.isMutable()) { + // Create a deep copy + inits.pr(input.getName() + " = copy.deepcopy(" + input.getName() + ")"); } - return ""; + } } - - /** - * Generate Python code to link cpython functions to python functions for each reaction. - * @param instance The reactor instance. - * @param mainDef The definition of the main reactor - */ - public static String generateCPythonReactionLinkers( - ReactorInstance instance, - Instantiation mainDef - ) { - String nameOfSelfStruct = CUtil.reactorRef(instance); - Reactor reactor = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); - CodeBuilder code = new CodeBuilder(); - - // Initialize the name field to the unique name of the instance - code.pr(nameOfSelfStruct+"->_lf_name = \""+instance.uniqueID()+"_lf\";"); - - for (ReactionInstance reaction : instance.reactions) { - // Reactions marked with a {@code @_c_body} attribute are generated in C - if (AttributeUtils.hasCBody(reaction.getDefinition())) continue; - // Create a PyObject for each reaction - code.pr(generateCPythonReactionLinker(instance, reaction, nameOfSelfStruct)); + for (VarRef src : ASTUtils.convertToEmptyListIfNull(reaction.getSources())) { + if (src.getVariable() instanceof Output) { + // Output of a contained reactor + generatedParams.add(src.getContainer().getName() + "_" + src.getVariable().getName()); + inits.pr(PythonPortGenerator.generatePythonPortVariableInReaction(src)); + } else { + generatedParams.add(src.getVariable().getName()); + if (src.getVariable() instanceof Input) { + if (((Input) src.getVariable()).isMutable()) { + // Create a deep copy + inits.pr( + src.getVariable().getName() + + " = copy.deepcopy(" + + src.getVariable().getName() + + ")"); + } } - return code.toString(); + } } - /** - * Generate Python code to link cpython functions to python functions for a reaction. - * @param instance The reactor instance. - * @param reaction The reaction of this instance to link. - * @param nameOfSelfStruct The name of the self struct in cpython. - */ - public static String generateCPythonReactionLinker( - ReactorInstance instance, - ReactionInstance reaction, - String nameOfSelfStruct - ) { - CodeBuilder code = new CodeBuilder(); - code.pr(generateCPythonFunctionLinker( - nameOfSelfStruct, generateCPythonReactionFunctionName(reaction.index), - instance, generatePythonReactionFunctionName(reaction.index)) - ); - if (reaction.getDefinition().getStp() != null) { - code.pr(generateCPythonFunctionLinker( - nameOfSelfStruct, generateCPythonSTPFunctionName(reaction.index), - instance, generatePythonSTPFunctionName(reaction.index)) - ); - } - if (reaction.getDefinition().getDeadline() != null) { - code.pr(generateCPythonFunctionLinker( - nameOfSelfStruct, generateCPythonDeadlineFunctionName(reaction.index), - instance, generatePythonDeadlineFunctionName(reaction.index)) - ); + // Handle effects + for (VarRef effect : ASTUtils.convertToEmptyListIfNull(reaction.getEffects())) { + if (effect.getVariable() instanceof Input) { + generatedParams.add(effect.getContainer().getName() + "_" + effect.getVariable().getName()); + inits.pr(PythonPortGenerator.generatePythonPortVariableInReaction(effect)); + } else { + generatedParams.add(effect.getVariable().getName()); + if (effect.getVariable() instanceof Port) { + if (ASTUtils.isMultiport((Port) effect.getVariable())) { + // Handle multiports + } } - return code.toString(); + } } - /** - * Generate code to link "pythonFunctionName" to "cpythonFunctionName" in "nameOfSelfStruct" of "instance". - * @param nameOfSelfStruct the self struct name of instance - * @param cpythonFunctionName the name of the cpython function - * @param instance the reactor instance - * @param pythonFunctionName the name of the python function - */ - private static String generateCPythonFunctionLinker(String nameOfSelfStruct, String cpythonFunctionName, ReactorInstance instance, String pythonFunctionName) { - return String.join("\n", - nameOfSelfStruct+"->"+cpythonFunctionName+" = ", - "get_python_function(\"__main__\", ", - " "+nameOfSelfStruct+"->_lf_name,", - " "+CUtil.runtimeIndex(instance)+",", - " \""+pythonFunctionName+"\");", - "if("+nameOfSelfStruct+"->"+cpythonFunctionName+" == NULL) {", - " lf_print_error_and_exit(\"Could not load function "+pythonFunctionName+"\");", - "}" - ); + for (String s : generatedParams) { + parameters.add(s); } - - /** - * Generate the function that is executed whenever the deadline of the reaction - * with the given reaction index is missed - * @param reaction The reaction to generate deadline miss code for - * @param reactionIndex The agreed-upon index of the reaction in the reactor (should match the C generated code) - * @param reactionParameters The parameters to the deadline violation function, which are the same as the reaction function - */ - public static String generatePythonFunction(String pythonFunctionName, String inits, String reactionBody, List reactionParameters) { - String params = reactionParameters.size() > 0 ? ", " + String.join(", ", reactionParameters) : ""; - CodeBuilder code = new CodeBuilder(); - code.pr("def "+pythonFunctionName+"(self"+params+"):"); - code.indent(); - code.pr(inits); - code.pr(reactionBody); - code.pr("return 0"); - return code.toString(); - } - - - /** - * Generate the Python code for reactions in reactor - * @param reactor The reactor - * @param reactions The reactions of reactor - */ - public static String generatePythonReactions(Reactor reactor, List reactions) { - CodeBuilder code = new CodeBuilder(); - int reactionIndex = 0; - for (Reaction reaction : reactions) { - code.pr(generatePythonReaction(reactor, reaction, reactionIndex)); - reactionIndex++; - } - return code.toString(); - } - - /** - * Generate the Python code for reaction in reactor - * @param reactor The reactor - * @param reaction The reaction of reactor - */ - public static String generatePythonReaction(Reactor reactor, Reaction reaction, int reactionIndex) { - // Reactions marked with a {@code @_c_body} attribute are generated in C - if (AttributeUtils.hasCBody(reaction)) return ""; - - CodeBuilder code = new CodeBuilder(); - List reactionParameters = new ArrayList<>(); // Will contain parameters for the function (e.g., Foo(x,y,z,...) - CodeBuilder inits = new CodeBuilder(); // Will contain initialization code for some parameters - PythonReactionGenerator.generatePythonReactionParametersAndInitializations(reactionParameters, inits, reactor, reaction); - code.pr(generatePythonFunction( - generatePythonReactionFunctionName(reactionIndex), - inits.toString(), - ASTUtils.toText(reaction.getCode()), - reactionParameters - )); - // Generate code for the STP violation handler function, if there is one. - if (reaction.getStp() != null) { - code.pr(generatePythonFunction( - generatePythonSTPFunctionName(reactionIndex), - "", - ASTUtils.toText(reaction.getStp().getCode()), - reactionParameters - )); - } - // Generate code for the deadline violation function, if there is one. - if (reaction.getDeadline() != null) { - code.pr(generatePythonFunction( - generatePythonDeadlineFunctionName(reactionIndex), - "", - ASTUtils.toText(reaction.getDeadline().getCode()), - reactionParameters - )); - } - return code.toString(); + } + + private static String generateVariableToSendPythonReaction( + VarRef varRef, Set actionsAsTriggers, ReactorDecl decl, List pyObjects) { + if (varRef.getVariable() instanceof Port) { + return PythonPortGenerator.generatePortVariablesToSendToPythonReaction( + pyObjects, varRef, decl); + } else if (varRef.getVariable() instanceof Action) { + actionsAsTriggers.add((Action) varRef.getVariable()); + PythonPortGenerator.generateActionVariableToSendToPythonReaction( + pyObjects, (Action) varRef.getVariable(), decl); } - - /** Return the function name of the reaction inside the self struct in the .c file. - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateCPythonReactionFunctionName(int reactionIndex) { - return "_lf_py_reaction_function_"+reactionIndex; + return ""; + } + + /** + * Generate Python code to link cpython functions to python functions for each reaction. + * + * @param instance The reactor instance. + * @param mainDef The definition of the main reactor + */ + public static String generateCPythonReactionLinkers( + ReactorInstance instance, Instantiation mainDef) { + String nameOfSelfStruct = CUtil.reactorRef(instance); + Reactor reactor = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); + CodeBuilder code = new CodeBuilder(); + + // Initialize the name field to the unique name of the instance + code.pr(nameOfSelfStruct + "->_lf_name = \"" + instance.uniqueID() + "_lf\";"); + + for (ReactionInstance reaction : instance.reactions) { + // Reactions marked with a {@code @_c_body} attribute are generated in C + if (AttributeUtils.hasCBody(reaction.getDefinition())) continue; + // Create a PyObject for each reaction + code.pr(generateCPythonReactionLinker(instance, reaction, nameOfSelfStruct)); } - - /** Return the function name of the deadline function inside the self struct in the .c file. - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateCPythonDeadlineFunctionName(int reactionIndex) { - return "_lf_py_deadline_function_"+reactionIndex; + return code.toString(); + } + + /** + * Generate Python code to link cpython functions to python functions for a reaction. + * + * @param instance The reactor instance. + * @param reaction The reaction of this instance to link. + * @param nameOfSelfStruct The name of the self struct in cpython. + */ + public static String generateCPythonReactionLinker( + ReactorInstance instance, ReactionInstance reaction, String nameOfSelfStruct) { + CodeBuilder code = new CodeBuilder(); + code.pr( + generateCPythonFunctionLinker( + nameOfSelfStruct, generateCPythonReactionFunctionName(reaction.index), + instance, generatePythonReactionFunctionName(reaction.index))); + if (reaction.getDefinition().getStp() != null) { + code.pr( + generateCPythonFunctionLinker( + nameOfSelfStruct, generateCPythonSTPFunctionName(reaction.index), + instance, generatePythonSTPFunctionName(reaction.index))); } - - /** Return the function name of the STP violation handler function inside the self struct in the .c file. - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generateCPythonSTPFunctionName(int reactionIndex) { - return "_lf_py_STP_function_"+reactionIndex; + if (reaction.getDefinition().getDeadline() != null) { + code.pr( + generateCPythonFunctionLinker( + nameOfSelfStruct, generateCPythonDeadlineFunctionName(reaction.index), + instance, generatePythonDeadlineFunctionName(reaction.index))); } - - /** Return the function name of the reaction in the .py file. - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generatePythonReactionFunctionName(int reactionIndex) { - return "reaction_function_" + reactionIndex; + return code.toString(); + } + + /** + * Generate code to link "pythonFunctionName" to "cpythonFunctionName" in "nameOfSelfStruct" of + * "instance". + * + * @param nameOfSelfStruct the self struct name of instance + * @param cpythonFunctionName the name of the cpython function + * @param instance the reactor instance + * @param pythonFunctionName the name of the python function + */ + private static String generateCPythonFunctionLinker( + String nameOfSelfStruct, + String cpythonFunctionName, + ReactorInstance instance, + String pythonFunctionName) { + return String.join( + "\n", + nameOfSelfStruct + "->" + cpythonFunctionName + " = ", + "get_python_function(\"__main__\", ", + " " + nameOfSelfStruct + "->_lf_name,", + " " + CUtil.runtimeIndex(instance) + ",", + " \"" + pythonFunctionName + "\");", + "if(" + nameOfSelfStruct + "->" + cpythonFunctionName + " == NULL) {", + " lf_print_error_and_exit(\"Could not load function " + pythonFunctionName + "\");", + "}"); + } + + /** + * Generate the function that is executed whenever the deadline of the reaction with the given + * reaction index is missed + * + * @param reaction The reaction to generate deadline miss code for + * @param reactionIndex The agreed-upon index of the reaction in the reactor (should match the C + * generated code) + * @param reactionParameters The parameters to the deadline violation function, which are the same + * as the reaction function + */ + public static String generatePythonFunction( + String pythonFunctionName, + String inits, + String reactionBody, + List reactionParameters) { + String params = + reactionParameters.size() > 0 ? ", " + String.join(", ", reactionParameters) : ""; + CodeBuilder code = new CodeBuilder(); + code.pr("def " + pythonFunctionName + "(self" + params + "):"); + code.indent(); + code.pr(inits); + code.pr(reactionBody); + code.pr("return 0"); + return code.toString(); + } + + /** + * Generate the Python code for reactions in reactor + * + * @param reactor The reactor + * @param reactions The reactions of reactor + */ + public static String generatePythonReactions(Reactor reactor, List reactions) { + CodeBuilder code = new CodeBuilder(); + int reactionIndex = 0; + for (Reaction reaction : reactions) { + code.pr(generatePythonReaction(reactor, reaction, reactionIndex)); + reactionIndex++; } - - /** Return the function name of the deadline function in the .py file. - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generatePythonDeadlineFunctionName(int reactionIndex) { - return "deadline_function_" + reactionIndex; + return code.toString(); + } + + /** + * Generate the Python code for reaction in reactor + * + * @param reactor The reactor + * @param reaction The reaction of reactor + */ + public static String generatePythonReaction( + Reactor reactor, Reaction reaction, int reactionIndex) { + // Reactions marked with a {@code @_c_body} attribute are generated in C + if (AttributeUtils.hasCBody(reaction)) return ""; + + CodeBuilder code = new CodeBuilder(); + List reactionParameters = + new ArrayList<>(); // Will contain parameters for the function (e.g., Foo(x,y,z,...) + CodeBuilder inits = new CodeBuilder(); // Will contain initialization code for some parameters + PythonReactionGenerator.generatePythonReactionParametersAndInitializations( + reactionParameters, inits, reactor, reaction); + code.pr( + generatePythonFunction( + generatePythonReactionFunctionName(reactionIndex), + inits.toString(), + ASTUtils.toText(reaction.getCode()), + reactionParameters)); + // Generate code for the STP violation handler function, if there is one. + if (reaction.getStp() != null) { + code.pr( + generatePythonFunction( + generatePythonSTPFunctionName(reactionIndex), + "", + ASTUtils.toText(reaction.getStp().getCode()), + reactionParameters)); } - - /** Return the function name of the STP violation handler function in the .py file. - * @param reactionIndex The reaction index. - * @return The function name for the reaction. - */ - public static String generatePythonSTPFunctionName(int reactionIndex) { - return "STP_function_" + reactionIndex; + // Generate code for the deadline violation function, if there is one. + if (reaction.getDeadline() != null) { + code.pr( + generatePythonFunction( + generatePythonDeadlineFunctionName(reactionIndex), + "", + ASTUtils.toText(reaction.getDeadline().getCode()), + reactionParameters)); } + return code.toString(); + } + + /** + * Return the function name of the reaction inside the self struct in the .c file. + * + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateCPythonReactionFunctionName(int reactionIndex) { + return "_lf_py_reaction_function_" + reactionIndex; + } + + /** + * Return the function name of the deadline function inside the self struct in the .c file. + * + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateCPythonDeadlineFunctionName(int reactionIndex) { + return "_lf_py_deadline_function_" + reactionIndex; + } + + /** + * Return the function name of the STP violation handler function inside the self struct in the .c + * file. + * + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generateCPythonSTPFunctionName(int reactionIndex) { + return "_lf_py_STP_function_" + reactionIndex; + } + + /** + * Return the function name of the reaction in the .py file. + * + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generatePythonReactionFunctionName(int reactionIndex) { + return "reaction_function_" + reactionIndex; + } + + /** + * Return the function name of the deadline function in the .py file. + * + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generatePythonDeadlineFunctionName(int reactionIndex) { + return "deadline_function_" + reactionIndex; + } + + /** + * Return the function name of the STP violation handler function in the .py file. + * + * @param reactionIndex The reaction index. + * @return The function name for the reaction. + */ + public static String generatePythonSTPFunctionName(int reactionIndex) { + return "STP_function_" + reactionIndex; + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java index 6e1a7f0183..8f2d3fd8ad 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java @@ -11,149 +11,162 @@ import org.lflang.lf.ReactorDecl; public class PythonReactorGenerator { - /** - * Wrapper function for the more elaborate generatePythonReactorClass that keeps track - * of visited reactors to avoid duplicate generation - * @param instance The reactor instance to be generated - */ - public static String generatePythonClass(ReactorInstance instance, ReactorInstance main, PythonTypes types) { - List instantiatedClasses = new ArrayList<>(); - return generatePythonClass(instance, instantiatedClasses, main, types); - } - - /** - * Generate a Python class corresponding to decl - * @param instance The reactor instance to be generated - * @param instantiatedClasses A list of visited instances to avoid generating duplicates - */ - public static String generatePythonClass(ReactorInstance instance, - List instantiatedClasses, - ReactorInstance main, PythonTypes types) { - CodeBuilder pythonClasses = new CodeBuilder(); - ReactorDecl decl = instance.getDefinition().getReactorClass(); - Reactor reactor = ASTUtils.toDefinition(decl); - String className = PyUtil.getName(instance.tpr); - if (instantiatedClasses == null) { - return ""; - } - - if (!instantiatedClasses.contains(className)) { - pythonClasses.pr(generatePythonClassHeader(className)); - // Generate preamble code - pythonClasses.indent(); - pythonClasses.pr(PythonPreambleGenerator.generatePythonPreambles(reactor.getPreambles())); - // Handle runtime initializations - pythonClasses.pr(generatePythonConstructor(decl, types)); - pythonClasses.pr(PythonParameterGenerator.generatePythonGetters(decl)); - // Generate methods - pythonClasses.pr(PythonMethodGenerator.generateMethods(reactor)); - // Generate reactions - List reactionToGenerate = ASTUtils.allReactions(reactor); - pythonClasses.pr(PythonReactionGenerator.generatePythonReactions(reactor, reactionToGenerate)); - pythonClasses.unindent(); - pythonClasses.pr("\n"); - instantiatedClasses.add(className); - } + /** + * Wrapper function for the more elaborate generatePythonReactorClass that keeps track of visited + * reactors to avoid duplicate generation + * + * @param instance The reactor instance to be generated + */ + public static String generatePythonClass( + ReactorInstance instance, ReactorInstance main, PythonTypes types) { + List instantiatedClasses = new ArrayList<>(); + return generatePythonClass(instance, instantiatedClasses, main, types); + } - for (ReactorInstance child : instance.children) { - pythonClasses.pr(generatePythonClass(child, instantiatedClasses, main, types)); - } - return pythonClasses.getCode(); + /** + * Generate a Python class corresponding to decl + * + * @param instance The reactor instance to be generated + * @param instantiatedClasses A list of visited instances to avoid generating duplicates + */ + public static String generatePythonClass( + ReactorInstance instance, + List instantiatedClasses, + ReactorInstance main, + PythonTypes types) { + CodeBuilder pythonClasses = new CodeBuilder(); + ReactorDecl decl = instance.getDefinition().getReactorClass(); + Reactor reactor = ASTUtils.toDefinition(decl); + String className = PyUtil.getName(instance.tpr); + if (instantiatedClasses == null) { + return ""; } - private static String generatePythonClassHeader(String className) { - return String.join("\n", - "# Python class for reactor "+className+"", - "class _"+className+":" - ); + if (!instantiatedClasses.contains(className)) { + pythonClasses.pr(generatePythonClassHeader(className)); + // Generate preamble code + pythonClasses.indent(); + pythonClasses.pr(PythonPreambleGenerator.generatePythonPreambles(reactor.getPreambles())); + // Handle runtime initializations + pythonClasses.pr(generatePythonConstructor(decl, types)); + pythonClasses.pr(PythonParameterGenerator.generatePythonGetters(decl)); + // Generate methods + pythonClasses.pr(PythonMethodGenerator.generateMethods(reactor)); + // Generate reactions + List reactionToGenerate = ASTUtils.allReactions(reactor); + pythonClasses.pr( + PythonReactionGenerator.generatePythonReactions(reactor, reactionToGenerate)); + pythonClasses.unindent(); + pythonClasses.pr("\n"); + instantiatedClasses.add(className); } - /** - * Generate code that instantiates and initializes parameters and state variables for a reactor 'decl'. - * - * @param decl The reactor declaration - * @return The generated code as a StringBuilder - */ - private static String generatePythonConstructor(ReactorDecl decl, PythonTypes types) { - CodeBuilder code = new CodeBuilder(); - code.pr("# Constructor"); - code.pr("def __init__(self, **kwargs):"); - code.indent(); - code.pr(PythonParameterGenerator.generatePythonInstantiations(decl, types)); - code.pr(PythonStateGenerator.generatePythonInstantiations(decl)); - return code.toString(); + for (ReactorInstance child : instance.children) { + pythonClasses.pr(generatePythonClass(child, instantiatedClasses, main, types)); } + return pythonClasses.getCode(); + } - /** - * Generate code to instantiate a Python list that will hold the Python - * class instance of reactor instance. Will recursively do - * the same for the children of instance as well. - * - * @param instance The reactor instance for which the Python list will be created. - */ - public static String generateListsToHoldClassInstances(ReactorInstance instance) { - CodeBuilder code = new CodeBuilder(); - code.pr(PyUtil.reactorRefName(instance)+" = [None] * "+instance.getTotalWidth()); - for (ReactorInstance child : instance.children) { - code.pr(generateListsToHoldClassInstances(child)); - } - return code.toString(); + private static String generatePythonClassHeader(String className) { + return String.join( + "\n", "# Python class for reactor " + className + "", "class _" + className + ":"); + } + + /** + * Generate code that instantiates and initializes parameters and state variables for a reactor + * 'decl'. + * + * @param decl The reactor declaration + * @return The generated code as a StringBuilder + */ + private static String generatePythonConstructor(ReactorDecl decl, PythonTypes types) { + CodeBuilder code = new CodeBuilder(); + code.pr("# Constructor"); + code.pr("def __init__(self, **kwargs):"); + code.indent(); + code.pr(PythonParameterGenerator.generatePythonInstantiations(decl, types)); + code.pr(PythonStateGenerator.generatePythonInstantiations(decl)); + return code.toString(); + } + + /** + * Generate code to instantiate a Python list that will hold the Python + * class instance of reactor instance. Will recursively do + * the same for the children of instance as well. + * + * @param instance The reactor instance for which the Python list will be created. + */ + public static String generateListsToHoldClassInstances(ReactorInstance instance) { + CodeBuilder code = new CodeBuilder(); + code.pr(PyUtil.reactorRefName(instance) + " = [None] * " + instance.getTotalWidth()); + for (ReactorInstance child : instance.children) { + code.pr(generateListsToHoldClassInstances(child)); } + return code.toString(); + } - /** - * Instantiate classes in Python, as well as subclasses. - * Instances are always instantiated as a list of className = [_className, _className, ...] depending on the size of the bank. - * If there is no bank or the size is 1, the instance would be generated as className = [_className] - * @param instance The reactor instance to be instantiated - * @param main The main reactor - */ - public static String generatePythonClassInstantiations(ReactorInstance instance, - ReactorInstance main) { - CodeBuilder code = new CodeBuilder(); + /** + * Instantiate classes in Python, as well as subclasses. Instances are always instantiated as a + * list of className = [_className, _className, ...] depending on the size of the bank. If there + * is no bank or the size is 1, the instance would be generated as className = [_className] + * + * @param instance The reactor instance to be instantiated + * @param main The main reactor + */ + public static String generatePythonClassInstantiations( + ReactorInstance instance, ReactorInstance main) { + CodeBuilder code = new CodeBuilder(); - String className = PyUtil.getName(instance.tpr); + String className = PyUtil.getName(instance.tpr); - if (instance.getWidth() > 0) { - // For each reactor instance, create a list regardless of whether it is a bank or not. - // Non-bank reactor instances will be a list of size 1. - String fullName = instance.getFullName(); - code.pr(String.join("\n", - "# Start initializing "+fullName+" of class "+className, - "for "+PyUtil.bankIndexName(instance)+" in range("+instance.getWidth()+"):" - )); - code.indent(); - // Define a bank_index local variable so that it can be used while - // setting parameter values. - code.pr("bank_index = "+PyUtil.bankIndexName(instance)); - code.pr(generatePythonClassInstantiation(instance, className)); - } + if (instance.getWidth() > 0) { + // For each reactor instance, create a list regardless of whether it is a bank or not. + // Non-bank reactor instances will be a list of size 1. + String fullName = instance.getFullName(); + code.pr( + String.join( + "\n", + "# Start initializing " + fullName + " of class " + className, + "for " + PyUtil.bankIndexName(instance) + " in range(" + instance.getWidth() + "):")); + code.indent(); + // Define a bank_index local variable so that it can be used while + // setting parameter values. + code.pr("bank_index = " + PyUtil.bankIndexName(instance)); + code.pr(generatePythonClassInstantiation(instance, className)); + } - for (ReactorInstance child : instance.children) { - code.pr(generatePythonClassInstantiations(child, main)); - } - code.unindent(); - return code.toString(); + for (ReactorInstance child : instance.children) { + code.pr(generatePythonClassInstantiations(child, main)); } + code.unindent(); + return code.toString(); + } - /** - * Instantiate a class with className in instance. - * @param instance The reactor instance to be instantiated - * @param className The name of the class to instantiate - */ - private static String generatePythonClassInstantiation(ReactorInstance instance, - String className) { - CodeBuilder code = new CodeBuilder(); - code.pr(PyUtil.reactorRef(instance)+" = _"+className+"("); - code.indent(); - // Always add the bank_index - code.pr("_bank_index = "+PyUtil.bankIndex(instance)+","); - for (ParameterInstance param : instance.parameters) { - if (!param.getName().equals("bank_index")) { - code.pr("_"+param.getName()+"="+ PythonParameterGenerator.generatePythonInitializer(param)+","); - } - } - code.unindent(); - code.pr(")"); - return code.toString(); + /** + * Instantiate a class with className in instance. + * + * @param instance The reactor instance to be instantiated + * @param className The name of the class to instantiate + */ + private static String generatePythonClassInstantiation( + ReactorInstance instance, String className) { + CodeBuilder code = new CodeBuilder(); + code.pr(PyUtil.reactorRef(instance) + " = _" + className + "("); + code.indent(); + // Always add the bank_index + code.pr("_bank_index = " + PyUtil.bankIndex(instance) + ","); + for (ParameterInstance param : instance.parameters) { + if (!param.getName().equals("bank_index")) { + code.pr( + "_" + + param.getName() + + "=" + + PythonParameterGenerator.generatePythonInitializer(param) + + ","); + } } + code.unindent(); + code.pr(")"); + return code.toString(); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java b/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java index e318a8812c..45dc8cf7d5 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java @@ -2,36 +2,38 @@ import java.util.ArrayList; import java.util.List; - import org.lflang.ast.ASTUtils; import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; public class PythonStateGenerator { - /** - * Generate state variable instantiations for reactor "decl" - * @param decl The reactor declaration to generate state variables. - */ - public static String generatePythonInstantiations(ReactorDecl decl) { - List lines = new ArrayList<>(); - lines.add("# Define state variables"); - // Next, handle state variables - for (StateVar state : ASTUtils.allStateVars(ASTUtils.toDefinition(decl))) { - lines.add("self."+state.getName()+" = "+generatePythonInitializer(state)); - } - lines.add(""); - return String.join("\n", lines); + /** + * Generate state variable instantiations for reactor "decl" + * + * @param decl The reactor declaration to generate state variables. + */ + public static String generatePythonInstantiations(ReactorDecl decl) { + List lines = new ArrayList<>(); + lines.add("# Define state variables"); + // Next, handle state variables + for (StateVar state : ASTUtils.allStateVars(ASTUtils.toDefinition(decl))) { + lines.add("self." + state.getName() + " = " + generatePythonInitializer(state)); } + lines.add(""); + return String.join("\n", lines); + } - /** - * Handle initialization for state variable - * @param state a state variable - */ - public static String generatePythonInitializer(StateVar state) { - if (!ASTUtils.isInitialized(state)) { - return "None"; - } - List list = state.getInit().getExprs().stream().map(PyUtil::getPythonTargetValue).toList(); - return list.size() > 1 ? "[" + String.join(", ", list) + "]" : list.get(0); + /** + * Handle initialization for state variable + * + * @param state a state variable + */ + public static String generatePythonInitializer(StateVar state) { + if (!ASTUtils.isInitialized(state)) { + return "None"; } + List list = + state.getInit().getExprs().stream().map(PyUtil::getPythonTargetValue).toList(); + return list.size() > 1 ? "[" + String.join(", ", list) + "]" : list.get(0); + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonTypes.java b/org.lflang/src/org/lflang/generator/python/PythonTypes.java index 5b62ee5f97..66abfabf5f 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonTypes.java +++ b/org.lflang/src/org/lflang/generator/python/PythonTypes.java @@ -3,74 +3,74 @@ import java.util.List; import java.util.regex.Pattern; import java.util.stream.Collectors; - import org.lflang.InferredType; import org.lflang.generator.ReactorInstance; import org.lflang.generator.c.CTypes; -import org.lflang.generator.c.CUtil; import org.lflang.lf.ParameterReference; public class PythonTypes extends CTypes { - // Regular expression pattern for pointer types. The star at the end has to be visible. - static final Pattern pointerPatternVariable = Pattern.compile("^\\s*+(\\w+)\\s*\\*\\s*$"); - private static final PythonTypes INSTANCE = new PythonTypes(); + // Regular expression pattern for pointer types. The star at the end has to be visible. + static final Pattern pointerPatternVariable = Pattern.compile("^\\s*+(\\w+)\\s*\\*\\s*$"); + private static final PythonTypes INSTANCE = new PythonTypes(); - @Override - public String getTargetUndefinedType() { - return "PyObject*"; - } + @Override + public String getTargetUndefinedType() { + return "PyObject*"; + } - /** - * This generator inherits types from the CGenerator. - * This function reverts them back to Python types - * For example, the types double is converted to float, - * the * for pointer types is removed, etc. - * @param type The type - * @return The Python equivalent of a C type - */ - public String getPythonType(InferredType type) { - var result = super.getTargetType(type); + /** + * This generator inherits types from the CGenerator. This function reverts them back to Python + * types For example, the types double is converted to float, the * for pointer types is removed, + * etc. + * + * @param type The type + * @return The Python equivalent of a C type + */ + public String getPythonType(InferredType type) { + var result = super.getTargetType(type); - result = switch (result) { - case "double" -> "float"; - case "string" -> "object"; - default -> result; + result = + switch (result) { + case "double" -> "float"; + case "string" -> "object"; + default -> result; }; - var matcher = pointerPatternVariable.matcher(result); - if (matcher.find()) { - return matcher.group(1); - } - - return result; + var matcher = pointerPatternVariable.matcher(result); + if (matcher.find()) { + return matcher.group(1); } - @Override - public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { - return "self." + expr.getParameter().getName(); - } + return result; + } - @Override - public String getFixedSizeListInitExpression(List contents, int listSize, boolean withBraces) { - return contents.stream().collect(Collectors.joining(", ", "[ ", " ]")); - } + @Override + public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + return "self." + expr.getParameter().getName(); + } - @Override - public String getVariableSizeListInitExpression(List contents, boolean withBraces) { - return contents.stream().collect(Collectors.joining(", ", "[ ", " ]")); - } + @Override + public String getFixedSizeListInitExpression( + List contents, int listSize, boolean withBraces) { + return contents.stream().collect(Collectors.joining(", ", "[ ", " ]")); + } - public static PythonTypes getInstance() { - return INSTANCE; - } + @Override + public String getVariableSizeListInitExpression(List contents, boolean withBraces) { + return contents.stream().collect(Collectors.joining(", ", "[ ", " ]")); + } - public static PythonTypes generateParametersIn(ReactorInstance instance) { - return new PythonTypes() { - @Override - public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { - return PyUtil.reactorRef(instance) + "." + expr.getParameter().getName(); - } - }; - } + public static PythonTypes getInstance() { + return INSTANCE; + } + + public static PythonTypes generateParametersIn(ReactorInstance instance) { + return new PythonTypes() { + @Override + public String getTargetParamRef(ParameterReference expr, InferredType typeOrNull) { + return PyUtil.reactorRef(instance) + "." + expr.getParameter().getName(); + } + }; + } } diff --git a/org.lflang/src/org/lflang/generator/python/PythonValidator.java b/org.lflang/src/org/lflang/generator/python/PythonValidator.java index 989d4181fc..dc87417c51 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonValidator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonValidator.java @@ -1,5 +1,11 @@ package org.lflang.generator.python; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; import java.nio.file.Path; import java.util.Collection; import java.util.List; @@ -8,9 +14,7 @@ import java.util.function.Function; import java.util.regex.Matcher; import java.util.regex.Pattern; - import org.eclipse.lsp4j.DiagnosticSeverity; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.generator.CodeMap; @@ -20,13 +24,6 @@ import org.lflang.generator.ValidationStrategy; import org.lflang.util.LFCommand; -import com.fasterxml.jackson.annotation.JsonProperty; -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.DeserializationFeature; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.ImmutableSet; - /** * A validator for generated Python. * @@ -34,317 +31,375 @@ */ public class PythonValidator extends org.lflang.generator.Validator { - /** The pattern that diagnostics from the Python compiler typically follow. */ - private static final Pattern DIAGNOSTIC_MESSAGE_PATTERN = Pattern.compile( - "(\\*\\*\\*)?\\s*File \"(?.*?\\.py)\", line (?\\d+)" - ); - /** The pattern typically followed by the message that typically follows the main diagnostic line. */ - private static final Pattern MESSAGE = Pattern.compile("\\w*Error: .*"); - /** An alternative pattern that at least some diagnostics from the Python compiler may follow. */ - private static final Pattern ALT_DIAGNOSTIC_MESSAGE_PATTERN = Pattern.compile( - ".*Error:.*line (?\\d+)\\)" - ); - - /** The JSON parser. */ - private static final ObjectMapper mapper = new ObjectMapper() - .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); - - private final Set protoNames; - - /** - * The message format of Pylint's JSON output. - */ - @SuppressWarnings( {"FieldCanBeLocal", "unused"}) // Unused fields are included for completeness. - private static final class PylintMessage { - private String type; - private String module; - private String obj; - private Integer line; - private Integer column; - private Integer endLine; - private Integer endColumn; - private Path path; - private String symbol; - private String message; - private String messageId; - public void setType(String type) { this.type = type; } - public void setModule(String module) { this.module = module; } - public void setObj(String obj) { this.obj = obj; } - public void setLine(int line) { this.line = line; } - public void setColumn(int column) { this.column = column; } - public void setEndLine(int endLine) { this.endLine = endLine; } - public void setEndColumn(int endColumn) { this.endColumn = endColumn; } - public void setPath(String path) { this.path = Path.of(path); } - public void setSymbol(String symbol) { this.symbol = symbol; } - public void setMessage(String message) { this.message = message; } - @JsonProperty("message-id") - public void setMessageId(String messageId) { this.messageId = messageId; } - public Position getStart() { - if (line != null && column != null) return Position.fromZeroBased(line - 1, column); - // Use 0 as fallback for the column. This will cause bugs by taking some positions out of the line - // adjuster's range. - if (line != null) return Position.fromZeroBased(line - 1, 0); - // This fallback will always fail with the line adjuster, but at least the program will not crash. - return Position.ORIGIN; - } - public Position getEnd() { - return endLine == null || endColumn == null ? getStart().plus(" ") : - Position.fromZeroBased(endLine - 1, endColumn); - } - public Path getPath(Path relativeTo) { return relativeTo.resolve(path); } - public DiagnosticSeverity getSeverity() { - // The following is consistent with VS Code's default behavior for pure Python: - // https://code.visualstudio.com/docs/python/linting#_pylint - switch (type.toLowerCase()) { - case "refactor": - return DiagnosticSeverity.Hint; - case "warning": - return DiagnosticSeverity.Warning; - case "error": - case "fatal": - return DiagnosticSeverity.Error; - case "convention": - default: - return DiagnosticSeverity.Information; - } - } + /** The pattern that diagnostics from the Python compiler typically follow. */ + private static final Pattern DIAGNOSTIC_MESSAGE_PATTERN = + Pattern.compile("(\\*\\*\\*)?\\s*File \"(?.*?\\.py)\", line (?\\d+)"); + /** + * The pattern typically followed by the message that typically follows the main diagnostic line. + */ + private static final Pattern MESSAGE = Pattern.compile("\\w*Error: .*"); + /** An alternative pattern that at least some diagnostics from the Python compiler may follow. */ + private static final Pattern ALT_DIAGNOSTIC_MESSAGE_PATTERN = + Pattern.compile(".*Error:.*line (?\\d+)\\)"); + + /** The JSON parser. */ + private static final ObjectMapper mapper = + new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + + private final Set protoNames; + + /** The message format of Pylint's JSON output. */ + @SuppressWarnings({"FieldCanBeLocal", "unused"}) // Unused fields are included for completeness. + private static final class PylintMessage { + private String type; + private String module; + private String obj; + private Integer line; + private Integer column; + private Integer endLine; + private Integer endColumn; + private Path path; + private String symbol; + private String message; + private String messageId; + + public void setType(String type) { + this.type = type; } - private static final Pattern PylintNoNamePattern = Pattern.compile("Instance of '(?\\w+)' has no .*"); - - private final FileConfig fileConfig; - private final ErrorReporter errorReporter; - private final ImmutableMap codeMaps; - - /** - * Initialize a {@code PythonValidator} for a build process using {@code fileConfig} and - * report errors to {@code errorReporter}. - * @param fileConfig The file configuration of this build. - * @param errorReporter The reporter to which diagnostics should be sent. - * @param codeMaps A mapping from generated file paths to code maps that map them back to - * LF sources. - * @param protoNames The names of any protocol buffer message types that are used in the LF - * program being built. - */ - public PythonValidator( - FileConfig fileConfig, - ErrorReporter errorReporter, - Map codeMaps, - Set protoNames - ) { - super(errorReporter, codeMaps); - this.fileConfig = fileConfig; - this.errorReporter = errorReporter; - this.codeMaps = ImmutableMap.copyOf(codeMaps); - this.protoNames = ImmutableSet.copyOf(protoNames); + public void setModule(String module) { + this.module = module; } - @Override - protected Collection getPossibleStrategies() { return List.of( + public void setObj(String obj) { + this.obj = obj; + } + + public void setLine(int line) { + this.line = line; + } + + public void setColumn(int column) { + this.column = column; + } + + public void setEndLine(int endLine) { + this.endLine = endLine; + } + + public void setEndColumn(int endColumn) { + this.endColumn = endColumn; + } + + public void setPath(String path) { + this.path = Path.of(path); + } + + public void setSymbol(String symbol) { + this.symbol = symbol; + } + + public void setMessage(String message) { + this.message = message; + } + + @JsonProperty("message-id") + public void setMessageId(String messageId) { + this.messageId = messageId; + } + + public Position getStart() { + if (line != null && column != null) return Position.fromZeroBased(line - 1, column); + // Use 0 as fallback for the column. This will cause bugs by taking some positions out of the + // line + // adjuster's range. + if (line != null) return Position.fromZeroBased(line - 1, 0); + // This fallback will always fail with the line adjuster, but at least the program will not + // crash. + return Position.ORIGIN; + } + + public Position getEnd() { + return endLine == null || endColumn == null + ? getStart().plus(" ") + : Position.fromZeroBased(endLine - 1, endColumn); + } + + public Path getPath(Path relativeTo) { + return relativeTo.resolve(path); + } + + public DiagnosticSeverity getSeverity() { + // The following is consistent with VS Code's default behavior for pure Python: + // https://code.visualstudio.com/docs/python/linting#_pylint + switch (type.toLowerCase()) { + case "refactor": + return DiagnosticSeverity.Hint; + case "warning": + return DiagnosticSeverity.Warning; + case "error": + case "fatal": + return DiagnosticSeverity.Error; + case "convention": + default: + return DiagnosticSeverity.Information; + } + } + } + + private static final Pattern PylintNoNamePattern = + Pattern.compile("Instance of '(?\\w+)' has no .*"); + + private final FileConfig fileConfig; + private final ErrorReporter errorReporter; + private final ImmutableMap codeMaps; + + /** + * Initialize a {@code PythonValidator} for a build process using {@code fileConfig} and report + * errors to {@code errorReporter}. + * + * @param fileConfig The file configuration of this build. + * @param errorReporter The reporter to which diagnostics should be sent. + * @param codeMaps A mapping from generated file paths to code maps that map them back to LF + * sources. + * @param protoNames The names of any protocol buffer message types that are used in the LF + * program being built. + */ + public PythonValidator( + FileConfig fileConfig, + ErrorReporter errorReporter, + Map codeMaps, + Set protoNames) { + super(errorReporter, codeMaps); + this.fileConfig = fileConfig; + this.errorReporter = errorReporter; + this.codeMaps = ImmutableMap.copyOf(codeMaps); + this.protoNames = ImmutableSet.copyOf(protoNames); + } + + @Override + protected Collection getPossibleStrategies() { + return List.of( new ValidationStrategy() { - @Override - public LFCommand getCommand(Path generatedFile) { - return LFCommand.get( - "python3", - List.of("-c", "import compileall; compileall.compile_dir('.', quiet=1)"), - true, - fileConfig.getSrcGenPkgPath() - ); - } + @Override + public LFCommand getCommand(Path generatedFile) { + return LFCommand.get( + "python3", + List.of("-c", "import compileall; compileall.compile_dir('.', quiet=1)"), + true, + fileConfig.getSrcGenPkgPath()); + } - @Override - public Strategy getErrorReportingStrategy() { - return (a, b, c) -> {}; - } + @Override + public Strategy getErrorReportingStrategy() { + return (a, b, c) -> {}; + } - @Override - public Strategy getOutputReportingStrategy() { - return (String validationOutput, ErrorReporter errorReporter, Map map) -> { - String[] lines = (validationOutput + "\n\n\n").lines().toArray(String[]::new); - for (int i = 0; i < lines.length - 3; i++) { - if (!tryReportTypical(lines, i)) { - tryReportAlternative(lines, i); - } - } - }; - } + @Override + public Strategy getOutputReportingStrategy() { + return (String validationOutput, + ErrorReporter errorReporter, + Map map) -> { + String[] lines = (validationOutput + "\n\n\n").lines().toArray(String[]::new); + for (int i = 0; i < lines.length - 3; i++) { + if (!tryReportTypical(lines, i)) { + tryReportAlternative(lines, i); + } + } + }; + } - /** - * Try to report a typical error message from the Python compiler. - * - * @param lines The lines of output from the compiler. - * @param i The current index at which a message may start. Guaranteed to be less - * than - * {@code lines.length - 3}. - * @return Whether an error message was reported. - */ - private boolean tryReportTypical(String[] lines, int i) { - Matcher main = DIAGNOSTIC_MESSAGE_PATTERN.matcher(lines[i]); - Matcher messageMatcher = MESSAGE.matcher(lines[i + 3]); - String message = messageMatcher.matches() ? messageMatcher.group() : "Syntax Error"; - if (main.matches()) { - int line = Integer.parseInt(main.group("line")); - CodeMap map = codeMaps.get(fileConfig.getSrcGenPkgPath().resolve(Path.of(main.group("path"))).normalize()); - Position genPosition = Position.fromOneBased(line, Integer.MAX_VALUE); // Column is just a placeholder. - if (map == null) { - errorReporter.report(null, DiagnosticSeverity.Error, message, 1); // Undesirable fallback - } else { - for (Path lfFile : map.lfSourcePaths()) { - Position lfPosition = map.adjusted(lfFile, genPosition); - // TODO: We could be more precise than just getting the right line, but the way the output - // is formatted (with leading whitespace possibly trimmed) does not make it easy. - errorReporter.report(lfFile, DiagnosticSeverity.Error, message, lfPosition.getOneBasedLine()); - } - } - return true; + /** + * Try to report a typical error message from the Python compiler. + * + * @param lines The lines of output from the compiler. + * @param i The current index at which a message may start. Guaranteed to be less than + * {@code lines.length - 3}. + * @return Whether an error message was reported. + */ + private boolean tryReportTypical(String[] lines, int i) { + Matcher main = DIAGNOSTIC_MESSAGE_PATTERN.matcher(lines[i]); + Matcher messageMatcher = MESSAGE.matcher(lines[i + 3]); + String message = messageMatcher.matches() ? messageMatcher.group() : "Syntax Error"; + if (main.matches()) { + int line = Integer.parseInt(main.group("line")); + CodeMap map = + codeMaps.get( + fileConfig + .getSrcGenPkgPath() + .resolve(Path.of(main.group("path"))) + .normalize()); + Position genPosition = + Position.fromOneBased(line, Integer.MAX_VALUE); // Column is just a placeholder. + if (map == null) { + errorReporter.report( + null, DiagnosticSeverity.Error, message, 1); // Undesirable fallback + } else { + for (Path lfFile : map.lfSourcePaths()) { + Position lfPosition = map.adjusted(lfFile, genPosition); + // TODO: We could be more precise than just getting the right line, but the way + // the output + // is formatted (with leading whitespace possibly trimmed) does not make it easy. + errorReporter.report( + lfFile, DiagnosticSeverity.Error, message, lfPosition.getOneBasedLine()); } - return false; + } + return true; } + return false; + } - /** - * Try to report an alternative error message from the Python compiler. - * - * @param lines The lines of output from the compiler. - * @param i The current index at which a message may start. - */ - private void tryReportAlternative(String[] lines, int i) { - Matcher main = ALT_DIAGNOSTIC_MESSAGE_PATTERN.matcher(lines[i]); - if (main.matches()) { - int line = Integer.parseInt(main.group("line")); - Iterable relevantMaps = codeMaps.keySet().stream() - .filter(p -> main.group().contains(p.getFileName().toString())) - .map(codeMaps::get)::iterator; - for (CodeMap map : relevantMaps) { // There should almost always be exactly one of these - for (Path lfFile : map.lfSourcePaths()) { - errorReporter.report( - lfFile, - DiagnosticSeverity.Error, - main.group().replace("*** ", "").replace("Sorry: ", ""), - map.adjusted(lfFile, Position.fromOneBased(line, 1)).getOneBasedLine() - ); - } - } + /** + * Try to report an alternative error message from the Python compiler. + * + * @param lines The lines of output from the compiler. + * @param i The current index at which a message may start. + */ + private void tryReportAlternative(String[] lines, int i) { + Matcher main = ALT_DIAGNOSTIC_MESSAGE_PATTERN.matcher(lines[i]); + if (main.matches()) { + int line = Integer.parseInt(main.group("line")); + Iterable relevantMaps = + codeMaps.keySet().stream() + .filter(p -> main.group().contains(p.getFileName().toString())) + .map(codeMaps::get) + ::iterator; + for (CodeMap map : + relevantMaps) { // There should almost always be exactly one of these + for (Path lfFile : map.lfSourcePaths()) { + errorReporter.report( + lfFile, + DiagnosticSeverity.Error, + main.group().replace("*** ", "").replace("Sorry: ", ""), + map.adjusted(lfFile, Position.fromOneBased(line, 1)).getOneBasedLine()); } + } } + } - @Override - public boolean isFullBatch() { - return true; - } + @Override + public boolean isFullBatch() { + return true; + } - @Override - public int getPriority() { - return 0; - } + @Override + public int getPriority() { + return 0; + } }, new ValidationStrategy() { - @Override - public LFCommand getCommand(Path generatedFile) { - return LFCommand.get( - "pylint", - List.of("--output-format=json", generatedFile.getFileName().toString()), - true, - fileConfig.getSrcGenPath() - ); - } + @Override + public LFCommand getCommand(Path generatedFile) { + return LFCommand.get( + "pylint", + List.of("--output-format=json", generatedFile.getFileName().toString()), + true, + fileConfig.getSrcGenPath()); + } - @Override - public Strategy getErrorReportingStrategy() { - return (a, b, c) -> {}; - } + @Override + public Strategy getErrorReportingStrategy() { + return (a, b, c) -> {}; + } - @Override - public Strategy getOutputReportingStrategy() { - return (validationOutput, errorReporter, codeMaps) -> { - if (validationOutput.isBlank()) return; - try { - for (PylintMessage message : mapper.readValue(validationOutput, PylintMessage[].class)) { - if (shouldIgnore(message)) continue; - CodeMap map = codeMaps.get(message.getPath(fileConfig.getSrcGenPath())); - if (map != null) { - for (Path lfFile : map.lfSourcePaths()) { - Function adjust = p -> map.adjusted(lfFile, p); - String humanMessage = DiagnosticReporting.messageOf( - message.message, - message.getPath(fileConfig.getSrcGenPath()), - message.getStart() - ); - Position lfStart = adjust.apply(message.getStart()); - Position lfEnd = adjust.apply(message.getEnd()); - bestEffortReport( - errorReporter, - adjust, - lfStart, - lfEnd, - lfFile, - message.getSeverity(), - humanMessage - ); - } - } - } - } catch (JsonProcessingException e) { - System.err.printf("Failed to parse \"%s\":%n", validationOutput); - e.printStackTrace(); - errorReporter.reportWarning( - "Failed to parse linter output. The Lingua Franca code generator is tested with Pylint " - + "version 2.12.2. Consider updating Pylint if you have an older version." - ); + @Override + public Strategy getOutputReportingStrategy() { + return (validationOutput, errorReporter, codeMaps) -> { + if (validationOutput.isBlank()) return; + try { + for (PylintMessage message : + mapper.readValue(validationOutput, PylintMessage[].class)) { + if (shouldIgnore(message)) continue; + CodeMap map = codeMaps.get(message.getPath(fileConfig.getSrcGenPath())); + if (map != null) { + for (Path lfFile : map.lfSourcePaths()) { + Function adjust = p -> map.adjusted(lfFile, p); + String humanMessage = + DiagnosticReporting.messageOf( + message.message, + message.getPath(fileConfig.getSrcGenPath()), + message.getStart()); + Position lfStart = adjust.apply(message.getStart()); + Position lfEnd = adjust.apply(message.getEnd()); + bestEffortReport( + errorReporter, + adjust, + lfStart, + lfEnd, + lfFile, + message.getSeverity(), + humanMessage); } - }; - } + } + } + } catch (JsonProcessingException e) { + System.err.printf("Failed to parse \"%s\":%n", validationOutput); + e.printStackTrace(); + errorReporter.reportWarning( + "Failed to parse linter output. The Lingua Franca code generator is tested with" + + " Pylint version 2.12.2. Consider updating Pylint if you have an older" + + " version."); + } + }; + } - /** - * Return whether the given message should be ignored. - * @param message A Pylint message that is a candidate to be reported. - * @return whether {@code message} should be reported. - */ - private boolean shouldIgnore(PylintMessage message) { - // Code generation does not preserve whitespace, so this check is unreliable. - if (message.symbol.equals("trailing-whitespace") || message.symbol.equals("line-too-long")) return true; - // This filters out Pylint messages concerning missing members in types defined by protocol buffers. - // FIXME: Make this unnecessary, perhaps using https://github.com/nelfin/pylint-protobuf. - Matcher matcher = PylintNoNamePattern.matcher(message.message); - return message.symbol.equals("no-member") - && matcher.matches() && protoNames.contains(matcher.group("name")); - } + /** + * Return whether the given message should be ignored. + * + * @param message A Pylint message that is a candidate to be reported. + * @return whether {@code message} should be reported. + */ + private boolean shouldIgnore(PylintMessage message) { + // Code generation does not preserve whitespace, so this check is unreliable. + if (message.symbol.equals("trailing-whitespace") + || message.symbol.equals("line-too-long")) return true; + // This filters out Pylint messages concerning missing members in types defined by + // protocol buffers. + // FIXME: Make this unnecessary, perhaps using + // https://github.com/nelfin/pylint-protobuf. + Matcher matcher = PylintNoNamePattern.matcher(message.message); + return message.symbol.equals("no-member") + && matcher.matches() + && protoNames.contains(matcher.group("name")); + } - /** Make a best-effort attempt to place the diagnostic on the correct line. */ - private void bestEffortReport( - ErrorReporter errorReporter, - Function adjust, - Position lfStart, - Position lfEnd, - Path file, - DiagnosticSeverity severity, - String humanMessage - ) { - if (!lfEnd.equals(Position.ORIGIN) && !lfStart.equals(Position.ORIGIN)) { // Ideal case - errorReporter.report(file, severity, humanMessage, lfStart, lfEnd); - } else { // Fallback: Try to report on the correct line, or failing that, just line 1. - if (lfStart.equals(Position.ORIGIN)) lfStart = adjust.apply( - Position.fromZeroBased(lfStart.getZeroBasedLine(), Integer.MAX_VALUE) - ); - // FIXME: It might be better to improve style of generated code instead of quietly returning here. - if (lfStart.equals(Position.ORIGIN) && severity != DiagnosticSeverity.Error) return; - errorReporter.report(file, severity, humanMessage, lfStart.getOneBasedLine()); - } + /** Make a best-effort attempt to place the diagnostic on the correct line. */ + private void bestEffortReport( + ErrorReporter errorReporter, + Function adjust, + Position lfStart, + Position lfEnd, + Path file, + DiagnosticSeverity severity, + String humanMessage) { + if (!lfEnd.equals(Position.ORIGIN) && !lfStart.equals(Position.ORIGIN)) { // Ideal case + errorReporter.report(file, severity, humanMessage, lfStart, lfEnd); + } else { // Fallback: Try to report on the correct line, or failing that, just line 1. + if (lfStart.equals(Position.ORIGIN)) + lfStart = + adjust.apply( + Position.fromZeroBased(lfStart.getZeroBasedLine(), Integer.MAX_VALUE)); + // FIXME: It might be better to improve style of generated code instead of quietly + // returning here. + if (lfStart.equals(Position.ORIGIN) && severity != DiagnosticSeverity.Error) return; + errorReporter.report(file, severity, humanMessage, lfStart.getOneBasedLine()); } + } - @Override - public boolean isFullBatch() { - return false; - } + @Override + public boolean isFullBatch() { + return false; + } - @Override - public int getPriority() { - return 1; - } - } - ); } + @Override + public int getPriority() { + return 1; + } + }); + } - @Override - protected Pair getBuildReportingStrategies() { - return new Pair<>((a, b, c) -> {}, (a, b, c) -> {}); - } + @Override + protected Pair getBuildReportingStrategies() { + return new Pair<>((a, b, c) -> {}, (a, b, c) -> {}); + } } diff --git a/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java b/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java index 69efcd3fab..ff97860970 100644 --- a/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java +++ b/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java @@ -31,9 +31,9 @@ import java.util.Objects; import java.util.Set; import java.util.stream.Collectors; -import org.lflang.ast.ASTUtils; import org.lflang.TargetProperty; import org.lflang.TargetProperty.TargetPropertyType; +import org.lflang.ast.ASTUtils; import org.lflang.generator.InvalidLfSourceException; import org.lflang.lf.Array; import org.lflang.lf.Element; @@ -202,14 +202,12 @@ private static CargoDependencySpec parseValue(Element element, boolean isRuntime pair.getValue(), "Expected string literal for key '" + name + "'"); } switch (name) { - case "version" -> version = literal; - case "git" -> gitRepo = literal; - case "rev" -> rev = literal; - case "tag" -> tag = literal; - case "path" -> localPath = literal; - default -> throw new InvalidLfSourceException(pair, - "Unknown key: '" + name - + "'"); + case "version" -> version = literal; + case "git" -> gitRepo = literal; + case "rev" -> rev = literal; + case "tag" -> tag = literal; + case "path" -> localPath = literal; + default -> throw new InvalidLfSourceException(pair, "Unknown key: '" + name + "'"); } } if (isRuntimeCrate || version != null || localPath != null || gitRepo != null) { diff --git a/org.lflang/src/org/lflang/generator/rust/RustTargetConfig.java b/org.lflang/src/org/lflang/generator/rust/RustTargetConfig.java index f2ff9d9c3f..b4e9a1778b 100644 --- a/org.lflang/src/org/lflang/generator/rust/RustTargetConfig.java +++ b/org.lflang/src/org/lflang/generator/rust/RustTargetConfig.java @@ -29,11 +29,8 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; -import java.util.Locale; import java.util.Map; - import org.eclipse.emf.ecore.EObject; - import org.lflang.ErrorReporter; import org.lflang.TargetProperty.BuildType; @@ -44,83 +41,66 @@ */ public final class RustTargetConfig { - - /** - * List of Cargo features of the generated crate to enable. - */ - private List cargoFeatures = new ArrayList<>(); - - /** - * Map of Cargo dependency to dependency properties. - */ - private Map cargoDependencies = new HashMap<>(); - - /** - * List of top-level modules, those are absolute paths. - */ - private final List rustTopLevelModules = new ArrayList<>(); - - /** - * Cargo profile, default is debug (corresponds to cargo dev profile). - */ - private BuildType profile = BuildType.DEBUG; - - public void setCargoFeatures(List cargoFeatures) { - this.cargoFeatures = cargoFeatures; - } - - public void setCargoDependencies(Map cargoDependencies) { - this.cargoDependencies = cargoDependencies; + /** List of Cargo features of the generated crate to enable. */ + private List cargoFeatures = new ArrayList<>(); + + /** Map of Cargo dependency to dependency properties. */ + private Map cargoDependencies = new HashMap<>(); + + /** List of top-level modules, those are absolute paths. */ + private final List rustTopLevelModules = new ArrayList<>(); + + /** Cargo profile, default is debug (corresponds to cargo dev profile). */ + private BuildType profile = BuildType.DEBUG; + + public void setCargoFeatures(List cargoFeatures) { + this.cargoFeatures = cargoFeatures; + } + + public void setCargoDependencies(Map cargoDependencies) { + this.cargoDependencies = cargoDependencies; + } + + public void addAndCheckTopLevelModule(Path path, EObject errorOwner, ErrorReporter err) { + String fileName = path.getFileName().toString(); + if (!Files.exists(path)) { + err.reportError(errorOwner, "File not found"); + } else if (Files.isRegularFile(path) && !fileName.endsWith(".rs")) { + err.reportError(errorOwner, "Not a rust file"); + } else if (fileName.equals("main.rs")) { + err.reportError(errorOwner, "Cannot use 'main.rs' as a module name (reserved)"); + } else if (fileName.equals("reactors") || fileName.equals("reactors.rs")) { + err.reportError(errorOwner, "Cannot use 'reactors' as a module name (reserved)"); + } else if (Files.isDirectory(path) && !Files.exists(path.resolve("mod.rs"))) { + err.reportError(errorOwner, "Cannot find module descriptor in directory"); } - - public void addAndCheckTopLevelModule(Path path, EObject errorOwner, ErrorReporter err) { - String fileName = path.getFileName().toString(); - if (!Files.exists(path)) { - err.reportError(errorOwner, "File not found"); - } else if (Files.isRegularFile(path) && !fileName.endsWith(".rs")) { - err.reportError(errorOwner, "Not a rust file"); - } else if (fileName.equals("main.rs")) { - err.reportError(errorOwner, "Cannot use 'main.rs' as a module name (reserved)"); - } else if (fileName.equals("reactors") || fileName.equals("reactors.rs")) { - err.reportError(errorOwner, "Cannot use 'reactors' as a module name (reserved)"); - } else if (Files.isDirectory(path) && !Files.exists(path.resolve("mod.rs"))) { - err.reportError(errorOwner, "Cannot find module descriptor in directory"); - } - this.rustTopLevelModules.add(path); - } - - public List getCargoFeatures() { - return cargoFeatures; - } - - /** - * Returns a map of cargo dependencies. - */ - public Map getCargoDependencies() { - return cargoDependencies; - } - - /** - * Returns the list of top-level module files to include in main.rs. - * Those files were checked to exists previously. - */ - public List getRustTopLevelModules() { - return rustTopLevelModules; - } - - /** - * The build type to use. Corresponds to a Cargo profile. - */ - public BuildType getBuildType() { - return profile; - } - - - /** - * Set a build profile chosen based on a cmake profile. - */ - public void setBuildType(BuildType profile) { - this.profile = profile; - } - + this.rustTopLevelModules.add(path); + } + + public List getCargoFeatures() { + return cargoFeatures; + } + + /** Returns a map of cargo dependencies. */ + public Map getCargoDependencies() { + return cargoDependencies; + } + + /** + * Returns the list of top-level module files to include in main.rs. Those files were checked to + * exists previously. + */ + public List getRustTopLevelModules() { + return rustTopLevelModules; + } + + /** The build type to use. Corresponds to a Cargo profile. */ + public BuildType getBuildType() { + return profile; + } + + /** Set a build profile chosen based on a cmake profile. */ + public void setBuildType(BuildType profile) { + this.profile = profile; + } } diff --git a/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java b/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java index cf89596a56..1e88ba4c12 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java +++ b/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java @@ -10,20 +10,19 @@ */ public class TSDockerGenerator extends DockerGenerator { - /** Construct a new Docker generator. */ - public TSDockerGenerator(LFGeneratorContext context) { - super(context); - } + /** Construct a new Docker generator. */ + public TSDockerGenerator(LFGeneratorContext context) { + super(context); + } - /** - * Return the content of the docker file for [tsFileName]. - */ - public String generateDockerFileContent() { - return """ + /** Return the content of the docker file for [tsFileName]. */ + public String generateDockerFileContent() { + return """ |FROM node:alpine |WORKDIR /linguafranca/$name |COPY . . |ENTRYPOINT ["node", "dist/%s.js"] - """.formatted(context.getFileConfig().name); - } + """ + .formatted(context.getFileConfig().name); + } } diff --git a/org.lflang/src/org/lflang/generator/ts/TSTypes.java b/org.lflang/src/org/lflang/generator/ts/TSTypes.java index 2e2c6a6dff..0fe4fc8a5e 100644 --- a/org.lflang/src/org/lflang/generator/ts/TSTypes.java +++ b/org.lflang/src/org/lflang/generator/ts/TSTypes.java @@ -1,75 +1,73 @@ package org.lflang.generator.ts; import java.util.List; - -import org.lflang.ast.ASTUtils; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.generator.TargetTypes; import org.lflang.generator.UnsupportedGeneratorFeatureException; import org.lflang.lf.StateVar; public class TSTypes implements TargetTypes { - private static TSTypes INSTANCE = new TSTypes(); - - private TSTypes() { - - } - - @Override - public String getTargetType(StateVar s) { - var type = TargetTypes.super.getTargetType(s); - if (!ASTUtils.isInitialized(s)) { - return "%s | undefined".formatted(type); - } else { - return type; - } - } - - @Override - public boolean supportsGenerics() { - return true; - } - - @Override - public String getTargetTimeType() { - return "TimeValue"; - } - - @Override - public String getTargetTagType() { - return "TimeValue"; - } + private static TSTypes INSTANCE = new TSTypes(); - @Override - public String getTargetUndefinedType() { - return "Present"; - } - - public String getTargetTimeExpr(TimeValue value) { - if (value.unit != null) { - return "TimeValue.%s(%s)".formatted(value.unit.getCanonicalName(), value.time); - } else { - // The value must be zero. - return "TimeValue.zero()"; - } - } + private TSTypes() {} - @Override - public String getTargetFixedSizeListType(String baseType, int size) { - throw new UnsupportedGeneratorFeatureException("TypeScript does not support fixed-size array types."); + @Override + public String getTargetType(StateVar s) { + var type = TargetTypes.super.getTargetType(s); + if (!ASTUtils.isInitialized(s)) { + return "%s | undefined".formatted(type); + } else { + return type; } - - @Override - public String getTargetVariableSizeListType(String baseType) { - return "Array<%s>".formatted(baseType); // same as "$baseType[]" - } - - public String getVariableSizeListInitExpression(List contents, boolean withBraces) { - return "[" + String.join(", ", contents) + "]"; - } - - public static TSTypes getInstance() { - return INSTANCE; + } + + @Override + public boolean supportsGenerics() { + return true; + } + + @Override + public String getTargetTimeType() { + return "TimeValue"; + } + + @Override + public String getTargetTagType() { + return "TimeValue"; + } + + @Override + public String getTargetUndefinedType() { + return "Present"; + } + + public String getTargetTimeExpr(TimeValue value) { + if (value.unit != null) { + return "TimeValue.%s(%s)".formatted(value.unit.getCanonicalName(), value.time); + } else { + // The value must be zero. + return "TimeValue.zero()"; } + } + + @Override + public String getTargetFixedSizeListType(String baseType, int size) { + throw new UnsupportedGeneratorFeatureException( + "TypeScript does not support fixed-size array types."); + } + + @Override + public String getTargetVariableSizeListType(String baseType) { + return "Array<%s>".formatted(baseType); // same as "$baseType[]" + } + + public String getVariableSizeListInitExpression(List contents, boolean withBraces) { + return "[" + String.join(", ", contents) + "]"; + } + + public static TSTypes getInstance() { + return INSTANCE; + } } diff --git a/org.lflang/src/org/lflang/graph/DirectedGraph.java b/org.lflang/src/org/lflang/graph/DirectedGraph.java index 771bbca539..0e506dbe30 100644 --- a/org.lflang/src/org/lflang/graph/DirectedGraph.java +++ b/org.lflang/src/org/lflang/graph/DirectedGraph.java @@ -1,25 +1,25 @@ /************* - Copyright (c) 2019, The University of California at Berkeley. - - 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. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. ***************/ package org.lflang.graph; @@ -27,7 +27,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.*; import java.util.Map.Entry; import java.util.stream.Collectors; - import org.lflang.util.CollectionUtil; /** @@ -38,287 +37,254 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY */ public class DirectedGraph implements Graph { - // Note that while both those maps are mutable, the sets - // they use as values may not be. They should only be - // manipulated through CollectionUtil - - // If a node has no neighbors, it is still in the map with an empty set as a value. - - /** - * Adjacency map from vertices to their downstream immediate neighbors. - */ - private final Map> downstreamAdjacentNodes = new LinkedHashMap<>(); - - /** - * Adjacency map from vertices to their upstream immediate neighbors. - */ - private final Map> upstreamAdjacentNodes = new LinkedHashMap<>(); - - - /** - * Mark the graph to have changed so that any cached analysis is refreshed - * accordingly. - */ - protected void graphChanged() { - // To be overridden by subclasses that perform analysis. - } - - - /** - * Return true if this graph has the given node in it. - * - * @param node The node to look for. - */ - @Override - public boolean hasNode(T node) { - return nodes().contains(node); - } - - - /** - * Return all immediate upstream neighbors of a given node. - * - * @param node The node to report the immediate upstream neighbors of. - */ - public Set getUpstreamAdjacentNodes(T node) { - return Collections.unmodifiableSet(this.upstreamAdjacentNodes.getOrDefault(node, Set.of())); - } - - - /** - * Return all immediate downstream neighbors of a given node. - * - * @param node The node to report the immediate downstream neighbors of. - */ - public Set getDownstreamAdjacentNodes(T node) { - return Collections.unmodifiableSet(this.downstreamAdjacentNodes.getOrDefault(node, Set.of())); - } - - - @Override - public void addNode(T node) { - this.graphChanged(); - this.upstreamAdjacentNodes.putIfAbsent(node, Set.of()); - this.downstreamAdjacentNodes.putIfAbsent(node, Set.of()); - } - - - @Override - public void removeNode(T node) { - this.graphChanged(); - this.upstreamAdjacentNodes.remove(node); - this.downstreamAdjacentNodes.remove(node); - // The node also needs to be removed from the sets that represent connections to the node. - CollectionUtil.removeFromValues(this.upstreamAdjacentNodes, node); - CollectionUtil.removeFromValues(this.downstreamAdjacentNodes, node); - } - - - /** - * Add a new directed edge to the graph. The first argument is - * the downstream node, the second argument the upstream node. - * If either argument is null, do nothing. - * - * @param sink The downstream immediate neighbor. - * @param source The upstream immediate neighbor. - */ - @Override - public void addEdge(T sink, T source) { - this.graphChanged(); - if (sink != null && source != null) { - this.downstreamAdjacentNodes.compute(source, (k, set) -> CollectionUtil.plus(set, sink)); - this.upstreamAdjacentNodes.compute(sink, (k, set) -> CollectionUtil.plus(set, source)); - } - } - - - /** - * Add new directed edges to the graph. The first argument is the - * downstream node, the second argument a set of upstream nodes. - * - * @param sink The downstream immediate neighbor. - * @param sources The upstream immediate neighbors. - */ - @Override - public void addEdges(T sink, List sources) { - for (T source : sources) { - this.addEdge(sink, source); - } - } - - - /** - * Remove a directed edge from the graph. - * - * @param sink The downstream immediate neighbor. - * @param source The upstream immediate neighbor. - */ - @Override - public void removeEdge(T sink, T source) { - this.graphChanged(); - this.upstreamAdjacentNodes.computeIfPresent(sink, (k, upstream) -> CollectionUtil.minus(upstream, source)); - this.downstreamAdjacentNodes.computeIfPresent(source, (k, downstream) -> CollectionUtil.minus(downstream, sink)); - } - - - /** - * Obtain a copy of this graph by creating an new instance and copying - * the adjacency maps. - */ - public DirectedGraph copy() { - var graph = new DirectedGraph(); - for (var entry : this.upstreamAdjacentNodes.entrySet()) { - graph.upstreamAdjacentNodes.put(entry.getKey(), CollectionUtil.copy(entry.getValue())); - } - for (var entry : this.downstreamAdjacentNodes.entrySet()) { - graph.downstreamAdjacentNodes.put(entry.getKey(), CollectionUtil.copy(entry.getValue())); - } - return graph; - } - - - /** - * For a given a two adjacency maps, copy missing edges from the first - * map to the second. - * - * @param srcMap The adjacency map to copy edges from. - * @param dstMap The adjacency map to copy edges to. - */ - private void mirror(Map> srcMap, Map> dstMap) { - if (srcMap != null && dstMap != null) { - for (Entry> entry : srcMap.entrySet()) { - var node = entry.getKey(); - var srcEdges = entry.getValue(); - dstMap.compute(node, (_node, dstEdges) -> { - // Node does not exist; add it. - if (dstEdges == null) { - return CollectionUtil.copy(srcEdges); - } - - // Node does exist; add the missing edges. - var set = dstEdges; - for (T edge : srcEdges) { - set = CollectionUtil.plus(set, edge); - } - return set; - }); - } - } - } - - - /** - * Merge another directed graph into this one. - * - * @param another The graph to merge into this one. - */ - public void merge(DirectedGraph another) { - this.graphChanged(); - mirror(another.upstreamAdjacentNodes, this.upstreamAdjacentNodes); - mirror(another.downstreamAdjacentNodes, this.downstreamAdjacentNodes); - } - - - /** - * Return the set of nodes that have no neighbors listed in the given - * adjacency map. - */ - private Set independentNodes(Map> adjacencyMap) { - var independent = new LinkedHashSet(); - for (T node : nodes()) { - var neighbors = adjacencyMap.get(node); - if (neighbors == null || neighbors.size() == 0) { - independent.add(node); - } - } - return independent; + // Note that while both those maps are mutable, the sets + // they use as values may not be. They should only be + // manipulated through CollectionUtil + + // If a node has no neighbors, it is still in the map with an empty set as a value. + + /** Adjacency map from vertices to their downstream immediate neighbors. */ + private final Map> downstreamAdjacentNodes = new LinkedHashMap<>(); + + /** Adjacency map from vertices to their upstream immediate neighbors. */ + private final Map> upstreamAdjacentNodes = new LinkedHashMap<>(); + + /** Mark the graph to have changed so that any cached analysis is refreshed accordingly. */ + protected void graphChanged() { + // To be overridden by subclasses that perform analysis. + } + + /** + * Return true if this graph has the given node in it. + * + * @param node The node to look for. + */ + @Override + public boolean hasNode(T node) { + return nodes().contains(node); + } + + /** + * Return all immediate upstream neighbors of a given node. + * + * @param node The node to report the immediate upstream neighbors of. + */ + public Set getUpstreamAdjacentNodes(T node) { + return Collections.unmodifiableSet(this.upstreamAdjacentNodes.getOrDefault(node, Set.of())); + } + + /** + * Return all immediate downstream neighbors of a given node. + * + * @param node The node to report the immediate downstream neighbors of. + */ + public Set getDownstreamAdjacentNodes(T node) { + return Collections.unmodifiableSet(this.downstreamAdjacentNodes.getOrDefault(node, Set.of())); + } + + @Override + public void addNode(T node) { + this.graphChanged(); + this.upstreamAdjacentNodes.putIfAbsent(node, Set.of()); + this.downstreamAdjacentNodes.putIfAbsent(node, Set.of()); + } + + @Override + public void removeNode(T node) { + this.graphChanged(); + this.upstreamAdjacentNodes.remove(node); + this.downstreamAdjacentNodes.remove(node); + // The node also needs to be removed from the sets that represent connections to the node. + CollectionUtil.removeFromValues(this.upstreamAdjacentNodes, node); + CollectionUtil.removeFromValues(this.downstreamAdjacentNodes, node); + } + + /** + * Add a new directed edge to the graph. The first argument is the downstream node, the second + * argument the upstream node. If either argument is null, do nothing. + * + * @param sink The downstream immediate neighbor. + * @param source The upstream immediate neighbor. + */ + @Override + public void addEdge(T sink, T source) { + this.graphChanged(); + if (sink != null && source != null) { + this.downstreamAdjacentNodes.compute(source, (k, set) -> CollectionUtil.plus(set, sink)); + this.upstreamAdjacentNodes.compute(sink, (k, set) -> CollectionUtil.plus(set, source)); } - - - /** - * Return the root nodes of this graph. - * Root nodes have no upstream neighbors. - */ - public Set rootNodes() { - return independentNodes(this.upstreamAdjacentNodes); + } + + /** + * Add new directed edges to the graph. The first argument is the downstream node, the second + * argument a set of upstream nodes. + * + * @param sink The downstream immediate neighbor. + * @param sources The upstream immediate neighbors. + */ + @Override + public void addEdges(T sink, List sources) { + for (T source : sources) { + this.addEdge(sink, source); } - - - /** - * Return the leaf nodes of this graph. - * Leaf nodes have no downstream neighbors. - */ - public Set leafNodes() { - return independentNodes(this.downstreamAdjacentNodes); + } + + /** + * Remove a directed edge from the graph. + * + * @param sink The downstream immediate neighbor. + * @param source The upstream immediate neighbor. + */ + @Override + public void removeEdge(T sink, T source) { + this.graphChanged(); + this.upstreamAdjacentNodes.computeIfPresent( + sink, (k, upstream) -> CollectionUtil.minus(upstream, source)); + this.downstreamAdjacentNodes.computeIfPresent( + source, (k, downstream) -> CollectionUtil.minus(downstream, sink)); + } + + /** Obtain a copy of this graph by creating an new instance and copying the adjacency maps. */ + public DirectedGraph copy() { + var graph = new DirectedGraph(); + for (var entry : this.upstreamAdjacentNodes.entrySet()) { + graph.upstreamAdjacentNodes.put(entry.getKey(), CollectionUtil.copy(entry.getValue())); } - - - @Override - public int nodeCount() { - return downstreamAdjacentNodes.size(); + for (var entry : this.downstreamAdjacentNodes.entrySet()) { + graph.downstreamAdjacentNodes.put(entry.getKey(), CollectionUtil.copy(entry.getValue())); } - - - @Override - public int edgeCount() { - return this.upstreamAdjacentNodes.values().stream().mapToInt(Set::size).sum(); + return graph; + } + + /** + * For a given a two adjacency maps, copy missing edges from the first map to the second. + * + * @param srcMap The adjacency map to copy edges from. + * @param dstMap The adjacency map to copy edges to. + */ + private void mirror(Map> srcMap, Map> dstMap) { + if (srcMap != null && dstMap != null) { + for (Entry> entry : srcMap.entrySet()) { + var node = entry.getKey(); + var srcEdges = entry.getValue(); + dstMap.compute( + node, + (_node, dstEdges) -> { + // Node does not exist; add it. + if (dstEdges == null) { + return CollectionUtil.copy(srcEdges); + } + + // Node does exist; add the missing edges. + var set = dstEdges; + for (T edge : srcEdges) { + set = CollectionUtil.plus(set, edge); + } + return set; + }); + } } - - - @Override - public Set nodes() { - return Collections.unmodifiableSet(this.downstreamAdjacentNodes.keySet()); + } + + /** + * Merge another directed graph into this one. + * + * @param another The graph to merge into this one. + */ + public void merge(DirectedGraph another) { + this.graphChanged(); + mirror(another.upstreamAdjacentNodes, this.upstreamAdjacentNodes); + mirror(another.downstreamAdjacentNodes, this.downstreamAdjacentNodes); + } + + /** Return the set of nodes that have no neighbors listed in the given adjacency map. */ + private Set independentNodes(Map> adjacencyMap) { + var independent = new LinkedHashSet(); + for (T node : nodes()) { + var neighbors = adjacencyMap.get(node); + if (neighbors == null || neighbors.size() == 0) { + independent.add(node); + } } - - - public void clear() { - this.graphChanged(); - this.downstreamAdjacentNodes.clear(); - this.upstreamAdjacentNodes.clear(); + return independent; + } + + /** Return the root nodes of this graph. Root nodes have no upstream neighbors. */ + public Set rootNodes() { + return independentNodes(this.upstreamAdjacentNodes); + } + + /** Return the leaf nodes of this graph. Leaf nodes have no downstream neighbors. */ + public Set leafNodes() { + return independentNodes(this.downstreamAdjacentNodes); + } + + @Override + public int nodeCount() { + return downstreamAdjacentNodes.size(); + } + + @Override + public int edgeCount() { + return this.upstreamAdjacentNodes.values().stream().mapToInt(Set::size).sum(); + } + + @Override + public Set nodes() { + return Collections.unmodifiableSet(this.downstreamAdjacentNodes.keySet()); + } + + public void clear() { + this.graphChanged(); + this.downstreamAdjacentNodes.clear(); + this.upstreamAdjacentNodes.clear(); + } + + /** Return a textual list of the nodes. */ + @Override + public String toString() { + return nodes().stream().map(Objects::toString).collect(Collectors.joining(", ", "{", "}")); + } + + /** Return the DOT (GraphViz) representation of the graph. */ + @Override + public String toDOT() { + StringBuilder dotRepresentation = new StringBuilder(); + StringBuilder edges = new StringBuilder(); + + // Start the digraph with a left-write rank + dotRepresentation.append("digraph {\n"); + dotRepresentation.append(" rankdir=LF;\n"); + + Set nodes = nodes(); + for (T node : nodes) { + // Draw the node + dotRepresentation.append( + " node_" + + (node.toString().hashCode() & 0xfffffff) + + " [label=\"" + + node.toString() + + "\"]\n"); + + // Draw the edges + Set downstreamNodes = getDownstreamAdjacentNodes(node); + for (T downstreamNode : downstreamNodes) { + edges.append( + " node_" + + (node.toString().hashCode() & 0xfffffff) + + " -> node_" + + (downstreamNode.toString().hashCode() & 0xfffffff) + + "\n"); + } } + // Add the edges to the definition of the graph at the bottom + dotRepresentation.append(edges); - /** - * Return a textual list of the nodes. - */ - @Override - public String toString() { - return nodes().stream().map(Objects::toString).collect(Collectors.joining(", ", "{", "}")); - } + // Close the digraph + dotRepresentation.append("}\n"); - /** - * Return the DOT (GraphViz) representation of the graph. - */ - @Override - public String toDOT() { - StringBuilder dotRepresentation = new StringBuilder(); - StringBuilder edges = new StringBuilder(); - - // Start the digraph with a left-write rank - dotRepresentation.append("digraph {\n"); - dotRepresentation.append(" rankdir=LF;\n"); - - Set nodes = nodes(); - for (T node: nodes) { - // Draw the node - dotRepresentation.append(" node_" + (node.toString().hashCode() & 0xfffffff) - + " [label=\""+ node.toString() +"\"]\n"); - - // Draw the edges - Set downstreamNodes = getDownstreamAdjacentNodes(node); - for (T downstreamNode: downstreamNodes) { - edges.append(" node_" + (node.toString().hashCode() & 0xfffffff) - + " -> node_" + (downstreamNode.toString().hashCode() & 0xfffffff) + "\n"); - } - } - - // Add the edges to the definition of the graph at the bottom - dotRepresentation.append(edges); - - // Close the digraph - dotRepresentation.append("}\n"); - - // Return the DOT representation - return dotRepresentation.toString(); - } + // Return the DOT representation + return dotRepresentation.toString(); + } } diff --git a/org.lflang/src/org/lflang/graph/Graph.java b/org.lflang/src/org/lflang/graph/Graph.java index 4e9a1723d9..07371c1255 100644 --- a/org.lflang/src/org/lflang/graph/Graph.java +++ b/org.lflang/src/org/lflang/graph/Graph.java @@ -1,26 +1,26 @@ /************* - Copyright (c) 2020, The University of California at Berkeley. - - 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. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * Copyright (c) 2020, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. ***************/ package org.lflang.graph; @@ -35,49 +35,36 @@ */ public interface Graph { - /** - * Return an unmodifiable set of nodes in this graph. - */ - Set nodes(); - - - boolean hasNode(T node); - - - /** Add the given node to the graph. */ - void addNode(T node); - - - /** - * Remove the given node from the graph. This also eliminates any - * edges from upstream and to downstream neighbors of this node. - * - * @param node The node to remove. - */ - void removeNode(T node); - - - // todo order of parameters here is unintuitive... from -> to is more usual - - void addEdge(T to, T from); + /** Return an unmodifiable set of nodes in this graph. */ + Set nodes(); + boolean hasNode(T node); - void addEdges(T to, List from); + /** Add the given node to the graph. */ + void addNode(T node); + /** + * Remove the given node from the graph. This also eliminates any edges from upstream and to + * downstream neighbors of this node. + * + * @param node The node to remove. + */ + void removeNode(T node); - void removeEdge(T to, T from); + // todo order of parameters here is unintuitive... from -> to is more usual + void addEdge(T to, T from); - /** - * Return the number of nodes in this graph. - */ - int nodeCount(); + void addEdges(T to, List from); + void removeEdge(T to, T from); - /** Return the number of directed edges in this graph. */ - int edgeCount(); + /** Return the number of nodes in this graph. */ + int nodeCount(); + /** Return the number of directed edges in this graph. */ + int edgeCount(); - /** Return the DOT (GraphViz) representation of the graph. */ - String toDOT(); + /** Return the DOT (GraphViz) representation of the graph. */ + String toDOT(); } diff --git a/org.lflang/src/org/lflang/graph/InstantiationGraph.java b/org.lflang/src/org/lflang/graph/InstantiationGraph.java index b32c97e2f2..dca5492fd0 100644 --- a/org.lflang/src/org/lflang/graph/InstantiationGraph.java +++ b/org.lflang/src/org/lflang/graph/InstantiationGraph.java @@ -1,35 +1,34 @@ /** * Copyright (c) 2020, The University of California at Berkeley. * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: + *

    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. + *

    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. + *

    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. * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + *

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR + * CONTRIBUTORS 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. */ package org.lflang.graph; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Iterables; import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Optional; import java.util.Set; - import org.eclipse.emf.ecore.resource.Resource; import org.lflang.ast.ASTUtils; import org.lflang.lf.Instantiation; @@ -38,138 +37,124 @@ import org.lflang.lf.ReactorDecl; import org.lflang.util.IteratorUtil; -import com.google.common.collect.HashMultimap; -import com.google.common.collect.Iterables; - /** - * A graph with vertices that are Reactors (not ReactorInstances) and edges that denote - * dependencies between them. A "dependency" from reactor class A to - * reactor class B (A depends on B) means that A instantiates within - * it at least one instance of B. Note that there a potentially - * confusing and subtle distinction here between an "instantiation" - * and an "instance". They are not the same thing at all. An - * "instantiation" is an AST node representing a statement like - * {@code a = new A();}. This can result in many instances of reactor - * class A (if the containing reactor class is instantiated multiple times). + * A graph with vertices that are Reactors (not ReactorInstances) and edges that denote dependencies + * between them. A "dependency" from reactor class A to reactor class B (A depends on B) means that + * A instantiates within it at least one instance of B. Note that there a potentially confusing and + * subtle distinction here between an "instantiation" and an "instance". They are not the same thing + * at all. An "instantiation" is an AST node representing a statement like {@code a = new A();}. + * This can result in many instances of reactor class A (if the containing reactor class is + * instantiated multiple times). * - * In addition to the graph, this class keeps track of the instantiations - * that induce the dependencies. These can be retrieved using the method - * {@code getInstantiations(Reactor)}. + *

    In addition to the graph, this class keeps track of the instantiations that induce the + * dependencies. These can be retrieved using the method {@code getInstantiations(Reactor)}. * * @author Marten Lohstroh */ public class InstantiationGraph extends PrecedenceGraph { - /** - * A mapping from reactors to the sites of their instantiation. - */ - protected final HashMultimap reactorToInstantiation = - HashMultimap.create(); + /** A mapping from reactors to the sites of their instantiation. */ + protected final HashMultimap reactorToInstantiation = + HashMultimap.create(); - /** - * A mapping from reactor classes to their declarations. - */ - protected final HashMultimap reactorToDecl = - HashMultimap.create(); + /** A mapping from reactor classes to their declarations. */ + protected final HashMultimap reactorToDecl = HashMultimap.create(); - /** - * Return the instantiations that point to a given reactor definition. - * If none are known, returns an empty set. * The returned set may be - * unmodifiable. - */ - public Set getInstantiations(final Reactor definition) { - Set instantiations = this.reactorToInstantiation.get(definition); - if (instantiations != null) { - return instantiations; - } else { - return Collections.emptySet(); - } + /** + * Return the instantiations that point to a given reactor definition. If none are known, returns + * an empty set. * The returned set may be unmodifiable. + */ + public Set getInstantiations(final Reactor definition) { + Set instantiations = this.reactorToInstantiation.get(definition); + if (instantiations != null) { + return instantiations; + } else { + return Collections.emptySet(); } + } - /** - * Return the declarations that point to a given reactor definition. - * A declaration is either a reactor definition or an import statement. - */ - public Set getDeclarations(final Reactor definition) { - return this.reactorToDecl.get(definition); - } + /** + * Return the declarations that point to a given reactor definition. A declaration is either a + * reactor definition or an import statement. + */ + public Set getDeclarations(final Reactor definition) { + return this.reactorToDecl.get(definition); + } - /** - * Return the reactor definitions referenced by instantiations in this graph - * ordered topologically. Each reactor in the returned list is preceded by - * any reactors that it may instantiate. - */ - public List getReactors() { - return this.nodesInTopologicalOrder(); - } + /** + * Return the reactor definitions referenced by instantiations in this graph ordered + * topologically. Each reactor in the returned list is preceded by any reactors that it may + * instantiate. + */ + public List getReactors() { + return this.nodesInTopologicalOrder(); + } - /** - * Construct an instantiation graph based on the given AST and, if the - * detectCycles argument is true, run Tarjan's algorithm to detect cyclic - * dependencies between instantiations. - * @param resource The resource associated with the AST. - * @param detectCycles Whether or not to detect cycles. - */ - public InstantiationGraph(final Resource resource, final boolean detectCycles) { - final Iterable instantiations = Iterables.filter( - IteratorUtil.asIterable(resource.getAllContents()), - Instantiation.class); - Optional main = IteratorUtil - .asFilteredStream(resource.getAllContents(), Reactor.class) - .filter(reactor -> reactor.isMain() || reactor.isFederated()) - .findFirst(); + /** + * Construct an instantiation graph based on the given AST and, if the detectCycles argument is + * true, run Tarjan's algorithm to detect cyclic dependencies between instantiations. + * + * @param resource The resource associated with the AST. + * @param detectCycles Whether or not to detect cycles. + */ + public InstantiationGraph(final Resource resource, final boolean detectCycles) { + final Iterable instantiations = + Iterables.filter(IteratorUtil.asIterable(resource.getAllContents()), Instantiation.class); + Optional main = + IteratorUtil.asFilteredStream(resource.getAllContents(), Reactor.class) + .filter(reactor -> reactor.isMain() || reactor.isFederated()) + .findFirst(); - if (main.isPresent()) { - this.addNode(main.get()); - } - for (final Instantiation i : instantiations) { - this.buildGraph(i, new HashSet<>()); - } - if (detectCycles) { - this.detectCycles(); - } + if (main.isPresent()) { + this.addNode(main.get()); + } + for (final Instantiation i : instantiations) { + this.buildGraph(i, new HashSet<>()); + } + if (detectCycles) { + this.detectCycles(); } + } - /** - * Construct an instantiation graph based on the given AST and, if the - * detectCycles argument is true, run Tarjan's algorithm to detect cyclic - * dependencies between instantiations. - * @param model The root of the AST. - * @param detectCycles Whether or not to detect cycles. - */ - public InstantiationGraph(final Model model, final boolean detectCycles) { - for (final Reactor r : model.getReactors()) { - for (final Instantiation i : r.getInstantiations()) { - this.buildGraph(i, new HashSet<>()); - } - } - if (detectCycles) { - this.detectCycles(); - } + /** + * Construct an instantiation graph based on the given AST and, if the detectCycles argument is + * true, run Tarjan's algorithm to detect cyclic dependencies between instantiations. + * + * @param model The root of the AST. + * @param detectCycles Whether or not to detect cycles. + */ + public InstantiationGraph(final Model model, final boolean detectCycles) { + for (final Reactor r : model.getReactors()) { + for (final Instantiation i : r.getInstantiations()) { + this.buildGraph(i, new HashSet<>()); + } + } + if (detectCycles) { + this.detectCycles(); } + } - /** - * Traverse the AST and build this precedence graph relating the - * encountered instantiations. Also map each reactor to all - * declarations associated with it and each reactor to the sites of - * its instantiations. - */ - private void buildGraph(final Instantiation instantiation, final Set visited) { - final ReactorDecl decl = instantiation.getReactorClass(); - final Reactor reactor = ASTUtils.toDefinition(decl); - if (reactor != null) { - Reactor container = ASTUtils.getEnclosingReactor(instantiation); - if (visited.add(instantiation)) { - this.reactorToInstantiation.put(reactor, instantiation); - this.reactorToDecl.put(reactor, decl); - if (container != null) { - this.addEdge(container, reactor); - } else { - this.addNode(reactor); - } - for (final Instantiation inst : reactor.getInstantiations()) { - this.buildGraph(inst, visited); - } - } + /** + * Traverse the AST and build this precedence graph relating the encountered instantiations. Also + * map each reactor to all declarations associated with it and each reactor to the sites of its + * instantiations. + */ + private void buildGraph(final Instantiation instantiation, final Set visited) { + final ReactorDecl decl = instantiation.getReactorClass(); + final Reactor reactor = ASTUtils.toDefinition(decl); + if (reactor != null) { + Reactor container = ASTUtils.getEnclosingReactor(instantiation); + if (visited.add(instantiation)) { + this.reactorToInstantiation.put(reactor, instantiation); + this.reactorToDecl.put(reactor, decl); + if (container != null) { + this.addEdge(container, reactor); + } else { + this.addNode(reactor); + } + for (final Instantiation inst : reactor.getInstantiations()) { + this.buildGraph(inst, visited); } + } } + } } diff --git a/org.lflang/src/org/lflang/graph/NodeAnnotation.java b/org.lflang/src/org/lflang/graph/NodeAnnotation.java index b8b91c92ad..191967d043 100644 --- a/org.lflang/src/org/lflang/graph/NodeAnnotation.java +++ b/org.lflang/src/org/lflang/graph/NodeAnnotation.java @@ -1,66 +1,54 @@ /** * Copyright (c) 2019, The University of California at Berkeley. - * - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * + *

    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. + * + *

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR + * CONTRIBUTORS 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. */ package org.lflang.graph; /** - * Note annotations used in Tarjan's algorithm for finding strongly connected - * components. - * + * Note annotations used in Tarjan's algorithm for finding strongly connected components. + * * @author Marten Lohstroh */ public class NodeAnnotation { - /** - * Sequence number that is assigned when this node is discovered. - * A node with a lower index was discovered later than this one; - * a node with a higher index was discovered later than this one. - */ - public int index = -1; - - /** - * Temporary mark do be used in topological sort algorithm. - */ - public boolean hasTempMark = false; - - /** - * Temporary mark do be used in topological sort algorithm. - */ - public boolean hasPermMark = false; - - /** - * The smallest index of any node known to be reachable from this node. - */ - public int lowLink = -1; - - /** - * Whether or not this node is currently on the stack that - * keeps track of visited nodes that potentially form a cycle. - */ - public boolean onStack = false; - - /** - * Whether or not this node has a dependency on itself. - */ - public boolean selfLoop = false; -} + /** + * Sequence number that is assigned when this node is discovered. A node with a lower index was + * discovered later than this one; a node with a higher index was discovered later than this one. + */ + public int index = -1; + + /** Temporary mark do be used in topological sort algorithm. */ + public boolean hasTempMark = false; + + /** Temporary mark do be used in topological sort algorithm. */ + public boolean hasPermMark = false; + /** The smallest index of any node known to be reachable from this node. */ + public int lowLink = -1; + + /** + * Whether or not this node is currently on the stack that keeps track of visited nodes that + * potentially form a cycle. + */ + public boolean onStack = false; + + /** Whether or not this node has a dependency on itself. */ + public boolean selfLoop = false; +} diff --git a/org.lflang/src/org/lflang/graph/NodeAnnotations.java b/org.lflang/src/org/lflang/graph/NodeAnnotations.java index 346149a8c4..6efe85760a 100644 --- a/org.lflang/src/org/lflang/graph/NodeAnnotations.java +++ b/org.lflang/src/org/lflang/graph/NodeAnnotations.java @@ -1,46 +1,42 @@ /** * Copyright (c) 2019, The University of California at Berkeley. - * - * 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. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * + *

    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. + * + *

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR + * CONTRIBUTORS 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. */ package org.lflang.graph; import java.util.HashMap; -/** - * Maps a node in the graph to its annotation. - * Creates a new annotation if no annotation exists. - */ +/** Maps a node in the graph to its annotation. Creates a new annotation if no annotation exists. */ public class NodeAnnotations { private HashMap annotations = new HashMap(); - + public NodeAnnotation get(final T node) { NodeAnnotation annotation = this.annotations.get(node); if (annotation == null) { - annotation = new NodeAnnotation(); - this.annotations.put(node, annotation); + annotation = new NodeAnnotation(); + this.annotations.put(node, annotation); } return annotation; } - + public NodeAnnotation put(final T node, final NodeAnnotation annotation) { return this.annotations.put(node, annotation); } diff --git a/org.lflang/src/org/lflang/graph/PrecedenceGraph.java b/org.lflang/src/org/lflang/graph/PrecedenceGraph.java index 03fd266f6a..80abb21455 100644 --- a/org.lflang/src/org/lflang/graph/PrecedenceGraph.java +++ b/org.lflang/src/org/lflang/graph/PrecedenceGraph.java @@ -1,242 +1,219 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.graph; +import java.util.ArrayList; import java.util.LinkedHashSet; import java.util.List; import java.util.Set; import java.util.Stack; - import org.eclipse.xtext.xbase.lib.ListExtensions; -import java.util.ArrayList; - -/** - * Elaboration of {@code DirectedGraph} that is capable of identifying strongly - * connected components and topologically sorting its nodes. - * +/** + * Elaboration of {@code DirectedGraph} that is capable of identifying strongly connected components + * and topologically sorting its nodes. + * * @author Marten Lohstroh */ public class PrecedenceGraph extends DirectedGraph { - /** - * Annotations used during the execution of Tarjan's algorithm. - */ - private NodeAnnotations annotations = new NodeAnnotations(); - - /** - * Indicates whether or not the graph has been analyzed for cycles. - * If this variable is false, Tarjan's algorithm need to be ran to find out - * whether or not this graph has cycles. - */ - private boolean cycleAnalysisDone = false; - - /** - * Indicates whether or not the graph has been sorted. - * If this variable is false, a new DFS has to be done to compute a - * topological sort. - */ - private boolean isSorted = false; - - /** - * Index used in Tarjan's algorithm. - */ - private int index = 0; - - /** - * After analysis has completed, this list contains all nodes in reverse - * topological order. - */ - private List sortedNodes = new ArrayList<>(); - - /** - * Stack used in Tarjan's algorithm. - */ - private Stack stack = new Stack<>(); - - /** - * After analysis has completed, this list contains all all sets of nodes - * that are part of the same strongly connected component. - */ - protected List> cycles = new ArrayList<>(); - - /** - * Invalidate cached analysis due to changes in the graph structure. - */ - @Override - public void graphChanged() { - this.cycleAnalysisDone = false; - this.isSorted = false; - } - - /** - * Construct a new dependency graph. - */ - public PrecedenceGraph() {} - - /** - * Topologically sort the nodes in the graph. - */ - private void sortNodes() { - if (!this.isSorted) { - // Cleanup. - this.sortedNodes = new ArrayList<>(); - this.nodes().forEach( - it -> { - this.annotations.get(it).hasTempMark = false; - this.annotations.get(it).hasPermMark = false; - } - ); - - // Start sorting. - for (T node : this.nodes()) { - if (!this.annotations.get(node).hasPermMark) { - // Unmarked node. - this.visit(node); - } - } - this.isSorted = true; + /** Annotations used during the execution of Tarjan's algorithm. */ + private NodeAnnotations annotations = new NodeAnnotations(); + + /** + * Indicates whether or not the graph has been analyzed for cycles. If this variable is false, + * Tarjan's algorithm need to be ran to find out whether or not this graph has cycles. + */ + private boolean cycleAnalysisDone = false; + + /** + * Indicates whether or not the graph has been sorted. If this variable is false, a new DFS has to + * be done to compute a topological sort. + */ + private boolean isSorted = false; + + /** Index used in Tarjan's algorithm. */ + private int index = 0; + + /** After analysis has completed, this list contains all nodes in reverse topological order. */ + private List sortedNodes = new ArrayList<>(); + + /** Stack used in Tarjan's algorithm. */ + private Stack stack = new Stack<>(); + + /** + * After analysis has completed, this list contains all all sets of nodes that are part of the + * same strongly connected component. + */ + protected List> cycles = new ArrayList<>(); + + /** Invalidate cached analysis due to changes in the graph structure. */ + @Override + public void graphChanged() { + this.cycleAnalysisDone = false; + this.isSorted = false; + } + + /** Construct a new dependency graph. */ + public PrecedenceGraph() {} + + /** Topologically sort the nodes in the graph. */ + private void sortNodes() { + if (!this.isSorted) { + // Cleanup. + this.sortedNodes = new ArrayList<>(); + this.nodes() + .forEach( + it -> { + this.annotations.get(it).hasTempMark = false; + this.annotations.get(it).hasPermMark = false; + }); + + // Start sorting. + for (T node : this.nodes()) { + if (!this.annotations.get(node).hasPermMark) { + // Unmarked node. + this.visit(node); } + } + this.isSorted = true; } - - /** - * Recursively visit all nodes reachable from the given node; after all - * those nodes have been visited add the current node to a list which will - * be sorted in reverse order. - */ - private void visit(T node) { - NodeAnnotation annotation = this.annotations.get(node); - if (annotation.hasPermMark) { - return; - } - if (annotation.hasTempMark) { - // Not a DAG. - throw new Error("Cannot order nodes due to cycle in the graph."); - } - annotation.hasTempMark = true; - for (T dep : this.getDownstreamAdjacentNodes(node)) { - visit(dep); - } - annotation.hasTempMark = false; - annotation.hasPermMark = true; - this.sortedNodes.add(node); - } - - /** - * Run Tarjan's algorithm for finding strongly connected components. - * After invoking this method, the detected cycles with be listed - * in the class variable {@code cycles}. - */ - public void detectCycles() { - if (!this.cycleAnalysisDone) { - this.index = 0; - this.stack = new Stack<>(); - this.cycles = new ArrayList<>(); - this.nodes().forEach(it -> { - this.annotations.get(it).index = -1; - }); - for (T node : this.nodes()) { - if (this.annotations.get(node).index == -1) { - this.strongConnect(node); - } - } - this.cycleAnalysisDone = true; - stack = null; - } + } + + /** + * Recursively visit all nodes reachable from the given node; after all those nodes have been + * visited add the current node to a list which will be sorted in reverse order. + */ + private void visit(T node) { + NodeAnnotation annotation = this.annotations.get(node); + if (annotation.hasPermMark) { + return; } - - /** - * Report whether this graph has any cycles in it. - */ - public boolean hasCycles() { - this.detectCycles(); - return this.cycles.size() > 0; + if (annotation.hasTempMark) { + // Not a DAG. + throw new Error("Cannot order nodes due to cycle in the graph."); } - - /** - * Return a list of strongly connected components that exist in this graph. - */ - public List> getCycles() { - this.detectCycles(); - return this.cycles; + annotation.hasTempMark = true; + for (T dep : this.getDownstreamAdjacentNodes(node)) { + visit(dep); } - - /** - * Traverse the graph to visit unvisited dependencies and determine - * whether they are part of a cycle. - */ - public void strongConnect(T node) { - NodeAnnotation annotation = this.annotations.get(node); - annotation.index = this.index; - annotation.lowLink = this.index; - annotation.onStack = true; - this.index++; - this.stack.push(node); - for (T dep : this.getUpstreamAdjacentNodes(node)) { - NodeAnnotation depAnnotation = this.annotations.get(dep); - if (depAnnotation.onStack) { - annotation.lowLink = Math.min(annotation.lowLink, depAnnotation.index); - if (node.equals(dep)) { - annotation.selfLoop = true; - } - } else if (depAnnotation.index == -1) { - strongConnect(dep); - annotation.lowLink = Math.min(annotation.lowLink, depAnnotation.lowLink); - } - } - - if (annotation.lowLink == annotation.index) { - Set scc = new LinkedHashSet<>(); - T dep = null; - do { - dep = this.stack.pop(); - this.annotations.get(dep).onStack = false; - scc.add(dep); - } while (!node.equals(dep)); - // Only report self loops or cycles with two or more nodes. - if (scc.size() > 1 || annotation.selfLoop) { - this.cycles.add(scc); - } + annotation.hasTempMark = false; + annotation.hasPermMark = true; + this.sortedNodes.add(node); + } + + /** + * Run Tarjan's algorithm for finding strongly connected components. After invoking this method, + * the detected cycles with be listed in the class variable {@code cycles}. + */ + public void detectCycles() { + if (!this.cycleAnalysisDone) { + this.index = 0; + this.stack = new Stack<>(); + this.cycles = new ArrayList<>(); + this.nodes() + .forEach( + it -> { + this.annotations.get(it).index = -1; + }); + for (T node : this.nodes()) { + if (this.annotations.get(node).index == -1) { + this.strongConnect(node); } + } + this.cycleAnalysisDone = true; + stack = null; } - - /** - * Return the nodes of this graph in reverse topological order. Each node - * in the returned list is succeeded by the nodes that it depends on. - */ - public List nodesInReverseTopologicalOrder() { - this.sortNodes(); - return this.sortedNodes; + } + + /** Report whether this graph has any cycles in it. */ + public boolean hasCycles() { + this.detectCycles(); + return this.cycles.size() > 0; + } + + /** Return a list of strongly connected components that exist in this graph. */ + public List> getCycles() { + this.detectCycles(); + return this.cycles; + } + + /** + * Traverse the graph to visit unvisited dependencies and determine whether they are part of a + * cycle. + */ + public void strongConnect(T node) { + NodeAnnotation annotation = this.annotations.get(node); + annotation.index = this.index; + annotation.lowLink = this.index; + annotation.onStack = true; + this.index++; + this.stack.push(node); + for (T dep : this.getUpstreamAdjacentNodes(node)) { + NodeAnnotation depAnnotation = this.annotations.get(dep); + if (depAnnotation.onStack) { + annotation.lowLink = Math.min(annotation.lowLink, depAnnotation.index); + if (node.equals(dep)) { + annotation.selfLoop = true; + } + } else if (depAnnotation.index == -1) { + strongConnect(dep); + annotation.lowLink = Math.min(annotation.lowLink, depAnnotation.lowLink); + } } - - /** - * Return the nodes of this graph in reverse topological order. Each node - * in the returned list is preceded by the nodes that it depends on. - */ - public List nodesInTopologicalOrder() { - this.sortNodes(); - return ListExtensions.reverse(this.sortedNodes); + + if (annotation.lowLink == annotation.index) { + Set scc = new LinkedHashSet<>(); + T dep = null; + do { + dep = this.stack.pop(); + this.annotations.get(dep).onStack = false; + scc.add(dep); + } while (!node.equals(dep)); + // Only report self loops or cycles with two or more nodes. + if (scc.size() > 1 || annotation.selfLoop) { + this.cycles.add(scc); + } } + } + + /** + * Return the nodes of this graph in reverse topological order. Each node in the returned list is + * succeeded by the nodes that it depends on. + */ + public List nodesInReverseTopologicalOrder() { + this.sortNodes(); + return this.sortedNodes; + } + + /** + * Return the nodes of this graph in reverse topological order. Each node in the returned list is + * preceded by the nodes that it depends on. + */ + public List nodesInTopologicalOrder() { + this.sortNodes(); + return ListExtensions.reverse(this.sortedNodes); + } } diff --git a/org.lflang/src/org/lflang/graph/TopologyGraph.java b/org.lflang/src/org/lflang/graph/TopologyGraph.java index f790de65a7..31d6de9500 100644 --- a/org.lflang/src/org/lflang/graph/TopologyGraph.java +++ b/org.lflang/src/org/lflang/graph/TopologyGraph.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2020, The University of California at Berkeley. - * + * * 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. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE @@ -28,7 +28,6 @@ import java.util.Arrays; import java.util.Collection; - import org.lflang.generator.NamedInstance; import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; @@ -39,142 +38,143 @@ import org.lflang.lf.Variable; /** - * A graph with vertices that are ports or reactions and edges that denote - * dependencies between them. - * - * NOTE: This is not used anywhere anymore, but we keep it in case this particular - * graph structure proves useful in the future. - * + * A graph with vertices that are ports or reactions and edges that denote dependencies between + * them. + * + *

    NOTE: This is not used anywhere anymore, but we keep it in case this particular graph + * structure proves useful in the future. + * * @author Marten Lohstroh */ public class TopologyGraph extends PrecedenceGraph> { - /** - * Construct a graph with vertices that are reactions or ports and edges - * that represent (zero-delay) dependencies. - * - * After constructing the graph, run Tarjan's algorithm to detect cyclic - * dependencies between reactions. It is assumed that no instantiation - * cycles are present in the program. Checks for instantiation cycles thus - * must be carried out prior to constructing this graph. - * - * @param reactors The reactor instances to construct the graph for. - */ - public TopologyGraph(Collection reactors) { - for (var r : reactors) { - collectNodesFrom(r); - } - this.detectCycles(); + /** + * Construct a graph with vertices that are reactions or ports and edges that represent + * (zero-delay) dependencies. + * + *

    After constructing the graph, run Tarjan's algorithm to detect cyclic dependencies between + * reactions. It is assumed that no instantiation cycles are present in the program. Checks for + * instantiation cycles thus must be carried out prior to constructing this graph. + * + * @param reactors The reactor instances to construct the graph for. + */ + public TopologyGraph(Collection reactors) { + for (var r : reactors) { + collectNodesFrom(r); } + this.detectCycles(); + } - /** See description on other constructor. */ - public TopologyGraph(ReactorInstance... reactors) { - this(Arrays.asList(reactors)); - } + /** See description on other constructor. */ + public TopologyGraph(ReactorInstance... reactors) { + this(Arrays.asList(reactors)); + } - /** - * Build the graph by recursively visiting reactor instances contained in - * the passed in reactor instance. - * - * @param reactor A reactor instance to harvest dependencies from. - */ - public void collectNodesFrom(ReactorInstance reactor) { - ReactionInstance previousReaction = null; - for (var reaction : reactor.reactions) { - this.addNode(reaction); + /** + * Build the graph by recursively visiting reactor instances contained in the passed in reactor + * instance. + * + * @param reactor A reactor instance to harvest dependencies from. + */ + public void collectNodesFrom(ReactorInstance reactor) { + ReactionInstance previousReaction = null; + for (var reaction : reactor.reactions) { + this.addNode(reaction); - this.addSources(reaction); - this.addEffects(reaction); + this.addSources(reaction); + this.addEffects(reaction); - // If this is not an unordered reaction, then create a dependency - // on any previously defined reaction. - if (!reaction.isUnordered) { - // If there is an earlier reaction in this same reactor, then - // create a link in the reaction graph. - if (previousReaction != null) { - this.addEdge(reaction, previousReaction); - } - previousReaction = reaction; - } - } - // Recursively add nodes and edges from contained reactors. - for (var child : reactor.children) { - collectNodesFrom(child); + // If this is not an unordered reaction, then create a dependency + // on any previously defined reaction. + if (!reaction.isUnordered) { + // If there is an earlier reaction in this same reactor, then + // create a link in the reaction graph. + if (previousReaction != null) { + this.addEdge(reaction, previousReaction); } + previousReaction = reaction; + } } + // Recursively add nodes and edges from contained reactors. + for (var child : reactor.children) { + collectNodesFrom(child); + } + } - /** - * Given a reaction instance, record dependencies implied by its effects. - * - * Excluded from the recorded dependencies are those that are broken by - * physical connections or "after" delays. - * - * @param reaction The reaction to record the dependencies of. - */ - private void addEffects(ReactionInstance reaction) { - for (TriggerInstance effect : reaction.effects) { - if (effect instanceof PortInstance) { - addEdge(effect, reaction); - PortInstance orig = (PortInstance) effect; - for (SendRange sendRange : orig.getDependentPorts()) { - sendRange.destinations.forEach(dest -> { - recordDependency(reaction, orig, dest.instance, sendRange.connection); - }); - } - } + /** + * Given a reaction instance, record dependencies implied by its effects. + * + *

    Excluded from the recorded dependencies are those that are broken by physical connections or + * "after" delays. + * + * @param reaction The reaction to record the dependencies of. + */ + private void addEffects(ReactionInstance reaction) { + for (TriggerInstance effect : reaction.effects) { + if (effect instanceof PortInstance) { + addEdge(effect, reaction); + PortInstance orig = (PortInstance) effect; + for (SendRange sendRange : orig.getDependentPorts()) { + sendRange.destinations.forEach( + dest -> { + recordDependency(reaction, orig, dest.instance, sendRange.connection); + }); } + } } + } - /** - * Given a reaction instance, record dependencies implied by its sources. - * - * Excluded from the recorded dependencies are those that are broken by - * physical connections or "after" delays. - * - * @param reaction The reaction to record the dependencies of. - */ - private void addSources(ReactionInstance reaction) { - for (TriggerInstance source : reaction.sources) { - if (source instanceof PortInstance) { - addEdge(reaction, source); - PortInstance dest = (PortInstance) source; - dest.getDependsOnPorts().forEach(orig -> { - // FIXME: Don't have connection information here, hence the null argument. - // This will like result in invalid cycle detection. - recordDependency(reaction, orig.instance, dest, null); + /** + * Given a reaction instance, record dependencies implied by its sources. + * + *

    Excluded from the recorded dependencies are those that are broken by physical connections or + * "after" delays. + * + * @param reaction The reaction to record the dependencies of. + */ + private void addSources(ReactionInstance reaction) { + for (TriggerInstance source : reaction.sources) { + if (source instanceof PortInstance) { + addEdge(reaction, source); + PortInstance dest = (PortInstance) source; + dest.getDependsOnPorts() + .forEach( + orig -> { + // FIXME: Don't have connection information here, hence the null argument. + // This will like result in invalid cycle detection. + recordDependency(reaction, orig.instance, dest, null); }); - } - } + } } + } - /** - * Record a dependency between two port instances, but only if there is a - * zero-delay path from origin to destination. - * - * @param reaction A reaction that has one of the given ports as a source or - * effect. - * @param orig The upstream port. - * @param dest The downstream port. - * @param connection The connection creating this dependency or null if not - * created by a connection. - */ - private void recordDependency(ReactionInstance reaction, PortInstance orig, - PortInstance dest, Connection connection) { - if (!dependencyBroken(connection)) { - addEdge(dest, orig); - } + /** + * Record a dependency between two port instances, but only if there is a zero-delay path from + * origin to destination. + * + * @param reaction A reaction that has one of the given ports as a source or effect. + * @param orig The upstream port. + * @param dest The downstream port. + * @param connection The connection creating this dependency or null if not created by a + * connection. + */ + private void recordDependency( + ReactionInstance reaction, PortInstance orig, PortInstance dest, Connection connection) { + if (!dependencyBroken(connection)) { + addEdge(dest, orig); } + } - /** - * Report whether or not the given connection breaks dependencies or not. - * - * @param c An AST object that represents a connection. - * @return true if the connection is physical or has a delay. - */ - private boolean dependencyBroken(Connection c) { - if (c != null && (c.isPhysical() || c.getDelay() != null)) { - return true; - } - return false; + /** + * Report whether or not the given connection breaks dependencies or not. + * + * @param c An AST object that represents a connection. + * @return true if the connection is physical or has a delay. + */ + private boolean dependencyBroken(Connection c) { + if (c != null && (c.isPhysical() || c.getDelay() != null)) { + return true; } + return false; + } } diff --git a/org.lflang/src/org/lflang/ide/LFIdeModule.java b/org.lflang/src/org/lflang/ide/LFIdeModule.java index 6c63d9c6e0..81aa863bd1 100644 --- a/org.lflang/src/org/lflang/ide/LFIdeModule.java +++ b/org.lflang/src/org/lflang/ide/LFIdeModule.java @@ -3,9 +3,5 @@ */ package org.lflang.ide; - -/** - * Use this class to register ide components. - */ -public class LFIdeModule extends AbstractLFIdeModule { -} +/** Use this class to register ide components. */ +public class LFIdeModule extends AbstractLFIdeModule {} diff --git a/org.lflang/src/org/lflang/ide/LFIdeSetup.java b/org.lflang/src/org/lflang/ide/LFIdeSetup.java index 2e6b969952..7465bda78b 100644 --- a/org.lflang/src/org/lflang/ide/LFIdeSetup.java +++ b/org.lflang/src/org/lflang/ide/LFIdeSetup.java @@ -6,17 +6,14 @@ import org.lflang.LFRuntimeModule; import org.lflang.LFStandaloneSetup; -/** - * Initialization support for running Xtext languages as language servers. - */ +/** Initialization support for running Xtext languages as language servers. */ public class LFIdeSetup extends LFStandaloneSetup { - public LFIdeSetup() { - super(new LFRuntimeModule(), new LFIdeModule()); - } - - public static void doSetup() { - new LFIdeSetup().createInjectorAndDoEMFRegistration(); - } + public LFIdeSetup() { + super(new LFRuntimeModule(), new LFIdeModule()); + } + public static void doSetup() { + new LFIdeSetup().createInjectorAndDoEMFRegistration(); + } } diff --git a/org.lflang/src/org/lflang/scoping/LFGlobalScopeProvider.java b/org.lflang/src/org/lflang/scoping/LFGlobalScopeProvider.java index 119ccae842..18c7a3a8af 100644 --- a/org.lflang/src/org/lflang/scoping/LFGlobalScopeProvider.java +++ b/org.lflang/src/org/lflang/scoping/LFGlobalScopeProvider.java @@ -25,134 +25,121 @@ import com.google.common.base.Splitter; import com.google.inject.Inject; import com.google.inject.Provider; - import java.util.LinkedHashSet; import java.util.Set; - import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.EcoreUtil2; import org.eclipse.xtext.resource.IResourceDescription; import org.eclipse.xtext.scoping.impl.ImportUriGlobalScopeProvider; import org.eclipse.xtext.util.IResourceScopeCache; - -import org.lflang.lf.LfPackage; import org.lflang.LFResourceDescriptionStrategy; +import org.lflang.lf.LfPackage; /** - * Global scope provider that limits access to only those files that were - * explicitly imported. - *

    - * Adapted from from Xtext manual, Chapter 8.7. + * Global scope provider that limits access to only those files that were explicitly imported. + * + *

    Adapted from from Xtext manual, Chapter 8.7. * * @author Marten Lohstroh - * @see xtext doc + * @see xtext + * doc */ public class LFGlobalScopeProvider extends ImportUriGlobalScopeProvider { - /** - * Splitter used to process user-data annotations of Model nodes. - */ - static final Splitter SPLITTER = Splitter.on(LFResourceDescriptionStrategy.DELIMITER); - - static final String IMPORTED_URIS = "IMPORTED_URIS"; - - static final String IMPORTED_RESOURCES = "IMPORTED_RESOURCES"; - - @Inject - private IResourceDescription.Manager descriptionManager; - - @Inject - private IResourceScopeCache cache; - - /** - * Return the set of URI objects pointing to the resources that must be - * included for compilation. - */ - @Override - protected LinkedHashSet getImportedUris(Resource resource) { - return cache.get(IMPORTED_URIS, resource, - new Provider>() { - /** - * Collect unique URIs in case the cache is not populated yet. - */ - @Override - public LinkedHashSet get() { - var uniqueImportURIs = new LinkedHashSet(5); - collectImportUris(resource, uniqueImportURIs); - uniqueImportURIs.removeIf(uri -> !EcoreUtil2.isValidUri(resource, uri)); - return uniqueImportURIs; - } - - /** - * Helper method to recursively collect unique URIs. - */ - void collectImportUris(Resource resource, LinkedHashSet uniqueImportURIs) { - for (var imported : getImportedResources(resource, uniqueImportURIs)) { - collectImportUris(imported, uniqueImportURIs); - } - } - }); - } - - /** - * Return the resources imported by the given resource. - */ - public Set getImportedResources(Resource resource) { - return cache.get(IMPORTED_RESOURCES, resource, () -> getImportedResources(resource, null)); - } - - /** - * Resolve a resource identifier. - * - * @param uriStr resource identifier to resolve. - * @param resource resource to (initially) resolve it relative to. - */ - protected URI resolve(String uriStr, Resource resource) { - var uriObj = URI.createURI(uriStr); - if (uriObj != null && "lf".equalsIgnoreCase(uriObj.fileExtension())) { - // FIXME: If this doesn't work, try other things: - // (1) Look for a .project file up the file structure and try to - // resolve relative to the directory in which it is found. - // (2) Look for package description files try to resolve relative - // to the paths it includes. - // FIXME: potentially use a cache here to speed things up. - // See OnChangeEvictingCache - return uriObj.resolve(resource.getURI()); - } - return null; + /** Splitter used to process user-data annotations of Model nodes. */ + static final Splitter SPLITTER = Splitter.on(LFResourceDescriptionStrategy.DELIMITER); + + static final String IMPORTED_URIS = "IMPORTED_URIS"; + + static final String IMPORTED_RESOURCES = "IMPORTED_RESOURCES"; + + @Inject private IResourceDescription.Manager descriptionManager; + + @Inject private IResourceScopeCache cache; + + /** + * Return the set of URI objects pointing to the resources that must be included for compilation. + */ + @Override + protected LinkedHashSet getImportedUris(Resource resource) { + return cache.get( + IMPORTED_URIS, + resource, + new Provider>() { + /** Collect unique URIs in case the cache is not populated yet. */ + @Override + public LinkedHashSet get() { + var uniqueImportURIs = new LinkedHashSet(5); + collectImportUris(resource, uniqueImportURIs); + uniqueImportURIs.removeIf(uri -> !EcoreUtil2.isValidUri(resource, uri)); + return uniqueImportURIs; + } + + /** Helper method to recursively collect unique URIs. */ + void collectImportUris(Resource resource, LinkedHashSet uniqueImportURIs) { + for (var imported : getImportedResources(resource, uniqueImportURIs)) { + collectImportUris(imported, uniqueImportURIs); + } + } + }); + } + + /** Return the resources imported by the given resource. */ + public Set getImportedResources(Resource resource) { + return cache.get(IMPORTED_RESOURCES, resource, () -> getImportedResources(resource, null)); + } + + /** + * Resolve a resource identifier. + * + * @param uriStr resource identifier to resolve. + * @param resource resource to (initially) resolve it relative to. + */ + protected URI resolve(String uriStr, Resource resource) { + var uriObj = URI.createURI(uriStr); + if (uriObj != null && "lf".equalsIgnoreCase(uriObj.fileExtension())) { + // FIXME: If this doesn't work, try other things: + // (1) Look for a .project file up the file structure and try to + // resolve relative to the directory in which it is found. + // (2) Look for package description files try to resolve relative + // to the paths it includes. + // FIXME: potentially use a cache here to speed things up. + // See OnChangeEvictingCache + return uriObj.resolve(resource.getURI()); } - - /** - * Return the resources imported by a given resource, excluding those - * already discovered and therefore are present in the given set of - * import URIs. - * - * @param resource The resource to analyze. - * @param uniqueImportURIs The set of discovered import URIs - */ - protected Set getImportedResources(Resource resource, LinkedHashSet uniqueImportURIs) { - var resourceDescription = descriptionManager.getResourceDescription(resource); - var models = resourceDescription.getExportedObjectsByType(LfPackage.Literals.MODEL); - var resources = new LinkedHashSet(); - for (var model : models) { - var userData = model.getUserData(LFResourceDescriptionStrategy.INCLUDES); - if (userData != null) { - for (String uri : SPLITTER.split(userData)) {// Attempt to resolve the URI - var includedUri = this.resolve(uri, resource); - if (includedUri != null) { - try { - if (uniqueImportURIs == null || uniqueImportURIs.add(includedUri)) { - resources.add(resource.getResourceSet().getResource(includedUri, true)); - } - } catch (RuntimeException e) { - System.err.println("Unable to import " + includedUri + ": " + e.getMessage()); - } - } - - } + return null; + } + + /** + * Return the resources imported by a given resource, excluding those already discovered and + * therefore are present in the given set of import URIs. + * + * @param resource The resource to analyze. + * @param uniqueImportURIs The set of discovered import URIs + */ + protected Set getImportedResources( + Resource resource, LinkedHashSet uniqueImportURIs) { + var resourceDescription = descriptionManager.getResourceDescription(resource); + var models = resourceDescription.getExportedObjectsByType(LfPackage.Literals.MODEL); + var resources = new LinkedHashSet(); + for (var model : models) { + var userData = model.getUserData(LFResourceDescriptionStrategy.INCLUDES); + if (userData != null) { + for (String uri : SPLITTER.split(userData)) { // Attempt to resolve the URI + var includedUri = this.resolve(uri, resource); + if (includedUri != null) { + try { + if (uniqueImportURIs == null || uniqueImportURIs.add(includedUri)) { + resources.add(resource.getResourceSet().getResource(includedUri, true)); + } + } catch (RuntimeException e) { + System.err.println("Unable to import " + includedUri + ": " + e.getMessage()); } + } } - return resources; + } } + return resources; + } } diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProvider.java b/org.lflang/src/org/lflang/scoping/LFScopeProvider.java index 9967ddaabe..6a303b0eaf 100644 --- a/org.lflang/src/org/lflang/scoping/LFScopeProvider.java +++ b/org.lflang/src/org/lflang/scoping/LFScopeProvider.java @@ -3,13 +3,10 @@ */ package org.lflang.scoping; - /** * This class contains custom scoping description. - * - * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping - * on how and when to use it. + * + *

    See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping on how and + * when to use it. */ -public class LFScopeProvider extends LFScopeProviderImpl { - -} +public class LFScopeProvider extends LFScopeProviderImpl {} diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java index 0e521e8cc4..c5cbea4e7e 100644 --- a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java +++ b/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java @@ -1,27 +1,27 @@ /************* -Copyright (c) 2020, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2020, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.scoping; @@ -29,16 +29,13 @@ import static org.lflang.ast.ASTUtils.*; import com.google.inject.Inject; - import java.util.ArrayList; - import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EReference; import org.eclipse.xtext.naming.SimpleNameProvider; import org.eclipse.xtext.scoping.IScope; import org.eclipse.xtext.scoping.Scopes; import org.eclipse.xtext.scoping.impl.SelectableBasedScope; - import org.lflang.lf.Assignment; import org.lflang.lf.Connection; import org.lflang.lf.Deadline; @@ -63,220 +60,220 @@ */ public class LFScopeProviderImpl extends AbstractLFScopeProvider { - @Inject - private SimpleNameProvider nameProvider; + @Inject private SimpleNameProvider nameProvider; - @Inject - private LFGlobalScopeProvider scopeProvider; + @Inject private LFGlobalScopeProvider scopeProvider; - /** - * Enumerate of the kinds of references. - */ - enum RefType { - NULL, - TRIGGER, - SOURCE, - EFFECT, - WATCHDOG, - DEADLINE, - CLEFT, - CRIGHT - } + /** Enumerate of the kinds of references. */ + enum RefType { + NULL, + TRIGGER, + SOURCE, + EFFECT, + WATCHDOG, + DEADLINE, + CLEFT, + CRIGHT + } - /** - * Depending on the provided context, construct the appropriate scope - * for the given reference. - * - * @param context The AST node in which a to-be-resolved reference occurs. - * @param reference The reference to resolve. - */ - @Override - public IScope getScope(EObject context, EReference reference) { - if (context instanceof VarRef) { - return getScopeForVarRef((VarRef) context, reference); - } else if (context instanceof Assignment) { - return getScopeForAssignment((Assignment) context, reference); - } else if (context instanceof Instantiation) { - return getScopeForReactorDecl(context, reference); - } else if (context instanceof Reactor) { - return getScopeForReactorDecl(context, reference); - } else if (context instanceof ImportedReactor) { - return getScopeForImportedReactor((ImportedReactor) context, reference); - } - return super.getScope(context, reference); + /** + * Depending on the provided context, construct the appropriate scope for the given reference. + * + * @param context The AST node in which a to-be-resolved reference occurs. + * @param reference The reference to resolve. + */ + @Override + public IScope getScope(EObject context, EReference reference) { + if (context instanceof VarRef) { + return getScopeForVarRef((VarRef) context, reference); + } else if (context instanceof Assignment) { + return getScopeForAssignment((Assignment) context, reference); + } else if (context instanceof Instantiation) { + return getScopeForReactorDecl(context, reference); + } else if (context instanceof Reactor) { + return getScopeForReactorDecl(context, reference); + } else if (context instanceof ImportedReactor) { + return getScopeForImportedReactor((ImportedReactor) context, reference); } + return super.getScope(context, reference); + } - /** - * Filter out candidates that do not originate from the file listed in - * this particular import statement. - */ - protected IScope getScopeForImportedReactor(ImportedReactor context, EReference reference) { - String importURI = ((Import) context.eContainer()).getImportURI(); - var importedURI = scopeProvider.resolve(importURI == null ? "" : importURI, context.eResource()); - if (importedURI != null) { - var uniqueImportURIs = scopeProvider.getImportedUris(context.eResource()); - var descriptions = scopeProvider.getResourceDescriptions(context.eResource(), uniqueImportURIs); - var description = descriptions.getResourceDescription(importedURI); - return SelectableBasedScope.createScope(IScope.NULLSCOPE, description, null, reference.getEReferenceType(), false); - } - return Scopes.scopeFor(emptyList()); + /** + * Filter out candidates that do not originate from the file listed in this particular import + * statement. + */ + protected IScope getScopeForImportedReactor(ImportedReactor context, EReference reference) { + String importURI = ((Import) context.eContainer()).getImportURI(); + var importedURI = + scopeProvider.resolve(importURI == null ? "" : importURI, context.eResource()); + if (importedURI != null) { + var uniqueImportURIs = scopeProvider.getImportedUris(context.eResource()); + var descriptions = + scopeProvider.getResourceDescriptions(context.eResource(), uniqueImportURIs); + var description = descriptions.getResourceDescription(importedURI); + return SelectableBasedScope.createScope( + IScope.NULLSCOPE, description, null, reference.getEReferenceType(), false); } + return Scopes.scopeFor(emptyList()); + } - /** - * @param obj Instantiation or Reactor that has a ReactorDecl to resolve. - * @param reference The reference to link to a ReactorDecl node. - */ - protected IScope getScopeForReactorDecl(EObject obj, EReference reference) { + /** + * @param obj Instantiation or Reactor that has a ReactorDecl to resolve. + * @param reference The reference to link to a ReactorDecl node. + */ + protected IScope getScopeForReactorDecl(EObject obj, EReference reference) { - // Find the local Model - Model model = null; - EObject container = obj; - while(model == null && container != null) { - container = container.eContainer(); - if (container instanceof Model) { - model = (Model)container; - } - } - if (model == null) { - return Scopes.scopeFor(emptyList()); - } + // Find the local Model + Model model = null; + EObject container = obj; + while (model == null && container != null) { + container = container.eContainer(); + if (container instanceof Model) { + model = (Model) container; + } + } + if (model == null) { + return Scopes.scopeFor(emptyList()); + } - // Collect eligible candidates, all of which are local (i.e., not in other files). - var locals = new ArrayList(model.getReactors()); + // Collect eligible candidates, all of which are local (i.e., not in other files). + var locals = new ArrayList(model.getReactors()); - // Either point to the import statement (if it is renamed) - // or directly to the reactor definition. - for (Import it : model.getImports()) { - for (ImportedReactor ir : it.getReactorClasses()) { - if (ir.getName() != null) { - locals.add(ir); - } else if (ir.getReactorClass() != null) { - locals.add(ir.getReactorClass()); - } - } + // Either point to the import statement (if it is renamed) + // or directly to the reactor definition. + for (Import it : model.getImports()) { + for (ImportedReactor ir : it.getReactorClasses()) { + if (ir.getName() != null) { + locals.add(ir); + } else if (ir.getReactorClass() != null) { + locals.add(ir.getReactorClass()); } - return Scopes.scopeFor(locals); + } } + return Scopes.scopeFor(locals); + } - protected IScope getScopeForAssignment(Assignment assignment, EReference reference) { + protected IScope getScopeForAssignment(Assignment assignment, EReference reference) { - if (reference == LfPackage.Literals.ASSIGNMENT__LHS) { - var defn = toDefinition(((Instantiation) assignment.eContainer()).getReactorClass()); - if (defn != null) { - return Scopes.scopeFor(allParameters(defn)); - } - } - if (reference == LfPackage.Literals.ASSIGNMENT__RHS) { - return Scopes.scopeFor(((Reactor) assignment.eContainer().eContainer()).getParameters()); - } - return Scopes.scopeFor(emptyList()); + if (reference == LfPackage.Literals.ASSIGNMENT__LHS) { + var defn = toDefinition(((Instantiation) assignment.eContainer()).getReactorClass()); + if (defn != null) { + return Scopes.scopeFor(allParameters(defn)); + } + } + if (reference == LfPackage.Literals.ASSIGNMENT__RHS) { + return Scopes.scopeFor(((Reactor) assignment.eContainer().eContainer()).getParameters()); } + return Scopes.scopeFor(emptyList()); + } - protected IScope getScopeForVarRef(VarRef variable, EReference reference) { - if (reference == LfPackage.Literals.VAR_REF__VARIABLE) { - // Resolve hierarchical reference - Reactor reactor; - Mode mode = null; - if (variable.eContainer().eContainer() instanceof Reactor) { - reactor = (Reactor) variable.eContainer().eContainer(); - } else if (variable.eContainer().eContainer() instanceof Mode) { - mode = (Mode) variable.eContainer().eContainer(); - reactor = (Reactor) variable.eContainer().eContainer().eContainer(); - } else { - return Scopes.scopeFor(emptyList()); - } + protected IScope getScopeForVarRef(VarRef variable, EReference reference) { + if (reference == LfPackage.Literals.VAR_REF__VARIABLE) { + // Resolve hierarchical reference + Reactor reactor; + Mode mode = null; + if (variable.eContainer().eContainer() instanceof Reactor) { + reactor = (Reactor) variable.eContainer().eContainer(); + } else if (variable.eContainer().eContainer() instanceof Mode) { + mode = (Mode) variable.eContainer().eContainer(); + reactor = (Reactor) variable.eContainer().eContainer().eContainer(); + } else { + return Scopes.scopeFor(emptyList()); + } - RefType type = getRefType(variable); + RefType type = getRefType(variable); - if (variable.getContainer() != null) { // Resolve hierarchical port reference - var instanceName = nameProvider.getFullyQualifiedName(variable.getContainer()); - var instances = new ArrayList(reactor.getInstantiations()); - if (mode != null) { - instances.addAll(mode.getInstantiations()); - } + if (variable.getContainer() != null) { // Resolve hierarchical port reference + var instanceName = nameProvider.getFullyQualifiedName(variable.getContainer()); + var instances = new ArrayList(reactor.getInstantiations()); + if (mode != null) { + instances.addAll(mode.getInstantiations()); + } - if (instanceName != null) { - for (var instance : instances) { - var defn = toDefinition(instance.getReactorClass()); - if (defn != null && instance.getName().equals(instanceName.toString())) { - switch (type) { - case TRIGGER: - case SOURCE: - case CLEFT: - return Scopes.scopeFor(allOutputs(defn)); - case EFFECT: - case DEADLINE: - case CRIGHT: - return Scopes.scopeFor(allInputs(defn)); - } - } - } - } - return Scopes.scopeFor(emptyList()); - } else { - // Resolve local reference - switch (type) { - case TRIGGER: { - var candidates = new ArrayList(); - if (mode != null) { - candidates.addAll(mode.getActions()); - candidates.addAll(mode.getTimers()); - } - candidates.addAll(allInputs(reactor)); - candidates.addAll(allActions(reactor)); - candidates.addAll(allTimers(reactor)); - candidates.addAll(allWatchdogs(reactor)); - return Scopes.scopeFor(candidates); - } + if (instanceName != null) { + for (var instance : instances) { + var defn = toDefinition(instance.getReactorClass()); + if (defn != null && instance.getName().equals(instanceName.toString())) { + switch (type) { + case TRIGGER: case SOURCE: - return super.getScope(variable, reference); - case EFFECT: { - var candidates = new ArrayList(); - if (mode != null) { - candidates.addAll(mode.getActions()); - candidates.addAll(reactor.getModes()); - } - candidates.addAll(allOutputs(reactor)); - candidates.addAll(allActions(reactor)); - candidates.addAll(allWatchdogs(reactor)); - return Scopes.scopeFor(candidates); - } - case WATCHDOG: - return Scopes.scopeFor(allWatchdogs(reactor)); - case DEADLINE: case CLEFT: - return Scopes.scopeFor(allInputs(reactor)); + return Scopes.scopeFor(allOutputs(defn)); + case EFFECT: + case DEADLINE: case CRIGHT: - return Scopes.scopeFor(allOutputs(reactor)); - default: - return Scopes.scopeFor(emptyList()); - } + return Scopes.scopeFor(allInputs(defn)); + } } - } else { // Resolve instance - return super.getScope(variable, reference); + } } - } - - private RefType getRefType(VarRef variable) { - if (variable.eContainer() instanceof Deadline) { - return RefType.DEADLINE; - } else if (variable.eContainer() instanceof Reaction) { - var reaction = (Reaction) variable.eContainer(); - if (reaction.getTriggers().contains(variable)) { - return RefType.TRIGGER; - } else if (reaction.getSources().contains(variable)) { - return RefType.SOURCE; - } else if (reaction.getEffects().contains(variable)) { - return RefType.EFFECT; + return Scopes.scopeFor(emptyList()); + } else { + // Resolve local reference + switch (type) { + case TRIGGER: + { + var candidates = new ArrayList(); + if (mode != null) { + candidates.addAll(mode.getActions()); + candidates.addAll(mode.getTimers()); + } + candidates.addAll(allInputs(reactor)); + candidates.addAll(allActions(reactor)); + candidates.addAll(allTimers(reactor)); + candidates.addAll(allWatchdogs(reactor)); + return Scopes.scopeFor(candidates); } - } else if (variable.eContainer() instanceof Connection) { - var conn = (Connection) variable.eContainer(); - if (conn.getLeftPorts().contains(variable)) { - return RefType.CLEFT; - } else if (conn.getRightPorts().contains(variable)) { - return RefType.CRIGHT; + case SOURCE: + return super.getScope(variable, reference); + case EFFECT: + { + var candidates = new ArrayList(); + if (mode != null) { + candidates.addAll(mode.getActions()); + candidates.addAll(reactor.getModes()); + } + candidates.addAll(allOutputs(reactor)); + candidates.addAll(allActions(reactor)); + candidates.addAll(allWatchdogs(reactor)); + return Scopes.scopeFor(candidates); } + case WATCHDOG: + return Scopes.scopeFor(allWatchdogs(reactor)); + case DEADLINE: + case CLEFT: + return Scopes.scopeFor(allInputs(reactor)); + case CRIGHT: + return Scopes.scopeFor(allOutputs(reactor)); + default: + return Scopes.scopeFor(emptyList()); } - return RefType.NULL; + } + } else { // Resolve instance + return super.getScope(variable, reference); + } + } + + private RefType getRefType(VarRef variable) { + if (variable.eContainer() instanceof Deadline) { + return RefType.DEADLINE; + } else if (variable.eContainer() instanceof Reaction) { + var reaction = (Reaction) variable.eContainer(); + if (reaction.getTriggers().contains(variable)) { + return RefType.TRIGGER; + } else if (reaction.getSources().contains(variable)) { + return RefType.SOURCE; + } else if (reaction.getEffects().contains(variable)) { + return RefType.EFFECT; + } + } else if (variable.eContainer() instanceof Connection) { + var conn = (Connection) variable.eContainer(); + if (conn.getLeftPorts().contains(variable)) { + return RefType.CLEFT; + } else if (conn.getRightPorts().contains(variable)) { + return RefType.CRIGHT; + } } + return RefType.NULL; + } } diff --git a/org.lflang/src/org/lflang/util/ArduinoUtil.java b/org.lflang/src/org/lflang/util/ArduinoUtil.java index 85eac8ae8f..af741da7f2 100644 --- a/org.lflang/src/org/lflang/util/ArduinoUtil.java +++ b/org.lflang/src/org/lflang/util/ArduinoUtil.java @@ -5,123 +5,153 @@ import java.io.FileWriter; import java.io.IOException; import java.util.List; - +import org.eclipse.xtext.xbase.lib.Exceptions; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.TargetConfig; import org.lflang.generator.GeneratorCommandFactory; import org.lflang.generator.LFGeneratorContext; -import org.eclipse.xtext.xbase.lib.Exceptions; - /** * Utilities for Building using Arduino CLI. * - * We take in a Generator Context, Command Factory, and Error Reporter and - * make subsequent calls to arduino-cli given a FileConfig and TargetConfig. - * - * This should be used immediately after CodeGen to compile if the user provides - * a board type within their LF file. If the user also provides a port with flash enabled, - * we will also attempt to upload the compiled sketch directly to the board. + *

    We take in a Generator Context, Command Factory, and Error Reporter and make subsequent calls + * to arduino-cli given a FileConfig and TargetConfig. + * + *

    This should be used immediately after CodeGen to compile if the user provides a board type + * within their LF file. If the user also provides a port with flash enabled, we will also attempt + * to upload the compiled sketch directly to the board. */ public class ArduinoUtil { - private LFGeneratorContext context; - private GeneratorCommandFactory commandFactory; - private ErrorReporter errorReporter; + private LFGeneratorContext context; + private GeneratorCommandFactory commandFactory; + private ErrorReporter errorReporter; - public ArduinoUtil (LFGeneratorContext context, GeneratorCommandFactory commandFactory, ErrorReporter errorReporter) { - this.context = context; - this.commandFactory = commandFactory; - this.errorReporter = errorReporter; - } + public ArduinoUtil( + LFGeneratorContext context, + GeneratorCommandFactory commandFactory, + ErrorReporter errorReporter) { + this.context = context; + this.commandFactory = commandFactory; + this.errorReporter = errorReporter; + } - /** - * Return true if arduino-cli exists, false otherwise. - */ - private boolean checkArduinoCLIExists() { - LFCommand checkCommand = LFCommand.get("arduino-cli", List.of("version")); - return checkCommand != null && checkCommand.run() == 0; - } + /** Return true if arduino-cli exists, false otherwise. */ + private boolean checkArduinoCLIExists() { + LFCommand checkCommand = LFCommand.get("arduino-cli", List.of("version")); + return checkCommand != null && checkCommand.run() == 0; + } - /** - * Generate an LF style command for Arduino compilation based on FQBN - * @param fileConfig - * @param targetConfig - * @return LFCommand to compile an Arduino program given an FQBN. - * @throws IOException - */ - private LFCommand arduinoCompileCommand(FileConfig fileConfig, TargetConfig targetConfig) throws IOException { - if (!checkArduinoCLIExists()) { - throw new IOException("Must have arduino-cli installed to auto-compile."); - } else { - var srcGenPath = fileConfig.getSrcGenPath(); - try { - // Write to a temporary file to execute since ProcessBuilder does not like spaces and double quotes in its arguments. - File testScript = File.createTempFile("arduino", null); - testScript.deleteOnExit(); - if (!testScript.setExecutable(true)) { - throw new IOException("Failed to make compile script executable"); - } - var fileWriter = new FileWriter(testScript.getAbsoluteFile(), true); - BufferedWriter bufferedWriter = new BufferedWriter(fileWriter); - String board = targetConfig.platformOptions.board != null ? targetConfig.platformOptions.board : "arduino:avr:leonardo"; - String isThreaded = targetConfig.platformOptions.board.contains("mbed") ? "-DLF_THREADED" : "-DLF_UNTHREADED"; - bufferedWriter.write("arduino-cli compile -b " + board + " --build-property " + - "compiler.c.extra_flags=\"" + isThreaded + " -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10\" " + - "--build-property compiler.cpp.extra_flags=\"" + isThreaded + " -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10\" " - + srcGenPath.toString()); - bufferedWriter.close(); - return commandFactory.createCommand( - testScript.getAbsolutePath(), List.of(), null); - } catch (IOException e) { - e.printStackTrace(); - throw new IOException(e); - } + /** + * Generate an LF style command for Arduino compilation based on FQBN + * + * @param fileConfig + * @param targetConfig + * @return LFCommand to compile an Arduino program given an FQBN. + * @throws IOException + */ + private LFCommand arduinoCompileCommand(FileConfig fileConfig, TargetConfig targetConfig) + throws IOException { + if (!checkArduinoCLIExists()) { + throw new IOException("Must have arduino-cli installed to auto-compile."); + } else { + var srcGenPath = fileConfig.getSrcGenPath(); + try { + // Write to a temporary file to execute since ProcessBuilder does not like spaces and double + // quotes in its arguments. + File testScript = File.createTempFile("arduino", null); + testScript.deleteOnExit(); + if (!testScript.setExecutable(true)) { + throw new IOException("Failed to make compile script executable"); } + var fileWriter = new FileWriter(testScript.getAbsoluteFile(), true); + BufferedWriter bufferedWriter = new BufferedWriter(fileWriter); + String board = + targetConfig.platformOptions.board != null + ? targetConfig.platformOptions.board + : "arduino:avr:leonardo"; + String isThreaded = + targetConfig.platformOptions.board.contains("mbed") + ? "-DLF_THREADED" + : "-DLF_UNTHREADED"; + bufferedWriter.write( + "arduino-cli compile -b " + + board + + " --build-property " + + "compiler.c.extra_flags=\"" + + isThreaded + + " -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10" + + " -DINITIAL_REACT_QUEUE_SIZE=10\" --build-property compiler.cpp.extra_flags=\"" + + isThreaded + + " -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10" + + " -DINITIAL_REACT_QUEUE_SIZE=10\" " + + srcGenPath.toString()); + bufferedWriter.close(); + return commandFactory.createCommand(testScript.getAbsolutePath(), List.of(), null); + } catch (IOException e) { + e.printStackTrace(); + throw new IOException(e); + } } + } - /** - * Compiles (and possibly auto-flashes) an Arduino program once code generation is completed. - * @param fileConfig - * @param targetConfig - */ - public void buildArduino(FileConfig fileConfig, TargetConfig targetConfig) { - System.out.println("Retrieving Arduino Compile Script"); - try { - LFCommand command = arduinoCompileCommand(fileConfig, targetConfig); // Use ProcessBuilder for finer control. - int retCode = 0; - retCode = command.run(context.getCancelIndicator()); - if (retCode != 0 && context.getMode() == LFGeneratorContext.Mode.STANDALONE) { - errorReporter.reportError("arduino-cli failed with error code " + retCode); - throw new IOException("arduino-cli failure"); - } - } catch (IOException e){ - Exceptions.sneakyThrow(e); + /** + * Compiles (and possibly auto-flashes) an Arduino program once code generation is completed. + * + * @param fileConfig + * @param targetConfig + */ + public void buildArduino(FileConfig fileConfig, TargetConfig targetConfig) { + System.out.println("Retrieving Arduino Compile Script"); + try { + LFCommand command = + arduinoCompileCommand(fileConfig, targetConfig); // Use ProcessBuilder for finer control. + int retCode = 0; + retCode = command.run(context.getCancelIndicator()); + if (retCode != 0 && context.getMode() == LFGeneratorContext.Mode.STANDALONE) { + errorReporter.reportError("arduino-cli failed with error code " + retCode); + throw new IOException("arduino-cli failure"); + } + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } + System.out.println( + "SUCCESS: Compiling generated code for " + fileConfig.name + " finished with no errors."); + if (targetConfig.platformOptions.flash) { + if (targetConfig.platformOptions.port != null) { + System.out.println("Invoking flash command for Arduino"); + LFCommand flash = + commandFactory.createCommand( + "arduino-cli", + List.of( + "upload", + "-b", + targetConfig.platformOptions.board, + "-p", + targetConfig.platformOptions.port), + fileConfig.getSrcGenPath()); + if (flash == null) { + errorReporter.reportError("Could not create arduino-cli flash command."); } - System.out.println("SUCCESS: Compiling generated code for " + fileConfig.name + " finished with no errors."); - if (targetConfig.platformOptions.flash) { - if (targetConfig.platformOptions.port != null) { - System.out.println("Invoking flash command for Arduino"); - LFCommand flash = commandFactory.createCommand( - "arduino-cli", List.of("upload", "-b", targetConfig.platformOptions.board, "-p", targetConfig.platformOptions.port), fileConfig.getSrcGenPath()); - if (flash == null) { - errorReporter.reportError( - "Could not create arduino-cli flash command." - ); - } - int flashRet = flash.run(); - if (flashRet != 0) { - errorReporter.reportError("arduino-cli flash command failed with error code " + flashRet); - } else { - System.out.println("SUCCESS: Flashed board using arduino-cli"); - } - } else { - errorReporter.reportError("Need to provide a port on which to automatically flash."); - } + int flashRet = flash.run(); + if (flashRet != 0) { + errorReporter.reportError("arduino-cli flash command failed with error code " + flashRet); } else { - System.out.println("********"); - System.out.println("To flash your program, run the following command to see information about the board you plugged in:\n\n\tarduino-cli board list\n\nGrab the FQBN and PORT from the command and run the following command in the generated sources directory:\n\n\tarduino-cli upload -b -p \n"); + System.out.println("SUCCESS: Flashed board using arduino-cli"); } + } else { + errorReporter.reportError("Need to provide a port on which to automatically flash."); + } + } else { + System.out.println("********"); + System.out.println( + "To flash your program, run the following command to see information about the board you" + + " plugged in:\n\n" + + "\tarduino-cli board list\n\n" + + "Grab the FQBN and PORT from the command and run the following command in the" + + " generated sources directory:\n\n" + + "\tarduino-cli upload -b -p \n"); } + } } diff --git a/org.lflang/src/org/lflang/util/Averager.java b/org.lflang/src/org/lflang/util/Averager.java index 81349c9db1..f156eafb22 100644 --- a/org.lflang/src/org/lflang/util/Averager.java +++ b/org.lflang/src/org/lflang/util/Averager.java @@ -1,27 +1,26 @@ package org.lflang.util; import java.util.Arrays; - import org.eclipse.xtext.xbase.lib.Procedures.Procedure1; /** Average asynchronously reported numbers and do something with them. */ public class Averager { - private final int n; - private final int[] reports; + private final int n; + private final int[] reports; - /** Create an averager of reports from {@code n} processes. */ - public Averager(int n) { - this.n = n; - reports = new int[n]; - } + /** Create an averager of reports from {@code n} processes. */ + public Averager(int n) { + this.n = n; + reports = new int[n]; + } - /** - * Receive {@code x} from process {@code id} and invoke {@code callback} - * on the mean of the numbers most recently reported by the processes. - */ - public synchronized void report(int id, int x, Procedure1 callback) { - assert 0 <= id && id < n; - reports[id] = x; - callback.apply(Arrays.stream(reports).sum() / n); - } + /** + * Receive {@code x} from process {@code id} and invoke {@code callback} on the mean of the + * numbers most recently reported by the processes. + */ + public synchronized void report(int id, int x, Procedure1 callback) { + assert 0 <= id && id < n; + reports[id] = x; + callback.apply(Arrays.stream(reports).sum() / n); + } } diff --git a/org.lflang/src/org/lflang/util/CollectionUtil.java b/org.lflang/src/org/lflang/util/CollectionUtil.java index 221cbc68ec..8510856c78 100644 --- a/org.lflang/src/org/lflang/util/CollectionUtil.java +++ b/org.lflang/src/org/lflang/util/CollectionUtil.java @@ -14,176 +14,159 @@ /** * Utilities to manipulate collections. * - *

    Most of these methods are using specialized collection - * implementations (possibly unmodifiable) for small collection - * sizes. No guarantee is made on the mutability of the collections - * returned from these functions, meaning, callers should always - * assume they are unmodifiable. Functions that take a collection - * parameter as input to produce a new one with a transformation - * require the input collection to have been obtained from one of - * the utility functions of this class in the first place. + *

    Most of these methods are using specialized collection implementations (possibly unmodifiable) + * for small collection sizes. No guarantee is made on the mutability of the collections returned + * from these functions, meaning, callers should always assume they are unmodifiable. Functions that + * take a collection parameter as input to produce a new one with a transformation require the input + * collection to have been obtained from one of the utility functions of this class in the first + * place. */ public class CollectionUtil { - /** - * Returns a set which contains the elements of the given - * set plus the given element. The returned set should be - * considered unmodifiable. - * - * @param set initial set, nullable - * @param t new element - * @param Type of elements - * @return A new set, or the same - */ - public static Set plus(Set set, T t) { - if (set == null || set.isEmpty()) { - return Set.of(t); - } else if (set.size() == 1) { - if (set.contains(t)) { - return set; - } - // make mutable - set = new LinkedHashSet<>(set); - } // else it's already mutable. - - set.add(t); + /** + * Returns a set which contains the elements of the given set plus the given element. The returned + * set should be considered unmodifiable. + * + * @param set initial set, nullable + * @param t new element + * @param Type of elements + * @return A new set, or the same + */ + public static Set plus(Set set, T t) { + if (set == null || set.isEmpty()) { + return Set.of(t); + } else if (set.size() == 1) { + if (set.contains(t)) { return set; + } + // make mutable + set = new LinkedHashSet<>(set); + } // else it's already mutable. + + set.add(t); + return set; + } + + public static Map plus(Map map, K k, V v) { + if (map == null || map.isEmpty()) { + return Collections.singletonMap(k, v); + } else if (map.size() == 1) { + Entry e = map.entrySet().iterator().next(); + if (e.getKey().equals(k)) { + return Map.of(k, v); + } + // make mutable + map = new LinkedHashMap<>(map); + } // else it's already mutable. + + map.put(k, v); + return map; + } + + /** + * Remove the given value from all the sets that are values in the given map. Use this if the + * values of the map (the sets) were build with {@link #plus(Set, Object)}. + * + *

    In {@link org.lflang.graph.DirectedGraph}, this is used to properly remove nodes from a + * graph. There, we use maps to represent edges, where a value in a map is a set of nodes adjacent + * to the key for that value. Hence, when a node is removed, it needs to be removed not just as a + * key, but it also needs to be removed from the neighbors sets of any other keys that may contain + * it. + * + * @param map A modifiable map + * @param valueToRemove Value to remove + */ + public static void removeFromValues(Map> map, V valueToRemove) { + mapValuesInPlace(map, set -> minus(set, valueToRemove)); + } + + /** + * Apply a transform to the values of the map. If the mapping function returns null, the entry is + * removed. + */ + private static void mapValuesInPlace(Map map, Function mapper) { + Iterator> iterator = map.entrySet().iterator(); + while (iterator.hasNext()) { + Entry e = iterator.next(); + V existing = e.getValue(); + V mapped = mapper.apply(existing); + if (mapped == null) { + iterator.remove(); + } else if (mapped != existing) { + e.setValue(mapped); + } } - - - public static Map plus(Map map, K k, V v) { - if (map == null || map.isEmpty()) { - return Collections.singletonMap(k, v); - } else if (map.size() == 1) { - Entry e = map.entrySet().iterator().next(); - if (e.getKey().equals(k)) { - return Map.of(k, v); - } - // make mutable - map = new LinkedHashMap<>(map); - } // else it's already mutable. - - map.put(k, v); - return map; + } + + /** + * Returns a set that contains the elements of the given set minus one element. An empty set is + * considered empty. + */ + public static Set minus(Set set, T eltToRemove) { + if (set instanceof LinkedHashSet) { + set.remove(eltToRemove); + return set; } - - /** - * Remove the given value from all the sets that are values - * in the given map. Use this if the values of the map (the - * sets) were build with {@link #plus(Set, Object)}. - *

    - * In {@link org.lflang.graph.DirectedGraph}, this is used - * to properly remove nodes from a graph. There, we use - * maps to represent edges, where a value in a map is a - * set of nodes adjacent to the key for that value. - * Hence, when a node is removed, it needs to be removed - * not just as a key, but it also needs to be removed - * from the neighbors sets of any other keys that may contain it. - * - * @param map A modifiable map - * @param valueToRemove Value to remove - */ - public static void removeFromValues(Map> map, V valueToRemove) { - mapValuesInPlace(map, set -> minus(set, valueToRemove)); + if (set == null || set.isEmpty()) { + return Collections.emptySet(); + } else if (set.size() == 1) { + return set.contains(eltToRemove) ? Collections.emptySet() : set; } - - - /** - * Apply a transform to the values of the map. If the mapping - * function returns null, the entry is removed. - */ - private static void mapValuesInPlace(Map map, Function mapper) { - Iterator> iterator = map.entrySet().iterator(); - while (iterator.hasNext()) { - Entry e = iterator.next(); - V existing = e.getValue(); - V mapped = mapper.apply(existing); - if (mapped == null) { - iterator.remove(); - } else if (mapped != existing) { - e.setValue(mapped); - } - } + throw new AssertionError("should be unreachable"); + } + + /** + * Returns a map that is identical to the original map, except the value for key {@code k} is + * transformed using the given function. The transformation function takes the key and current + * value (null if the key is not present) as inputs, and returns the new value to associate to the + * key (null if the mapping should be removed). + * + * @see Map#compute(Object, BiFunction) + */ + public static Map compute(Map map, K k, BiFunction computation) { + if (map == null || map.isEmpty()) { + return Collections.singletonMap(k, computation.apply(k, null)); + } else if (map.size() == 1) { + Entry e = map.entrySet().iterator().next(); + if (e.getKey().equals(k)) { + return Collections.singletonMap(k, computation.apply(k, e.getValue())); + } + // make mutable + map = new LinkedHashMap<>(map); + } // else it's already mutable. + + map.compute(k, computation); + return map; + } + + /** + * Returns a copy of the set. The returned set should be considered unmodifiable. + * + * @param set initial set, nullable + * @param Type of elements + * @return A new set, or the same + */ + public static Set copy(Set set) { + if (set == null || set.size() <= 1) { + return set; // it's unmodifiable + } else { + return new LinkedHashSet<>(set); } - - - /** - * Returns a set that contains the elements of the given - * set minus one element. An empty set is considered empty. - */ - public static Set minus(Set set, T eltToRemove) { - if (set instanceof LinkedHashSet) { - set.remove(eltToRemove); - return set; - } - - if (set == null || set.isEmpty()) { - return Collections.emptySet(); - } else if (set.size() == 1) { - return set.contains(eltToRemove) ? Collections.emptySet() : set; - } - throw new AssertionError("should be unreachable"); + } + + /** + * Returns an immutable Set that contains all argument values. Duplicate elements are removed + * without error (contrary to {@link Set#of()} and friends). + */ + @SafeVarargs + public static Set immutableSetOf(T first, T... rest) { + if (rest.length == 0) { + return Set.of(first); } - - - /** - * Returns a map that is identical to the original map, - * except the value for key {@code k} is transformed using - * the given function. The transformation function takes the - * key and current value (null if the key is not present) as inputs, - * and returns the new value to associate to the key (null if the mapping should be removed). - * - * @see Map#compute(Object, BiFunction) - */ - public static Map compute(Map map, K k, BiFunction computation) { - if (map == null || map.isEmpty()) { - return Collections.singletonMap(k, computation.apply(k, null)); - } else if (map.size() == 1) { - Entry e = map.entrySet().iterator().next(); - if (e.getKey().equals(k)) { - return Collections.singletonMap(k, computation.apply(k, e.getValue())); - } - // make mutable - map = new LinkedHashMap<>(map); - } // else it's already mutable. - - map.compute(k, computation); - return map; - } - - - /** - * Returns a copy of the set. The returned set should be - * considered unmodifiable. - * - * @param set initial set, nullable - * @param Type of elements - * @return A new set, or the same - */ - public static Set copy(Set set) { - if (set == null || set.size() <= 1) { - return set; // it's unmodifiable - } else { - return new LinkedHashSet<>(set); - } - } - - - /** - * Returns an immutable Set that contains all argument values. - * Duplicate elements are removed without error (contrary - * to {@link Set#of()} and friends). - */ - @SafeVarargs - public static Set immutableSetOf(T first, T... rest) { - if (rest.length == 0) { - return Set.of(first); - } - Set result = new LinkedHashSet<>(); - result.add(first); - result.addAll(Arrays.asList(rest)); - return result; - } - + Set result = new LinkedHashSet<>(); + result.add(first); + result.addAll(Arrays.asList(rest)); + return result; + } } diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/src/org/lflang/util/FileUtil.java index eb2550127e..e46a30d501 100644 --- a/org.lflang/src/org/lflang/util/FileUtil.java +++ b/org.lflang/src/org/lflang/util/FileUtil.java @@ -23,9 +23,7 @@ import java.util.jar.JarFile; import java.util.regex.Matcher; import java.util.regex.Pattern; -import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IWorkspaceRoot; @@ -35,890 +33,906 @@ import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.util.RuntimeIOException; - import org.lflang.ErrorReporter; import org.lflang.FileConfig; public class FileUtil { - /** - * Return the name of the file excluding its file extension. - * @param file A Path object - * @return The name of the file excluding its file extension. - */ - public static String nameWithoutExtension(Path file) { - String name = file.getFileName().toString(); - int idx = name.lastIndexOf('.'); - return idx < 0 ? name : name.substring(0, idx); - } - - /** - * Return the name of the file associated with the given resource, - * excluding its file extension. - * @param r Any {@code Resource}. - * @return The name of the file associated with the given resource, - * excluding its file extension. - * @throws IOException If the resource has an invalid URI. - */ - public static String nameWithoutExtension(Resource r) throws IOException { - return nameWithoutExtension(toPath(r)); - } - - /** - * Return a java.nio.Path object corresponding to the given URI. - * @throws IOException If the given URI is invalid. - */ - public static Path toPath(URI uri) throws IOException { - return Paths.get(toIPath(uri).toFile().getAbsolutePath()); - } - - /** - * Return a java.nio.Path object corresponding to the given Resource. - * @throws IOException If the given resource has an invalid URI. - */ - public static Path toPath(Resource resource) throws IOException { - return toPath(resource.getURI()); - } - - /** - * Return an org.eclipse.core.runtime.Path object corresponding to the - * given URI. - * @throws IOException If the given URI is invalid. - */ - public static IPath toIPath(URI uri) throws IOException { - if (uri.isPlatform()) { - IPath path = new org.eclipse.core.runtime.Path(uri.toPlatformString(true)); - if (path.segmentCount() == 1) { - return ResourcesPlugin.getWorkspace().getRoot().getProject(path.lastSegment()).getLocation(); - } else { - return ResourcesPlugin.getWorkspace().getRoot().getFile(path).getLocation(); - } - } else if (uri.isFile()) { - return new org.eclipse.core.runtime.Path(uri.toFileString()); - } else { - throw new IOException("Unrecognized file protocol in URI " + uri); - } - } - - /** - * Convert a given path to a unix-style string. - * - * This ensures that '/' is used instead of '\' as file separator. - */ - public static String toUnixString(Path path) { - return path.toString().replace('\\', '/'); - } - - /** - * Parse the string as file location and return it as URI. - * Supports URIs, plain file paths, and paths relative to a model. - * - * @param path the file location as string. - * @param resource the model resource this file should be resolved relatively. May be null. - * @return the (Java) URI or null if no file can be located. - */ - public static java.net.URI locateFile(String path, Resource resource) { - // Check if path is URL + /** + * Return the name of the file excluding its file extension. + * + * @param file A Path object + * @return The name of the file excluding its file extension. + */ + public static String nameWithoutExtension(Path file) { + String name = file.getFileName().toString(); + int idx = name.lastIndexOf('.'); + return idx < 0 ? name : name.substring(0, idx); + } + + /** + * Return the name of the file associated with the given resource, excluding its file extension. + * + * @param r Any {@code Resource}. + * @return The name of the file associated with the given resource, excluding its file extension. + * @throws IOException If the resource has an invalid URI. + */ + public static String nameWithoutExtension(Resource r) throws IOException { + return nameWithoutExtension(toPath(r)); + } + + /** + * Return a java.nio.Path object corresponding to the given URI. + * + * @throws IOException If the given URI is invalid. + */ + public static Path toPath(URI uri) throws IOException { + return Paths.get(toIPath(uri).toFile().getAbsolutePath()); + } + + /** + * Return a java.nio.Path object corresponding to the given Resource. + * + * @throws IOException If the given resource has an invalid URI. + */ + public static Path toPath(Resource resource) throws IOException { + return toPath(resource.getURI()); + } + + /** + * Return an org.eclipse.core.runtime.Path object corresponding to the given URI. + * + * @throws IOException If the given URI is invalid. + */ + public static IPath toIPath(URI uri) throws IOException { + if (uri.isPlatform()) { + IPath path = new org.eclipse.core.runtime.Path(uri.toPlatformString(true)); + if (path.segmentCount() == 1) { + return ResourcesPlugin.getWorkspace() + .getRoot() + .getProject(path.lastSegment()) + .getLocation(); + } else { + return ResourcesPlugin.getWorkspace().getRoot().getFile(path).getLocation(); + } + } else if (uri.isFile()) { + return new org.eclipse.core.runtime.Path(uri.toFileString()); + } else { + throw new IOException("Unrecognized file protocol in URI " + uri); + } + } + + /** + * Convert a given path to a unix-style string. + * + *

    This ensures that '/' is used instead of '\' as file separator. + */ + public static String toUnixString(Path path) { + return path.toString().replace('\\', '/'); + } + + /** + * Parse the string as file location and return it as URI. Supports URIs, plain file paths, and + * paths relative to a model. + * + * @param path the file location as string. + * @param resource the model resource this file should be resolved relatively. May be null. + * @return the (Java) URI or null if no file can be located. + */ + public static java.net.URI locateFile(String path, Resource resource) { + // Check if path is URL + try { + var uri = new java.net.URI(path); + if (uri.getScheme() != null) { // check if path was meant to be a URI + return uri; + } + } catch (Exception e) { + // nothing + } + // Check if path exists as it is + File file = new File(path); + if (file.exists()) { + try { + return file.toURI(); + } catch (Exception e) { + // nothing + } + } + // Check if path is relative to LF file + if (resource != null) { + URI eURI = resource.getURI(); + if (eURI != null) { + java.net.URI sourceURI = null; try { - var uri = new java.net.URI(path); - if(uri.getScheme() != null) { // check if path was meant to be a URI - return uri; - } + if (eURI.isFile()) { + sourceURI = new java.net.URI(eURI.toString()); + sourceURI = + new java.net.URI( + sourceURI.getScheme(), + null, + sourceURI.getPath().substring(0, sourceURI.getPath().lastIndexOf("/")), + null); + } else if (eURI.isPlatformResource()) { + IResource iFile = + ResourcesPlugin.getWorkspace().getRoot().findMember(eURI.toPlatformString(true)); + sourceURI = + iFile != null ? iFile.getRawLocation().toFile().getParentFile().toURI() : null; + } + if (sourceURI != null) { + return sourceURI.resolve(path); + } } catch (Exception e) { - // nothing - } - // Check if path exists as it is - File file = new File(path); - if (file.exists()) { - try { - return file.toURI(); - } catch (Exception e) { - // nothing - } - } - // Check if path is relative to LF file - if (resource != null) { - URI eURI = resource.getURI(); - if (eURI != null) { - java.net.URI sourceURI = null; - try { - if (eURI.isFile()) { - sourceURI = new java.net.URI(eURI.toString()); - sourceURI = new java.net.URI(sourceURI.getScheme(), null, - sourceURI.getPath().substring(0, sourceURI.getPath().lastIndexOf("/")), null); - } else if (eURI.isPlatformResource()) { - IResource iFile = ResourcesPlugin.getWorkspace().getRoot().findMember(eURI.toPlatformString(true)); - sourceURI = iFile != null ? iFile.getRawLocation().toFile().getParentFile().toURI() : null; - } - if (sourceURI != null) { - return sourceURI.resolve(path); - } - } catch (Exception e) { - // nothing - } + // nothing + } + } + } + // fail + return null; + } + + /** + * Recursively copy the contents of the given source directory into the given destination + * directory. Existing files of the destination may be overwritten. + * + * @param srcDir The source directory path. + * @param dstDir The destination directory path. + * @param skipIfUnchanged If true, don't overwrite anything in the destination if its content + * would not be changed. + * @throws IOException If the operation fails. + */ + public static void copyDirectoryContents( + final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + try (Stream stream = Files.walk(srcDir)) { + stream.forEach( + source -> { + // Handling checked exceptions in lambda expressions is + // hard. See + // https://www.baeldung.com/java-lambda-exceptions#handling-checked-exceptions. + // An alternative would be to create a custom Consumer interface and use that + // here. + if (Files.isRegularFile(source)) { // do not copy directories + try { + Path target = dstDir.resolve(srcDir.relativize(source)); + Files.createDirectories(target.getParent()); + copyFile(source, target, skipIfUnchanged); + } catch (IOException e) { + throw new RuntimeIOException(e); + } catch (Exception e) { + throw new RuntimeException(e); + } } - } - // fail + }); + } + } + + /** + * Copy the given source directory into the given destination directory. For example, if the + * source directory is {@code foo/bar} and the destination is {@code baz}, then copies of the + * contents of {@code foo/bar} will be located in {@code baz/bar}. + * + * @param srcDir The source directory path. + * @param dstDir The destination directory path. + * @param skipIfUnchanged If true, don't overwrite anything in the destination if its content + * would not be changed. + * @throws IOException If the operation fails. + */ + public static void copyDirectory( + final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + copyDirectoryContents(srcDir, dstDir.resolve(srcDir.getFileName()), skipIfUnchanged); + } + + /** + * Recursively copy the contents of the given source directory into the given destination + * directory. Existing files of the destination may be overwritten. + * + * @param srcDir The directory to copy files from. + * @param dstDir The directory to copy files to. + * @throws IOException if copy fails. + */ + public static void copyDirectoryContents(final Path srcDir, final Path dstDir) + throws IOException { + copyDirectoryContents(srcDir, dstDir, false); + } + + /** + * Copy a given source file to a given destination file. + * + *

    This also creates new directories on the path to {@code dstFile} that do not yet exist. + * + * @param srcFile The source file path. + * @param dstFile The destination file path. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not + * be changed. + * @throws IOException If the operation fails. + */ + public static void copyFile(Path srcFile, Path dstFile, boolean skipIfUnchanged) + throws IOException { + BufferedInputStream stream = new BufferedInputStream(new FileInputStream(srcFile.toFile())); + try (stream) { + copyInputStream(stream, dstFile, skipIfUnchanged); + } + } + + /** + * Copy a given source file to a given destination file. + * + *

    This also creates new directories for any directories on the path to {@code dstFile} that do + * not yet exist. + * + * @param srcFile The source file path. + * @param dstFile The destination file path. + * @throws IOException if copy fails. + */ + public static void copyFile(Path srcFile, Path dstFile) throws IOException { + copyFile(srcFile, dstFile, false); + } + + /** + * Find the given {@code file} in the package and return the path to the file that was found; null + * if it was not found. + * + * @param file The file to look for. + * @param dstDir The directory to copy it to. + * @param fileConfig The file configuration that specifies where look for the file. + * @return The path to the file that was found, or null if it was not found. + */ + public static Path findAndCopyFile(String file, Path dstDir, FileConfig fileConfig) { + var path = Paths.get(file); + var found = FileUtil.findInPackage(path, fileConfig); + if (found != null) { + try { + FileUtil.copyFile(found, dstDir.resolve(path.getFileName())); + return found; + } catch (IOException e) { return null; - } - - /** - * Recursively copy the contents of the given source directory into the given destination - * directory. Existing files of the destination may be overwritten. - * - * @param srcDir The source directory path. - * @param dstDir The destination directory path. - * @param skipIfUnchanged If true, don't overwrite anything in the destination if its content - * would not be changed. - * @throws IOException If the operation fails. - */ - public static void copyDirectoryContents(final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { - try (Stream stream = Files.walk(srcDir)) { - stream.forEach(source -> { - // Handling checked exceptions in lambda expressions is - // hard. See - // https://www.baeldung.com/java-lambda-exceptions#handling-checked-exceptions. - // An alternative would be to create a custom Consumer interface and use that - // here. - if (Files.isRegularFile(source)) { // do not copy directories - try { - Path target = dstDir.resolve(srcDir.relativize(source)); - Files.createDirectories(target.getParent()); - copyFile(source, target, skipIfUnchanged); - } catch (IOException e) { - throw new RuntimeIOException(e); - } catch (Exception e) { - throw new RuntimeException(e); - } - } - }); - } - } - - /** - * Copy the given source directory into the given destination directory. For example, if the - * source directory is {@code foo/bar} and the destination is {@code baz}, then copies of the - * contents of {@code foo/bar} will be located in {@code baz/bar}. - * @param srcDir The source directory path. - * @param dstDir The destination directory path. - * @param skipIfUnchanged If true, don't overwrite anything in the destination if its content - * would not be changed. - * @throws IOException If the operation fails. - */ - public static void copyDirectory( - final Path srcDir, final Path dstDir, final boolean skipIfUnchanged) throws IOException { - copyDirectoryContents(srcDir, dstDir.resolve(srcDir.getFileName()), skipIfUnchanged); - } - - /** - * Recursively copy the contents of the given source directory into the given destination - * directory. Existing files of the destination may be overwritten. - * - * @param srcDir The directory to copy files from. - * @param dstDir The directory to copy files to. - * @throws IOException if copy fails. - */ - public static void copyDirectoryContents(final Path srcDir, final Path dstDir) throws IOException { - copyDirectoryContents(srcDir, dstDir, false); - } - - /** - * Copy a given source file to a given destination file. - * - * This also creates new directories on the path to {@code dstFile} that do not yet exist. - * - * @param srcFile The source file path. - * @param dstFile The destination file path. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content - * would not be changed. - * @throws IOException If the operation fails. - */ - public static void copyFile(Path srcFile, Path dstFile, boolean skipIfUnchanged) throws IOException { - BufferedInputStream stream = new BufferedInputStream(new FileInputStream(srcFile.toFile())); - try (stream) { - copyInputStream(stream, dstFile, skipIfUnchanged); - } - } - - /** - * Copy a given source file to a given destination file. - * - * This also creates new directories for any directories - * on the path to {@code dstFile} that do not yet exist. - * - * @param srcFile The source file path. - * @param dstFile The destination file path. - * @throws IOException if copy fails. - */ - public static void copyFile(Path srcFile, Path dstFile) throws IOException { - copyFile(srcFile, dstFile, false); - } - - /** - * Find the given {@code file} in the package and return the path to the file that was found; null - * if it was not found. - * - * @param file The file to look for. - * @param dstDir The directory to copy it to. - * @param fileConfig The file configuration that specifies where look for the file. - * @return The path to the file that was found, or null if it was not found. - */ - public static Path findAndCopyFile( - String file, - Path dstDir, - FileConfig fileConfig - ) { - var path = Paths.get(file); - var found = FileUtil.findInPackage(path, fileConfig); - if (found != null) { - try { - FileUtil.copyFile(found, dstDir.resolve(path.getFileName())); - return found; - } catch (IOException e) { - return null; - } - } else { - return null; - } - } - - /** - * Given a list of files or directories, attempt to find each entry based on the given generator - * context and copy it to the destination directory. Entries are searched for in the file system - * first, relative to the source file and relative to the package root. Entries that cannot be - * found in the file system are looked for on the class path. - *

    - * If {@code contentsOnly} is true, then for each entry that is a directory, only its contents - * are copied, not the directory itself. - * For example, if the entry is a directory {@code foo/bar} and the destination is {@code baz}, - * then copies of the contents of {@code foo/bar} will be located directly in {@code baz}. - * If {@code contentsOnly} is false, then copies of the contents of {@code foo/bar} will be - * located in {@code baz/bar}. - * - * @param entries The files or directories to copy from. - * @param dstDir The location to copy the files to. - * @param fileConfig The file configuration that specifies where the find entries the given entries. - * @param errorReporter An error reporter to report problems. - */ - public static void copyFilesOrDirectories( - List entries, - Path dstDir, - FileConfig fileConfig, - ErrorReporter errorReporter, - boolean fileEntriesOnly - ) { - for (String fileOrDirectory : entries) { - var path = Paths.get(fileOrDirectory); - var found = FileUtil.findInPackage(path, fileConfig); - if (found != null) { - try { - if (fileEntriesOnly) { - FileUtil.copyFile(found, dstDir.resolve(path.getFileName())); - } else { - FileUtil.copyFromFileSystem(found, dstDir, false); - } - System.out.println("Copied '" + fileOrDirectory + "' from the file system."); - } catch (IOException e) { - errorReporter.reportError( - "Unable to copy '" + fileOrDirectory + "' from the file system. Reason: " + e.toString() - ); - } - } else { - try { - if (fileEntriesOnly) { - copyFileFromClassPath(fileOrDirectory, dstDir, false); - } else { - FileUtil.copyFromClassPath( - fileOrDirectory, - dstDir, - false, - false - ); - System.out.println("Copied '" + fileOrDirectory + "' from the class path."); - } - } catch(IOException e) { - errorReporter.reportError( - "Unable to copy '" + fileOrDirectory + "' from the class path. Reason: " + e.toString() - ); - } - } - } - } - - /** - * If the given {@code entry} is a file, then copy it into the destination. If the {@code entry} - * is a directory and {@code contentsOnly} is true, then copy its contents to the destination - * directory. If the {@code entry} is a directory and {@code contentsOnly} is true, then copy it - * including its contents to the destination directory. - * - * @param entry A file or directory to copy to the destination directory. - * @param dstDir A directory to copy the entry or its contents to. - * @param contentsOnly If true and {@code entry} is a directory, then copy its contents but not - * the directory itself. - * @throws IOException If the operation fails. - */ - public static void copyFromFileSystem(Path entry, Path dstDir, boolean contentsOnly) throws IOException { - if (Files.isDirectory(entry)) { - if (contentsOnly) { - copyDirectoryContents(entry, dstDir); - } else { - copyDirectory(entry, dstDir, false); - } - } else if (Files.isRegularFile(entry)) { - FileUtil.copyFile(entry, dstDir.resolve(entry.getFileName())); - } else { - throw new IllegalArgumentException("Source is neither a directory nor a regular file."); - } - } - /** - * Copy a given input stream to a destination file. - * - * This also creates new directories for any directories on the destination - * path that do not yet exist. - * - * @param source The source input stream. - * @param destination The destination file path. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content would - * not be changed. - * @throws IOException If the operation fails. - */ - private static void copyInputStream(InputStream source, Path destination, boolean skipIfUnchanged) throws IOException { - // Read the stream once and keep a copy of all bytes. This is required as a stream cannot be read twice. - final var bytes = source.readAllBytes(); - final var parent = destination.getParent(); - if (Files.isRegularFile(destination)) { - if (skipIfUnchanged) { - if (Arrays.equals(bytes, Files.readAllBytes(destination))) { - // Abort if the file contents are the same. - return; - } - } else { - // Delete the file exists but the contents don't match. - Files.delete(destination); - } - } else if (Files.isDirectory(destination)) { - deleteDirectory(destination); - } else if (!Files.exists(parent)) { - Files.createDirectories(parent); - } - - Files.write(destination, bytes); - } - - /** - * Look up the given {@code entry} in the classpath. If it is found and is a file, copy it into - * the destination directory. If the entry is not found or not a file, throw an exception. - * - * @param entry A file copy to the destination directory. - * @param dstDir A directory to copy the entry to. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content would - * not be changed. - * @throws IOException If the operation failed. - */ - public static void copyFileFromClassPath(final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { - final URL resource = FileConfig.class.getResource(entry); - - if (resource == null) { - throw new TargetResourceNotFoundException(entry); - } + } + } else { + return null; + } + } + + /** + * Given a list of files or directories, attempt to find each entry based on the given generator + * context and copy it to the destination directory. Entries are searched for in the file system + * first, relative to the source file and relative to the package root. Entries that cannot be + * found in the file system are looked for on the class path. + * + *

    If {@code contentsOnly} is true, then for each entry that is a directory, only its contents + * are copied, not the directory itself. For example, if the entry is a directory {@code foo/bar} + * and the destination is {@code baz}, then copies of the contents of {@code foo/bar} will be + * located directly in {@code baz}. If {@code contentsOnly} is false, then copies of the contents + * of {@code foo/bar} will be located in {@code baz/bar}. + * + * @param entries The files or directories to copy from. + * @param dstDir The location to copy the files to. + * @param fileConfig The file configuration that specifies where the find entries the given + * entries. + * @param errorReporter An error reporter to report problems. + */ + public static void copyFilesOrDirectories( + List entries, + Path dstDir, + FileConfig fileConfig, + ErrorReporter errorReporter, + boolean fileEntriesOnly) { + for (String fileOrDirectory : entries) { + var path = Paths.get(fileOrDirectory); + var found = FileUtil.findInPackage(path, fileConfig); + if (found != null) { + try { + if (fileEntriesOnly) { + FileUtil.copyFile(found, dstDir.resolve(path.getFileName())); + } else { + FileUtil.copyFromFileSystem(found, dstDir, false); + } + System.out.println("Copied '" + fileOrDirectory + "' from the file system."); + } catch (IOException e) { + errorReporter.reportError( + "Unable to copy '" + + fileOrDirectory + + "' from the file system. Reason: " + + e.toString()); + } + } else { + try { + if (fileEntriesOnly) { + copyFileFromClassPath(fileOrDirectory, dstDir, false); + } else { + FileUtil.copyFromClassPath(fileOrDirectory, dstDir, false, false); + System.out.println("Copied '" + fileOrDirectory + "' from the class path."); + } + } catch (IOException e) { + errorReporter.reportError( + "Unable to copy '" + + fileOrDirectory + + "' from the class path. Reason: " + + e.toString()); + } + } + } + } + + /** + * If the given {@code entry} is a file, then copy it into the destination. If the {@code entry} + * is a directory and {@code contentsOnly} is true, then copy its contents to the destination + * directory. If the {@code entry} is a directory and {@code contentsOnly} is true, then copy it + * including its contents to the destination directory. + * + * @param entry A file or directory to copy to the destination directory. + * @param dstDir A directory to copy the entry or its contents to. + * @param contentsOnly If true and {@code entry} is a directory, then copy its contents but not + * the directory itself. + * @throws IOException If the operation fails. + */ + public static void copyFromFileSystem(Path entry, Path dstDir, boolean contentsOnly) + throws IOException { + if (Files.isDirectory(entry)) { + if (contentsOnly) { + copyDirectoryContents(entry, dstDir); + } else { + copyDirectory(entry, dstDir, false); + } + } else if (Files.isRegularFile(entry)) { + FileUtil.copyFile(entry, dstDir.resolve(entry.getFileName())); + } else { + throw new IllegalArgumentException("Source is neither a directory nor a regular file."); + } + } + /** + * Copy a given input stream to a destination file. + * + *

    This also creates new directories for any directories on the destination path that do not + * yet exist. + * + * @param source The source input stream. + * @param destination The destination file path. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not + * be changed. + * @throws IOException If the operation fails. + */ + private static void copyInputStream(InputStream source, Path destination, boolean skipIfUnchanged) + throws IOException { + // Read the stream once and keep a copy of all bytes. This is required as a stream cannot be + // read twice. + final var bytes = source.readAllBytes(); + final var parent = destination.getParent(); + if (Files.isRegularFile(destination)) { + if (skipIfUnchanged) { + if (Arrays.equals(bytes, Files.readAllBytes(destination))) { + // Abort if the file contents are the same. + return; + } + } else { + // Delete the file exists but the contents don't match. + Files.delete(destination); + } + } else if (Files.isDirectory(destination)) { + deleteDirectory(destination); + } else if (!Files.exists(parent)) { + Files.createDirectories(parent); + } + + Files.write(destination, bytes); + } + + /** + * Look up the given {@code entry} in the classpath. If it is found and is a file, copy it into + * the destination directory. If the entry is not found or not a file, throw an exception. + * + * @param entry A file copy to the destination directory. + * @param dstDir A directory to copy the entry to. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not + * be changed. + * @throws IOException If the operation failed. + */ + public static void copyFileFromClassPath( + final String entry, final Path dstDir, final boolean skipIfUnchanged) throws IOException { + final URL resource = FileConfig.class.getResource(entry); + + if (resource == null) { + throw new TargetResourceNotFoundException(entry); + } + + final URLConnection connection = resource.openConnection(); + if (connection instanceof JarURLConnection) { + if (!copyFileFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged)) { + throw new IOException("'" + entry + "' is not a file"); + } + } else { + try { + Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); + copyFile(path, dstDir.resolve(path.getFileName()), skipIfUnchanged); + } catch (URISyntaxException e) { + // This should never happen as toFileURL should always return a valid URL + throw new IOException("Unexpected error while resolving " + entry + " on the classpath"); + } + } + } + + /** + * Look up the given {@code entry} in the classpath. If it is a file, copy it into the destination + * directory. If the {@code entry} is a directory and {@code contentsOnly} is true, then copy its + * contents to the destination directory. If the {@code entry} is a directory and {@code + * contentsOnly} is true, then copy it including its contents to the destination directory. + * + *

    This also creates new directories for any directories on the destination path that do not + * yet exist. + * + * @param entry The entry to be found on the class path and copied to the given destination. + * @param dstDir The file system path that found files are to be copied to. + * @param skipIfUnchanged If true, don't overwrite the file or directory if its content would not + * be changed + * @param contentsOnly If true and the entry is a directory, then copy its contents but not the + * directory itself. + * @throws IOException If the operation failed. + */ + public static void copyFromClassPath( + final String entry, + final Path dstDir, + final boolean skipIfUnchanged, + final boolean contentsOnly) + throws IOException { + final URL resource = FileConfig.class.getResource(entry); + + if (resource == null) { + throw new TargetResourceNotFoundException(entry); + } + + final URLConnection connection = resource.openConnection(); + if (connection instanceof JarURLConnection) { + boolean copiedFiles = + copyFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged, contentsOnly); + if (!copiedFiles) { + throw new TargetResourceNotFoundException(entry); + } + } else { + try { + Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); + if (path.toFile().isDirectory()) { + if (contentsOnly) { + copyDirectoryContents(path, dstDir, skipIfUnchanged); + } else { + copyDirectory(path, dstDir, skipIfUnchanged); + } - final URLConnection connection = resource.openConnection(); - if (connection instanceof JarURLConnection) { - if (!copyFileFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged)) { - throw new IOException("'" + entry + "' is not a file"); - } } else { - try { - Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); - copyFile(path, dstDir.resolve(path.getFileName()), skipIfUnchanged); - } catch(URISyntaxException e) { - // This should never happen as toFileURL should always return a valid URL - throw new IOException("Unexpected error while resolving " + entry + " on the classpath"); - } - } - } - - /** - * Look up the given {@code entry} in the classpath. If it is a file, copy it into the destination - * directory. - * If the {@code entry} is a directory and {@code contentsOnly} is true, then copy its contents - * to the destination directory. If the {@code entry} is a directory and {@code contentsOnly} is - * true, then copy it including its contents to the destination directory. - * - * This also creates new directories for any directories on the destination - * path that do not yet exist. - * - * @param entry The entry to be found on the class path and copied to the given destination. - * @param dstDir The file system path that found files are to be copied to. - * @param skipIfUnchanged If true, don't overwrite the file or directory if its content would not be changed - * @param contentsOnly If true and the entry is a directory, then copy its contents but not the directory itself. - * @throws IOException If the operation failed. - */ - public static void copyFromClassPath( - final String entry, - final Path dstDir, - final boolean skipIfUnchanged, - final boolean contentsOnly - ) throws IOException { - final URL resource = FileConfig.class.getResource(entry); - - if (resource == null) { - throw new TargetResourceNotFoundException(entry); - } - - final URLConnection connection = resource.openConnection(); - if (connection instanceof JarURLConnection) { - boolean copiedFiles = copyFromJar((JarURLConnection) connection, dstDir, skipIfUnchanged, contentsOnly); - if (!copiedFiles) { - throw new TargetResourceNotFoundException(entry); - } + copyFile(path, dstDir.resolve(path.getFileName()), skipIfUnchanged); + } + } catch (URISyntaxException e) { + // This should never happen as toFileURL should always return a valid URL + throw new IOException("Unexpected error while resolving " + entry + " on the classpath"); + } + } + } + + /** + * Return true if the given connection points to a file. + * + * @param connection A connection to a JAR file. + * @throws IOException If the connection is faulty. + */ + private static boolean isFileInJar(JarURLConnection connection) throws IOException { + return connection.getJarFile().stream() + .anyMatch(it -> it.getName().equals(connection.getEntryName())); + } + + /** + * Given a JAR file and a {@code srcFile} entry, copy it into the given destination directory. + * + * @param jar The JAR file from which to copy {@code srcFile}. + * @param srcFile The source file to copy from the given {@code jar}. + * @param dstDir The directory to top the source file into. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content would * not + * be changed. + * @throws IOException If the operation fails. + */ + private static void copyFileFromJar( + JarFile jar, String srcFile, Path dstDir, boolean skipIfUnchanged) throws IOException { + var entry = jar.getJarEntry(srcFile); + var filename = Paths.get(entry.getName()).getFileName(); + InputStream is = jar.getInputStream(entry); + try (is) { + copyInputStream(is, dstDir.resolve(filename), skipIfUnchanged); + } + } + + /** + * Copy the contents from an entry in a JAR to destination directory in the filesystem. The entry + * may be a file, in which case it will be copied under the same name into the destination + * directory. If the entry is a directory, then if {@code contentsOnly} is true, only the contents + * of the directory will be copied into the destination directory (not the directory itself). A + * directory will be copied as a whole, including its contents, if {@code contentsOnly} is false. + * + *

    This method should only be used in standalone mode (lfc). + * + *

    This also creates new directories for any directories on the destination path that do not + * yet exist. + * + * @param connection a URLConnection to the source entry within the jar + * @param dstDir The file system path that entries are copied to. + * @param skipIfUnchanged If true, don't overwrite the file if its content would not be changed. + * @param contentsOnly If true, and the connection points to a directory, copy its contents only + * (not the directory itself). + * @return true if any files were copied + * @throws IOException If the given source cannot be copied. + */ + private static boolean copyFromJar( + JarURLConnection connection, + Path dstDir, + final boolean skipIfUnchanged, + final boolean contentsOnly) + throws IOException { + + if (copyFileFromJar(connection, dstDir, skipIfUnchanged)) { + return true; + } + return copyDirectoryFromJar(connection, dstDir, skipIfUnchanged, contentsOnly); + } + + /** + * Given a connection to a JAR file that points to an entry that is a directory, recursively copy + * all entries located in that directory into the given {@code dstDir}. + * + *

    If {@code contentsOnly} is true, only the contents of the directory will be copied into the + * destination directory (not the directory itself). The directory will be copied as a whole, + * including its contents, if {@code contentsOnly} is false. + * + * @param connection A connection to a JAR file that points to a directory entry. + * @param dstDir The destination directory to copy the matching entries to. + * @param skipIfUnchanged + * @param contentsOnly + * @return + * @throws IOException + */ + private static boolean copyDirectoryFromJar( + JarURLConnection connection, + Path dstDir, + final boolean skipIfUnchanged, + final boolean contentsOnly) + throws IOException { + final JarFile jar = connection.getJarFile(); + final String source = connection.getEntryName(); + + boolean copiedFiles = false; + if (!contentsOnly) { + dstDir = dstDir.resolve(Paths.get(source).getFileName()); + } + // Iterate all entries in the jar file. + for (Enumeration e = jar.entries(); e.hasMoreElements(); ) { + final JarEntry entry = e.nextElement(); + final String entryName = entry.getName(); + if (entryName.startsWith(source)) { + String filename = entry.getName().substring(source.length() + 1); + Path currentFile = dstDir.resolve(filename); + if (entry.isDirectory()) { + Files.createDirectories(currentFile); } else { - try { - Path path = Paths.get(FileLocator.toFileURL(resource).toURI()); - if (path.toFile().isDirectory()) { - if (contentsOnly) { - copyDirectoryContents(path, dstDir, skipIfUnchanged); - } else { - copyDirectory(path, dstDir, skipIfUnchanged); - } - - } else { - copyFile(path, dstDir.resolve(path.getFileName()), skipIfUnchanged); - } - } catch(URISyntaxException e) { - // This should never happen as toFileURL should always return a valid URL - throw new IOException("Unexpected error while resolving " + entry + " on the classpath"); - } - } - } - - /** - * Return true if the given connection points to a file. - * @param connection A connection to a JAR file. - * @throws IOException If the connection is faulty. - */ - private static boolean isFileInJar(JarURLConnection connection) throws IOException { - return connection.getJarFile().stream().anyMatch( - it -> it.getName().equals(connection.getEntryName()) - ); - } - - /** - * Given a JAR file and a {@code srcFile} entry, copy it into the given destination directory. - * - * @param jar The JAR file from which to copy {@code srcFile}. - * @param srcFile The source file to copy from the given {@code jar}. - * @param dstDir The directory to top the source file into. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content would - * * not be changed. - * @throws IOException If the operation fails. - */ - private static void copyFileFromJar(JarFile jar, String srcFile, Path dstDir, boolean skipIfUnchanged) throws IOException { - var entry = jar.getJarEntry(srcFile); - var filename = Paths.get(entry.getName()).getFileName(); - InputStream is = jar.getInputStream(entry); - try (is) { - copyInputStream(is, dstDir.resolve(filename), skipIfUnchanged); - } - } - - /** - * Copy the contents from an entry in a JAR to destination directory in the filesystem. The entry - * may be a file, in which case it will be copied under the same name into the destination - * directory. If the entry is a directory, then if {@code contentsOnly} is true, only the - * contents of the directory will be copied into the destination directory (not the directory - * itself). A directory will be copied as a whole, including its contents, if - * {@code contentsOnly} is false. - * - * This method should only be used in standalone mode (lfc). - * - * This also creates new directories for any directories on - * the destination path that do not yet exist. - * - * @param connection a URLConnection to the source entry within the jar - * @param dstDir The file system path that entries are copied to. - * @param skipIfUnchanged If true, don't overwrite the file if its content would not be changed. - * @param contentsOnly If true, and the connection points to a directory, copy its contents only - * (not the directory itself). - * @return true if any files were copied - * @throws IOException If the given source cannot be copied. - */ - private static boolean copyFromJar( - JarURLConnection connection, - Path dstDir, - final boolean skipIfUnchanged, - final boolean contentsOnly - ) throws IOException { - - if (copyFileFromJar(connection, dstDir, skipIfUnchanged)) { - return true; - } - return copyDirectoryFromJar(connection, dstDir, skipIfUnchanged, contentsOnly); - } - - /** - * Given a connection to a JAR file that points to an entry that is a directory, recursively copy - * all entries located in that directory into the given {@code dstDir}. - *

    - * If {@code contentsOnly} is true, only the contents of the directory will be copied into the - * destination directory (not the directory itself). The directory will be copied as a whole, - * including its contents, if {@code contentsOnly} is false. - * @param connection A connection to a JAR file that points to a directory entry. - * @param dstDir The destination directory to copy the matching entries to. - * @param skipIfUnchanged - * @param contentsOnly - * @return - * @throws IOException - */ - private static boolean copyDirectoryFromJar(JarURLConnection connection, - Path dstDir, - final boolean skipIfUnchanged, - final boolean contentsOnly) throws IOException { - final JarFile jar = connection.getJarFile(); - final String source = connection.getEntryName(); - - boolean copiedFiles = false; - if (!contentsOnly) { - dstDir = dstDir.resolve(Paths.get(source).getFileName()); - } - // Iterate all entries in the jar file. - for (Enumeration e = jar.entries(); e.hasMoreElements(); ) { - final JarEntry entry = e.nextElement(); - final String entryName = entry.getName(); - if (entryName.startsWith(source)) { - String filename = entry.getName().substring(source.length() + 1); - Path currentFile = dstDir.resolve(filename); - if (entry.isDirectory()) { - Files.createDirectories(currentFile); - } else { - InputStream is = jar.getInputStream(entry); - try (is) { - copyInputStream(is, currentFile, skipIfUnchanged); - copiedFiles = true; - } - } - } - } - return copiedFiles; - } - - /** - * Given a connection to a JAR file that points to an entry that is a file, copy the file into the - * given {@code dstDir}. - * @param connection A connection to a JAR file that points to a directory entry. - * @param dstDir The destination directory to copy the file to. - * @param skipIfUnchanged - * @return {@code true} the connection entry is a file, and it was copied successfully; - * {@code false} if the connection entry is not a file and the copy operation was aborted. - * @throws IOException If the operation failed. - */ - private static boolean copyFileFromJar( - JarURLConnection connection, - Path dstDir, - final boolean skipIfUnchanged - ) throws IOException { - final JarFile jar = connection.getJarFile(); - final String source = connection.getEntryName(); - - if (!isFileInJar(connection)) { - return false; - } - copyFileFromJar(jar, source, dstDir, skipIfUnchanged); - - return true; - } - - /** - * Delete unused Files from Arduino-CLI based compilation. - * - * Arduino-CLI (the build system) uses lazy compilation (i.e. compiles every file recursively from - * a source directory). This does the work of CMake by explicitly deleting files that - * shouldn't get compiled by the CLI. Generally, we delete all CMake artifacts and multithreaded - * support files (including semaphores and thread folders) - * - * @param dir The folder to search for folders and files to delete. - * @throws IOException If the given folder and unneeded files cannot be deleted. - */ - public static void arduinoDeleteHelper(Path dir, boolean threadingOn) throws IOException { - deleteDirectory(dir.resolve("core/federated")); // TODO: Add Federated Support to Arduino - deleteDirectory(dir.resolve("include/core/federated")); // TODO: Add Federated Support to Arduino - - if (!threadingOn) { - deleteDirectory(dir.resolve("core/threaded")); // No Threaded Support for Arduino - deleteDirectory(dir.resolve("include/core/threaded")); // No Threaded Support for Arduino - deleteDirectory(dir.resolve("core/platform/arduino_mbed")); // No Threaded Support for Arduino - } - - List allPaths = Files.walk(dir) - .sorted(Comparator.reverseOrder()) - .toList(); - for (Path path : allPaths) { - String toCheck = path.toString().toLowerCase(); - if (toCheck.contains("cmake")) { - Files.delete(path); - } - } - } - - /** - * Helper function for getting the string representation of the relative path - * to take to get from one file (currPath) to get to the other (fileName). - * - * Generally, this is useful for converting includes to have relative pathing when - * you lack access to adding additional include paths when compiling. - * - * @param fileName File to search for. - * @param currPath The current path to the file whose include statements we are modifying. - * @param fileStringToFilePath Mapping of File Names to their paths. - */ - private static String fileNameMatchConverter(String fileName, Path currPath, Map fileStringToFilePath) - throws NullPointerException { - // First get the child file - int lastPath = fileName.lastIndexOf(File.separator); - if (lastPath != -1){ - fileName = fileName.substring(lastPath+1); - } - Path p = fileStringToFilePath.get(fileName); - if(p == null) { - return "#include \"" + fileName + "\""; - } - String relativePath = currPath.getParent().relativize(p).toString(); - return "#include \"" + relativePath + "\""; - } - - /** - * Return true if the given path points to a C file, false otherwise. - */ - public static boolean isCFile(Path path) { - String fileName = path.getFileName().toString(); - return fileName.endsWith(".c") || fileName.endsWith(".cpp") || fileName.endsWith(".h"); - } - - /** - * Convert all includes recursively inside files within a specified folder to relative links - * - * @param dir The folder to search for includes to change. - * @throws IOException If the given set of files cannot be relativized. - */ - public static void relativeIncludeHelper(Path dir, Path includePath) throws IOException { - System.out.println("Relativizing all includes in " + dir.toString()); - List includePaths = Files.walk(includePath) + InputStream is = jar.getInputStream(entry); + try (is) { + copyInputStream(is, currentFile, skipIfUnchanged); + copiedFiles = true; + } + } + } + } + return copiedFiles; + } + + /** + * Given a connection to a JAR file that points to an entry that is a file, copy the file into the + * given {@code dstDir}. + * + * @param connection A connection to a JAR file that points to a directory entry. + * @param dstDir The destination directory to copy the file to. + * @param skipIfUnchanged + * @return {@code true} the connection entry is a file, and it was copied successfully; {@code + * false} if the connection entry is not a file and the copy operation was aborted. + * @throws IOException If the operation failed. + */ + private static boolean copyFileFromJar( + JarURLConnection connection, Path dstDir, final boolean skipIfUnchanged) throws IOException { + final JarFile jar = connection.getJarFile(); + final String source = connection.getEntryName(); + + if (!isFileInJar(connection)) { + return false; + } + copyFileFromJar(jar, source, dstDir, skipIfUnchanged); + + return true; + } + + /** + * Delete unused Files from Arduino-CLI based compilation. + * + *

    Arduino-CLI (the build system) uses lazy compilation (i.e. compiles every file recursively + * from a source directory). This does the work of CMake by explicitly deleting files that + * shouldn't get compiled by the CLI. Generally, we delete all CMake artifacts and multithreaded + * support files (including semaphores and thread folders) + * + * @param dir The folder to search for folders and files to delete. + * @throws IOException If the given folder and unneeded files cannot be deleted. + */ + public static void arduinoDeleteHelper(Path dir, boolean threadingOn) throws IOException { + deleteDirectory(dir.resolve("core/federated")); // TODO: Add Federated Support to Arduino + deleteDirectory( + dir.resolve("include/core/federated")); // TODO: Add Federated Support to Arduino + + if (!threadingOn) { + deleteDirectory(dir.resolve("core/threaded")); // No Threaded Support for Arduino + deleteDirectory(dir.resolve("include/core/threaded")); // No Threaded Support for Arduino + deleteDirectory(dir.resolve("core/platform/arduino_mbed")); // No Threaded Support for Arduino + } + + List allPaths = Files.walk(dir).sorted(Comparator.reverseOrder()).toList(); + for (Path path : allPaths) { + String toCheck = path.toString().toLowerCase(); + if (toCheck.contains("cmake")) { + Files.delete(path); + } + } + } + + /** + * Helper function for getting the string representation of the relative path to take to get from + * one file (currPath) to get to the other (fileName). + * + *

    Generally, this is useful for converting includes to have relative pathing when you lack + * access to adding additional include paths when compiling. + * + * @param fileName File to search for. + * @param currPath The current path to the file whose include statements we are modifying. + * @param fileStringToFilePath Mapping of File Names to their paths. + */ + private static String fileNameMatchConverter( + String fileName, Path currPath, Map fileStringToFilePath) + throws NullPointerException { + // First get the child file + int lastPath = fileName.lastIndexOf(File.separator); + if (lastPath != -1) { + fileName = fileName.substring(lastPath + 1); + } + Path p = fileStringToFilePath.get(fileName); + if (p == null) { + return "#include \"" + fileName + "\""; + } + String relativePath = currPath.getParent().relativize(p).toString(); + return "#include \"" + relativePath + "\""; + } + + /** Return true if the given path points to a C file, false otherwise. */ + public static boolean isCFile(Path path) { + String fileName = path.getFileName().toString(); + return fileName.endsWith(".c") || fileName.endsWith(".cpp") || fileName.endsWith(".h"); + } + + /** + * Convert all includes recursively inside files within a specified folder to relative links + * + * @param dir The folder to search for includes to change. + * @throws IOException If the given set of files cannot be relativized. + */ + public static void relativeIncludeHelper(Path dir, Path includePath) throws IOException { + System.out.println("Relativizing all includes in " + dir.toString()); + List includePaths = + Files.walk(includePath) .filter(Files::isRegularFile) .filter(FileUtil::isCFile) .sorted(Comparator.reverseOrder()) .toList(); - List srcPaths = Files.walk(dir) + List srcPaths = + Files.walk(dir) .filter(Files::isRegularFile) .filter(FileUtil::isCFile) .sorted(Comparator.reverseOrder()) .toList(); - Map fileStringToFilePath = new HashMap(); - for (Path path : includePaths) { - String fileName = path.getFileName().toString(); - if (path.getFileName().toString().contains("CMakeLists.txt")) continue; - if (fileStringToFilePath.put(fileName, path) != null) { - throw new IOException("Directory has different files with the same name. Cannot Relativize."); - } - } - Pattern regexExpression = Pattern.compile("#include\s+[\"]([^\"]+)*[\"]"); - for (Path path : srcPaths) { - String fileContents = Files.readString(path); - Matcher matcher = regexExpression.matcher(fileContents); - int lastIndex = 0; - StringBuilder output = new StringBuilder(); - while (matcher.find()) { - output.append(fileContents, lastIndex, matcher.start()) - .append(fileNameMatchConverter(matcher.group(1), path, fileStringToFilePath)); - lastIndex = matcher.end(); - } - if (lastIndex < fileContents.length()) { - output.append(fileContents, lastIndex, fileContents.length()); - } - writeToFile(output.toString(), path); - } - } - - /** - * Delete the given file or directory if it exists. If {@code fileOrDirectory} is a directory, - * deletion is recursive. - * - * @param fileOrDirectory The file or directory to delete. - * @throws IOException If the operation failed. - */ - public static void delete(Path fileOrDirectory) throws IOException { - if (Files.isRegularFile(fileOrDirectory)) { - Files.deleteIfExists(fileOrDirectory); - } - if (Files.isDirectory(fileOrDirectory)) { - deleteDirectory(fileOrDirectory); - } - } - - /** - * Recursively delete a directory if it exists. - * - * @throws IOException If an I/O error occurs. - */ - public static void deleteDirectory(Path dir) throws IOException { - if (Files.isDirectory(dir)) { - System.out.println("Cleaning " + dir); - List pathsToDelete = Files.walk(dir) - .sorted(Comparator.reverseOrder()) - .toList(); - for (Path path : pathsToDelete) { - Files.deleteIfExists(path); - } - } - } - - /** - * Return an absolute path to the given file or directory if it can be found within the package. - * Otherwise, return null. - * - * NOTE: If the given file or directory is given as an absolute path but cannot be found, it is - * interpreted as a relative path with respect to the project root. - * - * @param fileOrDirectory The file or directory to look for. - * @param fileConfig A file configuration that determines where the package is located. - * @return An absolute path of the file or directory was found; null otherwise. - */ - public static Path findInPackage(Path fileOrDirectory, FileConfig fileConfig) { - if (fileOrDirectory.isAbsolute() && Files.exists(fileOrDirectory)) { - return fileOrDirectory; + Map fileStringToFilePath = new HashMap(); + for (Path path : includePaths) { + String fileName = path.getFileName().toString(); + if (path.getFileName().toString().contains("CMakeLists.txt")) continue; + if (fileStringToFilePath.put(fileName, path) != null) { + throw new IOException( + "Directory has different files with the same name. Cannot Relativize."); + } + } + Pattern regexExpression = Pattern.compile("#include\s+[\"]([^\"]+)*[\"]"); + for (Path path : srcPaths) { + String fileContents = Files.readString(path); + Matcher matcher = regexExpression.matcher(fileContents); + int lastIndex = 0; + StringBuilder output = new StringBuilder(); + while (matcher.find()) { + output + .append(fileContents, lastIndex, matcher.start()) + .append(fileNameMatchConverter(matcher.group(1), path, fileStringToFilePath)); + lastIndex = matcher.end(); + } + if (lastIndex < fileContents.length()) { + output.append(fileContents, lastIndex, fileContents.length()); + } + writeToFile(output.toString(), path); + } + } + + /** + * Delete the given file or directory if it exists. If {@code fileOrDirectory} is a directory, + * deletion is recursive. + * + * @param fileOrDirectory The file or directory to delete. + * @throws IOException If the operation failed. + */ + public static void delete(Path fileOrDirectory) throws IOException { + if (Files.isRegularFile(fileOrDirectory)) { + Files.deleteIfExists(fileOrDirectory); + } + if (Files.isDirectory(fileOrDirectory)) { + deleteDirectory(fileOrDirectory); + } + } + + /** + * Recursively delete a directory if it exists. + * + * @throws IOException If an I/O error occurs. + */ + public static void deleteDirectory(Path dir) throws IOException { + if (Files.isDirectory(dir)) { + System.out.println("Cleaning " + dir); + List pathsToDelete = Files.walk(dir).sorted(Comparator.reverseOrder()).toList(); + for (Path path : pathsToDelete) { + Files.deleteIfExists(path); + } + } + } + + /** + * Return an absolute path to the given file or directory if it can be found within the package. + * Otherwise, return null. + * + *

    NOTE: If the given file or directory is given as an absolute path but cannot be found, it is + * interpreted as a relative path with respect to the project root. + * + * @param fileOrDirectory The file or directory to look for. + * @param fileConfig A file configuration that determines where the package is located. + * @return An absolute path of the file or directory was found; null otherwise. + */ + public static Path findInPackage(Path fileOrDirectory, FileConfig fileConfig) { + if (fileOrDirectory.isAbsolute() && Files.exists(fileOrDirectory)) { + return fileOrDirectory; + } else { + Path relPath; + // Disregard root and interpret as relative path + if (fileOrDirectory.isAbsolute()) { + relPath = + Paths.get( + String.valueOf(fileOrDirectory) + .replaceFirst(String.valueOf(fileOrDirectory.getRoot()), "")); + } else { + relPath = fileOrDirectory; + } + + // Look relative to the source file and relative to the package root. + var locations = List.of(fileConfig.srcPath, fileConfig.srcPkgPath); + var found = locations.stream().filter(loc -> Files.exists(loc.resolve(relPath))).findFirst(); + if (found.isPresent()) { + return found.get().resolve(relPath).toAbsolutePath(); + } + } + return null; + } + + /** Get the iResource corresponding to the provided resource if it can be found. */ + public static IResource getIResource(Resource r) throws IOException { + return getIResource(FileUtil.toPath(r).toFile().toURI()); + } + + /** Get the specified path as an Eclipse IResource or null if it is not found. */ + public static IResource getIResource(Path path) { + IResource ret = getIResource(path.toUri()); + if (ret != null) return ret; + try { + // Handle a bug that not everyone can reproduce in which a path originating in the Ecore model + // is a relative + // path prefixed with a segment named "resource". + return ResourcesPlugin.getWorkspace() + .getRoot() + .findMember( + org.eclipse.core.runtime.Path.fromOSString( + path.subpath(1, path.getNameCount()).toString())); + } catch (IllegalStateException e) { + // We are outside of Eclipse. + } + return null; + } + + /** + * Get the specified uri as an Eclipse IResource or null if it is not found. + * + *

    Also returns null if this is not called from within a running Eclipse instance. + * + * @param uri A java.net.uri of the form "file://path". + */ + public static IResource getIResource(java.net.URI uri) { + // For some peculiar reason known only to Eclipse developers, + // the resource cannot be used directly but has to be converted + // a resource relative to the workspace root. + try { + IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); + + IFile[] files = workspaceRoot.findFilesForLocationURI(uri); + if (files != null && files.length > 0 && files[0] != null) { + return files[0]; + } + } catch (IllegalStateException e) { + // We are outside of Eclipse. + } + return null; + } + + /** + * Write text to a file. + * + * @param text The text to be written. + * @param path The file to write the code to. + * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not + * be changed + */ + public static void writeToFile(String text, Path path, boolean skipIfUnchanged) + throws IOException { + Files.createDirectories(path.getParent()); + final byte[] bytes = text.getBytes(); + if (skipIfUnchanged && Files.isRegularFile(path)) { + if (Arrays.equals(bytes, Files.readAllBytes(path))) { + return; + } + } + Files.write(path, text.getBytes()); + } + + /** + * Write text to a file. + * + * @param text The text to be written. + * @param path The file to write the code to. + */ + public static void writeToFile(String text, Path path) throws IOException { + writeToFile(text, path, false); + } + + /** + * Write text to a file. + * + * @param text The text to be written. + * @param path The file to write the code to. + */ + public static void writeToFile(CharSequence text, Path path) throws IOException { + writeToFile(text.toString(), path, false); + } + + public static void createDirectoryIfDoesNotExist(File dir) { + if (!dir.exists()) dir.mkdirs(); + } + + /** + * Return a list of files ending with "str". + * + * @param currentDir The current directory. + * @param str The pattern to match against. + */ + public static List globFilesEndsWith(Path currentDir, String str) { + List matches = new ArrayList<>(); + File[] files = currentDir.toFile().listFiles(); + if (files != null) { + for (File file : files) { + if (file.isDirectory()) { + matches.addAll(globFilesEndsWith(file.toPath(), str)); } else { - Path relPath; - // Disregard root and interpret as relative path - if (fileOrDirectory.isAbsolute()) { - relPath = Paths.get( - String.valueOf(fileOrDirectory).replaceFirst( - String.valueOf(fileOrDirectory.getRoot()), - "") - ); - } else { - relPath = fileOrDirectory; - } - - // Look relative to the source file and relative to the package root. - var locations = List.of(fileConfig.srcPath, fileConfig.srcPkgPath); - var found = locations.stream().filter( - loc -> Files.exists(loc.resolve(relPath)) - ).findFirst(); - if (found.isPresent()) { - return found.get().resolve(relPath).toAbsolutePath(); - } - } - return null; - } - - /** - * Get the iResource corresponding to the provided resource if it can be - * found. - */ - public static IResource getIResource(Resource r) throws IOException { - return getIResource(FileUtil.toPath(r).toFile().toURI()); - } - - /** - * Get the specified path as an Eclipse IResource or null if it is not found. - */ - public static IResource getIResource(Path path) { - IResource ret = getIResource(path.toUri()); - if (ret != null) return ret; - try { - // Handle a bug that not everyone can reproduce in which a path originating in the Ecore model is a relative - // path prefixed with a segment named "resource". - return ResourcesPlugin.getWorkspace().getRoot().findMember(org.eclipse.core.runtime.Path.fromOSString( - path.subpath(1, path.getNameCount()).toString() - )); - } catch (IllegalStateException e) { - // We are outside of Eclipse. - } - return null; - } - - /** - * Get the specified uri as an Eclipse IResource or null if it is not found. - * - * Also returns null if this is not called from within a running Eclipse instance. - * - * @param uri A java.net.uri of the form "file://path". - */ - public static IResource getIResource(java.net.URI uri) { - // For some peculiar reason known only to Eclipse developers, - // the resource cannot be used directly but has to be converted - // a resource relative to the workspace root. - try { - IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace().getRoot(); - - IFile[] files = workspaceRoot.findFilesForLocationURI(uri); - if (files != null && files.length > 0 && files[0] != null) { - return files[0]; - } - } catch (IllegalStateException e) { - // We are outside of Eclipse. - } - return null; - } - - /** - * Write text to a file. - * @param text The text to be written. - * @param path The file to write the code to. - * @param skipIfUnchanged If true, don't overwrite the destination file if its content would not be changed - */ - public static void writeToFile(String text, Path path, boolean skipIfUnchanged) throws IOException { - Files.createDirectories(path.getParent()); - final byte[] bytes = text.getBytes(); - if (skipIfUnchanged && Files.isRegularFile(path)) { - if (Arrays.equals(bytes, Files.readAllBytes(path))) { - return; - } - } - Files.write(path, text.getBytes()); - } - - /** - * Write text to a file. - * @param text The text to be written. - * @param path The file to write the code to. - */ - public static void writeToFile(String text, Path path) throws IOException { - writeToFile(text, path, false); - } - - /** - * Write text to a file. - * @param text The text to be written. - * @param path The file to write the code to. - */ - public static void writeToFile(CharSequence text, Path path) throws IOException { - writeToFile(text.toString(), path, false); - } - - public static void createDirectoryIfDoesNotExist(File dir) { - if (!dir.exists()) dir.mkdirs(); - } - - /** - * Return a list of files ending with "str". - * - * @param currentDir The current directory. - * @param str The pattern to match against. - */ - public static List globFilesEndsWith(Path currentDir, String str) { - List matches = new ArrayList<>(); - File[] files = currentDir.toFile().listFiles(); - if (files != null) { - for (File file : files) { - if (file.isDirectory()) { - matches.addAll(globFilesEndsWith(file.toPath(), str)); - } else { - if (file.getName().endsWith(str)) { - matches.add(file.getAbsoluteFile().toPath()); - } - } - } + if (file.getName().endsWith(str)) { + matches.add(file.getAbsoluteFile().toPath()); + } } - return matches; + } } + return matches; + } } diff --git a/org.lflang/src/org/lflang/util/IteratorUtil.java b/org.lflang/src/org/lflang/util/IteratorUtil.java index 37ddadf56d..559739ed00 100644 --- a/org.lflang/src/org/lflang/util/IteratorUtil.java +++ b/org.lflang/src/org/lflang/util/IteratorUtil.java @@ -4,8 +4,6 @@ import java.util.stream.Stream; import java.util.stream.StreamSupport; -import org.lflang.lf.Reactor; - /** * A utility class for Iterator. * @@ -14,55 +12,53 @@ */ public final class IteratorUtil { - private IteratorUtil() { - // Don't let anyone instantiate this class. - } + private IteratorUtil() { + // Don't let anyone instantiate this class. + } + + /** + * Turn an iterator into a sequential stream. + * + * @param iterator The iterator to create a sequential stream for. + * @return A stream. + */ + public static Stream asStream(Iterator iterator) { + return asStream(iterator, false); + } - /** - * Turn an iterator into a sequential stream. - * - * @param iterator The iterator to create a sequential stream for. - * @return A stream. - */ - public static Stream asStream(Iterator iterator) { - return asStream(iterator, false); - } + /** + * Given an iterator of type T, turn it into a stream containing only the instances of the given + * class of type S. + * + * @param The type of elements the iterator iterates over. + * @param The type of class to filter out instance of. + * @param iterator An iterator of type T. + * @param cls A given class of type S. + * @return A filtered stream that only has in it instances of the given class. + */ + public static Stream asFilteredStream(Iterator iterator, Class cls) { + return asStream(iterator, false).filter(cls::isInstance).map(cls::cast); + } - /** - * Given an iterator of type T, turn it into a stream containing only the - * instances of the given class of type S. - * - * @param The type of elements the iterator iterates over. - * @param The type of class to filter out instance of. - * @param iterator An iterator of type T. - * @param cls A given class of type S. - * @return A filtered stream that only has in it instances of the given - * class. - */ - public static Stream asFilteredStream(Iterator iterator, - Class cls) { - return asStream(iterator, false).filter(cls::isInstance).map(cls::cast); - } - - /** - * Turn an iterator into a sequential or parallel stream. - * - * @param iterator The iterator to create a stream for. - * @param parallel Whether or not the stream should be parallel. - * @return A stream. - */ - public static Stream asStream(Iterator iterator, boolean parallel) { - Iterable iterable = () -> iterator; - return StreamSupport.stream(iterable.spliterator(), parallel); - } + /** + * Turn an iterator into a sequential or parallel stream. + * + * @param iterator The iterator to create a stream for. + * @param parallel Whether or not the stream should be parallel. + * @return A stream. + */ + public static Stream asStream(Iterator iterator, boolean parallel) { + Iterable iterable = () -> iterator; + return StreamSupport.stream(iterable.spliterator(), parallel); + } - /** - * Function to get Iterable from Iterator. - * - * @param iterator The iterator to get an iterable from. - * @return An iterable. - */ - public static Iterable asIterable(Iterator iterator) { - return () -> iterator; - } + /** + * Function to get Iterable from Iterator. + * + * @param iterator The iterator to get an iterable from. + * @return An iterable. + */ + public static Iterable asIterable(Iterator iterator) { + return () -> iterator; + } } diff --git a/org.lflang/src/org/lflang/util/LFCommand.java b/org.lflang/src/org/lflang/util/LFCommand.java index 4f6927dcf0..4b4116f264 100644 --- a/org.lflang/src/org/lflang/util/LFCommand.java +++ b/org.lflang/src/org/lflang/util/LFCommand.java @@ -1,26 +1,26 @@ /************* - Copyright (c) 2019-2021 TU Dresden - Copyright (c) 2019-2021 UC Berkeley - - 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. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + * Copyright (c) 2019-2021 TU Dresden + * Copyright (c) 2019-2021 UC Berkeley + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. ***************/ package org.lflang.util; @@ -42,370 +42,353 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; - import org.eclipse.xtext.util.CancelIndicator; /** * An abstraction for an external command - *

    - * This is a wrapper around ProcessBuilder which allows for a more convenient usage in our code base. + * + *

    This is a wrapper around ProcessBuilder which allows for a more convenient usage in our code + * base. */ public class LFCommand { - /** - * The period with which the cancel indicator is - * checked and the output and error streams are - * forwarded. - */ - private static final int PERIOD_MILLISECONDS = 200; - /** - * The maximum amount of time to wait for the - * forwarding of output and error streams to finish. - */ - private static final int READ_TIMEOUT_MILLISECONDS = 1000; - - protected ProcessBuilder processBuilder; - protected boolean didRun = false; - protected ByteArrayOutputStream output = new ByteArrayOutputStream(); - protected ByteArrayOutputStream errors = new ByteArrayOutputStream(); - protected boolean quiet; - - - /** - * Construct an LFCommand that executes the command carried by {@code pb}. - */ - protected LFCommand(ProcessBuilder pb, boolean quiet) { - this.processBuilder = pb; - this.quiet = quiet; - } - - - /** - * Get the output collected during command execution - */ - public OutputStream getOutput() { return output; } - - - /** - * Get the error output collected during command execution - */ - public OutputStream getErrors() { return errors; } - - /** Get this command's program and arguments. */ - public List command() { return processBuilder.command(); } - - /** Get this command's working directory. */ - public File directory() { return processBuilder.directory(); } - - /** - * Get a String representation of the stored command - */ - public String toString() { return String.join(" ", processBuilder.command()); } - - - /** - * Collect as much output as possible from {@code in} without blocking, print it to - * {@code print} if not quiet, and store it in {@code store}. - */ - private void collectOutput(InputStream in, ByteArrayOutputStream store, PrintStream print) { - byte[] buffer = new byte[64]; - int len; - do { - try { - // This depends on in.available() being - // greater than zero if data is available - // (so that all data is collected) - // and upper-bounded by maximum number of - // bytes that can be read without blocking. - // Only the latter of these two conditions - // is guaranteed by the spec. - len = in.read(buffer, 0, Math.min(in.available(), buffer.length)); - if (len > 0) { - store.write(buffer, 0, len); - if (!quiet) print.write(buffer, 0, len); - } - } catch (IOException e) { - e.printStackTrace(); - break; - } - } while (len > 0); // Do not necessarily continue - // to EOF (len == -1) because a blocking read - // operation is hard to interrupt. - } - - /** - * Handle user cancellation if necessary, and handle any output from {@code process} - * otherwise. - * @param process a {@code Process} - * @param cancelIndicator a flag indicating whether a - * cancellation of {@code process} - * is requested - * directly to stderr and stdout). - */ - private void poll(Process process, CancelIndicator cancelIndicator) { - if (cancelIndicator != null && cancelIndicator.isCanceled()) { - process.descendants().forEach(ProcessHandle::destroyForcibly); - process.destroyForcibly(); - } else { - collectOutput(process.getInputStream(), output, System.out); - collectOutput(process.getErrorStream(), errors, System.err); + /** + * The period with which the cancel indicator is checked and the output and error streams are + * forwarded. + */ + private static final int PERIOD_MILLISECONDS = 200; + /** + * The maximum amount of time to wait for the forwarding of output and error streams to finish. + */ + private static final int READ_TIMEOUT_MILLISECONDS = 1000; + + protected ProcessBuilder processBuilder; + protected boolean didRun = false; + protected ByteArrayOutputStream output = new ByteArrayOutputStream(); + protected ByteArrayOutputStream errors = new ByteArrayOutputStream(); + protected boolean quiet; + + /** Construct an LFCommand that executes the command carried by {@code pb}. */ + protected LFCommand(ProcessBuilder pb, boolean quiet) { + this.processBuilder = pb; + this.quiet = quiet; + } + + /** Get the output collected during command execution */ + public OutputStream getOutput() { + return output; + } + + /** Get the error output collected during command execution */ + public OutputStream getErrors() { + return errors; + } + + /** Get this command's program and arguments. */ + public List command() { + return processBuilder.command(); + } + + /** Get this command's working directory. */ + public File directory() { + return processBuilder.directory(); + } + + /** Get a String representation of the stored command */ + public String toString() { + return String.join(" ", processBuilder.command()); + } + + /** + * Collect as much output as possible from {@code in} without blocking, print it to {@code print} + * if not quiet, and store it in {@code store}. + */ + private void collectOutput(InputStream in, ByteArrayOutputStream store, PrintStream print) { + byte[] buffer = new byte[64]; + int len; + do { + try { + // This depends on in.available() being + // greater than zero if data is available + // (so that all data is collected) + // and upper-bounded by maximum number of + // bytes that can be read without blocking. + // Only the latter of these two conditions + // is guaranteed by the spec. + len = in.read(buffer, 0, Math.min(in.available(), buffer.length)); + if (len > 0) { + store.write(buffer, 0, len); + if (!quiet) print.write(buffer, 0, len); } + } catch (IOException e) { + e.printStackTrace(); + break; + } + } while (len > 0); // Do not necessarily continue + // to EOF (len == -1) because a blocking read + // operation is hard to interrupt. + } + + /** + * Handle user cancellation if necessary, and handle any output from {@code process} otherwise. + * + * @param process a {@code Process} + * @param cancelIndicator a flag indicating whether a cancellation of {@code process} is requested + * directly to stderr and stdout). + */ + private void poll(Process process, CancelIndicator cancelIndicator) { + if (cancelIndicator != null && cancelIndicator.isCanceled()) { + process.descendants().forEach(ProcessHandle::destroyForcibly); + process.destroyForcibly(); + } else { + collectOutput(process.getInputStream(), output, System.out); + collectOutput(process.getErrorStream(), errors, System.err); } - - - /** - * Execute the command. - *

    - * Executing a process directly with {@code processBuilder.start()} could - * lead to a deadlock as the subprocess blocks when output or error - * buffers are full. This method ensures that output and error messages - * are continuously read and forwards them to the system output and - * error streams as well as to the output and error streams hold in - * this class. - *

    - *

    - * If the current operation is cancelled (as indicated - * by cancelIndicator), the subprocess - * is destroyed. Output and error streams until that - * point are still collected. - *

    - * - * @param cancelIndicator The indicator of whether the underlying process - * should be terminated. - * @return the process' return code - * @author Christian Menard - */ - public int run(CancelIndicator cancelIndicator) { - assert !didRun; - didRun = true; - - System.out.println("--- Current working directory: " + processBuilder.directory().toString()); - System.out.println("--- Executing command: " + String.join(" ", processBuilder.command())); - - final Process process = startProcess(); - if (process == null) return -1; - - ScheduledExecutorService poller = Executors.newSingleThreadScheduledExecutor(); - poller.scheduleAtFixedRate( - () -> poll(process, cancelIndicator), - 0, PERIOD_MILLISECONDS, TimeUnit.MILLISECONDS - ); - - try { - final int returnCode = process.waitFor(); - poller.shutdown(); - poller.awaitTermination(READ_TIMEOUT_MILLISECONDS, TimeUnit.MILLISECONDS); - // Finish collecting any remaining data - poll(process, cancelIndicator); - return returnCode; - } catch (InterruptedException e) { - e.printStackTrace(); - return -2; - } + } + + /** + * Execute the command. + * + *

    Executing a process directly with {@code processBuilder.start()} could lead to a deadlock as + * the subprocess blocks when output or error buffers are full. This method ensures that output + * and error messages are continuously read and forwards them to the system output and error + * streams as well as to the output and error streams hold in this class. + * + *

    If the current operation is cancelled (as indicated by cancelIndicator), the + * subprocess is destroyed. Output and error streams until that point are still collected. + * + * @param cancelIndicator The indicator of whether the underlying process should be terminated. + * @return the process' return code + * @author Christian Menard + */ + public int run(CancelIndicator cancelIndicator) { + assert !didRun; + didRun = true; + + System.out.println("--- Current working directory: " + processBuilder.directory().toString()); + System.out.println("--- Executing command: " + String.join(" ", processBuilder.command())); + + final Process process = startProcess(); + if (process == null) return -1; + + ScheduledExecutorService poller = Executors.newSingleThreadScheduledExecutor(); + poller.scheduleAtFixedRate( + () -> poll(process, cancelIndicator), 0, PERIOD_MILLISECONDS, TimeUnit.MILLISECONDS); + + try { + final int returnCode = process.waitFor(); + poller.shutdown(); + poller.awaitTermination(READ_TIMEOUT_MILLISECONDS, TimeUnit.MILLISECONDS); + // Finish collecting any remaining data + poll(process, cancelIndicator); + return returnCode; + } catch (InterruptedException e) { + e.printStackTrace(); + return -2; } - - /** - * Execute the command. Do not allow user cancellation. - * @return the process' return code - */ - public int run() { - return run(null); - } - - - /** - * Add the given variables and their values to the command's environment. - * - * @param variables A map of variable names and their values - */ - public void setEnvironmentVariables(Map variables) { - processBuilder.environment().putAll(variables); + } + + /** + * Execute the command. Do not allow user cancellation. + * + * @return the process' return code + */ + public int run() { + return run(null); + } + + /** + * Add the given variables and their values to the command's environment. + * + * @param variables A map of variable names and their values + */ + public void setEnvironmentVariables(Map variables) { + processBuilder.environment().putAll(variables); + } + + /** + * Add the given variable and its value to the command's environment. + * + * @param variableName name of the variable to add + * @param value the variable's value + */ + public void setEnvironmentVariable(String variableName, String value) { + processBuilder.environment().put(variableName, value); + } + + /** + * Replace the given variable and its value in the command's environment. + * + * @param variableName name of the variable to add + * @param value the variable's value + */ + public void replaceEnvironmentVariable(String variableName, String value) { + processBuilder.environment().remove(variableName); + processBuilder.environment().put(variableName, value); + } + + /** Require this to be quiet, overriding the verbosity specified at construction time. */ + public void setQuiet() { + quiet = true; + } + + /** + * Create a LFCommand instance from a given command and argument list in the current working + * directory. + * + * @see #get(String, List, boolean, Path) + */ + public static LFCommand get(final String cmd, final List args) { + return get(cmd, args, false, Paths.get("")); + } + + /** + * Create a LFCommand instance from a given command and argument list in the current working + * directory. + * + * @see #get(String, List, boolean, Path) + */ + public static LFCommand get(final String cmd, final List args, boolean quiet) { + return get(cmd, args, quiet, Paths.get("")); + } + + /** + * Create a LFCommand instance from a given command, an argument list and a directory. + * + *

    This will check first if the command can actually be found and executed. If the command is + * not found, null is returned. In order to find the command, different methods are applied in the + * following order: + * + *

    1. Check if the given command {@code cmd} is an executable file within {@code dir}. 2. If + * the above fails 'which ' (or 'where ' on Windows) is executed to see if the command + * is available on the PATH. 3. If both points above fail, a third attempt is started using bash + * to indirectly execute the command (see below for an explanation). + * + *

    A bit more context: If the command cannot be found directly, then a second attempt is made + * using a Bash shell with the --login option, which sources the user's ~/.bash_profile, + * ~/.bash_login, or ~/.bashrc (whichever is first found) before running the command. This helps + * to ensure that the user's PATH variable is set according to their usual environment, assuming + * that they use a bash shell. + * + *

    More information: Unfortunately, at least on a Mac if you are running within Eclipse, the + * PATH variable is extremely limited; supposedly, it is given by the default provided in + * /etc/paths, but at least on my machine, it does not even include directories in that file for + * some reason. One way to add a directory like /usr/local/bin to the path once-and-for-all is + * this: + * + *

    sudo launchctl config user path /usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin + * + *

    But asking users to do that is not ideal. Hence, we try a more hack-y approach of just + * trying to execute using a bash shell. Also note that while ProcessBuilder can be configured to + * use custom environment variables, these variables do not affect the command that is to be + * executed but merely the environment in which the command executes. + * + * @param cmd The command + * @param args A list of arguments to pass to the command + * @param quiet If true, the commands stdout and stderr will be suppressed + * @param dir The directory in which the command should be executed + * @return Returns an LFCommand if the given command could be found or null otherwise. + */ + public static LFCommand get(final String cmd, final List args, boolean quiet, Path dir) { + assert cmd != null && args != null && dir != null; + dir = dir.toAbsolutePath(); + + // a list containing the command as first element and then all arguments + List cmdList = new ArrayList<>(); + cmdList.add(cmd); + cmdList.addAll(args); + + ProcessBuilder builder = null; + + // First, see if the command is a local executable file + final File cmdFile = dir.resolve(cmd).toFile(); + if (cmdFile.exists() && cmdFile.canExecute()) { + builder = new ProcessBuilder(cmdList); + } else if (findCommand(cmd) != null) { + builder = new ProcessBuilder(cmdList); + } else if (checkIfCommandIsExecutableWithBash(cmd, dir)) { + builder = + new ProcessBuilder( + "bash", "--login", "-c", String.format("\"%s\"", String.join(" ", cmdList))); } - - /** - * Add the given variable and its value to the command's environment. - * - * @param variableName name of the variable to add - * @param value the variable's value - */ - public void setEnvironmentVariable(String variableName, String value) { - processBuilder.environment().put(variableName, value); - } - - /** - * Replace the given variable and its value in the command's environment. - * - * @param variableName name of the variable to add - * @param value the variable's value - */ - public void replaceEnvironmentVariable(String variableName, String value) { - processBuilder.environment().remove(variableName); - processBuilder.environment().put(variableName, value); + if (builder != null) { + builder.directory(dir.toFile()); + return new LFCommand(builder, quiet); } - /** - * Require this to be quiet, overriding the verbosity specified at construction time. - */ - public void setQuiet() { - quiet = true; + return null; + } + + /** + * Search for matches to the given command by following the PATH environment variable. + * + * @param command A command for which to search. + * @return The file locations of matches to the given command. + */ + private static List findCommand(final String command) { + final String whichCmd = System.getProperty("os.name").startsWith("Windows") ? "where" : "which"; + final ProcessBuilder whichBuilder = new ProcessBuilder(List.of(whichCmd, command)); + try { + Process p = whichBuilder.start(); + if (p.waitFor() != 0) return null; + return Arrays.stream(new String(p.getInputStream().readAllBytes()).split("\n")) + .map(String::strip) + .map(File::new) + .filter(File::canExecute) + .collect(Collectors.toList()); + } catch (InterruptedException | IOException e) { + e.printStackTrace(); + return null; } - - /** - * Create a LFCommand instance from a given command and argument list in the current working directory. - * - * @see #get(String, List, boolean, Path) - */ - public static LFCommand get(final String cmd, final List args) { - return get(cmd, args, false, Paths.get("")); + } + + /** + * Attempt to start the execution of this command. + * + *

    First collect a list of paths where the executable might be found, then select an executable + * that successfully executes from the list of paths. Return the {@code Process} instance that is + * the result of a successful execution, or {@code null} if no successful execution happened. + * + * @return The {@code Process} that is started by this command, or {@code null} in case of + * failure. + */ + private Process startProcess() { + ArrayDeque commands = new ArrayDeque<>(); + List matchesOnPath = findCommand(processBuilder.command().get(0)); + if (matchesOnPath != null) { + matchesOnPath.stream().map(File::toString).forEach(commands::addLast); } - - /** - * Create a LFCommand instance from a given command and argument list in the current working directory. - * - * @see #get(String, List, boolean, Path) - */ - public static LFCommand get(final String cmd, final List args, boolean quiet) { - return get(cmd, args, quiet, Paths.get("")); - } - - - /** - * Create a LFCommand instance from a given command, an argument list and a directory. - *

    - * This will check first if the command can actually be found and executed. If the command is not found, null is - * returned. In order to find the command, different methods are applied in the following order: - *

    - * 1. Check if the given command {@code cmd} is an executable file within {@code dir}. - * 2. If the above fails 'which ' (or 'where ' on Windows) is executed to see if the command is available - * on the PATH. - * 3. If both points above fail, a third attempt is started using bash to indirectly execute the command (see below - * for an explanation). - *

    - * A bit more context: - * If the command cannot be found directly, then a second attempt is made using a Bash shell with the --login - * option, which sources the user's ~/.bash_profile, ~/.bash_login, or ~/.bashrc (whichever is first found) before - * running the command. This helps to ensure that the user's PATH variable is set according to their usual - * environment, assuming that they use a bash shell. - *

    - * More information: Unfortunately, at least on a Mac if you are running within Eclipse, the PATH variable is - * extremely limited; supposedly, it is given by the default provided in /etc/paths, but at least on my machine, it - * does not even include directories in that file for some reason. One way to add a directory like /usr/local/bin - * to - * the path once-and-for-all is this: - *

    - * sudo launchctl config user path /usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin - *

    - * But asking users to do that is not ideal. Hence, we try a more hack-y approach of just trying to execute using a - * bash shell. Also note that while ProcessBuilder can be configured to use custom environment variables, these - * variables do not affect the command that is to be executed but merely the environment in which the command - * executes. - * - * @param cmd The command - * @param args A list of arguments to pass to the command - * @param quiet If true, the commands stdout and stderr will be suppressed - * @param dir The directory in which the command should be executed - * @return Returns an LFCommand if the given command could be found or null otherwise. - */ - public static LFCommand get(final String cmd, final List args, boolean quiet, Path dir) { - assert cmd != null && args != null && dir != null; - dir = dir.toAbsolutePath(); - - // a list containing the command as first element and then all arguments - List cmdList = new ArrayList<>(); - cmdList.add(cmd); - cmdList.addAll(args); - - ProcessBuilder builder = null; - - // First, see if the command is a local executable file - final File cmdFile = dir.resolve(cmd).toFile(); - if (cmdFile.exists() && cmdFile.canExecute()) { - builder = new ProcessBuilder(cmdList); - } else if (findCommand(cmd) != null) { - builder = new ProcessBuilder(cmdList); - } else if (checkIfCommandIsExecutableWithBash(cmd, dir)) { - builder = new ProcessBuilder("bash", "--login", "-c", String.format("\"%s\"", String.join(" ", cmdList))); - } - - if (builder != null) { - builder.directory(dir.toFile()); - return new LFCommand(builder, quiet); - } - - return null; - } - - - /** - * Search for matches to the given command by following the PATH environment variable. - * @param command A command for which to search. - * @return The file locations of matches to the given command. - */ - private static List findCommand(final String command) { - final String whichCmd = System.getProperty("os.name").startsWith("Windows") ? "where" : "which"; - final ProcessBuilder whichBuilder = new ProcessBuilder(List.of(whichCmd, command)); - try { - Process p = whichBuilder.start(); - if (p.waitFor() != 0) return null; - return Arrays.stream(new String(p.getInputStream().readAllBytes()).split("\n")) - .map(String::strip).map(File::new).filter(File::canExecute).collect(Collectors.toList()); - } catch (InterruptedException | IOException e) { - e.printStackTrace(); - return null; + while (true) { + try { + return processBuilder.start(); + } catch (IOException e) { + if (commands.isEmpty()) { + e.printStackTrace(); + return null; } + } + processBuilder.command().set(0, commands.removeFirst()); } + } - /** - * Attempt to start the execution of this command. - * - * First collect a list of paths where the executable might be found, - * then select an executable that successfully executes from the - * list of paths. Return the {@code Process} instance that is the - * result of a successful execution, or {@code null} if no successful - * execution happened. - * @return The {@code Process} that is started by this command, or {@code null} in case of failure. - */ - private Process startProcess() { - ArrayDeque commands = new ArrayDeque<>(); - List matchesOnPath = findCommand(processBuilder.command().get(0)); - if (matchesOnPath != null) { - matchesOnPath.stream().map(File::toString).forEach(commands::addLast); - } - while (true) { - try { - return processBuilder.start(); - } catch (IOException e) { - if (commands.isEmpty()) { - e.printStackTrace(); - return null; - } - } - processBuilder.command().set(0, commands.removeFirst()); - } + private static boolean checkIfCommandIsExecutableWithBash(final String command, final Path dir) { + // check first if bash is installed + if (findCommand("bash") == null) { + return false; } - - private static boolean checkIfCommandIsExecutableWithBash(final String command, final Path dir) { - // check first if bash is installed - if (findCommand("bash") == null) { - return false; - } - - // then try to find command with bash - final ProcessBuilder bashBuilder = new ProcessBuilder(List.of( - "bash", - "--login", - "-c", - String.format("\"which %s\"", command) - )); - bashBuilder.directory(dir.toFile()); - try { - int bashReturn = bashBuilder.start().waitFor(); - return bashReturn == 0; - } catch (InterruptedException | IOException e) { - e.printStackTrace(); - return false; - } + // then try to find command with bash + final ProcessBuilder bashBuilder = + new ProcessBuilder( + List.of("bash", "--login", "-c", String.format("\"which %s\"", command))); + bashBuilder.directory(dir.toFile()); + try { + int bashReturn = bashBuilder.start().waitFor(); + return bashReturn == 0; + } catch (InterruptedException | IOException e) { + e.printStackTrace(); + return false; } + } } diff --git a/org.lflang/src/org/lflang/util/StringUtil.java b/org.lflang/src/org/lflang/util/StringUtil.java index 31beef8a9b..516f340c06 100644 --- a/org.lflang/src/org/lflang/util/StringUtil.java +++ b/org.lflang/src/org/lflang/util/StringUtil.java @@ -36,137 +36,133 @@ */ public final class StringUtil { - /** - * Matches the boundary of a camel-case word. That's a zero-length match. - */ - private static final Pattern CAMEL_WORD_BOUNDARY = - Pattern.compile("(? !it.isEmpty()) - .map(it -> it.toLowerCase(Locale.ROOT)) - .collect(Collectors.joining("_")); - } + /** + * Convert a string in Camel case to snake case. E.g. {@code MinimalReactor} will be converted to + * {@code minimal_reactor}. The string is assumed to be a single camel case identifier (no + * whitespace). + */ + public static String camelToSnakeCase(String str) { + return CAMEL_WORD_BOUNDARY + .splitAsStream(str) + .filter(it -> !it.isEmpty()) + .map(it -> it.toLowerCase(Locale.ROOT)) + .collect(Collectors.joining("_")); + } - /** - * If the given string is surrounded by single or double - * quotes, returns what's inside the quotes. Otherwise - * returns the same string. - * - *

    Returns null if the parameter is null. - */ - public static String removeQuotes(String str) { - if (str == null) { - return null; - } - if (str.length() < 2) { - return str; - } - if (hasQuotes(str)) { - return str.substring(1, str.length() - 1); - } - return str; + /** + * If the given string is surrounded by single or double quotes, returns what's inside the quotes. + * Otherwise returns the same string. + * + *

    Returns null if the parameter is null. + */ + public static String removeQuotes(String str) { + if (str == null) { + return null; + } + if (str.length() < 2) { + return str; + } + if (hasQuotes(str)) { + return str.substring(1, str.length() - 1); } + return str; + } - /** - * Return true if the given string is surrounded by single or double - * quotes, - */ - public static boolean hasQuotes(String str) { - if (str == null) { - return false; - } - return str.startsWith("\"") && str.endsWith("\"") || str.startsWith("'") && str.endsWith("'"); + /** Return true if the given string is surrounded by single or double quotes, */ + public static boolean hasQuotes(String str) { + if (str == null) { + return false; } + return str.startsWith("\"") && str.endsWith("\"") || str.startsWith("'") && str.endsWith("'"); + } - /** - * Intelligently trim the white space in a code block. - * - * The leading whitespaces of the first non-empty - * code line is considered as a common prefix across all code lines. If the - * remaining code lines indeed start with this prefix, it removes the prefix - * from the code line. - * - * For examples, this code - * 

    {@code
-     *        int test = 4;
-     *        if (test == 42) {
-     *            printf("Hello\n");
-     *        }
-     * }
    - * will be trimmed to this: - * 
    {@code
-     * int test = 4;
-     * if (test == 42) {
-     *     printf("Hello\n");
-     * }
-     * }
    - * - * @param code the code block to be trimmed - * @param firstLineToConsider The first line not to ignore. - * @return trimmed code block - */ - public static String trimCodeBlock(String code, int firstLineToConsider) { - String[] codeLines = code.split("(\r\n?)|\n"); - int prefix = getWhitespacePrefix(code, firstLineToConsider); - StringBuilder buffer = new StringBuilder(); - boolean stillProcessingLeadingBlankLines = true; - for (int i = 0; i < firstLineToConsider; i++) { - var endIndex = codeLines[i].contains("//") ? - codeLines[i].indexOf("//") : codeLines[i].length(); - // The following will break Rust attributes in multiline code blocks - // where they appear next to the opening {= brace. - endIndex = codeLines[i].contains("#") ? - Math.min(endIndex, codeLines[i].indexOf("#")) : endIndex; - String toAppend = codeLines[i].substring(0, endIndex).strip(); - if (!toAppend.isBlank()) buffer.append(toAppend).append("\n"); - } - for (int i = firstLineToConsider; i < codeLines.length; i++) { - final String line = codeLines[i]; - if (!line.isBlank()) stillProcessingLeadingBlankLines = false; - if (stillProcessingLeadingBlankLines) continue; - if (!line.isBlank()) buffer.append(line.substring(prefix)); - buffer.append("\n"); - } - return buffer.toString().stripTrailing(); + /** + * Intelligently trim the white space in a code block. + * + *

    The leading whitespaces of the first non-empty code line is considered as a common prefix + * across all code lines. If the remaining code lines indeed start with this prefix, it removes + * the prefix from the code line. + * + *

    For examples, this code + * + * 

    {@code
+   * int test = 4;
+   * if (test == 42) {
+   *     printf("Hello\n");
+   * }
+   * }
    + * + * will be trimmed to this: + * + * 
    {@code
+   * int test = 4;
+   * if (test == 42) {
+   *     printf("Hello\n");
+   * }
+   * }
    + * + * @param code the code block to be trimmed + * @param firstLineToConsider The first line not to ignore. + * @return trimmed code block + */ + public static String trimCodeBlock(String code, int firstLineToConsider) { + String[] codeLines = code.split("(\r\n?)|\n"); + int prefix = getWhitespacePrefix(code, firstLineToConsider); + StringBuilder buffer = new StringBuilder(); + boolean stillProcessingLeadingBlankLines = true; + for (int i = 0; i < firstLineToConsider; i++) { + var endIndex = + codeLines[i].contains("//") ? codeLines[i].indexOf("//") : codeLines[i].length(); + // The following will break Rust attributes in multiline code blocks + // where they appear next to the opening {= brace. + endIndex = + codeLines[i].contains("#") ? Math.min(endIndex, codeLines[i].indexOf("#")) : endIndex; + String toAppend = codeLines[i].substring(0, endIndex).strip(); + if (!toAppend.isBlank()) buffer.append(toAppend).append("\n"); + } + for (int i = firstLineToConsider; i < codeLines.length; i++) { + final String line = codeLines[i]; + if (!line.isBlank()) stillProcessingLeadingBlankLines = false; + if (stillProcessingLeadingBlankLines) continue; + if (!line.isBlank()) buffer.append(line.substring(prefix)); + buffer.append("\n"); } + return buffer.toString().stripTrailing(); + } - private static int getWhitespacePrefix(String code, int firstLineToConsider) { - String[] codeLines = code.split("(\r\n?)|\n"); - int minLength = Integer.MAX_VALUE; - for (int j = firstLineToConsider; j < codeLines.length; j++) { - String line = codeLines[j]; - for (var i = 0; i < line.length(); i++) { - if (!Character.isWhitespace(line.charAt(i))) { - minLength = Math.min(minLength, i); - break; - } - } + private static int getWhitespacePrefix(String code, int firstLineToConsider) { + String[] codeLines = code.split("(\r\n?)|\n"); + int minLength = Integer.MAX_VALUE; + for (int j = firstLineToConsider; j < codeLines.length; j++) { + String line = codeLines[j]; + for (var i = 0; i < line.length(); i++) { + if (!Character.isWhitespace(line.charAt(i))) { + minLength = Math.min(minLength, i); + break; } - return minLength == Integer.MAX_VALUE ? 0 : minLength; + } } + return minLength == Integer.MAX_VALUE ? 0 : minLength; + } - public static String addDoubleQuotes(String str) { - return "\""+str+"\""; - } + public static String addDoubleQuotes(String str) { + return "\"" + str + "\""; + } - public static String joinObjects(List things, String delimiter) { - return things.stream().map(T::toString).collect(Collectors.joining(delimiter)); - } + public static String joinObjects(List things, String delimiter) { + return things.stream().map(T::toString).collect(Collectors.joining(delimiter)); + } - /** Normalize end-of-line sequences to the Linux style. */ - public static String normalizeEol(String s) { - return s.replaceAll("(\\r\\n?)|\\n", "\n"); - } + /** Normalize end-of-line sequences to the Linux style. */ + public static String normalizeEol(String s) { + return s.replaceAll("(\\r\\n?)|\\n", "\n"); + } } diff --git a/org.lflang/src/org/lflang/util/TargetResourceNotFoundException.java b/org.lflang/src/org/lflang/util/TargetResourceNotFoundException.java index dfcc1d671a..acc55fb0f3 100644 --- a/org.lflang/src/org/lflang/util/TargetResourceNotFoundException.java +++ b/org.lflang/src/org/lflang/util/TargetResourceNotFoundException.java @@ -3,12 +3,15 @@ import java.io.IOException; public class TargetResourceNotFoundException extends IOException { - public TargetResourceNotFoundException(String resourcePath) { - super(String.format(""" + public TargetResourceNotFoundException(String resourcePath) { + super( + String.format( + """ A required resource could not be found on the classpath or is an empty directory: %s Perhaps a git submodule is missing or not up to date. Try running 'git submodule update --init --recursive' and rebuild. - Also see https://www.lf-lang.org/docs/handbook/developer-setup. - """, resourcePath)); - } + Also see https://www.lf-lang.org/docs/handbook/developer-setup. + """, + resourcePath)); + } } diff --git a/org.lflang/src/org/lflang/validation/AttributeSpec.java b/org.lflang/src/org/lflang/validation/AttributeSpec.java index 48b10a140a..45c984204e 100644 --- a/org.lflang/src/org/lflang/validation/AttributeSpec.java +++ b/org.lflang/src/org/lflang/validation/AttributeSpec.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2019-2022, The University of California at Berkeley. - + * * 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. - + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -31,7 +31,6 @@ import java.util.Map; import java.util.Set; import java.util.stream.Collectors; - import org.lflang.ast.ASTUtils; import org.lflang.lf.AttrParm; import org.lflang.lf.Attribute; @@ -40,191 +39,189 @@ /** * Specification of the structure of an attribute annotation. + * * @author Clément Fournier * @author Shaokai Lin */ public class AttributeSpec { - private final Map paramSpecByName; + private final Map paramSpecByName; - public static final String VALUE_ATTR = "value"; - public static final String NETWORK_MESSAGE_ACTIONS = "network_message_actions"; - public static final String EACH_ATTR = "each"; + public static final String VALUE_ATTR = "value"; + public static final String NETWORK_MESSAGE_ACTIONS = "network_message_actions"; + public static final String EACH_ATTR = "each"; - /** A map from a string to a supported AttributeSpec */ - public static final Map ATTRIBUTE_SPECS_BY_NAME = new HashMap<>(); + /** A map from a string to a supported AttributeSpec */ + public static final Map ATTRIBUTE_SPECS_BY_NAME = new HashMap<>(); - public AttributeSpec(List params) { - if (params != null) { - paramSpecByName = params.stream().collect(Collectors.toMap(it -> it.name, it -> it)); - } else { - paramSpecByName = null; - } + public AttributeSpec(List params) { + if (params != null) { + paramSpecByName = params.stream().collect(Collectors.toMap(it -> it.name, it -> it)); + } else { + paramSpecByName = null; + } + } + + /** Check that the attribute conforms to this spec and whether attr has the correct name. */ + public void check(LFValidator validator, Attribute attr) { + Set seen; + // If there is just one parameter, it is required to be named "value". + if (attr.getAttrParms() != null + && attr.getAttrParms().size() == 1 + && attr.getAttrParms().get(0).getName() == null) { + // If we are in this branch, + // then the user has provided @attr("value"), + // which is a shorthand for @attr(value="value"). + if (paramSpecByName == null) { + validator.error("Attribute doesn't take a parameter.", Literals.ATTRIBUTE__ATTR_NAME); + return; + } + AttrParamSpec valueSpec = paramSpecByName.get(VALUE_ATTR); + if (valueSpec == null) { + validator.error("Attribute doesn't have a 'value' parameter.", Literals.ATTR_PARM__NAME); + return; + } + + valueSpec.check(validator, attr.getAttrParms().get(0)); + seen = Set.of(VALUE_ATTR); + } else { + // Process multiple parameters, each of which has to be named. + seen = processNamedAttrParms(validator, attr); } - /** - * Check that the attribute conforms to this spec and whether - * attr has the correct name. - */ - public void check(LFValidator validator, Attribute attr) { - Set seen; - // If there is just one parameter, it is required to be named "value". - if (attr.getAttrParms() != null - && attr.getAttrParms().size() == 1 - && attr.getAttrParms().get(0).getName() == null) { - // If we are in this branch, - // then the user has provided @attr("value"), - // which is a shorthand for @attr(value="value"). - if (paramSpecByName == null) { - validator.error("Attribute doesn't take a parameter.", Literals.ATTRIBUTE__ATTR_NAME); - return; + // Check if there are any missing parameters required by this attribute. + if (paramSpecByName != null) { + Map missingParams = new HashMap<>(paramSpecByName); + missingParams.keySet().removeAll(seen); + missingParams.forEach( + (name, paramSpec) -> { + if (!paramSpec.isOptional) { + validator.error( + "Missing required attribute parameter '" + name + "'.", + Literals.ATTRIBUTE__ATTR_PARMS); } - AttrParamSpec valueSpec = paramSpecByName.get(VALUE_ATTR); - if (valueSpec == null) { - validator.error("Attribute doesn't have a 'value' parameter.", Literals.ATTR_PARM__NAME); - return; - } - - valueSpec.check(validator, attr.getAttrParms().get(0)); - seen = Set.of(VALUE_ATTR); - } else { - // Process multiple parameters, each of which has to be named. - seen = processNamedAttrParms(validator, attr); + }); + } + } + + /** + * Check whether the attribute parameters are named, whether these names are known, and whether + * the named parameters conform to the param spec (whether the param has the right type, etc.). + * + * @param validator The current validator in use. + * @param attr The attribute being checked. + * @return A set of named attribute parameters the user provides. + */ + private Set processNamedAttrParms(LFValidator validator, Attribute attr) { + Set seen = new HashSet<>(); + if (attr.getAttrParms() != null) { + for (AttrParm parm : attr.getAttrParms()) { + if (paramSpecByName == null) { + validator.error("Attribute does not take parameters.", Literals.ATTRIBUTE__ATTR_NAME); + break; } - - // Check if there are any missing parameters required by this attribute. - if (paramSpecByName != null) { - Map missingParams = new HashMap<>(paramSpecByName); - missingParams.keySet().removeAll(seen); - missingParams.forEach((name, paramSpec) -> { - if (!paramSpec.isOptional) { - validator.error("Missing required attribute parameter '" + name + "'.", Literals.ATTRIBUTE__ATTR_PARMS); - } - }); + if (parm.getName() == null) { + validator.error("Missing name for attribute parameter.", Literals.ATTRIBUTE__ATTR_NAME); + continue; } - } - /** - * Check whether the attribute parameters are named, whether - * these names are known, and whether the named parameters - * conform to the param spec (whether the param has the - * right type, etc.). - * - * @param validator The current validator in use. - * @param attr The attribute being checked. - * @return A set of named attribute parameters the user provides. - */ - private Set processNamedAttrParms(LFValidator validator, Attribute attr) { - Set seen = new HashSet<>(); - if (attr.getAttrParms() != null) { - for (AttrParm parm : attr.getAttrParms()) { - if (paramSpecByName == null) { - validator.error("Attribute does not take parameters.", Literals.ATTRIBUTE__ATTR_NAME); - break; - } - if (parm.getName() == null) { - validator.error("Missing name for attribute parameter.", Literals.ATTRIBUTE__ATTR_NAME); - continue; - } - - AttrParamSpec parmSpec = paramSpecByName.get(parm.getName()); - if (parmSpec == null) { - validator.error("\"" + parm.getName() + "\"" + " is an unknown attribute parameter.", - Literals.ATTRIBUTE__ATTR_NAME); - continue; - } - // Check whether a parameter conforms to its spec. - parmSpec.check(validator, parm); - seen.add(parm.getName()); - } + AttrParamSpec parmSpec = paramSpecByName.get(parm.getName()); + if (parmSpec == null) { + validator.error( + "\"" + parm.getName() + "\"" + " is an unknown attribute parameter.", + Literals.ATTRIBUTE__ATTR_NAME); + continue; } - return seen; + // Check whether a parameter conforms to its spec. + parmSpec.check(validator, parm); + seen.add(parm.getName()); + } } - - /** - * The specification of the attribute parameter. - * - * @param name The name of the attribute parameter - * @param type The type of the parameter - * @param isOptional True if the parameter is optional. - */ - record AttrParamSpec(String name, AttrParamType type, boolean isOptional) { - - // Check if a parameter has the right type. - // Currently, only String, Int, Boolean, Float, and target language are supported. - public void check(LFValidator validator, AttrParm parm) { - switch (type) { - case STRING -> { - if (!StringUtil.hasQuotes(parm.getValue())) { - validator.error("Incorrect type: \"" + parm.getName() + "\"" - + " should have type String.", - Literals.ATTRIBUTE__ATTR_NAME); - } - } - case INT -> { - if (!ASTUtils.isInteger(parm.getValue())) { - validator.error( - "Incorrect type: \"" + parm.getName() + "\"" - + " should have type Int.", - Literals.ATTRIBUTE__ATTR_NAME); - } - } - case BOOLEAN -> { - if (!ASTUtils.isBoolean(parm.getValue())) { - validator.error( - "Incorrect type: \"" + parm.getName() + "\"" - + " should have type Boolean.", - Literals.ATTRIBUTE__ATTR_NAME); - } - } - case FLOAT -> { - if (!ASTUtils.isFloat(parm.getValue())) { - validator.error( - "Incorrect type: \"" + parm.getName() + "\"" - + " should have type Float.", - Literals.ATTRIBUTE__ATTR_NAME); - } - } - default -> throw new IllegalArgumentException("unexpected type"); - } + return seen; + } + + /** + * The specification of the attribute parameter. + * + * @param name The name of the attribute parameter + * @param type The type of the parameter + * @param isOptional True if the parameter is optional. + */ + record AttrParamSpec(String name, AttrParamType type, boolean isOptional) { + + // Check if a parameter has the right type. + // Currently, only String, Int, Boolean, Float, and target language are supported. + public void check(LFValidator validator, AttrParm parm) { + switch (type) { + case STRING -> { + if (!StringUtil.hasQuotes(parm.getValue())) { + validator.error( + "Incorrect type: \"" + parm.getName() + "\"" + " should have type String.", + Literals.ATTRIBUTE__ATTR_NAME); + } } + case INT -> { + if (!ASTUtils.isInteger(parm.getValue())) { + validator.error( + "Incorrect type: \"" + parm.getName() + "\"" + " should have type Int.", + Literals.ATTRIBUTE__ATTR_NAME); + } + } + case BOOLEAN -> { + if (!ASTUtils.isBoolean(parm.getValue())) { + validator.error( + "Incorrect type: \"" + parm.getName() + "\"" + " should have type Boolean.", + Literals.ATTRIBUTE__ATTR_NAME); + } + } + case FLOAT -> { + if (!ASTUtils.isFloat(parm.getValue())) { + validator.error( + "Incorrect type: \"" + parm.getName() + "\"" + " should have type Float.", + Literals.ATTRIBUTE__ATTR_NAME); + } + } + default -> throw new IllegalArgumentException("unexpected type"); + } } - - /** - * The type of attribute parameters currently supported. - */ - enum AttrParamType { - STRING, - INT, - BOOLEAN, - FLOAT, - } - - /* - * The specs of the known annotations are declared here. - * Note: If an attribute only has one parameter, the parameter name should be "value." - */ - static { - // @label("value") - ATTRIBUTE_SPECS_BY_NAME.put("label", new AttributeSpec( - List.of(new AttrParamSpec(VALUE_ATTR, AttrParamType.STRING, false)) - )); - // @sparse - ATTRIBUTE_SPECS_BY_NAME.put("sparse", new AttributeSpec(null)); - // @icon("value") - ATTRIBUTE_SPECS_BY_NAME.put("icon", new AttributeSpec( - List.of(new AttrParamSpec(VALUE_ATTR, AttrParamType.STRING, false)) - )); - // @enclave(each=boolean) - ATTRIBUTE_SPECS_BY_NAME.put("enclave", new AttributeSpec( - List.of(new AttrParamSpec(EACH_ATTR, AttrParamType.BOOLEAN, true)) - )); - - // attributes that are used internally only by the federated code generation - ATTRIBUTE_SPECS_BY_NAME.put("_unordered", new AttributeSpec(null)); - ATTRIBUTE_SPECS_BY_NAME.put("_fed_config", new AttributeSpec( - List.of(new AttrParamSpec(AttributeSpec.NETWORK_MESSAGE_ACTIONS, - AttrParamType.STRING, false)))); - ATTRIBUTE_SPECS_BY_NAME.put("_c_body", new AttributeSpec(null)); - } + } + + /** The type of attribute parameters currently supported. */ + enum AttrParamType { + STRING, + INT, + BOOLEAN, + FLOAT, + } + + /* + * The specs of the known annotations are declared here. + * Note: If an attribute only has one parameter, the parameter name should be "value." + */ + static { + // @label("value") + ATTRIBUTE_SPECS_BY_NAME.put( + "label", + new AttributeSpec(List.of(new AttrParamSpec(VALUE_ATTR, AttrParamType.STRING, false)))); + // @sparse + ATTRIBUTE_SPECS_BY_NAME.put("sparse", new AttributeSpec(null)); + // @icon("value") + ATTRIBUTE_SPECS_BY_NAME.put( + "icon", + new AttributeSpec(List.of(new AttrParamSpec(VALUE_ATTR, AttrParamType.STRING, false)))); + // @enclave(each=boolean) + ATTRIBUTE_SPECS_BY_NAME.put( + "enclave", + new AttributeSpec(List.of(new AttrParamSpec(EACH_ATTR, AttrParamType.BOOLEAN, true)))); + + // attributes that are used internally only by the federated code generation + ATTRIBUTE_SPECS_BY_NAME.put("_unordered", new AttributeSpec(null)); + ATTRIBUTE_SPECS_BY_NAME.put( + "_fed_config", + new AttributeSpec( + List.of( + new AttrParamSpec( + AttributeSpec.NETWORK_MESSAGE_ACTIONS, AttrParamType.STRING, false)))); + ATTRIBUTE_SPECS_BY_NAME.put("_c_body", new AttributeSpec(null)); + } } diff --git a/org.lflang/src/org/lflang/validation/BaseLFValidator.java b/org.lflang/src/org/lflang/validation/BaseLFValidator.java index 34e184a720..bcdc14dd94 100644 --- a/org.lflang/src/org/lflang/validation/BaseLFValidator.java +++ b/org.lflang/src/org/lflang/validation/BaseLFValidator.java @@ -28,55 +28,53 @@ import java.lang.reflect.Method; import java.util.Map; - import org.eclipse.emf.common.util.DiagnosticChain; import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.validation.Check; import org.eclipse.xtext.validation.CheckMode; import org.eclipse.xtext.validation.CheckType; -import org.lflang.ast.ASTUtils; import org.lflang.TimeUnit; +import org.lflang.ast.ASTUtils; import org.lflang.lf.LfPackage.Literals; import org.lflang.lf.Time; public class BaseLFValidator extends AbstractLFValidator { - @Check(CheckType.FAST) - public void checkTime(Time time) { - if (!ASTUtils.isValidTime(time)) { - error("Invalid time unit. " + - "Should be one of " + - TimeUnit.list() + ".", Literals.TIME__UNIT); - } + @Check(CheckType.FAST) + public void checkTime(Time time) { + if (!ASTUtils.isValidTime(time)) { + error( + "Invalid time unit. " + "Should be one of " + TimeUnit.list() + ".", Literals.TIME__UNIT); } + } - /** - * Provides convenient access to the inner state of the validator. - *

    - * The validator only gives protected access to its own state. With - * this class, we can grant access to the inner state to other objects. - * - * @author Christian Menard - */ - protected class ValidatorStateAccess { - public EObject getCurrentObject() { - return BaseLFValidator.this.getCurrentObject(); - } + /** + * Provides convenient access to the inner state of the validator. + * + *

    The validator only gives protected access to its own state. With this class, we can grant + * access to the inner state to other objects. + * + * @author Christian Menard + */ + protected class ValidatorStateAccess { + public EObject getCurrentObject() { + return BaseLFValidator.this.getCurrentObject(); + } - public Method getCurrentMethod() { - return BaseLFValidator.this.getCurrentMethod(); - } + public Method getCurrentMethod() { + return BaseLFValidator.this.getCurrentMethod(); + } - public DiagnosticChain getChain() { - return BaseLFValidator.this.getChain(); - } + public DiagnosticChain getChain() { + return BaseLFValidator.this.getChain(); + } - public CheckMode getCheckMode() { - return BaseLFValidator.this.getCheckMode(); - } + public CheckMode getCheckMode() { + return BaseLFValidator.this.getCheckMode(); + } - public Map getContext() { - return BaseLFValidator.this.getContext(); - } + public Map getContext() { + return BaseLFValidator.this.getContext(); } + } } diff --git a/org.lflang/src/org/lflang/validation/LFNamesAreUniqueValidationHelper.java b/org.lflang/src/org/lflang/validation/LFNamesAreUniqueValidationHelper.java index 75020fdc2b..9c6267cb0a 100644 --- a/org.lflang/src/org/lflang/validation/LFNamesAreUniqueValidationHelper.java +++ b/org.lflang/src/org/lflang/validation/LFNamesAreUniqueValidationHelper.java @@ -2,27 +2,24 @@ import org.eclipse.emf.ecore.EClass; import org.eclipse.xtext.validation.NamesAreUniqueValidationHelper; - import org.lflang.lf.LfPackage; public class LFNamesAreUniqueValidationHelper extends NamesAreUniqueValidationHelper { - /** - * Lump all inputs, outputs, timers, actions, parameters, and - * instantiations in the same cluster type. This ensures that - * names amongst them are checked for uniqueness. - */ - @Override public EClass getAssociatedClusterType(EClass eClass) { - if (LfPackage.Literals.INPUT == eClass || - LfPackage.Literals.OUTPUT == eClass || - LfPackage.Literals.TIMER == eClass || - LfPackage.Literals.ACTION == eClass || - LfPackage.Literals.PARAMETER == eClass || - LfPackage.Literals.INSTANTIATION == eClass - ) { - return LfPackage.Literals.VARIABLE; - } - return super.getAssociatedClusterType(eClass); + /** + * Lump all inputs, outputs, timers, actions, parameters, and instantiations in the same cluster + * type. This ensures that names amongst them are checked for uniqueness. + */ + @Override + public EClass getAssociatedClusterType(EClass eClass) { + if (LfPackage.Literals.INPUT == eClass + || LfPackage.Literals.OUTPUT == eClass + || LfPackage.Literals.TIMER == eClass + || LfPackage.Literals.ACTION == eClass + || LfPackage.Literals.PARAMETER == eClass + || LfPackage.Literals.INSTANTIATION == eClass) { + return LfPackage.Literals.VARIABLE; } - + return super.getAssociatedClusterType(eClass); + } } diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 36c09cf678..747b22ffc3 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -2,17 +2,17 @@ /************* * Copyright (c) 2019-2020, The University of California at Berkeley. - + * * 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. - + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 @@ -28,12 +28,10 @@ import static org.lflang.ast.ASTUtils.inferPortWidth; import static org.lflang.ast.ASTUtils.isGeneric; -import static org.lflang.ast.ASTUtils.isInteger; -import static org.lflang.ast.ASTUtils.isOfTimeType; -import static org.lflang.ast.ASTUtils.isZero; import static org.lflang.ast.ASTUtils.toDefinition; import static org.lflang.ast.ASTUtils.toOriginalText; +import com.google.inject.Inject; import java.io.File; import java.io.IOException; import java.util.ArrayList; @@ -46,7 +44,6 @@ import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.common.util.EList; import org.eclipse.emf.common.util.TreeIterator; import org.eclipse.emf.ecore.EAttribute; @@ -56,13 +53,13 @@ import org.eclipse.xtext.validation.Check; import org.eclipse.xtext.validation.CheckType; import org.eclipse.xtext.validation.ValidationMessageAcceptor; -import org.lflang.ast.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.InferredType; import org.lflang.ModelInfo; import org.lflang.Target; import org.lflang.TargetProperty; import org.lflang.TimeValue; +import org.lflang.ast.ASTUtils; import org.lflang.federated.serialization.SupportedSerializers; import org.lflang.federated.validation.FedValidator; import org.lflang.generator.NamedInstance; @@ -117,12 +114,10 @@ import org.lflang.lf.WidthTerm; import org.lflang.util.FileUtil; -import com.google.inject.Inject; - /** * Custom validation checks for Lingua Franca programs. * - * Also see: https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation + *

    Also see: https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation * * @author Edward A. Lee * @author Marten Lohstroh @@ -133,1763 +128,1853 @@ */ public class LFValidator extends BaseLFValidator { - ////////////////////////////////////////////////////////////// - //// Public check methods. - - // These methods are automatically invoked on AST nodes matching - // the types of their arguments. - // CheckType.FAST ensures that these checks run whenever a file is modified. - // Alternatives are CheckType.NORMAL (when saving) and - // CheckType.EXPENSIVE (only when right-click, validate). - // FIXME: What is the default when nothing is specified? - - // These methods are listed in alphabetical order, and, although - // it is isn't strictly required, follow a naming convention - // checkClass, where Class is the AST class, where possible. - - @Check(CheckType.FAST) - public void checkAction(Action action) { - checkName(action.getName(), Literals.VARIABLE__NAME); - if (action.getOrigin() == ActionOrigin.NONE) { - error( - "Action must have modifier {@code logical} or {@code physical}.", - Literals.ACTION__ORIGIN - ); - } - if (action.getPolicy() != null && - !SPACING_VIOLATION_POLICIES.contains(action.getPolicy())) { - error( - "Unrecognized spacing violation policy: " + action.getPolicy() + - ". Available policies are: " + - String.join(", ", SPACING_VIOLATION_POLICIES) + ".", - Literals.ACTION__POLICY); - } - checkExpressionIsTime(action.getMinDelay(), Literals.ACTION__MIN_DELAY); - checkExpressionIsTime(action.getMinSpacing(), Literals.ACTION__MIN_SPACING); + ////////////////////////////////////////////////////////////// + //// Public check methods. + + // These methods are automatically invoked on AST nodes matching + // the types of their arguments. + // CheckType.FAST ensures that these checks run whenever a file is modified. + // Alternatives are CheckType.NORMAL (when saving) and + // CheckType.EXPENSIVE (only when right-click, validate). + // FIXME: What is the default when nothing is specified? + + // These methods are listed in alphabetical order, and, although + // it is isn't strictly required, follow a naming convention + // checkClass, where Class is the AST class, where possible. + + @Check(CheckType.FAST) + public void checkAction(Action action) { + checkName(action.getName(), Literals.VARIABLE__NAME); + if (action.getOrigin() == ActionOrigin.NONE) { + error( + "Action must have modifier {@code logical} or {@code physical}.", + Literals.ACTION__ORIGIN); } - - - @Check(CheckType.FAST) - public void checkInitializer(Initializer init) { - if (init.isBraces() && target != Target.CPP) { - error("Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); - } else if (init.isParens() && target.mandatesEqualsInitializers()) { - var message = "This syntax is deprecated in the " + target - + " target, use an equal sign instead of parentheses for assignment."; - if (init.getExprs().size() == 1) { - message += " (run the formatter to fix this automatically)"; - } - warning(message, Literals.INITIALIZER__PARENS); - } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { - var feature = init.isBraces() ? Literals.INITIALIZER__BRACES - : Literals.INITIALIZER__PARENS; - var message = "This syntax is deprecated, do not use parentheses or braces but an equal sign."; - if (init.getExprs().size() == 1) { - message += " (run the formatter to fix this automatically)"; - } - warning(message, feature); - } + if (action.getPolicy() != null && !SPACING_VIOLATION_POLICIES.contains(action.getPolicy())) { + error( + "Unrecognized spacing violation policy: " + + action.getPolicy() + + ". Available policies are: " + + String.join(", ", SPACING_VIOLATION_POLICIES) + + ".", + Literals.ACTION__POLICY); } - - @Check(CheckType.FAST) - public void checkBracedExpression(BracedListExpression expr) { - if (!target.allowsBracedListExpressions()) { - var message = "Braced expression lists are not a valid expression for the " + target - + " target."; - error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); - } + checkExpressionIsTime(action.getMinDelay(), Literals.ACTION__MIN_DELAY); + checkExpressionIsTime(action.getMinSpacing(), Literals.ACTION__MIN_SPACING); + } + + @Check(CheckType.FAST) + public void checkInitializer(Initializer init) { + if (init.isBraces() && target != Target.CPP) { + error( + "Brace initializers are only supported for the C++ target", Literals.INITIALIZER__BRACES); + } else if (init.isParens() && target.mandatesEqualsInitializers()) { + var message = + "This syntax is deprecated in the " + + target + + " target, use an equal sign instead of parentheses for assignment."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, Literals.INITIALIZER__PARENS); + } else if (!init.isAssign() && init.eContainer() instanceof Assignment) { + var feature = init.isBraces() ? Literals.INITIALIZER__BRACES : Literals.INITIALIZER__PARENS; + var message = + "This syntax is deprecated, do not use parentheses or braces but an equal sign."; + if (init.getExprs().size() == 1) { + message += " (run the formatter to fix this automatically)"; + } + warning(message, feature); } - - @Check(CheckType.FAST) - public void checkAssignment(Assignment assignment) { - - // If the left-hand side is a time parameter, make sure the assignment has units - typeCheck(assignment.getRhs(), ASTUtils.getInferredType(assignment.getLhs()), Literals.ASSIGNMENT__RHS); - // If this assignment overrides a parameter that is used in a deadline, - // report possible overflow. - if (isCBasedTarget() && - this.info.overflowingAssignments.contains(assignment)) { - error( - "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.ASSIGNMENT__RHS); - } - + } + + @Check(CheckType.FAST) + public void checkBracedExpression(BracedListExpression expr) { + if (!target.allowsBracedListExpressions()) { + var message = + "Braced expression lists are not a valid expression for the " + target + " target."; + error(message, Literals.BRACED_LIST_EXPRESSION.eContainmentFeature()); } + } + + @Check(CheckType.FAST) + public void checkAssignment(Assignment assignment) { + + // If the left-hand side is a time parameter, make sure the assignment has units + typeCheck( + assignment.getRhs(), + ASTUtils.getInferredType(assignment.getLhs()), + Literals.ASSIGNMENT__RHS); + // If this assignment overrides a parameter that is used in a deadline, + // report possible overflow. + if (isCBasedTarget() && this.info.overflowingAssignments.contains(assignment)) { + error( + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + + " nanoseconds.", + Literals.ASSIGNMENT__RHS); + } + } - @Check(CheckType.FAST) - public void checkConnection(Connection connection) { - - // Report if connection is part of a cycle. - Set> cycles = this.info.topologyCycles(); - for (VarRef lp : connection.getLeftPorts()) { - for (VarRef rp : connection.getRightPorts()) { - boolean leftInCycle = false; - - for (NamedInstance it : cycles) { - if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) - || (it.getDefinition().equals(lp.getVariable()) && it.getParent().equals(lp.getContainer()))) { - leftInCycle = true; - break; - } - } - - for (NamedInstance it : cycles) { - if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) - || (it.getDefinition().equals(rp.getVariable()) && it.getParent().equals(rp.getContainer()))) { - if (leftInCycle) { - Reactor reactor = ASTUtils.getEnclosingReactor(connection); - String reactorName = reactor.getName(); - error(String.format("Connection in reactor %s creates", reactorName) + - String.format("a cyclic dependency between %s and %s.", toOriginalText(lp), toOriginalText(rp)), - Literals.CONNECTION__DELAY); - } - } - } - } - } - - // FIXME: look up all ReactorInstance objects that have a definition equal to the - // container of this connection. For each of those occurrences, the widths have to match. - // For the C target, since C has such a weak type system, check that - // the types on both sides of every connection match. For other languages, - // we leave type compatibility that language's compiler or interpreter. - if (isCBasedTarget()) { - Type type = (Type) null; - for (VarRef port : (Iterable) () -> Stream.concat( - connection.getLeftPorts().stream(), - connection.getRightPorts().stream() - ).iterator()) { - // If the variable is not a port, then there is some other - // error. Avoid a class cast exception. - if (port.getVariable() instanceof Port) { - if (type == null) { - type = ((Port) port.getVariable()).getType(); - } else { - var portType = ((Port) port.getVariable()).getType(); - portType = port.getContainer() == null ? portType : new TypeParameterizedReactor(port.getContainer()).resolveType(portType); - if (!sameType(type, portType)) { - error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); - } - } - } - } - } + @Check(CheckType.FAST) + public void checkConnection(Connection connection) { - // Check whether the total width of the left side of the connection - // matches the total width of the right side. This cannot be determined - // here if the width is not given as a constant. In that case, it is up - // to the code generator to check it. - int leftWidth = 0; - for (VarRef port : connection.getLeftPorts()) { - int width = inferPortWidth(port, null, null); // null args imply incomplete check. - if (width < 0 || leftWidth < 0) { - // Cannot determine the width of the left ports. - leftWidth = -1; - } else { - leftWidth += width; - } - } - int rightWidth = 0; - for (VarRef port : connection.getRightPorts()) { - int width = inferPortWidth(port, null, null); // null args imply incomplete check. - if (width < 0 || rightWidth < 0) { - // Cannot determine the width of the left ports. - rightWidth = -1; - } else { - rightWidth += width; - } - } + // Report if connection is part of a cycle. + Set> cycles = this.info.topologyCycles(); + for (VarRef lp : connection.getLeftPorts()) { + for (VarRef rp : connection.getRightPorts()) { + boolean leftInCycle = false; - if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { - if (connection.isIterated()) { - if (leftWidth == 0 || rightWidth % leftWidth != 0) { - // FIXME: The second argument should be Literals.CONNECTION, but - // stupidly, xtext will not accept that. There seems to be no way to - // report an error for the whole connection statement. - warning(String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), - Literals.CONNECTION__LEFT_PORTS - ); - } - } else { - // FIXME: The second argument should be Literals.CONNECTION, but - // stupidly, xtext will not accept that. There seems to be no way to - // report an error for the whole connection statement. - warning(String.format("Left width %s does not match right width %s", leftWidth, rightWidth), - Literals.CONNECTION__LEFT_PORTS - ); - } - } - - Reactor reactor = ASTUtils.getEnclosingReactor(connection); - - // Make sure the right port is not already an effect of a reaction. - for (Reaction reaction : ASTUtils.allReactions(reactor)) { - for (VarRef effect : reaction.getEffects()) { - for (VarRef rightPort : connection.getRightPorts()) { - if (rightPort.getVariable().equals(effect.getVariable()) && // Refers to the same variable - rightPort.getContainer() == effect.getContainer() && // Refers to the same instance - ( reaction.eContainer() instanceof Reactor || // Either is not part of a mode - connection.eContainer() instanceof Reactor || - connection.eContainer() == reaction.eContainer() // Or they are in the same mode - )) { - error("Cannot connect: Port named '" + effect.getVariable().getName() + - "' is already effect of a reaction.", - Literals.CONNECTION__RIGHT_PORTS); - } - } - } + for (NamedInstance it : cycles) { + if ((lp.getContainer() == null && it.getDefinition().equals(lp.getVariable())) + || (it.getDefinition().equals(lp.getVariable()) + && it.getParent().equals(lp.getContainer()))) { + leftInCycle = true; + break; + } } - // Check that the right port does not already have some other - // upstream connection. - for (Connection c : reactor.getConnections()) { - if (c != connection) { - for (VarRef thisRightPort : connection.getRightPorts()) { - for (VarRef thatRightPort : c.getRightPorts()) { - if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) && // Refers to the same variable - thisRightPort.getContainer() == thatRightPort.getContainer() && // Refers to the same instance - ( connection.eContainer() instanceof Reactor || // Or either of the connections in not part of a mode - c.eContainer() instanceof Reactor || - connection.eContainer() == c.eContainer() // Or they are in the same mode - )) { - error( - "Cannot connect: Port named '" + thisRightPort.getVariable().getName() + - "' may only appear once on the right side of a connection.", - Literals.CONNECTION__RIGHT_PORTS); - } - } - } + for (NamedInstance it : cycles) { + if ((rp.getContainer() == null && it.getDefinition().equals(rp.getVariable())) + || (it.getDefinition().equals(rp.getVariable()) + && it.getParent().equals(rp.getContainer()))) { + if (leftInCycle) { + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + String reactorName = reactor.getName(); + error( + String.format("Connection in reactor %s creates", reactorName) + + String.format( + "a cyclic dependency between %s and %s.", + toOriginalText(lp), toOriginalText(rp)), + Literals.CONNECTION__DELAY); } + } } + } + } - // Check the after delay - if (connection.getDelay() != null) { - final var delay = connection.getDelay(); - if (delay instanceof ParameterReference || delay instanceof Time || delay instanceof Literal) { - checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); - } else { - error("After delays can only be given by time literals or parameters.", - Literals.CONNECTION__DELAY); + // FIXME: look up all ReactorInstance objects that have a definition equal to the + // container of this connection. For each of those occurrences, the widths have to match. + // For the C target, since C has such a weak type system, check that + // the types on both sides of every connection match. For other languages, + // we leave type compatibility that language's compiler or interpreter. + if (isCBasedTarget()) { + Type type = (Type) null; + for (VarRef port : + (Iterable) + () -> + Stream.concat( + connection.getLeftPorts().stream(), connection.getRightPorts().stream()) + .iterator()) { + // If the variable is not a port, then there is some other + // error. Avoid a class cast exception. + if (port.getVariable() instanceof Port) { + if (type == null) { + type = ((Port) port.getVariable()).getType(); + } else { + var portType = ((Port) port.getVariable()).getType(); + portType = + port.getContainer() == null + ? portType + : new TypeParameterizedReactor(port.getContainer()).resolveType(portType); + if (!sameType(type, portType)) { + error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); } + } } + } } - @Check(CheckType.FAST) - public void checkDeadline(Deadline deadline) { - if (isCBasedTarget() && - this.info.overflowingDeadlines.contains(deadline)) { - error( - "Deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.DEADLINE__DELAY); - } - checkExpressionIsTime(deadline.getDelay(), Literals.DEADLINE__DELAY); + // Check whether the total width of the left side of the connection + // matches the total width of the right side. This cannot be determined + // here if the width is not given as a constant. In that case, it is up + // to the code generator to check it. + int leftWidth = 0; + for (VarRef port : connection.getLeftPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || leftWidth < 0) { + // Cannot determine the width of the left ports. + leftWidth = -1; + } else { + leftWidth += width; + } } - - @Check(CheckType.FAST) - public void checkHost(Host host) { - String addr = host.getAddr(); - String user = host.getUser(); - if (user != null && !user.matches(USERNAME_REGEX)) { - warning( - "Invalid user name.", - Literals.HOST__USER - ); - } - if (host instanceof IPV4Host && !addr.matches(IPV4_REGEX)) { - warning( - "Invalid IP address.", - Literals.HOST__ADDR - ); - } else if (host instanceof IPV6Host && !addr.matches(IPV6_REGEX)) { - warning( - "Invalid IP address.", - Literals.HOST__ADDR - ); - } else if (host instanceof NamedHost && !addr.matches(HOST_OR_FQN_REGEX)) { - warning( - "Invalid host name or fully qualified domain name.", - Literals.HOST__ADDR - ); - } + int rightWidth = 0; + for (VarRef port : connection.getRightPorts()) { + int width = inferPortWidth(port, null, null); // null args imply incomplete check. + if (width < 0 || rightWidth < 0) { + // Cannot determine the width of the left ports. + rightWidth = -1; + } else { + rightWidth += width; + } } - @Check - public void checkImport(Import imp) { - if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { - error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. - return; - } - - // FIXME: report error if resource cannot be resolved. - for (ImportedReactor reactor : imp.getReactorClasses()) { - if (!isUnused(reactor)) { - return; - } - } - warning("Unused import.", Literals.IMPORT__IMPORT_URI); + if (leftWidth != -1 && rightWidth != -1 && leftWidth != rightWidth) { + if (connection.isIterated()) { + if (leftWidth == 0 || rightWidth % leftWidth != 0) { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning( + String.format("Left width %s does not divide right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS); + } + } else { + // FIXME: The second argument should be Literals.CONNECTION, but + // stupidly, xtext will not accept that. There seems to be no way to + // report an error for the whole connection statement. + warning( + String.format("Left width %s does not match right width %s", leftWidth, rightWidth), + Literals.CONNECTION__LEFT_PORTS); + } } - @Check - public void checkImportedReactor(ImportedReactor reactor) { - if (isUnused(reactor)) { - warning("Unused reactor class.", - Literals.IMPORTED_REACTOR__REACTOR_CLASS); - } - - if (info.instantiationGraph.hasCycles()) { - Set cycleSet = new HashSet<>(); - for (Set cycle : info.instantiationGraph.getCycles()) { - cycleSet.addAll(cycle); - } - if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { - error("Imported reactor '" + toDefinition(reactor).getName() + - "' has cyclic instantiation in it.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); - } + Reactor reactor = ASTUtils.getEnclosingReactor(connection); + + // Make sure the right port is not already an effect of a reaction. + for (Reaction reaction : ASTUtils.allReactions(reactor)) { + for (VarRef effect : reaction.getEffects()) { + for (VarRef rightPort : connection.getRightPorts()) { + if (rightPort.getVariable().equals(effect.getVariable()) + && // Refers to the same variable + rightPort.getContainer() == effect.getContainer() + && // Refers to the same instance + (reaction.eContainer() instanceof Reactor + || // Either is not part of a mode + connection.eContainer() instanceof Reactor + || connection.eContainer() + == reaction.eContainer() // Or they are in the same mode + )) { + error( + "Cannot connect: Port named '" + + effect.getVariable().getName() + + "' is already effect of a reaction.", + Literals.CONNECTION__RIGHT_PORTS); + } } + } } - @Check(CheckType.FAST) - public void checkInput(Input input) { - Reactor parent = (Reactor)input.eContainer(); - if (parent.isMain() || parent.isFederated()) { - error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); - } - checkName(input.getName(), Literals.VARIABLE__NAME); - if (target.requiresTypes) { - if (input.getType() == null) { - error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); + // Check that the right port does not already have some other + // upstream connection. + for (Connection c : reactor.getConnections()) { + if (c != connection) { + for (VarRef thisRightPort : connection.getRightPorts()) { + for (VarRef thatRightPort : c.getRightPorts()) { + if (thisRightPort.getVariable().equals(thatRightPort.getVariable()) + && // Refers to the same variable + thisRightPort.getContainer() == thatRightPort.getContainer() + && // Refers to the same instance + (connection.eContainer() instanceof Reactor + || // Or either of the connections in not part of a mode + c.eContainer() instanceof Reactor + || connection.eContainer() == c.eContainer() // Or they are in the same mode + )) { + error( + "Cannot connect: Port named '" + + thisRightPort.getVariable().getName() + + "' may only appear once on the right side of a connection.", + Literals.CONNECTION__RIGHT_PORTS); } + } } - - // mutable has no meaning in C++ - if (input.isMutable() && this.target == Target.CPP) { - warning( - "The mutable qualifier has no meaning for the C++ target and should be removed. " + - "In C++, any value can be made mutable by calling get_mutable_copy().", - Literals.INPUT__MUTABLE - ); - } - - // Variable width multiports are not supported (yet?). - if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { - error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); - } + } } - @Check(CheckType.FAST) - public void checkInstantiation(Instantiation instantiation) { - checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); - Reactor reactor = toDefinition(instantiation.getReactorClass()); - if (reactor.isMain() || reactor.isFederated()) { - error( - "Cannot instantiate a main (or federated) reactor: " + - instantiation.getReactorClass().getName(), - Literals.INSTANTIATION__REACTOR_CLASS - ); - } + // Check the after delay + if (connection.getDelay() != null) { + final var delay = connection.getDelay(); + if (delay instanceof ParameterReference + || delay instanceof Time + || delay instanceof Literal) { + checkExpressionIsTime(delay, Literals.CONNECTION__DELAY); + } else { + error( + "After delays can only be given by time literals or parameters.", + Literals.CONNECTION__DELAY); + } + } + } + + @Check(CheckType.FAST) + public void checkDeadline(Deadline deadline) { + if (isCBasedTarget() && this.info.overflowingDeadlines.contains(deadline)) { + error( + "Deadline exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.DEADLINE__DELAY); + } + checkExpressionIsTime(deadline.getDelay(), Literals.DEADLINE__DELAY); + } + + @Check(CheckType.FAST) + public void checkHost(Host host) { + String addr = host.getAddr(); + String user = host.getUser(); + if (user != null && !user.matches(USERNAME_REGEX)) { + warning("Invalid user name.", Literals.HOST__USER); + } + if (host instanceof IPV4Host && !addr.matches(IPV4_REGEX)) { + warning("Invalid IP address.", Literals.HOST__ADDR); + } else if (host instanceof IPV6Host && !addr.matches(IPV6_REGEX)) { + warning("Invalid IP address.", Literals.HOST__ADDR); + } else if (host instanceof NamedHost && !addr.matches(HOST_OR_FQN_REGEX)) { + warning("Invalid host name or fully qualified domain name.", Literals.HOST__ADDR); + } + } - // Report error if this instantiation is part of a cycle. - // FIXME: improve error message. - // FIXME: Also report if there exists a cycle within. - if (this.info.instantiationGraph.getCycles().size() > 0) { - for (Set cycle : this.info.instantiationGraph.getCycles()) { - Reactor container = (Reactor) instantiation.eContainer(); - if (cycle.contains(container) && cycle.contains(reactor)) { - List names = new ArrayList<>(); - for (Reactor r : cycle) { - names.add(r.getName()); - } - - error( - "Instantiation is part of a cycle: " + String.join(", ", names) + ".", - Literals.INSTANTIATION__REACTOR_CLASS - ); - } - } - } - // Variable width multiports are not supported (yet?). - if (instantiation.getWidthSpec() != null - && instantiation.getWidthSpec().isOfVariableLength() - ) { - if (isCBasedTarget()) { - warning("Variable-width banks are for internal use only.", - Literals.INSTANTIATION__WIDTH_SPEC - ); - } else { - error("Variable-width banks are not supported.", - Literals.INSTANTIATION__WIDTH_SPEC - ); - } - } + @Check + public void checkImport(Import imp) { + if (toDefinition(imp.getReactorClasses().get(0)).eResource().getErrors().size() > 0) { + error("Error loading resource.", Literals.IMPORT__IMPORT_URI); // FIXME: print specifics. + return; } - /** Check target parameters, which are key-value pairs. */ - @Check(CheckType.FAST) - public void checkKeyValuePair(KeyValuePair param) { - // Check only if the container's container is a Target. - if (param.eContainer().eContainer() instanceof TargetDecl) { - TargetProperty prop = TargetProperty.forName(param.getName()); - - // Make sure the key is valid. - if (prop == null) { - String options = TargetProperty.getOptions().stream() - .map(p -> p.description).sorted() - .collect(Collectors.joining(", ")); - warning( - "Unrecognized target parameter: " + param.getName() + - ". Recognized parameters are: " + options, - Literals.KEY_VALUE_PAIR__NAME); - } else { - // Check whether the property is supported by the target. - if (!prop.supportedBy.contains(this.target)) { - warning( - "The target parameter: " + param.getName() + - " is not supported by the " + this.target + - " target and will thus be ignored.", - Literals.KEY_VALUE_PAIR__NAME); - } + // FIXME: report error if resource cannot be resolved. + for (ImportedReactor reactor : imp.getReactorClasses()) { + if (!isUnused(reactor)) { + return; + } + } + warning("Unused import.", Literals.IMPORT__IMPORT_URI); + } - // Report problem with the assigned value. - prop.type.check(param.getValue(), param.getName(), this); - } + @Check + public void checkImportedReactor(ImportedReactor reactor) { + if (isUnused(reactor)) { + warning("Unused reactor class.", Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } - for (String it : targetPropertyErrors) { - error(it, Literals.KEY_VALUE_PAIR__VALUE); - } - targetPropertyErrors.clear(); + if (info.instantiationGraph.hasCycles()) { + Set cycleSet = new HashSet<>(); + for (Set cycle : info.instantiationGraph.getCycles()) { + cycleSet.addAll(cycle); + } + if (dependsOnCycle(toDefinition(reactor), cycleSet, new HashSet<>())) { + error( + "Imported reactor '" + + toDefinition(reactor).getName() + + "' has cyclic instantiation in it.", + Literals.IMPORTED_REACTOR__REACTOR_CLASS); + } + } + } - for (String it : targetPropertyWarnings) { - error(it, Literals.KEY_VALUE_PAIR__VALUE); - } - targetPropertyWarnings.clear(); - } + @Check(CheckType.FAST) + public void checkInput(Input input) { + Reactor parent = (Reactor) input.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have inputs.", Literals.VARIABLE__NAME); + } + checkName(input.getName(), Literals.VARIABLE__NAME); + if (target.requiresTypes) { + if (input.getType() == null) { + error("Input must have a type.", Literals.TYPED_VARIABLE__TYPE); + } } - @Check(CheckType.FAST) - public void checkModel(Model model) { - // Since we're doing a fast check, we only want to update - // if the model info hasn't been initialized yet. If it has, - // we use the old information and update it during a normal - // check (see below). - if (!info.updated) { - info.update(model, errorReporter); - } + // mutable has no meaning in C++ + if (input.isMutable() && this.target == Target.CPP) { + warning( + "The mutable qualifier has no meaning for the C++ target and should be removed. " + + "In C++, any value can be made mutable by calling get_mutable_copy().", + Literals.INPUT__MUTABLE); } - @Check(CheckType.NORMAL) - public void updateModelInfo(Model model) { - info.update(model, errorReporter); + // Variable width multiports are not supported (yet?). + if (input.getWidthSpec() != null && input.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } + } + + @Check(CheckType.FAST) + public void checkInstantiation(Instantiation instantiation) { + checkName(instantiation.getName(), Literals.INSTANTIATION__NAME); + Reactor reactor = toDefinition(instantiation.getReactorClass()); + if (reactor.isMain() || reactor.isFederated()) { + error( + "Cannot instantiate a main (or federated) reactor: " + + instantiation.getReactorClass().getName(), + Literals.INSTANTIATION__REACTOR_CLASS); } - @Check(CheckType.FAST) - public void checkOutput(Output output) { - Reactor parent = (Reactor)output.eContainer(); - if (parent.isMain() || parent.isFederated()) { - error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); - } - checkName(output.getName(), Literals.VARIABLE__NAME); - if (this.target.requiresTypes) { - if (output.getType() == null) { - error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); - } - } + // Report error if this instantiation is part of a cycle. + // FIXME: improve error message. + // FIXME: Also report if there exists a cycle within. + if (this.info.instantiationGraph.getCycles().size() > 0) { + for (Set cycle : this.info.instantiationGraph.getCycles()) { + Reactor container = (Reactor) instantiation.eContainer(); + if (cycle.contains(container) && cycle.contains(reactor)) { + List names = new ArrayList<>(); + for (Reactor r : cycle) { + names.add(r.getName()); + } - // Variable width multiports are not supported (yet?). - if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { - error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + error( + "Instantiation is part of a cycle: " + String.join(", ", names) + ".", + Literals.INSTANTIATION__REACTOR_CLASS); } + } + } + // Variable width multiports are not supported (yet?). + if (instantiation.getWidthSpec() != null && instantiation.getWidthSpec().isOfVariableLength()) { + if (isCBasedTarget()) { + warning( + "Variable-width banks are for internal use only.", Literals.INSTANTIATION__WIDTH_SPEC); + } else { + error("Variable-width banks are not supported.", Literals.INSTANTIATION__WIDTH_SPEC); + } + } + } + + /** Check target parameters, which are key-value pairs. */ + @Check(CheckType.FAST) + public void checkKeyValuePair(KeyValuePair param) { + // Check only if the container's container is a Target. + if (param.eContainer().eContainer() instanceof TargetDecl) { + TargetProperty prop = TargetProperty.forName(param.getName()); + + // Make sure the key is valid. + if (prop == null) { + String options = + TargetProperty.getOptions().stream() + .map(p -> p.description) + .sorted() + .collect(Collectors.joining(", ")); + warning( + "Unrecognized target parameter: " + + param.getName() + + ". Recognized parameters are: " + + options, + Literals.KEY_VALUE_PAIR__NAME); + } else { + // Check whether the property is supported by the target. + if (!prop.supportedBy.contains(this.target)) { + warning( + "The target parameter: " + + param.getName() + + " is not supported by the " + + this.target + + " target and will thus be ignored.", + Literals.KEY_VALUE_PAIR__NAME); + } + + // Report problem with the assigned value. + prop.type.check(param.getValue(), param.getName(), this); + } + + for (String it : targetPropertyErrors) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyErrors.clear(); + + for (String it : targetPropertyWarnings) { + error(it, Literals.KEY_VALUE_PAIR__VALUE); + } + targetPropertyWarnings.clear(); + } + } + + @Check(CheckType.FAST) + public void checkModel(Model model) { + // Since we're doing a fast check, we only want to update + // if the model info hasn't been initialized yet. If it has, + // we use the old information and update it during a normal + // check (see below). + if (!info.updated) { + info.update(model, errorReporter); + } + } + + @Check(CheckType.NORMAL) + public void updateModelInfo(Model model) { + info.update(model, errorReporter); + } + + @Check(CheckType.FAST) + public void checkOutput(Output output) { + Reactor parent = (Reactor) output.eContainer(); + if (parent.isMain() || parent.isFederated()) { + error("Main reactor cannot have outputs.", Literals.VARIABLE__NAME); + } + checkName(output.getName(), Literals.VARIABLE__NAME); + if (this.target.requiresTypes) { + if (output.getType() == null) { + error("Output must have a type.", Literals.TYPED_VARIABLE__TYPE); + } } - @Check(CheckType.FAST) - public void checkParameter(Parameter param) { - checkName(param.getName(), Literals.PARAMETER__NAME); - - if (param.getInit() == null) { - // todo make initialization non-mandatory - // https://github.com/lf-lang/lingua-franca/issues/623 - error("Parameter must have a default value.", Literals.PARAMETER__INIT); - return; - } + // Variable width multiports are not supported (yet?). + if (output.getWidthSpec() != null && output.getWidthSpec().isOfVariableLength()) { + error("Variable-width multiports are not supported.", Literals.PORT__WIDTH_SPEC); + } + } - if (this.target.requiresTypes) { - // Report missing target type. param.inferredType.undefine - if (ASTUtils.getInferredType(param).isUndefined()) { - error("Type declaration missing.", Literals.PARAMETER__TYPE); - } - } + @Check(CheckType.FAST) + public void checkParameter(Parameter param) { + checkName(param.getName(), Literals.PARAMETER__NAME); - if (param.getType() != null) { - typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); - } + if (param.getInit() == null) { + // todo make initialization non-mandatory + // https://github.com/lf-lang/lingua-franca/issues/623 + error("Parameter must have a default value.", Literals.PARAMETER__INIT); + return; + } - if (param.getInit() != null) { - for (Expression expr : param.getInit().getExprs()) { - if (expr instanceof ParameterReference) { - // Initialization using parameters is forbidden. - error("Parameter cannot be initialized using parameter.", - Literals.PARAMETER__INIT); - } - } - } + if (this.target.requiresTypes) { + // Report missing target type. param.inferredType.undefine + if (ASTUtils.getInferredType(param).isUndefined()) { + error("Type declaration missing.", Literals.PARAMETER__TYPE); + } + } - if (this.target == Target.CPP) { - EObject container = param.eContainer(); - Reactor reactor = (Reactor) container; - if (reactor.isMain()) { - // we need to check for the cli parameters that are always taken - List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); - if (cliParams.contains(param.getName())) { - error("Parameter '" + param.getName() - + "' is already in use as command line argument by Lingua Franca,", - Literals.PARAMETER__NAME); - } - } - } + if (param.getType() != null) { + typeCheck(param.getInit(), ASTUtils.getInferredType(param), Literals.PARAMETER__INIT); + } - if (isCBasedTarget() && - this.info.overflowingParameters.contains(param)) { - error( - "Time value used to specify a deadline exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.PARAMETER__INIT); + if (param.getInit() != null) { + for (Expression expr : param.getInit().getExprs()) { + if (expr instanceof ParameterReference) { + // Initialization using parameters is forbidden. + error("Parameter cannot be initialized using parameter.", Literals.PARAMETER__INIT); } + } + } + if (this.target == Target.CPP) { + EObject container = param.eContainer(); + Reactor reactor = (Reactor) container; + if (reactor.isMain()) { + // we need to check for the cli parameters that are always taken + List cliParams = List.of("t", "threads", "o", "timeout", "f", "fast", "help"); + if (cliParams.contains(param.getName())) { + error( + "Parameter '" + + param.getName() + + "' is already in use as command line argument by Lingua Franca,", + Literals.PARAMETER__NAME); + } + } } - @Check(CheckType.FAST) - public void checkPreamble(Preamble preamble) { - if (this.target == Target.CPP) { - if (preamble.getVisibility() == Visibility.NONE) { - error( - "Preambles for the C++ target need a visibility qualifier (private or public)!", - Literals.PREAMBLE__VISIBILITY - ); - } else if (preamble.getVisibility() == Visibility.PRIVATE) { - EObject container = preamble.eContainer(); - if (container != null && container instanceof Reactor) { - Reactor reactor = (Reactor) container; - if (isGeneric(reactor)) { - warning( - "Private preambles in generic reactors are not truly private. " + - "Since the generated code is placed in a *_impl.hh file, it will " + - "be visible on the public interface. Consider using a public " + - "preamble within the reactor or a private preamble on file scope.", - Literals.PREAMBLE__VISIBILITY); - } - } - } - } else if (preamble.getVisibility() != Visibility.NONE) { + if (isCBasedTarget() && this.info.overflowingParameters.contains(param)) { + error( + "Time value used to specify a deadline exceeds the maximum of " + + TimeValue.MAX_LONG_DEADLINE + + " nanoseconds.", + Literals.PARAMETER__INIT); + } + } + + @Check(CheckType.FAST) + public void checkPreamble(Preamble preamble) { + if (this.target == Target.CPP) { + if (preamble.getVisibility() == Visibility.NONE) { + error( + "Preambles for the C++ target need a visibility qualifier (private or public)!", + Literals.PREAMBLE__VISIBILITY); + } else if (preamble.getVisibility() == Visibility.PRIVATE) { + EObject container = preamble.eContainer(); + if (container != null && container instanceof Reactor) { + Reactor reactor = (Reactor) container; + if (isGeneric(reactor)) { warning( - String.format("The %s qualifier has no meaning for the %s target. It should be removed.", - preamble.getVisibility(), this.target.name()), - Literals.PREAMBLE__VISIBILITY - ); + "Private preambles in generic reactors are not truly private. " + + "Since the generated code is placed in a *_impl.hh file, it will " + + "be visible on the public interface. Consider using a public " + + "preamble within the reactor or a private preamble on file scope.", + Literals.PREAMBLE__VISIBILITY); + } } + } + } else if (preamble.getVisibility() != Visibility.NONE) { + warning( + String.format( + "The %s qualifier has no meaning for the %s target. It should be removed.", + preamble.getVisibility(), this.target.name()), + Literals.PREAMBLE__VISIBILITY); } + } - @Check(CheckType.FAST) - public void checkReaction(Reaction reaction) { - - if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { - warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); - } - HashSet triggers = new HashSet<>(); - // Make sure input triggers have no container and output sources do. - for (TriggerRef trigger : reaction.getTriggers()) { - if (trigger instanceof VarRef) { - VarRef triggerVarRef = (VarRef) trigger; - triggers.add(triggerVarRef.getVariable()); - if (triggerVarRef instanceof Input) { - if (triggerVarRef.getContainer() != null) { - error(String.format("Cannot have an input of a contained reactor as a trigger: %s.%s", triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), - Literals.REACTION__TRIGGERS); - } - } else if (triggerVarRef.getVariable() instanceof Output) { - if (triggerVarRef.getContainer() == null) { - error(String.format("Cannot have an output of this reactor as a trigger: %s", triggerVarRef.getVariable().getName()), - Literals.REACTION__TRIGGERS); - } - } - } - } - - // Make sure input sources have no container and output sources do. - // Also check that a source is not already listed as a trigger. - for (VarRef source : reaction.getSources()) { - if (triggers.contains(source.getVariable())) { - error(String.format("Source is already listed as a trigger: %s", source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - if (source.getVariable() instanceof Input) { - if (source.getContainer() != null) { - error(String.format("Cannot have an input of a contained reactor as a source: %s.%s", source.getContainer().getName(), source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - } else if (source.getVariable() instanceof Output) { - if (source.getContainer() == null) { - error(String.format("Cannot have an output of this reactor as a source: %s", source.getVariable().getName()), - Literals.REACTION__SOURCES); - } - } - } - - // Make sure output effects have no container and input effects do. - for (VarRef effect : reaction.getEffects()) { - if (effect.getVariable() instanceof Input) { - if (effect.getContainer() == null) { - error(String.format("Cannot have an input of this reactor as an effect: %s", effect.getVariable().getName()), - Literals.REACTION__EFFECTS); - } - } else if (effect.getVariable() instanceof Output) { - if (effect.getContainer() != null) { - error(String.format("Cannot have an output of a contained reactor as an effect: %s.%s", effect.getContainer().getName(), effect.getVariable().getName()), - Literals.REACTION__EFFECTS); - } - } - } - - // // Report error if this reaction is part of a cycle. - Set> cycles = this.info.topologyCycles(); - Reactor reactor = ASTUtils.getEnclosingReactor(reaction); - boolean reactionInCycle = false; - for (NamedInstance it : cycles) { - if (it.getDefinition().equals(reaction)) { - reactionInCycle = true; - break; - } - } - if (reactionInCycle) { - // Report involved triggers. - List trigs = new ArrayList<>(); - for (TriggerRef t : reaction.getTriggers()) { - if (!(t instanceof VarRef)) { - continue; - } - VarRef tVarRef = (VarRef) t; - boolean triggerExistsInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(tVarRef.getVariable())) { - triggerExistsInCycle = true; - break; - } - } - if (triggerExistsInCycle) { - trigs.add(toOriginalText(tVarRef)); - } - } - if (trigs.size() > 0) { - error(String.format("Reaction triggers involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", trigs)), - Literals.REACTION__TRIGGERS); - } + @Check(CheckType.FAST) + public void checkReaction(Reaction reaction) { - // Report involved sources. - List sources = new ArrayList<>(); - for (VarRef t : reaction.getSources()) { - boolean sourceExistInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(t.getVariable())) { - sourceExistInCycle = true; - break; - } - } - if (sourceExistInCycle) { - sources.add(toOriginalText(t)); - } - } - if (sources.size() > 0) { - error(String.format("Reaction sources involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", sources)), - Literals.REACTION__SOURCES); - } - - // Report involved effects. - List effects = new ArrayList<>(); - for (VarRef t : reaction.getEffects()) { - boolean effectExistInCycle = false; - for (NamedInstance c : cycles) { - if (c.getDefinition().equals(t.getVariable())) { - effectExistInCycle = true; - break; - } - } - if (effectExistInCycle) { - effects.add(toOriginalText(t)); - } - } - if (effects.size() > 0) { - error(String.format("Reaction effects involved in cyclic dependency in reactor %s: %s.", reactor.getName(), String.join(", ", effects)), - Literals.REACTION__EFFECTS); - } - - if (trigs.size() + sources.size() == 0) { - error( - String.format("Cyclic dependency due to preceding reaction. Consider reordering reactions within reactor %s to avoid causality loop.", reactor.getName()), - reaction.eContainer(), - Literals.REACTOR__REACTIONS, - reactor.getReactions().indexOf(reaction) - ); - } else if (effects.size() == 0) { - error( - String.format("Cyclic dependency due to succeeding reaction. Consider reordering reactions within reactor %s to avoid causality loop.", reactor.getName()), - reaction.eContainer(), - Literals.REACTOR__REACTIONS, - reactor.getReactions().indexOf(reaction) - ); - } - // Not reporting reactions that are part of cycle _only_ due to reaction ordering. - // Moving them won't help solve the problem. - } - // FIXME: improve error message. + if (reaction.getTriggers() == null || reaction.getTriggers().size() == 0) { + warning("Reaction has no trigger.", Literals.REACTION__TRIGGERS); } - - public void checkReactorName(String name) throws IOException { - // Check for illegal names. - checkName(name, Literals.REACTOR_DECL__NAME); - - // C++ reactors may not be called 'preamble' - if (this.target == Target.CPP && name.equalsIgnoreCase("preamble")) { + HashSet triggers = new HashSet<>(); + // Make sure input triggers have no container and output sources do. + for (TriggerRef trigger : reaction.getTriggers()) { + if (trigger instanceof VarRef) { + VarRef triggerVarRef = (VarRef) trigger; + triggers.add(triggerVarRef.getVariable()); + if (triggerVarRef instanceof Input) { + if (triggerVarRef.getContainer() != null) { error( - "Reactor cannot be named '" + name + "'", - Literals.REACTOR_DECL__NAME - ); + String.format( + "Cannot have an input of a contained reactor as a trigger: %s.%s", + triggerVarRef.getContainer().getName(), triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } + } else if (triggerVarRef.getVariable() instanceof Output) { + if (triggerVarRef.getContainer() == null) { + error( + String.format( + "Cannot have an output of this reactor as a trigger: %s", + triggerVarRef.getVariable().getName()), + Literals.REACTION__TRIGGERS); + } } + } } - @Check(CheckType.FAST) - public void checkReactor(Reactor reactor) throws IOException { - String fileName = FileUtil.nameWithoutExtension(reactor.eResource()); - - if (reactor.isFederated() || reactor.isMain()) { - // Do not allow multiple main/federated reactors. - TreeIterator iter = reactor.eResource().getAllContents(); - int nMain = countMainOrFederated(iter); - if (nMain > 1) { - EAttribute attribute = Literals.REACTOR__MAIN; - if (reactor.isFederated()) { - attribute = Literals.REACTOR__FEDERATED; - } - error( - "Multiple definitions of main or federated reactor.", - attribute - ); - } - - if(reactor.getName() != null && !reactor.getName().equals(fileName)) { - // Make sure that if the name is given, it matches the expected name. - error( - "Name of main reactor must match the file name (or be omitted).", - Literals.REACTOR_DECL__NAME - ); - } - - // check the reactor name indicated by the file name - // Skip this check if the file is named __synthetic0. This Name is used during testing, - // and we would get an unexpected error due to the '__' prefix otherwise. - if (!fileName.equals("__synthetic0")) { - checkReactorName(fileName); - } - } else { - // Not federated or main. - if (reactor.getName() == null) { - error( - "Reactor must be named.", - Literals.REACTOR_DECL__NAME - ); - } else { - checkReactorName(reactor.getName()); - - TreeIterator iter = reactor.eResource().getAllContents(); - int nMain = countMainOrFederated(iter); - if (nMain > 0 && reactor.getName().equals(fileName)) { - error( - "Name conflict with main reactor.", - Literals.REACTOR_DECL__NAME - ); - } - } - } + // Make sure input sources have no container and output sources do. + // Also check that a source is not already listed as a trigger. + for (VarRef source : reaction.getSources()) { + if (triggers.contains(source.getVariable())) { + error( + String.format( + "Source is already listed as a trigger: %s", source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + if (source.getVariable() instanceof Input) { + if (source.getContainer() != null) { + error( + String.format( + "Cannot have an input of a contained reactor as a source: %s.%s", + source.getContainer().getName(), source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } else if (source.getVariable() instanceof Output) { + if (source.getContainer() == null) { + error( + String.format( + "Cannot have an output of this reactor as a source: %s", + source.getVariable().getName()), + Literals.REACTION__SOURCES); + } + } + } + // Make sure output effects have no container and input effects do. + for (VarRef effect : reaction.getEffects()) { + if (effect.getVariable() instanceof Input) { + if (effect.getContainer() == null) { + error( + String.format( + "Cannot have an input of this reactor as an effect: %s", + effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } else if (effect.getVariable() instanceof Output) { + if (effect.getContainer() != null) { + error( + String.format( + "Cannot have an output of a contained reactor as an effect: %s.%s", + effect.getContainer().getName(), effect.getVariable().getName()), + Literals.REACTION__EFFECTS); + } + } + } - Set superClasses = ASTUtils.superClasses(reactor); - if (superClasses == null) { - error( - "Problem with superclasses: Either they form a cycle or are not defined", - Literals.REACTOR_DECL__NAME - ); - // Continue checks, but without any superclasses. - superClasses = new LinkedHashSet<>(); + // // Report error if this reaction is part of a cycle. + Set> cycles = this.info.topologyCycles(); + Reactor reactor = ASTUtils.getEnclosingReactor(reaction); + boolean reactionInCycle = false; + for (NamedInstance it : cycles) { + if (it.getDefinition().equals(reaction)) { + reactionInCycle = true; + break; + } + } + if (reactionInCycle) { + // Report involved triggers. + List trigs = new ArrayList<>(); + for (TriggerRef t : reaction.getTriggers()) { + if (!(t instanceof VarRef)) { + continue; + } + VarRef tVarRef = (VarRef) t; + boolean triggerExistsInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(tVarRef.getVariable())) { + triggerExistsInCycle = true; + break; + } } - - if (reactor.getHost() != null) { - if (!reactor.isFederated()) { - error( - "Cannot assign a host to reactor '" + reactor.getName() + - "' because it is not federated.", - Literals.REACTOR__HOST - ); - } + if (triggerExistsInCycle) { + trigs.add(toOriginalText(tVarRef)); + } + } + if (trigs.size() > 0) { + error( + String.format( + "Reaction triggers involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", trigs)), + Literals.REACTION__TRIGGERS); + } + + // Report involved sources. + List sources = new ArrayList<>(); + for (VarRef t : reaction.getSources()) { + boolean sourceExistInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(t.getVariable())) { + sourceExistInCycle = true; + break; + } } - - List variables = new ArrayList<>(); - variables.addAll(reactor.getInputs()); - variables.addAll(reactor.getOutputs()); - variables.addAll(reactor.getActions()); - variables.addAll(reactor.getTimers()); - - if (!reactor.getSuperClasses().isEmpty() && !target.supportsInheritance()) { - error("The " + target.getDisplayName() + " target does not support reactor inheritance.", - Literals.REACTOR__SUPER_CLASSES); + if (sourceExistInCycle) { + sources.add(toOriginalText(t)); + } + } + if (sources.size() > 0) { + error( + String.format( + "Reaction sources involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", sources)), + Literals.REACTION__SOURCES); + } + + // Report involved effects. + List effects = new ArrayList<>(); + for (VarRef t : reaction.getEffects()) { + boolean effectExistInCycle = false; + for (NamedInstance c : cycles) { + if (c.getDefinition().equals(t.getVariable())) { + effectExistInCycle = true; + break; + } } + if (effectExistInCycle) { + effects.add(toOriginalText(t)); + } + } + if (effects.size() > 0) { + error( + String.format( + "Reaction effects involved in cyclic dependency in reactor %s: %s.", + reactor.getName(), String.join(", ", effects)), + Literals.REACTION__EFFECTS); + } + + if (trigs.size() + sources.size() == 0) { + error( + String.format( + "Cyclic dependency due to preceding reaction. Consider reordering reactions within" + + " reactor %s to avoid causality loop.", + reactor.getName()), + reaction.eContainer(), + Literals.REACTOR__REACTIONS, + reactor.getReactions().indexOf(reaction)); + } else if (effects.size() == 0) { + error( + String.format( + "Cyclic dependency due to succeeding reaction. Consider reordering reactions within" + + " reactor %s to avoid causality loop.", + reactor.getName()), + reaction.eContainer(), + Literals.REACTOR__REACTIONS, + reactor.getReactions().indexOf(reaction)); + } + // Not reporting reactions that are part of cycle _only_ due to reaction ordering. + // Moving them won't help solve the problem. + } + // FIXME: improve error message. + } - // Perform checks on super classes. - for (Reactor superClass : superClasses) { - HashSet conflicts = new HashSet<>(); - - // Detect input conflicts - checkConflict(superClass.getInputs(), reactor.getInputs(), variables, conflicts); - // Detect output conflicts - checkConflict(superClass.getOutputs(), reactor.getOutputs(), variables, conflicts); - // Detect output conflicts - checkConflict(superClass.getActions(), reactor.getActions(), variables, conflicts); - // Detect conflicts - for (Timer timer : superClass.getTimers()) { - List filteredVariables = new ArrayList<>(variables); - filteredVariables.removeIf(it -> reactor.getTimers().contains(it)); - if (hasNameConflict(timer, filteredVariables)) { - conflicts.add(timer); - } else { - variables.add(timer); - } - } - - // Report conflicts. - if (conflicts.size() > 0) { - List names = new ArrayList<>(); - for (Variable it : conflicts) { - names.add(it.getName()); - } - error( - String.format("Cannot extend %s due to the following conflicts: %s.", - superClass.getName(), String.join(",", names)), - Literals.REACTOR__SUPER_CLASSES - ); - } - } + public void checkReactorName(String name) throws IOException { + // Check for illegal names. + checkName(name, Literals.REACTOR_DECL__NAME); + // C++ reactors may not be called 'preamble' + if (this.target == Target.CPP && name.equalsIgnoreCase("preamble")) { + error("Reactor cannot be named '" + name + "'", Literals.REACTOR_DECL__NAME); + } + } + + @Check(CheckType.FAST) + public void checkReactor(Reactor reactor) throws IOException { + String fileName = FileUtil.nameWithoutExtension(reactor.eResource()); + + if (reactor.isFederated() || reactor.isMain()) { + // Do not allow multiple main/federated reactors. + TreeIterator iter = reactor.eResource().getAllContents(); + int nMain = countMainOrFederated(iter); + if (nMain > 1) { + EAttribute attribute = Literals.REACTOR__MAIN; if (reactor.isFederated()) { - if (!target.supportsFederated()) { - error("The " + target.getDisplayName() + " target does not support federated execution.", - Literals.REACTOR__FEDERATED); - } + attribute = Literals.REACTOR__FEDERATED; + } + error("Multiple definitions of main or federated reactor.", attribute); + } + + if (reactor.getName() != null && !reactor.getName().equals(fileName)) { + // Make sure that if the name is given, it matches the expected name. + error( + "Name of main reactor must match the file name (or be omitted).", + Literals.REACTOR_DECL__NAME); + } + + // check the reactor name indicated by the file name + // Skip this check if the file is named __synthetic0. This Name is used during testing, + // and we would get an unexpected error due to the '__' prefix otherwise. + if (!fileName.equals("__synthetic0")) { + checkReactorName(fileName); + } + } else { + // Not federated or main. + if (reactor.getName() == null) { + error("Reactor must be named.", Literals.REACTOR_DECL__NAME); + } else { + checkReactorName(reactor.getName()); + + TreeIterator iter = reactor.eResource().getAllContents(); + int nMain = countMainOrFederated(iter); + if (nMain > 0 && reactor.getName().equals(fileName)) { + error("Name conflict with main reactor.", Literals.REACTOR_DECL__NAME); + } + } + } - FedValidator.validateFederatedReactor(reactor, this.errorReporter); - } + Set superClasses = ASTUtils.superClasses(reactor); + if (superClasses == null) { + error( + "Problem with superclasses: Either they form a cycle or are not defined", + Literals.REACTOR_DECL__NAME); + // Continue checks, but without any superclasses. + superClasses = new LinkedHashSet<>(); } - /** - * Check if the requested serialization is supported. - */ - @Check(CheckType.FAST) - public void checkSerializer(Serializer serializer) { - boolean isValidSerializer = false; - for (SupportedSerializers method : SupportedSerializers.values()) { - if (method.name().equalsIgnoreCase(serializer.getType())){ - isValidSerializer = true; - } - } + if (reactor.getHost() != null) { + if (!reactor.isFederated()) { + error( + "Cannot assign a host to reactor '" + + reactor.getName() + + "' because it is not federated.", + Literals.REACTOR__HOST); + } + } - if (!isValidSerializer) { - error( - "Serializer can be " + Arrays.asList(SupportedSerializers.values()), - Literals.SERIALIZER__TYPE - ); - } + List variables = new ArrayList<>(); + variables.addAll(reactor.getInputs()); + variables.addAll(reactor.getOutputs()); + variables.addAll(reactor.getActions()); + variables.addAll(reactor.getTimers()); + + if (!reactor.getSuperClasses().isEmpty() && !target.supportsInheritance()) { + error( + "The " + target.getDisplayName() + " target does not support reactor inheritance.", + Literals.REACTOR__SUPER_CLASSES); } - @Check(CheckType.FAST) - public void checkState(StateVar stateVar) { - checkName(stateVar.getName(), Literals.STATE_VAR__NAME); - if (stateVar.getInit() != null && stateVar.getInit().getExprs().size() != 0) { - typeCheck(stateVar.getInit(), ASTUtils.getInferredType(stateVar), Literals.STATE_VAR__INIT); - } + // Perform checks on super classes. + for (Reactor superClass : superClasses) { + HashSet conflicts = new HashSet<>(); + + // Detect input conflicts + checkConflict(superClass.getInputs(), reactor.getInputs(), variables, conflicts); + // Detect output conflicts + checkConflict(superClass.getOutputs(), reactor.getOutputs(), variables, conflicts); + // Detect output conflicts + checkConflict(superClass.getActions(), reactor.getActions(), variables, conflicts); + // Detect conflicts + for (Timer timer : superClass.getTimers()) { + List filteredVariables = new ArrayList<>(variables); + filteredVariables.removeIf(it -> reactor.getTimers().contains(it)); + if (hasNameConflict(timer, filteredVariables)) { + conflicts.add(timer); + } else { + variables.add(timer); + } + } + + // Report conflicts. + if (conflicts.size() > 0) { + List names = new ArrayList<>(); + for (Variable it : conflicts) { + names.add(it.getName()); + } + error( + String.format( + "Cannot extend %s due to the following conflicts: %s.", + superClass.getName(), String.join(",", names)), + Literals.REACTOR__SUPER_CLASSES); + } + } - if (this.target.requiresTypes && ASTUtils.getInferredType(stateVar).isUndefined()) { - // Report if a type is missing - error("State must have a type.", Literals.STATE_VAR__TYPE); - } + if (reactor.isFederated()) { + if (!target.supportsFederated()) { + error( + "The " + target.getDisplayName() + " target does not support federated execution.", + Literals.REACTOR__FEDERATED); + } - if (isCBasedTarget() - && ASTUtils.isListInitializer(stateVar.getInit()) - && stateVar.getInit().getExprs().stream().anyMatch(it -> it instanceof ParameterReference)) { - // In C, if initialization is done with a list, elements cannot - // refer to parameters. - error("List items cannot refer to a parameter.", - Literals.STATE_VAR__INIT); - } + FedValidator.validateFederatedReactor(reactor, this.errorReporter); + } + } + + /** Check if the requested serialization is supported. */ + @Check(CheckType.FAST) + public void checkSerializer(Serializer serializer) { + boolean isValidSerializer = false; + for (SupportedSerializers method : SupportedSerializers.values()) { + if (method.name().equalsIgnoreCase(serializer.getType())) { + isValidSerializer = true; + } + } + if (!isValidSerializer) { + error( + "Serializer can be " + Arrays.asList(SupportedSerializers.values()), + Literals.SERIALIZER__TYPE); } + } - @Check(CheckType.FAST) - public void checkSTPOffset(STP stp) { - if (isCBasedTarget() && - this.info.overflowingSTP.contains(stp)) { - error( - "STP offset exceeds the maximum of " + - TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", - Literals.STP__VALUE); - } + @Check(CheckType.FAST) + public void checkState(StateVar stateVar) { + checkName(stateVar.getName(), Literals.STATE_VAR__NAME); + if (stateVar.getInit() != null && stateVar.getInit().getExprs().size() != 0) { + typeCheck(stateVar.getInit(), ASTUtils.getInferredType(stateVar), Literals.STATE_VAR__INIT); } - @Check(CheckType.FAST) - public void checkTargetDecl(TargetDecl target) throws IOException { - Optional targetOpt = Target.forName(target.getName()); - if (targetOpt.isEmpty()) { - error("Unrecognized target: " + target.getName(), - Literals.TARGET_DECL__NAME); - } else { - this.target = targetOpt.get(); - } - String lfFileName = FileUtil.nameWithoutExtension(target.eResource()); - if (Character.isDigit(lfFileName.charAt(0))) { - errorReporter.reportError("LF file names must not start with a number"); - } + if (this.target.requiresTypes && ASTUtils.getInferredType(stateVar).isUndefined()) { + // Report if a type is missing + error("State must have a type.", Literals.STATE_VAR__TYPE); } - /** - * Check for consistency of the target properties, which are - * defined as KeyValuePairs. - * - * @param targetProperties The target properties defined - * in the current Lingua Franca program. - */ - @Check(CheckType.EXPENSIVE) - public void checkTargetProperties(KeyValuePairs targetProperties) { - validateFastTargetProperty(targetProperties); - validateClockSyncTargetProperties(targetProperties); - validateSchedulerTargetProperties(targetProperties); - validateRos2TargetProperties(targetProperties); - validateKeepalive(targetProperties); - } - - private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { - List properties = targetProperties.getPairs().stream() + if (isCBasedTarget() + && ASTUtils.isListInitializer(stateVar.getInit()) + && stateVar.getInit().getExprs().stream() + .anyMatch(it -> it instanceof ParameterReference)) { + // In C, if initialization is done with a list, elements cannot + // refer to parameters. + error("List items cannot refer to a parameter.", Literals.STATE_VAR__INIT); + } + } + + @Check(CheckType.FAST) + public void checkSTPOffset(STP stp) { + if (isCBasedTarget() && this.info.overflowingSTP.contains(stp)) { + error( + "STP offset exceeds the maximum of " + TimeValue.MAX_LONG_DEADLINE + " nanoseconds.", + Literals.STP__VALUE); + } + } + + @Check(CheckType.FAST) + public void checkTargetDecl(TargetDecl target) throws IOException { + Optional targetOpt = Target.forName(target.getName()); + if (targetOpt.isEmpty()) { + error("Unrecognized target: " + target.getName(), Literals.TARGET_DECL__NAME); + } else { + this.target = targetOpt.get(); + } + String lfFileName = FileUtil.nameWithoutExtension(target.eResource()); + if (Character.isDigit(lfFileName.charAt(0))) { + errorReporter.reportError("LF file names must not start with a number"); + } + } + + /** + * Check for consistency of the target properties, which are defined as KeyValuePairs. + * + * @param targetProperties The target properties defined in the current Lingua Franca program. + */ + @Check(CheckType.EXPENSIVE) + public void checkTargetProperties(KeyValuePairs targetProperties) { + validateFastTargetProperty(targetProperties); + validateClockSyncTargetProperties(targetProperties); + validateSchedulerTargetProperties(targetProperties); + validateRos2TargetProperties(targetProperties); + validateKeepalive(targetProperties); + } + + private KeyValuePair getKeyValuePair(KeyValuePairs targetProperties, TargetProperty property) { + List properties = + targetProperties.getPairs().stream() .filter(pair -> pair.getName().equals(property.description)) .toList(); - assert (properties.size() <= 1); - return properties.size() > 0 ? properties.get(0) : null; - } - private void validateFastTargetProperty(KeyValuePairs targetProperties) { - KeyValuePair fastTargetProperty = getKeyValuePair(targetProperties, TargetProperty.FAST); - - if (fastTargetProperty != null) { - // Check for federated - for (Reactor reactor : info.model.getReactors()) { - // Check to see if the program has a federated reactor - if (reactor.isFederated()) { - error( - "The fast target property is incompatible with federated programs.", - fastTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - break; - } - } + assert (properties.size() <= 1); + return properties.size() > 0 ? properties.get(0) : null; + } - // Check for physical actions - for (Reactor reactor : info.model.getReactors()) { - // Check to see if the program has a physical action in a reactor - for (Action action : reactor.getActions()) { - if (action.getOrigin().equals(ActionOrigin.PHYSICAL)) { - error( - "The fast target property is incompatible with physical actions.", - fastTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - break; - } - } - } - } - } - - private void validateClockSyncTargetProperties(KeyValuePairs targetProperties) { - KeyValuePair clockSyncTargetProperty = getKeyValuePair(targetProperties, TargetProperty.CLOCK_SYNC); + private void validateFastTargetProperty(KeyValuePairs targetProperties) { + KeyValuePair fastTargetProperty = getKeyValuePair(targetProperties, TargetProperty.FAST); - if (clockSyncTargetProperty != null) { - boolean federatedExists = false; - for (Reactor reactor : info.model.getReactors()) { - if (reactor.isFederated()) { - federatedExists = true; - } - } - if (!federatedExists) { - warning( - "The clock-sync target property is incompatible with non-federated programs.", - clockSyncTargetProperty, - Literals.KEY_VALUE_PAIR__NAME - ); - } + if (fastTargetProperty != null) { + // Check for federated + for (Reactor reactor : info.model.getReactors()) { + // Check to see if the program has a federated reactor + if (reactor.isFederated()) { + error( + "The fast target property is incompatible with federated programs.", + fastTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + break; + } + } + + // Check for physical actions + for (Reactor reactor : info.model.getReactors()) { + // Check to see if the program has a physical action in a reactor + for (Action action : reactor.getActions()) { + if (action.getOrigin().equals(ActionOrigin.PHYSICAL)) { + error( + "The fast target property is incompatible with physical actions.", + fastTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + break; + } } + } } + } - private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { - KeyValuePair schedulerTargetProperty = getKeyValuePair(targetProperties, TargetProperty.SCHEDULER); - if (schedulerTargetProperty != null) { - String schedulerName = ASTUtils.elementToSingleString(schedulerTargetProperty.getValue()); - try { - if (!TargetProperty.SchedulerOption.valueOf(schedulerName) - .prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - // Filter reactors that contain at least one reaction that - // has a deadline handler. - if (info.model.getReactors().stream().anyMatch( - // Filter reactors that contain at least one reaction that - // has a deadline handler. - reactor -> ASTUtils.allReactions(reactor).stream().anyMatch( - reaction -> reaction.getDeadline() != null - )) - ) { - warning("This program contains deadlines, but the chosen " - + schedulerName - + " scheduler does not prioritize reaction execution " - + "based on deadlines. This might result in a sub-optimal " - + "scheduling.", schedulerTargetProperty, - Literals.KEY_VALUE_PAIR__VALUE); - } - } - } catch (IllegalArgumentException e) { - // the given scheduler is invalid, but this is already checked by - // checkTargetProperties - } - } - } + private void validateClockSyncTargetProperties(KeyValuePairs targetProperties) { + KeyValuePair clockSyncTargetProperty = + getKeyValuePair(targetProperties, TargetProperty.CLOCK_SYNC); - private void validateKeepalive(KeyValuePairs targetProperties) { - KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); - if (keepalive != null && target == Target.CPP) { - warning("The keepalive property is inferred automatically by the C++ " + - "runtime and the value given here is ignored", keepalive, Literals.KEY_VALUE_PAIR__NAME); - } + if (clockSyncTargetProperty != null) { + boolean federatedExists = false; + for (Reactor reactor : info.model.getReactors()) { + if (reactor.isFederated()) { + federatedExists = true; + } + } + if (!federatedExists) { + warning( + "The clock-sync target property is incompatible with non-federated programs.", + clockSyncTargetProperty, + Literals.KEY_VALUE_PAIR__NAME); + } } - - private void validateRos2TargetProperties(KeyValuePairs targetProperties) { - KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); - KeyValuePair ros2Dependencies = getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); - if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { + } + + private void validateSchedulerTargetProperties(KeyValuePairs targetProperties) { + KeyValuePair schedulerTargetProperty = + getKeyValuePair(targetProperties, TargetProperty.SCHEDULER); + if (schedulerTargetProperty != null) { + String schedulerName = ASTUtils.elementToSingleString(schedulerTargetProperty.getValue()); + try { + if (!TargetProperty.SchedulerOption.valueOf(schedulerName).prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + // Filter reactors that contain at least one reaction that + // has a deadline handler. + if (info.model.getReactors().stream() + .anyMatch( + // Filter reactors that contain at least one reaction that + // has a deadline handler. + reactor -> + ASTUtils.allReactions(reactor).stream() + .anyMatch(reaction -> reaction.getDeadline() != null))) { warning( - "Ignoring ros2-dependencies as ros2 compilation is disabled", - ros2Dependencies, - Literals.KEY_VALUE_PAIR__NAME - ); + "This program contains deadlines, but the chosen " + + schedulerName + + " scheduler does not prioritize reaction execution " + + "based on deadlines. This might result in a sub-optimal " + + "scheduling.", + schedulerTargetProperty, + Literals.KEY_VALUE_PAIR__VALUE); + } } + } catch (IllegalArgumentException e) { + // the given scheduler is invalid, but this is already checked by + // checkTargetProperties + } } - - @Check(CheckType.FAST) - public void checkTimer(Timer timer) { - checkName(timer.getName(), Literals.VARIABLE__NAME); - checkExpressionIsTime(timer.getOffset(), Literals.TIMER__OFFSET); - checkExpressionIsTime(timer.getPeriod(), Literals.TIMER__PERIOD); + } + + private void validateKeepalive(KeyValuePairs targetProperties) { + KeyValuePair keepalive = getKeyValuePair(targetProperties, TargetProperty.KEEPALIVE); + if (keepalive != null && target == Target.CPP) { + warning( + "The keepalive property is inferred automatically by the C++ " + + "runtime and the value given here is ignored", + keepalive, + Literals.KEY_VALUE_PAIR__NAME); } - - @Check(CheckType.FAST) - public void checkType(Type type) { - // FIXME: disallow the use of generics in C - if (this.target == Target.Python) { - if (type != null) { - error( - "Types are not allowed in the Python target", - Literals.TYPE__ID - ); - } - } + } + + private void validateRos2TargetProperties(KeyValuePairs targetProperties) { + KeyValuePair ros2 = getKeyValuePair(targetProperties, TargetProperty.ROS2); + KeyValuePair ros2Dependencies = + getKeyValuePair(targetProperties, TargetProperty.ROS2_DEPENDENCIES); + if (ros2Dependencies != null && (ros2 == null || !ASTUtils.toBoolean(ros2.getValue()))) { + warning( + "Ignoring ros2-dependencies as ros2 compilation is disabled", + ros2Dependencies, + Literals.KEY_VALUE_PAIR__NAME); } - - @Check(CheckType.FAST) - public void checkVarRef(VarRef varRef) { - // check correct usage of interleaved - if (varRef.isInterleaved()) { - var supportedTargets = List.of(Target.CPP, Target.Python, Target.Rust); - if (!supportedTargets.contains(this.target) && !isCBasedTarget()) { - error("This target does not support interleaved port references.", Literals.VAR_REF__INTERLEAVED); - } - if (!(varRef.eContainer() instanceof Connection)) { - error("interleaved can only be used in connections.", Literals.VAR_REF__INTERLEAVED); - } - - if (varRef.getVariable() instanceof Port) { - // This test only works correctly if the variable is actually a port. If it is not a port, other - // validator rules will produce error messages. - if (varRef.getContainer() == null || varRef.getContainer().getWidthSpec() == null || - ((Port) varRef.getVariable()).getWidthSpec() == null - ) { - error("interleaved can only be used for multiports contained within banks.", Literals.VAR_REF__INTERLEAVED); - } - } - } + } + + @Check(CheckType.FAST) + public void checkTimer(Timer timer) { + checkName(timer.getName(), Literals.VARIABLE__NAME); + checkExpressionIsTime(timer.getOffset(), Literals.TIMER__OFFSET); + checkExpressionIsTime(timer.getPeriod(), Literals.TIMER__PERIOD); + } + + @Check(CheckType.FAST) + public void checkType(Type type) { + // FIXME: disallow the use of generics in C + if (this.target == Target.Python) { + if (type != null) { + error("Types are not allowed in the Python target", Literals.TYPE__ID); + } } - - /** - * Check whether an attribute is supported - * and the validity of the attribute. - * - * @param attr The attribute being checked - */ - @Check(CheckType.FAST) - public void checkAttributes(Attribute attr) { - String name = attr.getAttrName().toString(); - AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); - if (spec == null) { - error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); - return; - } - // Check the validity of the attribute. - spec.check(this, attr); + } + + @Check(CheckType.FAST) + public void checkVarRef(VarRef varRef) { + // check correct usage of interleaved + if (varRef.isInterleaved()) { + var supportedTargets = List.of(Target.CPP, Target.Python, Target.Rust); + if (!supportedTargets.contains(this.target) && !isCBasedTarget()) { + error( + "This target does not support interleaved port references.", + Literals.VAR_REF__INTERLEAVED); + } + if (!(varRef.eContainer() instanceof Connection)) { + error("interleaved can only be used in connections.", Literals.VAR_REF__INTERLEAVED); + } + + if (varRef.getVariable() instanceof Port) { + // This test only works correctly if the variable is actually a port. If it is not a port, + // other + // validator rules will produce error messages. + if (varRef.getContainer() == null + || varRef.getContainer().getWidthSpec() == null + || ((Port) varRef.getVariable()).getWidthSpec() == null) { + error( + "interleaved can only be used for multiports contained within banks.", + Literals.VAR_REF__INTERLEAVED); + } + } } - - @Check(CheckType.FAST) - public void checkWidthSpec(WidthSpec widthSpec) { - if (!this.target.supportsMultiports()) { - error("Multiports and banks are currently not supported by the given target.", + } + + /** + * Check whether an attribute is supported and the validity of the attribute. + * + * @param attr The attribute being checked + */ + @Check(CheckType.FAST) + public void checkAttributes(Attribute attr) { + String name = attr.getAttrName().toString(); + AttributeSpec spec = AttributeSpec.ATTRIBUTE_SPECS_BY_NAME.get(name); + if (spec == null) { + error("Unknown attribute.", Literals.ATTRIBUTE__ATTR_NAME); + return; + } + // Check the validity of the attribute. + spec.check(this, attr); + } + + @Check(CheckType.FAST) + public void checkWidthSpec(WidthSpec widthSpec) { + if (!this.target.supportsMultiports()) { + error( + "Multiports and banks are currently not supported by the given target.", + Literals.WIDTH_SPEC__TERMS); + } else { + for (WidthTerm term : widthSpec.getTerms()) { + if (term.getParameter() != null) { + if (!this.target.supportsParameterizedWidths()) { + error( + "Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); - } else { - for (WidthTerm term : widthSpec.getTerms()) { - if (term.getParameter() != null) { - if (!this.target.supportsParameterizedWidths()) { - error("Parameterized widths are not supported by this target.", Literals.WIDTH_SPEC__TERMS); - } - } else if (term.getPort() != null) { - // Widths given with {@code widthof()} are not supported (yet?). - // This feature is currently only used for after delays. - error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); - } else if (term.getCode() != null) { - if (this.target != Target.CPP) { - error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); - } - } else if (term.getWidth() < 0) { - error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); - } - } + } + } else if (term.getPort() != null) { + // Widths given with {@code widthof()} are not supported (yet?). + // This feature is currently only used for after delays. + error("widthof is not supported.", Literals.WIDTH_SPEC__TERMS); + } else if (term.getCode() != null) { + if (this.target != Target.CPP) { + error("This target does not support width given as code.", Literals.WIDTH_SPEC__TERMS); + } + } else if (term.getWidth() < 0) { + error("Width must be a positive integer.", Literals.WIDTH_SPEC__TERMS); } + } } - - @Check(CheckType.FAST) - public void checkReactorIconAttribute(Reactor reactor) { - var path = AttributeUtils.getIconPath(reactor); - if (path != null) { - var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); - // Check file extension - var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); - var extensionStrart = path.lastIndexOf("."); - var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; - if (!validExtensions.contains(extension.toLowerCase())) { - warning("File extension '" + extension + "' is not supported. Provide any of: " + String.join(", ", validExtensions), - param, Literals.ATTR_PARM__VALUE); - return; - } - - // Check file location - var iconLocation = FileUtil.locateFile(path, reactor.eResource()); - if (iconLocation == null) { - warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); - } - if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) && !(new File(iconLocation.getPath()).exists())) { - warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); - } - } + } + + @Check(CheckType.FAST) + public void checkReactorIconAttribute(Reactor reactor) { + var path = AttributeUtils.getIconPath(reactor); + if (path != null) { + var param = AttributeUtils.findAttributeByName(reactor, "icon").getAttrParms().get(0); + // Check file extension + var validExtensions = Set.of("bmp", "png", "gif", "ico", "jpeg"); + var extensionStrart = path.lastIndexOf("."); + var extension = extensionStrart != -1 ? path.substring(extensionStrart + 1) : ""; + if (!validExtensions.contains(extension.toLowerCase())) { + warning( + "File extension '" + + extension + + "' is not supported. Provide any of: " + + String.join(", ", validExtensions), + param, + Literals.ATTR_PARM__VALUE); + return; + } + + // Check file location + var iconLocation = FileUtil.locateFile(path, reactor.eResource()); + if (iconLocation == null) { + warning("Cannot locate icon file.", param, Literals.ATTR_PARM__VALUE); + } + if (("file".equals(iconLocation.getScheme()) || iconLocation.getScheme() == null) + && !(new File(iconLocation.getPath()).exists())) { + warning("Icon does not exist.", param, Literals.ATTR_PARM__VALUE); + } } - - @Check(CheckType.FAST) - public void checkInitialMode(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - long initialModesCount = reactor.getModes().stream().filter(m -> m.isInitial()).count(); - if (initialModesCount == 0) { - error("Every modal reactor requires one initial mode.", Literals.REACTOR__MODES, 0); - } else if (initialModesCount > 1) { - reactor.getModes().stream().filter(m -> m.isInitial()).skip(1).forEach(m -> { - error("A modal reactor can only have one initial mode.", - Literals.REACTOR__MODES, reactor.getModes().indexOf(m)); + } + + @Check(CheckType.FAST) + public void checkInitialMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + long initialModesCount = reactor.getModes().stream().filter(m -> m.isInitial()).count(); + if (initialModesCount == 0) { + error("Every modal reactor requires one initial mode.", Literals.REACTOR__MODES, 0); + } else if (initialModesCount > 1) { + reactor.getModes().stream() + .filter(m -> m.isInitial()) + .skip(1) + .forEach( + m -> { + error( + "A modal reactor can only have one initial mode.", + Literals.REACTOR__MODES, + reactor.getModes().indexOf(m)); }); - } + } + } + } + + @Check(CheckType.FAST) + public void checkModeStateNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getStateVars().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var stateVar : mode.getStateVars()) { + if (names.contains(stateVar.getName())) { + error( + String.format( + "Duplicate state variable '%s'. (State variables are currently scoped on" + + " reactor level not modes)", + stateVar.getName()), + stateVar, + Literals.STATE_VAR__NAME); + } + names.add(stateVar.getName()); } + } } - - @Check(CheckType.FAST) - public void checkModeStateNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getStateVars().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var stateVar : mode.getStateVars()) { - if (names.contains(stateVar.getName())) { - error(String.format("Duplicate state variable '%s'. (State variables are currently scoped on reactor level not modes)", - stateVar.getName()), stateVar, Literals.STATE_VAR__NAME); - } - names.add(stateVar.getName()); - } - } + } + + @Check(CheckType.FAST) + public void checkModeTimerNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getTimers().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var timer : mode.getTimers()) { + if (names.contains(timer.getName())) { + error( + String.format( + "Duplicate Timer '%s'. (Timers are currently scoped on reactor level not" + + " modes)", + timer.getName()), + timer, + Literals.VARIABLE__NAME); + } + names.add(timer.getName()); } + } } - - @Check(CheckType.FAST) - public void checkModeTimerNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getTimers().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var timer : mode.getTimers()) { - if (names.contains(timer.getName())) { - error(String.format("Duplicate Timer '%s'. (Timers are currently scoped on reactor level not modes)", - timer.getName()), timer, Literals.VARIABLE__NAME); - } - names.add(timer.getName()); - } - } + } + + @Check(CheckType.FAST) + public void checkModeActionNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var action : mode.getActions()) { + if (names.contains(action.getName())) { + error( + String.format( + "Duplicate Action '%s'. (Actions are currently scoped on reactor level not" + + " modes)", + action.getName()), + action, + Literals.VARIABLE__NAME); + } + names.add(action.getName()); } + } } - - @Check(CheckType.FAST) - public void checkModeActionNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var action : mode.getActions()) { - if (names.contains(action.getName())) { - error(String.format("Duplicate Action '%s'. (Actions are currently scoped on reactor level not modes)", - action.getName()), action, Literals.VARIABLE__NAME); - } - names.add(action.getName()); - } - } + } + + @Check(CheckType.FAST) + public void checkModeInstanceNamespace(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var names = new ArrayList(); + reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); + for (var mode : reactor.getModes()) { + for (var instantiation : mode.getInstantiations()) { + if (names.contains(instantiation.getName())) { + error( + String.format( + "Duplicate Instantiation '%s'. (Instantiations are currently scoped on reactor" + + " level not modes)", + instantiation.getName()), + instantiation, + Literals.INSTANTIATION__NAME); + } + names.add(instantiation.getName()); } + } } - - @Check(CheckType.FAST) - public void checkModeInstanceNamespace(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var names = new ArrayList(); - reactor.getActions().stream().map(it -> it.getName()).forEach(it -> names.add(it)); - for (var mode : reactor.getModes()) { - for (var instantiation : mode.getInstantiations()) { - if (names.contains(instantiation.getName())) { - error(String.format("Duplicate Instantiation '%s'. (Instantiations are currently scoped on reactor level not modes)", - instantiation.getName()), instantiation, Literals.INSTANTIATION__NAME); - } - names.add(instantiation.getName()); - } + } + + @Check(CheckType.FAST) + public void checkMissingStateResetInMode(Reactor reactor) { + if (!reactor.getModes().isEmpty()) { + var resetModes = new HashSet(); + // Collect all modes that may be reset + for (var m : reactor.getModes()) { + for (var r : m.getReactions()) { + for (var e : r.getEffects()) { + if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { + resetModes.add((Mode) e.getVariable()); } + } } - } - - @Check(CheckType.FAST) - public void checkMissingStateResetInMode(Reactor reactor) { - if (!reactor.getModes().isEmpty()) { - var resetModes = new HashSet(); - // Collect all modes that may be reset - for (var m : reactor.getModes()) { - for (var r : m.getReactions()) { - for (var e : r.getEffects()) { - if (e.getVariable() instanceof Mode && e.getTransition() != ModeTransition.HISTORY) { - resetModes.add((Mode) e.getVariable()); - } - } - } + } + for (var m : resetModes) { + // Check state variables in this mode + if (!m.getStateVars().isEmpty()) { + var hasResetReaction = + m.getReactions().stream() + .anyMatch( + r -> + r.getTriggers().stream() + .anyMatch( + t -> + (t instanceof BuiltinTriggerRef + && ((BuiltinTriggerRef) t).getType() + == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + for (var s : m.getStateVars()) { + if (!s.isReset()) { + error( + "State variable is not reset upon mode entry. It is neither marked for" + + " automatic reset nor is there a reset reaction.", + m, + Literals.MODE__STATE_VARS, + m.getStateVars().indexOf(s)); + } } - for (var m : resetModes) { - // Check state variables in this mode - if (!m.getStateVars().isEmpty()) { - var hasResetReaction = m.getReactions().stream().anyMatch( - r -> r.getTriggers().stream().anyMatch( - t -> (t instanceof BuiltinTriggerRef && - ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); - if (!hasResetReaction) { - for (var s : m.getStateVars()) { - if (!s.isReset()) { - error("State variable is not reset upon mode entry. It is neither marked for automatic reset nor is there a reset reaction.", - m, Literals.MODE__STATE_VARS, m.getStateVars().indexOf(s)); - } - } - } + } + } + // Check state variables in instantiated reactors + if (!m.getInstantiations().isEmpty()) { + for (var i : m.getInstantiations()) { + var error = new LinkedHashSet(); + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty()) { + var check = toCheck.pop(); + checked.add(check); + if (!check.getStateVars().isEmpty()) { + var hasResetReaction = + check.getReactions().stream() + .anyMatch( + r -> + r.getTriggers().stream() + .anyMatch( + t -> + (t instanceof BuiltinTriggerRef + && ((BuiltinTriggerRef) t).getType() + == BuiltinTrigger.RESET))); + if (!hasResetReaction) { + // Add state vars that are not self-resetting to the error + check.getStateVars().stream() + .filter(s -> !s.isReset()) + .forEachOrdered(error::add); } - // Check state variables in instantiated reactors - if (!m.getInstantiations().isEmpty()) { - for (var i : m.getInstantiations()) { - var error = new LinkedHashSet(); - var checked = new HashSet(); - var toCheck = new LinkedList(); - toCheck.add((Reactor) i.getReactorClass()); - while (!toCheck.isEmpty()) { - var check = toCheck.pop(); - checked.add(check); - if (!check.getStateVars().isEmpty()) { - var hasResetReaction = check.getReactions().stream().anyMatch( - r -> r.getTriggers().stream().anyMatch( - t -> (t instanceof BuiltinTriggerRef && - ((BuiltinTriggerRef) t).getType() == BuiltinTrigger.RESET))); - if (!hasResetReaction) { - // Add state vars that are not self-resetting to the error - check.getStateVars().stream().filter(s -> !s.isReset()).forEachOrdered(error::add); - } - } - // continue with inner - for (var innerInstance : check.getInstantiations()) { - var next = (Reactor) innerInstance.getReactorClass(); - if (!checked.contains(next)) { - toCheck.push(next); - } - } - } - if (!error.isEmpty()) { - error("This reactor contains state variables that are not reset upon mode entry: " - + error.stream().map(e -> e.getName() + " in " - + ASTUtils.getEnclosingReactor(e).getName()).collect(Collectors.joining(", ")) - + ".\nThe state variables are neither marked for automatic reset nor have a dedicated reset reaction. " - + "It is unsafe to instantiate this reactor inside a mode entered with reset.", - m, Literals.MODE__INSTANTIATIONS, - m.getInstantiations().indexOf(i)); - } - } + } + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); } + } + } + if (!error.isEmpty()) { + error( + "This reactor contains state variables that are not reset upon mode entry: " + + error.stream() + .map( + e -> e.getName() + " in " + ASTUtils.getEnclosingReactor(e).getName()) + .collect(Collectors.joining(", ")) + + ".\n" + + "The state variables are neither marked for automatic reset nor have a" + + " dedicated reset reaction. It is unsafe to instantiate this reactor inside" + + " a mode entered with reset.", + m, + Literals.MODE__INSTANTIATIONS, + m.getInstantiations().indexOf(i)); } + } } + } } - - @Check(CheckType.FAST) - public void checkStateResetWithoutInitialValue(StateVar state) { - if (state.isReset() && (state.getInit() == null || state.getInit().getExprs().isEmpty())) { - error("The state variable can not be automatically reset without an initial value.", state, Literals.STATE_VAR__RESET); - } + } + + @Check(CheckType.FAST) + public void checkStateResetWithoutInitialValue(StateVar state) { + if (state.isReset() && (state.getInit() == null || state.getInit().getExprs().isEmpty())) { + error( + "The state variable can not be automatically reset without an initial value.", + state, + Literals.STATE_VAR__RESET); } - - @Check(CheckType.FAST) - public void checkUnspecifiedTransitionType(Reaction reaction) { - for (var effect : reaction.getEffects()) { - var variable = effect.getVariable(); - if (variable instanceof Mode) { - // The transition type is always set to default by Xtext. - // Hence, check if there is an explicit node for the transition type in the AST. - var transitionAssignment = NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); - if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. - var mode = (Mode) variable; - // Check if reset or history transition would make a difference. - var makesDifference = !mode.getStateVars().isEmpty() - || !mode.getTimers().isEmpty() - || !mode.getActions().isEmpty() - || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); - if (!makesDifference && !mode.getInstantiations().isEmpty()) { - // Also check instantiated reactors - for (var i : mode.getInstantiations()) { - var checked = new HashSet(); - var toCheck = new LinkedList(); - toCheck.add((Reactor) i.getReactorClass()); - while (!toCheck.isEmpty() && !makesDifference) { - var check = toCheck.pop(); - checked.add(check); - - makesDifference |= !check.getModes().isEmpty() - || !ASTUtils.allStateVars(check).isEmpty() - || !ASTUtils.allTimers(check).isEmpty() - || !ASTUtils.allActions(check).isEmpty() - || ASTUtils.allConnections(check).stream().anyMatch(c -> c.getDelay() != null); - - // continue with inner - for (var innerInstance : check.getInstantiations()) { - var next = (Reactor) innerInstance.getReactorClass(); - if (!checked.contains(next)) { - toCheck.push(next); - } - } - } - } - } - if (makesDifference) { - warning("You should specify a transition type! " - + "Reset and history transitions have different effects on this target mode. " - + "Currently, a reset type is implicitly assumed.", - reaction, Literals.REACTION__EFFECTS, reaction.getEffects().indexOf(effect)); - } + } + + @Check(CheckType.FAST) + public void checkUnspecifiedTransitionType(Reaction reaction) { + for (var effect : reaction.getEffects()) { + var variable = effect.getVariable(); + if (variable instanceof Mode) { + // The transition type is always set to default by Xtext. + // Hence, check if there is an explicit node for the transition type in the AST. + var transitionAssignment = + NodeModelUtils.findNodesForFeature((EObject) effect, Literals.VAR_REF__TRANSITION); + if (transitionAssignment.isEmpty()) { // Transition type not explicitly specified. + var mode = (Mode) variable; + // Check if reset or history transition would make a difference. + var makesDifference = + !mode.getStateVars().isEmpty() + || !mode.getTimers().isEmpty() + || !mode.getActions().isEmpty() + || mode.getConnections().stream().anyMatch(c -> c.getDelay() != null); + if (!makesDifference && !mode.getInstantiations().isEmpty()) { + // Also check instantiated reactors + for (var i : mode.getInstantiations()) { + var checked = new HashSet(); + var toCheck = new LinkedList(); + toCheck.add((Reactor) i.getReactorClass()); + while (!toCheck.isEmpty() && !makesDifference) { + var check = toCheck.pop(); + checked.add(check); + + makesDifference |= + !check.getModes().isEmpty() + || !ASTUtils.allStateVars(check).isEmpty() + || !ASTUtils.allTimers(check).isEmpty() + || !ASTUtils.allActions(check).isEmpty() + || ASTUtils.allConnections(check).stream() + .anyMatch(c -> c.getDelay() != null); + + // continue with inner + for (var innerInstance : check.getInstantiations()) { + var next = (Reactor) innerInstance.getReactorClass(); + if (!checked.contains(next)) { + toCheck.push(next); + } } + } } + } + if (makesDifference) { + warning( + "You should specify a transition type! " + + "Reset and history transitions have different effects on this target mode. " + + "Currently, a reset type is implicitly assumed.", + reaction, + Literals.REACTION__EFFECTS, + reaction.getEffects().indexOf(effect)); + } } + } + } + } + + ////////////////////////////////////////////////////////////// + //// Public methods. + + /** Return the error reporter for this validator. */ + public ValidatorErrorReporter getErrorReporter() { + return this.errorReporter; + } + + /** Implementation required by xtext to report validation errors. */ + @Override + public ValidationMessageAcceptor getMessageAcceptor() { + return messageAcceptor == null ? this : messageAcceptor; + } + + /** Return a list of error messages for the target declaration. */ + public List getTargetPropertyErrors() { + return this.targetPropertyErrors; + } + + ////////////////////////////////////////////////////////////// + //// Protected methods. + + /** Generate an error message for an AST node. */ + @Override + protected void error(java.lang.String message, org.eclipse.emf.ecore.EStructuralFeature feature) { + super.error(message, feature); + } + + ////////////////////////////////////////////////////////////// + //// Private methods. + + /** + * For each input, report a conflict if: 1) the input exists and the type doesn't match; or 2) the + * input has a name clash with variable that is not an input. + * + * @param superVars List of typed variables of a particular kind (i.e., inputs, outputs, or + * actions), found in a super class. + * @param sameKind Typed variables of the same kind, found in the subclass. + * @param allOwn Accumulator of non-conflicting variables incorporated in the subclass. + * @param conflicts Set of variables that are in conflict, to be used by this function to report + * conflicts. + */ + private void checkConflict( + EList superVars, EList sameKind, List allOwn, HashSet conflicts) { + for (T superVar : superVars) { + T match = null; + for (T it : sameKind) { + if (it.getName().equals(superVar.getName())) { + match = it; + break; + } + } + List rest = new ArrayList<>(allOwn); + rest.removeIf(it -> sameKind.contains(it)); + + if ((match != null && superVar.getType() != match.getType()) + || hasNameConflict(superVar, rest)) { + conflicts.add(superVar); + } else { + allOwn.add(superVar); + } + } + } + + /** + * Check the name of a feature for illegal substrings such as reserved identifiers and names with + * double leading underscores. + * + * @param name The name. + * @param feature The feature containing the name (for error reporting). + */ + private void checkName(String name, EStructuralFeature feature) { + + // Raises an error if the string starts with two underscores. + if (name.length() >= 2 && name.substring(0, 2).equals("__")) { + error(UNDERSCORE_MESSAGE + name, feature); } - ////////////////////////////////////////////////////////////// - //// Public methods. - - /** - * Return the error reporter for this validator. - */ - public ValidatorErrorReporter getErrorReporter() { - return this.errorReporter; - } - - /** - * Implementation required by xtext to report validation errors. - */ - @Override - public ValidationMessageAcceptor getMessageAcceptor() { - return messageAcceptor == null ? this : messageAcceptor; - } - - /** - * Return a list of error messages for the target declaration. - */ - public List getTargetPropertyErrors() { - return this.targetPropertyErrors; - } - - ////////////////////////////////////////////////////////////// - //// Protected methods. - - /** - * Generate an error message for an AST node. - */ - @Override - protected void error(java.lang.String message, - org.eclipse.emf.ecore.EStructuralFeature feature) { - super.error(message, feature); - } - - ////////////////////////////////////////////////////////////// - //// Private methods. - - /** - * For each input, report a conflict if: - * 1) the input exists and the type doesn't match; or - * 2) the input has a name clash with variable that is not an input. - * @param superVars List of typed variables of a particular kind (i.e., - * inputs, outputs, or actions), found in a super class. - * @param sameKind Typed variables of the same kind, found in the subclass. - * @param allOwn Accumulator of non-conflicting variables incorporated in the - * subclass. - * @param conflicts Set of variables that are in conflict, to be used by this - * function to report conflicts. - */ - private void checkConflict ( - EList superVars, EList sameKind, List allOwn, HashSet conflicts - ) { - for (T superVar : superVars) { - T match = null; - for (T it : sameKind) { - if (it.getName().equals(superVar.getName())) { - match = it; - break; - } - } - List rest = new ArrayList<>(allOwn); - rest.removeIf(it -> sameKind.contains(it)); + if (this.target.isReservedIdent(name)) { + error(RESERVED_MESSAGE + name, feature); + } - if ((match != null && superVar.getType() != match.getType()) || hasNameConflict(superVar, rest)) { - conflicts.add(superVar); - } else { - allOwn.add(superVar); - } - } + if (this.target == Target.TS) { + // "actions" is a reserved word within a TS reaction + if (name.equals("actions")) { + error(ACTIONS_MESSAGE + name, feature); + } + } + } + + /** + * Check that the initializer is compatible with the type. Note that if the type is inferred it + * will necessarily be compatible so this method is not harmful. + */ + public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { + if (init == null) { + return; } - /** - * Check the name of a feature for illegal substrings such as reserved - * identifiers and names with double leading underscores. - * @param name The name. - * @param feature The feature containing the name (for error reporting). - */ - private void checkName(String name, EStructuralFeature feature) { + // TODO: + // type is list => init is list + // type is fixed with size n => init is fixed with size n + // Specifically for C: list can only be literal or time lists - // Raises an error if the string starts with two underscores. - if (name.length() >= 2 && name.substring(0, 2).equals("__")) { - error(UNDERSCORE_MESSAGE + name, feature); + if (type.isTime) { + if (type.isList) { + // list of times + var exprs = init.getExprs(); + if (exprs.isEmpty()) { + error("Expected at least one time value.", feature); + return; } - - if (this.target.isReservedIdent(name)) { - error(RESERVED_MESSAGE + name, feature); + if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { + exprs = ((BracedListExpression) exprs.get(0)).getItems(); } - - if (this.target == Target.TS) { - // "actions" is a reserved word within a TS reaction - if (name.equals("actions")) { - error(ACTIONS_MESSAGE + name, feature); - } + for (var component : exprs) { + checkExpressionIsTime(component, feature); } + } else { + checkExpressionIsTime(init, feature); + } } + } - - /** - * Check that the initializer is compatible with the type. - * Note that if the type is inferred it will necessarily be compatible - * so this method is not harmful. - */ - public void typeCheck(Initializer init, InferredType type, EStructuralFeature feature) { - if (init == null) { - return; - } - - // TODO: - // type is list => init is list - // type is fixed with size n => init is fixed with size n - // Specifically for C: list can only be literal or time lists - - if (type.isTime) { - if (type.isList) { - // list of times - var exprs = init.getExprs(); - if (exprs.isEmpty()) { - error("Expected at least one time value.", feature); - return; - } - if (exprs.size() == 1 && exprs.get(0) instanceof BracedListExpression) { - exprs = ((BracedListExpression) exprs.get(0)).getItems(); - } - for (var component : exprs) { - checkExpressionIsTime(component, feature); - } - } else { - checkExpressionIsTime(init, feature); - } - } + private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { + if (init == null) { + return; } - private void checkExpressionIsTime(Initializer init, EStructuralFeature feature) { - if (init == null) { - return; - } - - if (init.getExprs().size() != 1) { - error("Expected exactly one time value.", feature); - } else { - checkExpressionIsTime(ASTUtils.asSingleExpr(init), feature); - } + if (init.getExprs().size() != 1) { + error("Expected exactly one time value.", feature); + } else { + checkExpressionIsTime(ASTUtils.asSingleExpr(init), feature); } + } - private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { - if (value == null || value instanceof Time) { - return; - } - - if (value instanceof ParameterReference) { - if (!ASTUtils.isOfTimeType(((ParameterReference) value).getParameter()) - && target.requiresTypes) { - error("Referenced parameter is not of time type.", feature); - } - return; - } else if (value instanceof Literal) { - if (ASTUtils.isZero(((Literal) value).getLiteral())) { - return; - } - - if (ASTUtils.isInteger(((Literal) value).getLiteral())) { - error("Missing time unit.", feature); - return; - } - // fallthrough - } - - error("Invalid time value.", feature); + private void checkExpressionIsTime(Expression value, EStructuralFeature feature) { + if (value == null || value instanceof Time) { + return; } - /** - * Return the number of main or federated reactors declared. - * - * @param iter An iterator over all objects in the resource. - */ - private int countMainOrFederated(TreeIterator iter) { - int nMain = 0; - while (iter.hasNext()) { - EObject obj = iter.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor r = (Reactor) obj; - if (r.isMain() || r.isFederated()) { - nMain++; - } - } - return nMain; - } - - /** - * Report whether a given reactor has dependencies on a cyclic - * instantiation pattern. This means the reactor has an instantiation - * in it -- directly or in one of its contained reactors -- that is - * self-referential. - * @param reactor The reactor definition to find out whether it has any - * dependencies on cyclic instantiations. - * @param cycleSet The set of all reactors that are part of an - * instantiation cycle. - * @param visited The set of nodes already visited in this graph traversal. - */ - private boolean dependsOnCycle( - Reactor reactor, Set cycleSet, Set visited - ) { - Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); - if (visited.contains(reactor)) { - return false; - } else { - visited.add(reactor); - for (Reactor it : origins) { - if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { - // Reached a cycle. - return true; - } - } - } - return false; - } - - /** - * Report whether the name of the given element matches any variable in - * the ones to check against. - * @param element The element to compare against all variables in the given iterable. - * @param toCheckAgainst Iterable variables to compare the given element against. - */ - private boolean hasNameConflict(Variable element, - Iterable toCheckAgainst) { - int numNameConflicts = 0; - for (Variable it : toCheckAgainst) { - if (it.getName().equals(element.getName())) { - numNameConflicts++; - } - } - return numNameConflicts > 0; + if (value instanceof ParameterReference) { + if (!ASTUtils.isOfTimeType(((ParameterReference) value).getParameter()) + && target.requiresTypes) { + error("Referenced parameter is not of time type.", feature); + } + return; + } else if (value instanceof Literal) { + if (ASTUtils.isZero(((Literal) value).getLiteral())) { + return; + } + + if (ASTUtils.isInteger(((Literal) value).getLiteral())) { + error("Missing time unit.", feature); + return; + } + // fallthrough } - /** - * Return true if target is C or a C-based target like CCpp. - */ - private boolean isCBasedTarget() { - return (this.target == Target.C || this.target == Target.CCPP); + error("Invalid time value.", feature); + } + + /** + * Return the number of main or federated reactors declared. + * + * @param iter An iterator over all objects in the resource. + */ + private int countMainOrFederated(TreeIterator iter) { + int nMain = 0; + while (iter.hasNext()) { + EObject obj = iter.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor r = (Reactor) obj; + if (r.isMain() || r.isFederated()) { + nMain++; + } } - - /** - * Report whether a given imported reactor is used in this resource or not. - * @param reactor The imported reactor to check whether it is used. - */ - private boolean isUnused(ImportedReactor reactor) { - TreeIterator instantiations = reactor.eResource().getAllContents(); - TreeIterator subclasses = reactor.eResource().getAllContents(); - - boolean instantiationsCheck = true; - while (instantiations.hasNext() && instantiationsCheck) { - EObject obj = instantiations.next(); - if (!(obj instanceof Instantiation)) { - continue; - } - Instantiation inst = (Instantiation) obj; - instantiationsCheck &= (inst.getReactorClass() != reactor && inst.getReactorClass() != reactor.getReactorClass()); - } - - boolean subclassesCheck = true; - while (subclasses.hasNext() && subclassesCheck) { - EObject obj = subclasses.next(); - if (!(obj instanceof Reactor)) { - continue; - } - Reactor subclass = (Reactor) obj; - for (ReactorDecl decl : subclass.getSuperClasses()) { - subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); - } - } - return instantiationsCheck && subclassesCheck; + return nMain; + } + + /** + * Report whether a given reactor has dependencies on a cyclic instantiation pattern. This means + * the reactor has an instantiation in it -- directly or in one of its contained reactors -- that + * is self-referential. + * + * @param reactor The reactor definition to find out whether it has any dependencies on cyclic + * instantiations. + * @param cycleSet The set of all reactors that are part of an instantiation cycle. + * @param visited The set of nodes already visited in this graph traversal. + */ + private boolean dependsOnCycle(Reactor reactor, Set cycleSet, Set visited) { + Set origins = info.instantiationGraph.getUpstreamAdjacentNodes(reactor); + if (visited.contains(reactor)) { + return false; + } else { + visited.add(reactor); + for (Reactor it : origins) { + if (cycleSet.contains(it) || dependsOnCycle(it, cycleSet, visited)) { + // Reached a cycle. + return true; + } + } } - - /** - * Return true if the two types match. Unfortunately, xtext does not - * seem to create a suitable equals() method for Type, so we have to - * do this manually. - */ - private boolean sameType(Type type1, Type type2) { - if (type1 == null) { - return type2 == null; - } - if (type2 == null) { - return type1 == null; - } - // Most common case first. - if (type1.getId() != null) { - if (type1.getStars() != null) { - if (type2.getStars() == null) return false; - if (type1.getStars().size() != type2.getStars().size()) return false; - } - return (type1.getId().equals(type2.getId())); - } - - // Type specification in the grammar is: - // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); - if (type1.isTime()) { - if (!type2.isTime()) return false; - // Ignore the arraySpec because that is checked when connection - // is checked for balance. - return true; - } - // Type must be given in a code body - return type1.getCode().getBody().equals(type2.getCode().getBody()); + return false; + } + + /** + * Report whether the name of the given element matches any variable in the ones to check against. + * + * @param element The element to compare against all variables in the given iterable. + * @param toCheckAgainst Iterable variables to compare the given element against. + */ + private boolean hasNameConflict(Variable element, Iterable toCheckAgainst) { + int numNameConflicts = 0; + for (Variable it : toCheckAgainst) { + if (it.getName().equals(element.getName())) { + numNameConflicts++; + } + } + return numNameConflicts > 0; + } + + /** Return true if target is C or a C-based target like CCpp. */ + private boolean isCBasedTarget() { + return (this.target == Target.C || this.target == Target.CCPP); + } + + /** + * Report whether a given imported reactor is used in this resource or not. + * + * @param reactor The imported reactor to check whether it is used. + */ + private boolean isUnused(ImportedReactor reactor) { + TreeIterator instantiations = reactor.eResource().getAllContents(); + TreeIterator subclasses = reactor.eResource().getAllContents(); + + boolean instantiationsCheck = true; + while (instantiations.hasNext() && instantiationsCheck) { + EObject obj = instantiations.next(); + if (!(obj instanceof Instantiation)) { + continue; + } + Instantiation inst = (Instantiation) obj; + instantiationsCheck &= + (inst.getReactorClass() != reactor + && inst.getReactorClass() != reactor.getReactorClass()); } - ////////////////////////////////////////////////////////////// - //// Private fields. - - /** The error reporter. */ - private ValidatorErrorReporter errorReporter - = new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); - - /** Helper class containing information about the model. */ - private ModelInfo info = new ModelInfo(); - - @Inject(optional = true) - private ValidationMessageAcceptor messageAcceptor; - - /** The declared target. */ - private Target target; - - private List targetPropertyErrors = new ArrayList<>(); - - private List targetPropertyWarnings = new ArrayList<>(); - - ////////////////////////////////////////////////////////////// - //// Private static constants. - - private static String ACTIONS_MESSAGE - = "\"actions\" is a reserved word for the TypeScript target for objects " - + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " - + "and reactor instantiation): "; - - private static String HOST_OR_FQN_REGEX - = "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; - - /** - * Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). - */ - private static String IPV4_REGEX = "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" + - "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; - - /** - * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), - * with minor adjustment to allow up to six IPV6 segments (without truncation) in front - * of an embedded IPv4-address. - **/ - private static String IPV6_REGEX = - "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" + - "([0-9a-fA-F]{1,4}:){1,7}:|" + - "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" + - "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" + - "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" + - "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" + - "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" + - "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" + - ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" + - "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" + - "::(ffff(:0{1,4}){0,1}:){0,1}" + IPV4_REGEX + "|" + - "([0-9a-fA-F]{1,4}:){1,4}:" + IPV4_REGEX + "|" + - "([0-9a-fA-F]{1,4}:){1,6}" + IPV4_REGEX + ")"; - - private static String RESERVED_MESSAGE = "Reserved words in the target language are not allowed for objects " - + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, and reactor instantiation): "; - - private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); - - private static String UNDERSCORE_MESSAGE = "Names of objects (inputs, outputs, actions, timers, parameters, " - + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; - - private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; + boolean subclassesCheck = true; + while (subclasses.hasNext() && subclassesCheck) { + EObject obj = subclasses.next(); + if (!(obj instanceof Reactor)) { + continue; + } + Reactor subclass = (Reactor) obj; + for (ReactorDecl decl : subclass.getSuperClasses()) { + subclassesCheck &= (decl != reactor && decl != reactor.getReactorClass()); + } + } + return instantiationsCheck && subclassesCheck; + } + + /** + * Return true if the two types match. Unfortunately, xtext does not seem to create a suitable + * equals() method for Type, so we have to do this manually. + */ + private boolean sameType(Type type1, Type type2) { + if (type1 == null) { + return type2 == null; + } + if (type2 == null) { + return type1 == null; + } + // Most common case first. + if (type1.getId() != null) { + if (type1.getStars() != null) { + if (type2.getStars() == null) return false; + if (type1.getStars().size() != type2.getStars().size()) return false; + } + return (type1.getId().equals(type2.getId())); + } + // Type specification in the grammar is: + // (time?='time' (arraySpec=ArraySpec)?) | ((id=(DottedName) (stars+='*')* ('<' + // typeParms+=TypeParm (',' typeParms+=TypeParm)* '>')? (arraySpec=ArraySpec)?) | code=Code); + if (type1.isTime()) { + if (!type2.isTime()) return false; + // Ignore the arraySpec because that is checked when connection + // is checked for balance. + return true; + } + // Type must be given in a code body + return type1.getCode().getBody().equals(type2.getCode().getBody()); + } + + ////////////////////////////////////////////////////////////// + //// Private fields. + + /** The error reporter. */ + private ValidatorErrorReporter errorReporter = + new ValidatorErrorReporter(getMessageAcceptor(), new ValidatorStateAccess()); + + /** Helper class containing information about the model. */ + private ModelInfo info = new ModelInfo(); + + @Inject(optional = true) + private ValidationMessageAcceptor messageAcceptor; + + /** The declared target. */ + private Target target; + + private List targetPropertyErrors = new ArrayList<>(); + + private List targetPropertyWarnings = new ArrayList<>(); + + ////////////////////////////////////////////////////////////// + //// Private static constants. + + private static String ACTIONS_MESSAGE = + "\"actions\" is a reserved word for the TypeScript target for objects " + + "(inputs, outputs, actions, timers, parameters, state, reactor definitions, " + + "and reactor instantiation): "; + + private static String HOST_OR_FQN_REGEX = + "^([a-z0-9]+(-[a-z0-9]+)*)|(([a-z0-9]+(-[a-z0-9]+)*\\.)+[a-z]{2,})$"; + + /** Regular expression to check the validity of IPV4 addresses (due to David M. Syzdek). */ + private static String IPV4_REGEX = + "((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}" + + "(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"; + + /** + * Regular expression to check the validity of IPV6 addresses (due to David M. Syzdek), with minor + * adjustment to allow up to six IPV6 segments (without truncation) in front of an embedded + * IPv4-address. + */ + private static String IPV6_REGEX = + "(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,7}:|" + + "([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|" + + "([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|" + + "([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|" + + "([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|" + + "([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|" + + "[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|" + + ":((:[0-9a-fA-F]{1,4}){1,7}|:)|" + + "fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|" + + "::(ffff(:0{1,4}){0,1}:){0,1}" + + IPV4_REGEX + + "|" + + "([0-9a-fA-F]{1,4}:){1,4}:" + + IPV4_REGEX + + "|" + + "([0-9a-fA-F]{1,4}:){1,6}" + + IPV4_REGEX + + ")"; + + private static String RESERVED_MESSAGE = + "Reserved words in the target language are not allowed for objects (inputs, outputs, actions," + + " timers, parameters, state, reactor definitions, and reactor instantiation): "; + + private static List SPACING_VIOLATION_POLICIES = List.of("defer", "drop", "replace"); + + private static String UNDERSCORE_MESSAGE = + "Names of objects (inputs, outputs, actions, timers, parameters, " + + "state, reactor definitions, and reactor instantiation) may not start with \"__\": "; + + private static String USERNAME_REGEX = "^[a-z_]([a-z0-9_-]{0,31}|[a-z0-9_-]{0,30}\\$)$"; } diff --git a/org.lflang/src/org/lflang/validation/ValidatorErrorReporter.java b/org.lflang/src/org/lflang/validation/ValidatorErrorReporter.java index ace55683f6..d21458a3a9 100644 --- a/org.lflang/src/org/lflang/validation/ValidatorErrorReporter.java +++ b/org.lflang/src/org/lflang/validation/ValidatorErrorReporter.java @@ -1,16 +1,16 @@ /************* * Copyright (c) 2021, TU Dresden. - * + * * 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. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE @@ -27,155 +27,160 @@ package org.lflang.validation; import java.nio.file.Path; - import org.eclipse.emf.ecore.EObject; import org.eclipse.xtext.validation.ValidationMessageAcceptor; - import org.lflang.ErrorReporter; /** - * This class translates messages reported via the ErrorReporrter interface to - * the interface of a given ValidationMessageAcceptor. - * - * Effectively this allows to report errors via the ErrorReporter interface - * during validator checks, while having the validator still track all the - * reported warnings and messages. This is required for some functionality, like - * the construction of an instance graph in LFValidator.checkModel(). Since the - * instance graph is also used in other components, it does not report directly - * to the validator, but uses our custom ErrorReporter interface that we use - * during code generation. This class bridges the gap between the ErrorReporter - * interface and the messages that the validator expects. - * + * This class translates messages reported via the ErrorReporrter interface to the interface of a + * given ValidationMessageAcceptor. + * + *

    Effectively this allows to report errors via the ErrorReporter interface during validator + * checks, while having the validator still track all the reported warnings and messages. This is + * required for some functionality, like the construction of an instance graph in + * LFValidator.checkModel(). Since the instance graph is also used in other components, it does not + * report directly to the validator, but uses our custom ErrorReporter interface that we use during + * code generation. This class bridges the gap between the ErrorReporter interface and the messages + * that the validator expects. + * * @author Christian Menard */ public class ValidatorErrorReporter implements ErrorReporter { - private ValidationMessageAcceptor acceptor; - private BaseLFValidator.ValidatorStateAccess validatorState; - private boolean errorsOccurred = false; - - public ValidatorErrorReporter(ValidationMessageAcceptor acceptor, - BaseLFValidator.ValidatorStateAccess stateAccess) { - this.acceptor = acceptor; - this.validatorState = stateAccess; - } - - /** - * Report the given message as an error on the object currently under - * validation. - */ - @Override - public String reportError(String message) { - errorsOccurred = true; - acceptor.acceptError(message, validatorState.getCurrentObject(), null, - ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return message; - } - - /** - * Report the given message as an error on the given object. - */ - @Override - public String reportError(EObject object, String message) { - errorsOccurred = true; - acceptor.acceptError(message, object, null, - ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return message; - } - - /** - * Report the given message as an error on the current object. - * - * Unfortunately, there is no way to provide a path and a line number to the - * ValidationMessageAcceptor as messages can only be reported directly as - * EObjects. While it is not an ideal solution, this method composes a - * messages indicating the location of the error and reports this on the - * object currently under validation. This way, the error message is not - * lost, but it is not necessarily reported precisely at the location of the - * actual error. - */ - @Override - public String reportError(Path file, Integer line, String message) { - errorsOccurred = true; - String fullMessage = message + " (Reported from " + file.toString() + " on line " - + line.toString() + ")"; - acceptor.acceptError(fullMessage, validatorState.getCurrentObject(), - null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return fullMessage; - } - - /** - * Report the given message as a waring on the object currently under - * validation. - */ - @Override - public String reportWarning(String message) { - acceptor.acceptWarning(message, validatorState.getCurrentObject(), null, - ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return message; - } - - @Override - public String reportInfo(String message) { - acceptor.acceptInfo(message, validatorState.getCurrentObject(), null, - ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return message; - } - - /** - * Report the given message as a warning on the given object. - */ - @Override - public String reportWarning(EObject object, String message) { - acceptor.acceptWarning(message, object, null, - ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return message; - } - - @Override - public String reportInfo(EObject object, String message) { - acceptor.acceptInfo(message, object, null, - ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return message; - } - - - /** - * Report the given message as an warning on the current object. - * - * Unfortunately, there is no way to provide a path and a line number to the - * ValidationMessageAcceptor as messages can only be reported directly as - * EObjects. While it is not an ideal solution, this method composes a - * messages indicating the location of the warning and reports this on the - * object currently under validation. This way, the warning message is not - * lost, but it is not necessarily reported precisely at the location of the - * actual warning. - */ - @Override - public String reportWarning(Path file, Integer line, String message) { - String fullMessage = message + " (Reported from " + file.toString() + " on line " - + line.toString() + ")"; - acceptor.acceptWarning(fullMessage, validatorState.getCurrentObject(), - null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return fullMessage; - } - - @Override - public String reportInfo(Path file, Integer line, String message) { - String fullMessage = message + " (Reported from " + file.toString() + " on line " - + line.toString() + ")"; - acceptor.acceptInfo(fullMessage, validatorState.getCurrentObject(), - null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); - return fullMessage; - } - - /** - * Check if errors where reported. - * - * @return true if errors where reported - */ - @Override - public boolean getErrorsOccurred() { - return errorsOccurred; - } + private ValidationMessageAcceptor acceptor; + private BaseLFValidator.ValidatorStateAccess validatorState; + private boolean errorsOccurred = false; + + public ValidatorErrorReporter( + ValidationMessageAcceptor acceptor, BaseLFValidator.ValidatorStateAccess stateAccess) { + this.acceptor = acceptor; + this.validatorState = stateAccess; + } + + /** Report the given message as an error on the object currently under validation. */ + @Override + public String reportError(String message) { + errorsOccurred = true; + acceptor.acceptError( + message, + validatorState.getCurrentObject(), + null, + ValidationMessageAcceptor.INSIGNIFICANT_INDEX, + null); + return message; + } + + /** Report the given message as an error on the given object. */ + @Override + public String reportError(EObject object, String message) { + errorsOccurred = true; + acceptor.acceptError( + message, object, null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); + return message; + } + + /** + * Report the given message as an error on the current object. + * + *

    Unfortunately, there is no way to provide a path and a line number to the + * ValidationMessageAcceptor as messages can only be reported directly as EObjects. While it is + * not an ideal solution, this method composes a messages indicating the location of the error and + * reports this on the object currently under validation. This way, the error message is not lost, + * but it is not necessarily reported precisely at the location of the actual error. + */ + @Override + public String reportError(Path file, Integer line, String message) { + errorsOccurred = true; + String fullMessage = + message + " (Reported from " + file.toString() + " on line " + line.toString() + ")"; + acceptor.acceptError( + fullMessage, + validatorState.getCurrentObject(), + null, + ValidationMessageAcceptor.INSIGNIFICANT_INDEX, + null); + return fullMessage; + } + + /** Report the given message as a waring on the object currently under validation. */ + @Override + public String reportWarning(String message) { + acceptor.acceptWarning( + message, + validatorState.getCurrentObject(), + null, + ValidationMessageAcceptor.INSIGNIFICANT_INDEX, + null); + return message; + } + + @Override + public String reportInfo(String message) { + acceptor.acceptInfo( + message, + validatorState.getCurrentObject(), + null, + ValidationMessageAcceptor.INSIGNIFICANT_INDEX, + null); + return message; + } + + /** Report the given message as a warning on the given object. */ + @Override + public String reportWarning(EObject object, String message) { + acceptor.acceptWarning( + message, object, null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); + return message; + } + + @Override + public String reportInfo(EObject object, String message) { + acceptor.acceptInfo(message, object, null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, null); + return message; + } + + /** + * Report the given message as an warning on the current object. + * + *

    Unfortunately, there is no way to provide a path and a line number to the + * ValidationMessageAcceptor as messages can only be reported directly as EObjects. While it is + * not an ideal solution, this method composes a messages indicating the location of the warning + * and reports this on the object currently under validation. This way, the warning message is not + * lost, but it is not necessarily reported precisely at the location of the actual warning. + */ + @Override + public String reportWarning(Path file, Integer line, String message) { + String fullMessage = + message + " (Reported from " + file.toString() + " on line " + line.toString() + ")"; + acceptor.acceptWarning( + fullMessage, + validatorState.getCurrentObject(), + null, + ValidationMessageAcceptor.INSIGNIFICANT_INDEX, + null); + return fullMessage; + } + + @Override + public String reportInfo(Path file, Integer line, String message) { + String fullMessage = + message + " (Reported from " + file.toString() + " on line " + line.toString() + ")"; + acceptor.acceptInfo( + fullMessage, + validatorState.getCurrentObject(), + null, + ValidationMessageAcceptor.INSIGNIFICANT_INDEX, + null); + return fullMessage; + } + + /** + * Check if errors where reported. + * + * @return true if errors where reported + */ + @Override + public boolean getErrorsOccurred() { + return errorsOccurred; + } } From 909860689905969e56125007369d5fa315583a82 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Mon, 22 May 2023 18:25:25 -0700 Subject: [PATCH 411/709] Initialize source_reactor for reactions writing to contained reactors --- .../src/org/lflang/generator/c/CTriggerObjectsGenerator.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java index 0767b33bff..60b12c887a 100644 --- a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java @@ -665,6 +665,7 @@ private static String deferredInputNumDestinations( // Syntax is slightly different for a multiport output vs. single port. var connector = (port.isMultiport())? "->" : "."; code.pr(CUtil.portRefNested(port, sr, sb, sc)+connector+"_base.num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); + code.pr(CUtil.portRefNested(port, sr, sb, sc)+connector+"_base.source_reactor = (self_base_t*)"+CUtil.reactorRef(reaction.getParent(), sb)+";"); // Initialize token types. var type = ASTUtils.getInferredType(port.getDefinition()); From 107eccc03d35413b59c032b9a8fd3c00e219fac6 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Mon, 22 May 2023 18:34:47 -0700 Subject: [PATCH 412/709] Apply formatter --- org.lflang/src/lib/c/reactor-c | 2 +- .../lflang/generator/c/CActionGenerator.java | 292 +-- .../lflang/generator/c/CPortGenerator.java | 516 ++--- .../generator/c/CTriggerObjectsGenerator.java | 2016 +++++++++-------- 4 files changed, 1449 insertions(+), 1377 deletions(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 72da1e1e33..1784274083 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 72da1e1e331a2c27adc53c5ac8739c172c68dfd3 +Subproject commit 17842740830b1fa92eb012a6d007cc78653115b6 diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java index 72647f5c0e..9da9d1bb62 100644 --- a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CActionGenerator.java @@ -1,7 +1,9 @@ package org.lflang.generator.c; -import java.util.List; +import static org.lflang.generator.c.CGenerator.variableStructType; + import java.util.ArrayList; +import java.util.List; import org.lflang.ASTUtils; import org.lflang.Target; import org.lflang.generator.ActionInstance; @@ -9,8 +11,7 @@ import org.lflang.generator.ReactorInstance; import org.lflang.lf.Action; import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; -import static org.lflang.generator.c.CGenerator.variableStructType; + /** * Generates code for actions (logical or physical) for the C and CCpp target. * @@ -24,156 +25,155 @@ * @author Hou Seng Wong */ public class CActionGenerator { - /** - * For each action of the specified reactor instance, generate initialization code - * for the offset and period fields. - * @param instance The reactor. - */ - public static String generateInitializers( - ReactorInstance instance - ) { - List code = new ArrayList<>(); - for (ActionInstance action : instance.actions) { - if (!action.isShutdown()) { - var triggerStructName = CUtil.reactorRef(action.getParent()) + "->_lf__" + action.getName(); - var minDelay = action.getMinDelay(); - var minSpacing = action.getMinSpacing(); - var offsetInitializer = triggerStructName+".offset = " + CTypes.getInstance().getTargetTimeExpr(minDelay) - + ";"; - var periodInitializer = triggerStructName+".period = " + (minSpacing != null ? - CTypes.getInstance().getTargetTimeExpr(minSpacing) : - CGenerator.UNDEFINED_MIN_SPACING) + ";"; - code.addAll(List.of( - "// Initializing action "+action.getFullName(), - offsetInitializer, - periodInitializer - )); + /** + * For each action of the specified reactor instance, generate initialization code for the offset + * and period fields. + * + * @param instance The reactor. + */ + public static String generateInitializers(ReactorInstance instance) { + List code = new ArrayList<>(); + for (ActionInstance action : instance.actions) { + if (!action.isShutdown()) { + var triggerStructName = CUtil.reactorRef(action.getParent()) + "->_lf__" + action.getName(); + var minDelay = action.getMinDelay(); + var minSpacing = action.getMinSpacing(); + var offsetInitializer = + triggerStructName + + ".offset = " + + CTypes.getInstance().getTargetTimeExpr(minDelay) + + ";"; + var periodInitializer = + triggerStructName + + ".period = " + + (minSpacing != null + ? CTypes.getInstance().getTargetTimeExpr(minSpacing) + : CGenerator.UNDEFINED_MIN_SPACING) + + ";"; + code.addAll( + List.of( + "// Initializing action " + action.getFullName(), + offsetInitializer, + periodInitializer)); - var mode = action.getMode(false); - if (mode != null) { - var modeParent = mode.getParent(); - var modeRef = "&"+CUtil.reactorRef(modeParent)+"->_lf__modes["+modeParent.modes.indexOf(mode)+"];"; - code.add(triggerStructName+".mode = "+modeRef+";"); - } else { - code.add(triggerStructName+".mode = NULL;"); - } - } + var mode = action.getMode(false); + if (mode != null) { + var modeParent = mode.getParent(); + var modeRef = + "&" + + CUtil.reactorRef(modeParent) + + "->_lf__modes[" + + modeParent.modes.indexOf(mode) + + "];"; + code.add(triggerStructName + ".mode = " + modeRef + ";"); + } else { + code.add(triggerStructName + ".mode = NULL;"); } - return String.join("\n", code); + } } + return String.join("\n", code); + } - /** - * Create a template token initialized to the payload size. - * This token is marked to not be freed so that the trigger_t struct - * always has a template token. - * At the start of each time step, we need to initialize the is_present field - * of each action's trigger object to false and free a previously - * allocated token if appropriate. This code sets up the table that does that. - * - * @param selfStruct The variable name of the self struct - * @param actionName The action name - * @param payloadSize The code that returns the size of the action's payload in C. - */ - public static String generateTokenInitializer( - String selfStruct, - String actionName, - String payloadSize - ) { - return String.join("\n", - "_lf_initialize_template((token_template_t*)", - " &("+selfStruct+"->_lf__"+actionName+"),", - payloadSize+");", - selfStruct+"->_lf__"+actionName+".status = absent;" - ); - } + /** + * Create a template token initialized to the payload size. This token is marked to not be freed + * so that the trigger_t struct always has a template token. At the start of each time step, we + * need to initialize the is_present field of each action's trigger object to false and free a + * previously allocated token if appropriate. This code sets up the table that does that. + * + * @param selfStruct The variable name of the self struct + * @param actionName The action name + * @param payloadSize The code that returns the size of the action's payload in C. + */ + public static String generateTokenInitializer( + String selfStruct, String actionName, String payloadSize) { + return String.join( + "\n", + "_lf_initialize_template((token_template_t*)", + " &(" + selfStruct + "->_lf__" + actionName + "),", + payloadSize + ");", + selfStruct + "->_lf__" + actionName + ".status = absent;"); + } - /** - * Generate the declarations of actions in the self struct - * - * @param reactor The reactor to generate declarations for - * @param decl The reactor's declaration - * @param body The content of the self struct - * @param constructorCode The constructor code of the reactor - */ - public static void generateDeclarations( - Reactor reactor, - CodeBuilder body, - CodeBuilder constructorCode - ) { - for (Action action : ASTUtils.allActions(reactor)) { - var actionName = action.getName(); - body.pr(action, CGenerator.variableStructType(action, reactor, false)+" _lf_"+actionName+";"); - // Initialize the trigger pointer and the parent pointer in the action. - constructorCode.pr(action, "self->_lf_"+actionName+"._base.trigger = &self->_lf__"+actionName+";"); - constructorCode.pr(action, "self->_lf_"+actionName+".parent = (self_base_t*)self;"); - } + /** + * Generate the declarations of actions in the self struct + * + * @param reactor The reactor to generate declarations for + * @param decl The reactor's declaration + * @param body The content of the self struct + * @param constructorCode The constructor code of the reactor + */ + public static void generateDeclarations( + Reactor reactor, CodeBuilder body, CodeBuilder constructorCode) { + for (Action action : ASTUtils.allActions(reactor)) { + var actionName = action.getName(); + body.pr( + action, + CGenerator.variableStructType(action, reactor, false) + " _lf_" + actionName + ";"); + // Initialize the trigger pointer and the parent pointer in the action. + constructorCode.pr( + action, "self->_lf_" + actionName + "._base.trigger = &self->_lf__" + actionName + ";"); + constructorCode.pr(action, "self->_lf_" + actionName + ".parent = (self_base_t*)self;"); } + } - /** - * Generate the struct type definitions for the action of the - * reactor - * - * @param decl The reactor declaration - * @param action The action to generate the struct for - * @param target The target of the code generation (C, CCpp or Python) - * @param types The helper object for types related stuff - * @param federatedExtension The code needed to support federated execution - * @return The auxiliary struct for the port as a string - */ - public static String generateAuxiliaryStruct( - Reactor r, - Action action, - Target target, - CTypes types, - CodeBuilder federatedExtension, - boolean userFacing - ) { - var code = new CodeBuilder(); - code.pr("typedef struct {"); - code.indent(); - // NOTE: The following fields are required to be the first ones so that - // pointer to this struct can be cast to a (lf_action_base_t*) or to - // (token_template_t*) to access these fields for any port. - // IMPORTANT: These must match exactly the fields defined in port.h!! - code.pr(String.join("\n", - "token_type_t type;", // From token_template_t - "lf_token_t* token;", // From token_template_t - "size_t length;", // From token_template_t - "bool is_present;", // From lf_port_or_action_t - "lf_action_internal_t _base;", // internal substruct - "self_base_t* parent;",// From lf_port_or_action_t - "bool has_value;" // From lf_action_base_t - )); - code.pr(valueDeclaration(action, target, types)); - code.pr(federatedExtension.toString()); - code.unindent(); - code.pr("} " + variableStructType(action, r, userFacing) + ";"); - return code.toString(); - } + /** + * Generate the struct type definitions for the action of the reactor + * + * @param decl The reactor declaration + * @param action The action to generate the struct for + * @param target The target of the code generation (C, CCpp or Python) + * @param types The helper object for types related stuff + * @param federatedExtension The code needed to support federated execution + * @return The auxiliary struct for the port as a string + */ + public static String generateAuxiliaryStruct( + Reactor r, + Action action, + Target target, + CTypes types, + CodeBuilder federatedExtension, + boolean userFacing) { + var code = new CodeBuilder(); + code.pr("typedef struct {"); + code.indent(); + // NOTE: The following fields are required to be the first ones so that + // pointer to this struct can be cast to a (lf_action_base_t*) or to + // (token_template_t*) to access these fields for any port. + // IMPORTANT: These must match exactly the fields defined in port.h!! + code.pr( + String.join( + "\n", + "token_type_t type;", // From token_template_t + "lf_token_t* token;", // From token_template_t + "size_t length;", // From token_template_t + "bool is_present;", // From lf_port_or_action_t + "lf_action_internal_t _base;", // internal substruct + "self_base_t* parent;", // From lf_port_or_action_t + "bool has_value;" // From lf_action_base_t + )); + code.pr(valueDeclaration(action, target, types)); + code.pr(federatedExtension.toString()); + code.unindent(); + code.pr("} " + variableStructType(action, r, userFacing) + ";"); + return code.toString(); + } - /** - * For the specified action, return a declaration for action struct to - * contain the value of the action. An action of - * type int[10], for example, will result in this: - * ``` - * int* value; - * ``` - * This will return an empty string for an action with no type. - * @param action The action. - * @return A string providing the value field of the action struct. - */ - private static String valueDeclaration( - Action action, - Target target, - CTypes types - ) { - if (target == Target.Python) { - return "PyObject* value;"; - } - // Do not convert to lf_token_t* using lfTypeToTokenType because there - // will be a separate field pointing to the token. - return action.getType() == null && target.requiresTypes ? - "" : - types.getTargetType(action) + " value;"; + /** + * For the specified action, return a declaration for action struct to contain the value of the + * action. An action of type int[10], for example, will result in this: ``` int* value; ``` This + * will return an empty string for an action with no type. + * + * @param action The action. + * @return A string providing the value field of the action struct. + */ + private static String valueDeclaration(Action action, Target target, CTypes types) { + if (target == Target.Python) { + return "PyObject* value;"; } + // Do not convert to lf_token_t* using lfTypeToTokenType because there + // will be a separate field pointing to the token. + return action.getType() == null && target.requiresTypes + ? "" + : types.getTargetType(action) + " value;"; + } } diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java index d315536139..1e9da4e309 100644 --- a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CPortGenerator.java @@ -1,5 +1,7 @@ package org.lflang.generator.c; +import static org.lflang.generator.c.CGenerator.variableStructType; + import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.ErrorReporter; @@ -11,8 +13,6 @@ import org.lflang.lf.Port; import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; -import static org.lflang.generator.c.CGenerator.variableStructType; - /** * Generates C code to declare and initialize ports. @@ -22,270 +22,276 @@ * @author Hou Seng Wong */ public class CPortGenerator { - /** - * Generate fields in the self struct for input and output ports - * - * @param reactor - * @param decl - * @param body - * @param constructorCode - */ - public static void generateDeclarations( - Reactor reactor, - ReactorDecl decl, - CodeBuilder body, - CodeBuilder constructorCode - ) { - generateInputDeclarations(reactor, decl, body, constructorCode); - generateOutputDeclarations(reactor, decl, body, constructorCode); - } + /** + * Generate fields in the self struct for input and output ports + * + * @param reactor + * @param decl + * @param body + * @param constructorCode + */ + public static void generateDeclarations( + Reactor reactor, ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode) { + generateInputDeclarations(reactor, decl, body, constructorCode); + generateOutputDeclarations(reactor, decl, body, constructorCode); + } - /** - * Generate the struct type definitions for the port of the - * reactor - * - * @param r The reactor - * @param port The port to generate the struct - * @param target The target of the code generation (C, CCpp or Python) - * @param errorReporter The error reporter - * @param types The helper object for types related stuff - * @param federatedExtension The code needed to support federated execution - * @param userFacing Whether this struct is to be presented in a user-facing header - * @param decl The reactorDecl if this struct is for the header of this reactor's container; - * null otherwise - * @return The auxiliary struct for the port as a string - */ - public static String generateAuxiliaryStruct( - Reactor r, - Port port, - Target target, - ErrorReporter errorReporter, - CTypes types, - CodeBuilder federatedExtension, - boolean userFacing, - ReactorDecl decl - ) { - assert decl == null || userFacing; - var code = new CodeBuilder(); - code.pr("typedef struct {"); - code.indent(); - // NOTE: The following fields are required to be the first ones so that - // pointer to this struct can be cast to a (lf_port_base_t*) or to - // (token_template_t*) to access these fields for any port. - // IMPORTANT: These must match exactly the fields defined in port.h!! - code.pr(String.join("\n", - "token_type_t type;", // From token_template_t - "lf_token_t* token;", // From token_template_t - "size_t length;", // From token_template_t - "bool is_present;", - "lf_port_internal_t _base;" - )); - code.pr(valueDeclaration(port, target, errorReporter, types)); - code.pr(federatedExtension.toString()); - code.unindent(); - var name = decl != null ? localPortName(decl, port.getName()) + /** + * Generate the struct type definitions for the port of the reactor + * + * @param r The reactor + * @param port The port to generate the struct + * @param target The target of the code generation (C, CCpp or Python) + * @param errorReporter The error reporter + * @param types The helper object for types related stuff + * @param federatedExtension The code needed to support federated execution + * @param userFacing Whether this struct is to be presented in a user-facing header + * @param decl The reactorDecl if this struct is for the header of this reactor's container; null + * otherwise + * @return The auxiliary struct for the port as a string + */ + public static String generateAuxiliaryStruct( + Reactor r, + Port port, + Target target, + ErrorReporter errorReporter, + CTypes types, + CodeBuilder federatedExtension, + boolean userFacing, + ReactorDecl decl) { + assert decl == null || userFacing; + var code = new CodeBuilder(); + code.pr("typedef struct {"); + code.indent(); + // NOTE: The following fields are required to be the first ones so that + // pointer to this struct can be cast to a (lf_port_base_t*) or to + // (token_template_t*) to access these fields for any port. + // IMPORTANT: These must match exactly the fields defined in port.h!! + code.pr( + String.join( + "\n", + "token_type_t type;", // From token_template_t + "lf_token_t* token;", // From token_template_t + "size_t length;", // From token_template_t + "bool is_present;", + "lf_port_internal_t _base;")); + code.pr(valueDeclaration(port, target, errorReporter, types)); + code.pr(federatedExtension.toString()); + code.unindent(); + var name = + decl != null + ? localPortName(decl, port.getName()) : variableStructType(port, r, userFacing); - code.pr("} " + name + ";"); - return code.toString(); - } + code.pr("} " + name + ";"); + return code.toString(); + } - public static String localPortName(ReactorDecl decl, String portName) { - return decl.getName().toLowerCase() + "_" + portName + "_t"; - } + public static String localPortName(ReactorDecl decl, String portName) { + return decl.getName().toLowerCase() + "_" + portName + "_t"; + } - /** - * Allocate memory for the input port. - * @param input The input port - * @param reactorSelfStruct The name of the self struct - */ - public static String initializeInputMultiport( - PortInstance input, - String reactorSelfStruct - ) { - var portRefName = CUtil.portRefName(input); - // If the port is a multiport, create an array. - if (input.isMultiport()) { - String result = String.join("\n", - portRefName+"_width = "+input.getWidth()+";", - "// Allocate memory for multiport inputs.", - portRefName+" = ("+variableStructType(input)+"**)_lf_allocate(", - " "+input.getWidth()+", sizeof("+variableStructType(input)+"*),", - " &"+reactorSelfStruct+"->base.allocations); ", - "// Set inputs by default to an always absent default input.", - "for (int i = 0; i < "+input.getWidth()+"; i++) {", - " "+portRefName+"[i] = &"+reactorSelfStruct+"->_lf_default__"+input.getName()+";", - "}" - ); - if (AttributeUtils.isSparse(input.getDefinition())) { - return String.join("\n", result, - "if ("+input.getWidth()+" >= LF_SPARSE_WIDTH_THRESHOLD) {", - " "+portRefName+"__sparse = (lf_sparse_io_record_t*)_lf_allocate(1,", - " sizeof(lf_sparse_io_record_t) + sizeof(size_t) * "+input.getWidth()+"/LF_SPARSE_CAPACITY_DIVIDER,", - " &"+reactorSelfStruct+"->base.allocations);", - " "+portRefName+"__sparse->capacity = "+input.getWidth()+"/LF_SPARSE_CAPACITY_DIVIDER;", - " if (_lf_sparse_io_record_sizes.start == NULL) {", - " _lf_sparse_io_record_sizes = vector_new(1);", - " }", - " vector_push(&_lf_sparse_io_record_sizes, (void*)&"+portRefName+"__sparse->size);", - "}" - ); - } - return result; - } else { - return String.join("\n", - "// width of -2 indicates that it is not a multiport.", - portRefName+"_width = -2;" - ); - } + /** + * Allocate memory for the input port. + * + * @param input The input port + * @param reactorSelfStruct The name of the self struct + */ + public static String initializeInputMultiport(PortInstance input, String reactorSelfStruct) { + var portRefName = CUtil.portRefName(input); + // If the port is a multiport, create an array. + if (input.isMultiport()) { + String result = + String.join( + "\n", + portRefName + "_width = " + input.getWidth() + ";", + "// Allocate memory for multiport inputs.", + portRefName + " = (" + variableStructType(input) + "**)_lf_allocate(", + " " + input.getWidth() + ", sizeof(" + variableStructType(input) + "*),", + " &" + reactorSelfStruct + "->base.allocations); ", + "// Set inputs by default to an always absent default input.", + "for (int i = 0; i < " + input.getWidth() + "; i++) {", + " " + + portRefName + + "[i] = &" + + reactorSelfStruct + + "->_lf_default__" + + input.getName() + + ";", + "}"); + if (AttributeUtils.isSparse(input.getDefinition())) { + return String.join( + "\n", + result, + "if (" + input.getWidth() + " >= LF_SPARSE_WIDTH_THRESHOLD) {", + " " + portRefName + "__sparse = (lf_sparse_io_record_t*)_lf_allocate(1,", + " sizeof(lf_sparse_io_record_t) + sizeof(size_t) * " + + input.getWidth() + + "/LF_SPARSE_CAPACITY_DIVIDER,", + " &" + reactorSelfStruct + "->base.allocations);", + " " + + portRefName + + "__sparse->capacity = " + + input.getWidth() + + "/LF_SPARSE_CAPACITY_DIVIDER;", + " if (_lf_sparse_io_record_sizes.start == NULL) {", + " _lf_sparse_io_record_sizes = vector_new(1);", + " }", + " vector_push(&_lf_sparse_io_record_sizes, (void*)&" + + portRefName + + "__sparse->size);", + "}"); + } + return result; + } else { + return String.join( + "\n", + "// width of -2 indicates that it is not a multiport.", + portRefName + "_width = -2;"); } + } - /** - * Allocate memory for the output port. - * @param output The output port - * @param reactorSelfStruct The name of the self struct - */ - public static String initializeOutputMultiport( - PortInstance output, - String reactorSelfStruct - ) { - var portRefName = CUtil.portRefName(output); - var portStructType = variableStructType(output); - return output.isMultiport() ? - String.join("\n", - portRefName+"_width = "+output.getWidth()+";", - "// Allocate memory for multiport output.", - portRefName+" = ("+portStructType+"*)_lf_allocate(", - " "+output.getWidth()+", sizeof("+portStructType+"),", - " &"+reactorSelfStruct+"->base.allocations); ", - portRefName+"_pointers = ("+portStructType+"**)_lf_allocate(", - " "+output.getWidth()+", sizeof("+portStructType+"*),", - " &"+reactorSelfStruct+"->base.allocations); ", - "// Assign each output port pointer to be used in", - "// reactions to facilitate user access to output ports", - "for(int i=0; i < "+output.getWidth()+"; i++) {", - " "+portRefName+"_pointers[i] = &("+portRefName+"[i]);", - "}" - ) : - String.join("\n", - "// width of -2 indicates that it is not a multiport.", - portRefName+"_width = -2;" - ); - } + /** + * Allocate memory for the output port. + * + * @param output The output port + * @param reactorSelfStruct The name of the self struct + */ + public static String initializeOutputMultiport(PortInstance output, String reactorSelfStruct) { + var portRefName = CUtil.portRefName(output); + var portStructType = variableStructType(output); + return output.isMultiport() + ? String.join( + "\n", + portRefName + "_width = " + output.getWidth() + ";", + "// Allocate memory for multiport output.", + portRefName + " = (" + portStructType + "*)_lf_allocate(", + " " + output.getWidth() + ", sizeof(" + portStructType + "),", + " &" + reactorSelfStruct + "->base.allocations); ", + portRefName + "_pointers = (" + portStructType + "**)_lf_allocate(", + " " + output.getWidth() + ", sizeof(" + portStructType + "*),", + " &" + reactorSelfStruct + "->base.allocations); ", + "// Assign each output port pointer to be used in", + "// reactions to facilitate user access to output ports", + "for(int i=0; i < " + output.getWidth() + "; i++) {", + " " + portRefName + "_pointers[i] = &(" + portRefName + "[i]);", + "}") + : String.join( + "\n", + "// width of -2 indicates that it is not a multiport.", + portRefName + "_width = -2;"); + } - /** - * For the specified port, return a declaration for port struct to - * contain the value of the port. A multiport output with width 4 and - * type int[10], for example, will result in this: - * ``` - * int value[10]; - * ``` - * There will be an array of size 4 of structs, each containing this value - * array. - * @param port The port. - * @return A string providing the value field of the port struct. - */ - private static String valueDeclaration( - Port port, - Target target, - ErrorReporter errorReporter, - CTypes types - ) { - if (port.getType() == null && target.requiresTypes) { - // This should have been caught by the validator. - errorReporter.reportError(port, "Port is required to have a type: " + port.getName()); - return ""; - } - // Do not convert to lf_token_t* using lfTypeToTokenType because there - // will be a separate field pointing to the token. - return types.getVariableDeclaration(ASTUtils.getInferredType(port), "value", false) + ";"; + /** + * For the specified port, return a declaration for port struct to contain the value of the port. + * A multiport output with width 4 and type int[10], for example, will result in this: ``` int + * value[10]; ``` There will be an array of size 4 of structs, each containing this value array. + * + * @param port The port. + * @return A string providing the value field of the port struct. + */ + private static String valueDeclaration( + Port port, Target target, ErrorReporter errorReporter, CTypes types) { + if (port.getType() == null && target.requiresTypes) { + // This should have been caught by the validator. + errorReporter.reportError(port, "Port is required to have a type: " + port.getName()); + return ""; } + // Do not convert to lf_token_t* using lfTypeToTokenType because there + // will be a separate field pointing to the token. + return types.getVariableDeclaration(ASTUtils.getInferredType(port), "value", false) + ";"; + } - /** - * Generate fields in the self struct for input ports - * - * If the port is a multiport, the input field is an array of - * pointers that will be allocated separately for each instance - * because the sizes may be different. Otherwise, it is a simple - * pointer. - * - */ - private static void generateInputDeclarations( - Reactor reactor, - ReactorDecl decl, - CodeBuilder body, - CodeBuilder constructorCode - ) { - for (Input input : ASTUtils.allInputs(reactor)) { - var inputName = input.getName(); - if (ASTUtils.isMultiport(input)) { - body.pr(input, String.join("\n", - "// Multiport input array will be malloc'd later.", - variableStructType(input, reactor, false)+"** _lf_"+inputName+";", - "int _lf_"+inputName+"_width;", - "// Default input (in case it does not get connected)", - variableStructType(input, reactor, false)+" _lf_default__"+inputName+";", - "// Struct to support efficiently reading sparse inputs.", - "lf_sparse_io_record_t* _lf_"+inputName+"__sparse;" - )); - } else { - // input is not a multiport. - body.pr(input, String.join("\n", - variableStructType(input, reactor, false)+"* _lf_"+inputName+";", - "// width of -2 indicates that it is not a multiport.", - "int _lf_"+inputName+"_width;", - "// Default input (in case it does not get connected)", - variableStructType(input, reactor, false)+" _lf_default__"+inputName+";" - )); + /** + * Generate fields in the self struct for input ports + * + *

    If the port is a multiport, the input field is an array of pointers that will be allocated + * separately for each instance because the sizes may be different. Otherwise, it is a simple + * pointer. + */ + private static void generateInputDeclarations( + Reactor reactor, ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode) { + for (Input input : ASTUtils.allInputs(reactor)) { + var inputName = input.getName(); + if (ASTUtils.isMultiport(input)) { + body.pr( + input, + String.join( + "\n", + "// Multiport input array will be malloc'd later.", + variableStructType(input, reactor, false) + "** _lf_" + inputName + ";", + "int _lf_" + inputName + "_width;", + "// Default input (in case it does not get connected)", + variableStructType(input, reactor, false) + " _lf_default__" + inputName + ";", + "// Struct to support efficiently reading sparse inputs.", + "lf_sparse_io_record_t* _lf_" + inputName + "__sparse;")); + } else { + // input is not a multiport. + body.pr( + input, + String.join( + "\n", + variableStructType(input, reactor, false) + "* _lf_" + inputName + ";", + "// width of -2 indicates that it is not a multiport.", + "int _lf_" + inputName + "_width;", + "// Default input (in case it does not get connected)", + variableStructType(input, reactor, false) + " _lf_default__" + inputName + ";")); - constructorCode.pr(input, String.join("\n", - "// Set input by default to an always absent default input.", - "self->_lf_"+inputName+" = &self->_lf_default__"+inputName+";" - )); - } - constructorCode.pr(input, String.join("\n", - "// Set the default source reactor pointer", - "self->_lf_default__"+inputName+"._base.source_reactor = (self_base_t*)self;" - )); - } + constructorCode.pr( + input, + String.join( + "\n", + "// Set input by default to an always absent default input.", + "self->_lf_" + inputName + " = &self->_lf_default__" + inputName + ";")); + } + constructorCode.pr( + input, + String.join( + "\n", + "// Set the default source reactor pointer", + "self->_lf_default__" + inputName + "._base.source_reactor = (self_base_t*)self;")); } + } - /** - * Generate fields in the self struct for output ports - * - * @param reactor - * @param decl - * @param body - * @param constructorCode - */ - private static void generateOutputDeclarations( - Reactor reactor, - ReactorDecl decl, - CodeBuilder body, - CodeBuilder constructorCode - ) { - for (Output output : ASTUtils.allOutputs(reactor)) { - // If the port is a multiport, create an array to be allocated - // at instantiation. - var outputName = output.getName(); - if (ASTUtils.isMultiport(output)) { - body.pr(output, String.join("\n", - "// Array of output ports.", - variableStructType(output, reactor, false)+"* _lf_"+outputName+";", - "int _lf_"+outputName+"_width;", - "// An array of pointers to the individual ports. Useful", - "// for the lf_set macros to work out-of-the-box for", - "// multiports in the body of reactions because their ", - "// value can be accessed via a -> operator (e.g.,foo[i]->value).", - "// So we have to handle multiports specially here a construct that", - "// array of pointers.", - variableStructType(output, reactor, false)+"** _lf_"+outputName+"_pointers;" - )); - } else { - body.pr(output, String.join("\n", - variableStructType(output, reactor, false)+" _lf_"+outputName+";", - "int _lf_"+outputName+"_width;" - )); - } - } + /** + * Generate fields in the self struct for output ports + * + * @param reactor + * @param decl + * @param body + * @param constructorCode + */ + private static void generateOutputDeclarations( + Reactor reactor, ReactorDecl decl, CodeBuilder body, CodeBuilder constructorCode) { + for (Output output : ASTUtils.allOutputs(reactor)) { + // If the port is a multiport, create an array to be allocated + // at instantiation. + var outputName = output.getName(); + if (ASTUtils.isMultiport(output)) { + body.pr( + output, + String.join( + "\n", + "// Array of output ports.", + variableStructType(output, reactor, false) + "* _lf_" + outputName + ";", + "int _lf_" + outputName + "_width;", + "// An array of pointers to the individual ports. Useful", + "// for the lf_set macros to work out-of-the-box for", + "// multiports in the body of reactions because their ", + "// value can be accessed via a -> operator (e.g.,foo[i]->value).", + "// So we have to handle multiports specially here a construct that", + "// array of pointers.", + variableStructType(output, reactor, false) + + "** _lf_" + + outputName + + "_pointers;")); + } else { + body.pr( + output, + String.join( + "\n", + variableStructType(output, reactor, false) + " _lf_" + outputName + ";", + "int _lf_" + outputName + "_width;")); + } } + } } diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java index 60b12c887a..0aa503b934 100644 --- a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java @@ -1,4 +1,5 @@ package org.lflang.generator.c; + import static org.lflang.generator.c.CMixedRadixGenerator.db; import static org.lflang.generator.c.CMixedRadixGenerator.dc; import static org.lflang.generator.c.CMixedRadixGenerator.dr; @@ -8,15 +9,13 @@ import static org.lflang.util.StringUtil.addDoubleQuotes; import static org.lflang.util.StringUtil.joinObjects; +import com.google.common.collect.Iterables; import java.util.Arrays; import java.util.HashSet; -import java.util.LinkedHashMap; import java.util.stream.Collectors; - import org.lflang.ASTUtils; import org.lflang.AttributeUtils; import org.lflang.TargetConfig; - import org.lflang.TargetProperty.LogLevel; import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.CodeBuilder; @@ -26,8 +25,6 @@ import org.lflang.generator.RuntimeRange; import org.lflang.generator.SendRange; -import com.google.common.collect.Iterables; - /** * Generate code for the "_lf_initialize_trigger_objects" function * @@ -36,1029 +33,1098 @@ * @author Hou Seng Wong */ public class CTriggerObjectsGenerator { - /** - * Generate the _lf_initialize_trigger_objects function for 'federate'. - */ - public static String generateInitializeTriggerObjects( - ReactorInstance main, - TargetConfig targetConfig, - CodeBuilder initializeTriggerObjects, - CodeBuilder startTimeStep, - CTypes types, - String lfModuleName, - int startTimeStepIsPresentCount - ) { - var code = new CodeBuilder(); - code.pr("void _lf_initialize_trigger_objects() {"); - code.indent(); - // Initialize the LF clock. - code.pr(String.join("\n", - "// Initialize the _lf_clock", - "lf_initialize_clock();" - )); - - // Initialize tracing if it is enabled - if (targetConfig.tracing != null) { - var traceFileName = lfModuleName; - if (targetConfig.tracing.traceFileName != null) { - traceFileName = targetConfig.tracing.traceFileName; - } - code.pr(String.join("\n", - "// Initialize tracing", - "start_trace("+ addDoubleQuotes(traceFileName + ".lft") + ");" - )); // .lft is for Lingua Franca trace - } + /** Generate the _lf_initialize_trigger_objects function for 'federate'. */ + public static String generateInitializeTriggerObjects( + ReactorInstance main, + TargetConfig targetConfig, + CodeBuilder initializeTriggerObjects, + CodeBuilder startTimeStep, + CTypes types, + String lfModuleName, + int startTimeStepIsPresentCount) { + var code = new CodeBuilder(); + code.pr("void _lf_initialize_trigger_objects() {"); + code.indent(); + // Initialize the LF clock. + code.pr(String.join("\n", "// Initialize the _lf_clock", "lf_initialize_clock();")); + + // Initialize tracing if it is enabled + if (targetConfig.tracing != null) { + var traceFileName = lfModuleName; + if (targetConfig.tracing.traceFileName != null) { + traceFileName = targetConfig.tracing.traceFileName; + } + code.pr( + String.join( + "\n", + "// Initialize tracing", + "start_trace(" + + addDoubleQuotes(traceFileName + ".lft") + + ");")); // .lft is for Lingua Franca trace + } - // Create the table to initialize is_present fields to false between time steps. - if (startTimeStepIsPresentCount > 0) { - // Allocate the initial (before mutations) array of pointers to _is_present fields. - code.pr(String.join("\n", - "// Create the array that will contain pointers to is_present fields to reset on each step.", - "_lf_is_present_fields_size = "+startTimeStepIsPresentCount+";", - "_lf_is_present_fields = (bool**)calloc("+startTimeStepIsPresentCount+", sizeof(bool*));", - "if (_lf_is_present_fields == NULL) lf_print_error_and_exit(" + addDoubleQuotes("Out of memory!") + ");", - "_lf_is_present_fields_abbreviated = (bool**)calloc("+startTimeStepIsPresentCount+", sizeof(bool*));", - "if (_lf_is_present_fields_abbreviated == NULL) lf_print_error_and_exit(" + addDoubleQuotes("Out of memory!") + ");", - "_lf_is_present_fields_abbreviated_size = 0;" - )); - } + // Create the table to initialize is_present fields to false between time steps. + if (startTimeStepIsPresentCount > 0) { + // Allocate the initial (before mutations) array of pointers to _is_present fields. + code.pr( + String.join( + "\n", + "// Create the array that will contain pointers to is_present fields to reset on each" + + " step.", + "_lf_is_present_fields_size = " + startTimeStepIsPresentCount + ";", + "_lf_is_present_fields = (bool**)calloc(" + + startTimeStepIsPresentCount + + ", sizeof(bool*));", + "if (_lf_is_present_fields == NULL) lf_print_error_and_exit(" + + addDoubleQuotes("Out of memory!") + + ");", + "_lf_is_present_fields_abbreviated = (bool**)calloc(" + + startTimeStepIsPresentCount + + ", sizeof(bool*));", + "if (_lf_is_present_fields_abbreviated == NULL) lf_print_error_and_exit(" + + addDoubleQuotes("Out of memory!") + + ");", + "_lf_is_present_fields_abbreviated_size = 0;")); + } - // Create the table to initialize intended tag fields to 0 between time - // steps. - if (startTimeStepIsPresentCount > 0) { - // Allocate the initial (before mutations) array of pointers to - // intended_tag fields. - // There is a 1-1 map between structs containing is_present and - // intended_tag fields, - // thus, we reuse startTimeStepIsPresentCount as the counter. - code.pr(String.join("\n", - CExtensionUtils.surroundWithIfFederatedDecentralized(""" + // Create the table to initialize intended tag fields to 0 between time + // steps. + if (startTimeStepIsPresentCount > 0) { + // Allocate the initial (before mutations) array of pointers to + // intended_tag fields. + // There is a 1-1 map between structs containing is_present and + // intended_tag fields, + // thus, we reuse startTimeStepIsPresentCount as the counter. + code.pr( + String.join( + "\n", + CExtensionUtils.surroundWithIfFederatedDecentralized( + """ // Create the array that will contain pointers to intended_tag fields to reset on each step. _lf_intended_tag_fields_size = %s; _lf_intended_tag_fields = (tag_t**)malloc(_lf_intended_tag_fields_size * sizeof(tag_t*)); - """.formatted(startTimeStepIsPresentCount) - ) - )); - } - + """ + .formatted(startTimeStepIsPresentCount)))); + } - code.pr(initializeTriggerObjects.toString()); - - code.pr(deferredInitialize( - main, - main.reactions, - targetConfig, - types - )); - code.pr(deferredInitializeNonNested( - main, - main, - main.reactions, - types - )); - // Next, for every input port, populate its "self" struct - // fields with pointers to the output port that sends it data. - code.pr(deferredConnectInputsToOutputs( - main - )); - // Put the code here to set up the tables that drive resetting is_present and - // decrementing reference counts between time steps. This code has to appear - // in _lf_initialize_trigger_objects() after the code that makes connections - // between inputs and outputs. - code.pr(startTimeStep.toString()); - code.pr(setReactionPriorities( - main - )); - code.pr(generateSchedulerInitializer( - main, - targetConfig - )); - - code.pr(""" + code.pr(initializeTriggerObjects.toString()); + + code.pr(deferredInitialize(main, main.reactions, targetConfig, types)); + code.pr(deferredInitializeNonNested(main, main, main.reactions, types)); + // Next, for every input port, populate its "self" struct + // fields with pointers to the output port that sends it data. + code.pr(deferredConnectInputsToOutputs(main)); + // Put the code here to set up the tables that drive resetting is_present and + // decrementing reference counts between time steps. This code has to appear + // in _lf_initialize_trigger_objects() after the code that makes connections + // between inputs and outputs. + code.pr(startTimeStep.toString()); + code.pr(setReactionPriorities(main)); + code.pr(generateSchedulerInitializer(main, targetConfig)); + + code.pr( + """ #ifdef EXECUTABLE_PREAMBLE _lf_executable_preamble(); #endif """); - // Initialize triggers for federated execution. - code.pr(CExtensionUtils.surroundWithIfFederated("initialize_triggers_for_federate();")); + // Initialize triggers for federated execution. + code.pr(CExtensionUtils.surroundWithIfFederated("initialize_triggers_for_federate();")); - code.unindent(); - code.pr("}\n"); - return code.toString(); - } + code.unindent(); + code.pr("}\n"); + return code.toString(); + } - /** - * Generate code to initialize the scheduler for the threaded C runtime. - */ - public static String generateSchedulerInitializer( - ReactorInstance main, - TargetConfig targetConfig - ) { - if (!targetConfig.threading) { - return ""; - } - var code = new CodeBuilder(); - var numReactionsPerLevel = main.assignLevels().getNumReactionsPerLevel(); - var numReactionsPerLevelJoined = Arrays.stream(numReactionsPerLevel) - .map(String::valueOf) - .collect(Collectors.joining(", ")); - code.pr(String.join("\n", + /** Generate code to initialize the scheduler for the threaded C runtime. */ + public static String generateSchedulerInitializer( + ReactorInstance main, TargetConfig targetConfig) { + if (!targetConfig.threading) { + return ""; + } + var code = new CodeBuilder(); + var numReactionsPerLevel = main.assignLevels().getNumReactionsPerLevel(); + var numReactionsPerLevelJoined = + Arrays.stream(numReactionsPerLevel).map(String::valueOf).collect(Collectors.joining(", ")); + code.pr( + String.join( + "\n", "// Initialize the scheduler", - "size_t num_reactions_per_level["+numReactionsPerLevel.length+"] = ", + "size_t num_reactions_per_level[" + numReactionsPerLevel.length + "] = ", " {" + numReactionsPerLevelJoined + "};", "sched_params_t sched_params = (sched_params_t) {", " .num_reactions_per_level = &num_reactions_per_level[0],", - " .num_reactions_per_level_size = (size_t) "+numReactionsPerLevel.length+"};", + " .num_reactions_per_level_size = (size_t) " + + numReactionsPerLevel.length + + "};", "lf_sched_init(", " (size_t)_lf_number_of_workers,", " &sched_params", - ");" - )); - return code.toString(); + ");")); + return code.toString(); + } + + /** + * * Set the reaction priorities based on dependency analysis. + * + * @param reactor The reactor on which to do this. + */ + private static String setReactionPriorities(ReactorInstance reactor) { + var code = new CodeBuilder(); + setReactionPriorities(reactor, code); + return code.toString(); + } + + /** + * * Set the reaction priorities based on dependency analysis. + * + * @param reactor The reactor on which to do this. + * @param builder Where to write the code. + */ + private static boolean setReactionPriorities(ReactorInstance reactor, CodeBuilder builder) { + var foundOne = false; + // Force calculation of levels if it has not been done. + // FIXME: Comment out this as I think it is redundant. + // If it is NOT redundant then deadline propagation is not correct + // reactor.assignLevels(); + + // We handle four different scenarios + // 1) A reactionInstance has 1 level and 1 deadline + // 2) A reactionInstance has 1 level but multiple deadlines + // 3) A reaction instance has multiple levels but all have the same deadline + // 4) Multiple deadlines and levels + + var prolog = new CodeBuilder(); + var epilog = new CodeBuilder(); + + for (ReactionInstance r : reactor.reactions) { + var levelSet = r.getLevels(); + var deadlineSet = r.getInferredDeadlines(); + + if (levelSet.size() > 1 || deadlineSet.size() > 1) { + // Scenario 2-4 + if (prolog.length() == 0) { + prolog.startScopedBlock(); + epilog.endScopedBlock(); + } + } + if (deadlineSet.size() > 1) { + // Scenario (2) or (4) + var deadlines = + r.getInferredDeadlinesList().stream() + .map(elt -> ("0x" + Long.toString(elt.toNanoSeconds(), 16) + "LL")) + .collect(Collectors.toList()); + + prolog.pr( + "interval_t " + + r.uniqueID() + + "_inferred_deadlines[] = { " + + joinObjects(deadlines, ", ") + + " };"); + } + + if (levelSet.size() > 1) { + // Scenario (3) or (4) + // Cannot use the above set of levels because it is a set, not a list. + prolog.pr( + "int " + + r.uniqueID() + + "_levels[] = { " + + joinObjects(r.getLevelsList(), ", ") + + " };"); + } } - /** - * * Set the reaction priorities based on dependency analysis. - * - * @param reactor The reactor on which to do this. - */ - private static String setReactionPriorities( - ReactorInstance reactor - ) { - var code = new CodeBuilder(); - setReactionPriorities(reactor, code); - return code.toString(); + var temp = new CodeBuilder(); + temp.pr("// Set reaction priorities for " + reactor); + temp.startScopedBlock(reactor); + for (ReactionInstance r : reactor.reactions) { + // if (currentFederate.contains(r.getDefinition())) { + foundOne = true; + var levelSet = r.getLevels(); + var deadlineSet = r.getInferredDeadlines(); + + // Get the head of the associated lists. To avoid duplication in + // several of the following cases + var level = r.getLevelsList().get(0); + var inferredDeadline = r.getInferredDeadlinesList().get(0); + var runtimeIdx = CUtil.runtimeIndex(r.getParent()); + + if (levelSet.size() == 1 && deadlineSet.size() == 1) { + // Scenario (1) + + var indexValue = inferredDeadline.toNanoSeconds() << 16 | level; + + var reactionIndex = "0x" + Long.toUnsignedString(indexValue, 16) + "LL"; + + temp.pr( + String.join( + "\n", + CUtil.reactionRef(r) + ".chain_id = " + r.chainID + ";", + "// index is the OR of level " + level + " and ", + "// deadline " + inferredDeadline.toNanoSeconds() + " shifted left 16 bits.", + CUtil.reactionRef(r) + ".index = " + reactionIndex + ";")); + } else if (levelSet.size() == 1 && deadlineSet.size() > 1) { + // Scenario 2 + temp.pr( + String.join( + "\n", + CUtil.reactionRef(r) + ".chain_id = " + r.chainID + ";", + "// index is the OR of levels[" + runtimeIdx + "] and ", + "// deadlines[" + runtimeIdx + "] shifted left 16 bits.", + CUtil.reactionRef(r) + + ".index = (" + + r.uniqueID() + + "_inferred_deadlines[" + + runtimeIdx + + "] << 16) | " + + level + + ";")); + + } else if (levelSet.size() > 1 && deadlineSet.size() == 1) { + // Scenarion (3) + temp.pr( + String.join( + "\n", + CUtil.reactionRef(r) + ".chain_id = " + r.chainID + ";", + "// index is the OR of levels[" + runtimeIdx + "] and ", + "// deadlines[" + runtimeIdx + "] shifted left 16 bits.", + CUtil.reactionRef(r) + + ".index = (" + + inferredDeadline.toNanoSeconds() + + " << 16) | " + + r.uniqueID() + + "_levels[" + + runtimeIdx + + "];")); + + } else if (levelSet.size() > 1 && deadlineSet.size() > 1) { + // Scenario (4) + temp.pr( + String.join( + "\n", + CUtil.reactionRef(r) + ".chain_id = " + r.chainID + ";", + "// index is the OR of levels[" + runtimeIdx + "] and ", + "// deadlines[" + runtimeIdx + "] shifted left 16 bits.", + CUtil.reactionRef(r) + + ".index = (" + + r.uniqueID() + + "_inferred_deadlines[" + + runtimeIdx + + "] << 16) | " + + r.uniqueID() + + "_levels[" + + runtimeIdx + + "];")); + } } - - /** - * * Set the reaction priorities based on dependency analysis. - * - * @param reactor The reactor on which to do this. - * @param builder Where to write the code. - */ - private static boolean setReactionPriorities( - ReactorInstance reactor, - CodeBuilder builder - ) { - var foundOne = false; - // Force calculation of levels if it has not been done. - // FIXME: Comment out this as I think it is redundant. - // If it is NOT redundant then deadline propagation is not correct - // reactor.assignLevels(); - - // We handle four different scenarios - // 1) A reactionInstance has 1 level and 1 deadline - // 2) A reactionInstance has 1 level but multiple deadlines - // 3) A reaction instance has multiple levels but all have the same deadline - // 4) Multiple deadlines and levels - - var prolog = new CodeBuilder(); - var epilog = new CodeBuilder(); - - for (ReactionInstance r : reactor.reactions) { - var levelSet = r.getLevels(); - var deadlineSet = r.getInferredDeadlines(); - - if (levelSet.size() > 1 || deadlineSet.size() > 1) { - // Scenario 2-4 - if (prolog.length() == 0) { - prolog.startScopedBlock(); - epilog.endScopedBlock(); - } - } - if (deadlineSet.size() > 1) { - // Scenario (2) or (4) - var deadlines = r.getInferredDeadlinesList().stream() - .map(elt -> ("0x" + Long.toString(elt.toNanoSeconds(), 16) + "LL")) - .collect(Collectors.toList()); - - prolog.pr("interval_t "+r.uniqueID()+"_inferred_deadlines[] = { "+joinObjects(deadlines, ", ")+" };"); - } - - if (levelSet.size() > 1) { - // Scenario (3) or (4) - // Cannot use the above set of levels because it is a set, not a list. - prolog.pr("int "+r.uniqueID()+"_levels[] = { "+joinObjects(r.getLevelsList(), ", ")+" };"); - } - } - - - var temp = new CodeBuilder(); - temp.pr("// Set reaction priorities for " + reactor); - temp.startScopedBlock(reactor); - for (ReactionInstance r : reactor.reactions) { - //if (currentFederate.contains(r.getDefinition())) { - foundOne = true; - var levelSet = r.getLevels(); - var deadlineSet = r.getInferredDeadlines(); - - // Get the head of the associated lists. To avoid duplication in - // several of the following cases - var level = r.getLevelsList().get(0); - var inferredDeadline = r.getInferredDeadlinesList().get(0); - var runtimeIdx =CUtil.runtimeIndex(r.getParent()); - - if (levelSet.size() == 1 && deadlineSet.size() == 1) { - // Scenario (1) - - var indexValue = inferredDeadline.toNanoSeconds() << 16 | level; - - var reactionIndex = "0x" + Long.toUnsignedString(indexValue, 16) + "LL"; - - temp.pr(String.join("\n", - CUtil.reactionRef(r)+".chain_id = "+r.chainID+";", - "// index is the OR of level "+level+" and ", - "// deadline "+ inferredDeadline.toNanoSeconds()+" shifted left 16 bits.", - CUtil.reactionRef(r)+".index = "+reactionIndex+";" - )); - } else if (levelSet.size() == 1 && deadlineSet.size() > 1) { - // Scenario 2 - temp.pr(String.join("\n", - CUtil.reactionRef(r)+".chain_id = "+r.chainID+";", - "// index is the OR of levels["+runtimeIdx+"] and ", - "// deadlines["+runtimeIdx+"] shifted left 16 bits.", - CUtil.reactionRef(r)+".index = ("+r.uniqueID()+"_inferred_deadlines["+runtimeIdx+"] << 16) | " + - level+";" - )); - - } else if (levelSet.size() > 1 && deadlineSet.size() == 1) { - // Scenarion (3) - temp.pr(String.join("\n", - CUtil.reactionRef(r)+".chain_id = "+r.chainID+";", - "// index is the OR of levels["+runtimeIdx+"] and ", - "// deadlines["+runtimeIdx+"] shifted left 16 bits.", - CUtil.reactionRef(r)+".index = ("+inferredDeadline.toNanoSeconds()+" << 16) | " + - r.uniqueID()+"_levels["+runtimeIdx+"];" - )); - - } else if (levelSet.size() > 1 && deadlineSet.size() > 1) { - // Scenario (4) - temp.pr(String.join("\n", - CUtil.reactionRef(r)+".chain_id = "+r.chainID+";", - "// index is the OR of levels["+runtimeIdx+"] and ", - "// deadlines["+runtimeIdx+"] shifted left 16 bits.", - CUtil.reactionRef(r)+".index = ("+r.uniqueID()+"_inferred_deadlines["+runtimeIdx+"] << 16) | " + - r.uniqueID()+"_levels["+runtimeIdx+"];" - )); - } - - } - for (ReactorInstance child : reactor.children) { - foundOne = setReactionPriorities(child, temp) || foundOne; - } - temp.endScopedBlock(); - - if (foundOne) { - builder.pr(prolog.toString()); - builder.pr(temp.toString()); - builder.pr(epilog.toString()); - } - return foundOne; + for (ReactorInstance child : reactor.children) { + foundOne = setReactionPriorities(child, temp) || foundOne; } + temp.endScopedBlock(); - /** - * Generate assignments of pointers in the "self" struct of a destination - * port's reactor to the appropriate entries in the "self" struct of the - * source reactor. This has to be done after all reactors have been created - * because inputs point to outputs that are arbitrarily far away. - * @param instance The reactor instance. - */ - private static String deferredConnectInputsToOutputs( - ReactorInstance instance - ) { - var code = new CodeBuilder(); - code.pr("// Connect inputs and outputs for reactor "+instance.getFullName()+"."); - // Iterate over all ports of this reactor that depend on reactions. - for (PortInstance input : instance.inputs) { - if (!input.getDependsOnReactions().isEmpty()) { - // Input is written to by reactions in the parent of the port's parent. - code.pr(connectPortToEventualDestinations(input)); - } - } - for (PortInstance output : instance.outputs) { - if (!output.getDependsOnReactions().isEmpty()) { - // Output is written to by reactions in the port's parent. - code.pr(connectPortToEventualDestinations(output)); - } - } - for (ReactorInstance child: instance.children) { - code.pr(deferredConnectInputsToOutputs(child)); - } - return code.toString(); + if (foundOne) { + builder.pr(prolog.toString()); + builder.pr(temp.toString()); + builder.pr(epilog.toString()); } - - /** - * Generate assignments of pointers in the "self" struct of a destination - * port's reactor to the appropriate entries in the "self" struct of the - * source reactor. If this port is an input, then it is being written - * to by a reaction belonging to the parent of the port's parent. - * If it is an output, then it is being written to by a reaction belonging - * to the port's parent. - * @param src A port that is written to by reactions. - */ - private static String connectPortToEventualDestinations( - PortInstance src - ) { - var code = new CodeBuilder(); - for (SendRange srcRange: src.eventualDestinations()) { - for (RuntimeRange dstRange : srcRange.destinations) { - var dst = dstRange.instance; - var destStructType = CGenerator.variableStructType(dst); - - // NOTE: For federated execution, dst.getParent() should always be contained - // by the currentFederate because an AST transformation removes connections - // between ports of distinct federates. So the following check is not - // really necessary. - var mod = (dst.isMultiport() || (src.isInput() && src.isMultiport()))? "" : "&"; - code.pr("// Connect "+srcRange+" to port "+dstRange); - code.startScopedRangeBlock(srcRange, dstRange); - if (src.isInput()) { - // Source port is written to by reaction in port's parent's parent - // and ultimate destination is further downstream. - code.pr(CUtil.portRef(dst, dr, db, dc)+" = ("+destStructType+"*)"+mod+CUtil.portRefNested(src, sr, sb, sc)+";"); - } else if (dst.isOutput()) { - // An output port of a contained reactor is triggering a reaction. - code.pr(CUtil.portRefNested(dst, dr, db, dc)+" = ("+destStructType+"*)&"+CUtil.portRef(src, sr, sb, sc)+";"); - } else { - // An output port is triggering an input port. - code.pr(CUtil.portRef(dst, dr, db, dc)+" = ("+destStructType+"*)&"+CUtil.portRef(src, sr, sb, sc)+";"); - if (AttributeUtils.isSparse(dst.getDefinition())) { - code.pr(CUtil.portRef(dst, dr, db, dc)+"->sparse_record = "+CUtil.portRefName(dst, dr, db, dc)+"__sparse;"); - code.pr(CUtil.portRef(dst, dr, db, dc)+"->destination_channel = "+dc+";"); - } - } - code.endScopedRangeBlock(srcRange, dstRange); - } - } - return code.toString(); + return foundOne; + } + + /** + * Generate assignments of pointers in the "self" struct of a destination port's reactor to the + * appropriate entries in the "self" struct of the source reactor. This has to be done after all + * reactors have been created because inputs point to outputs that are arbitrarily far away. + * + * @param instance The reactor instance. + */ + private static String deferredConnectInputsToOutputs(ReactorInstance instance) { + var code = new CodeBuilder(); + code.pr("// Connect inputs and outputs for reactor " + instance.getFullName() + "."); + // Iterate over all ports of this reactor that depend on reactions. + for (PortInstance input : instance.inputs) { + if (!input.getDependsOnReactions().isEmpty()) { + // Input is written to by reactions in the parent of the port's parent. + code.pr(connectPortToEventualDestinations(input)); + } } - - /** - * For each reaction of the specified reactor, - * set the last_enabling_reaction field of the reaction struct to point - * to the single dominating upstream reaction if there is one, or to be - * NULL if there is none. - * - * @param r The reactor. - */ - private static String deferredOptimizeForSingleDominatingReaction( - ReactorInstance r - ) { - var code = new CodeBuilder(); - for (ReactionInstance reaction : r.reactions) { - // The following code attempts to gather into a loop assignments of successive - // bank members relations between reactions to avoid large chunks of inline code - // when a large bank sends to a large bank or when a large bank receives from - // one reaction that is either multicasting or sending through a multiport. - var start = 0; - var end = 0; - var domStart = 0; - var same = false; // Set to true when finding a string of identical dominating reactions. - ReactionInstance.Runtime previousRuntime = null; - var first = true; //First time through the loop. - for (ReactionInstance.Runtime runtime : reaction.getRuntimeInstances()) { - if (!first) { // Not the first time through the loop. - if (same) { // Previously seen at least two identical dominating. - if (runtime.dominating != previousRuntime.dominating) { - // End of streak of same dominating reaction runtime instance. - code.pr(printOptimizeForSingleDominatingReaction( - previousRuntime, start, end, domStart, same - )); - same = false; - start = runtime.id; - domStart = (runtime.dominating != null) ? runtime.dominating.id : 0; - } - } else if (runtime.dominating == previousRuntime.dominating) { - // Start of a streak of identical dominating reaction runtime instances. - same = true; - } else if (runtime.dominating != null && previousRuntime.dominating != null - && runtime.dominating.getReaction() == previousRuntime.dominating.getReaction() - ) { - // Same dominating reaction even if not the same dominating runtime. - if (runtime.dominating.id != previousRuntime.dominating.id + 1) { - // End of a streak of contiguous runtimes. - printOptimizeForSingleDominatingReaction( - previousRuntime, start, end, domStart, same - ); - same = false; - start = runtime.id; - domStart = runtime.dominating.id; - } - } else { - // Different dominating reaction. - printOptimizeForSingleDominatingReaction( - previousRuntime, start, end, domStart, same - ); - same = false; - start = runtime.id; - domStart = (runtime.dominating != null) ? runtime.dominating.id : 0; - } - } - first = false; - previousRuntime = runtime; - end++; - } - if (end > start) { - printOptimizeForSingleDominatingReaction( - previousRuntime, start, end, domStart, same - ); - } - } - return code.toString(); + for (PortInstance output : instance.outputs) { + if (!output.getDependsOnReactions().isEmpty()) { + // Output is written to by reactions in the port's parent. + code.pr(connectPortToEventualDestinations(output)); + } } - - /** - * Print statement that sets the last_enabling_reaction field of a reaction. - */ - private static String printOptimizeForSingleDominatingReaction( - ReactionInstance.Runtime runtime, - int start, - int end, - int domStart, - boolean same - ) { - var code = new CodeBuilder(); - var dominatingRef = "NULL"; - - if (end > start + 1) { - code.startScopedBlock(); - var reactionRef = CUtil.reactionRef(runtime.getReaction(), "i"); - if (runtime.dominating != null) { - if (same) { - dominatingRef = "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "" + domStart) + ")"; - } else { - dominatingRef = "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "j++") + ")"; - } - } - code.pr(String.join("\n", - "// "+runtime.getReaction().getFullName()+" dominating upstream reaction.", - "int j = "+domStart+";", - "for (int i = "+start+"; i < "+end+"; i++) {", - " "+reactionRef+".last_enabling_reaction = "+dominatingRef+";", - "}" - )); - code.endScopedBlock(); - } else if (end == start + 1) { - var reactionRef = CUtil.reactionRef(runtime.getReaction(), "" + start); - if (runtime.dominating != null) { - dominatingRef = "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "" + domStart) + ")"; - } - code.pr(String.join("\n", - "// "+runtime.getReaction().getFullName()+" dominating upstream reaction.", - reactionRef+".last_enabling_reaction = "+dominatingRef+";" - )); - } - return code.toString(); + for (ReactorInstance child : instance.children) { + code.pr(deferredConnectInputsToOutputs(child)); } - - /** - * For the specified reaction, for ports that it writes to, - * fill the trigger table for triggering downstream reactions. - * - * @param reactions The reactions. - */ - private static String deferredFillTriggerTable( - Iterable reactions - ) { - var code = new CodeBuilder(); - for (ReactionInstance reaction : reactions) { - var name = reaction.getParent().getFullName(); - - var reactorSelfStruct = CUtil.reactorRef(reaction.getParent(), sr); - - var foundPort = false; - - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (!foundPort) { - // Need a separate index for the triggers array for each bank member. - code.startScopedBlock(); - code.pr("int triggers_index["+reaction.getParent().getTotalWidth()+"] = { 0 }; // Number of bank members with the reaction."); - foundPort = true; - } - // If the port is a multiport, then its channels may have different sets - // of destinations. For ordinary ports, there will be only one range and - // its width will be 1. - // We generate the code to fill the triggers array first in a temporary code buffer, - // so that we can simultaneously calculate the size of the total array. - for (SendRange srcRange : port.eventualDestinations()) { - var srcNested = port.isInput(); - code.startScopedRangeBlock(srcRange, sr, sb, sc, srcNested); - - var triggerArray = CUtil.reactionRef(reaction, sr)+".triggers[triggers_index["+sr+"]++]"; - // Skip ports whose parent is not in the federation. - // This can happen with reactions in the top-level that have - // as an effect a port in a bank. - code.pr(String.join("\n", - "// Reaction "+reaction.index+" of "+name+" triggers "+srcRange.destinations.size()+" downstream reactions", - "// through port "+port.getFullName()+".", - CUtil.reactionRef(reaction, sr)+".triggered_sizes[triggers_index["+sr+"]] = "+srcRange.destinations.size()+";", - "// For reaction "+reaction.index+" of "+name+", allocate an", - "// array of trigger pointers for downstream reactions through port "+port.getFullName(), - "trigger_t** trigger_array = (trigger_t**)_lf_allocate(", - " "+srcRange.destinations.size()+", sizeof(trigger_t*),", - " &"+reactorSelfStruct+"->base.allocations); ", - triggerArray+" = trigger_array;" - )); - code.endScopedRangeBlock(srcRange); - } - } - var cumulativePortWidth = 0; - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - // If this port does not have any destinations, do not generate code for it. - if (port.eventualDestinations().isEmpty()) continue; - - code.pr("for (int i = 0; i < "+reaction.getParent().getTotalWidth()+"; i++) triggers_index[i] = "+cumulativePortWidth+";"); - for (SendRange srcRange : port.eventualDestinations()) { - var srcNested = srcRange.instance.isInput(); - var multicastCount = 0; - for (RuntimeRange dstRange : srcRange.destinations) { - var dst = dstRange.instance; - - code.startScopedRangeBlock(srcRange, dstRange); - - // If the source is nested, need to take into account the parent's bank index - // when indexing into the triggers array. - var triggerArray = ""; - if (srcNested && port.getParent().getWidth() > 1) { - triggerArray = CUtil.reactionRef(reaction, sr)+".triggers[triggers_index["+sr+"] + "+sc+" + src_range_mr.digits[1] * src_range_mr.radixes[0]]"; - } else { - triggerArray = CUtil.reactionRef(reaction, sr)+".triggers[triggers_index["+sr+"] + "+sc+"]"; - } - - if (dst.isOutput()) { - // Include this destination port only if it has at least one - // reaction in the federation. - var belongs = false; - for (ReactionInstance destinationReaction : dst.getDependentReactions()) { - belongs = true; - } - if (belongs) { - code.pr(String.join("\n", - "// Port "+port.getFullName()+" has reactions in its parent's parent.", - "// Point to the trigger struct for those reactions.", - triggerArray+"["+multicastCount+"] = &"+CUtil.triggerRefNested(dst, dr, db)+";" - )); - } else { - // Put in a NULL pointer. - code.pr(String.join("\n", - "// Port "+port.getFullName()+" has reactions in its parent's parent.", - "// But those are not in the federation.", - triggerArray+"["+multicastCount+"] = NULL;" - )); - } - } else { - // Destination is an input port. - code.pr(String.join("\n", - "// Point to destination port "+dst.getFullName()+"'s trigger struct.", - triggerArray+"["+multicastCount+"] = &"+CUtil.triggerRef(dst, dr)+";" - )); - } - code.endScopedRangeBlock(srcRange, dstRange); - multicastCount++; - } - } - // If the port is an input of a contained reactor, then we have to take - // into account the bank width of the contained reactor. - if (port.getParent() != reaction.getParent()) { - cumulativePortWidth += port.getWidth() * port.getParent().getWidth(); - } else { - cumulativePortWidth += port.getWidth(); - } - } - if (foundPort) code.endScopedBlock(); + return code.toString(); + } + + /** + * Generate assignments of pointers in the "self" struct of a destination port's reactor to the + * appropriate entries in the "self" struct of the source reactor. If this port is an input, then + * it is being written to by a reaction belonging to the parent of the port's parent. If it is an + * output, then it is being written to by a reaction belonging to the port's parent. + * + * @param src A port that is written to by reactions. + */ + private static String connectPortToEventualDestinations(PortInstance src) { + var code = new CodeBuilder(); + for (SendRange srcRange : src.eventualDestinations()) { + for (RuntimeRange dstRange : srcRange.destinations) { + var dst = dstRange.instance; + var destStructType = CGenerator.variableStructType(dst); + + // NOTE: For federated execution, dst.getParent() should always be contained + // by the currentFederate because an AST transformation removes connections + // between ports of distinct federates. So the following check is not + // really necessary. + var mod = (dst.isMultiport() || (src.isInput() && src.isMultiport())) ? "" : "&"; + code.pr("// Connect " + srcRange + " to port " + dstRange); + code.startScopedRangeBlock(srcRange, dstRange); + if (src.isInput()) { + // Source port is written to by reaction in port's parent's parent + // and ultimate destination is further downstream. + code.pr( + CUtil.portRef(dst, dr, db, dc) + + " = (" + + destStructType + + "*)" + + mod + + CUtil.portRefNested(src, sr, sb, sc) + + ";"); + } else if (dst.isOutput()) { + // An output port of a contained reactor is triggering a reaction. + code.pr( + CUtil.portRefNested(dst, dr, db, dc) + + " = (" + + destStructType + + "*)&" + + CUtil.portRef(src, sr, sb, sc) + + ";"); + } else { + // An output port is triggering an input port. + code.pr( + CUtil.portRef(dst, dr, db, dc) + + " = (" + + destStructType + + "*)&" + + CUtil.portRef(src, sr, sb, sc) + + ";"); + if (AttributeUtils.isSparse(dst.getDefinition())) { + code.pr( + CUtil.portRef(dst, dr, db, dc) + + "->sparse_record = " + + CUtil.portRefName(dst, dr, db, dc) + + "__sparse;"); + code.pr(CUtil.portRef(dst, dr, db, dc) + "->destination_channel = " + dc + ";"); + } } - return code.toString(); + code.endScopedRangeBlock(srcRange, dstRange); + } } - - /** - * For each input port of a contained reactor that receives data - * from one or more of the specified reactions, set the num_destinations - * field of the corresponding port structs on the self struct of - * the reaction's parent reactor equal to the total number of - * destination reactors. - * If the port has a token type, this also initializes it with a token. - * @param reactions The reactions. - * @param types The C types. - */ - private static String deferredInputNumDestinations( - Iterable reactions, - CTypes types - ) { - // We need the number of destination _reactors_, not the - // number of destination ports nor the number of destination reactions. - // One of the destination reactors may be the container of this - // instance because it may have a reaction to an output of this instance. - // Since a port may be written to by multiple reactions, - // ensure that this is done only once. - var portsHandled = new HashSet(); - var code = new CodeBuilder(); - for (ReactionInstance reaction : reactions) { - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (port.isInput() && !portsHandled.contains(port)) { - // Port is an input of a contained reactor that gets data from a reaction of this reactor. - portsHandled.add(port); - code.pr("// Set number of destination reactors for port "+port.getParent().getName()+"."+port.getName()+"."); - // The input port may itself have multiple destinations. - for (SendRange sendingRange : port.eventualDestinations()) { - code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); - // Syntax is slightly different for a multiport output vs. single port. - var connector = (port.isMultiport())? "->" : "."; - code.pr(CUtil.portRefNested(port, sr, sb, sc)+connector+"_base.num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); - code.pr(CUtil.portRefNested(port, sr, sb, sc)+connector+"_base.source_reactor = (self_base_t*)"+CUtil.reactorRef(reaction.getParent(), sb)+";"); - - // Initialize token types. - var type = ASTUtils.getInferredType(port.getDefinition()); - if (CUtil.isTokenType(type, types)) { - // Create the template token that goes in the port struct. - var rootType = CUtil.rootType(types.getTargetType(type)); - // If the rootType is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var size = (rootType.equals("void")) ? "0" : "sizeof("+rootType+")"; - // If the port is a multiport, then the portRefNested is itself a pointer - // so we want its value, not its address. - var indirection = (port.isMultiport())? "" : "&"; - code.startChannelIteration(port); - code.pr(String.join("\n", - "_lf_initialize_template((token_template_t*)", - " "+indirection+"("+CUtil.portRefNested(port, sr, sb, sc)+"),", - size+");" - )); - code.endChannelIteration(port); - } - - code.endScopedRangeBlock(sendingRange); - } - } + return code.toString(); + } + + /** + * For each reaction of the specified reactor, set the last_enabling_reaction field of the + * reaction struct to point to the single dominating upstream reaction if there is one, or to be + * NULL if there is none. + * + * @param r The reactor. + */ + private static String deferredOptimizeForSingleDominatingReaction(ReactorInstance r) { + var code = new CodeBuilder(); + for (ReactionInstance reaction : r.reactions) { + // The following code attempts to gather into a loop assignments of successive + // bank members relations between reactions to avoid large chunks of inline code + // when a large bank sends to a large bank or when a large bank receives from + // one reaction that is either multicasting or sending through a multiport. + var start = 0; + var end = 0; + var domStart = 0; + var same = false; // Set to true when finding a string of identical dominating reactions. + ReactionInstance.Runtime previousRuntime = null; + var first = true; // First time through the loop. + for (ReactionInstance.Runtime runtime : reaction.getRuntimeInstances()) { + if (!first) { // Not the first time through the loop. + if (same) { // Previously seen at least two identical dominating. + if (runtime.dominating != previousRuntime.dominating) { + // End of streak of same dominating reaction runtime instance. + code.pr( + printOptimizeForSingleDominatingReaction( + previousRuntime, start, end, domStart, same)); + same = false; + start = runtime.id; + domStart = (runtime.dominating != null) ? runtime.dominating.id : 0; } - } - return code.toString(); - } - - /** - * For each output port of the specified reactor, - * set the num_destinations field of port structs on its self struct - * equal to the total number of destination reactors. This is used - * to initialize reference counts in dynamically allocated tokens - * sent to other reactors. - * @param reactor The reactor instance. - */ - private static String deferredOutputNumDestinations( - ReactorInstance reactor - ) { - // Reference counts are decremented by each destination reactor - // at the conclusion of a time step. Hence, the initial reference - // count should equal the number of destination _reactors_, not the - // number of destination ports nor the number of destination reactions. - // One of the destination reactors may be the container of this - // instance because it may have a reaction to an output of this instance. - var code = new CodeBuilder(); - for (PortInstance output : reactor.outputs) { - for (SendRange sendingRange : output.eventualDestinations()) { - code.pr("// For reference counting, set num_destinations for port " + output.getFullName() + "."); - code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); - code.pr(CUtil.portRef(output, sr, sb, sc)+"._base.num_destinations = "+sendingRange.getNumberOfDestinationReactors()+";"); - code.pr(CUtil.portRef(output, sr, sb, sc)+"._base.source_reactor = (self_base_t*)"+CUtil.reactorRef(reactor, sb)+";"); - code.endScopedRangeBlock(sendingRange); + } else if (runtime.dominating == previousRuntime.dominating) { + // Start of a streak of identical dominating reaction runtime instances. + same = true; + } else if (runtime.dominating != null + && previousRuntime.dominating != null + && runtime.dominating.getReaction() == previousRuntime.dominating.getReaction()) { + // Same dominating reaction even if not the same dominating runtime. + if (runtime.dominating.id != previousRuntime.dominating.id + 1) { + // End of a streak of contiguous runtimes. + printOptimizeForSingleDominatingReaction(previousRuntime, start, end, domStart, same); + same = false; + start = runtime.id; + domStart = runtime.dominating.id; } + } else { + // Different dominating reaction. + printOptimizeForSingleDominatingReaction(previousRuntime, start, end, domStart, same); + same = false; + start = runtime.id; + domStart = (runtime.dominating != null) ? runtime.dominating.id : 0; + } } - return code.toString(); + first = false; + previousRuntime = runtime; + end++; + } + if (end > start) { + printOptimizeForSingleDominatingReaction(previousRuntime, start, end, domStart, same); + } } - - /** - * Perform initialization functions that must be performed after - * all reactor runtime instances have been created. - * This function does not create nested loops over nested banks, - * so each function it calls must handle its own iteration - * over all runtime instance. - * @param reactor The container. - * @param main The top-level reactor. - * @param reactions The list of reactions to consider. - * @param types The C types. - */ - private static String deferredInitializeNonNested( - ReactorInstance reactor, - ReactorInstance main, - Iterable reactions, - CTypes types - ) { - var code = new CodeBuilder(); - code.pr("// **** Start non-nested deferred initialize for "+reactor.getFullName()); - // Initialize the num_destinations fields of port structs on the self struct. - // This needs to be outside the above scoped block because it performs - // its own iteration over ranges. - code.pr(deferredInputNumDestinations( - reactions, - types - )); - - // Second batch of initializes cannot be within a for loop - // iterating over bank members because they iterate over send - // ranges which may span bank members. - if (reactor != main) { - code.pr(deferredOutputNumDestinations( - reactor - )); - } - code.pr(deferredFillTriggerTable( - reactions - )); - code.pr(deferredOptimizeForSingleDominatingReaction( - reactor - )); - for (ReactorInstance child: reactor.children) { - code.pr(deferredInitializeNonNested( - child, - main, - child.reactions, - types - )); + return code.toString(); + } + + /** Print statement that sets the last_enabling_reaction field of a reaction. */ + private static String printOptimizeForSingleDominatingReaction( + ReactionInstance.Runtime runtime, int start, int end, int domStart, boolean same) { + var code = new CodeBuilder(); + var dominatingRef = "NULL"; + + if (end > start + 1) { + code.startScopedBlock(); + var reactionRef = CUtil.reactionRef(runtime.getReaction(), "i"); + if (runtime.dominating != null) { + if (same) { + dominatingRef = + "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "" + domStart) + ")"; + } else { + dominatingRef = "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "j++") + ")"; } - code.pr("// **** End of non-nested deferred initialize for "+reactor.getFullName()); - return code.toString(); + } + code.pr( + String.join( + "\n", + "// " + runtime.getReaction().getFullName() + " dominating upstream reaction.", + "int j = " + domStart + ";", + "for (int i = " + start + "; i < " + end + "; i++) {", + " " + reactionRef + ".last_enabling_reaction = " + dominatingRef + ";", + "}")); + code.endScopedBlock(); + } else if (end == start + 1) { + var reactionRef = CUtil.reactionRef(runtime.getReaction(), "" + start); + if (runtime.dominating != null) { + dominatingRef = + "&(" + CUtil.reactionRef(runtime.dominating.getReaction(), "" + domStart) + ")"; + } + code.pr( + String.join( + "\n", + "// " + runtime.getReaction().getFullName() + " dominating upstream reaction.", + reactionRef + ".last_enabling_reaction = " + dominatingRef + ";")); } - - /** - * For each output of the specified reactor that has a token type - * (type* or type[]), create a template token and put it on the self struct. - * @param reactor The reactor. - */ - private static String deferredCreateTemplateTokens( - ReactorInstance reactor, - CTypes types - ) { - var code = new CodeBuilder(); - // Look for outputs with token types. - for (PortInstance output : reactor.outputs) { - var type = ASTUtils.getInferredType(output.getDefinition()); - if (CUtil.isTokenType(type, types)) { - // Create the template token that goes in the trigger struct. - // Its reference count is zero, enabling it to be used immediately. - var rootType = CUtil.rootType(types.getTargetType(type)); - // If the rootType is 'void', we need to avoid generating the code - // 'sizeof(void)', which some compilers reject. - var size = (rootType.equals("void")) ? "0" : "sizeof("+rootType+")"; - code.startChannelIteration(output); - code.pr(String.join("\n", - "_lf_initialize_template((token_template_t*)", - " &("+CUtil.portRef(output)+"),", - size+");" - )); - code.endChannelIteration(output); - } + return code.toString(); + } + + /** + * For the specified reaction, for ports that it writes to, fill the trigger table for triggering + * downstream reactions. + * + * @param reactions The reactions. + */ + private static String deferredFillTriggerTable(Iterable reactions) { + var code = new CodeBuilder(); + for (ReactionInstance reaction : reactions) { + var name = reaction.getParent().getFullName(); + + var reactorSelfStruct = CUtil.reactorRef(reaction.getParent(), sr); + + var foundPort = false; + + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (!foundPort) { + // Need a separate index for the triggers array for each bank member. + code.startScopedBlock(); + code.pr( + "int triggers_index[" + + reaction.getParent().getTotalWidth() + + "] = { 0 }; // Number of bank members with the reaction."); + foundPort = true; } - return code.toString(); - } - - /** - * For the specified reaction, for ports that it writes to, - * set up the arrays that store the results (if necessary) and - * that are used to trigger downstream reactions if an effect is actually - * produced. The port may be an output of the reaction's parent - * or an input to a reactor contained by the parent. - * - * @param reaction The reaction instance. - */ - private static String deferredReactionOutputs( - ReactionInstance reaction, - TargetConfig targetConfig - ) { - var code = new CodeBuilder(); - // val selfRef = CUtil.reactorRef(reaction.getParent()); - var name = reaction.getParent().getFullName(); - // Insert a string name to facilitate debugging. - if (targetConfig.logLevel.compareTo(LogLevel.LOG) >= 0) { - code.pr(CUtil.reactionRef(reaction)+".name = "+addDoubleQuotes(name+" reaction "+reaction.index)+";"); + // If the port is a multiport, then its channels may have different sets + // of destinations. For ordinary ports, there will be only one range and + // its width will be 1. + // We generate the code to fill the triggers array first in a temporary code buffer, + // so that we can simultaneously calculate the size of the total array. + for (SendRange srcRange : port.eventualDestinations()) { + var srcNested = port.isInput(); + code.startScopedRangeBlock(srcRange, sr, sb, sc, srcNested); + + var triggerArray = + CUtil.reactionRef(reaction, sr) + ".triggers[triggers_index[" + sr + "]++]"; + // Skip ports whose parent is not in the federation. + // This can happen with reactions in the top-level that have + // as an effect a port in a bank. + code.pr( + String.join( + "\n", + "// Reaction " + + reaction.index + + " of " + + name + + " triggers " + + srcRange.destinations.size() + + " downstream reactions", + "// through port " + port.getFullName() + ".", + CUtil.reactionRef(reaction, sr) + + ".triggered_sizes[triggers_index[" + + sr + + "]] = " + + srcRange.destinations.size() + + ";", + "// For reaction " + reaction.index + " of " + name + ", allocate an", + "// array of trigger pointers for downstream reactions through port " + + port.getFullName(), + "trigger_t** trigger_array = (trigger_t**)_lf_allocate(", + " " + srcRange.destinations.size() + ", sizeof(trigger_t*),", + " &" + reactorSelfStruct + "->base.allocations); ", + triggerArray + " = trigger_array;")); + code.endScopedRangeBlock(srcRange); } - - var reactorSelfStruct = CUtil.reactorRef(reaction.getParent()); - - // Count the output ports and inputs of contained reactors that - // may be set by this reaction. This ignores actions in the effects. - // Collect initialization statements for the output_produced array for the reaction - // to point to the is_present field of the appropriate output. - // These statements must be inserted after the array is malloc'd, - // but we construct them while we are counting outputs. - var outputCount = 0; - var init = new CodeBuilder(); - - init.startScopedBlock(); - init.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - for (PortInstance effect : Iterables.filter(reaction.effects, PortInstance.class)) { - // Create the entry in the output_produced array for this port. - // If the port is a multiport, then we need to create an entry for each - // individual channel. - - // If the port is an input of a contained reactor, then, if that - // contained reactor is a bank, we will have to iterate over bank - // members. - var bankWidth = 1; - var portRef = ""; - if (effect.isInput()) { - init.pr("// Reaction writes to an input of a contained reactor."); - bankWidth = effect.getParent().getWidth(); - init.startScopedBlock(effect.getParent()); - portRef = CUtil.portRefNestedName(effect); + } + var cumulativePortWidth = 0; + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + // If this port does not have any destinations, do not generate code for it. + if (port.eventualDestinations().isEmpty()) continue; + + code.pr( + "for (int i = 0; i < " + + reaction.getParent().getTotalWidth() + + "; i++) triggers_index[i] = " + + cumulativePortWidth + + ";"); + for (SendRange srcRange : port.eventualDestinations()) { + var srcNested = srcRange.instance.isInput(); + var multicastCount = 0; + for (RuntimeRange dstRange : srcRange.destinations) { + var dst = dstRange.instance; + + code.startScopedRangeBlock(srcRange, dstRange); + + // If the source is nested, need to take into account the parent's bank index + // when indexing into the triggers array. + var triggerArray = ""; + if (srcNested && port.getParent().getWidth() > 1) { + triggerArray = + CUtil.reactionRef(reaction, sr) + + ".triggers[triggers_index[" + + sr + + "] + " + + sc + + " + src_range_mr.digits[1] * src_range_mr.radixes[0]]"; } else { - init.startScopedBlock(); - portRef = CUtil.portRefName(effect); + triggerArray = + CUtil.reactionRef(reaction, sr) + + ".triggers[triggers_index[" + + sr + + "] + " + + sc + + "]"; } - if (effect.isMultiport()) { - // Form is slightly different for inputs vs. outputs. - var connector = "."; - if (effect.isInput()) connector = "->"; - - // Point the output_produced field to where the is_present field of the port is. - init.pr(String.join("\n", - "for (int i = 0; i < "+effect.getWidth()+"; i++) {", - " "+CUtil.reactionRef(reaction)+".output_produced[i + count]", - " = &"+portRef+"[i]"+connector+"is_present;", - "}", - "count += "+effect.getWidth()+";" - )); - outputCount += effect.getWidth() * bankWidth; + if (dst.isOutput()) { + // Include this destination port only if it has at least one + // reaction in the federation. + var belongs = false; + for (ReactionInstance destinationReaction : dst.getDependentReactions()) { + belongs = true; + } + if (belongs) { + code.pr( + String.join( + "\n", + "// Port " + port.getFullName() + " has reactions in its parent's parent.", + "// Point to the trigger struct for those reactions.", + triggerArray + + "[" + + multicastCount + + "] = &" + + CUtil.triggerRefNested(dst, dr, db) + + ";")); + } else { + // Put in a NULL pointer. + code.pr( + String.join( + "\n", + "// Port " + port.getFullName() + " has reactions in its parent's parent.", + "// But those are not in the federation.", + triggerArray + "[" + multicastCount + "] = NULL;")); + } } else { - // The effect is not a multiport. - init.pr(CUtil.reactionRef(reaction)+".output_produced[count++] = &"+portRef+".is_present;"); - outputCount += bankWidth; + // Destination is an input port. + code.pr( + String.join( + "\n", + "// Point to destination port " + dst.getFullName() + "'s trigger struct.", + triggerArray + + "[" + + multicastCount + + "] = &" + + CUtil.triggerRef(dst, dr) + + ";")); } - init.endScopedBlock(); + code.endScopedRangeBlock(srcRange, dstRange); + multicastCount++; + } } - init.endScopedBlock(); - code.pr(String.join("\n", - "// Total number of outputs (single ports and multiport channels)", - "// produced by "+reaction+".", - CUtil.reactionRef(reaction)+".num_outputs = "+outputCount+";" - )); - if (outputCount > 0) { - code.pr(String.join("\n", - "// Allocate memory for triggers[] and triggered_sizes[] on the reaction_t", - "// struct for this reaction.", - CUtil.reactionRef(reaction)+".triggers = (trigger_t***)_lf_allocate(", - " "+outputCount+", sizeof(trigger_t**),", - " &"+reactorSelfStruct+"->base.allocations);", - CUtil.reactionRef(reaction)+".triggered_sizes = (int*)_lf_allocate(", - " "+outputCount+", sizeof(int),", - " &"+reactorSelfStruct+"->base.allocations);", - CUtil.reactionRef(reaction)+".output_produced = (bool**)_lf_allocate(", - " "+outputCount+", sizeof(bool*),", - " &"+reactorSelfStruct+"->base.allocations);" - )); + // If the port is an input of a contained reactor, then we have to take + // into account the bank width of the contained reactor. + if (port.getParent() != reaction.getParent()) { + cumulativePortWidth += port.getWidth() * port.getParent().getWidth(); + } else { + cumulativePortWidth += port.getWidth(); } - - code.pr(String.join("\n", - init.toString(), - "// ** End initialization for reaction "+reaction.index+" of "+name - )); - return code.toString(); + } + if (foundPort) code.endScopedBlock(); } - - /** - * Generate code to allocate the memory needed by reactions for triggering - * downstream reactions. - * @param reactions A list of reactions. - */ - private static String deferredReactionMemory( - Iterable reactions, - TargetConfig targetConfig - ) { - var code = new CodeBuilder(); - // For each reaction instance, allocate the arrays that will be used to - // trigger downstream reactions. - for (ReactionInstance reaction : reactions) { - code.pr(deferredReactionOutputs( - reaction, - targetConfig - )); - var reactorSelfStruct = CUtil.reactorRef(reaction.getParent()); - - // Next handle triggers of the reaction that come from a multiport output - // of a contained reactor. Also, handle startup and shutdown triggers. - for (PortInstance trigger : Iterables.filter(reaction.triggers, PortInstance.class)) { - // If the port is a multiport, then we need to create an entry for each - // individual port. - if (trigger.isMultiport() && trigger.getParent() != null && trigger.isOutput()) { - // Trigger is an output of a contained reactor or bank. - code.pr(String.join("\n", - "// Allocate memory to store pointers to the multiport output "+trigger.getName()+" ", - "// of a contained reactor "+trigger.getParent().getFullName() - )); - code.startScopedBlock(trigger.getParent()); - - var width = trigger.getWidth(); - var portStructType = CGenerator.variableStructType(trigger); - - code.pr(String.join("\n", - CUtil.reactorRefNested(trigger.getParent())+"."+trigger.getName()+"_width = "+width+";", - CUtil.reactorRefNested(trigger.getParent())+"."+trigger.getName(), - " = ("+portStructType+"**)_lf_allocate(", - " "+width+", sizeof("+portStructType+"*),", - " &"+reactorSelfStruct+"->base.allocations); " - )); - - code.endScopedBlock(); - } + return code.toString(); + } + + /** + * For each input port of a contained reactor that receives data from one or more of the specified + * reactions, set the num_destinations field of the corresponding port structs on the self struct + * of the reaction's parent reactor equal to the total number of destination reactors. If the port + * has a token type, this also initializes it with a token. + * + * @param reactions The reactions. + * @param types The C types. + */ + private static String deferredInputNumDestinations( + Iterable reactions, CTypes types) { + // We need the number of destination _reactors_, not the + // number of destination ports nor the number of destination reactions. + // One of the destination reactors may be the container of this + // instance because it may have a reaction to an output of this instance. + // Since a port may be written to by multiple reactions, + // ensure that this is done only once. + var portsHandled = new HashSet(); + var code = new CodeBuilder(); + for (ReactionInstance reaction : reactions) { + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (port.isInput() && !portsHandled.contains(port)) { + // Port is an input of a contained reactor that gets data from a reaction of this reactor. + portsHandled.add(port); + code.pr( + "// Set number of destination reactors for port " + + port.getParent().getName() + + "." + + port.getName() + + "."); + // The input port may itself have multiple destinations. + for (SendRange sendingRange : port.eventualDestinations()) { + code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); + // Syntax is slightly different for a multiport output vs. single port. + var connector = (port.isMultiport()) ? "->" : "."; + code.pr( + CUtil.portRefNested(port, sr, sb, sc) + + connector + + "_base.num_destinations = " + + sendingRange.getNumberOfDestinationReactors() + + ";"); + code.pr( + CUtil.portRefNested(port, sr, sb, sc) + + connector + + "_base.source_reactor = (self_base_t*)" + + CUtil.reactorRef(reaction.getParent(), sb) + + ";"); + + // Initialize token types. + var type = ASTUtils.getInferredType(port.getDefinition()); + if (CUtil.isTokenType(type, types)) { + // Create the template token that goes in the port struct. + var rootType = CUtil.rootType(types.getTargetType(type)); + // If the rootType is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var size = (rootType.equals("void")) ? "0" : "sizeof(" + rootType + ")"; + // If the port is a multiport, then the portRefNested is itself a pointer + // so we want its value, not its address. + var indirection = (port.isMultiport()) ? "" : "&"; + code.startChannelIteration(port); + code.pr( + String.join( + "\n", + "_lf_initialize_template((token_template_t*)", + " " + indirection + "(" + CUtil.portRefNested(port, sr, sb, sc) + "),", + size + ");")); + code.endChannelIteration(port); } + + code.endScopedRangeBlock(sendingRange); + } } - return code.toString(); + } + } + return code.toString(); + } + + /** + * For each output port of the specified reactor, set the num_destinations field of port structs + * on its self struct equal to the total number of destination reactors. This is used to + * initialize reference counts in dynamically allocated tokens sent to other reactors. + * + * @param reactor The reactor instance. + */ + private static String deferredOutputNumDestinations(ReactorInstance reactor) { + // Reference counts are decremented by each destination reactor + // at the conclusion of a time step. Hence, the initial reference + // count should equal the number of destination _reactors_, not the + // number of destination ports nor the number of destination reactions. + // One of the destination reactors may be the container of this + // instance because it may have a reaction to an output of this instance. + var code = new CodeBuilder(); + for (PortInstance output : reactor.outputs) { + for (SendRange sendingRange : output.eventualDestinations()) { + code.pr( + "// For reference counting, set num_destinations for port " + + output.getFullName() + + "."); + code.startScopedRangeBlock(sendingRange, sr, sb, sc, sendingRange.instance.isInput()); + code.pr( + CUtil.portRef(output, sr, sb, sc) + + "._base.num_destinations = " + + sendingRange.getNumberOfDestinationReactors() + + ";"); + code.pr( + CUtil.portRef(output, sr, sb, sc) + + "._base.source_reactor = (self_base_t*)" + + CUtil.reactorRef(reactor, sb) + + ";"); + code.endScopedRangeBlock(sendingRange); + } + } + return code.toString(); + } + + /** + * Perform initialization functions that must be performed after all reactor runtime instances + * have been created. This function does not create nested loops over nested banks, so each + * function it calls must handle its own iteration over all runtime instance. + * + * @param reactor The container. + * @param main The top-level reactor. + * @param reactions The list of reactions to consider. + * @param types The C types. + */ + private static String deferredInitializeNonNested( + ReactorInstance reactor, + ReactorInstance main, + Iterable reactions, + CTypes types) { + var code = new CodeBuilder(); + code.pr("// **** Start non-nested deferred initialize for " + reactor.getFullName()); + // Initialize the num_destinations fields of port structs on the self struct. + // This needs to be outside the above scoped block because it performs + // its own iteration over ranges. + code.pr(deferredInputNumDestinations(reactions, types)); + + // Second batch of initializes cannot be within a for loop + // iterating over bank members because they iterate over send + // ranges which may span bank members. + if (reactor != main) { + code.pr(deferredOutputNumDestinations(reactor)); + } + code.pr(deferredFillTriggerTable(reactions)); + code.pr(deferredOptimizeForSingleDominatingReaction(reactor)); + for (ReactorInstance child : reactor.children) { + code.pr(deferredInitializeNonNested(child, main, child.reactions, types)); + } + code.pr("// **** End of non-nested deferred initialize for " + reactor.getFullName()); + return code.toString(); + } + + /** + * For each output of the specified reactor that has a token type (type* or type[]), create a + * template token and put it on the self struct. + * + * @param reactor The reactor. + */ + private static String deferredCreateTemplateTokens(ReactorInstance reactor, CTypes types) { + var code = new CodeBuilder(); + // Look for outputs with token types. + for (PortInstance output : reactor.outputs) { + var type = ASTUtils.getInferredType(output.getDefinition()); + if (CUtil.isTokenType(type, types)) { + // Create the template token that goes in the trigger struct. + // Its reference count is zero, enabling it to be used immediately. + var rootType = CUtil.rootType(types.getTargetType(type)); + // If the rootType is 'void', we need to avoid generating the code + // 'sizeof(void)', which some compilers reject. + var size = (rootType.equals("void")) ? "0" : "sizeof(" + rootType + ")"; + code.startChannelIteration(output); + code.pr( + String.join( + "\n", + "_lf_initialize_template((token_template_t*)", + " &(" + CUtil.portRef(output) + "),", + size + ");")); + code.endChannelIteration(output); + } + } + return code.toString(); + } + + /** + * For the specified reaction, for ports that it writes to, set up the arrays that store the + * results (if necessary) and that are used to trigger downstream reactions if an effect is + * actually produced. The port may be an output of the reaction's parent or an input to a reactor + * contained by the parent. + * + * @param reaction The reaction instance. + */ + private static String deferredReactionOutputs( + ReactionInstance reaction, TargetConfig targetConfig) { + var code = new CodeBuilder(); + // val selfRef = CUtil.reactorRef(reaction.getParent()); + var name = reaction.getParent().getFullName(); + // Insert a string name to facilitate debugging. + if (targetConfig.logLevel.compareTo(LogLevel.LOG) >= 0) { + code.pr( + CUtil.reactionRef(reaction) + + ".name = " + + addDoubleQuotes(name + " reaction " + reaction.index) + + ";"); } - /** - * If any reaction of the specified reactor provides input - * to a contained reactor, then generate code to allocate - * memory to store the data produced by those reactions. - * The allocated memory is pointed to by a field called - * `_lf_containername.portname` on the self struct of the reactor. - * @param reactor The reactor. - */ - private static String deferredAllocationForEffectsOnInputs( - ReactorInstance reactor - ) { - var code = new CodeBuilder(); - // Keep track of ports already handled. There may be more than one reaction - // in the container writing to the port, but we want only one memory allocation. - var portsHandled = new HashSet(); - var reactorSelfStruct = CUtil.reactorRef(reactor); - // Find parent reactions that mention multiport inputs of this reactor. - for (ReactionInstance reaction : reactor.reactions) { - for (PortInstance effect : Iterables.filter(reaction.effects, PortInstance.class)) { - if (effect.getParent().getDepth() > reactor.getDepth() // port of a contained reactor. - && effect.isMultiport() - && !portsHandled.contains(effect) - ) { - code.pr("// A reaction writes to a multiport of a child. Allocate memory."); - portsHandled.add(effect); - code.startScopedBlock(effect.getParent()); - var portStructType = CGenerator.variableStructType(effect); - var effectRef = CUtil.portRefNestedName(effect); - code.pr(String.join("\n", - effectRef+"_width = "+effect.getWidth()+";", - "// Allocate memory to store output of reaction feeding ", - "// a multiport input of a contained reactor.", - effectRef+" = ("+portStructType+"**)_lf_allocate(", - " "+effect.getWidth()+", sizeof("+portStructType+"*),", - " &"+reactorSelfStruct+"->base.allocations); ", - "for (int i = 0; i < "+effect.getWidth()+"; i++) {", - " "+effectRef+"[i] = ("+portStructType+"*)_lf_allocate(", - " 1, sizeof("+portStructType+"),", - " &"+reactorSelfStruct+"->base.allocations); ", - "}" - )); - code.endScopedBlock(); - } - } - } - return code.toString(); + var reactorSelfStruct = CUtil.reactorRef(reaction.getParent()); + + // Count the output ports and inputs of contained reactors that + // may be set by this reaction. This ignores actions in the effects. + // Collect initialization statements for the output_produced array for the reaction + // to point to the is_present field of the appropriate output. + // These statements must be inserted after the array is malloc'd, + // but we construct them while we are counting outputs. + var outputCount = 0; + var init = new CodeBuilder(); + + init.startScopedBlock(); + init.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + for (PortInstance effect : Iterables.filter(reaction.effects, PortInstance.class)) { + // Create the entry in the output_produced array for this port. + // If the port is a multiport, then we need to create an entry for each + // individual channel. + + // If the port is an input of a contained reactor, then, if that + // contained reactor is a bank, we will have to iterate over bank + // members. + var bankWidth = 1; + var portRef = ""; + if (effect.isInput()) { + init.pr("// Reaction writes to an input of a contained reactor."); + bankWidth = effect.getParent().getWidth(); + init.startScopedBlock(effect.getParent()); + portRef = CUtil.portRefNestedName(effect); + } else { + init.startScopedBlock(); + portRef = CUtil.portRefName(effect); + } + + if (effect.isMultiport()) { + // Form is slightly different for inputs vs. outputs. + var connector = "."; + if (effect.isInput()) connector = "->"; + + // Point the output_produced field to where the is_present field of the port is. + init.pr( + String.join( + "\n", + "for (int i = 0; i < " + effect.getWidth() + "; i++) {", + " " + CUtil.reactionRef(reaction) + ".output_produced[i + count]", + " = &" + portRef + "[i]" + connector + "is_present;", + "}", + "count += " + effect.getWidth() + ";")); + outputCount += effect.getWidth() * bankWidth; + } else { + // The effect is not a multiport. + init.pr( + CUtil.reactionRef(reaction) + + ".output_produced[count++] = &" + + portRef + + ".is_present;"); + outputCount += bankWidth; + } + init.endScopedBlock(); + } + init.endScopedBlock(); + code.pr( + String.join( + "\n", + "// Total number of outputs (single ports and multiport channels)", + "// produced by " + reaction + ".", + CUtil.reactionRef(reaction) + ".num_outputs = " + outputCount + ";")); + if (outputCount > 0) { + code.pr( + String.join( + "\n", + "// Allocate memory for triggers[] and triggered_sizes[] on the reaction_t", + "// struct for this reaction.", + CUtil.reactionRef(reaction) + ".triggers = (trigger_t***)_lf_allocate(", + " " + outputCount + ", sizeof(trigger_t**),", + " &" + reactorSelfStruct + "->base.allocations);", + CUtil.reactionRef(reaction) + ".triggered_sizes = (int*)_lf_allocate(", + " " + outputCount + ", sizeof(int),", + " &" + reactorSelfStruct + "->base.allocations);", + CUtil.reactionRef(reaction) + ".output_produced = (bool**)_lf_allocate(", + " " + outputCount + ", sizeof(bool*),", + " &" + reactorSelfStruct + "->base.allocations);")); } - /** - * Perform initialization functions that must be performed after - * all reactor runtime instances have been created. - * This function creates nested loops over nested banks. - * @param reactor The container. - */ - private static String deferredInitialize( - ReactorInstance reactor, - Iterable reactions, - TargetConfig targetConfig, - CTypes types - ) { - var code = new CodeBuilder(); - code.pr("// **** Start deferred initialize for "+reactor.getFullName()); - // First batch of initializations is within a for loop iterating - // over bank members for the reactor's parent. - code.startScopedBlock(reactor); - - // If the child has a multiport that is an effect of some reaction in its container, - // then we have to generate code to allocate memory for arrays pointing to - // its data. If the child is a bank, then memory is allocated for the entire - // bank width because a reaction cannot specify which bank members it writes - // to so we have to assume it can write to any. - code.pr(deferredAllocationForEffectsOnInputs( - reactor - )); - code.pr(deferredReactionMemory( - reactions, - targetConfig - )); - - // For outputs that are not primitive types (of form type* or type[]), - // create a default token on the self struct. - code.pr(deferredCreateTemplateTokens( - reactor, - types - )); - for (ReactorInstance child: reactor.children) { - code.pr(deferredInitialize( - child, - child.reactions, - targetConfig, - types) - ); + code.pr( + String.join( + "\n", + init.toString(), + "// ** End initialization for reaction " + reaction.index + " of " + name)); + return code.toString(); + } + + /** + * Generate code to allocate the memory needed by reactions for triggering downstream reactions. + * + * @param reactions A list of reactions. + */ + private static String deferredReactionMemory( + Iterable reactions, TargetConfig targetConfig) { + var code = new CodeBuilder(); + // For each reaction instance, allocate the arrays that will be used to + // trigger downstream reactions. + for (ReactionInstance reaction : reactions) { + code.pr(deferredReactionOutputs(reaction, targetConfig)); + var reactorSelfStruct = CUtil.reactorRef(reaction.getParent()); + + // Next handle triggers of the reaction that come from a multiport output + // of a contained reactor. Also, handle startup and shutdown triggers. + for (PortInstance trigger : Iterables.filter(reaction.triggers, PortInstance.class)) { + // If the port is a multiport, then we need to create an entry for each + // individual port. + if (trigger.isMultiport() && trigger.getParent() != null && trigger.isOutput()) { + // Trigger is an output of a contained reactor or bank. + code.pr( + String.join( + "\n", + "// Allocate memory to store pointers to the multiport output " + + trigger.getName() + + " ", + "// of a contained reactor " + trigger.getParent().getFullName())); + code.startScopedBlock(trigger.getParent()); + + var width = trigger.getWidth(); + var portStructType = CGenerator.variableStructType(trigger); + + code.pr( + String.join( + "\n", + CUtil.reactorRefNested(trigger.getParent()) + + "." + + trigger.getName() + + "_width = " + + width + + ";", + CUtil.reactorRefNested(trigger.getParent()) + "." + trigger.getName(), + " = (" + portStructType + "**)_lf_allocate(", + " " + width + ", sizeof(" + portStructType + "*),", + " &" + reactorSelfStruct + "->base.allocations); ")); + + code.endScopedBlock(); } - code.endScopedBlock(); - code.pr("// **** End of deferred initialize for "+reactor.getFullName()); - return code.toString(); + } + } + return code.toString(); + } + + /** + * If any reaction of the specified reactor provides input to a contained reactor, then generate + * code to allocate memory to store the data produced by those reactions. The allocated memory is + * pointed to by a field called `_lf_containername.portname` on the self struct of the reactor. + * + * @param reactor The reactor. + */ + private static String deferredAllocationForEffectsOnInputs(ReactorInstance reactor) { + var code = new CodeBuilder(); + // Keep track of ports already handled. There may be more than one reaction + // in the container writing to the port, but we want only one memory allocation. + var portsHandled = new HashSet(); + var reactorSelfStruct = CUtil.reactorRef(reactor); + // Find parent reactions that mention multiport inputs of this reactor. + for (ReactionInstance reaction : reactor.reactions) { + for (PortInstance effect : Iterables.filter(reaction.effects, PortInstance.class)) { + if (effect.getParent().getDepth() > reactor.getDepth() // port of a contained reactor. + && effect.isMultiport() + && !portsHandled.contains(effect)) { + code.pr("// A reaction writes to a multiport of a child. Allocate memory."); + portsHandled.add(effect); + code.startScopedBlock(effect.getParent()); + var portStructType = CGenerator.variableStructType(effect); + var effectRef = CUtil.portRefNestedName(effect); + code.pr( + String.join( + "\n", + effectRef + "_width = " + effect.getWidth() + ";", + "// Allocate memory to store output of reaction feeding ", + "// a multiport input of a contained reactor.", + effectRef + " = (" + portStructType + "**)_lf_allocate(", + " " + effect.getWidth() + ", sizeof(" + portStructType + "*),", + " &" + reactorSelfStruct + "->base.allocations); ", + "for (int i = 0; i < " + effect.getWidth() + "; i++) {", + " " + effectRef + "[i] = (" + portStructType + "*)_lf_allocate(", + " 1, sizeof(" + portStructType + "),", + " &" + reactorSelfStruct + "->base.allocations); ", + "}")); + code.endScopedBlock(); + } + } + } + return code.toString(); + } + + /** + * Perform initialization functions that must be performed after all reactor runtime instances + * have been created. This function creates nested loops over nested banks. + * + * @param reactor The container. + */ + private static String deferredInitialize( + ReactorInstance reactor, + Iterable reactions, + TargetConfig targetConfig, + CTypes types) { + var code = new CodeBuilder(); + code.pr("// **** Start deferred initialize for " + reactor.getFullName()); + // First batch of initializations is within a for loop iterating + // over bank members for the reactor's parent. + code.startScopedBlock(reactor); + + // If the child has a multiport that is an effect of some reaction in its container, + // then we have to generate code to allocate memory for arrays pointing to + // its data. If the child is a bank, then memory is allocated for the entire + // bank width because a reaction cannot specify which bank members it writes + // to so we have to assume it can write to any. + code.pr(deferredAllocationForEffectsOnInputs(reactor)); + code.pr(deferredReactionMemory(reactions, targetConfig)); + + // For outputs that are not primitive types (of form type* or type[]), + // create a default token on the self struct. + code.pr(deferredCreateTemplateTokens(reactor, types)); + for (ReactorInstance child : reactor.children) { + code.pr(deferredInitialize(child, child.reactions, targetConfig, types)); } + code.endScopedBlock(); + code.pr("// **** End of deferred initialize for " + reactor.getFullName()); + return code.toString(); + } } From 7fd300344d590b84b5961effb90f17de132c9313 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 17 May 2023 23:03:18 -0700 Subject: [PATCH 413/709] Change default line length to 100 for LF files. --- test/C/src/ActionWithNoReaction.lf | 5 ++-- test/C/src/After.lf | 3 +- test/C/src/AfterCycles.lf | 4 +-- test/C/src/AfterZero.lf | 3 +- test/C/src/Alignment.lf | 3 +- test/C/src/ArrayAsParameter.lf | 5 ++-- test/C/src/ArrayAsType.lf | 4 +-- test/C/src/Composition.lf | 3 +- test/C/src/CompositionAfter.lf | 3 +- test/C/src/CompositionInheritance.lf | 3 +- test/C/src/DanglingOutput.lf | 4 +-- test/C/src/Deadline.lf | 5 ++-- test/C/src/DeadlineHandledAbove.lf | 4 +-- test/C/src/DelayArrayWithAfter.lf | 3 +- test/C/src/DelayInt.lf | 4 +-- test/C/src/DelayString.lf | 3 +- test/C/src/DoubleInvocation.lf | 9 +++--- test/C/src/DoublePort.lf | 9 ++---- test/C/src/DoubleReaction.lf | 4 +-- test/C/src/DoubleTrigger.lf | 3 +- test/C/src/FloatLiteral.lf | 3 +- test/C/src/GetTime.lf | 4 +-- test/C/src/Import.lf | 3 +- test/C/src/ImportComposition.lf | 3 +- test/C/src/ImportRenamed.lf | 3 +- test/C/src/InheritanceAction.lf | 3 +- test/C/src/MovingAverage.lf | 5 ++-- test/C/src/MultipleContained.lf | 3 +- test/C/src/MultipleOutputs.lf | 7 ++--- test/C/src/PingPong.lf | 17 +++++------ test/C/src/ReadOutputOfContainedReactor.lf | 3 +- test/C/src/RepeatedInheritance.lf | 8 ++--- test/C/src/RequestStop.lf | 3 +- test/C/src/ScheduleLogicalAction.lf | 4 +-- test/C/src/SendingInside.lf | 4 +-- test/C/src/SendsPointerTest.lf | 4 +-- test/C/src/SetArray.lf | 4 +-- test/C/src/SimpleDeadline.lf | 5 ++-- test/C/src/SlowingClock.lf | 7 ++--- test/C/src/SlowingClockPhysical.lf | 9 +++--- test/C/src/Starvation.lf | 4 +-- test/C/src/StopZero.lf | 4 +-- test/C/src/Stride.lf | 4 +-- test/C/src/StructPrint.lf | 4 +-- test/C/src/TestForPreviousOutput.lf | 4 +-- test/C/src/TimeLimit.lf | 5 ++-- test/C/src/TimeoutZero.lf | 3 +- test/C/src/TriggerDownstreamOnlyIfPresent2.lf | 5 +--- test/C/src/arduino/AnalogReadSerial.lf | 7 ++--- test/C/src/arduino/Blink.lf | 5 ++-- test/C/src/arduino/BlinkAttemptThreading.lf | 7 ++--- test/C/src/arduino/BlinkMBED.lf | 5 ++-- test/C/src/arduino/Fade.lf | 9 +++--- test/C/src/arduino/ReadAnalogVoltage.lf | 9 +++--- test/C/src/concurrent/AsyncCallback.lf | 10 +++---- test/C/src/concurrent/AsyncCallbackDrop.lf | 7 ++--- test/C/src/concurrent/AsyncCallbackReplace.lf | 7 ++--- test/C/src/concurrent/CompositionThreaded.lf | 3 +- .../DeadlineHandledAboveThreaded.lf | 4 +-- test/C/src/concurrent/DeadlineThreaded.lf | 5 ++-- .../src/concurrent/DoubleReactionThreaded.lf | 4 +-- test/C/src/concurrent/ImportThreaded.lf | 3 +- test/C/src/concurrent/PingPongThreaded.lf | 20 +++++-------- .../C/src/concurrent/SendingInsideThreaded.lf | 4 +-- test/C/src/concurrent/StarvationThreaded.lf | 5 ++-- test/C/src/concurrent/StopThreaded.lf | 4 +-- test/C/src/concurrent/StopZeroThreaded.lf | 3 +- test/C/src/concurrent/Threaded.lf | 19 +++++------- test/C/src/concurrent/ThreadedMultiport.lf | 3 +- test/C/src/concurrent/ThreadedThreaded.lf | 16 +++++----- test/C/src/concurrent/TimeLimitThreaded.lf | 4 +-- test/C/src/concurrent/TimeoutThreaded.lf | 3 +- test/C/src/concurrent/TimeoutZeroThreaded.lf | 4 +-- test/C/src/concurrent/Tracing.lf | 3 +- test/C/src/docker/PingPongContainerized.lf | 17 +++++------ .../DistributedCountContainerized.lf | 7 ++--- .../DistributedDoublePortContainerized.lf | 5 ++-- ...stributedStopDecentralizedContainerized.lf | 3 +- test/C/src/federated/BroadcastFeedback.lf | 4 +-- .../BroadcastFeedbackWithHierarchy.lf | 4 +-- test/C/src/federated/CycleDetection.lf | 4 +-- .../DecentralizedP2PUnbalancedTimeout.lf | 11 +++---- ...centralizedP2PUnbalancedTimeoutPhysical.lf | 15 ++++------ test/C/src/federated/DistributedCount.lf | 7 ++--- .../DistributedCountDecentralized.lf | 10 +++---- .../src/federated/DistributedCountPhysical.lf | 8 ++--- .../DistributedCountPhysicalAfterDelay.lf | 9 +++--- .../DistributedCountPhysicalDecentralized.lf | 8 ++--- test/C/src/federated/DistributedDoublePort.lf | 9 ++---- .../DistributedLogicalActionUpstreamLong.lf | 4 +-- .../src/federated/DistributedLoopedAction.lf | 6 ++-- .../DistributedLoopedActionDecentralized.lf | 23 ++++++--------- .../DistributedLoopedPhysicalAction.lf | 16 +++++----- ...ibutedLoopedPhysicalActionDecentralized.lf | 3 +- .../federated/DistributedMultiportToken.lf | 4 +-- .../src/federated/DistributedNetworkOrder.lf | 7 ++--- .../DistributedPhysicalActionUpstream.lf | 4 +-- .../DistributedPhysicalActionUpstreamLong.lf | 4 +-- test/C/src/federated/DistributedStop.lf | 3 +- .../federated/DistributedStopDecentralized.lf | 3 +- test/C/src/federated/DistributedStopZero.lf | 3 +- .../DistributedStopZeroDecentralized.lf | 3 +- test/C/src/federated/HelloDistributed.lf | 11 +++---- .../federated/LoopDistributedCentralized.lf | 3 +- .../LoopDistributedCentralizedPrecedence.lf | 4 +-- ...stributedCentralizedPrecedenceHierarchy.lf | 5 ++-- .../federated/LoopDistributedDecentralized.lf | 3 +- test/C/src/federated/LoopDistributedDouble.lf | 3 +- test/C/src/federated/PhysicalSTP.lf | 5 +--- test/C/src/federated/PingPongDistributed.lf | 17 +++++------ .../federated/PingPongDistributedPhysical.lf | 18 +++++------- test/C/src/federated/TopLevelArtifacts.lf | 7 ++--- test/C/src/federated/failing/ClockSync.lf | 29 ++++++++----------- test/C/src/lib/Imported.lf | 4 +-- test/C/src/lib/ImportedAgain.lf | 4 +-- test/C/src/lib/ImportedComposition.lf | 4 +-- test/C/src/lib/LoopedActionSender.lf | 7 ++--- test/C/src/lib/TestCount.lf | 5 ++-- .../src/modal_models/BanksModalStateReset.lf | 8 ++--- test/C/src/modal_models/Count3Modes.lf | 6 ++-- test/C/src/modal_models/MixedReactions.lf | 4 +-- .../src/modal_models/ModalNestedReactions.lf | 11 ++----- test/C/src/multiport/BankMulticast.lf | 4 +-- .../src/multiport/BankReactionsInContainer.lf | 4 +-- test/C/src/multiport/BankSelfBroadcast.lf | 6 ++-- test/C/src/multiport/MultiportFromBank.lf | 8 ++--- .../multiport/MultiportFromBankHierarchy.lf | 4 +-- .../MultiportFromBankHierarchyAfter.lf | 4 +-- .../C/src/multiport/MultiportFromHierarchy.lf | 3 +- test/C/src/multiport/MultiportIn.lf | 4 +-- .../src/multiport/MultiportInParameterized.lf | 7 ++--- test/C/src/multiport/MultiportMutableInput.lf | 5 ++-- .../multiport/MultiportMutableInputArray.lf | 7 ++--- test/C/src/multiport/MultiportToBank.lf | 7 ++--- test/C/src/multiport/MultiportToBankAfter.lf | 3 +- test/C/src/multiport/MultiportToBankDouble.lf | 8 ++--- .../src/multiport/MultiportToBankHierarchy.lf | 4 +-- test/C/src/multiport/MultiportToHierarchy.lf | 5 ++-- .../multiport/MultiportToMultiportArray.lf | 3 +- test/C/src/multiport/MultiportToPort.lf | 3 +- .../ReactionToContainedBankMultiport.lf | 3 +- test/C/src/multiport/ReactionsToNested.lf | 3 +- test/C/src/multiport/SparseFallback.lf | 4 +-- .../TriggerDownstreamOnlyIfPresent.lf | 5 +--- .../serialization/PersonProtocolBuffers.lf | 18 +++++------- test/C/src/serialization/ProtoNoPacking.lf | 18 +++++------- .../ROSBuiltInSerializationSharedPtr.lf | 13 ++++----- test/C/src/target/CMakeInclude.lf | 3 +- test/C/src/target/DistributedCMakeInclude.lf | 5 ++-- .../DistributedCMakeIncludeSeparateCompile.lf | 6 ++-- test/C/src/target/HelloWorldCCPP.lf | 4 +-- test/C/src/target/HelloWorldFederatedCCPP.lf | 4 +-- test/C/src/target/HelloWorldThreadedCPP.lf | 4 +-- test/Cpp/src/ActionWithNoReaction.lf | 5 ++-- test/Cpp/src/After.lf | 3 +- test/Cpp/src/AfterZero.lf | 3 +- test/Cpp/src/Alignment.lf | 3 +- test/Cpp/src/ArrayAsParameter.lf | 3 +- test/Cpp/src/ArrayAsType.lf | 4 +-- test/Cpp/src/ArrayParallel.lf | 6 ++-- test/Cpp/src/ArrayPrint.lf | 5 ++-- test/Cpp/src/ArrayScale.lf | 5 ++-- test/Cpp/src/Composition.lf | 3 +- test/Cpp/src/CompositionAfter.lf | 3 +- test/Cpp/src/DanglingOutput.lf | 4 +-- test/Cpp/src/Deadline.lf | 5 ++-- test/Cpp/src/DeadlineHandledAbove.lf | 4 +-- test/Cpp/src/DoubleInvocation.lf | 12 ++++---- test/Cpp/src/DoublePort.lf | 5 ++-- test/Cpp/src/DoubleReaction.lf | 4 +-- test/Cpp/src/DoubleTrigger.lf | 3 +- test/Cpp/src/GetTime.lf | 4 +-- test/Cpp/src/Import.lf | 3 +- test/Cpp/src/ImportComposition.lf | 3 +- test/Cpp/src/ImportRenamed.lf | 3 +- test/Cpp/src/ManualDelayedReaction.lf | 6 ++-- test/Cpp/src/MovingAverage.lf | 6 ++-- test/Cpp/src/MultipleContained.lf | 3 +- test/Cpp/src/PreambleTest.lf | 14 ++++----- test/Cpp/src/ReadOutputOfContainedReactor.lf | 3 +- test/Cpp/src/ScheduleLogicalAction.lf | 4 +-- test/Cpp/src/SendingInside.lf | 4 +-- test/Cpp/src/SimpleDeadline.lf | 5 ++-- test/Cpp/src/SlowingClock.lf | 7 ++--- test/Cpp/src/SlowingClockPhysical.lf | 9 +++--- test/Cpp/src/Stride.lf | 4 +-- test/Cpp/src/StructParallel.lf | 6 ++-- test/Cpp/src/StructScale.lf | 5 ++-- test/Cpp/src/TestForPreviousOutput.lf | 4 +-- test/Cpp/src/TimeLimit.lf | 5 ++-- .../src/TriggerDownstreamOnlyIfPresent2.lf | 3 +- .../Cpp/src/concurrent/CompositionThreaded.lf | 3 +- .../DeadlineHandledAboveThreaded.lf | 4 +-- test/Cpp/src/concurrent/DeadlineThreaded.lf | 5 ++-- .../src/concurrent/DoubleReactionThreaded.lf | 4 +-- test/Cpp/src/concurrent/ImportThreaded.lf | 3 +- .../src/concurrent/SendingInsideThreaded.lf | 4 +-- test/Cpp/src/concurrent/Threaded.lf | 14 ++++----- test/Cpp/src/concurrent/ThreadedThreaded.lf | 14 ++++----- test/Cpp/src/concurrent/TimeLimitThreaded.lf | 7 ++--- test/Cpp/src/lib/Imported.lf | 4 +-- test/Cpp/src/lib/ImportedAgain.lf | 4 +-- test/Cpp/src/lib/ImportedComposition.lf | 4 +-- test/Cpp/src/lib/LoopedActionSender.lf | 7 ++--- test/Cpp/src/multiport/BankSelfBroadcast.lf | 6 ++-- .../src/multiport/IndexIntoMultiportInput.lf | 5 ++-- .../src/multiport/IndexIntoMultiportOutput.lf | 5 ++-- test/Cpp/src/multiport/MultiportFromBank.lf | 4 +-- .../multiport/MultiportFromBankHierarchy.lf | 4 +-- .../MultiportFromBankHierarchyAfter.lf | 4 +-- .../src/multiport/MultiportFromHierarchy.lf | 3 +- test/Cpp/src/multiport/MultiportIn.lf | 4 +-- .../src/multiport/MultiportToBankHierarchy.lf | 4 +-- .../Cpp/src/multiport/MultiportToHierarchy.lf | 5 ++-- .../multiport/MultiportToMultiportArray.lf | 3 +- test/Cpp/src/multiport/MultiportToPort.lf | 3 +- .../ReadMultiportOutputOfContainedBank.lf | 3 +- .../multiport/ReadOutputOfContainedBank.lf | 3 +- .../src/target/BraceAndParenInitialization.lf | 6 ++-- test/Cpp/src/target/CMakeInclude.lf | 3 +- test/Cpp/src/target/PreambleFile.lf | 14 ++++----- test/Python/src/ActionWithNoReaction.lf | 5 ++-- test/Python/src/After.lf | 3 +- test/Python/src/AfterCycles.lf | 4 +-- test/Python/src/ArrayAsType.lf | 4 +-- test/Python/src/ArrayFree.lf | 8 ++--- test/Python/src/ArrayParallel.lf | 6 ++-- test/Python/src/ArrayPrint.lf | 4 +-- test/Python/src/ArrayScale.lf | 7 ++--- test/Python/src/Composition.lf | 3 +- test/Python/src/CompositionAfter.lf | 3 +- test/Python/src/CompositionInheritance.lf | 3 +- test/Python/src/DanglingOutput.lf | 4 +-- test/Python/src/Deadline.lf | 5 ++-- test/Python/src/DeadlineHandledAbove.lf | 4 +-- test/Python/src/DelayArrayWithAfter.lf | 3 +- test/Python/src/DelayString.lf | 3 +- test/Python/src/DoubleInvocation.lf | 9 +++--- test/Python/src/DoubleReaction.lf | 4 +-- test/Python/src/GetTime.lf | 4 +-- test/Python/src/Hello.lf | 14 ++++----- test/Python/src/Import.lf | 3 +- test/Python/src/ImportComposition.lf | 3 +- test/Python/src/ImportRenamed.lf | 3 +- test/Python/src/ManualDelayedReaction.lf | 9 +++--- test/Python/src/MovingAverage.lf | 5 ++-- test/Python/src/MultipleContained.lf | 3 +- test/Python/src/PingPong.lf | 17 +++++------ test/Python/src/Preamble.lf | 4 +-- .../src/ReadOutputOfContainedReactor.lf | 3 +- test/Python/src/ScheduleLogicalAction.lf | 4 +-- test/Python/src/SendingInside.lf | 4 +-- test/Python/src/SetArray.lf | 5 ++-- test/Python/src/SimpleDeadline.lf | 5 ++-- test/Python/src/SlowingClock.lf | 6 ++-- test/Python/src/Stride.lf | 4 +-- test/Python/src/StructAsState.lf | 3 +- test/Python/src/StructPrint.lf | 4 +-- test/Python/src/TestForPreviousOutput.lf | 4 +-- test/Python/src/TimeLimit.lf | 5 ++-- .../src/TriggerDownstreamOnlyIfPresent.lf | 5 +--- .../src/TriggerDownstreamOnlyIfPresent2.lf | 5 +--- test/Python/src/concurrent/AsyncCallback.lf | 5 ++-- .../src/concurrent/AsyncCallbackNoTimer.lf | 12 ++++---- .../src/docker/PingPongContainerized.lf | 17 +++++------ .../DistributedCountContainerized.lf | 7 ++--- .../DistributedDoublePortContainerized.lf | 5 ++-- .../Python/src/federated/BroadcastFeedback.lf | 4 +-- .../BroadcastFeedbackWithHierarchy.lf | 4 +-- test/Python/src/federated/CycleDetection.lf | 4 +-- .../DecentralizedP2PUnbalancedTimeout.lf | 7 ++--- ...centralizedP2PUnbalancedTimeoutPhysical.lf | 11 ++++--- test/Python/src/federated/DistributedCount.lf | 7 ++--- .../DistributedCountDecentralized.lf | 10 +++---- .../src/federated/DistributedCountPhysical.lf | 8 ++--- .../DistributedCountPhysicalAfterDelay.lf | 8 ++--- .../DistributedCountPhysicalDecentralized.lf | 8 ++--- .../src/federated/DistributedDoublePort.lf | 9 ++---- .../src/federated/DistributedLoopedAction.lf | 6 ++-- ...ibutedLoopedPhysicalActionDecentralized.lf | 3 +- .../federated/DistributedMultiportToken.lf | 4 +-- .../federated/DistributedStructParallel.lf | 4 +-- .../src/federated/DistributedStructPrint.lf | 4 +-- .../src/federated/DistributedStructScale.lf | 4 +-- test/Python/src/federated/HelloDistributed.lf | 10 +++---- ...stributedCentralizedPrecedenceHierarchy.lf | 5 ++-- test/Python/src/federated/PhysicalSTP.lf | 5 +--- .../src/federated/PingPongDistributed.lf | 16 +++++----- test/Python/src/lib/Imported.lf | 4 +-- test/Python/src/lib/ImportedAgain.lf | 4 +-- test/Python/src/lib/ImportedComposition.lf | 4 +-- test/Python/src/lib/LoopedActionSender.lf | 7 ++--- test/Python/src/lib/TestCount.lf | 5 ++-- test/Python/src/lib/TestCountMultiport.lf | 11 ++++--- .../src/modal_models/BanksModalStateReset.lf | 8 ++--- .../src/modal_models/ConvertCaseTest.lf | 4 +-- test/Python/src/modal_models/ModalActions.lf | 7 ++--- .../src/modal_models/ModalCycleBreaker.lf | 8 ++--- .../src/modal_models/ModalNestedReactions.lf | 5 +--- .../src/modal_models/ModalStartupShutdown.lf | 3 +- .../src/modal_models/ModalStateReset.lf | 3 +- .../src/modal_models/ModalStateResetAuto.lf | 3 +- test/Python/src/modal_models/ModalTimers.lf | 3 +- .../MultipleOutputFeeder_2Connections.lf | 10 +++---- ...ultipleOutputFeeder_ReactionConnections.lf | 14 ++++----- .../src/multiport/BankReactionsInContainer.lf | 4 +-- .../Python/src/multiport/MultiportFromBank.lf | 8 ++--- .../multiport/MultiportFromBankHierarchy.lf | 4 +-- .../MultiportFromBankHierarchyAfter.lf | 4 +-- .../src/multiport/MultiportFromHierarchy.lf | 3 +- test/Python/src/multiport/MultiportIn.lf | 4 +-- .../src/multiport/MultiportInParameterized.lf | 4 +-- .../src/multiport/MultiportMutableInput.lf | 5 ++-- .../multiport/MultiportMutableInputArray.lf | 7 ++--- .../src/multiport/MultiportToBankAfter.lf | 3 +- .../src/multiport/MultiportToBankHierarchy.lf | 4 +-- .../src/multiport/MultiportToHierarchy.lf | 5 ++-- .../multiport/MultiportToMultiportArray.lf | 3 +- test/Python/src/multiport/MultiportToPort.lf | 3 +- .../Python/src/multiport/ReactionsToNested.lf | 3 +- .../serialization/PersonProtocolBuffers.lf | 18 +++++------- .../src/serialization/ProtoNoPacking.lf | 18 +++++------- test/Python/src/target/AfterNoTypes.lf | 4 +-- test/Rust/src/ActionValuesCleanup.lf | 4 +-- .../src/CompositionInitializationOrder.lf | 3 +- test/Rust/src/DependencyOnChildPort.lf | 4 +-- test/Rust/src/DependencyUseAccessible.lf | 3 +- test/Rust/src/Import.lf | 3 +- test/Rust/src/ImportPreambleItem.lf | 7 ++--- ...ysicalActionCanBeScheduledSynchronously.lf | 3 +- .../src/PhysicalActionKeepaliveIsSmart.lf | 4 +-- .../PhysicalActionWakesSleepingScheduler.lf | 14 ++++----- test/Rust/src/ReactionLabels.lf | 4 +-- test/Rust/src/ReservedKeywords.lf | 3 +- test/Rust/src/StateInitializerVisibility.lf | 4 +-- test/Rust/src/Stop.lf | 7 ++--- test/Rust/src/StopNoEvent.lf | 5 +--- test/Rust/src/StopTimeout.lf | 3 +- test/Rust/src/StopTimeoutExact.lf | 4 +-- test/Rust/src/StructAsState.lf | 4 +-- test/Rust/src/generics/GenericReactor.lf | 4 +-- test/Rust/src/lib/Imported.lf | 4 +-- test/Rust/src/lib/ImportedAgain.lf | 4 +-- test/Rust/src/lib/SomethingWithAPreamble.lf | 4 +-- test/Rust/src/multiport/CycledLhs_SelfLoop.lf | 8 ++--- test/Rust/src/multiport/CycledLhs_Single.lf | 14 ++++----- .../src/multiport/MultiportFromHierarchy.lf | 3 +- test/Rust/src/multiport/MultiportIn.lf | 4 +-- .../src/multiport/MultiportToMultiport2.lf | 3 +- .../src/target/BuildProfileDefaultIsDev.lf | 4 +-- test/Rust/src/target/BuildProfileRelease.lf | 4 +-- test/Rust/src/target/CargoDependency.lf | 3 +- .../src/target/CargoDependencyOnRuntime.lf | 3 +- test/TypeScript/src/ActionWithNoReaction.lf | 5 ++-- test/TypeScript/src/After.lf | 3 +- test/TypeScript/src/ArrayAsType.lf | 5 ++-- test/TypeScript/src/ArrayPrint.lf | 5 ++-- test/TypeScript/src/ArrayScale.lf | 7 ++--- test/TypeScript/src/Composition.lf | 3 +- test/TypeScript/src/CompositionAfter.lf | 3 +- test/TypeScript/src/DanglingOutput.lf | 4 +-- test/TypeScript/src/Deadline.lf | 5 ++-- test/TypeScript/src/DeadlineHandledAbove.lf | 4 +-- test/TypeScript/src/DelayInt.lf | 4 +-- test/TypeScript/src/DoubleInvocation.lf | 9 +++--- test/TypeScript/src/DoubleReaction.lf | 4 +-- test/TypeScript/src/DoubleTrigger.lf | 3 +- test/TypeScript/src/GetTime.lf | 8 ++--- test/TypeScript/src/Import.lf | 3 +- test/TypeScript/src/MovingAverage.lf | 5 ++-- test/TypeScript/src/MultipleContained.lf | 3 +- .../src/ReadOutputOfContainedReactor.lf | 3 +- test/TypeScript/src/Schedule.lf | 3 +- test/TypeScript/src/ScheduleLogicalAction.lf | 4 +-- test/TypeScript/src/SendingInside.lf | 4 +-- test/TypeScript/src/SendsPointerTest.lf | 4 +-- test/TypeScript/src/SimpleDeadline.lf | 5 ++-- test/TypeScript/src/SlowingClockPhysical.lf | 14 ++++----- test/TypeScript/src/Stop.lf | 3 +- test/TypeScript/src/Stride.lf | 4 +-- test/TypeScript/src/StructPrint.lf | 4 +-- test/TypeScript/src/TestForPreviousOutput.lf | 4 +-- test/TypeScript/src/TimeLimit.lf | 7 ++--- .../src/federated/DistributedCount.lf | 7 ++--- .../src/federated/DistributedDoublePort.lf | 9 ++---- .../src/federated/DistributedLoopedAction.lf | 6 ++-- .../DistributedLoopedPhysicalAction.lf | 8 ++--- .../src/federated/DistributedStop.lf | 3 +- .../src/federated/DistributedStopZero.lf | 4 +-- .../src/federated/HelloDistributed.lf | 11 +++---- .../federated/LoopDistributedCentralized.lf | 3 +- .../src/federated/LoopDistributedDouble.lf | 3 +- .../src/federated/TopLevelArtifacts.lf | 7 ++--- test/TypeScript/src/lib/Imported.lf | 4 +-- test/TypeScript/src/lib/ImportedAgain.lf | 4 +-- test/TypeScript/src/lib/LoopedActionSender.lf | 7 ++--- test/TypeScript/src/lib/TestCount.lf | 5 ++-- .../TypeScript/src/multiport/BankMulticast.lf | 4 +-- .../src/multiport/BankReactionsInContainer.lf | 4 +-- .../src/multiport/BankSelfBroadcast.lf | 6 ++-- .../src/multiport/MultiportFromBank.lf | 4 +-- .../multiport/MultiportFromBankHierarchy.lf | 4 +-- .../MultiportFromBankHierarchyAfter.lf | 4 +-- .../src/multiport/MultiportFromHierarchy.lf | 3 +- test/TypeScript/src/multiport/MultiportIn.lf | 4 +-- .../src/multiport/MultiportInParameterized.lf | 4 +-- .../src/multiport/MultiportMutableInput.lf | 5 ++-- .../multiport/MultiportMutableInputArray.lf | 7 ++--- .../src/multiport/MultiportToBankAfter.lf | 3 +- .../src/multiport/MultiportToBankDouble.lf | 8 ++--- .../src/multiport/MultiportToBankHierarchy.lf | 4 +-- .../src/multiport/MultiportToHierarchy.lf | 5 ++-- .../multiport/MultiportToMultiportArray.lf | 3 +- .../src/multiport/MultiportToPort.lf | 3 +- .../src/multiport/ReactionsToNested.lf | 3 +- .../src/serialization/ProtoNoPacking.lf | 10 +++---- test/TypeScript/src/target/AfterNoTypes.lf | 3 +- 417 files changed, 962 insertions(+), 1361 deletions(-) diff --git a/test/C/src/ActionWithNoReaction.lf b/test/C/src/ActionWithNoReaction.lf index 8ac720167d..1cfe5bfba2 100644 --- a/test/C/src/ActionWithNoReaction.lf +++ b/test/C/src/ActionWithNoReaction.lf @@ -1,6 +1,5 @@ -// This checks that action can be created even if there is no reaction. This -// test passes merely by compiling and executing without a segfault. Its other -// functionality is tested by other tests. +// This checks that action can be created even if there is no reaction. This test passes merely by +// compiling and executing without a segfault. Its other functionality is tested by other tests. target C { fast: true, timeout: 3 sec diff --git a/test/C/src/After.lf b/test/C/src/After.lf index d3663457e4..a066cfcb35 100644 --- a/test/C/src/After.lf +++ b/test/C/src/After.lf @@ -1,5 +1,4 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target C { fast: false, timeout: 3 sec diff --git a/test/C/src/AfterCycles.lf b/test/C/src/AfterCycles.lf index d7d621046b..c79e33bb31 100644 --- a/test/C/src/AfterCycles.lf +++ b/test/C/src/AfterCycles.lf @@ -1,5 +1,5 @@ -// This tests that "after" does not introduce spurious cycles. Success if -// running without detected a cycle. +// This tests that "after" does not introduce spurious cycles. Success if running without detected a +// cycle. target C reactor Source { diff --git a/test/C/src/AfterZero.lf b/test/C/src/AfterZero.lf index 378114c730..265f866b59 100644 --- a/test/C/src/AfterZero.lf +++ b/test/C/src/AfterZero.lf @@ -1,5 +1,4 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target C { fast: false, timeout: 3 sec diff --git a/test/C/src/Alignment.lf b/test/C/src/Alignment.lf index a2b9b523fb..e63ff904b8 100644 --- a/test/C/src/Alignment.lf +++ b/test/C/src/Alignment.lf @@ -1,5 +1,4 @@ -// This test checks that the downstream reaction is not invoked more than once -// at a logical time. +// This test checks that the downstream reaction is not invoked more than once at a logical time. target C { logging: LOG, timeout: 1 sec diff --git a/test/C/src/ArrayAsParameter.lf b/test/C/src/ArrayAsParameter.lf index a9df29cb03..17718f0135 100644 --- a/test/C/src/ArrayAsParameter.lf +++ b/test/C/src/ArrayAsParameter.lf @@ -1,6 +1,5 @@ -// Source has an array as a parameter, the elements of which it passes to Print. -// The length of the array has to also be a parameter because C arrays do not -// encode their own length. +// Source has an array as a parameter, the elements of which it passes to Print. The length of the +// array has to also be a parameter because C arrays do not encode their own length. target C reactor Source(sequence: int[] = {0, 1, 2}, n_sequence: int = 3) { diff --git a/test/C/src/ArrayAsType.lf b/test/C/src/ArrayAsType.lf index c95e5bf385..a24f34e0a6 100644 --- a/test/C/src/ArrayAsType.lf +++ b/test/C/src/ArrayAsType.lf @@ -1,5 +1,5 @@ -// Source produces a statically allocated array, which it passes to Print. The -// destination references the array directly. +// Source produces a statically allocated array, which it passes to Print. The destination +// references the array directly. target C reactor Source { diff --git a/test/C/src/Composition.lf b/test/C/src/Composition.lf index 7c024a9eba..0f79a7465c 100644 --- a/test/C/src/Composition.lf +++ b/test/C/src/Composition.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { fast: true, timeout: 10 sec diff --git a/test/C/src/CompositionAfter.lf b/test/C/src/CompositionAfter.lf index cb98ef7d7e..98a0703138 100644 --- a/test/C/src/CompositionAfter.lf +++ b/test/C/src/CompositionAfter.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { fast: true, timeout: 10 sec diff --git a/test/C/src/CompositionInheritance.lf b/test/C/src/CompositionInheritance.lf index 06221e9788..3b3f9ea905 100644 --- a/test/C/src/CompositionInheritance.lf +++ b/test/C/src/CompositionInheritance.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { fast: true, timeout: 10 sec diff --git a/test/C/src/DanglingOutput.lf b/test/C/src/DanglingOutput.lf index 6305f17644..d13de1dac2 100644 --- a/test/C/src/DanglingOutput.lf +++ b/test/C/src/DanglingOutput.lf @@ -1,5 +1,5 @@ -// This tests that an output that is not connected to anything does not result -// in a compilation error. Passing the test is just compiling and running. +// This tests that an output that is not connected to anything does not result in a compilation +// error. Passing the test is just compiling and running. target C reactor Source { diff --git a/test/C/src/Deadline.lf b/test/C/src/Deadline.lf index 21ea7df141..bd48928bdc 100644 --- a/test/C/src/Deadline.lf +++ b/test/C/src/Deadline.lf @@ -1,6 +1,5 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target C { timeout: 6 sec } diff --git a/test/C/src/DeadlineHandledAbove.lf b/test/C/src/DeadlineHandledAbove.lf index 3b0dc49198..939d90b1d6 100644 --- a/test/C/src/DeadlineHandledAbove.lf +++ b/test/C/src/DeadlineHandledAbove.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target C preamble {= diff --git a/test/C/src/DelayArrayWithAfter.lf b/test/C/src/DelayArrayWithAfter.lf index c94be3b9a1..cc270d9bb8 100644 --- a/test/C/src/DelayArrayWithAfter.lf +++ b/test/C/src/DelayArrayWithAfter.lf @@ -1,5 +1,4 @@ -// This tests transport of dynamically allocated arrays over connections with -// 'after'. +// This tests transport of dynamically allocated arrays over connections with 'after'. target C { timeout: 5 sec, fast: true diff --git a/test/C/src/DelayInt.lf b/test/C/src/DelayInt.lf index 78ca793716..74eb50f1f4 100644 --- a/test/C/src/DelayInt.lf +++ b/test/C/src/DelayInt.lf @@ -6,9 +6,7 @@ reactor Delay(delay: time = 100 msec) { output out: int logical action a: int - reaction(a) -> out {= - if (a->has_value && a->is_present) lf_set(out, a->value); - =} + reaction(a) -> out {= if (a->has_value && a->is_present) lf_set(out, a->value); =} reaction(in) -> a {= // Use specialized form of schedule for integer payloads. diff --git a/test/C/src/DelayString.lf b/test/C/src/DelayString.lf index 1b4204cfc4..c5252bde55 100644 --- a/test/C/src/DelayString.lf +++ b/test/C/src/DelayString.lf @@ -1,5 +1,4 @@ -// This tests actions with immutable payloads that are neither malloc'd nor -// freed. +// This tests actions with immutable payloads that are neither malloc'd nor freed. target C preamble {= diff --git a/test/C/src/DoubleInvocation.lf b/test/C/src/DoubleInvocation.lf index 973c8b18f6..687b03a603 100644 --- a/test/C/src/DoubleInvocation.lf +++ b/test/C/src/DoubleInvocation.lf @@ -1,8 +1,7 @@ -// This illustrates a very strange bug that showed up and has now been fixed. -// This test ensures it does not reappear. At logical time zero, the two Print -// reactors used to be fired twice each at the same logical time. They should -// only be fired once. This behavior was oddly eliminated by either of the -// following actions, neither of which should affect this behavior: +// This illustrates a very strange bug that showed up and has now been fixed. This test ensures it +// does not reappear. At logical time zero, the two Print reactors used to be fired twice each at +// the same logical time. They should only be fired once. This behavior was oddly eliminated by +// either of the following actions, neither of which should affect this behavior: // * Removing the startup reaction in Print. // * Sending only position, not velocity from Ball. target C { diff --git a/test/C/src/DoublePort.lf b/test/C/src/DoublePort.lf index c8bf9811f8..3baab84667 100644 --- a/test/C/src/DoublePort.lf +++ b/test/C/src/DoublePort.lf @@ -1,7 +1,6 @@ /** - * Test the case where two upstream reactors pass messages to a downstream - * reactor on two different ports. One message carries a microstep delay - * relative to the other. + * Test the case where two upstream reactors pass messages to a downstream reactor on two different + * ports. One message carries a microstep delay relative to the other. * * @author Soroush Bateni */ @@ -36,9 +35,7 @@ reactor Print { } =} - reaction(shutdown) {= - printf("SUCCESS: messages were at least one microstep apart.\n"); - =} + reaction(shutdown) {= printf("SUCCESS: messages were at least one microstep apart.\n"); =} } main reactor DoublePort { diff --git a/test/C/src/DoubleReaction.lf b/test/C/src/DoubleReaction.lf index 8da6210825..0c78b9805d 100644 --- a/test/C/src/DoubleReaction.lf +++ b/test/C/src/DoubleReaction.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target C { timeout: 10 sec, fast: true diff --git a/test/C/src/DoubleTrigger.lf b/test/C/src/DoubleTrigger.lf index 68ad603168..9106853af3 100644 --- a/test/C/src/DoubleTrigger.lf +++ b/test/C/src/DoubleTrigger.lf @@ -1,5 +1,4 @@ -// Test that two simultaneous triggers don't cause a reaction to execute twice -// at the same tag. +// Test that two simultaneous triggers don't cause a reaction to execute twice at the same tag. target C { timeout: 1 sec, fast: true diff --git a/test/C/src/FloatLiteral.lf b/test/C/src/FloatLiteral.lf index 576a20d1ac..3c8bfa6037 100644 --- a/test/C/src/FloatLiteral.lf +++ b/test/C/src/FloatLiteral.lf @@ -1,7 +1,6 @@ target C -// This test verifies that floating-point literals are handled correctly. -main reactor { +main reactor { // This test verifies that floating-point literals are handled correctly. preamble {= #include =} diff --git a/test/C/src/GetTime.lf b/test/C/src/GetTime.lf index 18e70ebf79..77a8f980f9 100644 --- a/test/C/src/GetTime.lf +++ b/test/C/src/GetTime.lf @@ -1,5 +1,5 @@ -// This file includes code documented on the Wiki. For this test, success is -// just compiling and running. +// This file includes code documented on the Wiki. For this test, success is just compiling and +// running. target C { timeout: 2 sec, fast: false diff --git a/test/C/src/Import.lf b/test/C/src/Import.lf index dceb0e7813..7df0fd24b6 100644 --- a/test/C/src/Import.lf +++ b/test/C/src/Import.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target C import Imported from "lib/Imported.lf" diff --git a/test/C/src/ImportComposition.lf b/test/C/src/ImportComposition.lf index 22a1bfef87..635a3b2b8f 100644 --- a/test/C/src/ImportComposition.lf +++ b/test/C/src/ImportComposition.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target C import ImportedComposition from "lib/ImportedComposition.lf" diff --git a/test/C/src/ImportRenamed.lf b/test/C/src/ImportRenamed.lf index e28e6ba4ca..7d549f04dd 100644 --- a/test/C/src/ImportRenamed.lf +++ b/test/C/src/ImportRenamed.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target C import Imported as X from "lib/Imported.lf" diff --git a/test/C/src/InheritanceAction.lf b/test/C/src/InheritanceAction.lf index 680ffe2f75..22c4904695 100644 --- a/test/C/src/InheritanceAction.lf +++ b/test/C/src/InheritanceAction.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { fast: true } diff --git a/test/C/src/MovingAverage.lf b/test/C/src/MovingAverage.lf index a8309aa9d3..a477e55804 100644 --- a/test/C/src/MovingAverage.lf +++ b/test/C/src/MovingAverage.lf @@ -1,6 +1,5 @@ -// Demonstration of a state variable that is an array. The MovingAverage reactor -// computes the moving average of the last four inputs and produces that as -// output. The source is a counting sequence. +// Demonstration of a state variable that is an array. The MovingAverage reactor computes the moving +// average of the last four inputs and produces that as output. The source is a counting sequence. target C { timeout: 1 sec, fast: true diff --git a/test/C/src/MultipleContained.lf b/test/C/src/MultipleContained.lf index 540052ba87..f0fe73c6d5 100644 --- a/test/C/src/MultipleContained.lf +++ b/test/C/src/MultipleContained.lf @@ -1,5 +1,4 @@ -// Test that a reaction can react to and send two multiple ports of a contained -// reactor. +// Test that a reaction can react to and send two multiple ports of a contained reactor. target C reactor Contained { diff --git a/test/C/src/MultipleOutputs.lf b/test/C/src/MultipleOutputs.lf index 37b5ddba9f..b7609ab803 100644 --- a/test/C/src/MultipleOutputs.lf +++ b/test/C/src/MultipleOutputs.lf @@ -1,7 +1,6 @@ -// This test checks for one of the issues arised in the solution of EECS149 Lab -// Chapter 7. In this case, a reactor has two output ports, the first one of -// which is dangling. The generated code should not have any segmentation -// faults. +// This test checks for one of the issues arised in the solution of EECS149 Lab Chapter 7. In this +// case, a reactor has two output ports, the first one of which is dangling. The generated code +// should not have any segmentation faults. target C { timeout: 1 sec, fast: true diff --git a/test/C/src/PingPong.lf b/test/C/src/PingPong.lf index 2f1699a51d..e51f0160b8 100644 --- a/test/C/src/PingPong.lf +++ b/test/C/src/PingPong.lf @@ -1,23 +1,20 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the - * causality loop. + * Ping introduces a microstep delay using a logical action to break the causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * - Unthreaded: 97 msec * - Threaded: 265 msec * - * There is no parallelism in this application, so it does not benefit from - * being being threaded, just some additional overhead. + * There is no parallelism in this application, so it does not benefit from being being threaded, + * just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. - * These are about an order of magnitude faster than anything reported in the - * paper. + * These measurements are total execution time, including startup and shutdown. These are about an + * order of magnitude faster than anything reported in the paper. * * @author Edward A. Lee */ diff --git a/test/C/src/ReadOutputOfContainedReactor.lf b/test/C/src/ReadOutputOfContainedReactor.lf index ce2129069b..ba4490e237 100644 --- a/test/C/src/ReadOutputOfContainedReactor.lf +++ b/test/C/src/ReadOutputOfContainedReactor.lf @@ -1,5 +1,4 @@ -// Test reacting to and reading outputs from a contained reactor in various -// permutations. +// Test reacting to and reading outputs from a contained reactor in various permutations. target C reactor Contained { diff --git a/test/C/src/RepeatedInheritance.lf b/test/C/src/RepeatedInheritance.lf index b61147aa38..422ada69d8 100644 --- a/test/C/src/RepeatedInheritance.lf +++ b/test/C/src/RepeatedInheritance.lf @@ -1,6 +1,6 @@ /** - * This tests for the situation where a reactor extends two other reactors that - * each extend a common reactor. + * This tests for the situation where a reactor extends two other reactors that each extend a common + * reactor. * @author{Edward A. Lee} */ target C { @@ -27,9 +27,7 @@ reactor A extends B, C { input a: int output out: int - reaction(a, b, c, d) -> out {= - lf_set(out, a->value + b->value + c->value + d->value); - =} + reaction(a, b, c, d) -> out {= lf_set(out, a->value + b->value + c->value + d->value); =} } main reactor { diff --git a/test/C/src/RequestStop.lf b/test/C/src/RequestStop.lf index 83c59d1d27..1724f3ab92 100644 --- a/test/C/src/RequestStop.lf +++ b/test/C/src/RequestStop.lf @@ -1,5 +1,4 @@ -// Test verifying that lf_request_stop() called in a shutdown reaction is -// ignored. +// Test verifying that lf_request_stop() called in a shutdown reaction is ignored. target C main reactor { diff --git a/test/C/src/ScheduleLogicalAction.lf b/test/C/src/ScheduleLogicalAction.lf index 762f8c6f52..25fce8619d 100644 --- a/test/C/src/ScheduleLogicalAction.lf +++ b/test/C/src/ScheduleLogicalAction.lf @@ -1,5 +1,5 @@ -// This checks that a logical action is scheduled the specified logical time -// after the current logical time. +// This checks that a logical action is scheduled the specified logical time after the current +// logical time. target C { fast: true, timeout: 3 sec diff --git a/test/C/src/SendingInside.lf b/test/C/src/SendingInside.lf index b1e8f25f93..920f371d4a 100644 --- a/test/C/src/SendingInside.lf +++ b/test/C/src/SendingInside.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target C { timeout: 10 sec, fast: true diff --git a/test/C/src/SendsPointerTest.lf b/test/C/src/SendsPointerTest.lf index 1f17bd1388..0cfa6dc48c 100644 --- a/test/C/src/SendsPointerTest.lf +++ b/test/C/src/SendsPointerTest.lf @@ -1,5 +1,5 @@ -// Source produces a dynamically allocated struct, which it passes to Print. -// Reference counting ensures that the struct is freed. +// Source produces a dynamically allocated struct, which it passes to Print. Reference counting +// ensures that the struct is freed. target C preamble {= typedef int* int_pointer; =} diff --git a/test/C/src/SetArray.lf b/test/C/src/SetArray.lf index f30457f9f8..188fccba1f 100644 --- a/test/C/src/SetArray.lf +++ b/test/C/src/SetArray.lf @@ -1,5 +1,5 @@ -// This tests SET_ARRAY() This tests the use of the "polymorphic" delay reactor -// on a struct. It delays by a logical time any pointer datatype. +// This tests SET_ARRAY() This tests the use of the "polymorphic" delay reactor on a struct. It +// delays by a logical time any pointer datatype. target C reactor Source { diff --git a/test/C/src/SimpleDeadline.lf b/test/C/src/SimpleDeadline.lf index fba3e03cbc..e8ce362823 100644 --- a/test/C/src/SimpleDeadline.lf +++ b/test/C/src/SimpleDeadline.lf @@ -1,6 +1,5 @@ -// Test local deadline, where a deadline is associated with a reaction -// definition. This test triggers a reaction exactly once with a deadline -// violation. +// Test local deadline, where a deadline is associated with a reaction definition. This test +// triggers a reaction exactly once with a deadline violation. target C preamble {= diff --git a/test/C/src/SlowingClock.lf b/test/C/src/SlowingClock.lf index d4a1e1d5f4..36a1f01aef 100644 --- a/test/C/src/SlowingClock.lf +++ b/test/C/src/SlowingClock.lf @@ -1,8 +1,7 @@ /** - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 - * msec on a logical action with a minimum delay of 100 msec. The use of the - * logical action ensures the elapsed time jumps exactly from 0 to 100, 300, - * 600, and 1000 msec. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a logical + * action with a minimum delay of 100 msec. The use of the logical action ensures the elapsed time + * jumps exactly from 0 to 100, 300, 600, and 1000 msec. */ target C { timeout: 1 sec, diff --git a/test/C/src/SlowingClockPhysical.lf b/test/C/src/SlowingClockPhysical.lf index 0e82730112..7af44f3481 100644 --- a/test/C/src/SlowingClockPhysical.lf +++ b/test/C/src/SlowingClockPhysical.lf @@ -1,9 +1,8 @@ /** - * /* Events are scheduled with increasing additional delays of 0, 100, 300, 600 - * msec on a physical action with a minimum delay of 100 msec. The use of the - * physical action makes the elapsed time jumps from 0 to approximately 100 - * msec, to approximatly 300 msec thereafter, drifting away further with each - * new event. + * /* Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a physical + * action with a minimum delay of 100 msec. The use of the physical action makes the elapsed time + * jumps from 0 to approximately 100 msec, to approximatly 300 msec thereafter, drifting away + * further with each new event. */ target C { timeout: 1500 msec diff --git a/test/C/src/Starvation.lf b/test/C/src/Starvation.lf index 8f4c1423a5..c4ff41693e 100644 --- a/test/C/src/Starvation.lf +++ b/test/C/src/Starvation.lf @@ -1,6 +1,6 @@ /** - * Test that the starvation functionality in absence of the "keepalive: true" - * target property indeed works as expected. + * Test that the starvation functionality in absence of the "keepalive: true" target property indeed + * works as expected. * * @author Soroush Bateni */ diff --git a/test/C/src/StopZero.lf b/test/C/src/StopZero.lf index e845c6de48..1a317dd45e 100644 --- a/test/C/src/StopZero.lf +++ b/test/C/src/StopZero.lf @@ -1,6 +1,6 @@ /** - * Test for lf_request_stop() at tag (0,0). This also tests for logically - * simultaneous calls to lf_request_stop(). + * Test for lf_request_stop() at tag (0,0). This also tests for logically simultaneous calls to + * lf_request_stop(). * * @author Soroush Bateni */ diff --git a/test/C/src/Stride.lf b/test/C/src/Stride.lf index 62b9077878..c57c2e0aad 100644 --- a/test/C/src/Stride.lf +++ b/test/C/src/Stride.lf @@ -1,5 +1,5 @@ -// This example illustrates state variables and parameters on the wiki. For this -// test, success is just compiling and running. +// This example illustrates state variables and parameters on the wiki. For this test, success is +// just compiling and running. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/StructPrint.lf b/test/C/src/StructPrint.lf index 6af0d60c4f..5c2f10513e 100644 --- a/test/C/src/StructPrint.lf +++ b/test/C/src/StructPrint.lf @@ -1,5 +1,5 @@ -// Source produces a dynamically allocated struct, which it passes to Print. -// Reference counting ensures that the struct is freed. +// Source produces a dynamically allocated struct, which it passes to Print. Reference counting +// ensures that the struct is freed. target C { files: ["include/hello.h"] } diff --git a/test/C/src/TestForPreviousOutput.lf b/test/C/src/TestForPreviousOutput.lf index 583c6cbb74..825f559d13 100644 --- a/test/C/src/TestForPreviousOutput.lf +++ b/test/C/src/TestForPreviousOutput.lf @@ -1,5 +1,5 @@ -// This tests the mechanism for testing whether a previous reaction has produced -// a given output. The output should always be 42. +// This tests the mechanism for testing whether a previous reaction has produced a given output. The +// output should always be 42. target C preamble {= diff --git a/test/C/src/TimeLimit.lf b/test/C/src/TimeLimit.lf index ae178d53b5..3245725361 100644 --- a/test/C/src/TimeLimit.lf +++ b/test/C/src/TimeLimit.lf @@ -1,6 +1,5 @@ -// Test that the stop function can be used to internally impose a a time limit. -// Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt -// or getting the wrong data. +// Test that the stop function can be used to internally impose a a time limit. Correct output for +// this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. target C { fast: true } diff --git a/test/C/src/TimeoutZero.lf b/test/C/src/TimeoutZero.lf index 771d321a40..a9cd25a886 100644 --- a/test/C/src/TimeoutZero.lf +++ b/test/C/src/TimeoutZero.lf @@ -1,6 +1,5 @@ /** - * A test for the timeout functionality in Lingua Franca. This variant tests - * timeout at (0,0). + * A test for the timeout functionality in Lingua Franca. This variant tests timeout at (0,0). * * @author Soroush Bateni */ diff --git a/test/C/src/TriggerDownstreamOnlyIfPresent2.lf b/test/C/src/TriggerDownstreamOnlyIfPresent2.lf index bc62b214e9..5f843930b8 100644 --- a/test/C/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/C/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,7 +1,4 @@ -/** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. - */ +/** This test checks that a downstream reaction is triggered only if its trigger is present. */ target C { timeout: 1 sec, fast: true diff --git a/test/C/src/arduino/AnalogReadSerial.lf b/test/C/src/arduino/AnalogReadSerial.lf index 220cb47d47..c2fc4ef475 100644 --- a/test/C/src/arduino/AnalogReadSerial.lf +++ b/test/C/src/arduino/AnalogReadSerial.lf @@ -1,8 +1,7 @@ /** - * This example reads an analog input on pin 0, prints the result to the Serial - * Monitor. Graphical representation is available using Serial Plotter (Tools > - * Serial Plotter menu). Attach the center pin of a potentiometer to pin A0, and - * the outside pins to +5V and ground. + * This example reads an analog input on pin 0, prints the result to the Serial Monitor. Graphical + * representation is available using Serial Plotter (Tools > Serial Plotter menu). Attach the center + * pin of a potentiometer to pin A0, and the outside pins to +5V and ground. */ target C { platform: { diff --git a/test/C/src/arduino/Blink.lf b/test/C/src/arduino/Blink.lf index 809aa55884..4ed02cdc2a 100644 --- a/test/C/src/arduino/Blink.lf +++ b/test/C/src/arduino/Blink.lf @@ -1,7 +1,6 @@ /** - * This example demonstrates a very simple blink program that will turn on and - * off an LED on the Arduino Board with a 50% duty cycle switching every - * half-second. + * This example demonstrates a very simple blink program that will turn on and off an LED on the + * Arduino Board with a 50% duty cycle switching every half-second. */ target C { platform: { diff --git a/test/C/src/arduino/BlinkAttemptThreading.lf b/test/C/src/arduino/BlinkAttemptThreading.lf index 8f71009edf..31fd99989d 100644 --- a/test/C/src/arduino/BlinkAttemptThreading.lf +++ b/test/C/src/arduino/BlinkAttemptThreading.lf @@ -1,8 +1,7 @@ /** - * This example demonstrates a very simple blink program that will turn on and - * off an LED on the Arduino Board with a 50% duty cycle switching every - * half-second. Note: if we try to enable threading, the system will give us a - * warning and default back to no threading. + * This example demonstrates a very simple blink program that will turn on and off an LED on the + * Arduino Board with a 50% duty cycle switching every half-second. Note: if we try to enable + * threading, the system will give us a warning and default back to no threading. */ target C { platform: { diff --git a/test/C/src/arduino/BlinkMBED.lf b/test/C/src/arduino/BlinkMBED.lf index f9702d27cc..5330e018a0 100644 --- a/test/C/src/arduino/BlinkMBED.lf +++ b/test/C/src/arduino/BlinkMBED.lf @@ -1,7 +1,6 @@ /** - * This example demonstrates a very simple blink program that will turn on and - * off an LED on the Arduino Board with a 50% duty cycle switching every - * half-second. + * This example demonstrates a very simple blink program that will turn on and off an LED on the + * Arduino Board with a 50% duty cycle switching every half-second. */ target C { platform: { diff --git a/test/C/src/arduino/Fade.lf b/test/C/src/arduino/Fade.lf index d23aabd646..74d3fa0c8c 100644 --- a/test/C/src/arduino/Fade.lf +++ b/test/C/src/arduino/Fade.lf @@ -1,9 +1,8 @@ /** - * This example shows how to fade an LED on pin 9 using the analogWrite() - * function. The analogWrite() function uses PWM, so if you want to change the - * pin you're using, be sure to use another PWM capable pin. On most Arduino, - * the PWM pins are identified with a "~" sign, like ~3, ~5, ~6, ~9, ~10 and - * ~11. + * This example shows how to fade an LED on pin 9 using the analogWrite() function. The + * analogWrite() function uses PWM, so if you want to change the pin you're using, be sure to use + * another PWM capable pin. On most Arduino, the PWM pins are identified with a "~" sign, like ~3, + * ~5, ~6, ~9, ~10 and ~11. */ target C { platform: { diff --git a/test/C/src/arduino/ReadAnalogVoltage.lf b/test/C/src/arduino/ReadAnalogVoltage.lf index 77be8e8b06..2a56719f66 100644 --- a/test/C/src/arduino/ReadAnalogVoltage.lf +++ b/test/C/src/arduino/ReadAnalogVoltage.lf @@ -1,9 +1,8 @@ /** - * This example reads an analog input on pin 0, converts it to voltage, and - * prints the result to the Serial Monitor. Graphical representation is - * available using Serial Plotter (Tools > Serial Plotter menu). Attach the - * center pin of a potentiometer to pin A0, and the outside pins to +5V and - * ground. + * This example reads an analog input on pin 0, converts it to voltage, and prints the result to the + * Serial Monitor. Graphical representation is available using Serial Plotter (Tools > Serial + * Plotter menu). Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V + * and ground. */ target C { platform: { diff --git a/test/C/src/concurrent/AsyncCallback.lf b/test/C/src/concurrent/AsyncCallback.lf index 58120446d4..18268c574a 100644 --- a/test/C/src/concurrent/AsyncCallback.lf +++ b/test/C/src/concurrent/AsyncCallback.lf @@ -1,11 +1,9 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test case - * assumes that target is multithreaded. This test will not work with the - * unthreaded C target because that target does not implement any mutex - * protecting the event queue. + * Test asynchronous callbacks that trigger a physical action. This test case assumes that target is + * multithreaded. This test will not work with the unthreaded C target because that target does not + * implement any mutex protecting the event queue. * - * Note: This test uses the LF platform support to enable it to run on multiple - * platforms. + * Note: This test uses the LF platform support to enable it to run on multiple platforms. */ target C { tracing: true, diff --git a/test/C/src/concurrent/AsyncCallbackDrop.lf b/test/C/src/concurrent/AsyncCallbackDrop.lf index b0c5c502f2..d7d0858699 100644 --- a/test/C/src/concurrent/AsyncCallbackDrop.lf +++ b/test/C/src/concurrent/AsyncCallbackDrop.lf @@ -1,7 +1,6 @@ -// Test asynchronous callbacks that trigger a physical action with a DROP -// policy. This test case assumes that the target is multithreaded. This test -// will not work with the unthreaded C target because that target does not -// implement any mutex protecting the event queue. +// Test asynchronous callbacks that trigger a physical action with a DROP policy. This test case +// assumes that the target is multithreaded. This test will not work with the unthreaded C target +// because that target does not implement any mutex protecting the event queue. target C { keepalive: true, // To silence warning. timeout: 2 sec diff --git a/test/C/src/concurrent/AsyncCallbackReplace.lf b/test/C/src/concurrent/AsyncCallbackReplace.lf index 7bac7496b5..ba75b3e3db 100644 --- a/test/C/src/concurrent/AsyncCallbackReplace.lf +++ b/test/C/src/concurrent/AsyncCallbackReplace.lf @@ -1,7 +1,6 @@ -// Test asynchronous callbacks that trigger a physical action with a "replace" -// policy. This test case assumes that the target is multithreaded. This test -// will not work with the unthreaded C target because that target does not -// implement any mutex protecting the event queue. +// Test asynchronous callbacks that trigger a physical action with a "replace" policy. This test +// case assumes that the target is multithreaded. This test will not work with the unthreaded C +// target because that target does not implement any mutex protecting the event queue. target C { keepalive: true, timeout: 2 sec diff --git a/test/C/src/concurrent/CompositionThreaded.lf b/test/C/src/concurrent/CompositionThreaded.lf index cf0bafeb82..01185fa6b3 100644 --- a/test/C/src/concurrent/CompositionThreaded.lf +++ b/test/C/src/concurrent/CompositionThreaded.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { fast: true, timeout: 10 sec diff --git a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf index ad14879080..5f698d1c95 100644 --- a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target C preamble {= diff --git a/test/C/src/concurrent/DeadlineThreaded.lf b/test/C/src/concurrent/DeadlineThreaded.lf index ffc1be2701..ff5961b0d9 100644 --- a/test/C/src/concurrent/DeadlineThreaded.lf +++ b/test/C/src/concurrent/DeadlineThreaded.lf @@ -1,6 +1,5 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target C { timeout: 6 sec } diff --git a/test/C/src/concurrent/DoubleReactionThreaded.lf b/test/C/src/concurrent/DoubleReactionThreaded.lf index ba6c38ca19..eb46b4f7d6 100644 --- a/test/C/src/concurrent/DoubleReactionThreaded.lf +++ b/test/C/src/concurrent/DoubleReactionThreaded.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target C { timeout: 10 sec, fast: true diff --git a/test/C/src/concurrent/ImportThreaded.lf b/test/C/src/concurrent/ImportThreaded.lf index df804157c5..b10a222f1a 100644 --- a/test/C/src/concurrent/ImportThreaded.lf +++ b/test/C/src/concurrent/ImportThreaded.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target C import Imported from "../lib/Imported.lf" diff --git a/test/C/src/concurrent/PingPongThreaded.lf b/test/C/src/concurrent/PingPongThreaded.lf index 4fae17911e..37d7b97574 100644 --- a/test/C/src/concurrent/PingPongThreaded.lf +++ b/test/C/src/concurrent/PingPongThreaded.lf @@ -1,23 +1,19 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the - * causality loop. + * Ping introduces a microstep delay using a logical action to break the causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * - * Unthreaded: 97 msec Threaded: 265 msec (168 msec with optimization of - * executing immediately) + * Unthreaded: 97 msec Threaded: 265 msec (168 msec with optimization of executing immediately) * - * There is no parallelism in this application, so it does not benefit from - * being being threaded, just some additional overhead. + * There is no parallelism in this application, so it does not benefit from being being threaded, + * just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. - * These are about an order of magnitude faster than anything reported in the - * paper. + * These measurements are total execution time, including startup and shutdown. These are about an + * order of magnitude faster than anything reported in the paper. * * @author Edward A. Lee */ diff --git a/test/C/src/concurrent/SendingInsideThreaded.lf b/test/C/src/concurrent/SendingInsideThreaded.lf index e5185ecfc8..dc0892195b 100644 --- a/test/C/src/concurrent/SendingInsideThreaded.lf +++ b/test/C/src/concurrent/SendingInsideThreaded.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target C { timeout: 10 sec, fast: true diff --git a/test/C/src/concurrent/StarvationThreaded.lf b/test/C/src/concurrent/StarvationThreaded.lf index d1e78e5ced..2e50b71a58 100644 --- a/test/C/src/concurrent/StarvationThreaded.lf +++ b/test/C/src/concurrent/StarvationThreaded.lf @@ -1,7 +1,6 @@ /** - * Test that the starvation functionality in absence of the "keepalive: true" - * target property indeed works as expected. This version uses the threaded - * runtime. + * Test that the starvation functionality in absence of the "keepalive: true" target property indeed + * works as expected. This version uses the threaded runtime. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/StopThreaded.lf b/test/C/src/concurrent/StopThreaded.lf index 1deb1c4ff6..7beb0cb747 100644 --- a/test/C/src/concurrent/StopThreaded.lf +++ b/test/C/src/concurrent/StopThreaded.lf @@ -1,6 +1,6 @@ /** - * A test for the lf_request_stop() functionality in Lingua Franca. This version - * of the test is threaded. + * A test for the lf_request_stop() functionality in Lingua Franca. This version of the test is + * threaded. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/StopZeroThreaded.lf b/test/C/src/concurrent/StopZeroThreaded.lf index 7afd4b0069..22f5635e6c 100644 --- a/test/C/src/concurrent/StopZeroThreaded.lf +++ b/test/C/src/concurrent/StopZeroThreaded.lf @@ -1,6 +1,5 @@ /** - * Test for lf_request_stop() at tag (0,0). This version uses the threaded - * runtime. + * Test for lf_request_stop() at tag (0,0). This version uses the threaded runtime. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/Threaded.lf b/test/C/src/concurrent/Threaded.lf index 01f67c1bd4..4daa36f6fd 100644 --- a/test/C/src/concurrent/Threaded.lf +++ b/test/C/src/concurrent/Threaded.lf @@ -1,16 +1,13 @@ -// Check for speedup of multithreaded execution on multicore machines. Each -// instance of TakeTime takes 200 ms to transport the input to the output. Four -// of them are instantiated. Note that without parallel execution, there is no -// way this can keep up with real time since in every 200 msec cycle it has 800 -// msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded -// version, showing that without threads, this takes more than 800 msec to -// complete 200 msec of logical time. See ThreadedMultiport for a parameterized -// version of this. +// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime +// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that +// without parallel execution, there is no way this can keep up with real time since in every 200 +// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing +// that without threads, this takes more than 800 msec to complete 200 msec of logical time. See +// ThreadedMultiport for a parameterized version of this. target C { timeout: 2 sec, - // Disable compiler optimization so that TakeTime actually takes time. - flags: "" + flags: "" // Disable compiler optimization so that TakeTime actually takes time. } reactor Source { diff --git a/test/C/src/concurrent/ThreadedMultiport.lf b/test/C/src/concurrent/ThreadedMultiport.lf index 2878393dac..cbf8459b08 100644 --- a/test/C/src/concurrent/ThreadedMultiport.lf +++ b/test/C/src/concurrent/ThreadedMultiport.lf @@ -1,8 +1,7 @@ // Check multiport capabilities on Outputs. target C { timeout: 2 sec, - // Disable compiler optimization so that TakeTime actually takes time. - flags: "" + flags: "" // Disable compiler optimization so that TakeTime actually takes time. } reactor Source(width: int = 4) { diff --git a/test/C/src/concurrent/ThreadedThreaded.lf b/test/C/src/concurrent/ThreadedThreaded.lf index 4037e8c193..0ff1f1e09b 100644 --- a/test/C/src/concurrent/ThreadedThreaded.lf +++ b/test/C/src/concurrent/ThreadedThreaded.lf @@ -1,15 +1,13 @@ -// Check for speedup of multithreaded execution on multicore machines. Each -// instance of TakeTime takes 200 ms to transport the input to the output. Four -// of them are instantiated. Note that without parallel execution, there is no -// way this can keep up with real time since in every 200 msec cycle it has 800 -// msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. See ThreadedMultiport for a -// parameterized version of this. +// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime +// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that +// without parallel execution, there is no way this can keep up with real time since in every 200 +// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. See ThreadedMultiport for a parameterized version +// of this. target C { timeout: 2 sec, tracing: true, - // Disable compiler optimization so that TakeTime actually takes time. - flags: "" + flags: "" // Disable compiler optimization so that TakeTime actually takes time. } reactor Source { diff --git a/test/C/src/concurrent/TimeLimitThreaded.lf b/test/C/src/concurrent/TimeLimitThreaded.lf index 8d3824af47..07bd3c9257 100644 --- a/test/C/src/concurrent/TimeLimitThreaded.lf +++ b/test/C/src/concurrent/TimeLimitThreaded.lf @@ -1,5 +1,5 @@ -// Test that the stop function can be used to internally impose a a time limit. -// Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt. +// Test that the stop function can be used to internally impose a a time limit. Correct output for +// this 1, 2, 3, 4. Failure for this test is failing to halt. target C { fast: true } diff --git a/test/C/src/concurrent/TimeoutThreaded.lf b/test/C/src/concurrent/TimeoutThreaded.lf index 82ef231ed9..41fd8d1147 100644 --- a/test/C/src/concurrent/TimeoutThreaded.lf +++ b/test/C/src/concurrent/TimeoutThreaded.lf @@ -1,6 +1,5 @@ /** - * A test for the timeout functionality in Lingua Franca. This version of the - * test is threaded. + * A test for the timeout functionality in Lingua Franca. This version of the test is threaded. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/TimeoutZeroThreaded.lf b/test/C/src/concurrent/TimeoutZeroThreaded.lf index 7865b486a9..9df91b99ba 100644 --- a/test/C/src/concurrent/TimeoutZeroThreaded.lf +++ b/test/C/src/concurrent/TimeoutZeroThreaded.lf @@ -1,6 +1,6 @@ /** - * A test for the timeout functionality in Lingua Franca. This variant tests - * timeout at (0,0) and uses the threaded runtime. + * A test for the timeout functionality in Lingua Franca. This variant tests timeout at (0,0) and + * uses the threaded runtime. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/Tracing.lf b/test/C/src/concurrent/Tracing.lf index cbc4513732..2d13fbf259 100644 --- a/test/C/src/concurrent/Tracing.lf +++ b/test/C/src/concurrent/Tracing.lf @@ -2,8 +2,7 @@ target C { timeout: 2 sec, tracing: true, - // Disable compiler optimization so that TakeTime actually takes time. - flags: "", + flags: "", // Disable compiler optimization so that TakeTime actually takes time. logging: DEBUG } diff --git a/test/C/src/docker/PingPongContainerized.lf b/test/C/src/docker/PingPongContainerized.lf index e9ea8a0b56..10062bb3eb 100644 --- a/test/C/src/docker/PingPongContainerized.lf +++ b/test/C/src/docker/PingPongContainerized.lf @@ -1,22 +1,19 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the - * causality loop. + * Ping introduces a microstep delay using a logical action to break the causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * - Unthreaded: 97 msec * - Threaded: 265 msec * - * There is no parallelism in this application, so it does not benefit from - * being being threaded, just some additional overhead. + * There is no parallelism in this application, so it does not benefit from being being threaded, + * just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. - * These are about an order of magnitude faster than anything reported in the - * paper. + * These measurements are total execution time, including startup and shutdown. These are about an + * order of magnitude faster than anything reported in the paper. * * @author Edward A. Lee */ diff --git a/test/C/src/docker/federated/DistributedCountContainerized.lf b/test/C/src/docker/federated/DistributedCountContainerized.lf index 4a120c5e1e..13ae54fd80 100644 --- a/test/C/src/docker/federated/DistributedCountContainerized.lf +++ b/test/C/src/docker/federated/DistributedCountContainerized.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { diff --git a/test/C/src/docker/federated/DistributedDoublePortContainerized.lf b/test/C/src/docker/federated/DistributedDoublePortContainerized.lf index d856b6a600..6227b8b00a 100644 --- a/test/C/src/docker/federated/DistributedDoublePortContainerized.lf +++ b/test/C/src/docker/federated/DistributedDoublePortContainerized.lf @@ -1,7 +1,6 @@ /** - * Test the case for when two upstream federates send messages to a downstream - * federte on two different ports. One message should carry a microstep delay - * relative to the other message. + * Test the case for when two upstream federates send messages to a downstream federte on two + * different ports. One message should carry a microstep delay relative to the other message. * * @author Soroush Bateni */ diff --git a/test/C/src/docker/federated/DistributedStopDecentralizedContainerized.lf b/test/C/src/docker/federated/DistributedStopDecentralizedContainerized.lf index b72052a888..342dde28e0 100644 --- a/test/C/src/docker/federated/DistributedStopDecentralizedContainerized.lf +++ b/test/C/src/docker/federated/DistributedStopDecentralizedContainerized.lf @@ -1,6 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with decentralized - * coordination. + * Test for lf_request_stop() in federated execution with decentralized coordination. * * @author Soroush Bateni */ diff --git a/test/C/src/federated/BroadcastFeedback.lf b/test/C/src/federated/BroadcastFeedback.lf index 2bef908d2d..b38bb399d7 100644 --- a/test/C/src/federated/BroadcastFeedback.lf +++ b/test/C/src/federated/BroadcastFeedback.lf @@ -1,6 +1,4 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target C { timeout: 1 sec, build-type: RelWithDebInfo diff --git a/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf b/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf index d9edbc954b..7ac7edecb1 100644 --- a/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf +++ b/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf @@ -1,6 +1,4 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target C { timeout: 1 sec } diff --git a/test/C/src/federated/CycleDetection.lf b/test/C/src/federated/CycleDetection.lf index d22837bc1f..fb5bf39a7c 100644 --- a/test/C/src/federated/CycleDetection.lf +++ b/test/C/src/federated/CycleDetection.lf @@ -1,6 +1,6 @@ /** - * Check whether the internally generated network and control reactions - * introduce a cycle or not. The failure for this test is not being compiled. + * Check whether the internally generated network and control reactions introduce a cycle or not. + * The failure for this test is not being compiled. * @author Edward A. Lee */ target C diff --git a/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf b/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf index 9dea4032aa..2d007d2b09 100644 --- a/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf +++ b/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf @@ -1,8 +1,7 @@ /** - * Test a source-destination scenario where the source falls behind real-time, - * and reaches the timeout much later than the destination. In this test, the - * destination closes the connection early, causing the transmission to fail. - * Warnings will be printed about lost messages. + * Test a source-destination scenario where the source falls behind real-time, and reaches the + * timeout much later than the destination. In this test, the destination closes the connection + * early, causing the transmission to fail. Warnings will be printed about lost messages. * * The test fails if the federation does not exit. */ @@ -22,9 +21,7 @@ reactor Clock(offset: time = 0, period: time = 1 sec) { lf_set(y, self->count); =} - reaction(shutdown) {= - lf_print("SUCCESS: the source exited successfully."); - =} + reaction(shutdown) {= lf_print("SUCCESS: the source exited successfully."); =} } reactor Destination { diff --git a/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index 8468e1dc81..fc45db9d74 100644 --- a/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -1,11 +1,10 @@ /** - * Test a source-destination scenario where the source falls behind real-time, - * and reaches the timeout much later than the destination. In this test, the - * destination closes the connection early, causing the transmission to fail. - * Warnings will be printed. + * Test a source-destination scenario where the source falls behind real-time, and reaches the + * timeout much later than the destination. In this test, the destination closes the connection + * early, causing the transmission to fail. Warnings will be printed. * - * The test fails if the federation does not exit amenably. This variant has a - * physical connection between source and destination. + * The test fails if the federation does not exit amenably. This variant has a physical connection + * between source and destination. */ target C { timeout: 1 msec, @@ -23,9 +22,7 @@ reactor Clock(offset: time = 0, period: time = 1 sec) { lf_set(y, self->count); =} - reaction(shutdown) {= - lf_print("SUCCESS: the source exited successfully."); - =} + reaction(shutdown) {= lf_print("SUCCESS: the source exited successfully."); =} } reactor Destination { diff --git a/test/C/src/federated/DistributedCount.lf b/test/C/src/federated/DistributedCount.lf index 2ebdda169a..472e7f83a0 100644 --- a/test/C/src/federated/DistributedCount.lf +++ b/test/C/src/federated/DistributedCount.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { diff --git a/test/C/src/federated/DistributedCountDecentralized.lf b/test/C/src/federated/DistributedCountDecentralized.lf index 631dfab0c0..473e959392 100644 --- a/test/C/src/federated/DistributedCountDecentralized.lf +++ b/test/C/src/federated/DistributedCountDecentralized.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { @@ -48,6 +47,5 @@ reactor Print { federated reactor DistributedCountDecentralized { c = new Count() p = new Print() - // Indicating a 'logical' connection with a large enough delay. - c.out -> p.in after 200 msec + c.out -> p.in after 200 msec // Indicating a 'logical' connection with a large enough delay. } diff --git a/test/C/src/federated/DistributedCountPhysical.lf b/test/C/src/federated/DistributedCountPhysical.lf index 9e1e15f775..77355720ff 100644 --- a/test/C/src/federated/DistributedCountPhysical.lf +++ b/test/C/src/federated/DistributedCountPhysical.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf index b0da42218a..eeb2792425 100644 --- a/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf +++ b/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -1,7 +1,7 @@ /** - * Test a distributed system where a federation receives messages only over - * connections that are marked 'physical' (using the ~> arrow) with an after - * delay. The receiver verifies that the after delay is correctly imposed. + * Test a distributed system where a federation receives messages only over connections that are + * marked 'physical' (using the ~> arrow) with an after delay. The receiver verifies that the after + * delay is correctly imposed. * * @author Edward A. Lee * @author Soroush Bateni @@ -46,6 +46,5 @@ reactor Print { federated reactor at localhost { c = new Count(offset = 200 msec, period = 0) p = new Print() - // Indicating a 'physical' connection with a 400 msec after delay. - c.out ~> p.in after 400 msec + c.out ~> p.in after 400 msec // Indicating a 'physical' connection with a 400 msec after delay. } diff --git a/test/C/src/federated/DistributedCountPhysicalDecentralized.lf b/test/C/src/federated/DistributedCountPhysicalDecentralized.lf index e821e4fb70..b9a606ba0b 100644 --- a/test/C/src/federated/DistributedCountPhysicalDecentralized.lf +++ b/test/C/src/federated/DistributedCountPhysicalDecentralized.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/C/src/federated/DistributedDoublePort.lf b/test/C/src/federated/DistributedDoublePort.lf index 87de1ddb28..3394c383b6 100644 --- a/test/C/src/federated/DistributedDoublePort.lf +++ b/test/C/src/federated/DistributedDoublePort.lf @@ -1,7 +1,6 @@ /** - * Test the case for when two upstream federates send messages to a downstream - * federate on two different ports. One message should carry a microstep delay - * relative to the other message. + * Test the case for when two upstream federates send messages to a downstream federate on two + * different ports. One message should carry a microstep delay relative to the other message. * * @author Soroush Bateni */ @@ -36,9 +35,7 @@ reactor Print { } =} - reaction(shutdown) {= - lf_print("SUCCESS: messages were at least one microstep apart."); - =} + reaction(shutdown) {= lf_print("SUCCESS: messages were at least one microstep apart."); =} } federated reactor DistributedDoublePort { diff --git a/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf b/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf index acbbaf4035..a8c3805f34 100644 --- a/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf @@ -1,6 +1,6 @@ /** - * Test that a rapidly produced logical action in an upstream federate can be - * properly handled in a long chain of federates. + * Test that a rapidly produced logical action in an upstream federate can be properly handled in a + * long chain of federates. */ target C { timeout: 1 msec diff --git a/test/C/src/federated/DistributedLoopedAction.lf b/test/C/src/federated/DistributedLoopedAction.lf index 8218e73646..a398fb8b8d 100644 --- a/test/C/src/federated/DistributedLoopedAction.lf +++ b/test/C/src/federated/DistributedLoopedAction.lf @@ -1,6 +1,5 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. + * Test a sender-receiver network system that relies on microsteps being taken into account. * * @author Soroush Bateni */ @@ -20,8 +19,7 @@ reactor Receiver( state breaks: int = 0 timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more - // sensible log output. + // but forces the logical time to advance Comment this line for a more sensible log output. reaction(in) {= printf("At tag (%lld, %u) received value %d.\n", lf_time_logical_elapsed(), diff --git a/test/C/src/federated/DistributedLoopedActionDecentralized.lf b/test/C/src/federated/DistributedLoopedActionDecentralized.lf index 17842809fa..5a51465e5c 100644 --- a/test/C/src/federated/DistributedLoopedActionDecentralized.lf +++ b/test/C/src/federated/DistributedLoopedActionDecentralized.lf @@ -1,15 +1,13 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. The purpose of this test is to check whether the - * functionalities pertinent to dynamic STP offset adjustments are present and - * functioning to a degree. + * Test a sender-receiver network system that relies on microsteps being taken into account. The + * purpose of this test is to check whether the functionalities pertinent to dynamic STP offset + * adjustments are present and functioning to a degree. * - * This version of the test does not use a centralized coordinator to advance - * tag. Therefore, the receiver will rely on an STP offset (initially zero) to - * wait long enough for messages to arrive before advancing its tag. In this - * test, the STP offset is initially zero and gradually raised every time an STP - * violation is perceived until no STP violation is observed. Therefore, the - * exact outcome of the test will depend on actual runtime timing. + * This version of the test does not use a centralized coordinator to advance tag. Therefore, the + * receiver will rely on an STP offset (initially zero) to wait long enough for messages to arrive + * before advancing its tag. In this test, the STP offset is initially zero and gradually raised + * every time an STP violation is perceived until no STP violation is observed. Therefore, the exact + * outcome of the test will depend on actual runtime timing. * * @author Soroush Bateni */ @@ -116,10 +114,7 @@ reactor STPReceiver( federated reactor DistributedLoopedActionDecentralized { sender = new Sender(take_a_break_after = 10, break_interval = 400 msec) - stpReceiver = new STPReceiver( - take_a_break_after = 10, - break_interval = 400 msec - ) + stpReceiver = new STPReceiver(take_a_break_after = 10, break_interval = 400 msec) sender.out -> stpReceiver.in } diff --git a/test/C/src/federated/DistributedLoopedPhysicalAction.lf b/test/C/src/federated/DistributedLoopedPhysicalAction.lf index 454577ff35..d1990c05ad 100644 --- a/test/C/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/C/src/federated/DistributedLoopedPhysicalAction.lf @@ -1,11 +1,10 @@ /** - * Test a sender-receiver network system that is similar to - * DistributedLoopedAction, but it uses a physical action rather than a logical - * action. This also demonstrates the advance-message-interval coordination - * option. This specifies the time period between Time Advance Notice (TAN) - * messages sent to the RTI (a form of null message that must be sent because of - * the physical action). The presence of this option also silences a warning - * about having a physical action that triggers an output. + * Test a sender-receiver network system that is similar to DistributedLoopedAction, but it uses a + * physical action rather than a logical action. This also demonstrates the advance-message-interval + * coordination option. This specifies the time period between Time Advance Notice (TAN) messages + * sent to the RTI (a form of null message that must be sent because of the physical action). The + * presence of this option also silences a warning about having a physical action that triggers an + * output. * * @author Soroush Bateni */ @@ -45,8 +44,7 @@ reactor Receiver( state breaks: int = 0 timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more - // sensible log output. + // but forces the logical time to advance Comment this line for a more sensible log output. reaction(in) {= tag_t current_tag = lf_tag(); lf_print("At tag (%lld, %u) received %d.", diff --git a/test/C/src/federated/DistributedLoopedPhysicalActionDecentralized.lf b/test/C/src/federated/DistributedLoopedPhysicalActionDecentralized.lf index 8b22bc70be..38c4e016fe 100644 --- a/test/C/src/federated/DistributedLoopedPhysicalActionDecentralized.lf +++ b/test/C/src/federated/DistributedLoopedPhysicalActionDecentralized.lf @@ -1,6 +1,5 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. + * Test a sender-receiver network system that relies on microsteps being taken into account. * * @author Soroush Bateni */ diff --git a/test/C/src/federated/DistributedMultiportToken.lf b/test/C/src/federated/DistributedMultiportToken.lf index dfb791d861..c3a370cb66 100644 --- a/test/C/src/federated/DistributedMultiportToken.lf +++ b/test/C/src/federated/DistributedMultiportToken.lf @@ -1,5 +1,5 @@ -// Check multiport connections between federates where the message is carried by -// a Token (in this case, with an array of char). +// Check multiport connections between federates where the message is carried by a Token (in this +// case, with an array of char). target C { timeout: 1 sec, coordination: centralized diff --git a/test/C/src/federated/DistributedNetworkOrder.lf b/test/C/src/federated/DistributedNetworkOrder.lf index 42f3da6134..09ea7665c9 100644 --- a/test/C/src/federated/DistributedNetworkOrder.lf +++ b/test/C/src/federated/DistributedNetworkOrder.lf @@ -1,10 +1,9 @@ /** * This is a test for send_timed_message, which is an internal API. * - * This test sends a second message at time 5 msec that has the same intended - * tag as a message that it had previously sent at time 0 msec. This results in - * a warning, but the message microstep is incremented and correctly received - * one microstep later. + * This test sends a second message at time 5 msec that has the same intended tag as a message that + * it had previously sent at time 0 msec. This results in a warning, but the message microstep is + * incremented and correctly received one microstep later. * * @author Soroush Bateni */ diff --git a/test/C/src/federated/DistributedPhysicalActionUpstream.lf b/test/C/src/federated/DistributedPhysicalActionUpstream.lf index 520142b466..f41aa0dae3 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstream.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstream.lf @@ -1,6 +1,6 @@ /** - * Test that a rapidly produced physical action in an upstream federate can be - * properly handled in federated execution. + * Test that a rapidly produced physical action in an upstream federate can be properly handled in + * federated execution. */ target C { timeout: 10 secs, diff --git a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf index 5cee1171cc..a77727d9ce 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf @@ -1,6 +1,6 @@ /** - * Test that a rapidly produced physical action in an upstream federate can be - * properly handled in a long chain of federates. + * Test that a rapidly produced physical action in an upstream federate can be properly handled in a + * long chain of federates. */ target C { timeout: 1 sec, diff --git a/test/C/src/federated/DistributedStop.lf b/test/C/src/federated/DistributedStop.lf index 2d4a616664..7d906a0efe 100644 --- a/test/C/src/federated/DistributedStop.lf +++ b/test/C/src/federated/DistributedStop.lf @@ -1,6 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with centralized - * coordination. + * Test for lf_request_stop() in federated execution with centralized coordination. * * @author Soroush Bateni */ diff --git a/test/C/src/federated/DistributedStopDecentralized.lf b/test/C/src/federated/DistributedStopDecentralized.lf index bcf866aad6..f26dfe256a 100644 --- a/test/C/src/federated/DistributedStopDecentralized.lf +++ b/test/C/src/federated/DistributedStopDecentralized.lf @@ -1,6 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with decentralized - * coordination. + * Test for lf_request_stop() in federated execution with decentralized coordination. * * @author Soroush Bateni */ diff --git a/test/C/src/federated/DistributedStopZero.lf b/test/C/src/federated/DistributedStopZero.lf index 67141bc624..82f49b9b91 100644 --- a/test/C/src/federated/DistributedStopZero.lf +++ b/test/C/src/federated/DistributedStopZero.lf @@ -1,6 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with centralized - * coordination at tag (0,0). + * Test for lf_request_stop() in federated execution with centralized coordination at tag (0,0). * * @author Soroush Bateni */ diff --git a/test/C/src/federated/DistributedStopZeroDecentralized.lf b/test/C/src/federated/DistributedStopZeroDecentralized.lf index fe7a6e28cd..ae37fb3fc3 100644 --- a/test/C/src/federated/DistributedStopZeroDecentralized.lf +++ b/test/C/src/federated/DistributedStopZeroDecentralized.lf @@ -1,6 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with decentralized - * coordination at tag (0,0). + * Test for lf_request_stop() in federated execution with decentralized coordination at tag (0,0). * * @author Soroush Bateni */ diff --git a/test/C/src/federated/HelloDistributed.lf b/test/C/src/federated/HelloDistributed.lf index 909ce53b43..f0d74eead3 100644 --- a/test/C/src/federated/HelloDistributed.lf +++ b/test/C/src/federated/HelloDistributed.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target C @@ -49,7 +48,5 @@ federated reactor HelloDistributed at localhost { d = new Destination() // Reactor d is in federate Destination s.out -> d.in // This version preserves the timestamp. - reaction(startup) {= - lf_print("Printing something in top-level federated reactor."); - =} + reaction(startup) {= lf_print("Printing something in top-level federated reactor."); =} } diff --git a/test/C/src/federated/LoopDistributedCentralized.lf b/test/C/src/federated/LoopDistributedCentralized.lf index 7fdc972b5a..15a1c46934 100644 --- a/test/C/src/federated/LoopDistributedCentralized.lf +++ b/test/C/src/federated/LoopDistributedCentralized.lf @@ -1,6 +1,5 @@ /** - * This tests a feedback loop with physical actions and centralized - * coordination. + * This tests a feedback loop with physical actions and centralized coordination. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf b/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf index f9b088b7d1..9956d2ef34 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf @@ -1,6 +1,6 @@ /** - * This tests that the precedence order of reaction invocation is kept when a - * feedback loop is present in centralized coordination. + * This tests that the precedence order of reaction invocation is kept when a feedback loop is + * present in centralized coordination. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf b/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf index 17177aadb3..0e214813cd 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf @@ -1,7 +1,6 @@ /** - * This tests that the precedence order of reaction invocation is kept in the - * hierarchy of reactors when a feedback loop is present in centralized - * coordination. + * This tests that the precedence order of reaction invocation is kept in the hierarchy of reactors + * when a feedback loop is present in centralized coordination. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/C/src/federated/LoopDistributedDecentralized.lf b/test/C/src/federated/LoopDistributedDecentralized.lf index 4350c984b3..98d7a54eab 100644 --- a/test/C/src/federated/LoopDistributedDecentralized.lf +++ b/test/C/src/federated/LoopDistributedDecentralized.lf @@ -1,6 +1,5 @@ /** - * This tests a feedback loop with physical actions and decentralized - * coordination. + * This tests a feedback loop with physical actions and decentralized coordination. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/LoopDistributedDouble.lf b/test/C/src/federated/LoopDistributedDouble.lf index 9a49b5bde8..8646a477bf 100644 --- a/test/C/src/federated/LoopDistributedDouble.lf +++ b/test/C/src/federated/LoopDistributedDouble.lf @@ -1,6 +1,5 @@ /** - * This tests a feedback loop with physical actions and centralized - * coordination. + * This tests a feedback loop with physical actions and centralized coordination. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/PhysicalSTP.lf b/test/C/src/federated/PhysicalSTP.lf index 11b7a259cf..4e8a6c7a5d 100644 --- a/test/C/src/federated/PhysicalSTP.lf +++ b/test/C/src/federated/PhysicalSTP.lf @@ -1,7 +1,4 @@ -/** - * This is a test that detects STP violations according to the physical time of - * message arrival. - */ +/** This is a test that detects STP violations according to the physical time of message arrival. */ target C { timeout: 1900 msec, coordination: decentralized diff --git a/test/C/src/federated/PingPongDistributed.lf b/test/C/src/federated/PingPongDistributed.lf index e16de50ed2..147768f12d 100644 --- a/test/C/src/federated/PingPongDistributed.lf +++ b/test/C/src/federated/PingPongDistributed.lf @@ -1,21 +1,18 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. * - * This version is distributed, communicating using logical connections over - * sockets. + * This version is distributed, communicating using logical connections over sockets. * - * See [Benchmarks wiki - * page](https://github.com/icyphy/lingua-franca/wiki/Benchmarks). + * See [Benchmarks wiki page](https://github.com/icyphy/lingua-franca/wiki/Benchmarks). * * This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs - * and can be run on different machines. + * This is a distributed version, where Ping and Pong run in separate programs and can be run on + * different machines. * - * There is no parallelism in this application, so it does not benefit from - * being being distributed. + * There is no parallelism in this application, so it does not benefit from being being distributed. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/PingPongDistributedPhysical.lf b/test/C/src/federated/PingPongDistributedPhysical.lf index d9ba517c59..16769ec929 100644 --- a/test/C/src/federated/PingPongDistributedPhysical.lf +++ b/test/C/src/federated/PingPongDistributedPhysical.lf @@ -1,26 +1,24 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. * - * This version is distributed, communicating using physical connections over - * sockets. + * This version is distributed, communicating using physical connections over sockets. * * This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs - * and can be run on different machines. + * This is a distributed version, where Ping and Pong run in separate programs and can be run on + * different machines. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * - Unthreaded: 97 msec * - Threaded: 265 msec * - Distributed: 53 seconds * - * There is no parallelism in this application, so it does not benefit from - * being being distributed. + * There is no parallelism in this application, so it does not benefit from being being distributed. * - * These measurements are total execution time, including startup and shutdown, - * of all three programs. + * These measurements are total execution time, including startup and shutdown, of all three + * programs. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/TopLevelArtifacts.lf b/test/C/src/federated/TopLevelArtifacts.lf index 05932b1937..42a7cb3a37 100644 --- a/test/C/src/federated/TopLevelArtifacts.lf +++ b/test/C/src/federated/TopLevelArtifacts.lf @@ -1,11 +1,10 @@ /** - * Test whether top-level reactions, actions, and ports are handled - * appropriately. + * Test whether top-level reactions, actions, and ports are handled appropriately. * * Currently, these artifacts are replicated on all federates. * - * @note This just tests for the correctness of the code generation. These - * top-level artifacts might be disallowed in the future. + * @note This just tests for the correctness of the code generation. These top-level artifacts might + * be disallowed in the future. */ target C { timeout: 1 msec diff --git a/test/C/src/federated/failing/ClockSync.lf b/test/C/src/federated/failing/ClockSync.lf index 1231ce9cbf..a6c1e254d3 100644 --- a/test/C/src/federated/failing/ClockSync.lf +++ b/test/C/src/federated/failing/ClockSync.lf @@ -1,8 +1,8 @@ /** - * This program tests clock synchronization. It checks the clock synchronization - * error and fails if it exceeds a threshold. Note that failures could occur - * here intermittently because clock synchronization accuracy depends on many - * conditions. But the threshold is quite high, so failures should be rare. + * This program tests clock synchronization. It checks the clock synchronization error and fails if + * it exceeds a threshold. Note that failures could occur here intermittently because clock + * synchronization accuracy depends on many conditions. But the threshold is quite high, so failures + * should be rare. * @author Edward A. Lee */ target C { @@ -10,21 +10,16 @@ target C { timeout: 10 sec, clock-sync: on, // Turn on runtime clock synchronization. clock-sync-options: { - // Forces all federates to perform clock sync. - local-federates-on: true, - // Collect useful statistics like average network delay and the standard - // deviation for the network delay over one clock synchronization cycle. - // Generates a warning if the standard deviation is higher than the - // clock sync guard. Artificially offsets clocks by multiples of 200 - // msec. + local-federates-on: true, // Forces all federates to perform clock sync. + // Collect useful statistics like average network delay and the standard deviation for the + // network delay over one clock synchronization cycle. Generates a warning if the standard + // deviation is higher than the clock sync guard. Artificially offsets clocks by multiples + // of 200 msec. collect-stats: true, test-offset: 200 msec, - // Period with which runtime clock sync is performed. - period: 5 msec, - // Number of messages exchanged to perform clock sync. - trials: 10, - // Attenuation applied to runtime clock sync adjustments. - attenuation: 10 + period: 5 msec, // Period with which runtime clock sync is performed. + trials: 10, // Number of messages exchanged to perform clock sync. + attenuation: 10 // Attenuation applied to runtime clock sync adjustments. } } diff --git a/test/C/src/lib/Imported.lf b/test/C/src/lib/Imported.lf index b6cb3200c8..1c86f0cff8 100644 --- a/test/C/src/lib/Imported.lf +++ b/test/C/src/lib/Imported.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target C import ImportedAgain from "./ImportedAgain.lf" diff --git a/test/C/src/lib/ImportedAgain.lf b/test/C/src/lib/ImportedAgain.lf index 07f2cc9faa..af57afcace 100644 --- a/test/C/src/lib/ImportedAgain.lf +++ b/test/C/src/lib/ImportedAgain.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target C reactor ImportedAgain { diff --git a/test/C/src/lib/ImportedComposition.lf b/test/C/src/lib/ImportedComposition.lf index d10e7fdcd2..66a8845233 100644 --- a/test/C/src/lib/ImportedComposition.lf +++ b/test/C/src/lib/ImportedComposition.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target C reactor Gain { diff --git a/test/C/src/lib/LoopedActionSender.lf b/test/C/src/lib/LoopedActionSender.lf index b996fe6ac5..60af8480c7 100644 --- a/test/C/src/lib/LoopedActionSender.lf +++ b/test/C/src/lib/LoopedActionSender.lf @@ -6,10 +6,9 @@ target C /** - * @param take_a_break_after: Indicates how many messages are sent in - * consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break - * after sending take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break after sending + * take_a_break_after messages. */ reactor Sender(take_a_break_after: int = 10, break_interval: time = 400 msec) { output out: int diff --git a/test/C/src/lib/TestCount.lf b/test/C/src/lib/TestCount.lf index d3f29aec6c..e5cb1d601d 100644 --- a/test/C/src/lib/TestCount.lf +++ b/test/C/src/lib/TestCount.lf @@ -1,7 +1,6 @@ /** - * Test that a counting sequence of inputs starts with the specified start - * parameter value, increments by the specified stride, and receives the - * specified number of inputs. + * Test that a counting sequence of inputs starts with the specified start parameter value, + * increments by the specified stride, and receives the specified number of inputs. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. diff --git a/test/C/src/modal_models/BanksModalStateReset.lf b/test/C/src/modal_models/BanksModalStateReset.lf index 8e075715c8..95abf317fd 100644 --- a/test/C/src/modal_models/BanksModalStateReset.lf +++ b/test/C/src/modal_models/BanksModalStateReset.lf @@ -1,7 +1,4 @@ -/** - * Modal Reactor Test. Tests reset of state variables in modes with banks of - * reactors. - */ +/** Modal Reactor Test. Tests reset of state variables in modes with banks of reactors. */ target C { fast: false, timeout: 4 sec @@ -48,8 +45,7 @@ main reactor { reset2.count2 -> test.events - // Trigger mode change (separately because of #1278) - reaction(stepper) -> reset1.next {= + reaction(stepper) -> reset1.next {= // Trigger mode change (separately because of #1278) for(int i = 0; i < reset1_width; i++) { lf_set(reset1[i].next, true); } diff --git a/test/C/src/modal_models/Count3Modes.lf b/test/C/src/modal_models/Count3Modes.lf index 862915abed..6f597053e0 100644 --- a/test/C/src/modal_models/Count3Modes.lf +++ b/test/C/src/modal_models/Count3Modes.lf @@ -36,11 +36,9 @@ main reactor { state expected_value: int = 1 - // Trigger - reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} + reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} // Trigger - // Check - reaction(stepper) counter.count {= + reaction(stepper) counter.count {= // Check printf("%d\n", counter.count->value); if (!counter.count->is_present) { diff --git a/test/C/src/modal_models/MixedReactions.lf b/test/C/src/modal_models/MixedReactions.lf index 78ea39c95c..54d97fe156 100644 --- a/test/C/src/modal_models/MixedReactions.lf +++ b/test/C/src/modal_models/MixedReactions.lf @@ -1,6 +1,6 @@ /** - * Modal Reactor Test. Tests reactions that are defined between and after modes - * and should be ordered accordingly. + * Modal Reactor Test. Tests reactions that are defined between and after modes and should be + * ordered accordingly. */ target C { fast: true, diff --git a/test/C/src/modal_models/ModalNestedReactions.lf b/test/C/src/modal_models/ModalNestedReactions.lf index 454acbfc75..dcc61ae9c6 100644 --- a/test/C/src/modal_models/ModalNestedReactions.lf +++ b/test/C/src/modal_models/ModalNestedReactions.lf @@ -1,7 +1,4 @@ -/** - * Modal Reactor Test. Checks disabling of reactions indirectly nested in an - * inactive mode - */ +/** Modal Reactor Test. Checks disabling of reactions indirectly nested in an inactive mode */ target C { fast: false, timeout: 2 sec @@ -47,11 +44,9 @@ main reactor { timer stepper(0, 250 msec) counter = new CounterCycle() - // Trigger - reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} + reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} // Trigger - // Check - reaction(stepper) counter.count, counter.only_in_two {= + reaction(stepper) counter.count, counter.only_in_two {= // Check printf("%d\n", counter.count->value); if (!counter.count->is_present) { diff --git a/test/C/src/multiport/BankMulticast.lf b/test/C/src/multiport/BankMulticast.lf index cb6c5dfe38..35b4124c73 100644 --- a/test/C/src/multiport/BankMulticast.lf +++ b/test/C/src/multiport/BankMulticast.lf @@ -1,6 +1,6 @@ /** - * This tests that a contained bank can send not only to a local connection, but - * also multicast via the container's output port. + * This tests that a contained bank can send not only to a local connection, but also multicast via + * the container's output port. */ target C { timeout: 3 sec, diff --git a/test/C/src/multiport/BankReactionsInContainer.lf b/test/C/src/multiport/BankReactionsInContainer.lf index 98d7cf4e1f..1e93ed7478 100644 --- a/test/C/src/multiport/BankReactionsInContainer.lf +++ b/test/C/src/multiport/BankReactionsInContainer.lf @@ -1,6 +1,4 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target C { timeout: 1 sec } diff --git a/test/C/src/multiport/BankSelfBroadcast.lf b/test/C/src/multiport/BankSelfBroadcast.lf index e1ffb4b2dd..a242a246cc 100644 --- a/test/C/src/multiport/BankSelfBroadcast.lf +++ b/test/C/src/multiport/BankSelfBroadcast.lf @@ -1,7 +1,7 @@ /** - * Test a bank of reactors that broadcast a single output back to a multiport - * input of the same reactors in the bank so that each reactor in the bank - * receives the output produced by itself and each other reactor. + * Test a bank of reactors that broadcast a single output back to a multiport input of the same + * reactors in the bank so that each reactor in the bank receives the output produced by itself and + * each other reactor. * * @author Edward A. Lee */ diff --git a/test/C/src/multiport/MultiportFromBank.lf b/test/C/src/multiport/MultiportFromBank.lf index 1b49786060..3554380d8a 100644 --- a/test/C/src/multiport/MultiportFromBank.lf +++ b/test/C/src/multiport/MultiportFromBank.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target C { timeout: 2 sec, fast: true @@ -8,9 +8,7 @@ target C { reactor Source(check_override: int = 0, bank_index: int = 0) { output out: int - reaction(startup) -> out {= - lf_set(out, self->bank_index * self->check_override); - =} + reaction(startup) -> out {= lf_set(out, self->bank_index * self->check_override); =} } reactor Destination(port_width: int = 3) { diff --git a/test/C/src/multiport/MultiportFromBankHierarchy.lf b/test/C/src/multiport/MultiportFromBankHierarchy.lf index e8ee6194b5..295032cb8d 100644 --- a/test/C/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/C/src/multiport/MultiportFromBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/C/src/multiport/MultiportFromBankHierarchyAfter.lf index af657cf0b1..c67fea9b45 100644 --- a/test/C/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/C/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportFromHierarchy.lf b/test/C/src/multiport/MultiportFromHierarchy.lf index 8323210946..0f606e4750 100644 --- a/test/C/src/multiport/MultiportFromHierarchy.lf +++ b/test/C/src/multiport/MultiportFromHierarchy.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input, where the former is a hierarchical -// reactor. +// Check multiport output to multiport input, where the former is a hierarchical reactor. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportIn.lf b/test/C/src/multiport/MultiportIn.lf index b87a91a79b..e62d32b0c6 100644 --- a/test/C/src/multiport/MultiportIn.lf +++ b/test/C/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -// This is a version fo the Threaded test that uses a multiport input at the -// destination. Its purpose is to test multiport inputs. +// This is a version fo the Threaded test that uses a multiport input at the destination. Its +// purpose is to test multiport inputs. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportInParameterized.lf b/test/C/src/multiport/MultiportInParameterized.lf index bf7ec93f6e..fa8b64855c 100644 --- a/test/C/src/multiport/MultiportInParameterized.lf +++ b/test/C/src/multiport/MultiportInParameterized.lf @@ -1,5 +1,5 @@ -// This is a version of the Threaded test that uses a multiport input at the -// destination. Its purpose is to test multiport inputs. +// This is a version of the Threaded test that uses a multiport input at the destination. Its +// purpose is to test multiport inputs. target C { timeout: 2 sec, fast: true @@ -60,7 +60,6 @@ main reactor { a.out -> t2.in a.out -> t3.in a.out -> t4.in - // I.e.: t1.out -> b.in[0]; t2.out -> b.in[1]; t3.out -> b.in[2]; dt4.out -> - // b.in[3]; + // I.e.: t1.out -> b.in[0]; t2.out -> b.in[1]; t3.out -> b.in[2]; dt4.out -> b.in[3]; t1.out, t2.out, t3.out, t4.out -> b.in } diff --git a/test/C/src/multiport/MultiportMutableInput.lf b/test/C/src/multiport/MultiportMutableInput.lf index e1f8d579c2..e5c398def4 100644 --- a/test/C/src/multiport/MultiportMutableInput.lf +++ b/test/C/src/multiport/MultiportMutableInput.lf @@ -1,6 +1,5 @@ -// Source produces a ints on a multiport, which it passes to Scale. Scale -// requests a writable copy. It modifies it and passes it to Print. It gets -// freed after Print is done with it. +// Source produces a ints on a multiport, which it passes to Scale. Scale requests a writable copy. +// It modifies it and passes it to Print. It gets freed after Print is done with it. target C reactor Source { diff --git a/test/C/src/multiport/MultiportMutableInputArray.lf b/test/C/src/multiport/MultiportMutableInputArray.lf index 90907e4f44..d27f97f93c 100644 --- a/test/C/src/multiport/MultiportMutableInputArray.lf +++ b/test/C/src/multiport/MultiportMutableInputArray.lf @@ -1,7 +1,6 @@ -// Source produces a dynamically allocated arrays on a multiport, which it -// passes to Scale. Scale requests a writable copy, which, instead of copying, -// it just gets ownership of the original array. It modifies it and passes it to -// Print. It gets freed after Print is done with it. +// Source produces a dynamically allocated arrays on a multiport, which it passes to Scale. Scale +// requests a writable copy, which, instead of copying, it just gets ownership of the original +// array. It modifies it and passes it to Print. It gets freed after Print is done with it. target C reactor Source { diff --git a/test/C/src/multiport/MultiportToBank.lf b/test/C/src/multiport/MultiportToBank.lf index 86146b9818..b4ef84e9dc 100644 --- a/test/C/src/multiport/MultiportToBank.lf +++ b/test/C/src/multiport/MultiportToBank.lf @@ -14,10 +14,9 @@ reactor Source(width: int = 2) { } =} - // Test also that multiple appearances of the same effect port do not result - // in multiple allocations of memory for the port. - reaction(dummy) -> - out {= // Contents of the reactions does not matter (either could be empty) + // Test also that multiple appearances of the same effect port do not result in multiple + // allocations of memory for the port. + reaction(dummy) -> out {= // Contents of the reactions does not matter (either could be empty) for(int i = 0; i < out_width; i++) { lf_set(out[i], i); } diff --git a/test/C/src/multiport/MultiportToBankAfter.lf b/test/C/src/multiport/MultiportToBankAfter.lf index ba26142243..9ad4b04d71 100644 --- a/test/C/src/multiport/MultiportToBankAfter.lf +++ b/test/C/src/multiport/MultiportToBankAfter.lf @@ -1,5 +1,4 @@ -// Check multiport output to bank of recipients where the width of the bank is -// inferred. +// Check multiport output to bank of recipients where the width of the bank is inferred. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportToBankDouble.lf b/test/C/src/multiport/MultiportToBankDouble.lf index 444f02d170..5cf16f77a0 100644 --- a/test/C/src/multiport/MultiportToBankDouble.lf +++ b/test/C/src/multiport/MultiportToBankDouble.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients where the source has two -// reactions that write to the output. +// Check multiport output to bank of recipients where the source has two reactions that write to the +// output. target C { timeout: 2 sec, fast: true @@ -14,8 +14,8 @@ reactor Source { } =} - // Test also that multiple appearances of the same effect port do not result - // in multiple allocations of memory for the port. + // Test also that multiple appearances of the same effect port do not result in multiple + // allocations of memory for the port. reaction(startup) -> out {= // Contents of the reactions does not matter (either could be empty) for(int i = 0; i < out_width; i++) { diff --git a/test/C/src/multiport/MultiportToBankHierarchy.lf b/test/C/src/multiport/MultiportToBankHierarchy.lf index fbdc531bf0..93acb2081d 100644 --- a/test/C/src/multiport/MultiportToBankHierarchy.lf +++ b/test/C/src/multiport/MultiportToBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportToHierarchy.lf b/test/C/src/multiport/MultiportToHierarchy.lf index 41ca505077..bde5ee1169 100644 --- a/test/C/src/multiport/MultiportToHierarchy.lf +++ b/test/C/src/multiport/MultiportToHierarchy.lf @@ -1,6 +1,5 @@ -// Check multiport output to multiport input, where the latter is a hierarchical -// reactor. Note that the destination reactor has width wider than the sender, -// so one input is dangling. +// Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that +// the destination reactor has width wider than the sender, so one input is dangling. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportToMultiportArray.lf b/test/C/src/multiport/MultiportToMultiportArray.lf index 9d86a4a522..5cfac7368d 100644 --- a/test/C/src/multiport/MultiportToMultiportArray.lf +++ b/test/C/src/multiport/MultiportToMultiportArray.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportToPort.lf b/test/C/src/multiport/MultiportToPort.lf index 1784f2503c..a89c162e12 100644 --- a/test/C/src/multiport/MultiportToPort.lf +++ b/test/C/src/multiport/MultiportToPort.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/ReactionToContainedBankMultiport.lf b/test/C/src/multiport/ReactionToContainedBankMultiport.lf index d84b21c191..458d963bb9 100644 --- a/test/C/src/multiport/ReactionToContainedBankMultiport.lf +++ b/test/C/src/multiport/ReactionToContainedBankMultiport.lf @@ -1,5 +1,4 @@ -// Test reaction sending messages to a contained bank of reactors with a -// multiport input. +// Test reaction sending messages to a contained bank of reactors with a multiport input. target C { timeout: 1 sec, fast: true diff --git a/test/C/src/multiport/ReactionsToNested.lf b/test/C/src/multiport/ReactionsToNested.lf index 4270f55c2d..db8c1da63d 100644 --- a/test/C/src/multiport/ReactionsToNested.lf +++ b/test/C/src/multiport/ReactionsToNested.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { timeout: 1 sec } diff --git a/test/C/src/multiport/SparseFallback.lf b/test/C/src/multiport/SparseFallback.lf index a7788858d8..1326f9ca99 100644 --- a/test/C/src/multiport/SparseFallback.lf +++ b/test/C/src/multiport/SparseFallback.lf @@ -1,6 +1,6 @@ /** - * Test reading of sparse inputs on a multiport where the density of writes to - * the multiport is high enough to force the fallback policy to kick in. + * Test reading of sparse inputs on a multiport where the density of writes to the multiport is high + * enough to force the fallback policy to kick in. */ target C { timeout: 20 ms diff --git a/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf b/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf index 917982af39..d4a37bbaee 100644 --- a/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf +++ b/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf @@ -1,7 +1,4 @@ -/** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. - */ +/** This test checks that a downstream reaction is triggered only if its trigger is present. */ target C { timeout: 1 sec, fast: true diff --git a/test/C/src/serialization/PersonProtocolBuffers.lf b/test/C/src/serialization/PersonProtocolBuffers.lf index a01243d846..f2572fc72f 100644 --- a/test/C/src/serialization/PersonProtocolBuffers.lf +++ b/test/C/src/serialization/PersonProtocolBuffers.lf @@ -1,23 +1,21 @@ /** - * This example demonstrates a very simple use of protocol buffers within a - * reactor. It encodes and decodes a very simple protocol buffer definition in - * Person.proto. This reactor is heavily based on the examples at - * https://github.com/protobuf-c/protobuf-c/wiki/Examples. This example just + * This example demonstrates a very simple use of protocol buffers within a reactor. It encodes and + * decodes a very simple protocol buffer definition in Person.proto. This reactor is heavily based + * on the examples at https://github.com/protobuf-c/protobuf-c/wiki/Examples. This example just * packs and unpacks a message. * * To run this example first install the protocol buffers compiler from - * https://github.com/protocolbuffers/protobuf. It is also available from - * homebrew on a Mac via + * https://github.com/protocolbuffers/protobuf. It is also available from homebrew on a Mac via * * $ brew install protobuf * - * Building protobuf from source is slow, so avoid doing that if possible. Next - * install the C plugin for protocol buffers from + * Building protobuf from source is slow, so avoid doing that if possible. Next install the C plugin + * for protocol buffers from * * https://github.com/protobuf-c/protobuf-c * - * The code generator assumes that executables are installed within the PATH. On - * a Mac, this is typically at /usr/local/bin. + * The code generator assumes that executables are installed within the PATH. On a Mac, this is + * typically at /usr/local/bin. */ target C { protobufs: Person.proto diff --git a/test/C/src/serialization/ProtoNoPacking.lf b/test/C/src/serialization/ProtoNoPacking.lf index 283e4feafb..91464570fc 100644 --- a/test/C/src/serialization/ProtoNoPacking.lf +++ b/test/C/src/serialization/ProtoNoPacking.lf @@ -1,22 +1,20 @@ /** - * This example creates a Protocol Buffer message and passes it to another - * reactor without packing and unpacking. This demonstrates that local - * communication, within one shared-memory machine, need not incur the overhead - * of packing and unpacking. + * This example creates a Protocol Buffer message and passes it to another reactor without packing + * and unpacking. This demonstrates that local communication, within one shared-memory machine, need + * not incur the overhead of packing and unpacking. * * To run this example first install the protocol buffers compiler from - * https://github.com/protocolbuffers/protobuf. It is also available from - * homebrew on a Mac via + * https://github.com/protocolbuffers/protobuf. It is also available from homebrew on a Mac via * * $ brew install protobuf * - * Building protobuf from source is slow, so avoid doing that if possible. Next - * install the C plugin for protocol buffers from + * Building protobuf from source is slow, so avoid doing that if possible. Next install the C plugin + * for protocol buffers from * * https://github.com/protobuf-c/protobuf-c * - * The code generator assumes that executables are installed within the PATH. On - * a Mac, this is typically at /usr/local/bin. + * The code generator assumes that executables are installed within the PATH. On a Mac, this is + * typically at /usr/local/bin. */ target C { protobufs: [ProtoHelloWorld.proto] diff --git a/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf b/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf index 97b5a12554..dc5902885e 100644 --- a/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf +++ b/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf @@ -1,13 +1,12 @@ /** - * This test showcases the infrastructure that is built into the CCpp target - * that can automatically serialize and deserialize ROS2 messages (with a - * shared_ptr type) in federated programs. + * This test showcases the infrastructure that is built into the CCpp target that can automatically + * serialize and deserialize ROS2 messages (with a shared_ptr type) in federated programs. * - * This test contains a sender-receiver federated program in which the 'sender' - * federate sends a std_msgs::msg::Int32 message to the 'receiver' federate. + * This test contains a sender-receiver federated program in which the 'sender' federate sends a + * std_msgs::msg::Int32 message to the 'receiver' federate. * - * To run this test, make sure that your terminal is properly sourced for ROS2. - * See https://docs.ros.org/en/foxy/Tutorials/Configuring-ROS2-Environment.html. + * To run this test, make sure that your terminal is properly sourced for ROS2. See + * https://docs.ros.org/en/foxy/Tutorials/Configuring-ROS2-Environment.html. * * Then you can use lfc to compile this program: * diff --git a/test/C/src/target/CMakeInclude.lf b/test/C/src/target/CMakeInclude.lf index 411f07ee0f..6b9d3b2ecc 100644 --- a/test/C/src/target/CMakeInclude.lf +++ b/test/C/src/target/CMakeInclude.lf @@ -1,6 +1,5 @@ /** - * Test that cmake-include is working correctly. The failure for this test is - * failure to compile. + * Test that cmake-include is working correctly. The failure for this test is failure to compile. */ target C { cmake-include: [ diff --git a/test/C/src/target/DistributedCMakeInclude.lf b/test/C/src/target/DistributedCMakeInclude.lf index da02652ebf..486dafa608 100644 --- a/test/C/src/target/DistributedCMakeInclude.lf +++ b/test/C/src/target/DistributedCMakeInclude.lf @@ -1,7 +1,6 @@ /** - * Test that cmake-include in a federated program works correctly. Both - * federates should see FOO = 3.14. The failure for this test is failure to - * compile. + * Test that cmake-include in a federated program works correctly. Both federates should see FOO = + * 3.14. The failure for this test is failure to compile. */ target C { timeout: 0 sec, diff --git a/test/C/src/target/DistributedCMakeIncludeSeparateCompile.lf b/test/C/src/target/DistributedCMakeIncludeSeparateCompile.lf index c23e57972a..f1cf671c03 100644 --- a/test/C/src/target/DistributedCMakeIncludeSeparateCompile.lf +++ b/test/C/src/target/DistributedCMakeIncludeSeparateCompile.lf @@ -1,7 +1,7 @@ /** - * Test that cmake-include in an included file is being imported correctly, and - * that the imported cmake-includes are applied separately for each federate. - * The failure for this test is failure to compile. + * Test that cmake-include in an included file is being imported correctly, and that the imported + * cmake-includes are applied separately for each federate. The failure for this test is failure to + * compile. */ target C { timeout: 0 sec diff --git a/test/C/src/target/HelloWorldCCPP.lf b/test/C/src/target/HelloWorldCCPP.lf index 91d1cd61d1..917ca4308a 100644 --- a/test/C/src/target/HelloWorldCCPP.lf +++ b/test/C/src/target/HelloWorldCCPP.lf @@ -1,6 +1,6 @@ /** - * A variant of HelloWorld.lf that tests the CCpp target in conjunction with the - * CMake build system. This test should not pass if it does not compile. + * A variant of HelloWorld.lf that tests the CCpp target in conjunction with the CMake build system. + * This test should not pass if it does not compile. */ target CCpp { tracing: true, diff --git a/test/C/src/target/HelloWorldFederatedCCPP.lf b/test/C/src/target/HelloWorldFederatedCCPP.lf index 1ffa1a68b2..54c285c700 100644 --- a/test/C/src/target/HelloWorldFederatedCCPP.lf +++ b/test/C/src/target/HelloWorldFederatedCCPP.lf @@ -1,6 +1,6 @@ /** - * A variant of HelloWorld.lf that tests the federated runtime with the CCpp - * target. This test should not pass if it does not compile. + * A variant of HelloWorld.lf that tests the federated runtime with the CCpp target. This test + * should not pass if it does not compile. */ target CCpp { tracing: true, diff --git a/test/C/src/target/HelloWorldThreadedCPP.lf b/test/C/src/target/HelloWorldThreadedCPP.lf index 44bc439683..259ea9d320 100644 --- a/test/C/src/target/HelloWorldThreadedCPP.lf +++ b/test/C/src/target/HelloWorldThreadedCPP.lf @@ -1,6 +1,6 @@ /** - * A variant of HelloWorld.lf that tests the threaded CCpp target. This test - * should not pass if it does not compile. + * A variant of HelloWorld.lf that tests the threaded CCpp target. This test should not pass if it + * does not compile. */ target CCpp { tracing: true, diff --git a/test/Cpp/src/ActionWithNoReaction.lf b/test/Cpp/src/ActionWithNoReaction.lf index c43e567d3c..f4c0fa8a01 100644 --- a/test/Cpp/src/ActionWithNoReaction.lf +++ b/test/Cpp/src/ActionWithNoReaction.lf @@ -1,6 +1,5 @@ -// This checks that action can be created even if there is no reaction. This -// test passes merely by compiling and executing without a segfault. Its other -// functionality is tested by other tests. +// This checks that action can be created even if there is no reaction. This test passes merely by +// compiling and executing without a segfault. Its other functionality is tested by other tests. target Cpp { fast: true, timeout: 3 sec diff --git a/test/Cpp/src/After.lf b/test/Cpp/src/After.lf index bbcc287b78..40f9e3a54b 100644 --- a/test/Cpp/src/After.lf +++ b/test/Cpp/src/After.lf @@ -1,5 +1,4 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target Cpp { fast: false, timeout: 3 sec diff --git a/test/Cpp/src/AfterZero.lf b/test/Cpp/src/AfterZero.lf index 152b87cfc2..59ba9b4fb3 100644 --- a/test/Cpp/src/AfterZero.lf +++ b/test/Cpp/src/AfterZero.lf @@ -1,5 +1,4 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target Cpp { fast: false, timeout: 3 sec diff --git a/test/Cpp/src/Alignment.lf b/test/Cpp/src/Alignment.lf index 1bd3562f41..0ab486903c 100644 --- a/test/Cpp/src/Alignment.lf +++ b/test/Cpp/src/Alignment.lf @@ -1,5 +1,4 @@ -// This test checks that the downstream reaction is not invoked more than once -// at a logical time. +// This test checks that the downstream reaction is not invoked more than once at a logical time. target Cpp { logging: LOG, timeout: 1 sec, diff --git a/test/Cpp/src/ArrayAsParameter.lf b/test/Cpp/src/ArrayAsParameter.lf index 85cd0630bf..e36a63a201 100644 --- a/test/Cpp/src/ArrayAsParameter.lf +++ b/test/Cpp/src/ArrayAsParameter.lf @@ -1,5 +1,4 @@ -// Source has an variable sized list as a parameter, the elements of which it -// passes to Print. +// Source has an variable sized list as a parameter, the elements of which it passes to Print. target Cpp reactor Source(sequence: std::vector = {0, 1, 2}) { diff --git a/test/Cpp/src/ArrayAsType.lf b/test/Cpp/src/ArrayAsType.lf index 9a61e0e439..d678fc1d0b 100644 --- a/test/Cpp/src/ArrayAsType.lf +++ b/test/Cpp/src/ArrayAsType.lf @@ -1,5 +1,5 @@ -// Source produces a statically allocated array, which it passes to Print. The -// destination references the array directly. +// Source produces a statically allocated array, which it passes to Print. The destination +// references the array directly. target Cpp reactor Source { diff --git a/test/Cpp/src/ArrayParallel.lf b/test/Cpp/src/ArrayParallel.lf index 9e5e356a9d..c8272b64a2 100644 --- a/test/Cpp/src/ArrayParallel.lf +++ b/test/Cpp/src/ArrayParallel.lf @@ -1,6 +1,6 @@ -// Source allocates an array dynamically and then sends it to two reactors, each -// of which want to modify it. NOTE: Ideally, only one copy would be made, but -// this is not supported yet by the C++ runtime. +// Source allocates an array dynamically and then sends it to two reactors, each of which want to +// modify it. NOTE: Ideally, only one copy would be made, but this is not supported yet by the C++ +// runtime. target Cpp import Scale from "ArrayScale.lf" diff --git a/test/Cpp/src/ArrayPrint.lf b/test/Cpp/src/ArrayPrint.lf index 3bdf494107..59395d37d7 100644 --- a/test/Cpp/src/ArrayPrint.lf +++ b/test/Cpp/src/ArrayPrint.lf @@ -1,6 +1,5 @@ -// Source produces a dynamically allocated array, which it passes to Print. The -// ownership semantics of values ensure that the array is automatically deleted -// if it does have no owner. +// Source produces a dynamically allocated array, which it passes to Print. The ownership semantics +// of values ensure that the array is automatically deleted if it does have no owner. target Cpp reactor Source { diff --git a/test/Cpp/src/ArrayScale.lf b/test/Cpp/src/ArrayScale.lf index b52e7305b7..44db608e92 100644 --- a/test/Cpp/src/ArrayScale.lf +++ b/test/Cpp/src/ArrayScale.lf @@ -1,6 +1,5 @@ -// Source produces a dynamically allocated array, which it passes to Scale. -// Scale requests a writable copy. It modifies it and passes it to Print. It -// gets freed after Print is done with it. +// Source produces a dynamically allocated array, which it passes to Scale. Scale requests a +// writable copy. It modifies it and passes it to Print. It gets freed after Print is done with it. target Cpp import Source, Print from "ArrayPrint.lf" diff --git a/test/Cpp/src/Composition.lf b/test/Cpp/src/Composition.lf index 0a341d5e4f..4c5baeb870 100644 --- a/test/Cpp/src/Composition.lf +++ b/test/Cpp/src/Composition.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target Cpp { fast: true, timeout: 10 sec diff --git a/test/Cpp/src/CompositionAfter.lf b/test/Cpp/src/CompositionAfter.lf index 15d68e13ea..ea1b27fd5e 100644 --- a/test/Cpp/src/CompositionAfter.lf +++ b/test/Cpp/src/CompositionAfter.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target Cpp { fast: true, timeout: 10 sec diff --git a/test/Cpp/src/DanglingOutput.lf b/test/Cpp/src/DanglingOutput.lf index 1c8a45531a..499fa0e504 100644 --- a/test/Cpp/src/DanglingOutput.lf +++ b/test/Cpp/src/DanglingOutput.lf @@ -1,5 +1,5 @@ -// This tests that an output that is not connected to anything does not result -// in a compilation error. Passing the test is just compiling and running. +// This tests that an output that is not connected to anything does not result in a compilation +// error. Passing the test is just compiling and running. target Cpp reactor Source { diff --git a/test/Cpp/src/Deadline.lf b/test/Cpp/src/Deadline.lf index 19a41ff057..5a6448195d 100644 --- a/test/Cpp/src/Deadline.lf +++ b/test/Cpp/src/Deadline.lf @@ -1,6 +1,5 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target Cpp { timeout: 4 sec } diff --git a/test/Cpp/src/DeadlineHandledAbove.lf b/test/Cpp/src/DeadlineHandledAbove.lf index b2a6c7658a..e39ae3db09 100644 --- a/test/Cpp/src/DeadlineHandledAbove.lf +++ b/test/Cpp/src/DeadlineHandledAbove.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target Cpp reactor Deadline(threshold: time = 100 msec) { diff --git a/test/Cpp/src/DoubleInvocation.lf b/test/Cpp/src/DoubleInvocation.lf index 956b54bb17..236b0f425d 100644 --- a/test/Cpp/src/DoubleInvocation.lf +++ b/test/Cpp/src/DoubleInvocation.lf @@ -1,11 +1,9 @@ -// This illustrates a very strange bug that showed up and has now been fixed. -// This test ensures it does not reappear. At logical time zero, the two Print -// reactors used to be fired twice each at the same logical time. They should -// only be fired once. This behavior was oddly eliminated by either of the -// following actions, neither of which should affect this behavior: +// This illustrates a very strange bug that showed up and has now been fixed. This test ensures it +// does not reappear. At logical time zero, the two Print reactors used to be fired twice each at +// the same logical time. They should only be fired once. This behavior was oddly eliminated by +// either of the following actions, neither of which should affect this behavior: // * Removing the startup reaction in Print. -// * Sending only position, not velocity from Ball. (copied from the c version -// of the test) +// * Sending only position, not velocity from Ball. (copied from the c version of the test) target Cpp { timeout: 5 sec, fast: true diff --git a/test/Cpp/src/DoublePort.lf b/test/Cpp/src/DoublePort.lf index faaa474db5..b28f70db4d 100644 --- a/test/Cpp/src/DoublePort.lf +++ b/test/Cpp/src/DoublePort.lf @@ -1,7 +1,6 @@ /** - * Test the case where two upstream reactors pass messages to a downstream - * reactor on two different ports. One message carries a microstep delay - * relative to the other. + * Test the case where two upstream reactors pass messages to a downstream reactor on two different + * ports. One message carries a microstep delay relative to the other. * * @author Maiko Brants */ diff --git a/test/Cpp/src/DoubleReaction.lf b/test/Cpp/src/DoubleReaction.lf index 1128d63f97..3642fa027a 100644 --- a/test/Cpp/src/DoubleReaction.lf +++ b/test/Cpp/src/DoubleReaction.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target Cpp { timeout: 10 sec, fast: true diff --git a/test/Cpp/src/DoubleTrigger.lf b/test/Cpp/src/DoubleTrigger.lf index 5db4818048..b39f0a559e 100644 --- a/test/Cpp/src/DoubleTrigger.lf +++ b/test/Cpp/src/DoubleTrigger.lf @@ -1,5 +1,4 @@ -// Test that two simultaneous triggers don't cause a reaction to execute twice -// at the same tag. +// Test that two simultaneous triggers don't cause a reaction to execute twice at the same tag. target Cpp main reactor DoubleTrigger { diff --git a/test/Cpp/src/GetTime.lf b/test/Cpp/src/GetTime.lf index 5437fc78dd..e9ba6922d5 100644 --- a/test/Cpp/src/GetTime.lf +++ b/test/Cpp/src/GetTime.lf @@ -1,5 +1,5 @@ -// This file includes code documented on the Wiki. For this test, success is -// just compiling and running. +// This file includes code documented on the Wiki. For this test, success is just compiling and +// running. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/Import.lf b/test/Cpp/src/Import.lf index a7434a2b4d..020877a883 100644 --- a/test/Cpp/src/Import.lf +++ b/test/Cpp/src/Import.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target Cpp import Imported from "lib/Imported.lf" diff --git a/test/Cpp/src/ImportComposition.lf b/test/Cpp/src/ImportComposition.lf index 0559edacd1..492b77d96d 100644 --- a/test/Cpp/src/ImportComposition.lf +++ b/test/Cpp/src/ImportComposition.lf @@ -1,8 +1,7 @@ /** * @author Maiko Brants TU Dresden * - * This tests the ability to import a reactor definition that itself imports a - * reactor definition. + * This tests the ability to import a reactor definition that itself imports a reactor definition. * * modeled after the C version of this test */ diff --git a/test/Cpp/src/ImportRenamed.lf b/test/Cpp/src/ImportRenamed.lf index e7338e6346..ea21c06964 100644 --- a/test/Cpp/src/ImportRenamed.lf +++ b/test/Cpp/src/ImportRenamed.lf @@ -1,8 +1,7 @@ /** * @author Maiko Brants TU Dresden * - * This tests the ability to import a reactor definition that itself imports a - * reactor definition. + * This tests the ability to import a reactor definition that itself imports a reactor definition. * * modeled after the C version of this test */ diff --git a/test/Cpp/src/ManualDelayedReaction.lf b/test/Cpp/src/ManualDelayedReaction.lf index 3c55bdcaf1..e17d4eac13 100644 --- a/test/Cpp/src/ManualDelayedReaction.lf +++ b/test/Cpp/src/ManualDelayedReaction.lf @@ -1,7 +1,6 @@ target Cpp -// That's the stuff that shall be generated for the after -reactor GeneratedDelay { +reactor GeneratedDelay { // That's the stuff that shall be generated for the after input y_in: int output y_out: int state y_state: int = 0 @@ -17,8 +16,7 @@ reactor Source { output out: int timer t - // reaction(t) -> out after 100 msec {= - reaction(t) -> out {= out.set(1); =} + reaction(t) -> out {= out.set(1); =} // reaction(t) -> out after 100 msec {= } reactor Sink { diff --git a/test/Cpp/src/MovingAverage.lf b/test/Cpp/src/MovingAverage.lf index af202ca0a0..2ccaa87406 100644 --- a/test/Cpp/src/MovingAverage.lf +++ b/test/Cpp/src/MovingAverage.lf @@ -1,6 +1,6 @@ -// Demonstration of a state variable that is a fixed size list. The -// MovingAverage reactor computes the moving average of the last four inputs and -// produces that as output. The source is a counting sequence. +// Demonstration of a state variable that is a fixed size list. The MovingAverage reactor computes +// the moving average of the last four inputs and produces that as output. The source is a counting +// sequence. target Cpp { timeout: 1 sec, fast: true diff --git a/test/Cpp/src/MultipleContained.lf b/test/Cpp/src/MultipleContained.lf index e6db9eb7be..8831bb3d6d 100644 --- a/test/Cpp/src/MultipleContained.lf +++ b/test/Cpp/src/MultipleContained.lf @@ -1,5 +1,4 @@ -// Test that a reaction can react to and send two multiple ports of a contained -// reactor. +// Test that a reaction can react to and send two multiple ports of a contained reactor. target Cpp reactor Contained { diff --git a/test/Cpp/src/PreambleTest.lf b/test/Cpp/src/PreambleTest.lf index 6e056639fa..66b479397d 100644 --- a/test/Cpp/src/PreambleTest.lf +++ b/test/Cpp/src/PreambleTest.lf @@ -1,20 +1,18 @@ target Cpp main reactor { - // This declaration is required on the public reactor interface and - // therefore needs to be placed in the generated header. This goes to - // Preamble/Preamble.hh. + // This declaration is required on the public reactor interface and therefore needs to be placed + // in the generated header. This goes to Preamble/Preamble.hh. public preamble {= struct MyStruct { int foo; std::string bar; }; =} - // this is only used inside reactions and therefore goes to the generated - // source file This function is only used inside a reaction and therefore is - // part of the private interface. Moreover, we need to make sure that the - // function is only defined once within a source file. This goes to - // Preamble/Preamble.cc + // this is only used inside reactions and therefore goes to the generated source file This + // function is only used inside a reaction and therefore is part of the private interface. + // Moreover, we need to make sure that the function is only defined once within a source file. + // This goes to Preamble/Preamble.cc private preamble {= int add_42(int i) { return i + 42; diff --git a/test/Cpp/src/ReadOutputOfContainedReactor.lf b/test/Cpp/src/ReadOutputOfContainedReactor.lf index c7e85083b4..7d16b24cb7 100644 --- a/test/Cpp/src/ReadOutputOfContainedReactor.lf +++ b/test/Cpp/src/ReadOutputOfContainedReactor.lf @@ -1,5 +1,4 @@ -// Test reacting to and reading outputs from a contained reactor in various -// permutations. +// Test reacting to and reading outputs from a contained reactor in various permutations. target Cpp reactor Contained { diff --git a/test/Cpp/src/ScheduleLogicalAction.lf b/test/Cpp/src/ScheduleLogicalAction.lf index 96fd5382b7..2e2f9f99f5 100644 --- a/test/Cpp/src/ScheduleLogicalAction.lf +++ b/test/Cpp/src/ScheduleLogicalAction.lf @@ -1,8 +1,8 @@ /** * @author Maiko Brants TU Dresden * - * This checks that a logical action is scheduled the specified logical time - * after the current logical time. + * This checks that a logical action is scheduled the specified logical time after the current + * logical time. * * Modeled after the C version of this test. */ diff --git a/test/Cpp/src/SendingInside.lf b/test/Cpp/src/SendingInside.lf index 2f73122bc8..4b04d48bc7 100644 --- a/test/Cpp/src/SendingInside.lf +++ b/test/Cpp/src/SendingInside.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target Cpp { timeout: 10 sec, fast: true diff --git a/test/Cpp/src/SimpleDeadline.lf b/test/Cpp/src/SimpleDeadline.lf index be10b55d43..c14ba2adea 100644 --- a/test/Cpp/src/SimpleDeadline.lf +++ b/test/Cpp/src/SimpleDeadline.lf @@ -1,6 +1,5 @@ -// Test local deadline, where a deadline is associated with a reaction -// definition. This test triggers a reaction exactly once with a deadline -// violation. +// Test local deadline, where a deadline is associated with a reaction definition. This test +// triggers a reaction exactly once with a deadline violation. target Cpp reactor Deadline(threshold: time = 100 msec) { diff --git a/test/Cpp/src/SlowingClock.lf b/test/Cpp/src/SlowingClock.lf index adbe93e418..13228f17a1 100644 --- a/test/Cpp/src/SlowingClock.lf +++ b/test/Cpp/src/SlowingClock.lf @@ -1,10 +1,9 @@ /** * @author Maiko Brants TU Dresden * - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 - * msec on a logical action with a minimum delay of 100 msec. The use of the - * logical action ensures the elapsed time jumps exactly from 0 to 100, 300, - * 600, and 1000 msec. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a logical + * action with a minimum delay of 100 msec. The use of the logical action ensures the elapsed time + * jumps exactly from 0 to 100, 300, 600, and 1000 msec. * * Modeled after the C version of this test. */ diff --git a/test/Cpp/src/SlowingClockPhysical.lf b/test/Cpp/src/SlowingClockPhysical.lf index 919f9d6cdf..7486a00a91 100644 --- a/test/Cpp/src/SlowingClockPhysical.lf +++ b/test/Cpp/src/SlowingClockPhysical.lf @@ -1,11 +1,10 @@ /** * @author Maiko Brants TU Dresden * - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 - * msec on a physical action with a minimum delay of 100 msec. The use of the - * physical action makes the elapsed time jumps from 0 to approximately 100 - * msec, to approximatly 300 msec thereafter, drifting away further with each - * new event. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a physical + * action with a minimum delay of 100 msec. The use of the physical action makes the elapsed time + * jumps from 0 to approximately 100 msec, to approximatly 300 msec thereafter, drifting away + * further with each new event. * * Modeled after the C version of this test. */ diff --git a/test/Cpp/src/Stride.lf b/test/Cpp/src/Stride.lf index 5f469e4c70..7aabd9b399 100644 --- a/test/Cpp/src/Stride.lf +++ b/test/Cpp/src/Stride.lf @@ -1,5 +1,5 @@ -// This example illustrates state variables and parameters on the wiki. For this -// test, success is just compiling and running. +// This example illustrates state variables and parameters on the wiki. For this test, success is +// just compiling and running. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/StructParallel.lf b/test/Cpp/src/StructParallel.lf index e709057f02..ab50ab0e93 100644 --- a/test/Cpp/src/StructParallel.lf +++ b/test/Cpp/src/StructParallel.lf @@ -1,6 +1,6 @@ -// Source allocates an array dynamically and then sends it to two reactors, each -// of which want to modify it. NOTE: Ideally, only one copy would be made, but -// this requires is currently not supported by the C++ runtime. +// Source allocates an array dynamically and then sends it to two reactors, each of which want to +// modify it. NOTE: Ideally, only one copy would be made, but this requires is currently not +// supported by the C++ runtime. target Cpp import Scale from "StructScale.lf" diff --git a/test/Cpp/src/StructScale.lf b/test/Cpp/src/StructScale.lf index 776dad14b1..ed472eced6 100644 --- a/test/Cpp/src/StructScale.lf +++ b/test/Cpp/src/StructScale.lf @@ -1,6 +1,5 @@ -// Source produces a dynamically allocated struct, which it passes to Scale. -// Scale requests a writable copy. It modifies it and passes it to Print. It -// gets freed after Print is done with it. +// Source produces a dynamically allocated struct, which it passes to Scale. Scale requests a +// writable copy. It modifies it and passes it to Print. It gets freed after Print is done with it. target Cpp import Source, Print from "StructPrint.lf" diff --git a/test/Cpp/src/TestForPreviousOutput.lf b/test/Cpp/src/TestForPreviousOutput.lf index 7be315e5a4..3a5b9bd697 100644 --- a/test/Cpp/src/TestForPreviousOutput.lf +++ b/test/Cpp/src/TestForPreviousOutput.lf @@ -1,5 +1,5 @@ -// This tests the mechanism for testing whether a previous reaction has produced -// a given output. The output should always be 42. +// This tests the mechanism for testing whether a previous reaction has produced a given output. The +// output should always be 42. target Cpp reactor Source { diff --git a/test/Cpp/src/TimeLimit.lf b/test/Cpp/src/TimeLimit.lf index 8b33dcd967..8383d4bf26 100644 --- a/test/Cpp/src/TimeLimit.lf +++ b/test/Cpp/src/TimeLimit.lf @@ -1,6 +1,5 @@ -// Test that the stop function can be used to internally to impose a a time -// limit. Correct output for this 1, 2, 3, 4. Failure for this test is failing -// to halt or getting the wrong data. +// Test that the stop function can be used to internally to impose a a time limit. Correct output +// for this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. target Cpp { fast: true } diff --git a/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf b/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf index b8c304b164..1a360411ae 100644 --- a/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,6 +1,5 @@ /** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. + * This test checks that a downstream reaction is triggered only if its trigger is present. * * @author Maiko Brants TU Dresden * diff --git a/test/Cpp/src/concurrent/CompositionThreaded.lf b/test/Cpp/src/concurrent/CompositionThreaded.lf index 42817e8b1d..07738e3e45 100644 --- a/test/Cpp/src/concurrent/CompositionThreaded.lf +++ b/test/Cpp/src/concurrent/CompositionThreaded.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target Cpp { fast: true, timeout: 10 sec diff --git a/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf index bb380fe14c..fe39ebcb98 100644 --- a/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target Cpp reactor Deadline(threshold: time = 100 msec) { diff --git a/test/Cpp/src/concurrent/DeadlineThreaded.lf b/test/Cpp/src/concurrent/DeadlineThreaded.lf index cb794f5050..131167fa77 100644 --- a/test/Cpp/src/concurrent/DeadlineThreaded.lf +++ b/test/Cpp/src/concurrent/DeadlineThreaded.lf @@ -1,6 +1,5 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target Cpp { timeout: 4 sec } diff --git a/test/Cpp/src/concurrent/DoubleReactionThreaded.lf b/test/Cpp/src/concurrent/DoubleReactionThreaded.lf index d68f2e8b60..c8b1fa06a3 100644 --- a/test/Cpp/src/concurrent/DoubleReactionThreaded.lf +++ b/test/Cpp/src/concurrent/DoubleReactionThreaded.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target Cpp { timeout: 10 sec, fast: true diff --git a/test/Cpp/src/concurrent/ImportThreaded.lf b/test/Cpp/src/concurrent/ImportThreaded.lf index ae8f2405cd..d032b196fe 100644 --- a/test/Cpp/src/concurrent/ImportThreaded.lf +++ b/test/Cpp/src/concurrent/ImportThreaded.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target Cpp import Imported from "../lib/Imported.lf" diff --git a/test/Cpp/src/concurrent/SendingInsideThreaded.lf b/test/Cpp/src/concurrent/SendingInsideThreaded.lf index 51ca511e26..acd34f147f 100644 --- a/test/Cpp/src/concurrent/SendingInsideThreaded.lf +++ b/test/Cpp/src/concurrent/SendingInsideThreaded.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target Cpp { timeout: 10 sec, fast: true diff --git a/test/Cpp/src/concurrent/Threaded.lf b/test/Cpp/src/concurrent/Threaded.lf index 9ad4fcbe56..f0a72fc2ed 100644 --- a/test/Cpp/src/concurrent/Threaded.lf +++ b/test/Cpp/src/concurrent/Threaded.lf @@ -1,11 +1,9 @@ -// Check for speedup of multithreaded execution on multicore machines. Each -// instance of TakeTime takes 200 ms to transport the input to the output. Four -// of them are instantiated. Note that without parallel execution, there is no -// way this can keep up with real time since in every 200 msec cycle it has 800 -// msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded -// version, showing that without threads, this takes more than 800 msec to -// complete 200 msec of logical time. +// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime +// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that +// without parallel execution, there is no way this can keep up with real time since in every 200 +// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing +// that without threads, this takes more than 800 msec to complete 200 msec of logical time. target Cpp { timeout: 2 sec } diff --git a/test/Cpp/src/concurrent/ThreadedThreaded.lf b/test/Cpp/src/concurrent/ThreadedThreaded.lf index f8b21a6121..e8d50e7a33 100644 --- a/test/Cpp/src/concurrent/ThreadedThreaded.lf +++ b/test/Cpp/src/concurrent/ThreadedThreaded.lf @@ -1,11 +1,9 @@ -// Check for speedup of multithreaded execution on multicore machines. Each -// instance of TakeTime takes 200 ms to transport the input to the output. Four -// of them are instantiated. Note that without parallel execution, there is no -// way this can keep up with real time since in every 200 msec cycle it has 800 -// msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded -// version, showing that without threads, this takes more than 800 msec to -// complete 200 msec of logical time. +// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime +// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that +// without parallel execution, there is no way this can keep up with real time since in every 200 +// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing +// that without threads, this takes more than 800 msec to complete 200 msec of logical time. target Cpp { timeout: 2 sec } diff --git a/test/Cpp/src/concurrent/TimeLimitThreaded.lf b/test/Cpp/src/concurrent/TimeLimitThreaded.lf index 47371f72d7..bd9959b9a0 100644 --- a/test/Cpp/src/concurrent/TimeLimitThreaded.lf +++ b/test/Cpp/src/concurrent/TimeLimitThreaded.lf @@ -1,7 +1,6 @@ -// Test that the stop function can be used to internally to impose a a time -// limit. This is also used to test performance (number of reactions per -// second). Correct output for this 1, 2, 3, 4. Failure for this test is failing -// to halt or getting the wrong data. +// Test that the stop function can be used to internally to impose a a time limit. This is also used +// to test performance (number of reactions per second). Correct output for this 1, 2, 3, 4. Failure +// for this test is failing to halt or getting the wrong data. target Cpp { fast: true } diff --git a/test/Cpp/src/lib/Imported.lf b/test/Cpp/src/lib/Imported.lf index 96a540c171..9c29c48be2 100644 --- a/test/Cpp/src/lib/Imported.lf +++ b/test/Cpp/src/lib/Imported.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target Cpp import ImportedAgain from "ImportedAgain.lf" diff --git a/test/Cpp/src/lib/ImportedAgain.lf b/test/Cpp/src/lib/ImportedAgain.lf index 048bdef364..83495dc480 100644 --- a/test/Cpp/src/lib/ImportedAgain.lf +++ b/test/Cpp/src/lib/ImportedAgain.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target Cpp reactor ImportedAgain { diff --git a/test/Cpp/src/lib/ImportedComposition.lf b/test/Cpp/src/lib/ImportedComposition.lf index 3619ff7ed8..97ddb436d0 100644 --- a/test/Cpp/src/lib/ImportedComposition.lf +++ b/test/Cpp/src/lib/ImportedComposition.lf @@ -1,8 +1,8 @@ /** * @author Maiko Brants TU Dresden * - * This is used by the test for the ability to import a reactor definition that - * itself imports a reactor definition. + * This is used by the test for the ability to import a reactor definition that itself imports a + * reactor definition. * * modeled after the C version of this test */ diff --git a/test/Cpp/src/lib/LoopedActionSender.lf b/test/Cpp/src/lib/LoopedActionSender.lf index 3c1cc13631..572e00d6c4 100644 --- a/test/Cpp/src/lib/LoopedActionSender.lf +++ b/test/Cpp/src/lib/LoopedActionSender.lf @@ -8,10 +8,9 @@ target Cpp /** - * @param take_a_break_after: Indicates how many messages are sent in - * consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break - * after sending take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break after sending + * take_a_break_after messages. */ reactor Sender(take_a_break_after: int = 10, break_interval: time = 400 msec) { output out: int diff --git a/test/Cpp/src/multiport/BankSelfBroadcast.lf b/test/Cpp/src/multiport/BankSelfBroadcast.lf index 07da948506..417d5b325e 100644 --- a/test/Cpp/src/multiport/BankSelfBroadcast.lf +++ b/test/Cpp/src/multiport/BankSelfBroadcast.lf @@ -1,7 +1,7 @@ /** - * Test a bank of reactors that broadcast a single output back to a multiport - * input of the same reactors in the bank so that each reactor in the bank - * receives the output produced by itself and each other reactor. + * Test a bank of reactors that broadcast a single output back to a multiport input of the same + * reactors in the bank so that each reactor in the bank receives the output produced by itself and + * each other reactor. * * @author Edward A. Lee * @author Christian Menard diff --git a/test/Cpp/src/multiport/IndexIntoMultiportInput.lf b/test/Cpp/src/multiport/IndexIntoMultiportInput.lf index 26f9275b56..068724b781 100644 --- a/test/Cpp/src/multiport/IndexIntoMultiportInput.lf +++ b/test/Cpp/src/multiport/IndexIntoMultiportInput.lf @@ -2,9 +2,8 @@ * This test was first described by Peter Donovan in * https://github.com/lf-lang/lingua-franca/issues/1321 * - * It simply tests if passthrough connections work as expected in the C++ - * target. Such a connection directly connects an input to an output of the same - * reactor, without any reactions in between. + * It simply tests if passthrough connections work as expected in the C++ target. Such a connection + * directly connects an input to an output of the same reactor, without any reactions in between. */ target Cpp diff --git a/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf b/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf index 964e2e7095..dd5a5759e1 100644 --- a/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf +++ b/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf @@ -2,9 +2,8 @@ * This test was first described by Peter Donovan in * https://github.com/lf-lang/lingua-franca/issues/1321 * - * It simply tests if passthrough connections work as expected in the C++ - * target. Such a connection directly connects an input to an output of the same - * reactor, without any reactions in between. + * It simply tests if passthrough connections work as expected in the C++ target. Such a connection + * directly connects an input to an output of the same reactor, without any reactions in between. */ target Cpp diff --git a/test/Cpp/src/multiport/MultiportFromBank.lf b/test/Cpp/src/multiport/MultiportFromBank.lf index b7339a9184..d1cf2a9d36 100644 --- a/test/Cpp/src/multiport/MultiportFromBank.lf +++ b/test/Cpp/src/multiport/MultiportFromBank.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf b/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf index 673ef6889a..1b4c53bf83 100644 --- a/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf index fe27c74f35..1786e5292d 100644 --- a/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportFromHierarchy.lf b/test/Cpp/src/multiport/MultiportFromHierarchy.lf index fae914b609..75eadf542b 100644 --- a/test/Cpp/src/multiport/MultiportFromHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportFromHierarchy.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input, where the former is a hierarchical -// reactor. +// Check multiport output to multiport input, where the former is a hierarchical reactor. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportIn.lf b/test/Cpp/src/multiport/MultiportIn.lf index 39fce6f8ff..af2f4eab18 100644 --- a/test/Cpp/src/multiport/MultiportIn.lf +++ b/test/Cpp/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -// This is a version fo the Threaded test that uses a multiport input at the -// destination. Its purpose is to test multiport inputs. +// This is a version fo the Threaded test that uses a multiport input at the destination. Its +// purpose is to test multiport inputs. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportToBankHierarchy.lf b/test/Cpp/src/multiport/MultiportToBankHierarchy.lf index f9cef6a676..1c520d6759 100644 --- a/test/Cpp/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportToBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportToHierarchy.lf b/test/Cpp/src/multiport/MultiportToHierarchy.lf index 573a0e06da..ff641336ae 100644 --- a/test/Cpp/src/multiport/MultiportToHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportToHierarchy.lf @@ -1,6 +1,5 @@ -// Check multiport output to multiport input, where the latter is a hierarchical -// reactor. Note that the destination reactor has width wider than the sender, -// so one input is dangling. +// Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that +// the destination reactor has width wider than the sender, so one input is dangling. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportToMultiportArray.lf b/test/Cpp/src/multiport/MultiportToMultiportArray.lf index 6c96d17150..0da837bb17 100644 --- a/test/Cpp/src/multiport/MultiportToMultiportArray.lf +++ b/test/Cpp/src/multiport/MultiportToMultiportArray.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportToPort.lf b/test/Cpp/src/multiport/MultiportToPort.lf index c2b0bd66ef..48804f575e 100644 --- a/test/Cpp/src/multiport/MultiportToPort.lf +++ b/test/Cpp/src/multiport/MultiportToPort.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf b/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf index 6fa6dbb87b..c4bdb80d9d 100644 --- a/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf +++ b/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf @@ -1,5 +1,4 @@ -// Test reacting to and reading outputs from a contained reactor bank with a -// multiport +// Test reacting to and reading outputs from a contained reactor bank with a multiport target Cpp reactor Contained(bank_index: size_t = 0) { diff --git a/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf b/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf index 18179b9086..db27bf5a6f 100644 --- a/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf +++ b/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf @@ -1,5 +1,4 @@ -// Test reacting to and reading outputs from a contained reactor bank in various -// permutations. +// Test reacting to and reading outputs from a contained reactor bank in various permutations. target Cpp reactor Contained(bank_index: size_t = 0) { diff --git a/test/Cpp/src/target/BraceAndParenInitialization.lf b/test/Cpp/src/target/BraceAndParenInitialization.lf index 003b6d509d..488a2719f5 100644 --- a/test/Cpp/src/target/BraceAndParenInitialization.lf +++ b/test/Cpp/src/target/BraceAndParenInitialization.lf @@ -6,10 +6,8 @@ reactor Foo( param_list_3: std::vector(4, 2), // list containing [2,2,2,2] param_list_4: std::vector{4, 2} // list containing [4,2] ) { - // list containing [42,42,42,42,42,42] - state state_list_1: std::vector(6, 42) - // list containing [6,42] - state state_list_2: std::vector{6, 42} + state state_list_1: std::vector(6, 42) // list containing [42,42,42,42,42,42] + state state_list_2: std::vector{6, 42} // list containing [6,42] reaction(startup) {= std::cerr << "Hello!\n"; diff --git a/test/Cpp/src/target/CMakeInclude.lf b/test/Cpp/src/target/CMakeInclude.lf index a6e883a2d9..b1adacc966 100644 --- a/test/Cpp/src/target/CMakeInclude.lf +++ b/test/Cpp/src/target/CMakeInclude.lf @@ -1,6 +1,5 @@ /** - * Test that cmake-include is working correctly. The failure for this test is - * failure to compile. + * Test that cmake-include is working correctly. The failure for this test is failure to compile. */ target Cpp { cmake-include: [ diff --git a/test/Cpp/src/target/PreambleFile.lf b/test/Cpp/src/target/PreambleFile.lf index 9dc6dcc748..db9ff5e712 100644 --- a/test/Cpp/src/target/PreambleFile.lf +++ b/test/Cpp/src/target/PreambleFile.lf @@ -1,7 +1,7 @@ target Cpp -// These declarations are used by multiple reactors within this file and should -// be placed in a header. This goes to PreampleFile/preamble.hh. +// These declarations are used by multiple reactors within this file and should be placed in a +// header. This goes to PreampleFile/preamble.hh. public preamble {= struct MyStruct { int foo; @@ -11,9 +11,8 @@ public preamble {= int add_42(int i); =} -// This definition is used by multiple reactors within this file. Since the same -// function can only be defined once, this needs to go to a source file. This -// goes to PreampleFile/preamble.cc. +// This definition is used by multiple reactors within this file. Since the same function can only +// be defined once, this needs to go to a source file. This goes to PreampleFile/preamble.cc. private preamble {= int add_42(int i) { return i + 42; @@ -30,9 +29,8 @@ reactor Source { } reactor Print { - // This helper function is only used within the Print reactor and is - // therefore part of its private interface. This goes to - // PreambleFile/Print.cc + // This helper function is only used within the Print reactor and is therefore part of its + // private interface. This goes to PreambleFile/Print.cc private preamble {= void print(const MyStruct& x) { std::cout << "Received " << x.foo << " and '" << x.bar << "'\n"; diff --git a/test/Python/src/ActionWithNoReaction.lf b/test/Python/src/ActionWithNoReaction.lf index c9ed8b1f77..1b0ee74893 100644 --- a/test/Python/src/ActionWithNoReaction.lf +++ b/test/Python/src/ActionWithNoReaction.lf @@ -1,6 +1,5 @@ -# This checks that action can be created even if there is no reaction. This test -# passes merely by compiling and executing without a segfault. Its other -# functionality is tested by other tests. +# This checks that action can be created even if there is no reaction. This test passes merely by +# compiling and executing without a segfault. Its other functionality is tested by other tests. target Python { fast: true, timeout: 3 sec diff --git a/test/Python/src/After.lf b/test/Python/src/After.lf index 0c8b931543..8ed92b2061 100644 --- a/test/Python/src/After.lf +++ b/test/Python/src/After.lf @@ -1,5 +1,4 @@ -# This checks that the after keyword adjusts logical time, not using physical -# time. +# This checks that the after keyword adjusts logical time, not using physical time. target Python { fast: false, timeout: 3 sec diff --git a/test/Python/src/AfterCycles.lf b/test/Python/src/AfterCycles.lf index cd0f0dd98e..e062d013ee 100644 --- a/test/Python/src/AfterCycles.lf +++ b/test/Python/src/AfterCycles.lf @@ -1,5 +1,5 @@ -# This tests that "after" does not introduce spurious cycles. Success if running -# without detected a cycle. +# This tests that "after" does not introduce spurious cycles. Success if running without detected a +# cycle. target Python reactor Source { diff --git a/test/Python/src/ArrayAsType.lf b/test/Python/src/ArrayAsType.lf index dc3b2f6e26..37d5d66cf7 100644 --- a/test/Python/src/ArrayAsType.lf +++ b/test/Python/src/ArrayAsType.lf @@ -1,5 +1,5 @@ -# Source produces a statically allocated array, which it passes to Print. The -# destination references the array directly. +# Source produces a statically allocated array, which it passes to Print. The destination references +# the array directly. target Python reactor Source { diff --git a/test/Python/src/ArrayFree.lf b/test/Python/src/ArrayFree.lf index 2ea2777c12..147e9537a8 100644 --- a/test/Python/src/ArrayFree.lf +++ b/test/Python/src/ArrayFree.lf @@ -1,7 +1,7 @@ -# Source produces a dynamically allocated array, which it passes to Free. Free -# requests a writable copy, which, instead of copying, it just gets ownership of -# the original array. It then does nothing further with it. This test checks -# that the memory gets freed automatically even with the mutable input. +# Source produces a dynamically allocated array, which it passes to Free. Free requests a writable +# copy, which, instead of copying, it just gets ownership of the original array. It then does +# nothing further with it. This test checks that the memory gets freed automatically even with the +# mutable input. target Python import Source, Print from "ArrayPrint.lf" diff --git a/test/Python/src/ArrayParallel.lf b/test/Python/src/ArrayParallel.lf index 1ae1a0ac77..5e75898f14 100644 --- a/test/Python/src/ArrayParallel.lf +++ b/test/Python/src/ArrayParallel.lf @@ -1,6 +1,6 @@ -# Source allocates an array dynamically and then sends it to two reactors, each -# of which want to modify it. NOTE: Ideally, only one copy would be made, but -# this requires modifying the precedence graph between reactions. +# Source allocates an array dynamically and then sends it to two reactors, each of which want to +# modify it. NOTE: Ideally, only one copy would be made, but this requires modifying the precedence +# graph between reactions. target Python import Scale from "ArrayScale.lf" diff --git a/test/Python/src/ArrayPrint.lf b/test/Python/src/ArrayPrint.lf index 4420311b93..254d9c352d 100644 --- a/test/Python/src/ArrayPrint.lf +++ b/test/Python/src/ArrayPrint.lf @@ -1,5 +1,5 @@ -# Source produces a dynamically allocated array, which it passes to Print. -# Reference counting ensures that the array is freed. +# Source produces a dynamically allocated array, which it passes to Print. Reference counting +# ensures that the array is freed. target Python reactor Source { diff --git a/test/Python/src/ArrayScale.lf b/test/Python/src/ArrayScale.lf index 2b69aebe77..10f5a747e6 100644 --- a/test/Python/src/ArrayScale.lf +++ b/test/Python/src/ArrayScale.lf @@ -1,7 +1,6 @@ -# Source produces a dynamically allocated array, which it passes to Scale. Scale -# requests a writable copy, which, instead of copying, it just gets ownership of -# the original array. It modifies it and passes it to Print. It gets freed after -# Print is done with it. +# Source produces a dynamically allocated array, which it passes to Scale. Scale requests a writable +# copy, which, instead of copying, it just gets ownership of the original array. It modifies it and +# passes it to Print. It gets freed after Print is done with it. target Python import Print, Source from "ArrayPrint.lf" diff --git a/test/Python/src/Composition.lf b/test/Python/src/Composition.lf index d1bef93ed2..a5b9cac96f 100644 --- a/test/Python/src/Composition.lf +++ b/test/Python/src/Composition.lf @@ -1,5 +1,4 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { fast: true, timeout: 10 sec diff --git a/test/Python/src/CompositionAfter.lf b/test/Python/src/CompositionAfter.lf index 00b95e3ab9..74217559db 100644 --- a/test/Python/src/CompositionAfter.lf +++ b/test/Python/src/CompositionAfter.lf @@ -1,5 +1,4 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { fast: true, timeout: 10 sec diff --git a/test/Python/src/CompositionInheritance.lf b/test/Python/src/CompositionInheritance.lf index 4b0e4a38c9..aeaa9e30bb 100644 --- a/test/Python/src/CompositionInheritance.lf +++ b/test/Python/src/CompositionInheritance.lf @@ -1,5 +1,4 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { fast: true, timeout: 10 sec diff --git a/test/Python/src/DanglingOutput.lf b/test/Python/src/DanglingOutput.lf index 03709fef13..7894f73835 100644 --- a/test/Python/src/DanglingOutput.lf +++ b/test/Python/src/DanglingOutput.lf @@ -1,5 +1,5 @@ -# This tests that an output that is not connected to anything does not result in -# a compilation error. Passing the test is just compiling and running. +# This tests that an output that is not connected to anything does not result in a compilation +# error. Passing the test is just compiling and running. target Python reactor Source { diff --git a/test/Python/src/Deadline.lf b/test/Python/src/Deadline.lf index ceab2b28e2..154a755327 100644 --- a/test/Python/src/Deadline.lf +++ b/test/Python/src/Deadline.lf @@ -1,6 +1,5 @@ -# This example illustrates local deadline handling. Even numbers are sent by the -# Source immediately, whereas odd numbers are sent after a big enough delay to -# violate the deadline. +# This example illustrates local deadline handling. Even numbers are sent by the Source immediately, +# whereas odd numbers are sent after a big enough delay to violate the deadline. target Python { timeout: 6 sec } diff --git a/test/Python/src/DeadlineHandledAbove.lf b/test/Python/src/DeadlineHandledAbove.lf index 1259253cea..39c927ee08 100644 --- a/test/Python/src/DeadlineHandledAbove.lf +++ b/test/Python/src/DeadlineHandledAbove.lf @@ -1,5 +1,5 @@ -# Test a deadline where the deadline violation produces an output and the -# container reacts to that output. +# Test a deadline where the deadline violation produces an output and the container reacts to that +# output. target Python preamble {= import time =} diff --git a/test/Python/src/DelayArrayWithAfter.lf b/test/Python/src/DelayArrayWithAfter.lf index 1e6ac1f317..52245e314f 100644 --- a/test/Python/src/DelayArrayWithAfter.lf +++ b/test/Python/src/DelayArrayWithAfter.lf @@ -1,5 +1,4 @@ -# This tests transport of dynamically allocated arrays over connections with -# 'after'. +# This tests transport of dynamically allocated arrays over connections with 'after'. target Python { timeout: 5 sec, fast: true diff --git a/test/Python/src/DelayString.lf b/test/Python/src/DelayString.lf index d1201dec02..e7e7531888 100644 --- a/test/Python/src/DelayString.lf +++ b/test/Python/src/DelayString.lf @@ -1,5 +1,4 @@ -# This tests actions with immutable payloads that are neither malloc'd nor -# freed. +# This tests actions with immutable payloads that are neither malloc'd nor freed. target Python reactor DelayString2(delay = 100 msec) { diff --git a/test/Python/src/DoubleInvocation.lf b/test/Python/src/DoubleInvocation.lf index aaecfa31cb..78d31883ea 100644 --- a/test/Python/src/DoubleInvocation.lf +++ b/test/Python/src/DoubleInvocation.lf @@ -1,8 +1,7 @@ -# This illustrates a very strange bug that showed up and has now been fixed. -# This test ensures it does not reappear. At logical time zero, the two Print -# reactors used to be fired twice each at the same logical time. They should -# only be fired once. This behavior was oddly eliminated by either of the -# following actions, neither of which should affect this behavior: +# This illustrates a very strange bug that showed up and has now been fixed. This test ensures it +# does not reappear. At logical time zero, the two Print reactors used to be fired twice each at the +# same logical time. They should only be fired once. This behavior was oddly eliminated by either of +# the following actions, neither of which should affect this behavior: # * Removing the startup reaction in Print. # * Sending only position, not velocity from Ball. target Python { diff --git a/test/Python/src/DoubleReaction.lf b/test/Python/src/DoubleReaction.lf index c20a032a9a..7af73da6ec 100644 --- a/test/Python/src/DoubleReaction.lf +++ b/test/Python/src/DoubleReaction.lf @@ -1,5 +1,5 @@ -# Test that two simultaneous inputs that trigger a reaction trigger it only -# once. Correct output for this 2, 4, 6, 8, etc. +# Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output for +# this 2, 4, 6, 8, etc. target Python { timeout: 10 sec, fast: true diff --git a/test/Python/src/GetTime.lf b/test/Python/src/GetTime.lf index 7829cb0db5..8c22851395 100644 --- a/test/Python/src/GetTime.lf +++ b/test/Python/src/GetTime.lf @@ -1,5 +1,5 @@ -# This file includes code documented on the Wiki. For this test, success is just -# compiling and running. +# This file includes code documented on the Wiki. For this test, success is just compiling and +# running. target Python { timeout: 2 sec, fast: false diff --git a/test/Python/src/Hello.lf b/test/Python/src/Hello.lf index 271ed180ca..8e60df4ae5 100644 --- a/test/Python/src/Hello.lf +++ b/test/Python/src/Hello.lf @@ -1,8 +1,7 @@ -# This test checks that logical time is incremented an appropriate amount as a -# result of an invocation of the schedule() function at runtime. It also -# performs various smoke tests of timing aligned reactions. The first instance -# has a period of 4 seconds, the second of 2 seconds, and the third (composite) -# or 1 second. +# This test checks that logical time is incremented an appropriate amount as a result of an +# invocation of the schedule() function at runtime. It also performs various smoke tests of timing +# aligned reactions. The first instance has a period of 4 seconds, the second of 2 seconds, and the +# third (composite) or 1 second. target Python { timeout: 10 sec, fast: true @@ -43,10 +42,7 @@ reactor Inside(period = 1 sec, message = "Composite default message.") { } main reactor Hello { - first_instance = new Reschedule( - period = 4 sec, - message = "Hello from first_instance." - ) + first_instance = new Reschedule(period = 4 sec, message = "Hello from first_instance.") second_instance = new Reschedule(message = "Hello from second_instance.") composite_instance = new Inside(message = "Hello from composite_instance.") } diff --git a/test/Python/src/Import.lf b/test/Python/src/Import.lf index 95844fa5c0..4c17403320 100644 --- a/test/Python/src/Import.lf +++ b/test/Python/src/Import.lf @@ -1,5 +1,4 @@ -# This tests the ability to import a reactor definition that itself imports a -# reactor definition. +# This tests the ability to import a reactor definition that itself imports a reactor definition. target Python import Imported from "lib/Imported.lf" diff --git a/test/Python/src/ImportComposition.lf b/test/Python/src/ImportComposition.lf index 369fbcab44..8063e7c938 100644 --- a/test/Python/src/ImportComposition.lf +++ b/test/Python/src/ImportComposition.lf @@ -1,5 +1,4 @@ -# This tests the ability to import a reactor definition that itself imports a -# reactor definition. +# This tests the ability to import a reactor definition that itself imports a reactor definition. target Python import ImportedComposition from "lib/ImportedComposition.lf" diff --git a/test/Python/src/ImportRenamed.lf b/test/Python/src/ImportRenamed.lf index e9db8a2afb..ab6f1c8078 100644 --- a/test/Python/src/ImportRenamed.lf +++ b/test/Python/src/ImportRenamed.lf @@ -1,5 +1,4 @@ -# This tests the ability to import a reactor definition that itself imports a -# reactor definition. +# This tests the ability to import a reactor definition that itself imports a reactor definition. target Python import Imported as X from "lib/Imported.lf" diff --git a/test/Python/src/ManualDelayedReaction.lf b/test/Python/src/ManualDelayedReaction.lf index a9e39829eb..57a4d2efbb 100644 --- a/test/Python/src/ManualDelayedReaction.lf +++ b/test/Python/src/ManualDelayedReaction.lf @@ -1,12 +1,11 @@ target Python { - # Set keepalive to false since this is a test and schedule is called on a - # physical action from within a reaction. This is one of the special rare - # cases where the user might want to manually override keepalive. + # Set keepalive to false since this is a test and schedule is called on a physical action from + # within a reaction. This is one of the special rare cases where the user might want to manually + # override keepalive. keepalive: false } -# That's the stuff that shall be generated for the after -reactor GeneratedDelay { +reactor GeneratedDelay { # That's the stuff that shall be generated for the after input y_in output y_out state y_state = 0 diff --git a/test/Python/src/MovingAverage.lf b/test/Python/src/MovingAverage.lf index 3dbd5636c3..963cb72db1 100644 --- a/test/Python/src/MovingAverage.lf +++ b/test/Python/src/MovingAverage.lf @@ -1,6 +1,5 @@ -# Demonstration of a state variable that is a list. The MovingAverage reactor -# computes the moving average of the last four inputs and produces that as -# output. The source is a counting sequence. +# Demonstration of a state variable that is a list. The MovingAverage reactor computes the moving +# average of the last four inputs and produces that as output. The source is a counting sequence. target Python { timeout: 1 sec, fast: true diff --git a/test/Python/src/MultipleContained.lf b/test/Python/src/MultipleContained.lf index 27950ccd88..ae9cb0e96b 100644 --- a/test/Python/src/MultipleContained.lf +++ b/test/Python/src/MultipleContained.lf @@ -1,5 +1,4 @@ -# Test that a reaction can react to and send two multiple ports of a contained -# reactor. +# Test that a reaction can react to and send two multiple ports of a contained reactor. target Python reactor Contained { diff --git a/test/Python/src/PingPong.lf b/test/Python/src/PingPong.lf index f5f80511ae..72c5e19563 100644 --- a/test/Python/src/PingPong.lf +++ b/test/Python/src/PingPong.lf @@ -1,22 +1,19 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the - * causality loop. + * Ping introduces a microstep delay using a logical action to break the causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * Unthreaded: 97 msec Threaded: 265 msec * - * There is no parallelism in this application, so it does not benefit from - * being being threaded, just some additional overhead. + * There is no parallelism in this application, so it does not benefit from being being threaded, + * just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. - * These are about an order of magnitude faster than anything reported in the - * paper. + * These measurements are total execution time, including startup and shutdown. These are about an + * order of magnitude faster than anything reported in the paper. * * @author Edward A. Lee */ diff --git a/test/Python/src/Preamble.lf b/test/Python/src/Preamble.lf index c2bd38ed6b..e158ea03b3 100644 --- a/test/Python/src/Preamble.lf +++ b/test/Python/src/Preamble.lf @@ -1,5 +1,5 @@ -# Preambles are put inside the Python reactor class Therefore, accessing them -# requires the use of self. +# Preambles are put inside the Python reactor class Therefore, accessing them requires the use of +# self. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/ReadOutputOfContainedReactor.lf b/test/Python/src/ReadOutputOfContainedReactor.lf index 1cb73667ce..4052d70e77 100644 --- a/test/Python/src/ReadOutputOfContainedReactor.lf +++ b/test/Python/src/ReadOutputOfContainedReactor.lf @@ -1,5 +1,4 @@ -# Test reacting to and reading outputs from a contained reactor in various -# permutations. +# Test reacting to and reading outputs from a contained reactor in various permutations. target Python reactor Contained { diff --git a/test/Python/src/ScheduleLogicalAction.lf b/test/Python/src/ScheduleLogicalAction.lf index 3f99c65777..b60471f676 100644 --- a/test/Python/src/ScheduleLogicalAction.lf +++ b/test/Python/src/ScheduleLogicalAction.lf @@ -1,5 +1,5 @@ -# This checks that a logical action is scheduled the specified logical time -# after the current logical time. +# This checks that a logical action is scheduled the specified logical time after the current +# logical time. target Python { fast: true, timeout: 3 sec diff --git a/test/Python/src/SendingInside.lf b/test/Python/src/SendingInside.lf index 8bcc66c005..e6645fbc44 100644 --- a/test/Python/src/SendingInside.lf +++ b/test/Python/src/SendingInside.lf @@ -1,5 +1,5 @@ -# This tests a reactor that contains another reactor and also has its own -# reaction that routes inputs to the contained reactor. +# This tests a reactor that contains another reactor and also has its own reaction that routes +# inputs to the contained reactor. target Python { timeout: 10 sec, fast: true diff --git a/test/Python/src/SetArray.lf b/test/Python/src/SetArray.lf index 4766d529f7..8906312c04 100644 --- a/test/Python/src/SetArray.lf +++ b/test/Python/src/SetArray.lf @@ -1,6 +1,5 @@ -# This tests passing lists as port values This tests the use of the -# "polymorphic" delay reactor on a struct. It delays by a logical time any -# pointer datatype. +# This tests passing lists as port values This tests the use of the "polymorphic" delay reactor on a +# struct. It delays by a logical time any pointer datatype. target Python reactor Source { diff --git a/test/Python/src/SimpleDeadline.lf b/test/Python/src/SimpleDeadline.lf index a714124129..f1065e9508 100644 --- a/test/Python/src/SimpleDeadline.lf +++ b/test/Python/src/SimpleDeadline.lf @@ -1,6 +1,5 @@ -# Test local deadline, where a deadline is associated with a reaction -# definition. This test triggers a reaction exactly once with a deadline -# violation. +# Test local deadline, where a deadline is associated with a reaction definition. This test triggers +# a reaction exactly once with a deadline violation. target Python reactor Deadline(threshold = 100 msec) { diff --git a/test/Python/src/SlowingClock.lf b/test/Python/src/SlowingClock.lf index 972421437a..72f6657ffb 100644 --- a/test/Python/src/SlowingClock.lf +++ b/test/Python/src/SlowingClock.lf @@ -1,7 +1,7 @@ /** - * Output events at logical times 100, 300, 600, and 1000 msec after the start - * time. This uses a logical action with a minimum delay of 100 msec and - * additional delays provided as arguments to the schedule() function. + * Output events at logical times 100, 300, 600, and 1000 msec after the start time. This uses a + * logical action with a minimum delay of 100 msec and additional delays provided as arguments to + * the schedule() function. */ target Python { timeout: 1 sec, diff --git a/test/Python/src/Stride.lf b/test/Python/src/Stride.lf index 86c68bab5a..4d1ec22218 100644 --- a/test/Python/src/Stride.lf +++ b/test/Python/src/Stride.lf @@ -1,5 +1,5 @@ -# This example illustrates state variables and parameters on the wiki. For this -# test, success is just compiling and running. +# This example illustrates state variables and parameters on the wiki. For this test, success is +# just compiling and running. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/StructAsState.lf b/test/Python/src/StructAsState.lf index b6f38f8589..dc6bc3c70b 100644 --- a/test/Python/src/StructAsState.lf +++ b/test/Python/src/StructAsState.lf @@ -1,5 +1,4 @@ -# Check that a state variable can have a statically initialized struct as a -# value. +# Check that a state variable can have a statically initialized struct as a value. target Python main reactor StructAsState { diff --git a/test/Python/src/StructPrint.lf b/test/Python/src/StructPrint.lf index 3c0138f937..414e87c64d 100644 --- a/test/Python/src/StructPrint.lf +++ b/test/Python/src/StructPrint.lf @@ -1,5 +1,5 @@ -# Source produces a dynamically allocated class object, which it passes to -# Print. Reference counting ensures that the struct is freed. +# Source produces a dynamically allocated class object, which it passes to Print. Reference counting +# ensures that the struct is freed. target Python { files: ["include/hello.py"] } diff --git a/test/Python/src/TestForPreviousOutput.lf b/test/Python/src/TestForPreviousOutput.lf index 9e8ad43c26..1c17308c04 100644 --- a/test/Python/src/TestForPreviousOutput.lf +++ b/test/Python/src/TestForPreviousOutput.lf @@ -1,5 +1,5 @@ -# This tests the mechanism for testing whether a previous reaction has produced -# a given output. The output should always be 42. +# This tests the mechanism for testing whether a previous reaction has produced a given output. The +# output should always be 42. target Python reactor Source { diff --git a/test/Python/src/TimeLimit.lf b/test/Python/src/TimeLimit.lf index beb7602db9..95120083d8 100644 --- a/test/Python/src/TimeLimit.lf +++ b/test/Python/src/TimeLimit.lf @@ -1,6 +1,5 @@ -# Test that the stop function can be used to internally impose a a time limit. -# Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt -# or getting the wrong data. +# Test that the stop function can be used to internally impose a a time limit. Correct output for +# this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. target Python { fast: true } diff --git a/test/Python/src/TriggerDownstreamOnlyIfPresent.lf b/test/Python/src/TriggerDownstreamOnlyIfPresent.lf index b65f732652..a4ae089e46 100644 --- a/test/Python/src/TriggerDownstreamOnlyIfPresent.lf +++ b/test/Python/src/TriggerDownstreamOnlyIfPresent.lf @@ -1,7 +1,4 @@ -/** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. - */ +/** This test checks that a downstream reaction is triggered only if its trigger is present. */ target Python { timeout: 1 sec, fast: true diff --git a/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf b/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf index b9a9184296..7f94ab374a 100644 --- a/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,7 +1,4 @@ -/** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. - */ +/** This test checks that a downstream reaction is triggered only if its trigger is present. */ target Python { timeout: 1 sec, fast: true diff --git a/test/Python/src/concurrent/AsyncCallback.lf b/test/Python/src/concurrent/AsyncCallback.lf index 5ef4167bed..a85905c5fd 100644 --- a/test/Python/src/concurrent/AsyncCallback.lf +++ b/test/Python/src/concurrent/AsyncCallback.lf @@ -1,7 +1,6 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test - * periodically creates a concurrent Python thread that schedule a physical - * action twice. + * Test asynchronous callbacks that trigger a physical action. This test periodically creates a + * concurrent Python thread that schedule a physical action twice. */ target Python { timeout: 2 sec diff --git a/test/Python/src/concurrent/AsyncCallbackNoTimer.lf b/test/Python/src/concurrent/AsyncCallbackNoTimer.lf index 4e481d1d34..a51ff9acdb 100644 --- a/test/Python/src/concurrent/AsyncCallbackNoTimer.lf +++ b/test/Python/src/concurrent/AsyncCallbackNoTimer.lf @@ -1,11 +1,11 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test creates - * a concurrent Python thread that schedule a physical action twice. + * Test asynchronous callbacks that trigger a physical action. This test creates a concurrent Python + * thread that schedule a physical action twice. * - * There are no timers in this test to drive the logical time forward. This is - * important in the Python target since the user Python threads should be - * allowed to execute independently of the underlying C core runtime, without - * the C runtime polling the Python context with a reaction to a timer. + * There are no timers in this test to drive the logical time forward. This is important in the + * Python target since the user Python threads should be allowed to execute independently of the + * underlying C core runtime, without the C runtime polling the Python context with a reaction to a + * timer. */ target Python { timeout: 2 sec diff --git a/test/Python/src/docker/PingPongContainerized.lf b/test/Python/src/docker/PingPongContainerized.lf index 0346162390..4b9c772e2e 100644 --- a/test/Python/src/docker/PingPongContainerized.lf +++ b/test/Python/src/docker/PingPongContainerized.lf @@ -1,22 +1,19 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the - * causality loop. + * Ping introduces a microstep delay using a logical action to break the causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * Unthreaded: 97 msec Threaded: 265 msec * - * There is no parallelism in this application, so it does not benefit from - * being being threaded, just some additional overhead. + * There is no parallelism in this application, so it does not benefit from being being threaded, + * just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. - * These are about an order of magnitude faster than anything reported in the - * paper. + * These measurements are total execution time, including startup and shutdown. These are about an + * order of magnitude faster than anything reported in the paper. * * @author Edward A. Lee */ diff --git a/test/Python/src/docker/federated/DistributedCountContainerized.lf b/test/Python/src/docker/federated/DistributedCountContainerized.lf index 5f8a348d24..c2f9f7b0d5 100644 --- a/test/Python/src/docker/federated/DistributedCountContainerized.lf +++ b/test/Python/src/docker/federated/DistributedCountContainerized.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python { diff --git a/test/Python/src/docker/federated/DistributedDoublePortContainerized.lf b/test/Python/src/docker/federated/DistributedDoublePortContainerized.lf index d6605a2e6e..1aa2b1e640 100644 --- a/test/Python/src/docker/federated/DistributedDoublePortContainerized.lf +++ b/test/Python/src/docker/federated/DistributedDoublePortContainerized.lf @@ -1,7 +1,6 @@ /** - * Test the case for when two upstream federates send messages to a downstream - * federte on two different ports. One message should carry a microstep delay - * relative to the other message. + * Test the case for when two upstream federates send messages to a downstream federte on two + * different ports. One message should carry a microstep delay relative to the other message. * * @author Soroush Bateni */ diff --git a/test/Python/src/federated/BroadcastFeedback.lf b/test/Python/src/federated/BroadcastFeedback.lf index 75d313e61d..06fcd95037 100644 --- a/test/Python/src/federated/BroadcastFeedback.lf +++ b/test/Python/src/federated/BroadcastFeedback.lf @@ -1,6 +1,4 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target Python { timeout: 1 sec } diff --git a/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf b/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf index ad2a11c10c..d3e371b037 100644 --- a/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf +++ b/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf @@ -1,6 +1,4 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target Python { timeout: 1 sec } diff --git a/test/Python/src/federated/CycleDetection.lf b/test/Python/src/federated/CycleDetection.lf index cf9b6d6b54..5039f3f375 100644 --- a/test/Python/src/federated/CycleDetection.lf +++ b/test/Python/src/federated/CycleDetection.lf @@ -1,6 +1,6 @@ /** - * Check whether the internally generated network and control reactions - * introduce a cycle or not. The failure for this test is not being compiled. + * Check whether the internally generated network and control reactions introduce a cycle or not. + * The failure for this test is not being compiled. * @author Edward A. Lee */ target Python diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf index 48ff7a4ca7..a56a8f07ba 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf @@ -1,8 +1,7 @@ /** - * Test a source-destination scenario where the source falls behind real-time, - * and reaches the timeout much later than the destination. In this test, the - * destination closes the connection early, causing the transmission to fail. - * Warnings will be printed about lost messages. + * Test a source-destination scenario where the source falls behind real-time, and reaches the + * timeout much later than the destination. In this test, the destination closes the connection + * early, causing the transmission to fail. Warnings will be printed about lost messages. * * The test fails if the federation does not exit. */ diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index 4eb881694f..d065783f5a 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -1,11 +1,10 @@ /** - * Test a source-destination scenario where the source falls behind real-time, - * and reaches the timeout much later than the destination. In this test, the - * destination closes the connection early, causing the transmission to fail. - * Warnings will be printed. + * Test a source-destination scenario where the source falls behind real-time, and reaches the + * timeout much later than the destination. In this test, the destination closes the connection + * early, causing the transmission to fail. Warnings will be printed. * - * The test fails if the federation does not exit amenably. This variant has a - * physical connection between source and destination. + * The test fails if the federation does not exit amenably. This variant has a physical connection + * between source and destination. */ target Python { timeout: 1 msec, diff --git a/test/Python/src/federated/DistributedCount.lf b/test/Python/src/federated/DistributedCount.lf index 7713256520..6492c4fa32 100644 --- a/test/Python/src/federated/DistributedCount.lf +++ b/test/Python/src/federated/DistributedCount.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python { diff --git a/test/Python/src/federated/DistributedCountDecentralized.lf b/test/Python/src/federated/DistributedCountDecentralized.lf index e86adf9946..92cae03850 100644 --- a/test/Python/src/federated/DistributedCountDecentralized.lf +++ b/test/Python/src/federated/DistributedCountDecentralized.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ # reason for failing: in_.intended_tag are not supported in python target @@ -41,6 +40,5 @@ reactor Print { federated reactor DistributedCountDecentralized { c = new Count() p = new Print() - # Indicating a 'logical' connection with a large enough delay. - c.out -> p.in_ after 200 msec + c.out -> p.in_ after 200 msec # Indicating a 'logical' connection with a large enough delay. } diff --git a/test/Python/src/federated/DistributedCountPhysical.lf b/test/Python/src/federated/DistributedCountPhysical.lf index 69bc2faee9..c6ef7e2425 100644 --- a/test/Python/src/federated/DistributedCountPhysical.lf +++ b/test/Python/src/federated/DistributedCountPhysical.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf index 105413d0a0..065cfa83c4 100644 --- a/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf +++ b/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf b/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf index 0008479138..1b73f7e8e6 100644 --- a/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf +++ b/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/Python/src/federated/DistributedDoublePort.lf b/test/Python/src/federated/DistributedDoublePort.lf index 9eb24209e6..fe0a71dcc1 100644 --- a/test/Python/src/federated/DistributedDoublePort.lf +++ b/test/Python/src/federated/DistributedDoublePort.lf @@ -1,7 +1,6 @@ /** - * Test the case for when two upstream federates send messages to a downstream - * federte on two different ports. One message should carry a microstep delay - * relative to the other message. + * Test the case for when two upstream federates send messages to a downstream federte on two + * different ports. One message should carry a microstep delay relative to the other message. * * @author Soroush Bateni */ @@ -40,9 +39,7 @@ reactor Print { self.sys.exit(1) =} - reaction(shutdown) {= - print("SUCCESS: messages were at least one microstep apart.") - =} + reaction(shutdown) {= print("SUCCESS: messages were at least one microstep apart.") =} } federated reactor DistributedDoublePort { diff --git a/test/Python/src/federated/DistributedLoopedAction.lf b/test/Python/src/federated/DistributedLoopedAction.lf index 8f71d15363..a7564d5b28 100644 --- a/test/Python/src/federated/DistributedLoopedAction.lf +++ b/test/Python/src/federated/DistributedLoopedAction.lf @@ -1,6 +1,5 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. + * Test a sender-receiver network system that relies on microsteps being taken into account. * * @author Soroush Bateni */ @@ -18,8 +17,7 @@ reactor Receiver(take_a_break_after = 10, break_interval = 400 msec) { state breaks = 0 timer t(0, 1 msec) # This will impact the performance - # but forces the logical time to advance Comment this line for a more - # sensible log output. + # but forces the logical time to advance Comment this line for a more sensible log output. reaction(in_) {= print("At tag ({}, {}) received value {}.".format( lf.time.logical_elapsed(), diff --git a/test/Python/src/federated/DistributedLoopedPhysicalActionDecentralized.lf b/test/Python/src/federated/DistributedLoopedPhysicalActionDecentralized.lf index 626a416480..0cf1b5d22e 100644 --- a/test/Python/src/federated/DistributedLoopedPhysicalActionDecentralized.lf +++ b/test/Python/src/federated/DistributedLoopedPhysicalActionDecentralized.lf @@ -1,6 +1,5 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. + * Test a sender-receiver network system that relies on microsteps being taken into account. * * @author Soroush Bateni */ diff --git a/test/Python/src/federated/DistributedMultiportToken.lf b/test/Python/src/federated/DistributedMultiportToken.lf index 284e1c21a3..974f6f62fa 100644 --- a/test/Python/src/federated/DistributedMultiportToken.lf +++ b/test/Python/src/federated/DistributedMultiportToken.lf @@ -1,5 +1,5 @@ -# Check multiport connections between federates where the message is carried by -# a Token (in this case, with an array of char). +# Check multiport connections between federates where the message is carried by a Token (in this +# case, with an array of char). target Python { timeout: 1 sec, coordination: centralized diff --git a/test/Python/src/federated/DistributedStructParallel.lf b/test/Python/src/federated/DistributedStructParallel.lf index 300eb5fe9b..34a2f84e32 100644 --- a/test/Python/src/federated/DistributedStructParallel.lf +++ b/test/Python/src/federated/DistributedStructParallel.lf @@ -1,5 +1,5 @@ -# Source allocates a class object and then sends it to two reactors, each of -# which want to modify it. +# Source allocates a class object and then sends it to two reactors, each of which want to modify +# it. target Python { files: ["../include/hello.py"], timeout: 2 secs diff --git a/test/Python/src/federated/DistributedStructPrint.lf b/test/Python/src/federated/DistributedStructPrint.lf index 2c727d318e..b424dabacf 100644 --- a/test/Python/src/federated/DistributedStructPrint.lf +++ b/test/Python/src/federated/DistributedStructPrint.lf @@ -1,5 +1,5 @@ -# Source produces a dynamically allocated class object, which it passes to -# Print. Reference counting ensures that the struct is freed. +# Source produces a dynamically allocated class object, which it passes to Print. Reference counting +# ensures that the struct is freed. target Python { files: ["../include/hello.py"], timeout: 2 sec diff --git a/test/Python/src/federated/DistributedStructScale.lf b/test/Python/src/federated/DistributedStructScale.lf index c733367493..88867178f0 100644 --- a/test/Python/src/federated/DistributedStructScale.lf +++ b/test/Python/src/federated/DistributedStructScale.lf @@ -1,5 +1,5 @@ -# Source produces a dynamically allocated class object, which it passes to -# Scale. Scale modifies it and passes it to Print. +# Source produces a dynamically allocated class object, which it passes to Scale. Scale modifies it +# and passes it to Print. target Python { files: ["../include/hello.py"], timeout: 2 sec diff --git a/test/Python/src/federated/HelloDistributed.lf b/test/Python/src/federated/HelloDistributed.lf index ef99c3f793..a56bef1062 100644 --- a/test/Python/src/federated/HelloDistributed.lf +++ b/test/Python/src/federated/HelloDistributed.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python @@ -40,8 +39,7 @@ reactor Destination { } federated reactor HelloDistributed at localhost { - # reaction(startup) {= print("Printing something in top-level federated - # reactor.") + # reaction(startup) {= print("Printing something in top-level federated reactor.") # =} Reactor s is in federate Source s = new Source() d = new Destination() # Reactor d is in federate Destination diff --git a/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf b/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf index 2719fd57ba..d61fcc9100 100644 --- a/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf +++ b/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf @@ -1,7 +1,6 @@ /** - * This tests that the precedence order of reaction invocation is kept in the - * hierarchy of reactors when a feedback loop is present in centralized - * coordination. + * This tests that the precedence order of reaction invocation is kept in the hierarchy of reactors + * when a feedback loop is present in centralized coordination. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/Python/src/federated/PhysicalSTP.lf b/test/Python/src/federated/PhysicalSTP.lf index 5edc61df34..50ee659eb3 100644 --- a/test/Python/src/federated/PhysicalSTP.lf +++ b/test/Python/src/federated/PhysicalSTP.lf @@ -1,7 +1,4 @@ -/** - * This is a test that detects STP violations according to the physical time of - * message arrival. - */ +/** This is a test that detects STP violations according to the physical time of message arrival. */ target Python { timeout: 1900 msec, coordination: decentralized diff --git a/test/Python/src/federated/PingPongDistributed.lf b/test/Python/src/federated/PingPongDistributed.lf index 0f58cbf7db..0fc7cf3353 100644 --- a/test/Python/src/federated/PingPongDistributed.lf +++ b/test/Python/src/federated/PingPongDistributed.lf @@ -1,21 +1,19 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs - * and can be run on different machines. + * This is a distributed version, where Ping and Pong run in separate programs and can be run on + * different machines. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * Unthreaded: 97 msec Threaded: 265 msec Distributed: 53 seconds * - * There is no parallelism in this application, so it does not benefit from - * being being distributed. + * There is no parallelism in this application, so it does not benefit from being being distributed. * - * These measurements are total execution time, including startup and shutdown, - * of all three programs. + * These measurements are total execution time, including startup and shutdown, of all three + * programs. * * @author Edward A. Lee */ diff --git a/test/Python/src/lib/Imported.lf b/test/Python/src/lib/Imported.lf index 71d7558383..f59f1e9dee 100644 --- a/test/Python/src/lib/Imported.lf +++ b/test/Python/src/lib/Imported.lf @@ -1,5 +1,5 @@ -# This is used by the test for the ability to import a reactor definition that -# itself imports a reactor definition. +# This is used by the test for the ability to import a reactor definition that itself imports a +# reactor definition. target Python import ImportedAgain from "./ImportedAgain.lf" diff --git a/test/Python/src/lib/ImportedAgain.lf b/test/Python/src/lib/ImportedAgain.lf index cb877da53c..f29a5e6c83 100644 --- a/test/Python/src/lib/ImportedAgain.lf +++ b/test/Python/src/lib/ImportedAgain.lf @@ -1,5 +1,5 @@ -# This is used by the test for the ability to import a reactor definition that -# itself imports a reactor definition. +# This is used by the test for the ability to import a reactor definition that itself imports a +# reactor definition. target Python reactor ImportedAgain { # import Imported from "Imported.lf" diff --git a/test/Python/src/lib/ImportedComposition.lf b/test/Python/src/lib/ImportedComposition.lf index 56010ce509..be1cdfb1a8 100644 --- a/test/Python/src/lib/ImportedComposition.lf +++ b/test/Python/src/lib/ImportedComposition.lf @@ -1,5 +1,5 @@ -# This is used by the test for the ability to import a reactor definition that -# itself imports a reactor definition. +# This is used by the test for the ability to import a reactor definition that itself imports a +# reactor definition. target Python reactor Gain { diff --git a/test/Python/src/lib/LoopedActionSender.lf b/test/Python/src/lib/LoopedActionSender.lf index 9d4048d0ea..674256ea45 100644 --- a/test/Python/src/lib/LoopedActionSender.lf +++ b/test/Python/src/lib/LoopedActionSender.lf @@ -6,10 +6,9 @@ target Python /** - * @param take_a_break_after: Indicates how many messages are sent in - * consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break - * after sending take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break after sending + * take_a_break_after messages. */ reactor Sender(take_a_break_after = 10, break_interval = 400 msec) { output out diff --git a/test/Python/src/lib/TestCount.lf b/test/Python/src/lib/TestCount.lf index de611cbc69..eb214fe25d 100644 --- a/test/Python/src/lib/TestCount.lf +++ b/test/Python/src/lib/TestCount.lf @@ -1,7 +1,6 @@ /** - * Test that a counting sequence of inputs starts with the specified start - * parameter value, increments by the specified stride, and receives the - * specified number of inputs. + * Test that a counting sequence of inputs starts with the specified start parameter value, + * increments by the specified stride, and receives the specified number of inputs. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. diff --git a/test/Python/src/lib/TestCountMultiport.lf b/test/Python/src/lib/TestCountMultiport.lf index c30572e4d5..d584401bfa 100644 --- a/test/Python/src/lib/TestCountMultiport.lf +++ b/test/Python/src/lib/TestCountMultiport.lf @@ -1,13 +1,12 @@ /** - * Test that a counting sequence of inputs starts with the specified start - * parameter value, increments by the specified stride, and receives the - * specified number of inputs. This version has a multiport input, and each - * input is expected to be present and incremented over the previous input. + * Test that a counting sequence of inputs starts with the specified start parameter value, + * increments by the specified stride, and receives the specified number of inputs. This version has + * a multiport input, and each input is expected to be present and incremented over the previous + * input. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. - * @param num_inputs The number of inputs expected on each channel. Default is - * 1. + * @param num_inputs The number of inputs expected on each channel. Default is 1. */ target Python diff --git a/test/Python/src/modal_models/BanksModalStateReset.lf b/test/Python/src/modal_models/BanksModalStateReset.lf index f96a7bd638..00a1a7ca4f 100644 --- a/test/Python/src/modal_models/BanksModalStateReset.lf +++ b/test/Python/src/modal_models/BanksModalStateReset.lf @@ -1,7 +1,4 @@ -/** - * Modal Reactor Test. Tests reset of state variables in modes with banks of - * reactors. - */ +/** Modal Reactor Test. Tests reset of state variables in modes with banks of reactors. */ target Python { fast: false, timeout: 4 sec @@ -48,8 +45,7 @@ main reactor { reset2.count2 -> test.events - # Trigger mode change (separately because of #1278) - reaction(stepper) -> reset1.next {= + reaction(stepper) -> reset1.next {= # Trigger mode change (separately because of #1278) for i in range(len(reset1)): reset1[i].next.set(True) =} diff --git a/test/Python/src/modal_models/ConvertCaseTest.lf b/test/Python/src/modal_models/ConvertCaseTest.lf index f3bdee59fe..3f31a7100b 100644 --- a/test/Python/src/modal_models/ConvertCaseTest.lf +++ b/test/Python/src/modal_models/ConvertCaseTest.lf @@ -113,9 +113,7 @@ main reactor { history_processor.discard.set(True) =} - reaction(reset_processor.converted) {= - print(f"Reset: {reset_processor.converted.value}") - =} + reaction(reset_processor.converted) {= print(f"Reset: {reset_processor.converted.value}") =} reaction(history_processor.converted) {= print(f"History: {history_processor.converted.value}") diff --git a/test/Python/src/modal_models/ModalActions.lf b/test/Python/src/modal_models/ModalActions.lf index b74f92f3c9..2d148e89ef 100644 --- a/test/Python/src/modal_models/ModalActions.lf +++ b/test/Python/src/modal_models/ModalActions.lf @@ -1,6 +1,6 @@ /** - * Modal Reactor Test. Tests actions, their suspension during mode inactivity - * and continuation of delays with history transitions. + * Modal Reactor Test. Tests actions, their suspension during mode inactivity and continuation of + * delays with history transitions. */ target Python { fast: false, @@ -90,6 +90,5 @@ main reactor { modal.action2_exec -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalCycleBreaker.lf b/test/Python/src/modal_models/ModalCycleBreaker.lf index 1ceb2eb5d0..d3af61d142 100644 --- a/test/Python/src/modal_models/ModalCycleBreaker.lf +++ b/test/Python/src/modal_models/ModalCycleBreaker.lf @@ -1,8 +1,8 @@ /** * Modal Reactor Test. * - * Tests if connections in the same reactor that have the same destination work - * if they are located in separate modes. + * Tests if connections in the same reactor that have the same destination work if they are located + * in separate modes. */ target Python { fast: false, @@ -16,9 +16,7 @@ reactor Modal { input in2 output out - # Defining reaction to in2 before in1 would cause cycle if no mode were - # present - mode Two { + mode Two { # Defining reaction to in2 before in1 would cause cycle if no mode were present timer wait(150 msec, 1 sec) reaction(in2) {= =} diff --git a/test/Python/src/modal_models/ModalNestedReactions.lf b/test/Python/src/modal_models/ModalNestedReactions.lf index d699adc737..67247ac12f 100644 --- a/test/Python/src/modal_models/ModalNestedReactions.lf +++ b/test/Python/src/modal_models/ModalNestedReactions.lf @@ -1,7 +1,4 @@ -/** - * Modal Reactor Test. Checks disabling of reactions indirectly nested in an - * inactive mode - */ +/** Modal Reactor Test. Checks disabling of reactions indirectly nested in an inactive mode */ target Python { fast: false, timeout: 2 sec diff --git a/test/Python/src/modal_models/ModalStartupShutdown.lf b/test/Python/src/modal_models/ModalStartupShutdown.lf index c7a868eeca..ba8439e276 100644 --- a/test/Python/src/modal_models/ModalStartupShutdown.lf +++ b/test/Python/src/modal_models/ModalStartupShutdown.lf @@ -137,6 +137,5 @@ main reactor { modal.shutdown5 -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalStateReset.lf b/test/Python/src/modal_models/ModalStateReset.lf index 11b7425b63..d52161cede 100644 --- a/test/Python/src/modal_models/ModalStateReset.lf +++ b/test/Python/src/modal_models/ModalStateReset.lf @@ -87,6 +87,5 @@ main reactor { modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalStateResetAuto.lf b/test/Python/src/modal_models/ModalStateResetAuto.lf index 492e12259b..a8348592a5 100644 --- a/test/Python/src/modal_models/ModalStateResetAuto.lf +++ b/test/Python/src/modal_models/ModalStateResetAuto.lf @@ -83,6 +83,5 @@ main reactor { modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalTimers.lf b/test/Python/src/modal_models/ModalTimers.lf index 271a19ec38..8198e5dcb1 100644 --- a/test/Python/src/modal_models/ModalTimers.lf +++ b/test/Python/src/modal_models/ModalTimers.lf @@ -62,6 +62,5 @@ main reactor { modal.mode_switch, modal.timer1, modal.timer2 -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf b/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf index 3dd42f67ce..274d97a9f7 100644 --- a/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf +++ b/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf @@ -1,8 +1,8 @@ /** * Modal Reactor Test. * - * Tests if connections in the same reactor that have the same destination work - * if they are located in separate modes. + * Tests if connections in the same reactor that have the same destination work if they are located + * in separate modes. */ target Python { fast: false, @@ -66,9 +66,7 @@ main reactor { modal.count -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change - # Print - reaction(modal.count) {= print(modal.count.value) =} + reaction(modal.count) {= print(modal.count.value) =} # Print } diff --git a/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf b/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf index 86f5668357..bda602904e 100644 --- a/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf +++ b/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf @@ -1,8 +1,8 @@ /** * Modal Reactor Test. * - * Tests if a connection and a reaction in the same reactor can have the same - * destination if they are located in separate modes. + * Tests if a connection and a reaction in the same reactor can have the same destination if they + * are located in separate modes. */ target Python { fast: false, @@ -23,9 +23,7 @@ reactor Modal { mode Two { counter2 = new Counter(period = 100 msec) - reaction(counter2.value) -> count {= - count.set(counter2.value.value * 10) - =} + reaction(counter2.value) -> count {= count.set(counter2.value.value * 10) =} reaction(next) -> history(One) {= One.set() =} } @@ -69,9 +67,7 @@ main reactor { modal.count -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change - # Print - reaction(modal.count) {= print(modal.count.value) =} + reaction(modal.count) {= print(modal.count.value) =} # Print } diff --git a/test/Python/src/multiport/BankReactionsInContainer.lf b/test/Python/src/multiport/BankReactionsInContainer.lf index 7316463c3d..c4eabf8d19 100644 --- a/test/Python/src/multiport/BankReactionsInContainer.lf +++ b/test/Python/src/multiport/BankReactionsInContainer.lf @@ -1,6 +1,4 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target Python { timeout: 1 sec } diff --git a/test/Python/src/multiport/MultiportFromBank.lf b/test/Python/src/multiport/MultiportFromBank.lf index 92d9363df5..092458f76d 100644 --- a/test/Python/src/multiport/MultiportFromBank.lf +++ b/test/Python/src/multiport/MultiportFromBank.lf @@ -1,5 +1,5 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than -# the width of the sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +# sending port. target Python { timeout: 2 sec, fast: true @@ -8,9 +8,7 @@ target Python { reactor Source(check_override = 0, bank_index = 0) { output out - reaction(startup) -> out {= - out.set(self.bank_index * self.check_override) - =} + reaction(startup) -> out {= out.set(self.bank_index * self.check_override) =} } reactor Destination { diff --git a/test/Python/src/multiport/MultiportFromBankHierarchy.lf b/test/Python/src/multiport/MultiportFromBankHierarchy.lf index 27ecb3c80b..13cf078224 100644 --- a/test/Python/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/Python/src/multiport/MultiportFromBankHierarchy.lf @@ -1,5 +1,5 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than -# the width of the sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +# sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/Python/src/multiport/MultiportFromBankHierarchyAfter.lf index 6b03d766ea..2466b78574 100644 --- a/test/Python/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/Python/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,5 +1,5 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than -# the width of the sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +# sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportFromHierarchy.lf b/test/Python/src/multiport/MultiportFromHierarchy.lf index 4116587f01..83cdcad88a 100644 --- a/test/Python/src/multiport/MultiportFromHierarchy.lf +++ b/test/Python/src/multiport/MultiportFromHierarchy.lf @@ -1,5 +1,4 @@ -# Check multiport output to multiport input, where the former is a hierarchical -# reactor. +# Check multiport output to multiport input, where the former is a hierarchical reactor. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportIn.lf b/test/Python/src/multiport/MultiportIn.lf index 35bdee7341..feb5ef6d03 100644 --- a/test/Python/src/multiport/MultiportIn.lf +++ b/test/Python/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -# This is a version fo the Threaded test that uses a multiport input at the -# destination. Its purpose is to test multiport inputs. +# This is a version fo the Threaded test that uses a multiport input at the destination. Its purpose +# is to test multiport inputs. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportInParameterized.lf b/test/Python/src/multiport/MultiportInParameterized.lf index 28b15808e3..ca10b50175 100644 --- a/test/Python/src/multiport/MultiportInParameterized.lf +++ b/test/Python/src/multiport/MultiportInParameterized.lf @@ -1,5 +1,5 @@ -# This is a version of the Threaded test that uses a multiport input at the -# destination. Its purpose is to test multiport inputs. +# This is a version of the Threaded test that uses a multiport input at the destination. Its purpose +# is to test multiport inputs. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportMutableInput.lf b/test/Python/src/multiport/MultiportMutableInput.lf index f931900ef7..e12855db04 100644 --- a/test/Python/src/multiport/MultiportMutableInput.lf +++ b/test/Python/src/multiport/MultiportMutableInput.lf @@ -1,6 +1,5 @@ -# Source produces a ints on a multiport, which it passes to Scale. Scale -# requests a writable copy. It modifies it and passes it to Print. It gets freed -# after Print is done with it. +# Source produces a ints on a multiport, which it passes to Scale. Scale requests a writable copy. +# It modifies it and passes it to Print. It gets freed after Print is done with it. target Python reactor Source { diff --git a/test/Python/src/multiport/MultiportMutableInputArray.lf b/test/Python/src/multiport/MultiportMutableInputArray.lf index 9efa3eeebf..5e37ccd6b2 100644 --- a/test/Python/src/multiport/MultiportMutableInputArray.lf +++ b/test/Python/src/multiport/MultiportMutableInputArray.lf @@ -1,7 +1,6 @@ -# Source produces a list on a multiport, which it passes to Scale. Scale -# requests a writable copy, which, instead of copying, it just gets ownership of -# the original list. It modifies it and passes it to Print. It gets freed after -# Print is done with it. +# Source produces a list on a multiport, which it passes to Scale. Scale requests a writable copy, +# which, instead of copying, it just gets ownership of the original list. It modifies it and passes +# it to Print. It gets freed after Print is done with it. target Python reactor Source { diff --git a/test/Python/src/multiport/MultiportToBankAfter.lf b/test/Python/src/multiport/MultiportToBankAfter.lf index 85fc91e513..6d3f6e7ed4 100644 --- a/test/Python/src/multiport/MultiportToBankAfter.lf +++ b/test/Python/src/multiport/MultiportToBankAfter.lf @@ -1,5 +1,4 @@ -# Check multiport output to bank of recipients where the width of the bank is -# inferred. +# Check multiport output to bank of recipients where the width of the bank is inferred. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportToBankHierarchy.lf b/test/Python/src/multiport/MultiportToBankHierarchy.lf index f70fa8ad92..bef01b8d89 100644 --- a/test/Python/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Python/src/multiport/MultiportToBankHierarchy.lf @@ -1,5 +1,5 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than -# the width of the sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +# sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportToHierarchy.lf b/test/Python/src/multiport/MultiportToHierarchy.lf index 2a9e25a5e6..1e525b621d 100644 --- a/test/Python/src/multiport/MultiportToHierarchy.lf +++ b/test/Python/src/multiport/MultiportToHierarchy.lf @@ -1,6 +1,5 @@ -# Check multiport output to multiport input, where the latter is a hierarchical -# reactor. Note that the destination reactor has width wider than the sender, so -# one input is dangling. +# Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that +# the destination reactor has width wider than the sender, so one input is dangling. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportToMultiportArray.lf b/test/Python/src/multiport/MultiportToMultiportArray.lf index 5eb043570d..42e885ea37 100644 --- a/test/Python/src/multiport/MultiportToMultiportArray.lf +++ b/test/Python/src/multiport/MultiportToMultiportArray.lf @@ -1,5 +1,4 @@ -# Check multiport output to multiport input. Destination port is wider than -# sending port. +# Check multiport output to multiport input. Destination port is wider than sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportToPort.lf b/test/Python/src/multiport/MultiportToPort.lf index ebfbf81991..893ad600b0 100644 --- a/test/Python/src/multiport/MultiportToPort.lf +++ b/test/Python/src/multiport/MultiportToPort.lf @@ -1,5 +1,4 @@ -# Check multiport output to multiport input. Destination port is wider than -# sending port. +# Check multiport output to multiport input. Destination port is wider than sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/ReactionsToNested.lf b/test/Python/src/multiport/ReactionsToNested.lf index 2c207dffb0..5d1046fa24 100644 --- a/test/Python/src/multiport/ReactionsToNested.lf +++ b/test/Python/src/multiport/ReactionsToNested.lf @@ -1,5 +1,4 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { timeout: 1 sec } diff --git a/test/Python/src/serialization/PersonProtocolBuffers.lf b/test/Python/src/serialization/PersonProtocolBuffers.lf index 2d5519fbcb..530df50d8d 100644 --- a/test/Python/src/serialization/PersonProtocolBuffers.lf +++ b/test/Python/src/serialization/PersonProtocolBuffers.lf @@ -1,23 +1,21 @@ /** - * This example demonstrates a very simple use of protocol buffers within a - * reactor. It encodes and decodes a very simple protocol buffer definition in - * Person.proto. This reactor is heavily based on the examples at - * https://github.com/protobuf-c/protobuf-c/wiki/Examples. This example just + * This example demonstrates a very simple use of protocol buffers within a reactor. It encodes and + * decodes a very simple protocol buffer definition in Person.proto. This reactor is heavily based + * on the examples at https://github.com/protobuf-c/protobuf-c/wiki/Examples. This example just * packs and unpacks a message. * * To run this example first install the protocol buffers compiler from - * https://github.com/protocolbuffers/protobuf. It is also available from - * homebrew on a Mac via + * https://github.com/protocolbuffers/protobuf. It is also available from homebrew on a Mac via * * $ brew install protobuf * - * Building protobuf from source is slow, so avoid doing that if possible. Next, - * install the Google APIs for Python + * Building protobuf from source is slow, so avoid doing that if possible. Next, install the Google + * APIs for Python * * $ pip3 install --upgrade google-api-python-client * - * The code generator assumes that executables are installed within the PATH. On - * a Mac, this is typically at /usr/local/bin. + * The code generator assumes that executables are installed within the PATH. On a Mac, this is + * typically at /usr/local/bin. */ target Python { protobufs: Person.proto diff --git a/test/Python/src/serialization/ProtoNoPacking.lf b/test/Python/src/serialization/ProtoNoPacking.lf index 6cf4a0b789..92e04fd5f5 100644 --- a/test/Python/src/serialization/ProtoNoPacking.lf +++ b/test/Python/src/serialization/ProtoNoPacking.lf @@ -1,22 +1,20 @@ /** - * This example creates a Protocol Buffer message and passes it to another - * reactor without packing and unpacking. This demonstrates that local - * communication, within one shared-memory machine, need not incur the overhead - * of packing and unpacking. + * This example creates a Protocol Buffer message and passes it to another reactor without packing + * and unpacking. This demonstrates that local communication, within one shared-memory machine, need + * not incur the overhead of packing and unpacking. * * To run this example first install the protocol buffers compiler from - * https://github.com/protocolbuffers/protobuf. It is also available from - * homebrew on a Mac via + * https://github.com/protocolbuffers/protobuf. It is also available from homebrew on a Mac via * * $ brew install protobuf * - * Building protobuf from source is slow, so avoid doing that if possible. Next, - * install the Google APIs for Python + * Building protobuf from source is slow, so avoid doing that if possible. Next, install the Google + * APIs for Python * * $ pip3 install --upgrade google-api-python-client * - * The code generator assumes that executables are installed within the PATH. On - * a Mac, this is typically at /usr/local/bin. + * The code generator assumes that executables are installed within the PATH. On a Mac, this is + * typically at /usr/local/bin. */ target Python { protobufs: ProtoHelloWorld.proto diff --git a/test/Python/src/target/AfterNoTypes.lf b/test/Python/src/target/AfterNoTypes.lf index 44aaa89c73..fb5597e863 100644 --- a/test/Python/src/target/AfterNoTypes.lf +++ b/test/Python/src/target/AfterNoTypes.lf @@ -1,5 +1,5 @@ -# This test demonstrates that after can be used on connections with ports that -# have no types. The test passes if the compile is succeeded +# This test demonstrates that after can be used on connections with ports that have no types. The +# test passes if the compile is succeeded target Python { fast: false, timeout: 3 sec diff --git a/test/Rust/src/ActionValuesCleanup.lf b/test/Rust/src/ActionValuesCleanup.lf index f4bab7a2b5..6bda6e9fd6 100644 --- a/test/Rust/src/ActionValuesCleanup.lf +++ b/test/Rust/src/ActionValuesCleanup.lf @@ -22,9 +22,7 @@ main reactor ActionValuesCleanup { logical action act: FooDrop state count: u32 = 0 - reaction(startup) -> act {= - ctx.schedule_with_v(act, Some(FooDrop { }), Asap) - =} + reaction(startup) -> act {= ctx.schedule_with_v(act, Some(FooDrop { }), Asap) =} reaction(act) -> act {= ctx.use_ref(act, |v| println!("{:?}", v)); diff --git a/test/Rust/src/CompositionInitializationOrder.lf b/test/Rust/src/CompositionInitializationOrder.lf index 4c2a428f10..283923d9be 100644 --- a/test/Rust/src/CompositionInitializationOrder.lf +++ b/test/Rust/src/CompositionInitializationOrder.lf @@ -1,5 +1,4 @@ -// This test asserts the relative execution order of startup reactions within a -// composite reactor. +// This test asserts the relative execution order of startup reactions within a composite reactor. target Rust main reactor CompositionInitializationOrder { diff --git a/test/Rust/src/DependencyOnChildPort.lf b/test/Rust/src/DependencyOnChildPort.lf index ed8b6b2120..18ad405da2 100644 --- a/test/Rust/src/DependencyOnChildPort.lf +++ b/test/Rust/src/DependencyOnChildPort.lf @@ -18,9 +18,7 @@ main reactor { reaction(startup) -> box0.inp {= ctx.set(box0__inp, 444); =} - reaction(box1.out) {= - assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; - =} + reaction(box1.out) {= assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; =} reaction(shutdown) {= assert!(self.done, "reaction was not executed"); diff --git a/test/Rust/src/DependencyUseAccessible.lf b/test/Rust/src/DependencyUseAccessible.lf index 9b67fb510e..28afec9bc6 100644 --- a/test/Rust/src/DependencyUseAccessible.lf +++ b/test/Rust/src/DependencyUseAccessible.lf @@ -12,8 +12,7 @@ reactor Source { reaction(t1) -> clock, o1 {= ctx.set(clock, 1); ctx.set(o1, 10) =} - // has a dependency but doesn't use it - reaction(t2) -> clock, o2 {= ctx.set(clock, 2); =} + reaction(t2) -> clock, o2 {= ctx.set(clock, 2); =} // has a dependency but doesn't use it } reactor Sink { diff --git a/test/Rust/src/Import.lf b/test/Rust/src/Import.lf index dd40ad064d..15837b9c4c 100644 --- a/test/Rust/src/Import.lf +++ b/test/Rust/src/Import.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target Rust import Imported from "lib/Imported.lf" diff --git a/test/Rust/src/ImportPreambleItem.lf b/test/Rust/src/ImportPreambleItem.lf index e532f74c70..2abd438fb6 100644 --- a/test/Rust/src/ImportPreambleItem.lf +++ b/test/Rust/src/ImportPreambleItem.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target Rust import SomethingWithAPreamble from "lib/SomethingWithAPreamble.lf" @@ -7,7 +6,5 @@ import SomethingWithAPreamble from "lib/SomethingWithAPreamble.lf" main reactor { r = new SomethingWithAPreamble() - reaction(startup) -> r.a {= - ctx.set(r__a, super::something_with_a_preamble::some_fun()); - =} + reaction(startup) -> r.a {= ctx.set(r__a, super::something_with_a_preamble::some_fun()); =} } diff --git a/test/Rust/src/PhysicalActionCanBeScheduledSynchronously.lf b/test/Rust/src/PhysicalActionCanBeScheduledSynchronously.lf index 206a3d7d1c..faa4f54252 100644 --- a/test/Rust/src/PhysicalActionCanBeScheduledSynchronously.lf +++ b/test/Rust/src/PhysicalActionCanBeScheduledSynchronously.lf @@ -1,5 +1,4 @@ -// Tests that physical actions can be scheduled like logical actions within the -// body of reactions. +// Tests that physical actions can be scheduled like logical actions within the body of reactions. target Rust main reactor { diff --git a/test/Rust/src/PhysicalActionKeepaliveIsSmart.lf b/test/Rust/src/PhysicalActionKeepaliveIsSmart.lf index 1e578892d1..a34daa21e0 100644 --- a/test/Rust/src/PhysicalActionKeepaliveIsSmart.lf +++ b/test/Rust/src/PhysicalActionKeepaliveIsSmart.lf @@ -1,5 +1,5 @@ -// Tests that the scheduler ends up shutting down if there are no live Sender -// that can send messages back to the scheduler. +// Tests that the scheduler ends up shutting down if there are no live Sender that can send messages +// back to the scheduler. target Rust { keepalive: true } diff --git a/test/Rust/src/PhysicalActionWakesSleepingScheduler.lf b/test/Rust/src/PhysicalActionWakesSleepingScheduler.lf index 27b5f36af8..f1f8c154b0 100644 --- a/test/Rust/src/PhysicalActionWakesSleepingScheduler.lf +++ b/test/Rust/src/PhysicalActionWakesSleepingScheduler.lf @@ -1,11 +1,9 @@ -// Tests that, given a logical event scheduled far away in the future (which -// puts the scheduler to sleep), and a physical action being triggered -// asynchronously during that sleep time, the scheduler wakes up and processes -// the physical action before the logical action. This test is unfortunately not -// very reliable, as the sleeping thread may wake up very late depending on the -// platform and the weather. The test has already failed in CI on macos, because -// the action was triggered at (T0+135ms), that is, 115ms later than the -// expected wake up time (T0+20ms). +// Tests that, given a logical event scheduled far away in the future (which puts the scheduler to +// sleep), and a physical action being triggered asynchronously during that sleep time, the +// scheduler wakes up and processes the physical action before the logical action. This test is +// unfortunately not very reliable, as the sleeping thread may wake up very late depending on the +// platform and the weather. The test has already failed in CI on macos, because the action was +// triggered at (T0+135ms), that is, 115ms later than the expected wake up time (T0+20ms). target Rust main reactor { diff --git a/test/Rust/src/ReactionLabels.lf b/test/Rust/src/ReactionLabels.lf index c696ab85c2..6547792d8c 100644 --- a/test/Rust/src/ReactionLabels.lf +++ b/test/Rust/src/ReactionLabels.lf @@ -1,5 +1,5 @@ -// There was a bug whereby reaction labels mess up generated code. Labels are -// used as debug info by the runtime. +// There was a bug whereby reaction labels mess up generated code. Labels are used as debug info by +// the runtime. target Rust main reactor { diff --git a/test/Rust/src/ReservedKeywords.lf b/test/Rust/src/ReservedKeywords.lf index 5d30ba63a4..ef11dda278 100644 --- a/test/Rust/src/ReservedKeywords.lf +++ b/test/Rust/src/ReservedKeywords.lf @@ -1,5 +1,4 @@ -// Tests that rust keywords may be used as identifiers in LF and are properly -// escaped by the emitter +// Tests that rust keywords may be used as identifiers in LF and are properly escaped by the emitter target Rust reactor box { diff --git a/test/Rust/src/StateInitializerVisibility.lf b/test/Rust/src/StateInitializerVisibility.lf index d192f0ca98..f7da9a48d4 100644 --- a/test/Rust/src/StateInitializerVisibility.lf +++ b/test/Rust/src/StateInitializerVisibility.lf @@ -1,5 +1,5 @@ -// Tests that state vars are accessible within initializers of other state vars -// declared further down. +// Tests that state vars are accessible within initializers of other state vars declared further +// down. target Rust main reactor { diff --git a/test/Rust/src/Stop.lf b/test/Rust/src/Stop.lf index c43f8c30ff..80960ef142 100644 --- a/test/Rust/src/Stop.lf +++ b/test/Rust/src/Stop.lf @@ -8,10 +8,9 @@ target Rust { } /** - * @param take_a_break_after: Indicates how many messages are sent in - * consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break - * after sending take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break after sending + * take_a_break_after messages. */ reactor Sender(take_a_break_after: u32 = 10, break_interval: time = 400 msec) { output out: u32 diff --git a/test/Rust/src/StopNoEvent.lf b/test/Rust/src/StopNoEvent.lf index ae84b0bfbd..5ee2639fa2 100644 --- a/test/Rust/src/StopNoEvent.lf +++ b/test/Rust/src/StopNoEvent.lf @@ -1,7 +1,4 @@ -/** - * Tests that `shutdown` is triggered even if the program exits because of an - * empty event queue. - */ +/** Tests that `shutdown` is triggered even if the program exits because of an empty event queue. */ target Rust main reactor StopNoEvent { diff --git a/test/Rust/src/StopTimeout.lf b/test/Rust/src/StopTimeout.lf index 16fec44bb3..7ebf1595e4 100644 --- a/test/Rust/src/StopTimeout.lf +++ b/test/Rust/src/StopTimeout.lf @@ -1,6 +1,5 @@ /** - * Tests that `shutdown` is triggered even if the program exits because of - * timeout target property. + * Tests that `shutdown` is triggered even if the program exits because of timeout target property. */ target Rust { timeout: 30 msec diff --git a/test/Rust/src/StopTimeoutExact.lf b/test/Rust/src/StopTimeoutExact.lf index 2b9eb85cda..cd81e7923d 100644 --- a/test/Rust/src/StopTimeoutExact.lf +++ b/test/Rust/src/StopTimeoutExact.lf @@ -1,6 +1,6 @@ /** - * Tests that when a timeout coincides with a scheduled event, all scheduled - * reactions are properly executed (in addition to the shutdown ones). + * Tests that when a timeout coincides with a scheduled event, all scheduled reactions are properly + * executed (in addition to the shutdown ones). */ target Rust { timeout: 50 msec diff --git a/test/Rust/src/StructAsState.lf b/test/Rust/src/StructAsState.lf index 9b35e7a3fb..22565b58e9 100644 --- a/test/Rust/src/StructAsState.lf +++ b/test/Rust/src/StructAsState.lf @@ -1,5 +1,5 @@ -// Check that a state variable can have a statically initialized struct as a -// value. Check how preambles work +// Check that a state variable can have a statically initialized struct as a value. Check how +// preambles work target Rust main reactor StructAsState { diff --git a/test/Rust/src/generics/GenericReactor.lf b/test/Rust/src/generics/GenericReactor.lf index 3190524a5b..9715d7e0a3 100644 --- a/test/Rust/src/generics/GenericReactor.lf +++ b/test/Rust/src/generics/GenericReactor.lf @@ -18,9 +18,7 @@ main reactor { reaction(startup) -> box0.inp {= ctx.set(box0__inp, 444); =} - reaction(box1.out) {= - assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; - =} + reaction(box1.out) {= assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; =} reaction(shutdown) {= assert!(self.done, "reaction was not executed"); diff --git a/test/Rust/src/lib/Imported.lf b/test/Rust/src/lib/Imported.lf index 989f9d7168..8a33aa04b8 100644 --- a/test/Rust/src/lib/Imported.lf +++ b/test/Rust/src/lib/Imported.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target Rust import ImportedAgain from "ImportedAgain.lf" diff --git a/test/Rust/src/lib/ImportedAgain.lf b/test/Rust/src/lib/ImportedAgain.lf index 7e61e9a575..d1bd87c4f1 100644 --- a/test/Rust/src/lib/ImportedAgain.lf +++ b/test/Rust/src/lib/ImportedAgain.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target Rust reactor ImportedAgain { diff --git a/test/Rust/src/lib/SomethingWithAPreamble.lf b/test/Rust/src/lib/SomethingWithAPreamble.lf index 961a64f32d..d63f7c381a 100644 --- a/test/Rust/src/lib/SomethingWithAPreamble.lf +++ b/test/Rust/src/lib/SomethingWithAPreamble.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target Rust reactor SomethingWithAPreamble { diff --git a/test/Rust/src/multiport/CycledLhs_SelfLoop.lf b/test/Rust/src/multiport/CycledLhs_SelfLoop.lf index 925fafce21..5eb3cc226c 100644 --- a/test/Rust/src/multiport/CycledLhs_SelfLoop.lf +++ b/test/Rust/src/multiport/CycledLhs_SelfLoop.lf @@ -1,5 +1,5 @@ -// test a cycled connection which has ports of the same reactor on the LHS and -// rhs (single port)+ -> multiport +// test a cycled connection which has ports of the same reactor on the LHS and rhs (single port)+ -> +// multiport target Rust { timeout: 16 usec } @@ -10,9 +10,7 @@ reactor Test { logical action act: u32 state last: u32 = 1 - reaction(startup) -> act {= - ctx.schedule_with_v(act, Some(1), after!(1 us)); - =} + reaction(startup) -> act {= ctx.schedule_with_v(act, Some(1), after!(1 us)); =} reaction(act) -> out {= ctx.set_opt(out, ctx.get(act)); =} diff --git a/test/Rust/src/multiport/CycledLhs_Single.lf b/test/Rust/src/multiport/CycledLhs_Single.lf index 2fdd5c605c..62723bda42 100644 --- a/test/Rust/src/multiport/CycledLhs_Single.lf +++ b/test/Rust/src/multiport/CycledLhs_Single.lf @@ -1,5 +1,5 @@ -// test a cycled connection which has ports of the same reactor on the LHS and -// rhs (multiport)+ -> multiport +// test a cycled connection which has ports of the same reactor on the LHS and rhs (multiport)+ -> +// multiport target Rust { timeout: 16 usec } @@ -10,9 +10,7 @@ reactor Test { logical action act: {= (u32, u32) =} state last: u32 = 1 - reaction(startup) -> act {= - ctx.schedule_with_v(act, Some((0, 1)), after!(1 us)); - =} + reaction(startup) -> act {= ctx.schedule_with_v(act, Some((0, 1)), after!(1 us)); =} reaction(act) -> out {= let (a, b) = ctx.get(act).unwrap(); @@ -41,9 +39,9 @@ reactor Test { } /** - * 0 + 1 = 1 1 + 1 = 2 1 + 2 = 3 2 + 3 = 5 3 + 5 = 8 5 + 8 = 13 8 + 13 = 21 13 + - * 21 = 34 21 + 34 = 55 34 + 55 = 89 55 + 89 = 144 89 + 144 = 233 144 + 233 = - * 377 233 + 377 = 610 377 + 610 = 987 610 + 987 = 1597 987 + 1597 = 2584 + * 0 + 1 = 1 1 + 1 = 2 1 + 2 = 3 2 + 3 = 5 3 + 5 = 8 5 + 8 = 13 8 + 13 = 21 13 + 21 = 34 21 + 34 = + * 55 34 + 55 = 89 55 + 89 = 144 89 + 144 = 233 144 + 233 = 377 233 + 377 = 610 377 + 610 = 987 610 + * + 987 = 1597 987 + 1597 = 2584 */ main reactor { t = new Test() diff --git a/test/Rust/src/multiport/MultiportFromHierarchy.lf b/test/Rust/src/multiport/MultiportFromHierarchy.lf index d2af4253c4..400dfff7d9 100644 --- a/test/Rust/src/multiport/MultiportFromHierarchy.lf +++ b/test/Rust/src/multiport/MultiportFromHierarchy.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input, where the former is a hierarchical -// reactor. +// Check multiport output to multiport input, where the former is a hierarchical reactor. target Rust { timeout: 2 sec } diff --git a/test/Rust/src/multiport/MultiportIn.lf b/test/Rust/src/multiport/MultiportIn.lf index 4ebf1c56d5..27b3522449 100644 --- a/test/Rust/src/multiport/MultiportIn.lf +++ b/test/Rust/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -// This is a version fo the Threaded test that uses a multiport input at the -// destination. Its purpose is to test multiport inputs. +// This is a version fo the Threaded test that uses a multiport input at the destination. Its +// purpose is to test multiport inputs. target Rust { timeout: 2 sec, fast: true diff --git a/test/Rust/src/multiport/MultiportToMultiport2.lf b/test/Rust/src/multiport/MultiportToMultiport2.lf index a1e2db235d..0c79ee17d4 100644 --- a/test/Rust/src/multiport/MultiportToMultiport2.lf +++ b/test/Rust/src/multiport/MultiportToMultiport2.lf @@ -1,5 +1,4 @@ -// test a sparse connection between multiports (some channels are left -// disconnected) +// test a sparse connection between multiports (some channels are left disconnected) target Rust reactor Source(width: usize = 2) { diff --git a/test/Rust/src/target/BuildProfileDefaultIsDev.lf b/test/Rust/src/target/BuildProfileDefaultIsDev.lf index b27f66a2d0..e45c442406 100644 --- a/test/Rust/src/target/BuildProfileDefaultIsDev.lf +++ b/test/Rust/src/target/BuildProfileDefaultIsDev.lf @@ -1,5 +1,5 @@ -// Tests that the default build profile is dev. A proxy for checking this is to -// check that debug assertions are enabled. +// Tests that the default build profile is dev. A proxy for checking this is to check that debug +// assertions are enabled. target Rust main reactor { diff --git a/test/Rust/src/target/BuildProfileRelease.lf b/test/Rust/src/target/BuildProfileRelease.lf index 2e28f8ee5f..20712f0721 100644 --- a/test/Rust/src/target/BuildProfileRelease.lf +++ b/test/Rust/src/target/BuildProfileRelease.lf @@ -1,5 +1,5 @@ -// Tests that the we can enable the release profile A proxy for checking this is -// to check that debug assertions are disabled. +// Tests that the we can enable the release profile A proxy for checking this is to check that debug +// assertions are disabled. target Rust { build-type: "Release" } diff --git a/test/Rust/src/target/CargoDependency.lf b/test/Rust/src/target/CargoDependency.lf index c0ba4c88e8..a425958fab 100644 --- a/test/Rust/src/target/CargoDependency.lf +++ b/test/Rust/src/target/CargoDependency.lf @@ -1,5 +1,4 @@ -// This tests the ability to depend on crates with carg if this compiles it's -// fine +// This tests the ability to depend on crates with carg if this compiles it's fine target Rust { cargo-dependencies: { rand: "0.8", diff --git a/test/Rust/src/target/CargoDependencyOnRuntime.lf b/test/Rust/src/target/CargoDependencyOnRuntime.lf index a6168df15c..2d3473f474 100644 --- a/test/Rust/src/target/CargoDependencyOnRuntime.lf +++ b/test/Rust/src/target/CargoDependencyOnRuntime.lf @@ -1,5 +1,4 @@ -// This tests the ability to depend on crates with carg if this compiles it's -// fine +// This tests the ability to depend on crates with carg if this compiles it's fine target Rust { cargo-dependencies: { reactor_rt: { diff --git a/test/TypeScript/src/ActionWithNoReaction.lf b/test/TypeScript/src/ActionWithNoReaction.lf index 4e95418d48..f8dab33ef6 100644 --- a/test/TypeScript/src/ActionWithNoReaction.lf +++ b/test/TypeScript/src/ActionWithNoReaction.lf @@ -1,6 +1,5 @@ -// This checks that action can be created even if there is no reaction. This -// test passes merely by compiling and executing without a segfault. Its other -// functionality is tested by other tests. +// This checks that action can be created even if there is no reaction. This test passes merely by +// compiling and executing without a segfault. Its other functionality is tested by other tests. target TypeScript { fast: true, timeout: 3 sec diff --git a/test/TypeScript/src/After.lf b/test/TypeScript/src/After.lf index 8a872103e9..525ff817f1 100644 --- a/test/TypeScript/src/After.lf +++ b/test/TypeScript/src/After.lf @@ -1,5 +1,4 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target TypeScript { fast: true, timeout: 3 sec diff --git a/test/TypeScript/src/ArrayAsType.lf b/test/TypeScript/src/ArrayAsType.lf index 9e30764307..3ff1e9e31a 100644 --- a/test/TypeScript/src/ArrayAsType.lf +++ b/test/TypeScript/src/ArrayAsType.lf @@ -1,6 +1,5 @@ -// In TypeScript this test is almost exactly the same as ArrayAsType. Source -// produces a statically allocated array, which it passes to Print. The -// destination references the array directly. +// In TypeScript this test is almost exactly the same as ArrayAsType. Source produces a statically +// allocated array, which it passes to Print. The destination references the array directly. target TypeScript reactor Source { diff --git a/test/TypeScript/src/ArrayPrint.lf b/test/TypeScript/src/ArrayPrint.lf index 93b6486506..ba77fa47c6 100644 --- a/test/TypeScript/src/ArrayPrint.lf +++ b/test/TypeScript/src/ArrayPrint.lf @@ -1,6 +1,5 @@ -// In TypeScript this test is almost exactly the same as ArrayAsType. Source -// produces a dynamically allocated array, which it passes to Print. Reference -// counting ensures that the array is freed. +// In TypeScript this test is almost exactly the same as ArrayAsType. Source produces a dynamically +// allocated array, which it passes to Print. Reference counting ensures that the array is freed. target TypeScript reactor Source { diff --git a/test/TypeScript/src/ArrayScale.lf b/test/TypeScript/src/ArrayScale.lf index 107ef8cf2f..0b29b9f918 100644 --- a/test/TypeScript/src/ArrayScale.lf +++ b/test/TypeScript/src/ArrayScale.lf @@ -1,7 +1,6 @@ -// Source produces a dynamically allocated array, which it passes to Scale. -// Scale requests a writable copy, which, instead of copying, it just gets -// ownership of the original array. It modifies it and passes it to Print. It -// gets freed after Print is done with it. +// Source produces a dynamically allocated array, which it passes to Scale. Scale requests a +// writable copy, which, instead of copying, it just gets ownership of the original array. It +// modifies it and passes it to Print. It gets freed after Print is done with it. target TypeScript import Source, Print from "ArrayPrint.lf" diff --git a/test/TypeScript/src/Composition.lf b/test/TypeScript/src/Composition.lf index e74bbe9aa9..f3dc9ae5da 100644 --- a/test/TypeScript/src/Composition.lf +++ b/test/TypeScript/src/Composition.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target TypeScript { timeout: 5 sec } diff --git a/test/TypeScript/src/CompositionAfter.lf b/test/TypeScript/src/CompositionAfter.lf index 8840298c2d..474f1525dd 100644 --- a/test/TypeScript/src/CompositionAfter.lf +++ b/test/TypeScript/src/CompositionAfter.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source that checks against its own -// count. +// This test connects a simple counting source that checks against its own count. target TypeScript { fast: true, timeout: 10 sec diff --git a/test/TypeScript/src/DanglingOutput.lf b/test/TypeScript/src/DanglingOutput.lf index f3f67e6529..c07115ea93 100644 --- a/test/TypeScript/src/DanglingOutput.lf +++ b/test/TypeScript/src/DanglingOutput.lf @@ -1,5 +1,5 @@ -// This tests that an output that is not connected to anything does not result -// in a compilation error. Passing the test is just compiling and running. +// This tests that an output that is not connected to anything does not result in a compilation +// error. Passing the test is just compiling and running. target TypeScript reactor Source { diff --git a/test/TypeScript/src/Deadline.lf b/test/TypeScript/src/Deadline.lf index 9f3086f1f5..b4586090f3 100644 --- a/test/TypeScript/src/Deadline.lf +++ b/test/TypeScript/src/Deadline.lf @@ -1,6 +1,5 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target TypeScript { timeout: 4 sec } diff --git a/test/TypeScript/src/DeadlineHandledAbove.lf b/test/TypeScript/src/DeadlineHandledAbove.lf index ba47fd7aac..a87a677048 100644 --- a/test/TypeScript/src/DeadlineHandledAbove.lf +++ b/test/TypeScript/src/DeadlineHandledAbove.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/DelayInt.lf b/test/TypeScript/src/DelayInt.lf index 224a7eab4a..2910a5b6b5 100644 --- a/test/TypeScript/src/DelayInt.lf +++ b/test/TypeScript/src/DelayInt.lf @@ -1,5 +1,5 @@ -// This tests actions with payloads by delaying an input by a fixed amount. This -// is a start at handling dynamic memory allocation for such actions. +// This tests actions with payloads by delaying an input by a fixed amount. This is a start at +// handling dynamic memory allocation for such actions. target TypeScript reactor Delay(delay: time = 100 msec) { diff --git a/test/TypeScript/src/DoubleInvocation.lf b/test/TypeScript/src/DoubleInvocation.lf index 9557857ee2..92369ca913 100644 --- a/test/TypeScript/src/DoubleInvocation.lf +++ b/test/TypeScript/src/DoubleInvocation.lf @@ -1,8 +1,7 @@ -// This illustrates a very strange bug that showed up and has now been fixed. -// This test ensures it does not reappear. At logical time zero, the two Print -// reactors used to be fired twice each at the same logical time. They should -// only be fired once. This behavior was oddly eliminated by either of the -// following actions, neither of which should affect this behavior: +// This illustrates a very strange bug that showed up and has now been fixed. This test ensures it +// does not reappear. At logical time zero, the two Print reactors used to be fired twice each at +// the same logical time. They should only be fired once. This behavior was oddly eliminated by +// either of the following actions, neither of which should affect this behavior: // * Removing the startup reaction in Print. // * Sending only position, not velocity from Ball. target TypeScript { diff --git a/test/TypeScript/src/DoubleReaction.lf b/test/TypeScript/src/DoubleReaction.lf index b172166613..67f2632920 100644 --- a/test/TypeScript/src/DoubleReaction.lf +++ b/test/TypeScript/src/DoubleReaction.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target TypeScript { timeout: 10 sec, fast: true diff --git a/test/TypeScript/src/DoubleTrigger.lf b/test/TypeScript/src/DoubleTrigger.lf index fc8921622c..dafbd7f453 100644 --- a/test/TypeScript/src/DoubleTrigger.lf +++ b/test/TypeScript/src/DoubleTrigger.lf @@ -1,5 +1,4 @@ -// Test that two simultaneous triggers don't cause a reaction to execute twice -// at the same tag. +// Test that two simultaneous triggers don't cause a reaction to execute twice at the same tag. target TypeScript { fast: true, timeout: 1 sec diff --git a/test/TypeScript/src/GetTime.lf b/test/TypeScript/src/GetTime.lf index 2fee5dfc20..8e14c563a0 100644 --- a/test/TypeScript/src/GetTime.lf +++ b/test/TypeScript/src/GetTime.lf @@ -1,8 +1,8 @@ -// This file includes code documented on the Wiki. For this test, success is -// just compiling and running. +// This file includes code documented on the Wiki. For this test, success is just compiling and +// running. target TypeScript { - // FIXME the C version of this test is fast, but in TS it's illegal to - // subtract TimeValues and get a negative result fast: true + // FIXME the C version of this test is fast, but in TS it's illegal to subtract TimeValues and + // get a negative result fast: true timeout: 2 sec } diff --git a/test/TypeScript/src/Import.lf b/test/TypeScript/src/Import.lf index 6a914e03c0..afdc8465ca 100644 --- a/test/TypeScript/src/Import.lf +++ b/test/TypeScript/src/Import.lf @@ -1,5 +1,4 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/MovingAverage.lf b/test/TypeScript/src/MovingAverage.lf index 19e767e3e2..b8018d92c2 100644 --- a/test/TypeScript/src/MovingAverage.lf +++ b/test/TypeScript/src/MovingAverage.lf @@ -1,6 +1,5 @@ -// Demonstration of a state variable that is an array. The MovingAverage reactor -// computes the moving average of the last four inputs and produces that as -// output. The source is a counting sequence. +// Demonstration of a state variable that is an array. The MovingAverage reactor computes the moving +// average of the last four inputs and produces that as output. The source is a counting sequence. target TypeScript { timeout: 1 sec, fast: true diff --git a/test/TypeScript/src/MultipleContained.lf b/test/TypeScript/src/MultipleContained.lf index 1bbeb82162..4c5fb53db8 100644 --- a/test/TypeScript/src/MultipleContained.lf +++ b/test/TypeScript/src/MultipleContained.lf @@ -1,5 +1,4 @@ -// Test that a reaction can react to and send two multiple ports of a contained -// reactor. +// Test that a reaction can react to and send two multiple ports of a contained reactor. target TypeScript reactor Contained { diff --git a/test/TypeScript/src/ReadOutputOfContainedReactor.lf b/test/TypeScript/src/ReadOutputOfContainedReactor.lf index 01b725e181..8591fe96bc 100644 --- a/test/TypeScript/src/ReadOutputOfContainedReactor.lf +++ b/test/TypeScript/src/ReadOutputOfContainedReactor.lf @@ -1,5 +1,4 @@ -// Test reacting to and reading outputs from a contained reactor in various -// permutations. +// Test reacting to and reading outputs from a contained reactor in various permutations. target TypeScript reactor Contained { diff --git a/test/TypeScript/src/Schedule.lf b/test/TypeScript/src/Schedule.lf index 27739f29a5..66464ccf70 100644 --- a/test/TypeScript/src/Schedule.lf +++ b/test/TypeScript/src/Schedule.lf @@ -1,5 +1,4 @@ -// TypeScript translated example from Schedule section of the C Reactor Target -// wiki page. +// TypeScript translated example from Schedule section of the C Reactor Target wiki page. target TypeScript reactor ScheduleLogicalAction { diff --git a/test/TypeScript/src/ScheduleLogicalAction.lf b/test/TypeScript/src/ScheduleLogicalAction.lf index 84e8fbe1cb..ee49204288 100644 --- a/test/TypeScript/src/ScheduleLogicalAction.lf +++ b/test/TypeScript/src/ScheduleLogicalAction.lf @@ -1,5 +1,5 @@ -// This checks that a logical action is scheduled the specified logical time -// after the current logical time. +// This checks that a logical action is scheduled the specified logical time after the current +// logical time. target TypeScript { fast: true, timeout: 3 sec diff --git a/test/TypeScript/src/SendingInside.lf b/test/TypeScript/src/SendingInside.lf index ca4b6489b3..a22f637deb 100644 --- a/test/TypeScript/src/SendingInside.lf +++ b/test/TypeScript/src/SendingInside.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target TypeScript { timeout: 10 sec, fast: true diff --git a/test/TypeScript/src/SendsPointerTest.lf b/test/TypeScript/src/SendsPointerTest.lf index 3c80613b52..6bdbf514af 100644 --- a/test/TypeScript/src/SendsPointerTest.lf +++ b/test/TypeScript/src/SendsPointerTest.lf @@ -1,5 +1,5 @@ -// Source produces a dynamically allocated object, which it passes to Print. -// Reference counting ensures that the struct is freed. +// Source produces a dynamically allocated object, which it passes to Print. Reference counting +// ensures that the struct is freed. target TypeScript reactor SendsPointer { diff --git a/test/TypeScript/src/SimpleDeadline.lf b/test/TypeScript/src/SimpleDeadline.lf index a518e04e5e..d02fe0044c 100644 --- a/test/TypeScript/src/SimpleDeadline.lf +++ b/test/TypeScript/src/SimpleDeadline.lf @@ -1,6 +1,5 @@ -// Test local deadline, where a deadline is associated with a reaction -// definition. This test triggers a reaction exactly once with a deadline -// violation. +// Test local deadline, where a deadline is associated with a reaction definition. This test +// triggers a reaction exactly once with a deadline violation. target TypeScript reactor Deadline(threshold: time = 100 msec) { diff --git a/test/TypeScript/src/SlowingClockPhysical.lf b/test/TypeScript/src/SlowingClockPhysical.lf index 53bc3f9da4..f1c65a92b7 100644 --- a/test/TypeScript/src/SlowingClockPhysical.lf +++ b/test/TypeScript/src/SlowingClockPhysical.lf @@ -1,12 +1,10 @@ /** - * Output events at physical times at least 100, 300, and 600 msec after the - * start time. This uses a physical action with a minimum interarrival time of - * 100 msec. The reactor increases the interarrival time with each invocation of - * the schedule() function. The timestamps of the events will be exact because - * the physical time at which schedule() is called is always way smaller than - * the time of the last invocation (or start time) plus the minimum interarrival - * time. Hence, the minimum interarrival time always determines the time of the - * next event. + * Output events at physical times at least 100, 300, and 600 msec after the start time. This uses a + * physical action with a minimum interarrival time of 100 msec. The reactor increases the + * interarrival time with each invocation of the schedule() function. The timestamps of the events + * will be exact because the physical time at which schedule() is called is always way smaller than + * the time of the last invocation (or start time) plus the minimum interarrival time. Hence, the + * minimum interarrival time always determines the time of the next event. */ target TypeScript { timeout: 1 sec diff --git a/test/TypeScript/src/Stop.lf b/test/TypeScript/src/Stop.lf index 6104c418d5..3464239b0a 100644 --- a/test/TypeScript/src/Stop.lf +++ b/test/TypeScript/src/Stop.lf @@ -1,6 +1,5 @@ /** - * A test for the util.requestStop() functionality in TypeScript target Lingua - * Franca. + * A test for the util.requestStop() functionality in TypeScript target Lingua Franca. * * @author Soroush Bateni * @author Byeong-gil Jun diff --git a/test/TypeScript/src/Stride.lf b/test/TypeScript/src/Stride.lf index 04d7805d0b..dd0ef5359e 100644 --- a/test/TypeScript/src/Stride.lf +++ b/test/TypeScript/src/Stride.lf @@ -1,5 +1,5 @@ -// This example illustrates state variables and parameters on the wiki. For this -// test, success is just compiling and running. +// This example illustrates state variables and parameters on the wiki. For this test, success is +// just compiling and running. target TypeScript { timeout: 2 sec, fast: true diff --git a/test/TypeScript/src/StructPrint.lf b/test/TypeScript/src/StructPrint.lf index e75d9ead37..201f788779 100644 --- a/test/TypeScript/src/StructPrint.lf +++ b/test/TypeScript/src/StructPrint.lf @@ -1,5 +1,5 @@ -// Source produces a dynamically allocated struct, which it passes to Print. -// Reference counting ensures that the struct is freed. +// Source produces a dynamically allocated struct, which it passes to Print. Reference counting +// ensures that the struct is freed. target TypeScript reactor Source { diff --git a/test/TypeScript/src/TestForPreviousOutput.lf b/test/TypeScript/src/TestForPreviousOutput.lf index c0eb21e6f0..0c37653ad0 100644 --- a/test/TypeScript/src/TestForPreviousOutput.lf +++ b/test/TypeScript/src/TestForPreviousOutput.lf @@ -1,5 +1,5 @@ -// This tests the mechanism for testing whether a previous reaction has produced -// a given output. The output should always be 42. +// This tests the mechanism for testing whether a previous reaction has produced a given output. The +// output should always be 42. target TypeScript reactor Source { diff --git a/test/TypeScript/src/TimeLimit.lf b/test/TypeScript/src/TimeLimit.lf index 05a2a5a3b3..c837a4cbb4 100644 --- a/test/TypeScript/src/TimeLimit.lf +++ b/test/TypeScript/src/TimeLimit.lf @@ -1,7 +1,6 @@ -// Test that the stop function can be used to internally impose a a time limit. -// This is also used to test performance (number of reactions per second). -// Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt -// or getting the wrong data. +// Test that the stop function can be used to internally impose a a time limit. This is also used to +// test performance (number of reactions per second). Correct output for this 1, 2, 3, 4. Failure +// for this test is failing to halt or getting the wrong data. target TypeScript { fast: true, logging: INFO diff --git a/test/TypeScript/src/federated/DistributedCount.lf b/test/TypeScript/src/federated/DistributedCount.lf index 50f510cdcd..a85228f606 100644 --- a/test/TypeScript/src/federated/DistributedCount.lf +++ b/test/TypeScript/src/federated/DistributedCount.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee * @author Hokeun Kim */ diff --git a/test/TypeScript/src/federated/DistributedDoublePort.lf b/test/TypeScript/src/federated/DistributedDoublePort.lf index d3a2636661..056216e687 100644 --- a/test/TypeScript/src/federated/DistributedDoublePort.lf +++ b/test/TypeScript/src/federated/DistributedDoublePort.lf @@ -1,7 +1,6 @@ /** - * Test the case for when two upstream federates send messages to a downstream - * federte on two different ports. One message should carry a microstep delay - * relative to the other message. + * Test the case for when two upstream federates send messages to a downstream federte on two + * different ports. One message should carry a microstep delay relative to the other message. * * @author Soroush Bateni * @author Hokeun Kim @@ -40,9 +39,7 @@ reactor Print { } =} - reaction(shutdown) {= - console.log("SUCCESS: messages were at least one microstep apart."); - =} + reaction(shutdown) {= console.log("SUCCESS: messages were at least one microstep apart."); =} } federated reactor DistributedDoublePort { diff --git a/test/TypeScript/src/federated/DistributedLoopedAction.lf b/test/TypeScript/src/federated/DistributedLoopedAction.lf index 02a7f5dc62..46170a0d1f 100644 --- a/test/TypeScript/src/federated/DistributedLoopedAction.lf +++ b/test/TypeScript/src/federated/DistributedLoopedAction.lf @@ -1,6 +1,5 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. + * Test a sender-receiver network system that relies on microsteps being taken into account. * * @author Soroush Bateni * @author Hokeun Kim @@ -18,8 +17,7 @@ reactor Receiver(takeBreakAfter: number = 10, breakInterval: time = 400 msec) { state breaks: number = 0 timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more - // sensible log output. + // but forces the logical time to advance Comment this line for a more sensible log output. reaction(inp) {= console.log("At tag (" + util.getElapsedLogicalTime() + ", " + util.getCurrentTag().microstep + ") received value " + inp); totalReceivedMessages++; diff --git a/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf b/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf index 842f13f74c..aa14ba553d 100644 --- a/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf @@ -1,7 +1,6 @@ /** - * Test a sender-receiver network system that is similar to - * DistributedLoopedAction, but it uses a physical action rather than a logical - * action. + * Test a sender-receiver network system that is similar to DistributedLoopedAction, but it uses a + * physical action rather than a logical action. * * @author Soroush Bateni * @author Hokeun Kim @@ -36,8 +35,7 @@ reactor Receiver(takeBreakAfter: number = 10, breakInterval: time = 550 msec) { state breaks: number = 0 timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more - // sensible log output. + // but forces the logical time to advance Comment this line for a more sensible log output. reaction(inp) {= console.log("At tag (" + util.getElapsedLogicalTime() + ", " + util.getCurrentTag().microstep + ") received value " + inp); totalReceivedMessages++; diff --git a/test/TypeScript/src/federated/DistributedStop.lf b/test/TypeScript/src/federated/DistributedStop.lf index c0dd04149a..6815501b4a 100644 --- a/test/TypeScript/src/federated/DistributedStop.lf +++ b/test/TypeScript/src/federated/DistributedStop.lf @@ -1,6 +1,5 @@ /** - * Test for util.requestStop() in federated execution with centralized - * coordination. + * Test for util.requestStop() in federated execution with centralized coordination. * * @author Soroush Bateni * @author Byeong-gil Jun diff --git a/test/TypeScript/src/federated/DistributedStopZero.lf b/test/TypeScript/src/federated/DistributedStopZero.lf index b3086b02f7..c85c3a21cf 100644 --- a/test/TypeScript/src/federated/DistributedStopZero.lf +++ b/test/TypeScript/src/federated/DistributedStopZero.lf @@ -1,6 +1,6 @@ /** - * Test for util.requestStop() in federated execution with centralized - * coordination at tag ((0 secs, 0 nsecs), 0). + * Test for util.requestStop() in federated execution with centralized coordination at tag ((0 secs, + * 0 nsecs), 0). * * @author Soroush Bateni * @author Byeong-gil Jun diff --git a/test/TypeScript/src/federated/HelloDistributed.lf b/test/TypeScript/src/federated/HelloDistributed.lf index 1189270ab1..a8376910c1 100644 --- a/test/TypeScript/src/federated/HelloDistributed.lf +++ b/test/TypeScript/src/federated/HelloDistributed.lf @@ -1,8 +1,7 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee * @author Hokeun Kim */ @@ -45,7 +44,5 @@ federated reactor HelloDistributed at localhost { d = new Destination() // Reactor d is in federate Destination s.out -> d.inp // This version preserves the timestamp. - reaction(startup) {= - console.log("Printing something in top-level federated reactor."); - =} + reaction(startup) {= console.log("Printing something in top-level federated reactor."); =} } diff --git a/test/TypeScript/src/federated/LoopDistributedCentralized.lf b/test/TypeScript/src/federated/LoopDistributedCentralized.lf index bb52679489..042d917106 100644 --- a/test/TypeScript/src/federated/LoopDistributedCentralized.lf +++ b/test/TypeScript/src/federated/LoopDistributedCentralized.lf @@ -1,6 +1,5 @@ /** - * This tests a feedback loop with physical actions and centralized - * coordination. + * This tests a feedback loop with physical actions and centralized coordination. * * @author Edward A. Lee * @author Hokeun Kim diff --git a/test/TypeScript/src/federated/LoopDistributedDouble.lf b/test/TypeScript/src/federated/LoopDistributedDouble.lf index 2c791377f7..ac82edbd0d 100644 --- a/test/TypeScript/src/federated/LoopDistributedDouble.lf +++ b/test/TypeScript/src/federated/LoopDistributedDouble.lf @@ -1,6 +1,5 @@ /** - * This tests a feedback loop with physical actions and centralized - * coordination. + * This tests a feedback loop with physical actions and centralized coordination. * * @author Edward A. Lee * @author Hokeun Kim diff --git a/test/TypeScript/src/federated/TopLevelArtifacts.lf b/test/TypeScript/src/federated/TopLevelArtifacts.lf index 917da033f5..cd5909a1f7 100644 --- a/test/TypeScript/src/federated/TopLevelArtifacts.lf +++ b/test/TypeScript/src/federated/TopLevelArtifacts.lf @@ -1,11 +1,10 @@ /** - * Test whether top-level reactions, actions, and ports are handled - * appropriately. + * Test whether top-level reactions, actions, and ports are handled appropriately. * * Currently, these artifacts are replicated on all federates. * - * @note This just tests for the correctness of the code generation. These - * top-level artifacts might be disallowed in the future. + * @note This just tests for the correctness of the code generation. These top-level artifacts might + * be disallowed in the future. * @author Youri Su */ target TypeScript { diff --git a/test/TypeScript/src/lib/Imported.lf b/test/TypeScript/src/lib/Imported.lf index b19cd366a9..52ed1e4c85 100644 --- a/test/TypeScript/src/lib/Imported.lf +++ b/test/TypeScript/src/lib/Imported.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/lib/ImportedAgain.lf b/test/TypeScript/src/lib/ImportedAgain.lf index e0093e3b10..a98513b692 100644 --- a/test/TypeScript/src/lib/ImportedAgain.lf +++ b/test/TypeScript/src/lib/ImportedAgain.lf @@ -1,5 +1,5 @@ -// This is used by the test for the ability to import a reactor definition that -// itself imports a reactor definition. +// This is used by the test for the ability to import a reactor definition that itself imports a +// reactor definition. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/lib/LoopedActionSender.lf b/test/TypeScript/src/lib/LoopedActionSender.lf index 7da4c133b0..eb441ff2e8 100644 --- a/test/TypeScript/src/lib/LoopedActionSender.lf +++ b/test/TypeScript/src/lib/LoopedActionSender.lf @@ -7,10 +7,9 @@ target TypeScript /** - * @param takeBreakAfter: Indicates how many messages are sent in consecutive - * superdense time - * @param breakInterval: Determines how long the reactor should take a break - * after sending takeBreakAfter messages. + * @param takeBreakAfter: Indicates how many messages are sent in consecutive superdense time + * @param breakInterval: Determines how long the reactor should take a break after sending + * takeBreakAfter messages. */ reactor Sender(takeBreakAfter: number = 10, breakInterval: time = 400 msec) { output out: number diff --git a/test/TypeScript/src/lib/TestCount.lf b/test/TypeScript/src/lib/TestCount.lf index 822b4c64b1..d5181f10f0 100644 --- a/test/TypeScript/src/lib/TestCount.lf +++ b/test/TypeScript/src/lib/TestCount.lf @@ -1,7 +1,6 @@ /** - * Test that a counting sequence of inputs starts with the specified start - * parameter value, increments by the specified stride, and receives the - * specified number of inputs. + * Test that a counting sequence of inputs starts with the specified start parameter value, + * increments by the specified stride, and receives the specified number of inputs. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. diff --git a/test/TypeScript/src/multiport/BankMulticast.lf b/test/TypeScript/src/multiport/BankMulticast.lf index 610306e30e..84a7acb6c6 100644 --- a/test/TypeScript/src/multiport/BankMulticast.lf +++ b/test/TypeScript/src/multiport/BankMulticast.lf @@ -1,6 +1,6 @@ /** - * This tests that a contained bank can send not only to a local connection, but - * also multicast via the container's output port. + * This tests that a contained bank can send not only to a local connection, but also multicast via + * the container's output port. */ target TypeScript { timeout: 3 sec diff --git a/test/TypeScript/src/multiport/BankReactionsInContainer.lf b/test/TypeScript/src/multiport/BankReactionsInContainer.lf index b14ca33f70..485f1074f1 100644 --- a/test/TypeScript/src/multiport/BankReactionsInContainer.lf +++ b/test/TypeScript/src/multiport/BankReactionsInContainer.lf @@ -1,6 +1,4 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target TypeScript { timeout: 1 sec } diff --git a/test/TypeScript/src/multiport/BankSelfBroadcast.lf b/test/TypeScript/src/multiport/BankSelfBroadcast.lf index cf5af4bee3..50d6683592 100644 --- a/test/TypeScript/src/multiport/BankSelfBroadcast.lf +++ b/test/TypeScript/src/multiport/BankSelfBroadcast.lf @@ -1,7 +1,7 @@ /** - * Test a bank of reactors that broadcast a single output back to a multiport - * input of the same reactors in the bank so that each reactor in the bank - * receives the output produced by itself and each other reactor. + * Test a bank of reactors that broadcast a single output back to a multiport input of the same + * reactors in the bank so that each reactor in the bank receives the output produced by itself and + * each other reactor. * * @author Edward A. Lee * @author Christian Menard diff --git a/test/TypeScript/src/multiport/MultiportFromBank.lf b/test/TypeScript/src/multiport/MultiportFromBank.lf index 18896eed2a..53f8c523ee 100644 --- a/test/TypeScript/src/multiport/MultiportFromBank.lf +++ b/test/TypeScript/src/multiport/MultiportFromBank.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf b/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf index ffc394b26c..c896494897 100644 --- a/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/TypeScript/src/multiport/MultiportFromBankHierarchyAfter.lf index 96b25104a4..1462f157a5 100644 --- a/test/TypeScript/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/TypeScript/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportFromHierarchy.lf b/test/TypeScript/src/multiport/MultiportFromHierarchy.lf index 5627652b2f..b294dc3995 100644 --- a/test/TypeScript/src/multiport/MultiportFromHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportFromHierarchy.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input, where the former is a hierarchical -// reactor. +// Check multiport output to multiport input, where the former is a hierarchical reactor. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportIn.lf b/test/TypeScript/src/multiport/MultiportIn.lf index 97a36c08d2..346eeffa11 100644 --- a/test/TypeScript/src/multiport/MultiportIn.lf +++ b/test/TypeScript/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -// This is a version of the test that uses a multiport input at the destination. -// Its purpose is to test multiport inputs. +// This is a version of the test that uses a multiport input at the destination. Its purpose is to +// test multiport inputs. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportInParameterized.lf b/test/TypeScript/src/multiport/MultiportInParameterized.lf index fb11c5e102..3ff15c14dc 100644 --- a/test/TypeScript/src/multiport/MultiportInParameterized.lf +++ b/test/TypeScript/src/multiport/MultiportInParameterized.lf @@ -1,5 +1,5 @@ -// This is a version of the Threaded test that uses a multiport input at the -// destination. Its purpose is to test multiport inputs. +// This is a version of the Threaded test that uses a multiport input at the destination. Its +// purpose is to test multiport inputs. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportMutableInput.lf b/test/TypeScript/src/multiport/MultiportMutableInput.lf index 11120e8d30..c570b5b245 100644 --- a/test/TypeScript/src/multiport/MultiportMutableInput.lf +++ b/test/TypeScript/src/multiport/MultiportMutableInput.lf @@ -1,6 +1,5 @@ -// Source produces a ints on a multiport, which it passes to Scale. Scale -// requests a writable copy. It modifies it and passes it to Print. It gets -// freed after Print is done with it. +// Source produces a ints on a multiport, which it passes to Scale. Scale requests a writable copy. +// It modifies it and passes it to Print. It gets freed after Print is done with it. target TypeScript reactor Source { diff --git a/test/TypeScript/src/multiport/MultiportMutableInputArray.lf b/test/TypeScript/src/multiport/MultiportMutableInputArray.lf index 382f444df7..d91b6aa8ac 100644 --- a/test/TypeScript/src/multiport/MultiportMutableInputArray.lf +++ b/test/TypeScript/src/multiport/MultiportMutableInputArray.lf @@ -1,7 +1,6 @@ -// Source produces a dynamically allocated arrays on a multiport, which it -// passes to Scale. Scale requests a writable copy, which, instead of copying, -// it just gets ownership of the original array. It modifies it and passes it to -// Print. It gets freed after Print is done with it. +// Source produces a dynamically allocated arrays on a multiport, which it passes to Scale. Scale +// requests a writable copy, which, instead of copying, it just gets ownership of the original +// array. It modifies it and passes it to Print. It gets freed after Print is done with it. target TypeScript reactor Source { diff --git a/test/TypeScript/src/multiport/MultiportToBankAfter.lf b/test/TypeScript/src/multiport/MultiportToBankAfter.lf index ee10df94c6..b8005863ff 100644 --- a/test/TypeScript/src/multiport/MultiportToBankAfter.lf +++ b/test/TypeScript/src/multiport/MultiportToBankAfter.lf @@ -1,5 +1,4 @@ -// Check multiport output to bank of recipients where the width of the bank is -// inferred. +// Check multiport output to bank of recipients where the width of the bank is inferred. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportToBankDouble.lf b/test/TypeScript/src/multiport/MultiportToBankDouble.lf index e618dd898d..32b5e86b7c 100644 --- a/test/TypeScript/src/multiport/MultiportToBankDouble.lf +++ b/test/TypeScript/src/multiport/MultiportToBankDouble.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients where the source has two -// reactions that write to the output. +// Check multiport output to bank of recipients where the source has two reactions that write to the +// output. target TypeScript { timeout: 2 sec } @@ -13,8 +13,8 @@ reactor Source { } =} - // Test also that multiple appearances of the same effect port do not result - // in multiple allocations of memory for the port. + // Test also that multiple appearances of the same effect port do not result in multiple + // allocations of memory for the port. reaction(startup) -> out {= // Contents of the reactions does not matter (either could be empty) for (let i = 0; i < out.length; i++) { diff --git a/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf b/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf index 7420704ce1..a2e60ef8c2 100644 --- a/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportToHierarchy.lf b/test/TypeScript/src/multiport/MultiportToHierarchy.lf index c620000872..01edeb3192 100644 --- a/test/TypeScript/src/multiport/MultiportToHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportToHierarchy.lf @@ -1,6 +1,5 @@ -// Check multiport output to multiport input, where the latter is a hierarchical -// reactor. Note that the destination reactor has width wider than the sender, -// so one input is dangling. +// Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that +// the destination reactor has width wider than the sender, so one input is dangling. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportToMultiportArray.lf b/test/TypeScript/src/multiport/MultiportToMultiportArray.lf index 737603a5bd..ba1f578f09 100644 --- a/test/TypeScript/src/multiport/MultiportToMultiportArray.lf +++ b/test/TypeScript/src/multiport/MultiportToMultiportArray.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportToPort.lf b/test/TypeScript/src/multiport/MultiportToPort.lf index a00d482fe8..caf87f1d3b 100644 --- a/test/TypeScript/src/multiport/MultiportToPort.lf +++ b/test/TypeScript/src/multiport/MultiportToPort.lf @@ -1,5 +1,4 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/ReactionsToNested.lf b/test/TypeScript/src/multiport/ReactionsToNested.lf index 055e08d086..514973762a 100644 --- a/test/TypeScript/src/multiport/ReactionsToNested.lf +++ b/test/TypeScript/src/multiport/ReactionsToNested.lf @@ -1,5 +1,4 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target TypeScript { timeout: 1 sec } diff --git a/test/TypeScript/src/serialization/ProtoNoPacking.lf b/test/TypeScript/src/serialization/ProtoNoPacking.lf index d0867da282..02c6f71c0e 100644 --- a/test/TypeScript/src/serialization/ProtoNoPacking.lf +++ b/test/TypeScript/src/serialization/ProtoNoPacking.lf @@ -1,12 +1,10 @@ /** - * This example creates a Protocol Buffer message and passes it to another - * reactor without packing and unpacking. This demonstrates that local - * communication, within one shared-memory machine, need not incur the overhead - * of packing and unpacking. + * This example creates a Protocol Buffer message and passes it to another reactor without packing + * and unpacking. This demonstrates that local communication, within one shared-memory machine, need + * not incur the overhead of packing and unpacking. * * To run this example first install the protocol buffers compiler from - * https://github.com/protocolbuffers/protobuf. It is also available from - * homebrew on a Mac via + * https://github.com/protocolbuffers/protobuf. It is also available from homebrew on a Mac via * * $ brew install protobuf * diff --git a/test/TypeScript/src/target/AfterNoTypes.lf b/test/TypeScript/src/target/AfterNoTypes.lf index b3477bbf55..5d698cb3e0 100644 --- a/test/TypeScript/src/target/AfterNoTypes.lf +++ b/test/TypeScript/src/target/AfterNoTypes.lf @@ -1,5 +1,4 @@ -// This test demonstrates that after can be used on connections with ports that -// have no types. +// This test demonstrates that after can be used on connections with ports that have no types. target TypeScript { fast: false, timeout: 3 sec From 7171392a8d03f0f226d78048d4f1b721cc8536e4 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 5 Oct 2022 19:26:01 -0700 Subject: [PATCH 414/709] Reformat LF tests with 2 spaces of indentation. --- README.md | 2 - REQUIREMENTS.md | 34 ++--- test/C/src/ActionWithNoReaction.lf | 40 +++--- test/C/src/After.lf | 3 +- test/C/src/AfterCycles.lf | 4 +- test/C/src/AfterZero.lf | 3 +- test/C/src/Alignment.lf | 3 +- test/C/src/ArrayAsParameter.lf | 5 +- test/C/src/ArrayAsType.lf | 4 +- test/C/src/ArrayParallel.lf | 18 +-- test/C/src/Composition.lf | 3 +- test/C/src/CompositionAfter.lf | 3 +- test/C/src/CompositionGain.lf | 40 +++--- test/C/src/CompositionInheritance.lf | 3 +- test/C/src/CountTest.lf | 12 +- test/C/src/DanglingOutput.lf | 24 ++-- test/C/src/Deadline.lf | 5 +- test/C/src/DeadlineAnytime.lf | 30 ++--- test/C/src/DeadlineHandledAbove.lf | 4 +- test/C/src/DelayArrayWithAfter.lf | 3 +- test/C/src/DelayInt.lf | 4 +- test/C/src/DelayString.lf | 3 +- test/C/src/DelayedReaction.lf | 30 ++--- test/C/src/Determinism.lf | 60 ++++----- test/C/src/DoubleInvocation.lf | 9 +- test/C/src/DoublePort.lf | 9 +- test/C/src/DoubleReaction.lf | 4 +- test/C/src/DoubleTrigger.lf | 3 +- test/C/src/FloatLiteral.lf | 3 +- test/C/src/GetTime.lf | 28 ++-- test/C/src/Hierarchy.lf | 64 ++++----- test/C/src/Import.lf | 6 +- test/C/src/ImportComposition.lf | 3 +- test/C/src/ImportRenamed.lf | 10 +- test/C/src/InheritanceAction.lf | 3 +- test/C/src/Microsteps.lf | 62 ++++----- test/C/src/Minimal.lf | 2 +- test/C/src/MovingAverage.lf | 5 +- test/C/src/MultipleContained.lf | 3 +- test/C/src/MultipleOutputs.lf | 7 +- test/C/src/PingPong.lf | 17 ++- test/C/src/Preamble.lf | 30 ++--- test/C/src/ReadOutputOfContainedReactor.lf | 3 +- test/C/src/RepeatedInheritance.lf | 26 ++-- test/C/src/RequestStop.lf | 3 +- test/C/src/Schedule.lf | 28 ++-- test/C/src/ScheduleLogicalAction.lf | 4 +- test/C/src/ScheduleValue.lf | 28 ++-- test/C/src/SendingInside.lf | 4 +- test/C/src/SendingInside2.lf | 22 +-- test/C/src/SendsPointerTest.lf | 4 +- test/C/src/SetArray.lf | 4 +- test/C/src/SimpleDeadline.lf | 5 +- test/C/src/SimpleImport.lf | 4 +- test/C/src/SlowingClock.lf | 7 +- test/C/src/SlowingClockPhysical.lf | 9 +- test/C/src/StartupOutFromInside.lf | 20 +-- test/C/src/Starvation.lf | 4 +- test/C/src/StopZero.lf | 4 +- test/C/src/Stride.lf | 4 +- test/C/src/StructPrint.lf | 4 +- test/C/src/TestForPreviousOutput.lf | 54 ++++---- test/C/src/TimeLimit.lf | 5 +- test/C/src/TimeoutZero.lf | 3 +- test/C/src/TriggerDownstreamOnlyIfPresent2.lf | 5 +- test/C/src/Wcet.lf | 58 ++++---- test/C/src/arduino/AnalogReadSerial.lf | 7 +- test/C/src/arduino/Blink.lf | 5 +- test/C/src/arduino/BlinkAttemptThreading.lf | 7 +- test/C/src/arduino/BlinkMBED.lf | 5 +- test/C/src/arduino/Fade.lf | 9 +- test/C/src/arduino/ReadAnalogVoltage.lf | 9 +- test/C/src/concurrent/AsyncCallback.lf | 10 +- test/C/src/concurrent/AsyncCallbackDrop.lf | 7 +- test/C/src/concurrent/AsyncCallbackReplace.lf | 7 +- test/C/src/concurrent/CompositionThreaded.lf | 3 +- .../DeadlineHandledAboveThreaded.lf | 4 +- test/C/src/concurrent/DeadlineThreaded.lf | 5 +- test/C/src/concurrent/DeterminismThreaded.lf | 60 ++++----- .../src/concurrent/DoubleReactionThreaded.lf | 4 +- test/C/src/concurrent/ImportThreaded.lf | 6 +- test/C/src/concurrent/MinimalThreaded.lf | 4 +- test/C/src/concurrent/PingPongThreaded.lf | 20 +-- .../C/src/concurrent/SendingInsideThreaded.lf | 4 +- test/C/src/concurrent/StarvationThreaded.lf | 5 +- test/C/src/concurrent/StopThreaded.lf | 4 +- test/C/src/concurrent/StopZeroThreaded.lf | 3 +- test/C/src/concurrent/Threaded.lf | 19 +-- test/C/src/concurrent/ThreadedMultiport.lf | 3 +- test/C/src/concurrent/ThreadedThreaded.lf | 16 ++- test/C/src/concurrent/TimeLimitThreaded.lf | 4 +- test/C/src/concurrent/TimeoutThreaded.lf | 3 +- test/C/src/concurrent/TimeoutZeroThreaded.lf | 4 +- test/C/src/concurrent/Tracing.lf | 3 +- test/C/src/concurrent/Workers.lf | 16 +-- .../src/docker/FilesPropertyContainerized.lf | 14 +- test/C/src/docker/HelloWorldContainerized.lf | 14 +- test/C/src/docker/PingPongContainerized.lf | 12 +- .../DistributedCountContainerized.lf | 7 +- .../DistributedDoublePortContainerized.lf | 18 +-- .../DistributedMultiportContainerized.lf | 12 +- ...stributedStopDecentralizedContainerized.lf | 10 +- test/C/src/federated/BroadcastFeedback.lf | 4 +- .../BroadcastFeedbackWithHierarchy.lf | 4 +- test/C/src/federated/ChainWithDelay.lf | 12 +- test/C/src/federated/CycleDetection.lf | 4 +- .../DecentralizedP2PUnbalancedTimeout.lf | 11 +- ...centralizedP2PUnbalancedTimeoutPhysical.lf | 15 ++- test/C/src/federated/DistributedCount.lf | 7 +- .../DistributedCountDecentralized.lf | 10 +- .../src/federated/DistributedCountPhysical.lf | 8 +- .../DistributedCountPhysicalAfterDelay.lf | 9 +- .../DistributedCountPhysicalDecentralized.lf | 8 +- test/C/src/federated/DistributedDoublePort.lf | 9 +- .../DistributedLogicalActionUpstreamLong.lf | 4 +- .../src/federated/DistributedLoopedAction.lf | 6 +- .../DistributedLoopedActionDecentralized.lf | 23 ++-- .../DistributedLoopedPhysicalAction.lf | 16 ++- ...ibutedLoopedPhysicalActionDecentralized.lf | 10 +- .../federated/DistributedMultiportToken.lf | 4 +- .../src/federated/DistributedNetworkOrder.lf | 7 +- .../DistributedPhysicalActionUpstream.lf | 4 +- .../DistributedPhysicalActionUpstreamLong.lf | 4 +- test/C/src/federated/DistributedStop.lf | 3 +- .../federated/DistributedStopDecentralized.lf | 8 +- test/C/src/federated/DistributedStopZero.lf | 126 +++++++++--------- .../DistributedStopZeroDecentralized.lf | 6 +- test/C/src/federated/HelloDistributed.lf | 11 +- .../federated/LoopDistributedCentralized.lf | 3 +- .../LoopDistributedCentralizedPrecedence.lf | 4 +- ...stributedCentralizedPrecedenceHierarchy.lf | 5 +- .../federated/LoopDistributedDecentralized.lf | 3 +- test/C/src/federated/LoopDistributedDouble.lf | 3 +- test/C/src/federated/ParallelDestinations.lf | 18 +-- test/C/src/federated/ParallelSources.lf | 18 +-- .../src/federated/ParallelSourcesMultiport.lf | 30 ++--- test/C/src/federated/PhysicalSTP.lf | 5 +- test/C/src/federated/PingPongDistributed.lf | 17 ++- .../federated/PingPongDistributedPhysical.lf | 18 +-- test/C/src/federated/SimpleFederated.lf | 16 +-- test/C/src/federated/StopAtShutdown.lf | 24 ++-- test/C/src/federated/TopLevelArtifacts.lf | 7 +- test/C/src/federated/failing/ClockSync.lf | 29 ++-- test/C/src/lib/Imported.lf | 6 +- test/C/src/lib/ImportedAgain.lf | 16 +-- test/C/src/lib/ImportedComposition.lf | 20 +-- test/C/src/lib/LoopedActionSender.lf | 7 +- test/C/src/lib/TestCount.lf | 5 +- .../src/modal_models/BanksModalStateReset.lf | 8 +- test/C/src/modal_models/Count3Modes.lf | 6 +- test/C/src/modal_models/MixedReactions.lf | 4 +- .../src/modal_models/ModalNestedReactions.lf | 94 ++++++------- test/C/src/multiport/BankGangedConnections.lf | 24 ++-- test/C/src/multiport/BankMulticast.lf | 30 ++--- .../src/multiport/BankReactionsInContainer.lf | 4 +- test/C/src/multiport/BankSelfBroadcast.lf | 6 +- test/C/src/multiport/MultiportFromBank.lf | 8 +- .../multiport/MultiportFromBankHierarchy.lf | 4 +- .../MultiportFromBankHierarchyAfter.lf | 10 +- .../C/src/multiport/MultiportFromHierarchy.lf | 3 +- test/C/src/multiport/MultiportIn.lf | 4 +- .../src/multiport/MultiportInParameterized.lf | 7 +- test/C/src/multiport/MultiportMutableInput.lf | 5 +- .../multiport/MultiportMutableInputArray.lf | 7 +- test/C/src/multiport/MultiportToBank.lf | 7 +- test/C/src/multiport/MultiportToBankAfter.lf | 3 +- test/C/src/multiport/MultiportToBankDouble.lf | 8 +- .../src/multiport/MultiportToBankHierarchy.lf | 4 +- test/C/src/multiport/MultiportToHierarchy.lf | 5 +- .../multiport/MultiportToMultiportArray.lf | 3 +- test/C/src/multiport/MultiportToPort.lf | 3 +- test/C/src/multiport/PipelineAfter.lf | 44 +++--- .../ReactionToContainedBankMultiport.lf | 3 +- test/C/src/multiport/ReactionsToNested.lf | 3 +- test/C/src/multiport/SparseFallback.lf | 4 +- .../TriggerDownstreamOnlyIfPresent.lf | 5 +- .../serialization/PersonProtocolBuffers.lf | 36 ++--- test/C/src/serialization/ProtoNoPacking.lf | 28 ++-- .../ROSBuiltInSerializationSharedPtr.lf | 13 +- test/C/src/target/CMakeInclude.lf | 32 ++--- test/C/src/target/DistributedCMakeInclude.lf | 30 ++--- .../DistributedCMakeIncludeSeparateCompile.lf | 6 +- test/C/src/target/Files.lf | 16 +-- test/C/src/target/HelloWorldCCPP.lf | 4 +- test/C/src/target/HelloWorldFederatedCCPP.lf | 10 +- test/C/src/target/HelloWorldThreadedCPP.lf | 6 +- test/C/src/target/Platform.lf | 4 +- test/C/src/target/lib/ImportedCMakeInclude.lf | 22 +-- test/Cpp/src/ActionWithNoReaction.lf | 40 +++--- test/Cpp/src/After.lf | 3 +- test/Cpp/src/AfterZero.lf | 3 +- test/Cpp/src/Alignment.lf | 3 +- test/Cpp/src/ArrayAsParameter.lf | 3 +- test/Cpp/src/ArrayAsType.lf | 74 +++++----- test/Cpp/src/ArrayParallel.lf | 18 +-- test/Cpp/src/ArrayPrint.lf | 5 +- test/Cpp/src/ArrayScale.lf | 5 +- test/Cpp/src/Composition.lf | 3 +- test/Cpp/src/CompositionAfter.lf | 3 +- test/Cpp/src/CompositionGain.lf | 40 +++--- test/Cpp/src/DanglingOutput.lf | 24 ++-- test/Cpp/src/Deadline.lf | 5 +- test/Cpp/src/DeadlineHandledAbove.lf | 4 +- test/Cpp/src/DelayedReaction.lf | 28 ++-- test/Cpp/src/Determinism.lf | 60 ++++----- test/Cpp/src/DoubleInvocation.lf | 12 +- test/Cpp/src/DoublePort.lf | 5 +- test/Cpp/src/DoubleReaction.lf | 4 +- test/Cpp/src/DoubleTrigger.lf | 3 +- test/Cpp/src/GetTime.lf | 28 ++-- test/Cpp/src/HelloWorld.lf | 6 +- test/Cpp/src/Hierarchy.lf | 60 ++++----- test/Cpp/src/Import.lf | 6 +- test/Cpp/src/ImportComposition.lf | 3 +- test/Cpp/src/ImportRenamed.lf | 10 +- test/Cpp/src/ManualDelayedReaction.lf | 6 +- test/Cpp/src/Microsteps.lf | 66 ++++----- test/Cpp/src/Minimal.lf | 2 +- test/Cpp/src/MovingAverage.lf | 6 +- test/Cpp/src/MultipleContained.lf | 46 +++---- test/Cpp/src/PreambleTest.lf | 46 +++---- test/Cpp/src/ReadOutputOfContainedReactor.lf | 3 +- test/Cpp/src/Schedule.lf | 32 ++--- test/Cpp/src/ScheduleLogicalAction.lf | 4 +- test/Cpp/src/SendingInside.lf | 4 +- test/Cpp/src/SendingInside2.lf | 22 +-- test/Cpp/src/SimpleDeadline.lf | 5 +- test/Cpp/src/SimpleImport.lf | 4 +- test/Cpp/src/SlowingClock.lf | 7 +- test/Cpp/src/SlowingClockPhysical.lf | 9 +- test/Cpp/src/StartupOutFromInside.lf | 20 +-- test/Cpp/src/Stride.lf | 4 +- test/Cpp/src/StructAsState.lf | 18 +-- test/Cpp/src/StructAsType.lf | 20 +-- test/Cpp/src/StructAsTypeDirect.lf | 18 +-- test/Cpp/src/StructParallel.lf | 20 +-- test/Cpp/src/StructScale.lf | 5 +- test/Cpp/src/TestForPreviousOutput.lf | 56 ++++---- test/Cpp/src/TimeLimit.lf | 5 +- .../src/TriggerDownstreamOnlyIfPresent2.lf | 3 +- .../Cpp/src/concurrent/CompositionThreaded.lf | 3 +- .../DeadlineHandledAboveThreaded.lf | 4 +- test/Cpp/src/concurrent/DeadlineThreaded.lf | 5 +- .../Cpp/src/concurrent/DeterminismThreaded.lf | 60 ++++----- .../src/concurrent/DoubleReactionThreaded.lf | 4 +- test/Cpp/src/concurrent/ImportThreaded.lf | 6 +- test/Cpp/src/concurrent/MinimalThreaded.lf | 2 +- .../src/concurrent/SendingInsideThreaded.lf | 4 +- test/Cpp/src/concurrent/Threaded.lf | 14 +- test/Cpp/src/concurrent/ThreadedThreaded.lf | 14 +- test/Cpp/src/concurrent/TimeLimitThreaded.lf | 7 +- test/Cpp/src/concurrent/Workers.lf | 18 +-- test/Cpp/src/lib/Imported.lf | 6 +- test/Cpp/src/lib/ImportedAgain.lf | 20 +-- test/Cpp/src/lib/ImportedComposition.lf | 20 +-- test/Cpp/src/lib/LoopedActionSender.lf | 7 +- test/Cpp/src/multiport/BankSelfBroadcast.lf | 6 +- .../src/multiport/IndexIntoMultiportInput.lf | 56 ++++---- .../src/multiport/IndexIntoMultiportOutput.lf | 5 +- test/Cpp/src/multiport/MultiportFromBank.lf | 4 +- .../multiport/MultiportFromBankHierarchy.lf | 4 +- .../MultiportFromBankHierarchyAfter.lf | 4 +- .../src/multiport/MultiportFromHierarchy.lf | 3 +- test/Cpp/src/multiport/MultiportIn.lf | 4 +- .../src/multiport/MultiportToBankHierarchy.lf | 4 +- .../Cpp/src/multiport/MultiportToHierarchy.lf | 5 +- .../multiport/MultiportToMultiportArray.lf | 3 +- test/Cpp/src/multiport/MultiportToPort.lf | 3 +- test/Cpp/src/multiport/PipelineAfter.lf | 44 +++--- .../ReadMultiportOutputOfContainedBank.lf | 3 +- .../multiport/ReadOutputOfContainedBank.lf | 3 +- .../src/target/BraceAndParenInitialization.lf | 6 +- test/Cpp/src/target/CMakeInclude.lf | 22 +-- test/Cpp/src/target/PreambleFile.lf | 60 ++++----- test/Python/src/ActionWithNoReaction.lf | 40 +++--- test/Python/src/After.lf | 3 +- test/Python/src/AfterCycles.lf | 4 +- test/Python/src/ArrayAsType.lf | 4 +- test/Python/src/ArrayFree.lf | 8 +- test/Python/src/ArrayParallel.lf | 18 +-- test/Python/src/ArrayPrint.lf | 4 +- test/Python/src/ArrayScale.lf | 7 +- test/Python/src/Composition.lf | 3 +- test/Python/src/CompositionAfter.lf | 3 +- test/Python/src/CompositionGain.lf | 38 +++--- test/Python/src/CompositionInheritance.lf | 3 +- test/Python/src/DanglingOutput.lf | 24 ++-- test/Python/src/Deadline.lf | 5 +- test/Python/src/DeadlineHandledAbove.lf | 4 +- test/Python/src/DelayArrayWithAfter.lf | 3 +- test/Python/src/DelayString.lf | 3 +- test/Python/src/DelayedReaction.lf | 28 ++-- test/Python/src/Determinism.lf | 54 ++++---- test/Python/src/DoubleInvocation.lf | 9 +- test/Python/src/DoubleReaction.lf | 4 +- test/Python/src/GetTime.lf | 28 ++-- test/Python/src/Hello.lf | 14 +- test/Python/src/Hierarchy.lf | 62 ++++----- test/Python/src/Import.lf | 6 +- test/Python/src/ImportComposition.lf | 3 +- test/Python/src/ImportRenamed.lf | 10 +- test/Python/src/ManualDelayedReaction.lf | 9 +- test/Python/src/Microsteps.lf | 54 ++++---- test/Python/src/Minimal.lf | 2 +- test/Python/src/MovingAverage.lf | 5 +- test/Python/src/MultipleContained.lf | 3 +- test/Python/src/PingPong.lf | 17 ++- test/Python/src/Preamble.lf | 30 ++--- .../src/ReadOutputOfContainedReactor.lf | 3 +- test/Python/src/Schedule.lf | 26 ++-- test/Python/src/ScheduleLogicalAction.lf | 4 +- test/Python/src/ScheduleValue.lf | 24 ++-- test/Python/src/SendingInside.lf | 4 +- test/Python/src/SendingInside2.lf | 20 +-- test/Python/src/SetArray.lf | 5 +- test/Python/src/SimpleDeadline.lf | 5 +- test/Python/src/SimpleImport.lf | 4 +- test/Python/src/SlowingClock.lf | 6 +- test/Python/src/StartupOutFromInside.lf | 18 +-- test/Python/src/Stride.lf | 4 +- test/Python/src/StructAsState.lf | 3 +- test/Python/src/StructPrint.lf | 4 +- test/Python/src/TestForPreviousOutput.lf | 50 +++---- test/Python/src/TimeLimit.lf | 5 +- .../src/TriggerDownstreamOnlyIfPresent.lf | 5 +- .../src/TriggerDownstreamOnlyIfPresent2.lf | 5 +- test/Python/src/Wcet.lf | 56 ++++---- test/Python/src/concurrent/AsyncCallback.lf | 5 +- .../src/concurrent/AsyncCallbackNoTimer.lf | 12 +- .../src/docker/HelloWorldContainerized.lf | 4 +- .../src/docker/PingPongContainerized.lf | 12 +- .../DistributedCountContainerized.lf | 7 +- .../DistributedDoublePortContainerized.lf | 18 +-- .../DistributedMultiportContainerized.lf | 12 +- .../DistributedSendClassContainerized.lf | 10 +- ...stributedStopDecentralizedContainerized.lf | 10 +- .../Python/src/federated/BroadcastFeedback.lf | 4 +- .../BroadcastFeedbackWithHierarchy.lf | 4 +- test/Python/src/federated/ChainWithDelay.lf | 12 +- test/Python/src/federated/CycleDetection.lf | 4 +- .../DecentralizedP2PUnbalancedTimeout.lf | 7 +- ...centralizedP2PUnbalancedTimeoutPhysical.lf | 11 +- test/Python/src/federated/DistributedCount.lf | 7 +- .../DistributedCountDecentralized.lf | 10 +- .../src/federated/DistributedCountPhysical.lf | 8 +- .../DistributedCountPhysicalAfterDelay.lf | 8 +- .../DistributedCountPhysicalDecentralized.lf | 8 +- .../src/federated/DistributedDoublePort.lf | 9 +- .../src/federated/DistributedLoopedAction.lf | 6 +- ...ibutedLoopedPhysicalActionDecentralized.lf | 10 +- .../federated/DistributedMultiportToken.lf | 4 +- .../src/federated/DistributedNoReact.lf | 20 +-- .../federated/DistributedStopDecentralized.lf | 8 +- .../src/federated/DistributedStructAsType.lf | 10 +- .../DistributedStructAsTypeDirect.lf | 10 +- .../federated/DistributedStructParallel.lf | 22 +-- .../src/federated/DistributedStructPrint.lf | 10 +- .../src/federated/DistributedStructScale.lf | 14 +- test/Python/src/federated/HelloDistributed.lf | 10 +- ...stributedCentralizedPrecedenceHierarchy.lf | 5 +- .../src/federated/ParallelDestinations.lf | 18 +-- test/Python/src/federated/ParallelSources.lf | 18 +-- .../src/federated/ParallelSourcesMultiport.lf | 30 ++--- test/Python/src/federated/PhysicalSTP.lf | 5 +- .../src/federated/PingPongDistributed.lf | 16 ++- test/Python/src/lib/Imported.lf | 6 +- test/Python/src/lib/ImportedAgain.lf | 14 +- test/Python/src/lib/ImportedComposition.lf | 20 +-- test/Python/src/lib/LoopedActionSender.lf | 7 +- test/Python/src/lib/TestCount.lf | 5 +- test/Python/src/lib/TestCountMultiport.lf | 11 +- .../modal_models/BanksCount3ModesSimple.lf | 40 +++--- .../src/modal_models/BanksModalStateReset.lf | 8 +- .../src/modal_models/ConvertCaseTest.lf | 4 +- test/Python/src/modal_models/ModalActions.lf | 7 +- .../src/modal_models/ModalCycleBreaker.lf | 8 +- .../src/modal_models/ModalNestedReactions.lf | 92 ++++++------- .../src/modal_models/ModalStartupShutdown.lf | 3 +- .../src/modal_models/ModalStateReset.lf | 3 +- .../src/modal_models/ModalStateResetAuto.lf | 3 +- test/Python/src/modal_models/ModalTimers.lf | 3 +- .../MultipleOutputFeeder_2Connections.lf | 10 +- ...ultipleOutputFeeder_ReactionConnections.lf | 14 +- .../src/multiport/BankReactionsInContainer.lf | 4 +- test/Python/src/multiport/BroadcastAfter.lf | 10 +- .../Python/src/multiport/MultiportFromBank.lf | 8 +- .../multiport/MultiportFromBankHierarchy.lf | 4 +- .../MultiportFromBankHierarchyAfter.lf | 10 +- .../src/multiport/MultiportFromHierarchy.lf | 3 +- test/Python/src/multiport/MultiportIn.lf | 4 +- .../src/multiport/MultiportInParameterized.lf | 4 +- .../src/multiport/MultiportMutableInput.lf | 5 +- .../multiport/MultiportMutableInputArray.lf | 7 +- .../src/multiport/MultiportToBankAfter.lf | 3 +- .../src/multiport/MultiportToBankHierarchy.lf | 4 +- .../src/multiport/MultiportToHierarchy.lf | 5 +- .../multiport/MultiportToMultiportArray.lf | 3 +- test/Python/src/multiport/MultiportToPort.lf | 3 +- test/Python/src/multiport/PipelineAfter.lf | 40 +++--- .../Python/src/multiport/ReactionsToNested.lf | 3 +- .../serialization/PersonProtocolBuffers.lf | 28 ++-- .../src/serialization/ProtoNoPacking.lf | 30 ++--- test/Python/src/target/AfterNoTypes.lf | 4 +- test/Rust/src/ActionIsPresentDouble.lf | 28 ++-- test/Rust/src/ActionValuesCleanup.lf | 4 +- .../src/CompositionInitializationOrder.lf | 10 +- test/Rust/src/DependencyOnChildPort.lf | 4 +- test/Rust/src/DependencyThroughChildPort.lf | 70 +++++----- test/Rust/src/DependencyUseAccessible.lf | 60 ++++----- test/Rust/src/DependencyUseNonTrigger.lf | 18 +-- test/Rust/src/Import.lf | 6 +- test/Rust/src/ImportPreambleItem.lf | 4 +- test/Rust/src/Minimal.lf | 2 +- ...ysicalActionCanBeScheduledSynchronously.lf | 34 ++--- .../src/PhysicalActionKeepaliveIsSmart.lf | 30 ++--- .../PhysicalActionWakesSleepingScheduler.lf | 28 ++-- test/Rust/src/PhysicalActionWithKeepalive.lf | 34 ++--- test/Rust/src/Preamble.lf | 12 +- test/Rust/src/ReactionLabels.lf | 4 +- test/Rust/src/ReservedKeywords.lf | 3 +- test/Rust/src/SingleFileGeneration.lf | 30 ++--- test/Rust/src/StateDefaultValue.lf | 18 +-- test/Rust/src/StateInitializerVisibility.lf | 4 +- test/Rust/src/Stop.lf | 7 +- test/Rust/src/StopAsync.lf | 22 +-- test/Rust/src/StopCleanup.lf | 30 ++--- test/Rust/src/StopDuringStartup.lf | 20 +-- test/Rust/src/StopNoEvent.lf | 2 +- test/Rust/src/StopTimeout.lf | 10 +- test/Rust/src/StopTimeoutExact.lf | 4 +- test/Rust/src/StopTopology.lf | 24 ++-- test/Rust/src/StructAsState.lf | 4 +- test/Rust/src/concurrent/Workers.lf | 16 +-- test/Rust/src/generics/GenericReactor.lf | 4 +- test/Rust/src/lib/Imported.lf | 6 +- test/Rust/src/lib/ImportedAgain.lf | 10 +- test/Rust/src/lib/SomethingWithAPreamble.lf | 12 +- test/Rust/src/multiport/CycledLhs_SelfLoop.lf | 8 +- test/Rust/src/multiport/CycledLhs_Single.lf | 14 +- .../src/multiport/MultiportFromHierarchy.lf | 3 +- test/Rust/src/multiport/MultiportIn.lf | 4 +- .../src/multiport/MultiportToMultiport2.lf | 3 +- .../src/target/BuildProfileDefaultIsDev.lf | 8 +- test/Rust/src/target/BuildProfileRelease.lf | 10 +- test/Rust/src/target/CargoDependency.lf | 18 +-- .../src/target/CargoDependencyOnRuntime.lf | 10 +- test/Rust/src/target/ModuleDependency.lf | 14 +- .../target/ModuleDependencyWithDirModule.lf | 16 +-- test/TypeScript/src/ActionWithNoReaction.lf | 40 +++--- test/TypeScript/src/After.lf | 3 +- test/TypeScript/src/ArrayAsType.lf | 5 +- test/TypeScript/src/ArrayPrint.lf | 5 +- test/TypeScript/src/ArrayScale.lf | 7 +- test/TypeScript/src/Composition.lf | 3 +- test/TypeScript/src/CompositionAfter.lf | 3 +- test/TypeScript/src/DanglingOutput.lf | 24 ++-- test/TypeScript/src/Deadline.lf | 5 +- test/TypeScript/src/DeadlineHandledAbove.lf | 4 +- test/TypeScript/src/DelayInt.lf | 4 +- test/TypeScript/src/DelayedReaction.lf | 28 ++-- test/TypeScript/src/Determinism.lf | 58 ++++---- test/TypeScript/src/DoubleInvocation.lf | 9 +- test/TypeScript/src/DoubleReaction.lf | 4 +- test/TypeScript/src/DoubleTrigger.lf | 3 +- test/TypeScript/src/GetTime.lf | 26 ++-- test/TypeScript/src/HelloWorld.lf | 6 +- test/TypeScript/src/Hierarchy.lf | 70 +++++----- test/TypeScript/src/Import.lf | 8 +- test/TypeScript/src/Microsteps.lf | 58 ++++---- test/TypeScript/src/Minimal.lf | 4 +- test/TypeScript/src/MovingAverage.lf | 5 +- test/TypeScript/src/MultipleContained.lf | 48 +++---- test/TypeScript/src/Preamble.lf | 28 ++-- .../src/ReadOutputOfContainedReactor.lf | 3 +- test/TypeScript/src/Schedule.lf | 30 ++--- test/TypeScript/src/ScheduleLogicalAction.lf | 4 +- test/TypeScript/src/SendingInside.lf | 4 +- test/TypeScript/src/SendingInside2.lf | 20 +-- test/TypeScript/src/SendsPointerTest.lf | 4 +- test/TypeScript/src/SimpleDeadline.lf | 5 +- test/TypeScript/src/SimpleImport.lf | 4 +- test/TypeScript/src/SlowingClockPhysical.lf | 14 +- test/TypeScript/src/Stop.lf | 3 +- test/TypeScript/src/Stride.lf | 4 +- test/TypeScript/src/StructPrint.lf | 4 +- test/TypeScript/src/TestForPreviousOutput.lf | 54 ++++---- test/TypeScript/src/TimeLimit.lf | 7 +- test/TypeScript/src/Wcet.lf | 58 ++++---- .../src/docker/HelloWorldContainerized.lf | 4 +- .../src/federated/ChainWithDelay.lf | 12 +- .../src/federated/DistributedCount.lf | 7 +- .../src/federated/DistributedDoublePort.lf | 9 +- .../src/federated/DistributedLoopedAction.lf | 6 +- .../DistributedLoopedPhysicalAction.lf | 8 +- .../src/federated/DistributedStop.lf | 3 +- .../src/federated/DistributedStopZero.lf | 98 +++++++------- .../src/federated/HelloDistributed.lf | 11 +- .../federated/LoopDistributedCentralized.lf | 3 +- .../src/federated/LoopDistributedDouble.lf | 3 +- .../src/federated/SimpleFederated.lf | 14 +- .../src/federated/StopAtShutdown.lf | 24 ++-- .../src/federated/TopLevelArtifacts.lf | 7 +- test/TypeScript/src/lib/Imported.lf | 8 +- test/TypeScript/src/lib/ImportedAgain.lf | 16 +-- test/TypeScript/src/lib/LoopedActionSender.lf | 7 +- test/TypeScript/src/lib/TestCount.lf | 5 +- .../TypeScript/src/multiport/BankMulticast.lf | 28 ++-- .../src/multiport/BankReactionsInContainer.lf | 4 +- .../src/multiport/BankSelfBroadcast.lf | 6 +- test/TypeScript/src/multiport/Broadcast.lf | 24 ++-- .../src/multiport/MultiportFromBank.lf | 4 +- .../multiport/MultiportFromBankHierarchy.lf | 4 +- .../MultiportFromBankHierarchyAfter.lf | 8 +- .../src/multiport/MultiportFromHierarchy.lf | 3 +- test/TypeScript/src/multiport/MultiportIn.lf | 4 +- .../src/multiport/MultiportInParameterized.lf | 4 +- .../src/multiport/MultiportMutableInput.lf | 5 +- .../multiport/MultiportMutableInputArray.lf | 7 +- .../src/multiport/MultiportToBank.lf | 32 ++--- .../src/multiport/MultiportToBankAfter.lf | 3 +- .../src/multiport/MultiportToBankDouble.lf | 8 +- .../src/multiport/MultiportToBankHierarchy.lf | 4 +- .../src/multiport/MultiportToHierarchy.lf | 5 +- .../multiport/MultiportToMultiportArray.lf | 3 +- .../src/multiport/MultiportToPort.lf | 3 +- .../TypeScript/src/multiport/PipelineAfter.lf | 40 +++--- .../src/multiport/ReactionsToNested.lf | 3 +- .../src/serialization/ProtoNoPacking.lf | 42 +++--- test/TypeScript/src/target/AfterNoTypes.lf | 3 +- 529 files changed, 3735 insertions(+), 3411 deletions(-) diff --git a/README.md b/README.md index 4825e78573..8c04a318a5 100644 --- a/README.md +++ b/README.md @@ -19,5 +19,3 @@ Lingua Franca (LF) is a polyglot coordination language for concurrent and possib See [lf-lang.org](https://lf-lang.org) for installation instructions and documentation. See also the [wiki](https://github.com/icyphy/lingua-franca/wiki) for further information on ongoing projects. See our [Publications and Presentations](https://www.lf-lang.org/publications-and-presentations). - - diff --git a/REQUIREMENTS.md b/REQUIREMENTS.md index 9a63d0e71a..ddeff25a77 100644 --- a/REQUIREMENTS.md +++ b/REQUIREMENTS.md @@ -11,7 +11,7 @@ This document includes information about supported operating systems and externa | Windows | >= 10 1903 | Y | Y | Y | Y | ### **Dependencies** - - Java >= 11 +- Java >= 11 In order to develop the core Lingua Franca, the only basic requirement is to have Java >= 11 installed. You should be able to download and run the provided Eclipse development project (see [Downloading and Building](https://github.com/icyphy/lingua-franca/wiki/Downloading-and-Building)). This will get you as far as modifying the under-the-hood code of Lingua Franca, and contributing to the ongoing open-source effort. Please see [Contribution](). @@ -20,7 +20,7 @@ With Java (>= 11), you should also be able to use the provided Eclipse IDE produ However, to compile the generated code and to create a binary (which is done by default), each target language in Lingua Franca has an additional set of requirements, which are listed in this section. We also include a list of tested operating systems in the format of a compact table below. -**Note:** Compiling the generated code is generally automatically done in the Eclipse IDE or while using the `lfc` command line tool. This default behavior can be disabled, however, using the [no-compile](https://github.com/icyphy/lingua-franca/wiki/target-specification#no-compile) target property in your Lingua Franca program or by using the `-n` argument for the `lfc` command line tool (see [Command Line Tools](https://github.com/icyphy/lingua-franca/wiki/Command-Line-Tools)). +**Note:** Compiling the generated code is generally automatically done in the Eclipse IDE or while using the `lfc` command line tool. This default behavior can be disabled, however, using the [no-compile](https://github.com/icyphy/lingua-franca/wiki/target-specification#no-compile) target property in your Lingua Franca program or by using the `-n` argument for the `lfc` command line tool (see [Command Line Tools](https://github.com/icyphy/lingua-franca/wiki/Command-Line-Tools)). ### Supported Operating Systems @@ -34,24 +34,24 @@ However, to compile the generated code and to create a binary (which is done by ### Dependencies **C:** - - A C compiler (e.g., gcc >= 7, clang, or MSVC >= 14.20) - - CMAKE >= 3.13 (follow https://cmake.org/install/ for installation instructions) - - **Windows Only:** Visual Studio >= 2019 and Windows SDK >= 10.0.18362.0 - - **Programs using Protocol Buffers:** protoc-c 1.3.3 - see https://github.com/icyphy/lingua-franca/wiki/Protobufs. +- A C compiler (e.g., gcc >= 7, clang, or MSVC >= 14.20) +- CMAKE >= 3.13 (follow https://cmake.org/install/ for installation instructions) +- **Windows Only:** Visual Studio >= 2019 and Windows SDK >= 10.0.18362.0 +- **Programs using Protocol Buffers:** protoc-c 1.3.3 - see https://github.com/icyphy/lingua-franca/wiki/Protobufs. **C++:** - - g++ >= 7 or MSVC >= 14.20 - 1920 (Visual Studio 2019) - - CMAKE >= 3.16 (follow https://cmake.org/install/ for installation instructions) - - **Windows Only:** Visual Studio >= 2019 and Windows SDK >= 10.0.18362.0 +- g++ >= 7 or MSVC >= 14.20 - 1920 (Visual Studio 2019) +- CMAKE >= 3.16 (follow https://cmake.org/install/ for installation instructions) +- **Windows Only:** Visual Studio >= 2019 and Windows SDK >= 10.0.18362.0 **Python:** - - A C compiler (e.g., gcc >= 7, clang, or MSVC >= 14.20) - - Python >= 3.6 - - pip >= 20.0.2 - - setuptools >= 45.2.0-1 - - **Windows Only:** Visual Studio >= 2019 and Windows SDK >= 10.0.18362.0 - - **Programs using Protocol Buffers:** protoc >= 3.6.1 +- A C compiler (e.g., gcc >= 7, clang, or MSVC >= 14.20) +- Python >= 3.6 +- pip >= 20.0.2 +- setuptools >= 45.2.0-1 +- **Windows Only:** Visual Studio >= 2019 and Windows SDK >= 10.0.18362.0 +- **Programs using Protocol Buffers:** protoc >= 3.6.1 **TypeScript:** - - pnpm >= 6 or npm >= 6.14.4 - - **Programs using Protocol Buffers:** protoc >= 3.6.1 (for using protobuf and data serialization - see https://github.com/icyphy/lingua-franca/wiki/Protobufs) +- pnpm >= 6 or npm >= 6.14.4 +- **Programs using Protocol Buffers:** protoc >= 3.6.1 (for using protobuf and data serialization - see https://github.com/icyphy/lingua-franca/wiki/Protobufs) diff --git a/test/C/src/ActionWithNoReaction.lf b/test/C/src/ActionWithNoReaction.lf index 1cfe5bfba2..87f1c707c2 100644 --- a/test/C/src/ActionWithNoReaction.lf +++ b/test/C/src/ActionWithNoReaction.lf @@ -1,36 +1,36 @@ // This checks that action can be created even if there is no reaction. This test passes merely by // compiling and executing without a segfault. Its other functionality is tested by other tests. target C { - fast: true, - timeout: 3 sec + fast: true, + timeout: 3 sec } reactor foo { - input x: int - output y: int - logical action a: int* + input x: int + output y: int + logical action a: int* - reaction(x) -> y, a {= // reaction(a) {= =} - lf_set(y, 2*x->value); - lf_schedule(a, MSEC(500)); - =} + reaction(x) -> y, a {= // reaction(a) {= =} + lf_set(y, 2*x->value); + lf_schedule(a, MSEC(500)); + =} } reactor print { - input x: int + input x: int - reaction(x) {= - printf("Result is %d\n", x->value); - printf("Current logical time is: %lld\n", lf_time_logical_elapsed()); - printf("Current physical time is: %lld\n", lf_time_physical_elapsed()); - =} + reaction(x) {= + printf("Result is %d\n", x->value); + printf("Current logical time is: %lld\n", lf_time_logical_elapsed()); + printf("Current physical time is: %lld\n", lf_time_physical_elapsed()); + =} } main reactor ActionWithNoReaction { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x after 10 msec + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x after 10 msec - reaction(t) -> f.x {= lf_set(f.x, 42); =} + reaction(t) -> f.x {= lf_set(f.x, 42); =} } diff --git a/test/C/src/After.lf b/test/C/src/After.lf index a066cfcb35..d3663457e4 100644 --- a/test/C/src/After.lf +++ b/test/C/src/After.lf @@ -1,4 +1,5 @@ -// This checks that the after keyword adjusts logical time, not using physical time. +// This checks that the after keyword adjusts logical time, not using physical +// time. target C { fast: false, timeout: 3 sec diff --git a/test/C/src/AfterCycles.lf b/test/C/src/AfterCycles.lf index c79e33bb31..d7d621046b 100644 --- a/test/C/src/AfterCycles.lf +++ b/test/C/src/AfterCycles.lf @@ -1,5 +1,5 @@ -// This tests that "after" does not introduce spurious cycles. Success if running without detected a -// cycle. +// This tests that "after" does not introduce spurious cycles. Success if +// running without detected a cycle. target C reactor Source { diff --git a/test/C/src/AfterZero.lf b/test/C/src/AfterZero.lf index 265f866b59..378114c730 100644 --- a/test/C/src/AfterZero.lf +++ b/test/C/src/AfterZero.lf @@ -1,4 +1,5 @@ -// This checks that the after keyword adjusts logical time, not using physical time. +// This checks that the after keyword adjusts logical time, not using physical +// time. target C { fast: false, timeout: 3 sec diff --git a/test/C/src/Alignment.lf b/test/C/src/Alignment.lf index e63ff904b8..a2b9b523fb 100644 --- a/test/C/src/Alignment.lf +++ b/test/C/src/Alignment.lf @@ -1,4 +1,5 @@ -// This test checks that the downstream reaction is not invoked more than once at a logical time. +// This test checks that the downstream reaction is not invoked more than once +// at a logical time. target C { logging: LOG, timeout: 1 sec diff --git a/test/C/src/ArrayAsParameter.lf b/test/C/src/ArrayAsParameter.lf index 17718f0135..a9df29cb03 100644 --- a/test/C/src/ArrayAsParameter.lf +++ b/test/C/src/ArrayAsParameter.lf @@ -1,5 +1,6 @@ -// Source has an array as a parameter, the elements of which it passes to Print. The length of the -// array has to also be a parameter because C arrays do not encode their own length. +// Source has an array as a parameter, the elements of which it passes to Print. +// The length of the array has to also be a parameter because C arrays do not +// encode their own length. target C reactor Source(sequence: int[] = {0, 1, 2}, n_sequence: int = 3) { diff --git a/test/C/src/ArrayAsType.lf b/test/C/src/ArrayAsType.lf index a24f34e0a6..c95e5bf385 100644 --- a/test/C/src/ArrayAsType.lf +++ b/test/C/src/ArrayAsType.lf @@ -1,5 +1,5 @@ -// Source produces a statically allocated array, which it passes to Print. The destination -// references the array directly. +// Source produces a statically allocated array, which it passes to Print. The +// destination references the array directly. target C reactor Source { diff --git a/test/C/src/ArrayParallel.lf b/test/C/src/ArrayParallel.lf index cc7b9c0e2b..6275924b82 100644 --- a/test/C/src/ArrayParallel.lf +++ b/test/C/src/ArrayParallel.lf @@ -10,13 +10,13 @@ import Scale from "ArrayScale.lf" import Source, Print from "ArrayPrint.lf" main reactor ArrayParallel { - s = new Source() - c1 = new Scale() - c2 = new Scale(scale = 3) - p1 = new Print(scale = 2) - p2 = new Print(scale = 3) - s.out -> c1.in - s.out -> c2.in - c1.out -> p1.in - c2.out -> p2.in + s = new Source() + c1 = new Scale() + c2 = new Scale(scale = 3) + p1 = new Print(scale = 2) + p2 = new Print(scale = 3) + s.out -> c1.in + s.out -> c2.in + c1.out -> p1.in + c2.out -> p2.in } diff --git a/test/C/src/Composition.lf b/test/C/src/Composition.lf index 0f79a7465c..7c024a9eba 100644 --- a/test/C/src/Composition.lf +++ b/test/C/src/Composition.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target C { fast: true, timeout: 10 sec diff --git a/test/C/src/CompositionAfter.lf b/test/C/src/CompositionAfter.lf index 98a0703138..cb98ef7d7e 100644 --- a/test/C/src/CompositionAfter.lf +++ b/test/C/src/CompositionAfter.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target C { fast: true, timeout: 10 sec diff --git a/test/C/src/CompositionGain.lf b/test/C/src/CompositionGain.lf index 31cd7e5123..0b0ead780f 100644 --- a/test/C/src/CompositionGain.lf +++ b/test/C/src/CompositionGain.lf @@ -2,33 +2,33 @@ target C reactor Gain { - input gainin: int - output y: int + input gainin: int + output y: int - reaction(gainin) -> y {= - printf("Gain received %d\n", gainin->value); - lf_set(y, gainin->value * 2); - =} + reaction(gainin) -> y {= + printf("Gain received %d\n", gainin->value); + lf_set(y, gainin->value * 2); + =} } reactor Wrapper { - input x: int - output y: int - gain = new Gain() - x -> gain.gainin - gain.y -> y + input x: int + output y: int + gain = new Gain() + x -> gain.gainin + gain.y -> y } main reactor CompositionGain { - wrapper = new Wrapper() + wrapper = new Wrapper() - reaction(startup) -> wrapper.x {= lf_set(wrapper.x, 42); =} + reaction(startup) -> wrapper.x {= lf_set(wrapper.x, 42); =} - reaction(wrapper.y) {= - printf("Received %d\n", wrapper.y->value); - if (wrapper.y->value != 42 * 2) { - fprintf(stderr, "ERROR: Received value should have been %d.\n", 42 * 2); - exit(2); - } - =} + reaction(wrapper.y) {= + printf("Received %d\n", wrapper.y->value); + if (wrapper.y->value != 42 * 2) { + fprintf(stderr, "ERROR: Received value should have been %d.\n", 42 * 2); + exit(2); + } + =} } diff --git a/test/C/src/CompositionInheritance.lf b/test/C/src/CompositionInheritance.lf index 3b3f9ea905..06221e9788 100644 --- a/test/C/src/CompositionInheritance.lf +++ b/test/C/src/CompositionInheritance.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target C { fast: true, timeout: 10 sec diff --git a/test/C/src/CountTest.lf b/test/C/src/CountTest.lf index 323302d132..7ac4349d2a 100644 --- a/test/C/src/CountTest.lf +++ b/test/C/src/CountTest.lf @@ -1,14 +1,14 @@ target C { - timeout: 3 sec, - tracing: true, - fast: true + timeout: 3 sec, + tracing: true, + fast: true } import Count from "lib/Count.lf" import TestCount from "lib/TestCount.lf" main reactor CountTest { - count = new Count() - test = new TestCount(num_inputs = 4) - count.out -> test.in + count = new Count() + test = new TestCount(num_inputs = 4) + count.out -> test.in } diff --git a/test/C/src/DanglingOutput.lf b/test/C/src/DanglingOutput.lf index d13de1dac2..8c39ad5612 100644 --- a/test/C/src/DanglingOutput.lf +++ b/test/C/src/DanglingOutput.lf @@ -3,24 +3,24 @@ target C reactor Source { - output out: int - timer t + output out: int + timer t - reaction(t) -> out {= lf_set(out, 1); =} + reaction(t) -> out {= lf_set(out, 1); =} } reactor Gain { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= - printf("Received %d.\n", in->value); - lf_set(out, in->value * 2); - =} + reaction(in) -> out {= + printf("Received %d.\n", in->value); + lf_set(out, in->value * 2); + =} } main reactor DanglingOutput { - source = new Source() - container = new Gain() - source.out -> container.in + source = new Source() + container = new Gain() + source.out -> container.in } diff --git a/test/C/src/Deadline.lf b/test/C/src/Deadline.lf index bd48928bdc..21ea7df141 100644 --- a/test/C/src/Deadline.lf +++ b/test/C/src/Deadline.lf @@ -1,5 +1,6 @@ -// This example illustrates local deadline handling. Even numbers are sent by the Source -// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by +// the Source immediately, whereas odd numbers are sent after a big enough delay +// to violate the deadline. target C { timeout: 6 sec } diff --git a/test/C/src/DeadlineAnytime.lf b/test/C/src/DeadlineAnytime.lf index 37540fd10b..bc5ac67188 100644 --- a/test/C/src/DeadlineAnytime.lf +++ b/test/C/src/DeadlineAnytime.lf @@ -2,25 +2,25 @@ target C reactor A { - state i: int - logical action a + state i: int + logical action a - reaction(startup) -> a {= - self->i = 0; - while (!lf_check_deadline(self, true)); - =} deadline(10 msec) {= lf_schedule(a, 0); =} + reaction(startup) -> a {= + self->i = 0; + while (!lf_check_deadline(self, true)); + =} deadline(10 msec) {= lf_schedule(a, 0); =} - reaction(a) {= self->i = 42; =} + reaction(a) {= self->i = 42; =} - reaction(shutdown) {= - if (self->i == 42) { - printf("SUCCESS\n"); - } else { - lf_print_error_and_exit("Expected 42, but got %d", self->i); - } - =} + reaction(shutdown) {= + if (self->i == 42) { + printf("SUCCESS\n"); + } else { + lf_print_error_and_exit("Expected 42, but got %d", self->i); + } + =} } main reactor { - a = new A() + a = new A() } diff --git a/test/C/src/DeadlineHandledAbove.lf b/test/C/src/DeadlineHandledAbove.lf index 939d90b1d6..3b0dc49198 100644 --- a/test/C/src/DeadlineHandledAbove.lf +++ b/test/C/src/DeadlineHandledAbove.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the container reacts to that -// output. +// Test a deadline where the deadline violation produces an output and the +// container reacts to that output. target C preamble {= diff --git a/test/C/src/DelayArrayWithAfter.lf b/test/C/src/DelayArrayWithAfter.lf index cc270d9bb8..c94be3b9a1 100644 --- a/test/C/src/DelayArrayWithAfter.lf +++ b/test/C/src/DelayArrayWithAfter.lf @@ -1,4 +1,5 @@ -// This tests transport of dynamically allocated arrays over connections with 'after'. +// This tests transport of dynamically allocated arrays over connections with +// 'after'. target C { timeout: 5 sec, fast: true diff --git a/test/C/src/DelayInt.lf b/test/C/src/DelayInt.lf index 74eb50f1f4..78ca793716 100644 --- a/test/C/src/DelayInt.lf +++ b/test/C/src/DelayInt.lf @@ -6,7 +6,9 @@ reactor Delay(delay: time = 100 msec) { output out: int logical action a: int - reaction(a) -> out {= if (a->has_value && a->is_present) lf_set(out, a->value); =} + reaction(a) -> out {= + if (a->has_value && a->is_present) lf_set(out, a->value); + =} reaction(in) -> a {= // Use specialized form of schedule for integer payloads. diff --git a/test/C/src/DelayString.lf b/test/C/src/DelayString.lf index c5252bde55..1b4204cfc4 100644 --- a/test/C/src/DelayString.lf +++ b/test/C/src/DelayString.lf @@ -1,4 +1,5 @@ -// This tests actions with immutable payloads that are neither malloc'd nor freed. +// This tests actions with immutable payloads that are neither malloc'd nor +// freed. target C preamble {= diff --git a/test/C/src/DelayedReaction.lf b/test/C/src/DelayedReaction.lf index 2dcf80f106..dbdec1a2e8 100644 --- a/test/C/src/DelayedReaction.lf +++ b/test/C/src/DelayedReaction.lf @@ -2,27 +2,27 @@ target C reactor Source { - output out: int - timer t + output out: int + timer t - reaction(t) -> out {= lf_set(out, 1); =} + reaction(t) -> out {= lf_set(out, 1); =} } reactor Sink { - input in: int + input in: int - reaction(in) {= - interval_t elapsed = lf_time_logical_elapsed(); - printf("Nanoseconds since start: %lld.\n", elapsed); - if (elapsed != 100000000LL) { - printf("ERROR: Expected 100000000 but.\n"); - exit(1); - } - =} + reaction(in) {= + interval_t elapsed = lf_time_logical_elapsed(); + printf("Nanoseconds since start: %lld.\n", elapsed); + if (elapsed != 100000000LL) { + printf("ERROR: Expected 100000000 but.\n"); + exit(1); + } + =} } main reactor DelayedReaction { - source = new Source() - sink = new Sink() - source.out -> sink.in after 100 msec + source = new Source() + sink = new Sink() + source.out -> sink.in after 100 msec } diff --git a/test/C/src/Determinism.lf b/test/C/src/Determinism.lf index fea5290373..a063b108f0 100644 --- a/test/C/src/Determinism.lf +++ b/test/C/src/Determinism.lf @@ -1,46 +1,46 @@ target C reactor Source { - output y: int - timer t + output y: int + timer t - reaction(t) -> y {= lf_set(y, 1); =} + reaction(t) -> y {= lf_set(y, 1); =} } reactor Destination { - input x: int - input y: int + input x: int + input y: int - reaction(x, y) {= - int sum = 0; - if (x->is_present) { - sum += x->value; - } - if (y->is_present) { - sum += y->value; - } - printf("Received %d.\n", sum); - if (sum != 2) { - printf("FAILURE: Expected 2.\n"); - exit(4); - } - =} + reaction(x, y) {= + int sum = 0; + if (x->is_present) { + sum += x->value; + } + if (y->is_present) { + sum += y->value; + } + printf("Received %d.\n", sum); + if (sum != 2) { + printf("FAILURE: Expected 2.\n"); + exit(4); + } + =} } reactor Pass { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= lf_set(y, x->value); =} + reaction(x) -> y {= lf_set(y, x->value); =} } main reactor Determinism { - s = new Source() - d = new Destination() - p1 = new Pass() - p2 = new Pass() - s.y -> d.y - s.y -> p1.x - p1.y -> p2.x - p2.y -> d.x + s = new Source() + d = new Destination() + p1 = new Pass() + p2 = new Pass() + s.y -> d.y + s.y -> p1.x + p1.y -> p2.x + p2.y -> d.x } diff --git a/test/C/src/DoubleInvocation.lf b/test/C/src/DoubleInvocation.lf index 687b03a603..973c8b18f6 100644 --- a/test/C/src/DoubleInvocation.lf +++ b/test/C/src/DoubleInvocation.lf @@ -1,7 +1,8 @@ -// This illustrates a very strange bug that showed up and has now been fixed. This test ensures it -// does not reappear. At logical time zero, the two Print reactors used to be fired twice each at -// the same logical time. They should only be fired once. This behavior was oddly eliminated by -// either of the following actions, neither of which should affect this behavior: +// This illustrates a very strange bug that showed up and has now been fixed. +// This test ensures it does not reappear. At logical time zero, the two Print +// reactors used to be fired twice each at the same logical time. They should +// only be fired once. This behavior was oddly eliminated by either of the +// following actions, neither of which should affect this behavior: // * Removing the startup reaction in Print. // * Sending only position, not velocity from Ball. target C { diff --git a/test/C/src/DoublePort.lf b/test/C/src/DoublePort.lf index 3baab84667..c8bf9811f8 100644 --- a/test/C/src/DoublePort.lf +++ b/test/C/src/DoublePort.lf @@ -1,6 +1,7 @@ /** - * Test the case where two upstream reactors pass messages to a downstream reactor on two different - * ports. One message carries a microstep delay relative to the other. + * Test the case where two upstream reactors pass messages to a downstream + * reactor on two different ports. One message carries a microstep delay + * relative to the other. * * @author Soroush Bateni */ @@ -35,7 +36,9 @@ reactor Print { } =} - reaction(shutdown) {= printf("SUCCESS: messages were at least one microstep apart.\n"); =} + reaction(shutdown) {= + printf("SUCCESS: messages were at least one microstep apart.\n"); + =} } main reactor DoublePort { diff --git a/test/C/src/DoubleReaction.lf b/test/C/src/DoubleReaction.lf index 0c78b9805d..8da6210825 100644 --- a/test/C/src/DoubleReaction.lf +++ b/test/C/src/DoubleReaction.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output -// for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only +// once. Correct output for this 2, 4, 6, 8, etc. target C { timeout: 10 sec, fast: true diff --git a/test/C/src/DoubleTrigger.lf b/test/C/src/DoubleTrigger.lf index 9106853af3..68ad603168 100644 --- a/test/C/src/DoubleTrigger.lf +++ b/test/C/src/DoubleTrigger.lf @@ -1,4 +1,5 @@ -// Test that two simultaneous triggers don't cause a reaction to execute twice at the same tag. +// Test that two simultaneous triggers don't cause a reaction to execute twice +// at the same tag. target C { timeout: 1 sec, fast: true diff --git a/test/C/src/FloatLiteral.lf b/test/C/src/FloatLiteral.lf index 3c8bfa6037..576a20d1ac 100644 --- a/test/C/src/FloatLiteral.lf +++ b/test/C/src/FloatLiteral.lf @@ -1,6 +1,7 @@ target C -main reactor { // This test verifies that floating-point literals are handled correctly. +// This test verifies that floating-point literals are handled correctly. +main reactor { preamble {= #include =} diff --git a/test/C/src/GetTime.lf b/test/C/src/GetTime.lf index 77a8f980f9..324195ddc9 100644 --- a/test/C/src/GetTime.lf +++ b/test/C/src/GetTime.lf @@ -1,26 +1,26 @@ // This file includes code documented on the Wiki. For this test, success is just compiling and // running. target C { - timeout: 2 sec, - fast: false + timeout: 2 sec, + fast: false } main reactor GetTime { - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) {= - instant_t logical = lf_time_logical(); - printf("Logical time is %lld.\n", logical); + reaction(t) {= + instant_t logical = lf_time_logical(); + printf("Logical time is %lld.\n", logical); - interval_t elapsed = lf_time_logical_elapsed(); - printf("Elapsed logical time is %lld.\n", elapsed); + interval_t elapsed = lf_time_logical_elapsed(); + printf("Elapsed logical time is %lld.\n", elapsed); - instant_t physical = lf_time_physical(); - printf("Physical time is %lld.\n", physical); + instant_t physical = lf_time_physical(); + printf("Physical time is %lld.\n", physical); - instant_t elapsed_physical = lf_time_physical_elapsed(); - printf("Elapsed physical time is %lld.\n", elapsed_physical); + instant_t elapsed_physical = lf_time_physical_elapsed(); + printf("Elapsed physical time is %lld.\n", elapsed_physical); - printf("Time lag is %lld.\n", physical - logical); - =} + printf("Time lag is %lld.\n", physical - logical); + =} } diff --git a/test/C/src/Hierarchy.lf b/test/C/src/Hierarchy.lf index ea14165e24..71aa7f9269 100644 --- a/test/C/src/Hierarchy.lf +++ b/test/C/src/Hierarchy.lf @@ -2,50 +2,50 @@ target C reactor Source { - output out: int - timer t + output out: int + timer t - reaction(t) -> out {= lf_set(out, 1); =} + reaction(t) -> out {= lf_set(out, 1); =} } reactor Gain { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= - printf("Gain received %d.\n", in->value); - lf_set(out, in->value * 2); - =} + reaction(in) -> out {= + printf("Gain received %d.\n", in->value); + lf_set(out, in->value * 2); + =} } reactor Print { - input in: int - - reaction(in) {= - printf("Received: %d.\n", in->value); - if (in->value != 2) { - printf("Expected 2.\n"); - exit(1); - } - =} + input in: int + + reaction(in) {= + printf("Received: %d.\n", in->value); + if (in->value != 2) { + printf("Expected 2.\n"); + exit(1); + } + =} } reactor GainContainer { - input in: int - output out: int - output out2: int - gain = new Gain() - in -> gain.in - gain.out -> out - gain.out -> out2 + input in: int + output out: int + output out2: int + gain = new Gain() + in -> gain.in + gain.out -> out + gain.out -> out2 } main reactor Hierarchy { - source = new Source() - container = new GainContainer() - print = new Print() - print2 = new Print() - source.out -> container.in - container.out -> print.in - container.out2 -> print2.in + source = new Source() + container = new GainContainer() + print = new Print() + print2 = new Print() + source.out -> container.in + container.out -> print.in + container.out2 -> print2.in } diff --git a/test/C/src/Import.lf b/test/C/src/Import.lf index 7df0fd24b6..812f14edaa 100644 --- a/test/C/src/Import.lf +++ b/test/C/src/Import.lf @@ -4,8 +4,8 @@ target C import Imported from "lib/Imported.lf" main reactor Import { - timer t - a = new Imported() + timer t + a = new Imported() - reaction(t) -> a.x {= lf_set(a.x, 42); =} + reaction(t) -> a.x {= lf_set(a.x, 42); =} } diff --git a/test/C/src/ImportComposition.lf b/test/C/src/ImportComposition.lf index 635a3b2b8f..22a1bfef87 100644 --- a/test/C/src/ImportComposition.lf +++ b/test/C/src/ImportComposition.lf @@ -1,4 +1,5 @@ -// This tests the ability to import a reactor definition that itself imports a reactor definition. +// This tests the ability to import a reactor definition that itself imports a +// reactor definition. target C import ImportedComposition from "lib/ImportedComposition.lf" diff --git a/test/C/src/ImportRenamed.lf b/test/C/src/ImportRenamed.lf index 7d549f04dd..6ddee69dfa 100644 --- a/test/C/src/ImportRenamed.lf +++ b/test/C/src/ImportRenamed.lf @@ -6,10 +6,10 @@ import Imported as Y from "lib/Imported.lf" import ImportedAgain as Z from "lib/ImportedAgain.lf" main reactor { - timer t - a = new X() - b = new Y() - c = new Z() + timer t + a = new X() + b = new Y() + c = new Z() - reaction(t) -> a.x {= lf_set(a.x, 42); =} + reaction(t) -> a.x {= lf_set(a.x, 42); =} } diff --git a/test/C/src/InheritanceAction.lf b/test/C/src/InheritanceAction.lf index 22c4904695..680ffe2f75 100644 --- a/test/C/src/InheritanceAction.lf +++ b/test/C/src/InheritanceAction.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target C { fast: true } diff --git a/test/C/src/Microsteps.lf b/test/C/src/Microsteps.lf index 795a4801a7..1e5cca7bf3 100644 --- a/test/C/src/Microsteps.lf +++ b/test/C/src/Microsteps.lf @@ -1,41 +1,41 @@ target C reactor Destination { - input x: int - input y: int + input x: int + input y: int - reaction(x, y) {= - interval_t elapsed = lf_time_logical_elapsed(); - printf("Time since start: %lld.\n", elapsed); - if (elapsed != 0LL) { - printf("Expected elapsed time to be 0, but it was %lld.\n", elapsed); - exit(1); - } - int count = 0; - if (x->is_present) { - printf(" x is present.\n"); - count++; - } - if (y->is_present) { - printf(" y is present.\n"); - count++; - } - if (count != 1) { - printf("Expected exactly one input to be present but got %d.\n", count); - exit(1); - } - =} + reaction(x, y) {= + interval_t elapsed = lf_time_logical_elapsed(); + printf("Time since start: %lld.\n", elapsed); + if (elapsed != 0LL) { + printf("Expected elapsed time to be 0, but it was %lld.\n", elapsed); + exit(1); + } + int count = 0; + if (x->is_present) { + printf(" x is present.\n"); + count++; + } + if (y->is_present) { + printf(" y is present.\n"); + count++; + } + if (count != 1) { + printf("Expected exactly one input to be present but got %d.\n", count); + exit(1); + } + =} } main reactor Microsteps { - timer start - logical action repeat - d = new Destination() + timer start + logical action repeat + d = new Destination() - reaction(start) -> d.x, repeat {= - lf_set(d.x, 1); - lf_schedule(repeat, 0); - =} + reaction(start) -> d.x, repeat {= + lf_set(d.x, 1); + lf_schedule(repeat, 0); + =} - reaction(repeat) -> d.y {= lf_set(d.y, 1); =} + reaction(repeat) -> d.y {= lf_set(d.y, 1); =} } diff --git a/test/C/src/Minimal.lf b/test/C/src/Minimal.lf index 350f92a795..b2534ab993 100644 --- a/test/C/src/Minimal.lf +++ b/test/C/src/Minimal.lf @@ -2,5 +2,5 @@ target C main reactor Minimal { - reaction(startup) {= printf("Hello World.\n"); =} + reaction(startup) {= printf("Hello World.\n"); =} } diff --git a/test/C/src/MovingAverage.lf b/test/C/src/MovingAverage.lf index a477e55804..a8309aa9d3 100644 --- a/test/C/src/MovingAverage.lf +++ b/test/C/src/MovingAverage.lf @@ -1,5 +1,6 @@ -// Demonstration of a state variable that is an array. The MovingAverage reactor computes the moving -// average of the last four inputs and produces that as output. The source is a counting sequence. +// Demonstration of a state variable that is an array. The MovingAverage reactor +// computes the moving average of the last four inputs and produces that as +// output. The source is a counting sequence. target C { timeout: 1 sec, fast: true diff --git a/test/C/src/MultipleContained.lf b/test/C/src/MultipleContained.lf index f0fe73c6d5..540052ba87 100644 --- a/test/C/src/MultipleContained.lf +++ b/test/C/src/MultipleContained.lf @@ -1,4 +1,5 @@ -// Test that a reaction can react to and send two multiple ports of a contained reactor. +// Test that a reaction can react to and send two multiple ports of a contained +// reactor. target C reactor Contained { diff --git a/test/C/src/MultipleOutputs.lf b/test/C/src/MultipleOutputs.lf index b7609ab803..37b5ddba9f 100644 --- a/test/C/src/MultipleOutputs.lf +++ b/test/C/src/MultipleOutputs.lf @@ -1,6 +1,7 @@ -// This test checks for one of the issues arised in the solution of EECS149 Lab Chapter 7. In this -// case, a reactor has two output ports, the first one of which is dangling. The generated code -// should not have any segmentation faults. +// This test checks for one of the issues arised in the solution of EECS149 Lab +// Chapter 7. In this case, a reactor has two output ports, the first one of +// which is dangling. The generated code should not have any segmentation +// faults. target C { timeout: 1 sec, fast: true diff --git a/test/C/src/PingPong.lf b/test/C/src/PingPong.lf index e51f0160b8..2f1699a51d 100644 --- a/test/C/src/PingPong.lf +++ b/test/C/src/PingPong.lf @@ -1,20 +1,23 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing - * overhead. This is based on https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure + * message-passing overhead. This is based on + * https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the causality loop. + * Ping introduces a microstep delay using a logical action to break the + * causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * - Unthreaded: 97 msec * - Threaded: 265 msec * - * There is no parallelism in this application, so it does not benefit from being being threaded, - * just some additional overhead. + * There is no parallelism in this application, so it does not benefit from + * being being threaded, just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. These are about an - * order of magnitude faster than anything reported in the paper. + * These measurements are total execution time, including startup and shutdown. + * These are about an order of magnitude faster than anything reported in the + * paper. * * @author Edward A. Lee */ diff --git a/test/C/src/Preamble.lf b/test/C/src/Preamble.lf index 01b4b371b6..28fa5a7d5e 100644 --- a/test/C/src/Preamble.lf +++ b/test/C/src/Preamble.lf @@ -1,21 +1,21 @@ target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } main reactor Preamble { - preamble {= - #include - int add_42(int i) { - return i + 42; - } - =} - timer t + preamble {= + #include + int add_42(int i) { + return i + 42; + } + =} + timer t - reaction(t) {= - char* s = "42"; - int i = atoi(s); - printf("Converted string %s to int %d.\n", s, i); - printf("42 plus 42 is %d.\n", add_42(42)); - =} + reaction(t) {= + char* s = "42"; + int i = atoi(s); + printf("Converted string %s to int %d.\n", s, i); + printf("42 plus 42 is %d.\n", add_42(42)); + =} } diff --git a/test/C/src/ReadOutputOfContainedReactor.lf b/test/C/src/ReadOutputOfContainedReactor.lf index ba4490e237..ce2129069b 100644 --- a/test/C/src/ReadOutputOfContainedReactor.lf +++ b/test/C/src/ReadOutputOfContainedReactor.lf @@ -1,4 +1,5 @@ -// Test reacting to and reading outputs from a contained reactor in various permutations. +// Test reacting to and reading outputs from a contained reactor in various +// permutations. target C reactor Contained { diff --git a/test/C/src/RepeatedInheritance.lf b/test/C/src/RepeatedInheritance.lf index 422ada69d8..47d4e46e63 100644 --- a/test/C/src/RepeatedInheritance.lf +++ b/test/C/src/RepeatedInheritance.lf @@ -4,36 +4,36 @@ * @author{Edward A. Lee} */ target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } import Count from "lib/Count.lf" import TestCount from "lib/TestCount.lf" reactor D { - input d: int + input d: int } reactor C extends D { - input c: int + input c: int } reactor B extends D { - input b: int + input b: int } reactor A extends B, C { - input a: int - output out: int + input a: int + output out: int - reaction(a, b, c, d) -> out {= lf_set(out, a->value + b->value + c->value + d->value); =} + reaction(a, b, c, d) -> out {= lf_set(out, a->value + b->value + c->value + d->value); =} } main reactor { - c = new Count() - a = new A() - t = new TestCount(start = 4, stride = 4, num_inputs = 6) - (c.out)+ -> a.a, a.b, a.c, a.d - a.out -> t.in + c = new Count() + a = new A() + t = new TestCount(start = 4, stride = 4, num_inputs = 6) + (c.out)+ -> a.a, a.b, a.c, a.d + a.out -> t.in } diff --git a/test/C/src/RequestStop.lf b/test/C/src/RequestStop.lf index 1724f3ab92..83c59d1d27 100644 --- a/test/C/src/RequestStop.lf +++ b/test/C/src/RequestStop.lf @@ -1,4 +1,5 @@ -// Test verifying that lf_request_stop() called in a shutdown reaction is ignored. +// Test verifying that lf_request_stop() called in a shutdown reaction is +// ignored. target C main reactor { diff --git a/test/C/src/Schedule.lf b/test/C/src/Schedule.lf index 91d3e2db2b..a806170d74 100644 --- a/test/C/src/Schedule.lf +++ b/test/C/src/Schedule.lf @@ -2,24 +2,24 @@ target C reactor Schedule2 { - input x: int - logical action a + input x: int + logical action a - reaction(x) -> a {= lf_schedule(a, MSEC(200)); =} + reaction(x) -> a {= lf_schedule(a, MSEC(200)); =} - reaction(a) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("Action triggered at logical time %lld nsec after start.\n", elapsed_time); - if (elapsed_time != 200000000LL) { - printf("Expected action time to be 200 msec. It was %lld nsec.\n", elapsed_time); - exit(1); - } - =} + reaction(a) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("Action triggered at logical time %lld nsec after start.\n", elapsed_time); + if (elapsed_time != 200000000LL) { + printf("Expected action time to be 200 msec. It was %lld nsec.\n", elapsed_time); + exit(1); + } + =} } main reactor { - a = new Schedule2() - timer t + a = new Schedule2() + timer t - reaction(t) -> a.x {= lf_set(a.x, 1); =} + reaction(t) -> a.x {= lf_set(a.x, 1); =} } diff --git a/test/C/src/ScheduleLogicalAction.lf b/test/C/src/ScheduleLogicalAction.lf index 25fce8619d..762f8c6f52 100644 --- a/test/C/src/ScheduleLogicalAction.lf +++ b/test/C/src/ScheduleLogicalAction.lf @@ -1,5 +1,5 @@ -// This checks that a logical action is scheduled the specified logical time after the current -// logical time. +// This checks that a logical action is scheduled the specified logical time +// after the current logical time. target C { fast: true, timeout: 3 sec diff --git a/test/C/src/ScheduleValue.lf b/test/C/src/ScheduleValue.lf index 8481d47d61..2ef4333db8 100644 --- a/test/C/src/ScheduleValue.lf +++ b/test/C/src/ScheduleValue.lf @@ -1,6 +1,6 @@ /** Test of schedule_value. */ target C { - timeout: 3 sec + timeout: 3 sec } preamble {= @@ -15,19 +15,19 @@ preamble {= =} main reactor ScheduleValue { - logical action a: char* + logical action a: char* - reaction(startup) -> a {= - char* value = (char*)malloc(6); - strcpy(value, "Hello"); - lf_schedule_value(a, 0, value, 6); - =} + reaction(startup) -> a {= + char* value = (char*)malloc(6); + strcpy(value, "Hello"); + lf_schedule_value(a, 0, value, 6); + =} - reaction(a) {= - printf("Received: %s\n", a->value); - if (strcmp(a->value, "Hello") != 0) { - fprintf(stderr, "FAILURE: Should have received 'Hello'\n"); - exit(1); - } - =} + reaction(a) {= + printf("Received: %s\n", a->value); + if (strcmp(a->value, "Hello") != 0) { + fprintf(stderr, "FAILURE: Should have received 'Hello'\n"); + exit(1); + } + =} } diff --git a/test/C/src/SendingInside.lf b/test/C/src/SendingInside.lf index 920f371d4a..b1e8f25f93 100644 --- a/test/C/src/SendingInside.lf +++ b/test/C/src/SendingInside.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own reaction that routes -// inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own +// reaction that routes inputs to the contained reactor. target C { timeout: 10 sec, fast: true diff --git a/test/C/src/SendingInside2.lf b/test/C/src/SendingInside2.lf index f65342de52..e1b684ff74 100644 --- a/test/C/src/SendingInside2.lf +++ b/test/C/src/SendingInside2.lf @@ -1,20 +1,20 @@ target C reactor Printer { - input x: int + input x: int - reaction(x) {= - printf("Inside reactor received: %d\n", x->value); - if (x->value != 1) { - fprintf(stderr, "ERROR: Expected 1.\n"); - exit(1); - } - =} + reaction(x) {= + printf("Inside reactor received: %d\n", x->value); + if (x->value != 1) { + fprintf(stderr, "ERROR: Expected 1.\n"); + exit(1); + } + =} } main reactor SendingInside2 { - timer t - p = new Printer() + timer t + p = new Printer() - reaction(t) -> p.x {= lf_set(p.x, 1); =} + reaction(t) -> p.x {= lf_set(p.x, 1); =} } diff --git a/test/C/src/SendsPointerTest.lf b/test/C/src/SendsPointerTest.lf index 0cfa6dc48c..1f17bd1388 100644 --- a/test/C/src/SendsPointerTest.lf +++ b/test/C/src/SendsPointerTest.lf @@ -1,5 +1,5 @@ -// Source produces a dynamically allocated struct, which it passes to Print. Reference counting -// ensures that the struct is freed. +// Source produces a dynamically allocated struct, which it passes to Print. +// Reference counting ensures that the struct is freed. target C preamble {= typedef int* int_pointer; =} diff --git a/test/C/src/SetArray.lf b/test/C/src/SetArray.lf index 188fccba1f..f30457f9f8 100644 --- a/test/C/src/SetArray.lf +++ b/test/C/src/SetArray.lf @@ -1,5 +1,5 @@ -// This tests SET_ARRAY() This tests the use of the "polymorphic" delay reactor on a struct. It -// delays by a logical time any pointer datatype. +// This tests SET_ARRAY() This tests the use of the "polymorphic" delay reactor +// on a struct. It delays by a logical time any pointer datatype. target C reactor Source { diff --git a/test/C/src/SimpleDeadline.lf b/test/C/src/SimpleDeadline.lf index e8ce362823..fba3e03cbc 100644 --- a/test/C/src/SimpleDeadline.lf +++ b/test/C/src/SimpleDeadline.lf @@ -1,5 +1,6 @@ -// Test local deadline, where a deadline is associated with a reaction definition. This test -// triggers a reaction exactly once with a deadline violation. +// Test local deadline, where a deadline is associated with a reaction +// definition. This test triggers a reaction exactly once with a deadline +// violation. target C preamble {= diff --git a/test/C/src/SimpleImport.lf b/test/C/src/SimpleImport.lf index 71258bd678..7a1a517c02 100644 --- a/test/C/src/SimpleImport.lf +++ b/test/C/src/SimpleImport.lf @@ -3,6 +3,6 @@ target C import HelloWorld2 from "HelloWorld.lf" main reactor SimpleImport { - a = new HelloWorld2() - b = new HelloWorld2() + a = new HelloWorld2() + b = new HelloWorld2() } diff --git a/test/C/src/SlowingClock.lf b/test/C/src/SlowingClock.lf index 36a1f01aef..d4a1e1d5f4 100644 --- a/test/C/src/SlowingClock.lf +++ b/test/C/src/SlowingClock.lf @@ -1,7 +1,8 @@ /** - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a logical - * action with a minimum delay of 100 msec. The use of the logical action ensures the elapsed time - * jumps exactly from 0 to 100, 300, 600, and 1000 msec. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 + * msec on a logical action with a minimum delay of 100 msec. The use of the + * logical action ensures the elapsed time jumps exactly from 0 to 100, 300, + * 600, and 1000 msec. */ target C { timeout: 1 sec, diff --git a/test/C/src/SlowingClockPhysical.lf b/test/C/src/SlowingClockPhysical.lf index 7af44f3481..0e82730112 100644 --- a/test/C/src/SlowingClockPhysical.lf +++ b/test/C/src/SlowingClockPhysical.lf @@ -1,8 +1,9 @@ /** - * /* Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a physical - * action with a minimum delay of 100 msec. The use of the physical action makes the elapsed time - * jumps from 0 to approximately 100 msec, to approximatly 300 msec thereafter, drifting away - * further with each new event. + * /* Events are scheduled with increasing additional delays of 0, 100, 300, 600 + * msec on a physical action with a minimum delay of 100 msec. The use of the + * physical action makes the elapsed time jumps from 0 to approximately 100 + * msec, to approximatly 300 msec thereafter, drifting away further with each + * new event. */ target C { timeout: 1500 msec diff --git a/test/C/src/StartupOutFromInside.lf b/test/C/src/StartupOutFromInside.lf index cad2d282bf..1e9a8a822a 100644 --- a/test/C/src/StartupOutFromInside.lf +++ b/test/C/src/StartupOutFromInside.lf @@ -1,19 +1,19 @@ target C reactor Bar { - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, 42); =} + reaction(startup) -> out {= lf_set(out, 42); =} } main reactor StartupOutFromInside { - bar = new Bar() + bar = new Bar() - reaction(startup) bar.out {= - printf("Output from bar: %d\n", bar.out->value); - if (bar.out->value != 42) { - fprintf(stderr, "Expected 42!\n"); - exit(1); - } - =} + reaction(startup) bar.out {= + printf("Output from bar: %d\n", bar.out->value); + if (bar.out->value != 42) { + fprintf(stderr, "Expected 42!\n"); + exit(1); + } + =} } diff --git a/test/C/src/Starvation.lf b/test/C/src/Starvation.lf index c4ff41693e..8f4c1423a5 100644 --- a/test/C/src/Starvation.lf +++ b/test/C/src/Starvation.lf @@ -1,6 +1,6 @@ /** - * Test that the starvation functionality in absence of the "keepalive: true" target property indeed - * works as expected. + * Test that the starvation functionality in absence of the "keepalive: true" + * target property indeed works as expected. * * @author Soroush Bateni */ diff --git a/test/C/src/StopZero.lf b/test/C/src/StopZero.lf index 1a317dd45e..e845c6de48 100644 --- a/test/C/src/StopZero.lf +++ b/test/C/src/StopZero.lf @@ -1,6 +1,6 @@ /** - * Test for lf_request_stop() at tag (0,0). This also tests for logically simultaneous calls to - * lf_request_stop(). + * Test for lf_request_stop() at tag (0,0). This also tests for logically + * simultaneous calls to lf_request_stop(). * * @author Soroush Bateni */ diff --git a/test/C/src/Stride.lf b/test/C/src/Stride.lf index c57c2e0aad..62b9077878 100644 --- a/test/C/src/Stride.lf +++ b/test/C/src/Stride.lf @@ -1,5 +1,5 @@ -// This example illustrates state variables and parameters on the wiki. For this test, success is -// just compiling and running. +// This example illustrates state variables and parameters on the wiki. For this +// test, success is just compiling and running. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/StructPrint.lf b/test/C/src/StructPrint.lf index 5c2f10513e..6af0d60c4f 100644 --- a/test/C/src/StructPrint.lf +++ b/test/C/src/StructPrint.lf @@ -1,5 +1,5 @@ -// Source produces a dynamically allocated struct, which it passes to Print. Reference counting -// ensures that the struct is freed. +// Source produces a dynamically allocated struct, which it passes to Print. +// Reference counting ensures that the struct is freed. target C { files: ["include/hello.h"] } diff --git a/test/C/src/TestForPreviousOutput.lf b/test/C/src/TestForPreviousOutput.lf index 825f559d13..890b47361d 100644 --- a/test/C/src/TestForPreviousOutput.lf +++ b/test/C/src/TestForPreviousOutput.lf @@ -13,40 +13,40 @@ preamble {= =} reactor Source { - output out: int + output out: int - reaction(startup) -> out {= - // Set a seed for random number generation based on the current time. - srand(time(0)); - // Randomly produce an output or not. - if (rand() % 2) { - lf_set(out, 21); - } - =} + reaction(startup) -> out {= + // Set a seed for random number generation based on the current time. + srand(time(0)); + // Randomly produce an output or not. + if (rand() % 2) { + lf_set(out, 21); + } + =} - reaction(startup) -> out {= - if (out->is_present) { - lf_set(out, 2 * out->value); - } else { - lf_set(out, 42); - } - =} + reaction(startup) -> out {= + if (out->is_present) { + lf_set(out, 2 * out->value); + } else { + lf_set(out, 42); + } + =} } reactor Sink { - input in: int + input in: int - reaction(in) {= - printf("Received %d.\n", in->value); - if (in->value != 42) { - fprintf(stderr, "FAILED: Expected 42.\n"); - exit(1); - } - =} + reaction(in) {= + printf("Received %d.\n", in->value); + if (in->value != 42) { + fprintf(stderr, "FAILED: Expected 42.\n"); + exit(1); + } + =} } main reactor TestForPreviousOutput { - s = new Source() - d = new Sink() - s.out -> d.in + s = new Source() + d = new Sink() + s.out -> d.in } diff --git a/test/C/src/TimeLimit.lf b/test/C/src/TimeLimit.lf index 3245725361..ae178d53b5 100644 --- a/test/C/src/TimeLimit.lf +++ b/test/C/src/TimeLimit.lf @@ -1,5 +1,6 @@ -// Test that the stop function can be used to internally impose a a time limit. Correct output for -// this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. +// Test that the stop function can be used to internally impose a a time limit. +// Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt +// or getting the wrong data. target C { fast: true } diff --git a/test/C/src/TimeoutZero.lf b/test/C/src/TimeoutZero.lf index a9cd25a886..771d321a40 100644 --- a/test/C/src/TimeoutZero.lf +++ b/test/C/src/TimeoutZero.lf @@ -1,5 +1,6 @@ /** - * A test for the timeout functionality in Lingua Franca. This variant tests timeout at (0,0). + * A test for the timeout functionality in Lingua Franca. This variant tests + * timeout at (0,0). * * @author Soroush Bateni */ diff --git a/test/C/src/TriggerDownstreamOnlyIfPresent2.lf b/test/C/src/TriggerDownstreamOnlyIfPresent2.lf index 5f843930b8..bc62b214e9 100644 --- a/test/C/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/C/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,4 +1,7 @@ -/** This test checks that a downstream reaction is triggered only if its trigger is present. */ +/** + * This test checks that a downstream reaction is triggered only if its trigger + * is present. + */ target C { timeout: 1 sec, fast: true diff --git a/test/C/src/Wcet.lf b/test/C/src/Wcet.lf index d21268ea79..984f95244f 100644 --- a/test/C/src/Wcet.lf +++ b/test/C/src/Wcet.lf @@ -2,44 +2,44 @@ target C reactor Source { - output out1: int - output out2: int - timer t - - reaction(t) -> out1, out2 {= - lf_set(out1, 5); - lf_set(out2, 10); - =} + output out1: int + output out2: int + timer t + + reaction(t) -> out1, out2 {= + lf_set(out1, 5); + lf_set(out2, 10); + =} } reactor Work { - input in1: int - input in2: int - output out: int - - reaction(in1, in2) -> out {= - int ret; - if (in1->value > 10) { - ret = in2->value * in1->value; - } else { - ret = in2->value + in1->value; - } - lf_set(out, ret); - =} + input in1: int + input in2: int + output out: int + + reaction(in1, in2) -> out {= + int ret; + if (in1->value > 10) { + ret = in2->value * in1->value; + } else { + ret = in2->value + in1->value; + } + lf_set(out, ret); + =} } reactor Print { - input in: int + input in: int - reaction(in) {= printf("Received: %d\n", in->value); =} + reaction(in) {= printf("Received: %d\n", in->value); =} } main reactor Wcet { - source = new Source() - work = new Work() - print = new Print() + source = new Source() + work = new Work() + print = new Print() - source.out1 -> work.in1 - source.out2 -> work.in2 - work.out -> print.in + source.out1 -> work.in1 + source.out2 -> work.in2 + work.out -> print.in } diff --git a/test/C/src/arduino/AnalogReadSerial.lf b/test/C/src/arduino/AnalogReadSerial.lf index c2fc4ef475..220cb47d47 100644 --- a/test/C/src/arduino/AnalogReadSerial.lf +++ b/test/C/src/arduino/AnalogReadSerial.lf @@ -1,7 +1,8 @@ /** - * This example reads an analog input on pin 0, prints the result to the Serial Monitor. Graphical - * representation is available using Serial Plotter (Tools > Serial Plotter menu). Attach the center - * pin of a potentiometer to pin A0, and the outside pins to +5V and ground. + * This example reads an analog input on pin 0, prints the result to the Serial + * Monitor. Graphical representation is available using Serial Plotter (Tools > + * Serial Plotter menu). Attach the center pin of a potentiometer to pin A0, and + * the outside pins to +5V and ground. */ target C { platform: { diff --git a/test/C/src/arduino/Blink.lf b/test/C/src/arduino/Blink.lf index 4ed02cdc2a..809aa55884 100644 --- a/test/C/src/arduino/Blink.lf +++ b/test/C/src/arduino/Blink.lf @@ -1,6 +1,7 @@ /** - * This example demonstrates a very simple blink program that will turn on and off an LED on the - * Arduino Board with a 50% duty cycle switching every half-second. + * This example demonstrates a very simple blink program that will turn on and + * off an LED on the Arduino Board with a 50% duty cycle switching every + * half-second. */ target C { platform: { diff --git a/test/C/src/arduino/BlinkAttemptThreading.lf b/test/C/src/arduino/BlinkAttemptThreading.lf index 31fd99989d..8f71009edf 100644 --- a/test/C/src/arduino/BlinkAttemptThreading.lf +++ b/test/C/src/arduino/BlinkAttemptThreading.lf @@ -1,7 +1,8 @@ /** - * This example demonstrates a very simple blink program that will turn on and off an LED on the - * Arduino Board with a 50% duty cycle switching every half-second. Note: if we try to enable - * threading, the system will give us a warning and default back to no threading. + * This example demonstrates a very simple blink program that will turn on and + * off an LED on the Arduino Board with a 50% duty cycle switching every + * half-second. Note: if we try to enable threading, the system will give us a + * warning and default back to no threading. */ target C { platform: { diff --git a/test/C/src/arduino/BlinkMBED.lf b/test/C/src/arduino/BlinkMBED.lf index 5330e018a0..f9702d27cc 100644 --- a/test/C/src/arduino/BlinkMBED.lf +++ b/test/C/src/arduino/BlinkMBED.lf @@ -1,6 +1,7 @@ /** - * This example demonstrates a very simple blink program that will turn on and off an LED on the - * Arduino Board with a 50% duty cycle switching every half-second. + * This example demonstrates a very simple blink program that will turn on and + * off an LED on the Arduino Board with a 50% duty cycle switching every + * half-second. */ target C { platform: { diff --git a/test/C/src/arduino/Fade.lf b/test/C/src/arduino/Fade.lf index 74d3fa0c8c..d23aabd646 100644 --- a/test/C/src/arduino/Fade.lf +++ b/test/C/src/arduino/Fade.lf @@ -1,8 +1,9 @@ /** - * This example shows how to fade an LED on pin 9 using the analogWrite() function. The - * analogWrite() function uses PWM, so if you want to change the pin you're using, be sure to use - * another PWM capable pin. On most Arduino, the PWM pins are identified with a "~" sign, like ~3, - * ~5, ~6, ~9, ~10 and ~11. + * This example shows how to fade an LED on pin 9 using the analogWrite() + * function. The analogWrite() function uses PWM, so if you want to change the + * pin you're using, be sure to use another PWM capable pin. On most Arduino, + * the PWM pins are identified with a "~" sign, like ~3, ~5, ~6, ~9, ~10 and + * ~11. */ target C { platform: { diff --git a/test/C/src/arduino/ReadAnalogVoltage.lf b/test/C/src/arduino/ReadAnalogVoltage.lf index 2a56719f66..77be8e8b06 100644 --- a/test/C/src/arduino/ReadAnalogVoltage.lf +++ b/test/C/src/arduino/ReadAnalogVoltage.lf @@ -1,8 +1,9 @@ /** - * This example reads an analog input on pin 0, converts it to voltage, and prints the result to the - * Serial Monitor. Graphical representation is available using Serial Plotter (Tools > Serial - * Plotter menu). Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V - * and ground. + * This example reads an analog input on pin 0, converts it to voltage, and + * prints the result to the Serial Monitor. Graphical representation is + * available using Serial Plotter (Tools > Serial Plotter menu). Attach the + * center pin of a potentiometer to pin A0, and the outside pins to +5V and + * ground. */ target C { platform: { diff --git a/test/C/src/concurrent/AsyncCallback.lf b/test/C/src/concurrent/AsyncCallback.lf index 18268c574a..58120446d4 100644 --- a/test/C/src/concurrent/AsyncCallback.lf +++ b/test/C/src/concurrent/AsyncCallback.lf @@ -1,9 +1,11 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test case assumes that target is - * multithreaded. This test will not work with the unthreaded C target because that target does not - * implement any mutex protecting the event queue. + * Test asynchronous callbacks that trigger a physical action. This test case + * assumes that target is multithreaded. This test will not work with the + * unthreaded C target because that target does not implement any mutex + * protecting the event queue. * - * Note: This test uses the LF platform support to enable it to run on multiple platforms. + * Note: This test uses the LF platform support to enable it to run on multiple + * platforms. */ target C { tracing: true, diff --git a/test/C/src/concurrent/AsyncCallbackDrop.lf b/test/C/src/concurrent/AsyncCallbackDrop.lf index d7d0858699..b0c5c502f2 100644 --- a/test/C/src/concurrent/AsyncCallbackDrop.lf +++ b/test/C/src/concurrent/AsyncCallbackDrop.lf @@ -1,6 +1,7 @@ -// Test asynchronous callbacks that trigger a physical action with a DROP policy. This test case -// assumes that the target is multithreaded. This test will not work with the unthreaded C target -// because that target does not implement any mutex protecting the event queue. +// Test asynchronous callbacks that trigger a physical action with a DROP +// policy. This test case assumes that the target is multithreaded. This test +// will not work with the unthreaded C target because that target does not +// implement any mutex protecting the event queue. target C { keepalive: true, // To silence warning. timeout: 2 sec diff --git a/test/C/src/concurrent/AsyncCallbackReplace.lf b/test/C/src/concurrent/AsyncCallbackReplace.lf index ba75b3e3db..7bac7496b5 100644 --- a/test/C/src/concurrent/AsyncCallbackReplace.lf +++ b/test/C/src/concurrent/AsyncCallbackReplace.lf @@ -1,6 +1,7 @@ -// Test asynchronous callbacks that trigger a physical action with a "replace" policy. This test -// case assumes that the target is multithreaded. This test will not work with the unthreaded C -// target because that target does not implement any mutex protecting the event queue. +// Test asynchronous callbacks that trigger a physical action with a "replace" +// policy. This test case assumes that the target is multithreaded. This test +// will not work with the unthreaded C target because that target does not +// implement any mutex protecting the event queue. target C { keepalive: true, timeout: 2 sec diff --git a/test/C/src/concurrent/CompositionThreaded.lf b/test/C/src/concurrent/CompositionThreaded.lf index 01185fa6b3..cf0bafeb82 100644 --- a/test/C/src/concurrent/CompositionThreaded.lf +++ b/test/C/src/concurrent/CompositionThreaded.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target C { fast: true, timeout: 10 sec diff --git a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf index 5f698d1c95..ad14879080 100644 --- a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the container reacts to that -// output. +// Test a deadline where the deadline violation produces an output and the +// container reacts to that output. target C preamble {= diff --git a/test/C/src/concurrent/DeadlineThreaded.lf b/test/C/src/concurrent/DeadlineThreaded.lf index ff5961b0d9..ffc1be2701 100644 --- a/test/C/src/concurrent/DeadlineThreaded.lf +++ b/test/C/src/concurrent/DeadlineThreaded.lf @@ -1,5 +1,6 @@ -// This example illustrates local deadline handling. Even numbers are sent by the Source -// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by +// the Source immediately, whereas odd numbers are sent after a big enough delay +// to violate the deadline. target C { timeout: 6 sec } diff --git a/test/C/src/concurrent/DeterminismThreaded.lf b/test/C/src/concurrent/DeterminismThreaded.lf index c141f36330..a0df17b15c 100644 --- a/test/C/src/concurrent/DeterminismThreaded.lf +++ b/test/C/src/concurrent/DeterminismThreaded.lf @@ -1,46 +1,46 @@ target C reactor Source { - output y: int - timer t + output y: int + timer t - reaction(t) -> y {= lf_set(y, 1); =} + reaction(t) -> y {= lf_set(y, 1); =} } reactor Destination { - input x: int - input y: int + input x: int + input y: int - reaction(x, y) {= - int sum = 0; - if (x->is_present) { - sum += x->value; - } - if (y->is_present) { - sum += y->value; - } - printf("Received %d.\n", sum); - if (sum != 2) { - printf("FAILURE: Expected 2.\n"); - exit(4); - } - =} + reaction(x, y) {= + int sum = 0; + if (x->is_present) { + sum += x->value; + } + if (y->is_present) { + sum += y->value; + } + printf("Received %d.\n", sum); + if (sum != 2) { + printf("FAILURE: Expected 2.\n"); + exit(4); + } + =} } reactor Pass { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= lf_set(y, x->value); =} + reaction(x) -> y {= lf_set(y, x->value); =} } main reactor { - s = new Source() - d = new Destination() - p1 = new Pass() - p2 = new Pass() - s.y -> d.y - s.y -> p1.x - p1.y -> p2.x - p2.y -> d.x + s = new Source() + d = new Destination() + p1 = new Pass() + p2 = new Pass() + s.y -> d.y + s.y -> p1.x + p1.y -> p2.x + p2.y -> d.x } diff --git a/test/C/src/concurrent/DoubleReactionThreaded.lf b/test/C/src/concurrent/DoubleReactionThreaded.lf index eb46b4f7d6..ba6c38ca19 100644 --- a/test/C/src/concurrent/DoubleReactionThreaded.lf +++ b/test/C/src/concurrent/DoubleReactionThreaded.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output -// for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only +// once. Correct output for this 2, 4, 6, 8, etc. target C { timeout: 10 sec, fast: true diff --git a/test/C/src/concurrent/ImportThreaded.lf b/test/C/src/concurrent/ImportThreaded.lf index b10a222f1a..a40fd11fb7 100644 --- a/test/C/src/concurrent/ImportThreaded.lf +++ b/test/C/src/concurrent/ImportThreaded.lf @@ -4,8 +4,8 @@ target C import Imported from "../lib/Imported.lf" main reactor ImportThreaded { - timer t - a = new Imported() + timer t + a = new Imported() - reaction(t) -> a.x {= lf_set(a.x, 42); =} + reaction(t) -> a.x {= lf_set(a.x, 42); =} } diff --git a/test/C/src/concurrent/MinimalThreaded.lf b/test/C/src/concurrent/MinimalThreaded.lf index 5252d0465f..dacafdcb73 100644 --- a/test/C/src/concurrent/MinimalThreaded.lf +++ b/test/C/src/concurrent/MinimalThreaded.lf @@ -2,7 +2,7 @@ target C main reactor MinimalThreaded { - timer t + timer t - reaction(t) {= printf("Hello World.\n"); =} + reaction(t) {= printf("Hello World.\n"); =} } diff --git a/test/C/src/concurrent/PingPongThreaded.lf b/test/C/src/concurrent/PingPongThreaded.lf index 37d7b97574..4fae17911e 100644 --- a/test/C/src/concurrent/PingPongThreaded.lf +++ b/test/C/src/concurrent/PingPongThreaded.lf @@ -1,19 +1,23 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing - * overhead. This is based on https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure + * message-passing overhead. This is based on + * https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the causality loop. + * Ping introduces a microstep delay using a logical action to break the + * causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * - * Unthreaded: 97 msec Threaded: 265 msec (168 msec with optimization of executing immediately) + * Unthreaded: 97 msec Threaded: 265 msec (168 msec with optimization of + * executing immediately) * - * There is no parallelism in this application, so it does not benefit from being being threaded, - * just some additional overhead. + * There is no parallelism in this application, so it does not benefit from + * being being threaded, just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. These are about an - * order of magnitude faster than anything reported in the paper. + * These measurements are total execution time, including startup and shutdown. + * These are about an order of magnitude faster than anything reported in the + * paper. * * @author Edward A. Lee */ diff --git a/test/C/src/concurrent/SendingInsideThreaded.lf b/test/C/src/concurrent/SendingInsideThreaded.lf index dc0892195b..e5185ecfc8 100644 --- a/test/C/src/concurrent/SendingInsideThreaded.lf +++ b/test/C/src/concurrent/SendingInsideThreaded.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own reaction that routes -// inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own +// reaction that routes inputs to the contained reactor. target C { timeout: 10 sec, fast: true diff --git a/test/C/src/concurrent/StarvationThreaded.lf b/test/C/src/concurrent/StarvationThreaded.lf index 2e50b71a58..d1e78e5ced 100644 --- a/test/C/src/concurrent/StarvationThreaded.lf +++ b/test/C/src/concurrent/StarvationThreaded.lf @@ -1,6 +1,7 @@ /** - * Test that the starvation functionality in absence of the "keepalive: true" target property indeed - * works as expected. This version uses the threaded runtime. + * Test that the starvation functionality in absence of the "keepalive: true" + * target property indeed works as expected. This version uses the threaded + * runtime. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/StopThreaded.lf b/test/C/src/concurrent/StopThreaded.lf index 7beb0cb747..1deb1c4ff6 100644 --- a/test/C/src/concurrent/StopThreaded.lf +++ b/test/C/src/concurrent/StopThreaded.lf @@ -1,6 +1,6 @@ /** - * A test for the lf_request_stop() functionality in Lingua Franca. This version of the test is - * threaded. + * A test for the lf_request_stop() functionality in Lingua Franca. This version + * of the test is threaded. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/StopZeroThreaded.lf b/test/C/src/concurrent/StopZeroThreaded.lf index 22f5635e6c..7afd4b0069 100644 --- a/test/C/src/concurrent/StopZeroThreaded.lf +++ b/test/C/src/concurrent/StopZeroThreaded.lf @@ -1,5 +1,6 @@ /** - * Test for lf_request_stop() at tag (0,0). This version uses the threaded runtime. + * Test for lf_request_stop() at tag (0,0). This version uses the threaded + * runtime. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/Threaded.lf b/test/C/src/concurrent/Threaded.lf index 4daa36f6fd..01f67c1bd4 100644 --- a/test/C/src/concurrent/Threaded.lf +++ b/test/C/src/concurrent/Threaded.lf @@ -1,13 +1,16 @@ -// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime -// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that -// without parallel execution, there is no way this can keep up with real time since in every 200 -// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing -// that without threads, this takes more than 800 msec to complete 200 msec of logical time. See -// ThreadedMultiport for a parameterized version of this. +// Check for speedup of multithreaded execution on multicore machines. Each +// instance of TakeTime takes 200 ms to transport the input to the output. Four +// of them are instantiated. Note that without parallel execution, there is no +// way this can keep up with real time since in every 200 msec cycle it has 800 +// msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded +// version, showing that without threads, this takes more than 800 msec to +// complete 200 msec of logical time. See ThreadedMultiport for a parameterized +// version of this. target C { timeout: 2 sec, - flags: "" // Disable compiler optimization so that TakeTime actually takes time. + // Disable compiler optimization so that TakeTime actually takes time. + flags: "" } reactor Source { diff --git a/test/C/src/concurrent/ThreadedMultiport.lf b/test/C/src/concurrent/ThreadedMultiport.lf index cbf8459b08..2878393dac 100644 --- a/test/C/src/concurrent/ThreadedMultiport.lf +++ b/test/C/src/concurrent/ThreadedMultiport.lf @@ -1,7 +1,8 @@ // Check multiport capabilities on Outputs. target C { timeout: 2 sec, - flags: "" // Disable compiler optimization so that TakeTime actually takes time. + // Disable compiler optimization so that TakeTime actually takes time. + flags: "" } reactor Source(width: int = 4) { diff --git a/test/C/src/concurrent/ThreadedThreaded.lf b/test/C/src/concurrent/ThreadedThreaded.lf index 0ff1f1e09b..4037e8c193 100644 --- a/test/C/src/concurrent/ThreadedThreaded.lf +++ b/test/C/src/concurrent/ThreadedThreaded.lf @@ -1,13 +1,15 @@ -// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime -// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that -// without parallel execution, there is no way this can keep up with real time since in every 200 -// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. See ThreadedMultiport for a parameterized version -// of this. +// Check for speedup of multithreaded execution on multicore machines. Each +// instance of TakeTime takes 200 ms to transport the input to the output. Four +// of them are instantiated. Note that without parallel execution, there is no +// way this can keep up with real time since in every 200 msec cycle it has 800 +// msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. See ThreadedMultiport for a +// parameterized version of this. target C { timeout: 2 sec, tracing: true, - flags: "" // Disable compiler optimization so that TakeTime actually takes time. + // Disable compiler optimization so that TakeTime actually takes time. + flags: "" } reactor Source { diff --git a/test/C/src/concurrent/TimeLimitThreaded.lf b/test/C/src/concurrent/TimeLimitThreaded.lf index 07bd3c9257..8d3824af47 100644 --- a/test/C/src/concurrent/TimeLimitThreaded.lf +++ b/test/C/src/concurrent/TimeLimitThreaded.lf @@ -1,5 +1,5 @@ -// Test that the stop function can be used to internally impose a a time limit. Correct output for -// this 1, 2, 3, 4. Failure for this test is failing to halt. +// Test that the stop function can be used to internally impose a a time limit. +// Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt. target C { fast: true } diff --git a/test/C/src/concurrent/TimeoutThreaded.lf b/test/C/src/concurrent/TimeoutThreaded.lf index 41fd8d1147..82ef231ed9 100644 --- a/test/C/src/concurrent/TimeoutThreaded.lf +++ b/test/C/src/concurrent/TimeoutThreaded.lf @@ -1,5 +1,6 @@ /** - * A test for the timeout functionality in Lingua Franca. This version of the test is threaded. + * A test for the timeout functionality in Lingua Franca. This version of the + * test is threaded. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/TimeoutZeroThreaded.lf b/test/C/src/concurrent/TimeoutZeroThreaded.lf index 9df91b99ba..7865b486a9 100644 --- a/test/C/src/concurrent/TimeoutZeroThreaded.lf +++ b/test/C/src/concurrent/TimeoutZeroThreaded.lf @@ -1,6 +1,6 @@ /** - * A test for the timeout functionality in Lingua Franca. This variant tests timeout at (0,0) and - * uses the threaded runtime. + * A test for the timeout functionality in Lingua Franca. This variant tests + * timeout at (0,0) and uses the threaded runtime. * * @author Soroush Bateni */ diff --git a/test/C/src/concurrent/Tracing.lf b/test/C/src/concurrent/Tracing.lf index 2d13fbf259..cbc4513732 100644 --- a/test/C/src/concurrent/Tracing.lf +++ b/test/C/src/concurrent/Tracing.lf @@ -2,7 +2,8 @@ target C { timeout: 2 sec, tracing: true, - flags: "", // Disable compiler optimization so that TakeTime actually takes time. + // Disable compiler optimization so that TakeTime actually takes time. + flags: "", logging: DEBUG } diff --git a/test/C/src/concurrent/Workers.lf b/test/C/src/concurrent/Workers.lf index 8bf88dd6f5..90dbecb468 100644 --- a/test/C/src/concurrent/Workers.lf +++ b/test/C/src/concurrent/Workers.lf @@ -1,13 +1,13 @@ target C { - workers: 16 + workers: 16 } main reactor { - reaction(startup) {= - if (NUMBER_OF_WORKERS != 16) { - lf_print_error_and_exit("Expected to have 16 workers."); - } else { - lf_print("Using 16 workers."); - } - =} + reaction(startup) {= + if (NUMBER_OF_WORKERS != 16) { + lf_print_error_and_exit("Expected to have 16 workers."); + } else { + lf_print("Using 16 workers."); + } + =} } diff --git a/test/C/src/docker/FilesPropertyContainerized.lf b/test/C/src/docker/FilesPropertyContainerized.lf index f9a1a240f3..ca50fc8ac6 100644 --- a/test/C/src/docker/FilesPropertyContainerized.lf +++ b/test/C/src/docker/FilesPropertyContainerized.lf @@ -1,15 +1,15 @@ target C { - files: "../include/hello.h", - docker: true + files: "../include/hello.h", + docker: true } preamble {= - #include "hello.h" + #include "hello.h" =} main reactor { - reaction(startup) {= - hello_t hello; - printf("SUCCESS\n"); - =} + reaction(startup) {= + hello_t hello; + printf("SUCCESS\n"); + =} } diff --git a/test/C/src/docker/HelloWorldContainerized.lf b/test/C/src/docker/HelloWorldContainerized.lf index 9a0b2e8403..f486c7bb9a 100644 --- a/test/C/src/docker/HelloWorldContainerized.lf +++ b/test/C/src/docker/HelloWorldContainerized.lf @@ -1,14 +1,14 @@ target C { - tracing: { // To test generating a custom trace file name. - trace-file-name: "HelloWorldTrace" - }, - logging: error, - docker: true, - build-type: Debug + tracing: { // To test generating a custom trace file name. + trace-file-name: "HelloWorldTrace" + }, + logging: error, + docker: true, + build-type: Debug } import HelloWorld2 from "../HelloWorld.lf" main reactor { - a = new HelloWorld2() + a = new HelloWorld2() } diff --git a/test/C/src/docker/PingPongContainerized.lf b/test/C/src/docker/PingPongContainerized.lf index 10062bb3eb..5cce20321f 100644 --- a/test/C/src/docker/PingPongContainerized.lf +++ b/test/C/src/docker/PingPongContainerized.lf @@ -18,16 +18,16 @@ * @author Edward A. Lee */ target C { - fast: true, - docker: true + fast: true, + docker: true } import Ping from "../PingPong.lf" import Pong from "../PingPong.lf" main reactor PingPongContainerized { - ping = new Ping() - pong = new Pong() - ping.send -> pong.receive - pong.send -> ping.receive + ping = new Ping() + pong = new Pong() + ping.send -> pong.receive + pong.send -> ping.receive } diff --git a/test/C/src/docker/federated/DistributedCountContainerized.lf b/test/C/src/docker/federated/DistributedCountContainerized.lf index 13ae54fd80..4a120c5e1e 100644 --- a/test/C/src/docker/federated/DistributedCountContainerized.lf +++ b/test/C/src/docker/federated/DistributedCountContainerized.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { diff --git a/test/C/src/docker/federated/DistributedDoublePortContainerized.lf b/test/C/src/docker/federated/DistributedDoublePortContainerized.lf index 6227b8b00a..c9273862c5 100644 --- a/test/C/src/docker/federated/DistributedDoublePortContainerized.lf +++ b/test/C/src/docker/federated/DistributedDoublePortContainerized.lf @@ -5,10 +5,10 @@ * @author Soroush Bateni */ target C { - timeout: 900 msec, - logging: DEBUG, - coordination: centralized, - docker: true + timeout: 900 msec, + logging: DEBUG, + coordination: centralized, + docker: true } import Count from "../../lib/Count.lf" @@ -16,9 +16,9 @@ import CountMicrostep from "../../federated/DistributedDoublePort.lf" import Print from "../../federated/DistributedDoublePort.lf" federated reactor DistributedDoublePortContainerized at rti { - c = new Count() - cm = new CountMicrostep() - p = new Print() - c.out -> p.in // Indicating a 'logical' connection. - cm.out -> p.in2 + c = new Count() + cm = new CountMicrostep() + p = new Print() + c.out -> p.in // Indicating a 'logical' connection. + cm.out -> p.in2 } diff --git a/test/C/src/docker/federated/DistributedMultiportContainerized.lf b/test/C/src/docker/federated/DistributedMultiportContainerized.lf index c162e5189f..ec27e0dea3 100644 --- a/test/C/src/docker/federated/DistributedMultiportContainerized.lf +++ b/test/C/src/docker/federated/DistributedMultiportContainerized.lf @@ -1,14 +1,14 @@ // Check multiport connections between federates. target C { - timeout: 1 sec, - coordination: centralized, - docker: true + timeout: 1 sec, + coordination: centralized, + docker: true } import Source, Destination from "../../federated/DistributedMultiport.lf" federated reactor DistributedMultiportContainerized at rti { - s = new Source() - d = new Destination() - s.out -> d.in + s = new Source() + d = new Destination() + s.out -> d.in } diff --git a/test/C/src/docker/federated/DistributedStopDecentralizedContainerized.lf b/test/C/src/docker/federated/DistributedStopDecentralizedContainerized.lf index 342dde28e0..5480a6f06c 100644 --- a/test/C/src/docker/federated/DistributedStopDecentralizedContainerized.lf +++ b/test/C/src/docker/federated/DistributedStopDecentralizedContainerized.lf @@ -4,14 +4,14 @@ * @author Soroush Bateni */ target C { - coordination: decentralized, - docker: true + coordination: decentralized, + docker: true } import Sender, Receiver from "../../federated/DistributedStop.lf" federated reactor DistributedStopDecentralizedContainerized at rti { - sender = new Sender() - receiver = new Receiver() - sender.out -> receiver.in + sender = new Sender() + receiver = new Receiver() + sender.out -> receiver.in } diff --git a/test/C/src/federated/BroadcastFeedback.lf b/test/C/src/federated/BroadcastFeedback.lf index b38bb399d7..2bef908d2d 100644 --- a/test/C/src/federated/BroadcastFeedback.lf +++ b/test/C/src/federated/BroadcastFeedback.lf @@ -1,4 +1,6 @@ -/** This tests an output that is broadcast back to a multiport input of a bank. */ +/** + * This tests an output that is broadcast back to a multiport input of a bank. + */ target C { timeout: 1 sec, build-type: RelWithDebInfo diff --git a/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf b/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf index 7ac7edecb1..d9edbc954b 100644 --- a/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf +++ b/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf @@ -1,4 +1,6 @@ -/** This tests an output that is broadcast back to a multiport input of a bank. */ +/** + * This tests an output that is broadcast back to a multiport input of a bank. + */ target C { timeout: 1 sec } diff --git a/test/C/src/federated/ChainWithDelay.lf b/test/C/src/federated/ChainWithDelay.lf index 2638756e19..c0a4c6a2a9 100644 --- a/test/C/src/federated/ChainWithDelay.lf +++ b/test/C/src/federated/ChainWithDelay.lf @@ -4,7 +4,7 @@ * @author Edward A. Lee */ target C { - timeout: 3 msec + timeout: 3 msec } import Count from "../lib/Count.lf" @@ -12,9 +12,9 @@ import InternalDelay from "../lib/InternalDelay.lf" import TestCount from "../lib/TestCount.lf" federated reactor { - c = new Count(period = 1 msec) - i = new InternalDelay(delay = 500 usec) - t = new TestCount(num_inputs = 3) - c.out -> i.in - i.out -> t.in + c = new Count(period = 1 msec) + i = new InternalDelay(delay = 500 usec) + t = new TestCount(num_inputs = 3) + c.out -> i.in + i.out -> t.in } diff --git a/test/C/src/federated/CycleDetection.lf b/test/C/src/federated/CycleDetection.lf index fb5bf39a7c..d22837bc1f 100644 --- a/test/C/src/federated/CycleDetection.lf +++ b/test/C/src/federated/CycleDetection.lf @@ -1,6 +1,6 @@ /** - * Check whether the internally generated network and control reactions introduce a cycle or not. - * The failure for this test is not being compiled. + * Check whether the internally generated network and control reactions + * introduce a cycle or not. The failure for this test is not being compiled. * @author Edward A. Lee */ target C diff --git a/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf b/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf index 2d007d2b09..9dea4032aa 100644 --- a/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf +++ b/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf @@ -1,7 +1,8 @@ /** - * Test a source-destination scenario where the source falls behind real-time, and reaches the - * timeout much later than the destination. In this test, the destination closes the connection - * early, causing the transmission to fail. Warnings will be printed about lost messages. + * Test a source-destination scenario where the source falls behind real-time, + * and reaches the timeout much later than the destination. In this test, the + * destination closes the connection early, causing the transmission to fail. + * Warnings will be printed about lost messages. * * The test fails if the federation does not exit. */ @@ -21,7 +22,9 @@ reactor Clock(offset: time = 0, period: time = 1 sec) { lf_set(y, self->count); =} - reaction(shutdown) {= lf_print("SUCCESS: the source exited successfully."); =} + reaction(shutdown) {= + lf_print("SUCCESS: the source exited successfully."); + =} } reactor Destination { diff --git a/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index fc45db9d74..8468e1dc81 100644 --- a/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -1,10 +1,11 @@ /** - * Test a source-destination scenario where the source falls behind real-time, and reaches the - * timeout much later than the destination. In this test, the destination closes the connection - * early, causing the transmission to fail. Warnings will be printed. + * Test a source-destination scenario where the source falls behind real-time, + * and reaches the timeout much later than the destination. In this test, the + * destination closes the connection early, causing the transmission to fail. + * Warnings will be printed. * - * The test fails if the federation does not exit amenably. This variant has a physical connection - * between source and destination. + * The test fails if the federation does not exit amenably. This variant has a + * physical connection between source and destination. */ target C { timeout: 1 msec, @@ -22,7 +23,9 @@ reactor Clock(offset: time = 0, period: time = 1 sec) { lf_set(y, self->count); =} - reaction(shutdown) {= lf_print("SUCCESS: the source exited successfully."); =} + reaction(shutdown) {= + lf_print("SUCCESS: the source exited successfully."); + =} } reactor Destination { diff --git a/test/C/src/federated/DistributedCount.lf b/test/C/src/federated/DistributedCount.lf index 472e7f83a0..2ebdda169a 100644 --- a/test/C/src/federated/DistributedCount.lf +++ b/test/C/src/federated/DistributedCount.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { diff --git a/test/C/src/federated/DistributedCountDecentralized.lf b/test/C/src/federated/DistributedCountDecentralized.lf index 473e959392..631dfab0c0 100644 --- a/test/C/src/federated/DistributedCountDecentralized.lf +++ b/test/C/src/federated/DistributedCountDecentralized.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { @@ -47,5 +48,6 @@ reactor Print { federated reactor DistributedCountDecentralized { c = new Count() p = new Print() - c.out -> p.in after 200 msec // Indicating a 'logical' connection with a large enough delay. + // Indicating a 'logical' connection with a large enough delay. + c.out -> p.in after 200 msec } diff --git a/test/C/src/federated/DistributedCountPhysical.lf b/test/C/src/federated/DistributedCountPhysical.lf index 77355720ff..9e1e15f775 100644 --- a/test/C/src/federated/DistributedCountPhysical.lf +++ b/test/C/src/federated/DistributedCountPhysical.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages only over connections that are marked 'physical' (using the ~> - * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is - * needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages only over connections that are + * marked 'physical' (using the ~> arrow). Therefore, no additional coordination + * of the advancement of time (HLA or Ptides) is needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf index eeb2792425..b0da42218a 100644 --- a/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf +++ b/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -1,7 +1,7 @@ /** - * Test a distributed system where a federation receives messages only over connections that are - * marked 'physical' (using the ~> arrow) with an after delay. The receiver verifies that the after - * delay is correctly imposed. + * Test a distributed system where a federation receives messages only over + * connections that are marked 'physical' (using the ~> arrow) with an after + * delay. The receiver verifies that the after delay is correctly imposed. * * @author Edward A. Lee * @author Soroush Bateni @@ -46,5 +46,6 @@ reactor Print { federated reactor at localhost { c = new Count(offset = 200 msec, period = 0) p = new Print() - c.out ~> p.in after 400 msec // Indicating a 'physical' connection with a 400 msec after delay. + // Indicating a 'physical' connection with a 400 msec after delay. + c.out ~> p.in after 400 msec } diff --git a/test/C/src/federated/DistributedCountPhysicalDecentralized.lf b/test/C/src/federated/DistributedCountPhysicalDecentralized.lf index b9a606ba0b..e821e4fb70 100644 --- a/test/C/src/federated/DistributedCountPhysicalDecentralized.lf +++ b/test/C/src/federated/DistributedCountPhysicalDecentralized.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages only over connections that are marked 'physical' (using the ~> - * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is - * needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages only over connections that are + * marked 'physical' (using the ~> arrow). Therefore, no additional coordination + * of the advancement of time (HLA or Ptides) is needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/C/src/federated/DistributedDoublePort.lf b/test/C/src/federated/DistributedDoublePort.lf index 3394c383b6..87de1ddb28 100644 --- a/test/C/src/federated/DistributedDoublePort.lf +++ b/test/C/src/federated/DistributedDoublePort.lf @@ -1,6 +1,7 @@ /** - * Test the case for when two upstream federates send messages to a downstream federate on two - * different ports. One message should carry a microstep delay relative to the other message. + * Test the case for when two upstream federates send messages to a downstream + * federate on two different ports. One message should carry a microstep delay + * relative to the other message. * * @author Soroush Bateni */ @@ -35,7 +36,9 @@ reactor Print { } =} - reaction(shutdown) {= lf_print("SUCCESS: messages were at least one microstep apart."); =} + reaction(shutdown) {= + lf_print("SUCCESS: messages were at least one microstep apart."); + =} } federated reactor DistributedDoublePort { diff --git a/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf b/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf index a8c3805f34..acbbaf4035 100644 --- a/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf @@ -1,6 +1,6 @@ /** - * Test that a rapidly produced logical action in an upstream federate can be properly handled in a - * long chain of federates. + * Test that a rapidly produced logical action in an upstream federate can be + * properly handled in a long chain of federates. */ target C { timeout: 1 msec diff --git a/test/C/src/federated/DistributedLoopedAction.lf b/test/C/src/federated/DistributedLoopedAction.lf index a398fb8b8d..8218e73646 100644 --- a/test/C/src/federated/DistributedLoopedAction.lf +++ b/test/C/src/federated/DistributedLoopedAction.lf @@ -1,5 +1,6 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken into account. + * Test a sender-receiver network system that relies on microsteps being taken + * into account. * * @author Soroush Bateni */ @@ -19,7 +20,8 @@ reactor Receiver( state breaks: int = 0 timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more sensible log output. + // but forces the logical time to advance Comment this line for a more + // sensible log output. reaction(in) {= printf("At tag (%lld, %u) received value %d.\n", lf_time_logical_elapsed(), diff --git a/test/C/src/federated/DistributedLoopedActionDecentralized.lf b/test/C/src/federated/DistributedLoopedActionDecentralized.lf index 5a51465e5c..17842809fa 100644 --- a/test/C/src/federated/DistributedLoopedActionDecentralized.lf +++ b/test/C/src/federated/DistributedLoopedActionDecentralized.lf @@ -1,13 +1,15 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken into account. The - * purpose of this test is to check whether the functionalities pertinent to dynamic STP offset - * adjustments are present and functioning to a degree. + * Test a sender-receiver network system that relies on microsteps being taken + * into account. The purpose of this test is to check whether the + * functionalities pertinent to dynamic STP offset adjustments are present and + * functioning to a degree. * - * This version of the test does not use a centralized coordinator to advance tag. Therefore, the - * receiver will rely on an STP offset (initially zero) to wait long enough for messages to arrive - * before advancing its tag. In this test, the STP offset is initially zero and gradually raised - * every time an STP violation is perceived until no STP violation is observed. Therefore, the exact - * outcome of the test will depend on actual runtime timing. + * This version of the test does not use a centralized coordinator to advance + * tag. Therefore, the receiver will rely on an STP offset (initially zero) to + * wait long enough for messages to arrive before advancing its tag. In this + * test, the STP offset is initially zero and gradually raised every time an STP + * violation is perceived until no STP violation is observed. Therefore, the + * exact outcome of the test will depend on actual runtime timing. * * @author Soroush Bateni */ @@ -114,7 +116,10 @@ reactor STPReceiver( federated reactor DistributedLoopedActionDecentralized { sender = new Sender(take_a_break_after = 10, break_interval = 400 msec) - stpReceiver = new STPReceiver(take_a_break_after = 10, break_interval = 400 msec) + stpReceiver = new STPReceiver( + take_a_break_after = 10, + break_interval = 400 msec + ) sender.out -> stpReceiver.in } diff --git a/test/C/src/federated/DistributedLoopedPhysicalAction.lf b/test/C/src/federated/DistributedLoopedPhysicalAction.lf index d1990c05ad..454577ff35 100644 --- a/test/C/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/C/src/federated/DistributedLoopedPhysicalAction.lf @@ -1,10 +1,11 @@ /** - * Test a sender-receiver network system that is similar to DistributedLoopedAction, but it uses a - * physical action rather than a logical action. This also demonstrates the advance-message-interval - * coordination option. This specifies the time period between Time Advance Notice (TAN) messages - * sent to the RTI (a form of null message that must be sent because of the physical action). The - * presence of this option also silences a warning about having a physical action that triggers an - * output. + * Test a sender-receiver network system that is similar to + * DistributedLoopedAction, but it uses a physical action rather than a logical + * action. This also demonstrates the advance-message-interval coordination + * option. This specifies the time period between Time Advance Notice (TAN) + * messages sent to the RTI (a form of null message that must be sent because of + * the physical action). The presence of this option also silences a warning + * about having a physical action that triggers an output. * * @author Soroush Bateni */ @@ -44,7 +45,8 @@ reactor Receiver( state breaks: int = 0 timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more sensible log output. + // but forces the logical time to advance Comment this line for a more + // sensible log output. reaction(in) {= tag_t current_tag = lf_tag(); lf_print("At tag (%lld, %u) received %d.", diff --git a/test/C/src/federated/DistributedLoopedPhysicalActionDecentralized.lf b/test/C/src/federated/DistributedLoopedPhysicalActionDecentralized.lf index 38c4e016fe..0397d3336d 100644 --- a/test/C/src/federated/DistributedLoopedPhysicalActionDecentralized.lf +++ b/test/C/src/federated/DistributedLoopedPhysicalActionDecentralized.lf @@ -4,15 +4,15 @@ * @author Soroush Bateni */ target C { - timeout: 1 sec, - coordination: decentralized + timeout: 1 sec, + coordination: decentralized } import Sender, Receiver from "DistributedLoopedPhysicalAction.lf" federated reactor { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/federated/DistributedMultiportToken.lf b/test/C/src/federated/DistributedMultiportToken.lf index c3a370cb66..dfb791d861 100644 --- a/test/C/src/federated/DistributedMultiportToken.lf +++ b/test/C/src/federated/DistributedMultiportToken.lf @@ -1,5 +1,5 @@ -// Check multiport connections between federates where the message is carried by a Token (in this -// case, with an array of char). +// Check multiport connections between federates where the message is carried by +// a Token (in this case, with an array of char). target C { timeout: 1 sec, coordination: centralized diff --git a/test/C/src/federated/DistributedNetworkOrder.lf b/test/C/src/federated/DistributedNetworkOrder.lf index 09ea7665c9..42f3da6134 100644 --- a/test/C/src/federated/DistributedNetworkOrder.lf +++ b/test/C/src/federated/DistributedNetworkOrder.lf @@ -1,9 +1,10 @@ /** * This is a test for send_timed_message, which is an internal API. * - * This test sends a second message at time 5 msec that has the same intended tag as a message that - * it had previously sent at time 0 msec. This results in a warning, but the message microstep is - * incremented and correctly received one microstep later. + * This test sends a second message at time 5 msec that has the same intended + * tag as a message that it had previously sent at time 0 msec. This results in + * a warning, but the message microstep is incremented and correctly received + * one microstep later. * * @author Soroush Bateni */ diff --git a/test/C/src/federated/DistributedPhysicalActionUpstream.lf b/test/C/src/federated/DistributedPhysicalActionUpstream.lf index f41aa0dae3..520142b466 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstream.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstream.lf @@ -1,6 +1,6 @@ /** - * Test that a rapidly produced physical action in an upstream federate can be properly handled in - * federated execution. + * Test that a rapidly produced physical action in an upstream federate can be + * properly handled in federated execution. */ target C { timeout: 10 secs, diff --git a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf index a77727d9ce..5cee1171cc 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf @@ -1,6 +1,6 @@ /** - * Test that a rapidly produced physical action in an upstream federate can be properly handled in a - * long chain of federates. + * Test that a rapidly produced physical action in an upstream federate can be + * properly handled in a long chain of federates. */ target C { timeout: 1 sec, diff --git a/test/C/src/federated/DistributedStop.lf b/test/C/src/federated/DistributedStop.lf index 7d906a0efe..2d4a616664 100644 --- a/test/C/src/federated/DistributedStop.lf +++ b/test/C/src/federated/DistributedStop.lf @@ -1,5 +1,6 @@ /** - * Test for lf_request_stop() in federated execution with centralized coordination. + * Test for lf_request_stop() in federated execution with centralized + * coordination. * * @author Soroush Bateni */ diff --git a/test/C/src/federated/DistributedStopDecentralized.lf b/test/C/src/federated/DistributedStopDecentralized.lf index f26dfe256a..c54bedd38c 100644 --- a/test/C/src/federated/DistributedStopDecentralized.lf +++ b/test/C/src/federated/DistributedStopDecentralized.lf @@ -4,14 +4,14 @@ * @author Soroush Bateni */ target C { - coordination: decentralized + coordination: decentralized } import Sender, Receiver from "DistributedStop.lf" federated reactor DistributedStopDecentralized { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/federated/DistributedStopZero.lf b/test/C/src/federated/DistributedStopZero.lf index 82f49b9b91..2e0529ea1d 100644 --- a/test/C/src/federated/DistributedStopZero.lf +++ b/test/C/src/federated/DistributedStopZero.lf @@ -6,79 +6,79 @@ target C reactor Sender { - output out: int - timer t(0, 1 usec) + output out: int + timer t(0, 1 usec) - reaction(t) -> out {= - printf("Sending 42 at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_set(out, 42); + reaction(t) -> out {= + printf("Sending 42 at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_set(out, 42); - tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; - if (lf_tag_compare(lf_tag(), zero) == 0) { - // Request stop at (0,0) - printf("Requesting stop at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_request_stop(); - } - =} + tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; + if (lf_tag_compare(lf_tag(), zero) == 0) { + // Request stop at (0,0) + printf("Requesting stop at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_request_stop(); + } + =} - reaction(shutdown) {= - if (lf_time_logical_elapsed() != USEC(0) || - lf_tag().microstep != 1) { - fprintf(stderr, "ERROR: Sender failed to stop the federation in time. " - "Stopping at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } - printf("SUCCESS: Successfully stopped the federation at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + reaction(shutdown) {= + if (lf_time_logical_elapsed() != USEC(0) || + lf_tag().microstep != 1) { + fprintf(stderr, "ERROR: Sender failed to stop the federation in time. " + "Stopping at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } + printf("SUCCESS: Successfully stopped the federation at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + =} } reactor Receiver { - input in: int + input in: int - reaction(in) {= - printf("Received %d at (%lld, %u).\n", - in->value, - lf_time_logical_elapsed(), - lf_tag().microstep); - tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; - if (lf_tag_compare(lf_tag(), zero) == 0) { - // Request stop at (0,0) - printf("Requesting stop at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_request_stop(); - } - =} + reaction(in) {= + printf("Received %d at (%lld, %u).\n", + in->value, + lf_time_logical_elapsed(), + lf_tag().microstep); + tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; + if (lf_tag_compare(lf_tag(), zero) == 0) { + // Request stop at (0,0) + printf("Requesting stop at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_request_stop(); + } + =} - reaction(shutdown) {= - // Sender should have requested stop earlier than the receiver. - // Therefore, the shutdown events must occur at (0, 0) on the - // receiver. - if (lf_time_logical_elapsed() != USEC(0) || - lf_tag().microstep != 1) { - fprintf(stderr, "ERROR: Receiver failed to stop the federation in time. " - "Stopping at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } - printf("SUCCESS: Successfully stopped the federation at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + reaction(shutdown) {= + // Sender should have requested stop earlier than the receiver. + // Therefore, the shutdown events must occur at (0, 0) on the + // receiver. + if (lf_time_logical_elapsed() != USEC(0) || + lf_tag().microstep != 1) { + fprintf(stderr, "ERROR: Receiver failed to stop the federation in time. " + "Stopping at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } + printf("SUCCESS: Successfully stopped the federation at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + =} } federated reactor { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/federated/DistributedStopZeroDecentralized.lf b/test/C/src/federated/DistributedStopZeroDecentralized.lf index ae37fb3fc3..ac67ef8f20 100644 --- a/test/C/src/federated/DistributedStopZeroDecentralized.lf +++ b/test/C/src/federated/DistributedStopZeroDecentralized.lf @@ -8,8 +8,8 @@ target C import Sender, Receiver from "DistributedStopZero.lf" federated reactor { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/federated/HelloDistributed.lf b/test/C/src/federated/HelloDistributed.lf index f0d74eead3..909ce53b43 100644 --- a/test/C/src/federated/HelloDistributed.lf +++ b/test/C/src/federated/HelloDistributed.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee */ target C @@ -48,5 +49,7 @@ federated reactor HelloDistributed at localhost { d = new Destination() // Reactor d is in federate Destination s.out -> d.in // This version preserves the timestamp. - reaction(startup) {= lf_print("Printing something in top-level federated reactor."); =} + reaction(startup) {= + lf_print("Printing something in top-level federated reactor."); + =} } diff --git a/test/C/src/federated/LoopDistributedCentralized.lf b/test/C/src/federated/LoopDistributedCentralized.lf index 15a1c46934..7fdc972b5a 100644 --- a/test/C/src/federated/LoopDistributedCentralized.lf +++ b/test/C/src/federated/LoopDistributedCentralized.lf @@ -1,5 +1,6 @@ /** - * This tests a feedback loop with physical actions and centralized coordination. + * This tests a feedback loop with physical actions and centralized + * coordination. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf b/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf index 9956d2ef34..f9b088b7d1 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf @@ -1,6 +1,6 @@ /** - * This tests that the precedence order of reaction invocation is kept when a feedback loop is - * present in centralized coordination. + * This tests that the precedence order of reaction invocation is kept when a + * feedback loop is present in centralized coordination. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf b/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf index 0e214813cd..17177aadb3 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf @@ -1,6 +1,7 @@ /** - * This tests that the precedence order of reaction invocation is kept in the hierarchy of reactors - * when a feedback loop is present in centralized coordination. + * This tests that the precedence order of reaction invocation is kept in the + * hierarchy of reactors when a feedback loop is present in centralized + * coordination. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/C/src/federated/LoopDistributedDecentralized.lf b/test/C/src/federated/LoopDistributedDecentralized.lf index 98d7a54eab..4350c984b3 100644 --- a/test/C/src/federated/LoopDistributedDecentralized.lf +++ b/test/C/src/federated/LoopDistributedDecentralized.lf @@ -1,5 +1,6 @@ /** - * This tests a feedback loop with physical actions and decentralized coordination. + * This tests a feedback loop with physical actions and decentralized + * coordination. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/LoopDistributedDouble.lf b/test/C/src/federated/LoopDistributedDouble.lf index 8646a477bf..9a49b5bde8 100644 --- a/test/C/src/federated/LoopDistributedDouble.lf +++ b/test/C/src/federated/LoopDistributedDouble.lf @@ -1,5 +1,6 @@ /** - * This tests a feedback loop with physical actions and centralized coordination. + * This tests a feedback loop with physical actions and centralized + * coordination. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/ParallelDestinations.lf b/test/C/src/federated/ParallelDestinations.lf index ee0a171cc4..1d76627853 100644 --- a/test/C/src/federated/ParallelDestinations.lf +++ b/test/C/src/federated/ParallelDestinations.lf @@ -1,23 +1,23 @@ /** Test parallel connections for federated execution. */ target C { - timeout: 2 sec + timeout: 2 sec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Source { - output[2] out: int - c1 = new Count() - c2 = new Count() + output[2] out: int + c1 = new Count() + c2 = new Count() - c1.out, c2.out -> out + c1.out, c2.out -> out } federated reactor { - s = new Source() - t1 = new TestCount(num_inputs = 3) - t2 = new TestCount(num_inputs = 3) + s = new Source() + t1 = new TestCount(num_inputs = 3) + t2 = new TestCount(num_inputs = 3) - s.out -> t1.in, t2.in + s.out -> t1.in, t2.in } diff --git a/test/C/src/federated/ParallelSources.lf b/test/C/src/federated/ParallelSources.lf index dab021efae..adcab8c689 100644 --- a/test/C/src/federated/ParallelSources.lf +++ b/test/C/src/federated/ParallelSources.lf @@ -1,24 +1,24 @@ /** Test parallel connections for federated execution. */ target C { - timeout: 2 sec + timeout: 2 sec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Destination { - input[2] in: int + input[2] in: int - t1 = new TestCount(num_inputs = 3) - t2 = new TestCount(num_inputs = 3) + t1 = new TestCount(num_inputs = 3) + t2 = new TestCount(num_inputs = 3) - in -> t1.in, t2.in + in -> t1.in, t2.in } federated reactor { - c1 = new Count() - c2 = new Count() - d = new Destination() + c1 = new Count() + c2 = new Count() + d = new Destination() - c1.out, c2.out -> d.in + c1.out, c2.out -> d.in } diff --git a/test/C/src/federated/ParallelSourcesMultiport.lf b/test/C/src/federated/ParallelSourcesMultiport.lf index 601d18c444..7d76c31522 100644 --- a/test/C/src/federated/ParallelSourcesMultiport.lf +++ b/test/C/src/federated/ParallelSourcesMultiport.lf @@ -1,34 +1,34 @@ /** Test parallel connections for federated execution. */ target C { - timeout: 2 sec + timeout: 2 sec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Source { - output[2] out: int - c1 = new Count() - c2 = new Count() + output[2] out: int + c1 = new Count() + c2 = new Count() - c1.out, c2.out -> out + c1.out, c2.out -> out } reactor Destination1 { - input[3] in: int + input[3] in: int - t1 = new TestCount(num_inputs = 3) - t2 = new TestCount(num_inputs = 3) - t3 = new TestCount(num_inputs = 3) + t1 = new TestCount(num_inputs = 3) + t2 = new TestCount(num_inputs = 3) + t3 = new TestCount(num_inputs = 3) - in -> t1.in, t2.in, t3.in + in -> t1.in, t2.in, t3.in } federated reactor { - s1 = new Source() - s2 = new Source() - d1 = new Destination1() - t4 = new TestCount(num_inputs = 3) + s1 = new Source() + s2 = new Source() + d1 = new Destination1() + t4 = new TestCount(num_inputs = 3) - s1.out, s2.out -> d1.in, t4.in + s1.out, s2.out -> d1.in, t4.in } diff --git a/test/C/src/federated/PhysicalSTP.lf b/test/C/src/federated/PhysicalSTP.lf index 4e8a6c7a5d..11b7a259cf 100644 --- a/test/C/src/federated/PhysicalSTP.lf +++ b/test/C/src/federated/PhysicalSTP.lf @@ -1,4 +1,7 @@ -/** This is a test that detects STP violations according to the physical time of message arrival. */ +/** + * This is a test that detects STP violations according to the physical time of + * message arrival. + */ target C { timeout: 1900 msec, coordination: decentralized diff --git a/test/C/src/federated/PingPongDistributed.lf b/test/C/src/federated/PingPongDistributed.lf index 147768f12d..e16de50ed2 100644 --- a/test/C/src/federated/PingPongDistributed.lf +++ b/test/C/src/federated/PingPongDistributed.lf @@ -1,18 +1,21 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing - * overhead. + * Basic benchmark from the Savina benchmark suite that is intended to measure + * message-passing overhead. * - * This version is distributed, communicating using logical connections over sockets. + * This version is distributed, communicating using logical connections over + * sockets. * - * See [Benchmarks wiki page](https://github.com/icyphy/lingua-franca/wiki/Benchmarks). + * See [Benchmarks wiki + * page](https://github.com/icyphy/lingua-franca/wiki/Benchmarks). * * This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs and can be run on - * different machines. + * This is a distributed version, where Ping and Pong run in separate programs + * and can be run on different machines. * - * There is no parallelism in this application, so it does not benefit from being being distributed. + * There is no parallelism in this application, so it does not benefit from + * being being distributed. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/PingPongDistributedPhysical.lf b/test/C/src/federated/PingPongDistributedPhysical.lf index 16769ec929..d9ba517c59 100644 --- a/test/C/src/federated/PingPongDistributedPhysical.lf +++ b/test/C/src/federated/PingPongDistributedPhysical.lf @@ -1,24 +1,26 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing - * overhead. + * Basic benchmark from the Savina benchmark suite that is intended to measure + * message-passing overhead. * - * This version is distributed, communicating using physical connections over sockets. + * This version is distributed, communicating using physical connections over + * sockets. * * This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs and can be run on - * different machines. + * This is a distributed version, where Ping and Pong run in separate programs + * and can be run on different machines. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * - Unthreaded: 97 msec * - Threaded: 265 msec * - Distributed: 53 seconds * - * There is no parallelism in this application, so it does not benefit from being being distributed. + * There is no parallelism in this application, so it does not benefit from + * being being distributed. * - * These measurements are total execution time, including startup and shutdown, of all three - * programs. + * These measurements are total execution time, including startup and shutdown, + * of all three programs. * * @author Edward A. Lee */ diff --git a/test/C/src/federated/SimpleFederated.lf b/test/C/src/federated/SimpleFederated.lf index 1a13a49d21..cb6a798f8b 100644 --- a/test/C/src/federated/SimpleFederated.lf +++ b/test/C/src/federated/SimpleFederated.lf @@ -1,17 +1,17 @@ target C { - timeout: 2 secs, - build-type: RelWithDebInfo + timeout: 2 secs, + build-type: RelWithDebInfo } reactor Fed { - input in: int - output out: int + input in: int + output out: int } federated reactor { - fed1 = new Fed() - fed2 = new Fed() + fed1 = new Fed() + fed2 = new Fed() - fed1.out -> fed2.in - fed2.out -> fed1.in + fed1.out -> fed2.in + fed2.out -> fed1.in } diff --git a/test/C/src/federated/StopAtShutdown.lf b/test/C/src/federated/StopAtShutdown.lf index aef59ef3a1..2ac97d6805 100644 --- a/test/C/src/federated/StopAtShutdown.lf +++ b/test/C/src/federated/StopAtShutdown.lf @@ -6,30 +6,30 @@ * @author Steven Wong */ target C { - timeout: 2 sec + timeout: 2 sec } reactor A { - input in: int + input in: int - reaction(startup) {= lf_print("Hello World!"); =} + reaction(startup) {= lf_print("Hello World!"); =} - reaction(in) {= lf_print("Got it"); =} + reaction(in) {= lf_print("Got it"); =} - reaction(shutdown) {= lf_request_stop(); =} + reaction(shutdown) {= lf_request_stop(); =} } reactor B { - output out: int - timer t(1 sec) + output out: int + timer t(1 sec) - reaction(t) -> out {= lf_set(out, 1); =} + reaction(t) -> out {= lf_set(out, 1); =} - reaction(shutdown) {= lf_request_stop(); =} + reaction(shutdown) {= lf_request_stop(); =} } federated reactor { - a = new A() - b = new B() - b.out -> a.in + a = new A() + b = new B() + b.out -> a.in } diff --git a/test/C/src/federated/TopLevelArtifacts.lf b/test/C/src/federated/TopLevelArtifacts.lf index 42a7cb3a37..05932b1937 100644 --- a/test/C/src/federated/TopLevelArtifacts.lf +++ b/test/C/src/federated/TopLevelArtifacts.lf @@ -1,10 +1,11 @@ /** - * Test whether top-level reactions, actions, and ports are handled appropriately. + * Test whether top-level reactions, actions, and ports are handled + * appropriately. * * Currently, these artifacts are replicated on all federates. * - * @note This just tests for the correctness of the code generation. These top-level artifacts might - * be disallowed in the future. + * @note This just tests for the correctness of the code generation. These + * top-level artifacts might be disallowed in the future. */ target C { timeout: 1 msec diff --git a/test/C/src/federated/failing/ClockSync.lf b/test/C/src/federated/failing/ClockSync.lf index a6c1e254d3..1231ce9cbf 100644 --- a/test/C/src/federated/failing/ClockSync.lf +++ b/test/C/src/federated/failing/ClockSync.lf @@ -1,8 +1,8 @@ /** - * This program tests clock synchronization. It checks the clock synchronization error and fails if - * it exceeds a threshold. Note that failures could occur here intermittently because clock - * synchronization accuracy depends on many conditions. But the threshold is quite high, so failures - * should be rare. + * This program tests clock synchronization. It checks the clock synchronization + * error and fails if it exceeds a threshold. Note that failures could occur + * here intermittently because clock synchronization accuracy depends on many + * conditions. But the threshold is quite high, so failures should be rare. * @author Edward A. Lee */ target C { @@ -10,16 +10,21 @@ target C { timeout: 10 sec, clock-sync: on, // Turn on runtime clock synchronization. clock-sync-options: { - local-federates-on: true, // Forces all federates to perform clock sync. - // Collect useful statistics like average network delay and the standard deviation for the - // network delay over one clock synchronization cycle. Generates a warning if the standard - // deviation is higher than the clock sync guard. Artificially offsets clocks by multiples - // of 200 msec. + // Forces all federates to perform clock sync. + local-federates-on: true, + // Collect useful statistics like average network delay and the standard + // deviation for the network delay over one clock synchronization cycle. + // Generates a warning if the standard deviation is higher than the + // clock sync guard. Artificially offsets clocks by multiples of 200 + // msec. collect-stats: true, test-offset: 200 msec, - period: 5 msec, // Period with which runtime clock sync is performed. - trials: 10, // Number of messages exchanged to perform clock sync. - attenuation: 10 // Attenuation applied to runtime clock sync adjustments. + // Period with which runtime clock sync is performed. + period: 5 msec, + // Number of messages exchanged to perform clock sync. + trials: 10, + // Attenuation applied to runtime clock sync adjustments. + attenuation: 10 } } diff --git a/test/C/src/lib/Imported.lf b/test/C/src/lib/Imported.lf index 1c86f0cff8..30e17cd94e 100644 --- a/test/C/src/lib/Imported.lf +++ b/test/C/src/lib/Imported.lf @@ -5,8 +5,8 @@ target C import ImportedAgain from "./ImportedAgain.lf" reactor Imported { - input x: int - a = new ImportedAgain() + input x: int + a = new ImportedAgain() - reaction(x) -> a.x {= lf_set(a.x, x->value); =} + reaction(x) -> a.x {= lf_set(a.x, x->value); =} } diff --git a/test/C/src/lib/ImportedAgain.lf b/test/C/src/lib/ImportedAgain.lf index af57afcace..dbde5e9fb0 100644 --- a/test/C/src/lib/ImportedAgain.lf +++ b/test/C/src/lib/ImportedAgain.lf @@ -3,13 +3,13 @@ target C reactor ImportedAgain { - input x: int + input x: int - reaction(x) {= - printf("Received: %d.\n", x->value); - if (x->value != 42) { - printf("ERROR: Expected input to be 42. Got: %d.\n", x->value); - exit(1); - } - =} + reaction(x) {= + printf("Received: %d.\n", x->value); + if (x->value != 42) { + printf("ERROR: Expected input to be 42. Got: %d.\n", x->value); + exit(1); + } + =} } diff --git a/test/C/src/lib/ImportedComposition.lf b/test/C/src/lib/ImportedComposition.lf index 66a8845233..d434f4eb6a 100644 --- a/test/C/src/lib/ImportedComposition.lf +++ b/test/C/src/lib/ImportedComposition.lf @@ -3,18 +3,18 @@ target C reactor Gain { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= lf_set(y, x->value * 2); =} + reaction(x) -> y {= lf_set(y, x->value * 2); =} } reactor ImportedComposition { - input x: int - output y: int - g1 = new Gain() - g2 = new Gain() - x -> g1.x after 10 msec - g1.y -> g2.x after 30 msec - g2.y -> y after 15 msec + input x: int + output y: int + g1 = new Gain() + g2 = new Gain() + x -> g1.x after 10 msec + g1.y -> g2.x after 30 msec + g2.y -> y after 15 msec } diff --git a/test/C/src/lib/LoopedActionSender.lf b/test/C/src/lib/LoopedActionSender.lf index 60af8480c7..b996fe6ac5 100644 --- a/test/C/src/lib/LoopedActionSender.lf +++ b/test/C/src/lib/LoopedActionSender.lf @@ -6,9 +6,10 @@ target C /** - * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break after sending - * take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in + * consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break + * after sending take_a_break_after messages. */ reactor Sender(take_a_break_after: int = 10, break_interval: time = 400 msec) { output out: int diff --git a/test/C/src/lib/TestCount.lf b/test/C/src/lib/TestCount.lf index e5cb1d601d..d3f29aec6c 100644 --- a/test/C/src/lib/TestCount.lf +++ b/test/C/src/lib/TestCount.lf @@ -1,6 +1,7 @@ /** - * Test that a counting sequence of inputs starts with the specified start parameter value, - * increments by the specified stride, and receives the specified number of inputs. + * Test that a counting sequence of inputs starts with the specified start + * parameter value, increments by the specified stride, and receives the + * specified number of inputs. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. diff --git a/test/C/src/modal_models/BanksModalStateReset.lf b/test/C/src/modal_models/BanksModalStateReset.lf index 95abf317fd..8e075715c8 100644 --- a/test/C/src/modal_models/BanksModalStateReset.lf +++ b/test/C/src/modal_models/BanksModalStateReset.lf @@ -1,4 +1,7 @@ -/** Modal Reactor Test. Tests reset of state variables in modes with banks of reactors. */ +/** + * Modal Reactor Test. Tests reset of state variables in modes with banks of + * reactors. + */ target C { fast: false, timeout: 4 sec @@ -45,7 +48,8 @@ main reactor { reset2.count2 -> test.events - reaction(stepper) -> reset1.next {= // Trigger mode change (separately because of #1278) + // Trigger mode change (separately because of #1278) + reaction(stepper) -> reset1.next {= for(int i = 0; i < reset1_width; i++) { lf_set(reset1[i].next, true); } diff --git a/test/C/src/modal_models/Count3Modes.lf b/test/C/src/modal_models/Count3Modes.lf index 6f597053e0..862915abed 100644 --- a/test/C/src/modal_models/Count3Modes.lf +++ b/test/C/src/modal_models/Count3Modes.lf @@ -36,9 +36,11 @@ main reactor { state expected_value: int = 1 - reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} // Trigger + // Trigger + reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} - reaction(stepper) counter.count {= // Check + // Check + reaction(stepper) counter.count {= printf("%d\n", counter.count->value); if (!counter.count->is_present) { diff --git a/test/C/src/modal_models/MixedReactions.lf b/test/C/src/modal_models/MixedReactions.lf index 54d97fe156..78ea39c95c 100644 --- a/test/C/src/modal_models/MixedReactions.lf +++ b/test/C/src/modal_models/MixedReactions.lf @@ -1,6 +1,6 @@ /** - * Modal Reactor Test. Tests reactions that are defined between and after modes and should be - * ordered accordingly. + * Modal Reactor Test. Tests reactions that are defined between and after modes + * and should be ordered accordingly. */ target C { fast: true, diff --git a/test/C/src/modal_models/ModalNestedReactions.lf b/test/C/src/modal_models/ModalNestedReactions.lf index dcc61ae9c6..f42ad4573f 100644 --- a/test/C/src/modal_models/ModalNestedReactions.lf +++ b/test/C/src/modal_models/ModalNestedReactions.lf @@ -1,68 +1,68 @@ /** Modal Reactor Test. Checks disabling of reactions indirectly nested in an inactive mode */ target C { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } reactor CounterCycle { - input next: bool + input next: bool - output count: int - output only_in_two: bool - output never: int + output count: int + output only_in_two: bool + output never: int - initial mode One { - reaction(next) -> count, reset(Two) {= - lf_set(count, 1); - lf_set_mode(Two); - =} - } + initial mode One { + reaction(next) -> count, reset(Two) {= + lf_set(count, 1); + lf_set_mode(Two); + =} + } - mode Two { - fwd = new Forward() - next -> fwd.in - fwd.out -> only_in_two - reaction(next) -> count, reset(One) {= - lf_set(count, 2); - lf_set_mode(One); - =} - } + mode Two { + fwd = new Forward() + next -> fwd.in + fwd.out -> only_in_two + reaction(next) -> count, reset(One) {= + lf_set(count, 2); + lf_set_mode(One); + =} + } - mode Three { - reaction(next) -> never {= lf_set(never, true); =} - } + mode Three { + reaction(next) -> never {= lf_set(never, true); =} + } } reactor Forward { - input in: bool - output out: bool + input in: bool + output out: bool - reaction(in) -> out {= lf_set(out, in->value); =} + reaction(in) -> out {= lf_set(out, in->value); =} } main reactor { - timer stepper(0, 250 msec) - counter = new CounterCycle() + timer stepper(0, 250 msec) + counter = new CounterCycle() - reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} // Trigger + reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} // Trigger - reaction(stepper) counter.count, counter.only_in_two {= // Check - printf("%d\n", counter.count->value); + reaction(stepper) counter.count, counter.only_in_two {= // Check + printf("%d\n", counter.count->value); - if (!counter.count->is_present) { - printf("ERROR: Missing mode change.\n"); - exit(1); - } else if (counter.only_in_two->is_present && counter.count->value != 2) { - printf("ERROR: Indirectly nested reaction was not properly deactivated.\n"); - exit(2); - } else if (!counter.only_in_two->is_present && counter.count->value == 2) { - printf("ERROR: Missing output from indirectly nested reaction.\n"); - exit(3); - } - =} + if (!counter.count->is_present) { + printf("ERROR: Missing mode change.\n"); + exit(1); + } else if (counter.only_in_two->is_present && counter.count->value != 2) { + printf("ERROR: Indirectly nested reaction was not properly deactivated.\n"); + exit(2); + } else if (!counter.only_in_two->is_present && counter.count->value == 2) { + printf("ERROR: Missing output from indirectly nested reaction.\n"); + exit(3); + } + =} - reaction(counter.never) {= - printf("ERROR: Detected output from unreachable mode.\n"); - exit(4); - =} + reaction(counter.never) {= + printf("ERROR: Detected output from unreachable mode.\n"); + exit(4); + =} } diff --git a/test/C/src/multiport/BankGangedConnections.lf b/test/C/src/multiport/BankGangedConnections.lf index f8cd730cae..231014c55e 100644 --- a/test/C/src/multiport/BankGangedConnections.lf +++ b/test/C/src/multiport/BankGangedConnections.lf @@ -1,27 +1,27 @@ target C { - timeout: 0 sec + timeout: 0 sec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Through { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= lf_set(out, in->value); =} + reaction(in) -> out {= lf_set(out, in->value); =} } reactor Bank { - input in: int - output out: int - t = new Through() - in, t.out -> t.in, out + input in: int + output out: int + t = new Through() + in, t.out -> t.in, out } main reactor { - b = new[2] Bank() - s = new Count() - t = new TestCount() - s.out, b.out -> b.in, t.in + b = new[2] Bank() + s = new Count() + t = new TestCount() + s.out, b.out -> b.in, t.in } diff --git a/test/C/src/multiport/BankMulticast.lf b/test/C/src/multiport/BankMulticast.lf index 35b4124c73..312a073464 100644 --- a/test/C/src/multiport/BankMulticast.lf +++ b/test/C/src/multiport/BankMulticast.lf @@ -3,36 +3,36 @@ * the container's output port. */ target C { - timeout: 3 sec, - fast: true + timeout: 3 sec, + fast: true } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Foo { - input in: int - output out: int + input in: int + output out: int - c = new Count() - c.out -> out + c = new Count() + c.out -> out - d = new TestCount(num_inputs = 4) - in -> d.in + d = new TestCount(num_inputs = 4) + in -> d.in } reactor Bar { - output[4] out: int + output[4] out: int - foo = new[4] Foo() + foo = new[4] Foo() - foo.out -> foo.in - foo.out -> out + foo.out -> foo.in + foo.out -> out } main reactor { - bar = new Bar() + bar = new Bar() - d = new[4] TestCount(num_inputs = 4) - bar.out -> d.in + d = new[4] TestCount(num_inputs = 4) + bar.out -> d.in } diff --git a/test/C/src/multiport/BankReactionsInContainer.lf b/test/C/src/multiport/BankReactionsInContainer.lf index 1e93ed7478..98d7cf4e1f 100644 --- a/test/C/src/multiport/BankReactionsInContainer.lf +++ b/test/C/src/multiport/BankReactionsInContainer.lf @@ -1,4 +1,6 @@ -/** This tests an output that is broadcast back to a multiport input of a bank. */ +/** + * This tests an output that is broadcast back to a multiport input of a bank. + */ target C { timeout: 1 sec } diff --git a/test/C/src/multiport/BankSelfBroadcast.lf b/test/C/src/multiport/BankSelfBroadcast.lf index a242a246cc..e1ffb4b2dd 100644 --- a/test/C/src/multiport/BankSelfBroadcast.lf +++ b/test/C/src/multiport/BankSelfBroadcast.lf @@ -1,7 +1,7 @@ /** - * Test a bank of reactors that broadcast a single output back to a multiport input of the same - * reactors in the bank so that each reactor in the bank receives the output produced by itself and - * each other reactor. + * Test a bank of reactors that broadcast a single output back to a multiport + * input of the same reactors in the bank so that each reactor in the bank + * receives the output produced by itself and each other reactor. * * @author Edward A. Lee */ diff --git a/test/C/src/multiport/MultiportFromBank.lf b/test/C/src/multiport/MultiportFromBank.lf index 3554380d8a..1b49786060 100644 --- a/test/C/src/multiport/MultiportFromBank.lf +++ b/test/C/src/multiport/MultiportFromBank.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target C { timeout: 2 sec, fast: true @@ -8,7 +8,9 @@ target C { reactor Source(check_override: int = 0, bank_index: int = 0) { output out: int - reaction(startup) -> out {= lf_set(out, self->bank_index * self->check_override); =} + reaction(startup) -> out {= + lf_set(out, self->bank_index * self->check_override); + =} } reactor Destination(port_width: int = 3) { diff --git a/test/C/src/multiport/MultiportFromBankHierarchy.lf b/test/C/src/multiport/MultiportFromBankHierarchy.lf index 295032cb8d..e8ee6194b5 100644 --- a/test/C/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/C/src/multiport/MultiportFromBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/C/src/multiport/MultiportFromBankHierarchyAfter.lf index c67fea9b45..dab31049a8 100644 --- a/test/C/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/C/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,15 +1,15 @@ // Check multiport output to bank of recipients. Here, the bank is smaller than the width of the // sending port. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Destination from "MultiportFromBank.lf" import Container from "MultiportFromBankHierarchy.lf" main reactor MultiportFromBankHierarchyAfter { - a = new Container(port_width = 4) - b = new Destination(port_width = 4) - a.out -> b.in after 1 sec + a = new Container(port_width = 4) + b = new Destination(port_width = 4) + a.out -> b.in after 1 sec } diff --git a/test/C/src/multiport/MultiportFromHierarchy.lf b/test/C/src/multiport/MultiportFromHierarchy.lf index 0f606e4750..8323210946 100644 --- a/test/C/src/multiport/MultiportFromHierarchy.lf +++ b/test/C/src/multiport/MultiportFromHierarchy.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input, where the former is a hierarchical reactor. +// Check multiport output to multiport input, where the former is a hierarchical +// reactor. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportIn.lf b/test/C/src/multiport/MultiportIn.lf index e62d32b0c6..b87a91a79b 100644 --- a/test/C/src/multiport/MultiportIn.lf +++ b/test/C/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -// This is a version fo the Threaded test that uses a multiport input at the destination. Its -// purpose is to test multiport inputs. +// This is a version fo the Threaded test that uses a multiport input at the +// destination. Its purpose is to test multiport inputs. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportInParameterized.lf b/test/C/src/multiport/MultiportInParameterized.lf index fa8b64855c..bf7ec93f6e 100644 --- a/test/C/src/multiport/MultiportInParameterized.lf +++ b/test/C/src/multiport/MultiportInParameterized.lf @@ -1,5 +1,5 @@ -// This is a version of the Threaded test that uses a multiport input at the destination. Its -// purpose is to test multiport inputs. +// This is a version of the Threaded test that uses a multiport input at the +// destination. Its purpose is to test multiport inputs. target C { timeout: 2 sec, fast: true @@ -60,6 +60,7 @@ main reactor { a.out -> t2.in a.out -> t3.in a.out -> t4.in - // I.e.: t1.out -> b.in[0]; t2.out -> b.in[1]; t3.out -> b.in[2]; dt4.out -> b.in[3]; + // I.e.: t1.out -> b.in[0]; t2.out -> b.in[1]; t3.out -> b.in[2]; dt4.out -> + // b.in[3]; t1.out, t2.out, t3.out, t4.out -> b.in } diff --git a/test/C/src/multiport/MultiportMutableInput.lf b/test/C/src/multiport/MultiportMutableInput.lf index e5c398def4..e1f8d579c2 100644 --- a/test/C/src/multiport/MultiportMutableInput.lf +++ b/test/C/src/multiport/MultiportMutableInput.lf @@ -1,5 +1,6 @@ -// Source produces a ints on a multiport, which it passes to Scale. Scale requests a writable copy. -// It modifies it and passes it to Print. It gets freed after Print is done with it. +// Source produces a ints on a multiport, which it passes to Scale. Scale +// requests a writable copy. It modifies it and passes it to Print. It gets +// freed after Print is done with it. target C reactor Source { diff --git a/test/C/src/multiport/MultiportMutableInputArray.lf b/test/C/src/multiport/MultiportMutableInputArray.lf index d27f97f93c..90907e4f44 100644 --- a/test/C/src/multiport/MultiportMutableInputArray.lf +++ b/test/C/src/multiport/MultiportMutableInputArray.lf @@ -1,6 +1,7 @@ -// Source produces a dynamically allocated arrays on a multiport, which it passes to Scale. Scale -// requests a writable copy, which, instead of copying, it just gets ownership of the original -// array. It modifies it and passes it to Print. It gets freed after Print is done with it. +// Source produces a dynamically allocated arrays on a multiport, which it +// passes to Scale. Scale requests a writable copy, which, instead of copying, +// it just gets ownership of the original array. It modifies it and passes it to +// Print. It gets freed after Print is done with it. target C reactor Source { diff --git a/test/C/src/multiport/MultiportToBank.lf b/test/C/src/multiport/MultiportToBank.lf index b4ef84e9dc..86146b9818 100644 --- a/test/C/src/multiport/MultiportToBank.lf +++ b/test/C/src/multiport/MultiportToBank.lf @@ -14,9 +14,10 @@ reactor Source(width: int = 2) { } =} - // Test also that multiple appearances of the same effect port do not result in multiple - // allocations of memory for the port. - reaction(dummy) -> out {= // Contents of the reactions does not matter (either could be empty) + // Test also that multiple appearances of the same effect port do not result + // in multiple allocations of memory for the port. + reaction(dummy) -> + out {= // Contents of the reactions does not matter (either could be empty) for(int i = 0; i < out_width; i++) { lf_set(out[i], i); } diff --git a/test/C/src/multiport/MultiportToBankAfter.lf b/test/C/src/multiport/MultiportToBankAfter.lf index 9ad4b04d71..ba26142243 100644 --- a/test/C/src/multiport/MultiportToBankAfter.lf +++ b/test/C/src/multiport/MultiportToBankAfter.lf @@ -1,4 +1,5 @@ -// Check multiport output to bank of recipients where the width of the bank is inferred. +// Check multiport output to bank of recipients where the width of the bank is +// inferred. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportToBankDouble.lf b/test/C/src/multiport/MultiportToBankDouble.lf index 5cf16f77a0..444f02d170 100644 --- a/test/C/src/multiport/MultiportToBankDouble.lf +++ b/test/C/src/multiport/MultiportToBankDouble.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients where the source has two reactions that write to the -// output. +// Check multiport output to bank of recipients where the source has two +// reactions that write to the output. target C { timeout: 2 sec, fast: true @@ -14,8 +14,8 @@ reactor Source { } =} - // Test also that multiple appearances of the same effect port do not result in multiple - // allocations of memory for the port. + // Test also that multiple appearances of the same effect port do not result + // in multiple allocations of memory for the port. reaction(startup) -> out {= // Contents of the reactions does not matter (either could be empty) for(int i = 0; i < out_width; i++) { diff --git a/test/C/src/multiport/MultiportToBankHierarchy.lf b/test/C/src/multiport/MultiportToBankHierarchy.lf index 93acb2081d..fbdc531bf0 100644 --- a/test/C/src/multiport/MultiportToBankHierarchy.lf +++ b/test/C/src/multiport/MultiportToBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportToHierarchy.lf b/test/C/src/multiport/MultiportToHierarchy.lf index bde5ee1169..41ca505077 100644 --- a/test/C/src/multiport/MultiportToHierarchy.lf +++ b/test/C/src/multiport/MultiportToHierarchy.lf @@ -1,5 +1,6 @@ -// Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that -// the destination reactor has width wider than the sender, so one input is dangling. +// Check multiport output to multiport input, where the latter is a hierarchical +// reactor. Note that the destination reactor has width wider than the sender, +// so one input is dangling. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportToMultiportArray.lf b/test/C/src/multiport/MultiportToMultiportArray.lf index 5cfac7368d..9d86a4a522 100644 --- a/test/C/src/multiport/MultiportToMultiportArray.lf +++ b/test/C/src/multiport/MultiportToMultiportArray.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input. Destination port is wider than sending port. +// Check multiport output to multiport input. Destination port is wider than +// sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/MultiportToPort.lf b/test/C/src/multiport/MultiportToPort.lf index a89c162e12..1784f2503c 100644 --- a/test/C/src/multiport/MultiportToPort.lf +++ b/test/C/src/multiport/MultiportToPort.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input. Destination port is wider than sending port. +// Check multiport output to multiport input. Destination port is wider than +// sending port. target C { timeout: 2 sec, fast: true diff --git a/test/C/src/multiport/PipelineAfter.lf b/test/C/src/multiport/PipelineAfter.lf index a9f9085873..e3256c5cb8 100644 --- a/test/C/src/multiport/PipelineAfter.lf +++ b/test/C/src/multiport/PipelineAfter.lf @@ -1,38 +1,38 @@ target C reactor Source { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= lf_set(out, 40); =} + reaction(startup) -> out {= lf_set(out, 40); =} } reactor Compute { - input in: unsigned - output out: unsigned + input in: unsigned + output out: unsigned - reaction(in) -> out {= lf_set(out, in->value + 2); =} + reaction(in) -> out {= lf_set(out, in->value + 2); =} } reactor Sink { - input in: unsigned - - reaction(in) {= - printf("Received %d\n", in->value); - if (in->value != 42) { - printf("ERROR: expected 42!\n"); - exit(1); - } - if (lf_time_logical_elapsed() != SEC(1)) { - printf("ERROR: Expected to receive input after one second.\n"); - exit(2); - } - =} + input in: unsigned + + reaction(in) {= + printf("Received %d\n", in->value); + if (in->value != 42) { + printf("ERROR: expected 42!\n"); + exit(1); + } + if (lf_time_logical_elapsed() != SEC(1)) { + printf("ERROR: Expected to receive input after one second.\n"); + exit(2); + } + =} } main reactor { - source = new Source() - compute = new Compute() - sink = new Sink() + source = new Source() + compute = new Compute() + sink = new Sink() - source.out, compute.out -> compute.in, sink.in after 500 msec + source.out, compute.out -> compute.in, sink.in after 500 msec } diff --git a/test/C/src/multiport/ReactionToContainedBankMultiport.lf b/test/C/src/multiport/ReactionToContainedBankMultiport.lf index 458d963bb9..d84b21c191 100644 --- a/test/C/src/multiport/ReactionToContainedBankMultiport.lf +++ b/test/C/src/multiport/ReactionToContainedBankMultiport.lf @@ -1,4 +1,5 @@ -// Test reaction sending messages to a contained bank of reactors with a multiport input. +// Test reaction sending messages to a contained bank of reactors with a +// multiport input. target C { timeout: 1 sec, fast: true diff --git a/test/C/src/multiport/ReactionsToNested.lf b/test/C/src/multiport/ReactionsToNested.lf index db8c1da63d..4270f55c2d 100644 --- a/test/C/src/multiport/ReactionsToNested.lf +++ b/test/C/src/multiport/ReactionsToNested.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target C { timeout: 1 sec } diff --git a/test/C/src/multiport/SparseFallback.lf b/test/C/src/multiport/SparseFallback.lf index 1326f9ca99..a7788858d8 100644 --- a/test/C/src/multiport/SparseFallback.lf +++ b/test/C/src/multiport/SparseFallback.lf @@ -1,6 +1,6 @@ /** - * Test reading of sparse inputs on a multiport where the density of writes to the multiport is high - * enough to force the fallback policy to kick in. + * Test reading of sparse inputs on a multiport where the density of writes to + * the multiport is high enough to force the fallback policy to kick in. */ target C { timeout: 20 ms diff --git a/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf b/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf index d4a37bbaee..917982af39 100644 --- a/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf +++ b/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf @@ -1,4 +1,7 @@ -/** This test checks that a downstream reaction is triggered only if its trigger is present. */ +/** + * This test checks that a downstream reaction is triggered only if its trigger + * is present. + */ target C { timeout: 1 sec, fast: true diff --git a/test/C/src/serialization/PersonProtocolBuffers.lf b/test/C/src/serialization/PersonProtocolBuffers.lf index f2572fc72f..ffc346db3d 100644 --- a/test/C/src/serialization/PersonProtocolBuffers.lf +++ b/test/C/src/serialization/PersonProtocolBuffers.lf @@ -18,29 +18,29 @@ * typically at /usr/local/bin. */ target C { - protobufs: Person.proto + protobufs: Person.proto } main reactor { - reaction(startup) {= - Person person = PERSON__INIT; // Macro to create the protocol buffer - uint8_t* buffer; // Buffer to store the serialized data - unsigned len; // Length of the packed message + reaction(startup) {= + Person person = PERSON__INIT; // Macro to create the protocol buffer + uint8_t* buffer; // Buffer to store the serialized data + unsigned len; // Length of the packed message - person.name = "Lingua Franca"; - person.id = 1; - person.email = "eal@berkeley.edu"; + person.name = "Lingua Franca"; + person.id = 1; + person.email = "eal@berkeley.edu"; - // Pack the message into buffer. - len = person__get_packed_size(&person); - buffer = (uint8_t*)malloc(len); - person__pack(&person, buffer); + // Pack the message into buffer. + len = person__get_packed_size(&person); + buffer = (uint8_t*)malloc(len); + person__pack(&person, buffer); - // Now unpack the message from buffer. - Person *unpacked = person__unpack(NULL, len, buffer); + // Now unpack the message from buffer. + Person *unpacked = person__unpack(NULL, len, buffer); - // Extract and print the unpacked message. - printf("Name: %s\n", unpacked->name); - free(buffer); // Free the allocated serialized buffer - =} + // Extract and print the unpacked message. + printf("Name: %s\n", unpacked->name); + free(buffer); // Free the allocated serialized buffer + =} } diff --git a/test/C/src/serialization/ProtoNoPacking.lf b/test/C/src/serialization/ProtoNoPacking.lf index 91464570fc..57b610e337 100644 --- a/test/C/src/serialization/ProtoNoPacking.lf +++ b/test/C/src/serialization/ProtoNoPacking.lf @@ -17,29 +17,29 @@ * typically at /usr/local/bin. */ target C { - protobufs: [ProtoHelloWorld.proto] + protobufs: [ProtoHelloWorld.proto] } reactor SourceProto { - output out: ProtoHelloWorld + output out: ProtoHelloWorld - reaction(startup) -> out {= - out->value.name = "Hello World"; - out->value.number = 42; - SET_PRESENT(out); - =} + reaction(startup) -> out {= + out->value.name = "Hello World"; + out->value.number = 42; + SET_PRESENT(out); + =} } reactor SinkProto { - input in: ProtoHelloWorld + input in: ProtoHelloWorld - reaction(in) {= - printf("Received: name=\"%s\", number=%d.\n", in->value.name, in->value.number); - =} + reaction(in) {= + printf("Received: name=\"%s\", number=%d.\n", in->value.name, in->value.number); + =} } main reactor ProtoNoPacking { - s = new SourceProto() - d = new SinkProto() - s.out -> d.in + s = new SourceProto() + d = new SinkProto() + s.out -> d.in } diff --git a/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf b/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf index dc5902885e..97b5a12554 100644 --- a/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf +++ b/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf @@ -1,12 +1,13 @@ /** - * This test showcases the infrastructure that is built into the CCpp target that can automatically - * serialize and deserialize ROS2 messages (with a shared_ptr type) in federated programs. + * This test showcases the infrastructure that is built into the CCpp target + * that can automatically serialize and deserialize ROS2 messages (with a + * shared_ptr type) in federated programs. * - * This test contains a sender-receiver federated program in which the 'sender' federate sends a - * std_msgs::msg::Int32 message to the 'receiver' federate. + * This test contains a sender-receiver federated program in which the 'sender' + * federate sends a std_msgs::msg::Int32 message to the 'receiver' federate. * - * To run this test, make sure that your terminal is properly sourced for ROS2. See - * https://docs.ros.org/en/foxy/Tutorials/Configuring-ROS2-Environment.html. + * To run this test, make sure that your terminal is properly sourced for ROS2. + * See https://docs.ros.org/en/foxy/Tutorials/Configuring-ROS2-Environment.html. * * Then you can use lfc to compile this program: * diff --git a/test/C/src/target/CMakeInclude.lf b/test/C/src/target/CMakeInclude.lf index 6b9d3b2ecc..e1215fa85e 100644 --- a/test/C/src/target/CMakeInclude.lf +++ b/test/C/src/target/CMakeInclude.lf @@ -2,28 +2,28 @@ * Test that cmake-include is working correctly. The failure for this test is failure to compile. */ target C { - cmake-include: [ - "../include/mlib-cmake-extension.cmake", - "../include/foo-cmake-compile-definition.txt" - ], - timeout: 0 sec + cmake-include: [ + "../include/mlib-cmake-extension.cmake", + "../include/foo-cmake-compile-definition.txt" + ], + timeout: 0 sec } reactor Foo { - preamble {= - #include - =} + preamble {= + #include + =} - reaction(startup) {= - lf_print("Maximum of 4.20 and %.2f is %.2f", FOO, fmax(4.20, FOO)); + reaction(startup) {= + lf_print("Maximum of 4.20 and %.2f is %.2f", FOO, fmax(4.20, FOO)); - // Check if BAR is defined, which is an error condition (@see federated/DistributedCMakeIncludeSeparateCompile.lf). - #ifdef BAR - #error "I found definition for BAR in Foo. Failed to compile federates separately." - #endif // BAR - =} + // Check if BAR is defined, which is an error condition (@see federated/DistributedCMakeIncludeSeparateCompile.lf). + #ifdef BAR + #error "I found definition for BAR in Foo. Failed to compile federates separately." + #endif // BAR + =} } main reactor { - f = new Foo() + f = new Foo() } diff --git a/test/C/src/target/DistributedCMakeInclude.lf b/test/C/src/target/DistributedCMakeInclude.lf index 486dafa608..e9b393f3d1 100644 --- a/test/C/src/target/DistributedCMakeInclude.lf +++ b/test/C/src/target/DistributedCMakeInclude.lf @@ -3,29 +3,29 @@ * 3.14. The failure for this test is failure to compile. */ target C { - timeout: 0 sec, - cmake-include: "include/bar-cmake-compile-definition.cmake" + timeout: 0 sec, + cmake-include: "include/bar-cmake-compile-definition.cmake" } import Baz from "lib/ImportedCMakeInclude.lf" reactor Bar { - baz = new Baz() - preamble {= - #include - =} + baz = new Baz() + preamble {= + #include + =} - reaction(startup) {= - lf_print("Maximum of 4.20 and %.2f is %.2f", BAR, fmax(4.20, BAR)); + reaction(startup) {= + lf_print("Maximum of 4.20 and %.2f is %.2f", BAR, fmax(4.20, BAR)); - // Check if FOO is defined, which is an error condition (@see DistributedCMakeIncludeSeparateCompile.lf). - #ifdef FOO - #error "I found definition for FOO in Bar. Failed to compile federates separately." - #endif // FOO - =} + // Check if FOO is defined, which is an error condition (@see DistributedCMakeIncludeSeparateCompile.lf). + #ifdef FOO + #error "I found definition for FOO in Bar. Failed to compile federates separately." + #endif // FOO + =} } federated reactor { - f1 = new Bar() - f2 = new Bar() + f1 = new Bar() + f2 = new Bar() } diff --git a/test/C/src/target/DistributedCMakeIncludeSeparateCompile.lf b/test/C/src/target/DistributedCMakeIncludeSeparateCompile.lf index f1cf671c03..12711c3203 100644 --- a/test/C/src/target/DistributedCMakeIncludeSeparateCompile.lf +++ b/test/C/src/target/DistributedCMakeIncludeSeparateCompile.lf @@ -4,13 +4,13 @@ * compile. */ target C { - timeout: 0 sec + timeout: 0 sec } import Foo from "CMakeInclude.lf" import Bar from "DistributedCMakeInclude.lf" federated reactor { - f1 = new Foo() - b1 = new Bar() + f1 = new Foo() + b1 = new Bar() } diff --git a/test/C/src/target/Files.lf b/test/C/src/target/Files.lf index a89ad56da4..e49bd80684 100644 --- a/test/C/src/target/Files.lf +++ b/test/C/src/target/Files.lf @@ -1,17 +1,17 @@ /** Test the files target property. */ target C { - files: ["../include", "include/dummy.h"] + files: ["../include", "include/dummy.h"] } preamble {= - #include "include/hello.h" - #include "dummy.h" + #include "include/hello.h" + #include "dummy.h" =} main reactor { - reaction(startup) {= - hello_t t; - dummy_t d; - lf_print("SUCCESS."); - =} + reaction(startup) {= + hello_t t; + dummy_t d; + lf_print("SUCCESS."); + =} } diff --git a/test/C/src/target/HelloWorldCCPP.lf b/test/C/src/target/HelloWorldCCPP.lf index 917ca4308a..91d1cd61d1 100644 --- a/test/C/src/target/HelloWorldCCPP.lf +++ b/test/C/src/target/HelloWorldCCPP.lf @@ -1,6 +1,6 @@ /** - * A variant of HelloWorld.lf that tests the CCpp target in conjunction with the CMake build system. - * This test should not pass if it does not compile. + * A variant of HelloWorld.lf that tests the CCpp target in conjunction with the + * CMake build system. This test should not pass if it does not compile. */ target CCpp { tracing: true, diff --git a/test/C/src/target/HelloWorldFederatedCCPP.lf b/test/C/src/target/HelloWorldFederatedCCPP.lf index 54c285c700..25124a18fc 100644 --- a/test/C/src/target/HelloWorldFederatedCCPP.lf +++ b/test/C/src/target/HelloWorldFederatedCCPP.lf @@ -3,14 +3,14 @@ * should not pass if it does not compile. */ target CCpp { - tracing: true, - coordination: centralized, - timeout: 1 sec + tracing: true, + coordination: centralized, + timeout: 1 sec } import HelloWorld from "HelloWorldCCPP.lf" federated reactor { - a = new HelloWorld() - b = new HelloWorld() // Create a non-singleton federation + a = new HelloWorld() + b = new HelloWorld() // Create a non-singleton federation } diff --git a/test/C/src/target/HelloWorldThreadedCPP.lf b/test/C/src/target/HelloWorldThreadedCPP.lf index 259ea9d320..e6e2a257e8 100644 --- a/test/C/src/target/HelloWorldThreadedCPP.lf +++ b/test/C/src/target/HelloWorldThreadedCPP.lf @@ -3,12 +3,12 @@ * does not compile. */ target CCpp { - tracing: true, - logging: DEBUG + tracing: true, + logging: DEBUG } import HelloWorld from "HelloWorldCCPP.lf" main reactor { - a = new HelloWorld() + a = new HelloWorld() } diff --git a/test/C/src/target/Platform.lf b/test/C/src/target/Platform.lf index 79e163b2af..00895a749f 100644 --- a/test/C/src/target/Platform.lf +++ b/test/C/src/target/Platform.lf @@ -1,8 +1,8 @@ /** Test that the cross-compile capability works as expected. */ target C { - platform: "Mac" + platform: "Mac" } main reactor { - reaction(startup) {= lf_print("Hello, Mac!"); =} + reaction(startup) {= lf_print("Hello, Mac!"); =} } diff --git a/test/C/src/target/lib/ImportedCMakeInclude.lf b/test/C/src/target/lib/ImportedCMakeInclude.lf index fc44313fad..e272c2aa96 100644 --- a/test/C/src/target/lib/ImportedCMakeInclude.lf +++ b/test/C/src/target/lib/ImportedCMakeInclude.lf @@ -1,18 +1,18 @@ target C { - cmake-include: "../include/baz-cmake-compile-definition.cmake" + cmake-include: "../include/baz-cmake-compile-definition.cmake" } reactor Baz { - preamble {= - #include - =} + preamble {= + #include + =} - reaction(startup) {= - lf_print("Maximum of 4.20 and %.2f is %.2f", BAZ, fmax(4.20, BAZ)); + reaction(startup) {= + lf_print("Maximum of 4.20 and %.2f is %.2f", BAZ, fmax(4.20, BAZ)); - // Check if FOO is defined, which is an error condition (@see DistributedCMakeIncludeSeparateCompile.lf). - #ifdef FOO - #error "I found definition for FOO in Baz. Failed to compile federates separately." - #endif // FOO - =} + // Check if FOO is defined, which is an error condition (@see DistributedCMakeIncludeSeparateCompile.lf). + #ifdef FOO + #error "I found definition for FOO in Baz. Failed to compile federates separately." + #endif // FOO + =} } diff --git a/test/Cpp/src/ActionWithNoReaction.lf b/test/Cpp/src/ActionWithNoReaction.lf index f4c0fa8a01..78f1011544 100644 --- a/test/Cpp/src/ActionWithNoReaction.lf +++ b/test/Cpp/src/ActionWithNoReaction.lf @@ -1,36 +1,36 @@ // This checks that action can be created even if there is no reaction. This test passes merely by // compiling and executing without a segfault. Its other functionality is tested by other tests. target Cpp { - fast: true, - timeout: 3 sec + fast: true, + timeout: 3 sec } reactor foo { - input x: int - output y: int - logical action a + input x: int + output y: int + logical action a - reaction(x) -> y, a {= - y.set(2*(*x.get())); - a.schedule(500ms); - =} + reaction(x) -> y, a {= + y.set(2*(*x.get())); + a.schedule(500ms); + =} } reactor print { - input x: int + input x: int - reaction(x) {= - std::cout << "Result is " << *x.get() << '\n'; - std::cout << "Current logical time is: " << get_elapsed_logical_time() << '\n'; - std::cout << "Current physical time is: " << get_elapsed_physical_time() << '\n'; - =} + reaction(x) {= + std::cout << "Result is " << *x.get() << '\n'; + std::cout << "Current logical time is: " << get_elapsed_logical_time() << '\n'; + std::cout << "Current physical time is: " << get_elapsed_physical_time() << '\n'; + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x - reaction(t) -> f.x {= f.x.set(42); =} + reaction(t) -> f.x {= f.x.set(42); =} } diff --git a/test/Cpp/src/After.lf b/test/Cpp/src/After.lf index 40f9e3a54b..bbcc287b78 100644 --- a/test/Cpp/src/After.lf +++ b/test/Cpp/src/After.lf @@ -1,4 +1,5 @@ -// This checks that the after keyword adjusts logical time, not using physical time. +// This checks that the after keyword adjusts logical time, not using physical +// time. target Cpp { fast: false, timeout: 3 sec diff --git a/test/Cpp/src/AfterZero.lf b/test/Cpp/src/AfterZero.lf index 59ba9b4fb3..152b87cfc2 100644 --- a/test/Cpp/src/AfterZero.lf +++ b/test/Cpp/src/AfterZero.lf @@ -1,4 +1,5 @@ -// This checks that the after keyword adjusts logical time, not using physical time. +// This checks that the after keyword adjusts logical time, not using physical +// time. target Cpp { fast: false, timeout: 3 sec diff --git a/test/Cpp/src/Alignment.lf b/test/Cpp/src/Alignment.lf index 0ab486903c..1bd3562f41 100644 --- a/test/Cpp/src/Alignment.lf +++ b/test/Cpp/src/Alignment.lf @@ -1,4 +1,5 @@ -// This test checks that the downstream reaction is not invoked more than once at a logical time. +// This test checks that the downstream reaction is not invoked more than once +// at a logical time. target Cpp { logging: LOG, timeout: 1 sec, diff --git a/test/Cpp/src/ArrayAsParameter.lf b/test/Cpp/src/ArrayAsParameter.lf index e36a63a201..85cd0630bf 100644 --- a/test/Cpp/src/ArrayAsParameter.lf +++ b/test/Cpp/src/ArrayAsParameter.lf @@ -1,4 +1,5 @@ -// Source has an variable sized list as a parameter, the elements of which it passes to Print. +// Source has an variable sized list as a parameter, the elements of which it +// passes to Print. target Cpp reactor Source(sequence: std::vector = {0, 1, 2}) { diff --git a/test/Cpp/src/ArrayAsType.lf b/test/Cpp/src/ArrayAsType.lf index d678fc1d0b..0c7ba0f16b 100644 --- a/test/Cpp/src/ArrayAsType.lf +++ b/test/Cpp/src/ArrayAsType.lf @@ -3,49 +3,49 @@ target Cpp reactor Source { - output out: int[3] - - reaction(startup) -> out {= - // create a statically allocated array - std::array result = {3, 4, 5}; - // send a copy - out.set(result); - =} + output out: int[3] + + reaction(startup) -> out {= + // create a statically allocated array + std::array result = {3, 4, 5}; + // send a copy + out.set(result); + =} } reactor Print { - input in: int[3] - - reaction(in) {= - int expected = 3; - bool failed = false; - - // get a reference to the result to avoid a copy - auto& result = *in.get(); - - std::cout << "Received: ["; - for (int i = 0; i < 3; i++) { - std::cout << result[i]; - if (i < 2) { - std::cout << ", "; - } - - // check whether values match expectation. - if (result[i] != expected) { - failed = true; - } - expected++; + input in: int[3] + + reaction(in) {= + int expected = 3; + bool failed = false; + + // get a reference to the result to avoid a copy + auto& result = *in.get(); + + std::cout << "Received: ["; + for (int i = 0; i < 3; i++) { + std::cout << result[i]; + if (i < 2) { + std::cout << ", "; } - std::cout << "]\n"; - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); + + // check whether values match expectation. + if (result[i] != expected) { + failed = true; } - =} + expected++; + } + std::cout << "]\n"; + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/Cpp/src/ArrayParallel.lf b/test/Cpp/src/ArrayParallel.lf index c8272b64a2..739614442c 100644 --- a/test/Cpp/src/ArrayParallel.lf +++ b/test/Cpp/src/ArrayParallel.lf @@ -7,13 +7,13 @@ import Scale from "ArrayScale.lf" import Source, Print from "ArrayPrint.lf" main reactor ArrayParallel { - s = new Source() - c1 = new Scale() - c2 = new Scale(scale = 3) - p1 = new Print(scale = 2) - p2 = new Print(scale = 3) - s.out -> c1.in - s.out -> c2.in - c1.out -> p1.in - c2.out -> p2.in + s = new Source() + c1 = new Scale() + c2 = new Scale(scale = 3) + p1 = new Print(scale = 2) + p2 = new Print(scale = 3) + s.out -> c1.in + s.out -> c2.in + c1.out -> p1.in + c2.out -> p2.in } diff --git a/test/Cpp/src/ArrayPrint.lf b/test/Cpp/src/ArrayPrint.lf index 59395d37d7..3bdf494107 100644 --- a/test/Cpp/src/ArrayPrint.lf +++ b/test/Cpp/src/ArrayPrint.lf @@ -1,5 +1,6 @@ -// Source produces a dynamically allocated array, which it passes to Print. The ownership semantics -// of values ensure that the array is automatically deleted if it does have no owner. +// Source produces a dynamically allocated array, which it passes to Print. The +// ownership semantics of values ensure that the array is automatically deleted +// if it does have no owner. target Cpp reactor Source { diff --git a/test/Cpp/src/ArrayScale.lf b/test/Cpp/src/ArrayScale.lf index 44db608e92..b52e7305b7 100644 --- a/test/Cpp/src/ArrayScale.lf +++ b/test/Cpp/src/ArrayScale.lf @@ -1,5 +1,6 @@ -// Source produces a dynamically allocated array, which it passes to Scale. Scale requests a -// writable copy. It modifies it and passes it to Print. It gets freed after Print is done with it. +// Source produces a dynamically allocated array, which it passes to Scale. +// Scale requests a writable copy. It modifies it and passes it to Print. It +// gets freed after Print is done with it. target Cpp import Source, Print from "ArrayPrint.lf" diff --git a/test/Cpp/src/Composition.lf b/test/Cpp/src/Composition.lf index 4c5baeb870..0a341d5e4f 100644 --- a/test/Cpp/src/Composition.lf +++ b/test/Cpp/src/Composition.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target Cpp { fast: true, timeout: 10 sec diff --git a/test/Cpp/src/CompositionAfter.lf b/test/Cpp/src/CompositionAfter.lf index ea1b27fd5e..15d68e13ea 100644 --- a/test/Cpp/src/CompositionAfter.lf +++ b/test/Cpp/src/CompositionAfter.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target Cpp { fast: true, timeout: 10 sec diff --git a/test/Cpp/src/CompositionGain.lf b/test/Cpp/src/CompositionGain.lf index a59b869786..bd4804fcc6 100644 --- a/test/Cpp/src/CompositionGain.lf +++ b/test/Cpp/src/CompositionGain.lf @@ -2,33 +2,33 @@ target Cpp reactor Gain { - input gainin: int - output y: int + input gainin: int + output y: int - reaction(gainin) -> y {= - reactor::log::Info() << "Gain received " << *gainin.get(); - y.set(*gainin.get()*2); - =} + reaction(gainin) -> y {= + reactor::log::Info() << "Gain received " << *gainin.get(); + y.set(*gainin.get()*2); + =} } reactor Wrapper { - input x: int - output y: int - gain = new Gain() - x -> gain.gainin - gain.y -> y + input x: int + output y: int + gain = new Gain() + x -> gain.gainin + gain.y -> y } main reactor CompositionGain { - wrapper = new Wrapper() + wrapper = new Wrapper() - reaction(startup) -> wrapper.x {= wrapper.x.set(42); =} + reaction(startup) -> wrapper.x {= wrapper.x.set(42); =} - reaction(wrapper.y) {= - reactor::log::Info() << "Received " << *wrapper.y.get(); - if (*wrapper.y.get() != 42*2) { - reactor::log::Error() << "Received value should have been " << 42 * 2; - exit(2); - } - =} + reaction(wrapper.y) {= + reactor::log::Info() << "Received " << *wrapper.y.get(); + if (*wrapper.y.get() != 42*2) { + reactor::log::Error() << "Received value should have been " << 42 * 2; + exit(2); + } + =} } diff --git a/test/Cpp/src/DanglingOutput.lf b/test/Cpp/src/DanglingOutput.lf index 499fa0e504..537eff1cde 100644 --- a/test/Cpp/src/DanglingOutput.lf +++ b/test/Cpp/src/DanglingOutput.lf @@ -3,24 +3,24 @@ target Cpp reactor Source { - output out: int - timer t + output out: int + timer t - reaction(t) -> out {= out.set(1); =} + reaction(t) -> out {= out.set(1); =} } reactor Gain { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= - std::cout << "Received " << *in.get() << std::endl; - out.set(*in.get() * 2); - =} + reaction(in) -> out {= + std::cout << "Received " << *in.get() << std::endl; + out.set(*in.get() * 2); + =} } main reactor DanglingOutput { - source = new Source() - container = new Gain() - source.out -> container.in + source = new Source() + container = new Gain() + source.out -> container.in } diff --git a/test/Cpp/src/Deadline.lf b/test/Cpp/src/Deadline.lf index 5a6448195d..19a41ff057 100644 --- a/test/Cpp/src/Deadline.lf +++ b/test/Cpp/src/Deadline.lf @@ -1,5 +1,6 @@ -// This example illustrates local deadline handling. Even numbers are sent by the Source -// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by +// the Source immediately, whereas odd numbers are sent after a big enough delay +// to violate the deadline. target Cpp { timeout: 4 sec } diff --git a/test/Cpp/src/DeadlineHandledAbove.lf b/test/Cpp/src/DeadlineHandledAbove.lf index e39ae3db09..b2a6c7658a 100644 --- a/test/Cpp/src/DeadlineHandledAbove.lf +++ b/test/Cpp/src/DeadlineHandledAbove.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the container reacts to that -// output. +// Test a deadline where the deadline violation produces an output and the +// container reacts to that output. target Cpp reactor Deadline(threshold: time = 100 msec) { diff --git a/test/Cpp/src/DelayedReaction.lf b/test/Cpp/src/DelayedReaction.lf index d7fdabb2f8..c5e937a8e7 100644 --- a/test/Cpp/src/DelayedReaction.lf +++ b/test/Cpp/src/DelayedReaction.lf @@ -2,26 +2,26 @@ target Cpp reactor Source { - output out: void + output out: void - reaction(startup) -> out {= out.set(); =} + reaction(startup) -> out {= out.set(); =} } reactor Sink { - input in: void + input in: void - reaction(in) {= - auto elapsed = get_elapsed_logical_time(); - std::cout << "Nanoseconds since start: " << elapsed << '\n'; - if (elapsed != 100ms) { - std::cerr << "ERROR: Expected 100000000 nsecs.\n"; - exit(1); - } - =} + reaction(in) {= + auto elapsed = get_elapsed_logical_time(); + std::cout << "Nanoseconds since start: " << elapsed << '\n'; + if (elapsed != 100ms) { + std::cerr << "ERROR: Expected 100000000 nsecs.\n"; + exit(1); + } + =} } main reactor DelayedReaction { - source = new Source() - sink = new Sink() - source.out -> sink.in after 100 msec + source = new Source() + sink = new Sink() + source.out -> sink.in after 100 msec } diff --git a/test/Cpp/src/Determinism.lf b/test/Cpp/src/Determinism.lf index 916c54c8c0..063a25519d 100644 --- a/test/Cpp/src/Determinism.lf +++ b/test/Cpp/src/Determinism.lf @@ -1,46 +1,46 @@ target Cpp reactor Source { - output y: int - timer t + output y: int + timer t - reaction(t) -> y {= y.set(1); =} + reaction(t) -> y {= y.set(1); =} } reactor Destination { - input x: int - input y: int + input x: int + input y: int - reaction(x, y) {= - int sum = 0; - if (x.is_present()) { - sum += *x.get(); - } - if (y.is_present()) { - sum += *y.get(); - } - std::cout << "Received " << sum << std::endl; - if (sum != 2) { - std::cerr << "FAILURE: Expected 2." << std::endl; - exit(4); - } - =} + reaction(x, y) {= + int sum = 0; + if (x.is_present()) { + sum += *x.get(); + } + if (y.is_present()) { + sum += *y.get(); + } + std::cout << "Received " << sum << std::endl; + if (sum != 2) { + std::cerr << "FAILURE: Expected 2." << std::endl; + exit(4); + } + =} } reactor Pass { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= y.set(x.get()); =} + reaction(x) -> y {= y.set(x.get()); =} } main reactor Determinism { - s = new Source() - d = new Destination() - p1 = new Pass() - p2 = new Pass() - s.y -> d.y - s.y -> p1.x - p1.y -> p2.x - p2.y -> d.x + s = new Source() + d = new Destination() + p1 = new Pass() + p2 = new Pass() + s.y -> d.y + s.y -> p1.x + p1.y -> p2.x + p2.y -> d.x } diff --git a/test/Cpp/src/DoubleInvocation.lf b/test/Cpp/src/DoubleInvocation.lf index 236b0f425d..956b54bb17 100644 --- a/test/Cpp/src/DoubleInvocation.lf +++ b/test/Cpp/src/DoubleInvocation.lf @@ -1,9 +1,11 @@ -// This illustrates a very strange bug that showed up and has now been fixed. This test ensures it -// does not reappear. At logical time zero, the two Print reactors used to be fired twice each at -// the same logical time. They should only be fired once. This behavior was oddly eliminated by -// either of the following actions, neither of which should affect this behavior: +// This illustrates a very strange bug that showed up and has now been fixed. +// This test ensures it does not reappear. At logical time zero, the two Print +// reactors used to be fired twice each at the same logical time. They should +// only be fired once. This behavior was oddly eliminated by either of the +// following actions, neither of which should affect this behavior: // * Removing the startup reaction in Print. -// * Sending only position, not velocity from Ball. (copied from the c version of the test) +// * Sending only position, not velocity from Ball. (copied from the c version +// of the test) target Cpp { timeout: 5 sec, fast: true diff --git a/test/Cpp/src/DoublePort.lf b/test/Cpp/src/DoublePort.lf index b28f70db4d..faaa474db5 100644 --- a/test/Cpp/src/DoublePort.lf +++ b/test/Cpp/src/DoublePort.lf @@ -1,6 +1,7 @@ /** - * Test the case where two upstream reactors pass messages to a downstream reactor on two different - * ports. One message carries a microstep delay relative to the other. + * Test the case where two upstream reactors pass messages to a downstream + * reactor on two different ports. One message carries a microstep delay + * relative to the other. * * @author Maiko Brants */ diff --git a/test/Cpp/src/DoubleReaction.lf b/test/Cpp/src/DoubleReaction.lf index 3642fa027a..1128d63f97 100644 --- a/test/Cpp/src/DoubleReaction.lf +++ b/test/Cpp/src/DoubleReaction.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output -// for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only +// once. Correct output for this 2, 4, 6, 8, etc. target Cpp { timeout: 10 sec, fast: true diff --git a/test/Cpp/src/DoubleTrigger.lf b/test/Cpp/src/DoubleTrigger.lf index b39f0a559e..5db4818048 100644 --- a/test/Cpp/src/DoubleTrigger.lf +++ b/test/Cpp/src/DoubleTrigger.lf @@ -1,4 +1,5 @@ -// Test that two simultaneous triggers don't cause a reaction to execute twice at the same tag. +// Test that two simultaneous triggers don't cause a reaction to execute twice +// at the same tag. target Cpp main reactor DoubleTrigger { diff --git a/test/Cpp/src/GetTime.lf b/test/Cpp/src/GetTime.lf index e9ba6922d5..a61b299d45 100644 --- a/test/Cpp/src/GetTime.lf +++ b/test/Cpp/src/GetTime.lf @@ -1,25 +1,25 @@ // This file includes code documented on the Wiki. For this test, success is just compiling and // running. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } main reactor GetTime { - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) {= - auto logical = get_logical_time(); - std::cout << "Logical time is " << logical << std::endl; + reaction(t) {= + auto logical = get_logical_time(); + std::cout << "Logical time is " << logical << std::endl; - auto elapsed = get_elapsed_logical_time(); - auto elapsed_secs = std::chrono::duration_cast(elapsed); - std::cout << "Elapsed logical time is " << elapsed_secs << std::endl; + auto elapsed = get_elapsed_logical_time(); + auto elapsed_secs = std::chrono::duration_cast(elapsed); + std::cout << "Elapsed logical time is " << elapsed_secs << std::endl; - auto physical = get_physical_time(); - std::cout << "Physical time is " << physical << std::endl; + auto physical = get_physical_time(); + std::cout << "Physical time is " << physical << std::endl; - auto diff = physical - logical; - std::cout << "Time lag is " << diff << std::endl; - =} + auto diff = physical - logical; + std::cout << "Time lag is " << diff << std::endl; + =} } diff --git a/test/Cpp/src/HelloWorld.lf b/test/Cpp/src/HelloWorld.lf index 8d32d55553..071cc5c968 100644 --- a/test/Cpp/src/HelloWorld.lf +++ b/test/Cpp/src/HelloWorld.lf @@ -1,11 +1,11 @@ target Cpp reactor HelloWorld2 { - timer t + timer t - reaction(t) {= std::cout << "Hello World." << std::endl; =} + reaction(t) {= std::cout << "Hello World." << std::endl; =} } main reactor { - a = new HelloWorld2() + a = new HelloWorld2() } diff --git a/test/Cpp/src/Hierarchy.lf b/test/Cpp/src/Hierarchy.lf index 7767b98311..d207a20c31 100644 --- a/test/Cpp/src/Hierarchy.lf +++ b/test/Cpp/src/Hierarchy.lf @@ -2,48 +2,48 @@ target Cpp reactor Source { - output out: int - timer t + output out: int + timer t - reaction(t) -> out {= out.set(1); =} + reaction(t) -> out {= out.set(1); =} } reactor Gain { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= out.set((*in.get()) * 2); =} + reaction(in) -> out {= out.set((*in.get()) * 2); =} } reactor Print { - input in: int - - reaction(in) {= - auto value = *in.get(); - std::cout << "Received: " << value << std::endl; - if (value != 2) { - std::cerr << "Expected 2." << std::endl; - exit(1); - } - =} + input in: int + + reaction(in) {= + auto value = *in.get(); + std::cout << "Received: " << value << std::endl; + if (value != 2) { + std::cerr << "Expected 2." << std::endl; + exit(1); + } + =} } reactor GainContainer { - input in: int - output out: int - output out2: int - gain = new Gain() - in -> gain.in - gain.out -> out - gain.out -> out2 + input in: int + output out: int + output out2: int + gain = new Gain() + in -> gain.in + gain.out -> out + gain.out -> out2 } main reactor Hierarchy { - source = new Source() - container = new GainContainer() - print = new Print() - print2 = new Print() - source.out -> container.in - container.out -> print.in - container.out -> print2.in + source = new Source() + container = new GainContainer() + print = new Print() + print2 = new Print() + source.out -> container.in + container.out -> print.in + container.out -> print2.in } diff --git a/test/Cpp/src/Import.lf b/test/Cpp/src/Import.lf index 020877a883..c77f8382c5 100644 --- a/test/Cpp/src/Import.lf +++ b/test/Cpp/src/Import.lf @@ -4,8 +4,8 @@ target Cpp import Imported from "lib/Imported.lf" main reactor Import { - timer t - a = new Imported() + timer t + a = new Imported() - reaction(t) -> a.x {= a.x.set(42); =} + reaction(t) -> a.x {= a.x.set(42); =} } diff --git a/test/Cpp/src/ImportComposition.lf b/test/Cpp/src/ImportComposition.lf index 492b77d96d..0559edacd1 100644 --- a/test/Cpp/src/ImportComposition.lf +++ b/test/Cpp/src/ImportComposition.lf @@ -1,7 +1,8 @@ /** * @author Maiko Brants TU Dresden * - * This tests the ability to import a reactor definition that itself imports a reactor definition. + * This tests the ability to import a reactor definition that itself imports a + * reactor definition. * * modeled after the C version of this test */ diff --git a/test/Cpp/src/ImportRenamed.lf b/test/Cpp/src/ImportRenamed.lf index ea21c06964..4ec5dc132e 100644 --- a/test/Cpp/src/ImportRenamed.lf +++ b/test/Cpp/src/ImportRenamed.lf @@ -12,10 +12,10 @@ import Imported as Y from "lib/Imported.lf" import ImportedAgain as Z from "lib/ImportedAgain.lf" main reactor { - timer t - a = new X() - b = new Y() - c = new Z() + timer t + a = new X() + b = new Y() + c = new Z() - reaction(t) -> a.x {= a.x.set(42); =} + reaction(t) -> a.x {= a.x.set(42); =} } diff --git a/test/Cpp/src/ManualDelayedReaction.lf b/test/Cpp/src/ManualDelayedReaction.lf index e17d4eac13..3c55bdcaf1 100644 --- a/test/Cpp/src/ManualDelayedReaction.lf +++ b/test/Cpp/src/ManualDelayedReaction.lf @@ -1,6 +1,7 @@ target Cpp -reactor GeneratedDelay { // That's the stuff that shall be generated for the after +// That's the stuff that shall be generated for the after +reactor GeneratedDelay { input y_in: int output y_out: int state y_state: int = 0 @@ -16,7 +17,8 @@ reactor Source { output out: int timer t - reaction(t) -> out {= out.set(1); =} // reaction(t) -> out after 100 msec {= + // reaction(t) -> out after 100 msec {= + reaction(t) -> out {= out.set(1); =} } reactor Sink { diff --git a/test/Cpp/src/Microsteps.lf b/test/Cpp/src/Microsteps.lf index f4fb8c10e4..fedf9c145f 100644 --- a/test/Cpp/src/Microsteps.lf +++ b/test/Cpp/src/Microsteps.lf @@ -1,43 +1,43 @@ target Cpp reactor Destination { - input x: int - input y: int + input x: int + input y: int - reaction(x, y) {= - auto elapsed = get_elapsed_logical_time(); - std::cout << "Time since start: " << elapsed << std::endl; - if (elapsed != reactor::Duration::zero()) { - std::cerr << "Expected elapsed time to be 0, but it was " << - elapsed << std::endl; - exit(1); - } - int count{0}; - if (x.is_present()) { - std::cout << " x is present." << std::endl; - count++; - } - if (y.is_present()) { - std::cout << " y is present." << std::endl; - count++; - } - if (count != 1) { - std::cerr << "Expected exactly one input to be present but got " - << count << std::endl; - exit(1); - } - =} + reaction(x, y) {= + auto elapsed = get_elapsed_logical_time(); + std::cout << "Time since start: " << elapsed << std::endl; + if (elapsed != reactor::Duration::zero()) { + std::cerr << "Expected elapsed time to be 0, but it was " << + elapsed << std::endl; + exit(1); + } + int count{0}; + if (x.is_present()) { + std::cout << " x is present." << std::endl; + count++; + } + if (y.is_present()) { + std::cout << " y is present." << std::endl; + count++; + } + if (count != 1) { + std::cerr << "Expected exactly one input to be present but got " + << count << std::endl; + exit(1); + } + =} } main reactor Microsteps { - timer start - logical action repeat: void - d = new Destination() + timer start + logical action repeat: void + d = new Destination() - reaction(start) -> d.x, repeat {= - d.x.set(1); - repeat.schedule(); - =} + reaction(start) -> d.x, repeat {= + d.x.set(1); + repeat.schedule(); + =} - reaction(repeat) -> d.y {= d.y.set(1); =} + reaction(repeat) -> d.y {= d.y.set(1); =} } diff --git a/test/Cpp/src/Minimal.lf b/test/Cpp/src/Minimal.lf index 77238dbd30..d49bea2620 100644 --- a/test/Cpp/src/Minimal.lf +++ b/test/Cpp/src/Minimal.lf @@ -2,5 +2,5 @@ target Cpp main reactor Minimal { - reaction(startup) {= std::cout << "Hello World!\n"; =} + reaction(startup) {= std::cout << "Hello World!\n"; =} } diff --git a/test/Cpp/src/MovingAverage.lf b/test/Cpp/src/MovingAverage.lf index 2ccaa87406..af202ca0a0 100644 --- a/test/Cpp/src/MovingAverage.lf +++ b/test/Cpp/src/MovingAverage.lf @@ -1,6 +1,6 @@ -// Demonstration of a state variable that is a fixed size list. The MovingAverage reactor computes -// the moving average of the last four inputs and produces that as output. The source is a counting -// sequence. +// Demonstration of a state variable that is a fixed size list. The +// MovingAverage reactor computes the moving average of the last four inputs and +// produces that as output. The source is a counting sequence. target Cpp { timeout: 1 sec, fast: true diff --git a/test/Cpp/src/MultipleContained.lf b/test/Cpp/src/MultipleContained.lf index 8831bb3d6d..bfe71c9b02 100644 --- a/test/Cpp/src/MultipleContained.lf +++ b/test/Cpp/src/MultipleContained.lf @@ -2,34 +2,34 @@ target Cpp reactor Contained { - output trigger: int - input in1: int - input in2: int + output trigger: int + input in1: int + input in2: int - reaction(startup) -> trigger {= trigger.set(42); =} + reaction(startup) -> trigger {= trigger.set(42); =} - reaction(in1) {= - std::cout << "in1 received " << *in1.get() << '\n'; - if (*in1.get() != 42) { - std::cerr << "FAILED: Expected 42.\n"; - exit(1); - } - =} + reaction(in1) {= + std::cout << "in1 received " << *in1.get() << '\n'; + if (*in1.get() != 42) { + std::cerr << "FAILED: Expected 42.\n"; + exit(1); + } + =} - reaction(in2) {= - std::cout << "in2 received " << *in2.get() << '\n'; - if (*in2.get() != 42) { - std::cerr << "FAILED: Expected 42.\n"; - exit(1); - } - =} + reaction(in2) {= + std::cout << "in2 received " << *in2.get() << '\n'; + if (*in2.get() != 42) { + std::cerr << "FAILED: Expected 42.\n"; + exit(1); + } + =} } main reactor MultipleContained { - c = new Contained() + c = new Contained() - reaction(c.trigger) -> c.in1, c.in2 {= - c.in1.set(c.trigger.get()); - c.in2.set(c.trigger.get()); - =} + reaction(c.trigger) -> c.in1, c.in2 {= + c.in1.set(c.trigger.get()); + c.in2.set(c.trigger.get()); + =} } diff --git a/test/Cpp/src/PreambleTest.lf b/test/Cpp/src/PreambleTest.lf index 66b479397d..60a0128b29 100644 --- a/test/Cpp/src/PreambleTest.lf +++ b/test/Cpp/src/PreambleTest.lf @@ -1,29 +1,29 @@ target Cpp main reactor { - // This declaration is required on the public reactor interface and therefore needs to be placed - // in the generated header. This goes to Preamble/Preamble.hh. - public preamble {= - struct MyStruct { - int foo; - std::string bar; - }; - =} - // this is only used inside reactions and therefore goes to the generated source file This - // function is only used inside a reaction and therefore is part of the private interface. - // Moreover, we need to make sure that the function is only defined once within a source file. - // This goes to Preamble/Preamble.cc - private preamble {= - int add_42(int i) { - return i + 42; - } - =} - logical action a: MyStruct + // This declaration is required on the public reactor interface and therefore needs to be placed + // in the generated header. This goes to Preamble/Preamble.hh. + public preamble {= + struct MyStruct { + int foo; + std::string bar; + }; + =} + // this is only used inside reactions and therefore goes to the generated source file This + // function is only used inside a reaction and therefore is part of the private interface. + // Moreover, we need to make sure that the function is only defined once within a source file. + // This goes to Preamble/Preamble.cc + private preamble {= + int add_42(int i) { + return i + 42; + } + =} + logical action a: MyStruct - reaction(startup) -> a {= a.schedule({add_42(42), "baz"}); =} + reaction(startup) -> a {= a.schedule({add_42(42), "baz"}); =} - reaction(a) {= - auto& value = *a.get(); - std::cout << "Received " << value.foo << " and '" << value.bar << "'\n"; - =} + reaction(a) {= + auto& value = *a.get(); + std::cout << "Received " << value.foo << " and '" << value.bar << "'\n"; + =} } diff --git a/test/Cpp/src/ReadOutputOfContainedReactor.lf b/test/Cpp/src/ReadOutputOfContainedReactor.lf index 7d16b24cb7..c7e85083b4 100644 --- a/test/Cpp/src/ReadOutputOfContainedReactor.lf +++ b/test/Cpp/src/ReadOutputOfContainedReactor.lf @@ -1,4 +1,5 @@ -// Test reacting to and reading outputs from a contained reactor in various permutations. +// Test reacting to and reading outputs from a contained reactor in various +// permutations. target Cpp reactor Contained { diff --git a/test/Cpp/src/Schedule.lf b/test/Cpp/src/Schedule.lf index 754368c072..67de9fb876 100644 --- a/test/Cpp/src/Schedule.lf +++ b/test/Cpp/src/Schedule.lf @@ -2,26 +2,26 @@ target Cpp reactor ScheduleTest { - input x: int - logical action a: void + input x: int + logical action a: void - reaction(x) -> a {= a.schedule(200ms); =} + reaction(x) -> a {= a.schedule(200ms); =} - reaction(a) {= - auto elapsed_time = get_elapsed_logical_time(); - std::cout << "Action triggered at logical time " << elapsed_time.count() - << " after start" << std::endl; - if (elapsed_time != 200ms) { - std::cerr << "Expected action time to be 200 msec. It was " - << elapsed_time.count() << "nsec!" << std::endl; - exit(1); - } - =} + reaction(a) {= + auto elapsed_time = get_elapsed_logical_time(); + std::cout << "Action triggered at logical time " << elapsed_time.count() + << " after start" << std::endl; + if (elapsed_time != 200ms) { + std::cerr << "Expected action time to be 200 msec. It was " + << elapsed_time.count() << "nsec!" << std::endl; + exit(1); + } + =} } main reactor Schedule { - a = new ScheduleTest() - timer t + a = new ScheduleTest() + timer t - reaction(t) -> a.x {= a.x.set(1); =} + reaction(t) -> a.x {= a.x.set(1); =} } diff --git a/test/Cpp/src/ScheduleLogicalAction.lf b/test/Cpp/src/ScheduleLogicalAction.lf index 2e2f9f99f5..96fd5382b7 100644 --- a/test/Cpp/src/ScheduleLogicalAction.lf +++ b/test/Cpp/src/ScheduleLogicalAction.lf @@ -1,8 +1,8 @@ /** * @author Maiko Brants TU Dresden * - * This checks that a logical action is scheduled the specified logical time after the current - * logical time. + * This checks that a logical action is scheduled the specified logical time + * after the current logical time. * * Modeled after the C version of this test. */ diff --git a/test/Cpp/src/SendingInside.lf b/test/Cpp/src/SendingInside.lf index 4b04d48bc7..2f73122bc8 100644 --- a/test/Cpp/src/SendingInside.lf +++ b/test/Cpp/src/SendingInside.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own reaction that routes -// inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own +// reaction that routes inputs to the contained reactor. target Cpp { timeout: 10 sec, fast: true diff --git a/test/Cpp/src/SendingInside2.lf b/test/Cpp/src/SendingInside2.lf index 1656c77f9d..29b6da59aa 100644 --- a/test/Cpp/src/SendingInside2.lf +++ b/test/Cpp/src/SendingInside2.lf @@ -1,20 +1,20 @@ target Cpp reactor Printer { - input x: int + input x: int - reaction(x) {= - std::cout << "Inside reactor received: " << *x.get() << std::endl; - if (*x.get() != 1) { - std::cerr << "ERROR: Expected 1." << std::endl; - exit(1); - } - =} + reaction(x) {= + std::cout << "Inside reactor received: " << *x.get() << std::endl; + if (*x.get() != 1) { + std::cerr << "ERROR: Expected 1." << std::endl; + exit(1); + } + =} } main reactor SendingInside2 { - timer t - p = new Printer() + timer t + p = new Printer() - reaction(t) -> p.x {= p.x.set(1); =} + reaction(t) -> p.x {= p.x.set(1); =} } diff --git a/test/Cpp/src/SimpleDeadline.lf b/test/Cpp/src/SimpleDeadline.lf index c14ba2adea..be10b55d43 100644 --- a/test/Cpp/src/SimpleDeadline.lf +++ b/test/Cpp/src/SimpleDeadline.lf @@ -1,5 +1,6 @@ -// Test local deadline, where a deadline is associated with a reaction definition. This test -// triggers a reaction exactly once with a deadline violation. +// Test local deadline, where a deadline is associated with a reaction +// definition. This test triggers a reaction exactly once with a deadline +// violation. target Cpp reactor Deadline(threshold: time = 100 msec) { diff --git a/test/Cpp/src/SimpleImport.lf b/test/Cpp/src/SimpleImport.lf index 0054bf1040..eadef75f9c 100644 --- a/test/Cpp/src/SimpleImport.lf +++ b/test/Cpp/src/SimpleImport.lf @@ -3,6 +3,6 @@ target Cpp import HelloWorld2 from "HelloWorld.lf" main reactor SimpleImport { - a = new HelloWorld2() - b = new HelloWorld2() + a = new HelloWorld2() + b = new HelloWorld2() } diff --git a/test/Cpp/src/SlowingClock.lf b/test/Cpp/src/SlowingClock.lf index 13228f17a1..adbe93e418 100644 --- a/test/Cpp/src/SlowingClock.lf +++ b/test/Cpp/src/SlowingClock.lf @@ -1,9 +1,10 @@ /** * @author Maiko Brants TU Dresden * - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a logical - * action with a minimum delay of 100 msec. The use of the logical action ensures the elapsed time - * jumps exactly from 0 to 100, 300, 600, and 1000 msec. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 + * msec on a logical action with a minimum delay of 100 msec. The use of the + * logical action ensures the elapsed time jumps exactly from 0 to 100, 300, + * 600, and 1000 msec. * * Modeled after the C version of this test. */ diff --git a/test/Cpp/src/SlowingClockPhysical.lf b/test/Cpp/src/SlowingClockPhysical.lf index 7486a00a91..919f9d6cdf 100644 --- a/test/Cpp/src/SlowingClockPhysical.lf +++ b/test/Cpp/src/SlowingClockPhysical.lf @@ -1,10 +1,11 @@ /** * @author Maiko Brants TU Dresden * - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a physical - * action with a minimum delay of 100 msec. The use of the physical action makes the elapsed time - * jumps from 0 to approximately 100 msec, to approximatly 300 msec thereafter, drifting away - * further with each new event. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 + * msec on a physical action with a minimum delay of 100 msec. The use of the + * physical action makes the elapsed time jumps from 0 to approximately 100 + * msec, to approximatly 300 msec thereafter, drifting away further with each + * new event. * * Modeled after the C version of this test. */ diff --git a/test/Cpp/src/StartupOutFromInside.lf b/test/Cpp/src/StartupOutFromInside.lf index 1832d01d92..b8b43b78b9 100644 --- a/test/Cpp/src/StartupOutFromInside.lf +++ b/test/Cpp/src/StartupOutFromInside.lf @@ -6,19 +6,19 @@ target Cpp reactor Bar { - output out: int + output out: int - reaction(startup) -> out {= out.set(42); =} + reaction(startup) -> out {= out.set(42); =} } main reactor StartupOutFromInside { - bar = new Bar() + bar = new Bar() - reaction(startup) bar.out {= - reactor::log::Info() << "Output from bar: " << *bar.out.get(); - if(*bar.out.get() != 42) { - reactor::log::Error() << "Expected 42!"; - exit(1); - } - =} + reaction(startup) bar.out {= + reactor::log::Info() << "Output from bar: " << *bar.out.get(); + if(*bar.out.get() != 42) { + reactor::log::Error() << "Expected 42!"; + exit(1); + } + =} } diff --git a/test/Cpp/src/Stride.lf b/test/Cpp/src/Stride.lf index 7aabd9b399..5f469e4c70 100644 --- a/test/Cpp/src/Stride.lf +++ b/test/Cpp/src/Stride.lf @@ -1,5 +1,5 @@ -// This example illustrates state variables and parameters on the wiki. For this test, success is -// just compiling and running. +// This example illustrates state variables and parameters on the wiki. For this +// test, success is just compiling and running. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/StructAsState.lf b/test/Cpp/src/StructAsState.lf index fd48d50d25..f8171a2ec6 100644 --- a/test/Cpp/src/StructAsState.lf +++ b/test/Cpp/src/StructAsState.lf @@ -2,17 +2,17 @@ target Cpp public preamble {= - #include "include/hello.h" + #include "include/hello.h" =} main reactor StructAsState { - state s: Hello{"Earth", 42} + state s: Hello{"Earth", 42} - reaction(startup) {= - std::cout << "State s.name=" << s.name << ", s.value=" << s.value << '\n'; - if (s.value != 42 && s.name != "Earth") { - std::cerr << "ERROR: Expected 42 and Earth!\n"; - exit(1); - } - =} + reaction(startup) {= + std::cout << "State s.name=" << s.name << ", s.value=" << s.value << '\n'; + if (s.value != 42 && s.name != "Earth") { + std::cerr << "ERROR: Expected 42 and Earth!\n"; + exit(1); + } + =} } diff --git a/test/Cpp/src/StructAsType.lf b/test/Cpp/src/StructAsType.lf index 9d853b98b2..fee53b7062 100644 --- a/test/Cpp/src/StructAsType.lf +++ b/test/Cpp/src/StructAsType.lf @@ -4,21 +4,21 @@ target Cpp import Print from "StructPrint.lf" public preamble {= - #include "include/hello.h" + #include "include/hello.h" =} reactor StaticSource { - output out: Hello + output out: Hello - reaction(startup) -> out {= - Hello hello{"Earth", 42}; - // this implicitly sends a dynamically allocated copy of the hello object - out.set(hello); - =} + reaction(startup) -> out {= + Hello hello{"Earth", 42}; + // this implicitly sends a dynamically allocated copy of the hello object + out.set(hello); + =} } main reactor StructAsType { - s = new StaticSource() - p = new Print() - s.out -> p.in + s = new StaticSource() + p = new Print() + s.out -> p.in } diff --git a/test/Cpp/src/StructAsTypeDirect.lf b/test/Cpp/src/StructAsTypeDirect.lf index e31b1190b4..00aae7c565 100644 --- a/test/Cpp/src/StructAsTypeDirect.lf +++ b/test/Cpp/src/StructAsTypeDirect.lf @@ -4,20 +4,20 @@ target Cpp import Print from "StructPrint.lf" public preamble {= - #include "include/hello.h" + #include "include/hello.h" =} reactor DirectSource { - output out: Hello + output out: Hello - reaction(startup) -> out {= - // this implicitly creates a new hello object which is then send - out.set({"Earth", 42}); - =} + reaction(startup) -> out {= + // this implicitly creates a new hello object which is then send + out.set({"Earth", 42}); + =} } main reactor { - s = new DirectSource() - p = new Print() - s.out -> p.in + s = new DirectSource() + p = new Print() + s.out -> p.in } diff --git a/test/Cpp/src/StructParallel.lf b/test/Cpp/src/StructParallel.lf index ab50ab0e93..375fa41bb2 100644 --- a/test/Cpp/src/StructParallel.lf +++ b/test/Cpp/src/StructParallel.lf @@ -7,17 +7,17 @@ import Scale from "StructScale.lf" import Source, Print from "StructPrint.lf" public preamble {= - #include "include/hello.h" + #include "include/hello.h" =} main reactor { - s = new Source() - c1 = new Scale() - c2 = new Scale(scale = 3) - p1 = new Print(expected_value = 84) - p2 = new Print(expected_value = 126) - s.out -> c1.in - s.out -> c2.in - c1.out -> p1.in - c2.out -> p2.in + s = new Source() + c1 = new Scale() + c2 = new Scale(scale = 3) + p1 = new Print(expected_value = 84) + p2 = new Print(expected_value = 126) + s.out -> c1.in + s.out -> c2.in + c1.out -> p1.in + c2.out -> p2.in } diff --git a/test/Cpp/src/StructScale.lf b/test/Cpp/src/StructScale.lf index ed472eced6..776dad14b1 100644 --- a/test/Cpp/src/StructScale.lf +++ b/test/Cpp/src/StructScale.lf @@ -1,5 +1,6 @@ -// Source produces a dynamically allocated struct, which it passes to Scale. Scale requests a -// writable copy. It modifies it and passes it to Print. It gets freed after Print is done with it. +// Source produces a dynamically allocated struct, which it passes to Scale. +// Scale requests a writable copy. It modifies it and passes it to Print. It +// gets freed after Print is done with it. target Cpp import Source, Print from "StructPrint.lf" diff --git a/test/Cpp/src/TestForPreviousOutput.lf b/test/Cpp/src/TestForPreviousOutput.lf index 3a5b9bd697..e181c4d791 100644 --- a/test/Cpp/src/TestForPreviousOutput.lf +++ b/test/Cpp/src/TestForPreviousOutput.lf @@ -3,41 +3,41 @@ target Cpp reactor Source { - output out: int + output out: int - reaction(startup) -> out {= - // Set a seed for random number generation based on the current time. - std::srand(std::time(nullptr)); - // Randomly produce an output or not. - if (std::rand() % 2) { - out.set(21); - } - =} + reaction(startup) -> out {= + // Set a seed for random number generation based on the current time. + std::srand(std::time(nullptr)); + // Randomly produce an output or not. + if (std::rand() % 2) { + out.set(21); + } + =} - reaction(startup) -> out {= - if (out.is_present()) { - int previous_output = *out.get(); - out.set(2 * previous_output); - } else { - out.set(42); - } - =} + reaction(startup) -> out {= + if (out.is_present()) { + int previous_output = *out.get(); + out.set(2 * previous_output); + } else { + out.set(42); + } + =} } reactor Sink { - input in: int + input in: int - reaction(in) {= - std::cout << "Received: " << *in.get() << '\n'; - if (*in.get() != 42) { - std::cerr << "FAILED: Expected 42.\n"; - exit(1); - } - =} + reaction(in) {= + std::cout << "Received: " << *in.get() << '\n'; + if (*in.get() != 42) { + std::cerr << "FAILED: Expected 42.\n"; + exit(1); + } + =} } main reactor TestForPreviousOutput { - s = new Source() - d = new Sink() - s.out -> d.in + s = new Source() + d = new Sink() + s.out -> d.in } diff --git a/test/Cpp/src/TimeLimit.lf b/test/Cpp/src/TimeLimit.lf index 8383d4bf26..8b33dcd967 100644 --- a/test/Cpp/src/TimeLimit.lf +++ b/test/Cpp/src/TimeLimit.lf @@ -1,5 +1,6 @@ -// Test that the stop function can be used to internally to impose a a time limit. Correct output -// for this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. +// Test that the stop function can be used to internally to impose a a time +// limit. Correct output for this 1, 2, 3, 4. Failure for this test is failing +// to halt or getting the wrong data. target Cpp { fast: true } diff --git a/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf b/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf index 1a360411ae..b8c304b164 100644 --- a/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,5 +1,6 @@ /** - * This test checks that a downstream reaction is triggered only if its trigger is present. + * This test checks that a downstream reaction is triggered only if its trigger + * is present. * * @author Maiko Brants TU Dresden * diff --git a/test/Cpp/src/concurrent/CompositionThreaded.lf b/test/Cpp/src/concurrent/CompositionThreaded.lf index 07738e3e45..42817e8b1d 100644 --- a/test/Cpp/src/concurrent/CompositionThreaded.lf +++ b/test/Cpp/src/concurrent/CompositionThreaded.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target Cpp { fast: true, timeout: 10 sec diff --git a/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf index fe39ebcb98..bb380fe14c 100644 --- a/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the container reacts to that -// output. +// Test a deadline where the deadline violation produces an output and the +// container reacts to that output. target Cpp reactor Deadline(threshold: time = 100 msec) { diff --git a/test/Cpp/src/concurrent/DeadlineThreaded.lf b/test/Cpp/src/concurrent/DeadlineThreaded.lf index 131167fa77..cb794f5050 100644 --- a/test/Cpp/src/concurrent/DeadlineThreaded.lf +++ b/test/Cpp/src/concurrent/DeadlineThreaded.lf @@ -1,5 +1,6 @@ -// This example illustrates local deadline handling. Even numbers are sent by the Source -// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by +// the Source immediately, whereas odd numbers are sent after a big enough delay +// to violate the deadline. target Cpp { timeout: 4 sec } diff --git a/test/Cpp/src/concurrent/DeterminismThreaded.lf b/test/Cpp/src/concurrent/DeterminismThreaded.lf index 48a224db11..b97d9fd1fe 100644 --- a/test/Cpp/src/concurrent/DeterminismThreaded.lf +++ b/test/Cpp/src/concurrent/DeterminismThreaded.lf @@ -1,46 +1,46 @@ target Cpp reactor Source { - output y: int - timer t + output y: int + timer t - reaction(t) -> y {= y.set(1); =} + reaction(t) -> y {= y.set(1); =} } reactor Destination { - input x: int - input y: int + input x: int + input y: int - reaction(x, y) {= - int sum = 0; - if (x.is_present()) { - sum += *x.get(); - } - if (y.is_present()) { - sum += *y.get(); - } - std::cout << "Received " << sum << std::endl; - if (sum != 2) { - std::cerr << "FAILURE: Expected 2." << std::endl; - exit(4); - } - =} + reaction(x, y) {= + int sum = 0; + if (x.is_present()) { + sum += *x.get(); + } + if (y.is_present()) { + sum += *y.get(); + } + std::cout << "Received " << sum << std::endl; + if (sum != 2) { + std::cerr << "FAILURE: Expected 2." << std::endl; + exit(4); + } + =} } reactor Pass { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= y.set(x.get()); =} + reaction(x) -> y {= y.set(x.get()); =} } main reactor { - s = new Source() - d = new Destination() - p1 = new Pass() - p2 = new Pass() - s.y -> d.y - s.y -> p1.x - p1.y -> p2.x - p2.y -> d.x + s = new Source() + d = new Destination() + p1 = new Pass() + p2 = new Pass() + s.y -> d.y + s.y -> p1.x + p1.y -> p2.x + p2.y -> d.x } diff --git a/test/Cpp/src/concurrent/DoubleReactionThreaded.lf b/test/Cpp/src/concurrent/DoubleReactionThreaded.lf index c8b1fa06a3..d68f2e8b60 100644 --- a/test/Cpp/src/concurrent/DoubleReactionThreaded.lf +++ b/test/Cpp/src/concurrent/DoubleReactionThreaded.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output -// for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only +// once. Correct output for this 2, 4, 6, 8, etc. target Cpp { timeout: 10 sec, fast: true diff --git a/test/Cpp/src/concurrent/ImportThreaded.lf b/test/Cpp/src/concurrent/ImportThreaded.lf index d032b196fe..791291fc10 100644 --- a/test/Cpp/src/concurrent/ImportThreaded.lf +++ b/test/Cpp/src/concurrent/ImportThreaded.lf @@ -4,8 +4,8 @@ target Cpp import Imported from "../lib/Imported.lf" main reactor { - timer t - a = new Imported() + timer t + a = new Imported() - reaction(t) -> a.x {= a.x.set(42); =} + reaction(t) -> a.x {= a.x.set(42); =} } diff --git a/test/Cpp/src/concurrent/MinimalThreaded.lf b/test/Cpp/src/concurrent/MinimalThreaded.lf index f13148781d..a0184d5261 100644 --- a/test/Cpp/src/concurrent/MinimalThreaded.lf +++ b/test/Cpp/src/concurrent/MinimalThreaded.lf @@ -2,5 +2,5 @@ target Cpp main reactor { - reaction(startup) {= std::cout << "Hello World!\n"; =} + reaction(startup) {= std::cout << "Hello World!\n"; =} } diff --git a/test/Cpp/src/concurrent/SendingInsideThreaded.lf b/test/Cpp/src/concurrent/SendingInsideThreaded.lf index acd34f147f..51ca511e26 100644 --- a/test/Cpp/src/concurrent/SendingInsideThreaded.lf +++ b/test/Cpp/src/concurrent/SendingInsideThreaded.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own reaction that routes -// inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own +// reaction that routes inputs to the contained reactor. target Cpp { timeout: 10 sec, fast: true diff --git a/test/Cpp/src/concurrent/Threaded.lf b/test/Cpp/src/concurrent/Threaded.lf index f0a72fc2ed..9ad4fcbe56 100644 --- a/test/Cpp/src/concurrent/Threaded.lf +++ b/test/Cpp/src/concurrent/Threaded.lf @@ -1,9 +1,11 @@ -// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime -// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that -// without parallel execution, there is no way this can keep up with real time since in every 200 -// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing -// that without threads, this takes more than 800 msec to complete 200 msec of logical time. +// Check for speedup of multithreaded execution on multicore machines. Each +// instance of TakeTime takes 200 ms to transport the input to the output. Four +// of them are instantiated. Note that without parallel execution, there is no +// way this can keep up with real time since in every 200 msec cycle it has 800 +// msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded +// version, showing that without threads, this takes more than 800 msec to +// complete 200 msec of logical time. target Cpp { timeout: 2 sec } diff --git a/test/Cpp/src/concurrent/ThreadedThreaded.lf b/test/Cpp/src/concurrent/ThreadedThreaded.lf index e8d50e7a33..f8b21a6121 100644 --- a/test/Cpp/src/concurrent/ThreadedThreaded.lf +++ b/test/Cpp/src/concurrent/ThreadedThreaded.lf @@ -1,9 +1,11 @@ -// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime -// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that -// without parallel execution, there is no way this can keep up with real time since in every 200 -// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing -// that without threads, this takes more than 800 msec to complete 200 msec of logical time. +// Check for speedup of multithreaded execution on multicore machines. Each +// instance of TakeTime takes 200 ms to transport the input to the output. Four +// of them are instantiated. Note that without parallel execution, there is no +// way this can keep up with real time since in every 200 msec cycle it has 800 +// msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded +// version, showing that without threads, this takes more than 800 msec to +// complete 200 msec of logical time. target Cpp { timeout: 2 sec } diff --git a/test/Cpp/src/concurrent/TimeLimitThreaded.lf b/test/Cpp/src/concurrent/TimeLimitThreaded.lf index bd9959b9a0..47371f72d7 100644 --- a/test/Cpp/src/concurrent/TimeLimitThreaded.lf +++ b/test/Cpp/src/concurrent/TimeLimitThreaded.lf @@ -1,6 +1,7 @@ -// Test that the stop function can be used to internally to impose a a time limit. This is also used -// to test performance (number of reactions per second). Correct output for this 1, 2, 3, 4. Failure -// for this test is failing to halt or getting the wrong data. +// Test that the stop function can be used to internally to impose a a time +// limit. This is also used to test performance (number of reactions per +// second). Correct output for this 1, 2, 3, 4. Failure for this test is failing +// to halt or getting the wrong data. target Cpp { fast: true } diff --git a/test/Cpp/src/concurrent/Workers.lf b/test/Cpp/src/concurrent/Workers.lf index 88579d4ba7..43b7d8a114 100644 --- a/test/Cpp/src/concurrent/Workers.lf +++ b/test/Cpp/src/concurrent/Workers.lf @@ -1,14 +1,14 @@ target Cpp { - workers: 16 + workers: 16 } main reactor { - reaction(startup) {= - if (environment()->num_workers() != 16) { - std::cout << "Expected to have 16 workers.\n"; - exit(1); - } else { - std::cout << "Using 16 workers.\n"; - } - =} + reaction(startup) {= + if (environment()->num_workers() != 16) { + std::cout << "Expected to have 16 workers.\n"; + exit(1); + } else { + std::cout << "Using 16 workers.\n"; + } + =} } diff --git a/test/Cpp/src/lib/Imported.lf b/test/Cpp/src/lib/Imported.lf index 9c29c48be2..abf2464b96 100644 --- a/test/Cpp/src/lib/Imported.lf +++ b/test/Cpp/src/lib/Imported.lf @@ -5,8 +5,8 @@ target Cpp import ImportedAgain from "ImportedAgain.lf" reactor Imported { - input x: int - a = new ImportedAgain() + input x: int + a = new ImportedAgain() - reaction(x) -> a.x {= a.x.set(x.get()); =} + reaction(x) -> a.x {= a.x.set(x.get()); =} } diff --git a/test/Cpp/src/lib/ImportedAgain.lf b/test/Cpp/src/lib/ImportedAgain.lf index 83495dc480..a5e0ba3ceb 100644 --- a/test/Cpp/src/lib/ImportedAgain.lf +++ b/test/Cpp/src/lib/ImportedAgain.lf @@ -3,15 +3,15 @@ target Cpp reactor ImportedAgain { - input x: int + input x: int - reaction(x) {= - auto value = *x.get(); - if (value != 42) { - std::cerr << "ERROR: Expected input to be 42. Got: " << value << std::endl; - exit(1); - } else { - std::cout << "Received " << value << std::endl; - } - =} + reaction(x) {= + auto value = *x.get(); + if (value != 42) { + std::cerr << "ERROR: Expected input to be 42. Got: " << value << std::endl; + exit(1); + } else { + std::cout << "Received " << value << std::endl; + } + =} } diff --git a/test/Cpp/src/lib/ImportedComposition.lf b/test/Cpp/src/lib/ImportedComposition.lf index 97ddb436d0..cc3ccba591 100644 --- a/test/Cpp/src/lib/ImportedComposition.lf +++ b/test/Cpp/src/lib/ImportedComposition.lf @@ -9,18 +9,18 @@ target Cpp reactor Gain { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= y.set(*x.get() * 2); =} + reaction(x) -> y {= y.set(*x.get() * 2); =} } reactor ImportedComposition { - input x: int - output y: int - g1 = new Gain() - g2 = new Gain() - x -> g1.x after 10 msec - g1.y -> g2.x after 30 msec - g2.y -> y after 15 msec + input x: int + output y: int + g1 = new Gain() + g2 = new Gain() + x -> g1.x after 10 msec + g1.y -> g2.x after 30 msec + g2.y -> y after 15 msec } diff --git a/test/Cpp/src/lib/LoopedActionSender.lf b/test/Cpp/src/lib/LoopedActionSender.lf index 572e00d6c4..3c1cc13631 100644 --- a/test/Cpp/src/lib/LoopedActionSender.lf +++ b/test/Cpp/src/lib/LoopedActionSender.lf @@ -8,9 +8,10 @@ target Cpp /** - * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break after sending - * take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in + * consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break + * after sending take_a_break_after messages. */ reactor Sender(take_a_break_after: int = 10, break_interval: time = 400 msec) { output out: int diff --git a/test/Cpp/src/multiport/BankSelfBroadcast.lf b/test/Cpp/src/multiport/BankSelfBroadcast.lf index 417d5b325e..07da948506 100644 --- a/test/Cpp/src/multiport/BankSelfBroadcast.lf +++ b/test/Cpp/src/multiport/BankSelfBroadcast.lf @@ -1,7 +1,7 @@ /** - * Test a bank of reactors that broadcast a single output back to a multiport input of the same - * reactors in the bank so that each reactor in the bank receives the output produced by itself and - * each other reactor. + * Test a bank of reactors that broadcast a single output back to a multiport + * input of the same reactors in the bank so that each reactor in the bank + * receives the output produced by itself and each other reactor. * * @author Edward A. Lee * @author Christian Menard diff --git a/test/Cpp/src/multiport/IndexIntoMultiportInput.lf b/test/Cpp/src/multiport/IndexIntoMultiportInput.lf index 068724b781..8deaef2c2a 100644 --- a/test/Cpp/src/multiport/IndexIntoMultiportInput.lf +++ b/test/Cpp/src/multiport/IndexIntoMultiportInput.lf @@ -8,46 +8,46 @@ target Cpp reactor ReactorWithMultiport { - input[3] in: int - - reaction(startup, in) {= - bool error{false}; - for (size_t i{0}; i < in.size(); i++) { - if (in[i].is_present()) { - if (*in[i].get() != i) { - reactor::log::Error() << "received wrong input on port " << i; - } - } else { - error = true; - reactor::log::Error() << "input " << i << " is not present"; + input[3] in: int + + reaction(startup, in) {= + bool error{false}; + for (size_t i{0}; i < in.size(); i++) { + if (in[i].is_present()) { + if (*in[i].get() != i) { + reactor::log::Error() << "received wrong input on port " << i; } + } else { + error = true; + reactor::log::Error() << "input " << i << " is not present"; } - if (error) { - exit(1); - } - reactor::log::Info() << "success"; - =} + } + if (error) { + exit(1); + } + reactor::log::Info() << "success"; + =} } reactor MultiportSplitter { - output[3] out: int + output[3] out: int - input in0: int - input in1: int - input in2: int + input in0: int + input in1: int + input in2: int - in0, in1, in2 -> out + in0, in1, in2 -> out } main reactor IndexIntoMultiportInput { - splitter = new MultiportSplitter() - receiver = new ReactorWithMultiport() + splitter = new MultiportSplitter() + receiver = new ReactorWithMultiport() - splitter.out -> receiver.in + splitter.out -> receiver.in - reaction(startup) -> splitter.in0 {= splitter.in0.set(0); =} + reaction(startup) -> splitter.in0 {= splitter.in0.set(0); =} - reaction(startup) -> splitter.in1 {= splitter.in1.set(1); =} + reaction(startup) -> splitter.in1 {= splitter.in1.set(1); =} - reaction(startup) -> splitter.in2 {= splitter.in2.set(2); =} + reaction(startup) -> splitter.in2 {= splitter.in2.set(2); =} } diff --git a/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf b/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf index dd5a5759e1..964e2e7095 100644 --- a/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf +++ b/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf @@ -2,8 +2,9 @@ * This test was first described by Peter Donovan in * https://github.com/lf-lang/lingua-franca/issues/1321 * - * It simply tests if passthrough connections work as expected in the C++ target. Such a connection - * directly connects an input to an output of the same reactor, without any reactions in between. + * It simply tests if passthrough connections work as expected in the C++ + * target. Such a connection directly connects an input to an output of the same + * reactor, without any reactions in between. */ target Cpp diff --git a/test/Cpp/src/multiport/MultiportFromBank.lf b/test/Cpp/src/multiport/MultiportFromBank.lf index d1cf2a9d36..b7339a9184 100644 --- a/test/Cpp/src/multiport/MultiportFromBank.lf +++ b/test/Cpp/src/multiport/MultiportFromBank.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf b/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf index 1b4c53bf83..673ef6889a 100644 --- a/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf index 1786e5292d..fe27c74f35 100644 --- a/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportFromHierarchy.lf b/test/Cpp/src/multiport/MultiportFromHierarchy.lf index 75eadf542b..fae914b609 100644 --- a/test/Cpp/src/multiport/MultiportFromHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportFromHierarchy.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input, where the former is a hierarchical reactor. +// Check multiport output to multiport input, where the former is a hierarchical +// reactor. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportIn.lf b/test/Cpp/src/multiport/MultiportIn.lf index af2f4eab18..39fce6f8ff 100644 --- a/test/Cpp/src/multiport/MultiportIn.lf +++ b/test/Cpp/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -// This is a version fo the Threaded test that uses a multiport input at the destination. Its -// purpose is to test multiport inputs. +// This is a version fo the Threaded test that uses a multiport input at the +// destination. Its purpose is to test multiport inputs. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportToBankHierarchy.lf b/test/Cpp/src/multiport/MultiportToBankHierarchy.lf index 1c520d6759..f9cef6a676 100644 --- a/test/Cpp/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportToBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportToHierarchy.lf b/test/Cpp/src/multiport/MultiportToHierarchy.lf index ff641336ae..573a0e06da 100644 --- a/test/Cpp/src/multiport/MultiportToHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportToHierarchy.lf @@ -1,5 +1,6 @@ -// Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that -// the destination reactor has width wider than the sender, so one input is dangling. +// Check multiport output to multiport input, where the latter is a hierarchical +// reactor. Note that the destination reactor has width wider than the sender, +// so one input is dangling. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportToMultiportArray.lf b/test/Cpp/src/multiport/MultiportToMultiportArray.lf index 0da837bb17..6c96d17150 100644 --- a/test/Cpp/src/multiport/MultiportToMultiportArray.lf +++ b/test/Cpp/src/multiport/MultiportToMultiportArray.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input. Destination port is wider than sending port. +// Check multiport output to multiport input. Destination port is wider than +// sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/MultiportToPort.lf b/test/Cpp/src/multiport/MultiportToPort.lf index 48804f575e..c2b0bd66ef 100644 --- a/test/Cpp/src/multiport/MultiportToPort.lf +++ b/test/Cpp/src/multiport/MultiportToPort.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input. Destination port is wider than sending port. +// Check multiport output to multiport input. Destination port is wider than +// sending port. target Cpp { timeout: 2 sec, fast: true diff --git a/test/Cpp/src/multiport/PipelineAfter.lf b/test/Cpp/src/multiport/PipelineAfter.lf index d708d727ff..b160ab8104 100644 --- a/test/Cpp/src/multiport/PipelineAfter.lf +++ b/test/Cpp/src/multiport/PipelineAfter.lf @@ -1,38 +1,38 @@ target Cpp reactor Source { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(40); =} + reaction(startup) -> out {= out.set(40); =} } reactor Compute { - input in: unsigned - output out: unsigned + input in: unsigned + output out: unsigned - reaction(in) -> out {= out.set(*in.get() + 2); =} + reaction(in) -> out {= out.set(*in.get() + 2); =} } reactor Sink { - input in: unsigned - - reaction(in) {= - std::cout << "Received " << *in.get() << '\n'; - if (*in.get() != 42) { - std::cerr << "Error: expected 42!\n"; - exit(1); - } - if (get_elapsed_logical_time() != 1s) { - std::cerr << "ERROR: Expected to receive input after 1 second.\n"; - exit(2); - } - =} + input in: unsigned + + reaction(in) {= + std::cout << "Received " << *in.get() << '\n'; + if (*in.get() != 42) { + std::cerr << "Error: expected 42!\n"; + exit(1); + } + if (get_elapsed_logical_time() != 1s) { + std::cerr << "ERROR: Expected to receive input after 1 second.\n"; + exit(2); + } + =} } main reactor { - source = new Source() - compute = new Compute() - sink = new Sink() + source = new Source() + compute = new Compute() + sink = new Sink() - source.out, compute.out -> compute.in, sink.in after 500 msec + source.out, compute.out -> compute.in, sink.in after 500 msec } diff --git a/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf b/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf index c4bdb80d9d..6fa6dbb87b 100644 --- a/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf +++ b/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf @@ -1,4 +1,5 @@ -// Test reacting to and reading outputs from a contained reactor bank with a multiport +// Test reacting to and reading outputs from a contained reactor bank with a +// multiport target Cpp reactor Contained(bank_index: size_t = 0) { diff --git a/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf b/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf index db27bf5a6f..18179b9086 100644 --- a/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf +++ b/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf @@ -1,4 +1,5 @@ -// Test reacting to and reading outputs from a contained reactor bank in various permutations. +// Test reacting to and reading outputs from a contained reactor bank in various +// permutations. target Cpp reactor Contained(bank_index: size_t = 0) { diff --git a/test/Cpp/src/target/BraceAndParenInitialization.lf b/test/Cpp/src/target/BraceAndParenInitialization.lf index 488a2719f5..003b6d509d 100644 --- a/test/Cpp/src/target/BraceAndParenInitialization.lf +++ b/test/Cpp/src/target/BraceAndParenInitialization.lf @@ -6,8 +6,10 @@ reactor Foo( param_list_3: std::vector(4, 2), // list containing [2,2,2,2] param_list_4: std::vector{4, 2} // list containing [4,2] ) { - state state_list_1: std::vector(6, 42) // list containing [42,42,42,42,42,42] - state state_list_2: std::vector{6, 42} // list containing [6,42] + // list containing [42,42,42,42,42,42] + state state_list_1: std::vector(6, 42) + // list containing [6,42] + state state_list_2: std::vector{6, 42} reaction(startup) {= std::cerr << "Hello!\n"; diff --git a/test/Cpp/src/target/CMakeInclude.lf b/test/Cpp/src/target/CMakeInclude.lf index b1adacc966..1291e56425 100644 --- a/test/Cpp/src/target/CMakeInclude.lf +++ b/test/Cpp/src/target/CMakeInclude.lf @@ -2,19 +2,19 @@ * Test that cmake-include is working correctly. The failure for this test is failure to compile. */ target Cpp { - cmake-include: [ - "../include/mlib-cmake-extension.cmake", - "../include/bar-cmake-compile-definition.txt" - ], - timeout: 0 sec + cmake-include: [ + "../include/mlib-cmake-extension.cmake", + "../include/bar-cmake-compile-definition.txt" + ], + timeout: 0 sec } main reactor { - private preamble {= - #include - =} + private preamble {= + #include + =} - reaction(startup) {= - std::cout << "Maximum of 4.20 and " << BAR << " is " << fmax(4.20, BAR) << std::endl; - =} + reaction(startup) {= + std::cout << "Maximum of 4.20 and " << BAR << " is " << fmax(4.20, BAR) << std::endl; + =} } diff --git a/test/Cpp/src/target/PreambleFile.lf b/test/Cpp/src/target/PreambleFile.lf index db9ff5e712..53f6ff49da 100644 --- a/test/Cpp/src/target/PreambleFile.lf +++ b/test/Cpp/src/target/PreambleFile.lf @@ -3,50 +3,50 @@ target Cpp // These declarations are used by multiple reactors within this file and should be placed in a // header. This goes to PreampleFile/preamble.hh. public preamble {= - struct MyStruct { - int foo; - std::string bar; - }; + struct MyStruct { + int foo; + std::string bar; + }; - int add_42(int i); + int add_42(int i); =} // This definition is used by multiple reactors within this file. Since the same function can only // be defined once, this needs to go to a source file. This goes to PreampleFile/preamble.cc. private preamble {= - int add_42(int i) { - return i + 42; - } + int add_42(int i) { + return i + 42; + } =} reactor Source { - output x: MyStruct + output x: MyStruct - reaction(startup) -> x {= - int a = add_42(0); - x.set({a, "baz"}); - =} + reaction(startup) -> x {= + int a = add_42(0); + x.set({a, "baz"}); + =} } reactor Print { - // This helper function is only used within the Print reactor and is therefore part of its - // private interface. This goes to PreambleFile/Print.cc - private preamble {= - void print(const MyStruct& x) { - std::cout << "Received " << x.foo << " and '" << x.bar << "'\n"; - } - =} - input x: MyStruct - - reaction(x) {= - MyStruct value = *x.get(); // implicit copy - value.foo = add_42(value.foo); - print(value); - =} + // This helper function is only used within the Print reactor and is therefore part of its private + // interface. This goes to PreambleFile/Print.cc + private preamble {= + void print(const MyStruct& x) { + std::cout << "Received " << x.foo << " and '" << x.bar << "'\n"; + } + =} + input x: MyStruct + + reaction(x) {= + MyStruct value = *x.get(); // implicit copy + value.foo = add_42(value.foo); + print(value); + =} } main reactor PreambleFile { - s = new Source() - p = new Print() - s.x -> p.x + s = new Source() + p = new Print() + s.x -> p.x } diff --git a/test/Python/src/ActionWithNoReaction.lf b/test/Python/src/ActionWithNoReaction.lf index 1b0ee74893..a219377e6e 100644 --- a/test/Python/src/ActionWithNoReaction.lf +++ b/test/Python/src/ActionWithNoReaction.lf @@ -1,36 +1,36 @@ # This checks that action can be created even if there is no reaction. This test passes merely by # compiling and executing without a segfault. Its other functionality is tested by other tests. target Python { - fast: true, - timeout: 3 sec + fast: true, + timeout: 3 sec } reactor foo { - input x - output y - logical action a + input x + output y + logical action a - reaction(x) -> y, a {= # reaction(a) {= =} - y.set(2*x.value) - a.schedule(MSEC(500)) - =} + reaction(x) -> y, a {= # reaction(a) {= =} + y.set(2*x.value) + a.schedule(MSEC(500)) + =} } reactor print { - input x + input x - reaction(x) {= - print("Result is {:d}\n".format(x.value)) - print("Current logical time is: {:d}\n".format(lf.time.logical_elapsed())) - print("Current physical time is: {:d}\n".format(lf.time.physical_elapsed())) - =} + reaction(x) {= + print("Result is {:d}\n".format(x.value)) + print("Current logical time is: {:d}\n".format(lf.time.logical_elapsed())) + print("Current physical time is: {:d}\n".format(lf.time.physical_elapsed())) + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x after 10 msec + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x after 10 msec - reaction(t) -> f.x {= f.x.set(42) =} + reaction(t) -> f.x {= f.x.set(42) =} } diff --git a/test/Python/src/After.lf b/test/Python/src/After.lf index 8ed92b2061..0c8b931543 100644 --- a/test/Python/src/After.lf +++ b/test/Python/src/After.lf @@ -1,4 +1,5 @@ -# This checks that the after keyword adjusts logical time, not using physical time. +# This checks that the after keyword adjusts logical time, not using physical +# time. target Python { fast: false, timeout: 3 sec diff --git a/test/Python/src/AfterCycles.lf b/test/Python/src/AfterCycles.lf index e062d013ee..cd0f0dd98e 100644 --- a/test/Python/src/AfterCycles.lf +++ b/test/Python/src/AfterCycles.lf @@ -1,5 +1,5 @@ -# This tests that "after" does not introduce spurious cycles. Success if running without detected a -# cycle. +# This tests that "after" does not introduce spurious cycles. Success if running +# without detected a cycle. target Python reactor Source { diff --git a/test/Python/src/ArrayAsType.lf b/test/Python/src/ArrayAsType.lf index 37d5d66cf7..dc3b2f6e26 100644 --- a/test/Python/src/ArrayAsType.lf +++ b/test/Python/src/ArrayAsType.lf @@ -1,5 +1,5 @@ -# Source produces a statically allocated array, which it passes to Print. The destination references -# the array directly. +# Source produces a statically allocated array, which it passes to Print. The +# destination references the array directly. target Python reactor Source { diff --git a/test/Python/src/ArrayFree.lf b/test/Python/src/ArrayFree.lf index 147e9537a8..2ea2777c12 100644 --- a/test/Python/src/ArrayFree.lf +++ b/test/Python/src/ArrayFree.lf @@ -1,7 +1,7 @@ -# Source produces a dynamically allocated array, which it passes to Free. Free requests a writable -# copy, which, instead of copying, it just gets ownership of the original array. It then does -# nothing further with it. This test checks that the memory gets freed automatically even with the -# mutable input. +# Source produces a dynamically allocated array, which it passes to Free. Free +# requests a writable copy, which, instead of copying, it just gets ownership of +# the original array. It then does nothing further with it. This test checks +# that the memory gets freed automatically even with the mutable input. target Python import Source, Print from "ArrayPrint.lf" diff --git a/test/Python/src/ArrayParallel.lf b/test/Python/src/ArrayParallel.lf index 5e75898f14..1316f14ee5 100644 --- a/test/Python/src/ArrayParallel.lf +++ b/test/Python/src/ArrayParallel.lf @@ -7,13 +7,13 @@ import Scale from "ArrayScale.lf" import Source, Print from "ArrayPrint.lf" main reactor ArrayParallel { - s = new Source() - c1 = new Scale() - c2 = new Scale(scale = 3) - p1 = new Print(scale = 2) - p2 = new Print(scale = 3) - s.out -> c1._in - s.out -> c2._in - c1.out -> p1._in - c2.out -> p2._in + s = new Source() + c1 = new Scale() + c2 = new Scale(scale = 3) + p1 = new Print(scale = 2) + p2 = new Print(scale = 3) + s.out -> c1._in + s.out -> c2._in + c1.out -> p1._in + c2.out -> p2._in } diff --git a/test/Python/src/ArrayPrint.lf b/test/Python/src/ArrayPrint.lf index 254d9c352d..4420311b93 100644 --- a/test/Python/src/ArrayPrint.lf +++ b/test/Python/src/ArrayPrint.lf @@ -1,5 +1,5 @@ -# Source produces a dynamically allocated array, which it passes to Print. Reference counting -# ensures that the array is freed. +# Source produces a dynamically allocated array, which it passes to Print. +# Reference counting ensures that the array is freed. target Python reactor Source { diff --git a/test/Python/src/ArrayScale.lf b/test/Python/src/ArrayScale.lf index 10f5a747e6..2b69aebe77 100644 --- a/test/Python/src/ArrayScale.lf +++ b/test/Python/src/ArrayScale.lf @@ -1,6 +1,7 @@ -# Source produces a dynamically allocated array, which it passes to Scale. Scale requests a writable -# copy, which, instead of copying, it just gets ownership of the original array. It modifies it and -# passes it to Print. It gets freed after Print is done with it. +# Source produces a dynamically allocated array, which it passes to Scale. Scale +# requests a writable copy, which, instead of copying, it just gets ownership of +# the original array. It modifies it and passes it to Print. It gets freed after +# Print is done with it. target Python import Print, Source from "ArrayPrint.lf" diff --git a/test/Python/src/Composition.lf b/test/Python/src/Composition.lf index a5b9cac96f..d1bef93ed2 100644 --- a/test/Python/src/Composition.lf +++ b/test/Python/src/Composition.lf @@ -1,4 +1,5 @@ -# This test connects a simple counting source to tester that checks against its own count. +# This test connects a simple counting source to tester that checks against its +# own count. target Python { fast: true, timeout: 10 sec diff --git a/test/Python/src/CompositionAfter.lf b/test/Python/src/CompositionAfter.lf index 74217559db..00b95e3ab9 100644 --- a/test/Python/src/CompositionAfter.lf +++ b/test/Python/src/CompositionAfter.lf @@ -1,4 +1,5 @@ -# This test connects a simple counting source to tester that checks against its own count. +# This test connects a simple counting source to tester that checks against its +# own count. target Python { fast: true, timeout: 10 sec diff --git a/test/Python/src/CompositionGain.lf b/test/Python/src/CompositionGain.lf index 6bc0f74c74..e3630f3169 100644 --- a/test/Python/src/CompositionGain.lf +++ b/test/Python/src/CompositionGain.lf @@ -2,32 +2,32 @@ target Python reactor Gain { - input gainin - output y + input gainin + output y - reaction(gainin) -> y {= - print("Gain received " + str(gainin.value)) - y.set(gainin.value * 2) - =} + reaction(gainin) -> y {= + print("Gain received " + str(gainin.value)) + y.set(gainin.value * 2) + =} } reactor Wrapper { - input x - output y - gain = new Gain() - x -> gain.gainin - gain.y -> y + input x + output y + gain = new Gain() + x -> gain.gainin + gain.y -> y } main reactor { - wrapper = new Wrapper() + wrapper = new Wrapper() - reaction(startup) -> wrapper.x {= wrapper_x.set(42) =} + reaction(startup) -> wrapper.x {= wrapper_x.set(42) =} - reaction(wrapper.y) {= - print("Received " + str(wrapper_y.value)) - if (wrapper_y.value != 42 * 2): - sys.stderr.write("ERROR: Received value should have been ", str(42 * 2)) - exit(2) - =} + reaction(wrapper.y) {= + print("Received " + str(wrapper_y.value)) + if (wrapper_y.value != 42 * 2): + sys.stderr.write("ERROR: Received value should have been ", str(42 * 2)) + exit(2) + =} } diff --git a/test/Python/src/CompositionInheritance.lf b/test/Python/src/CompositionInheritance.lf index aeaa9e30bb..4b0e4a38c9 100644 --- a/test/Python/src/CompositionInheritance.lf +++ b/test/Python/src/CompositionInheritance.lf @@ -1,4 +1,5 @@ -# This test connects a simple counting source to tester that checks against its own count. +# This test connects a simple counting source to tester that checks against its +# own count. target Python { fast: true, timeout: 10 sec diff --git a/test/Python/src/DanglingOutput.lf b/test/Python/src/DanglingOutput.lf index 7894f73835..f6fe938765 100644 --- a/test/Python/src/DanglingOutput.lf +++ b/test/Python/src/DanglingOutput.lf @@ -3,24 +3,24 @@ target Python reactor Source { - output out - timer t + output out + timer t - reaction(t) -> out {= out.set(1); =} + reaction(t) -> out {= out.set(1); =} } reactor Gain { - input _in - output out + input _in + output out - reaction(_in) -> out {= - print("Received ", _in.value) - out.set(_in.value * 2) - =} + reaction(_in) -> out {= + print("Received ", _in.value) + out.set(_in.value * 2) + =} } main reactor DanglingOutput { - source = new Source() - container = new Gain() - source.out -> container._in + source = new Source() + container = new Gain() + source.out -> container._in } diff --git a/test/Python/src/Deadline.lf b/test/Python/src/Deadline.lf index 154a755327..ceab2b28e2 100644 --- a/test/Python/src/Deadline.lf +++ b/test/Python/src/Deadline.lf @@ -1,5 +1,6 @@ -# This example illustrates local deadline handling. Even numbers are sent by the Source immediately, -# whereas odd numbers are sent after a big enough delay to violate the deadline. +# This example illustrates local deadline handling. Even numbers are sent by the +# Source immediately, whereas odd numbers are sent after a big enough delay to +# violate the deadline. target Python { timeout: 6 sec } diff --git a/test/Python/src/DeadlineHandledAbove.lf b/test/Python/src/DeadlineHandledAbove.lf index 39c927ee08..1259253cea 100644 --- a/test/Python/src/DeadlineHandledAbove.lf +++ b/test/Python/src/DeadlineHandledAbove.lf @@ -1,5 +1,5 @@ -# Test a deadline where the deadline violation produces an output and the container reacts to that -# output. +# Test a deadline where the deadline violation produces an output and the +# container reacts to that output. target Python preamble {= import time =} diff --git a/test/Python/src/DelayArrayWithAfter.lf b/test/Python/src/DelayArrayWithAfter.lf index 52245e314f..1e6ac1f317 100644 --- a/test/Python/src/DelayArrayWithAfter.lf +++ b/test/Python/src/DelayArrayWithAfter.lf @@ -1,4 +1,5 @@ -# This tests transport of dynamically allocated arrays over connections with 'after'. +# This tests transport of dynamically allocated arrays over connections with +# 'after'. target Python { timeout: 5 sec, fast: true diff --git a/test/Python/src/DelayString.lf b/test/Python/src/DelayString.lf index e7e7531888..d1201dec02 100644 --- a/test/Python/src/DelayString.lf +++ b/test/Python/src/DelayString.lf @@ -1,4 +1,5 @@ -# This tests actions with immutable payloads that are neither malloc'd nor freed. +# This tests actions with immutable payloads that are neither malloc'd nor +# freed. target Python reactor DelayString2(delay = 100 msec) { diff --git a/test/Python/src/DelayedReaction.lf b/test/Python/src/DelayedReaction.lf index fc3a47f04a..c62b4a3857 100644 --- a/test/Python/src/DelayedReaction.lf +++ b/test/Python/src/DelayedReaction.lf @@ -2,26 +2,26 @@ target Python reactor Source { - output out - timer t + output out + timer t - reaction(t) -> out {= out.set(1) =} + reaction(t) -> out {= out.set(1) =} } reactor Sink { - input _in + input _in - reaction(_in) {= - elapsed = lf.time.logical_elapsed() - print("Nanoseconds since start: ", elapsed) - if elapsed != 100000000: - sys.stderr.write("ERROR: Expected 100000000 but.\n") - exit(1) - =} + reaction(_in) {= + elapsed = lf.time.logical_elapsed() + print("Nanoseconds since start: ", elapsed) + if elapsed != 100000000: + sys.stderr.write("ERROR: Expected 100000000 but.\n") + exit(1) + =} } main reactor DelayedReaction { - source = new Source() - sink = new Sink() - source.out -> sink._in after 100 msec + source = new Source() + sink = new Sink() + source.out -> sink._in after 100 msec } diff --git a/test/Python/src/Determinism.lf b/test/Python/src/Determinism.lf index 1a88bac2e8..fdfe446e3d 100644 --- a/test/Python/src/Determinism.lf +++ b/test/Python/src/Determinism.lf @@ -1,43 +1,43 @@ target Python reactor Source { - output y - timer t + output y + timer t - reaction(t) -> y {= y.set(1) =} + reaction(t) -> y {= y.set(1) =} } reactor Destination { - input x - input y + input x + input y - reaction(x, y) {= - sm = 0 - if x.is_present: - sm += x.value - if y.is_present: - sm += y.value - print("Received ", sm); - if sm != 2: - sys.stderr.write("FAILURE: Expected 2.\n") - exit(4) - =} + reaction(x, y) {= + sm = 0 + if x.is_present: + sm += x.value + if y.is_present: + sm += y.value + print("Received ", sm); + if sm != 2: + sys.stderr.write("FAILURE: Expected 2.\n") + exit(4) + =} } reactor Pass { - input x - output y + input x + output y - reaction(x) -> y {= y.set(x.value) =} + reaction(x) -> y {= y.set(x.value) =} } main reactor Determinism { - s = new Source() - d = new Destination() - p1 = new Pass() - p2 = new Pass() - s.y -> d.y - s.y -> p1.x - p1.y -> p2.x - p2.y -> d.x + s = new Source() + d = new Destination() + p1 = new Pass() + p2 = new Pass() + s.y -> d.y + s.y -> p1.x + p1.y -> p2.x + p2.y -> d.x } diff --git a/test/Python/src/DoubleInvocation.lf b/test/Python/src/DoubleInvocation.lf index 78d31883ea..aaecfa31cb 100644 --- a/test/Python/src/DoubleInvocation.lf +++ b/test/Python/src/DoubleInvocation.lf @@ -1,7 +1,8 @@ -# This illustrates a very strange bug that showed up and has now been fixed. This test ensures it -# does not reappear. At logical time zero, the two Print reactors used to be fired twice each at the -# same logical time. They should only be fired once. This behavior was oddly eliminated by either of -# the following actions, neither of which should affect this behavior: +# This illustrates a very strange bug that showed up and has now been fixed. +# This test ensures it does not reappear. At logical time zero, the two Print +# reactors used to be fired twice each at the same logical time. They should +# only be fired once. This behavior was oddly eliminated by either of the +# following actions, neither of which should affect this behavior: # * Removing the startup reaction in Print. # * Sending only position, not velocity from Ball. target Python { diff --git a/test/Python/src/DoubleReaction.lf b/test/Python/src/DoubleReaction.lf index 7af73da6ec..c20a032a9a 100644 --- a/test/Python/src/DoubleReaction.lf +++ b/test/Python/src/DoubleReaction.lf @@ -1,5 +1,5 @@ -# Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output for -# this 2, 4, 6, 8, etc. +# Test that two simultaneous inputs that trigger a reaction trigger it only +# once. Correct output for this 2, 4, 6, 8, etc. target Python { timeout: 10 sec, fast: true diff --git a/test/Python/src/GetTime.lf b/test/Python/src/GetTime.lf index 8c22851395..b24d667aec 100644 --- a/test/Python/src/GetTime.lf +++ b/test/Python/src/GetTime.lf @@ -1,26 +1,26 @@ # This file includes code documented on the Wiki. For this test, success is just compiling and # running. target Python { - timeout: 2 sec, - fast: false + timeout: 2 sec, + fast: false } main reactor GetTime { - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) {= - logical = lf.time.logical() - print("Logical time is ", logical) + reaction(t) {= + logical = lf.time.logical() + print("Logical time is ", logical) - elapsed = lf.time.logical_elapsed() - print("Elapsed logical time is ", elapsed) + elapsed = lf.time.logical_elapsed() + print("Elapsed logical time is ", elapsed) - physical = lf.time.physical() - print("Physical time is ", physical) + physical = lf.time.physical() + print("Physical time is ", physical) - elapsed_physical = lf.time.physical_elapsed() - print("Elapsed physical time is ", elapsed_physical) + elapsed_physical = lf.time.physical_elapsed() + print("Elapsed physical time is ", elapsed_physical) - print("Time lag is ", physical - logical) - =} + print("Time lag is ", physical - logical) + =} } diff --git a/test/Python/src/Hello.lf b/test/Python/src/Hello.lf index 8e60df4ae5..271ed180ca 100644 --- a/test/Python/src/Hello.lf +++ b/test/Python/src/Hello.lf @@ -1,7 +1,8 @@ -# This test checks that logical time is incremented an appropriate amount as a result of an -# invocation of the schedule() function at runtime. It also performs various smoke tests of timing -# aligned reactions. The first instance has a period of 4 seconds, the second of 2 seconds, and the -# third (composite) or 1 second. +# This test checks that logical time is incremented an appropriate amount as a +# result of an invocation of the schedule() function at runtime. It also +# performs various smoke tests of timing aligned reactions. The first instance +# has a period of 4 seconds, the second of 2 seconds, and the third (composite) +# or 1 second. target Python { timeout: 10 sec, fast: true @@ -42,7 +43,10 @@ reactor Inside(period = 1 sec, message = "Composite default message.") { } main reactor Hello { - first_instance = new Reschedule(period = 4 sec, message = "Hello from first_instance.") + first_instance = new Reschedule( + period = 4 sec, + message = "Hello from first_instance." + ) second_instance = new Reschedule(message = "Hello from second_instance.") composite_instance = new Inside(message = "Hello from composite_instance.") } diff --git a/test/Python/src/Hierarchy.lf b/test/Python/src/Hierarchy.lf index 9563d62e31..f8206f81db 100644 --- a/test/Python/src/Hierarchy.lf +++ b/test/Python/src/Hierarchy.lf @@ -2,49 +2,49 @@ target Python reactor Source { - output out - timer t + output out + timer t - reaction(t) -> out {= out.set(1) =} + reaction(t) -> out {= out.set(1) =} } reactor Gain { - input _in - output out + input _in + output out - reaction(_in) -> out {= - print("Gain received ", _in.value) - out.set(_in.value * 2) - =} + reaction(_in) -> out {= + print("Gain received ", _in.value) + out.set(_in.value * 2) + =} } reactor Print { - input _in - - reaction(_in) {= - print("Received: ", _in.value) - if _in.value != 2: - sys.stderr.write("Expected 2.\n") - exit(1) - =} + input _in + + reaction(_in) {= + print("Received: ", _in.value) + if _in.value != 2: + sys.stderr.write("Expected 2.\n") + exit(1) + =} } reactor GainContainer { - input _in - output out - output out2 - gain = new Gain() - _in -> gain._in - gain.out -> out - gain.out -> out2 + input _in + output out + output out2 + gain = new Gain() + _in -> gain._in + gain.out -> out + gain.out -> out2 } main reactor Hierarchy { - source = new Source() - container = new GainContainer() - print = new Print() - print2 = new Print() - source.out -> container._in - container.out -> print._in - container.out -> print2._in + source = new Source() + container = new GainContainer() + print = new Print() + print2 = new Print() + source.out -> container._in + container.out -> print._in + container.out -> print2._in } diff --git a/test/Python/src/Import.lf b/test/Python/src/Import.lf index 4c17403320..fc225f1cb0 100644 --- a/test/Python/src/Import.lf +++ b/test/Python/src/Import.lf @@ -4,8 +4,8 @@ target Python import Imported from "lib/Imported.lf" main reactor Import { - timer t - a = new Imported() + timer t + a = new Imported() - reaction(t) -> a.x {= a.x.set(42) =} + reaction(t) -> a.x {= a.x.set(42) =} } diff --git a/test/Python/src/ImportComposition.lf b/test/Python/src/ImportComposition.lf index 8063e7c938..369fbcab44 100644 --- a/test/Python/src/ImportComposition.lf +++ b/test/Python/src/ImportComposition.lf @@ -1,4 +1,5 @@ -# This tests the ability to import a reactor definition that itself imports a reactor definition. +# This tests the ability to import a reactor definition that itself imports a +# reactor definition. target Python import ImportedComposition from "lib/ImportedComposition.lf" diff --git a/test/Python/src/ImportRenamed.lf b/test/Python/src/ImportRenamed.lf index ab6f1c8078..0d7433028f 100644 --- a/test/Python/src/ImportRenamed.lf +++ b/test/Python/src/ImportRenamed.lf @@ -6,10 +6,10 @@ import Imported as Y from "lib/Imported.lf" import ImportedAgain as Z from "lib/ImportedAgain.lf" main reactor { - timer t - a = new X() - b = new Y() - c = new Z() + timer t + a = new X() + b = new Y() + c = new Z() - reaction(t) -> a.x {= a.x.set(42) =} + reaction(t) -> a.x {= a.x.set(42) =} } diff --git a/test/Python/src/ManualDelayedReaction.lf b/test/Python/src/ManualDelayedReaction.lf index 57a4d2efbb..a9e39829eb 100644 --- a/test/Python/src/ManualDelayedReaction.lf +++ b/test/Python/src/ManualDelayedReaction.lf @@ -1,11 +1,12 @@ target Python { - # Set keepalive to false since this is a test and schedule is called on a physical action from - # within a reaction. This is one of the special rare cases where the user might want to manually - # override keepalive. + # Set keepalive to false since this is a test and schedule is called on a + # physical action from within a reaction. This is one of the special rare + # cases where the user might want to manually override keepalive. keepalive: false } -reactor GeneratedDelay { # That's the stuff that shall be generated for the after +# That's the stuff that shall be generated for the after +reactor GeneratedDelay { input y_in output y_out state y_state = 0 diff --git a/test/Python/src/Microsteps.lf b/test/Python/src/Microsteps.lf index 292118f61e..3913cc9c4b 100644 --- a/test/Python/src/Microsteps.lf +++ b/test/Python/src/Microsteps.lf @@ -1,37 +1,37 @@ target Python reactor Destination { - input x - input y + input x + input y - reaction(x, y) {= - elapsed = lf.time.logical_elapsed() - print("Time since start: ", elapsed) - if elapsed != 0: - sys.stderr.write("Expected elapsed time to be 0, but it was {:d}.".format(elapsed)) - exit(1) - count = 0 - if x.is_present: - print("x is present.") - count += 1 - if y.is_present: - print("y is present.") - count += 1 - if count != 1: - sys.stderr.write("Expected exactly one input to be present but got {:d}.".format(count)) - exit(1) - =} + reaction(x, y) {= + elapsed = lf.time.logical_elapsed() + print("Time since start: ", elapsed) + if elapsed != 0: + sys.stderr.write("Expected elapsed time to be 0, but it was {:d}.".format(elapsed)) + exit(1) + count = 0 + if x.is_present: + print("x is present.") + count += 1 + if y.is_present: + print("y is present.") + count += 1 + if count != 1: + sys.stderr.write("Expected exactly one input to be present but got {:d}.".format(count)) + exit(1) + =} } main reactor Microsteps { - timer start - logical action repeat - d = new Destination() + timer start + logical action repeat + d = new Destination() - reaction(start) -> d.x, repeat {= - d.x.set(1) - repeat.schedule(0) - =} + reaction(start) -> d.x, repeat {= + d.x.set(1) + repeat.schedule(0) + =} - reaction(repeat) -> d.y {= d.y.set(1) =} + reaction(repeat) -> d.y {= d.y.set(1) =} } diff --git a/test/Python/src/Minimal.lf b/test/Python/src/Minimal.lf index 63b089c41c..c0f3f9f6fa 100644 --- a/test/Python/src/Minimal.lf +++ b/test/Python/src/Minimal.lf @@ -2,5 +2,5 @@ target Python main reactor Minimal { - reaction(startup) {= print("Hello World.") =} + reaction(startup) {= print("Hello World.") =} } diff --git a/test/Python/src/MovingAverage.lf b/test/Python/src/MovingAverage.lf index 963cb72db1..3dbd5636c3 100644 --- a/test/Python/src/MovingAverage.lf +++ b/test/Python/src/MovingAverage.lf @@ -1,5 +1,6 @@ -# Demonstration of a state variable that is a list. The MovingAverage reactor computes the moving -# average of the last four inputs and produces that as output. The source is a counting sequence. +# Demonstration of a state variable that is a list. The MovingAverage reactor +# computes the moving average of the last four inputs and produces that as +# output. The source is a counting sequence. target Python { timeout: 1 sec, fast: true diff --git a/test/Python/src/MultipleContained.lf b/test/Python/src/MultipleContained.lf index ae9cb0e96b..27950ccd88 100644 --- a/test/Python/src/MultipleContained.lf +++ b/test/Python/src/MultipleContained.lf @@ -1,4 +1,5 @@ -# Test that a reaction can react to and send two multiple ports of a contained reactor. +# Test that a reaction can react to and send two multiple ports of a contained +# reactor. target Python reactor Contained { diff --git a/test/Python/src/PingPong.lf b/test/Python/src/PingPong.lf index 72c5e19563..f5f80511ae 100644 --- a/test/Python/src/PingPong.lf +++ b/test/Python/src/PingPong.lf @@ -1,19 +1,22 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing - * overhead. This is based on https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure + * message-passing overhead. This is based on + * https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the causality loop. + * Ping introduces a microstep delay using a logical action to break the + * causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * Unthreaded: 97 msec Threaded: 265 msec * - * There is no parallelism in this application, so it does not benefit from being being threaded, - * just some additional overhead. + * There is no parallelism in this application, so it does not benefit from + * being being threaded, just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. These are about an - * order of magnitude faster than anything reported in the paper. + * These measurements are total execution time, including startup and shutdown. + * These are about an order of magnitude faster than anything reported in the + * paper. * * @author Edward A. Lee */ diff --git a/test/Python/src/Preamble.lf b/test/Python/src/Preamble.lf index e158ea03b3..6cbd9d9299 100644 --- a/test/Python/src/Preamble.lf +++ b/test/Python/src/Preamble.lf @@ -1,23 +1,23 @@ # Preambles are put inside the Python reactor class Therefore, accessing them requires the use of # self. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } main reactor Preamble { - preamble {= - import platform - def add_42(self, i): - return i + 42 - =} - timer t + preamble {= + import platform + def add_42(self, i): + return i + 42 + =} + timer t - reaction(t) {= - s = "42"; - i = int(s) - print("Converted string {:s} to int {:d}.".format(s, i)) - print("42 plus 42 is ", self.add_42(42)) - print("Your platform is ", self.platform.system()) - =} + reaction(t) {= + s = "42"; + i = int(s) + print("Converted string {:s} to int {:d}.".format(s, i)) + print("42 plus 42 is ", self.add_42(42)) + print("Your platform is ", self.platform.system()) + =} } diff --git a/test/Python/src/ReadOutputOfContainedReactor.lf b/test/Python/src/ReadOutputOfContainedReactor.lf index 4052d70e77..1cb73667ce 100644 --- a/test/Python/src/ReadOutputOfContainedReactor.lf +++ b/test/Python/src/ReadOutputOfContainedReactor.lf @@ -1,4 +1,5 @@ -# Test reacting to and reading outputs from a contained reactor in various permutations. +# Test reacting to and reading outputs from a contained reactor in various +# permutations. target Python reactor Contained { diff --git a/test/Python/src/Schedule.lf b/test/Python/src/Schedule.lf index 15806af2e3..b79a7298bd 100644 --- a/test/Python/src/Schedule.lf +++ b/test/Python/src/Schedule.lf @@ -2,23 +2,23 @@ target Python reactor Schedule2 { - input x - logical action a + input x + logical action a - reaction(x) -> a {= a.schedule(MSEC(200)) =} + reaction(x) -> a {= a.schedule(MSEC(200)) =} - reaction(a) {= - elapsed_time = lf.time.logical_elapsed() - print("Action triggered at logical time {:d} nsec after start.".format(elapsed_time)) - if elapsed_time != 200000000: - sys.stderr.write("Expected action time to be 200 msec. It was {:d} nsec.\n".format(elapsed_time)) - exit(1) - =} + reaction(a) {= + elapsed_time = lf.time.logical_elapsed() + print("Action triggered at logical time {:d} nsec after start.".format(elapsed_time)) + if elapsed_time != 200000000: + sys.stderr.write("Expected action time to be 200 msec. It was {:d} nsec.\n".format(elapsed_time)) + exit(1) + =} } main reactor { - a = new Schedule2() - timer t + a = new Schedule2() + timer t - reaction(t) -> a.x {= a.x.set(1) =} + reaction(t) -> a.x {= a.x.set(1) =} } diff --git a/test/Python/src/ScheduleLogicalAction.lf b/test/Python/src/ScheduleLogicalAction.lf index b60471f676..3f99c65777 100644 --- a/test/Python/src/ScheduleLogicalAction.lf +++ b/test/Python/src/ScheduleLogicalAction.lf @@ -1,5 +1,5 @@ -# This checks that a logical action is scheduled the specified logical time after the current -# logical time. +# This checks that a logical action is scheduled the specified logical time +# after the current logical time. target Python { fast: true, timeout: 3 sec diff --git a/test/Python/src/ScheduleValue.lf b/test/Python/src/ScheduleValue.lf index 3dc2a28717..02fb0a3b1f 100644 --- a/test/Python/src/ScheduleValue.lf +++ b/test/Python/src/ScheduleValue.lf @@ -1,20 +1,20 @@ /** Test of schedule_value. */ target Python { - timeout: 3 sec + timeout: 3 sec } main reactor ScheduleValue { - logical action a + logical action a - reaction(startup) -> a {= - value = "Hello" - a.schedule(0, value) - =} + reaction(startup) -> a {= + value = "Hello" + a.schedule(0, value) + =} - reaction(a) {= - print("Received: ", a.value) - if a.value != "Hello": - sys.stderr.write("FAILURE: Should have received 'Hello'\n") - exit(1) - =} + reaction(a) {= + print("Received: ", a.value) + if a.value != "Hello": + sys.stderr.write("FAILURE: Should have received 'Hello'\n") + exit(1) + =} } diff --git a/test/Python/src/SendingInside.lf b/test/Python/src/SendingInside.lf index e6645fbc44..8bcc66c005 100644 --- a/test/Python/src/SendingInside.lf +++ b/test/Python/src/SendingInside.lf @@ -1,5 +1,5 @@ -# This tests a reactor that contains another reactor and also has its own reaction that routes -# inputs to the contained reactor. +# This tests a reactor that contains another reactor and also has its own +# reaction that routes inputs to the contained reactor. target Python { timeout: 10 sec, fast: true diff --git a/test/Python/src/SendingInside2.lf b/test/Python/src/SendingInside2.lf index db941c67d4..cdf99e6a2d 100644 --- a/test/Python/src/SendingInside2.lf +++ b/test/Python/src/SendingInside2.lf @@ -1,19 +1,19 @@ target Python reactor Printer { - input x + input x - reaction(x) {= - print("Inside reactor received: ", x.value) - if x.value != 1: - sys.stderr.write("ERROR: Expected 1.\n") - exit(1) - =} + reaction(x) {= + print("Inside reactor received: ", x.value) + if x.value != 1: + sys.stderr.write("ERROR: Expected 1.\n") + exit(1) + =} } main reactor SendingInside2 { - timer t - p = new Printer() + timer t + p = new Printer() - reaction(t) -> p.x {= p.x.set(1) =} + reaction(t) -> p.x {= p.x.set(1) =} } diff --git a/test/Python/src/SetArray.lf b/test/Python/src/SetArray.lf index 8906312c04..4766d529f7 100644 --- a/test/Python/src/SetArray.lf +++ b/test/Python/src/SetArray.lf @@ -1,5 +1,6 @@ -# This tests passing lists as port values This tests the use of the "polymorphic" delay reactor on a -# struct. It delays by a logical time any pointer datatype. +# This tests passing lists as port values This tests the use of the +# "polymorphic" delay reactor on a struct. It delays by a logical time any +# pointer datatype. target Python reactor Source { diff --git a/test/Python/src/SimpleDeadline.lf b/test/Python/src/SimpleDeadline.lf index f1065e9508..a714124129 100644 --- a/test/Python/src/SimpleDeadline.lf +++ b/test/Python/src/SimpleDeadline.lf @@ -1,5 +1,6 @@ -# Test local deadline, where a deadline is associated with a reaction definition. This test triggers -# a reaction exactly once with a deadline violation. +# Test local deadline, where a deadline is associated with a reaction +# definition. This test triggers a reaction exactly once with a deadline +# violation. target Python reactor Deadline(threshold = 100 msec) { diff --git a/test/Python/src/SimpleImport.lf b/test/Python/src/SimpleImport.lf index 1183070e24..ee97177f06 100644 --- a/test/Python/src/SimpleImport.lf +++ b/test/Python/src/SimpleImport.lf @@ -3,6 +3,6 @@ target Python import HelloWorld2 from "HelloWorld.lf" main reactor SimpleImport { - a = new HelloWorld2() - b = new HelloWorld2() + a = new HelloWorld2() + b = new HelloWorld2() } diff --git a/test/Python/src/SlowingClock.lf b/test/Python/src/SlowingClock.lf index 72f6657ffb..972421437a 100644 --- a/test/Python/src/SlowingClock.lf +++ b/test/Python/src/SlowingClock.lf @@ -1,7 +1,7 @@ /** - * Output events at logical times 100, 300, 600, and 1000 msec after the start time. This uses a - * logical action with a minimum delay of 100 msec and additional delays provided as arguments to - * the schedule() function. + * Output events at logical times 100, 300, 600, and 1000 msec after the start + * time. This uses a logical action with a minimum delay of 100 msec and + * additional delays provided as arguments to the schedule() function. */ target Python { timeout: 1 sec, diff --git a/test/Python/src/StartupOutFromInside.lf b/test/Python/src/StartupOutFromInside.lf index e539f6b63e..eff09b1a77 100644 --- a/test/Python/src/StartupOutFromInside.lf +++ b/test/Python/src/StartupOutFromInside.lf @@ -1,18 +1,18 @@ target Python reactor Bar { - output out + output out - reaction(startup) -> out {= out.set(42) =} + reaction(startup) -> out {= out.set(42) =} } main reactor StartupOutFromInside { - bar = new Bar() + bar = new Bar() - reaction(startup) bar.out {= - print("Output from bar: ", bar.out.value) - if bar.out.value != 42: - sys.stderr.write("Expected 42!\n") - exit(1) - =} + reaction(startup) bar.out {= + print("Output from bar: ", bar.out.value) + if bar.out.value != 42: + sys.stderr.write("Expected 42!\n") + exit(1) + =} } diff --git a/test/Python/src/Stride.lf b/test/Python/src/Stride.lf index 4d1ec22218..86c68bab5a 100644 --- a/test/Python/src/Stride.lf +++ b/test/Python/src/Stride.lf @@ -1,5 +1,5 @@ -# This example illustrates state variables and parameters on the wiki. For this test, success is -# just compiling and running. +# This example illustrates state variables and parameters on the wiki. For this +# test, success is just compiling and running. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/StructAsState.lf b/test/Python/src/StructAsState.lf index dc6bc3c70b..b6f38f8589 100644 --- a/test/Python/src/StructAsState.lf +++ b/test/Python/src/StructAsState.lf @@ -1,4 +1,5 @@ -# Check that a state variable can have a statically initialized struct as a value. +# Check that a state variable can have a statically initialized struct as a +# value. target Python main reactor StructAsState { diff --git a/test/Python/src/StructPrint.lf b/test/Python/src/StructPrint.lf index 414e87c64d..3c0138f937 100644 --- a/test/Python/src/StructPrint.lf +++ b/test/Python/src/StructPrint.lf @@ -1,5 +1,5 @@ -# Source produces a dynamically allocated class object, which it passes to Print. Reference counting -# ensures that the struct is freed. +# Source produces a dynamically allocated class object, which it passes to +# Print. Reference counting ensures that the struct is freed. target Python { files: ["include/hello.py"] } diff --git a/test/Python/src/TestForPreviousOutput.lf b/test/Python/src/TestForPreviousOutput.lf index 1c17308c04..d2a0661768 100644 --- a/test/Python/src/TestForPreviousOutput.lf +++ b/test/Python/src/TestForPreviousOutput.lf @@ -3,38 +3,38 @@ target Python reactor Source { - output out - preamble {= import random =} + output out + preamble {= import random =} - reaction(startup) -> out {= - # Set a seed for random number generation based on the current time. - self.random.seed() - # Randomly produce an output or not. - if self.random.choice([0,1]) == 1: - out.set(21) - =} + reaction(startup) -> out {= + # Set a seed for random number generation based on the current time. + self.random.seed() + # Randomly produce an output or not. + if self.random.choice([0,1]) == 1: + out.set(21) + =} - reaction(startup) -> out {= - if out.is_present: - out.set(2 * out.value) - else: - out.set(42) - =} + reaction(startup) -> out {= + if out.is_present: + out.set(2 * out.value) + else: + out.set(42) + =} } reactor Sink { - input _in + input _in - reaction(_in) {= - print("Received ", _in.value) - if _in.value != 42: - sys.stderr.write("FAILED: Expected 42.\n") - exit(1) - =} + reaction(_in) {= + print("Received ", _in.value) + if _in.value != 42: + sys.stderr.write("FAILED: Expected 42.\n") + exit(1) + =} } main reactor TestForPreviousOutput { - s = new Source() - d = new Sink() - s.out -> d._in + s = new Source() + d = new Sink() + s.out -> d._in } diff --git a/test/Python/src/TimeLimit.lf b/test/Python/src/TimeLimit.lf index 95120083d8..beb7602db9 100644 --- a/test/Python/src/TimeLimit.lf +++ b/test/Python/src/TimeLimit.lf @@ -1,5 +1,6 @@ -# Test that the stop function can be used to internally impose a a time limit. Correct output for -# this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. +# Test that the stop function can be used to internally impose a a time limit. +# Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt +# or getting the wrong data. target Python { fast: true } diff --git a/test/Python/src/TriggerDownstreamOnlyIfPresent.lf b/test/Python/src/TriggerDownstreamOnlyIfPresent.lf index a4ae089e46..b65f732652 100644 --- a/test/Python/src/TriggerDownstreamOnlyIfPresent.lf +++ b/test/Python/src/TriggerDownstreamOnlyIfPresent.lf @@ -1,4 +1,7 @@ -/** This test checks that a downstream reaction is triggered only if its trigger is present. */ +/** + * This test checks that a downstream reaction is triggered only if its trigger + * is present. + */ target Python { timeout: 1 sec, fast: true diff --git a/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf b/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf index 7f94ab374a..b9a9184296 100644 --- a/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,4 +1,7 @@ -/** This test checks that a downstream reaction is triggered only if its trigger is present. */ +/** + * This test checks that a downstream reaction is triggered only if its trigger + * is present. + */ target Python { timeout: 1 sec, fast: true diff --git a/test/Python/src/Wcet.lf b/test/Python/src/Wcet.lf index ef539b47aa..57216ca078 100644 --- a/test/Python/src/Wcet.lf +++ b/test/Python/src/Wcet.lf @@ -2,43 +2,43 @@ target Python reactor Source { - output out1 - output out2 - timer t - - reaction(t) -> out1, out2 {= - out1.set(5) - out2.set(10) - =} + output out1 + output out2 + timer t + + reaction(t) -> out1, out2 {= + out1.set(5) + out2.set(10) + =} } reactor Work { - input in1 - input in2 - output out - - reaction(in1, in2) -> out {= - ret = 0 - if in1.value > 10: - ret = in2.value * in1.value - else: - ret = in2.value + in1.value - out.set(ret) - =} + input in1 + input in2 + output out + + reaction(in1, in2) -> out {= + ret = 0 + if in1.value > 10: + ret = in2.value * in1.value + else: + ret = in2.value + in1.value + out.set(ret) + =} } reactor Print { - input p_in + input p_in - reaction(p_in) {= print("Received: ", p_in.value) =} + reaction(p_in) {= print("Received: ", p_in.value) =} } main reactor Wcet { - source = new Source() - work = new Work() - print = new Print() + source = new Source() + work = new Work() + print = new Print() - source.out1 -> work.in1 - source.out2 -> work.in2 - work.out -> print.p_in + source.out1 -> work.in1 + source.out2 -> work.in2 + work.out -> print.p_in } diff --git a/test/Python/src/concurrent/AsyncCallback.lf b/test/Python/src/concurrent/AsyncCallback.lf index a85905c5fd..5ef4167bed 100644 --- a/test/Python/src/concurrent/AsyncCallback.lf +++ b/test/Python/src/concurrent/AsyncCallback.lf @@ -1,6 +1,7 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test periodically creates a - * concurrent Python thread that schedule a physical action twice. + * Test asynchronous callbacks that trigger a physical action. This test + * periodically creates a concurrent Python thread that schedule a physical + * action twice. */ target Python { timeout: 2 sec diff --git a/test/Python/src/concurrent/AsyncCallbackNoTimer.lf b/test/Python/src/concurrent/AsyncCallbackNoTimer.lf index a51ff9acdb..4e481d1d34 100644 --- a/test/Python/src/concurrent/AsyncCallbackNoTimer.lf +++ b/test/Python/src/concurrent/AsyncCallbackNoTimer.lf @@ -1,11 +1,11 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test creates a concurrent Python - * thread that schedule a physical action twice. + * Test asynchronous callbacks that trigger a physical action. This test creates + * a concurrent Python thread that schedule a physical action twice. * - * There are no timers in this test to drive the logical time forward. This is important in the - * Python target since the user Python threads should be allowed to execute independently of the - * underlying C core runtime, without the C runtime polling the Python context with a reaction to a - * timer. + * There are no timers in this test to drive the logical time forward. This is + * important in the Python target since the user Python threads should be + * allowed to execute independently of the underlying C core runtime, without + * the C runtime polling the Python context with a reaction to a timer. */ target Python { timeout: 2 sec diff --git a/test/Python/src/docker/HelloWorldContainerized.lf b/test/Python/src/docker/HelloWorldContainerized.lf index 1518dd0583..26e684c580 100644 --- a/test/Python/src/docker/HelloWorldContainerized.lf +++ b/test/Python/src/docker/HelloWorldContainerized.lf @@ -1,9 +1,9 @@ target Python { - docker: true + docker: true } import HelloWorld2 from "../HelloWorld.lf" main reactor { - a = new HelloWorld2() + a = new HelloWorld2() } diff --git a/test/Python/src/docker/PingPongContainerized.lf b/test/Python/src/docker/PingPongContainerized.lf index 4b9c772e2e..1539a12615 100644 --- a/test/Python/src/docker/PingPongContainerized.lf +++ b/test/Python/src/docker/PingPongContainerized.lf @@ -18,16 +18,16 @@ * @author Edward A. Lee */ target Python { - fast: true, - docker: true + fast: true, + docker: true } import Ping from "../PingPong.lf" import Pong from "../PingPong.lf" main reactor PingPongContainerized { - ping = new Ping() - pong = new Pong() - ping.send -> pong.receive - pong.send -> ping.receive + ping = new Ping() + pong = new Pong() + ping.send -> pong.receive + pong.send -> ping.receive } diff --git a/test/Python/src/docker/federated/DistributedCountContainerized.lf b/test/Python/src/docker/federated/DistributedCountContainerized.lf index c2f9f7b0d5..5f8a348d24 100644 --- a/test/Python/src/docker/federated/DistributedCountContainerized.lf +++ b/test/Python/src/docker/federated/DistributedCountContainerized.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python { diff --git a/test/Python/src/docker/federated/DistributedDoublePortContainerized.lf b/test/Python/src/docker/federated/DistributedDoublePortContainerized.lf index 1aa2b1e640..6ae8fa6492 100644 --- a/test/Python/src/docker/federated/DistributedDoublePortContainerized.lf +++ b/test/Python/src/docker/federated/DistributedDoublePortContainerized.lf @@ -5,10 +5,10 @@ * @author Soroush Bateni */ target Python { - timeout: 900 msec, - logging: DEBUG, - coordination: centralized, - docker: true + timeout: 900 msec, + logging: DEBUG, + coordination: centralized, + docker: true } import Count from "../../lib/Count.lf" @@ -16,9 +16,9 @@ import CountMicrostep from "../../federated/DistributedDoublePort.lf" import Print from "../../federated/DistributedDoublePort.lf" federated reactor DistributedDoublePortContainerized at rti { - c = new Count() - cm = new CountMicrostep() - p = new Print() - c.out -> p.in_ # Indicating a 'logical' connection. - cm.out -> p.in2 + c = new Count() + cm = new CountMicrostep() + p = new Print() + c.out -> p.in_ # Indicating a 'logical' connection. + cm.out -> p.in2 } diff --git a/test/Python/src/docker/federated/DistributedMultiportContainerized.lf b/test/Python/src/docker/federated/DistributedMultiportContainerized.lf index f0c9870bd6..b4333d8c00 100644 --- a/test/Python/src/docker/federated/DistributedMultiportContainerized.lf +++ b/test/Python/src/docker/federated/DistributedMultiportContainerized.lf @@ -1,14 +1,14 @@ # Check multiport connections between federates. target Python { - timeout: 1 sec, - coordination: centralized, - docker: true + timeout: 1 sec, + coordination: centralized, + docker: true } import Source, Destination from "../../federated/DistributedMultiport.lf" federated reactor DistributedMultiportContainerized at rti { - s = new Source() - d = new Destination() - s.out -> d.in_ + s = new Source() + d = new Destination() + s.out -> d.in_ } diff --git a/test/Python/src/docker/federated/DistributedSendClassContainerized.lf b/test/Python/src/docker/federated/DistributedSendClassContainerized.lf index 5f6ccd66dd..797a017146 100644 --- a/test/Python/src/docker/federated/DistributedSendClassContainerized.lf +++ b/test/Python/src/docker/federated/DistributedSendClassContainerized.lf @@ -1,12 +1,12 @@ target Python { - coordination: centralized, - docker: true + coordination: centralized, + docker: true } import A, B from "../../federated/DistributedSendClass.lf" federated reactor at rti { - a = new A() - b = new B() - b.o -> a.o + a = new A() + b = new B() + b.o -> a.o } diff --git a/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf b/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf index 11e24746cd..911f0f3055 100644 --- a/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf +++ b/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf @@ -5,14 +5,14 @@ * @author Soroush Bateni */ target Python { - coordination: decentralized, - docker: true + coordination: decentralized, + docker: true } import Sender, Receiver from "../../federated/DistributedStop.lf" federated reactor DistributedStopDecentralizedContainerized at rti { - sender = new Sender() - receiver = new Receiver() - sender.out -> receiver.in_ + sender = new Sender() + receiver = new Receiver() + sender.out -> receiver.in_ } diff --git a/test/Python/src/federated/BroadcastFeedback.lf b/test/Python/src/federated/BroadcastFeedback.lf index 06fcd95037..75d313e61d 100644 --- a/test/Python/src/federated/BroadcastFeedback.lf +++ b/test/Python/src/federated/BroadcastFeedback.lf @@ -1,4 +1,6 @@ -/** This tests an output that is broadcast back to a multiport input of a bank. */ +/** + * This tests an output that is broadcast back to a multiport input of a bank. + */ target Python { timeout: 1 sec } diff --git a/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf b/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf index d3e371b037..ad2a11c10c 100644 --- a/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf +++ b/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf @@ -1,4 +1,6 @@ -/** This tests an output that is broadcast back to a multiport input of a bank. */ +/** + * This tests an output that is broadcast back to a multiport input of a bank. + */ target Python { timeout: 1 sec } diff --git a/test/Python/src/federated/ChainWithDelay.lf b/test/Python/src/federated/ChainWithDelay.lf index b8fb6208a9..8199b0b319 100644 --- a/test/Python/src/federated/ChainWithDelay.lf +++ b/test/Python/src/federated/ChainWithDelay.lf @@ -4,7 +4,7 @@ * @author Edward A. Lee */ target Python { - timeout: 3 msec + timeout: 3 msec } import Count from "../lib/Count.lf" @@ -12,9 +12,9 @@ import InternalDelay from "../lib/InternalDelay.lf" import TestCount from "../lib/TestCount.lf" federated reactor { - c = new Count(period = 1 msec) - i = new InternalDelay(delay = 500 usec) - t = new TestCount(num_inputs = 3) - c.out -> i.in_ - i.out -> t.in_ + c = new Count(period = 1 msec) + i = new InternalDelay(delay = 500 usec) + t = new TestCount(num_inputs = 3) + c.out -> i.in_ + i.out -> t.in_ } diff --git a/test/Python/src/federated/CycleDetection.lf b/test/Python/src/federated/CycleDetection.lf index 5039f3f375..cf9b6d6b54 100644 --- a/test/Python/src/federated/CycleDetection.lf +++ b/test/Python/src/federated/CycleDetection.lf @@ -1,6 +1,6 @@ /** - * Check whether the internally generated network and control reactions introduce a cycle or not. - * The failure for this test is not being compiled. + * Check whether the internally generated network and control reactions + * introduce a cycle or not. The failure for this test is not being compiled. * @author Edward A. Lee */ target Python diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf index a56a8f07ba..48ff7a4ca7 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf @@ -1,7 +1,8 @@ /** - * Test a source-destination scenario where the source falls behind real-time, and reaches the - * timeout much later than the destination. In this test, the destination closes the connection - * early, causing the transmission to fail. Warnings will be printed about lost messages. + * Test a source-destination scenario where the source falls behind real-time, + * and reaches the timeout much later than the destination. In this test, the + * destination closes the connection early, causing the transmission to fail. + * Warnings will be printed about lost messages. * * The test fails if the federation does not exit. */ diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index d065783f5a..4eb881694f 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -1,10 +1,11 @@ /** - * Test a source-destination scenario where the source falls behind real-time, and reaches the - * timeout much later than the destination. In this test, the destination closes the connection - * early, causing the transmission to fail. Warnings will be printed. + * Test a source-destination scenario where the source falls behind real-time, + * and reaches the timeout much later than the destination. In this test, the + * destination closes the connection early, causing the transmission to fail. + * Warnings will be printed. * - * The test fails if the federation does not exit amenably. This variant has a physical connection - * between source and destination. + * The test fails if the federation does not exit amenably. This variant has a + * physical connection between source and destination. */ target Python { timeout: 1 msec, diff --git a/test/Python/src/federated/DistributedCount.lf b/test/Python/src/federated/DistributedCount.lf index 6492c4fa32..7713256520 100644 --- a/test/Python/src/federated/DistributedCount.lf +++ b/test/Python/src/federated/DistributedCount.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python { diff --git a/test/Python/src/federated/DistributedCountDecentralized.lf b/test/Python/src/federated/DistributedCountDecentralized.lf index 92cae03850..e86adf9946 100644 --- a/test/Python/src/federated/DistributedCountDecentralized.lf +++ b/test/Python/src/federated/DistributedCountDecentralized.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee */ # reason for failing: in_.intended_tag are not supported in python target @@ -40,5 +41,6 @@ reactor Print { federated reactor DistributedCountDecentralized { c = new Count() p = new Print() - c.out -> p.in_ after 200 msec # Indicating a 'logical' connection with a large enough delay. + # Indicating a 'logical' connection with a large enough delay. + c.out -> p.in_ after 200 msec } diff --git a/test/Python/src/federated/DistributedCountPhysical.lf b/test/Python/src/federated/DistributedCountPhysical.lf index c6ef7e2425..69bc2faee9 100644 --- a/test/Python/src/federated/DistributedCountPhysical.lf +++ b/test/Python/src/federated/DistributedCountPhysical.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages only over connections that are marked 'physical' (using the ~> - * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is - * needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages only over connections that are + * marked 'physical' (using the ~> arrow). Therefore, no additional coordination + * of the advancement of time (HLA or Ptides) is needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf index 065cfa83c4..105413d0a0 100644 --- a/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf +++ b/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages only over connections that are marked 'physical' (using the ~> - * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is - * needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages only over connections that are + * marked 'physical' (using the ~> arrow). Therefore, no additional coordination + * of the advancement of time (HLA or Ptides) is needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf b/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf index 1b73f7e8e6..0008479138 100644 --- a/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf +++ b/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf @@ -1,8 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages only over connections that are marked 'physical' (using the ~> - * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is - * needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages only over connections that are + * marked 'physical' (using the ~> arrow). Therefore, no additional coordination + * of the advancement of time (HLA or Ptides) is needed. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/Python/src/federated/DistributedDoublePort.lf b/test/Python/src/federated/DistributedDoublePort.lf index fe0a71dcc1..9eb24209e6 100644 --- a/test/Python/src/federated/DistributedDoublePort.lf +++ b/test/Python/src/federated/DistributedDoublePort.lf @@ -1,6 +1,7 @@ /** - * Test the case for when two upstream federates send messages to a downstream federte on two - * different ports. One message should carry a microstep delay relative to the other message. + * Test the case for when two upstream federates send messages to a downstream + * federte on two different ports. One message should carry a microstep delay + * relative to the other message. * * @author Soroush Bateni */ @@ -39,7 +40,9 @@ reactor Print { self.sys.exit(1) =} - reaction(shutdown) {= print("SUCCESS: messages were at least one microstep apart.") =} + reaction(shutdown) {= + print("SUCCESS: messages were at least one microstep apart.") + =} } federated reactor DistributedDoublePort { diff --git a/test/Python/src/federated/DistributedLoopedAction.lf b/test/Python/src/federated/DistributedLoopedAction.lf index a7564d5b28..8f71d15363 100644 --- a/test/Python/src/federated/DistributedLoopedAction.lf +++ b/test/Python/src/federated/DistributedLoopedAction.lf @@ -1,5 +1,6 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken into account. + * Test a sender-receiver network system that relies on microsteps being taken + * into account. * * @author Soroush Bateni */ @@ -17,7 +18,8 @@ reactor Receiver(take_a_break_after = 10, break_interval = 400 msec) { state breaks = 0 timer t(0, 1 msec) # This will impact the performance - # but forces the logical time to advance Comment this line for a more sensible log output. + # but forces the logical time to advance Comment this line for a more + # sensible log output. reaction(in_) {= print("At tag ({}, {}) received value {}.".format( lf.time.logical_elapsed(), diff --git a/test/Python/src/federated/DistributedLoopedPhysicalActionDecentralized.lf b/test/Python/src/federated/DistributedLoopedPhysicalActionDecentralized.lf index 0cf1b5d22e..773d483004 100644 --- a/test/Python/src/federated/DistributedLoopedPhysicalActionDecentralized.lf +++ b/test/Python/src/federated/DistributedLoopedPhysicalActionDecentralized.lf @@ -4,15 +4,15 @@ * @author Soroush Bateni */ target Python { - timeout: 1 sec, - coordination: decentralized + timeout: 1 sec, + coordination: decentralized } import Sender, Receiver from "DistributedLoopedPhysicalAction.lf" federated reactor { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in_ + sender.out -> receiver.in_ } diff --git a/test/Python/src/federated/DistributedMultiportToken.lf b/test/Python/src/federated/DistributedMultiportToken.lf index 974f6f62fa..284e1c21a3 100644 --- a/test/Python/src/federated/DistributedMultiportToken.lf +++ b/test/Python/src/federated/DistributedMultiportToken.lf @@ -1,5 +1,5 @@ -# Check multiport connections between federates where the message is carried by a Token (in this -# case, with an array of char). +# Check multiport connections between federates where the message is carried by +# a Token (in this case, with an array of char). target Python { timeout: 1 sec, coordination: centralized diff --git a/test/Python/src/federated/DistributedNoReact.lf b/test/Python/src/federated/DistributedNoReact.lf index d5692a6cec..39f51b609a 100644 --- a/test/Python/src/federated/DistributedNoReact.lf +++ b/test/Python/src/federated/DistributedNoReact.lf @@ -1,25 +1,25 @@ target Python { - timeout: 2 sec + timeout: 2 sec } preamble {= - class C: - def __init__(self): - pass + class C: + def __init__(self): + pass =} reactor A { - input o + input o } reactor B { - output o + output o - reaction(startup) -> o {= o.set(C()) =} + reaction(startup) -> o {= o.set(C()) =} } federated reactor { - a = new A() - b = new B() - b.o -> a.o + a = new A() + b = new B() + b.o -> a.o } diff --git a/test/Python/src/federated/DistributedStopDecentralized.lf b/test/Python/src/federated/DistributedStopDecentralized.lf index e6afa6384b..d76154f487 100644 --- a/test/Python/src/federated/DistributedStopDecentralized.lf +++ b/test/Python/src/federated/DistributedStopDecentralized.lf @@ -7,14 +7,14 @@ # reason for failing: lf_tag().microstep and lf.tag_compare() are not not # supported in python target target Python { - coordination: decentralized + coordination: decentralized } import Sender, Receiver from "DistributedStop.lf" federated reactor DistributedStopDecentralized { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in_ + sender.out -> receiver.in_ } diff --git a/test/Python/src/federated/DistributedStructAsType.lf b/test/Python/src/federated/DistributedStructAsType.lf index eeebf1b7e7..36a3151289 100644 --- a/test/Python/src/federated/DistributedStructAsType.lf +++ b/test/Python/src/federated/DistributedStructAsType.lf @@ -1,6 +1,6 @@ target Python { - files: ../include/hello.py, - timeout: 2 secs + files: ../include/hello.py, + timeout: 2 secs } import Source, Print from "../StructAsType.lf" @@ -8,7 +8,7 @@ import Source, Print from "../StructAsType.lf" preamble {= import hello =} federated reactor { - s = new Source() - p = new Print() - s.out -> p._in + s = new Source() + p = new Print() + s.out -> p._in } diff --git a/test/Python/src/federated/DistributedStructAsTypeDirect.lf b/test/Python/src/federated/DistributedStructAsTypeDirect.lf index abb1d936ce..b74ba275b5 100644 --- a/test/Python/src/federated/DistributedStructAsTypeDirect.lf +++ b/test/Python/src/federated/DistributedStructAsTypeDirect.lf @@ -1,6 +1,6 @@ target Python { - files: ../include/hello.py, - timeout: 2 secs + files: ../include/hello.py, + timeout: 2 secs } import Source, Print from "../StructAsTypeDirect.lf" @@ -8,7 +8,7 @@ import Source, Print from "../StructAsTypeDirect.lf" preamble {= import hello =} federated reactor { - s = new Source() - p = new Print() - s.out -> p._in + s = new Source() + p = new Print() + s.out -> p._in } diff --git a/test/Python/src/federated/DistributedStructParallel.lf b/test/Python/src/federated/DistributedStructParallel.lf index 34a2f84e32..332f315bec 100644 --- a/test/Python/src/federated/DistributedStructParallel.lf +++ b/test/Python/src/federated/DistributedStructParallel.lf @@ -1,8 +1,8 @@ # Source allocates a class object and then sends it to two reactors, each of which want to modify # it. target Python { - files: ["../include/hello.py"], - timeout: 2 secs + files: ["../include/hello.py"], + timeout: 2 secs } import Source from "../StructScale.lf" @@ -11,13 +11,13 @@ import Check, Print from "../StructParallel.lf" preamble {= import hello =} federated reactor { - s = new Source() - c1 = new Print() - c2 = new Print(scale = 3) - p1 = new Check(expected = 84) - p2 = new Check(expected = 126) - s.out -> c1._in - s.out -> c2._in - c1.out -> p1._in - c2.out -> p2._in + s = new Source() + c1 = new Print() + c2 = new Print(scale = 3) + p1 = new Check(expected = 84) + p2 = new Check(expected = 126) + s.out -> c1._in + s.out -> c2._in + c1.out -> p1._in + c2.out -> p2._in } diff --git a/test/Python/src/federated/DistributedStructPrint.lf b/test/Python/src/federated/DistributedStructPrint.lf index b424dabacf..829b298b28 100644 --- a/test/Python/src/federated/DistributedStructPrint.lf +++ b/test/Python/src/federated/DistributedStructPrint.lf @@ -1,8 +1,8 @@ # Source produces a dynamically allocated class object, which it passes to Print. Reference counting # ensures that the struct is freed. target Python { - files: ["../include/hello.py"], - timeout: 2 sec + files: ["../include/hello.py"], + timeout: 2 sec } import Print, Check from "../StructPrint.lf" @@ -10,7 +10,7 @@ import Print, Check from "../StructPrint.lf" preamble {= import hello =} federated reactor { - s = new Print() - p = new Check() - s.out -> p._in + s = new Print() + p = new Check() + s.out -> p._in } diff --git a/test/Python/src/federated/DistributedStructScale.lf b/test/Python/src/federated/DistributedStructScale.lf index 88867178f0..5156de1644 100644 --- a/test/Python/src/federated/DistributedStructScale.lf +++ b/test/Python/src/federated/DistributedStructScale.lf @@ -1,8 +1,8 @@ # Source produces a dynamically allocated class object, which it passes to Scale. Scale modifies it # and passes it to Print. target Python { - files: ["../include/hello.py"], - timeout: 2 sec + files: ["../include/hello.py"], + timeout: 2 sec } import Source, TestInput, Print from "../StructScale.lf" @@ -10,9 +10,9 @@ import Source, TestInput, Print from "../StructScale.lf" preamble {= import hello =} federated reactor { - s = new Source() - c = new Print() - p = new TestInput(expected = 84) - s.out -> c._in - c.out -> p._in + s = new Source() + c = new Print() + p = new TestInput(expected = 84) + s.out -> c._in + c.out -> p._in } diff --git a/test/Python/src/federated/HelloDistributed.lf b/test/Python/src/federated/HelloDistributed.lf index a56bef1062..ef99c3f793 100644 --- a/test/Python/src/federated/HelloDistributed.lf +++ b/test/Python/src/federated/HelloDistributed.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python @@ -39,7 +40,8 @@ reactor Destination { } federated reactor HelloDistributed at localhost { - # reaction(startup) {= print("Printing something in top-level federated reactor.") + # reaction(startup) {= print("Printing something in top-level federated + # reactor.") # =} Reactor s is in federate Source s = new Source() d = new Destination() # Reactor d is in federate Destination diff --git a/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf b/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf index d61fcc9100..2719fd57ba 100644 --- a/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf +++ b/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf @@ -1,6 +1,7 @@ /** - * This tests that the precedence order of reaction invocation is kept in the hierarchy of reactors - * when a feedback loop is present in centralized coordination. + * This tests that the precedence order of reaction invocation is kept in the + * hierarchy of reactors when a feedback loop is present in centralized + * coordination. * * @author Edward A. Lee * @author Soroush Bateni diff --git a/test/Python/src/federated/ParallelDestinations.lf b/test/Python/src/federated/ParallelDestinations.lf index d7e4dcd6fe..4c65ba4351 100644 --- a/test/Python/src/federated/ParallelDestinations.lf +++ b/test/Python/src/federated/ParallelDestinations.lf @@ -1,23 +1,23 @@ /** Test parallel connections for federated execution. */ target Python { - timeout: 2 sec + timeout: 2 sec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Source { - output[2] out - c1 = new Count() - c2 = new Count() + output[2] out + c1 = new Count() + c2 = new Count() - c1.out, c2.out -> out + c1.out, c2.out -> out } federated reactor { - s = new Source() - t1 = new TestCount(num_inputs = 3) - t2 = new TestCount(num_inputs = 3) + s = new Source() + t1 = new TestCount(num_inputs = 3) + t2 = new TestCount(num_inputs = 3) - s.out -> t1.in_, t2.in_ + s.out -> t1.in_, t2.in_ } diff --git a/test/Python/src/federated/ParallelSources.lf b/test/Python/src/federated/ParallelSources.lf index d4cf67ebe8..222cb6dab1 100644 --- a/test/Python/src/federated/ParallelSources.lf +++ b/test/Python/src/federated/ParallelSources.lf @@ -1,24 +1,24 @@ /** Test parallel connections for federated execution. */ target Python { - timeout: 2 sec + timeout: 2 sec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Destination { - input[2] in_ + input[2] in_ - t1 = new TestCount(num_inputs = 3) - t2 = new TestCount(num_inputs = 3) + t1 = new TestCount(num_inputs = 3) + t2 = new TestCount(num_inputs = 3) - in_ -> t1.in_, t2.in_ + in_ -> t1.in_, t2.in_ } federated reactor { - c1 = new Count() - c2 = new Count() - d = new Destination() + c1 = new Count() + c2 = new Count() + d = new Destination() - c1.out, c2.out -> d.in_ + c1.out, c2.out -> d.in_ } diff --git a/test/Python/src/federated/ParallelSourcesMultiport.lf b/test/Python/src/federated/ParallelSourcesMultiport.lf index f19b33281c..553b1f95ee 100644 --- a/test/Python/src/federated/ParallelSourcesMultiport.lf +++ b/test/Python/src/federated/ParallelSourcesMultiport.lf @@ -1,34 +1,34 @@ /** Test parallel connections for federated execution. */ target Python { - timeout: 2 sec + timeout: 2 sec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Source { - output[2] out - c1 = new Count() - c2 = new Count() + output[2] out + c1 = new Count() + c2 = new Count() - c1.out, c2.out -> out + c1.out, c2.out -> out } reactor Destination1 { - input[3] in_ + input[3] in_ - t1 = new TestCount(num_inputs = 3) - t2 = new TestCount(num_inputs = 3) - t3 = new TestCount(num_inputs = 3) + t1 = new TestCount(num_inputs = 3) + t2 = new TestCount(num_inputs = 3) + t3 = new TestCount(num_inputs = 3) - in_ -> t1.in_, t2.in_, t3.in_ + in_ -> t1.in_, t2.in_, t3.in_ } federated reactor { - s1 = new Source() - s2 = new Source() - d1 = new Destination1() - t4 = new TestCount(num_inputs = 3) + s1 = new Source() + s2 = new Source() + d1 = new Destination1() + t4 = new TestCount(num_inputs = 3) - s1.out, s2.out -> d1.in_, t4.in_ + s1.out, s2.out -> d1.in_, t4.in_ } diff --git a/test/Python/src/federated/PhysicalSTP.lf b/test/Python/src/federated/PhysicalSTP.lf index 50ee659eb3..5edc61df34 100644 --- a/test/Python/src/federated/PhysicalSTP.lf +++ b/test/Python/src/federated/PhysicalSTP.lf @@ -1,4 +1,7 @@ -/** This is a test that detects STP violations according to the physical time of message arrival. */ +/** + * This is a test that detects STP violations according to the physical time of + * message arrival. + */ target Python { timeout: 1900 msec, coordination: decentralized diff --git a/test/Python/src/federated/PingPongDistributed.lf b/test/Python/src/federated/PingPongDistributed.lf index 0fc7cf3353..0f58cbf7db 100644 --- a/test/Python/src/federated/PingPongDistributed.lf +++ b/test/Python/src/federated/PingPongDistributed.lf @@ -1,19 +1,21 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing - * overhead. This is based on https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure + * message-passing overhead. This is based on + * https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs and can be run on - * different machines. + * This is a distributed version, where Ping and Pong run in separate programs + * and can be run on different machines. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * Unthreaded: 97 msec Threaded: 265 msec Distributed: 53 seconds * - * There is no parallelism in this application, so it does not benefit from being being distributed. + * There is no parallelism in this application, so it does not benefit from + * being being distributed. * - * These measurements are total execution time, including startup and shutdown, of all three - * programs. + * These measurements are total execution time, including startup and shutdown, + * of all three programs. * * @author Edward A. Lee */ diff --git a/test/Python/src/lib/Imported.lf b/test/Python/src/lib/Imported.lf index f59f1e9dee..e23b300991 100644 --- a/test/Python/src/lib/Imported.lf +++ b/test/Python/src/lib/Imported.lf @@ -5,8 +5,8 @@ target Python import ImportedAgain from "./ImportedAgain.lf" reactor Imported { - input x - a = new ImportedAgain() + input x + a = new ImportedAgain() - reaction(x) -> a.x {= a.x.set(x.value) =} + reaction(x) -> a.x {= a.x.set(x.value) =} } diff --git a/test/Python/src/lib/ImportedAgain.lf b/test/Python/src/lib/ImportedAgain.lf index f29a5e6c83..9371712337 100644 --- a/test/Python/src/lib/ImportedAgain.lf +++ b/test/Python/src/lib/ImportedAgain.lf @@ -3,12 +3,12 @@ target Python reactor ImportedAgain { # import Imported from "Imported.lf" - input x # y = new Imported(); // FIXME: Address this bug + input x # y = new Imported(); // FIXME: Address this bug - reaction(x) {= - print("Received: " + str(x.value)) - if (x.value != 42): - print("ERROR: Expected input to be 42. Got: " + x.value) - exit(1) - =} + reaction(x) {= + print("Received: " + str(x.value)) + if (x.value != 42): + print("ERROR: Expected input to be 42. Got: " + x.value) + exit(1) + =} } diff --git a/test/Python/src/lib/ImportedComposition.lf b/test/Python/src/lib/ImportedComposition.lf index be1cdfb1a8..5eeb39420f 100644 --- a/test/Python/src/lib/ImportedComposition.lf +++ b/test/Python/src/lib/ImportedComposition.lf @@ -3,18 +3,18 @@ target Python reactor Gain { - input x - output y + input x + output y - reaction(x) -> y {= y.set(x.value * 2) =} + reaction(x) -> y {= y.set(x.value * 2) =} } reactor ImportedComposition { - input x - output y - g1 = new Gain() - g2 = new Gain() - x -> g1.x after 10 msec - g1.y -> g2.x after 30 msec - g2.y -> y after 15 msec + input x + output y + g1 = new Gain() + g2 = new Gain() + x -> g1.x after 10 msec + g1.y -> g2.x after 30 msec + g2.y -> y after 15 msec } diff --git a/test/Python/src/lib/LoopedActionSender.lf b/test/Python/src/lib/LoopedActionSender.lf index 674256ea45..9d4048d0ea 100644 --- a/test/Python/src/lib/LoopedActionSender.lf +++ b/test/Python/src/lib/LoopedActionSender.lf @@ -6,9 +6,10 @@ target Python /** - * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break after sending - * take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in + * consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break + * after sending take_a_break_after messages. */ reactor Sender(take_a_break_after = 10, break_interval = 400 msec) { output out diff --git a/test/Python/src/lib/TestCount.lf b/test/Python/src/lib/TestCount.lf index eb214fe25d..de611cbc69 100644 --- a/test/Python/src/lib/TestCount.lf +++ b/test/Python/src/lib/TestCount.lf @@ -1,6 +1,7 @@ /** - * Test that a counting sequence of inputs starts with the specified start parameter value, - * increments by the specified stride, and receives the specified number of inputs. + * Test that a counting sequence of inputs starts with the specified start + * parameter value, increments by the specified stride, and receives the + * specified number of inputs. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. diff --git a/test/Python/src/lib/TestCountMultiport.lf b/test/Python/src/lib/TestCountMultiport.lf index d584401bfa..c30572e4d5 100644 --- a/test/Python/src/lib/TestCountMultiport.lf +++ b/test/Python/src/lib/TestCountMultiport.lf @@ -1,12 +1,13 @@ /** - * Test that a counting sequence of inputs starts with the specified start parameter value, - * increments by the specified stride, and receives the specified number of inputs. This version has - * a multiport input, and each input is expected to be present and incremented over the previous - * input. + * Test that a counting sequence of inputs starts with the specified start + * parameter value, increments by the specified stride, and receives the + * specified number of inputs. This version has a multiport input, and each + * input is expected to be present and incremented over the previous input. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. - * @param num_inputs The number of inputs expected on each channel. Default is 1. + * @param num_inputs The number of inputs expected on each channel. Default is + * 1. */ target Python diff --git a/test/Python/src/modal_models/BanksCount3ModesSimple.lf b/test/Python/src/modal_models/BanksCount3ModesSimple.lf index a2142d2e36..f36a82178a 100644 --- a/test/Python/src/modal_models/BanksCount3ModesSimple.lf +++ b/test/Python/src/modal_models/BanksCount3ModesSimple.lf @@ -1,31 +1,31 @@ /** Modal Reactor Test. Tests cycling through modes with banks of reactors. */ target Python { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } import TraceTesting from "util/TraceTesting.lf" import CounterCycle from "Count3Modes.lf" main reactor { - timer stepper(0, 250 msec) - counters = new[3] CounterCycle() - test = new TraceTesting(events_size = 3, trace = ( // keep-format - 0,1,1,1,1,1,1, - 250000000,1,2,1,2,1,2, - 250000000,1,3,1,3,1,3, - 250000000,1,1,1,1,1,1, - 250000000,1,2,1,2,1,2, - 250000000,1,3,1,3,1,3, - 250000000,1,1,1,1,1,1, - 250000000,1,2,1,2,1,2, - 250000000,1,3,1,3,1,3 - ), training = False) + timer stepper(0, 250 msec) + counters = new[3] CounterCycle() + test = new TraceTesting(events_size = 3, trace = ( // keep-format + 0,1,1,1,1,1,1, + 250000000,1,2,1,2,1,2, + 250000000,1,3,1,3,1,3, + 250000000,1,1,1,1,1,1, + 250000000,1,2,1,2,1,2, + 250000000,1,3,1,3,1,3, + 250000000,1,1,1,1,1,1, + 250000000,1,2,1,2,1,2, + 250000000,1,3,1,3,1,3 + ), training = False) - counters.count -> test.events + counters.count -> test.events - reaction(stepper) -> counters.next {= # Trigger - for counter in counters: - counter.next.set(True) - =} + reaction(stepper) -> counters.next {= # Trigger + for counter in counters: + counter.next.set(True) + =} } diff --git a/test/Python/src/modal_models/BanksModalStateReset.lf b/test/Python/src/modal_models/BanksModalStateReset.lf index 00a1a7ca4f..f96a7bd638 100644 --- a/test/Python/src/modal_models/BanksModalStateReset.lf +++ b/test/Python/src/modal_models/BanksModalStateReset.lf @@ -1,4 +1,7 @@ -/** Modal Reactor Test. Tests reset of state variables in modes with banks of reactors. */ +/** + * Modal Reactor Test. Tests reset of state variables in modes with banks of + * reactors. + */ target Python { fast: false, timeout: 4 sec @@ -45,7 +48,8 @@ main reactor { reset2.count2 -> test.events - reaction(stepper) -> reset1.next {= # Trigger mode change (separately because of #1278) + # Trigger mode change (separately because of #1278) + reaction(stepper) -> reset1.next {= for i in range(len(reset1)): reset1[i].next.set(True) =} diff --git a/test/Python/src/modal_models/ConvertCaseTest.lf b/test/Python/src/modal_models/ConvertCaseTest.lf index 3f31a7100b..f3bdee59fe 100644 --- a/test/Python/src/modal_models/ConvertCaseTest.lf +++ b/test/Python/src/modal_models/ConvertCaseTest.lf @@ -113,7 +113,9 @@ main reactor { history_processor.discard.set(True) =} - reaction(reset_processor.converted) {= print(f"Reset: {reset_processor.converted.value}") =} + reaction(reset_processor.converted) {= + print(f"Reset: {reset_processor.converted.value}") + =} reaction(history_processor.converted) {= print(f"History: {history_processor.converted.value}") diff --git a/test/Python/src/modal_models/ModalActions.lf b/test/Python/src/modal_models/ModalActions.lf index 2d148e89ef..b74f92f3c9 100644 --- a/test/Python/src/modal_models/ModalActions.lf +++ b/test/Python/src/modal_models/ModalActions.lf @@ -1,6 +1,6 @@ /** - * Modal Reactor Test. Tests actions, their suspension during mode inactivity and continuation of - * delays with history transitions. + * Modal Reactor Test. Tests actions, their suspension during mode inactivity + * and continuation of delays with history transitions. */ target Python { fast: false, @@ -90,5 +90,6 @@ main reactor { modal.action2_exec -> test.events - reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change + # Trigger mode change + reaction(stepper) -> modal.next {= modal.next.set(True) =} } diff --git a/test/Python/src/modal_models/ModalCycleBreaker.lf b/test/Python/src/modal_models/ModalCycleBreaker.lf index d3af61d142..1ceb2eb5d0 100644 --- a/test/Python/src/modal_models/ModalCycleBreaker.lf +++ b/test/Python/src/modal_models/ModalCycleBreaker.lf @@ -1,8 +1,8 @@ /** * Modal Reactor Test. * - * Tests if connections in the same reactor that have the same destination work if they are located - * in separate modes. + * Tests if connections in the same reactor that have the same destination work + * if they are located in separate modes. */ target Python { fast: false, @@ -16,7 +16,9 @@ reactor Modal { input in2 output out - mode Two { # Defining reaction to in2 before in1 would cause cycle if no mode were present + # Defining reaction to in2 before in1 would cause cycle if no mode were + # present + mode Two { timer wait(150 msec, 1 sec) reaction(in2) {= =} diff --git a/test/Python/src/modal_models/ModalNestedReactions.lf b/test/Python/src/modal_models/ModalNestedReactions.lf index 67247ac12f..2a9dc780f0 100644 --- a/test/Python/src/modal_models/ModalNestedReactions.lf +++ b/test/Python/src/modal_models/ModalNestedReactions.lf @@ -1,67 +1,67 @@ /** Modal Reactor Test. Checks disabling of reactions indirectly nested in an inactive mode */ target Python { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } reactor CounterCycle { - input next + input next - output count - output only_in_two - output never + output count + output only_in_two + output never - initial mode One { - reaction(next) -> count, reset(Two) {= - count.set(1) - Two.set() - =} - } + initial mode One { + reaction(next) -> count, reset(Two) {= + count.set(1) + Two.set() + =} + } - mode Two { - fwd = new Forward() - next -> fwd.inp - fwd.out -> only_in_two - reaction(next) -> count, reset(One) {= - count.set(2) - One.set() - =} - } + mode Two { + fwd = new Forward() + next -> fwd.inp + fwd.out -> only_in_two + reaction(next) -> count, reset(One) {= + count.set(2) + One.set() + =} + } - mode Three { - reaction(next) -> never {= never.set(True) =} - } + mode Three { + reaction(next) -> never {= never.set(True) =} + } } reactor Forward { - input inp - output out + input inp + output out - reaction(inp) -> out {= out.set(inp.value) =} + reaction(inp) -> out {= out.set(inp.value) =} } main reactor { - timer stepper(0, 250 msec) - counter = new CounterCycle() + timer stepper(0, 250 msec) + counter = new CounterCycle() - reaction(stepper) -> counter.next {= counter.next.set(True) =} # Trigger + reaction(stepper) -> counter.next {= counter.next.set(True) =} # Trigger - reaction(stepper) counter.count, counter.only_in_two {= # Check - print(counter.count.value) + reaction(stepper) counter.count, counter.only_in_two {= # Check + print(counter.count.value) - if counter.count.is_present is not True: - sys.stderr.write("ERROR: Missing mode change.\n") - exit(1) - elif counter.only_in_two.is_present and (counter.count.value != 2): - sys.stderr.write("ERROR: Indirectly nested reaction was not properly deactivated.\n") - exit(2) - elif counter.only_in_two.is_present is not True and (counter.count.value == 2): - sys.stderr.write("ERROR: Missing output from indirectly nested reaction.\n") - exit(3) - =} + if counter.count.is_present is not True: + sys.stderr.write("ERROR: Missing mode change.\n") + exit(1) + elif counter.only_in_two.is_present and (counter.count.value != 2): + sys.stderr.write("ERROR: Indirectly nested reaction was not properly deactivated.\n") + exit(2) + elif counter.only_in_two.is_present is not True and (counter.count.value == 2): + sys.stderr.write("ERROR: Missing output from indirectly nested reaction.\n") + exit(3) + =} - reaction(counter.never) {= - sys.stderr.write("ERROR: Detected output from unreachable mode.\n") - exit(4) - =} + reaction(counter.never) {= + sys.stderr.write("ERROR: Detected output from unreachable mode.\n") + exit(4) + =} } diff --git a/test/Python/src/modal_models/ModalStartupShutdown.lf b/test/Python/src/modal_models/ModalStartupShutdown.lf index ba8439e276..c7a868eeca 100644 --- a/test/Python/src/modal_models/ModalStartupShutdown.lf +++ b/test/Python/src/modal_models/ModalStartupShutdown.lf @@ -137,5 +137,6 @@ main reactor { modal.shutdown5 -> test.events - reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change + # Trigger mode change + reaction(stepper) -> modal.next {= modal.next.set(True) =} } diff --git a/test/Python/src/modal_models/ModalStateReset.lf b/test/Python/src/modal_models/ModalStateReset.lf index d52161cede..11b7425b63 100644 --- a/test/Python/src/modal_models/ModalStateReset.lf +++ b/test/Python/src/modal_models/ModalStateReset.lf @@ -87,5 +87,6 @@ main reactor { modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events - reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change + # Trigger mode change + reaction(stepper) -> modal.next {= modal.next.set(True) =} } diff --git a/test/Python/src/modal_models/ModalStateResetAuto.lf b/test/Python/src/modal_models/ModalStateResetAuto.lf index a8348592a5..492e12259b 100644 --- a/test/Python/src/modal_models/ModalStateResetAuto.lf +++ b/test/Python/src/modal_models/ModalStateResetAuto.lf @@ -83,5 +83,6 @@ main reactor { modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events - reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change + # Trigger mode change + reaction(stepper) -> modal.next {= modal.next.set(True) =} } diff --git a/test/Python/src/modal_models/ModalTimers.lf b/test/Python/src/modal_models/ModalTimers.lf index 8198e5dcb1..271a19ec38 100644 --- a/test/Python/src/modal_models/ModalTimers.lf +++ b/test/Python/src/modal_models/ModalTimers.lf @@ -62,5 +62,6 @@ main reactor { modal.mode_switch, modal.timer1, modal.timer2 -> test.events - reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change + # Trigger mode change + reaction(stepper) -> modal.next {= modal.next.set(True) =} } diff --git a/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf b/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf index 274d97a9f7..3dd42f67ce 100644 --- a/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf +++ b/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf @@ -1,8 +1,8 @@ /** * Modal Reactor Test. * - * Tests if connections in the same reactor that have the same destination work if they are located - * in separate modes. + * Tests if connections in the same reactor that have the same destination work + * if they are located in separate modes. */ target Python { fast: false, @@ -66,7 +66,9 @@ main reactor { modal.count -> test.events - reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change + # Trigger mode change + reaction(stepper) -> modal.next {= modal.next.set(True) =} - reaction(modal.count) {= print(modal.count.value) =} # Print + # Print + reaction(modal.count) {= print(modal.count.value) =} } diff --git a/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf b/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf index bda602904e..86f5668357 100644 --- a/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf +++ b/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf @@ -1,8 +1,8 @@ /** * Modal Reactor Test. * - * Tests if a connection and a reaction in the same reactor can have the same destination if they - * are located in separate modes. + * Tests if a connection and a reaction in the same reactor can have the same + * destination if they are located in separate modes. */ target Python { fast: false, @@ -23,7 +23,9 @@ reactor Modal { mode Two { counter2 = new Counter(period = 100 msec) - reaction(counter2.value) -> count {= count.set(counter2.value.value * 10) =} + reaction(counter2.value) -> count {= + count.set(counter2.value.value * 10) + =} reaction(next) -> history(One) {= One.set() =} } @@ -67,7 +69,9 @@ main reactor { modal.count -> test.events - reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change + # Trigger mode change + reaction(stepper) -> modal.next {= modal.next.set(True) =} - reaction(modal.count) {= print(modal.count.value) =} # Print + # Print + reaction(modal.count) {= print(modal.count.value) =} } diff --git a/test/Python/src/multiport/BankReactionsInContainer.lf b/test/Python/src/multiport/BankReactionsInContainer.lf index c4eabf8d19..7316463c3d 100644 --- a/test/Python/src/multiport/BankReactionsInContainer.lf +++ b/test/Python/src/multiport/BankReactionsInContainer.lf @@ -1,4 +1,6 @@ -/** This tests an output that is broadcast back to a multiport input of a bank. */ +/** + * This tests an output that is broadcast back to a multiport input of a bank. + */ target Python { timeout: 1 sec } diff --git a/test/Python/src/multiport/BroadcastAfter.lf b/test/Python/src/multiport/BroadcastAfter.lf index a2e1e2e6ef..21cbf4d885 100644 --- a/test/Python/src/multiport/BroadcastAfter.lf +++ b/test/Python/src/multiport/BroadcastAfter.lf @@ -1,12 +1,12 @@ target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Source, Destination from "Broadcast.lf" main reactor { - a = new Source() - b = new[4] Destination(delay = 1 sec) - (a.out)+ -> b._in after 1 sec + a = new Source() + b = new[4] Destination(delay = 1 sec) + (a.out)+ -> b._in after 1 sec } diff --git a/test/Python/src/multiport/MultiportFromBank.lf b/test/Python/src/multiport/MultiportFromBank.lf index 092458f76d..92d9363df5 100644 --- a/test/Python/src/multiport/MultiportFromBank.lf +++ b/test/Python/src/multiport/MultiportFromBank.lf @@ -1,5 +1,5 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -# sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than +# the width of the sending port. target Python { timeout: 2 sec, fast: true @@ -8,7 +8,9 @@ target Python { reactor Source(check_override = 0, bank_index = 0) { output out - reaction(startup) -> out {= out.set(self.bank_index * self.check_override) =} + reaction(startup) -> out {= + out.set(self.bank_index * self.check_override) + =} } reactor Destination { diff --git a/test/Python/src/multiport/MultiportFromBankHierarchy.lf b/test/Python/src/multiport/MultiportFromBankHierarchy.lf index 13cf078224..27ecb3c80b 100644 --- a/test/Python/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/Python/src/multiport/MultiportFromBankHierarchy.lf @@ -1,5 +1,5 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -# sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than +# the width of the sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/Python/src/multiport/MultiportFromBankHierarchyAfter.lf index 2466b78574..d23f294dde 100644 --- a/test/Python/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/Python/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,15 +1,15 @@ # Check multiport output to bank of recipients. Here, the bank is smaller than the width of the # sending port. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Container from "MultiportFromBankHierarchy.lf" import Destination from "MultiportFromBank.lf" main reactor MultiportFromBankHierarchyAfter { - a = new Container() - b = new Destination() - a.out -> b._in after 1 sec + a = new Container() + b = new Destination() + a.out -> b._in after 1 sec } diff --git a/test/Python/src/multiport/MultiportFromHierarchy.lf b/test/Python/src/multiport/MultiportFromHierarchy.lf index 83cdcad88a..4116587f01 100644 --- a/test/Python/src/multiport/MultiportFromHierarchy.lf +++ b/test/Python/src/multiport/MultiportFromHierarchy.lf @@ -1,4 +1,5 @@ -# Check multiport output to multiport input, where the former is a hierarchical reactor. +# Check multiport output to multiport input, where the former is a hierarchical +# reactor. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportIn.lf b/test/Python/src/multiport/MultiportIn.lf index feb5ef6d03..35bdee7341 100644 --- a/test/Python/src/multiport/MultiportIn.lf +++ b/test/Python/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -# This is a version fo the Threaded test that uses a multiport input at the destination. Its purpose -# is to test multiport inputs. +# This is a version fo the Threaded test that uses a multiport input at the +# destination. Its purpose is to test multiport inputs. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportInParameterized.lf b/test/Python/src/multiport/MultiportInParameterized.lf index ca10b50175..28b15808e3 100644 --- a/test/Python/src/multiport/MultiportInParameterized.lf +++ b/test/Python/src/multiport/MultiportInParameterized.lf @@ -1,5 +1,5 @@ -# This is a version of the Threaded test that uses a multiport input at the destination. Its purpose -# is to test multiport inputs. +# This is a version of the Threaded test that uses a multiport input at the +# destination. Its purpose is to test multiport inputs. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportMutableInput.lf b/test/Python/src/multiport/MultiportMutableInput.lf index e12855db04..f931900ef7 100644 --- a/test/Python/src/multiport/MultiportMutableInput.lf +++ b/test/Python/src/multiport/MultiportMutableInput.lf @@ -1,5 +1,6 @@ -# Source produces a ints on a multiport, which it passes to Scale. Scale requests a writable copy. -# It modifies it and passes it to Print. It gets freed after Print is done with it. +# Source produces a ints on a multiport, which it passes to Scale. Scale +# requests a writable copy. It modifies it and passes it to Print. It gets freed +# after Print is done with it. target Python reactor Source { diff --git a/test/Python/src/multiport/MultiportMutableInputArray.lf b/test/Python/src/multiport/MultiportMutableInputArray.lf index 5e37ccd6b2..9efa3eeebf 100644 --- a/test/Python/src/multiport/MultiportMutableInputArray.lf +++ b/test/Python/src/multiport/MultiportMutableInputArray.lf @@ -1,6 +1,7 @@ -# Source produces a list on a multiport, which it passes to Scale. Scale requests a writable copy, -# which, instead of copying, it just gets ownership of the original list. It modifies it and passes -# it to Print. It gets freed after Print is done with it. +# Source produces a list on a multiport, which it passes to Scale. Scale +# requests a writable copy, which, instead of copying, it just gets ownership of +# the original list. It modifies it and passes it to Print. It gets freed after +# Print is done with it. target Python reactor Source { diff --git a/test/Python/src/multiport/MultiportToBankAfter.lf b/test/Python/src/multiport/MultiportToBankAfter.lf index 6d3f6e7ed4..85fc91e513 100644 --- a/test/Python/src/multiport/MultiportToBankAfter.lf +++ b/test/Python/src/multiport/MultiportToBankAfter.lf @@ -1,4 +1,5 @@ -# Check multiport output to bank of recipients where the width of the bank is inferred. +# Check multiport output to bank of recipients where the width of the bank is +# inferred. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportToBankHierarchy.lf b/test/Python/src/multiport/MultiportToBankHierarchy.lf index bef01b8d89..f70fa8ad92 100644 --- a/test/Python/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Python/src/multiport/MultiportToBankHierarchy.lf @@ -1,5 +1,5 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -# sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than +# the width of the sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportToHierarchy.lf b/test/Python/src/multiport/MultiportToHierarchy.lf index 1e525b621d..2a9e25a5e6 100644 --- a/test/Python/src/multiport/MultiportToHierarchy.lf +++ b/test/Python/src/multiport/MultiportToHierarchy.lf @@ -1,5 +1,6 @@ -# Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that -# the destination reactor has width wider than the sender, so one input is dangling. +# Check multiport output to multiport input, where the latter is a hierarchical +# reactor. Note that the destination reactor has width wider than the sender, so +# one input is dangling. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportToMultiportArray.lf b/test/Python/src/multiport/MultiportToMultiportArray.lf index 42e885ea37..5eb043570d 100644 --- a/test/Python/src/multiport/MultiportToMultiportArray.lf +++ b/test/Python/src/multiport/MultiportToMultiportArray.lf @@ -1,4 +1,5 @@ -# Check multiport output to multiport input. Destination port is wider than sending port. +# Check multiport output to multiport input. Destination port is wider than +# sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/MultiportToPort.lf b/test/Python/src/multiport/MultiportToPort.lf index 893ad600b0..ebfbf81991 100644 --- a/test/Python/src/multiport/MultiportToPort.lf +++ b/test/Python/src/multiport/MultiportToPort.lf @@ -1,4 +1,5 @@ -# Check multiport output to multiport input. Destination port is wider than sending port. +# Check multiport output to multiport input. Destination port is wider than +# sending port. target Python { timeout: 2 sec, fast: true diff --git a/test/Python/src/multiport/PipelineAfter.lf b/test/Python/src/multiport/PipelineAfter.lf index ba423299d9..43048f04ca 100644 --- a/test/Python/src/multiport/PipelineAfter.lf +++ b/test/Python/src/multiport/PipelineAfter.lf @@ -1,36 +1,36 @@ target Python reactor Source { - output out + output out - reaction(startup) -> out {= out.set(40) =} + reaction(startup) -> out {= out.set(40) =} } reactor Compute { - input inp - output out + input inp + output out - reaction(inp) -> out {= out.set(inp.value + 2) =} + reaction(inp) -> out {= out.set(inp.value + 2) =} } reactor Sink { - input inp - - reaction(inp) {= - print(f"Received {inp.value}") - if inp.value != 42: - sys.stderr.write("ERROR: expected 42!\n") - exit(1) - if lf.time.logical_elapsed() != SEC(1): - sys.stderr.write("ERROR: Expected to receive input after one second.\n") - exit(2) - =} + input inp + + reaction(inp) {= + print(f"Received {inp.value}") + if inp.value != 42: + sys.stderr.write("ERROR: expected 42!\n") + exit(1) + if lf.time.logical_elapsed() != SEC(1): + sys.stderr.write("ERROR: Expected to receive input after one second.\n") + exit(2) + =} } main reactor { - source = new Source() - compute = new Compute() - sink = new Sink() + source = new Source() + compute = new Compute() + sink = new Sink() - source.out, compute.out -> compute.inp, sink.inp after 500 msec + source.out, compute.out -> compute.inp, sink.inp after 500 msec } diff --git a/test/Python/src/multiport/ReactionsToNested.lf b/test/Python/src/multiport/ReactionsToNested.lf index 5d1046fa24..2c207dffb0 100644 --- a/test/Python/src/multiport/ReactionsToNested.lf +++ b/test/Python/src/multiport/ReactionsToNested.lf @@ -1,4 +1,5 @@ -# This test connects a simple counting source to tester that checks against its own count. +# This test connects a simple counting source to tester that checks against its +# own count. target Python { timeout: 1 sec } diff --git a/test/Python/src/serialization/PersonProtocolBuffers.lf b/test/Python/src/serialization/PersonProtocolBuffers.lf index 530df50d8d..eb14cc8f9c 100644 --- a/test/Python/src/serialization/PersonProtocolBuffers.lf +++ b/test/Python/src/serialization/PersonProtocolBuffers.lf @@ -18,25 +18,25 @@ * typically at /usr/local/bin. */ target Python { - protobufs: Person.proto + protobufs: Person.proto } main reactor { - reaction(startup) {= - person = Person.Person() + reaction(startup) {= + person = Person.Person() - person.name = "Lingua Franca" - person.id = 1 - person.email = "eal@berkeley.edu" + person.name = "Lingua Franca" + person.id = 1 + person.email = "eal@berkeley.edu" - # Pack the message into buffer. - serialized_msg = person.SerializeToString() + # Pack the message into buffer. + serialized_msg = person.SerializeToString() - # Now unpack the message from buffer. - unpacked = Person.Person() - unpacked.ParseFromString(serialized_msg) + # Now unpack the message from buffer. + unpacked = Person.Person() + unpacked.ParseFromString(serialized_msg) - # Extract and print the unpacked message. - print("Name: ", unpacked.name) - =} + # Extract and print the unpacked message. + print("Name: ", unpacked.name) + =} } diff --git a/test/Python/src/serialization/ProtoNoPacking.lf b/test/Python/src/serialization/ProtoNoPacking.lf index 92e04fd5f5..9800645687 100644 --- a/test/Python/src/serialization/ProtoNoPacking.lf +++ b/test/Python/src/serialization/ProtoNoPacking.lf @@ -17,30 +17,30 @@ * typically at /usr/local/bin. */ target Python { - protobufs: ProtoHelloWorld.proto + protobufs: ProtoHelloWorld.proto } reactor SourceProto { - output out + output out - reaction(startup) -> out {= - message = ProtoHelloWorld.ProtoHelloWorld() - message.name = "Hello World" - message.number = 42 - out.set(message) - =} + reaction(startup) -> out {= + message = ProtoHelloWorld.ProtoHelloWorld() + message.name = "Hello World" + message.number = 42 + out.set(message) + =} } reactor SinkProto { - input _in + input _in - reaction(_in) {= - print("Received: name='{:s}', number={:d}.".format(_in.value.name, _in.value.number)) - =} + reaction(_in) {= + print("Received: name='{:s}', number={:d}.".format(_in.value.name, _in.value.number)) + =} } main reactor ProtoNoPacking { - s = new SourceProto() - d = new SinkProto() - s.out -> d._in + s = new SourceProto() + d = new SinkProto() + s.out -> d._in } diff --git a/test/Python/src/target/AfterNoTypes.lf b/test/Python/src/target/AfterNoTypes.lf index fb5597e863..44aaa89c73 100644 --- a/test/Python/src/target/AfterNoTypes.lf +++ b/test/Python/src/target/AfterNoTypes.lf @@ -1,5 +1,5 @@ -# This test demonstrates that after can be used on connections with ports that have no types. The -# test passes if the compile is succeeded +# This test demonstrates that after can be used on connections with ports that +# have no types. The test passes if the compile is succeeded target Python { fast: false, timeout: 3 sec diff --git a/test/Rust/src/ActionIsPresentDouble.lf b/test/Rust/src/ActionIsPresentDouble.lf index 361378a6bc..4aec9776be 100644 --- a/test/Rust/src/ActionIsPresentDouble.lf +++ b/test/Rust/src/ActionIsPresentDouble.lf @@ -2,20 +2,20 @@ target Rust main reactor ActionIsPresentDouble { - logical action act0 - logical action act1(100 msec) + logical action act0 + logical action act1(100 msec) - reaction(startup) -> act0, act1 {= - ctx.schedule(act0, after!(100 ms)); - ctx.schedule(act1, after!(0 ms)); - ctx.schedule(act1, Asap); - =} + reaction(startup) -> act0, act1 {= + ctx.schedule(act0, after!(100 ms)); + ctx.schedule(act1, after!(0 ms)); + ctx.schedule(act1, Asap); + =} - reaction(act1, act0) {= - assert!(ctx.is_present(act0)); - assert!(ctx.is_present(act1)); - if ctx.get_tag() == tag!(T0 + 100 ms) { - println!("success"); - } - =} + reaction(act1, act0) {= + assert!(ctx.is_present(act0)); + assert!(ctx.is_present(act1)); + if ctx.get_tag() == tag!(T0 + 100 ms) { + println!("success"); + } + =} } diff --git a/test/Rust/src/ActionValuesCleanup.lf b/test/Rust/src/ActionValuesCleanup.lf index 6bda6e9fd6..f4bab7a2b5 100644 --- a/test/Rust/src/ActionValuesCleanup.lf +++ b/test/Rust/src/ActionValuesCleanup.lf @@ -22,7 +22,9 @@ main reactor ActionValuesCleanup { logical action act: FooDrop state count: u32 = 0 - reaction(startup) -> act {= ctx.schedule_with_v(act, Some(FooDrop { }), Asap) =} + reaction(startup) -> act {= + ctx.schedule_with_v(act, Some(FooDrop { }), Asap) + =} reaction(act) -> act {= ctx.use_ref(act, |v| println!("{:?}", v)); diff --git a/test/Rust/src/CompositionInitializationOrder.lf b/test/Rust/src/CompositionInitializationOrder.lf index 283923d9be..5bb11f7d9c 100644 --- a/test/Rust/src/CompositionInitializationOrder.lf +++ b/test/Rust/src/CompositionInitializationOrder.lf @@ -2,16 +2,16 @@ target Rust main reactor CompositionInitializationOrder { - c1 = new Component1() - c2 = new Component2() + c1 = new Component1() + c2 = new Component2() - reaction(startup) {= println!("parent woke up"); =} + reaction(startup) {= println!("parent woke up"); =} } reactor Component2 { - reaction(startup) {= println!("c2 woke up"); =} + reaction(startup) {= println!("c2 woke up"); =} } reactor Component1 { - reaction(startup) {= println!("c1 woke up"); =} + reaction(startup) {= println!("c1 woke up"); =} } diff --git a/test/Rust/src/DependencyOnChildPort.lf b/test/Rust/src/DependencyOnChildPort.lf index 18ad405da2..ed8b6b2120 100644 --- a/test/Rust/src/DependencyOnChildPort.lf +++ b/test/Rust/src/DependencyOnChildPort.lf @@ -18,7 +18,9 @@ main reactor { reaction(startup) -> box0.inp {= ctx.set(box0__inp, 444); =} - reaction(box1.out) {= assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; =} + reaction(box1.out) {= + assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; + =} reaction(shutdown) {= assert!(self.done, "reaction was not executed"); diff --git a/test/Rust/src/DependencyThroughChildPort.lf b/test/Rust/src/DependencyThroughChildPort.lf index 0e708cf878..851472503f 100644 --- a/test/Rust/src/DependencyThroughChildPort.lf +++ b/test/Rust/src/DependencyThroughChildPort.lf @@ -1,44 +1,44 @@ target Rust reactor Destination { - input x: u32 - input y: u32 - - state exec_count: u32 - - reaction(x, y) {= - let tag = ctx.get_tag(); - println!( - "Time since start: {}, microstep: {}", - tag.offset_from_t0.as_nanos(), - tag.microstep, - ); - - if tag == tag!(T0) { - assert!(ctx.is_present(x)); - assert_eq!(self.exec_count, 0); - } else { - assert_tag_is!(ctx, (T0, 1)); - assert!(ctx.is_present(y)); - assert_eq!(self.exec_count, 1); - } - self.exec_count += 1; - =} - - reaction(shutdown) {= - assert!(self.exec_count == 2, "reaction was not executed twice"); - println!("success"); - =} + input x: u32 + input y: u32 + + state exec_count: u32 + + reaction(x, y) {= + let tag = ctx.get_tag(); + println!( + "Time since start: {}, microstep: {}", + tag.offset_from_t0.as_nanos(), + tag.microstep, + ); + + if tag == tag!(T0) { + assert!(ctx.is_present(x)); + assert_eq!(self.exec_count, 0); + } else { + assert_tag_is!(ctx, (T0, 1)); + assert!(ctx.is_present(y)); + assert_eq!(self.exec_count, 1); + } + self.exec_count += 1; + =} + + reaction(shutdown) {= + assert!(self.exec_count == 2, "reaction was not executed twice"); + println!("success"); + =} } main reactor { - logical action repeat - d = new Destination() + logical action repeat + d = new Destination() - reaction(startup) -> d.x, repeat {= - ctx.set(d__x, 1); - ctx.schedule(repeat, Asap); - =} + reaction(startup) -> d.x, repeat {= + ctx.set(d__x, 1); + ctx.schedule(repeat, Asap); + =} - reaction(repeat) -> d.y {= ctx.set(d__y, 1); =} + reaction(repeat) -> d.y {= ctx.set(d__y, 1); =} } diff --git a/test/Rust/src/DependencyUseAccessible.lf b/test/Rust/src/DependencyUseAccessible.lf index 28afec9bc6..6e288af8e8 100644 --- a/test/Rust/src/DependencyUseAccessible.lf +++ b/test/Rust/src/DependencyUseAccessible.lf @@ -2,45 +2,45 @@ target Rust reactor Source { - output clock: u32 - output o1: u32 - output o2: u32 - timer t1(35 msec) - timer t2(70 msec) + output clock: u32 + output o1: u32 + output o2: u32 + timer t1(35 msec) + timer t2(70 msec) - reaction(startup) -> clock {= ctx.set(clock, 0); =} + reaction(startup) -> clock {= ctx.set(clock, 0); =} - reaction(t1) -> clock, o1 {= ctx.set(clock, 1); ctx.set(o1, 10) =} + reaction(t1) -> clock, o1 {= ctx.set(clock, 1); ctx.set(o1, 10) =} - reaction(t2) -> clock, o2 {= ctx.set(clock, 2); =} // has a dependency but doesn't use it + reaction(t2) -> clock, o2 {= ctx.set(clock, 2); =} // has a dependency but doesn't use it } reactor Sink { - input clock: u32 - input in1: u32 - input in2: u32 - - reaction(clock) in1, in2 {= - match ctx.get(clock) { - Some(0) | Some(2) => { - assert_eq!(None, ctx.get(in1)); - assert_eq!(None, ctx.get(in2)); - }, - Some(1) => { - assert_eq!(Some(10), ctx.get(in1)); - assert_eq!(None, ctx.get(in2)); - }, - c => panic!("No such signal expected {:?}", c) - } - =} + input clock: u32 + input in1: u32 + input in2: u32 + + reaction(clock) in1, in2 {= + match ctx.get(clock) { + Some(0) | Some(2) => { + assert_eq!(None, ctx.get(in1)); + assert_eq!(None, ctx.get(in2)); + }, + Some(1) => { + assert_eq!(Some(10), ctx.get(in1)); + assert_eq!(None, ctx.get(in2)); + }, + c => panic!("No such signal expected {:?}", c) + } + =} } main reactor { - source = new Source() - sink = new Sink() + source = new Source() + sink = new Sink() - source.clock -> sink.clock + source.clock -> sink.clock - source.o1 -> sink.in1 - source.o2 -> sink.in2 + source.o1 -> sink.in1 + source.o2 -> sink.in2 } diff --git a/test/Rust/src/DependencyUseNonTrigger.lf b/test/Rust/src/DependencyUseNonTrigger.lf index 53496d6896..656ad1f768 100644 --- a/test/Rust/src/DependencyUseNonTrigger.lf +++ b/test/Rust/src/DependencyUseNonTrigger.lf @@ -2,23 +2,23 @@ target Rust reactor Source { - output clock: u32 + output clock: u32 - reaction(startup) -> clock {= ctx.set(clock, 0); =} + reaction(startup) -> clock {= ctx.set(clock, 0); =} } reactor Sink { - input clock: u32 - input bogus: u32 + input clock: u32 + input bogus: u32 - reaction(bogus) clock {= panic!("Should not be executed") =} + reaction(bogus) clock {= panic!("Should not be executed") =} - reaction(shutdown) {= println!("Success") =} + reaction(shutdown) {= println!("Success") =} } main reactor { - source = new Source() - sink = new Sink() + source = new Source() + sink = new Sink() - source.clock -> sink.clock + source.clock -> sink.clock } diff --git a/test/Rust/src/Import.lf b/test/Rust/src/Import.lf index 15837b9c4c..c14618ba6e 100644 --- a/test/Rust/src/Import.lf +++ b/test/Rust/src/Import.lf @@ -4,8 +4,8 @@ target Rust import Imported from "lib/Imported.lf" main reactor Import { - timer t - a = new Imported() + timer t + a = new Imported() - reaction(t) -> a.x {= ctx.set(a__x, 42); =} + reaction(t) -> a.x {= ctx.set(a__x, 42); =} } diff --git a/test/Rust/src/ImportPreambleItem.lf b/test/Rust/src/ImportPreambleItem.lf index 2abd438fb6..922ea74b1a 100644 --- a/test/Rust/src/ImportPreambleItem.lf +++ b/test/Rust/src/ImportPreambleItem.lf @@ -4,7 +4,7 @@ target Rust import SomethingWithAPreamble from "lib/SomethingWithAPreamble.lf" main reactor { - r = new SomethingWithAPreamble() + r = new SomethingWithAPreamble() - reaction(startup) -> r.a {= ctx.set(r__a, super::something_with_a_preamble::some_fun()); =} + reaction(startup) -> r.a {= ctx.set(r__a, super::something_with_a_preamble::some_fun()); =} } diff --git a/test/Rust/src/Minimal.lf b/test/Rust/src/Minimal.lf index 77c7c791f6..02fd0d3eb3 100644 --- a/test/Rust/src/Minimal.lf +++ b/test/Rust/src/Minimal.lf @@ -2,5 +2,5 @@ target Rust main reactor Minimal { - reaction(startup) {= println!("Hello World."); =} + reaction(startup) {= println!("Hello World."); =} } diff --git a/test/Rust/src/PhysicalActionCanBeScheduledSynchronously.lf b/test/Rust/src/PhysicalActionCanBeScheduledSynchronously.lf index faa4f54252..de06f462eb 100644 --- a/test/Rust/src/PhysicalActionCanBeScheduledSynchronously.lf +++ b/test/Rust/src/PhysicalActionCanBeScheduledSynchronously.lf @@ -2,26 +2,26 @@ target Rust main reactor { - physical action act: u32 + physical action act: u32 - state count: u32 + state count: u32 - reaction(startup) -> act {= - ctx.schedule(act, Asap); - ctx.schedule(act, after!(20 ms)); - =} + reaction(startup) -> act {= + ctx.schedule(act, Asap); + ctx.schedule(act, after!(20 ms)); + =} - reaction(act) {= - println!("---- Invocation at {}", ctx.get_tag()); - self.count += 1; + reaction(act) {= + println!("---- Invocation at {}", ctx.get_tag()); + self.count += 1; - // If the physical time is used then it is unlikely to be - // exactly TO + 20 ms. - assert_ne!(ctx.get_elapsed_logical_time(), delay!(20 ms)); - =} + // If the physical time is used then it is unlikely to be + // exactly TO + 20 ms. + assert_ne!(ctx.get_elapsed_logical_time(), delay!(20 ms)); + =} - reaction(shutdown) {= - assert_eq!(self.count, 2); - println!("success"); - =} + reaction(shutdown) {= + assert_eq!(self.count, 2); + println!("success"); + =} } diff --git a/test/Rust/src/PhysicalActionKeepaliveIsSmart.lf b/test/Rust/src/PhysicalActionKeepaliveIsSmart.lf index a34daa21e0..a10abd9a7a 100644 --- a/test/Rust/src/PhysicalActionKeepaliveIsSmart.lf +++ b/test/Rust/src/PhysicalActionKeepaliveIsSmart.lf @@ -1,24 +1,24 @@ // Tests that the scheduler ends up shutting down if there are no live Sender that can send messages // back to the scheduler. target Rust { - keepalive: true + keepalive: true } main reactor { - physical action act: u32 + physical action act: u32 - reaction(startup) -> act {= - std::thread::spawn(|| { - std::thread::sleep(delay!(1 sec)); - // this is a regular thread which doesn't have a reference to the scheduler - }); - =} + reaction(startup) -> act {= + std::thread::spawn(|| { + std::thread::sleep(delay!(1 sec)); + // this is a regular thread which doesn't have a reference to the scheduler + }); + =} - reaction(shutdown) {= - assert!( - ctx.get_elapsed_logical_time() < Duration::from_millis(500), - "Should shutdown before the other thread catches up" - ); - println!("success"); - =} + reaction(shutdown) {= + assert!( + ctx.get_elapsed_logical_time() < Duration::from_millis(500), + "Should shutdown before the other thread catches up" + ); + println!("success"); + =} } diff --git a/test/Rust/src/PhysicalActionWakesSleepingScheduler.lf b/test/Rust/src/PhysicalActionWakesSleepingScheduler.lf index f1f8c154b0..de6a92c72f 100644 --- a/test/Rust/src/PhysicalActionWakesSleepingScheduler.lf +++ b/test/Rust/src/PhysicalActionWakesSleepingScheduler.lf @@ -7,21 +7,21 @@ target Rust main reactor { - timer t(250 msec) // this is unused but important - physical action act: u32 + timer t(250 msec) // this is unused but important + physical action act: u32 - reaction(startup) -> act {= - let act = act.clone(); - ctx.spawn_physical_thread(move |link| { - std::thread::sleep(delay!(20 msec)); - link.schedule_physical(&act, Asap); - }); - =} + reaction(startup) -> act {= + let act = act.clone(); + ctx.spawn_physical_thread(move |link| { + std::thread::sleep(delay!(20 msec)); + link.schedule_physical(&act, Asap); + }); + =} - reaction(act) {= - println!("---- Invocation at {}", ctx.get_tag()); + reaction(act) {= + println!("---- Invocation at {}", ctx.get_tag()); - assert!(ctx.get_elapsed_logical_time() < delay!(250 msec)); - println!("success") - =} + assert!(ctx.get_elapsed_logical_time() < delay!(250 msec)); + println!("success") + =} } diff --git a/test/Rust/src/PhysicalActionWithKeepalive.lf b/test/Rust/src/PhysicalActionWithKeepalive.lf index 8ed4c01a06..a1abdd7743 100644 --- a/test/Rust/src/PhysicalActionWithKeepalive.lf +++ b/test/Rust/src/PhysicalActionWithKeepalive.lf @@ -1,25 +1,25 @@ target Rust { - keepalive: true + keepalive: true } main reactor { - physical action act: u32 + physical action act: u32 - reaction(startup) -> act {= - let act = act.clone(); - ctx.spawn_physical_thread(move |link| { - std::thread::sleep(Duration::from_millis(20)); - link.schedule_physical_with_v(&act, Some(434), Asap); - }); - =} + reaction(startup) -> act {= + let act = act.clone(); + ctx.spawn_physical_thread(move |link| { + std::thread::sleep(Duration::from_millis(20)); + link.schedule_physical_with_v(&act, Some(434), Asap); + }); + =} - reaction(act) {= - let value = ctx.get(act).unwrap(); - println!("---- saw {} at {}", value, ctx.get_tag()); + reaction(act) {= + let value = ctx.get(act).unwrap(); + println!("---- saw {} at {}", value, ctx.get_tag()); - let elapsed_time = ctx.get_elapsed_logical_time(); - assert!(elapsed_time >= delay!(20 ms)); - println!("success"); - ctx.request_stop(Asap); - =} + let elapsed_time = ctx.get_elapsed_logical_time(); + assert!(elapsed_time >= delay!(20 ms)); + println!("success"); + ctx.request_stop(Asap); + =} } diff --git a/test/Rust/src/Preamble.lf b/test/Rust/src/Preamble.lf index c8c186491d..68e2a2f709 100644 --- a/test/Rust/src/Preamble.lf +++ b/test/Rust/src/Preamble.lf @@ -1,11 +1,11 @@ target Rust main reactor Preamble { - preamble {= - fn add_42(i: i32) -> i32 { - return i + 42; - } - =} + preamble {= + fn add_42(i: i32) -> i32 { + return i + 42; + } + =} - reaction(startup) {= println!("42 plus 42 is {}.\n", add_42(42)); =} + reaction(startup) {= println!("42 plus 42 is {}.\n", add_42(42)); =} } diff --git a/test/Rust/src/ReactionLabels.lf b/test/Rust/src/ReactionLabels.lf index 6547792d8c..41c7ec57dd 100644 --- a/test/Rust/src/ReactionLabels.lf +++ b/test/Rust/src/ReactionLabels.lf @@ -3,7 +3,7 @@ target Rust main reactor { - timer t(0) + timer t(0) - reaction(t) {= println!("success"); =} // @label foo + reaction(t) {= println!("success"); =} // @label foo } diff --git a/test/Rust/src/ReservedKeywords.lf b/test/Rust/src/ReservedKeywords.lf index ef11dda278..5d30ba63a4 100644 --- a/test/Rust/src/ReservedKeywords.lf +++ b/test/Rust/src/ReservedKeywords.lf @@ -1,4 +1,5 @@ -// Tests that rust keywords may be used as identifiers in LF and are properly escaped by the emitter +// Tests that rust keywords may be used as identifiers in LF and are properly +// escaped by the emitter target Rust reactor box { diff --git a/test/Rust/src/SingleFileGeneration.lf b/test/Rust/src/SingleFileGeneration.lf index 096e4d2dcd..a3cfdc89f8 100644 --- a/test/Rust/src/SingleFileGeneration.lf +++ b/test/Rust/src/SingleFileGeneration.lf @@ -1,30 +1,30 @@ // The same as CompositionWithPorts.lf, but as a single file project target Rust { - single-file-project: true + single-file-project: true } reactor Source { - output out: i32 + output out: i32 - reaction(startup) -> out {= ctx.set(out, 76600) =} + reaction(startup) -> out {= ctx.set(out, 76600) =} } reactor Sink { - input inport: i32 + input inport: i32 - reaction(inport) {= - if let Some(value) = ctx.get(inport) { - println!("received {}", value); - assert_eq!(76600, value); - } else { - unreachable!(); - } - =} + reaction(inport) {= + if let Some(value) = ctx.get(inport) { + println!("received {}", value); + assert_eq!(76600, value); + } else { + unreachable!(); + } + =} } main reactor { - source = new Source() - sink = new Sink() + source = new Source() + sink = new Sink() - source.out -> sink.inport + source.out -> sink.inport } diff --git a/test/Rust/src/StateDefaultValue.lf b/test/Rust/src/StateDefaultValue.lf index a9eeb1d457..f16549b6db 100644 --- a/test/Rust/src/StateDefaultValue.lf +++ b/test/Rust/src/StateDefaultValue.lf @@ -1,14 +1,14 @@ target Rust main reactor { - // missing initializers are taken to mean "initialize to Default::default()" - state foo_default: u32 - state vec_default: Vec - state option: Option> + // missing initializers are taken to mean "initialize to Default::default()" + state foo_default: u32 + state vec_default: Vec + state option: Option> - reaction(startup) {= - assert_eq!(self.foo_default, 0); - assert_eq!(self.vec_default, vec![]); - assert_eq!(self.option, None); - =} + reaction(startup) {= + assert_eq!(self.foo_default, 0); + assert_eq!(self.vec_default, vec![]); + assert_eq!(self.option, None); + =} } diff --git a/test/Rust/src/StateInitializerVisibility.lf b/test/Rust/src/StateInitializerVisibility.lf index f7da9a48d4..d192f0ca98 100644 --- a/test/Rust/src/StateInitializerVisibility.lf +++ b/test/Rust/src/StateInitializerVisibility.lf @@ -1,5 +1,5 @@ -// Tests that state vars are accessible within initializers of other state vars declared further -// down. +// Tests that state vars are accessible within initializers of other state vars +// declared further down. target Rust main reactor { diff --git a/test/Rust/src/Stop.lf b/test/Rust/src/Stop.lf index 80960ef142..c43f8c30ff 100644 --- a/test/Rust/src/Stop.lf +++ b/test/Rust/src/Stop.lf @@ -8,9 +8,10 @@ target Rust { } /** - * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break after sending - * take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in + * consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break + * after sending take_a_break_after messages. */ reactor Sender(take_a_break_after: u32 = 10, break_interval: time = 400 msec) { output out: u32 diff --git a/test/Rust/src/StopAsync.lf b/test/Rust/src/StopAsync.lf index 6f54ceecde..ca2be1c8a6 100644 --- a/test/Rust/src/StopAsync.lf +++ b/test/Rust/src/StopAsync.lf @@ -1,16 +1,16 @@ target Rust main reactor { - reaction(startup) {= - ctx.spawn_physical_thread(|ctx| { - std::thread::sleep(delay!(140 msec)); - ctx.request_stop(Asap); - }); - =} + reaction(startup) {= + ctx.spawn_physical_thread(|ctx| { + std::thread::sleep(delay!(140 msec)); + ctx.request_stop(Asap); + }); + =} - reaction(shutdown) {= - assert!(ctx.is_shutdown()); - assert!(ctx.get_elapsed_logical_time() > delay!(140 msec)); - println!("success"); - =} + reaction(shutdown) {= + assert!(ctx.is_shutdown()); + assert!(ctx.get_elapsed_logical_time() > delay!(140 msec)); + println!("success"); + =} } diff --git a/test/Rust/src/StopCleanup.lf b/test/Rust/src/StopCleanup.lf index 5bb89fffc2..c9f36bb013 100644 --- a/test/Rust/src/StopCleanup.lf +++ b/test/Rust/src/StopCleanup.lf @@ -2,28 +2,28 @@ target Rust reactor Sender { - output out: u32 + output out: u32 - reaction(startup) -> out {= - assert_tag_is!(ctx, (T0, 0)); - ctx.set(out, 43); - ctx.request_stop(Asap); // requested for (T0, 1) - =} + reaction(startup) -> out {= + assert_tag_is!(ctx, (T0, 0)); + ctx.set(out, 43); + ctx.request_stop(Asap); // requested for (T0, 1) + =} } reactor Consumer { - input in_: u32 + input in_: u32 - reaction(shutdown) in_ {= - assert!(ctx.get(in_).is_none(), "Port should have been cleaned up before shutdown"); - assert_tag_is!(ctx, (T0, 1)); - assert!(ctx.get_elapsed_logical_time().is_zero(), "Should be called on startup step"); - =} + reaction(shutdown) in_ {= + assert!(ctx.get(in_).is_none(), "Port should have been cleaned up before shutdown"); + assert_tag_is!(ctx, (T0, 1)); + assert!(ctx.get_elapsed_logical_time().is_zero(), "Should be called on startup step"); + =} } main reactor StopCleanup { - consumer = new Consumer() - producer = new Sender() + consumer = new Consumer() + producer = new Sender() - producer.out -> consumer.in_ + producer.out -> consumer.in_ } diff --git a/test/Rust/src/StopDuringStartup.lf b/test/Rust/src/StopDuringStartup.lf index 4e78a12e11..149a2fe7e0 100644 --- a/test/Rust/src/StopDuringStartup.lf +++ b/test/Rust/src/StopDuringStartup.lf @@ -1,17 +1,17 @@ // tests that a request_stop called during startup is acted upon. target Rust { - timeout: 30 msec + timeout: 30 msec } main reactor { - reaction(startup) {= - ctx.request_stop(Asap); // requested for (T0, 1) - assert_tag_is!(ctx, T0); - =} + reaction(startup) {= + ctx.request_stop(Asap); // requested for (T0, 1) + assert_tag_is!(ctx, T0); + =} - reaction(shutdown) {= - assert!(ctx.is_shutdown()); - assert_tag_is!(ctx, (T0, 1)); - println!("success"); - =} + reaction(shutdown) {= + assert!(ctx.is_shutdown()); + assert_tag_is!(ctx, (T0, 1)); + println!("success"); + =} } diff --git a/test/Rust/src/StopNoEvent.lf b/test/Rust/src/StopNoEvent.lf index 5ee2639fa2..9dc96d3533 100644 --- a/test/Rust/src/StopNoEvent.lf +++ b/test/Rust/src/StopNoEvent.lf @@ -2,5 +2,5 @@ target Rust main reactor StopNoEvent { - reaction(shutdown) {= println!("success"); =} + reaction(shutdown) {= println!("success"); =} } diff --git a/test/Rust/src/StopTimeout.lf b/test/Rust/src/StopTimeout.lf index 7ebf1595e4..0cd9423156 100644 --- a/test/Rust/src/StopTimeout.lf +++ b/test/Rust/src/StopTimeout.lf @@ -2,12 +2,12 @@ * Tests that `shutdown` is triggered even if the program exits because of timeout target property. */ target Rust { - timeout: 30 msec + timeout: 30 msec } main reactor StopTimeout { - reaction(shutdown) {= - assert_tag_is!(ctx, T0 + 30 ms); - println!("Success!"); // if this is not printed the test failed - =} + reaction(shutdown) {= + assert_tag_is!(ctx, T0 + 30 ms); + println!("Success!"); // if this is not printed the test failed + =} } diff --git a/test/Rust/src/StopTimeoutExact.lf b/test/Rust/src/StopTimeoutExact.lf index cd81e7923d..2b9eb85cda 100644 --- a/test/Rust/src/StopTimeoutExact.lf +++ b/test/Rust/src/StopTimeoutExact.lf @@ -1,6 +1,6 @@ /** - * Tests that when a timeout coincides with a scheduled event, all scheduled reactions are properly - * executed (in addition to the shutdown ones). + * Tests that when a timeout coincides with a scheduled event, all scheduled + * reactions are properly executed (in addition to the shutdown ones). */ target Rust { timeout: 50 msec diff --git a/test/Rust/src/StopTopology.lf b/test/Rust/src/StopTopology.lf index 2d10ee83a8..7f92eb4a82 100644 --- a/test/Rust/src/StopTopology.lf +++ b/test/Rust/src/StopTopology.lf @@ -1,20 +1,20 @@ /** Tests that shutdown wave occurs in topological order like a normal wave. */ target Rust { - timeout: 30 msec + timeout: 30 msec } main reactor StopTopology { - timer end(30 msec) // collides with timeout - state count: u32 + timer end(30 msec) // collides with timeout + state count: u32 - reaction(end) {= - assert_eq!(self.count, 0); - self.count += 1; - =} + reaction(end) {= + assert_eq!(self.count, 0); + self.count += 1; + =} - reaction(shutdown) {= - // executes after because of priority - assert_eq!(self.count, 1); - println!("success"); - =} + reaction(shutdown) {= + // executes after because of priority + assert_eq!(self.count, 1); + println!("success"); + =} } diff --git a/test/Rust/src/StructAsState.lf b/test/Rust/src/StructAsState.lf index 22565b58e9..9b35e7a3fb 100644 --- a/test/Rust/src/StructAsState.lf +++ b/test/Rust/src/StructAsState.lf @@ -1,5 +1,5 @@ -// Check that a state variable can have a statically initialized struct as a value. Check how -// preambles work +// Check that a state variable can have a statically initialized struct as a +// value. Check how preambles work target Rust main reactor StructAsState { diff --git a/test/Rust/src/concurrent/Workers.lf b/test/Rust/src/concurrent/Workers.lf index 497b60fd53..fd330a73cb 100644 --- a/test/Rust/src/concurrent/Workers.lf +++ b/test/Rust/src/concurrent/Workers.lf @@ -1,13 +1,13 @@ target Rust { - workers: 16 + workers: 16 } main reactor { - reaction(startup) {= - if (ctx.num_workers() != 16) { - panic!("Expected to have 16 workers."); - } else { - println!("Using 16 workers."); - } - =} + reaction(startup) {= + if (ctx.num_workers() != 16) { + panic!("Expected to have 16 workers."); + } else { + println!("Using 16 workers."); + } + =} } diff --git a/test/Rust/src/generics/GenericReactor.lf b/test/Rust/src/generics/GenericReactor.lf index 9715d7e0a3..3190524a5b 100644 --- a/test/Rust/src/generics/GenericReactor.lf +++ b/test/Rust/src/generics/GenericReactor.lf @@ -18,7 +18,9 @@ main reactor { reaction(startup) -> box0.inp {= ctx.set(box0__inp, 444); =} - reaction(box1.out) {= assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; =} + reaction(box1.out) {= + assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; + =} reaction(shutdown) {= assert!(self.done, "reaction was not executed"); diff --git a/test/Rust/src/lib/Imported.lf b/test/Rust/src/lib/Imported.lf index 8a33aa04b8..b72cfdf533 100644 --- a/test/Rust/src/lib/Imported.lf +++ b/test/Rust/src/lib/Imported.lf @@ -5,8 +5,8 @@ target Rust import ImportedAgain from "ImportedAgain.lf" reactor Imported { - input x: u32 - a = new ImportedAgain() + input x: u32 + a = new ImportedAgain() - reaction(x) -> a.x {= ctx.set(a__x, ctx.get(x).unwrap()); =} + reaction(x) -> a.x {= ctx.set(a__x, ctx.get(x).unwrap()); =} } diff --git a/test/Rust/src/lib/ImportedAgain.lf b/test/Rust/src/lib/ImportedAgain.lf index d1bd87c4f1..1f9d236318 100644 --- a/test/Rust/src/lib/ImportedAgain.lf +++ b/test/Rust/src/lib/ImportedAgain.lf @@ -3,10 +3,10 @@ target Rust reactor ImportedAgain { - input x: u32 + input x: u32 - reaction(x) {= - assert_eq!(Some(42), ctx.get(x)); - println!("success"); - =} + reaction(x) {= + assert_eq!(Some(42), ctx.get(x)); + println!("success"); + =} } diff --git a/test/Rust/src/lib/SomethingWithAPreamble.lf b/test/Rust/src/lib/SomethingWithAPreamble.lf index d63f7c381a..af5caa871b 100644 --- a/test/Rust/src/lib/SomethingWithAPreamble.lf +++ b/test/Rust/src/lib/SomethingWithAPreamble.lf @@ -3,10 +3,10 @@ target Rust reactor SomethingWithAPreamble { - input a: u32 - preamble {= - pub fn some_fun() -> u32 { - 4 - } - =} + input a: u32 + preamble {= + pub fn some_fun() -> u32 { + 4 + } + =} } diff --git a/test/Rust/src/multiport/CycledLhs_SelfLoop.lf b/test/Rust/src/multiport/CycledLhs_SelfLoop.lf index 5eb3cc226c..925fafce21 100644 --- a/test/Rust/src/multiport/CycledLhs_SelfLoop.lf +++ b/test/Rust/src/multiport/CycledLhs_SelfLoop.lf @@ -1,5 +1,5 @@ -// test a cycled connection which has ports of the same reactor on the LHS and rhs (single port)+ -> -// multiport +// test a cycled connection which has ports of the same reactor on the LHS and +// rhs (single port)+ -> multiport target Rust { timeout: 16 usec } @@ -10,7 +10,9 @@ reactor Test { logical action act: u32 state last: u32 = 1 - reaction(startup) -> act {= ctx.schedule_with_v(act, Some(1), after!(1 us)); =} + reaction(startup) -> act {= + ctx.schedule_with_v(act, Some(1), after!(1 us)); + =} reaction(act) -> out {= ctx.set_opt(out, ctx.get(act)); =} diff --git a/test/Rust/src/multiport/CycledLhs_Single.lf b/test/Rust/src/multiport/CycledLhs_Single.lf index 62723bda42..2fdd5c605c 100644 --- a/test/Rust/src/multiport/CycledLhs_Single.lf +++ b/test/Rust/src/multiport/CycledLhs_Single.lf @@ -1,5 +1,5 @@ -// test a cycled connection which has ports of the same reactor on the LHS and rhs (multiport)+ -> -// multiport +// test a cycled connection which has ports of the same reactor on the LHS and +// rhs (multiport)+ -> multiport target Rust { timeout: 16 usec } @@ -10,7 +10,9 @@ reactor Test { logical action act: {= (u32, u32) =} state last: u32 = 1 - reaction(startup) -> act {= ctx.schedule_with_v(act, Some((0, 1)), after!(1 us)); =} + reaction(startup) -> act {= + ctx.schedule_with_v(act, Some((0, 1)), after!(1 us)); + =} reaction(act) -> out {= let (a, b) = ctx.get(act).unwrap(); @@ -39,9 +41,9 @@ reactor Test { } /** - * 0 + 1 = 1 1 + 1 = 2 1 + 2 = 3 2 + 3 = 5 3 + 5 = 8 5 + 8 = 13 8 + 13 = 21 13 + 21 = 34 21 + 34 = - * 55 34 + 55 = 89 55 + 89 = 144 89 + 144 = 233 144 + 233 = 377 233 + 377 = 610 377 + 610 = 987 610 - * + 987 = 1597 987 + 1597 = 2584 + * 0 + 1 = 1 1 + 1 = 2 1 + 2 = 3 2 + 3 = 5 3 + 5 = 8 5 + 8 = 13 8 + 13 = 21 13 + + * 21 = 34 21 + 34 = 55 34 + 55 = 89 55 + 89 = 144 89 + 144 = 233 144 + 233 = + * 377 233 + 377 = 610 377 + 610 = 987 610 + 987 = 1597 987 + 1597 = 2584 */ main reactor { t = new Test() diff --git a/test/Rust/src/multiport/MultiportFromHierarchy.lf b/test/Rust/src/multiport/MultiportFromHierarchy.lf index 400dfff7d9..d2af4253c4 100644 --- a/test/Rust/src/multiport/MultiportFromHierarchy.lf +++ b/test/Rust/src/multiport/MultiportFromHierarchy.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input, where the former is a hierarchical reactor. +// Check multiport output to multiport input, where the former is a hierarchical +// reactor. target Rust { timeout: 2 sec } diff --git a/test/Rust/src/multiport/MultiportIn.lf b/test/Rust/src/multiport/MultiportIn.lf index 27b3522449..4ebf1c56d5 100644 --- a/test/Rust/src/multiport/MultiportIn.lf +++ b/test/Rust/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -// This is a version fo the Threaded test that uses a multiport input at the destination. Its -// purpose is to test multiport inputs. +// This is a version fo the Threaded test that uses a multiport input at the +// destination. Its purpose is to test multiport inputs. target Rust { timeout: 2 sec, fast: true diff --git a/test/Rust/src/multiport/MultiportToMultiport2.lf b/test/Rust/src/multiport/MultiportToMultiport2.lf index 0c79ee17d4..a1e2db235d 100644 --- a/test/Rust/src/multiport/MultiportToMultiport2.lf +++ b/test/Rust/src/multiport/MultiportToMultiport2.lf @@ -1,4 +1,5 @@ -// test a sparse connection between multiports (some channels are left disconnected) +// test a sparse connection between multiports (some channels are left +// disconnected) target Rust reactor Source(width: usize = 2) { diff --git a/test/Rust/src/target/BuildProfileDefaultIsDev.lf b/test/Rust/src/target/BuildProfileDefaultIsDev.lf index e45c442406..083794bdfc 100644 --- a/test/Rust/src/target/BuildProfileDefaultIsDev.lf +++ b/test/Rust/src/target/BuildProfileDefaultIsDev.lf @@ -3,8 +3,8 @@ target Rust main reactor { - reaction(startup) {= - assert!(cfg!(debug_assertions), "debug assertions should be enabled"); - println!("success"); - =} + reaction(startup) {= + assert!(cfg!(debug_assertions), "debug assertions should be enabled"); + println!("success"); + =} } diff --git a/test/Rust/src/target/BuildProfileRelease.lf b/test/Rust/src/target/BuildProfileRelease.lf index 20712f0721..da19c0bc79 100644 --- a/test/Rust/src/target/BuildProfileRelease.lf +++ b/test/Rust/src/target/BuildProfileRelease.lf @@ -1,12 +1,12 @@ // Tests that the we can enable the release profile A proxy for checking this is to check that debug // assertions are disabled. target Rust { - build-type: "Release" + build-type: "Release" } main reactor { - reaction(startup) {= - assert!(!cfg!(debug_assertions), "debug assertions should be disabled"); - println!("success"); - =} + reaction(startup) {= + assert!(!cfg!(debug_assertions), "debug assertions should be disabled"); + println!("success"); + =} } diff --git a/test/Rust/src/target/CargoDependency.lf b/test/Rust/src/target/CargoDependency.lf index a425958fab..5a9b37cf5e 100644 --- a/test/Rust/src/target/CargoDependency.lf +++ b/test/Rust/src/target/CargoDependency.lf @@ -1,16 +1,16 @@ // This tests the ability to depend on crates with carg if this compiles it's fine target Rust { - cargo-dependencies: { - rand: "0.8", - regex: { - version: "1" - } + cargo-dependencies: { + rand: "0.8", + regex: { + version: "1" } + } } main reactor { - reaction(startup) {= - use rand::rngs::StdRng; - use regex::*; - =} + reaction(startup) {= + use rand::rngs::StdRng; + use regex::*; + =} } diff --git a/test/Rust/src/target/CargoDependencyOnRuntime.lf b/test/Rust/src/target/CargoDependencyOnRuntime.lf index 2d3473f474..26aa2c5eb3 100644 --- a/test/Rust/src/target/CargoDependencyOnRuntime.lf +++ b/test/Rust/src/target/CargoDependencyOnRuntime.lf @@ -1,12 +1,12 @@ // This tests the ability to depend on crates with carg if this compiles it's fine target Rust { - cargo-dependencies: { - reactor_rt: { - features: ["parallel-runtime"] - } + cargo-dependencies: { + reactor_rt: { + features: ["parallel-runtime"] } + } } main reactor { - reaction(startup) {= println!("success") =} + reaction(startup) {= println!("success") =} } diff --git a/test/Rust/src/target/ModuleDependency.lf b/test/Rust/src/target/ModuleDependency.lf index 43945fda06..e3d22914c8 100644 --- a/test/Rust/src/target/ModuleDependency.lf +++ b/test/Rust/src/target/ModuleDependency.lf @@ -1,14 +1,14 @@ // Test that we can include modules into main target Rust { - rust-include: "some_module.rs" + rust-include: "some_module.rs" } main reactor { - timer t(0) + timer t(0) - reaction(t) {= - use crate::some_module::*; - assert_eq!("hihihi", from_some_module()); - println!("success"); - =} + reaction(t) {= + use crate::some_module::*; + assert_eq!("hihihi", from_some_module()); + println!("success"); + =} } diff --git a/test/Rust/src/target/ModuleDependencyWithDirModule.lf b/test/Rust/src/target/ModuleDependencyWithDirModule.lf index 3820594198..237904ed74 100644 --- a/test/Rust/src/target/ModuleDependencyWithDirModule.lf +++ b/test/Rust/src/target/ModuleDependencyWithDirModule.lf @@ -1,15 +1,15 @@ // The same as CompositionWithPorts.lf, but as a single file project target Rust { - rust-include: "testmod" + rust-include: "testmod" } main reactor { - timer t(0) + timer t(0) - reaction(t) {= - use crate::testmod::*; - assert_eq!(44, something()); - assert_eq!("other", other::from_other()); - println!("success"); - =} + reaction(t) {= + use crate::testmod::*; + assert_eq!(44, something()); + assert_eq!("other", other::from_other()); + println!("success"); + =} } diff --git a/test/TypeScript/src/ActionWithNoReaction.lf b/test/TypeScript/src/ActionWithNoReaction.lf index f8dab33ef6..14d6aa8801 100644 --- a/test/TypeScript/src/ActionWithNoReaction.lf +++ b/test/TypeScript/src/ActionWithNoReaction.lf @@ -1,36 +1,36 @@ // This checks that action can be created even if there is no reaction. This test passes merely by // compiling and executing without a segfault. Its other functionality is tested by other tests. target TypeScript { - fast: true, - timeout: 3 sec + fast: true, + timeout: 3 sec } reactor foo { - input x: number - output y: number - logical action a + input x: number + output y: number + logical action a - reaction(x) -> y, a {= - y = 2 * (x as number); - actions.a.schedule(TimeValue.msec(500), null) - =} + reaction(x) -> y, a {= + y = 2 * (x as number); + actions.a.schedule(TimeValue.msec(500), null) + =} } reactor print { - input x: number + input x: number - reaction(x) {= - console.log("Result is " + (x as number)); - console.log("Current logical time is " + util.getElapsedLogicalTime()); - console.log("Current physical time is: " + util.getElapsedPhysicalTime()); - =} + reaction(x) {= + console.log("Result is " + (x as number)); + console.log("Current logical time is " + util.getElapsedLogicalTime()); + console.log("Current physical time is: " + util.getElapsedPhysicalTime()); + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x after 10 msec + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x after 10 msec - reaction(t) -> f.x {= f.x = 42; =} + reaction(t) -> f.x {= f.x = 42; =} } diff --git a/test/TypeScript/src/After.lf b/test/TypeScript/src/After.lf index 525ff817f1..8a872103e9 100644 --- a/test/TypeScript/src/After.lf +++ b/test/TypeScript/src/After.lf @@ -1,4 +1,5 @@ -// This checks that the after keyword adjusts logical time, not using physical time. +// This checks that the after keyword adjusts logical time, not using physical +// time. target TypeScript { fast: true, timeout: 3 sec diff --git a/test/TypeScript/src/ArrayAsType.lf b/test/TypeScript/src/ArrayAsType.lf index 3ff1e9e31a..9e30764307 100644 --- a/test/TypeScript/src/ArrayAsType.lf +++ b/test/TypeScript/src/ArrayAsType.lf @@ -1,5 +1,6 @@ -// In TypeScript this test is almost exactly the same as ArrayAsType. Source produces a statically -// allocated array, which it passes to Print. The destination references the array directly. +// In TypeScript this test is almost exactly the same as ArrayAsType. Source +// produces a statically allocated array, which it passes to Print. The +// destination references the array directly. target TypeScript reactor Source { diff --git a/test/TypeScript/src/ArrayPrint.lf b/test/TypeScript/src/ArrayPrint.lf index ba77fa47c6..93b6486506 100644 --- a/test/TypeScript/src/ArrayPrint.lf +++ b/test/TypeScript/src/ArrayPrint.lf @@ -1,5 +1,6 @@ -// In TypeScript this test is almost exactly the same as ArrayAsType. Source produces a dynamically -// allocated array, which it passes to Print. Reference counting ensures that the array is freed. +// In TypeScript this test is almost exactly the same as ArrayAsType. Source +// produces a dynamically allocated array, which it passes to Print. Reference +// counting ensures that the array is freed. target TypeScript reactor Source { diff --git a/test/TypeScript/src/ArrayScale.lf b/test/TypeScript/src/ArrayScale.lf index 0b29b9f918..107ef8cf2f 100644 --- a/test/TypeScript/src/ArrayScale.lf +++ b/test/TypeScript/src/ArrayScale.lf @@ -1,6 +1,7 @@ -// Source produces a dynamically allocated array, which it passes to Scale. Scale requests a -// writable copy, which, instead of copying, it just gets ownership of the original array. It -// modifies it and passes it to Print. It gets freed after Print is done with it. +// Source produces a dynamically allocated array, which it passes to Scale. +// Scale requests a writable copy, which, instead of copying, it just gets +// ownership of the original array. It modifies it and passes it to Print. It +// gets freed after Print is done with it. target TypeScript import Source, Print from "ArrayPrint.lf" diff --git a/test/TypeScript/src/Composition.lf b/test/TypeScript/src/Composition.lf index f3dc9ae5da..e74bbe9aa9 100644 --- a/test/TypeScript/src/Composition.lf +++ b/test/TypeScript/src/Composition.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target TypeScript { timeout: 5 sec } diff --git a/test/TypeScript/src/CompositionAfter.lf b/test/TypeScript/src/CompositionAfter.lf index 474f1525dd..8840298c2d 100644 --- a/test/TypeScript/src/CompositionAfter.lf +++ b/test/TypeScript/src/CompositionAfter.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source that checks against its own count. +// This test connects a simple counting source that checks against its own +// count. target TypeScript { fast: true, timeout: 10 sec diff --git a/test/TypeScript/src/DanglingOutput.lf b/test/TypeScript/src/DanglingOutput.lf index c07115ea93..8c9f884dd0 100644 --- a/test/TypeScript/src/DanglingOutput.lf +++ b/test/TypeScript/src/DanglingOutput.lf @@ -3,24 +3,24 @@ target TypeScript reactor Source { - output out: number - timer t + output out: number + timer t - reaction(t) -> out {= out = 1; =} + reaction(t) -> out {= out = 1; =} } reactor Gain { - input x: number - output out: number + input x: number + output out: number - reaction(x) -> out {= - console.log("Received " + x); - out = (x as number) * 2; - =} + reaction(x) -> out {= + console.log("Received " + x); + out = (x as number) * 2; + =} } main reactor DanglingOutput { - source = new Source() - container = new Gain() - source.out -> container.x + source = new Source() + container = new Gain() + source.out -> container.x } diff --git a/test/TypeScript/src/Deadline.lf b/test/TypeScript/src/Deadline.lf index b4586090f3..9f3086f1f5 100644 --- a/test/TypeScript/src/Deadline.lf +++ b/test/TypeScript/src/Deadline.lf @@ -1,5 +1,6 @@ -// This example illustrates local deadline handling. Even numbers are sent by the Source -// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by +// the Source immediately, whereas odd numbers are sent after a big enough delay +// to violate the deadline. target TypeScript { timeout: 4 sec } diff --git a/test/TypeScript/src/DeadlineHandledAbove.lf b/test/TypeScript/src/DeadlineHandledAbove.lf index a87a677048..ba47fd7aac 100644 --- a/test/TypeScript/src/DeadlineHandledAbove.lf +++ b/test/TypeScript/src/DeadlineHandledAbove.lf @@ -1,5 +1,5 @@ -// Test a deadline where the deadline violation produces an output and the container reacts to that -// output. +// Test a deadline where the deadline violation produces an output and the +// container reacts to that output. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/DelayInt.lf b/test/TypeScript/src/DelayInt.lf index 2910a5b6b5..224a7eab4a 100644 --- a/test/TypeScript/src/DelayInt.lf +++ b/test/TypeScript/src/DelayInt.lf @@ -1,5 +1,5 @@ -// This tests actions with payloads by delaying an input by a fixed amount. This is a start at -// handling dynamic memory allocation for such actions. +// This tests actions with payloads by delaying an input by a fixed amount. This +// is a start at handling dynamic memory allocation for such actions. target TypeScript reactor Delay(delay: time = 100 msec) { diff --git a/test/TypeScript/src/DelayedReaction.lf b/test/TypeScript/src/DelayedReaction.lf index 9ec7135f5a..1622b4069c 100644 --- a/test/TypeScript/src/DelayedReaction.lf +++ b/test/TypeScript/src/DelayedReaction.lf @@ -2,26 +2,26 @@ target TypeScript reactor Source { - output out: number - timer t + output out: number + timer t - reaction(t) -> out {= out = 1; =} + reaction(t) -> out {= out = 1; =} } reactor Sink { - input x: number + input x: number - reaction(x) {= - let elapsed = util.getElapsedLogicalTime(); - console.log("Nanoseconds since start: " + elapsed); - if (! elapsed.isEqualTo(TimeValue.msec(100))) { - util.requestErrorStop("ERROR: Expected 100 msecs but got" + elapsed) - } - =} + reaction(x) {= + let elapsed = util.getElapsedLogicalTime(); + console.log("Nanoseconds since start: " + elapsed); + if (! elapsed.isEqualTo(TimeValue.msec(100))) { + util.requestErrorStop("ERROR: Expected 100 msecs but got" + elapsed) + } + =} } main reactor DelayedReaction { - source = new Source() - sink = new Sink() - source.out -> sink.x after 100 msec + source = new Source() + sink = new Sink() + source.out -> sink.x after 100 msec } diff --git a/test/TypeScript/src/Determinism.lf b/test/TypeScript/src/Determinism.lf index 51381216c6..d0fc8db2a5 100644 --- a/test/TypeScript/src/Determinism.lf +++ b/test/TypeScript/src/Determinism.lf @@ -1,45 +1,45 @@ target TypeScript reactor Source { - output y: number - timer t + output y: number + timer t - reaction(t) -> y {= y = 1; =} + reaction(t) -> y {= y = 1; =} } reactor Destination { - input x: number - input y: number + input x: number + input y: number - reaction(x, y) {= - let sum = 0; - if (x !== undefined) { - sum += x; - } - if (y !== undefined) { - sum += y; - } - console.log("Received " + sum); - if (sum != 2) { - util.requestErrorStop("FAILURE: Expected 2.") - } - =} + reaction(x, y) {= + let sum = 0; + if (x !== undefined) { + sum += x; + } + if (y !== undefined) { + sum += y; + } + console.log("Received " + sum); + if (sum != 2) { + util.requestErrorStop("FAILURE: Expected 2.") + } + =} } reactor Pass { - input x: number - output y: number + input x: number + output y: number - reaction(x) -> y {= y = x as number; =} + reaction(x) -> y {= y = x as number; =} } main reactor Determinism { - s = new Source() - d = new Destination() - p1 = new Pass() - p2 = new Pass() - s.y -> d.y - s.y -> p1.x - p1.y -> p2.x - p2.y -> d.x + s = new Source() + d = new Destination() + p1 = new Pass() + p2 = new Pass() + s.y -> d.y + s.y -> p1.x + p1.y -> p2.x + p2.y -> d.x } diff --git a/test/TypeScript/src/DoubleInvocation.lf b/test/TypeScript/src/DoubleInvocation.lf index 92369ca913..9557857ee2 100644 --- a/test/TypeScript/src/DoubleInvocation.lf +++ b/test/TypeScript/src/DoubleInvocation.lf @@ -1,7 +1,8 @@ -// This illustrates a very strange bug that showed up and has now been fixed. This test ensures it -// does not reappear. At logical time zero, the two Print reactors used to be fired twice each at -// the same logical time. They should only be fired once. This behavior was oddly eliminated by -// either of the following actions, neither of which should affect this behavior: +// This illustrates a very strange bug that showed up and has now been fixed. +// This test ensures it does not reappear. At logical time zero, the two Print +// reactors used to be fired twice each at the same logical time. They should +// only be fired once. This behavior was oddly eliminated by either of the +// following actions, neither of which should affect this behavior: // * Removing the startup reaction in Print. // * Sending only position, not velocity from Ball. target TypeScript { diff --git a/test/TypeScript/src/DoubleReaction.lf b/test/TypeScript/src/DoubleReaction.lf index 67f2632920..b172166613 100644 --- a/test/TypeScript/src/DoubleReaction.lf +++ b/test/TypeScript/src/DoubleReaction.lf @@ -1,5 +1,5 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output -// for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only +// once. Correct output for this 2, 4, 6, 8, etc. target TypeScript { timeout: 10 sec, fast: true diff --git a/test/TypeScript/src/DoubleTrigger.lf b/test/TypeScript/src/DoubleTrigger.lf index dafbd7f453..fc8921622c 100644 --- a/test/TypeScript/src/DoubleTrigger.lf +++ b/test/TypeScript/src/DoubleTrigger.lf @@ -1,4 +1,5 @@ -// Test that two simultaneous triggers don't cause a reaction to execute twice at the same tag. +// Test that two simultaneous triggers don't cause a reaction to execute twice +// at the same tag. target TypeScript { fast: true, timeout: 1 sec diff --git a/test/TypeScript/src/GetTime.lf b/test/TypeScript/src/GetTime.lf index 8e14c563a0..d168c4c594 100644 --- a/test/TypeScript/src/GetTime.lf +++ b/test/TypeScript/src/GetTime.lf @@ -1,24 +1,24 @@ // This file includes code documented on the Wiki. For this test, success is just compiling and // running. target TypeScript { - // FIXME the C version of this test is fast, but in TS it's illegal to subtract TimeValues and - // get a negative result fast: true - timeout: 2 sec + // FIXME the C version of this test is fast, but in TS it's illegal to subtract TimeValues and get + // a negative result fast: true + timeout: 2 sec } main reactor GetTime { - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) {= - let logical = util.getCurrentLogicalTime(); - console.log("Logical time is " + logical); + reaction(t) {= + let logical = util.getCurrentLogicalTime(); + console.log("Logical time is " + logical); - let elapsed = util.getElapsedLogicalTime(); - console.log("Elapsed logical time is " + elapsed); + let elapsed = util.getElapsedLogicalTime(); + console.log("Elapsed logical time is " + elapsed); - let physical = util.getCurrentPhysicalTime(); - console.log("Physical time is " + physical); + let physical = util.getCurrentPhysicalTime(); + console.log("Physical time is " + physical); - console.log("Time lag is " + physical.subtract(logical)); - =} + console.log("Time lag is " + physical.subtract(logical)); + =} } diff --git a/test/TypeScript/src/HelloWorld.lf b/test/TypeScript/src/HelloWorld.lf index 85d560e3a7..2fe705929b 100644 --- a/test/TypeScript/src/HelloWorld.lf +++ b/test/TypeScript/src/HelloWorld.lf @@ -1,11 +1,11 @@ target TypeScript reactor HelloWorldInside { - timer t + timer t - reaction(t) {= console.log("Hello World."); =} + reaction(t) {= console.log("Hello World."); =} } main reactor HelloWorld { - a = new HelloWorldInside() + a = new HelloWorldInside() } diff --git a/test/TypeScript/src/Hierarchy.lf b/test/TypeScript/src/Hierarchy.lf index 4f3ea06e98..7a7b2d72ee 100644 --- a/test/TypeScript/src/Hierarchy.lf +++ b/test/TypeScript/src/Hierarchy.lf @@ -2,53 +2,53 @@ target TypeScript reactor Source { - output out: number - timer t + output out: number + timer t - reaction(t) -> out {= - console.log("Producing from source"); - out = 1; - =} + reaction(t) -> out {= + console.log("Producing from source"); + out = 1; + =} } reactor Gain { - input x: number - output out: number + input x: number + output out: number - reaction(x) -> out {= - console.log("Gain received " + x); - out = (x as number) * 2; - =} + reaction(x) -> out {= + console.log("Gain received " + x); + out = (x as number) * 2; + =} } reactor Print { - input x: number - - reaction(x) {= - x = x as number; - console.log("Received: " + x); - if (x != 2) { - util.requestErrorStop("Expected 2.") - } - =} + input x: number + + reaction(x) {= + x = x as number; + console.log("Received: " + x); + if (x != 2) { + util.requestErrorStop("Expected 2.") + } + =} } reactor GainContainer { - input x: number - output out: number - output out2: number - gain = new Gain() - x -> gain.x - gain.out -> out - gain.out -> out2 + input x: number + output out: number + output out2: number + gain = new Gain() + x -> gain.x + gain.out -> out + gain.out -> out2 } main reactor Hierarchy { - source = new Source() - container = new GainContainer() - print = new Print() - print2 = new Print() - source.out -> container.x - container.out -> print.x - container.out -> print2.x + source = new Source() + container = new GainContainer() + print = new Print() + print2 = new Print() + source.out -> container.x + container.out -> print.x + container.out -> print2.x } diff --git a/test/TypeScript/src/Import.lf b/test/TypeScript/src/Import.lf index afdc8465ca..aecf259f71 100644 --- a/test/TypeScript/src/Import.lf +++ b/test/TypeScript/src/Import.lf @@ -1,13 +1,13 @@ // This tests the ability to import a reactor definition that itself imports a reactor definition. target TypeScript { - timeout: 2 sec + timeout: 2 sec } import Imported from "lib/Imported.lf" main reactor Import { - timer t - a = new Imported() + timer t + a = new Imported() - reaction(t) -> a.x {= a.x = 42; =} + reaction(t) -> a.x {= a.x = 42; =} } diff --git a/test/TypeScript/src/Microsteps.lf b/test/TypeScript/src/Microsteps.lf index 44130af36b..a04b454a92 100644 --- a/test/TypeScript/src/Microsteps.lf +++ b/test/TypeScript/src/Microsteps.lf @@ -1,39 +1,39 @@ target TypeScript reactor Destination { - input x: number - input y: number + input x: number + input y: number - reaction(x, y) {= - let elapsed = util.getElapsedLogicalTime(); - console.log("Time since start: " + elapsed); - if (! elapsed.isEqualTo(TimeValue.zero())) { - util.requestErrorStop("Expected elapsed time to be 0, but it was " + elapsed); - } - let count = 0; - if (x) { - console.log("x is present."); - count++; - } - if (y) { - console.log("y is present."); - count++; - } - if (count != 1) { - util.requestErrorStop("Expected exactly one input to be present but got " + count) - } - =} + reaction(x, y) {= + let elapsed = util.getElapsedLogicalTime(); + console.log("Time since start: " + elapsed); + if (! elapsed.isEqualTo(TimeValue.zero())) { + util.requestErrorStop("Expected elapsed time to be 0, but it was " + elapsed); + } + let count = 0; + if (x) { + console.log("x is present."); + count++; + } + if (y) { + console.log("y is present."); + count++; + } + if (count != 1) { + util.requestErrorStop("Expected exactly one input to be present but got " + count) + } + =} } main reactor Microsteps { - timer start - logical action repeat - d = new Destination() + timer start + logical action repeat + d = new Destination() - reaction(start) -> d.x, repeat {= - d.x = 1; - actions.repeat.schedule(0, null); - =} + reaction(start) -> d.x, repeat {= + d.x = 1; + actions.repeat.schedule(0, null); + =} - reaction(repeat) -> d.y {= d.y = 1; =} + reaction(repeat) -> d.y {= d.y = 1; =} } diff --git a/test/TypeScript/src/Minimal.lf b/test/TypeScript/src/Minimal.lf index 737ec70336..54a1aa7ae9 100644 --- a/test/TypeScript/src/Minimal.lf +++ b/test/TypeScript/src/Minimal.lf @@ -2,7 +2,7 @@ target TypeScript main reactor Minimal { - timer t + timer t - reaction(t) {= console.log("Hello World."); =} + reaction(t) {= console.log("Hello World."); =} } diff --git a/test/TypeScript/src/MovingAverage.lf b/test/TypeScript/src/MovingAverage.lf index b8018d92c2..19e767e3e2 100644 --- a/test/TypeScript/src/MovingAverage.lf +++ b/test/TypeScript/src/MovingAverage.lf @@ -1,5 +1,6 @@ -// Demonstration of a state variable that is an array. The MovingAverage reactor computes the moving -// average of the last four inputs and produces that as output. The source is a counting sequence. +// Demonstration of a state variable that is an array. The MovingAverage reactor +// computes the moving average of the last four inputs and produces that as +// output. The source is a counting sequence. target TypeScript { timeout: 1 sec, fast: true diff --git a/test/TypeScript/src/MultipleContained.lf b/test/TypeScript/src/MultipleContained.lf index 4c5fb53db8..d381c2c697 100644 --- a/test/TypeScript/src/MultipleContained.lf +++ b/test/TypeScript/src/MultipleContained.lf @@ -2,35 +2,35 @@ target TypeScript reactor Contained { - output trigger: number - input in1: number - input in2: number + output trigger: number + input in1: number + input in2: number - reaction(startup) -> trigger {= trigger = 42; =} + reaction(startup) -> trigger {= trigger = 42; =} - reaction(in1) {= - in1 = in1 as number; - console.log("in1 received " + in1); - if (in1 != 42) { - util.requestErrorStop("FAILED: Expected 42.") - } - =} + reaction(in1) {= + in1 = in1 as number; + console.log("in1 received " + in1); + if (in1 != 42) { + util.requestErrorStop("FAILED: Expected 42.") + } + =} - reaction(in2) {= - in2 = in2 as number; - console.log("in2 received " + in2); - if (in2 != 42) { - util.requestErrorStop("FAILED: Expected 42.") - } - =} + reaction(in2) {= + in2 = in2 as number; + console.log("in2 received " + in2); + if (in2 != 42) { + util.requestErrorStop("FAILED: Expected 42.") + } + =} } main reactor MultipleContained { - c = new Contained() + c = new Contained() - reaction(c.trigger) -> c.in1, c.in2 {= - c.trigger = c.trigger as number; - c.in1 = c.trigger; - c.in2 = c.trigger; - =} + reaction(c.trigger) -> c.in1, c.in2 {= + c.trigger = c.trigger as number; + c.in1 = c.trigger; + c.in2 = c.trigger; + =} } diff --git a/test/TypeScript/src/Preamble.lf b/test/TypeScript/src/Preamble.lf index fbbe9a67b4..51cd0a1868 100644 --- a/test/TypeScript/src/Preamble.lf +++ b/test/TypeScript/src/Preamble.lf @@ -1,20 +1,20 @@ target TypeScript { - timeout: 2 sec + timeout: 2 sec } main reactor Preamble { - preamble {= - function add42( i:number) { - return i + 42; - } - =} - timer t + preamble {= + function add42( i:number) { + return i + 42; + } + =} + timer t - reaction(t) {= - let s = "42"; - let radix = 10; - let i = parseInt(s, radix); - console.log("Converted string " + s + " to number " + i); - console.log("42 plus 42 is " + add42(42)); - =} + reaction(t) {= + let s = "42"; + let radix = 10; + let i = parseInt(s, radix); + console.log("Converted string " + s + " to number " + i); + console.log("42 plus 42 is " + add42(42)); + =} } diff --git a/test/TypeScript/src/ReadOutputOfContainedReactor.lf b/test/TypeScript/src/ReadOutputOfContainedReactor.lf index 8591fe96bc..01b725e181 100644 --- a/test/TypeScript/src/ReadOutputOfContainedReactor.lf +++ b/test/TypeScript/src/ReadOutputOfContainedReactor.lf @@ -1,4 +1,5 @@ -// Test reacting to and reading outputs from a contained reactor in various permutations. +// Test reacting to and reading outputs from a contained reactor in various +// permutations. target TypeScript reactor Contained { diff --git a/test/TypeScript/src/Schedule.lf b/test/TypeScript/src/Schedule.lf index 66464ccf70..fa779cc5bd 100644 --- a/test/TypeScript/src/Schedule.lf +++ b/test/TypeScript/src/Schedule.lf @@ -2,25 +2,25 @@ target TypeScript reactor ScheduleLogicalAction { - input x: number - logical action a + input x: number + logical action a - reaction(x) -> a {= actions.a.schedule(TimeValue.msec(200), null) =} + reaction(x) -> a {= actions.a.schedule(TimeValue.msec(200), null) =} - reaction(a) {= - let elapsedTime = util.getElapsedLogicalTime(); - console.log("Action triggered at logical time " + elapsedTime + " (sec, nsec) after start."); - if (!elapsedTime.isEqualTo(TimeValue.msec(200))) { - util.requestErrorStop("Expected action time to be 200 msec. It was " + elapsedTime + " (sec, nsec).") - } else { - console.log("Success! Action time was " + elapsedTime); - } - =} + reaction(a) {= + let elapsedTime = util.getElapsedLogicalTime(); + console.log("Action triggered at logical time " + elapsedTime + " (sec, nsec) after start."); + if (!elapsedTime.isEqualTo(TimeValue.msec(200))) { + util.requestErrorStop("Expected action time to be 200 msec. It was " + elapsedTime + " (sec, nsec).") + } else { + console.log("Success! Action time was " + elapsedTime); + } + =} } main reactor { - a = new ScheduleLogicalAction() - timer t + a = new ScheduleLogicalAction() + timer t - reaction(t) -> a.x {= a.x = 1; =} + reaction(t) -> a.x {= a.x = 1; =} } diff --git a/test/TypeScript/src/ScheduleLogicalAction.lf b/test/TypeScript/src/ScheduleLogicalAction.lf index ee49204288..84e8fbe1cb 100644 --- a/test/TypeScript/src/ScheduleLogicalAction.lf +++ b/test/TypeScript/src/ScheduleLogicalAction.lf @@ -1,5 +1,5 @@ -// This checks that a logical action is scheduled the specified logical time after the current -// logical time. +// This checks that a logical action is scheduled the specified logical time +// after the current logical time. target TypeScript { fast: true, timeout: 3 sec diff --git a/test/TypeScript/src/SendingInside.lf b/test/TypeScript/src/SendingInside.lf index a22f637deb..ca4b6489b3 100644 --- a/test/TypeScript/src/SendingInside.lf +++ b/test/TypeScript/src/SendingInside.lf @@ -1,5 +1,5 @@ -// This tests a reactor that contains another reactor and also has its own reaction that routes -// inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own +// reaction that routes inputs to the contained reactor. target TypeScript { timeout: 10 sec, fast: true diff --git a/test/TypeScript/src/SendingInside2.lf b/test/TypeScript/src/SendingInside2.lf index f013b75549..a537191e4b 100644 --- a/test/TypeScript/src/SendingInside2.lf +++ b/test/TypeScript/src/SendingInside2.lf @@ -1,19 +1,19 @@ target TypeScript reactor Printer { - input x: number + input x: number - reaction(x) {= - console.log("Inside reactor received:" + x ); - if (x != 1) { - util.requestErrorStop("ERROR: Expected 1."); - } - =} + reaction(x) {= + console.log("Inside reactor received:" + x ); + if (x != 1) { + util.requestErrorStop("ERROR: Expected 1."); + } + =} } main reactor SendingInside2 { - timer t - p = new Printer() + timer t + p = new Printer() - reaction(t) -> p.x {= p.x = 1; =} + reaction(t) -> p.x {= p.x = 1; =} } diff --git a/test/TypeScript/src/SendsPointerTest.lf b/test/TypeScript/src/SendsPointerTest.lf index 6bdbf514af..3c80613b52 100644 --- a/test/TypeScript/src/SendsPointerTest.lf +++ b/test/TypeScript/src/SendsPointerTest.lf @@ -1,5 +1,5 @@ -// Source produces a dynamically allocated object, which it passes to Print. Reference counting -// ensures that the struct is freed. +// Source produces a dynamically allocated object, which it passes to Print. +// Reference counting ensures that the struct is freed. target TypeScript reactor SendsPointer { diff --git a/test/TypeScript/src/SimpleDeadline.lf b/test/TypeScript/src/SimpleDeadline.lf index d02fe0044c..a518e04e5e 100644 --- a/test/TypeScript/src/SimpleDeadline.lf +++ b/test/TypeScript/src/SimpleDeadline.lf @@ -1,5 +1,6 @@ -// Test local deadline, where a deadline is associated with a reaction definition. This test -// triggers a reaction exactly once with a deadline violation. +// Test local deadline, where a deadline is associated with a reaction +// definition. This test triggers a reaction exactly once with a deadline +// violation. target TypeScript reactor Deadline(threshold: time = 100 msec) { diff --git a/test/TypeScript/src/SimpleImport.lf b/test/TypeScript/src/SimpleImport.lf index 364c2f2ab3..72b6baa031 100644 --- a/test/TypeScript/src/SimpleImport.lf +++ b/test/TypeScript/src/SimpleImport.lf @@ -3,6 +3,6 @@ target TypeScript import HelloWorldInside from "HelloWorld.lf" main reactor SimpleImport { - a = new HelloWorldInside() - b = new HelloWorldInside() + a = new HelloWorldInside() + b = new HelloWorldInside() } diff --git a/test/TypeScript/src/SlowingClockPhysical.lf b/test/TypeScript/src/SlowingClockPhysical.lf index f1c65a92b7..53bc3f9da4 100644 --- a/test/TypeScript/src/SlowingClockPhysical.lf +++ b/test/TypeScript/src/SlowingClockPhysical.lf @@ -1,10 +1,12 @@ /** - * Output events at physical times at least 100, 300, and 600 msec after the start time. This uses a - * physical action with a minimum interarrival time of 100 msec. The reactor increases the - * interarrival time with each invocation of the schedule() function. The timestamps of the events - * will be exact because the physical time at which schedule() is called is always way smaller than - * the time of the last invocation (or start time) plus the minimum interarrival time. Hence, the - * minimum interarrival time always determines the time of the next event. + * Output events at physical times at least 100, 300, and 600 msec after the + * start time. This uses a physical action with a minimum interarrival time of + * 100 msec. The reactor increases the interarrival time with each invocation of + * the schedule() function. The timestamps of the events will be exact because + * the physical time at which schedule() is called is always way smaller than + * the time of the last invocation (or start time) plus the minimum interarrival + * time. Hence, the minimum interarrival time always determines the time of the + * next event. */ target TypeScript { timeout: 1 sec diff --git a/test/TypeScript/src/Stop.lf b/test/TypeScript/src/Stop.lf index 3464239b0a..6104c418d5 100644 --- a/test/TypeScript/src/Stop.lf +++ b/test/TypeScript/src/Stop.lf @@ -1,5 +1,6 @@ /** - * A test for the util.requestStop() functionality in TypeScript target Lingua Franca. + * A test for the util.requestStop() functionality in TypeScript target Lingua + * Franca. * * @author Soroush Bateni * @author Byeong-gil Jun diff --git a/test/TypeScript/src/Stride.lf b/test/TypeScript/src/Stride.lf index dd0ef5359e..04d7805d0b 100644 --- a/test/TypeScript/src/Stride.lf +++ b/test/TypeScript/src/Stride.lf @@ -1,5 +1,5 @@ -// This example illustrates state variables and parameters on the wiki. For this test, success is -// just compiling and running. +// This example illustrates state variables and parameters on the wiki. For this +// test, success is just compiling and running. target TypeScript { timeout: 2 sec, fast: true diff --git a/test/TypeScript/src/StructPrint.lf b/test/TypeScript/src/StructPrint.lf index 201f788779..e75d9ead37 100644 --- a/test/TypeScript/src/StructPrint.lf +++ b/test/TypeScript/src/StructPrint.lf @@ -1,5 +1,5 @@ -// Source produces a dynamically allocated struct, which it passes to Print. Reference counting -// ensures that the struct is freed. +// Source produces a dynamically allocated struct, which it passes to Print. +// Reference counting ensures that the struct is freed. target TypeScript reactor Source { diff --git a/test/TypeScript/src/TestForPreviousOutput.lf b/test/TypeScript/src/TestForPreviousOutput.lf index 0c37653ad0..c088ac1d6d 100644 --- a/test/TypeScript/src/TestForPreviousOutput.lf +++ b/test/TypeScript/src/TestForPreviousOutput.lf @@ -3,40 +3,40 @@ target TypeScript reactor Source { - output out: number + output out: number - reaction(startup) -> out {= - // Note: Math.random can't be seeded - // Randomly produce an output or not. - if (Math.random() > 0.5) { - out = 21; - } - =} + reaction(startup) -> out {= + // Note: Math.random can't be seeded + // Randomly produce an output or not. + if (Math.random() > 0.5) { + out = 21; + } + =} - reaction(startup) -> out {= - let previous_output = out; - if (previous_output) { - out = 2 * previous_output; - } else { - out = 42; - } - =} + reaction(startup) -> out {= + let previous_output = out; + if (previous_output) { + out = 2 * previous_output; + } else { + out = 42; + } + =} } reactor Sink { - input x: number + input x: number - reaction(x) {= - x = x as number; - console.log("Received " + x); - if (x != 42) { - util.requestErrorStop("FAILED: Expected 42.") - } - =} + reaction(x) {= + x = x as number; + console.log("Received " + x); + if (x != 42) { + util.requestErrorStop("FAILED: Expected 42.") + } + =} } main reactor TestForPreviousOutput { - s = new Source() - d = new Sink() - s.out -> d.x + s = new Source() + d = new Sink() + s.out -> d.x } diff --git a/test/TypeScript/src/TimeLimit.lf b/test/TypeScript/src/TimeLimit.lf index c837a4cbb4..05a2a5a3b3 100644 --- a/test/TypeScript/src/TimeLimit.lf +++ b/test/TypeScript/src/TimeLimit.lf @@ -1,6 +1,7 @@ -// Test that the stop function can be used to internally impose a a time limit. This is also used to -// test performance (number of reactions per second). Correct output for this 1, 2, 3, 4. Failure -// for this test is failing to halt or getting the wrong data. +// Test that the stop function can be used to internally impose a a time limit. +// This is also used to test performance (number of reactions per second). +// Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt +// or getting the wrong data. target TypeScript { fast: true, logging: INFO diff --git a/test/TypeScript/src/Wcet.lf b/test/TypeScript/src/Wcet.lf index 34fdd18dfc..a68e54c877 100644 --- a/test/TypeScript/src/Wcet.lf +++ b/test/TypeScript/src/Wcet.lf @@ -2,44 +2,44 @@ target TypeScript reactor Source { - output out1: number - output out2: number - timer t - - reaction(t) -> out1, out2 {= - out1 = 5; - out2 = 10; - =} + output out1: number + output out2: number + timer t + + reaction(t) -> out1, out2 {= + out1 = 5; + out2 = 10; + =} } reactor Work { - input in1: number - input in2: number - output out: number - - reaction(in1, in2) -> out {= - let ret:number; - if ((in1 as number) > 10) { - ret = (in2 as number) * (in1 as number); - } else { - ret = (in2 as number) + (in1 as number); - } - out = ret; - =} + input in1: number + input in2: number + output out: number + + reaction(in1, in2) -> out {= + let ret:number; + if ((in1 as number) > 10) { + ret = (in2 as number) * (in1 as number); + } else { + ret = (in2 as number) + (in1 as number); + } + out = ret; + =} } reactor Print { - input x: number + input x: number - reaction(x) {= console.log("Received: " + x); =} + reaction(x) {= console.log("Received: " + x); =} } main reactor Wcet { - source = new Source() - work = new Work() - print = new Print() + source = new Source() + work = new Work() + print = new Print() - source.out1 -> work.in1 - source.out2 -> work.in2 - work.out -> print.x + source.out1 -> work.in1 + source.out2 -> work.in2 + work.out -> print.x } diff --git a/test/TypeScript/src/docker/HelloWorldContainerized.lf b/test/TypeScript/src/docker/HelloWorldContainerized.lf index 75de9313a7..66b96312e9 100644 --- a/test/TypeScript/src/docker/HelloWorldContainerized.lf +++ b/test/TypeScript/src/docker/HelloWorldContainerized.lf @@ -1,9 +1,9 @@ target TypeScript { - docker: true + docker: true } import HelloWorldInside from "../HelloWorld.lf" main reactor HelloWorldContainerized { - a = new HelloWorldInside() + a = new HelloWorldInside() } diff --git a/test/TypeScript/src/federated/ChainWithDelay.lf b/test/TypeScript/src/federated/ChainWithDelay.lf index 286506258f..7c37d47d7f 100644 --- a/test/TypeScript/src/federated/ChainWithDelay.lf +++ b/test/TypeScript/src/federated/ChainWithDelay.lf @@ -5,7 +5,7 @@ * @author Youri Su */ target TypeScript { - timeout: 3 msec + timeout: 3 msec } import Count from "../lib/Count.lf" @@ -13,9 +13,9 @@ import InternalDelay from "../lib/InternalDelay.lf" import TestCount from "../lib/TestCount.lf" federated reactor { - c = new Count(period = 1 msec) - i = new InternalDelay(delay = 500 usec) - t = new TestCount(numInputs = 3) - c.out -> i.inp - i.out -> t.inp + c = new Count(period = 1 msec) + i = new InternalDelay(delay = 500 usec) + t = new TestCount(numInputs = 3) + c.out -> i.inp + i.out -> t.inp } diff --git a/test/TypeScript/src/federated/DistributedCount.lf b/test/TypeScript/src/federated/DistributedCount.lf index a85228f606..50f510cdcd 100644 --- a/test/TypeScript/src/federated/DistributedCount.lf +++ b/test/TypeScript/src/federated/DistributedCount.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee * @author Hokeun Kim */ diff --git a/test/TypeScript/src/federated/DistributedDoublePort.lf b/test/TypeScript/src/federated/DistributedDoublePort.lf index 056216e687..d3a2636661 100644 --- a/test/TypeScript/src/federated/DistributedDoublePort.lf +++ b/test/TypeScript/src/federated/DistributedDoublePort.lf @@ -1,6 +1,7 @@ /** - * Test the case for when two upstream federates send messages to a downstream federte on two - * different ports. One message should carry a microstep delay relative to the other message. + * Test the case for when two upstream federates send messages to a downstream + * federte on two different ports. One message should carry a microstep delay + * relative to the other message. * * @author Soroush Bateni * @author Hokeun Kim @@ -39,7 +40,9 @@ reactor Print { } =} - reaction(shutdown) {= console.log("SUCCESS: messages were at least one microstep apart."); =} + reaction(shutdown) {= + console.log("SUCCESS: messages were at least one microstep apart."); + =} } federated reactor DistributedDoublePort { diff --git a/test/TypeScript/src/federated/DistributedLoopedAction.lf b/test/TypeScript/src/federated/DistributedLoopedAction.lf index 46170a0d1f..02a7f5dc62 100644 --- a/test/TypeScript/src/federated/DistributedLoopedAction.lf +++ b/test/TypeScript/src/federated/DistributedLoopedAction.lf @@ -1,5 +1,6 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken into account. + * Test a sender-receiver network system that relies on microsteps being taken + * into account. * * @author Soroush Bateni * @author Hokeun Kim @@ -17,7 +18,8 @@ reactor Receiver(takeBreakAfter: number = 10, breakInterval: time = 400 msec) { state breaks: number = 0 timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more sensible log output. + // but forces the logical time to advance Comment this line for a more + // sensible log output. reaction(inp) {= console.log("At tag (" + util.getElapsedLogicalTime() + ", " + util.getCurrentTag().microstep + ") received value " + inp); totalReceivedMessages++; diff --git a/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf b/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf index aa14ba553d..842f13f74c 100644 --- a/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/TypeScript/src/federated/DistributedLoopedPhysicalAction.lf @@ -1,6 +1,7 @@ /** - * Test a sender-receiver network system that is similar to DistributedLoopedAction, but it uses a - * physical action rather than a logical action. + * Test a sender-receiver network system that is similar to + * DistributedLoopedAction, but it uses a physical action rather than a logical + * action. * * @author Soroush Bateni * @author Hokeun Kim @@ -35,7 +36,8 @@ reactor Receiver(takeBreakAfter: number = 10, breakInterval: time = 550 msec) { state breaks: number = 0 timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more sensible log output. + // but forces the logical time to advance Comment this line for a more + // sensible log output. reaction(inp) {= console.log("At tag (" + util.getElapsedLogicalTime() + ", " + util.getCurrentTag().microstep + ") received value " + inp); totalReceivedMessages++; diff --git a/test/TypeScript/src/federated/DistributedStop.lf b/test/TypeScript/src/federated/DistributedStop.lf index 6815501b4a..c0dd04149a 100644 --- a/test/TypeScript/src/federated/DistributedStop.lf +++ b/test/TypeScript/src/federated/DistributedStop.lf @@ -1,5 +1,6 @@ /** - * Test for util.requestStop() in federated execution with centralized coordination. + * Test for util.requestStop() in federated execution with centralized + * coordination. * * @author Soroush Bateni * @author Byeong-gil Jun diff --git a/test/TypeScript/src/federated/DistributedStopZero.lf b/test/TypeScript/src/federated/DistributedStopZero.lf index c85c3a21cf..846b98343c 100644 --- a/test/TypeScript/src/federated/DistributedStopZero.lf +++ b/test/TypeScript/src/federated/DistributedStopZero.lf @@ -8,66 +8,66 @@ target TypeScript reactor Sender { - output out: number - timer t(0, 1 usec) + output out: number + timer t(0, 1 usec) - reaction(t) -> out {= - console.log(`Sending 42 at ${util.getElapsedLogicalTime()}, ` - + `${util.getCurrentTag().microstep}).`); - out = 42; + reaction(t) -> out {= + console.log(`Sending 42 at ${util.getElapsedLogicalTime()}, ` + + `${util.getCurrentTag().microstep}).`); + out = 42; - let zero = util.getStartTag(); - if (util.getCurrentTag().isSimultaneousWith(zero)) { - // Request stop at ((0 secs, 0 nsecs), 0) - console.log(`Requesting stop at ${util.getElapsedLogicalTime()}, ` - + `${util.getCurrentTag().microstep}).`); - util.requestStop(); - } - =} + let zero = util.getStartTag(); + if (util.getCurrentTag().isSimultaneousWith(zero)) { + // Request stop at ((0 secs, 0 nsecs), 0) + console.log(`Requesting stop at ${util.getElapsedLogicalTime()}, ` + + `${util.getCurrentTag().microstep}).`); + util.requestStop(); + } + =} - reaction(shutdown) {= - if (!util.getElapsedLogicalTime().isEqualTo(TimeValue.usec(0))|| - util.getCurrentTag().microstep !== 1) { - util.requestErrorStop(`ERROR: Sender failed to stop the federation in time. ` - + `Stopping at (${util.getElapsedLogicalTime()}, ${util.getCurrentTag().microstep}).`); - } - console.log(`SUCCESS: Successfully stopped the federation at ` - + `(${util.getElapsedLogicalTime()}, ${util.getCurrentTag().microstep}).`); - =} + reaction(shutdown) {= + if (!util.getElapsedLogicalTime().isEqualTo(TimeValue.usec(0))|| + util.getCurrentTag().microstep !== 1) { + util.requestErrorStop(`ERROR: Sender failed to stop the federation in time. ` + + `Stopping at (${util.getElapsedLogicalTime()}, ${util.getCurrentTag().microstep}).`); + } + console.log(`SUCCESS: Successfully stopped the federation at ` + + `(${util.getElapsedLogicalTime()}, ${util.getCurrentTag().microstep}).`); + =} } reactor Receiver { - input in1: number + input in1: number - reaction(in1) {= - console.log(`Received ${in1} at (${util.getElapsedLogicalTime()}, ` + reaction(in1) {= + console.log(`Received ${in1} at (${util.getElapsedLogicalTime()}, ` + + `${util.getCurrentTag().microstep}).`); + let zero = util.getStartTag(); + if (util.getCurrentTag().isSimultaneousWith(zero)) { + // Request stop at ((0 secs, 0 nsecs), 0) + console.log(`Requesting stop at ${util.getElapsedLogicalTime()}, ` + `${util.getCurrentTag().microstep}).`); - let zero = util.getStartTag(); - if (util.getCurrentTag().isSimultaneousWith(zero)) { - // Request stop at ((0 secs, 0 nsecs), 0) - console.log(`Requesting stop at ${util.getElapsedLogicalTime()}, ` - + `${util.getCurrentTag().microstep}).`); - util.requestStop(); - } - =} + util.requestStop(); + } + =} - reaction(shutdown) {= - // Sender should have requested stop earlier than the receiver. - // Therefore, the shutdown events must occur at ((0 secs, 0 nsecs), 0) on the - // receiver. - if (!util.getElapsedLogicalTime().isEqualTo(TimeValue.usec(0)) || - util.getCurrentTag().microstep !== 1) { - util.requestErrorStop(`ERROR: Receiver failed to stop the federation at the right time. ` - + `Stopping at (${util.getElapsedLogicalTime()}, ${util.getCurrentTag().microstep}).`); - } - console.log(`SUCCESS: Successfully stopped the federation at ` - + `(${util.getElapsedLogicalTime()}, ${util.getCurrentTag().microstep}).`); - =} + reaction(shutdown) {= + // Sender should have requested stop earlier than the receiver. + // Therefore, the shutdown events must occur at ((0 secs, 0 nsecs), 0) on the + // receiver. + if (!util.getElapsedLogicalTime().isEqualTo(TimeValue.usec(0)) || + util.getCurrentTag().microstep !== 1) { + util.requestErrorStop(`ERROR: Receiver failed to stop the federation at the right time. ` + + `Stopping at (${util.getElapsedLogicalTime()}, ${util.getCurrentTag().microstep}).`); + } + console.log(`SUCCESS: Successfully stopped the federation at ` + + `(${util.getElapsedLogicalTime()}, ${util.getCurrentTag().microstep}).`); + =} } federated reactor { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in1 + sender.out -> receiver.in1 } diff --git a/test/TypeScript/src/federated/HelloDistributed.lf b/test/TypeScript/src/federated/HelloDistributed.lf index a8376910c1..1189270ab1 100644 --- a/test/TypeScript/src/federated/HelloDistributed.lf +++ b/test/TypeScript/src/federated/HelloDistributed.lf @@ -1,7 +1,8 @@ /** - * Test a particularly simple form of a distributed deterministic system where a federation that - * receives timestamped messages has only those messages as triggers. Therefore, no additional - * coordination of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a + * federation that receives timestamped messages has only those messages as + * triggers. Therefore, no additional coordination of the advancement of time + * (HLA or Ptides) is needed. * @author Edward A. Lee * @author Hokeun Kim */ @@ -44,5 +45,7 @@ federated reactor HelloDistributed at localhost { d = new Destination() // Reactor d is in federate Destination s.out -> d.inp // This version preserves the timestamp. - reaction(startup) {= console.log("Printing something in top-level federated reactor."); =} + reaction(startup) {= + console.log("Printing something in top-level federated reactor."); + =} } diff --git a/test/TypeScript/src/federated/LoopDistributedCentralized.lf b/test/TypeScript/src/federated/LoopDistributedCentralized.lf index 042d917106..bb52679489 100644 --- a/test/TypeScript/src/federated/LoopDistributedCentralized.lf +++ b/test/TypeScript/src/federated/LoopDistributedCentralized.lf @@ -1,5 +1,6 @@ /** - * This tests a feedback loop with physical actions and centralized coordination. + * This tests a feedback loop with physical actions and centralized + * coordination. * * @author Edward A. Lee * @author Hokeun Kim diff --git a/test/TypeScript/src/federated/LoopDistributedDouble.lf b/test/TypeScript/src/federated/LoopDistributedDouble.lf index ac82edbd0d..2c791377f7 100644 --- a/test/TypeScript/src/federated/LoopDistributedDouble.lf +++ b/test/TypeScript/src/federated/LoopDistributedDouble.lf @@ -1,5 +1,6 @@ /** - * This tests a feedback loop with physical actions and centralized coordination. + * This tests a feedback loop with physical actions and centralized + * coordination. * * @author Edward A. Lee * @author Hokeun Kim diff --git a/test/TypeScript/src/federated/SimpleFederated.lf b/test/TypeScript/src/federated/SimpleFederated.lf index 804eec10aa..e85627d073 100644 --- a/test/TypeScript/src/federated/SimpleFederated.lf +++ b/test/TypeScript/src/federated/SimpleFederated.lf @@ -1,16 +1,16 @@ target TypeScript { - timeout: 2 secs + timeout: 2 secs } reactor Fed { - input inp: number - output out: number + input inp: number + output out: number } federated reactor { - fed1 = new Fed() - fed2 = new Fed() + fed1 = new Fed() + fed2 = new Fed() - fed1.out -> fed2.inp - fed2.out -> fed1.inp + fed1.out -> fed2.inp + fed2.out -> fed1.inp } diff --git a/test/TypeScript/src/federated/StopAtShutdown.lf b/test/TypeScript/src/federated/StopAtShutdown.lf index 44ca12aa04..200e773e82 100644 --- a/test/TypeScript/src/federated/StopAtShutdown.lf +++ b/test/TypeScript/src/federated/StopAtShutdown.lf @@ -4,30 +4,30 @@ * Original bug discovered by Steven Wong */ target TypeScript { - timeout: 2 sec + timeout: 2 sec } reactor A { - input inp: number + input inp: number - reaction(startup) {= console.log("Hello World!"); =} + reaction(startup) {= console.log("Hello World!"); =} - reaction(inp) {= console.log("Got it"); =} + reaction(inp) {= console.log("Got it"); =} - reaction(shutdown) {= util.requestStop(); =} + reaction(shutdown) {= util.requestStop(); =} } reactor B { - output out: number - timer t(1 sec) + output out: number + timer t(1 sec) - reaction(t) -> out {= out = 1; =} + reaction(t) -> out {= out = 1; =} - reaction(shutdown) {= util.requestStop(); =} + reaction(shutdown) {= util.requestStop(); =} } federated reactor { - a = new A() - b = new B() - b.out -> a.inp + a = new A() + b = new B() + b.out -> a.inp } diff --git a/test/TypeScript/src/federated/TopLevelArtifacts.lf b/test/TypeScript/src/federated/TopLevelArtifacts.lf index cd5909a1f7..917da033f5 100644 --- a/test/TypeScript/src/federated/TopLevelArtifacts.lf +++ b/test/TypeScript/src/federated/TopLevelArtifacts.lf @@ -1,10 +1,11 @@ /** - * Test whether top-level reactions, actions, and ports are handled appropriately. + * Test whether top-level reactions, actions, and ports are handled + * appropriately. * * Currently, these artifacts are replicated on all federates. * - * @note This just tests for the correctness of the code generation. These top-level artifacts might - * be disallowed in the future. + * @note This just tests for the correctness of the code generation. These + * top-level artifacts might be disallowed in the future. * @author Youri Su */ target TypeScript { diff --git a/test/TypeScript/src/lib/Imported.lf b/test/TypeScript/src/lib/Imported.lf index 52ed1e4c85..9b8506f39b 100644 --- a/test/TypeScript/src/lib/Imported.lf +++ b/test/TypeScript/src/lib/Imported.lf @@ -1,14 +1,14 @@ // This is used by the test for the ability to import a reactor definition that itself imports a // reactor definition. target TypeScript { - timeout: 2 sec + timeout: 2 sec } import ImportedAgain from "ImportedAgain.lf" reactor Imported { - input x: number - a = new ImportedAgain() + input x: number + a = new ImportedAgain() - reaction(x) -> a.x {= a.x = (x as number); =} + reaction(x) -> a.x {= a.x = (x as number); =} } diff --git a/test/TypeScript/src/lib/ImportedAgain.lf b/test/TypeScript/src/lib/ImportedAgain.lf index a98513b692..e10ab4aa53 100644 --- a/test/TypeScript/src/lib/ImportedAgain.lf +++ b/test/TypeScript/src/lib/ImportedAgain.lf @@ -1,16 +1,16 @@ // This is used by the test for the ability to import a reactor definition that itself imports a // reactor definition. target TypeScript { - timeout: 2 sec + timeout: 2 sec } reactor ImportedAgain { - input x: number + input x: number - reaction(x) {= - console.log("Received: " + x); - if ((x as number) != 42) { - util.requestErrorStop("ERROR: Expected input to be 42. Got: " + x); - } - =} + reaction(x) {= + console.log("Received: " + x); + if ((x as number) != 42) { + util.requestErrorStop("ERROR: Expected input to be 42. Got: " + x); + } + =} } diff --git a/test/TypeScript/src/lib/LoopedActionSender.lf b/test/TypeScript/src/lib/LoopedActionSender.lf index eb441ff2e8..7da4c133b0 100644 --- a/test/TypeScript/src/lib/LoopedActionSender.lf +++ b/test/TypeScript/src/lib/LoopedActionSender.lf @@ -7,9 +7,10 @@ target TypeScript /** - * @param takeBreakAfter: Indicates how many messages are sent in consecutive superdense time - * @param breakInterval: Determines how long the reactor should take a break after sending - * takeBreakAfter messages. + * @param takeBreakAfter: Indicates how many messages are sent in consecutive + * superdense time + * @param breakInterval: Determines how long the reactor should take a break + * after sending takeBreakAfter messages. */ reactor Sender(takeBreakAfter: number = 10, breakInterval: time = 400 msec) { output out: number diff --git a/test/TypeScript/src/lib/TestCount.lf b/test/TypeScript/src/lib/TestCount.lf index d5181f10f0..822b4c64b1 100644 --- a/test/TypeScript/src/lib/TestCount.lf +++ b/test/TypeScript/src/lib/TestCount.lf @@ -1,6 +1,7 @@ /** - * Test that a counting sequence of inputs starts with the specified start parameter value, - * increments by the specified stride, and receives the specified number of inputs. + * Test that a counting sequence of inputs starts with the specified start + * parameter value, increments by the specified stride, and receives the + * specified number of inputs. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. diff --git a/test/TypeScript/src/multiport/BankMulticast.lf b/test/TypeScript/src/multiport/BankMulticast.lf index 84a7acb6c6..64a944deea 100644 --- a/test/TypeScript/src/multiport/BankMulticast.lf +++ b/test/TypeScript/src/multiport/BankMulticast.lf @@ -3,35 +3,35 @@ * the container's output port. */ target TypeScript { - timeout: 3 sec + timeout: 3 sec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Foo { - input inp: number - output out: number + input inp: number + output out: number - c = new Count() - c.out -> out + c = new Count() + c.out -> out - d = new TestCount(numInputs = 4) - inp -> d.inp + d = new TestCount(numInputs = 4) + inp -> d.inp } reactor Bar { - output[4] out: number + output[4] out: number - foo = new[4] Foo() + foo = new[4] Foo() - foo.out -> foo.inp - foo.out -> out + foo.out -> foo.inp + foo.out -> out } main reactor { - bar = new Bar() + bar = new Bar() - d = new[4] TestCount(numInputs = 4) - bar.out -> d.inp + d = new[4] TestCount(numInputs = 4) + bar.out -> d.inp } diff --git a/test/TypeScript/src/multiport/BankReactionsInContainer.lf b/test/TypeScript/src/multiport/BankReactionsInContainer.lf index 485f1074f1..b14ca33f70 100644 --- a/test/TypeScript/src/multiport/BankReactionsInContainer.lf +++ b/test/TypeScript/src/multiport/BankReactionsInContainer.lf @@ -1,4 +1,6 @@ -/** This tests an output that is broadcast back to a multiport input of a bank. */ +/** + * This tests an output that is broadcast back to a multiport input of a bank. + */ target TypeScript { timeout: 1 sec } diff --git a/test/TypeScript/src/multiport/BankSelfBroadcast.lf b/test/TypeScript/src/multiport/BankSelfBroadcast.lf index 50d6683592..cf5af4bee3 100644 --- a/test/TypeScript/src/multiport/BankSelfBroadcast.lf +++ b/test/TypeScript/src/multiport/BankSelfBroadcast.lf @@ -1,7 +1,7 @@ /** - * Test a bank of reactors that broadcast a single output back to a multiport input of the same - * reactors in the bank so that each reactor in the bank receives the output produced by itself and - * each other reactor. + * Test a bank of reactors that broadcast a single output back to a multiport + * input of the same reactors in the bank so that each reactor in the bank + * receives the output produced by itself and each other reactor. * * @author Edward A. Lee * @author Christian Menard diff --git a/test/TypeScript/src/multiport/Broadcast.lf b/test/TypeScript/src/multiport/Broadcast.lf index b1fbacb029..c43b81f736 100644 --- a/test/TypeScript/src/multiport/Broadcast.lf +++ b/test/TypeScript/src/multiport/Broadcast.lf @@ -1,24 +1,24 @@ target TypeScript reactor Source { - output out: number + output out: number - reaction(startup) -> out {= out = 42; =} + reaction(startup) -> out {= out = 42; =} } reactor Sink { - input inp: number + input inp: number - reaction(inp) {= - console.log("Received " + inp); - if (inp != 42) { - util.requestErrorStop("Error: expected " + 42); - } - =} + reaction(inp) {= + console.log("Received " + inp); + if (inp != 42) { + util.requestErrorStop("Error: expected " + 42); + } + =} } main reactor { - source = new Source() - sink = new[4] Sink() - (source.out)+ -> sink.inp + source = new Source() + sink = new[4] Sink() + (source.out)+ -> sink.inp } diff --git a/test/TypeScript/src/multiport/MultiportFromBank.lf b/test/TypeScript/src/multiport/MultiportFromBank.lf index 53f8c523ee..18896eed2a 100644 --- a/test/TypeScript/src/multiport/MultiportFromBank.lf +++ b/test/TypeScript/src/multiport/MultiportFromBank.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf b/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf index c896494897..ffc394b26c 100644 --- a/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportFromBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/TypeScript/src/multiport/MultiportFromBankHierarchyAfter.lf index 1462f157a5..b960ff2bc1 100644 --- a/test/TypeScript/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/TypeScript/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,14 +1,14 @@ // Check multiport output to bank of recipients. Here, the bank is smaller than the width of the // sending port. target TypeScript { - timeout: 2 sec + timeout: 2 sec } import Destination from "MultiportFromBank.lf" import Container from "MultiportFromBankHierarchy.lf" main reactor MultiportFromBankHierarchyAfter { - a = new Container(portWidth = 4) - b = new Destination(portWidth = 4) - a.out -> b.inp after 1 sec + a = new Container(portWidth = 4) + b = new Destination(portWidth = 4) + a.out -> b.inp after 1 sec } diff --git a/test/TypeScript/src/multiport/MultiportFromHierarchy.lf b/test/TypeScript/src/multiport/MultiportFromHierarchy.lf index b294dc3995..5627652b2f 100644 --- a/test/TypeScript/src/multiport/MultiportFromHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportFromHierarchy.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input, where the former is a hierarchical reactor. +// Check multiport output to multiport input, where the former is a hierarchical +// reactor. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportIn.lf b/test/TypeScript/src/multiport/MultiportIn.lf index 346eeffa11..97a36c08d2 100644 --- a/test/TypeScript/src/multiport/MultiportIn.lf +++ b/test/TypeScript/src/multiport/MultiportIn.lf @@ -1,5 +1,5 @@ -// This is a version of the test that uses a multiport input at the destination. Its purpose is to -// test multiport inputs. +// This is a version of the test that uses a multiport input at the destination. +// Its purpose is to test multiport inputs. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportInParameterized.lf b/test/TypeScript/src/multiport/MultiportInParameterized.lf index 3ff15c14dc..fb11c5e102 100644 --- a/test/TypeScript/src/multiport/MultiportInParameterized.lf +++ b/test/TypeScript/src/multiport/MultiportInParameterized.lf @@ -1,5 +1,5 @@ -// This is a version of the Threaded test that uses a multiport input at the destination. Its -// purpose is to test multiport inputs. +// This is a version of the Threaded test that uses a multiport input at the +// destination. Its purpose is to test multiport inputs. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportMutableInput.lf b/test/TypeScript/src/multiport/MultiportMutableInput.lf index c570b5b245..11120e8d30 100644 --- a/test/TypeScript/src/multiport/MultiportMutableInput.lf +++ b/test/TypeScript/src/multiport/MultiportMutableInput.lf @@ -1,5 +1,6 @@ -// Source produces a ints on a multiport, which it passes to Scale. Scale requests a writable copy. -// It modifies it and passes it to Print. It gets freed after Print is done with it. +// Source produces a ints on a multiport, which it passes to Scale. Scale +// requests a writable copy. It modifies it and passes it to Print. It gets +// freed after Print is done with it. target TypeScript reactor Source { diff --git a/test/TypeScript/src/multiport/MultiportMutableInputArray.lf b/test/TypeScript/src/multiport/MultiportMutableInputArray.lf index d91b6aa8ac..382f444df7 100644 --- a/test/TypeScript/src/multiport/MultiportMutableInputArray.lf +++ b/test/TypeScript/src/multiport/MultiportMutableInputArray.lf @@ -1,6 +1,7 @@ -// Source produces a dynamically allocated arrays on a multiport, which it passes to Scale. Scale -// requests a writable copy, which, instead of copying, it just gets ownership of the original -// array. It modifies it and passes it to Print. It gets freed after Print is done with it. +// Source produces a dynamically allocated arrays on a multiport, which it +// passes to Scale. Scale requests a writable copy, which, instead of copying, +// it just gets ownership of the original array. It modifies it and passes it to +// Print. It gets freed after Print is done with it. target TypeScript reactor Source { diff --git a/test/TypeScript/src/multiport/MultiportToBank.lf b/test/TypeScript/src/multiport/MultiportToBank.lf index e0e864cedd..efc4fcca4d 100644 --- a/test/TypeScript/src/multiport/MultiportToBank.lf +++ b/test/TypeScript/src/multiport/MultiportToBank.lf @@ -1,28 +1,28 @@ target TypeScript reactor Source { - output[4] out: number + output[4] out: number - reaction(startup) -> out {= - for (let i = 0 ; i < out.length; i++) { - out[i] = i; - } - =} + reaction(startup) -> out {= + for (let i = 0 ; i < out.length; i++) { + out[i] = i; + } + =} } reactor Sink { - input inp: number + input inp: number - reaction(inp) {= - console.log("Received " + inp); - if (inp != this.getBankIndex()) { - util.requestErrorStop("Error: expected " + this.getBankIndex()); - } - =} + reaction(inp) {= + console.log("Received " + inp); + if (inp != this.getBankIndex()) { + util.requestErrorStop("Error: expected " + this.getBankIndex()); + } + =} } main reactor MultiportToBank { - source = new Source() - sink = new[4] Sink() - source.out -> sink.inp + source = new Source() + sink = new[4] Sink() + source.out -> sink.inp } diff --git a/test/TypeScript/src/multiport/MultiportToBankAfter.lf b/test/TypeScript/src/multiport/MultiportToBankAfter.lf index b8005863ff..ee10df94c6 100644 --- a/test/TypeScript/src/multiport/MultiportToBankAfter.lf +++ b/test/TypeScript/src/multiport/MultiportToBankAfter.lf @@ -1,4 +1,5 @@ -// Check multiport output to bank of recipients where the width of the bank is inferred. +// Check multiport output to bank of recipients where the width of the bank is +// inferred. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportToBankDouble.lf b/test/TypeScript/src/multiport/MultiportToBankDouble.lf index 32b5e86b7c..e618dd898d 100644 --- a/test/TypeScript/src/multiport/MultiportToBankDouble.lf +++ b/test/TypeScript/src/multiport/MultiportToBankDouble.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients where the source has two reactions that write to the -// output. +// Check multiport output to bank of recipients where the source has two +// reactions that write to the output. target TypeScript { timeout: 2 sec } @@ -13,8 +13,8 @@ reactor Source { } =} - // Test also that multiple appearances of the same effect port do not result in multiple - // allocations of memory for the port. + // Test also that multiple appearances of the same effect port do not result + // in multiple allocations of memory for the port. reaction(startup) -> out {= // Contents of the reactions does not matter (either could be empty) for (let i = 0; i < out.length; i++) { diff --git a/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf b/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf index a2e60ef8c2..7420704ce1 100644 --- a/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportToBankHierarchy.lf @@ -1,5 +1,5 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the -// sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than +// the width of the sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportToHierarchy.lf b/test/TypeScript/src/multiport/MultiportToHierarchy.lf index 01edeb3192..c620000872 100644 --- a/test/TypeScript/src/multiport/MultiportToHierarchy.lf +++ b/test/TypeScript/src/multiport/MultiportToHierarchy.lf @@ -1,5 +1,6 @@ -// Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that -// the destination reactor has width wider than the sender, so one input is dangling. +// Check multiport output to multiport input, where the latter is a hierarchical +// reactor. Note that the destination reactor has width wider than the sender, +// so one input is dangling. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportToMultiportArray.lf b/test/TypeScript/src/multiport/MultiportToMultiportArray.lf index ba1f578f09..737603a5bd 100644 --- a/test/TypeScript/src/multiport/MultiportToMultiportArray.lf +++ b/test/TypeScript/src/multiport/MultiportToMultiportArray.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input. Destination port is wider than sending port. +// Check multiport output to multiport input. Destination port is wider than +// sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/MultiportToPort.lf b/test/TypeScript/src/multiport/MultiportToPort.lf index caf87f1d3b..a00d482fe8 100644 --- a/test/TypeScript/src/multiport/MultiportToPort.lf +++ b/test/TypeScript/src/multiport/MultiportToPort.lf @@ -1,4 +1,5 @@ -// Check multiport output to multiport input. Destination port is wider than sending port. +// Check multiport output to multiport input. Destination port is wider than +// sending port. target TypeScript { timeout: 2 sec } diff --git a/test/TypeScript/src/multiport/PipelineAfter.lf b/test/TypeScript/src/multiport/PipelineAfter.lf index b11455cb47..5835193d9c 100644 --- a/test/TypeScript/src/multiport/PipelineAfter.lf +++ b/test/TypeScript/src/multiport/PipelineAfter.lf @@ -1,36 +1,36 @@ target TypeScript reactor Source { - output out: number + output out: number - reaction(startup) -> out {= out = 40; =} + reaction(startup) -> out {= out = 40; =} } reactor Compute { - input inp: number - output out: number + input inp: number + output out: number - reaction(inp) -> out {= out = (inp as number) + 2; =} + reaction(inp) -> out {= out = (inp as number) + 2; =} } reactor Sink { - input inp: number - - reaction(inp) {= - console.log("Received " + inp); - if (inp != 42) { - util.requestErrorStop("ERROR: expected 42!"); - } - if (!util.getElapsedLogicalTime().isEqualTo(TimeValue.sec(1))) { - util.requestErrorStop("ERROR: Expected to receive input after one second."); - } - =} + input inp: number + + reaction(inp) {= + console.log("Received " + inp); + if (inp != 42) { + util.requestErrorStop("ERROR: expected 42!"); + } + if (!util.getElapsedLogicalTime().isEqualTo(TimeValue.sec(1))) { + util.requestErrorStop("ERROR: Expected to receive input after one second."); + } + =} } main reactor { - source = new Source() - compute = new Compute() - sink = new Sink() + source = new Source() + compute = new Compute() + sink = new Sink() - source.out, compute.out -> compute.inp, sink.inp after 500 msec + source.out, compute.out -> compute.inp, sink.inp after 500 msec } diff --git a/test/TypeScript/src/multiport/ReactionsToNested.lf b/test/TypeScript/src/multiport/ReactionsToNested.lf index 514973762a..055e08d086 100644 --- a/test/TypeScript/src/multiport/ReactionsToNested.lf +++ b/test/TypeScript/src/multiport/ReactionsToNested.lf @@ -1,4 +1,5 @@ -// This test connects a simple counting source to tester that checks against its own count. +// This test connects a simple counting source to tester that checks against its +// own count. target TypeScript { timeout: 1 sec } diff --git a/test/TypeScript/src/serialization/ProtoNoPacking.lf b/test/TypeScript/src/serialization/ProtoNoPacking.lf index 02c6f71c0e..8e35981c6c 100644 --- a/test/TypeScript/src/serialization/ProtoNoPacking.lf +++ b/test/TypeScript/src/serialization/ProtoNoPacking.lf @@ -11,36 +11,36 @@ * Building protobuf from source is slow, so avoid doing that if possible. */ target TypeScript { - protobufs: ProtoHelloWorld.proto + protobufs: ProtoHelloWorld.proto } reactor SourceProto { - output out: ProtoHelloWorld.ProtoHelloWorld + output out: ProtoHelloWorld.ProtoHelloWorld - reaction(startup) -> out {= - // The contents of a compiled proto file are imported in - // TypeScript as "import * as <.protoFileName>". So the constructor - // for class ProtoHelloWorld from the file ProtoHelloWorld.proto is - // ProtoHelloWorld.ProtoHelloWorld() - let helloObject = new ProtoHelloWorld.ProtoHelloWorld(); - helloObject.setName("Hello World"); - helloObject.setNumber(42); - out = helloObject; - =} + reaction(startup) -> out {= + // The contents of a compiled proto file are imported in + // TypeScript as "import * as <.protoFileName>". So the constructor + // for class ProtoHelloWorld from the file ProtoHelloWorld.proto is + // ProtoHelloWorld.ProtoHelloWorld() + let helloObject = new ProtoHelloWorld.ProtoHelloWorld(); + helloObject.setName("Hello World"); + helloObject.setNumber(42); + out = helloObject; + =} } reactor SinkProto { - input x: ProtoHelloWorld.ProtoHelloWorld + input x: ProtoHelloWorld.ProtoHelloWorld - reaction(x) {= - if (x !== undefined) { - console.log(`Received: name=${x.getName()}, number=${x.getNumber()}.`) - } - =} + reaction(x) {= + if (x !== undefined) { + console.log(`Received: name=${x.getName()}, number=${x.getNumber()}.`) + } + =} } main reactor ProtoNoPacking { - s = new SourceProto() - d = new SinkProto() - s.out -> d.x + s = new SourceProto() + d = new SinkProto() + s.out -> d.x } diff --git a/test/TypeScript/src/target/AfterNoTypes.lf b/test/TypeScript/src/target/AfterNoTypes.lf index 5d698cb3e0..b3477bbf55 100644 --- a/test/TypeScript/src/target/AfterNoTypes.lf +++ b/test/TypeScript/src/target/AfterNoTypes.lf @@ -1,4 +1,5 @@ -// This test demonstrates that after can be used on connections with ports that have no types. +// This test demonstrates that after can be used on connections with ports that +// have no types. target TypeScript { fast: false, timeout: 3 sec From 66e95e6b8abe990d900d431c7ac85d713d78b46c Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 17 May 2023 23:21:16 -0700 Subject: [PATCH 415/709] Reformat all integration tests. --- build.gradle | 2 +- .../src/org/lflang/ast/FormattingUtils.java | 4 +- test/C/src/ActionDelay.lf | 60 ++-- test/C/src/ActionIsPresent.lf | 38 +-- test/C/src/After.lf | 73 +++-- test/C/src/AfterCycles.lf | 98 +++---- test/C/src/AfterOverlapped.lf | 64 ++--- test/C/src/AfterZero.lf | 83 +++--- test/C/src/Alignment.lf | 165 ++++++----- test/C/src/ArrayAsParameter.lf | 67 +++-- test/C/src/ArrayAsType.lf | 62 ++-- test/C/src/ArrayFree.lf | 38 +-- test/C/src/ArrayFreeMultiple.lf | 60 ++-- test/C/src/ArrayParallel.lf | 10 +- test/C/src/ArrayPrint.lf | 84 +++--- test/C/src/ArrayScale.lf | 37 ++- test/C/src/CharLiteralInitializer.lf | 14 +- test/C/src/Composition.lf | 59 ++-- test/C/src/CompositionAfter.lf | 47 ++-- test/C/src/CompositionInheritance.lf | 81 +++--- test/C/src/CountSelf.lf | 30 +- test/C/src/Deadline.lf | 91 +++--- test/C/src/DeadlineHandledAbove.lf | 76 ++--- test/C/src/DeadlineInherited.lf | 30 +- test/C/src/DeadlinePriority.lf | 28 +- test/C/src/DeadlineWithAfterDelay.lf | 38 +-- test/C/src/DeadlineWithBanks.lf | 85 +++--- test/C/src/DeadlineZero.lf | 26 +- test/C/src/DelayArray.lf | 91 +++--- test/C/src/DelayArrayWithAfter.lf | 107 ++++--- test/C/src/DelayInt.lf | 96 ++++--- test/C/src/DelayPointer.lf | 106 +++---- test/C/src/DelayString.lf | 73 +++-- test/C/src/DelayStruct.lf | 80 +++--- test/C/src/DelayStructWithAfter.lf | 42 +-- test/C/src/DelayStructWithAfterOverlapped.lf | 76 ++--- test/C/src/DelayedAction.lf | 36 +-- test/C/src/DoubleInvocation.lf | 75 +++-- test/C/src/DoublePort.lf | 59 ++-- test/C/src/DoubleReaction.lf | 68 ++--- test/C/src/DoubleTrigger.lf | 43 ++- test/C/src/FilePkgReader.lf | 78 ++--- test/C/src/FileReader.lf | 64 ++--- test/C/src/FloatLiteral.lf | 39 ++- test/C/src/Gain.lf | 48 ++-- test/C/src/GetMicroStep.lf | 26 +- test/C/src/Hello.lf | 89 +++--- test/C/src/HelloWorld.lf | 36 +-- test/C/src/Hierarchy2.lf | 86 +++--- test/C/src/IdentifierLength.lf | 52 ++-- test/C/src/ImportComposition.lf | 47 ++-- test/C/src/InheritanceAction.lf | 49 ++-- test/C/src/ManualDelayedReaction.lf | 70 +++-- test/C/src/Methods.lf | 30 +- test/C/src/MethodsRecursive.lf | 22 +- test/C/src/MethodsSameName.lf | 38 +-- test/C/src/MovingAverage.lf | 79 +++--- test/C/src/MultipleContained.lf | 65 +++-- test/C/src/MultipleOutputs.lf | 47 ++-- test/C/src/NativeListsAndTimes.lf | 41 ++- test/C/src/NestedTriggeredReactions.lf | 40 +-- test/C/src/ParameterHierarchy.lf | 20 +- test/C/src/ParameterizedState.lf | 6 +- test/C/src/PeriodicDesugared.lf | 30 +- test/C/src/PhysicalConnection.lf | 28 +- test/C/src/PingPong.lf | 83 +++--- test/C/src/PreambleFileLevel.lf | 7 +- test/C/src/PreambleInherited.lf | 10 +- test/C/src/ReadOutputOfContainedReactor.lf | 75 +++-- test/C/src/RequestStop.lf | 17 +- test/C/src/ScheduleLogicalAction.lf | 62 ++-- test/C/src/ScheduleValue.lf | 16 +- test/C/src/SelfLoop.lf | 56 ++-- test/C/src/SendingInside.lf | 42 +-- test/C/src/SendsPointerTest.lf | 36 +-- test/C/src/SetArray.lf | 68 ++--- test/C/src/SetToken.lf | 30 +- test/C/src/SimpleDeadline.lf | 67 +++-- test/C/src/SlowingClock.lf | 65 +++-- test/C/src/SlowingClockPhysical.lf | 69 +++-- test/C/src/Starvation.lf | 98 +++---- test/C/src/Stop.lf | 88 +++--- test/C/src/StopZero.lf | 172 +++++------ test/C/src/Stride.lf | 46 +-- test/C/src/StructAsState.lf | 28 +- test/C/src/StructAsType.lf | 50 ++-- test/C/src/StructAsTypeDirect.lf | 38 +-- test/C/src/StructParallel.lf | 81 +++--- test/C/src/StructPrint.lf | 46 +-- test/C/src/StructScale.lf | 90 +++--- test/C/src/SubclassesAndStartup.lf | 54 ++-- test/C/src/TestForPreviousOutput.lf | 14 +- test/C/src/TimeLimit.lf | 67 +++-- test/C/src/TimeState.lf | 6 +- test/C/src/Timeout.lf | 62 ++-- test/C/src/TimeoutZero.lf | 65 +++-- test/C/src/ToReactionNested.lf | 44 +-- test/C/src/TriggerDownstreamOnlyIfPresent2.lf | 49 ++-- test/C/src/UnconnectedInput.lf | 60 ++-- test/C/src/arduino/AnalogReadSerial.lf | 25 +- test/C/src/arduino/Blink.lf | 23 +- test/C/src/arduino/BlinkAttemptThreading.lf | 27 +- test/C/src/arduino/BlinkMBED.lf | 23 +- test/C/src/arduino/DigitalReadSerial.lf | 29 +- test/C/src/arduino/Fade.lf | 45 ++- test/C/src/arduino/ReadAnalogVoltage.lf | 37 ++- test/C/src/concurrent/AsyncCallback.lf | 118 ++++---- test/C/src/concurrent/AsyncCallbackDrop.lf | 119 ++++---- test/C/src/concurrent/AsyncCallbackReplace.lf | 119 ++++---- test/C/src/concurrent/CompositionThreaded.lf | 47 ++-- .../DeadlineHandledAboveThreaded.lf | 76 ++--- test/C/src/concurrent/DeadlineThreaded.lf | 91 +++--- test/C/src/concurrent/DelayIntThreaded.lf | 90 +++--- .../src/concurrent/DoubleReactionThreaded.lf | 68 ++--- test/C/src/concurrent/GainThreaded.lf | 48 ++-- test/C/src/concurrent/HelloThreaded.lf | 89 +++--- test/C/src/concurrent/PingPongThreaded.lf | 86 +++--- test/C/src/concurrent/ScheduleAt.lf | 160 +++++------ test/C/src/concurrent/ScheduleTwice.lf | 54 ++-- .../C/src/concurrent/ScheduleTwiceThreaded.lf | 48 ++-- .../C/src/concurrent/SendingInsideThreaded.lf | 42 +-- test/C/src/concurrent/StarvationThreaded.lf | 99 ++++--- test/C/src/concurrent/StopThreaded.lf | 96 +++---- test/C/src/concurrent/StopZeroThreaded.lf | 171 ++++++----- test/C/src/concurrent/Threaded.lf | 97 ++++--- test/C/src/concurrent/ThreadedMultiport.lf | 101 ++++--- test/C/src/concurrent/ThreadedThreaded.lf | 96 ++++--- test/C/src/concurrent/TimeLimitThreaded.lf | 66 ++--- test/C/src/concurrent/TimeoutThreaded.lf | 65 +++-- test/C/src/concurrent/TimeoutZeroThreaded.lf | 66 ++--- test/C/src/concurrent/Tracing.lf | 147 +++++----- .../DistributedCountContainerized.lf | 25 +- test/C/src/federated/BroadcastFeedback.lf | 42 ++- .../BroadcastFeedbackWithHierarchy.lf | 48 ++-- test/C/src/federated/CycleDetection.lf | 76 ++--- test/C/src/federated/DecentralizedP2PComm.lf | 78 +++-- .../DecentralizedP2PUnbalancedTimeout.lf | 69 +++-- ...centralizedP2PUnbalancedTimeoutPhysical.lf | 67 +++-- test/C/src/federated/DistributedBank.lf | 22 +- .../federated/DistributedBankToMultiport.lf | 38 +-- test/C/src/federated/DistributedCount.lf | 53 ++-- .../DistributedCountDecentralized.lf | 74 +++-- .../DistributedCountDecentralizedLate.lf | 97 ++++--- ...tributedCountDecentralizedLateHierarchy.lf | 137 +++++---- .../src/federated/DistributedCountPhysical.lf | 76 ++--- .../DistributedCountPhysicalAfterDelay.lf | 69 +++-- .../DistributedCountPhysicalDecentralized.lf | 76 ++--- test/C/src/federated/DistributedDoublePort.lf | 59 ++-- .../DistributedLogicalActionUpstreamLong.lf | 92 +++--- .../src/federated/DistributedLoopedAction.lf | 101 ++++--- .../DistributedLoopedActionDecentralized.lf | 194 ++++++------- .../DistributedLoopedPhysicalAction.lf | 129 ++++----- test/C/src/federated/DistributedMultiport.lf | 56 ++-- .../federated/DistributedMultiportToBank.lf | 52 ++-- .../federated/DistributedMultiportToken.lf | 64 ++--- .../src/federated/DistributedNetworkOrder.lf | 101 ++++--- .../DistributedPhysicalActionUpstream.lf | 76 ++--- .../DistributedPhysicalActionUpstreamLong.lf | 132 ++++----- test/C/src/federated/DistributedStop.lf | 193 +++++++------ test/C/src/federated/DistributedToken.lf | 147 +++++----- .../C/src/federated/FederatedFilePkgReader.lf | 90 +++--- test/C/src/federated/FederatedFileReader.lf | 90 +++--- test/C/src/federated/FeedbackDelay.lf | 88 +++--- test/C/src/federated/FeedbackDelaySimple.lf | 54 ++-- test/C/src/federated/HelloDistributed.lf | 71 +++-- test/C/src/federated/LevelPattern.lf | 50 ++-- .../federated/LoopDistributedCentralized.lf | 67 +++-- .../federated/LoopDistributedCentralized2.lf | 107 ++++--- ...oopDistributedCentralizedPhysicalAction.lf | 107 ++++--- .../LoopDistributedCentralizedPrecedence.lf | 78 ++--- ...stributedCentralizedPrecedenceHierarchy.lf | 93 +++--- .../federated/LoopDistributedDecentralized.lf | 121 ++++---- test/C/src/federated/LoopDistributedDouble.lf | 153 +++++----- test/C/src/federated/PhysicalSTP.lf | 65 ++--- test/C/src/federated/PingPongDistributed.lf | 25 +- .../federated/PingPongDistributedPhysical.lf | 96 ++++--- test/C/src/federated/TopLevelArtifacts.lf | 45 ++- .../failing/SimpleFederatedAuthenticated.lf | 25 +- test/C/src/lib/Count.lf | 8 +- test/C/src/lib/FileLevelPreamble.lf | 9 +- test/C/src/lib/InternalDelay.lf | 10 +- test/C/src/lib/LoopedActionSender.lf | 47 ++-- test/C/src/lib/PassThrough.lf | 6 +- test/C/src/lib/Test.lf | 20 +- test/C/src/lib/TestCount.lf | 45 ++- test/C/src/lib/TestCountMultiport.lf | 66 ++--- .../modal_models/BanksCount3ModesComplex.lf | 116 ++++---- .../modal_models/BanksCount3ModesSimple.lf | 47 ++-- .../src/modal_models/BanksModalStateReset.lf | 96 +++---- test/C/src/modal_models/ConvertCaseTest.lf | 234 ++++++++------- test/C/src/modal_models/Count3Modes.lf | 96 ++++--- test/C/src/modal_models/MixedReactions.lf | 68 ++--- test/C/src/modal_models/ModalActions.lf | 150 +++++----- test/C/src/modal_models/ModalAfter.lf | 146 +++++----- test/C/src/modal_models/ModalCycleBreaker.lf | 101 ++++--- .../src/modal_models/ModalNestedReactions.lf | 2 +- .../src/modal_models/ModalStartupShutdown.lf | 266 +++++++++--------- test/C/src/modal_models/ModalStateReset.lf | 136 +++++---- .../C/src/modal_models/ModalStateResetAuto.lf | 132 +++++---- test/C/src/modal_models/ModalTimers.lf | 100 ++++--- .../MultipleOutputFeeder_2Connections.lf | 95 +++---- ...ultipleOutputFeeder_ReactionConnections.lf | 97 +++---- test/C/src/modal_models/util/TraceTesting.lf | 116 ++++---- test/C/src/multiport/BankIndexInitializer.lf | 48 ++-- .../src/multiport/BankMultiportToReaction.lf | 50 ++-- .../src/multiport/BankReactionsInContainer.lf | 112 ++++---- test/C/src/multiport/BankSelfBroadcast.lf | 62 ++-- test/C/src/multiport/BankToBank.lf | 58 ++-- test/C/src/multiport/BankToBankMultiport.lf | 68 ++--- .../src/multiport/BankToBankMultiportAfter.lf | 68 ++--- test/C/src/multiport/BankToMultiport.lf | 46 +-- test/C/src/multiport/BankToReaction.lf | 24 +- test/C/src/multiport/Broadcast.lf | 48 ++-- test/C/src/multiport/BroadcastAfter.lf | 56 ++-- .../C/src/multiport/BroadcastMultipleAfter.lf | 62 ++-- test/C/src/multiport/DualBanks.lf | 54 ++-- test/C/src/multiport/DualBanksMultiport.lf | 66 ++--- test/C/src/multiport/FullyConnected.lf | 58 ++-- .../multiport/FullyConnectedAddressable.lf | 80 +++--- .../FullyConnectedAddressableAfter.lf | 8 +- test/C/src/multiport/MultiportFromBank.lf | 56 ++-- .../multiport/MultiportFromBankHierarchy.lf | 20 +- .../C/src/multiport/MultiportFromHierarchy.lf | 89 +++--- test/C/src/multiport/MultiportFromReaction.lf | 68 ++--- test/C/src/multiport/MultiportIn.lf | 92 +++--- .../src/multiport/MultiportInParameterized.lf | 95 ++++--- test/C/src/multiport/MultiportMutableInput.lf | 63 ++--- .../multiport/MultiportMutableInputArray.lf | 107 ++++--- test/C/src/multiport/MultiportOut.lf | 98 +++---- test/C/src/multiport/MultiportToBank.lf | 73 +++-- test/C/src/multiport/MultiportToBankAfter.lf | 67 +++-- test/C/src/multiport/MultiportToBankDouble.lf | 75 +++-- .../src/multiport/MultiportToBankHierarchy.lf | 66 ++--- test/C/src/multiport/MultiportToHierarchy.lf | 79 +++--- test/C/src/multiport/MultiportToMultiport.lf | 74 ++--- test/C/src/multiport/MultiportToMultiport2.lf | 50 ++-- .../multiport/MultiportToMultiport2After.lf | 52 ++-- .../multiport/MultiportToMultiportArray.lf | 85 +++--- .../MultiportToMultiportParameter.lf | 74 ++--- test/C/src/multiport/MultiportToPort.lf | 63 ++--- test/C/src/multiport/MultiportToReaction.lf | 64 ++--- test/C/src/multiport/NestedBanks.lf | 92 +++--- .../C/src/multiport/NestedInterleavedBanks.lf | 44 +-- .../src/multiport/ReactionToContainedBank.lf | 22 +- .../src/multiport/ReactionToContainedBank2.lf | 26 +- .../ReactionToContainedBankMultiport.lf | 27 +- test/C/src/multiport/ReactionsToNested.lf | 47 ++-- test/C/src/multiport/Sparse.lf | 70 ++--- test/C/src/multiport/SparseFallback.lf | 74 ++--- .../TriggerDownstreamOnlyIfPresent.lf | 67 +++-- .../BankMultiportToReactionNoInlining.lf | 34 +-- .../no_inlining/BankToReactionNoInlining.lf | 14 +- test/C/src/no_inlining/Count.lf | 14 +- test/C/src/no_inlining/CountHierarchy.lf | 20 +- test/C/src/no_inlining/IntPrint.lf | 18 +- .../MultiportToReactionNoInlining.lf | 46 +-- .../serialization/ROSBuiltInSerialization.lf | 68 +++-- .../ROSBuiltInSerializationSharedPtr.lf | 67 +++-- test/C/src/target/FederatedFiles.lf | 12 +- test/C/src/target/HelloWorldCCPP.lf | 40 +-- test/C/src/token/TokenContainedPrint.lf | 30 +- test/C/src/token/TokenContainedPrintBank.lf | 47 ++-- test/C/src/token/TokenContainedSource.lf | 54 ++-- test/C/src/token/TokenContainedSourceBank.lf | 61 ++-- test/C/src/token/TokenDelayTest.lf | 12 +- test/C/src/token/TokenMutable.lf | 26 +- test/C/src/token/TokenSourcePrint.lf | 8 +- test/C/src/token/TokenSourceScalePrint.lf | 16 +- test/C/src/token/lib/Token.lf | 130 +++++---- test/C/src/zephyr/HelloZephyr.lf | 4 +- test/C/src/zephyr/Timer.lf | 16 +- test/C/src/zephyr/lib/Led.lf | 52 ++-- test/Cpp/src/ActionDelay.lf | 64 ++--- test/Cpp/src/ActionIsPresent.lf | 40 +-- test/Cpp/src/ActionValues.lf | 70 ++--- test/Cpp/src/After.lf | 79 +++--- test/Cpp/src/AfterOverlapped.lf | 56 ++-- test/Cpp/src/AfterZero.lf | 89 +++--- test/Cpp/src/Alignment.lf | 163 ++++++----- test/Cpp/src/ArrayAsParameter.lf | 61 ++-- test/Cpp/src/ArrayPrint.lf | 87 +++--- test/Cpp/src/ArrayScale.lf | 39 ++- test/Cpp/src/CharLiteralInitializer.lf | 14 +- test/Cpp/src/Composition.lf | 61 ++-- test/Cpp/src/CompositionAfter.lf | 61 ++-- test/Cpp/src/CountTest.lf | 28 +- test/Cpp/src/Deadline.lf | 91 +++--- test/Cpp/src/DeadlineHandledAbove.lf | 62 ++-- test/Cpp/src/DelayInt.lf | 80 +++--- test/Cpp/src/DelayedAction.lf | 34 +-- test/Cpp/src/DoubleInvocation.lf | 78 +++-- test/Cpp/src/DoublePort.lf | 81 +++--- test/Cpp/src/DoubleReaction.lf | 70 ++--- test/Cpp/src/DoubleTrigger.lf | 39 ++- test/Cpp/src/FloatLiteral.lf | 31 +- test/Cpp/src/Gain.lf | 34 +-- test/Cpp/src/GetMicroStep.lf | 40 +-- test/Cpp/src/Hello.lf | 80 +++--- test/Cpp/src/Hierarchy2.lf | 88 +++--- test/Cpp/src/ImportComposition.lf | 53 ++-- test/Cpp/src/ManualDelayedReaction.lf | 52 ++-- test/Cpp/src/Methods.lf | 32 +-- test/Cpp/src/MovingAverage.lf | 106 +++---- test/Cpp/src/NativeListsAndTimes.lf | 51 ++-- test/Cpp/src/NestedTriggeredReactions.lf | 44 +-- test/Cpp/src/ParameterHierarchy.lf | 23 +- test/Cpp/src/ParameterizedState.lf | 16 +- test/Cpp/src/ParametersOutOfOrder.lf | 18 +- test/Cpp/src/PeriodicDesugared.lf | 42 +-- test/Cpp/src/PhysicalConnection.lf | 52 ++-- test/Cpp/src/Pipeline.lf | 62 ++-- test/Cpp/src/ReadOutputOfContainedReactor.lf | 79 +++--- test/Cpp/src/ScheduleLogicalAction.lf | 62 ++-- test/Cpp/src/SelfLoop.lf | 56 ++-- test/Cpp/src/SendingInside.lf | 42 +-- test/Cpp/src/SimpleDeadline.lf | 57 ++-- test/Cpp/src/SlowingClock.lf | 57 ++-- test/Cpp/src/SlowingClockPhysical.lf | 63 ++--- test/Cpp/src/Stride.lf | 32 +-- test/Cpp/src/StructPrint.lf | 51 ++-- test/Cpp/src/StructScale.lf | 31 +- test/Cpp/src/TimeLimit.lf | 67 +++-- test/Cpp/src/TimeState.lf | 6 +- test/Cpp/src/Timeout_Test.lf | 48 ++-- test/Cpp/src/TimerIsPresent.lf | 86 +++--- test/Cpp/src/ToReactionNested.lf | 46 +-- .../src/TriggerDownstreamOnlyIfPresent2.lf | 47 ++-- test/Cpp/src/concurrent/AsyncCallback.lf | 100 +++---- test/Cpp/src/concurrent/AsyncCallback2.lf | 66 ++--- .../Cpp/src/concurrent/CompositionThreaded.lf | 61 ++-- .../DeadlineHandledAboveThreaded.lf | 62 ++-- test/Cpp/src/concurrent/DeadlineThreaded.lf | 91 +++--- test/Cpp/src/concurrent/DelayIntThreaded.lf | 80 +++--- .../src/concurrent/DoubleReactionThreaded.lf | 70 ++--- test/Cpp/src/concurrent/GainThreaded.lf | 34 +-- test/Cpp/src/concurrent/HelloThreaded.lf | 80 +++--- .../src/concurrent/SendingInsideThreaded.lf | 42 +-- test/Cpp/src/concurrent/Threaded.lf | 104 ++++--- test/Cpp/src/concurrent/ThreadedThreaded.lf | 86 +++--- test/Cpp/src/concurrent/TimeLimitThreaded.lf | 69 +++-- test/Cpp/src/enclave/EnclaveBank.lf | 36 +-- test/Cpp/src/enclave/EnclaveBankEach.lf | 39 ++- test/Cpp/src/enclave/EnclaveBroadcast.lf | 48 ++-- test/Cpp/src/enclave/EnclaveCommunication.lf | 58 ++-- test/Cpp/src/enclave/EnclaveCommunication2.lf | 56 ++-- .../enclave/EnclaveCommunicationDelayed.lf | 58 ++-- .../enclave/EnclaveCommunicationDelayed2.lf | 56 ++-- .../EnclaveCommunicationDelayedLocalEvents.lf | 68 ++--- .../EnclaveCommunicationLocalEvents.lf | 68 ++--- .../EnclaveCommunicationMultiportToBank.lf | 90 +++--- ...laveCommunicationMultiportToBankDelayed.lf | 90 +++--- ...EnclaveCommunicationMultiportToBankEach.lf | 90 +++--- ...CommunicationMultiportToBankEachDelayed.lf | 90 +++--- ...ommunicationMultiportToBankEachPhysical.lf | 90 +++--- ...aveCommunicationMultiportToBankPhysical.lf | 90 +++--- .../enclave/EnclaveCommunicationPhysical.lf | 58 ++-- ...EnclaveCommunicationPhysicalLocalEvents.lf | 68 ++--- test/Cpp/src/enclave/EnclaveCycle.lf | 100 +++---- test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf | 104 +++---- test/Cpp/src/enclave/EnclaveHelloWorld.lf | 8 +- test/Cpp/src/enclave/EnclaveHierarchy.lf | 44 ++- .../Cpp/src/enclave/EnclaveMultiportToPort.lf | 69 +++-- .../src/enclave/EnclaveMultiportToPort2.lf | 67 +++-- test/Cpp/src/enclave/EnclaveShutdown.lf | 48 ++-- .../enclave/EnclaveSparseUpstreamEvents.lf | 78 ++--- .../EnclaveSparseUpstreamEventsDelayed.lf | 78 ++--- .../EnclaveSparseUpstreamEventsPhysical.lf | 78 ++--- test/Cpp/src/enclave/EnclaveTimeout.lf | 40 +-- .../enclave/EnclaveUpstreamPhysicalAction.lf | 114 ++++---- .../EnclaveUpstreamPhysicalActionDelayed.lf | 114 ++++---- test/Cpp/src/enclave/FastAndSlow.lf | 44 ++- test/Cpp/src/lib/Count.lf | 14 +- test/Cpp/src/lib/LoopedActionSender.lf | 35 ++- test/Cpp/src/multiport/BankSelfBroadcast.lf | 56 ++-- test/Cpp/src/multiport/BankToBank.lf | 59 ++-- test/Cpp/src/multiport/BankToBankMultiport.lf | 78 ++--- .../src/multiport/BankToBankMultiportAfter.lf | 94 +++---- test/Cpp/src/multiport/BankToMultiport.lf | 44 +-- test/Cpp/src/multiport/Broadcast.lf | 42 +-- test/Cpp/src/multiport/BroadcastAfter.lf | 54 ++-- .../src/multiport/BroadcastMultipleAfter.lf | 60 ++-- test/Cpp/src/multiport/FullyConnected.lf | 60 ++-- .../multiport/FullyConnectedAddressable.lf | 82 +++--- .../FullyConnectedAddressableAfter.lf | 8 +- .../src/multiport/IndexIntoMultiportOutput.lf | 95 ++++--- test/Cpp/src/multiport/Multiport.lf | 91 +++--- test/Cpp/src/multiport/MultiportFromBank.lf | 54 ++-- .../multiport/MultiportFromBankHierarchy.lf | 60 ++-- .../MultiportFromBankHierarchyAfter.lf | 70 ++--- .../src/multiport/MultiportFromHierarchy.lf | 91 +++--- test/Cpp/src/multiport/MultiportIn.lf | 90 +++--- .../Cpp/src/multiport/MultiportMultipleSet.lf | 82 +++--- test/Cpp/src/multiport/MultiportOut.lf | 98 +++---- test/Cpp/src/multiport/MultiportToBank.lf | 34 +-- .../Cpp/src/multiport/MultiportToBankAfter.lf | 42 +-- .../src/multiport/MultiportToBankHierarchy.lf | 66 ++--- .../Cpp/src/multiport/MultiportToHierarchy.lf | 87 +++--- .../Cpp/src/multiport/MultiportToMultiport.lf | 52 ++-- .../src/multiport/MultiportToMultiport2.lf | 44 +-- .../multiport/MultiportToMultiport2After.lf | 54 ++-- .../multiport/MultiportToMultiportArray.lf | 89 +++--- .../multiport/MultiportToMultiportPhysical.lf | 62 ++-- test/Cpp/src/multiport/MultiportToPort.lf | 63 ++--- .../ReadMultiportOutputOfContainedBank.lf | 103 ++++--- .../multiport/ReadOutputOfContainedBank.lf | 91 +++--- test/Cpp/src/multiport/SparseMultiport.lf | 110 ++++---- test/Cpp/src/multiport/WidthGivenByCode.lf | 54 ++-- .../multiport/WriteInputOfContainedBank.lf | 46 +-- .../WriteMultiportInputOfContainedBank.lf | 50 ++-- test/Cpp/src/properties/Fast.lf | 38 +-- test/Cpp/src/properties/Timeout.lf | 44 +-- test/Cpp/src/properties/TimeoutZero.lf | 44 +-- test/Cpp/src/target/AfterVoid.lf | 56 ++-- .../src/target/BraceAndParenInitialization.lf | 40 ++- .../src/target/CliParserGenericArguments.lf | 84 +++--- test/Cpp/src/target/CombinedTypeNames.lf | 27 +- test/Cpp/src/target/GenericAfter.lf | 18 +- test/Cpp/src/target/GenericDelay.lf | 18 +- .../src/target/GenericParameterAndState.lf | 26 +- test/Cpp/src/target/InitializerSyntax.lf | 146 +++++----- .../src/target/MultipleContainedGeneric.lf | 49 ++-- test/Cpp/src/target/PointerParameters.lf | 20 +- test/Python/src/ActionDelay.lf | 58 ++-- test/Python/src/ActionIsPresent.lf | 42 +-- test/Python/src/After.lf | 73 +++-- test/Python/src/AfterCycles.lf | 92 +++--- test/Python/src/AfterOverlapped.lf | 54 ++-- test/Python/src/ArrayAsParameter.lf | 56 ++-- test/Python/src/ArrayAsType.lf | 34 +-- test/Python/src/ArrayFree.lf | 32 +-- test/Python/src/ArrayPrint.lf | 34 +-- test/Python/src/ArrayScale.lf | 31 +- test/Python/src/CompareTags.lf | 46 +-- test/Python/src/Composition.lf | 57 ++-- test/Python/src/CompositionAfter.lf | 45 ++- test/Python/src/CompositionInheritance.lf | 77 +++-- test/Python/src/CountSelf.lf | 48 ++-- test/Python/src/CountTest.lf | 38 +-- test/Python/src/Deadline.lf | 79 +++--- test/Python/src/DeadlineHandledAbove.lf | 58 ++-- test/Python/src/DelayArray.lf | 59 ++-- test/Python/src/DelayArrayWithAfter.lf | 77 +++-- test/Python/src/DelayInt.lf | 84 +++--- test/Python/src/DelayString.lf | 49 ++-- test/Python/src/DelayStruct.lf | 50 ++-- test/Python/src/DelayStructWithAfter.lf | 26 +- .../src/DelayStructWithAfterOverlapped.lf | 54 ++-- test/Python/src/DelayedAction.lf | 34 +-- test/Python/src/DoubleInvocation.lf | 71 +++-- test/Python/src/DoubleReaction.lf | 62 ++-- test/Python/src/FloatLiteral.lf | 31 +- test/Python/src/Gain.lf | 44 +-- test/Python/src/GetMicroStep.lf | 28 +- test/Python/src/Hello.lf | 74 +++-- test/Python/src/HelloWorld.lf | 26 +- test/Python/src/Hierarchy2.lf | 88 +++--- test/Python/src/IdentifierLength.lf | 52 ++-- test/Python/src/ImportComposition.lf | 41 ++- test/Python/src/ManualDelayedReaction.lf | 67 +++-- test/Python/src/Methods.lf | 30 +- test/Python/src/MethodsRecursive.lf | 22 +- test/Python/src/MethodsSameName.lf | 38 +-- test/Python/src/MovingAverage.lf | 75 +++-- test/Python/src/MultipleContained.lf | 61 ++-- test/Python/src/NativeListsAndTimes.lf | 43 ++- test/Python/src/ParameterizedState.lf | 6 +- test/Python/src/PeriodicDesugared.lf | 28 +- test/Python/src/PingPong.lf | 89 +++--- test/Python/src/Pipeline.lf | 90 +++--- .../src/ReadOutputOfContainedReactor.lf | 67 +++-- test/Python/src/ScheduleLogicalAction.lf | 60 ++-- test/Python/src/SelfLoop.lf | 52 ++-- test/Python/src/SendingInside.lf | 40 +-- test/Python/src/SetArray.lf | 29 +- test/Python/src/SimpleDeadline.lf | 51 ++-- test/Python/src/SlowingClock.lf | 54 ++-- test/Python/src/SlowingClockPhysical.lf | 67 +++-- test/Python/src/Stride.lf | 44 +-- test/Python/src/StructAsState.lf | 29 +- test/Python/src/StructAsType.lf | 32 +-- test/Python/src/StructAsTypeDirect.lf | 38 +-- test/Python/src/StructParallel.lf | 57 ++-- test/Python/src/StructPrint.lf | 30 +- test/Python/src/StructScale.lf | 51 ++-- test/Python/src/SubclassesAndStartup.lf | 48 ++-- test/Python/src/TimeLimit.lf | 63 ++--- test/Python/src/TimeState.lf | 6 +- test/Python/src/Timers.lf | 24 +- .../src/TriggerDownstreamOnlyIfPresent.lf | 61 ++-- .../src/TriggerDownstreamOnlyIfPresent2.lf | 49 ++-- test/Python/src/UnconnectedInput.lf | 72 ++--- test/Python/src/concurrent/AsyncCallback.lf | 95 ++++--- .../src/concurrent/AsyncCallbackNoTimer.lf | 100 +++---- .../src/docker/FilesPropertyContainerized.lf | 42 +-- .../DistributedCountContainerized.lf | 21 +- ...stributedStopDecentralizedContainerized.lf | 3 +- .../Python/src/federated/BroadcastFeedback.lf | 38 ++- .../BroadcastFeedbackWithHierarchy.lf | 48 ++-- test/Python/src/federated/CycleDetection.lf | 74 ++--- .../src/federated/DecentralizedP2PComm.lf | 72 ++--- .../DecentralizedP2PUnbalancedTimeout.lf | 77 +++-- ...centralizedP2PUnbalancedTimeoutPhysical.lf | 63 ++--- test/Python/src/federated/DistributedBank.lf | 30 +- .../federated/DistributedBankToMultiport.lf | 40 +-- test/Python/src/federated/DistributedCount.lf | 55 ++-- .../DistributedCountDecentralized.lf | 58 ++-- .../DistributedCountDecentralizedLate.lf | 99 ++++--- ...ributedCountDecentralizedLateDownstream.lf | 140 +++++---- ...tributedCountDecentralizedLateHierarchy.lf | 41 ++- .../src/federated/DistributedCountPhysical.lf | 70 ++--- .../DistributedCountPhysicalAfterDelay.lf | 70 ++--- .../DistributedCountPhysicalDecentralized.lf | 72 ++--- .../src/federated/DistributedDoublePort.lf | 67 +++-- .../src/federated/DistributedLoopedAction.lf | 92 +++--- .../DistributedLoopedPhysicalAction.lf | 123 ++++---- .../src/federated/DistributedMultiport.lf | 60 ++-- .../federated/DistributedMultiportToBank.lf | 54 ++-- .../federated/DistributedMultiportToken.lf | 50 ++-- .../src/federated/DistributedSendClass.lf | 20 +- test/Python/src/federated/DistributedStop.lf | 181 ++++++------ .../federated/DistributedStopDecentralized.lf | 6 +- .../src/federated/DistributedStopZero.lf | 132 +++++---- test/Python/src/federated/HelloDistributed.lf | 62 ++-- ...stributedCentralizedPrecedenceHierarchy.lf | 87 +++--- test/Python/src/federated/PhysicalSTP.lf | 69 +++-- .../src/federated/PingPongDistributed.lf | 88 +++--- test/Python/src/federated/StopAtShutdown.lf | 24 +- test/Python/src/lib/Count.lf | 14 +- test/Python/src/lib/InternalDelay.lf | 10 +- test/Python/src/lib/LoopedActionSender.lf | 35 ++- test/Python/src/lib/Test.lf | 18 +- test/Python/src/lib/TestCount.lf | 41 ++- test/Python/src/lib/TestCountMultiport.lf | 61 ++-- .../modal_models/BanksCount3ModesComplex.lf | 108 ++++--- .../src/modal_models/BanksModalStateReset.lf | 92 +++--- .../src/modal_models/ConvertCaseTest.lf | 197 +++++++------ test/Python/src/modal_models/Count3Modes.lf | 84 +++--- test/Python/src/modal_models/ModalActions.lf | 145 +++++----- test/Python/src/modal_models/ModalAfter.lf | 141 +++++----- .../src/modal_models/ModalCycleBreaker.lf | 96 ++++--- .../src/modal_models/ModalStartupShutdown.lf | 261 +++++++++-------- .../src/modal_models/ModalStateReset.lf | 137 +++++---- .../src/modal_models/ModalStateResetAuto.lf | 133 +++++---- test/Python/src/modal_models/ModalTimers.lf | 95 ++++--- .../MultipleOutputFeeder_2Connections.lf | 96 ++++--- ...ultipleOutputFeeder_ReactionConnections.lf | 98 ++++--- .../src/modal_models/util/TraceTesting.lf | 98 +++---- .../src/multiport/BankIndexInitializer.lf | 42 +-- .../src/multiport/BankReactionsInContainer.lf | 106 ++++--- test/Python/src/multiport/BankToBank.lf | 54 ++-- .../src/multiport/BankToBankMultiport.lf | 76 ++--- .../src/multiport/BankToBankMultiportAfter.lf | 10 +- test/Python/src/multiport/BankToMultiport.lf | 42 +-- test/Python/src/multiport/Broadcast.lf | 50 ++-- .../src/multiport/BroadcastMultipleAfter.lf | 52 ++-- .../Python/src/multiport/MultiportFromBank.lf | 56 ++-- .../multiport/MultiportFromBankHierarchy.lf | 24 +- .../src/multiport/MultiportFromHierarchy.lf | 85 +++--- .../src/multiport/MultiportFromReaction.lf | 64 ++--- test/Python/src/multiport/MultiportIn.lf | 86 +++--- .../src/multiport/MultiportInParameterized.lf | 96 +++---- .../src/multiport/MultiportMutableInput.lf | 61 ++-- .../multiport/MultiportMutableInputArray.lf | 59 ++-- test/Python/src/multiport/MultiportOut.lf | 90 +++--- test/Python/src/multiport/MultiportToBank.lf | 50 ++-- .../src/multiport/MultiportToBankAfter.lf | 49 ++-- .../src/multiport/MultiportToBankHierarchy.lf | 50 ++-- .../src/multiport/MultiportToHierarchy.lf | 75 +++-- .../src/multiport/MultiportToMultiport.lf | 32 +-- .../src/multiport/MultiportToMultiport2.lf | 40 +-- .../multiport/MultiportToMultiport2After.lf | 36 +-- .../multiport/MultiportToMultiportArray.lf | 77 +++-- .../MultiportToMultiportParameter.lf | 10 +- test/Python/src/multiport/MultiportToPort.lf | 57 ++-- .../src/multiport/MultiportToReaction.lf | 58 ++-- test/Python/src/multiport/NestedBanks.lf | 90 +++--- .../src/multiport/NestedInterleavedBanks.lf | 42 +-- .../Python/src/multiport/ReactionsToNested.lf | 47 ++-- test/Python/src/target/AfterNoTypes.lf | 74 ++--- test/Rust/src/ActionDelay.lf | 38 +-- test/Rust/src/ActionImplicitDelay.lf | 24 +- test/Rust/src/ActionIsPresent.lf | 44 +-- test/Rust/src/ActionScheduleMicrostep.lf | 32 +-- test/Rust/src/ActionValues.lf | 46 +-- test/Rust/src/ActionValuesCleanup.lf | 74 +++-- test/Rust/src/CompositionWithPorts.lf | 28 +- test/Rust/src/CtorParamDefault.lf | 12 +- test/Rust/src/CtorParamMixed.lf | 26 +- test/Rust/src/CtorParamSimple.lf | 12 +- test/Rust/src/DependencyOnChildPort.lf | 28 +- test/Rust/src/DependencyUseOnLogicalAction.lf | 82 +++--- test/Rust/src/FloatLiteral.lf | 21 +- test/Rust/src/MainReactorParam.lf | 6 +- test/Rust/src/MovingAverage.lf | 88 +++--- test/Rust/src/NativeListsAndTimes.lf | 75 +++-- test/Rust/src/PortConnectionInSelfInChild.lf | 36 +-- test/Rust/src/PortConnectionInSelfOutSelf.lf | 42 +-- .../Rust/src/PortConnectionOutChildOutSelf.lf | 48 ++-- test/Rust/src/PortRefCleanup.lf | 62 ++-- test/Rust/src/PortValueCleanup.lf | 52 ++-- test/Rust/src/ReservedKeywords.lf | 27 +- test/Rust/src/StateInitializerVisibility.lf | 18 +- test/Rust/src/Stop.lf | 115 ++++---- test/Rust/src/StopIdempotence.lf | 26 +- test/Rust/src/StopTimeoutExact.lf | 30 +- test/Rust/src/StructAsState.lf | 44 +-- test/Rust/src/StructAsType.lf | 50 ++-- test/Rust/src/TimeState.lf | 6 +- test/Rust/src/TimerDefaults.lf | 14 +- test/Rust/src/TimerIsPresent.lf | 86 +++--- test/Rust/src/TimerPeriodic.lf | 22 +- test/Rust/src/Timers.lf | 20 +- test/Rust/src/TypeVarLengthList.lf | 18 +- test/Rust/src/concurrent/AsyncCallback.lf | 108 +++---- test/Rust/src/generics/CtorParamGeneric.lf | 22 +- .../Rust/src/generics/CtorParamGenericInst.lf | 42 ++- test/Rust/src/generics/GenericComplexType.lf | 22 +- test/Rust/src/generics/GenericReactor.lf | 28 +- .../src/multiport/ConnectionToSelfBank.lf | 24 +- .../multiport/ConnectionToSelfMultiport.lf | 30 +- test/Rust/src/multiport/CycledLhs_SelfLoop.lf | 46 ++- test/Rust/src/multiport/CycledLhs_Single.lf | 72 +++-- test/Rust/src/multiport/FullyConnected.lf | 26 +- .../multiport/FullyConnectedAddressable.lf | 84 +++--- test/Rust/src/multiport/MultiportFromBank.lf | 28 +- .../src/multiport/MultiportFromHierarchy.lf | 71 +++-- test/Rust/src/multiport/MultiportIn.lf | 84 +++--- test/Rust/src/multiport/MultiportOut.lf | 94 +++---- test/Rust/src/multiport/MultiportToBank.lf | 40 +-- .../src/multiport/MultiportToBankHierarchy.lf | 48 ++-- .../src/multiport/MultiportToMultiport.lf | 32 +-- .../src/multiport/MultiportToMultiport2.lf | 41 ++- .../multiport/ReadOutputOfContainedBank.lf | 77 +++-- test/Rust/src/multiport/WidthWithParameter.lf | 16 +- .../multiport/WriteInputOfContainedBank.lf | 34 ++- test/Rust/src/target/CliFeature.lf | 6 +- .../target/MainParameterCanBeExpression.lf | 14 +- test/TypeScript/src/ActionDelay.lf | 60 ++-- test/TypeScript/src/After.lf | 47 ++-- test/TypeScript/src/ArrayAsParameter.lf | 44 +-- test/TypeScript/src/ArrayAsType.lf | 69 +++-- test/TypeScript/src/ArrayPrint.lf | 69 +++-- test/TypeScript/src/ArrayScale.lf | 35 ++- test/TypeScript/src/Composition.lf | 43 ++- test/TypeScript/src/CompositionAfter.lf | 45 ++- test/TypeScript/src/CountTest.lf | 26 +- test/TypeScript/src/Deadline.lf | 79 +++--- test/TypeScript/src/DeadlineHandledAbove.lf | 68 ++--- test/TypeScript/src/DelayInt.lf | 90 +++--- test/TypeScript/src/DelayedAction.lf | 32 +-- test/TypeScript/src/DoubleInvocation.lf | 73 +++-- test/TypeScript/src/DoubleReaction.lf | 66 ++--- test/TypeScript/src/DoubleTrigger.lf | 35 ++- test/TypeScript/src/FloatLiteral.lf | 27 +- test/TypeScript/src/Gain.lf | 46 +-- test/TypeScript/src/Hello.lf | 77 +++-- test/TypeScript/src/Hierarchy2.lf | 84 +++--- test/TypeScript/src/MovingAverage.lf | 95 ++++--- test/TypeScript/src/NativeListsAndTimes.lf | 39 ++- test/TypeScript/src/ParameterizedState.lf | 6 +- test/TypeScript/src/PeriodicDesugared.lf | 36 +-- test/TypeScript/src/PhysicalConnection.lf | 26 +- .../src/ReadOutputOfContainedReactor.lf | 69 +++-- test/TypeScript/src/ScheduleLogicalAction.lf | 62 ++-- test/TypeScript/src/SendingInside.lf | 40 +-- test/TypeScript/src/SendsPointerTest.lf | 36 +-- test/TypeScript/src/SimpleDeadline.lf | 61 ++-- test/TypeScript/src/SlowingClock.lf | 44 +-- test/TypeScript/src/SlowingClockPhysical.lf | 60 ++-- test/TypeScript/src/Stop.lf | 83 +++--- test/TypeScript/src/Stride.lf | 32 +-- test/TypeScript/src/StructAsState.lf | 26 +- test/TypeScript/src/StructAsType.lf | 48 ++-- test/TypeScript/src/StructAsTypeDirect.lf | 48 ++-- test/TypeScript/src/StructPrint.lf | 48 ++-- test/TypeScript/src/StructScale.lf | 34 ++- test/TypeScript/src/TimeLimit.lf | 51 ++-- test/TypeScript/src/TimeState.lf | 6 +- .../src/concurrent/AsyncCallback.lf | 74 ++--- .../DistributedCountContainerized.lf | 10 +- .../src/federated/DistributedCount.lf | 51 ++-- .../src/federated/DistributedCountPhysical.lf | 72 ++--- .../DistributedCountPhysicalAfterDelay.lf | 61 ++-- .../src/federated/DistributedDoublePort.lf | 65 ++--- .../src/federated/DistributedLoopedAction.lf | 86 +++--- .../DistributedLoopedPhysicalAction.lf | 104 ++++--- .../src/federated/DistributedStop.lf | 161 ++++++----- .../src/federated/HelloDistributed.lf | 67 +++-- .../federated/LoopDistributedCentralized.lf | 89 +++--- .../src/federated/LoopDistributedDouble.lf | 121 ++++---- .../src/federated/PingPongDistributed.lf | 76 ++--- .../federated/PingPongDistributedPhysical.lf | 90 +++--- .../src/federated/TopLevelArtifacts.lf | 45 ++- test/TypeScript/src/lib/Count.lf | 8 +- test/TypeScript/src/lib/InternalDelay.lf | 10 +- test/TypeScript/src/lib/LoopedActionSender.lf | 37 ++- test/TypeScript/src/lib/TestCount.lf | 45 ++- .../src/multiport/BankMultiportToReaction.lf | 48 ++-- .../src/multiport/BankReactionsInContainer.lf | 110 ++++---- .../src/multiport/BankSelfBroadcast.lf | 52 ++-- test/TypeScript/src/multiport/BankToBank.lf | 53 ++-- .../src/multiport/BankToBankMultiport.lf | 64 ++--- .../src/multiport/BankToBankMultiportAfter.lf | 64 ++--- .../src/multiport/BankToMultiport.lf | 40 +-- .../src/multiport/BankToReaction.lf | 22 +- .../src/multiport/BroadcastAfter.lf | 50 ++-- .../src/multiport/BroadcastMultipleAfter.lf | 56 ++-- .../src/multiport/FullyConnected.lf | 60 ++-- .../src/multiport/MultiportFromBank.lf | 48 ++-- .../multiport/MultiportFromBankHierarchy.lf | 18 +- .../src/multiport/MultiportFromHierarchy.lf | 85 +++--- .../src/multiport/MultiportFromReaction.lf | 64 ++--- test/TypeScript/src/multiport/MultiportIn.lf | 92 +++--- .../src/multiport/MultiportInParameterized.lf | 94 +++---- .../src/multiport/MultiportMutableInput.lf | 63 ++--- .../multiport/MultiportMutableInputArray.lf | 117 ++++---- test/TypeScript/src/multiport/MultiportOut.lf | 94 +++---- .../src/multiport/MultiportToBankAfter.lf | 61 ++-- .../src/multiport/MultiportToBankDouble.lf | 69 +++-- .../src/multiport/MultiportToBankHierarchy.lf | 60 ++-- .../src/multiport/MultiportToHierarchy.lf | 75 +++-- .../src/multiport/MultiportToMultiport.lf | 50 ++-- .../src/multiport/MultiportToMultiport2.lf | 40 +-- .../multiport/MultiportToMultiport2After.lf | 52 ++-- .../multiport/MultiportToMultiportArray.lf | 85 +++--- .../MultiportToMultiportParameter.lf | 62 ++-- .../src/multiport/MultiportToPort.lf | 57 ++-- .../src/multiport/MultiportToReaction.lf | 60 ++-- test/TypeScript/src/multiport/NestedBanks.lf | 92 +++--- .../src/multiport/ReactionToContainedBank.lf | 20 +- .../src/multiport/ReactionsToNested.lf | 47 ++-- test/TypeScript/src/target/AfterNoTypes.lf | 41 ++- 732 files changed, 22019 insertions(+), 22657 deletions(-) diff --git a/build.gradle b/build.gradle index 348949c01e..37a497f632 100644 --- a/build.gradle +++ b/build.gradle @@ -96,7 +96,7 @@ spotless { // define the steps to apply to those files trimTrailingWhitespace() - indentWithSpaces() // or spaces. Takes an integer argument if you don't like 4 + indentWithSpaces(2) // or spaces. Takes an integer argument if you don't like 4 endWithNewline() } diff --git a/org.lflang/src/org/lflang/ast/FormattingUtils.java b/org.lflang/src/org/lflang/ast/FormattingUtils.java index 9b47440391..7ec3d7d59a 100644 --- a/org.lflang/src/org/lflang/ast/FormattingUtils.java +++ b/org.lflang/src/org/lflang/ast/FormattingUtils.java @@ -29,9 +29,9 @@ public class FormattingUtils { private static final Pattern MULTILINE_COMMENT = Pattern.compile("\\s*/\\*\\v?(\\V*\\v+)*\\V*"); /** The number of spaces to prepend to a line per indentation level. */ - private static final int INDENTATION = 4; + private static final int INDENTATION = 2; - public static final int DEFAULT_LINE_LENGTH = 80; + public static final int DEFAULT_LINE_LENGTH = 100; static final int MAX_WHITESPACE_USED_FOR_ALIGNMENT = 20; diff --git a/test/C/src/ActionDelay.lf b/test/C/src/ActionDelay.lf index 86e510080a..4951f806c2 100644 --- a/test/C/src/ActionDelay.lf +++ b/test/C/src/ActionDelay.lf @@ -2,47 +2,47 @@ target C reactor GeneratedDelay { - input y_in: int - output y_out: int - state y_state: int = 0 - logical action act(100 msec) + input y_in: int + output y_out: int + state y_state: int = 0 + logical action act(100 msec) - reaction(y_in) -> act {= - self->y_state = y_in->value; - lf_schedule(act, MSEC(0)); - =} + reaction(y_in) -> act {= + self->y_state = y_in->value; + lf_schedule(act, MSEC(0)); + =} - reaction(act) -> y_out {= lf_set(y_out, self->y_state); =} + reaction(act) -> y_out {= lf_set(y_out, self->y_state); =} } reactor Source { - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, 1); =} + reaction(startup) -> out {= lf_set(out, 1); =} } reactor Sink { - input in: int - - reaction(in) {= - interval_t elapsed_logical = lf_time_logical_elapsed(); - interval_t logical = lf_time_logical(); - interval_t physical = lf_time_physical(); - printf("Logical, physical, and elapsed logical: %lld %lld %lld.\n", logical, physical, elapsed_logical); - if (elapsed_logical != MSEC(100)) { - printf("FAILURE: Expected %lld but got %lld.\n", MSEC(100), elapsed_logical); - exit(1); - } else { - printf("SUCCESS. Elapsed logical time is 100 msec.\n"); - } - =} + input in: int + + reaction(in) {= + interval_t elapsed_logical = lf_time_logical_elapsed(); + interval_t logical = lf_time_logical(); + interval_t physical = lf_time_physical(); + printf("Logical, physical, and elapsed logical: %lld %lld %lld.\n", logical, physical, elapsed_logical); + if (elapsed_logical != MSEC(100)) { + printf("FAILURE: Expected %lld but got %lld.\n", MSEC(100), elapsed_logical); + exit(1); + } else { + printf("SUCCESS. Elapsed logical time is 100 msec.\n"); + } + =} } main reactor ActionDelay { - source = new Source() - sink = new Sink() - g = new GeneratedDelay() + source = new Source() + sink = new Sink() + g = new GeneratedDelay() - source.out -> g.y_in - g.y_out -> sink.in + source.out -> g.y_in + g.y_out -> sink.in } diff --git a/test/C/src/ActionIsPresent.lf b/test/C/src/ActionIsPresent.lf index b94108949e..2c0bff1293 100644 --- a/test/C/src/ActionIsPresent.lf +++ b/test/C/src/ActionIsPresent.lf @@ -2,27 +2,27 @@ target C main reactor ActionIsPresent(offset: time = 1 nsec, period: time = 500 msec) { - logical action a - state success: bool = false + logical action a + state success: bool = false - reaction(startup, a) -> a {= - if (!a->is_present) { - if (self->offset == 0) { - printf("Hello World!\n"); - self->success = true; - } else { - lf_schedule(a, self->offset); - } - } else { - printf("Hello World 2!\n"); + reaction(startup, a) -> a {= + if (!a->is_present) { + if (self->offset == 0) { + printf("Hello World!\n"); self->success = true; + } else { + lf_schedule(a, self->offset); } - =} + } else { + printf("Hello World 2!\n"); + self->success = true; + } + =} - reaction(shutdown) {= - if (!self->success) { - fprintf(stderr, "Failed to print 'Hello World'\n"); - exit(1); - } - =} + reaction(shutdown) {= + if (!self->success) { + fprintf(stderr, "Failed to print 'Hello World'\n"); + exit(1); + } + =} } diff --git a/test/C/src/After.lf b/test/C/src/After.lf index d3663457e4..e7aeba5b8d 100644 --- a/test/C/src/After.lf +++ b/test/C/src/After.lf @@ -1,52 +1,51 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target C { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } reactor foo { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= lf_set(y, 2*x->value); =} + reaction(x) -> y {= lf_set(y, 2*x->value); =} } reactor print { - state expected_time: time = 10 msec - state received: int = 0 - input x: int + state expected_time: time = 10 msec + state received: int = 0 + input x: int - reaction(x) {= - self->received++; - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("Result is %d\n", x->value); - if (x->value != 84) { - printf("ERROR: Expected result to be 84.\n"); - exit(1); - } - printf("Current logical time is: %lld\n", elapsed_time); - printf("Current physical time is: %lld\n", lf_time_physical_elapsed()); - if (elapsed_time != self->expected_time) { - printf("ERROR: Expected logical time to be %lld.\n", self->expected_time); - exit(2); - } - self->expected_time += SEC(1); - =} + reaction(x) {= + self->received++; + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("Result is %d\n", x->value); + if (x->value != 84) { + printf("ERROR: Expected result to be 84.\n"); + exit(1); + } + printf("Current logical time is: %lld\n", elapsed_time); + printf("Current physical time is: %lld\n", lf_time_physical_elapsed()); + if (elapsed_time != self->expected_time) { + printf("ERROR: Expected logical time to be %lld.\n", self->expected_time); + exit(2); + } + self->expected_time += SEC(1); + =} - reaction(shutdown) {= - if (self->received == 0) { - printf("ERROR: Final reactor received no data.\n"); - exit(3); - } - =} + reaction(shutdown) {= + if (self->received == 0) { + printf("ERROR: Final reactor received no data.\n"); + exit(3); + } + =} } main reactor After { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x after 10 msec + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x after 10 msec - reaction(t) -> f.x {= lf_set(f.x, 42); =} + reaction(t) -> f.x {= lf_set(f.x, 42); =} } diff --git a/test/C/src/AfterCycles.lf b/test/C/src/AfterCycles.lf index d7d621046b..3a7301a7a2 100644 --- a/test/C/src/AfterCycles.lf +++ b/test/C/src/AfterCycles.lf @@ -1,61 +1,61 @@ -// This tests that "after" does not introduce spurious cycles. Success if -// running without detected a cycle. +// This tests that "after" does not introduce spurious cycles. Success if running without detected a +// cycle. target C reactor Source { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= lf_set(out, 1); =} + reaction(startup) -> out {= lf_set(out, 1); =} } reactor Work { - input in: unsigned - output out: unsigned + input in: unsigned + output out: unsigned - reaction(in) -> out {= lf_set(out, in->value); =} + reaction(in) -> out {= lf_set(out, in->value); =} } main reactor AfterCycles { - state count: int = 0 - s = new Source() - w0 = new Work() - w1 = new Work() - - s.out -> w0.in after 10 msec - s.out -> w1.in after 20 msec - - reaction(w0.out) {= - self->count++; - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("Received %d from worker 0 at time %lld.\n", w0.out->value, elapsed_time); - if (elapsed_time != MSEC(10)) { - fprintf(stderr, "Time should have been 10000000.\n"); - exit(1); - } - if (w0.out->value != 1) { - fprintf(stderr, "Value should have been 1.\n"); - exit(4); - } - =} - - reaction(w1.out) {= - self->count++; - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("Received %d from worker 1 at time %lld.\n", w1.out->value, elapsed_time); - if (elapsed_time != MSEC(20)) { - fprintf(stderr, "Time should have been 20000000.\n"); - exit(3); - } - if (w1.out->value != 1) { - fprintf(stderr, "Value should have been 1.\n"); - exit(4); - } - =} - - reaction(shutdown) {= - if (self->count != 2) { - fprintf(stderr, "Top-level reactions should have been triggered but were not.\n"); - exit(5); - } - =} + state count: int = 0 + s = new Source() + w0 = new Work() + w1 = new Work() + + s.out -> w0.in after 10 msec + s.out -> w1.in after 20 msec + + reaction(w0.out) {= + self->count++; + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("Received %d from worker 0 at time %lld.\n", w0.out->value, elapsed_time); + if (elapsed_time != MSEC(10)) { + fprintf(stderr, "Time should have been 10000000.\n"); + exit(1); + } + if (w0.out->value != 1) { + fprintf(stderr, "Value should have been 1.\n"); + exit(4); + } + =} + + reaction(w1.out) {= + self->count++; + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("Received %d from worker 1 at time %lld.\n", w1.out->value, elapsed_time); + if (elapsed_time != MSEC(20)) { + fprintf(stderr, "Time should have been 20000000.\n"); + exit(3); + } + if (w1.out->value != 1) { + fprintf(stderr, "Value should have been 1.\n"); + exit(4); + } + =} + + reaction(shutdown) {= + if (self->count != 2) { + fprintf(stderr, "Top-level reactions should have been triggered but were not.\n"); + exit(5); + } + =} } diff --git a/test/C/src/AfterOverlapped.lf b/test/C/src/AfterOverlapped.lf index 0925dc5164..b1124c4274 100644 --- a/test/C/src/AfterOverlapped.lf +++ b/test/C/src/AfterOverlapped.lf @@ -1,46 +1,46 @@ // This the after keyword with overlapped time intervals. target C { - fast: true, - timeout: 5 sec + fast: true, + timeout: 5 sec } import Count from "lib/Count.lf" reactor Test { - input c: int - state i: int = 0 - state received: int = 0 + input c: int + state i: int = 0 + state received: int = 0 - reaction(c) {= - self->received++; - printf("Received %d.\n", c->value); - (self->i)++; - if (c->value != self->i) { - printf("ERROR: Expected %d but got %d\n.", self->i, c->value); - exit(1); - } - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("Current logical time is: %lld\n", elapsed_time); + reaction(c) {= + self->received++; + printf("Received %d.\n", c->value); + (self->i)++; + if (c->value != self->i) { + printf("ERROR: Expected %d but got %d\n.", self->i, c->value); + exit(1); + } + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("Current logical time is: %lld\n", elapsed_time); - interval_t expected_logical_time = SEC(2) + SEC(1)*(c->value - 1); - if (elapsed_time != expected_logical_time) { - printf("ERROR: Expected logical time to be %lld but got %lld\n.", - expected_logical_time, elapsed_time - ); - exit(1); - } - =} + interval_t expected_logical_time = SEC(2) + SEC(1)*(c->value - 1); + if (elapsed_time != expected_logical_time) { + printf("ERROR: Expected logical time to be %lld but got %lld\n.", + expected_logical_time, elapsed_time + ); + exit(1); + } + =} - reaction(shutdown) {= - if (self->received == 0) { - printf("ERROR: Final reactor received no data.\n"); - exit(3); - } - =} + reaction(shutdown) {= + if (self->received == 0) { + printf("ERROR: Final reactor received no data.\n"); + exit(3); + } + =} } main reactor AfterOverlapped { - count = new Count() - test = new Test() - count.out -> test.c after 2 sec + count = new Count() + test = new Test() + count.out -> test.c after 2 sec } diff --git a/test/C/src/AfterZero.lf b/test/C/src/AfterZero.lf index 378114c730..547222246c 100644 --- a/test/C/src/AfterZero.lf +++ b/test/C/src/AfterZero.lf @@ -1,57 +1,56 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target C { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } reactor foo { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= SET(y, 2*x->value); =} + reaction(x) -> y {= SET(y, 2*x->value); =} } reactor print { - state expected_time: time = 0 - state received: int = 0 - input x: int + state expected_time: time = 0 + state received: int = 0 + input x: int - reaction(x) {= - self->received++; - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("Result is %d\n", x->value); - if (x->value != 84) { - printf("ERROR: Expected result to be 84.\n"); - exit(1); - } - printf("Current logical time is: %lld\n", elapsed_time); - printf("Current microstep is: %lld\n", lf_tag().microstep); - printf("Current physical time is: %lld\n", lf_time_physical_elapsed()); - if (elapsed_time != self->expected_time) { - printf("ERROR: Expected logical time to be %lld.\n", self->expected_time); - exit(2); - } - if (lf_tag().microstep != 1) { - printf("ERROR: Expected microstep to be 1\n"); - exit(3); - } - self->expected_time += SEC(1); - =} + reaction(x) {= + self->received++; + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("Result is %d\n", x->value); + if (x->value != 84) { + printf("ERROR: Expected result to be 84.\n"); + exit(1); + } + printf("Current logical time is: %lld\n", elapsed_time); + printf("Current microstep is: %lld\n", lf_tag().microstep); + printf("Current physical time is: %lld\n", lf_time_physical_elapsed()); + if (elapsed_time != self->expected_time) { + printf("ERROR: Expected logical time to be %lld.\n", self->expected_time); + exit(2); + } + if (lf_tag().microstep != 1) { + printf("ERROR: Expected microstep to be 1\n"); + exit(3); + } + self->expected_time += SEC(1); + =} - reaction(shutdown) {= - if (self->received == 0) { - printf("ERROR: Final reactor received no data.\n"); - exit(3); - } - =} + reaction(shutdown) {= + if (self->received == 0) { + printf("ERROR: Final reactor received no data.\n"); + exit(3); + } + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x after 0 + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x after 0 - reaction(t) -> f.x {= SET(f.x, 42); =} + reaction(t) -> f.x {= SET(f.x, 42); =} } diff --git a/test/C/src/Alignment.lf b/test/C/src/Alignment.lf index a2b9b523fb..1c5c907a37 100644 --- a/test/C/src/Alignment.lf +++ b/test/C/src/Alignment.lf @@ -1,105 +1,104 @@ -// This test checks that the downstream reaction is not invoked more than once -// at a logical time. +// This test checks that the downstream reaction is not invoked more than once at a logical time. target C { - logging: LOG, - timeout: 1 sec + logging: LOG, + timeout: 1 sec } reactor Source { - output out: int - state count: int = 1 - timer t(0, 100 msec) + output out: int + state count: int = 1 + timer t(0, 100 msec) - reaction(t) -> out {= lf_set(out, self->count++); =} + reaction(t) -> out {= lf_set(out, self->count++); =} } reactor Sieve { - input in: int - output out: bool - state primes: int* = {= NULL =} - state last_prime: int = 0 + input in: int + output out: bool + state primes: int* = {= NULL =} + state last_prime: int = 0 - reaction(startup) {= - // There are 1229 primes between 1 and 10,000. - self->primes = (int*)calloc(1229, sizeof(int)); - // Primes 1 and 2 are not on the list. - self->primes[0] = 3; - =} + reaction(startup) {= + // There are 1229 primes between 1 and 10,000. + self->primes = (int*)calloc(1229, sizeof(int)); + // Primes 1 and 2 are not on the list. + self->primes[0] = 3; + =} - reaction(in) -> out {= - // Reject inputs that are out of bounds. - if (in->value <= 0 || in->value > 10000) { - lf_print_warning("Sieve: Input value out of range: %d.", in->value); + reaction(in) -> out {= + // Reject inputs that are out of bounds. + if (in->value <= 0 || in->value > 10000) { + lf_print_warning("Sieve: Input value out of range: %d.", in->value); + } + // Primes 1 and 2 are not on the list. + if (in->value == 1 || in->value == 2) { + lf_set(out, true); + return; + } + // If the input is greater than the last found prime, then + // we have to expand the list of primes before checking to + // see whether this is prime. + int candidate = self->primes[self->last_prime]; + while (in->value > self->primes[self->last_prime]) { + // The next prime is always odd, so we can increment by two. + candidate += 2; + bool prime = true; + for (int i = 0; i < self->last_prime; i++) { + if (candidate % self->primes[i] == 0) { + // Candidate is not prime. Break and add 2 + prime = false; + break; + } + } + // If the candidate is not divisible by any prime in the list, it is prime. + if (prime) { + self->last_prime++; + self->primes[self->last_prime] = candidate; + lf_print("Sieve: Found prime: %d.", candidate); } - // Primes 1 and 2 are not on the list. - if (in->value == 1 || in->value == 2) { + } + // We are now assured that the input is less than or + // equal to the last prime on the list. + // See whether the input is an already found prime. + for (int i = self->last_prime; i >= 0; i--) { + // Search the primes from the end, where they are sparser. + if (self->primes[i] == in->value) { lf_set(out, true); return; } - // If the input is greater than the last found prime, then - // we have to expand the list of primes before checking to - // see whether this is prime. - int candidate = self->primes[self->last_prime]; - while (in->value > self->primes[self->last_prime]) { - // The next prime is always odd, so we can increment by two. - candidate += 2; - bool prime = true; - for (int i = 0; i < self->last_prime; i++) { - if (candidate % self->primes[i] == 0) { - // Candidate is not prime. Break and add 2 - prime = false; - break; - } - } - // If the candidate is not divisible by any prime in the list, it is prime. - if (prime) { - self->last_prime++; - self->primes[self->last_prime] = candidate; - lf_print("Sieve: Found prime: %d.", candidate); - } - } - // We are now assured that the input is less than or - // equal to the last prime on the list. - // See whether the input is an already found prime. - for (int i = self->last_prime; i >= 0; i--) { - // Search the primes from the end, where they are sparser. - if (self->primes[i] == in->value) { - lf_set(out, true); - return; - } - } - =} + } + =} } reactor Destination { - input ok: bool - input in: int - state last_invoked: tag_t = {= NEVER_TAG_INITIALIZER =} + input ok: bool + input in: int + state last_invoked: tag_t = {= NEVER_TAG_INITIALIZER =} - reaction(ok, in) {= - tag_t current_tag = lf_tag(); - if (ok->is_present && in->is_present) { - lf_print("Destination: Input %d is prime at tag (%lld, %d).", - in->value, - current_tag.time - lf_time_start(), current_tag.microstep - ); - } - if (lf_tag_compare(current_tag, self->last_invoked) <= 0) { - lf_print_error_and_exit("Invoked at tag (%lld, %d), " - "but previously invoked at tag (%lld, %d).", - current_tag.time - lf_time_start(), current_tag.microstep, - self->last_invoked.time - lf_time_start(), self->last_invoked.microstep - ); - } - self->last_invoked = current_tag; - =} + reaction(ok, in) {= + tag_t current_tag = lf_tag(); + if (ok->is_present && in->is_present) { + lf_print("Destination: Input %d is prime at tag (%lld, %d).", + in->value, + current_tag.time - lf_time_start(), current_tag.microstep + ); + } + if (lf_tag_compare(current_tag, self->last_invoked) <= 0) { + lf_print_error_and_exit("Invoked at tag (%lld, %d), " + "but previously invoked at tag (%lld, %d).", + current_tag.time - lf_time_start(), current_tag.microstep, + self->last_invoked.time - lf_time_start(), self->last_invoked.microstep + ); + } + self->last_invoked = current_tag; + =} } main reactor { - source = new Source() - sieve = new Sieve() - destination = new Destination() - source.out -> sieve.in - sieve.out -> destination.ok - source.out -> destination.in + source = new Source() + sieve = new Sieve() + destination = new Destination() + source.out -> sieve.in + sieve.out -> destination.ok + source.out -> destination.in } diff --git a/test/C/src/ArrayAsParameter.lf b/test/C/src/ArrayAsParameter.lf index a9df29cb03..a513cbee9f 100644 --- a/test/C/src/ArrayAsParameter.lf +++ b/test/C/src/ArrayAsParameter.lf @@ -1,47 +1,46 @@ -// Source has an array as a parameter, the elements of which it passes to Print. -// The length of the array has to also be a parameter because C arrays do not -// encode their own length. +// Source has an array as a parameter, the elements of which it passes to Print. The length of the +// array has to also be a parameter because C arrays do not encode their own length. target C reactor Source(sequence: int[] = {0, 1, 2}, n_sequence: int = 3) { - output out: int - state count: int = 0 - logical action next + output out: int + state count: int = 0 + logical action next - reaction(startup, next) -> out, next {= - lf_set(out, self->sequence[self->count]); - self->count++; - if (self->count < self->n_sequence) { - lf_schedule(next, 0); - } - =} + reaction(startup, next) -> out, next {= + lf_set(out, self->sequence[self->count]); + self->count++; + if (self->count < self->n_sequence) { + lf_schedule(next, 0); + } + =} } reactor Print { - input in: int - state count: int = 1 - state received: int = 0 + input in: int + state count: int = 1 + state received: int = 0 - reaction(in) {= - self->received++; - printf("Received: %d\n", in->value); - if (in->value != self->count) { - printf("ERROR: Expected %d.\n", self->count); - exit(1); - } - self->count++; - =} + reaction(in) {= + self->received++; + printf("Received: %d\n", in->value); + if (in->value != self->count) { + printf("ERROR: Expected %d.\n", self->count); + exit(1); + } + self->count++; + =} - reaction(shutdown) {= - if (self->received == 0) { - printf("ERROR: Final reactor received no data.\n"); - exit(3); - } - =} + reaction(shutdown) {= + if (self->received == 0) { + printf("ERROR: Final reactor received no data.\n"); + exit(3); + } + =} } main reactor ArrayAsParameter { - s = new Source(sequence = {1, 2, 3, 4}, n_sequence = 4) - p = new Print() - s.out -> p.in + s = new Source(sequence = {1, 2, 3, 4}, n_sequence = 4) + p = new Print() + s.out -> p.in } diff --git a/test/C/src/ArrayAsType.lf b/test/C/src/ArrayAsType.lf index c95e5bf385..07dc9d1843 100644 --- a/test/C/src/ArrayAsType.lf +++ b/test/C/src/ArrayAsType.lf @@ -1,44 +1,44 @@ -// Source produces a statically allocated array, which it passes to Print. The -// destination references the array directly. +// Source produces a statically allocated array, which it passes to Print. The destination +// references the array directly. target C reactor Source { - output out: int[3] + output out: int[3] - reaction(startup) -> out {= - out->value[0] = 0; - out->value[1] = 1; - out->value[2] = 2; - SET_PRESENT(out); - =} + reaction(startup) -> out {= + out->value[0] = 0; + out->value[1] = 1; + out->value[2] = 2; + SET_PRESENT(out); + =} } reactor Print(scale: int = 1) { // The scale parameter is just for testing. - input in: int[3] + input in: int[3] - reaction(in) {= - int count = 0; // For testing. - bool failed = false; // For testing. - printf("Received: ["); - for (int i = 0; i < 3; i++) { - if (i > 0) printf(", "); - printf("%d", in->value[i]); - // For testing, check whether values match expectation. - if (in->value[i] != self->scale * count) { - failed = true; - } - count++; // For testing. + reaction(in) {= + int count = 0; // For testing. + bool failed = false; // For testing. + printf("Received: ["); + for (int i = 0; i < 3; i++) { + if (i > 0) printf(", "); + printf("%d", in->value[i]); + // For testing, check whether values match expectation. + if (in->value[i] != self->scale * count) { + failed = true; } - printf("]\n"); - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); - } - =} + count++; // For testing. + } + printf("]\n"); + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + =} } main reactor ArrayAsType { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/C/src/ArrayFree.lf b/test/C/src/ArrayFree.lf index 11b31c123f..ced36f82f7 100644 --- a/test/C/src/ArrayFree.lf +++ b/test/C/src/ArrayFree.lf @@ -1,31 +1,31 @@ -// Source produces a dynamically allocated array, which it passes to Free. Free -// requests a writable copy, which, instead of copying, it just gets ownership -// of the original array. It then does nothing further with it. This test checks -// that the memory gets freed automatically even with the mutable input. +// Source produces a dynamically allocated array, which it passes to Free. Free requests a writable +// copy, which, instead of copying, it just gets ownership of the original array. It then does +// nothing further with it. This test checks that the memory gets freed automatically even with the +// mutable input. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } import Source, Print from "ArrayPrint.lf" import Scale from "ArrayScale.lf" reactor Free(scale: int = 2, size: int = 3) { - mutable input in: int[] + mutable input in: int[] - reaction(in) {= - for(int i = 0; i < self->size; i++) { - in->value[i] *= self->scale; - } - =} + reaction(in) {= + for(int i = 0; i < self->size; i++) { + in->value[i] *= self->scale; + } + =} } main reactor ArrayFree { - s = new Source() - c = new Free() - c2 = new Scale() - p = new Print(scale = 2) - s.out -> c.in - s.out -> c2.in - c2.out -> p.in + s = new Source() + c = new Free() + c2 = new Scale() + p = new Print(scale = 2) + s.out -> c.in + s.out -> c2.in + c2.out -> p.in } diff --git a/test/C/src/ArrayFreeMultiple.lf b/test/C/src/ArrayFreeMultiple.lf index 7b933ce518..292f5cdb10 100644 --- a/test/C/src/ArrayFreeMultiple.lf +++ b/test/C/src/ArrayFreeMultiple.lf @@ -1,47 +1,47 @@ -// Source produces a dynamically allocated array, which it passes to Free. Free -// requests a writable copy, which, instead of copying, it just gets ownership -// of the original array. It then does nothing further with it. This test checks -// that the memory gets freed automatically even with the mutable input. +// Source produces a dynamically allocated array, which it passes to Free. Free requests a writable +// copy, which, instead of copying, it just gets ownership of the original array. It then does +// nothing further with it. This test checks that the memory gets freed automatically even with the +// mutable input. target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } import Scale from "ArrayScale.lf" import Print from "ArrayPrint.lf" reactor Source { - output out: int[] - state c: int = 0 - timer t(0, 1 sec) + output out: int[] + state c: int = 0 + timer t(0, 1 sec) - reaction(t) -> out {= - // Dynamically allocate an output array of length 3. - SET_NEW_ARRAY(out, 3); + reaction(t) -> out {= + // Dynamically allocate an output array of length 3. + SET_NEW_ARRAY(out, 3); - // Above allocates the array, which then must be populated. - out->value[0] = self->c++; - out->value[1] = self->c++; - out->value[2] = self->c++; - =} + // Above allocates the array, which then must be populated. + out->value[0] = self->c++; + out->value[1] = self->c++; + out->value[2] = self->c++; + =} } reactor Free(scale: int = 2) { - mutable input in: int[] + mutable input in: int[] - reaction(in) {= - for(int i = 0; i < in->length; i++) { - in->value[i] *= self->scale; - } - =} + reaction(in) {= + for(int i = 0; i < in->length; i++) { + in->value[i] *= self->scale; + } + =} } main reactor ArrayFreeMultiple { - s = new Source() - c = new Free() - c2 = new Scale() - p = new Print(scale = 2) - s.out -> c.in - s.out -> c2.in - c2.out -> p.in + s = new Source() + c = new Free() + c2 = new Scale() + p = new Print(scale = 2) + s.out -> c.in + s.out -> c2.in + c2.out -> p.in } diff --git a/test/C/src/ArrayParallel.lf b/test/C/src/ArrayParallel.lf index 6275924b82..3edb9c659e 100644 --- a/test/C/src/ArrayParallel.lf +++ b/test/C/src/ArrayParallel.lf @@ -1,9 +1,9 @@ -// Source allocates an array dynamically and then sends it to two reactors, each -// of which want to modify it. NOTE: Ideally, only one copy would be made, but -// this requires modifying the precedence graph between reactions. +// Source allocates an array dynamically and then sends it to two reactors, each of which want to +// modify it. NOTE: Ideally, only one copy would be made, but this requires modifying the precedence +// graph between reactions. target C { - timeout: 3 sec, - fast: true + timeout: 3 sec, + fast: true } import Scale from "ArrayScale.lf" diff --git a/test/C/src/ArrayPrint.lf b/test/C/src/ArrayPrint.lf index 937bc51bea..9cbf0e2fd6 100644 --- a/test/C/src/ArrayPrint.lf +++ b/test/C/src/ArrayPrint.lf @@ -1,57 +1,55 @@ -// Source produces a dynamically allocated array, which it passes to Print. -// Reference counting ensures that the array is freed. The array size here must -// be known to all reactors. +// Source produces a dynamically allocated array, which it passes to Print. Reference counting +// ensures that the array is freed. The array size here must be known to all reactors. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Source(size: int = 3) { - output out: int[] - state count: int = 0 - timer t(0, 1 sec) + output out: int[] + state count: int = 0 + timer t(0, 1 sec) - reaction(t) -> out {= - // Dynamically allocate an output array of length 3. - // Note that the receiving reactors need to know that the length is 3. - // A better design is given at: - // https://www.lf-lang.org/docs/handbook/target-language-details?target=c#dynamically-allocated-data - SET_NEW_ARRAY(out, 3); + reaction(t) -> out {= + // Dynamically allocate an output array of length 3. + // Note that the receiving reactors need to know that the length is 3. + // A better design is given at: + // https://www.lf-lang.org/docs/handbook/target-language-details?target=c#dynamically-allocated-data + SET_NEW_ARRAY(out, 3); - // Above allocates the array, which then must be populated. - out->value[0] = self->count++; - out->value[1] = self->count++; - out->value[2] = self->count++; - =} + // Above allocates the array, which then must be populated. + out->value[0] = self->count++; + out->value[1] = self->count++; + out->value[2] = self->count++; + =} } -// The scale parameter is just for testing. -reactor Print(scale: int = 1, size: int = 3) { - input in: int[] - state count: int = 0 +reactor Print(scale: int = 1, size: int = 3) { // The scale parameter is just for testing. + input in: int[] + state count: int = 0 - reaction(in) {= - bool failed = false; // For testing. - printf("Received: ["); - for (int i = 0; i < self->size; i++) { - if (i > 0) printf(", "); - printf("%d", in->value[i]); - // For testing, check whether values match expectation. - if (in->value[i] != self->scale * self->count) { - failed = true; - } - self->count++; // For testing. + reaction(in) {= + bool failed = false; // For testing. + printf("Received: ["); + for (int i = 0; i < self->size; i++) { + if (i > 0) printf(", "); + printf("%d", in->value[i]); + // For testing, check whether values match expectation. + if (in->value[i] != self->scale * self->count) { + failed = true; } - printf("]\n"); - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); - } - =} + self->count++; // For testing. + } + printf("]\n"); + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + =} } main reactor ArrayPrint { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/C/src/ArrayScale.lf b/test/C/src/ArrayScale.lf index 63edfc421c..06744dbcf1 100644 --- a/test/C/src/ArrayScale.lf +++ b/test/C/src/ArrayScale.lf @@ -1,30 +1,29 @@ -// Source produces a dynamically allocated array, which it passes to Scale. -// Scale requests a writable copy, which, instead of copying, it just gets -// ownership of the original array. It modifies it and passes it to Print. It -// gets freed after Print is done with it. +// Source produces a dynamically allocated array, which it passes to Scale. Scale requests a +// writable copy, which, instead of copying, it just gets ownership of the original array. It +// modifies it and passes it to Print. It gets freed after Print is done with it. target C { - timeout: 3 sec, - fast: true + timeout: 3 sec, + fast: true } import Print, Source from "ArrayPrint.lf" reactor Scale(scale: int = 2) { - mutable input in: int[] - output out: int[] + mutable input in: int[] + output out: int[] - reaction(in) -> out {= - for(int i = 0; i < in->length; i++) { - in->value[i] *= self->scale; - } - lf_set_token(out, in->token); - =} + reaction(in) -> out {= + for(int i = 0; i < in->length; i++) { + in->value[i] *= self->scale; + } + lf_set_token(out, in->token); + =} } main reactor ArrayScale { - s = new Source() - c = new Scale() - p = new Print(scale = 2) - s.out -> c.in - c.out -> p.in + s = new Source() + c = new Scale() + p = new Print(scale = 2) + s.out -> c.in + c.out -> p.in } diff --git a/test/C/src/CharLiteralInitializer.lf b/test/C/src/CharLiteralInitializer.lf index 319af0224c..ab0c12b1d8 100644 --- a/test/C/src/CharLiteralInitializer.lf +++ b/test/C/src/CharLiteralInitializer.lf @@ -2,12 +2,12 @@ target C main reactor CharLiteralInitializer { - state c: char = 'x' + state c: char = 'x' - reaction(startup) {= - if (self->c != 'x') { - fprintf(stderr, "FAILED: Expected 'x', got %c.\n", self->c); - exit(1); - } - =} + reaction(startup) {= + if (self->c != 'x') { + fprintf(stderr, "FAILED: Expected 'x', got %c.\n", self->c); + exit(1); + } + =} } diff --git a/test/C/src/Composition.lf b/test/C/src/Composition.lf index 7c024a9eba..823bd1a2fe 100644 --- a/test/C/src/Composition.lf +++ b/test/C/src/Composition.lf @@ -1,45 +1,44 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period: time = 2 sec) { - output y: int - timer t(1 sec, period) - state count: int = 0 + output y: int + timer t(1 sec, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - printf("Source sending %d.\n", self->count); - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + printf("Source sending %d.\n", self->count); + lf_set(y, self->count); + =} } reactor Test { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - (self->count)++; - printf("Received %d\n", x->value); - if (x->value != self->count) { - fprintf(stderr, "FAILURE: Expected %d\n", self->count); - exit(1); - } - =} + reaction(x) {= + (self->count)++; + printf("Received %d\n", x->value); + if (x->value != self->count) { + fprintf(stderr, "FAILURE: Expected %d\n", self->count); + exit(1); + } + =} - reaction(shutdown) {= - if (self->count == 0) { - fprintf(stderr, "FAILURE: No data received.\n"); - } - =} + reaction(shutdown) {= + if (self->count == 0) { + fprintf(stderr, "FAILURE: No data received.\n"); + } + =} } main reactor Composition { - s = new Source() + s = new Source() - d = new Test() - s.y -> d.x + d = new Test() + s.y -> d.x } diff --git a/test/C/src/CompositionAfter.lf b/test/C/src/CompositionAfter.lf index cb98ef7d7e..c0ce81f46b 100644 --- a/test/C/src/CompositionAfter.lf +++ b/test/C/src/CompositionAfter.lf @@ -1,37 +1,36 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period: time = 2 sec) { - output y: int - timer t(1 sec, period) - state count: int = 0 + output y: int + timer t(1 sec, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + lf_set(y, self->count); + =} } reactor Test { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - (self->count)++; - printf("Received %d\n", x->value); - if (x->value != self->count) { - printf("FAILURE: Expected %d\n", self->count); - exit(1); - } - =} + reaction(x) {= + (self->count)++; + printf("Received %d\n", x->value); + if (x->value != self->count) { + printf("FAILURE: Expected %d\n", self->count); + exit(1); + } + =} } main reactor CompositionAfter(delay: time = 5 sec) { - s = new Source() - d = new Test() - s.y -> d.x after delay + s = new Source() + d = new Test() + s.y -> d.x after delay } diff --git a/test/C/src/CompositionInheritance.lf b/test/C/src/CompositionInheritance.lf index 06221e9788..cd345149d5 100644 --- a/test/C/src/CompositionInheritance.lf +++ b/test/C/src/CompositionInheritance.lf @@ -1,56 +1,55 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period: time = 2 sec) { - input foo: int - output y: int - timer t(1 sec, period) - state count: int = 0 - - reaction(t) -> y {= - printf("Hello World. At time %lld, my count is: %d.\n", lf_time_logical_elapsed(), self->count); - lf_set(y, self->count); - =} + input foo: int + output y: int + timer t(1 sec, period) + state count: int = 0 + + reaction(t) -> y {= + printf("Hello World. At time %lld, my count is: %d.\n", lf_time_logical_elapsed(), self->count); + lf_set(y, self->count); + =} } reactor SourceExtended extends Source { - output y2: int - timer t2(1 sec, 3 sec) - - reaction(t2) -> y2 {= - (self->count)++; - printf("At time %lld, source sending %d.\n", lf_time_logical_elapsed(), self->count); - lf_set(y2, self->count); - =} + output y2: int + timer t2(1 sec, 3 sec) + + reaction(t2) -> y2 {= + (self->count)++; + printf("At time %lld, source sending %d.\n", lf_time_logical_elapsed(), self->count); + lf_set(y2, self->count); + =} } reactor Test { - input x: int - state count: int = 0 - - reaction(x) {= - (self->count)++; - printf("Received %d\n", x->value); - if (x->value != self->count) { - fprintf(stderr, "FAILURE: Expected %d\n", self->count); - exit(1); - } - =} - - reaction(shutdown) {= - if (self->count == 0) { - fprintf(stderr, "FAILURE: No data received.\n"); - } - =} + input x: int + state count: int = 0 + + reaction(x) {= + (self->count)++; + printf("Received %d\n", x->value); + if (x->value != self->count) { + fprintf(stderr, "FAILURE: Expected %d\n", self->count); + exit(1); + } + =} + + reaction(shutdown) {= + if (self->count == 0) { + fprintf(stderr, "FAILURE: No data received.\n"); + } + =} } main reactor CompositionInheritance { - s = new SourceExtended(period = 2 sec) + s = new SourceExtended(period = 2 sec) - d = new Test() - s.y2 -> d.x + d = new Test() + s.y2 -> d.x } diff --git a/test/C/src/CountSelf.lf b/test/C/src/CountSelf.lf index 1ef27187ae..ec910c1066 100644 --- a/test/C/src/CountSelf.lf +++ b/test/C/src/CountSelf.lf @@ -1,28 +1,28 @@ // This tests actions with payloads by delaying an input by a fixed amount. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } import TestCount from "lib/TestCount.lf" reactor CountSelf2(delay: time = 100 msec) { - output out: int - logical action a: int + output out: int + logical action a: int - reaction(startup) -> a, out {= - lf_set(out, 0); - lf_schedule_int(a, self->delay, 1); - =} + reaction(startup) -> a, out {= + lf_set(out, 0); + lf_schedule_int(a, self->delay, 1); + =} - reaction(a) -> a, out {= - lf_set(out, a->value); - lf_schedule_int(a, self->delay, a->value + 1); - =} + reaction(a) -> a, out {= + lf_set(out, a->value); + lf_schedule_int(a, self->delay, a->value + 1); + =} } main reactor { - d = new CountSelf2() - t = new TestCount(num_inputs = 11, start = 0) - d.out -> t.in + d = new CountSelf2() + t = new TestCount(num_inputs = 11, start = 0) + d.out -> t.in } diff --git a/test/C/src/Deadline.lf b/test/C/src/Deadline.lf index 21ea7df141..76d5bf564e 100644 --- a/test/C/src/Deadline.lf +++ b/test/C/src/Deadline.lf @@ -1,62 +1,61 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target C { - timeout: 6 sec + timeout: 6 sec } preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "platform.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif =} reactor Source(period: time = 3 sec) { - output y: int - timer t(0, period) - state count: int = 0 + output y: int + timer t(0, period) + state count: int = 0 - reaction(t) -> y {= - if (2 * (self->count / 2) != self->count) { - // The count variable is odd. - // Take time to cause a deadline violation. - lf_sleep(MSEC(1500)); - } - printf("Source sends: %d.\n", self->count); - lf_set(y, self->count); - (self->count)++; - =} + reaction(t) -> y {= + if (2 * (self->count / 2) != self->count) { + // The count variable is odd. + // Take time to cause a deadline violation. + lf_sleep(MSEC(1500)); + } + printf("Source sends: %d.\n", self->count); + lf_set(y, self->count); + (self->count)++; + =} } reactor Destination(timeout: time = 1 sec) { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - printf("Destination receives: %d\n", x->value); - if (2 * (self->count / 2) != self->count) { - // The count variable is odd, so the deadline should have been violated. - printf("ERROR: Failed to detect deadline.\n"); - exit(1); - } - (self->count)++; - =} deadline(timeout) {= - printf("Destination deadline handler receives: %d\n", x->value); - if (2 * (self->count / 2) == self->count) { - // The count variable is even, so the deadline should not have been violated. - printf("ERROR: Deadline miss handler invoked without deadline violation.\n"); - exit(2); - } - (self->count)++; - =} + reaction(x) {= + printf("Destination receives: %d\n", x->value); + if (2 * (self->count / 2) != self->count) { + // The count variable is odd, so the deadline should have been violated. + printf("ERROR: Failed to detect deadline.\n"); + exit(1); + } + (self->count)++; + =} deadline(timeout) {= + printf("Destination deadline handler receives: %d\n", x->value); + if (2 * (self->count / 2) == self->count) { + // The count variable is even, so the deadline should not have been violated. + printf("ERROR: Deadline miss handler invoked without deadline violation.\n"); + exit(2); + } + (self->count)++; + =} } main reactor Deadline { - s = new Source() - d = new Destination(timeout = 1 sec) - s.y -> d.x + s = new Source() + d = new Destination(timeout = 1 sec) + s.y -> d.x } diff --git a/test/C/src/DeadlineHandledAbove.lf b/test/C/src/DeadlineHandledAbove.lf index 3b0dc49198..df20467cad 100644 --- a/test/C/src/DeadlineHandledAbove.lf +++ b/test/C/src/DeadlineHandledAbove.lf @@ -1,52 +1,52 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target C preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "platform.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif =} reactor Deadline(threshold: time = 100 msec) { - input x: int - output deadline_violation: bool + input x: int + output deadline_violation: bool - reaction(x) -> deadline_violation {= - printf("ERROR: Deadline violation was not detected!\n"); - exit(1); - =} deadline(threshold) {= - printf("Deadline violation detected.\n"); - lf_set(deadline_violation, true); - =} + reaction(x) -> deadline_violation {= + printf("ERROR: Deadline violation was not detected!\n"); + exit(1); + =} deadline(threshold) {= + printf("Deadline violation detected.\n"); + lf_set(deadline_violation, true); + =} } main reactor DeadlineHandledAbove { - state violation_detected: bool = false - d = new Deadline(threshold = 10 msec) + state violation_detected: bool = false + d = new Deadline(threshold = 10 msec) - reaction(startup) -> d.x {= - lf_nanosleep(MSEC(200)); - lf_set(d.x, 42); - =} + reaction(startup) -> d.x {= + lf_nanosleep(MSEC(200)); + lf_set(d.x, 42); + =} - reaction(d.deadline_violation) {= - if (d.deadline_violation->value) { - printf("Output successfully produced by deadline miss handler.\n"); - self->violation_detected = true; - } - =} + reaction(d.deadline_violation) {= + if (d.deadline_violation->value) { + printf("Output successfully produced by deadline miss handler.\n"); + self->violation_detected = true; + } + =} - reaction(shutdown) {= - if (self->violation_detected) { - printf("SUCCESS. Test passes.\n"); - } else { - printf("FAILURE. Container did not react to deadline violation.\n"); - exit(2); - } - =} + reaction(shutdown) {= + if (self->violation_detected) { + printf("SUCCESS. Test passes.\n"); + } else { + printf("FAILURE. Container did not react to deadline violation.\n"); + exit(2); + } + =} } diff --git a/test/C/src/DeadlineInherited.lf b/test/C/src/DeadlineInherited.lf index 3d3c8ac96b..de718e34a0 100644 --- a/test/C/src/DeadlineInherited.lf +++ b/test/C/src/DeadlineInherited.lf @@ -1,32 +1,32 @@ // Test to verify that deadline priority are inherited target C { - timeout: 1 sec, - threading: false + timeout: 1 sec, + threading: false } preamble {= extern int global_cnt; =} reactor NoDeadline { - preamble {= int global_cnt = 0; =} - timer t(0 msec, 100 msec) + preamble {= int global_cnt = 0; =} + timer t(0 msec, 100 msec) - reaction(t) {= global_cnt++; =} + reaction(t) {= global_cnt++; =} } reactor WithDeadline { - timer t(0 msec, 100 msec) + timer t(0 msec, 100 msec) - reaction(t) {= =} + reaction(t) {= =} - reaction(t) {= - if (global_cnt != 0) { - lf_print_error_and_exit("Deadline reaction was not executed first. cnt=%i", global_cnt); - } - global_cnt--; - =} deadline(100 sec) {= =} + reaction(t) {= + if (global_cnt != 0) { + lf_print_error_and_exit("Deadline reaction was not executed first. cnt=%i", global_cnt); + } + global_cnt--; + =} deadline(100 sec) {= =} } main reactor { - a = new NoDeadline() - b = new WithDeadline() + a = new NoDeadline() + b = new WithDeadline() } diff --git a/test/C/src/DeadlinePriority.lf b/test/C/src/DeadlinePriority.lf index 2aa5c8136f..21a810e786 100644 --- a/test/C/src/DeadlinePriority.lf +++ b/test/C/src/DeadlinePriority.lf @@ -1,30 +1,30 @@ // Test to verify that deadline gives priority target C { - timeout: 1 sec, - threading: false + timeout: 1 sec, + threading: false } preamble {= extern int global_cnt; =} reactor NoDeadline { - preamble {= int global_cnt = 0; =} - timer t(0 msec, 100 msec) + preamble {= int global_cnt = 0; =} + timer t(0 msec, 100 msec) - reaction(t) {= global_cnt++; =} + reaction(t) {= global_cnt++; =} } reactor WithDeadline { - timer t(0 msec, 100 msec) + timer t(0 msec, 100 msec) - reaction(t) {= - if (global_cnt != 0) { - lf_print_error_and_exit("Deadline reaction was not executed first. cnt=%i", global_cnt); - } - global_cnt--; - =} deadline(100 sec) {= =} + reaction(t) {= + if (global_cnt != 0) { + lf_print_error_and_exit("Deadline reaction was not executed first. cnt=%i", global_cnt); + } + global_cnt--; + =} deadline(100 sec) {= =} } main reactor { - a = new NoDeadline() - b = new WithDeadline() + a = new NoDeadline() + b = new WithDeadline() } diff --git a/test/C/src/DeadlineWithAfterDelay.lf b/test/C/src/DeadlineWithAfterDelay.lf index 5e33e129e6..af4d1cc8c8 100644 --- a/test/C/src/DeadlineWithAfterDelay.lf +++ b/test/C/src/DeadlineWithAfterDelay.lf @@ -1,36 +1,36 @@ // Test to verify that deadline priority are inherited when using after delays target C { - timeout: 1 sec, - threading: false + timeout: 1 sec, + threading: false } preamble {= extern int global_cnt; =} reactor Source { - preamble {= int global_cnt = 0; =} + preamble {= int global_cnt = 0; =} - output out: int - timer t(0 msec, 100 msec) + output out: int + timer t(0 msec, 100 msec) - reaction(t) -> out {= - lf_set(out, 1); - global_cnt++; - =} + reaction(t) -> out {= + lf_set(out, 1); + global_cnt++; + =} } reactor SinkWithDeadline { - input in: int + input in: int - reaction(in) {= - global_cnt--; - if (global_cnt != 0) { - lf_print_error_and_exit("Deadline reaction was not executed first. cnt=%i", global_cnt); - } - =} deadline(100 sec) {= =} + reaction(in) {= + global_cnt--; + if (global_cnt != 0) { + lf_print_error_and_exit("Deadline reaction was not executed first. cnt=%i", global_cnt); + } + =} deadline(100 sec) {= =} } main reactor { - a = new Source() - b = new SinkWithDeadline() - a.out -> b.in after 100 msec // a.out -> b.in + a = new Source() + b = new SinkWithDeadline() + a.out -> b.in after 100 msec // a.out -> b.in } diff --git a/test/C/src/DeadlineWithBanks.lf b/test/C/src/DeadlineWithBanks.lf index 7a9445ec8d..2e1fd9bcca 100644 --- a/test/C/src/DeadlineWithBanks.lf +++ b/test/C/src/DeadlineWithBanks.lf @@ -1,65 +1,64 @@ /** - * This program verifies that reactions inside banks inherit the correct - * priority from their downstream reactions. A global variable is used to check - * execution order. Threading is disabled + * This program verifies that reactions inside banks inherit the correct priority from their + * downstream reactions. A global variable is used to check execution order. Threading is disabled */ target C { - threading: false, - timeout: 300 msec, - build-type: Debug + threading: false, + timeout: 300 msec, + build-type: Debug } preamble {= extern volatile int global_cnt; =} reactor Bank(bank_index: int = 0) { - preamble {= volatile int global_cnt = 0; =} + preamble {= volatile int global_cnt = 0; =} - timer t(0, 100 msec) - output out: int + timer t(0, 100 msec) + output out: int - reaction(t) -> out {= - int exp_cnt; - switch(self->bank_index) { - case 0: { - exp_cnt = 3; - break; - } - case 1: { - exp_cnt = 1; - break; - } - case 2: { - exp_cnt = 0; - break; - } - case 3: { - exp_cnt = 2; - break; - } + reaction(t) -> out {= + int exp_cnt; + switch(self->bank_index) { + case 0: { + exp_cnt = 3; + break; } - if (global_cnt != exp_cnt) { - lf_print_error_and_exit("global_cnt=%i expected=%i\n", global_cnt, exp_cnt); + case 1: { + exp_cnt = 1; + break; } - global_cnt++; - - if (self->bank_index==0) { - global_cnt=0; + case 2: { + exp_cnt = 0; + break; + } + case 3: { + exp_cnt = 2; + break; } - =} + } + if (global_cnt != exp_cnt) { + lf_print_error_and_exit("global_cnt=%i expected=%i\n", global_cnt, exp_cnt); + } + global_cnt++; + + if (self->bank_index==0) { + global_cnt=0; + } + =} } reactor Sink(dead: time = 0) { - input in: int + input in: int - reaction(in) {= =} deadline(dead) {= =} + reaction(in) {= =} deadline(dead) {= =} } main reactor { - rp = new[4] Bank() - s1 = new Sink(dead = 14 msec) - s2 = new Sink(dead = 12 msec) - s3 = new Sink(dead = 11 msec) - s4 = new Sink(dead = 13 msec) + rp = new[4] Bank() + s1 = new Sink(dead = 14 msec) + s2 = new Sink(dead = 12 msec) + s3 = new Sink(dead = 11 msec) + s4 = new Sink(dead = 13 msec) - rp.out -> s1.in, s2.in, s3.in, s4.in + rp.out -> s1.in, s2.in, s3.in, s4.in } diff --git a/test/C/src/DeadlineZero.lf b/test/C/src/DeadlineZero.lf index 3ae49a9409..26f556a800 100644 --- a/test/C/src/DeadlineZero.lf +++ b/test/C/src/DeadlineZero.lf @@ -1,27 +1,27 @@ // Tests that specified deadlines with zero duration are always violated. target C { - timeout: 1 sec + timeout: 1 sec } reactor Detector { - input trigger: int - state cnt: int = 0 + input trigger: int + state cnt: int = 0 - reaction(trigger) {= - printf("ERROR: failed to detect zero-duration deadline at iteration %d.\n", self->cnt); - exit(1); - =} deadline(0 msec) {= self->cnt++; =} + reaction(trigger) {= + printf("ERROR: failed to detect zero-duration deadline at iteration %d.\n", self->cnt); + exit(1); + =} deadline(0 msec) {= self->cnt++; =} } reactor Generator { - output pulse: int - timer t(0, 100 msec) + output pulse: int + timer t(0, 100 msec) - reaction(t) -> pulse {= lf_set(pulse, 0); =} + reaction(t) -> pulse {= lf_set(pulse, 0); =} } main reactor { - g = new Generator() - d = new Detector() - g.pulse -> d.trigger + g = new Generator() + d = new Detector() + g.pulse -> d.trigger } diff --git a/test/C/src/DelayArray.lf b/test/C/src/DelayArray.lf index 72eb734888..62f36b059e 100644 --- a/test/C/src/DelayArray.lf +++ b/test/C/src/DelayArray.lf @@ -1,63 +1,62 @@ -// This tests delaying an array type. The array length has to be agreed upon by -// all reactors. +// This tests delaying an array type. The array length has to be agreed upon by all reactors. target C { - build-type: RelWithDebInfo + build-type: RelWithDebInfo } reactor DelayPointer(delay: time = 100 msec) { - input in: int[] - output out: int[] - logical action a: int[] + input in: int[] + output out: int[] + logical action a: int[] - reaction(in) -> a {= lf_schedule_token(a, self->delay, in->token); =} + reaction(in) -> a {= lf_schedule_token(a, self->delay, in->token); =} - reaction(a) -> out {= lf_set_token(out, a->token); =} + reaction(a) -> out {= lf_set_token(out, a->token); =} } reactor Source { - output out: int[] - - reaction(startup) -> out {= - // Dynamically allocate an output array of length 3. - // Note that the receiving reactors need to know that the length is 3. - // A better design is given at: - // https://www.lf-lang.org/docs/handbook/target-language-details?target=c#dynamically-allocated-data - int* array = (int*)malloc(3 * sizeof(int)); - for (size_t i = 0; i < 3; i++) { - array[i] = i; - } - lf_set(out, array); - =} + output out: int[] + + reaction(startup) -> out {= + // Dynamically allocate an output array of length 3. + // Note that the receiving reactors need to know that the length is 3. + // A better design is given at: + // https://www.lf-lang.org/docs/handbook/target-language-details?target=c#dynamically-allocated-data + int* array = (int*)malloc(3 * sizeof(int)); + for (size_t i = 0; i < 3; i++) { + array[i] = i; + } + lf_set(out, array); + =} } reactor Print(scale: int = 1) { // The scale parameter is just for testing. - input in: int[] - - reaction(in) {= - int count = 0; // For testing. - bool failed = false; // For testing. - printf("Received: ["); - for (int i = 0; i < 3; i++) { - if (i > 0) printf(", "); - printf("%d", in->value[i]); - // For testing, check whether values match expectation. - if (in->value[i] != self->scale * count) { - failed = true; - } - count++; // For testing. - } - printf("]\n"); - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); + input in: int[] + + reaction(in) {= + int count = 0; // For testing. + bool failed = false; // For testing. + printf("Received: ["); + for (int i = 0; i < 3; i++) { + if (i > 0) printf(", "); + printf("%d", in->value[i]); + // For testing, check whether values match expectation. + if (in->value[i] != self->scale * count) { + failed = true; } - =} + count++; // For testing. + } + printf("]\n"); + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + =} } main reactor DelayArray { - s = new Source() - d = new DelayPointer() - p = new Print() - s.out -> d.in - d.out -> p.in + s = new Source() + d = new DelayPointer() + p = new Print() + s.out -> d.in + d.out -> p.in } diff --git a/test/C/src/DelayArrayWithAfter.lf b/test/C/src/DelayArrayWithAfter.lf index c94be3b9a1..094d264b08 100644 --- a/test/C/src/DelayArrayWithAfter.lf +++ b/test/C/src/DelayArrayWithAfter.lf @@ -1,70 +1,69 @@ -// This tests transport of dynamically allocated arrays over connections with -// 'after'. +// This tests transport of dynamically allocated arrays over connections with 'after'. target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Source { - output out: int[] - state iteration: int = 1 - timer t(0, 1 sec) + output out: int[] + state iteration: int = 1 + timer t(0, 1 sec) - reaction(t) -> out {= - // Dynamically allocate an output array of length 3. - SET_NEW_ARRAY(out, 3); - printf("At time %lld, sending array at address %p\n", lf_time_logical_elapsed(), out->value); + reaction(t) -> out {= + // Dynamically allocate an output array of length 3. + SET_NEW_ARRAY(out, 3); + printf("At time %lld, sending array at address %p\n", lf_time_logical_elapsed(), out->value); - // Above allocates the array, which then must be populated. - out->value[0] = 1 * self->iteration; - out->value[1] = 2 * self->iteration; - out->value[2] = 3 * self->iteration; - self->iteration++; - =} + // Above allocates the array, which then must be populated. + out->value[0] = 1 * self->iteration; + out->value[1] = 2 * self->iteration; + out->value[2] = 3 * self->iteration; + self->iteration++; + =} } reactor Print(scale: int = 1) { // The scale parameter is just for testing. - input in: int[] - state iteration: int = 1 - state inputs_received: int = 0 + input in: int[] + state iteration: int = 1 + state inputs_received: int = 0 - reaction(in) {= - self->inputs_received++; - int count = 1; // For testing. - bool failed = false; // For testing. - printf("At time %lld, received array at address %p\n", lf_time_logical_elapsed(), in->value); - printf("Received: ["); - for (int i = 0; i < in->length; i++) { - if (i > 0) printf(", "); - printf("%d", in->value[i]); - // For testing, check whether values match expectation. - if (in->value[i] != self->scale * count * self->iteration) { - failed = true; - } - count++; // For testing. + reaction(in) {= + self->inputs_received++; + int count = 1; // For testing. + bool failed = false; // For testing. + printf("At time %lld, received array at address %p\n", lf_time_logical_elapsed(), in->value); + printf("Received: ["); + for (int i = 0; i < in->length; i++) { + if (i > 0) printf(", "); + printf("%d", in->value[i]); + // For testing, check whether values match expectation. + if (in->value[i] != self->scale * count * self->iteration) { + failed = true; } - printf("]\n"); - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); - } - if (count != 4) { - printf("ERROR: Received array length is not 3!\n"); - exit(2); - } - self->iteration++; - =} + count++; // For testing. + } + printf("]\n"); + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + if (count != 4) { + printf("ERROR: Received array length is not 3!\n"); + exit(2); + } + self->iteration++; + =} - reaction(shutdown) {= - if (self->inputs_received == 0) { - printf("ERROR: Print reactor received no inputs.\n"); - exit(3); - } - =} + reaction(shutdown) {= + if (self->inputs_received == 0) { + printf("ERROR: Print reactor received no inputs.\n"); + exit(3); + } + =} } main reactor DelayArrayWithAfter { - s = new Source() - p = new Print() - s.out -> p.in after 1500 msec + s = new Source() + p = new Print() + s.out -> p.in after 1500 msec } diff --git a/test/C/src/DelayInt.lf b/test/C/src/DelayInt.lf index 78ca793716..a8fce5fe4e 100644 --- a/test/C/src/DelayInt.lf +++ b/test/C/src/DelayInt.lf @@ -2,60 +2,58 @@ target C reactor Delay(delay: time = 100 msec) { - input in: int - output out: int - logical action a: int - - reaction(a) -> out {= - if (a->has_value && a->is_present) lf_set(out, a->value); - =} - - reaction(in) -> a {= - // Use specialized form of schedule for integer payloads. - lf_schedule_int(a, self->delay, in->value); - =} + input in: int + output out: int + logical action a: int + + reaction(a) -> out {= if (a->has_value && a->is_present) lf_set(out, a->value); =} + + reaction(in) -> a {= + // Use specialized form of schedule for integer payloads. + lf_schedule_int(a, self->delay, in->value); + =} } reactor Test { - input in: int - state start_time: time = 0 - state received_value: bool = false - - reaction(startup) {= - // Record the logical time at the start. - self->start_time = lf_time_logical(); - =} - - reaction(in) {= - printf("Received: %d.\n", in->value); - self->received_value = true; - // Check the time of the input. - instant_t current_time = lf_time_logical(); - interval_t elapsed = current_time - self->start_time; - printf("After %lld nsec of logical time.\n", elapsed); - if (elapsed != 100000000LL) { - printf("ERROR: Expected elapsed time to be 100000000. It was %lld.\n", elapsed); - exit(1); - } - if (in->value != 42) { - printf("ERROR: Expected input value to be 42. It was %d.\n", in->value); - exit(2); - } - =} - - reaction(shutdown) {= - printf("Checking that communication occurred.\n"); - if (!self->received_value) { - printf("ERROR: No communication occurred!\n"); - exit(3); - } - =} + input in: int + state start_time: time = 0 + state received_value: bool = false + + reaction(startup) {= + // Record the logical time at the start. + self->start_time = lf_time_logical(); + =} + + reaction(in) {= + printf("Received: %d.\n", in->value); + self->received_value = true; + // Check the time of the input. + instant_t current_time = lf_time_logical(); + interval_t elapsed = current_time - self->start_time; + printf("After %lld nsec of logical time.\n", elapsed); + if (elapsed != 100000000LL) { + printf("ERROR: Expected elapsed time to be 100000000. It was %lld.\n", elapsed); + exit(1); + } + if (in->value != 42) { + printf("ERROR: Expected input value to be 42. It was %d.\n", in->value); + exit(2); + } + =} + + reaction(shutdown) {= + printf("Checking that communication occurred.\n"); + if (!self->received_value) { + printf("ERROR: No communication occurred!\n"); + exit(3); + } + =} } main reactor DelayInt { - d = new Delay() - t = new Test() - d.out -> t.in + d = new Delay() + t = new Test() + d.out -> t.in - reaction(startup) -> d.in {= lf_set(d.in, 42); =} + reaction(startup) -> d.in {= lf_set(d.in, 42); =} } diff --git a/test/C/src/DelayPointer.lf b/test/C/src/DelayPointer.lf index c6313c199d..d0dba9d68e 100644 --- a/test/C/src/DelayPointer.lf +++ b/test/C/src/DelayPointer.lf @@ -2,72 +2,72 @@ target C reactor DelayPointer2(delay: time = 100 msec) { - input in: int* - output out: int* - logical action a: int* + input in: int* + output out: int* + logical action a: int* - reaction(a) -> out {= - // Using lf_set_token delegates responsibility for - // freeing the allocated memory downstream. - lf_set_token(out, a->token); - =} + reaction(a) -> out {= + // Using lf_set_token delegates responsibility for + // freeing the allocated memory downstream. + lf_set_token(out, a->token); + =} - reaction(in) -> a {= - // Schedule the actual token from the input rather than - // a new token with a copy of the input value. - lf_schedule_token(a, self->delay, in->token); - =} + reaction(in) -> a {= + // Schedule the actual token from the input rather than + // a new token with a copy of the input value. + lf_schedule_token(a, self->delay, in->token); + =} } reactor Source { - output out: int* + output out: int* - reaction(startup) -> out {= - SET_NEW(out); - *(out->value) = 42; - =} + reaction(startup) -> out {= + SET_NEW(out); + *(out->value) = 42; + =} } reactor Test { - input in: int* - state start_time: time = 0 - state received_value: bool = false + input in: int* + state start_time: time = 0 + state received_value: bool = false - reaction(startup) {= - // Record the logical time at the start. - self->start_time = lf_time_logical(); - =} + reaction(startup) {= + // Record the logical time at the start. + self->start_time = lf_time_logical(); + =} - reaction(in) {= - printf("Received: %d.\n", *(in->value)); - self->received_value = true; - // Check the time of the input. - instant_t current_time = lf_time_logical(); - interval_t elapsed = current_time - self->start_time; - printf("After %lld nsec of logical time.\n", elapsed); - if (elapsed != 100000000LL) { - printf("ERROR: Expected elapsed time to be 100000000. It was %lld.\n", elapsed); - exit(1); - } - if (*(in->value) != 42) { - printf("ERROR: Expected input value to be 42. It was %d.\n", *(in->value)); - exit(2); - } - =} + reaction(in) {= + printf("Received: %d.\n", *(in->value)); + self->received_value = true; + // Check the time of the input. + instant_t current_time = lf_time_logical(); + interval_t elapsed = current_time - self->start_time; + printf("After %lld nsec of logical time.\n", elapsed); + if (elapsed != 100000000LL) { + printf("ERROR: Expected elapsed time to be 100000000. It was %lld.\n", elapsed); + exit(1); + } + if (*(in->value) != 42) { + printf("ERROR: Expected input value to be 42. It was %d.\n", *(in->value)); + exit(2); + } + =} - reaction(shutdown) {= - printf("Checking that communication occurred.\n"); - if (!self->received_value) { - printf("ERROR: No communication occurred!\n"); - exit(3); - } - =} + reaction(shutdown) {= + printf("Checking that communication occurred.\n"); + if (!self->received_value) { + printf("ERROR: No communication occurred!\n"); + exit(3); + } + =} } main reactor { - s = new Source() - d = new DelayPointer2() - t = new Test() - s.out -> d.in - d.out -> t.in + s = new Source() + d = new DelayPointer2() + t = new Test() + s.out -> d.in + d.out -> t.in } diff --git a/test/C/src/DelayString.lf b/test/C/src/DelayString.lf index 1b4204cfc4..9eb5417375 100644 --- a/test/C/src/DelayString.lf +++ b/test/C/src/DelayString.lf @@ -1,53 +1,52 @@ -// This tests actions with immutable payloads that are neither malloc'd nor -// freed. +// This tests actions with immutable payloads that are neither malloc'd nor freed. target C preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include + #ifdef __cplusplus + } + #endif =} reactor DelayString2(delay: time = 100 msec) { - input in: string - output out: string - logical action a: string + input in: string + output out: string + logical action a: string - reaction(a) -> out {= lf_set(out, a->value); =} + reaction(a) -> out {= lf_set(out, a->value); =} - reaction(in) -> a {= - // The following copies the char*, not the string. - lf_schedule_copy(a, self->delay, &(in->value), 1); - =} + reaction(in) -> a {= + // The following copies the char*, not the string. + lf_schedule_copy(a, self->delay, &(in->value), 1); + =} } reactor Test { - input in: string - - reaction(in) {= - printf("Received: %s.\n", in->value); - // Check the time of the input. - interval_t elapsed = lf_time_logical_elapsed(); - printf("After %lld nsec of logical time.\n", elapsed); - if (elapsed != 100000000LL) { - printf("ERROR: Expected elapsed time to be 100000000. It was %lld.\n", elapsed); - exit(1); - } - if (strcmp(in->value, "Hello") != 0) { - printf("ERROR: Expected input value to be \"Hello\". It was \"%s\".\n", in->value); - exit(2); - } - =} + input in: string + + reaction(in) {= + printf("Received: %s.\n", in->value); + // Check the time of the input. + interval_t elapsed = lf_time_logical_elapsed(); + printf("After %lld nsec of logical time.\n", elapsed); + if (elapsed != 100000000LL) { + printf("ERROR: Expected elapsed time to be 100000000. It was %lld.\n", elapsed); + exit(1); + } + if (strcmp(in->value, "Hello") != 0) { + printf("ERROR: Expected input value to be \"Hello\". It was \"%s\".\n", in->value); + exit(2); + } + =} } main reactor { - d = new DelayString2() - t = new Test() - d.out -> t.in + d = new DelayString2() + t = new Test() + d.out -> t.in - reaction(startup) -> d.in {= lf_set(d.in, "Hello"); =} + reaction(startup) -> d.in {= lf_set(d.in, "Hello"); =} } diff --git a/test/C/src/DelayStruct.lf b/test/C/src/DelayStruct.lf index 0a92171d35..6394ddbc1f 100644 --- a/test/C/src/DelayStruct.lf +++ b/test/C/src/DelayStruct.lf @@ -1,60 +1,60 @@ // Test delaying a struct pointer type. target C { - files: ["include/hello.h"] + files: ["include/hello.h"] } preamble {= - #include "hello.h" - #include + #include "hello.h" + #include =} reactor DelayPointer(delay: time = 100 msec) { - input in: hello_t* - output out: hello_t* - logical action a: hello_t* - - reaction(a) -> out {= - // Using lf_set_token delegates responsibility for - // freeing the allocated memory downstream. - lf_set_token(out, a->token); - =} - - reaction(in) -> a {= - // Schedule the actual token from the input rather than - // a new token with a copy of the input value. - lf_schedule_token(a, self->delay, in->token); - =} + input in: hello_t* + output out: hello_t* + logical action a: hello_t* + + reaction(a) -> out {= + // Using lf_set_token delegates responsibility for + // freeing the allocated memory downstream. + lf_set_token(out, a->token); + =} + + reaction(in) -> a {= + // Schedule the actual token from the input rather than + // a new token with a copy of the input value. + lf_schedule_token(a, self->delay, in->token); + =} } reactor Source { - output out: hello_t* + output out: hello_t* - reaction(startup) -> out {= - // Dynamically allocate an output struct. - SET_NEW(out); + reaction(startup) -> out {= + // Dynamically allocate an output struct. + SET_NEW(out); - // Above allocates a struct, which then must be populated. - out->value->name = "Earth"; - out->value->value = 42; - =} + // Above allocates a struct, which then must be populated. + out->value->name = "Earth"; + out->value->value = 42; + =} } reactor Print(expected: int = 42) { // expected parameter is for testing. - input in: hello_t* - - reaction(in) {= - printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); - if (in->value->value != self->expected) { - printf("ERROR: Expected value to be %d.\n", self->expected); - exit(1); - } - =} + input in: hello_t* + + reaction(in) {= + printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); + if (in->value->value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } + =} } main reactor DelayStruct { - s = new Source() - d = new DelayPointer() - p = new Print() - s.out -> d.in - d.out -> p.in + s = new Source() + d = new DelayPointer() + p = new Print() + s.out -> d.in + d.out -> p.in } diff --git a/test/C/src/DelayStructWithAfter.lf b/test/C/src/DelayStructWithAfter.lf index 6693a437e6..e3cf5b5b59 100644 --- a/test/C/src/DelayStructWithAfter.lf +++ b/test/C/src/DelayStructWithAfter.lf @@ -1,39 +1,39 @@ // This tests delaying a struct using after. target C { - files: include/hello.h + files: include/hello.h } preamble {= - #include "hello.h" + #include "hello.h" =} reactor Source { - output out: hello_t* + output out: hello_t* - reaction(startup) -> out {= - // Dynamically allocate an output struct. - SET_NEW(out); + reaction(startup) -> out {= + // Dynamically allocate an output struct. + SET_NEW(out); - // Above allocates a struct, which then must be populated. - out->value->name = "Earth"; - out->value->value = 42; - =} + // Above allocates a struct, which then must be populated. + out->value->name = "Earth"; + out->value->value = 42; + =} } reactor Print(expected: int = 42) { // expected parameter is for testing. - input in: hello_t* + input in: hello_t* - reaction(in) {= - printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); - if (in->value->value != self->expected) { - printf("ERROR: Expected value to be %d.\n", self->expected); - exit(1); - } - =} + reaction(in) {= + printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); + if (in->value->value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } + =} } main reactor DelayStructWithAfter { - s = new Source() - p = new Print() - s.out -> p.in after 100 msec + s = new Source() + p = new Print() + s.out -> p.in after 100 msec } diff --git a/test/C/src/DelayStructWithAfterOverlapped.lf b/test/C/src/DelayStructWithAfterOverlapped.lf index 8161022653..d10772a964 100644 --- a/test/C/src/DelayStructWithAfterOverlapped.lf +++ b/test/C/src/DelayStructWithAfterOverlapped.lf @@ -1,53 +1,53 @@ // This tests delaying a struct using after. target C { - timeout: 5 sec, - fast: true, - files: ["include/hello.h"] + timeout: 5 sec, + fast: true, + files: ["include/hello.h"] } preamble {= - #include "hello.h" + #include "hello.h" =} reactor Source { - output out: hello_t* - timer t(0, 1 sec) - state s: int = 0 - - reaction(t) -> out {= - self->s++; - // Dynamically allocate an output struct. - SET_NEW(out); - - // Above allocates a struct, which then must be populated. - out->value->name = "Earth"; - out->value->value = 42 * self->s; - =} + output out: hello_t* + timer t(0, 1 sec) + state s: int = 0 + + reaction(t) -> out {= + self->s++; + // Dynamically allocate an output struct. + SET_NEW(out); + + // Above allocates a struct, which then must be populated. + out->value->name = "Earth"; + out->value->value = 42 * self->s; + =} } reactor Print { // expected parameter is for testing. - input in: hello_t* - state s: int = 0 - - reaction(in) {= - self->s++; - printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); - if (in->value->value != 42 * self->s) { - printf("ERROR: Expected value to be %d.\n", 42 * self->s); - exit(1); - } - =} - - reaction(shutdown) {= - if (self->s == 0) { - printf("ERROR: Print received no data.\n"); - exit(2); - } - =} + input in: hello_t* + state s: int = 0 + + reaction(in) {= + self->s++; + printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); + if (in->value->value != 42 * self->s) { + printf("ERROR: Expected value to be %d.\n", 42 * self->s); + exit(1); + } + =} + + reaction(shutdown) {= + if (self->s == 0) { + printf("ERROR: Print received no data.\n"); + exit(2); + } + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p.in after 1500 msec + s = new Source() + p = new Print() + s.out -> p.in after 1500 msec } diff --git a/test/C/src/DelayedAction.lf b/test/C/src/DelayedAction.lf index 28a3e81ac5..ff7ce075f4 100644 --- a/test/C/src/DelayedAction.lf +++ b/test/C/src/DelayedAction.lf @@ -1,25 +1,25 @@ target C { - fast: true, - timeout: 5 sec + fast: true, + timeout: 5 sec } main reactor DelayedAction { - timer t(0, 1 sec) - logical action a - state count: int = 0 + timer t(0, 1 sec) + logical action a + state count: int = 0 - reaction(t) -> a {= lf_schedule(a, MSEC(100)); =} + reaction(t) -> a {= lf_schedule(a, MSEC(100)); =} - reaction(a) {= - interval_t elapsed = lf_time_logical_elapsed(); - interval_t elapsed_physical = lf_time_physical_elapsed(); - printf("Nanoseconds since start: %lld.\n", elapsed); - printf("Physical nanoseconds since start: %lld.\n", elapsed_physical); - interval_t expected = self->count * 1000000000LL + 100000000LL; - self->count++; - if (elapsed != expected) { - printf("Expected %lld but got %lld.\n", expected, elapsed); - exit(1); - } - =} + reaction(a) {= + interval_t elapsed = lf_time_logical_elapsed(); + interval_t elapsed_physical = lf_time_physical_elapsed(); + printf("Nanoseconds since start: %lld.\n", elapsed); + printf("Physical nanoseconds since start: %lld.\n", elapsed_physical); + interval_t expected = self->count * 1000000000LL + 100000000LL; + self->count++; + if (elapsed != expected) { + printf("Expected %lld but got %lld.\n", expected, elapsed); + exit(1); + } + =} } diff --git a/test/C/src/DoubleInvocation.lf b/test/C/src/DoubleInvocation.lf index 973c8b18f6..98c0d51e20 100644 --- a/test/C/src/DoubleInvocation.lf +++ b/test/C/src/DoubleInvocation.lf @@ -1,54 +1,53 @@ -// This illustrates a very strange bug that showed up and has now been fixed. -// This test ensures it does not reappear. At logical time zero, the two Print -// reactors used to be fired twice each at the same logical time. They should -// only be fired once. This behavior was oddly eliminated by either of the -// following actions, neither of which should affect this behavior: +// This illustrates a very strange bug that showed up and has now been fixed. This test ensures it +// does not reappear. At logical time zero, the two Print reactors used to be fired twice each at +// the same logical time. They should only be fired once. This behavior was oddly eliminated by +// either of the following actions, neither of which should affect this behavior: // * Removing the startup reaction in Print. // * Sending only position, not velocity from Ball. target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Ball { - output position: int - output velocity: int - state p: int = 200 - timer trigger(0, 1 sec) + output position: int + output velocity: int + state p: int = 200 + timer trigger(0, 1 sec) - reaction(trigger) -> position, velocity {= - lf_set(position, self->p); - lf_set(velocity, -1); - self->p -= 1; - =} + reaction(trigger) -> position, velocity {= + lf_set(position, self->p); + lf_set(velocity, -1); + self->p -= 1; + =} } reactor Print { - input velocity: int - input position: int - state previous: int = -1 + input velocity: int + input position: int + state previous: int = -1 - reaction(startup) {= - printf("####### Print startup\n"); - =} + reaction(startup) {= + printf("####### Print startup\n"); + =} - reaction(position, velocity) {= - if (position->is_present) { - printf("Position: %d.\n", position->value); - } - if (position->value == self->previous) { - printf("ERROR: Multiple firings at the same logical time!\n"); - exit(1); - } - =} + reaction(position, velocity) {= + if (position->is_present) { + printf("Position: %d.\n", position->value); + } + if (position->value == self->previous) { + printf("ERROR: Multiple firings at the same logical time!\n"); + exit(1); + } + =} } main reactor DoubleInvocation { - b1 = new Ball() - p = new Print() - plot = new Print() - b1.position -> p.position - b1.velocity -> p.velocity - b1.position -> plot.position - b1.velocity -> plot.velocity + b1 = new Ball() + p = new Print() + plot = new Print() + b1.position -> p.position + b1.velocity -> p.velocity + b1.position -> plot.position + b1.velocity -> plot.velocity } diff --git a/test/C/src/DoublePort.lf b/test/C/src/DoublePort.lf index c8bf9811f8..545c7fba1f 100644 --- a/test/C/src/DoublePort.lf +++ b/test/C/src/DoublePort.lf @@ -1,50 +1,47 @@ /** - * Test the case where two upstream reactors pass messages to a downstream - * reactor on two different ports. One message carries a microstep delay - * relative to the other. + * Test the case where two upstream reactors pass messages to a downstream reactor on two different + * ports. One message carries a microstep delay relative to the other. * * @author Soroush Bateni */ target C { - timeout: 900 msec, - fast: true + timeout: 900 msec, + fast: true } import Count from "lib/Count.lf" reactor CountMicrostep { - state count: int = 1 - output out: int - logical action act: int - timer t(0, 1 sec) + state count: int = 1 + output out: int + logical action act: int + timer t(0, 1 sec) - reaction(t) -> act {= lf_schedule_int(act, 0, self->count++); =} + reaction(t) -> act {= lf_schedule_int(act, 0, self->count++); =} - reaction(act) -> out {= lf_set(out, act->value); =} + reaction(act) -> out {= lf_set(out, act->value); =} } reactor Print { - input in: int - input in2: int - - reaction(in, in2) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("At tag (%lld, %u), received in = %d and in2 = %d.\n", elapsed_time, lf_tag().microstep, in->value, in2->value); - if (in->is_present && in2->is_present) { - fprintf(stderr, "ERROR: invalid logical simultaneity.\n"); - exit(1); - } - =} - - reaction(shutdown) {= - printf("SUCCESS: messages were at least one microstep apart.\n"); - =} + input in: int + input in2: int + + reaction(in, in2) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("At tag (%lld, %u), received in = %d and in2 = %d.\n", elapsed_time, lf_tag().microstep, in->value, in2->value); + if (in->is_present && in2->is_present) { + fprintf(stderr, "ERROR: invalid logical simultaneity.\n"); + exit(1); + } + =} + + reaction(shutdown) {= printf("SUCCESS: messages were at least one microstep apart.\n"); =} } main reactor DoublePort { - c = new Count() - cm = new CountMicrostep() - p = new Print() - c.out -> p.in - cm.out -> p.in2 + c = new Count() + cm = new CountMicrostep() + p = new Print() + c.out -> p.in + cm.out -> p.in2 } diff --git a/test/C/src/DoubleReaction.lf b/test/C/src/DoubleReaction.lf index 8da6210825..4dd17db7c4 100644 --- a/test/C/src/DoubleReaction.lf +++ b/test/C/src/DoubleReaction.lf @@ -1,47 +1,47 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target C { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + lf_set(y, self->count); + =} } reactor Destination { - input x: int - input w: int - state s: int = 2 + input x: int + input w: int + state s: int = 2 - reaction(x, w) {= - int sum = 0; - if (x->is_present) { - sum += x->value; - } - if (w->is_present) { - sum += w->value; - } - printf("Sum of inputs is: %d\n", sum); - if (sum != self->s) { - printf("FAILURE: Expected sum to be %d, but it was %d.\n", self->s, sum); - exit(1); - } - self->s += 2; - =} + reaction(x, w) {= + int sum = 0; + if (x->is_present) { + sum += x->value; + } + if (w->is_present) { + sum += w->value; + } + printf("Sum of inputs is: %d\n", sum); + if (sum != self->s) { + printf("FAILURE: Expected sum to be %d, but it was %d.\n", self->s, sum); + exit(1); + } + self->s += 2; + =} } main reactor DoubleReaction { - c1 = new Clock() - c2 = new Clock() - d = new Destination() - c1.y -> d.x - c2.y -> d.w + c1 = new Clock() + c2 = new Clock() + d = new Destination() + c1.y -> d.x + c2.y -> d.w } diff --git a/test/C/src/DoubleTrigger.lf b/test/C/src/DoubleTrigger.lf index 68ad603168..c36eaa0362 100644 --- a/test/C/src/DoubleTrigger.lf +++ b/test/C/src/DoubleTrigger.lf @@ -1,29 +1,28 @@ -// Test that two simultaneous triggers don't cause a reaction to execute twice -// at the same tag. +// Test that two simultaneous triggers don't cause a reaction to execute twice at the same tag. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } main reactor DoubleTrigger { - timer t1 - timer t2 - state s: int = 0 + timer t1 + timer t2 + state s: int = 0 - reaction(t1, t2) {= - self->s++; - if (self->s > 1) { - printf("FAILURE: Reaction got triggered twice.\n"); - exit(1); - } - =} + reaction(t1, t2) {= + self->s++; + if (self->s > 1) { + printf("FAILURE: Reaction got triggered twice.\n"); + exit(1); + } + =} - reaction(shutdown) {= - if (self->s == 1) { - printf("SUCCESS.\n"); - } else { - printf("FAILURE: Reaction was never triggered.\n"); - exit(1); - } - =} + reaction(shutdown) {= + if (self->s == 1) { + printf("SUCCESS.\n"); + } else { + printf("FAILURE: Reaction was never triggered.\n"); + exit(1); + } + =} } diff --git a/test/C/src/FilePkgReader.lf b/test/C/src/FilePkgReader.lf index df2c03ab78..7fdd2d62d2 100644 --- a/test/C/src/FilePkgReader.lf +++ b/test/C/src/FilePkgReader.lf @@ -2,46 +2,46 @@ target C reactor Source { - output out: char* // Use char*, not string, so memory is freed. - - reaction(startup) -> out {= - char* file_path = - LF_PACKAGE_DIRECTORY - LF_FILE_SEPARATOR "src" - LF_FILE_SEPARATOR "lib" - LF_FILE_SEPARATOR "FileReader.txt"; - - FILE* file = fopen(file_path, "rb"); - if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); - - // Determine the file size - fseek(file, 0, SEEK_END); - long file_size = ftell(file); - fseek(file, 0, SEEK_SET); - - // Allocate memory for the buffer - char* buffer = (char *) malloc(file_size + 1); - if (buffer == NULL) lf_print_error_and_exit("Out of memory."); - - // Read the file into the buffer - fread(buffer, file_size, 1, file); - buffer[file_size] = '\0'; - fclose(file); - - lf_set(out, buffer); - =} + output out: char* // Use char*, not string, so memory is freed. + + reaction(startup) -> out {= + char* file_path = + LF_PACKAGE_DIRECTORY + LF_FILE_SEPARATOR "src" + LF_FILE_SEPARATOR "lib" + LF_FILE_SEPARATOR "FileReader.txt"; + + FILE* file = fopen(file_path, "rb"); + if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); + + // Determine the file size + fseek(file, 0, SEEK_END); + long file_size = ftell(file); + fseek(file, 0, SEEK_SET); + + // Allocate memory for the buffer + char* buffer = (char *) malloc(file_size + 1); + if (buffer == NULL) lf_print_error_and_exit("Out of memory."); + + // Read the file into the buffer + fread(buffer, file_size, 1, file); + buffer[file_size] = '\0'; + fclose(file); + + lf_set(out, buffer); + =} } main reactor { - preamble {= - #include - =} - s = new Source() - - reaction(s.out) {= - printf("Received: %s\n", s.out->value); - if (strcmp("Hello World", s.out->value) != 0) { - lf_print_error_and_exit("Expected 'Hello World'"); - } - =} + preamble {= + #include + =} + s = new Source() + + reaction(s.out) {= + printf("Received: %s\n", s.out->value); + if (strcmp("Hello World", s.out->value) != 0) { + lf_print_error_and_exit("Expected 'Hello World'"); + } + =} } diff --git a/test/C/src/FileReader.lf b/test/C/src/FileReader.lf index 10be772fb7..4bd093eedf 100644 --- a/test/C/src/FileReader.lf +++ b/test/C/src/FileReader.lf @@ -2,45 +2,45 @@ target C reactor Source { - output out: char* // Use char*, not string, so memory is freed. + output out: char* // Use char*, not string, so memory is freed. - reaction(startup) -> out {= - char* file_path = - LF_SOURCE_DIRECTORY - LF_FILE_SEPARATOR "lib" - LF_FILE_SEPARATOR "FileReader.txt"; + reaction(startup) -> out {= + char* file_path = + LF_SOURCE_DIRECTORY + LF_FILE_SEPARATOR "lib" + LF_FILE_SEPARATOR "FileReader.txt"; - FILE* file = fopen(file_path, "rb"); - if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); + FILE* file = fopen(file_path, "rb"); + if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); - // Determine the file size - fseek(file, 0, SEEK_END); - long file_size = ftell(file); - fseek(file, 0, SEEK_SET); + // Determine the file size + fseek(file, 0, SEEK_END); + long file_size = ftell(file); + fseek(file, 0, SEEK_SET); - // Allocate memory for the buffer - char* buffer = (char *) malloc(file_size + 1); - if (buffer == NULL) lf_print_error_and_exit("Out of memory."); + // Allocate memory for the buffer + char* buffer = (char *) malloc(file_size + 1); + if (buffer == NULL) lf_print_error_and_exit("Out of memory."); - // Read the file into the buffer - fread(buffer, file_size, 1, file); - buffer[file_size] = '\0'; - fclose(file); + // Read the file into the buffer + fread(buffer, file_size, 1, file); + buffer[file_size] = '\0'; + fclose(file); - lf_set(out, buffer); - =} + lf_set(out, buffer); + =} } main reactor { - preamble {= - #include - =} - s = new Source() - - reaction(s.out) {= - printf("Received: %s\n", s.out->value); - if (strcmp("Hello World", s.out->value) != 0) { - lf_print_error_and_exit("Expected 'Hello World'"); - } - =} + preamble {= + #include + =} + s = new Source() + + reaction(s.out) {= + printf("Received: %s\n", s.out->value); + if (strcmp("Hello World", s.out->value) != 0) { + lf_print_error_and_exit("Expected 'Hello World'"); + } + =} } diff --git a/test/C/src/FloatLiteral.lf b/test/C/src/FloatLiteral.lf index 576a20d1ac..dd6a39fc95 100644 --- a/test/C/src/FloatLiteral.lf +++ b/test/C/src/FloatLiteral.lf @@ -1,25 +1,24 @@ target C -// This test verifies that floating-point literals are handled correctly. -main reactor { - preamble {= - #include - =} +main reactor { // This test verifies that floating-point literals are handled correctly. + preamble {= + #include + =} - state N: double = 6.0221409e+23 - state charge: double = -1.6021766E-19 - state minus_epsilon: double = -.01e0 - state expected: double = .964853323188E5 + state N: double = 6.0221409e+23 + state charge: double = -1.6021766E-19 + state minus_epsilon: double = -.01e0 + state expected: double = .964853323188E5 - reaction(startup) {= - double F = - self->N * self->charge; - if (fabs(F - self->expected) < fabs(self->minus_epsilon)) { - lf_print("The Faraday constant is roughly %f.", F); - } else { - lf_print_error_and_exit( - "ERROR: Expected %f but computed %f.", - self->expected, F - ); - } - =} + reaction(startup) {= + double F = - self->N * self->charge; + if (fabs(F - self->expected) < fabs(self->minus_epsilon)) { + lf_print("The Faraday constant is roughly %f.", F); + } else { + lf_print_error_and_exit( + "ERROR: Expected %f but computed %f.", + self->expected, F + ); + } + =} } diff --git a/test/C/src/Gain.lf b/test/C/src/Gain.lf index 7cac5eaae6..5df74e2e01 100644 --- a/test/C/src/Gain.lf +++ b/test/C/src/Gain.lf @@ -2,38 +2,38 @@ target C reactor Scale(scale: int = 2) { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= lf_set(y, x->value * self->scale); =} + reaction(x) -> y {= lf_set(y, x->value * self->scale); =} } reactor Test { - input x: int - state received_value: bool = false + input x: int + state received_value: bool = false - reaction(x) {= - printf("Received %d.\n", x->value); - self->received_value = true; - if (x->value != 2) { - printf("ERROR: Expected 2!\n"); - exit(1); - } - =} + reaction(x) {= + printf("Received %d.\n", x->value); + self->received_value = true; + if (x->value != 2) { + printf("ERROR: Expected 2!\n"); + exit(1); + } + =} - reaction(shutdown) {= - if (!self->received_value) { - printf("ERROR: No value received by Test reactor!\n"); - } else { - printf("Test passes.\n"); - } - =} + reaction(shutdown) {= + if (!self->received_value) { + printf("ERROR: No value received by Test reactor!\n"); + } else { + printf("Test passes.\n"); + } + =} } main reactor Gain { - g = new Scale() - d = new Test() - g.y -> d.x + g = new Scale() + d = new Test() + g.y -> d.x - reaction(startup) -> g.x {= lf_set(g.x, 1); =} + reaction(startup) -> g.x {= lf_set(g.x, 1); =} } diff --git a/test/C/src/GetMicroStep.lf b/test/C/src/GetMicroStep.lf index 0a428fd07d..65a60f7174 100644 --- a/test/C/src/GetMicroStep.lf +++ b/test/C/src/GetMicroStep.lf @@ -2,20 +2,20 @@ target C main reactor GetMicroStep { - state s: int = 1 + state s: int = 1 - logical action l + logical action l - reaction(startup) -> l {= lf_schedule(l, 0); =} + reaction(startup) -> l {= lf_schedule(l, 0); =} - reaction(l) -> l {= - microstep_t microstep = lf_tag().microstep; - if (microstep != self->s) { - lf_print_error_and_exit("expected microstep %d, got %d instead.", self->s, microstep); - } - self->s += 1; - if (self->s < 10) { - lf_schedule(l, 0); - } - =} + reaction(l) -> l {= + microstep_t microstep = lf_tag().microstep; + if (microstep != self->s) { + lf_print_error_and_exit("expected microstep %d, got %d instead.", self->s, microstep); + } + self->s += 1; + if (self->s < 10) { + lf_schedule(l, 0); + } + =} } diff --git a/test/C/src/Hello.lf b/test/C/src/Hello.lf index 7784e2f86f..32f822e711 100644 --- a/test/C/src/Hello.lf +++ b/test/C/src/Hello.lf @@ -1,63 +1,56 @@ -// This test checks that logical time is incremented an appropriate amount as a -// result of an invocation of the lf_schedule() function at runtime. It also -// performs various smoke tests of timing aligned reactions. The first instance -// has a period of 4 seconds, the second of 2 seconds, and the third (composite) -// or 1 second. +// This test checks that logical time is incremented an appropriate amount as a result of an +// invocation of the lf_schedule() function at runtime. It also performs various smoke tests of +// timing aligned reactions. The first instance has a period of 4 seconds, the second of 2 seconds, +// and the third (composite) or 1 second. target C { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } preamble {= - #include + #include =} reactor Reschedule(period: time = 2 sec, message: string = "Hello C") { - state count: int = 0 - state previous_time: time = 0 - timer t(1 sec, period) - logical action a + state count: int = 0 + state previous_time: time = 0 + timer t(1 sec, period) + logical action a - reaction(t) -> a {= - printf("%s\n", self->message); - lf_schedule(a, MSEC(200)); - // Print the current time. - self->previous_time = lf_time_logical(); - time_t secs = self->previous_time/BILLION; - printf("Current time is %lld\n", self->previous_time); - printf("Which is %sPlus %lld nanoseconds.\n", ctime(&secs), self->previous_time % BILLION); - =} + reaction(t) -> a {= + printf("%s\n", self->message); + lf_schedule(a, MSEC(200)); + // Print the current time. + self->previous_time = lf_time_logical(); + time_t secs = self->previous_time/BILLION; + printf("Current time is %lld\n", self->previous_time); + printf("Which is %sPlus %lld nanoseconds.\n", ctime(&secs), self->previous_time % BILLION); + =} - reaction(a) {= - (self->count)++; - printf("***** action %d at time %lld\n", self->count, lf_time_logical()); - // Check the a_has_value variable. - if (a->has_value) { - printf("FAILURE: Expected a_has_value to be false, but it was true.\n"); - exit(2); - } - long long time = lf_time_logical(); - if (time - self->previous_time != 200000000ll) { - printf("FAILURE: Expected 200ms of logical time to elapse but got %lld nanoseconds.\n", - time - self->previous_time - ); - exit(1); - } - =} + reaction(a) {= + (self->count)++; + printf("***** action %d at time %lld\n", self->count, lf_time_logical()); + // Check the a_has_value variable. + if (a->has_value) { + printf("FAILURE: Expected a_has_value to be false, but it was true.\n"); + exit(2); + } + long long time = lf_time_logical(); + if (time - self->previous_time != 200000000ll) { + printf("FAILURE: Expected 200ms of logical time to elapse but got %lld nanoseconds.\n", + time - self->previous_time + ); + exit(1); + } + =} } -reactor Inside( - period: time = 1 sec, - message: string = "Composite default message." -) { - third_instance = new Reschedule(period = period, message = message) +reactor Inside(period: time = 1 sec, message: string = "Composite default message.") { + third_instance = new Reschedule(period = period, message = message) } main reactor Hello { - first_instance = new Reschedule( - period = 4 sec, - message = "Hello from first_instance." - ) - second_instance = new Reschedule(message = "Hello from second_instance.") - composite_instance = new Inside(message = "Hello from composite_instance.") + first_instance = new Reschedule(period = 4 sec, message = "Hello from first_instance.") + second_instance = new Reschedule(message = "Hello from second_instance.") + composite_instance = new Inside(message = "Hello from composite_instance.") } diff --git a/test/C/src/HelloWorld.lf b/test/C/src/HelloWorld.lf index 7de913c8ad..07b49b0afd 100644 --- a/test/C/src/HelloWorld.lf +++ b/test/C/src/HelloWorld.lf @@ -1,28 +1,28 @@ target C { - tracing: { // To test generating a custom trace file name. - trace-file-name: "HelloWorldTrace" - }, - logging: error, - build-type: Debug + tracing: { // To test generating a custom trace file name. + trace-file-name: "HelloWorldTrace" + }, + logging: error, + build-type: Debug } reactor HelloWorld2 { - state success: bool = false + state success: bool = false - reaction(startup) {= - printf("Hello World.\n"); - self->success = true; - =} + reaction(startup) {= + printf("Hello World.\n"); + self->success = true; + =} - reaction(shutdown) {= - printf("Shutdown invoked.\n"); - if (!self->success) { - fprintf(stderr, "ERROR: startup reaction not executed.\n"); - exit(1); - } - =} + reaction(shutdown) {= + printf("Shutdown invoked.\n"); + if (!self->success) { + fprintf(stderr, "ERROR: startup reaction not executed.\n"); + exit(1); + } + =} } main reactor HelloWorld { - a = new HelloWorld2() + a = new HelloWorld2() } diff --git a/test/C/src/Hierarchy2.lf b/test/C/src/Hierarchy2.lf index 0a4f20d4bc..daa7b832f8 100644 --- a/test/C/src/Hierarchy2.lf +++ b/test/C/src/Hierarchy2.lf @@ -1,68 +1,68 @@ // Test data transport across hierarchy. target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Source { - output out: int - timer t(0, 1 sec) + output out: int + timer t(0, 1 sec) - reaction(t) -> out {= lf_set(out, 1); =} + reaction(t) -> out {= lf_set(out, 1); =} } reactor Count { - output out: int - timer t(0, 1 sec) - state i: int = 0 + output out: int + timer t(0, 1 sec) + state i: int = 0 - reaction(t) -> out {= - (self->i)++; - lf_set(out, self->i); - =} + reaction(t) -> out {= + (self->i)++; + lf_set(out, self->i); + =} } reactor Add { - input in1: int - input in2: int - output out: int + input in1: int + input in2: int + output out: int - reaction(in1, in2) -> out {= - int result = 0; - if (in1->is_present) result += in1->value; - if (in2->is_present) result += in2->value; - lf_set(out, result); - =} + reaction(in1, in2) -> out {= + int result = 0; + if (in1->is_present) result += in1->value; + if (in2->is_present) result += in2->value; + lf_set(out, result); + =} } reactor Print { - input in: int - state expected: int = 2 + input in: int + state expected: int = 2 - reaction(in) {= - printf("Received: %d.\n", in->value); - if (in->value != self->expected) { - printf("Expected %d.\n", self->expected); - exit(1); - } - self->expected++; - =} + reaction(in) {= + printf("Received: %d.\n", in->value); + if (in->value != self->expected) { + printf("Expected %d.\n", self->expected); + exit(1); + } + self->expected++; + =} } reactor AddCount { - input in: int - output out: int - count = new Count() - add = new Add() - in -> add.in1 - count.out -> add.in2 - add.out -> out + input in: int + output out: int + count = new Count() + add = new Add() + in -> add.in1 + count.out -> add.in2 + add.out -> out } main reactor Hierarchy2 { - source = new Source() - addCount = new AddCount() - print = new Print() - source.out -> addCount.in - addCount.out -> print.in + source = new Source() + addCount = new AddCount() + print = new Print() + source.out -> addCount.in + addCount.out -> print.in } diff --git a/test/C/src/IdentifierLength.lf b/test/C/src/IdentifierLength.lf index 8fa38b96f0..6e4b34e976 100644 --- a/test/C/src/IdentifierLength.lf +++ b/test/C/src/IdentifierLength.lf @@ -1,42 +1,36 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor A_Really_Long_Name_For_A_Source(period: time = 2 sec) { - output y: int - timer t(1 sec, period) - state count: int = 0 + output y: int + timer t(1 sec, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + lf_set(y, self->count); + =} } reactor Another_Really_Long_Name_For_A_Test_Class { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - (self->count)++; - printf("Received %d\n", x->value); - if (x->value != self->count) { - printf("FAILURE: Expected %d\n", self->count); - exit(1); - } - =} + reaction(x) {= + (self->count)++; + printf("Received %d\n", x->value); + if (x->value != self->count) { + printf("FAILURE: Expected %d\n", self->count); + exit(1); + } + =} } main reactor IdentifierLength { - a_really_long_name_for_a_source_instance = new A_Really_Long_Name_For_A_Source( - - ) - another_really_long_name_for_a_test_instance = new Another_Really_Long_Name_For_A_Test_Class( - - ) - a_really_long_name_for_a_source_instance.y - -> another_really_long_name_for_a_test_instance.x + a_really_long_name_for_a_source_instance = new A_Really_Long_Name_For_A_Source() + another_really_long_name_for_a_test_instance = new Another_Really_Long_Name_For_A_Test_Class() + a_really_long_name_for_a_source_instance.y -> another_really_long_name_for_a_test_instance.x } diff --git a/test/C/src/ImportComposition.lf b/test/C/src/ImportComposition.lf index 22a1bfef87..c80bf87eab 100644 --- a/test/C/src/ImportComposition.lf +++ b/test/C/src/ImportComposition.lf @@ -1,33 +1,32 @@ -// This tests the ability to import a reactor definition that itself imports a -// reactor definition. +// This tests the ability to import a reactor definition that itself imports a reactor definition. target C import ImportedComposition from "lib/ImportedComposition.lf" main reactor ImportComposition { - a = new ImportedComposition() - state received: bool = false + a = new ImportedComposition() + state received: bool = false - reaction(startup) -> a.x {= lf_set(a.x, 42); =} + reaction(startup) -> a.x {= lf_set(a.x, 42); =} - reaction(a.y) {= - interval_t receive_time = lf_time_logical_elapsed(); - printf("Received %d at time %lld\n", a.y->value, receive_time); - self->received = true; - if (receive_time != 55000000LL) { - fprintf(stderr, "ERROR: Received time should have been 55,000,000.\n"); - exit(1); - } - if (a.y->value != 42 * 2 * 2) { - fprintf(stderr, "ERROR: Received value should have been %d.\n", 42 * 2 * 2); - exit(2); - } - =} + reaction(a.y) {= + interval_t receive_time = lf_time_logical_elapsed(); + printf("Received %d at time %lld\n", a.y->value, receive_time); + self->received = true; + if (receive_time != 55000000LL) { + fprintf(stderr, "ERROR: Received time should have been 55,000,000.\n"); + exit(1); + } + if (a.y->value != 42 * 2 * 2) { + fprintf(stderr, "ERROR: Received value should have been %d.\n", 42 * 2 * 2); + exit(2); + } + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Nothing received.\n"); - exit(3); - } - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Nothing received.\n"); + exit(3); + } + =} } diff --git a/test/C/src/InheritanceAction.lf b/test/C/src/InheritanceAction.lf index 680ffe2f75..f6a87ef360 100644 --- a/test/C/src/InheritanceAction.lf +++ b/test/C/src/InheritanceAction.lf @@ -1,42 +1,41 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { - fast: true + fast: true } reactor Source { - logical action foo: int - output y: int + logical action foo: int + output y: int - reaction(foo) -> y {= lf_set(y, foo->value); =} + reaction(foo) -> y {= lf_set(y, foo->value); =} } reactor SourceExtended extends Source { - reaction(startup) -> foo {= lf_schedule_int(foo, 0, 42); =} + reaction(startup) -> foo {= lf_schedule_int(foo, 0, 42); =} } reactor Test { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - (self->count)++; - printf("Received %d\n", x->value); - if (x->value != 42) { - fprintf(stderr, "FAILURE: Expected 42\n"); - exit(1); - } - =} + reaction(x) {= + (self->count)++; + printf("Received %d\n", x->value); + if (x->value != 42) { + fprintf(stderr, "FAILURE: Expected 42\n"); + exit(1); + } + =} - reaction(shutdown) {= - if (self->count == 0) { - fprintf(stderr, "FAILURE: No data received.\n"); - } - =} + reaction(shutdown) {= + if (self->count == 0) { + fprintf(stderr, "FAILURE: No data received.\n"); + } + =} } main reactor { - s = new SourceExtended() - d = new Test() - s.y -> d.x + s = new SourceExtended() + d = new Test() + s.y -> d.x } diff --git a/test/C/src/ManualDelayedReaction.lf b/test/C/src/ManualDelayedReaction.lf index 72c57105ce..61e2519fc3 100644 --- a/test/C/src/ManualDelayedReaction.lf +++ b/test/C/src/ManualDelayedReaction.lf @@ -1,54 +1,52 @@ target C { - // Set keepalive to false since this is a test and schedule is called on a - // physical action from within a reaction. This is one of the special rare - // cases where the user might want to manually override keepalive. - keepalive: false + // Set keepalive to false since this is a test and schedule is called on a physical action from + // within a reaction. This is one of the special rare cases where the user might want to manually + // override keepalive. + keepalive: false } -// That's the stuff that shall be generated for the after -reactor GeneratedDelay { - input y_in: int - output y_out: int - state y_state: int = 0 +reactor GeneratedDelay { // That's the stuff that shall be generated for the after + input y_in: int + output y_out: int + state y_state: int = 0 - physical action act(0 msec) // TODO: delay in act or the schedule call? + physical action act(0 msec) // TODO: delay in act or the schedule call? - reaction(y_in) -> act {= - self->y_state = y_in->value; - lf_schedule(act, MSEC(100)); - =} + reaction(y_in) -> act {= + self->y_state = y_in->value; + lf_schedule(act, MSEC(100)); + =} - reaction(act) -> y_out {= lf_set(y_out, self->y_state); =} + reaction(act) -> y_out {= lf_set(y_out, self->y_state); =} } reactor Source { - output out: int - timer t + output out: int + timer t - // reaction(t) -> out after 100 msec - reaction(t) -> out {= lf_set(out, 1); =} + reaction(t) -> out {= lf_set(out, 1); =} // reaction(t) -> out after 100 msec } reactor Sink { - input in: int - - reaction(in) {= - interval_t elapsed_logical = lf_time_logical_elapsed(); - interval_t logical = lf_time_logical(); - interval_t physical = lf_time_physical(); - printf("Nanoseconds since start: %lld %lld %lld.\n", logical, physical, elapsed_logical); - if (elapsed_logical < MSEC(100)) { - printf("Expected %lld but got %lld.\n", MSEC(100), elapsed_logical); - exit(1); - } - =} deadline(200 msec) {= =} + input in: int + + reaction(in) {= + interval_t elapsed_logical = lf_time_logical_elapsed(); + interval_t logical = lf_time_logical(); + interval_t physical = lf_time_physical(); + printf("Nanoseconds since start: %lld %lld %lld.\n", logical, physical, elapsed_logical); + if (elapsed_logical < MSEC(100)) { + printf("Expected %lld but got %lld.\n", MSEC(100), elapsed_logical); + exit(1); + } + =} deadline(200 msec) {= =} } main reactor ManualDelayedReaction { - source = new Source() - sink = new Sink() - g = new GeneratedDelay() + source = new Source() + sink = new Sink() + g = new GeneratedDelay() - source.out -> g.y_in // source.out -> sink.in; rewritten above - g.y_out -> sink.in + source.out -> g.y_in // source.out -> sink.in; rewritten above + g.y_out -> sink.in } diff --git a/test/C/src/Methods.lf b/test/C/src/Methods.lf index edbdd2f7f6..45bb9fa4ba 100644 --- a/test/C/src/Methods.lf +++ b/test/C/src/Methods.lf @@ -1,23 +1,23 @@ target C main reactor { - state foo: int = 2 + state foo: int = 2 - method getFoo(): int {= return self->foo; =} + method getFoo(): int {= return self->foo; =} - method add(x: int) {= self->foo += x; =} + method add(x: int) {= self->foo += x; =} - reaction(startup) {= - lf_print("Foo is initialized to %d", getFoo()); - if (getFoo() != 2) { - lf_print_error_and_exit("Expected 2!"); - } + reaction(startup) {= + lf_print("Foo is initialized to %d", getFoo()); + if (getFoo() != 2) { + lf_print_error_and_exit("Expected 2!"); + } - add(40); - int a = getFoo(); - lf_print("2 + 40 = %d", a); - if (a != 42) { - lf_print_error_and_exit("Expected 42!"); - } - =} + add(40); + int a = getFoo(); + lf_print("2 + 40 = %d", a); + if (a != 42) { + lf_print_error_and_exit("Expected 42!"); + } + =} } diff --git a/test/C/src/MethodsRecursive.lf b/test/C/src/MethodsRecursive.lf index 5465e0c92c..3f2ec1fd00 100644 --- a/test/C/src/MethodsRecursive.lf +++ b/test/C/src/MethodsRecursive.lf @@ -2,18 +2,18 @@ target C main reactor { - state foo: int = 2 + state foo: int = 2 - method fib(n: int): int {= // Return the n-th Fibonacci number. - if (n <= 1) return 1; - return add(fib(n-1), fib(n-2)); - =} + method fib(n: int): int {= // Return the n-th Fibonacci number. + if (n <= 1) return 1; + return add(fib(n-1), fib(n-2)); + =} - method add(x: int, y: int): int {= return x + y; =} + method add(x: int, y: int): int {= return x + y; =} - reaction(startup) {= - for (int n = 1; n < 10; n++) { - lf_print("%d-th Fibonacci number is %d", n, fib(n)); - } - =} + reaction(startup) {= + for (int n = 1; n < 10; n++) { + lf_print("%d-th Fibonacci number is %d", n, fib(n)); + } + =} } diff --git a/test/C/src/MethodsSameName.lf b/test/C/src/MethodsSameName.lf index b274d153c8..349f62fc55 100644 --- a/test/C/src/MethodsSameName.lf +++ b/test/C/src/MethodsSameName.lf @@ -2,31 +2,31 @@ target C reactor Foo { - state foo: int = 2 + state foo: int = 2 - method add(x: int) {= self->foo += x; =} + method add(x: int) {= self->foo += x; =} - reaction(startup) {= - add(40); - lf_print("Foo: 2 + 40 = %d", self->foo); - if (self->foo != 42) { - lf_print_error_and_exit("Expected 42!"); - } - =} + reaction(startup) {= + add(40); + lf_print("Foo: 2 + 40 = %d", self->foo); + if (self->foo != 42) { + lf_print_error_and_exit("Expected 42!"); + } + =} } main reactor { - state foo: int = 2 + state foo: int = 2 - a = new Foo() + a = new Foo() - method add(x: int) {= self->foo += x; =} + method add(x: int) {= self->foo += x; =} - reaction(startup) {= - add(40); - lf_print("Main: 2 + 40 = %d", self->foo); - if (self->foo != 42) { - lf_print_error_and_exit("Expected 42!"); - } - =} + reaction(startup) {= + add(40); + lf_print("Main: 2 + 40 = %d", self->foo); + if (self->foo != 42) { + lf_print_error_and_exit("Expected 42!"); + } + =} } diff --git a/test/C/src/MovingAverage.lf b/test/C/src/MovingAverage.lf index a8309aa9d3..53e761f61b 100644 --- a/test/C/src/MovingAverage.lf +++ b/test/C/src/MovingAverage.lf @@ -1,53 +1,52 @@ -// Demonstration of a state variable that is an array. The MovingAverage reactor -// computes the moving average of the last four inputs and produces that as -// output. The source is a counting sequence. +// Demonstration of a state variable that is an array. The MovingAverage reactor computes the moving +// average of the last four inputs and produces that as output. The source is a counting sequence. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } import TestDouble from "lib/Test.lf" reactor MASource { - output out: double - state count: int = 0 - timer clock(0, 200 msec) - - reaction(clock) -> out {= - lf_set(out, self->count); - self->count++; - =} + output out: double + state count: int = 0 + timer clock(0, 200 msec) + + reaction(clock) -> out {= + lf_set(out, self->count); + self->count++; + =} } reactor MovingAverageImpl { - state delay_line: double[] = {0.0, 0.0, 0.0} - state index: int = 0 - input in: double - output out: double - - reaction(in) -> out {= - // Calculate the output. - double sum = in->value; - for (int i = 0; i < 3; i++) { - sum += self->delay_line[i]; - } - lf_set(out, sum/4.0); - - // Insert the input in the delay line. - self->delay_line[self->index] = in->value; - - // Update the index for the next input. - self->index++; - if (self->index >= 3) { - self->index = 0; - } - =} + state delay_line: double[] = {0.0, 0.0, 0.0} + state index: int = 0 + input in: double + output out: double + + reaction(in) -> out {= + // Calculate the output. + double sum = in->value; + for (int i = 0; i < 3; i++) { + sum += self->delay_line[i]; + } + lf_set(out, sum/4.0); + + // Insert the input in the delay line. + self->delay_line[self->index] = in->value; + + // Update the index for the next input. + self->index++; + if (self->index >= 3) { + self->index = 0; + } + =} } main reactor MovingAverage { - s = new MASource() - m = new MovingAverageImpl() - p = new TestDouble(expected = {0.0, 0.25, 0.75, 1.5, 2.5, 3.5}) - s.out -> m.in - m.out -> p.in + s = new MASource() + m = new MovingAverageImpl() + p = new TestDouble(expected = {0.0, 0.25, 0.75, 1.5, 2.5, 3.5}) + s.out -> m.in + m.out -> p.in } diff --git a/test/C/src/MultipleContained.lf b/test/C/src/MultipleContained.lf index 540052ba87..384543e56f 100644 --- a/test/C/src/MultipleContained.lf +++ b/test/C/src/MultipleContained.lf @@ -1,45 +1,44 @@ -// Test that a reaction can react to and send two multiple ports of a contained -// reactor. +// Test that a reaction can react to and send two multiple ports of a contained reactor. target C reactor Contained { - output trigger: int - input in1: int - input in2: int - state count: int = 0 + output trigger: int + input in1: int + input in2: int + state count: int = 0 - reaction(startup) -> trigger {= lf_set(trigger, 42); =} + reaction(startup) -> trigger {= lf_set(trigger, 42); =} - reaction(in1) {= - printf("in1 received %d.\n", in1->value); - if (in1->value != 42) { - fprintf(stderr, "FAILED: Expected 42.\n"); - exit(1); - } - self->count++; - =} + reaction(in1) {= + printf("in1 received %d.\n", in1->value); + if (in1->value != 42) { + fprintf(stderr, "FAILED: Expected 42.\n"); + exit(1); + } + self->count++; + =} - reaction(in2) {= - printf("in2 received %d.\n", in2->value); - if (in2->value != 42) { - fprintf(stderr, "FAILED: Expected 42.\n"); - exit(1); - } - self->count++; - =} + reaction(in2) {= + printf("in2 received %d.\n", in2->value); + if (in2->value != 42) { + fprintf(stderr, "FAILED: Expected 42.\n"); + exit(1); + } + self->count++; + =} - reaction(shutdown) {= - if (self->count != 2) { - lf_print_error_and_exit("FAILED: Expected two inputs!"); - } - =} + reaction(shutdown) {= + if (self->count != 2) { + lf_print_error_and_exit("FAILED: Expected two inputs!"); + } + =} } main reactor MultipleContained { - c = new Contained() + c = new Contained() - reaction(c.trigger) -> c.in1, c.in2 {= - lf_set(c.in1, c.trigger->value); - lf_set(c.in2, c.trigger->value); - =} + reaction(c.trigger) -> c.in1, c.in2 {= + lf_set(c.in1, c.trigger->value); + lf_set(c.in2, c.trigger->value); + =} } diff --git a/test/C/src/MultipleOutputs.lf b/test/C/src/MultipleOutputs.lf index 37b5ddba9f..4682ce8eef 100644 --- a/test/C/src/MultipleOutputs.lf +++ b/test/C/src/MultipleOutputs.lf @@ -1,35 +1,34 @@ -// This test checks for one of the issues arised in the solution of EECS149 Lab -// Chapter 7. In this case, a reactor has two output ports, the first one of -// which is dangling. The generated code should not have any segmentation -// faults. +// This test checks for one of the issues arised in the solution of EECS149 Lab Chapter 7. In this +// case, a reactor has two output ports, the first one of which is dangling. The generated code +// should not have any segmentation faults. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor C { - output x: int - output z: int - timer t(0, 100 msec) + output x: int + output z: int + timer t(0, 100 msec) - reaction(t) -> x, z {= - lf_set(x, 42); - lf_set(z, 44); - =} + reaction(t) -> x, z {= + lf_set(x, 42); + lf_set(z, 44); + =} } main reactor { - c = new C() - state triggered: bool = true + c = new C() + state triggered: bool = true - reaction(c.z) {= - lf_print("c.z = %d", c.z->value); - self->triggered = true; - =} + reaction(c.z) {= + lf_print("c.z = %d", c.z->value); + self->triggered = true; + =} - reaction(shutdown) {= - if (!self->triggered) { - lf_print_error_and_exit("Reaction never triggered.\n"); - } - =} + reaction(shutdown) {= + if (!self->triggered) { + lf_print_error_and_exit("Reaction never triggered.\n"); + } + =} } diff --git a/test/C/src/NativeListsAndTimes.lf b/test/C/src/NativeListsAndTimes.lf index a1d09beb6c..fa82f181a1 100644 --- a/test/C/src/NativeListsAndTimes.lf +++ b/test/C/src/NativeListsAndTimes.lf @@ -1,27 +1,26 @@ target C -// This test passes if it is successfully compiled into valid target code. -main reactor( - x: int = 0, - y: time = 0, // Units are missing but not required - z = 1 msec, // Type is missing but not required - p: int[] = {1, 2, 3, 4}, // List of integers - q: interval_t[] = {1 msec, 2 msec, 3 msec}, // list of time values - g: time[] = {1 msec, 2 msec} // List of time values +main reactor( // This test passes if it is successfully compiled into valid target code. + x: int = 0, + y: time = 0, // Units are missing but not required + z = 1 msec, // Type is missing but not required + p: int[] = {1, 2, 3, 4}, // List of integers + q: interval_t[] = {1 msec, 2 msec, 3 msec}, // list of time values + g: time[] = {1 msec, 2 msec} // List of time values ) { - state s: time = y // Reference to explicitly typed time parameter - state t: time = z // Reference to implicitly typed time parameter - state v: bool // Uninitialized boolean state variable - state w: time // Uninitialized time state variable - timer tick(0) // Units missing but not required - timer tock(1 sec) // Implicit type time - timer toe(z) // Implicit type time - state baz = p // Implicit type int[] - state period = z // Implicit type time + state s: time = y // Reference to explicitly typed time parameter + state t: time = z // Reference to implicitly typed time parameter + state v: bool // Uninitialized boolean state variable + state w: time // Uninitialized time state variable + timer tick(0) // Units missing but not required + timer tock(1 sec) // Implicit type time + timer toe(z) // Implicit type time + state baz = p // Implicit type int[] + state period = z // Implicit type time - state empty_list: int[] + state empty_list: int[] - reaction(tick) {= - // Target code - =} + reaction(tick) {= + // Target code + =} } diff --git a/test/C/src/NestedTriggeredReactions.lf b/test/C/src/NestedTriggeredReactions.lf index df52d36a14..730bc1db08 100644 --- a/test/C/src/NestedTriggeredReactions.lf +++ b/test/C/src/NestedTriggeredReactions.lf @@ -1,39 +1,39 @@ target C reactor Container { - input in: bool + input in: bool - state triggered: bool = false + state triggered: bool = false - contained = new Contained() + contained = new Contained() - in -> contained.in + in -> contained.in - reaction(in) {= self->triggered = true; =} + reaction(in) {= self->triggered = true; =} - reaction(shutdown) {= - if (!self->triggered) { - lf_print_error_and_exit("The Container reaction was not triggered!"); - } - =} + reaction(shutdown) {= + if (!self->triggered) { + lf_print_error_and_exit("The Container reaction was not triggered!"); + } + =} } reactor Contained { - input in: bool + input in: bool - state triggered: bool = false + state triggered: bool = false - reaction(in) {= self->triggered = true; =} + reaction(in) {= self->triggered = true; =} - reaction(shutdown) {= - if (!self->triggered) { - lf_print_error_and_exit("The Contained reaction was not triggered!"); - } - =} + reaction(shutdown) {= + if (!self->triggered) { + lf_print_error_and_exit("The Contained reaction was not triggered!"); + } + =} } main reactor { - container = new Container() + container = new Container() - reaction(startup) -> container.in {= lf_set(container.in, true); =} + reaction(startup) -> container.in {= lf_set(container.in, true); =} } diff --git a/test/C/src/ParameterHierarchy.lf b/test/C/src/ParameterHierarchy.lf index 825f9f5a60..ef71b43eeb 100644 --- a/test/C/src/ParameterHierarchy.lf +++ b/test/C/src/ParameterHierarchy.lf @@ -2,23 +2,23 @@ target C reactor Deep(p0: int = 0) { - reaction(startup) {= - if (self->p0 != 42) { - lf_print_error_and_exit("Parameter value is %d. Should have been 42.", self->p0); - } else { - lf_print("Success."); - } - =} + reaction(startup) {= + if (self->p0 != 42) { + lf_print_error_and_exit("Parameter value is %d. Should have been 42.", self->p0); + } else { + lf_print("Success."); + } + =} } reactor Intermediate(p1: int = 10) { - a0 = new Deep(p0 = p1) + a0 = new Deep(p0 = p1) } reactor Another(p2: int = 20) { - a1 = new Intermediate(p1 = p2) + a1 = new Intermediate(p1 = p2) } main reactor ParameterHierarchy { - a2 = new Another(p2 = 42) + a2 = new Another(p2 = 42) } diff --git a/test/C/src/ParameterizedState.lf b/test/C/src/ParameterizedState.lf index 3d92345ca9..5b601a740b 100644 --- a/test/C/src/ParameterizedState.lf +++ b/test/C/src/ParameterizedState.lf @@ -1,11 +1,11 @@ target C reactor Foo(bar: int = 42) { - state baz = bar + state baz = bar - reaction(startup) {= printf("Baz: %d\n", self->baz); =} + reaction(startup) {= printf("Baz: %d\n", self->baz); =} } main reactor { - a = new Foo() + a = new Foo() } diff --git a/test/C/src/PeriodicDesugared.lf b/test/C/src/PeriodicDesugared.lf index 46eb97db9c..c31b81e534 100644 --- a/test/C/src/PeriodicDesugared.lf +++ b/test/C/src/PeriodicDesugared.lf @@ -1,23 +1,23 @@ target C { - fast: true, - timeout: 1 sec + fast: true, + timeout: 1 sec } main reactor(offset: time = 0, period: time = 500 msec) { - logical action init(offset) - logical action recur(period) + logical action init(offset) + logical action recur(period) - reaction(startup) -> init, recur {= - if (self->offset == 0) { - printf("Hello World!\n"); - lf_schedule(recur, 0); - } else { - lf_schedule(init, 0); - } - =} - - reaction(init, recur) -> recur {= + reaction(startup) -> init, recur {= + if (self->offset == 0) { printf("Hello World!\n"); lf_schedule(recur, 0); - =} + } else { + lf_schedule(init, 0); + } + =} + + reaction(init, recur) -> recur {= + printf("Hello World!\n"); + lf_schedule(recur, 0); + =} } diff --git a/test/C/src/PhysicalConnection.lf b/test/C/src/PhysicalConnection.lf index 2cac10c240..3276b1e11c 100644 --- a/test/C/src/PhysicalConnection.lf +++ b/test/C/src/PhysicalConnection.lf @@ -2,26 +2,26 @@ target C reactor Source { - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, 42); =} + reaction(startup) -> out {= lf_set(out, 42); =} } reactor Destination { - input in: int + input in: int - reaction(in) {= - interval_t time = lf_time_logical_elapsed(); - printf("Received %d at logical time %lld.\n", in->value, time); - if (time <= 0LL) { - fprintf(stderr, "ERROR: Logical time should have been greater than zero.\n"); - exit(1); - } - =} + reaction(in) {= + interval_t time = lf_time_logical_elapsed(); + printf("Received %d at logical time %lld.\n", in->value, time); + if (time <= 0LL) { + fprintf(stderr, "ERROR: Logical time should have been greater than zero.\n"); + exit(1); + } + =} } main reactor PhysicalConnection { - source = new Source() - destination = new Destination() - source.out ~> destination.in + source = new Source() + destination = new Destination() + source.out ~> destination.in } diff --git a/test/C/src/PingPong.lf b/test/C/src/PingPong.lf index 2f1699a51d..c3e0a69357 100644 --- a/test/C/src/PingPong.lf +++ b/test/C/src/PingPong.lf @@ -1,71 +1,68 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the - * causality loop. + * Ping introduces a microstep delay using a logical action to break the causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * - Unthreaded: 97 msec * - Threaded: 265 msec * - * There is no parallelism in this application, so it does not benefit from - * being being threaded, just some additional overhead. + * There is no parallelism in this application, so it does not benefit from being being threaded, + * just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. - * These are about an order of magnitude faster than anything reported in the - * paper. + * These measurements are total execution time, including startup and shutdown. These are about an + * order of magnitude faster than anything reported in the paper. * * @author Edward A. Lee */ target C { - fast: true + fast: true } reactor Ping(count: int = 10) { - input receive: int - output send: int - state pingsLeft: int = count - logical action serve + input receive: int + output send: int + state pingsLeft: int = count + logical action serve - reaction(startup, serve) -> send {= lf_set(send, self->pingsLeft--); =} + reaction(startup, serve) -> send {= lf_set(send, self->pingsLeft--); =} - reaction(receive) -> serve {= - if (self->pingsLeft > 0) { - lf_schedule(serve, 0); - } else { - lf_request_stop(); - } - =} + reaction(receive) -> serve {= + if (self->pingsLeft > 0) { + lf_schedule(serve, 0); + } else { + lf_request_stop(); + } + =} } reactor Pong(expected: int = 10) { - input receive: int - output send: int - state count: int = 0 + input receive: int + output send: int + state count: int = 0 - reaction(receive) -> send {= - self->count++; - lf_set(send, receive->value); - =} + reaction(receive) -> send {= + self->count++; + lf_set(send, receive->value); + =} - reaction(shutdown) {= - if (self->count != self->expected) { - fprintf(stderr, "ERROR: Pong expected to receive %d inputs, but it received %d.\n", - self->expected, self->count - ); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->count != self->expected) { + fprintf(stderr, "ERROR: Pong expected to receive %d inputs, but it received %d.\n", + self->expected, self->count + ); + exit(1); + } + printf("Success.\n"); + =} } main reactor PingPong { - ping = new Ping() - pong = new Pong() - ping.send -> pong.receive - pong.send -> ping.receive + ping = new Ping() + pong = new Pong() + ping.send -> pong.receive + pong.send -> ping.receive } diff --git a/test/C/src/PreambleFileLevel.lf b/test/C/src/PreambleFileLevel.lf index ed2def967a..e9ea7b33b9 100644 --- a/test/C/src/PreambleFileLevel.lf +++ b/test/C/src/PreambleFileLevel.lf @@ -1,7 +1,4 @@ -/** - * Test for ensuring that file-level preambles are inherited when a file is - * imported. - */ +/** Test for ensuring that file-level preambles are inherited when a file is imported. */ target C import FileLevelPreamble from "lib/FileLevelPreamble.lf" @@ -10,5 +7,5 @@ reactor B extends FileLevelPreamble { } main reactor { - b = new B() + b = new B() } diff --git a/test/C/src/PreambleInherited.lf b/test/C/src/PreambleInherited.lf index c7db161962..83f4a59d44 100644 --- a/test/C/src/PreambleInherited.lf +++ b/test/C/src/PreambleInherited.lf @@ -2,16 +2,16 @@ target C reactor A { - preamble {= - #define FOO 2 - =} + preamble {= + #define FOO 2 + =} - reaction(startup) {= printf("FOO: %d\n", FOO); =} + reaction(startup) {= printf("FOO: %d\n", FOO); =} } reactor B extends A { } main reactor { - b = new B() + b = new B() } diff --git a/test/C/src/ReadOutputOfContainedReactor.lf b/test/C/src/ReadOutputOfContainedReactor.lf index ce2129069b..eb8dba11bf 100644 --- a/test/C/src/ReadOutputOfContainedReactor.lf +++ b/test/C/src/ReadOutputOfContainedReactor.lf @@ -1,50 +1,49 @@ -// Test reacting to and reading outputs from a contained reactor in various -// permutations. +// Test reacting to and reading outputs from a contained reactor in various permutations. target C reactor Contained { - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, 42); =} + reaction(startup) -> out {= lf_set(out, 42); =} } main reactor ReadOutputOfContainedReactor { - c = new Contained() - state count: int = 0 + c = new Contained() + state count: int = 0 - reaction(startup) c.out {= - printf("Startup reaction reading output of contained reactor: %d.\n", c.out->value); - if (c.out->value != 42) { - fprintf(stderr, "Expected 42!\n"); - exit(2); - } - self->count++; - =} + reaction(startup) c.out {= + printf("Startup reaction reading output of contained reactor: %d.\n", c.out->value); + if (c.out->value != 42) { + fprintf(stderr, "Expected 42!\n"); + exit(2); + } + self->count++; + =} - reaction(c.out) {= - printf("Reading output of contained reactor: %d.\n", c.out->value); - if (c.out->value != 42) { - fprintf(stderr, "Expected 42!\n"); - exit(3); - } - self->count++; - =} + reaction(c.out) {= + printf("Reading output of contained reactor: %d.\n", c.out->value); + if (c.out->value != 42) { + fprintf(stderr, "Expected 42!\n"); + exit(3); + } + self->count++; + =} - reaction(startup, c.out) {= - printf("Alternate triggering reading output of contained reactor: %d.\n", c.out->value); - if (c.out->value != 42) { - fprintf(stderr, "Expected 42!\n"); - exit(4); - } - self->count++; - =} + reaction(startup, c.out) {= + printf("Alternate triggering reading output of contained reactor: %d.\n", c.out->value); + if (c.out->value != 42) { + fprintf(stderr, "Expected 42!\n"); + exit(4); + } + self->count++; + =} - reaction(shutdown) {= - if (self->count != 3) { - printf("FAILURE: One of the reactions failed to trigger.\n"); - exit(1); - } else { - printf("Test passes.\n"); - } - =} + reaction(shutdown) {= + if (self->count != 3) { + printf("FAILURE: One of the reactions failed to trigger.\n"); + exit(1); + } else { + printf("Test passes.\n"); + } + =} } diff --git a/test/C/src/RequestStop.lf b/test/C/src/RequestStop.lf index 83c59d1d27..07e6806f72 100644 --- a/test/C/src/RequestStop.lf +++ b/test/C/src/RequestStop.lf @@ -1,13 +1,12 @@ -// Test verifying that lf_request_stop() called in a shutdown reaction is -// ignored. +// Test verifying that lf_request_stop() called in a shutdown reaction is ignored. target C main reactor { - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - lf_print("Shutdown invoked at tag (%lld, %d). Calling lf_request_stop(), which should have no effect.", - current_tag.time - lf_time_start(), current_tag.microstep - ); - lf_request_stop(); - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + lf_print("Shutdown invoked at tag (%lld, %d). Calling lf_request_stop(), which should have no effect.", + current_tag.time - lf_time_start(), current_tag.microstep + ); + lf_request_stop(); + =} } diff --git a/test/C/src/ScheduleLogicalAction.lf b/test/C/src/ScheduleLogicalAction.lf index 762f8c6f52..4a301977a3 100644 --- a/test/C/src/ScheduleLogicalAction.lf +++ b/test/C/src/ScheduleLogicalAction.lf @@ -1,46 +1,46 @@ -// This checks that a logical action is scheduled the specified logical time -// after the current logical time. +// This checks that a logical action is scheduled the specified logical time after the current +// logical time. target C { - fast: true, - timeout: 3 sec + fast: true, + timeout: 3 sec } reactor foo { - input x: int - output y: int - logical action a: int* + input x: int + output y: int + logical action a: int* - reaction(x) -> y, a {= - lf_set(y, 2*x->value); - // The following uses physical time, incorrectly. - lf_schedule(a, MSEC(500)); - =} + reaction(x) -> y, a {= + lf_set(y, 2*x->value); + // The following uses physical time, incorrectly. + lf_schedule(a, MSEC(500)); + =} - reaction(a) -> y {= lf_set(y, -42); =} + reaction(a) -> y {= lf_set(y, -42); =} } reactor print { - state expected_time: time = 0 - input x: int + state expected_time: time = 0 + input x: int - reaction(x) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("Result is %d\n", x->value); - printf("Current logical time is: %lld\n", elapsed_time); - printf("Current physical time is: %lld\n", lf_time_physical_elapsed()); - if (elapsed_time != self->expected_time) { - printf("ERROR: Expected logical time to be %lld.\n", self->expected_time); - exit(1); - } - self->expected_time += MSEC(500); - =} + reaction(x) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("Result is %d\n", x->value); + printf("Current logical time is: %lld\n", elapsed_time); + printf("Current physical time is: %lld\n", lf_time_physical_elapsed()); + if (elapsed_time != self->expected_time) { + printf("ERROR: Expected logical time to be %lld.\n", self->expected_time); + exit(1); + } + self->expected_time += MSEC(500); + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x - reaction(t) -> f.x {= lf_set(f.x, 42); =} + reaction(t) -> f.x {= lf_set(f.x, 42); =} } diff --git a/test/C/src/ScheduleValue.lf b/test/C/src/ScheduleValue.lf index 2ef4333db8..05532c145f 100644 --- a/test/C/src/ScheduleValue.lf +++ b/test/C/src/ScheduleValue.lf @@ -4,14 +4,14 @@ target C { } preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include - #include - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include + #include + #ifdef __cplusplus + } + #endif =} main reactor ScheduleValue { diff --git a/test/C/src/SelfLoop.lf b/test/C/src/SelfLoop.lf index 855be46792..cf200024ce 100644 --- a/test/C/src/SelfLoop.lf +++ b/test/C/src/SelfLoop.lf @@ -1,40 +1,40 @@ target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Self { - input x: int - output y: int - logical action a: int - state expected: int = 43 + input x: int + output y: int + logical action a: int + state expected: int = 43 - reaction(a) -> y {= - printf("a = %d\n", a->value); - lf_set(y, a->value + 1); - =} + reaction(a) -> y {= + printf("a = %d\n", a->value); + lf_set(y, a->value + 1); + =} - reaction(x) -> a {= - printf("x = %d\n", x->value); - if (x->value != self->expected) { - fprintf(stderr, "Expected %d.\n", self->expected); - exit(1); - } - self->expected++; - lf_schedule_int(a, MSEC(100), x->value); - =} + reaction(x) -> a {= + printf("x = %d\n", x->value); + if (x->value != self->expected) { + fprintf(stderr, "Expected %d.\n", self->expected); + exit(1); + } + self->expected++; + lf_schedule_int(a, MSEC(100), x->value); + =} - reaction(startup) -> a {= lf_schedule_int(a, 0, 42); =} + reaction(startup) -> a {= lf_schedule_int(a, 0, 42); =} - reaction(shutdown) {= - if (self->expected <= 43) { - fprintf(stderr, "Received no data.\n"); - exit(2); - } - =} + reaction(shutdown) {= + if (self->expected <= 43) { + fprintf(stderr, "Received no data.\n"); + exit(2); + } + =} } main reactor SelfLoop { - u = new Self() - u.y -> u.x + u = new Self() + u.y -> u.x } diff --git a/test/C/src/SendingInside.lf b/test/C/src/SendingInside.lf index b1e8f25f93..5371e8892a 100644 --- a/test/C/src/SendingInside.lf +++ b/test/C/src/SendingInside.lf @@ -1,31 +1,31 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target C { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Printer { - input x: int - state count: int = 1 + input x: int + state count: int = 1 - reaction(x) {= - printf("Inside reactor received: %d\n", x->value); - if (x->value != self->count) { - printf("FAILURE: Expected %d.\n", self->count); - exit(1); - } - self->count++; - =} + reaction(x) {= + printf("Inside reactor received: %d\n", x->value); + if (x->value != self->count) { + printf("FAILURE: Expected %d.\n", self->count); + exit(1); + } + self->count++; + =} } main reactor SendingInside { - state count: int = 0 - timer t(0, 1 sec) - p = new Printer() + state count: int = 0 + timer t(0, 1 sec) + p = new Printer() - reaction(t) -> p.x {= - (self->count)++; - lf_set(p.x, self->count); - =} + reaction(t) -> p.x {= + (self->count)++; + lf_set(p.x, self->count); + =} } diff --git a/test/C/src/SendsPointerTest.lf b/test/C/src/SendsPointerTest.lf index 1f17bd1388..0ec366cadb 100644 --- a/test/C/src/SendsPointerTest.lf +++ b/test/C/src/SendsPointerTest.lf @@ -1,32 +1,32 @@ -// Source produces a dynamically allocated struct, which it passes to Print. -// Reference counting ensures that the struct is freed. +// Source produces a dynamically allocated struct, which it passes to Print. Reference counting +// ensures that the struct is freed. target C preamble {= typedef int* int_pointer; =} reactor SendsPointer { - output out: int_pointer + output out: int_pointer - reaction(startup) -> out {= - static int my_constant = 42; - lf_set(out, &my_constant); - =} + reaction(startup) -> out {= + static int my_constant = 42; + lf_set(out, &my_constant); + =} } reactor Print(expected: int = 42) { // expected parameter is for testing. - input in: int_pointer + input in: int_pointer - reaction(in) {= - printf("Received: %d\n", *in->value); - if (*in->value != self->expected) { - printf("ERROR: Expected value to be %d.\n", self->expected); - exit(1); - } - =} + reaction(in) {= + printf("Received: %d\n", *in->value); + if (*in->value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } + =} } main reactor SendsPointerTest { - s = new SendsPointer() - p = new Print() - s.out -> p.in + s = new SendsPointer() + p = new Print() + s.out -> p.in } diff --git a/test/C/src/SetArray.lf b/test/C/src/SetArray.lf index f30457f9f8..72c2e938de 100644 --- a/test/C/src/SetArray.lf +++ b/test/C/src/SetArray.lf @@ -1,48 +1,48 @@ -// This tests SET_ARRAY() This tests the use of the "polymorphic" delay reactor -// on a struct. It delays by a logical time any pointer datatype. +// This tests SET_ARRAY() This tests the use of the "polymorphic" delay reactor on a struct. It +// delays by a logical time any pointer datatype. target C reactor Source { - output out: int[] + output out: int[] - reaction(startup) -> out {= - // Dynamically allocate an output array of length 3. - int* array = (int*)malloc(3 * sizeof(int)); - SET_ARRAY(out, array, sizeof(int), 3); + reaction(startup) -> out {= + // Dynamically allocate an output array of length 3. + int* array = (int*)malloc(3 * sizeof(int)); + SET_ARRAY(out, array, sizeof(int), 3); - // Above allocates the array, which then must be populated. - out->value[0] = 0; - out->value[1] = 1; - out->value[2] = 2; - =} + // Above allocates the array, which then must be populated. + out->value[0] = 0; + out->value[1] = 1; + out->value[2] = 2; + =} } reactor Print(scale: int = 1) { // The scale parameter is just for testing. - input in: int[] + input in: int[] - reaction(in) {= - int count = 0; // For testing. - bool failed = false; // For testing. - printf("Received: ["); - for (int i = 0; i < in->length; i++) { - if (i > 0) printf(", "); - printf("%d", in->value[i]); - // For testing, check whether values match expectation. - if (in->value[i] != self->scale * count) { - failed = true; - } - count++; // For testing. + reaction(in) {= + int count = 0; // For testing. + bool failed = false; // For testing. + printf("Received: ["); + for (int i = 0; i < in->length; i++) { + if (i > 0) printf(", "); + printf("%d", in->value[i]); + // For testing, check whether values match expectation. + if (in->value[i] != self->scale * count) { + failed = true; } - printf("]\n"); - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); - } - =} + count++; // For testing. + } + printf("]\n"); + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/C/src/SetToken.lf b/test/C/src/SetToken.lf index b9af4bff20..3ac1958b83 100644 --- a/test/C/src/SetToken.lf +++ b/test/C/src/SetToken.lf @@ -2,28 +2,28 @@ target C reactor Source { - output out: int* - logical action a: int + output out: int* + logical action a: int - reaction(startup) -> a {= lf_schedule_int(a, MSEC(200), 42); =} + reaction(startup) -> a {= lf_schedule_int(a, MSEC(200), 42); =} - reaction(a) -> out {= lf_set_token(out, a->token); =} + reaction(a) -> out {= lf_set_token(out, a->token); =} } reactor Print(expected: int = 42) { // expected parameter is for testing. - input in: int* + input in: int* - reaction(in) {= - printf("Received %d\n", *(in->value)); - if (*(in->value) != 42) { - printf("ERROR: Expected value to be 42.\n"); - exit(1); - } - =} + reaction(in) {= + printf("Received %d\n", *(in->value)); + if (*(in->value) != 42) { + printf("ERROR: Expected value to be 42.\n"); + exit(1); + } + =} } main reactor SetToken { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/C/src/SimpleDeadline.lf b/test/C/src/SimpleDeadline.lf index fba3e03cbc..6ae30cfb45 100644 --- a/test/C/src/SimpleDeadline.lf +++ b/test/C/src/SimpleDeadline.lf @@ -1,50 +1,49 @@ -// Test local deadline, where a deadline is associated with a reaction -// definition. This test triggers a reaction exactly once with a deadline -// violation. +// Test local deadline, where a deadline is associated with a reaction definition. This test +// triggers a reaction exactly once with a deadline violation. target C preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "platform.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif =} reactor Deadline(threshold: time = 100 msec) { - input x: int - output deadlineViolation: bool + input x: int + output deadlineViolation: bool - reaction(x) -> deadlineViolation {= - printf("ERROR: Deadline violation was not detected!\n"); - exit(1); - =} deadline(threshold) {= - printf("Deadline violation detected.\n"); - lf_set(deadlineViolation, true); - =} + reaction(x) -> deadlineViolation {= + printf("ERROR: Deadline violation was not detected!\n"); + exit(1); + =} deadline(threshold) {= + printf("Deadline violation detected.\n"); + lf_set(deadlineViolation, true); + =} } reactor Print { - input in: bool + input in: bool - reaction(in) {= - if (in) { - printf("Output successfully produced by deadline handler.\n"); - } - =} + reaction(in) {= + if (in) { + printf("Output successfully produced by deadline handler.\n"); + } + =} } main reactor SimpleDeadline { - timer start - d = new Deadline(threshold = 10 msec) - p = new Print() - d.deadlineViolation -> p.in + timer start + d = new Deadline(threshold = 10 msec) + p = new Print() + d.deadlineViolation -> p.in - reaction(start) -> d.x {= - instant_t sleep_time_ns = 20000000; - lf_sleep(sleep_time_ns); - lf_set(d.x, 42); - =} + reaction(start) -> d.x {= + instant_t sleep_time_ns = 20000000; + lf_sleep(sleep_time_ns); + lf_set(d.x, 42); + =} } diff --git a/test/C/src/SlowingClock.lf b/test/C/src/SlowingClock.lf index d4a1e1d5f4..c7ba2266fc 100644 --- a/test/C/src/SlowingClock.lf +++ b/test/C/src/SlowingClock.lf @@ -1,44 +1,43 @@ /** - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 - * msec on a logical action with a minimum delay of 100 msec. The use of the - * logical action ensures the elapsed time jumps exactly from 0 to 100, 300, - * 600, and 1000 msec. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a logical + * action with a minimum delay of 100 msec. The use of the logical action ensures the elapsed time + * jumps exactly from 0 to 100, 300, 600, and 1000 msec. */ target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } main reactor SlowingClock { - logical action a(100 msec) - state interval: time = 100 msec - state expected_time: time = 100 msec + logical action a(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec - reaction(startup) -> a {= lf_schedule(a, 0); =} + reaction(startup) -> a {= lf_schedule(a, 0); =} - reaction(a) -> a {= - instant_t elapsed_logical_time = lf_time_logical_elapsed(); - printf("Logical time since start: \%lld nsec.\n", - elapsed_logical_time + reaction(a) -> a {= + instant_t elapsed_logical_time = lf_time_logical_elapsed(); + printf("Logical time since start: \%lld nsec.\n", + elapsed_logical_time + ); + if (elapsed_logical_time != self->expected_time) { + printf("ERROR: Expected time to be: \%lld nsec.\n", + self->expected_time ); - if (elapsed_logical_time != self->expected_time) { - printf("ERROR: Expected time to be: \%lld nsec.\n", - self->expected_time - ); - exit(1); - } - lf_schedule(a, self->interval); - self->expected_time += MSEC(100) + self->interval; - self->interval += MSEC(100); - =} + exit(1); + } + lf_schedule(a, self->interval); + self->expected_time += MSEC(100) + self->interval; + self->interval += MSEC(100); + =} - reaction(shutdown) {= - if (self->expected_time != MSEC(1500)) { - printf("ERROR: Expected the next expected time to be: 1500000000 nsec.\n"); - printf("It was: \%lld nsec.\n", self->expected_time); - exit(2); - } else { - printf("Test passes.\n"); - } - =} + reaction(shutdown) {= + if (self->expected_time != MSEC(1500)) { + printf("ERROR: Expected the next expected time to be: 1500000000 nsec.\n"); + printf("It was: \%lld nsec.\n", self->expected_time); + exit(2); + } else { + printf("Test passes.\n"); + } + =} } diff --git a/test/C/src/SlowingClockPhysical.lf b/test/C/src/SlowingClockPhysical.lf index 0e82730112..9ec8d48ef9 100644 --- a/test/C/src/SlowingClockPhysical.lf +++ b/test/C/src/SlowingClockPhysical.lf @@ -1,46 +1,45 @@ /** - * /* Events are scheduled with increasing additional delays of 0, 100, 300, 600 - * msec on a physical action with a minimum delay of 100 msec. The use of the - * physical action makes the elapsed time jumps from 0 to approximately 100 - * msec, to approximatly 300 msec thereafter, drifting away further with each - * new event. + * /* Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a physical + * action with a minimum delay of 100 msec. The use of the physical action makes the elapsed time + * jumps from 0 to approximately 100 msec, to approximatly 300 msec thereafter, drifting away + * further with each new event. */ target C { - timeout: 1500 msec + timeout: 1500 msec } main reactor SlowingClockPhysical { - physical action a(100 msec) - state interval: time = 100 msec - state expected_time: time = 100 msec + physical action a(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec - reaction(startup) -> a {= - self->expected_time = MSEC(100); - lf_schedule(a, 0); - =} + reaction(startup) -> a {= + self->expected_time = MSEC(100); + lf_schedule(a, 0); + =} - reaction(a) -> a {= - instant_t elapsed_logical_time = lf_time_logical_elapsed(); - printf("Logical time since start: \%lld nsec.\n", - elapsed_logical_time + reaction(a) -> a {= + instant_t elapsed_logical_time = lf_time_logical_elapsed(); + printf("Logical time since start: \%lld nsec.\n", + elapsed_logical_time + ); + if (elapsed_logical_time < self->expected_time) { + printf("ERROR: Expected logical time to be at least: \%lld nsec.\n", + self->expected_time ); - if (elapsed_logical_time < self->expected_time) { - printf("ERROR: Expected logical time to be at least: \%lld nsec.\n", - self->expected_time - ); - exit(1); - } - self->interval += MSEC(100); - self->expected_time = MSEC(100) + self->interval; - lf_schedule(a, self->interval); - printf("Scheduling next to occur approximately after: \%lld nsec.\n", self->interval); - =} + exit(1); + } + self->interval += MSEC(100); + self->expected_time = MSEC(100) + self->interval; + lf_schedule(a, self->interval); + printf("Scheduling next to occur approximately after: \%lld nsec.\n", self->interval); + =} - reaction(shutdown) {= - if (self->expected_time < MSEC(500)) { - printf("ERROR: Expected the next expected time to be at least: 500000000 nsec.\n"); - printf("It was: \%lld nsec.\n", self->expected_time); - exit(2); - } - =} + reaction(shutdown) {= + if (self->expected_time < MSEC(500)) { + printf("ERROR: Expected the next expected time to be at least: 500000000 nsec.\n"); + printf("It was: \%lld nsec.\n", self->expected_time); + exit(2); + } + =} } diff --git a/test/C/src/Starvation.lf b/test/C/src/Starvation.lf index 8f4c1423a5..da56c2d4f7 100644 --- a/test/C/src/Starvation.lf +++ b/test/C/src/Starvation.lf @@ -1,68 +1,68 @@ /** - * Test that the starvation functionality in absence of the "keepalive: true" - * target property indeed works as expected. + * Test that the starvation functionality in absence of the "keepalive: true" target property indeed + * works as expected. * * @author Soroush Bateni */ target C reactor SuperDenseSender(number_of_iterations: int = 10) { - logical action loop - output out: int - state iterator: int = 0 + logical action loop + output out: int + state iterator: int = 0 - reaction(startup, loop) -> out {= - if (self->iterator < self->number_of_iterations) { - lf_schedule(loop, 0); - } - self->iterator++; - lf_set(out, 42); - =} + reaction(startup, loop) -> out {= + if (self->iterator < self->number_of_iterations) { + lf_schedule(loop, 0); + } + self->iterator++; + lf_set(out, 42); + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - if (current_tag.time == lf_time_start() - && current_tag.microstep == self->number_of_iterations + 1) { - printf("SUCCESS: Sender successfully detected starvation.\n"); - } else { - fprintf(stderr, "ERROR: Failed to properly enforce starvation at sender. " - "Shutting down at tag (%lld, %u).\n", - current_tag.time - lf_time_start(), - current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + if (current_tag.time == lf_time_start() + && current_tag.microstep == self->number_of_iterations + 1) { + printf("SUCCESS: Sender successfully detected starvation.\n"); + } else { + fprintf(stderr, "ERROR: Failed to properly enforce starvation at sender. " + "Shutting down at tag (%lld, %u).\n", + current_tag.time - lf_time_start(), + current_tag.microstep); + exit(1); + } + =} } reactor SuperDenseReceiver(number_of_iterations: int = 10) { - input in: int + input in: int - reaction(in) {= - tag_t current_tag = lf_tag(); - printf("Received %d at tag (%lld, %u).\n", - in->value, - current_tag.time - lf_time_start(), - current_tag.microstep); - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + printf("Received %d at tag (%lld, %u).\n", + in->value, + current_tag.time - lf_time_start(), + current_tag.microstep); + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - if (current_tag.time == lf_time_start() - && current_tag.microstep == self->number_of_iterations + 1) { - printf("SUCCESS: Receiver successfully detected starvation.\n"); - } else { - fprintf(stderr, "ERROR: Failed to properly enforce starvation at receiver. " - "Shutting down at tag (%lld, %u).\n", - current_tag.time - lf_time_start(), - current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + if (current_tag.time == lf_time_start() + && current_tag.microstep == self->number_of_iterations + 1) { + printf("SUCCESS: Receiver successfully detected starvation.\n"); + } else { + fprintf(stderr, "ERROR: Failed to properly enforce starvation at receiver. " + "Shutting down at tag (%lld, %u).\n", + current_tag.time - lf_time_start(), + current_tag.microstep); + exit(1); + } + =} } main reactor Starvation { - sender = new SuperDenseSender() - receiver = new SuperDenseReceiver() + sender = new SuperDenseSender() + receiver = new SuperDenseReceiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/Stop.lf b/test/C/src/Stop.lf index 1731bced42..a9586ecee7 100644 --- a/test/C/src/Stop.lf +++ b/test/C/src/Stop.lf @@ -4,59 +4,59 @@ * @author Soroush Bateni */ target C { - timeout: 11 msec + timeout: 11 msec } import Sender from "lib/LoopedActionSender.lf" reactor Consumer { - input in: int - state reaction_invoked_correctly: bool = false + input in: int + state reaction_invoked_correctly: bool = false - reaction(in) {= - tag_t current_tag = lf_tag(); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) > 0) { - // The reaction should not have been called at tags larger than (10 msec, 9) - fprintf(stderr, "ERROR: Invoked reaction(in) at tag bigger than shutdown.\n"); - exit(1); - } else if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 8}) == 0) { - // Call lf_request_stop() at relative tag (10 msec, 8) - printf("Requesting stop.\n"); - lf_request_stop(); - } else if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) == 0) { - // Check that this reaction is indeed also triggered at (10 msec, 9) - self->reaction_invoked_correctly = true; - } - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) > 0) { + // The reaction should not have been called at tags larger than (10 msec, 9) + fprintf(stderr, "ERROR: Invoked reaction(in) at tag bigger than shutdown.\n"); + exit(1); + } else if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 8}) == 0) { + // Call lf_request_stop() at relative tag (10 msec, 8) + printf("Requesting stop.\n"); + lf_request_stop(); + } else if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) == 0) { + // Check that this reaction is indeed also triggered at (10 msec, 9) + self->reaction_invoked_correctly = true; + } + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); - // Check to see if shutdown is called at relative tag (10 msec, 9) - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) == 0 && - self->reaction_invoked_correctly == true) { - printf("SUCCESS: successfully enforced stop.\n"); - } else if(lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) > 0) { - fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", - current_tag.time - lf_time_start(), current_tag.microstep); - exit(1); - } else if (self->reaction_invoked_correctly == false) { - // Check to see if reactions were called correctly - fprintf(stderr,"ERROR: Failed to invoke reaction(in) at tag (%llu, %d).\n", - current_tag.time - lf_time_start(), current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); + // Check to see if shutdown is called at relative tag (10 msec, 9) + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) == 0 && + self->reaction_invoked_correctly == true) { + printf("SUCCESS: successfully enforced stop.\n"); + } else if(lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) > 0) { + fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", + current_tag.time - lf_time_start(), current_tag.microstep); + exit(1); + } else if (self->reaction_invoked_correctly == false) { + // Check to see if reactions were called correctly + fprintf(stderr,"ERROR: Failed to invoke reaction(in) at tag (%llu, %d).\n", + current_tag.time - lf_time_start(), current_tag.microstep); + exit(1); + } + =} } main reactor { - consumer = new Consumer() - producer = new Sender(break_interval = 1 msec) + consumer = new Consumer() + producer = new Sender(break_interval = 1 msec) - producer.out -> consumer.in + producer.out -> consumer.in } diff --git a/test/C/src/StopZero.lf b/test/C/src/StopZero.lf index e845c6de48..ad22467a89 100644 --- a/test/C/src/StopZero.lf +++ b/test/C/src/StopZero.lf @@ -1,106 +1,106 @@ /** - * Test for lf_request_stop() at tag (0,0). This also tests for logically - * simultaneous calls to lf_request_stop(). + * Test for lf_request_stop() at tag (0,0). This also tests for logically simultaneous calls to + * lf_request_stop(). * * @author Soroush Bateni */ target C reactor Sender { - output out: int - state reaction_invoked_correctly: bool = false - timer t(0, 1 usec) - logical action act + output out: int + state reaction_invoked_correctly: bool = false + timer t(0, 1 usec) + logical action act - reaction(t) -> out, act {= - printf("Sending 42 at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_set(out, 42); - lf_schedule(act, 0); - tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; - tag_t one = (tag_t) { .time = lf_time_start(), .microstep = 1u }; - if (lf_tag_compare(lf_tag(), zero) == 0) { - // Request stop at (0,0) - printf("Requesting stop at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_request_stop(); - } else if (lf_tag_compare(lf_tag(), one) > 0) { - fprintf(stderr, "ERROR: Reaction called after shutdown at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } - =} + reaction(t) -> out, act {= + printf("Sending 42 at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_set(out, 42); + lf_schedule(act, 0); + tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; + tag_t one = (tag_t) { .time = lf_time_start(), .microstep = 1u }; + if (lf_tag_compare(lf_tag(), zero) == 0) { + // Request stop at (0,0) + printf("Requesting stop at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_request_stop(); + } else if (lf_tag_compare(lf_tag(), one) > 0) { + fprintf(stderr, "ERROR: Reaction called after shutdown at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } + =} - reaction(act) {= - // Reaction should be invoked at (0,1) - tag_t one = (tag_t) { .time = lf_time_start(), .microstep = 1u }; - if (lf_tag_compare(lf_tag(), one) == 0) { - self->reaction_invoked_correctly = true; - } - =} + reaction(act) {= + // Reaction should be invoked at (0,1) + tag_t one = (tag_t) { .time = lf_time_start(), .microstep = 1u }; + if (lf_tag_compare(lf_tag(), one) == 0) { + self->reaction_invoked_correctly = true; + } + =} - reaction(shutdown) {= - if (lf_time_logical_elapsed() != USEC(0) || - lf_tag().microstep != 1) { - fprintf(stderr, "ERROR: Sender failed to stop the program in time. " - "Stopping at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } else if (self->reaction_invoked_correctly == false) { - fprintf(stderr, "ERROR: Sender reaction(act) was not invoked. " - "Stopping at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } - printf("SUCCESS: Successfully stopped the program at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + reaction(shutdown) {= + if (lf_time_logical_elapsed() != USEC(0) || + lf_tag().microstep != 1) { + fprintf(stderr, "ERROR: Sender failed to stop the program in time. " + "Stopping at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } else if (self->reaction_invoked_correctly == false) { + fprintf(stderr, "ERROR: Sender reaction(act) was not invoked. " + "Stopping at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } + printf("SUCCESS: Successfully stopped the program at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + =} } reactor Receiver { - input in: int + input in: int - reaction(in) {= - printf("Received %d at (%lld, %u).\n", - in->value, - lf_time_logical_elapsed(), - lf_tag().microstep); - tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; - if (lf_tag_compare(lf_tag(), zero) == 0) { - // Request stop at (0,0) - printf("Requesting stop at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_request_stop(); - } - =} + reaction(in) {= + printf("Received %d at (%lld, %u).\n", + in->value, + lf_time_logical_elapsed(), + lf_tag().microstep); + tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; + if (lf_tag_compare(lf_tag(), zero) == 0) { + // Request stop at (0,0) + printf("Requesting stop at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_request_stop(); + } + =} - reaction(shutdown) {= - // Shutdown events must occur at (0, 1) on the - // receiver. - if (lf_time_logical_elapsed() != USEC(0) || - lf_tag().microstep != 1) { - fprintf(stderr, "ERROR: Receiver failed to stop the program in time. " - "Stopping at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } - printf("SUCCESS: Successfully stopped the program at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + reaction(shutdown) {= + // Shutdown events must occur at (0, 1) on the + // receiver. + if (lf_time_logical_elapsed() != USEC(0) || + lf_tag().microstep != 1) { + fprintf(stderr, "ERROR: Receiver failed to stop the program in time. " + "Stopping at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } + printf("SUCCESS: Successfully stopped the program at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + =} } main reactor StopZero { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/Stride.lf b/test/C/src/Stride.lf index 62b9077878..c4016d5059 100644 --- a/test/C/src/Stride.lf +++ b/test/C/src/Stride.lf @@ -1,36 +1,36 @@ -// This example illustrates state variables and parameters on the wiki. For this -// test, success is just compiling and running. +// This example illustrates state variables and parameters on the wiki. For this test, success is +// just compiling and running. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Count(stride: int = 1) { - state count: int = 1 - output y: int - timer t(0, 100 msec) + state count: int = 1 + output y: int + timer t(0, 100 msec) - reaction(t) -> y {= - lf_set(y, self->count); - self->count += self->stride; - =} + reaction(t) -> y {= + lf_set(y, self->count); + self->count += self->stride; + =} } reactor Display { - input x: int - state expected: int = 1 // for testing. + input x: int + state expected: int = 1 // for testing. - reaction(x) {= - printf("Received: %d.\n", x->value); - if (x->value != self->expected) { - fprintf(stderr, "ERROR: Expected %d\n", self->expected); - } - self->expected += 2; - =} + reaction(x) {= + printf("Received: %d.\n", x->value); + if (x->value != self->expected) { + fprintf(stderr, "ERROR: Expected %d\n", self->expected); + } + self->expected += 2; + =} } main reactor Stride { - c = new Count(stride = 2) - d = new Display() - c.y -> d.x + c = new Count(stride = 2) + d = new Display() + c.y -> d.x } diff --git a/test/C/src/StructAsState.lf b/test/C/src/StructAsState.lf index 119762c14c..c26429e1a7 100644 --- a/test/C/src/StructAsState.lf +++ b/test/C/src/StructAsState.lf @@ -1,23 +1,21 @@ -// Check that a state variable can have a statically initialized struct as a -// value. +// Check that a state variable can have a statically initialized struct as a value. target C preamble {= - typedef struct hello_t { - char* name; - int value; - } hello_t; + typedef struct hello_t { + char* name; + int value; + } hello_t; =} main reactor StructAsState { - // Notice that target code delimiters are no longer necessary. - state s: hello_t = {"Earth", 42} + state s: hello_t = {"Earth", 42} // Notice that target code delimiters are no longer necessary. - reaction(startup) {= - printf("State s.name=\"%s\", value=%d.\n", self->s.name, self->s.value); - if (self->s.value != 42) { - fprintf(stderr, "FAILED: Expected 42.\n"); - exit(1); - } - =} + reaction(startup) {= + printf("State s.name=\"%s\", value=%d.\n", self->s.name, self->s.value); + if (self->s.value != 42) { + fprintf(stderr, "FAILED: Expected 42.\n"); + exit(1); + } + =} } diff --git a/test/C/src/StructAsType.lf b/test/C/src/StructAsType.lf index 8674685530..eded331cb9 100644 --- a/test/C/src/StructAsType.lf +++ b/test/C/src/StructAsType.lf @@ -1,42 +1,42 @@ // Source produces a struct directly, rather than a pointer to a struct. target C { - files: include/hello.h + files: include/hello.h } preamble {= - #include "hello.h" + #include "hello.h" =} reactor Source { - output out: hello_t + output out: hello_t - reaction(startup) -> out {= - // Create the struct on the stack and then copy - // it to the output as follows: - struct hello_t temp = {"Earth", 42}; - lf_set(out, temp); - // Alternatively, you can anonymously create the struct, but in this case, - // parentheses around the second argument to lf_set() are needed because - // lf_set() is a macro and it will get confused by the comma in the argument - // and think that three arguments are being provided. - // lf_set(out, ((hello_t){"Earth", 42})); - =} + reaction(startup) -> out {= + // Create the struct on the stack and then copy + // it to the output as follows: + struct hello_t temp = {"Earth", 42}; + lf_set(out, temp); + // Alternatively, you can anonymously create the struct, but in this case, + // parentheses around the second argument to lf_set() are needed because + // lf_set() is a macro and it will get confused by the comma in the argument + // and think that three arguments are being provided. + // lf_set(out, ((hello_t){"Earth", 42})); + =} } reactor Print(expected: int = 42) { // expected parameter is for testing. - input in: hello_t + input in: hello_t - reaction(in) {= - printf("Received: name = %s, value = %d\n", in->value.name, in->value.value); - if (in->value.value != self->expected) { - printf("ERROR: Expected value to be %d.\n", self->expected); - exit(1); - } - =} + reaction(in) {= + printf("Received: name = %s, value = %d\n", in->value.name, in->value.value); + if (in->value.value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } + =} } main reactor StructAsType { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/C/src/StructAsTypeDirect.lf b/test/C/src/StructAsTypeDirect.lf index 29472f057b..b12e46b08e 100644 --- a/test/C/src/StructAsTypeDirect.lf +++ b/test/C/src/StructAsTypeDirect.lf @@ -1,36 +1,36 @@ // Source produces a struct directly, rather than a pointer to a struct. target C { - files: include/hello.h + files: include/hello.h } preamble {= - #include "hello.h" + #include "hello.h" =} reactor Source { - output out: hello_t + output out: hello_t - reaction(startup) -> out {= - out->value.name = "Earth"; - out->value.value = 42; - SET_PRESENT(out); - =} + reaction(startup) -> out {= + out->value.name = "Earth"; + out->value.value = 42; + SET_PRESENT(out); + =} } reactor Print(expected: int = 42) { // expected parameter is for testing. - input in: hello_t + input in: hello_t - reaction(in) {= - printf("Received: name = %s, value = %d\n", in->value.name, in->value.value); - if (in->value.value != self->expected) { - printf("ERROR: Expected value to be %d.\n", self->expected); - exit(1); - } - =} + reaction(in) {= + printf("Received: name = %s, value = %d\n", in->value.name, in->value.value); + if (in->value.value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/C/src/StructParallel.lf b/test/C/src/StructParallel.lf index 3c8e61a3a2..237f42366e 100644 --- a/test/C/src/StructParallel.lf +++ b/test/C/src/StructParallel.lf @@ -1,59 +1,58 @@ -// Source allocates an array dynamically and then sends it to two reactors, each -// of which want to modify it. NOTE: Ideally, only one copy would be made, but -// this requires modifying the precedence graph between reactions. +// Source allocates an array dynamically and then sends it to two reactors, each of which want to +// modify it. NOTE: Ideally, only one copy would be made, but this requires modifying the precedence +// graph between reactions. target C { - files: ["include/hello.h"] + files: ["include/hello.h"] } import Source from "StructScale.lf" preamble {= - #include "hello.h" + #include "hello.h" =} reactor Check(expected: int = 42) { - input in: hello_t* - state invoked: bool = false - - reaction(in) {= - printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); - if (in->value->value != self->expected) { - printf("ERROR: Expected value to be %d.\n", self->expected); - exit(1); - } - self->invoked = true; - =} - - reaction(shutdown) {= - if (self->invoked == false) { - fprintf(stderr, "ERROR: No data received.\n"); - exit(2); - } - =} + input in: hello_t* + state invoked: bool = false + + reaction(in) {= + printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); + if (in->value->value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } + self->invoked = true; + =} + + reaction(shutdown) {= + if (self->invoked == false) { + fprintf(stderr, "ERROR: No data received.\n"); + exit(2); + } + =} } reactor Print(scale: int = 2) { - // Mutable keyword indicates that this reactor wants a writable copy of the - // input. - mutable input in: hello_t* + // Mutable keyword indicates that this reactor wants a writable copy of the input. + mutable input in: hello_t* - output out: hello_t* + output out: hello_t* - reaction(in) -> out {= - in->value->value *= self->scale; - printf("Print received name = %s, value = %d\n", in->value->name, in->value->value); - lf_set_token(out, in->token); - =} + reaction(in) -> out {= + in->value->value *= self->scale; + printf("Print received name = %s, value = %d\n", in->value->name, in->value->value); + lf_set_token(out, in->token); + =} } main reactor StructParallel { - s = new Source() - c1 = new Print() - c2 = new Print(scale = 3) - p1 = new Check(expected = 84) - p2 = new Check(expected = 126) - s.out -> c1.in - s.out -> c2.in - c1.out -> p1.in - c2.out -> p2.in + s = new Source() + c1 = new Print() + c2 = new Print(scale = 3) + p1 = new Check(expected = 84) + p2 = new Check(expected = 126) + s.out -> c1.in + s.out -> c2.in + c1.out -> p1.in + c2.out -> p2.in } diff --git a/test/C/src/StructPrint.lf b/test/C/src/StructPrint.lf index 6af0d60c4f..43d699860b 100644 --- a/test/C/src/StructPrint.lf +++ b/test/C/src/StructPrint.lf @@ -1,39 +1,39 @@ -// Source produces a dynamically allocated struct, which it passes to Print. -// Reference counting ensures that the struct is freed. +// Source produces a dynamically allocated struct, which it passes to Print. Reference counting +// ensures that the struct is freed. target C { - files: ["include/hello.h"] + files: ["include/hello.h"] } preamble {= - #include "hello.h" + #include "hello.h" =} reactor Print { - output out: hello_t* + output out: hello_t* - reaction(startup) -> out {= - // Dynamically allocate an output struct. - SET_NEW(out); - // Above allocates a struct, which then must be populated. - out->value->name = "Earth"; - out->value->value = 42; - =} + reaction(startup) -> out {= + // Dynamically allocate an output struct. + SET_NEW(out); + // Above allocates a struct, which then must be populated. + out->value->name = "Earth"; + out->value->value = 42; + =} } reactor Check(expected: int = 42) { // expected parameter is for testing. - input in: hello_t* + input in: hello_t* - reaction(in) {= - printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); - if (in->value->value != self->expected) { - printf("ERROR: Expected value to be %d.\n", self->expected); - exit(1); - } - =} + reaction(in) {= + printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); + if (in->value->value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } + =} } main reactor { - s = new Print() - p = new Check() - s.out -> p.in + s = new Print() + p = new Check() + s.out -> p.in } diff --git a/test/C/src/StructScale.lf b/test/C/src/StructScale.lf index 3b92bab002..bbc4d5d078 100644 --- a/test/C/src/StructScale.lf +++ b/test/C/src/StructScale.lf @@ -1,65 +1,63 @@ -// Source produces a dynamically allocated struct, which it passes to Scale. -// Scale requests a writable copy, which, instead of copying, it just gets -// ownership of the original struct. It modifies it and passes it to Print. It -// gets freed after Print is done with it. +// Source produces a dynamically allocated struct, which it passes to Scale. Scale requests a +// writable copy, which, instead of copying, it just gets ownership of the original struct. It +// modifies it and passes it to Print. It gets freed after Print is done with it. target C { - files: ["include/hello.h"] + files: ["include/hello.h"] } preamble {= - #include "hello.h" + #include "hello.h" =} reactor Source { - output out: hello_t* - - reaction(startup) -> out {= - // Dynamically allocate an output struct. - SET_NEW(out); - // Above allocates a struct, which then must be populated. - out->value->name = "Earth"; - out->value->value = 42; - =} + output out: hello_t* + + reaction(startup) -> out {= + // Dynamically allocate an output struct. + SET_NEW(out); + // Above allocates a struct, which then must be populated. + out->value->name = "Earth"; + out->value->value = 42; + =} } reactor TestInput(expected: int = 42) { // expected parameter is for testing. - input in: hello_t* - state invoked: bool = false - - reaction(in) {= - printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); - if (in->value->value != self->expected) { - printf("ERROR: Expected value to be %d.\n", self->expected); - exit(1); - } - self->invoked = true; - =} - - reaction(shutdown) {= - if (self->invoked == false) { - fprintf(stderr, "ERROR: No data received.\n"); - exit(2); - } - =} + input in: hello_t* + state invoked: bool = false + + reaction(in) {= + printf("Received: name = %s, value = %d\n", in->value->name, in->value->value); + if (in->value->value != self->expected) { + printf("ERROR: Expected value to be %d.\n", self->expected); + exit(1); + } + self->invoked = true; + =} + + reaction(shutdown) {= + if (self->invoked == false) { + fprintf(stderr, "ERROR: No data received.\n"); + exit(2); + } + =} } reactor Print(scale: int = 2) { - // Mutable keyword indicates that this reactor wants a writable copy of the - // input. - mutable input in: hello_t* + // Mutable keyword indicates that this reactor wants a writable copy of the input. + mutable input in: hello_t* - output out: hello_t* + output out: hello_t* - reaction(in) -> out {= - in->value->value *= self->scale; - lf_set_token(out, in->token); - =} + reaction(in) -> out {= + in->value->value *= self->scale; + lf_set_token(out, in->token); + =} } main reactor StructScale { - s = new Source() - c = new Print() - p = new TestInput(expected = 84) - s.out -> c.in - c.out -> p.in + s = new Source() + c = new Print() + p = new TestInput(expected = 84) + s.out -> c.in + c.out -> p.in } diff --git a/test/C/src/SubclassesAndStartup.lf b/test/C/src/SubclassesAndStartup.lf index 2dbc1f688f..46e184e378 100644 --- a/test/C/src/SubclassesAndStartup.lf +++ b/test/C/src/SubclassesAndStartup.lf @@ -1,42 +1,42 @@ target C reactor Super { - state count: int = 0 + state count: int = 0 - reaction(startup) {= - printf("%s(Super) started\n", self->name); - self->count++; - =} + reaction(startup) {= + printf("%s(Super) started\n", self->name); + self->count++; + =} - reaction(shutdown) {= - if (self->count == 0) { - fprintf(stderr, "No startup reaction was invoked!\n"); - exit(3); - } - =} + reaction(shutdown) {= + if (self->count == 0) { + fprintf(stderr, "No startup reaction was invoked!\n"); + exit(3); + } + =} } reactor SubA(name: string = "SubA") extends Super { - reaction(startup) {= - printf("%s started\n", self->name); - if (self->count == 0) { - fprintf(stderr, "Base class startup reaction was not invoked!\n"); - exit(1); - } - =} + reaction(startup) {= + printf("%s started\n", self->name); + if (self->count == 0) { + fprintf(stderr, "Base class startup reaction was not invoked!\n"); + exit(1); + } + =} } reactor SubB(name: string = "SubB") extends Super { - reaction(startup) {= - printf("%s started\n", self->name); - if (self->count == 0) { - fprintf(stderr, "Base class startup reaction was not invoked!\n"); - exit(2); - } - =} + reaction(startup) {= + printf("%s started\n", self->name); + if (self->count == 0) { + fprintf(stderr, "Base class startup reaction was not invoked!\n"); + exit(2); + } + =} } main reactor SubclassesAndStartup { - a = new SubA() - b = new SubB() + a = new SubA() + b = new SubB() } diff --git a/test/C/src/TestForPreviousOutput.lf b/test/C/src/TestForPreviousOutput.lf index 890b47361d..0151715df0 100644 --- a/test/C/src/TestForPreviousOutput.lf +++ b/test/C/src/TestForPreviousOutput.lf @@ -3,13 +3,13 @@ target C preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include + #ifdef __cplusplus + } + #endif =} reactor Source { diff --git a/test/C/src/TimeLimit.lf b/test/C/src/TimeLimit.lf index ae178d53b5..efffe62f98 100644 --- a/test/C/src/TimeLimit.lf +++ b/test/C/src/TimeLimit.lf @@ -1,49 +1,48 @@ -// Test that the stop function can be used to internally impose a a time limit. -// Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt -// or getting the wrong data. +// Test that the stop function can be used to internally impose a a time limit. Correct output for +// this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. target C { - fast: true + fast: true } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - //printf("Reacting at time %ld.\n", lf_time_logical_elapsed()); - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + //printf("Reacting at time %ld.\n", lf_time_logical_elapsed()); + lf_set(y, self->count); + =} } reactor Destination { - input x: int - state s: int = 1 + input x: int + state s: int = 1 - reaction(x) {= - // printf("%d\n", x->value); - if (x->value != self->s) { - printf("Error: Expected %d and got %d.\n", self->s, x->value); - exit(1); - } - self->s++; - =} + reaction(x) {= + // printf("%d\n", x->value); + if (x->value != self->s) { + printf("Error: Expected %d and got %d.\n", self->s, x->value); + exit(1); + } + self->s++; + =} - reaction(shutdown) {= - printf("**** shutdown reaction invoked.\n"); - if (self->s != 12) { - fprintf(stderr, "ERROR: Expected 12 but got %d.\n", self->s); - exit(1); - } - =} + reaction(shutdown) {= + printf("**** shutdown reaction invoked.\n"); + if (self->s != 12) { + fprintf(stderr, "ERROR: Expected 12 but got %d.\n", self->s); + exit(1); + } + =} } main reactor TimeLimit(period: time = 1 sec) { - timer stop(10 sec) - c = new Clock(period = period) - d = new Destination() - c.y -> d.x + timer stop(10 sec) + c = new Clock(period = period) + d = new Destination() + c.y -> d.x - reaction(stop) {= lf_request_stop(); =} + reaction(stop) {= lf_request_stop(); =} } diff --git a/test/C/src/TimeState.lf b/test/C/src/TimeState.lf index cb0a9627f3..d3aaf2029a 100644 --- a/test/C/src/TimeState.lf +++ b/test/C/src/TimeState.lf @@ -1,11 +1,11 @@ target C reactor Foo(bar: int = 42) { - state baz: time = 500 msec + state baz: time = 500 msec - reaction(startup) {= printf("Baz: %lld\n", self->baz); =} + reaction(startup) {= printf("Baz: %lld\n", self->baz); =} } main reactor { - a = new Foo() + a = new Foo() } diff --git a/test/C/src/Timeout.lf b/test/C/src/Timeout.lf index d56d86a951..e6198c4c13 100644 --- a/test/C/src/Timeout.lf +++ b/test/C/src/Timeout.lf @@ -4,46 +4,46 @@ * @author Soroush Bateni */ target C { - timeout: 11 msec + timeout: 11 msec } import Sender from "lib/LoopedActionSender.lf" reactor Consumer { - input in: int - state success: bool = false + input in: int + state success: bool = false - reaction(in) {= - tag_t current_tag = lf_tag(); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) > 0) { - fprintf(stderr,"ERROR: Tag (%lld, %d) received. Failed to enforce timeout.\n", - current_tag.time, current_tag.microstep); - exit(1); - } else if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) == 0) { - self->success = true; // Successfully invoked the reaction at (timeout, 0) - } - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) > 0) { + fprintf(stderr,"ERROR: Tag (%lld, %d) received. Failed to enforce timeout.\n", + current_tag.time, current_tag.microstep); + exit(1); + } else if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) == 0) { + self->success = true; // Successfully invoked the reaction at (timeout, 0) + } + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) == 0 && - self->success == true) { - printf("SUCCESS: successfully enforced timeout.\n"); - } else { - fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", - current_tag.time, current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) == 0 && + self->success == true) { + printf("SUCCESS: successfully enforced timeout.\n"); + } else { + fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", + current_tag.time, current_tag.microstep); + exit(1); + } + =} } main reactor Timeout { - consumer = new Consumer() - producer = new Sender(break_interval = 1 msec) + consumer = new Consumer() + producer = new Sender(break_interval = 1 msec) - producer.out -> consumer.in + producer.out -> consumer.in } diff --git a/test/C/src/TimeoutZero.lf b/test/C/src/TimeoutZero.lf index 771d321a40..414a4460b0 100644 --- a/test/C/src/TimeoutZero.lf +++ b/test/C/src/TimeoutZero.lf @@ -1,50 +1,49 @@ /** - * A test for the timeout functionality in Lingua Franca. This variant tests - * timeout at (0,0). + * A test for the timeout functionality in Lingua Franca. This variant tests timeout at (0,0). * * @author Soroush Bateni */ target C { - timeout: 0 sec + timeout: 0 sec } import Sender from "lib/LoopedActionSender.lf" reactor Consumer { - input in: int - state success: bool = false + input in: int + state success: bool = false - reaction(in) {= - tag_t current_tag = lf_tag(); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) > 0) { - fprintf(stderr,"ERROR: Tag (%lld, %d) received. Failed to enforce timeout.\n", - current_tag.time, current_tag.microstep); - exit(1); - } else if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) == 0) { - self->success = true; // Successfully invoked the reaction at (timeout, 0) - } - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) > 0) { + fprintf(stderr,"ERROR: Tag (%lld, %d) received. Failed to enforce timeout.\n", + current_tag.time, current_tag.microstep); + exit(1); + } else if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) == 0) { + self->success = true; // Successfully invoked the reaction at (timeout, 0) + } + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) == 0 && - self->success == true) { - printf("SUCCESS: successfully enforced timeout.\n"); - } else { - fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", - current_tag.time, current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) == 0 && + self->success == true) { + printf("SUCCESS: successfully enforced timeout.\n"); + } else { + fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", + current_tag.time, current_tag.microstep); + exit(1); + } + =} } main reactor { - consumer = new Consumer() - producer = new Sender(break_interval = 1 msec) + consumer = new Consumer() + producer = new Sender(break_interval = 1 msec) - producer.out -> consumer.in + producer.out -> consumer.in } diff --git a/test/C/src/ToReactionNested.lf b/test/C/src/ToReactionNested.lf index 11b3577c84..14be00164d 100644 --- a/test/C/src/ToReactionNested.lf +++ b/test/C/src/ToReactionNested.lf @@ -1,36 +1,36 @@ target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } import Count from "lib/Count.lf" reactor CountContainer { - output out: int - c1 = new Count() - c1.out -> out + output out: int + c1 = new Count() + c1.out -> out } main reactor { - state count: int = 1 - state received: bool = false + state count: int = 1 + state received: bool = false - s = new CountContainer() + s = new CountContainer() - reaction(s.out) {= - if (s.out->is_present) { - lf_print("Received %d.", s.out->value); - if (self->count != s.out->value) { - lf_print_error_and_exit("Expected %d.", self->count); - } - self->received = true; + reaction(s.out) {= + if (s.out->is_present) { + lf_print("Received %d.", s.out->value); + if (self->count != s.out->value) { + lf_print_error_and_exit("Expected %d.", self->count); } - self->count++; - =} + self->received = true; + } + self->count++; + =} - reaction(shutdown) {= - if (!self->received) { - lf_print_error_and_exit("No inputs present."); - } - =} + reaction(shutdown) {= + if (!self->received) { + lf_print_error_and_exit("No inputs present."); + } + =} } diff --git a/test/C/src/TriggerDownstreamOnlyIfPresent2.lf b/test/C/src/TriggerDownstreamOnlyIfPresent2.lf index bc62b214e9..25eb13e564 100644 --- a/test/C/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/C/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,39 +1,36 @@ -/** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. - */ +/** This test checks that a downstream reaction is triggered only if its trigger is present. */ target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Source { - output[2] out: int - state count: int = 0 - timer t(0, 200 msec) + output[2] out: int + state count: int = 0 + timer t(0, 200 msec) - reaction(t) -> out {= - if (self->count++ % 2 == 0) { - lf_set(out[0], self->count); - } else { - lf_set(out[1], self->count); - } - =} + reaction(t) -> out {= + if (self->count++ % 2 == 0) { + lf_set(out[0], self->count); + } else { + lf_set(out[1], self->count); + } + =} } reactor Destination { - input in: int + input in: int - reaction(in) {= - if (!in->is_present) { - fprintf(stderr, "Reaction to input of triggered even though all inputs are absent!\n"); - exit(1); - } - =} + reaction(in) {= + if (!in->is_present) { + fprintf(stderr, "Reaction to input of triggered even though all inputs are absent!\n"); + exit(1); + } + =} } main reactor TriggerDownstreamOnlyIfPresent2 { - s = new Source() - d = new[2] Destination() - s.out -> d.in + s = new Source() + d = new[2] Destination() + s.out -> d.in } diff --git a/test/C/src/UnconnectedInput.lf b/test/C/src/UnconnectedInput.lf index 21e8cc5a69..88f7554149 100644 --- a/test/C/src/UnconnectedInput.lf +++ b/test/C/src/UnconnectedInput.lf @@ -1,48 +1,48 @@ // Test unconnected input. target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Source { - output out: int - timer t(0, 1 sec) - state s: int = 1 + output out: int + timer t(0, 1 sec) + state s: int = 1 - reaction(t) -> out {= lf_set(out, self->s++); =} + reaction(t) -> out {= lf_set(out, self->s++); =} } reactor Add { - input in1: int - input in2: int - output out: int + input in1: int + input in2: int + output out: int - reaction(in1, in2) -> out {= - int result = 0; - if (in1->is_present) result += in1->value; - if (in2->is_present) result += in2->value; - lf_set(out, result); - =} + reaction(in1, in2) -> out {= + int result = 0; + if (in1->is_present) result += in1->value; + if (in2->is_present) result += in2->value; + lf_set(out, result); + =} } reactor Print { - input in: int - state expected: int = 1 + input in: int + state expected: int = 1 - reaction(in) {= - printf("Received: %d.\n", in->value); - if (in->value != self->expected) { - printf("ERROR: Expected %d.\n", self->expected); - exit(1); - } - self->expected++; - =} + reaction(in) {= + printf("Received: %d.\n", in->value); + if (in->value != self->expected) { + printf("ERROR: Expected %d.\n", self->expected); + exit(1); + } + self->expected++; + =} } main reactor UnconnectedInput { - source = new Source() - add = new Add() - print = new Print() - source.out -> add.in2 - add.out -> print.in + source = new Source() + add = new Add() + print = new Print() + source.out -> add.in2 + add.out -> print.in } diff --git a/test/C/src/arduino/AnalogReadSerial.lf b/test/C/src/arduino/AnalogReadSerial.lf index 220cb47d47..b5d83d09de 100644 --- a/test/C/src/arduino/AnalogReadSerial.lf +++ b/test/C/src/arduino/AnalogReadSerial.lf @@ -1,21 +1,20 @@ /** - * This example reads an analog input on pin 0, prints the result to the Serial - * Monitor. Graphical representation is available using Serial Plotter (Tools > - * Serial Plotter menu). Attach the center pin of a potentiometer to pin A0, and - * the outside pins to +5V and ground. + * This example reads an analog input on pin 0, prints the result to the Serial Monitor. Graphical + * representation is available using Serial Plotter (Tools > Serial Plotter menu). Attach the center + * pin of a potentiometer to pin A0, and the outside pins to +5V and ground. */ target C { - platform: { - name: "arduino", - board: "arduino:avr:mega" - } + platform: { + name: "arduino", + board: "arduino:avr:mega" + } } main reactor AnalogReadSerial { - timer t1(0, 1 msec) + timer t1(0, 1 msec) - reaction(t1) {= - int sensorValue = analogRead(A0); - Serial.println(sensorValue); - =} + reaction(t1) {= + int sensorValue = analogRead(A0); + Serial.println(sensorValue); + =} } diff --git a/test/C/src/arduino/Blink.lf b/test/C/src/arduino/Blink.lf index 809aa55884..2612e72a62 100644 --- a/test/C/src/arduino/Blink.lf +++ b/test/C/src/arduino/Blink.lf @@ -1,22 +1,21 @@ /** - * This example demonstrates a very simple blink program that will turn on and - * off an LED on the Arduino Board with a 50% duty cycle switching every - * half-second. + * This example demonstrates a very simple blink program that will turn on and off an LED on the + * Arduino Board with a 50% duty cycle switching every half-second. */ target C { - platform: { - name: "arduino", - board: "arduino:avr:mega" - } + platform: { + name: "arduino", + board: "arduino:avr:mega" + } } main reactor Blink { - timer t1(0, 1 sec) - timer t2(500 msec, 1 sec) + timer t1(0, 1 sec) + timer t2(500 msec, 1 sec) - reaction(startup) {= pinMode(LED_BUILTIN, OUTPUT); =} + reaction(startup) {= pinMode(LED_BUILTIN, OUTPUT); =} - reaction(t1) {= digitalWrite(LED_BUILTIN, HIGH); =} + reaction(t1) {= digitalWrite(LED_BUILTIN, HIGH); =} - reaction(t2) {= digitalWrite(LED_BUILTIN, LOW); =} + reaction(t2) {= digitalWrite(LED_BUILTIN, LOW); =} } diff --git a/test/C/src/arduino/BlinkAttemptThreading.lf b/test/C/src/arduino/BlinkAttemptThreading.lf index 8f71009edf..4c4dac927c 100644 --- a/test/C/src/arduino/BlinkAttemptThreading.lf +++ b/test/C/src/arduino/BlinkAttemptThreading.lf @@ -1,24 +1,23 @@ /** - * This example demonstrates a very simple blink program that will turn on and - * off an LED on the Arduino Board with a 50% duty cycle switching every - * half-second. Note: if we try to enable threading, the system will give us a - * warning and default back to no threading. + * This example demonstrates a very simple blink program that will turn on and off an LED on the + * Arduino Board with a 50% duty cycle switching every half-second. Note: if we try to enable + * threading, the system will give us a warning and default back to no threading. */ target C { - platform: { - name: "arduino", - board: "arduino:avr:mega" - }, - threading: true + platform: { + name: "arduino", + board: "arduino:avr:mega" + }, + threading: true } main reactor BlinkAttemptThreading { - timer t1(0, 1 sec) - timer t2(500 msec, 1 sec) + timer t1(0, 1 sec) + timer t2(500 msec, 1 sec) - reaction(startup) {= pinMode(LED_BUILTIN, OUTPUT); =} + reaction(startup) {= pinMode(LED_BUILTIN, OUTPUT); =} - reaction(t1) {= digitalWrite(LED_BUILTIN, HIGH); =} + reaction(t1) {= digitalWrite(LED_BUILTIN, HIGH); =} - reaction(t2) {= digitalWrite(LED_BUILTIN, LOW); =} + reaction(t2) {= digitalWrite(LED_BUILTIN, LOW); =} } diff --git a/test/C/src/arduino/BlinkMBED.lf b/test/C/src/arduino/BlinkMBED.lf index f9702d27cc..3b2c84427e 100644 --- a/test/C/src/arduino/BlinkMBED.lf +++ b/test/C/src/arduino/BlinkMBED.lf @@ -1,22 +1,21 @@ /** - * This example demonstrates a very simple blink program that will turn on and - * off an LED on the Arduino Board with a 50% duty cycle switching every - * half-second. + * This example demonstrates a very simple blink program that will turn on and off an LED on the + * Arduino Board with a 50% duty cycle switching every half-second. */ target C { - platform: { - name: "arduino", - board: "arduino:mbed:nano33ble" - } + platform: { + name: "arduino", + board: "arduino:mbed:nano33ble" + } } main reactor BlinkMBED { - timer t1(0, 1 sec) - timer t2(500 msec, 1 sec) + timer t1(0, 1 sec) + timer t2(500 msec, 1 sec) - reaction(startup) {= pinMode(LED_BUILTIN, OUTPUT); =} + reaction(startup) {= pinMode(LED_BUILTIN, OUTPUT); =} - reaction(t1) {= digitalWrite(LED_BUILTIN, HIGH); =} + reaction(t1) {= digitalWrite(LED_BUILTIN, HIGH); =} - reaction(t2) {= digitalWrite(LED_BUILTIN, LOW); =} + reaction(t2) {= digitalWrite(LED_BUILTIN, LOW); =} } diff --git a/test/C/src/arduino/DigitalReadSerial.lf b/test/C/src/arduino/DigitalReadSerial.lf index d79f86ad9b..e521585a5d 100644 --- a/test/C/src/arduino/DigitalReadSerial.lf +++ b/test/C/src/arduino/DigitalReadSerial.lf @@ -1,23 +1,20 @@ -/** - * This example reads a digital input on pin 2, prints the result to the Serial - * Monitor - */ +/** This example reads a digital input on pin 2, prints the result to the Serial Monitor */ target C { - platform: { - name: "arduino", - board: "arduino:avr:mega" - } + platform: { + name: "arduino", + board: "arduino:avr:mega" + } } main reactor DigitalReadSerial { - timer t1(0, 1 msec) - state pushButton: int = 2 + timer t1(0, 1 msec) + state pushButton: int = 2 - reaction(startup) {= pinMode(self->pushButton, INPUT); =} + reaction(startup) {= pinMode(self->pushButton, INPUT); =} - reaction(t1) {= - int buttonState = digitalRead(self->pushButton); - // print out the state of the button: - Serial.println(buttonState); - =} + reaction(t1) {= + int buttonState = digitalRead(self->pushButton); + // print out the state of the button: + Serial.println(buttonState); + =} } diff --git a/test/C/src/arduino/Fade.lf b/test/C/src/arduino/Fade.lf index d23aabd646..5be1e79a79 100644 --- a/test/C/src/arduino/Fade.lf +++ b/test/C/src/arduino/Fade.lf @@ -1,32 +1,31 @@ /** - * This example shows how to fade an LED on pin 9 using the analogWrite() - * function. The analogWrite() function uses PWM, so if you want to change the - * pin you're using, be sure to use another PWM capable pin. On most Arduino, - * the PWM pins are identified with a "~" sign, like ~3, ~5, ~6, ~9, ~10 and - * ~11. + * This example shows how to fade an LED on pin 9 using the analogWrite() function. The + * analogWrite() function uses PWM, so if you want to change the pin you're using, be sure to use + * another PWM capable pin. On most Arduino, the PWM pins are identified with a "~" sign, like ~3, + * ~5, ~6, ~9, ~10 and ~11. */ target C { - platform: { - name: "arduino", - board: "arduino:avr:mega" - } + platform: { + name: "arduino", + board: "arduino:avr:mega" + } } main reactor Fade { - timer t1(0, 30 msec) - state led: int = 9 - state brightness: int = 9 - state fadeAmount: int = 5 + timer t1(0, 30 msec) + state led: int = 9 + state brightness: int = 9 + state fadeAmount: int = 5 - reaction(startup) {= pinMode(self->led, OUTPUT); =} + reaction(startup) {= pinMode(self->led, OUTPUT); =} - reaction(t1) {= - analogWrite(self->led, self->brightness); - // change the brightness for next time through the loop: - self->brightness += self->fadeAmount; - // reverse the direction of the fading at the ends of the fade: - if (self->brightness <= 0 || self->brightness >= 255) { - self->fadeAmount = -self->fadeAmount; - } - =} + reaction(t1) {= + analogWrite(self->led, self->brightness); + // change the brightness for next time through the loop: + self->brightness += self->fadeAmount; + // reverse the direction of the fading at the ends of the fade: + if (self->brightness <= 0 || self->brightness >= 255) { + self->fadeAmount = -self->fadeAmount; + } + =} } diff --git a/test/C/src/arduino/ReadAnalogVoltage.lf b/test/C/src/arduino/ReadAnalogVoltage.lf index 77be8e8b06..4dbffbbb83 100644 --- a/test/C/src/arduino/ReadAnalogVoltage.lf +++ b/test/C/src/arduino/ReadAnalogVoltage.lf @@ -1,28 +1,27 @@ /** - * This example reads an analog input on pin 0, converts it to voltage, and - * prints the result to the Serial Monitor. Graphical representation is - * available using Serial Plotter (Tools > Serial Plotter menu). Attach the - * center pin of a potentiometer to pin A0, and the outside pins to +5V and - * ground. + * This example reads an analog input on pin 0, converts it to voltage, and prints the result to the + * Serial Monitor. Graphical representation is available using Serial Plotter (Tools > Serial + * Plotter menu). Attach the center pin of a potentiometer to pin A0, and the outside pins to +5V + * and ground. */ target C { - platform: { - name: "arduino", - board: "arduino:avr:mega" - } + platform: { + name: "arduino", + board: "arduino:avr:mega" + } } main reactor ReadAnalogVoltage { - logical action a + logical action a - reaction(startup) -> a {= lf_schedule(a, 0); =} + reaction(startup) -> a {= lf_schedule(a, 0); =} - reaction(a) -> a {= - int sensorValue = analogRead(A0); - // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V): - float voltage = sensorValue * (5.0 / 1023.0); - // print out the value you read: - Serial.println(voltage); - lf_schedule(a, 0); - =} + reaction(a) -> a {= + int sensorValue = analogRead(A0); + // Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V): + float voltage = sensorValue * (5.0 / 1023.0); + // print out the value you read: + Serial.println(voltage); + lf_schedule(a, 0); + =} } diff --git a/test/C/src/concurrent/AsyncCallback.lf b/test/C/src/concurrent/AsyncCallback.lf index 58120446d4..d43dbc2a90 100644 --- a/test/C/src/concurrent/AsyncCallback.lf +++ b/test/C/src/concurrent/AsyncCallback.lf @@ -1,74 +1,72 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test case - * assumes that target is multithreaded. This test will not work with the - * unthreaded C target because that target does not implement any mutex - * protecting the event queue. + * Test asynchronous callbacks that trigger a physical action. This test case assumes that target is + * multithreaded. This test will not work with the unthreaded C target because that target does not + * implement any mutex protecting the event queue. * - * Note: This test uses the LF platform support to enable it to run on multiple - * platforms. + * Note: This test uses the LF platform support to enable it to run on multiple platforms. */ target C { - tracing: true, - timeout: 2 sec, - keepalive: true + tracing: true, + timeout: 2 sec, + keepalive: true } preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "platform.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif =} main reactor AsyncCallback { - preamble {= - void callback(void* a) { - // Schedule twice. If the action is not physical, these should - // get consolidated into a single action triggering. If it is, - // then they cause two separate triggerings with close but not - // equal time stamps. The minimum time between these is determined - // by the argument in the physical action definition. - lf_schedule(a, 0LL); - lf_schedule(a, 0LL); - } - // Simulate time passing before a callback occurs. - void* take_time(void* a) { - instant_t sleep_time = 100000000; - lf_sleep(sleep_time); - callback(a); - return NULL; - } - lf_thread_t threadId; - =} - timer t(0, 200 msec) - state thread_id: lf_thread_t = 0 - state expected_time: time = 100 msec - state toggle: bool = false + preamble {= + void callback(void* a) { + // Schedule twice. If the action is not physical, these should + // get consolidated into a single action triggering. If it is, + // then they cause two separate triggerings with close but not + // equal time stamps. The minimum time between these is determined + // by the argument in the physical action definition. + lf_schedule(a, 0LL); + lf_schedule(a, 0LL); + } + // Simulate time passing before a callback occurs. + void* take_time(void* a) { + instant_t sleep_time = 100000000; + lf_sleep(sleep_time); + callback(a); + return NULL; + } + lf_thread_t threadId; + =} + timer t(0, 200 msec) + state thread_id: lf_thread_t = 0 + state expected_time: time = 100 msec + state toggle: bool = false - physical action a(100 msec): int - state i: int = 0 + physical action a(100 msec): int + state i: int = 0 - reaction(t) -> a {= - // start new thread, provide callback - lf_thread_create(&self->thread_id, &take_time, a); - =} + reaction(t) -> a {= + // start new thread, provide callback + lf_thread_create(&self->thread_id, &take_time, a); + =} - reaction(a) {= - instant_t elapsed_time = lf_time_logical_elapsed(); - printf("Asynchronous callback %d: Assigned logical time greater than start time by %lld nsec.\n", - self->i++, elapsed_time); - if (elapsed_time <= self->expected_time) { - printf("ERROR: Expected logical time to be larger than %lld.\n", self->expected_time); - exit(1); - } - if (self->toggle) { - self->toggle = false; - self->expected_time += 200000000LL; - } else { - self->toggle = true; - } - =} + reaction(a) {= + instant_t elapsed_time = lf_time_logical_elapsed(); + printf("Asynchronous callback %d: Assigned logical time greater than start time by %lld nsec.\n", + self->i++, elapsed_time); + if (elapsed_time <= self->expected_time) { + printf("ERROR: Expected logical time to be larger than %lld.\n", self->expected_time); + exit(1); + } + if (self->toggle) { + self->toggle = false; + self->expected_time += 200000000LL; + } else { + self->toggle = true; + } + =} } diff --git a/test/C/src/concurrent/AsyncCallbackDrop.lf b/test/C/src/concurrent/AsyncCallbackDrop.lf index b0c5c502f2..245048d910 100644 --- a/test/C/src/concurrent/AsyncCallbackDrop.lf +++ b/test/C/src/concurrent/AsyncCallbackDrop.lf @@ -1,71 +1,70 @@ -// Test asynchronous callbacks that trigger a physical action with a DROP -// policy. This test case assumes that the target is multithreaded. This test -// will not work with the unthreaded C target because that target does not -// implement any mutex protecting the event queue. +// Test asynchronous callbacks that trigger a physical action with a DROP policy. This test case +// assumes that the target is multithreaded. This test will not work with the unthreaded C target +// because that target does not implement any mutex protecting the event queue. target C { - keepalive: true, // To silence warning. - timeout: 2 sec + keepalive: true, // To silence warning. + timeout: 2 sec } preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "platform.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif =} main reactor { - preamble {= - void callback(void* a) { - // Schedule twice in rapid succession. - // The second value should be dropped because the - // timestamps will not be sufficiently separated. - // The minimum time between these is determined - // by the argument in the physical action definition. - lf_schedule_int(a, 0, 0); - lf_schedule_int(a, 0, 1); - } - // Simulate time passing before a callback occurs. - void* take_time(void* a) { - instant_t sleep_time = 100000000; - lf_sleep(sleep_time); - callback(a); - return NULL; - } - lf_thread_t threadId; - =} - timer t(0, 200 msec) - state thread_id: lf_thread_t = 0 - state expected_time: time = 100 msec - state toggle: bool = false + preamble {= + void callback(void* a) { + // Schedule twice in rapid succession. + // The second value should be dropped because the + // timestamps will not be sufficiently separated. + // The minimum time between these is determined + // by the argument in the physical action definition. + lf_schedule_int(a, 0, 0); + lf_schedule_int(a, 0, 1); + } + // Simulate time passing before a callback occurs. + void* take_time(void* a) { + instant_t sleep_time = 100000000; + lf_sleep(sleep_time); + callback(a); + return NULL; + } + lf_thread_t threadId; + =} + timer t(0, 200 msec) + state thread_id: lf_thread_t = 0 + state expected_time: time = 100 msec + state toggle: bool = false - physical action a(100 msec, 100 msec, "drop"): int - state i: int = 0 + physical action a(100 msec, 100 msec, "drop"): int + state i: int = 0 - reaction(t) -> a {= - // start new thread, provide callback - lf_thread_create(&self->thread_id, &take_time, a); - =} + reaction(t) -> a {= + // start new thread, provide callback + lf_thread_create(&self->thread_id, &take_time, a); + =} - reaction(a) {= - instant_t elapsed_time = lf_time_logical_elapsed(); - printf("Asynchronous callback %d: Assigned logical time greater than start time by %lld nsec.\n", self->i++, elapsed_time); - if (elapsed_time <= self->expected_time) { - printf("ERROR: Expected logical time to be larger than %lld.\n", self->expected_time); - exit(1); - } - if (a->value != 0) { - printf("ERROR: Received: %d, expected 0 because the second event should have been dropped.\n", a->value); - exit(2); - } - if (self->toggle) { - self->toggle = false; - self->expected_time += 200000000LL; - } else { - self->toggle = true; - } - =} + reaction(a) {= + instant_t elapsed_time = lf_time_logical_elapsed(); + printf("Asynchronous callback %d: Assigned logical time greater than start time by %lld nsec.\n", self->i++, elapsed_time); + if (elapsed_time <= self->expected_time) { + printf("ERROR: Expected logical time to be larger than %lld.\n", self->expected_time); + exit(1); + } + if (a->value != 0) { + printf("ERROR: Received: %d, expected 0 because the second event should have been dropped.\n", a->value); + exit(2); + } + if (self->toggle) { + self->toggle = false; + self->expected_time += 200000000LL; + } else { + self->toggle = true; + } + =} } diff --git a/test/C/src/concurrent/AsyncCallbackReplace.lf b/test/C/src/concurrent/AsyncCallbackReplace.lf index 7bac7496b5..2809012ac9 100644 --- a/test/C/src/concurrent/AsyncCallbackReplace.lf +++ b/test/C/src/concurrent/AsyncCallbackReplace.lf @@ -1,71 +1,70 @@ -// Test asynchronous callbacks that trigger a physical action with a "replace" -// policy. This test case assumes that the target is multithreaded. This test -// will not work with the unthreaded C target because that target does not -// implement any mutex protecting the event queue. +// Test asynchronous callbacks that trigger a physical action with a "replace" policy. This test +// case assumes that the target is multithreaded. This test will not work with the unthreaded C +// target because that target does not implement any mutex protecting the event queue. target C { - keepalive: true, - timeout: 2 sec + keepalive: true, + timeout: 2 sec } preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "platform.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif =} main reactor { - preamble {= - void callback(void* a) { - // Schedule twice in rapid succession. - // The second value should be dropped because the - // timestamps will not be sufficiently separated. - // The minimum time between these is determined - // by the argument in the physical action definition. - lf_schedule_int(a, 0, 0); - lf_schedule_int(a, 0, 1); - } - // Simulate time passing before a callback occurs. - void* take_time(void* a) { - instant_t sleep_time = 100000000; - lf_sleep(sleep_time); - callback(a); - return NULL; - } - lf_thread_t threadId; - =} - timer t(0, 200 msec) - state thread_id: lf_thread_t = 0 - state expected_time: time = 100 msec - state toggle: bool = false + preamble {= + void callback(void* a) { + // Schedule twice in rapid succession. + // The second value should be dropped because the + // timestamps will not be sufficiently separated. + // The minimum time between these is determined + // by the argument in the physical action definition. + lf_schedule_int(a, 0, 0); + lf_schedule_int(a, 0, 1); + } + // Simulate time passing before a callback occurs. + void* take_time(void* a) { + instant_t sleep_time = 100000000; + lf_sleep(sleep_time); + callback(a); + return NULL; + } + lf_thread_t threadId; + =} + timer t(0, 200 msec) + state thread_id: lf_thread_t = 0 + state expected_time: time = 100 msec + state toggle: bool = false - physical action a(100 msec, 100 msec, "replace"): int - state i: int = 0 + physical action a(100 msec, 100 msec, "replace"): int + state i: int = 0 - reaction(t) -> a {= - // start new thread, provide callback - lf_thread_create(&self->thread_id, &take_time, a); - =} + reaction(t) -> a {= + // start new thread, provide callback + lf_thread_create(&self->thread_id, &take_time, a); + =} - reaction(a) {= - instant_t elapsed_time = lf_time_logical_elapsed(); - printf("Asynchronous callback %d: Assigned logical time greater than start time by %lld nsec.\n", self->i++, elapsed_time); - if (elapsed_time <= self->expected_time) { - printf("ERROR: Expected logical time to be larger than %lld.\n", self->expected_time); - exit(1); - } - if (a->value != 1) { - printf("ERROR: Received: %d, expected 1 because the second event should have replaced the first.\n", a->value); - exit(2); - } - if (self->toggle) { - self->toggle = false; - self->expected_time += 200000000LL; - } else { - self->toggle = true; - } - =} + reaction(a) {= + instant_t elapsed_time = lf_time_logical_elapsed(); + printf("Asynchronous callback %d: Assigned logical time greater than start time by %lld nsec.\n", self->i++, elapsed_time); + if (elapsed_time <= self->expected_time) { + printf("ERROR: Expected logical time to be larger than %lld.\n", self->expected_time); + exit(1); + } + if (a->value != 1) { + printf("ERROR: Received: %d, expected 1 because the second event should have replaced the first.\n", a->value); + exit(2); + } + if (self->toggle) { + self->toggle = false; + self->expected_time += 200000000LL; + } else { + self->toggle = true; + } + =} } diff --git a/test/C/src/concurrent/CompositionThreaded.lf b/test/C/src/concurrent/CompositionThreaded.lf index cf0bafeb82..ed40610e62 100644 --- a/test/C/src/concurrent/CompositionThreaded.lf +++ b/test/C/src/concurrent/CompositionThreaded.lf @@ -1,37 +1,36 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period: time = 2 sec) { - output y: int - timer t(1 sec, period) - state count: int = 0 + output y: int + timer t(1 sec, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + lf_set(y, self->count); + =} } reactor Test { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - (self->count)++; - printf("Received %d\n", x->value); - if (x->value != self->count) { - printf("FAILURE: Expected %d\n", self->count); - exit(1); - } - =} + reaction(x) {= + (self->count)++; + printf("Received %d\n", x->value); + if (x->value != self->count) { + printf("FAILURE: Expected %d\n", self->count); + exit(1); + } + =} } main reactor CompositionThreaded { - s = new Source() - d = new Test() - s.y -> d.x + s = new Source() + d = new Test() + s.y -> d.x } diff --git a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf index ad14879080..175745baa5 100644 --- a/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/C/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -1,52 +1,52 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target C preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "platform.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif =} reactor Deadline(threshold: time = 100 msec) { - input x: int - output deadline_violation: bool + input x: int + output deadline_violation: bool - reaction(x) -> deadline_violation {= - printf("ERROR: Deadline violation was not detected!\n"); - exit(1); - =} deadline(threshold) {= - printf("Deadline violation detected.\n"); - lf_set(deadline_violation, true); - =} + reaction(x) -> deadline_violation {= + printf("ERROR: Deadline violation was not detected!\n"); + exit(1); + =} deadline(threshold) {= + printf("Deadline violation detected.\n"); + lf_set(deadline_violation, true); + =} } main reactor { - state violation_detected: bool = false - d = new Deadline(threshold = 10 msec) + state violation_detected: bool = false + d = new Deadline(threshold = 10 msec) - reaction(startup) -> d.x {= - lf_sleep(MSEC(200)); - lf_set(d.x, 42); - =} + reaction(startup) -> d.x {= + lf_sleep(MSEC(200)); + lf_set(d.x, 42); + =} - reaction(d.deadline_violation) {= - if (d.deadline_violation) { - printf("Output successfully produced by deadline miss handler.\n"); - self->violation_detected = true; - } - =} + reaction(d.deadline_violation) {= + if (d.deadline_violation) { + printf("Output successfully produced by deadline miss handler.\n"); + self->violation_detected = true; + } + =} - reaction(shutdown) {= - if (self->violation_detected) { - printf("SUCCESS. Test passes.\n"); - } else { - printf("FAILURE. Container did not react to deadline violation.\n"); - exit(2); - } - =} + reaction(shutdown) {= + if (self->violation_detected) { + printf("SUCCESS. Test passes.\n"); + } else { + printf("FAILURE. Container did not react to deadline violation.\n"); + exit(2); + } + =} } diff --git a/test/C/src/concurrent/DeadlineThreaded.lf b/test/C/src/concurrent/DeadlineThreaded.lf index ffc1be2701..b3b86dfb23 100644 --- a/test/C/src/concurrent/DeadlineThreaded.lf +++ b/test/C/src/concurrent/DeadlineThreaded.lf @@ -1,62 +1,61 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target C { - timeout: 6 sec + timeout: 6 sec } preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "platform.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "platform.h" + #ifdef __cplusplus + } + #endif =} reactor Source(period: time = 3000 msec) { - output y: int - timer t(0, period) - state count: int = 0 + output y: int + timer t(0, period) + state count: int = 0 - reaction(t) -> y {= - if (2 * (self->count / 2) != self->count) { - // The count variable is odd. - // Take time to cause a deadline violation. - lf_sleep(MSEC(210)); - } - printf("Source sends: %d.\n", self->count); - lf_set(y, self->count); - (self->count)++; - =} + reaction(t) -> y {= + if (2 * (self->count / 2) != self->count) { + // The count variable is odd. + // Take time to cause a deadline violation. + lf_sleep(MSEC(210)); + } + printf("Source sends: %d.\n", self->count); + lf_set(y, self->count); + (self->count)++; + =} } reactor Destination(timeout: time = 1 sec) { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - printf("Destination receives: %d\n", x->value); - if (2 * (self->count / 2) != self->count) { - // The count variable is odd, so the deadline should have been violated. - printf("ERROR: Failed to detect deadline.\n"); - exit(1); - } - (self->count)++; - =} deadline(timeout) {= - printf("Destination deadline handler receives: %d\n", x->value); - if (2 * (self->count / 2) == self->count) { - // The count variable is even, so the deadline should not have been violated. - printf("ERROR: Unexpected deadline violation.\n"); - exit(2); - } - (self->count)++; - =} + reaction(x) {= + printf("Destination receives: %d\n", x->value); + if (2 * (self->count / 2) != self->count) { + // The count variable is odd, so the deadline should have been violated. + printf("ERROR: Failed to detect deadline.\n"); + exit(1); + } + (self->count)++; + =} deadline(timeout) {= + printf("Destination deadline handler receives: %d\n", x->value); + if (2 * (self->count / 2) == self->count) { + // The count variable is even, so the deadline should not have been violated. + printf("ERROR: Unexpected deadline violation.\n"); + exit(2); + } + (self->count)++; + =} } main reactor { - s = new Source() - d = new Destination(timeout = 200 msec) - s.y -> d.x + s = new Source() + d = new Destination(timeout = 200 msec) + s.y -> d.x } diff --git a/test/C/src/concurrent/DelayIntThreaded.lf b/test/C/src/concurrent/DelayIntThreaded.lf index 449b17eb60..57d3987386 100644 --- a/test/C/src/concurrent/DelayIntThreaded.lf +++ b/test/C/src/concurrent/DelayIntThreaded.lf @@ -2,58 +2,58 @@ target C reactor Delay(delay: time = 100 msec) { - input in: int - output out: int - logical action a: int + input in: int + output out: int + logical action a: int - reaction(a) -> out {= lf_set(out, a->value); =} + reaction(a) -> out {= lf_set(out, a->value); =} - reaction(in) -> a {= - // Use specialized form of schedule for integer payloads. - lf_schedule_int(a, self->delay, in->value); - =} + reaction(in) -> a {= + // Use specialized form of schedule for integer payloads. + lf_schedule_int(a, self->delay, in->value); + =} } reactor Test { - input in: int - state start_time: time = 0 - state received_value: bool = false - - reaction(startup) {= - // Record the logical time at the start. - self->start_time = lf_time_logical(); - =} - - reaction(in) {= - printf("Received: %d.\n", in->value); - self->received_value = true; - // Check the time of the input. - instant_t current_time = lf_time_logical(); - interval_t elapsed = current_time - self->start_time; - printf("After %lld nsec of logical time.\n", elapsed); - if (elapsed != 100000000LL) { - printf("ERROR: Expected elapsed time to be 100000000. It was %lld.\n", elapsed); - exit(1); - } - if (in->value != 42) { - printf("ERROR: Expected input value to be 42. It was %d.\n", in->value); - exit(2); - } - =} - - reaction(shutdown) {= - printf("Checking that communication occurred.\n"); - if (!self->received_value) { - printf("ERROR: No communication occurred!\n"); - exit(3); - } - =} + input in: int + state start_time: time = 0 + state received_value: bool = false + + reaction(startup) {= + // Record the logical time at the start. + self->start_time = lf_time_logical(); + =} + + reaction(in) {= + printf("Received: %d.\n", in->value); + self->received_value = true; + // Check the time of the input. + instant_t current_time = lf_time_logical(); + interval_t elapsed = current_time - self->start_time; + printf("After %lld nsec of logical time.\n", elapsed); + if (elapsed != 100000000LL) { + printf("ERROR: Expected elapsed time to be 100000000. It was %lld.\n", elapsed); + exit(1); + } + if (in->value != 42) { + printf("ERROR: Expected input value to be 42. It was %d.\n", in->value); + exit(2); + } + =} + + reaction(shutdown) {= + printf("Checking that communication occurred.\n"); + if (!self->received_value) { + printf("ERROR: No communication occurred!\n"); + exit(3); + } + =} } main reactor { - d = new Delay() - t = new Test() - d.out -> t.in + d = new Delay() + t = new Test() + d.out -> t.in - reaction(startup) -> d.in {= lf_set(d.in, 42); =} + reaction(startup) -> d.in {= lf_set(d.in, 42); =} } diff --git a/test/C/src/concurrent/DoubleReactionThreaded.lf b/test/C/src/concurrent/DoubleReactionThreaded.lf index ba6c38ca19..25eeb9f846 100644 --- a/test/C/src/concurrent/DoubleReactionThreaded.lf +++ b/test/C/src/concurrent/DoubleReactionThreaded.lf @@ -1,47 +1,47 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target C { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + lf_set(y, self->count); + =} } reactor Destination { - input x: int - input w: int - state s: int = 2 + input x: int + input w: int + state s: int = 2 - reaction(x, w) {= - int sum = 0; - if (x->is_present) { - sum += x->value; - } - if (w->is_present) { - sum += w->value; - } - printf("Sum of inputs is: %d\n", sum); - if (sum != self->s) { - printf("FAILURE: Expected sum to be %d, but it was %d.\n", self->s, sum); - exit(1); - } - self->s += 2; - =} + reaction(x, w) {= + int sum = 0; + if (x->is_present) { + sum += x->value; + } + if (w->is_present) { + sum += w->value; + } + printf("Sum of inputs is: %d\n", sum); + if (sum != self->s) { + printf("FAILURE: Expected sum to be %d, but it was %d.\n", self->s, sum); + exit(1); + } + self->s += 2; + =} } main reactor DoubleReactionThreaded { - c1 = new Clock() - c2 = new Clock() - d = new Destination() - c1.y -> d.x - c2.y -> d.w + c1 = new Clock() + c2 = new Clock() + d = new Destination() + c1.y -> d.x + c2.y -> d.w } diff --git a/test/C/src/concurrent/GainThreaded.lf b/test/C/src/concurrent/GainThreaded.lf index d9d6ec7673..f1407793bd 100644 --- a/test/C/src/concurrent/GainThreaded.lf +++ b/test/C/src/concurrent/GainThreaded.lf @@ -2,38 +2,38 @@ target C reactor Scale(scale: int = 2) { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= lf_set(y, x->value * self->scale); =} + reaction(x) -> y {= lf_set(y, x->value * self->scale); =} } reactor Test { - input x: int - state received_value: bool = false + input x: int + state received_value: bool = false - reaction(x) {= - printf("Received %d.\n", x->value); - self->received_value = true; - if (x->value != 2) { - printf("ERROR: Expected 2!\n"); - exit(1); - } - =} + reaction(x) {= + printf("Received %d.\n", x->value); + self->received_value = true; + if (x->value != 2) { + printf("ERROR: Expected 2!\n"); + exit(1); + } + =} - reaction(shutdown) {= - if (!self->received_value) { - printf("ERROR: No value received by Test reactor!\n"); - } else { - printf("Test passes.\n"); - } - =} + reaction(shutdown) {= + if (!self->received_value) { + printf("ERROR: No value received by Test reactor!\n"); + } else { + printf("Test passes.\n"); + } + =} } main reactor { - g = new Scale() - d = new Test() - g.y -> d.x + g = new Scale() + d = new Test() + g.y -> d.x - reaction(startup) -> g.x {= lf_set(g.x, 1); =} + reaction(startup) -> g.x {= lf_set(g.x, 1); =} } diff --git a/test/C/src/concurrent/HelloThreaded.lf b/test/C/src/concurrent/HelloThreaded.lf index 285811a17d..afe424aaaf 100644 --- a/test/C/src/concurrent/HelloThreaded.lf +++ b/test/C/src/concurrent/HelloThreaded.lf @@ -1,63 +1,56 @@ -// This test checks that logical time is incremented an appropriate amount as a -// result of an invocation of the lf_schedule() function at runtime. It also -// performs various smoke tests of timing aligned reactions. The first instance -// has a period of 4 seconds, the second of 2 seconds, and the third (composite) -// or 1 second. +// This test checks that logical time is incremented an appropriate amount as a result of an +// invocation of the lf_schedule() function at runtime. It also performs various smoke tests of +// timing aligned reactions. The first instance has a period of 4 seconds, the second of 2 seconds, +// and the third (composite) or 1 second. target C { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } preamble {= - #include + #include =} reactor Reschedule(period: time = 2 sec, message: string = "Hello C") { - state count: int = 0 - state previous_time: time = 0 - timer t(1 sec, period) - logical action a + state count: int = 0 + state previous_time: time = 0 + timer t(1 sec, period) + logical action a - reaction(t) -> a {= - printf("%s\n", self->message); - lf_schedule(a, MSEC(200)); - // Print the current time. - self->previous_time = lf_time_logical(); - time_t secs = self->previous_time/BILLION; - printf("Current time is %lld\n", self->previous_time); - printf("Which is %sPlus %lld nanoseconds.\n", ctime(&secs), self->previous_time % BILLION); - =} + reaction(t) -> a {= + printf("%s\n", self->message); + lf_schedule(a, MSEC(200)); + // Print the current time. + self->previous_time = lf_time_logical(); + time_t secs = self->previous_time/BILLION; + printf("Current time is %lld\n", self->previous_time); + printf("Which is %sPlus %lld nanoseconds.\n", ctime(&secs), self->previous_time % BILLION); + =} - reaction(a) {= - (self->count)++; - printf("***** action %d at time %lld\n", self->count, lf_time_logical()); - // Check the a_has_value variable. - if (a->has_value) { - printf("FAILURE: Expected a->has_value to be false, but it was true.\n"); - exit(2); - } - long long time = lf_time_logical(); - if (time - self->previous_time != 200000000ll) { - printf("FAILURE: Expected 200ms of logical time to elapse but got %lld nanoseconds.\n", - time - self->previous_time - ); - exit(1); - } - =} + reaction(a) {= + (self->count)++; + printf("***** action %d at time %lld\n", self->count, lf_time_logical()); + // Check the a_has_value variable. + if (a->has_value) { + printf("FAILURE: Expected a->has_value to be false, but it was true.\n"); + exit(2); + } + long long time = lf_time_logical(); + if (time - self->previous_time != 200000000ll) { + printf("FAILURE: Expected 200ms of logical time to elapse but got %lld nanoseconds.\n", + time - self->previous_time + ); + exit(1); + } + =} } -reactor Inside( - period: time = 1 sec, - message: string = "Composite default message." -) { - third_instance = new Reschedule(period = period, message = message) +reactor Inside(period: time = 1 sec, message: string = "Composite default message.") { + third_instance = new Reschedule(period = period, message = message) } main reactor HelloThreaded { - first_instance = new Reschedule( - period = 4 sec, - message = "Hello from first_instance." - ) - second_instance = new Reschedule(message = "Hello from second_instance.") - composite_instance = new Inside(message = "Hello from composite_instance.") + first_instance = new Reschedule(period = 4 sec, message = "Hello from first_instance.") + second_instance = new Reschedule(message = "Hello from second_instance.") + composite_instance = new Inside(message = "Hello from composite_instance.") } diff --git a/test/C/src/concurrent/PingPongThreaded.lf b/test/C/src/concurrent/PingPongThreaded.lf index 4fae17911e..4d6532acdd 100644 --- a/test/C/src/concurrent/PingPongThreaded.lf +++ b/test/C/src/concurrent/PingPongThreaded.lf @@ -1,71 +1,67 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the - * causality loop. + * Ping introduces a microstep delay using a logical action to break the causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * - * Unthreaded: 97 msec Threaded: 265 msec (168 msec with optimization of - * executing immediately) + * Unthreaded: 97 msec Threaded: 265 msec (168 msec with optimization of executing immediately) * - * There is no parallelism in this application, so it does not benefit from - * being being threaded, just some additional overhead. + * There is no parallelism in this application, so it does not benefit from being being threaded, + * just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. - * These are about an order of magnitude faster than anything reported in the - * paper. + * These measurements are total execution time, including startup and shutdown. These are about an + * order of magnitude faster than anything reported in the paper. * * @author Edward A. Lee */ target C { - fast: true + fast: true } reactor Ping(count: int = 10) { - input receive: int - output send: int - state pingsLeft: int = count - logical action serve + input receive: int + output send: int + state pingsLeft: int = count + logical action serve - reaction(startup, serve) -> send {= lf_set(send, self->pingsLeft--); =} + reaction(startup, serve) -> send {= lf_set(send, self->pingsLeft--); =} - reaction(receive) -> serve {= - if (self->pingsLeft > 0) { - lf_schedule(serve, 0); - } else { - lf_request_stop(); - } - =} + reaction(receive) -> serve {= + if (self->pingsLeft > 0) { + lf_schedule(serve, 0); + } else { + lf_request_stop(); + } + =} } reactor Pong(expected: int = 10) { - input receive: int - output send: int - state count: int = 0 + input receive: int + output send: int + state count: int = 0 - reaction(receive) -> send {= - self->count++; - lf_set(send, receive->value); - =} + reaction(receive) -> send {= + self->count++; + lf_set(send, receive->value); + =} - reaction(shutdown) {= - if (self->count != self->expected) { - fprintf(stderr, "Pong expected to receive %d inputs, but it received %d.\n", - self->expected, self->count - ); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->count != self->expected) { + fprintf(stderr, "Pong expected to receive %d inputs, but it received %d.\n", + self->expected, self->count + ); + exit(1); + } + printf("Success.\n"); + =} } main reactor PingPongThreaded { - ping = new Ping() - pong = new Pong() - ping.send -> pong.receive - pong.send -> ping.receive + ping = new Ping() + pong = new Pong() + ping.send -> pong.receive + pong.send -> ping.receive } diff --git a/test/C/src/concurrent/ScheduleAt.lf b/test/C/src/concurrent/ScheduleAt.lf index 2ef6af7af6..37aea62afb 100644 --- a/test/C/src/concurrent/ScheduleAt.lf +++ b/test/C/src/concurrent/ScheduleAt.lf @@ -1,106 +1,88 @@ /** - * Test _lf_schedule_at_tag which is an internal API function not meant to be - * used in user code. + * Test _lf_schedule_at_tag which is an internal API function not meant to be used in user code. * * @author Soroush Bateni */ target C { - timeout: 1 sec, - keepalive: true + timeout: 1 sec, + keepalive: true } reactor Scheduler { - preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "include/core/reactor_common.h" - #ifdef __cplusplus - } - #endif - =} - logical action act - // List of microsteps. Size = 16 - state microstep_delay_list: uint32_t[] = { - 0, - 1, - 1, - 2, - 2, - 0, - 0, - 1, - 1, - 0, - 2, - 3, - 3, - 4, - 4, - 5 + preamble {= + #ifdef __cplusplus + extern "C" { + #endif + #include "include/core/reactor_common.h" + #ifdef __cplusplus } + #endif + =} + logical action act + // List of microsteps. Size = 16 + state microstep_delay_list: uint32_t[] = {0, 1, 1, 2, 2, 0, 0, 1, 1, 0, 2, 3, 3, 4, 4, 5} - state times: int[] = { - 0, - 0, - 0, - 0, - 0, - 400 msec, - 400 msec, - 400 msec, - 400 msec, // List of the corresponding times. Size = 16 - 800 msec, - 800 msec, - 800 msec, - 800 msec, - 900 msec, - 900 msec, - 900 msec - } - // Size = 9 - state action_hit_list_microstep: int[] = {1, 2, 0, 1, 0, 2, 3, 4, 5} - state action_hit_list_times: int[] = { - 0, - 0, - 400 msec, - 400 msec, - 800 msec, - 800 msec, - 800 msec, - 900 msec, - 900 msec - } - // Size = 9 - state action_hit_list_index: int = 0 + state times: int[] = { + 0, + 0, + 0, + 0, + 0, + 400 msec, + 400 msec, + 400 msec, + 400 msec, // List of the corresponding times. Size = 16 + 800 msec, + 800 msec, + 800 msec, + 800 msec, + 900 msec, + 900 msec, + 900 msec + } + // Size = 9 + state action_hit_list_microstep: int[] = {1, 2, 0, 1, 0, 2, 3, 4, 5} + state action_hit_list_times: int[] = { + 0, + 0, + 400 msec, + 400 msec, + 800 msec, + 800 msec, + 800 msec, + 900 msec, + 900 msec + } + // Size = 9 + state action_hit_list_index: int = 0 - reaction(startup) -> act {= - for (int i=0; i < 16; i++) { - _lf_schedule_at_tag(act->trigger, - (tag_t) { .time = self->times[i] + lf_time_logical(), .microstep = self->microstep_delay_list[i]}, - NULL); - } - =} + reaction(startup) -> act {= + for (int i=0; i < 16; i++) { + _lf_schedule_at_tag(act->trigger, + (tag_t) { .time = self->times[i] + lf_time_logical(), .microstep = self->microstep_delay_list[i]}, + NULL); + } + =} - reaction(act) {= - microstep_t microstep = lf_tag().microstep; - instant_t elapsed_time = lf_time_logical_elapsed(); - if (elapsed_time == self->action_hit_list_times[self->action_hit_list_index] && - microstep == self->action_hit_list_microstep[self->action_hit_list_index]) { - self->action_hit_list_index++; - } - printf("Triggered at tag (%lld, %u).\n", elapsed_time, microstep); - =} + reaction(act) {= + microstep_t microstep = lf_tag().microstep; + instant_t elapsed_time = lf_time_logical_elapsed(); + if (elapsed_time == self->action_hit_list_times[self->action_hit_list_index] && + microstep == self->action_hit_list_microstep[self->action_hit_list_index]) { + self->action_hit_list_index++; + } + printf("Triggered at tag (%lld, %u).\n", elapsed_time, microstep); + =} - reaction(shutdown) {= - if (self->action_hit_list_index != 9) { - fprintf(stderr, "ERROR: incorrect number of actions were correctly scheduled: %d.", self->action_hit_list_index); - exit(1); - } - printf("SUCCESS: successfully scheduled all the events.\n"); - =} + reaction(shutdown) {= + if (self->action_hit_list_index != 9) { + fprintf(stderr, "ERROR: incorrect number of actions were correctly scheduled: %d.", self->action_hit_list_index); + exit(1); + } + printf("SUCCESS: successfully scheduled all the events.\n"); + =} } main reactor ScheduleAt { - sender = new Scheduler() + sender = new Scheduler() } diff --git a/test/C/src/concurrent/ScheduleTwice.lf b/test/C/src/concurrent/ScheduleTwice.lf index e19f4d02d5..06a1c2c1cb 100644 --- a/test/C/src/concurrent/ScheduleTwice.lf +++ b/test/C/src/concurrent/ScheduleTwice.lf @@ -1,34 +1,34 @@ target C main reactor ScheduleTwice { - logical action a: int - state rc_count: int = 0 - preamble {= - #define VERBOSE - =} + logical action a: int + state rc_count: int = 0 + preamble {= + #define VERBOSE + =} - reaction(startup) -> a {= - lf_schedule_int(a, MSEC(100), 42); - lf_schedule_int(a, MSEC(100), 84); - =} + reaction(startup) -> a {= + lf_schedule_int(a, MSEC(100), 42); + lf_schedule_int(a, MSEC(100), 84); + =} - reaction(a) {= - printf("Received %d at tag(%lld, %u).\n", a->value, lf_time_logical_elapsed(), lf_tag().microstep); - if (lf_tag().microstep == 0 && a->value != 42) { - fprintf(stderr, "ERROR: Expected 42 at microstep 0.\n"); - exit(1); - } - if (lf_tag().microstep == 1 && a->value != 84) { - fprintf(stderr, "ERROR: Expected 84 at microstep 1.\n"); - exit(1); - } - self->rc_count++; - =} + reaction(a) {= + printf("Received %d at tag(%lld, %u).\n", a->value, lf_time_logical_elapsed(), lf_tag().microstep); + if (lf_tag().microstep == 0 && a->value != 42) { + fprintf(stderr, "ERROR: Expected 42 at microstep 0.\n"); + exit(1); + } + if (lf_tag().microstep == 1 && a->value != 84) { + fprintf(stderr, "ERROR: Expected 84 at microstep 1.\n"); + exit(1); + } + self->rc_count++; + =} - reaction(shutdown) {= - if (self->rc_count < 2) { - fprintf(stderr, "Didn't see two events.\n"); - exit(2); - } - =} + reaction(shutdown) {= + if (self->rc_count < 2) { + fprintf(stderr, "Didn't see two events.\n"); + exit(2); + } + =} } diff --git a/test/C/src/concurrent/ScheduleTwiceThreaded.lf b/test/C/src/concurrent/ScheduleTwiceThreaded.lf index 499e0e4999..d7e3d926f3 100644 --- a/test/C/src/concurrent/ScheduleTwiceThreaded.lf +++ b/test/C/src/concurrent/ScheduleTwiceThreaded.lf @@ -1,31 +1,31 @@ target C main reactor { - logical action a: int - state rc_count: int = 0 + logical action a: int + state rc_count: int = 0 - reaction(startup) -> a {= - lf_schedule_int(a, MSEC(100), 42); - lf_schedule_int(a, MSEC(100), 84); - =} + reaction(startup) -> a {= + lf_schedule_int(a, MSEC(100), 42); + lf_schedule_int(a, MSEC(100), 84); + =} - reaction(a) {= - printf("Received %d at tag(%lld, %u).\n", a->value, lf_time_logical_elapsed(), lf_tag().microstep); - if (lf_tag().microstep == 0 && a->value != 42) { - fprintf(stderr, "ERROR: Expected 42 at microstep 0.\n"); - exit(1); - } - if (lf_tag().microstep == 1 && a->value != 84) { - fprintf(stderr, "ERROR: Expected 84 at microstep 1.\n"); - exit(1); - } - self->rc_count++; - =} + reaction(a) {= + printf("Received %d at tag(%lld, %u).\n", a->value, lf_time_logical_elapsed(), lf_tag().microstep); + if (lf_tag().microstep == 0 && a->value != 42) { + fprintf(stderr, "ERROR: Expected 42 at microstep 0.\n"); + exit(1); + } + if (lf_tag().microstep == 1 && a->value != 84) { + fprintf(stderr, "ERROR: Expected 84 at microstep 1.\n"); + exit(1); + } + self->rc_count++; + =} - reaction(shutdown) {= - if (self->rc_count < 2) { - fprintf(stderr, "Didn't see two events.\n"); - exit(2); - } - =} + reaction(shutdown) {= + if (self->rc_count < 2) { + fprintf(stderr, "Didn't see two events.\n"); + exit(2); + } + =} } diff --git a/test/C/src/concurrent/SendingInsideThreaded.lf b/test/C/src/concurrent/SendingInsideThreaded.lf index e5185ecfc8..e651f0fc69 100644 --- a/test/C/src/concurrent/SendingInsideThreaded.lf +++ b/test/C/src/concurrent/SendingInsideThreaded.lf @@ -1,31 +1,31 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target C { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Printer { - input x: int - state count: int = 1 + input x: int + state count: int = 1 - reaction(x) {= - printf("Inside reactor received: %d\n", x->value); - if (x->value != self->count) { - printf("FAILURE: Expected %d.\n", self->count); - exit(1); - } - self->count++; - =} + reaction(x) {= + printf("Inside reactor received: %d\n", x->value); + if (x->value != self->count) { + printf("FAILURE: Expected %d.\n", self->count); + exit(1); + } + self->count++; + =} } main reactor SendingInsideThreaded { - state count: int = 0 - timer t(0, 1 sec) - p = new Printer() + state count: int = 0 + timer t(0, 1 sec) + p = new Printer() - reaction(t) -> p.x {= - (self->count)++; - lf_set(p.x, self->count); - =} + reaction(t) -> p.x {= + (self->count)++; + lf_set(p.x, self->count); + =} } diff --git a/test/C/src/concurrent/StarvationThreaded.lf b/test/C/src/concurrent/StarvationThreaded.lf index d1e78e5ced..5152b4daa0 100644 --- a/test/C/src/concurrent/StarvationThreaded.lf +++ b/test/C/src/concurrent/StarvationThreaded.lf @@ -1,69 +1,68 @@ /** - * Test that the starvation functionality in absence of the "keepalive: true" - * target property indeed works as expected. This version uses the threaded - * runtime. + * Test that the starvation functionality in absence of the "keepalive: true" target property indeed + * works as expected. This version uses the threaded runtime. * * @author Soroush Bateni */ target C reactor SuperDenseSender(number_of_iterations: int = 10) { - logical action loop - output out: int - state iterator: int = 0 + logical action loop + output out: int + state iterator: int = 0 - reaction(startup, loop) -> out {= - if (self->iterator < self->number_of_iterations) { - lf_schedule(loop, 0); - } - self->iterator++; - lf_set(out, 42); - =} + reaction(startup, loop) -> out {= + if (self->iterator < self->number_of_iterations) { + lf_schedule(loop, 0); + } + self->iterator++; + lf_set(out, 42); + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - if (current_tag.time == lf_time_start() - && current_tag.microstep == self->number_of_iterations + 1) { - printf("SUCCESS: Sender successfully detected starvation.\n"); - } else { - fprintf(stderr, "ERROR: Failed to properly enforce starvation at sender. " - "Shutting down at tag (%lld, %u).\n", - current_tag.time - lf_time_start(), - current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + if (current_tag.time == lf_time_start() + && current_tag.microstep == self->number_of_iterations + 1) { + printf("SUCCESS: Sender successfully detected starvation.\n"); + } else { + fprintf(stderr, "ERROR: Failed to properly enforce starvation at sender. " + "Shutting down at tag (%lld, %u).\n", + current_tag.time - lf_time_start(), + current_tag.microstep); + exit(1); + } + =} } reactor SuperDenseReceiver(number_of_iterations: int = 10) { - input in: int + input in: int - reaction(in) {= - tag_t current_tag = lf_tag(); - printf("Received %d at tag (%lld, %u).\n", - in->value, - current_tag.time - lf_time_start(), - current_tag.microstep); - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + printf("Received %d at tag (%lld, %u).\n", + in->value, + current_tag.time - lf_time_start(), + current_tag.microstep); + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - if (current_tag.time == lf_time_start() - && current_tag.microstep == self->number_of_iterations + 1) { - printf("SUCCESS: Receiver successfully detected starvation.\n"); - } else { - fprintf(stderr, "ERROR: Failed to properly enforce starvation at receiver. " - "Shutting down at tag (%lld, %u).\n", - current_tag.time - lf_time_start(), - current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + if (current_tag.time == lf_time_start() + && current_tag.microstep == self->number_of_iterations + 1) { + printf("SUCCESS: Receiver successfully detected starvation.\n"); + } else { + fprintf(stderr, "ERROR: Failed to properly enforce starvation at receiver. " + "Shutting down at tag (%lld, %u).\n", + current_tag.time - lf_time_start(), + current_tag.microstep); + exit(1); + } + =} } main reactor StarvationThreaded { - sender = new[8] SuperDenseSender() - receiver = new[8] SuperDenseReceiver() + sender = new[8] SuperDenseSender() + receiver = new[8] SuperDenseReceiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/concurrent/StopThreaded.lf b/test/C/src/concurrent/StopThreaded.lf index 1deb1c4ff6..3c00bff39f 100644 --- a/test/C/src/concurrent/StopThreaded.lf +++ b/test/C/src/concurrent/StopThreaded.lf @@ -1,65 +1,65 @@ /** - * A test for the lf_request_stop() functionality in Lingua Franca. This version - * of the test is threaded. + * A test for the lf_request_stop() functionality in Lingua Franca. This version of the test is + * threaded. * * @author Soroush Bateni */ target C { - timeout: 11 msec, - build-type: RelWithDebInfo // logging: DEBUG + timeout: 11 msec, + build-type: RelWithDebInfo // logging: DEBUG } import Sender from "../lib/LoopedActionSender.lf" reactor Consumer { - input in: int - state reaction_invoked_correctly: bool = false + input in: int + state reaction_invoked_correctly: bool = false - reaction(in) {= - tag_t current_tag = lf_tag(); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) > 0) { - // The reaction should not have been called at tags larger than (10 - // msec, 9) - char time[255]; - lf_print_error_and_exit("Invoked reaction(in) at tag (%llu, %d) which is bigger than shutdown.", - current_tag.time - lf_time_start(), current_tag.microstep); - } else if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 8}) == 0) { - // Call lf_request_stop() at relative tag (10 msec, 8) - lf_print("Requesting stop."); - lf_request_stop(); - } else if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) == 0) { - // Check that this reaction is indeed also triggered at (10 msec, 9) - // printf("Reaction invoked.\n"); - self->reaction_invoked_correctly = true; - } - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) > 0) { + // The reaction should not have been called at tags larger than (10 + // msec, 9) + char time[255]; + lf_print_error_and_exit("Invoked reaction(in) at tag (%llu, %d) which is bigger than shutdown.", + current_tag.time - lf_time_start(), current_tag.microstep); + } else if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 8}) == 0) { + // Call lf_request_stop() at relative tag (10 msec, 8) + lf_print("Requesting stop."); + lf_request_stop(); + } else if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) == 0) { + // Check that this reaction is indeed also triggered at (10 msec, 9) + // printf("Reaction invoked.\n"); + self->reaction_invoked_correctly = true; + } + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - lf_print("Shutdown invoked at tag (%lld, %u).", current_tag.time - lf_time_start(), current_tag.microstep); - // Check to see if shutdown is called at relative tag (10 msec, 9) - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) == 0 && - self->reaction_invoked_correctly == true) { - lf_print("SUCCESS: successfully enforced stop."); - } else if(lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) > 0) { - lf_print_error_and_exit("Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.", - current_tag.time - lf_time_start(), current_tag.microstep); - } else if (self->reaction_invoked_correctly == false) { - // Check to see if reactions were called correctly - lf_print_error_and_exit("Failed to invoke reaction(in) at tag (%llu, %d).", - current_tag.time - lf_time_start(), current_tag.microstep); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + lf_print("Shutdown invoked at tag (%lld, %u).", current_tag.time - lf_time_start(), current_tag.microstep); + // Check to see if shutdown is called at relative tag (10 msec, 9) + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) == 0 && + self->reaction_invoked_correctly == true) { + lf_print("SUCCESS: successfully enforced stop."); + } else if(lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(10) + lf_time_start(), .microstep = 9}) > 0) { + lf_print_error_and_exit("Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.", + current_tag.time - lf_time_start(), current_tag.microstep); + } else if (self->reaction_invoked_correctly == false) { + // Check to see if reactions were called correctly + lf_print_error_and_exit("Failed to invoke reaction(in) at tag (%llu, %d).", + current_tag.time - lf_time_start(), current_tag.microstep); + } + =} } main reactor { - consumer = new[4] Consumer() - producer = new[4] Sender(break_interval = 1 msec) + consumer = new[4] Consumer() + producer = new[4] Sender(break_interval = 1 msec) - producer.out -> consumer.in + producer.out -> consumer.in } diff --git a/test/C/src/concurrent/StopZeroThreaded.lf b/test/C/src/concurrent/StopZeroThreaded.lf index 7afd4b0069..80713d15ac 100644 --- a/test/C/src/concurrent/StopZeroThreaded.lf +++ b/test/C/src/concurrent/StopZeroThreaded.lf @@ -1,106 +1,105 @@ /** - * Test for lf_request_stop() at tag (0,0). This version uses the threaded - * runtime. + * Test for lf_request_stop() at tag (0,0). This version uses the threaded runtime. * * @author Soroush Bateni */ target C reactor Sender { - output out: int - state reaction_invoked_correctly: bool = false - timer t(0, 1 usec) - logical action act + output out: int + state reaction_invoked_correctly: bool = false + timer t(0, 1 usec) + logical action act - reaction(t) -> out, act {= - printf("Sending 42 at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_set(out, 42); - lf_schedule(act, 0); - tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; - tag_t one = (tag_t) { .time = lf_time_start(), .microstep = 1u }; - if (lf_tag_compare(lf_tag(), zero) == 0) { - // Request stop at (0,0) - printf("Requesting stop at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_request_stop(); - } else if (lf_tag_compare(lf_tag(), one) > 0) { - fprintf(stderr, "ERROR: Reaction called after shutdown at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } - =} + reaction(t) -> out, act {= + printf("Sending 42 at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_set(out, 42); + lf_schedule(act, 0); + tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; + tag_t one = (tag_t) { .time = lf_time_start(), .microstep = 1u }; + if (lf_tag_compare(lf_tag(), zero) == 0) { + // Request stop at (0,0) + printf("Requesting stop at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_request_stop(); + } else if (lf_tag_compare(lf_tag(), one) > 0) { + fprintf(stderr, "ERROR: Reaction called after shutdown at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } + =} - reaction(act) {= - // Reaction should be invoked at (0,1) - tag_t one = (tag_t) { .time = lf_time_start(), .microstep = 1u }; - if (lf_tag_compare(lf_tag(), one) == 0) { - self->reaction_invoked_correctly = true; - } - =} + reaction(act) {= + // Reaction should be invoked at (0,1) + tag_t one = (tag_t) { .time = lf_time_start(), .microstep = 1u }; + if (lf_tag_compare(lf_tag(), one) == 0) { + self->reaction_invoked_correctly = true; + } + =} - reaction(shutdown) {= - if (lf_time_logical_elapsed() != USEC(0) || - lf_tag().microstep != 1) { - fprintf(stderr, "ERROR: Sender failed to stop the program in time. " - "Stopping at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } else if (self->reaction_invoked_correctly == false) { - fprintf(stderr, "ERROR: Sender reaction(act) was not invoked. " - "Stopping at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } - printf("SUCCESS: Successfully stopped the program at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + reaction(shutdown) {= + if (lf_time_logical_elapsed() != USEC(0) || + lf_tag().microstep != 1) { + fprintf(stderr, "ERROR: Sender failed to stop the program in time. " + "Stopping at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } else if (self->reaction_invoked_correctly == false) { + fprintf(stderr, "ERROR: Sender reaction(act) was not invoked. " + "Stopping at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } + printf("SUCCESS: Successfully stopped the program at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + =} } reactor Receiver { - input in: int + input in: int - reaction(in) {= - printf("Received %d at (%lld, %u).\n", - in->value, - lf_time_logical_elapsed(), - lf_tag().microstep); - tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; - if (lf_tag_compare(lf_tag(), zero) == 0) { - // Request stop at (0,0) - printf("Requesting stop at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_request_stop(); - } - =} + reaction(in) {= + printf("Received %d at (%lld, %u).\n", + in->value, + lf_time_logical_elapsed(), + lf_tag().microstep); + tag_t zero = (tag_t) { .time = lf_time_start(), .microstep = 0u }; + if (lf_tag_compare(lf_tag(), zero) == 0) { + // Request stop at (0,0) + printf("Requesting stop at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_request_stop(); + } + =} - reaction(shutdown) {= - // Shutdown events must occur at (0, 1) on the - // receiver. - if (lf_time_logical_elapsed() != USEC(0) || - lf_tag().microstep != 1) { - fprintf(stderr, "ERROR: Receiver failed to stop the program in time. " - "Stopping at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - exit(1); - } - printf("SUCCESS: Successfully stopped the program at (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + reaction(shutdown) {= + // Shutdown events must occur at (0, 1) on the + // receiver. + if (lf_time_logical_elapsed() != USEC(0) || + lf_tag().microstep != 1) { + fprintf(stderr, "ERROR: Receiver failed to stop the program in time. " + "Stopping at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + exit(1); + } + printf("SUCCESS: Successfully stopped the program at (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep); + =} } main reactor StopZeroThreaded { - sender = new[4] Sender() - receiver = new[4] Receiver() + sender = new[4] Sender() + receiver = new[4] Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/concurrent/Threaded.lf b/test/C/src/concurrent/Threaded.lf index 01f67c1bd4..0b5f20a79c 100644 --- a/test/C/src/concurrent/Threaded.lf +++ b/test/C/src/concurrent/Threaded.lf @@ -1,67 +1,64 @@ -// Check for speedup of multithreaded execution on multicore machines. Each -// instance of TakeTime takes 200 ms to transport the input to the output. Four -// of them are instantiated. Note that without parallel execution, there is no -// way this can keep up with real time since in every 200 msec cycle it has 800 -// msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded -// version, showing that without threads, this takes more than 800 msec to -// complete 200 msec of logical time. See ThreadedMultiport for a parameterized -// version of this. +// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime +// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that +// without parallel execution, there is no way this can keep up with real time since in every 200 +// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing +// that without threads, this takes more than 800 msec to complete 200 msec of logical time. See +// ThreadedMultiport for a parameterized version of this. target C { - timeout: 2 sec, - // Disable compiler optimization so that TakeTime actually takes time. - flags: "" + timeout: 2 sec, + flags: "" // Disable compiler optimization so that TakeTime actually takes time. } reactor Source { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - lf_set(out, self->s); - self->s++; - =} + reaction(t) -> out {= + lf_set(out, self->s); + self->s++; + =} } reactor TakeTime { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= - // struct timespec sleep_time = {(time_t) 0, (long)200000000}; - // struct timespec remaining_time; - // nanosleep(&sleep_time, &remaining_time); - int offset = 0; - for (int i = 0; i < 100000000; i++) { - offset++; - } - lf_set(out, in->value + offset); - =} + reaction(in) -> out {= + // struct timespec sleep_time = {(time_t) 0, (long)200000000}; + // struct timespec remaining_time; + // nanosleep(&sleep_time, &remaining_time); + int offset = 0; + for (int i = 0; i < 100000000; i++) { + offset++; + } + lf_set(out, in->value + offset); + =} } reactor Destination(width: int = 4) { - state s: int = 400000000 - input[width] in: int + state s: int = 400000000 + input[width] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += in_width; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += in_width; + =} } main reactor(width: int = 4) { - a = new Source() - t = new[width] TakeTime() - (a.out)+ -> t.in - b = new Destination(width = width) - t.out -> b.in + a = new Source() + t = new[width] TakeTime() + (a.out)+ -> t.in + b = new Destination(width = width) + t.out -> b.in } diff --git a/test/C/src/concurrent/ThreadedMultiport.lf b/test/C/src/concurrent/ThreadedMultiport.lf index 2878393dac..b6bb6fbe8a 100644 --- a/test/C/src/concurrent/ThreadedMultiport.lf +++ b/test/C/src/concurrent/ThreadedMultiport.lf @@ -1,70 +1,69 @@ // Check multiport capabilities on Outputs. target C { - timeout: 2 sec, - // Disable compiler optimization so that TakeTime actually takes time. - flags: "" + timeout: 2 sec, + flags: "" // Disable compiler optimization so that TakeTime actually takes time. } reactor Source(width: int = 4) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < out_width; i++) { - lf_set(out[i], self->s); - } - self->s++; - =} + reaction(t) -> out {= + for(int i = 0; i < out_width; i++) { + lf_set(out[i], self->s); + } + self->s++; + =} } reactor Computation(iterations: int = 100000000) { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= - // struct timespec sleep_time = {(time_t) 0, (long)200000000}; - // struct timespec remaining_time; - // nanosleep(&sleep_time, &remaining_time); - int offset = 0; - for (int i = 0; i < self->iterations; i++) { - offset++; - } - lf_set(out, in->value + offset); - =} + reaction(in) -> out {= + // struct timespec sleep_time = {(time_t) 0, (long)200000000}; + // struct timespec remaining_time; + // nanosleep(&sleep_time, &remaining_time); + int offset = 0; + for (int i = 0; i < self->iterations; i++) { + offset++; + } + lf_set(out, in->value + offset); + =} } reactor Destination(width: int = 4, iterations: int = 100000000) { - state s: int = 0 - input[width] in: int + state s: int = 0 + input[width] in: int - reaction(in) {= - int expected = self->iterations * self->width + self->s; - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != expected) { - printf("ERROR: Expected %d.\n", expected); - exit(1); - } - self->s += self->width; - =} + reaction(in) {= + int expected = self->iterations * self->width + self->s; + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != expected) { + printf("ERROR: Expected %d.\n", expected); + exit(1); + } + self->s += self->width; + =} - reaction(shutdown) {= - if (self->s == 0) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s == 0) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor ThreadedMultiport(width: int = 4, iterations: int = 100000000) { - a = new Source(width = width) - t = new[width] Computation(iterations = iterations) - b = new Destination(width = width, iterations = iterations) - a.out -> t.in - t.out -> b.in + a = new Source(width = width) + t = new[width] Computation(iterations = iterations) + b = new Destination(width = width, iterations = iterations) + a.out -> t.in + t.out -> b.in } diff --git a/test/C/src/concurrent/ThreadedThreaded.lf b/test/C/src/concurrent/ThreadedThreaded.lf index 4037e8c193..b644256401 100644 --- a/test/C/src/concurrent/ThreadedThreaded.lf +++ b/test/C/src/concurrent/ThreadedThreaded.lf @@ -1,66 +1,64 @@ -// Check for speedup of multithreaded execution on multicore machines. Each -// instance of TakeTime takes 200 ms to transport the input to the output. Four -// of them are instantiated. Note that without parallel execution, there is no -// way this can keep up with real time since in every 200 msec cycle it has 800 -// msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. See ThreadedMultiport for a -// parameterized version of this. +// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime +// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that +// without parallel execution, there is no way this can keep up with real time since in every 200 +// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. See ThreadedMultiport for a parameterized version +// of this. target C { - timeout: 2 sec, - tracing: true, - // Disable compiler optimization so that TakeTime actually takes time. - flags: "" + timeout: 2 sec, + tracing: true, + flags: "" // Disable compiler optimization so that TakeTime actually takes time. } reactor Source { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - lf_set(out, self->s); - self->s++; - =} + reaction(t) -> out {= + lf_set(out, self->s); + self->s++; + =} } reactor TakeTime { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= - // struct timespec sleep_time = {(time_t) 0, (long)200000000}; - // struct timespec remaining_time; - // nanosleep(&sleep_time, &remaining_time); - int offset = 0; - for (int i = 0; i < 100000000; i++) { - offset++; - } - lf_set(out, in->value + offset); - =} + reaction(in) -> out {= + // struct timespec sleep_time = {(time_t) 0, (long)200000000}; + // struct timespec remaining_time; + // nanosleep(&sleep_time, &remaining_time); + int offset = 0; + for (int i = 0; i < 100000000; i++) { + offset++; + } + lf_set(out, in->value + offset); + =} } reactor Destination(width: int = 4) { - state s: int = 400000000 - input[width] in: int + state s: int = 400000000 + input[width] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += in_width; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += in_width; + =} } main reactor ThreadedThreaded(width: int = 4) { - a = new Source() - t = new[width] TakeTime() - (a.out)+ -> t.in - b = new Destination(width = width) - t.out -> b.in + a = new Source() + t = new[width] TakeTime() + (a.out)+ -> t.in + b = new Destination(width = width) + t.out -> b.in } diff --git a/test/C/src/concurrent/TimeLimitThreaded.lf b/test/C/src/concurrent/TimeLimitThreaded.lf index 8d3824af47..e1a08b06ab 100644 --- a/test/C/src/concurrent/TimeLimitThreaded.lf +++ b/test/C/src/concurrent/TimeLimitThreaded.lf @@ -1,48 +1,48 @@ -// Test that the stop function can be used to internally impose a a time limit. -// Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt. +// Test that the stop function can be used to internally impose a a time limit. Correct output for +// this 1, 2, 3, 4. Failure for this test is failing to halt. target C { - fast: true + fast: true } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - //printf("Reacting at time %ld.\n", lf_time_logical_elapsed()); - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + //printf("Reacting at time %ld.\n", lf_time_logical_elapsed()); + lf_set(y, self->count); + =} } reactor Destination { - input x: int - state s: int = 1 + input x: int + state s: int = 1 - reaction(x) {= - // printf("%d\n", x->value); - if (x->value != self->s) { - printf("Error: Expected %d and got %d.\n", self->s, x->value); - exit(1); - } - self->s++; - =} + reaction(x) {= + // printf("%d\n", x->value); + if (x->value != self->s) { + printf("Error: Expected %d and got %d.\n", self->s, x->value); + exit(1); + } + self->s++; + =} - reaction(shutdown) {= - printf("**** shutdown reaction invoked.\n"); - if (self->s != 12) { - fprintf(stderr, "ERROR: Expected 12 but got %d.\n", self->s); - exit(1); - } - =} + reaction(shutdown) {= + printf("**** shutdown reaction invoked.\n"); + if (self->s != 12) { + fprintf(stderr, "ERROR: Expected 12 but got %d.\n", self->s); + exit(1); + } + =} } main reactor(period: time = 1 sec) { - timer stop(10 sec) - c = new Clock(period = period) - d = new Destination() - c.y -> d.x + timer stop(10 sec) + c = new Clock(period = period) + d = new Destination() + c.y -> d.x - reaction(stop) {= lf_request_stop(); =} + reaction(stop) {= lf_request_stop(); =} } diff --git a/test/C/src/concurrent/TimeoutThreaded.lf b/test/C/src/concurrent/TimeoutThreaded.lf index 82ef231ed9..fe733bef56 100644 --- a/test/C/src/concurrent/TimeoutThreaded.lf +++ b/test/C/src/concurrent/TimeoutThreaded.lf @@ -1,50 +1,49 @@ /** - * A test for the timeout functionality in Lingua Franca. This version of the - * test is threaded. + * A test for the timeout functionality in Lingua Franca. This version of the test is threaded. * * @author Soroush Bateni */ target C { - timeout: 11 msec + timeout: 11 msec } import Sender from "../lib/LoopedActionSender.lf" reactor Consumer { - input in: int - state success: bool = false + input in: int + state success: bool = false - reaction(in) {= - tag_t current_tag = lf_tag(); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) > 0) { - fprintf(stderr,"ERROR: Tag (%lld, %d) received. Failed to enforce timeout.\n", - current_tag.time, current_tag.microstep); - exit(1); - } else if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) == 0) { - self->success = true; // Successfully invoked the reaction at (timeout, 0) - } - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) > 0) { + fprintf(stderr,"ERROR: Tag (%lld, %d) received. Failed to enforce timeout.\n", + current_tag.time, current_tag.microstep); + exit(1); + } else if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) == 0) { + self->success = true; // Successfully invoked the reaction at (timeout, 0) + } + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) == 0 && - self->success == true) { - printf("SUCCESS: successfully enforced timeout.\n"); - } else { - fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", - current_tag.time - lf_time_start(), current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(11) + lf_time_start(), .microstep = 0}) == 0 && + self->success == true) { + printf("SUCCESS: successfully enforced timeout.\n"); + } else { + fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", + current_tag.time - lf_time_start(), current_tag.microstep); + exit(1); + } + =} } main reactor { - consumer = new[4] Consumer() - producer = new[4] Sender(break_interval = 1 msec) + consumer = new[4] Consumer() + producer = new[4] Sender(break_interval = 1 msec) - producer.out -> consumer.in + producer.out -> consumer.in } diff --git a/test/C/src/concurrent/TimeoutZeroThreaded.lf b/test/C/src/concurrent/TimeoutZeroThreaded.lf index 7865b486a9..5a33aa3c4c 100644 --- a/test/C/src/concurrent/TimeoutZeroThreaded.lf +++ b/test/C/src/concurrent/TimeoutZeroThreaded.lf @@ -1,50 +1,50 @@ /** - * A test for the timeout functionality in Lingua Franca. This variant tests - * timeout at (0,0) and uses the threaded runtime. + * A test for the timeout functionality in Lingua Franca. This variant tests timeout at (0,0) and + * uses the threaded runtime. * * @author Soroush Bateni */ target C { - timeout: 0 sec + timeout: 0 sec } import Sender from "../lib/LoopedActionSender.lf" reactor Consumer { - input in: int - state success: bool = false + input in: int + state success: bool = false - reaction(in) {= - tag_t current_tag = lf_tag(); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) > 0) { - fprintf(stderr,"ERROR: Tag (%lld, %d) received. Failed to enforce timeout.\n", - current_tag.time - lf_time_start(), current_tag.microstep); - exit(1); - } else if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) == 0) { - self->success = true; // Successfully invoked the reaction at (timeout, 0) - } - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) > 0) { + fprintf(stderr,"ERROR: Tag (%lld, %d) received. Failed to enforce timeout.\n", + current_tag.time - lf_time_start(), current_tag.microstep); + exit(1); + } else if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) == 0) { + self->success = true; // Successfully invoked the reaction at (timeout, 0) + } + =} - reaction(shutdown) {= - tag_t current_tag = lf_tag(); - printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); - if (lf_tag_compare(current_tag, - (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) == 0 && - self->success == true) { - printf("SUCCESS: successfully enforced timeout.\n"); - } else { - fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", - current_tag.time - lf_time_start(), current_tag.microstep); - exit(1); - } - =} + reaction(shutdown) {= + tag_t current_tag = lf_tag(); + printf("Shutdown invoked at tag (%lld, %u).\n", current_tag.time - lf_time_start(), current_tag.microstep); + if (lf_tag_compare(current_tag, + (tag_t) { .time = MSEC(0) + lf_time_start(), .microstep = 0}) == 0 && + self->success == true) { + printf("SUCCESS: successfully enforced timeout.\n"); + } else { + fprintf(stderr,"ERROR: Shutdown invoked at tag (%llu, %d). Failed to enforce timeout.\n", + current_tag.time - lf_time_start(), current_tag.microstep); + exit(1); + } + =} } main reactor { - consumer = new[4] Consumer() - producer = new[4] Sender(break_interval = 1 msec) + consumer = new[4] Consumer() + producer = new[4] Sender(break_interval = 1 msec) - producer.out -> consumer.in + producer.out -> consumer.in } diff --git a/test/C/src/concurrent/Tracing.lf b/test/C/src/concurrent/Tracing.lf index cbc4513732..25d0157ab5 100644 --- a/test/C/src/concurrent/Tracing.lf +++ b/test/C/src/concurrent/Tracing.lf @@ -1,99 +1,98 @@ // Version of ThreadedThreaded used to test tracing functions. target C { - timeout: 2 sec, - tracing: true, - // Disable compiler optimization so that TakeTime actually takes time. - flags: "", - logging: DEBUG + timeout: 2 sec, + tracing: true, + flags: "", // Disable compiler optimization so that TakeTime actually takes time. + logging: DEBUG } preamble {= - #include + #include =} reactor Source { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - lf_set(out, self->s); - self->s++; - =} + reaction(t) -> out {= + lf_set(out, self->s); + self->s++; + =} } reactor TakeTime(bank_index: int = 0) { - input in: int - output out: int - state event: char* = "No ID" + input in: int + output out: int + state event: char* = "No ID" - reaction(startup) {= - // Construct an id string for a user trace event. - const char* format = "Count completed by reactor %d."; - size_t length = strlen(format) + 2; - self->event = (char*)malloc(sizeof(char) * (length + 1)); - snprintf(self->event, length, format, self->bank_index); + reaction(startup) {= + // Construct an id string for a user trace event. + const char* format = "Count completed by reactor %d."; + size_t length = strlen(format) + 2; + self->event = (char*)malloc(sizeof(char) * (length + 1)); + snprintf(self->event, length, format, self->bank_index); - // Register the user trace event. - if (!register_user_trace_event(self->event)) { - fprintf(stderr, "ERROR: Failed to register trace event.\n"); - exit(1); - } - =} + // Register the user trace event. + if (!register_user_trace_event(self->event)) { + fprintf(stderr, "ERROR: Failed to register trace event.\n"); + exit(1); + } + =} - reaction(in) -> out {= - // struct timespec sleep_time = {(time_t) 0, (long)200000000}; - // struct timespec remaining_time; - // nanosleep(&sleep_time, &remaining_time); - int offset = 0; - for (int i = 0; i < 100000000; i++) { - offset++; - } - tracepoint_user_event(self->event); - lf_set(out, in->value + offset); - =} + reaction(in) -> out {= + // struct timespec sleep_time = {(time_t) 0, (long)200000000}; + // struct timespec remaining_time; + // nanosleep(&sleep_time, &remaining_time); + int offset = 0; + for (int i = 0; i < 100000000; i++) { + offset++; + } + tracepoint_user_event(self->event); + lf_set(out, in->value + offset); + =} - reaction(shutdown) {= - // NOTE: Can't actually free this because the tracepoint - // code runs after shutdown events are processed and the - // string id of the event may get corrupted. - // free(self->event); - =} + reaction(shutdown) {= + // NOTE: Can't actually free this because the tracepoint + // code runs after shutdown events are processed and the + // string id of the event may get corrupted. + // free(self->event); + =} } reactor Destination(width: int = 4) { - state s: int = 400000000 - state count: int = 0 - input[width] in: int + state s: int = 400000000 + state count: int = 0 + input[width] in: int - reaction(startup) {= - // Register the user value event. - if (!register_user_trace_event("Number of Destination invocations")) { - fprintf(stderr, "ERROR: Failed to register trace event.\n"); - exit(1); - } - =} + reaction(startup) {= + // Register the user value event. + if (!register_user_trace_event("Number of Destination invocations")) { + fprintf(stderr, "ERROR: Failed to register trace event.\n"); + exit(1); + } + =} - reaction(in) {= - self->count++; - tracepoint_user_value("Number of Destination invocations", self->count); - int sum = 0; - for (int i = 0; i < in_width; i++) { - sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += in_width; - =} + reaction(in) {= + self->count++; + tracepoint_user_value("Number of Destination invocations", self->count); + int sum = 0; + for (int i = 0; i < in_width; i++) { + sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += in_width; + =} } main reactor(width: int = 4) { - a = new Source() - t = new[width] TakeTime() - (a.out)+ -> t.in - b = new Destination(width = width) - t.out -> b.in + a = new Source() + t = new[width] TakeTime() + (a.out)+ -> t.in + b = new Destination(width = width) + t.out -> b.in } diff --git a/test/C/src/docker/federated/DistributedCountContainerized.lf b/test/C/src/docker/federated/DistributedCountContainerized.lf index 4a120c5e1e..d7f5fc2cdb 100644 --- a/test/C/src/docker/federated/DistributedCountContainerized.lf +++ b/test/C/src/docker/federated/DistributedCountContainerized.lf @@ -1,24 +1,21 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { - timeout: 5 sec, - logging: DEBUG, - coordination: centralized, - docker: true + timeout: 5 sec, + logging: DEBUG, + coordination: centralized, + docker: true } import Count from "../../lib/Count.lf" import Print from "../../federated/DistributedCount.lf" -federated reactor DistributedCountContainerized( - offset: time = 200 msec -) at rti { - c = new Count() - p = new Print() - c.out -> p.in after offset +federated reactor DistributedCountContainerized(offset: time = 200 msec) at rti { + c = new Count() + p = new Print() + c.out -> p.in after offset } diff --git a/test/C/src/federated/BroadcastFeedback.lf b/test/C/src/federated/BroadcastFeedback.lf index 2bef908d2d..b1fa201ed5 100644 --- a/test/C/src/federated/BroadcastFeedback.lf +++ b/test/C/src/federated/BroadcastFeedback.lf @@ -1,33 +1,31 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target C { - timeout: 1 sec, - build-type: RelWithDebInfo + timeout: 1 sec, + build-type: RelWithDebInfo } reactor SenderAndReceiver { - output out: int - input[2] in: int - state received: bool = false + output out: int + input[2] in: int + state received: bool = false - reaction(startup) -> out {= lf_set(out, 42); =} + reaction(startup) -> out {= lf_set(out, 42); =} - reaction(in) {= - if (in[0]->is_present && in[1]->is_present && in[0]->value == 42 && in[1]->value == 42) { - lf_print("SUCCESS"); - self->received = true; - } - =} + reaction(in) {= + if (in[0]->is_present && in[1]->is_present && in[0]->value == 42 && in[1]->value == 42) { + lf_print("SUCCESS"); + self->received = true; + } + =} - reaction(shutdown) {= - if (!self->received == true) { - lf_print_error_and_exit("Failed to receive broadcast"); - } - =} + reaction(shutdown) {= + if (!self->received == true) { + lf_print_error_and_exit("Failed to receive broadcast"); + } + =} } federated reactor { - s = new[2] SenderAndReceiver() - (s.out)+ -> s.in + s = new[2] SenderAndReceiver() + (s.out)+ -> s.in } diff --git a/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf b/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf index d9edbc954b..fe269ce401 100644 --- a/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf +++ b/test/C/src/federated/BroadcastFeedbackWithHierarchy.lf @@ -1,40 +1,38 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target C { - timeout: 1 sec + timeout: 1 sec } reactor SenderAndReceiver { - output out: int - input[2] in: int - state received: bool = false + output out: int + input[2] in: int + state received: bool = false - r = new Receiver() - in -> r.in + r = new Receiver() + in -> r.in - reaction(startup) -> out {= lf_set(out, 42); =} + reaction(startup) -> out {= lf_set(out, 42); =} } reactor Receiver { - input[2] in: int - state received: bool = false + input[2] in: int + state received: bool = false - reaction(in) {= - if (in[0]->is_present && in[1]->is_present && in[0]->value == 42 && in[1]->value == 42) { - lf_print("SUCCESS"); - self->received = true; - } - =} + reaction(in) {= + if (in[0]->is_present && in[1]->is_present && in[0]->value == 42 && in[1]->value == 42) { + lf_print("SUCCESS"); + self->received = true; + } + =} - reaction(shutdown) {= - if (!self->received == true) { - lf_print_error_and_exit("Failed to receive broadcast"); - } - =} + reaction(shutdown) {= + if (!self->received == true) { + lf_print_error_and_exit("Failed to receive broadcast"); + } + =} } federated reactor { - s = new[2] SenderAndReceiver() - (s.out)+ -> s.in + s = new[2] SenderAndReceiver() + (s.out)+ -> s.in } diff --git a/test/C/src/federated/CycleDetection.lf b/test/C/src/federated/CycleDetection.lf index d22837bc1f..5e6b3b868d 100644 --- a/test/C/src/federated/CycleDetection.lf +++ b/test/C/src/federated/CycleDetection.lf @@ -1,58 +1,58 @@ /** - * Check whether the internally generated network and control reactions - * introduce a cycle or not. The failure for this test is not being compiled. + * Check whether the internally generated network and control reactions introduce a cycle or not. + * The failure for this test is not being compiled. * @author Edward A. Lee */ target C reactor CAReplica { - input local_update: int - input remote_update: int - input query: int + input local_update: int + input remote_update: int + input query: int - state balance: int = 0 + state balance: int = 0 - output response: int + output response: int - reaction(local_update, remote_update) {= - if (local_update->is_present) { - self->balance += local_update->value; - } - if (remote_update->is_present) { - self->balance += remote_update->value; - } - =} + reaction(local_update, remote_update) {= + if (local_update->is_present) { + self->balance += local_update->value; + } + if (remote_update->is_present) { + self->balance += remote_update->value; + } + =} - reaction(query) -> response {= lf_set(response, self->balance); =} + reaction(query) -> response {= lf_set(response, self->balance); =} } reactor UserInput { - input balance: int - output deposit: int + input balance: int + output deposit: int - reaction(startup) -> deposit {= lf_set(deposit, 100); =} + reaction(startup) -> deposit {= lf_set(deposit, 100); =} - reaction(balance) {= - if (balance->value != 200) { - lf_print_error_and_exit("Did not receive the expected balance. Expected: 200. Got: %d.", balance->value); - } - lf_print("Balance: %d", balance->value); - lf_request_stop(); - =} + reaction(balance) {= + if (balance->value != 200) { + lf_print_error_and_exit("Did not receive the expected balance. Expected: 200. Got: %d.", balance->value); + } + lf_print("Balance: %d", balance->value); + lf_request_stop(); + =} - reaction(shutdown) {= lf_print("Test passed!"); =} + reaction(shutdown) {= lf_print("Test passed!"); =} } federated reactor { - u1 = new UserInput() - r1 = new CAReplica() - u2 = new UserInput() - r2 = new CAReplica() - (u1.deposit)+ -> r1.query, r1.local_update - r1.response -> u1.balance - u1.deposit -> r2.remote_update - - (u2.deposit)+ -> r2.query, r2.local_update - r2.response -> u2.balance - u2.deposit -> r1.remote_update + u1 = new UserInput() + r1 = new CAReplica() + u2 = new UserInput() + r2 = new CAReplica() + (u1.deposit)+ -> r1.query, r1.local_update + r1.response -> u1.balance + u1.deposit -> r2.remote_update + + (u2.deposit)+ -> r2.query, r2.local_update + r2.response -> u2.balance + u2.deposit -> r1.remote_update } diff --git a/test/C/src/federated/DecentralizedP2PComm.lf b/test/C/src/federated/DecentralizedP2PComm.lf index 0ca6a10e6f..bb96cb32d2 100644 --- a/test/C/src/federated/DecentralizedP2PComm.lf +++ b/test/C/src/federated/DecentralizedP2PComm.lf @@ -1,52 +1,48 @@ target C { - timeout: 1 sec, - tracing: true, - clock-sync: off, - coordination: decentralized + timeout: 1 sec, + tracing: true, + clock-sync: off, + coordination: decentralized } -reactor Platform( - start: int = 0, - expected_start: int = 0, - stp_offset_param: time = 0 -) { - input in: int - output out: int - timer t(0, 100 msec) - state count: int = start - state expected: int = expected_start +reactor Platform(start: int = 0, expected_start: int = 0, stp_offset_param: time = 0) { + input in: int + output out: int + timer t(0, 100 msec) + state count: int = start + state expected: int = expected_start - reaction(t) -> out {= lf_set(out, self->count++); =} + reaction(t) -> out {= lf_set(out, self->count++); =} - reaction(in) {= - lf_print("Received %d.", in->value); - if (in->value != self->expected_start++) { - lf_print_error_and_exit("Expected %d but got %d.", - self->expected_start - 1, - in->value - ); - } - =} STP(stp_offset_param) {= - lf_print("Received %d late.", in->value); - tag_t current_tag = lf_tag(); - self->expected_start++; - lf_print_error("STP offset was violated by (%lld, %u).", - current_tag.time - in->intended_tag.time, - current_tag.microstep - in->intended_tag.microstep + reaction(in) {= + lf_print("Received %d.", in->value); + if (in->value != self->expected_start++) { + lf_print_error_and_exit("Expected %d but got %d.", + self->expected_start - 1, + in->value ); - =} + } + =} STP(stp_offset_param) {= + lf_print("Received %d late.", in->value); + tag_t current_tag = lf_tag(); + self->expected_start++; + lf_print_error("STP offset was violated by (%lld, %u).", + current_tag.time - in->intended_tag.time, + current_tag.microstep - in->intended_tag.microstep + ); + =} - reaction(shutdown) {= - lf_print("Shutdown invoked."); - if (self->expected == self->expected_start) { - lf_print_error_and_exit("Did not receive anything."); - } - =} + reaction(shutdown) {= + lf_print("Shutdown invoked."); + if (self->expected == self->expected_start) { + lf_print_error_and_exit("Did not receive anything."); + } + =} } federated reactor DecentralizedP2PComm { - a = new Platform(expected_start = 100, stp_offset_param = 10 msec) - b = new Platform(start = 100, stp_offset_param = 10 msec) - a.out -> b.in - b.out -> a.in + a = new Platform(expected_start = 100, stp_offset_param = 10 msec) + b = new Platform(start = 100, stp_offset_param = 10 msec) + a.out -> b.in + b.out -> a.in } diff --git a/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf b/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf index 9dea4032aa..d6a372d56b 100644 --- a/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf +++ b/test/C/src/federated/DecentralizedP2PUnbalancedTimeout.lf @@ -1,55 +1,52 @@ /** - * Test a source-destination scenario where the source falls behind real-time, - * and reaches the timeout much later than the destination. In this test, the - * destination closes the connection early, causing the transmission to fail. - * Warnings will be printed about lost messages. + * Test a source-destination scenario where the source falls behind real-time, and reaches the + * timeout much later than the destination. In this test, the destination closes the connection + * early, causing the transmission to fail. Warnings will be printed about lost messages. * * The test fails if the federation does not exit. */ target C { - timeout: 1 msec, - coordination: decentralized + timeout: 1 msec, + coordination: decentralized } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - lf_print("Sending %d.", self->count); - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + lf_print("Sending %d.", self->count); + lf_set(y, self->count); + =} - reaction(shutdown) {= - lf_print("SUCCESS: the source exited successfully."); - =} + reaction(shutdown) {= lf_print("SUCCESS: the source exited successfully."); =} } reactor Destination { - input x: int - state s: int = 1 + input x: int + state s: int = 1 - reaction(x) {= - lf_print("Received %d", x->value); - tag_t current_tag = lf_tag(); - if (x->value != self->s) { - lf_print_error_and_exit("At tag (%lld, %u) expected %d and got %d.", - current_tag.time - lf_time_start(), current_tag.microstep, self->s, x->value - ); - } - self->s++; - =} + reaction(x) {= + lf_print("Received %d", x->value); + tag_t current_tag = lf_tag(); + if (x->value != self->s) { + lf_print_error_and_exit("At tag (%lld, %u) expected %d and got %d.", + current_tag.time - lf_time_start(), current_tag.microstep, self->s, x->value + ); + } + self->s++; + =} - reaction(shutdown) {= - lf_print("**** shutdown reaction invoked."); - lf_print("Approx. time per reaction: %lldns", lf_time_physical_elapsed()/(self->s+1)); - =} + reaction(shutdown) {= + lf_print("**** shutdown reaction invoked."); + lf_print("Approx. time per reaction: %lldns", lf_time_physical_elapsed()/(self->s+1)); + =} } federated reactor(period: time = 10 usec) { - c = new Clock(period = period) - d = new Destination() - c.y -> d.x + c = new Clock(period = period) + d = new Destination() + c.y -> d.x } diff --git a/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index 8468e1dc81..bb3b6544c0 100644 --- a/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/C/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -1,53 +1,50 @@ /** - * Test a source-destination scenario where the source falls behind real-time, - * and reaches the timeout much later than the destination. In this test, the - * destination closes the connection early, causing the transmission to fail. - * Warnings will be printed. + * Test a source-destination scenario where the source falls behind real-time, and reaches the + * timeout much later than the destination. In this test, the destination closes the connection + * early, causing the transmission to fail. Warnings will be printed. * - * The test fails if the federation does not exit amenably. This variant has a - * physical connection between source and destination. + * The test fails if the federation does not exit amenably. This variant has a physical connection + * between source and destination. */ target C { - timeout: 1 msec, - coordination: decentralized + timeout: 1 msec, + coordination: decentralized } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - (self->count)++; - //printf("Reacting at time %ld.\n", lf_time_logical_elapsed()); - lf_set(y, self->count); - =} + reaction(t) -> y {= + (self->count)++; + //printf("Reacting at time %ld.\n", lf_time_logical_elapsed()); + lf_set(y, self->count); + =} - reaction(shutdown) {= - lf_print("SUCCESS: the source exited successfully."); - =} + reaction(shutdown) {= lf_print("SUCCESS: the source exited successfully."); =} } reactor Destination { - input x: int - state s: int = 1 + input x: int + state s: int = 1 - reaction(x) {= - // printf("%d\n", x->value); - if (x->value != self->s) { - lf_print_error_and_exit("Expected %d and got %d.", self->s, x->value); - } - self->s++; - =} + reaction(x) {= + // printf("%d\n", x->value); + if (x->value != self->s) { + lf_print_error_and_exit("Expected %d and got %d.", self->s, x->value); + } + self->s++; + =} - reaction(shutdown) {= - lf_print("**** shutdown reaction invoked."); - lf_print("Approx. time per reaction: %lldns", lf_time_physical_elapsed()/(self->s+1)); - =} + reaction(shutdown) {= + lf_print("**** shutdown reaction invoked."); + lf_print("Approx. time per reaction: %lldns", lf_time_physical_elapsed()/(self->s+1)); + =} } federated reactor(period: time = 10 usec) { - c = new Clock(period = period) - d = new Destination() - c.y ~> d.x + c = new Clock(period = period) + d = new Destination() + c.y ~> d.x } diff --git a/test/C/src/federated/DistributedBank.lf b/test/C/src/federated/DistributedBank.lf index 84acb00031..85bc8875b7 100644 --- a/test/C/src/federated/DistributedBank.lf +++ b/test/C/src/federated/DistributedBank.lf @@ -1,22 +1,22 @@ // Check bank of federates. target C { - timeout: 1 sec, - coordination: centralized + timeout: 1 sec, + coordination: centralized } reactor Node { - timer t(0, 100 msec) - state count: int = 0 + timer t(0, 100 msec) + state count: int = 0 - reaction(t) {= lf_print("Hello world %d.", self->count++); =} + reaction(t) {= lf_print("Hello world %d.", self->count++); =} - reaction(shutdown) {= - if (self->count == 0) { - lf_print_error_and_exit("Timer reactions did not execute."); - } - =} + reaction(shutdown) {= + if (self->count == 0) { + lf_print_error_and_exit("Timer reactions did not execute."); + } + =} } federated reactor DistributedBank { - n = new[2] Node() + n = new[2] Node() } diff --git a/test/C/src/federated/DistributedBankToMultiport.lf b/test/C/src/federated/DistributedBankToMultiport.lf index 796db0718e..fdc1b67b84 100644 --- a/test/C/src/federated/DistributedBankToMultiport.lf +++ b/test/C/src/federated/DistributedBankToMultiport.lf @@ -1,33 +1,33 @@ // Check multiport to bank connections between federates. target C { - timeout: 3 sec + timeout: 3 sec } import Count from "../lib/Count.lf" reactor Destination { - input[2] in: int - state count: int = 1 + input[2] in: int + state count: int = 1 - reaction(in) {= - for (int i = 0; i < in_width; i++) { - lf_print("Received %d.", in[i]->value); - if (self->count != in[i]->value) { - lf_print_error_and_exit("Expected %d.", self->count); - } + reaction(in) {= + for (int i = 0; i < in_width; i++) { + lf_print("Received %d.", in[i]->value); + if (self->count != in[i]->value) { + lf_print_error_and_exit("Expected %d.", self->count); } - self->count++; - =} + } + self->count++; + =} - reaction(shutdown) {= - if (self->count == 0) { - lf_print_error_and_exit("No data received."); - } - =} + reaction(shutdown) {= + if (self->count == 0) { + lf_print_error_and_exit("No data received."); + } + =} } federated reactor { - s = new[2] Count() - d = new Destination() - s.out -> d.in + s = new[2] Count() + d = new Destination() + s.out -> d.in } diff --git a/test/C/src/federated/DistributedCount.lf b/test/C/src/federated/DistributedCount.lf index 2ebdda169a..9e1a1b2e93 100644 --- a/test/C/src/federated/DistributedCount.lf +++ b/test/C/src/federated/DistributedCount.lf @@ -1,42 +1,41 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { - timeout: 5 sec, - coordination: centralized + timeout: 5 sec, + coordination: centralized } import Count from "../lib/Count.lf" reactor Print { - input in: int - state c: int = 1 + input in: int + state c: int = 1 - reaction(in) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - lf_print("At time %lld, received %d", elapsed_time, in->value); - if (in->value != self->c) { - lf_print_error_and_exit("Expected to receive %d.", self->c); - } - if (elapsed_time != MSEC(200) + SEC(1) * (self->c - 1) ) { - lf_print_error_and_exit("Expected received time to be %lld.", MSEC(200) * self->c); - } - self->c++; - =} + reaction(in) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + lf_print("At time %lld, received %d", elapsed_time, in->value); + if (in->value != self->c) { + lf_print_error_and_exit("Expected to receive %d.", self->c); + } + if (elapsed_time != MSEC(200) + SEC(1) * (self->c - 1) ) { + lf_print_error_and_exit("Expected received time to be %lld.", MSEC(200) * self->c); + } + self->c++; + =} - reaction(shutdown) {= - if (self->c != 6) { - lf_print_error_and_exit("Expected to receive 5 items."); - } - =} + reaction(shutdown) {= + if (self->c != 6) { + lf_print_error_and_exit("Expected to receive 5 items."); + } + =} } federated reactor DistributedCount(offset: time = 200 msec) { - c = new Count() - p = new Print() - c.out -> p.in after offset + c = new Count() + p = new Print() + c.out -> p.in after offset } diff --git a/test/C/src/federated/DistributedCountDecentralized.lf b/test/C/src/federated/DistributedCountDecentralized.lf index 631dfab0c0..0b99861269 100644 --- a/test/C/src/federated/DistributedCountDecentralized.lf +++ b/test/C/src/federated/DistributedCountDecentralized.lf @@ -1,53 +1,51 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target C { - timeout: 5 sec, - coordination: decentralized + timeout: 5 sec, + coordination: decentralized } import Count from "../lib/Count.lf" reactor Print { - input in: int - state c: int = 1 + input in: int + state c: int = 1 - reaction(in) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("At tag (%lld, %u), received %d. " - "The original intended tag of the message was (%lld, %u).\n", - (long long int)elapsed_time, - lf_tag().microstep, - in->value, - (long long int)(in->intended_tag.time - lf_time_start()), - in->intended_tag.microstep); - if (in->value != self->c) { - printf("Expected to receive %d.\n", self->c); - exit(1); - } - if (elapsed_time != MSEC(200) + SEC(1) * (self->c - 1)) { - printf("Expected received time to be %lld.\n", MSEC(200) * self->c); - exit(3); - } - self->c++; - =} + reaction(in) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("At tag (%lld, %u), received %d. " + "The original intended tag of the message was (%lld, %u).\n", + (long long int)elapsed_time, + lf_tag().microstep, + in->value, + (long long int)(in->intended_tag.time - lf_time_start()), + in->intended_tag.microstep); + if (in->value != self->c) { + printf("Expected to receive %d.\n", self->c); + exit(1); + } + if (elapsed_time != MSEC(200) + SEC(1) * (self->c - 1)) { + printf("Expected received time to be %lld.\n", MSEC(200) * self->c); + exit(3); + } + self->c++; + =} - reaction(shutdown) {= - if (self->c != 6) { - fprintf(stderr, "Expected to receive 5 items.\n"); - exit(2); - } - printf("SUCCESS: Successfully received 5 items.\n"); - =} + reaction(shutdown) {= + if (self->c != 6) { + fprintf(stderr, "Expected to receive 5 items.\n"); + exit(2); + } + printf("SUCCESS: Successfully received 5 items.\n"); + =} } federated reactor DistributedCountDecentralized { - c = new Count() - p = new Print() - // Indicating a 'logical' connection with a large enough delay. - c.out -> p.in after 200 msec + c = new Count() + p = new Print() + c.out -> p.in after 200 msec // Indicating a 'logical' connection with a large enough delay. } diff --git a/test/C/src/federated/DistributedCountDecentralizedLate.lf b/test/C/src/federated/DistributedCountDecentralizedLate.lf index 878bc89796..d08edbdb52 100644 --- a/test/C/src/federated/DistributedCountDecentralizedLate.lf +++ b/test/C/src/federated/DistributedCountDecentralizedLate.lf @@ -1,66 +1,65 @@ /** - * Test a form of a distributed deterministic system where a federate that - * receives timestamped messages has a timer in addition to the messages as - * triggers. Therefore, careful coordination of the advancement of time using - * Ptides is needed. + * Test a form of a distributed deterministic system where a federate that receives timestamped + * messages has a timer in addition to the messages as triggers. Therefore, careful coordination of + * the advancement of time using Ptides is needed. * @author Edward A. Lee * @author Soroush Bateni */ target C { - timeout: 4900 msec, - coordination: decentralized + timeout: 4900 msec, + coordination: decentralized } import Count from "../lib/Count.lf" reactor Print { - input in: int // STP () - state success: int = 0 // STP(in, 30 msec); - state success_stp_violation: int = 0 - // Force a timer to be invoke periodically to ensure logical time will - // advance in the absence of incoming messages. - timer t(0, 10 msec) - state c: int = 0 + input in: int // STP () + state success: int = 0 // STP(in, 30 msec); + state success_stp_violation: int = 0 + // Force a timer to be invoke periodically to ensure logical time will advance in the absence of + // incoming messages. + timer t(0, 10 msec) + state c: int = 0 - reaction(in) {= - tag_t current_tag = lf_tag(); - printf("At tag (%lld, %u) received %d. Intended tag is (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep, - in->value, - in->intended_tag.time - lf_time_start(), - in->intended_tag.microstep); - if (lf_tag_compare((tag_t){.time=current_tag.time - lf_time_start(), .microstep=current_tag.microstep}, - (tag_t){.time=SEC(1) * self->c, .microstep=0}) == 0) { - self->success++; // Message was on-time - } - self->c++; - =} STP(0) {= - tag_t current_tag = lf_tag(); - printf("At tag (%lld, %u), message has violated the STP offset by (%lld, %u).\n", - current_tag.time - lf_time_start(), current_tag.microstep, - current_tag.time - in->intended_tag.time, - current_tag.microstep - in->intended_tag.microstep); - self->success_stp_violation++; - self->c++; - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + printf("At tag (%lld, %u) received %d. Intended tag is (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep, + in->value, + in->intended_tag.time - lf_time_start(), + in->intended_tag.microstep); + if (lf_tag_compare((tag_t){.time=current_tag.time - lf_time_start(), .microstep=current_tag.microstep}, + (tag_t){.time=SEC(1) * self->c, .microstep=0}) == 0) { + self->success++; // Message was on-time + } + self->c++; + =} STP(0) {= + tag_t current_tag = lf_tag(); + printf("At tag (%lld, %u), message has violated the STP offset by (%lld, %u).\n", + current_tag.time - lf_time_start(), current_tag.microstep, + current_tag.time - in->intended_tag.time, + current_tag.microstep - in->intended_tag.microstep); + self->success_stp_violation++; + self->c++; + =} - reaction(t) {= - // Do nothing. - =} + reaction(t) {= + // Do nothing. + =} - reaction(shutdown) {= - if ((self->success + self->success_stp_violation) != 5) { - fprintf(stderr, "Failed to detect STP violations in messages.\n"); - exit(1); - } else { - printf("Successfully detected STP violation (%d violations, %d on-time).\n", self->success_stp_violation, self->success); - } - =} + reaction(shutdown) {= + if ((self->success + self->success_stp_violation) != 5) { + fprintf(stderr, "Failed to detect STP violations in messages.\n"); + exit(1); + } else { + printf("Successfully detected STP violation (%d violations, %d on-time).\n", self->success_stp_violation, self->success); + } + =} } federated reactor { - c = new Count() - p = new Print() - c.out -> p.in // Indicating a 'logical' connection. + c = new Count() + p = new Print() + c.out -> p.in // Indicating a 'logical' connection. } diff --git a/test/C/src/federated/DistributedCountDecentralizedLateHierarchy.lf b/test/C/src/federated/DistributedCountDecentralizedLateHierarchy.lf index 31ab87e110..baf267ca74 100644 --- a/test/C/src/federated/DistributedCountDecentralizedLateHierarchy.lf +++ b/test/C/src/federated/DistributedCountDecentralizedLateHierarchy.lf @@ -1,97 +1,92 @@ /** - * Test a form of a distributed deterministic system where a federate that - * receives timestamped messages has a timer in addition to the messages as - * triggers. Therefore, careful coordination of the advancement of time using - * Ptides is needed. In addition, this test shows that the STP violation of the - * reaction is passed down the hierarchy until it is handled. + * Test a form of a distributed deterministic system where a federate that receives timestamped + * messages has a timer in addition to the messages as triggers. Therefore, careful coordination of + * the advancement of time using Ptides is needed. In addition, this test shows that the STP + * violation of the reaction is passed down the hierarchy until it is handled. * * @author Edward A. Lee * @author Soroush Bateni */ target C { - timeout: 4900 msec, - coordination: decentralized + timeout: 4900 msec, + coordination: decentralized } import Count from "../lib/Count.lf" reactor ImportantActuator { - input in: int - state success: int = 0 - state success_stp_violation: int = 0 - // Force a timer to be invoke periodically - timer t(0, 10 msec) - // to ensure logical time will advance in the absence of incoming messages. - state c: int = 0 + input in: int + state success: int = 0 + state success_stp_violation: int = 0 + timer t(0, 10 msec) // Force a timer to be invoke periodically + state c: int = 0 // to ensure logical time will advance in the absence of incoming messages. - reaction(in) {= - tag_t current_tag = lf_tag(); - printf("At tag (%lld, %u) received %d. Intended tag is (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep, - in->value, - in->intended_tag.time - lf_time_start(), - in->intended_tag.microstep); - if (lf_tag_compare((tag_t){.time=current_tag.time - lf_time_start(), .microstep=current_tag.microstep}, - (tag_t){.time=SEC(1) * self->c, .microstep=0}) == 0) { - self->success++; // Message was on-time - } - self->c++; - =} STP(0) {= - tag_t current_tag = lf_tag(); - printf("Message violated STP offset by (%lld, %u).\n", - current_tag.time - in->intended_tag.time, - current_tag.microstep - in->intended_tag.microstep); - self->success_stp_violation++; - self->c++; - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + printf("At tag (%lld, %u) received %d. Intended tag is (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep, + in->value, + in->intended_tag.time - lf_time_start(), + in->intended_tag.microstep); + if (lf_tag_compare((tag_t){.time=current_tag.time - lf_time_start(), .microstep=current_tag.microstep}, + (tag_t){.time=SEC(1) * self->c, .microstep=0}) == 0) { + self->success++; // Message was on-time + } + self->c++; + =} STP(0) {= + tag_t current_tag = lf_tag(); + printf("Message violated STP offset by (%lld, %u).\n", + current_tag.time - in->intended_tag.time, + current_tag.microstep - in->intended_tag.microstep); + self->success_stp_violation++; + self->c++; + =} - reaction(t) {= - // Do nothing. - =} + reaction(t) {= + // Do nothing. + =} - reaction(shutdown) {= - if ((self->success + self->success_stp_violation) != 5) { - fprintf(stderr, "Failed to detect STP violations in messages.\n"); - exit(1); - } else { - printf("Successfully detected STP violations (%d violations, %d on-time).\n", self->success_stp_violation, self->success); - } - =} + reaction(shutdown) {= + if ((self->success + self->success_stp_violation) != 5) { + fprintf(stderr, "Failed to detect STP violations in messages.\n"); + exit(1); + } else { + printf("Successfully detected STP violations (%d violations, %d on-time).\n", self->success_stp_violation, self->success); + } + =} } reactor Print { - input in: int + input in: int - reaction(in) {= - tag_t current_tag = lf_tag(); - printf("At tag (%lld, %u) received %d. Intended tag is (%lld, %u).\n", - current_tag.time - lf_time_start(), - current_tag.microstep, - in->value, - in->intended_tag.time - lf_time_start(), - in->intended_tag.microstep); - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + printf("At tag (%lld, %u) received %d. Intended tag is (%lld, %u).\n", + current_tag.time - lf_time_start(), + current_tag.microstep, + in->value, + in->intended_tag.time - lf_time_start(), + in->intended_tag.microstep); + =} } reactor Receiver { - input in: int - // Force a timer to be invoke periodically - timer t(0, 10 msec) - // to ensure logical time will advance in the absence of incoming messages. - state c: int = 0 - p = new Print() - a = new ImportantActuator() - in -> p.in - in -> a.in + input in: int + timer t(0, 10 msec) // Force a timer to be invoke periodically + state c: int = 0 // to ensure logical time will advance in the absence of incoming messages. + p = new Print() + a = new ImportantActuator() + in -> p.in + in -> a.in - reaction(t) {= - // Do nothing. - =} + reaction(t) {= + // Do nothing. + =} } federated reactor { - c = new Count() - r = new Receiver() - c.out -> r.in // Indicating a 'logical' connection. + c = new Count() + r = new Receiver() + c.out -> r.in // Indicating a 'logical' connection. } diff --git a/test/C/src/federated/DistributedCountPhysical.lf b/test/C/src/federated/DistributedCountPhysical.lf index 9e1e15f775..9baa1dd1cc 100644 --- a/test/C/src/federated/DistributedCountPhysical.lf +++ b/test/C/src/federated/DistributedCountPhysical.lf @@ -1,57 +1,57 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni */ target C { - timeout: 1 sec + timeout: 1 sec } reactor Count { - timer t(200 msec, 1 sec) - state s: int = 0 - output out: int + timer t(200 msec, 1 sec) + state s: int = 0 + output out: int - reaction(t) -> out {= - lf_set(out, self->s); - self->s++; - =} + reaction(t) -> out {= + lf_set(out, self->s); + self->s++; + =} } reactor Print { - input in: int - state c: int = 0 + input in: int + state c: int = 0 - reaction(in) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("At time %lld, received %d.\n", elapsed_time, in->value); - if (in->value != self->c) { - fprintf(stderr, "ERROR: Expected to receive %d.\n", self->c); - exit(1); - } - if (!(elapsed_time > (SEC(1) * self->c) + MSEC(200))) { - fprintf(stderr, "ERROR: Expected received time to be strictly greater than %lld. " - "Got %lld.\n", MSEC(200) * self->c, elapsed_time); - exit(3); - } - self->c++; - =} + reaction(in) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("At time %lld, received %d.\n", elapsed_time, in->value); + if (in->value != self->c) { + fprintf(stderr, "ERROR: Expected to receive %d.\n", self->c); + exit(1); + } + if (!(elapsed_time > (SEC(1) * self->c) + MSEC(200))) { + fprintf(stderr, "ERROR: Expected received time to be strictly greater than %lld. " + "Got %lld.\n", MSEC(200) * self->c, elapsed_time); + exit(3); + } + self->c++; + =} - reaction(shutdown) {= - if (self->c != 1) { - fprintf(stderr, "ERROR: Expected to receive 1 item. Received %d.\n", self->c); - exit(2); - } - printf("SUCCESS: Successfully received 1 item.\n"); - =} + reaction(shutdown) {= + if (self->c != 1) { + fprintf(stderr, "ERROR: Expected to receive 1 item. Received %d.\n", self->c); + exit(2); + } + printf("SUCCESS: Successfully received 1 item.\n"); + =} } federated reactor at localhost { - c = new Count() - p = new Print() - c.out ~> p.in // Indicating a 'physical' connection. + c = new Count() + p = new Print() + c.out ~> p.in // Indicating a 'physical' connection. } diff --git a/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf index b0da42218a..9eb2a1acff 100644 --- a/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf +++ b/test/C/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -1,7 +1,7 @@ /** - * Test a distributed system where a federation receives messages only over - * connections that are marked 'physical' (using the ~> arrow) with an after - * delay. The receiver verifies that the after delay is correctly imposed. + * Test a distributed system where a federation receives messages only over connections that are + * marked 'physical' (using the ~> arrow) with an after delay. The receiver verifies that the after + * delay is correctly imposed. * * @author Edward A. Lee * @author Soroush Bateni @@ -11,41 +11,40 @@ target C import Count from "../lib/Count.lf" reactor Print { - input in: int - state c: int = 1 + input in: int + state c: int = 1 - reaction(in) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("At time " PRINTF_TIME ", received %d.\n", elapsed_time, in->value); - if (in->value != self->c) { - fprintf(stderr, "ERROR: Expected to receive %d.\n", self->c); - exit(1); - } - if (!(elapsed_time > MSEC(600))) { - fprintf(stderr, "ERROR: Expected received time to be strictly greater than " - PRINTF_TIME ".\n", MSEC(600) - ); - exit(3); - } - self->c++; - lf_request_stop(); - =} + reaction(in) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("At time " PRINTF_TIME ", received %d.\n", elapsed_time, in->value); + if (in->value != self->c) { + fprintf(stderr, "ERROR: Expected to receive %d.\n", self->c); + exit(1); + } + if (!(elapsed_time > MSEC(600))) { + fprintf(stderr, "ERROR: Expected received time to be strictly greater than " + PRINTF_TIME ".\n", MSEC(600) + ); + exit(3); + } + self->c++; + lf_request_stop(); + =} - reaction(shutdown) {= - if (self->c != 2) { - fprintf( - stderr, "ERROR: Expected to receive 1 item. Received %d.\n", - self->c - 1 - ); - exit(2); - } - printf("SUCCESS: Successfully received 1 item.\n"); - =} + reaction(shutdown) {= + if (self->c != 2) { + fprintf( + stderr, "ERROR: Expected to receive 1 item. Received %d.\n", + self->c - 1 + ); + exit(2); + } + printf("SUCCESS: Successfully received 1 item.\n"); + =} } federated reactor at localhost { - c = new Count(offset = 200 msec, period = 0) - p = new Print() - // Indicating a 'physical' connection with a 400 msec after delay. - c.out ~> p.in after 400 msec + c = new Count(offset = 200 msec, period = 0) + p = new Print() + c.out ~> p.in after 400 msec // Indicating a 'physical' connection with a 400 msec after delay. } diff --git a/test/C/src/federated/DistributedCountPhysicalDecentralized.lf b/test/C/src/federated/DistributedCountPhysicalDecentralized.lf index e821e4fb70..581d0f9670 100644 --- a/test/C/src/federated/DistributedCountPhysicalDecentralized.lf +++ b/test/C/src/federated/DistributedCountPhysicalDecentralized.lf @@ -1,57 +1,57 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni */ target C { - timeout: 1 sec, - coordination: decentralized + timeout: 1 sec, + coordination: decentralized } reactor Count { - timer t(200 msec, 1 sec) - state s: int = 0 - output out: int + timer t(200 msec, 1 sec) + state s: int = 0 + output out: int - reaction(t) -> out {= - lf_set(out, self->s); - self->s++; - =} + reaction(t) -> out {= + lf_set(out, self->s); + self->s++; + =} } reactor Print { - input in: int - state c: int = 0 + input in: int + state c: int = 0 - reaction(in) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - printf("At time %lld, received %d.\n", elapsed_time, in->value); - if (in->value != self->c) { - fprintf(stderr, "ERROR: Expected to receive %d.\n", self->c); - exit(1); - } - if (!(elapsed_time > (SEC(1) * self->c) + MSEC(200))) { - fprintf(stderr, "ERROR: Expected received time to be strictly greater than %lld.\n", MSEC(200) * self->c); - exit(3); - } - self->c++; - =} + reaction(in) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + printf("At time %lld, received %d.\n", elapsed_time, in->value); + if (in->value != self->c) { + fprintf(stderr, "ERROR: Expected to receive %d.\n", self->c); + exit(1); + } + if (!(elapsed_time > (SEC(1) * self->c) + MSEC(200))) { + fprintf(stderr, "ERROR: Expected received time to be strictly greater than %lld.\n", MSEC(200) * self->c); + exit(3); + } + self->c++; + =} - reaction(shutdown) {= - if (self->c != 1) { - fprintf(stderr, "ERROR: Expected to receive 1 item. Received %d.\n", self->c); - exit(2); - } - printf("SUCCESS: Successfully received 1 item.\n"); - =} + reaction(shutdown) {= + if (self->c != 1) { + fprintf(stderr, "ERROR: Expected to receive 1 item. Received %d.\n", self->c); + exit(2); + } + printf("SUCCESS: Successfully received 1 item.\n"); + =} } federated reactor at localhost { - c = new Count() - p = new Print() - c.out ~> p.in // Indicating a 'physical' connection. + c = new Count() + p = new Print() + c.out ~> p.in // Indicating a 'physical' connection. } diff --git a/test/C/src/federated/DistributedDoublePort.lf b/test/C/src/federated/DistributedDoublePort.lf index 87de1ddb28..e478f8c596 100644 --- a/test/C/src/federated/DistributedDoublePort.lf +++ b/test/C/src/federated/DistributedDoublePort.lf @@ -1,50 +1,47 @@ /** - * Test the case for when two upstream federates send messages to a downstream - * federate on two different ports. One message should carry a microstep delay - * relative to the other message. + * Test the case for when two upstream federates send messages to a downstream federate on two + * different ports. One message should carry a microstep delay relative to the other message. * * @author Soroush Bateni */ target C { - timeout: 900 msec, - logging: DEBUG, - coordination: centralized + timeout: 900 msec, + logging: DEBUG, + coordination: centralized } import Count from "../lib/Count.lf" reactor CountMicrostep { - state count: int = 1 - output out: int - logical action act: int - timer t(0, 1 sec) + state count: int = 1 + output out: int + logical action act: int + timer t(0, 1 sec) - reaction(t) -> act {= lf_schedule_int(act, 0, self->count++); =} + reaction(t) -> act {= lf_schedule_int(act, 0, self->count++); =} - reaction(act) -> out {= lf_set(out, act->value); =} + reaction(act) -> out {= lf_set(out, act->value); =} } reactor Print { - input in: int - input in2: int - - reaction(in, in2) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - lf_print("At tag (%lld, %u), received in = %d and in2 = %d.", elapsed_time, lf_tag().microstep, in->value, in2->value); - if (in->is_present && in2->is_present) { - lf_print_error_and_exit("ERROR: invalid logical simultaneity."); - } - =} - - reaction(shutdown) {= - lf_print("SUCCESS: messages were at least one microstep apart."); - =} + input in: int + input in2: int + + reaction(in, in2) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + lf_print("At tag (%lld, %u), received in = %d and in2 = %d.", elapsed_time, lf_tag().microstep, in->value, in2->value); + if (in->is_present && in2->is_present) { + lf_print_error_and_exit("ERROR: invalid logical simultaneity."); + } + =} + + reaction(shutdown) {= lf_print("SUCCESS: messages were at least one microstep apart."); =} } federated reactor DistributedDoublePort { - c = new Count() - cm = new CountMicrostep() - p = new Print() - c.out -> p.in // Indicating a 'logical' connection. - cm.out -> p.in2 + c = new Count() + cm = new CountMicrostep() + p = new Print() + c.out -> p.in // Indicating a 'logical' connection. + cm.out -> p.in2 } diff --git a/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf b/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf index acbbaf4035..87dd86229e 100644 --- a/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedLogicalActionUpstreamLong.lf @@ -1,62 +1,62 @@ /** - * Test that a rapidly produced logical action in an upstream federate can be - * properly handled in a long chain of federates. + * Test that a rapidly produced logical action in an upstream federate can be properly handled in a + * long chain of federates. */ target C { - timeout: 1 msec + timeout: 1 msec } import PassThrough from "../lib/PassThrough.lf" import TestCount from "../lib/TestCount.lf" reactor WithLogicalAction { - output out: int - state thread_id: lf_thread_t = 0 - state counter: int = 1 - logical action act(0): int + output out: int + state thread_id: lf_thread_t = 0 + state counter: int = 1 + logical action act(0): int - reaction(startup, act) -> act, out {= - lf_set(out, self->counter); - lf_schedule_int(act, USEC(50), self->counter++); - =} + reaction(startup, act) -> act, out {= + lf_set(out, self->counter); + lf_schedule_int(act, USEC(50), self->counter++); + =} } federated reactor { - a = new WithLogicalAction() - test = new TestCount(num_inputs = 21) + a = new WithLogicalAction() + test = new TestCount(num_inputs = 21) - passThroughs1 = new PassThrough() - passThroughs2 = new PassThrough() - passThroughs3 = new PassThrough() - passThroughs4 = new PassThrough() - passThroughs5 = new PassThrough() - passThroughs6 = new PassThrough() - passThroughs7 = new PassThrough() - passThroughs8 = new PassThrough() - passThroughs9 = new PassThrough() - passThroughs10 = new PassThrough() + passThroughs1 = new PassThrough() + passThroughs2 = new PassThrough() + passThroughs3 = new PassThrough() + passThroughs4 = new PassThrough() + passThroughs5 = new PassThrough() + passThroughs6 = new PassThrough() + passThroughs7 = new PassThrough() + passThroughs8 = new PassThrough() + passThroughs9 = new PassThrough() + passThroughs10 = new PassThrough() - a.out, - passThroughs1.out, - passThroughs2.out, - passThroughs3.out, - passThroughs4.out, - passThroughs5.out, - passThroughs6.out, - passThroughs7.out, - passThroughs8.out, - passThroughs9.out, - passThroughs10.out - -> - passThroughs1.in, - passThroughs2.in, - passThroughs3.in, - passThroughs4.in, - passThroughs5.in, - passThroughs6.in, - passThroughs7.in, - passThroughs8.in, - passThroughs9.in, - passThroughs10.in, - test.in + a.out, + passThroughs1.out, + passThroughs2.out, + passThroughs3.out, + passThroughs4.out, + passThroughs5.out, + passThroughs6.out, + passThroughs7.out, + passThroughs8.out, + passThroughs9.out, + passThroughs10.out + -> + passThroughs1.in, + passThroughs2.in, + passThroughs3.in, + passThroughs4.in, + passThroughs5.in, + passThroughs6.in, + passThroughs7.in, + passThroughs8.in, + passThroughs9.in, + passThroughs10.in, + test.in } diff --git a/test/C/src/federated/DistributedLoopedAction.lf b/test/C/src/federated/DistributedLoopedAction.lf index 8218e73646..db26c1b462 100644 --- a/test/C/src/federated/DistributedLoopedAction.lf +++ b/test/C/src/federated/DistributedLoopedAction.lf @@ -1,67 +1,62 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. + * Test a sender-receiver network system that relies on microsteps being taken into account. * * @author Soroush Bateni */ target C { - timeout: 1 sec + timeout: 1 sec } import Sender from "../lib/LoopedActionSender.lf" -reactor Receiver( - take_a_break_after: int = 10, - break_interval: time = 400 msec -) { - input in: int - state received_messages: int = 0 - state total_received_messages: int = 0 - state breaks: int = 0 - timer t(0, 1 msec) // This will impact the performance - - // but forces the logical time to advance Comment this line for a more - // sensible log output. - reaction(in) {= - printf("At tag (%lld, %u) received value %d.\n", - lf_time_logical_elapsed(), - lf_tag().microstep, - in->value); - self->total_received_messages++; - if (in->value != self->received_messages++) { - fprintf(stderr,"ERROR: received messages out of order.\n"); - // exit(1); - } - if (lf_time_logical_elapsed() != self->breaks * self->break_interval) { - fprintf(stderr,"ERROR: received messages at an incorrect time: %lld.\n", lf_time_logical_elapsed()); - // exit(2); - } - - if (self->received_messages == self->take_a_break_after) { - // Sender is taking a break; - self->breaks++; - self->received_messages = 0; - } - =} - - reaction(t) {= - // Do nothing - =} - - reaction(shutdown) {= - if (self->breaks != 3 || - (self->total_received_messages != ((SEC(1)/self->break_interval)+1) * self->take_a_break_after) - ) { - fprintf(stderr,"ERROR: test failed.\n"); - exit(4); - } - printf("SUCCESS: Successfully received all messages from the sender.\n"); - =} +reactor Receiver(take_a_break_after: int = 10, break_interval: time = 400 msec) { + input in: int + state received_messages: int = 0 + state total_received_messages: int = 0 + state breaks: int = 0 + timer t(0, 1 msec) // This will impact the performance + + // but forces the logical time to advance Comment this line for a more sensible log output. + reaction(in) {= + printf("At tag (%lld, %u) received value %d.\n", + lf_time_logical_elapsed(), + lf_tag().microstep, + in->value); + self->total_received_messages++; + if (in->value != self->received_messages++) { + fprintf(stderr,"ERROR: received messages out of order.\n"); + // exit(1); + } + if (lf_time_logical_elapsed() != self->breaks * self->break_interval) { + fprintf(stderr,"ERROR: received messages at an incorrect time: %lld.\n", lf_time_logical_elapsed()); + // exit(2); + } + + if (self->received_messages == self->take_a_break_after) { + // Sender is taking a break; + self->breaks++; + self->received_messages = 0; + } + =} + + reaction(t) {= + // Do nothing + =} + + reaction(shutdown) {= + if (self->breaks != 3 || + (self->total_received_messages != ((SEC(1)/self->break_interval)+1) * self->take_a_break_after) + ) { + fprintf(stderr,"ERROR: test failed.\n"); + exit(4); + } + printf("SUCCESS: Successfully received all messages from the sender.\n"); + =} } federated reactor DistributedLoopedAction { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/federated/DistributedLoopedActionDecentralized.lf b/test/C/src/federated/DistributedLoopedActionDecentralized.lf index 17842809fa..0d364f026d 100644 --- a/test/C/src/federated/DistributedLoopedActionDecentralized.lf +++ b/test/C/src/federated/DistributedLoopedActionDecentralized.lf @@ -1,125 +1,117 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. The purpose of this test is to check whether the - * functionalities pertinent to dynamic STP offset adjustments are present and - * functioning to a degree. + * Test a sender-receiver network system that relies on microsteps being taken into account. The + * purpose of this test is to check whether the functionalities pertinent to dynamic STP offset + * adjustments are present and functioning to a degree. * - * This version of the test does not use a centralized coordinator to advance - * tag. Therefore, the receiver will rely on an STP offset (initially zero) to - * wait long enough for messages to arrive before advancing its tag. In this - * test, the STP offset is initially zero and gradually raised every time an STP - * violation is perceived until no STP violation is observed. Therefore, the - * exact outcome of the test will depend on actual runtime timing. + * This version of the test does not use a centralized coordinator to advance tag. Therefore, the + * receiver will rely on an STP offset (initially zero) to wait long enough for messages to arrive + * before advancing its tag. In this test, the STP offset is initially zero and gradually raised + * every time an STP violation is perceived until no STP violation is observed. Therefore, the exact + * outcome of the test will depend on actual runtime timing. * * @author Soroush Bateni */ target C { - timeout: 1 sec, - coordination: decentralized + timeout: 1 sec, + coordination: decentralized } import Sender from "../lib/LoopedActionSender.lf" -reactor Receiver( - take_a_break_after: int = 10, - break_interval: time = 400 msec -) { - input in: int - state received_messages: int = 0 - state total_received_messages: int = 0 - state breaks: int = 0 +reactor Receiver(take_a_break_after: int = 10, break_interval: time = 400 msec) { + input in: int + state received_messages: int = 0 + state total_received_messages: int = 0 + state breaks: int = 0 - reaction(in) {= - tag_t current_tag = lf_tag(); - lf_print("At tag (%lld, %u) received value %d with STP violation (%lld, %u).", - current_tag.time - lf_time_start(), - current_tag.microstep, - in->value, - current_tag.time - in->intended_tag.time, - current_tag.microstep - in->intended_tag.microstep - ); - self->total_received_messages++; - if (in->value != lf_tag().microstep) { - lf_print_warning("Received incorrect value %d. Expected %d.", in->value, lf_tag().microstep); - // exit(1); // The receiver should tolerate this type of error - // in this test because messages on the network can - // arrive late. Note that with an accurate STP offset, - // this type of error should be extremely rare. + reaction(in) {= + tag_t current_tag = lf_tag(); + lf_print("At tag (%lld, %u) received value %d with STP violation (%lld, %u).", + current_tag.time - lf_time_start(), + current_tag.microstep, + in->value, + current_tag.time - in->intended_tag.time, + current_tag.microstep - in->intended_tag.microstep + ); + self->total_received_messages++; + if (in->value != lf_tag().microstep) { + lf_print_warning("Received incorrect value %d. Expected %d.", in->value, lf_tag().microstep); + // exit(1); // The receiver should tolerate this type of error + // in this test because messages on the network can + // arrive late. Note that with an accurate STP offset, + // this type of error should be extremely rare. - } - if (in->value != self->received_messages) { - lf_print_warning("Skipped expected value %d. Received value %d.", self->received_messages, in->value); - self->received_messages = in->value; - // exit(1); // The receiver should tolerate this type of error - // in this test because multiple messages arriving - // at a given tag (t, m) can overwrite each other. - // Because messages arrive in order, only the last - // value that is received on the port at a given tag - // can be observed. Note that with an accurate STP - // offset, this type of error should be extremely - // rare. - // FIXME: Messages should not be dropped or - // overwritten. - } - self->received_messages++; - if (self->received_messages == self->take_a_break_after) { - // Sender is taking a break; - self->breaks++; - self->received_messages = 0; - } - =} + } + if (in->value != self->received_messages) { + lf_print_warning("Skipped expected value %d. Received value %d.", self->received_messages, in->value); + self->received_messages = in->value; + // exit(1); // The receiver should tolerate this type of error + // in this test because multiple messages arriving + // at a given tag (t, m) can overwrite each other. + // Because messages arrive in order, only the last + // value that is received on the port at a given tag + // can be observed. Note that with an accurate STP + // offset, this type of error should be extremely + // rare. + // FIXME: Messages should not be dropped or + // overwritten. + } + self->received_messages++; + if (self->received_messages == self->take_a_break_after) { + // Sender is taking a break; + self->breaks++; + self->received_messages = 0; + } + =} - reaction(shutdown) {= - if (self->breaks != 3 || - (self->total_received_messages != ((SEC(1)/self->break_interval)+1) * self->take_a_break_after) - ) { - lf_print_error_and_exit("Test failed. Breaks: %d, Messages: %d.", self->breaks, self->total_received_messages); - } - lf_print("SUCCESS: Successfully received all messages from the sender. Breaks: %d, Messages: %d.", self->breaks, self->total_received_messages); - =} + reaction(shutdown) {= + if (self->breaks != 3 || + (self->total_received_messages != ((SEC(1)/self->break_interval)+1) * self->take_a_break_after) + ) { + lf_print_error_and_exit("Test failed. Breaks: %d, Messages: %d.", self->breaks, self->total_received_messages); + } + lf_print("SUCCESS: Successfully received all messages from the sender. Breaks: %d, Messages: %d.", self->breaks, self->total_received_messages); + =} } reactor STPReceiver( - take_a_break_after: int = 10, - break_interval: time = 400 msec, - stp_offset: time = 0 + take_a_break_after: int = 10, + break_interval: time = 400 msec, + stp_offset: time = 0 ) { - input in: int - state last_time_updated_stp: time = 0 - receiver = new Receiver(take_a_break_after = 10, break_interval = 400 msec) - timer t(0, 1 msec) // Force advancement of logical time + input in: int + state last_time_updated_stp: time = 0 + receiver = new Receiver(take_a_break_after = 10, break_interval = 400 msec) + timer t(0, 1 msec) // Force advancement of logical time - reaction(in) -> receiver.in {= - lf_print("Received %d.", in->value); - lf_set(receiver.in, in->value); - =} STP(stp_offset) {= - lf_print("Received %d late.", in->value); - tag_t current_tag = lf_tag(); - lf_print("STP violation of (%lld, %u) perceived on the input.", - current_tag.time - in->intended_tag.time, - current_tag.microstep - in->intended_tag.microstep); - lf_set(receiver.in, in->value); - // Only update the STP offset once per - // time step. - if (current_tag.time != self->last_time_updated_stp) { - lf_print("Raising the STP offset by %lld.", MSEC(10)); - self->stp_offset += MSEC(10); - lf_set_stp_offset(MSEC(10)); - self->last_time_updated_stp = current_tag.time; - } - =} + reaction(in) -> receiver.in {= + lf_print("Received %d.", in->value); + lf_set(receiver.in, in->value); + =} STP(stp_offset) {= + lf_print("Received %d late.", in->value); + tag_t current_tag = lf_tag(); + lf_print("STP violation of (%lld, %u) perceived on the input.", + current_tag.time - in->intended_tag.time, + current_tag.microstep - in->intended_tag.microstep); + lf_set(receiver.in, in->value); + // Only update the STP offset once per + // time step. + if (current_tag.time != self->last_time_updated_stp) { + lf_print("Raising the STP offset by %lld.", MSEC(10)); + self->stp_offset += MSEC(10); + lf_set_stp_offset(MSEC(10)); + self->last_time_updated_stp = current_tag.time; + } + =} - reaction(t) {= - // Do nothing - =} + reaction(t) {= + // Do nothing + =} } federated reactor DistributedLoopedActionDecentralized { - sender = new Sender(take_a_break_after = 10, break_interval = 400 msec) - stpReceiver = new STPReceiver( - take_a_break_after = 10, - break_interval = 400 msec - ) + sender = new Sender(take_a_break_after = 10, break_interval = 400 msec) + stpReceiver = new STPReceiver(take_a_break_after = 10, break_interval = 400 msec) - sender.out -> stpReceiver.in + sender.out -> stpReceiver.in } diff --git a/test/C/src/federated/DistributedLoopedPhysicalAction.lf b/test/C/src/federated/DistributedLoopedPhysicalAction.lf index 454577ff35..dd7375cdb7 100644 --- a/test/C/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/C/src/federated/DistributedLoopedPhysicalAction.lf @@ -1,87 +1,82 @@ /** - * Test a sender-receiver network system that is similar to - * DistributedLoopedAction, but it uses a physical action rather than a logical - * action. This also demonstrates the advance-message-interval coordination - * option. This specifies the time period between Time Advance Notice (TAN) - * messages sent to the RTI (a form of null message that must be sent because of - * the physical action). The presence of this option also silences a warning - * about having a physical action that triggers an output. + * Test a sender-receiver network system that is similar to DistributedLoopedAction, but it uses a + * physical action rather than a logical action. This also demonstrates the advance-message-interval + * coordination option. This specifies the time period between Time Advance Notice (TAN) messages + * sent to the RTI (a form of null message that must be sent because of the physical action). The + * presence of this option also silences a warning about having a physical action that triggers an + * output. * * @author Soroush Bateni */ target C { - timeout: 1 sec, - coordination-options: { // Silences warning. - advance-message-interval: 10 msec - } + timeout: 1 sec, + coordination-options: { // Silences warning. + advance-message-interval: 10 msec + } } reactor Sender(take_a_break_after: int = 10, break_interval: time = 550 msec) { - output out: int - physical action act - state sent_messages: int = 0 + output out: int + physical action act + state sent_messages: int = 0 - reaction(startup, act) -> act, out {= - // Send a message on out - lf_set(out, self->sent_messages); - self->sent_messages++; - if (self->sent_messages < self->take_a_break_after) { - lf_schedule(act, 0); - } else { - // Take a break - self->sent_messages = 0; - lf_schedule(act, self->break_interval); - } - =} + reaction(startup, act) -> act, out {= + // Send a message on out + lf_set(out, self->sent_messages); + self->sent_messages++; + if (self->sent_messages < self->take_a_break_after) { + lf_schedule(act, 0); + } else { + // Take a break + self->sent_messages = 0; + lf_schedule(act, self->break_interval); + } + =} } -reactor Receiver( - take_a_break_after: int = 10, - break_interval: time = 550 msec -) { - input in: int - state received_messages: int = 0 - state total_received_messages: int = 0 - state breaks: int = 0 - timer t(0, 1 msec) // This will impact the performance +reactor Receiver(take_a_break_after: int = 10, break_interval: time = 550 msec) { + input in: int + state received_messages: int = 0 + state total_received_messages: int = 0 + state breaks: int = 0 + timer t(0, 1 msec) // This will impact the performance - // but forces the logical time to advance Comment this line for a more - // sensible log output. - reaction(in) {= - tag_t current_tag = lf_tag(); - lf_print("At tag (%lld, %u) received %d.", - current_tag.time - lf_time_start(), - current_tag.microstep, - in->value); - self->total_received_messages++; - if (in->value != self->received_messages++) { - lf_print_error_and_exit("Expected %d.", self->received_messages - 1); - } + // but forces the logical time to advance Comment this line for a more sensible log output. + reaction(in) {= + tag_t current_tag = lf_tag(); + lf_print("At tag (%lld, %u) received %d.", + current_tag.time - lf_time_start(), + current_tag.microstep, + in->value); + self->total_received_messages++; + if (in->value != self->received_messages++) { + lf_print_error_and_exit("Expected %d.", self->received_messages - 1); + } - if (self->received_messages == self->take_a_break_after) { - // Sender is taking a break; - self->breaks++; - self->received_messages = 0; - } - =} + if (self->received_messages == self->take_a_break_after) { + // Sender is taking a break; + self->breaks++; + self->received_messages = 0; + } + =} - reaction(t) {= - // Do nothing - =} + reaction(t) {= + // Do nothing + =} - reaction(shutdown) {= - if (self->breaks != 2 || - (self->total_received_messages != ((SEC(1)/self->break_interval)+1) * self->take_a_break_after) - ) { - lf_print_error_and_exit("Test failed. Breaks: %d, Messages: %d.", self->breaks, self->total_received_messages); - } - lf_print("SUCCESS: Successfully received all messages from the sender."); - =} + reaction(shutdown) {= + if (self->breaks != 2 || + (self->total_received_messages != ((SEC(1)/self->break_interval)+1) * self->take_a_break_after) + ) { + lf_print_error_and_exit("Test failed. Breaks: %d, Messages: %d.", self->breaks, self->total_received_messages); + } + lf_print("SUCCESS: Successfully received all messages from the sender."); + =} } federated reactor DistributedLoopedPhysicalAction { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/federated/DistributedMultiport.lf b/test/C/src/federated/DistributedMultiport.lf index 3853629731..7590710339 100644 --- a/test/C/src/federated/DistributedMultiport.lf +++ b/test/C/src/federated/DistributedMultiport.lf @@ -1,45 +1,45 @@ // Check multiport connections between federates. target C { - timeout: 1 sec, - coordination: centralized + timeout: 1 sec, + coordination: centralized } reactor Source { - output[4] out: int - timer t(0, 100 msec) - state count: int = 0 + output[4] out: int + timer t(0, 100 msec) + state count: int = 0 - reaction(t) -> out {= - for (int i = 0; i < out_width; i++) { - lf_set(out[i], self->count++); - } - =} + reaction(t) -> out {= + for (int i = 0; i < out_width; i++) { + lf_set(out[i], self->count++); + } + =} } reactor Destination { - input[4] in: int - state count: int = 0 + input[4] in: int + state count: int = 0 - reaction(in) {= - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - lf_print("Received %d.", in[i]->value); - if (in[i]->value != self->count++) { - lf_print_error_and_exit("Expected %d.", self->count - 1); - } + reaction(in) {= + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + lf_print("Received %d.", in[i]->value); + if (in[i]->value != self->count++) { + lf_print_error_and_exit("Expected %d.", self->count - 1); } } - =} + } + =} - reaction(shutdown) {= - if (self->count == 0) { - lf_print_error_and_exit("No data received."); - } - =} + reaction(shutdown) {= + if (self->count == 0) { + lf_print_error_and_exit("No data received."); + } + =} } federated reactor DistributedMultiport { - s = new Source() - d = new Destination() - s.out -> d.in + s = new Source() + d = new Destination() + s.out -> d.in } diff --git a/test/C/src/federated/DistributedMultiportToBank.lf b/test/C/src/federated/DistributedMultiportToBank.lf index 0accaf8c60..c7a3b7dd5f 100644 --- a/test/C/src/federated/DistributedMultiportToBank.lf +++ b/test/C/src/federated/DistributedMultiportToBank.lf @@ -1,41 +1,41 @@ // Check multiport to bank connections between federates. target C { - timeout: 1 sec + timeout: 1 sec } reactor Source { - output[2] out: int - timer t(0, 100 msec) - state count: int = 0 + output[2] out: int + timer t(0, 100 msec) + state count: int = 0 - reaction(t) -> out {= - for (int i = 0; i < out_width; i++) { - lf_set(out[i], self->count); - } - self->count++; - =} + reaction(t) -> out {= + for (int i = 0; i < out_width; i++) { + lf_set(out[i], self->count); + } + self->count++; + =} } reactor Destination { - input in: int - state count: int = 0 + input in: int + state count: int = 0 - reaction(in) {= - lf_print("Received %d.", in->value); - if (self->count++ != in->value) { - lf_print_error_and_exit("Expected %d.", self->count - 1); - } - =} + reaction(in) {= + lf_print("Received %d.", in->value); + if (self->count++ != in->value) { + lf_print_error_and_exit("Expected %d.", self->count - 1); + } + =} - reaction(shutdown) {= - if (self->count == 0) { - lf_print_error_and_exit("No data received."); - } - =} + reaction(shutdown) {= + if (self->count == 0) { + lf_print_error_and_exit("No data received."); + } + =} } federated reactor DistributedMultiportToBank { - s = new Source() - d = new[2] Destination() - s.out -> d.in + s = new Source() + d = new[2] Destination() + s.out -> d.in } diff --git a/test/C/src/federated/DistributedMultiportToken.lf b/test/C/src/federated/DistributedMultiportToken.lf index dfb791d861..821f48d17a 100644 --- a/test/C/src/federated/DistributedMultiportToken.lf +++ b/test/C/src/federated/DistributedMultiportToken.lf @@ -1,46 +1,46 @@ -// Check multiport connections between federates where the message is carried by -// a Token (in this case, with an array of char). +// Check multiport connections between federates where the message is carried by a Token (in this +// case, with an array of char). target C { - timeout: 1 sec, - coordination: centralized + timeout: 1 sec, + coordination: centralized } reactor Source { - output[4] out: char* - timer t(0, 200 msec) - state count: int = 0 + output[4] out: char* + timer t(0, 200 msec) + state count: int = 0 - reaction(t) -> out {= - for (int i = 0; i < out_width; i++) { - // With NULL, 0 arguments, snprintf tells us how many bytes are needed. - // Add one for the null terminator. - int length = snprintf(NULL, 0, "Hello %d", self->count) + 1; - // Dynamically allocate memory for the output. - SET_NEW_ARRAY(out[i], length); - // Populate the output string and increment the count. - snprintf(out[i]->value, length, "Hello %d", self->count++); - lf_print("MessageGenerator: At time %lld, send message: %s.", - lf_time_logical_elapsed(), - out[i]->value - ); - } - =} + reaction(t) -> out {= + for (int i = 0; i < out_width; i++) { + // With NULL, 0 arguments, snprintf tells us how many bytes are needed. + // Add one for the null terminator. + int length = snprintf(NULL, 0, "Hello %d", self->count) + 1; + // Dynamically allocate memory for the output. + SET_NEW_ARRAY(out[i], length); + // Populate the output string and increment the count. + snprintf(out[i]->value, length, "Hello %d", self->count++); + lf_print("MessageGenerator: At time %lld, send message: %s.", + lf_time_logical_elapsed(), + out[i]->value + ); + } + =} } reactor Destination { - input[4] in: char* + input[4] in: char* - reaction(in) {= - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - lf_print("Received %s.", in[i]->value); - } + reaction(in) {= + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + lf_print("Received %s.", in[i]->value); } - =} + } + =} } federated reactor DistributedMultiportToken { - s = new Source() - d = new Destination() - s.out -> d.in + s = new Source() + d = new Destination() + s.out -> d.in } diff --git a/test/C/src/federated/DistributedNetworkOrder.lf b/test/C/src/federated/DistributedNetworkOrder.lf index 42f3da6134..851c363d77 100644 --- a/test/C/src/federated/DistributedNetworkOrder.lf +++ b/test/C/src/federated/DistributedNetworkOrder.lf @@ -1,76 +1,75 @@ /** * This is a test for send_timed_message, which is an internal API. * - * This test sends a second message at time 5 msec that has the same intended - * tag as a message that it had previously sent at time 0 msec. This results in - * a warning, but the message microstep is incremented and correctly received - * one microstep later. + * This test sends a second message at time 5 msec that has the same intended tag as a message that + * it had previously sent at time 0 msec. This results in a warning, but the message microstep is + * incremented and correctly received one microstep later. * * @author Soroush Bateni */ target C { - timeout: 1 sec, - build-type: RelWithDebInfo // Release with debug info + timeout: 1 sec, + build-type: RelWithDebInfo // Release with debug info } preamble {= - #ifdef __cplusplus - extern "C" { - #endif - #include "federate.h" - #ifdef __cplusplus - } - #endif + #ifdef __cplusplus + extern "C" { + #endif + #include "federate.h" + #ifdef __cplusplus + } + #endif =} reactor Sender { - output out: int - timer t(0, 1 msec) + output out: int + timer t(0, 1 msec) - reaction(t) -> out {= - int payload = 1; - if (lf_time_logical_elapsed() == 0LL) { - send_timed_message(MSEC(10), MSG_TYPE_TAGGED_MESSAGE, 0, 1, "federate 1", sizeof(int), - (unsigned char*)&payload); - } else if (lf_time_logical_elapsed() == MSEC(5)) { - payload = 2; - send_timed_message(MSEC(5), MSG_TYPE_TAGGED_MESSAGE, 0, 1, "federate 1", sizeof(int), - (unsigned char*)&payload); - } - =} + reaction(t) -> out {= + int payload = 1; + if (lf_time_logical_elapsed() == 0LL) { + send_timed_message(MSEC(10), MSG_TYPE_TAGGED_MESSAGE, 0, 1, "federate 1", sizeof(int), + (unsigned char*)&payload); + } else if (lf_time_logical_elapsed() == MSEC(5)) { + payload = 2; + send_timed_message(MSEC(5), MSG_TYPE_TAGGED_MESSAGE, 0, 1, "federate 1", sizeof(int), + (unsigned char*)&payload); + } + =} } reactor Receiver { - input in: int - state success: int = 0 + input in: int + state success: int = 0 - reaction(in) {= - tag_t current_tag = lf_tag(); - if (current_tag.time == (lf_time_start() + MSEC(10))) { - if (current_tag.microstep == 0 && in->value == 1) { - self->success++; - } else if (current_tag.microstep == 1 && in->value == 2) { - self->success++; - } + reaction(in) {= + tag_t current_tag = lf_tag(); + if (current_tag.time == (lf_time_start() + MSEC(10))) { + if (current_tag.microstep == 0 && in->value == 1) { + self->success++; + } else if (current_tag.microstep == 1 && in->value == 2) { + self->success++; } - printf("Received %d at tag (%lld, %u).\n", - in->value, - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + } + printf("Received %d at tag (%lld, %u).\n", + in->value, + lf_time_logical_elapsed(), + lf_tag().microstep); + =} - reaction(shutdown) {= - if (self->success != 2) { - fprintf(stderr, "ERROR: Failed to receive messages.\n"); - exit(1); - } - printf("SUCCESS.\n"); - =} + reaction(shutdown) {= + if (self->success != 2) { + fprintf(stderr, "ERROR: Failed to receive messages.\n"); + exit(1); + } + printf("SUCCESS.\n"); + =} } federated reactor DistributedNetworkOrder { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/federated/DistributedPhysicalActionUpstream.lf b/test/C/src/federated/DistributedPhysicalActionUpstream.lf index 520142b466..e4c8ad1e68 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstream.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstream.lf @@ -1,58 +1,58 @@ /** - * Test that a rapidly produced physical action in an upstream federate can be - * properly handled in federated execution. + * Test that a rapidly produced physical action in an upstream federate can be properly handled in + * federated execution. */ target C { - timeout: 10 secs, - coordination-options: { - advance-message-interval: 30 msec - } + timeout: 10 secs, + coordination-options: { + advance-message-interval: 30 msec + } } import PassThrough from "../lib/PassThrough.lf" import TestCount from "../lib/TestCount.lf" preamble {= - extern int _counter; - void callback(void *a); - void* take_time(void* a); + extern int _counter; + void callback(void *a); + void* take_time(void* a); =} reactor WithPhysicalAction { - preamble {= - int _counter = 1; - void callback(void *a) { - lf_schedule_int(a, 0, _counter++); - } - // Simulate time passing before a callback occurs. - void* take_time(void* a) { - while (_counter < 15) { - instant_t sleep_time = MSEC(10); - lf_sleep(sleep_time); - callback(a); - } - return NULL; + preamble {= + int _counter = 1; + void callback(void *a) { + lf_schedule_int(a, 0, _counter++); + } + // Simulate time passing before a callback occurs. + void* take_time(void* a) { + while (_counter < 15) { + instant_t sleep_time = MSEC(10); + lf_sleep(sleep_time); + callback(a); } - =} + return NULL; + } + =} - output out: int - state thread_id: lf_thread_t = 0 - physical action act(0): int + output out: int + state thread_id: lf_thread_t = 0 + physical action act(0): int - reaction(startup) -> act {= - // start new thread, provide callback - lf_thread_create(&self->thread_id, &take_time, act); - =} + reaction(startup) -> act {= + // start new thread, provide callback + lf_thread_create(&self->thread_id, &take_time, act); + =} - reaction(act) -> out {= lf_set(out, act->value); =} + reaction(act) -> out {= lf_set(out, act->value); =} } federated reactor { - a = new WithPhysicalAction() - m1 = new PassThrough() - m2 = new PassThrough() - test = new TestCount(num_inputs = 14) - a.out -> m1.in - m1.out -> m2.in - m2.out -> test.in + a = new WithPhysicalAction() + m1 = new PassThrough() + m2 = new PassThrough() + test = new TestCount(num_inputs = 14) + a.out -> m1.in + m1.out -> m2.in + m2.out -> test.in } diff --git a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf index 5cee1171cc..4fe2407b54 100644 --- a/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf +++ b/test/C/src/federated/DistributedPhysicalActionUpstreamLong.lf @@ -1,87 +1,87 @@ /** - * Test that a rapidly produced physical action in an upstream federate can be - * properly handled in a long chain of federates. + * Test that a rapidly produced physical action in an upstream federate can be properly handled in a + * long chain of federates. */ target C { - timeout: 1 sec, - coordination-options: { - advance-message-interval: 500 usec - } + timeout: 1 sec, + coordination-options: { + advance-message-interval: 500 usec + } } import PassThrough from "../lib/PassThrough.lf" import TestCount from "../lib/TestCount.lf" preamble {= - extern int _counter; - void callback(void *a); - void* take_time(void* a); + extern int _counter; + void callback(void *a); + void* take_time(void* a); =} reactor WithPhysicalAction { - preamble {= - int _counter = 1; - void callback(void *a) { - lf_schedule_int(a, 0, _counter++); - } - // Simulate time passing before a callback occurs. - void* take_time(void* a) { - while (_counter < 20) { - instant_t sleep_time = USEC(50); - lf_sleep(sleep_time); - callback(a); - } - return NULL; + preamble {= + int _counter = 1; + void callback(void *a) { + lf_schedule_int(a, 0, _counter++); + } + // Simulate time passing before a callback occurs. + void* take_time(void* a) { + while (_counter < 20) { + instant_t sleep_time = USEC(50); + lf_sleep(sleep_time); + callback(a); } - =} - output out: int - state thread_id: lf_thread_t = 0 - physical action act(0): int + return NULL; + } + =} + output out: int + state thread_id: lf_thread_t = 0 + physical action act(0): int - reaction(startup) -> act {= - // start new thread, provide callback - lf_thread_create(&self->thread_id, &take_time, act); - =} + reaction(startup) -> act {= + // start new thread, provide callback + lf_thread_create(&self->thread_id, &take_time, act); + =} - reaction(act) -> out {= lf_set(out, act->value); =} + reaction(act) -> out {= lf_set(out, act->value); =} } federated reactor { - a = new WithPhysicalAction() - test = new TestCount(num_inputs = 19) + a = new WithPhysicalAction() + test = new TestCount(num_inputs = 19) - passThroughs1 = new PassThrough() - passThroughs2 = new PassThrough() - passThroughs3 = new PassThrough() - passThroughs4 = new PassThrough() - passThroughs5 = new PassThrough() - passThroughs6 = new PassThrough() - passThroughs7 = new PassThrough() - passThroughs8 = new PassThrough() - passThroughs9 = new PassThrough() - passThroughs10 = new PassThrough() + passThroughs1 = new PassThrough() + passThroughs2 = new PassThrough() + passThroughs3 = new PassThrough() + passThroughs4 = new PassThrough() + passThroughs5 = new PassThrough() + passThroughs6 = new PassThrough() + passThroughs7 = new PassThrough() + passThroughs8 = new PassThrough() + passThroughs9 = new PassThrough() + passThroughs10 = new PassThrough() - a.out, - passThroughs1.out, - passThroughs2.out, - passThroughs3.out, - passThroughs4.out, - passThroughs5.out, - passThroughs6.out, - passThroughs7.out, - passThroughs8.out, - passThroughs9.out, - passThroughs10.out - -> - passThroughs1.in, - passThroughs2.in, - passThroughs3.in, - passThroughs4.in, - passThroughs5.in, - passThroughs6.in, - passThroughs7.in, - passThroughs8.in, - passThroughs9.in, - passThroughs10.in, - test.in + a.out, + passThroughs1.out, + passThroughs2.out, + passThroughs3.out, + passThroughs4.out, + passThroughs5.out, + passThroughs6.out, + passThroughs7.out, + passThroughs8.out, + passThroughs9.out, + passThroughs10.out + -> + passThroughs1.in, + passThroughs2.in, + passThroughs3.in, + passThroughs4.in, + passThroughs5.in, + passThroughs6.in, + passThroughs7.in, + passThroughs8.in, + passThroughs9.in, + passThroughs10.in, + test.in } diff --git a/test/C/src/federated/DistributedStop.lf b/test/C/src/federated/DistributedStop.lf index 2d4a616664..4af4685169 100644 --- a/test/C/src/federated/DistributedStop.lf +++ b/test/C/src/federated/DistributedStop.lf @@ -1,119 +1,118 @@ /** - * Test for lf_request_stop() in federated execution with centralized - * coordination. + * Test for lf_request_stop() in federated execution with centralized coordination. * * @author Soroush Bateni */ target C reactor Sender { - output out: int - timer t(0, 1 usec) - logical action act - state reaction_invoked_correctly: bool = false + output out: int + timer t(0, 1 usec) + logical action act + state reaction_invoked_correctly: bool = false - reaction(t, act) -> out, act {= - lf_print("Sending 42 at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_set(out, 42); - if (lf_tag().microstep == 0) { - // Instead of having a separate reaction - // for 'act' like Stop.lf, we trigger the - // same reaction to test lf_request_stop() being - // called multiple times - lf_schedule(act, 0); - } - if (lf_time_logical_elapsed() == USEC(1)) { - // Call lf_request_stop() both at (1 usec, 0) and - // (1 usec, 1) - lf_print("Requesting stop at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_request_stop(); - } + reaction(t, act) -> out, act {= + lf_print("Sending 42 at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_set(out, 42); + if (lf_tag().microstep == 0) { + // Instead of having a separate reaction + // for 'act' like Stop.lf, we trigger the + // same reaction to test lf_request_stop() being + // called multiple times + lf_schedule(act, 0); + } + if (lf_time_logical_elapsed() == USEC(1)) { + // Call lf_request_stop() both at (1 usec, 0) and + // (1 usec, 1) + lf_print("Requesting stop at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_request_stop(); + } - tag_t _1usec1 = (tag_t) { .time = USEC(1) + lf_time_start(), .microstep = 1u }; - if (lf_tag_compare(lf_tag(), _1usec1) == 0) { - // The reaction was invoked at (1 usec, 1) as expected - self->reaction_invoked_correctly = true; - } else if (lf_tag_compare(lf_tag(), _1usec1) > 0) { - // The reaction should not have been invoked at tags larger than (1 usec, 1) - lf_print_error_and_exit("ERROR: Invoked reaction(t, act) at tag bigger than shutdown."); - } - =} + tag_t _1usec1 = (tag_t) { .time = USEC(1) + lf_time_start(), .microstep = 1u }; + if (lf_tag_compare(lf_tag(), _1usec1) == 0) { + // The reaction was invoked at (1 usec, 1) as expected + self->reaction_invoked_correctly = true; + } else if (lf_tag_compare(lf_tag(), _1usec1) > 0) { + // The reaction should not have been invoked at tags larger than (1 usec, 1) + lf_print_error_and_exit("ERROR: Invoked reaction(t, act) at tag bigger than shutdown."); + } + =} - reaction(shutdown) {= - if (lf_time_logical_elapsed() != USEC(1) || - lf_tag().microstep != 1) { - lf_print_error_and_exit("ERROR: Sender failed to stop the federation in time. " - "Stopping at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - } else if (self->reaction_invoked_correctly == false) { - lf_print_error_and_exit("ERROR: Sender reaction(t, act) was not invoked at (1 usec, 1). " - "Stopping at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - } - lf_print("SUCCESS: Successfully stopped the federation at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + reaction(shutdown) {= + if (lf_time_logical_elapsed() != USEC(1) || + lf_tag().microstep != 1) { + lf_print_error_and_exit("ERROR: Sender failed to stop the federation in time. " + "Stopping at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + } else if (self->reaction_invoked_correctly == false) { + lf_print_error_and_exit("ERROR: Sender reaction(t, act) was not invoked at (1 usec, 1). " + "Stopping at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + } + lf_print("SUCCESS: Successfully stopped the federation at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + =} } reactor Receiver( - stp_offset: time = 10 msec // Used in the decentralized variant of the test + stp_offset: time = 10 msec // Used in the decentralized variant of the test ) { - input in: int - state reaction_invoked_correctly: bool = false + input in: int + state reaction_invoked_correctly: bool = false - reaction(in) {= - lf_print("Received %d at (%lld, %u).", - in->value, - lf_time_logical_elapsed(), - lf_tag().microstep); - if (lf_time_logical_elapsed() == USEC(1)) { - lf_print("Requesting stop at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - lf_request_stop(); - // The receiver should receive a message at tag - // (1 usec, 1) and trigger this reaction - self->reaction_invoked_correctly = true; - } + reaction(in) {= + lf_print("Received %d at (%lld, %u).", + in->value, + lf_time_logical_elapsed(), + lf_tag().microstep); + if (lf_time_logical_elapsed() == USEC(1)) { + lf_print("Requesting stop at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + lf_request_stop(); + // The receiver should receive a message at tag + // (1 usec, 1) and trigger this reaction + self->reaction_invoked_correctly = true; + } - tag_t _1usec1 = (tag_t) { .time = USEC(1) + lf_time_start(), .microstep = 1u }; - if (lf_tag_compare(lf_tag(), _1usec1) > 0) { - self->reaction_invoked_correctly = false; - } - =} + tag_t _1usec1 = (tag_t) { .time = USEC(1) + lf_time_start(), .microstep = 1u }; + if (lf_tag_compare(lf_tag(), _1usec1) > 0) { + self->reaction_invoked_correctly = false; + } + =} - reaction(shutdown) {= - // Sender should have requested stop earlier than the receiver. - // Therefore, the shutdown events must occur at (1000, 0) on the - // receiver. - if (lf_time_logical_elapsed() != USEC(1) || - lf_tag().microstep != 1) { - lf_print_error_and_exit("Receiver failed to stop the federation at the right time. " - "Stopping at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - } else if (self->reaction_invoked_correctly == false) { - lf_print_error_and_exit("Receiver reaction(in) was not invoked the correct number of times. " - "Stopping at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - } - lf_print("SUCCESS: Successfully stopped the federation at (%lld, %u).", - lf_time_logical_elapsed(), - lf_tag().microstep); - =} + reaction(shutdown) {= + // Sender should have requested stop earlier than the receiver. + // Therefore, the shutdown events must occur at (1000, 0) on the + // receiver. + if (lf_time_logical_elapsed() != USEC(1) || + lf_tag().microstep != 1) { + lf_print_error_and_exit("Receiver failed to stop the federation at the right time. " + "Stopping at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + } else if (self->reaction_invoked_correctly == false) { + lf_print_error_and_exit("Receiver reaction(in) was not invoked the correct number of times. " + "Stopping at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + } + lf_print("SUCCESS: Successfully stopped the federation at (%lld, %u).", + lf_time_logical_elapsed(), + lf_tag().microstep); + =} } federated reactor DistributedStop { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in + sender.out -> receiver.in } diff --git a/test/C/src/federated/DistributedToken.lf b/test/C/src/federated/DistributedToken.lf index 1068bd5f85..14ce0b94e0 100644 --- a/test/C/src/federated/DistributedToken.lf +++ b/test/C/src/federated/DistributedToken.lf @@ -1,53 +1,50 @@ /** - * Distributed LF program where a MessageGenerator creates a string message that - * is sent via the RTI (runtime infrastructure) to a receiver that prints the - * message. The type is char*, so this tests the transport of token-encapsulated - * messages. Three executable programs are generated, Distributed, - * Distributed_Sender, and Distributed_Receiver. The RTI is realized in the - * first of these and is identified as a "launcher," so it launches the other - * two programs. + * Distributed LF program where a MessageGenerator creates a string message that is sent via the RTI + * (runtime infrastructure) to a receiver that prints the message. The type is char*, so this tests + * the transport of token-encapsulated messages. Three executable programs are generated, + * Distributed, Distributed_Sender, and Distributed_Receiver. The RTI is realized in the first of + * these and is identified as a "launcher," so it launches the other two programs. * - * This program uses a 'logical' connection -> with a STP violation handler, - * decentralized coordination, and an 'after' that is sufficiently large to get - * deterministic timestamps. Hence, it realizes a 'poor man's Ptides' that does - * not require clock synchronization nor HLA-style centralized control over the - * advancement of time. + * This program uses a 'logical' connection -> with a STP violation handler, decentralized + * coordination, and an 'after' that is sufficiently large to get deterministic timestamps. Hence, + * it realizes a 'poor man's Ptides' that does not require clock synchronization nor HLA-style + * centralized control over the advancement of time. * * @author Edward A. Lee */ target C { - timeout: 5 secs, - coordination: decentralized + timeout: 5 secs, + coordination: decentralized } /** - * Reactor that generates a sequence of messages, one per second. The message - * will be a string consisting of a root string followed by a count. + * Reactor that generates a sequence of messages, one per second. The message will be a string + * consisting of a root string followed by a count. * @param root The root string. * @output message The message. */ reactor MessageGenerator(root: string = "") { - // Output type char* instead of string is used for dynamically allocated - // character arrays (as opposed to static constant strings). - output message: char* - state count: int = 1 - // Send first message after 1 sec so that the startup reactions do not - // factor into the transport time measurement on the first message. - timer t(1 sec, 1 sec) + // Output type char* instead of string is used for dynamically allocated character arrays (as + // opposed to static constant strings). + output message: char* + state count: int = 1 + // Send first message after 1 sec so that the startup reactions do not factor into the transport + // time measurement on the first message. + timer t(1 sec, 1 sec) - reaction(t) -> message {= - // With NULL, 0 arguments, snprintf tells us how many bytes are needed. - // Add one for the null terminator. - int length = snprintf(NULL, 0, "%s %d", self->root, self->count) + 1; - // Dynamically allocate memory for the output. - SET_NEW_ARRAY(message, length); - // Populate the output string and increment the count. - snprintf(message->value, length, "%s %d", self->root, self->count++); - printf("MessageGenerator: At time %lld, send message: %s\n", - lf_time_logical_elapsed(), - message->value - ); - =} + reaction(t) -> message {= + // With NULL, 0 arguments, snprintf tells us how many bytes are needed. + // Add one for the null terminator. + int length = snprintf(NULL, 0, "%s %d", self->root, self->count) + 1; + // Dynamically allocate memory for the output. + SET_NEW_ARRAY(message, length); + // Populate the output string and increment the count. + snprintf(message->value, length, "%s %d", self->root, self->count++); + printf("MessageGenerator: At time %lld, send message: %s\n", + lf_time_logical_elapsed(), + message->value + ); + =} } /** @@ -56,48 +53,48 @@ reactor MessageGenerator(root: string = "") { * @input message The message. */ reactor PrintMessage { - input message: char* - state count: int = 0 + input message: char* + state count: int = 0 - reaction(message) {= - printf("PrintMessage: At (elapsed) logical time %lld, receiver receives: %s\n", - lf_time_logical_elapsed(), - message->value - ); - // Check the trailing number only of the message. - self->count++; - int trailing_number = atoi(&message->value[12]); - if (trailing_number != self->count) { - printf("ERROR: Expected message to be 'Hello World %d'.\n", self->count); - exit(1); - } - =} STP(0) {= - printf("PrintMessage: At (elapsed) tag (%lld, %u), receiver receives: %s\n" - "Original intended tag was (%lld, %u).\n", - lf_time_logical_elapsed(), - lf_tag().microstep, - message->value, - message->intended_tag.time - lf_time_start(), - message->intended_tag.microstep); - // Check the trailing number only of the message. - self->count++; - int trailing_number = atoi(&message->value[12]); - if (trailing_number != self->count) { - printf("ERROR: Expected message to be 'Hello World %d'.\n", self->count); - exit(1); - } - =} + reaction(message) {= + printf("PrintMessage: At (elapsed) logical time %lld, receiver receives: %s\n", + lf_time_logical_elapsed(), + message->value + ); + // Check the trailing number only of the message. + self->count++; + int trailing_number = atoi(&message->value[12]); + if (trailing_number != self->count) { + printf("ERROR: Expected message to be 'Hello World %d'.\n", self->count); + exit(1); + } + =} STP(0) {= + printf("PrintMessage: At (elapsed) tag (%lld, %u), receiver receives: %s\n" + "Original intended tag was (%lld, %u).\n", + lf_time_logical_elapsed(), + lf_tag().microstep, + message->value, + message->intended_tag.time - lf_time_start(), + message->intended_tag.microstep); + // Check the trailing number only of the message. + self->count++; + int trailing_number = atoi(&message->value[12]); + if (trailing_number != self->count) { + printf("ERROR: Expected message to be 'Hello World %d'.\n", self->count); + exit(1); + } + =} - reaction(shutdown) {= - if (self->count == 0) { - printf("ERROR: No messages received.\n"); - exit(2); - } - =} + reaction(shutdown) {= + if (self->count == 0) { + printf("ERROR: No messages received.\n"); + exit(2); + } + =} } federated reactor DistributedToken { - msg = new MessageGenerator(root = "Hello World") - dsp = new PrintMessage() - msg.message -> dsp.message after 40 msec + msg = new MessageGenerator(root = "Hello World") + dsp = new PrintMessage() + msg.message -> dsp.message after 40 msec } diff --git a/test/C/src/federated/FederatedFilePkgReader.lf b/test/C/src/federated/FederatedFilePkgReader.lf index 597ebbf96a..e4396b7783 100644 --- a/test/C/src/federated/FederatedFilePkgReader.lf +++ b/test/C/src/federated/FederatedFilePkgReader.lf @@ -1,57 +1,57 @@ /** Test reading a file at a location relative to the source file. */ target C { - timeout: 0 s + timeout: 0 s } reactor Source { - output out: char* // Use char*, not string, so memory is freed. - - reaction(startup) -> out {= - char* file_path = - LF_PACKAGE_DIRECTORY - LF_FILE_SEPARATOR "src" - LF_FILE_SEPARATOR "lib" - LF_FILE_SEPARATOR "FileReader.txt"; - - FILE* file = fopen(file_path, "rb"); - if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); - - // Determine the file size - fseek(file, 0, SEEK_END); - long file_size = ftell(file); - fseek(file, 0, SEEK_SET); - - // Allocate memory for the buffer - char* buffer = (char *) malloc(file_size + 1); - if (buffer == NULL) lf_print_error_and_exit("Out of memory."); - - // Read the file into the buffer - fread(buffer, file_size, 1, file); - buffer[file_size] = '\0'; - fclose(file); - - // For federated version, have to use lf_set_array so array size is know - // to the serializer. - lf_set_array(out, buffer, file_size + 1); - =} + output out: char* // Use char*, not string, so memory is freed. + + reaction(startup) -> out {= + char* file_path = + LF_PACKAGE_DIRECTORY + LF_FILE_SEPARATOR "src" + LF_FILE_SEPARATOR "lib" + LF_FILE_SEPARATOR "FileReader.txt"; + + FILE* file = fopen(file_path, "rb"); + if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); + + // Determine the file size + fseek(file, 0, SEEK_END); + long file_size = ftell(file); + fseek(file, 0, SEEK_SET); + + // Allocate memory for the buffer + char* buffer = (char *) malloc(file_size + 1); + if (buffer == NULL) lf_print_error_and_exit("Out of memory."); + + // Read the file into the buffer + fread(buffer, file_size, 1, file); + buffer[file_size] = '\0'; + fclose(file); + + // For federated version, have to use lf_set_array so array size is know + // to the serializer. + lf_set_array(out, buffer, file_size + 1); + =} } reactor Check { - preamble {= - #include - =} - input in: char* - - reaction(in) {= - printf("Received: %s\n", in->value); - if (strcmp("Hello World", in->value) != 0) { - lf_print_error_and_exit("Expected 'Hello World'"); - } - =} + preamble {= + #include + =} + input in: char* + + reaction(in) {= + printf("Received: %s\n", in->value); + if (strcmp("Hello World", in->value) != 0) { + lf_print_error_and_exit("Expected 'Hello World'"); + } + =} } federated reactor { - s = new Source() - c = new Check() - s.out -> c.in + s = new Source() + c = new Check() + s.out -> c.in } diff --git a/test/C/src/federated/FederatedFileReader.lf b/test/C/src/federated/FederatedFileReader.lf index 6ba2da763f..9a2534195a 100644 --- a/test/C/src/federated/FederatedFileReader.lf +++ b/test/C/src/federated/FederatedFileReader.lf @@ -1,57 +1,57 @@ /** Test reading a file at a location relative to the source file. */ target C { - timeout: 0 s + timeout: 0 s } reactor Source { - output out: char* // Use char*, not string, so memory is freed. - - reaction(startup) -> out {= - char* file_path = - LF_SOURCE_DIRECTORY - LF_FILE_SEPARATOR ".." - LF_FILE_SEPARATOR "lib" - LF_FILE_SEPARATOR "FileReader.txt"; - - FILE* file = fopen(file_path, "rb"); - if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); - - // Determine the file size - fseek(file, 0, SEEK_END); - long file_size = ftell(file); - fseek(file, 0, SEEK_SET); - - // Allocate memory for the buffer - char* buffer = (char *) malloc(file_size + 1); - if (buffer == NULL) lf_print_error_and_exit("Out of memory."); - - // Read the file into the buffer - fread(buffer, file_size, 1, file); - buffer[file_size] = '\0'; - fclose(file); - - // For federated version, have to use lf_set_array so array size is know - // to the serializer. - lf_set_array(out, buffer, file_size + 1); - =} + output out: char* // Use char*, not string, so memory is freed. + + reaction(startup) -> out {= + char* file_path = + LF_SOURCE_DIRECTORY + LF_FILE_SEPARATOR ".." + LF_FILE_SEPARATOR "lib" + LF_FILE_SEPARATOR "FileReader.txt"; + + FILE* file = fopen(file_path, "rb"); + if (file == NULL) lf_print_error_and_exit("Error opening file at path %s.", file_path); + + // Determine the file size + fseek(file, 0, SEEK_END); + long file_size = ftell(file); + fseek(file, 0, SEEK_SET); + + // Allocate memory for the buffer + char* buffer = (char *) malloc(file_size + 1); + if (buffer == NULL) lf_print_error_and_exit("Out of memory."); + + // Read the file into the buffer + fread(buffer, file_size, 1, file); + buffer[file_size] = '\0'; + fclose(file); + + // For federated version, have to use lf_set_array so array size is know + // to the serializer. + lf_set_array(out, buffer, file_size + 1); + =} } reactor Check { - preamble {= - #include - =} - input in: char* - - reaction(in) {= - printf("Received: %s\n", in->value); - if (strcmp("Hello World", in->value) != 0) { - lf_print_error_and_exit("Expected 'Hello World'"); - } - =} + preamble {= + #include + =} + input in: char* + + reaction(in) {= + printf("Received: %s\n", in->value); + if (strcmp("Hello World", in->value) != 0) { + lf_print_error_and_exit("Expected 'Hello World'"); + } + =} } federated reactor { - s = new Source() - c = new Check() - s.out -> c.in + s = new Source() + c = new Check() + s.out -> c.in } diff --git a/test/C/src/federated/FeedbackDelay.lf b/test/C/src/federated/FeedbackDelay.lf index 997a4ad012..abfe5f1d6c 100644 --- a/test/C/src/federated/FeedbackDelay.lf +++ b/test/C/src/federated/FeedbackDelay.lf @@ -1,66 +1,66 @@ target C { - timeout: 1 sec, - logging: DEBUG + timeout: 1 sec, + logging: DEBUG } reactor PhysicalPlant { - input control: double - output sensor: double - timer t(0, 33 msec) - state last_sensor_time: time = 0 - state previous_sensor_time: time = 0 + input control: double + output sensor: double + timer t(0, 33 msec) + state last_sensor_time: time = 0 + state previous_sensor_time: time = 0 - reaction(t) -> sensor {= - lf_set(sensor, 42); - self->previous_sensor_time = self->last_sensor_time; - self->last_sensor_time = lf_time_physical(); - =} + reaction(t) -> sensor {= + lf_set(sensor, 42); + self->previous_sensor_time = self->last_sensor_time; + self->last_sensor_time = lf_time_physical(); + =} - reaction(control) {= - instant_t control_time = lf_time_physical(); - lf_print("Latency %lld.", control_time - self->previous_sensor_time); - lf_print("Logical time: %lld.", lf_time_logical_elapsed()); - =} STP(33 msec) {= lf_print_warning("STP violation."); =} + reaction(control) {= + instant_t control_time = lf_time_physical(); + lf_print("Latency %lld.", control_time - self->previous_sensor_time); + lf_print("Logical time: %lld.", lf_time_logical_elapsed()); + =} STP(33 msec) {= lf_print_warning("STP violation."); =} } reactor Controller { - input sensor: double - output control: double + input sensor: double + output control: double - state latest_control: double = 0.0 - state first: bool = true + state latest_control: double = 0.0 + state first: bool = true - output request_for_planning: double - input planning: double + output request_for_planning: double + input planning: double - reaction(planning) {= self->latest_control = planning->value; =} + reaction(planning) {= self->latest_control = planning->value; =} - reaction(sensor) -> control, request_for_planning {= - if (!self->first) { - lf_set(control, self->latest_control); - } - self->first = false; - lf_set(request_for_planning, sensor->value); - =} + reaction(sensor) -> control, request_for_planning {= + if (!self->first) { + lf_set(control, self->latest_control); + } + self->first = false; + lf_set(request_for_planning, sensor->value); + =} } reactor Planner { - input request: double - output response: double + input request: double + output response: double - reaction(request) -> response {= - lf_sleep(MSEC(10)); - lf_set(response, request->value); - =} + reaction(request) -> response {= + lf_sleep(MSEC(10)); + lf_set(response, request->value); + =} } federated reactor { - p = new PhysicalPlant() - c = new Controller() - pl = new Planner() + p = new PhysicalPlant() + c = new Controller() + pl = new Planner() - p.sensor -> c.sensor - c.request_for_planning -> pl.request - pl.response -> c.planning after 0 - c.control -> p.control + p.sensor -> c.sensor + c.request_for_planning -> pl.request + pl.response -> c.planning after 0 + c.control -> p.control } diff --git a/test/C/src/federated/FeedbackDelaySimple.lf b/test/C/src/federated/FeedbackDelaySimple.lf index 0c9b147cda..7f4756c49d 100644 --- a/test/C/src/federated/FeedbackDelaySimple.lf +++ b/test/C/src/federated/FeedbackDelaySimple.lf @@ -1,39 +1,39 @@ target C { - timeout: 1 sec + timeout: 1 sec } reactor Loop { - input in: int - output out: int - timer t(0, 100 msec) - state count: int = 1 + input in: int + output out: int + timer t(0, 100 msec) + state count: int = 1 - reaction(in) {= - lf_print("Received %d.", in->value); - if (in->value != self->count) { - lf_print_error_and_exit( - "Expected %d. Got %d.", - self->count, - in->value - ); - } - self->count++; - =} + reaction(in) {= + lf_print("Received %d.", in->value); + if (in->value != self->count) { + lf_print_error_and_exit( + "Expected %d. Got %d.", + self->count, + in->value + ); + } + self->count++; + =} - reaction(t) -> out {= lf_set(out, self->count); =} + reaction(t) -> out {= lf_set(out, self->count); =} - reaction(shutdown) {= - if (self->count != 11) { - lf_print_error_and_exit( - "Expected 11 messages. Got %d.", - self->count - ); - } - =} + reaction(shutdown) {= + if (self->count != 11) { + lf_print_error_and_exit( + "Expected 11 messages. Got %d.", + self->count + ); + } + =} } federated reactor { - l = new Loop() + l = new Loop() - l.out -> l.in after 0 + l.out -> l.in after 0 } diff --git a/test/C/src/federated/HelloDistributed.lf b/test/C/src/federated/HelloDistributed.lf index 909ce53b43..d2c4ea4c16 100644 --- a/test/C/src/federated/HelloDistributed.lf +++ b/test/C/src/federated/HelloDistributed.lf @@ -1,55 +1,52 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target C preamble {= - #include + #include =} reactor Source { - output out: string + output out: string - reaction(startup) -> out {= - lf_print("Sending 'Hello World!' message from source federate."); - lf_set(out, "Hello World!"); - lf_request_stop(); - =} + reaction(startup) -> out {= + lf_print("Sending 'Hello World!' message from source federate."); + lf_set(out, "Hello World!"); + lf_request_stop(); + =} } reactor Destination { - input in: string - state received: bool = false - - reaction(startup) {= lf_print("Destination started."); =} - - reaction(in) {= - lf_print("At logical time %lld, destination received: %s", lf_time_logical_elapsed(), in->value); - if (strcmp(in->value, "Hello World!") != 0) { - fprintf(stderr, "ERROR: Expected to receive 'Hello World!'\n"); - exit(1); - } - self->received = true; - =} - - reaction(shutdown) {= - lf_print("Shutdown invoked."); - if (!self->received) { - lf_print_error_and_exit("Destination did not receive the message."); - } - =} + input in: string + state received: bool = false + + reaction(startup) {= lf_print("Destination started."); =} + + reaction(in) {= + lf_print("At logical time %lld, destination received: %s", lf_time_logical_elapsed(), in->value); + if (strcmp(in->value, "Hello World!") != 0) { + fprintf(stderr, "ERROR: Expected to receive 'Hello World!'\n"); + exit(1); + } + self->received = true; + =} + + reaction(shutdown) {= + lf_print("Shutdown invoked."); + if (!self->received) { + lf_print_error_and_exit("Destination did not receive the message."); + } + =} } federated reactor HelloDistributed at localhost { - s = new Source() // Reactor s is in federate Source - d = new Destination() // Reactor d is in federate Destination - s.out -> d.in // This version preserves the timestamp. + s = new Source() // Reactor s is in federate Source + d = new Destination() // Reactor d is in federate Destination + s.out -> d.in // This version preserves the timestamp. - reaction(startup) {= - lf_print("Printing something in top-level federated reactor."); - =} + reaction(startup) {= lf_print("Printing something in top-level federated reactor."); =} } diff --git a/test/C/src/federated/LevelPattern.lf b/test/C/src/federated/LevelPattern.lf index 9f1ba16b7e..cdbcc46ffe 100644 --- a/test/C/src/federated/LevelPattern.lf +++ b/test/C/src/federated/LevelPattern.lf @@ -1,48 +1,48 @@ /** - * This test verifies that the artificial dependencies introduced by level-based - * scheduling do not, by themselves, introduce deadlocks in federated execution. + * This test verifies that the artificial dependencies introduced by level-based scheduling do not, + * by themselves, introduce deadlocks in federated execution. * * @author Edward A. Lee */ target C { - timeout: 1 s + timeout: 1 s } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" reactor Through { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= lf_set(out, in->value); =} + reaction(in) -> out {= lf_set(out, in->value); =} } reactor A { - input in1: int - input in2: int - output out1: int - output out2: int + input in1: int + input in2: int + output out1: int + output out2: int - i1 = new Through() - i1.out -> out1 + i1 = new Through() + i1.out -> out1 - i2 = new Through() - i2.out -> out2 + i2 = new Through() + i2.out -> out2 - reaction(in1) -> i1.in {= lf_set(i1.in, in1->value); =} + reaction(in1) -> i1.in {= lf_set(i1.in, in1->value); =} - reaction(in2) -> i2.in {= lf_set(i2.in, in2->value); =} + reaction(in2) -> i2.in {= lf_set(i2.in, in2->value); =} } federated reactor { - c = new Count() - test = new TestCount(num_inputs = 2) - b = new A() - t = new Through() - - c.out -> b.in1 - b.out1 -> t.in - t.out -> b.in2 - b.out2 -> test.in + c = new Count() + test = new TestCount(num_inputs = 2) + b = new A() + t = new Through() + + c.out -> b.in1 + b.out1 -> t.in + t.out -> b.in2 + b.out2 -> test.in } diff --git a/test/C/src/federated/LoopDistributedCentralized.lf b/test/C/src/federated/LoopDistributedCentralized.lf index 7fdc972b5a..c8b08ee317 100644 --- a/test/C/src/federated/LoopDistributedCentralized.lf +++ b/test/C/src/federated/LoopDistributedCentralized.lf @@ -1,50 +1,49 @@ /** - * This tests a feedback loop with physical actions and centralized - * coordination. + * This tests a feedback loop with physical actions and centralized coordination. * * @author Edward A. Lee */ target C { - flags: "-Wall", - coordination: centralized, - coordination-options: { - advance-message-interval: 100 msec - }, - timeout: 4 sec, - logging: DEBUG + flags: "-Wall", + coordination: centralized, + coordination-options: { + advance-message-interval: 100 msec + }, + timeout: 4 sec, + logging: DEBUG } reactor Looper(incr: int = 1, delay: time = 0 msec) { - input in: int - output out: int - physical action a(delay) - state count: int = 0 + input in: int + output out: int + physical action a(delay) + state count: int = 0 - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) -> out {= - lf_set(out, self->count); - self->count += self->incr; - =} + reaction(t) -> out {= + lf_set(out, self->count); + self->count += self->incr; + =} - reaction(in) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} + reaction(in) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + =} - reaction(shutdown) {= - lf_print("******* Shutdown invoked."); - if (self->count != 5 * self->incr) { - lf_print_error_and_exit("Failed to receive all five expected inputs."); - } - =} + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + if (self->count != 5 * self->incr) { + lf_print_error_and_exit("Failed to receive all five expected inputs."); + } + =} } federated reactor LoopDistributedCentralized(delay: time = 0) { - left = new Looper() - right = new Looper(incr = -1) - left.out -> right.in - right.out -> left.in + left = new Looper() + right = new Looper(incr = -1) + left.out -> right.in + right.out -> left.in } diff --git a/test/C/src/federated/LoopDistributedCentralized2.lf b/test/C/src/federated/LoopDistributedCentralized2.lf index 82412e16fe..e83fc1e308 100644 --- a/test/C/src/federated/LoopDistributedCentralized2.lf +++ b/test/C/src/federated/LoopDistributedCentralized2.lf @@ -1,77 +1,76 @@ /** - * This tests a feedback loop with physical actions and centralized - * coordination. + * This tests a feedback loop with physical actions and centralized coordination. * * @author Edward A. Lee */ target C { - flags: "-Wall", - coordination: centralized, - coordination-options: { - advance-message-interval: 100 msec - }, - timeout: 4 sec + flags: "-Wall", + coordination: centralized, + coordination-options: { + advance-message-interval: 100 msec + }, + timeout: 4 sec } reactor Looper(incr: int = 1, delay: time = 0 msec) { - input in: int - output out: int - physical action a(delay) - state count: int = 0 + input in: int + output out: int + physical action a(delay) + state count: int = 0 - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) -> out {= - lf_set(out, self->count); - self->count += self->incr; - =} + reaction(t) -> out {= + lf_set(out, self->count); + self->count += self->incr; + =} - reaction(in) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} + reaction(in) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + =} - reaction(shutdown) {= - lf_print("******* Shutdown invoked."); - if (self->count != 5 * self->incr) { - lf_print_error_and_exit("Failed to receive all five expected inputs."); - } - =} + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + if (self->count != 5 * self->incr) { + lf_print_error_and_exit("Failed to receive all five expected inputs."); + } + =} } reactor Looper2(incr: int = 1, delay: time = 0 msec) { - input in: int - output out: int - physical action a(delay) - state count: int = 0 + input in: int + output out: int + physical action a(delay) + state count: int = 0 - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(in) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} + reaction(in) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + =} - reaction(t) -> out {= - lf_set(out, self->count); - self->count += self->incr; - =} + reaction(t) -> out {= + lf_set(out, self->count); + self->count += self->incr; + =} - reaction(shutdown) {= - lf_print("******* Shutdown invoked."); - if (self->count != 5 * self->incr) { - lf_print_error_and_exit("Failed to receive all five expected inputs."); - } - =} + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + if (self->count != 5 * self->incr) { + lf_print_error_and_exit("Failed to receive all five expected inputs."); + } + =} } federated reactor(delay: time = 0) { - left = new Looper() - right = new Looper2(incr = -1) - left.out -> right.in - right.out -> left.in + left = new Looper() + right = new Looper2(incr = -1) + left.out -> right.in + right.out -> left.in } diff --git a/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf b/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf index b4501cd555..5b9d47fd88 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPhysicalAction.lf @@ -1,74 +1,73 @@ /** - * This tests a feedback loop with physical actions and centralized - * coordination. + * This tests a feedback loop with physical actions and centralized coordination. * * @author Edward A. Lee */ target C { - flags: "-Wall", - coordination: centralized, - coordination-options: { - advance-message-interval: 100 msec - }, - timeout: 5 sec + flags: "-Wall", + coordination: centralized, + coordination-options: { + advance-message-interval: 100 msec + }, + timeout: 5 sec } preamble {= - #include // Defines sleep() - extern bool stop; - void* ping(void* actionref); + #include // Defines sleep() + extern bool stop; + void* ping(void* actionref); =} reactor Looper(incr: int = 1, delay: time = 0 msec) { - preamble {= - bool stop = false; - // Thread to trigger an action once every second. - void* ping(void* actionref) { - while(!stop) { - lf_print("Scheduling action."); - lf_schedule(actionref, 0); - sleep(1); - } - return NULL; + preamble {= + bool stop = false; + // Thread to trigger an action once every second. + void* ping(void* actionref) { + while(!stop) { + lf_print("Scheduling action."); + lf_schedule(actionref, 0); + sleep(1); } - =} - input in: int - output out: int - physical action a(delay) - state count: int = 0 + return NULL; + } + =} + input in: int + output out: int + physical action a(delay) + state count: int = 0 - reaction(startup) -> a {= - // Start the thread that listens for Enter or Return. - lf_thread_t thread_id; - lf_print("Starting thread."); - lf_thread_create(&thread_id, &ping, a); - =} + reaction(startup) -> a {= + // Start the thread that listens for Enter or Return. + lf_thread_t thread_id; + lf_print("Starting thread."); + lf_thread_create(&thread_id, &ping, a); + =} - reaction(a) -> out {= - lf_set(out, self->count); - self->count += self->incr; - =} + reaction(a) -> out {= + lf_set(out, self->count); + self->count += self->incr; + =} - reaction(in) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} + reaction(in) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + =} - reaction(shutdown) {= - lf_print("******* Shutdown invoked."); - // Stop the thread that is scheduling actions. - stop = true; - if (self->count != 5 * self->incr) { - lf_print_error_and_exit("Failed to receive all five expected inputs."); - } - =} + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + // Stop the thread that is scheduling actions. + stop = true; + if (self->count != 5 * self->incr) { + lf_print_error_and_exit("Failed to receive all five expected inputs."); + } + =} } federated reactor(delay: time = 0) { - left = new Looper() - right = new Looper(incr = -1) - left.out -> right.in - right.out -> left.in + left = new Looper() + right = new Looper(incr = -1) + left.out -> right.in + right.out -> left.in } diff --git a/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf b/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf index f9b088b7d1..9d4ed9e4fe 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPrecedence.lf @@ -1,56 +1,56 @@ /** - * This tests that the precedence order of reaction invocation is kept when a - * feedback loop is present in centralized coordination. + * This tests that the precedence order of reaction invocation is kept when a feedback loop is + * present in centralized coordination. * * @author Edward A. Lee * @author Soroush Bateni */ target C { - flags: "-Wall", - coordination: centralized, - coordination-options: { - advance-message-interval: 100 msec - }, - timeout: 5 sec + flags: "-Wall", + coordination: centralized, + coordination-options: { + advance-message-interval: 100 msec + }, + timeout: 5 sec } reactor Looper(incr: int = 1, delay: time = 0 msec) { - input in: int - output out: int - state count: int = 0 - state received_count: int = 0 - timer t(0, 1 sec) + input in: int + output out: int + state count: int = 0 + state received_count: int = 0 + timer t(0, 1 sec) - reaction(t) -> out {= - lf_set(out, self->count); - self->count += self->incr; - =} + reaction(t) -> out {= + lf_set(out, self->count); + self->count += self->incr; + =} - reaction(in) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - self->received_count = self->count; - =} + reaction(in) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + self->received_count = self->count; + =} - reaction(t) {= - if (self->received_count != self->count) { - lf_print_error_and_exit("reaction(t) was invoked before reaction(in). Precedence order was not kept."); - } - =} + reaction(t) {= + if (self->received_count != self->count) { + lf_print_error_and_exit("reaction(t) was invoked before reaction(in). Precedence order was not kept."); + } + =} - reaction(shutdown) {= - lf_print("******* Shutdown invoked."); - if (self->count != 6 * self->incr) { - lf_print_error_and_exit("Failed to receive all six expected inputs."); - } - =} + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + if (self->count != 6 * self->incr) { + lf_print_error_and_exit("Failed to receive all six expected inputs."); + } + =} } federated reactor(delay: time = 0) { - left = new Looper() - right = new Looper(incr = -1) - left.out -> right.in - right.out -> left.in + left = new Looper() + right = new Looper(incr = -1) + left.out -> right.in + right.out -> left.in } diff --git a/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf b/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf index 17177aadb3..da6054251c 100644 --- a/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf +++ b/test/C/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf @@ -1,70 +1,69 @@ /** - * This tests that the precedence order of reaction invocation is kept in the - * hierarchy of reactors when a feedback loop is present in centralized - * coordination. + * This tests that the precedence order of reaction invocation is kept in the hierarchy of reactors + * when a feedback loop is present in centralized coordination. * * @author Edward A. Lee * @author Soroush Bateni */ target C { - flags: "-Wall", - coordination: centralized, - coordination-options: { - advance-message-interval: 100 msec - }, - timeout: 5 sec + flags: "-Wall", + coordination: centralized, + coordination-options: { + advance-message-interval: 100 msec + }, + timeout: 5 sec } reactor Contained(incr: int = 1) { - timer t(0, 1 sec) - input in: int - state count: int = 0 - state received_count: int = 0 + timer t(0, 1 sec) + input in: int + state count: int = 0 + state received_count: int = 0 - reaction(t) {= self->count += self->incr; =} + reaction(t) {= self->count += self->incr; =} - reaction(in) {= self->received_count = self->count; =} + reaction(in) {= self->received_count = self->count; =} - reaction(t) {= - if (self->received_count != self->count) { - lf_print_error_and_exit("reaction(t) was invoked before reaction(in). Precedence order was not kept."); - } - =} + reaction(t) {= + if (self->received_count != self->count) { + lf_print_error_and_exit("reaction(t) was invoked before reaction(in). Precedence order was not kept."); + } + =} } reactor Looper(incr: int = 1, delay: time = 0 msec) { - input in: int - output out: int - state count: int = 0 - timer t(0, 1 sec) + input in: int + output out: int + state count: int = 0 + timer t(0, 1 sec) - c = new Contained(incr = incr) - in -> c.in + c = new Contained(incr = incr) + in -> c.in - reaction(t) -> out {= - lf_print("Sending network output %d", self->count); - lf_set(out, self->count); - self->count += self->incr; - =} + reaction(t) -> out {= + lf_print("Sending network output %d", self->count); + lf_set(out, self->count); + self->count += self->incr; + =} - reaction(in) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} + reaction(in) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + =} - reaction(shutdown) {= - lf_print("******* Shutdown invoked."); - if (self->count != 6 * self->incr) { - lf_print_error_and_exit("Failed to receive all six expected inputs."); - } - =} + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + if (self->count != 6 * self->incr) { + lf_print_error_and_exit("Failed to receive all six expected inputs."); + } + =} } federated reactor(delay: time = 0) { - left = new Looper() - right = new Looper(incr = -1) - left.out -> right.in - right.out -> left.in + left = new Looper() + right = new Looper(incr = -1) + left.out -> right.in + right.out -> left.in } diff --git a/test/C/src/federated/LoopDistributedDecentralized.lf b/test/C/src/federated/LoopDistributedDecentralized.lf index 4350c984b3..387ec55325 100644 --- a/test/C/src/federated/LoopDistributedDecentralized.lf +++ b/test/C/src/federated/LoopDistributedDecentralized.lf @@ -1,81 +1,80 @@ /** - * This tests a feedback loop with physical actions and decentralized - * coordination. + * This tests a feedback loop with physical actions and decentralized coordination. * * @author Edward A. Lee */ target C { - coordination: decentralized, - timeout: 5 sec + coordination: decentralized, + timeout: 5 sec } preamble {= - #include // Defines sleep() - extern bool stop; - void* ping(void* actionref); + #include // Defines sleep() + extern bool stop; + void* ping(void* actionref); =} reactor Looper(incr: int = 1, delay: time = 0 msec, stp_offset: time = 0) { - preamble {= - bool stop = false; - // Thread to trigger an action once every second. - void* ping(void* actionref) { - while(!stop) { - lf_print("Scheduling action."); - lf_schedule(actionref, 0); - sleep(1); - } - return NULL; + preamble {= + bool stop = false; + // Thread to trigger an action once every second. + void* ping(void* actionref) { + while(!stop) { + lf_print("Scheduling action."); + lf_schedule(actionref, 0); + sleep(1); } - =} - input in: int - output out: int - physical action a(stp_offset) - state count: int = 0 + return NULL; + } + =} + input in: int + output out: int + physical action a(stp_offset) + state count: int = 0 - reaction(startup) -> a {= - // Start the thread that listens for Enter or Return. - lf_thread_t thread_id; - lf_print("Starting thread."); - lf_thread_create(&thread_id, &ping, a); - =} + reaction(startup) -> a {= + // Start the thread that listens for Enter or Return. + lf_thread_t thread_id; + lf_print("Starting thread."); + lf_thread_create(&thread_id, &ping, a); + =} - reaction(a) -> out {= - lf_print("Setting out."); - lf_set(out, self->count); - self->count += self->incr; - =} + reaction(a) -> out {= + lf_print("Setting out."); + lf_set(out, self->count); + self->count += self->incr; + =} - reaction(in) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} STP(stp_offset) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("STP offset was violated. Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} deadline(10 msec) {= - instant_t time_lag = lf_time_physical() - lf_time_logical(); - char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 - lf_comma_separated_time(time_buffer, time_lag); - lf_print("Deadline miss. Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); - =} + reaction(in) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + =} STP(stp_offset) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("STP offset was violated. Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + =} deadline(10 msec) {= + instant_t time_lag = lf_time_physical() - lf_time_logical(); + char time_buffer[28]; // 28 bytes is enough for the largest 64 bit number: 9,223,372,036,854,775,807 + lf_comma_separated_time(time_buffer, time_lag); + lf_print("Deadline miss. Received %d. Logical time is behind physical time by %s nsec.", in->value, time_buffer); + =} - reaction(shutdown) {= - lf_print("******* Shutdown invoked."); - // Stop the thread that is scheduling actions. - stop = true; - if (self->count != 5 * self->incr) { - lf_print_error_and_exit("Failed to receive all five expected inputs."); - } - =} + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + // Stop the thread that is scheduling actions. + stop = true; + if (self->count != 5 * self->incr) { + lf_print_error_and_exit("Failed to receive all five expected inputs."); + } + =} } federated reactor LoopDistributedDecentralized(delay: time = 0) { - left = new Looper(stp_offset = 900 usec) - right = new Looper(incr = -1, stp_offset = 2400 usec) - left.out -> right.in - right.out -> left.in + left = new Looper(stp_offset = 900 usec) + right = new Looper(incr = -1, stp_offset = 2400 usec) + left.out -> right.in + right.out -> left.in } diff --git a/test/C/src/federated/LoopDistributedDouble.lf b/test/C/src/federated/LoopDistributedDouble.lf index 9a49b5bde8..69c84799c7 100644 --- a/test/C/src/federated/LoopDistributedDouble.lf +++ b/test/C/src/federated/LoopDistributedDouble.lf @@ -1,99 +1,98 @@ /** - * This tests a feedback loop with physical actions and centralized - * coordination. + * This tests a feedback loop with physical actions and centralized coordination. * * @author Edward A. Lee */ target C { - flags: "-Wall", - coordination: centralized, - coordination-options: { - advance-message-interval: 100 msec - }, - timeout: 5 sec + flags: "-Wall", + coordination: centralized, + coordination-options: { + advance-message-interval: 100 msec + }, + timeout: 5 sec } preamble {= - #include // Defines sleep() - extern bool stop; - void* ping(void* actionref); + #include // Defines sleep() + extern bool stop; + void* ping(void* actionref); =} reactor Looper(incr: int = 1, delay: time = 0 msec) { - preamble {= - bool stop = false; - // Thread to trigger an action once every second. - void* ping(void* actionref) { - while(!stop) { - lf_print("Scheduling action."); - lf_schedule(actionref, 0); - sleep(1); - } - return NULL; + preamble {= + bool stop = false; + // Thread to trigger an action once every second. + void* ping(void* actionref) { + while(!stop) { + lf_print("Scheduling action."); + lf_schedule(actionref, 0); + sleep(1); } - =} - input in: int - input in2: int - output out: int - output out2: int - physical action a(delay) - state count: int = 0 - timer t(0, 1 sec) + return NULL; + } + =} + input in: int + input in2: int + output out: int + output out2: int + physical action a(delay) + state count: int = 0 + timer t(0, 1 sec) - reaction(startup) -> a {= - // Start the thread that listens for Enter or Return. - lf_thread_t thread_id; - lf_print("Starting thread."); - lf_thread_create(&thread_id, &ping, a); - =} + reaction(startup) -> a {= + // Start the thread that listens for Enter or Return. + lf_thread_t thread_id; + lf_print("Starting thread."); + lf_thread_create(&thread_id, &ping, a); + =} - reaction(a) -> out, out2 {= - if (self->count%2 == 0) { - lf_set(out, self->count); - } else { - lf_set(out2, self->count); - } - self->count += self->incr; - =} + reaction(a) -> out, out2 {= + if (self->count%2 == 0) { + lf_set(out, self->count); + } else { + lf_set(out2, self->count); + } + self->count += self->incr; + =} - reaction(in) {= - tag_t current_tag = lf_tag(); - lf_print("Received %d at logical time (%lld, %d).", - in->value, - current_tag.time - lf_time_start(), current_tag.microstep - ); - =} + reaction(in) {= + tag_t current_tag = lf_tag(); + lf_print("Received %d at logical time (%lld, %d).", + in->value, + current_tag.time - lf_time_start(), current_tag.microstep + ); + =} - reaction(in2) {= - tag_t current_tag = lf_tag(); - lf_print("Received %d on in2 at logical time (%lld, %d).", - in2->value, - current_tag.time - lf_time_start(), current_tag.microstep - ); - =} + reaction(in2) {= + tag_t current_tag = lf_tag(); + lf_print("Received %d on in2 at logical time (%lld, %d).", + in2->value, + current_tag.time - lf_time_start(), current_tag.microstep + ); + =} - reaction(t) {= - tag_t current_tag = lf_tag(); - lf_print("Timer triggered at logical time (%lld, %d).", - current_tag.time - lf_time_start(), current_tag.microstep - ); - =} + reaction(t) {= + tag_t current_tag = lf_tag(); + lf_print("Timer triggered at logical time (%lld, %d).", + current_tag.time - lf_time_start(), current_tag.microstep + ); + =} - reaction(shutdown) {= - lf_print("******* Shutdown invoked."); - // Stop the thread that is scheduling actions. - stop = true; - if (self->count != 5 * self->incr) { - lf_print_error_and_exit("Failed to receive all five expected inputs."); - } - =} + reaction(shutdown) {= + lf_print("******* Shutdown invoked."); + // Stop the thread that is scheduling actions. + stop = true; + if (self->count != 5 * self->incr) { + lf_print_error_and_exit("Failed to receive all five expected inputs."); + } + =} } federated reactor(delay: time = 0) { - left = new Looper() - right = new Looper(incr = -1) - left.out -> right.in - right.out -> left.in - right.out2 -> left.in2 - left.out2 -> right.in2 + left = new Looper() + right = new Looper(incr = -1) + left.out -> right.in + right.out -> left.in + right.out2 -> left.in2 + left.out2 -> right.in2 } diff --git a/test/C/src/federated/PhysicalSTP.lf b/test/C/src/federated/PhysicalSTP.lf index 11b7a259cf..130ca02996 100644 --- a/test/C/src/federated/PhysicalSTP.lf +++ b/test/C/src/federated/PhysicalSTP.lf @@ -1,47 +1,44 @@ -/** - * This is a test that detects STP violations according to the physical time of - * message arrival. - */ +/** This is a test that detects STP violations according to the physical time of message arrival. */ target C { - timeout: 1900 msec, - coordination: decentralized + timeout: 1900 msec, + coordination: decentralized } import Count from "../lib/Count.lf" reactor Print(STP_offset_param: time = 0) { - input in: int - state c: int = 1 + input in: int + state c: int = 1 - reaction(in) {= - interval_t elapsed_time = lf_time_logical_elapsed(); - lf_print("At time %lld, received %d", elapsed_time, in->value); - if (in->value != self->c) { - lf_print_error_and_exit("Expected to receive %d.", self->c); - } - instant_t STP_discrepency = lf_time_logical() + self->STP_offset_param - in->physical_time_of_arrival; - if (STP_discrepency < 0) { - lf_print("The message has violated the STP offset by %lld in physical time.", -1 * STP_discrepency); - self->c++; - } else { - lf_print_error_and_exit("Message arrived %lld early.", STP_discrepency); - } - =} STP(STP_offset_param) {= - // This STP handler should never be invoked because the only source of event - // for Print is the Count reactor. - lf_print_error_and_exit("Logical STP violation was detected. Only physical STP violations are possible."); - =} + reaction(in) {= + interval_t elapsed_time = lf_time_logical_elapsed(); + lf_print("At time %lld, received %d", elapsed_time, in->value); + if (in->value != self->c) { + lf_print_error_and_exit("Expected to receive %d.", self->c); + } + instant_t STP_discrepency = lf_time_logical() + self->STP_offset_param - in->physical_time_of_arrival; + if (STP_discrepency < 0) { + lf_print("The message has violated the STP offset by %lld in physical time.", -1 * STP_discrepency); + self->c++; + } else { + lf_print_error_and_exit("Message arrived %lld early.", STP_discrepency); + } + =} STP(STP_offset_param) {= + // This STP handler should never be invoked because the only source of event + // for Print is the Count reactor. + lf_print_error_and_exit("Logical STP violation was detected. Only physical STP violations are possible."); + =} - reaction(shutdown) {= - if (self->c != 3) { - lf_print_error_and_exit("Expected to receive 2 items but got %d.", self->c); - } - =} + reaction(shutdown) {= + if (self->c != 3) { + lf_print_error_and_exit("Expected to receive 2 items but got %d.", self->c); + } + =} } federated reactor { - c = new Count(offset = 1 msec, period = 1 sec) - p = new Print(STP_offset_param = 1 usec) + c = new Count(offset = 1 msec, period = 1 sec) + p = new Print(STP_offset_param = 1 usec) - c.out -> p.in + c.out -> p.in } diff --git a/test/C/src/federated/PingPongDistributed.lf b/test/C/src/federated/PingPongDistributed.lf index e16de50ed2..5fcc1bf32b 100644 --- a/test/C/src/federated/PingPongDistributed.lf +++ b/test/C/src/federated/PingPongDistributed.lf @@ -1,21 +1,18 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. * - * This version is distributed, communicating using logical connections over - * sockets. + * This version is distributed, communicating using logical connections over sockets. * - * See [Benchmarks wiki - * page](https://github.com/icyphy/lingua-franca/wiki/Benchmarks). + * See [Benchmarks wiki page](https://github.com/icyphy/lingua-franca/wiki/Benchmarks). * * This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs - * and can be run on different machines. + * This is a distributed version, where Ping and Pong run in separate programs and can be run on + * different machines. * - * There is no parallelism in this application, so it does not benefit from - * being being distributed. + * There is no parallelism in this application, so it does not benefit from being being distributed. * * @author Edward A. Lee */ @@ -24,8 +21,8 @@ target C import Ping, Pong from "PingPongDistributedPhysical.lf" federated reactor(count: int = 10) { - ping = new Ping(count = count) - pong = new Pong(expected = count) - ping.send -> pong.receive - pong.send -> ping.receive + ping = new Ping(count = count) + pong = new Pong(expected = count) + ping.send -> pong.receive + pong.send -> ping.receive } diff --git a/test/C/src/federated/PingPongDistributedPhysical.lf b/test/C/src/federated/PingPongDistributedPhysical.lf index d9ba517c59..63ea109a14 100644 --- a/test/C/src/federated/PingPongDistributedPhysical.lf +++ b/test/C/src/federated/PingPongDistributedPhysical.lf @@ -1,79 +1,77 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. * - * This version is distributed, communicating using physical connections over - * sockets. + * This version is distributed, communicating using physical connections over sockets. * * This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs - * and can be run on different machines. + * This is a distributed version, where Ping and Pong run in separate programs and can be run on + * different machines. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * - Unthreaded: 97 msec * - Threaded: 265 msec * - Distributed: 53 seconds * - * There is no parallelism in this application, so it does not benefit from - * being being distributed. + * There is no parallelism in this application, so it does not benefit from being being distributed. * - * These measurements are total execution time, including startup and shutdown, - * of all three programs. + * These measurements are total execution time, including startup and shutdown, of all three + * programs. * * @author Edward A. Lee */ target C reactor Ping(count: int = 10) { - input receive: int - output send: int - state pingsLeft: int = count - logical action serve + input receive: int + output send: int + state pingsLeft: int = count + logical action serve - reaction(startup, serve) -> send {= - printf("At logical time %lld, Ping sending %d.\n", lf_time_logical_elapsed(), self->pingsLeft); - lf_set(send, self->pingsLeft--); - =} + reaction(startup, serve) -> send {= + printf("At logical time %lld, Ping sending %d.\n", lf_time_logical_elapsed(), self->pingsLeft); + lf_set(send, self->pingsLeft--); + =} - reaction(receive) -> serve {= - if (self->pingsLeft > 0) { - lf_schedule(serve, 0); - } else { - lf_request_stop(); - } - =} + reaction(receive) -> serve {= + if (self->pingsLeft > 0) { + lf_schedule(serve, 0); + } else { + lf_request_stop(); + } + =} } reactor Pong(expected: int = 10) { - input receive: int - output send: int - state count: int = 0 + input receive: int + output send: int + state count: int = 0 - reaction(receive) -> send {= - self->count++; - printf("At logical time %lld, Pong received %d.\n", lf_time_logical_elapsed(), receive->value); - lf_set(send, receive->value); - if (self->count == self->expected) { - lf_request_stop(); - } - =} + reaction(receive) -> send {= + self->count++; + printf("At logical time %lld, Pong received %d.\n", lf_time_logical_elapsed(), receive->value); + lf_set(send, receive->value); + if (self->count == self->expected) { + lf_request_stop(); + } + =} - reaction(shutdown) {= - if (self->count != self->expected) { - fprintf(stderr, "Pong expected to receive %d inputs, but it received %d.\n", - self->expected, self->count - ); - exit(1); - } - printf("Pong received %d pings.\n", self->count); - =} + reaction(shutdown) {= + if (self->count != self->expected) { + fprintf(stderr, "Pong expected to receive %d inputs, but it received %d.\n", + self->expected, self->count + ); + exit(1); + } + printf("Pong received %d pings.\n", self->count); + =} } federated reactor(count: int = 10) { - ping = new Ping(count = count) - pong = new Pong(expected = count) - ping.send ~> pong.receive - pong.send ~> ping.receive + ping = new Ping(count = count) + pong = new Pong(expected = count) + ping.send ~> pong.receive + pong.send ~> ping.receive } diff --git a/test/C/src/federated/TopLevelArtifacts.lf b/test/C/src/federated/TopLevelArtifacts.lf index 05932b1937..8332821089 100644 --- a/test/C/src/federated/TopLevelArtifacts.lf +++ b/test/C/src/federated/TopLevelArtifacts.lf @@ -1,41 +1,40 @@ /** - * Test whether top-level reactions, actions, and ports are handled - * appropriately. + * Test whether top-level reactions, actions, and ports are handled appropriately. * * Currently, these artifacts are replicated on all federates. * - * @note This just tests for the correctness of the code generation. These - * top-level artifacts might be disallowed in the future. + * @note This just tests for the correctness of the code generation. These top-level artifacts might + * be disallowed in the future. */ target C { - timeout: 1 msec + timeout: 1 msec } import Count from "../lib/Count.lf" import TestCount from "../lib/TestCount.lf" federated reactor { - state successes: int = 0 - timer t(0, 1 sec) - logical action act(0) + state successes: int = 0 + timer t(0, 1 sec) + logical action act(0) - c = new Count() - tc = new TestCount() - c.out -> tc.in + c = new Count() + tc = new TestCount() + c.out -> tc.in - reaction(startup) {= self->successes++; =} + reaction(startup) {= self->successes++; =} - reaction(t) -> act {= - self->successes++; - lf_schedule(act, 0); - =} + reaction(t) -> act {= + self->successes++; + lf_schedule(act, 0); + =} - reaction(act) {= self->successes++; =} + reaction(act) {= self->successes++; =} - reaction(shutdown) {= - if (self->successes != 3) { - lf_print_error_and_exit("Failed to properly execute top-level reactions"); - } - lf_print("SUCCESS!"); - =} + reaction(shutdown) {= + if (self->successes != 3) { + lf_print_error_and_exit("Failed to properly execute top-level reactions"); + } + lf_print("SUCCESS!"); + =} } diff --git a/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf b/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf index f6ce5edcc1..bf6ff377e6 100644 --- a/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf +++ b/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf @@ -1,23 +1,20 @@ -/** - * This simple test checks if federate authentication works by adding `auth` - * target property. - */ +/** This simple test checks if federate authentication works by adding `auth` target property. */ target C { - timeout: 2 secs, - build-type: RelWithDebInfo, - auth: true, - logging: DEBUG + timeout: 2 secs, + build-type: RelWithDebInfo, + auth: true, + logging: DEBUG } reactor Fed { - input in: int - output out: int + input in: int + output out: int } federated reactor { - fed1 = new Fed() - fed2 = new Fed() + fed1 = new Fed() + fed2 = new Fed() - fed1.out -> fed2.in - fed2.out -> fed1.in + fed1.out -> fed2.in + fed2.out -> fed1.in } diff --git a/test/C/src/lib/Count.lf b/test/C/src/lib/Count.lf index 70291e783f..5b8d7b5844 100644 --- a/test/C/src/lib/Count.lf +++ b/test/C/src/lib/Count.lf @@ -1,9 +1,9 @@ target C reactor Count(offset: time = 0, period: time = 1 sec) { - state count: int = 1 - output out: int - timer t(offset, period) + state count: int = 1 + output out: int + timer t(offset, period) - reaction(t) -> out {= lf_set(out, self->count++); =} + reaction(t) -> out {= lf_set(out, self->count++); =} } diff --git a/test/C/src/lib/FileLevelPreamble.lf b/test/C/src/lib/FileLevelPreamble.lf index 846ed66163..f11186979d 100644 --- a/test/C/src/lib/FileLevelPreamble.lf +++ b/test/C/src/lib/FileLevelPreamble.lf @@ -1,13 +1,10 @@ -/** - * Test for ensuring that file-level preambles are inherited when a file is - * imported. - */ +/** Test for ensuring that file-level preambles are inherited when a file is imported. */ target C preamble {= - #define FOO 2 + #define FOO 2 =} reactor FileLevelPreamble { - reaction(startup) {= printf("FOO: %d\n", FOO); =} + reaction(startup) {= printf("FOO: %d\n", FOO); =} } diff --git a/test/C/src/lib/InternalDelay.lf b/test/C/src/lib/InternalDelay.lf index fbbf2f0cb6..fe03eec9b9 100644 --- a/test/C/src/lib/InternalDelay.lf +++ b/test/C/src/lib/InternalDelay.lf @@ -1,11 +1,11 @@ target C reactor InternalDelay(delay: int = 10 msec) { - input in: int - output out: int - logical action d: int + input in: int + output out: int + logical action d: int - reaction(in) -> d {= lf_schedule_int(d, self->delay, in->value); =} + reaction(in) -> d {= lf_schedule_int(d, self->delay, in->value); =} - reaction(d) -> out {= lf_set(out, d->value); =} + reaction(d) -> out {= lf_set(out, d->value); =} } diff --git a/test/C/src/lib/LoopedActionSender.lf b/test/C/src/lib/LoopedActionSender.lf index b996fe6ac5..e4f52c75c3 100644 --- a/test/C/src/lib/LoopedActionSender.lf +++ b/test/C/src/lib/LoopedActionSender.lf @@ -6,31 +6,30 @@ target C /** - * @param take_a_break_after: Indicates how many messages are sent in - * consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break - * after sending take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break after sending + * take_a_break_after messages. */ reactor Sender(take_a_break_after: int = 10, break_interval: time = 400 msec) { - output out: int - logical action act - state sent_messages: int = 0 + output out: int + logical action act + state sent_messages: int = 0 - reaction(startup, act) -> act, out {= - // Send a message on out - /* printf("At tag (%lld, %u) sending value %d.\n", - lf_time_logical_elapsed(), - lf_tag().microstep, - self->sent_messages - ); */ - lf_set(out, self->sent_messages); - self->sent_messages++; - if (self->sent_messages < self->take_a_break_after) { - lf_schedule(act, 0); - } else { - // Take a break - self->sent_messages=0; - lf_schedule(act, self->break_interval); - } - =} + reaction(startup, act) -> act, out {= + // Send a message on out + /* printf("At tag (%lld, %u) sending value %d.\n", + lf_time_logical_elapsed(), + lf_tag().microstep, + self->sent_messages + ); */ + lf_set(out, self->sent_messages); + self->sent_messages++; + if (self->sent_messages < self->take_a_break_after) { + lf_schedule(act, 0); + } else { + // Take a break + self->sent_messages=0; + lf_schedule(act, self->break_interval); + } + =} } diff --git a/test/C/src/lib/PassThrough.lf b/test/C/src/lib/PassThrough.lf index 54185901e2..90d9138c09 100644 --- a/test/C/src/lib/PassThrough.lf +++ b/test/C/src/lib/PassThrough.lf @@ -2,8 +2,8 @@ target C reactor PassThrough { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= lf_set(out, in->value); =} + reaction(in) -> out {= lf_set(out, in->value); =} } diff --git a/test/C/src/lib/Test.lf b/test/C/src/lib/Test.lf index 3ad7518d4e..6feab88015 100644 --- a/test/C/src/lib/Test.lf +++ b/test/C/src/lib/Test.lf @@ -1,15 +1,15 @@ target C reactor TestDouble(expected: double[] = {1.0, 1.0, 1.0, 1.0}) { - input in: double - state count: int = 0 + input in: double + state count: int = 0 - reaction(in) {= - printf("Received: %f\n", in->value); - if (in->value != self->expected[self->count]) { - printf("ERROR: Expected %f.\n", self->expected[self->count]); - exit(1); - } - self->count++; - =} + reaction(in) {= + printf("Received: %f\n", in->value); + if (in->value != self->expected[self->count]) { + printf("ERROR: Expected %f.\n", self->expected[self->count]); + exit(1); + } + self->count++; + =} } diff --git a/test/C/src/lib/TestCount.lf b/test/C/src/lib/TestCount.lf index d3f29aec6c..570cc7fe3e 100644 --- a/test/C/src/lib/TestCount.lf +++ b/test/C/src/lib/TestCount.lf @@ -1,7 +1,6 @@ /** - * Test that a counting sequence of inputs starts with the specified start - * parameter value, increments by the specified stride, and receives the - * specified number of inputs. + * Test that a counting sequence of inputs starts with the specified start parameter value, + * increments by the specified stride, and receives the specified number of inputs. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. @@ -10,26 +9,26 @@ target C reactor TestCount(start: int = 1, stride: int = 1, num_inputs: int = 1) { - state count: int = start - state inputs_received: int = 0 - input in: int + state count: int = start + state inputs_received: int = 0 + input in: int - reaction(in) {= - lf_print("Received %d.", in->value); - if (in->value != self->count) { - lf_print_error_and_exit("Expected %d.", self->count); - } - self->count += self->stride; - self->inputs_received++; - =} + reaction(in) {= + lf_print("Received %d.", in->value); + if (in->value != self->count) { + lf_print_error_and_exit("Expected %d.", self->count); + } + self->count += self->stride; + self->inputs_received++; + =} - reaction(shutdown) {= - lf_print("Shutdown invoked."); - if (self->inputs_received != self->num_inputs) { - lf_print_error_and_exit("Expected to receive %d inputs, but got %d.", - self->num_inputs, - self->inputs_received - ); - } - =} + reaction(shutdown) {= + lf_print("Shutdown invoked."); + if (self->inputs_received != self->num_inputs) { + lf_print_error_and_exit("Expected to receive %d inputs, but got %d.", + self->num_inputs, + self->inputs_received + ); + } + =} } diff --git a/test/C/src/lib/TestCountMultiport.lf b/test/C/src/lib/TestCountMultiport.lf index 5a2db4b029..69ec75adec 100644 --- a/test/C/src/lib/TestCountMultiport.lf +++ b/test/C/src/lib/TestCountMultiport.lf @@ -1,47 +1,41 @@ /** - * Test that a counting sequence of inputs starts with the specified start - * parameter value, increments by the specified stride, and receives the - * specified number of inputs. This version has a multiport input, and each - * input is expected to be present and incremented over the previous input. + * Test that a counting sequence of inputs starts with the specified start parameter value, + * increments by the specified stride, and receives the specified number of inputs. This version has + * a multiport input, and each input is expected to be present and incremented over the previous + * input. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. - * @param num_inputs The number of inputs expected on each channel. Default is - * 1. + * @param num_inputs The number of inputs expected on each channel. Default is 1. */ target C -reactor TestCountMultiport( - start: int = 1, - stride: int = 1, - num_inputs: int = 1, - width: int = 2 -) { - state count: int = start - state inputs_received: int = 0 - input[width] in: int +reactor TestCountMultiport(start: int = 1, stride: int = 1, num_inputs: int = 1, width: int = 2) { + state count: int = start + state inputs_received: int = 0 + input[width] in: int - reaction(in) {= - for (int i = 0; i < in_width; i++) { - if (!in[i]->is_present) { - lf_print_error_and_exit("No input on channel %d.", i); - } - lf_print("Received %d on channel %d.", in[i]->value, i); - if (in[i]->value != self->count) { - lf_print_error_and_exit("Expected %d.", self->count); - } - self->count += self->stride; + reaction(in) {= + for (int i = 0; i < in_width; i++) { + if (!in[i]->is_present) { + lf_print_error_and_exit("No input on channel %d.", i); } - self->inputs_received++; - =} - - reaction(shutdown) {= - lf_print("Shutdown invoked."); - if (self->inputs_received != self->num_inputs) { - lf_print_error_and_exit("Expected to receive %d inputs, but only got %d.", - self->num_inputs, - self->inputs_received - ); + lf_print("Received %d on channel %d.", in[i]->value, i); + if (in[i]->value != self->count) { + lf_print_error_and_exit("Expected %d.", self->count); } - =} + self->count += self->stride; + } + self->inputs_received++; + =} + + reaction(shutdown) {= + lf_print("Shutdown invoked."); + if (self->inputs_received != self->num_inputs) { + lf_print_error_and_exit("Expected to receive %d inputs, but only got %d.", + self->num_inputs, + self->inputs_received + ); + } + =} } diff --git a/test/C/src/modal_models/BanksCount3ModesComplex.lf b/test/C/src/modal_models/BanksCount3ModesComplex.lf index 47805f1009..b8afa7064f 100644 --- a/test/C/src/modal_models/BanksCount3ModesComplex.lf +++ b/test/C/src/modal_models/BanksCount3ModesComplex.lf @@ -1,82 +1,78 @@ -/** - * Modal Reactor Test. Tests cycling through modes with banks of reactors and - * complex nesting. - */ +/** Modal Reactor Test. Tests cycling through modes with banks of reactors and complex nesting. */ target C { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } import TraceTesting from "util/TraceTesting.lf" import CounterCycle from "Count3Modes.lf" reactor MetaCounter { - input next: bool - output[2] always: int - output[2] mode1: int - output[2] mode2: int - output[2] never: int + input next: bool + output[2] always: int + output[2] mode1: int + output[2] mode2: int + output[2] never: int - outer_counters = new[2] CounterCycle() - (next)+ -> outer_counters.next - outer_counters.count -> always + outer_counters = new[2] CounterCycle() + (next)+ -> outer_counters.next + outer_counters.count -> always - initial mode One { - mode1_counters = new[2] CounterCycle() + initial mode One { + mode1_counters = new[2] CounterCycle() - (next)+ -> mode1_counters.next - mode1_counters.count -> mode1 + (next)+ -> mode1_counters.next + mode1_counters.count -> mode1 - timer t1(500 msec, 250 msec) - reaction(t1) -> reset(Two) {= lf_set_mode(Two); =} - } + timer t1(500 msec, 250 msec) + reaction(t1) -> reset(Two) {= lf_set_mode(Two); =} + } - mode Two { - mode2_counters = new[2] CounterCycle() + mode Two { + mode2_counters = new[2] CounterCycle() - (next)+ -> mode2_counters.next - mode2_counters.count -> mode2 + (next)+ -> mode2_counters.next + mode2_counters.count -> mode2 - timer t2(500 msec, 250 msec) - reaction(t2) -> history(One) {= lf_set_mode(One); =} - } + timer t2(500 msec, 250 msec) + reaction(t2) -> history(One) {= lf_set_mode(One); =} + } - mode Three { - mode3_counters = new[2] CounterCycle() + mode Three { + mode3_counters = new[2] CounterCycle() - (next)+ -> mode3_counters.next - mode3_counters.count -> never - } + (next)+ -> mode3_counters.next + mode3_counters.count -> never + } } main reactor { - timer stepper(0, 250 msec) - counters = new[2] MetaCounter() - test = new TraceTesting( // keep-format - events_size = 16, - trace_size = 429, - trace = { - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 250000000,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, - 250000000,1,2,1,2,1,2,1,2,0,3,0,3,0,3,0,3,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, - 250000000,1,3,1,3,1,3,1,3,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, - 250000000,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, - 250000000,1,2,1,2,1,2,1,2,0,1,0,1,0,1,0,1,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, - 250000000,1,3,1,3,1,3,1,3,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, - 250000000,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,2,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, - 250000000,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, - 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, - 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0 - }, training = false) + timer stepper(0, 250 msec) + counters = new[2] MetaCounter() + test = new TraceTesting( // keep-format + events_size = 16, + trace_size = 429, + trace = { + 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 250000000,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, + 250000000,1,2,1,2,1,2,1,2,0,3,0,3,0,3,0,3,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, + 250000000,1,3,1,3,1,3,1,3,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, + 250000000,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, + 250000000,1,2,1,2,1,2,1,2,0,1,0,1,0,1,0,1,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, + 250000000,1,3,1,3,1,3,1,3,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, + 250000000,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,2,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, + 250000000,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, + 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, + 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0 + }, training = false) - counters.always, counters.mode1, counters.mode2, counters.never - -> test.events + counters.always, counters.mode1, counters.mode2, counters.never -> test.events - reaction(stepper) -> counters.next {= // Trigger - for(int i = 0; i < 2; i++) { - lf_set(counters[i].next, true); - } - =} + reaction(stepper) -> counters.next {= // Trigger + for(int i = 0; i < 2; i++) { + lf_set(counters[i].next, true); + } + =} } diff --git a/test/C/src/modal_models/BanksCount3ModesSimple.lf b/test/C/src/modal_models/BanksCount3ModesSimple.lf index 40c2ba50a8..8ca84403c9 100644 --- a/test/C/src/modal_models/BanksCount3ModesSimple.lf +++ b/test/C/src/modal_models/BanksCount3ModesSimple.lf @@ -1,37 +1,32 @@ /** Modal Reactor Test. Tests cycling through modes with banks of reactors. */ target C { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } import TraceTesting from "util/TraceTesting.lf" import CounterCycle from "Count3Modes.lf" main reactor { - timer stepper(0, 250 msec) - counters = new[3] CounterCycle() - test = new TraceTesting( - events_size = 3, - trace_size = 63, - trace = { // keep-format - 0,1,1,1,1,1,1, - 250000000,1,2,1,2,1,2, - 250000000,1,3,1,3,1,3, - 250000000,1,1,1,1,1,1, - 250000000,1,2,1,2,1,2, - 250000000,1,3,1,3,1,3, - 250000000,1,1,1,1,1,1, - 250000000,1,2,1,2,1,2, - 250000000,1,3,1,3,1,3 - }, - training = false - ) + timer stepper(0, 250 msec) + counters = new[3] CounterCycle() + test = new TraceTesting(events_size = 3, trace_size = 63, trace = { // keep-format + 0,1,1,1,1,1,1, + 250000000,1,2,1,2,1,2, + 250000000,1,3,1,3,1,3, + 250000000,1,1,1,1,1,1, + 250000000,1,2,1,2,1,2, + 250000000,1,3,1,3,1,3, + 250000000,1,1,1,1,1,1, + 250000000,1,2,1,2,1,2, + 250000000,1,3,1,3,1,3 + }, training = false) - counters.count -> test.events + counters.count -> test.events - reaction(stepper) -> counters.next {= // Trigger - for(int i = 0; i < 3; i++) { - lf_set(counters[i].next, true); - } - =} + reaction(stepper) -> counters.next {= // Trigger + for(int i = 0; i < 3; i++) { + lf_set(counters[i].next, true); + } + =} } diff --git a/test/C/src/modal_models/BanksModalStateReset.lf b/test/C/src/modal_models/BanksModalStateReset.lf index 8e075715c8..d8130611c7 100644 --- a/test/C/src/modal_models/BanksModalStateReset.lf +++ b/test/C/src/modal_models/BanksModalStateReset.lf @@ -1,10 +1,7 @@ -/** - * Modal Reactor Test. Tests reset of state variables in modes with banks of - * reactors. - */ +/** Modal Reactor Test. Tests reset of state variables in modes with banks of reactors. */ target C { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" @@ -12,52 +9,51 @@ import Modal as ResetReaction from "ModalStateReset.lf" import Modal as AutoReset from "ModalStateResetAuto.lf" main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - reset1 = new[2] ResetReaction() - reset2 = new[2] AutoReset() - test = new TraceTesting(events_size = 16, trace_size = 627, trace = { // keep-format - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, - 250000000,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, 0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, - 250000000,0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, 0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, - 250000000,0,0,0,0,0,0,0,0,1,3,1,3,0,0,0,0, 0,0,0,0,0,0,0,0,1,3,1,3,0,0,0,0, - 250000000,1,1,1,1,1,0,1,0,1,4,1,4,0,0,0,0, 1,1,1,1,1,0,1,0,1,4,1,4,0,0,0,0, - 0,0,1,0,1,0,0,0,0,0,4,0,4,1,-2,1,-2, 0,1,0,1,0,0,0,0,0,4,0,4,1,-2,1,-2, - 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,-1,1,-1, 0,1,0,1,0,0,0,0,0,4,0,4,1,-1,1,-1, - 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,0,1,0, 0,1,0,1,0,0,0,0,0,4,0,4,1,0,1,0, - 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,1,1,1, 0,1,0,1,0,0,0,0,0,4,0,4,1,1,1,1, - 250000000,1,1,1,1,1,1,1,1,0,4,0,4,1,2,1,2, 1,1,1,1,1,1,1,1,0,4,0,4,1,2,1,2, - 250000000,0,1,0,1,0,1,0,1,1,5,1,5,0,2,0,2, 0,1,0,1,0,1,0,1,1,5,1,5,0,2,0,2, - 250000000,0,1,0,1,0,1,0,1,1,6,1,6,0,2,0,2, 0,1,0,1,0,1,0,1,1,6,1,6,0,2,0,2, - 250000000,0,1,0,1,0,1,0,1,1,7,1,7,0,2,0,2, 0,1,0,1,0,1,0,1,1,7,1,7,0,2,0,2, - 250000000,1,1,1,1,1,2,1,2,1,8,1,8,0,2,0,2, 1,1,1,1,1,2,1,2,1,8,1,8,0,2,0,2, - 0,0,1,0,1,0,2,0,2,0,8,0,8,1,-2,1,-2, 0,1,0,1,0,2,0,2,0,8,0,8,1,-2,1,-2, - 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,-1,1,-1, 0,1,0,1,0,2,0,2,0,8,0,8,1,-1,1,-1, - 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, 0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, - 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, 0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, - 250000000,1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2, 1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2 - }, training = false) + reset1 = new[2] ResetReaction() + reset2 = new[2] AutoReset() + test = new TraceTesting(events_size = 16, trace_size = 627, trace = { // keep-format + 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, + 250000000,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, 0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, + 250000000,0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, 0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, + 250000000,0,0,0,0,0,0,0,0,1,3,1,3,0,0,0,0, 0,0,0,0,0,0,0,0,1,3,1,3,0,0,0,0, + 250000000,1,1,1,1,1,0,1,0,1,4,1,4,0,0,0,0, 1,1,1,1,1,0,1,0,1,4,1,4,0,0,0,0, + 0,0,1,0,1,0,0,0,0,0,4,0,4,1,-2,1,-2, 0,1,0,1,0,0,0,0,0,4,0,4,1,-2,1,-2, + 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,-1,1,-1, 0,1,0,1,0,0,0,0,0,4,0,4,1,-1,1,-1, + 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,0,1,0, 0,1,0,1,0,0,0,0,0,4,0,4,1,0,1,0, + 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,1,1,1, 0,1,0,1,0,0,0,0,0,4,0,4,1,1,1,1, + 250000000,1,1,1,1,1,1,1,1,0,4,0,4,1,2,1,2, 1,1,1,1,1,1,1,1,0,4,0,4,1,2,1,2, + 250000000,0,1,0,1,0,1,0,1,1,5,1,5,0,2,0,2, 0,1,0,1,0,1,0,1,1,5,1,5,0,2,0,2, + 250000000,0,1,0,1,0,1,0,1,1,6,1,6,0,2,0,2, 0,1,0,1,0,1,0,1,1,6,1,6,0,2,0,2, + 250000000,0,1,0,1,0,1,0,1,1,7,1,7,0,2,0,2, 0,1,0,1,0,1,0,1,1,7,1,7,0,2,0,2, + 250000000,1,1,1,1,1,2,1,2,1,8,1,8,0,2,0,2, 1,1,1,1,1,2,1,2,1,8,1,8,0,2,0,2, + 0,0,1,0,1,0,2,0,2,0,8,0,8,1,-2,1,-2, 0,1,0,1,0,2,0,2,0,8,0,8,1,-2,1,-2, + 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,-1,1,-1, 0,1,0,1,0,2,0,2,0,8,0,8,1,-1,1,-1, + 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, 0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, + 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, 0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, + 250000000,1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2, 1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2 + }, training = false) - reset1.mode_switch, - reset1.count0, - reset1.count1, - reset1.count2, - reset2.mode_switch, - reset2.count0, - reset2.count1, - reset2.count2 - -> test.events + reset1.mode_switch, + reset1.count0, + reset1.count1, + reset1.count2, + reset2.mode_switch, + reset2.count0, + reset2.count1, + reset2.count2 + -> test.events - // Trigger mode change (separately because of #1278) - reaction(stepper) -> reset1.next {= - for(int i = 0; i < reset1_width; i++) { - lf_set(reset1[i].next, true); - } - =} + reaction(stepper) -> reset1.next {= // Trigger mode change (separately because of #1278) + for(int i = 0; i < reset1_width; i++) { + lf_set(reset1[i].next, true); + } + =} - reaction(stepper) -> reset2.next {= - for(int i = 0; i < reset2_width; i++) { - lf_set(reset2[i].next, true); - } - =} + reaction(stepper) -> reset2.next {= + for(int i = 0; i < reset2_width; i++) { + lf_set(reset2[i].next, true); + } + =} } diff --git a/test/C/src/modal_models/ConvertCaseTest.lf b/test/C/src/modal_models/ConvertCaseTest.lf index 3f644eb133..24afa7439e 100644 --- a/test/C/src/modal_models/ConvertCaseTest.lf +++ b/test/C/src/modal_models/ConvertCaseTest.lf @@ -1,145 +1,135 @@ /** Modal Reactor Test. Tests nested reactors with modes. */ target C { - fast: false, - timeout: 4 sec // logging: debug + fast: false, + timeout: 4 sec // logging: debug } import TraceTesting from "util/TraceTesting.lf" reactor ResetProcessor { - input discard: bool - input character: char - output converted: int - - initial mode Converting { - converter = new Converter() - character -> converter.raw - converter.converted -> converted - reaction(discard) -> reset(Discarding) {= lf_set_mode(Discarding); =} - } - - mode Discarding { - reaction(character) -> converted {= lf_set(converted, '_'); =} - - reaction(character) -> reset(Converting) {= lf_set_mode(Converting); =} - } + input discard: bool + input character: char + output converted: int + + initial mode Converting { + converter = new Converter() + character -> converter.raw + converter.converted -> converted + reaction(discard) -> reset(Discarding) {= lf_set_mode(Discarding); =} + } + + mode Discarding { + reaction(character) -> converted {= lf_set(converted, '_'); =} + + reaction(character) -> reset(Converting) {= lf_set_mode(Converting); =} + } } reactor HistoryProcessor { - input discard: bool - input character: char - output converted: int - - initial mode Converting { - converter = new Converter() - character -> converter.raw - converter.converted -> converted - reaction(discard) -> reset(Discarding) {= lf_set_mode(Discarding); =} - } - - mode Discarding { - reaction(character) -> converted {= lf_set(converted, '_'); =} - - reaction(character) -> history(Converting) {= - lf_set_mode(Converting); - =} - } + input discard: bool + input character: char + output converted: int + + initial mode Converting { + converter = new Converter() + character -> converter.raw + converter.converted -> converted + reaction(discard) -> reset(Discarding) {= lf_set_mode(Discarding); =} + } + + mode Discarding { + reaction(character) -> converted {= lf_set(converted, '_'); =} + + reaction(character) -> history(Converting) {= lf_set_mode(Converting); =} + } } reactor Converter { - input raw: char - output converted: int - - initial mode Upper { - reaction(raw) -> converted, reset(Lower) {= - char c = raw->value; - if (c >= 'a' && c <= 'z') { - lf_set(converted, c - 32); - } else { - lf_set(converted, c); - } - if (c == ' ') { - lf_set_mode(Lower); - } - =} - } - - mode Lower { - reaction(raw) -> converted, reset(Upper) {= - char c = raw->value; - if (c >= 'A' && c <= 'Z') { - lf_set(converted, c + 32); - } else { - lf_set(converted, c); - } - if (c == ' ') { - lf_set_mode(Upper); - } - =} - } + input raw: char + output converted: int + + initial mode Upper { + reaction(raw) -> converted, reset(Lower) {= + char c = raw->value; + if (c >= 'a' && c <= 'z') { + lf_set(converted, c - 32); + } else { + lf_set(converted, c); + } + if (c == ' ') { + lf_set_mode(Lower); + } + =} + } + + mode Lower { + reaction(raw) -> converted, reset(Upper) {= + char c = raw->value; + if (c >= 'A' && c <= 'Z') { + lf_set(converted, c + 32); + } else { + lf_set(converted, c); + } + if (c == ' ') { + lf_set_mode(Upper); + } + =} + } } reactor InputFeeder(message: string = "") { - output character: char - state idx: int = 0 + output character: char + state idx: int = 0 - timer t(0, 250 msec) + timer t(0, 250 msec) - preamble {= - #include - =} + preamble {= + #include + =} - reaction(t) -> character {= - if (self->idx < strlen(self->message)) { - lf_set(character, *(self->message + self->idx)); - self->idx++; - } - =} + reaction(t) -> character {= + if (self->idx < strlen(self->message)) { + lf_set(character, *(self->message + self->idx)); + self->idx++; + } + =} } main reactor { - timer stepper(500 msec, 1 sec) - - feeder = new InputFeeder(message = "Hello World!") - reset_processor = new ResetProcessor() - history_processor = new HistoryProcessor() - - feeder.character -> reset_processor.character - feeder.character -> history_processor.character - - test = new TraceTesting( - events_size = 2, - trace_size = 60, - trace = { // keep-format - 0,1,72,1,72, - 250000000,1,69,1,69, - 250000000,1,76,1,76, - 250000000,1,95,1,95, - 250000000,1,79,1,79, - 250000000,1,32,1,32, - 250000000,1,119,1,119, - 250000000,1,95,1,95, - 250000000,1,82,1,114, - 250000000,1,76,1,108, - 250000000,1,68,1,100, - 250000000,1,95,1,95 - }, - training = false - ) - - reset_processor.converted, history_processor.converted -> test.events - - // Trigger mode change - reaction(stepper) -> reset_processor.discard, history_processor.discard {= - lf_set(reset_processor.discard, true); - lf_set(history_processor.discard, true); - =} - - reaction(reset_processor.converted) {= - printf("Reset: %c\n", reset_processor.converted->value); - =} - - reaction(history_processor.converted) {= - printf("History: %c\n", history_processor.converted->value); - =} + timer stepper(500 msec, 1 sec) + + feeder = new InputFeeder(message = "Hello World!") + reset_processor = new ResetProcessor() + history_processor = new HistoryProcessor() + + feeder.character -> reset_processor.character + feeder.character -> history_processor.character + + test = new TraceTesting(events_size = 2, trace_size = 60, trace = { // keep-format + 0,1,72,1,72, + 250000000,1,69,1,69, + 250000000,1,76,1,76, + 250000000,1,95,1,95, + 250000000,1,79,1,79, + 250000000,1,32,1,32, + 250000000,1,119,1,119, + 250000000,1,95,1,95, + 250000000,1,82,1,114, + 250000000,1,76,1,108, + 250000000,1,68,1,100, + 250000000,1,95,1,95 + }, training = false) + + reset_processor.converted, history_processor.converted -> test.events + + reaction(stepper) -> reset_processor.discard, history_processor.discard {= // Trigger mode change + lf_set(reset_processor.discard, true); + lf_set(history_processor.discard, true); + =} + + reaction(reset_processor.converted) {= printf("Reset: %c\n", reset_processor.converted->value); =} + + reaction(history_processor.converted) {= + printf("History: %c\n", history_processor.converted->value); + =} } diff --git a/test/C/src/modal_models/Count3Modes.lf b/test/C/src/modal_models/Count3Modes.lf index 862915abed..93e5119759 100644 --- a/test/C/src/modal_models/Count3Modes.lf +++ b/test/C/src/modal_models/Count3Modes.lf @@ -1,60 +1,58 @@ /** Modal Reactor Test. Tests cycling through modes. */ target C { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } reactor CounterCycle { - input next: bool - output count: int - - initial mode One { - reaction(next) -> count, reset(Two) {= - lf_set(count, 1); - lf_set_mode(Two); - =} - } + input next: bool + output count: int - mode Two { - reaction(next) -> count, reset(Three) {= - lf_set(count, 2); - lf_set_mode(Three); - =} - } + initial mode One { + reaction(next) -> count, reset(Two) {= + lf_set(count, 1); + lf_set_mode(Two); + =} + } - mode Three { - reaction(next) -> count, reset(One) {= - lf_set(count, 3); - lf_set_mode(One); - =} - } + mode Two { + reaction(next) -> count, reset(Three) {= + lf_set(count, 2); + lf_set_mode(Three); + =} + } + + mode Three { + reaction(next) -> count, reset(One) {= + lf_set(count, 3); + lf_set_mode(One); + =} + } } main reactor { - timer stepper(0, 250 msec) - counter = new CounterCycle() - - state expected_value: int = 1 - - // Trigger - reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} - - // Check - reaction(stepper) counter.count {= - printf("%d\n", counter.count->value); - - if (!counter.count->is_present) { - printf("ERROR: Missing mode change.\n"); - exit(1); - } else if (counter.count->value != self->expected_value) { - printf("ERROR: Wrong mode.\n"); - exit(2); - } - - if (self->expected_value == 3) { - self->expected_value = 1; - } else { - self->expected_value++; - } - =} + timer stepper(0, 250 msec) + counter = new CounterCycle() + + state expected_value: int = 1 + + reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} // Trigger + + reaction(stepper) counter.count {= // Check + printf("%d\n", counter.count->value); + + if (!counter.count->is_present) { + printf("ERROR: Missing mode change.\n"); + exit(1); + } else if (counter.count->value != self->expected_value) { + printf("ERROR: Wrong mode.\n"); + exit(2); + } + + if (self->expected_value == 3) { + self->expected_value = 1; + } else { + self->expected_value++; + } + =} } diff --git a/test/C/src/modal_models/MixedReactions.lf b/test/C/src/modal_models/MixedReactions.lf index 78ea39c95c..274cf77573 100644 --- a/test/C/src/modal_models/MixedReactions.lf +++ b/test/C/src/modal_models/MixedReactions.lf @@ -1,46 +1,46 @@ /** - * Modal Reactor Test. Tests reactions that are defined between and after modes - * and should be ordered accordingly. + * Modal Reactor Test. Tests reactions that are defined between and after modes and should be + * ordered accordingly. */ target C { - fast: true, - timeout: 110 msec + fast: true, + timeout: 110 msec } main reactor { - state x: int = 0 - state first: bool = true + state x: int = 0 + state first: bool = true - timer t(0, 100 msec) + timer t(0, 100 msec) - reaction(t) {= self->x = self->x * 10 + 1; =} + reaction(t) {= self->x = self->x * 10 + 1; =} - reaction(t) {= self->x = self->x * 10 + 2; =} + reaction(t) {= self->x = self->x * 10 + 2; =} - initial mode A { - reaction(t) -> reset(B) {= - self->x = self->x * 10 + 3; - lf_set_mode(B); - =} - } - - reaction(t) {= self->x = self->x * 10 + 4; =} - - mode B { - reaction(t) {= self->x = self->x * 10 + 5; =} - } - - reaction(t) {= - printf("%d\n", self->x); - if (self->first) { - if (self->x != 1234) { - printf("ERROR: Wrong reaction order.\n"); - exit(1); - } - self->first = false; - } else if (self->x != 12341245) { - printf("ERROR: Wrong reaction order.\n"); - exit(2); - } + initial mode A { + reaction(t) -> reset(B) {= + self->x = self->x * 10 + 3; + lf_set_mode(B); =} + } + + reaction(t) {= self->x = self->x * 10 + 4; =} + + mode B { + reaction(t) {= self->x = self->x * 10 + 5; =} + } + + reaction(t) {= + printf("%d\n", self->x); + if (self->first) { + if (self->x != 1234) { + printf("ERROR: Wrong reaction order.\n"); + exit(1); + } + self->first = false; + } else if (self->x != 12341245) { + printf("ERROR: Wrong reaction order.\n"); + exit(2); + } + =} } diff --git a/test/C/src/modal_models/ModalActions.lf b/test/C/src/modal_models/ModalActions.lf index e687d4bafd..594273bb6f 100644 --- a/test/C/src/modal_models/ModalActions.lf +++ b/test/C/src/modal_models/ModalActions.lf @@ -1,100 +1,94 @@ /** - * Modal Reactor Test. Tests actions, their suspension during mode inactivity - * and continuation of delays with history transitions. + * Modal Reactor Test. Tests actions, their suspension during mode inactivity and continuation of + * delays with history transitions. */ target C { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next: bool + input next: bool - output mode_switch: int - output action1_sched: int - output action1_exec: int - output action2_sched: int - output action2_exec: int + output mode_switch: int + output action1_sched: int + output action1_exec: int + output action2_sched: int + output action2_exec: int - initial mode One { - timer T1(0, 750 msec) - logical action delay1(500 msec) - reaction(T1) -> delay1, action1_sched {= - printf("Scheduled Action\n"); - lf_schedule(delay1, 0); - lf_set(action1_sched, 1); - =} + initial mode One { + timer T1(0, 750 msec) + logical action delay1(500 msec) + reaction(T1) -> delay1, action1_sched {= + printf("Scheduled Action\n"); + lf_schedule(delay1, 0); + lf_set(action1_sched, 1); + =} - reaction(delay1) -> action1_exec {= - printf("Executed Action\n"); - lf_set(action1_exec, 1); - =} + reaction(delay1) -> action1_exec {= + printf("Executed Action\n"); + lf_set(action1_exec, 1); + =} - reaction(next) -> reset(Two), mode_switch {= - printf("Transitioning to mode Two (reset)\n"); - lf_set(mode_switch, 1); - lf_set_mode(Two); - =} - } + reaction(next) -> reset(Two), mode_switch {= + printf("Transitioning to mode Two (reset)\n"); + lf_set(mode_switch, 1); + lf_set_mode(Two); + =} + } - mode Two { - timer T2(0, 750 msec) - logical action delay2(500 msec) - reaction(T2) -> delay2, action2_sched {= - printf("Scheduled Action2\n"); - lf_schedule(delay2, 0); - lf_set(action2_sched, 1); - =} + mode Two { + timer T2(0, 750 msec) + logical action delay2(500 msec) + reaction(T2) -> delay2, action2_sched {= + printf("Scheduled Action2\n"); + lf_schedule(delay2, 0); + lf_set(action2_sched, 1); + =} - reaction(delay2) -> action2_exec {= - printf("Executed Action2\n"); - lf_set(action2_exec, 1); - =} + reaction(delay2) -> action2_exec {= + printf("Executed Action2\n"); + lf_set(action2_exec, 1); + =} - reaction(next) -> history(One), mode_switch {= - printf("Transitioning to mode One (continue)\n"); - lf_set(mode_switch, 1); - lf_set_mode(One); - =} - } + reaction(next) -> history(One), mode_switch {= + printf("Transitioning to mode One (continue)\n"); + lf_set(mode_switch, 1); + lf_set_mode(One); + =} + } } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting( - events_size = 5, - trace_size = 165, - trace = { // keep-format - 0,0,0,1,1,0,0,0,0,0,0, - 500000000,0,0,0,1,1,1,0,0,0,0, - 250000000,0,0,1,1,0,1,0,0,0,0, - 250000000,1,1,0,1,0,1,0,0,0,0, - 0,0,1,0,1,0,1,1,1,0,0, - 500000000,0,1,0,1,0,1,0,1,1,1, - 250000000,0,1,0,1,0,1,1,1,0,1, - 250000000,1,1,0,1,0,1,0,1,0,1, - 250000000,0,1,0,1,1,1,0,1,0,1, - 250000000,0,1,1,1,0,1,0,1,0,1, - 500000000,1,1,0,1,1,1,0,1,0,1, - 0,0,1,0,1,0,1,1,1,0,1, - 500000000,0,1,0,1,0,1,0,1,1,1, - 250000000,0,1,0,1,0,1,1,1,0,1, - 250000000,1,1,0,1,0,1,0,1,0,1 - }, - training = false - ) + modal = new Modal() + test = new TraceTesting(events_size = 5, trace_size = 165, trace = { // keep-format + 0,0,0,1,1,0,0,0,0,0,0, + 500000000,0,0,0,1,1,1,0,0,0,0, + 250000000,0,0,1,1,0,1,0,0,0,0, + 250000000,1,1,0,1,0,1,0,0,0,0, + 0,0,1,0,1,0,1,1,1,0,0, + 500000000,0,1,0,1,0,1,0,1,1,1, + 250000000,0,1,0,1,0,1,1,1,0,1, + 250000000,1,1,0,1,0,1,0,1,0,1, + 250000000,0,1,0,1,1,1,0,1,0,1, + 250000000,0,1,1,1,0,1,0,1,0,1, + 500000000,1,1,0,1,1,1,0,1,0,1, + 0,0,1,0,1,0,1,1,1,0,1, + 500000000,0,1,0,1,0,1,0,1,1,1, + 250000000,0,1,0,1,0,1,1,1,0,1, + 250000000,1,1,0,1,0,1,0,1,0,1 + }, training = false) - modal.mode_switch, - modal.action1_sched, - modal.action1_exec, - modal.action2_sched, - modal.action2_exec - -> test.events + modal.mode_switch, + modal.action1_sched, + modal.action1_exec, + modal.action2_sched, + modal.action2_exec + -> test.events - // Trigger mode change - reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} + reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} // Trigger mode change } diff --git a/test/C/src/modal_models/ModalAfter.lf b/test/C/src/modal_models/ModalAfter.lf index f5cc8d229e..f0ddd8ea6e 100644 --- a/test/C/src/modal_models/ModalAfter.lf +++ b/test/C/src/modal_models/ModalAfter.lf @@ -1,105 +1,95 @@ /** - * Modal Reactor Test. Tests after delays, its suspension during mode inactivity - * and continuation with history transitions. + * Modal Reactor Test. Tests after delays, its suspension during mode inactivity and continuation + * with history transitions. */ target C { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next: bool + input next: bool - output mode_switch: int - output produced1: int - output consumed1: int - output produced2: int - output consumed2: int + output mode_switch: int + output produced1: int + output consumed1: int + output produced2: int + output consumed2: int - initial mode One { - producer1 = new Producer(mode_id = 1) - consumer1 = new Consumer(mode_id = 1) - producer1.product -> produced1 - producer1.product -> consumer1.product after 500 msec - consumer1.report -> consumed1 - reaction(next) -> reset(Two), mode_switch {= - printf("Transitioning to mode Two (reset)\n"); - lf_set(mode_switch, 1); - lf_set_mode(Two); - =} - } + initial mode One { + producer1 = new Producer(mode_id = 1) + consumer1 = new Consumer(mode_id = 1) + producer1.product -> produced1 + producer1.product -> consumer1.product after 500 msec + consumer1.report -> consumed1 + reaction(next) -> reset(Two), mode_switch {= + printf("Transitioning to mode Two (reset)\n"); + lf_set(mode_switch, 1); + lf_set_mode(Two); + =} + } - mode Two { - producer2 = new Producer(mode_id = 2) - consumer2 = new Consumer(mode_id = 2) - producer2.product -> produced2 - producer2.product -> consumer2.product after 500 msec - consumer2.report -> consumed2 - reaction(next) -> history(One), mode_switch {= - printf("Transitioning to mode One (continue)\n"); - lf_set(mode_switch, 1); - lf_set_mode(One); - =} - } + mode Two { + producer2 = new Producer(mode_id = 2) + consumer2 = new Consumer(mode_id = 2) + producer2.product -> produced2 + producer2.product -> consumer2.product after 500 msec + consumer2.report -> consumed2 + reaction(next) -> history(One), mode_switch {= + printf("Transitioning to mode One (continue)\n"); + lf_set(mode_switch, 1); + lf_set_mode(One); + =} + } } reactor Producer(mode_id: int = 0) { - output product: int + output product: int - timer t(0, 750 msec) + timer t(0, 750 msec) - reaction(t) -> product {= - printf("Produced in %d\n", self->mode_id); - lf_set(product, 1); - =} + reaction(t) -> product {= + printf("Produced in %d\n", self->mode_id); + lf_set(product, 1); + =} } reactor Consumer(mode_id: int = 0) { - input product: int - output report: int + input product: int + output report: int - reaction(product) -> report {= - printf("Consumed in %d\n", self->mode_id); - lf_set(report, 1); - =} + reaction(product) -> report {= + printf("Consumed in %d\n", self->mode_id); + lf_set(report, 1); + =} } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting( - events_size = 5, - trace_size = 165, - trace = { // keep-format - 0,0,0,1,1,0,0,0,0,0,0, - 500000000,0,0,0,1,1,1,0,0,0,0, - 250000000,0,0,1,1,0,1,0,0,0,0, - 250000000,1,1,0,1,0,1,0,0,0,0, - 0,0,1,0,1,0,1,1,1,0,0, - 500000000,0,1,0,1,0,1,0,1,1,1, - 250000000,0,1,0,1,0,1,1,1,0,1, - 250000000,1,1,0,1,0,1,0,1,0,1, - 250000000,0,1,0,1,1,1,0,1,0,1, - 250000000,0,1,1,1,0,1,0,1,0,1, - 500000000,1,1,0,1,1,1,0,1,0,1, - 0,0,1,0,1,0,1,1,1,0,1, - 500000000,0,1,0,1,0,1,0,1,1,1, - 250000000,0,1,0,1,0,1,1,1,0,1, - 250000000,1,1,0,1,0,1,0,1,0,1 - }, - training = false - ) + modal = new Modal() + test = new TraceTesting(events_size = 5, trace_size = 165, trace = { // keep-format + 0,0,0,1,1,0,0,0,0,0,0, + 500000000,0,0,0,1,1,1,0,0,0,0, + 250000000,0,0,1,1,0,1,0,0,0,0, + 250000000,1,1,0,1,0,1,0,0,0,0, + 0,0,1,0,1,0,1,1,1,0,0, + 500000000,0,1,0,1,0,1,0,1,1,1, + 250000000,0,1,0,1,0,1,1,1,0,1, + 250000000,1,1,0,1,0,1,0,1,0,1, + 250000000,0,1,0,1,1,1,0,1,0,1, + 250000000,0,1,1,1,0,1,0,1,0,1, + 500000000,1,1,0,1,1,1,0,1,0,1, + 0,0,1,0,1,0,1,1,1,0,1, + 500000000,0,1,0,1,0,1,0,1,1,1, + 250000000,0,1,0,1,0,1,1,1,0,1, + 250000000,1,1,0,1,0,1,0,1,0,1 + }, training = false) - modal.mode_switch, - modal.produced1, - modal.consumed1, - modal.produced2, - modal.consumed2 - -> test.events + modal.mode_switch, modal.produced1, modal.consumed1, modal.produced2, modal.consumed2 + -> test.events - // Trigger mode change - reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} + reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} // Trigger mode change } diff --git a/test/C/src/modal_models/ModalCycleBreaker.lf b/test/C/src/modal_models/ModalCycleBreaker.lf index aae727b23d..c411fcbe3b 100644 --- a/test/C/src/modal_models/ModalCycleBreaker.lf +++ b/test/C/src/modal_models/ModalCycleBreaker.lf @@ -1,80 +1,73 @@ /** * Modal Reactor Test. * - * Tests if connections in the same reactor that have the same destination work - * if they are located in separate modes. + * Tests if connections in the same reactor that have the same destination work if they are located + * in separate modes. */ target C { - fast: false, - timeout: 1 sec + fast: false, + timeout: 1 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input in1: int - input in2: int - output out: int + input in1: int + input in2: int + output out: int - // Defining reaction to in2 before in1 would cause cycle if no mode were - // present - mode Two { - timer wait(150 msec, 1 sec) - reaction(in2) {= - // lf_set(out, in2->value); - =} + mode Two { // Defining reaction to in2 before in1 would cause cycle if no mode were present + timer wait(150 msec, 1 sec) + reaction(in2) {= + // lf_set(out, in2->value); + =} - reaction(wait) -> reset(One) {= - lf_set_mode(One); - printf("Switching to mode One\n"); - =} - } + reaction(wait) -> reset(One) {= + lf_set_mode(One); + printf("Switching to mode One\n"); + =} + } - initial mode One { - reaction(in1) -> out {= lf_set(out, in1->value); =} + initial mode One { + reaction(in1) -> out {= lf_set(out, in1->value); =} - reaction(in1) -> reset(Two) {= - if (in1->value % 5 == 4) { - lf_set_mode(Two); - printf("Switching to mode Two\n"); - } - =} - } + reaction(in1) -> reset(Two) {= + if (in1->value % 5 == 4) { + lf_set_mode(Two); + printf("Switching to mode Two\n"); + } + =} + } } reactor Counter(period: time = 1 sec) { - output value: int + output value: int - timer t(0, period) - state curval: int = 0 + timer t(0, period) + state curval: int = 0 - reaction(t) -> value {= lf_set(value, self->curval++); =} + reaction(t) -> value {= lf_set(value, self->curval++); =} } main reactor { - counter = new Counter(period = 100 msec) - modal = new Modal() - test = new TraceTesting( - events_size = 1, - trace_size = 27, - trace = { // keep-format - 0,1,0, - 100000000,1,1, - 100000000,1,2, - 100000000,1,3, - 100000000,1,4, - 200000000,1,6, - 100000000,1,7, - 100000000,1,8, - 100000000,1,9 - }, - training = false - ) + counter = new Counter(period = 100 msec) + modal = new Modal() + test = new TraceTesting(events_size = 1, trace_size = 27, trace = { // keep-format + 0,1,0, + 100000000,1,1, + 100000000,1,2, + 100000000,1,3, + 100000000,1,4, + 200000000,1,6, + 100000000,1,7, + 100000000,1,8, + 100000000,1,9 + }, training = false) - counter.value -> modal.in1 - modal.out -> modal.in2 + counter.value -> modal.in1 + modal.out -> modal.in2 - modal.out -> test.events + modal.out -> test.events - reaction(modal.out) {= printf("%d\n", modal.out->value); =} // Print + reaction(modal.out) {= printf("%d\n", modal.out->value); =} // Print } diff --git a/test/C/src/modal_models/ModalNestedReactions.lf b/test/C/src/modal_models/ModalNestedReactions.lf index f42ad4573f..c17c8abb8b 100644 --- a/test/C/src/modal_models/ModalNestedReactions.lf +++ b/test/C/src/modal_models/ModalNestedReactions.lf @@ -46,7 +46,7 @@ main reactor { reaction(stepper) -> counter.next {= lf_set(counter.next, true); =} // Trigger - reaction(stepper) counter.count, counter.only_in_two {= // Check + reaction(stepper) counter.count, counter.only_in_two {= // Check printf("%d\n", counter.count->value); if (!counter.count->is_present) { diff --git a/test/C/src/modal_models/ModalStartupShutdown.lf b/test/C/src/modal_models/ModalStartupShutdown.lf index d39117882a..389856c9e7 100644 --- a/test/C/src/modal_models/ModalStartupShutdown.lf +++ b/test/C/src/modal_models/ModalStartupShutdown.lf @@ -1,147 +1,141 @@ /** Modal Reactor Test. Test startup/shutdown reactions in modes. */ target C { - fast: false, - timeout: 3000 msec + fast: false, + timeout: 3000 msec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next: bool - - output mode_switch: int - output startup1: int - output startup2: int - output shutdown2: int - output shutdown3: int - output startup4: int - output reset4: int - output shutdown4: int - output startup5: int - output reset5: int - output shutdown5: int - - initial mode One { - reaction(startup) -> startup1 {= - printf("Startup 1 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(startup1, 1); - =} - - reaction(next) -> reset(Two), mode_switch {= - printf("Transitioning to mode 1\n"); - lf_set(mode_switch, 2); - lf_set_mode(Two); - =} - } - - mode Two { - reaction(startup) -> startup2 {= - printf("Startup 2 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(startup2, 1); - =} - - reaction(next) -> reset(Three), mode_switch {= - printf("Transitioning to mode 3\n"); - lf_set(mode_switch, 3); - lf_set_mode(Three); - =} - - reaction(shutdown) -> shutdown2 {= - printf("Shutdown 2 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(shutdown2, 1); - =} - } - - mode Three { - reaction(next) -> reset(Four), mode_switch {= - printf("Transitioning to mode 4\n"); - lf_set(mode_switch, 4); - lf_set_mode(Four); - =} - - reaction(shutdown) -> shutdown3 {= - printf("Shutdown 3 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(shutdown3, 1); - =} - } - - mode Four { - reaction(startup) -> startup4 {= - printf("Startup 4 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(startup4, 1); - =} - - reaction(reset) -> reset4 {= - printf("Reset 4 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(reset4, 1); - =} - - reaction(next) -> reset(Four), mode_switch {= - printf("Transitioning to mode 4\n"); - lf_set(mode_switch, 4); - lf_set_mode(Four); - =} - - reaction(shutdown) -> shutdown4 {= - printf("Shutdown 4 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(shutdown4, 1); - =} - } - - mode Five { // Unreachable! - reaction(startup) -> startup5 {= - printf("Startup 5 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(startup5, 1); - =} - - reaction(reset) -> reset5 {= - printf("Reset 5 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(reset5, 1); - =} - - reaction(shutdown) -> shutdown5 {= - printf("Shutdown 5 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); - lf_set(shutdown5, 1); - =} - } + input next: bool + + output mode_switch: int + output startup1: int + output startup2: int + output shutdown2: int + output shutdown3: int + output startup4: int + output reset4: int + output shutdown4: int + output startup5: int + output reset5: int + output shutdown5: int + + initial mode One { + reaction(startup) -> startup1 {= + printf("Startup 1 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(startup1, 1); + =} + + reaction(next) -> reset(Two), mode_switch {= + printf("Transitioning to mode 1\n"); + lf_set(mode_switch, 2); + lf_set_mode(Two); + =} + } + + mode Two { + reaction(startup) -> startup2 {= + printf("Startup 2 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(startup2, 1); + =} + + reaction(next) -> reset(Three), mode_switch {= + printf("Transitioning to mode 3\n"); + lf_set(mode_switch, 3); + lf_set_mode(Three); + =} + + reaction(shutdown) -> shutdown2 {= + printf("Shutdown 2 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(shutdown2, 1); + =} + } + + mode Three { + reaction(next) -> reset(Four), mode_switch {= + printf("Transitioning to mode 4\n"); + lf_set(mode_switch, 4); + lf_set_mode(Four); + =} + + reaction(shutdown) -> shutdown3 {= + printf("Shutdown 3 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(shutdown3, 1); + =} + } + + mode Four { + reaction(startup) -> startup4 {= + printf("Startup 4 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(startup4, 1); + =} + + reaction(reset) -> reset4 {= + printf("Reset 4 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(reset4, 1); + =} + + reaction(next) -> reset(Four), mode_switch {= + printf("Transitioning to mode 4\n"); + lf_set(mode_switch, 4); + lf_set_mode(Four); + =} + + reaction(shutdown) -> shutdown4 {= + printf("Shutdown 4 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(shutdown4, 1); + =} + } + + mode Five { // Unreachable! + reaction(startup) -> startup5 {= + printf("Startup 5 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(startup5, 1); + =} + + reaction(reset) -> reset5 {= + printf("Reset 5 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(reset5, 1); + =} + + reaction(shutdown) -> shutdown5 {= + printf("Shutdown 5 at (%lld, %u).\n", lf_time_logical_elapsed(), lf_tag().microstep); + lf_set(shutdown5, 1); + =} + } } main reactor { - timer stepper(500 msec, 500 msec) - - modal = new Modal() - test = new TraceTesting( - events_size = 11, - trace_size = 253, - trace = { // keep-format - 0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 500000000,1,2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,2,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 500000000,1,3,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 500000000,1,4,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,4,0,1,0,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, - 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, - 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, - 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, - 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, - 500000000,1,4,0,1,0,1,1,1,1,1,0,1,0,1,1,1,0,0,0,0,0,0 - }, - training = false - ) - - modal.mode_switch, - modal.startup1, - modal.startup2, - modal.shutdown2, - modal.shutdown3, - modal.startup4, - modal.reset4, - modal.shutdown4, - modal.startup5, - modal.reset5, - modal.shutdown5 - -> test.events - - // Trigger mode change - reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} + timer stepper(500 msec, 500 msec) + + modal = new Modal() + test = new TraceTesting(events_size = 11, trace_size = 253, trace = { // keep-format + 0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 500000000,1,2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,2,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 500000000,1,3,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 500000000,1,4,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,4,0,1,0,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, + 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, + 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, + 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, + 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, + 500000000,1,4,0,1,0,1,1,1,1,1,0,1,0,1,1,1,0,0,0,0,0,0 + }, training = false) + + modal.mode_switch, + modal.startup1, + modal.startup2, + modal.shutdown2, + modal.shutdown3, + modal.startup4, + modal.reset4, + modal.shutdown4, + modal.startup5, + modal.reset5, + modal.shutdown5 + -> test.events + + reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} // Trigger mode change } diff --git a/test/C/src/modal_models/ModalStateReset.lf b/test/C/src/modal_models/ModalStateReset.lf index c098f088d5..46f94958cd 100644 --- a/test/C/src/modal_models/ModalStateReset.lf +++ b/test/C/src/modal_models/ModalStateReset.lf @@ -1,94 +1,88 @@ /** Modal Reactor Test. Tests reset of state variables in modes. */ target C { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next: bool + input next: bool - output mode_switch: int - output count0: int - output count1: int - output count2: int + output mode_switch: int + output count0: int + output count1: int + output count2: int - state counter0: int = 0 + state counter0: int = 0 - reaction(next) -> count0 {= - printf("Counter0: %d\n", self->counter0); - lf_set(count0, self->counter0++); - =} + reaction(next) -> count0 {= + printf("Counter0: %d\n", self->counter0); + lf_set(count0, self->counter0++); + =} - initial mode One { - state counter1: int = 0 - timer T1(0 msec, 250 msec) - reaction(reset) {= self->counter1 = 0; =} + initial mode One { + state counter1: int = 0 + timer T1(0 msec, 250 msec) + reaction(reset) {= self->counter1 = 0; =} - reaction(T1) -> count1 {= - printf("Counter1: %d\n", self->counter1); - lf_set(count1, self->counter1++); - =} + reaction(T1) -> count1 {= + printf("Counter1: %d\n", self->counter1); + lf_set(count1, self->counter1++); + =} - reaction(next) -> reset(Two), mode_switch {= - printf("Transitioning to mode Two (reset)\n"); - lf_set(mode_switch, 1); - lf_set_mode(Two); - =} - } + reaction(next) -> reset(Two), mode_switch {= + printf("Transitioning to mode Two (reset)\n"); + lf_set(mode_switch, 1); + lf_set_mode(Two); + =} + } - mode Two { - state counter2: int = -2 - timer T2(0 msec, 250 msec) - reaction(reset) {= self->counter2 = -2; =} + mode Two { + state counter2: int = -2 + timer T2(0 msec, 250 msec) + reaction(reset) {= self->counter2 = -2; =} - reaction(T2) -> count2 {= - printf("Counter2: %d\n", self->counter2); - lf_set(count2, self->counter2++); - =} + reaction(T2) -> count2 {= + printf("Counter2: %d\n", self->counter2); + lf_set(count2, self->counter2++); + =} - reaction(next) -> history(One), mode_switch {= - printf("Transitioning to mode One (continue)\n"); - lf_set(mode_switch, 1); - lf_set_mode(One); - =} - } + reaction(next) -> history(One), mode_switch {= + printf("Transitioning to mode One (continue)\n"); + lf_set(mode_switch, 1); + lf_set_mode(One); + =} + } } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting( - events_size = 4, - trace_size = 171, - trace = { // keep-format - 0,0,0,0,0,1,0,0,0, - 250000000,0,0,0,0,1,1,0,0, - 250000000,0,0,0,0,1,2,0,0, - 250000000,0,0,0,0,1,3,0,0, - 250000000,1,1,1,0,1,4,0,0, - 0,0,1,0,0,0,4,1,-2, - 250000000,0,1,0,0,0,4,1,-1, - 250000000,0,1,0,0,0,4,1,0, - 250000000,0,1,0,0,0,4,1,1, - 250000000,1,1,1,1,0,4,1,2, - 250000000,0,1,0,1,1,5,0,2, - 250000000,0,1,0,1,1,6,0,2, - 250000000,0,1,0,1,1,7,0,2, - 250000000,1,1,1,2,1,8,0,2, - 0,0,1,0,2,0,8,1,-2, - 250000000,0,1,0,2,0,8,1,-1, - 250000000,0,1,0,2,0,8,1,0, - 250000000,0,1,0,2,0,8,1,1, - 250000000,1,1,1,3,0,8,1,2 - }, - training = false - ) + modal = new Modal() + test = new TraceTesting(events_size = 4, trace_size = 171, trace = { // keep-format + 0,0,0,0,0,1,0,0,0, + 250000000,0,0,0,0,1,1,0,0, + 250000000,0,0,0,0,1,2,0,0, + 250000000,0,0,0,0,1,3,0,0, + 250000000,1,1,1,0,1,4,0,0, + 0,0,1,0,0,0,4,1,-2, + 250000000,0,1,0,0,0,4,1,-1, + 250000000,0,1,0,0,0,4,1,0, + 250000000,0,1,0,0,0,4,1,1, + 250000000,1,1,1,1,0,4,1,2, + 250000000,0,1,0,1,1,5,0,2, + 250000000,0,1,0,1,1,6,0,2, + 250000000,0,1,0,1,1,7,0,2, + 250000000,1,1,1,2,1,8,0,2, + 0,0,1,0,2,0,8,1,-2, + 250000000,0,1,0,2,0,8,1,-1, + 250000000,0,1,0,2,0,8,1,0, + 250000000,0,1,0,2,0,8,1,1, + 250000000,1,1,1,3,0,8,1,2 + }, training = false) - modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events + modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events - // Trigger mode change - reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} + reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} // Trigger mode change } diff --git a/test/C/src/modal_models/ModalStateResetAuto.lf b/test/C/src/modal_models/ModalStateResetAuto.lf index a82fd18212..be13d7b58e 100644 --- a/test/C/src/modal_models/ModalStateResetAuto.lf +++ b/test/C/src/modal_models/ModalStateResetAuto.lf @@ -1,90 +1,84 @@ /** Modal Reactor Test. Tests reset of state variables in modes. */ target C { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next: bool + input next: bool - output mode_switch: int - output count0: int - output count1: int - output count2: int + output mode_switch: int + output count0: int + output count1: int + output count2: int - state counter0: int = 0 + state counter0: int = 0 - reaction(next) -> count0 {= - printf("Counter0: %d\n", self->counter0); - lf_set(count0, self->counter0++); - =} + reaction(next) -> count0 {= + printf("Counter0: %d\n", self->counter0); + lf_set(count0, self->counter0++); + =} - initial mode One { - state counter1: int = 0 - timer T1(0 msec, 250 msec) - reaction(T1) -> count1 {= - printf("Counter1: %d\n", self->counter1); - lf_set(count1, self->counter1++); - =} + initial mode One { + state counter1: int = 0 + timer T1(0 msec, 250 msec) + reaction(T1) -> count1 {= + printf("Counter1: %d\n", self->counter1); + lf_set(count1, self->counter1++); + =} - reaction(next) -> reset(Two), mode_switch {= - printf("Transitioning to mode Two (reset)\n"); - lf_set(mode_switch, 1); - lf_set_mode(Two); - =} - } + reaction(next) -> reset(Two), mode_switch {= + printf("Transitioning to mode Two (reset)\n"); + lf_set(mode_switch, 1); + lf_set_mode(Two); + =} + } - mode Two { - reset state counter2: int = -2 - timer T2(0 msec, 250 msec) - reaction(T2) -> count2 {= - printf("Counter2: %d\n", self->counter2); - lf_set(count2, self->counter2++); - =} + mode Two { + reset state counter2: int = -2 + timer T2(0 msec, 250 msec) + reaction(T2) -> count2 {= + printf("Counter2: %d\n", self->counter2); + lf_set(count2, self->counter2++); + =} - reaction(next) -> history(One), mode_switch {= - printf("Transitioning to mode One (continue)\n"); - lf_set(mode_switch, 1); - lf_set_mode(One); - =} - } + reaction(next) -> history(One), mode_switch {= + printf("Transitioning to mode One (continue)\n"); + lf_set(mode_switch, 1); + lf_set_mode(One); + =} + } } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting( - events_size = 4, - trace_size = 171, - trace = { // keep-format - 0,0,0,0,0,1,0,0,0, - 250000000,0,0,0,0,1,1,0,0, - 250000000,0,0,0,0,1,2,0,0, - 250000000,0,0,0,0,1,3,0,0, - 250000000,1,1,1,0,1,4,0,0, - 0,0,1,0,0,0,4,1,-2, - 250000000,0,1,0,0,0,4,1,-1, - 250000000,0,1,0,0,0,4,1,0, - 250000000,0,1,0,0,0,4,1,1, - 250000000,1,1,1,1,0,4,1,2, - 250000000,0,1,0,1,1,5,0,2, - 250000000,0,1,0,1,1,6,0,2, - 250000000,0,1,0,1,1,7,0,2, - 250000000,1,1,1,2,1,8,0,2, - 0,0,1,0,2,0,8,1,-2, - 250000000,0,1,0,2,0,8,1,-1, - 250000000,0,1,0,2,0,8,1,0, - 250000000,0,1,0,2,0,8,1,1, - 250000000,1,1,1,3,0,8,1,2 - }, - training = false - ) + modal = new Modal() + test = new TraceTesting(events_size = 4, trace_size = 171, trace = { // keep-format + 0,0,0,0,0,1,0,0,0, + 250000000,0,0,0,0,1,1,0,0, + 250000000,0,0,0,0,1,2,0,0, + 250000000,0,0,0,0,1,3,0,0, + 250000000,1,1,1,0,1,4,0,0, + 0,0,1,0,0,0,4,1,-2, + 250000000,0,1,0,0,0,4,1,-1, + 250000000,0,1,0,0,0,4,1,0, + 250000000,0,1,0,0,0,4,1,1, + 250000000,1,1,1,1,0,4,1,2, + 250000000,0,1,0,1,1,5,0,2, + 250000000,0,1,0,1,1,6,0,2, + 250000000,0,1,0,1,1,7,0,2, + 250000000,1,1,1,2,1,8,0,2, + 0,0,1,0,2,0,8,1,-2, + 250000000,0,1,0,2,0,8,1,-1, + 250000000,0,1,0,2,0,8,1,0, + 250000000,0,1,0,2,0,8,1,1, + 250000000,1,1,1,3,0,8,1,2 + }, training = false) - modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events + modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events - // Trigger mode change - reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} + reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} // Trigger mode change } diff --git a/test/C/src/modal_models/ModalTimers.lf b/test/C/src/modal_models/ModalTimers.lf index 954a677de4..0ceaddd3a6 100644 --- a/test/C/src/modal_models/ModalTimers.lf +++ b/test/C/src/modal_models/ModalTimers.lf @@ -1,72 +1,66 @@ /** Modal Reactor Test. Tests timers, their deactivation and reset in modes. */ target C { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next: bool + input next: bool - output mode_switch: int - output timer1: int - output timer2: int + output mode_switch: int + output timer1: int + output timer2: int - initial mode One { - timer T1(0, 750 msec) - reaction(T1) -> timer1 {= - printf("T1\n"); - lf_set(timer1, 1); - =} + initial mode One { + timer T1(0, 750 msec) + reaction(T1) -> timer1 {= + printf("T1\n"); + lf_set(timer1, 1); + =} - reaction(next) -> reset(Two), mode_switch {= - printf("Transitioning to mode Two (reset)\n"); - lf_set(mode_switch, 1); - lf_set_mode(Two); - =} - } + reaction(next) -> reset(Two), mode_switch {= + printf("Transitioning to mode Two (reset)\n"); + lf_set(mode_switch, 1); + lf_set_mode(Two); + =} + } - mode Two { - timer T2(0, 750 msec) - reaction(T2) -> timer2 {= - printf("T2\n"); - lf_set(timer2, 1); - =} + mode Two { + timer T2(0, 750 msec) + reaction(T2) -> timer2 {= + printf("T2\n"); + lf_set(timer2, 1); + =} - reaction(next) -> history(One), mode_switch {= - printf("Transitioning to mode One (continue)\n"); - lf_set(mode_switch, 1); - lf_set_mode(One); - =} - } + reaction(next) -> history(One), mode_switch {= + printf("Transitioning to mode One (continue)\n"); + lf_set(mode_switch, 1); + lf_set_mode(One); + =} + } } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting( - events_size = 3, - trace_size = 77, - trace = { // keep-format - 0,0,0,1,1,0,0, - 750000000,0,0,1,1,0,0, - 250000000,1,1,0,1,0,0, - 0,0,1,0,1,1,1, - 750000000,0,1,0,1,1,1, - 250000000,1,1,0,1,0,1, - 500000000,0,1,1,1,0,1, - 500000000,1,1,0,1,0,1, - 0,0,1,0,1,1,1, - 750000000,0,1,0,1,1,1, - 250000000,1,1,0,1,0,1 - }, - training = false - ) + modal = new Modal() + test = new TraceTesting(events_size = 3, trace_size = 77, trace = { // keep-format + 0,0,0,1,1,0,0, + 750000000,0,0,1,1,0,0, + 250000000,1,1,0,1,0,0, + 0,0,1,0,1,1,1, + 750000000,0,1,0,1,1,1, + 250000000,1,1,0,1,0,1, + 500000000,0,1,1,1,0,1, + 500000000,1,1,0,1,0,1, + 0,0,1,0,1,1,1, + 750000000,0,1,0,1,1,1, + 250000000,1,1,0,1,0,1 + }, training = false) - modal.mode_switch, modal.timer1, modal.timer2 -> test.events + modal.mode_switch, modal.timer1, modal.timer2 -> test.events - // Trigger mode change - reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} + reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} // Trigger mode change } diff --git a/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf b/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf index 31de4fe6bd..198ba0fd37 100644 --- a/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf +++ b/test/C/src/modal_models/MultipleOutputFeeder_2Connections.lf @@ -1,76 +1,69 @@ /** * Modal Reactor Test. * - * Tests if connections in the same reactor that have the same destination work - * if they are located in separate modes. + * Tests if connections in the same reactor that have the same destination work if they are located + * in separate modes. */ target C { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next: bool - output count: int + input next: bool + output count: int - initial mode One { - counter1 = new Counter(period = 250 msec) - counter1.value -> count - reaction(next) -> reset(Two) {= lf_set_mode(Two); =} - } + initial mode One { + counter1 = new Counter(period = 250 msec) + counter1.value -> count + reaction(next) -> reset(Two) {= lf_set_mode(Two); =} + } - mode Two { - counter2 = new Counter(period = 100 msec) - counter2.value -> count - reaction(next) -> history(One) {= lf_set_mode(One); =} - } + mode Two { + counter2 = new Counter(period = 100 msec) + counter2.value -> count + reaction(next) -> history(One) {= lf_set_mode(One); =} + } } reactor Counter(period: time = 1 sec) { - output value: int + output value: int - timer t(0, period) - reset state curval: int = 0 + timer t(0, period) + reset state curval: int = 0 - reaction(t) -> value {= lf_set(value, self->curval++); =} + reaction(t) -> value {= lf_set(value, self->curval++); =} } main reactor { - timer stepper(500 msec, 500 msec) + timer stepper(500 msec, 500 msec) - modal = new Modal() - test = new TraceTesting( - events_size = 1, - trace_size = 51, - trace = { // keep-format - 0,1,0, - 250000000,1,1, - 250000000,1,2, - 0,1,0, - 100000000,1,1, - 100000000,1,2, - 100000000,1,3, - 100000000,1,4, - 100000000,1,5, - 250000000,1,3, - 250000000,1,4, - 0,1,0, - 100000000,1,1, - 100000000,1,2, - 100000000,1,3, - 100000000,1,4, - 100000000,1,5 - }, - training = false - ) + modal = new Modal() + test = new TraceTesting(events_size = 1, trace_size = 51, trace = { // keep-format + 0,1,0, + 250000000,1,1, + 250000000,1,2, + 0,1,0, + 100000000,1,1, + 100000000,1,2, + 100000000,1,3, + 100000000,1,4, + 100000000,1,5, + 250000000,1,3, + 250000000,1,4, + 0,1,0, + 100000000,1,1, + 100000000,1,2, + 100000000,1,3, + 100000000,1,4, + 100000000,1,5 + }, training = false) - modal.count -> test.events + modal.count -> test.events - // Trigger mode change - reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} + reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} // Trigger mode change - // Print - reaction(modal.count) {= printf("%d\n", modal.count->value); =} + reaction(modal.count) {= printf("%d\n", modal.count->value); =} // Print } diff --git a/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf b/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf index f89073dfc1..fe3c4dde17 100644 --- a/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf +++ b/test/C/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf @@ -1,79 +1,70 @@ /** * Modal Reactor Test. * - * Tests if a connection and a reaction in the same reactor can have the same - * destination if they are located in separate modes. + * Tests if a connection and a reaction in the same reactor can have the same destination if they + * are located in separate modes. */ target C { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next: bool - output count: int + input next: bool + output count: int - initial mode One { - counter1 = new Counter(period = 250 msec) - counter1.value -> count - reaction(next) -> reset(Two) {= lf_set_mode(Two); =} - } + initial mode One { + counter1 = new Counter(period = 250 msec) + counter1.value -> count + reaction(next) -> reset(Two) {= lf_set_mode(Two); =} + } - mode Two { - counter2 = new Counter(period = 100 msec) - reaction(counter2.value) -> count {= - lf_set(count, counter2.value->value * 10); - =} + mode Two { + counter2 = new Counter(period = 100 msec) + reaction(counter2.value) -> count {= lf_set(count, counter2.value->value * 10); =} - reaction(next) -> history(One) {= lf_set_mode(One); =} - } + reaction(next) -> history(One) {= lf_set_mode(One); =} + } } reactor Counter(period: time = 1 sec) { - output value: int + output value: int - timer t(0, period) - reset state curval: int = 0 + timer t(0, period) + reset state curval: int = 0 - reaction(t) -> value {= lf_set(value, self->curval++); =} + reaction(t) -> value {= lf_set(value, self->curval++); =} } main reactor { - timer stepper(500 msec, 500 msec) + timer stepper(500 msec, 500 msec) - modal = new Modal() - test = new TraceTesting( - events_size = 1, - trace_size = 51, - trace = { // keep-format - 0,1,0, - 250000000,1,1, - 250000000,1,2, - 0,1,0, - 100000000,1,10, - 100000000,1,20, - 100000000,1,30, - 100000000,1,40, - 100000000,1,50, - 250000000,1,3, - 250000000,1,4, - 0,1,0, - 100000000,1,10, - 100000000,1,20, - 100000000,1,30, - 100000000,1,40, - 100000000,1,50 - }, - training = false - ) + modal = new Modal() + test = new TraceTesting(events_size = 1, trace_size = 51, trace = { // keep-format + 0,1,0, + 250000000,1,1, + 250000000,1,2, + 0,1,0, + 100000000,1,10, + 100000000,1,20, + 100000000,1,30, + 100000000,1,40, + 100000000,1,50, + 250000000,1,3, + 250000000,1,4, + 0,1,0, + 100000000,1,10, + 100000000,1,20, + 100000000,1,30, + 100000000,1,40, + 100000000,1,50 + }, training = false) - modal.count -> test.events + modal.count -> test.events - // Trigger mode change - reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} + reaction(stepper) -> modal.next {= lf_set(modal.next, true); =} // Trigger mode change - // Print - reaction(modal.count) {= printf("%d\n", modal.count->value); =} + reaction(modal.count) {= printf("%d\n", modal.count->value); =} // Print } diff --git a/test/C/src/modal_models/util/TraceTesting.lf b/test/C/src/modal_models/util/TraceTesting.lf index c63de35f2a..38b78b4173 100644 --- a/test/C/src/modal_models/util/TraceTesting.lf +++ b/test/C/src/modal_models/util/TraceTesting.lf @@ -2,79 +2,79 @@ target C reactor TraceTesting( - events_size: int = 0, - trace_size: int = 0, - trace: int[] = 0, - training: bool = false + events_size: int = 0, + trace_size: int = 0, + trace: int[] = 0, + training: bool = false ) { - input[events_size] events: int + input[events_size] events: int - state last_reaction_time: int = 0 - state trace_idx: int = 0 - state recorded_events: int* = 0 - state recorded_events_next: int = 0 + state last_reaction_time: int = 0 + state trace_idx: int = 0 + state recorded_events: int* = 0 + state recorded_events_next: int = 0 - reaction(startup) {= self->last_reaction_time = lf_time_logical(); =} + reaction(startup) {= self->last_reaction_time = lf_time_logical(); =} - reaction(events) {= - // Time passed since last reaction - int curr_reaction_delay = lf_time_logical() - self->last_reaction_time; + reaction(events) {= + // Time passed since last reaction + int curr_reaction_delay = lf_time_logical() - self->last_reaction_time; - if (self->training) { - // Save time - self->recorded_events = (int*) realloc(self->recorded_events, sizeof(int) * (self->recorded_events_next + 1 + 2 * self->events_size)); - self->recorded_events[self->recorded_events_next++] = curr_reaction_delay; - } else { - if (self->trace_idx >= self->trace_size) { - printf("ERROR: Trace Error: Current execution exceeds given trace.\n"); - exit(1); - } + if (self->training) { + // Save time + self->recorded_events = (int*) realloc(self->recorded_events, sizeof(int) * (self->recorded_events_next + 1 + 2 * self->events_size)); + self->recorded_events[self->recorded_events_next++] = curr_reaction_delay; + } else { + if (self->trace_idx >= self->trace_size) { + printf("ERROR: Trace Error: Current execution exceeds given trace.\n"); + exit(1); + } - int trace_reaction_delay = self->trace[self->trace_idx++]; + int trace_reaction_delay = self->trace[self->trace_idx++]; - if (curr_reaction_delay != trace_reaction_delay) { - printf("ERROR: Trace Mismatch: Unexpected reaction timing. (delay: %d, expected: %d)\n", curr_reaction_delay, trace_reaction_delay); - exit(2); - } + if (curr_reaction_delay != trace_reaction_delay) { + printf("ERROR: Trace Mismatch: Unexpected reaction timing. (delay: %d, expected: %d)\n", curr_reaction_delay, trace_reaction_delay); + exit(2); } + } - for (int i = 0; i < self->events_size; i++) { - int curr_present = events[i]->is_present; - int curr_value = events[i]->value; + for (int i = 0; i < self->events_size; i++) { + int curr_present = events[i]->is_present; + int curr_value = events[i]->value; - if (self->training) { - // Save event - self->recorded_events[self->recorded_events_next++] = curr_present; - self->recorded_events[self->recorded_events_next++] = curr_value; - } else { - int trace_present = self->trace[self->trace_idx++]; - int trace_value = self->trace[self->trace_idx++]; + if (self->training) { + // Save event + self->recorded_events[self->recorded_events_next++] = curr_present; + self->recorded_events[self->recorded_events_next++] = curr_value; + } else { + int trace_present = self->trace[self->trace_idx++]; + int trace_value = self->trace[self->trace_idx++]; - if (trace_present != curr_present) { - printf("ERROR: Trace Mismatch: Unexpected event presence. (event: %d, presence: %d, expected: %d)\n", i, curr_present, trace_present); - exit(3); - } else if (curr_present && trace_value != curr_value) { - printf("ERROR: Trace Mismatch: Unexpected event value. (event: %d, presence: %d, expected: %d)\n", i, curr_value, trace_value); - exit(4); - } + if (trace_present != curr_present) { + printf("ERROR: Trace Mismatch: Unexpected event presence. (event: %d, presence: %d, expected: %d)\n", i, curr_present, trace_present); + exit(3); + } else if (curr_present && trace_value != curr_value) { + printf("ERROR: Trace Mismatch: Unexpected event value. (event: %d, presence: %d, expected: %d)\n", i, curr_value, trace_value); + exit(4); } } + } - self->last_reaction_time = lf_time_logical(); - =} + self->last_reaction_time = lf_time_logical(); + =} - reaction(shutdown) {= - if (self->training) { - printf("Recorded event trace (%d): (", self->recorded_events_next); - for (int i = 0; i < self->recorded_events_next; i++) { - printf("%d", self->recorded_events[i]); - if (i < self->recorded_events_next - 1) { - printf(","); - } + reaction(shutdown) {= + if (self->training) { + printf("Recorded event trace (%d): (", self->recorded_events_next); + for (int i = 0; i < self->recorded_events_next; i++) { + printf("%d", self->recorded_events[i]); + if (i < self->recorded_events_next - 1) { + printf(","); } - printf(")\n"); - - free(self->recorded_events); } - =} + printf(")\n"); + + free(self->recorded_events); + } + =} } diff --git a/test/C/src/multiport/BankIndexInitializer.lf b/test/C/src/multiport/BankIndexInitializer.lf index e6c52e8efe..4c24c2d92b 100644 --- a/test/C/src/multiport/BankIndexInitializer.lf +++ b/test/C/src/multiport/BankIndexInitializer.lf @@ -4,38 +4,38 @@ target C preamble {= extern int table[4]; =} reactor Source(bank_index: int = 0, value: int = 0) { - preamble {= int table[] = {4, 3, 2, 1}; =} + preamble {= int table[] = {4, 3, 2, 1}; =} - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, self->value); =} + reaction(startup) -> out {= lf_set(out, self->value); =} } reactor Sink(width: int = 4) { - input[width] in: int - state received: bool = false - - reaction(in) {= - for (int idx = 0; idx < in_width; idx++) { - if (in[idx]->is_present) { - printf("Received on channel %d: %d\n", idx, in[idx]->value); - self->received = true; - if (in[idx]->value != 4 - idx) { - lf_print_error_and_exit("Expected %d.", 4 - idx); - } + input[width] in: int + state received: bool = false + + reaction(in) {= + for (int idx = 0; idx < in_width; idx++) { + if (in[idx]->is_present) { + printf("Received on channel %d: %d\n", idx, in[idx]->value); + self->received = true; + if (in[idx]->value != 4 - idx) { + lf_print_error_and_exit("Expected %d.", 4 - idx); } } - =} - - reaction(shutdown) {= - if (!self->received) { - lf_print_error_and_exit("Sink received no data."); - } - =} + } + =} + + reaction(shutdown) {= + if (!self->received) { + lf_print_error_and_exit("Sink received no data."); + } + =} } main reactor(width: int = 4) { - source = new[width] Source(value = {= table[bank_index] =}) - sink = new Sink(width = width) - source.out -> sink.in + source = new[width] Source(value = {= table[bank_index] =}) + sink = new Sink(width = width) + source.out -> sink.in } diff --git a/test/C/src/multiport/BankMultiportToReaction.lf b/test/C/src/multiport/BankMultiportToReaction.lf index 731cd6891b..c5923c7073 100644 --- a/test/C/src/multiport/BankMultiportToReaction.lf +++ b/test/C/src/multiport/BankMultiportToReaction.lf @@ -1,41 +1,41 @@ target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } import Count from "../lib/Count.lf" reactor DoubleCount { - output[2] out: int - c1 = new Count() - c2 = new Count() - c1.out, c2.out -> out + output[2] out: int + c1 = new Count() + c2 = new Count() + c1.out, c2.out -> out } main reactor { - state count: int = 1 - state received: bool = false + state count: int = 1 + state received: bool = false - s = new[2] DoubleCount() + s = new[2] DoubleCount() - reaction(s.out) {= - for (int i = 0; i < s_width; i++) { - for (int j = 0; j < s[0].out_width; j++) { - if (s[i].out[j]->is_present) { - lf_print("Received %d.", s[i].out[j]->value); - if (self->count != s[i].out[j]->value) { - lf_print_error_and_exit("Expected %d.", self->count); - } - self->received = true; + reaction(s.out) {= + for (int i = 0; i < s_width; i++) { + for (int j = 0; j < s[0].out_width; j++) { + if (s[i].out[j]->is_present) { + lf_print("Received %d.", s[i].out[j]->value); + if (self->count != s[i].out[j]->value) { + lf_print_error_and_exit("Expected %d.", self->count); } + self->received = true; } } - self->count++; - =} + } + self->count++; + =} - reaction(shutdown) {= - if (!self->received) { - lf_print_error_and_exit("No inputs present."); - } - =} + reaction(shutdown) {= + if (!self->received) { + lf_print_error_and_exit("No inputs present."); + } + =} } diff --git a/test/C/src/multiport/BankReactionsInContainer.lf b/test/C/src/multiport/BankReactionsInContainer.lf index 98d7cf4e1f..71d566ac4b 100644 --- a/test/C/src/multiport/BankReactionsInContainer.lf +++ b/test/C/src/multiport/BankReactionsInContainer.lf @@ -1,77 +1,75 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target C { - timeout: 1 sec + timeout: 1 sec } reactor R(bank_index: int = 0) { - output[2] out: int - input[2] in: int - state received: bool = false + output[2] out: int + input[2] in: int + state received: bool = false - reaction(startup) -> out {= - for (int i = 0; i < out_width; i++) { - int value = self->bank_index * 2 + i; - lf_set(out[i], value); - lf_print("Inner sending %d to bank %d channel %d.", - value, self->bank_index, i - ); - } - =} + reaction(startup) -> out {= + for (int i = 0; i < out_width; i++) { + int value = self->bank_index * 2 + i; + lf_set(out[i], value); + lf_print("Inner sending %d to bank %d channel %d.", + value, self->bank_index, i + ); + } + =} - reaction(in) {= - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - lf_print("Inner received %d in bank %d, channel %d", in[i]->value, self->bank_index, i); - self->received = true; - if (in[i]->value != self->bank_index * 2 + i) { - lf_print_error_and_exit("Expected %d.", self->bank_index * 2 + i); - } + reaction(in) {= + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + lf_print("Inner received %d in bank %d, channel %d", in[i]->value, self->bank_index, i); + self->received = true; + if (in[i]->value != self->bank_index * 2 + i) { + lf_print_error_and_exit("Expected %d.", self->bank_index * 2 + i); } } - =} + } + =} - reaction(shutdown) {= - lf_print("Inner shutdown invoked."); - if (!self->received) { - lf_print_error_and_exit("Received no input."); - } - =} + reaction(shutdown) {= + lf_print("Inner shutdown invoked."); + if (!self->received) { + lf_print_error_and_exit("Received no input."); + } + =} } main reactor { - s = new[2] R() - state received: bool = false + s = new[2] R() + state received: bool = false - reaction(startup) -> s.in {= - int count = 0; - for (int i = 0; i < s_width; i++) { - for (int j = 0; j < s[i].in_width; j++) { - lf_print("Sending %d to bank %d channel %d.", count, i, j); - lf_set(s[i].in[j], count++); - } + reaction(startup) -> s.in {= + int count = 0; + for (int i = 0; i < s_width; i++) { + for (int j = 0; j < s[i].in_width; j++) { + lf_print("Sending %d to bank %d channel %d.", count, i, j); + lf_set(s[i].in[j], count++); } - =} + } + =} - reaction(s.out) {= - for (int j = 0; j < s_width; j++) { - for (int i = 0; i < s[j].out_width; i++) { - if (s[j].out[i]->is_present) { - lf_print("Outer received %d on bank %d channel %d.", s[j].out[i]->value, j, i); - self->received = true; - if (s[j].out[i]->value != j * 2 + i) { - lf_print_error_and_exit("Expected %d.", j * 2 + i); - } + reaction(s.out) {= + for (int j = 0; j < s_width; j++) { + for (int i = 0; i < s[j].out_width; i++) { + if (s[j].out[i]->is_present) { + lf_print("Outer received %d on bank %d channel %d.", s[j].out[i]->value, j, i); + self->received = true; + if (s[j].out[i]->value != j * 2 + i) { + lf_print_error_and_exit("Expected %d.", j * 2 + i); } } } - =} + } + =} - reaction(shutdown) {= - lf_print("Outer shutdown invoked."); - if (!self->received) { - lf_print_error_and_exit("Received no input."); - } - =} + reaction(shutdown) {= + lf_print("Outer shutdown invoked."); + if (!self->received) { + lf_print_error_and_exit("Received no input."); + } + =} } diff --git a/test/C/src/multiport/BankSelfBroadcast.lf b/test/C/src/multiport/BankSelfBroadcast.lf index e1ffb4b2dd..52b7a678f2 100644 --- a/test/C/src/multiport/BankSelfBroadcast.lf +++ b/test/C/src/multiport/BankSelfBroadcast.lf @@ -1,48 +1,48 @@ /** - * Test a bank of reactors that broadcast a single output back to a multiport - * input of the same reactors in the bank so that each reactor in the bank - * receives the output produced by itself and each other reactor. + * Test a bank of reactors that broadcast a single output back to a multiport input of the same + * reactors in the bank so that each reactor in the bank receives the output produced by itself and + * each other reactor. * * @author Edward A. Lee */ target C reactor A(bank_index: int = 0) { - input[4] in: int - output out: int - state received: bool = false + input[4] in: int + output out: int + state received: bool = false - reaction(startup) -> out {= lf_set(out, self->bank_index); =} + reaction(startup) -> out {= lf_set(out, self->bank_index); =} - reaction(in) {= - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - lf_print( - "Reactor %d received %d on channel %d.", - self->bank_index, in[i]->value, i - ); - if (in[i]->value != i) { - lf_print_error_and_exit("Expected %d.", i); - } - self->received = true; - } else { - lf_print( - "Reactor %d channel %d is absent.", - self->bank_index, i - ); + reaction(in) {= + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + lf_print( + "Reactor %d received %d on channel %d.", + self->bank_index, in[i]->value, i + ); + if (in[i]->value != i) { lf_print_error_and_exit("Expected %d.", i); } + self->received = true; + } else { + lf_print( + "Reactor %d channel %d is absent.", + self->bank_index, i + ); + lf_print_error_and_exit("Expected %d.", i); } - =} + } + =} - reaction(shutdown) {= - if (!self->received) { - lf_print_error_and_exit("No inputs received."); - } - =} + reaction(shutdown) {= + if (!self->received) { + lf_print_error_and_exit("No inputs received."); + } + =} } main reactor { - a = new[4] A() - (a.out)+ -> a.in + a = new[4] A() + (a.out)+ -> a.in } diff --git a/test/C/src/multiport/BankToBank.lf b/test/C/src/multiport/BankToBank.lf index beb3a32fa8..0b2c2ff5b5 100644 --- a/test/C/src/multiport/BankToBank.lf +++ b/test/C/src/multiport/BankToBank.lf @@ -1,44 +1,44 @@ // Check bank of reactors sending to bank of reactors. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(bank_index: int = 0) { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - lf_set(out, self->s); - self->s += self->bank_index; - =} + reaction(t) -> out {= + lf_set(out, self->s); + self->s += self->bank_index; + =} } reactor Destination(bank_index: int = 0) { - state s: int = 0 - input in: int + state s: int = 0 + input in: int - reaction(in) {= - printf("Destination %d received: %d.\n", self->bank_index, in->value); - if (in->value != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += self->bank_index; - =} + reaction(in) {= + printf("Destination %d received: %d.\n", self->bank_index, in->value); + if (in->value != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += self->bank_index; + =} - reaction(shutdown) {= - if (self->s == 0 && self->bank_index != 0) { - fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s == 0 && self->bank_index != 0) { + fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); + exit(1); + } + printf("Success.\n"); + =} } main reactor BankToBank(width: int = 4) { - a = new[width] Source() - b = new[width] Destination() - a.out -> b.in + a = new[width] Source() + b = new[width] Destination() + a.out -> b.in } diff --git a/test/C/src/multiport/BankToBankMultiport.lf b/test/C/src/multiport/BankToBankMultiport.lf index 681538f116..502e5ed064 100644 --- a/test/C/src/multiport/BankToBankMultiport.lf +++ b/test/C/src/multiport/BankToBankMultiport.lf @@ -1,49 +1,49 @@ // Check bank of reactors sending to bank of reactors with multiports. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 1) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < out_width; i++) { - lf_set(out[i], self->s++); - } - =} + reaction(t) -> out {= + for(int i = 0; i < out_width; i++) { + lf_set(out[i], self->s++); + } + =} } reactor Destination(width: int = 1) { - state s: int = 6 - input[width] in: int + state s: int = 6 + input[width] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 16; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; + =} - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor BankToBankMultiport(bank_width: int = 4) { - a = new[bank_width] Source(width = 4) - b = new[bank_width] Destination(width = 4) - a.out -> b.in + a = new[bank_width] Source(width = 4) + b = new[bank_width] Destination(width = 4) + a.out -> b.in } diff --git a/test/C/src/multiport/BankToBankMultiportAfter.lf b/test/C/src/multiport/BankToBankMultiportAfter.lf index db0ff7771e..9338be1f8c 100644 --- a/test/C/src/multiport/BankToBankMultiportAfter.lf +++ b/test/C/src/multiport/BankToBankMultiportAfter.lf @@ -1,49 +1,49 @@ // Check bank of reactors sending to bank of reactors with multiports. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 1) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < out_width; i++) { - lf_set(out[i], self->s++); - } - =} + reaction(t) -> out {= + for(int i = 0; i < out_width; i++) { + lf_set(out[i], self->s++); + } + =} } reactor Destination(width: int = 1) { - state s: int = 6 - input[width] in: int + state s: int = 6 + input[width] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 16; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; + =} - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor(bank_width: int = 4) { - a = new[bank_width] Source(width = 4) - b = new[bank_width] Destination(width = 4) - a.out -> b.in after 200 msec + a = new[bank_width] Source(width = 4) + b = new[bank_width] Destination(width = 4) + a.out -> b.in after 200 msec } diff --git a/test/C/src/multiport/BankToMultiport.lf b/test/C/src/multiport/BankToMultiport.lf index f72c104df7..b45d812974 100644 --- a/test/C/src/multiport/BankToMultiport.lf +++ b/test/C/src/multiport/BankToMultiport.lf @@ -2,38 +2,38 @@ target C reactor Source(bank_index: int = 0) { - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, self->bank_index); =} + reaction(startup) -> out {= lf_set(out, self->bank_index); =} } reactor Sink(width: int = 4) { - input[width] in: int - state received: bool = false + input[width] in: int + state received: bool = false - reaction(in) {= - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - printf("Received on channel %d: %d\n", i, in[i]->value); - self->received = true; - if (in[i]->value != i) { - fprintf(stderr, "ERROR: expected %d\n", i); - exit(1); - } + reaction(in) {= + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + printf("Received on channel %d: %d\n", i, in[i]->value); + self->received = true; + if (in[i]->value != i) { + fprintf(stderr, "ERROR: expected %d\n", i); + exit(1); } } - =} + } + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Sink received no data\n"); - exit(1); - } - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Sink received no data\n"); + exit(1); + } + =} } main reactor BankToMultiport(width: int = 5) { - source = new[width] Source() - sink = new Sink(width = width) - source.out -> sink.in + source = new[width] Source() + sink = new Sink(width = width) + source.out -> sink.in } diff --git a/test/C/src/multiport/BankToReaction.lf b/test/C/src/multiport/BankToReaction.lf index 4e59352bd5..59c3282a36 100644 --- a/test/C/src/multiport/BankToReaction.lf +++ b/test/C/src/multiport/BankToReaction.lf @@ -1,22 +1,22 @@ target C { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } import Count from "../lib/Count.lf" main reactor { - state count: int = 1 + state count: int = 1 - s = new[2] Count() + s = new[2] Count() - reaction(s.out) {= - for (int i = 0; i < s_width; i++) { - lf_print("Received %d.", s[i].out->value); - if (self->count != s[i].out->value) { - lf_print_error_and_exit("Expected %d.", self->count); - } + reaction(s.out) {= + for (int i = 0; i < s_width; i++) { + lf_print("Received %d.", s[i].out->value); + if (self->count != s[i].out->value) { + lf_print_error_and_exit("Expected %d.", self->count); } - self->count++; - =} + } + self->count++; + =} } diff --git a/test/C/src/multiport/Broadcast.lf b/test/C/src/multiport/Broadcast.lf index e3471da5f6..d2b4b34d48 100644 --- a/test/C/src/multiport/Broadcast.lf +++ b/test/C/src/multiport/Broadcast.lf @@ -1,38 +1,38 @@ target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, 42); =} + reaction(startup) -> out {= lf_set(out, 42); =} } reactor Destination(bank_index: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - printf("Destination %d received %d.\n", self->bank_index, in->value); - if (in->value != 42) { - printf("ERROR: Expected 42.\n"); - exit(1); - } - self->received = true; - =} + reaction(in) {= + printf("Destination %d received %d.\n", self->bank_index, in->value); + if (in->value != 42) { + printf("ERROR: Expected 42.\n"); + exit(1); + } + self->received = true; + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); + exit(1); + } + printf("Success.\n"); + =} } main reactor { - a = new Source() - b = new[4] Destination() - (a.out)+ -> b.in + a = new Source() + b = new[4] Destination() + (a.out)+ -> b.in } diff --git a/test/C/src/multiport/BroadcastAfter.lf b/test/C/src/multiport/BroadcastAfter.lf index c1be635e55..cb3c9306f6 100644 --- a/test/C/src/multiport/BroadcastAfter.lf +++ b/test/C/src/multiport/BroadcastAfter.lf @@ -1,42 +1,42 @@ target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, 42); =} + reaction(startup) -> out {= lf_set(out, 42); =} } reactor Destination(bank_index: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - printf("Destination %d received %d.\n", self->bank_index, in->value); - if (in->value != 42) { - printf("ERROR: Expected 42.\n"); - exit(1); - } - if (lf_time_logical_elapsed() != SEC(1)) { - printf("ERROR: Expected to receive input after one second.\n"); - exit(2); - } - self->received = true; - =} + reaction(in) {= + printf("Destination %d received %d.\n", self->bank_index, in->value); + if (in->value != 42) { + printf("ERROR: Expected 42.\n"); + exit(1); + } + if (lf_time_logical_elapsed() != SEC(1)) { + printf("ERROR: Expected to receive input after one second.\n"); + exit(2); + } + self->received = true; + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); - exit(3); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); + exit(3); + } + printf("Success.\n"); + =} } main reactor { - a = new Source() - b = new[4] Destination() - (a.out)+ -> b.in after 1 sec + a = new Source() + b = new[4] Destination() + (a.out)+ -> b.in after 1 sec } diff --git a/test/C/src/multiport/BroadcastMultipleAfter.lf b/test/C/src/multiport/BroadcastMultipleAfter.lf index 97d853e4ce..6304f27492 100644 --- a/test/C/src/multiport/BroadcastMultipleAfter.lf +++ b/test/C/src/multiport/BroadcastMultipleAfter.lf @@ -1,45 +1,45 @@ target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(value: int = 42) { - output out: int + output out: int - reaction(startup) -> out {= lf_set(out, self->value); =} + reaction(startup) -> out {= lf_set(out, self->value); =} } reactor Destination(bank_index: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - printf("Destination %d received %d.\n", self->bank_index, in->value); - int expected = (self->bank_index % 3) + 1; - if (in->value != expected) { - printf("ERROR: Expected %d.\n", expected); - exit(1); - } - if (lf_time_logical_elapsed() != SEC(1)) { - printf("ERROR: Expected to receive input after one second.\n"); - exit(2); - } - self->received = true; - =} + reaction(in) {= + printf("Destination %d received %d.\n", self->bank_index, in->value); + int expected = (self->bank_index % 3) + 1; + if (in->value != expected) { + printf("ERROR: Expected %d.\n", expected); + exit(1); + } + if (lf_time_logical_elapsed() != SEC(1)) { + printf("ERROR: Expected to receive input after one second.\n"); + exit(2); + } + self->received = true; + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); - exit(3); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); + exit(3); + } + printf("Success.\n"); + =} } main reactor { - a1 = new Source(value = 1) - a2 = new Source(value = 2) - a3 = new Source(value = 3) - b = new[9] Destination() - (a1.out, a2.out, a3.out)+ -> b.in after 1 sec + a1 = new Source(value = 1) + a2 = new Source(value = 2) + a3 = new Source(value = 3) + b = new[9] Destination() + (a1.out, a2.out, a3.out)+ -> b.in after 1 sec } diff --git a/test/C/src/multiport/DualBanks.lf b/test/C/src/multiport/DualBanks.lf index 3cb5d38887..f674626dc8 100644 --- a/test/C/src/multiport/DualBanks.lf +++ b/test/C/src/multiport/DualBanks.lf @@ -1,42 +1,42 @@ target C reactor Base(bank_index: int = 0) { - input I: int - state received: bool = false + input I: int + state received: bool = false - reaction(shutdown) {= - if(!self->received) { - lf_print_error_and_exit("Bank member %d received no input.", - self->bank_index - ); - } - =} + reaction(shutdown) {= + if(!self->received) { + lf_print_error_and_exit("Bank member %d received no input.", + self->bank_index + ); + } + =} } reactor Hello extends Base { - reaction(I) {= - printf("Hello %d\n", self->bank_index); - self->received = true; - =} + reaction(I) {= + printf("Hello %d\n", self->bank_index); + self->received = true; + =} } reactor World extends Base { - reaction(I) {= - printf("World %d\n", self->bank_index); - self->received = true; - =} + reaction(I) {= + printf("World %d\n", self->bank_index); + self->received = true; + =} } main reactor { - hellos = new[3] Hello() - worlds = new[3] World() + hellos = new[3] Hello() + worlds = new[3] World() - reaction(startup) -> hellos.I, worlds.I {= - for(int i = 0; i < hellos_width; i++) { - lf_set(hellos[i].I, true); - } - for(int i = 0; i < worlds_width; i++) { - lf_set(worlds[i].I, true); - } - =} + reaction(startup) -> hellos.I, worlds.I {= + for(int i = 0; i < hellos_width; i++) { + lf_set(hellos[i].I, true); + } + for(int i = 0; i < worlds_width; i++) { + lf_set(worlds[i].I, true); + } + =} } diff --git a/test/C/src/multiport/DualBanksMultiport.lf b/test/C/src/multiport/DualBanksMultiport.lf index a5c2120a79..d1975b6789 100644 --- a/test/C/src/multiport/DualBanksMultiport.lf +++ b/test/C/src/multiport/DualBanksMultiport.lf @@ -1,48 +1,48 @@ target C reactor Base(bank_index: int = 0) { - input[2] I: int - state received: bool = false + input[2] I: int + state received: bool = false - reaction(shutdown) {= - if(!self->received) { - lf_print_error_and_exit("Bank member %d did not receive all inputs.", - self->bank_index - ); - } - =} + reaction(shutdown) {= + if(!self->received) { + lf_print_error_and_exit("Bank member %d did not receive all inputs.", + self->bank_index + ); + } + =} } reactor Hello extends Base { - reaction(I) {= - if (I[0]->is_present && I[1]->is_present) { - printf("Hello %d\n", self->bank_index); - self->received = true; - } - =} + reaction(I) {= + if (I[0]->is_present && I[1]->is_present) { + printf("Hello %d\n", self->bank_index); + self->received = true; + } + =} } reactor World extends Base { - reaction(I) {= - if (I[0]->is_present && I[1]->is_present) { - printf("World %d\n", self->bank_index); - self->received = true; - } - =} + reaction(I) {= + if (I[0]->is_present && I[1]->is_present) { + printf("World %d\n", self->bank_index); + self->received = true; + } + =} } main reactor { - hellos = new[3] Hello() - worlds = new[3] World() + hellos = new[3] Hello() + worlds = new[3] World() - reaction(startup) -> hellos.I, worlds.I {= - for(int i = 0; i < hellos_width; i++) { - lf_set(hellos[i].I[0], true); - lf_set(hellos[i].I[1], true); - } - for(int i = 0; i < worlds_width; i++) { - lf_set(worlds[i].I[0], true); - lf_set(worlds[i].I[1], true); - } - =} + reaction(startup) -> hellos.I, worlds.I {= + for(int i = 0; i < hellos_width; i++) { + lf_set(hellos[i].I[0], true); + lf_set(hellos[i].I[1], true); + } + for(int i = 0; i < worlds_width; i++) { + lf_set(worlds[i].I[0], true); + lf_set(worlds[i].I[1], true); + } + =} } diff --git a/test/C/src/multiport/FullyConnected.lf b/test/C/src/multiport/FullyConnected.lf index 758ecf1580..d65b64f18f 100644 --- a/test/C/src/multiport/FullyConnected.lf +++ b/test/C/src/multiport/FullyConnected.lf @@ -1,41 +1,41 @@ target C reactor Node(num_nodes: size_t = 4, bank_index: int = 0) { - input[num_nodes] in: int - output out: int + input[num_nodes] in: int + output out: int - state received: bool = false + state received: bool = false - reaction(startup) -> out {= - lf_print("Hello from node %d!", self->bank_index); - // broadcast my ID to everyone - lf_set(out, self->bank_index); - =} + reaction(startup) -> out {= + lf_print("Hello from node %d!", self->bank_index); + // broadcast my ID to everyone + lf_set(out, self->bank_index); + =} - reaction(in) {= - printf("Node %d received messages from ", self->bank_index); - size_t count = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - self->received = true; - count++; - printf("%d, ", in[i]->value); - } + reaction(in) {= + printf("Node %d received messages from ", self->bank_index); + size_t count = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + self->received = true; + count++; + printf("%d, ", in[i]->value); } - printf("\n"); - if (count != self->num_nodes) { - lf_print_error_and_exit("Received fewer messages than expected!"); - } - =} + } + printf("\n"); + if (count != self->num_nodes) { + lf_print_error_and_exit("Received fewer messages than expected!"); + } + =} - reaction(shutdown) {= - if (!self->received) { - lf_print_error_and_exit("Received no input!"); - } - =} + reaction(shutdown) {= + if (!self->received) { + lf_print_error_and_exit("Received no input!"); + } + =} } main reactor(num_nodes: size_t = 4) { - nodes = new[num_nodes] Node(num_nodes = num_nodes) - (nodes.out)+ -> nodes.in + nodes = new[num_nodes] Node(num_nodes = num_nodes) + (nodes.out)+ -> nodes.in } diff --git a/test/C/src/multiport/FullyConnectedAddressable.lf b/test/C/src/multiport/FullyConnectedAddressable.lf index 91b0f5caac..2fd5e03ad2 100644 --- a/test/C/src/multiport/FullyConnectedAddressable.lf +++ b/test/C/src/multiport/FullyConnectedAddressable.lf @@ -2,53 +2,53 @@ target C reactor Node(num_nodes: size_t = 4, bank_index: int = 0) { - input[num_nodes] in: int - output[num_nodes] out: int + input[num_nodes] in: int + output[num_nodes] out: int - state received: int = 0 - state triggered: bool = false + state received: int = 0 + state triggered: bool = false - reaction(startup) -> out {= - int outChannel = (self->bank_index + 1) % self->num_nodes; - lf_print("Node %d sending %d out on channel %d.", - self->bank_index, self->bank_index, outChannel - ); - // broadcast my ID to everyone - lf_set(out[outChannel], self->bank_index); - =} + reaction(startup) -> out {= + int outChannel = (self->bank_index + 1) % self->num_nodes; + lf_print("Node %d sending %d out on channel %d.", + self->bank_index, self->bank_index, outChannel + ); + // broadcast my ID to everyone + lf_set(out[outChannel], self->bank_index); + =} - reaction(in) {= - self->triggered = true; - printf("Node %d received messages from ", self->bank_index); - size_t count = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - count++; - printf("%d, ", in[i]->value); - self->received = in[i]->value; - } + reaction(in) {= + self->triggered = true; + printf("Node %d received messages from ", self->bank_index); + size_t count = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + count++; + printf("%d, ", in[i]->value); + self->received = in[i]->value; } - printf("\n"); - int expected = self->bank_index == 0 ? self->num_nodes - 1 : self->bank_index - 1; - if (count != 1) { - lf_print_error_and_exit("Received %d messages, but expecting only one!"); - } - if (self->received != expected) { - lf_print_error_and_exit("Received %d, but expected %d!", self->received, expected); - } - =} + } + printf("\n"); + int expected = self->bank_index == 0 ? self->num_nodes - 1 : self->bank_index - 1; + if (count != 1) { + lf_print_error_and_exit("Received %d messages, but expecting only one!"); + } + if (self->received != expected) { + lf_print_error_and_exit("Received %d, but expected %d!", self->received, expected); + } + =} - reaction(shutdown) {= - if (!self->triggered) { - lf_print_error_and_exit("Received no input!"); - } - =} + reaction(shutdown) {= + if (!self->triggered) { + lf_print_error_and_exit("Received no input!"); + } + =} } main reactor(num_nodes: size_t = 4) { - nodes1 = new[num_nodes] Node(num_nodes = num_nodes) - nodes1.out -> interleaved (nodes1.in) + nodes1 = new[num_nodes] Node(num_nodes = num_nodes) + nodes1.out -> interleaved (nodes1.in) - nodes2 = new[num_nodes] Node(num_nodes = num_nodes) - interleaved (nodes2.out) -> nodes2.in + nodes2 = new[num_nodes] Node(num_nodes = num_nodes) + interleaved (nodes2.out) -> nodes2.in } diff --git a/test/C/src/multiport/FullyConnectedAddressableAfter.lf b/test/C/src/multiport/FullyConnectedAddressableAfter.lf index 1d30430deb..e71c5194bb 100644 --- a/test/C/src/multiport/FullyConnectedAddressableAfter.lf +++ b/test/C/src/multiport/FullyConnectedAddressableAfter.lf @@ -4,9 +4,9 @@ target C import Node from "FullyConnectedAddressable.lf" main reactor(num_nodes: size_t = 4) { - nodes1 = new[num_nodes] Node(num_nodes = num_nodes) - nodes1.out -> interleaved (nodes1.in) after 200 msec + nodes1 = new[num_nodes] Node(num_nodes = num_nodes) + nodes1.out -> interleaved (nodes1.in) after 200 msec - nodes2 = new[num_nodes] Node(num_nodes = num_nodes) - interleaved (nodes2.out) -> nodes2.in after 400 msec + nodes2 = new[num_nodes] Node(num_nodes = num_nodes) + interleaved (nodes2.out) -> nodes2.in after 400 msec } diff --git a/test/C/src/multiport/MultiportFromBank.lf b/test/C/src/multiport/MultiportFromBank.lf index 1b49786060..2bdb344cf0 100644 --- a/test/C/src/multiport/MultiportFromBank.lf +++ b/test/C/src/multiport/MultiportFromBank.lf @@ -1,44 +1,42 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(check_override: int = 0, bank_index: int = 0) { - output out: int + output out: int - reaction(startup) -> out {= - lf_set(out, self->bank_index * self->check_override); - =} + reaction(startup) -> out {= lf_set(out, self->bank_index * self->check_override); =} } reactor Destination(port_width: int = 3) { - input[port_width] in: int - state received: bool = false + input[port_width] in: int + state received: bool = false - reaction(in) {= - for (int i = 0; i < in_width; i++) { - printf("Destination channel %d received %d.\n", i, in[i]->value); - if (i != in[i]->value) { - printf("ERROR: Expected %d.\n", i); - exit(1); - } - } - self->received = true; - =} - - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination received no input!\n"); + reaction(in) {= + for (int i = 0; i < in_width; i++) { + printf("Destination channel %d received %d.\n", i, in[i]->value); + if (i != in[i]->value) { + printf("ERROR: Expected %d.\n", i); exit(1); } - printf("Success.\n"); - =} + } + self->received = true; + =} + + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor MultiportFromBank(width: int = 4) { - a = new[width] Source(check_override = 1) - b = new Destination(port_width = width) - a.out -> b.in + a = new[width] Source(check_override = 1) + b = new Destination(port_width = width) + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportFromBankHierarchy.lf b/test/C/src/multiport/MultiportFromBankHierarchy.lf index e8ee6194b5..073f76ad7a 100644 --- a/test/C/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/C/src/multiport/MultiportFromBankHierarchy.lf @@ -1,20 +1,20 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Source, Destination from "MultiportFromBank.lf" reactor Container(port_width: int = 3) { - output[port_width] out: int - s = new[port_width] Source(check_override = 1) - s.out -> out + output[port_width] out: int + s = new[port_width] Source(check_override = 1) + s.out -> out } main reactor(width: int = 4) { - a = new Container(port_width = width) - b = new Destination(port_width = width) - a.out -> b.in + a = new Container(port_width = width) + b = new Destination(port_width = width) + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportFromHierarchy.lf b/test/C/src/multiport/MultiportFromHierarchy.lf index 8323210946..c7a6b36277 100644 --- a/test/C/src/multiport/MultiportFromHierarchy.lf +++ b/test/C/src/multiport/MultiportFromHierarchy.lf @@ -1,62 +1,61 @@ -// Check multiport output to multiport input, where the former is a hierarchical -// reactor. +// Check multiport output to multiport input, where the former is a hierarchical reactor. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 3) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 - - reaction(t) -> out {= - for(int i = 0; i < out_width; i++) { - lf_set(out[i], self->s++); - } - =} + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 + + reaction(t) -> out {= + for(int i = 0; i < out_width; i++) { + lf_set(out[i], self->s++); + } + =} } reactor Destination(width: int = 3) { - state s: int = 6 - input[width] in: int - - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 16; - =} - - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + state s: int = 6 + input[width] in: int + + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; + =} + + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } reactor Container(width: int = 3) { - output[width] out: int - src = new InsideContainer(width = width) - src.out -> out + output[width] out: int + src = new InsideContainer(width = width) + src.out -> out } reactor InsideContainer(width: int = 3) { - output[width] out: int - src = new Source(width = width) - src.out -> out + output[width] out: int + src = new Source(width = width) + src.out -> out } main reactor MultiportFromHierarchy(width: int = 4) { - a = new Container(width = width) - b = new Destination(width = width) - a.out -> b.in + a = new Container(width = width) + b = new Destination(width = width) + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportFromReaction.lf b/test/C/src/multiport/MultiportFromReaction.lf index 33cbfffd83..0b0b83aa71 100644 --- a/test/C/src/multiport/MultiportFromReaction.lf +++ b/test/C/src/multiport/MultiportFromReaction.lf @@ -1,46 +1,46 @@ // Check reaction to multiport input of a contained reactor. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Destination(width: int = 1) { - state s: int = 6 - input[width] in: int + state s: int = 6 + input[width] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 16; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; + =} - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor MultiportFromReaction(width: int = 4) { - timer t(0, 200 msec) - state s: int = 0 - b = new Destination(width = width) + timer t(0, 200 msec) + state s: int = 0 + b = new Destination(width = width) - reaction(t) -> b.in {= - for(int i = 0; i < b.in_width; i++) { - printf("Before lf_set, b.in[%d]->is_present has value %d\n", i, b.in[i]->is_present); - lf_set(b.in[i], self->s++); - printf("AFTER set, b.in[%d]->is_present has value %d\n", i, b.in[i]->is_present); - printf("AFTER set, b.in[%d]->value has value %d\n", i, b.in[i]->value); - } - =} + reaction(t) -> b.in {= + for(int i = 0; i < b.in_width; i++) { + printf("Before lf_set, b.in[%d]->is_present has value %d\n", i, b.in[i]->is_present); + lf_set(b.in[i], self->s++); + printf("AFTER set, b.in[%d]->is_present has value %d\n", i, b.in[i]->is_present); + printf("AFTER set, b.in[%d]->value has value %d\n", i, b.in[i]->value); + } + =} } diff --git a/test/C/src/multiport/MultiportIn.lf b/test/C/src/multiport/MultiportIn.lf index b87a91a79b..cba7094684 100644 --- a/test/C/src/multiport/MultiportIn.lf +++ b/test/C/src/multiport/MultiportIn.lf @@ -1,64 +1,64 @@ -// This is a version fo the Threaded test that uses a multiport input at the -// destination. Its purpose is to test multiport inputs. +// This is a version fo the Threaded test that uses a multiport input at the destination. Its +// purpose is to test multiport inputs. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - lf_set(out, self->s); - self->s++; - =} + reaction(t) -> out {= + lf_set(out, self->s); + self->s++; + =} } reactor Computation { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= lf_set(out, in->value); =} + reaction(in) -> out {= lf_set(out, in->value); =} } reactor Destination { - state s: int = 0 - input[4] in: int + state s: int = 0 + input[4] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 4; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 4; + =} - reaction(shutdown) {= - if (self->s == 0) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s == 0) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor MultiportIn { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination() - a.out -> t1.in - a.out -> t2.in - a.out -> t3.in - a.out -> t4.in - t1.out, t2.out, t3.out, t4.out -> b.in + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination() + a.out -> t1.in + a.out -> t2.in + a.out -> t3.in + a.out -> t4.in + t1.out, t2.out, t3.out, t4.out -> b.in } diff --git a/test/C/src/multiport/MultiportInParameterized.lf b/test/C/src/multiport/MultiportInParameterized.lf index bf7ec93f6e..d2026c8aca 100644 --- a/test/C/src/multiport/MultiportInParameterized.lf +++ b/test/C/src/multiport/MultiportInParameterized.lf @@ -1,66 +1,65 @@ -// This is a version of the Threaded test that uses a multiport input at the -// destination. Its purpose is to test multiport inputs. +// This is a version of the Threaded test that uses a multiport input at the destination. Its +// purpose is to test multiport inputs. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - lf_set(out, self->s); - self->s++; - =} + reaction(t) -> out {= + lf_set(out, self->s); + self->s++; + =} } reactor Computation { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= lf_set(out, in->value); =} + reaction(in) -> out {= lf_set(out, in->value); =} } reactor Destination(width: int = 1) { - state s: int = 0 - input[width] in: int + state s: int = 0 + input[width] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 4; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 4; + =} - reaction(shutdown) {= - if (self->s == 0) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s == 0) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination(width = 4) - a.out -> t1.in - a.out -> t2.in - a.out -> t3.in - a.out -> t4.in - // I.e.: t1.out -> b.in[0]; t2.out -> b.in[1]; t3.out -> b.in[2]; dt4.out -> - // b.in[3]; - t1.out, t2.out, t3.out, t4.out -> b.in + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination(width = 4) + a.out -> t1.in + a.out -> t2.in + a.out -> t3.in + a.out -> t4.in + // I.e.: t1.out -> b.in[0]; t2.out -> b.in[1]; t3.out -> b.in[2]; dt4.out -> b.in[3]; + t1.out, t2.out, t3.out, t4.out -> b.in } diff --git a/test/C/src/multiport/MultiportMutableInput.lf b/test/C/src/multiport/MultiportMutableInput.lf index e1f8d579c2..187b4d47be 100644 --- a/test/C/src/multiport/MultiportMutableInput.lf +++ b/test/C/src/multiport/MultiportMutableInput.lf @@ -1,49 +1,48 @@ -// Source produces a ints on a multiport, which it passes to Scale. Scale -// requests a writable copy. It modifies it and passes it to Print. It gets -// freed after Print is done with it. +// Source produces a ints on a multiport, which it passes to Scale. Scale requests a writable copy. +// It modifies it and passes it to Print. It gets freed after Print is done with it. target C reactor Source { - output[2] out: int + output[2] out: int - reaction(startup) -> out {= - lf_set(out[0], 21); - lf_set(out[1], 42); - =} + reaction(startup) -> out {= + lf_set(out[0], 21); + lf_set(out[1], 42); + =} } reactor Print(scale: int = 1) { // The scale parameter is just for testing. - input[2] in: int + input[2] in: int - reaction(in) {= - int expected = 42; - for(int j = 0; j < 2; j++) { - lf_print("Received on channel %d: %d", j, in[j]->value); - if (in[j]->value != expected) { - lf_print_error_and_exit("ERROR: Expected %d!\n", expected); - } - expected *=2; + reaction(in) {= + int expected = 42; + for(int j = 0; j < 2; j++) { + lf_print("Received on channel %d: %d", j, in[j]->value); + if (in[j]->value != expected) { + lf_print_error_and_exit("ERROR: Expected %d!\n", expected); } - =} + expected *=2; + } + =} } reactor Scale(scale: int = 2) { - mutable input[2] in: int - output[2] out: int + mutable input[2] in: int + output[2] out: int - reaction(in) -> out {= - for(int j = 0; j < 2; j++) { - // Modify the input, allowed because mutable. - in[j]->value *= self->scale; - lf_set(out[j], in[j]->value); - } - =} + reaction(in) -> out {= + for(int j = 0; j < 2; j++) { + // Modify the input, allowed because mutable. + in[j]->value *= self->scale; + lf_set(out[j], in[j]->value); + } + =} } main reactor { - s = new Source() - c = new Scale() - p = new Print(scale = 2) - s.out -> c.in - c.out -> p.in + s = new Source() + c = new Scale() + p = new Print(scale = 2) + s.out -> c.in + c.out -> p.in } diff --git a/test/C/src/multiport/MultiportMutableInputArray.lf b/test/C/src/multiport/MultiportMutableInputArray.lf index 90907e4f44..07f8a97365 100644 --- a/test/C/src/multiport/MultiportMutableInputArray.lf +++ b/test/C/src/multiport/MultiportMutableInputArray.lf @@ -1,77 +1,76 @@ -// Source produces a dynamically allocated arrays on a multiport, which it -// passes to Scale. Scale requests a writable copy, which, instead of copying, -// it just gets ownership of the original array. It modifies it and passes it to -// Print. It gets freed after Print is done with it. +// Source produces a dynamically allocated arrays on a multiport, which it passes to Scale. Scale +// requests a writable copy, which, instead of copying, it just gets ownership of the original +// array. It modifies it and passes it to Print. It gets freed after Print is done with it. target C reactor Source { - output[2] out: int[] + output[2] out: int[] - reaction(startup) -> out {= - // Dynamically allocate an output array of length 3. - SET_NEW_ARRAY(out[0], 3); + reaction(startup) -> out {= + // Dynamically allocate an output array of length 3. + SET_NEW_ARRAY(out[0], 3); - // Above allocates the array, which then must be populated. - out[0]->value[0] = 0; - out[0]->value[1] = 1; - out[0]->value[2] = 2; + // Above allocates the array, which then must be populated. + out[0]->value[0] = 0; + out[0]->value[1] = 1; + out[0]->value[2] = 2; - // Dynamically allocate an output array of length 3. - SET_NEW_ARRAY(out[1], 3); + // Dynamically allocate an output array of length 3. + SET_NEW_ARRAY(out[1], 3); - // Above allocates the array, which then must be populated. - out[1]->value[0] = 3; - out[1]->value[1] = 4; - out[1]->value[2] = 5; - =} + // Above allocates the array, which then must be populated. + out[1]->value[0] = 3; + out[1]->value[1] = 4; + out[1]->value[2] = 5; + =} } reactor Print(scale: int = 1) { // The scale parameter is just for testing. - input[2] in: int[] + input[2] in: int[] - reaction(in) {= - int count = 0; // For testing. - bool failed = false; // For testing. - for(int j = 0; j < 2; j++) { - printf("Received on channel %d: [", j); - for (int i = 0; i < in[j]->length; i++) { - if (i > 0) printf(", "); - printf("%d", in[j]->value[i]); - // For testing, check whether values match expectation. - if (in[j]->value[i] != self->scale * count) { - failed = true; - } - count++; // For testing. + reaction(in) {= + int count = 0; // For testing. + bool failed = false; // For testing. + for(int j = 0; j < 2; j++) { + printf("Received on channel %d: [", j); + for (int i = 0; i < in[j]->length; i++) { + if (i > 0) printf(", "); + printf("%d", in[j]->value[i]); + // For testing, check whether values match expectation. + if (in[j]->value[i] != self->scale * count) { + failed = true; } - printf("]\n"); + count++; // For testing. } - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); - } - =} + printf("]\n"); + } + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + =} } reactor Scale(scale: int = 2) { - mutable input[2] in: int[] - output[2] out: int[] + mutable input[2] in: int[] + output[2] out: int[] - reaction(in) -> out {= - for(int j = 0; j < in_width; j++) { - for(int i = 0; i < in[j]->length; i++) { - if (in[j]->is_present) { - in[j]->value[i] *= self->scale; - } + reaction(in) -> out {= + for(int j = 0; j < in_width; j++) { + for(int i = 0; i < in[j]->length; i++) { + if (in[j]->is_present) { + in[j]->value[i] *= self->scale; } - lf_set_token(out[j], in[j]->token); } - =} + lf_set_token(out[j], in[j]->token); + } + =} } main reactor { - s = new Source() - c = new Scale() - p = new Print(scale = 2) - s.out -> c.in - c.out -> p.in + s = new Source() + c = new Scale() + p = new Print(scale = 2) + s.out -> c.in + c.out -> p.in } diff --git a/test/C/src/multiport/MultiportOut.lf b/test/C/src/multiport/MultiportOut.lf index 38365d217a..bb756937e5 100644 --- a/test/C/src/multiport/MultiportOut.lf +++ b/test/C/src/multiport/MultiportOut.lf @@ -1,68 +1,68 @@ // Check multiport capabilities on Outputs. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[4] out: int - state s: int = 0 + timer t(0, 200 msec) + output[4] out: int + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < 4; i++) { - lf_set(out[i], self->s); - } - self->s++; - =} + reaction(t) -> out {= + for(int i = 0; i < 4; i++) { + lf_set(out[i], self->s); + } + self->s++; + =} } reactor Computation { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= - // No need to sleep for this test. - // struct timespec sleep_time = {(time_t) 0, (long)200000000}; - // struct timespec remaining_time; - // nanosleep(&sleep_time, &remaining_time); - lf_set(out, in->value); - =} + reaction(in) -> out {= + // No need to sleep for this test. + // struct timespec sleep_time = {(time_t) 0, (long)200000000}; + // struct timespec remaining_time; + // nanosleep(&sleep_time, &remaining_time); + lf_set(out, in->value); + =} } reactor Destination { - state s: int = 0 - input[4] in: int + state s: int = 0 + input[4] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 4; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 4; + =} - reaction(shutdown) {= - if (self->s == 0) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s == 0) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination() - a.out -> t1.in, t2.in, t3.in, t4.in - t1.out, t2.out, t3.out, t4.out -> b.in + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination() + a.out -> t1.in, t2.in, t3.in, t4.in + t1.out, t2.out, t3.out, t4.out -> b.in } diff --git a/test/C/src/multiport/MultiportToBank.lf b/test/C/src/multiport/MultiportToBank.lf index 86146b9818..4e0e89d05e 100644 --- a/test/C/src/multiport/MultiportToBank.lf +++ b/test/C/src/multiport/MultiportToBank.lf @@ -1,53 +1,52 @@ // Check multiport output to bank of recipients. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 2) { - output[width] out: int // Connected to a bank of Destination reactors - input dummy: int // Not connected to anything + output[width] out: int // Connected to a bank of Destination reactors + input dummy: int // Not connected to anything - reaction(startup) -> out {= - for(int i = 0; i < out_width; i++) { - lf_set(out[i], i); - } - =} + reaction(startup) -> out {= + for(int i = 0; i < out_width; i++) { + lf_set(out[i], i); + } + =} - // Test also that multiple appearances of the same effect port do not result - // in multiple allocations of memory for the port. - reaction(dummy) -> - out {= // Contents of the reactions does not matter (either could be empty) - for(int i = 0; i < out_width; i++) { - lf_set(out[i], i); - } - =} + // Test also that multiple appearances of the same effect port do not result in multiple + // allocations of memory for the port. + reaction(dummy) -> out {= // Contents of the reactions does not matter (either could be empty) + for(int i = 0; i < out_width; i++) { + lf_set(out[i], i); + } + =} } reactor Destination(bank_index: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - printf("Destination %d received %d.\n", self->bank_index, in->value); - if (self->bank_index != in->value) { - printf("ERROR: Expected %d.\n", self->bank_index); - exit(1); - } - self->received = true; - =} + reaction(in) {= + printf("Destination %d received %d.\n", self->bank_index, in->value); + if (self->bank_index != in->value) { + printf("ERROR: Expected %d.\n", self->bank_index); + exit(1); + } + self->received = true; + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); + exit(1); + } + printf("Success.\n"); + =} } main reactor MultiportToBank(width: int = 3) { - a = new Source(width = width) - b = new[width] Destination() - a.out -> b.in + a = new Source(width = width) + b = new[width] Destination() + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportToBankAfter.lf b/test/C/src/multiport/MultiportToBankAfter.lf index ba26142243..52945d1c67 100644 --- a/test/C/src/multiport/MultiportToBankAfter.lf +++ b/test/C/src/multiport/MultiportToBankAfter.lf @@ -1,48 +1,47 @@ -// Check multiport output to bank of recipients where the width of the bank is -// inferred. +// Check multiport output to bank of recipients where the width of the bank is inferred. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 2) { - output[width] out: int + output[width] out: int - reaction(startup) -> out {= - for(int i = 0; i < out_width; i++) { - lf_set(out[i], i); - } - =} + reaction(startup) -> out {= + for(int i = 0; i < out_width; i++) { + lf_set(out[i], i); + } + =} } reactor Destination(bank_index: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - printf("Destination %d received %d.\n", self->bank_index, in->value); - if (self->bank_index != in->value) { - printf("ERROR: Expected %d.\n", self->bank_index); - exit(1); - } - if (lf_time_logical_elapsed() != SEC(1)) { - printf("ERROR: Expected to receive input after one second.\n"); - exit(2); - } - self->received = true; - =} + reaction(in) {= + printf("Destination %d received %d.\n", self->bank_index, in->value); + if (self->bank_index != in->value) { + printf("ERROR: Expected %d.\n", self->bank_index); + exit(1); + } + if (lf_time_logical_elapsed() != SEC(1)) { + printf("ERROR: Expected to receive input after one second.\n"); + exit(2); + } + self->received = true; + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); - exit(3); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); + exit(3); + } + printf("Success.\n"); + =} } main reactor(width: int = 3) { - a = new Source(width = width) - b = new[width] Destination() - a.out -> b.in after 1 sec // Width of the bank of delays will be inferred. + a = new Source(width = width) + b = new[width] Destination() + a.out -> b.in after 1 sec // Width of the bank of delays will be inferred. } diff --git a/test/C/src/multiport/MultiportToBankDouble.lf b/test/C/src/multiport/MultiportToBankDouble.lf index 444f02d170..baf752b338 100644 --- a/test/C/src/multiport/MultiportToBankDouble.lf +++ b/test/C/src/multiport/MultiportToBankDouble.lf @@ -1,53 +1,52 @@ -// Check multiport output to bank of recipients where the source has two -// reactions that write to the output. +// Check multiport output to bank of recipients where the source has two reactions that write to the +// output. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output[3] out: int // Connected to a bank of Destination reactors + output[3] out: int // Connected to a bank of Destination reactors - reaction(startup) -> out {= - for(int i = 0; i < out_width; i++) { - lf_set(out[i], i); - } - =} + reaction(startup) -> out {= + for(int i = 0; i < out_width; i++) { + lf_set(out[i], i); + } + =} - // Test also that multiple appearances of the same effect port do not result - // in multiple allocations of memory for the port. - reaction(startup) -> - out {= // Contents of the reactions does not matter (either could be empty) - for(int i = 0; i < out_width; i++) { - lf_set(out[i], i * 2); - } - =} + // Test also that multiple appearances of the same effect port do not result in multiple + // allocations of memory for the port. + reaction(startup) -> out {= // Contents of the reactions does not matter (either could be empty) + for(int i = 0; i < out_width; i++) { + lf_set(out[i], i * 2); + } + =} } reactor Destination(bank_index: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - printf("Destination %d received %d.\n", self->bank_index, in->value); - if (self->bank_index * 2 != in->value) { - printf("ERROR: Expected %d.\n", self->bank_index * 2); - exit(1); - } - self->received = true; - =} + reaction(in) {= + printf("Destination %d received %d.\n", self->bank_index, in->value); + if (self->bank_index * 2 != in->value) { + printf("ERROR: Expected %d.\n", self->bank_index * 2); + exit(1); + } + self->received = true; + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); + exit(1); + } + printf("Success.\n"); + =} } main reactor { - a = new Source() - b = new[3] Destination() - a.out -> b.in + a = new Source() + b = new[3] Destination() + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportToBankHierarchy.lf b/test/C/src/multiport/MultiportToBankHierarchy.lf index fbdc531bf0..dcb3b41811 100644 --- a/test/C/src/multiport/MultiportToBankHierarchy.lf +++ b/test/C/src/multiport/MultiportToBankHierarchy.lf @@ -1,50 +1,50 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 2) { - output[width] out: int + output[width] out: int - reaction(startup) -> out {= - for(int i = 0; i < out_width; i++) { - lf_set(out[i], i); - } - =} + reaction(startup) -> out {= + for(int i = 0; i < out_width; i++) { + lf_set(out[i], i); + } + =} } reactor Destination(bank_index: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - printf("Destination %d received %d.\n", self->bank_index, in->value); - if (self->bank_index != in->value) { - printf("ERROR: Expected %d.\n", self->bank_index); - exit(1); - } - self->received = true; - =} + reaction(in) {= + printf("Destination %d received %d.\n", self->bank_index, in->value); + if (self->bank_index != in->value) { + printf("ERROR: Expected %d.\n", self->bank_index); + exit(1); + } + self->received = true; + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination %d received no input!\n", self->bank_index); + exit(1); + } + printf("Success.\n"); + =} } reactor Container(width: int = 2) { - input[width] in: int - c = new[width] Destination() - in -> c.in + input[width] in: int + c = new[width] Destination() + in -> c.in } main reactor MultiportToBankHierarchy(width: int = 3) { - a = new Source(width = width) - b = new Container(width = width) - a.out -> b.in + a = new Source(width = width) + b = new Container(width = width) + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportToHierarchy.lf b/test/C/src/multiport/MultiportToHierarchy.lf index 41ca505077..2abaca76eb 100644 --- a/test/C/src/multiport/MultiportToHierarchy.lf +++ b/test/C/src/multiport/MultiportToHierarchy.lf @@ -1,57 +1,56 @@ -// Check multiport output to multiport input, where the latter is a hierarchical -// reactor. Note that the destination reactor has width wider than the sender, -// so one input is dangling. +// Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that +// the destination reactor has width wider than the sender, so one input is dangling. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 2) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < 4; i++) { - lf_set(out[i], self->s++); - } - =} + reaction(t) -> out {= + for(int i = 0; i < 4; i++) { + lf_set(out[i], self->s++); + } + =} } reactor Destination(width: int = 4) { - state s: int = 6 - input[width] in: int + state s: int = 6 + input[width] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 16; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; + =} - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } reactor Container(width: int = 4) { - input[width] in: int - dst = new Destination() - in -> dst.in + input[width] in: int + dst = new Destination() + in -> dst.in } main reactor MultiportToHierarchy(width: int = 4) { - a = new Source(width = width) - b = new Container(width = width) - a.out -> b.in + a = new Source(width = width) + b = new Container(width = width) + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportToMultiport.lf b/test/C/src/multiport/MultiportToMultiport.lf index 375fa080e2..c24b8b59de 100644 --- a/test/C/src/multiport/MultiportToMultiport.lf +++ b/test/C/src/multiport/MultiportToMultiport.lf @@ -1,52 +1,52 @@ // Check multiport output to multiport input. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 1) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < out_width; i++) { - printf("Before lf_set, out[%d]->is_present has value %d\n", i, out[i]->is_present); - lf_set(out[i], self->s++); - printf("AFTER set, out[%d]->is_present has value %d\n", i, out[i]->is_present); - printf("AFTER set, out[%d]->value has value %d\n", i, out[i]->value); - } - =} + reaction(t) -> out {= + for(int i = 0; i < out_width; i++) { + printf("Before lf_set, out[%d]->is_present has value %d\n", i, out[i]->is_present); + lf_set(out[i], self->s++); + printf("AFTER set, out[%d]->is_present has value %d\n", i, out[i]->is_present); + printf("AFTER set, out[%d]->value has value %d\n", i, out[i]->value); + } + =} } reactor Destination(width: int = 1) { - state s: int = 6 - input[width] in: int + state s: int = 6 + input[width] in: int - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 16; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; + =} - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor MultiportToMultiport(width: int = 4) { - a = new Source(width = width) - b = new Destination(width = width) - a.out -> b.in + a = new Source(width = width) + b = new Destination(width = width) + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportToMultiport2.lf b/test/C/src/multiport/MultiportToMultiport2.lf index 76858a2a86..4247995caa 100644 --- a/test/C/src/multiport/MultiportToMultiport2.lf +++ b/test/C/src/multiport/MultiportToMultiport2.lf @@ -2,40 +2,36 @@ target C reactor Source(width: int = 2) { - output[width] out: int + output[width] out: int - reaction(startup) -> out {= - for (int i = 0; i < out_width; i++) { - lf_set(out[i], i); - } - =} + reaction(startup) -> out {= + for (int i = 0; i < out_width; i++) { + lf_set(out[i], i); + } + =} } reactor Destination(width: int = 2) { - input[width] in: int + input[width] in: int - reaction(in) {= - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - printf("Received on channel %d: %d\n", i, in[i]->value); - // NOTE: For testing purposes, this assumes the specific - // widths instantiated below. - if (in[i]->value != i % 3) { - fprintf(stderr, "ERROR: expected %d!\n", i % 3); - exit(1); - } + reaction(in) {= + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + printf("Received on channel %d: %d\n", i, in[i]->value); + // NOTE: For testing purposes, this assumes the specific + // widths instantiated below. + if (in[i]->value != i % 3) { + fprintf(stderr, "ERROR: expected %d!\n", i % 3); + exit(1); } } - =} + } + =} } -main reactor MultiportToMultiport2( - width1: int = 3, - width2: int = 2, - width3: int = 5 -) { - a1 = new Source(width = width1) - a2 = new Source(width = width2) - b = new Destination(width = width3) - a1.out, a2.out -> b.in +main reactor MultiportToMultiport2(width1: int = 3, width2: int = 2, width3: int = 5) { + a1 = new Source(width = width1) + a2 = new Source(width = width2) + b = new Destination(width = width3) + a1.out, a2.out -> b.in } diff --git a/test/C/src/multiport/MultiportToMultiport2After.lf b/test/C/src/multiport/MultiportToMultiport2After.lf index 49585ea1b0..2d626610cf 100644 --- a/test/C/src/multiport/MultiportToMultiport2After.lf +++ b/test/C/src/multiport/MultiportToMultiport2After.lf @@ -2,40 +2,40 @@ target C reactor Source(width: int = 2) { - output[width] out: int + output[width] out: int - reaction(startup) -> out {= - for (int i = 0; i < out_width; i++) { - lf_set(out[i], i); - } - =} + reaction(startup) -> out {= + for (int i = 0; i < out_width; i++) { + lf_set(out[i], i); + } + =} } reactor Destination(width: int = 2) { - input[width] in: int + input[width] in: int - reaction(in) {= - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - printf("Received on channel %d: %d\n", i, in[i]->value); - // NOTE: For testing purposes, this assumes the specific - // widths instantiated below. - if (in[i]->value != i % 3) { - fprintf(stderr, "ERROR: expected %d!\n", i % 3); - exit(1); - } + reaction(in) {= + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + printf("Received on channel %d: %d\n", i, in[i]->value); + // NOTE: For testing purposes, this assumes the specific + // widths instantiated below. + if (in[i]->value != i % 3) { + fprintf(stderr, "ERROR: expected %d!\n", i % 3); + exit(1); } } - if (lf_time_logical_elapsed() != SEC(1)) { - printf("ERROR: Expected to receive input after one second.\n"); - exit(2); - } - =} + } + if (lf_time_logical_elapsed() != SEC(1)) { + printf("ERROR: Expected to receive input after one second.\n"); + exit(2); + } + =} } main reactor MultiportToMultiport2After { - a1 = new Source(width = 3) - a2 = new Source(width = 2) - b = new Destination(width = 5) - a1.out, a2.out -> b.in after 1 sec + a1 = new Source(width = 3) + a2 = new Source(width = 2) + b = new Destination(width = 5) + a1.out, a2.out -> b.in after 1 sec } diff --git a/test/C/src/multiport/MultiportToMultiportArray.lf b/test/C/src/multiport/MultiportToMultiportArray.lf index 9d86a4a522..203e4fb04f 100644 --- a/test/C/src/multiport/MultiportToMultiportArray.lf +++ b/test/C/src/multiport/MultiportToMultiportArray.lf @@ -1,60 +1,59 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[2] out: int[] - state s: int = 0 + timer t(0, 200 msec) + output[2] out: int[] + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < 2; i++) { - // Dynamically allocate an output array of length 3. - SET_NEW_ARRAY(out[i], 3); + reaction(t) -> out {= + for(int i = 0; i < 2; i++) { + // Dynamically allocate an output array of length 3. + SET_NEW_ARRAY(out[i], 3); - // Above allocates the array, which then must be populated. - out[i]->value[0] = self->s++; - out[i]->value[1] = self->s++; - out[i]->value[2] = self->s++; - } - =} + // Above allocates the array, which then must be populated. + out[i]->value[0] = self->s++; + out[i]->value[1] = self->s++; + out[i]->value[2] = self->s++; + } + =} } reactor Destination { - state s: int = 15 - input[2] in: int[] + state s: int = 15 + input[2] in: int[] - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) { - for (int j = 0; j < in[i]->length; j++) { - sum += in[i]->value[j]; - } + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) { + for (int j = 0; j < in[i]->length; j++) { + sum += in[i]->value[j]; } } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 36; - =} + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 36; + =} - reaction(shutdown) {= - if (self->s <= 15) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 15) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor MultiportToMultiportArray { - a = new Source() - b = new Destination() - a.out -> b.in + a = new Source() + b = new Destination() + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportToMultiportParameter.lf b/test/C/src/multiport/MultiportToMultiportParameter.lf index d1c96e5ddd..fe311cd7fa 100644 --- a/test/C/src/multiport/MultiportToMultiportParameter.lf +++ b/test/C/src/multiport/MultiportToMultiportParameter.lf @@ -1,52 +1,52 @@ // Check multiport output to multiport input. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 1) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < out_width; i++) { - printf("Before lf_set, out[%d]->is_present has value %d\n", i, out[i]->is_present); - lf_set(out[i], self->s++); - printf("AFTER set, out[%d]->is_present has value %d\n", i, out[i]->is_present); - printf("AFTER set, out[%d]->value has value %d\n", i, out[i]->value); - } - =} + reaction(t) -> out {= + for(int i = 0; i < out_width; i++) { + printf("Before lf_set, out[%d]->is_present has value %d\n", i, out[i]->is_present); + lf_set(out[i], self->s++); + printf("AFTER set, out[%d]->is_present has value %d\n", i, out[i]->is_present); + printf("AFTER set, out[%d]->value has value %d\n", i, out[i]->value); + } + =} } reactor Destination(width: int = 1) { - state s: int = 6 - input[width] in: int // Width is one larger than that of the source. + state s: int = 6 + input[width] in: int // Width is one larger than that of the source. - reaction(in) {= - int sum = 0; - for (int i = 0; i < in_width; i++) { - if (in[i]->is_present) sum += in[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 16; - =} + reaction(in) {= + int sum = 0; + for (int i = 0; i < in_width; i++) { + if (in[i]->is_present) sum += in[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; + =} - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor(width: int = 4) { - a = new Source(width = width) - b = new Destination(width = width) - a.out -> b.in + a = new Source(width = width) + b = new Destination(width = width) + a.out -> b.in } diff --git a/test/C/src/multiport/MultiportToPort.lf b/test/C/src/multiport/MultiportToPort.lf index 1784f2503c..60523029cf 100644 --- a/test/C/src/multiport/MultiportToPort.lf +++ b/test/C/src/multiport/MultiportToPort.lf @@ -1,46 +1,45 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output[2] out: int + output[2] out: int - reaction(startup) -> out {= - for(int i = 0; i < out_width; i++) { - printf("Source sending %d.\n", i); - lf_set(out[i], i); - } - =} + reaction(startup) -> out {= + for(int i = 0; i < out_width; i++) { + printf("Source sending %d.\n", i); + lf_set(out[i], i); + } + =} } reactor Destination(expected: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - printf("Received: %d.\n", in->value); - self->received = true; - if (in->value != self->expected) { - printf("ERROR: Expected %d.\n", self->expected); - exit(1); - } - =} + reaction(in) {= + printf("Received: %d.\n", in->value); + self->received = true; + if (in->value != self->expected) { + printf("ERROR: Expected %d.\n", self->expected); + exit(1); + } + =} - reaction(shutdown) {= - if (!self->received) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (!self->received) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } main reactor MultiportToPort { - a = new Source() - b1 = new Destination() - b2 = new Destination(expected = 1) - a.out -> b1.in, b2.in + a = new Source() + b1 = new Destination() + b2 = new Destination(expected = 1) + a.out -> b1.in, b2.in } diff --git a/test/C/src/multiport/MultiportToReaction.lf b/test/C/src/multiport/MultiportToReaction.lf index 9281633079..77eba059f3 100644 --- a/test/C/src/multiport/MultiportToReaction.lf +++ b/test/C/src/multiport/MultiportToReaction.lf @@ -1,44 +1,44 @@ // Check reaction to multiport output of a contained reactor. target C { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: int = 1) { - timer t(0, 200 msec) - state s: int = 0 - output[width] out: int + timer t(0, 200 msec) + state s: int = 0 + output[width] out: int - reaction(t) -> out {= - printf("Sending.\n"); - for(int i = 0; i < out_width; i++) { - lf_set(out[i], self->s++); - } - =} + reaction(t) -> out {= + printf("Sending.\n"); + for(int i = 0; i < out_width; i++) { + lf_set(out[i], self->s++); + } + =} } main reactor MultiportToReaction { - state s: int = 6 - b = new Source(width = 4) + state s: int = 6 + b = new Source(width = 4) - reaction(b.out) {= - int sum = 0; - for (int i = 0; i < b.out_width; i++) { - if (b.out[i]->is_present) sum += b.out[i]->value; - } - printf("Sum of received: %d.\n", sum); - if (sum != self->s) { - printf("ERROR: Expected %d.\n", self->s); - exit(1); - } - self->s += 16; - =} + reaction(b.out) {= + int sum = 0; + for (int i = 0; i < b.out_width; i++) { + if (b.out[i]->is_present) sum += b.out[i]->value; + } + printf("Sum of received: %d.\n", sum); + if (sum != self->s) { + printf("ERROR: Expected %d.\n", self->s); + exit(1); + } + self->s += 16; + =} - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } diff --git a/test/C/src/multiport/NestedBanks.lf b/test/C/src/multiport/NestedBanks.lf index bef08727f3..5c2953c2a4 100644 --- a/test/C/src/multiport/NestedBanks.lf +++ b/test/C/src/multiport/NestedBanks.lf @@ -5,78 +5,78 @@ target C main reactor { - a = new[2] A() - c = new[3] C() - d = new D() - e = new E() + a = new[2] A() + c = new[3] C() + d = new D() + e = new E() - (a.x)+ -> c.z, d.u, e.t + (a.x)+ -> c.z, d.u, e.t } reactor A(bank_index: int = 0) { - output[4] x: int - b = new[2] B(a_bank_index = bank_index) - b.y -> x + output[4] x: int + b = new[2] B(a_bank_index = bank_index) + b.y -> x } reactor B(a_bank_index: int = 0, bank_index: int = 0) { - output[2] y: int + output[2] y: int - reaction(startup) -> y {= - int base = self->a_bank_index * 4 + self->bank_index * 2; - lf_set(y[0], base); - lf_set(y[1], base + 1); - =} + reaction(startup) -> y {= + int base = self->a_bank_index * 4 + self->bank_index * 2; + lf_set(y[0], base); + lf_set(y[1], base + 1); + =} } reactor C(bank_index: int = 0) { - input[2] z: int - f = new F(c_bank_index = bank_index) - g = new G(c_bank_index = bank_index) - z -> f.w, g.s + input[2] z: int + f = new F(c_bank_index = bank_index) + g = new G(c_bank_index = bank_index) + z -> f.w, g.s } reactor D { - input[2] u: int + input[2] u: int - reaction(u) {= - for (int i = 0; i < u_width; i++) { - lf_print("d.u[%d] received %d.", i, u[i]->value); - if (u[i]->value != 6 + i) { - lf_print_error_and_exit("Expected %d but received %d.", 6 + i, u[i]->value); - } + reaction(u) {= + for (int i = 0; i < u_width; i++) { + lf_print("d.u[%d] received %d.", i, u[i]->value); + if (u[i]->value != 6 + i) { + lf_print_error_and_exit("Expected %d but received %d.", 6 + i, u[i]->value); } - =} + } + =} } reactor E { - input[8] t: int + input[8] t: int - reaction(t) {= - for (int i = 0; i < t_width; i++) { - lf_print("e.t[%d] received %d.", i, t[i]->value); - } - =} + reaction(t) {= + for (int i = 0; i < t_width; i++) { + lf_print("e.t[%d] received %d.", i, t[i]->value); + } + =} } reactor F(c_bank_index: int = 0) { - input w: int + input w: int - reaction(w) {= - lf_print("c[%d].f.w received %d.", self->c_bank_index, w->value); - if (w->value != self->c_bank_index * 2) { - lf_print_error_and_exit("Expected %d but received %d.", self->c_bank_index * 2, w->value); - } - =} + reaction(w) {= + lf_print("c[%d].f.w received %d.", self->c_bank_index, w->value); + if (w->value != self->c_bank_index * 2) { + lf_print_error_and_exit("Expected %d but received %d.", self->c_bank_index * 2, w->value); + } + =} } reactor G(c_bank_index: int = 0) { - input s: int + input s: int - reaction(s) {= - lf_print("c[%d].g.s received %d.", self->c_bank_index, s->value); - if (s->value != self->c_bank_index * 2 + 1) { - lf_print_error_and_exit("Expected %d but received %d.", self->c_bank_index * 2 + 1, s->value); - } - =} + reaction(s) {= + lf_print("c[%d].g.s received %d.", self->c_bank_index, s->value); + if (s->value != self->c_bank_index * 2 + 1) { + lf_print_error_and_exit("Expected %d but received %d.", self->c_bank_index * 2 + 1, s->value); + } + =} } diff --git a/test/C/src/multiport/NestedInterleavedBanks.lf b/test/C/src/multiport/NestedInterleavedBanks.lf index 8e3056bd88..2d8f10e518 100644 --- a/test/C/src/multiport/NestedInterleavedBanks.lf +++ b/test/C/src/multiport/NestedInterleavedBanks.lf @@ -5,38 +5,38 @@ target C reactor A(bank_index: int = 0, outer_bank_index: int = 0) { - output[2] p: int + output[2] p: int - reaction(startup) -> p {= - for (int i = 0; i < p_width; i++) { - lf_set(p[i], self->outer_bank_index * 4 + self->bank_index * 2 + i + 1); - lf_print("A sending %d.", p[i]->value); - } - =} + reaction(startup) -> p {= + for (int i = 0; i < p_width; i++) { + lf_set(p[i], self->outer_bank_index * 4 + self->bank_index * 2 + i + 1); + lf_print("A sending %d.", p[i]->value); + } + =} } reactor B(bank_index: int = 0) { - output[4] q: int - a = new[2] A(outer_bank_index = bank_index) - interleaved (a.p) -> q + output[4] q: int + a = new[2] A(outer_bank_index = bank_index) + interleaved (a.p) -> q } reactor C { - input[8] i: int + input[8] i: int - reaction(i) {= - int expected[] = {1, 3, 2, 4, 5, 7, 6, 8}; - for(int j = 0; j < i_width; j++) { - lf_print("C received %d.", i[j]->value); - if (i[j]->value != expected[j]) { - lf_print_error_and_exit("Expected %d.", expected[j]); - } + reaction(i) {= + int expected[] = {1, 3, 2, 4, 5, 7, 6, 8}; + for(int j = 0; j < i_width; j++) { + lf_print("C received %d.", i[j]->value); + if (i[j]->value != expected[j]) { + lf_print_error_and_exit("Expected %d.", expected[j]); } - =} + } + =} } main reactor { - b = new[2] B() - c = new C() - b.q -> c.i + b = new[2] B() + c = new C() + b.q -> c.i } diff --git a/test/C/src/multiport/ReactionToContainedBank.lf b/test/C/src/multiport/ReactionToContainedBank.lf index 30f3f5564c..e448913d79 100644 --- a/test/C/src/multiport/ReactionToContainedBank.lf +++ b/test/C/src/multiport/ReactionToContainedBank.lf @@ -1,21 +1,21 @@ // Test reaction sending messages to a contained bank of reactors. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } import TestCount from "../lib/TestCount.lf" main reactor ReactionToContainedBank(width: int = 2) { - timer t(0, 100 msec) - state count: int = 1 + timer t(0, 100 msec) + state count: int = 1 - test = new[width] TestCount(num_inputs = 11) + test = new[width] TestCount(num_inputs = 11) - reaction(t) -> test.in {= - for (int i = 0; i < self->width; i++) { - lf_set(test[i].in, self->count); - } - self->count++; - =} + reaction(t) -> test.in {= + for (int i = 0; i < self->width; i++) { + lf_set(test[i].in, self->count); + } + self->count++; + =} } diff --git a/test/C/src/multiport/ReactionToContainedBank2.lf b/test/C/src/multiport/ReactionToContainedBank2.lf index e03e884558..a36e575b21 100644 --- a/test/C/src/multiport/ReactionToContainedBank2.lf +++ b/test/C/src/multiport/ReactionToContainedBank2.lf @@ -1,26 +1,26 @@ // Test reaction sending messages to a contained bank of reactors. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } import TestCount from "../lib/TestCount.lf" reactor ReactionToContainedBank(width: int = 2) { - timer t(0, 100 msec) - state count: int = 1 + timer t(0, 100 msec) + state count: int = 1 - test = new[width] TestCount(num_inputs = 11) + test = new[width] TestCount(num_inputs = 11) - reaction(t) -> test.in {= - for (int i = 0; i < self->width; i++) { - lf_set(test[i].in, self->count); - } - self->count++; - =} + reaction(t) -> test.in {= + for (int i = 0; i < self->width; i++) { + lf_set(test[i].in, self->count); + } + self->count++; + =} } main reactor(width: int = 2) { - a = new ReactionToContainedBank(width = width) - b = new ReactionToContainedBank(width = 4) + a = new ReactionToContainedBank(width = width) + b = new ReactionToContainedBank(width = 4) } diff --git a/test/C/src/multiport/ReactionToContainedBankMultiport.lf b/test/C/src/multiport/ReactionToContainedBankMultiport.lf index d84b21c191..e778f125c9 100644 --- a/test/C/src/multiport/ReactionToContainedBankMultiport.lf +++ b/test/C/src/multiport/ReactionToContainedBankMultiport.lf @@ -1,24 +1,23 @@ -// Test reaction sending messages to a contained bank of reactors with a -// multiport input. +// Test reaction sending messages to a contained bank of reactors with a multiport input. target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } import TestCountMultiport from "../lib/TestCountMultiport.lf" main reactor(width: int = 2) { - timer t(0, 100 msec) - state count: int = 1 + timer t(0, 100 msec) + state count: int = 1 - test = new[width] TestCountMultiport(num_inputs = 11, width = width) + test = new[width] TestCountMultiport(num_inputs = 11, width = width) - reaction(t) -> test.in {= - for (int i = 0; i < self->width; i++) { - for (int j = 0; j < self->width; j++) { - lf_set(test[j].in[i], self->count); - } - self->count++; + reaction(t) -> test.in {= + for (int i = 0; i < self->width; i++) { + for (int j = 0; j < self->width; j++) { + lf_set(test[j].in[i], self->count); } - =} + self->count++; + } + =} } diff --git a/test/C/src/multiport/ReactionsToNested.lf b/test/C/src/multiport/ReactionsToNested.lf index 4270f55c2d..71a76444b6 100644 --- a/test/C/src/multiport/ReactionsToNested.lf +++ b/test/C/src/multiport/ReactionsToNested.lf @@ -1,39 +1,38 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target C { - timeout: 1 sec + timeout: 1 sec } reactor T(expected: int = 0) { - input z: int - state received: bool = false + input z: int + state received: bool = false - reaction(z) {= - lf_print("T received %d", z->value); - self->received = true; - if (z->value != self->expected) { - lf_print_error_and_exit("Expected %d", self->expected); - } - =} + reaction(z) {= + lf_print("T received %d", z->value); + self->received = true; + if (z->value != self->expected) { + lf_print_error_and_exit("Expected %d", self->expected); + } + =} - reaction(shutdown) {= - if (!self->received) { - lf_print_error_and_exit("No input received"); - } - =} + reaction(shutdown) {= + if (!self->received) { + lf_print_error_and_exit("No input received"); + } + =} } reactor D { - input[2] y: int - t1 = new T(expected = 42) - t2 = new T(expected = 43) - y -> t1.z, t2.z + input[2] y: int + t1 = new T(expected = 42) + t2 = new T(expected = 43) + y -> t1.z, t2.z } main reactor { - d = new D() + d = new D() - reaction(startup) -> d.y {= lf_set(d.y[0], 42); =} + reaction(startup) -> d.y {= lf_set(d.y[0], 42); =} - reaction(startup) -> d.y {= lf_set(d.y[1], 43); =} + reaction(startup) -> d.y {= lf_set(d.y[1], 43); =} } diff --git a/test/C/src/multiport/Sparse.lf b/test/C/src/multiport/Sparse.lf index 537daabb4b..3ebda275b1 100644 --- a/test/C/src/multiport/Sparse.lf +++ b/test/C/src/multiport/Sparse.lf @@ -1,50 +1,50 @@ /** Test reading of sparse inputs on a multiport. */ target C { - timeout: 20 ms + timeout: 20 ms } reactor SparseSource(width: int = 20) { - output[width] out: int - state count: int = 0 - timer t(0, 1 msec) + output[width] out: int + state count: int = 0 + timer t(0, 1 msec) - reaction(t) -> out {= - int next_count = self->count + 1; - if (next_count >= self->width) { - next_count = 0; - } - lf_set(out[next_count], next_count); - lf_set(out[self->count], self->count); - self->count = next_count; - =} + reaction(t) -> out {= + int next_count = self->count + 1; + if (next_count >= self->width) { + next_count = 0; + } + lf_set(out[next_count], next_count); + lf_set(out[self->count], self->count); + self->count = next_count; + =} } reactor SparseSink(width: int = 20) { - input[width] in: int + input[width] in: int - reaction(in) {= - struct lf_multiport_iterator_t i = lf_multiport_iterator(in); - lf_print("--------"); - // Ensure inputs are seen in order. - int previous = -1; - int channel = lf_multiport_next(&i); - while(channel >= 0) { - lf_print("Received %d on channel %d", in[channel]->value, channel); - // The value of the input should equal the channel number. - if (in[channel]->value != channel) { - lf_print_error_and_exit("Expected %d", channel); - } - if (channel <= previous) { - lf_print_error_and_exit("Input channels not read in order."); - } - previous = channel; - channel = lf_multiport_next(&i); + reaction(in) {= + struct lf_multiport_iterator_t i = lf_multiport_iterator(in); + lf_print("--------"); + // Ensure inputs are seen in order. + int previous = -1; + int channel = lf_multiport_next(&i); + while(channel >= 0) { + lf_print("Received %d on channel %d", in[channel]->value, channel); + // The value of the input should equal the channel number. + if (in[channel]->value != channel) { + lf_print_error_and_exit("Expected %d", channel); + } + if (channel <= previous) { + lf_print_error_and_exit("Input channels not read in order."); } - =} + previous = channel; + channel = lf_multiport_next(&i); + } + =} } main reactor(width: int = 20) { - s = new SparseSource(width = width) - d = new SparseSink(width = width) - s.out -> d.in + s = new SparseSource(width = width) + d = new SparseSink(width = width) + s.out -> d.in } diff --git a/test/C/src/multiport/SparseFallback.lf b/test/C/src/multiport/SparseFallback.lf index a7788858d8..a5a0bf4284 100644 --- a/test/C/src/multiport/SparseFallback.lf +++ b/test/C/src/multiport/SparseFallback.lf @@ -1,53 +1,53 @@ /** - * Test reading of sparse inputs on a multiport where the density of writes to - * the multiport is high enough to force the fallback policy to kick in. + * Test reading of sparse inputs on a multiport where the density of writes to the multiport is high + * enough to force the fallback policy to kick in. */ target C { - timeout: 20 ms + timeout: 20 ms } reactor SparseSource(width: int = 20) { - output[width] out: int - state count: int = 0 - timer t(0, 1 msec) + output[width] out: int + state count: int = 0 + timer t(0, 1 msec) - reaction(t) -> out {= - int next_count = self->count + 1; - if (next_count >= self->width) { - next_count = 0; - } - lf_set(out[self->count], self->count); - lf_set(out[next_count], next_count); - self->count = next_count; - =} + reaction(t) -> out {= + int next_count = self->count + 1; + if (next_count >= self->width) { + next_count = 0; + } + lf_set(out[self->count], self->count); + lf_set(out[next_count], next_count); + self->count = next_count; + =} } reactor SparseSink(width: int = 20) { - input[width] in: int + input[width] in: int - reaction(in) {= - struct lf_multiport_iterator_t i = lf_multiport_iterator(in); - lf_print("--------"); - // Ensure inputs are seen in order. - int previous = -1; - int channel = lf_multiport_next(&i); - while(channel >= 0) { - lf_print("Received %d on channel %d", in[channel]->value, channel); - // The value of the input should equal the channel number. - if (in[channel]->value != channel) { - lf_print_error_and_exit("Expected %d", channel); - } - if (channel <= previous) { - lf_print_error_and_exit("Input channels not read in order."); - } - previous = channel; - channel = lf_multiport_next(&i); + reaction(in) {= + struct lf_multiport_iterator_t i = lf_multiport_iterator(in); + lf_print("--------"); + // Ensure inputs are seen in order. + int previous = -1; + int channel = lf_multiport_next(&i); + while(channel >= 0) { + lf_print("Received %d on channel %d", in[channel]->value, channel); + // The value of the input should equal the channel number. + if (in[channel]->value != channel) { + lf_print_error_and_exit("Expected %d", channel); + } + if (channel <= previous) { + lf_print_error_and_exit("Input channels not read in order."); } - =} + previous = channel; + channel = lf_multiport_next(&i); + } + =} } main reactor(width: int = 10) { - s = new SparseSource(width = width) - d = new SparseSink(width = width) - s.out -> d.in + s = new SparseSource(width = width) + d = new SparseSink(width = width) + s.out -> d.in } diff --git a/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf b/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf index 917982af39..9acf39c95c 100644 --- a/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf +++ b/test/C/src/multiport/TriggerDownstreamOnlyIfPresent.lf @@ -1,49 +1,46 @@ -/** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. - */ +/** This test checks that a downstream reaction is triggered only if its trigger is present. */ target C { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Source { - output a: int - output b: int - state count: int = 0 - timer t(0, 200 msec) + output a: int + output b: int + state count: int = 0 + timer t(0, 200 msec) - reaction(t) -> a, b {= - if (self->count++ % 2 == 0) { - lf_set(a, self->count); - } else { - lf_set(b, self->count); - } - =} + reaction(t) -> a, b {= + if (self->count++ % 2 == 0) { + lf_set(a, self->count); + } else { + lf_set(b, self->count); + } + =} } reactor Destination { - input a: int - input b: int + input a: int + input b: int - reaction(a) {= - if (!a->is_present) { - fprintf(stderr, "Reaction to a triggered even though all inputs are absent!\n"); - exit(1); - } - =} + reaction(a) {= + if (!a->is_present) { + fprintf(stderr, "Reaction to a triggered even though all inputs are absent!\n"); + exit(1); + } + =} - reaction(b) {= - if (!b->is_present) { - fprintf(stderr, "Reaction to b triggered even though all inputs are absent!\n"); - exit(2); - } - =} + reaction(b) {= + if (!b->is_present) { + fprintf(stderr, "Reaction to b triggered even though all inputs are absent!\n"); + exit(2); + } + =} } main reactor TriggerDownstreamOnlyIfPresent { - s = new[2] Source() - d = new[2] Destination() - s.a -> d.a - s.b -> d.b + s = new[2] Source() + d = new[2] Destination() + s.a -> d.a + s.b -> d.b } diff --git a/test/C/src/no_inlining/BankMultiportToReactionNoInlining.lf b/test/C/src/no_inlining/BankMultiportToReactionNoInlining.lf index e69e0af0b4..4ed83a1700 100644 --- a/test/C/src/no_inlining/BankMultiportToReactionNoInlining.lf +++ b/test/C/src/no_inlining/BankMultiportToReactionNoInlining.lf @@ -1,30 +1,30 @@ target C { - timeout: 5 sec, - fast: true, - cmake-include: ["../../c/bank_multiport_to_reaction_no_inlining.cmake"], - files: ["../../c"] + timeout: 5 sec, + fast: true, + cmake-include: ["../../c/bank_multiport_to_reaction_no_inlining.cmake"], + files: ["../../c"] } import Count from "../lib/Count.lf" reactor DoubleCount { - output[2] out: int - c1 = new Count() - c2 = new Count() - c1.out, c2.out -> out + output[2] out: int + c1 = new Count() + c2 = new Count() + c1.out, c2.out -> out } main reactor { - state count: int = 1 - state received: bool = false + state count: int = 1 + state received: bool = false - s = new[2] DoubleCount() + s = new[2] DoubleCount() - reaction(s.out) named check + reaction(s.out) named check - reaction(shutdown) {= - if (!self->received) { - lf_print_error_and_exit("No inputs present."); - } - =} + reaction(shutdown) {= + if (!self->received) { + lf_print_error_and_exit("No inputs present."); + } + =} } diff --git a/test/C/src/no_inlining/BankToReactionNoInlining.lf b/test/C/src/no_inlining/BankToReactionNoInlining.lf index 4956bf68cd..d7277d31a2 100644 --- a/test/C/src/no_inlining/BankToReactionNoInlining.lf +++ b/test/C/src/no_inlining/BankToReactionNoInlining.lf @@ -1,16 +1,16 @@ target C { - timeout: 5 sec, - fast: true, - cmake-include: ["../../c/bank_to_reaction_no_inlining.cmake"], - files: ["../../c"] + timeout: 5 sec, + fast: true, + cmake-include: ["../../c/bank_to_reaction_no_inlining.cmake"], + files: ["../../c"] } import Count from "../lib/Count.lf" main reactor { - state count: int = 1 + state count: int = 1 - s = new[2] Count() + s = new[2] Count() - reaction(s.out) named check + reaction(s.out) named check } diff --git a/test/C/src/no_inlining/Count.lf b/test/C/src/no_inlining/Count.lf index f8fd51bec7..b57615db92 100644 --- a/test/C/src/no_inlining/Count.lf +++ b/test/C/src/no_inlining/Count.lf @@ -1,16 +1,16 @@ target C { - cmake-include: ["../../c/count.cmake"], - files: ["../../c"] + cmake-include: ["../../c/count.cmake"], + files: ["../../c"] } main reactor Count { - timer t(0, 1 msec) + timer t(0, 1 msec) - state count: int + state count: int - reaction(t) named increment + reaction(t) named increment - reaction(t) named check_done + reaction(t) named check_done - reaction(shutdown) {= printf("%s", "shutting down\n"); =} + reaction(shutdown) {= printf("%s", "shutting down\n"); =} } diff --git a/test/C/src/no_inlining/CountHierarchy.lf b/test/C/src/no_inlining/CountHierarchy.lf index 771222af2f..706ca75c35 100644 --- a/test/C/src/no_inlining/CountHierarchy.lf +++ b/test/C/src/no_inlining/CountHierarchy.lf @@ -1,23 +1,23 @@ target C { - cmake-include: ["../../c/count_hierarchy.cmake"], - files: ["../../c"] + cmake-include: ["../../c/count_hierarchy.cmake"], + files: ["../../c"] } reactor Timer(m: time = 0, n: time = 0) { - output out: int - timer t(m, n) + output out: int + timer t(m, n) - reaction(t) -> out {= lf_set(out, 0); =} + reaction(t) -> out {= lf_set(out, 0); =} } main reactor { - t = new Timer(m = 0, n = 1 msec) + t = new Timer(m = 0, n = 1 msec) - state count: int + state count: int - reaction(t.out) named increment + reaction(t.out) named increment - reaction(t.out) named check_done + reaction(t.out) named check_done - reaction(shutdown) {= printf("%s", "shutting down\n"); =} + reaction(shutdown) {= printf("%s", "shutting down\n"); =} } diff --git a/test/C/src/no_inlining/IntPrint.lf b/test/C/src/no_inlining/IntPrint.lf index fa6ab8c757..fd7639d45d 100644 --- a/test/C/src/no_inlining/IntPrint.lf +++ b/test/C/src/no_inlining/IntPrint.lf @@ -1,22 +1,22 @@ target C { - cmake-include: ["../../c/sendreceive.cmake"], - files: ["../../c"] + cmake-include: ["../../c/sendreceive.cmake"], + files: ["../../c"] } reactor Print { - output out: int + output out: int - reaction(startup) -> out named send + reaction(startup) -> out named send } reactor Check(expected: int = 42) { // expected parameter is for testing. - input in: int + input in: int - reaction(in) named receive + reaction(in) named receive } main reactor { - s = new Print() - p = new Check() - s.out -> p.in + s = new Print() + p = new Check() + s.out -> p.in } diff --git a/test/C/src/no_inlining/MultiportToReactionNoInlining.lf b/test/C/src/no_inlining/MultiportToReactionNoInlining.lf index 3c5f18d62a..98811fd9db 100644 --- a/test/C/src/no_inlining/MultiportToReactionNoInlining.lf +++ b/test/C/src/no_inlining/MultiportToReactionNoInlining.lf @@ -1,35 +1,35 @@ // Check reaction to multiport output of a contained reactor. target C { - timeout: 2 sec, - fast: true, - cmake-include: ["../../c/multiport_to_reaction_no_inlining.cmake"], - files: ["../../c"] + timeout: 2 sec, + fast: true, + cmake-include: ["../../c/multiport_to_reaction_no_inlining.cmake"], + files: ["../../c"] } reactor Source(width: int = 1) { - timer t(0, 200 msec) - state s: int = 0 - output[width] out: int + timer t(0, 200 msec) + state s: int = 0 + output[width] out: int - reaction(t) -> out {= - printf("Sending.\n"); - for(int i = 0; i < out_width; i++) { - lf_set(out[i], self->s++); - } - =} + reaction(t) -> out {= + printf("Sending.\n"); + for(int i = 0; i < out_width; i++) { + lf_set(out[i], self->s++); + } + =} } main reactor { - state s: int = 6 - b = new Source(width = 4) + state s: int = 6 + b = new Source(width = 4) - reaction(b.out) named check + reaction(b.out) named check - reaction(shutdown) {= - if (self->s <= 6) { - fprintf(stderr, "ERROR: Destination received no input!\n"); - exit(1); - } - printf("Success.\n"); - =} + reaction(shutdown) {= + if (self->s <= 6) { + fprintf(stderr, "ERROR: Destination received no input!\n"); + exit(1); + } + printf("Success.\n"); + =} } diff --git a/test/C/src/serialization/ROSBuiltInSerialization.lf b/test/C/src/serialization/ROSBuiltInSerialization.lf index 095aadacd2..6054a50fa2 100644 --- a/test/C/src/serialization/ROSBuiltInSerialization.lf +++ b/test/C/src/serialization/ROSBuiltInSerialization.lf @@ -1,13 +1,12 @@ /** - * This test showcases the infrastructure that is built into the CCpp target - * that can automatically serialize and deserialize ROS2 messages in federated - * programs. + * This test showcases the infrastructure that is built into the CCpp target that can automatically + * serialize and deserialize ROS2 messages in federated programs. * - * This test contains a sender-receiver federated program in which the 'sender' - * federate sends a std_msgs::msg::Int32 message to the 'receiver' federate. + * This test contains a sender-receiver federated program in which the 'sender' federate sends a + * std_msgs::msg::Int32 message to the 'receiver' federate. * - * To run this test, make sure that your terminal is properly sourced for ROS2. - * See https://docs.ros.org/en/foxy/Tutorials/Configuring-ROS2-Environment.html. + * To run this test, make sure that your terminal is properly sourced for ROS2. See + * https://docs.ros.org/en/foxy/Tutorials/Configuring-ROS2-Environment.html. * * Then you can use lfc to compile this program: * @@ -20,49 +19,48 @@ * @author Soroush Bateni */ target CCpp { - cmake-include: "include/CMakeListsExtension.txt", - timeout: 2 sec + cmake-include: "include/CMakeListsExtension.txt", + timeout: 2 sec } preamble {= - #include "std_msgs/msg/int32.hpp" + #include "std_msgs/msg/int32.hpp" =} reactor Sender { - output out: std_msgs::msg::Int32 + output out: std_msgs::msg::Int32 - // state serialized_msg_pcl:rclcpp::SerializedMessage({=0u=}); - state count: int = 0 + state count: int = 0 // state serialized_msg_pcl:rclcpp::SerializedMessage({=0u=}); - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) -> out {= - std_msgs::msg::Int32 ros_message; - ros_message.data = self->count++; - lf_set(out, ros_message); - =} + reaction(t) -> out {= + std_msgs::msg::Int32 ros_message; + ros_message.data = self->count++; + lf_set(out, ros_message); + =} } reactor Receiver { - input in: std_msgs::msg::Int32 - state count: int = 0 + input in: std_msgs::msg::Int32 + state count: int = 0 - reaction(in) {= - // Print the ROS2 message data - lf_print( - "Serialized integer after deserialization: %d", - in->value.data - ); - if (in->value.data != self->count) { - lf_print_error_and_exit("Expected %d.", self->count); - } - self->count++; - =} + reaction(in) {= + // Print the ROS2 message data + lf_print( + "Serialized integer after deserialization: %d", + in->value.data + ); + if (in->value.data != self->count) { + lf_print_error_and_exit("Expected %d.", self->count); + } + self->count++; + =} } federated reactor { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in after 100 msec serializer "ros2" + sender.out -> receiver.in after 100 msec serializer "ros2" } diff --git a/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf b/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf index 97b5a12554..e407f18bb9 100644 --- a/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf +++ b/test/C/src/serialization/ROSBuiltInSerializationSharedPtr.lf @@ -1,13 +1,12 @@ /** - * This test showcases the infrastructure that is built into the CCpp target - * that can automatically serialize and deserialize ROS2 messages (with a - * shared_ptr type) in federated programs. + * This test showcases the infrastructure that is built into the CCpp target that can automatically + * serialize and deserialize ROS2 messages (with a shared_ptr type) in federated programs. * - * This test contains a sender-receiver federated program in which the 'sender' - * federate sends a std_msgs::msg::Int32 message to the 'receiver' federate. + * This test contains a sender-receiver federated program in which the 'sender' federate sends a + * std_msgs::msg::Int32 message to the 'receiver' federate. * - * To run this test, make sure that your terminal is properly sourced for ROS2. - * See https://docs.ros.org/en/foxy/Tutorials/Configuring-ROS2-Environment.html. + * To run this test, make sure that your terminal is properly sourced for ROS2. See + * https://docs.ros.org/en/foxy/Tutorials/Configuring-ROS2-Environment.html. * * Then you can use lfc to compile this program: * @@ -20,48 +19,48 @@ * @author Soroush Bateni */ target CCpp { - cmake-include: "include/CMakeListsExtension.txt", - timeout: 2 sec + cmake-include: "include/CMakeListsExtension.txt", + timeout: 2 sec } preamble {= - #include "std_msgs/msg/int32.hpp" + #include "std_msgs/msg/int32.hpp" =} reactor Sender { - output out: std::shared_ptr + output out: std::shared_ptr - state count: int = 0 + state count: int = 0 - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) -> out {= - auto ros_message = std::make_shared(); - ros_message->data = self->count++; - lf_set(out, ros_message); - =} + reaction(t) -> out {= + auto ros_message = std::make_shared(); + ros_message->data = self->count++; + lf_set(out, ros_message); + =} } reactor Receiver { - input in: std::shared_ptr - state count: int = 0 + input in: std::shared_ptr + state count: int = 0 - reaction(in) {= - // Print the ROS2 message data - lf_print( - "Serialized integer after deserialization: %d", - in->value->data - ); - if (in->value->data != self->count) { - lf_print_error_and_exit("Expected %d.", self->count); - } - self->count++; - =} + reaction(in) {= + // Print the ROS2 message data + lf_print( + "Serialized integer after deserialization: %d", + in->value->data + ); + if (in->value->data != self->count) { + lf_print_error_and_exit("Expected %d.", self->count); + } + self->count++; + =} } federated reactor { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in serializer "ros2" + sender.out -> receiver.in serializer "ros2" } diff --git a/test/C/src/target/FederatedFiles.lf b/test/C/src/target/FederatedFiles.lf index ebc1ff210e..9fb4440a02 100644 --- a/test/C/src/target/FederatedFiles.lf +++ b/test/C/src/target/FederatedFiles.lf @@ -1,14 +1,14 @@ -// This test references a header file in reactor-c, which has to be obtained -// from the class path. This test is successful if it compiles. +// This test references a header file in reactor-c, which has to be obtained from the class path. +// This test is successful if it compiles. target C { - files: "/lib/c/reactor-c/util/sensor_simulator.h", - timeout: 1 s + files: "/lib/c/reactor-c/util/sensor_simulator.h", + timeout: 1 s } reactor Foo { - reaction(startup) {= lf_print("Hello World"); =} + reaction(startup) {= lf_print("Hello World"); =} } federated reactor { - f = new Foo() + f = new Foo() } diff --git a/test/C/src/target/HelloWorldCCPP.lf b/test/C/src/target/HelloWorldCCPP.lf index 91d1cd61d1..1b3a9b023f 100644 --- a/test/C/src/target/HelloWorldCCPP.lf +++ b/test/C/src/target/HelloWorldCCPP.lf @@ -1,32 +1,32 @@ /** - * A variant of HelloWorld.lf that tests the CCpp target in conjunction with the - * CMake build system. This test should not pass if it does not compile. + * A variant of HelloWorld.lf that tests the CCpp target in conjunction with the CMake build system. + * This test should not pass if it does not compile. */ target CCpp { - tracing: true, - logging: DEBUG + tracing: true, + logging: DEBUG } reactor HelloWorld { - preamble {= - #include - =} - state success: bool = false + preamble {= + #include + =} + state success: bool = false - reaction(startup) {= - std::cout << "Hello World." << std::endl; - self->success = true; - =} + reaction(startup) {= + std::cout << "Hello World." << std::endl; + self->success = true; + =} - reaction(shutdown) {= - printf("Shutdown invoked.\n"); - if (!self->success) { - fprintf(stderr, "ERROR: startup reaction not executed.\n"); - exit(1); - } - =} + reaction(shutdown) {= + printf("Shutdown invoked.\n"); + if (!self->success) { + fprintf(stderr, "ERROR: startup reaction not executed.\n"); + exit(1); + } + =} } main reactor { - a = new HelloWorld() + a = new HelloWorld() } diff --git a/test/C/src/token/TokenContainedPrint.lf b/test/C/src/token/TokenContainedPrint.lf index 29e6005c4c..586e7283a2 100644 --- a/test/C/src/token/TokenContainedPrint.lf +++ b/test/C/src/token/TokenContainedPrint.lf @@ -3,27 +3,27 @@ * @author Edward A. Lee (eal@berkeley.edu) */ target C { - timeout: 2 ms + timeout: 2 ms } import TokenPrint from "lib/Token.lf" main reactor { - state count: int = 0 - timer t(0, 1 ms) + state count: int = 0 + timer t(0, 1 ms) - p = new TokenPrint() + p = new TokenPrint() - reaction(startup) -> p.in {= - lf_set_destructor(p.in, int_array_destructor); - lf_set_copy_constructor(p.in, int_array_copy_constructor); - =} + reaction(startup) -> p.in {= + lf_set_destructor(p.in, int_array_destructor); + lf_set_copy_constructor(p.in, int_array_copy_constructor); + =} - reaction(t) -> p.in {= - int_array_t* array = int_array_constructor(3); - for (size_t i = 0; i < array->length; i++) { - array->data[i] = self->count++; - } - lf_set(p.in, array); - =} + reaction(t) -> p.in {= + int_array_t* array = int_array_constructor(3); + for (size_t i = 0; i < array->length; i++) { + array->data[i] = self->count++; + } + lf_set(p.in, array); + =} } diff --git a/test/C/src/token/TokenContainedPrintBank.lf b/test/C/src/token/TokenContainedPrintBank.lf index 991a94b5a7..69ae534b20 100644 --- a/test/C/src/token/TokenContainedPrintBank.lf +++ b/test/C/src/token/TokenContainedPrintBank.lf @@ -1,36 +1,35 @@ /** - * Basic test of token type passed from a reaction to a bank of contained - * destinations. + * Basic test of token type passed from a reaction to a bank of contained destinations. * @author Edward A. Lee (eal@berkeley.edu) */ target C { - timeout: 2 ms + timeout: 2 ms } import TokenPrint from "lib/Token.lf" main reactor { - state count: int = 0 - timer t(0, 1 ms) - p = new[2] TokenPrint() + state count: int = 0 + timer t(0, 1 ms) + p = new[2] TokenPrint() - reaction(startup) -> p.in {= - for (int j = 0; j < p_width; j++) { - lf_set_destructor(p[j].in, int_array_destructor); - lf_set_copy_constructor(p[j].in, int_array_copy_constructor); - } - =} + reaction(startup) -> p.in {= + for (int j = 0; j < p_width; j++) { + lf_set_destructor(p[j].in, int_array_destructor); + lf_set_copy_constructor(p[j].in, int_array_copy_constructor); + } + =} - reaction(t) -> p.in {= - int_array_t* array = int_array_constructor(3); - for (size_t i = 0; i < array->length; i++) { - array->data[i] = self->count++; - } - // Sending the array to more than one destination, so we need - // to wrap it in a token. - lf_token_t* token = lf_new_token(p[0].in, array, 1); - for (int j = 0; j < p_width; j++) { - lf_set_token(p[j].in, token); - } - =} + reaction(t) -> p.in {= + int_array_t* array = int_array_constructor(3); + for (size_t i = 0; i < array->length; i++) { + array->data[i] = self->count++; + } + // Sending the array to more than one destination, so we need + // to wrap it in a token. + lf_token_t* token = lf_new_token(p[0].in, array, 1); + for (int j = 0; j < p_width; j++) { + lf_set_token(p[j].in, token); + } + =} } diff --git a/test/C/src/token/TokenContainedSource.lf b/test/C/src/token/TokenContainedSource.lf index 66095b8a0b..72fd079032 100644 --- a/test/C/src/token/TokenContainedSource.lf +++ b/test/C/src/token/TokenContainedSource.lf @@ -4,40 +4,40 @@ * @author Edward A. Lee (eal@berkeley.edu) */ target C { - timeout: 2 ms + timeout: 2 ms } import TokenSource from "lib/Token.lf" main reactor(scale: int = 1) { - state count: int = 0 - state input_received: bool = false + state count: int = 0 + state input_received: bool = false - s = new TokenSource() + s = new TokenSource() - reaction(s.out) {= - self->input_received = true; - bool failed = false; // For testing. - printf("Received: ["); - for (int i = 0; i < s.out->value->length; i++) { - if (i > 0) printf(", "); - printf("%d", s.out->value->data[i]); - // For testing, check whether values match expectation. - if (s.out->value->data[i] != self->scale * self->count) { - failed = true; - } - self->count++; + reaction(s.out) {= + self->input_received = true; + bool failed = false; // For testing. + printf("Received: ["); + for (int i = 0; i < s.out->value->length; i++) { + if (i > 0) printf(", "); + printf("%d", s.out->value->data[i]); + // For testing, check whether values match expectation. + if (s.out->value->data[i] != self->scale * self->count) { + failed = true; } - printf("]\n"); - if (failed) { - printf("ERROR: Value received does not match expectation!\n"); - exit(1); - } - =} + self->count++; + } + printf("]\n"); + if (failed) { + printf("ERROR: Value received does not match expectation!\n"); + exit(1); + } + =} - reaction(shutdown) {= - if (!self->input_received) { - lf_print_error_and_exit("TokenPrint: No result received!"); - } - =} + reaction(shutdown) {= + if (!self->input_received) { + lf_print_error_and_exit("TokenPrint: No result received!"); + } + =} } diff --git a/test/C/src/token/TokenContainedSourceBank.lf b/test/C/src/token/TokenContainedSourceBank.lf index 615695890b..0a0b4383c7 100644 --- a/test/C/src/token/TokenContainedSourceBank.lf +++ b/test/C/src/token/TokenContainedSourceBank.lf @@ -1,47 +1,46 @@ /** - * Basic test of token type passed from a bank of contained sources to a - * reaction. + * Basic test of token type passed from a bank of contained sources to a reaction. * @author Hou Seng (Steven) Wong (housengw@berkeley.edu) * @author Edward A. Lee (eal@berkeley.edu) */ target C { - timeout: 2 ms + timeout: 2 ms } import TokenSource from "lib/Token.lf" main reactor(scale: int = 1) { - state count: int = 0 - state input_received: bool = false + state count: int = 0 + state input_received: bool = false - s = new[2] TokenSource() + s = new[2] TokenSource() - reaction(s.out) {= - self->input_received = true; - bool failed = false; // For testing. - for (int j = 0; j < s_width; j++) { - printf("Received from %d: [", j); - if (j > 0) self->count -= s[j].out->value->length; - for (int i = 0; i < s[j].out->value->length; i++) { - if (i > 0) printf(", "); - printf("%d", s[j].out->value->data[i]); - // For testing, check whether values match expectation. - if (s[j].out->value->data[i] != self->scale * self->count) { - failed = true; - } - self->count++; + reaction(s.out) {= + self->input_received = true; + bool failed = false; // For testing. + for (int j = 0; j < s_width; j++) { + printf("Received from %d: [", j); + if (j > 0) self->count -= s[j].out->value->length; + for (int i = 0; i < s[j].out->value->length; i++) { + if (i > 0) printf(", "); + printf("%d", s[j].out->value->data[i]); + // For testing, check whether values match expectation. + if (s[j].out->value->data[i] != self->scale * self->count) { + failed = true; } - printf("]\n"); + self->count++; } - if (failed) { - printf("ERROR: Value received does not match expectation!\n"); - exit(1); - } - =} + printf("]\n"); + } + if (failed) { + printf("ERROR: Value received does not match expectation!\n"); + exit(1); + } + =} - reaction(shutdown) {= - if (!self->input_received) { - lf_print_error_and_exit("TokenPrint: No result received!"); - } - =} + reaction(shutdown) {= + if (!self->input_received) { + lf_print_error_and_exit("TokenPrint: No result received!"); + } + =} } diff --git a/test/C/src/token/TokenDelayTest.lf b/test/C/src/token/TokenDelayTest.lf index 5fcd03f4cf..9070ab5f87 100644 --- a/test/C/src/token/TokenDelayTest.lf +++ b/test/C/src/token/TokenDelayTest.lf @@ -3,15 +3,15 @@ * @author Edward A. Lee (eal@berkeley.edu) */ target C { - timeout: 2 ms + timeout: 2 ms } import TokenSource, TokenPrint, TokenDelay from "lib/Token.lf" main reactor { - s = new TokenSource() - d = new TokenDelay() - p = new TokenPrint() - s.out -> d.in - d.out -> p.in + s = new TokenSource() + d = new TokenDelay() + p = new TokenPrint() + s.out -> d.in + d.out -> p.in } diff --git a/test/C/src/token/TokenMutable.lf b/test/C/src/token/TokenMutable.lf index 47fad08bcd..7169f421c8 100644 --- a/test/C/src/token/TokenMutable.lf +++ b/test/C/src/token/TokenMutable.lf @@ -1,23 +1,23 @@ /** - * Test of token scaled by two scale factors with a mutable inputs. The total - * memory allocated in this test should be the greater than in - * TokenSourcePrint.lf because two destinations have mutable inputs. + * Test of token scaled by two scale factors with a mutable inputs. The total memory allocated in + * this test should be the greater than in TokenSourcePrint.lf because two destinations have mutable + * inputs. * @author Edward A. Lee (eal@berkeley.edu) */ target C { - timeout: 2 ms + timeout: 2 ms } import TokenSource, TokenPrint, TokenScale from "lib/Token.lf" main reactor { - s = new TokenSource() - g2 = new TokenScale(scale = 2) - g3 = new TokenScale(scale = 3) - p2 = new TokenPrint(scale = 2) - p3 = new TokenPrint(scale = 3) - s.out -> g2.in - s.out -> g3.in - g2.out -> p2.in - g3.out -> p3.in + s = new TokenSource() + g2 = new TokenScale(scale = 2) + g3 = new TokenScale(scale = 3) + p2 = new TokenPrint(scale = 2) + p3 = new TokenPrint(scale = 3) + s.out -> g2.in + s.out -> g3.in + g2.out -> p2.in + g3.out -> p3.in } diff --git a/test/C/src/token/TokenSourcePrint.lf b/test/C/src/token/TokenSourcePrint.lf index ef3d69bbfb..7a46f74c20 100644 --- a/test/C/src/token/TokenSourcePrint.lf +++ b/test/C/src/token/TokenSourcePrint.lf @@ -4,13 +4,13 @@ * @author Edward A. Lee (eal@berkeley.edu) */ target C { - timeout: 2 ms + timeout: 2 ms } import TokenSource, TokenPrint from "lib/Token.lf" main reactor { - s = new TokenSource() - p = new TokenPrint() - s.out -> p.in + s = new TokenSource() + p = new TokenPrint() + s.out -> p.in } diff --git a/test/C/src/token/TokenSourceScalePrint.lf b/test/C/src/token/TokenSourceScalePrint.lf index 8c601168e0..01d57936ff 100644 --- a/test/C/src/token/TokenSourceScalePrint.lf +++ b/test/C/src/token/TokenSourceScalePrint.lf @@ -1,19 +1,19 @@ /** - * Test of token scaled by a scale factor with a mutable input. The total memory - * allocated in this test should be the same as in TokenSourcePrint.lf. + * Test of token scaled by a scale factor with a mutable input. The total memory allocated in this + * test should be the same as in TokenSourcePrint.lf. * @author Hou Seng (Steven) Wong (housengw@berkeley.edu) * @author Edward A. Lee (eal@berkeley.edu) */ target C { - timeout: 2 ms + timeout: 2 ms } import TokenSource, TokenPrint, TokenScale from "lib/Token.lf" main reactor { - s = new TokenSource() - g2 = new TokenScale(scale = 2) - p2 = new TokenPrint(scale = 2) - s.out -> g2.in - g2.out -> p2.in + s = new TokenSource() + g2 = new TokenScale(scale = 2) + p2 = new TokenPrint(scale = 2) + s.out -> g2.in + g2.out -> p2.in } diff --git a/test/C/src/token/lib/Token.lf b/test/C/src/token/lib/Token.lf index 7b8d2a83ee..f5f0bc5d27 100644 --- a/test/C/src/token/lib/Token.lf +++ b/test/C/src/token/lib/Token.lf @@ -4,100 +4,98 @@ * @author Edward A. Lee (eal@berkeley.edu) */ target C { - files: ["../include/array.h"] + files: ["../include/array.h"] } preamble {= - #include "array.h" + #include "array.h" =} /** - * @brief Produce a sequence of arrays of length 3 with increasing values. - * Values are produced at intervals of 1 ms. The first arrray has value [0, 1, - * 2], the second has value [3, 4, 5], etc. The output token will have a - * destructor and copy constructor associated with it so that its memory can be - * managed automatically by the C runtime. + * @brief Produce a sequence of arrays of length 3 with increasing values. Values are produced at + * intervals of 1 ms. The first arrray has value [0, 1, 2], the second has value [3, 4, 5], etc. The + * output token will have a destructor and copy constructor associated with it so that its memory + * can be managed automatically by the C runtime. */ reactor TokenSource { - output out: int_array_t* - state count: int = 0 - timer t(0, 1 ms) + output out: int_array_t* + state count: int = 0 + timer t(0, 1 ms) - reaction(startup) -> out {= - lf_set_destructor(out, int_array_destructor); - lf_set_copy_constructor(out, int_array_copy_constructor); - =} + reaction(startup) -> out {= + lf_set_destructor(out, int_array_destructor); + lf_set_copy_constructor(out, int_array_copy_constructor); + =} - reaction(t) -> out {= - int_array_t* array = int_array_constructor(3); - for (size_t i = 0; i < array->length; i++) { - array->data[i] = self->count++; - } - lf_set(out, array); - =} + reaction(t) -> out {= + int_array_t* array = int_array_constructor(3); + for (size_t i = 0; i < array->length; i++) { + array->data[i] = self->count++; + } + lf_set(out, array); + =} } /** - * @brief Print input array values and test for expected value. The expected - * value is a scaled version of the sequence of values produced by the - * TokenSource, where the scaling factor is given by the scale parameter. + * @brief Print input array values and test for expected value. The expected value is a scaled + * version of the sequence of values produced by the TokenSource, where the scaling factor is given + * by the scale parameter. */ reactor TokenPrint(scale: int = 1) { - input in: int_array_t* - state count: int = 0 - state input_received: bool = false + input in: int_array_t* + state count: int = 0 + state input_received: bool = false - reaction(in) {= - self->input_received = true; - bool failed = false; // For testing. - printf("TokenPrint received: ["); - for (int i = 0; i < in->value->length; i++) { - if (i > 0) printf(", "); - printf("%d", in->value->data[i]); - // For testing, check whether values match expectation. - if (in->value->data[i] != self->scale * self->count) { - failed = true; - } - self->count++; - } - printf("]\n"); - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); + reaction(in) {= + self->input_received = true; + bool failed = false; // For testing. + printf("TokenPrint received: ["); + for (int i = 0; i < in->value->length; i++) { + if (i > 0) printf(", "); + printf("%d", in->value->data[i]); + // For testing, check whether values match expectation. + if (in->value->data[i] != self->scale * self->count) { + failed = true; } - =} + self->count++; + } + printf("]\n"); + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + =} - reaction(shutdown) {= - if (!self->input_received) { - lf_print_error_and_exit("TokenPrint: No input received!"); - } - =} + reaction(shutdown) {= + if (!self->input_received) { + lf_print_error_and_exit("TokenPrint: No input received!"); + } + =} } /** - * @brief Multiply an input array by the scale factor given as a parameter. The - * input is declared mutable so, if possible, the input token will be modified - * rather than allocating a new token. + * @brief Multiply an input array by the scale factor given as a parameter. The input is declared + * mutable so, if possible, the input token will be modified rather than allocating a new token. */ reactor TokenScale(scale: int = 2) { - mutable input in: int_array_t* - output out: int_array_t* + mutable input in: int_array_t* + output out: int_array_t* - reaction(in) -> out {= - for (int i = 0; i < in->value->length; i++) { - in->value->data[i] *= self->scale; - } - lf_set_token(out, in->token); - =} + reaction(in) -> out {= + for (int i = 0; i < in->value->length; i++) { + in->value->data[i] *= self->scale; + } + lf_set_token(out, in->token); + =} } /** @brief Delay a token using a logical action. The delay is 1 ms. */ reactor TokenDelay { - input in: int_array_t* - output out: int_array_t* - logical action a: int_array_t* + input in: int_array_t* + output out: int_array_t* + logical action a: int_array_t* - reaction(a) -> out {= lf_set_token(out, a->token); =} + reaction(a) -> out {= lf_set_token(out, a->token); =} - reaction(in) -> a {= lf_schedule_token(a, MSEC(1), in->token); =} + reaction(in) -> a {= lf_schedule_token(a, MSEC(1), in->token); =} } diff --git a/test/C/src/zephyr/HelloZephyr.lf b/test/C/src/zephyr/HelloZephyr.lf index 3ce632796b..aae4f62252 100644 --- a/test/C/src/zephyr/HelloZephyr.lf +++ b/test/C/src/zephyr/HelloZephyr.lf @@ -1,7 +1,7 @@ target C { - platform: "Zephyr" + platform: "Zephyr" } main reactor { - reaction(startup) {= printf("Hello World!\n"); =} + reaction(startup) {= printf("Hello World!\n"); =} } diff --git a/test/C/src/zephyr/Timer.lf b/test/C/src/zephyr/Timer.lf index d3cb3f96de..56f2d9002f 100644 --- a/test/C/src/zephyr/Timer.lf +++ b/test/C/src/zephyr/Timer.lf @@ -1,14 +1,14 @@ target C { - platform: { - name: Zephyr, - board: qemu_cortex_m3 - }, - threading: false, - timeout: 10 sec + platform: { + name: Zephyr, + board: qemu_cortex_m3 + }, + threading: false, + timeout: 10 sec } main reactor { - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) {= printf("Hello\n"); =} + reaction(t) {= printf("Hello\n"); =} } diff --git a/test/C/src/zephyr/lib/Led.lf b/test/C/src/zephyr/lib/Led.lf index 04999cf14b..e634fac745 100644 --- a/test/C/src/zephyr/lib/Led.lf +++ b/test/C/src/zephyr/lib/Led.lf @@ -1,32 +1,32 @@ target C reactor NrfLeds { - preamble {= - #include - #include - #define LED0_NODE DT_ALIAS(led0) - #define LED1_NODE DT_ALIAS(led1) - #define LED2_NODE DT_ALIAS(led2) - #define LED3_NODE DT_ALIAS(led3) - static const struct gpio_dt_spec led0 = GPIO_DT_SPEC_GET(LED0_NODE, gpios); - static const struct gpio_dt_spec led1 = GPIO_DT_SPEC_GET(LED1_NODE, gpios); - static const struct gpio_dt_spec led2 = GPIO_DT_SPEC_GET(LED2_NODE, gpios); - static const struct gpio_dt_spec led3 = GPIO_DT_SPEC_GET(LED3_NODE, gpios); - =} - timer t(0, 100 msec) + preamble {= + #include + #include + #define LED0_NODE DT_ALIAS(led0) + #define LED1_NODE DT_ALIAS(led1) + #define LED2_NODE DT_ALIAS(led2) + #define LED3_NODE DT_ALIAS(led3) + static const struct gpio_dt_spec led0 = GPIO_DT_SPEC_GET(LED0_NODE, gpios); + static const struct gpio_dt_spec led1 = GPIO_DT_SPEC_GET(LED1_NODE, gpios); + static const struct gpio_dt_spec led2 = GPIO_DT_SPEC_GET(LED2_NODE, gpios); + static const struct gpio_dt_spec led3 = GPIO_DT_SPEC_GET(LED3_NODE, gpios); + =} + timer t(0, 100 msec) - reaction(startup) {= - gpio_pin_configure_dt(&led0, GPIO_OUTPUT_ACTIVE); - gpio_pin_configure_dt(&led1, GPIO_OUTPUT_ACTIVE); - gpio_pin_configure_dt(&led2, GPIO_OUTPUT_ACTIVE); - gpio_pin_configure_dt(&led3, GPIO_OUTPUT_ACTIVE); - =} + reaction(startup) {= + gpio_pin_configure_dt(&led0, GPIO_OUTPUT_ACTIVE); + gpio_pin_configure_dt(&led1, GPIO_OUTPUT_ACTIVE); + gpio_pin_configure_dt(&led2, GPIO_OUTPUT_ACTIVE); + gpio_pin_configure_dt(&led3, GPIO_OUTPUT_ACTIVE); + =} - reaction(t) {= - printf("Hello\n"); - gpio_pin_toggle_dt(&led0); - gpio_pin_toggle_dt(&led1); - gpio_pin_toggle_dt(&led2); - gpio_pin_toggle_dt(&led3); - =} + reaction(t) {= + printf("Hello\n"); + gpio_pin_toggle_dt(&led0); + gpio_pin_toggle_dt(&led1); + gpio_pin_toggle_dt(&led2); + gpio_pin_toggle_dt(&led3); + =} } diff --git a/test/Cpp/src/ActionDelay.lf b/test/Cpp/src/ActionDelay.lf index 14210e1009..03b6b8beb9 100644 --- a/test/Cpp/src/ActionDelay.lf +++ b/test/Cpp/src/ActionDelay.lf @@ -2,49 +2,49 @@ target Cpp reactor GeneratedDelay { - input y_in: int - output y_out: int - state y_state: int = 0 - logical action act(100 msec): void + input y_in: int + output y_out: int + state y_state: int = 0 + logical action act(100 msec): void - reaction(y_in) -> act {= - y_state = *y_in.get(); - act.schedule(); - =} + reaction(y_in) -> act {= + y_state = *y_in.get(); + act.schedule(); + =} - reaction(act) -> y_out {= y_out.set(y_state); =} + reaction(act) -> y_out {= y_out.set(y_state); =} } reactor Source { - output out: int + output out: int - reaction(startup) -> out {= out.set(1); =} + reaction(startup) -> out {= out.set(1); =} } reactor Sink { - input in: int - - reaction(in) {= - auto elapsed_logical = get_elapsed_logical_time(); - auto logical = get_logical_time(); - auto physical = get_physical_time(); - std::cout << "logical time: " << logical << '\n'; - std::cout << "physical time: " << physical << '\n'; - std::cout << "elapsed logical time: " << elapsed_logical << '\n'; - if (elapsed_logical != 100ms) { - std::cerr << "ERROR: Expected 100 msecs but got " << elapsed_logical << '\n'; - exit(1); - } else { - std::cout << "SUCCESS. Elapsed logical time is 100 msec.\n"; - } - =} + input in: int + + reaction(in) {= + auto elapsed_logical = get_elapsed_logical_time(); + auto logical = get_logical_time(); + auto physical = get_physical_time(); + std::cout << "logical time: " << logical << '\n'; + std::cout << "physical time: " << physical << '\n'; + std::cout << "elapsed logical time: " << elapsed_logical << '\n'; + if (elapsed_logical != 100ms) { + std::cerr << "ERROR: Expected 100 msecs but got " << elapsed_logical << '\n'; + exit(1); + } else { + std::cout << "SUCCESS. Elapsed logical time is 100 msec.\n"; + } + =} } main reactor ActionDelay { - source = new Source() - sink = new Sink() - g = new GeneratedDelay() + source = new Source() + sink = new Sink() + g = new GeneratedDelay() - source.out -> g.y_in - g.y_out -> sink.in + source.out -> g.y_in + g.y_out -> sink.in } diff --git a/test/Cpp/src/ActionIsPresent.lf b/test/Cpp/src/ActionIsPresent.lf index e98c2a2a32..4a75c262c7 100644 --- a/test/Cpp/src/ActionIsPresent.lf +++ b/test/Cpp/src/ActionIsPresent.lf @@ -2,28 +2,28 @@ target Cpp main reactor ActionIsPresent(offset: time = 1 nsec, period: time(500 msec)) { - logical action a - state success: bool = false - state zero: time = 0 nsec + logical action a + state success: bool = false + state zero: time = 0 nsec - reaction(startup, a) -> a {= - if (!a.is_present()) { - if (offset == zero) { - std::cout << "Hello World!" << '\n'; - success = true; - } else { - a.schedule(offset); - } - } else { - std::cout << "Hello World 2!" << '\n'; + reaction(startup, a) -> a {= + if (!a.is_present()) { + if (offset == zero) { + std::cout << "Hello World!" << '\n'; success = true; + } else { + a.schedule(offset); } - =} + } else { + std::cout << "Hello World 2!" << '\n'; + success = true; + } + =} - reaction(shutdown) {= - if (!success) { - std::cerr << "Failed to print 'Hello World!'" << '\n'; - exit(1); - } - =} + reaction(shutdown) {= + if (!success) { + std::cerr << "Failed to print 'Hello World!'" << '\n'; + exit(1); + } + =} } diff --git a/test/Cpp/src/ActionValues.lf b/test/Cpp/src/ActionValues.lf index 8d115c60fa..6e40e2d526 100644 --- a/test/Cpp/src/ActionValues.lf +++ b/test/Cpp/src/ActionValues.lf @@ -2,46 +2,46 @@ target Cpp main reactor ActionValues { - state r1done: bool = false - state r2done: bool = false - logical action act(100 msec): int + state r1done: bool = false + state r2done: bool = false + logical action act(100 msec): int - reaction(startup) -> act {= - act.schedule(100); // scheduled in 100 ms - std::chrono::milliseconds delay(50); - act.schedule(-100, delay); // scheduled in 150 ms, value is overwritten - =} + reaction(startup) -> act {= + act.schedule(100); // scheduled in 100 ms + std::chrono::milliseconds delay(50); + act.schedule(-100, delay); // scheduled in 150 ms, value is overwritten + =} - reaction(act) {= - auto elapsed = get_elapsed_logical_time(); + reaction(act) {= + auto elapsed = get_elapsed_logical_time(); - std::cout << "[@" << elapsed << '\n'; - std::cout << " action transmitted: " << *act.get() << '\n'; - std::cout << "]\n"; + std::cout << "[@" << elapsed << '\n'; + std::cout << " action transmitted: " << *act.get() << '\n'; + std::cout << "]\n"; - if (elapsed == 100ms) { - if (*act.get() != 100) { - std::cerr << "ERROR: Expected action value to be 100\n"; - exit(1); - } - r1done = true; - } else { - if (elapsed != 150ms) { - std::cerr << "ERROR: Unexpected reaction invocation at " << elapsed << '\n'; - exit(1); - } - if (*act.get() != -100) { - std::cerr << "ERROR: Expected action value to be -100\n"; - exit(1); - } - r2done = true; + if (elapsed == 100ms) { + if (*act.get() != 100) { + std::cerr << "ERROR: Expected action value to be 100\n"; + exit(1); } - =} - - reaction(shutdown) {= - if (!r1done || !r2done) { - std::cerr << "ERROR: Expected 2 reaction invocations\n"; + r1done = true; + } else { + if (elapsed != 150ms) { + std::cerr << "ERROR: Unexpected reaction invocation at " << elapsed << '\n'; exit(1); } - =} + if (*act.get() != -100) { + std::cerr << "ERROR: Expected action value to be -100\n"; + exit(1); + } + r2done = true; + } + =} + + reaction(shutdown) {= + if (!r1done || !r2done) { + std::cerr << "ERROR: Expected 2 reaction invocations\n"; + exit(1); + } + =} } diff --git a/test/Cpp/src/After.lf b/test/Cpp/src/After.lf index bbcc287b78..30405a258b 100644 --- a/test/Cpp/src/After.lf +++ b/test/Cpp/src/After.lf @@ -1,55 +1,54 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target Cpp { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } reactor foo { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= y.set(2*(*x.get())); =} + reaction(x) -> y {= y.set(2*(*x.get())); =} } reactor print { - state expected_time: time = 10 msec - state i: int = 0 - input x: int + state expected_time: time = 10 msec + state i: int = 0 + input x: int - reaction(x) {= - i++; - auto elapsed_time = get_elapsed_logical_time(); - std::cout << "Result is " << *x.get() << '\n'; - if (*x.get() != 84) { - std::cerr << "ERROR: Expected result to be 84.\n"; - exit(1); - } - std::cout << "Current logical time is: " << elapsed_time << '\n'; - std::cout << "Current physical time is: " << get_elapsed_physical_time() << '\n'; - if (elapsed_time != expected_time) { - std::cerr << "ERROR: Expected logical time to be " << expected_time << '\n'; - exit(2); - } - expected_time += 1s; - =} + reaction(x) {= + i++; + auto elapsed_time = get_elapsed_logical_time(); + std::cout << "Result is " << *x.get() << '\n'; + if (*x.get() != 84) { + std::cerr << "ERROR: Expected result to be 84.\n"; + exit(1); + } + std::cout << "Current logical time is: " << elapsed_time << '\n'; + std::cout << "Current physical time is: " << get_elapsed_physical_time() << '\n'; + if (elapsed_time != expected_time) { + std::cerr << "ERROR: Expected logical time to be " << expected_time << '\n'; + exit(2); + } + expected_time += 1s; + =} - reaction(shutdown) {= - if (i == 0) { - std::cerr << "ERROR: Final reactor received no data.\n"; - exit(3); - } - =} + reaction(shutdown) {= + if (i == 0) { + std::cerr << "ERROR: Final reactor received no data.\n"; + exit(3); + } + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x after 10 msec + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x after 10 msec - reaction(t) -> f.x {= - f.x.set(42); - std::cout << "Timer!\n"; - =} + reaction(t) -> f.x {= + f.x.set(42); + std::cout << "Timer!\n"; + =} } diff --git a/test/Cpp/src/AfterOverlapped.lf b/test/Cpp/src/AfterOverlapped.lf index 6a85eaf5bc..0ef3c57da5 100644 --- a/test/Cpp/src/AfterOverlapped.lf +++ b/test/Cpp/src/AfterOverlapped.lf @@ -1,43 +1,43 @@ // This the after keyword with overlapped time intervals. target Cpp { - fast: true, - timeout: 5 sec + fast: true, + timeout: 5 sec } import Count from "lib/Count.lf" reactor Test { - input c: int - state i: int = 0 + input c: int + state i: int = 0 - reaction(c) {= - std::cout << "Received " << *c.get() << '\n'; - i++; - if (*c.get() != i) { - std::cerr << "ERROR: Expected " << i << " but got " << *c.get() << '\n'; - exit(1); - } - auto elapsed_time = get_elapsed_logical_time(); + reaction(c) {= + std::cout << "Received " << *c.get() << '\n'; + i++; + if (*c.get() != i) { + std::cerr << "ERROR: Expected " << i << " but got " << *c.get() << '\n'; + exit(1); + } + auto elapsed_time = get_elapsed_logical_time(); - std::cout << "Elapsed logical time is: " << elapsed_time << '\n'; + std::cout << "Elapsed logical time is: " << elapsed_time << '\n'; - auto expected = 2s + ((*c.get() - 1) * 1s); - if (elapsed_time != expected) { - std::cerr << "ERROR: Expected logical time to be " << expected << '\n'; - exit(1); - } - =} + auto expected = 2s + ((*c.get() - 1) * 1s); + if (elapsed_time != expected) { + std::cerr << "ERROR: Expected logical time to be " << expected << '\n'; + exit(1); + } + =} - reaction(shutdown) {= - if (i == 0) { - std::cerr << "ERROR: Final reactor received no data.\n"; - exit(3); - } - =} + reaction(shutdown) {= + if (i == 0) { + std::cerr << "ERROR: Final reactor received no data.\n"; + exit(3); + } + =} } main reactor { - count = new Count() - test = new Test() - count.c -> test.c after 2 sec + count = new Count() + test = new Test() + count.c -> test.c after 2 sec } diff --git a/test/Cpp/src/AfterZero.lf b/test/Cpp/src/AfterZero.lf index 152b87cfc2..a52ce7cedb 100644 --- a/test/Cpp/src/AfterZero.lf +++ b/test/Cpp/src/AfterZero.lf @@ -1,60 +1,59 @@ -// This checks that the after keyword adjusts logical time, not using physical -// time. +// This checks that the after keyword adjusts logical time, not using physical time. target Cpp { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } reactor foo { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= y.set(2*(*x.get())); =} + reaction(x) -> y {= y.set(2*(*x.get())); =} } reactor print { - state expected_time: time = 0 - state i: int = 0 - input x: int + state expected_time: time = 0 + state i: int = 0 + input x: int - reaction(x) {= - i++; - auto elapsed_time = get_elapsed_logical_time(); - std::cout << "Result is " << *x.get() << '\n'; - if (*x.get() != 84) { - std::cerr << "ERROR: Expected result to be 84.\n"; - exit(1); - } - std::cout << "Current logical time is: " << elapsed_time << '\n'; - std::cout << "Current microstep is: " << get_microstep() << '\n'; - std::cout << "Current physical time is: " << get_elapsed_physical_time() << '\n'; - if (elapsed_time != expected_time) { - std::cerr << "ERROR: Expected logical time to be " << expected_time << '\n'; - exit(2); - } - if (get_microstep() != 1) { - std::cerr << "Expected microstrp to be 1\n"; - exit(3); - } - expected_time += 1s; - =} + reaction(x) {= + i++; + auto elapsed_time = get_elapsed_logical_time(); + std::cout << "Result is " << *x.get() << '\n'; + if (*x.get() != 84) { + std::cerr << "ERROR: Expected result to be 84.\n"; + exit(1); + } + std::cout << "Current logical time is: " << elapsed_time << '\n'; + std::cout << "Current microstep is: " << get_microstep() << '\n'; + std::cout << "Current physical time is: " << get_elapsed_physical_time() << '\n'; + if (elapsed_time != expected_time) { + std::cerr << "ERROR: Expected logical time to be " << expected_time << '\n'; + exit(2); + } + if (get_microstep() != 1) { + std::cerr << "Expected microstrp to be 1\n"; + exit(3); + } + expected_time += 1s; + =} - reaction(shutdown) {= - if (i == 0) { - std::cerr << "ERROR: Final reactor received no data.\n"; - exit(3); - } - =} + reaction(shutdown) {= + if (i == 0) { + std::cerr << "ERROR: Final reactor received no data.\n"; + exit(3); + } + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x after 0 + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x after 0 - reaction(t) -> f.x {= - f.x.set(42); - std::cout << "Timer!\n"; - =} + reaction(t) -> f.x {= + f.x.set(42); + std::cout << "Timer!\n"; + =} } diff --git a/test/Cpp/src/Alignment.lf b/test/Cpp/src/Alignment.lf index 1bd3562f41..674c29c34c 100644 --- a/test/Cpp/src/Alignment.lf +++ b/test/Cpp/src/Alignment.lf @@ -1,105 +1,104 @@ -// This test checks that the downstream reaction is not invoked more than once -// at a logical time. +// This test checks that the downstream reaction is not invoked more than once at a logical time. target Cpp { - logging: LOG, - timeout: 1 sec, - build-type: Debug + logging: LOG, + timeout: 1 sec, + build-type: Debug } reactor Source { - output out: int - state count: int = 1 - timer t(0, 100 msec) + output out: int + state count: int = 1 + timer t(0, 100 msec) - reaction(t) -> out {= - count++; - out.set(count); - =} + reaction(t) -> out {= + count++; + out.set(count); + =} } reactor Sieve { - private preamble {= - #include "reactor-cpp/logging.hh" - =} - input in: int - output out: bool - state primes: std::vector + private preamble {= + #include "reactor-cpp/logging.hh" + =} + input in: int + output out: bool + state primes: std::vector - reaction(startup) {= - // There are 1229 primes between 1 and 10,000. - // Primes 1 and 2 are not on the list. - primes.push_back(3); - =} + reaction(startup) {= + // There are 1229 primes between 1 and 10,000. + // Primes 1 and 2 are not on the list. + primes.push_back(3); + =} - reaction(in) -> out {= - // Reject out of bounds inputs - if(*in.get() <= 0 || *in.get() > 10000) { - reactor::log::Warn() << "Sieve: Input value out of range: " << *in.get(); - } - // Primes 1 and 2 are not on the list. - if (*in.get() == 1 || *in.get() == 2) { - out.set(true); - return; - } - // If the input is greater than the last found prime, then - // we have to expand the list of primes before checking to - // see whether this is prime. - int candidate = primes.back(); - reactor::log::Info() << "Sieve: Checking prime: " << candidate; - while (*in.get() > primes.back()) { - candidate += 2; - bool prime = true; - for (auto i : primes) { - if(candidate % i == 0) { - // Candidate is not prime. Break and add 2 by starting the loop again - prime = false; - break; - } - } - // If the candidate is not divisible by any prime in the list, it is prime - if (prime) { - primes.push_back(candidate); - reactor::log::Info() << "Sieve: Found prime: " << candidate; + reaction(in) -> out {= + // Reject out of bounds inputs + if(*in.get() <= 0 || *in.get() > 10000) { + reactor::log::Warn() << "Sieve: Input value out of range: " << *in.get(); + } + // Primes 1 and 2 are not on the list. + if (*in.get() == 1 || *in.get() == 2) { + out.set(true); + return; + } + // If the input is greater than the last found prime, then + // we have to expand the list of primes before checking to + // see whether this is prime. + int candidate = primes.back(); + reactor::log::Info() << "Sieve: Checking prime: " << candidate; + while (*in.get() > primes.back()) { + candidate += 2; + bool prime = true; + for (auto i : primes) { + if(candidate % i == 0) { + // Candidate is not prime. Break and add 2 by starting the loop again + prime = false; + break; } } + // If the candidate is not divisible by any prime in the list, it is prime + if (prime) { + primes.push_back(candidate); + reactor::log::Info() << "Sieve: Found prime: " << candidate; + } + } - // We are now assured that the input is less than or - // equal to the last prime on the list. - // See whether the input is an already found prime. - // Search the primes from the end, where they are sparser. - for (auto i = primes.rbegin(); i != primes.rend(); ++i) { - if(*i == *in.get()) { - out.set(true); - return; - } + // We are now assured that the input is less than or + // equal to the last prime on the list. + // See whether the input is an already found prime. + // Search the primes from the end, where they are sparser. + for (auto i = primes.rbegin(); i != primes.rend(); ++i) { + if(*i == *in.get()) { + out.set(true); + return; } - =} + } + =} } reactor Destination { - input ok: bool - input in: int - state last_invoked: {= reactor::TimePoint =} + input ok: bool + input in: int + state last_invoked: {= reactor::TimePoint =} - reaction(ok, in) {= - if (ok.is_present() && in.is_present()) { - reactor::log::Info() << "Destination: Input " << *in.get() << " is a prime at logical time ( " - << get_elapsed_logical_time() << " )"; - } - if( get_logical_time() <= last_invoked) { - reactor::log::Error() << "Invoked at logical time (" << get_logical_time() << ") " - << "but previously invoked at logical time (" << get_elapsed_logical_time() << ")"; - } + reaction(ok, in) {= + if (ok.is_present() && in.is_present()) { + reactor::log::Info() << "Destination: Input " << *in.get() << " is a prime at logical time ( " + << get_elapsed_logical_time() << " )"; + } + if( get_logical_time() <= last_invoked) { + reactor::log::Error() << "Invoked at logical time (" << get_logical_time() << ") " + << "but previously invoked at logical time (" << get_elapsed_logical_time() << ")"; + } - last_invoked = get_logical_time(); - =} + last_invoked = get_logical_time(); + =} } main reactor { - source = new Source() - sieve = new Sieve() - destination = new Destination() - source.out -> sieve.in - sieve.out -> destination.ok - source.out -> destination.in + source = new Source() + sieve = new Sieve() + destination = new Destination() + source.out -> sieve.in + sieve.out -> destination.ok + source.out -> destination.in } diff --git a/test/Cpp/src/ArrayAsParameter.lf b/test/Cpp/src/ArrayAsParameter.lf index 85cd0630bf..d2bf3c5ef9 100644 --- a/test/Cpp/src/ArrayAsParameter.lf +++ b/test/Cpp/src/ArrayAsParameter.lf @@ -1,44 +1,43 @@ -// Source has an variable sized list as a parameter, the elements of which it -// passes to Print. +// Source has an variable sized list as a parameter, the elements of which it passes to Print. target Cpp reactor Source(sequence: std::vector = {0, 1, 2}) { - output out: size_t - state count: size_t = 0 - logical action next: void + output out: size_t + state count: size_t = 0 + logical action next: void - reaction(startup, next) -> out, next {= - out.set(sequence[count]); - count++; - if (count < sequence.size()) { - next.schedule(); - } - =} + reaction(startup, next) -> out, next {= + out.set(sequence[count]); + count++; + if (count < sequence.size()) { + next.schedule(); + } + =} } reactor Print { - input in: size_t - state count: size_t = 1 + input in: size_t + state count: size_t = 1 - reaction(in) {= - std::cout << "Received: " << *in.get() << '\n'; - if (*in.get() != count) { - std::cerr << "ERROR: Expected " << count << '\n'; - exit(1); - } - count++; - =} + reaction(in) {= + std::cout << "Received: " << *in.get() << '\n'; + if (*in.get() != count) { + std::cerr << "ERROR: Expected " << count << '\n'; + exit(1); + } + count++; + =} - reaction(shutdown) {= - if (count == 1) { - std::cerr << "ERROR: Final reactor received no data.\n"; - exit(3); - } - =} + reaction(shutdown) {= + if (count == 1) { + std::cerr << "ERROR: Final reactor received no data.\n"; + exit(3); + } + =} } main reactor ArrayAsParameter { - s = new Source(sequence = {1, 2, 3, 4}) - p = new Print() - s.out -> p.in + s = new Source(sequence = {1, 2, 3, 4}) + p = new Print() + s.out -> p.in } diff --git a/test/Cpp/src/ArrayPrint.lf b/test/Cpp/src/ArrayPrint.lf index 3bdf494107..c0cbcff6fc 100644 --- a/test/Cpp/src/ArrayPrint.lf +++ b/test/Cpp/src/ArrayPrint.lf @@ -1,56 +1,55 @@ -// Source produces a dynamically allocated array, which it passes to Print. The -// ownership semantics of values ensure that the array is automatically deleted -// if it does have no owner. +// Source produces a dynamically allocated array, which it passes to Print. The ownership semantics +// of values ensure that the array is automatically deleted if it does have no owner. target Cpp reactor Source { - output out: int[3] - - reaction(startup) -> out {= - // create a dynamically allocated mutable array - auto result = reactor::make_mutable_value>(); - (*result)[0] = 0; - (*result)[1] = 1; - (*result)[2] = 2; - // Send the array and move ownership. This implicitly converts the mutable - // value to an immutable value. - out.set(std::move(result)); - =} + output out: int[3] + + reaction(startup) -> out {= + // create a dynamically allocated mutable array + auto result = reactor::make_mutable_value>(); + (*result)[0] = 0; + (*result)[1] = 1; + (*result)[2] = 2; + // Send the array and move ownership. This implicitly converts the mutable + // value to an immutable value. + out.set(std::move(result)); + =} } reactor Print(scale: int = 1) { - input in: int[3] - - reaction(in) {= - int expected = 0; - bool failed = false; - - // get a reference to the result to avoid a copy - auto& result = *in.get(); - - std::cout << "Received: ["; - for (int i = 0; i < 3; i++) { - std::cout << result[i]; - if (i < 2) { - std::cout << ", "; - } - - // check whether values match expectation. - if (result[i] != expected * scale) { - failed = true; - } - expected++; + input in: int[3] + + reaction(in) {= + int expected = 0; + bool failed = false; + + // get a reference to the result to avoid a copy + auto& result = *in.get(); + + std::cout << "Received: ["; + for (int i = 0; i < 3; i++) { + std::cout << result[i]; + if (i < 2) { + std::cout << ", "; } - std::cout << "]\n"; - if (failed) { - printf("ERROR: Value received by Print does not match expectation!\n"); - exit(1); + + // check whether values match expectation. + if (result[i] != expected * scale) { + failed = true; } - =} + expected++; + } + std::cout << "]\n"; + if (failed) { + printf("ERROR: Value received by Print does not match expectation!\n"); + exit(1); + } + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/Cpp/src/ArrayScale.lf b/test/Cpp/src/ArrayScale.lf index b52e7305b7..89bdf68ab9 100644 --- a/test/Cpp/src/ArrayScale.lf +++ b/test/Cpp/src/ArrayScale.lf @@ -1,31 +1,30 @@ -// Source produces a dynamically allocated array, which it passes to Scale. -// Scale requests a writable copy. It modifies it and passes it to Print. It -// gets freed after Print is done with it. +// Source produces a dynamically allocated array, which it passes to Scale. Scale requests a +// writable copy. It modifies it and passes it to Print. It gets freed after Print is done with it. target Cpp import Source, Print from "ArrayPrint.lf" reactor Scale(scale: int = 2) { - input in: int[3] + input in: int[3] - output out: int[3] + output out: int[3] - reaction(in) -> out {= - // create a mutable copy of the received input - auto array = in.get().get_mutable_copy(); - // NOTE: Ideally, no copy copy would be made here, as there is only - // one recipient for the value, but this is not supported yet by the C++ runtime. - for(int i = 0; i < array->size(); i++) { - (*array)[i] = (*array)[i] * scale; - } - out.set(std::move(array)); - =} + reaction(in) -> out {= + // create a mutable copy of the received input + auto array = in.get().get_mutable_copy(); + // NOTE: Ideally, no copy copy would be made here, as there is only + // one recipient for the value, but this is not supported yet by the C++ runtime. + for(int i = 0; i < array->size(); i++) { + (*array)[i] = (*array)[i] * scale; + } + out.set(std::move(array)); + =} } main reactor ArrayScale { - s = new Source() - c = new Scale(scale = 2) - p = new Print(scale = 2) - s.out -> c.in - c.out -> p.in + s = new Source() + c = new Scale(scale = 2) + p = new Print(scale = 2) + s.out -> c.in + c.out -> p.in } diff --git a/test/Cpp/src/CharLiteralInitializer.lf b/test/Cpp/src/CharLiteralInitializer.lf index e01e5973a6..3a104b2bb3 100644 --- a/test/Cpp/src/CharLiteralInitializer.lf +++ b/test/Cpp/src/CharLiteralInitializer.lf @@ -2,12 +2,12 @@ target Cpp main reactor CharLiteralInitializer { - state c: char = 'x' + state c: char = 'x' - reaction(startup) {= - if (c != 'x') { - std::cout << "FAILED: Expected 'x', got " << c << '\n'; - exit(1); - } - =} + reaction(startup) {= + if (c != 'x') { + std::cout << "FAILED: Expected 'x', got " << c << '\n'; + exit(1); + } + =} } diff --git a/test/Cpp/src/Composition.lf b/test/Cpp/src/Composition.lf index 0a341d5e4f..79105666d5 100644 --- a/test/Cpp/src/Composition.lf +++ b/test/Cpp/src/Composition.lf @@ -1,45 +1,44 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target Cpp { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period: time = 2 sec) { - output y: int - timer t(1 sec, period) - state count: int = 0 + output y: int + timer t(1 sec, period) + state count: int = 0 - reaction(t) -> y {= - count++; - y.set(count); - =} + reaction(t) -> y {= + count++; + y.set(count); + =} } reactor Test { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - count++; - auto value = *x.get(); - std::cout << "Received " << value << std::endl; - if (value != count) { - std::cerr << "FAILURE: Expected " << count << std::endl; - exit(1); - } - =} + reaction(x) {= + count++; + auto value = *x.get(); + std::cout << "Received " << value << std::endl; + if (value != count) { + std::cerr << "FAILURE: Expected " << count << std::endl; + exit(1); + } + =} - reaction(shutdown) {= - if (count != 5) { - std::cerr << "ERROR: expected to receive 5 values but got " << count << '\n'; - exit(1); - } - =} + reaction(shutdown) {= + if (count != 5) { + std::cerr << "ERROR: expected to receive 5 values but got " << count << '\n'; + exit(1); + } + =} } main reactor Composition { - s = new Source() - d = new Test() - s.y -> d.x + s = new Source() + d = new Test() + s.y -> d.x } diff --git a/test/Cpp/src/CompositionAfter.lf b/test/Cpp/src/CompositionAfter.lf index 15d68e13ea..265cc3b249 100644 --- a/test/Cpp/src/CompositionAfter.lf +++ b/test/Cpp/src/CompositionAfter.lf @@ -1,45 +1,44 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target Cpp { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period: time = 2 sec) { - output y: int - timer t(1 sec, period) - state count: int = 0 + output y: int + timer t(1 sec, period) + state count: int = 0 - reaction(t) -> y {= - count++; - y.set(count); - =} + reaction(t) -> y {= + count++; + y.set(count); + =} } reactor Test { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - count++; - auto value = *x.get(); - std::cout << "Received " << value << std::endl; - if (value != count) { - std::cerr << "FAILURE: Expected " << count << std::endl; - exit(1); - } - =} + reaction(x) {= + count++; + auto value = *x.get(); + std::cout << "Received " << value << std::endl; + if (value != count) { + std::cerr << "FAILURE: Expected " << count << std::endl; + exit(1); + } + =} - reaction(shutdown) {= - if (count != 3) { - std::cerr << "ERROR: expected to receive 3 values but got " << count << '\n'; - exit(1); - } - =} + reaction(shutdown) {= + if (count != 3) { + std::cerr << "ERROR: expected to receive 3 values but got " << count << '\n'; + exit(1); + } + =} } main reactor(delay: time = 5 sec) { - s = new Source() - d = new Test() - s.y -> d.x after delay + s = new Source() + d = new Test() + s.y -> d.x after delay } diff --git a/test/Cpp/src/CountTest.lf b/test/Cpp/src/CountTest.lf index 838d84a998..d272ee39ca 100644 --- a/test/Cpp/src/CountTest.lf +++ b/test/Cpp/src/CountTest.lf @@ -1,25 +1,25 @@ target Cpp { - timeout: 3 sec, - fast: true + timeout: 3 sec, + fast: true } import Count from "lib/Count.lf" reactor Test { - input c: int - state i: int = 0 + input c: int + state i: int = 0 - reaction(c) {= - i++; - if (*c.get() != i) { - std::cerr << "ERROR: Expected " << i << " but got " << *c.get() << std::endl; - exit(1); - } - =} + reaction(c) {= + i++; + if (*c.get() != i) { + std::cerr << "ERROR: Expected " << i << " but got " << *c.get() << std::endl; + exit(1); + } + =} } main reactor CountTest { - count = new Count() - test = new Test() - count.c -> test.c + count = new Count() + test = new Test() + count.c -> test.c } diff --git a/test/Cpp/src/Deadline.lf b/test/Cpp/src/Deadline.lf index 19a41ff057..90f0a70af6 100644 --- a/test/Cpp/src/Deadline.lf +++ b/test/Cpp/src/Deadline.lf @@ -1,59 +1,58 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target Cpp { - timeout: 4 sec + timeout: 4 sec } reactor Source(period: time = 2 sec) { - private preamble {= - #include - =} - output y: int - timer t(0, period) - state count: int = 0 + private preamble {= + #include + =} + output y: int + timer t(0, period) + state count: int = 0 - reaction(t) -> y {= - if (count % 2 == 1) { - // The count variable is odd. - // Take time to cause a deadline violation. - std::this_thread::sleep_for(400ms); - } - std::cout << "Source sends: " << count << std::endl; - y.set(count); - count++; - =} + reaction(t) -> y {= + if (count % 2 == 1) { + // The count variable is odd. + // Take time to cause a deadline violation. + std::this_thread::sleep_for(400ms); + } + std::cout << "Source sends: " << count << std::endl; + y.set(count); + count++; + =} } reactor Destination(timeout: time = 1 sec) { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - std::cout << "Destination receives: " << *x.get() << std::endl; - if (count % 2 == 1) { - // The count variable is odd, so the deadline should have been - // violated - std::cerr << "ERROR: Failed to detect deadline." << std::endl; - exit(1); - } - count++; - =} deadline(timeout) {= - std::cout << "Destination deadline handler receives: " - << *x.get() << std::endl; - if (count % 2 == 0) { - // The count variable is even, so the deadline should not have - // been violated. - std::cerr << "ERROR: Deadline handler invoked without deadline " - << "violation." << std::endl; - exit(2); - } - count++; - =} + reaction(x) {= + std::cout << "Destination receives: " << *x.get() << std::endl; + if (count % 2 == 1) { + // The count variable is odd, so the deadline should have been + // violated + std::cerr << "ERROR: Failed to detect deadline." << std::endl; + exit(1); + } + count++; + =} deadline(timeout) {= + std::cout << "Destination deadline handler receives: " + << *x.get() << std::endl; + if (count % 2 == 0) { + // The count variable is even, so the deadline should not have + // been violated. + std::cerr << "ERROR: Deadline handler invoked without deadline " + << "violation." << std::endl; + exit(2); + } + count++; + =} } main reactor Deadline { - s = new Source() - d = new Destination(timeout = 200 msec) - s.y -> d.x + s = new Source() + d = new Destination(timeout = 200 msec) + s.y -> d.x } diff --git a/test/Cpp/src/DeadlineHandledAbove.lf b/test/Cpp/src/DeadlineHandledAbove.lf index b2a6c7658a..17ed373ab0 100644 --- a/test/Cpp/src/DeadlineHandledAbove.lf +++ b/test/Cpp/src/DeadlineHandledAbove.lf @@ -1,42 +1,42 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target Cpp reactor Deadline(threshold: time = 100 msec) { - input x: int - output deadline_violation: bool + input x: int + output deadline_violation: bool - reaction(x) -> deadline_violation {= - std::cerr << "ERROR: Deadline violation was not detected!" << std::endl; - exit(1); - =} deadline(threshold) {= - std::cout << "Deadline violation detected." << std::endl; - deadline_violation.set(true); - =} + reaction(x) -> deadline_violation {= + std::cerr << "ERROR: Deadline violation was not detected!" << std::endl; + exit(1); + =} deadline(threshold) {= + std::cout << "Deadline violation detected." << std::endl; + deadline_violation.set(true); + =} } main reactor DeadlineHandledAbove { - state violation_detected: bool = {= false =} - d = new Deadline(threshold = 10 msec) + state violation_detected: bool = {= false =} + d = new Deadline(threshold = 10 msec) - reaction(startup) -> d.x {= - std::this_thread::sleep_for(std::chrono::milliseconds(20)); - d.x.set(42); - =} + reaction(startup) -> d.x {= + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + d.x.set(42); + =} - reaction(d.deadline_violation) {= - if (*d.deadline_violation.get()) { - std::cout << "Output successfully produced by deadline miss handler." << std::endl; - violation_detected = true; - } - =} + reaction(d.deadline_violation) {= + if (*d.deadline_violation.get()) { + std::cout << "Output successfully produced by deadline miss handler." << std::endl; + violation_detected = true; + } + =} - reaction(shutdown) {= - if (violation_detected) { - std::cout << "SUCCESS. Test passes." << std::endl; - } else { - std::cerr << "ERROR. Container did not react to deadline violation." << std::endl; - exit(2); - } - =} + reaction(shutdown) {= + if (violation_detected) { + std::cout << "SUCCESS. Test passes." << std::endl; + } else { + std::cerr << "ERROR. Container did not react to deadline violation." << std::endl; + exit(2); + } + =} } diff --git a/test/Cpp/src/DelayInt.lf b/test/Cpp/src/DelayInt.lf index f58e5ef45b..d9c2e0afe7 100644 --- a/test/Cpp/src/DelayInt.lf +++ b/test/Cpp/src/DelayInt.lf @@ -2,53 +2,53 @@ target Cpp reactor Delay(delay: time = 100 msec) { - input in: int - output out: int - logical action d: int + input in: int + output out: int + logical action d: int - reaction(in) -> d {= d.schedule(in.get(), delay); =} + reaction(in) -> d {= d.schedule(in.get(), delay); =} - reaction(d) -> out {= - if (d.is_present()) { - out.set(d.get()); - } - =} + reaction(d) -> out {= + if (d.is_present()) { + out.set(d.get()); + } + =} } reactor Test { - input in: int - state start_time: {= reactor::TimePoint =} - timer start - - reaction(start) {= - // Record the logical time at the start. - start_time = get_logical_time(); - =} - - reaction(in) {= - std::cout << "Received: " << *in.get() << std::endl; - // Check the time of the input. - auto current_time = get_logical_time(); - auto elapsed = current_time - start_time; - std::cout << "After " << elapsed << " of logical time." << std::endl; - if (elapsed != 100ms) { - std::cerr << "ERROR: Expected elapsed time to be 100000000 nsecs. " - << "It was " << elapsed << std::endl; - exit(1); - } - if (*in.get() != 42) { - std::cerr << "ERROR: Expected input value to be 42. " - << "It was " << *in.get() << std::endl; - exit(2); - } - =} + input in: int + state start_time: {= reactor::TimePoint =} + timer start + + reaction(start) {= + // Record the logical time at the start. + start_time = get_logical_time(); + =} + + reaction(in) {= + std::cout << "Received: " << *in.get() << std::endl; + // Check the time of the input. + auto current_time = get_logical_time(); + auto elapsed = current_time - start_time; + std::cout << "After " << elapsed << " of logical time." << std::endl; + if (elapsed != 100ms) { + std::cerr << "ERROR: Expected elapsed time to be 100000000 nsecs. " + << "It was " << elapsed << std::endl; + exit(1); + } + if (*in.get() != 42) { + std::cerr << "ERROR: Expected input value to be 42. " + << "It was " << *in.get() << std::endl; + exit(2); + } + =} } main reactor DelayInt { - timer t - d = new Delay() - test = new Test() - d.out -> test.in + timer t + d = new Delay() + test = new Test() + d.out -> test.in - reaction(t) -> d.in {= d.in.set(42); =} + reaction(t) -> d.in {= d.in.set(42); =} } diff --git a/test/Cpp/src/DelayedAction.lf b/test/Cpp/src/DelayedAction.lf index 1ce1aea63f..d8f908cc73 100644 --- a/test/Cpp/src/DelayedAction.lf +++ b/test/Cpp/src/DelayedAction.lf @@ -1,25 +1,25 @@ target Cpp { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } main reactor DelayedAction { - timer t(0, 1 sec) - logical action a: void - state count: int = 0 + timer t(0, 1 sec) + logical action a: void + state count: int = 0 - reaction(t) -> a {= a.schedule(100ms); =} + reaction(t) -> a {= a.schedule(100ms); =} - reaction(a) {= - auto elapsed = get_elapsed_logical_time(); - std::cout << "Nanoseconds since start: " << elapsed << std::endl; + reaction(a) {= + auto elapsed = get_elapsed_logical_time(); + std::cout << "Nanoseconds since start: " << elapsed << std::endl; - auto expected = count * 1s + 100ms; - count++; - if (elapsed != expected) { - std::cerr << "Expected " << expected << " but got " - << elapsed << std::endl; - exit(1); - } - =} + auto expected = count * 1s + 100ms; + count++; + if (elapsed != expected) { + std::cerr << "Expected " << expected << " but got " + << elapsed << std::endl; + exit(1); + } + =} } diff --git a/test/Cpp/src/DoubleInvocation.lf b/test/Cpp/src/DoubleInvocation.lf index 956b54bb17..52496dbd9c 100644 --- a/test/Cpp/src/DoubleInvocation.lf +++ b/test/Cpp/src/DoubleInvocation.lf @@ -1,55 +1,53 @@ -// This illustrates a very strange bug that showed up and has now been fixed. -// This test ensures it does not reappear. At logical time zero, the two Print -// reactors used to be fired twice each at the same logical time. They should -// only be fired once. This behavior was oddly eliminated by either of the -// following actions, neither of which should affect this behavior: +// This illustrates a very strange bug that showed up and has now been fixed. This test ensures it +// does not reappear. At logical time zero, the two Print reactors used to be fired twice each at +// the same logical time. They should only be fired once. This behavior was oddly eliminated by +// either of the following actions, neither of which should affect this behavior: // * Removing the startup reaction in Print. -// * Sending only position, not velocity from Ball. (copied from the c version -// of the test) +// * Sending only position, not velocity from Ball. (copied from the c version of the test) target Cpp { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Ball { - output position: int - output velocity: int - state p: int = 200 - timer trigger(0, 1 sec) + output position: int + output velocity: int + state p: int = 200 + timer trigger(0, 1 sec) - reaction(trigger) -> position, velocity {= - position.set(p); - velocity.set(-1); - p -= 1; - =} + reaction(trigger) -> position, velocity {= + position.set(p); + velocity.set(-1); + p -= 1; + =} } reactor Print { - input velocity: int - input position: int - state previous: int = -1 + input velocity: int + input position: int + state previous: int = -1 - reaction(startup) {= - reactor::log::Info() << "####### Print startup"; - =} + reaction(startup) {= + reactor::log::Info() << "####### Print startup"; + =} - reaction(position, velocity) {= - if (position.is_present()) { - reactor::log::Info() << "Position: " << *position.get(); - } - if (*position.get() == previous) { - reactor::log::Error() << "Multiple firings at the same logical time!"; - exit(1); - } - =} + reaction(position, velocity) {= + if (position.is_present()) { + reactor::log::Info() << "Position: " << *position.get(); + } + if (*position.get() == previous) { + reactor::log::Error() << "Multiple firings at the same logical time!"; + exit(1); + } + =} } main reactor DoubleInvocation { - b1 = new Ball() - p = new Print() - plot = new Print() - b1.position -> p.position - b1.velocity -> p.velocity - b1.position -> plot.position - b1.velocity -> plot.velocity + b1 = new Ball() + p = new Print() + plot = new Print() + b1.position -> p.position + b1.velocity -> p.velocity + b1.position -> plot.position + b1.velocity -> plot.velocity } diff --git a/test/Cpp/src/DoublePort.lf b/test/Cpp/src/DoublePort.lf index faaa474db5..79a385873c 100644 --- a/test/Cpp/src/DoublePort.lf +++ b/test/Cpp/src/DoublePort.lf @@ -1,60 +1,59 @@ /** - * Test the case where two upstream reactors pass messages to a downstream - * reactor on two different ports. One message carries a microstep delay - * relative to the other. + * Test the case where two upstream reactors pass messages to a downstream reactor on two different + * ports. One message carries a microstep delay relative to the other. * * @author Maiko Brants */ target Cpp { - timeout: 900 msec, - fast: true + timeout: 900 msec, + fast: true } import Count from "lib/Count.lf" reactor CountMicrostep { - state count: int = 1 - output out: int - logical action act: int - timer t(0, 1 sec) + state count: int = 1 + output out: int + logical action act: int + timer t(0, 1 sec) - reaction(t) -> act {= - act.schedule( count); - count++; - =} + reaction(t) -> act {= + act.schedule( count); + count++; + =} - reaction(act) -> out {= out.set(act.get()); =} + reaction(act) -> out {= out.set(act.get()); =} } reactor Print { - input in: int - input in2: int - - reaction(in, in2) {= - if(in.is_present()){ - reactor::log::Info() << "At tag (" << get_elapsed_logical_time() << ", " << environment()->logical_time().micro_step() - << "), received in = " << *in.get(); - } else if (in2.is_present()){ - reactor::log::Info() << "At tag (" << get_elapsed_logical_time() << ", " << environment()->logical_time().micro_step() - << "), received in2 = " << *in2.get(); - } - - - if ( in.is_present() && in2.is_present()) { - reactor::log::Error() << "ERROR: invalid logical simultaneity."; - exit(1); - } - =} - - reaction(shutdown) {= - reactor::log::Info() << "SUCCESS: messages were at least one microstep apart."; - =} + input in: int + input in2: int + + reaction(in, in2) {= + if(in.is_present()){ + reactor::log::Info() << "At tag (" << get_elapsed_logical_time() << ", " << environment()->logical_time().micro_step() + << "), received in = " << *in.get(); + } else if (in2.is_present()){ + reactor::log::Info() << "At tag (" << get_elapsed_logical_time() << ", " << environment()->logical_time().micro_step() + << "), received in2 = " << *in2.get(); + } + + + if ( in.is_present() && in2.is_present()) { + reactor::log::Error() << "ERROR: invalid logical simultaneity."; + exit(1); + } + =} + + reaction(shutdown) {= + reactor::log::Info() << "SUCCESS: messages were at least one microstep apart."; + =} } main reactor DoublePort { - c = new Count() - cm = new CountMicrostep() - p = new Print() - c.c -> p.in - cm.out -> p.in2 + c = new Count() + cm = new CountMicrostep() + p = new Print() + c.c -> p.in + cm.out -> p.in2 } diff --git a/test/Cpp/src/DoubleReaction.lf b/test/Cpp/src/DoubleReaction.lf index 1128d63f97..f8002be54d 100644 --- a/test/Cpp/src/DoubleReaction.lf +++ b/test/Cpp/src/DoubleReaction.lf @@ -1,48 +1,48 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target Cpp { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - count++; - y.set(count); - =} + reaction(t) -> y {= + count++; + y.set(count); + =} } reactor Destination { - input x: int - input w: int - state s: int = 2 + input x: int + input w: int + state s: int = 2 - reaction(x, w) {= - int sum = 0; - if (x.is_present()) { - sum += *x.get(); - } - if (w.is_present()) { - sum += *w.get(); - } - std::cout << "Sum of inputs is: " << sum << std::endl; - if (sum != s) { - std::cerr << "FAILURE: Expected sum to be " << s - << "but it was " << sum << std::endl; - exit(1); - } - s += 2; - =} + reaction(x, w) {= + int sum = 0; + if (x.is_present()) { + sum += *x.get(); + } + if (w.is_present()) { + sum += *w.get(); + } + std::cout << "Sum of inputs is: " << sum << std::endl; + if (sum != s) { + std::cerr << "FAILURE: Expected sum to be " << s + << "but it was " << sum << std::endl; + exit(1); + } + s += 2; + =} } main reactor DoubleReaction { - c1 = new Clock() - c2 = new Clock() - d = new Destination() - c1.y -> d.x - c2.y -> d.w + c1 = new Clock() + c2 = new Clock() + d = new Destination() + c1.y -> d.x + c2.y -> d.w } diff --git a/test/Cpp/src/DoubleTrigger.lf b/test/Cpp/src/DoubleTrigger.lf index 5db4818048..f55ffcfedd 100644 --- a/test/Cpp/src/DoubleTrigger.lf +++ b/test/Cpp/src/DoubleTrigger.lf @@ -1,26 +1,25 @@ -// Test that two simultaneous triggers don't cause a reaction to execute twice -// at the same tag. +// Test that two simultaneous triggers don't cause a reaction to execute twice at the same tag. target Cpp main reactor DoubleTrigger { - timer t1 - timer t2 - state s: int = 0 + timer t1 + timer t2 + state s: int = 0 - reaction(t1, t2) {= - s++; - if (s > 1) { - std::cout << "FAILURE: Reaction got triggered twice." << std::endl; - exit(1); - } - =} + reaction(t1, t2) {= + s++; + if (s > 1) { + std::cout << "FAILURE: Reaction got triggered twice." << std::endl; + exit(1); + } + =} - reaction(shutdown) {= - if (s == 1) { - std::cout << "SUCCESS" << std::endl; - } else { - std::cerr << "FAILURE: Reaction was never triggered." << std::endl; - exit(1); - } - =} + reaction(shutdown) {= + if (s == 1) { + std::cout << "SUCCESS" << std::endl; + } else { + std::cerr << "FAILURE: Reaction was never triggered." << std::endl; + exit(1); + } + =} } diff --git a/test/Cpp/src/FloatLiteral.lf b/test/Cpp/src/FloatLiteral.lf index 6ad95f9e55..4f57e36caa 100644 --- a/test/Cpp/src/FloatLiteral.lf +++ b/test/Cpp/src/FloatLiteral.lf @@ -1,20 +1,19 @@ target Cpp -// This test verifies that floating-point literals are handled correctly. -main reactor { - state N: double = 6.0221409e+23 - state charge: double = -1.6021766E-19 - state minus_epsilon: double = -.01e0 - state expected: double = .964853323188E5 +main reactor { // This test verifies that floating-point literals are handled correctly. + state N: double = 6.0221409e+23 + state charge: double = -1.6021766E-19 + state minus_epsilon: double = -.01e0 + state expected: double = .964853323188E5 - reaction(startup) {= - auto F = - N * charge; - if (std::abs(F - expected) < std::abs(minus_epsilon)) { - std::cout << "The Faraday constant is roughly " << F << ".\n"; - } else { - std::cerr << "ERROR: Expected " << expected - << " but computed " << F << ".\n"; - exit(1); - } - =} + reaction(startup) {= + auto F = - N * charge; + if (std::abs(F - expected) < std::abs(minus_epsilon)) { + std::cout << "The Faraday constant is roughly " << F << ".\n"; + } else { + std::cerr << "ERROR: Expected " << expected + << " but computed " << F << ".\n"; + exit(1); + } + =} } diff --git a/test/Cpp/src/Gain.lf b/test/Cpp/src/Gain.lf index 4b123cc992..1a5d6eeedd 100644 --- a/test/Cpp/src/Gain.lf +++ b/test/Cpp/src/Gain.lf @@ -2,30 +2,30 @@ target Cpp reactor Scale(scale: int = 2) { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= y.set(*x.get() * scale); =} + reaction(x) -> y {= y.set(*x.get() * scale); =} } reactor Test { - input x: int + input x: int - reaction(x) {= - auto value = *x.get(); - std::cout << "Received " << value << std::endl; - if (value != 2) { - std::cerr << "Expected 2!" << std::endl; - exit(1); - } - =} + reaction(x) {= + auto value = *x.get(); + std::cout << "Received " << value << std::endl; + if (value != 2) { + std::cerr << "Expected 2!" << std::endl; + exit(1); + } + =} } main reactor Gain { - g = new Scale() - t = new Test() - g.y -> t.x - timer tim + g = new Scale() + t = new Test() + g.y -> t.x + timer tim - reaction(tim) -> g.x {= g.x.set(1); =} + reaction(tim) -> g.x {= g.x.set(1); =} } diff --git a/test/Cpp/src/GetMicroStep.lf b/test/Cpp/src/GetMicroStep.lf index 8370a21403..5bec79df3c 100644 --- a/test/Cpp/src/GetMicroStep.lf +++ b/test/Cpp/src/GetMicroStep.lf @@ -2,28 +2,28 @@ target Cpp main reactor GetMicroStep { - state s: {= reactor::mstep_t =} = 1 + state s: {= reactor::mstep_t =} = 1 - logical action l + logical action l - reaction(startup) -> l {= l.schedule(reactor::Duration::zero()); =} + reaction(startup) -> l {= l.schedule(reactor::Duration::zero()); =} - reaction(l) -> l {= - auto microstep = get_microstep(); - if (microstep != s) { - std::cerr << "Error: expected microstep " << s << ", got " << microstep << "instead\n"; - exit(1); - } - if (s++ < 10) { - l.schedule(); - } - =} + reaction(l) -> l {= + auto microstep = get_microstep(); + if (microstep != s) { + std::cerr << "Error: expected microstep " << s << ", got " << microstep << "instead\n"; + exit(1); + } + if (s++ < 10) { + l.schedule(); + } + =} - reaction(shutdown) {= - if (s != 11) { - std::cerr << "Error: unexpected state!\n"; - exit(2); - } - std::cout << "Success!\n"; - =} + reaction(shutdown) {= + if (s != 11) { + std::cerr << "Error: unexpected state!\n"; + exit(2); + } + std::cout << "Success!\n"; + =} } diff --git a/test/Cpp/src/Hello.lf b/test/Cpp/src/Hello.lf index f74acf6688..0bf2f029da 100644 --- a/test/Cpp/src/Hello.lf +++ b/test/Cpp/src/Hello.lf @@ -1,56 +1,46 @@ -// This test checks that logical time is incremented an appropriate amount as a -// result of an invocation of the schedule() function at runtime. It also -// performs various smoke tests of timing aligned reactions. The first instance -// has a period of 4 seconds, the second of 2 seconds, and the third (composite) -// or 1 second. +// This test checks that logical time is incremented an appropriate amount as a result of an +// invocation of the schedule() function at runtime. It also performs various smoke tests of timing +// aligned reactions. The first instance has a period of 4 seconds, the second of 2 seconds, and the +// third (composite) or 1 second. target Cpp { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } -reactor HelloCpp( - period: time = 2 sec, - message: {= std::string =} = "Hello C++" -) { - state count: int = 0 - state previous_time: {= reactor::TimePoint =} - timer t(1 sec, period) - logical action a: void +reactor HelloCpp(period: time = 2 sec, message: {= std::string =} = "Hello C++") { + state count: int = 0 + state previous_time: {= reactor::TimePoint =} + timer t(1 sec, period) + logical action a: void - reaction(t) -> a {= - std::cout << message << std::endl; - a.schedule(200ms); // No payload. - // Print the current time. - previous_time = get_logical_time(); - std::cout << "Current time is " << previous_time << std::endl; - =} + reaction(t) -> a {= + std::cout << message << std::endl; + a.schedule(200ms); // No payload. + // Print the current time. + previous_time = get_logical_time(); + std::cout << "Current time is " << previous_time << std::endl; + =} - reaction(a) {= - count++; - auto time = get_logical_time(); - std::cout << "***** action " << count << " at time " - << time << std::endl; - auto diff = time - previous_time; - if (diff != 200ms) { - std::cerr << "FAILURE: Expected 200 msecs of logical time to elapse " - << "but got " << diff << std::endl; - exit(1); - } - =} + reaction(a) {= + count++; + auto time = get_logical_time(); + std::cout << "***** action " << count << " at time " + << time << std::endl; + auto diff = time - previous_time; + if (diff != 200ms) { + std::cerr << "FAILURE: Expected 200 msecs of logical time to elapse " + << "but got " << diff << std::endl; + exit(1); + } + =} } -reactor Inside( - period: time = 1 sec, - message: std::string = "Composite default message." -) { - third_instance = new HelloCpp(period = period, message = message) +reactor Inside(period: time = 1 sec, message: std::string = "Composite default message.") { + third_instance = new HelloCpp(period = period, message = message) } main reactor Hello { - first_instance = new HelloCpp( - period = 4 sec, - message = "Hello from first_instance." - ) - second_instance = new HelloCpp(message = "Hello from second_instance.") - composite_instance = new Inside(message = "Hello from composite_instance.") + first_instance = new HelloCpp(period = 4 sec, message = "Hello from first_instance.") + second_instance = new HelloCpp(message = "Hello from second_instance.") + composite_instance = new Inside(message = "Hello from composite_instance.") } diff --git a/test/Cpp/src/Hierarchy2.lf b/test/Cpp/src/Hierarchy2.lf index db81bf4971..478c82db97 100644 --- a/test/Cpp/src/Hierarchy2.lf +++ b/test/Cpp/src/Hierarchy2.lf @@ -1,69 +1,69 @@ // Test data transport across hierarchy. target Cpp { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Source { - output out: int - timer t(0, 1 sec) + output out: int + timer t(0, 1 sec) - reaction(t) -> out {= out.set(1); =} + reaction(t) -> out {= out.set(1); =} } reactor Count { - output out: int - timer t(0, 1 sec) - state i: int = 0 + output out: int + timer t(0, 1 sec) + state i: int = 0 - reaction(t) -> out {= - i++; - out.set(i); - =} + reaction(t) -> out {= + i++; + out.set(i); + =} } reactor Add { - input in1: int - input in2: int - output out: int + input in1: int + input in2: int + output out: int - reaction(in1, in2) -> out {= - int result = 0; - if (in1.is_present()) result += *in1.get(); - if (in2.is_present()) result += *in2.get(); - out.set(result); - =} + reaction(in1, in2) -> out {= + int result = 0; + if (in1.is_present()) result += *in1.get(); + if (in2.is_present()) result += *in2.get(); + out.set(result); + =} } reactor Print { - input in: int - state expected: int = 2 + input in: int + state expected: int = 2 - reaction(in) {= - auto value = *in.get(); - std::cout << "Received: " << value << std::endl; - if (value != expected) { - std::cerr << "Expected " << expected << std::endl; - exit(1); - } - expected++; - =} + reaction(in) {= + auto value = *in.get(); + std::cout << "Received: " << value << std::endl; + if (value != expected) { + std::cerr << "Expected " << expected << std::endl; + exit(1); + } + expected++; + =} } reactor AddCount { - input in: int - output out: int - count = new Count() - add = new Add() - in -> add.in1 - count.out -> add.in2 - add.out -> out + input in: int + output out: int + count = new Count() + add = new Add() + in -> add.in1 + count.out -> add.in2 + add.out -> out } main reactor Hierarchy2 { - source = new Source() - addCount = new AddCount() - print = new Print() - source.out -> addCount.in - addCount.out -> print.in + source = new Source() + addCount = new AddCount() + print = new Print() + source.out -> addCount.in + addCount.out -> print.in } diff --git a/test/Cpp/src/ImportComposition.lf b/test/Cpp/src/ImportComposition.lf index 0559edacd1..88dfdff0a9 100644 --- a/test/Cpp/src/ImportComposition.lf +++ b/test/Cpp/src/ImportComposition.lf @@ -1,8 +1,7 @@ /** * @author Maiko Brants TU Dresden * - * This tests the ability to import a reactor definition that itself imports a - * reactor definition. + * This tests the ability to import a reactor definition that itself imports a reactor definition. * * modeled after the C version of this test */ @@ -11,33 +10,33 @@ target Cpp import ImportedComposition from "lib/ImportedComposition.lf" main reactor ImportComposition { - public preamble {= - #include "reactor-cpp/logging.hh" - =} + public preamble {= + #include "reactor-cpp/logging.hh" + =} - imp_comp = new ImportedComposition() - state received: bool = false + imp_comp = new ImportedComposition() + state received: bool = false - reaction(startup) -> imp_comp.x {= imp_comp.x.set(42); =} + reaction(startup) -> imp_comp.x {= imp_comp.x.set(42); =} - reaction(imp_comp.y) {= - auto receive_time = get_elapsed_logical_time(); - reactor::log::Info() << "Received " << *imp_comp.y.get() << " at time " << receive_time; - received = true; - if(receive_time != 55ms) { - reactor::log::Error() << "ERROR: Received time should have been: 55,000,000."; - exit(1); - } - if(*imp_comp.y.get() != 42*2*2) { - reactor::log::Error() << "ERROR: Received value should have been: " << 42*2*2 << "."; - exit(2); - } - =} + reaction(imp_comp.y) {= + auto receive_time = get_elapsed_logical_time(); + reactor::log::Info() << "Received " << *imp_comp.y.get() << " at time " << receive_time; + received = true; + if(receive_time != 55ms) { + reactor::log::Error() << "ERROR: Received time should have been: 55,000,000."; + exit(1); + } + if(*imp_comp.y.get() != 42*2*2) { + reactor::log::Error() << "ERROR: Received value should have been: " << 42*2*2 << "."; + exit(2); + } + =} - reaction(shutdown) {= - if(!received){ - reactor::log::Error() << "ERROR: Nothing received."; - exit(3); - } - =} + reaction(shutdown) {= + if(!received){ + reactor::log::Error() << "ERROR: Nothing received."; + exit(3); + } + =} } diff --git a/test/Cpp/src/ManualDelayedReaction.lf b/test/Cpp/src/ManualDelayedReaction.lf index 3c55bdcaf1..f3b8991136 100644 --- a/test/Cpp/src/ManualDelayedReaction.lf +++ b/test/Cpp/src/ManualDelayedReaction.lf @@ -1,44 +1,42 @@ target Cpp -// That's the stuff that shall be generated for the after -reactor GeneratedDelay { - input y_in: int - output y_out: int - state y_state: int = 0 +reactor GeneratedDelay { // That's the stuff that shall be generated for the after + input y_in: int + output y_out: int + state y_state: int = 0 - logical action act(100 msec): int + logical action act(100 msec): int - reaction(y_in) -> act {= act.schedule(y_in.get()); =} + reaction(y_in) -> act {= act.schedule(y_in.get()); =} - reaction(act) -> y_out {= y_out.set(act.get()); =} + reaction(act) -> y_out {= y_out.set(act.get()); =} } reactor Source { - output out: int - timer t + output out: int + timer t - // reaction(t) -> out after 100 msec {= - reaction(t) -> out {= out.set(1); =} + reaction(t) -> out {= out.set(1); =} // reaction(t) -> out after 100 msec {= } reactor Sink { - input in: int - - reaction(in) {= - auto elapsed_logical = get_elapsed_logical_time(); - std::cout << "Elapsed logical time: " << elapsed_logical << '\n'; - if (elapsed_logical != 100ms) { - std::cerr << "ERROR: Expected 100 ms\n"; - exit(1); - } - =} + input in: int + + reaction(in) {= + auto elapsed_logical = get_elapsed_logical_time(); + std::cout << "Elapsed logical time: " << elapsed_logical << '\n'; + if (elapsed_logical != 100ms) { + std::cerr << "ERROR: Expected 100 ms\n"; + exit(1); + } + =} } main reactor ManualDelayedReaction { - source = new Source() - sink = new Sink() - g = new GeneratedDelay() + source = new Source() + sink = new Sink() + g = new GeneratedDelay() - source.out -> g.y_in // source.out -> sink.in; rewritten above - g.y_out -> sink.in + source.out -> g.y_in // source.out -> sink.in; rewritten above + g.y_out -> sink.in } diff --git a/test/Cpp/src/Methods.lf b/test/Cpp/src/Methods.lf index ff94460b62..6b60012640 100644 --- a/test/Cpp/src/Methods.lf +++ b/test/Cpp/src/Methods.lf @@ -1,24 +1,24 @@ target Cpp main reactor { - state foo: int = 2 + state foo: int = 2 - const method getFoo(): int {= return foo; =} + const method getFoo(): int {= return foo; =} - method add(x: int) {= foo += x; =} + method add(x: int) {= foo += x; =} - reaction(startup) {= - std::cout << "Foo is initialized to " << getFoo() << '\n'; - if (getFoo() != 2) { - std::cerr << "Error: expected 2!\n"; - exit(1); - } + reaction(startup) {= + std::cout << "Foo is initialized to " << getFoo() << '\n'; + if (getFoo() != 2) { + std::cerr << "Error: expected 2!\n"; + exit(1); + } - add(40); - std::cout << "2 + 40 = " << getFoo() << '\n'; - if (getFoo() != 42) { - std::cerr << "Error: expected 42!\n"; - exit(2); - } - =} + add(40); + std::cout << "2 + 40 = " << getFoo() << '\n'; + if (getFoo() != 42) { + std::cerr << "Error: expected 42!\n"; + exit(2); + } + =} } diff --git a/test/Cpp/src/MovingAverage.lf b/test/Cpp/src/MovingAverage.lf index af202ca0a0..817c80c920 100644 --- a/test/Cpp/src/MovingAverage.lf +++ b/test/Cpp/src/MovingAverage.lf @@ -1,73 +1,73 @@ -// Demonstration of a state variable that is a fixed size list. The -// MovingAverage reactor computes the moving average of the last four inputs and -// produces that as output. The source is a counting sequence. +// Demonstration of a state variable that is a fixed size list. The MovingAverage reactor computes +// the moving average of the last four inputs and produces that as output. The source is a counting +// sequence. target Cpp { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Source { - output out: double - state count: int = 0 - timer clock(0, 200 msec) + output out: double + state count: int = 0 + timer clock(0, 200 msec) - reaction(clock) -> out {= - out.set(count); - count++; - =} + reaction(clock) -> out {= + out.set(count); + count++; + =} } reactor MovingAverageImpl { - state delay_line: double[3]{0.0, 0.0, 0.0} - state index: int = 0 - input in: double - output out: double + state delay_line: double[3]{0.0, 0.0, 0.0} + state index: int = 0 + input in: double + output out: double - reaction(in) -> out {= - // Calculate the output. - double sum = *in.get(); - for (int i = 0; i < 3; i++) { - sum += delay_line[i]; - } - out.set(sum/4.0); + reaction(in) -> out {= + // Calculate the output. + double sum = *in.get(); + for (int i = 0; i < 3; i++) { + sum += delay_line[i]; + } + out.set(sum/4.0); - // Insert the input in the delay line. - delay_line[index] = *in.get(); + // Insert the input in the delay line. + delay_line[index] = *in.get(); - // Update the index for the next input. - index++; - if (index >= 3) { - index = 0; - } - =} + // Update the index for the next input. + index++; + if (index >= 3) { + index = 0; + } + =} } reactor Print { - input in: double - state count: int = 0 + input in: double + state count: int = 0 - reaction(in) {= - std::cout << "Received: " << *in.get() << '\n'; - constexpr double expected[6] = {0.0, 0.25, 0.75, 1.5, 2.5, 3.5}; - if (*in.get() != expected[count]) { - std::cerr << "ERROR: Expected " << expected[count] << '\n'; - exit(1); - } - count++; - =} + reaction(in) {= + std::cout << "Received: " << *in.get() << '\n'; + constexpr double expected[6] = {0.0, 0.25, 0.75, 1.5, 2.5, 3.5}; + if (*in.get() != expected[count]) { + std::cerr << "ERROR: Expected " << expected[count] << '\n'; + exit(1); + } + count++; + =} - reaction(shutdown) {= - if(count != 6) { - std::cerr << "ERROR: Expected 6 values but got " << count << '\n'; - exit(2); - } - =} + reaction(shutdown) {= + if(count != 6) { + std::cerr << "ERROR: Expected 6 values but got " << count << '\n'; + exit(2); + } + =} } main reactor MovingAverage { - s = new Source() - m = new MovingAverageImpl() - p = new Print() - s.out -> m.in - m.out -> p.in + s = new Source() + m = new MovingAverageImpl() + p = new Print() + s.out -> m.in + m.out -> p.in } diff --git a/test/Cpp/src/NativeListsAndTimes.lf b/test/Cpp/src/NativeListsAndTimes.lf index f9ddfa4bd7..59d0101087 100644 --- a/test/Cpp/src/NativeListsAndTimes.lf +++ b/test/Cpp/src/NativeListsAndTimes.lf @@ -1,34 +1,33 @@ target Cpp -// This test passes if it is successfully compiled into valid target code. -reactor Foo( - x: int = 0, - y: time = 0, // Units are missing but not required - z = 1 msec, // Type is missing but not required - p: int[]{1, 2, 3, 4}, // List of integers - q: {= std::vector =}{1 msec, 2 msec, 3 msec}, - g: time[]{1 msec, 2 msec}, // List of time values - g2: int[] = {} +reactor Foo( // This test passes if it is successfully compiled into valid target code. + x: int = 0, + y: time = 0, // Units are missing but not required + z = 1 msec, // Type is missing but not required + p: int[]{1, 2, 3, 4}, // List of integers + q: {= std::vector =}{1 msec, 2 msec, 3 msec}, + g: time[]{1 msec, 2 msec}, // List of time values + g2: int[] = {} ) { - state s: time = y // Reference to explicitly typed time parameter - state t: time = z // Reference to implicitly typed time parameter - state v: bool // Uninitialized boolean state variable - state w: time // Uninitialized time state variable - timer tick(0) // Units missing but not required - timer tock(1 sec) // Implicit type time - timer toe(z) // Implicit type time - state baz = p // Implicit type int[] - state period = z // Implicit type time - state times: std::vector< // a list of lists - std::vector<{= reactor::Duration =}> - >{q, g} - state empty_list: int[] = {} + state s: time = y // Reference to explicitly typed time parameter + state t: time = z // Reference to implicitly typed time parameter + state v: bool // Uninitialized boolean state variable + state w: time // Uninitialized time state variable + timer tick(0) // Units missing but not required + timer tock(1 sec) // Implicit type time + timer toe(z) // Implicit type time + state baz = p // Implicit type int[] + state period = z // Implicit type time + state times: std::vector< // a list of lists + std::vector<{= reactor::Duration =}> + >{q, g} + state empty_list: int[] = {} - reaction(tick) {= - // Target code - =} + reaction(tick) {= + // Target code + =} } main reactor NativeListsAndTimes { - foo = new Foo() + foo = new Foo() } diff --git a/test/Cpp/src/NestedTriggeredReactions.lf b/test/Cpp/src/NestedTriggeredReactions.lf index 783dcefc7e..22ea978545 100644 --- a/test/Cpp/src/NestedTriggeredReactions.lf +++ b/test/Cpp/src/NestedTriggeredReactions.lf @@ -1,41 +1,41 @@ target Cpp reactor Container { - input in: void + input in: void - state triggered: bool = false + state triggered: bool = false - contained = new Contained() + contained = new Contained() - in -> contained.in + in -> contained.in - reaction(in) {= triggered = true; =} + reaction(in) {= triggered = true; =} - reaction(shutdown) {= - if (!triggered) { - reactor::log::Error() << "The Container reaction was not triggered!"; - exit(1); - } - =} + reaction(shutdown) {= + if (!triggered) { + reactor::log::Error() << "The Container reaction was not triggered!"; + exit(1); + } + =} } reactor Contained { - input in: void + input in: void - state triggered: bool = false + state triggered: bool = false - reaction(in) {= triggered = true; =} + reaction(in) {= triggered = true; =} - reaction(shutdown) {= - if (!triggered) { - reactor::log::Error() << "The Contained reaction was not triggered!"; - exit(1); - } - =} + reaction(shutdown) {= + if (!triggered) { + reactor::log::Error() << "The Contained reaction was not triggered!"; + exit(1); + } + =} } main reactor { - container = new Container() + container = new Container() - reaction(startup) -> container.in {= container.in.set(); =} + reaction(startup) -> container.in {= container.in.set(); =} } diff --git a/test/Cpp/src/ParameterHierarchy.lf b/test/Cpp/src/ParameterHierarchy.lf index c183cbca03..dcef563d68 100644 --- a/test/Cpp/src/ParameterHierarchy.lf +++ b/test/Cpp/src/ParameterHierarchy.lf @@ -8,25 +8,24 @@ target Cpp reactor Deep(p: int = 0) { - reaction(startup) {= - if(p != 42) { - reactor::log::Error() << "Parameter value is: " << p << ". Should have been 42."; - exit(1); - } else { - reactor::log::Info() << "Success."; - } - =} + reaction(startup) {= + if(p != 42) { + reactor::log::Error() << "Parameter value is: " << p << ". Should have been 42."; + exit(1); + } else { + reactor::log::Info() << "Success."; + } + =} } reactor Intermediate(p: int = 10) { - a = new Deep(p = p) + a = new Deep(p = p) } reactor Another(p: int = 20) { - // also test forwarding parameters via target code blocks - a = new Intermediate(p = {= p =}) + a = new Intermediate(p = {= p =}) // also test forwarding parameters via target code blocks } main reactor ParameterHierarchy { - a = new Intermediate(p = 42) + a = new Intermediate(p = 42) } diff --git a/test/Cpp/src/ParameterizedState.lf b/test/Cpp/src/ParameterizedState.lf index 1c39043a75..9bea16475f 100644 --- a/test/Cpp/src/ParameterizedState.lf +++ b/test/Cpp/src/ParameterizedState.lf @@ -1,16 +1,16 @@ target Cpp reactor Foo(bar: int = 4) { - state baz = bar + state baz = bar - reaction(startup) {= - std::cout << "Baz: " << baz << std::endl; - if (baz != 42) { - exit(1); - } - =} + reaction(startup) {= + std::cout << "Baz: " << baz << std::endl; + if (baz != 42) { + exit(1); + } + =} } main reactor ParameterizedState { - a = new Foo(bar = 42) + a = new Foo(bar = 42) } diff --git a/test/Cpp/src/ParametersOutOfOrder.lf b/test/Cpp/src/ParametersOutOfOrder.lf index 7ef28b914a..4fa2a933ba 100644 --- a/test/Cpp/src/ParametersOutOfOrder.lf +++ b/test/Cpp/src/ParametersOutOfOrder.lf @@ -1,16 +1,16 @@ -// This is a smoke test to see if parameters can be initiailized out of -// definition order. Compilation without errors is success. +// This is a smoke test to see if parameters can be initiailized out of definition order. +// Compilation without errors is success. target Cpp reactor Foo(a: int = 0, b: std::string = "", c: float = 0.0) { - reaction(startup) {= - if (a != 42 || b != "bar" || c < 3.1) { - reactor::log::Error() << "received an unexpected parameter!"; - exit(1); - } - =} + reaction(startup) {= + if (a != 42 || b != "bar" || c < 3.1) { + reactor::log::Error() << "received an unexpected parameter!"; + exit(1); + } + =} } main reactor { - foo = new Foo(c = 3.14, b = "bar", a = 42) + foo = new Foo(c = 3.14, b = "bar", a = 42) } diff --git a/test/Cpp/src/PeriodicDesugared.lf b/test/Cpp/src/PeriodicDesugared.lf index 2823835687..23d815b46d 100644 --- a/test/Cpp/src/PeriodicDesugared.lf +++ b/test/Cpp/src/PeriodicDesugared.lf @@ -1,29 +1,29 @@ target Cpp { - fast: true, - timeout: 5 secs + fast: true, + timeout: 5 secs } main reactor(offset: time = 50 msec, period: time = 500 msec) { - logical action init(offset): void - logical action recur(period): void - state expected = offset + logical action init(offset): void + logical action recur(period): void + state expected = offset - reaction(startup) -> init {= - std::cout << "Hello from Periodic!\n"; - init.schedule(); - =} + reaction(startup) -> init {= + std::cout << "Hello from Periodic!\n"; + init.schedule(); + =} - reaction(init) -> recur {= recur.schedule(); =} + reaction(init) -> recur {= recur.schedule(); =} - reaction(init, recur) -> recur {= - std::cout << "Periodic trigger!\n"; - auto logical_time = get_elapsed_logical_time(); - std::cout << "Elapsed logical time: " << logical_time << '\n'; - if (logical_time != expected) { - std::cerr << "ERROR: expected " << expected << '\n'; - exit(1); - } - expected += period; - recur.schedule(); - =} + reaction(init, recur) -> recur {= + std::cout << "Periodic trigger!\n"; + auto logical_time = get_elapsed_logical_time(); + std::cout << "Elapsed logical time: " << logical_time << '\n'; + if (logical_time != expected) { + std::cerr << "ERROR: expected " << expected << '\n'; + exit(1); + } + expected += period; + recur.schedule(); + =} } diff --git a/test/Cpp/src/PhysicalConnection.lf b/test/Cpp/src/PhysicalConnection.lf index a3b6b864c7..c42b827765 100644 --- a/test/Cpp/src/PhysicalConnection.lf +++ b/test/Cpp/src/PhysicalConnection.lf @@ -2,37 +2,37 @@ target Cpp reactor Source { - output out: int + output out: int - reaction(startup) -> out {= out.set(42); =} + reaction(startup) -> out {= out.set(42); =} } reactor Destination { - input in: int - - state received: bool(false) - - reaction(in) {= - auto time = get_elapsed_logical_time(); - reactor::log::Info() << "Received " << *in.get() << " at logical time " << time; - if (time == reactor::Duration::zero()) { - reactor::log::Error() << "Logical time should have been greater than zero."; - exit(1); - } - - received = true; - =} - - reaction(shutdown) {= - if (!received) { - reactor::log::Error() << "Nothing received."; - exit(2); - } - =} + input in: int + + state received: bool(false) + + reaction(in) {= + auto time = get_elapsed_logical_time(); + reactor::log::Info() << "Received " << *in.get() << " at logical time " << time; + if (time == reactor::Duration::zero()) { + reactor::log::Error() << "Logical time should have been greater than zero."; + exit(1); + } + + received = true; + =} + + reaction(shutdown) {= + if (!received) { + reactor::log::Error() << "Nothing received."; + exit(2); + } + =} } main reactor { - source = new Source() - destination = new Destination() - source.out ~> destination.in + source = new Source() + destination = new Destination() + source.out ~> destination.in } diff --git a/test/Cpp/src/Pipeline.lf b/test/Cpp/src/Pipeline.lf index cc86ef67a0..49cc4dd212 100644 --- a/test/Cpp/src/Pipeline.lf +++ b/test/Cpp/src/Pipeline.lf @@ -1,44 +1,44 @@ target Cpp { - timeout: 2 sec + timeout: 2 sec } import Computation from "concurrent/Threaded.lf" reactor Print { - input in: int - state count: int = 0 - - reaction(in) {= - std::cout << "Received: " << *in.get() << '\n'; - if (*in.get() != count) { - std::cerr << "ERROR: Expected " << count << '\n'; - exit(1); - } - count++; - =} - - reaction(shutdown) {= - if (count == 1) { - std::cerr << "ERROR: Final reactor received no data.\n"; - exit(3); - } - =} + input in: int + state count: int = 0 + + reaction(in) {= + std::cout << "Received: " << *in.get() << '\n'; + if (*in.get() != count) { + std::cerr << "ERROR: Expected " << count << '\n'; + exit(1); + } + count++; + =} + + reaction(shutdown) {= + if (count == 1) { + std::cerr << "ERROR: Final reactor received no data.\n"; + exit(3); + } + =} } main reactor Pipeline { - timer t(0, 200 msec) - state count: int = 0 + timer t(0, 200 msec) + state count: int = 0 - c1 = new Computation() - c2 = new Computation() - c3 = new Computation() - c4 = new Computation() - p = new Print() + c1 = new Computation() + c2 = new Computation() + c3 = new Computation() + c4 = new Computation() + p = new Print() - c1.out -> c2.in after 200 msec - c2.out -> c3.in after 200 msec - c3.out -> c4.in after 200 msec - c4.out -> p.in + c1.out -> c2.in after 200 msec + c2.out -> c3.in after 200 msec + c3.out -> c4.in after 200 msec + c4.out -> p.in - reaction(t) -> c1.in {= c1.in.set(count++); =} + reaction(t) -> c1.in {= c1.in.set(count++); =} } diff --git a/test/Cpp/src/ReadOutputOfContainedReactor.lf b/test/Cpp/src/ReadOutputOfContainedReactor.lf index c7e85083b4..4e0f17f46e 100644 --- a/test/Cpp/src/ReadOutputOfContainedReactor.lf +++ b/test/Cpp/src/ReadOutputOfContainedReactor.lf @@ -1,52 +1,51 @@ -// Test reacting to and reading outputs from a contained reactor in various -// permutations. +// Test reacting to and reading outputs from a contained reactor in various permutations. target Cpp reactor Contained { - output out: int + output out: int - reaction(startup) -> out {= out.set(42); =} + reaction(startup) -> out {= out.set(42); =} } main reactor ReadOutputOfContainedReactor { - c = new Contained() - state count: int = 0 + c = new Contained() + state count: int = 0 - reaction(startup) c.out {= - std::cout << "Startup reaction reading output of contained " - << "reactor: " << *c.out.get() << std::endl; - if (*c.out.get() != 42) { - std::cout << "FAILURE: expected 42" << std::endl; - exit(2); - } - count++; - =} + reaction(startup) c.out {= + std::cout << "Startup reaction reading output of contained " + << "reactor: " << *c.out.get() << std::endl; + if (*c.out.get() != 42) { + std::cout << "FAILURE: expected 42" << std::endl; + exit(2); + } + count++; + =} - reaction(c.out) {= - std::cout << "Reading output of contained reactor: " << *c.out.get() - << std::endl; - if (*c.out.get() != 42) { - std::cout << "FAILURE: expected 42" << std::endl; - exit(2); - } - count++; - =} + reaction(c.out) {= + std::cout << "Reading output of contained reactor: " << *c.out.get() + << std::endl; + if (*c.out.get() != 42) { + std::cout << "FAILURE: expected 42" << std::endl; + exit(2); + } + count++; + =} - reaction(startup, c.out) {= - std::cout << "Alternate triggering reading output of contained " - << "reactor: " << *c.out.get() << std::endl; - if (*c.out.get() != 42) { - std::cout << "FAILURE: expected 42" << std::endl; - exit(2); - } - count++; - =} + reaction(startup, c.out) {= + std::cout << "Alternate triggering reading output of contained " + << "reactor: " << *c.out.get() << std::endl; + if (*c.out.get() != 42) { + std::cout << "FAILURE: expected 42" << std::endl; + exit(2); + } + count++; + =} - reaction(shutdown) {= - if (count != 3) { - std::cerr << "ERROR: One of the reactions failed to trigger." - << std::endl; - exit(1); - } - =} + reaction(shutdown) {= + if (count != 3) { + std::cerr << "ERROR: One of the reactions failed to trigger." + << std::endl; + exit(1); + } + =} } diff --git a/test/Cpp/src/ScheduleLogicalAction.lf b/test/Cpp/src/ScheduleLogicalAction.lf index 96fd5382b7..a64eac9fe7 100644 --- a/test/Cpp/src/ScheduleLogicalAction.lf +++ b/test/Cpp/src/ScheduleLogicalAction.lf @@ -1,52 +1,52 @@ /** * @author Maiko Brants TU Dresden * - * This checks that a logical action is scheduled the specified logical time - * after the current logical time. + * This checks that a logical action is scheduled the specified logical time after the current + * logical time. * * Modeled after the C version of this test. */ target Cpp { - fast: true, - timeout: 3 sec + fast: true, + timeout: 3 sec } reactor foo { - input x: int - output y: int - logical action a: void + input x: int + output y: int + logical action a: void - reaction(x) -> y, a {= - y.set( 2*(*x.get())); - // The following uses physical time, incorrectly. - a.schedule(500ms); - =} + reaction(x) -> y, a {= + y.set( 2*(*x.get())); + // The following uses physical time, incorrectly. + a.schedule(500ms); + =} - reaction(a) -> y {= y.set(-42); =} + reaction(a) -> y {= y.set(-42); =} } reactor print { - state expected_time: time = 0 - input x: int + state expected_time: time = 0 + input x: int - reaction(x) {= - auto elapsed_time = get_elapsed_logical_time(); - reactor::log::Info() << "Result is " << *x.get(); - reactor::log::Info() << "Current logical time is: " << elapsed_time; - reactor::log::Info() << "Current physical time is: " << get_elapsed_physical_time().count(); - if(elapsed_time != expected_time) { - reactor::log::Error() << "ERROR: Expected logical time to be " << expected_time; - exit(1); - } - expected_time += 500ms; - =} + reaction(x) {= + auto elapsed_time = get_elapsed_logical_time(); + reactor::log::Info() << "Result is " << *x.get(); + reactor::log::Info() << "Current logical time is: " << elapsed_time; + reactor::log::Info() << "Current physical time is: " << get_elapsed_physical_time().count(); + if(elapsed_time != expected_time) { + reactor::log::Error() << "ERROR: Expected logical time to be " << expected_time; + exit(1); + } + expected_time += 500ms; + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x - reaction(t) -> f.x {= f.x.set(42); =} + reaction(t) -> f.x {= f.x.set(42); =} } diff --git a/test/Cpp/src/SelfLoop.lf b/test/Cpp/src/SelfLoop.lf index 2be47e3d4e..8d3188e937 100644 --- a/test/Cpp/src/SelfLoop.lf +++ b/test/Cpp/src/SelfLoop.lf @@ -4,42 +4,42 @@ * Modeled after the C version of this test. */ target Cpp { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Self { - input x: int - output y: int - logical action a: int - state expected: int = 43 + input x: int + output y: int + logical action a: int + state expected: int = 43 - reaction(a) -> y {= - reactor::log::Info() << "a = " << *a.get(); - y.set(*a.get()+1); - =} + reaction(a) -> y {= + reactor::log::Info() << "a = " << *a.get(); + y.set(*a.get()+1); + =} - reaction(x) -> a {= - reactor::log::Info() << "x = " << *x.get(); - if(*x.get() != expected){ - reactor::log::Error() << "Expected " << expected; - exit(1); - } - expected++; - a.schedule(x.get(), 100ms); - =} + reaction(x) -> a {= + reactor::log::Info() << "x = " << *x.get(); + if(*x.get() != expected){ + reactor::log::Error() << "Expected " << expected; + exit(1); + } + expected++; + a.schedule(x.get(), 100ms); + =} - reaction(startup) -> a {= a.schedule(42, 0ns); =} + reaction(startup) -> a {= a.schedule(42, 0ns); =} - reaction(shutdown) {= - if(expected <= 43) { - reactor::log::Error() << "Received no data."; - exit(2); - } - =} + reaction(shutdown) {= + if(expected <= 43) { + reactor::log::Error() << "Received no data."; + exit(2); + } + =} } main reactor SelfLoop { - u = new Self() - u.y -> u.x + u = new Self() + u.y -> u.x } diff --git a/test/Cpp/src/SendingInside.lf b/test/Cpp/src/SendingInside.lf index 2f73122bc8..42d15f2f68 100644 --- a/test/Cpp/src/SendingInside.lf +++ b/test/Cpp/src/SendingInside.lf @@ -1,31 +1,31 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target Cpp { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Printer { - input x: int - state count: int = 1 + input x: int + state count: int = 1 - reaction(x) {= - std::cout << "Inside reactor received: " << *x.get() << std::endl; - if (*x.get() != count) { - std::cerr << "FAILURE: Expected " << count << std::endl; - exit(1); - } - count++; - =} + reaction(x) {= + std::cout << "Inside reactor received: " << *x.get() << std::endl; + if (*x.get() != count) { + std::cerr << "FAILURE: Expected " << count << std::endl; + exit(1); + } + count++; + =} } main reactor SendingInside { - state count: int = 0 - timer t(0, 1 sec) - p = new Printer() + state count: int = 0 + timer t(0, 1 sec) + p = new Printer() - reaction(t) -> p.x {= - count++; - p.x.set(count); - =} + reaction(t) -> p.x {= + count++; + p.x.set(count); + =} } diff --git a/test/Cpp/src/SimpleDeadline.lf b/test/Cpp/src/SimpleDeadline.lf index be10b55d43..57538f5e9f 100644 --- a/test/Cpp/src/SimpleDeadline.lf +++ b/test/Cpp/src/SimpleDeadline.lf @@ -1,42 +1,41 @@ -// Test local deadline, where a deadline is associated with a reaction -// definition. This test triggers a reaction exactly once with a deadline -// violation. +// Test local deadline, where a deadline is associated with a reaction definition. This test +// triggers a reaction exactly once with a deadline violation. target Cpp reactor Deadline(threshold: time = 100 msec) { - private preamble {= - #include - =} - input x: int - output deadlineViolation: bool + private preamble {= + #include + =} + input x: int + output deadlineViolation: bool - reaction(x) -> deadlineViolation {= - std::cerr << "ERROR: Deadline violation was not detected!" << std::endl; - exit(1); - =} deadline(threshold) {= - std::cout << "Deadline violation detected." << std::endl; - deadlineViolation.set(true); - =} + reaction(x) -> deadlineViolation {= + std::cerr << "ERROR: Deadline violation was not detected!" << std::endl; + exit(1); + =} deadline(threshold) {= + std::cout << "Deadline violation detected." << std::endl; + deadlineViolation.set(true); + =} } reactor Print { - input in: bool + input in: bool - reaction(in) {= - if (*in.get()) { - std::cout << "Output successfully produced by deadline handler." - << std::endl; - } - =} + reaction(in) {= + if (*in.get()) { + std::cout << "Output successfully produced by deadline handler." + << std::endl; + } + =} } main reactor SimpleDeadline { - d = new Deadline(threshold = 10 msec) - p = new Print() - d.deadlineViolation -> p.in + d = new Deadline(threshold = 10 msec) + p = new Print() + d.deadlineViolation -> p.in - reaction(startup) -> d.x {= - std::this_thread::sleep_for(std::chrono::milliseconds(20)); - d.x.set(42); - =} + reaction(startup) -> d.x {= + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + d.x.set(42); + =} } diff --git a/test/Cpp/src/SlowingClock.lf b/test/Cpp/src/SlowingClock.lf index adbe93e418..19d475ffe3 100644 --- a/test/Cpp/src/SlowingClock.lf +++ b/test/Cpp/src/SlowingClock.lf @@ -1,43 +1,42 @@ /** * @author Maiko Brants TU Dresden * - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 - * msec on a logical action with a minimum delay of 100 msec. The use of the - * logical action ensures the elapsed time jumps exactly from 0 to 100, 300, - * 600, and 1000 msec. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a logical + * action with a minimum delay of 100 msec. The use of the logical action ensures the elapsed time + * jumps exactly from 0 to 100, 300, 600, and 1000 msec. * * Modeled after the C version of this test. */ target Cpp { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } main reactor SlowingClock { - logical action a(100 msec) - state interval: time = 100 msec - state expected_time: time = 100 msec + logical action a(100 msec) + state interval: time = 100 msec + state expected_time: time = 100 msec - reaction(startup) -> a {= a.schedule(0ns); =} + reaction(startup) -> a {= a.schedule(0ns); =} - reaction(a) -> a {= - auto elapsed_logical_time = get_elapsed_logical_time(); - reactor::log::Info() << "Logical time since start: " << elapsed_logical_time; - if(elapsed_logical_time != expected_time) { - reactor::log::Error() << "Expected time to be: " << expected_time; - exit(1); - } - a.schedule(interval); - expected_time += 100ms + interval; - interval += 100ms; - =} + reaction(a) -> a {= + auto elapsed_logical_time = get_elapsed_logical_time(); + reactor::log::Info() << "Logical time since start: " << elapsed_logical_time; + if(elapsed_logical_time != expected_time) { + reactor::log::Error() << "Expected time to be: " << expected_time; + exit(1); + } + a.schedule(interval); + expected_time += 100ms + interval; + interval += 100ms; + =} - reaction(shutdown) {= - if(expected_time != 1500ms){ - reactor::log::Error() << "Expected the next expected time to be: 1500000000 nsec."; - reactor::log::Error() << "It was: " << expected_time; - } else { - reactor::log::Info() << "Test passes."; - } - =} + reaction(shutdown) {= + if(expected_time != 1500ms){ + reactor::log::Error() << "Expected the next expected time to be: 1500000000 nsec."; + reactor::log::Error() << "It was: " << expected_time; + } else { + reactor::log::Info() << "Test passes."; + } + =} } diff --git a/test/Cpp/src/SlowingClockPhysical.lf b/test/Cpp/src/SlowingClockPhysical.lf index 919f9d6cdf..2d5529f851 100644 --- a/test/Cpp/src/SlowingClockPhysical.lf +++ b/test/Cpp/src/SlowingClockPhysical.lf @@ -1,46 +1,45 @@ /** * @author Maiko Brants TU Dresden * - * Events are scheduled with increasing additional delays of 0, 100, 300, 600 - * msec on a physical action with a minimum delay of 100 msec. The use of the - * physical action makes the elapsed time jumps from 0 to approximately 100 - * msec, to approximatly 300 msec thereafter, drifting away further with each - * new event. + * Events are scheduled with increasing additional delays of 0, 100, 300, 600 msec on a physical + * action with a minimum delay of 100 msec. The use of the physical action makes the elapsed time + * jumps from 0 to approximately 100 msec, to approximatly 300 msec thereafter, drifting away + * further with each new event. * * Modeled after the C version of this test. */ target Cpp { - timeout: 1500 msec + timeout: 1500 msec } main reactor SlowingClockPhysical { - physical action a - state interval: time = 100 msec - state expected_time: time = 100 msec + physical action a + state interval: time = 100 msec + state expected_time: time = 100 msec - reaction(startup) -> a {= - expected_time=100ms; - a.schedule(100ms); - =} + reaction(startup) -> a {= + expected_time=100ms; + a.schedule(100ms); + =} - reaction(a) -> a {= - auto elapsed_logical_time{get_elapsed_logical_time()}; - reactor::log::Info() << "Logical time since start: " << elapsed_logical_time; - if(elapsed_logical_time < expected_time){ - reactor::log::Error() << "Expected logical time to be at least: " << expected_time; - exit(1); - } - interval += 100ms; - expected_time = 100ms + interval; - a.schedule(interval); - reactor::log::Info() << "Scheduling next to occur approximately after: " << interval; - =} + reaction(a) -> a {= + auto elapsed_logical_time{get_elapsed_logical_time()}; + reactor::log::Info() << "Logical time since start: " << elapsed_logical_time; + if(elapsed_logical_time < expected_time){ + reactor::log::Error() << "Expected logical time to be at least: " << expected_time; + exit(1); + } + interval += 100ms; + expected_time = 100ms + interval; + a.schedule(interval); + reactor::log::Info() << "Scheduling next to occur approximately after: " << interval; + =} - reaction(shutdown) {= - if(expected_time < 500ms){ - reactor::log::Error() << "Expected the next expected time to be at least: 500000000 nsec."; - reactor::log::Error() << "It was: " << expected_time; - exit(2); - } - =} + reaction(shutdown) {= + if(expected_time < 500ms){ + reactor::log::Error() << "Expected the next expected time to be at least: 500000000 nsec."; + reactor::log::Error() << "It was: " << expected_time; + exit(2); + } + =} } diff --git a/test/Cpp/src/Stride.lf b/test/Cpp/src/Stride.lf index 5f469e4c70..be44540bb4 100644 --- a/test/Cpp/src/Stride.lf +++ b/test/Cpp/src/Stride.lf @@ -1,29 +1,29 @@ -// This example illustrates state variables and parameters on the wiki. For this -// test, success is just compiling and running. +// This example illustrates state variables and parameters on the wiki. For this test, success is +// just compiling and running. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Count(stride: int = 1) { - state count: int = 0 - output y: int - timer t(0, 100 msec) + state count: int = 0 + output y: int + timer t(0, 100 msec) - reaction(t) -> y {= - y.set(count); - count += stride; - =} + reaction(t) -> y {= + y.set(count); + count += stride; + =} } reactor Display { - input x: int + input x: int - reaction(x) {= std::cout << "Received " << *x.get() << std::endl; =} + reaction(x) {= std::cout << "Received " << *x.get() << std::endl; =} } main reactor Stride { - c = new Count(stride = 2) - d = new Display() - c.y -> d.x + c = new Count(stride = 2) + d = new Display() + c.y -> d.x } diff --git a/test/Cpp/src/StructPrint.lf b/test/Cpp/src/StructPrint.lf index 4ee404b8bf..e59ef45dda 100644 --- a/test/Cpp/src/StructPrint.lf +++ b/test/Cpp/src/StructPrint.lf @@ -2,41 +2,38 @@ target Cpp public preamble {= - #include "include/hello.h" + #include "include/hello.h" =} reactor Source { - output out: Hello + output out: Hello - reaction(startup) -> out {= - // create an dynamically allocated mutable Hello object - auto hello = reactor::make_mutable_value(); - hello->name = "Earth"; - hello->value = 42; - // this implicitly converts the mutable value to an immutable value - out.set(std::move(hello)); - =} + reaction(startup) -> out {= + // create an dynamically allocated mutable Hello object + auto hello = reactor::make_mutable_value(); + hello->name = "Earth"; + hello->value = 42; + // this implicitly converts the mutable value to an immutable value + out.set(std::move(hello)); + =} } -reactor Print( - expected_value: int = 42, - expected_name: {= std::string =} = "Earth" -) { - input in: Hello +reactor Print(expected_value: int = 42, expected_name: {= std::string =} = "Earth") { + input in: Hello - reaction(in) {= - // get a reference to the received struct for convenience - auto& s = *in.get(); - std::cout << "Received: name = " << s.name << ", value = " << s.value << '\n'; - if (s.value != expected_value || s.name != expected_name) { - std::cerr << "ERROR: Expected name = " << expected_name << ", value = " << expected_value << '\n'; - exit(1); - } - =} + reaction(in) {= + // get a reference to the received struct for convenience + auto& s = *in.get(); + std::cout << "Received: name = " << s.name << ", value = " << s.value << '\n'; + if (s.value != expected_value || s.name != expected_name) { + std::cerr << "ERROR: Expected name = " << expected_name << ", value = " << expected_value << '\n'; + exit(1); + } + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p.in + s = new Source() + p = new Print() + s.out -> p.in } diff --git a/test/Cpp/src/StructScale.lf b/test/Cpp/src/StructScale.lf index 776dad14b1..de3bef6579 100644 --- a/test/Cpp/src/StructScale.lf +++ b/test/Cpp/src/StructScale.lf @@ -1,30 +1,29 @@ -// Source produces a dynamically allocated struct, which it passes to Scale. -// Scale requests a writable copy. It modifies it and passes it to Print. It -// gets freed after Print is done with it. +// Source produces a dynamically allocated struct, which it passes to Scale. Scale requests a +// writable copy. It modifies it and passes it to Print. It gets freed after Print is done with it. target Cpp import Source, Print from "StructPrint.lf" public preamble {= - #include "include/hello.h" + #include "include/hello.h" =} reactor Scale(scale: int = 2) { - input in: Hello + input in: Hello - output out: Hello + output out: Hello - reaction(in) -> out {= - auto hello = in.get().get_mutable_copy(); - hello->value *= scale; - out.set(std::move(hello)); - =} + reaction(in) -> out {= + auto hello = in.get().get_mutable_copy(); + hello->value *= scale; + out.set(std::move(hello)); + =} } main reactor StructScale { - s = new Source() - c = new Scale() - p = new Print(expected_value = 84) - s.out -> c.in - c.out -> p.in + s = new Source() + c = new Scale() + p = new Print(expected_value = 84) + s.out -> c.in + c.out -> p.in } diff --git a/test/Cpp/src/TimeLimit.lf b/test/Cpp/src/TimeLimit.lf index 8b33dcd967..a25ebdf07c 100644 --- a/test/Cpp/src/TimeLimit.lf +++ b/test/Cpp/src/TimeLimit.lf @@ -1,49 +1,48 @@ -// Test that the stop function can be used to internally to impose a a time -// limit. Correct output for this 1, 2, 3, 4. Failure for this test is failing -// to halt or getting the wrong data. +// Test that the stop function can be used to internally to impose a a time limit. Correct output +// for this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. target Cpp { - fast: true + fast: true } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - count++; - //std::cout << "Reacting at time " << get_elapsed_logical_time() << '\n'; - y.set(count); - =} + reaction(t) -> y {= + count++; + //std::cout << "Reacting at time " << get_elapsed_logical_time() << '\n'; + y.set(count); + =} } reactor Destination { - input x: int - state s: int = 1 + input x: int + state s: int = 1 - reaction(x) {= - //std::cout << "Received " << *x.get() << '\n'; - if (*x.get() != s) { - std::cerr << "Error: Expected " << s << " and got " << *x.get() << '\n'; - exit(1); - } - s++; - =} + reaction(x) {= + //std::cout << "Received " << *x.get() << '\n'; + if (*x.get() != s) { + std::cerr << "Error: Expected " << s << " and got " << *x.get() << '\n'; + exit(1); + } + s++; + =} - reaction(shutdown) {= - std::cout << "**** shutdown reaction invoked.\n"; - if (s != 12) { - std::cerr << "ERROR: Expected 12 but got " << s << '\n'; - exit(1); - } - =} + reaction(shutdown) {= + std::cout << "**** shutdown reaction invoked.\n"; + if (s != 12) { + std::cerr << "ERROR: Expected 12 but got " << s << '\n'; + exit(1); + } + =} } main reactor TimeLimit(period: time = 1 sec) { - timer stop(10 sec) - c = new Clock(period = period) - d = new Destination() - c.y -> d.x + timer stop(10 sec) + c = new Clock(period = period) + d = new Destination() + c.y -> d.x - reaction(stop) {= environment()->sync_shutdown(); =} + reaction(stop) {= environment()->sync_shutdown(); =} } diff --git a/test/Cpp/src/TimeState.lf b/test/Cpp/src/TimeState.lf index aefac79b1c..01f28e7f85 100644 --- a/test/Cpp/src/TimeState.lf +++ b/test/Cpp/src/TimeState.lf @@ -1,11 +1,11 @@ target Cpp reactor Foo(bar: time = 42 msec) { - state baz = bar + state baz = bar - reaction(startup) {= std::cout << "Baz: " << baz << std::endl; =} + reaction(startup) {= std::cout << "Baz: " << baz << std::endl; =} } main reactor { - a = new Foo() + a = new Foo() } diff --git a/test/Cpp/src/Timeout_Test.lf b/test/Cpp/src/Timeout_Test.lf index c3fe1ffbf9..95971d113a 100644 --- a/test/Cpp/src/Timeout_Test.lf +++ b/test/Cpp/src/Timeout_Test.lf @@ -6,39 +6,39 @@ * Modeled after the C version of this test. */ target Cpp { - timeout: 11 msec + timeout: 11 msec } import Sender from "lib/LoopedActionSender.lf" reactor Consumer { - input in: int - state success: bool = false + input in: int + state success: bool = false - reaction(in) {= - auto current{get_elapsed_logical_time()}; - if(current > 11ms ){ - reactor::log::Error() << "Received at: " << current.count() << ". Failed to enforce timeout."; - exit(1); - } else if(current == 11ms) { - success=true; - } - =} + reaction(in) {= + auto current{get_elapsed_logical_time()}; + if(current > 11ms ){ + reactor::log::Error() << "Received at: " << current.count() << ". Failed to enforce timeout."; + exit(1); + } else if(current == 11ms) { + success=true; + } + =} - reaction(shutdown) {= - reactor::log::Info() << "Shutdown invoked at " << get_elapsed_logical_time(); - if((get_elapsed_logical_time() == 11ms ) && (success == true)){ - reactor::log::Info() << "SUCCESS: successfully enforced timeout."; - } else { - reactor::log::Error() << "Shutdown invoked at: " << get_elapsed_logical_time() << ". Failed to enforce timeout."; - exit(1); - } - =} + reaction(shutdown) {= + reactor::log::Info() << "Shutdown invoked at " << get_elapsed_logical_time(); + if((get_elapsed_logical_time() == 11ms ) && (success == true)){ + reactor::log::Info() << "SUCCESS: successfully enforced timeout."; + } else { + reactor::log::Error() << "Shutdown invoked at: " << get_elapsed_logical_time() << ". Failed to enforce timeout."; + exit(1); + } + =} } main reactor Timeout_Test { - consumer = new Consumer() - producer = new Sender(take_a_break_after = 10, break_interval = 1 msec) + consumer = new Consumer() + producer = new Sender(take_a_break_after = 10, break_interval = 1 msec) - producer.out -> consumer.in + producer.out -> consumer.in } diff --git a/test/Cpp/src/TimerIsPresent.lf b/test/Cpp/src/TimerIsPresent.lf index 4745078dc5..b87b22281e 100644 --- a/test/Cpp/src/TimerIsPresent.lf +++ b/test/Cpp/src/TimerIsPresent.lf @@ -1,54 +1,54 @@ target Cpp { - timeout: 1 sec + timeout: 1 sec } main reactor { - timer t1(0, 50 msec) - timer t2(33 msec, 33 msec) - - reaction(startup) t1, t2 {= - if (!startup.is_present()) { - reactor::log::Error() << "Startup is not present."; - exit(1); - } - - if (!t1.is_present()) { - reactor::log::Error() << "t1 is not present at startup."; + timer t1(0, 50 msec) + timer t2(33 msec, 33 msec) + + reaction(startup) t1, t2 {= + if (!startup.is_present()) { + reactor::log::Error() << "Startup is not present."; + exit(1); + } + + if (!t1.is_present()) { + reactor::log::Error() << "t1 is not present at startup."; + exit(1); + } + + if (t2.is_present()) { + reactor::log::Error() << "t2 is present at startup."; + exit(1); + } + =} + + reaction(t1, t2) {= + if (t1.is_present() && t2.is_present()) { + reactor::log::Error() << "t1 and t2 are both present."; + exit(1); + } + + if (!t1.is_present() && !t2.is_present()) { + reactor::log::Error() << "Neither t1 nor t2 are both present."; + exit(1); + } + =} + + reaction(shutdown) t1, t2 {= + if (!shutdown.is_present()) { + reactor::log::Error() << "Shutdown is not present."; + exit(1); + } + + if (!t1.is_present()) { + reactor::log::Error() << "t1 is not present at shutdown."; exit(1); } if (t2.is_present()) { - reactor::log::Error() << "t2 is present at startup."; + reactor::log::Error() << "t2 is present at shutdown"; exit(1); } - =} - - reaction(t1, t2) {= - if (t1.is_present() && t2.is_present()) { - reactor::log::Error() << "t1 and t2 are both present."; - exit(1); - } - - if (!t1.is_present() && !t2.is_present()) { - reactor::log::Error() << "Neither t1 nor t2 are both present."; - exit(1); - } - =} - - reaction(shutdown) t1, t2 {= - if (!shutdown.is_present()) { - reactor::log::Error() << "Shutdown is not present."; - exit(1); - } - - if (!t1.is_present()) { - reactor::log::Error() << "t1 is not present at shutdown."; - exit(1); - } - - if (t2.is_present()) { - reactor::log::Error() << "t2 is present at shutdown"; - exit(1); - } - =} + =} } diff --git a/test/Cpp/src/ToReactionNested.lf b/test/Cpp/src/ToReactionNested.lf index 5b048bc0a7..6a1997972a 100644 --- a/test/Cpp/src/ToReactionNested.lf +++ b/test/Cpp/src/ToReactionNested.lf @@ -1,37 +1,37 @@ target Cpp { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } import Count from "lib/Count.lf" reactor CountContainer { - output out: int - c1 = new Count() - c1.c -> out + output out: int + c1 = new Count() + c1.c -> out } main reactor { - state count: int = 1 - state received: bool = false + state count: int = 1 + state received: bool = false - s = new CountContainer() + s = new CountContainer() - reaction(s.out) {= - if (s.out.is_present()){ - reactor::log::Info() << "Received " << *s.out.get(); - if(count != *s.out.get()){ - reactor::log::Error() << "Expected " << count; - } - received = true; + reaction(s.out) {= + if (s.out.is_present()){ + reactor::log::Info() << "Received " << *s.out.get(); + if(count != *s.out.get()){ + reactor::log::Error() << "Expected " << count; } - count++; - =} + received = true; + } + count++; + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "No inputs present."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "No inputs present."; + exit(1); + } + =} } diff --git a/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf b/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf index b8c304b164..8bac112717 100644 --- a/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/Cpp/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,43 +1,42 @@ /** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. + * This test checks that a downstream reaction is triggered only if its trigger is present. * * @author Maiko Brants TU Dresden * * Modeled after the C version of this test. */ target Cpp { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Source { - output[2] out: int - state count: int = 0 - timer t(0, 200 msec) + output[2] out: int + state count: int = 0 + timer t(0, 200 msec) - reaction(t) -> out {= - if(count++ % 2 == 0) { - out[0].set(count); - } else { - out[1].set(count); - } - =} + reaction(t) -> out {= + if(count++ % 2 == 0) { + out[0].set(count); + } else { + out[1].set(count); + } + =} } reactor Destination { - input in: int + input in: int - reaction(in) {= - if(!in.is_present()){ - reactor::log::Error() << "Reaction to input of triggered even though all inputs are absent!"; - exit(1); - } - =} + reaction(in) {= + if(!in.is_present()){ + reactor::log::Error() << "Reaction to input of triggered even though all inputs are absent!"; + exit(1); + } + =} } main reactor TriggerDownstreamOnlyIfPresent2 { - s = new Source() - d = new[2] Destination() - s.out -> d.in + s = new Source() + d = new[2] Destination() + s.out -> d.in } diff --git a/test/Cpp/src/concurrent/AsyncCallback.lf b/test/Cpp/src/concurrent/AsyncCallback.lf index 1258f69ce5..fff5b229e0 100644 --- a/test/Cpp/src/concurrent/AsyncCallback.lf +++ b/test/Cpp/src/concurrent/AsyncCallback.lf @@ -1,62 +1,62 @@ // Test asynchronous callbacks that trigger a physical action. target Cpp { - timeout: 2 sec, - cmake-include: "AsyncCallback.cmake" + timeout: 2 sec, + cmake-include: "AsyncCallback.cmake" } main reactor AsyncCallback { - public preamble {= - #include - =} + public preamble {= + #include + =} - timer t(0, 200 msec) - state thread: {= std::thread =} - state expected_time: time = 100 msec - state toggle: bool = false + timer t(0, 200 msec) + state thread: {= std::thread =} + state expected_time: time = 100 msec + state toggle: bool = false - physical action a: int - state i: int = 0 + physical action a: int + state i: int = 0 - reaction(t) -> a {= - // make sure to join the old thread first - if(thread.joinable()) { - thread.join(); - } + reaction(t) -> a {= + // make sure to join the old thread first + if(thread.joinable()) { + thread.join(); + } - // start new thread - this->thread = std::thread([&] () { - // Simulate time passing before a callback occurs - std::this_thread::sleep_for(100ms); - // Schedule twice. If the action is not physical, these should - // get consolidated into a single action triggering. If it is, - // then they cause two separate triggerings with close but not - // equal time stamps. - a.schedule(0); - a.schedule(0); - }); - =} + // start new thread + this->thread = std::thread([&] () { + // Simulate time passing before a callback occurs + std::this_thread::sleep_for(100ms); + // Schedule twice. If the action is not physical, these should + // get consolidated into a single action triggering. If it is, + // then they cause two separate triggerings with close but not + // equal time stamps. + a.schedule(0); + a.schedule(0); + }); + =} - reaction(a) {= - auto elapsed_time = get_elapsed_logical_time(); - std::cout << "Asynchronous callback " << i++ << ": Assigned logical " - << "time greater than start time by " << elapsed_time << std::endl; - if (elapsed_time <= expected_time) { - std::cerr << "ERROR: Expected logical time to be larger than " - << expected_time << std::endl; - exit(1); - } - if (toggle) { - toggle = false; - expected_time += 200ms; - } else { - toggle = true; - } - =} + reaction(a) {= + auto elapsed_time = get_elapsed_logical_time(); + std::cout << "Asynchronous callback " << i++ << ": Assigned logical " + << "time greater than start time by " << elapsed_time << std::endl; + if (elapsed_time <= expected_time) { + std::cerr << "ERROR: Expected logical time to be larger than " + << expected_time << std::endl; + exit(1); + } + if (toggle) { + toggle = false; + expected_time += 200ms; + } else { + toggle = true; + } + =} - reaction(shutdown) {= - // make sure to join the thread before shutting down - if(thread.joinable()) { - thread.join(); - } - =} + reaction(shutdown) {= + // make sure to join the thread before shutting down + if(thread.joinable()) { + thread.join(); + } + =} } diff --git a/test/Cpp/src/concurrent/AsyncCallback2.lf b/test/Cpp/src/concurrent/AsyncCallback2.lf index c89b8ab712..d2f34ea4e6 100644 --- a/test/Cpp/src/concurrent/AsyncCallback2.lf +++ b/test/Cpp/src/concurrent/AsyncCallback2.lf @@ -1,43 +1,43 @@ // Test asynchronous callbacks that trigger a non-physical action. target Cpp { - timeout: 2 sec, - cmake-include: "AsyncCallback.cmake" + timeout: 2 sec, + cmake-include: "AsyncCallback.cmake" } main reactor AsyncCallback2 { - private preamble {= - #include - =} + private preamble {= + #include + =} - timer t(0, 200 msec) - state expected_time: time = 0 + timer t(0, 200 msec) + state expected_time: time = 0 - logical action a: int - state i: int = 0 + logical action a: int + state i: int = 0 - reaction(t) -> a {= - // start new thread - auto thread = std::thread([&] () { - // Simulate time passing before a callback occurs - std::this_thread::sleep_for(100ms); - // Schedule twice. If the action is not physical, these should - // get consolidated into a single action triggering. If it is, - // then they cause two separate triggerings with close but not - // equal time stamps. - a.schedule(0); - a.schedule(0); - }); - thread.join(); - =} + reaction(t) -> a {= + // start new thread + auto thread = std::thread([&] () { + // Simulate time passing before a callback occurs + std::this_thread::sleep_for(100ms); + // Schedule twice. If the action is not physical, these should + // get consolidated into a single action triggering. If it is, + // then they cause two separate triggerings with close but not + // equal time stamps. + a.schedule(0); + a.schedule(0); + }); + thread.join(); + =} - reaction(a) {= - auto elapsed_time = get_elapsed_logical_time(); - std::cout << "Asynchronous callback " << i++ << ": Assigned logical " - << "time greater than start time by " << elapsed_time << std::endl; - if (elapsed_time != expected_time) { - std::cerr << "ERROR: Expected logical time to be " << expected_time << std::endl; - exit(1); - } - expected_time += 200ms; - =} + reaction(a) {= + auto elapsed_time = get_elapsed_logical_time(); + std::cout << "Asynchronous callback " << i++ << ": Assigned logical " + << "time greater than start time by " << elapsed_time << std::endl; + if (elapsed_time != expected_time) { + std::cerr << "ERROR: Expected logical time to be " << expected_time << std::endl; + exit(1); + } + expected_time += 200ms; + =} } diff --git a/test/Cpp/src/concurrent/CompositionThreaded.lf b/test/Cpp/src/concurrent/CompositionThreaded.lf index 42817e8b1d..01cb2b9b17 100644 --- a/test/Cpp/src/concurrent/CompositionThreaded.lf +++ b/test/Cpp/src/concurrent/CompositionThreaded.lf @@ -1,45 +1,44 @@ -// This test connects a simple counting source to tester that checks against its -// own count. +// This test connects a simple counting source to tester that checks against its own count. target Cpp { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period: time = 2 sec) { - output y: int - timer t(1 sec, period) - state count: int = 0 + output y: int + timer t(1 sec, period) + state count: int = 0 - reaction(t) -> y {= - count++; - y.set(count); - =} + reaction(t) -> y {= + count++; + y.set(count); + =} } reactor Test { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - count++; - auto value = *x.get(); - std::cout << "Received " << value << std::endl; - if (value != count) { - std::cerr << "FAILURE: Expected " << count << std::endl; - exit(1); - } - =} + reaction(x) {= + count++; + auto value = *x.get(); + std::cout << "Received " << value << std::endl; + if (value != count) { + std::cerr << "FAILURE: Expected " << count << std::endl; + exit(1); + } + =} - reaction(shutdown) {= - if (count != 5) { - std::cerr << "ERROR: expected to receive 5 values but got " << count << '\n'; - exit(1); - } - =} + reaction(shutdown) {= + if (count != 5) { + std::cerr << "ERROR: expected to receive 5 values but got " << count << '\n'; + exit(1); + } + =} } main reactor { - s = new Source() - d = new Test() - s.y -> d.x + s = new Source() + d = new Test() + s.y -> d.x } diff --git a/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf b/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf index bb380fe14c..548a5d477b 100644 --- a/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf +++ b/test/Cpp/src/concurrent/DeadlineHandledAboveThreaded.lf @@ -1,42 +1,42 @@ -// Test a deadline where the deadline violation produces an output and the -// container reacts to that output. +// Test a deadline where the deadline violation produces an output and the container reacts to that +// output. target Cpp reactor Deadline(threshold: time = 100 msec) { - input x: int - output deadline_violation: bool + input x: int + output deadline_violation: bool - reaction(x) -> deadline_violation {= - std::cerr << "ERROR: Deadline violation was not detected!" << std::endl; - exit(1); - =} deadline(threshold) {= - std::cout << "Deadline violation detected." << std::endl; - deadline_violation.set(true); - =} + reaction(x) -> deadline_violation {= + std::cerr << "ERROR: Deadline violation was not detected!" << std::endl; + exit(1); + =} deadline(threshold) {= + std::cout << "Deadline violation detected." << std::endl; + deadline_violation.set(true); + =} } main reactor { - state violation_detected: bool = {= false =} - d = new Deadline(threshold = 10 msec) + state violation_detected: bool = {= false =} + d = new Deadline(threshold = 10 msec) - reaction(startup) -> d.x {= - std::this_thread::sleep_for(std::chrono::milliseconds(20)); - d.x.set(42); - =} + reaction(startup) -> d.x {= + std::this_thread::sleep_for(std::chrono::milliseconds(20)); + d.x.set(42); + =} - reaction(d.deadline_violation) {= - if (*d.deadline_violation.get()) { - std::cout << "Output successfully produced by deadline miss handler." << std::endl; - violation_detected = true; - } - =} + reaction(d.deadline_violation) {= + if (*d.deadline_violation.get()) { + std::cout << "Output successfully produced by deadline miss handler." << std::endl; + violation_detected = true; + } + =} - reaction(shutdown) {= - if (violation_detected) { - std::cout << "SUCCESS. Test passes." << std::endl; - } else { - std::cerr << "ERROR. Container did not react to deadline violation." << std::endl; - exit(2); - } - =} + reaction(shutdown) {= + if (violation_detected) { + std::cout << "SUCCESS. Test passes." << std::endl; + } else { + std::cerr << "ERROR. Container did not react to deadline violation." << std::endl; + exit(2); + } + =} } diff --git a/test/Cpp/src/concurrent/DeadlineThreaded.lf b/test/Cpp/src/concurrent/DeadlineThreaded.lf index cb794f5050..3a202fd568 100644 --- a/test/Cpp/src/concurrent/DeadlineThreaded.lf +++ b/test/Cpp/src/concurrent/DeadlineThreaded.lf @@ -1,59 +1,58 @@ -// This example illustrates local deadline handling. Even numbers are sent by -// the Source immediately, whereas odd numbers are sent after a big enough delay -// to violate the deadline. +// This example illustrates local deadline handling. Even numbers are sent by the Source +// immediately, whereas odd numbers are sent after a big enough delay to violate the deadline. target Cpp { - timeout: 4 sec + timeout: 4 sec } reactor Source(period: time = 2 sec) { - private preamble {= - #include - =} - output y: int - timer t(0, period) - state count: int = 0 + private preamble {= + #include + =} + output y: int + timer t(0, period) + state count: int = 0 - reaction(t) -> y {= - if (count % 2 == 1) { - // The count variable is odd. - // Take time to cause a deadline violation. - std::this_thread::sleep_for(200ms); - } - std::cout << "Source sends: " << count << std::endl; - y.set(count); - count++; - =} + reaction(t) -> y {= + if (count % 2 == 1) { + // The count variable is odd. + // Take time to cause a deadline violation. + std::this_thread::sleep_for(200ms); + } + std::cout << "Source sends: " << count << std::endl; + y.set(count); + count++; + =} } reactor Destination(timeout: time = 1 sec) { - input x: int - state count: int = 0 + input x: int + state count: int = 0 - reaction(x) {= - std::cout << "Destination receives: " << *x.get() << std::endl; - if (count % 2 == 1) { - // The count variable is odd, so the deadline should have been - // violated - std::cerr << "ERROR: Failed to detect deadline." << std::endl; - exit(1); - } - count++; - =} deadline(timeout) {= - std::cout << "Destination deadline handler receives: " - << *x.get() << std::endl; - if (count % 2 == 0) { - // The count variable is even, so the deadline should not have - // been violated. - std::cerr << "ERROR: Deadline handler invoked without deadline " - << "violation." << std::endl; - exit(2); - } - count++; - =} + reaction(x) {= + std::cout << "Destination receives: " << *x.get() << std::endl; + if (count % 2 == 1) { + // The count variable is odd, so the deadline should have been + // violated + std::cerr << "ERROR: Failed to detect deadline." << std::endl; + exit(1); + } + count++; + =} deadline(timeout) {= + std::cout << "Destination deadline handler receives: " + << *x.get() << std::endl; + if (count % 2 == 0) { + // The count variable is even, so the deadline should not have + // been violated. + std::cerr << "ERROR: Deadline handler invoked without deadline " + << "violation." << std::endl; + exit(2); + } + count++; + =} } main reactor { - s = new Source() - d = new Destination(timeout = 200 msec) - s.y -> d.x + s = new Source() + d = new Destination(timeout = 200 msec) + s.y -> d.x } diff --git a/test/Cpp/src/concurrent/DelayIntThreaded.lf b/test/Cpp/src/concurrent/DelayIntThreaded.lf index 319cae8b76..dc3c2746ee 100644 --- a/test/Cpp/src/concurrent/DelayIntThreaded.lf +++ b/test/Cpp/src/concurrent/DelayIntThreaded.lf @@ -2,53 +2,53 @@ target Cpp reactor Delay(delay: time = 100 msec) { - input in: int - output out: int - logical action d: int + input in: int + output out: int + logical action d: int - reaction(in) -> d {= d.schedule(in.get(), delay); =} + reaction(in) -> d {= d.schedule(in.get(), delay); =} - reaction(d) -> out {= - if (d.is_present()) { - out.set(d.get()); - } - =} + reaction(d) -> out {= + if (d.is_present()) { + out.set(d.get()); + } + =} } reactor Test { - input in: int - state start_time: {= reactor::TimePoint =} - timer start - - reaction(start) {= - // Record the logical time at the start. - start_time = get_logical_time(); - =} - - reaction(in) {= - std::cout << "Received: " << *in.get() << std::endl; - // Check the time of the input. - auto current_time = get_logical_time(); - auto elapsed = current_time - start_time; - std::cout << "After " << elapsed << " of logical time." << std::endl; - if (elapsed != 100ms) { - std::cerr << "ERROR: Expected elapsed time to be 100000000 nsecs. " - << "It was " << elapsed << std::endl; - exit(1); - } - if (*in.get() != 42) { - std::cerr << "ERROR: Expected input value to be 42. " - << "It was " << *in.get() << std::endl; - exit(2); - } - =} + input in: int + state start_time: {= reactor::TimePoint =} + timer start + + reaction(start) {= + // Record the logical time at the start. + start_time = get_logical_time(); + =} + + reaction(in) {= + std::cout << "Received: " << *in.get() << std::endl; + // Check the time of the input. + auto current_time = get_logical_time(); + auto elapsed = current_time - start_time; + std::cout << "After " << elapsed << " of logical time." << std::endl; + if (elapsed != 100ms) { + std::cerr << "ERROR: Expected elapsed time to be 100000000 nsecs. " + << "It was " << elapsed << std::endl; + exit(1); + } + if (*in.get() != 42) { + std::cerr << "ERROR: Expected input value to be 42. " + << "It was " << *in.get() << std::endl; + exit(2); + } + =} } main reactor { - timer t - d = new Delay() - test = new Test() - d.out -> test.in + timer t + d = new Delay() + test = new Test() + d.out -> test.in - reaction(t) -> d.in {= d.in.set(42); =} + reaction(t) -> d.in {= d.in.set(42); =} } diff --git a/test/Cpp/src/concurrent/DoubleReactionThreaded.lf b/test/Cpp/src/concurrent/DoubleReactionThreaded.lf index d68f2e8b60..489782ed94 100644 --- a/test/Cpp/src/concurrent/DoubleReactionThreaded.lf +++ b/test/Cpp/src/concurrent/DoubleReactionThreaded.lf @@ -1,48 +1,48 @@ -// Test that two simultaneous inputs that trigger a reaction trigger it only -// once. Correct output for this 2, 4, 6, 8, etc. +// Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output +// for this 2, 4, 6, 8, etc. target Cpp { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - count++; - y.set(count); - =} + reaction(t) -> y {= + count++; + y.set(count); + =} } reactor Destination { - input x: int - input w: int - state s: int = 2 + input x: int + input w: int + state s: int = 2 - reaction(x, w) {= - int sum = 0; - if (x.is_present()) { - sum += *x.get(); - } - if (w.is_present()) { - sum += *w.get(); - } - std::cout << "Sum of inputs is: " << sum << std::endl; - if (sum != s) { - std::cerr << "FAILURE: Expected sum to be " << s - << "but it was " << sum << std::endl; - exit(1); - } - s += 2; - =} + reaction(x, w) {= + int sum = 0; + if (x.is_present()) { + sum += *x.get(); + } + if (w.is_present()) { + sum += *w.get(); + } + std::cout << "Sum of inputs is: " << sum << std::endl; + if (sum != s) { + std::cerr << "FAILURE: Expected sum to be " << s + << "but it was " << sum << std::endl; + exit(1); + } + s += 2; + =} } main reactor { - c1 = new Clock() - c2 = new Clock() - d = new Destination() - c1.y -> d.x - c2.y -> d.w + c1 = new Clock() + c2 = new Clock() + d = new Destination() + c1.y -> d.x + c2.y -> d.w } diff --git a/test/Cpp/src/concurrent/GainThreaded.lf b/test/Cpp/src/concurrent/GainThreaded.lf index e88801f5a1..ca1a7cc676 100644 --- a/test/Cpp/src/concurrent/GainThreaded.lf +++ b/test/Cpp/src/concurrent/GainThreaded.lf @@ -2,30 +2,30 @@ target Cpp reactor Scale(scale: int = 2) { - input x: int - output y: int + input x: int + output y: int - reaction(x) -> y {= y.set(*x.get() * scale); =} + reaction(x) -> y {= y.set(*x.get() * scale); =} } reactor Test { - input x: int + input x: int - reaction(x) {= - auto value = *x.get(); - std::cout << "Received " << value << std::endl; - if (value != 2) { - std::cerr << "Expected 2!" << std::endl; - exit(1); - } - =} + reaction(x) {= + auto value = *x.get(); + std::cout << "Received " << value << std::endl; + if (value != 2) { + std::cerr << "Expected 2!" << std::endl; + exit(1); + } + =} } main reactor { - g = new Scale() - t = new Test() - g.y -> t.x - timer tim + g = new Scale() + t = new Test() + g.y -> t.x + timer tim - reaction(tim) -> g.x {= g.x.set(1); =} + reaction(tim) -> g.x {= g.x.set(1); =} } diff --git a/test/Cpp/src/concurrent/HelloThreaded.lf b/test/Cpp/src/concurrent/HelloThreaded.lf index 2c849b94dc..790aadf913 100644 --- a/test/Cpp/src/concurrent/HelloThreaded.lf +++ b/test/Cpp/src/concurrent/HelloThreaded.lf @@ -1,56 +1,46 @@ -// This test checks that logical time is incremented an appropriate amount as a -// result of an invocation of the schedule() function at runtime. It also -// performs various smoke tests of timing aligned reactions. The first instance -// has a period of 4 seconds, the second of 2 seconds, and the third (composite) -// or 1 second. +// This test checks that logical time is incremented an appropriate amount as a result of an +// invocation of the schedule() function at runtime. It also performs various smoke tests of timing +// aligned reactions. The first instance has a period of 4 seconds, the second of 2 seconds, and the +// third (composite) or 1 second. target Cpp { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } -reactor HelloCpp( - period: time = 2 sec, - message: {= std::string =} = "Hello C++" -) { - state count: int = 0 - state previous_time: {= reactor::TimePoint =} - timer t(1 sec, period) - logical action a: void +reactor HelloCpp(period: time = 2 sec, message: {= std::string =} = "Hello C++") { + state count: int = 0 + state previous_time: {= reactor::TimePoint =} + timer t(1 sec, period) + logical action a: void - reaction(t) -> a {= - std::cout << message << std::endl; - a.schedule(200ms); // No payload. - // Print the current time. - previous_time = get_logical_time(); - std::cout << "Current time is " << previous_time << std::endl; - =} + reaction(t) -> a {= + std::cout << message << std::endl; + a.schedule(200ms); // No payload. + // Print the current time. + previous_time = get_logical_time(); + std::cout << "Current time is " << previous_time << std::endl; + =} - reaction(a) {= - count++; - auto time = get_logical_time(); - std::cout << "***** action " << count << " at time " - << time << std::endl; - auto diff = time - previous_time; - if (diff != 200ms) { - std::cerr << "FAILURE: Expected 200 msecs of logical time to elapse " - << "but got " << diff << std::endl; - exit(1); - } - =} + reaction(a) {= + count++; + auto time = get_logical_time(); + std::cout << "***** action " << count << " at time " + << time << std::endl; + auto diff = time - previous_time; + if (diff != 200ms) { + std::cerr << "FAILURE: Expected 200 msecs of logical time to elapse " + << "but got " << diff << std::endl; + exit(1); + } + =} } -reactor Inside( - period: time = 1 sec, - message: {= std::string =} = "Composite default message." -) { - third_instance = new HelloCpp(period = period, message = message) +reactor Inside(period: time = 1 sec, message: {= std::string =} = "Composite default message.") { + third_instance = new HelloCpp(period = period, message = message) } main reactor { - first_instance = new HelloCpp( - period = 4 sec, - message = "Hello from first_instance." - ) - second_instance = new HelloCpp(message = "Hello from second_instance.") - composite_instance = new Inside(message = "Hello from composite_instance.") + first_instance = new HelloCpp(period = 4 sec, message = "Hello from first_instance.") + second_instance = new HelloCpp(message = "Hello from second_instance.") + composite_instance = new Inside(message = "Hello from composite_instance.") } diff --git a/test/Cpp/src/concurrent/SendingInsideThreaded.lf b/test/Cpp/src/concurrent/SendingInsideThreaded.lf index 51ca511e26..f4b4dd2560 100644 --- a/test/Cpp/src/concurrent/SendingInsideThreaded.lf +++ b/test/Cpp/src/concurrent/SendingInsideThreaded.lf @@ -1,31 +1,31 @@ -// This tests a reactor that contains another reactor and also has its own -// reaction that routes inputs to the contained reactor. +// This tests a reactor that contains another reactor and also has its own reaction that routes +// inputs to the contained reactor. target Cpp { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Printer { - input x: int - state count: int = 1 + input x: int + state count: int = 1 - reaction(x) {= - std::cout << "Inside reactor received: " << *x.get() << std::endl; - if (*x.get() != count) { - std::cerr << "FAILURE: Expected " << count << std::endl; - exit(1); - } - count++; - =} + reaction(x) {= + std::cout << "Inside reactor received: " << *x.get() << std::endl; + if (*x.get() != count) { + std::cerr << "FAILURE: Expected " << count << std::endl; + exit(1); + } + count++; + =} } main reactor { - state count: int = 0 - timer t(0, 1 sec) - p = new Printer() + state count: int = 0 + timer t(0, 1 sec) + p = new Printer() - reaction(t) -> p.x {= - count++; - p.x.set(count); - =} + reaction(t) -> p.x {= + count++; + p.x.set(count); + =} } diff --git a/test/Cpp/src/concurrent/Threaded.lf b/test/Cpp/src/concurrent/Threaded.lf index 9ad4fcbe56..382c3bfa7c 100644 --- a/test/Cpp/src/concurrent/Threaded.lf +++ b/test/Cpp/src/concurrent/Threaded.lf @@ -1,70 +1,68 @@ -// Check for speedup of multithreaded execution on multicore machines. Each -// instance of TakeTime takes 200 ms to transport the input to the output. Four -// of them are instantiated. Note that without parallel execution, there is no -// way this can keep up with real time since in every 200 msec cycle it has 800 -// msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded -// version, showing that without threads, this takes more than 800 msec to -// complete 200 msec of logical time. +// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime +// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that +// without parallel execution, there is no way this can keep up with real time since in every 200 +// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing +// that without threads, this takes more than 800 msec to complete 200 msec of logical time. target Cpp { - timeout: 2 sec + timeout: 2 sec } reactor Source { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - out.set(s); - s++; - =} + reaction(t) -> out {= + out.set(s); + s++; + =} } reactor Computation { - private preamble {= - #include - =} - input in: int - output out: int + private preamble {= + #include + =} + input in: int + output out: int - reaction(in) -> out {= - std::this_thread::sleep_for(200ms); - out.set(in.get()); - =} + reaction(in) -> out {= + std::this_thread::sleep_for(200ms); + out.set(in.get()); + =} } reactor Destination { - state s: int = 0 - input in1: int - input in2: int - input in3: int - input in4: int + state s: int = 0 + input in1: int + input in2: int + input in3: int + input in4: int - reaction(in1, in2, in3, in4) {= - int sum = *in1.get() + *in2.get() + *in3.get() + *in4.get(); - std::cout << "Sum of received: " << sum << '\n'; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << '\n'; - exit(1); - } - s += 4; - =} + reaction(in1, in2, in3, in4) {= + int sum = *in1.get() + *in2.get() + *in3.get() + *in4.get(); + std::cout << "Sum of received: " << sum << '\n'; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << '\n'; + exit(1); + } + s += 4; + =} } main reactor { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination() - a.out -> t1.in - a.out -> t2.in - a.out -> t3.in - a.out -> t4.in - t1.out -> b.in1 - t2.out -> b.in2 - t3.out -> b.in3 - t4.out -> b.in4 + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination() + a.out -> t1.in + a.out -> t2.in + a.out -> t3.in + a.out -> t4.in + t1.out -> b.in1 + t2.out -> b.in2 + t3.out -> b.in3 + t4.out -> b.in4 } diff --git a/test/Cpp/src/concurrent/ThreadedThreaded.lf b/test/Cpp/src/concurrent/ThreadedThreaded.lf index f8b21a6121..8e51ef0ccb 100644 --- a/test/Cpp/src/concurrent/ThreadedThreaded.lf +++ b/test/Cpp/src/concurrent/ThreadedThreaded.lf @@ -1,61 +1,59 @@ -// Check for speedup of multithreaded execution on multicore machines. Each -// instance of TakeTime takes 200 ms to transport the input to the output. Four -// of them are instantiated. Note that without parallel execution, there is no -// way this can keep up with real time since in every 200 msec cycle it has 800 -// msec of work to do. On a quad-core machine, however, it does pretty well, -// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded -// version, showing that without threads, this takes more than 800 msec to -// complete 200 msec of logical time. +// Check for speedup of multithreaded execution on multicore machines. Each instance of TakeTime +// takes 200 ms to transport the input to the output. Four of them are instantiated. Note that +// without parallel execution, there is no way this can keep up with real time since in every 200 +// msec cycle it has 800 msec of work to do. On a quad-core machine, however, it does pretty well, +// completing 800 msec of work in about 225 msec. NOTE: This is the non-threaded version, showing +// that without threads, this takes more than 800 msec to complete 200 msec of logical time. target Cpp { - timeout: 2 sec + timeout: 2 sec } reactor Source { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - out.set(s); - s++; - =} + reaction(t) -> out {= + out.set(s); + s++; + =} } reactor Computation { - private preamble {= - #include - =} - input in: int - output out: int + private preamble {= + #include + =} + input in: int + output out: int - reaction(in) -> out {= - std::this_thread::sleep_for(200ms); - out.set(in.get()); - =} + reaction(in) -> out {= + std::this_thread::sleep_for(200ms); + out.set(in.get()); + =} } reactor Destination { - state s: int = 0 - input[4] in: int + state s: int = 0 + input[4] in: int - reaction(in) {= - int sum = 0; - for (std::size_t i = 0; i < in.size(); i++) { - if (in[i].is_present()) sum += *in[i].get(); - } - std::cout << "Sum of received: " << sum << '\n'; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << '\n'; - exit(1); - } - s += 4; - =} + reaction(in) {= + int sum = 0; + for (std::size_t i = 0; i < in.size(); i++) { + if (in[i].is_present()) sum += *in[i].get(); + } + std::cout << "Sum of received: " << sum << '\n'; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << '\n'; + exit(1); + } + s += 4; + =} } main reactor { - a = new Source() - t = new[4] Computation() - b = new Destination() - (a.out)+ -> t.in - t.out -> b.in + a = new Source() + t = new[4] Computation() + b = new Destination() + (a.out)+ -> t.in + t.out -> b.in } diff --git a/test/Cpp/src/concurrent/TimeLimitThreaded.lf b/test/Cpp/src/concurrent/TimeLimitThreaded.lf index 47371f72d7..195ccef79f 100644 --- a/test/Cpp/src/concurrent/TimeLimitThreaded.lf +++ b/test/Cpp/src/concurrent/TimeLimitThreaded.lf @@ -1,50 +1,49 @@ -// Test that the stop function can be used to internally to impose a a time -// limit. This is also used to test performance (number of reactions per -// second). Correct output for this 1, 2, 3, 4. Failure for this test is failing -// to halt or getting the wrong data. +// Test that the stop function can be used to internally to impose a a time limit. This is also used +// to test performance (number of reactions per second). Correct output for this 1, 2, 3, 4. Failure +// for this test is failing to halt or getting the wrong data. target Cpp { - fast: true + fast: true } reactor Clock(offset: time = 0, period: time = 1 sec) { - output y: int - timer t(offset, period) - state count: int = 0 + output y: int + timer t(offset, period) + state count: int = 0 - reaction(t) -> y {= - count++; - //std::cout << "Reacting at time " << get_elapsed_logical_time() << '\n'; - y.set(count); - =} + reaction(t) -> y {= + count++; + //std::cout << "Reacting at time " << get_elapsed_logical_time() << '\n'; + y.set(count); + =} } reactor Destination { - input x: int - state s: int = 1 + input x: int + state s: int = 1 - reaction(x) {= - //std::cout << "Received " << *x.get() << '\n'; - if (*x.get() != s) { - std::cerr << "Error: Expected " << s << " and got " << *x.get() << '\n'; - exit(1); - } - s++; - =} + reaction(x) {= + //std::cout << "Received " << *x.get() << '\n'; + if (*x.get() != s) { + std::cerr << "Error: Expected " << s << " and got " << *x.get() << '\n'; + exit(1); + } + s++; + =} - reaction(shutdown) {= - std::cout << "**** shutdown reaction invoked.\n"; - if (s != 12) { - std::cerr << "ERROR: Expected 12 but got " << s << '\n'; - exit(1); - } - =} + reaction(shutdown) {= + std::cout << "**** shutdown reaction invoked.\n"; + if (s != 12) { + std::cerr << "ERROR: Expected 12 but got " << s << '\n'; + exit(1); + } + =} } main reactor(period: time = 1 sec) { - timer stop(10 sec) - c = new Clock(period = period) - d = new Destination() - c.y -> d.x + timer stop(10 sec) + c = new Clock(period = period) + d = new Destination() + c.y -> d.x - reaction(stop) {= environment()->sync_shutdown(); =} + reaction(stop) {= environment()->sync_shutdown(); =} } diff --git a/test/Cpp/src/enclave/EnclaveBank.lf b/test/Cpp/src/enclave/EnclaveBank.lf index 8894526927..64d1cba5a2 100644 --- a/test/Cpp/src/enclave/EnclaveBank.lf +++ b/test/Cpp/src/enclave/EnclaveBank.lf @@ -1,29 +1,29 @@ // This is a smoke test for an enclaved bank target Cpp { - timeout: 3 sec + timeout: 3 sec } reactor Node( - bank_index: size_t = 0, - id: std::string = {= "node" + std::to_string(bank_index) =}, - period: time = 500 msec, - duration: time = 10 msec + bank_index: size_t = 0, + id: std::string = {= "node" + std::to_string(bank_index) =}, + period: time = 500 msec, + duration: time = 10 msec ) { - logical action a: void + logical action a: void - reaction(startup, a) -> a {= - reactor::log::Info() << id << " reaction executes."; - std::this_thread::sleep_for(duration); - reactor::log::Info() << id << " reaction done."; - a.schedule(period); - =} deadline(period) {= - reactor::log::Error() << id << " deadline was violated!"; - exit(1); - =} + reaction(startup, a) -> a {= + reactor::log::Info() << id << " reaction executes."; + std::this_thread::sleep_for(duration); + reactor::log::Info() << id << " reaction done."; + a.schedule(period); + =} deadline(period) {= + reactor::log::Error() << id << " deadline was violated!"; + exit(1); + =} } main reactor { - slow = new Node(id = "slow", period = 1 sec, duration = 500 msec) - @enclave - nodes = new[2] Node() + slow = new Node(id = "slow", period = 1 sec, duration = 500 msec) + @enclave + nodes = new[2] Node() } diff --git a/test/Cpp/src/enclave/EnclaveBankEach.lf b/test/Cpp/src/enclave/EnclaveBankEach.lf index c6cdeac564..e4c497f422 100644 --- a/test/Cpp/src/enclave/EnclaveBankEach.lf +++ b/test/Cpp/src/enclave/EnclaveBankEach.lf @@ -1,30 +1,29 @@ -// This is a smoke test for an enclaved bank where each individual instance is -// an enclave +// This is a smoke test for an enclaved bank where each individual instance is an enclave target Cpp { - timeout: 1 sec + timeout: 1 sec } reactor Node( - bank_index: size_t = 0, - id: std::string = {= "node" + std::to_string(bank_index) =}, - period: {= reactor::Duration =} = {= 100ms * (bank_index+1) =}, - duration: {= reactor::Duration =} = {= 50ms + 100ms * bank_index =} + bank_index: size_t = 0, + id: std::string = {= "node" + std::to_string(bank_index) =}, + period: {= reactor::Duration =} = {= 100ms * (bank_index+1) =}, + duration: {= reactor::Duration =} = {= 50ms + 100ms * bank_index =} ) { - logical action a: void + logical action a: void - reaction(startup, a) -> a {= - reactor::log::Info() << id << " reaction executes."; - std::this_thread::sleep_for(duration); - reactor::log::Info() << id << " reaction done."; - a.schedule(period); - =} deadline(600 msec) {= - reactor::log::Error() << id << " deadline was violated!"; - exit(1); - =} + reaction(startup, a) -> a {= + reactor::log::Info() << id << " reaction executes."; + std::this_thread::sleep_for(duration); + reactor::log::Info() << id << " reaction done."; + a.schedule(period); + =} deadline(600 msec) {= + reactor::log::Error() << id << " deadline was violated!"; + exit(1); + =} } main reactor { - slow = new Node(id = "slow", period = {= 1s =}, duration = {= 700ms =}) - @enclave(each = true) - nodes = new[2] Node() + slow = new Node(id = "slow", period = {= 1s =}, duration = {= 700ms =}) + @enclave(each = true) + nodes = new[2] Node() } diff --git a/test/Cpp/src/enclave/EnclaveBroadcast.lf b/test/Cpp/src/enclave/EnclaveBroadcast.lf index 04a2a77941..cc4a110f13 100644 --- a/test/Cpp/src/enclave/EnclaveBroadcast.lf +++ b/test/Cpp/src/enclave/EnclaveBroadcast.lf @@ -1,39 +1,39 @@ target Cpp { - timeout: 1 sec + timeout: 1 sec } reactor Source { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(42); =} + reaction(startup) -> out {= out.set(42); =} } reactor Sink(bank_index: size_t = 0) { - input in: unsigned + input in: unsigned - state received: bool = false + state received: bool = false - reaction(in) {= - received = true; - std::cout << "Received " << *in.get() << '\n'; - if (*in.get() != 42) { - std::cerr << "Error: expected " << 42 << "!\n"; - exit(1); - } - =} + reaction(in) {= + received = true; + std::cout << "Received " << *in.get() << '\n'; + if (*in.get() != 42) { + std::cerr << "Error: expected " << 42 << "!\n"; + exit(1); + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "Error: Sink " << bank_index << " didn't receive anything.\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: Sink " << bank_index << " didn't receive anything.\n"; + exit(2); + } + =} } main reactor { - @enclave - source = new Source() - @enclave(each = true) - sink = new[4] Sink() - (source.out)+ -> sink.in + @enclave + source = new Source() + @enclave(each = true) + sink = new[4] Sink() + (source.out)+ -> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunication.lf b/test/Cpp/src/enclave/EnclaveCommunication.lf index b780dad109..17c8ee9242 100644 --- a/test/Cpp/src/enclave/EnclaveCommunication.lf +++ b/test/Cpp/src/enclave/EnclaveCommunication.lf @@ -1,44 +1,44 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output out: int - state counter: int = 0 + timer t(0, 100 ms) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 100ms * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in + src.out -> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunication2.lf b/test/Cpp/src/enclave/EnclaveCommunication2.lf index 648223fb0b..9451f455e2 100644 --- a/test/Cpp/src/enclave/EnclaveCommunication2.lf +++ b/test/Cpp/src/enclave/EnclaveCommunication2.lf @@ -1,43 +1,43 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output out: int - state counter: int = 0 + timer t(0, 100 ms) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 100ms * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } main reactor { - src = new Src() - @enclave - sink = new Sink() + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in + src.out -> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf index 6bbab0a700..36afcecd34 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayed.lf @@ -1,44 +1,44 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output out: int - state counter: int = 0 + timer t(0, 100 ms) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 100ms * value + 50ms; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value + 50ms; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in after 50 ms + src.out -> sink.in after 50 ms } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayed2.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayed2.lf index 9cfa3f0a11..5c51a84850 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationDelayed2.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayed2.lf @@ -1,43 +1,43 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output out: int - state counter: int = 0 + timer t(0, 100 ms) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 100ms * value + 50ms; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value + 50ms; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } main reactor { - src = new Src() - @enclave - sink = new Sink() + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in after 50 ms + src.out -> sink.in after 50 ms } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf index fa9c7b25e4..5c2ea549ea 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf @@ -1,47 +1,47 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output out: int - state counter: int = 0 + timer t(0, 100 ms) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 50 ms) - input in: int - state received: bool = false - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 100ms * value + 50ms; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value + 50ms; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in after 50 ms + src.out -> sink.in after 50 ms } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf index 3a0edfd7e5..a8a93dabbe 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationLocalEvents.lf @@ -1,47 +1,47 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output out: int - state counter: int = 0 + timer t(0, 100 ms) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 50 ms) - input in: int - state received: bool = false - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 100ms * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in + src.out -> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf index 4a74085dbc..a853b023a3 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBank.lf @@ -1,57 +1,57 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output[4] out: int - state counter: int = 0 - - reaction(t) -> out {= - for (auto& port : out) { - port.set(counter++); - } - =} + timer t(0, 100 ms) + output[4] out: int + state counter: int = 0 + + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50 ms) - input in: int - state received: bool = false - state iteration: int = 0 - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); - auto expected = 100ms * iteration; - if (value != iteration*4 + bank_index) { - reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; - exit(1); - } - iteration++; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expected value at " << expected; - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + state iteration: int = 0 + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected; + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new[4] Sink() + @enclave + src = new Src() + @enclave + sink = new[4] Sink() - src.out -> sink.in + src.out -> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf index 682b812d4a..3b716ddbb7 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankDelayed.lf @@ -1,57 +1,57 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output[4] out: int - state counter: int = 0 - - reaction(t) -> out {= - for (auto& port : out) { - port.set(counter++); - } - =} + timer t(0, 100 ms) + output[4] out: int + state counter: int = 0 + + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50 ms) - input in: int - state received: bool = false - state iteration: int = 0 - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); - auto expected = 100ms * iteration + 50ms; - if (value != iteration*4 + bank_index) { - reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; - exit(1); - } - iteration++; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expected value at " << expected; - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + state iteration: int = 0 + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration + 50ms; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected; + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new[4] Sink() + @enclave + src = new Src() + @enclave + sink = new[4] Sink() - src.out -> sink.in after 50 ms + src.out -> sink.in after 50 ms } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf index e926019572..bf1dcc9a6d 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEach.lf @@ -1,57 +1,57 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output[4] out: int - state counter: int = 0 - - reaction(t) -> out {= - for (auto& port : out) { - port.set(counter++); - } - =} + timer t(0, 100 ms) + output[4] out: int + state counter: int = 0 + + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50 ms) - input in: int - state received: bool = false - state iteration: int = 0 - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); - auto expected = 100ms * iteration; - if (value != iteration*4 + bank_index) { - reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; - exit(1); - } - iteration++; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expected value at " << expected; - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + state iteration: int = 0 + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected; + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave(each = true) - sink = new[4] Sink() + @enclave + src = new Src() + @enclave(each = true) + sink = new[4] Sink() - src.out -> sink.in + src.out -> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf index 238edf7bfc..0da4f978d7 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachDelayed.lf @@ -1,57 +1,57 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output[4] out: int - state counter: int = 0 - - reaction(t) -> out {= - for (auto& port : out) { - port.set(counter++); - } - =} + timer t(0, 100 ms) + output[4] out: int + state counter: int = 0 + + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50 ms) - input in: int - state received: bool = false - state iteration: int = 0 - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); - auto expected = 100ms * iteration + 50ms; - if (value != iteration*4 + bank_index) { - reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; - exit(1); - } - iteration++; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expected value at " << expected; - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + state iteration: int = 0 + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration + 50ms; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected; + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave(each = true) - sink = new[4] Sink() + @enclave + src = new Src() + @enclave(each = true) + sink = new[4] Sink() - src.out -> sink.in after 50 ms + src.out -> sink.in after 50 ms } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf index 15eb6faf68..87d498d3c8 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankEachPhysical.lf @@ -1,57 +1,57 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output[4] out: int - state counter: int = 0 - - reaction(t) -> out {= - for (auto& port : out) { - port.set(counter++); - } - =} + timer t(0, 100 ms) + output[4] out: int + state counter: int = 0 + + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50 ms) - input in: int - state received: bool = false - state iteration: int = 0 - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); - auto expected = 100ms * iteration; - if (value != iteration*4 + bank_index) { - reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; - exit(1); - } - iteration++; - if (get_elapsed_logical_time() < expected) { - reactor::log::Error() << "Expected value not before " << expected; - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + state iteration: int = 0 + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected; + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave(each = true) - sink = new[4] Sink() + @enclave + src = new Src() + @enclave(each = true) + sink = new[4] Sink() - src.out ~> sink.in + src.out ~> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf index 3867a7a627..84b933d475 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationMultiportToBankPhysical.lf @@ -1,57 +1,57 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output[4] out: int - state counter: int = 0 - - reaction(t) -> out {= - for (auto& port : out) { - port.set(counter++); - } - =} + timer t(0, 100 ms) + output[4] out: int + state counter: int = 0 + + reaction(t) -> out {= + for (auto& port : out) { + port.set(counter++); + } + =} } reactor Sink(bank_index: std::size_t = 0) { - timer t(0, 50 ms) - input in: int - state received: bool = false - state iteration: int = 0 - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); - auto expected = 100ms * iteration; - if (value != iteration*4 + bank_index) { - reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; - exit(1); - } - iteration++; - if (get_elapsed_logical_time() < expected) { - reactor::log::Error() << "Expected value not before " << expected; - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + state iteration: int = 0 + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * iteration; + if (value != iteration*4 + bank_index) { + reactor::log::Error() << "Expected to recive " << iteration*4 + bank_index; + exit(1); + } + iteration++; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected; + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new[4] Sink() + @enclave + src = new Src() + @enclave + sink = new[4] Sink() - src.out ~> sink.in + src.out ~> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf b/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf index ee3ab7f80b..19e49b0642 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationPhysical.lf @@ -1,44 +1,44 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output out: int - state counter: int = 0 + timer t(0, 100 ms) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); - auto expected = 100ms * value; - if (get_elapsed_logical_time() < expected) { - reactor::log::Error() << "Expecded value not before " << expected; - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expecded value not before " << expected; + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out ~> sink.in + src.out ~> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf index aa9c042502..e4467680db 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationPhysicalLocalEvents.lf @@ -1,47 +1,47 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Src { - timer t(0, 100 ms) - output out: int - state counter: int = 0 + timer t(0, 100 ms) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 50 ms) - input in: int - state received: bool = false - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); - auto expected = 100ms * value; - if (get_elapsed_logical_time() < expected) { - reactor::log::Error() << "Expecded value not before " << expected; - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} + timer t(0, 50 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value << " at " << get_elapsed_logical_time(); + auto expected = 100ms * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expecded value not before " << expected; + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out ~> sink.in + src.out ~> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveCycle.lf b/test/Cpp/src/enclave/EnclaveCycle.lf index d073c801c8..5643ba824c 100644 --- a/test/Cpp/src/enclave/EnclaveCycle.lf +++ b/test/Cpp/src/enclave/EnclaveCycle.lf @@ -1,67 +1,67 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Ping { - timer t(0, 100 ms) - input in: int - output out: int - state counter: int = 0 - state received: bool = false + timer t(0, 100 ms) + input in: int + output out: int + state counter: int = 0 + state received: bool = false - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Ping Received " << value; - auto expected = 50ms + 100ms * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Ping Received " << value; + auto expected = 50ms + 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } reactor Pong { - input in: int - output out: int - state received: bool = false + input in: int + output out: int + state received: bool = false - reaction(in) -> out {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Pong Received " << value; - auto expected = 100ms * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - out.set(value); - =} + reaction(in) -> out {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Pong Received " << value; + auto expected = 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + out.set(value); + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } main reactor { - @enclave - ping = new Ping() - @enclave - pong = new Pong() + @enclave + ping = new Ping() + @enclave + pong = new Pong() - ping.out -> pong.in - pong.out -> ping.in after 50 ms + ping.out -> pong.in + pong.out -> ping.in after 50 ms } diff --git a/test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf b/test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf index f347aa53a4..5a0310573d 100644 --- a/test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf +++ b/test/Cpp/src/enclave/EnclaveCycleTwoTimers.lf @@ -1,70 +1,70 @@ target Cpp { - timeout: 1 s, - workers: 1 + timeout: 1 s, + workers: 1 } reactor Ping { - timer t(0, 100 ms) - input in: int - output out: int - state counter: int = 0 - state received: bool = false + timer t(0, 100 ms) + input in: int + output out: int + state counter: int = 0 + state received: bool = false - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Ping Received " << value; - auto expected = 50ms + 100ms * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Ping Received " << value; + auto expected = 50ms + 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } reactor Pong { - timer t(0, 100 ms) - input in: int - output out: int - state counter: int = 0 - state received: bool = false + timer t(0, 100 ms) + input in: int + output out: int + state counter: int = 0 + state received: bool = false - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Pong Received " << value; - auto expected = 50ms + 100ms * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Pong Received " << value; + auto expected = 50ms + 100ms * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} } main reactor { - @enclave - ping = new Ping() - @enclave - pong = new Pong() + @enclave + ping = new Ping() + @enclave + pong = new Pong() - ping.out -> pong.in after 50 ms - pong.out -> ping.in after 50 ms + ping.out -> pong.in after 50 ms + pong.out -> ping.in after 50 ms } diff --git a/test/Cpp/src/enclave/EnclaveHelloWorld.lf b/test/Cpp/src/enclave/EnclaveHelloWorld.lf index 7ca051533b..7947dd0bf4 100644 --- a/test/Cpp/src/enclave/EnclaveHelloWorld.lf +++ b/test/Cpp/src/enclave/EnclaveHelloWorld.lf @@ -1,12 +1,12 @@ target Cpp reactor Hello(msg: std::string = "World") { - reaction(startup) {= reactor::log::Info() << "Hello " << msg << '!'; =} + reaction(startup) {= reactor::log::Info() << "Hello " << msg << '!'; =} } main reactor(msg1: std::string = "World", msg2: std::string = "Enclave") { - hello1 = new Hello(msg = msg1) + hello1 = new Hello(msg = msg1) - @enclave - hello2 = new Hello(msg = msg2) + @enclave + hello2 = new Hello(msg = msg2) } diff --git a/test/Cpp/src/enclave/EnclaveHierarchy.lf b/test/Cpp/src/enclave/EnclaveHierarchy.lf index 9063942575..3fd3b6d528 100644 --- a/test/Cpp/src/enclave/EnclaveHierarchy.lf +++ b/test/Cpp/src/enclave/EnclaveHierarchy.lf @@ -1,41 +1,37 @@ // This is a smoke test for nested enclaves target Cpp { - timeout: 3 sec + timeout: 3 sec } -reactor Node( - id: std::string = "node", - period: time = 100 msec, - duration: time = 50 msec -) { - timer t(0, period) +reactor Node(id: std::string = "node", period: time = 100 msec, duration: time = 50 msec) { + timer t(0, period) - reaction(t) {= - reactor::log::Info() << id << " reaction executes."; - std::this_thread::sleep_for(duration); - reactor::log::Info() << id << " reaction done."; - =} deadline(300 msec) {= - reactor::log::Error() << id << " deadline was violated!"; - exit(1); - =} + reaction(t) {= + reactor::log::Info() << id << " reaction executes."; + std::this_thread::sleep_for(duration); + reactor::log::Info() << id << " reaction done."; + =} deadline(300 msec) {= + reactor::log::Error() << id << " deadline was violated!"; + exit(1); + =} } reactor MiddleNode { - @enclave - inner = new Node(id = "inner", period = 1 sec, duration = 400 msec) + @enclave + inner = new Node(id = "inner", period = 1 sec, duration = 400 msec) - middle = new Node(id = "middle", period = 200 msec, duration = 70 msec) + middle = new Node(id = "middle", period = 200 msec, duration = 70 msec) } reactor OuterNode { - @enclave - middle = new MiddleNode() + @enclave + middle = new MiddleNode() - outer = new Node(id = "outer", period = 500 msec, duration = 200 msec) + outer = new Node(id = "outer", period = 500 msec, duration = 200 msec) } main reactor { - outer = new OuterNode() - @enclave - node = new Node(id = "node", period = 2 sec, duration = 500 msec) + outer = new OuterNode() + @enclave + node = new Node(id = "node", period = 2 sec, duration = 500 msec) } diff --git a/test/Cpp/src/enclave/EnclaveMultiportToPort.lf b/test/Cpp/src/enclave/EnclaveMultiportToPort.lf index 027de94bfb..e5eb8dac90 100644 --- a/test/Cpp/src/enclave/EnclaveMultiportToPort.lf +++ b/test/Cpp/src/enclave/EnclaveMultiportToPort.lf @@ -1,49 +1,48 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output[2] out: int + output[2] out: int - reaction(startup) -> out {= - for(int i = 0; i < out.size(); i++) { - std::cout << "Source sending " << i << ".\n"; - out[i].set(i); - } - =} + reaction(startup) -> out {= + for(int i = 0; i < out.size(); i++) { + std::cout << "Source sending " << i << ".\n"; + out[i].set(i); + } + =} } reactor Destination(expected: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - std::cout << "Received: " << *in.get() << ".\n"; - received = true; - if (*in.get() != expected) { - std::cerr << "ERROR: Expected " << expected << ".\n"; - exit(1); - } - =} + reaction(in) {= + std::cout << "Received: " << *in.get() << ".\n"; + received = true; + if (*in.get() != expected) { + std::cerr << "ERROR: Expected " << expected << ".\n"; + exit(1); + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor { - @enclave - a = new Source() - @enclave - b1 = new Destination() - @enclave - b2 = new Destination(expected = 1) - a.out -> b1.in, b2.in + @enclave + a = new Source() + @enclave + b1 = new Destination() + @enclave + b2 = new Destination(expected = 1) + a.out -> b1.in, b2.in } diff --git a/test/Cpp/src/enclave/EnclaveMultiportToPort2.lf b/test/Cpp/src/enclave/EnclaveMultiportToPort2.lf index 5d8d72494d..7f3c5ff938 100644 --- a/test/Cpp/src/enclave/EnclaveMultiportToPort2.lf +++ b/test/Cpp/src/enclave/EnclaveMultiportToPort2.lf @@ -1,48 +1,47 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output[2] out: int + output[2] out: int - reaction(startup) -> out {= - for(int i = 0; i < out.size(); i++) { - std::cout << "Source sending " << i << ".\n"; - out[i].set(i); - } - =} + reaction(startup) -> out {= + for(int i = 0; i < out.size(); i++) { + std::cout << "Source sending " << i << ".\n"; + out[i].set(i); + } + =} } reactor Destination(expected: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - std::cout << "Received: " << *in.get() << ".\n"; - received = true; - if (*in.get() != expected) { - std::cerr << "ERROR: Expected " << expected << ".\n"; - exit(1); - } - =} + reaction(in) {= + std::cout << "Received: " << *in.get() << ".\n"; + received = true; + if (*in.get() != expected) { + std::cerr << "ERROR: Expected " << expected << ".\n"; + exit(1); + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor { - @enclave - a = new Source() - @enclave - b1 = new Destination() - b2 = new Destination(expected = 1) - a.out -> b1.in, b2.in + @enclave + a = new Source() + @enclave + b1 = new Destination() + b2 = new Destination(expected = 1) + a.out -> b1.in, b2.in } diff --git a/test/Cpp/src/enclave/EnclaveShutdown.lf b/test/Cpp/src/enclave/EnclaveShutdown.lf index 831adcde9c..c0c0aa1c64 100644 --- a/test/Cpp/src/enclave/EnclaveShutdown.lf +++ b/test/Cpp/src/enclave/EnclaveShutdown.lf @@ -1,37 +1,33 @@ target Cpp -reactor Node( - message: std::string = "Hello", - period: time = 1 sec, - stop: time = 3 sec -) { - timer t(0, period) - timer s(stop) +reactor Node(message: std::string = "Hello", period: time = 1 sec, stop: time = 3 sec) { + timer t(0, period) + timer s(stop) - reaction(t) {= reactor::log::Info() << message; =} + reaction(t) {= reactor::log::Info() << message; =} - reaction(s) {= request_stop(); =} + reaction(s) {= request_stop(); =} - reaction(shutdown) {= - reactor::log::Info() << "Goodbye!"; + reaction(shutdown) {= + reactor::log::Info() << "Goodbye!"; - if (get_elapsed_logical_time() != stop || get_microstep() != 1) { - reactor::log::Error() << "Expected to shut down at [" << stop << ", 1]"; - exit(1); - } - =} + if (get_elapsed_logical_time() != stop || get_microstep() != 1) { + reactor::log::Error() << "Expected to shut down at [" << stop << ", 1]"; + exit(1); + } + =} } main reactor { - @enclave - node1 = new Node(message = "Hello Foo!") - @enclave - node2 = new Node(message = "Hello Bar!", stop = 2 sec) + @enclave + node1 = new Node(message = "Hello Foo!") + @enclave + node2 = new Node(message = "Hello Bar!", stop = 2 sec) - reaction(shutdown) {= - if (get_elapsed_logical_time() != 0s || get_microstep() != 1) { - reactor::log::Error() << "Expected to shut down at [0, 1]e"; - exit(1); - } - =} + reaction(shutdown) {= + if (get_elapsed_logical_time() != 0s || get_microstep() != 1) { + reactor::log::Error() << "Expected to shut down at [0, 1]e"; + exit(1); + } + =} } diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf index 431c2cd60a..6f713a7d88 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEvents.lf @@ -1,52 +1,52 @@ -// The purpose of this test is to check that the downstream enclave can -// progress, even if there are only sparse upstream events. +// The purpose of this test is to check that the downstream enclave can progress, even if there are +// only sparse upstream events. target Cpp { - timeout: 12 s, - workers: 1 + timeout: 12 s, + workers: 1 } reactor Src { - timer t(0, 4 s) - output out: int - state counter: int = 0 + timer t(0, 4 s) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 100 ms) - input in: int - state received: bool = false - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 4s * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expected value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= - reactor::log::Error() << "Deadline violated."; - exit(2); - =} + timer t(0, 100 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 4s * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in + src.out -> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf index 691e80f4bf..dd2e0d04d7 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsDelayed.lf @@ -1,52 +1,52 @@ -// The purpose of this test is to check that the downstream enclave respects the -// after delay when aquiring tags from its upstream. +// The purpose of this test is to check that the downstream enclave respects the after delay when +// aquiring tags from its upstream. target Cpp { - timeout: 12 s, - workers: 1 + timeout: 12 s, + workers: 1 } reactor Src { - timer t(0, 4 s) - output out: int - state counter: int = 0 + timer t(0, 4 s) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 100 ms) - input in: int - state received: bool = false - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 2s + 4s * value; - if (get_elapsed_logical_time() != expected) { - reactor::log::Error() << "Expected value at " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= - reactor::log::Error() << "Deadline violated."; - exit(2); - =} + timer t(0, 100 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 2s + 4s * value; + if (get_elapsed_logical_time() != expected) { + reactor::log::Error() << "Expected value at " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in after 2 s + src.out -> sink.in after 2 s } diff --git a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf index 10b5a8c4af..895e50d6c8 100644 --- a/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf +++ b/test/Cpp/src/enclave/EnclaveSparseUpstreamEventsPhysical.lf @@ -1,52 +1,52 @@ -// The purpose of this test is to check that the downstream enclave advances -// time independenty of the upstraem if the connection is physical. +// The purpose of this test is to check that the downstream enclave advances time independenty of +// the upstraem if the connection is physical. target Cpp { - timeout: 12 s, - workers: 1 + timeout: 12 s, + workers: 1 } reactor Src { - timer t(0, 4 s) - output out: int - state counter: int = 0 + timer t(0, 4 s) + output out: int + state counter: int = 0 - reaction(t) -> out {= out.set(counter++); =} + reaction(t) -> out {= out.set(counter++); =} } reactor Sink { - timer t(0, 100 ms) - input in: int - state received: bool = false - - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 4s * value; - if (get_elapsed_logical_time() < expected) { - reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} - - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} - - reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= - reactor::log::Error() << "Deadline violated."; - exit(2); - =} + timer t(0, 100 ms) + input in: int + state received: bool = false + + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 4s * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} + + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} + + reaction(t) {= reactor::log::Info() << "Tick"; =} deadline(2 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out ~> sink.in + src.out ~> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveTimeout.lf b/test/Cpp/src/enclave/EnclaveTimeout.lf index dc87acbd26..1e9614baa5 100644 --- a/test/Cpp/src/enclave/EnclaveTimeout.lf +++ b/test/Cpp/src/enclave/EnclaveTimeout.lf @@ -1,32 +1,32 @@ target Cpp { - timeout: 1 sec + timeout: 1 sec } reactor Node(message: std::string = "Hello", period: time = 1 sec) { - timer t(0, period) + timer t(0, period) - reaction(t) {= reactor::log::Info() << message; =} + reaction(t) {= reactor::log::Info() << message; =} - reaction(shutdown) {= - reactor::log::Info() << "Goodbye!"; + reaction(shutdown) {= + reactor::log::Info() << "Goodbye!"; - if (get_elapsed_logical_time() != 1s || get_microstep() != 0) { - reactor::log::Error() << "Expected to shut down at [1s, 0]"; - exit(1); - } - =} + if (get_elapsed_logical_time() != 1s || get_microstep() != 0) { + reactor::log::Error() << "Expected to shut down at [1s, 0]"; + exit(1); + } + =} } main reactor { - @enclave - node1 = new Node(message = "Hello Foo!") - @enclave - node2 = new Node(message = "Hello Bar!") + @enclave + node1 = new Node(message = "Hello Foo!") + @enclave + node2 = new Node(message = "Hello Bar!") - reaction(shutdown) {= - if (get_elapsed_logical_time() != 1s || get_microstep() != 0) { - reactor::log::Error() << "Expected to shut down at [1s, 0]e"; - exit(1); - } - =} + reaction(shutdown) {= + if (get_elapsed_logical_time() != 1s || get_microstep() != 0) { + reactor::log::Error() << "Expected to shut down at [1s, 0]e"; + exit(1); + } + =} } diff --git a/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf index 18ac74b091..a82755181f 100644 --- a/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf +++ b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalAction.lf @@ -1,77 +1,77 @@ -// The purpose of this test is to check that the downstream enclave can -// progress, even if there are only sparse upstream events. +// The purpose of this test is to check that the downstream enclave can progress, even if there are +// only sparse upstream events. target Cpp { - timeout: 10 s, - workers: 1 + timeout: 10 s, + workers: 1 } reactor Src { - public preamble {= - #include - =} + public preamble {= + #include + =} - state thread: std::thread{} + state thread: std::thread{} - physical action a: int - output out: int + physical action a: int + output out: int - reaction(startup) -> a {= - // start new thread - this->thread = std::thread([&] () { - for (int i{0}; i < 3; i++) { - a.schedule(i); - std::this_thread::sleep_for(2s); - } - }); - =} + reaction(startup) -> a {= + // start new thread + this->thread = std::thread([&] () { + for (int i{0}; i < 3; i++) { + a.schedule(i); + std::this_thread::sleep_for(2s); + } + }); + =} - reaction(a) -> out {= out.set(a.get()); =} + reaction(a) -> out {= out.set(a.get()); =} - reaction(shutdown) {= - // make sure to join the thread before shutting down - if(thread.joinable()) { - thread.join(); - } - =} + reaction(shutdown) {= + // make sure to join the thread before shutting down + if(thread.joinable()) { + thread.join(); + } + =} } reactor Sink { - timer t(0, 100 ms) - input in: int - state received: bool = false + timer t(0, 100 ms) + input in: int + state received: bool = false - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 2s * value; - if (get_elapsed_logical_time() < expected) { - reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 2s * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} - reaction(t) {= - reactor::log::Info() << "Tick - " << "logical time: " << get_elapsed_logical_time() - << "; physical time: " << get_elapsed_physical_time(); - =} deadline(1 s) {= - reactor::log::Error() << "Deadline violated."; - exit(2); - =} + reaction(t) {= + reactor::log::Info() << "Tick - " << "logical time: " << get_elapsed_logical_time() + << "; physical time: " << get_elapsed_physical_time(); + =} deadline(1 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in + src.out -> sink.in } diff --git a/test/Cpp/src/enclave/EnclaveUpstreamPhysicalActionDelayed.lf b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalActionDelayed.lf index f87895f960..afc391bca2 100644 --- a/test/Cpp/src/enclave/EnclaveUpstreamPhysicalActionDelayed.lf +++ b/test/Cpp/src/enclave/EnclaveUpstreamPhysicalActionDelayed.lf @@ -1,77 +1,77 @@ -// The purpose of this test is to check that the downstream enclave can -// progress, even if there are only sparse upstream events. +// The purpose of this test is to check that the downstream enclave can progress, even if there are +// only sparse upstream events. target Cpp { - timeout: 10 s, - workers: 1 + timeout: 10 s, + workers: 1 } reactor Src { - public preamble {= - #include - =} + public preamble {= + #include + =} - state thread: std::thread{} + state thread: std::thread{} - physical action a: int - output out: int + physical action a: int + output out: int - reaction(startup) -> a {= - // start new thread - this->thread = std::thread([&] () { - for (int i{0}; i < 3; i++) { - a.schedule(i); - std::this_thread::sleep_for(2s); - } - }); - =} + reaction(startup) -> a {= + // start new thread + this->thread = std::thread([&] () { + for (int i{0}; i < 3; i++) { + a.schedule(i); + std::this_thread::sleep_for(2s); + } + }); + =} - reaction(a) -> out {= out.set(a.get()); =} + reaction(a) -> out {= out.set(a.get()); =} - reaction(shutdown) {= - // make sure to join the thread before shutting down - if(thread.joinable()) { - thread.join(); - } - =} + reaction(shutdown) {= + // make sure to join the thread before shutting down + if(thread.joinable()) { + thread.join(); + } + =} } reactor Sink { - timer t(0, 100 ms) - input in: int - state received: bool = false + timer t(0, 100 ms) + input in: int + state received: bool = false - reaction(in) {= - received = true; - auto value = *in.get(); - reactor::log::Info() << "Received " << value; - auto expected = 2s * value; - if (get_elapsed_logical_time() < expected) { - reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); - exit(1); - } - =} + reaction(in) {= + received = true; + auto value = *in.get(); + reactor::log::Info() << "Received " << value; + auto expected = 2s * value; + if (get_elapsed_logical_time() < expected) { + reactor::log::Error() << "Expected value not before " << expected << " but received it at " << get_elapsed_logical_time(); + exit(1); + } + =} - reaction(shutdown) {= - if(!received) { - reactor::log::Error() << "Nothing received."; - exit(1); - } - =} + reaction(shutdown) {= + if(!received) { + reactor::log::Error() << "Nothing received."; + exit(1); + } + =} - reaction(t) {= - reactor::log::Info() << "Tick - " << "logical time: " << get_elapsed_logical_time() - << "; physical time: " << get_elapsed_physical_time(); - =} deadline(1 s) {= - reactor::log::Error() << "Deadline violated."; - exit(2); - =} + reaction(t) {= + reactor::log::Info() << "Tick - " << "logical time: " << get_elapsed_logical_time() + << "; physical time: " << get_elapsed_physical_time(); + =} deadline(1 s) {= + reactor::log::Error() << "Deadline violated."; + exit(2); + =} } main reactor { - @enclave - src = new Src() - @enclave - sink = new Sink() + @enclave + src = new Src() + @enclave + sink = new Sink() - src.out -> sink.in after 2 s + src.out -> sink.in after 2 s } diff --git a/test/Cpp/src/enclave/FastAndSlow.lf b/test/Cpp/src/enclave/FastAndSlow.lf index 73b6869394..3d421223e6 100644 --- a/test/Cpp/src/enclave/FastAndSlow.lf +++ b/test/Cpp/src/enclave/FastAndSlow.lf @@ -1,37 +1,33 @@ -// This is a basic test for enclaved execution. The deadlines shiuld never be -// violated for the test to pass. +// This is a basic test for enclaved execution. The deadlines shiuld never be violated for the test +// to pass. target Cpp { - timeout: 3 sec + timeout: 3 sec } reactor Slow { - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(t) {= - reactor::log::Info() << "Slow reaction starts"; - std::this_thread::sleep_for(700ms); - reactor::log::Info() << "Slow reaction ends"; - =} deadline(200 msec) {= - reactor::log::Error() << "Slow deadline was violated!"; - exit(1); - =} + reaction(t) {= + reactor::log::Info() << "Slow reaction starts"; + std::this_thread::sleep_for(700ms); + reactor::log::Info() << "Slow reaction ends"; + =} deadline(200 msec) {= + reactor::log::Error() << "Slow deadline was violated!"; + exit(1); + =} } reactor Fast { - timer t(0 msec, 100 msec) + timer t(0 msec, 100 msec) - reaction(t) {= - reactor::log::Info() << "Fast reaction executes"; - =} deadline( - 200 msec - ) {= - reactor::log::Error() << "Fast deadline was violated!"; - exit(2); - =} + reaction(t) {= reactor::log::Info() << "Fast reaction executes"; =} deadline(200 msec) {= + reactor::log::Error() << "Fast deadline was violated!"; + exit(2); + =} } main reactor { - slow = new Slow() - @enclave - fast = new Fast() + slow = new Slow() + @enclave + fast = new Fast() } diff --git a/test/Cpp/src/lib/Count.lf b/test/Cpp/src/lib/Count.lf index 7b56233019..4bb993db42 100644 --- a/test/Cpp/src/lib/Count.lf +++ b/test/Cpp/src/lib/Count.lf @@ -1,12 +1,12 @@ target Cpp reactor Count { - output c: int - timer t(0, 1 sec) - state i: int = 0 + output c: int + timer t(0, 1 sec) + state i: int = 0 - reaction(t) -> c {= - i++; - c.set(i); - =} + reaction(t) -> c {= + i++; + c.set(i); + =} } diff --git a/test/Cpp/src/lib/LoopedActionSender.lf b/test/Cpp/src/lib/LoopedActionSender.lf index 3c1cc13631..00dee5631d 100644 --- a/test/Cpp/src/lib/LoopedActionSender.lf +++ b/test/Cpp/src/lib/LoopedActionSender.lf @@ -8,25 +8,24 @@ target Cpp /** - * @param take_a_break_after: Indicates how many messages are sent in - * consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break - * after sending take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break after sending + * take_a_break_after messages. */ reactor Sender(take_a_break_after: int = 10, break_interval: time = 400 msec) { - output out: int - logical action act - state sent_messages: int = 0 + output out: int + logical action act + state sent_messages: int = 0 - reaction(startup, act) -> act, out {= - out.set(sent_messages); - sent_messages++; - if(sent_messages < take_a_break_after){ - act.schedule(0ns); - } else { - // Take a break - sent_messages=0; - act.schedule(break_interval); - } - =} + reaction(startup, act) -> act, out {= + out.set(sent_messages); + sent_messages++; + if(sent_messages < take_a_break_after){ + act.schedule(0ns); + } else { + // Take a break + sent_messages=0; + act.schedule(break_interval); + } + =} } diff --git a/test/Cpp/src/multiport/BankSelfBroadcast.lf b/test/Cpp/src/multiport/BankSelfBroadcast.lf index 07da948506..9fcf4c51d0 100644 --- a/test/Cpp/src/multiport/BankSelfBroadcast.lf +++ b/test/Cpp/src/multiport/BankSelfBroadcast.lf @@ -1,7 +1,7 @@ /** - * Test a bank of reactors that broadcast a single output back to a multiport - * input of the same reactors in the bank so that each reactor in the bank - * receives the output produced by itself and each other reactor. + * Test a bank of reactors that broadcast a single output back to a multiport input of the same + * reactors in the bank so that each reactor in the bank receives the output produced by itself and + * each other reactor. * * @author Edward A. Lee * @author Christian Menard @@ -9,40 +9,40 @@ target Cpp reactor A(bank_index: size_t = 0) { - input[4] in: size_t - output out: size_t - state received: bool = false + input[4] in: size_t + output out: size_t + state received: bool = false - reaction(startup) -> out {= out.set(bank_index); =} + reaction(startup) -> out {= out.set(bank_index); =} - reaction(in) {= - for (size_t i = 0; i < in.size(); i++) { - if (in[i].is_present()) { - std::cout << "Reactor " << bank_index << " received " - << *in[i].get() << " on channel " << i << '\n'; + reaction(in) {= + for (size_t i = 0; i < in.size(); i++) { + if (in[i].is_present()) { + std::cout << "Reactor " << bank_index << " received " + << *in[i].get() << " on channel " << i << '\n'; - if (*in[i].get() != i) { - std::cerr << "ERROR: Expected " << i << '\n'; - exit(1); - } - received = true; - } else { - std::cout << "Reactor " << bank_index << " channel " << i << " is absent.\n"; + if (*in[i].get() != i) { std::cerr << "ERROR: Expected " << i << '\n'; exit(1); } + received = true; + } else { + std::cout << "Reactor " << bank_index << " channel " << i << " is absent.\n"; + std::cerr << "ERROR: Expected " << i << '\n'; + exit(1); } - =} + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: No inputs received.\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: No inputs received.\n"; + exit(2); + } + =} } main reactor { - a = new[4] A() - (a.out)+ -> a.in + a = new[4] A() + (a.out)+ -> a.in } diff --git a/test/Cpp/src/multiport/BankToBank.lf b/test/Cpp/src/multiport/BankToBank.lf index f70cfd83e4..d9fe3f437c 100644 --- a/test/Cpp/src/multiport/BankToBank.lf +++ b/test/Cpp/src/multiport/BankToBank.lf @@ -1,45 +1,44 @@ // Check bank of reactors sending to bank of reactors. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(bank_index: size_t = 0) { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= - out.set(s); - s += bank_index; - =} + reaction(t) -> out {= + out.set(s); + s += bank_index; + =} } reactor Destination(bank_index: size_t = 0) { - state s: int = 0 - input in: int + state s: int = 0 + input in: int - reaction(in) {= - std::cout << "Destination " << bank_index << " received: " << *in.get() << "\n"; - if (*in.get() != s) { - std::cerr << "ERROR: Expected " << s << ".\n"; - exit(1); - } - s += bank_index; - =} + reaction(in) {= + std::cout << "Destination " << bank_index << " received: " << *in.get() << "\n"; + if (*in.get() != s) { + std::cerr << "ERROR: Expected " << s << ".\n"; + exit(1); + } + s += bank_index; + =} - reaction(shutdown) {= - if (s == 0 && bank_index != 0) { - std::cerr << "ERROR: Destination " << bank_index << " received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (s == 0 && bank_index != 0) { + std::cerr << "ERROR: Destination " << bank_index << " received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor BankToBank(width: int = 4) { - // FIXME: Should set the width to "width" rather than "4". - a = new[4] Source() - b = new[4] Destination() - a.out -> b.in + a = new[4] Source() // FIXME: Should set the width to "width" rather than "4". + b = new[4] Destination() + a.out -> b.in } diff --git a/test/Cpp/src/multiport/BankToBankMultiport.lf b/test/Cpp/src/multiport/BankToBankMultiport.lf index bdb3e9a880..faffacb0cf 100644 --- a/test/Cpp/src/multiport/BankToBankMultiport.lf +++ b/test/Cpp/src/multiport/BankToBankMultiport.lf @@ -1,51 +1,51 @@ // Check bank of reactors sending to bank of reactors with multiports. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: size_t = 1) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 - - reaction(t) -> out {= - for(size_t i = 0; i < out.size(); i++) { - out[i].set(s++); - } - =} + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 + + reaction(t) -> out {= + for(size_t i = 0; i < out.size(); i++) { + out[i].set(s++); + } + =} } reactor Destination(width: size_t = 1) { - state s: int = 6 - input[width] in: int - - reaction(in) {= - int sum = 0; - - for (auto i : in.present_indices_unsorted()) { - sum += *in[i].get(); - } - - std::cout << "Sum of received: " << sum << ".\n"; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << ".\n"; - exit(1); - } - s += 16; - =} - - reaction(shutdown) {= - if (s <= 6) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + state s: int = 6 + input[width] in: int + + reaction(in) {= + int sum = 0; + + for (auto i : in.present_indices_unsorted()) { + sum += *in[i].get(); + } + + std::cout << "Sum of received: " << sum << ".\n"; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << ".\n"; + exit(1); + } + s += 16; + =} + + reaction(shutdown) {= + if (s <= 6) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor(bank_width: size_t = 4) { - a = new[bank_width] Source(width = 4) - b = new[bank_width] Destination(width = 4) - a.out -> b.in + a = new[bank_width] Source(width = 4) + b = new[bank_width] Destination(width = 4) + a.out -> b.in } diff --git a/test/Cpp/src/multiport/BankToBankMultiportAfter.lf b/test/Cpp/src/multiport/BankToBankMultiportAfter.lf index 78d832a5ea..6c9c81c5b4 100644 --- a/test/Cpp/src/multiport/BankToBankMultiportAfter.lf +++ b/test/Cpp/src/multiport/BankToBankMultiportAfter.lf @@ -1,59 +1,59 @@ // Check bank of reactors sending to bank of reactors with multiports. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: size_t = 1) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 - - reaction(t) -> out {= - for(size_t i = 0; i < out.size(); i++) { - out[i].set(s++); - } - =} + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 + + reaction(t) -> out {= + for(size_t i = 0; i < out.size(); i++) { + out[i].set(s++); + } + =} } reactor Destination(width: size_t = 1) { - state s: int = 6 - state iterations: unsigned = 0 - input[width] in: int - - reaction(in) {= - iterations++; - auto lt = get_elapsed_logical_time(); - auto expected = iterations * 200ms; - if (expected != lt) { - std::cerr << "ERROR: Expected logical time to be " << expected << " but got " << lt << '\n'; - exit(1); - } - - int sum = 0; - for (auto i : in.present_indices_unsorted()) { - sum += *in[i].get(); - } - - std::cout << "Sum of received: " << sum << '\n'; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << '\n'; - exit(1); - } - s += 16; - =} - - reaction(shutdown) {= - if (s <= 6) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + state s: int = 6 + state iterations: unsigned = 0 + input[width] in: int + + reaction(in) {= + iterations++; + auto lt = get_elapsed_logical_time(); + auto expected = iterations * 200ms; + if (expected != lt) { + std::cerr << "ERROR: Expected logical time to be " << expected << " but got " << lt << '\n'; + exit(1); + } + + int sum = 0; + for (auto i : in.present_indices_unsorted()) { + sum += *in[i].get(); + } + + std::cout << "Sum of received: " << sum << '\n'; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << '\n'; + exit(1); + } + s += 16; + =} + + reaction(shutdown) {= + if (s <= 6) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor(bank_width: size_t = 4) { - a = new[bank_width] Source(width = 4) - b = new[bank_width] Destination(width = 4) - a.out -> b.in after 200 msec + a = new[bank_width] Source(width = 4) + b = new[bank_width] Destination(width = 4) + a.out -> b.in after 200 msec } diff --git a/test/Cpp/src/multiport/BankToMultiport.lf b/test/Cpp/src/multiport/BankToMultiport.lf index 6b1acf7591..af338a32a2 100644 --- a/test/Cpp/src/multiport/BankToMultiport.lf +++ b/test/Cpp/src/multiport/BankToMultiport.lf @@ -2,36 +2,36 @@ target Cpp reactor Source(bank_index: size_t = 0) { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(bank_index); =} + reaction(startup) -> out {= out.set(bank_index); =} } reactor Sink { - input[4] in: unsigned - state received: bool = false + input[4] in: unsigned + state received: bool = false - reaction(in) {= - for (unsigned i = 0; i < in.size(); i++) { - received = true; - std::cout << "Received " << *in[i].get() << '\n'; - if (*in[i].get() != i) { - std::cerr << "Error: expected " << i << "!\n"; - exit(1); - } + reaction(in) {= + for (unsigned i = 0; i < in.size(); i++) { + received = true; + std::cout << "Received " << *in[i].get() << '\n'; + if (*in[i].get() != i) { + std::cerr << "Error: expected " << i << "!\n"; + exit(1); } - =} + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "Error: received no input!\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: received no input!\n"; + exit(2); + } + =} } main reactor BankToMultiport { - source = new[4] Source() - sink = new Sink() - source.out -> sink.in + source = new[4] Source() + sink = new Sink() + source.out -> sink.in } diff --git a/test/Cpp/src/multiport/Broadcast.lf b/test/Cpp/src/multiport/Broadcast.lf index 202a30c5f7..e6dcbf9607 100644 --- a/test/Cpp/src/multiport/Broadcast.lf +++ b/test/Cpp/src/multiport/Broadcast.lf @@ -1,34 +1,34 @@ target Cpp reactor Source { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(42); =} + reaction(startup) -> out {= out.set(42); =} } reactor Sink(bank_index: size_t = 0) { - input in: unsigned - state received: bool = false + input in: unsigned + state received: bool = false - reaction(in) {= - received = true; - std::cout << "Received " << *in.get() << '\n'; - if (*in.get() != 42) { - std::cerr << "Error: expected " << 42 << "!\n"; - exit(1); - } - =} + reaction(in) {= + received = true; + std::cout << "Received " << *in.get() << '\n'; + if (*in.get() != 42) { + std::cerr << "Error: expected " << 42 << "!\n"; + exit(1); + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "Error: Sink " << bank_index << " didn't receive anything.\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: Sink " << bank_index << " didn't receive anything.\n"; + exit(2); + } + =} } main reactor { - source = new Source() - sink = new[4] Sink() - (source.out)+ -> sink.in + source = new Source() + sink = new[4] Sink() + (source.out)+ -> sink.in } diff --git a/test/Cpp/src/multiport/BroadcastAfter.lf b/test/Cpp/src/multiport/BroadcastAfter.lf index 6cb7f84f4d..73cccc1904 100644 --- a/test/Cpp/src/multiport/BroadcastAfter.lf +++ b/test/Cpp/src/multiport/BroadcastAfter.lf @@ -1,41 +1,41 @@ target Cpp { - fast: true + fast: true } reactor Source { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(42); =} + reaction(startup) -> out {= out.set(42); =} } reactor Sink(bank_index: size_t = 0) { - input in: unsigned - state received: bool = false + input in: unsigned + state received: bool = false - reaction(in) {= - std::cout << bank_index << " received " << *in.get() << '\n'; - if (*in.get() != 42) { - std::cerr << "Error: expected " << 42 << "!\n"; - exit(1); - } - if (get_elapsed_logical_time() != 1s) { - std::cerr << "ERROR: Expected to receive input after one second.\n"; - exit(2); - } - received = true; - =} + reaction(in) {= + std::cout << bank_index << " received " << *in.get() << '\n'; + if (*in.get() != 42) { + std::cerr << "Error: expected " << 42 << "!\n"; + exit(1); + } + if (get_elapsed_logical_time() != 1s) { + std::cerr << "ERROR: Expected to receive input after one second.\n"; + exit(2); + } + received = true; + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination " << bank_index << " received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination " << bank_index << " received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor { - source = new Source() - sink = new[4] Sink() - (source.out)+ -> sink.in after 1 sec + source = new Source() + sink = new[4] Sink() + (source.out)+ -> sink.in after 1 sec } diff --git a/test/Cpp/src/multiport/BroadcastMultipleAfter.lf b/test/Cpp/src/multiport/BroadcastMultipleAfter.lf index 065e9bf403..f24a5f7c8c 100644 --- a/test/Cpp/src/multiport/BroadcastMultipleAfter.lf +++ b/test/Cpp/src/multiport/BroadcastMultipleAfter.lf @@ -1,44 +1,44 @@ target Cpp { - fast: true + fast: true } reactor Source(value: unsigned = 42) { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(value); =} + reaction(startup) -> out {= out.set(value); =} } reactor Sink(bank_index: size_t = 0) { - input in: unsigned - state received: bool = false + input in: unsigned + state received: bool = false - reaction(in) {= - std::cout << bank_index << " received " << *in.get() << '\n'; - auto expected = (bank_index % 3) + 1; - if (*in.get() != expected) { - std::cerr << "Error: expected " << expected << "!\n"; - exit(1); - } - if (get_elapsed_logical_time() != 1s) { - std::cerr << "ERROR: Expected to receive input after one second.\n"; - exit(2); - } - received = true; - =} + reaction(in) {= + std::cout << bank_index << " received " << *in.get() << '\n'; + auto expected = (bank_index % 3) + 1; + if (*in.get() != expected) { + std::cerr << "Error: expected " << expected << "!\n"; + exit(1); + } + if (get_elapsed_logical_time() != 1s) { + std::cerr << "ERROR: Expected to receive input after one second.\n"; + exit(2); + } + received = true; + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination " << bank_index << " received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination " << bank_index << " received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor { - source1 = new Source(value = 1) - source2 = new Source(value = 2) - source3 = new Source(value = 3) - sink = new[9] Sink() - (source1.out, source2.out, source3.out)+ -> sink.in after 1 sec + source1 = new Source(value = 1) + source2 = new Source(value = 2) + source3 = new Source(value = 3) + sink = new[9] Sink() + (source1.out, source2.out, source3.out)+ -> sink.in after 1 sec } diff --git a/test/Cpp/src/multiport/FullyConnected.lf b/test/Cpp/src/multiport/FullyConnected.lf index 0b0a66405e..09826be5f2 100644 --- a/test/Cpp/src/multiport/FullyConnected.lf +++ b/test/Cpp/src/multiport/FullyConnected.lf @@ -1,42 +1,42 @@ target Cpp reactor Node(bank_index: size_t = 0, num_nodes: size_t = 4) { - input[num_nodes] in: size_t - output out: size_t + input[num_nodes] in: size_t + output out: size_t - state received: bool = false + state received: bool = false - reaction(startup) -> out {= - std::cout << "Hello from node " << bank_index << "!\n"; - // broadcast my ID to everyone - out.set(bank_index); - =} + reaction(startup) -> out {= + std::cout << "Hello from node " << bank_index << "!\n"; + // broadcast my ID to everyone + out.set(bank_index); + =} - reaction(in) {= - std::cout << "Node " << bank_index << " received messages from "; - received = true; - size_t count{0}; - for (auto i: in.present_indices_unsorted()) { - count++; - std::cout << *in[i].get() << ", "; - } + reaction(in) {= + std::cout << "Node " << bank_index << " received messages from "; + received = true; + size_t count{0}; + for (auto i: in.present_indices_unsorted()) { + count++; + std::cout << *in[i].get() << ", "; + } - std::cout << '\n'; - if (count != num_nodes) { - std::cerr << "ERROR: received less messages than expected!"; - exit(1); - } - =} + std::cout << '\n'; + if (count != num_nodes) { + std::cerr << "ERROR: received less messages than expected!"; + exit(1); + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "Error: received no input!\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: received no input!\n"; + exit(2); + } + =} } main reactor(num_nodes: size_t = 4) { - nodes = new[num_nodes] Node(num_nodes = num_nodes) - (nodes.out)+ -> nodes.in + nodes = new[num_nodes] Node(num_nodes = num_nodes) + (nodes.out)+ -> nodes.in } diff --git a/test/Cpp/src/multiport/FullyConnectedAddressable.lf b/test/Cpp/src/multiport/FullyConnectedAddressable.lf index 5385c44222..ed148437a5 100644 --- a/test/Cpp/src/multiport/FullyConnectedAddressable.lf +++ b/test/Cpp/src/multiport/FullyConnectedAddressable.lf @@ -2,49 +2,49 @@ target Cpp reactor Node(bank_index: size_t = 0, num_nodes: size_t = 4) { - input[num_nodes] in: size_t - output[num_nodes] out: size_t - - state received: bool = false - - reaction(startup) -> out {= - std::cout << "Hello from node " << bank_index << "!\n"; - // send my ID only to my right neighbour - out[(bank_index + 1) % num_nodes].set(bank_index); - =} - - reaction(in) {= - std::cout << "Node " << bank_index << " received messages from "; - received = true; - size_t count{0}; - size_t result{0}; - for (auto i : in.present_indices_unsorted()) { - count++; - result = *in[i].get(); - std::cout << result << ", "; - } - - std::cout << '\n'; - - size_t expected = bank_index == 0 ? num_nodes - 1 : bank_index - 1; - if (count != 1 || result != expected) { - std::cerr << "ERROR: received an unexpected message!\n"; - exit(1); - } - =} - - reaction(shutdown) {= - if (!received) { - std::cerr << "Error: received no input!\n"; - exit(2); - } - =} + input[num_nodes] in: size_t + output[num_nodes] out: size_t + + state received: bool = false + + reaction(startup) -> out {= + std::cout << "Hello from node " << bank_index << "!\n"; + // send my ID only to my right neighbour + out[(bank_index + 1) % num_nodes].set(bank_index); + =} + + reaction(in) {= + std::cout << "Node " << bank_index << " received messages from "; + received = true; + size_t count{0}; + size_t result{0}; + for (auto i : in.present_indices_unsorted()) { + count++; + result = *in[i].get(); + std::cout << result << ", "; + } + + std::cout << '\n'; + + size_t expected = bank_index == 0 ? num_nodes - 1 : bank_index - 1; + if (count != 1 || result != expected) { + std::cerr << "ERROR: received an unexpected message!\n"; + exit(1); + } + =} + + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: received no input!\n"; + exit(2); + } + =} } main reactor(num_nodes: size_t = 4) { - nodes1 = new[num_nodes] Node(num_nodes = num_nodes) - nodes1.out -> interleaved (nodes1.in) + nodes1 = new[num_nodes] Node(num_nodes = num_nodes) + nodes1.out -> interleaved (nodes1.in) - nodes2 = new[num_nodes] Node(num_nodes = num_nodes) - interleaved (nodes2.out) -> nodes2.in + nodes2 = new[num_nodes] Node(num_nodes = num_nodes) + interleaved (nodes2.out) -> nodes2.in } diff --git a/test/Cpp/src/multiport/FullyConnectedAddressableAfter.lf b/test/Cpp/src/multiport/FullyConnectedAddressableAfter.lf index c6fcb4c9e6..e33511a41a 100644 --- a/test/Cpp/src/multiport/FullyConnectedAddressableAfter.lf +++ b/test/Cpp/src/multiport/FullyConnectedAddressableAfter.lf @@ -4,9 +4,9 @@ target Cpp import Node from "FullyConnectedAddressable.lf" main reactor(num_nodes: size_t = 4) { - nodes1 = new[num_nodes] Node(num_nodes = num_nodes) - nodes1.out -> interleaved (nodes1.in) after 200 msec + nodes1 = new[num_nodes] Node(num_nodes = num_nodes) + nodes1.out -> interleaved (nodes1.in) after 200 msec - nodes2 = new[num_nodes] Node(num_nodes = num_nodes) - interleaved (nodes2.out) -> nodes2.in after 400 msec + nodes2 = new[num_nodes] Node(num_nodes = num_nodes) + interleaved (nodes2.out) -> nodes2.in after 400 msec } diff --git a/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf b/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf index 964e2e7095..70b89fa728 100644 --- a/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf +++ b/test/Cpp/src/multiport/IndexIntoMultiportOutput.lf @@ -2,71 +2,70 @@ * This test was first described by Peter Donovan in * https://github.com/lf-lang/lingua-franca/issues/1321 * - * It simply tests if passthrough connections work as expected in the C++ - * target. Such a connection directly connects an input to an output of the same - * reactor, without any reactions in between. + * It simply tests if passthrough connections work as expected in the C++ target. Such a connection + * directly connects an input to an output of the same reactor, without any reactions in between. */ target Cpp reactor ReactorWithMultiport(width: size_t = 3) { - output[width] out: int + output[width] out: int - reaction(startup) -> out {= - for (size_t i{0}; i < width; i++) { - out[i].set(i); - } - =} + reaction(startup) -> out {= + for (size_t i{0}; i < width; i++) { + out[i].set(i); + } + =} } reactor MultiportSplitter(width: size_t = 3) { - input[width] in: int + input[width] in: int - output out0: int - output out1: int - output out2: int + output out0: int + output out1: int + output out2: int - in -> out0, out1, out2 + in -> out0, out1, out2 } main reactor IndexIntoMultiportOutput { - source = new ReactorWithMultiport() - splitter = new MultiportSplitter() + source = new ReactorWithMultiport() + splitter = new MultiportSplitter() - source.out -> splitter.in + source.out -> splitter.in - state received0: bool = false - state received1: bool = false - state received2: bool = false + state received0: bool = false + state received1: bool = false + state received2: bool = false - reaction(splitter.out0) {= - received0 = true; - if (*splitter.out0.get() != 0) { - reactor::log::Error() << "expeced 0"; - exit(1); - } - =} + reaction(splitter.out0) {= + received0 = true; + if (*splitter.out0.get() != 0) { + reactor::log::Error() << "expeced 0"; + exit(1); + } + =} - reaction(splitter.out1) {= - received1 = true; - if (*splitter.out1.get() != 1) { - reactor::log::Error() << "expeced 1"; - exit(1); - } - =} + reaction(splitter.out1) {= + received1 = true; + if (*splitter.out1.get() != 1) { + reactor::log::Error() << "expeced 1"; + exit(1); + } + =} - reaction(splitter.out2) {= - received2 = true; - if (*splitter.out2.get() != 2) { - reactor::log::Error() << "expeced 2"; - exit(1); - } - =} + reaction(splitter.out2) {= + received2 = true; + if (*splitter.out2.get() != 2) { + reactor::log::Error() << "expeced 2"; + exit(1); + } + =} - reaction(shutdown) {= - if (!received0 || !received1 || !received2) { - reactor::log::Error() << "missed a message"; - } else { - reactor::log::Info() << "success"; - } - =} + reaction(shutdown) {= + if (!received0 || !received1 || !received2) { + reactor::log::Error() << "missed a message"; + } else { + reactor::log::Info() << "success"; + } + =} } diff --git a/test/Cpp/src/multiport/Multiport.lf b/test/Cpp/src/multiport/Multiport.lf index a63924c67c..32bc20b810 100644 --- a/test/Cpp/src/multiport/Multiport.lf +++ b/test/Cpp/src/multiport/Multiport.lf @@ -1,66 +1,65 @@ -// The Multiport tests the present_indices_unsorted() function in the -// reactor::Multiport class. This method returnes all present ports this test -// checks if the returned list of indices is correctly generated by the runtime. -// For that we manually recreate this list and check if they are identical. If -// they are not identical the Multiport and Port Class do not correctly exchange +// The Multiport tests the present_indices_unsorted() function in the reactor::Multiport class. This +// method returnes all present ports this test checks if the returned list of indices is correctly +// generated by the runtime. For that we manually recreate this list and check if they are +// identical. If they are not identical the Multiport and Port Class do not correctly exchange // information. // // Author: Tassilo Tanneberger target Cpp reactor Test { - input[3000] sink: void - output[3000] source: void + input[3000] sink: void + output[3000] source: void - reaction(sink) -> source {= - for (auto i: sink.present_indices_unsorted()) { - source[i].set(); - } - =} + reaction(sink) -> source {= + for (auto i: sink.present_indices_unsorted()) { + source[i].set(); + } + =} } main reactor Multiport { - test = new Test() - state received: bool = false + test = new Test() + state received: bool = false - reaction(startup) -> test.sink {= - for (auto i = 0; i < 30; i++) { - auto semi_random_index = (i * 100) % 3000; - test.sink[semi_random_index].set(); - } - =} + reaction(startup) -> test.sink {= + for (auto i = 0; i < 30; i++) { + auto semi_random_index = (i * 100) % 3000; + test.sink[semi_random_index].set(); + } + =} - reaction(test.source) {= - received = true; - std::vector positions; + reaction(test.source) {= + received = true; + std::vector positions; - for (auto i = 0; i < 30; i++) { - auto semi_random_index = (i * 100) % 3000; - positions.push_back(semi_random_index); - } + for (auto i = 0; i < 30; i++) { + auto semi_random_index = (i * 100) % 3000; + positions.push_back(semi_random_index); + } - auto received_indices = test.source.present_indices_unsorted(); + auto received_indices = test.source.present_indices_unsorted(); - if (positions.size() != received_indices.size()) { - std::cerr << "positions size:" << positions.size() - << " indices size:" << received_indices.size() << std::endl; - throw std::runtime_error("not matching sizes"); - } + if (positions.size() != received_indices.size()) { + std::cerr << "positions size:" << positions.size() + << " indices size:" << received_indices.size() << std::endl; + throw std::runtime_error("not matching sizes"); + } - for (auto i = 0; i < positions.size(); i++) { - if (positions[i] != received_indices[i]) { - std::cerr << "mismatch detected:" << positions[i] << " and " << received_indices[i] << std::endl; - throw std::runtime_error("indices do not match"); - } + for (auto i = 0; i < positions.size(); i++) { + if (positions[i] != received_indices[i]) { + std::cerr << "mismatch detected:" << positions[i] << " and " << received_indices[i] << std::endl; + throw std::runtime_error("indices do not match"); } + } - std::cout << "[SUCCESS] all indices match" << std::endl; - =} + std::cout << "[SUCCESS] all indices match" << std::endl; + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "Error: received no input!\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: received no input!\n"; + exit(2); + } + =} } diff --git a/test/Cpp/src/multiport/MultiportFromBank.lf b/test/Cpp/src/multiport/MultiportFromBank.lf index b7339a9184..65d3554b3f 100644 --- a/test/Cpp/src/multiport/MultiportFromBank.lf +++ b/test/Cpp/src/multiport/MultiportFromBank.lf @@ -1,42 +1,42 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(bank_index: size_t = 0) { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(bank_index); =} + reaction(startup) -> out {= out.set(bank_index); =} } reactor Destination(port_width: size_t = 2) { - input[port_width] in: unsigned - state received: bool = false + input[port_width] in: unsigned + state received: bool = false - reaction(in) {= - for (size_t i = 0; i < in.size(); i++) { - std::cout << "Destination channel " << i << " received " << *in[i].get() << ".\n"; - if (i != *in[i].get()) { - std::cerr << "ERROR: Expected " << i << ".\n"; - exit(1); - } - } - received = true; - =} - - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination received no input!\n"; + reaction(in) {= + for (size_t i = 0; i < in.size(); i++) { + std::cout << "Destination channel " << i << " received " << *in[i].get() << ".\n"; + if (i != *in[i].get()) { + std::cerr << "ERROR: Expected " << i << ".\n"; exit(1); } - std::cout << "Success.\n"; - =} + } + received = true; + =} + + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor(width: size_t = 4) { - a = new[width] Source() - b = new Destination(port_width = width) - a.out -> b.in + a = new[width] Source() + b = new Destination(port_width = width) + a.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf b/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf index 673ef6889a..3814b6c510 100644 --- a/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportFromBankHierarchy.lf @@ -1,48 +1,48 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(bank_index: size_t = 0) { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(bank_index); =} + reaction(startup) -> out {= out.set(bank_index); =} } reactor Container { - output[3] out: unsigned - s = new[3] Source() - s.out -> out + output[3] out: unsigned + s = new[3] Source() + s.out -> out } reactor Destination { - input[3] in: unsigned - state received: bool = false + input[3] in: unsigned + state received: bool = false - reaction(in) {= - for (size_t i = 0; i < in.size(); i++) { - std::cout << "Destination channel " << i << " received " << *in[i].get() << ".\n"; - if (i != *in[i].get()) { - std::cerr << "ERROR: Expected " << i << ".\n"; - exit(1); - } - } - received = true; - =} - - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination received no input!\n"; + reaction(in) {= + for (size_t i = 0; i < in.size(); i++) { + std::cout << "Destination channel " << i << " received " << *in[i].get() << ".\n"; + if (i != *in[i].get()) { + std::cerr << "ERROR: Expected " << i << ".\n"; exit(1); } - std::cout << "Success.\n"; - =} + } + received = true; + =} + + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor { - a = new Container() - b = new Destination() - a.out -> b.in + a = new Container() + b = new Destination() + a.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf b/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf index fe27c74f35..d745d5ebd0 100644 --- a/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf +++ b/test/Cpp/src/multiport/MultiportFromBankHierarchyAfter.lf @@ -1,53 +1,53 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(bank_index: size_t = 0) { - output out: int + output out: int - reaction(startup) -> out {= out.set(bank_index); =} + reaction(startup) -> out {= out.set(bank_index); =} } reactor Container { - output[3] out: int - s = new[3] Source() - s.out -> out + output[3] out: int + s = new[3] Source() + s.out -> out } reactor Destination { - input[3] in: int - state received: bool = false + input[3] in: int + state received: bool = false - reaction(in) {= - for (int i = 0; i < in.size(); i++) { - int value = *in[i].get(); - std::cout << "Destination channel " << i << " received " << value << '\n'; - if (i != value) { - std::cerr << "ERROR: Expected " << i << '\n'; - exit(1); - } - } - if (get_elapsed_logical_time() != 1s) { - std::cerr << "ERROR: Expected to receive input after one second.\n"; - exit(2); - } - received = true; - =} - - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination received no input!\n"; + reaction(in) {= + for (int i = 0; i < in.size(); i++) { + int value = *in[i].get(); + std::cout << "Destination channel " << i << " received " << value << '\n'; + if (i != value) { + std::cerr << "ERROR: Expected " << i << '\n'; exit(1); } - std::cout << "Success.\n"; - =} + } + if (get_elapsed_logical_time() != 1s) { + std::cerr << "ERROR: Expected to receive input after one second.\n"; + exit(2); + } + received = true; + =} + + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor MultiportFromBankHierarchyAfter { - a = new Container() - b = new Destination() - a.out -> b.in after 1 sec + a = new Container() + b = new Destination() + a.out -> b.in after 1 sec } diff --git a/test/Cpp/src/multiport/MultiportFromHierarchy.lf b/test/Cpp/src/multiport/MultiportFromHierarchy.lf index fae914b609..21726e1238 100644 --- a/test/Cpp/src/multiport/MultiportFromHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportFromHierarchy.lf @@ -1,63 +1,62 @@ -// Check multiport output to multiport input, where the former is a hierarchical -// reactor. +// Check multiport output to multiport input, where the former is a hierarchical reactor. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[4] out: int - state s: int = 0 - - reaction(t) -> out {= - for(int i = 0; i < 4; i++) { - out[i].set(s++); - } - =} + timer t(0, 200 msec) + output[4] out: int + state s: int = 0 + + reaction(t) -> out {= + for(int i = 0; i < 4; i++) { + out[i].set(s++); + } + =} } reactor Destination { - state s: int = 6 - input[4] in: int - - reaction(in) {= - int sum = 0; - for (auto i : in.present_indices_unsorted()) { - sum += *in[i].get(); - } - - std::cout << "Sum of received: " << sum << ".\n"; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << ".\n"; - exit(1); - } - s += 16; - =} - - reaction(shutdown) {= - if (s <= 6) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + state s: int = 6 + input[4] in: int + + reaction(in) {= + int sum = 0; + for (auto i : in.present_indices_unsorted()) { + sum += *in[i].get(); + } + + std::cout << "Sum of received: " << sum << ".\n"; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << ".\n"; + exit(1); + } + s += 16; + =} + + reaction(shutdown) {= + if (s <= 6) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } reactor Container { - output[4] out: int - src = new InsideContainer() - src.out -> out + output[4] out: int + src = new InsideContainer() + src.out -> out } reactor InsideContainer { - output[4] out: int - src = new Source() - src.out -> out + output[4] out: int + src = new Source() + src.out -> out } main reactor MultiportFromHierarchy { - a = new Container() - b = new Destination() - a.out -> b.in + a = new Container() + b = new Destination() + a.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportIn.lf b/test/Cpp/src/multiport/MultiportIn.lf index 39fce6f8ff..5e6750a886 100644 --- a/test/Cpp/src/multiport/MultiportIn.lf +++ b/test/Cpp/src/multiport/MultiportIn.lf @@ -1,61 +1,61 @@ -// This is a version fo the Threaded test that uses a multiport input at the -// destination. Its purpose is to test multiport inputs. +// This is a version fo the Threaded test that uses a multiport input at the destination. Its +// purpose is to test multiport inputs. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output out: int - state s: int = 0 + timer t(0, 200 msec) + output out: int + state s: int = 0 - reaction(t) -> out {= out.set(s++); =} + reaction(t) -> out {= out.set(s++); =} } reactor Computation { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= out.set(*in.get()); =} + reaction(in) -> out {= out.set(*in.get()); =} } reactor Destination { - state s: int = 0 - input[4] in: int - - reaction(in) {= - int sum = 0; - for (int i = 0; i < in.size(); i++) { - sum += *in[i].get(); - } - std::cout << "Sum of received: " << sum << ".\n"; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << ".\n"; - exit(1); - } - s += 4; - =} - - reaction(shutdown) {= - if (s == 0) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + state s: int = 0 + input[4] in: int + + reaction(in) {= + int sum = 0; + for (int i = 0; i < in.size(); i++) { + sum += *in[i].get(); + } + std::cout << "Sum of received: " << sum << ".\n"; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << ".\n"; + exit(1); + } + s += 4; + =} + + reaction(shutdown) {= + if (s == 0) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor MultiportIn { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination() - a.out -> t1.in - a.out -> t2.in - a.out -> t3.in - a.out -> t4.in - t1.out, t2.out, t3.out, t4.out -> b.in + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination() + a.out -> t1.in + a.out -> t2.in + a.out -> t3.in + a.out -> t4.in + t1.out, t2.out, t3.out, t4.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportMultipleSet.lf b/test/Cpp/src/multiport/MultiportMultipleSet.lf index ca7495cc91..74ef376070 100644 --- a/test/Cpp/src/multiport/MultiportMultipleSet.lf +++ b/test/Cpp/src/multiport/MultiportMultipleSet.lf @@ -1,60 +1,60 @@ target Cpp { - timeout: 1 s + timeout: 1 s } reactor Producer { - timer t(0, 100 ms) + timer t(0, 100 ms) - output[10] out: int + output[10] out: int - state odd: bool(true) + state odd: bool(true) - reaction(t) -> out {= - for (int i{odd ? 1 : 0}; i < 10; i += 2) { - for (int j{0}; j < 10; j++) { - out[i].set(j); - } + reaction(t) -> out {= + for (int i{odd ? 1 : 0}; i < 10; i += 2) { + for (int j{0}; j < 10; j++) { + out[i].set(j); } + } - odd = !odd; - =} + odd = !odd; + =} } reactor Consumer { - state odd: bool(true) - input[10] in: int - - reaction(in) {= - int count = 0; - int last = -1; - - for (int i : in.present_indices_unsorted()) { - count++; - if (odd && i%2 == 0) { - reactor::log::Error() << "Expected values only on odd ports, but received one on port " << i; - exit(1); - } - if (!odd && i%2 == 1) { - reactor::log::Error() << "Expected values only on even ports, but received one on port " << i; - exit(2); - } - if (9 != *in[i].get()) { - reactor::log::Error() << "Expected 9 but got " << *in[i].get(); - exit(3); - } + state odd: bool(true) + input[10] in: int + + reaction(in) {= + int count = 0; + int last = -1; + + for (int i : in.present_indices_unsorted()) { + count++; + if (odd && i%2 == 0) { + reactor::log::Error() << "Expected values only on odd ports, but received one on port " << i; + exit(1); } - if (count != 5) { - reactor::log::Error() << "Expected count to be 5, but got " << count; - exit(4); + if (!odd && i%2 == 1) { + reactor::log::Error() << "Expected values only on even ports, but received one on port " << i; + exit(2); } - - odd = !odd; - =} + if (9 != *in[i].get()) { + reactor::log::Error() << "Expected 9 but got " << *in[i].get(); + exit(3); + } + } + if (count != 5) { + reactor::log::Error() << "Expected count to be 5, but got " << count; + exit(4); + } + + odd = !odd; + =} } main reactor { - c = new Consumer() - p = new Producer() + c = new Consumer() + p = new Producer() - p.out -> c.in + p.out -> c.in } diff --git a/test/Cpp/src/multiport/MultiportOut.lf b/test/Cpp/src/multiport/MultiportOut.lf index 53f2a5bb23..1e03e75fdb 100644 --- a/test/Cpp/src/multiport/MultiportOut.lf +++ b/test/Cpp/src/multiport/MultiportOut.lf @@ -1,68 +1,68 @@ // Check multiport capabilities on Outputs. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[4] out: int - state s: int = 0 + timer t(0, 200 msec) + output[4] out: int + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < 4; i++) { - out[i].set(s); - } - s++; - =} + reaction(t) -> out {= + for(int i = 0; i < 4; i++) { + out[i].set(s); + } + s++; + =} } reactor Computation { - input in: int - output out: int + input in: int + output out: int - reaction(in) -> out {= - // No need to sleep for this test. - // struct timespec sleep_time = {(time_t) 0, (long)200000000}; - // struct timespec remaining_time; - // nanosleep(&sleep_time, &remaining_time); - out.set(*in.get()); - =} + reaction(in) -> out {= + // No need to sleep for this test. + // struct timespec sleep_time = {(time_t) 0, (long)200000000}; + // struct timespec remaining_time; + // nanosleep(&sleep_time, &remaining_time); + out.set(*in.get()); + =} } reactor Destination { - state s: int = 0 - input[4] in: int + state s: int = 0 + input[4] in: int - reaction(in) {= - int sum = 0; - for (auto i : in.present_indices_unsorted()) { - sum += *in[i].get(); - } - std::cout << "Sum of received: " << sum << ".\n"; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << ".\n"; - exit(1); - } - s += 4; - =} + reaction(in) {= + int sum = 0; + for (auto i : in.present_indices_unsorted()) { + sum += *in[i].get(); + } + std::cout << "Sum of received: " << sum << ".\n"; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << ".\n"; + exit(1); + } + s += 4; + =} - reaction(shutdown) {= - if (s == 0) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (s == 0) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination() - a.out -> t1.in, t2.in, t3.in, t4.in - t1.out, t2.out, t3.out, t4.out -> b.in + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination() + a.out -> t1.in, t2.in, t3.in, t4.in + t1.out, t2.out, t3.out, t4.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportToBank.lf b/test/Cpp/src/multiport/MultiportToBank.lf index fa2f79419f..adb7b73b34 100644 --- a/test/Cpp/src/multiport/MultiportToBank.lf +++ b/test/Cpp/src/multiport/MultiportToBank.lf @@ -1,29 +1,29 @@ target Cpp reactor Source { - output[4] out: unsigned + output[4] out: unsigned - reaction(startup) -> out {= - for (unsigned i = 0 ; i < out.size(); i++) { - out[i].set(i); - } - =} + reaction(startup) -> out {= + for (unsigned i = 0 ; i < out.size(); i++) { + out[i].set(i); + } + =} } reactor Sink(bank_index: size_t = 0) { - input in: unsigned + input in: unsigned - reaction(in) {= - std::cout << "Received " << *in.get() << '\n'; - if (*in.get() != bank_index) { - std::cerr << "Error: expected " << bank_index << "!\n"; - exit(1); - } - =} + reaction(in) {= + std::cout << "Received " << *in.get() << '\n'; + if (*in.get() != bank_index) { + std::cerr << "Error: expected " << bank_index << "!\n"; + exit(1); + } + =} } main reactor MultiportToBank { - source = new Source() - sink = new[4] Sink() - source.out -> sink.in + source = new Source() + sink = new[4] Sink() + source.out -> sink.in } diff --git a/test/Cpp/src/multiport/MultiportToBankAfter.lf b/test/Cpp/src/multiport/MultiportToBankAfter.lf index c05730680f..423d9ee433 100644 --- a/test/Cpp/src/multiport/MultiportToBankAfter.lf +++ b/test/Cpp/src/multiport/MultiportToBankAfter.lf @@ -1,33 +1,33 @@ target Cpp reactor Source { - output[4] out: unsigned + output[4] out: unsigned - reaction(startup) -> out {= - for (unsigned i = 0 ; i < out.size(); i++) { - out[i].set(i); - } - =} + reaction(startup) -> out {= + for (unsigned i = 0 ; i < out.size(); i++) { + out[i].set(i); + } + =} } reactor Sink(bank_index: size_t = 0) { - input in: unsigned + input in: unsigned - reaction(in) {= - std::cout << "Received " << *in.get() << '\n'; - if (*in.get() != bank_index) { - std::cerr << "Error: expected " << bank_index << "!\n"; - exit(1); - } - if (get_elapsed_logical_time() != 1s) { - std::cerr << "ERROR: Expected to receive input after one second.\n"; - exit(2); - } - =} + reaction(in) {= + std::cout << "Received " << *in.get() << '\n'; + if (*in.get() != bank_index) { + std::cerr << "Error: expected " << bank_index << "!\n"; + exit(1); + } + if (get_elapsed_logical_time() != 1s) { + std::cerr << "ERROR: Expected to receive input after one second.\n"; + exit(2); + } + =} } main reactor MultiportToBankAfter { - source = new Source() - sink = new[4] Sink() - source.out -> sink.in after 1 sec + source = new Source() + sink = new[4] Sink() + source.out -> sink.in after 1 sec } diff --git a/test/Cpp/src/multiport/MultiportToBankHierarchy.lf b/test/Cpp/src/multiport/MultiportToBankHierarchy.lf index f9cef6a676..e58531e70c 100644 --- a/test/Cpp/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportToBankHierarchy.lf @@ -1,50 +1,50 @@ -// Check multiport output to bank of recipients. Here, the bank is smaller than -// the width of the sending port. +// Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +// sending port. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output[3] out: unsigned + output[3] out: unsigned - reaction(startup) -> out {= - for(size_t i = 0; i < out.size(); i++) { - out[i].set(i); - } - =} + reaction(startup) -> out {= + for(size_t i = 0; i < out.size(); i++) { + out[i].set(i); + } + =} } reactor Destination(bank_index: size_t = 0) { - input in: unsigned - state received: bool = false + input in: unsigned + state received: bool = false - reaction(in) {= - std::cout << "Destination " << bank_index << " received " << *in.get() << ".\n"; - if (bank_index != *in.get()) { - std::cerr << "ERROR: Expected " << bank_index << ".\n"; - exit(1); - } - received = true; - =} + reaction(in) {= + std::cout << "Destination " << bank_index << " received " << *in.get() << ".\n"; + if (bank_index != *in.get()) { + std::cerr << "ERROR: Expected " << bank_index << ".\n"; + exit(1); + } + received = true; + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination " << bank_index << " received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination " << bank_index << " received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } reactor Container { - input[3] in: unsigned - c = new[3] Destination() - in -> c.in + input[3] in: unsigned + c = new[3] Destination() + in -> c.in } main reactor MultiportToBankHierarchy { - a = new Source() - b = new Container() - a.out -> b.in + a = new Source() + b = new Container() + a.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportToHierarchy.lf b/test/Cpp/src/multiport/MultiportToHierarchy.lf index 573a0e06da..6e7a8e757b 100644 --- a/test/Cpp/src/multiport/MultiportToHierarchy.lf +++ b/test/Cpp/src/multiport/MultiportToHierarchy.lf @@ -1,58 +1,57 @@ -// Check multiport output to multiport input, where the latter is a hierarchical -// reactor. Note that the destination reactor has width wider than the sender, -// so one input is dangling. +// Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that +// the destination reactor has width wider than the sender, so one input is dangling. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width: size_t = 4) { - timer t(0, 200 msec) - output[width] out: int - state s: int = 0 - - reaction(t) -> out {= - for(size_t i = 0; i < 4; i++) { - out[i].set(s++); - } - =} + timer t(0, 200 msec) + output[width] out: int + state s: int = 0 + + reaction(t) -> out {= + for(size_t i = 0; i < 4; i++) { + out[i].set(s++); + } + =} } reactor Destination(width: size_t = 4) { - state s: int = 6 - input[width] in: int - - reaction(in) {= - int sum = 0; - for (auto i : in.present_indices_unsorted()) { - sum += *in[i].get(); - } - - std::cout << "Sum of received: " << sum << ".\n"; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << ".\n"; - exit(1); - } - s += 16; - =} - - reaction(shutdown) {= - if (s <= 6) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + state s: int = 6 + input[width] in: int + + reaction(in) {= + int sum = 0; + for (auto i : in.present_indices_unsorted()) { + sum += *in[i].get(); + } + + std::cout << "Sum of received: " << sum << ".\n"; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << ".\n"; + exit(1); + } + s += 16; + =} + + reaction(shutdown) {= + if (s <= 6) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } reactor Container(width: size_t = 4) { - input[width] in: int - dst = new Destination() - in -> dst.in + input[width] in: int + dst = new Destination() + in -> dst.in } main reactor MultiportToHierarchy(width: size_t = 4) { - a = new Source(width = width) - b = new Container(width = width) - a.out -> b.in + a = new Source(width = width) + b = new Container(width = width) + a.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportToMultiport.lf b/test/Cpp/src/multiport/MultiportToMultiport.lf index 37a1ee5222..b018299508 100644 --- a/test/Cpp/src/multiport/MultiportToMultiport.lf +++ b/test/Cpp/src/multiport/MultiportToMultiport.lf @@ -1,40 +1,40 @@ target Cpp reactor Source { - output[4] out: unsigned + output[4] out: unsigned - reaction(startup) -> out {= - for (unsigned i = 0; i < out.size(); i++) { - out[i].set(i); - } - =} + reaction(startup) -> out {= + for (unsigned i = 0; i < out.size(); i++) { + out[i].set(i); + } + =} } reactor Sink { - input[4] in: unsigned - state received: bool = false + input[4] in: unsigned + state received: bool = false - reaction(in) {= - for (unsigned i = 0; i < in.size(); i++) { - std::cout << "Received " << *in[i].get() << '\n'; - received = true; - if (*in[i].get() != i) { - std::cerr << "Error: expected " << i << "!\n"; - exit(1); - } + reaction(in) {= + for (unsigned i = 0; i < in.size(); i++) { + std::cout << "Received " << *in[i].get() << '\n'; + received = true; + if (*in[i].get() != i) { + std::cerr << "Error: expected " << i << "!\n"; + exit(1); } - =} + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "Error: No data received!\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "Error: No data received!\n"; + exit(2); + } + =} } main reactor MultiportToMultiport { - source = new Source() - sink = new Sink() - source.out -> sink.in + source = new Source() + sink = new Sink() + source.out -> sink.in } diff --git a/test/Cpp/src/multiport/MultiportToMultiport2.lf b/test/Cpp/src/multiport/MultiportToMultiport2.lf index 165f3201ce..eafe9fee3c 100644 --- a/test/Cpp/src/multiport/MultiportToMultiport2.lf +++ b/test/Cpp/src/multiport/MultiportToMultiport2.lf @@ -2,35 +2,35 @@ target Cpp reactor Source(width: size_t = 2) { - output[width] out: size_t + output[width] out: size_t - reaction(startup) -> out {= - for (size_t i = 0; i < out.size(); i++) { - out[i].set(i); - } - =} + reaction(startup) -> out {= + for (size_t i = 0; i < out.size(); i++) { + out[i].set(i); + } + =} } reactor Destination(width: size_t = 2) { - input[width] in: size_t + input[width] in: size_t - reaction(in) {= - for (auto i: in.present_indices_unsorted()) { - size_t value = *in[i].get(); - std::cout << "Received on channel " << i << ": " << value << '\n'; - // NOTE: For testing purposes, this assumes the specific - // widths instantiated below. - if (value != i % 3) { - std::cerr << "ERROR: expected " << i % 3 << '\n'; - exit(1); - } + reaction(in) {= + for (auto i: in.present_indices_unsorted()) { + size_t value = *in[i].get(); + std::cout << "Received on channel " << i << ": " << value << '\n'; + // NOTE: For testing purposes, this assumes the specific + // widths instantiated below. + if (value != i % 3) { + std::cerr << "ERROR: expected " << i % 3 << '\n'; + exit(1); } - =} + } + =} } main reactor MultiportToMultiport2 { - a1 = new Source(width = 3) - a2 = new Source(width = 2) - b = new Destination(width = 5) - a1.out, a2.out -> b.in + a1 = new Source(width = 3) + a2 = new Source(width = 2) + b = new Destination(width = 5) + a1.out, a2.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportToMultiport2After.lf b/test/Cpp/src/multiport/MultiportToMultiport2After.lf index 781275b2f4..ed64200076 100644 --- a/test/Cpp/src/multiport/MultiportToMultiport2After.lf +++ b/test/Cpp/src/multiport/MultiportToMultiport2After.lf @@ -2,41 +2,41 @@ target Cpp reactor Source(width: size_t = 2) { - output[width] out: size_t + output[width] out: size_t - reaction(startup) -> out {= - for (size_t i = 0; i < out.size(); i++) { - out[i].set(i); - } - =} + reaction(startup) -> out {= + for (size_t i = 0; i < out.size(); i++) { + out[i].set(i); + } + =} } reactor Destination(width: size_t = 2) { - input[width] in: size_t + input[width] in: size_t - reaction(in) {= - for (size_t i = 0; i < in.size(); i++) { - if (in[i].is_present()) { - size_t value = *in[i].get(); - std::cout << "Received on channel " << i << ": " << value << '\n'; - // NOTE: For testing purposes, this assumes the specific - // widths instantiated below. - if (value != i % 3) { - std::cerr << "ERROR: expected " << i % 3 << '\n'; - exit(1); - } + reaction(in) {= + for (size_t i = 0; i < in.size(); i++) { + if (in[i].is_present()) { + size_t value = *in[i].get(); + std::cout << "Received on channel " << i << ": " << value << '\n'; + // NOTE: For testing purposes, this assumes the specific + // widths instantiated below. + if (value != i % 3) { + std::cerr << "ERROR: expected " << i % 3 << '\n'; + exit(1); } } - if (get_elapsed_logical_time() != 1s) { - std::cerr << "ERROR: Expected to receive input after one second.\n"; - exit(2); - } - =} + } + if (get_elapsed_logical_time() != 1s) { + std::cerr << "ERROR: Expected to receive input after one second.\n"; + exit(2); + } + =} } main reactor { - a1 = new Source(width = 3) - a2 = new Source(width = 2) - b = new Destination(width = 5) - a1.out, a2.out -> b.in after 1 sec + a1 = new Source(width = 3) + a2 = new Source(width = 2) + b = new Destination(width = 5) + a1.out, a2.out -> b.in after 1 sec } diff --git a/test/Cpp/src/multiport/MultiportToMultiportArray.lf b/test/Cpp/src/multiport/MultiportToMultiportArray.lf index 6c96d17150..fce25b346b 100644 --- a/test/Cpp/src/multiport/MultiportToMultiportArray.lf +++ b/test/Cpp/src/multiport/MultiportToMultiportArray.lf @@ -1,60 +1,59 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[2] out: int[3] - state s: int = 0 + timer t(0, 200 msec) + output[2] out: int[3] + state s: int = 0 - reaction(t) -> out {= - for(int i = 0; i < 2; i++) { - // Dynamically allocate a new output array - auto a = reactor::make_mutable_value>(); - // initialize it - (*a)[0] = s++; - (*a)[1] = s++; - (*a)[2] = s++; - // and send it - out[i].set(std::move(a)); - } - =} + reaction(t) -> out {= + for(int i = 0; i < 2; i++) { + // Dynamically allocate a new output array + auto a = reactor::make_mutable_value>(); + // initialize it + (*a)[0] = s++; + (*a)[1] = s++; + (*a)[2] = s++; + // and send it + out[i].set(std::move(a)); + } + =} } reactor Destination { - state s: int = 15 - input[2] in: int[3] + state s: int = 15 + input[2] in: int[3] - reaction(in) {= - int sum = 0; - for (auto i : in.present_indices_unsorted()) { - const auto& a = *in[i].get(); - for (int j = 0; j < a.size(); j++) { - sum += a[j]; - } - } - std::cout << "Sum of received: " << sum << '\n'; - if (sum != s) { - std::cerr << "ERROR: Expected " << s << '\n'; - exit(1); + reaction(in) {= + int sum = 0; + for (auto i : in.present_indices_unsorted()) { + const auto& a = *in[i].get(); + for (int j = 0; j < a.size(); j++) { + sum += a[j]; } - s += 36; - =} + } + std::cout << "Sum of received: " << sum << '\n'; + if (sum != s) { + std::cerr << "ERROR: Expected " << s << '\n'; + exit(1); + } + s += 36; + =} - reaction(shutdown) {= - if (s <= 15) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (s <= 15) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor MultiportToMultiportArray { - a = new Source() - b = new Destination() - a.out -> b.in + a = new Source() + b = new Destination() + a.out -> b.in } diff --git a/test/Cpp/src/multiport/MultiportToMultiportPhysical.lf b/test/Cpp/src/multiport/MultiportToMultiportPhysical.lf index 43cdcbc713..7418bee409 100644 --- a/test/Cpp/src/multiport/MultiportToMultiportPhysical.lf +++ b/test/Cpp/src/multiport/MultiportToMultiportPhysical.lf @@ -1,44 +1,44 @@ target Cpp reactor Source { - output[4] out: unsigned + output[4] out: unsigned - reaction(startup) -> out {= - for (unsigned i = 0; i < out.size(); i++) { - out[i].set(i); - } - =} + reaction(startup) -> out {= + for (unsigned i = 0; i < out.size(); i++) { + out[i].set(i); + } + =} } reactor Sink { - input[4] in: unsigned - state received: int(-1) + input[4] in: unsigned + state received: int(-1) - reaction(in) {= - auto present_ports = in.present_indices_unsorted(); - if (present_ports.size() != 1) { - reactor::log::Error() << "Expected only one value, but got " << present_ports.size(); - exit(1); - } - int idx = present_ports[0]; - std::cout << "Received " << *in[idx].get() << '\n'; - if (idx <= received) { - reactor::log::Error() << "Received index " << idx << " after " << received; - exit(2); - } - received = idx; - =} + reaction(in) {= + auto present_ports = in.present_indices_unsorted(); + if (present_ports.size() != 1) { + reactor::log::Error() << "Expected only one value, but got " << present_ports.size(); + exit(1); + } + int idx = present_ports[0]; + std::cout << "Received " << *in[idx].get() << '\n'; + if (idx <= received) { + reactor::log::Error() << "Received index " << idx << " after " << received; + exit(2); + } + received = idx; + =} - reaction(shutdown) {= - if (received != 3) { - std::cerr << "Error: No data received!\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (received != 3) { + std::cerr << "Error: No data received!\n"; + exit(2); + } + =} } main reactor { - source = new Source() - sink = new Sink() - source.out ~> sink.in + source = new Source() + sink = new Sink() + source.out ~> sink.in } diff --git a/test/Cpp/src/multiport/MultiportToPort.lf b/test/Cpp/src/multiport/MultiportToPort.lf index c2b0bd66ef..ed69542aa7 100644 --- a/test/Cpp/src/multiport/MultiportToPort.lf +++ b/test/Cpp/src/multiport/MultiportToPort.lf @@ -1,46 +1,45 @@ -// Check multiport output to multiport input. Destination port is wider than -// sending port. +// Check multiport output to multiport input. Destination port is wider than sending port. target Cpp { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output[2] out: int + output[2] out: int - reaction(startup) -> out {= - for(int i = 0; i < out.size(); i++) { - std::cout << "Source sending " << i << ".\n"; - out[i].set(i); - } - =} + reaction(startup) -> out {= + for(int i = 0; i < out.size(); i++) { + std::cout << "Source sending " << i << ".\n"; + out[i].set(i); + } + =} } reactor Destination(expected: int = 0) { - input in: int - state received: bool = false + input in: int + state received: bool = false - reaction(in) {= - std::cout << "Received: " << *in.get() << ".\n"; - received = true; - if (*in.get() != expected) { - std::cerr << "ERROR: Expected " << expected << ".\n"; - exit(1); - } - =} + reaction(in) {= + std::cout << "Received: " << *in.get() << ".\n"; + received = true; + if (*in.get() != expected) { + std::cerr << "ERROR: Expected " << expected << ".\n"; + exit(1); + } + =} - reaction(shutdown) {= - if (!received) { - std::cerr << "ERROR: Destination received no input!\n"; - exit(1); - } - std::cout << "Success.\n"; - =} + reaction(shutdown) {= + if (!received) { + std::cerr << "ERROR: Destination received no input!\n"; + exit(1); + } + std::cout << "Success.\n"; + =} } main reactor MultiportToPort { - a = new Source() - b1 = new Destination() - b2 = new Destination(expected = 1) - a.out -> b1.in, b2.in + a = new Source() + b1 = new Destination() + b2 = new Destination(expected = 1) + a.out -> b1.in, b2.in } diff --git a/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf b/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf index 6fa6dbb87b..329ac18ed7 100644 --- a/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf +++ b/test/Cpp/src/multiport/ReadMultiportOutputOfContainedBank.lf @@ -1,70 +1,69 @@ -// Test reacting to and reading outputs from a contained reactor bank with a -// multiport +// Test reacting to and reading outputs from a contained reactor bank with a multiport target Cpp reactor Contained(bank_index: size_t = 0) { - output[3] out: unsigned + output[3] out: unsigned - reaction(startup) -> out {= - for (size_t i = 0; i < 3; i++) { - out[i].set(bank_index * i); - } - =} + reaction(startup) -> out {= + for (size_t i = 0; i < 3; i++) { + out[i].set(bank_index * i); + } + =} } main reactor { - c = new[3] Contained() - state count: int = 0 + c = new[3] Contained() + state count: int = 0 - reaction(startup) c.out {= - for (size_t i = 0; i < c.size(); i++) { - for (size_t j = 0; j < c[i].out.size(); j++) { - unsigned result = *c[i].out[j].get(); - std::cout << "Startup reaction reading output of contained " - << "reactor: " << result << std::endl; - if (result != i * j) { - std::cout << "FAILURE: expected " << i * j << std::endl; - exit(2); - } + reaction(startup) c.out {= + for (size_t i = 0; i < c.size(); i++) { + for (size_t j = 0; j < c[i].out.size(); j++) { + unsigned result = *c[i].out[j].get(); + std::cout << "Startup reaction reading output of contained " + << "reactor: " << result << std::endl; + if (result != i * j) { + std::cout << "FAILURE: expected " << i * j << std::endl; + exit(2); } } - count++; - =} + } + count++; + =} - reaction(c.out) {= - for (size_t i = 0; i < c.size(); i++) { - for (size_t j = 0; j < c[i].out.size(); j++) { - unsigned result = *c[i].out[j].get(); - std::cout << "Reading output of contained reactor: " << result << std::endl; - if (result != i * j) { - std::cout << "FAILURE: expected " << i * j << std::endl; - exit(2); - } + reaction(c.out) {= + for (size_t i = 0; i < c.size(); i++) { + for (size_t j = 0; j < c[i].out.size(); j++) { + unsigned result = *c[i].out[j].get(); + std::cout << "Reading output of contained reactor: " << result << std::endl; + if (result != i * j) { + std::cout << "FAILURE: expected " << i * j << std::endl; + exit(2); } } - count++; - =} + } + count++; + =} - reaction(startup, c.out) {= - for (size_t i = 0; i < c.size(); i++) { - for (size_t j = 0; j < c[i].out.size(); j++) { - unsigned result = *c[i].out[j].get(); - std::cout << "Alternate triggering reading output of contained " - << "reactor: " << result << std::endl; - if (result != i * j) { - std::cout << "FAILURE: expected " << i * j << std::endl; - exit(2); - } + reaction(startup, c.out) {= + for (size_t i = 0; i < c.size(); i++) { + for (size_t j = 0; j < c[i].out.size(); j++) { + unsigned result = *c[i].out[j].get(); + std::cout << "Alternate triggering reading output of contained " + << "reactor: " << result << std::endl; + if (result != i * j) { + std::cout << "FAILURE: expected " << i * j << std::endl; + exit(2); } } - count++; - =} + } + count++; + =} - reaction(shutdown) {= - if (count != 3) { - std::cerr << "ERROR: One of the reactions failed to trigger." - << std::endl; - exit(1); - } - =} + reaction(shutdown) {= + if (count != 3) { + std::cerr << "ERROR: One of the reactions failed to trigger." + << std::endl; + exit(1); + } + =} } diff --git a/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf b/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf index 18179b9086..b9a485ac7d 100644 --- a/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf +++ b/test/Cpp/src/multiport/ReadOutputOfContainedBank.lf @@ -1,61 +1,60 @@ -// Test reacting to and reading outputs from a contained reactor bank in various -// permutations. +// Test reacting to and reading outputs from a contained reactor bank in various permutations. target Cpp reactor Contained(bank_index: size_t = 0) { - output out: unsigned + output out: unsigned - reaction(startup) -> out {= out.set(42 * bank_index); =} + reaction(startup) -> out {= out.set(42 * bank_index); =} } main reactor { - c = new[4] Contained() - state count: int = 0 + c = new[4] Contained() + state count: int = 0 - reaction(startup) c.out {= - for (size_t i = 0; i < c.size(); i++) { - unsigned result = *c[i].out.get(); - std::cout << "Startup reaction reading output of contained " - << "reactor: " << result << std::endl; - if (result != 42 * i) { - std::cout << "FAILURE: expected " << 42 * i << std::endl; - exit(2); - } + reaction(startup) c.out {= + for (size_t i = 0; i < c.size(); i++) { + unsigned result = *c[i].out.get(); + std::cout << "Startup reaction reading output of contained " + << "reactor: " << result << std::endl; + if (result != 42 * i) { + std::cout << "FAILURE: expected " << 42 * i << std::endl; + exit(2); } - count++; - =} + } + count++; + =} - reaction(c.out) {= - for (size_t i = 0; i < c.size(); i++) { - unsigned result = *c[i].out.get(); - std::cout << "Reading output of contained reactor: " << result - << std::endl; - if (result != 42 * i) { - std::cout << "FAILURE: expected " << 42 * i << std::endl; - exit(2); - } + reaction(c.out) {= + for (size_t i = 0; i < c.size(); i++) { + unsigned result = *c[i].out.get(); + std::cout << "Reading output of contained reactor: " << result + << std::endl; + if (result != 42 * i) { + std::cout << "FAILURE: expected " << 42 * i << std::endl; + exit(2); } - count++; - =} + } + count++; + =} - reaction(startup, c.out) {= - for (size_t i = 0; i < c.size(); i++) { - unsigned result = *c[i].out.get(); - std::cout << "Alternate triggering reading output of contained " - << "reactor: " << result << std::endl; - if (result != 42 * i) { - std::cout << "FAILURE: expected " << 42 * i << std::endl; - exit(2); - } + reaction(startup, c.out) {= + for (size_t i = 0; i < c.size(); i++) { + unsigned result = *c[i].out.get(); + std::cout << "Alternate triggering reading output of contained " + << "reactor: " << result << std::endl; + if (result != 42 * i) { + std::cout << "FAILURE: expected " << 42 * i << std::endl; + exit(2); } - count++; - =} + } + count++; + =} - reaction(shutdown) {= - if (count != 3) { - std::cerr << "ERROR: One of the reactions failed to trigger." - << std::endl; - exit(1); - } - =} + reaction(shutdown) {= + if (count != 3) { + std::cerr << "ERROR: One of the reactions failed to trigger." + << std::endl; + exit(1); + } + =} } diff --git a/test/Cpp/src/multiport/SparseMultiport.lf b/test/Cpp/src/multiport/SparseMultiport.lf index c0ffff2e12..f126ce385d 100644 --- a/test/Cpp/src/multiport/SparseMultiport.lf +++ b/test/Cpp/src/multiport/SparseMultiport.lf @@ -1,49 +1,31 @@ target Cpp { - timeout: 1 s + timeout: 1 s } reactor Producer { - timer t(0, 100 ms) + timer t(0, 100 ms) - output[10] out: int + output[10] out: int - state odd: bool(true) + state odd: bool(true) - reaction(t) -> out {= - for (int i{odd ? 1 : 0}; i < 10; i += 2) { - out[i].set(i); - } + reaction(t) -> out {= + for (int i{odd ? 1 : 0}; i < 10; i += 2) { + out[i].set(i); + } - odd = !odd; - =} + odd = !odd; + =} } reactor Consumer { - state odd: bool(true) - input[10] in: int - - reaction(in) {= - reactor::log::Info() << "Received:"; - for (int i{0}; i < 10; i++) { - if (in[i].is_present()) { - if (odd && i%2 == 0) { - reactor::log::Error() << "Expected values only on odd ports, but received one on port " << i; - exit(1); - } - if (!odd && i%2 == 1) { - reactor::log::Error() << "Expected values only on even ports, but received one on port " << i; - exit(1); - } - reactor::log::Info() << "- " << i; - } - } - =} + state odd: bool(true) + input[10] in: int - reaction(in) {= - int count = 0; - int last = -1; - for (int i : in.present_indices_sorted()) { - count++; + reaction(in) {= + reactor::log::Info() << "Received:"; + for (int i{0}; i < 10; i++) { + if (in[i].is_present()) { if (odd && i%2 == 0) { reactor::log::Error() << "Expected values only on odd ports, but received one on port " << i; exit(1); @@ -52,34 +34,52 @@ reactor Consumer { reactor::log::Error() << "Expected values only on even ports, but received one on port " << i; exit(1); } - if (i < last) { - reactor::log::Error() << "Received index out of order! " << i << " after " << last; - exit(1); - } + reactor::log::Info() << "- " << i; } - for (int i : in.present_indices_unsorted()) { - count++; - if (odd && i%2 == 0) { - reactor::log::Error() << "Expected values only on odd ports, but received one on port " << i; - exit(1); - } - if (!odd && i%2 == 1) { - reactor::log::Error() << "Expected values only on even ports, but received one on port " << i; - exit(1); - } + } + =} + + reaction(in) {= + int count = 0; + int last = -1; + for (int i : in.present_indices_sorted()) { + count++; + if (odd && i%2 == 0) { + reactor::log::Error() << "Expected values only on odd ports, but received one on port " << i; + exit(1); + } + if (!odd && i%2 == 1) { + reactor::log::Error() << "Expected values only on even ports, but received one on port " << i; + exit(1); + } + if (i < last) { + reactor::log::Error() << "Received index out of order! " << i << " after " << last; + exit(1); + } + } + for (int i : in.present_indices_unsorted()) { + count++; + if (odd && i%2 == 0) { + reactor::log::Error() << "Expected values only on odd ports, but received one on port " << i; + exit(1); } - if (count != 10) { - reactor::log::Error() << "Expected count to be 10, but got " << count; + if (!odd && i%2 == 1) { + reactor::log::Error() << "Expected values only on even ports, but received one on port " << i; exit(1); } + } + if (count != 10) { + reactor::log::Error() << "Expected count to be 10, but got " << count; + exit(1); + } - odd = !odd; - =} + odd = !odd; + =} } main reactor { - c = new Consumer() - p = new Producer() + c = new Consumer() + p = new Producer() - p.out -> c.in + p.out -> c.in } diff --git a/test/Cpp/src/multiport/WidthGivenByCode.lf b/test/Cpp/src/multiport/WidthGivenByCode.lf index 10a2a59489..6bfc814650 100644 --- a/test/Cpp/src/multiport/WidthGivenByCode.lf +++ b/test/Cpp/src/multiport/WidthGivenByCode.lf @@ -1,37 +1,37 @@ target Cpp reactor Foo(a: size_t = 8, b: size_t = 2) { - input[{= a*b =}] in: size_t - output[{= a/b =}] out: size_t + input[{= a*b =}] in: size_t + output[{= a/b =}] out: size_t - reaction(startup) in -> out {= - if (in.size() != a*b) { - std::cerr << "ERROR: expected in to have a width of " << a*b << '\n'; - exit(1); - } - if (out.size() != a/b) { - std::cerr << "ERROR: expected out to have a width of " << a/b << '\n'; - exit(2); - } - =} + reaction(startup) in -> out {= + if (in.size() != a*b) { + std::cerr << "ERROR: expected in to have a width of " << a*b << '\n'; + exit(1); + } + if (out.size() != a/b) { + std::cerr << "ERROR: expected out to have a width of " << a/b << '\n'; + exit(2); + } + =} } main reactor { - foo1 = new Foo() - foo2 = new Foo(a = 10, b = 3) - foo3 = new Foo(a = 9, b = 9) - foo_bank = new[{= 42 =}] Foo() + foo1 = new Foo() + foo2 = new Foo(a = 10, b = 3) + foo3 = new Foo(a = 9, b = 9) + foo_bank = new[{= 42 =}] Foo() - reaction(startup) foo_bank.out {= - if (foo_bank.size() != 42) { - std::cerr << "ERROR: expected foo_bank to have a width of " << 42 << '\n'; - exit(3); - } - for (auto& foo : foo_bank) { - if (foo.out.size() != 4) { - std::cerr << "ERROR: expected foo_bank.out to have a width of " << 4 << '\n'; - exit(4); - } + reaction(startup) foo_bank.out {= + if (foo_bank.size() != 42) { + std::cerr << "ERROR: expected foo_bank to have a width of " << 42 << '\n'; + exit(3); + } + for (auto& foo : foo_bank) { + if (foo.out.size() != 4) { + std::cerr << "ERROR: expected foo_bank.out to have a width of " << 4 << '\n'; + exit(4); } - =} + } + =} } diff --git a/test/Cpp/src/multiport/WriteInputOfContainedBank.lf b/test/Cpp/src/multiport/WriteInputOfContainedBank.lf index b8f8d50958..87258ae953 100644 --- a/test/Cpp/src/multiport/WriteInputOfContainedBank.lf +++ b/test/Cpp/src/multiport/WriteInputOfContainedBank.lf @@ -2,33 +2,33 @@ target Cpp reactor Contained(bank_index: size_t = 0) { - input in: unsigned - state count: int = 0 + input in: unsigned + state count: int = 0 - reaction(in) {= - unsigned result = *in.get(); - std::cout << "Instance " << bank_index << " received " << result << '\n'; - if (result != bank_index * 42) { - std::cout << "FAILURE: expected " << 42 * bank_index << '\n'; - exit(2); - } - count++; - =} + reaction(in) {= + unsigned result = *in.get(); + std::cout << "Instance " << bank_index << " received " << result << '\n'; + if (result != bank_index * 42) { + std::cout << "FAILURE: expected " << 42 * bank_index << '\n'; + exit(2); + } + count++; + =} - reaction(shutdown) {= - if (count != 1) { - std::cerr << "ERROR: One of the reactions failed to trigger.\n"; - exit(1); - } - =} + reaction(shutdown) {= + if (count != 1) { + std::cerr << "ERROR: One of the reactions failed to trigger.\n"; + exit(1); + } + =} } main reactor { - c = new[4] Contained() + c = new[4] Contained() - reaction(startup) -> c.in {= - for (size_t i = 0; i < c.size(); i++) { - c[i].in.set(i*42); - } - =} + reaction(startup) -> c.in {= + for (size_t i = 0; i < c.size(); i++) { + c[i].in.set(i*42); + } + =} } diff --git a/test/Cpp/src/multiport/WriteMultiportInputOfContainedBank.lf b/test/Cpp/src/multiport/WriteMultiportInputOfContainedBank.lf index 5ffe567dfb..2bb7c12b9a 100644 --- a/test/Cpp/src/multiport/WriteMultiportInputOfContainedBank.lf +++ b/test/Cpp/src/multiport/WriteMultiportInputOfContainedBank.lf @@ -2,37 +2,37 @@ target Cpp reactor Contained(bank_index: size_t = 0) { - input[4] in: unsigned - state count: int = 0 + input[4] in: unsigned + state count: int = 0 - reaction(in) {= - for (size_t i = 0; i < 3; i++) { - unsigned result = *in[i].get(); - std::cout << "Instance " << bank_index << " received " << result << '\n'; - if (result != bank_index * i) { - std::cout << "FAILURE: expected " << i * bank_index << '\n'; - exit(2); - } + reaction(in) {= + for (size_t i = 0; i < 3; i++) { + unsigned result = *in[i].get(); + std::cout << "Instance " << bank_index << " received " << result << '\n'; + if (result != bank_index * i) { + std::cout << "FAILURE: expected " << i * bank_index << '\n'; + exit(2); } - count++; - =} + } + count++; + =} - reaction(shutdown) {= - if (count != 1) { - std::cerr << "ERROR: One of the reactions failed to trigger.\n"; - exit(1); - } - =} + reaction(shutdown) {= + if (count != 1) { + std::cerr << "ERROR: One of the reactions failed to trigger.\n"; + exit(1); + } + =} } main reactor { - c = new[4] Contained() + c = new[4] Contained() - reaction(startup) -> c.in {= - for (size_t i = 0; i < c.size(); i++) { - for (size_t j = 0; j < c[i].in.size(); j++) { - c[i].in[j].set(i*j); - } + reaction(startup) -> c.in {= + for (size_t i = 0; i < c.size(); i++) { + for (size_t j = 0; j < c[i].in.size(); j++) { + c[i].in[j].set(i*j); } - =} + } + =} } diff --git a/test/Cpp/src/properties/Fast.lf b/test/Cpp/src/properties/Fast.lf index 1d4ba25d2f..97e40f05b8 100644 --- a/test/Cpp/src/properties/Fast.lf +++ b/test/Cpp/src/properties/Fast.lf @@ -1,28 +1,28 @@ target Cpp { - fast: true + fast: true } main reactor { - logical action a + logical action a - state triggered: bool = false + state triggered: bool = false - reaction(startup) -> a {= a.schedule(2s); =} + reaction(startup) -> a {= a.schedule(2s); =} - reaction(a) {= - triggered = true; - if (get_elapsed_physical_time() >= 2s) { - std::cout << "ERROR: needed more than 2s to process the reaction\n"; - exit(1); - } - =} + reaction(a) {= + triggered = true; + if (get_elapsed_physical_time() >= 2s) { + std::cout << "ERROR: needed more than 2s to process the reaction\n"; + exit(1); + } + =} - reaction(shutdown) {= - if (triggered) { - std::cout << "SUCCESS!\n"; - } else { - std::cout << "ERROR: reaction was not invoked!\n"; - exit(2); - } - =} + reaction(shutdown) {= + if (triggered) { + std::cout << "SUCCESS!\n"; + } else { + std::cout << "ERROR: reaction was not invoked!\n"; + exit(2); + } + =} } diff --git a/test/Cpp/src/properties/Timeout.lf b/test/Cpp/src/properties/Timeout.lf index 57c55ad24c..3fd5982952 100644 --- a/test/Cpp/src/properties/Timeout.lf +++ b/test/Cpp/src/properties/Timeout.lf @@ -1,31 +1,31 @@ target Cpp { - timeout: 1 sec + timeout: 1 sec } main reactor { - timer t(1 sec, 1 sec) + timer t(1 sec, 1 sec) - state triggered: bool = false + state triggered: bool = false - reaction(t) {= - triggered = true; - if (get_elapsed_logical_time() != 1s) { - std::cout << "ERROR: triggered reaction at an unexpected tag"; - exit(1); - } - =} + reaction(t) {= + triggered = true; + if (get_elapsed_logical_time() != 1s) { + std::cout << "ERROR: triggered reaction at an unexpected tag"; + exit(1); + } + =} - reaction(shutdown) {= - if (get_elapsed_logical_time() != 1s || get_microstep() != 0) { - std::cout << "ERROR: shutdown invoked at an unexpected tag"; - exit(2); - } + reaction(shutdown) {= + if (get_elapsed_logical_time() != 1s || get_microstep() != 0) { + std::cout << "ERROR: shutdown invoked at an unexpected tag"; + exit(2); + } - if (triggered) { - std::cout << "SUCCESS!\n"; - } else { - std::cout << "ERROR: reaction was not invoked!\n"; - exit(2); - } - =} + if (triggered) { + std::cout << "SUCCESS!\n"; + } else { + std::cout << "ERROR: reaction was not invoked!\n"; + exit(2); + } + =} } diff --git a/test/Cpp/src/properties/TimeoutZero.lf b/test/Cpp/src/properties/TimeoutZero.lf index 9d04fa8048..c49db95731 100644 --- a/test/Cpp/src/properties/TimeoutZero.lf +++ b/test/Cpp/src/properties/TimeoutZero.lf @@ -1,31 +1,31 @@ target Cpp { - timeout: 0 sec + timeout: 0 sec } main reactor { - timer t(0, 1 sec) + timer t(0, 1 sec) - state triggered: bool = false + state triggered: bool = false - reaction(t) {= - triggered = true; - if (get_elapsed_logical_time() != 0s) { - std::cout << "ERROR: triggered reaction at an unexpected tag"; - exit(1); - } - =} + reaction(t) {= + triggered = true; + if (get_elapsed_logical_time() != 0s) { + std::cout << "ERROR: triggered reaction at an unexpected tag"; + exit(1); + } + =} - reaction(shutdown) {= - if (get_elapsed_logical_time() != 0s || get_microstep() != 0) { - std::cout << "ERROR: shutdown invoked at an unexpected tag"; - exit(2); - } + reaction(shutdown) {= + if (get_elapsed_logical_time() != 0s || get_microstep() != 0) { + std::cout << "ERROR: shutdown invoked at an unexpected tag"; + exit(2); + } - if (triggered) { - std::cout << "SUCCESS!\n"; - } else { - std::cout << "ERROR: reaction was not invoked!\n"; - exit(2); - } - =} + if (triggered) { + std::cout << "SUCCESS!\n"; + } else { + std::cout << "ERROR: reaction was not invoked!\n"; + exit(2); + } + =} } diff --git a/test/Cpp/src/target/AfterVoid.lf b/test/Cpp/src/target/AfterVoid.lf index 555e024e6b..dbb0041a3e 100644 --- a/test/Cpp/src/target/AfterVoid.lf +++ b/test/Cpp/src/target/AfterVoid.lf @@ -1,44 +1,44 @@ // This checks that the after keyword also works with void ports target Cpp { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } reactor foo { - timer t(0, 1 sec) - output y: void + timer t(0, 1 sec) + output y: void - reaction(t) -> y {= y.set(); =} + reaction(t) -> y {= y.set(); =} } reactor print { - state expected_time: time = 10 msec - state i: int = 0 - input x: void + state expected_time: time = 10 msec + state i: int = 0 + input x: void - reaction(x) {= - i++; - auto elapsed_time = get_elapsed_logical_time(); - std::cout << "Current logical time is: " << elapsed_time << '\n'; - std::cout << "Current physical time is: " << get_elapsed_physical_time() << '\n'; - if (elapsed_time != expected_time) { - std::cerr << "ERROR: Expected logical time to be " << expected_time << '\n'; - exit(2); - } - expected_time += 1s; - =} + reaction(x) {= + i++; + auto elapsed_time = get_elapsed_logical_time(); + std::cout << "Current logical time is: " << elapsed_time << '\n'; + std::cout << "Current physical time is: " << get_elapsed_physical_time() << '\n'; + if (elapsed_time != expected_time) { + std::cerr << "ERROR: Expected logical time to be " << expected_time << '\n'; + exit(2); + } + expected_time += 1s; + =} - reaction(shutdown) {= - if (i == 0) { - std::cerr << "ERROR: Final reactor received no data.\n"; - exit(3); - } - =} + reaction(shutdown) {= + if (i == 0) { + std::cerr << "ERROR: Final reactor received no data.\n"; + exit(3); + } + =} } main reactor { - f = new foo() - p = new print() + f = new foo() + p = new print() - f.y -> p.x after 10 msec + f.y -> p.x after 10 msec } diff --git a/test/Cpp/src/target/BraceAndParenInitialization.lf b/test/Cpp/src/target/BraceAndParenInitialization.lf index 003b6d509d..e6ab2168f3 100644 --- a/test/Cpp/src/target/BraceAndParenInitialization.lf +++ b/test/Cpp/src/target/BraceAndParenInitialization.lf @@ -1,30 +1,28 @@ target Cpp reactor Foo( - param_list_1: std::vector(4, 2), // list containing [2,2,2,2] - param_list_2: std::vector{4, 2}, // list containing [4,2] - param_list_3: std::vector(4, 2), // list containing [2,2,2,2] - param_list_4: std::vector{4, 2} // list containing [4,2] + param_list_1: std::vector(4, 2), // list containing [2,2,2,2] + param_list_2: std::vector{4, 2}, // list containing [4,2] + param_list_3: std::vector(4, 2), // list containing [2,2,2,2] + param_list_4: std::vector{4, 2} // list containing [4,2] ) { - // list containing [42,42,42,42,42,42] - state state_list_1: std::vector(6, 42) - // list containing [6,42] - state state_list_2: std::vector{6, 42} + state state_list_1: std::vector(6, 42) // list containing [42,42,42,42,42,42] + state state_list_2: std::vector{6, 42} // list containing [6,42] - reaction(startup) {= - std::cerr << "Hello!\n"; - if (param_list_1.size() != 4 || param_list_1[0] != 2 || - param_list_2.size() != 2 || param_list_2[0] != 4 || - param_list_3.size() != 3 || param_list_3[0] != 5 || - param_list_4.size() != 2 || param_list_4[0] != 3 || - state_list_1.size() != 6 || state_list_1[0] != 42 || - state_list_2.size() != 2 || state_list_2[0] != 6) { - std::cerr << "Error!\n"; - exit(1); - } - =} + reaction(startup) {= + std::cerr << "Hello!\n"; + if (param_list_1.size() != 4 || param_list_1[0] != 2 || + param_list_2.size() != 2 || param_list_2[0] != 4 || + param_list_3.size() != 3 || param_list_3[0] != 5 || + param_list_4.size() != 2 || param_list_4[0] != 3 || + state_list_1.size() != 6 || state_list_1[0] != 42 || + state_list_2.size() != 2 || state_list_2[0] != 6) { + std::cerr << "Error!\n"; + exit(1); + } + =} } main reactor { - foo = new Foo(param_list_3 = {= std::vector(3, 5) =}, param_list_4 = {3, 5}) + foo = new Foo(param_list_3 = {= std::vector(3, 5) =}, param_list_4 = {3, 5}) } diff --git a/test/Cpp/src/target/CliParserGenericArguments.lf b/test/Cpp/src/target/CliParserGenericArguments.lf index 9a008ebcab..4ab5729088 100644 --- a/test/Cpp/src/target/CliParserGenericArguments.lf +++ b/test/Cpp/src/target/CliParserGenericArguments.lf @@ -6,57 +6,57 @@ target Cpp public preamble {= - using unsigned_long = unsigned long; - using long_long = long long; - using uns_long_long = unsigned long long; - using long_double = long double; + using unsigned_long = unsigned long; + using long_long = long long; + using uns_long_long = unsigned long long; + using long_double = long double; - #include - #include - using namespace std; - class CustomClass { - public: - std::string name; - CustomClass(std::string new_name="John") : name{new_name} - {} - std::string get_name() const {return this->name;} - void set_name(std::string updated_name){this->name = updated_name;} - }; + #include + #include + using namespace std; + class CustomClass { + public: + std::string name; + CustomClass(std::string new_name="John") : name{new_name} + {} + std::string get_name() const {return this->name;} + void set_name(std::string updated_name){this->name = updated_name;} + }; - ostream& operator<<(ostream& os, const CustomClass& cc); + ostream& operator<<(ostream& os, const CustomClass& cc); - stringstream& operator>>(stringstream& in, CustomClass& cc); + stringstream& operator>>(stringstream& in, CustomClass& cc); =} private preamble {= - stringstream& operator>>(stringstream& in, CustomClass& cc) - { - cc.set_name(in.str()); - return in; - } + stringstream& operator>>(stringstream& in, CustomClass& cc) + { + cc.set_name(in.str()); + return in; + } - ostream& operator<<(ostream& os, const CustomClass& cc) - { - os << cc.get_name(); - return os; - } + ostream& operator<<(ostream& os, const CustomClass& cc) + { + os << cc.get_name(); + return os; + } =} main reactor CliParserGenericArguments( - int_value: int = 10, - signed_value: signed = -10, - unsigned_value: unsigned = 11, - long_value: long = -100, - unsigned_long_value: {= unsigned_long =} = 42, - long_long_value: {= long_long =} = -42, - ull_value: {= uns_long_long =} = 42, - bool_value: bool = false, - char_value: char = 'T', - double_value: double = 4.2, - long_double_value: {= long_double =} = 4.2, - float_value: float = 10.5, - string_value: string = "This is a testvalue", - custom_class_value: {= CustomClass =}("Peter") + int_value: int = 10, + signed_value: signed = -10, + unsigned_value: unsigned = 11, + long_value: long = -100, + unsigned_long_value: {= unsigned_long =} = 42, + long_long_value: {= long_long =} = -42, + ull_value: {= uns_long_long =} = 42, + bool_value: bool = false, + char_value: char = 'T', + double_value: double = 4.2, + long_double_value: {= long_double =} = 4.2, + float_value: float = 10.5, + string_value: string = "This is a testvalue", + custom_class_value: {= CustomClass =}("Peter") ) { - reaction(startup) {= std::cout << "Hello World!\n"; =} + reaction(startup) {= std::cout << "Hello World!\n"; =} } diff --git a/test/Cpp/src/target/CombinedTypeNames.lf b/test/Cpp/src/target/CombinedTypeNames.lf index d55c70a823..e4ae72cfcd 100644 --- a/test/Cpp/src/target/CombinedTypeNames.lf +++ b/test/Cpp/src/target/CombinedTypeNames.lf @@ -1,22 +1,19 @@ -// This test simply checks if combined type names consisting of multiple words -// (such as `unsigned int`) can be used correctly in LF code. +// This test simply checks if combined type names consisting of multiple words (such as `unsigned +// int`) can be used correctly in LF code. target Cpp -reactor Foo( - bar: {= unsigned int =} = 0, - baz: {= const unsigned int* =} = {= nullptr =} -) { - state s_bar: {= unsigned int =} = bar - state s_baz: {= const unsigned int* =} = baz +reactor Foo(bar: {= unsigned int =} = 0, baz: {= const unsigned int* =} = {= nullptr =}) { + state s_bar: {= unsigned int =} = bar + state s_baz: {= const unsigned int* =} = baz - reaction(startup) {= - if (bar != 42 || s_bar != 42 || *baz != 42 || *s_baz != 42) { - reactor::log::Error() << "Unexpected value!"; - exit(1); - } - =} + reaction(startup) {= + if (bar != 42 || s_bar != 42 || *baz != 42 || *s_baz != 42) { + reactor::log::Error() << "Unexpected value!"; + exit(1); + } + =} } main reactor(bar: {= unsigned int =} = 42) { - foo = new Foo(bar = bar, baz = {= &bar =}) + foo = new Foo(bar = bar, baz = {= &bar =}) } diff --git a/test/Cpp/src/target/GenericAfter.lf b/test/Cpp/src/target/GenericAfter.lf index 25a91e7877..3de5c1dba8 100644 --- a/test/Cpp/src/target/GenericAfter.lf +++ b/test/Cpp/src/target/GenericAfter.lf @@ -3,19 +3,19 @@ target Cpp import Test from "../DelayInt.lf" reactor Delay(delay: time(0)) { - output out: T - input in: T - logical action a(delay): T + output out: T + input in: T + logical action a(delay): T - reaction(a) -> out {= out.set(a.get()); =} + reaction(a) -> out {= out.set(a.get()); =} - reaction(in) -> a {= a.schedule(in.get()); =} + reaction(in) -> a {= a.schedule(in.get()); =} } main reactor { - d = new Delay(delay = 50 msec) - test = new Test() - d.out -> test.in after 50 msec + d = new Delay(delay = 50 msec) + test = new Test() + d.out -> test.in after 50 msec - reaction(startup) -> d.in {= d.in.set(42); =} + reaction(startup) -> d.in {= d.in.set(42); =} } diff --git a/test/Cpp/src/target/GenericDelay.lf b/test/Cpp/src/target/GenericDelay.lf index 5efa81b011..5134f8cde6 100644 --- a/test/Cpp/src/target/GenericDelay.lf +++ b/test/Cpp/src/target/GenericDelay.lf @@ -3,19 +3,19 @@ target Cpp import Test from "../DelayInt.lf" reactor Delay(delay: time = 0) { - output out: T - input in: T - logical action a(delay): T + output out: T + input in: T + logical action a(delay): T - reaction(a) -> out {= out.set(a.get()); =} + reaction(a) -> out {= out.set(a.get()); =} - reaction(in) -> a {= a.schedule(in.get()); =} + reaction(in) -> a {= a.schedule(in.get()); =} } main reactor { - d = new Delay(delay = 100 msec) - test = new Test() - d.out -> test.in + d = new Delay(delay = 100 msec) + test = new Test() + d.out -> test.in - reaction(startup) -> d.in {= d.in.set(42); =} + reaction(startup) -> d.in {= d.in.set(42); =} } diff --git a/test/Cpp/src/target/GenericParameterAndState.lf b/test/Cpp/src/target/GenericParameterAndState.lf index 6803eb9509..76cb2f9c3d 100644 --- a/test/Cpp/src/target/GenericParameterAndState.lf +++ b/test/Cpp/src/target/GenericParameterAndState.lf @@ -1,21 +1,21 @@ target Cpp reactor Foo(bar: T = 0, expected: T = 14542135) { - state baz: T = bar + state baz: T = bar - reaction(startup) {= - if (bar != expected) { - std::cerr << "ERROR: Expected baz=" << expected << " but got baz=" << bar << '\n'; - exit(1); - } - if (baz != expected) { - std::cerr << "ERROR: Expected baz=" << expected << " but got baz=" << baz << '\n'; - exit(1); - } - =} + reaction(startup) {= + if (bar != expected) { + std::cerr << "ERROR: Expected baz=" << expected << " but got baz=" << bar << '\n'; + exit(1); + } + if (baz != expected) { + std::cerr << "ERROR: Expected baz=" << expected << " but got baz=" << baz << '\n'; + exit(1); + } + =} } main reactor { - foo = new Foo(bar = 42, expected = 42) - bar = new Foo(expected = 0) // default value is used + foo = new Foo(bar = 42, expected = 42) + bar = new Foo(expected = 0) // default value is used } diff --git a/test/Cpp/src/target/InitializerSyntax.lf b/test/Cpp/src/target/InitializerSyntax.lf index 54ae268457..998c711f1f 100644 --- a/test/Cpp/src/target/InitializerSyntax.lf +++ b/test/Cpp/src/target/InitializerSyntax.lf @@ -1,89 +1,89 @@ target Cpp public preamble {= - #include - struct TestType { - int x; + #include + struct TestType { + int x; - // constructor #1 - TestType() : x(42) {} - // constructor #2 - TestType(int x) : x(x) {} - // constructor #3 - TestType(std::initializer_list l) : x(l.size()) {} - // constructor #4 - TestType(const TestType& t) : x(t.x + 10) { } - // constructor #5 - TestType(TestType&& t) : x(t.x + 20) { } + // constructor #1 + TestType() : x(42) {} + // constructor #2 + TestType(int x) : x(x) {} + // constructor #3 + TestType(std::initializer_list l) : x(l.size()) {} + // constructor #4 + TestType(const TestType& t) : x(t.x + 10) { } + // constructor #5 + TestType(TestType&& t) : x(t.x + 20) { } - TestType& operator=(const TestType& t) { - std::cout << "assign\n"; - this->x = t.x + 30; - return *this; - } - TestType& operator=(TestType&& t) { - this->x = t.x + 40; - return *this; - } + TestType& operator=(const TestType& t) { + std::cout << "assign\n"; + this->x = t.x + 30; + return *this; + } + TestType& operator=(TestType&& t) { + this->x = t.x + 40; + return *this; + } - ~TestType() = default; - }; + ~TestType() = default; + }; =} reactor TestReactor( - /** - * FIXME: should work without an explicit initialization, see - * https://github.com/lf-lang/lingua-franca/issues/623 - */ - // p_default: TestType, constructor #1 - p_default: TestType(), - p_empty: TestType(), // constructor #1 - p_value: TestType(24), // constructor #2 - p_init_empty: TestType{}, // constructor #1 - p_init_empty2: TestType({}), // constructor #1 - p_init_some: TestType{2, 6, 6, 3, 1}, // constructor #1 - p_assign_init_empty: TestType = {}, // constructor #1 - p_assign_init_some: TestType = {4, 2, 1} // constructor #3 + /** + * FIXME: should work without an explicit initialization, see + * https://github.com/lf-lang/lingua-franca/issues/623 + */ + // p_default: TestType, constructor #1 + p_default: TestType(), + p_empty: TestType(), // constructor #1 + p_value: TestType(24), // constructor #2 + p_init_empty: TestType{}, // constructor #1 + p_init_empty2: TestType({}), // constructor #1 + p_init_some: TestType{2, 6, 6, 3, 1}, // constructor #1 + p_assign_init_empty: TestType = {}, // constructor #1 + p_assign_init_some: TestType = {4, 2, 1} // constructor #3 ) { - state s_default: TestType // constructor #1 - state s_empty: TestType() // constructor #1 - state s_value: TestType(24) // constructor #2 - state s_init_empty: TestType{} // constructor #1 - state s_init_empty2: TestType({}) // constructor #3 - state s_init_some: TestType{3, 12, 40} // constructor #3 - state s_assign_init_empty: TestType = {} // constructor #3 - state s_assign_init_some: TestType = {4, 3, 2, 1} // constructor #3 - state s_copy1: TestType(p_default) // constructor #4 - state s_copy2: TestType{p_default} // constructor #4 - state s_copy3: TestType = p_default // constructor #4 + state s_default: TestType // constructor #1 + state s_empty: TestType() // constructor #1 + state s_value: TestType(24) // constructor #2 + state s_init_empty: TestType{} // constructor #1 + state s_init_empty2: TestType({}) // constructor #3 + state s_init_some: TestType{3, 12, 40} // constructor #3 + state s_assign_init_empty: TestType = {} // constructor #3 + state s_assign_init_some: TestType = {4, 3, 2, 1} // constructor #3 + state s_copy1: TestType(p_default) // constructor #4 + state s_copy2: TestType{p_default} // constructor #4 + state s_copy3: TestType = p_default // constructor #4 - reaction(startup) {= - reactor::validate(p_default.x == 62, "p_default should be default constructed and then moved"); - reactor::validate(p_empty.x == 62, "p_empty should be default constructed and then moved"); - reactor::validate(p_value.x == 44, "p_value should be constructed from 24 and then moved"); - reactor::validate(p_init_empty.x == 62, "p_init_empty should be default constructed and then moved"); - reactor::validate(p_init_empty2.x == 20, "p_init_empty2 should be constructed with 0 and then moved"); - reactor::validate(p_init_some.x == 25, "p_init_some should be constructed with 3 and then moved"); - reactor::validate(p_assign_init_empty.x == 62, "p_assign_init_empty should be default constructed and then moved"); - reactor::validate(p_assign_init_some.x == 23, "p_assign_init_some should be constructed with 4 and then moved"); + reaction(startup) {= + reactor::validate(p_default.x == 62, "p_default should be default constructed and then moved"); + reactor::validate(p_empty.x == 62, "p_empty should be default constructed and then moved"); + reactor::validate(p_value.x == 44, "p_value should be constructed from 24 and then moved"); + reactor::validate(p_init_empty.x == 62, "p_init_empty should be default constructed and then moved"); + reactor::validate(p_init_empty2.x == 20, "p_init_empty2 should be constructed with 0 and then moved"); + reactor::validate(p_init_some.x == 25, "p_init_some should be constructed with 3 and then moved"); + reactor::validate(p_assign_init_empty.x == 62, "p_assign_init_empty should be default constructed and then moved"); + reactor::validate(p_assign_init_some.x == 23, "p_assign_init_some should be constructed with 4 and then moved"); - reactor::validate(s_default.x == 42, "s_default should be default constructed"); - reactor::validate(s_empty.x == 42, "s_empty should be default constructed"); - reactor::validate(s_value.x == 24, "s_value should be constructed with 24"); - reactor::validate(s_init_empty.x == 42, "s_init_empty should be default constructed"); - reactor::validate(s_init_empty2.x == 0, "s_init_empty2 should be constructed with 0"); - reactor::validate(s_init_some.x == 3, "s_init_some should be constructed with 3"); - // NOTE: This is a strange corner case. Since the equal assignment will be translated to a () initializers (e.g. :foo(42)), - // the initialization here in LF behaves differently from what one might expect. When writing `Foo foo = {}`, - // the default constructor would be called instead of the initializer list constructor. - reactor::validate(s_assign_init_empty.x == 0, "s_assign_init_empty should be constructed with 0"); - reactor::validate(s_assign_init_some.x == 4, "s_assign_init_some should be constructed with 4"); - reactor::validate(s_copy1.x == 72, "s_copy1 should be copy constructed from p_default"); - reactor::validate(s_copy2.x == 72, "s_copy1 should be copy constructed from p_default"); - reactor::validate(s_copy3.x == 72, "s_copy1 should be copy constructed from p_default"); - =} + reactor::validate(s_default.x == 42, "s_default should be default constructed"); + reactor::validate(s_empty.x == 42, "s_empty should be default constructed"); + reactor::validate(s_value.x == 24, "s_value should be constructed with 24"); + reactor::validate(s_init_empty.x == 42, "s_init_empty should be default constructed"); + reactor::validate(s_init_empty2.x == 0, "s_init_empty2 should be constructed with 0"); + reactor::validate(s_init_some.x == 3, "s_init_some should be constructed with 3"); + // NOTE: This is a strange corner case. Since the equal assignment will be translated to a () initializers (e.g. :foo(42)), + // the initialization here in LF behaves differently from what one might expect. When writing `Foo foo = {}`, + // the default constructor would be called instead of the initializer list constructor. + reactor::validate(s_assign_init_empty.x == 0, "s_assign_init_empty should be constructed with 0"); + reactor::validate(s_assign_init_some.x == 4, "s_assign_init_some should be constructed with 4"); + reactor::validate(s_copy1.x == 72, "s_copy1 should be copy constructed from p_default"); + reactor::validate(s_copy2.x == 72, "s_copy1 should be copy constructed from p_default"); + reactor::validate(s_copy3.x == 72, "s_copy1 should be copy constructed from p_default"); + =} } main reactor { - test = new TestReactor() + test = new TestReactor() } diff --git a/test/Cpp/src/target/MultipleContainedGeneric.lf b/test/Cpp/src/target/MultipleContainedGeneric.lf index ab2b2e0956..5a767dc3c1 100644 --- a/test/Cpp/src/target/MultipleContainedGeneric.lf +++ b/test/Cpp/src/target/MultipleContainedGeneric.lf @@ -1,36 +1,35 @@ -// Test that a reaction can react to and send two multiple ports of a contained -// reactor. +// Test that a reaction can react to and send two multiple ports of a contained reactor. target Cpp reactor Contained { - output trigger: T - input in1: T - input in2: T + output trigger: T + input in1: T + input in2: T - reaction(startup) -> trigger {= trigger.set(42); =} + reaction(startup) -> trigger {= trigger.set(42); =} - reaction(in1) {= - std::cout << "in1 received " << *in1.get() << '\n'; - if (*in1.get() != 42) { - std::cerr << "FAILED: Expected 42.\n"; - exit(1); - } - =} + reaction(in1) {= + std::cout << "in1 received " << *in1.get() << '\n'; + if (*in1.get() != 42) { + std::cerr << "FAILED: Expected 42.\n"; + exit(1); + } + =} - reaction(in2) {= - std::cout << "in2 received " << *in2.get() << '\n'; - if (*in2.get() != 42) { - std::cerr << "FAILED: Expected 42.\n"; - exit(1); - } - =} + reaction(in2) {= + std::cout << "in2 received " << *in2.get() << '\n'; + if (*in2.get() != 42) { + std::cerr << "FAILED: Expected 42.\n"; + exit(1); + } + =} } main reactor { - c = new Contained() + c = new Contained() - reaction(c.trigger) -> c.in1, c.in2 {= - c.in1.set(c.trigger.get()); - c.in2.set(c.trigger.get()); - =} + reaction(c.trigger) -> c.in1, c.in2 {= + c.in1.set(c.trigger.get()); + c.in2.set(c.trigger.get()); + =} } diff --git a/test/Cpp/src/target/PointerParameters.lf b/test/Cpp/src/target/PointerParameters.lf index a769f20da3..2de286aaa4 100644 --- a/test/Cpp/src/target/PointerParameters.lf +++ b/test/Cpp/src/target/PointerParameters.lf @@ -1,18 +1,18 @@ -// This is a smoke test to see if pointers can be used as parameters. -// Compilation without errors is success. +// This is a smoke test to see if pointers can be used as parameters. Compilation without errors is +// success. target Cpp reactor Foo(ptr: int* = {= nullptr =}) { - reaction(startup) {= - if (ptr == nullptr || *ptr != 42) { - reactor::log::Error() << "received an unexpected value!"; - exit(1); - } - =} + reaction(startup) {= + if (ptr == nullptr || *ptr != 42) { + reactor::log::Error() << "received an unexpected value!"; + exit(1); + } + =} } main reactor { - private preamble {= int a{42}; =} + private preamble {= int a{42}; =} - foo = new Foo(ptr = {= &a =}) + foo = new Foo(ptr = {= &a =}) } diff --git a/test/Python/src/ActionDelay.lf b/test/Python/src/ActionDelay.lf index 60efa42f57..ba46edf9c4 100644 --- a/test/Python/src/ActionDelay.lf +++ b/test/Python/src/ActionDelay.lf @@ -2,46 +2,46 @@ target Python reactor GeneratedDelay { - input y_in - output y_out - state y_state = 0 - logical action act(100 msec) + input y_in + output y_out + state y_state = 0 + logical action act(100 msec) - reaction(y_in) -> act {= - self.y_state = y_in.value - act.schedule(MSEC(0)) - =} + reaction(y_in) -> act {= + self.y_state = y_in.value + act.schedule(MSEC(0)) + =} - reaction(act) -> y_out {= y_out.set(self.y_state) =} + reaction(act) -> y_out {= y_out.set(self.y_state) =} } reactor Source { - output out + output out - reaction(startup) -> out {= out.set(1) =} + reaction(startup) -> out {= out.set(1) =} } reactor Sink { - input _in - - reaction(_in) {= - elapsed_logical = lf.time.logical_elapsed() - logical = lf.time.logical() - physical = lf.time.physical() - print("Logical, physical, and elapsed logical: ", logical, physical, elapsed_logical) - if elapsed_logical != MSEC(100): - sys.stderr.write("FAILURE: Expected " + str(MSEC(100)) + " but got " + str(elapsed_logical) + ".\n") - exit(1) - else: - print("SUCCESS. Elapsed logical time is 100 msec.\n") - =} + input _in + + reaction(_in) {= + elapsed_logical = lf.time.logical_elapsed() + logical = lf.time.logical() + physical = lf.time.physical() + print("Logical, physical, and elapsed logical: ", logical, physical, elapsed_logical) + if elapsed_logical != MSEC(100): + sys.stderr.write("FAILURE: Expected " + str(MSEC(100)) + " but got " + str(elapsed_logical) + ".\n") + exit(1) + else: + print("SUCCESS. Elapsed logical time is 100 msec.\n") + =} } main reactor ActionDelay { - source = new Source() - sink = new Sink() - g = new GeneratedDelay() + source = new Source() + sink = new Sink() + g = new GeneratedDelay() - source.out -> g.y_in - g.y_out -> sink._in + source.out -> g.y_in + g.y_out -> sink._in } diff --git a/test/Python/src/ActionIsPresent.lf b/test/Python/src/ActionIsPresent.lf index ceb52d10b8..3bdd419700 100644 --- a/test/Python/src/ActionIsPresent.lf +++ b/test/Python/src/ActionIsPresent.lf @@ -2,28 +2,28 @@ target Python main reactor ActionIsPresent(offset = 1 nsec, period = 500 msec) { - logical action a - state first_time = True - state success = False + logical action a + state first_time = True + state success = False - reaction(startup, a) -> a {= - # The is_present field should be initially False - if a.is_present is not True: - if self.offset == 0: - print("Hello World!") - self.success = True - else: - a.schedule(self.offset) - self.first_time = False + reaction(startup, a) -> a {= + # The is_present field should be initially False + if a.is_present is not True: + if self.offset == 0: + print("Hello World!") + self.success = True else: - print("Hello World 2!") - if self.first_time is not True: - self.success = True - =} + a.schedule(self.offset) + self.first_time = False + else: + print("Hello World 2!") + if self.first_time is not True: + self.success = True + =} - reaction(shutdown) {= - if self.success is not True: - sys.stderr.write("Failed to print 'Hello World'\n") - exit(1) - =} + reaction(shutdown) {= + if self.success is not True: + sys.stderr.write("Failed to print 'Hello World'\n") + exit(1) + =} } diff --git a/test/Python/src/After.lf b/test/Python/src/After.lf index 0c8b931543..d1f720ddfa 100644 --- a/test/Python/src/After.lf +++ b/test/Python/src/After.lf @@ -1,50 +1,49 @@ -# This checks that the after keyword adjusts logical time, not using physical -# time. +# This checks that the after keyword adjusts logical time, not using physical time. target Python { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } reactor foo { - input x - output y + input x + output y - reaction(x) -> y {= y.set(2*x.value) =} + reaction(x) -> y {= y.set(2*x.value) =} } reactor print { - state expected_time = 10 msec - state received = 0 - input x - - reaction(x) {= - self.received+=1 - elapsed_time = lf.time.logical_elapsed() - print("Result is " + str(x.value)) - if x.value != 84: - sys.stderr.write("ERROR: Expected result to be 84.\n") - exit(1) - - print("Current logical time is: " + str(elapsed_time)) - print("Current physical time is: " + str(lf.time.physical_elapsed())) - if elapsed_time != self.expected_time: - sys.stderr.write("ERROR: Expected logical time to be " + self.expected_time) - exit(2) - self.expected_time += SEC(1) - =} - - reaction(shutdown) {= - if (self.received == 0): - sys.stderr.write("ERROR: Final reactor received no data.\n") - exit(3) - =} + state expected_time = 10 msec + state received = 0 + input x + + reaction(x) {= + self.received+=1 + elapsed_time = lf.time.logical_elapsed() + print("Result is " + str(x.value)) + if x.value != 84: + sys.stderr.write("ERROR: Expected result to be 84.\n") + exit(1) + + print("Current logical time is: " + str(elapsed_time)) + print("Current physical time is: " + str(lf.time.physical_elapsed())) + if elapsed_time != self.expected_time: + sys.stderr.write("ERROR: Expected logical time to be " + self.expected_time) + exit(2) + self.expected_time += SEC(1) + =} + + reaction(shutdown) {= + if (self.received == 0): + sys.stderr.write("ERROR: Final reactor received no data.\n") + exit(3) + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x after 10 msec + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x after 10 msec - reaction(t) -> f.x {= f.x.set(42) =} + reaction(t) -> f.x {= f.x.set(42) =} } diff --git a/test/Python/src/AfterCycles.lf b/test/Python/src/AfterCycles.lf index cd0f0dd98e..38ee982c6e 100644 --- a/test/Python/src/AfterCycles.lf +++ b/test/Python/src/AfterCycles.lf @@ -1,58 +1,58 @@ -# This tests that "after" does not introduce spurious cycles. Success if running -# without detected a cycle. +# This tests that "after" does not introduce spurious cycles. Success if running without detected a +# cycle. target Python reactor Source { - output out + output out - reaction(startup) -> out {= out.set(1) =} + reaction(startup) -> out {= out.set(1) =} } reactor Work { - input _in - output out + input _in + output out - reaction(_in) -> out {= out.set(_in.value) =} + reaction(_in) -> out {= out.set(_in.value) =} } main reactor AfterCycles { - state count = 0 - s = new Source() - w0 = new Work() - w1 = new Work() - - s.out -> w0._in after 10 msec - s.out -> w1._in after 20 msec - - reaction(w0.out) {= - self.count+=1 - elapsed_time = lf.time.logical_elapsed() - print("Received {:d} from worker 0 at time {:d}.".format(w0.out.value, elapsed_time)) - if elapsed_time != MSEC(10): - sys.stderr.write("Time should have been 10000000.\n") - exit(1) - - if w0.out.value != 1: - sys.stderr.write("Value should have been 1.\n") - exit(4) - =} - - reaction(w1.out) {= - self.count+=1 - elapsed_time = lf.time.logical_elapsed() - print("Received {:d} from worker 1 at time {:d}.".format(w1.out.value, elapsed_time)) - if elapsed_time != MSEC(20): - sys.stderr.write("Time should have been 20000000.\n") - exit(3) - - if w1.out.value != 1: - sys.stderr.write("Value should have been 1.\n") - exit(4) - =} - - reaction(shutdown) {= - if self.count != 2: - sys.stderr.write("Top-level reactions should have been triggered but were not.\n") - exit(5) - =} + state count = 0 + s = new Source() + w0 = new Work() + w1 = new Work() + + s.out -> w0._in after 10 msec + s.out -> w1._in after 20 msec + + reaction(w0.out) {= + self.count+=1 + elapsed_time = lf.time.logical_elapsed() + print("Received {:d} from worker 0 at time {:d}.".format(w0.out.value, elapsed_time)) + if elapsed_time != MSEC(10): + sys.stderr.write("Time should have been 10000000.\n") + exit(1) + + if w0.out.value != 1: + sys.stderr.write("Value should have been 1.\n") + exit(4) + =} + + reaction(w1.out) {= + self.count+=1 + elapsed_time = lf.time.logical_elapsed() + print("Received {:d} from worker 1 at time {:d}.".format(w1.out.value, elapsed_time)) + if elapsed_time != MSEC(20): + sys.stderr.write("Time should have been 20000000.\n") + exit(3) + + if w1.out.value != 1: + sys.stderr.write("Value should have been 1.\n") + exit(4) + =} + + reaction(shutdown) {= + if self.count != 2: + sys.stderr.write("Top-level reactions should have been triggered but were not.\n") + exit(5) + =} } diff --git a/test/Python/src/AfterOverlapped.lf b/test/Python/src/AfterOverlapped.lf index 32657f1cdb..ec090046f4 100644 --- a/test/Python/src/AfterOverlapped.lf +++ b/test/Python/src/AfterOverlapped.lf @@ -1,41 +1,41 @@ # This the after keyword with overlapped time intervals. target Python { - fast: true, - timeout: 5 sec + fast: true, + timeout: 5 sec } import Count from "lib/Count.lf" reactor Test { - input c - state i = 0 - state received = 0 + input c + state i = 0 + state received = 0 - reaction(c) {= - self.received += 1 - print(f"Received {c.value}.") - self.i += 1 - if c.value != self.i: - sys.stderr.write("ERROR: Expected {:d} but got {:d}\n.".format(self.i, c.value)); - exit(1) - elapsed_time = lf.time.logical_elapsed() - print("Current logical time is: ", elapsed_time) + reaction(c) {= + self.received += 1 + print(f"Received {c.value}.") + self.i += 1 + if c.value != self.i: + sys.stderr.write("ERROR: Expected {:d} but got {:d}\n.".format(self.i, c.value)); + exit(1) + elapsed_time = lf.time.logical_elapsed() + print("Current logical time is: ", elapsed_time) - expected_logical_time = SEC(2) + SEC(1)*(c.value - 1) - if elapsed_time != expected_logical_time: - sys.stderr.write("ERROR: Expected logical time to be {:d} but got {:d}\n.".format(expected_logical_time, elapsed_time)) - exit(1) - =} + expected_logical_time = SEC(2) + SEC(1)*(c.value - 1) + if elapsed_time != expected_logical_time: + sys.stderr.write("ERROR: Expected logical time to be {:d} but got {:d}\n.".format(expected_logical_time, elapsed_time)) + exit(1) + =} - reaction(shutdown) {= - if self.received == 0: - sys.stderr.write("ERROR: Final reactor received no data.\n") - exit(3) - =} + reaction(shutdown) {= + if self.received == 0: + sys.stderr.write("ERROR: Final reactor received no data.\n") + exit(3) + =} } main reactor AfterOverlapped { - count = new Count() - test = new Test() - count.out -> test.c after 2 sec + count = new Count() + test = new Test() + count.out -> test.c after 2 sec } diff --git a/test/Python/src/ArrayAsParameter.lf b/test/Python/src/ArrayAsParameter.lf index 359e38b7a3..ad5fe3c15e 100644 --- a/test/Python/src/ArrayAsParameter.lf +++ b/test/Python/src/ArrayAsParameter.lf @@ -2,41 +2,41 @@ target Python reactor Source(sequence(0, 1, 2)) { - output out - state count = 0 - logical action next + output out + state count = 0 + logical action next - reaction(startup, next) -> out, next {= - out.set(self.sequence[self.count]) - self.count+=1 - if self.count < len(self.sequence): - next.schedule(0) - =} + reaction(startup, next) -> out, next {= + out.set(self.sequence[self.count]) + self.count+=1 + if self.count < len(self.sequence): + next.schedule(0) + =} } reactor Print { - input _in - state count = 1 - state received = 0 + input _in + state count = 1 + state received = 0 - reaction(_in) {= - self.received+=1 - print("Received: {:d}\n".format(_in.value)) - if _in.value != self.count: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.count)) - exit(1) - self.count+=1 - =} + reaction(_in) {= + self.received+=1 + print("Received: {:d}\n".format(_in.value)) + if _in.value != self.count: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.count)) + exit(1) + self.count+=1 + =} - reaction(shutdown) {= - if self.received == 0: - sys.stderr.write("ERROR: Final reactor received no data.\n") - exit(3) - =} + reaction(shutdown) {= + if self.received == 0: + sys.stderr.write("ERROR: Final reactor received no data.\n") + exit(3) + =} } main reactor ArrayAsParameter { - s = new Source(sequence(1, 2, 3, 4)) - p = new Print() - s.out -> p._in + s = new Source(sequence(1, 2, 3, 4)) + p = new Print() + s.out -> p._in } diff --git a/test/Python/src/ArrayAsType.lf b/test/Python/src/ArrayAsType.lf index dc3b2f6e26..de1490d332 100644 --- a/test/Python/src/ArrayAsType.lf +++ b/test/Python/src/ArrayAsType.lf @@ -1,29 +1,29 @@ -# Source produces a statically allocated array, which it passes to Print. The -# destination references the array directly. +# Source produces a statically allocated array, which it passes to Print. The destination references +# the array directly. target Python reactor Source { - output out + output out - reaction(startup) -> out {= - # Pass on a tuple to out - out.set((0, 2.8, "hello")) - =} + reaction(startup) -> out {= + # Pass on a tuple to out + out.set((0, 2.8, "hello")) + =} } reactor Print(scale = 1) { # The scale parameter is just for testing. - input _in + input _in - reaction(_in) {= - print("Received: [%s]" % ", ".join(map(str, _in.value))) - if _in.value != (0, 2.8, "hello"): - sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") - exit(1) - =} + reaction(_in) {= + print("Received: [%s]" % ", ".join(map(str, _in.value))) + if _in.value != (0, 2.8, "hello"): + sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") + exit(1) + =} } main reactor ArrayAsType { - s = new Source() - p = new Print() - s.out -> p._in + s = new Source() + p = new Print() + s.out -> p._in } diff --git a/test/Python/src/ArrayFree.lf b/test/Python/src/ArrayFree.lf index 2ea2777c12..24f9b4b754 100644 --- a/test/Python/src/ArrayFree.lf +++ b/test/Python/src/ArrayFree.lf @@ -1,27 +1,27 @@ -# Source produces a dynamically allocated array, which it passes to Free. Free -# requests a writable copy, which, instead of copying, it just gets ownership of -# the original array. It then does nothing further with it. This test checks -# that the memory gets freed automatically even with the mutable input. +# Source produces a dynamically allocated array, which it passes to Free. Free requests a writable +# copy, which, instead of copying, it just gets ownership of the original array. It then does +# nothing further with it. This test checks that the memory gets freed automatically even with the +# mutable input. target Python import Source, Print from "ArrayPrint.lf" import Scale from "ArrayScale.lf" reactor Free(scale = 2) { - mutable input _in + mutable input _in - reaction(_in) {= - for i in range(len(_in.value)): - _in.value[i] *= self.scale - =} + reaction(_in) {= + for i in range(len(_in.value)): + _in.value[i] *= self.scale + =} } main reactor ArrayFree { - s = new Source() - c = new Free() - c2 = new Scale() - p = new Print(scale = 2) - s.out -> c._in - s.out -> c2._in - c2.out -> p._in + s = new Source() + c = new Free() + c2 = new Scale() + p = new Print(scale = 2) + s.out -> c._in + s.out -> c2._in + c2.out -> p._in } diff --git a/test/Python/src/ArrayPrint.lf b/test/Python/src/ArrayPrint.lf index 4420311b93..f13d44c7bf 100644 --- a/test/Python/src/ArrayPrint.lf +++ b/test/Python/src/ArrayPrint.lf @@ -1,29 +1,29 @@ -# Source produces a dynamically allocated array, which it passes to Print. -# Reference counting ensures that the array is freed. +# Source produces a dynamically allocated array, which it passes to Print. Reference counting +# ensures that the array is freed. target Python reactor Source { - output out + output out - reaction(startup) -> out {= - # Dynamically allocate an output array of length 3 and populate it. - out.set([0,1,2]) - =} + reaction(startup) -> out {= + # Dynamically allocate an output array of length 3 and populate it. + out.set([0,1,2]) + =} } reactor Print(scale = 1) { # The scale parameter is just for testing. - input _in + input _in - reaction(_in) {= - print("Received: [%s]" % ", ".join(map(str, _in.value))) - if _in.value != [x * self.scale for x in [0, 1, 2]]: - sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") - exit(1) - =} + reaction(_in) {= + print("Received: [%s]" % ", ".join(map(str, _in.value))) + if _in.value != [x * self.scale for x in [0, 1, 2]]: + sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") + exit(1) + =} } main reactor ArrayPrint { - s = new Source() - p = new Print() - s.out -> p._in + s = new Source() + p = new Print() + s.out -> p._in } diff --git a/test/Python/src/ArrayScale.lf b/test/Python/src/ArrayScale.lf index 2b69aebe77..a174053b2c 100644 --- a/test/Python/src/ArrayScale.lf +++ b/test/Python/src/ArrayScale.lf @@ -1,26 +1,25 @@ -# Source produces a dynamically allocated array, which it passes to Scale. Scale -# requests a writable copy, which, instead of copying, it just gets ownership of -# the original array. It modifies it and passes it to Print. It gets freed after -# Print is done with it. +# Source produces a dynamically allocated array, which it passes to Scale. Scale requests a writable +# copy, which, instead of copying, it just gets ownership of the original array. It modifies it and +# passes it to Print. It gets freed after Print is done with it. target Python import Print, Source from "ArrayPrint.lf" reactor Scale(scale = 2) { - mutable input _in - output out + mutable input _in + output out - reaction(_in) -> out {= - for i in range(len(_in.value)): - _in.value[i] *= self.scale - out.set(_in.value) - =} + reaction(_in) -> out {= + for i in range(len(_in.value)): + _in.value[i] *= self.scale + out.set(_in.value) + =} } main reactor ArrayScale { - s = new Source() - c = new Scale() - p = new Print(scale = 2) - s.out -> c._in - c.out -> p._in + s = new Source() + c = new Scale() + p = new Print(scale = 2) + s.out -> c._in + c.out -> p._in } diff --git a/test/Python/src/CompareTags.lf b/test/Python/src/CompareTags.lf index fc6449dbff..462d57864e 100644 --- a/test/Python/src/CompareTags.lf +++ b/test/Python/src/CompareTags.lf @@ -1,31 +1,31 @@ # Tests the lf.tag_compare() function in the python target. target Python { - timeout: 10 msec, - fast: false + timeout: 10 msec, + fast: false } main reactor CompareTags { - preamble {= import sys =} - timer t(0, 1 msec) - logical action l + preamble {= import sys =} + timer t(0, 1 msec) + logical action l - reaction(t) -> l {= - tag1 = lf.tag() - tag2 = lf.tag() - if (lf.tag_compare(tag1, tag2) != 0 or not tag1 == tag2 or tag1 != tag2): - self.sys.stderr.write("Tags should be equal\n") - self.sys.exit(1) - l.schedule(0, tag1) - =} + reaction(t) -> l {= + tag1 = lf.tag() + tag2 = lf.tag() + if (lf.tag_compare(tag1, tag2) != 0 or not tag1 == tag2 or tag1 != tag2): + self.sys.stderr.write("Tags should be equal\n") + self.sys.exit(1) + l.schedule(0, tag1) + =} - reaction(l) {= - tag3 = lf.tag() - tag1 = l.value - if (lf.tag_compare(tag1, tag3) != -1 or not tag1 < tag3 or tag1 >= tag3): - self.sys.stderr.write("tag1 should be lesser than tag3\n") - self.sys.exit(1) - if (lf.tag_compare(tag3, tag1) != 1 or not tag3 > tag1 or tag3 <= tag1): - self.sys.stderr.write("tag3 should be greater than tag1\n") - self.sys.exit(1) - =} + reaction(l) {= + tag3 = lf.tag() + tag1 = l.value + if (lf.tag_compare(tag1, tag3) != -1 or not tag1 < tag3 or tag1 >= tag3): + self.sys.stderr.write("tag1 should be lesser than tag3\n") + self.sys.exit(1) + if (lf.tag_compare(tag3, tag1) != 1 or not tag3 > tag1 or tag3 <= tag1): + self.sys.stderr.write("tag3 should be greater than tag1\n") + self.sys.exit(1) + =} } diff --git a/test/Python/src/Composition.lf b/test/Python/src/Composition.lf index d1bef93ed2..d4b36c0a76 100644 --- a/test/Python/src/Composition.lf +++ b/test/Python/src/Composition.lf @@ -1,44 +1,43 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period = 2 sec) { - output y - timer t(1 sec, period) - state count = 0 + output y + timer t(1 sec, period) + state count = 0 - reaction(t) -> y {= - self.count += 1 - print("Source sending " + str(self.count)) - #print("y value is " + str(y.value)) - y.set(self.count) - =} + reaction(t) -> y {= + self.count += 1 + print("Source sending " + str(self.count)) + #print("y value is " + str(y.value)) + y.set(self.count) + =} } reactor Test { - input x - state count = 0 + input x + state count = 0 - reaction(x) {= - self.count += 1 - print("Recieved " + str(x.value)) - if (x.value != self.count): - sys.stderr.write("FAILURE: Expected " + str(self.count) + "\n") - exit(1) - =} + reaction(x) {= + self.count += 1 + print("Recieved " + str(x.value)) + if (x.value != self.count): + sys.stderr.write("FAILURE: Expected " + str(self.count) + "\n") + exit(1) + =} - reaction(shutdown) {= - if(self.count == 0): - sys.stderr.write("FAILURE: No data received.\n") - =} + reaction(shutdown) {= + if(self.count == 0): + sys.stderr.write("FAILURE: No data received.\n") + =} } main reactor Composition { - s = new Source() + s = new Source() - d = new Test() - s.y -> d.x + d = new Test() + s.y -> d.x } diff --git a/test/Python/src/CompositionAfter.lf b/test/Python/src/CompositionAfter.lf index 00b95e3ab9..49b2f0012a 100644 --- a/test/Python/src/CompositionAfter.lf +++ b/test/Python/src/CompositionAfter.lf @@ -1,36 +1,35 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period = 2 sec) { - output y - timer t(1 sec, period) - state count = 0 + output y + timer t(1 sec, period) + state count = 0 - reaction(t) -> y {= - self.count += 1 - y.set(self.count) - =} + reaction(t) -> y {= + self.count += 1 + y.set(self.count) + =} } reactor Test { - input x - state count = 0 + input x + state count = 0 - reaction(x) {= - self.count += 1 - print("Received ", x.value) - if x.value != self.count: - sys.stderr.write("FAILURE: Expected %d\n", self.count) - exit(1) - =} + reaction(x) {= + self.count += 1 + print("Received ", x.value) + if x.value != self.count: + sys.stderr.write("FAILURE: Expected %d\n", self.count) + exit(1) + =} } main reactor(delay = 5 sec) { - s = new Source() - d = new Test() - s.y -> d.x after delay + s = new Source() + d = new Test() + s.y -> d.x after delay } diff --git a/test/Python/src/CompositionInheritance.lf b/test/Python/src/CompositionInheritance.lf index 4b0e4a38c9..8765192cc7 100644 --- a/test/Python/src/CompositionInheritance.lf +++ b/test/Python/src/CompositionInheritance.lf @@ -1,54 +1,53 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { - fast: true, - timeout: 10 sec + fast: true, + timeout: 10 sec } reactor Source(period = 2 sec) { - input foo - output y - timer t(1 sec, period) - state count = 0 - - reaction(t) -> y {= - print("Hello World. My count is: ", self.count) - y.set(self.count) - =} + input foo + output y + timer t(1 sec, period) + state count = 0 + + reaction(t) -> y {= + print("Hello World. My count is: ", self.count) + y.set(self.count) + =} } reactor SourceExtended extends Source { - output y2 - timer t2(1 sec, 3 sec) - - reaction(t2) -> y2 {= - self.count += 1 - print("Source sending ", self.count) - y2.set(self.count) - =} + output y2 + timer t2(1 sec, 3 sec) + + reaction(t2) -> y2 {= + self.count += 1 + print("Source sending ", self.count) + y2.set(self.count) + =} } reactor Test { - input x - state count = 0 - - reaction(x) {= - self.count += 1 - print("Received ", x.value) - if x.value != self.count: - sys.stderr.write("FAILURE: Expected %d\n", self.count) - exit(1) - =} - - reaction(shutdown) {= - if self.count == 0: - sys.stderr.write("FAILURE: No data received.\n") - =} + input x + state count = 0 + + reaction(x) {= + self.count += 1 + print("Received ", x.value) + if x.value != self.count: + sys.stderr.write("FAILURE: Expected %d\n", self.count) + exit(1) + =} + + reaction(shutdown) {= + if self.count == 0: + sys.stderr.write("FAILURE: No data received.\n") + =} } main reactor { - s = new SourceExtended() + s = new SourceExtended() - d = new Test() - s.y2 -> d.x + d = new Test() + s.y2 -> d.x } diff --git a/test/Python/src/CountSelf.lf b/test/Python/src/CountSelf.lf index 74219e6fe0..8fe1d4915b 100644 --- a/test/Python/src/CountSelf.lf +++ b/test/Python/src/CountSelf.lf @@ -1,40 +1,40 @@ # This tests actions with payloads by delaying an input by a fixed amount. target Python { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor CountSelf2(delay = 100 msec) { - output out - logical action a + output out + logical action a - reaction(startup) -> a, out {= - out.set(0) - a.schedule(self.delay, 1) - =} + reaction(startup) -> a, out {= + out.set(0) + a.schedule(self.delay, 1) + =} - reaction(a) -> a, out {= - out.set(a.value) - a.schedule(self.delay, a.value + 1) - =} + reaction(a) -> a, out {= + out.set(a.value) + a.schedule(self.delay, a.value + 1) + =} } reactor Test { - input _in - state count = 0 + input _in + state count = 0 - reaction(_in) {= - print("Received: {:d}".format(_in.value)) - if _in.value != self.count: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.count)) - exit(1) + reaction(_in) {= + print("Received: {:d}".format(_in.value)) + if _in.value != self.count: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.count)) + exit(1) - self.count+=1 - =} + self.count+=1 + =} } main reactor { - d = new CountSelf2() - t = new Test() - d.out -> t._in + d = new CountSelf2() + t = new Test() + d.out -> t._in } diff --git a/test/Python/src/CountTest.lf b/test/Python/src/CountTest.lf index 06c4a6fdb6..6e178cbcb0 100644 --- a/test/Python/src/CountTest.lf +++ b/test/Python/src/CountTest.lf @@ -1,31 +1,31 @@ target Python { - timeout: 3 sec, - fast: true + timeout: 3 sec, + fast: true } import Count from "lib/Count.lf" reactor Test { - input c - state i = 0 + input c + state i = 0 - reaction(c) {= - print("Received ", c.value) - self.i +=1 - if c.value != self.i: - sys.stderr.write("ERROR: Expected {:d} but got {:d}\n.".format(self.i, c.value)) - exit(1) - =} + reaction(c) {= + print("Received ", c.value) + self.i +=1 + if c.value != self.i: + sys.stderr.write("ERROR: Expected {:d} but got {:d}\n.".format(self.i, c.value)) + exit(1) + =} - reaction(shutdown) {= - if self.i != 4: - sys.stderr.write("ERROR: Test should have reacted 4 times, but reacted {:d} times.\n".format(self.i)) - exit(2) - =} + reaction(shutdown) {= + if self.i != 4: + sys.stderr.write("ERROR: Test should have reacted 4 times, but reacted {:d} times.\n".format(self.i)) + exit(2) + =} } main reactor CountTest { - count = new Count() - test = new Test() - count.out -> test.c + count = new Count() + test = new Test() + count.out -> test.c } diff --git a/test/Python/src/Deadline.lf b/test/Python/src/Deadline.lf index ceab2b28e2..1104c80e86 100644 --- a/test/Python/src/Deadline.lf +++ b/test/Python/src/Deadline.lf @@ -1,53 +1,52 @@ -# This example illustrates local deadline handling. Even numbers are sent by the -# Source immediately, whereas odd numbers are sent after a big enough delay to -# violate the deadline. +# This example illustrates local deadline handling. Even numbers are sent by the Source immediately, +# whereas odd numbers are sent after a big enough delay to violate the deadline. target Python { - timeout: 6 sec + timeout: 6 sec } preamble {= import time =} reactor Source(period = 3 sec) { - output y - timer t(0, period) - state count = 0 - - reaction(t) -> y {= - if self.count % 2 != 0: - # The count variable is odd. - # Take time to cause a deadline violation. - time.sleep(1.5) - - print("Source sends: ", self.count) - y.set(self.count) - self.count += 1 - =} + output y + timer t(0, period) + state count = 0 + + reaction(t) -> y {= + if self.count % 2 != 0: + # The count variable is odd. + # Take time to cause a deadline violation. + time.sleep(1.5) + + print("Source sends: ", self.count) + y.set(self.count) + self.count += 1 + =} } reactor Destination(timeout = 1 sec) { - input x - state count = 0 - - reaction(x) {= - print("Destination receives: ", x.value) - if self.count % 2 != 0: - # The count variable is odd, so the deadline should have been violated. - sys.stderr.write("ERROR: Failed to detect deadline.\n") - exit(1) - - self.count += 1 - =} deadline(timeout) {= - print("Destination deadline handler receives: ", x.value) - if self.count % 2 == 0: - # The count variable is even, so the deadline should not have been violated. - sys.stderr.write("ERROR: Deadline miss handler invoked without deadline violation.\n") - exit(2) - self.count += 1 - =} + input x + state count = 0 + + reaction(x) {= + print("Destination receives: ", x.value) + if self.count % 2 != 0: + # The count variable is odd, so the deadline should have been violated. + sys.stderr.write("ERROR: Failed to detect deadline.\n") + exit(1) + + self.count += 1 + =} deadline(timeout) {= + print("Destination deadline handler receives: ", x.value) + if self.count % 2 == 0: + # The count variable is even, so the deadline should not have been violated. + sys.stderr.write("ERROR: Deadline miss handler invoked without deadline violation.\n") + exit(2) + self.count += 1 + =} } main reactor Deadline { - s = new Source() - d = new Destination(timeout = 1 sec) - s.y -> d.x + s = new Source() + d = new Destination(timeout = 1 sec) + s.y -> d.x } diff --git a/test/Python/src/DeadlineHandledAbove.lf b/test/Python/src/DeadlineHandledAbove.lf index 1259253cea..575b9df49e 100644 --- a/test/Python/src/DeadlineHandledAbove.lf +++ b/test/Python/src/DeadlineHandledAbove.lf @@ -1,42 +1,42 @@ -# Test a deadline where the deadline violation produces an output and the -# container reacts to that output. +# Test a deadline where the deadline violation produces an output and the container reacts to that +# output. target Python preamble {= import time =} reactor Deadline(threshold = 100 msec) { - input x - output deadline_violation + input x + output deadline_violation - reaction(x) -> deadline_violation {= - sys.stderr.write("ERROR: Deadline violation was not detected!\n") - exit(1) - =} deadline(threshold) {= - print("Deadline violation detected.") - deadline_violation.set(True) - =} + reaction(x) -> deadline_violation {= + sys.stderr.write("ERROR: Deadline violation was not detected!\n") + exit(1) + =} deadline(threshold) {= + print("Deadline violation detected.") + deadline_violation.set(True) + =} } main reactor DeadlineHandledAbove { - state violation_detected = False - d = new Deadline(threshold = 10 msec) + state violation_detected = False + d = new Deadline(threshold = 10 msec) - reaction(startup) -> d.x {= - time.sleep(0.2) - d.x.set(42) - =} + reaction(startup) -> d.x {= + time.sleep(0.2) + d.x.set(42) + =} - reaction(d.deadline_violation) {= - if d.deadline_violation.value is True: - print("Output successfully produced by deadline miss handler.") - self.violation_detected = True - =} + reaction(d.deadline_violation) {= + if d.deadline_violation.value is True: + print("Output successfully produced by deadline miss handler.") + self.violation_detected = True + =} - reaction(shutdown) {= - if self.violation_detected is True: - print("SUCCESS. Test passes.") - else: - sys.stderr.write("FAILURE. Container did not react to deadline violation.\n") - exit(2) - =} + reaction(shutdown) {= + if self.violation_detected is True: + print("SUCCESS. Test passes.") + else: + sys.stderr.write("FAILURE. Container did not react to deadline violation.\n") + exit(2) + =} } diff --git a/test/Python/src/DelayArray.lf b/test/Python/src/DelayArray.lf index 945b786cca..b931821682 100644 --- a/test/Python/src/DelayArray.lf +++ b/test/Python/src/DelayArray.lf @@ -2,44 +2,43 @@ target Python reactor DelayPointer(delay = 100 msec) { - # The Python target does not require explicit type allocation for types - # other than time - mutable input _in - output out - logical action a - - reaction(_in) -> a {= - # mutable input guarantees in will not be freed. - a.schedule(self.delay, _in.value); - =} - - reaction(a) -> out {= out.set(a.value); =} + # The Python target does not require explicit type allocation for types other than time + mutable input _in + output out + logical action a + + reaction(_in) -> a {= + # mutable input guarantees in will not be freed. + a.schedule(self.delay, _in.value); + =} + + reaction(a) -> out {= out.set(a.value); =} } reactor Source { - output out + output out - reaction(startup) -> out {= - # Send an output list of length 3. - out.set([0, 1, 2]) - =} + reaction(startup) -> out {= + # Send an output list of length 3. + out.set([0, 1, 2]) + =} } reactor Print(scale = 1) { # The scale parameter is just for testing. - input _in - - reaction(_in) {= - print("Received: [%s]" % ", ".join(map(str, _in.value))) - if _in.value != [x * self.scale for x in [0, 1, 2]]: - sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") - exit(1) - =} + input _in + + reaction(_in) {= + print("Received: [%s]" % ", ".join(map(str, _in.value))) + if _in.value != [x * self.scale for x in [0, 1, 2]]: + sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") + exit(1) + =} } main reactor DelayArray { - s = new Source() - d = new DelayPointer() - p = new Print() - s.out -> d._in - d.out -> p._in + s = new Source() + d = new DelayPointer() + p = new Print() + s.out -> d._in + d.out -> p._in } diff --git a/test/Python/src/DelayArrayWithAfter.lf b/test/Python/src/DelayArrayWithAfter.lf index 1e6ac1f317..1567074c22 100644 --- a/test/Python/src/DelayArrayWithAfter.lf +++ b/test/Python/src/DelayArrayWithAfter.lf @@ -1,52 +1,51 @@ -# This tests transport of dynamically allocated arrays over connections with -# 'after'. +# This tests transport of dynamically allocated arrays over connections with 'after'. target Python { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Source { - output out - state iteration = 1 - timer t(0, 1 sec) + output out + state iteration = 1 + timer t(0, 1 sec) - reaction(t) -> out {= - out.set([(x * self.iteration) for x in [1,2,3]]) - print("At time {:d}, sending list ".format(lf.time.logical_elapsed()), out.value) + reaction(t) -> out {= + out.set([(x * self.iteration) for x in [1,2,3]]) + print("At time {:d}, sending list ".format(lf.time.logical_elapsed()), out.value) - self.iteration += 1 - =} + self.iteration += 1 + =} } reactor Print(scale = 1) { # The scale parameter is just for testing. - input _in - state iteration = 1 - state inputs_received = 0 - - reaction(_in) {= - self.inputs_received += 1 - - print("At time {:d}, received list ".format(lf.time.logical_elapsed()), _in.value) - print("Received: [%s]" % ", ".join(map(str, _in.value))) - if _in.value != [(x * self.scale * self.iteration) for x in [1, 2, 3]]: - sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") - exit(1) - if len(_in.value) != 3: - sys.stderr.write("ERROR: Received list length is not 3!\n") - exit(2) - - self.iteration += 1 - =} - - reaction(shutdown) {= - if self.inputs_received == 0: - sys.stderr.write("ERROR: Print reactor received no inputs.\n") - exit(3) - =} + input _in + state iteration = 1 + state inputs_received = 0 + + reaction(_in) {= + self.inputs_received += 1 + + print("At time {:d}, received list ".format(lf.time.logical_elapsed()), _in.value) + print("Received: [%s]" % ", ".join(map(str, _in.value))) + if _in.value != [(x * self.scale * self.iteration) for x in [1, 2, 3]]: + sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") + exit(1) + if len(_in.value) != 3: + sys.stderr.write("ERROR: Received list length is not 3!\n") + exit(2) + + self.iteration += 1 + =} + + reaction(shutdown) {= + if self.inputs_received == 0: + sys.stderr.write("ERROR: Print reactor received no inputs.\n") + exit(3) + =} } main reactor DelayArrayWithAfter { - s = new Source() - p = new Print() - s.out -> p._in after 1500 msec + s = new Source() + p = new Print() + s.out -> p._in after 1500 msec } diff --git a/test/Python/src/DelayInt.lf b/test/Python/src/DelayInt.lf index fae554bd30..52d78dd47e 100644 --- a/test/Python/src/DelayInt.lf +++ b/test/Python/src/DelayInt.lf @@ -2,55 +2,55 @@ target Python reactor Delay(delay = 100 msec) { - input _in - output out - logical action a + input _in + output out + logical action a - reaction(a) -> out {= - if (a.value is not None) and a.is_present: - out.set(a.value) - =} + reaction(a) -> out {= + if (a.value is not None) and a.is_present: + out.set(a.value) + =} - reaction(_in) -> a {= a.schedule(self.delay, _in.value) =} + reaction(_in) -> a {= a.schedule(self.delay, _in.value) =} } reactor Test { - input _in - state start_time = 0 - state received_value = False - - reaction(startup) {= - # Record the logical time at the start. - self.start_time = lf.time.logical() - =} - - reaction(_in) {= - print("Received: ", _in.value) - self.received_value = True - # Check the time of the input. - current_time = lf.time.logical() - elapsed = current_time - self.start_time - print("After {:d} nsec of logical time.\n".format(elapsed)) - if elapsed != 100000000: - sys.stderr.write("ERROR: Expected elapsed time to be 100000000. It was {:d}.\n".format(elapsed)) - exit(1) - if _in.value != 42: - sys.stderr.write("ERROR: Expected input value to be 42. It was {:d}.\n".format(_in.value)) - exit(2) - =} - - reaction(shutdown) {= - print("Checking that communication occurred.") - if self.received_value is not True: - sys.stderr.write("ERROR: No communication occurred!\n") - exit(3) - =} + input _in + state start_time = 0 + state received_value = False + + reaction(startup) {= + # Record the logical time at the start. + self.start_time = lf.time.logical() + =} + + reaction(_in) {= + print("Received: ", _in.value) + self.received_value = True + # Check the time of the input. + current_time = lf.time.logical() + elapsed = current_time - self.start_time + print("After {:d} nsec of logical time.\n".format(elapsed)) + if elapsed != 100000000: + sys.stderr.write("ERROR: Expected elapsed time to be 100000000. It was {:d}.\n".format(elapsed)) + exit(1) + if _in.value != 42: + sys.stderr.write("ERROR: Expected input value to be 42. It was {:d}.\n".format(_in.value)) + exit(2) + =} + + reaction(shutdown) {= + print("Checking that communication occurred.") + if self.received_value is not True: + sys.stderr.write("ERROR: No communication occurred!\n") + exit(3) + =} } main reactor DelayInt { - d = new Delay() - t = new Test() - d.out -> t._in + d = new Delay() + t = new Test() + d.out -> t._in - reaction(startup) -> d._in {= d._in.set(42) =} + reaction(startup) -> d._in {= d._in.set(42) =} } diff --git a/test/Python/src/DelayString.lf b/test/Python/src/DelayString.lf index d1201dec02..e5462b60e8 100644 --- a/test/Python/src/DelayString.lf +++ b/test/Python/src/DelayString.lf @@ -1,39 +1,38 @@ -# This tests actions with immutable payloads that are neither malloc'd nor -# freed. +# This tests actions with immutable payloads that are neither malloc'd nor freed. target Python reactor DelayString2(delay = 100 msec) { - input _in - output out - logical action a + input _in + output out + logical action a - reaction(a) -> out {= out.set(a.value) =} + reaction(a) -> out {= out.set(a.value) =} - reaction(_in) -> a {= a.schedule(self.delay, _in.value) =} + reaction(_in) -> a {= a.schedule(self.delay, _in.value) =} } reactor Test { - input _in - state start_time = 0 + input _in + state start_time = 0 - reaction(_in) {= - print("Received: ", _in.value) - # Check the time of the input. - elapsed = lf.time.logical_elapsed() - print("After {:d} nsec of logical time.\n".format(elapsed)) - if elapsed != 100000000: - sys.stderr.write("ERROR: Expected elapsed time to be 100000000. It was {:d}.\n".format(elapsed)) - exit(1) - if _in.value != "Hello": - sys.stderr.write("ERROR: Expected input value to be 'Hello'. It was '{:s}'.\n".format(_in.value)) - exit(2) - =} + reaction(_in) {= + print("Received: ", _in.value) + # Check the time of the input. + elapsed = lf.time.logical_elapsed() + print("After {:d} nsec of logical time.\n".format(elapsed)) + if elapsed != 100000000: + sys.stderr.write("ERROR: Expected elapsed time to be 100000000. It was {:d}.\n".format(elapsed)) + exit(1) + if _in.value != "Hello": + sys.stderr.write("ERROR: Expected input value to be 'Hello'. It was '{:s}'.\n".format(_in.value)) + exit(2) + =} } main reactor { - d = new DelayString2() - t = new Test() - d.out -> t._in + d = new DelayString2() + t = new Test() + d.out -> t._in - reaction(startup) -> d._in {= d._in.set("Hello") =} + reaction(startup) -> d._in {= d._in.set("Hello") =} } diff --git a/test/Python/src/DelayStruct.lf b/test/Python/src/DelayStruct.lf index e578a42699..94d232011b 100644 --- a/test/Python/src/DelayStruct.lf +++ b/test/Python/src/DelayStruct.lf @@ -1,45 +1,45 @@ # Test delaying a struct pointer type. target Python { - files: ["include/hello.py"] + files: ["include/hello.py"] } preamble {= import hello =} reactor DelayPointer(delay = 100 msec) { - input _in - output out - logical action a + input _in + output out + logical action a - reaction(a) -> out {= out.set(a.value); =} + reaction(a) -> out {= out.set(a.value); =} - reaction(_in) -> a {= - # Schedule the actual token from the input rather than - # a new token with a copy of the input value. - a.schedule(self.delay, _in.value); - =} + reaction(_in) -> a {= + # Schedule the actual token from the input rather than + # a new token with a copy of the input value. + a.schedule(self.delay, _in.value); + =} } reactor Source { - output out + output out - reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} + reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} } reactor Print(expected = 42) { # expected parameter is for testing. - input _in - - reaction(_in) {= - print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) - if _in.value.value != self.expected: - sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) - exit(1) - =} + input _in + + reaction(_in) {= + print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) + if _in.value.value != self.expected: + sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) + exit(1) + =} } main reactor DelayStruct { - s = new Source() - d = new DelayPointer() - p = new Print() - s.out -> d._in - d.out -> p._in + s = new Source() + d = new DelayPointer() + p = new Print() + s.out -> d._in + d.out -> p._in } diff --git a/test/Python/src/DelayStructWithAfter.lf b/test/Python/src/DelayStructWithAfter.lf index 5bb945cb3c..b7d34f127a 100644 --- a/test/Python/src/DelayStructWithAfter.lf +++ b/test/Python/src/DelayStructWithAfter.lf @@ -1,29 +1,29 @@ # This tests delaying a struct using after. target Python { - files: include/hello.py + files: include/hello.py } preamble {= import hello =} reactor Source { - output out + output out - reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} + reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} } reactor Print(expected = 42) { # expected parameter is for testing. - input _in + input _in - reaction(_in) {= - print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) - if _in.value.value != self.expected: - sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) - exit(1) - =} + reaction(_in) {= + print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) + if _in.value.value != self.expected: + sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) + exit(1) + =} } main reactor DelayStructWithAfter { - s = new Source() - p = new Print() - s.out -> p._in after 100 msec + s = new Source() + p = new Print() + s.out -> p._in after 100 msec } diff --git a/test/Python/src/DelayStructWithAfterOverlapped.lf b/test/Python/src/DelayStructWithAfterOverlapped.lf index 072012a106..ed9270de31 100644 --- a/test/Python/src/DelayStructWithAfterOverlapped.lf +++ b/test/Python/src/DelayStructWithAfterOverlapped.lf @@ -1,44 +1,44 @@ # This tests delaying a struct using after. target Python { - timeout: 5 sec, - fast: true, - files: ["include/hello.py"] + timeout: 5 sec, + fast: true, + files: ["include/hello.py"] } preamble {= import hello =} reactor Source { - output out - timer t(0, 1 sec) - state s = 0 + output out + timer t(0, 1 sec) + state s = 0 - reaction(t) -> out {= - self.s += 1 - out.set(hello.hello("Earth", 42 * self.s)) - =} + reaction(t) -> out {= + self.s += 1 + out.set(hello.hello("Earth", 42 * self.s)) + =} } reactor Print { # expected parameter is for testing. - input _in - state s = 0 + input _in + state s = 0 - reaction(_in) {= - self.s += 1 - print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) - if _in.value.value != 42 * self.s: - sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(42 * self.s)) - exit(1) - =} + reaction(_in) {= + self.s += 1 + print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) + if _in.value.value != 42 * self.s: + sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(42 * self.s)) + exit(1) + =} - reaction(shutdown) {= - if self.s == 0: - sys.stderr.write("ERROR: Print received no data.\n") - exit(2) - =} + reaction(shutdown) {= + if self.s == 0: + sys.stderr.write("ERROR: Print received no data.\n") + exit(2) + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p._in after 1500 msec + s = new Source() + p = new Print() + s.out -> p._in after 1500 msec } diff --git a/test/Python/src/DelayedAction.lf b/test/Python/src/DelayedAction.lf index 06c488b9c5..5bab6bc7c8 100644 --- a/test/Python/src/DelayedAction.lf +++ b/test/Python/src/DelayedAction.lf @@ -1,24 +1,24 @@ target Python { - fast: true, - timeout: 5 sec + fast: true, + timeout: 5 sec } main reactor DelayedAction { - timer t(0, 1 sec) - logical action a - state count = 0 + timer t(0, 1 sec) + logical action a + state count = 0 - reaction(t) -> a {= a.schedule(MSEC(100)) =} + reaction(t) -> a {= a.schedule(MSEC(100)) =} - reaction(a) {= - elapsed = lf.time.logical_elapsed() - elapsed_physical = lf.time.physical_elapsed() - print("Nanoseconds since start: ", elapsed) - print("Physical nanoseconds since start: ", elapsed_physical) - expected = self.count * 1000000000 + 100000000 - self.count += 1 - if elapsed != expected: - sys.stderr.write("Expected {:d} but got {:d}.\n".format(expected, elapsed)) - exit(1) - =} + reaction(a) {= + elapsed = lf.time.logical_elapsed() + elapsed_physical = lf.time.physical_elapsed() + print("Nanoseconds since start: ", elapsed) + print("Physical nanoseconds since start: ", elapsed_physical) + expected = self.count * 1000000000 + 100000000 + self.count += 1 + if elapsed != expected: + sys.stderr.write("Expected {:d} but got {:d}.\n".format(expected, elapsed)) + exit(1) + =} } diff --git a/test/Python/src/DoubleInvocation.lf b/test/Python/src/DoubleInvocation.lf index aaecfa31cb..36327d815f 100644 --- a/test/Python/src/DoubleInvocation.lf +++ b/test/Python/src/DoubleInvocation.lf @@ -1,52 +1,51 @@ -# This illustrates a very strange bug that showed up and has now been fixed. -# This test ensures it does not reappear. At logical time zero, the two Print -# reactors used to be fired twice each at the same logical time. They should -# only be fired once. This behavior was oddly eliminated by either of the -# following actions, neither of which should affect this behavior: +# This illustrates a very strange bug that showed up and has now been fixed. This test ensures it +# does not reappear. At logical time zero, the two Print reactors used to be fired twice each at the +# same logical time. They should only be fired once. This behavior was oddly eliminated by either of +# the following actions, neither of which should affect this behavior: # * Removing the startup reaction in Print. # * Sending only position, not velocity from Ball. target Python { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Ball { - output position - output velocity - state p = 200 - timer trigger(0, 1 sec) + output position + output velocity + state p = 200 + timer trigger(0, 1 sec) - reaction(trigger) -> position, velocity {= - position.set(self.p) - velocity.set(-1) - self.p -= 1 - =} + reaction(trigger) -> position, velocity {= + position.set(self.p) + velocity.set(-1) + self.p -= 1 + =} } reactor Print { - input velocity - input position - state previous = -1 + input velocity + input position + state previous = -1 - reaction(startup) {= - print("####### Print startup\n") - =} + reaction(startup) {= + print("####### Print startup\n") + =} - reaction(position, velocity) {= - if position.is_present: - print("Position: ", position.value) - if position.value == self.previous: - sys.stderr.write("ERROR: Multiple firings at the same logical time!\n") - exit(1) - =} + reaction(position, velocity) {= + if position.is_present: + print("Position: ", position.value) + if position.value == self.previous: + sys.stderr.write("ERROR: Multiple firings at the same logical time!\n") + exit(1) + =} } main reactor DoubleInvocation { - b1 = new Ball() - p = new Print() - plot = new Print() - b1.position -> p.position - b1.velocity -> p.velocity - b1.position -> plot.position - b1.velocity -> plot.velocity + b1 = new Ball() + p = new Print() + plot = new Print() + b1.position -> p.position + b1.velocity -> p.velocity + b1.position -> plot.position + b1.velocity -> plot.velocity } diff --git a/test/Python/src/DoubleReaction.lf b/test/Python/src/DoubleReaction.lf index c20a032a9a..855dbdfe6a 100644 --- a/test/Python/src/DoubleReaction.lf +++ b/test/Python/src/DoubleReaction.lf @@ -1,44 +1,44 @@ -# Test that two simultaneous inputs that trigger a reaction trigger it only -# once. Correct output for this 2, 4, 6, 8, etc. +# Test that two simultaneous inputs that trigger a reaction trigger it only once. Correct output for +# this 2, 4, 6, 8, etc. target Python { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Clock(offset = 0, period = 1 sec) { - output y - timer t(offset, period) - state count = 0 + output y + timer t(offset, period) + state count = 0 - reaction(t) -> y {= - self.count += 1 - y.set(self.count) - =} + reaction(t) -> y {= + self.count += 1 + y.set(self.count) + =} } reactor Destination { - input x - input w - state s = 2 + input x + input w + state s = 2 - reaction(x, w) {= - sm = 0 - if x.is_present: - sm += x.value - if w.is_present: - sm += w.value - print("Sum of inputs is: ", sm) - if sm != self.s: - sys.stderr.write("FAILURE: Expected sum to be {:d}, but it was {:d}.\n".format(self.s, sm)); - exit(1) - self.s += 2 - =} + reaction(x, w) {= + sm = 0 + if x.is_present: + sm += x.value + if w.is_present: + sm += w.value + print("Sum of inputs is: ", sm) + if sm != self.s: + sys.stderr.write("FAILURE: Expected sum to be {:d}, but it was {:d}.\n".format(self.s, sm)); + exit(1) + self.s += 2 + =} } main reactor DoubleReaction { - c1 = new Clock() - c2 = new Clock() - d = new Destination() - c1.y -> d.x - c2.y -> d.w + c1 = new Clock() + c2 = new Clock() + d = new Destination() + c1.y -> d.x + c2.y -> d.w } diff --git a/test/Python/src/FloatLiteral.lf b/test/Python/src/FloatLiteral.lf index b55953d135..8d1edd93f1 100644 --- a/test/Python/src/FloatLiteral.lf +++ b/test/Python/src/FloatLiteral.lf @@ -1,20 +1,19 @@ target Python -# This test verifies that floating-point literals are handled correctly. -main reactor { - state N = 6.0221409e+23 - state charge = -1.6021766E-19 - state minus_epsilon = -.01e0 - state expected = .964853323188E5 +main reactor { # This test verifies that floating-point literals are handled correctly. + state N = 6.0221409e+23 + state charge = -1.6021766E-19 + state minus_epsilon = -.01e0 + state expected = .964853323188E5 - reaction(startup) {= - F = - self.N * self.charge - if abs(F - self.expected) < abs(self.minus_epsilon): - print("The Faraday constant is roughly {}.".format(F)) - else: - sys.stderr.write("ERROR: Expected {} but got {}.".format( - self.expected, F - )) - exit(1) - =} + reaction(startup) {= + F = - self.N * self.charge + if abs(F - self.expected) < abs(self.minus_epsilon): + print("The Faraday constant is roughly {}.".format(F)) + else: + sys.stderr.write("ERROR: Expected {} but got {}.".format( + self.expected, F + )) + exit(1) + =} } diff --git a/test/Python/src/Gain.lf b/test/Python/src/Gain.lf index d69d4d2a65..769d08f78e 100644 --- a/test/Python/src/Gain.lf +++ b/test/Python/src/Gain.lf @@ -2,36 +2,36 @@ target Python reactor Scale(scale = 2) { - input x - output y + input x + output y - reaction(x) -> y {= y.set(x.value * self.scale) =} + reaction(x) -> y {= y.set(x.value * self.scale) =} } reactor Test { - input x - state received_value = 0 + input x + state received_value = 0 - reaction(x) {= - print("Received " + str(x.value)) - self.received_value = True - if x.value != 2: - sys.stderr.write("ERROR: Expected 2!") - exit(1) - =} + reaction(x) {= + print("Received " + str(x.value)) + self.received_value = True + if x.value != 2: + sys.stderr.write("ERROR: Expected 2!") + exit(1) + =} - reaction(shutdown) {= - if self.received_value is None: - sys.stderr.write("ERROR: No value received by Test reactor!") - else: - sys.stderr.write("Test passes.") - =} + reaction(shutdown) {= + if self.received_value is None: + sys.stderr.write("ERROR: No value received by Test reactor!") + else: + sys.stderr.write("Test passes.") + =} } main reactor Gain { - g = new Scale() - d = new Test() - g.y -> d.x + g = new Scale() + d = new Test() + g.y -> d.x - reaction(startup) -> g.x {= g.x.set(1) =} + reaction(startup) -> g.x {= g.x.set(1) =} } diff --git a/test/Python/src/GetMicroStep.lf b/test/Python/src/GetMicroStep.lf index 124c692ef8..345c953f95 100644 --- a/test/Python/src/GetMicroStep.lf +++ b/test/Python/src/GetMicroStep.lf @@ -1,23 +1,23 @@ # Tests the get_microstep() function in the python target. target Python { - fast: false + fast: false } main reactor GetMicroStep { - preamble {= import sys =} - state s = 1 + preamble {= import sys =} + state s = 1 - logical action l # timer t(0, 1 msec); + logical action l # timer t(0, 1 msec); - reaction(startup) -> l {= l.schedule(0); =} + reaction(startup) -> l {= l.schedule(0); =} - reaction(l) -> l {= - microstep = lf.tag().microstep - if microstep != self.s: - self.sys.stderr.write(f"expected microstep {self.s}, got {microstep} instead\n") - self.sys.exit(1) - self.s += 1 - if self.s < 10: - l.schedule(0) - =} + reaction(l) -> l {= + microstep = lf.tag().microstep + if microstep != self.s: + self.sys.stderr.write(f"expected microstep {self.s}, got {microstep} instead\n") + self.sys.exit(1) + self.s += 1 + if self.s < 10: + l.schedule(0) + =} } diff --git a/test/Python/src/Hello.lf b/test/Python/src/Hello.lf index 271ed180ca..4f9dd68f47 100644 --- a/test/Python/src/Hello.lf +++ b/test/Python/src/Hello.lf @@ -1,52 +1,48 @@ -# This test checks that logical time is incremented an appropriate amount as a -# result of an invocation of the schedule() function at runtime. It also -# performs various smoke tests of timing aligned reactions. The first instance -# has a period of 4 seconds, the second of 2 seconds, and the third (composite) -# or 1 second. +# This test checks that logical time is incremented an appropriate amount as a result of an +# invocation of the schedule() function at runtime. It also performs various smoke tests of timing +# aligned reactions. The first instance has a period of 4 seconds, the second of 2 seconds, and the +# third (composite) or 1 second. target Python { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Reschedule(period = 2 sec, message = "Hello Python") { - state count = 0 - state previous_time = 0 - timer t(1 sec, period) - logical action a + state count = 0 + state previous_time = 0 + timer t(1 sec, period) + logical action a - reaction(t) -> a {= - print(self.message) - a.schedule(MSEC(200)) - # Print the current time. - self.previous_time = lf.time.logical() - secs = self.previous_time/BILLION - print("Current time is ", self.previous_time) - print("Which is {:f} Plus {:d} nanoseconds.\n".format(secs, self.previous_time % BILLION)) - =} + reaction(t) -> a {= + print(self.message) + a.schedule(MSEC(200)) + # Print the current time. + self.previous_time = lf.time.logical() + secs = self.previous_time/BILLION + print("Current time is ", self.previous_time) + print("Which is {:f} Plus {:d} nanoseconds.\n".format(secs, self.previous_time % BILLION)) + =} - reaction(a) {= - self.count += 1 - print("***** action {:d} at time {:d}\n".format(self.count, lf.time.logical())) - # Check if a.value is not None. - if a.value is not None: - sys.stderr.write("FAILURE: Expected a.value to be None, but it exists.\n") - exit(2) - tm = lf.time.logical() - if (tm - self.previous_time) != 200000000: - sys.stderr.write("FAILURE: Expected 200ms of logical time to elapse but got {:d} nanoseconds.\n".format(tm - self.previous_time)) - exit(1) - =} + reaction(a) {= + self.count += 1 + print("***** action {:d} at time {:d}\n".format(self.count, lf.time.logical())) + # Check if a.value is not None. + if a.value is not None: + sys.stderr.write("FAILURE: Expected a.value to be None, but it exists.\n") + exit(2) + tm = lf.time.logical() + if (tm - self.previous_time) != 200000000: + sys.stderr.write("FAILURE: Expected 200ms of logical time to elapse but got {:d} nanoseconds.\n".format(tm - self.previous_time)) + exit(1) + =} } reactor Inside(period = 1 sec, message = "Composite default message.") { - third_instance = new Reschedule(period = period, message = message) + third_instance = new Reschedule(period = period, message = message) } main reactor Hello { - first_instance = new Reschedule( - period = 4 sec, - message = "Hello from first_instance." - ) - second_instance = new Reschedule(message = "Hello from second_instance.") - composite_instance = new Inside(message = "Hello from composite_instance.") + first_instance = new Reschedule(period = 4 sec, message = "Hello from first_instance.") + second_instance = new Reschedule(message = "Hello from second_instance.") + composite_instance = new Inside(message = "Hello from composite_instance.") } diff --git a/test/Python/src/HelloWorld.lf b/test/Python/src/HelloWorld.lf index 523ff9ce2b..486bea5990 100644 --- a/test/Python/src/HelloWorld.lf +++ b/test/Python/src/HelloWorld.lf @@ -1,23 +1,23 @@ target Python { - tracing: true + tracing: true } reactor HelloWorld2 { - state success = False + state success = False - reaction(startup) {= - print("Hello World.") - self.success = True - =} + reaction(startup) {= + print("Hello World.") + self.success = True + =} - reaction(shutdown) {= - print("Shutdown invoked.") - if not self.success: - sys.stderr.write("ERROR: startup reaction not executed.\n") - sys.exit(1) - =} + reaction(shutdown) {= + print("Shutdown invoked.") + if not self.success: + sys.stderr.write("ERROR: startup reaction not executed.\n") + sys.exit(1) + =} } main reactor HelloWorld { - a = new HelloWorld2() + a = new HelloWorld2() } diff --git a/test/Python/src/Hierarchy2.lf b/test/Python/src/Hierarchy2.lf index a1792712fa..cec5bf4c9f 100644 --- a/test/Python/src/Hierarchy2.lf +++ b/test/Python/src/Hierarchy2.lf @@ -1,69 +1,69 @@ # Test data transport across hierarchy. target Python { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Source { - output out - timer t(0, 1 sec) + output out + timer t(0, 1 sec) - reaction(t) -> out {= out.set(1) =} + reaction(t) -> out {= out.set(1) =} } reactor Count { - output out - timer t(0, 1 sec) - state i = 0 + output out + timer t(0, 1 sec) + state i = 0 - reaction(t) -> out {= - self.i += 1 - out.set(self.i) - =} + reaction(t) -> out {= + self.i += 1 + out.set(self.i) + =} } reactor Add { - input in1 - input in2 - output out + input in1 + input in2 + output out - reaction(in1, in2) -> out {= - result = 0 - if in1.is_present: - result += in1.value - if in2.is_present: - result += in2.value - out.set(result) - =} + reaction(in1, in2) -> out {= + result = 0 + if in1.is_present: + result += in1.value + if in2.is_present: + result += in2.value + out.set(result) + =} } reactor Print { - input _in - state expected = 2 + input _in + state expected = 2 - reaction(_in) {= - print("Received: ", _in.value) - if _in.value != self.expected: - sys.stderr.write("Expected {:d}.\n".format(self.expected)) - exit(1) - self.expected+=1 - =} + reaction(_in) {= + print("Received: ", _in.value) + if _in.value != self.expected: + sys.stderr.write("Expected {:d}.\n".format(self.expected)) + exit(1) + self.expected+=1 + =} } reactor AddCount { - input _in - output out - count = new Count() - add = new Add() - _in -> add.in1 - count.out -> add.in2 - add.out -> out + input _in + output out + count = new Count() + add = new Add() + _in -> add.in1 + count.out -> add.in2 + add.out -> out } main reactor Hierarchy2 { - source = new Source() - addCount = new AddCount() - print = new Print() - source.out -> addCount._in - addCount.out -> print._in + source = new Source() + addCount = new AddCount() + print = new Print() + source.out -> addCount._in + addCount.out -> print._in } diff --git a/test/Python/src/IdentifierLength.lf b/test/Python/src/IdentifierLength.lf index 62b31141a0..e80c3e3f7a 100644 --- a/test/Python/src/IdentifierLength.lf +++ b/test/Python/src/IdentifierLength.lf @@ -1,43 +1,39 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor A_Really_Long_Name_For_A_Source_But_Not_Quite_255_Characters_Which_Is_The_Maximum_For_The_Python_Target( - period = 2 sec + period = 2 sec ) { - output y - timer t(1 sec, period) - state count = 0 + output y + timer t(1 sec, period) + state count = 0 - reaction(t) -> y {= - self.count += 1 - y.set(self.count) - =} + reaction(t) -> y {= + self.count += 1 + y.set(self.count) + =} } reactor Another_Really_Long_Name_For_A_Test_Class { - input x - state count = 0 + input x + state count = 0 - reaction(x) {= - self.count += 1 - print("Received ", x.value) - if x.value != self.count: - sys.stderr.write("FAILURE: Expected {:d}.\n".format(self.count)) - exit(1) - =} + reaction(x) {= + self.count += 1 + print("Received ", x.value) + if x.value != self.count: + sys.stderr.write("FAILURE: Expected {:d}.\n".format(self.count)) + exit(1) + =} } main reactor IdentifierLength { - a_really_long_name_for_a_source_instance = new A_Really_Long_Name_For_A_Source_But_Not_Quite_255_Characters_Which_Is_The_Maximum_For_The_Python_Target( + a_really_long_name_for_a_source_instance = new A_Really_Long_Name_For_A_Source_But_Not_Quite_255_Characters_Which_Is_The_Maximum_For_The_Python_Target( - ) - another_really_long_name_for_a_test_instance = new Another_Really_Long_Name_For_A_Test_Class( - - ) - a_really_long_name_for_a_source_instance.y - -> another_really_long_name_for_a_test_instance.x + ) + another_really_long_name_for_a_test_instance = new Another_Really_Long_Name_For_A_Test_Class() + a_really_long_name_for_a_source_instance.y -> another_really_long_name_for_a_test_instance.x } diff --git a/test/Python/src/ImportComposition.lf b/test/Python/src/ImportComposition.lf index 369fbcab44..5558db6163 100644 --- a/test/Python/src/ImportComposition.lf +++ b/test/Python/src/ImportComposition.lf @@ -1,30 +1,29 @@ -# This tests the ability to import a reactor definition that itself imports a -# reactor definition. +# This tests the ability to import a reactor definition that itself imports a reactor definition. target Python import ImportedComposition from "lib/ImportedComposition.lf" main reactor ImportComposition { - a = new ImportedComposition() - state received = False + a = new ImportedComposition() + state received = False - reaction(startup) -> a.x {= a.x.set(42) =} + reaction(startup) -> a.x {= a.x.set(42) =} - reaction(a.y) {= - receive_time = lf.time.logical_elapsed() - print("Received {:d} at time {:d}".format(a.y.value, receive_time)) - self.received = True - if receive_time != 55000000: - sys.stderr.write("ERROR: Received time should have been 55,000,000.\n") - exit(1) - if a.y.value != 42 * 2 * 2: - sys.stderr.write("ERROR: Received value should have been {:d}.\n".format(42 * 2 * 2)) - exit(2) - =} + reaction(a.y) {= + receive_time = lf.time.logical_elapsed() + print("Received {:d} at time {:d}".format(a.y.value, receive_time)) + self.received = True + if receive_time != 55000000: + sys.stderr.write("ERROR: Received time should have been 55,000,000.\n") + exit(1) + if a.y.value != 42 * 2 * 2: + sys.stderr.write("ERROR: Received value should have been {:d}.\n".format(42 * 2 * 2)) + exit(2) + =} - reaction(shutdown) {= - if self.received is not True: - sys.stderr.write("ERROR: Nothing received.\n"); - exit(3) - =} + reaction(shutdown) {= + if self.received is not True: + sys.stderr.write("ERROR: Nothing received.\n"); + exit(3) + =} } diff --git a/test/Python/src/ManualDelayedReaction.lf b/test/Python/src/ManualDelayedReaction.lf index a9e39829eb..573c588b67 100644 --- a/test/Python/src/ManualDelayedReaction.lf +++ b/test/Python/src/ManualDelayedReaction.lf @@ -1,52 +1,51 @@ target Python { - # Set keepalive to false since this is a test and schedule is called on a - # physical action from within a reaction. This is one of the special rare - # cases where the user might want to manually override keepalive. - keepalive: false + # Set keepalive to false since this is a test and schedule is called on a physical action from + # within a reaction. This is one of the special rare cases where the user might want to manually + # override keepalive. + keepalive: false } -# That's the stuff that shall be generated for the after -reactor GeneratedDelay { - input y_in - output y_out - state y_state = 0 +reactor GeneratedDelay { # That's the stuff that shall be generated for the after + input y_in + output y_out + state y_state = 0 - physical action act(0 msec) # TODO: delay in act or the schedule call? + physical action act(0 msec) # TODO: delay in act or the schedule call? - reaction(y_in) -> act {= - self.y_state = y_in.value - act.schedule(MSEC(100)) - =} + reaction(y_in) -> act {= + self.y_state = y_in.value + act.schedule(MSEC(100)) + =} - reaction(act) -> y_out {= y_out.set(self.y_state) =} + reaction(act) -> y_out {= y_out.set(self.y_state) =} } reactor Source { - output out - timer t + output out + timer t - reaction(t) -> out {= out.set(1) =} # reaction(t) -> out after 100 msec + reaction(t) -> out {= out.set(1) =} # reaction(t) -> out after 100 msec } reactor Sink { - input s_in - - reaction(s_in) {= - elapsed_logical = lf.time.logical_elapsed() - logical = lf.time.logical() - physical = lf.time.physical() - print("Nanoseconds since start: {:d} {:d} {:d}.\n".format(logical, physical, elapsed_logical)) - if elapsed_logical < MSEC(100): - sys.stderr.write("Expected {:d} but got {:d}.\n".format(MSEC(100), elapsed_logical)) - exit(1) - =} deadline(200 msec) {= =} + input s_in + + reaction(s_in) {= + elapsed_logical = lf.time.logical_elapsed() + logical = lf.time.logical() + physical = lf.time.physical() + print("Nanoseconds since start: {:d} {:d} {:d}.\n".format(logical, physical, elapsed_logical)) + if elapsed_logical < MSEC(100): + sys.stderr.write("Expected {:d} but got {:d}.\n".format(MSEC(100), elapsed_logical)) + exit(1) + =} deadline(200 msec) {= =} } main reactor ManualDelayedReaction { - source = new Source() - sink = new Sink() - g = new GeneratedDelay() + source = new Source() + sink = new Sink() + g = new GeneratedDelay() - source.out -> g.y_in # source.out -> sink.s_in; rewritten above - g.y_out -> sink.s_in + source.out -> g.y_in # source.out -> sink.s_in; rewritten above + g.y_out -> sink.s_in } diff --git a/test/Python/src/Methods.lf b/test/Python/src/Methods.lf index 5e0023fe8f..54bdacc825 100644 --- a/test/Python/src/Methods.lf +++ b/test/Python/src/Methods.lf @@ -2,23 +2,23 @@ target Python main reactor { - state foo = 2 + state foo = 2 - method getFoo() {= return self.foo =} + method getFoo() {= return self.foo =} - method add(x) {= self.foo += x =} + method add(x) {= self.foo += x =} - reaction(startup) {= - print(f"Foo is initialized to {self.getFoo()}") - if self.getFoo() != 2: - sys.stderr.write("Expected 2!"); - exit(1) + reaction(startup) {= + print(f"Foo is initialized to {self.getFoo()}") + if self.getFoo() != 2: + sys.stderr.write("Expected 2!"); + exit(1) - self.add(40) - a = self.getFoo() - print(f"2 + 40 = {a}") - if a != 42: - sys.stderr.write("Expected 42!"); - exit(1) - =} + self.add(40) + a = self.getFoo() + print(f"2 + 40 = {a}") + if a != 42: + sys.stderr.write("Expected 42!"); + exit(1) + =} } diff --git a/test/Python/src/MethodsRecursive.lf b/test/Python/src/MethodsRecursive.lf index 81afc86bea..a1fa182792 100644 --- a/test/Python/src/MethodsRecursive.lf +++ b/test/Python/src/MethodsRecursive.lf @@ -2,18 +2,18 @@ target Python main reactor { - state foo = 2 + state foo = 2 - method fib(n) {= # Return the n-th Fibonacci number. - if n <= 1: - return 1 - return self.add(self.fib(n-1), self.fib(n-2)) - =} + method fib(n) {= # Return the n-th Fibonacci number. + if n <= 1: + return 1 + return self.add(self.fib(n-1), self.fib(n-2)) + =} - method add(x, y) {= return x + y =} + method add(x, y) {= return x + y =} - reaction(startup) {= - for n in range(1, 10): - print(f"{n}-th Fibonacci number is {self.fib(n)}") - =} + reaction(startup) {= + for n in range(1, 10): + print(f"{n}-th Fibonacci number is {self.fib(n)}") + =} } diff --git a/test/Python/src/MethodsSameName.lf b/test/Python/src/MethodsSameName.lf index a80f521356..aedf19bef0 100644 --- a/test/Python/src/MethodsSameName.lf +++ b/test/Python/src/MethodsSameName.lf @@ -2,31 +2,31 @@ target Python reactor Foo { - state foo = 2 + state foo = 2 - method add(x) {= self.foo += x =} + method add(x) {= self.foo += x =} - reaction(startup) {= - self.add(40) - print(f"Foo: 2 + 40 = {self.foo}") - if self.foo != 42: - sys.stderr.write("Expected 42!") - exit(1) - =} + reaction(startup) {= + self.add(40) + print(f"Foo: 2 + 40 = {self.foo}") + if self.foo != 42: + sys.stderr.write("Expected 42!") + exit(1) + =} } main reactor { - state foo = 2 + state foo = 2 - a = new Foo() + a = new Foo() - method add(x) {= self.foo += x =} + method add(x) {= self.foo += x =} - reaction(startup) {= - self.add(40) - print(f"Main: 2 + 40 = {self.foo}") - if self.foo != 42: - sys.stderr.write("Expected 42!") - exit(1) - =} + reaction(startup) {= + self.add(40) + print(f"Main: 2 + 40 = {self.foo}") + if self.foo != 42: + sys.stderr.write("Expected 42!") + exit(1) + =} } diff --git a/test/Python/src/MovingAverage.lf b/test/Python/src/MovingAverage.lf index 3dbd5636c3..efaff22c10 100644 --- a/test/Python/src/MovingAverage.lf +++ b/test/Python/src/MovingAverage.lf @@ -1,51 +1,50 @@ -# Demonstration of a state variable that is a list. The MovingAverage reactor -# computes the moving average of the last four inputs and produces that as -# output. The source is a counting sequence. +# Demonstration of a state variable that is a list. The MovingAverage reactor computes the moving +# average of the last four inputs and produces that as output. The source is a counting sequence. target Python { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } import TestDouble from "lib/Test.lf" reactor MASource { - output out - state count = 0 - timer clock(0, 200 msec) - - reaction(clock) -> out {= - out.set(self.count) - self.count +=1 - =} + output out + state count = 0 + timer clock(0, 200 msec) + + reaction(clock) -> out {= + out.set(self.count) + self.count +=1 + =} } reactor MovingAverageImpl { - state delay_line(0.0, 0.0, 0.0) - state index = 0 - input m_in - output out - - reaction(m_in) -> out {= - # Calculate the output. - sm = m_in.value - sm += sum(self.delay_line) - - out.set(sm/4.0) - - # Insert the input in the delay line. - self.delay_line[self.index] = m_in.value - - # Update the index for the next input. - self.index +=1 - if self.index >= 3: - self.index = 0 - =} + state delay_line(0.0, 0.0, 0.0) + state index = 0 + input m_in + output out + + reaction(m_in) -> out {= + # Calculate the output. + sm = m_in.value + sm += sum(self.delay_line) + + out.set(sm/4.0) + + # Insert the input in the delay line. + self.delay_line[self.index] = m_in.value + + # Update the index for the next input. + self.index +=1 + if self.index >= 3: + self.index = 0 + =} } main reactor MovingAverage { - s = new MASource() - m = new MovingAverageImpl() - p = new TestDouble(expected(0.0, 0.25, 0.75, 1.5, 2.5, 3.5)) - s.out -> m.m_in - m.out -> p.t_in + s = new MASource() + m = new MovingAverageImpl() + p = new TestDouble(expected(0.0, 0.25, 0.75, 1.5, 2.5, 3.5)) + s.out -> m.m_in + m.out -> p.t_in } diff --git a/test/Python/src/MultipleContained.lf b/test/Python/src/MultipleContained.lf index 27950ccd88..515962986f 100644 --- a/test/Python/src/MultipleContained.lf +++ b/test/Python/src/MultipleContained.lf @@ -1,43 +1,42 @@ -# Test that a reaction can react to and send two multiple ports of a contained -# reactor. +# Test that a reaction can react to and send two multiple ports of a contained reactor. target Python reactor Contained { - output trigger - state count = 0 - input in1 - input in2 + output trigger + state count = 0 + input in1 + input in2 - reaction(startup) -> trigger {= trigger.set(42) =} + reaction(startup) -> trigger {= trigger.set(42) =} - reaction(in1) {= - print("in1 received ", in1.value); - if in1.value != 42: - sys.stderr.write("FAILED: Expected 42.\n") - exit(1) - self.count += 1 - =} + reaction(in1) {= + print("in1 received ", in1.value); + if in1.value != 42: + sys.stderr.write("FAILED: Expected 42.\n") + exit(1) + self.count += 1 + =} - reaction(in2) {= - print("in2 received ", in2.value) - if in2.value != 42: - sys.stderr.write("FAILED: Expected 42.\n") - exit(1) - self.count += 1 - =} + reaction(in2) {= + print("in2 received ", in2.value) + if in2.value != 42: + sys.stderr.write("FAILED: Expected 42.\n") + exit(1) + self.count += 1 + =} - reaction(shutdown) {= - if self.count != 2: - sys.stderr.write("FAILED: Should have received two inputs.\n") - exit(1) - =} + reaction(shutdown) {= + if self.count != 2: + sys.stderr.write("FAILED: Should have received two inputs.\n") + exit(1) + =} } main reactor MultipleContained { - c = new Contained() + c = new Contained() - reaction(c.trigger) -> c.in1, c.in2 {= - c.in1.set(c.trigger.value) - c.in2.set(c.trigger.value) - =} + reaction(c.trigger) -> c.in1, c.in2 {= + c.in1.set(c.trigger.value) + c.in2.set(c.trigger.value) + =} } diff --git a/test/Python/src/NativeListsAndTimes.lf b/test/Python/src/NativeListsAndTimes.lf index b7b52b3d0a..775d074343 100644 --- a/test/Python/src/NativeListsAndTimes.lf +++ b/test/Python/src/NativeListsAndTimes.lf @@ -1,27 +1,26 @@ target Python -# This test passes if it is successfully compiled into valid target code. -main reactor( - x = 0, - y = 0, # Units are missing but not required - z = 1 msec, # Type is missing but not required - p(1, 2, 3, 4), # List of integers - q(1 msec, 2 msec, 3 msec), # list of time values - g(1 msec, 2 msec) # List of time values +main reactor( # This test passes if it is successfully compiled into valid target code. + x = 0, + y = 0, # Units are missing but not required + z = 1 msec, # Type is missing but not required + p(1, 2, 3, 4), # List of integers + q(1 msec, 2 msec, 3 msec), # list of time values + g(1 msec, 2 msec) # List of time values ) { - state s = y # Reference to explicitly typed time parameter - state t = z # Reference to implicitly typed time parameter - state v # Uninitialized boolean state variable - state w # Uninitialized time state variable - timer tick(0) # Units missing but not required - timer tock(1 sec) # Implicit type time - timer toe(z) # Implicit type time - state baz = p # Implicit type int[] - state period = z # Implicit type time - state bar(1 msec, 2 msec, 3 msec) # list of time values - state notype(1, 2, 3, 4) + state s = y # Reference to explicitly typed time parameter + state t = z # Reference to implicitly typed time parameter + state v # Uninitialized boolean state variable + state w # Uninitialized time state variable + timer tick(0) # Units missing but not required + timer tock(1 sec) # Implicit type time + timer toe(z) # Implicit type time + state baz = p # Implicit type int[] + state period = z # Implicit type time + state bar(1 msec, 2 msec, 3 msec) # list of time values + state notype(1, 2, 3, 4) - reaction(tick) {= - # Target code - =} + reaction(tick) {= + # Target code + =} } diff --git a/test/Python/src/ParameterizedState.lf b/test/Python/src/ParameterizedState.lf index e8805b027f..32791918de 100644 --- a/test/Python/src/ParameterizedState.lf +++ b/test/Python/src/ParameterizedState.lf @@ -1,11 +1,11 @@ target Python reactor Foo(bar = 42) { - state baz = bar + state baz = bar - reaction(startup) {= print("Baz: ", self.baz) =} + reaction(startup) {= print("Baz: ", self.baz) =} } main reactor { - a = new Foo() + a = new Foo() } diff --git a/test/Python/src/PeriodicDesugared.lf b/test/Python/src/PeriodicDesugared.lf index b003ffc9f8..7c6f6768f2 100644 --- a/test/Python/src/PeriodicDesugared.lf +++ b/test/Python/src/PeriodicDesugared.lf @@ -1,22 +1,22 @@ target Python { - fast: true, - timeout: 1 sec + fast: true, + timeout: 1 sec } main reactor(offset = 0, period = 500 msec) { - logical action init(offset) - logical action recur(period) + logical action init(offset) + logical action recur(period) - reaction(startup) -> init, recur {= - if self.offset == 0: - print("Hello World!") - recur.schedule(0) - else: - init.schedule(0) - =} - - reaction(init, recur) -> recur {= + reaction(startup) -> init, recur {= + if self.offset == 0: print("Hello World!") recur.schedule(0) - =} + else: + init.schedule(0) + =} + + reaction(init, recur) -> recur {= + print("Hello World!") + recur.schedule(0) + =} } diff --git a/test/Python/src/PingPong.lf b/test/Python/src/PingPong.lf index f5f80511ae..5be9cfb50b 100644 --- a/test/Python/src/PingPong.lf +++ b/test/Python/src/PingPong.lf @@ -1,74 +1,71 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * Ping introduces a microstep delay using a logical action to break the - * causality loop. + * Ping introduces a microstep delay using a logical action to break the causality loop. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * Unthreaded: 97 msec Threaded: 265 msec * - * There is no parallelism in this application, so it does not benefit from - * being being threaded, just some additional overhead. + * There is no parallelism in this application, so it does not benefit from being being threaded, + * just some additional overhead. * - * These measurements are total execution time, including startup and shutdown. - * These are about an order of magnitude faster than anything reported in the - * paper. + * These measurements are total execution time, including startup and shutdown. These are about an + * order of magnitude faster than anything reported in the paper. * * @author Edward A. Lee */ target Python { - fast: true + fast: true } reactor Ping(count = 10) { - input receive - output send - state pingsLeft = count - logical action serve + input receive + output send + state pingsLeft = count + logical action serve - reaction(startup, serve) -> send {= - send.set(self.pingsLeft) - self.pingsLeft -= 1 - =} + reaction(startup, serve) -> send {= + send.set(self.pingsLeft) + self.pingsLeft -= 1 + =} - reaction(receive) -> serve {= - if self.pingsLeft > 0: - serve.schedule(0) - else: - request_stop() - =} + reaction(receive) -> serve {= + if self.pingsLeft > 0: + serve.schedule(0) + else: + request_stop() + =} } reactor Pong(expected = 10) { - input receive - output send - state count = 0 + input receive + output send + state count = 0 - reaction(receive) -> send {= - self.count += 1 - send.set(receive.value) - =} + reaction(receive) -> send {= + self.count += 1 + send.set(receive.value) + =} - reaction(shutdown) {= - if self.count != self.expected: - sys.stderr.write( - "ERROR: Pong expected to receive {} inputs, but it received {}.\n".format( - self.expected, - self.count - ) + reaction(shutdown) {= + if self.count != self.expected: + sys.stderr.write( + "ERROR: Pong expected to receive {} inputs, but it received {}.\n".format( + self.expected, + self.count ) - sys.exit(1) - print("Success.") - =} + ) + sys.exit(1) + print("Success.") + =} } main reactor PingPong { - ping = new Ping() - pong = new Pong() - ping.send -> pong.receive - pong.send -> ping.receive + ping = new Ping() + pong = new Pong() + ping.send -> pong.receive + pong.send -> ping.receive } diff --git a/test/Python/src/Pipeline.lf b/test/Python/src/Pipeline.lf index 18436561b8..fb72fd1026 100644 --- a/test/Python/src/Pipeline.lf +++ b/test/Python/src/Pipeline.lf @@ -1,58 +1,58 @@ target Python { - timeout: 2 sec + timeout: 2 sec } reactor TakeTime { - input _in - output out + input _in + output out - reaction(_in) -> out {= - offset = 0 - for i in range(10000): - offset+=1 + reaction(_in) -> out {= + offset = 0 + for i in range(10000): + offset+=1 - out.set(_in.value + offset) - =} + out.set(_in.value + offset) + =} } reactor Print { - input _in - state count = 0 - state received = 0 - - reaction(_in) {= - self.received += 1 - print("Received: {:d} at logical time {:d}".format(_in.value, lf.time.logical_elapsed())) - if _in.value != (self.count + 40000): - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.count + 40000)) - exit(1) - self.count+=1 - =} - - reaction(shutdown) {= - if self.received == 0: - sys.stderr.write("ERROR: Final reactor received no data.\n") - exit(3) - =} + input _in + state count = 0 + state received = 0 + + reaction(_in) {= + self.received += 1 + print("Received: {:d} at logical time {:d}".format(_in.value, lf.time.logical_elapsed())) + if _in.value != (self.count + 40000): + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.count + 40000)) + exit(1) + self.count+=1 + =} + + reaction(shutdown) {= + if self.received == 0: + sys.stderr.write("ERROR: Final reactor received no data.\n") + exit(3) + =} } main reactor Pipeline { - timer t(0, 200 msec) - state count = 0 - - c1 = new TakeTime() - c2 = new TakeTime() - c3 = new TakeTime() - c4 = new TakeTime() - p = new Print() - - c1.out -> c2._in after 200 msec - c2.out -> c3._in after 200 msec - c3.out -> c4._in after 200 msec - c4.out -> p._in - - reaction(t) -> c1._in {= - c1._in.set(self.count) - self.count += 1 - =} + timer t(0, 200 msec) + state count = 0 + + c1 = new TakeTime() + c2 = new TakeTime() + c3 = new TakeTime() + c4 = new TakeTime() + p = new Print() + + c1.out -> c2._in after 200 msec + c2.out -> c3._in after 200 msec + c3.out -> c4._in after 200 msec + c4.out -> p._in + + reaction(t) -> c1._in {= + c1._in.set(self.count) + self.count += 1 + =} } diff --git a/test/Python/src/ReadOutputOfContainedReactor.lf b/test/Python/src/ReadOutputOfContainedReactor.lf index 1cb73667ce..c67243b0d5 100644 --- a/test/Python/src/ReadOutputOfContainedReactor.lf +++ b/test/Python/src/ReadOutputOfContainedReactor.lf @@ -1,46 +1,45 @@ -# Test reacting to and reading outputs from a contained reactor in various -# permutations. +# Test reacting to and reading outputs from a contained reactor in various permutations. target Python reactor Contained { - output out + output out - reaction(startup) -> out {= out.set(42) =} + reaction(startup) -> out {= out.set(42) =} } main reactor ReadOutputOfContainedReactor { - c = new Contained() - state count = 0 + c = new Contained() + state count = 0 - reaction(startup) c.out {= - print("Startup reaction reading output of contained reactor: ", c.out.value) - if c.out.value != 42: - sys.stderr.write("Expected 42!\n") - exit(2) - self.count += 1 - =} + reaction(startup) c.out {= + print("Startup reaction reading output of contained reactor: ", c.out.value) + if c.out.value != 42: + sys.stderr.write("Expected 42!\n") + exit(2) + self.count += 1 + =} - reaction(c.out) {= - print("Reading output of contained reactor:", c.out.value) - if c.out.value != 42: - sys.stderr.write("Expected 42!\n") - exit(3) - self.count += 1 - =} + reaction(c.out) {= + print("Reading output of contained reactor:", c.out.value) + if c.out.value != 42: + sys.stderr.write("Expected 42!\n") + exit(3) + self.count += 1 + =} - reaction(startup, c.out) {= - print("Alternate triggering reading output of contained reactor: ", c.out.value) - if c.out.value != 42: - sys.stderr.write("Expected 42!\n") - exit(4) - self.count += 1 - =} + reaction(startup, c.out) {= + print("Alternate triggering reading output of contained reactor: ", c.out.value) + if c.out.value != 42: + sys.stderr.write("Expected 42!\n") + exit(4) + self.count += 1 + =} - reaction(shutdown) {= - if self.count != 3: - print("FAILURE: One of the reactions failed to trigger.\n") - exit(1) - else: - print("Test passes.") - =} + reaction(shutdown) {= + if self.count != 3: + print("FAILURE: One of the reactions failed to trigger.\n") + exit(1) + else: + print("Test passes.") + =} } diff --git a/test/Python/src/ScheduleLogicalAction.lf b/test/Python/src/ScheduleLogicalAction.lf index 3f99c65777..c1328ee85e 100644 --- a/test/Python/src/ScheduleLogicalAction.lf +++ b/test/Python/src/ScheduleLogicalAction.lf @@ -1,45 +1,45 @@ -# This checks that a logical action is scheduled the specified logical time -# after the current logical time. +# This checks that a logical action is scheduled the specified logical time after the current +# logical time. target Python { - fast: true, - timeout: 3 sec + fast: true, + timeout: 3 sec } reactor foo { - input x - output y - logical action a + input x + output y + logical action a - reaction(x) -> y, a {= - y.set(2*x.value) - # The following uses physical time, incorrectly. - a.schedule(MSEC(500)) - =} + reaction(x) -> y, a {= + y.set(2*x.value) + # The following uses physical time, incorrectly. + a.schedule(MSEC(500)) + =} - reaction(a) -> y {= y.set(-42) =} + reaction(a) -> y {= y.set(-42) =} } reactor print { - state expected_time = 0 - input x + state expected_time = 0 + input x - reaction(x) {= - elapsed_time = lf.time.logical_elapsed() - print("Result is ", x.value) - print("Current logical time is: ", elapsed_time) - print("Current physical time is: ", lf.time.physical_elapsed()) - if elapsed_time != self.expected_time: - sys.stderr.write("ERROR: Expected logical time to be {:d}.\n".format(self.expected_time)) - exit(1); - self.expected_time += MSEC(500) - =} + reaction(x) {= + elapsed_time = lf.time.logical_elapsed() + print("Result is ", x.value) + print("Current logical time is: ", elapsed_time) + print("Current physical time is: ", lf.time.physical_elapsed()) + if elapsed_time != self.expected_time: + sys.stderr.write("ERROR: Expected logical time to be {:d}.\n".format(self.expected_time)) + exit(1); + self.expected_time += MSEC(500) + =} } main reactor { - f = new foo() - p = new print() - timer t(0, 1 sec) - f.y -> p.x + f = new foo() + p = new print() + timer t(0, 1 sec) + f.y -> p.x - reaction(t) -> f.x {= f.x.set(42) =} + reaction(t) -> f.x {= f.x.set(42) =} } diff --git a/test/Python/src/SelfLoop.lf b/test/Python/src/SelfLoop.lf index 2b607b09c8..f4fd756bb2 100644 --- a/test/Python/src/SelfLoop.lf +++ b/test/Python/src/SelfLoop.lf @@ -1,38 +1,38 @@ target Python { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Self { - input x - output y - logical action a - state expected = 43 + input x + output y + logical action a + state expected = 43 - reaction(a) -> y {= - print("a = ", a.value) - y.set(a.value + 1) - =} + reaction(a) -> y {= + print("a = ", a.value) + y.set(a.value + 1) + =} - reaction(x) -> a {= - print("x = ", x.value) - if x.value != self.expected: - sys.stderr.write("Expected {:d}.\n".format(self.expected)) - exit(1) - self.expected += 1 - a.schedule(MSEC(100), x.value) - =} + reaction(x) -> a {= + print("x = ", x.value) + if x.value != self.expected: + sys.stderr.write("Expected {:d}.\n".format(self.expected)) + exit(1) + self.expected += 1 + a.schedule(MSEC(100), x.value) + =} - reaction(startup) -> a {= a.schedule(0, 42) =} + reaction(startup) -> a {= a.schedule(0, 42) =} - reaction(shutdown) {= - if self.expected <= 43: - sys.stderr.write("Received no data.\n") - exit(2) - =} + reaction(shutdown) {= + if self.expected <= 43: + sys.stderr.write("Received no data.\n") + exit(2) + =} } main reactor SelfLoop { - u = new Self() - u.y -> u.x + u = new Self() + u.y -> u.x } diff --git a/test/Python/src/SendingInside.lf b/test/Python/src/SendingInside.lf index 8bcc66c005..0edc80bf73 100644 --- a/test/Python/src/SendingInside.lf +++ b/test/Python/src/SendingInside.lf @@ -1,30 +1,30 @@ -# This tests a reactor that contains another reactor and also has its own -# reaction that routes inputs to the contained reactor. +# This tests a reactor that contains another reactor and also has its own reaction that routes +# inputs to the contained reactor. target Python { - timeout: 10 sec, - fast: true + timeout: 10 sec, + fast: true } reactor Printer { - input x - state count = 1 + input x + state count = 1 - reaction(x) {= - print("Inside reactor received: ", x.value) - if x.value != self.count: - sys.stderr.write("FAILURE: Expected {:d}.\n".format(self.count)) - exit(1) - self.count += 1 - =} + reaction(x) {= + print("Inside reactor received: ", x.value) + if x.value != self.count: + sys.stderr.write("FAILURE: Expected {:d}.\n".format(self.count)) + exit(1) + self.count += 1 + =} } main reactor SendingInside { - state count = 0 - timer t(0, 1 sec) - p = new Printer() + state count = 0 + timer t(0, 1 sec) + p = new Printer() - reaction(t) -> p.x {= - self.count += 1 - p.x.set(self.count) - =} + reaction(t) -> p.x {= + self.count += 1 + p.x.set(self.count) + =} } diff --git a/test/Python/src/SetArray.lf b/test/Python/src/SetArray.lf index 4766d529f7..c27408647b 100644 --- a/test/Python/src/SetArray.lf +++ b/test/Python/src/SetArray.lf @@ -1,27 +1,26 @@ -# This tests passing lists as port values This tests the use of the -# "polymorphic" delay reactor on a struct. It delays by a logical time any -# pointer datatype. +# This tests passing lists as port values This tests the use of the "polymorphic" delay reactor on a +# struct. It delays by a logical time any pointer datatype. target Python reactor Source { - output out + output out - reaction(startup) -> out {= out.set([0,1,2]) =} + reaction(startup) -> out {= out.set([0,1,2]) =} } reactor Print(scale = 1) { # The scale parameter is just for testing. - input _in + input _in - reaction(_in) {= - print("Recieved ", _in.value) - if _in.value != [self.scale*count for count in range(len(_in.value))]: - sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") - exit(1) - =} + reaction(_in) {= + print("Recieved ", _in.value) + if _in.value != [self.scale*count for count in range(len(_in.value))]: + sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") + exit(1) + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p._in + s = new Source() + p = new Print() + s.out -> p._in } diff --git a/test/Python/src/SimpleDeadline.lf b/test/Python/src/SimpleDeadline.lf index a714124129..1a9d42f48d 100644 --- a/test/Python/src/SimpleDeadline.lf +++ b/test/Python/src/SimpleDeadline.lf @@ -1,39 +1,38 @@ -# Test local deadline, where a deadline is associated with a reaction -# definition. This test triggers a reaction exactly once with a deadline -# violation. +# Test local deadline, where a deadline is associated with a reaction definition. This test triggers +# a reaction exactly once with a deadline violation. target Python reactor Deadline(threshold = 100 msec) { - input x - output deadlineViolation + input x + output deadlineViolation - reaction(x) -> deadlineViolation {= - sys.stderr.write("ERROR: Deadline violation was not detected!\n") - exit(1) - =} deadline(threshold) {= - print("Deadline violation detected.") - deadlineViolation.set(True) - =} + reaction(x) -> deadlineViolation {= + sys.stderr.write("ERROR: Deadline violation was not detected!\n") + exit(1) + =} deadline(threshold) {= + print("Deadline violation detected.") + deadlineViolation.set(True) + =} } reactor Print { - input _in + input _in - reaction(_in) {= - if _in.value is True: - print("Output successfully produced by deadline handler.") - =} + reaction(_in) {= + if _in.value is True: + print("Output successfully produced by deadline handler.") + =} } main reactor SimpleDeadline { - timer start - d = new Deadline(threshold = 10 msec) - p = new Print() - d.deadlineViolation -> p._in - preamble {= import time =} + timer start + d = new Deadline(threshold = 10 msec) + p = new Print() + d.deadlineViolation -> p._in + preamble {= import time =} - reaction(start) -> d.x {= - self.time.sleep(0.02) - d.x.set(42) - =} + reaction(start) -> d.x {= + self.time.sleep(0.02) + d.x.set(42) + =} } diff --git a/test/Python/src/SlowingClock.lf b/test/Python/src/SlowingClock.lf index 972421437a..b53c59d713 100644 --- a/test/Python/src/SlowingClock.lf +++ b/test/Python/src/SlowingClock.lf @@ -1,38 +1,38 @@ /** - * Output events at logical times 100, 300, 600, and 1000 msec after the start - * time. This uses a logical action with a minimum delay of 100 msec and - * additional delays provided as arguments to the schedule() function. + * Output events at logical times 100, 300, 600, and 1000 msec after the start time. This uses a + * logical action with a minimum delay of 100 msec and additional delays provided as arguments to + * the schedule() function. */ target Python { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } main reactor SlowingClock { - logical action a(100 msec) - state interval = 100 msec - state expected_time = 100 msec + logical action a(100 msec) + state interval = 100 msec + state expected_time = 100 msec - reaction(startup) -> a {= a.schedule(0) =} + reaction(startup) -> a {= a.schedule(0) =} - reaction(a) -> a {= - elapsed_logical_time = lf.time.logical_elapsed() - print("Logical time since start: {:d} nsec.\n".format(elapsed_logical_time)) - if elapsed_logical_time != self.expected_time: - sys.stderr.write("ERROR: Expected time to be: {:d} nsec.\n".format(self.expected_time)) - exit(1) + reaction(a) -> a {= + elapsed_logical_time = lf.time.logical_elapsed() + print("Logical time since start: {:d} nsec.\n".format(elapsed_logical_time)) + if elapsed_logical_time != self.expected_time: + sys.stderr.write("ERROR: Expected time to be: {:d} nsec.\n".format(self.expected_time)) + exit(1) - a.schedule(self.interval) - self.expected_time += MSEC(100) + self.interval - self.interval += MSEC(100) - =} + a.schedule(self.interval) + self.expected_time += MSEC(100) + self.interval + self.interval += MSEC(100) + =} - reaction(shutdown) {= - if self.expected_time != MSEC(1500): - sys.stderr.write("ERROR: Expected the next expected time to be: 1500000000 nsec.\n") - sys.stderr.write("It was: {:d} nsec.\n".format(self.expected_time)) - exit(2) - else: - print("Test passes.") - =} + reaction(shutdown) {= + if self.expected_time != MSEC(1500): + sys.stderr.write("ERROR: Expected the next expected time to be: 1500000000 nsec.\n") + sys.stderr.write("It was: {:d} nsec.\n".format(self.expected_time)) + exit(2) + else: + print("Test passes.") + =} } diff --git a/test/Python/src/SlowingClockPhysical.lf b/test/Python/src/SlowingClockPhysical.lf index dbb9da705f..39d75b4c6d 100644 --- a/test/Python/src/SlowingClockPhysical.lf +++ b/test/Python/src/SlowingClockPhysical.lf @@ -1,45 +1,42 @@ /** - * Output events at physical times at least 100, 300, and 600 msec after the - * start time. This uses a physical action with a minimum interarrival time of - * 100 msec. The reactor increases the interarrival time with each invocation of - * the schedule() function. The timestamps of the events will be exact because - * the physical time at which schedule() is called is always way smaller than - * the time of the last invocation (or start time) plus the minimum interarrival - * time. Hence, the minimum interarrival time always determines the time of the - * next event. + * Output events at physical times at least 100, 300, and 600 msec after the start time. This uses a + * physical action with a minimum interarrival time of 100 msec. The reactor increases the + * interarrival time with each invocation of the schedule() function. The timestamps of the events + * will be exact because the physical time at which schedule() is called is always way smaller than + * the time of the last invocation (or start time) plus the minimum interarrival time. Hence, the + * minimum interarrival time always determines the time of the next event. */ target Python { - timeout: 1500 msec + timeout: 1500 msec } main reactor SlowingClockPhysical { - # first offset and minimum interarrival time. - physical action a(100 msec, 100 msec) - state interval = 100 msec - state expected_time = 100 msec + physical action a(100 msec, 100 msec) # first offset and minimum interarrival time. + state interval = 100 msec + state expected_time = 100 msec - reaction(startup) -> a {= - self.expected_time = MSEC(100) - a.schedule(0) - =} + reaction(startup) -> a {= + self.expected_time = MSEC(100) + a.schedule(0) + =} - reaction(a) -> a {= - elapsed_logical_time = lf.time.logical_elapsed() - print("Logical time since start: {:d} nsec.".format(elapsed_logical_time)) - if elapsed_logical_time < self.expected_time: - sys.stderr.write("ERROR: Expected logical time to be at least: {:d} nsec.\n".format(self.expected_time)) - exit(1) - self.interval += MSEC(100) - self.expected_time = MSEC(100) + self.interval - a.schedule(self.interval) - print("Scheduling next to occur after: {:d} nsec.".format(self.interval)) - =} + reaction(a) -> a {= + elapsed_logical_time = lf.time.logical_elapsed() + print("Logical time since start: {:d} nsec.".format(elapsed_logical_time)) + if elapsed_logical_time < self.expected_time: + sys.stderr.write("ERROR: Expected logical time to be at least: {:d} nsec.\n".format(self.expected_time)) + exit(1) + self.interval += MSEC(100) + self.expected_time = MSEC(100) + self.interval + a.schedule(self.interval) + print("Scheduling next to occur after: {:d} nsec.".format(self.interval)) + =} - reaction(shutdown) {= - if self.expected_time < MSEC(500): - sys.stderr.write("ERROR: Expected the next expected time to be at least: 500000000 nsec.\n"); - sys.stderr.write("It was: {:d} nsec.\n".format(self.expected_time)) - exit(2) - print("Success") - =} + reaction(shutdown) {= + if self.expected_time < MSEC(500): + sys.stderr.write("ERROR: Expected the next expected time to be at least: 500000000 nsec.\n"); + sys.stderr.write("It was: {:d} nsec.\n".format(self.expected_time)) + exit(2) + print("Success") + =} } diff --git a/test/Python/src/Stride.lf b/test/Python/src/Stride.lf index 86c68bab5a..db83ecc2e6 100644 --- a/test/Python/src/Stride.lf +++ b/test/Python/src/Stride.lf @@ -1,35 +1,35 @@ -# This example illustrates state variables and parameters on the wiki. For this -# test, success is just compiling and running. +# This example illustrates state variables and parameters on the wiki. For this test, success is +# just compiling and running. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Count(stride = 1) { - state count = 1 - output y - timer t(0, 100 msec) + state count = 1 + output y + timer t(0, 100 msec) - reaction(t) -> y {= - y.set(self.count) - self.count += self.stride - =} + reaction(t) -> y {= + y.set(self.count) + self.count += self.stride + =} } reactor Display { - input x - state expected = 1 # for testing. + input x + state expected = 1 # for testing. - reaction(x) {= - print("Received: ", x.value) - if x.value != self.expected: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.expected)) - self.expected += 2 - =} + reaction(x) {= + print("Received: ", x.value) + if x.value != self.expected: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.expected)) + self.expected += 2 + =} } main reactor Stride { - c = new Count(stride = 2) - d = new Display() - c.y -> d.x + c = new Count(stride = 2) + d = new Display() + c.y -> d.x } diff --git a/test/Python/src/StructAsState.lf b/test/Python/src/StructAsState.lf index b6f38f8589..f7d725325d 100644 --- a/test/Python/src/StructAsState.lf +++ b/test/Python/src/StructAsState.lf @@ -1,20 +1,19 @@ -# Check that a state variable can have a statically initialized struct as a -# value. +# Check that a state variable can have a statically initialized struct as a value. target Python main reactor StructAsState { - preamble {= - class hello: - def __init__(self, name, value): - self.name = name - self.value = value - =} - state s = {= self.hello("Earth", 42) =} + preamble {= + class hello: + def __init__(self, name, value): + self.name = name + self.value = value + =} + state s = {= self.hello("Earth", 42) =} - reaction(startup) {= - print("State s.name=\"{:s}\", value={:d}.".format(self.s.name, self.s.value)) - if self.s.value != 42: - sys.stderr.write("FAILED: Expected 42.\n") - exit(1) - =} + reaction(startup) {= + print("State s.name=\"{:s}\", value={:d}.".format(self.s.name, self.s.value)) + if self.s.value != 42: + sys.stderr.write("FAILED: Expected 42.\n") + exit(1) + =} } diff --git a/test/Python/src/StructAsType.lf b/test/Python/src/StructAsType.lf index 46951ec86a..cd200a86ff 100644 --- a/test/Python/src/StructAsType.lf +++ b/test/Python/src/StructAsType.lf @@ -1,31 +1,31 @@ target Python { - files: include/hello.py + files: include/hello.py } preamble {= import hello =} reactor Source { - output out + output out - reaction(startup) -> out {= - temp = hello.hello("Earth", 42) - out.set(temp) - =} + reaction(startup) -> out {= + temp = hello.hello("Earth", 42) + out.set(temp) + =} } reactor Print(expected = 42) { # expected parameter is for testing. - input _in + input _in - reaction(_in) {= - print("Received: name = {:s}, value = {:d}\n".format(_in.value.name, _in.value.value)) - if _in.value.value != self.expected: - sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) - exit(1) - =} + reaction(_in) {= + print("Received: name = {:s}, value = {:d}\n".format(_in.value.name, _in.value.value)) + if _in.value.value != self.expected: + sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) + exit(1) + =} } main reactor StructAsType { - s = new Source() - p = new Print() - s.out -> p._in + s = new Source() + p = new Print() + s.out -> p._in } diff --git a/test/Python/src/StructAsTypeDirect.lf b/test/Python/src/StructAsTypeDirect.lf index 921b7e4390..9e44cc6f34 100644 --- a/test/Python/src/StructAsTypeDirect.lf +++ b/test/Python/src/StructAsTypeDirect.lf @@ -1,34 +1,34 @@ target Python { - files: include/hello.py + files: include/hello.py } preamble {= import hello =} reactor Source { - output out + output out - reaction(startup) -> out {= - out_value = out.value - out_value = hello.hello() - out_value.name = "Earth" - out_value.value = 42 - out.set(out_value) - =} + reaction(startup) -> out {= + out_value = out.value + out_value = hello.hello() + out_value.name = "Earth" + out_value.value = 42 + out.set(out_value) + =} } reactor Print(expected = 42) { # expected parameter is for testing. - input _in + input _in - reaction(_in) {= - print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) - if _in.value.value != self.expected: - sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) - exit(1) - =} + reaction(_in) {= + print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) + if _in.value.value != self.expected: + sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) + exit(1) + =} } main reactor { - s = new Source() - p = new Print() - s.out -> p._in + s = new Source() + p = new Print() + s.out -> p._in } diff --git a/test/Python/src/StructParallel.lf b/test/Python/src/StructParallel.lf index bac79a6abe..1f5a51fa50 100644 --- a/test/Python/src/StructParallel.lf +++ b/test/Python/src/StructParallel.lf @@ -1,7 +1,7 @@ -# Source allocates a class object and then sends it to two reactors, each of -# which want to modify it. +# Source allocates a class object and then sends it to two reactors, each of which want to modify +# it. target Python { - files: ["include/hello.py"] + files: ["include/hello.py"] } import Source from "StructScale.lf" @@ -9,38 +9,37 @@ import Source from "StructScale.lf" preamble {= import hello =} reactor Check(expected = 42) { - input _in - - reaction(_in) {= - print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) - if _in.value.value != self.expected: - sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) - exit(1) - =} + input _in + + reaction(_in) {= + print("Received: name = {:s}, value = {:d}".format(_in.value.name, _in.value.value)) + if _in.value.value != self.expected: + sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) + exit(1) + =} } reactor Print(scale = 2) { - # Mutable keyword indicates that this reactor wants a writable copy of the - # input. - mutable input _in + # Mutable keyword indicates that this reactor wants a writable copy of the input. + mutable input _in - output out + output out - reaction(_in) -> out {= - print(_in.value.value) - _in.value.value *= self.scale; - out.set(_in.value) - =} + reaction(_in) -> out {= + print(_in.value.value) + _in.value.value *= self.scale; + out.set(_in.value) + =} } main reactor StructParallel { - s = new Source() - c1 = new Print() - c2 = new Print(scale = 3) - p1 = new Check(expected = 84) - p2 = new Check(expected = 126) - s.out -> c1._in - s.out -> c2._in - c1.out -> p1._in - c2.out -> p2._in + s = new Source() + c1 = new Print() + c2 = new Print(scale = 3) + p1 = new Check(expected = 84) + p2 = new Check(expected = 126) + s.out -> c1._in + s.out -> c2._in + c1.out -> p1._in + c2.out -> p2._in } diff --git a/test/Python/src/StructPrint.lf b/test/Python/src/StructPrint.lf index 3c0138f937..191f72bc6d 100644 --- a/test/Python/src/StructPrint.lf +++ b/test/Python/src/StructPrint.lf @@ -1,30 +1,30 @@ -# Source produces a dynamically allocated class object, which it passes to -# Print. Reference counting ensures that the struct is freed. +# Source produces a dynamically allocated class object, which it passes to Print. Reference counting +# ensures that the struct is freed. target Python { - files: ["include/hello.py"] + files: ["include/hello.py"] } preamble {= import hello =} reactor Print { - output out + output out - reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} + reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} } reactor Check(expected = 42) { # expected parameter is for testing. - input _in + input _in - reaction(_in) {= - print("Received: name = {:s}, value = {:d}\n".format(_in.value.name, _in.value.value)) - if _in.value.value != self.expected: - sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) - exit(1) - =} + reaction(_in) {= + print("Received: name = {:s}, value = {:d}\n".format(_in.value.name, _in.value.value)) + if _in.value.value != self.expected: + sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) + exit(1) + =} } main reactor { - s = new Print() - p = new Check() - s.out -> p._in + s = new Print() + p = new Check() + s.out -> p._in } diff --git a/test/Python/src/StructScale.lf b/test/Python/src/StructScale.lf index 120c6fde65..ce4a25bc67 100644 --- a/test/Python/src/StructScale.lf +++ b/test/Python/src/StructScale.lf @@ -1,45 +1,44 @@ -# Source produces a dynamically allocated class object, which it passes to -# Scale. Scale modifies it and passes it to Print. +# Source produces a dynamically allocated class object, which it passes to Scale. Scale modifies it +# and passes it to Print. target Python { - files: ["include/hello.py"] + files: ["include/hello.py"] } preamble {= import hello =} reactor Source { - output out + output out - reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} + reaction(startup) -> out {= out.set(hello.hello("Earth", 42)) =} } reactor TestInput(expected = 42) { # expected parameter is for testing. - input _in - - reaction(_in) {= - print("Received: name = {:s}, value = {:d}\n".format(_in.value.name, _in.value.value)) - if _in.value.value != self.expected: - sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) - exit(1) - =} + input _in + + reaction(_in) {= + print("Received: name = {:s}, value = {:d}\n".format(_in.value.name, _in.value.value)) + if _in.value.value != self.expected: + sys.stderr.write("ERROR: Expected value to be {:d}.\n".format(self.expected)) + exit(1) + =} } reactor Print(scale = 2) { - # Mutable keyword indicates that this reactor wants a writable copy of the - # input. - mutable input _in + # Mutable keyword indicates that this reactor wants a writable copy of the input. + mutable input _in - output out + output out - reaction(_in) -> out {= - _in.value.value *= self.scale; - out.set(_in.value) - =} + reaction(_in) -> out {= + _in.value.value *= self.scale; + out.set(_in.value) + =} } main reactor StructScale { - s = new Source() - c = new Print() - p = new TestInput(expected = 84) - s.out -> c._in - c.out -> p._in + s = new Source() + c = new Print() + p = new TestInput(expected = 84) + s.out -> c._in + c.out -> p._in } diff --git a/test/Python/src/SubclassesAndStartup.lf b/test/Python/src/SubclassesAndStartup.lf index a98e580851..794ad83d53 100644 --- a/test/Python/src/SubclassesAndStartup.lf +++ b/test/Python/src/SubclassesAndStartup.lf @@ -1,39 +1,39 @@ target Python reactor Super { - state count = 0 + state count = 0 - reaction(startup) {= - print("{:s}(Super) started".format(self.name)) - self.count += 1 - =} + reaction(startup) {= + print("{:s}(Super) started".format(self.name)) + self.count += 1 + =} - reaction(shutdown) {= - if self.count == 0: - sys.stderr.write("No startup reaction was invoked!\n") - exit(3) - =} + reaction(shutdown) {= + if self.count == 0: + sys.stderr.write("No startup reaction was invoked!\n") + exit(3) + =} } reactor SubA(name = "SubA") extends Super { - reaction(startup) {= - print("{:s} started".format(self.name)) - if self.count == 0: - sys.stderr.write("Base class startup reaction was not invoked!\n") - exit(1) - =} + reaction(startup) {= + print("{:s} started".format(self.name)) + if self.count == 0: + sys.stderr.write("Base class startup reaction was not invoked!\n") + exit(1) + =} } reactor SubB(name = "SubB") extends Super { - reaction(startup) {= - print("{:s} started".format(self.name)) - if self.count == 0: - sys.stderr.write("Base class startup reaction was not invoked!\n") - exit(2) - =} + reaction(startup) {= + print("{:s} started".format(self.name)) + if self.count == 0: + sys.stderr.write("Base class startup reaction was not invoked!\n") + exit(2) + =} } main reactor SubclassesAndStartup { - a = new SubA() - b = new SubB() + a = new SubA() + b = new SubB() } diff --git a/test/Python/src/TimeLimit.lf b/test/Python/src/TimeLimit.lf index beb7602db9..54b0bbc7fb 100644 --- a/test/Python/src/TimeLimit.lf +++ b/test/Python/src/TimeLimit.lf @@ -1,47 +1,46 @@ -# Test that the stop function can be used to internally impose a a time limit. -# Correct output for this 1, 2, 3, 4. Failure for this test is failing to halt -# or getting the wrong data. +# Test that the stop function can be used to internally impose a a time limit. Correct output for +# this 1, 2, 3, 4. Failure for this test is failing to halt or getting the wrong data. target Python { - fast: true + fast: true } reactor Clock(offset = 0, period = 1 sec) { - output y - timer t(offset, period) - state count = 0 + output y + timer t(offset, period) + state count = 0 - reaction(t) -> y {= - self.count += 1 - # print("Reacting at time ", lf.time.logical_elapsed()) - y.set(self.count) - =} + reaction(t) -> y {= + self.count += 1 + # print("Reacting at time ", lf.time.logical_elapsed()) + y.set(self.count) + =} } reactor Destination { - input x - state s = 1 + input x + state s = 1 - reaction(x) {= - # print(x.value) - if x.value != self.s: - sys.stderr.write("ERROR: Expected {:d} and got {:d}.\n".format(self.s, x.value)) - exit(1) - self.s += 1 - =} + reaction(x) {= + # print(x.value) + if x.value != self.s: + sys.stderr.write("ERROR: Expected {:d} and got {:d}.\n".format(self.s, x.value)) + exit(1) + self.s += 1 + =} - reaction(shutdown) {= - print("**** shutdown reaction invoked.") - if self.s != 12: - sys.stderr.write("ERROR: Expected 12 but got {:d}.\n".format(self.s)) - exit(1) - =} + reaction(shutdown) {= + print("**** shutdown reaction invoked.") + if self.s != 12: + sys.stderr.write("ERROR: Expected 12 but got {:d}.\n".format(self.s)) + exit(1) + =} } main reactor TimeLimit(period = 1 sec) { - timer stop(10 sec) - c = new Clock(period = period) - d = new Destination() - c.y -> d.x + timer stop(10 sec) + c = new Clock(period = period) + d = new Destination() + c.y -> d.x - reaction(stop) {= request_stop() =} + reaction(stop) {= request_stop() =} } diff --git a/test/Python/src/TimeState.lf b/test/Python/src/TimeState.lf index 72ad9f0ebd..6a82c5fbf9 100644 --- a/test/Python/src/TimeState.lf +++ b/test/Python/src/TimeState.lf @@ -1,11 +1,11 @@ target Python reactor Foo(bar = 42) { - state baz = 500 msec + state baz = 500 msec - reaction(startup) {= print("Baz: ", self.baz) =} + reaction(startup) {= print("Baz: ", self.baz) =} } main reactor { - a = new Foo() + a = new Foo() } diff --git a/test/Python/src/Timers.lf b/test/Python/src/Timers.lf index f6cbba747a..fb533ee3f6 100644 --- a/test/Python/src/Timers.lf +++ b/test/Python/src/Timers.lf @@ -1,21 +1,21 @@ /** Test whether timers with different periods are triggered correctly. */ target Python { - timeout: 2 sec + timeout: 2 sec } main reactor { - timer t(0, 1 sec) - timer t2(0, 2 sec) - state counter = 0 + timer t(0, 1 sec) + timer t2(0, 2 sec) + state counter = 0 - reaction(t2) {= self.counter += 2 =} + reaction(t2) {= self.counter += 2 =} - reaction(t) {= self.counter -= 1 =} + reaction(t) {= self.counter -= 1 =} - reaction(shutdown) {= - if self.counter != 1: - sys.stderr.write("Error: Expected {:d} and got {:d}.\n".format(1, self.counter)) - exit(1) - print("SUCCESS.") - =} + reaction(shutdown) {= + if self.counter != 1: + sys.stderr.write("Error: Expected {:d} and got {:d}.\n".format(1, self.counter)) + exit(1) + print("SUCCESS.") + =} } diff --git a/test/Python/src/TriggerDownstreamOnlyIfPresent.lf b/test/Python/src/TriggerDownstreamOnlyIfPresent.lf index b65f732652..6f7fdcc8bf 100644 --- a/test/Python/src/TriggerDownstreamOnlyIfPresent.lf +++ b/test/Python/src/TriggerDownstreamOnlyIfPresent.lf @@ -1,46 +1,43 @@ -/** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. - */ +/** This test checks that a downstream reaction is triggered only if its trigger is present. */ target Python { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Source { - output a - output b - state count = 0 - timer t(0, 200 msec) + output a + output b + state count = 0 + timer t(0, 200 msec) - reaction(t) -> a, b {= - if (self.count % 2) == 0: - a.set(self.count) - else: - b.set(self.count) - =} + reaction(t) -> a, b {= + if (self.count % 2) == 0: + a.set(self.count) + else: + b.set(self.count) + =} } reactor Destination { - input a - input b + input a + input b - reaction(a) {= - if a.is_present is not True: - sys.stderr.write("Reaction to a triggered even though all inputs are absent!\n") - exit(1) - =} + reaction(a) {= + if a.is_present is not True: + sys.stderr.write("Reaction to a triggered even though all inputs are absent!\n") + exit(1) + =} - reaction(b) {= - if b.is_present is not True: - sys.stderr.write("Reaction to b triggered even though all inputs are absent!\n") - exit(2) - =} + reaction(b) {= + if b.is_present is not True: + sys.stderr.write("Reaction to b triggered even though all inputs are absent!\n") + exit(2) + =} } main reactor TriggerDownstreamOnlyIfPresent { - s = new[2] Source() - d = new[2] Destination() - s.a -> d.a - s.b -> d.b + s = new[2] Source() + d = new[2] Destination() + s.a -> d.a + s.b -> d.b } diff --git a/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf b/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf index b9a9184296..2975045571 100644 --- a/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf +++ b/test/Python/src/TriggerDownstreamOnlyIfPresent2.lf @@ -1,40 +1,37 @@ -/** - * This test checks that a downstream reaction is triggered only if its trigger - * is present. - */ +/** This test checks that a downstream reaction is triggered only if its trigger is present. */ target Python { - timeout: 1 sec, - fast: true + timeout: 1 sec, + fast: true } reactor Source { - output[2] out - state count = 0 - timer t(0, 200 msec) + output[2] out + state count = 0 + timer t(0, 200 msec) - reaction(t) -> out {= - if (self.count % 2) == 0: - self.count += 1 - out[0].set(self.count) - else: - out[1].set(self.count) - =} + reaction(t) -> out {= + if (self.count % 2) == 0: + self.count += 1 + out[0].set(self.count) + else: + out[1].set(self.count) + =} } reactor Destination { - input _in + input _in - reaction(_in) {= - if _in.is_present is not True: - sys.stderr.write("Reaction to input of triggered even though all inputs are absent!\n") - exit(1) - =} + reaction(_in) {= + if _in.is_present is not True: + sys.stderr.write("Reaction to input of triggered even though all inputs are absent!\n") + exit(1) + =} - reaction(shutdown) {= print("SUCCESS.") =} + reaction(shutdown) {= print("SUCCESS.") =} } main reactor TriggerDownstreamOnlyIfPresent2 { - s = new Source() - d = new[2] Destination() - s.out -> d._in + s = new Source() + d = new[2] Destination() + s.out -> d._in } diff --git a/test/Python/src/UnconnectedInput.lf b/test/Python/src/UnconnectedInput.lf index 66f459138b..f518731c20 100644 --- a/test/Python/src/UnconnectedInput.lf +++ b/test/Python/src/UnconnectedInput.lf @@ -1,53 +1,53 @@ # Test unconnected input. target Python { - timeout: 5 sec, - fast: true + timeout: 5 sec, + fast: true } reactor Source { - output out - timer t(0, 1 sec) - state s = 1 - - reaction(t) -> out {= - out.set(self.s) - self.s += 1 - =} + output out + timer t(0, 1 sec) + state s = 1 + + reaction(t) -> out {= + out.set(self.s) + self.s += 1 + =} } reactor Add { - input in1 - input in2 - output out - - reaction(in1, in2) -> out {= - result = 0 - if in1.is_present: - result += in1.value - if in2.is_present: - result += in2.value - out.set(result) - =} + input in1 + input in2 + output out + + reaction(in1, in2) -> out {= + result = 0 + if in1.is_present: + result += in1.value + if in2.is_present: + result += in2.value + out.set(result) + =} } reactor Print { - input _in - state expected = 1 + input _in + state expected = 1 - reaction(_in) {= - print("Received: ", _in.value) - if _in.value != self.expected: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.expected)) - exit(1) + reaction(_in) {= + print("Received: ", _in.value) + if _in.value != self.expected: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.expected)) + exit(1) - self.expected +=1 - =} + self.expected +=1 + =} } main reactor UnconnectedInput { - source = new Source() - add = new Add() - print = new Print() - source.out -> add.in2 - add.out -> print._in + source = new Source() + add = new Add() + print = new Print() + source.out -> add.in2 + add.out -> print._in } diff --git a/test/Python/src/concurrent/AsyncCallback.lf b/test/Python/src/concurrent/AsyncCallback.lf index 5ef4167bed..bc61fb8c53 100644 --- a/test/Python/src/concurrent/AsyncCallback.lf +++ b/test/Python/src/concurrent/AsyncCallback.lf @@ -1,60 +1,59 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test - * periodically creates a concurrent Python thread that schedule a physical - * action twice. + * Test asynchronous callbacks that trigger a physical action. This test periodically creates a + * concurrent Python thread that schedule a physical action twice. */ target Python { - timeout: 2 sec + timeout: 2 sec } main reactor AsyncCallback { - preamble {= - # Note that preamble code is generated inside the reactor class in Python - import time - import threading + preamble {= + # Note that preamble code is generated inside the reactor class in Python + import time + import threading - def callback(self, a): - # Schedule twice. If the action is not physical, these should - # get consolidated into a single action triggering. If it is, - # then they cause two separate triggerings with close but not - # equal time stamps. The minimum time between these is determined - # by the argument in the physical action definition. - a.schedule(0) - a.schedule(0) + def callback(self, a): + # Schedule twice. If the action is not physical, these should + # get consolidated into a single action triggering. If it is, + # then they cause two separate triggerings with close but not + # equal time stamps. The minimum time between these is determined + # by the argument in the physical action definition. + a.schedule(0) + a.schedule(0) - # Simulate time passing before a callback occurs. - def take_time(self, a): - # The best Python can offer short of directly using ctypes to call nanosleep - self.time.sleep(0.1) - self.callback(a) - return None - =} - timer t(0, 200 msec) - state threads = {= list() =} - state expected_time = 100 msec - state toggle = False + # Simulate time passing before a callback occurs. + def take_time(self, a): + # The best Python can offer short of directly using ctypes to call nanosleep + self.time.sleep(0.1) + self.callback(a) + return None + =} + timer t(0, 200 msec) + state threads = {= list() =} + state expected_time = 100 msec + state toggle = False - physical action a(100 msec) - state i = 0 + physical action a(100 msec) + state i = 0 - reaction(t) -> a {= - # start new thread, provide callback - x = self.threading.Thread(target=self.take_time, args=(a,)) - self.threads.append(x) - x.start() - =} + reaction(t) -> a {= + # start new thread, provide callback + x = self.threading.Thread(target=self.take_time, args=(a,)) + self.threads.append(x) + x.start() + =} - reaction(a) {= - elapsed_time = lf.time.logical_elapsed() - print("Asynchronous callback {:d}: Assigned logical time greater than start time by {:d} nsec.".format(self.i, elapsed_time)); - self.i += 1 - if elapsed_time <= self.expected_time: - sys.stderr.write("ERROR: Expected logical time to be larger than {:d}.".format(self.expected_time)); - exit(1) - if self.toggle: - self.toggle = False - self.expected_time += 200000000 - else: - self.toggle = True - =} + reaction(a) {= + elapsed_time = lf.time.logical_elapsed() + print("Asynchronous callback {:d}: Assigned logical time greater than start time by {:d} nsec.".format(self.i, elapsed_time)); + self.i += 1 + if elapsed_time <= self.expected_time: + sys.stderr.write("ERROR: Expected logical time to be larger than {:d}.".format(self.expected_time)); + exit(1) + if self.toggle: + self.toggle = False + self.expected_time += 200000000 + else: + self.toggle = True + =} } diff --git a/test/Python/src/concurrent/AsyncCallbackNoTimer.lf b/test/Python/src/concurrent/AsyncCallbackNoTimer.lf index 4e481d1d34..971b4db6ce 100644 --- a/test/Python/src/concurrent/AsyncCallbackNoTimer.lf +++ b/test/Python/src/concurrent/AsyncCallbackNoTimer.lf @@ -1,64 +1,64 @@ /** - * Test asynchronous callbacks that trigger a physical action. This test creates - * a concurrent Python thread that schedule a physical action twice. + * Test asynchronous callbacks that trigger a physical action. This test creates a concurrent Python + * thread that schedule a physical action twice. * - * There are no timers in this test to drive the logical time forward. This is - * important in the Python target since the user Python threads should be - * allowed to execute independently of the underlying C core runtime, without - * the C runtime polling the Python context with a reaction to a timer. + * There are no timers in this test to drive the logical time forward. This is important in the + * Python target since the user Python threads should be allowed to execute independently of the + * underlying C core runtime, without the C runtime polling the Python context with a reaction to a + * timer. */ target Python { - timeout: 2 sec + timeout: 2 sec } main reactor { - preamble {= - # Note that preamble code is generated inside the reactor class in Python - import time - import threading + preamble {= + # Note that preamble code is generated inside the reactor class in Python + import time + import threading - def callback(self, a): - # Schedule twice. If the action is not physical, these should - # get consolidated into a single action triggering. If it is, - # then they cause two separate triggerings with close but not - # equal time stamps. The minimum time between these is determined - # by the argument in the physical action definition. - a.schedule(0) - a.schedule(0) + def callback(self, a): + # Schedule twice. If the action is not physical, these should + # get consolidated into a single action triggering. If it is, + # then they cause two separate triggerings with close but not + # equal time stamps. The minimum time between these is determined + # by the argument in the physical action definition. + a.schedule(0) + a.schedule(0) - # Simulate time passing before a callback occurs. - def take_time(self, a): - # The best Python can offer short of directly using ctypes to call nanosleep - self.time.sleep(0.1) - self.callback(a) - return None - =} + # Simulate time passing before a callback occurs. + def take_time(self, a): + # The best Python can offer short of directly using ctypes to call nanosleep + self.time.sleep(0.1) + self.callback(a) + return None + =} - state threads = {= list() =} - state expected_time = 100 msec - state toggle = False + state threads = {= list() =} + state expected_time = 100 msec + state toggle = False - physical action a(100 msec) - state i = 0 + physical action a(100 msec) + state i = 0 - reaction(startup) -> a {= - # start new thread, provide callback - x = self.threading.Thread(target=self.take_time, args=(a,)) - self.threads.append(x) - x.start() - =} + reaction(startup) -> a {= + # start new thread, provide callback + x = self.threading.Thread(target=self.take_time, args=(a,)) + self.threads.append(x) + x.start() + =} - reaction(a) {= - elapsed_time = lf.time.logical_elapsed() - print("Asynchronous callback {:d}: Assigned logical time greater than start time by {:d} nsec.".format(self.i, elapsed_time)); - self.i += 1 - if elapsed_time <= self.expected_time: - sys.stderr.write("ERROR: Expected logical time to be larger than {:d}.".format(self.expected_time)); - exit(1) - if self.toggle: - self.toggle = False - self.expected_time += 200000000 - else: - self.toggle = True - =} + reaction(a) {= + elapsed_time = lf.time.logical_elapsed() + print("Asynchronous callback {:d}: Assigned logical time greater than start time by {:d} nsec.".format(self.i, elapsed_time)); + self.i += 1 + if elapsed_time <= self.expected_time: + sys.stderr.write("ERROR: Expected logical time to be larger than {:d}.".format(self.expected_time)); + exit(1) + if self.toggle: + self.toggle = False + self.expected_time += 200000000 + else: + self.toggle = True + =} } diff --git a/test/Python/src/docker/FilesPropertyContainerized.lf b/test/Python/src/docker/FilesPropertyContainerized.lf index c34736af48..534f1416a5 100644 --- a/test/Python/src/docker/FilesPropertyContainerized.lf +++ b/test/Python/src/docker/FilesPropertyContainerized.lf @@ -1,32 +1,32 @@ target Python { - files: "../include/hello.py", - docker: true + files: "../include/hello.py", + docker: true } preamble {= + try: + import hello + except: + lf_request_stop() +=} + +main reactor { + preamble {= try: import hello except: lf_request_stop() -=} - -main reactor { - preamble {= - try: - import hello - except: - lf_request_stop() - =} - state passed = False - timer t(1 msec) + =} + state passed = False + timer t(1 msec) - reaction(t) {= self.passed = True =} + reaction(t) {= self.passed = True =} - reaction(shutdown) {= - if not self.passed: - print("Failed to import file listed in files target property") - exit(1) - else: - print("PASSED") - =} + reaction(shutdown) {= + if not self.passed: + print("Failed to import file listed in files target property") + exit(1) + else: + print("PASSED") + =} } diff --git a/test/Python/src/docker/federated/DistributedCountContainerized.lf b/test/Python/src/docker/federated/DistributedCountContainerized.lf index 5f8a348d24..48b71bd046 100644 --- a/test/Python/src/docker/federated/DistributedCountContainerized.lf +++ b/test/Python/src/docker/federated/DistributedCountContainerized.lf @@ -1,22 +1,21 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python { - timeout: 5 sec, - logging: DEBUG, - coordination: centralized, - docker: true + timeout: 5 sec, + logging: DEBUG, + coordination: centralized, + docker: true } import Count from "../../lib/Count.lf" import Print from "../../federated/DistributedCount.lf" federated reactor DistributedCountContainerized(offset = 200 msec) at rti { - c = new Count() - p = new Print() - c.out -> p.in_ after offset + c = new Count() + p = new Print() + c.out -> p.in_ after offset } diff --git a/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf b/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf index 911f0f3055..1fc26b13bc 100644 --- a/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf +++ b/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf @@ -1,6 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with decentralized - * coordination. + * Test for lf_request_stop() in federated execution with decentralized coordination. * * @author Soroush Bateni */ diff --git a/test/Python/src/federated/BroadcastFeedback.lf b/test/Python/src/federated/BroadcastFeedback.lf index 75d313e61d..b33b13742b 100644 --- a/test/Python/src/federated/BroadcastFeedback.lf +++ b/test/Python/src/federated/BroadcastFeedback.lf @@ -1,31 +1,29 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target Python { - timeout: 1 sec + timeout: 1 sec } reactor SenderAndReceiver { - output out - input[2] inp - state received = False + output out + input[2] inp + state received = False - reaction(startup) -> out {= out.set(42) =} + reaction(startup) -> out {= out.set(42) =} - reaction(inp) {= - if inp[0].is_present and inp[1].is_present and inp[0].value == 42 and inp[1].value == 42: - print("SUCCESS") - self.received = True - =} + reaction(inp) {= + if inp[0].is_present and inp[1].is_present and inp[0].value == 42 and inp[1].value == 42: + print("SUCCESS") + self.received = True + =} - reaction(shutdown) {= - if not self.received: - print("Failed to receive broadcast") - sys.exit(1) - =} + reaction(shutdown) {= + if not self.received: + print("Failed to receive broadcast") + sys.exit(1) + =} } federated reactor { - s = new[2] SenderAndReceiver() - (s.out)+ -> s.inp + s = new[2] SenderAndReceiver() + (s.out)+ -> s.inp } diff --git a/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf b/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf index ad2a11c10c..5f50210a22 100644 --- a/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf +++ b/test/Python/src/federated/BroadcastFeedbackWithHierarchy.lf @@ -1,40 +1,38 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target Python { - timeout: 1 sec + timeout: 1 sec } reactor SenderAndReceiver { - output out - input[2] in_ - state received = False + output out + input[2] in_ + state received = False - r = new Receiver() - in_ -> r.in_ + r = new Receiver() + in_ -> r.in_ - reaction(startup) -> out {= out.set(42) =} + reaction(startup) -> out {= out.set(42) =} } reactor Receiver { - preamble {= import sys =} - input[2] in_ - state received = False + preamble {= import sys =} + input[2] in_ + state received = False - reaction(in_) {= - if in_[0].is_present and in_[1].is_present and in_[0].value == 42 and in_[1].value == 42: - print("SUCCESS") - self.received = True - =} + reaction(in_) {= + if in_[0].is_present and in_[1].is_present and in_[0].value == 42 and in_[1].value == 42: + print("SUCCESS") + self.received = True + =} - reaction(shutdown) {= - if not self.received: - print("Failed to receive broadcast") - self.sys.exit(1) - =} + reaction(shutdown) {= + if not self.received: + print("Failed to receive broadcast") + self.sys.exit(1) + =} } federated reactor { - s = new[2] SenderAndReceiver() - (s.out)+ -> s.in_ + s = new[2] SenderAndReceiver() + (s.out)+ -> s.in_ } diff --git a/test/Python/src/federated/CycleDetection.lf b/test/Python/src/federated/CycleDetection.lf index cf9b6d6b54..7161b963f8 100644 --- a/test/Python/src/federated/CycleDetection.lf +++ b/test/Python/src/federated/CycleDetection.lf @@ -1,57 +1,57 @@ /** - * Check whether the internally generated network and control reactions - * introduce a cycle or not. The failure for this test is not being compiled. + * Check whether the internally generated network and control reactions introduce a cycle or not. + * The failure for this test is not being compiled. * @author Edward A. Lee */ target Python reactor CAReplica { - input local_update - input remote_update - input query + input local_update + input remote_update + input query - state balance = 0 + state balance = 0 - output response + output response - reaction(local_update, remote_update) {= - if local_update.is_present: - self.balance += local_update.value - if remote_update.is_present: - self.balance += remote_update.value - =} + reaction(local_update, remote_update) {= + if local_update.is_present: + self.balance += local_update.value + if remote_update.is_present: + self.balance += remote_update.value + =} - reaction(query) -> response {= response.set(self.balance) =} + reaction(query) -> response {= response.set(self.balance) =} } reactor UserInput { - preamble {= import sys =} - input balance - output deposit + preamble {= import sys =} + input balance + output deposit - reaction(startup) -> deposit {= deposit.set(100) =} + reaction(startup) -> deposit {= deposit.set(100) =} - reaction(balance) {= - if balance.value != 200: - self.sys.stderr.write("Did not receive the expected balance. Expected: 200. Got: {}.\n".format(balance.value)) - self.sys.exit(1) - print("Balance: {}".format(balance.value)) - lf_request_stop() - =} + reaction(balance) {= + if balance.value != 200: + self.sys.stderr.write("Did not receive the expected balance. Expected: 200. Got: {}.\n".format(balance.value)) + self.sys.exit(1) + print("Balance: {}".format(balance.value)) + lf_request_stop() + =} - reaction(shutdown) {= print("Test passed!") =} + reaction(shutdown) {= print("Test passed!") =} } federated reactor { - u1 = new UserInput() - r1 = new CAReplica() - u2 = new UserInput() - r2 = new CAReplica() - (u1.deposit)+ -> r1.query, r1.local_update - r1.response -> u1.balance - u1.deposit -> r2.remote_update - - (u2.deposit)+ -> r2.query, r2.local_update - r2.response -> u2.balance - u2.deposit -> r1.remote_update + u1 = new UserInput() + r1 = new CAReplica() + u2 = new UserInput() + r2 = new CAReplica() + (u1.deposit)+ -> r1.query, r1.local_update + r1.response -> u1.balance + u1.deposit -> r2.remote_update + + (u2.deposit)+ -> r2.query, r2.local_update + r2.response -> u2.balance + u2.deposit -> r1.remote_update } diff --git a/test/Python/src/federated/DecentralizedP2PComm.lf b/test/Python/src/federated/DecentralizedP2PComm.lf index 2725386915..922b3a7008 100644 --- a/test/Python/src/federated/DecentralizedP2PComm.lf +++ b/test/Python/src/federated/DecentralizedP2PComm.lf @@ -1,47 +1,47 @@ target Python { - timeout: 1 sec, - tracing: true, - clock-sync: off, - coordination: decentralized + timeout: 1 sec, + tracing: true, + clock-sync: off, + coordination: decentralized } reactor Platform(start = 0, expected_start = 0, stp_offset_param = 0) { - preamble {= import sys =} - input in_ - output out - timer t(0, 100 msec) - state count = start - state expected = expected_start + preamble {= import sys =} + input in_ + output out + timer t(0, 100 msec) + state count = start + state expected = expected_start - reaction(t) -> out {= - out.set(self.count) - self.count += 1 - =} + reaction(t) -> out {= + out.set(self.count) + self.count += 1 + =} - reaction(in_) {= - print("Received {}.".format(in_.value)) - if in_.value != self.expected: - self.sys.stderr.write("Expected {} but got {}.\n".format(self.expected_start, in_.value)) - self.sys.exit(1) - self.expected += 1 - =} STP(stp_offset_param) {= - print("Received {} late.".format(in_.value)) - current_tag = lf.tag() - self.expected += 1 - self.sys.stderr.write("STP offset was violated by ({}, {}).".format(current_tag.time - in_.intended_tag.time, current_tag.microstep - in_.intended_tag.microstep)) - =} + reaction(in_) {= + print("Received {}.".format(in_.value)) + if in_.value != self.expected: + self.sys.stderr.write("Expected {} but got {}.\n".format(self.expected_start, in_.value)) + self.sys.exit(1) + self.expected += 1 + =} STP(stp_offset_param) {= + print("Received {} late.".format(in_.value)) + current_tag = lf.tag() + self.expected += 1 + self.sys.stderr.write("STP offset was violated by ({}, {}).".format(current_tag.time - in_.intended_tag.time, current_tag.microstep - in_.intended_tag.microstep)) + =} - reaction(shutdown) {= - print("Shutdown invoked.") - if self.expected == self.expected_start: - self.sys.stderr.write("Did not receive anything.\n") - self.sys.exit(1) - =} + reaction(shutdown) {= + print("Shutdown invoked.") + if self.expected == self.expected_start: + self.sys.stderr.write("Did not receive anything.\n") + self.sys.exit(1) + =} } federated reactor DecentralizedP2PComm { - a = new Platform(expected_start = 100, stp_offset_param = 10 msec) - b = new Platform(start = 100, stp_offset_param = 10 msec) - a.out -> b.in_ - b.out -> a.in_ + a = new Platform(expected_start = 100, stp_offset_param = 10 msec) + b = new Platform(start = 100, stp_offset_param = 10 msec) + a.out -> b.in_ + b.out -> a.in_ } diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf index 48ff7a4ca7..a91a9fd9ec 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeout.lf @@ -1,57 +1,56 @@ /** - * Test a source-destination scenario where the source falls behind real-time, - * and reaches the timeout much later than the destination. In this test, the - * destination closes the connection early, causing the transmission to fail. - * Warnings will be printed about lost messages. + * Test a source-destination scenario where the source falls behind real-time, and reaches the + * timeout much later than the destination. In this test, the destination closes the connection + * early, causing the transmission to fail. Warnings will be printed about lost messages. * * The test fails if the federation does not exit. */ target Python { - timeout: 1 msec, - coordination: decentralized + timeout: 1 msec, + coordination: decentralized } # reason for failing: lf_tag() not supported by the python target reactor Clock(offset = 0, period = 1 sec) { - output y - timer t(offset, period) - state count = 0 + output y + timer t(offset, period) + state count = 0 - reaction(t) -> y {= - self.count += 1 - print("Sending {}.".format(self.count)) - y.set(self.count) - =} + reaction(t) -> y {= + self.count += 1 + print("Sending {}.".format(self.count)) + y.set(self.count) + =} - reaction(shutdown) {= print("SUCCESS: the source exited successfully.") =} + reaction(shutdown) {= print("SUCCESS: the source exited successfully.") =} } reactor Destination { - preamble {= import sys =} - input x - state s = 1 - state startup_logical_time - - reaction(startup) {= self.startup_logical_time = lf.time.logical() =} - - reaction(x) {= - print("Received {}".format(x.value)) - current_tag = lf.tag() - if x.value != self.s: - error_msg = "At tag ({}, {}) expected {} and got {}.".format(current_tag.time - self.startup_logical_time, current_tag.microstep, self.s, x.value) - self.sys.stderr.write(error_msg) - self.sys.exit(1) - self.s += 1 - =} - - reaction(shutdown) {= - print("**** shutdown reaction invoked.") - print("Approx. time per reaction: {}ns".format(lf.time.physical_elapsed()//(self.s+1))) - =} + preamble {= import sys =} + input x + state s = 1 + state startup_logical_time + + reaction(startup) {= self.startup_logical_time = lf.time.logical() =} + + reaction(x) {= + print("Received {}".format(x.value)) + current_tag = lf.tag() + if x.value != self.s: + error_msg = "At tag ({}, {}) expected {} and got {}.".format(current_tag.time - self.startup_logical_time, current_tag.microstep, self.s, x.value) + self.sys.stderr.write(error_msg) + self.sys.exit(1) + self.s += 1 + =} + + reaction(shutdown) {= + print("**** shutdown reaction invoked.") + print("Approx. time per reaction: {}ns".format(lf.time.physical_elapsed()//(self.s+1))) + =} } federated reactor(period = 10 usec) { - c = new Clock(period = period) - d = new Destination() - c.y -> d.x + c = new Clock(period = period) + d = new Destination() + c.y -> d.x } diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index 4eb881694f..15069f0aea 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -1,50 +1,49 @@ /** - * Test a source-destination scenario where the source falls behind real-time, - * and reaches the timeout much later than the destination. In this test, the - * destination closes the connection early, causing the transmission to fail. - * Warnings will be printed. + * Test a source-destination scenario where the source falls behind real-time, and reaches the + * timeout much later than the destination. In this test, the destination closes the connection + * early, causing the transmission to fail. Warnings will be printed. * - * The test fails if the federation does not exit amenably. This variant has a - * physical connection between source and destination. + * The test fails if the federation does not exit amenably. This variant has a physical connection + * between source and destination. */ target Python { - timeout: 1 msec, - coordination: decentralized + timeout: 1 msec, + coordination: decentralized } reactor Clock(offset = 0, period = 1 sec) { - output y - timer t(offset, period) - state count = 0 + output y + timer t(offset, period) + state count = 0 - reaction(t) -> y {= - self.count += 1 - y.set(self.count) - =} + reaction(t) -> y {= + self.count += 1 + y.set(self.count) + =} - reaction(shutdown) {= print("SUCCESS: the source exited successfully.") =} + reaction(shutdown) {= print("SUCCESS: the source exited successfully.") =} } reactor Destination { - preamble {= import sys =} - input x - state s = 1 + preamble {= import sys =} + input x + state s = 1 - reaction(x) {= - if x.value != self.s: - self.sys.stderr.write("Expected {} and got {}.".format(self.s, x.value)) - self.sys.exit(1) - self.s += 1 - =} + reaction(x) {= + if x.value != self.s: + self.sys.stderr.write("Expected {} and got {}.".format(self.s, x.value)) + self.sys.exit(1) + self.s += 1 + =} - reaction(shutdown) {= - print("**** shutdown reaction invoked.") - print("Approx. time per reaction: {}ns".format(lf.time.physical_elapsed()//(self.s+1))) - =} + reaction(shutdown) {= + print("**** shutdown reaction invoked.") + print("Approx. time per reaction: {}ns".format(lf.time.physical_elapsed()//(self.s+1))) + =} } federated reactor(period = 10 usec) { - c = new Clock(period = period) - d = new Destination() - c.y ~> d.x + c = new Clock(period = period) + d = new Destination() + c.y ~> d.x } diff --git a/test/Python/src/federated/DistributedBank.lf b/test/Python/src/federated/DistributedBank.lf index de9ea298e4..65115acafb 100644 --- a/test/Python/src/federated/DistributedBank.lf +++ b/test/Python/src/federated/DistributedBank.lf @@ -1,26 +1,26 @@ # Check bank of federates. target Python { - timeout: 1 sec, - coordination: centralized + timeout: 1 sec, + coordination: centralized } reactor Node { - preamble {= import sys =} - timer t(0, 100 msec) - state count = 0 + preamble {= import sys =} + timer t(0, 100 msec) + state count = 0 - reaction(t) {= - print("Hello world {}.".format(self.count)) - self.count += 1 - =} + reaction(t) {= + print("Hello world {}.".format(self.count)) + self.count += 1 + =} - reaction(shutdown) {= - if self.count == 0: - self.sys.stderr.write("Timer reactions did not execute.\n") - self.sys.exit(1) - =} + reaction(shutdown) {= + if self.count == 0: + self.sys.stderr.write("Timer reactions did not execute.\n") + self.sys.exit(1) + =} } federated reactor DistributedBank { - n = new[2] Node() + n = new[2] Node() } diff --git a/test/Python/src/federated/DistributedBankToMultiport.lf b/test/Python/src/federated/DistributedBankToMultiport.lf index 493e73a3b1..534e623d19 100644 --- a/test/Python/src/federated/DistributedBankToMultiport.lf +++ b/test/Python/src/federated/DistributedBankToMultiport.lf @@ -1,33 +1,33 @@ # Check multiport to bank connections between federates. target Python { - timeout: 3 sec + timeout: 3 sec } import Count from "../lib/Count.lf" reactor Destination { - preamble {= import sys =} - input[2] in_ - state count = 1 + preamble {= import sys =} + input[2] in_ + state count = 1 - reaction(in_) {= - for i in range(len(in_)): - print("Received {}.".format(in_[i].value)) - if self.count != in_[i].value: - self.sys.stderr.write("Expected {}.\n".format(self.count)) - self.sys.exit(1) - self.count += 1 - =} - - reaction(shutdown) {= - if self.count == 0: - self.sys.stderr.write("No data received.\n") + reaction(in_) {= + for i in range(len(in_)): + print("Received {}.".format(in_[i].value)) + if self.count != in_[i].value: + self.sys.stderr.write("Expected {}.\n".format(self.count)) self.sys.exit(1) - =} + self.count += 1 + =} + + reaction(shutdown) {= + if self.count == 0: + self.sys.stderr.write("No data received.\n") + self.sys.exit(1) + =} } federated reactor { - s = new[2] Count() - d = new Destination() - s.out -> d.in_ + s = new[2] Count() + d = new Destination() + s.out -> d.in_ } diff --git a/test/Python/src/federated/DistributedCount.lf b/test/Python/src/federated/DistributedCount.lf index 7713256520..20c8beedc5 100644 --- a/test/Python/src/federated/DistributedCount.lf +++ b/test/Python/src/federated/DistributedCount.lf @@ -1,43 +1,42 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python { - timeout: 5 sec, - coordination: centralized + timeout: 5 sec, + coordination: centralized } import Count from "../lib/Count.lf" reactor Print { - preamble {= import sys =} - input in_ - state c = 1 + preamble {= import sys =} + input in_ + state c = 1 - reaction(in_) {= - elapsed_time = lf.time.logical_elapsed() - print("At time {}, received {}".format(elapsed_time, in_.value)) - if in_.value != self.c: - print("Expected to receive {}.".format(self.c)) - self.sys.exit(1) - if elapsed_time != MSEC(200) + SEC(1) * (self.c - 1): - print("Expected received time to be {}.".format(MSEC(200) * self.c)) - self.sys.exit(1) - self.c += 1 - =} + reaction(in_) {= + elapsed_time = lf.time.logical_elapsed() + print("At time {}, received {}".format(elapsed_time, in_.value)) + if in_.value != self.c: + print("Expected to receive {}.".format(self.c)) + self.sys.exit(1) + if elapsed_time != MSEC(200) + SEC(1) * (self.c - 1): + print("Expected received time to be {}.".format(MSEC(200) * self.c)) + self.sys.exit(1) + self.c += 1 + =} - reaction(shutdown) {= - if self.c != 6: - print("Expected to receive 5 items.") - self.sys.exit(1) - =} + reaction(shutdown) {= + if self.c != 6: + print("Expected to receive 5 items.") + self.sys.exit(1) + =} } federated reactor DistributedCount(offset = 200 msec) { - c = new Count() - p = new Print() - c.out -> p.in_ after offset + c = new Count() + p = new Print() + c.out -> p.in_ after offset } diff --git a/test/Python/src/federated/DistributedCountDecentralized.lf b/test/Python/src/federated/DistributedCountDecentralized.lf index e86adf9946..6b664335dd 100644 --- a/test/Python/src/federated/DistributedCountDecentralized.lf +++ b/test/Python/src/federated/DistributedCountDecentralized.lf @@ -1,46 +1,44 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ # reason for failing: in_.intended_tag are not supported in python target target Python { - timeout: 5 sec, - coordination: decentralized + timeout: 5 sec, + coordination: decentralized } import Count from "../lib/Count.lf" reactor Print { - preamble {= import sys =} - input in_ - state c = 1 + preamble {= import sys =} + input in_ + state c = 1 - reaction(in_) {= - print(f"At tag ({lf.time.logical_elapsed()}, {lf.tag().microstep}), received {in_.value}. " - f"The original intended tag of the message was ({in_.intended_tag.time-lf.time.start()}, {in_.intended_tag.microstep}).") - if in_.value != self.c: - print("Expected to receive {}.".format(self.c)) - self.sys.exit(1) - if lf.time.logical_elapsed() != MSEC(200) + SEC(1) * (self.c - 1): - print("Expected received time to be {}.".format(MSEC(200) * self.c)) - self.sys.exit(3) - self.c += 1 - =} + reaction(in_) {= + print(f"At tag ({lf.time.logical_elapsed()}, {lf.tag().microstep}), received {in_.value}. " + f"The original intended tag of the message was ({in_.intended_tag.time-lf.time.start()}, {in_.intended_tag.microstep}).") + if in_.value != self.c: + print("Expected to receive {}.".format(self.c)) + self.sys.exit(1) + if lf.time.logical_elapsed() != MSEC(200) + SEC(1) * (self.c - 1): + print("Expected received time to be {}.".format(MSEC(200) * self.c)) + self.sys.exit(3) + self.c += 1 + =} - reaction(shutdown) {= - if self.c != 6: - self.sys.stderr.write("Expected to receive 5 items.\n") - self.sys.exit(2) - print("SUCCESS: Successfully received 5 items.") - =} + reaction(shutdown) {= + if self.c != 6: + self.sys.stderr.write("Expected to receive 5 items.\n") + self.sys.exit(2) + print("SUCCESS: Successfully received 5 items.") + =} } federated reactor DistributedCountDecentralized { - c = new Count() - p = new Print() - # Indicating a 'logical' connection with a large enough delay. - c.out -> p.in_ after 200 msec + c = new Count() + p = new Print() + c.out -> p.in_ after 200 msec # Indicating a 'logical' connection with a large enough delay. } diff --git a/test/Python/src/federated/DistributedCountDecentralizedLate.lf b/test/Python/src/federated/DistributedCountDecentralizedLate.lf index e3a6899e78..b0cedf9a80 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLate.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLate.lf @@ -1,70 +1,65 @@ /** - * Test a form of a distributed deterministic system where a federate that - * receives timestamped messages has a timer in addition to the messages as - * triggers. Therefore, careful coordination of the advancement of time using - * Ptides is needed. + * Test a form of a distributed deterministic system where a federate that receives timestamped + * messages has a timer in addition to the messages as triggers. Therefore, careful coordination of + * the advancement of time using Ptides is needed. * @author Edward A. Lee * @author Soroush Bateni */ target Python { - timeout: 4900 msec, - coordination: decentralized + timeout: 4900 msec, + coordination: decentralized } import Count from "../lib/Count.lf" reactor Print { - preamble {= import sys =} - # STP () - input in_ - # STP(in, 30 msec); - state success = 0 - state success_stp_violation = 0 - # Force a timer to be invoke periodically - timer t(0, 10 usec) - # to ensure logical time will advance in the absence of incoming messages. - state c = 0 + preamble {= import sys =} + input in_ # STP () + state success = 0 # STP(in, 30 msec); + state success_stp_violation = 0 + timer t(0, 10 usec) # Force a timer to be invoke periodically + state c = 0 # to ensure logical time will advance in the absence of incoming messages. - reaction(in_) {= - current_tag = lf.tag() - print("At tag ({}, {}) received {}. Intended tag is ({}, {}).".format( - lf.time.logical_elapsed(), - lf.tag().microstep, - in_.value, - in_.intended_tag.time - lf.time.start(), - in_.intended_tag.microstep - ) - ) - if (lf.tag() == Tag(SEC(1), 0)): - self.success += 1 # Message was on-time - self.c += 1 - =} STP(0) {= - current_tag = lf.tag() - print("At tag ({}, {}), message has violated the STP offset by ({}, {}).".format( - current_tag.time - lf.time.start(), current_tag.microstep, - current_tag.time - in_.intended_tag.time, - current_tag.microstep - in_.intended_tag.microstep - ) + reaction(in_) {= + current_tag = lf.tag() + print("At tag ({}, {}) received {}. Intended tag is ({}, {}).".format( + lf.time.logical_elapsed(), + lf.tag().microstep, + in_.value, + in_.intended_tag.time - lf.time.start(), + in_.intended_tag.microstep ) - self.success_stp_violation += 1 - self.c += 1 - =} + ) + if (lf.tag() == Tag(SEC(1), 0)): + self.success += 1 # Message was on-time + self.c += 1 + =} STP(0) {= + current_tag = lf.tag() + print("At tag ({}, {}), message has violated the STP offset by ({}, {}).".format( + current_tag.time - lf.time.start(), current_tag.microstep, + current_tag.time - in_.intended_tag.time, + current_tag.microstep - in_.intended_tag.microstep + ) + ) + self.success_stp_violation += 1 + self.c += 1 + =} - reaction(t) {= - # Do nothing. - =} + reaction(t) {= + # Do nothing. + =} - reaction(shutdown) {= - if self.success + self.success_stp_violation != 5: - self.sys.stderr.write("Failed to detect STP violations in messages.\n") - self.sys.exit(1) - else: - print("Successfully detected STP violation ({} violations, {} on-time).".format(self.success_stp_violation, self.success)) - =} + reaction(shutdown) {= + if self.success + self.success_stp_violation != 5: + self.sys.stderr.write("Failed to detect STP violations in messages.\n") + self.sys.exit(1) + else: + print("Successfully detected STP violation ({} violations, {} on-time).".format(self.success_stp_violation, self.success)) + =} } federated reactor { - c = new Count() - p = new Print() - c.out -> p.in_ # Indicating a 'logical' connection. + c = new Count() + p = new Print() + c.out -> p.in_ # Indicating a 'logical' connection. } diff --git a/test/Python/src/federated/DistributedCountDecentralizedLateDownstream.lf b/test/Python/src/federated/DistributedCountDecentralizedLateDownstream.lf index c1c641827f..a82d66675b 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLateDownstream.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLateDownstream.lf @@ -1,102 +1,94 @@ /** - * Test a form of a distributed deterministic system where a federate that - * receives timestamped messages has a timer in addition to the messages as - * triggers. Therefore, careful coordination of the advancement of time using - * Ptides is needed. In addition, this test shows that the STP violation is - * passed down the hierarchy until it is handled. + * Test a form of a distributed deterministic system where a federate that receives timestamped + * messages has a timer in addition to the messages as triggers. Therefore, careful coordination of + * the advancement of time using Ptides is needed. In addition, this test shows that the STP + * violation is passed down the hierarchy until it is handled. * - * An STP violation occurs if when a message with intended tag g1 arrives on a - * port p after the receiving federate has progressed far enough that it cannot - * process an event with tag g1 on the port p. This test has a fast timer (10 - * usec period) in the receiving federate so that the receiving federate is - * continually advancing its current tag, and hence an STP violation is more - * likely to occur. Furthermore, this test sets the STP threshold to 0, which - * makes the violation extremely likely to occur. It could still not occur, - * however, if the message arrives between ticks of the 10 usec timer. + * An STP violation occurs if when a message with intended tag g1 arrives on a port p after the + * receiving federate has progressed far enough that it cannot process an event with tag g1 on the + * port p. This test has a fast timer (10 usec period) in the receiving federate so that the + * receiving federate is continually advancing its current tag, and hence an STP violation is more + * likely to occur. Furthermore, this test sets the STP threshold to 0, which makes the violation + * extremely likely to occur. It could still not occur, however, if the message arrives between + * ticks of the 10 usec timer. * * @author Edward A. Lee * @author Soroush Bateni */ target Python { - # 9 msec headroom for the last (probably tardy) message to arrive. - timeout: 1900 msec, - coordination: decentralized + timeout: 1900 msec, # 9 msec headroom for the last (probably tardy) message to arrive. + coordination: decentralized } import Count from "../lib/Count.lf" reactor ImportantActuator { - input inp - # Count messages that arrive without STP violation. - state success = 0 - state success_stp_violation = 0 - # Force a timer to be invoked periodically - timer t(0, 10 usec) - # to ensure logical time will advance in the absence of incoming messages. - state c = 0 + input inp + state success = 0 # Count messages that arrive without STP violation. + state success_stp_violation = 0 + timer t(0, 10 usec) # Force a timer to be invoked periodically + state c = 0 # to ensure logical time will advance in the absence of incoming messages. - reaction(inp) {= - current_tag = lf.tag() - print(f"ImportantActuator: At tag ({lf.tag().time}, {lf.tag().microstep}) received {inp.value}. " - f"Intended tag is ({inp.intended_tag.time - lf.time.start()}, {inp.intended_tag.microstep}).") - if lf.tag() == Tag((SEC(1) * self.c) + + lf.time.start(), 0): - self.success += 1 # Message was on-time - else: - self.sys.stderr.write("Normal reaction was invoked, but current tag doesn't match expected tag.") - self.sys.exit(1) - self.c += 1 - =} STP(0) {= - current_tag = lf.tag() - print(f"ImportantActuator: At tag ({lf.time.logical_elapsed()}, {lf.tag().microstep}), message has violated the STP offset " - f"by ({lf.tag().time - inp.intended_tag.time}, {lf.tag().microstep - inp.intended_tag.microstep}).") - self.success_stp_violation += 1 - self.c += 1 - =} + reaction(inp) {= + current_tag = lf.tag() + print(f"ImportantActuator: At tag ({lf.tag().time}, {lf.tag().microstep}) received {inp.value}. " + f"Intended tag is ({inp.intended_tag.time - lf.time.start()}, {inp.intended_tag.microstep}).") + if lf.tag() == Tag((SEC(1) * self.c) + + lf.time.start(), 0): + self.success += 1 # Message was on-time + else: + self.sys.stderr.write("Normal reaction was invoked, but current tag doesn't match expected tag.") + self.sys.exit(1) + self.c += 1 + =} STP(0) {= + current_tag = lf.tag() + print(f"ImportantActuator: At tag ({lf.time.logical_elapsed()}, {lf.tag().microstep}), message has violated the STP offset " + f"by ({lf.tag().time - inp.intended_tag.time}, {lf.tag().microstep - inp.intended_tag.microstep}).") + self.success_stp_violation += 1 + self.c += 1 + =} - reaction(t) {= - # Do nothing. - =} + reaction(t) {= + # Do nothing. + =} - reaction(shutdown) {= - if (self.success + self.success_stp_violation) != 2: - self.sys.stderr.write("Failed to detect STP violation in messages.") - self.sys.exit(1) - else: - print(f"Successfully detected STP violations ({self.success_stp_violation} violations, {self.success} on-time).") - =} + reaction(shutdown) {= + if (self.success + self.success_stp_violation) != 2: + self.sys.stderr.write("Failed to detect STP violation in messages.") + self.sys.exit(1) + else: + print(f"Successfully detected STP violations ({self.success_stp_violation} violations, {self.success} on-time).") + =} } reactor Print { - input inp + input inp - reaction(inp) {= - current_tag = lf.tag(); - print(f"Print reactor: at tag ({lf.time.logical_elapsed()}, lf.tag().microstep) received {inp.value}. " - f"Intended tag is ({inp.intended_tag.time - lf.time.start()}, {inp.intended_tag.microstep}).") - =} + reaction(inp) {= + current_tag = lf.tag(); + print(f"Print reactor: at tag ({lf.time.logical_elapsed()}, lf.tag().microstep) received {inp.value}. " + f"Intended tag is ({inp.intended_tag.time - lf.time.start()}, {inp.intended_tag.microstep}).") + =} } reactor Receiver { - input inp - # Force a timer to be invoke periodically - timer t(0, 10 msec) - # to ensure logical time will advance in the absence of incoming messages. - state c = 0 - p = new Print() - a = new ImportantActuator() + input inp + timer t(0, 10 msec) # Force a timer to be invoke periodically + state c = 0 # to ensure logical time will advance in the absence of incoming messages. + p = new Print() + a = new ImportantActuator() - reaction(inp) -> p.inp, a.inp {= - p.inp.set(inp.value + 1) - a.inp.set(inp.value + 1) - =} + reaction(inp) -> p.inp, a.inp {= + p.inp.set(inp.value + 1) + a.inp.set(inp.value + 1) + =} - reaction(t) {= - # Do nothing. - =} + reaction(t) {= + # Do nothing. + =} } federated reactor { - c = new Count(period = 1 sec) - r = new Receiver() - c.out -> r.inp # Indicating a 'logical' connection. + c = new Count(period = 1 sec) + r = new Receiver() + c.out -> r.inp # Indicating a 'logical' connection. } diff --git a/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf b/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf index d806ab5453..8d480a0122 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf @@ -1,39 +1,36 @@ /** - * Test a form of a distributed deterministic system where a federate that - * receives timestamped messages has a timer in addition to the messages as - * triggers. Therefore, careful coordination of the advancement of time using - * Ptides is needed. In addition, this test shows that the STP violation of the - * reaction is passed down the hierarchy until it is handled. + * Test a form of a distributed deterministic system where a federate that receives timestamped + * messages has a timer in addition to the messages as triggers. Therefore, careful coordination of + * the advancement of time using Ptides is needed. In addition, this test shows that the STP + * violation of the reaction is passed down the hierarchy until it is handled. * * @author Edward A. Lee * @author Soroush Bateni */ target Python { - timeout: 4900 msec, - coordination: decentralized + timeout: 4900 msec, + coordination: decentralized } import Count from "../lib/Count.lf" import ImportantActuator, Print from "DistributedCountDecentralizedLateDownstream.lf" reactor Receiver { - input inp - # Force a timer to be invoke periodically - timer t(0, 10 msec) - # to ensure logical time will advance in the absence of incoming messages. - state c = 0 - p = new Print() - a = new ImportantActuator() - inp -> p.inp - inp -> a.inp + input inp + timer t(0, 10 msec) # Force a timer to be invoke periodically + state c = 0 # to ensure logical time will advance in the absence of incoming messages. + p = new Print() + a = new ImportantActuator() + inp -> p.inp + inp -> a.inp - reaction(t) {= - # Do nothing. - =} + reaction(t) {= + # Do nothing. + =} } federated reactor { - c = new Count() - r = new Receiver() - c.out -> r.inp # Indicating a 'logical' connection. + c = new Count() + r = new Receiver() + c.out -> r.inp # Indicating a 'logical' connection. } diff --git a/test/Python/src/federated/DistributedCountPhysical.lf b/test/Python/src/federated/DistributedCountPhysical.lf index 69bc2faee9..af59f4da8f 100644 --- a/test/Python/src/federated/DistributedCountPhysical.lf +++ b/test/Python/src/federated/DistributedCountPhysical.lf @@ -1,54 +1,54 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni */ target Python { - timeout: 1 sec + timeout: 1 sec } reactor Count { - timer t(200 msec, 1 sec) - state s = 0 - output out + timer t(200 msec, 1 sec) + state s = 0 + output out - reaction(t) -> out {= - out.set(self.s) - self.s += 1; - =} + reaction(t) -> out {= + out.set(self.s) + self.s += 1; + =} } reactor Print { - preamble {= import sys =} - input in_ - state c = 0 + preamble {= import sys =} + input in_ + state c = 0 - reaction(in_) {= - elapsed_time = lf.time.logical_elapsed() - print("At time {}, received {}.".format(elapsed_time, in_.value)) - if in_.value != self.c: - self.sys.stderr.write("ERROR: Expected to receive {}.\n".format(self.c)) - self.sys.exit(1) - if not (elapsed_time > (SEC(1) * self.c) + MSEC(200)): - self.sys.stderr.write("ERROR: Expected received time to be strictly greater than {}. Got {}.\n".format(MSEC(200) * self.c, elapsed_time)) - self.sys.exit(3) - self.c += 1 - =} + reaction(in_) {= + elapsed_time = lf.time.logical_elapsed() + print("At time {}, received {}.".format(elapsed_time, in_.value)) + if in_.value != self.c: + self.sys.stderr.write("ERROR: Expected to receive {}.\n".format(self.c)) + self.sys.exit(1) + if not (elapsed_time > (SEC(1) * self.c) + MSEC(200)): + self.sys.stderr.write("ERROR: Expected received time to be strictly greater than {}. Got {}.\n".format(MSEC(200) * self.c, elapsed_time)) + self.sys.exit(3) + self.c += 1 + =} - reaction(shutdown) {= - if (self.c != 1): - self.sys.stderr.write("ERROR: Expected to receive 1 item. Received {}.\n".format(self.c)) - self.sys.exit(2) - print("SUCCESS: Successfully received 1 item."); - =} + reaction(shutdown) {= + if (self.c != 1): + self.sys.stderr.write("ERROR: Expected to receive 1 item. Received {}.\n".format(self.c)) + self.sys.exit(2) + print("SUCCESS: Successfully received 1 item."); + =} } federated reactor at localhost { - c = new Count() - p = new Print() - c.out ~> p.in_ # Indicating a 'physical' connection. + c = new Count() + p = new Print() + c.out ~> p.in_ # Indicating a 'physical' connection. } diff --git a/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf b/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf index 105413d0a0..dd753fca44 100644 --- a/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf +++ b/test/Python/src/federated/DistributedCountPhysicalAfterDelay.lf @@ -1,54 +1,54 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni */ target Python { - timeout: 1 sec + timeout: 1 sec } reactor Count { - timer t(200 msec, 1 sec) - state s = 0 - output out + timer t(200 msec, 1 sec) + state s = 0 + output out - reaction(t) -> out {= - out.set(self.s) - self.s += 1; - =} + reaction(t) -> out {= + out.set(self.s) + self.s += 1; + =} } reactor Print { - preamble {= import sys =} - input in_ - state c = 0 + preamble {= import sys =} + input in_ + state c = 0 - reaction(in_) {= - elapsed_time = lf.time.logical_elapsed() - print("At time {}, received {}.".format(elapsed_time, in_.value)) - if in_.value != self.c: - self.sys.stderr.write("ERROR: Expected to receive {}.\n".format(self.c)) - self.sys.exit(1) - if not (elapsed_time > (SEC(1) * self.c) + MSEC(200)): - self.sys.stderr.write("ERROR: Expected received time to be strictly greater than {}. Got {}.\n".format(MSEC(200) * self.c, elapsed_time)) - self.sys.exit(3) - self.c += 1 - =} + reaction(in_) {= + elapsed_time = lf.time.logical_elapsed() + print("At time {}, received {}.".format(elapsed_time, in_.value)) + if in_.value != self.c: + self.sys.stderr.write("ERROR: Expected to receive {}.\n".format(self.c)) + self.sys.exit(1) + if not (elapsed_time > (SEC(1) * self.c) + MSEC(200)): + self.sys.stderr.write("ERROR: Expected received time to be strictly greater than {}. Got {}.\n".format(MSEC(200) * self.c, elapsed_time)) + self.sys.exit(3) + self.c += 1 + =} - reaction(shutdown) {= - if (self.c != 1): - self.sys.stderr.write("ERROR: Expected to receive 1 item. Received {}.\n".format(self.c)) - self.sys.exit(2) - print("SUCCESS: Successfully received 1 item."); - =} + reaction(shutdown) {= + if (self.c != 1): + self.sys.stderr.write("ERROR: Expected to receive 1 item. Received {}.\n".format(self.c)) + self.sys.exit(2) + print("SUCCESS: Successfully received 1 item."); + =} } federated reactor at localhost { - c = new Count() - p = new Print() - c.out ~> p.in_ after 400 msec # Indicating a 'physical' connection. + c = new Count() + p = new Print() + c.out ~> p.in_ after 400 msec # Indicating a 'physical' connection. } diff --git a/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf b/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf index 0008479138..49041a5c7a 100644 --- a/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf +++ b/test/Python/src/federated/DistributedCountPhysicalDecentralized.lf @@ -1,55 +1,55 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages only over connections that are - * marked 'physical' (using the ~> arrow). Therefore, no additional coordination - * of the advancement of time (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages only over connections that are marked 'physical' (using the ~> + * arrow). Therefore, no additional coordination of the advancement of time (HLA or Ptides) is + * needed. * * @author Edward A. Lee * @author Soroush Bateni */ target Python { - timeout: 1 sec, - coordination: decentralized + timeout: 1 sec, + coordination: decentralized } reactor Count { - timer t(200 msec, 1 sec) - state s = 0 - output out + timer t(200 msec, 1 sec) + state s = 0 + output out - reaction(t) -> out {= - out.set(self.s) - self.s += 1 - =} + reaction(t) -> out {= + out.set(self.s) + self.s += 1 + =} } reactor Print { - preamble {= import sys =} - input in_ - state c = 0 + preamble {= import sys =} + input in_ + state c = 0 - reaction(in_) {= - elapsed_time = lf.time.logical_elapsed() - print("At time {}, received {}.".format(elapsed_time, in_.value)) - if in_.value != self.c: - self.sys.stderr.write("ERROR: Expected to receive {}.\n".format(self.c)) - self.sys.exit(1) - if not (elapsed_time > (SEC(1) * self.c) + MSEC(200)): - self.sys.stderr.write("ERROR: Expected received time to be strictly greater than {}.\n".format(MSEC(200) * self.c)) - self.sys.exit(3) - self.c += 1 - =} + reaction(in_) {= + elapsed_time = lf.time.logical_elapsed() + print("At time {}, received {}.".format(elapsed_time, in_.value)) + if in_.value != self.c: + self.sys.stderr.write("ERROR: Expected to receive {}.\n".format(self.c)) + self.sys.exit(1) + if not (elapsed_time > (SEC(1) * self.c) + MSEC(200)): + self.sys.stderr.write("ERROR: Expected received time to be strictly greater than {}.\n".format(MSEC(200) * self.c)) + self.sys.exit(3) + self.c += 1 + =} - reaction(shutdown) {= - if self.c != 1: - self.sys.stderr.write("ERROR: Expected to receive 1 item. Received {}.\n".format(self.c)) - self.sys.exit(2) - print("SUCCESS: Successfully received 1 item.") - =} + reaction(shutdown) {= + if self.c != 1: + self.sys.stderr.write("ERROR: Expected to receive 1 item. Received {}.\n".format(self.c)) + self.sys.exit(2) + print("SUCCESS: Successfully received 1 item.") + =} } federated reactor at localhost { - c = new Count() - p = new Print() - c.out ~> p.in_ # Indicating a 'physical' connection. + c = new Count() + p = new Print() + c.out ~> p.in_ # Indicating a 'physical' connection. } diff --git a/test/Python/src/federated/DistributedDoublePort.lf b/test/Python/src/federated/DistributedDoublePort.lf index 9eb24209e6..3e0d25c4a0 100644 --- a/test/Python/src/federated/DistributedDoublePort.lf +++ b/test/Python/src/federated/DistributedDoublePort.lf @@ -1,54 +1,51 @@ /** - * Test the case for when two upstream federates send messages to a downstream - * federte on two different ports. One message should carry a microstep delay - * relative to the other message. + * Test the case for when two upstream federates send messages to a downstream federte on two + * different ports. One message should carry a microstep delay relative to the other message. * * @author Soroush Bateni */ target Python { - timeout: 900 msec, - logging: DEBUG, - coordination: centralized + timeout: 900 msec, + logging: DEBUG, + coordination: centralized } import Count from "../lib/Count.lf" reactor CountMicrostep { - state count = 1 - output out - logical action act - timer t(0, 1 sec) + state count = 1 + output out + logical action act + timer t(0, 1 sec) - reaction(t) -> act {= - act.schedule(0, self.count) - self.count += 1 - =} + reaction(t) -> act {= + act.schedule(0, self.count) + self.count += 1 + =} - reaction(act) -> out {= out.set(act.value) =} + reaction(act) -> out {= out.set(act.value) =} } reactor Print { - preamble {= import sys =} - input in_ - input in2 - - reaction(in_, in2) {= - current_tag = lf.tag() - print("At tag ({}, {}), received in_ = {} and in2 = {}.".format(current_tag.time, current_tag.microstep, in_.value, in2.value)) - if in_.is_present and in2.is_present: - self.sys.stderr.write("ERROR: invalid logical simultaneity.") - self.sys.exit(1) - =} - - reaction(shutdown) {= - print("SUCCESS: messages were at least one microstep apart.") - =} + preamble {= import sys =} + input in_ + input in2 + + reaction(in_, in2) {= + current_tag = lf.tag() + print("At tag ({}, {}), received in_ = {} and in2 = {}.".format(current_tag.time, current_tag.microstep, in_.value, in2.value)) + if in_.is_present and in2.is_present: + self.sys.stderr.write("ERROR: invalid logical simultaneity.") + self.sys.exit(1) + =} + + reaction(shutdown) {= print("SUCCESS: messages were at least one microstep apart.") =} } federated reactor DistributedDoublePort { - c = new Count() - cm = new CountMicrostep() - p = new Print() - c.out -> p.in_ # Indicating a 'logical' connection. - cm.out -> p.in2 + c = new Count() + cm = new CountMicrostep() + p = new Print() + c.out -> p.in_ # Indicating a 'logical' connection. + cm.out -> p.in2 } diff --git a/test/Python/src/federated/DistributedLoopedAction.lf b/test/Python/src/federated/DistributedLoopedAction.lf index 8f71d15363..c278f04922 100644 --- a/test/Python/src/federated/DistributedLoopedAction.lf +++ b/test/Python/src/federated/DistributedLoopedAction.lf @@ -1,63 +1,61 @@ /** - * Test a sender-receiver network system that relies on microsteps being taken - * into account. + * Test a sender-receiver network system that relies on microsteps being taken into account. * * @author Soroush Bateni */ target Python { - timeout: 1 sec + timeout: 1 sec } import Sender from "../lib/LoopedActionSender.lf" reactor Receiver(take_a_break_after = 10, break_interval = 400 msec) { - preamble {= import sys =} - input in_ - state received_messages = 0 - state total_received_messages = 0 - state breaks = 0 - timer t(0, 1 msec) # This will impact the performance - - # but forces the logical time to advance Comment this line for a more - # sensible log output. - reaction(in_) {= - print("At tag ({}, {}) received value {}.".format( - lf.time.logical_elapsed(), - lf.tag().microstep, - in_.value - ) + preamble {= import sys =} + input in_ + state received_messages = 0 + state total_received_messages = 0 + state breaks = 0 + timer t(0, 1 msec) # This will impact the performance + + # but forces the logical time to advance Comment this line for a more sensible log output. + reaction(in_) {= + print("At tag ({}, {}) received value {}.".format( + lf.time.logical_elapsed(), + lf.tag().microstep, + in_.value ) - self.total_received_messages += 1 - if in_.value != self.received_messages: - self.sys.stderr.write("ERROR: received messages out of order.\n") - # exit(1); - self.received_messages += 1 - if lf.time.logical_elapsed() != self.breaks * self.break_interval: - self.sys.stderr.write("ERROR: received messages at an incorrect time: {}.\n".format(lf.time.logical_elapsed())) - # exit(2); - - if self.received_messages == self.take_a_break_after: - # Sender is taking a break; - self.breaks += 1 - self.received_messages = 0 - =} - - reaction(t) {= - # Do nothing - =} - - reaction(shutdown) {= - print(((SEC(1)/self.break_interval)+1) * self.take_a_break_after) - if self.breaks != 3 or (self.total_received_messages != ((SEC(1)//self.break_interval)+1) * self.take_a_break_after): - self.sys.stderr.write("ERROR: test failed.\n") - exit(4) - print("SUCCESS: Successfully received all messages from the sender.") - =} + ) + self.total_received_messages += 1 + if in_.value != self.received_messages: + self.sys.stderr.write("ERROR: received messages out of order.\n") + # exit(1); + self.received_messages += 1 + if lf.time.logical_elapsed() != self.breaks * self.break_interval: + self.sys.stderr.write("ERROR: received messages at an incorrect time: {}.\n".format(lf.time.logical_elapsed())) + # exit(2); + + if self.received_messages == self.take_a_break_after: + # Sender is taking a break; + self.breaks += 1 + self.received_messages = 0 + =} + + reaction(t) {= + # Do nothing + =} + + reaction(shutdown) {= + print(((SEC(1)/self.break_interval)+1) * self.take_a_break_after) + if self.breaks != 3 or (self.total_received_messages != ((SEC(1)//self.break_interval)+1) * self.take_a_break_after): + self.sys.stderr.write("ERROR: test failed.\n") + exit(4) + print("SUCCESS: Successfully received all messages from the sender.") + =} } federated reactor DistributedLoopedAction { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in_ + sender.out -> receiver.in_ } diff --git a/test/Python/src/federated/DistributedLoopedPhysicalAction.lf b/test/Python/src/federated/DistributedLoopedPhysicalAction.lf index d992e3d841..fa72e4c264 100644 --- a/test/Python/src/federated/DistributedLoopedPhysicalAction.lf +++ b/test/Python/src/federated/DistributedLoopedPhysicalAction.lf @@ -1,84 +1,83 @@ /** - * Test a sender-receiver network system that is similar to - * DistributedLoopedAction, but it uses a physical action rather than a logical - * action. This also demonstrates the advance-message-interval coordination - * option. This specifies the time period between Time Advance Notice (TAN) - * messages sent to the RTI (a form of null message that must be sent because of - * the physical action). The presence of this option also silences a warning - * about having a physical action that triggers an output. + * Test a sender-receiver network system that is similar to DistributedLoopedAction, but it uses a + * physical action rather than a logical action. This also demonstrates the advance-message-interval + * coordination option. This specifies the time period between Time Advance Notice (TAN) messages + * sent to the RTI (a form of null message that must be sent because of the physical action). The + * presence of this option also silences a warning about having a physical action that triggers an + * output. * * @author Soroush Bateni */ target Python { - timeout: 1 sec, - keepalive: true + timeout: 1 sec, + keepalive: true } reactor Sender(take_a_break_after = 10, break_interval = 550 msec) { - output out - physical action act - state sent_messages = 0 + output out + physical action act + state sent_messages = 0 - reaction(startup, act) -> act, out {= - # Send a message on out - out.set(self.sent_messages) - self.sent_messages += 1 - if self.sent_messages < self.take_a_break_after: - act.schedule(0) - else: - # Take a break - self.sent_messages = 0 - act.schedule(self.break_interval) - =} + reaction(startup, act) -> act, out {= + # Send a message on out + out.set(self.sent_messages) + self.sent_messages += 1 + if self.sent_messages < self.take_a_break_after: + act.schedule(0) + else: + # Take a break + self.sent_messages = 0 + act.schedule(self.break_interval) + =} } reactor Receiver(take_a_break_after = 10, break_interval = 550 msec) { - preamble {= import sys =} - input in_ - state received_messages = 0 - state total_received_messages = 0 - state breaks = 0 - timer t(0, 1 msec) # This will impact the performance - # but forces the logical time to advance Comment this line for a more - # sensible log output. - state base_logical_time + preamble {= import sys =} + input in_ + state received_messages = 0 + state total_received_messages = 0 + state breaks = 0 + # This will impact the performance + timer t(0, 1 msec) + # but forces the logical time to advance Comment this line for a more sensible log output. + state base_logical_time - reaction(startup) {= self.base_logical_time = lf.time.logical() =} + reaction(startup) {= self.base_logical_time = lf.time.logical() =} - reaction(in_) {= - current_tag = lf.tag() - print("At tag ({}, {}) received {}".format( - current_tag.time - self.base_logical_time, - current_tag.microstep, - in_.value) - ) - self.total_received_messages += 1 - if in_.value != self.received_messages: - self.sys.stderr.write("Expected {}.".format(self.received_messages - 1)) - self.sys.exit(1) - self.received_messages += 1 + reaction(in_) {= + current_tag = lf.tag() + print("At tag ({}, {}) received {}".format( + current_tag.time - self.base_logical_time, + current_tag.microstep, + in_.value) + ) + self.total_received_messages += 1 + if in_.value != self.received_messages: + self.sys.stderr.write("Expected {}.".format(self.received_messages - 1)) + self.sys.exit(1) + self.received_messages += 1 - if self.received_messages == self.take_a_break_after: - # Sender is taking a break; - self.breaks += 1 - self.received_messages = 0 - =} + if self.received_messages == self.take_a_break_after: + # Sender is taking a break; + self.breaks += 1 + self.received_messages = 0 + =} - reaction(t) {= - # Do nothing - =} + reaction(t) {= + # Do nothing + =} - reaction(shutdown) {= - if self.breaks != 2 or (self.total_received_messages != ((SEC(1)//self.break_interval)+1) * self.take_a_break_after): - self.sys.stderr.write("Test failed. Breaks: {}, Messages: {}.".format(self.breaks, self.total_received_messages)) - self.sys.exit(1) - print("SUCCESS: Successfully received all messages from the sender.") - =} + reaction(shutdown) {= + if self.breaks != 2 or (self.total_received_messages != ((SEC(1)//self.break_interval)+1) * self.take_a_break_after): + self.sys.stderr.write("Test failed. Breaks: {}, Messages: {}.".format(self.breaks, self.total_received_messages)) + self.sys.exit(1) + print("SUCCESS: Successfully received all messages from the sender.") + =} } federated reactor DistributedLoopedPhysicalAction { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in_ + sender.out -> receiver.in_ } diff --git a/test/Python/src/federated/DistributedMultiport.lf b/test/Python/src/federated/DistributedMultiport.lf index 7250f838ef..bd1f24820d 100644 --- a/test/Python/src/federated/DistributedMultiport.lf +++ b/test/Python/src/federated/DistributedMultiport.lf @@ -1,45 +1,45 @@ # Check multiport connections between federates. target Python { - timeout: 1 sec, - coordination: centralized + timeout: 1 sec, + coordination: centralized } reactor Source { - output[4] out - timer t(0, 100 msec) - state count = 0 + output[4] out + timer t(0, 100 msec) + state count = 0 - reaction(t) -> out {= - for i in range(len(out)): - out[i].set(self.count) - self.count += 1 - =} + reaction(t) -> out {= + for i in range(len(out)): + out[i].set(self.count) + self.count += 1 + =} } reactor Destination { - preamble {= import sys =} - input[4] in_ - state count = 0 + preamble {= import sys =} + input[4] in_ + state count = 0 - reaction(in_) {= - for i in range(len(in_)): - if in_[i].is_present: - print("Received {}.".format(in_[i].value)) - if in_[i].value != self.count: - self.sys.stderr.write("Expected {}.\n".format(self.count)) - self.sys.exit(1) - self.count += 1 - =} + reaction(in_) {= + for i in range(len(in_)): + if in_[i].is_present: + print("Received {}.".format(in_[i].value)) + if in_[i].value != self.count: + self.sys.stderr.write("Expected {}.\n".format(self.count)) + self.sys.exit(1) + self.count += 1 + =} - reaction(shutdown) {= - if self.count == 0: - self.sys.stderr.write("No data received.") - self.sys.exit(1) - =} + reaction(shutdown) {= + if self.count == 0: + self.sys.stderr.write("No data received.") + self.sys.exit(1) + =} } federated reactor DistributedMultiport { - s = new Source() - d = new Destination() - s.out -> d.in_ + s = new Source() + d = new Destination() + s.out -> d.in_ } diff --git a/test/Python/src/federated/DistributedMultiportToBank.lf b/test/Python/src/federated/DistributedMultiportToBank.lf index 69c87b7f0c..b9b65686ef 100644 --- a/test/Python/src/federated/DistributedMultiportToBank.lf +++ b/test/Python/src/federated/DistributedMultiportToBank.lf @@ -1,42 +1,42 @@ # Check multiport to bank connections between federates. target Python { - timeout: 1 sec + timeout: 1 sec } reactor Source { - output[2] out - timer t(0, 100 msec) - state count = 0 + output[2] out + timer t(0, 100 msec) + state count = 0 - reaction(t) -> out {= - for i in range(len(out)): - out[i].set(self.count) - self.count += 1 - =} + reaction(t) -> out {= + for i in range(len(out)): + out[i].set(self.count) + self.count += 1 + =} } reactor Destination { - preamble {= import sys =} - input in_ - state count = 0 + preamble {= import sys =} + input in_ + state count = 0 - reaction(in_) {= - print("Received {}.".format(in_.value)) - if self.count != in_.value: - self.sys.stderr.write("Expected {}.\n".format(self.count)) - self.sys.exit(1) - self.count += 1 - =} + reaction(in_) {= + print("Received {}.".format(in_.value)) + if self.count != in_.value: + self.sys.stderr.write("Expected {}.\n".format(self.count)) + self.sys.exit(1) + self.count += 1 + =} - reaction(shutdown) {= - if self.count == 0: - self.sys.stderr.write("No data received.") - self.sys.exit(1) - =} + reaction(shutdown) {= + if self.count == 0: + self.sys.stderr.write("No data received.") + self.sys.exit(1) + =} } federated reactor DistributedMultiportToBank { - s = new Source() - d = new[2] Destination() - s.out -> d.in_ + s = new Source() + d = new[2] Destination() + s.out -> d.in_ } diff --git a/test/Python/src/federated/DistributedMultiportToken.lf b/test/Python/src/federated/DistributedMultiportToken.lf index 284e1c21a3..bd380f22fe 100644 --- a/test/Python/src/federated/DistributedMultiportToken.lf +++ b/test/Python/src/federated/DistributedMultiportToken.lf @@ -1,39 +1,39 @@ -# Check multiport connections between federates where the message is carried by -# a Token (in this case, with an array of char). +# Check multiport connections between federates where the message is carried by a Token (in this +# case, with an array of char). target Python { - timeout: 1 sec, - coordination: centralized + timeout: 1 sec, + coordination: centralized } reactor Source { - output[4] out - timer t(0, 200 msec) - state count = 0 + output[4] out + timer t(0, 200 msec) + state count = 0 - reaction(t) -> out {= - for i in range(len(out)): - self.count += 1 - out[i].set("Hello {}".format(self.count)) - print("MessageGenerator: At time {}, send message: {}.".format( - lf.time.logical_elapsed(), - out[i].value - ) + reaction(t) -> out {= + for i in range(len(out)): + self.count += 1 + out[i].set("Hello {}".format(self.count)) + print("MessageGenerator: At time {}, send message: {}.".format( + lf.time.logical_elapsed(), + out[i].value ) - =} + ) + =} } reactor Destination { - input[4] in_ + input[4] in_ - reaction(in_) {= - for i in range(len(in_)): - if in_[i].is_present: - print("Received {}.".format(in_[i].value)) - =} + reaction(in_) {= + for i in range(len(in_)): + if in_[i].is_present: + print("Received {}.".format(in_[i].value)) + =} } federated reactor DistributedMultiportToken { - s = new Source() - d = new Destination() - s.out -> d.in_ + s = new Source() + d = new Destination() + s.out -> d.in_ } diff --git a/test/Python/src/federated/DistributedSendClass.lf b/test/Python/src/federated/DistributedSendClass.lf index fd056bb0c0..f607d156e3 100644 --- a/test/Python/src/federated/DistributedSendClass.lf +++ b/test/Python/src/federated/DistributedSendClass.lf @@ -1,25 +1,25 @@ target Python preamble {= - class C: - def __init__(self): - pass + class C: + def __init__(self): + pass =} reactor A { - input o + input o - reaction(o) {= lf_request_stop() =} + reaction(o) {= lf_request_stop() =} } reactor B { - output o + output o - reaction(startup) -> o {= o.set(C()) =} + reaction(startup) -> o {= o.set(C()) =} } federated reactor { - a = new A() - b = new B() - b.o -> a.o + a = new A() + b = new B() + b.o -> a.o } diff --git a/test/Python/src/federated/DistributedStop.lf b/test/Python/src/federated/DistributedStop.lf index 06dfe96c36..76bbe16d46 100644 --- a/test/Python/src/federated/DistributedStop.lf +++ b/test/Python/src/federated/DistributedStop.lf @@ -1,6 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with centralized - * coordination. + * Test for lf_request_stop() in federated execution with centralized coordination. * * @author Soroush Bateni */ @@ -9,107 +8,107 @@ target Python preamble {= import sys =} reactor Sender { - output out - timer t(0, 1 usec) - logical action act - state reaction_invoked_correctly = False + output out + timer t(0, 1 usec) + logical action act + state reaction_invoked_correctly = False - reaction(t, act) -> out, act {= - tag = lf.tag() - print("Sending 42 at ({}, {}).".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - out.set(42) - if lf.tag().microstep == 0: - # Instead of having a separate reaction - # for 'act' like Stop.lf, we trigger the - # same reaction to test lf_request_stop() being - # called multiple times - act.schedule(0) - if tag.time == USEC(1): - # Call lf_request_stop() both at (1 usec, 0) and - # (1 usec, 1) - print("Requesting stop at ({}, {}).".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - lf_request_stop() + reaction(t, act) -> out, act {= + tag = lf.tag() + print("Sending 42 at ({}, {}).".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + out.set(42) + if lf.tag().microstep == 0: + # Instead of having a separate reaction + # for 'act' like Stop.lf, we trigger the + # same reaction to test lf_request_stop() being + # called multiple times + act.schedule(0) + if tag.time == USEC(1): + # Call lf_request_stop() both at (1 usec, 0) and + # (1 usec, 1) + print("Requesting stop at ({}, {}).".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + lf_request_stop() - _1usec1 = Tag(time=USEC(1) + get_start_time(), microstep=1) - if lf.tag_compare(lf.tag(), _1usec1) == 0: - # The reaction was invoked at (1 usec, 1) as expected - self.reaction_invoked_correctly = True - elif lf.tag_compare(lf.tag(), _1usec1) > 0: - # The reaction should not have been invoked at tags larger than (1 usec, 1) - sys.stderr.write("ERROR: Invoked reaction(t, act) at tag bigger than shutdown.\n") - sys.exit(1) - =} + _1usec1 = Tag(time=USEC(1) + get_start_time(), microstep=1) + if lf.tag_compare(lf.tag(), _1usec1) == 0: + # The reaction was invoked at (1 usec, 1) as expected + self.reaction_invoked_correctly = True + elif lf.tag_compare(lf.tag(), _1usec1) > 0: + # The reaction should not have been invoked at tags larger than (1 usec, 1) + sys.stderr.write("ERROR: Invoked reaction(t, act) at tag bigger than shutdown.\n") + sys.exit(1) + =} - reaction(shutdown) {= - if lf.time.logical_elapsed() != USEC(1) or lf.tag().microstep != 1: - sys.stderr.write("ERROR: Sender failed to stop the federation in time. Stopping at ({}, {}).\n".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - sys.exit(1) - elif not self.reaction_invoked_correctly: - sys.stderr.write("ERROR: Sender reaction(t, act) was not invoked at (1 usec, 1). Stopping at ({}, {}).\n".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - sys.exit(1) - print("SUCCESS: Successfully stopped the federation at ({}, {}).".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - =} + reaction(shutdown) {= + if lf.time.logical_elapsed() != USEC(1) or lf.tag().microstep != 1: + sys.stderr.write("ERROR: Sender failed to stop the federation in time. Stopping at ({}, {}).\n".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + sys.exit(1) + elif not self.reaction_invoked_correctly: + sys.stderr.write("ERROR: Sender reaction(t, act) was not invoked at (1 usec, 1). Stopping at ({}, {}).\n".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + sys.exit(1) + print("SUCCESS: Successfully stopped the federation at ({}, {}).".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + =} } reactor Receiver( - stp_offset = 10 msec # Used in the decentralized variant of the test + stp_offset = 10 msec # Used in the decentralized variant of the test ) { - input in_ - state reaction_invoked_correctly = False + input in_ + state reaction_invoked_correctly = False - reaction(in_) {= - tag = lf.tag() - print("Received {} at ({}, {}).".format( - in_.value, - lf.time.logical_elapsed(), - lf.tag().microstep)) - if lf.time.logical_elapsed() == USEC(1): - print("Requesting stop at ({}, {}).".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - lf_request_stop() - # The receiver should receive a message at tag - # (1 usec, 1) and trigger this reaction - self.reaction_invoked_correctly = True + reaction(in_) {= + tag = lf.tag() + print("Received {} at ({}, {}).".format( + in_.value, + lf.time.logical_elapsed(), + lf.tag().microstep)) + if lf.time.logical_elapsed() == USEC(1): + print("Requesting stop at ({}, {}).".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + lf_request_stop() + # The receiver should receive a message at tag + # (1 usec, 1) and trigger this reaction + self.reaction_invoked_correctly = True - _1usec1 = Tag(time=USEC(1) + get_start_time(), microstep=1) - if lf.tag_compare(lf.tag(), _1usec1) > 0: - self.reaction_invoked_correctly = False - =} + _1usec1 = Tag(time=USEC(1) + get_start_time(), microstep=1) + if lf.tag_compare(lf.tag(), _1usec1) > 0: + self.reaction_invoked_correctly = False + =} - reaction(shutdown) {= - # Sender should have requested stop earlier than the receiver. - # Therefore, the shutdown events must occur at (1000, 0) on the - # receiver. - if lf.time.logical_elapsed() != USEC(1) or lf.tag().microstep != 1: - sys.stderr.write("Error: Receiver failed to stop the federation at the right time. Stopping at ({}, {}).\n".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - sys.exit(1) - elif not self.reaction_invoked_correctly: - sys.stderr.write("Error: Receiver reaction(in) was not invoked the correct number of times. Stopping at ({}, {}).\n".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - sys.exit(1) - print("SUCCESS: Successfully stopped the federation at ({}, {}).".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - =} + reaction(shutdown) {= + # Sender should have requested stop earlier than the receiver. + # Therefore, the shutdown events must occur at (1000, 0) on the + # receiver. + if lf.time.logical_elapsed() != USEC(1) or lf.tag().microstep != 1: + sys.stderr.write("Error: Receiver failed to stop the federation at the right time. Stopping at ({}, {}).\n".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + sys.exit(1) + elif not self.reaction_invoked_correctly: + sys.stderr.write("Error: Receiver reaction(in) was not invoked the correct number of times. Stopping at ({}, {}).\n".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + sys.exit(1) + print("SUCCESS: Successfully stopped the federation at ({}, {}).".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + =} } federated reactor DistributedStop { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in_ + sender.out -> receiver.in_ } diff --git a/test/Python/src/federated/DistributedStopDecentralized.lf b/test/Python/src/federated/DistributedStopDecentralized.lf index d76154f487..42d3182985 100644 --- a/test/Python/src/federated/DistributedStopDecentralized.lf +++ b/test/Python/src/federated/DistributedStopDecentralized.lf @@ -1,11 +1,9 @@ /** - * Test for lf_request_stop() in federated execution with decentralized - * coordination. + * Test for lf_request_stop() in federated execution with decentralized coordination. * * @author Soroush Bateni */ -# reason for failing: lf_tag().microstep and lf.tag_compare() are not not -# supported in python target +# reason for failing: lf_tag().microstep and lf.tag_compare() are not not supported in python target target Python { coordination: decentralized } diff --git a/test/Python/src/federated/DistributedStopZero.lf b/test/Python/src/federated/DistributedStopZero.lf index 089a839105..2f1c348e4d 100644 --- a/test/Python/src/federated/DistributedStopZero.lf +++ b/test/Python/src/federated/DistributedStopZero.lf @@ -1,90 +1,88 @@ /** - * Test for lf_request_stop() in federated execution with centralized - * coordination at tag (0,0). + * Test for lf_request_stop() in federated execution with centralized coordination at tag (0,0). * * @author Soroush Bateni */ -# reason for failing: lf_tag().microstep and lf.tag_compare() are not not -# supported in python target +# reason for failing: lf_tag().microstep and lf.tag_compare() are not not supported in python target target Python preamble {= import sys =} reactor Sender { - output out - timer t(0, 1 usec) - state startup_logical_time + output out + timer t(0, 1 usec) + state startup_logical_time - reaction(startup) {= self.startup_logical_time = lf.time.logical() =} + reaction(startup) {= self.startup_logical_time = lf.time.logical() =} - reaction(t) -> out {= - tag = lf.tag() - print("Sending 42 at ({}, {}).".format( - tag.time, - tag.microstep)) - out.set(42) - zero = Tag(time=self.startup_logical_time, microstep=0) - if lf.tag_compare(lf.tag(), zero) == 0: - # Request stop at (0,0) - print("Requesting stop at ({}, {}).".format( - lf.time.logical_elapsed(), - lf.tag().microstep)) - lf_request_stop() - =} + reaction(t) -> out {= + tag = lf.tag() + print("Sending 42 at ({}, {}).".format( + tag.time, + tag.microstep)) + out.set(42) + zero = Tag(time=self.startup_logical_time, microstep=0) + if lf.tag_compare(lf.tag(), zero) == 0: + # Request stop at (0,0) + print("Requesting stop at ({}, {}).".format( + lf.time.logical_elapsed(), + lf.tag().microstep)) + lf_request_stop() + =} - reaction(shutdown) {= - tag = lf.tag() - if tag.time != USEC(0) or tag.microstep != 1: - sys.stderr.write("ERROR: Sender failed to stop the federation in time. Stopping at ({}, {}).\n".format( - tag.time, - tag.microstep)) - sys.exit(1) - print("SUCCESS: Successfully stopped the federation at ({}, {}).".format( - tag.time, - tag.microstep)) - =} + reaction(shutdown) {= + tag = lf.tag() + if tag.time != USEC(0) or tag.microstep != 1: + sys.stderr.write("ERROR: Sender failed to stop the federation in time. Stopping at ({}, {}).\n".format( + tag.time, + tag.microstep)) + sys.exit(1) + print("SUCCESS: Successfully stopped the federation at ({}, {}).".format( + tag.time, + tag.microstep)) + =} } reactor Receiver { - input in_ - state startup_logical_time + input in_ + state startup_logical_time - reaction(startup) {= self.startup_logical_time = lf.time.logical() =} + reaction(startup) {= self.startup_logical_time = lf.time.logical() =} - reaction(in_) {= - tag = lf.tag() - print("Received {} at ({}, {}).\n".format( - in_.value, - tag.time, - tag.microstep)) - zero = Tag(time=self.startup_logical_time, microstep=0) - if lf.tag_compare(lf.tag(), zero) == 0: - # Request stop at (0,0) - print("Requesting stop at ({}, {}).".format( - tag.time, - tag.microstep)) - lf_request_stop() - =} + reaction(in_) {= + tag = lf.tag() + print("Received {} at ({}, {}).\n".format( + in_.value, + tag.time, + tag.microstep)) + zero = Tag(time=self.startup_logical_time, microstep=0) + if lf.tag_compare(lf.tag(), zero) == 0: + # Request stop at (0,0) + print("Requesting stop at ({}, {}).".format( + tag.time, + tag.microstep)) + lf_request_stop() + =} - reaction(shutdown) {= - # Sender should have requested stop earlier than the receiver. - # Therefore, the shutdown events must occur at (1000, 0) on the - # receiver. - tag = lf.tag() - if tag.time != USEC(0) or tag.microstep != 1: - sys.stderr.write("ERROR: Receiver failed to stop the federation in time. Stopping at ({}, {}).\n".format( - tag.time, - tag.microstep)) - sys.exit(1) - print("SUCCESS: Successfully stopped the federation at ({}, {}).\n".format( - tag.time, - tag.microstep)) - =} + reaction(shutdown) {= + # Sender should have requested stop earlier than the receiver. + # Therefore, the shutdown events must occur at (1000, 0) on the + # receiver. + tag = lf.tag() + if tag.time != USEC(0) or tag.microstep != 1: + sys.stderr.write("ERROR: Receiver failed to stop the federation in time. Stopping at ({}, {}).\n".format( + tag.time, + tag.microstep)) + sys.exit(1) + print("SUCCESS: Successfully stopped the federation at ({}, {}).\n".format( + tag.time, + tag.microstep)) + =} } federated reactor { - sender = new Sender() - receiver = new Receiver() + sender = new Sender() + receiver = new Receiver() - sender.out -> receiver.in_ + sender.out -> receiver.in_ } diff --git a/test/Python/src/federated/HelloDistributed.lf b/test/Python/src/federated/HelloDistributed.lf index ef99c3f793..fdcdc0e91c 100644 --- a/test/Python/src/federated/HelloDistributed.lf +++ b/test/Python/src/federated/HelloDistributed.lf @@ -1,49 +1,47 @@ /** - * Test a particularly simple form of a distributed deterministic system where a - * federation that receives timestamped messages has only those messages as - * triggers. Therefore, no additional coordination of the advancement of time - * (HLA or Ptides) is needed. + * Test a particularly simple form of a distributed deterministic system where a federation that + * receives timestamped messages has only those messages as triggers. Therefore, no additional + * coordination of the advancement of time (HLA or Ptides) is needed. * @author Edward A. Lee */ target Python reactor Source { - output out + output out - reaction(startup) -> out {= - print("Sending 'Hello World!' message from source federate."); - out.set("Hello World!") - lf_request_stop() - =} + reaction(startup) -> out {= + print("Sending 'Hello World!' message from source federate."); + out.set("Hello World!") + lf_request_stop() + =} } reactor Destination { - input _in - state received = False + input _in + state received = False - reaction(startup) {= print("Destination started.") =} + reaction(startup) {= print("Destination started.") =} - reaction(_in) {= - print(f"At logical time {lf.time.logical_elapsed()}, destination received {_in.value}") - if _in.value != "Hello World!": - sys.stderr.write("ERROR: Expected to receive 'Hello World!'\n"); - exit(1) - self.received = True - =} + reaction(_in) {= + print(f"At logical time {lf.time.logical_elapsed()}, destination received {_in.value}") + if _in.value != "Hello World!": + sys.stderr.write("ERROR: Expected to receive 'Hello World!'\n"); + exit(1) + self.received = True + =} - reaction(shutdown) {= - print("Shutdown invoked.") - if self.received is not True: - sys.stderr.write("ERROR: Destination did not receive the message.") - exit(1) - =} + reaction(shutdown) {= + print("Shutdown invoked.") + if self.received is not True: + sys.stderr.write("ERROR: Destination did not receive the message.") + exit(1) + =} } federated reactor HelloDistributed at localhost { - # reaction(startup) {= print("Printing something in top-level federated - # reactor.") - # =} Reactor s is in federate Source - s = new Source() - d = new Destination() # Reactor d is in federate Destination - s.out -> d._in # This version preserves the timestamp. + # reaction(startup) {= print("Printing something in top-level federated reactor.") + # =} Reactor s is in federate Source + s = new Source() + d = new Destination() # Reactor d is in federate Destination + s.out -> d._in # This version preserves the timestamp. } diff --git a/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf b/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf index 2719fd57ba..732311e6d2 100644 --- a/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf +++ b/test/Python/src/federated/LoopDistributedCentralizedPrecedenceHierarchy.lf @@ -1,67 +1,66 @@ /** - * This tests that the precedence order of reaction invocation is kept in the - * hierarchy of reactors when a feedback loop is present in centralized - * coordination. + * This tests that the precedence order of reaction invocation is kept in the hierarchy of reactors + * when a feedback loop is present in centralized coordination. * * @author Edward A. Lee * @author Soroush Bateni */ target Python { - coordination: centralized, - coordination-options: { - advance-message-interval: 100 msec - }, - timeout: 5 sec + coordination: centralized, + coordination-options: { + advance-message-interval: 100 msec + }, + timeout: 5 sec } reactor Contained(incr = 1) { - timer t(0, 1 sec) - input inp - state count = 0 - state received_count = 0 + timer t(0, 1 sec) + input inp + state count = 0 + state received_count = 0 - reaction(t) {= self.count += self.incr =} + reaction(t) {= self.count += self.incr =} - reaction(inp) {= self.received_count = self.count =} + reaction(inp) {= self.received_count = self.count =} - reaction(t) {= - if self.received_count != self.count: - self.sys.stderr.write("reaction(t) was invoked before reaction(in). Precedence order was not kept.") - self.sys.exit(1) - =} + reaction(t) {= + if self.received_count != self.count: + self.sys.stderr.write("reaction(t) was invoked before reaction(in). Precedence order was not kept.") + self.sys.exit(1) + =} } reactor Looper(incr = 1, delay = 0 msec) { - input inp - output out - state count = 0 - timer t(0, 1 sec) + input inp + output out + state count = 0 + timer t(0, 1 sec) - c = new Contained(incr = incr) - inp -> c.inp + c = new Contained(incr = incr) + inp -> c.inp - reaction(t) -> out {= - print(f"Sending network output {self.count}") - out.set(self.count) - self.count += self.incr - =} + reaction(t) -> out {= + print(f"Sending network output {self.count}") + out.set(self.count) + self.count += self.incr + =} - reaction(inp) {= - time_lag = lf.time.physical() - lf.time.logical() - print(f"Received {inp.value}. Logical time is behind physical time by {time_lag:,} nsec.") - =} + reaction(inp) {= + time_lag = lf.time.physical() - lf.time.logical() + print(f"Received {inp.value}. Logical time is behind physical time by {time_lag:,} nsec.") + =} - reaction(shutdown) {= - print("******* Shutdown invoked.") - if self.count != 6 * self.incr: - self.sys.stderr.write("Failed to receive all six expected inputs.") - self.sys.exit(1) - =} + reaction(shutdown) {= + print("******* Shutdown invoked.") + if self.count != 6 * self.incr: + self.sys.stderr.write("Failed to receive all six expected inputs.") + self.sys.exit(1) + =} } federated reactor(delay = 0) { - left = new Looper() - right = new Looper(incr = -1) - left.out -> right.inp - right.out -> left.inp + left = new Looper() + right = new Looper(incr = -1) + left.out -> right.inp + right.out -> left.inp } diff --git a/test/Python/src/federated/PhysicalSTP.lf b/test/Python/src/federated/PhysicalSTP.lf index 5edc61df34..a51319c6b3 100644 --- a/test/Python/src/federated/PhysicalSTP.lf +++ b/test/Python/src/federated/PhysicalSTP.lf @@ -1,50 +1,47 @@ -/** - * This is a test that detects STP violations according to the physical time of - * message arrival. - */ +/** This is a test that detects STP violations according to the physical time of message arrival. */ target Python { - timeout: 1900 msec, - coordination: decentralized + timeout: 1900 msec, + coordination: decentralized } import Count from "../lib/Count.lf" reactor Print(STP_offset = 0) { - preamble {= import sys =} - input in_ - state c = 1 + preamble {= import sys =} + input in_ + state c = 1 - reaction(in_) {= - elapsed_time = lf.time.logical_elapsed() - print("At time {}, received {}".format(elapsed_time, in_.value)) - print(f"Physical time of arrival: {in_.physical_time_of_arrival}") - if in_.value != self.c: - self.sys.stderr.write("Expected to receive {}.\n".format(self.c)) - self.sys.exit(1) - STP_discrepency = lf.time.logical() + self.STP_offset - in_.physical_time_of_arrival - if STP_discrepency < 0: - print("The message has violated the STP offset by {} in physical time.".format(-1 * STP_discrepency)) - self.c += 1 - else: - self.sys.stderr.write("Message arrived {} early.\n".format(STP_discrepency)) - self.sys.exit(1) - =} STP(STP_offset) {= - # This STP handler should never be invoked because the only source of event - # for Print is the Count reactor. - self.sys.stderr.write("Logical STP violation was detected. Only physical STP violations are possible.\n") + reaction(in_) {= + elapsed_time = lf.time.logical_elapsed() + print("At time {}, received {}".format(elapsed_time, in_.value)) + print(f"Physical time of arrival: {in_.physical_time_of_arrival}") + if in_.value != self.c: + self.sys.stderr.write("Expected to receive {}.\n".format(self.c)) self.sys.exit(1) - =} + STP_discrepency = lf.time.logical() + self.STP_offset - in_.physical_time_of_arrival + if STP_discrepency < 0: + print("The message has violated the STP offset by {} in physical time.".format(-1 * STP_discrepency)) + self.c += 1 + else: + self.sys.stderr.write("Message arrived {} early.\n".format(STP_discrepency)) + self.sys.exit(1) + =} STP(STP_offset) {= + # This STP handler should never be invoked because the only source of event + # for Print is the Count reactor. + self.sys.stderr.write("Logical STP violation was detected. Only physical STP violations are possible.\n") + self.sys.exit(1) + =} - reaction(shutdown) {= - if self.c != 3: - self.sys.stderr.write("Expected to receive 2 items but got {}.\n".format(self.c)) - self.sys.exit(1) - =} + reaction(shutdown) {= + if self.c != 3: + self.sys.stderr.write("Expected to receive 2 items but got {}.\n".format(self.c)) + self.sys.exit(1) + =} } federated reactor { - c = new Count(offset = 1 msec, period = 1 sec) - p = new Print(STP_offset = 1 usec) + c = new Count(offset = 1 msec, period = 1 sec) + p = new Print(STP_offset = 1 usec) - c.out -> p.in_ + c.out -> p.in_ } diff --git a/test/Python/src/federated/PingPongDistributed.lf b/test/Python/src/federated/PingPongDistributed.lf index 0f58cbf7db..41a76a9a7e 100644 --- a/test/Python/src/federated/PingPongDistributed.lf +++ b/test/Python/src/federated/PingPongDistributed.lf @@ -1,72 +1,70 @@ /** - * Basic benchmark from the Savina benchmark suite that is intended to measure - * message-passing overhead. This is based on - * https://www.scala-lang.org/old/node/54 See + * Basic benchmark from the Savina benchmark suite that is intended to measure message-passing + * overhead. This is based on https://www.scala-lang.org/old/node/54 See * https://shamsimam.github.io/papers/2014-agere-savina.pdf. * - * This is a distributed version, where Ping and Pong run in separate programs - * and can be run on different machines. + * This is a distributed version, where Ping and Pong run in separate programs and can be run on + * different machines. * * To get a sense, some (informal) results for 1,000,000 ping-pongs on my Mac: * * Unthreaded: 97 msec Threaded: 265 msec Distributed: 53 seconds * - * There is no parallelism in this application, so it does not benefit from - * being being distributed. + * There is no parallelism in this application, so it does not benefit from being being distributed. * - * These measurements are total execution time, including startup and shutdown, - * of all three programs. + * These measurements are total execution time, including startup and shutdown, of all three + * programs. * * @author Edward A. Lee */ target Python reactor Ping(count = 10) { - input receive - output send - state pingsLeft = count - logical action serve + input receive + output send + state pingsLeft = count + logical action serve - reaction(startup, serve) -> send {= - print("At logical time {}, Ping sending {}.\n".format(lf.time.logical_elapsed(), self.pingsLeft)) - send.set(self.pingsLeft) - self.pingsLeft -= 1 - =} + reaction(startup, serve) -> send {= + print("At logical time {}, Ping sending {}.\n".format(lf.time.logical_elapsed(), self.pingsLeft)) + send.set(self.pingsLeft) + self.pingsLeft -= 1 + =} - reaction(receive) -> serve {= - if self.pingsLeft > 0: - serve.schedule(0) - else: - lf_request_stop() - =} + reaction(receive) -> serve {= + if self.pingsLeft > 0: + serve.schedule(0) + else: + lf_request_stop() + =} } reactor Pong(expected = 10) { - preamble {= import sys =} + preamble {= import sys =} - input receive - output send - state count = 0 + input receive + output send + state count = 0 - reaction(receive) -> send {= - self.count += 1 - print("At logical time {}, Pong received {}.\n".format(lf.time.logical_elapsed(), receive.value)) - send.set(receive.value) - if self.count == self.expected: - lf_request_stop() - =} + reaction(receive) -> send {= + self.count += 1 + print("At logical time {}, Pong received {}.\n".format(lf.time.logical_elapsed(), receive.value)) + send.set(receive.value) + if self.count == self.expected: + lf_request_stop() + =} - reaction(shutdown) {= - if self.count != self.expected: - print("Pong expected to receive {} inputs, but it received {}.\n".format(self.expected, self.count), file=self.sys.stderr) - self.sys.exit(1) - print("Pong received {} pings.\n".format(self.count)) - =} + reaction(shutdown) {= + if self.count != self.expected: + print("Pong expected to receive {} inputs, but it received {}.\n".format(self.expected, self.count), file=self.sys.stderr) + self.sys.exit(1) + print("Pong received {} pings.\n".format(self.count)) + =} } federated reactor(count = 10) { - ping = new Ping(count = count) - pong = new Pong(expected = count) - ping.send ~> pong.receive - pong.send ~> ping.receive + ping = new Ping(count = count) + pong = new Pong(expected = count) + ping.send ~> pong.receive + pong.send ~> ping.receive } diff --git a/test/Python/src/federated/StopAtShutdown.lf b/test/Python/src/federated/StopAtShutdown.lf index 3179c44592..958ee269ca 100644 --- a/test/Python/src/federated/StopAtShutdown.lf +++ b/test/Python/src/federated/StopAtShutdown.lf @@ -6,30 +6,30 @@ * @author Steven Wong */ target Python { - timeout: 2 sec + timeout: 2 sec } reactor A { - input in_ + input in_ - reaction(startup) {= print("Hello World!") =} + reaction(startup) {= print("Hello World!") =} - reaction(in_) {= print("Got it") =} + reaction(in_) {= print("Got it") =} - reaction(shutdown) {= lf_request_stop() =} + reaction(shutdown) {= lf_request_stop() =} } reactor B { - output out - timer t(1 sec) + output out + timer t(1 sec) - reaction(t) -> out {= out.set(1) =} + reaction(t) -> out {= out.set(1) =} - reaction(shutdown) {= lf_request_stop() =} + reaction(shutdown) {= lf_request_stop() =} } federated reactor { - a = new A() - b = new B() - b.out -> a.in_ + a = new A() + b = new B() + b.out -> a.in_ } diff --git a/test/Python/src/lib/Count.lf b/test/Python/src/lib/Count.lf index 26b53ce13b..2f86fabf60 100644 --- a/test/Python/src/lib/Count.lf +++ b/test/Python/src/lib/Count.lf @@ -1,12 +1,12 @@ target Python reactor Count(offset = 0, period = 1 sec) { - state count = 1 - output out - timer t(offset, period) + state count = 1 + output out + timer t(offset, period) - reaction(t) -> out {= - out.set(self.count) - self.count += 1 - =} + reaction(t) -> out {= + out.set(self.count) + self.count += 1 + =} } diff --git a/test/Python/src/lib/InternalDelay.lf b/test/Python/src/lib/InternalDelay.lf index a9796aa8d9..964ec6b5a3 100644 --- a/test/Python/src/lib/InternalDelay.lf +++ b/test/Python/src/lib/InternalDelay.lf @@ -1,11 +1,11 @@ target Python reactor InternalDelay(delay = 10 msec) { - input in_ - output out - logical action d + input in_ + output out + logical action d - reaction(in_) -> d {= d.schedule(self.delay, in_.value) =} + reaction(in_) -> d {= d.schedule(self.delay, in_.value) =} - reaction(d) -> out {= out.set(d.value) =} + reaction(d) -> out {= out.set(d.value) =} } diff --git a/test/Python/src/lib/LoopedActionSender.lf b/test/Python/src/lib/LoopedActionSender.lf index 9d4048d0ea..e3b7dfa961 100644 --- a/test/Python/src/lib/LoopedActionSender.lf +++ b/test/Python/src/lib/LoopedActionSender.lf @@ -6,25 +6,24 @@ target Python /** - * @param take_a_break_after: Indicates how many messages are sent in - * consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break - * after sending take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break after sending + * take_a_break_after messages. */ reactor Sender(take_a_break_after = 10, break_interval = 400 msec) { - output out - logical action act - state sent_messages = 0 + output out + logical action act + state sent_messages = 0 - reaction(startup, act) -> act, out {= - # Send a message on out - out.set(self.sent_messages) - self.sent_messages += 1 - if self.sent_messages < self.take_a_break_after: - act.schedule(0) - else: - # Take a break - self.sent_messages=0; - act.schedule(self.break_interval) - =} + reaction(startup, act) -> act, out {= + # Send a message on out + out.set(self.sent_messages) + self.sent_messages += 1 + if self.sent_messages < self.take_a_break_after: + act.schedule(0) + else: + # Take a break + self.sent_messages=0; + act.schedule(self.break_interval) + =} } diff --git a/test/Python/src/lib/Test.lf b/test/Python/src/lib/Test.lf index 301ed9c8e6..6cbc45bfcb 100644 --- a/test/Python/src/lib/Test.lf +++ b/test/Python/src/lib/Test.lf @@ -1,14 +1,14 @@ target Python reactor TestDouble(expected(1.0, 1.0, 1.0, 1.0)) { - input t_in - state count = 0 + input t_in + state count = 0 - reaction(t_in) {= - print("Received: ", t_in.value) - if t_in.value != self.expected[self.count]: - sys.stderr.write("ERROR: Expected {:f}.\n".format(self.expected[self.count])) - exit(1) - self.count += 1 - =} + reaction(t_in) {= + print("Received: ", t_in.value) + if t_in.value != self.expected[self.count]: + sys.stderr.write("ERROR: Expected {:f}.\n".format(self.expected[self.count])) + exit(1) + self.count += 1 + =} } diff --git a/test/Python/src/lib/TestCount.lf b/test/Python/src/lib/TestCount.lf index de611cbc69..a079ff2e37 100644 --- a/test/Python/src/lib/TestCount.lf +++ b/test/Python/src/lib/TestCount.lf @@ -1,7 +1,6 @@ /** - * Test that a counting sequence of inputs starts with the specified start - * parameter value, increments by the specified stride, and receives the - * specified number of inputs. + * Test that a counting sequence of inputs starts with the specified start parameter value, + * increments by the specified stride, and receives the specified number of inputs. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. @@ -10,24 +9,24 @@ target Python reactor TestCount(start = 1, stride = 1, num_inputs = 1) { - preamble {= import sys =} - state count = start - state inputs_received = 0 - input in_ + preamble {= import sys =} + state count = start + state inputs_received = 0 + input in_ - reaction(in_) {= - print("Received {}.".format(in_.value)) - if in_.value != self.count: - print("Expected {}.".format(self.count)) - self.sys.exit(1) - self.count += self.stride; - self.inputs_received += 1; - =} + reaction(in_) {= + print("Received {}.".format(in_.value)) + if in_.value != self.count: + print("Expected {}.".format(self.count)) + self.sys.exit(1) + self.count += self.stride; + self.inputs_received += 1; + =} - reaction(shutdown) {= - print("Shutdown invoked.") - if self.inputs_received != self.num_inputs: - print("Expected to receive {} inputs, but got {}.".format(self.num_inputs, self.inputs_received)) - self.sys.exit(1) - =} + reaction(shutdown) {= + print("Shutdown invoked.") + if self.inputs_received != self.num_inputs: + print("Expected to receive {} inputs, but got {}.".format(self.num_inputs, self.inputs_received)) + self.sys.exit(1) + =} } diff --git a/test/Python/src/lib/TestCountMultiport.lf b/test/Python/src/lib/TestCountMultiport.lf index c30572e4d5..d5b0a635cd 100644 --- a/test/Python/src/lib/TestCountMultiport.lf +++ b/test/Python/src/lib/TestCountMultiport.lf @@ -1,42 +1,41 @@ /** - * Test that a counting sequence of inputs starts with the specified start - * parameter value, increments by the specified stride, and receives the - * specified number of inputs. This version has a multiport input, and each - * input is expected to be present and incremented over the previous input. + * Test that a counting sequence of inputs starts with the specified start parameter value, + * increments by the specified stride, and receives the specified number of inputs. This version has + * a multiport input, and each input is expected to be present and incremented over the previous + * input. * * @param start The starting value for the expected inputs. Default is 1. * @param stride The increment for the inputs. Default is 1. - * @param num_inputs The number of inputs expected on each channel. Default is - * 1. + * @param num_inputs The number of inputs expected on each channel. Default is 1. */ target Python reactor TestCountMultiport(start = 1, stride = 1, num_inputs = 1, width = 2) { - preamble {= import sys =} - state count = start - state inputs_received = 0 - input[width] inp + preamble {= import sys =} + state count = start + state inputs_received = 0 + input[width] inp - reaction(inp) {= - for i in range(in_width): - if not inp[i].is_present: - print("No input on channel {}.".format(i)) - self.sys.exit(1) - print("Received {} on channel {}.".format(inp[i].value, i)) - if inp[i].value != self.count: - print("Expected {}.".format(self.count)) - self.sys.exit(1) - self.count += self.stride - self.inputs_received += 1 - =} - - reaction(shutdown) {= - print("Shutdown invoked.") - if self.inputs_received != self.num_inputs: - print("Expected to receive {} inputs, but only got {}.".format( - self.num_inputs, - self.inputs_received - )) + reaction(inp) {= + for i in range(in_width): + if not inp[i].is_present: + print("No input on channel {}.".format(i)) + self.sys.exit(1) + print("Received {} on channel {}.".format(inp[i].value, i)) + if inp[i].value != self.count: + print("Expected {}.".format(self.count)) self.sys.exit(1) - =} + self.count += self.stride + self.inputs_received += 1 + =} + + reaction(shutdown) {= + print("Shutdown invoked.") + if self.inputs_received != self.num_inputs: + print("Expected to receive {} inputs, but only got {}.".format( + self.num_inputs, + self.inputs_received + )) + self.sys.exit(1) + =} } diff --git a/test/Python/src/modal_models/BanksCount3ModesComplex.lf b/test/Python/src/modal_models/BanksCount3ModesComplex.lf index 59b41ef75f..97447dc0b5 100644 --- a/test/Python/src/modal_models/BanksCount3ModesComplex.lf +++ b/test/Python/src/modal_models/BanksCount3ModesComplex.lf @@ -1,78 +1,74 @@ -/** - * Modal Reactor Test. Tests cycling through modes with banks of reactors and - * complex nesting. - */ +/** Modal Reactor Test. Tests cycling through modes with banks of reactors and complex nesting. */ target Python { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } import TraceTesting from "util/TraceTesting.lf" import CounterCycle from "Count3Modes.lf" reactor MetaCounter { - input next - output[2] always - output[2] mode1 - output[2] mode2 - output[2] never + input next + output[2] always + output[2] mode1 + output[2] mode2 + output[2] never - outer_counters = new[2] CounterCycle() - (next)+ -> outer_counters.next - outer_counters.count -> always + outer_counters = new[2] CounterCycle() + (next)+ -> outer_counters.next + outer_counters.count -> always - initial mode One { - mode1_counters = new[2] CounterCycle() + initial mode One { + mode1_counters = new[2] CounterCycle() - (next)+ -> mode1_counters.next - mode1_counters.count -> mode1 + (next)+ -> mode1_counters.next + mode1_counters.count -> mode1 - timer t1(500 msec, 250 msec) - reaction(t1) -> reset(Two) {= Two.set() =} - } + timer t1(500 msec, 250 msec) + reaction(t1) -> reset(Two) {= Two.set() =} + } - mode Two { - mode2_counters = new[2] CounterCycle() + mode Two { + mode2_counters = new[2] CounterCycle() - (next)+ -> mode2_counters.next - mode2_counters.count -> mode2 + (next)+ -> mode2_counters.next + mode2_counters.count -> mode2 - timer t2(500 msec, 250 msec) - reaction(t2) -> history(One) {= One.set() =} - } + timer t2(500 msec, 250 msec) + reaction(t2) -> history(One) {= One.set() =} + } - mode Three { - mode3_counters = new[2] CounterCycle() + mode Three { + mode3_counters = new[2] CounterCycle() - (next)+ -> mode3_counters.next - mode3_counters.count -> never - } + (next)+ -> mode3_counters.next + mode3_counters.count -> never + } } main reactor { - timer stepper(0, 250 msec) - counters = new[2] MetaCounter() - test = new TraceTesting(events_size = 16, trace = ( // keep-format - 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 250000000,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, - 250000000,1,2,1,2,1,2,1,2,0,3,0,3,0,3,0,3,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, - 250000000,1,3,1,3,1,3,1,3,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, - 250000000,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, - 250000000,1,2,1,2,1,2,1,2,0,1,0,1,0,1,0,1,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, - 250000000,1,3,1,3,1,3,1,3,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, - 250000000,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,2,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, - 250000000,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, - 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, - 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0 - ), training = False) + timer stepper(0, 250 msec) + counters = new[2] MetaCounter() + test = new TraceTesting(events_size = 16, trace = ( // keep-format + 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 250000000,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, + 250000000,1,2,1,2,1,2,1,2,0,3,0,3,0,3,0,3,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, + 250000000,1,3,1,3,1,3,1,3,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, + 250000000,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, + 250000000,1,2,1,2,1,2,1,2,0,1,0,1,0,1,0,1,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, + 250000000,1,3,1,3,1,3,1,3,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, + 250000000,1,1,1,1,1,1,1,1,0,2,0,2,0,2,0,2,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, + 250000000,1,2,1,2,1,2,1,2,0,2,0,2,0,2,0,2,1,2,1,2,1,2,1,2,0,0,0,0,0,0,0,0, + 250000000,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,0,2,0,2,0,2,0,2,0,0,0,0,0,0,0,0, + 250000000,1,1,1,1,1,1,1,1,0,3,0,3,0,3,0,3,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0 + ), training = False) - counters.always, counters.mode1, counters.mode2, counters.never - -> test.events + counters.always, counters.mode1, counters.mode2, counters.never -> test.events - reaction(stepper) -> counters.next {= # Trigger - for i in range(len(counters)): - counters[i].next.set(True) - =} + reaction(stepper) -> counters.next {= # Trigger + for i in range(len(counters)): + counters[i].next.set(True) + =} } diff --git a/test/Python/src/modal_models/BanksModalStateReset.lf b/test/Python/src/modal_models/BanksModalStateReset.lf index f96a7bd638..65080b5da9 100644 --- a/test/Python/src/modal_models/BanksModalStateReset.lf +++ b/test/Python/src/modal_models/BanksModalStateReset.lf @@ -1,10 +1,7 @@ -/** - * Modal Reactor Test. Tests reset of state variables in modes with banks of - * reactors. - */ +/** Modal Reactor Test. Tests reset of state variables in modes with banks of reactors. */ target Python { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" @@ -12,50 +9,49 @@ import Modal as ResetReaction from "ModalStateReset.lf" import Modal as AutoReset from "ModalStateResetAuto.lf" main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - reset1 = new[2] ResetReaction() - reset2 = new[2] AutoReset() - test = new TraceTesting(events_size = 16, trace = ( // keep-format - 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, - 250000000,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, 0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, - 250000000,0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, 0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, - 250000000,0,0,0,0,0,0,0,0,1,3,1,3,0,0,0,0, 0,0,0,0,0,0,0,0,1,3,1,3,0,0,0,0, - 250000000,1,1,1,1,1,0,1,0,1,4,1,4,0,0,0,0, 1,1,1,1,1,0,1,0,1,4,1,4,0,0,0,0, - 0,0,1,0,1,0,0,0,0,0,4,0,4,1,-2,1,-2, 0,1,0,1,0,0,0,0,0,4,0,4,1,-2,1,-2, - 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,-1,1,-1, 0,1,0,1,0,0,0,0,0,4,0,4,1,-1,1,-1, - 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,0,1,0, 0,1,0,1,0,0,0,0,0,4,0,4,1,0,1,0, - 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,1,1,1, 0,1,0,1,0,0,0,0,0,4,0,4,1,1,1,1, - 250000000,1,1,1,1,1,1,1,1,0,4,0,4,1,2,1,2, 1,1,1,1,1,1,1,1,0,4,0,4,1,2,1,2, - 250000000,0,1,0,1,0,1,0,1,1,5,1,5,0,2,0,2, 0,1,0,1,0,1,0,1,1,5,1,5,0,2,0,2, - 250000000,0,1,0,1,0,1,0,1,1,6,1,6,0,2,0,2, 0,1,0,1,0,1,0,1,1,6,1,6,0,2,0,2, - 250000000,0,1,0,1,0,1,0,1,1,7,1,7,0,2,0,2, 0,1,0,1,0,1,0,1,1,7,1,7,0,2,0,2, - 250000000,1,1,1,1,1,2,1,2,1,8,1,8,0,2,0,2, 1,1,1,1,1,2,1,2,1,8,1,8,0,2,0,2, - 0,0,1,0,1,0,2,0,2,0,8,0,8,1,-2,1,-2, 0,1,0,1,0,2,0,2,0,8,0,8,1,-2,1,-2, - 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,-1,1,-1, 0,1,0,1,0,2,0,2,0,8,0,8,1,-1,1,-1, - 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, 0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, - 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, 0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, - 250000000,1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2, 1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2 - ), training = False) + reset1 = new[2] ResetReaction() + reset2 = new[2] AutoReset() + test = new TraceTesting(events_size = 16, trace = ( // keep-format + 0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, + 250000000,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, 0,0,0,0,0,0,0,0,1,1,1,1,0,0,0,0, + 250000000,0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, 0,0,0,0,0,0,0,0,1,2,1,2,0,0,0,0, + 250000000,0,0,0,0,0,0,0,0,1,3,1,3,0,0,0,0, 0,0,0,0,0,0,0,0,1,3,1,3,0,0,0,0, + 250000000,1,1,1,1,1,0,1,0,1,4,1,4,0,0,0,0, 1,1,1,1,1,0,1,0,1,4,1,4,0,0,0,0, + 0,0,1,0,1,0,0,0,0,0,4,0,4,1,-2,1,-2, 0,1,0,1,0,0,0,0,0,4,0,4,1,-2,1,-2, + 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,-1,1,-1, 0,1,0,1,0,0,0,0,0,4,0,4,1,-1,1,-1, + 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,0,1,0, 0,1,0,1,0,0,0,0,0,4,0,4,1,0,1,0, + 250000000,0,1,0,1,0,0,0,0,0,4,0,4,1,1,1,1, 0,1,0,1,0,0,0,0,0,4,0,4,1,1,1,1, + 250000000,1,1,1,1,1,1,1,1,0,4,0,4,1,2,1,2, 1,1,1,1,1,1,1,1,0,4,0,4,1,2,1,2, + 250000000,0,1,0,1,0,1,0,1,1,5,1,5,0,2,0,2, 0,1,0,1,0,1,0,1,1,5,1,5,0,2,0,2, + 250000000,0,1,0,1,0,1,0,1,1,6,1,6,0,2,0,2, 0,1,0,1,0,1,0,1,1,6,1,6,0,2,0,2, + 250000000,0,1,0,1,0,1,0,1,1,7,1,7,0,2,0,2, 0,1,0,1,0,1,0,1,1,7,1,7,0,2,0,2, + 250000000,1,1,1,1,1,2,1,2,1,8,1,8,0,2,0,2, 1,1,1,1,1,2,1,2,1,8,1,8,0,2,0,2, + 0,0,1,0,1,0,2,0,2,0,8,0,8,1,-2,1,-2, 0,1,0,1,0,2,0,2,0,8,0,8,1,-2,1,-2, + 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,-1,1,-1, 0,1,0,1,0,2,0,2,0,8,0,8,1,-1,1,-1, + 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, 0,1,0,1,0,2,0,2,0,8,0,8,1,0,1,0, + 250000000,0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, 0,1,0,1,0,2,0,2,0,8,0,8,1,1,1,1, + 250000000,1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2, 1,1,1,1,1,3,1,3,0,8,0,8,1,2,1,2 + ), training = False) - reset1.mode_switch, - reset1.count0, - reset1.count1, - reset1.count2, - reset2.mode_switch, - reset2.count0, - reset2.count1, - reset2.count2 - -> test.events + reset1.mode_switch, + reset1.count0, + reset1.count1, + reset1.count2, + reset2.mode_switch, + reset2.count0, + reset2.count1, + reset2.count2 + -> test.events - # Trigger mode change (separately because of #1278) - reaction(stepper) -> reset1.next {= - for i in range(len(reset1)): - reset1[i].next.set(True) - =} + reaction(stepper) -> reset1.next {= # Trigger mode change (separately because of #1278) + for i in range(len(reset1)): + reset1[i].next.set(True) + =} - reaction(stepper) -> reset2.next {= - for i in range(len(reset2)): - reset2[i].next.set(True) - =} + reaction(stepper) -> reset2.next {= + for i in range(len(reset2)): + reset2[i].next.set(True) + =} } diff --git a/test/Python/src/modal_models/ConvertCaseTest.lf b/test/Python/src/modal_models/ConvertCaseTest.lf index f3bdee59fe..85e6c6f5e9 100644 --- a/test/Python/src/modal_models/ConvertCaseTest.lf +++ b/test/Python/src/modal_models/ConvertCaseTest.lf @@ -1,123 +1,118 @@ /** Modal Reactor Test. Tests nested reactors with modes. */ target Python { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor ResetProcessor { - input discard - input character - output converted - - initial mode Converting { - converter = new Converter() - character -> converter.raw - converter.converted -> converted - reaction(discard) -> reset(Discarding) {= Discarding.set() =} - } - - mode Discarding { - reaction(character) -> converted {= converted.set('_') =} - - reaction(character) -> reset(Converting) {= Converting.set() =} - } + input discard + input character + output converted + + initial mode Converting { + converter = new Converter() + character -> converter.raw + converter.converted -> converted + reaction(discard) -> reset(Discarding) {= Discarding.set() =} + } + + mode Discarding { + reaction(character) -> converted {= converted.set('_') =} + + reaction(character) -> reset(Converting) {= Converting.set() =} + } } reactor HistoryProcessor { - input discard - input character - output converted - - initial mode Converting { - converter = new Converter() - character -> converter.raw - converter.converted -> converted - reaction(discard) -> reset(Discarding) {= Discarding.set() =} - } - - mode Discarding { - reaction(character) -> converted {= converted.set('_') =} - - reaction(character) -> history(Converting) {= Converting.set() =} - } + input discard + input character + output converted + + initial mode Converting { + converter = new Converter() + character -> converter.raw + converter.converted -> converted + reaction(discard) -> reset(Discarding) {= Discarding.set() =} + } + + mode Discarding { + reaction(character) -> converted {= converted.set('_') =} + + reaction(character) -> history(Converting) {= Converting.set() =} + } } reactor Converter { - input raw - output converted - - initial mode Upper { - reaction(raw) -> converted, reset(Lower) {= - character = raw.value.upper() - converted.set(character) - if character == ' ': - Lower.set() - =} - } - - mode Lower { - reaction(raw) -> converted, reset(Upper) {= - character = raw.value.lower() - converted.set(character) - if character == ' ': - Upper.set() - =} - } + input raw + output converted + + initial mode Upper { + reaction(raw) -> converted, reset(Lower) {= + character = raw.value.upper() + converted.set(character) + if character == ' ': + Lower.set() + =} + } + + mode Lower { + reaction(raw) -> converted, reset(Upper) {= + character = raw.value.lower() + converted.set(character) + if character == ' ': + Upper.set() + =} + } } reactor InputFeeder(message = "") { - output character - state idx = 0 + output character + state idx = 0 - timer t(0, 250 msec) + timer t(0, 250 msec) - reaction(t) -> character {= - if self.idx < len(self.message): - character.set(self.message[self.idx]) - self.idx += 1 - =} + reaction(t) -> character {= + if self.idx < len(self.message): + character.set(self.message[self.idx]) + self.idx += 1 + =} } main reactor { - timer stepper(500 msec, 1 sec) - - feeder = new InputFeeder(message = "Hello World!") - reset_processor = new ResetProcessor() - history_processor = new HistoryProcessor() - - feeder.character -> reset_processor.character - feeder.character -> history_processor.character - - test = new TraceTesting(events_size = 2, trace = ( // keep-format - 0, True, 'H', True, 'H', - 250000000, True, 'E', True, 'E', - 250000000, True, 'L', True, 'L', - 250000000, True, '_', True, '_', - 250000000, True, 'O', True, 'O', - 250000000, True, ' ', True, ' ', - 250000000, True, 'w', True, 'w', - 250000000, True, '_', True, '_', - 250000000, True, 'R', True, 'r', - 250000000, True, 'L', True, 'l', - 250000000, True, 'D', True, 'd', - 250000000, True, '_', True, '_' - ), training = False) - - reset_processor.converted, history_processor.converted -> test.events - - # Trigger mode change - reaction(stepper) -> reset_processor.discard, history_processor.discard {= - reset_processor.discard.set(True) - history_processor.discard.set(True) - =} - - reaction(reset_processor.converted) {= - print(f"Reset: {reset_processor.converted.value}") - =} - - reaction(history_processor.converted) {= - print(f"History: {history_processor.converted.value}") - =} + timer stepper(500 msec, 1 sec) + + feeder = new InputFeeder(message = "Hello World!") + reset_processor = new ResetProcessor() + history_processor = new HistoryProcessor() + + feeder.character -> reset_processor.character + feeder.character -> history_processor.character + + test = new TraceTesting(events_size = 2, trace = ( // keep-format + 0, True, 'H', True, 'H', + 250000000, True, 'E', True, 'E', + 250000000, True, 'L', True, 'L', + 250000000, True, '_', True, '_', + 250000000, True, 'O', True, 'O', + 250000000, True, ' ', True, ' ', + 250000000, True, 'w', True, 'w', + 250000000, True, '_', True, '_', + 250000000, True, 'R', True, 'r', + 250000000, True, 'L', True, 'l', + 250000000, True, 'D', True, 'd', + 250000000, True, '_', True, '_' + ), training = False) + + reset_processor.converted, history_processor.converted -> test.events + + reaction(stepper) -> reset_processor.discard, history_processor.discard {= # Trigger mode change + reset_processor.discard.set(True) + history_processor.discard.set(True) + =} + + reaction(reset_processor.converted) {= print(f"Reset: {reset_processor.converted.value}") =} + + reaction(history_processor.converted) {= print(f"History: {history_processor.converted.value}") =} } diff --git a/test/Python/src/modal_models/Count3Modes.lf b/test/Python/src/modal_models/Count3Modes.lf index 7e2e9d98e2..77fb09d1c0 100644 --- a/test/Python/src/modal_models/Count3Modes.lf +++ b/test/Python/src/modal_models/Count3Modes.lf @@ -1,56 +1,56 @@ /** Modal Reactor Test. Tests cycling through modes. */ target Python { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } reactor CounterCycle { - input next - output count - - initial mode One { - reaction(next) -> count, reset(Two) {= - count.set(1) - Two.set() - =} - } - - mode Two { - reaction(next) -> count, reset(Three) {= - count.set(2) - Three.set() - =} - } - - mode Three { - reaction(next) -> count, reset(One) {= - count.set(3) - One.set() - =} - } + input next + output count + + initial mode One { + reaction(next) -> count, reset(Two) {= + count.set(1) + Two.set() + =} + } + + mode Two { + reaction(next) -> count, reset(Three) {= + count.set(2) + Three.set() + =} + } + + mode Three { + reaction(next) -> count, reset(One) {= + count.set(3) + One.set() + =} + } } main reactor { - timer stepper(0, 250 msec) - counter = new CounterCycle() + timer stepper(0, 250 msec) + counter = new CounterCycle() - state expected_value = 1 + state expected_value = 1 - reaction(stepper) -> counter.next {= counter.next.set(True) =} # Trigger + reaction(stepper) -> counter.next {= counter.next.set(True) =} # Trigger - reaction(stepper) counter.count {= # Check - print(f"{counter.count.value}") + reaction(stepper) counter.count {= # Check + print(f"{counter.count.value}") - if counter.count.is_present is not True: - sys.stderr.write("ERROR: Missing mode change.\n") - exit(1) - elif counter.count.value != self.expected_value: - sys.stderr.write("ERROR: Wrong mode.\n") - exit(2) + if counter.count.is_present is not True: + sys.stderr.write("ERROR: Missing mode change.\n") + exit(1) + elif counter.count.value != self.expected_value: + sys.stderr.write("ERROR: Wrong mode.\n") + exit(2) - if self.expected_value == 3: - self.expected_value = 1 - else: - self.expected_value += 1 - =} + if self.expected_value == 3: + self.expected_value = 1 + else: + self.expected_value += 1 + =} } diff --git a/test/Python/src/modal_models/ModalActions.lf b/test/Python/src/modal_models/ModalActions.lf index b74f92f3c9..fd4adf8eb8 100644 --- a/test/Python/src/modal_models/ModalActions.lf +++ b/test/Python/src/modal_models/ModalActions.lf @@ -1,95 +1,94 @@ /** - * Modal Reactor Test. Tests actions, their suspension during mode inactivity - * and continuation of delays with history transitions. + * Modal Reactor Test. Tests actions, their suspension during mode inactivity and continuation of + * delays with history transitions. */ target Python { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next + input next - output mode_switch - output action1_sched - output action1_exec - output action2_sched - output action2_exec + output mode_switch + output action1_sched + output action1_exec + output action2_sched + output action2_exec - initial mode One { - timer T1(0, 750 msec) - logical action delay1(500 msec) - reaction(T1) -> delay1, action1_sched {= - print("Scheduled Action") - delay1.schedule(0) - action1_sched.set(1) - =} + initial mode One { + timer T1(0, 750 msec) + logical action delay1(500 msec) + reaction(T1) -> delay1, action1_sched {= + print("Scheduled Action") + delay1.schedule(0) + action1_sched.set(1) + =} - reaction(delay1) -> action1_exec {= - print("Executed Action") - action1_exec.set(1) - =} + reaction(delay1) -> action1_exec {= + print("Executed Action") + action1_exec.set(1) + =} - reaction(next) -> reset(Two), mode_switch {= - print("Transitioning to mode Two (reset)") - mode_switch.set(1) - Two.set() - =} - } + reaction(next) -> reset(Two), mode_switch {= + print("Transitioning to mode Two (reset)") + mode_switch.set(1) + Two.set() + =} + } - mode Two { - timer T2(0, 750 msec) - logical action delay2(500 msec) - reaction(T2) -> delay2, action2_sched {= - print("Scheduled Action2") - delay2.schedule(0) - action2_sched.set(1) - =} + mode Two { + timer T2(0, 750 msec) + logical action delay2(500 msec) + reaction(T2) -> delay2, action2_sched {= + print("Scheduled Action2") + delay2.schedule(0) + action2_sched.set(1) + =} - reaction(delay2) -> action2_exec {= - print("Executed Action2") - action2_exec.set(1) - =} + reaction(delay2) -> action2_exec {= + print("Executed Action2") + action2_exec.set(1) + =} - reaction(next) -> history(One), mode_switch {= - print("Transitioning to mode One (continue)") - mode_switch.set(1) - One.set() - =} - } + reaction(next) -> history(One), mode_switch {= + print("Transitioning to mode One (continue)") + mode_switch.set(1) + One.set() + =} + } } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting(events_size = 5, trace = ( // keep-format - 0,0,0,1,1,0,0,0,0,0,0, - 500000000,0,0,0,1,1,1,0,0,0,0, - 250000000,0,0,1,1,0,1,0,0,0,0, - 250000000,1,1,0,1,0,1,0,0,0,0, - 0,0,1,0,1,0,1,1,1,0,0, - 500000000,0,1,0,1,0,1,0,1,1,1, - 250000000,0,1,0,1,0,1,1,1,0,1, - 250000000,1,1,0,1,0,1,0,1,0,1, - 250000000,0,1,0,1,1,1,0,1,0,1, - 250000000,0,1,1,1,0,1,0,1,0,1, - 500000000,1,1,0,1,1,1,0,1,0,1, - 0,0,1,0,1,0,1,1,1,0,1, - 500000000,0,1,0,1,0,1,0,1,1,1, - 250000000,0,1,0,1,0,1,1,1,0,1, - 250000000,1,1,0,1,0,1,0,1,0,1 - ), training = False) + modal = new Modal() + test = new TraceTesting(events_size = 5, trace = ( // keep-format + 0,0,0,1,1,0,0,0,0,0,0, + 500000000,0,0,0,1,1,1,0,0,0,0, + 250000000,0,0,1,1,0,1,0,0,0,0, + 250000000,1,1,0,1,0,1,0,0,0,0, + 0,0,1,0,1,0,1,1,1,0,0, + 500000000,0,1,0,1,0,1,0,1,1,1, + 250000000,0,1,0,1,0,1,1,1,0,1, + 250000000,1,1,0,1,0,1,0,1,0,1, + 250000000,0,1,0,1,1,1,0,1,0,1, + 250000000,0,1,1,1,0,1,0,1,0,1, + 500000000,1,1,0,1,1,1,0,1,0,1, + 0,0,1,0,1,0,1,1,1,0,1, + 500000000,0,1,0,1,0,1,0,1,1,1, + 250000000,0,1,0,1,0,1,1,1,0,1, + 250000000,1,1,0,1,0,1,0,1,0,1 + ), training = False) - modal.mode_switch, - modal.action1_sched, - modal.action1_exec, - modal.action2_sched, - modal.action2_exec - -> test.events + modal.mode_switch, + modal.action1_sched, + modal.action1_exec, + modal.action2_sched, + modal.action2_exec + -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalAfter.lf b/test/Python/src/modal_models/ModalAfter.lf index 19c84f33d5..f6290e9bee 100644 --- a/test/Python/src/modal_models/ModalAfter.lf +++ b/test/Python/src/modal_models/ModalAfter.lf @@ -1,100 +1,95 @@ /** - * Modal Reactor Test. Tests after delays, its suspension during mode inactivity - * and continuation with history transitions. + * Modal Reactor Test. Tests after delays, its suspension during mode inactivity and continuation + * with history transitions. */ target Python { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next + input next - output mode_switch - output produced1 - output consumed1 - output produced2 - output consumed2 + output mode_switch + output produced1 + output consumed1 + output produced2 + output consumed2 - initial mode One { - producer1 = new Producer(mode_id = 1) - consumer1 = new Consumer(mode_id = 1) - producer1.product -> produced1 - producer1.product -> consumer1.product after 500 msec - consumer1.report -> consumed1 - reaction(next) -> reset(Two), mode_switch {= - print("Transitioning to mode Two (reset)") - mode_switch.set(1) - Two.set() - =} - } + initial mode One { + producer1 = new Producer(mode_id = 1) + consumer1 = new Consumer(mode_id = 1) + producer1.product -> produced1 + producer1.product -> consumer1.product after 500 msec + consumer1.report -> consumed1 + reaction(next) -> reset(Two), mode_switch {= + print("Transitioning to mode Two (reset)") + mode_switch.set(1) + Two.set() + =} + } - mode Two { - producer2 = new Producer(mode_id = 2) - consumer2 = new Consumer(mode_id = 2) - producer2.product -> produced2 - producer2.product -> consumer2.product after 500 msec - consumer2.report -> consumed2 - reaction(next) -> history(One), mode_switch {= - print("Transitioning to mode One (continue)") - mode_switch.set(1) - One.set() - =} - } + mode Two { + producer2 = new Producer(mode_id = 2) + consumer2 = new Consumer(mode_id = 2) + producer2.product -> produced2 + producer2.product -> consumer2.product after 500 msec + consumer2.report -> consumed2 + reaction(next) -> history(One), mode_switch {= + print("Transitioning to mode One (continue)") + mode_switch.set(1) + One.set() + =} + } } reactor Producer(mode_id = 0) { - output product + output product - timer t(0, 750 msec) + timer t(0, 750 msec) - reaction(t) -> product {= - print(f"Produced in {self.mode_id}") - product.set(1) - =} + reaction(t) -> product {= + print(f"Produced in {self.mode_id}") + product.set(1) + =} } reactor Consumer(mode_id = 0) { - input product - output report + input product + output report - reaction(product) -> report {= - print("Consumed in {self.mode_id}") - report.set(1) - =} + reaction(product) -> report {= + print("Consumed in {self.mode_id}") + report.set(1) + =} } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting(events_size = 5, trace = ( // keep-format - 0,0,0,1,1,0,0,0,0,0,0, - 500000000,0,0,0,1,1,1,0,0,0,0, - 250000000,0,0,1,1,0,1,0,0,0,0, - 250000000,1,1,0,1,0,1,0,0,0,0, - 0,0,1,0,1,0,1,1,1,0,0, - 500000000,0,1,0,1,0,1,0,1,1,1, - 250000000,0,1,0,1,0,1,1,1,0,1, - 250000000,1,1,0,1,0,1,0,1,0,1, - 250000000,0,1,0,1,1,1,0,1,0,1, - 250000000,0,1,1,1,0,1,0,1,0,1, - 500000000,1,1,0,1,1,1,0,1,0,1, - 0,0,1,0,1,0,1,1,1,0,1, - 500000000,0,1,0,1,0,1,0,1,1,1, - 250000000,0,1,0,1,0,1,1,1,0,1, - 250000000,1,1,0,1,0,1,0,1,0,1 - ), training = False) + modal = new Modal() + test = new TraceTesting(events_size = 5, trace = ( // keep-format + 0,0,0,1,1,0,0,0,0,0,0, + 500000000,0,0,0,1,1,1,0,0,0,0, + 250000000,0,0,1,1,0,1,0,0,0,0, + 250000000,1,1,0,1,0,1,0,0,0,0, + 0,0,1,0,1,0,1,1,1,0,0, + 500000000,0,1,0,1,0,1,0,1,1,1, + 250000000,0,1,0,1,0,1,1,1,0,1, + 250000000,1,1,0,1,0,1,0,1,0,1, + 250000000,0,1,0,1,1,1,0,1,0,1, + 250000000,0,1,1,1,0,1,0,1,0,1, + 500000000,1,1,0,1,1,1,0,1,0,1, + 0,0,1,0,1,0,1,1,1,0,1, + 500000000,0,1,0,1,0,1,0,1,1,1, + 250000000,0,1,0,1,0,1,1,1,0,1, + 250000000,1,1,0,1,0,1,0,1,0,1 + ), training = False) - modal.mode_switch, - modal.produced1, - modal.consumed1, - modal.produced2, - modal.consumed2 - -> test.events + modal.mode_switch, modal.produced1, modal.consumed1, modal.produced2, modal.consumed2 + -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalCycleBreaker.lf b/test/Python/src/modal_models/ModalCycleBreaker.lf index 1ceb2eb5d0..97155b1534 100644 --- a/test/Python/src/modal_models/ModalCycleBreaker.lf +++ b/test/Python/src/modal_models/ModalCycleBreaker.lf @@ -1,75 +1,73 @@ /** * Modal Reactor Test. * - * Tests if connections in the same reactor that have the same destination work - * if they are located in separate modes. + * Tests if connections in the same reactor that have the same destination work if they are located + * in separate modes. */ target Python { - fast: false, - timeout: 1 sec + fast: false, + timeout: 1 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input in1 - input in2 - output out + input in1 + input in2 + output out - # Defining reaction to in2 before in1 would cause cycle if no mode were - # present - mode Two { - timer wait(150 msec, 1 sec) - reaction(in2) {= =} + mode Two { # Defining reaction to in2 before in1 would cause cycle if no mode were present + timer wait(150 msec, 1 sec) + reaction(in2) {= =} - reaction(wait) -> reset(One) {= - One.set() - print("Switching to mode One") - =} - } + reaction(wait) -> reset(One) {= + One.set() + print("Switching to mode One") + =} + } - initial mode One { - reaction(in1) -> out {= out.set(in1.value) =} + initial mode One { + reaction(in1) -> out {= out.set(in1.value) =} - reaction(in1) -> reset(Two) {= - if in1.value % 5 == 4: - Two.set() - print("Switching to mode Two") - =} - } + reaction(in1) -> reset(Two) {= + if in1.value % 5 == 4: + Two.set() + print("Switching to mode Two") + =} + } } reactor Counter(period = 1 sec) { - output value + output value - timer t(0, period) - state curval = 0 + timer t(0, period) + state curval = 0 - reaction(t) -> value {= - value.set(self.curval) - self.curval += 1 - =} + reaction(t) -> value {= + value.set(self.curval) + self.curval += 1 + =} } main reactor { - counter = new Counter(period = 100 msec) - modal = new Modal() - test = new TraceTesting(events_size = 1, trace = ( // keep-format - 0,1,0, - 100000000,1,1, - 100000000,1,2, - 100000000,1,3, - 100000000,1,4, - 200000000,1,6, - 100000000,1,7, - 100000000,1,8, - 100000000,1,9 - ), training = False) + counter = new Counter(period = 100 msec) + modal = new Modal() + test = new TraceTesting(events_size = 1, trace = ( // keep-format + 0,1,0, + 100000000,1,1, + 100000000,1,2, + 100000000,1,3, + 100000000,1,4, + 200000000,1,6, + 100000000,1,7, + 100000000,1,8, + 100000000,1,9 + ), training = False) - counter.value -> modal.in1 - modal.out -> modal.in2 + counter.value -> modal.in1 + modal.out -> modal.in2 - modal.out -> test.events + modal.out -> test.events - reaction(modal.out) {= print(modal.out.value) =} # Print + reaction(modal.out) {= print(modal.out.value) =} # Print } diff --git a/test/Python/src/modal_models/ModalStartupShutdown.lf b/test/Python/src/modal_models/ModalStartupShutdown.lf index c7a868eeca..cd0770ef5f 100644 --- a/test/Python/src/modal_models/ModalStartupShutdown.lf +++ b/test/Python/src/modal_models/ModalStartupShutdown.lf @@ -1,142 +1,141 @@ /** Modal Reactor Test. Test startup/shutdown reactions in modes. */ target Python { - fast: false, - timeout: 3000 msec + fast: false, + timeout: 3000 msec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next - - output mode_switch - output startup1 - output startup2 - output shutdown2 - output shutdown3 - output startup4 - output reset4 - output shutdown4 - output startup5 - output reset5 - output shutdown5 - - initial mode One { - reaction(startup) -> startup1 {= - print(f"Startup 1 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - startup1.set(1) - =} - - reaction(next) -> reset(Two), mode_switch {= - print("Transitioning to mode 2") - mode_switch.set(2) - Two.set() - =} - } - - mode Two { - reaction(startup) -> startup2 {= - print(f"Startup 2 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - startup2.set(1) - =} - - reaction(next) -> reset(Three), mode_switch {= - print("Transitioning to mode 3") - mode_switch.set(3) - Three.set() - =} - - reaction(shutdown) -> shutdown2 {= - print(f"Shutdown 2 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - shutdown2.set(1) - =} - } - - mode Three { - reaction(next) -> reset(Four), mode_switch {= - print("Transitioning to mode 4") - mode_switch.set(4) - Four.set() - =} - - reaction(shutdown) -> shutdown3 {= - print(f"Shutdown 3 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - shutdown3.set(1) - =} - } - - mode Four { - reaction(startup) -> startup4 {= - print(f"Startup 4 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - startup4.set(1) - =} - - reaction(reset) -> reset4 {= - print(f"Reset 4 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - reset4.set(1) - =} - - reaction(next) -> reset(Four), mode_switch {= - print("Transitioning to mode 4") - mode_switch.set(4) - Four.set() - =} - - reaction(shutdown) -> shutdown4 {= - print(f"Shutdown 4 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - shutdown4.set(1) - =} - } - - mode Five { # Unreachable! - reaction(startup) -> startup5 {= - print(f"Startup 5 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - startup5.set(1) - =} - - reaction(reset) -> reset5 {= - print(f"Reset 5 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - reset5.set(1) - =} - - reaction(shutdown) -> shutdown5 {= - print(f"Shutdown 5 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") - shutdown5.set(1) - =} - } + input next + + output mode_switch + output startup1 + output startup2 + output shutdown2 + output shutdown3 + output startup4 + output reset4 + output shutdown4 + output startup5 + output reset5 + output shutdown5 + + initial mode One { + reaction(startup) -> startup1 {= + print(f"Startup 1 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + startup1.set(1) + =} + + reaction(next) -> reset(Two), mode_switch {= + print("Transitioning to mode 2") + mode_switch.set(2) + Two.set() + =} + } + + mode Two { + reaction(startup) -> startup2 {= + print(f"Startup 2 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + startup2.set(1) + =} + + reaction(next) -> reset(Three), mode_switch {= + print("Transitioning to mode 3") + mode_switch.set(3) + Three.set() + =} + + reaction(shutdown) -> shutdown2 {= + print(f"Shutdown 2 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + shutdown2.set(1) + =} + } + + mode Three { + reaction(next) -> reset(Four), mode_switch {= + print("Transitioning to mode 4") + mode_switch.set(4) + Four.set() + =} + + reaction(shutdown) -> shutdown3 {= + print(f"Shutdown 3 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + shutdown3.set(1) + =} + } + + mode Four { + reaction(startup) -> startup4 {= + print(f"Startup 4 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + startup4.set(1) + =} + + reaction(reset) -> reset4 {= + print(f"Reset 4 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + reset4.set(1) + =} + + reaction(next) -> reset(Four), mode_switch {= + print("Transitioning to mode 4") + mode_switch.set(4) + Four.set() + =} + + reaction(shutdown) -> shutdown4 {= + print(f"Shutdown 4 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + shutdown4.set(1) + =} + } + + mode Five { # Unreachable! + reaction(startup) -> startup5 {= + print(f"Startup 5 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + startup5.set(1) + =} + + reaction(reset) -> reset5 {= + print(f"Reset 5 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + reset5.set(1) + =} + + reaction(shutdown) -> shutdown5 {= + print(f"Shutdown 5 at ({lf.time.logical_elapsed()}, {lf.tag().microstep}).") + shutdown5.set(1) + =} + } } main reactor { - timer stepper(500 msec, 500 msec) - - modal = new Modal() - test = new TraceTesting(events_size = 11, trace = ( // keep-format - 0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 500000000,1,2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,2,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 500000000,1,3,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 500000000,1,4,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, - 0,0,4,0,1,0,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, - 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, - 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, - 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, - 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, - 500000000,1,4,0,1,0,1,1,1,1,1,0,1,0,1,1,1,0,0,0,0,0,0 - ), training = False) - - modal.mode_switch, - modal.startup1, - modal.startup2, - modal.shutdown2, - modal.shutdown3, - modal.startup4, - modal.reset4, - modal.shutdown4, - modal.startup5, - modal.reset5, - modal.shutdown5 - -> test.events - - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + timer stepper(500 msec, 500 msec) + + modal = new Modal() + test = new TraceTesting(events_size = 11, trace = ( // keep-format + 0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 500000000,1,2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,2,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 500000000,1,3,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 500000000,1,4,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,4,0,1,0,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, + 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, + 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, + 500000000,1,4,0,1,0,1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0, + 0,0,4,0,1,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0, + 500000000,1,4,0,1,0,1,1,1,1,1,0,1,0,1,1,1,0,0,0,0,0,0 + ), training = False) + + modal.mode_switch, + modal.startup1, + modal.startup2, + modal.shutdown2, + modal.shutdown3, + modal.startup4, + modal.reset4, + modal.shutdown4, + modal.startup5, + modal.reset5, + modal.shutdown5 + -> test.events + + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalStateReset.lf b/test/Python/src/modal_models/ModalStateReset.lf index 11b7425b63..76f94b259b 100644 --- a/test/Python/src/modal_models/ModalStateReset.lf +++ b/test/Python/src/modal_models/ModalStateReset.lf @@ -1,92 +1,91 @@ /** Modal Reactor Test. Tests reset of state variables in modes. */ target Python { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next + input next - output mode_switch - output count0 - output count1 - output count2 + output mode_switch + output count0 + output count1 + output count2 - state counter0 = 0 + state counter0 = 0 - reaction(next) -> count0 {= - print(f"Counter0: {self.counter0}") - count0.set(self.counter0) - self.counter0 += 1 - =} + reaction(next) -> count0 {= + print(f"Counter0: {self.counter0}") + count0.set(self.counter0) + self.counter0 += 1 + =} - initial mode One { - state counter1 = 0 - timer T1(0 msec, 250 msec) - reaction(reset) {= self.counter1 = 0 =} + initial mode One { + state counter1 = 0 + timer T1(0 msec, 250 msec) + reaction(reset) {= self.counter1 = 0 =} - reaction(T1) -> count1 {= - print(f"Counter1: {self.counter1}") - count1.set(self.counter1) - self.counter1 += 1 - =} + reaction(T1) -> count1 {= + print(f"Counter1: {self.counter1}") + count1.set(self.counter1) + self.counter1 += 1 + =} - reaction(next) -> reset(Two), mode_switch {= - print("Transitioning to mode Two (reset)") - mode_switch.set(1) - Two.set() - =} - } + reaction(next) -> reset(Two), mode_switch {= + print("Transitioning to mode Two (reset)") + mode_switch.set(1) + Two.set() + =} + } - mode Two { - state counter2 = -2 - timer T2(0 msec, 250 msec) - reaction(reset) {= self.counter2 = -2 =} + mode Two { + state counter2 = -2 + timer T2(0 msec, 250 msec) + reaction(reset) {= self.counter2 = -2 =} - reaction(T2) -> count2 {= - print(f"Counter2: {self.counter2}") - count2.set(self.counter2) - self.counter2 += 1 - =} + reaction(T2) -> count2 {= + print(f"Counter2: {self.counter2}") + count2.set(self.counter2) + self.counter2 += 1 + =} - reaction(next) -> history(One), mode_switch {= - print("Transitioning to mode One (continue)") - mode_switch.set(1) - One.set() - =} - } + reaction(next) -> history(One), mode_switch {= + print("Transitioning to mode One (continue)") + mode_switch.set(1) + One.set() + =} + } } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting(events_size = 4, trace = ( // keep-format - 0,0,0,0,0,1,0,0,0, - 250000000,0,0,0,0,1,1,0,0, - 250000000,0,0,0,0,1,2,0,0, - 250000000,0,0,0,0,1,3,0,0, - 250000000,1,1,1,0,1,4,0,0, - 0,0,1,0,0,0,4,1,-2, - 250000000,0,1,0,0,0,4,1,-1, - 250000000,0,1,0,0,0,4,1,0, - 250000000,0,1,0,0,0,4,1,1, - 250000000,1,1,1,1,0,4,1,2, - 250000000,0,1,0,1,1,5,0,2, - 250000000,0,1,0,1,1,6,0,2, - 250000000,0,1,0,1,1,7,0,2, - 250000000,1,1,1,2,1,8,0,2, - 0,0,1,0,2,0,8,1,-2, - 250000000,0,1,0,2,0,8,1,-1, - 250000000,0,1,0,2,0,8,1,0, - 250000000,0,1,0,2,0,8,1,1, - 250000000,1,1,1,3,0,8,1,2 - ), training = False) + modal = new Modal() + test = new TraceTesting(events_size = 4, trace = ( // keep-format + 0,0,0,0,0,1,0,0,0, + 250000000,0,0,0,0,1,1,0,0, + 250000000,0,0,0,0,1,2,0,0, + 250000000,0,0,0,0,1,3,0,0, + 250000000,1,1,1,0,1,4,0,0, + 0,0,1,0,0,0,4,1,-2, + 250000000,0,1,0,0,0,4,1,-1, + 250000000,0,1,0,0,0,4,1,0, + 250000000,0,1,0,0,0,4,1,1, + 250000000,1,1,1,1,0,4,1,2, + 250000000,0,1,0,1,1,5,0,2, + 250000000,0,1,0,1,1,6,0,2, + 250000000,0,1,0,1,1,7,0,2, + 250000000,1,1,1,2,1,8,0,2, + 0,0,1,0,2,0,8,1,-2, + 250000000,0,1,0,2,0,8,1,-1, + 250000000,0,1,0,2,0,8,1,0, + 250000000,0,1,0,2,0,8,1,1, + 250000000,1,1,1,3,0,8,1,2 + ), training = False) - modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events + modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalStateResetAuto.lf b/test/Python/src/modal_models/ModalStateResetAuto.lf index 492e12259b..ab09f7f325 100644 --- a/test/Python/src/modal_models/ModalStateResetAuto.lf +++ b/test/Python/src/modal_models/ModalStateResetAuto.lf @@ -1,88 +1,87 @@ /** Modal Reactor Test. Tests reset of state variables in modes. */ target Python { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next + input next - output mode_switch - output count0 - output count1 - output count2 + output mode_switch + output count0 + output count1 + output count2 - state counter0 = 0 + state counter0 = 0 - reaction(next) -> count0 {= - print(f"Counter0: {self.counter0}") - count0.set(self.counter0) - self.counter0 += 1 - =} + reaction(next) -> count0 {= + print(f"Counter0: {self.counter0}") + count0.set(self.counter0) + self.counter0 += 1 + =} - initial mode One { - state counter1 = 0 - timer T1(0 msec, 250 msec) - reaction(T1) -> count1 {= - print(f"Counter1: {self.counter1}") - count1.set(self.counter1) - self.counter1 += 1 - =} + initial mode One { + state counter1 = 0 + timer T1(0 msec, 250 msec) + reaction(T1) -> count1 {= + print(f"Counter1: {self.counter1}") + count1.set(self.counter1) + self.counter1 += 1 + =} - reaction(next) -> reset(Two), mode_switch {= - print("Transitioning to mode Two (reset)") - mode_switch.set(1) - Two.set() - =} - } + reaction(next) -> reset(Two), mode_switch {= + print("Transitioning to mode Two (reset)") + mode_switch.set(1) + Two.set() + =} + } - mode Two { - reset state counter2 = -2 - timer T2(0 msec, 250 msec) - reaction(T2) -> count2 {= - print(f"Counter2: {self.counter2}") - count2.set(self.counter2) - self.counter2 += 1 - =} + mode Two { + reset state counter2 = -2 + timer T2(0 msec, 250 msec) + reaction(T2) -> count2 {= + print(f"Counter2: {self.counter2}") + count2.set(self.counter2) + self.counter2 += 1 + =} - reaction(next) -> history(One), mode_switch {= - print("Transitioning to mode One (continue)") - mode_switch.set(1) - One.set() - =} - } + reaction(next) -> history(One), mode_switch {= + print("Transitioning to mode One (continue)") + mode_switch.set(1) + One.set() + =} + } } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting(events_size = 4, trace = ( // keep-format - 0,0,0,0,0,1,0,0,0, - 250000000,0,0,0,0,1,1,0,0, - 250000000,0,0,0,0,1,2,0,0, - 250000000,0,0,0,0,1,3,0,0, - 250000000,1,1,1,0,1,4,0,0, - 0,0,1,0,0,0,4,1,-2, - 250000000,0,1,0,0,0,4,1,-1, - 250000000,0,1,0,0,0,4,1,0, - 250000000,0,1,0,0,0,4,1,1, - 250000000,1,1,1,1,0,4,1,2, - 250000000,0,1,0,1,1,5,0,2, - 250000000,0,1,0,1,1,6,0,2, - 250000000,0,1,0,1,1,7,0,2, - 250000000,1,1,1,2,1,8,0,2, - 0,0,1,0,2,0,8,1,-2, - 250000000,0,1,0,2,0,8,1,-1, - 250000000,0,1,0,2,0,8,1,0, - 250000000,0,1,0,2,0,8,1,1, - 250000000,1,1,1,3,0,8,1,2 - ), training = False) + modal = new Modal() + test = new TraceTesting(events_size = 4, trace = ( // keep-format + 0,0,0,0,0,1,0,0,0, + 250000000,0,0,0,0,1,1,0,0, + 250000000,0,0,0,0,1,2,0,0, + 250000000,0,0,0,0,1,3,0,0, + 250000000,1,1,1,0,1,4,0,0, + 0,0,1,0,0,0,4,1,-2, + 250000000,0,1,0,0,0,4,1,-1, + 250000000,0,1,0,0,0,4,1,0, + 250000000,0,1,0,0,0,4,1,1, + 250000000,1,1,1,1,0,4,1,2, + 250000000,0,1,0,1,1,5,0,2, + 250000000,0,1,0,1,1,6,0,2, + 250000000,0,1,0,1,1,7,0,2, + 250000000,1,1,1,2,1,8,0,2, + 0,0,1,0,2,0,8,1,-2, + 250000000,0,1,0,2,0,8,1,-1, + 250000000,0,1,0,2,0,8,1,0, + 250000000,0,1,0,2,0,8,1,1, + 250000000,1,1,1,3,0,8,1,2 + ), training = False) - modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events + modal.mode_switch, modal.count0, modal.count1, modal.count2 -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/ModalTimers.lf b/test/Python/src/modal_models/ModalTimers.lf index 271a19ec38..9f92a876fb 100644 --- a/test/Python/src/modal_models/ModalTimers.lf +++ b/test/Python/src/modal_models/ModalTimers.lf @@ -1,67 +1,66 @@ /** Modal Reactor Test. Tests timers, their deactivation and reset in modes. */ target Python { - fast: false, - timeout: 4 sec + fast: false, + timeout: 4 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next + input next - output mode_switch - output timer1 - output timer2 + output mode_switch + output timer1 + output timer2 - initial mode One { - timer T1(0, 750 msec) - reaction(T1) -> timer1 {= - print(f"T1: at tag ({lf.time.logical_elapsed()}, {lf.tag().microstep})") - timer1.set(1) - =} + initial mode One { + timer T1(0, 750 msec) + reaction(T1) -> timer1 {= + print(f"T1: at tag ({lf.time.logical_elapsed()}, {lf.tag().microstep})") + timer1.set(1) + =} - reaction(next) -> reset(Two), mode_switch {= - print("Transitioning to mode Two (reset)") - mode_switch.set(1) - Two.set() - =} - } + reaction(next) -> reset(Two), mode_switch {= + print("Transitioning to mode Two (reset)") + mode_switch.set(1) + Two.set() + =} + } - mode Two { - timer T2(0, 750 msec) - reaction(T2) -> timer2 {= - print(f"T2: at tag ({lf.time.logical_elapsed()}, {lf.tag().microstep})") - timer2.set(1) - =} + mode Two { + timer T2(0, 750 msec) + reaction(T2) -> timer2 {= + print(f"T2: at tag ({lf.time.logical_elapsed()}, {lf.tag().microstep})") + timer2.set(1) + =} - reaction(next) -> history(One), mode_switch {= - print("Transitioning to mode One (continue)") - mode_switch.set(1) - One.set() - =} - } + reaction(next) -> history(One), mode_switch {= + print("Transitioning to mode One (continue)") + mode_switch.set(1) + One.set() + =} + } } main reactor { - timer stepper(1 sec, 1 sec) + timer stepper(1 sec, 1 sec) - modal = new Modal() - test = new TraceTesting(events_size = 3, trace = ( // keep-format - 0,0,0,1,1,0,0, - 750000000,0,0,1,1,0,0, - 250000000,1,1,0,1,0,0, - 0,0,1,0,1,1,1, - 750000000,0,1,0,1,1,1, - 250000000,1,1,0,1,0,1, - 500000000,0,1,1,1,0,1, - 500000000,1,1,0,1,0,1, - 0,0,1,0,1,1,1, - 750000000,0,1,0,1,1,1, - 250000000,1,1,0,1,0,1 - ), training = False) + modal = new Modal() + test = new TraceTesting(events_size = 3, trace = ( // keep-format + 0,0,0,1,1,0,0, + 750000000,0,0,1,1,0,0, + 250000000,1,1,0,1,0,0, + 0,0,1,0,1,1,1, + 750000000,0,1,0,1,1,1, + 250000000,1,1,0,1,0,1, + 500000000,0,1,1,1,0,1, + 500000000,1,1,0,1,0,1, + 0,0,1,0,1,1,1, + 750000000,0,1,0,1,1,1, + 250000000,1,1,0,1,0,1 + ), training = False) - modal.mode_switch, modal.timer1, modal.timer2 -> test.events + modal.mode_switch, modal.timer1, modal.timer2 -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change } diff --git a/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf b/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf index 3dd42f67ce..9eebec636f 100644 --- a/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf +++ b/test/Python/src/modal_models/MultipleOutputFeeder_2Connections.lf @@ -1,74 +1,72 @@ /** * Modal Reactor Test. * - * Tests if connections in the same reactor that have the same destination work - * if they are located in separate modes. + * Tests if connections in the same reactor that have the same destination work if they are located + * in separate modes. */ target Python { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next - output count + input next + output count - initial mode One { - counter1 = new Counter(period = 250 msec) - counter1.value -> count - reaction(next) -> reset(Two) {= Two.set() =} - } + initial mode One { + counter1 = new Counter(period = 250 msec) + counter1.value -> count + reaction(next) -> reset(Two) {= Two.set() =} + } - mode Two { - counter2 = new Counter(period = 100 msec) - counter2.value -> count - reaction(next) -> history(One) {= One.set() =} - } + mode Two { + counter2 = new Counter(period = 100 msec) + counter2.value -> count + reaction(next) -> history(One) {= One.set() =} + } } reactor Counter(period = 1 sec) { - output value + output value - timer t(0, period) - reset state curval = 0 + timer t(0, period) + reset state curval = 0 - reaction(t) -> value {= - value.set(self.curval) - self.curval += 1 - =} + reaction(t) -> value {= + value.set(self.curval) + self.curval += 1 + =} } main reactor { - timer stepper(500 msec, 500 msec) + timer stepper(500 msec, 500 msec) - modal = new Modal() - test = new TraceTesting(events_size = 1, trace = ( // keep-format - 0,1,0, - 250000000,1,1, - 250000000,1,2, - 0,1,0, - 100000000,1,1, - 100000000,1,2, - 100000000,1,3, - 100000000,1,4, - 100000000,1,5, - 250000000,1,3, - 250000000,1,4, - 0,1,0, - 100000000,1,1, - 100000000,1,2, - 100000000,1,3, - 100000000,1,4, - 100000000,1,5 - ), training = False) + modal = new Modal() + test = new TraceTesting(events_size = 1, trace = ( // keep-format + 0,1,0, + 250000000,1,1, + 250000000,1,2, + 0,1,0, + 100000000,1,1, + 100000000,1,2, + 100000000,1,3, + 100000000,1,4, + 100000000,1,5, + 250000000,1,3, + 250000000,1,4, + 0,1,0, + 100000000,1,1, + 100000000,1,2, + 100000000,1,3, + 100000000,1,4, + 100000000,1,5 + ), training = False) - modal.count -> test.events + modal.count -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change - # Print - reaction(modal.count) {= print(modal.count.value) =} + reaction(modal.count) {= print(modal.count.value) =} # Print } diff --git a/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf b/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf index 86f5668357..1b1c0429a1 100644 --- a/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf +++ b/test/Python/src/modal_models/MultipleOutputFeeder_ReactionConnections.lf @@ -1,77 +1,73 @@ /** * Modal Reactor Test. * - * Tests if a connection and a reaction in the same reactor can have the same - * destination if they are located in separate modes. + * Tests if a connection and a reaction in the same reactor can have the same destination if they + * are located in separate modes. */ target Python { - fast: false, - timeout: 2 sec + fast: false, + timeout: 2 sec } import TraceTesting from "util/TraceTesting.lf" reactor Modal { - input next - output count + input next + output count - initial mode One { - counter1 = new Counter(period = 250 msec) - counter1.value -> count - reaction(next) -> reset(Two) {= Two.set() =} - } + initial mode One { + counter1 = new Counter(period = 250 msec) + counter1.value -> count + reaction(next) -> reset(Two) {= Two.set() =} + } - mode Two { - counter2 = new Counter(period = 100 msec) - reaction(counter2.value) -> count {= - count.set(counter2.value.value * 10) - =} + mode Two { + counter2 = new Counter(period = 100 msec) + reaction(counter2.value) -> count {= count.set(counter2.value.value * 10) =} - reaction(next) -> history(One) {= One.set() =} - } + reaction(next) -> history(One) {= One.set() =} + } } reactor Counter(period = 1 sec) { - output value + output value - timer t(0, period) - reset state curval = 0 + timer t(0, period) + reset state curval = 0 - reaction(t) -> value {= - value.set(self.curval) - self.curval += 1 - =} + reaction(t) -> value {= + value.set(self.curval) + self.curval += 1 + =} } main reactor { - timer stepper(500 msec, 500 msec) + timer stepper(500 msec, 500 msec) - modal = new Modal() - test = new TraceTesting(events_size = 1, trace = ( // keep-format - 0,1,0, - 250000000,1,1, - 250000000,1,2, - 0,1,0, - 100000000,1,10, - 100000000,1,20, - 100000000,1,30, - 100000000,1,40, - 100000000,1,50, - 250000000,1,3, - 250000000,1,4, - 0,1,0, - 100000000,1,10, - 100000000,1,20, - 100000000,1,30, - 100000000,1,40, - 100000000,1,50 - ), training = False) + modal = new Modal() + test = new TraceTesting(events_size = 1, trace = ( // keep-format + 0,1,0, + 250000000,1,1, + 250000000,1,2, + 0,1,0, + 100000000,1,10, + 100000000,1,20, + 100000000,1,30, + 100000000,1,40, + 100000000,1,50, + 250000000,1,3, + 250000000,1,4, + 0,1,0, + 100000000,1,10, + 100000000,1,20, + 100000000,1,30, + 100000000,1,40, + 100000000,1,50 + ), training = False) - modal.count -> test.events + modal.count -> test.events - # Trigger mode change - reaction(stepper) -> modal.next {= modal.next.set(True) =} + reaction(stepper) -> modal.next {= modal.next.set(True) =} # Trigger mode change - # Print - reaction(modal.count) {= print(modal.count.value) =} + reaction(modal.count) {= print(modal.count.value) =} # Print } diff --git a/test/Python/src/modal_models/util/TraceTesting.lf b/test/Python/src/modal_models/util/TraceTesting.lf index 305ff31a5b..02781b42fe 100644 --- a/test/Python/src/modal_models/util/TraceTesting.lf +++ b/test/Python/src/modal_models/util/TraceTesting.lf @@ -2,61 +2,61 @@ target Python reactor TraceTesting(events_size = 0, trace = {= [] =}, training = False) { - input[events_size] events + input[events_size] events - state last_reaction_time = 0 - state trace_idx = 0 - state recorded_events = {= [] =} - state recorded_events_next = 0 + state last_reaction_time = 0 + state trace_idx = 0 + state recorded_events = {= [] =} + state recorded_events_next = 0 - reaction(startup) {= self.last_reaction_time = lf.time.logical() =} + reaction(startup) {= self.last_reaction_time = lf.time.logical() =} - reaction(events) {= - # Time passed since last reaction - curr_reaction_delay = lf.time.logical() - self.last_reaction_time + reaction(events) {= + # Time passed since last reaction + curr_reaction_delay = lf.time.logical() - self.last_reaction_time + + if self.training: + # Save the time + self.recorded_events.append(curr_reaction_delay) + else: + if self.trace_idx >= len(self.trace): + sys.stderr.write("ERROR: Trace Error: Current execution exceeds given trace.\n") + exit(1) + + trace_reaction_delay = self.trace[self.trace_idx] + self.trace_idx += 1 + + if curr_reaction_delay != trace_reaction_delay: + sys.stderr.write(f"ERROR: Trace Mismatch: Unexpected reaction timing. (delay: {curr_reaction_delay}, expected: {trace_reaction_delay})\n") + exit(2) + + for i in range(self.events_size): + curr_present = events[i].is_present + curr_value = events[i].value if self.training: - # Save the time - self.recorded_events.append(curr_reaction_delay) + # Save the event + self.recorded_events.append(curr_present) + self.recorded_events.append(curr_value) else: - if self.trace_idx >= len(self.trace): - sys.stderr.write("ERROR: Trace Error: Current execution exceeds given trace.\n") - exit(1) - - trace_reaction_delay = self.trace[self.trace_idx] + trace_present = self.trace[self.trace_idx] + self.trace_idx += 1 + trace_value = self.trace[self.trace_idx] self.trace_idx += 1 - if curr_reaction_delay != trace_reaction_delay: - sys.stderr.write(f"ERROR: Trace Mismatch: Unexpected reaction timing. (delay: {curr_reaction_delay}, expected: {trace_reaction_delay})\n") - exit(2) - - for i in range(self.events_size): - curr_present = events[i].is_present - curr_value = events[i].value - - if self.training: - # Save the event - self.recorded_events.append(curr_present) - self.recorded_events.append(curr_value) - else: - trace_present = self.trace[self.trace_idx] - self.trace_idx += 1 - trace_value = self.trace[self.trace_idx] - self.trace_idx += 1 - - if trace_present != curr_present: - sys.stderr.write(f"ERROR: Trace Mismatch: Unexpected event presence. (event: {i}, presence: {curr_present}, expected: {trace_present})\n") - exit(3) - elif curr_present and trace_value != curr_value: - sys.stderr.write(f"ERROR: Trace Mismatch: Unexpected event presence. (event: {i}, value: {curr_value}, expected: {trace_value})\n") - exit(4) - - self.last_reaction_time = lf.time.logical() - =} - - reaction(shutdown) {= - if self.training: - print(f"Recorded event trace ({self.recorded_events_next}):") - print(self.recorded_events) - =} + if trace_present != curr_present: + sys.stderr.write(f"ERROR: Trace Mismatch: Unexpected event presence. (event: {i}, presence: {curr_present}, expected: {trace_present})\n") + exit(3) + elif curr_present and trace_value != curr_value: + sys.stderr.write(f"ERROR: Trace Mismatch: Unexpected event presence. (event: {i}, value: {curr_value}, expected: {trace_value})\n") + exit(4) + + self.last_reaction_time = lf.time.logical() + =} + + reaction(shutdown) {= + if self.training: + print(f"Recorded event trace ({self.recorded_events_next}):") + print(self.recorded_events) + =} } diff --git a/test/Python/src/multiport/BankIndexInitializer.lf b/test/Python/src/multiport/BankIndexInitializer.lf index 52ef58bb1d..7a717e3c57 100644 --- a/test/Python/src/multiport/BankIndexInitializer.lf +++ b/test/Python/src/multiport/BankIndexInitializer.lf @@ -4,34 +4,34 @@ target Python preamble {= table = [4, 3, 2, 1] =} reactor Source(bank_index = 0, value = 0) { - output out + output out - reaction(startup) -> out {= out.set(self.value) =} + reaction(startup) -> out {= out.set(self.value) =} } reactor Sink(width = 4) { - input[width] _in - state received = False + input[width] _in + state received = False - reaction(_in) {= - for (idx, port) in enumerate(_in): - if port.is_present is True: - print("Received on channel {:d}: {:d}".format(idx, port.value)) - self.received = True - if port.value != 4 - idx: - sys.stderr.write("ERROR: expected {:d}\n".format(4 - idx)) - exit(1) - =} + reaction(_in) {= + for (idx, port) in enumerate(_in): + if port.is_present is True: + print("Received on channel {:d}: {:d}".format(idx, port.value)) + self.received = True + if port.value != 4 - idx: + sys.stderr.write("ERROR: expected {:d}\n".format(4 - idx)) + exit(1) + =} - reaction(shutdown) {= - if self.received is False: - sys.stderr.write("ERROR: Sink received no data\n") - exit(1) - =} + reaction(shutdown) {= + if self.received is False: + sys.stderr.write("ERROR: Sink received no data\n") + exit(1) + =} } main reactor(width = 4) { - source = new[width] Source(value = {= table[bank_index] =}) - sink = new Sink(width = width) - source.out -> sink._in + source = new[width] Source(value = {= table[bank_index] =}) + sink = new Sink(width = width) + source.out -> sink._in } diff --git a/test/Python/src/multiport/BankReactionsInContainer.lf b/test/Python/src/multiport/BankReactionsInContainer.lf index 7316463c3d..147eddfef4 100644 --- a/test/Python/src/multiport/BankReactionsInContainer.lf +++ b/test/Python/src/multiport/BankReactionsInContainer.lf @@ -1,68 +1,66 @@ -/** - * This tests an output that is broadcast back to a multiport input of a bank. - */ +/** This tests an output that is broadcast back to a multiport input of a bank. */ target Python { - timeout: 1 sec + timeout: 1 sec } reactor R(bank_index = 0) { - output[2] out - input[2] inp - state received = False + output[2] out + input[2] inp + state received = False - reaction(startup) -> out {= - for (i, p) in enumerate(out): - value = self.bank_index * 2 + i - p.set(value) - print(f"Inner sending {value} to bank {self.bank_index} channel {i}.") - =} + reaction(startup) -> out {= + for (i, p) in enumerate(out): + value = self.bank_index * 2 + i + p.set(value) + print(f"Inner sending {value} to bank {self.bank_index} channel {i}.") + =} - reaction(inp) {= - for (i, p) in enumerate(inp): - if p.is_present: - print(f"Inner received {p.value} in bank {self.bank_index}, channel {i}") - self.received = True - if p.value != (self.bank_index * 2 + i): - sys.stderr.write(f"ERROR: Expected {self.bank_index * 2 + i}.\n") - exit(1) - =} + reaction(inp) {= + for (i, p) in enumerate(inp): + if p.is_present: + print(f"Inner received {p.value} in bank {self.bank_index}, channel {i}") + self.received = True + if p.value != (self.bank_index * 2 + i): + sys.stderr.write(f"ERROR: Expected {self.bank_index * 2 + i}.\n") + exit(1) + =} - reaction(shutdown) {= - print("Inner shutdown invoked.") - if self.received is not True: - sys.stderr.write(f"ERROR: Received no input.") - exit(1) - =} + reaction(shutdown) {= + print("Inner shutdown invoked.") + if self.received is not True: + sys.stderr.write(f"ERROR: Received no input.") + exit(1) + =} } main reactor { - s = new[2] R() - state received = False + s = new[2] R() + state received = False - reaction(startup) -> s.inp {= - count = 0 - for i in range(len(s)): - for (j, p) in enumerate(s[i].inp): - print(f"Sending {count} to bank {i} channel {j}.") - p.set(count) - count+=1 - =} + reaction(startup) -> s.inp {= + count = 0 + for i in range(len(s)): + for (j, p) in enumerate(s[i].inp): + print(f"Sending {count} to bank {i} channel {j}.") + p.set(count) + count+=1 + =} - reaction(s.out) {= - for i in range(len(s)): - for (j, p) in enumerate(s[i].out): - if p.is_present: - print(f"Outer received {p.value} on bank {i} channel {j}.") - self.received = True - if p.value != i * 2 + j: - sys.stderr.write(f"ERROR: Expected {i*2+j}.\n") - exit(1) - =} + reaction(s.out) {= + for i in range(len(s)): + for (j, p) in enumerate(s[i].out): + if p.is_present: + print(f"Outer received {p.value} on bank {i} channel {j}.") + self.received = True + if p.value != i * 2 + j: + sys.stderr.write(f"ERROR: Expected {i*2+j}.\n") + exit(1) + =} - reaction(shutdown) {= - print("Outer shutdown invoked.") - if self.received is not True: - sys.stderr.write(f"ERROR: Received no input.\n") - exit(1) - =} + reaction(shutdown) {= + print("Outer shutdown invoked.") + if self.received is not True: + sys.stderr.write(f"ERROR: Received no input.\n") + exit(1) + =} } diff --git a/test/Python/src/multiport/BankToBank.lf b/test/Python/src/multiport/BankToBank.lf index 6e3ddc734d..c1924f6a53 100644 --- a/test/Python/src/multiport/BankToBank.lf +++ b/test/Python/src/multiport/BankToBank.lf @@ -1,42 +1,42 @@ # Check bank of reactors sending to bank of reactors. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(bank_index = 0) { - timer t(0, 200 msec) - output out - state s = 0 + timer t(0, 200 msec) + output out + state s = 0 - reaction(t) -> out {= - out.set(self.s) - self.s += self.bank_index - =} + reaction(t) -> out {= + out.set(self.s) + self.s += self.bank_index + =} } reactor Destination(bank_index = 0) { - state s = 0 - input _in + state s = 0 + input _in - reaction(_in) {= - print("Destination " + str(self.bank_index) + " received: " + str(_in.value)) - if (_in.value != self.s): - sys.stderr.write("ERROR: Expected " + str(self.s)) - exit(1) - self.s += self.bank_index - =} + reaction(_in) {= + print("Destination " + str(self.bank_index) + " received: " + str(_in.value)) + if (_in.value != self.s): + sys.stderr.write("ERROR: Expected " + str(self.s)) + exit(1) + self.s += self.bank_index + =} - reaction(shutdown) {= - if self.s == 0 and self.bank_index != 0: - sys.stderr.write("ERROR: Destination " + self.bank_index + " received no input!") - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.s == 0 and self.bank_index != 0: + sys.stderr.write("ERROR: Destination " + self.bank_index + " received no input!") + exit(1) + print("Success.") + =} } main reactor BankToBank(width = 4) { - a = new[width] Source() - b = new[width] Destination() - a.out -> b._in + a = new[width] Source() + b = new[width] Destination() + a.out -> b._in } diff --git a/test/Python/src/multiport/BankToBankMultiport.lf b/test/Python/src/multiport/BankToBankMultiport.lf index f335e53858..ace36af77f 100644 --- a/test/Python/src/multiport/BankToBankMultiport.lf +++ b/test/Python/src/multiport/BankToBankMultiport.lf @@ -1,50 +1,50 @@ # Check bank of reactors sending to bank of reactors with multiports. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width = 1) { - timer t(0, 200 msec) - output[width] out - state s = 0 - - reaction(t) -> out {= - for port in out: - port.set(self.s) - self.s += 1 - =} + timer t(0, 200 msec) + output[width] out + state s = 0 + + reaction(t) -> out {= + for port in out: + port.set(self.s) + self.s += 1 + =} } reactor Destination(width = 1) { - state s = 6 - input[width] _in - - reaction(_in) {= - sm = 0 - for port in _in: - if port.is_present: - sm += port.value - - print("Sum of received: ", sm) - if sm != self.s: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) - exit(1) - - self.s += 16 - =} - - reaction(shutdown) {= - if self.s <= 6: - sys.stderr.write("ERROR: Destination received no input!\n") - exit(1) - - print("Success.") - =} + state s = 6 + input[width] _in + + reaction(_in) {= + sm = 0 + for port in _in: + if port.is_present: + sm += port.value + + print("Sum of received: ", sm) + if sm != self.s: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) + exit(1) + + self.s += 16 + =} + + reaction(shutdown) {= + if self.s <= 6: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + + print("Success.") + =} } main reactor BankToBankMultiport(bank_width = 4) { - a = new[bank_width] Source(width = 4) - b = new[bank_width] Destination(width = 4) - a.out -> b._in + a = new[bank_width] Source(width = 4) + b = new[bank_width] Destination(width = 4) + a.out -> b._in } diff --git a/test/Python/src/multiport/BankToBankMultiportAfter.lf b/test/Python/src/multiport/BankToBankMultiportAfter.lf index 9d6e946122..4f42b8dac2 100644 --- a/test/Python/src/multiport/BankToBankMultiportAfter.lf +++ b/test/Python/src/multiport/BankToBankMultiportAfter.lf @@ -1,13 +1,13 @@ # Check bank of reactors sending to bank of reactors with multiports. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Source, Destination from "BankToBankMultiport.lf" main reactor BankToBankMultiportAfter(bank_width = 4) { - a = new[bank_width] Source(width = 4) - b = new[bank_width] Destination(width = 4) - a.out -> b._in after 200 msec + a = new[bank_width] Source(width = 4) + b = new[bank_width] Destination(width = 4) + a.out -> b._in after 200 msec } diff --git a/test/Python/src/multiport/BankToMultiport.lf b/test/Python/src/multiport/BankToMultiport.lf index 769e0ea2fc..45719b6a13 100644 --- a/test/Python/src/multiport/BankToMultiport.lf +++ b/test/Python/src/multiport/BankToMultiport.lf @@ -2,34 +2,34 @@ target Python reactor Source(bank_index = 0) { - output out + output out - reaction(startup) -> out {= out.set(self.bank_index) =} + reaction(startup) -> out {= out.set(self.bank_index) =} } reactor Sink(width = 4) { - input[width] _in - state received = False + input[width] _in + state received = False - reaction(_in) {= - for (idx, port) in enumerate(_in): - if port.is_present is True: - print("Received on channel {:d}: {:d}".format(idx, port.value)) - self.received = True - if port.value != idx: - sys.stderr.write("ERROR: expected {:d}\n".format(idx)) - exit(1) - =} + reaction(_in) {= + for (idx, port) in enumerate(_in): + if port.is_present is True: + print("Received on channel {:d}: {:d}".format(idx, port.value)) + self.received = True + if port.value != idx: + sys.stderr.write("ERROR: expected {:d}\n".format(idx)) + exit(1) + =} - reaction(shutdown) {= - if self.received is False: - sys.stderr.write("ERROR: Sink received no data\n") - exit(1) - =} + reaction(shutdown) {= + if self.received is False: + sys.stderr.write("ERROR: Sink received no data\n") + exit(1) + =} } main reactor BankToMultiport(width = 5) { - source = new[width] Source() - sink = new Sink(width = width) - source.out -> sink._in + source = new[width] Source() + sink = new Sink(width = width) + source.out -> sink._in } diff --git a/test/Python/src/multiport/Broadcast.lf b/test/Python/src/multiport/Broadcast.lf index 2e507d607f..09643f3679 100644 --- a/test/Python/src/multiport/Broadcast.lf +++ b/test/Python/src/multiport/Broadcast.lf @@ -1,40 +1,40 @@ target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(value = 42) { - output out + output out - reaction(startup) -> out {= out.set(self.value) =} + reaction(startup) -> out {= out.set(self.value) =} } reactor Destination(bank_index = 0, delay = 0) { - input _in - state received = False + input _in + state received = False - reaction(_in) {= - print(f"Destination {self.bank_index} received {_in.value}.") - if (_in.value != 42): - sys.stderr.write("ERROR: Expected 42.\n") - exit(1) + reaction(_in) {= + print(f"Destination {self.bank_index} received {_in.value}.") + if (_in.value != 42): + sys.stderr.write("ERROR: Expected 42.\n") + exit(1) - if lf.time.logical_elapsed() != self.delay: - sys.stderr.write(f"ERROR: Expected to receive input after {self.delay/1000000000} second(s).\n") - exit(2) - self.received = True - =} + if lf.time.logical_elapsed() != self.delay: + sys.stderr.write(f"ERROR: Expected to receive input after {self.delay/1000000000} second(s).\n") + exit(2) + self.received = True + =} - reaction(shutdown) {= - if self.received is not True: - sys.stderr.write(f"ERROR: Destination {self.bank_index} received no input!\n") - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.received is not True: + sys.stderr.write(f"ERROR: Destination {self.bank_index} received no input!\n") + exit(1) + print("Success.") + =} } main reactor { - a = new Source() - b = new[4] Destination() - (a.out)+ -> b._in + a = new Source() + b = new[4] Destination() + (a.out)+ -> b._in } diff --git a/test/Python/src/multiport/BroadcastMultipleAfter.lf b/test/Python/src/multiport/BroadcastMultipleAfter.lf index 9fc327e6fd..eba9455f39 100644 --- a/test/Python/src/multiport/BroadcastMultipleAfter.lf +++ b/test/Python/src/multiport/BroadcastMultipleAfter.lf @@ -1,39 +1,39 @@ target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Source from "Broadcast.lf" reactor Destination(bank_index = 0, delay = 0) { - input _in - state received = False + input _in + state received = False - reaction(_in) {= - print(f"Destination {self.bank_index} received {_in.value}.") - expected = (self.bank_index % 3) + 1 - if (_in.value != expected): - sys.stderr.write("ERROR: Expected 42.\n") - exit(1) + reaction(_in) {= + print(f"Destination {self.bank_index} received {_in.value}.") + expected = (self.bank_index % 3) + 1 + if (_in.value != expected): + sys.stderr.write("ERROR: Expected 42.\n") + exit(1) - if lf.time.logical_elapsed() != self.delay: - sys.stderr.write(f"ERROR: Expected to receive input after {self.delay/1000000000} second(s).\n") - exit(2) - self.received = True - =} + if lf.time.logical_elapsed() != self.delay: + sys.stderr.write(f"ERROR: Expected to receive input after {self.delay/1000000000} second(s).\n") + exit(2) + self.received = True + =} - reaction(shutdown) {= - if self.received is not True: - sys.stderr.write(f"ERROR: Destination {self.bank_index} received no input!\n") - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.received is not True: + sys.stderr.write(f"ERROR: Destination {self.bank_index} received no input!\n") + exit(1) + print("Success.") + =} } main reactor { - a1 = new Source(value = 1) - a2 = new Source(value = 2) - a3 = new Source(value = 3) - b = new[9] Destination(delay = 1 sec) - (a1.out, a2.out, a3.out)+ -> b._in after 1 sec + a1 = new Source(value = 1) + a2 = new Source(value = 2) + a3 = new Source(value = 3) + b = new[9] Destination(delay = 1 sec) + (a1.out, a2.out, a3.out)+ -> b._in after 1 sec } diff --git a/test/Python/src/multiport/MultiportFromBank.lf b/test/Python/src/multiport/MultiportFromBank.lf index 92d9363df5..f1ca4769ee 100644 --- a/test/Python/src/multiport/MultiportFromBank.lf +++ b/test/Python/src/multiport/MultiportFromBank.lf @@ -1,43 +1,41 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than -# the width of the sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +# sending port. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(check_override = 0, bank_index = 0) { - output out + output out - reaction(startup) -> out {= - out.set(self.bank_index * self.check_override) - =} + reaction(startup) -> out {= out.set(self.bank_index * self.check_override) =} } reactor Destination { - input[3] _in - state received = 0 - - reaction(_in) {= - for (idx, port) in enumerate(_in): - print("Destination channel " + str(idx) + " received " + str(port.value)) - if idx != port.value: - sys.stderr.write("ERROR: Expected " + str(idx)) - exit(1) - - self.received = True - =} - - reaction(shutdown) {= - if self.received is False: - sys.stderr.write("ERROR: Destination received no input!\n") + input[3] _in + state received = 0 + + reaction(_in) {= + for (idx, port) in enumerate(_in): + print("Destination channel " + str(idx) + " received " + str(port.value)) + if idx != port.value: + sys.stderr.write("ERROR: Expected " + str(idx)) exit(1) - print("Success.") - =} + self.received = True + =} + + reaction(shutdown) {= + if self.received is False: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + + print("Success.") + =} } main reactor MultiportFromBank { - a = new[3] Source(check_override = 1) - b = new Destination() - a.out -> b._in + a = new[3] Source(check_override = 1) + b = new Destination() + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportFromBankHierarchy.lf b/test/Python/src/multiport/MultiportFromBankHierarchy.lf index 27ecb3c80b..d47481b817 100644 --- a/test/Python/src/multiport/MultiportFromBankHierarchy.lf +++ b/test/Python/src/multiport/MultiportFromBankHierarchy.lf @@ -1,26 +1,26 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than -# the width of the sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +# sending port. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Destination from "MultiportFromBank.lf" reactor Source(bank_index = 0) { - output out + output out - reaction(startup) -> out {= out.set(self.bank_index) =} + reaction(startup) -> out {= out.set(self.bank_index) =} } reactor Container { - output[3] out - s = new[3] Source() - s.out -> out + output[3] out + s = new[3] Source() + s.out -> out } main reactor MultiportFromBankHierarchy { - a = new Container() - b = new Destination() - a.out -> b._in + a = new Container() + b = new Destination() + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportFromHierarchy.lf b/test/Python/src/multiport/MultiportFromHierarchy.lf index 4116587f01..342ae198c3 100644 --- a/test/Python/src/multiport/MultiportFromHierarchy.lf +++ b/test/Python/src/multiport/MultiportFromHierarchy.lf @@ -1,60 +1,59 @@ -# Check multiport output to multiport input, where the former is a hierarchical -# reactor. +# Check multiport output to multiport input, where the former is a hierarchical reactor. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[4] out - state s = 0 - - reaction(t) -> out {= - for port in out: - port.set(self.s) - self.s = self.s + 1 - =} + timer t(0, 200 msec) + output[4] out + state s = 0 + + reaction(t) -> out {= + for port in out: + port.set(self.s) + self.s = self.s + 1 + =} } reactor Destination { - state s = 6 - input[4] _in - - reaction(_in) {= - sm = 0 - for port in _in: - if port.is_present: - sm += port.value - print("Sum of received: " + str(sm)) - if (sm != self.s): - sys.stderr.write("ERROR: Expected " + str(self.s) + ".\n") - exit(1) - self.s += 16 - =} - - reaction(shutdown) {= - if self.s <= 6: - sys.stderr.write("ERROR: Destination received no input!\n") - exit(1) - print("Success.") - =} + state s = 6 + input[4] _in + + reaction(_in) {= + sm = 0 + for port in _in: + if port.is_present: + sm += port.value + print("Sum of received: " + str(sm)) + if (sm != self.s): + sys.stderr.write("ERROR: Expected " + str(self.s) + ".\n") + exit(1) + self.s += 16 + =} + + reaction(shutdown) {= + if self.s <= 6: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + print("Success.") + =} } reactor Container { - output[4] out - src = new InsideContainer() - src.out -> out + output[4] out + src = new InsideContainer() + src.out -> out } reactor InsideContainer { - output[4] out - src = new Source() - src.out -> out + output[4] out + src = new Source() + src.out -> out } main reactor MultiportFromHierarchy { - a = new Container() - b = new Destination() - a.out -> b._in + a = new Container() + b = new Destination() + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportFromReaction.lf b/test/Python/src/multiport/MultiportFromReaction.lf index 05b280b126..2b8266cffc 100644 --- a/test/Python/src/multiport/MultiportFromReaction.lf +++ b/test/Python/src/multiport/MultiportFromReaction.lf @@ -1,45 +1,45 @@ # Check reaction to multiport input of a contained reactor. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Destination(width = 1) { - state s = 6 - input[width] _in + state s = 6 + input[width] _in - reaction(_in) {= - sm = 0; - for port in _in: - if port.is_present: - sm += port.value - print("Sum of received: ", sm) - if sm != self.s: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) - exit(1) + reaction(_in) {= + sm = 0; + for port in _in: + if port.is_present: + sm += port.value + print("Sum of received: ", sm) + if sm != self.s: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) + exit(1) - self.s += 16 - =} + self.s += 16 + =} - reaction(shutdown) {= - if self.s <= 6: - sys.stderr.write("ERROR: Destination received no input!\n") - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.s <= 6: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + print("Success.") + =} } main reactor MultiportFromReaction { - timer t(0, 200 msec) - state s = 0 - b = new Destination(width = 4) + timer t(0, 200 msec) + state s = 0 + b = new Destination(width = 4) - reaction(t) -> b._in {= - for (idx, port) in enumerate(b._in): - print("Before SET, b.in[{:d}].is_present has value {:d}".format(idx, port.is_present)) - port.set(self.s) - self.s += 1 - print("AFTER set, b.in[{:d}].is_present has value {:d}".format(idx, port.is_present)) - print("AFTER set, b.in[{:d}].value has value {:d}".format(idx, port.value)) - =} + reaction(t) -> b._in {= + for (idx, port) in enumerate(b._in): + print("Before SET, b.in[{:d}].is_present has value {:d}".format(idx, port.is_present)) + port.set(self.s) + self.s += 1 + print("AFTER set, b.in[{:d}].is_present has value {:d}".format(idx, port.is_present)) + print("AFTER set, b.in[{:d}].value has value {:d}".format(idx, port.value)) + =} } diff --git a/test/Python/src/multiport/MultiportIn.lf b/test/Python/src/multiport/MultiportIn.lf index 35bdee7341..9045be7792 100644 --- a/test/Python/src/multiport/MultiportIn.lf +++ b/test/Python/src/multiport/MultiportIn.lf @@ -1,64 +1,64 @@ -# This is a version fo the Threaded test that uses a multiport input at the -# destination. Its purpose is to test multiport inputs. +# This is a version fo the Threaded test that uses a multiport input at the destination. Its purpose +# is to test multiport inputs. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output out - state s = 0 + timer t(0, 200 msec) + output out + state s = 0 - reaction(t) -> out {= - out.set(self.s) - self.s+=1 - =} + reaction(t) -> out {= + out.set(self.s) + self.s+=1 + =} } reactor Computation { - input _in - output out + input _in + output out - reaction(_in) -> out {= out.set(_in.value) =} + reaction(_in) -> out {= out.set(_in.value) =} } reactor Destination { - state s = 0 - input[4] _in + state s = 0 + input[4] _in - reaction(_in) {= - sum = 0 - for port in _in: - sum += port.value + reaction(_in) {= + sum = 0 + for port in _in: + sum += port.value - print("Sum of received: " + str(sum)) - if sum != self.s: - sys.stderr.write("ERROR: Expected " + str(self.s)) - exit(1) + print("Sum of received: " + str(sum)) + if sum != self.s: + sys.stderr.write("ERROR: Expected " + str(self.s)) + exit(1) - self.s += 4 - =} + self.s += 4 + =} - reaction(shutdown) {= - if self.s == 0: - sys.stderr.write("ERROR: Destination received no input!") - exit(1) + reaction(shutdown) {= + if self.s == 0: + sys.stderr.write("ERROR: Destination received no input!") + exit(1) - print("Success.") - =} + print("Success.") + =} } main reactor MultiportIn { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination() - a.out -> t1._in - a.out -> t2._in - a.out -> t3._in - a.out -> t4._in - t1.out, t2.out, t3.out, t4.out -> b._in + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination() + a.out -> t1._in + a.out -> t2._in + a.out -> t3._in + a.out -> t4._in + t1.out, t2.out, t3.out, t4.out -> b._in } diff --git a/test/Python/src/multiport/MultiportInParameterized.lf b/test/Python/src/multiport/MultiportInParameterized.lf index 28b15808e3..206fa512ac 100644 --- a/test/Python/src/multiport/MultiportInParameterized.lf +++ b/test/Python/src/multiport/MultiportInParameterized.lf @@ -1,63 +1,63 @@ -# This is a version of the Threaded test that uses a multiport input at the -# destination. Its purpose is to test multiport inputs. +# This is a version of the Threaded test that uses a multiport input at the destination. Its purpose +# is to test multiport inputs. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output out - state s = 0 - - reaction(t) -> out {= - out.set(self.s) - self.s += 1 - =} + timer t(0, 200 msec) + output out + state s = 0 + + reaction(t) -> out {= + out.set(self.s) + self.s += 1 + =} } reactor Computation { - input _in - output out + input _in + output out - reaction(_in) -> out {= out.set(_in.value) =} + reaction(_in) -> out {= out.set(_in.value) =} } reactor Destination(width = 1) { - state s = 0 - input[width] _in - - reaction(_in) {= - sm = 0 - for port in _in: - sm += port.value - print("Sum of received: ", sm) - if sm != self.s: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) - exit(1) - self.s += 4 - =} - - reaction(shutdown) {= - if self.s == 0: - sys.stderr.write("ERROR: Destination received no input!\n") - exit(1) - print("Success."); - =} + state s = 0 + input[width] _in + + reaction(_in) {= + sm = 0 + for port in _in: + sm += port.value + print("Sum of received: ", sm) + if sm != self.s: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) + exit(1) + self.s += 4 + =} + + reaction(shutdown) {= + if self.s == 0: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + print("Success."); + =} } main reactor MultiportInParameterized { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination(width = 4) - a.out -> t1._in - a.out -> t2._in - a.out -> t3._in - a.out -> t4._in - # I.e.: t1.out -> b._in[0]; t2.out -> b._in[1]; t3.out -> b._in[2]; dt4.out - # -> b._in[3]; - t1.out, t2.out, t3.out, t4.out -> b._in + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination(width = 4) + a.out -> t1._in + a.out -> t2._in + a.out -> t3._in + a.out -> t4._in + # I.e.: t1.out -> b._in[0]; t2.out -> b._in[1]; t3.out -> b._in[2]; dt4.out + # -> b._in[3]; + t1.out, t2.out, t3.out, t4.out -> b._in } diff --git a/test/Python/src/multiport/MultiportMutableInput.lf b/test/Python/src/multiport/MultiportMutableInput.lf index f931900ef7..a8e15b8bd6 100644 --- a/test/Python/src/multiport/MultiportMutableInput.lf +++ b/test/Python/src/multiport/MultiportMutableInput.lf @@ -1,47 +1,46 @@ -# Source produces a ints on a multiport, which it passes to Scale. Scale -# requests a writable copy. It modifies it and passes it to Print. It gets freed -# after Print is done with it. +# Source produces a ints on a multiport, which it passes to Scale. Scale requests a writable copy. +# It modifies it and passes it to Print. It gets freed after Print is done with it. target Python reactor Source { - output[2] out + output[2] out - reaction(startup) -> out {= - out[0].set(21) - out[1].set(42) - =} + reaction(startup) -> out {= + out[0].set(21) + out[1].set(42) + =} } reactor Print(scale = 1) { # The scale parameter is just for testing. - input[2] _in + input[2] _in - reaction(_in) {= - expected = 42 - for (idx, port) in enumerate(_in): - print("Received on channel {:d}: ".format(idx), port.value) - if port.value != expected: - sys.stderr.write("ERROR: Expected {:d}!\n".format(expected)) - exit(1) - expected *= 2 - =} + reaction(_in) {= + expected = 42 + for (idx, port) in enumerate(_in): + print("Received on channel {:d}: ".format(idx), port.value) + if port.value != expected: + sys.stderr.write("ERROR: Expected {:d}!\n".format(expected)) + exit(1) + expected *= 2 + =} } reactor Scale(scale = 2) { - mutable input[2] _in - output[2] out + mutable input[2] _in + output[2] out - reaction(_in) -> out {= - for (idx, port) in enumerate(_in): - # Modify the input, allowed because mutable. - port.value *= self.scale - out[idx].set(port.value) - =} + reaction(_in) -> out {= + for (idx, port) in enumerate(_in): + # Modify the input, allowed because mutable. + port.value *= self.scale + out[idx].set(port.value) + =} } main reactor MultiportMutableInput { - s = new Source() - c = new Scale() - p = new Print(scale = 2) - s.out -> c._in - c.out -> p._in + s = new Source() + c = new Scale() + p = new Print(scale = 2) + s.out -> c._in + c.out -> p._in } diff --git a/test/Python/src/multiport/MultiportMutableInputArray.lf b/test/Python/src/multiport/MultiportMutableInputArray.lf index 9efa3eeebf..9e6a7630de 100644 --- a/test/Python/src/multiport/MultiportMutableInputArray.lf +++ b/test/Python/src/multiport/MultiportMutableInputArray.lf @@ -1,46 +1,45 @@ -# Source produces a list on a multiport, which it passes to Scale. Scale -# requests a writable copy, which, instead of copying, it just gets ownership of -# the original list. It modifies it and passes it to Print. It gets freed after -# Print is done with it. +# Source produces a list on a multiport, which it passes to Scale. Scale requests a writable copy, +# which, instead of copying, it just gets ownership of the original list. It modifies it and passes +# it to Print. It gets freed after Print is done with it. target Python reactor Source { - output[2] out + output[2] out - reaction(startup) -> out {= - out[0].set([0,1,2]) - out[1].set([3,4,5]) - =} + reaction(startup) -> out {= + out[0].set([0,1,2]) + out[1].set([3,4,5]) + =} } reactor Print(scale = 1) { # The scale parameter is just for testing. - input[2] _in + input[2] _in - reaction(_in) {= - for (idx, port) in enumerate(_in): - print("Received on channel ", port.value) - if port.value != [(self.scale*i) for i in range(3*idx,(3*idx)+3)]: - sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") - exit(1) - =} + reaction(_in) {= + for (idx, port) in enumerate(_in): + print("Received on channel ", port.value) + if port.value != [(self.scale*i) for i in range(3*idx,(3*idx)+3)]: + sys.stderr.write("ERROR: Value received by Print does not match expectation!\n") + exit(1) + =} } reactor Scale(scale = 2) { - mutable input[2] _in - output[2] out + mutable input[2] _in + output[2] out - reaction(_in) -> out {= - for (idx, port) in enumerate(_in): - if port.is_present: - port.value = [value*self.scale for value in port.value] - out[idx].set(port.value) - =} + reaction(_in) -> out {= + for (idx, port) in enumerate(_in): + if port.is_present: + port.value = [value*self.scale for value in port.value] + out[idx].set(port.value) + =} } main reactor MultiportMutableInputArray { - s = new Source() - c = new Scale() - p = new Print(scale = 2) - s.out -> c._in - c.out -> p._in + s = new Source() + c = new Scale() + p = new Print(scale = 2) + s.out -> c._in + c.out -> p._in } diff --git a/test/Python/src/multiport/MultiportOut.lf b/test/Python/src/multiport/MultiportOut.lf index 3d29c5188a..0e84fed165 100644 --- a/test/Python/src/multiport/MultiportOut.lf +++ b/test/Python/src/multiport/MultiportOut.lf @@ -1,63 +1,63 @@ # Check multiport capabilities on Outputs. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[4] out - state s = 0 + timer t(0, 200 msec) + output[4] out + state s = 0 - reaction(t) -> out {= - for port in out: - port.set(self.s) + reaction(t) -> out {= + for port in out: + port.set(self.s) - self.s+=1 - =} + self.s+=1 + =} } reactor Computation { - input _in - output out + input _in + output out - reaction(_in) -> out {= out.set(_in.value) =} + reaction(_in) -> out {= out.set(_in.value) =} } reactor Destination { - state s = 0 - input[4] _in - - reaction(_in) {= - sum = 0 - for port in _in: - if port.is_present: - sum += port.value - - print("Sum of received: " + str(sum)) - if sum != self.s: - sys.stderr.write("ERROR: Expected " + str(self.s)) - exit(1) - - self.s += 4 - =} - - reaction(shutdown) {= - if self.s == 0: - sys.stderr.write("ERROR: Destination received no input!") - exit(1) - - print("Success.") - =} + state s = 0 + input[4] _in + + reaction(_in) {= + sum = 0 + for port in _in: + if port.is_present: + sum += port.value + + print("Sum of received: " + str(sum)) + if sum != self.s: + sys.stderr.write("ERROR: Expected " + str(self.s)) + exit(1) + + self.s += 4 + =} + + reaction(shutdown) {= + if self.s == 0: + sys.stderr.write("ERROR: Destination received no input!") + exit(1) + + print("Success.") + =} } main reactor MultiportOut { - a = new Source() - t1 = new Computation() - t2 = new Computation() - t3 = new Computation() - t4 = new Computation() - b = new Destination() - a.out -> t1._in, t2._in, t3._in, t4._in - t1.out, t2.out, t3.out, t4.out -> b._in + a = new Source() + t1 = new Computation() + t2 = new Computation() + t3 = new Computation() + t4 = new Computation() + b = new Destination() + a.out -> t1._in, t2._in, t3._in, t4._in + t1.out, t2.out, t3.out, t4.out -> b._in } diff --git a/test/Python/src/multiport/MultiportToBank.lf b/test/Python/src/multiport/MultiportToBank.lf index 12d68d6662..8ac3e28321 100644 --- a/test/Python/src/multiport/MultiportToBank.lf +++ b/test/Python/src/multiport/MultiportToBank.lf @@ -1,40 +1,40 @@ # Check multiport output to bank of recipients. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output[3] out + output[3] out - reaction(startup) -> out {= - for (idx, port) in enumerate(out): - port.set(idx) - =} + reaction(startup) -> out {= + for (idx, port) in enumerate(out): + port.set(idx) + =} } reactor Destination(bank_index = 0) { - input _in - state received = 0 + input _in + state received = 0 - reaction(_in) {= - print("Destination " + str(self.bank_index) + " received " + str(_in.value)) - if self.bank_index != _in.value: - sys.stderr.write("ERROR: Expected " + str(self.bank_index)) - exit(1) - self.received = True - =} + reaction(_in) {= + print("Destination " + str(self.bank_index) + " received " + str(_in.value)) + if self.bank_index != _in.value: + sys.stderr.write("ERROR: Expected " + str(self.bank_index)) + exit(1) + self.received = True + =} - reaction(shutdown) {= - if self.received is not True: - sys.stderr.write("ERROR: Destination " + str(self.bank_index) + " received no input!\n") - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.received is not True: + sys.stderr.write("ERROR: Destination " + str(self.bank_index) + " received no input!\n") + exit(1) + print("Success.") + =} } main reactor MultiportToBank { - a = new Source() - b = new[3] Destination() - a.out -> b._in + a = new Source() + b = new[3] Destination() + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportToBankAfter.lf b/test/Python/src/multiport/MultiportToBankAfter.lf index 85fc91e513..e48624e853 100644 --- a/test/Python/src/multiport/MultiportToBankAfter.lf +++ b/test/Python/src/multiport/MultiportToBankAfter.lf @@ -1,37 +1,36 @@ -# Check multiport output to bank of recipients where the width of the bank is -# inferred. +# Check multiport output to bank of recipients where the width of the bank is inferred. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Source from "MultiportToBank.lf" reactor Destination(bank_index = 0) { - input _in - state received = False + input _in + state received = False - reaction(_in) {= - print("Destination {:d} received {:d}.".format(self.bank_index, _in.value)) - if self.bank_index != _in.value: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.bank_index)) - exit(1) - if lf.time.logical_elapsed() != SEC(1): - sys.stderr.write("ERROR: Expected to receive input after one second.\n") - exit(2) - self.received = True - =} + reaction(_in) {= + print("Destination {:d} received {:d}.".format(self.bank_index, _in.value)) + if self.bank_index != _in.value: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.bank_index)) + exit(1) + if lf.time.logical_elapsed() != SEC(1): + sys.stderr.write("ERROR: Expected to receive input after one second.\n") + exit(2) + self.received = True + =} - reaction(shutdown) {= - if self.received is not True: - sys.stderr.write("ERROR: Destination {:d} received no input!\n".format(self.bank_index)) - exit(3) - print("Success.") - =} + reaction(shutdown) {= + if self.received is not True: + sys.stderr.write("ERROR: Destination {:d} received no input!\n".format(self.bank_index)) + exit(3) + print("Success.") + =} } main reactor MultiportToBankAfter { - a = new Source() - b = new[3] Destination() - a.out -> b._in after 1 sec # Width of the bank of delays will be inferred. + a = new Source() + b = new[3] Destination() + a.out -> b._in after 1 sec # Width of the bank of delays will be inferred. } diff --git a/test/Python/src/multiport/MultiportToBankHierarchy.lf b/test/Python/src/multiport/MultiportToBankHierarchy.lf index f70fa8ad92..8dde25e5da 100644 --- a/test/Python/src/multiport/MultiportToBankHierarchy.lf +++ b/test/Python/src/multiport/MultiportToBankHierarchy.lf @@ -1,40 +1,40 @@ -# Check multiport output to bank of recipients. Here, the bank is smaller than -# the width of the sending port. +# Check multiport output to bank of recipients. Here, the bank is smaller than the width of the +# sending port. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Source from "MultiportToBank.lf" reactor Destination(bank_index = 0) { - input _in - state received = False + input _in + state received = False - reaction(_in) {= - print("Destination {:d} received {:d}.\n".format(self.bank_index, _in.value)) - if self.bank_index != _in.value: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.bank_index)) - exit(1) - self.received = True - =} + reaction(_in) {= + print("Destination {:d} received {:d}.\n".format(self.bank_index, _in.value)) + if self.bank_index != _in.value: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.bank_index)) + exit(1) + self.received = True + =} - reaction(shutdown) {= - if self.received is not True: - sys.stderr.write("ERROR: Destination {:d} received no input!\n".format(self.bank_index)) - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.received is not True: + sys.stderr.write("ERROR: Destination {:d} received no input!\n".format(self.bank_index)) + exit(1) + print("Success.") + =} } reactor Container { - input[3] _in - c = new[3] Destination() - _in -> c._in + input[3] _in + c = new[3] Destination() + _in -> c._in } main reactor MultiportToBankHierarchy { - a = new Source() - b = new Container() - a.out -> b._in + a = new Source() + b = new Container() + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportToHierarchy.lf b/test/Python/src/multiport/MultiportToHierarchy.lf index 2a9e25a5e6..e5820481b5 100644 --- a/test/Python/src/multiport/MultiportToHierarchy.lf +++ b/test/Python/src/multiport/MultiportToHierarchy.lf @@ -1,55 +1,54 @@ -# Check multiport output to multiport input, where the latter is a hierarchical -# reactor. Note that the destination reactor has width wider than the sender, so -# one input is dangling. +# Check multiport output to multiport input, where the latter is a hierarchical reactor. Note that +# the destination reactor has width wider than the sender, so one input is dangling. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[4] out - state s = 0 + timer t(0, 200 msec) + output[4] out + state s = 0 - reaction(t) -> out {= - for port in out: - port.set(self.s) - self.s += 1 - =} + reaction(t) -> out {= + for port in out: + port.set(self.s) + self.s += 1 + =} } reactor Destination(width = 4) { - state s = 6 - input[width] _in + state s = 6 + input[width] _in - reaction(_in) {= - sm = 0 - for port in _in: - if port.is_present: - sm += port.value - print("Sum of received: ", sm) - if sm != self.s: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) - exit(1) - self.s += 16 - =} + reaction(_in) {= + sm = 0 + for port in _in: + if port.is_present: + sm += port.value + print("Sum of received: ", sm) + if sm != self.s: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) + exit(1) + self.s += 16 + =} - reaction(shutdown) {= - if self.s <= 6: - sys.stderr.write("ERROR: Destination received no input!\n") - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.s <= 6: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + print("Success.") + =} } reactor Container(width = 4) { - input[width] _in - dst = new Destination() - _in -> dst._in + input[width] _in + dst = new Destination() + _in -> dst._in } main reactor MultiportToHierarchy { - a = new Source() - b = new Container() - a.out -> b._in + a = new Source() + b = new Container() + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportToMultiport.lf b/test/Python/src/multiport/MultiportToMultiport.lf index b16e832e7e..33fa418feb 100644 --- a/test/Python/src/multiport/MultiportToMultiport.lf +++ b/test/Python/src/multiport/MultiportToMultiport.lf @@ -1,28 +1,28 @@ # Check multiport output to multiport input. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Destination from "MultiportToHierarchy.lf" reactor Source(width = 1) { - timer t(0, 200 msec) - output[width] out - state s = 0 + timer t(0, 200 msec) + output[width] out + state s = 0 - reaction(t) -> out {= - for i in range(len(out)): - print("Before SET, out[{:d}]->is_present has value %d".format(i), out[i].is_present) - out[i].set(self.s) - self.s += 1 - print("AFTER set, out[{:d}]->is_present has value ".format(i), out[i].is_present) - print("AFTER set, out[{:d}]->value has value ".format(i), out[i].value) - =} + reaction(t) -> out {= + for i in range(len(out)): + print("Before SET, out[{:d}]->is_present has value %d".format(i), out[i].is_present) + out[i].set(self.s) + self.s += 1 + print("AFTER set, out[{:d}]->is_present has value ".format(i), out[i].is_present) + print("AFTER set, out[{:d}]->value has value ".format(i), out[i].value) + =} } main reactor MultiportToMultiport { - a = new Source(width = 4) - b = new Destination(width = 4) - a.out -> b._in + a = new Source(width = 4) + b = new Destination(width = 4) + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportToMultiport2.lf b/test/Python/src/multiport/MultiportToMultiport2.lf index cb6da65f35..2a92c3ef3c 100644 --- a/test/Python/src/multiport/MultiportToMultiport2.lf +++ b/test/Python/src/multiport/MultiportToMultiport2.lf @@ -2,32 +2,32 @@ target Python reactor Source(width = 2) { - output[width] out + output[width] out - reaction(startup) -> out {= - for (idx, port) in enumerate(out): - port.set(idx) - =} + reaction(startup) -> out {= + for (idx, port) in enumerate(out): + port.set(idx) + =} } reactor Destination(width = 2) { - input[width] _in + input[width] _in - reaction(_in) {= - for (idx, port) in enumerate(_in): - if port.is_present: - print("Received on channel {:d}: ".format(idx), port.value) - # NOTE: For testing purposes, this assumes the specific - # widths instantiated below. - if port.value != idx % 3: - sys.stderr.write("ERROR: expected {:d}!\n".format(idx % 3)) - exit(1) - =} + reaction(_in) {= + for (idx, port) in enumerate(_in): + if port.is_present: + print("Received on channel {:d}: ".format(idx), port.value) + # NOTE: For testing purposes, this assumes the specific + # widths instantiated below. + if port.value != idx % 3: + sys.stderr.write("ERROR: expected {:d}!\n".format(idx % 3)) + exit(1) + =} } main reactor MultiportToMultiport2 { - a1 = new Source(width = 3) - a2 = new Source(width = 2) - b = new Destination(width = 5) - a1.out, a2.out -> b._in + a1 = new Source(width = 3) + a2 = new Source(width = 2) + b = new Destination(width = 5) + a1.out, a2.out -> b._in } diff --git a/test/Python/src/multiport/MultiportToMultiport2After.lf b/test/Python/src/multiport/MultiportToMultiport2After.lf index 0e7ee9aef2..423a3b8b2e 100644 --- a/test/Python/src/multiport/MultiportToMultiport2After.lf +++ b/test/Python/src/multiport/MultiportToMultiport2After.lf @@ -4,26 +4,26 @@ target Python import Source from "MultiportToMultiport2.lf" reactor Destination(width = 2) { - input[width] _in + input[width] _in - reaction(_in) {= - for (idx, port) in enumerate(_in): - if port.is_present: - print("Received on channel {:d}: ".format(idx), port.value) - # NOTE: For testing purposes, this assumes the specific - # widths instantiated below. - if port.value != idx % 3: - sys.stderr.write("ERROR: expected {:d}!\n".format(idx % 3)) - exit(1) - if lf.time.logical_elapsed() != SEC(1): - sys.stderr.write("ERROR: Expected to receive input after one second.\n") - exit(2) - =} + reaction(_in) {= + for (idx, port) in enumerate(_in): + if port.is_present: + print("Received on channel {:d}: ".format(idx), port.value) + # NOTE: For testing purposes, this assumes the specific + # widths instantiated below. + if port.value != idx % 3: + sys.stderr.write("ERROR: expected {:d}!\n".format(idx % 3)) + exit(1) + if lf.time.logical_elapsed() != SEC(1): + sys.stderr.write("ERROR: Expected to receive input after one second.\n") + exit(2) + =} } main reactor MultiportToMultiport2After { - a1 = new Source(width = 3) - a2 = new Source(width = 2) - b = new Destination(width = 5) - a1.out, a2.out -> b._in after 1 sec + a1 = new Source(width = 3) + a2 = new Source(width = 2) + b = new Destination(width = 5) + a1.out, a2.out -> b._in after 1 sec } diff --git a/test/Python/src/multiport/MultiportToMultiportArray.lf b/test/Python/src/multiport/MultiportToMultiportArray.lf index 5eb043570d..4be3c1b68d 100644 --- a/test/Python/src/multiport/MultiportToMultiportArray.lf +++ b/test/Python/src/multiport/MultiportToMultiportArray.lf @@ -1,50 +1,49 @@ -# Check multiport output to multiport input. Destination port is wider than -# sending port. +# Check multiport output to multiport input. Destination port is wider than sending port. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - timer t(0, 200 msec) - output[2] out - state s = 0 - - reaction(t) -> out {= - for port in out: - port.set([self.s, self.s + 1, self.s + 2]) - self.s += 3 - =} + timer t(0, 200 msec) + output[2] out + state s = 0 + + reaction(t) -> out {= + for port in out: + port.set([self.s, self.s + 1, self.s + 2]) + self.s += 3 + =} } reactor Destination { - state s = 15 - input[2] _in - - reaction(_in) {= - sm = 0 - for port in _in: - if port.is_present: - sm += sum(port.value) - - print("Sum of received: ", sm); - if sm != self.s: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) - exit(1) - - self.s += 36 - =} - - reaction(shutdown) {= - if self.s <= 15: - sys.stderr.write("ERROR: Destination received no input!\n") - exit(1) - print("Success.") - =} + state s = 15 + input[2] _in + + reaction(_in) {= + sm = 0 + for port in _in: + if port.is_present: + sm += sum(port.value) + + print("Sum of received: ", sm); + if sm != self.s: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) + exit(1) + + self.s += 36 + =} + + reaction(shutdown) {= + if self.s <= 15: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + print("Success.") + =} } main reactor MultiportToMultiportArray { - a = new Source() - b = new Destination() - a.out -> b._in + a = new Source() + b = new Destination() + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportToMultiportParameter.lf b/test/Python/src/multiport/MultiportToMultiportParameter.lf index b47905bb6e..ac6b3663dc 100644 --- a/test/Python/src/multiport/MultiportToMultiportParameter.lf +++ b/test/Python/src/multiport/MultiportToMultiportParameter.lf @@ -1,14 +1,14 @@ # Check multiport output to multiport input. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } import Source from "MultiportToMultiport.lf" import Destination from "MultiportToHierarchy.lf" main reactor MultiportToMultiportParameter(width = 4) { - a = new Source(width = width) - b = new Destination(width = width) - a.out -> b._in + a = new Source(width = width) + b = new Destination(width = width) + a.out -> b._in } diff --git a/test/Python/src/multiport/MultiportToPort.lf b/test/Python/src/multiport/MultiportToPort.lf index ebfbf81991..cc8efe50d6 100644 --- a/test/Python/src/multiport/MultiportToPort.lf +++ b/test/Python/src/multiport/MultiportToPort.lf @@ -1,43 +1,42 @@ -# Check multiport output to multiport input. Destination port is wider than -# sending port. +# Check multiport output to multiport input. Destination port is wider than sending port. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source { - output[2] out + output[2] out - reaction(startup) -> out {= - for (idx, port) in enumerate(out): - print("Source sending ", idx) - port.set(idx) - =} + reaction(startup) -> out {= + for (idx, port) in enumerate(out): + print("Source sending ", idx) + port.set(idx) + =} } reactor Destination(expected = 0) { - input _in - state received = False + input _in + state received = False - reaction(_in) {= - print("Received: ", _in.value) - self.received = True - if _in.value != self.expected: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.expected)) - exit(1) - =} + reaction(_in) {= + print("Received: ", _in.value) + self.received = True + if _in.value != self.expected: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.expected)) + exit(1) + =} - reaction(shutdown) {= - if self.received is not True: - sys.stderr.write("ERROR: Destination received no input!\n") - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.received is not True: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + print("Success.") + =} } main reactor MultiportToPort { - a = new Source() - b1 = new Destination() - b2 = new Destination(expected = 1) - a.out -> b1._in, b2._in + a = new Source() + b1 = new Destination() + b2 = new Destination(expected = 1) + a.out -> b1._in, b2._in } diff --git a/test/Python/src/multiport/MultiportToReaction.lf b/test/Python/src/multiport/MultiportToReaction.lf index b45ee9ac9e..811f233038 100644 --- a/test/Python/src/multiport/MultiportToReaction.lf +++ b/test/Python/src/multiport/MultiportToReaction.lf @@ -1,41 +1,41 @@ # Check reaction to multiport output of a contained reactor. target Python { - timeout: 2 sec, - fast: true + timeout: 2 sec, + fast: true } reactor Source(width = 1) { - timer t(0, 200 msec) - state s = 0 - output[width] out + timer t(0, 200 msec) + state s = 0 + output[width] out - reaction(t) -> out {= - for port in out: - port.set(self.s) - self.s += 1 - =} + reaction(t) -> out {= + for port in out: + port.set(self.s) + self.s += 1 + =} } main reactor { - state s = 6 - b = new Source(width = 4) + state s = 6 + b = new Source(width = 4) - reaction(b.out) {= - sm = 0 - for port in b.out: - if port.is_present: - sm += port.value - print("Sum of received: ", sm) - if sm != self.s: - sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) - exit(1) - self.s += 16 - =} + reaction(b.out) {= + sm = 0 + for port in b.out: + if port.is_present: + sm += port.value + print("Sum of received: ", sm) + if sm != self.s: + sys.stderr.write("ERROR: Expected {:d}.\n".format(self.s)) + exit(1) + self.s += 16 + =} - reaction(shutdown) {= - if self.s <= 6: - sys.stderr.write("ERROR: Destination received no input!\n") - exit(1) - print("Success.") - =} + reaction(shutdown) {= + if self.s <= 6: + sys.stderr.write("ERROR: Destination received no input!\n") + exit(1) + print("Success.") + =} } diff --git a/test/Python/src/multiport/NestedBanks.lf b/test/Python/src/multiport/NestedBanks.lf index 1e863043e6..bc2c08db54 100644 --- a/test/Python/src/multiport/NestedBanks.lf +++ b/test/Python/src/multiport/NestedBanks.lf @@ -5,76 +5,76 @@ target Python main reactor { - a = new[2] A() - c = new[3] C() - d = new D() - e = new E() + a = new[2] A() + c = new[3] C() + d = new D() + e = new E() - (a.x)+ -> c.z, d.u, e.t + (a.x)+ -> c.z, d.u, e.t } reactor A(bank_index = 0) { - output[4] x - b = new[2] B(a_bank_index = bank_index) - b.y -> x + output[4] x + b = new[2] B(a_bank_index = bank_index) + b.y -> x } reactor B(a_bank_index = 0, bank_index = 0) { - output[2] y + output[2] y - reaction(startup) -> y {= - base = self.a_bank_index * 4 + self.bank_index * 2 - y[0].set(base) - y[1].set(base + 1) - =} + reaction(startup) -> y {= + base = self.a_bank_index * 4 + self.bank_index * 2 + y[0].set(base) + y[1].set(base + 1) + =} } reactor C(bank_index = 0) { - input[2] z - f = new F(c_bank_index = bank_index) - g = new G(c_bank_index = bank_index) - z -> f.w, g.s + input[2] z + f = new F(c_bank_index = bank_index) + g = new G(c_bank_index = bank_index) + z -> f.w, g.s } reactor D { - input[2] u + input[2] u - reaction(u) {= - for (i, p) in enumerate(u): - print(f"d.u[{i}] received {p.value}.") - if p.value != (6 + i): - sys.stderr.write(f"ERROR: Expected {6 + i} but received {p.value}.\n") - exit(1) - =} + reaction(u) {= + for (i, p) in enumerate(u): + print(f"d.u[{i}] received {p.value}.") + if p.value != (6 + i): + sys.stderr.write(f"ERROR: Expected {6 + i} but received {p.value}.\n") + exit(1) + =} } reactor E { - input[8] t + input[8] t - reaction(t) {= - for (i, p) in enumerate(t): - print(f"e.t[{i}] received {p.value}.") - =} + reaction(t) {= + for (i, p) in enumerate(t): + print(f"e.t[{i}] received {p.value}.") + =} } reactor F(c_bank_index = 0) { - input w + input w - reaction(w) {= - print(f"c[{self.c_bank_index}].f.w received {w.value}.") - if w.value != self.c_bank_index * 2: - sys.stderr.write(f"ERROR: Expected {self.c_bank_index * 2} but received {w.value}.\n") - exit(1) - =} + reaction(w) {= + print(f"c[{self.c_bank_index}].f.w received {w.value}.") + if w.value != self.c_bank_index * 2: + sys.stderr.write(f"ERROR: Expected {self.c_bank_index * 2} but received {w.value}.\n") + exit(1) + =} } reactor G(c_bank_index = 0) { - input s + input s - reaction(s) {= - print(f"c[{self.c_bank_index}].g.s received {s.value}.") - if s.value != (self.c_bank_index * 2 + 1): - sys.stderr.write(f"ERROR: Expected {self.c_bank_index * 2 + 1} but received {s.value}.\n") - exit(1) - =} + reaction(s) {= + print(f"c[{self.c_bank_index}].g.s received {s.value}.") + if s.value != (self.c_bank_index * 2 + 1): + sys.stderr.write(f"ERROR: Expected {self.c_bank_index * 2 + 1} but received {s.value}.\n") + exit(1) + =} } diff --git a/test/Python/src/multiport/NestedInterleavedBanks.lf b/test/Python/src/multiport/NestedInterleavedBanks.lf index 9be37badcd..ea124666af 100644 --- a/test/Python/src/multiport/NestedInterleavedBanks.lf +++ b/test/Python/src/multiport/NestedInterleavedBanks.lf @@ -5,36 +5,36 @@ target Python reactor A(bank_index = 0, outer_bank_index = 0) { - output[2] p + output[2] p - reaction(startup) -> p {= - for i, port in enumerate(p): - port.set(self.outer_bank_index * 4 + self.bank_index * 2 + i + 1) - print(f"A sending {port.value}.") - =} + reaction(startup) -> p {= + for i, port in enumerate(p): + port.set(self.outer_bank_index * 4 + self.bank_index * 2 + i + 1) + print(f"A sending {port.value}.") + =} } reactor B(bank_index = 0) { - output[4] q - a = new[2] A(outer_bank_index = bank_index) - interleaved (a.p) -> q + output[4] q + a = new[2] A(outer_bank_index = bank_index) + interleaved (a.p) -> q } reactor C { - input[8] i + input[8] i - reaction(i) {= - expected = [1, 3, 2, 4, 5, 7, 6, 8] - for j, port in enumerate(i): - print(f"C received {port.value}.") - if port.value != expected[j]: - sys.stderr.write(f"ERROR: Expected {expected[j]}.\n") - exit(1) - =} + reaction(i) {= + expected = [1, 3, 2, 4, 5, 7, 6, 8] + for j, port in enumerate(i): + print(f"C received {port.value}.") + if port.value != expected[j]: + sys.stderr.write(f"ERROR: Expected {expected[j]}.\n") + exit(1) + =} } main reactor { - b = new[2] B() - c = new C() - b.q -> c.i + b = new[2] B() + c = new C() + b.q -> c.i } diff --git a/test/Python/src/multiport/ReactionsToNested.lf b/test/Python/src/multiport/ReactionsToNested.lf index 2c207dffb0..1f05d5ba5b 100644 --- a/test/Python/src/multiport/ReactionsToNested.lf +++ b/test/Python/src/multiport/ReactionsToNested.lf @@ -1,39 +1,38 @@ -# This test connects a simple counting source to tester that checks against its -# own count. +# This test connects a simple counting source to tester that checks against its own count. target Python { - timeout: 1 sec + timeout: 1 sec } reactor T(expected = 0) { - input z - state received = False + input z + state received = False - reaction(z) {= - print(f"T received {z.value}.") - self.received = True - if z.value != self.expected: - sys.stderr.write(f"ERROR: Expected {self.response}") - exit(1) - =} + reaction(z) {= + print(f"T received {z.value}.") + self.received = True + if z.value != self.expected: + sys.stderr.write(f"ERROR: Expected {self.response}") + exit(1) + =} - reaction(shutdown) {= - if self.received is not True: - sys.stderr.write(f"ERROR: No input received.") - exit(1) - =} + reaction(shutdown) {= + if self.received is not True: + sys.stderr.write(f"ERROR: No input received.") + exit(1) + =} } reactor D { - input[2] y - t1 = new T(expected = 42) - t2 = new T(expected = 43) - y -> t1.z, t2.z + input[2] y + t1 = new T(expected = 42) + t2 = new T(expected = 43) + y -> t1.z, t2.z } main reactor { - d = new D() + d = new D() - reaction(startup) -> d.y {= d.y[0].set(42) =} + reaction(startup) -> d.y {= d.y[0].set(42) =} - reaction(startup) -> d.y {= d.y[1].set(43) =} + reaction(startup) -> d.y {= d.y[1].set(43) =} } diff --git a/test/Python/src/target/AfterNoTypes.lf b/test/Python/src/target/AfterNoTypes.lf index 44aaa89c73..ef92444c34 100644 --- a/test/Python/src/target/AfterNoTypes.lf +++ b/test/Python/src/target/AfterNoTypes.lf @@ -1,50 +1,50 @@ -# This test demonstrates that after can be used on connections with ports that -# have no types. The test passes if the compile is succeeded +# This test demonstrates that after can be used on connections with ports that have no types. The +# test passes if the compile is succeeded target Python { - fast: false, - timeout: 3 sec + fast: false, + timeout: 3 sec } reactor Foo { - input x - output y + input x + output y - reaction(x) -> y {= y.set(2*x.value); =} + reaction(x) -> y {= y.set(2*x.value); =} } reactor Print { - state expected_time = 10 msec - state received = 0 - input x - - reaction(x) {= - self.received+=1 - elapsed_time = lf.time.logical_elapsed() - print("Result is " + str(x.value)) - if x.value != 84: - sys.stderr.write("ERROR: Expected result to be 84.\n") - exit(1) - - print("Current logical time is: " + str(elapsed_time)) - print("Current physical time is: " + str(lf.time.physical_elapsed())) - if elapsed_time != self.expected_time: - sys.stderr.write("ERROR: Expected logical time to be " + self.expected_time) - exit(2) - self.expected_time += SEC(1) - =} - - reaction(shutdown) {= - if (self.received == 0): - sys.stderr.write("ERROR: Final reactor received no data.\n") - exit(3) - =} + state expected_time = 10 msec + state received = 0 + input x + + reaction(x) {= + self.received+=1 + elapsed_time = lf.time.logical_elapsed() + print("Result is " + str(x.value)) + if x.value != 84: + sys.stderr.write("ERROR: Expected result to be 84.\n") + exit(1) + + print("Current logical time is: " + str(elapsed_time)) + print("Current physical time is: " + str(lf.time.physical_elapsed())) + if elapsed_time != self.expected_time: + sys.stderr.write("ERROR: Expected logical time to be " + self.expected_time) + exit(2) + self.expected_time += SEC(1) + =} + + reaction(shutdown) {= + if (self.received == 0): + sys.stderr.write("ERROR: Final reactor received no data.\n") + exit(3) + =} } main reactor { - f = new Foo() - p = new Print() - timer t(0, 1 sec) - f.y -> p.x after 10 msec + f = new Foo() + p = new Print() + timer t(0, 1 sec) + f.y -> p.x after 10 msec - reaction(t) -> f.x {= f.x.set(42) =} + reaction(t) -> f.x {= f.x.set(42) =} } diff --git a/test/Rust/src/ActionDelay.lf b/test/Rust/src/ActionDelay.lf index 75c7ab909f..e45f315c93 100644 --- a/test/Rust/src/ActionDelay.lf +++ b/test/Rust/src/ActionDelay.lf @@ -2,27 +2,27 @@ target Rust main reactor ActionDelay { - logical action act0 - logical action act1(100 msec) - state count: u32 = 0 + logical action act0 + logical action act1(100 msec) + state count: u32 = 0 - reaction(startup) -> act0, act1 {= - ctx.schedule(act0, after!(100 ms)); - ctx.schedule(act1, after!(40 ms)); - =} + reaction(startup) -> act0, act1 {= + ctx.schedule(act0, after!(100 ms)); + ctx.schedule(act1, after!(40 ms)); + =} - reaction(act0) {= - assert_tag_is!(ctx, T0 + 100 ms); - self.count += 1; - =} + reaction(act0) {= + assert_tag_is!(ctx, T0 + 100 ms); + self.count += 1; + =} - reaction(act1) {= - assert_tag_is!(ctx, T0 + 140 ms); - self.count += 1; - =} + reaction(act1) {= + assert_tag_is!(ctx, T0 + 140 ms); + self.count += 1; + =} - reaction(shutdown) {= - assert_eq!(2, self.count); - println!("SUCCESS") - =} + reaction(shutdown) {= + assert_eq!(2, self.count); + println!("SUCCESS") + =} } diff --git a/test/Rust/src/ActionImplicitDelay.lf b/test/Rust/src/ActionImplicitDelay.lf index 9a3a900d93..46b4a4d767 100644 --- a/test/Rust/src/ActionImplicitDelay.lf +++ b/test/Rust/src/ActionImplicitDelay.lf @@ -2,18 +2,18 @@ target Rust main reactor ActionImplicitDelay { - logical action act(40 msec) - state count: u64 = 1 + logical action act(40 msec) + state count: u64 = 1 - reaction(startup) -> act {= ctx.schedule(act, Asap); =} + reaction(startup) -> act {= ctx.schedule(act, Asap); =} - reaction(act) -> act {= - assert_tag_is!(ctx, T0 + (40 * self.count) ms); - self.count += 1; - if self.count <= 3 { - ctx.schedule(act, Asap); - } else { - println!("SUCCESS") - } - =} + reaction(act) -> act {= + assert_tag_is!(ctx, T0 + (40 * self.count) ms); + self.count += 1; + if self.count <= 3 { + ctx.schedule(act, Asap); + } else { + println!("SUCCESS") + } + =} } diff --git a/test/Rust/src/ActionIsPresent.lf b/test/Rust/src/ActionIsPresent.lf index 3a1e556c5a..a581fe7574 100644 --- a/test/Rust/src/ActionIsPresent.lf +++ b/test/Rust/src/ActionIsPresent.lf @@ -2,28 +2,28 @@ target Rust main reactor ActionIsPresent { - logical action a - state success: bool = false - state tried: bool = false + logical action a + state success: bool = false + state tried: bool = false - reaction(startup, a) -> a {= - if !ctx.is_present(a) { - assert_tag_is!(ctx, T0); - assert!(!self.tried, "Already tried, is_present does not work properly."); - self.tried = true; - // was triggered by startup - println!("Startup reaction @ {}", ctx.get_tag()); - ctx.schedule(a, after!(1 ns)); - } else { - assert_tag_is!(ctx, T0 + 1 ns); - // was triggered by schedule above - println!("Scheduled reaction @ {}", ctx.get_tag()); - self.success = true; - } - =} + reaction(startup, a) -> a {= + if !ctx.is_present(a) { + assert_tag_is!(ctx, T0); + assert!(!self.tried, "Already tried, is_present does not work properly."); + self.tried = true; + // was triggered by startup + println!("Startup reaction @ {}", ctx.get_tag()); + ctx.schedule(a, after!(1 ns)); + } else { + assert_tag_is!(ctx, T0 + 1 ns); + // was triggered by schedule above + println!("Scheduled reaction @ {}", ctx.get_tag()); + self.success = true; + } + =} - reaction(shutdown) {= - assert!(self.success, "What happened!?"); - println!("success"); - =} + reaction(shutdown) {= + assert!(self.success, "What happened!?"); + println!("success"); + =} } diff --git a/test/Rust/src/ActionScheduleMicrostep.lf b/test/Rust/src/ActionScheduleMicrostep.lf index 53bf8781b9..db1210190f 100644 --- a/test/Rust/src/ActionScheduleMicrostep.lf +++ b/test/Rust/src/ActionScheduleMicrostep.lf @@ -2,22 +2,22 @@ target Rust main reactor ActionScheduleMicrostep { - logical action act - state count: u32 = 1 + logical action act + state count: u32 = 1 - reaction(startup) -> act {= - assert_tag_is!(ctx, T0); - // executes at (T0, 0) - ctx.schedule(act, Asap); - =} + reaction(startup) -> act {= + assert_tag_is!(ctx, T0); + // executes at (T0, 0) + ctx.schedule(act, Asap); + =} - reaction(act) -> act {= - assert_tag_is!(ctx, (T0, self.count)); - self.count += 1; - if self.count <= 3 { - ctx.schedule(act, Asap); - } else { - println!("SUCCESS") - } - =} + reaction(act) -> act {= + assert_tag_is!(ctx, (T0, self.count)); + self.count += 1; + if self.count <= 3 { + ctx.schedule(act, Asap); + } else { + println!("SUCCESS") + } + =} } diff --git a/test/Rust/src/ActionValues.lf b/test/Rust/src/ActionValues.lf index 007da1fb5a..8e8fb9f958 100644 --- a/test/Rust/src/ActionValues.lf +++ b/test/Rust/src/ActionValues.lf @@ -2,31 +2,31 @@ target Rust main reactor ActionValues { - state r1done: bool = false - state r2done: bool = false - logical action act(100 msec): i32 + state r1done: bool = false + state r2done: bool = false + logical action act(100 msec): i32 - reaction(startup) -> act {= - ctx.schedule_with_v(act, Some(100), Asap); // scheduled in 100 ms - // scheduled in 150 ms, value is overwritten - ctx.schedule_with_v(act, Some(-100), after!(50 ms)); - =} + reaction(startup) -> act {= + ctx.schedule_with_v(act, Some(100), Asap); // scheduled in 100 ms + // scheduled in 150 ms, value is overwritten + ctx.schedule_with_v(act, Some(-100), after!(50 ms)); + =} - reaction(act) {= - println!("At {}, received {:?}", ctx.get_tag(), ctx.get(act)); + reaction(act) {= + println!("At {}, received {:?}", ctx.get_tag(), ctx.get(act)); - if ctx.get_tag() == tag!(T0 + 100 ms) { - assert_eq!(Some(100), ctx.get(act)); - self.r1done = true; - } else { - assert_tag_is!(ctx, T0 + 150 ms); - assert_eq!(Some(-100), ctx.get(act)); - self.r2done = true; - } - =} + if ctx.get_tag() == tag!(T0 + 100 ms) { + assert_eq!(Some(100), ctx.get(act)); + self.r1done = true; + } else { + assert_tag_is!(ctx, T0 + 150 ms); + assert_eq!(Some(-100), ctx.get(act)); + self.r2done = true; + } + =} - reaction(shutdown) {= - assert!(self.r1done && self.r2done); - println!("Success") - =} + reaction(shutdown) {= + assert!(self.r1done && self.r2done); + println!("Success") + =} } diff --git a/test/Rust/src/ActionValuesCleanup.lf b/test/Rust/src/ActionValuesCleanup.lf index f4bab7a2b5..6ad9bd1b38 100644 --- a/test/Rust/src/ActionValuesCleanup.lf +++ b/test/Rust/src/ActionValuesCleanup.lf @@ -2,49 +2,47 @@ target Rust main reactor ActionValuesCleanup { - preamble {= - use std::sync::atomic::AtomicBool; - use std::sync::atomic::Ordering; - // set to true when destructor is called - static mut DROPPED: AtomicBool = AtomicBool::new(false); + preamble {= + use std::sync::atomic::AtomicBool; + use std::sync::atomic::Ordering; + // set to true when destructor is called + static mut DROPPED: AtomicBool = AtomicBool::new(false); - #[derive(Clone, Debug)] - struct FooDrop { } - impl std::ops::Drop for FooDrop { - fn drop(&mut self) { - unsafe { - DROPPED.store(true, Ordering::SeqCst); - } + #[derive(Clone, Debug)] + struct FooDrop { } + impl std::ops::Drop for FooDrop { + fn drop(&mut self) { + unsafe { + DROPPED.store(true, Ordering::SeqCst); } } - =} + } + =} - logical action act: FooDrop - state count: u32 = 0 + logical action act: FooDrop + state count: u32 = 0 - reaction(startup) -> act {= - ctx.schedule_with_v(act, Some(FooDrop { }), Asap) - =} + reaction(startup) -> act {= ctx.schedule_with_v(act, Some(FooDrop { }), Asap) =} - reaction(act) -> act {= - ctx.use_ref(act, |v| println!("{:?}", v)); - if self.count == 0 { - self.count = 1; - assert!(ctx.is_present(act)); - assert!(ctx.use_ref(act, |v| v.is_some())); - ctx.schedule(act, Asap); - } else if self.count == 1 { - assert!(ctx.is_present(act)); - assert!(ctx.use_ref(act, |v| v.is_none())); - assert!(unsafe { DROPPED.load(Ordering::SeqCst) }); - self.count = 2; - } else { - unreachable!(); - } - =} + reaction(act) -> act {= + ctx.use_ref(act, |v| println!("{:?}", v)); + if self.count == 0 { + self.count = 1; + assert!(ctx.is_present(act)); + assert!(ctx.use_ref(act, |v| v.is_some())); + ctx.schedule(act, Asap); + } else if self.count == 1 { + assert!(ctx.is_present(act)); + assert!(ctx.use_ref(act, |v| v.is_none())); + assert!(unsafe { DROPPED.load(Ordering::SeqCst) }); + self.count = 2; + } else { + unreachable!(); + } + =} - reaction(shutdown) {= - assert_eq!(2, self.count, "expected 2 invocations"); - println!("success"); - =} + reaction(shutdown) {= + assert_eq!(2, self.count, "expected 2 invocations"); + println!("success"); + =} } diff --git a/test/Rust/src/CompositionWithPorts.lf b/test/Rust/src/CompositionWithPorts.lf index d91e8f3370..94fc2de449 100644 --- a/test/Rust/src/CompositionWithPorts.lf +++ b/test/Rust/src/CompositionWithPorts.lf @@ -1,27 +1,27 @@ target Rust reactor Source { - output out: i32 + output out: i32 - reaction(startup) -> out {= ctx.set(out, 76600) =} + reaction(startup) -> out {= ctx.set(out, 76600) =} } reactor Sink { - input inport: i32 + input inport: i32 - reaction(inport) {= - if let Some(value) = ctx.get(inport) { - println!("received {}", value); - assert_eq!(76600, value); - } else { - unreachable!(); - } - =} + reaction(inport) {= + if let Some(value) = ctx.get(inport) { + println!("received {}", value); + assert_eq!(76600, value); + } else { + unreachable!(); + } + =} } main reactor CompositionWithPorts { - source = new Source() - sink = new Sink() + source = new Source() + sink = new Sink() - source.out -> sink.inport + source.out -> sink.inport } diff --git a/test/Rust/src/CtorParamDefault.lf b/test/Rust/src/CtorParamDefault.lf index a7d2d868bc..aeaad8a957 100644 --- a/test/Rust/src/CtorParamDefault.lf +++ b/test/Rust/src/CtorParamDefault.lf @@ -1,14 +1,14 @@ target Rust reactor Print(value: i32 = 42) { - state v: i32 = value + state v: i32 = value - reaction(startup) {= - assert_eq!(42, self.v); - println!("success"); - =} + reaction(startup) {= + assert_eq!(42, self.v); + println!("success"); + =} } main reactor CtorParamDefault { - p = new Print() + p = new Print() } diff --git a/test/Rust/src/CtorParamMixed.lf b/test/Rust/src/CtorParamMixed.lf index 5de7a3dc4c..33c4730eb9 100644 --- a/test/Rust/src/CtorParamMixed.lf +++ b/test/Rust/src/CtorParamMixed.lf @@ -1,22 +1,18 @@ target Rust -reactor Print( - value: i32 = 42, - name: String = {= "xxx".into() =}, - other: bool = false -) { - state value = value - state name = name - state other = other +reactor Print(value: i32 = 42, name: String = {= "xxx".into() =}, other: bool = false) { + state value = value + state name = name + state other = other - reaction(startup) {= - assert_eq!(42, self.value); - assert_eq!("x2hr", self.name.as_str()); - assert_eq!(true, self.other); - println!("success"); - =} + reaction(startup) {= + assert_eq!(42, self.value); + assert_eq!("x2hr", self.name.as_str()); + assert_eq!(true, self.other); + println!("success"); + =} } main reactor CtorParamMixed { - p = new Print(other = true, name = {= "x2hr".into() =}) + p = new Print(other = true, name = {= "x2hr".into() =}) } diff --git a/test/Rust/src/CtorParamSimple.lf b/test/Rust/src/CtorParamSimple.lf index bbf38c04a0..09a3046af3 100644 --- a/test/Rust/src/CtorParamSimple.lf +++ b/test/Rust/src/CtorParamSimple.lf @@ -1,14 +1,14 @@ target Rust reactor Print(value: i32 = 42) { - state v: i32 = value + state v: i32 = value - reaction(startup) {= - assert_eq!(self.v, 23); - println!("success"); - =} + reaction(startup) {= + assert_eq!(self.v, 23); + println!("success"); + =} } main reactor CtorParamSimple { - p = new Print(value = 23) + p = new Print(value = 23) } diff --git a/test/Rust/src/DependencyOnChildPort.lf b/test/Rust/src/DependencyOnChildPort.lf index ed8b6b2120..2758af8604 100644 --- a/test/Rust/src/DependencyOnChildPort.lf +++ b/test/Rust/src/DependencyOnChildPort.lf @@ -2,28 +2,26 @@ target Rust reactor Box { - input inp: u32 - output out: u32 + input inp: u32 + output out: u32 - inp -> out + inp -> out } main reactor { - state done: bool = false + state done: bool = false - box0 = new Box() - box1 = new Box() + box0 = new Box() + box1 = new Box() - box0.out -> box1.inp + box0.out -> box1.inp - reaction(startup) -> box0.inp {= ctx.set(box0__inp, 444); =} + reaction(startup) -> box0.inp {= ctx.set(box0__inp, 444); =} - reaction(box1.out) {= - assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; - =} + reaction(box1.out) {= assert!(ctx.get_elapsed_logical_time().is_zero()); self.done = true; =} - reaction(shutdown) {= - assert!(self.done, "reaction was not executed"); - println!("success"); - =} + reaction(shutdown) {= + assert!(self.done, "reaction was not executed"); + println!("success"); + =} } diff --git a/test/Rust/src/DependencyUseOnLogicalAction.lf b/test/Rust/src/DependencyUseOnLogicalAction.lf index 6278ec76f7..f1b244901e 100644 --- a/test/Rust/src/DependencyUseOnLogicalAction.lf +++ b/test/Rust/src/DependencyUseOnLogicalAction.lf @@ -1,47 +1,47 @@ /** Test that use-dependencies may be declared on logical actions and timers. */ target Rust { - timeout: 10 msec + timeout: 10 msec } main reactor { - logical action clock: u32 - - logical action a - - timer t(0, 2 msec) - - state tick: u32 = 0 - - reaction(startup) -> clock, a {= - ctx.schedule(a, after!(3 ms)); // out of order on purpose - ctx.schedule(a, after!(1 ms)); - ctx.schedule(a, after!(5 ms)); - - // not scheduled on milli 1 (action is) - ctx.schedule_with_v(clock, Some(2), after!(2 ms)); - ctx.schedule_with_v(clock, Some(3), after!(3 ms)); - ctx.schedule_with_v(clock, Some(4), after!(4 ms)); - ctx.schedule_with_v(clock, Some(5), after!(5 ms)); - // not scheduled on milli 6 (timer is) - =} - - reaction(clock) a, t {= - match ctx.get(clock) { - Some(2) | Some(4) => { - assert!(ctx.is_present(t)); // t is there on even millis - assert!(!ctx.is_present(a)); // - }, - Some(3) | Some(5) => { - assert!(!ctx.is_present(t)); - assert!(ctx.is_present(a)); - }, - it => unreachable!("{:?}", it) - } - self.tick += 1; - =} - - reaction(shutdown) {= - assert_eq!(self.tick, 4); - println!("success"); - =} + logical action clock: u32 + + logical action a + + timer t(0, 2 msec) + + state tick: u32 = 0 + + reaction(startup) -> clock, a {= + ctx.schedule(a, after!(3 ms)); // out of order on purpose + ctx.schedule(a, after!(1 ms)); + ctx.schedule(a, after!(5 ms)); + + // not scheduled on milli 1 (action is) + ctx.schedule_with_v(clock, Some(2), after!(2 ms)); + ctx.schedule_with_v(clock, Some(3), after!(3 ms)); + ctx.schedule_with_v(clock, Some(4), after!(4 ms)); + ctx.schedule_with_v(clock, Some(5), after!(5 ms)); + // not scheduled on milli 6 (timer is) + =} + + reaction(clock) a, t {= + match ctx.get(clock) { + Some(2) | Some(4) => { + assert!(ctx.is_present(t)); // t is there on even millis + assert!(!ctx.is_present(a)); // + }, + Some(3) | Some(5) => { + assert!(!ctx.is_present(t)); + assert!(ctx.is_present(a)); + }, + it => unreachable!("{:?}", it) + } + self.tick += 1; + =} + + reaction(shutdown) {= + assert_eq!(self.tick, 4); + println!("success"); + =} } diff --git a/test/Rust/src/FloatLiteral.lf b/test/Rust/src/FloatLiteral.lf index b1dd37ca5e..a0d61c9fdf 100644 --- a/test/Rust/src/FloatLiteral.lf +++ b/test/Rust/src/FloatLiteral.lf @@ -1,15 +1,14 @@ target Rust -// This test verifies that floating-point literals are handled correctly. -main reactor { - state N: f64 = 6.0221409e+23 - state charge: f64 = -1.6021766E-19 - state minus_epsilon: f64 = -.01e0 - state expected: f64 = .964853323188E5 +main reactor { // This test verifies that floating-point literals are handled correctly. + state N: f64 = 6.0221409e+23 + state charge: f64 = -1.6021766E-19 + state minus_epsilon: f64 = -.01e0 + state expected: f64 = .964853323188E5 - reaction(startup) {= - let F = - self.N * self.charge; - println!("The Faraday constant is roughly {}.", F); - assert!((F - self.expected).abs() < (self.minus_epsilon).abs()); - =} + reaction(startup) {= + let F = - self.N * self.charge; + println!("The Faraday constant is roughly {}.", F); + assert!((F - self.expected).abs() < (self.minus_epsilon).abs()); + =} } diff --git a/test/Rust/src/MainReactorParam.lf b/test/Rust/src/MainReactorParam.lf index 0c9f189548..2081466a37 100644 --- a/test/Rust/src/MainReactorParam.lf +++ b/test/Rust/src/MainReactorParam.lf @@ -1,8 +1,8 @@ target Rust main reactor(one: u64 = 1152921504606846976, two: u64 = {= 1 << 60 =}) { - state one = one - state two = two + state one = one + state two = two - reaction(startup) {= assert_eq!(self.one, self.two); =} + reaction(startup) {= assert_eq!(self.one, self.two); =} } diff --git a/test/Rust/src/MovingAverage.lf b/test/Rust/src/MovingAverage.lf index 3dcbb69c98..22d10cabe0 100644 --- a/test/Rust/src/MovingAverage.lf +++ b/test/Rust/src/MovingAverage.lf @@ -1,66 +1,64 @@ -// Demonstration of a state variable that is a fixed size list. The -// MovingAverage reactor computes the moving average of the last four inputs and -// produces that as output. The source is a counting sequence. +// Demonstration of a state variable that is a fixed size list. The MovingAverage reactor computes +// the moving average of the last four inputs and produces that as output. The source is a counting +// sequence. target Rust { - timeout: 50 msec + timeout: 50 msec } reactor Source { - output out: f64 - state count: u32 = 0 - timer clock(0, 10 msec) + output out: f64 + state count: u32 = 0 + timer clock(0, 10 msec) - reaction(clock) -> out {= - ctx.set(out, self.count.into()); - self.count += 1; - =} + reaction(clock) -> out {= + ctx.set(out, self.count.into()); + self.count += 1; + =} } reactor MovingAverageImpl { - state delay_line: {= [f64 ; 4] =} = {= [ 0.0 ; 4 ] =} - state index: usize = 0 - input in_: f64 - output out: f64 + state delay_line: {= [f64 ; 4] =} = {= [ 0.0 ; 4 ] =} + state index: usize = 0 + input in_: f64 + output out: f64 - reaction(in_) -> out {= - let in_ = ctx.get(in_).unwrap(); + reaction(in_) -> out {= + let in_ = ctx.get(in_).unwrap(); - // Insert the input in the delay line. - self.delay_line[self.index] = in_; - // Update the index for the next input. - self.index = (self.index + 1) % 4; + // Insert the input in the delay line. + self.delay_line[self.index] = in_; + // Update the index for the next input. + self.index = (self.index + 1) % 4; - // Calculate the output. - let sum: f64 = self.delay_line.iter().sum(); - ctx.set(out, sum / 4.0); - =} + // Calculate the output. + let sum: f64 = self.delay_line.iter().sum(); + ctx.set(out, sum / 4.0); + =} } reactor Print { - input in_: f64 - state count: usize = 0 + input in_: f64 + state count: usize = 0 - preamble {= - const EXPECTED: [ f64 ; 6 ] = [0.0, 0.25, 0.75, 1.5, 2.5, 3.5]; - =} + preamble {= const EXPECTED: [ f64 ; 6 ] = [0.0, 0.25, 0.75, 1.5, 2.5, 3.5]; =} - reaction(in_) {= - let in_ = ctx.get(in_).unwrap(); - println!("Received {}", in_); - assert_eq!(in_, EXPECTED[self.count]); - self.count += 1; - =} + reaction(in_) {= + let in_ = ctx.get(in_).unwrap(); + println!("Received {}", in_); + assert_eq!(in_, EXPECTED[self.count]); + self.count += 1; + =} - reaction(shutdown) {= - assert_eq!(self.count, 6); - println!("Success."); - =} + reaction(shutdown) {= + assert_eq!(self.count, 6); + println!("Success."); + =} } main reactor MovingAverage { - s = new Source() - m = new MovingAverageImpl() - p = new Print() - s.out -> m.in_ - m.out -> p.in_ + s = new Source() + m = new MovingAverageImpl() + p = new Print() + s.out -> m.in_ + m.out -> p.in_ } diff --git a/test/Rust/src/NativeListsAndTimes.lf b/test/Rust/src/NativeListsAndTimes.lf index 79fd56e004..21c44e17d8 100644 --- a/test/Rust/src/NativeListsAndTimes.lf +++ b/test/Rust/src/NativeListsAndTimes.lf @@ -1,46 +1,45 @@ target Rust -// This test passes if it is successfully compiled into valid target code. -reactor Foo( - x: i32 = 0, - y: time = 0, // Units are missing but not required - z = 1 msec, // Type is missing but not required - p: i32[](1, 2, 3, 4), // List of integers - p2: i32[] = {= vec![1] =}, // List of integers with single element - // todo // p2: i32[](1), // List of integers with single element p3: - // i32[](), // Empty list of integers List of time values - q: Vec(1 msec, 2 msec, 3 msec), - g: time[](1 msec, 2 msec) // List of time values +reactor Foo( // This test passes if it is successfully compiled into valid target code. + x: i32 = 0, + y: time = 0, // Units are missing but not required + z = 1 msec, // Type is missing but not required + p: i32[](1, 2, 3, 4), // List of integers + p2: i32[] = {= vec![1] =}, // List of integers with single element + // todo // p2: i32[](1), // List of integers with single element p3: i32[](), // Empty list of + // integers List of time values + q: Vec(1 msec, 2 msec, 3 msec), + g: time[](1 msec, 2 msec) // List of time values ) { - state s: time = y // Reference to explicitly typed time parameter - state t: time = z // Reference to implicitly typed time parameter - state v: bool // Uninitialized boolean state variable - state w: time // Uninitialized time state variable - timer tick(0) // Units missing but not required - timer tock(1 sec) // Implicit type time - timer toe(z) // Implicit type time - /** - * fixme following should be equivalent: - * - state baz(p); - * - state baz: i32[4](p); - * - state baz: i32[4]({=p=}); - * - * because the initializer is the same modulo fat braces - */ - // state baz(p); // Implicit type i32[] fixme this interplays badly with - // syntax for array init Implicit type time - state period = z - state times: Vec>(q, g) // a list of lists + state s: time = y // Reference to explicitly typed time parameter + state t: time = z // Reference to implicitly typed time parameter + state v: bool // Uninitialized boolean state variable + state w: time // Uninitialized time state variable + timer tick(0) // Units missing but not required + timer tock(1 sec) // Implicit type time + timer toe(z) // Implicit type time + /** + * fixme following should be equivalent: + * - state baz(p); + * - state baz: i32[4](p); + * - state baz: i32[4]({=p=}); + * + * because the initializer is the same modulo fat braces + */ + // state baz(p); // Implicit type i32[] fixme this interplays badly with syntax for array init + // Implicit type time + state period = z + state times: Vec>(q, g) // a list of lists - /** - * reactor Foo (p: i32[](1, 2)) { state baz(p); // Implicit type i32[] state - * baz({=p=}); // Implicit type i32[] } - */ - reaction(tick) {= - // Target code - =} + /** + * reactor Foo (p: i32[](1, 2)) { state baz(p); // Implicit type i32[] state baz({=p=}); // + * Implicit type i32[] } + */ + reaction(tick) {= + // Target code + =} } main reactor NativeListsAndTimes { - foo = new Foo() + foo = new Foo() } diff --git a/test/Rust/src/PortConnectionInSelfInChild.lf b/test/Rust/src/PortConnectionInSelfInChild.lf index 7fd66783f1..8deee3f39c 100644 --- a/test/Rust/src/PortConnectionInSelfInChild.lf +++ b/test/Rust/src/PortConnectionInSelfInChild.lf @@ -2,31 +2,31 @@ target Rust reactor Child { - input inp: i32 - state done: bool = false + input inp: i32 + state done: bool = false - reaction(inp) {= - assert_eq!(ctx.get(inp), Some(76600)); - self.done = true; - =} + reaction(inp) {= + assert_eq!(ctx.get(inp), Some(76600)); + self.done = true; + =} - reaction(shutdown) {= - assert!(self.done); - println!("Success") - =} + reaction(shutdown) {= + assert!(self.done); + println!("Success") + =} } reactor Parent { - input inp: i32 - child = new Child() - inp -> child.inp + input inp: i32 + child = new Child() + inp -> child.inp } main reactor { - parent = new Parent() + parent = new Parent() - reaction(startup) -> parent.inp {= - ctx.set(parent__inp, 76600); - println!("out := 76600") - =} + reaction(startup) -> parent.inp {= + ctx.set(parent__inp, 76600); + println!("out := 76600") + =} } diff --git a/test/Rust/src/PortConnectionInSelfOutSelf.lf b/test/Rust/src/PortConnectionInSelfOutSelf.lf index 2e33b0e498..d398e89f0f 100644 --- a/test/Rust/src/PortConnectionInSelfOutSelf.lf +++ b/test/Rust/src/PortConnectionInSelfOutSelf.lf @@ -2,38 +2,38 @@ target Rust reactor Source { - output out: i32 + output out: i32 - reaction(startup) -> out {= - ctx.set(out, 76600); - println!("out := 76600") - =} + reaction(startup) -> out {= + ctx.set(out, 76600); + println!("out := 76600") + =} } reactor TestCase { - input inp: i32 - output out: i32 - inp -> out + input inp: i32 + output out: i32 + inp -> out } reactor Sink { - input inp: i32 - state done: bool = false + input inp: i32 + state done: bool = false - reaction(inp) {= - assert_eq!(ctx.get(inp), Some(76600)); - println!("Success"); - self.done = true; - =} + reaction(inp) {= + assert_eq!(ctx.get(inp), Some(76600)); + println!("Success"); + self.done = true; + =} - reaction(shutdown) {= assert!(self.done, "reaction was not executed") =} + reaction(shutdown) {= assert!(self.done, "reaction was not executed") =} } main reactor { - source = new Source() - middle = new TestCase() - sink = new Sink() + source = new Source() + middle = new TestCase() + sink = new Sink() - source.out -> middle.inp - middle.out -> sink.inp + source.out -> middle.inp + middle.out -> sink.inp } diff --git a/test/Rust/src/PortConnectionOutChildOutSelf.lf b/test/Rust/src/PortConnectionOutChildOutSelf.lf index 4d58153d97..6935eb4256 100644 --- a/test/Rust/src/PortConnectionOutChildOutSelf.lf +++ b/test/Rust/src/PortConnectionOutChildOutSelf.lf @@ -2,44 +2,44 @@ target Rust reactor Child { - output out: i32 + output out: i32 - reaction(startup) -> out {= - ctx.set(out, 76600); - println!("out := 76600") - =} + reaction(startup) -> out {= + ctx.set(out, 76600); + println!("out := 76600") + =} } reactor Parent { - output out: i32 + output out: i32 - child = new Child() - child.out -> out + child = new Child() + child.out -> out } reactor Sink { - input inp: i32 - state done: bool = false + input inp: i32 + state done: bool = false - reaction(inp) {= - assert_eq!(ctx.get(inp), Some(76600)); - println!("Success"); - self.done = true; - =} + reaction(inp) {= + assert_eq!(ctx.get(inp), Some(76600)); + println!("Success"); + self.done = true; + =} - reaction(shutdown) {= assert!(self.done, "reaction was not executed") =} + reaction(shutdown) {= assert!(self.done, "reaction was not executed") =} } main reactor { - parent = new Parent() + parent = new Parent() - state done: bool = false + state done: bool = false - reaction(parent.out) {= - assert_eq!(ctx.get(parent__out), Some(76600)); - println!("Success"); - self.done = true; - =} + reaction(parent.out) {= + assert_eq!(ctx.get(parent__out), Some(76600)); + println!("Success"); + self.done = true; + =} - reaction(shutdown) {= assert!(self.done, "reaction was not executed") =} + reaction(shutdown) {= assert!(self.done, "reaction was not executed") =} } diff --git a/test/Rust/src/PortRefCleanup.lf b/test/Rust/src/PortRefCleanup.lf index 30573ceee9..3704998794 100644 --- a/test/Rust/src/PortRefCleanup.lf +++ b/test/Rust/src/PortRefCleanup.lf @@ -2,39 +2,39 @@ target Rust reactor Box { - input inp: u32 - output out: u32 + input inp: u32 + output out: u32 - inp -> out + inp -> out } main reactor { - boxr = new Box() - - timer t1(0) - timer t2(15 msec) - - state reaction_num: u32 = 0 - state done: bool = false - - reaction(t1) -> boxr.inp {= - ctx.set(boxr__inp, 150); - self.reaction_num += 1; - =} - - reaction(boxr.out, t2) {= - if self.reaction_num == 1 { - assert!(matches!(ctx.get(boxr__out), Some(150))); - } else { - assert_eq!(self.reaction_num, 2); - assert!(ctx.get(boxr__out).is_none(), "value should have been cleaned up"); - self.done = true; - } - self.reaction_num += 1; - =} - - reaction(shutdown) {= - assert!(self.done, "reaction was not executed"); - println!("success"); - =} + boxr = new Box() + + timer t1(0) + timer t2(15 msec) + + state reaction_num: u32 = 0 + state done: bool = false + + reaction(t1) -> boxr.inp {= + ctx.set(boxr__inp, 150); + self.reaction_num += 1; + =} + + reaction(boxr.out, t2) {= + if self.reaction_num == 1 { + assert!(matches!(ctx.get(boxr__out), Some(150))); + } else { + assert_eq!(self.reaction_num, 2); + assert!(ctx.get(boxr__out).is_none(), "value should have been cleaned up"); + self.done = true; + } + self.reaction_num += 1; + =} + + reaction(shutdown) {= + assert!(self.done, "reaction was not executed"); + println!("success"); + =} } diff --git a/test/Rust/src/PortValueCleanup.lf b/test/Rust/src/PortValueCleanup.lf index 9a11372cfb..5200956cdc 100644 --- a/test/Rust/src/PortValueCleanup.lf +++ b/test/Rust/src/PortValueCleanup.lf @@ -2,38 +2,38 @@ target Rust reactor Source { - output out: u32 + output out: u32 - reaction(startup) -> out {= ctx.set(out, 150); =} + reaction(startup) -> out {= ctx.set(out, 150); =} } reactor Sink { - timer t2(15 msec) - - input in: u32 - state reaction_num: u32 = 0 - state done: bool = false - - reaction(in, t2) {= - if self.reaction_num == 0 { - assert!(matches!(ctx.get(r#in), Some(150))); - } else { - assert_eq!(self.reaction_num, 1); - assert!(ctx.get(r#in).is_none(), "value should have been cleaned up"); - self.done = true; - } - self.reaction_num += 1; - =} - - reaction(shutdown) {= - assert!(self.done, "reaction was not executed"); - println!("success"); - =} + timer t2(15 msec) + + input in: u32 + state reaction_num: u32 = 0 + state done: bool = false + + reaction(in, t2) {= + if self.reaction_num == 0 { + assert!(matches!(ctx.get(r#in), Some(150))); + } else { + assert_eq!(self.reaction_num, 1); + assert!(ctx.get(r#in).is_none(), "value should have been cleaned up"); + self.done = true; + } + self.reaction_num += 1; + =} + + reaction(shutdown) {= + assert!(self.done, "reaction was not executed"); + println!("success"); + =} } main reactor { - source = new Source() - sink = new Sink() + source = new Source() + sink = new Sink() - source.out -> sink.in + source.out -> sink.in } diff --git a/test/Rust/src/ReservedKeywords.lf b/test/Rust/src/ReservedKeywords.lf index 5d30ba63a4..33e4df4586 100644 --- a/test/Rust/src/ReservedKeywords.lf +++ b/test/Rust/src/ReservedKeywords.lf @@ -1,26 +1,25 @@ -// Tests that rust keywords may be used as identifiers in LF and are properly -// escaped by the emitter +// Tests that rust keywords may be used as identifiers in LF and are properly escaped by the emitter target Rust reactor box { - input in: u32 - output struct: u32 + input in: u32 + output struct: u32 - in -> struct + in -> struct - state foo: bool = true // not escaped + state foo: bool = true // not escaped - reaction(in) {= - ctx.get(r#in); - =} + reaction(in) {= + ctx.get(r#in); + =} } main reactor ReservedKeywords(struct: u32 = 0) { - box = new box() + box = new box() - timer t1(0) - timer t2(15 msec) + timer t1(0) + timer t2(15 msec) - // not in types, this wouldn't be useful. state reaction_num: struct(0); - reaction(box.struct, t2) {= =} + // not in types, this wouldn't be useful. state reaction_num: struct(0); + reaction(box.struct, t2) {= =} } diff --git a/test/Rust/src/StateInitializerVisibility.lf b/test/Rust/src/StateInitializerVisibility.lf index d192f0ca98..276fd54027 100644 --- a/test/Rust/src/StateInitializerVisibility.lf +++ b/test/Rust/src/StateInitializerVisibility.lf @@ -1,14 +1,14 @@ -// Tests that state vars are accessible within initializers of other state vars -// declared further down. +// Tests that state vars are accessible within initializers of other state vars declared further +// down. target Rust main reactor { - state foo: u32 = 123 - state x: u32 = {= *&foo =} + state foo: u32 = 123 + state x: u32 = {= *&foo =} - reaction(startup) {= - assert_eq!(self.x, self.foo); - assert_eq!(self.x, 123); - println!("success"); - =} + reaction(startup) {= + assert_eq!(self.x, self.foo); + assert_eq!(self.x, 123); + println!("success"); + =} } diff --git a/test/Rust/src/Stop.lf b/test/Rust/src/Stop.lf index c43f8c30ff..b70a034c12 100644 --- a/test/Rust/src/Stop.lf +++ b/test/Rust/src/Stop.lf @@ -4,83 +4,82 @@ * @author Soroush Bateni */ target Rust { - timeout: 11 msec + timeout: 11 msec } /** - * @param take_a_break_after: Indicates how many messages are sent in - * consecutive superdense time - * @param break_interval: Determines how long the reactor should take a break - * after sending take_a_break_after messages. + * @param take_a_break_after: Indicates how many messages are sent in consecutive superdense time + * @param break_interval: Determines how long the reactor should take a break after sending + * take_a_break_after messages. */ reactor Sender(take_a_break_after: u32 = 10, break_interval: time = 400 msec) { - output out: u32 - logical action act - state sent_messages: u32 = 0 + output out: u32 + logical action act + state sent_messages: u32 = 0 - state take_a_break_after = take_a_break_after - state break_interval = break_interval + state take_a_break_after = take_a_break_after + state break_interval = break_interval - reaction(startup, act) -> act, out {= - // Send a message on out - println!("At tag {} sending value {}.\n", ctx.get_tag(), self.sent_messages); + reaction(startup, act) -> act, out {= + // Send a message on out + println!("At tag {} sending value {}.\n", ctx.get_tag(), self.sent_messages); - ctx.set(out, self.sent_messages); - self.sent_messages += 1; + ctx.set(out, self.sent_messages); + self.sent_messages += 1; - if self.sent_messages < self.take_a_break_after { - ctx.schedule(act, Asap); - } else { - // Take a break - self.sent_messages = 0; - ctx.schedule(act, After(self.break_interval)); - } - =} + if self.sent_messages < self.take_a_break_after { + ctx.schedule(act, Asap); + } else { + // Take a break + self.sent_messages = 0; + ctx.schedule(act, After(self.break_interval)); + } + =} } reactor Consumer { - input in_: u32 - state reaction_invoked_correctly: bool = false + input in_: u32 + state reaction_invoked_correctly: bool = false - reaction(in_) {= - let current_tag = ctx.get_tag(); + reaction(in_) {= + let current_tag = ctx.get_tag(); - if current_tag > tag!(T0 + 10 ms, 9) { - // The reaction should not have been called at tags larger than (10 msec, 9) - panic!("ERROR: Invoked reaction(in) at tag bigger than shutdown."); - } else if current_tag == tag!(T0 + 10 ms, 8) { - // Call request_stop() at relative tag (10 msec, 8) - println!("Requesting stop."); - ctx.request_stop(Asap); - return; - } else if current_tag == tag!(T0 + 10 ms, 9) { - // Check that this reaction is indeed also triggered at (10 msec, 9) - self.reaction_invoked_correctly = true; - return; - } - println!("Tag is {}.", current_tag); - =} + if current_tag > tag!(T0 + 10 ms, 9) { + // The reaction should not have been called at tags larger than (10 msec, 9) + panic!("ERROR: Invoked reaction(in) at tag bigger than shutdown."); + } else if current_tag == tag!(T0 + 10 ms, 8) { + // Call request_stop() at relative tag (10 msec, 8) + println!("Requesting stop."); + ctx.request_stop(Asap); + return; + } else if current_tag == tag!(T0 + 10 ms, 9) { + // Check that this reaction is indeed also triggered at (10 msec, 9) + self.reaction_invoked_correctly = true; + return; + } + println!("Tag is {}.", current_tag); + =} - reaction(shutdown) {= - let current_tag = ctx.get_tag(); + reaction(shutdown) {= + let current_tag = ctx.get_tag(); - println!("Shutdown invoked at tag {}.\n", current_tag); + println!("Shutdown invoked at tag {}.\n", current_tag); - // Check to see if shutdown is called at relative tag (10 msec, 9) - if current_tag == tag!(T0 + 10 ms, 9) && self.reaction_invoked_correctly { - println!("SUCCESS: successfully enforced stop."); - } else if current_tag > tag!(T0 + 10 ms, 9) { - panic!("ERROR: Shutdown invoked at tag {}. Failed to enforce timeout at (T0 + 10ms, 9).", current_tag); - } else if !self.reaction_invoked_correctly { - // Check to see if reactions were called correctly - panic!("ERROR: Failed to invoke reaction(in) at tag {}.", current_tag); - } - =} + // Check to see if shutdown is called at relative tag (10 msec, 9) + if current_tag == tag!(T0 + 10 ms, 9) && self.reaction_invoked_correctly { + println!("SUCCESS: successfully enforced stop."); + } else if current_tag > tag!(T0 + 10 ms, 9) { + panic!("ERROR: Shutdown invoked at tag {}. Failed to enforce timeout at (T0 + 10ms, 9).", current_tag); + } else if !self.reaction_invoked_correctly { + // Check to see if reactions were called correctly + panic!("ERROR: Failed to invoke reaction(in) at tag {}.", current_tag); + } + =} } main reactor Stop { - consumer = new Consumer() - producer = new Sender(break_interval = 1 msec) + consumer = new Consumer() + producer = new Sender(break_interval = 1 msec) - producer.out -> consumer.in_ + producer.out -> consumer.in_ } diff --git a/test/Rust/src/StopIdempotence.lf b/test/Rust/src/StopIdempotence.lf index 1f79347758..c5f4dcf342 100644 --- a/test/Rust/src/StopIdempotence.lf +++ b/test/Rust/src/StopIdempotence.lf @@ -1,21 +1,21 @@ /** Tests that ports are cleaned up before the shutdown wave executes. */ target Rust { - timeout: 30 msec + timeout: 30 msec } main reactor StopIdempotence { - state count: u32 = 0 + state count: u32 = 0 - reaction(startup) {= - ctx.request_stop(Asap); // requested for (T0, 1) - assert_tag_is!(ctx, T0); - =} + reaction(startup) {= + ctx.request_stop(Asap); // requested for (T0, 1) + assert_tag_is!(ctx, T0); + =} - reaction(shutdown) {= - ctx.request_stop(Asap); // requested for (T0, 1) - assert_eq!(self.count, 0, "Shutdown was run several times"); - self.count += 1; - assert_tag_is!(ctx, (T0, 1)); - println!("success"); - =} + reaction(shutdown) {= + ctx.request_stop(Asap); // requested for (T0, 1) + assert_eq!(self.count, 0, "Shutdown was run several times"); + self.count += 1; + assert_tag_is!(ctx, (T0, 1)); + println!("success"); + =} } diff --git a/test/Rust/src/StopTimeoutExact.lf b/test/Rust/src/StopTimeoutExact.lf index 2b9eb85cda..0261e8b0d9 100644 --- a/test/Rust/src/StopTimeoutExact.lf +++ b/test/Rust/src/StopTimeoutExact.lf @@ -1,25 +1,25 @@ /** - * Tests that when a timeout coincides with a scheduled event, all scheduled - * reactions are properly executed (in addition to the shutdown ones). + * Tests that when a timeout coincides with a scheduled event, all scheduled reactions are properly + * executed (in addition to the shutdown ones). */ target Rust { - timeout: 50 msec + timeout: 50 msec } main reactor StopTimeoutExact { - timer t(0, 10 msec) // the fifth triggering will coincide with the timeout + timer t(0, 10 msec) // the fifth triggering will coincide with the timeout - state reacted_on_shutdown: bool = false + state reacted_on_shutdown: bool = false - reaction(t) {= - if ctx.get_tag() == tag!(T0 + 50 ms) { - self.reacted_on_shutdown = true; - } - =} + reaction(t) {= + if ctx.get_tag() == tag!(T0 + 50 ms) { + self.reacted_on_shutdown = true; + } + =} - reaction(shutdown) {= - assert_tag_is!(ctx, T0 + 50 ms); - assert!(self.reacted_on_shutdown, "Reaction was not executed"); - println!("Success!"); // if this is not printed the test failed - =} + reaction(shutdown) {= + assert_tag_is!(ctx, T0 + 50 ms); + assert!(self.reacted_on_shutdown, "Reaction was not executed"); + println!("Success!"); // if this is not printed the test failed + =} } diff --git a/test/Rust/src/StructAsState.lf b/test/Rust/src/StructAsState.lf index 9b35e7a3fb..574d3ff59f 100644 --- a/test/Rust/src/StructAsState.lf +++ b/test/Rust/src/StructAsState.lf @@ -1,27 +1,27 @@ -// Check that a state variable can have a statically initialized struct as a -// value. Check how preambles work +// Check that a state variable can have a statically initialized struct as a value. Check how +// preambles work target Rust main reactor StructAsState { - preamble {= - struct Hello { - name: String, - value: i32, - } - =} - /** - * notice this uses parentheses todo - * - state s: Hello(name= "Earth".into(), value= 42); - * - state s: Hello(name: "Earth".into(), value: 42); - * - state s: Hello { name: "Earth".into(), value: 42 }; - */ - state s: Hello = {= Hello { name: "Earth".into(), value: 42 } =} + preamble {= + struct Hello { + name: String, + value: i32, + } + =} + /** + * notice this uses parentheses todo + * - state s: Hello(name= "Earth".into(), value= 42); + * - state s: Hello(name: "Earth".into(), value: 42); + * - state s: Hello { name: "Earth".into(), value: 42 }; + */ + state s: Hello = {= Hello { name: "Earth".into(), value: 42 } =} - reaction(startup) {= - println!("State s.name=\"{}\", s.value={}.", self.s.name, self.s.value); - if self.s.value != 42 { - eprintln!("FAILED: Expected 42."); - std::process::exit(1); - } - =} + reaction(startup) {= + println!("State s.name=\"{}\", s.value={}.", self.s.name, self.s.value); + if self.s.value != 42 { + eprintln!("FAILED: Expected 42."); + std::process::exit(1); + } + =} } diff --git a/test/Rust/src/StructAsType.lf b/test/Rust/src/StructAsType.lf index 0c8ed51456..93450959b5 100644 --- a/test/Rust/src/StructAsType.lf +++ b/test/Rust/src/StructAsType.lf @@ -2,38 +2,38 @@ target Rust reactor Source { - output out: Hello + output out: Hello - preamble {= - pub struct Hello { - pub name: String, - pub value: i32, - } - =} + preamble {= + pub struct Hello { + pub name: String, + pub value: i32, + } + =} - reaction(startup) -> out {= - // Create the struct on the stack and then copy - // it to the output - ctx.set(out, Hello { name: "Earth".into(), value: 42 }) - =} + reaction(startup) -> out {= + // Create the struct on the stack and then copy + // it to the output + ctx.set(out, Hello { name: "Earth".into(), value: 42 }) + =} } reactor Print(expected: i32 = 42) { // expected parameter is for testing. - input inp: {= super::source::Hello =} - state expected: i32 = expected + input inp: {= super::source::Hello =} + state expected: i32 = expected - reaction(inp) {= - ctx.use_ref_opt(inp, |hello| { - println!("Received: name=\"{}\", value={}.", hello.name, hello.value); - if hello.value != self.expected { - panic!("ERROR: Expected value to be {}.\n", self.expected); - } - }); - =} + reaction(inp) {= + ctx.use_ref_opt(inp, |hello| { + println!("Received: name=\"{}\", value={}.", hello.name, hello.value); + if hello.value != self.expected { + panic!("ERROR: Expected value to be {}.\n", self.expected); + } + }); + =} } main reactor StructAsType { - s = new Source() - p = new Print() - s.out -> p.inp + s = new Source() + p = new Print() + s.out -> p.inp } diff --git a/test/Rust/src/TimeState.lf b/test/Rust/src/TimeState.lf index efffb00c2f..3de9934e28 100644 --- a/test/Rust/src/TimeState.lf +++ b/test/Rust/src/TimeState.lf @@ -1,11 +1,11 @@ target Rust reactor Foo { - state baz: time = 500 msec + state baz: time = 500 msec - reaction(startup) {= assert_eq!(500, self.baz.as_millis()); =} + reaction(startup) {= assert_eq!(500, self.baz.as_millis()); =} } main reactor TimeState { - a = new Foo() + a = new Foo() } diff --git a/test/Rust/src/TimerDefaults.lf b/test/Rust/src/TimerDefaults.lf index bbc920bf4a..f6f02b1e49 100644 --- a/test/Rust/src/TimerDefaults.lf +++ b/test/Rust/src/TimerDefaults.lf @@ -1,12 +1,12 @@ target Rust main reactor TimerDefaults { - state i: i32 = 0 - timer t + state i: i32 = 0 + timer t - reaction(t) {= - assert_tag_is!(ctx, T0); - println!("Tick {} after {} ms", self.i, ctx.get_elapsed_physical_time().as_millis()); - self.i += 1; - =} + reaction(t) {= + assert_tag_is!(ctx, T0); + println!("Tick {} after {} ms", self.i, ctx.get_elapsed_physical_time().as_millis()); + self.i += 1; + =} } diff --git a/test/Rust/src/TimerIsPresent.lf b/test/Rust/src/TimerIsPresent.lf index 1e87c11f51..18977c42cf 100644 --- a/test/Rust/src/TimerIsPresent.lf +++ b/test/Rust/src/TimerIsPresent.lf @@ -1,52 +1,52 @@ // Tests the is_present function for timers. target Rust { - timeout: 7 msec + timeout: 7 msec } main reactor { - timer a(0, 5 msec) - timer b(1 msec, 5 msec) - timer c(1 msec) + timer a(0, 5 msec) + timer b(1 msec, 5 msec) + timer c(1 msec) - state success: bool = false - state tick: u32 = 0 + state success: bool = false + state tick: u32 = 0 - reaction(startup, a, b, c) {= - match self.tick { - 0 => { // startup - assert_tag_is!(ctx, T0); - assert!(ctx.is_present(a)); - assert!(!ctx.is_present(b)); - assert!(!ctx.is_present(c)); - }, - 1 => { // 1 msec - assert_tag_is!(ctx, T0 + 1 ms); - assert!(!ctx.is_present(a)); - assert!(ctx.is_present(b)); - assert!(ctx.is_present(c)); - }, - 2 => { // 5 msec (a triggers) - assert_tag_is!(ctx, T0 + 5 ms); - assert!(ctx.is_present(a)); - assert!(!ctx.is_present(b)); - assert!(!ctx.is_present(c)); - }, - 3 => { // 6 msec (b triggers) - assert_tag_is!(ctx, T0 + 6 ms); - assert!(!ctx.is_present(a)); - assert!(ctx.is_present(b)); - assert!(!ctx.is_present(c)); - self.success = true; - }, - _ => { - unreachable!("unexpected reaction invocation"); - } - } - self.tick += 1; - =} + reaction(startup, a, b, c) {= + match self.tick { + 0 => { // startup + assert_tag_is!(ctx, T0); + assert!(ctx.is_present(a)); + assert!(!ctx.is_present(b)); + assert!(!ctx.is_present(c)); + }, + 1 => { // 1 msec + assert_tag_is!(ctx, T0 + 1 ms); + assert!(!ctx.is_present(a)); + assert!(ctx.is_present(b)); + assert!(ctx.is_present(c)); + }, + 2 => { // 5 msec (a triggers) + assert_tag_is!(ctx, T0 + 5 ms); + assert!(ctx.is_present(a)); + assert!(!ctx.is_present(b)); + assert!(!ctx.is_present(c)); + }, + 3 => { // 6 msec (b triggers) + assert_tag_is!(ctx, T0 + 6 ms); + assert!(!ctx.is_present(a)); + assert!(ctx.is_present(b)); + assert!(!ctx.is_present(c)); + self.success = true; + }, + _ => { + unreachable!("unexpected reaction invocation"); + } + } + self.tick += 1; + =} - reaction(shutdown) {= - assert!(self.success); - println!("success"); - =} + reaction(shutdown) {= + assert!(self.success); + println!("success"); + =} } diff --git a/test/Rust/src/TimerPeriodic.lf b/test/Rust/src/TimerPeriodic.lf index c6dce10a73..2015bb9d19 100644 --- a/test/Rust/src/TimerPeriodic.lf +++ b/test/Rust/src/TimerPeriodic.lf @@ -1,18 +1,18 @@ target Rust { - timeout: 15 msec // fast: true + timeout: 15 msec // fast: true } main reactor TimerPeriodic { - state i: i32 = 0 - timer t2(0, 3 msec) + state i: i32 = 0 + timer t2(0, 3 msec) - reaction(t2) {= - println!("Tick {} at {}", self.i, ctx.get_tag()); - self.i += 1; - =} + reaction(t2) {= + println!("Tick {} at {}", self.i, ctx.get_tag()); + self.i += 1; + =} - reaction(shutdown) {= - assert_eq!(self.i, 6); - println!("success"); - =} + reaction(shutdown) {= + assert_eq!(self.i, 6); + println!("success"); + =} } diff --git a/test/Rust/src/Timers.lf b/test/Rust/src/Timers.lf index 1ef5fc0ae5..16b359966c 100644 --- a/test/Rust/src/Timers.lf +++ b/test/Rust/src/Timers.lf @@ -1,19 +1,19 @@ /** Test whether timers with different periods are triggered correctly. */ target Rust { - timeout: 2 sec + timeout: 2 sec } main reactor Timers { - timer t(0, 1 sec) - timer t2(0, 2 sec) - state counter: i32 = 0 + timer t(0, 1 sec) + timer t2(0, 2 sec) + state counter: i32 = 0 - reaction(t2) {= self.counter += 2; =} + reaction(t2) {= self.counter += 2; =} - reaction(t) {= self.counter -= 1; =} + reaction(t) {= self.counter -= 1; =} - reaction(shutdown) {= - assert_eq!(1, self.counter); - println!("SUCCESS.") - =} + reaction(shutdown) {= + assert_eq!(1, self.counter); + println!("SUCCESS.") + =} } diff --git a/test/Rust/src/TypeVarLengthList.lf b/test/Rust/src/TypeVarLengthList.lf index 37ff36df56..41e964aa0c 100644 --- a/test/Rust/src/TypeVarLengthList.lf +++ b/test/Rust/src/TypeVarLengthList.lf @@ -3,13 +3,13 @@ target Rust // this thing must compile needs to be modified when // https://github.com/lf-lang/lingua-franca/discussions/492 is implemented main reactor TypeVarLengthList { - state l0: i32[] = {= Vec::new() =} // generates l0: Vec::new() - // generates l1: vec![1, 2] - /** - * - state l2: i32[](1); // generates l2: 1 // doesn't compile... - * - state l3: i32[](); // doesn't parse... - * - * - state l1: Vec(1, 2); // does not compile... - */ - state l1: i32[](1, 2) + state l0: i32[] = {= Vec::new() =} // generates l0: Vec::new() + // generates l1: vec![1, 2] + /** + * - state l2: i32[](1); // generates l2: 1 // doesn't compile... + * - state l3: i32[](); // doesn't parse... + * + * - state l1: Vec(1, 2); // does not compile... + */ + state l1: i32[](1, 2) } diff --git a/test/Rust/src/concurrent/AsyncCallback.lf b/test/Rust/src/concurrent/AsyncCallback.lf index dccbcf37c0..64ced0d2be 100644 --- a/test/Rust/src/concurrent/AsyncCallback.lf +++ b/test/Rust/src/concurrent/AsyncCallback.lf @@ -1,60 +1,60 @@ // Test asynchronous callbacks that trigger a physical action. target Rust { - timeout: 1000 ms, - cargo-features: ["cli"] + timeout: 1000 ms, + cargo-features: ["cli"] } main reactor AsyncCallback(period: time = 10 msec) { - preamble {= use std::thread; =} - - timer t(0, period) - state thread: Option> - state expected_time: time = period - state period: time = period - state toggle: bool = false - - physical action act - state i: u32 = 0 - - reaction(t) -> act {= - let act = act.clone(); - let period = self.period; - if let Some(old_thread) = self.thread.take() { - old_thread.join().ok(); - } - // start new thread - let new_thread = ctx.spawn_physical_thread(move |ctx| { - // Simulate time passing before a callback occurs - thread::sleep(period); - // Schedule twice. If the action is not physical, these should - // get consolidated into a single action triggering. If it is, - // then they cause two separate triggerings with close but not - // equal time stamps. - ctx.schedule_physical(&act, Asap).ok(); - ctx.schedule_physical(&act, Asap).ok(); - }); - - self.thread.replace(new_thread); - =} - - reaction(act) {= - let elapsed_time = ctx.get_elapsed_logical_time(); - let i = self.i; - println!("Asynchronous callback {}: Assigned logical time greater than start time by {} ms", - i, elapsed_time.as_millis()); - assert!(elapsed_time > self.expected_time,"ERROR: Expected logical time to be larger than {} ms", self.expected_time.as_millis()); - - self.i += 1; - if self.toggle { - self.expected_time += self.period; - } - self.toggle = !self.toggle; - =} - - reaction(shutdown) {= - if let Some(thread) = self.thread.take() { - thread.join().ok(); - } - println!("success"); - =} + preamble {= use std::thread; =} + + timer t(0, period) + state thread: Option> + state expected_time: time = period + state period: time = period + state toggle: bool = false + + physical action act + state i: u32 = 0 + + reaction(t) -> act {= + let act = act.clone(); + let period = self.period; + if let Some(old_thread) = self.thread.take() { + old_thread.join().ok(); + } + // start new thread + let new_thread = ctx.spawn_physical_thread(move |ctx| { + // Simulate time passing before a callback occurs + thread::sleep(period); + // Schedule twice. If the action is not physical, these should + // get consolidated into a single action triggering. If it is, + // then they cause two separate triggerings with close but not + // equal time stamps. + ctx.schedule_physical(&act, Asap).ok(); + ctx.schedule_physical(&act, Asap).ok(); + }); + + self.thread.replace(new_thread); + =} + + reaction(act) {= + let elapsed_time = ctx.get_elapsed_logical_time(); + let i = self.i; + println!("Asynchronous callback {}: Assigned logical time greater than start time by {} ms", + i, elapsed_time.as_millis()); + assert!(elapsed_time > self.expected_time,"ERROR: Expected logical time to be larger than {} ms", self.expected_time.as_millis()); + + self.i += 1; + if self.toggle { + self.expected_time += self.period; + } + self.toggle = !self.toggle; + =} + + reaction(shutdown) {= + if let Some(thread) = self.thread.take() { + thread.join().ok(); + } + println!("success"); + =} } diff --git a/test/Rust/src/generics/CtorParamGeneric.lf b/test/Rust/src/generics/CtorParamGeneric.lf index 1c8b1cab24..44d630a152 100644 --- a/test/Rust/src/generics/CtorParamGeneric.lf +++ b/test/Rust/src/generics/CtorParamGeneric.lf @@ -2,21 +2,21 @@ target Rust reactor Generic<{= T: Default + Eq + Sync + std::fmt::Debug =}>( - value: T = {= Default::default() =} + value: T = {= Default::default() =} ) { - input in: T - state v: T = value + input in: T + state v: T = value - reaction(in) {= - ctx.use_ref_opt(r#in, |i| { - assert_eq!(&self.v, i); - println!("success"); - }); - =} + reaction(in) {= + ctx.use_ref_opt(r#in, |i| { + assert_eq!(&self.v, i); + println!("success"); + }); + =} } main reactor { - p = new Generic(value = 23) + p = new Generic(value = 23) - reaction(startup) -> p.in {= ctx.set(p__in, 23); =} + reaction(startup) -> p.in {= ctx.set(p__in, 23); =} } diff --git a/test/Rust/src/generics/CtorParamGenericInst.lf b/test/Rust/src/generics/CtorParamGenericInst.lf index 86f696185c..8c5d2522aa 100644 --- a/test/Rust/src/generics/CtorParamGenericInst.lf +++ b/test/Rust/src/generics/CtorParamGenericInst.lf @@ -1,37 +1,33 @@ -// this one is deeper than CtorParamGeneric, it illustrates the use of ctor -// parameters within the argument list of a further child instance. +// this one is deeper than CtorParamGeneric, it illustrates the use of ctor parameters within the +// argument list of a further child instance. target Rust -reactor Generic2< - {= T: Default + Eq + Sync + std::fmt::Debug + Send + 'static =} ->( - value: T = {= Default::default() =} +reactor Generic2<{= T: Default + Eq + Sync + std::fmt::Debug + Send + 'static =}>( + value: T = {= Default::default() =} ) { - input in: T - state v: T = value + input in: T + state v: T = value - reaction(in) {= - ctx.use_ref_opt(r#in, |i| { - assert_eq!(&self.v, i); - println!("success"); - }); - =} + reaction(in) {= + ctx.use_ref_opt(r#in, |i| { + assert_eq!(&self.v, i); + println!("success"); + }); + =} } -reactor Generic< - {= T: Default + Eq + Sync + std::fmt::Debug + Copy + Send + 'static =} ->( - value: T = {= Default::default() =} +reactor Generic<{= T: Default + Eq + Sync + std::fmt::Debug + Copy + Send + 'static =}>( + value: T = {= Default::default() =} ) { - input in: T + input in: T - inner = new Generic2(value = value) + inner = new Generic2(value = value) - in -> inner.in + in -> inner.in } main reactor { - p = new Generic(value = 23) + p = new Generic(value = 23) - reaction(startup) -> p.in {= ctx.set(p__in, 23); =} + reaction(startup) -> p.in {= ctx.set(p__in, 23); =} } diff --git a/test/Rust/src/generics/GenericComplexType.lf b/test/Rust/src/generics/GenericComplexType.lf index 67453e6530..34765ade72 100644 --- a/test/Rust/src/generics/GenericComplexType.lf +++ b/test/Rust/src/generics/GenericComplexType.lf @@ -2,21 +2,21 @@ target Rust reactor R { - input in: Vec

    For targets that provide a threaded and an unthreaded runtime, this configures using the + * unthreaded runtime. For targets that do not distinguish threaded and unthreaded runtime, the + * number of workers is set to 1. + * + * @param test The test to configure. + * @return True if successful, false otherwise. + */ + public static boolean disableThreading(LFTest test) { + test.getContext().getArgs().setProperty("threading", "false"); + test.getContext().getArgs().setProperty("workers", "1"); + return true; + } - public static boolean makeZephyrCompatible(LFTest test) { - test.getContext().getArgs().setProperty("tracing", "false"); - test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; - test.getContext().getTargetConfig().platformOptions.flash = false; - test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; - return true; - } + public static boolean makeZephyrCompatibleUnthreaded(LFTest test) { + test.getContext().getArgs().setProperty("tracing", "false"); + test.getContext().getTargetConfig().threading = false; + test.getContext().getTargetConfig().setByUser.add(TargetProperty.THREADING); + test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; + test.getContext().getTargetConfig().platformOptions.flash = false; + test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; + return true; + } - /** - * Make no changes to the configuration. - * - * @param ignoredTest The test to configure. - * @return True - */ - public static boolean noChanges(LFTest ignoredTest) { - return true; - } + public static boolean makeZephyrCompatible(LFTest test) { + test.getContext().getArgs().setProperty("tracing", "false"); + test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; + test.getContext().getTargetConfig().platformOptions.flash = false; + test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; + return true; + } - /** - * Given a test category, return true if it is compatible with single-threaded execution. - */ - public static boolean compatibleWithThreadingOff(TestCategory category) { + /** + * Make no changes to the configuration. + * + * @param ignoredTest The test to configure. + * @return True + */ + public static boolean noChanges(LFTest ignoredTest) { + return true; + } + + /** Given a test category, return true if it is compatible with single-threaded execution. */ + public static boolean compatibleWithThreadingOff(TestCategory category) { - // CONCURRENT, FEDERATED, DOCKER_FEDERATED, DOCKER - // are not compatible with single-threaded execution. - // ARDUINO and ZEPHYR have their own test suites, so we don't need to rerun. - boolean excluded = category == TestCategory.CONCURRENT + // CONCURRENT, FEDERATED, DOCKER_FEDERATED, DOCKER + // are not compatible with single-threaded execution. + // ARDUINO and ZEPHYR have their own test suites, so we don't need to rerun. + boolean excluded = + category == TestCategory.CONCURRENT || category == TestCategory.SERIALIZATION || category == TestCategory.FEDERATED || category == TestCategory.DOCKER_FEDERATED @@ -109,8 +106,8 @@ public static boolean compatibleWithThreadingOff(TestCategory category) { || category == TestCategory.ARDUINO || category == TestCategory.ZEPHYR; - // SERIALIZATION and TARGET tests are excluded on Windows. - excluded |= TestBase.isWindows() && (category == TestCategory.TARGET); - return !excluded; - } + // SERIALIZATION and TARGET tests are excluded on Windows. + excluded |= TestBase.isWindows() && (category == TestCategory.TARGET); + return !excluded; + } } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java index c1e2e5e3f5..db5eb46fc3 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java @@ -1,35 +1,32 @@ /************* -Copyright (c) 2023, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2023, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.tests.runtime; import java.util.List; - import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; - import org.lflang.Target; import org.lflang.tests.Configurators; import org.lflang.tests.RuntimeTest; @@ -42,29 +39,31 @@ */ public class CZephyrTest extends RuntimeTest { - public CZephyrTest() { - super(Target.C); - } + public CZephyrTest() { + super(Target.C); + } - @Test - public void buildZephyrTests() { - Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); - super.runTestsFor(List.of(Target.C), - Message.DESC_ZEPHYR, - TestCategory.ZEPHYR::equals, - Configurators::makeZephyrCompatible, - TestLevel.BUILD, - false); - } - @Test - public void buildGenericTests() { - Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); - super.runTestsFor(List.of(Target.C), - Message.DESC_GENERIC, - TestCategory.GENERIC::equals, - Configurators::makeZephyrCompatibleUnthreaded, - TestLevel.BUILD, - false); - } -} + @Test + public void buildZephyrTests() { + Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); + super.runTestsFor( + List.of(Target.C), + Message.DESC_ZEPHYR, + TestCategory.ZEPHYR::equals, + Configurators::makeZephyrCompatible, + TestLevel.BUILD, + false); + } + @Test + public void buildGenericTests() { + Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); + super.runTestsFor( + List.of(Target.C), + Message.DESC_GENERIC, + TestCategory.GENERIC::equals, + Configurators::makeZephyrCompatibleUnthreaded, + TestLevel.BUILD, + false); + } +} diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 3d2b77dd4c..af805491da 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -1,27 +1,27 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang; import java.util.ArrayList; @@ -32,7 +32,6 @@ import java.util.Objects; import java.util.Properties; import java.util.Set; - import org.lflang.TargetProperty.BuildType; import org.lflang.TargetProperty.ClockSyncMode; import org.lflang.TargetProperty.CoordinationType; @@ -48,458 +47,382 @@ /** * A class for keeping the current target configuration. * - * Class members of type String are initialized as empty strings, - * unless otherwise stated. + *

    Class members of type String are initialized as empty strings, unless otherwise stated. + * * @author Marten Lohstroh */ public class TargetConfig { - /** - * The target of this configuration (e.g., C, TypeScript, Python). - */ - public final Target target; - - /** - * Create a new target configuration based on the given target declaration AST node only. - * @param target AST node of a target declaration. - */ - public TargetConfig(TargetDecl target) { // FIXME: eliminate this constructor if we can - this.target = Target.fromDecl(target); + /** The target of this configuration (e.g., C, TypeScript, Python). */ + public final Target target; + + /** + * Create a new target configuration based on the given target declaration AST node only. + * + * @param target AST node of a target declaration. + */ + public TargetConfig(TargetDecl target) { // FIXME: eliminate this constructor if we can + this.target = Target.fromDecl(target); + } + + /** + * Create a new target configuration based on the given commandline arguments and target + * declaration AST node. + * + * @param cliArgs Arguments passed on the commandline. + * @param target AST node of a target declaration. + * @param errorReporter An error reporter to report problems. + */ + public TargetConfig(Properties cliArgs, TargetDecl target, ErrorReporter errorReporter) { + this(target); + if (target.getConfig() != null) { + List pairs = target.getConfig().getPairs(); + TargetProperty.set(this, pairs != null ? pairs : List.of(), errorReporter); } - - /** - * Create a new target configuration based on the given commandline arguments and target - * declaration AST node. - * @param cliArgs Arguments passed on the commandline. - * @param target AST node of a target declaration. - * @param errorReporter An error reporter to report problems. - */ - public TargetConfig( - Properties cliArgs, - TargetDecl target, - ErrorReporter errorReporter - ) { - this(target); - if (target.getConfig() != null) { - List pairs = target.getConfig().getPairs(); - TargetProperty.set(this, pairs != null ? pairs : List.of(), errorReporter); - } - if (cliArgs.containsKey("no-compile")) { - this.noCompile = true; - } - if (cliArgs.containsKey("docker")) { - var arg = cliArgs.getProperty("docker"); - if (Boolean.parseBoolean(arg)) { - this.dockerOptions = new DockerOptions(); - } else { - this.dockerOptions = null; - } - // FIXME: this is pretty ad-hoc and does not account for more complex overrides yet. - } - if (cliArgs.containsKey("build-type")) { - this.cmakeBuildType = (BuildType) UnionType.BUILD_TYPE_UNION.forName(cliArgs.getProperty("build-type")); - } - if (cliArgs.containsKey("logging")) { - this.logLevel = LogLevel.valueOf(cliArgs.getProperty("logging").toUpperCase()); - } - if (cliArgs.containsKey("workers")) { - this.workers = Integer.parseInt(cliArgs.getProperty("workers")); - } - if (cliArgs.containsKey("threading")) { - this.threading = Boolean.parseBoolean(cliArgs.getProperty("threading")); - } - if (cliArgs.containsKey("target-compiler")) { - this.compiler = cliArgs.getProperty("target-compiler"); - } - if (cliArgs.containsKey("tracing")) { - this.tracing = new TracingOptions(); - } - if (cliArgs.containsKey("scheduler")) { - this.schedulerType = SchedulerOption.valueOf( - cliArgs.getProperty("scheduler") - ); - this.setByUser.add(TargetProperty.SCHEDULER); - } - if (cliArgs.containsKey("target-flags")) { - this.compilerFlags.clear(); - if (!cliArgs.getProperty("target-flags").isEmpty()) { - this.compilerFlags.addAll(List.of( - cliArgs.getProperty("target-flags").split(" ") - )); - } - } - if (cliArgs.containsKey("runtime-version")) { - this.runtimeVersion = cliArgs.getProperty("runtime-version"); - } - if (cliArgs.containsKey("external-runtime-path")) { - this.externalRuntimePath = cliArgs.getProperty("external-runtime-path"); - } - if (cliArgs.containsKey(TargetProperty.KEEPALIVE.description)) { - this.keepalive = Boolean.parseBoolean( - cliArgs.getProperty(TargetProperty.KEEPALIVE.description)); - } - if (cliArgs.containsKey(BuildParm.PRINT_STATISTICS.getKey())) { - this.printStatistics = true; - } + if (cliArgs.containsKey("no-compile")) { + this.noCompile = true; + } + if (cliArgs.containsKey("docker")) { + var arg = cliArgs.getProperty("docker"); + if (Boolean.parseBoolean(arg)) { + this.dockerOptions = new DockerOptions(); + } else { + this.dockerOptions = null; + } + // FIXME: this is pretty ad-hoc and does not account for more complex overrides yet. + } + if (cliArgs.containsKey("build-type")) { + this.cmakeBuildType = + (BuildType) UnionType.BUILD_TYPE_UNION.forName(cliArgs.getProperty("build-type")); + } + if (cliArgs.containsKey("logging")) { + this.logLevel = LogLevel.valueOf(cliArgs.getProperty("logging").toUpperCase()); + } + if (cliArgs.containsKey("workers")) { + this.workers = Integer.parseInt(cliArgs.getProperty("workers")); + } + if (cliArgs.containsKey("threading")) { + this.threading = Boolean.parseBoolean(cliArgs.getProperty("threading")); + } + if (cliArgs.containsKey("target-compiler")) { + this.compiler = cliArgs.getProperty("target-compiler"); + } + if (cliArgs.containsKey("tracing")) { + this.tracing = new TracingOptions(); + } + if (cliArgs.containsKey("scheduler")) { + this.schedulerType = SchedulerOption.valueOf(cliArgs.getProperty("scheduler")); + this.setByUser.add(TargetProperty.SCHEDULER); + } + if (cliArgs.containsKey("target-flags")) { + this.compilerFlags.clear(); + if (!cliArgs.getProperty("target-flags").isEmpty()) { + this.compilerFlags.addAll(List.of(cliArgs.getProperty("target-flags").split(" "))); + } + } + if (cliArgs.containsKey("runtime-version")) { + this.runtimeVersion = cliArgs.getProperty("runtime-version"); + } + if (cliArgs.containsKey("external-runtime-path")) { + this.externalRuntimePath = cliArgs.getProperty("external-runtime-path"); + } + if (cliArgs.containsKey(TargetProperty.KEEPALIVE.description)) { + this.keepalive = + Boolean.parseBoolean(cliArgs.getProperty(TargetProperty.KEEPALIVE.description)); } + if (cliArgs.containsKey(BuildParm.PRINT_STATISTICS.getKey())) { + this.printStatistics = true; + } + } - /** - * Keep track of every target property that is explicitly set by the user. - */ - public Set setByUser = new HashSet<>(); + /** Keep track of every target property that is explicitly set by the user. */ + public Set setByUser = new HashSet<>(); - /** - * A list of custom build commands that replace the default build process of - * directly invoking a designated compiler. A common usage of this target - * property is to set the command to build on the basis of a Makefile. - */ - public List buildCommands = new ArrayList<>(); + /** + * A list of custom build commands that replace the default build process of directly invoking a + * designated compiler. A common usage of this target property is to set the command to build on + * the basis of a Makefile. + */ + public List buildCommands = new ArrayList<>(); - /** - * The mode of clock synchronization to be used in federated programs. - * The default is 'initial'. - */ - public ClockSyncMode clockSync = ClockSyncMode.INIT; + /** + * The mode of clock synchronization to be used in federated programs. The default is 'initial'. + */ + public ClockSyncMode clockSync = ClockSyncMode.INIT; - /** - * Clock sync options. - */ - public ClockSyncOptions clockSyncOptions = new ClockSyncOptions(); + /** Clock sync options. */ + public ClockSyncOptions clockSyncOptions = new ClockSyncOptions(); - /** - * Parameter passed to cmake. The default is 'Release'. - */ - public BuildType cmakeBuildType = BuildType.RELEASE; + /** Parameter passed to cmake. The default is 'Release'. */ + public BuildType cmakeBuildType = BuildType.RELEASE; - /** - * Optional additional extensions to include in the generated CMakeLists.txt. - */ - public List cmakeIncludes = new ArrayList<>(); + /** Optional additional extensions to include in the generated CMakeLists.txt. */ + public List cmakeIncludes = new ArrayList<>(); - /** - * The compiler to invoke, unless a build command has been specified. - */ - public String compiler = ""; + /** The compiler to invoke, unless a build command has been specified. */ + public String compiler = ""; - /** - * Additional sources to add to the compile command if appropriate. - */ - public List compileAdditionalSources = new ArrayList<>(); + /** Additional sources to add to the compile command if appropriate. */ + public List compileAdditionalSources = new ArrayList<>(); - /** - * Additional (preprocessor) definitions to add to the compile command if appropriate. - * - * The first string is the definition itself, and the second string is the value to attribute to that definition, if any. - * The second value could be left empty. - */ - public Map compileDefinitions = new HashMap<>(); + /** + * Additional (preprocessor) definitions to add to the compile command if appropriate. + * + *

    The first string is the definition itself, and the second string is the value to attribute + * to that definition, if any. The second value could be left empty. + */ + public Map compileDefinitions = new HashMap<>(); - /** - * Additional libraries to add to the compile command using the "-l" command-line option. - */ - public List compileLibraries = new ArrayList<>(); + /** Additional libraries to add to the compile command using the "-l" command-line option. */ + public List compileLibraries = new ArrayList<>(); - /** - * Flags to pass to the compiler, unless a build command has been specified. - */ - public List compilerFlags = new ArrayList<>(); + /** Flags to pass to the compiler, unless a build command has been specified. */ + public List compilerFlags = new ArrayList<>(); - /** - * The type of coordination used during the execution of a federated program. - * The default is 'centralized'. - */ - public CoordinationType coordination = CoordinationType.CENTRALIZED; + /** + * The type of coordination used during the execution of a federated program. The default is + * 'centralized'. + */ + public CoordinationType coordination = CoordinationType.CENTRALIZED; + + /** Docker options. */ + public DockerOptions dockerOptions = null; - /** - * Docker options. - */ - public DockerOptions dockerOptions = null; + /** Coordination options. */ + public CoordinationOptions coordinationOptions = new CoordinationOptions(); - /** - * Coordination options. - */ - public CoordinationOptions coordinationOptions = new CoordinationOptions(); + /** Link to an external runtime library instead of the default one. */ + public String externalRuntimePath = null; - /** - * Link to an external runtime library instead of the default one. - */ - public String externalRuntimePath = null; + /** + * If true, configure the execution environment such that it does not wait for physical time to + * match logical time. The default is false. + */ + public boolean fastMode = false; - /** - * If true, configure the execution environment such that it does not - * wait for physical time to match logical time. The default is false. - */ - public boolean fastMode = false; + /** List of files to be copied to src-gen. */ + public List files = new ArrayList<>(); - /** - * List of files to be copied to src-gen. - */ - public List files = new ArrayList<>(); + /** + * If true, configure the execution environment to keep executing if there are no more events on + * the event queue. The default is false. + */ + public boolean keepalive = false; - /** - * If true, configure the execution environment to keep executing if there - * are no more events on the event queue. The default is false. - */ - public boolean keepalive = false; + /** The level of logging during execution. The default is INFO. */ + public LogLevel logLevel = LogLevel.INFO; - /** - * The level of logging during execution. The default is INFO. - */ - public LogLevel logLevel = LogLevel.INFO; + /** Flags to pass to the linker, unless a build command has been specified. */ + public String linkerFlags = ""; - /** - * Flags to pass to the linker, unless a build command has been specified. - */ - public String linkerFlags = ""; + /** If true, do not invoke the target compiler or build command. The default is false. */ + public boolean noCompile = false; - /** - * If true, do not invoke the target compiler or build command. - * The default is false. - */ - public boolean noCompile = false; + /** If true, do not perform runtime validation. The default is false. */ + public boolean noRuntimeValidation = false; - /** - * If true, do not perform runtime validation. The default is false. - */ - public boolean noRuntimeValidation = false; + /** + * Set the target platform config. This tells the build system what platform-specific support + * files it needs to incorporate at compile time. + * + *

    This is now a wrapped class to account for overloaded definitions of defining platform + * (either a string or dictionary of values) + */ + public PlatformOptions platformOptions = new PlatformOptions(); - /** - * Set the target platform config. - * This tells the build system what platform-specific support - * files it needs to incorporate at compile time. - * - * This is now a wrapped class to account for overloaded definitions - * of defining platform (either a string or dictionary of values) - */ - public PlatformOptions platformOptions = new PlatformOptions(); + /** If true, instruct the runtime to collect and print execution statistics. */ + public boolean printStatistics = false; - /** - * If true, instruct the runtime to collect and print execution statistics. - */ - public boolean printStatistics = false; + /** List of proto files to be processed by the code generator. */ + public List protoFiles = new ArrayList<>(); - /** - * List of proto files to be processed by the code generator. - */ - public List protoFiles = new ArrayList<>(); + /** If true, generate ROS2 specific code. */ + public boolean ros2 = false; - /** - * If true, generate ROS2 specific code. - */ - public boolean ros2 = false; + /** Additional ROS2 packages that the LF program depends on. */ + public List ros2Dependencies = null; + + /** The version of the runtime library to be used in the generated target. */ + public String runtimeVersion = null; + + /** Whether all reactors are to be generated into a single target language file. */ + public boolean singleFileProject = false; + + /** What runtime scheduler to use. */ + public SchedulerOption schedulerType = SchedulerOption.getDefault(); + + /** + * The number of worker threads to deploy. The default is zero, which indicates that the runtime + * is allowed to freely choose the number of workers. + */ + public int workers = 0; + + /** Indicate whether HMAC authentication is used. */ + public boolean auth = false; + + /** Indicate whether the runtime should use multithreaded execution. */ + public boolean threading = true; + + /** The timeout to be observed during execution of the program. */ + public TimeValue timeout; + + /** If non-null, configure the runtime environment to perform tracing. The default is null. */ + public TracingOptions tracing = null; + + /** + * If true, the resulting binary will output a graph visualizing all reaction dependencies. + * + *

    This option is currently only used for C++ and Rust. This export function is a valuable tool + * for debugging LF programs and helps to understand the dependencies inferred by the runtime. + */ + public boolean exportDependencyGraph = false; + + /** + * If true, the resulting binary will output a yaml file describing the whole reactor structure of + * the program. + * + *

    This option is currently only used for C++. This export function is a valuable tool for + * debugging LF programs and performing external analysis. + */ + public boolean exportToYaml = false; + + /** Rust-specific configuration. */ + public final RustTargetConfig rust = + new RustTargetConfig(); // FIXME: https://issue.lf-lang.org/1558 + + /** Path to a C file used by the Python target to setup federated execution. */ + public String fedSetupPreamble = null; // FIXME: https://issue.lf-lang.org/1558 + + /** Settings related to clock synchronization. */ + public static class ClockSyncOptions { /** - * Additional ROS2 packages that the LF program depends on. + * Dampen the adjustments to the clock synchronization offset by this rate. The default is 10. */ - public List ros2Dependencies = null; + public int attenuation = 10; /** - * The version of the runtime library to be used in the generated target. + * Whether to collect statistics while performing clock synchronization. This setting is only + * considered when clock synchronization has been activated. The default is true. */ - public String runtimeVersion = null; - - /** Whether all reactors are to be generated into a single target language file. */ - public boolean singleFileProject = false; + public boolean collectStats = true; - /** What runtime scheduler to use. */ - public SchedulerOption schedulerType = SchedulerOption.getDefault(); + /** Enable clock synchronization for federates on the same machine. Default is false. */ + public boolean localFederatesOn = false; /** - * The number of worker threads to deploy. The default is zero, which indicates that - * the runtime is allowed to freely choose the number of workers. + * Interval at which clock synchronization is initiated by the RTI (will be passed to it as an + * argument on the command-line). The default is 5 milliseconds. */ - public int workers = 0; + public TimeValue period = new TimeValue(5, TimeUnit.MILLI); /** - * Indicate whether HMAC authentication is used. + * Indicate the number of exchanges to be had per each clock synchronization round. See + * /lib/core/federated/clock-sync.h for more details. The default is 10. */ - public boolean auth = false; + public int trials = 10; /** - * Indicate whether the runtime should use multithreaded execution. + * Used to create an artificial clock synchronization error for the purpose of testing. The + * default is null. */ - public boolean threading = true; + public TimeValue testOffset; + } + + /** Settings related to coordination of federated execution. */ + public static class CoordinationOptions { /** - * The timeout to be observed during execution of the program. + * For centralized coordination, if a federate has a physical action that can trigger an output, + * directly or indirectly, then it will send NET (next event tag) messages to the RTI + * periodically as its physical clock advances. This option sets the amount of time to wait + * between sending such messages. Increasing this value results in downstream federates that lag + * further behind physical time (if the "after" delays are insufficient). The default is null, + * which means it is up the implementation to choose an interval. */ - public TimeValue timeout; + public TimeValue advance_message_interval = null; + } + /** Settings related to Docker options. */ + public static class DockerOptions { /** - * If non-null, configure the runtime environment to perform tracing. - * The default is null. + * The base image and tag from which to build the Docker image. The default is "alpine:latest". */ - public TracingOptions tracing = null; + public String from = "alpine:latest"; + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + DockerOptions that = (DockerOptions) o; + return from.equals(that.from); + } + } + + /** Settings related to Platform Options. */ + public static class PlatformOptions { /** - * If true, the resulting binary will output a graph visualizing all reaction dependencies. - * - * This option is currently only used for C++ and Rust. This export function is a valuable tool - * for debugging LF programs and helps to understand the dependencies inferred by the runtime. + * The base platform we build our LF Files on. Should be set to AUTO by default unless + * developing for specific OS/Embedded Platform */ - public boolean exportDependencyGraph = false; - + public Platform platform = Platform.AUTO; /** - * If true, the resulting binary will output a yaml file describing the whole reactor structure - * of the program. - * - * This option is currently only used for C++. This export function is a valuable tool for debugging - * LF programs and performing external analysis. + * The string value used to determine what type of embedded board we work with and can be used + * to simplify the build process. For example, when we want to flash to an Arduino Nano 33 BLE + * board, we can use the string arduino:mbed_nano:nano33ble */ - public boolean exportToYaml = false; - - /** Rust-specific configuration. */ - public final RustTargetConfig rust = new RustTargetConfig(); // FIXME: https://issue.lf-lang.org/1558 - - /** Path to a C file used by the Python target to setup federated execution. */ - public String fedSetupPreamble = null; // FIXME: https://issue.lf-lang.org/1558 + public String board = null; /** - * Settings related to clock synchronization. + * The string value used to determine the port on which to flash the compiled program (i.e. + * /dev/cu.usbmodem21301) */ - public static class ClockSyncOptions { - - /** - * Dampen the adjustments to the clock synchronization offset by this rate. - * The default is 10. - */ - public int attenuation = 10; - - /** - * Whether to collect statistics while performing clock synchronization. - * This setting is only considered when clock synchronization has been activated. - * The default is true. - */ - public boolean collectStats = true; - - /** - * Enable clock synchronization for federates on the same machine. - * Default is false. - */ - public boolean localFederatesOn = false; - - - /** - * Interval at which clock synchronization is initiated by the RTI (will be passed - * to it as an argument on the command-line). - * The default is 5 milliseconds. - */ - public TimeValue period = new TimeValue(5, TimeUnit.MILLI); - - /** - * Indicate the number of exchanges to be had per each clock synchronization round. - * See /lib/core/federated/clock-sync.h for more details. - * The default is 10. - */ - public int trials = 10; - - /** - * Used to create an artificial clock synchronization error for the purpose of testing. - * The default is null. - */ - public TimeValue testOffset; - } + public String port = null; /** - * Settings related to coordination of federated execution. + * The baud rate used as a parameter to certain embedded platforms. 9600 is a standard rate + * amongst systems like Arduino, so it's the default value. */ - public static class CoordinationOptions { - - /** - * For centralized coordination, if a federate has a physical action that can trigger - * an output, directly or indirectly, then it will send NET (next event tag) messages - * to the RTI periodically as its physical clock advances. This option sets the amount - * of time to wait between sending such messages. Increasing this value results in - * downstream federates that lag further behind physical time (if the "after" delays - * are insufficient). - * The default is null, which means it is up the implementation to choose an interval. - */ - public TimeValue advance_message_interval = null; - } + public int baudRate = 9600; /** - * Settings related to Docker options. + * The boolean statement used to determine whether we should automatically attempt to flash once + * we compile. This may require the use of board and port values depending on the infrastructure + * you use to flash the boards. */ - public static class DockerOptions { - /** - * The base image and tag from which to build the Docker image. The default is "alpine:latest". - */ - public String from = "alpine:latest"; - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - DockerOptions that = (DockerOptions) o; - return from.equals(that.from); - } - } + public boolean flash = false; /** - * Settings related to Platform Options. + * The int value is used to determine the number of needed threads for the user application in + * Zephyr. */ - public static class PlatformOptions { - - /** - * The base platform we build our LF Files on. Should be set to AUTO by default unless developing for specific OS/Embedded Platform - */ - public Platform platform = Platform.AUTO; - - /** - * The string value used to determine what type of embedded board we work with and can be used to simplify the build process. For example, - * when we want to flash to an Arduino Nano 33 BLE board, we can use the string arduino:mbed_nano:nano33ble - */ - public String board = null; - - - /** - * The string value used to determine the port on which to flash the compiled program (i.e. /dev/cu.usbmodem21301) - */ - public String port = null; - - /** - * The baud rate used as a parameter to certain embedded platforms. 9600 is a standard rate amongst systems like Arduino, so it's the default value. - */ - public int baudRate = 9600; - - /** - * The boolean statement used to determine whether we should automatically attempt to flash once we compile. This may require the use of board and - * port values depending on the infrastructure you use to flash the boards. - */ - public boolean flash = false; - - /** - * The int value is used to determine the number of needed threads for the user application in Zephyr. - */ - public int userThreads = 0; - } + public int userThreads = 0; + } + /** Settings related to tracing options. */ + public static class TracingOptions { /** - * Settings related to tracing options. + * The name to use as the root of the trace file produced. This defaults to the name of the .lf + * file. */ - public static class TracingOptions { - /** - * The name to use as the root of the trace file produced. - * This defaults to the name of the .lf file. - */ - public String traceFileName = null; - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - TracingOptions that = (TracingOptions) o; - return Objects.equals(traceFileName, that.traceFileName); // traceFileName may be null - } + public String traceFileName = null; + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + TracingOptions that = (TracingOptions) o; + return Objects.equals(traceFileName, that.traceFileName); // traceFileName may be null } + } } diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index d874a97ee1..916b29b115 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -1,30 +1,31 @@ /************* -Copyright (c) 2019, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang; +import com.google.common.collect.ImmutableList; import java.io.IOException; import java.nio.file.Path; import java.util.Arrays; @@ -33,7 +34,6 @@ import java.util.Optional; import java.util.function.Predicate; import java.util.stream.Collectors; - import org.eclipse.xtext.util.RuntimeIOException; import org.lflang.TargetConfig.DockerOptions; import org.lflang.TargetConfig.PlatformOptions; @@ -51,1824 +51,1765 @@ import org.lflang.util.StringUtil; import org.lflang.validation.LFValidator; -import com.google.common.collect.ImmutableList; - /** - * A target properties along with a type and a list of supporting targets - * that supports it, as well as a function for configuration updates. + * A target properties along with a type and a list of supporting targets that supports it, as well + * as a function for configuration updates. * * @author Marten Lohstroh */ public enum TargetProperty { - /** - * Directive to allow including OpenSSL libraries and process HMAC authentication. - */ - AUTH("auth", PrimitiveType.BOOLEAN, - Arrays.asList(Target.C, Target.CCPP), - (config) -> ASTUtils.toElement(config.auth), - (config, value, err) -> { - config.auth = ASTUtils.toBoolean(value); - }), - /** - * Directive to let the generator use the custom build command. - */ - BUILD("build", UnionType.STRING_OR_STRING_ARRAY, - Arrays.asList(Target.C, Target.CCPP), - (config) -> ASTUtils.toElement(config.buildCommands), - (config, value, err) -> { - config.buildCommands = ASTUtils.elementToListOfStrings(value); - }), - - /** - * Directive to specify the target build type such as 'Release' or 'Debug'. - * This is also used in the Rust target to select a Cargo profile. - */ - BUILD_TYPE("build-type", UnionType.BUILD_TYPE_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Rust), - (config) -> ASTUtils.toElement(config.cmakeBuildType.toString()), - (config, value, err) -> { - config.cmakeBuildType = (BuildType) UnionType.BUILD_TYPE_UNION - .forName(ASTUtils.elementToSingleString(value)); - // set it there too, because the default is different. - config.rust.setBuildType(config.cmakeBuildType); - }), - - /** - * Directive to let the federate execution handle clock synchronization in software. - */ - CLOCK_SYNC("clock-sync", UnionType.CLOCK_SYNC_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.clockSync.toString()), - (config, value, err) -> { - config.clockSync = (ClockSyncMode) UnionType.CLOCK_SYNC_UNION - .forName(ASTUtils.elementToSingleString(value)); - }), - /** - * Key-value pairs giving options for clock synchronization. - */ - CLOCK_SYNC_OPTIONS("clock-sync-options", - DictionaryType.CLOCK_SYNC_OPTION_DICT, Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (ClockSyncOption opt : ClockSyncOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case ATTENUATION: - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.attenuation)); - break; - case COLLECT_STATS: - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.collectStats)); - break; - case LOCAL_FEDERATES_ON: - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.localFederatesOn)); - break; - case PERIOD: - if (config.clockSyncOptions.period == null) continue; // don't set if null - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.period)); - break; - case TEST_OFFSET: - if (config.clockSyncOptions.testOffset == null) continue; // don't set if null - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.testOffset)); - break; - case TRIALS: - pair.setValue(ASTUtils.toElement(config.clockSyncOptions.trials)); - break; - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - // kvp will never be empty - return e; - }, - (config, value, err) -> { - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - ClockSyncOption option = (ClockSyncOption) DictionaryType.CLOCK_SYNC_OPTION_DICT - .forName(entry.getName()); - switch (option) { - case ATTENUATION: - config.clockSyncOptions.attenuation = ASTUtils - .toInteger(entry.getValue()); - break; - case COLLECT_STATS: - config.clockSyncOptions.collectStats = ASTUtils - .toBoolean(entry.getValue()); - break; - case LOCAL_FEDERATES_ON: - config.clockSyncOptions.localFederatesOn = ASTUtils - .toBoolean(entry.getValue()); - break; - case PERIOD: - config.clockSyncOptions.period = ASTUtils - .toTimeValue(entry.getValue()); - break; - case TEST_OFFSET: - config.clockSyncOptions.testOffset = ASTUtils - .toTimeValue(entry.getValue()); - break; - case TRIALS: - config.clockSyncOptions.trials = ASTUtils - .toInteger(entry.getValue()); - break; - default: - break; - } - } - }), - - /** - * Directive to specify a cmake to be included by the generated build - * systems. - * - * This gives full control over the C/C++ build as any cmake parameters - * can be adjusted in the included file. - */ - CMAKE_INCLUDE("cmake-include", UnionType.FILE_OR_FILE_ARRAY, - Arrays.asList(Target.CPP, Target.C, Target.CCPP), - (config) -> ASTUtils.toElement(config.cmakeIncludes), - (config, value, err) -> { - config.cmakeIncludes = ASTUtils.elementToListOfStrings(value); - }, - // FIXME: This merging of lists is potentially dangerous since - // the incoming list of cmake-includes can belong to a .lf file that is - // located in a different location, and keeping just filename - // strings like this without absolute paths is incorrect. - (config, value, err) -> { - config.cmakeIncludes.addAll(ASTUtils.elementToListOfStrings(value)); - }), - /** - * Directive to specify the target compiler. - */ - COMPILER("compiler", PrimitiveType.STRING, Target.ALL, - (config) -> ASTUtils.toElement(config.compiler), - (config, value, err) -> { - config.compiler = ASTUtils.elementToSingleString(value); - }), - - /** - * Directive to specify compile-time definitions. - */ - COMPILE_DEFINITIONS("compile-definitions", StringDictionaryType.COMPILE_DEFINITION, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.compileDefinitions), - (config, value, err) -> { - config.compileDefinitions = ASTUtils.elementToStringMaps(value); - }), - - /** - * Directive to generate a Dockerfile. This is either a boolean, - * true or false, or a dictionary of options. - */ - DOCKER("docker", UnionType.DOCKER_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS), - (config) -> { - if (config.dockerOptions == null) { - return null; - } else if(config.dockerOptions.equals(new DockerOptions())) { - // default configuration - return ASTUtils.toElement(true); - } else { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (DockerOption opt : DockerOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case FROM: - if (config.dockerOptions.from == null) continue; - pair.setValue(ASTUtils.toElement(config.dockerOptions.from)); - break; - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - if (kvp.getPairs().isEmpty()) return null; - return e; - } - }, - (config, value, err) -> setDockerProperty(config, value), - (config, value, err) -> setDockerProperty(config, value)), - - /** - * Directive for specifying a path to an external runtime to be used for the - * compiled binary. - */ - EXTERNAL_RUNTIME_PATH("external-runtime-path", PrimitiveType.STRING, - List.of(Target.CPP), - (config) -> ASTUtils.toElement(config.externalRuntimePath), - (config, value, err) -> { - config.externalRuntimePath = ASTUtils.elementToSingleString(value); - }), - - /** - * Directive to let the execution engine allow logical time to elapse - * faster than physical time. - */ - FAST("fast", PrimitiveType.BOOLEAN, Target.ALL, - (config) -> ASTUtils.toElement(config.fastMode), - (config, value, err) -> { - config.fastMode = ASTUtils.toBoolean(value); - }), - - /** - * Directive to stage particular files on the class path to be - * processed by the code generator. - */ - FILES("files", UnionType.FILE_OR_FILE_ARRAY, List.of(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.files), - (config, value, err) -> { - config.files = ASTUtils.elementToListOfStrings(value); - }, - // FIXME: This merging of lists is potentially dangerous since - // the incoming list of files can belong to a .lf file that is - // located in a different location, and keeping just filename - // strings like this without absolute paths is incorrect. - (config, value, err) -> { - config.files.addAll(ASTUtils.elementToListOfStrings(value)); - }), - - /** - * Flags to be passed on to the target compiler. - */ - FLAGS("flags", UnionType.STRING_OR_STRING_ARRAY, - Arrays.asList(Target.C, Target.CCPP), - (config) -> ASTUtils.toElement(config.compilerFlags), - (config, value, err) -> { - config.compilerFlags = ASTUtils.elementToListOfStrings(value); - }), - - /** - * Directive to specify the coordination mode - */ - COORDINATION("coordination", UnionType.COORDINATION_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.coordination.toString()), - (config, value, err) -> { - config.coordination = (CoordinationType) UnionType.COORDINATION_UNION - .forName(ASTUtils.elementToSingleString(value)); - }, - (config, value, err) -> { - config.coordination = (CoordinationType) UnionType.COORDINATION_UNION - .forName(ASTUtils.elementToSingleString(value)); - }), - - /** - * Key-value pairs giving options for clock synchronization. - */ - COORDINATION_OPTIONS("coordination-options", - DictionaryType.COORDINATION_OPTION_DICT, Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS), - (config) -> { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (CoordinationOption opt : CoordinationOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case ADVANCE_MESSAGE_INTERVAL: - if (config.coordinationOptions.advance_message_interval == null) continue; - pair.setValue(ASTUtils.toElement(config.coordinationOptions.advance_message_interval)); - break; - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - if (kvp.getPairs().isEmpty()) return null; - return e; - }, - (config, value, err) -> { - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - CoordinationOption option = (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT - .forName(entry.getName()); - switch (option) { - case ADVANCE_MESSAGE_INTERVAL: - config.coordinationOptions.advance_message_interval = ASTUtils - .toTimeValue(entry.getValue()); - break; - default: - break; - } - } - }, - (config, value, err) -> { - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - CoordinationOption option = (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT - .forName(entry.getName()); - switch (option) { - case ADVANCE_MESSAGE_INTERVAL: - config.coordinationOptions.advance_message_interval = ASTUtils - .toTimeValue(entry.getValue()); - break; - default: - break; - } - } - }), - - /** - * Directive to let the execution engine remain active also if there - * are no more events in the event queue. - */ - KEEPALIVE("keepalive", PrimitiveType.BOOLEAN, Target.ALL, - (config) -> ASTUtils.toElement(config.keepalive), - (config, value, err) -> { - config.keepalive = ASTUtils.toBoolean(value); - }), - - /** - * Directive to specify the grain at which to report log messages during execution. - */ - LOGGING("logging", UnionType.LOGGING_UNION, Target.ALL, - (config) -> ASTUtils.toElement(config.logLevel.toString()), - (config, value, err) -> { - config.logLevel = (LogLevel) UnionType.LOGGING_UNION - .forName(ASTUtils.elementToSingleString(value)); - }), - - /** - * Directive to not invoke the target compiler. - */ - NO_COMPILE("no-compile", PrimitiveType.BOOLEAN, - Arrays.asList(Target.C, Target.CPP, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.noCompile), - (config, value, err) -> { - config.noCompile = ASTUtils.toBoolean(value); - }), - - /** - * Directive to disable validation of reactor rules at runtime. - */ - NO_RUNTIME_VALIDATION("no-runtime-validation", PrimitiveType.BOOLEAN, - Arrays.asList(Target.CPP), - (config) -> ASTUtils.toElement(config.noRuntimeValidation), - (config, value, err) -> { - config.noRuntimeValidation = ASTUtils.toBoolean(value); - }), - - /** - * Directive to specify the platform for cross code generation. This is either a string of the platform - * or a dictionary of options that includes the string name. - */ - PLATFORM("platform", UnionType.PLATFORM_STRING_OR_DICTIONARY, Target.ALL, - (config) -> { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (PlatformOption opt : PlatformOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case NAME: - pair.setValue(ASTUtils.toElement(config.platformOptions.platform.toString())); - break; - case BAUDRATE: - pair.setValue(ASTUtils.toElement(config.platformOptions.baudRate)); - break; - case BOARD: - pair.setValue(ASTUtils.toElement(config.platformOptions.board)); - break; - case FLASH: - pair.setValue(ASTUtils.toElement(config.platformOptions.flash)); - break; - case PORT: - pair.setValue(ASTUtils.toElement(config.platformOptions.port)); - break; - case USER_THREADS: - pair.setValue(ASTUtils.toElement(config.platformOptions.userThreads)); - break; - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - if (kvp.getPairs().isEmpty()) return null; - return e; - }, - (config, value, err) -> { - if (value.getLiteral() != null) { - config.platformOptions = new PlatformOptions(); - config.platformOptions.platform = (Platform) UnionType.PLATFORM_UNION - .forName(ASTUtils.elementToSingleString(value)); - } else { - config.platformOptions= new PlatformOptions(); - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - PlatformOption option = (PlatformOption) DictionaryType.PLATFORM_DICT - .forName(entry.getName()); - switch (option) { - case NAME: - Platform p = (Platform) UnionType.PLATFORM_UNION - .forName(ASTUtils.elementToSingleString(entry.getValue())); - if(p == null) { - String s = "Unidentified Platform Type, LF supports the following platform types: " + Arrays.asList(Platform.values()).toString(); - err.reportError(s); - throw new AssertionError(s); - } - config.platformOptions.platform = p; - break; - case BAUDRATE: - config.platformOptions.baudRate = ASTUtils.toInteger(entry.getValue()); - break; - case BOARD: - config.platformOptions.board = ASTUtils.elementToSingleString(entry.getValue()); - break; - case FLASH: - config.platformOptions.flash = ASTUtils.toBoolean(entry.getValue()); - break; - case PORT: - config.platformOptions.port = ASTUtils.elementToSingleString(entry.getValue()); - break; - case USER_THREADS: - config.platformOptions.userThreads = ASTUtils.toInteger(entry.getValue()); - break; - default: - break; - } - } - } - }), - - /** - * Directive to instruct the runtime to collect and print execution statistics. - */ - PRINT_STATISTICS("print-statistics", PrimitiveType.BOOLEAN, - Arrays.asList(Target.CPP), - (config) -> ASTUtils.toElement(config.printStatistics), - (config, value, err) -> { - config.printStatistics = ASTUtils.toBoolean(value); - }), - - /** - * Directive for specifying .proto files that need to be compiled and their - * code included in the sources. - */ - PROTOBUFS("protobufs", UnionType.FILE_OR_FILE_ARRAY, - Arrays.asList(Target.C, Target.CCPP, Target.TS, Target.Python), - (config) -> ASTUtils.toElement(config.protoFiles), - (config, value, err) -> { - config.protoFiles = ASTUtils.elementToListOfStrings(value); - }), - - - /** - * Directive to specify that ROS2 specific code is generated, - */ - ROS2("ros2", PrimitiveType.BOOLEAN, - List.of(Target.CPP), - (config) -> ASTUtils.toElement(config.ros2), - (config, value, err) -> { - config.ros2 = ASTUtils.toBoolean(value); - }), - - /** - * Directive to specify additional ROS2 packages that this LF program depends on. - */ - ROS2_DEPENDENCIES("ros2-dependencies", ArrayType.STRING_ARRAY, - List.of(Target.CPP), - (config) -> ASTUtils.toElement(config.ros2Dependencies), - (config, value, err) -> { - config.ros2Dependencies = ASTUtils.elementToListOfStrings(value); - }), - - /** - * Directive for specifying a specific version of the reactor runtime library. - */ - RUNTIME_VERSION("runtime-version", PrimitiveType.STRING, - Arrays.asList(Target.CPP), - (config) -> ASTUtils.toElement(config.runtimeVersion), - (config, value, err) -> { - config.runtimeVersion = ASTUtils.elementToSingleString(value); - }), - - - /** - * Directive for specifying a specific runtime scheduler, if supported. - */ - SCHEDULER("scheduler", UnionType.SCHEDULER_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.schedulerType.toString()), - (config, value, err) -> { - config.schedulerType = (SchedulerOption) UnionType.SCHEDULER_UNION - .forName(ASTUtils.elementToSingleString(value)); - }), - - /** - * Directive to specify that all code is generated in a single file. - */ - SINGLE_FILE_PROJECT("single-file-project", PrimitiveType.BOOLEAN, - List.of(Target.Rust), - (config) -> ASTUtils.toElement(config.singleFileProject), - (config, value, err) -> { - config.singleFileProject = ASTUtils.toBoolean(value); - }), - - /** - * Directive to indicate whether the runtime should use multi-threading. - */ - THREADING("threading", PrimitiveType.BOOLEAN, - List.of(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.threading), - (config, value, err) -> { - config.threading = ASTUtils.toBoolean(value); - }), - - /** - * Directive to specify the number of worker threads used by the runtime. - */ - WORKERS("workers", PrimitiveType.NON_NEGATIVE_INTEGER, - List.of(Target.C, Target.CCPP, Target.Python, Target.CPP, Target.Rust), - (config) -> ASTUtils.toElement(config.workers), - (config, value, err) -> { - config.workers = ASTUtils.toInteger(value); - }), - - /** - * Directive to specify the execution timeout. - */ - TIMEOUT("timeout", PrimitiveType.TIME_VALUE, Target.ALL, - (config) -> ASTUtils.toElement(config.timeout), - (config, value, err) -> { - config.timeout = ASTUtils.toTimeValue(value); - }, - (config, value, err) -> { - config.timeout = ASTUtils.toTimeValue(value); - }), - - /** - * Directive to enable tracing. - */ - TRACING("tracing", UnionType.TRACING_UNION, - Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Python), - (config) -> { - if (config.tracing == null) { - return null; - } else if (config.tracing.equals(new TracingOptions())) { - // default values - return ASTUtils.toElement(true); - } else { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (TracingOption opt : TracingOption.values()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(opt.toString()); - switch (opt) { - case TRACE_FILE_NAME: - if (config.tracing.traceFileName == null) continue; - pair.setValue(ASTUtils.toElement(config.tracing.traceFileName)); - } - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - if (kvp.getPairs().isEmpty()) return null; - return e; - } - }, - (config, value, err) -> { - if (value.getLiteral() != null) { - if (ASTUtils.toBoolean(value)) { - config.tracing = new TracingOptions(); - } else { - config.tracing = null; - } - } else { - config.tracing = new TracingOptions(); - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - TracingOption option = (TracingOption) DictionaryType.TRACING_DICT - .forName(entry.getName()); - switch (option) { - case TRACE_FILE_NAME: - config.tracing.traceFileName = ASTUtils.elementToSingleString(entry.getValue()); - break; - default: - break; - } - } - } - }), - - /** - * Directive to let the runtime export its internal dependency graph. - * - * This is a debugging feature and currently only used for C++ and Rust programs. - */ - EXPORT_DEPENDENCY_GRAPH("export-dependency-graph", PrimitiveType.BOOLEAN, - List.of(Target.CPP, Target.Rust), - (config) -> ASTUtils.toElement(config.exportDependencyGraph), - (config, value, err) -> { - config.exportDependencyGraph = ASTUtils.toBoolean(value); - }), - - /** - * Directive to let the runtime export the program structure to a yaml file. - * - * This is a debugging feature and currently only used for C++ programs. - */ - EXPORT_TO_YAML("export-to-yaml", PrimitiveType.BOOLEAN, - List.of(Target.CPP), - (config) -> ASTUtils.toElement(config.exportToYaml), - (config, value, err) -> { - config.exportToYaml = ASTUtils.toBoolean(value); - }), - - /** - * List of module files to link into the crate as top-level. - * For instance, a {@code target Rust { rust-modules: [ "foo.rs" ] }} - * will cause the file to be copied into the generated project, - * and the generated `main.rs` will include it with a `mod foo;`. - * If one of the paths is a directory, it must contain a `mod.rs` - * file, and all its contents are copied. - */ - RUST_INCLUDE("rust-include", - UnionType.FILE_OR_FILE_ARRAY, - List.of(Target.Rust), - (config) -> { - // do not check paths here, and simply copy the absolute path over - List paths = config.rust.getRustTopLevelModules(); - if (paths.isEmpty()) return null; - else if (paths.size() == 1) { - return ASTUtils.toElement(paths.get(0).toString()); - } else { - Element e = LfFactory.eINSTANCE.createElement(); - Array arr = LfFactory.eINSTANCE.createArray(); - for (Path p : paths) { - arr.getElements().add(ASTUtils.toElement(p.toString())); - } - e.setArray(arr); - return e; - } - }, - (config, value, err) -> { - Path referencePath; - try { - referencePath = FileUtil.toPath(value.eResource().getURI()).toAbsolutePath(); - } catch (IOException e) { - err.reportError(value, "Invalid path? " + e.getMessage()); - throw new RuntimeIOException(e); - } - - // we'll resolve relative paths to check that the files - // are as expected. - - if (value.getLiteral() != null) { - Path resolved = referencePath.resolveSibling(StringUtil.removeQuotes(value.getLiteral())); - - config.rust.addAndCheckTopLevelModule(resolved, value, err); - } else if (value.getArray() != null) { - for (Element element : value.getArray().getElements()) { - String literal = StringUtil.removeQuotes(element.getLiteral()); - Path resolved = referencePath.resolveSibling(literal); - config.rust.addAndCheckTopLevelModule(resolved, element, err); - } - } - }), - - /** - * Directive for specifying Cargo features of the generated - * program to enable. - */ - CARGO_FEATURES("cargo-features", ArrayType.STRING_ARRAY, - List.of(Target.Rust), - (config) -> ASTUtils.toElement(config.rust.getCargoFeatures()), - (config, value, err) -> { - config.rust.setCargoFeatures(ASTUtils.elementToListOfStrings(value)); - }), - - /** - * Dependency specifications for Cargo. This property looks like this: - * 

    {@code
-     * cargo-dependencies: {
-     *    // Name-of-the-crate: "version"
-     *    rand: "0.8",
-     *    // Equivalent to using an explicit map:
-     *    rand: {
-     *      version: "0.8"
-     *    },
-     *    // The map allows specifying more details
-     *    rand: {
-     *      // A path to a local unpublished crate.
-     *      // Note 'path' is mutually exclusive with 'version'.
-     *      path: "/home/me/Git/local-rand-clone"
-     *    },
-     *    rand: {
-     *      version: "0.8",
-     *      // you can specify cargo features
-     *      features: ["some-cargo-feature",]
-     *    }
-     * }
-     * }
    - */ - CARGO_DEPENDENCIES("cargo-dependencies", - CargoDependenciesPropertyType.INSTANCE, - List.of(Target.Rust), - (config) -> { - var deps = config.rust.getCargoDependencies(); - if (deps.size() == 0) return null; - else { - Element e = LfFactory.eINSTANCE.createElement(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (var ent : deps.entrySet()) { - KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); - pair.setName(ent.getKey()); - pair.setValue(CargoDependencySpec.extractSpec(ent.getValue())); - kvp.getPairs().add(pair); - } - e.setKeyvalue(kvp); - return e; - } - }, - (config, value, err) -> { - config.rust.setCargoDependencies(CargoDependencySpec.parseAll(value)); - }), - - /** - * Directs the C or Python target to include the associated C file used for - * setting up federated execution before processing the first tag. - */ - FED_SETUP("_fed_setup", PrimitiveType.FILE, - Arrays.asList(Target.C, Target.CCPP, Target.Python), - (config) -> ASTUtils.toElement(config.fedSetupPreamble), - (config, value, err) -> - config.fedSetupPreamble = StringUtil.removeQuotes(ASTUtils.elementToSingleString(value)) - ) - ; - - /** - * Update {@code config}.dockerOptions based on value. - */ - private static void setDockerProperty(TargetConfig config, Element value) { - if (value.getLiteral() != null) { - if (ASTUtils.toBoolean(value)) { - config.dockerOptions = new DockerOptions(); - } else { - config.dockerOptions = null; + /** Directive to allow including OpenSSL libraries and process HMAC authentication. */ + AUTH( + "auth", + PrimitiveType.BOOLEAN, + Arrays.asList(Target.C, Target.CCPP), + (config) -> ASTUtils.toElement(config.auth), + (config, value, err) -> { + config.auth = ASTUtils.toBoolean(value); + }), + /** Directive to let the generator use the custom build command. */ + BUILD( + "build", + UnionType.STRING_OR_STRING_ARRAY, + Arrays.asList(Target.C, Target.CCPP), + (config) -> ASTUtils.toElement(config.buildCommands), + (config, value, err) -> { + config.buildCommands = ASTUtils.elementToListOfStrings(value); + }), + + /** + * Directive to specify the target build type such as 'Release' or 'Debug'. This is also used in + * the Rust target to select a Cargo profile. + */ + BUILD_TYPE( + "build-type", + UnionType.BUILD_TYPE_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Rust), + (config) -> ASTUtils.toElement(config.cmakeBuildType.toString()), + (config, value, err) -> { + config.cmakeBuildType = + (BuildType) UnionType.BUILD_TYPE_UNION.forName(ASTUtils.elementToSingleString(value)); + // set it there too, because the default is different. + config.rust.setBuildType(config.cmakeBuildType); + }), + + /** Directive to let the federate execution handle clock synchronization in software. */ + CLOCK_SYNC( + "clock-sync", + UnionType.CLOCK_SYNC_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.clockSync.toString()), + (config, value, err) -> { + config.clockSync = + (ClockSyncMode) + UnionType.CLOCK_SYNC_UNION.forName(ASTUtils.elementToSingleString(value)); + }), + /** Key-value pairs giving options for clock synchronization. */ + CLOCK_SYNC_OPTIONS( + "clock-sync-options", + DictionaryType.CLOCK_SYNC_OPTION_DICT, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (ClockSyncOption opt : ClockSyncOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case ATTENUATION: + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.attenuation)); + break; + case COLLECT_STATS: + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.collectStats)); + break; + case LOCAL_FEDERATES_ON: + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.localFederatesOn)); + break; + case PERIOD: + if (config.clockSyncOptions.period == null) continue; // don't set if null + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.period)); + break; + case TEST_OFFSET: + if (config.clockSyncOptions.testOffset == null) continue; // don't set if null + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.testOffset)); + break; + case TRIALS: + pair.setValue(ASTUtils.toElement(config.clockSyncOptions.trials)); + break; + } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + // kvp will never be empty + return e; + }, + (config, value, err) -> { + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + ClockSyncOption option = + (ClockSyncOption) DictionaryType.CLOCK_SYNC_OPTION_DICT.forName(entry.getName()); + switch (option) { + case ATTENUATION: + config.clockSyncOptions.attenuation = ASTUtils.toInteger(entry.getValue()); + break; + case COLLECT_STATS: + config.clockSyncOptions.collectStats = ASTUtils.toBoolean(entry.getValue()); + break; + case LOCAL_FEDERATES_ON: + config.clockSyncOptions.localFederatesOn = ASTUtils.toBoolean(entry.getValue()); + break; + case PERIOD: + config.clockSyncOptions.period = ASTUtils.toTimeValue(entry.getValue()); + break; + case TEST_OFFSET: + config.clockSyncOptions.testOffset = ASTUtils.toTimeValue(entry.getValue()); + break; + case TRIALS: + config.clockSyncOptions.trials = ASTUtils.toInteger(entry.getValue()); + break; + default: + break; + } + } + }), + + /** + * Directive to specify a cmake to be included by the generated build systems. + * + *

    This gives full control over the C/C++ build as any cmake parameters can be adjusted in the + * included file. + */ + CMAKE_INCLUDE( + "cmake-include", + UnionType.FILE_OR_FILE_ARRAY, + Arrays.asList(Target.CPP, Target.C, Target.CCPP), + (config) -> ASTUtils.toElement(config.cmakeIncludes), + (config, value, err) -> { + config.cmakeIncludes = ASTUtils.elementToListOfStrings(value); + }, + // FIXME: This merging of lists is potentially dangerous since + // the incoming list of cmake-includes can belong to a .lf file that is + // located in a different location, and keeping just filename + // strings like this without absolute paths is incorrect. + (config, value, err) -> { + config.cmakeIncludes.addAll(ASTUtils.elementToListOfStrings(value)); + }), + /** Directive to specify the target compiler. */ + COMPILER( + "compiler", + PrimitiveType.STRING, + Target.ALL, + (config) -> ASTUtils.toElement(config.compiler), + (config, value, err) -> { + config.compiler = ASTUtils.elementToSingleString(value); + }), + + /** Directive to specify compile-time definitions. */ + COMPILE_DEFINITIONS( + "compile-definitions", + StringDictionaryType.COMPILE_DEFINITION, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.compileDefinitions), + (config, value, err) -> { + config.compileDefinitions = ASTUtils.elementToStringMaps(value); + }), + + /** + * Directive to generate a Dockerfile. This is either a boolean, true or false, or a dictionary of + * options. + */ + DOCKER( + "docker", + UnionType.DOCKER_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS), + (config) -> { + if (config.dockerOptions == null) { + return null; + } else if (config.dockerOptions.equals(new DockerOptions())) { + // default configuration + return ASTUtils.toElement(true); + } else { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (DockerOption opt : DockerOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case FROM: + if (config.dockerOptions.from == null) continue; + pair.setValue(ASTUtils.toElement(config.dockerOptions.from)); + break; } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + if (kvp.getPairs().isEmpty()) return null; + return e; + } + }, + (config, value, err) -> setDockerProperty(config, value), + (config, value, err) -> setDockerProperty(config, value)), + + /** Directive for specifying a path to an external runtime to be used for the compiled binary. */ + EXTERNAL_RUNTIME_PATH( + "external-runtime-path", + PrimitiveType.STRING, + List.of(Target.CPP), + (config) -> ASTUtils.toElement(config.externalRuntimePath), + (config, value, err) -> { + config.externalRuntimePath = ASTUtils.elementToSingleString(value); + }), + + /** + * Directive to let the execution engine allow logical time to elapse faster than physical time. + */ + FAST( + "fast", + PrimitiveType.BOOLEAN, + Target.ALL, + (config) -> ASTUtils.toElement(config.fastMode), + (config, value, err) -> { + config.fastMode = ASTUtils.toBoolean(value); + }), + + /** + * Directive to stage particular files on the class path to be processed by the code generator. + */ + FILES( + "files", + UnionType.FILE_OR_FILE_ARRAY, + List.of(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.files), + (config, value, err) -> { + config.files = ASTUtils.elementToListOfStrings(value); + }, + // FIXME: This merging of lists is potentially dangerous since + // the incoming list of files can belong to a .lf file that is + // located in a different location, and keeping just filename + // strings like this without absolute paths is incorrect. + (config, value, err) -> { + config.files.addAll(ASTUtils.elementToListOfStrings(value)); + }), + + /** Flags to be passed on to the target compiler. */ + FLAGS( + "flags", + UnionType.STRING_OR_STRING_ARRAY, + Arrays.asList(Target.C, Target.CCPP), + (config) -> ASTUtils.toElement(config.compilerFlags), + (config, value, err) -> { + config.compilerFlags = ASTUtils.elementToListOfStrings(value); + }), + + /** Directive to specify the coordination mode */ + COORDINATION( + "coordination", + UnionType.COORDINATION_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.coordination.toString()), + (config, value, err) -> { + config.coordination = + (CoordinationType) + UnionType.COORDINATION_UNION.forName(ASTUtils.elementToSingleString(value)); + }, + (config, value, err) -> { + config.coordination = + (CoordinationType) + UnionType.COORDINATION_UNION.forName(ASTUtils.elementToSingleString(value)); + }), + + /** Key-value pairs giving options for clock synchronization. */ + COORDINATION_OPTIONS( + "coordination-options", + DictionaryType.COORDINATION_OPTION_DICT, + Arrays.asList(Target.C, Target.CCPP, Target.Python, Target.TS), + (config) -> { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (CoordinationOption opt : CoordinationOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case ADVANCE_MESSAGE_INTERVAL: + if (config.coordinationOptions.advance_message_interval == null) continue; + pair.setValue( + ASTUtils.toElement(config.coordinationOptions.advance_message_interval)); + break; + } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + if (kvp.getPairs().isEmpty()) return null; + return e; + }, + (config, value, err) -> { + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + CoordinationOption option = + (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT.forName(entry.getName()); + switch (option) { + case ADVANCE_MESSAGE_INTERVAL: + config.coordinationOptions.advance_message_interval = + ASTUtils.toTimeValue(entry.getValue()); + break; + default: + break; + } + } + }, + (config, value, err) -> { + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + CoordinationOption option = + (CoordinationOption) DictionaryType.COORDINATION_OPTION_DICT.forName(entry.getName()); + switch (option) { + case ADVANCE_MESSAGE_INTERVAL: + config.coordinationOptions.advance_message_interval = + ASTUtils.toTimeValue(entry.getValue()); + break; + default: + break; + } + } + }), + + /** + * Directive to let the execution engine remain active also if there are no more events in the + * event queue. + */ + KEEPALIVE( + "keepalive", + PrimitiveType.BOOLEAN, + Target.ALL, + (config) -> ASTUtils.toElement(config.keepalive), + (config, value, err) -> { + config.keepalive = ASTUtils.toBoolean(value); + }), + + /** Directive to specify the grain at which to report log messages during execution. */ + LOGGING( + "logging", + UnionType.LOGGING_UNION, + Target.ALL, + (config) -> ASTUtils.toElement(config.logLevel.toString()), + (config, value, err) -> { + config.logLevel = + (LogLevel) UnionType.LOGGING_UNION.forName(ASTUtils.elementToSingleString(value)); + }), + + /** Directive to not invoke the target compiler. */ + NO_COMPILE( + "no-compile", + PrimitiveType.BOOLEAN, + Arrays.asList(Target.C, Target.CPP, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.noCompile), + (config, value, err) -> { + config.noCompile = ASTUtils.toBoolean(value); + }), + + /** Directive to disable validation of reactor rules at runtime. */ + NO_RUNTIME_VALIDATION( + "no-runtime-validation", + PrimitiveType.BOOLEAN, + Arrays.asList(Target.CPP), + (config) -> ASTUtils.toElement(config.noRuntimeValidation), + (config, value, err) -> { + config.noRuntimeValidation = ASTUtils.toBoolean(value); + }), + + /** + * Directive to specify the platform for cross code generation. This is either a string of the + * platform or a dictionary of options that includes the string name. + */ + PLATFORM( + "platform", + UnionType.PLATFORM_STRING_OR_DICTIONARY, + Target.ALL, + (config) -> { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (PlatformOption opt : PlatformOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case NAME: + pair.setValue(ASTUtils.toElement(config.platformOptions.platform.toString())); + break; + case BAUDRATE: + pair.setValue(ASTUtils.toElement(config.platformOptions.baudRate)); + break; + case BOARD: + pair.setValue(ASTUtils.toElement(config.platformOptions.board)); + break; + case FLASH: + pair.setValue(ASTUtils.toElement(config.platformOptions.flash)); + break; + case PORT: + pair.setValue(ASTUtils.toElement(config.platformOptions.port)); + break; + case USER_THREADS: + pair.setValue(ASTUtils.toElement(config.platformOptions.userThreads)); + break; + } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + if (kvp.getPairs().isEmpty()) return null; + return e; + }, + (config, value, err) -> { + if (value.getLiteral() != null) { + config.platformOptions = new PlatformOptions(); + config.platformOptions.platform = + (Platform) UnionType.PLATFORM_UNION.forName(ASTUtils.elementToSingleString(value)); } else { - config.dockerOptions = new DockerOptions(); - for (KeyValuePair entry : value.getKeyvalue().getPairs()) { - DockerOption option = (DockerOption) DictionaryType.DOCKER_DICT - .forName(entry.getName()); - switch (option) { - case FROM: - config.dockerOptions.from = ASTUtils.elementToSingleString(entry.getValue()); - break; - default: - break; + config.platformOptions = new PlatformOptions(); + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + PlatformOption option = + (PlatformOption) DictionaryType.PLATFORM_DICT.forName(entry.getName()); + switch (option) { + case NAME: + Platform p = + (Platform) + UnionType.PLATFORM_UNION.forName( + ASTUtils.elementToSingleString(entry.getValue())); + if (p == null) { + String s = + "Unidentified Platform Type, LF supports the following platform types: " + + Arrays.asList(Platform.values()).toString(); + err.reportError(s); + throw new AssertionError(s); } + config.platformOptions.platform = p; + break; + case BAUDRATE: + config.platformOptions.baudRate = ASTUtils.toInteger(entry.getValue()); + break; + case BOARD: + config.platformOptions.board = ASTUtils.elementToSingleString(entry.getValue()); + break; + case FLASH: + config.platformOptions.flash = ASTUtils.toBoolean(entry.getValue()); + break; + case PORT: + config.platformOptions.port = ASTUtils.elementToSingleString(entry.getValue()); + break; + case USER_THREADS: + config.platformOptions.userThreads = ASTUtils.toInteger(entry.getValue()); + break; + default: + break; } + } + } + }), + + /** Directive to instruct the runtime to collect and print execution statistics. */ + PRINT_STATISTICS( + "print-statistics", + PrimitiveType.BOOLEAN, + Arrays.asList(Target.CPP), + (config) -> ASTUtils.toElement(config.printStatistics), + (config, value, err) -> { + config.printStatistics = ASTUtils.toBoolean(value); + }), + + /** + * Directive for specifying .proto files that need to be compiled and their code included in the + * sources. + */ + PROTOBUFS( + "protobufs", + UnionType.FILE_OR_FILE_ARRAY, + Arrays.asList(Target.C, Target.CCPP, Target.TS, Target.Python), + (config) -> ASTUtils.toElement(config.protoFiles), + (config, value, err) -> { + config.protoFiles = ASTUtils.elementToListOfStrings(value); + }), + + /** Directive to specify that ROS2 specific code is generated, */ + ROS2( + "ros2", + PrimitiveType.BOOLEAN, + List.of(Target.CPP), + (config) -> ASTUtils.toElement(config.ros2), + (config, value, err) -> { + config.ros2 = ASTUtils.toBoolean(value); + }), + + /** Directive to specify additional ROS2 packages that this LF program depends on. */ + ROS2_DEPENDENCIES( + "ros2-dependencies", + ArrayType.STRING_ARRAY, + List.of(Target.CPP), + (config) -> ASTUtils.toElement(config.ros2Dependencies), + (config, value, err) -> { + config.ros2Dependencies = ASTUtils.elementToListOfStrings(value); + }), + + /** Directive for specifying a specific version of the reactor runtime library. */ + RUNTIME_VERSION( + "runtime-version", + PrimitiveType.STRING, + Arrays.asList(Target.CPP), + (config) -> ASTUtils.toElement(config.runtimeVersion), + (config, value, err) -> { + config.runtimeVersion = ASTUtils.elementToSingleString(value); + }), + + /** Directive for specifying a specific runtime scheduler, if supported. */ + SCHEDULER( + "scheduler", + UnionType.SCHEDULER_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.schedulerType.toString()), + (config, value, err) -> { + config.schedulerType = + (SchedulerOption) + UnionType.SCHEDULER_UNION.forName(ASTUtils.elementToSingleString(value)); + }), + + /** Directive to specify that all code is generated in a single file. */ + SINGLE_FILE_PROJECT( + "single-file-project", + PrimitiveType.BOOLEAN, + List.of(Target.Rust), + (config) -> ASTUtils.toElement(config.singleFileProject), + (config, value, err) -> { + config.singleFileProject = ASTUtils.toBoolean(value); + }), + + /** Directive to indicate whether the runtime should use multi-threading. */ + THREADING( + "threading", + PrimitiveType.BOOLEAN, + List.of(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.threading), + (config, value, err) -> { + config.threading = ASTUtils.toBoolean(value); + }), + + /** Directive to specify the number of worker threads used by the runtime. */ + WORKERS( + "workers", + PrimitiveType.NON_NEGATIVE_INTEGER, + List.of(Target.C, Target.CCPP, Target.Python, Target.CPP, Target.Rust), + (config) -> ASTUtils.toElement(config.workers), + (config, value, err) -> { + config.workers = ASTUtils.toInteger(value); + }), + + /** Directive to specify the execution timeout. */ + TIMEOUT( + "timeout", + PrimitiveType.TIME_VALUE, + Target.ALL, + (config) -> ASTUtils.toElement(config.timeout), + (config, value, err) -> { + config.timeout = ASTUtils.toTimeValue(value); + }, + (config, value, err) -> { + config.timeout = ASTUtils.toTimeValue(value); + }), + + /** Directive to enable tracing. */ + TRACING( + "tracing", + UnionType.TRACING_UNION, + Arrays.asList(Target.C, Target.CCPP, Target.CPP, Target.Python), + (config) -> { + if (config.tracing == null) { + return null; + } else if (config.tracing.equals(new TracingOptions())) { + // default values + return ASTUtils.toElement(true); + } else { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (TracingOption opt : TracingOption.values()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(opt.toString()); + switch (opt) { + case TRACE_FILE_NAME: + if (config.tracing.traceFileName == null) continue; + pair.setValue(ASTUtils.toElement(config.tracing.traceFileName)); + } + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + if (kvp.getPairs().isEmpty()) return null; + return e; + } + }, + (config, value, err) -> { + if (value.getLiteral() != null) { + if (ASTUtils.toBoolean(value)) { + config.tracing = new TracingOptions(); + } else { + config.tracing = null; + } + } else { + config.tracing = new TracingOptions(); + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + TracingOption option = + (TracingOption) DictionaryType.TRACING_DICT.forName(entry.getName()); + switch (option) { + case TRACE_FILE_NAME: + config.tracing.traceFileName = ASTUtils.elementToSingleString(entry.getValue()); + break; + default: + break; + } + } + } + }), + + /** + * Directive to let the runtime export its internal dependency graph. + * + *

    This is a debugging feature and currently only used for C++ and Rust programs. + */ + EXPORT_DEPENDENCY_GRAPH( + "export-dependency-graph", + PrimitiveType.BOOLEAN, + List.of(Target.CPP, Target.Rust), + (config) -> ASTUtils.toElement(config.exportDependencyGraph), + (config, value, err) -> { + config.exportDependencyGraph = ASTUtils.toBoolean(value); + }), + + /** + * Directive to let the runtime export the program structure to a yaml file. + * + *

    This is a debugging feature and currently only used for C++ programs. + */ + EXPORT_TO_YAML( + "export-to-yaml", + PrimitiveType.BOOLEAN, + List.of(Target.CPP), + (config) -> ASTUtils.toElement(config.exportToYaml), + (config, value, err) -> { + config.exportToYaml = ASTUtils.toBoolean(value); + }), + + /** + * List of module files to link into the crate as top-level. For instance, a {@code target Rust { + * rust-modules: [ "foo.rs" ] }} will cause the file to be copied into the generated project, and + * the generated `main.rs` will include it with a `mod foo;`. If one of the paths is a directory, + * it must contain a `mod.rs` file, and all its contents are copied. + */ + RUST_INCLUDE( + "rust-include", + UnionType.FILE_OR_FILE_ARRAY, + List.of(Target.Rust), + (config) -> { + // do not check paths here, and simply copy the absolute path over + List paths = config.rust.getRustTopLevelModules(); + if (paths.isEmpty()) return null; + else if (paths.size() == 1) { + return ASTUtils.toElement(paths.get(0).toString()); + } else { + Element e = LfFactory.eINSTANCE.createElement(); + Array arr = LfFactory.eINSTANCE.createArray(); + for (Path p : paths) { + arr.getElements().add(ASTUtils.toElement(p.toString())); + } + e.setArray(arr); + return e; + } + }, + (config, value, err) -> { + Path referencePath; + try { + referencePath = FileUtil.toPath(value.eResource().getURI()).toAbsolutePath(); + } catch (IOException e) { + err.reportError(value, "Invalid path? " + e.getMessage()); + throw new RuntimeIOException(e); } - } - - /** - * String representation of this target property. - */ - public final String description; - - /** - * List of targets that support this property. If a property is used for - * a target that does not support it, a warning reported during - * validation. - */ - public final List supportedBy; - - /** - * The type of values that can be assigned to this property. - */ - public final TargetPropertyType type; - /** - * Function that given a configuration object and an Element AST node - * sets the configuration. It is assumed that validation already - * occurred, so this code should be straightforward. - */ - public final PropertyParser setter; + // we'll resolve relative paths to check that the files + // are as expected. - /** - * Function that given a configuration object and an Element AST node - * sets the configuration. It is assumed that validation already - * occurred, so this code should be straightforward. - */ - public final PropertyParser updater; + if (value.getLiteral() != null) { + Path resolved = referencePath.resolveSibling(StringUtil.removeQuotes(value.getLiteral())); + + config.rust.addAndCheckTopLevelModule(resolved, value, err); + } else if (value.getArray() != null) { + for (Element element : value.getArray().getElements()) { + String literal = StringUtil.removeQuotes(element.getLiteral()); + Path resolved = referencePath.resolveSibling(literal); + config.rust.addAndCheckTopLevelModule(resolved, element, err); + } + } + }), + + /** Directive for specifying Cargo features of the generated program to enable. */ + CARGO_FEATURES( + "cargo-features", + ArrayType.STRING_ARRAY, + List.of(Target.Rust), + (config) -> ASTUtils.toElement(config.rust.getCargoFeatures()), + (config, value, err) -> { + config.rust.setCargoFeatures(ASTUtils.elementToListOfStrings(value)); + }), + + /** + * Dependency specifications for Cargo. This property looks like this: + * + * 

    {@code
+   * cargo-dependencies: {
+   *    // Name-of-the-crate: "version"
+   *    rand: "0.8",
+   *    // Equivalent to using an explicit map:
+   *    rand: {
+   *      version: "0.8"
+   *    },
+   *    // The map allows specifying more details
+   *    rand: {
+   *      // A path to a local unpublished crate.
+   *      // Note 'path' is mutually exclusive with 'version'.
+   *      path: "/home/me/Git/local-rand-clone"
+   *    },
+   *    rand: {
+   *      version: "0.8",
+   *      // you can specify cargo features
+   *      features: ["some-cargo-feature",]
+   *    }
+   * }
+   * }
    + */ + CARGO_DEPENDENCIES( + "cargo-dependencies", + CargoDependenciesPropertyType.INSTANCE, + List.of(Target.Rust), + (config) -> { + var deps = config.rust.getCargoDependencies(); + if (deps.size() == 0) return null; + else { + Element e = LfFactory.eINSTANCE.createElement(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (var ent : deps.entrySet()) { + KeyValuePair pair = LfFactory.eINSTANCE.createKeyValuePair(); + pair.setName(ent.getKey()); + pair.setValue(CargoDependencySpec.extractSpec(ent.getValue())); + kvp.getPairs().add(pair); + } + e.setKeyvalue(kvp); + return e; + } + }, + (config, value, err) -> { + config.rust.setCargoDependencies(CargoDependencySpec.parseAll(value)); + }), + + /** + * Directs the C or Python target to include the associated C file used for setting up federated + * execution before processing the first tag. + */ + FED_SETUP( + "_fed_setup", + PrimitiveType.FILE, + Arrays.asList(Target.C, Target.CCPP, Target.Python), + (config) -> ASTUtils.toElement(config.fedSetupPreamble), + (config, value, err) -> + config.fedSetupPreamble = StringUtil.removeQuotes(ASTUtils.elementToSingleString(value))); + + /** Update {@code config}.dockerOptions based on value. */ + private static void setDockerProperty(TargetConfig config, Element value) { + if (value.getLiteral() != null) { + if (ASTUtils.toBoolean(value)) { + config.dockerOptions = new DockerOptions(); + } else { + config.dockerOptions = null; + } + } else { + config.dockerOptions = new DockerOptions(); + for (KeyValuePair entry : value.getKeyvalue().getPairs()) { + DockerOption option = (DockerOption) DictionaryType.DOCKER_DICT.forName(entry.getName()); + switch (option) { + case FROM: + config.dockerOptions.from = ASTUtils.elementToSingleString(entry.getValue()); + break; + default: + break; + } + } + } + } + + /** String representation of this target property. */ + public final String description; + + /** + * List of targets that support this property. If a property is used for a target that does not + * support it, a warning reported during validation. + */ + public final List supportedBy; + + /** The type of values that can be assigned to this property. */ + public final TargetPropertyType type; + + /** + * Function that given a configuration object and an Element AST node sets the configuration. It + * is assumed that validation already occurred, so this code should be straightforward. + */ + public final PropertyParser setter; + + /** + * Function that given a configuration object and an Element AST node sets the configuration. It + * is assumed that validation already occurred, so this code should be straightforward. + */ + public final PropertyParser updater; + + @FunctionalInterface + private interface PropertyParser { + + /** + * Parse the given element into the given target config. May use the error reporter to report + * format errors. + */ + void parseIntoTargetConfig(TargetConfig config, Element element, ErrorReporter err); + } + + public final PropertyGetter getter; + + @FunctionalInterface + private interface PropertyGetter { + + /** + * Read this property from the target config and build an element which represents it for the + * AST. May return null if the given value of this property is the same as the default. + */ + Element getPropertyElement(TargetConfig config); + } + + /** + * Private constructor for target properties. + * + * @param description String representation of this property. + * @param type The type that values assigned to this property should conform to. + * @param supportedBy List of targets that support this property. + * @param setter Function for configuration updates. + */ + TargetProperty( + String description, + TargetPropertyType type, + List supportedBy, + PropertyGetter getter, + PropertyParser setter) { + this.description = description; + this.type = type; + this.supportedBy = supportedBy; + this.getter = getter; + this.setter = setter; + this.updater = setter; // (Re)set by default + } + + /** + * Private constructor for target properties. This will take an additional `updater`, which will + * be used to merge target properties from imported resources. + * + * @param description String representation of this property. + * @param type The type that values assigned to this property should conform to. + * @param supportedBy List of targets that support this property. + * @param setter Function for setting configuration values. + * @param updater Function for updating configuration values. + */ + TargetProperty( + String description, + TargetPropertyType type, + List supportedBy, + PropertyGetter getter, + PropertyParser setter, + PropertyParser updater) { + this.description = description; + this.type = type; + this.supportedBy = supportedBy; + this.getter = getter; + this.setter = setter; + this.updater = updater; + } + + /** + * Return the name of the property in lingua franca. This is suitable for use as a key in a target + * properties block. It may be an invalid identifier in other languages (may contains dashes + * {@code -}). + */ + public String getDisplayName() { + return description; + } + + /** + * Set the given configuration using the given target properties. + * + * @param config The configuration object to update. + * @param properties AST node that holds all the target properties. + * @param err Error reporter on which property format errors will be reported + */ + public static void set(TargetConfig config, List properties, ErrorReporter err) { + properties.forEach( + property -> { + TargetProperty p = forName(property.getName()); + if (p != null) { + // Mark the specified target property as set by the user + config.setByUser.add(p); + try { + p.setter.parseIntoTargetConfig(config, property.getValue(), err); + } catch (InvalidLfSourceException e) { + err.reportError(e.getNode(), e.getProblem()); + } + } + }); + } + + /** + * Extracts all properties as a list of key-value pairs from a TargetConfig. Only extracts + * properties explicitly set by user. + * + * @param config The TargetConfig to extract from. + * @return The extracted properties. + */ + public static List extractProperties(TargetConfig config) { + var res = new LinkedList(); + for (TargetProperty p : config.setByUser) { + KeyValuePair kv = LfFactory.eINSTANCE.createKeyValuePair(); + kv.setName(p.toString()); + kv.setValue(p.getter.getPropertyElement(config)); + if (kv.getValue() != null) res.add(kv); + } + return res; + } + + /** + * Constructs a TargetDecl by extracting the fields of the given TargetConfig. + * + * @param target The target to generate for. + * @param config The TargetConfig to extract from. + * @return A generated TargetDecl. + */ + public static TargetDecl extractTargetDecl(Target target, TargetConfig config) { + TargetDecl decl = LfFactory.eINSTANCE.createTargetDecl(); + KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); + for (KeyValuePair p : extractProperties(config)) { + kvp.getPairs().add(p); + } + decl.setName(target.toString()); + decl.setConfig(kvp); + return decl; + } + + /** + * Update the given configuration using the given target properties. + * + * @param config The configuration object to update. + * @param properties AST node that holds all the target properties. + */ + public static void update(TargetConfig config, List properties, ErrorReporter err) { + properties.forEach( + property -> { + TargetProperty p = forName(property.getName()); + if (p != null) { + // Mark the specified target property as set by the user + config.setByUser.add(p); + p.updater.parseIntoTargetConfig(config, property.getValue(), err); + } + }); + } + + /** + * Update one of the target properties, given by 'propertyName'. For convenience, a list of target + * properties (e.g., taken from a file or resource) can be passed without any filtering. This + * function will do nothing if the list of target properties doesn't include the property given by + * 'propertyName'. + * + * @param config The target config to apply the update to. + * @param property The target property. + * @param properties AST node that holds all the target properties. + * @param err Error reporter on which property format errors will be reported + */ + public static void updateOne( + TargetConfig config, + TargetProperty property, + List properties, + ErrorReporter err) { + properties.stream() + .filter(p -> p.getName().equals(property.getDisplayName())) + .findFirst() + .map(KeyValuePair::getValue) + .ifPresent(value -> property.updater.parseIntoTargetConfig(config, value, err)); + } + + /** + * Return the entry that matches the given string. + * + * @param name The string to match against. + */ + public static TargetProperty forName(String name) { + return Target.match(name, TargetProperty.values()); + } + + /** + * Return a list with all target properties. + * + * @return All existing target properties. + */ + public static List getOptions() { + return Arrays.asList(TargetProperty.values()); + } + + /** Return the description. */ + @Override + public String toString() { + return this.description; + } + + // Inner classes for the various supported types. + + /** Dictionary type that allows for keys that will be interpreted as strings and string values. */ + public enum StringDictionaryType implements TargetPropertyType { + COMPILE_DEFINITION(); - @FunctionalInterface - private interface PropertyParser { + @Override + public boolean validate(Element e) { + if (e.getKeyvalue() != null) { + return true; + } + return false; + } - /** - * Parse the given element into the given target config. - * May use the error reporter to report format errors. - */ - void parseIntoTargetConfig(TargetConfig config, Element element, ErrorReporter err); + @Override + public void check(Element e, String name, LFValidator v) { + KeyValuePairs kv = e.getKeyvalue(); + if (kv == null) { + TargetPropertyType.produceError(name, this.toString(), v); + } else { + for (KeyValuePair pair : kv.getPairs()) { + String key = pair.getName(); + Element val = pair.getValue(); + + // Make sure the type is string + PrimitiveType.STRING.check(val, name + "." + key, v); + } + } } + } - public final PropertyGetter getter; + /** Interface for dictionary elements. It associates an entry with a type. */ + public interface DictionaryElement { - @FunctionalInterface - private interface PropertyGetter { + TargetPropertyType getType(); + } - /** - * Read this property from the target config and build an element which represents it for the AST. - * May return null if the given value of this property is the same as the default. - */ - Element getPropertyElement(TargetConfig config); - } + /** + * A dictionary type with a predefined set of possible keys and assignable types. + * + * @author Marten Lohstroh + */ + public enum DictionaryType implements TargetPropertyType { + CLOCK_SYNC_OPTION_DICT(Arrays.asList(ClockSyncOption.values())), + DOCKER_DICT(Arrays.asList(DockerOption.values())), + PLATFORM_DICT(Arrays.asList(PlatformOption.values())), + COORDINATION_OPTION_DICT(Arrays.asList(CoordinationOption.values())), + TRACING_DICT(Arrays.asList(TracingOption.values())); - /** - * Private constructor for target properties. - * - * @param description String representation of this property. - * @param type The type that values assigned to this property - * should conform to. - * @param supportedBy List of targets that support this property. - * @param setter Function for configuration updates. - */ - TargetProperty(String description, TargetPropertyType type, - List supportedBy, - PropertyGetter getter, - PropertyParser setter) { - this.description = description; - this.type = type; - this.supportedBy = supportedBy; - this.getter = getter; - this.setter = setter; - this.updater = setter; // (Re)set by default - } + /** The keys and assignable types that are allowed in this dictionary. */ + public List options; /** - * Private constructor for target properties. This will take an additional - * `updater`, which will be used to merge target properties from imported resources. + * A dictionary type restricted to sets of predefined keys and types of values. * - * @param description String representation of this property. - * @param type The type that values assigned to this property - * should conform to. - * @param supportedBy List of targets that support this property. - * @param setter Function for setting configuration values. - * @param updater Function for updating configuration values. - */ - TargetProperty(String description, TargetPropertyType type, - List supportedBy, - PropertyGetter getter, - PropertyParser setter, - PropertyParser updater) { - this.description = description; - this.type = type; - this.supportedBy = supportedBy; - this.getter = getter; - this.setter = setter; - this.updater = updater; - } - - /** - * Return the name of the property in lingua franca. This - * is suitable for use as a key in a target properties block. - * It may be an invalid identifier in other languages (may - * contains dashes {@code -}). + * @param options The dictionary elements allowed by this type. */ - public String getDisplayName() { - return description; + private DictionaryType(List options) { + this.options = options; } /** - * Set the given configuration using the given target properties. + * Return the dictionary element of which the key matches the given string. * - * @param config The configuration object to update. - * @param properties AST node that holds all the target properties. - * @param err Error reporter on which property format errors will be reported + * @param name The string to match against. + * @return The matching dictionary element (or null if there is none). */ - public static void set(TargetConfig config, List properties, ErrorReporter err) { - properties.forEach(property -> { - TargetProperty p = forName(property.getName()); - if (p != null) { - // Mark the specified target property as set by the user - config.setByUser.add(p); - try { - p.setter.parseIntoTargetConfig(config, property.getValue(), err); - } catch (InvalidLfSourceException e) { - err.reportError(e.getNode(), e.getProblem()); - } - } - }); + public DictionaryElement forName(String name) { + return Target.match(name, options); } - /** - * Extracts all properties as a list of key-value pairs from a TargetConfig. Only extracts properties explicitly set by user. - * @param config The TargetConfig to extract from. - * @return The extracted properties. - */ - public static List extractProperties(TargetConfig config) { - var res = new LinkedList(); - for (TargetProperty p : config.setByUser) { - KeyValuePair kv = LfFactory.eINSTANCE.createKeyValuePair(); - kv.setName(p.toString()); - kv.setValue(p.getter.getPropertyElement(config)); - if (kv.getValue() != null) - res.add(kv); + /** Recursively check that the passed in element conforms to the rules of this dictionary. */ + @Override + public void check(Element e, String name, LFValidator v) { + KeyValuePairs kv = e.getKeyvalue(); + if (kv == null) { + TargetPropertyType.produceError(name, this.toString(), v); + } else { + for (KeyValuePair pair : kv.getPairs()) { + String key = pair.getName(); + Element val = pair.getValue(); + Optional match = + this.options.stream() + .filter(element -> key.equalsIgnoreCase(element.toString())) + .findAny(); + if (match.isPresent()) { + // Make sure the type is correct, too. + TargetPropertyType type = match.get().getType(); + type.check(val, name + "." + key, v); + } else { + // No match found; report error. + TargetPropertyType.produceError(name, this.toString(), v); + } } - return res; + } } - /** - * Constructs a TargetDecl by extracting the fields of the given TargetConfig. - * @param target The target to generate for. - * @param config The TargetConfig to extract from. - * @return A generated TargetDecl. - */ - public static TargetDecl extractTargetDecl(Target target, TargetConfig config) { - TargetDecl decl = LfFactory.eINSTANCE.createTargetDecl(); - KeyValuePairs kvp = LfFactory.eINSTANCE.createKeyValuePairs(); - for (KeyValuePair p : extractProperties(config)) { - kvp.getPairs().add(p); - } - decl.setName(target.toString()); - decl.setConfig(kvp); - return decl; + /** Return true if the given element represents a dictionary, false otherwise. */ + @Override + public boolean validate(Element e) { + if (e.getKeyvalue() != null) { + return true; + } + return false; } - /** - * Update the given configuration using the given target properties. - * - * @param config The configuration object to update. - * @param properties AST node that holds all the target properties. - */ - public static void update(TargetConfig config, List properties, ErrorReporter err) { - properties.forEach(property -> { - TargetProperty p = forName(property.getName()); - if (p != null) { - // Mark the specified target property as set by the user - config.setByUser.add(p); - p.updater.parseIntoTargetConfig(config, property.getValue(), err); - } - }); + /** Return a human-readable description of this type. */ + @Override + public String toString() { + return "a dictionary with one or more of the following keys: " + + options.stream().map(option -> option.toString()).collect(Collectors.joining(", ")); } - - /** - * Update one of the target properties, given by 'propertyName'. - * For convenience, a list of target properties (e.g., taken from - * a file or resource) can be passed without any filtering. This - * function will do nothing if the list of target properties doesn't - * include the property given by 'propertyName'. + } + /** + * A type that can assume one of several types. + * + * @author Marten Lohstroh + */ + public enum UnionType implements TargetPropertyType { + STRING_OR_STRING_ARRAY(Arrays.asList(PrimitiveType.STRING, ArrayType.STRING_ARRAY), null), + PLATFORM_STRING_OR_DICTIONARY( + Arrays.asList(PrimitiveType.STRING, DictionaryType.PLATFORM_DICT), null), + FILE_OR_FILE_ARRAY(Arrays.asList(PrimitiveType.FILE, ArrayType.FILE_ARRAY), null), + BUILD_TYPE_UNION(Arrays.asList(BuildType.values()), null), + COORDINATION_UNION(Arrays.asList(CoordinationType.values()), CoordinationType.CENTRALIZED), + SCHEDULER_UNION(Arrays.asList(SchedulerOption.values()), SchedulerOption.getDefault()), + LOGGING_UNION(Arrays.asList(LogLevel.values()), LogLevel.INFO), + PLATFORM_UNION(Arrays.asList(Platform.values()), Platform.AUTO), + CLOCK_SYNC_UNION(Arrays.asList(ClockSyncMode.values()), ClockSyncMode.INIT), + DOCKER_UNION(Arrays.asList(PrimitiveType.BOOLEAN, DictionaryType.DOCKER_DICT), null), + TRACING_UNION(Arrays.asList(PrimitiveType.BOOLEAN, DictionaryType.TRACING_DICT), null); + + /** The constituents of this type union. */ + public final List> options; + + /** The default type, if there is one. */ + private final Enum defaultOption; + + /** + * Private constructor for creating unions types. * - * @param config The target config to apply the update to. - * @param property The target property. - * @param properties AST node that holds all the target properties. - * @param err Error reporter on which property format errors will be reported + * @param options The types that that are part of the union. + * @param defaultOption The default type. */ - public static void updateOne(TargetConfig config, TargetProperty property, List properties, ErrorReporter err) { - properties.stream() - .filter(p -> p.getName().equals(property.getDisplayName())) - .findFirst() - .map(KeyValuePair::getValue) - .ifPresent(value -> property.updater.parseIntoTargetConfig( - config, - value, - err - )); + private UnionType(List> options, Enum defaultOption) { + this.options = options; + this.defaultOption = defaultOption; } /** - * Return the entry that matches the given string. - * @param name The string to match against. - */ - public static TargetProperty forName(String name) { - return Target.match(name, TargetProperty.values()); - } - - /** - * Return a list with all target properties. + * Return the type among those in this type union that matches the given name. * - * @return All existing target properties. + * @param name The string to match against. + * @return The matching dictionary element (or null if there is none). */ - public static List getOptions() { - return Arrays.asList(TargetProperty.values()); + public Enum forName(String name) { + return Target.match(name, options); } - /** - * Return the description. - */ + /** Recursively check that the passed in element conforms to the rules of this union. */ @Override - public String toString() { - return this.description; + public void check(Element e, String name, LFValidator v) { + Optional> match = this.match(e); + if (match.isPresent()) { + // Go deeper if the element is an array or dictionary. + Enum type = match.get(); + if (type instanceof DictionaryType) { + ((DictionaryType) type).check(e, name, v); + } else if (type instanceof ArrayType) { + ((ArrayType) type).check(e, name, v); + } else if (type instanceof PrimitiveType) { + ((PrimitiveType) type).check(e, name, v); + } else if (!(type instanceof Enum)) { + throw new RuntimeException("Encountered an unknown type."); + } + } else { + // No match found; report error. + TargetPropertyType.produceError(name, this.toString(), v); + } } - // Inner classes for the various supported types. - /** - * Dictionary type that allows for keys that will be interpreted as strings - * and string values. + * Internal method for matching a given element against the allowable types. + * + * @param e AST node that represents the value of a target property. + * @return The matching type wrapped in an Optional object. */ - public enum StringDictionaryType implements TargetPropertyType { - COMPILE_DEFINITION(); - @Override - public boolean validate(Element e) { - if (e.getKeyvalue() != null) { - return true; - } - return false; - } - - @Override - public void check(Element e, String name, LFValidator v) { - KeyValuePairs kv = e.getKeyvalue(); - if (kv == null) { - TargetPropertyType.produceError(name, this.toString(), v); - } else { - for (KeyValuePair pair : kv.getPairs()) { - String key = pair.getName(); - Element val = pair.getValue(); - - // Make sure the type is string - PrimitiveType.STRING.check(val, name + "." + key, v); + private Optional> match(Element e) { + return this.options.stream() + .filter( + option -> { + if (option instanceof TargetPropertyType) { + return ((TargetPropertyType) option).validate(e); + } else { + return ASTUtils.elementToSingleString(e).equalsIgnoreCase(option.toString()); } - } - - } + }) + .findAny(); } /** - * Interface for dictionary elements. It associates an entry with a type. + * Return true if this union has an option that matches the given element. + * + * @param e The element to match against this type. */ - public interface DictionaryElement { - - TargetPropertyType getType(); + @Override + public boolean validate(Element e) { + if (this.match(e).isPresent()) { + return true; + } + return false; } /** - * A dictionary type with a predefined set of possible keys and assignable - * types. - * - * @author Marten Lohstroh - * + * Return a human-readable description of this type. If three is a default option, then indicate + * it. */ - public enum DictionaryType implements TargetPropertyType { - CLOCK_SYNC_OPTION_DICT(Arrays.asList(ClockSyncOption.values())), - DOCKER_DICT(Arrays.asList(DockerOption.values())), - PLATFORM_DICT(Arrays.asList(PlatformOption.values())), - COORDINATION_OPTION_DICT(Arrays.asList(CoordinationOption.values())), - TRACING_DICT(Arrays.asList(TracingOption.values())); - - /** - * The keys and assignable types that are allowed in this dictionary. - */ - public List options; - - /** - * A dictionary type restricted to sets of predefined keys and types of - * values. - * - * @param options The dictionary elements allowed by this type. - */ - private DictionaryType(List options) { - this.options = options; - } - - /** - * Return the dictionary element of which the key matches the given - * string. - * - * @param name The string to match against. - * @return The matching dictionary element (or null if there is none). - */ - public DictionaryElement forName(String name) { - return Target.match(name, options); - } - - /** - * Recursively check that the passed in element conforms to the rules of - * this dictionary. - */ - @Override - public void check(Element e, String name, LFValidator v) { - KeyValuePairs kv = e.getKeyvalue(); - if (kv == null) { - TargetPropertyType.produceError(name, this.toString(), v); - } else { - for (KeyValuePair pair : kv.getPairs()) { - String key = pair.getName(); - Element val = pair.getValue(); - Optional match = this.options.stream() - .filter(element -> key.equalsIgnoreCase(element.toString())).findAny(); - if (match.isPresent()) { - // Make sure the type is correct, too. - TargetPropertyType type = match.get().getType(); - type.check(val, name + "." + key, v); + @Override + public String toString() { + return "one of the following: " + + options.stream() + .map( + option -> { + if (option == this.defaultOption) { + return option.toString() + " (default)"; } else { - // No match found; report error. - TargetPropertyType.produceError(name, - this.toString(), v); + return option.toString(); } - } - } - } - - /** - * Return true if the given element represents a dictionary, false - * otherwise. - */ - @Override - public boolean validate(Element e) { - if (e.getKeyvalue() != null) { - return true; - } - return false; - } - - /** - * Return a human-readable description of this type. - */ - @Override - public String toString() { - return "a dictionary with one or more of the following keys: " - + options.stream().map(option -> option.toString()) - .collect(Collectors.joining(", ")); - } + }) + .collect(Collectors.joining(", ")); } - /** - * A type that can assume one of several types. - * - * @author Marten Lohstroh - * - */ - public enum UnionType implements TargetPropertyType { - STRING_OR_STRING_ARRAY( - Arrays.asList(PrimitiveType.STRING, ArrayType.STRING_ARRAY), - null), - PLATFORM_STRING_OR_DICTIONARY( - Arrays.asList(PrimitiveType.STRING, DictionaryType.PLATFORM_DICT), - null), - FILE_OR_FILE_ARRAY( - Arrays.asList(PrimitiveType.FILE, ArrayType.FILE_ARRAY), null), - BUILD_TYPE_UNION(Arrays.asList(BuildType.values()), null), - COORDINATION_UNION(Arrays.asList(CoordinationType.values()), - CoordinationType.CENTRALIZED), - SCHEDULER_UNION(Arrays.asList(SchedulerOption.values()), SchedulerOption.getDefault()), - LOGGING_UNION(Arrays.asList(LogLevel.values()), LogLevel.INFO), - PLATFORM_UNION(Arrays.asList(Platform.values()), Platform.AUTO), - CLOCK_SYNC_UNION(Arrays.asList(ClockSyncMode.values()), - ClockSyncMode.INIT), - DOCKER_UNION(Arrays.asList(PrimitiveType.BOOLEAN, DictionaryType.DOCKER_DICT), - null), - TRACING_UNION(Arrays.asList(PrimitiveType.BOOLEAN, DictionaryType.TRACING_DICT), - null); - - /** - * The constituents of this type union. - */ - public final List> options; - - /** - * The default type, if there is one. - */ - private final Enum defaultOption; - - /** - * Private constructor for creating unions types. - * - * @param options The types that that are part of the union. - * @param defaultOption The default type. - */ - private UnionType(List> options, Enum defaultOption) { - this.options = options; - this.defaultOption = defaultOption; - } - - /** - * Return the type among those in this type union that matches the given - * name. - * - * @param name The string to match against. - * @return The matching dictionary element (or null if there is none). - */ - public Enum forName(String name) { - return Target.match(name, options); - } - - /** - * Recursively check that the passed in element conforms to the rules of - * this union. - */ - @Override - public void check(Element e, String name, LFValidator v) { - Optional> match = this.match(e); - if (match.isPresent()) { - // Go deeper if the element is an array or dictionary. - Enum type = match.get(); - if (type instanceof DictionaryType) { - ((DictionaryType) type).check(e, name, v); - } else if (type instanceof ArrayType) { - ((ArrayType) type).check(e, name, v); - } else if (type instanceof PrimitiveType) { - ((PrimitiveType) type).check(e, name, v); - } else if (!(type instanceof Enum)) { - throw new RuntimeException("Encountered an unknown type."); - } - } else { - // No match found; report error. - TargetPropertyType.produceError(name, this.toString(), v); - } - } - - /** - * Internal method for matching a given element against the allowable - * types. - * - * @param e AST node that represents the value of a target property. - * @return The matching type wrapped in an Optional object. - */ - private Optional> match(Element e) { - return this.options.stream().filter(option -> { - if (option instanceof TargetPropertyType) { - return ((TargetPropertyType) option).validate(e); - } else { - return ASTUtils.elementToSingleString(e) - .equalsIgnoreCase(option.toString()); - } - }).findAny(); - } + } - /** - * Return true if this union has an option that matches the given - * element. - * @param e The element to match against this type. - */ - @Override - public boolean validate(Element e) { - if (this.match(e).isPresent()) { - return true; - } - return false; - } - - /** - * Return a human-readable description of this type. If three is a - * default option, then indicate it. - */ - @Override - public String toString() { - return "one of the following: " + options.stream().map(option -> { - if (option == this.defaultOption) { - return option.toString() + " (default)"; - } else { - return option.toString(); - } - }).collect(Collectors.joining(", ")); - } + /** + * An array type of which the elements confirm to a given type. + * + * @author Marten Lohstroh + */ + public enum ArrayType implements TargetPropertyType { + STRING_ARRAY(PrimitiveType.STRING), + FILE_ARRAY(PrimitiveType.FILE); - } + /** Type parameter of this array type. */ + public TargetPropertyType type; /** - * An array type of which the elements confirm to a given type. - * - * @author Marten Lohstroh + * Private constructor to create a new array type. * + * @param type The type of elements in the array. */ - public enum ArrayType implements TargetPropertyType { - STRING_ARRAY(PrimitiveType.STRING), - FILE_ARRAY(PrimitiveType.FILE); - - /** - * Type parameter of this array type. - */ - public TargetPropertyType type; - - /** - * Private constructor to create a new array type. - * - * @param type The type of elements in the array. - */ - private ArrayType(TargetPropertyType type) { - this.type = type; - } - - /** - * Check that the passed in element represents an array and ensure that - * its elements are all of the correct type. - */ - @Override - public void check(Element e, String name, LFValidator v) { - Array array = e.getArray(); - if (array == null) { - TargetPropertyType.produceError(name, this.toString(), v); - } else { - List elements = array.getElements(); - for (int i = 0; i < elements.size(); i++) { - this.type.check(elements.get(i), name + "[" + i + "]", v); - } - } - } - - /** - * Return true of the given element is an array. - */ - @Override - public boolean validate(Element e) { - if (e.getArray() != null) { - return true; - } - return false; - } - - /** - * Return a human-readable description of this type. - */ - @Override - public String toString() { - return "an array of which each element is " + this.type.toString(); - } + private ArrayType(TargetPropertyType type) { + this.type = type; } /** - * Enumeration of Cmake build types. These are also mapped - * to Cargo profiles for the Rust target (see {@link org.lflang.generator.rust.RustTargetConfig}) - * - * @author Christian Menard + * Check that the passed in element represents an array and ensure that its elements are all of + * the correct type. */ - public enum BuildType { - RELEASE("Release"), - DEBUG("Debug"), - TEST("Test"), - REL_WITH_DEB_INFO("RelWithDebInfo"), - MIN_SIZE_REL("MinSizeRel"); - - /** - * Alias used in toString method. - */ - private final String alias; - - /** - * Private constructor for Cmake build types. - */ - BuildType(String alias) { - this.alias = alias; + @Override + public void check(Element e, String name, LFValidator v) { + Array array = e.getArray(); + if (array == null) { + TargetPropertyType.produceError(name, this.toString(), v); + } else { + List elements = array.getElements(); + for (int i = 0; i < elements.size(); i++) { + this.type.check(elements.get(i), name + "[" + i + "]", v); } + } + } - /** - * Return the alias. - */ - @Override - public String toString() { - return this.alias; - } + /** Return true of the given element is an array. */ + @Override + public boolean validate(Element e) { + if (e.getArray() != null) { + return true; + } + return false; } - /** - * Enumeration of coordination types. - * - * @author Marten Lohstroh - */ - public enum CoordinationType { - CENTRALIZED, DECENTRALIZED; - - /** - * Return the name in lower case. - */ - @Override - public String toString() { - return this.name().toLowerCase(); - } + /** Return a human-readable description of this type. */ + @Override + public String toString() { + return "an array of which each element is " + this.type.toString(); + } + } + + /** + * Enumeration of Cmake build types. These are also mapped to Cargo profiles for the Rust target + * (see {@link org.lflang.generator.rust.RustTargetConfig}) + * + * @author Christian Menard + */ + public enum BuildType { + RELEASE("Release"), + DEBUG("Debug"), + TEST("Test"), + REL_WITH_DEB_INFO("RelWithDebInfo"), + MIN_SIZE_REL("MinSizeRel"); + + /** Alias used in toString method. */ + private final String alias; + + /** Private constructor for Cmake build types. */ + BuildType(String alias) { + this.alias = alias; + } + + /** Return the alias. */ + @Override + public String toString() { + return this.alias; + } + } + + /** + * Enumeration of coordination types. + * + * @author Marten Lohstroh + */ + public enum CoordinationType { + CENTRALIZED, + DECENTRALIZED; + + /** Return the name in lower case. */ + @Override + public String toString() { + return this.name().toLowerCase(); + } + } + + /** + * Enumeration of clock synchronization modes. + * + *

    - OFF: The clock synchronization is universally off. - STARTUP: Clock synchronization occurs + * at startup only. - ON: Clock synchronization occurs at startup and at runtime. + * + * @author Edward A. Lee + */ + public enum ClockSyncMode { + OFF, + INIT, + ON; // TODO Discuss initial in now a mode keyword (same as startup) and cannot be used as target + // property value, thus changed it to init + // FIXME I could not test if this change breaks anything + + /** Return the name in lower case. */ + @Override + public String toString() { + return this.name().toLowerCase(); } + } + /** + * An interface for types associated with target properties. + * + * @author Marten Lohstroh + */ + public interface TargetPropertyType { /** - * Enumeration of clock synchronization modes. + * Return true if the the given Element is a valid instance of this type. * - * - OFF: The clock synchronization is universally off. - * - STARTUP: Clock synchronization occurs at startup only. - * - ON: Clock synchronization occurs at startup and at runtime. - * - * @author Edward A. Lee + * @param e The Element to validate. + * @return True if the element conforms to this type, false otherwise. */ - public enum ClockSyncMode { - OFF, INIT, ON; // TODO Discuss initial in now a mode keyword (same as startup) and cannot be used as target property value, thus changed it to init - // FIXME I could not test if this change breaks anything - - /** - * Return the name in lower case. - */ - @Override - public String toString() { - return this.name().toLowerCase(); - } - } + public boolean validate(Element e); /** - * An interface for types associated with target properties. + * Check (recursively) the given Element against its associated type(s) and add found problems + * to the given list of errors. * - * @author Marten Lohstroh + * @param e The Element to type check. + * @param name The name of the target property. + * @param v A reference to the validator to report errors to. */ - public interface TargetPropertyType { - - /** - * Return true if the the given Element is a valid instance of this - * type. - * - * @param e The Element to validate. - * @return True if the element conforms to this type, false otherwise. - */ - public boolean validate(Element e); - - /** - * Check (recursively) the given Element against its associated type(s) - * and add found problems to the given list of errors. - * - * @param e The Element to type check. - * @param name The name of the target property. - * @param v A reference to the validator to report errors to. - */ - public void check(Element e, String name, LFValidator v); - - /** - * Helper function to produce an error during type checking. - * - * @param name The description of the target property. - * @param description The description of the type. - * @param v A reference to the validator to report errors to. - */ - public static void produceError(String name, String description, - LFValidator v) { - v.getTargetPropertyErrors().add("Target property '" + name - + "' is required to be " + description + "."); - } - } + public void check(Element e, String name, LFValidator v); /** - * Primitive types for target properties, each with a description used in - * error messages and predicate used for validating values. + * Helper function to produce an error during type checking. * - * @author Marten Lohstroh + * @param name The description of the target property. + * @param description The description of the type. + * @param v A reference to the validator to report errors to. */ - public enum PrimitiveType implements TargetPropertyType { - BOOLEAN("'true' or 'false'", - v -> ASTUtils.elementToSingleString(v).equalsIgnoreCase("true") - || ASTUtils.elementToSingleString(v).equalsIgnoreCase("false")), - INTEGER("an integer", v -> { - try { - Integer.parseInt(ASTUtils.elementToSingleString(v)); - } catch (NumberFormatException e) { - return false; - } - return true; + public static void produceError(String name, String description, LFValidator v) { + v.getTargetPropertyErrors() + .add("Target property '" + name + "' is required to be " + description + "."); + } + } + + /** + * Primitive types for target properties, each with a description used in error messages and + * predicate used for validating values. + * + * @author Marten Lohstroh + */ + public enum PrimitiveType implements TargetPropertyType { + BOOLEAN( + "'true' or 'false'", + v -> + ASTUtils.elementToSingleString(v).equalsIgnoreCase("true") + || ASTUtils.elementToSingleString(v).equalsIgnoreCase("false")), + INTEGER( + "an integer", + v -> { + try { + Integer.parseInt(ASTUtils.elementToSingleString(v)); + } catch (NumberFormatException e) { + return false; + } + return true; }), - NON_NEGATIVE_INTEGER("a non-negative integer", v -> { - try { - int result = Integer.parseInt(ASTUtils.elementToSingleString(v)); - if (result < 0) - return false; - } catch (NumberFormatException e) { - return false; - } - return true; + NON_NEGATIVE_INTEGER( + "a non-negative integer", + v -> { + try { + int result = Integer.parseInt(ASTUtils.elementToSingleString(v)); + if (result < 0) return false; + } catch (NumberFormatException e) { + return false; + } + return true; }), - TIME_VALUE("a time value with units", v -> - v.getKeyvalue() == null && v.getArray() == null - && v.getLiteral() == null && v.getId() == null + TIME_VALUE( + "a time value with units", + v -> + v.getKeyvalue() == null + && v.getArray() == null + && v.getLiteral() == null + && v.getId() == null && (v.getTime() == 0 || v.getUnit() != null)), - STRING("a string", v -> v.getLiteral() != null && !isCharLiteral(v.getLiteral()) || v.getId() != null), - FILE("a path to a file", STRING.validator); - - /** - * A description of this type, featured in error messages. - */ - private final String description; - - /** - * A predicate for determining whether a given Element conforms to this - * type. - */ - public final Predicate validator; - - /** - * Private constructor to create a new primitive type. - * @param description A textual description of the type that should - * start with "a/an". - * @param validator A predicate that returns true if a given Element - * conforms to this type. - */ - private PrimitiveType(String description, - Predicate validator) { - this.description = description; - this.validator = validator; - } + STRING( + "a string", + v -> v.getLiteral() != null && !isCharLiteral(v.getLiteral()) || v.getId() != null), + FILE("a path to a file", STRING.validator); - /** - * Return true if the the given Element is a valid instance of this type. - */ - public boolean validate(Element e) { - return this.validator.test(e); - } + /** A description of this type, featured in error messages. */ + private final String description; - /** - * Check (recursively) the given Element against its associated type(s) - * and add found problems to the given list of errors. - * - * @param e The element to type check. - * @param name The name of the target property. - * @param v The LFValidator to append errors to. - */ - public void check(Element e, String name, LFValidator v) { - if (!this.validate(e)) { - TargetPropertyType.produceError(name, this.description, v); - } - // If this is a file, perform an additional check to make sure - // the file actually exists. - // FIXME: premature because we first need a mechanism for looking up files! - // Looking in the same directory is too restrictive. Disabling this check for now. - /* - if (this == FILE) { - String file = ASTUtils.toSingleString(e); - - if (!FileConfig.fileExists(file, FileConfig.toPath(e.eResource().getURI()).toFile().getParent())) { - v.targetPropertyWarnings - .add("Could not find file: '" + file + "'."); - } - } - */ - } - - /** - * Return a textual description of this type. - */ - @Override - public String toString() { - return this.description; - } - - - private static boolean isCharLiteral(String s) { - return s.length() > 2 - && '\'' == s.charAt(0) - && '\'' == s.charAt(s.length() - 1); - } - } + /** A predicate for determining whether a given Element conforms to this type. */ + public final Predicate validator; /** - * Clock synchronization options. - * @author Marten Lohstroh + * Private constructor to create a new primitive type. + * + * @param description A textual description of the type that should start with "a/an". + * @param validator A predicate that returns true if a given Element conforms to this type. */ - public enum ClockSyncOption implements DictionaryElement { - ATTENUATION("attenuation", PrimitiveType.NON_NEGATIVE_INTEGER), - LOCAL_FEDERATES_ON("local-federates-on", PrimitiveType.BOOLEAN), - PERIOD("period", PrimitiveType.TIME_VALUE), - TEST_OFFSET("test-offset", PrimitiveType.TIME_VALUE), - TRIALS("trials", PrimitiveType.NON_NEGATIVE_INTEGER), - COLLECT_STATS("collect-stats", PrimitiveType.BOOLEAN); - - public final PrimitiveType type; - - private final String description; - - private ClockSyncOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } - - - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + private PrimitiveType(String description, Predicate validator) { + this.description = description; + this.validator = validator; + } - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + /** Return true if the the given Element is a valid instance of this type. */ + public boolean validate(Element e) { + return this.validator.test(e); } /** - * Docker options. - * @author Edward A. Lee - */ - public enum DockerOption implements DictionaryElement { - FROM("FROM", PrimitiveType.STRING); - - public final PrimitiveType type; - - private final String description; - - private DockerOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } - - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + * Check (recursively) the given Element against its associated type(s) and add found problems + * to the given list of errors. + * + * @param e The element to type check. + * @param name The name of the target property. + * @param v The LFValidator to append errors to. + */ + public void check(Element e, String name, LFValidator v) { + if (!this.validate(e)) { + TargetPropertyType.produceError(name, this.description, v); + } + // If this is a file, perform an additional check to make sure + // the file actually exists. + // FIXME: premature because we first need a mechanism for looking up files! + // Looking in the same directory is too restrictive. Disabling this check for now. + /* + if (this == FILE) { + String file = ASTUtils.toSingleString(e); + + if (!FileConfig.fileExists(file, FileConfig.toPath(e.eResource().getURI()).toFile().getParent())) { + v.targetPropertyWarnings + .add("Could not find file: '" + file + "'."); + } + } + */ + } - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + /** Return a textual description of this type. */ + @Override + public String toString() { + return this.description; } + private static boolean isCharLiteral(String s) { + return s.length() > 2 && '\'' == s.charAt(0) && '\'' == s.charAt(s.length() - 1); + } + } + + /** + * Clock synchronization options. + * + * @author Marten Lohstroh + */ + public enum ClockSyncOption implements DictionaryElement { + ATTENUATION("attenuation", PrimitiveType.NON_NEGATIVE_INTEGER), + LOCAL_FEDERATES_ON("local-federates-on", PrimitiveType.BOOLEAN), + PERIOD("period", PrimitiveType.TIME_VALUE), + TEST_OFFSET("test-offset", PrimitiveType.TIME_VALUE), + TRIALS("trials", PrimitiveType.NON_NEGATIVE_INTEGER), + COLLECT_STATS("collect-stats", PrimitiveType.BOOLEAN); + + public final PrimitiveType type; + + private final String description; + + private ClockSyncOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; + } - /** - * Platform options. - * @author Anirudh Rengarajan - */ - public enum PlatformOption implements DictionaryElement { - NAME("name", PrimitiveType.STRING), - BAUDRATE("baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER), - BOARD("board", PrimitiveType.STRING), - FLASH("flash", PrimitiveType.BOOLEAN), - PORT("port", PrimitiveType.STRING), - USER_THREADS("user-threads", PrimitiveType.NON_NEGATIVE_INTEGER); + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; + } - public final PrimitiveType type; + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } - private final String description; + /** + * Docker options. + * + * @author Edward A. Lee + */ + public enum DockerOption implements DictionaryElement { + FROM("FROM", PrimitiveType.STRING); - private PlatformOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } + public final PrimitiveType type; + private final String description; - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + private DockerOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; + } - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; } - /** - * Coordination options. - * @author Edward A. Lee - */ - public enum CoordinationOption implements DictionaryElement { - ADVANCE_MESSAGE_INTERVAL("advance-message-interval", PrimitiveType.TIME_VALUE); + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } + + /** + * Platform options. + * + * @author Anirudh Rengarajan + */ + public enum PlatformOption implements DictionaryElement { + NAME("name", PrimitiveType.STRING), + BAUDRATE("baud-rate", PrimitiveType.NON_NEGATIVE_INTEGER), + BOARD("board", PrimitiveType.STRING), + FLASH("flash", PrimitiveType.BOOLEAN), + PORT("port", PrimitiveType.STRING), + USER_THREADS("user-threads", PrimitiveType.NON_NEGATIVE_INTEGER); + + public final PrimitiveType type; + + private final String description; + + private PlatformOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; + } - public final PrimitiveType type; + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; + } - private final String description; + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } - private CoordinationOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } + /** + * Coordination options. + * + * @author Edward A. Lee + */ + public enum CoordinationOption implements DictionaryElement { + ADVANCE_MESSAGE_INTERVAL("advance-message-interval", PrimitiveType.TIME_VALUE); + public final PrimitiveType type; - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + private final String description; - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + private CoordinationOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; } - /** - * Log levels in descending order of severity. - * @author Marten Lohstroh - */ - public enum LogLevel { - ERROR, WARN, INFO, LOG, DEBUG; - - /** - * Return the name in lower case. - */ - @Override - public String toString() { - return this.name().toLowerCase(); - } + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; } - /** - * Enumeration of supported platforms - */ - public enum Platform { - AUTO, - ARDUINO, - NRF52("Nrf52"), - LINUX("Linux"), - MAC("Darwin"), - ZEPHYR("Zephyr"), - WINDOWS("Windows"); - - String cMakeName; - Platform() { - this.cMakeName = this.toString(); - } - Platform(String cMakeName) { - this.cMakeName = cMakeName; - } + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } + + /** + * Log levels in descending order of severity. + * + * @author Marten Lohstroh + */ + public enum LogLevel { + ERROR, + WARN, + INFO, + LOG, + DEBUG; + + /** Return the name in lower case. */ + @Override + public String toString() { + return this.name().toLowerCase(); + } + } + + /** Enumeration of supported platforms */ + public enum Platform { + AUTO, + ARDUINO, + NRF52("Nrf52"), + LINUX("Linux"), + MAC("Darwin"), + ZEPHYR("Zephyr"), + WINDOWS("Windows"); + + String cMakeName; + + Platform() { + this.cMakeName = this.toString(); + } - /** - * Return the name in lower case. - */ - @Override - public String toString() { - return this.name().toLowerCase(); - } + Platform(String cMakeName) { + this.cMakeName = cMakeName; + } - /** - * Get the CMake name for the platform. - */ - public String getcMakeName() { - return this.cMakeName; - } + /** Return the name in lower case. */ + @Override + public String toString() { + return this.name().toLowerCase(); } - /** - * Supported schedulers. - * @author Soroush Bateni - */ - public enum SchedulerOption { - NP(false), // Non-preemptive - ADAPTIVE(false, List.of( + /** Get the CMake name for the platform. */ + public String getcMakeName() { + return this.cMakeName; + } + } + + /** + * Supported schedulers. + * + * @author Soroush Bateni + */ + public enum SchedulerOption { + NP(false), // Non-preemptive + ADAPTIVE( + false, + List.of( Path.of("scheduler_adaptive.c"), Path.of("worker_assignments.h"), Path.of("worker_states.h"), - Path.of("data_collection.h") - )), - GEDF_NP(true), // Global EDF non-preemptive - GEDF_NP_CI(true); // Global EDF non-preemptive with chain ID - // PEDF_NP(true); // Partitioned EDF non-preemptive (FIXME: To be re-added in a future PR) - - /** - * Indicate whether or not the scheduler prioritizes reactions by deadline. - */ - private final boolean prioritizesDeadline; - - /** Relative paths to files required by this scheduler. */ - private final List relativePaths; - - SchedulerOption(boolean prioritizesDeadline) { - this(prioritizesDeadline, null); - } + Path.of("data_collection.h"))), + GEDF_NP(true), // Global EDF non-preemptive + GEDF_NP_CI(true); // Global EDF non-preemptive with chain ID + // PEDF_NP(true); // Partitioned EDF non-preemptive (FIXME: To be re-added in a future PR) - SchedulerOption(boolean prioritizesDeadline, List relativePaths) { - this.prioritizesDeadline = prioritizesDeadline; - this.relativePaths = relativePaths; - } + /** Indicate whether or not the scheduler prioritizes reactions by deadline. */ + private final boolean prioritizesDeadline; - /** - * Return true if the scheduler prioritizes reactions by deadline. - */ - public boolean prioritizesDeadline() { - return this.prioritizesDeadline; - } + /** Relative paths to files required by this scheduler. */ + private final List relativePaths; - public List getRelativePaths() { - return relativePaths != null ? ImmutableList.copyOf(relativePaths) : - List.of(Path.of("scheduler_" + this + ".c")); - } + SchedulerOption(boolean prioritizesDeadline) { + this(prioritizesDeadline, null); + } - public static SchedulerOption getDefault() { - return NP; - } + SchedulerOption(boolean prioritizesDeadline, List relativePaths) { + this.prioritizesDeadline = prioritizesDeadline; + this.relativePaths = relativePaths; } - /** - * Tracing options. - * @author Edward A. Lee - */ - public enum TracingOption implements DictionaryElement { - TRACE_FILE_NAME("trace-file-name", PrimitiveType.STRING); + /** Return true if the scheduler prioritizes reactions by deadline. */ + public boolean prioritizesDeadline() { + return this.prioritizesDeadline; + } - public final PrimitiveType type; + public List getRelativePaths() { + return relativePaths != null + ? ImmutableList.copyOf(relativePaths) + : List.of(Path.of("scheduler_" + this + ".c")); + } - private final String description; + public static SchedulerOption getDefault() { + return NP; + } + } - private TracingOption(String alias, PrimitiveType type) { - this.description = alias; - this.type = type; - } + /** + * Tracing options. + * + * @author Edward A. Lee + */ + public enum TracingOption implements DictionaryElement { + TRACE_FILE_NAME("trace-file-name", PrimitiveType.STRING); - /** - * Return the description of this dictionary element. - */ - @Override - public String toString() { - return this.description; - } + public final PrimitiveType type; - /** - * Return the type associated with this dictionary element. - */ - public TargetPropertyType getType() { - return this.type; - } + private final String description; + + private TracingOption(String alias, PrimitiveType type) { + this.description = alias; + this.type = type; } + /** Return the description of this dictionary element. */ + @Override + public String toString() { + return this.description; + } + + /** Return the type associated with this dictionary element. */ + public TargetPropertyType getType() { + return this.type; + } + } } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 01adccc8ca..0f9c25952c 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -1,26 +1,26 @@ /************* -Copyright (c) 2019-2021, The University of California at Berkeley. - -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -***************/ + * Copyright (c) 2019-2021, The University of California at Berkeley. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. + ***************/ package org.lflang.generator.c; @@ -34,6 +34,7 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import static org.lflang.ASTUtils.toText; import static org.lflang.util.StringUtil.addDoubleQuotes; +import com.google.common.collect.Iterables; import java.io.File; import java.io.IOException; import java.nio.file.Files; @@ -44,35 +45,28 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; - import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.xbase.lib.Exceptions; import org.eclipse.xtext.xbase.lib.IterableExtensions; import org.eclipse.xtext.xbase.lib.StringExtensions; - import org.lflang.ASTUtils; -import org.lflang.generator.CodeMap; -import org.lflang.generator.DockerComposeGenerator; import org.lflang.FileConfig; import org.lflang.Target; import org.lflang.TargetConfig; import org.lflang.TargetProperty; import org.lflang.TargetProperty.Platform; import org.lflang.TargetProperty.PlatformOption; - -import org.lflang.federated.extensions.CExtensionUtils; - import org.lflang.ast.DelayedConnectionTransformation; - +import org.lflang.federated.extensions.CExtensionUtils; import org.lflang.generator.ActionInstance; import org.lflang.generator.CodeBuilder; +import org.lflang.generator.CodeMap; +import org.lflang.generator.DelayBodyGenerator; +import org.lflang.generator.DockerComposeGenerator; import org.lflang.generator.DockerGenerator; import org.lflang.generator.GeneratorBase; import org.lflang.generator.GeneratorResult; import org.lflang.generator.GeneratorUtils; - -import org.lflang.generator.DelayBodyGenerator; - import org.lflang.generator.LFGeneratorContext; import org.lflang.generator.LFResource; import org.lflang.generator.ParameterInstance; @@ -87,7 +81,6 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.lf.Input; import org.lflang.lf.Instantiation; import org.lflang.lf.Mode; -import org.lflang.lf.Model; import org.lflang.lf.Port; import org.lflang.lf.Preamble; import org.lflang.lf.Reaction; @@ -98,201 +91,168 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; -import com.google.common.collect.Iterables; - /** - * Generator for C target. This class generates C code defining each reactor - * class given in the input .lf file and imported .lf files. The generated code - * has the following components: + * Generator for C target. This class generates C code defining each reactor class given in the + * input .lf file and imported .lf files. The generated code has the following components: * - * * A typedef for inputs, outputs, and actions of each reactor class. These - * define the types of the variables that reactions use to access inputs and - * action values and to set output values. + *

    * A typedef for inputs, outputs, and actions of each reactor class. These define the types of + * the variables that reactions use to access inputs and action values and to set output values. * - * * A typedef for a "self" struct for each reactor class. One instance of this - * struct will be created for each reactor instance. See below for details. + *

    * A typedef for a "self" struct for each reactor class. One instance of this struct will be + * created for each reactor instance. See below for details. * - * * A function definition for each reaction in each reactor class. These - * functions take an instance of the self struct as an argument. + *

    * A function definition for each reaction in each reactor class. These functions take an + * instance of the self struct as an argument. * - * * A constructor function for each reactor class. This is used to create - * a new instance of the reactor. + *

    * A constructor function for each reactor class. This is used to create a new instance of the + * reactor. * - * After these, the main generated function is `_lf_initialize_trigger_objects()`. - * This function creates the instances of reactors (using their constructors) - * and makes connections between them. + *

    After these, the main generated function is `_lf_initialize_trigger_objects()`. This function + * creates the instances of reactors (using their constructors) and makes connections between them. * - * A few other smaller functions are also generated. + *

    A few other smaller functions are also generated. * - * ## Self Struct + *

    ## Self Struct * - * The "self" struct has fields for each of the following: + *

    The "self" struct has fields for each of the following: * - * * parameter: the field name and type match the parameter. - * * state: the field name and type match the state. - * * action: the field name prepends the action name with "_lf_". - * A second field for the action is also created to house the trigger_t object. - * That second field prepends the action name with "_lf__". - * * output: the field name prepends the output name with "_lf_". - * * input: the field name prepends the output name with "_lf_". - * A second field for the input is also created to house the trigger_t object. - * That second field prepends the input name with "_lf__". + *

    * parameter: the field name and type match the parameter. * state: the field name and type + * match the state. * action: the field name prepends the action name with "_lf_". A second field + * for the action is also created to house the trigger_t object. That second field prepends the + * action name with "_lf__". * output: the field name prepends the output name with "_lf_". * input: + * the field name prepends the output name with "_lf_". A second field for the input is also created + * to house the trigger_t object. That second field prepends the input name with "_lf__". * - * If, in addition, the reactor contains other reactors and reacts to their outputs, - * then there will be a struct within the self struct for each such contained reactor. - * The name of that self struct will be the name of the contained reactor prepended with "_lf_". - * That inside struct will contain pointers the outputs of the contained reactors - * that are read together with pointers to booleans indicating whether those outputs are present. + *

    If, in addition, the reactor contains other reactors and reacts to their outputs, then there + * will be a struct within the self struct for each such contained reactor. The name of that self + * struct will be the name of the contained reactor prepended with "_lf_". That inside struct will + * contain pointers the outputs of the contained reactors that are read together with pointers to + * booleans indicating whether those outputs are present. * - * If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to - * trigger_t object (see reactor.h) for the shutdown event and an action struct named - * _lf_shutdown on the self struct. + *

    If, in addition, the reactor has a reaction to shutdown, then there will be a pointer to + * trigger_t object (see reactor.h) for the shutdown event and an action struct named _lf_shutdown + * on the self struct. * - * ## Reaction Functions + *

    ## Reaction Functions * - * For each reaction in a reactor class, this generator will produce a C function - * that expects a pointer to an instance of the "self" struct as an argument. - * This function will contain verbatim the C code specified in the reaction, but - * before that C code, the generator inserts a few lines of code that extract from the - * self struct the variables that that code has declared it will use. For example, if - * the reaction declares that it is triggered by or uses an input named "x" of type - * int, the function will contain a line like this: - * ``` - * r_x_t* x = self->_lf_x; - * ``` - * where `r` is the full name of the reactor class and the struct type `r_x_t` - * has fields `is_present` and `value`, where the type of `value` matches the port type. - * If the programmer fails to declare that it uses x, then the absence of the - * above code will trigger a compile error when the verbatim code attempts to read `x`. + *

    For each reaction in a reactor class, this generator will produce a C function that expects a + * pointer to an instance of the "self" struct as an argument. This function will contain verbatim + * the C code specified in the reaction, but before that C code, the generator inserts a few lines + * of code that extract from the self struct the variables that that code has declared it will use. + * For example, if the reaction declares that it is triggered by or uses an input named "x" of type + * int, the function will contain a line like this: ``` r_x_t* x = self->_lf_x; ``` where `r` is the + * full name of the reactor class and the struct type `r_x_t` has fields `is_present` and `value`, + * where the type of `value` matches the port type. If the programmer fails to declare that it uses + * x, then the absence of the above code will trigger a compile error when the verbatim code + * attempts to read `x`. * - * ## Constructor + *

    ## Constructor * - * For each reactor class, this generator will create a constructor function named - * `new_r`, where `r` is the reactor class name. This function will malloc and return - * a pointer to an instance of the "self" struct. This struct initially represents - * an unconnected reactor. To establish connections between reactors, additional - * information needs to be inserted (see below). The self struct is made visible - * to the body of a reaction as a variable named "self". The self struct contains the - * following: + *

    For each reactor class, this generator will create a constructor function named `new_r`, where + * `r` is the reactor class name. This function will malloc and return a pointer to an instance of + * the "self" struct. This struct initially represents an unconnected reactor. To establish + * connections between reactors, additional information needs to be inserted (see below). The self + * struct is made visible to the body of a reaction as a variable named "self". The self struct + * contains the following: * - * * Parameters: For each parameter `p` of the reactor, there will be a field `p` - * with the type and value of the parameter. So C code in the body of a reaction - * can access parameter values as `self->p`. + *

    * Parameters: For each parameter `p` of the reactor, there will be a field `p` with the type + * and value of the parameter. So C code in the body of a reaction can access parameter values as + * `self->p`. * - * * State variables: For each state variable `s` of the reactor, there will be a field `s` - * with the type and value of the state variable. So C code in the body of a reaction - * can access state variables as `self->s`. + *

    * State variables: For each state variable `s` of the reactor, there will be a field `s` with + * the type and value of the state variable. So C code in the body of a reaction can access state + * variables as `self->s`. * - * The self struct also contains various fields that the user is not intended to - * use. The names of these fields begin with at least two underscores. They are: + *

    The self struct also contains various fields that the user is not intended to use. The names + * of these fields begin with at least two underscores. They are: * - * * Outputs: For each output named `out`, there will be a field `_lf_out` that is - * a struct containing a value field whose type matches that of the output. - * The output value is stored here. That struct also has a field `is_present` - * that is a boolean indicating whether the output has been set. - * This field is reset to false at the start of every time - * step. There is also a field `num_destinations` whose value matches the - * number of downstream reactors that use this variable. This field must be - * set when connections are made or changed. It is used to determine for - * a mutable input destination whether a copy needs to be made. + *

    * Outputs: For each output named `out`, there will be a field `_lf_out` that is a struct + * containing a value field whose type matches that of the output. The output value is stored here. + * That struct also has a field `is_present` that is a boolean indicating whether the output has + * been set. This field is reset to false at the start of every time step. There is also a field + * `num_destinations` whose value matches the number of downstream reactors that use this variable. + * This field must be set when connections are made or changed. It is used to determine for a + * mutable input destination whether a copy needs to be made. * - * * Inputs: For each input named `in` of type T, there is a field named `_lf_in` - * that is a pointer struct with a value field of type T. The struct pointed - * to also has an `is_present` field of type bool that indicates whether the - * input is present. + *

    * Inputs: For each input named `in` of type T, there is a field named `_lf_in` that is a + * pointer struct with a value field of type T. The struct pointed to also has an `is_present` field + * of type bool that indicates whether the input is present. * - * * Outputs of contained reactors: If a reactor reacts to outputs of a - * contained reactor `r`, then the self struct will contain a nested struct - * named `_lf_r` that has fields pointing to those outputs. For example, - * if `r` has an output `out` of type T, then there will be field in `_lf_r` - * named `out` that points to a struct containing a value field - * of type T and a field named `is_present` of type bool. + *

    * Outputs of contained reactors: If a reactor reacts to outputs of a contained reactor `r`, + * then the self struct will contain a nested struct named `_lf_r` that has fields pointing to those + * outputs. For example, if `r` has an output `out` of type T, then there will be field in `_lf_r` + * named `out` that points to a struct containing a value field of type T and a field named + * `is_present` of type bool. * - * * Inputs of contained reactors: If a reactor sends to inputs of a - * contained reactor `r`, then the self struct will contain a nested struct - * named `_lf_r` that has fields for storing the values provided to those - * inputs. For example, if R has an input `in` of type T, then there will - * be field in _lf_R named `in` that is a struct with a value field - * of type T and a field named `is_present` of type bool. + *

    * Inputs of contained reactors: If a reactor sends to inputs of a contained reactor `r`, then + * the self struct will contain a nested struct named `_lf_r` that has fields for storing the values + * provided to those inputs. For example, if R has an input `in` of type T, then there will be field + * in _lf_R named `in` that is a struct with a value field of type T and a field named `is_present` + * of type bool. * - * * Actions: If the reactor has an action a (logical or physical), then there - * will be a field in the self struct named `_lf_a` and another named `_lf__a`. - * The type of the first is specific to the action and contains a `value` - * field with the type and value of the action (if it has a value). That - * struct also has a `has_value` field, an `is_present` field, and a - * `token` field (which is NULL if the action carries no value). - * The `_lf__a` field is of type trigger_t. - * That struct contains various things, including an array of reactions - * sensitive to this trigger and a lf_token_t struct containing the value of - * the action, if it has a value. See reactor.h in the C library for - * details. + *

    * Actions: If the reactor has an action a (logical or physical), then there will be a field in + * the self struct named `_lf_a` and another named `_lf__a`. The type of the first is specific to + * the action and contains a `value` field with the type and value of the action (if it has a + * value). That struct also has a `has_value` field, an `is_present` field, and a `token` field + * (which is NULL if the action carries no value). The `_lf__a` field is of type trigger_t. That + * struct contains various things, including an array of reactions sensitive to this trigger and a + * lf_token_t struct containing the value of the action, if it has a value. See reactor.h in the C + * library for details. * - * * Reactions: Each reaction will have several fields in the self struct. - * Each of these has a name that begins with `_lf__reaction_i`, where i is - * the number of the reaction, starting with 0. The fields are: - * * _lf__reaction_i: The struct that is put onto the reaction queue to - * execute the reaction (see reactor.h in the C library). + *

    * Reactions: Each reaction will have several fields in the self struct. Each of these has a + * name that begins with `_lf__reaction_i`, where i is the number of the reaction, starting with 0. + * The fields are: * _lf__reaction_i: The struct that is put onto the reaction queue to execute the + * reaction (see reactor.h in the C library). * - * * Timers: For each timer t, there is are two fields in the self struct: - * * _lf__t: The trigger_t struct for this timer (see reactor.h). - * * _lf__t_reactions: An array of reactions (pointers to the - * reaction_t structs on this self struct) sensitive to this timer. + *

    * Timers: For each timer t, there is are two fields in the self struct: * _lf__t: The + * trigger_t struct for this timer (see reactor.h). * _lf__t_reactions: An array of reactions + * (pointers to the reaction_t structs on this self struct) sensitive to this timer. * - * * Triggers: For each Timer, Action, Input, and Output of a contained - * reactor that triggers reactions, there will be a trigger_t struct - * on the self struct with name `_lf__t`, where t is the name of the trigger. + *

    * Triggers: For each Timer, Action, Input, and Output of a contained reactor that triggers + * reactions, there will be a trigger_t struct on the self struct with name `_lf__t`, where t is the + * name of the trigger. * - * ## Connections Between Reactors + *

    ## Connections Between Reactors * - * Establishing connections between reactors involves two steps. - * First, each destination (e.g. an input port) must have pointers to - * the source (the output port). As explained above, for an input named - * `in`, the field `_lf_in->value` is a pointer to the output data being read. - * In addition, `_lf_in->is_present` is a pointer to the corresponding - * `out->is_present` field of the output reactor's self struct. + *

    Establishing connections between reactors involves two steps. First, each destination (e.g. an + * input port) must have pointers to the source (the output port). As explained above, for an input + * named `in`, the field `_lf_in->value` is a pointer to the output data being read. In addition, + * `_lf_in->is_present` is a pointer to the corresponding `out->is_present` field of the output + * reactor's self struct. * - * In addition, the `reaction_i` struct on the self struct has a `triggers` - * field that records all the trigger_t structs for ports and actions - * that are triggered by the i-th reaction. The triggers field is - * an array of arrays of pointers to trigger_t structs. - * The length of the outer array is the number of output channels - * (single ports plus multiport widths) that the reaction effects - * plus the number of input port channels of contained - * reactors that it effects. Each inner array has a length equal to the - * number of final destinations of that output channel or input channel. - * The reaction_i struct has an array triggered_sizes that indicates - * the sizes of these inner arrays. The num_outputs field of the - * reaction_i struct gives the length of the triggered_sizes and - * (outer) triggers arrays. The num_outputs field is equal to the - * total number of single ports and multiport channels that the reaction - * writes to. + *

    In addition, the `reaction_i` struct on the self struct has a `triggers` field that records + * all the trigger_t structs for ports and actions that are triggered by the i-th reaction. The + * triggers field is an array of arrays of pointers to trigger_t structs. The length of the outer + * array is the number of output channels (single ports plus multiport widths) that the reaction + * effects plus the number of input port channels of contained reactors that it effects. Each inner + * array has a length equal to the number of final destinations of that output channel or input + * channel. The reaction_i struct has an array triggered_sizes that indicates the sizes of these + * inner arrays. The num_outputs field of the reaction_i struct gives the length of the + * triggered_sizes and (outer) triggers arrays. The num_outputs field is equal to the total number + * of single ports and multiport channels that the reaction writes to. * - * ## Runtime Tables + *

    ## Runtime Tables * - * This generator creates an populates the following tables used at run time. - * These tables may have to be resized and adjusted when mutations occur. + *

    This generator creates an populates the following tables used at run time. These tables may + * have to be resized and adjusted when mutations occur. * - * * _lf_is_present_fields: An array of pointers to booleans indicating whether an - * event is present. The _lf_start_time_step() function in reactor_common.c uses - * this to mark every event absent at the start of a time step. The size of this - * table is contained in the variable _lf_is_present_fields_size. - * * This table is accompanied by another list, _lf_is_present_fields_abbreviated, - * which only contains the is_present fields that have been set to true in the - * current tag. This list can allow a performance improvement if most ports are - * seldom present because only fields that have been set to true need to be - * reset to false. + *

    * _lf_is_present_fields: An array of pointers to booleans indicating whether an event is + * present. The _lf_start_time_step() function in reactor_common.c uses this to mark every event + * absent at the start of a time step. The size of this table is contained in the variable + * _lf_is_present_fields_size. * This table is accompanied by another list, + * _lf_is_present_fields_abbreviated, which only contains the is_present fields that have been set + * to true in the current tag. This list can allow a performance improvement if most ports are + * seldom present because only fields that have been set to true need to be reset to false. * - * * _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown - * reactions. The length of this table is in the _lf_shutdown_triggers_size - * variable. + *

    * _lf_shutdown_triggers: An array of pointers to trigger_t structs for shutdown reactions. The + * length of this table is in the _lf_shutdown_triggers_size variable. * - * * _lf_timer_triggers: An array of pointers to trigger_t structs for timers that - * need to be started when the program runs. The length of this table is in the - * _lf_timer_triggers_size variable. + *

    * _lf_timer_triggers: An array of pointers to trigger_t structs for timers that need to be + * started when the program runs. The length of this table is in the _lf_timer_triggers_size + * variable. * - * * _lf_action_table: For a federated execution, each federate will have this table - * that maps port IDs to the corresponding action struct, which can be cast to - * action_base_t. + *

    * _lf_action_table: For a federated execution, each federate will have this table that maps + * port IDs to the corresponding action struct, which can be cast to action_base_t. * * @author Edward A. Lee * @author Marten Lohstroh @@ -307,1129 +267,1135 @@ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY @SuppressWarnings("StaticPseudoFunctionalStyleMethod") public class CGenerator extends GeneratorBase { - // Regular expression pattern for compiler error messages with resource - // and line number information. The first match will a resource URI in the - // form of "file:/path/file.lf". The second match will be a line number. - // The third match is a character position within the line. - // The fourth match will be the error message. - static final Pattern compileErrorPattern = Pattern.compile( - "^(?.*):(?\\d+):(?\\d+):(?.*)$" - ); - - public static int UNDEFINED_MIN_SPACING = -1; - - //////////////////////////////////////////// - //// Protected fields - - /** The main place to put generated code. */ - protected CodeBuilder code = new CodeBuilder(); - - /** Place to collect code to initialize the trigger objects for all reactor instances. */ - protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); - - protected final CFileConfig fileConfig; - - /** - * Count of the number of is_present fields of the self struct that - * need to be reinitialized in _lf_start_time_step(). - */ - protected int startTimeStepIsPresentCount = 0; - - //////////////////////////////////////////// - //// Private fields - /** - * Extra lines that need to go into the generated CMakeLists.txt. - */ - private String cMakeExtras = ""; - - /** Place to collect code to execute at the start of a time step. */ - private CodeBuilder startTimeStep = new CodeBuilder(); - - /** Count of the number of token pointers that need to have their - * reference count decremented in _lf_start_time_step(). - */ - private int timerCount = 0; - private int startupReactionCount = 0; - private int shutdownReactionCount = 0; - private int resetReactionCount = 0; - private int modalReactorCount = 0; - private int modalStateResetCount = 0; - private int watchdogCount = 0; - - // Indicate whether the generator is in Cpp mode or not - private final boolean CCppMode; - - private final CTypes types; - - private final CCmakeGenerator cmakeGenerator; - - protected CGenerator( - LFGeneratorContext context, - boolean CCppMode, - CTypes types, - CCmakeGenerator cmakeGenerator, - DelayBodyGenerator delayBodyGenerator - ) { - super(context); - this.fileConfig = (CFileConfig) context.getFileConfig(); - this.CCppMode = CCppMode; - this.types = types; - this.cmakeGenerator = cmakeGenerator; - - // Register the delayed connection transformation to be applied by GeneratorBase. - // transform both after delays and physical connections - registerTransformation(new DelayedConnectionTransformation(delayBodyGenerator, types, fileConfig.resource, true, true)); + // Regular expression pattern for compiler error messages with resource + // and line number information. The first match will a resource URI in the + // form of "file:/path/file.lf". The second match will be a line number. + // The third match is a character position within the line. + // The fourth match will be the error message. + static final Pattern compileErrorPattern = + Pattern.compile("^(?.*):(?\\d+):(?\\d+):(?.*)$"); + + public static int UNDEFINED_MIN_SPACING = -1; + + //////////////////////////////////////////// + //// Protected fields + + /** The main place to put generated code. */ + protected CodeBuilder code = new CodeBuilder(); + + /** Place to collect code to initialize the trigger objects for all reactor instances. */ + protected CodeBuilder initializeTriggerObjects = new CodeBuilder(); + + protected final CFileConfig fileConfig; + + /** + * Count of the number of is_present fields of the self struct that need to be reinitialized in + * _lf_start_time_step(). + */ + protected int startTimeStepIsPresentCount = 0; + + //////////////////////////////////////////// + //// Private fields + /** Extra lines that need to go into the generated CMakeLists.txt. */ + private String cMakeExtras = ""; + + /** Place to collect code to execute at the start of a time step. */ + private CodeBuilder startTimeStep = new CodeBuilder(); + + /** + * Count of the number of token pointers that need to have their reference count decremented in + * _lf_start_time_step(). + */ + private int timerCount = 0; + + private int startupReactionCount = 0; + private int shutdownReactionCount = 0; + private int resetReactionCount = 0; + private int modalReactorCount = 0; + private int modalStateResetCount = 0; + private int watchdogCount = 0; + + // Indicate whether the generator is in Cpp mode or not + private final boolean CCppMode; + + private final CTypes types; + + private final CCmakeGenerator cmakeGenerator; + + protected CGenerator( + LFGeneratorContext context, + boolean CCppMode, + CTypes types, + CCmakeGenerator cmakeGenerator, + DelayBodyGenerator delayBodyGenerator) { + super(context); + this.fileConfig = (CFileConfig) context.getFileConfig(); + this.CCppMode = CCppMode; + this.types = types; + this.cmakeGenerator = cmakeGenerator; + + // Register the delayed connection transformation to be applied by GeneratorBase. + // transform both after delays and physical connections + registerTransformation( + new DelayedConnectionTransformation( + delayBodyGenerator, types, fileConfig.resource, true, true)); + } + + public CGenerator(LFGeneratorContext context, boolean ccppMode) { + this( + context, + ccppMode, + new CTypes(), + new CCmakeGenerator(context.getFileConfig(), List.of()), + new CDelayBodyGenerator(new CTypes())); + } + + /** + * Look for physical actions in all resources. If found, set threads to be at least one to allow + * asynchronous schedule calls. + */ + public void accommodatePhysicalActionsIfPresent() { + // If there are any physical actions, ensure the threaded engine is used and that + // keepalive is set to true, unless the user has explicitly set it to false. + for (Resource resource : GeneratorUtils.getResources(reactors)) { + for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { + if (ActionOrigin.PHYSICAL.equals(action.getOrigin())) { + // If the unthreaded runtime is not requested by the user, use the threaded runtime + // instead + // because it is the only one currently capable of handling asynchronous events. + if (!targetConfig.threading + && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { + targetConfig.threading = true; + errorReporter.reportWarning( + action, + "Using the threaded C runtime to allow for asynchronous handling of physical action" + + " " + + action.getName()); + return; + } + } + } } - - public CGenerator(LFGeneratorContext context, boolean ccppMode) { - this( - context, - ccppMode, - new CTypes(), - new CCmakeGenerator(context.getFileConfig(), List.of()), - new CDelayBodyGenerator(new CTypes()) - ); + } + + /** + * Return true if the host operating system is compatible and otherwise report an error and return + * false. + */ + protected boolean isOSCompatible() { + if (GeneratorUtils.isHostWindows()) { + if (CCppMode) { + errorReporter.reportError( + "LF programs with a CCpp target are currently not supported on Windows. " + + "Exiting code generation."); + return false; + } } + return true; + } + + /** + * Generate C code from the Lingua Franca model contained by the specified resource. This is the + * main entry point for code generation. + * + * @param resource The resource containing the source code. + * @param context The context in which the generator is invoked, including whether it is cancelled + * and whether it is a standalone context + */ + @Override + public void doGenerate(Resource resource, LFGeneratorContext context) { + super.doGenerate(resource, context); + if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; + if (!isOSCompatible()) return; // Incompatible OS and configuration - /** - * Look for physical actions in all resources. - * If found, set threads to be at least one to allow asynchronous schedule calls. - */ - public void accommodatePhysicalActionsIfPresent() { - // If there are any physical actions, ensure the threaded engine is used and that - // keepalive is set to true, unless the user has explicitly set it to false. - for (Resource resource : GeneratorUtils.getResources(reactors)) { - for (Action action : ASTUtils.allElementsOfClass(resource, Action.class)) { - if (ActionOrigin.PHYSICAL.equals(action.getOrigin())) { - // If the unthreaded runtime is not requested by the user, use the threaded runtime instead - // because it is the only one currently capable of handling asynchronous events. - if (!targetConfig.threading && !targetConfig.setByUser.contains(TargetProperty.THREADING)) { - targetConfig.threading = true; - errorReporter.reportWarning( - action, - "Using the threaded C runtime to allow for asynchronous handling of physical action " + - action.getName() - ); - return; - } - } - } - } + // Perform set up that does not generate code + setUpGeneralParameters(); + + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); + FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); + handleProtoFiles(); + + // Derive target filename from the .lf filename. + var lfModuleName = fileConfig.name; + var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); + var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; + try { + generateCodeFor(lfModuleName); + copyTargetFiles(); + generateHeaders(); + code.writeToFile(targetFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); } - /** - * Return true if the host operating system is compatible and - * otherwise report an error and return false. - */ - protected boolean isOSCompatible() { - if (GeneratorUtils.isHostWindows()) { - if (CCppMode) { - errorReporter.reportError( - "LF programs with a CCpp target are currently not supported on Windows. " + - "Exiting code generation." - ); - return false; - } - } - return true; + // Create docker file. + if (targetConfig.dockerOptions != null && mainDef != null) { + try { + var dockerData = getDockerGenerator(context).generateDockerData(); + dockerData.writeDockerFile(); + (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); + } catch (IOException e) { + throw new RuntimeException("Error while writing Docker files", e); + } } - /** - * Generate C code from the Lingua Franca model contained by the - * specified resource. This is the main entry point for code - * generation. - * @param resource The resource containing the source code. - * @param context The context in which the generator is - * invoked, including whether it is cancelled and - * whether it is a standalone context - */ - @Override - public void doGenerate(Resource resource, LFGeneratorContext context) { - super.doGenerate(resource, context); - if (!GeneratorUtils.canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return; - if (!isOSCompatible()) return; // Incompatible OS and configuration - - // Perform set up that does not generate code - setUpGeneralParameters(); - - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getSrcGenPath().toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.binPath.toFile()); - FileUtil.createDirectoryIfDoesNotExist(fileConfig.getIncludePath().toFile()); - handleProtoFiles(); - - // Derive target filename from the .lf filename. - var lfModuleName = fileConfig.name; - var cFilename = CCompiler.getTargetFileName(lfModuleName, this.CCppMode, targetConfig); - var targetFile = fileConfig.getSrcGenPath() + File.separator + cFilename; - try { - generateCodeFor(lfModuleName); - copyTargetFiles(); - generateHeaders(); - code.writeToFile(targetFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - - // Create docker file. - if (targetConfig.dockerOptions != null && mainDef != null) { - try { - var dockerData = getDockerGenerator(context).generateDockerData(); - dockerData.writeDockerFile(); - (new DockerComposeGenerator(context)).writeDockerComposeFile(List.of(dockerData)); - } catch (IOException e) { - throw new RuntimeException("Error while writing Docker files", e); - } - } - - // If cmake is requested, generate the CMakeLists.txt - if (targetConfig.platformOptions.platform != Platform.ARDUINO) { - var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; - var sources = new HashSet<>(ASTUtils.recursiveChildren(main)).stream() - .map(CUtil::getName).map(it -> it + (CCppMode ? ".cpp" : ".c")) - .collect(Collectors.toList()); - sources.add(cFilename); - var cmakeCode = cmakeGenerator.generateCMakeCode( - sources, - lfModuleName, - errorReporter, - CCppMode, - mainDef != null, - cMakeExtras, - targetConfig - ); - try { - cmakeCode.writeToFile(cmakeFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - } else { - try { - Path include = fileConfig.getSrcGenPath().resolve("include/"); - Path src = fileConfig.getSrcGenPath().resolve("src/"); - FileUtil.arduinoDeleteHelper(src, targetConfig.threading); - FileUtil.relativeIncludeHelper(src, include); - FileUtil.relativeIncludeHelper(include, include); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); - } - - if (!targetConfig.noCompile) { - ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); - arduinoUtil.buildArduino(fileConfig, targetConfig); - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } else { - System.out.println("********"); - System.out.println("To compile your program, run the following command to see information about the board you plugged in:\n\n\tarduino-cli board list\n\nGrab the FQBN and PORT from the command and run the following command in the generated sources directory:\n\n\tarduino-cli compile -b --build-property compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\nTo flash/upload your generated sketch to the board, run the following command in the generated sources directory:\n\n\tarduino-cli upload -b -p \n"); - // System.out.println("For a list of all boards installed on your computer, you can use the following command:\n\n\tarduino-cli board listall\n"); - context.finish( - GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null) - ); - } - GeneratorUtils.refreshProject(resource, context.getMode()); - return; - } + // If cmake is requested, generate the CMakeLists.txt + if (targetConfig.platformOptions.platform != Platform.ARDUINO) { + var cmakeFile = fileConfig.getSrcGenPath() + File.separator + "CMakeLists.txt"; + var sources = + new HashSet<>(ASTUtils.recursiveChildren(main)) + .stream() + .map(CUtil::getName) + .map(it -> it + (CCppMode ? ".cpp" : ".c")) + .collect(Collectors.toList()); + sources.add(cFilename); + var cmakeCode = + cmakeGenerator.generateCMakeCode( + sources, + lfModuleName, + errorReporter, + CCppMode, + mainDef != null, + cMakeExtras, + targetConfig); + try { + cmakeCode.writeToFile(cmakeFile); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } + } else { + try { + Path include = fileConfig.getSrcGenPath().resolve("include/"); + Path src = fileConfig.getSrcGenPath().resolve("src/"); + FileUtil.arduinoDeleteHelper(src, targetConfig.threading); + FileUtil.relativeIncludeHelper(src, include); + FileUtil.relativeIncludeHelper(include, include); + } catch (IOException e) { + //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored + Exceptions.sneakyThrow(e); + } - // Dump the additional compile definitions to a file to keep the generated project - // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can - // take over and do the rest of compilation. - try { - String compileDefs = targetConfig.compileDefinitions.keySet().stream() - .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) - .collect(Collectors.joining("\n")) + "\n"; - FileUtil.writeToFile( - compileDefs, - Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt") - ); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + if (!targetConfig.noCompile) { + ArduinoUtil arduinoUtil = new ArduinoUtil(context, commandFactory, errorReporter); + arduinoUtil.buildArduino(fileConfig, targetConfig); + context.finish(GeneratorResult.Status.COMPILED, null); + } else { + System.out.println("********"); + System.out.println( + "To compile your program, run the following command to see information about the board" + + " you plugged in:\n\n" + + "\tarduino-cli board list\n\n" + + "Grab the FQBN and PORT from the command and run the following command in the" + + " generated sources directory:\n\n" + + "\tarduino-cli compile -b --build-property" + + " compiler.c.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" + + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' --build-property" + + " compiler.cpp.extra_flags='-DLF_UNTHREADED -DPLATFORM_ARDUINO" + + " -DINITIAL_EVENT_QUEUE_SIZE=10 -DINITIAL_REACT_QUEUE_SIZE=10' .\n\n" + + "To flash/upload your generated sketch to the board, run the following command in" + + " the generated sources directory:\n\n" + + "\tarduino-cli upload -b -p \n"); + // System.out.println("For a list of all boards installed on your computer, you can use the + // following command:\n\n\tarduino-cli board listall\n"); + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + } + GeneratorUtils.refreshProject(resource, context.getMode()); + return; + } - // Create a .vscode/settings.json file in the target directory so that VSCode can - // immediately compile the generated code. - try { - String compileDefs = targetConfig.compileDefinitions.keySet().stream() - .map(key -> "\"-D" + key + "=" + targetConfig.compileDefinitions.get(key) + "\"") - .collect(Collectors.joining(",\n")); - String settings = "{\n" - + "\"cmake.configureArgs\": [\n" - + compileDefs - + "\n]\n}\n"; - Path vscodePath = Path.of(fileConfig.getSrcGenPath() + File.separator + ".vscode"); - if (!Files.exists(vscodePath)) - Files.createDirectory(vscodePath); - FileUtil.writeToFile( - settings, - Path.of(fileConfig.getSrcGenPath() - + File.separator + ".vscode" - + File.separator + "settings.json") - ); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } + // Dump the additional compile definitions to a file to keep the generated project + // self-contained. In this way, third-party build tools like PlatformIO, west, arduino-cli can + // take over and do the rest of compilation. + try { + String compileDefs = + targetConfig.compileDefinitions.keySet().stream() + .map(key -> key + "=" + targetConfig.compileDefinitions.get(key)) + .collect(Collectors.joining("\n")) + + "\n"; + FileUtil.writeToFile( + compileDefs, + Path.of(fileConfig.getSrcGenPath() + File.separator + "CompileDefinitions.txt")); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } - // If this code generator is directly compiling the code, compile it now so that we - // clean it up after, removing the #line directives after errors have been reported. - if ( - !targetConfig.noCompile && targetConfig.dockerOptions == null - && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) - // This code is unreachable in LSP_FAST mode, so that check is omitted. - && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM - ) { - // FIXME: Currently, a lack of main is treated as a request to not produce - // a binary and produce a .o file instead. There should be a way to control - // this. - // Create an anonymous Runnable class and add it to the compileThreadPool - // so that compilation can happen in parallel. - var cleanCode = code.removeLines("#line"); - - var execName = lfModuleName; - var threadFileConfig = fileConfig; - var generator = this; // FIXME: currently only passed to report errors with line numbers in the Eclipse IDE - var CppMode = CCppMode; - // generatingContext.reportProgress( - // String.format("Generated code for %d/%d executables. Compiling...", federateCount, federates.size()), - // 100 * federateCount / federates.size() - // ); // FIXME: Move to FedGenerator - // Create the compiler to be used later - - var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); - try { - if (!cCompiler.runCCompiler(generator, context)) { - // If compilation failed, remove any bin files that may have been created. - CUtil.deleteBinFiles(threadFileConfig); - // If finish has already been called, it is illegal and makes no sense. However, - // if finish has already been called, then this must be a federated execution. - context.unsuccessfulFinish(); - } else { - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } - cleanCode.writeToFile(targetFile); - } catch (IOException e) { - Exceptions.sneakyThrow(e); - } - } + // Create a .vscode/settings.json file in the target directory so that VSCode can + // immediately compile the generated code. + try { + String compileDefs = + targetConfig.compileDefinitions.keySet().stream() + .map(key -> "\"-D" + key + "=" + targetConfig.compileDefinitions.get(key) + "\"") + .collect(Collectors.joining(",\n")); + String settings = "{\n" + "\"cmake.configureArgs\": [\n" + compileDefs + "\n]\n}\n"; + Path vscodePath = Path.of(fileConfig.getSrcGenPath() + File.separator + ".vscode"); + if (!Files.exists(vscodePath)) Files.createDirectory(vscodePath); + FileUtil.writeToFile( + settings, + Path.of( + fileConfig.getSrcGenPath() + + File.separator + + ".vscode" + + File.separator + + "settings.json")); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } - // If a build directive has been given, invoke it now. - // Note that the code does not get cleaned in this case. - if (!targetConfig.noCompile) { - if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { - CUtil.runBuildCommand( - fileConfig, - targetConfig, - commandFactory, - errorReporter, - this::reportCommandErrors, - context.getMode() - ); - context.finish( - GeneratorResult.Status.COMPILED, null - ); - } - if (!errorsOccurred()){ - System.out.println("Compiled binary is in " + fileConfig.binPath); - } + // If this code generator is directly compiling the code, compile it now so that we + // clean it up after, removing the #line directives after errors have been reported. + if (!targetConfig.noCompile + && targetConfig.dockerOptions == null + && IterableExtensions.isNullOrEmpty(targetConfig.buildCommands) + // This code is unreachable in LSP_FAST mode, so that check is omitted. + && context.getMode() != LFGeneratorContext.Mode.LSP_MEDIUM) { + // FIXME: Currently, a lack of main is treated as a request to not produce + // a binary and produce a .o file instead. There should be a way to control + // this. + // Create an anonymous Runnable class and add it to the compileThreadPool + // so that compilation can happen in parallel. + var cleanCode = code.removeLines("#line"); + + var execName = lfModuleName; + var threadFileConfig = fileConfig; + var generator = + this; // FIXME: currently only passed to report errors with line numbers in the Eclipse + // IDE + var CppMode = CCppMode; + // generatingContext.reportProgress( + // String.format("Generated code for %d/%d executables. Compiling...", federateCount, + // federates.size()), + // 100 * federateCount / federates.size() + // ); // FIXME: Move to FedGenerator + // Create the compiler to be used later + + var cCompiler = new CCompiler(targetConfig, threadFileConfig, errorReporter, CppMode); + try { + if (!cCompiler.runCCompiler(generator, context)) { + // If compilation failed, remove any bin files that may have been created. + CUtil.deleteBinFiles(threadFileConfig); + // If finish has already been called, it is illegal and makes no sense. However, + // if finish has already been called, then this must be a federated execution. + context.unsuccessfulFinish(); } else { - context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); + context.finish(GeneratorResult.Status.COMPILED, null); } + cleanCode.writeToFile(targetFile); + } catch (IOException e) { + Exceptions.sneakyThrow(e); + } + } - // In case we are in Eclipse, make sure the generated code is visible. - GeneratorUtils.refreshProject(resource, context.getMode()); + // If a build directive has been given, invoke it now. + // Note that the code does not get cleaned in this case. + if (!targetConfig.noCompile) { + if (!IterableExtensions.isNullOrEmpty(targetConfig.buildCommands)) { + CUtil.runBuildCommand( + fileConfig, + targetConfig, + commandFactory, + errorReporter, + this::reportCommandErrors, + context.getMode()); + context.finish(GeneratorResult.Status.COMPILED, null); + } + if (!errorsOccurred()) { + System.out.println("Compiled binary is in " + fileConfig.binPath); + } + } else { + context.finish(GeneratorResult.GENERATED_NO_EXECUTABLE.apply(context, null)); } - private void generateCodeFor( - String lfModuleName - ) throws IOException { - startTimeStepIsPresentCount = 0; - code.pr(generateDirectives()); - code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); - // Generate code for each reactor. - generateReactorDefinitions(); - - // Generate main instance, if there is one. - // Note that any main reactors in imported files are ignored. - // Skip generation if there are cycles. - if (main != null) { - initializeTriggerObjects.pr(String.join("\n", - "int _lf_startup_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", - "int _lf_shutdown_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", - "int _lf_reset_reactions_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", - "int _lf_timer_triggers_count = 0;", - "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", - "int bank_index;", - "SUPPRESS_UNUSED_WARNING(bank_index);", - "int watchdog_number = 0;", - "SUPPRESS_UNUSED_WARNING(watchdog_number);")); - // Add counters for modal initialization - initializeTriggerObjects.pr(CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); - - // Create an array of arrays to store all self structs. - // This is needed because connections cannot be established until - // all reactor instances have self structs because ports that - // receive data reference the self structs of the originating - // reactors, which are arbitarily far away in the program graph. - generateSelfStructs(main); - generateReactorInstance(main); - - if (targetConfig.fedSetupPreamble != null) { - if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); - code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); - if (targetLanguageIsCpp()) code.pr("}"); - } + // In case we are in Eclipse, make sure the generated code is visible. + GeneratorUtils.refreshProject(resource, context.getMode()); + } + + private void generateCodeFor(String lfModuleName) throws IOException { + startTimeStepIsPresentCount = 0; + code.pr(generateDirectives()); + code.pr(new CMainFunctionGenerator(targetConfig).generateCode()); + // Generate code for each reactor. + generateReactorDefinitions(); + + // Generate main instance, if there is one. + // Note that any main reactors in imported files are ignored. + // Skip generation if there are cycles. + if (main != null) { + initializeTriggerObjects.pr( + String.join( + "\n", + "int _lf_startup_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_startup_reactions_count);", + "int _lf_shutdown_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_shutdown_reactions_count);", + "int _lf_reset_reactions_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_reset_reactions_count);", + "int _lf_timer_triggers_count = 0;", + "SUPPRESS_UNUSED_WARNING(_lf_timer_triggers_count);", + "int bank_index;", + "SUPPRESS_UNUSED_WARNING(bank_index);", + "int watchdog_number = 0;", + "SUPPRESS_UNUSED_WARNING(watchdog_number);")); + // Add counters for modal initialization + initializeTriggerObjects.pr( + CModesGenerator.generateModalInitalizationCounters(hasModalReactors)); + + // Create an array of arrays to store all self structs. + // This is needed because connections cannot be established until + // all reactor instances have self structs because ports that + // receive data reference the self structs of the originating + // reactors, which are arbitarily far away in the program graph. + generateSelfStructs(main); + generateReactorInstance(main); + + if (targetConfig.fedSetupPreamble != null) { + if (targetLanguageIsCpp()) code.pr("extern \"C\" {"); + code.pr("#include \"" + targetConfig.fedSetupPreamble + "\""); + if (targetLanguageIsCpp()) code.pr("}"); + } - // If there are timers, create a table of timers to be initialized. - code.pr(CTimerGenerator.generateDeclarations(timerCount)); - - // If there are startup reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); - - // If there are shutdown reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); - - // If there are reset reactions, create a table of triggers. - code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); - - // If there are watchdogs, create a table of triggers. - code.pr(CWatchdogGenerator.generateWatchdogTable(watchdogCount)); - - // If there are modes, create a table of mode state to be checked for transitions. - code.pr(CModesGenerator.generateModeStatesTable( - hasModalReactors, - modalReactorCount, - modalStateResetCount - )); - - // Generate function to initialize the trigger objects for all reactors. - code.pr(CTriggerObjectsGenerator.generateInitializeTriggerObjects( - main, - targetConfig, - initializeTriggerObjects, - startTimeStep, - types, - lfModuleName, - startTimeStepIsPresentCount - )); - - // Generate function to trigger startup reactions for all reactors. - code.pr(CReactionGenerator.generateLfTriggerStartupReactions(startupReactionCount, hasModalReactors)); - - // Generate function to schedule timers for all reactors. - code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); - - // Generate a function that will either do nothing - // (if there is only one federate or the coordination - // is set to decentralized) or, if there are - // downstream federates, will notify the RTI - // that the specified logical time is complete. - if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) code.pr("extern \"C\""); - code.pr(String.join("\n", - "void logical_tag_complete(tag_t tag_to_send) {", - CExtensionUtils.surroundWithIfFederatedCentralized( - " _lf_logical_tag_complete(tag_to_send);" - ), - "}" - )); - - // Generate function to schedule shutdown reactions if any - // reactors have reactions to shutdown. - code.pr(CReactionGenerator.generateLfTriggerShutdownReactions(shutdownReactionCount, hasModalReactors)); - - // Generate an empty termination function for non-federated - // execution. For federated execution, an implementation is - // provided in federate.c. That implementation will resign - // from the federation and close any open sockets. - code.pr(""" + // If there are timers, create a table of timers to be initialized. + code.pr(CTimerGenerator.generateDeclarations(timerCount)); + + // If there are startup reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(startupReactionCount, "startup")); + + // If there are shutdown reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(shutdownReactionCount, "shutdown")); + + // If there are reset reactions, create a table of triggers. + code.pr(CReactionGenerator.generateBuiltinTriggersTable(resetReactionCount, "reset")); + + // If there are watchdogs, create a table of triggers. + code.pr(CWatchdogGenerator.generateWatchdogTable(watchdogCount)); + + // If there are modes, create a table of mode state to be checked for transitions. + code.pr( + CModesGenerator.generateModeStatesTable( + hasModalReactors, modalReactorCount, modalStateResetCount)); + + // Generate function to initialize the trigger objects for all reactors. + code.pr( + CTriggerObjectsGenerator.generateInitializeTriggerObjects( + main, + targetConfig, + initializeTriggerObjects, + startTimeStep, + types, + lfModuleName, + startTimeStepIsPresentCount)); + + // Generate function to trigger startup reactions for all reactors. + code.pr( + CReactionGenerator.generateLfTriggerStartupReactions( + startupReactionCount, hasModalReactors)); + + // Generate function to schedule timers for all reactors. + code.pr(CTimerGenerator.generateLfInitializeTimer(timerCount)); + + // Generate a function that will either do nothing + // (if there is only one federate or the coordination + // is set to decentralized) or, if there are + // downstream federates, will notify the RTI + // that the specified logical time is complete. + if (CCppMode || targetConfig.platformOptions.platform == Platform.ARDUINO) + code.pr("extern \"C\""); + code.pr( + String.join( + "\n", + "void logical_tag_complete(tag_t tag_to_send) {", + CExtensionUtils.surroundWithIfFederatedCentralized( + " _lf_logical_tag_complete(tag_to_send);"), + "}")); + + // Generate function to schedule shutdown reactions if any + // reactors have reactions to shutdown. + code.pr( + CReactionGenerator.generateLfTriggerShutdownReactions( + shutdownReactionCount, hasModalReactors)); + + // Generate an empty termination function for non-federated + // execution. For federated execution, an implementation is + // provided in federate.c. That implementation will resign + // from the federation and close any open sockets. + code.pr( + """ #ifndef FEDERATED void terminate_execution() {} - #endif""" - ); - - - // Generate functions for modes - code.pr(CModesGenerator.generateLfInitializeModes( - hasModalReactors - )); - code.pr(CModesGenerator.generateLfHandleModeChanges( - hasModalReactors, - modalStateResetCount - )); - code.pr(CReactionGenerator.generateLfModeTriggeredReactions( - startupReactionCount, - resetReactionCount, - hasModalReactors - )); - } - } - - @Override - public void checkModalReactorSupport(boolean __) { - // Modal reactors are currently only supported for non federated applications - super.checkModalReactorSupport(true); + #endif"""); + + // Generate functions for modes + code.pr(CModesGenerator.generateLfInitializeModes(hasModalReactors)); + code.pr(CModesGenerator.generateLfHandleModeChanges(hasModalReactors, modalStateResetCount)); + code.pr( + CReactionGenerator.generateLfModeTriggeredReactions( + startupReactionCount, resetReactionCount, hasModalReactors)); } - - @Override - protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { - return String.join("\n", - "// Generated forwarding reaction for connections with the same destination", - "// but located in mutually exclusive modes.", - "lf_set("+dest+", "+source+"->value);" - ); - } - - /** Set the scheduler type in the target config as needed. */ - private void pickScheduler() { - // Don't use a scheduler that does not prioritize reactions based on deadlines - // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. - if (!targetConfig.schedulerType.prioritizesDeadline()) { - // Check if a deadline is assigned to any reaction - if (hasDeadlines(reactors)) { - if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { - targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; - } - } + } + + @Override + public void checkModalReactorSupport(boolean __) { + // Modal reactors are currently only supported for non federated applications + super.checkModalReactorSupport(true); + } + + @Override + protected String getConflictingConnectionsInModalReactorsBody(String source, String dest) { + return String.join( + "\n", + "// Generated forwarding reaction for connections with the same destination", + "// but located in mutually exclusive modes.", + "lf_set(" + dest + ", " + source + "->value);"); + } + + /** Set the scheduler type in the target config as needed. */ + private void pickScheduler() { + // Don't use a scheduler that does not prioritize reactions based on deadlines + // if the program contains a deadline (handler). Use the GEDF_NP scheduler instead. + if (!targetConfig.schedulerType.prioritizesDeadline()) { + // Check if a deadline is assigned to any reaction + if (hasDeadlines(reactors)) { + if (!targetConfig.setByUser.contains(TargetProperty.SCHEDULER)) { + targetConfig.schedulerType = TargetProperty.SchedulerOption.GEDF_NP; } + } } + } - private boolean hasDeadlines(List reactors) { - for (Reactor reactor : reactors) { - for (Reaction reaction : allReactions(reactor)) { - if (reaction.getDeadline() != null) { - return true; - } - } + private boolean hasDeadlines(List reactors) { + for (Reactor reactor : reactors) { + for (Reaction reaction : allReactions(reactor)) { + if (reaction.getDeadline() != null) { + return true; } - return false; + } } - - /** - * Look at the 'reactor' eResource. - * If it is an imported .lf file, incorporate it into the current - * program in the following manner: - * - Merge its target property with `targetConfig` - * - If there are any preambles, add them to the preambles of the reactor. - */ - private void inspectReactorEResource(ReactorDecl reactor) { - // If the reactor is imported, look at the - // target definition of the .lf file in which the reactor is imported from and - // append any cmake-include. - // Check if the reactor definition is imported - if (reactor.eResource() != mainDef.getReactorClass().eResource()) { - // Find the LFResource corresponding to this eResource - LFResource lfResource = null; - for (var resource : resources) { - if (resource.getEResource() == reactor.eResource()) { - lfResource = resource; - break; - } - } - if (lfResource != null) { - // Copy the user files and cmake-includes to the src-gen path of the main .lf file - copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); - // Merge the CMake includes from the imported file into the target config - lfResource.getTargetConfig().cmakeIncludes.forEach(incl -> { - if (!this.targetConfig.cmakeIncludes.contains(incl)) { - this.targetConfig.cmakeIncludes.add(incl); - } - }); - } + return false; + } + + /** + * Look at the 'reactor' eResource. If it is an imported .lf file, incorporate it into the current + * program in the following manner: - Merge its target property with `targetConfig` - If there are + * any preambles, add them to the preambles of the reactor. + */ + private void inspectReactorEResource(ReactorDecl reactor) { + // If the reactor is imported, look at the + // target definition of the .lf file in which the reactor is imported from and + // append any cmake-include. + // Check if the reactor definition is imported + if (reactor.eResource() != mainDef.getReactorClass().eResource()) { + // Find the LFResource corresponding to this eResource + LFResource lfResource = null; + for (var resource : resources) { + if (resource.getEResource() == reactor.eResource()) { + lfResource = resource; + break; } + } + if (lfResource != null) { + // Copy the user files and cmake-includes to the src-gen path of the main .lf file + copyUserFiles(lfResource.getTargetConfig(), lfResource.getFileConfig()); + // Merge the CMake includes from the imported file into the target config + lfResource + .getTargetConfig() + .cmakeIncludes + .forEach( + incl -> { + if (!this.targetConfig.cmakeIncludes.contains(incl)) { + this.targetConfig.cmakeIncludes.add(incl); + } + }); + } } - - /** - * Copy all files or directories listed in the target property `files`, `cmake-include`, - * and `_fed_setup` into the src-gen folder of the main .lf file - * - * @param targetConfig The targetConfig to read the target properties from. - * @param fileConfig The fileConfig used to make the copy and resolve paths. - */ - @Override - protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { - super.copyUserFiles(targetConfig, fileConfig); - // Must use class variable to determine destination! - var destination = this.fileConfig.getSrcGenPath(); - - FileUtil.copyFilesOrDirectories(targetConfig.cmakeIncludes, destination, fileConfig, errorReporter, true); - - // FIXME: Unclear what the following does, but it does not appear to belong here. - if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { - try { - FileUtil.copyFile(fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), - destination.resolve(targetConfig.fedSetupPreamble)); - } catch (IOException e) { - errorReporter.reportError("Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); - } - } + } + + /** + * Copy all files or directories listed in the target property `files`, `cmake-include`, and + * `_fed_setup` into the src-gen folder of the main .lf file + * + * @param targetConfig The targetConfig to read the target properties from. + * @param fileConfig The fileConfig used to make the copy and resolve paths. + */ + @Override + protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { + super.copyUserFiles(targetConfig, fileConfig); + // Must use class variable to determine destination! + var destination = this.fileConfig.getSrcGenPath(); + + FileUtil.copyFilesOrDirectories( + targetConfig.cmakeIncludes, destination, fileConfig, errorReporter, true); + + // FIXME: Unclear what the following does, but it does not appear to belong here. + if (!StringExtensions.isNullOrEmpty(targetConfig.fedSetupPreamble)) { + try { + FileUtil.copyFile( + fileConfig.srcFile.getParent().resolve(targetConfig.fedSetupPreamble), + destination.resolve(targetConfig.fedSetupPreamble)); + } catch (IOException e) { + errorReporter.reportError( + "Failed to find _fed_setup file " + targetConfig.fedSetupPreamble); + } } - - /** - * Generate code for defining all reactors that belong to the federate, - * including all the child reactors down the hierarchy. Duplicate - * Duplicates are avoided. - * - * Imported reactors' original .lf file is - * incorporated in the following manner: - * - If there are any cmake-include files, add them to the current list - * of cmake-include files. - * - If there are any preambles, add them to the preambles of the reactor. - */ - private void generateReactorDefinitions() throws IOException { - var generatedReactors = new LinkedHashSet(); - if (this.main != null) { - generateReactorChildren(this.main, generatedReactors); - } - - if (this.mainDef != null) { - generateReactorClass(ASTUtils.toDefinition(this.mainDef.getReactorClass())); - } - - if (mainDef == null) { - // Generate code for each reactor that was not instantiated in main or its children. - for (Reactor r : reactors) { - // Get the declarations for reactors that are instantiated somewhere. - // A declaration is either a reactor definition or an import statement.; - var declarations = this.instantiationGraph.getDeclarations(r); - // If the reactor has no instantiations and there is no main reactor, then - // generate code for it anyway (at a minimum, this means that the compiler is invoked - // so that reaction bodies are checked). - if (declarations.isEmpty()) { - generateReactorClass(r); - } - } - } + } + + /** + * Generate code for defining all reactors that belong to the federate, including all the child + * reactors down the hierarchy. Duplicate Duplicates are avoided. + * + *

    Imported reactors' original .lf file is incorporated in the following manner: - If there are + * any cmake-include files, add them to the current list of cmake-include files. - If there are + * any preambles, add them to the preambles of the reactor. + */ + private void generateReactorDefinitions() throws IOException { + var generatedReactors = new LinkedHashSet(); + if (this.main != null) { + generateReactorChildren(this.main, generatedReactors); } - /** Generate user-visible header files for all reactors instantiated. */ - private void generateHeaders() throws IOException { - FileUtil.deleteDirectory(fileConfig.getIncludePath()); - FileUtil.copyFromClassPath( - fileConfig.getRuntimeIncludePath(), - fileConfig.getIncludePath(), - false, - true - ); - for (Reactor r : reactors) { - CReactorHeaderFileGenerator.doGenerate( - types, r, fileConfig, - (builder, rr, userFacing) -> { - generateAuxiliaryStructs(builder, rr, userFacing); - if (userFacing) { - ASTUtils.allInstantiations(r).stream().map(Instantiation::getReactorClass).collect(Collectors.toSet()).forEach(it -> { - ASTUtils.allPorts(ASTUtils.toDefinition(it)) - .forEach(p -> builder.pr(CPortGenerator.generateAuxiliaryStruct( - ASTUtils.toDefinition(it), p, getTarget(), errorReporter, types, new CodeBuilder(), true, it - ))); - }); - } - }, - this::generateTopLevelPreambles); - } - FileUtil.copyDirectoryContents(fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + if (this.mainDef != null) { + generateReactorClass(ASTUtils.toDefinition(this.mainDef.getReactorClass())); } - /** - * Generate code for the children of 'reactor' that belong to 'federate'. - * Duplicates are avoided. - * - * Imported reactors' original .lf file is - * incorporated in the following manner: - * - If there are any cmake-include files, add them to the current list - * of cmake-include files. - * - If there are any preambles, add them to the preambles of the reactor. - * - * @param reactor Used to extract children from - */ - private void generateReactorChildren( - ReactorInstance reactor, - LinkedHashSet generatedReactors - ) throws IOException { - for (ReactorInstance r : reactor.children) { - if (r.reactorDeclaration != null && - !generatedReactors.contains(r.reactorDefinition)) { - generatedReactors.add(r.reactorDefinition); - generateReactorChildren(r, generatedReactors); - inspectReactorEResource(r.reactorDeclaration); - generateReactorClass(r.reactorDefinition); - } + if (mainDef == null) { + // Generate code for each reactor that was not instantiated in main or its children. + for (Reactor r : reactors) { + // Get the declarations for reactors that are instantiated somewhere. + // A declaration is either a reactor definition or an import statement.; + var declarations = this.instantiationGraph.getDeclarations(r); + // If the reactor has no instantiations and there is no main reactor, then + // generate code for it anyway (at a minimum, this means that the compiler is invoked + // so that reaction bodies are checked). + if (declarations.isEmpty()) { + generateReactorClass(r); } + } } - - /** - * Choose which platform files to compile with according to the OS. - * If there is no main reactor, then compilation will produce a .o file requiring further linking. - * Also, if useCmake is set to true, we don't need to add platform files. The CMakeLists.txt file - * will detect and use the appropriate platform file based on the platform that cmake is invoked on. - */ - private void pickCompilePlatform() { - var osName = System.getProperty("os.name").toLowerCase(); - // if platform target was set, use given platform instead - if (targetConfig.platformOptions.platform != Platform.AUTO) { - osName = targetConfig.platformOptions.platform.toString(); - } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { - errorReporter.reportError("Platform " + osName + " is not supported"); - } + } + + /** Generate user-visible header files for all reactors instantiated. */ + private void generateHeaders() throws IOException { + FileUtil.deleteDirectory(fileConfig.getIncludePath()); + FileUtil.copyFromClassPath( + fileConfig.getRuntimeIncludePath(), fileConfig.getIncludePath(), false, true); + for (Reactor r : reactors) { + CReactorHeaderFileGenerator.doGenerate( + types, + r, + fileConfig, + (builder, rr, userFacing) -> { + generateAuxiliaryStructs(builder, rr, userFacing); + if (userFacing) { + ASTUtils.allInstantiations(r).stream() + .map(Instantiation::getReactorClass) + .collect(Collectors.toSet()) + .forEach( + it -> { + ASTUtils.allPorts(ASTUtils.toDefinition(it)) + .forEach( + p -> + builder.pr( + CPortGenerator.generateAuxiliaryStruct( + ASTUtils.toDefinition(it), + p, + getTarget(), + errorReporter, + types, + new CodeBuilder(), + true, + it))); + }); + } + }, + this::generateTopLevelPreambles); } - - /** - * Copy target-specific header file to the src-gen directory. - */ - protected void copyTargetFiles() throws IOException { - // Copy the core lib - String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); - Path dest = fileConfig.getSrcGenPath(); - if (targetConfig.platformOptions.platform == Platform.ARDUINO) { - dest = dest.resolve("src"); + FileUtil.copyDirectoryContents( + fileConfig.getIncludePath(), fileConfig.getSrcGenPath().resolve("include"), false); + } + + /** + * Generate code for the children of 'reactor' that belong to 'federate'. Duplicates are avoided. + * + *

    Imported reactors' original .lf file is incorporated in the following manner: - If there are + * any cmake-include files, add them to the current list of cmake-include files. - If there are + * any preambles, add them to the preambles of the reactor. + * + * @param reactor Used to extract children from + */ + private void generateReactorChildren( + ReactorInstance reactor, LinkedHashSet generatedReactors) throws IOException { + for (ReactorInstance r : reactor.children) { + if (r.reactorDeclaration != null && !generatedReactors.contains(r.reactorDefinition)) { + generatedReactors.add(r.reactorDefinition); + generateReactorChildren(r, generatedReactors); + inspectReactorEResource(r.reactorDeclaration); + generateReactorClass(r.reactorDefinition); } - if (coreLib != null) { - FileUtil.copyDirectoryContents(Path.of(coreLib), dest, true); - } else { - FileUtil.copyFromClassPath( - "/lib/c/reactor-c/core", - dest, - true, - false - ); - FileUtil.copyFromClassPath( - "/lib/c/reactor-c/lib", - dest, - true, - false - ); - } - - // For the Zephyr target, copy default config and board files. - if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { - FileUtil.copyFromClassPath( - "/lib/platform/zephyr/boards", - fileConfig.getSrcGenPath(), - false, - false - ); - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/prj_lf.conf", - fileConfig.getSrcGenPath(), - true - ); - - FileUtil.copyFileFromClassPath( - "/lib/platform/zephyr/Kconfig", - fileConfig.getSrcGenPath(), - true - ); - } } - - //////////////////////////////////////////// - //// Code generators. - - /** - * Generate a reactor class definition for the specified federate. - * A class definition has four parts: - * - * * Preamble code, if any, specified in the Lingua Franca file. - * * A "self" struct type definition (see the class documentation above). - * * A function for each reaction. - * * A constructor for creating an instance. - * for deleting an instance. - * - * If the reactor is the main reactor, then - * the generated code may be customized. Specifically, - * if the main reactor has reactions, these reactions - * will not be generated if they are triggered by or send - * data to contained reactors that are not in the federate. - * @param reactor The parsed reactor data structure. - */ - private void generateReactorClass(Reactor reactor) throws IOException { - // FIXME: Currently we're not reusing definitions for declarations that point to the same definition. - CodeBuilder header = new CodeBuilder(); - CodeBuilder src = new CodeBuilder(); - final String headerName = CUtil.getName(reactor) + ".h"; - var guardMacro = headerName.toUpperCase().replace(".", "_"); - header.pr("#ifndef " + guardMacro); - header.pr("#define " + guardMacro); - generateReactorClassHeaders(reactor, headerName, header, src); - header.pr(generateTopLevelPreambles(reactor)); - generateUserPreamblesForReactor(reactor, src); - generateReactorClassBody(reactor, header, src); - header.pr("#endif // " + guardMacro); - FileUtil.writeToFile(CodeMap.fromGeneratedCode(header.toString()).getGeneratedCode(), fileConfig.getSrcGenPath().resolve(headerName), true); - var extension = targetConfig.platformOptions.platform == Platform.ARDUINO ? ".ino" : - CCppMode ? ".cpp" : ".c"; - FileUtil.writeToFile(CodeMap.fromGeneratedCode(src.toString()).getGeneratedCode(), fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), true); + } + + /** + * Choose which platform files to compile with according to the OS. If there is no main reactor, + * then compilation will produce a .o file requiring further linking. Also, if useCmake is set to + * true, we don't need to add platform files. The CMakeLists.txt file will detect and use the + * appropriate platform file based on the platform that cmake is invoked on. + */ + private void pickCompilePlatform() { + var osName = System.getProperty("os.name").toLowerCase(); + // if platform target was set, use given platform instead + if (targetConfig.platformOptions.platform != Platform.AUTO) { + osName = targetConfig.platformOptions.platform.toString(); + } else if (Stream.of("mac", "darwin", "win", "nux").noneMatch(osName::contains)) { + errorReporter.reportError("Platform " + osName + " is not supported"); } - - protected void generateReactorClassHeaders(Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { - if (CCppMode) { - src.pr("extern \"C\" {"); - header.pr("extern \"C\" {"); - } - header.pr("#include \"include/core/reactor.h\""); - src.pr("#include \"include/api/api.h\""); - src.pr("#include \"include/api/set.h\""); - generateIncludes(reactor); - if (CCppMode) { - src.pr("}"); - header.pr("}"); - } - src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(reactor) + "\""); - src.pr("#include \"" + headerName + "\""); - ASTUtils.allNestedClasses(reactor).map(CUtil::getName) - .map(name -> "#include \"" + name + ".h\"") - .forEach(header::pr); + } + + /** Copy target-specific header file to the src-gen directory. */ + protected void copyTargetFiles() throws IOException { + // Copy the core lib + String coreLib = LFGeneratorContext.BuildParm.EXTERNAL_RUNTIME_PATH.getValue(context); + Path dest = fileConfig.getSrcGenPath(); + if (targetConfig.platformOptions.platform == Platform.ARDUINO) { + dest = dest.resolve("src"); } - - private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeBuilder src) { - // Some of the following methods create lines of code that need to - // go into the constructor. Collect those lines of code here: - var constructorCode = new CodeBuilder(); - generateAuxiliaryStructs(header, reactor, false); - // The following must go before the self struct so the #include watchdog.h ends up in the header. - CWatchdogGenerator.generateWatchdogs(src, header, reactor, errorReporter); - generateSelfStruct(header, reactor, constructorCode); - generateMethods(src, reactor); - generateReactions(src, reactor); - generateConstructor(src, header, reactor, constructorCode); + if (coreLib != null) { + FileUtil.copyDirectoryContents(Path.of(coreLib), dest, true); + } else { + FileUtil.copyFromClassPath("/lib/c/reactor-c/core", dest, true, false); + FileUtil.copyFromClassPath("/lib/c/reactor-c/lib", dest, true, false); } - /** - * Generate methods for {@code reactor}. - */ - protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { - CMethodGenerator.generateMethods(reactor, src, types); - } + // For the Zephyr target, copy default config and board files. + if (targetConfig.platformOptions.platform == Platform.ZEPHYR) { + FileUtil.copyFromClassPath( + "/lib/platform/zephyr/boards", fileConfig.getSrcGenPath(), false, false); + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/prj_lf.conf", fileConfig.getSrcGenPath(), true); - /** - * Generates preambles defined by user for a given reactor - * @param reactor The given reactor - */ - protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { - for (Preamble p : ASTUtils.allPreambles(reactor)) { - src.pr("// *********** From the preamble, verbatim:"); - src.prSourceLineNumber(p.getCode()); - src.pr(toText(p.getCode())); - src.pr("\n// *********** End of preamble."); - } + FileUtil.copyFileFromClassPath( + "/lib/platform/zephyr/Kconfig", fileConfig.getSrcGenPath(), true); } - - /** - * Generate a constructor for the specified reactor in the specified federate. - * @param reactor The parsed reactor data structure. - * @param constructorCode Lines of code previously generated that need to - * go into the constructor. - */ - protected void generateConstructor( - CodeBuilder src, CodeBuilder header, Reactor reactor, CodeBuilder constructorCode - ) { - header.pr(CConstructorGenerator.generateConstructorPrototype(reactor)); - src.pr(CConstructorGenerator.generateConstructor( - reactor, - constructorCode.toString() - )); + } + + //////////////////////////////////////////// + //// Code generators. + + /** + * Generate a reactor class definition for the specified federate. A class definition has four + * parts: + * + *

    * Preamble code, if any, specified in the Lingua Franca file. * A "self" struct type + * definition (see the class documentation above). * A function for each reaction. * A constructor + * for creating an instance. for deleting an instance. + * + *

    If the reactor is the main reactor, then the generated code may be customized. Specifically, + * if the main reactor has reactions, these reactions will not be generated if they are triggered + * by or send data to contained reactors that are not in the federate. + * + * @param reactor The parsed reactor data structure. + */ + private void generateReactorClass(Reactor reactor) throws IOException { + // FIXME: Currently we're not reusing definitions for declarations that point to the same + // definition. + CodeBuilder header = new CodeBuilder(); + CodeBuilder src = new CodeBuilder(); + final String headerName = CUtil.getName(reactor) + ".h"; + var guardMacro = headerName.toUpperCase().replace(".", "_"); + header.pr("#ifndef " + guardMacro); + header.pr("#define " + guardMacro); + generateReactorClassHeaders(reactor, headerName, header, src); + header.pr(generateTopLevelPreambles(reactor)); + generateUserPreamblesForReactor(reactor, src); + generateReactorClassBody(reactor, header, src); + header.pr("#endif // " + guardMacro); + FileUtil.writeToFile( + CodeMap.fromGeneratedCode(header.toString()).getGeneratedCode(), + fileConfig.getSrcGenPath().resolve(headerName), + true); + var extension = + targetConfig.platformOptions.platform == Platform.ARDUINO + ? ".ino" + : CCppMode ? ".cpp" : ".c"; + FileUtil.writeToFile( + CodeMap.fromGeneratedCode(src.toString()).getGeneratedCode(), + fileConfig.getSrcGenPath().resolve(CUtil.getName(reactor) + extension), + true); + } + + protected void generateReactorClassHeaders( + Reactor reactor, String headerName, CodeBuilder header, CodeBuilder src) { + if (CCppMode) { + src.pr("extern \"C\" {"); + header.pr("extern \"C\" {"); } - - protected void generateIncludes(Reactor r) { - code.pr("#include \"" + CUtil.getName(r) + ".h\""); + header.pr("#include \"include/core/reactor.h\""); + src.pr("#include \"include/api/api.h\""); + src.pr("#include \"include/api/set.h\""); + generateIncludes(reactor); + if (CCppMode) { + src.pr("}"); + header.pr("}"); } - - /** - * Generate the struct type definitions for inputs, outputs, and - * actions of the specified reactor. - */ - protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { - // In the case where there are incoming - // p2p logical connections in decentralized - // federated execution, there will be an - // intended_tag field added to accommodate - // the case where a reaction triggered by a - // port or action is late due to network - // latency, etc.. - var federatedExtension = new CodeBuilder(); - federatedExtension.pr(""" + src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(reactor) + "\""); + src.pr("#include \"" + headerName + "\""); + ASTUtils.allNestedClasses(reactor) + .map(CUtil::getName) + .map(name -> "#include \"" + name + ".h\"") + .forEach(header::pr); + } + + private void generateReactorClassBody(Reactor reactor, CodeBuilder header, CodeBuilder src) { + // Some of the following methods create lines of code that need to + // go into the constructor. Collect those lines of code here: + var constructorCode = new CodeBuilder(); + generateAuxiliaryStructs(header, reactor, false); + // The following must go before the self struct so the #include watchdog.h ends up in the + // header. + CWatchdogGenerator.generateWatchdogs(src, header, reactor, errorReporter); + generateSelfStruct(header, reactor, constructorCode); + generateMethods(src, reactor); + generateReactions(src, reactor); + generateConstructor(src, header, reactor, constructorCode); + } + + /** Generate methods for {@code reactor}. */ + protected void generateMethods(CodeBuilder src, ReactorDecl reactor) { + CMethodGenerator.generateMethods(reactor, src, types); + } + + /** + * Generates preambles defined by user for a given reactor + * + * @param reactor The given reactor + */ + protected void generateUserPreamblesForReactor(Reactor reactor, CodeBuilder src) { + for (Preamble p : ASTUtils.allPreambles(reactor)) { + src.pr("// *********** From the preamble, verbatim:"); + src.prSourceLineNumber(p.getCode()); + src.pr(toText(p.getCode())); + src.pr("\n// *********** End of preamble."); + } + } + + /** + * Generate a constructor for the specified reactor in the specified federate. + * + * @param reactor The parsed reactor data structure. + * @param constructorCode Lines of code previously generated that need to go into the constructor. + */ + protected void generateConstructor( + CodeBuilder src, CodeBuilder header, Reactor reactor, CodeBuilder constructorCode) { + header.pr(CConstructorGenerator.generateConstructorPrototype(reactor)); + src.pr(CConstructorGenerator.generateConstructor(reactor, constructorCode.toString())); + } + + protected void generateIncludes(Reactor r) { + code.pr("#include \"" + CUtil.getName(r) + ".h\""); + } + + /** + * Generate the struct type definitions for inputs, outputs, and actions of the specified reactor. + */ + protected void generateAuxiliaryStructs(CodeBuilder builder, Reactor r, boolean userFacing) { + // In the case where there are incoming + // p2p logical connections in decentralized + // federated execution, there will be an + // intended_tag field added to accommodate + // the case where a reaction triggered by a + // port or action is late due to network + // latency, etc.. + var federatedExtension = new CodeBuilder(); + federatedExtension.pr( + """ #ifdef FEDERATED #ifdef FEDERATED_DECENTRALIZED %s intended_tag; #endif %s physical_time_of_arrival; #endif - """.formatted(types.getTargetTagType(), types.getTargetTimeType()) - ); - for (Port p : allPorts(r)) { - builder.pr(CPortGenerator.generateAuxiliaryStruct( - r, - p, - getTarget(), - errorReporter, - types, - federatedExtension, - userFacing, - null - )); - } - // The very first item on this struct needs to be - // a trigger_t* because the struct will be cast to (trigger_t*) - // by the lf_schedule() functions to get to the trigger. - for (Action action : allActions(r)) { - builder.pr(CActionGenerator.generateAuxiliaryStruct( - r, - action, - getTarget(), - types, - federatedExtension, - userFacing - )); - } + """ + .formatted(types.getTargetTagType(), types.getTargetTimeType())); + for (Port p : allPorts(r)) { + builder.pr( + CPortGenerator.generateAuxiliaryStruct( + r, p, getTarget(), errorReporter, types, federatedExtension, userFacing, null)); } - - /** - * Generate the self struct type definition for the specified reactor - * in the specified federate. - * @param decl The parsed reactor data structure. - * @param constructorCode Place to put lines of code that need to - * go into the constructor. - */ - private void generateSelfStruct(CodeBuilder builder, ReactorDecl decl, CodeBuilder constructorCode) { - var reactor = toDefinition(decl); - var selfType = CUtil.selfType(ASTUtils.toDefinition(decl)); - - // Construct the typedef for the "self" struct. - // Create a type name for the self struct. - var body = new CodeBuilder(); - - // Extensions can add functionality to the CGenerator - generateSelfStructExtension(body, decl, constructorCode); - - // Next handle parameters. - body.pr(CParameterGenerator.generateDeclarations(reactor, types)); - - // Next handle states. - body.pr(CStateGenerator.generateDeclarations(reactor, types)); - - // Next handle actions. - CActionGenerator.generateDeclarations(reactor, body, constructorCode); - - // Next handle inputs and outputs. - CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); - - // If there are contained reactors that either receive inputs - // from reactions of this reactor or produce outputs that trigger - // reactions of this reactor, then we need to create a struct - // inside the self struct for each contained reactor. That - // struct has a place to hold the data produced by this reactor's - // reactions and a place to put pointers to data produced by - // the contained reactors. - generateInteractingContainedReactors(reactor, body, constructorCode); - - // Next, generate the fields needed for each reaction. - CReactionGenerator.generateReactionAndTriggerStructs( - body, - reactor, - constructorCode, - types - ); - - // Generate the fields needed for each watchdog. - CWatchdogGenerator.generateWatchdogStruct(body, decl, constructorCode); - - // Next, generate fields for modes - CModesGenerator.generateDeclarations(reactor, body, constructorCode); - - // The first field has to always be a pointer to the list of - // of allocated memory that must be freed when the reactor is freed. - // This means that the struct can be safely cast to self_base_t. - builder.pr("typedef struct {"); - builder.indent(); - builder.pr("struct self_base_t base;"); - builder.pr(body.toString()); - builder.unindent(); - builder.pr("} " + selfType + ";"); + // The very first item on this struct needs to be + // a trigger_t* because the struct will be cast to (trigger_t*) + // by the lf_schedule() functions to get to the trigger. + for (Action action : allActions(r)) { + builder.pr( + CActionGenerator.generateAuxiliaryStruct( + r, action, getTarget(), types, federatedExtension, userFacing)); } - - /** - * Generate structs and associated code for contained reactors that - * send or receive data to or from the container's reactions. - * - * If there are contained reactors that either receive inputs - * from reactions of this reactor or produce outputs that trigger - * reactions of this reactor, then we need to create a struct - * inside the self struct of the container for each contained reactor. - * That struct has a place to hold the data produced by the container reactor's - * reactions and a place to put pointers to data produced by - * the contained reactors. - * - * @param reactor The reactor. - * @param body The place to put the struct definition for the contained reactors. - * @param constructorCode The place to put matching code that goes in the container's constructor. - */ - private void generateInteractingContainedReactors( - Reactor reactor, - CodeBuilder body, - CodeBuilder constructorCode - ) { - // The contents of the struct will be collected first so that - // we avoid duplicate entries and then the struct will be constructed. - var contained = new InteractingContainedReactors(reactor); - // Next generate the relevant code. - for (Instantiation containedReactor : contained.containedReactors()) { - Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); - // First define an _width variable in case it is a bank. - var array = ""; - var width = -2; - // If the instantiation is a bank, find the maximum bank width - // to define an array. - if (containedReactor.getWidthSpec() != null) { - width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); - array = "[" + width + "]"; - } - // NOTE: The following needs to be done for each instance - // so that the width can be parameter, not in the constructor. - // Here, we conservatively use a width that is the largest of all isntances. - constructorCode.pr(String.join("\n", - "// Set the _width variable for all cases. This will be -2", - "// if the reactor is not a bank of reactors.", - "self->_lf_"+containedReactor.getName()+"_width = "+width+";" - )); - - // Generate one struct for each contained reactor that interacts. - body.pr("struct {"); - body.indent(); - for (Port port : contained.portsOfInstance(containedReactor)) { - if (port instanceof Input) { - // If the variable is a multiport, then the place to store the data has - // to be malloc'd at initialization. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType, false)+" "+port.getName()+";"); - } else { - // Is a multiport. - // Memory will be malloc'd in initialization. - body.pr(port, String.join("\n", - variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", - "int "+port.getName()+"_width;" - )); - } - } else { - // Must be an output port. - // Outputs of contained reactors are pointers to the source of data on the - // self struct of the container. - if (!ASTUtils.isMultiport(port)) { - // Not a multiport. - body.pr(port, variableStructType(port, containedReactorType, false)+"* "+port.getName()+";"); - } else { - // Is a multiport. - // Here, we will use an array of pointers. - // Memory will be malloc'd in initialization. - body.pr(port, String.join("\n", - variableStructType(port, containedReactorType, false)+"** "+port.getName()+";", - "int "+port.getName()+"_width;" - )); - } - body.pr(port, "trigger_t "+port.getName()+"_trigger;"); - var reactorIndex = ""; - if (containedReactor.getWidthSpec() != null) { - reactorIndex = "[reactor_index]"; - constructorCode.pr("for (int reactor_index = 0; reactor_index < self->_lf_"+containedReactor.getName()+"_width; reactor_index++) {"); - constructorCode.indent(); - } - var portOnSelf = "self->_lf_"+containedReactor.getName()+reactorIndex+"."+port.getName(); - - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederatedDecentralized( - portOnSelf+"_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};" - ) - ); - - var triggered = contained.reactionsTriggered(containedReactor, port); - //noinspection StatementWithEmptyBody - if (triggered.size() > 0) { - body.pr(port, "reaction_t* "+port.getName()+"_reactions["+triggered.size()+"];"); - var triggeredCount = 0; - for (Integer index : triggered) { - constructorCode.pr(port, portOnSelf+"_reactions["+triggeredCount+++"] = &self->_lf__reaction_"+index+";"); - } - constructorCode.pr(port, portOnSelf+"_trigger.reactions = "+portOnSelf+"_reactions;"); - } else { - // Since the self struct is created using calloc, there is no need to set - // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL - } - // Since the self struct is created using calloc, there is no need to set falsy fields. - constructorCode.pr(port, String.join("\n", - portOnSelf+"_trigger.last = NULL;", - portOnSelf+"_trigger.number_of_reactions = "+triggered.size()+";" - )); - - - // Set the physical_time_of_arrival - constructorCode.pr( - port, - CExtensionUtils.surroundWithIfFederated( - portOnSelf+"_trigger.physical_time_of_arrival = NEVER;" - ) - ); - - if (containedReactor.getWidthSpec() != null) { - constructorCode.unindent(); - constructorCode.pr("}"); - } - } + } + + /** + * Generate the self struct type definition for the specified reactor in the specified federate. + * + * @param decl The parsed reactor data structure. + * @param constructorCode Place to put lines of code that need to go into the constructor. + */ + private void generateSelfStruct( + CodeBuilder builder, ReactorDecl decl, CodeBuilder constructorCode) { + var reactor = toDefinition(decl); + var selfType = CUtil.selfType(ASTUtils.toDefinition(decl)); + + // Construct the typedef for the "self" struct. + // Create a type name for the self struct. + var body = new CodeBuilder(); + + // Extensions can add functionality to the CGenerator + generateSelfStructExtension(body, decl, constructorCode); + + // Next handle parameters. + body.pr(CParameterGenerator.generateDeclarations(reactor, types)); + + // Next handle states. + body.pr(CStateGenerator.generateDeclarations(reactor, types)); + + // Next handle actions. + CActionGenerator.generateDeclarations(reactor, body, constructorCode); + + // Next handle inputs and outputs. + CPortGenerator.generateDeclarations(reactor, decl, body, constructorCode); + + // If there are contained reactors that either receive inputs + // from reactions of this reactor or produce outputs that trigger + // reactions of this reactor, then we need to create a struct + // inside the self struct for each contained reactor. That + // struct has a place to hold the data produced by this reactor's + // reactions and a place to put pointers to data produced by + // the contained reactors. + generateInteractingContainedReactors(reactor, body, constructorCode); + + // Next, generate the fields needed for each reaction. + CReactionGenerator.generateReactionAndTriggerStructs(body, reactor, constructorCode, types); + + // Generate the fields needed for each watchdog. + CWatchdogGenerator.generateWatchdogStruct(body, decl, constructorCode); + + // Next, generate fields for modes + CModesGenerator.generateDeclarations(reactor, body, constructorCode); + + // The first field has to always be a pointer to the list of + // of allocated memory that must be freed when the reactor is freed. + // This means that the struct can be safely cast to self_base_t. + builder.pr("typedef struct {"); + builder.indent(); + builder.pr("struct self_base_t base;"); + builder.pr(body.toString()); + builder.unindent(); + builder.pr("} " + selfType + ";"); + } + + /** + * Generate structs and associated code for contained reactors that send or receive data to or + * from the container's reactions. + * + *

    If there are contained reactors that either receive inputs from reactions of this reactor or + * produce outputs that trigger reactions of this reactor, then we need to create a struct inside + * the self struct of the container for each contained reactor. That struct has a place to hold + * the data produced by the container reactor's reactions and a place to put pointers to data + * produced by the contained reactors. + * + * @param reactor The reactor. + * @param body The place to put the struct definition for the contained reactors. + * @param constructorCode The place to put matching code that goes in the container's constructor. + */ + private void generateInteractingContainedReactors( + Reactor reactor, CodeBuilder body, CodeBuilder constructorCode) { + // The contents of the struct will be collected first so that + // we avoid duplicate entries and then the struct will be constructed. + var contained = new InteractingContainedReactors(reactor); + // Next generate the relevant code. + for (Instantiation containedReactor : contained.containedReactors()) { + Reactor containedReactorType = ASTUtils.toDefinition(containedReactor.getReactorClass()); + // First define an _width variable in case it is a bank. + var array = ""; + var width = -2; + // If the instantiation is a bank, find the maximum bank width + // to define an array. + if (containedReactor.getWidthSpec() != null) { + width = CReactionGenerator.maxContainedReactorBankWidth(containedReactor, null, 0, mainDef); + array = "[" + width + "]"; + } + // NOTE: The following needs to be done for each instance + // so that the width can be parameter, not in the constructor. + // Here, we conservatively use a width that is the largest of all isntances. + constructorCode.pr( + String.join( + "\n", + "// Set the _width variable for all cases. This will be -2", + "// if the reactor is not a bank of reactors.", + "self->_lf_" + containedReactor.getName() + "_width = " + width + ";")); + + // Generate one struct for each contained reactor that interacts. + body.pr("struct {"); + body.indent(); + for (Port port : contained.portsOfInstance(containedReactor)) { + if (port instanceof Input) { + // If the variable is a multiport, then the place to store the data has + // to be malloc'd at initialization. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr( + port, + variableStructType(port, containedReactorType, false) + " " + port.getName() + ";"); + } else { + // Is a multiport. + // Memory will be malloc'd in initialization. + body.pr( + port, + String.join( + "\n", + variableStructType(port, containedReactorType, false) + + "** " + + port.getName() + + ";", + "int " + port.getName() + "_width;")); + } + } else { + // Must be an output port. + // Outputs of contained reactors are pointers to the source of data on the + // self struct of the container. + if (!ASTUtils.isMultiport(port)) { + // Not a multiport. + body.pr( + port, + variableStructType(port, containedReactorType, false) + + "* " + + port.getName() + + ";"); + } else { + // Is a multiport. + // Here, we will use an array of pointers. + // Memory will be malloc'd in initialization. + body.pr( + port, + String.join( + "\n", + variableStructType(port, containedReactorType, false) + + "** " + + port.getName() + + ";", + "int " + port.getName() + "_width;")); + } + body.pr(port, "trigger_t " + port.getName() + "_trigger;"); + var reactorIndex = ""; + if (containedReactor.getWidthSpec() != null) { + reactorIndex = "[reactor_index]"; + constructorCode.pr( + "for (int reactor_index = 0; reactor_index < self->_lf_" + + containedReactor.getName() + + "_width; reactor_index++) {"); + constructorCode.indent(); + } + var portOnSelf = + "self->_lf_" + containedReactor.getName() + reactorIndex + "." + port.getName(); + + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederatedDecentralized( + portOnSelf + + "_trigger.intended_tag = (tag_t) { .time = NEVER, .microstep = 0u};")); + + var triggered = contained.reactionsTriggered(containedReactor, port); + //noinspection StatementWithEmptyBody + if (triggered.size() > 0) { + body.pr( + port, "reaction_t* " + port.getName() + "_reactions[" + triggered.size() + "];"); + var triggeredCount = 0; + for (Integer index : triggered) { + constructorCode.pr( + port, + portOnSelf + + "_reactions[" + + triggeredCount++ + + "] = &self->_lf__reaction_" + + index + + ";"); } - body.unindent(); - body.pr(String.join("\n", - "} _lf_"+containedReactor.getName()+array+";", - "int _lf_"+containedReactor.getName()+"_width;" - )); + constructorCode.pr( + port, portOnSelf + "_trigger.reactions = " + portOnSelf + "_reactions;"); + } else { + // Since the self struct is created using calloc, there is no need to set + // self->_lf_"+containedReactor.getName()+"."+port.getName()+"_trigger.reactions = NULL + } + // Since the self struct is created using calloc, there is no need to set falsy fields. + constructorCode.pr( + port, + String.join( + "\n", + portOnSelf + "_trigger.last = NULL;", + portOnSelf + "_trigger.number_of_reactions = " + triggered.size() + ";")); + + // Set the physical_time_of_arrival + constructorCode.pr( + port, + CExtensionUtils.surroundWithIfFederated( + portOnSelf + "_trigger.physical_time_of_arrival = NEVER;")); + + if (containedReactor.getWidthSpec() != null) { + constructorCode.unindent(); + constructorCode.pr("}"); + } } + } + body.unindent(); + body.pr( + String.join( + "\n", + "} _lf_" + containedReactor.getName() + array + ";", + "int _lf_" + containedReactor.getName() + "_width;")); } - - /** - * This function is provided to allow extensions of the CGenerator to append the structure of the self struct - * @param body The body of the self struct - * @param decl The reactor declaration for the self struct - * @param constructorCode Code that is executed when the reactor is instantiated - */ - protected void generateSelfStructExtension( - CodeBuilder body, - ReactorDecl decl, - CodeBuilder constructorCode - ) { - // Do nothing - } - - /** Generate reaction functions definition for a reactor. - * These functions have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param r The reactor. - */ - public void generateReactions(CodeBuilder src, Reactor r) { - var reactionIndex = 0; - var reactor = ASTUtils.toDefinition(r); - for (Reaction reaction : allReactions(reactor)) { - generateReaction(src, reaction, r, reactionIndex); - // Increment reaction index even if the reaction is not in the federate - // so that across federates, the reaction indices are consistent. - reactionIndex++; - } + } + + /** + * This function is provided to allow extensions of the CGenerator to append the structure of the + * self struct + * + * @param body The body of the self struct + * @param decl The reactor declaration for the self struct + * @param constructorCode Code that is executed when the reactor is instantiated + */ + protected void generateSelfStructExtension( + CodeBuilder body, ReactorDecl decl, CodeBuilder constructorCode) { + // Do nothing + } + + /** + * Generate reaction functions definition for a reactor. These functions have a single argument + * that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param r The reactor. + */ + public void generateReactions(CodeBuilder src, Reactor r) { + var reactionIndex = 0; + var reactor = ASTUtils.toDefinition(r); + for (Reaction reaction : allReactions(reactor)) { + generateReaction(src, reaction, r, reactionIndex); + // Increment reaction index even if the reaction is not in the federate + // so that across federates, the reaction indices are consistent. + reactionIndex++; } - - /** Generate a reaction function definition for a reactor. - * This function will have a single argument that is a void* pointing to - * a struct that contains parameters, state variables, inputs (triggering or not), - * actions (triggering or produced), and outputs. - * @param reaction The reaction. - * @param r The reactor. - * @param reactionIndex The position of the reaction within the reactor. - */ - protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { - src.pr(CReactionGenerator.generateReaction( + } + + /** + * Generate a reaction function definition for a reactor. This function will have a single + * argument that is a void* pointing to a struct that contains parameters, state variables, inputs + * (triggering or not), actions (triggering or produced), and outputs. + * + * @param reaction The reaction. + * @param r The reactor. + * @param reactionIndex The position of the reaction within the reactor. + */ + protected void generateReaction( + CodeBuilder src, Reaction reaction, Reactor r, int reactionIndex) { + src.pr( + CReactionGenerator.generateReaction( reaction, r, reactionIndex, @@ -1437,707 +1403,746 @@ protected void generateReaction(CodeBuilder src, Reaction reaction, Reactor r, i errorReporter, types, targetConfig, - getTarget().requiresTypes - )); - } - - /** - * Record startup, shutdown, and reset reactions. - * @param instance A reactor instance. - */ - private void recordBuiltinTriggers(ReactorInstance instance) { - // For each reaction instance, allocate the arrays that will be used to - // trigger downstream reactions. - for (ReactionInstance reaction : instance.reactions) { - var reactor = reaction.getParent(); - var temp = new CodeBuilder(); - var foundOne = false; - - var reactionRef = CUtil.reactionRef(reaction); - - // Next handle triggers of the reaction that come from a multiport output - // of a contained reactor. Also, handle startup and shutdown triggers. - for (TriggerInstance trigger : reaction.triggers) { - if (trigger.isStartup()) { - temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &"+reactionRef+";"); - startupReactionCount += reactor.getTotalWidth(); - foundOne = true; - } else if (trigger.isShutdown()) { - temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &"+reactionRef+";"); - foundOne = true; - shutdownReactionCount += reactor.getTotalWidth(); - - if (targetConfig.tracing != null) { - var description = CUtil.getShortenedName(reactor); - var reactorRef = CUtil.reactorRef(reactor); - temp.pr(String.join("\n", - "_lf_register_trace_event("+reactorRef+", &("+reactorRef+"->_lf__shutdown),", - "trace_trigger, "+addDoubleQuotes(description+".shutdown")+");" - )); - } - } else if (trigger.isReset()) { - temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &"+reactionRef+";"); - resetReactionCount += reactor.getTotalWidth(); - foundOne = true; - } - } - if (foundOne) initializeTriggerObjects.pr(temp.toString()); + getTarget().requiresTypes)); + } + + /** + * Record startup, shutdown, and reset reactions. + * + * @param instance A reactor instance. + */ + private void recordBuiltinTriggers(ReactorInstance instance) { + // For each reaction instance, allocate the arrays that will be used to + // trigger downstream reactions. + for (ReactionInstance reaction : instance.reactions) { + var reactor = reaction.getParent(); + var temp = new CodeBuilder(); + var foundOne = false; + + var reactionRef = CUtil.reactionRef(reaction); + + // Next handle triggers of the reaction that come from a multiport output + // of a contained reactor. Also, handle startup and shutdown triggers. + for (TriggerInstance trigger : reaction.triggers) { + if (trigger.isStartup()) { + temp.pr("_lf_startup_reactions[_lf_startup_reactions_count++] = &" + reactionRef + ";"); + startupReactionCount += reactor.getTotalWidth(); + foundOne = true; + } else if (trigger.isShutdown()) { + temp.pr("_lf_shutdown_reactions[_lf_shutdown_reactions_count++] = &" + reactionRef + ";"); + foundOne = true; + shutdownReactionCount += reactor.getTotalWidth(); + + if (targetConfig.tracing != null) { + var description = CUtil.getShortenedName(reactor); + var reactorRef = CUtil.reactorRef(reactor); + temp.pr( + String.join( + "\n", + "_lf_register_trace_event(" + + reactorRef + + ", &(" + + reactorRef + + "->_lf__shutdown),", + "trace_trigger, " + addDoubleQuotes(description + ".shutdown") + ");")); + } + } else if (trigger.isReset()) { + temp.pr("_lf_reset_reactions[_lf_reset_reactions_count++] = &" + reactionRef + ";"); + resetReactionCount += reactor.getTotalWidth(); + foundOne = true; } + } + if (foundOne) initializeTriggerObjects.pr(temp.toString()); } - - /** - * Generate code to set up the tables used in _lf_start_time_step to decrement reference - * counts and mark outputs absent between time steps. This function puts the code - * into startTimeStep. - */ - private void generateStartTimeStep(ReactorInstance instance) { - // Avoid generating dead code if nothing is relevant. - var foundOne = false; - var temp = new CodeBuilder(); - var containerSelfStructName = CUtil.reactorRef(instance); - - // Handle inputs that get sent data from a reaction rather than from - // another contained reactor and reactions that are triggered by an - // output of a contained reactor. - // Note that there may be more than one reaction reacting to the same - // port so we have to avoid listing the port more than once. - var portsSeen = new LinkedHashSet(); - for (ReactionInstance reaction : instance.reactions) { - for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { - if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { - portsSeen.add(port); - // This reaction is sending to an input. Must be - // the input of a contained reactor in the federate. - // NOTE: If instance == main and the federate is within a bank, - // this assumes that the reaction writes only to the bank member in the federate. - foundOne = true; - - temp.pr("// Add port "+port.getFullName()+" to array of is_present fields."); - - if (!instance.equals(port.getParent())) { - // The port belongs to contained reactor, so we also have - // iterate over the instance bank members. - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(instance); - temp.startScopedBankChannelIteration(port, null); - } else { - temp.startScopedBankChannelIteration(port, "count"); - } - var portRef = CUtil.portRefNested(port); - var con = (port.isMultiport()) ? "->" : "."; - - temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"is_present;"); - // Intended_tag is only applicable to ports in federated execution. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+portRef+con+"intended_tag;" - ) - ); - - startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); - - if (!instance.equals(port.getParent())) { - temp.pr("count++;"); - temp.endScopedBlock(); - temp.endScopedBlock(); - temp.endScopedBankChannelIteration(port, null); - } else { - temp.endScopedBankChannelIteration(port, "count"); - } - } - } + } + + /** + * Generate code to set up the tables used in _lf_start_time_step to decrement reference counts + * and mark outputs absent between time steps. This function puts the code into startTimeStep. + */ + private void generateStartTimeStep(ReactorInstance instance) { + // Avoid generating dead code if nothing is relevant. + var foundOne = false; + var temp = new CodeBuilder(); + var containerSelfStructName = CUtil.reactorRef(instance); + + // Handle inputs that get sent data from a reaction rather than from + // another contained reactor and reactions that are triggered by an + // output of a contained reactor. + // Note that there may be more than one reaction reacting to the same + // port so we have to avoid listing the port more than once. + var portsSeen = new LinkedHashSet(); + for (ReactionInstance reaction : instance.reactions) { + for (PortInstance port : Iterables.filter(reaction.effects, PortInstance.class)) { + if (port.getDefinition() instanceof Input && !portsSeen.contains(port)) { + portsSeen.add(port); + // This reaction is sending to an input. Must be + // the input of a contained reactor in the federate. + // NOTE: If instance == main and the federate is within a bank, + // this assumes that the reaction writes only to the bank member in the federate. + foundOne = true; + + temp.pr("// Add port " + port.getFullName() + " to array of is_present fields."); + + if (!instance.equals(port.getParent())) { + // The port belongs to contained reactor, so we also have + // iterate over the instance bank members. + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(instance); + temp.startScopedBankChannelIteration(port, null); + } else { + temp.startScopedBankChannelIteration(port, "count"); + } + var portRef = CUtil.portRefNested(port); + var con = (port.isMultiport()) ? "->" : "."; + + temp.pr( + "_lf_is_present_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + portRef + + con + + "is_present;"); + // Intended_tag is only applicable to ports in federated execution. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + portRef + + con + + "intended_tag;")); + + startTimeStepIsPresentCount += port.getWidth() * port.getParent().getTotalWidth(); + + if (!instance.equals(port.getParent())) { + temp.pr("count++;"); + temp.endScopedBlock(); + temp.endScopedBlock(); + temp.endScopedBankChannelIteration(port, null); + } else { + temp.endScopedBankChannelIteration(port, "count"); + } } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; + } + } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; + + for (ActionInstance action : instance.actions) { + foundOne = true; + temp.startScopedBlock(instance); + + temp.pr( + String.join( + "\n", + "// Add action " + action.getFullName() + " to array of is_present fields.", + "_lf_is_present_fields[" + startTimeStepIsPresentCount + "] ", + " = &" + + containerSelfStructName + + "->_lf_" + + action.getName() + + ".is_present;")); + + // Intended_tag is only applicable to actions in federated execution with decentralized + // coordination. + temp.pr( + CExtensionUtils.surroundWithIfFederatedDecentralized( + String.join( + "\n", + "// Add action " + action.getFullName() + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + startTimeStepIsPresentCount + "] ", + " = &" + + containerSelfStructName + + "->_lf_" + + action.getName() + + ".intended_tag;"))); + + startTimeStepIsPresentCount += action.getParent().getTotalWidth(); + temp.endScopedBlock(); + } + if (foundOne) startTimeStep.pr(temp.toString()); + temp = new CodeBuilder(); + foundOne = false; - for (ActionInstance action : instance.actions) { - foundOne = true; - temp.startScopedBlock(instance); + // Next, set up the table to mark each output of each contained reactor absent. + for (ReactorInstance child : instance.children) { + if (child.outputs.size() > 0) { - temp.pr(String.join("\n", - "// Add action "+action.getFullName()+" to array of is_present fields.", - "_lf_is_present_fields["+startTimeStepIsPresentCount+"] ", - " = &"+containerSelfStructName+"->_lf_"+action.getName()+".is_present;" - )); + temp.startScopedBlock(); + temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); + temp.startScopedBlock(child); - // Intended_tag is only applicable to actions in federated execution with decentralized coordination. + var channelCount = 0; + for (PortInstance output : child.outputs) { + if (!output.getDependsOnReactions().isEmpty()) { + foundOne = true; + temp.pr("// Add port " + output.getFullName() + " to array of is_present fields."); + temp.startChannelIteration(output); + temp.pr( + "_lf_is_present_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + CUtil.portRef(output) + + ".is_present;"); + + // Intended_tag is only applicable to ports in federated execution with decentralized + // coordination. temp.pr( CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join("\n", - "// Add action " + action.getFullName() - + " to array of intended_tag fields.", - "_lf_intended_tag_fields[" - + startTimeStepIsPresentCount + "] ", - " = &" + containerSelfStructName - + "->_lf_" + action.getName() - + ".intended_tag;" - ))); - - startTimeStepIsPresentCount += action.getParent().getTotalWidth(); - temp.endScopedBlock(); + String.join( + "\n", + "// Add port " + output.getFullName() + " to array of intended_tag fields.", + "_lf_intended_tag_fields[" + + startTimeStepIsPresentCount + + " + count] = &" + + CUtil.portRef(output) + + ".intended_tag;"))); + + temp.pr("count++;"); + channelCount += output.getWidth(); + temp.endChannelIteration(output); + } } - if (foundOne) startTimeStep.pr(temp.toString()); - temp = new CodeBuilder(); - foundOne = false; - - // Next, set up the table to mark each output of each contained reactor absent. - for (ReactorInstance child : instance.children) { - if (child.outputs.size() > 0) { - - temp.startScopedBlock(); - temp.pr("int count = 0; SUPPRESS_UNUSED_WARNING(count);"); - temp.startScopedBlock(child); - - var channelCount = 0; - for (PortInstance output : child.outputs) { - if (!output.getDependsOnReactions().isEmpty()){ - foundOne = true; - temp.pr("// Add port "+output.getFullName()+" to array of is_present fields."); - temp.startChannelIteration(output); - temp.pr("_lf_is_present_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".is_present;"); - - // Intended_tag is only applicable to ports in federated execution with decentralized coordination. - temp.pr( - CExtensionUtils.surroundWithIfFederatedDecentralized( - String.join("\n", - "// Add port "+output.getFullName()+" to array of intended_tag fields.", - "_lf_intended_tag_fields["+startTimeStepIsPresentCount+" + count] = &"+CUtil.portRef(output)+".intended_tag;" - ))); - - temp.pr("count++;"); - channelCount += output.getWidth(); - temp.endChannelIteration(output); - } - } - startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); - temp.endScopedBlock(); - temp.endScopedBlock(); - } - } - if (foundOne) startTimeStep.pr(temp.toString()); + startTimeStepIsPresentCount += channelCount * child.getTotalWidth(); + temp.endScopedBlock(); + temp.endScopedBlock(); + } } - - /** - * For each timer in the given reactor, generate initialization code for the offset - * and period fields. - * - * This method will also populate the global _lf_timer_triggers array, which is - * used to start all timers at the start of execution. - * - * @param instance A reactor instance. - */ - private void generateTimerInitializations(ReactorInstance instance) { - for (TimerInstance timer : instance.timers) { - if (!timer.isStartup()) { - initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); - timerCount += timer.getParent().getTotalWidth(); - } - } + if (foundOne) startTimeStep.pr(temp.toString()); + } + + /** + * For each timer in the given reactor, generate initialization code for the offset and period + * fields. + * + *

    This method will also populate the global _lf_timer_triggers array, which is used to start + * all timers at the start of execution. + * + * @param instance A reactor instance. + */ + private void generateTimerInitializations(ReactorInstance instance) { + for (TimerInstance timer : instance.timers) { + if (!timer.isStartup()) { + initializeTriggerObjects.pr(CTimerGenerator.generateInitializer(timer)); + timerCount += timer.getParent().getTotalWidth(); + } } - - /** - * Process a given .proto file. - * - * Run, if possible, the proto-c protocol buffer code generator to produce - * the required .h and .c files. - * @param filename Name of the file to process. - */ - public void processProtoFile(String filename) { - var protoc = commandFactory.createCommand( + } + + /** + * Process a given .proto file. + * + *

    Run, if possible, the proto-c protocol buffer code generator to produce the required .h and + * .c files. + * + * @param filename Name of the file to process. + */ + public void processProtoFile(String filename) { + var protoc = + commandFactory.createCommand( "protoc-c", - List.of("--c_out="+this.fileConfig.getSrcGenPath(), filename), + List.of("--c_out=" + this.fileConfig.getSrcGenPath(), filename), fileConfig.srcPath); - if (protoc == null) { - errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); - return; - } - var returnCode = protoc.run(); - if (returnCode == 0) { - var nameSansProto = filename.substring(0, filename.length() - 6); - targetConfig.compileAdditionalSources.add( - fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString() - ); - - targetConfig.compileLibraries.add("-l"); - targetConfig.compileLibraries.add("protobuf-c"); - targetConfig.compilerFlags.add("-lprotobuf-c"); - } else { - errorReporter.reportError("protoc-c returns error code " + returnCode); - } + if (protoc == null) { + errorReporter.reportError("Processing .proto files requires protoc-c >= 1.3.3."); + return; } - - /** - * Construct a unique type for the struct of the specified - * typed variable (port or action) of the specified reactor class. - * This is required to be the same as the type name returned by - * {@link #variableStructType(TriggerInstance)}. - */ - public static String variableStructType(Variable variable, Reactor reactor, boolean userFacing) { - return (userFacing ? reactor.getName().toLowerCase() : CUtil.getName(reactor)) +"_"+variable.getName()+"_t"; + var returnCode = protoc.run(); + if (returnCode == 0) { + var nameSansProto = filename.substring(0, filename.length() - 6); + targetConfig.compileAdditionalSources.add( + fileConfig.getSrcGenPath().resolve(nameSansProto + ".pb-c.c").toString()); + + targetConfig.compileLibraries.add("-l"); + targetConfig.compileLibraries.add("protobuf-c"); + targetConfig.compilerFlags.add("-lprotobuf-c"); + } else { + errorReporter.reportError("protoc-c returns error code " + returnCode); } - - /** - * Construct a unique type for the struct of the specified - * instance (port or action). - * This is required to be the same as the type name returned by - * {@link #variableStructType(Variable, Reactor, boolean)}. - * @param portOrAction The port or action instance. - * @return The name of the self struct. - */ - public static String variableStructType(TriggerInstance portOrAction) { - return CUtil.getName(portOrAction.getParent().reactorDefinition)+"_"+portOrAction.getName()+"_t"; + } + + /** + * Construct a unique type for the struct of the specified typed variable (port or action) of the + * specified reactor class. This is required to be the same as the type name returned by {@link + * #variableStructType(TriggerInstance)}. + */ + public static String variableStructType(Variable variable, Reactor reactor, boolean userFacing) { + return (userFacing ? reactor.getName().toLowerCase() : CUtil.getName(reactor)) + + "_" + + variable.getName() + + "_t"; + } + + /** + * Construct a unique type for the struct of the specified instance (port or action). This is + * required to be the same as the type name returned by {@link #variableStructType(Variable, + * Reactor, boolean)}. + * + * @param portOrAction The port or action instance. + * @return The name of the self struct. + */ + public static String variableStructType(TriggerInstance portOrAction) { + return CUtil.getName(portOrAction.getParent().reactorDefinition) + + "_" + + portOrAction.getName() + + "_t"; + } + + /** + * If tracing is turned on, then generate code that records the full name of the specified reactor + * instance in the trace table. If tracing is not turned on, do nothing. + * + * @param instance The reactor instance. + */ + private void generateTraceTableEntries(ReactorInstance instance) { + if (targetConfig.tracing != null) { + initializeTriggerObjects.pr(CTracingGenerator.generateTraceTableEntries(instance)); } - - /** - * If tracing is turned on, then generate code that records - * the full name of the specified reactor instance in the - * trace table. If tracing is not turned on, do nothing. - * @param instance The reactor instance. - */ - private void generateTraceTableEntries(ReactorInstance instance) { - if (targetConfig.tracing != null) { - initializeTriggerObjects.pr( - CTracingGenerator.generateTraceTableEntries(instance) - ); - } + } + + /** + * Generate code to instantiate the specified reactor instance and initialize it. + * + * @param instance A reactor instance. + */ + public void generateReactorInstance(ReactorInstance instance) { + var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); + var fullName = instance.getFullName(); + initializeTriggerObjects.pr( + "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); + // Generate the instance self struct containing parameters, state variables, + // and outputs (the "self" struct). + initializeTriggerObjects.pr( + CUtil.reactorRefName(instance) + + "[" + + CUtil.runtimeIndex(instance) + + "] = new_" + + CUtil.getName(reactorClass) + + "();"); + // Generate code to initialize the "self" struct in the + // _lf_initialize_trigger_objects function. + generateTraceTableEntries(instance); + generateReactorInstanceExtension(instance); + generateParameterInitialization(instance); + initializeOutputMultiports(instance); + initializeInputMultiports(instance); + recordBuiltinTriggers(instance); + watchdogCount += + CWatchdogGenerator.generateInitializeWatchdogs(initializeTriggerObjects, instance); + + // Next, initialize the "self" struct with state variables. + // These values may be expressions that refer to the parameter values defined above. + generateStateVariableInitializations(instance); + + // Generate trigger objects for the instance. + generateTimerInitializations(instance); + generateActionInitializations(instance); + generateInitializeActionToken(instance); + generateSetDeadline(instance); + generateModeStructure(instance); + + // Recursively generate code for the children. + for (ReactorInstance child : instance.children) { + // If this reactor is a placeholder for a bank of reactors, then generate + // an array of instances of reactors and create an enclosing for loop. + // Need to do this for each of the builders into which the code writes. + startTimeStep.startScopedBlock(child); + initializeTriggerObjects.startScopedBlock(child); + generateReactorInstance(child); + initializeTriggerObjects.endScopedBlock(); + startTimeStep.endScopedBlock(); } - /** - * Generate code to instantiate the specified reactor instance and - * initialize it. - * @param instance A reactor instance. - */ - public void generateReactorInstance(ReactorInstance instance) { - var reactorClass = ASTUtils.toDefinition(instance.getDefinition().getReactorClass()); - var fullName = instance.getFullName(); - initializeTriggerObjects.pr( - "// ***** Start initializing " + fullName + " of class " + reactorClass.getName()); - // Generate the instance self struct containing parameters, state variables, - // and outputs (the "self" struct). - initializeTriggerObjects.pr(CUtil.reactorRefName(instance)+"["+CUtil.runtimeIndex(instance)+"] = new_"+CUtil.getName(reactorClass)+"();"); - // Generate code to initialize the "self" struct in the - // _lf_initialize_trigger_objects function. - generateTraceTableEntries(instance); - generateReactorInstanceExtension(instance); - generateParameterInitialization(instance); - initializeOutputMultiports(instance); - initializeInputMultiports(instance); - recordBuiltinTriggers(instance); - watchdogCount += CWatchdogGenerator.generateInitializeWatchdogs(initializeTriggerObjects, instance); - - // Next, initialize the "self" struct with state variables. - // These values may be expressions that refer to the parameter values defined above. - generateStateVariableInitializations(instance); - - // Generate trigger objects for the instance. - generateTimerInitializations(instance); - generateActionInitializations(instance); - generateInitializeActionToken(instance); - generateSetDeadline(instance); - generateModeStructure(instance); - - // Recursively generate code for the children. - for (ReactorInstance child : instance.children) { - // If this reactor is a placeholder for a bank of reactors, then generate - // an array of instances of reactors and create an enclosing for loop. - // Need to do this for each of the builders into which the code writes. - startTimeStep.startScopedBlock(child); - initializeTriggerObjects.startScopedBlock(child); - generateReactorInstance(child); - initializeTriggerObjects.endScopedBlock(); - startTimeStep.endScopedBlock(); + // For this instance, define what must be done at the start of + // each time step. This sets up the tables that are used by the + // _lf_start_time_step() function in reactor_common.c. + // Note that this function is also run once at the end + // so that it can deallocate any memory. + generateStartTimeStep(instance); + initializeTriggerObjects.pr("//***** End initializing " + fullName); + } + + /** + * For each action of the specified reactor instance, generate initialization code for the offset + * and period fields. + * + * @param instance The reactor. + */ + private void generateActionInitializations(ReactorInstance instance) { + initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + } + + /** + * Initialize actions by creating a lf_token_t in the self struct. This has the information + * required to allocate memory for the action payload. Skip any action that is not actually used + * as a trigger. + * + * @param reactor The reactor containing the actions. + */ + private void generateInitializeActionToken(ReactorInstance reactor) { + for (ActionInstance action : reactor.actions) { + // Skip this step if the action is not in use. + if (action.getParent().getTriggers().contains(action)) { + var type = getInferredType(action.getDefinition()); + var payloadSize = "0"; + if (!type.isUndefined()) { + var typeStr = types.getTargetType(type); + if (CUtil.isTokenType(type, types)) { + typeStr = CUtil.rootType(typeStr); + } + if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { + payloadSize = "sizeof(" + typeStr + ")"; + } } - // For this instance, define what must be done at the start of - // each time step. This sets up the tables that are used by the - // _lf_start_time_step() function in reactor_common.c. - // Note that this function is also run once at the end - // so that it can deallocate any memory. - generateStartTimeStep(instance); - initializeTriggerObjects.pr("//***** End initializing " + fullName); - } - - /** - * For each action of the specified reactor instance, generate initialization code - * for the offset and period fields. - * @param instance The reactor. - */ - private void generateActionInitializations(ReactorInstance instance) { - initializeTriggerObjects.pr(CActionGenerator.generateInitializers(instance)); + var selfStruct = CUtil.reactorRef(action.getParent()); + initializeTriggerObjects.pr( + CActionGenerator.generateTokenInitializer(selfStruct, action.getName(), payloadSize)); + } } - - /** - * Initialize actions by creating a lf_token_t in the self struct. - * This has the information required to allocate memory for the action payload. - * Skip any action that is not actually used as a trigger. - * @param reactor The reactor containing the actions. - */ - private void generateInitializeActionToken(ReactorInstance reactor) { - for (ActionInstance action : reactor.actions) { - // Skip this step if the action is not in use. - if (action.getParent().getTriggers().contains(action) - ) { - var type = getInferredType(action.getDefinition()); - var payloadSize = "0"; - if (!type.isUndefined()) { - var typeStr = types.getTargetType(type); - if (CUtil.isTokenType(type, types)) { - typeStr = CUtil.rootType(typeStr); - } - if (typeStr != null && !typeStr.equals("") && !typeStr.equals("void")) { - payloadSize = "sizeof("+typeStr+")"; - } - } - - var selfStruct = CUtil.reactorRef(action.getParent()); - initializeTriggerObjects.pr( - CActionGenerator.generateTokenInitializer( - selfStruct, action.getName(), payloadSize - ) - ); - } + } + + /** + * Generate code that is executed while the reactor instance is being initialized. This is + * provided as an extension point for subclasses. Normally, the reactions argument is the full + * list of reactions, but for the top-level of a federate, will be a subset of reactions that is + * relevant to the federate. + * + * @param instance The reactor instance. + */ + protected void generateReactorInstanceExtension(ReactorInstance instance) { + // Do nothing + } + + /** + * Generate code that initializes the state variables for a given instance. Unlike parameters, + * state variables are uniformly initialized for all instances of the same reactor. + * + * @param instance The reactor class instance + */ + protected void generateStateVariableInitializations(ReactorInstance instance) { + var reactorClass = instance.getDefinition().getReactorClass(); + var selfRef = CUtil.reactorRef(instance); + for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { + if (isInitialized(stateVar)) { + var mode = + stateVar.eContainer() instanceof Mode + ? instance.lookupModeInstance((Mode) stateVar.eContainer()) + : instance.getMode(false); + initializeTriggerObjects.pr( + CStateGenerator.generateInitializer(instance, selfRef, stateVar, mode, types)); + if (mode != null && stateVar.isReset()) { + modalStateResetCount += instance.getTotalWidth(); } + } } - - /** - * Generate code that is executed while the reactor instance is being initialized. - * This is provided as an extension point for subclasses. - * Normally, the reactions argument is the full list of reactions, - * but for the top-level of a federate, will be a subset of reactions that - * is relevant to the federate. - * @param instance The reactor instance. - */ - protected void generateReactorInstanceExtension(ReactorInstance instance) { - // Do nothing - } - - /** - * Generate code that initializes the state variables for a given instance. - * Unlike parameters, state variables are uniformly initialized for all instances - * of the same reactor. - * @param instance The reactor class instance - */ - protected void generateStateVariableInitializations(ReactorInstance instance) { - var reactorClass = instance.getDefinition().getReactorClass(); - var selfRef = CUtil.reactorRef(instance); - for (StateVar stateVar : allStateVars(toDefinition(reactorClass))) { - if (isInitialized(stateVar)) { - var mode = stateVar.eContainer() instanceof Mode ? - instance.lookupModeInstance((Mode) stateVar.eContainer()) : - instance.getMode(false); - initializeTriggerObjects.pr(CStateGenerator.generateInitializer( - instance, - selfRef, - stateVar, - mode, - types - )); - if (mode != null && stateVar.isReset()) { - modalStateResetCount += instance.getTotalWidth(); - } - } - } + } + + /** + * Generate code to set the deadline field of the reactions in the specified reactor instance. + * + * @param instance The reactor instance. + */ + private void generateSetDeadline(ReactorInstance instance) { + for (ReactionInstance reaction : instance.reactions) { + var selfRef = CUtil.reactorRef(reaction.getParent()) + "->_lf__reaction_" + reaction.index; + if (reaction.declaredDeadline != null) { + var deadline = reaction.declaredDeadline.maxDelay; + initializeTriggerObjects.pr( + selfRef + ".deadline = " + types.getTargetTimeExpr(deadline) + ";"); + } else { // No deadline. + initializeTriggerObjects.pr(selfRef + ".deadline = NEVER;"); + } } - - /** - * Generate code to set the deadline field of the reactions in the - * specified reactor instance. - * @param instance The reactor instance. - */ - private void generateSetDeadline(ReactorInstance instance) { - for (ReactionInstance reaction : instance.reactions) { - var selfRef = CUtil.reactorRef(reaction.getParent())+"->_lf__reaction_"+reaction.index; - if (reaction.declaredDeadline != null) { - var deadline = reaction.declaredDeadline.maxDelay; - initializeTriggerObjects.pr(selfRef+".deadline = "+types.getTargetTimeExpr(deadline)+";"); - } else { // No deadline. - initializeTriggerObjects.pr(selfRef+".deadline = NEVER;"); - } - } + } + + /** + * Generate code to initialize modes. + * + * @param instance The reactor instance. + */ + private void generateModeStructure(ReactorInstance instance) { + CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); + if (!instance.modes.isEmpty()) { + modalReactorCount += instance.getTotalWidth(); } - - /** - * Generate code to initialize modes. - * @param instance The reactor instance. - */ - private void generateModeStructure(ReactorInstance instance) { - CModesGenerator.generateModeStructure(instance, initializeTriggerObjects); - if (!instance.modes.isEmpty()) { - modalReactorCount += instance.getTotalWidth(); - } + } + + /** + * Generate runtime initialization code for parameters of a given reactor instance + * + * @param instance The reactor instance. + */ + protected void generateParameterInitialization(ReactorInstance instance) { + var selfRef = CUtil.reactorRef(instance); + // Set the local bank_index variable so that initializers can use it. + initializeTriggerObjects.pr( + "bank_index = " + + CUtil.bankIndex(instance) + + ";" + + " SUPPRESS_UNUSED_WARNING(bank_index);"); + for (ParameterInstance parameter : instance.parameters) { + // NOTE: we now use the resolved literal value. For better efficiency, we could + // store constants in a global array and refer to its elements to avoid duplicate + // memory allocations. + // NOTE: If the parameter is initialized with a static initializer for an array + // or struct (the initialization expression is surrounded by { ... }), then we + // have to declare a static variable to ensure that the memory is put in data space + // and not on the stack. + // FIXME: Is there a better way to determine this than the string comparison? + var initializer = CParameterGenerator.getInitializer(parameter); + if (initializer.startsWith("{")) { + var temporaryVariableName = parameter.uniqueID(); + initializeTriggerObjects.pr( + String.join( + "\n", + "static " + + types.getVariableDeclaration(parameter.type, temporaryVariableName, true) + + " = " + + initializer + + ";", + selfRef + "->" + parameter.getName() + " = " + temporaryVariableName + ";")); + } else { + initializeTriggerObjects.pr( + selfRef + "->" + parameter.getName() + " = " + initializer + ";"); + } } - - /** - * Generate runtime initialization code for parameters of a given reactor instance - * @param instance The reactor instance. - */ - protected void generateParameterInitialization(ReactorInstance instance) { - var selfRef = CUtil.reactorRef(instance); - // Set the local bank_index variable so that initializers can use it. - initializeTriggerObjects.pr("bank_index = "+CUtil.bankIndex(instance)+";" - + " SUPPRESS_UNUSED_WARNING(bank_index);"); - for (ParameterInstance parameter : instance.parameters) { - // NOTE: we now use the resolved literal value. For better efficiency, we could - // store constants in a global array and refer to its elements to avoid duplicate - // memory allocations. - // NOTE: If the parameter is initialized with a static initializer for an array - // or struct (the initialization expression is surrounded by { ... }), then we - // have to declare a static variable to ensure that the memory is put in data space - // and not on the stack. - // FIXME: Is there a better way to determine this than the string comparison? - var initializer = CParameterGenerator.getInitializer(parameter); - if (initializer.startsWith("{")) { - var temporaryVariableName = parameter.uniqueID(); - initializeTriggerObjects.pr(String.join("\n", - "static "+types.getVariableDeclaration(parameter.type, temporaryVariableName, true)+" = "+initializer+";", - selfRef+"->"+parameter.getName()+" = "+temporaryVariableName+";" - )); - } else { - initializeTriggerObjects.pr(selfRef+"->"+parameter.getName()+" = "+initializer+";"); - } - } + } + + /** + * Generate code that mallocs memory for any output multiports. + * + * @param reactor The reactor instance. + */ + private void initializeOutputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance output : reactor.outputs) { + initializeTriggerObjects.pr( + CPortGenerator.initializeOutputMultiport(output, reactorSelfStruct)); } - - /** - * Generate code that mallocs memory for any output multiports. - * @param reactor The reactor instance. - */ - private void initializeOutputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance output : reactor.outputs) { - initializeTriggerObjects.pr(CPortGenerator.initializeOutputMultiport( - output, - reactorSelfStruct - )); - } + } + + /** + * Allocate memory for inputs. + * + * @param reactor The reactor. + */ + private void initializeInputMultiports(ReactorInstance reactor) { + var reactorSelfStruct = CUtil.reactorRef(reactor); + for (PortInstance input : reactor.inputs) { + initializeTriggerObjects.pr( + CPortGenerator.initializeInputMultiport(input, reactorSelfStruct)); } - - /** - * Allocate memory for inputs. - * @param reactor The reactor. - */ - private void initializeInputMultiports(ReactorInstance reactor) { - var reactorSelfStruct = CUtil.reactorRef(reactor); - for (PortInstance input : reactor.inputs) { - initializeTriggerObjects.pr(CPortGenerator.initializeInputMultiport( - input, - reactorSelfStruct - )); - } + } + + @Override + public TargetTypes getTargetTypes() { + return types; + } + + /** + * Get the Docker generator. + * + * @param context + * @return + */ + protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { + return new CDockerGenerator(context); + } + + // ////////////////////////////////////////// + // // Protected methods. + + // Perform set up that does not generate code + protected void setUpGeneralParameters() { + accommodatePhysicalActionsIfPresent(); + targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); + targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); + // Create the main reactor instance if there is a main reactor. + createMainReactorInstance(); + if (hasModalReactors) { + // So that each separate compile knows about modal reactors, do this: + targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); } - - @Override - public TargetTypes getTargetTypes() { - return types; + if (targetConfig.threading + && targetConfig.platformOptions.platform == Platform.ARDUINO + && (targetConfig.platformOptions.board == null + || !targetConfig.platformOptions.board.contains("mbed"))) { + // non-MBED boards should not use threading + System.out.println( + "Threading is incompatible on your current Arduino flavor. Setting threading to false."); + targetConfig.threading = false; } - /** - * Get the Docker generator. - * @param context - * @return - */ - protected DockerGenerator getDockerGenerator(LFGeneratorContext context) { - return new CDockerGenerator(context); + if (targetConfig.platformOptions.platform == Platform.ARDUINO + && !targetConfig.noCompile + && targetConfig.platformOptions.board == null) { + System.out.println( + "To enable compilation for the Arduino platform, you must specify the fully-qualified" + + " board name (FQBN) in the target property. For example, platform: {name: arduino," + + " board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target" + + " code only."); + targetConfig.noCompile = true; } - // ////////////////////////////////////////// - // // Protected methods. - - // Perform set up that does not generate code - protected void setUpGeneralParameters() { - accommodatePhysicalActionsIfPresent(); - targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + ""); - targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc()); - // Create the main reactor instance if there is a main reactor. - createMainReactorInstance(); - if (hasModalReactors) { - // So that each separate compile knows about modal reactors, do this: - targetConfig.compileDefinitions.put("MODAL_REACTORS", "TRUE"); - } - if (targetConfig.threading && targetConfig.platformOptions.platform == Platform.ARDUINO - && (targetConfig.platformOptions.board == null || !targetConfig.platformOptions.board.contains("mbed"))) { - //non-MBED boards should not use threading - System.out.println("Threading is incompatible on your current Arduino flavor. Setting threading to false."); - targetConfig.threading = false; - } - - if (targetConfig.platformOptions.platform == Platform.ARDUINO && !targetConfig.noCompile - && targetConfig.platformOptions.board == null) { - System.out.println("To enable compilation for the Arduino platform, you must specify the fully-qualified board name (FQBN) in the target property. For example, platform: {name: arduino, board: arduino:avr:leonardo}. Entering \"no-compile\" mode and generating target code only."); - targetConfig.noCompile = true; - } - - if (targetConfig.platformOptions.platform == Platform.ZEPHYR && targetConfig.threading - && targetConfig.platformOptions.userThreads >= 0) { - targetConfig.compileDefinitions.put( - PlatformOption.USER_THREADS.name(), - String.valueOf(targetConfig.platformOptions.userThreads) - ); - } else if (targetConfig.platformOptions.userThreads > 0) { - errorReporter.reportWarning("Specifying user threads is only for threaded Lingua Franca on the Zephyr platform. This option will be ignored."); - } - - if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake - pickScheduler(); - // FIXME: this and pickScheduler should be combined. - targetConfig.compileDefinitions.put( - "SCHEDULER", - targetConfig.schedulerType.name() - ); - targetConfig.compileDefinitions.put( - "NUMBER_OF_WORKERS", - String.valueOf(targetConfig.workers) - ); - } - pickCompilePlatform(); + if (targetConfig.platformOptions.platform == Platform.ZEPHYR + && targetConfig.threading + && targetConfig.platformOptions.userThreads >= 0) { + targetConfig.compileDefinitions.put( + PlatformOption.USER_THREADS.name(), + String.valueOf(targetConfig.platformOptions.userThreads)); + } else if (targetConfig.platformOptions.userThreads > 0) { + errorReporter.reportWarning( + "Specifying user threads is only for threaded Lingua Franca on the Zephyr platform. This" + + " option will be ignored."); } - protected void handleProtoFiles() { - // Handle .proto files. - for (String file : targetConfig.protoFiles) { - this.processProtoFile(file); - } + if (targetConfig.threading) { // FIXME: This logic is duplicated in CMake + pickScheduler(); + // FIXME: this and pickScheduler should be combined. + targetConfig.compileDefinitions.put("SCHEDULER", targetConfig.schedulerType.name()); + targetConfig.compileDefinitions.put( + "NUMBER_OF_WORKERS", String.valueOf(targetConfig.workers)); } + pickCompilePlatform(); + } - /** - * Generate code that needs to appear at the top of the generated - * C file, such as #define and #include statements. - */ - public String generateDirectives() { - CodeBuilder code = new CodeBuilder(); - code.prComment("Code generated by the Lingua Franca compiler from:"); - code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); - code.pr(CPreambleGenerator.generateDefineDirectives( - targetConfig, - fileConfig.getSrcGenPath(), - hasModalReactors - )); - code.pr(CPreambleGenerator.generateIncludeStatements( - targetConfig, - CCppMode - )); - return code.toString(); + protected void handleProtoFiles() { + // Handle .proto files. + for (String file : targetConfig.protoFiles) { + this.processProtoFile(file); } - - /** - * Generate top-level preamble code. - */ - protected String generateTopLevelPreambles(Reactor reactor) { - CodeBuilder builder = new CodeBuilder(); - var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; - builder.pr("#ifndef " + guard); - builder.pr("#define " + guard); - // Reactors that are instantiated by the specified reactor need to have - // their file-level preambles included. This needs to also include file-level - // preambles of base classes of those reactors. - Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) - .flatMap(it -> ASTUtils.allFileLevelPreambles(it).stream()) - .collect(Collectors.toSet()) - .forEach(it -> builder.pr(toText(it.getCode()))); - for (String file : targetConfig.protoFiles) { - var dotIndex = file.lastIndexOf("."); - var rootFilename = file; - if (dotIndex > 0) { - rootFilename = file.substring(0, dotIndex); - } - code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); - builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); - } - builder.pr("#endif"); - return builder.toString(); + } + + /** + * Generate code that needs to appear at the top of the generated C file, such as #define and + * #include statements. + */ + public String generateDirectives() { + CodeBuilder code = new CodeBuilder(); + code.prComment("Code generated by the Lingua Franca compiler from:"); + code.prComment("file:/" + FileUtil.toUnixString(fileConfig.srcFile)); + code.pr( + CPreambleGenerator.generateDefineDirectives( + targetConfig, fileConfig.getSrcGenPath(), hasModalReactors)); + code.pr(CPreambleGenerator.generateIncludeStatements(targetConfig, CCppMode)); + return code.toString(); + } + + /** Generate top-level preamble code. */ + protected String generateTopLevelPreambles(Reactor reactor) { + CodeBuilder builder = new CodeBuilder(); + var guard = "TOP_LEVEL_PREAMBLE_" + reactor.eContainer().hashCode() + "_H"; + builder.pr("#ifndef " + guard); + builder.pr("#define " + guard); + // Reactors that are instantiated by the specified reactor need to have + // their file-level preambles included. This needs to also include file-level + // preambles of base classes of those reactors. + Stream.concat(Stream.of(reactor), ASTUtils.allNestedClasses(reactor)) + .flatMap(it -> ASTUtils.allFileLevelPreambles(it).stream()) + .collect(Collectors.toSet()) + .forEach(it -> builder.pr(toText(it.getCode()))); + for (String file : targetConfig.protoFiles) { + var dotIndex = file.lastIndexOf("."); + var rootFilename = file; + if (dotIndex > 0) { + rootFilename = file.substring(0, dotIndex); + } + code.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); + builder.pr("#include " + addDoubleQuotes(rootFilename + ".pb-c.h")); } - - protected boolean targetLanguageIsCpp() { - return CCppMode; + builder.pr("#endif"); + return builder.toString(); + } + + protected boolean targetLanguageIsCpp() { + return CCppMode; + } + + /** + * Given a line of text from the output of a compiler, return an instance of ErrorFileAndLine if + * the line is recognized as the first line of an error message. Otherwise, return null. + * + * @param line A line of output from a compiler or other external tool that might generate errors. + * @return If the line is recognized as the start of an error message, then return a class + * containing the path to the file on which the error occurred (or null if there is none), the + * line number (or the string "1" if there is none), the character position (or the string "0" + * if there is none), and the message (or an empty string if there is none). + */ + @Override + public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { + var matcher = compileErrorPattern.matcher(line); + if (matcher.find()) { + var result = new ErrorFileAndLine(); + result.filepath = matcher.group("path"); + result.line = matcher.group("line"); + result.character = matcher.group("column"); + result.message = matcher.group("message"); + + if (!result.message.toLowerCase().contains("error:")) { + result.isError = false; + } + return result; } - - /** Given a line of text from the output of a compiler, return - * an instance of ErrorFileAndLine if the line is recognized as - * the first line of an error message. Otherwise, return null. - * @param line A line of output from a compiler or other external - * tool that might generate errors. - * @return If the line is recognized as the start of an error message, - * then return a class containing the path to the file on which the - * error occurred (or null if there is none), the line number (or the - * string "1" if there is none), the character position (or the string - * "0" if there is none), and the message (or an empty string if there - * is none). - */ - @Override - public GeneratorBase.ErrorFileAndLine parseCommandOutput(String line) { - var matcher = compileErrorPattern.matcher(line); - if (matcher.find()) { - var result = new ErrorFileAndLine(); - result.filepath = matcher.group("path"); - result.line = matcher.group("line"); - result.character = matcher.group("column"); - result.message = matcher.group("message"); - - if (!result.message.toLowerCase().contains("error:")) { - result.isError = false; - } - return result; + return null; + } + + //////////////////////////////////////////// + //// Private methods. + + /** Returns the Target enum for this generator */ + @Override + public Target getTarget() { + return Target.C; + } + + //////////////////////////////////////////////////////////// + //// Private methods + + /** + * If a main or federated reactor has been declared, create a ReactorInstance for this top level. + * This will also assign levels to reactions, then, if the program is federated, perform an AST + * transformation to disconnect connections between federates. + */ + private void createMainReactorInstance() { + if (this.mainDef != null) { + if (this.main == null) { + // Recursively build instances. + this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); + var reactionInstanceGraph = this.main.assignLevels(); + if (reactionInstanceGraph.nodeCount() > 0) { + errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); + return; } - return null; - } - - //////////////////////////////////////////// - //// Private methods. - - /** Returns the Target enum for this generator */ - @Override - public Target getTarget() { - return Target.C; - } - - //////////////////////////////////////////////////////////// - //// Private methods - - /** - * If a main or federated reactor has been declared, create a ReactorInstance - * for this top level. This will also assign levels to reactions, then, - * if the program is federated, perform an AST transformation to disconnect - * connections between federates. - */ - private void createMainReactorInstance() { - if (this.mainDef != null) { - if (this.main == null) { - // Recursively build instances. - this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); - var reactionInstanceGraph = this.main.assignLevels(); - if (reactionInstanceGraph.nodeCount() > 0) { - errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); - return; - } - if (hasDeadlines) { - this.main.assignDeadlines(); - } - // Inform the run-time of the breadth/parallelism of the reaction graph - var breadth = reactionInstanceGraph.getBreadth(); - if (breadth == 0) { - errorReporter.reportWarning("The program has no reactions"); - } else { - targetConfig.compileDefinitions.put( - "LF_REACTION_GRAPH_BREADTH", - String.valueOf(reactionInstanceGraph.getBreadth()) - ); - } - } + if (hasDeadlines) { + this.main.assignDeadlines(); } - } - - /** - * Generate an array of self structs for the reactor - * and one for each of its children. - * @param r The reactor instance. - */ - private void generateSelfStructs(ReactorInstance r) { - initializeTriggerObjects.pr(CUtil.selfType(r)+"* "+CUtil.reactorRefName(r)+"["+r.getTotalWidth()+"];"); - initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING("+CUtil.reactorRefName(r)+");"); - for (ReactorInstance child : r.children) { - generateSelfStructs(child); + // Inform the run-time of the breadth/parallelism of the reaction graph + var breadth = reactionInstanceGraph.getBreadth(); + if (breadth == 0) { + errorReporter.reportWarning("The program has no reactions"); + } else { + targetConfig.compileDefinitions.put( + "LF_REACTION_GRAPH_BREADTH", String.valueOf(reactionInstanceGraph.getBreadth())); } + } + } + } + + /** + * Generate an array of self structs for the reactor and one for each of its children. + * + * @param r The reactor instance. + */ + private void generateSelfStructs(ReactorInstance r) { + initializeTriggerObjects.pr( + CUtil.selfType(r) + "* " + CUtil.reactorRefName(r) + "[" + r.getTotalWidth() + "];"); + initializeTriggerObjects.pr("SUPPRESS_UNUSED_WARNING(" + CUtil.reactorRefName(r) + ");"); + for (ReactorInstance child : r.children) { + generateSelfStructs(child); } + } } From a3a6d5b510556dcf69c4efc0599ab893501ce13d Mon Sep 17 00:00:00 2001 From: erlingrj Date: Tue, 23 May 2023 14:59:39 -0700 Subject: [PATCH 429/709] Add makeZephyrCompatible configurator --- org.lflang.tests/src/org/lflang/tests/Configurators.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/org.lflang.tests/src/org/lflang/tests/Configurators.java b/org.lflang.tests/src/org/lflang/tests/Configurators.java index 21cb85fb43..a5db8f2abf 100644 --- a/org.lflang.tests/src/org/lflang/tests/Configurators.java +++ b/org.lflang.tests/src/org/lflang/tests/Configurators.java @@ -72,6 +72,14 @@ public static boolean makeZephyrCompatibleUnthreaded(LFTest test) { test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; return true; } + + public static boolean makeZephyrCompatible(LFTest test) { + test.getContext().getArgs().setProperty("tracing", "false"); + test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; + test.getContext().getTargetConfig().platformOptions.flash = false; + test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; + return true; + } /** * Make no changes to the configuration. * From 24e581aeb66c3d3d3fc65905e908cc259389f5c4 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Tue, 23 May 2023 16:20:56 -0700 Subject: [PATCH 430/709] Run formatter --- test/C/src/zephyr/Timer.lf | 1 - test/C/src/zephyr/UserThreads.lf | 10 +++++----- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/test/C/src/zephyr/Timer.lf b/test/C/src/zephyr/Timer.lf index d3cb3f96de..a3dd0e68cc 100644 --- a/test/C/src/zephyr/Timer.lf +++ b/test/C/src/zephyr/Timer.lf @@ -3,7 +3,6 @@ target C { name: Zephyr, board: qemu_cortex_m3 }, - threading: false, timeout: 10 sec } diff --git a/test/C/src/zephyr/UserThreads.lf b/test/C/src/zephyr/UserThreads.lf index 744abb5748..115d8114a7 100644 --- a/test/C/src/zephyr/UserThreads.lf +++ b/test/C/src/zephyr/UserThreads.lf @@ -10,15 +10,15 @@ target C { } main reactor { - preamble {= + preamble {= + #include "platform.h" void func(void* arg) { lf_print("Hello from user thread"); - } + } - lf_thread_t thread_ids[3]; + lf_thread_t thread_ids[4]; =} - reaction(startup) {= int res; @@ -29,7 +29,7 @@ main reactor { } } - res = lf_thread_create(&thread_ids[i], &func, NULL); + res = lf_thread_create(&thread_ids[3], &func, NULL); if (res == 0) { lf_print_error_and_exit("Could create more threads than specified."); } else { From 6b09905194ae6d90c4145eef18e7cca37a751daf Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 16:51:17 -0700 Subject: [PATCH 431/709] Delete check (subsumed by spotlessCheck in CI). --- .../src/org/lflang/tests/compiler/RoundTripTests.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java b/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java index 8087d552a8..1beb54b81a 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java +++ b/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java @@ -5,7 +5,6 @@ import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.jupiter.api.Assertions.fail; -import java.nio.file.Files; import java.nio.file.Path; import org.eclipse.xtext.testing.InjectWith; import org.eclipse.xtext.testing.extensions.InjectionExtension; @@ -58,10 +57,5 @@ private void run(Path file) throws Exception { "The reformatted version of %s was not equivalent to the original file.%n" + "Formatted file:%n%s%n%n", file, squishedTestCase)); - final String normalTestCase = FormattingUtils.render(originalModel); - Assertions.assertEquals( - Files.readString(file).replaceAll("\\r\\n?", "\n"), - normalTestCase, - "File is not formatted properly, or formatter is bugged. Check " + file); } } From 9195543920fafaaca7a2ad00db36f4e5f1b59624 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 17:15:57 -0700 Subject: [PATCH 432/709] Rename spotlessCheck workflow. --- .github/workflows/check-format.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/check-format.yml b/.github/workflows/check-format.yml index e47bf5513c..8c022f90a5 100644 --- a/.github/workflows/check-format.yml +++ b/.github/workflows/check-format.yml @@ -1,4 +1,4 @@ -name: Check if all files are formatted correctly with spotless +name: Spotless check on: workflow_call: From e40d53f68aa3e8f655b774e41f1c36889612de7e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 00:01:15 -0700 Subject: [PATCH 433/709] Refactor a bit. Also, undo a stray edit from earlier commit. --- .github/workflows/cancel.yml | 2 +- org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java | 2 +- org.lflang/src/org/lflang/generator/CodeMap.java | 4 ++++ .../src/org/lflang/generator/python/PythonValidator.java | 2 +- test/Python/src/ImportComposition.lf | 1 - .../federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf | 1 - test/Python/src/target/AfterNoTypes.lf | 1 - 7 files changed, 7 insertions(+), 6 deletions(-) diff --git a/.github/workflows/cancel.yml b/.github/workflows/cancel.yml index 00733bb5b8..49765257c9 100644 --- a/.github/workflows/cancel.yml +++ b/.github/workflows/cancel.yml @@ -2,7 +2,7 @@ name: Cancel previous jobs on: workflow_call: - + jobs: cancel: name: run diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java b/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java index 9ccc3d408d..fe52d6016c 100644 --- a/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java +++ b/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java @@ -92,7 +92,7 @@ void typescriptValidationTest() throws IOException { */ private void targetLanguageValidationTest(Target target, ErrorInserter.Builder builder) throws IOException { - long seed = 2290053266328212836L;//new Random().nextLong(); + long seed = new Random().nextLong(); System.out.printf( "Running validation tests for %s with random seed %d.%n", target.getDisplayName(), seed); Random random = new Random(seed); diff --git a/org.lflang/src/org/lflang/generator/CodeMap.java b/org.lflang/src/org/lflang/generator/CodeMap.java index 9d196c7daa..7e5e603510 100644 --- a/org.lflang/src/org/lflang/generator/CodeMap.java +++ b/org.lflang/src/org/lflang/generator/CodeMap.java @@ -274,6 +274,10 @@ public Range adjusted(Path lfFile, Range generatedFileRange) { return start.compareTo(end) <= 0 ? new Range(start, end) : new Range(start, start); } + public int firstNonWhitespace(int line) { + return getGeneratedCode().lines().skip(line - 1).findFirst().orElse("").lastIndexOf(" ") + 1; + } + /* ------------------------- PRIVATE METHODS ------------------------- */ private CodeMap( diff --git a/org.lflang/src/org/lflang/generator/python/PythonValidator.java b/org.lflang/src/org/lflang/generator/python/PythonValidator.java index 12da60fd39..37893d270b 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonValidator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonValidator.java @@ -271,7 +271,7 @@ private void tryReportAlternative(String[] lines, int i) { lfFile, DiagnosticSeverity.Error, main.group().replace("*** ", "").replace("Sorry: ", ""), - map.adjusted(lfFile, Position.fromOneBased(line, map.getGeneratedCode().lines().skip(line - 1).findFirst().orElse("").lastIndexOf(" ") + 1)).getOneBasedLine()); + map.adjusted(lfFile, Position.fromOneBased(line, map.firstNonWhitespace(line))).getOneBasedLine()); } } } diff --git a/test/Python/src/ImportComposition.lf b/test/Python/src/ImportComposition.lf index 08906537f3..5558db6163 100644 --- a/test/Python/src/ImportComposition.lf +++ b/test/Python/src/ImportComposition.lf @@ -10,7 +10,6 @@ main reactor ImportComposition { reaction(startup) -> a.x {= a.x.set(42) =} reaction(a.y) {= - +++++; receive_time = lf.time.logical_elapsed() print("Received {:d} at time {:d}".format(a.y.value, receive_time)) self.received = True diff --git a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf index 2dc3bcfb34..15069f0aea 100644 --- a/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf +++ b/test/Python/src/federated/DecentralizedP2PUnbalancedTimeoutPhysical.lf @@ -30,7 +30,6 @@ reactor Destination { state s = 1 reaction(x) {= - +++++; if x.value != self.s: self.sys.stderr.write("Expected {} and got {}.".format(self.s, x.value)) self.sys.exit(1) diff --git a/test/Python/src/target/AfterNoTypes.lf b/test/Python/src/target/AfterNoTypes.lf index bc7e810030..ef92444c34 100644 --- a/test/Python/src/target/AfterNoTypes.lf +++ b/test/Python/src/target/AfterNoTypes.lf @@ -19,7 +19,6 @@ reactor Print { reaction(x) {= self.received+=1 - +++++; elapsed_time = lf.time.logical_elapsed() print("Result is " + str(x.value)) if x.value != 84: From ceb9b7e3bea980c1aeb8d128666425d72592e7a7 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 23 May 2023 17:29:50 -0700 Subject: [PATCH 434/709] Update ci.yml --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ca6573968c..dc9832cf35 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -31,7 +31,7 @@ jobs: needs: cancel check-format: - uses: lf-lang/lingua-franca/.github/workflows/check-format.yml@ci-check-formatting + uses: lf-lang/lingua-franca/.github/workflows/check-format.yml@master needs: cancel # Run the unit tests. From f90dd83dc1bd8c542d82a2030e6b0072756bea28 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 20:27:57 -0700 Subject: [PATCH 435/709] Format. --- .../src/org/lflang/generator/python/PythonValidator.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/python/PythonValidator.java b/org.lflang/src/org/lflang/generator/python/PythonValidator.java index 37893d270b..7d040bace0 100644 --- a/org.lflang/src/org/lflang/generator/python/PythonValidator.java +++ b/org.lflang/src/org/lflang/generator/python/PythonValidator.java @@ -271,7 +271,9 @@ private void tryReportAlternative(String[] lines, int i) { lfFile, DiagnosticSeverity.Error, main.group().replace("*** ", "").replace("Sorry: ", ""), - map.adjusted(lfFile, Position.fromOneBased(line, map.firstNonWhitespace(line))).getOneBasedLine()); + map.adjusted( + lfFile, Position.fromOneBased(line, map.firstNonWhitespace(line))) + .getOneBasedLine()); } } } From daa1467728abf028ad53d484ac2d9592b44d08da Mon Sep 17 00:00:00 2001 From: Kagamihara Nadeshiko Date: Tue, 23 May 2023 20:43:52 -0700 Subject: [PATCH 436/709] Optimise gradle by applying intellij recommendations @petervdonovan mentioned that build time is slow with gradle and most of the time spent is related not to building/execution but initialisation and configuration. While I didn't find a profiler that tells me what exactly causes the long configuration time, it does appear that some time-consuming configurations were carried out regardless of whether or not they are needed (i.e. same time is needed for `buildAll` and `help`). This commit applied some of the optimations suggested by IntelliJ that prevents unnecessary configurations from running, and drastically improved the configuration time for `buildAll` locally. --- build.gradle | 4 +- org.lflang/build.gradle | 116 ++++++++++++++++++++-------------------- 2 files changed, 60 insertions(+), 60 deletions(-) diff --git a/build.gradle b/build.gradle index 348949c01e..563377e3d3 100644 --- a/build.gradle +++ b/build.gradle @@ -57,7 +57,7 @@ subprojects { sourceCompatibility = JavaVersion.VERSION_17 targetCompatibility = JavaVersion.VERSION_17 - configurations.all { + configurations.configureEach { exclude group: 'asm' } @@ -115,4 +115,4 @@ spotless { formatAnnotations() } } -tasks.withType(SpotlessTask) { it.dependsOn(":org.lflang:jarCliTools") } +tasks.withType(SpotlessTask).configureEach { it.dependsOn(":org.lflang:jarCliTools") } diff --git a/org.lflang/build.gradle b/org.lflang/build.gradle index 5155c0a6e2..8d4f6a41c9 100644 --- a/org.lflang/build.gradle +++ b/org.lflang/build.gradle @@ -42,7 +42,7 @@ dependencies { mwe2 "org.eclipse.xtext:org.eclipse.xtext.xtext.generator:${xtextVersion}" } -task generateXtextLanguage(type: JavaExec) { +tasks.register('generateXtextLanguage', JavaExec) { main = 'org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher' classpath = configurations.mwe2 inputs.file "src/org/lflang/GenerateLinguaFranca.mwe2" @@ -90,10 +90,10 @@ configurations { } } -task getSubmoduleVersions(type: Exec) { +tasks.register('getSubmoduleVersions', Exec) { description('Run a Git command to get the current status of submodules') workingDir project.rootDir - // This will make gradle execute git submodule status every time updateRustRuntime is called + // This will make gradle execute git submodule status every time updateRustRuntime is called outputs.upToDateWhen { false } def command = "git submodule status" @@ -119,7 +119,7 @@ task getSubmoduleVersions(type: Exec) { } } -task updateRustRuntime { +tasks.register('updateRustRuntime') { description('Record the VCS revisions of the language runtimes into a properties file available at runtime.') dependsOn getSubmoduleVersions @@ -138,7 +138,7 @@ task updateRustRuntime { sourceSets.main.output.dir tasks.updateRustRuntime.outputFile, builtBy: updateRustRuntime tasks.processResources.dependsOn(updateRustRuntime) -task checkRuntimeVersionFileUpToDate { +tasks.register('checkRuntimeVersionFileUpToDate') { description('Check that the runtime version recorded in the built Jar for LFC matches the version of the checked out submodule') dependsOn getSubmoduleVersions inputs.file updateRustRuntime.outputFile @@ -168,13 +168,13 @@ task checkRuntimeVersionFileUpToDate { apply plugin: 'application' apply plugin: 'com.github.johnrengelman.shadow' -task buildAll() { +tasks.register('buildAll') { apply plugin: 'application' apply plugin: 'com.github.johnrengelman.shadow' mainClassName = 'org.lflang.cli.Lfc' } -task jarCliTools(type: ShadowJar) { +tasks.register('jarCliTools', ShadowJar) { manifest { attributes('Main-Class': 'org.lflang.cli.Lfc') } @@ -186,7 +186,7 @@ task jarCliTools(type: ShadowJar) { // the classes manually, minimize does not see the dependency. While we can add an exclude // rule, this does not seem to work very well and causes problems when compiling for a // second time. Also see https://github.com/lf-lang/lingua-franca/pull/1285 - transform(com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer){ + transform(com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer) { resource = 'plugin.properties' } from sourceSets.main.output @@ -200,7 +200,7 @@ buildAll.finalizedBy jarCliTools // to escape cli flags which start with --.For instance --args ' --help'. // Otherwise they're parsed as arguments to the Gradle CLI, not lfc. -task runLfc(type: JavaExec) { +tasks.register('runLfc', JavaExec) { // builds and runs lfc description = "Build and run lfc, use --args to pass arguments" group = "application" @@ -209,7 +209,7 @@ task runLfc(type: JavaExec) { workingDir = '..' } -task runLff(type: JavaExec) { +tasks.register('runLff', JavaExec) { // builds and runs lff description = "Build and run lff, use --args to pass arguments" group = "application" @@ -218,75 +218,75 @@ task runLff(type: JavaExec) { workingDir = '..' } -task generateLanguageDiagramServer { - description 'Creates a jar that implements a language server with diagram support for LF.' +tasks.register('generateLanguageDiagramServer') { + description 'Creates a jar that implements a language server with diagram support for LF.' apply plugin: 'java' apply plugin: 'application' apply plugin: 'com.github.johnrengelman.shadow' mainClassName = "org.lflang.diagram.lsp.LanguageDiagramServer" - + compileJava { options.compilerArgs << '-Xlint:unchecked' } shadowJar { archiveClassifier = 'lds' - + // Handling of service loader registrations via META-INF/services/* mergeServiceFiles() // Merge properties - transform(com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer){ + transform(com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer) { resource = 'plugin.properties' } // Exclude files that are known to be dispensable for a language server exclude( - '*._trace', - '*.ecore', - '*.ecorediag', - '*.g', - '*.genmodel', - '*.html', - '*.mwe2', - '*.profile', - '*.xtext', - '*readme.txt', - '.api_description', - '.options', - 'about.*', - 'about_*', - 'about_files/*', - 'ant_tasks/*', - 'cheatsheets/*', - 'com/*/*.java', - 'de/*/*.java', - 'docs/*', - 'log4j.properties', - 'META-INF/*.DSA', - 'META-INF/*.RSA', - 'META-INF/*.SF', - 'META-INF/changelog.txt', - 'META-INF/DEPENDENCIES', - 'META-INF/eclipse.inf', - 'META-INF/INDEX.LIST', - 'META-INF/maven/*', - 'META-INF/NOTICE', - 'META-INF/NOTICE.txt', - 'META-INF/p2.inf', - 'META-INF/versions/*/module-info.class', - 'modeling32.png', - 'module-info.class', - 'org/*/*.java', - 'OSGI-INF/l10n/bundle.properties', - 'plugin.xml', - 'profile.list', - 'schema/*', - 'systembundle.properties', - 'xtend-gen/*', - 'xtext32.png', + '*._trace', + '*.ecore', + '*.ecorediag', + '*.g', + '*.genmodel', + '*.html', + '*.mwe2', + '*.profile', + '*.xtext', + '*readme.txt', + '.api_description', + '.options', + 'about.*', + 'about_*', + 'about_files/*', + 'ant_tasks/*', + 'cheatsheets/*', + 'com/*/*.java', + 'de/*/*.java', + 'docs/*', + 'log4j.properties', + 'META-INF/*.DSA', + 'META-INF/*.RSA', + 'META-INF/*.SF', + 'META-INF/changelog.txt', + 'META-INF/DEPENDENCIES', + 'META-INF/eclipse.inf', + 'META-INF/INDEX.LIST', + 'META-INF/maven/*', + 'META-INF/NOTICE', + 'META-INF/NOTICE.txt', + 'META-INF/p2.inf', + 'META-INF/versions/*/module-info.class', + 'modeling32.png', + 'module-info.class', + 'org/*/*.java', + 'OSGI-INF/l10n/bundle.properties', + 'plugin.xml', + 'profile.list', + 'schema/*', + 'systembundle.properties', + 'xtend-gen/*', + 'xtext32.png', ) // Minimizing should be enabled with caution because some classes are only From f61362b2b489ed9f7c430d443ef56ea89338a0e3 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 21:00:23 -0700 Subject: [PATCH 437/709] Fix validator check for C generics. --- .../org/lflang/validation/LFValidator.java | 15 ++++--- test/C/src/generics/TypeCheck.lf | 43 +++++++++++++++++++ 2 files changed, 52 insertions(+), 6 deletions(-) create mode 100644 test/C/src/generics/TypeCheck.lf diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 747b22ffc3..b9df7e1e18 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -216,6 +216,13 @@ public void checkAssignment(Assignment assignment) { } } + private Type portTypeIfResolvable(VarRef port) { + var portType = ((Port) port.getVariable()).getType(); + return port.getContainer() == null + ? portType + : new TypeParameterizedReactor(port.getContainer()).resolveType(portType); + } + @Check(CheckType.FAST) public void checkConnection(Connection connection) { @@ -270,13 +277,9 @@ public void checkConnection(Connection connection) { // error. Avoid a class cast exception. if (port.getVariable() instanceof Port) { if (type == null) { - type = ((Port) port.getVariable()).getType(); + type = portTypeIfResolvable(port); } else { - var portType = ((Port) port.getVariable()).getType(); - portType = - port.getContainer() == null - ? portType - : new TypeParameterizedReactor(port.getContainer()).resolveType(portType); + var portType = portTypeIfResolvable(port); if (!sameType(type, portType)) { error("Types do not match.", Literals.CONNECTION__LEFT_PORTS); } diff --git a/test/C/src/generics/TypeCheck.lf b/test/C/src/generics/TypeCheck.lf new file mode 100644 index 0000000000..72575ca9ea --- /dev/null +++ b/test/C/src/generics/TypeCheck.lf @@ -0,0 +1,43 @@ +/** Check that two reactors that use generics can be connected together. */ +target C { + fast: true +} + +reactor Count(offset: time = 0, period: time = 1 sec) { + state count: int = 1 + output out: int + timer t(offset, period) + + reaction(t) -> out {= lf_set(out, self->count++); =} +} + +reactor TestCount(start: int = 1, num_inputs: int = 1) { + state count: int = 0 + state inputs_received: int = 0 + input in: T + + reaction(in) {= + lf_print("Received %d.", in->value); + if (in->value != self->count) { + lf_print_error_and_exit("Expected %d.", self->count); + } + self->count++; + self->inputs_received++; + =} + + reaction(shutdown) {= + lf_print("Shutdown invoked."); + if (self->inputs_received != self->num_inputs) { + lf_print_error_and_exit("Expected to receive %d inputs, but got %d.", + self->num_inputs, + self->inputs_received + ); + } + =} +} + +main reactor { + count = new Count() + testcount = new TestCount() + count.out -> testcount.in +} From 752432f0ad4c9380b68ea99fb2be0a244e335838 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 21:15:08 -0700 Subject: [PATCH 438/709] Add timeout. --- test/C/src/generics/TypeCheck.lf | 1 + 1 file changed, 1 insertion(+) diff --git a/test/C/src/generics/TypeCheck.lf b/test/C/src/generics/TypeCheck.lf index 72575ca9ea..8aa3d42f8d 100644 --- a/test/C/src/generics/TypeCheck.lf +++ b/test/C/src/generics/TypeCheck.lf @@ -1,5 +1,6 @@ /** Check that two reactors that use generics can be connected together. */ target C { + timeout: 3 sec, fast: true } From 67c7bce5ce75e4b39df9aa17851e4e70027cf9ee Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 21:28:37 -0700 Subject: [PATCH 439/709] Add comment. --- org.lflang/src/org/lflang/validation/LFValidator.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index b9df7e1e18..555d6d0da3 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -216,6 +216,7 @@ public void checkAssignment(Assignment assignment) { } } + /** Resolve the port type if it is known. */ private Type portTypeIfResolvable(VarRef port) { var portType = ((Port) port.getVariable()).getType(); return port.getContainer() == null From b7f494fb05058cf9a2bb33c568974e055b5f789a Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 21:31:02 -0700 Subject: [PATCH 440/709] Fix test. --- test/C/src/generics/TypeCheck.lf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/C/src/generics/TypeCheck.lf b/test/C/src/generics/TypeCheck.lf index 8aa3d42f8d..3080af48ea 100644 --- a/test/C/src/generics/TypeCheck.lf +++ b/test/C/src/generics/TypeCheck.lf @@ -13,7 +13,7 @@ reactor Count(offset: time = 0, period: time = 1 sec) { } reactor TestCount(start: int = 1, num_inputs: int = 1) { - state count: int = 0 + state count: int = start state inputs_received: int = 0 input in: T @@ -39,6 +39,6 @@ reactor TestCount(start: int = 1, num_inputs: int = 1) { main reactor { count = new Count() - testcount = new TestCount() + testcount = new TestCount(num_inputs = 4) count.out -> testcount.in } From b7bd75b3e6153c84a15737ba7120345928297647 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 23 May 2023 22:31:45 -0700 Subject: [PATCH 441/709] Update submodule pointer --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 845daae394..83b1cef7fd 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 845daae39479b8c06d15c1215aca575a4728a599 +Subproject commit 83b1cef7fd4209b3e25b6a310ce8f964277d9692 From 19d54baa77c05f442fddd629600113f71a8f4b59 Mon Sep 17 00:00:00 2001 From: Jakio815 Date: Wed, 24 May 2023 15:44:19 +0900 Subject: [PATCH 442/709] Move to not failing --- .../C/src/federated/{failing => }/SimpleFederatedAuthenticated.lf | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/C/src/federated/{failing => }/SimpleFederatedAuthenticated.lf (100%) diff --git a/test/C/src/federated/failing/SimpleFederatedAuthenticated.lf b/test/C/src/federated/SimpleFederatedAuthenticated.lf similarity index 100% rename from test/C/src/federated/failing/SimpleFederatedAuthenticated.lf rename to test/C/src/federated/SimpleFederatedAuthenticated.lf From de51be1ad4cebd650f6c7089dd4bb1d6676bb6da Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 24 May 2023 13:12:29 +0200 Subject: [PATCH 443/709] Fixed race condition in C++ enclave coordination This pulls in https://github.com/lf-lang/reactor-cpp/pull/49 to fix https://github.com/lf-lang/lingua-franca/issues/1746 --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index a13eda638f..c7b736296c 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit a13eda638fd5a4a71c8d42ef5fa20ef692370f87 +Subproject commit c7b736296cd365ec90996259d637d926090a133c From bc7033d94ed14dbd8814b12c2a7cb8a9e294abe9 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 24 May 2023 13:18:01 +0200 Subject: [PATCH 444/709] Revert "Fixed race condition in C++ enclave coordination" This reverts commit de51be1ad4cebd650f6c7089dd4bb1d6676bb6da. --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index c7b736296c..a13eda638f 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit c7b736296cd365ec90996259d637d926090a133c +Subproject commit a13eda638fd5a4a71c8d42ef5fa20ef692370f87 From 5e9150b7a52b1580c079b3cdc14132b0b4540162 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 24 May 2023 13:12:29 +0200 Subject: [PATCH 445/709] Fixed race condition in C++ enclave coordination This pulls in https://github.com/lf-lang/reactor-cpp/pull/49 to fix https://github.com/lf-lang/lingua-franca/issues/1746 --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index a13eda638f..b607f1f640 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit a13eda638fd5a4a71c8d42ef5fa20ef692370f87 +Subproject commit b607f1f64083ab531e7a676b29de75f076aa1cde From 849b9dfddee75f3f934605f02203532099a6ae88 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 24 May 2023 18:59:29 +0200 Subject: [PATCH 446/709] initial gradle setup cleanup --- build.gradle | 118 ------- lfc/build.gradle | 52 ++++ .../src/org/lflang/cli/Lfc.java | 0 org.lflang.tests/build.gradle | 75 ----- org.lflang/build.gradle | 287 +++--------------- settings.gradle | 6 +- 6 files changed, 95 insertions(+), 443 deletions(-) delete mode 100644 build.gradle create mode 100644 lfc/build.gradle rename {org.lflang => lfc}/src/org/lflang/cli/Lfc.java (100%) delete mode 100644 org.lflang.tests/build.gradle diff --git a/build.gradle b/build.gradle deleted file mode 100644 index 563377e3d3..0000000000 --- a/build.gradle +++ /dev/null @@ -1,118 +0,0 @@ -import com.diffplug.gradle.spotless.SpotlessTask -import lfformat.LfFormatStep - -buildscript { - repositories { - mavenCentral() - } - dependencies { - classpath "org.xtext:xtext-gradle-plugin:${xtextGradleVersion}" - classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}" - } -} - -plugins { - id "com.github.johnrengelman.shadow" version "${shadowJarVersion}" - id 'java' - id 'jacoco' - id "com.diffplug.spotless" version "${spotlessVersion}" -} - -subprojects { - repositories { - mavenCentral() - } - - apply plugin: 'kotlin' - compileKotlin { - destinationDir = compileJava.destinationDir - kotlinOptions { - jvmTarget = kotlinJvmTarget - } - } - compileTestKotlin { - kotlinOptions { - jvmTarget = kotlinJvmTarget - } - } - - dependencies { - implementation platform("org.eclipse.xtext:xtext-dev-bom:${xtextVersion}") - // https://mvnrepository.com/artifact/com.google.inject/guice - implementation group: 'com.google.inject', name: 'guice', version: guiceVersion - // https://picocli.info/ - implementation group: 'info.picocli', name: 'picocli', version: picocliVersion - // https://mvnrepository.com/artifact/com.google.code.gson/gson - implementation group: 'com.google.code.gson', name: 'gson', version: gsonVersion - implementation group: 'org.jetbrains.kotlin', name: 'kotlin-stdlib', version: kotlinVersion - implementation group: 'org.jetbrains.kotlin', name: 'kotlin-reflect', version: kotlinVersion - } - - apply from: "${rootDir}/gradle/source-layout.gradle" - apply plugin: 'eclipse' - - // generate xtend sources before kotlin compilation - compileKotlin.dependsOn(":org.lflang:generateXtextLanguage") - - sourceCompatibility = JavaVersion.VERSION_17 - targetCompatibility = JavaVersion.VERSION_17 - - configurations.configureEach { - exclude group: 'asm' - } - - // Delete generated sources on `gradle clean` - clean.doFirst { - project.logger.info("Deleting ${projectDir}/src-gen") - delete "${projectDir}/src-gen/" - } -} - -// Our CI uses --tests filters, which fails if some -// subprojects have no matching test. -// -// https://stackoverflow.com/questions/26147480/how-to-make-gradle-not-to-mark-build-failed-if-no-tests-are-found -subprojects { - test { - filter { - setFailOnNoMatchingTests(false) - } - testLogging { - // print exception message when a test fails. - exceptionFormat "full" - } - } -} - - -spotless { - repositories { - mavenCentral() - } - - format 'misc', { - // define the files to apply `misc` to - target '*.gradle', '*.md', '.gitignore' - - // define the steps to apply to those files - trimTrailingWhitespace() - indentWithSpaces() // or spaces. Takes an integer argument if you don't like 4 - endWithNewline() - } - - format 'linguaFranca', { - addStep(LfFormatStep.create(project.projectDir)) - target 'test/*/src/**/*.lf' // you have to set the target manually - targetExclude 'test/**/failing/**' - } - - java { - target 'org.lflang*/src/**/*.java', 'buildSrc/**/*.java' - // The following is quoted from https://github.com/google/google-java-format - // "Note: There is no configurability as to the formatter's algorithm for formatting. - // This is a deliberate design decision to unify our code formatting on a single format." - googleJavaFormat(googleJavaFormatVersion).reflowLongStrings() - formatAnnotations() - } -} -tasks.withType(SpotlessTask).configureEach { it.dependsOn(":org.lflang:jarCliTools") } diff --git a/lfc/build.gradle b/lfc/build.gradle new file mode 100644 index 0000000000..7dd8ee764b --- /dev/null +++ b/lfc/build.gradle @@ -0,0 +1,52 @@ +plugins { + id 'java' + id 'application' +} + +sourceSets { + main { + java { + srcDirs = ['src'] + } + } +} + +repositories { + mavenCentral() + // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. + maven { + url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + } +} + +dependencies { + implementation "org.eclipse.xtext:org.eclipse.xtext:${xtextVersion}" + implementation "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:${xtextVersion}" + implementation "org.eclipse.xtext:org.eclipse.xtext.ide:${xtextVersion}" + // https://mvnrepository.com/artifact/org.eclipse.platform/org.eclipse.core.resources + implementation group: 'org.eclipse.platform', name: 'org.eclipse.core.resources', version: "${resourcesVersion}" + // https://mvnrepository.com/artifact/org.eclipse.emf/org.eclipse.emf.mwe2.launch + implementation group: 'org.eclipse.emf', name: 'org.eclipse.emf.mwe2.launch', version: "${mwe2LaunchVersion}" + // https://mvnrepository.com/artifact/org.eclipse.lsp4j/org.eclipse.lsp4j + implementation group: 'org.eclipse.lsp4j', name: 'org.eclipse.lsp4j', version: "${lsp4jVersion}" + implementation group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.12.4' + implementation group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: '2.12.4' + implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.12.4' + implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:${klighdVersion}") { + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' + } + implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.standalone:${klighdVersion}") { + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' + } + implementation group: 'info.picocli', name: 'picocli', version: picocliVersion + implementation project(':org.lflang') +} + +application { + mainClass = 'org.lflang.cli.Lfc' + tasks.run.workingDir = rootProject.projectDir +} + +build.finalizedBy installDist \ No newline at end of file diff --git a/org.lflang/src/org/lflang/cli/Lfc.java b/lfc/src/org/lflang/cli/Lfc.java similarity index 100% rename from org.lflang/src/org/lflang/cli/Lfc.java rename to lfc/src/org/lflang/cli/Lfc.java diff --git a/org.lflang.tests/build.gradle b/org.lflang.tests/build.gradle deleted file mode 100644 index 97f664c1a8..0000000000 --- a/org.lflang.tests/build.gradle +++ /dev/null @@ -1,75 +0,0 @@ -repositories { - mavenCentral() - // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. - maven { - url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - } -} -dependencies { - implementation project(':org.lflang') - testImplementation "org.junit.jupiter:junit-jupiter-api:${jupiterVersion}" - testImplementation "org.junit.jupiter:junit-jupiter-engine:${jupiterVersion}" - testImplementation "org.junit.platform:junit-platform-commons:${jUnitPlatformVersion}" - testImplementation "org.junit.platform:junit-platform-engine:${jUnitPlatformVersion}" - testImplementation "org.opentest4j:opentest4j:${openTest4jVersion}" - testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:${xtextVersion}" - testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:${xtextVersion}" -} - -apply plugin: 'java' -apply plugin: 'jacoco' - -jacoco { - toolVersion = jacocoVersion - reportsDirectory = file("$buildDir/reports/jacoco") //default directory where jacoco generates test reports -} - - -jacocoTestReport { - reports { - xml.required = true - csv.required = false - html.destination file("${buildDir}/reports/html/jacoco") - xml.destination file("${buildDir}/reports/xml/jacoco") - } - def fileFilter = [ 'org/lflang/services/**', - 'org/lflang/linguaFranca/impl/**', - 'org/lflang/serializer/**', - 'org/lflang/linguaFranca/util/**', - 'org/lflang/linguaFranca/**', - 'org/lflang/parser/antlr/**' - ] - def mainCls = fileTree(dir: "$project.buildDir/../../org.lflang/build/classes/java/main", excludes: fileFilter) - def javaSrc = "$project.buildDir/../../org.lflang/src" - - classDirectories.from = files(mainCls) - sourceDirectories.from = files([javaSrc]) -} - -test { - testLogging { - events "passed", "skipped", "failed" - showStandardStreams = true - } - // Pass the scheduler property on to the Java VM - systemProperty 'scheduler', System.getProperty('scheduler') - systemProperty 'runtime', System.getProperty('runtime') - // Suggested by Gradle documentation: https://guides.gradle.org/performance/#parallel_test_execution - maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1 - useJUnitPlatform() - finalizedBy jacocoTestReport - workingDir = ".." - filter { - setFailOnNoMatchingTests(true) - } -} - -test.dependsOn("compileKotlin") - -task runSingleTest(type: JavaExec) { - description = "Execute a single test, use with eg --args test/Python/src/Minimal.lf" - group = "test" - classpath = sourceSets.test.runtimeClasspath - workingDir = ".." - mainClass = 'org.lflang.tests.RunSingleTestMain' -} diff --git a/org.lflang/build.gradle b/org.lflang/build.gradle index 8d4f6a41c9..f93af170ad 100644 --- a/org.lflang/build.gradle +++ b/org.lflang/build.gradle @@ -1,4 +1,36 @@ -import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar +plugins { + id 'org.jetbrains.kotlin.jvm' version "${kotlinVersion}" + id 'java-library' +} + +sourceSets { + main { + java { + srcDirs = ['src', 'src-gen'] + } + kotlin { + srcDirs = ['src', 'src-gen'] + } + resources { + srcDirs = ['src-gen', 'src'] + include 'lib/' + include 'org/lflang/LF.xtextbin' + include 'org/lflang/parser/antlr/internal/InternalLF.tokens' + } + } +} + +compileKotlin { + destinationDir = compileJava.destinationDir + kotlinOptions { + jvmTarget = kotlinJvmTarget + } +} +compileTestKotlin { + kotlinOptions { + jvmTarget = kotlinJvmTarget + } +} repositories { mavenCentral() @@ -7,6 +39,7 @@ repositories { url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" } } + dependencies { implementation "org.eclipse.xtext:org.eclipse.xtext:${xtextVersion}" implementation "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:${xtextVersion}" @@ -28,6 +61,7 @@ dependencies { exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' } + implementation group: 'info.picocli', name: 'picocli', version: picocliVersion } configurations { @@ -51,252 +85,9 @@ tasks.register('generateXtextLanguage', JavaExec) { args += "src/org/lflang/GenerateLinguaFranca.mwe2" args += "-p" args += "rootPath=/${projectDir}/.." - - // Currently we don't need to delete any generated files because we use the - // Java/Xtend implementations. However, if we commit to porting such files - // to Kotlin, we might to reintroduce the deletion mechanism below. - /*doLast { - def filesToDelete = [ - "org.lflang.validation.LFValidator", - "org.lflang.LFRuntimeModule", - "org.lflang.LFStandaloneSetup", - "org.lflang.generator.LFGenerator", - "org.lflang.scoping.LFScopeProvider" - ] - - filesToDelete.each { qname -> - def path = qname.replace('.', '/') - def ktFile = file("src/${path}.kt") - def javaFile = file("src/${path}.java") - def xtendFile = file("src/${path}.xtend") - - if (ktFile.exists() || xtendFile.exists()) { - def chosenLang = ktFile.exists() ? "Kotlin" : "Xtend" - project.logger.info("deleting ${projectDir.relativePath(javaFile)}, the ${chosenLang} file prevails") - project.delete(javaFile) // generated by Xtend - } else { - project.logger.info("no ${projectDir.relativePath(ktFile)}, leaving the Java implementation in") - } - } - }*/ -} -processResources.dependsOn(generateXtextLanguage) -clean.dependsOn(cleanGenerateXtextLanguage) -eclipse.classpath.plusConfigurations += [configurations.mwe2] - -configurations { - cli_impl { - extendsFrom implementation - } -} - -tasks.register('getSubmoduleVersions', Exec) { - description('Run a Git command to get the current status of submodules') - workingDir project.rootDir - // This will make gradle execute git submodule status every time updateRustRuntime is called - outputs.upToDateWhen { false } - - def command = "git submodule status" - if (System.getProperty('os.name').toLowerCase(Locale.ROOT).contains('windows')) { - commandLine 'cmd', '/c', command - } else { - commandLine 'sh', '-c', command - } - standardOutput = new ByteArrayOutputStream() - - ext.outputFile = file("$project.buildDir/submodule-status.properties") - outputs.file(outputFile) - - doLast { - def matcher = standardOutput.toString() =~ ~"(?m)^[-+ ]?([0-9a-f]+) org.lflang/src/lib/\\w+/reactor-([-a-zA-Z]+)" - def properties = new StringBuilder() - while (matcher.find()) { - def rev = matcher.group(1) - def language = matcher.group(2) - properties << "$language = $rev\n" - } - outputFile.text = properties - } -} - -tasks.register('updateRustRuntime') { - description('Record the VCS revisions of the language runtimes into a properties file available at runtime.') - - dependsOn getSubmoduleVersions - // If the output of the git submodule status did not change (the getSubmoduleVersions task), then this task is considered up to date. - inputs.files(getSubmoduleVersions.outputs) - ext.outputFile = file("$project.projectDir/src/lib/rs/runtime-version.properties") - outputs.file(outputFile) - - doLast { - def upToDateProps = new Properties() - getSubmoduleVersions.outputFile.withReader { r -> upToDateProps.load(r) } - outputFile.text = "rs = " + upToDateProps.get("rs") + "\n" - } -} -// add the generated file as an output -sourceSets.main.output.dir tasks.updateRustRuntime.outputFile, builtBy: updateRustRuntime -tasks.processResources.dependsOn(updateRustRuntime) - -tasks.register('checkRuntimeVersionFileUpToDate') { - description('Check that the runtime version recorded in the built Jar for LFC matches the version of the checked out submodule') - dependsOn getSubmoduleVersions - inputs.file updateRustRuntime.outputFile - - doLast { - def rtProps = new Properties() - updateRustRuntime.outputFile.withReader { r -> rtProps.load(r) } - def upToDateProps = new Properties() - getSubmoduleVersions.outputFile.withReader { r -> upToDateProps.load(r) } - - upToDateProps.each { language, rev -> - def actualLanguage = rtProps.get(language) - if (actualLanguage == null) - return - if (actualLanguage != rev) { - logger.error("Runtime for $language is not checked out at correct revision:\n" + - "expected: $rev\n" + - "actual: $actualLanguage\n" + - "You may need to call `./gradlew updateRustRuntime`.") - } else { - logger.info("Success: Runtime for $language is checked out at expected revision $rev") - } - } - } -} - -apply plugin: 'application' -apply plugin: 'com.github.johnrengelman.shadow' - -tasks.register('buildAll') { - apply plugin: 'application' - apply plugin: 'com.github.johnrengelman.shadow' - mainClassName = 'org.lflang.cli.Lfc' -} - -tasks.register('jarCliTools', ShadowJar) { - manifest { - attributes('Main-Class': 'org.lflang.cli.Lfc') - } - configurations = [project.configurations.cli_impl] - exclude 'test/*' - exclude 'META-INF/*.RSA', 'META-INF/*.SF', 'META-INF/*.DSA' - // We should use minimize() here to reduce the size of the JAR, but it causes problems - // with regard to our Kotlin classes. Since we don't use imports to load them but load - // the classes manually, minimize does not see the dependency. While we can add an exclude - // rule, this does not seem to work very well and causes problems when compiling for a - // second time. Also see https://github.com/lf-lang/lingua-franca/pull/1285 - transform(com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer) { - resource = 'plugin.properties' - } - from sourceSets.main.output -} - -buildAll.finalizedBy jarCliTools - -// Tasks for running specific CLI tools. -// The working directory will be the root directory of the lingua franca project -// CLI arguments can be passed to lfc by using --args. Note that you need -// to escape cli flags which start with --.For instance --args ' --help'. -// Otherwise they're parsed as arguments to the Gradle CLI, not lfc. - -tasks.register('runLfc', JavaExec) { - // builds and runs lfc - description = "Build and run lfc, use --args to pass arguments" - group = "application" - classpath = sourceSets.main.runtimeClasspath - mainClass = 'org.lflang.cli.Lfc' - workingDir = '..' -} - -tasks.register('runLff', JavaExec) { - // builds and runs lff - description = "Build and run lff, use --args to pass arguments" - group = "application" - classpath = sourceSets.main.runtimeClasspath - mainClass = 'org.lflang.cli.Lff' - workingDir = '..' -} - -tasks.register('generateLanguageDiagramServer') { - description 'Creates a jar that implements a language server with diagram support for LF.' - - apply plugin: 'java' - apply plugin: 'application' - apply plugin: 'com.github.johnrengelman.shadow' - - mainClassName = "org.lflang.diagram.lsp.LanguageDiagramServer" - - compileJava { - options.compilerArgs << '-Xlint:unchecked' - } - - shadowJar { - archiveClassifier = 'lds' - - // Handling of service loader registrations via META-INF/services/* - mergeServiceFiles() - - // Merge properties - transform(com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer) { - resource = 'plugin.properties' - } - - // Exclude files that are known to be dispensable for a language server - exclude( - '*._trace', - '*.ecore', - '*.ecorediag', - '*.g', - '*.genmodel', - '*.html', - '*.mwe2', - '*.profile', - '*.xtext', - '*readme.txt', - '.api_description', - '.options', - 'about.*', - 'about_*', - 'about_files/*', - 'ant_tasks/*', - 'cheatsheets/*', - 'com/*/*.java', - 'de/*/*.java', - 'docs/*', - 'log4j.properties', - 'META-INF/*.DSA', - 'META-INF/*.RSA', - 'META-INF/*.SF', - 'META-INF/changelog.txt', - 'META-INF/DEPENDENCIES', - 'META-INF/eclipse.inf', - 'META-INF/INDEX.LIST', - 'META-INF/maven/*', - 'META-INF/NOTICE', - 'META-INF/NOTICE.txt', - 'META-INF/p2.inf', - 'META-INF/versions/*/module-info.class', - 'modeling32.png', - 'module-info.class', - 'org/*/*.java', - 'OSGI-INF/l10n/bundle.properties', - 'plugin.xml', - 'profile.list', - 'schema/*', - 'systembundle.properties', - 'xtend-gen/*', - 'xtext32.png', - ) - - // Minimizing should be enabled with caution because some classes are only - // loaded via services (e.g. diagram syntheses and some xtext aspects) - // and would be removed when minimized - // minimize() { - // exclude(dependency('log4j:log4j:.*')) - // exclude(dependency('org.eclipse.xtext:.*ide:.*')) - // } - } } -generateLanguageDiagramServer.finalizedBy shadowJar \ No newline at end of file +compileJava.dependsOn(generateXtextLanguage) +compileKotlin.dependsOn(generateXtextLanguage) +processResources.dependsOn(generateXtextLanguage) +clean.dependsOn(cleanGenerateXtextLanguage) \ No newline at end of file diff --git a/settings.gradle b/settings.gradle index 7f3458275f..94d44e8d96 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,2 +1,4 @@ -include 'org.lflang' -include 'org.lflang.tests' +rootProject.name = 'org.lflang' +include('org.lflang', 'lfc') + + From 27f7d55a378ab30f8b79ce3d4dd38235e5394532 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Wed, 24 May 2023 11:56:39 -0700 Subject: [PATCH 447/709] Moved Watchdog.lf into failing temporarily while we figure this out --- test/C/src/concurrent/{ => failing}/Watchdog.lf | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename test/C/src/concurrent/{ => failing}/Watchdog.lf (100%) diff --git a/test/C/src/concurrent/Watchdog.lf b/test/C/src/concurrent/failing/Watchdog.lf similarity index 100% rename from test/C/src/concurrent/Watchdog.lf rename to test/C/src/concurrent/failing/Watchdog.lf From c2b9ce218621e13a94522bc6ec44498e64dea705 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 21 May 2023 12:17:38 -0700 Subject: [PATCH 448/709] Skip tests for changes specific to other targets. --- .github/workflows/all-c.yml | 80 +++++++++++++++++++++++++++ .github/workflows/all-cpp.yml | 59 ++++++++++++++++++++ .github/workflows/all-py.yml | 47 ++++++++++++++++ .github/workflows/all-rs.yml | 54 ++++++++++++++++++ .github/workflows/all-ts.yml | 47 ++++++++++++++++ .github/workflows/{ci.yml => all.yml} | 8 +-- 6 files changed, 289 insertions(+), 6 deletions(-) create mode 100644 .github/workflows/all-c.yml create mode 100644 .github/workflows/all-cpp.yml create mode 100644 .github/workflows/all-py.yml create mode 100644 .github/workflows/all-rs.yml create mode 100644 .github/workflows/all-ts.yml rename .github/workflows/{ci.yml => all.yml} (95%) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml new file mode 100644 index 0000000000..03a2fe00b3 --- /dev/null +++ b/.github/workflows/all-c.yml @@ -0,0 +1,80 @@ +# Main workflow for testing the Lingua Franca compiler. +name: CI + +on: + # Trigger this workflow on push events, but only on master. + push: + branches: + - master + # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + pull_request: + branches-ignore: + - 'nightly' + paths-ignore: + - 'org.lflang/src/org/lflang/generator/cpp/**' + - 'org.lflang/src/org/lflang/generator/python/**' + - 'org.lflang/src/org/lflang/generator/rust/**' + - 'org.lflang/src/org/lflang/generator/ts/**' + - 'org.lflang/src/lib/cpp/**' + - 'org.lflang/src/lib/py/**' + - 'org.lflang/src/lib/rs/**' + - 'org.lflang/src/lib/ts/**' + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Cancel previous workflow runs. + cancel: + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + +# Check that automatic code formatting works. +# TODO: Uncomment after fed-gen is merged. +# format: +# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master +# needs: cancel + + # Run the unit tests. + unit-tests: + uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml@master + needs: cancel + + # Run the C benchmark tests. + c-benchmark-tests: + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + with: + target: 'C' + needs: cancel + + # Run the C integration tests. + c-tests: + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + needs: cancel + + # Run the C Arduino integration tests. + c-arduino-tests: + uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml@master + needs: cancel + + # Run the C Zephyr integration tests. + c-zephyr-tests: + uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml@master + needs: cancel + + # Run the CCpp integration tests. + ccpp-tests: + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + with: + use-cpp: true + needs: cancel + + # Run the Python integration tests. + py-tests: + uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@master + needs: cancel + + # Run the serialization tests + serialization-tests: + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + needs: cancel diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml new file mode 100644 index 0000000000..cd3cfebe9c --- /dev/null +++ b/.github/workflows/all-cpp.yml @@ -0,0 +1,59 @@ +# Main workflow for testing the Lingua Franca compiler. +name: CI + +on: + # Trigger this workflow on push events, but only on master. + push: + branches: + - master + # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + pull_request: + branches-ignore: + - 'nightly' + paths-ignore: + - 'org.lflang/src/org/lflang/generator/c/**' + - 'org.lflang/src/org/lflang/generator/python/**' + - 'org.lflang/src/org/lflang/generator/rust/**' + - 'org.lflang/src/org/lflang/generator/ts/**' + - 'org.lflang/src/lib/c/**' + - 'org.lflang/src/lib/platform/**' + - 'org.lflang/src/lib/py/**' + - 'org.lflang/src/lib/rs/**' + - 'org.lflang/src/lib/ts/**' + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Cancel previous workflow runs. + cancel: + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + +# Check that automatic code formatting works. +# TODO: Uncomment after fed-gen is merged. +# format: +# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master +# needs: cancel + + # Run the C++ benchmark tests. + cpp-benchmark-tests: + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + with: + target: 'Cpp' + needs: cancel + + # Run the C++ integration tests. + cpp-tests: + uses: lf-lang/lingua-franca/.github/workflows/cpp-tests.yml@master + needs: cancel + + # Run the C++ integration tests on ROS2. + cpp-ros2-tests: + uses: lf-lang/lingua-franca/.github/workflows/cpp-ros2-tests.yml@master + needs: cancel + + # Run the serialization tests + serialization-tests: + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + needs: cancel diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml new file mode 100644 index 0000000000..5b6b8a29a0 --- /dev/null +++ b/.github/workflows/all-py.yml @@ -0,0 +1,47 @@ +# Main workflow for testing the Lingua Franca compiler. +name: CI + +on: + # Trigger this workflow on push events, but only on master. + push: + branches: + - master + # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + pull_request: + branches-ignore: + - 'nightly' + paths-ignore: + - 'org.lflang/src/org/lflang/generator/c/**' + - 'org.lflang/src/org/lflang/generator/cpp/**' + - 'org.lflang/src/org/lflang/generator/rust/**' + - 'org.lflang/src/org/lflang/generator/ts/**' + - 'org.lflang/src/lib/c/**' + - 'org.lflang/src/lib/platform/**' + - 'org.lflang/src/lib/cpp/**' + - 'org.lflang/src/lib/rs/**' + - 'org.lflang/src/lib/ts/**' + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Cancel previous workflow runs. + cancel: + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + +# Check that automatic code formatting works. +# TODO: Uncomment after fed-gen is merged. +# format: +# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master +# needs: cancel + + # Run the Python integration tests. + py-tests: + uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@master + needs: cancel + + # Run the serialization tests + serialization-tests: + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + needs: cancel diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml new file mode 100644 index 0000000000..3924a5d09f --- /dev/null +++ b/.github/workflows/all-rs.yml @@ -0,0 +1,54 @@ +# Main workflow for testing the Lingua Franca compiler. +name: CI + +on: + # Trigger this workflow on push events, but only on master. + push: + branches: + - master + # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + pull_request: + branches-ignore: + - 'nightly' + paths-ignore: + - 'org.lflang/src/org/lflang/generator/c/**' + - 'org.lflang/src/org/lflang/generator/cpp/**' + - 'org.lflang/src/org/lflang/generator/python/**' + - 'org.lflang/src/org/lflang/generator/ts/**' + - 'org.lflang/src/lib/c/**' + - 'org.lflang/src/lib/platform/**' + - 'org.lflang/src/lib/cpp/**' + - 'org.lflang/src/lib/py/**' + - 'org.lflang/src/lib/ts/**' + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Cancel previous workflow runs. + cancel: + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + +# Check that automatic code formatting works. +# TODO: Uncomment after fed-gen is merged. +# format: +# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master +# needs: cancel + + # Run the Rust integration tests. + rs-tests: + uses: lf-lang/lingua-franca/.github/workflows/rs-tests.yml@master + needs: cancel + + # Run the Rust benchmark tests. + rs-benchmark-tests: + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + with: + target: 'Rust' + needs: cancel + + # Run the serialization tests + serialization-tests: + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + needs: cancel diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml new file mode 100644 index 0000000000..d29d5d5599 --- /dev/null +++ b/.github/workflows/all-ts.yml @@ -0,0 +1,47 @@ +# Main workflow for testing the Lingua Franca compiler. +name: CI + +on: + # Trigger this workflow on push events, but only on master. + push: + branches: + - master + # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + pull_request: + branches-ignore: + - 'nightly' + paths-ignore: + - 'org.lflang/src/org/lflang/generator/c/**' + - 'org.lflang/src/org/lflang/generator/cpp/**' + - 'org.lflang/src/org/lflang/generator/python/**' + - 'org.lflang/src/org/lflang/generator/rust/**' + - 'org.lflang/src/lib/c/**' + - 'org.lflang/src/lib/platform/**' + - 'org.lflang/src/lib/cpp/**' + - 'org.lflang/src/lib/py/**' + - 'org.lflang/src/lib/rs/**' + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Cancel previous workflow runs. + cancel: + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + +# Check that automatic code formatting works. +# TODO: Uncomment after fed-gen is merged. +# format: +# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master +# needs: cancel + + # Run the TypeScript integration tests. + ts-tests: + uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml@master + needs: cancel + + # Run the serialization tests + serialization-tests: + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + needs: cancel diff --git a/.github/workflows/ci.yml b/.github/workflows/all.yml similarity index 95% rename from .github/workflows/ci.yml rename to .github/workflows/all.yml index dc9832cf35..1238a97bcd 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/all.yml @@ -6,10 +6,6 @@ on: push: branches: - master - # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. - pull_request: - branches-ignore: - - 'nightly' env: # 2020.11 @@ -60,12 +56,12 @@ jobs: c-tests: uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master needs: cancel - + # Run the C Arduino integration tests. c-arduino-tests: uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml@master needs: cancel - + # Run the C Zephyr integration tests. c-zephyr-tests: uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml@master From 9de16d56917084f9ceed28cff7e7a6a36d30ab4f Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 21 May 2023 12:33:57 -0700 Subject: [PATCH 449/709] More aggressively reduce the amount of tests run. --- .github/workflows/all-c.yml | 13 ++-- .github/workflows/all-cpp.yml | 13 +--- .github/workflows/all-non-target-specific.yml | 65 +++++++++++++++++++ .github/workflows/all-py.yml | 13 +--- .github/workflows/all-rs.yml | 13 +--- .github/workflows/all-ts.yml | 13 +--- 6 files changed, 81 insertions(+), 49 deletions(-) create mode 100644 .github/workflows/all-non-target-specific.yml diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index 03a2fe00b3..9541214f8e 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -10,15 +10,10 @@ on: pull_request: branches-ignore: - 'nightly' - paths-ignore: - - 'org.lflang/src/org/lflang/generator/cpp/**' - - 'org.lflang/src/org/lflang/generator/python/**' - - 'org.lflang/src/org/lflang/generator/rust/**' - - 'org.lflang/src/org/lflang/generator/ts/**' - - 'org.lflang/src/lib/cpp/**' - - 'org.lflang/src/lib/py/**' - - 'org.lflang/src/lib/rs/**' - - 'org.lflang/src/lib/ts/**' + paths: + - 'org.lflang/src/org/lflang/generator/c/**' + - 'org.lflang/src/lib/c/**' + - 'org.lflang/src/lib/platform/**' env: # 2020.11 diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index cd3cfebe9c..2df8b7eab6 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -10,16 +10,9 @@ on: pull_request: branches-ignore: - 'nightly' - paths-ignore: - - 'org.lflang/src/org/lflang/generator/c/**' - - 'org.lflang/src/org/lflang/generator/python/**' - - 'org.lflang/src/org/lflang/generator/rust/**' - - 'org.lflang/src/org/lflang/generator/ts/**' - - 'org.lflang/src/lib/c/**' - - 'org.lflang/src/lib/platform/**' - - 'org.lflang/src/lib/py/**' - - 'org.lflang/src/lib/rs/**' - - 'org.lflang/src/lib/ts/**' + paths: + - 'org.lflang/src/org/lflang/generator/cpp/**' + - 'org.lflang/src/lib/cpp/**' env: # 2020.11 diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml new file mode 100644 index 0000000000..17938b20db --- /dev/null +++ b/.github/workflows/all-non-target-specific.yml @@ -0,0 +1,65 @@ +# Main workflow for testing the Lingua Franca compiler. +name: CI + +on: + # Trigger this workflow on push events, but only on master. + push: + branches: + - master + paths-ignore: + - 'org.lflang/src/org/lflang/generator/c/**' + - 'org.lflang/src/org/lflang/generator/cpp/**' + - 'org.lflang/src/org/lflang/generator/python/**' + - 'org.lflang/src/org/lflang/generator/rust/**' + - 'org.lflang/src/org/lflang/generator/ts/**' + - 'org.lflang/src/lib/c/**' + - 'org.lflang/src/lib/platform/**' + - 'org.lflang/src/lib/cpp/**' + - 'org.lflang/src/lib/py/**' + - 'org.lflang/src/lib/rs/**' + - 'org.lflang/src/lib/ts/**' + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Cancel previous workflow runs. + cancel: + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + + # Test the Gradle build. + build: + uses: lf-lang/lingua-franca/.github/workflows/build.yml@master + needs: cancel + + # Build the tools used for processing execution traces + build-tracing-tools: + uses: lf-lang/lingua-franca/.github/workflows/build-trace-tools.yml@master + needs: cancel + +# Check that automatic code formatting works. +# TODO: Uncomment after fed-gen is merged. +# format: +# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master +# needs: cancel + + # Run the unit tests. + unit-tests: + uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml@master + needs: cancel + + # Run tests for the standalone compiler. + cli-tests: + uses: lf-lang/lingua-franca/.github/workflows/cli-tests.yml@master + needs: cancel + + # Run language server tests. + lsp-tests: + uses: lf-lang/lingua-franca/.github/workflows/lsp-tests.yml@master + needs: cancel + + # Run the serialization tests + serialization-tests: + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + needs: cancel diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index 5b6b8a29a0..22dade8922 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -10,16 +10,9 @@ on: pull_request: branches-ignore: - 'nightly' - paths-ignore: - - 'org.lflang/src/org/lflang/generator/c/**' - - 'org.lflang/src/org/lflang/generator/cpp/**' - - 'org.lflang/src/org/lflang/generator/rust/**' - - 'org.lflang/src/org/lflang/generator/ts/**' - - 'org.lflang/src/lib/c/**' - - 'org.lflang/src/lib/platform/**' - - 'org.lflang/src/lib/cpp/**' - - 'org.lflang/src/lib/rs/**' - - 'org.lflang/src/lib/ts/**' + paths: + - 'org.lflang/src/org/lflang/generator/python/**' + - 'org.lflang/src/lib/py/**' env: # 2020.11 diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index 3924a5d09f..12df37e060 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -10,16 +10,9 @@ on: pull_request: branches-ignore: - 'nightly' - paths-ignore: - - 'org.lflang/src/org/lflang/generator/c/**' - - 'org.lflang/src/org/lflang/generator/cpp/**' - - 'org.lflang/src/org/lflang/generator/python/**' - - 'org.lflang/src/org/lflang/generator/ts/**' - - 'org.lflang/src/lib/c/**' - - 'org.lflang/src/lib/platform/**' - - 'org.lflang/src/lib/cpp/**' - - 'org.lflang/src/lib/py/**' - - 'org.lflang/src/lib/ts/**' + paths: + - 'org.lflang/src/org/lflang/generator/rust/**' + - 'org.lflang/src/lib/rs/**' env: # 2020.11 diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index d29d5d5599..1875fc8e76 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -10,16 +10,9 @@ on: pull_request: branches-ignore: - 'nightly' - paths-ignore: - - 'org.lflang/src/org/lflang/generator/c/**' - - 'org.lflang/src/org/lflang/generator/cpp/**' - - 'org.lflang/src/org/lflang/generator/python/**' - - 'org.lflang/src/org/lflang/generator/rust/**' - - 'org.lflang/src/lib/c/**' - - 'org.lflang/src/lib/platform/**' - - 'org.lflang/src/lib/cpp/**' - - 'org.lflang/src/lib/py/**' - - 'org.lflang/src/lib/rs/**' + paths: + - 'org.lflang/src/org/lflang/generator/ts/**' + - 'org.lflang/src/lib/ts/**' env: # 2020.11 From 3510231faca219a7d959151bf0cae2db2180b604 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 21 May 2023 12:41:00 -0700 Subject: [PATCH 450/709] Update names. --- .github/workflows/all-c.yml | 2 +- .github/workflows/all-cpp.yml | 2 +- .github/workflows/all-non-target-specific.yml | 4 +++- .github/workflows/all-py.yml | 2 +- .github/workflows/all-rs.yml | 2 +- .github/workflows/all-ts.yml | 2 +- 6 files changed, 8 insertions(+), 6 deletions(-) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index 9541214f8e..7e44da4bc4 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -1,5 +1,5 @@ # Main workflow for testing the Lingua Franca compiler. -name: CI +name: C on: # Trigger this workflow on push events, but only on master. diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index 2df8b7eab6..479ffd61d7 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -1,5 +1,5 @@ # Main workflow for testing the Lingua Franca compiler. -name: CI +name: Cpp on: # Trigger this workflow on push events, but only on master. diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 17938b20db..be0e01e3c1 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,11 +1,13 @@ # Main workflow for testing the Lingua Franca compiler. -name: CI +name: Non-target-specific on: # Trigger this workflow on push events, but only on master. push: branches: - master + # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + pull_request: paths-ignore: - 'org.lflang/src/org/lflang/generator/c/**' - 'org.lflang/src/org/lflang/generator/cpp/**' diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index 22dade8922..5b329f96a1 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -1,5 +1,5 @@ # Main workflow for testing the Lingua Franca compiler. -name: CI +name: Python on: # Trigger this workflow on push events, but only on master. diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index 12df37e060..6b833efcd5 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -1,5 +1,5 @@ # Main workflow for testing the Lingua Franca compiler. -name: CI +name: Rust on: # Trigger this workflow on push events, but only on master. diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index 1875fc8e76..7affdf1f64 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -1,5 +1,5 @@ # Main workflow for testing the Lingua Franca compiler. -name: CI +name: TypeScript on: # Trigger this workflow on push events, but only on master. From e721efa96a06e4cb194a67716f5003db86464729 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 22 May 2023 14:01:12 -0700 Subject: [PATCH 451/709] Add manual trigger. --- .github/workflows/all-c.yml | 5 +++-- .github/workflows/all-cpp.yml | 1 + .github/workflows/all-non-target-specific.yml | 1 + .github/workflows/all-py.yml | 1 + .github/workflows/all-rs.yml | 1 + .github/workflows/all-ts.yml | 1 + .github/workflows/all.yml | 1 + 7 files changed, 9 insertions(+), 2 deletions(-) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index 7e44da4bc4..f5f00cad55 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -2,14 +2,15 @@ name: C on: + workflow_dispatch: # Allow the workflow to be triggered manually. # Trigger this workflow on push events, but only on master. push: branches: - - master + - master # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. pull_request: branches-ignore: - - 'nightly' + - 'nightly' paths: - 'org.lflang/src/org/lflang/generator/c/**' - 'org.lflang/src/lib/c/**' diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index 479ffd61d7..e21492722d 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -2,6 +2,7 @@ name: Cpp on: + workflow_dispatch: # Allow the workflow to be triggered manually. # Trigger this workflow on push events, but only on master. push: branches: diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index be0e01e3c1..d3a0ced5da 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -2,6 +2,7 @@ name: Non-target-specific on: + workflow_dispatch: # Allow the workflow to be triggered manually. # Trigger this workflow on push events, but only on master. push: branches: diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index 5b329f96a1..82a6f089c6 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -2,6 +2,7 @@ name: Python on: + workflow_dispatch: # Allow the workflow to be triggered manually. # Trigger this workflow on push events, but only on master. push: branches: diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index 6b833efcd5..13393cb2aa 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -2,6 +2,7 @@ name: Rust on: + workflow_dispatch: # Allow the workflow to be triggered manually. # Trigger this workflow on push events, but only on master. push: branches: diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index 7affdf1f64..f14b1cfc0a 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -2,6 +2,7 @@ name: TypeScript on: + workflow_dispatch: # Allow the workflow to be triggered manually. # Trigger this workflow on push events, but only on master. push: branches: diff --git a/.github/workflows/all.yml b/.github/workflows/all.yml index 1238a97bcd..134ea4798f 100644 --- a/.github/workflows/all.yml +++ b/.github/workflows/all.yml @@ -2,6 +2,7 @@ name: CI on: + workflow_dispatch: # Allow the workflow to be triggered manually. # Trigger this workflow on push events, but only on master. push: branches: From 3dae6487343b4531c77d189d51e02cd255148e6c Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 11:03:01 -0700 Subject: [PATCH 452/709] Remove redundant push trigger. --- .github/workflows/all-c.yml | 7 +------ .github/workflows/all-cpp.yml | 7 +------ .github/workflows/all-non-target-specific.yml | 7 +------ .github/workflows/all-py.yml | 7 +------ .github/workflows/all-rs.yml | 7 +------ .github/workflows/all-ts.yml | 7 +------ .github/workflows/all.yml | 3 +-- 7 files changed, 7 insertions(+), 38 deletions(-) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index f5f00cad55..5a5d24e931 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -2,12 +2,7 @@ name: C on: - workflow_dispatch: # Allow the workflow to be triggered manually. - # Trigger this workflow on push events, but only on master. - push: - branches: - - master - # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + workflow_dispatch: pull_request: branches-ignore: - 'nightly' diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index e21492722d..5c1906bc31 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -2,12 +2,7 @@ name: Cpp on: - workflow_dispatch: # Allow the workflow to be triggered manually. - # Trigger this workflow on push events, but only on master. - push: - branches: - - master - # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + workflow_dispatch: pull_request: branches-ignore: - 'nightly' diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index d3a0ced5da..871b610446 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -2,12 +2,7 @@ name: Non-target-specific on: - workflow_dispatch: # Allow the workflow to be triggered manually. - # Trigger this workflow on push events, but only on master. - push: - branches: - - master - # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + workflow_dispatch: pull_request: paths-ignore: - 'org.lflang/src/org/lflang/generator/c/**' diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index 82a6f089c6..327a8a07b3 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -2,12 +2,7 @@ name: Python on: - workflow_dispatch: # Allow the workflow to be triggered manually. - # Trigger this workflow on push events, but only on master. - push: - branches: - - master - # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + workflow_dispatch: pull_request: branches-ignore: - 'nightly' diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index 13393cb2aa..d4a9a46966 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -2,12 +2,7 @@ name: Rust on: - workflow_dispatch: # Allow the workflow to be triggered manually. - # Trigger this workflow on push events, but only on master. - push: - branches: - - master - # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + workflow_dispatch: pull_request: branches-ignore: - 'nightly' diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index f14b1cfc0a..56174b1079 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -2,12 +2,7 @@ name: TypeScript on: - workflow_dispatch: # Allow the workflow to be triggered manually. - # Trigger this workflow on push events, but only on master. - push: - branches: - - master - # Trigger this workflow also on pull_request events, but ignore the 'nightly' branch. + workflow_dispatch: pull_request: branches-ignore: - 'nightly' diff --git a/.github/workflows/all.yml b/.github/workflows/all.yml index 134ea4798f..cf393ebaac 100644 --- a/.github/workflows/all.yml +++ b/.github/workflows/all.yml @@ -2,8 +2,7 @@ name: CI on: - workflow_dispatch: # Allow the workflow to be triggered manually. - # Trigger this workflow on push events, but only on master. + workflow_dispatch: push: branches: - master From 7e469a9c2f62fe939517322689bf25c9759e00d5 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 11:24:04 -0700 Subject: [PATCH 453/709] Remove incorrect comments. --- .github/workflows/all-c.yml | 1 - .github/workflows/all-cpp.yml | 1 - .github/workflows/all-non-target-specific.yml | 1 - .github/workflows/all-py.yml | 1 - .github/workflows/all-rs.yml | 1 - .github/workflows/all-ts.yml | 1 - 6 files changed, 6 deletions(-) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index 5a5d24e931..f0fdaa328e 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -1,4 +1,3 @@ -# Main workflow for testing the Lingua Franca compiler. name: C on: diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index 5c1906bc31..2138765523 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -1,4 +1,3 @@ -# Main workflow for testing the Lingua Franca compiler. name: Cpp on: diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 871b610446..a417009a4a 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,4 +1,3 @@ -# Main workflow for testing the Lingua Franca compiler. name: Non-target-specific on: diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index 327a8a07b3..87a8a150af 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -1,4 +1,3 @@ -# Main workflow for testing the Lingua Franca compiler. name: Python on: diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index d4a9a46966..06e52499c8 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -1,4 +1,3 @@ -# Main workflow for testing the Lingua Franca compiler. name: Rust on: diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index 56174b1079..f00935b93c 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -1,4 +1,3 @@ -# Main workflow for testing the Lingua Franca compiler. name: TypeScript on: From 4f5fa0f6f6ecce156330ba34f5efa522aef20709 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 18:05:47 -0700 Subject: [PATCH 454/709] Factor out of all-c.yml. --- .github/workflows/all-c.yml | 39 ++++++--------------------------- .github/workflows/only-c.yml | 40 ++++++++++++++++++++++++++++++++++ .github/workflows/only-cpp.yml | 0 .github/workflows/only-py.yml | 0 .github/workflows/only-rs.yml | 0 .github/workflows/only-ts.yml | 0 6 files changed, 47 insertions(+), 32 deletions(-) create mode 100644 .github/workflows/only-c.yml create mode 100644 .github/workflows/only-cpp.yml create mode 100644 .github/workflows/only-py.yml create mode 100644 .github/workflows/only-rs.yml create mode 100644 .github/workflows/only-ts.yml diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index f0fdaa328e..02a30e0753 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -9,6 +9,7 @@ on: - 'org.lflang/src/org/lflang/generator/c/**' - 'org.lflang/src/lib/c/**' - 'org.lflang/src/lib/platform/**' + - '**' # Delete me env: # 2020.11 @@ -17,7 +18,7 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml # Check that automatic code formatting works. # TODO: Uncomment after fed-gen is merged. @@ -27,44 +28,18 @@ jobs: # Run the unit tests. unit-tests: - uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml needs: cancel - # Run the C benchmark tests. - c-benchmark-tests: - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main - with: - target: 'C' - needs: cancel - - # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master - needs: cancel - - # Run the C Arduino integration tests. - c-arduino-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml@master - needs: cancel - - # Run the C Zephyr integration tests. - c-zephyr-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml@master - needs: cancel - - # Run the CCpp integration tests. - ccpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master - with: - use-cpp: true - needs: cancel + uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml # Run the Python integration tests. py-tests: - uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@master - needs: cancel + uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml + needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml new file mode 100644 index 0000000000..9073b51d7b --- /dev/null +++ b/.github/workflows/only-c.yml @@ -0,0 +1,40 @@ +name: C + +on: + workflow_dispatch: + pull_request: + branches-ignore: + - 'nightly' + paths: + - 'org.lflang/src/org/lflang/generator/c/**' + - 'org.lflang/src/lib/c/**' + - 'org.lflang/src/lib/platform/**' + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Run the C benchmark tests. + c-benchmark-tests: + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + with: + target: 'C' + + # Run the C integration tests. + c-tests: + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + + # Run the C Arduino integration tests. + c-arduino-tests: + uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml@master + + # Run the C Zephyr integration tests. + c-zephyr-tests: + uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml@master + + # Run the CCpp integration tests. + ccpp-tests: + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + with: + use-cpp: true diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml new file mode 100644 index 0000000000..e69de29bb2 diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml new file mode 100644 index 0000000000..e69de29bb2 diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml new file mode 100644 index 0000000000..e69de29bb2 diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml new file mode 100644 index 0000000000..e69de29bb2 From b180129c5828f395e7ca67dc63fab8aef04edaeb Mon Sep 17 00:00:00 2001 From: Peter Donovan <33707478+petervdonovan@users.noreply.github.com> Date: Tue, 23 May 2023 18:07:50 -0700 Subject: [PATCH 455/709] Apply suggestions from code review Co-authored-by: Marten Lohstroh --- .github/workflows/all-c.yml | 2 +- .github/workflows/all-cpp.yml | 2 +- .github/workflows/all-non-target-specific.yml | 2 +- .github/workflows/all-py.yml | 2 +- .github/workflows/all-rs.yml | 2 +- .github/workflows/all-ts.yml | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index 02a30e0753..35f68165bd 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -1,4 +1,4 @@ -name: C +name: C-based tests on: workflow_dispatch: diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index 2138765523..0c960a0b48 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -1,4 +1,4 @@ -name: Cpp +name: Cpp-based tests on: workflow_dispatch: diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index a417009a4a..43293b40eb 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,4 +1,4 @@ -name: Non-target-specific +name: Non-target-specific tests on: workflow_dispatch: diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index 87a8a150af..ae216866a9 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -1,4 +1,4 @@ -name: Python +name: Python-based tests on: workflow_dispatch: diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index 06e52499c8..ab4eb747f1 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -1,4 +1,4 @@ -name: Rust +name: Rust-based tests on: workflow_dispatch: diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index f00935b93c..ccdcd48469 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -1,4 +1,4 @@ -name: TypeScript +name: TypeScript-based tests on: workflow_dispatch: From 7ddbe6c33d65c3196e11889164293418d461cb5d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 18:30:44 -0700 Subject: [PATCH 456/709] Reduce duplication. --- .github/workflows/all-c.yml | 9 ++----- .github/workflows/all-cpp.yml | 25 +++---------------- .github/workflows/all-non-target-specific.yml | 6 ----- .github/workflows/all-py.yml | 13 +++------- .github/workflows/all-rs.yml | 20 +++------------ .github/workflows/all-ts.yml | 13 +++------- .github/workflows/only-c.yml | 15 +++-------- .github/workflows/only-cpp.yml | 23 +++++++++++++++++ .github/workflows/only-py.yml | 13 ++++++++++ .github/workflows/only-rs.yml | 19 ++++++++++++++ .github/workflows/only-ts.yml | 13 ++++++++++ 11 files changed, 86 insertions(+), 83 deletions(-) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index 35f68165bd..e84b209438 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -20,19 +20,14 @@ jobs: cancel: uses: lf-lang/lingua-franca/.github/workflows/cancel.yml -# Check that automatic code formatting works. -# TODO: Uncomment after fed-gen is merged. -# format: -# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master -# needs: cancel - # Run the unit tests. unit-tests: uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml needs: cancel c-tests: - uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml + uses: lf-lang/lingua-franca/.github/workflows/only-c.yml + needs: cancel # Run the Python integration tests. py-tests: diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index 0c960a0b48..cf9f37572b 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -16,32 +16,13 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml -# Check that automatic code formatting works. -# TODO: Uncomment after fed-gen is merged. -# format: -# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master -# needs: cancel - - # Run the C++ benchmark tests. - cpp-benchmark-tests: - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main - with: - target: 'Cpp' - needs: cancel - - # Run the C++ integration tests. cpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/cpp-tests.yml@master - needs: cancel - - # Run the C++ integration tests on ROS2. - cpp-ros2-tests: - uses: lf-lang/lingua-franca/.github/workflows/cpp-ros2-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/only-cpp.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 43293b40eb..faa6c04b49 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -35,12 +35,6 @@ jobs: uses: lf-lang/lingua-franca/.github/workflows/build-trace-tools.yml@master needs: cancel -# Check that automatic code formatting works. -# TODO: Uncomment after fed-gen is merged. -# format: -# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master -# needs: cancel - # Run the unit tests. unit-tests: uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml@master diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index ae216866a9..ab0de0d3ea 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -16,20 +16,13 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml -# Check that automatic code formatting works. -# TODO: Uncomment after fed-gen is merged. -# format: -# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master -# needs: cancel - - # Run the Python integration tests. py-tests: - uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/only-py.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index ab4eb747f1..80ee654996 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -16,27 +16,13 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml -# Check that automatic code formatting works. -# TODO: Uncomment after fed-gen is merged. -# format: -# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master -# needs: cancel - - # Run the Rust integration tests. rs-tests: - uses: lf-lang/lingua-franca/.github/workflows/rs-tests.yml@master - needs: cancel - - # Run the Rust benchmark tests. - rs-benchmark-tests: - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main - with: - target: 'Rust' + uses: lf-lang/lingua-franca/.github/workflows/only-rs.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index ccdcd48469..1c0faf75af 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -16,20 +16,13 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + uses: lf-lang/lingua-franca/.github/workflows/cancel.yml -# Check that automatic code formatting works. -# TODO: Uncomment after fed-gen is merged. -# format: -# uses: lf-lang/lingua-franca/.github/workflows/format.yml@master -# needs: cancel - - # Run the TypeScript integration tests. ts-tests: - uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/only-ts.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 9073b51d7b..a48561a463 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -2,13 +2,6 @@ name: C on: workflow_dispatch: - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/c/**' - - 'org.lflang/src/lib/c/**' - - 'org.lflang/src/lib/platform/**' env: # 2020.11 @@ -23,18 +16,18 @@ jobs: # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml # Run the C Arduino integration tests. c-arduino-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml # Run the C Zephyr integration tests. c-zephyr-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml # Run the CCpp integration tests. ccpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml with: use-cpp: true diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index e69de29bb2..ef0fa0de32 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -0,0 +1,23 @@ +name: C++ + +on: + workflow_dispatch: + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Run the C++ benchmark tests. + cpp-benchmark-tests: + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + with: + target: 'Cpp' + + # Run the C++ integration tests. + cpp-tests: + uses: lf-lang/lingua-franca/.github/workflows/cpp-tests.yml + + # Run the C++ integration tests on ROS2. + cpp-ros2-tests: + uses: lf-lang/lingua-franca/.github/workflows/cpp-ros2-tests.yml diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index e69de29bb2..e03d967278 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -0,0 +1,13 @@ +name: Python + +on: + workflow_dispatch: + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Run the Python integration tests. + py-tests: + uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index e69de29bb2..abd885ba49 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -0,0 +1,19 @@ +name: Rust + +on: + workflow_dispatch: + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Run the Rust integration tests. + rs-tests: + uses: lf-lang/lingua-franca/.github/workflows/rs-tests.yml + + # Run the Rust benchmark tests. + rs-benchmark-tests: + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + with: + target: 'Rust' diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index e69de29bb2..2a9b93140a 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -0,0 +1,13 @@ +name: Rust + +on: + workflow_dispatch: + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + # Run the TypeScript integration tests. + ts-tests: + uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml From 366599e09cc632fc90354f96a0d43a2d6eb1ad2a Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 18:52:42 -0700 Subject: [PATCH 457/709] Try again to make workflow files valid. --- .github/actions/build-rti-docker/action.yml | 4 +-- .github/actions/install-rti/action.yml | 3 +- .github/actions/setup-zephyr/action.yml | 4 +-- .github/workflows/all-c.yml | 10 +++--- .github/workflows/all-cpp.yml | 8 ++--- .github/workflows/all-non-target-specific.yml | 14 ++++---- .github/workflows/all-py.yml | 6 ++-- .github/workflows/all-rs.yml | 6 ++-- .github/workflows/all-ts.yml | 6 ++-- .github/workflows/all.yml | 34 +++++++++---------- .github/workflows/cancel.yml | 2 +- .github/workflows/nightly-build.yml | 2 +- .github/workflows/only-c.yml | 9 ++--- .github/workflows/only-cpp.yml | 5 +-- .github/workflows/only-py.yml | 3 +- .github/workflows/only-rs.yml | 3 +- .github/workflows/only-ts.yml | 3 +- build.gradle | 2 +- org.lflang/src/lib/c/reactor-c | 2 +- 19 files changed, 65 insertions(+), 61 deletions(-) diff --git a/.github/actions/build-rti-docker/action.yml b/.github/actions/build-rti-docker/action.yml index a44afd8375..643f726181 100644 --- a/.github/actions/build-rti-docker/action.yml +++ b/.github/actions/build-rti-docker/action.yml @@ -2,6 +2,6 @@ name: Build RTI docker image description: Build and install runs: using: "composite" - steps: + steps: - run: .github/actions/build-rti-docker/build-rti-image.sh - shell: bash \ No newline at end of file + shell: bash diff --git a/.github/actions/install-rti/action.yml b/.github/actions/install-rti/action.yml index 65b55b8e3b..895daf26b6 100644 --- a/.github/actions/install-rti/action.yml +++ b/.github/actions/install-rti/action.yml @@ -2,7 +2,6 @@ name: Install RTI description: Build and install runs: using: "composite" - steps: + steps: - run: .github/actions/install-rti/install.sh shell: bash - \ No newline at end of file diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 7d835049dc..e77ac6c0e4 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -4,7 +4,7 @@ runs: using: "composite" steps: - name: Dependencies - run: | + run: | sudo apt-get update && sudo apt-get upgrade sudo apt-get install -y --no-install-recommends git cmake ninja-build gperf \ ccache dfu-util device-tree-compiler wget \ @@ -32,4 +32,4 @@ runs: pip install -r zephyr/scripts/requirements.txt echo "ZEPHYR_BASE=$HOME/zephyrproject/zephyr" >> $GITHUB_ENV echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-0.15.2/" >> $GITHUB_ENV - shell: bash \ No newline at end of file + shell: bash diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index e84b209438..b946cfe66e 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -18,23 +18,23 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml + uses: ./.github/workflows/cancel.yml # Run the unit tests. unit-tests: - uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml + uses: ./.github/workflows/unit-tests.yml needs: cancel c-tests: - uses: lf-lang/lingua-franca/.github/workflows/only-c.yml + uses: ./.github/workflows/only-c.yml needs: cancel # Run the Python integration tests. py-tests: - uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml + uses: ./.github/workflows/py-tests.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml + uses: ./.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index cf9f37572b..f1bc279024 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -1,4 +1,4 @@ -name: Cpp-based tests +name: Cpp-based tests on: workflow_dispatch: @@ -16,13 +16,13 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml + uses: ./.github/workflows/cancel.yml cpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/only-cpp.yml + uses: ./.github/workflows/only-cpp.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml + uses: ./.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index faa6c04b49..49bd93dfcc 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -23,34 +23,34 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + uses: ./.github/workflows/cancel.yml # Test the Gradle build. build: - uses: lf-lang/lingua-franca/.github/workflows/build.yml@master + uses: ./.github/workflows/build.yml needs: cancel # Build the tools used for processing execution traces build-tracing-tools: - uses: lf-lang/lingua-franca/.github/workflows/build-trace-tools.yml@master + uses: ./.github/workflows/build-trace-tools.yml needs: cancel # Run the unit tests. unit-tests: - uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml@master + uses: ./.github/workflows/unit-tests.yml needs: cancel # Run tests for the standalone compiler. cli-tests: - uses: lf-lang/lingua-franca/.github/workflows/cli-tests.yml@master + uses: ./.github/workflows/cli-tests.yml needs: cancel # Run language server tests. lsp-tests: - uses: lf-lang/lingua-franca/.github/workflows/lsp-tests.yml@master + uses: ./.github/workflows/lsp-tests.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: ./.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index ab0de0d3ea..539040f8a5 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -16,13 +16,13 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml + uses: ./.github/workflows/cancel.yml py-tests: - uses: lf-lang/lingua-franca/.github/workflows/only-py.yml + uses: ./.github/workflows/only-py.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml + uses: ./.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index 80ee654996..80c10912ce 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -16,13 +16,13 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml + uses: ./.github/workflows/cancel.yml rs-tests: - uses: lf-lang/lingua-franca/.github/workflows/only-rs.yml + uses: ./.github/workflows/only-rs.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml + uses: ./.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index 1c0faf75af..3687187a83 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -16,13 +16,13 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml + uses: ./.github/workflows/cancel.yml ts-tests: - uses: lf-lang/lingua-franca/.github/workflows/only-ts.yml + uses: ./.github/workflows/only-ts.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml + uses: ./.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/all.yml b/.github/workflows/all.yml index cf393ebaac..3ca846d2ad 100644 --- a/.github/workflows/all.yml +++ b/.github/workflows/all.yml @@ -14,30 +14,30 @@ env: jobs: # Cancel previous workflow runs. cancel: - uses: lf-lang/lingua-franca/.github/workflows/cancel.yml@master + uses: ./.github/workflows/cancel.yml # Test the Gradle build. build: - uses: lf-lang/lingua-franca/.github/workflows/build.yml@master + uses: ./.github/workflows/build.yml needs: cancel # Build the tools used for processing execution traces build-tracing-tools: - uses: lf-lang/lingua-franca/.github/workflows/build-trace-tools.yml@master + uses: ./.github/workflows/build-trace-tools.yml needs: cancel check-format: - uses: lf-lang/lingua-franca/.github/workflows/check-format.yml@master + uses: ./.github/workflows/check-format.yml needs: cancel # Run the unit tests. unit-tests: - uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml@master + uses: ./.github/workflows/unit-tests.yml needs: cancel # Run tests for the standalone compiler. cli-tests: - uses: lf-lang/lingua-franca/.github/workflows/cli-tests.yml@master + uses: ./.github/workflows/cli-tests.yml needs: cancel # Run the C benchmark tests. @@ -49,27 +49,27 @@ jobs: # Run language server tests. lsp-tests: - uses: lf-lang/lingua-franca/.github/workflows/lsp-tests.yml@master + uses: ./.github/workflows/lsp-tests.yml needs: cancel # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: ./.github/workflows/c-tests.yml needs: cancel # Run the C Arduino integration tests. c-arduino-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml@master + uses: ./.github/workflows/c-arduino-tests.yml needs: cancel # Run the C Zephyr integration tests. c-zephyr-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml@master + uses: ./.github/workflows/c-zephyr-tests.yml needs: cancel # Run the CCpp integration tests. ccpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: ./.github/workflows/c-tests.yml with: use-cpp: true needs: cancel @@ -83,22 +83,22 @@ jobs: # Run the C++ integration tests. cpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/cpp-tests.yml@master + uses: ./.github/workflows/cpp-tests.yml needs: cancel # Run the C++ integration tests on ROS2. cpp-ros2-tests: - uses: lf-lang/lingua-franca/.github/workflows/cpp-ros2-tests.yml@master + uses: ./.github/workflows/cpp-ros2-tests.yml needs: cancel # Run the Python integration tests. py-tests: - uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@master + uses: ./.github/workflows/py-tests.yml needs: cancel # Run the Rust integration tests. rs-tests: - uses: lf-lang/lingua-franca/.github/workflows/rs-tests.yml@master + uses: ./.github/workflows/rs-tests.yml needs: cancel # Run the Rust benchmark tests. @@ -110,10 +110,10 @@ jobs: # Run the TypeScript integration tests. ts-tests: - uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml@master + uses: ./.github/workflows/ts-tests.yml needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: ./.github/workflows/serialization-tests.yml needs: cancel diff --git a/.github/workflows/cancel.yml b/.github/workflows/cancel.yml index 00733bb5b8..49765257c9 100644 --- a/.github/workflows/cancel.yml +++ b/.github/workflows/cancel.yml @@ -2,7 +2,7 @@ name: Cancel previous jobs on: workflow_call: - + jobs: cancel: name: run diff --git a/.github/workflows/nightly-build.yml b/.github/workflows/nightly-build.yml index d79d88be82..9ffb82c581 100644 --- a/.github/workflows/nightly-build.yml +++ b/.github/workflows/nightly-build.yml @@ -8,7 +8,7 @@ on: jobs: build: - uses: lf-lang/lingua-franca/.github/workflows/build.yml@master + uses: ./.github/workflows/build.yml with: nightly: true secrets: diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index a48561a463..f360a8525e 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -2,6 +2,7 @@ name: C on: workflow_dispatch: + workflow_call: env: # 2020.11 @@ -16,18 +17,18 @@ jobs: # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml + uses: ./.github/workflows/c-tests.yml # Run the C Arduino integration tests. c-arduino-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml + uses: ./.github/workflows/c-arduino-tests.yml # Run the C Zephyr integration tests. c-zephyr-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml + uses: ./.github/workflows/c-zephyr-tests.yml # Run the CCpp integration tests. ccpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml + uses: ./.github/workflows/c-tests.yml with: use-cpp: true diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index ef0fa0de32..ecedfd52b8 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -2,6 +2,7 @@ name: C++ on: workflow_dispatch: + workflow_call: env: # 2020.11 @@ -16,8 +17,8 @@ jobs: # Run the C++ integration tests. cpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/cpp-tests.yml + uses: ./.github/workflows/cpp-tests.yml # Run the C++ integration tests on ROS2. cpp-ros2-tests: - uses: lf-lang/lingua-franca/.github/workflows/cpp-ros2-tests.yml + uses: ./.github/workflows/cpp-ros2-tests.yml diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index e03d967278..b595502b21 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -2,6 +2,7 @@ name: Python on: workflow_dispatch: + workflow_call: env: # 2020.11 @@ -10,4 +11,4 @@ env: jobs: # Run the Python integration tests. py-tests: - uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml + uses: ./.github/workflows/py-tests.yml diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index abd885ba49..dc5fce56ba 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -2,6 +2,7 @@ name: Rust on: workflow_dispatch: + workflow_call: env: # 2020.11 @@ -10,7 +11,7 @@ env: jobs: # Run the Rust integration tests. rs-tests: - uses: lf-lang/lingua-franca/.github/workflows/rs-tests.yml + uses: ./.github/workflows/rs-tests.yml # Run the Rust benchmark tests. rs-benchmark-tests: diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 2a9b93140a..4f2b176d1f 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -2,6 +2,7 @@ name: Rust on: workflow_dispatch: + workflow_call: env: # 2020.11 @@ -10,4 +11,4 @@ env: jobs: # Run the TypeScript integration tests. ts-tests: - uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml + uses: ./.github/workflows/ts-tests.yml diff --git a/build.gradle b/build.gradle index 563377e3d3..f1ddbf9b96 100644 --- a/build.gradle +++ b/build.gradle @@ -92,7 +92,7 @@ spotless { format 'misc', { // define the files to apply `misc` to - target '*.gradle', '*.md', '.gitignore' + target '*.gradle', '*.md', '.gitignore', '**/*.yml' // define the steps to apply to those files trimTrailingWhitespace() diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 880fb34310..83b1cef7fd 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 880fb343109d150cd853208c368641863050df4f +Subproject commit 83b1cef7fd4209b3e25b6a310ce8f964277d9692 From 0b157b05bee8bd033a6a5067d4d4526f7c687002 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 19:22:54 -0700 Subject: [PATCH 458/709] Reuse the other workflows in all.yml. --- .github/workflows/all-non-target-specific.yml | 1 + .github/workflows/all.yml | 94 +++---------------- 2 files changed, 14 insertions(+), 81 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 49bd93dfcc..ff9ae06b13 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -2,6 +2,7 @@ name: Non-target-specific tests on: workflow_dispatch: + workflow_call: pull_request: paths-ignore: - 'org.lflang/src/org/lflang/generator/c/**' diff --git a/.github/workflows/all.yml b/.github/workflows/all.yml index 3ca846d2ad..10042c135a 100644 --- a/.github/workflows/all.yml +++ b/.github/workflows/all.yml @@ -16,104 +16,36 @@ jobs: cancel: uses: ./.github/workflows/cancel.yml - # Test the Gradle build. - build: - uses: ./.github/workflows/build.yml - needs: cancel - - # Build the tools used for processing execution traces - build-tracing-tools: - uses: ./.github/workflows/build-trace-tools.yml - needs: cancel - check-format: uses: ./.github/workflows/check-format.yml needs: cancel - # Run the unit tests. - unit-tests: - uses: ./.github/workflows/unit-tests.yml - needs: cancel - - # Run tests for the standalone compiler. - cli-tests: - uses: ./.github/workflows/cli-tests.yml + # Run the non-target-specific tests. + non-target-specific: + uses: ./.github/workflows/all-non-target-specific.yml needs: cancel - # Run the C benchmark tests. - c-benchmark-tests: - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main - with: - target: 'C' - needs: cancel - - # Run language server tests. - lsp-tests: - uses: ./.github/workflows/lsp-tests.yml - needs: cancel - - # Run the C integration tests. + # Run the C tests. c-tests: - uses: ./.github/workflows/c-tests.yml - needs: cancel - - # Run the C Arduino integration tests. - c-arduino-tests: - uses: ./.github/workflows/c-arduino-tests.yml + uses: ./.github/workflows/only-c.yml needs: cancel - # Run the C Zephyr integration tests. - c-zephyr-tests: - uses: ./.github/workflows/c-zephyr-tests.yml - needs: cancel - - # Run the CCpp integration tests. - ccpp-tests: - uses: ./.github/workflows/c-tests.yml - with: - use-cpp: true - needs: cancel - - # Run the C++ benchmark tests. - cpp-benchmark-tests: - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main - with: - target: 'Cpp' - needs: cancel - - # Run the C++ integration tests. + # Run the C++ tests. cpp-tests: - uses: ./.github/workflows/cpp-tests.yml + uses: ./.github/workflows/only-cpp.yml needs: cancel - # Run the C++ integration tests on ROS2. - cpp-ros2-tests: - uses: ./.github/workflows/cpp-ros2-tests.yml - needs: cancel - - # Run the Python integration tests. + # Run the Python tests. py-tests: - uses: ./.github/workflows/py-tests.yml + uses: ./.github/workflows/only-py.yml needs: cancel - # Run the Rust integration tests. + # Run the Rust tests. rs-tests: - uses: ./.github/workflows/rs-tests.yml - needs: cancel - - # Run the Rust benchmark tests. - rs-benchmark-tests: - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main - with: - target: 'Rust' + uses: ./.github/workflows/only-rs.yml needs: cancel - # Run the TypeScript integration tests. + # Run the TypeScript tests. ts-tests: - uses: ./.github/workflows/ts-tests.yml - needs: cancel - - # Run the serialization tests - serialization-tests: - uses: ./.github/workflows/serialization-tests.yml + uses: ./.github/workflows/only-ts.yml needs: cancel From ce0d66cf82513d15e8f9f02a935b90508c928773 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 21:16:50 -0700 Subject: [PATCH 459/709] Remove tests from non-target-specific. These tests are already in the target-specific tests. --- .github/workflows/all-non-target-specific.yml | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index ff9ae06b13..e11cc82cf5 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -36,11 +36,6 @@ jobs: uses: ./.github/workflows/build-trace-tools.yml needs: cancel - # Run the unit tests. - unit-tests: - uses: ./.github/workflows/unit-tests.yml - needs: cancel - # Run tests for the standalone compiler. cli-tests: uses: ./.github/workflows/cli-tests.yml @@ -50,8 +45,3 @@ jobs: lsp-tests: uses: ./.github/workflows/lsp-tests.yml needs: cancel - - # Run the serialization tests - serialization-tests: - uses: ./.github/workflows/serialization-tests.yml - needs: cancel From ac2bf54c2fb383fd6e6d64b0d713cf854f5240be Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 23 May 2023 22:25:47 -0700 Subject: [PATCH 460/709] Do not run multiple instances of same job at once. Multiple instances on different refs can run at once, but on on the same ref. --- .github/workflows/all-c.yml | 5 ++++- .github/workflows/all-cpp.yml | 4 ++++ .github/workflows/all-non-target-specific.yml | 4 ++++ .github/workflows/all-py.yml | 4 ++++ .github/workflows/all-rs.yml | 4 ++++ .github/workflows/all-ts.yml | 4 ++++ .github/workflows/build-trace-tools.yml | 4 ++++ .github/workflows/build.yml | 4 ++++ .github/workflows/c-arduino-tests.yml | 4 ++++ .github/workflows/c-tests.yml | 4 ++++ .github/workflows/c-zephyr-tests.yml | 4 ++++ .github/workflows/check-format.yml | 4 ++++ .github/workflows/cli-tests.yml | 4 ++++ .github/workflows/cpp-ros2-tests.yml | 5 +++++ .github/workflows/cpp-tests.yml | 5 +++++ .github/workflows/lsp-tests.yml | 4 ++++ .github/workflows/nightly-build.yml | 4 ++++ .github/workflows/only-c.yml | 4 ++++ .github/workflows/only-cpp.yml | 4 ++++ .github/workflows/only-py.yml | 4 ++++ .github/workflows/only-rs.yml | 4 ++++ .github/workflows/only-ts.yml | 4 ++++ .github/workflows/py-tests.yml | 4 ++++ .github/workflows/rs-tests.yml | 4 ++++ .github/workflows/serialization-tests.yml | 4 ++++ .github/workflows/ts-tests.yml | 4 ++++ .github/workflows/unit-tests.yml | 4 ++++ 27 files changed, 110 insertions(+), 1 deletion(-) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml index b946cfe66e..7249009852 100644 --- a/.github/workflows/all-c.yml +++ b/.github/workflows/all-c.yml @@ -9,7 +9,10 @@ on: - 'org.lflang/src/org/lflang/generator/c/**' - 'org.lflang/src/lib/c/**' - 'org.lflang/src/lib/platform/**' - - '**' # Delete me + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} env: # 2020.11 diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml index f1bc279024..c9b207d72e 100644 --- a/.github/workflows/all-cpp.yml +++ b/.github/workflows/all-cpp.yml @@ -9,6 +9,10 @@ on: - 'org.lflang/src/org/lflang/generator/cpp/**' - 'org.lflang/src/lib/cpp/**' +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index e11cc82cf5..db05bd982f 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -17,6 +17,10 @@ on: - 'org.lflang/src/lib/rs/**' - 'org.lflang/src/lib/ts/**' +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml index 539040f8a5..40b9250a7a 100644 --- a/.github/workflows/all-py.yml +++ b/.github/workflows/all-py.yml @@ -9,6 +9,10 @@ on: - 'org.lflang/src/org/lflang/generator/python/**' - 'org.lflang/src/lib/py/**' +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/all-rs.yml b/.github/workflows/all-rs.yml index 80c10912ce..3328c27d72 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/all-rs.yml @@ -9,6 +9,10 @@ on: - 'org.lflang/src/org/lflang/generator/rust/**' - 'org.lflang/src/lib/rs/**' +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml index 3687187a83..1e4e9edbd7 100644 --- a/.github/workflows/all-ts.yml +++ b/.github/workflows/all-ts.yml @@ -9,6 +9,10 @@ on: - 'org.lflang/src/org/lflang/generator/ts/**' - 'org.lflang/src/lib/ts/**' +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/build-trace-tools.yml b/.github/workflows/build-trace-tools.yml index 2490e9b75e..bd69f7be68 100644 --- a/.github/workflows/build-trace-tools.yml +++ b/.github/workflows/build-trace-tools.yml @@ -3,6 +3,10 @@ name: Build the tools for processing execution traces on: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 767df01fa1..2417cece56 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -12,6 +12,10 @@ on: required: false workflow_dispatch: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: runs-on: ubuntu-latest diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 167e8f6f1c..8c77d6e52d 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -17,6 +17,10 @@ on: required: false type: string +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 0764128a1b..c29b3c0a61 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -17,6 +17,10 @@ on: required: false type: string +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 3b7a76feee..49f204bb44 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -17,6 +17,10 @@ on: required: false type: string +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: runs-on: ubuntu-latest diff --git a/.github/workflows/check-format.yml b/.github/workflows/check-format.yml index 8c022f90a5..8fc44a98df 100644 --- a/.github/workflows/check-format.yml +++ b/.github/workflows/check-format.yml @@ -3,6 +3,10 @@ name: Spotless check on: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: runs-on: ubuntu-latest diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 056e32c04c..3d23f0bd9f 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -3,6 +3,10 @@ name: CLI tests on: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/cpp-ros2-tests.yml b/.github/workflows/cpp-ros2-tests.yml index bfb3e12cb8..c81ca59f02 100644 --- a/.github/workflows/cpp-ros2-tests.yml +++ b/.github/workflows/cpp-ros2-tests.yml @@ -9,6 +9,11 @@ on: runtime-ref: required: false type: string + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: runs-on: ubuntu-latest diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index 3fe74ae393..e3f957ab2d 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -9,6 +9,11 @@ on: runtime-ref: required: false type: string + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index bf32254b0f..7418bde69d 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -3,6 +3,10 @@ name: Language server tests on: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/nightly-build.yml b/.github/workflows/nightly-build.yml index 9ffb82c581..469e9dc600 100644 --- a/.github/workflows/nightly-build.yml +++ b/.github/workflows/nightly-build.yml @@ -6,6 +6,10 @@ on: - cron: '0 5 * * *' workflow_dispatch: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: build: uses: ./.github/workflows/build.yml diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index f360a8525e..530e3e2aca 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -4,6 +4,10 @@ on: workflow_dispatch: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index ecedfd52b8..23cdc4b117 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -4,6 +4,10 @@ on: workflow_dispatch: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index b595502b21..809c4cf4ed 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -4,6 +4,10 @@ on: workflow_dispatch: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index dc5fce56ba..bd9efc79d7 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -4,6 +4,10 @@ on: workflow_dispatch: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 4f2b176d1f..63d0eb77ac 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -4,6 +4,10 @@ on: workflow_dispatch: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index 3f6e521fd1..c65e8fe27b 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -13,6 +13,10 @@ on: required: false type: string +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index 720efaa29c..e8d30dbfee 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -16,6 +16,10 @@ on: required: false type: string +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 89f1ad735c..8aadae65b7 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -7,6 +7,10 @@ on: required: false type: string +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: runs-on: ubuntu-latest diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 4342082868..3ca800349c 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -3,6 +3,10 @@ name: TypeScript tests on: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 1caec5c1ac..331627e262 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -3,6 +3,10 @@ name: Unit tests on: workflow_call: +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: run: strategy: From 896bd6533688f9be9eba2ea246f1dbf6e0c4b84d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 11:12:25 -0700 Subject: [PATCH 461/709] Address the redundancy problem. --- .github/workflows/all-c.yml | 43 ---------------- .github/workflows/all-cpp.yml | 32 ------------ .github/workflows/all-py.yml | 32 ------------ .github/workflows/all-ts.yml | 32 ------------ .github/workflows/all.yml | 51 ------------------- ...c.yml => non-target-specific-extended.yml} | 2 +- .../{all-rs.yml => non-target-specific.yml} | 18 ++----- .github/workflows/only-c.yml | 7 +++ .github/workflows/only-cpp.yml | 6 +++ .github/workflows/only-py.yml | 6 +++ .github/workflows/only-rs.yml | 6 +++ .github/workflows/only-ts.yml | 6 +++ 12 files changed, 37 insertions(+), 204 deletions(-) delete mode 100644 .github/workflows/all-c.yml delete mode 100644 .github/workflows/all-cpp.yml delete mode 100644 .github/workflows/all-py.yml delete mode 100644 .github/workflows/all-ts.yml delete mode 100644 .github/workflows/all.yml rename .github/workflows/{all-non-target-specific.yml => non-target-specific-extended.yml} (96%) rename .github/workflows/{all-rs.yml => non-target-specific.yml} (54%) diff --git a/.github/workflows/all-c.yml b/.github/workflows/all-c.yml deleted file mode 100644 index 7249009852..0000000000 --- a/.github/workflows/all-c.yml +++ /dev/null @@ -1,43 +0,0 @@ -name: C-based tests - -on: - workflow_dispatch: - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/c/**' - - 'org.lflang/src/lib/c/**' - - 'org.lflang/src/lib/platform/**' - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - -env: - # 2020.11 - vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 - -jobs: - # Cancel previous workflow runs. - cancel: - uses: ./.github/workflows/cancel.yml - - # Run the unit tests. - unit-tests: - uses: ./.github/workflows/unit-tests.yml - needs: cancel - - c-tests: - uses: ./.github/workflows/only-c.yml - needs: cancel - - # Run the Python integration tests. - py-tests: - uses: ./.github/workflows/py-tests.yml - needs: cancel - - # Run the serialization tests - serialization-tests: - uses: ./.github/workflows/serialization-tests.yml - needs: cancel diff --git a/.github/workflows/all-cpp.yml b/.github/workflows/all-cpp.yml deleted file mode 100644 index c9b207d72e..0000000000 --- a/.github/workflows/all-cpp.yml +++ /dev/null @@ -1,32 +0,0 @@ -name: Cpp-based tests - -on: - workflow_dispatch: - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/cpp/**' - - 'org.lflang/src/lib/cpp/**' - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - -env: - # 2020.11 - vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 - -jobs: - # Cancel previous workflow runs. - cancel: - uses: ./.github/workflows/cancel.yml - - cpp-tests: - uses: ./.github/workflows/only-cpp.yml - needs: cancel - - # Run the serialization tests - serialization-tests: - uses: ./.github/workflows/serialization-tests.yml - needs: cancel diff --git a/.github/workflows/all-py.yml b/.github/workflows/all-py.yml deleted file mode 100644 index 40b9250a7a..0000000000 --- a/.github/workflows/all-py.yml +++ /dev/null @@ -1,32 +0,0 @@ -name: Python-based tests - -on: - workflow_dispatch: - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/python/**' - - 'org.lflang/src/lib/py/**' - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - -env: - # 2020.11 - vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 - -jobs: - # Cancel previous workflow runs. - cancel: - uses: ./.github/workflows/cancel.yml - - py-tests: - uses: ./.github/workflows/only-py.yml - needs: cancel - - # Run the serialization tests - serialization-tests: - uses: ./.github/workflows/serialization-tests.yml - needs: cancel diff --git a/.github/workflows/all-ts.yml b/.github/workflows/all-ts.yml deleted file mode 100644 index 1e4e9edbd7..0000000000 --- a/.github/workflows/all-ts.yml +++ /dev/null @@ -1,32 +0,0 @@ -name: TypeScript-based tests - -on: - workflow_dispatch: - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/ts/**' - - 'org.lflang/src/lib/ts/**' - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - -env: - # 2020.11 - vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 - -jobs: - # Cancel previous workflow runs. - cancel: - uses: ./.github/workflows/cancel.yml - - ts-tests: - uses: ./.github/workflows/only-ts.yml - needs: cancel - - # Run the serialization tests - serialization-tests: - uses: ./.github/workflows/serialization-tests.yml - needs: cancel diff --git a/.github/workflows/all.yml b/.github/workflows/all.yml deleted file mode 100644 index 10042c135a..0000000000 --- a/.github/workflows/all.yml +++ /dev/null @@ -1,51 +0,0 @@ -# Main workflow for testing the Lingua Franca compiler. -name: CI - -on: - workflow_dispatch: - push: - branches: - - master - -env: - # 2020.11 - vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 - -jobs: - # Cancel previous workflow runs. - cancel: - uses: ./.github/workflows/cancel.yml - - check-format: - uses: ./.github/workflows/check-format.yml - needs: cancel - - # Run the non-target-specific tests. - non-target-specific: - uses: ./.github/workflows/all-non-target-specific.yml - needs: cancel - - # Run the C tests. - c-tests: - uses: ./.github/workflows/only-c.yml - needs: cancel - - # Run the C++ tests. - cpp-tests: - uses: ./.github/workflows/only-cpp.yml - needs: cancel - - # Run the Python tests. - py-tests: - uses: ./.github/workflows/only-py.yml - needs: cancel - - # Run the Rust tests. - rs-tests: - uses: ./.github/workflows/only-rs.yml - needs: cancel - - # Run the TypeScript tests. - ts-tests: - uses: ./.github/workflows/only-ts.yml - needs: cancel diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/non-target-specific-extended.yml similarity index 96% rename from .github/workflows/all-non-target-specific.yml rename to .github/workflows/non-target-specific-extended.yml index db05bd982f..63571ae210 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -1,4 +1,4 @@ -name: Non-target-specific tests +name: Additional non-target-specific tests on: workflow_dispatch: diff --git a/.github/workflows/all-rs.yml b/.github/workflows/non-target-specific.yml similarity index 54% rename from .github/workflows/all-rs.yml rename to .github/workflows/non-target-specific.yml index 3328c27d72..cdf5762eea 100644 --- a/.github/workflows/all-rs.yml +++ b/.github/workflows/non-target-specific.yml @@ -1,13 +1,10 @@ -name: Rust-based tests +name: Non-target-specific tests on: workflow_dispatch: pull_request: branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/rust/**' - - 'org.lflang/src/lib/rs/**' + - 'nightly' concurrency: group: ${{ github.workflow }}-${{ github.ref }} @@ -18,15 +15,10 @@ env: vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 jobs: - # Cancel previous workflow runs. - cancel: - uses: ./.github/workflows/cancel.yml - - rs-tests: - uses: ./.github/workflows/only-rs.yml - needs: cancel + # Run the unit tests. + unit-tests: + uses: ./.github/workflows/unit-tests.yml # Run the serialization tests serialization-tests: uses: ./.github/workflows/serialization-tests.yml - needs: cancel diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 530e3e2aca..f59f2c151b 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -3,6 +3,13 @@ name: C on: workflow_dispatch: workflow_call: + pull_request: + branches-ignore: + - 'nightly' + paths: + - 'org.lflang/src/org/lflang/generator/c/**' + - 'org.lflang/src/lib/c/**' + - 'org.lflang/src/lib/platform/**' concurrency: group: ${{ github.workflow }}-${{ github.ref }} diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index 23cdc4b117..c7a36cb1a3 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -3,6 +3,12 @@ name: C++ on: workflow_dispatch: workflow_call: + pull_request: + branches-ignore: + - 'nightly' + paths: + - 'org.lflang/src/org/lflang/generator/cpp/**' + - 'org.lflang/src/lib/cpp/**' concurrency: group: ${{ github.workflow }}-${{ github.ref }} diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index 809c4cf4ed..0c5f2ed4c9 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -3,6 +3,12 @@ name: Python on: workflow_dispatch: workflow_call: + pull_request: + branches-ignore: + - 'nightly' + paths: + - 'org.lflang/src/org/lflang/generator/python/**' + - 'org.lflang/src/lib/py/**' concurrency: group: ${{ github.workflow }}-${{ github.ref }} diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index bd9efc79d7..2f0158767b 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -3,6 +3,12 @@ name: Rust on: workflow_dispatch: workflow_call: + pull_request: + branches-ignore: + - 'nightly' + paths: + - 'org.lflang/src/org/lflang/generator/rust/**' + - 'org.lflang/src/lib/rs/**' concurrency: group: ${{ github.workflow }}-${{ github.ref }} diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 63d0eb77ac..fafedb3885 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -3,6 +3,12 @@ name: Rust on: workflow_dispatch: workflow_call: + pull_request: + branches-ignore: + - 'nightly' + paths: + - 'org.lflang/src/org/lflang/generator/ts/**' + - 'org.lflang/src/lib/ts/**' concurrency: group: ${{ github.workflow }}-${{ github.ref }} From e74ee4ac6ee0cefa4d81010b90ed880df5eae4e1 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 11:29:02 -0700 Subject: [PATCH 462/709] Do not run on all platforms if PR is still a draft. --- .github/workflows/c-arduino-tests.yml | 6 +++++- .github/workflows/c-tests.yml | 8 ++++++-- .github/workflows/cpp-tests.yml | 6 +++++- .github/workflows/only-c.yml | 5 +++++ .github/workflows/only-cpp.yml | 5 +++++ .github/workflows/only-py.yml | 2 ++ .github/workflows/only-rs.yml | 3 +++ .github/workflows/only-ts.yml | 2 ++ .github/workflows/py-tests.yml | 6 +++++- .github/workflows/rs-tests.yml | 6 +++++- .github/workflows/ts-tests.yml | 7 ++++++- 11 files changed, 49 insertions(+), 7 deletions(-) diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 8c77d6e52d..348ca06d4c 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -16,6 +16,10 @@ on: scheduler: required: false type: string + all-platforms: + required: false + default: true + type: boolean concurrency: group: ${{ github.workflow }}-${{ github.ref }} @@ -25,7 +29,7 @@ jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest"]')) || 'ubuntu-latest' }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index c29b3c0a61..8f641e6482 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -16,16 +16,20 @@ on: scheduler: required: false type: string + all-platforms: + required: false + default: true + type: boolean concurrency: group: ${{ github.workflow }}-${{ github.ref }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: - run: + c-tests: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index e3f957ab2d..1f8001cf7d 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -9,6 +9,10 @@ on: runtime-ref: required: false type: string + all-platforms: + required: false + default: true + type: boolean concurrency: group: ${{ github.workflow }}-${{ github.ref }} @@ -18,7 +22,7 @@ jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index f59f2c151b..f720bb5006 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -29,10 +29,14 @@ jobs: # Run the C integration tests. c-tests: uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Arduino integration tests. c-arduino-tests: uses: ./.github/workflows/c-arduino-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Zephyr integration tests. c-zephyr-tests: @@ -43,3 +47,4 @@ jobs: uses: ./.github/workflows/c-tests.yml with: use-cpp: true + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index c7a36cb1a3..75b89cadff 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -24,11 +24,16 @@ jobs: uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Cpp' + all-platforms: ${{ !github.event.pull_request.draft }} # Run the C++ integration tests. cpp-tests: uses: ./.github/workflows/cpp-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Run the C++ integration tests on ROS2. cpp-ros2-tests: uses: ./.github/workflows/cpp-ros2-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index 0c5f2ed4c9..71003f0dad 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -22,3 +22,5 @@ jobs: # Run the Python integration tests. py-tests: uses: ./.github/workflows/py-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 2f0158767b..7b6dbe7042 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -22,9 +22,12 @@ jobs: # Run the Rust integration tests. rs-tests: uses: ./.github/workflows/rs-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Run the Rust benchmark tests. rs-benchmark-tests: uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Rust' + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index fafedb3885..ee5b5444b8 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -22,3 +22,5 @@ jobs: # Run the TypeScript integration tests. ts-tests: uses: ./.github/workflows/ts-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index c65e8fe27b..edc5f67e04 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -12,6 +12,10 @@ on: reactor-c-py-ref: required: false type: string + all-platforms: + required: false + default: true + type: boolean concurrency: group: ${{ github.workflow }}-${{ github.ref }} @@ -21,7 +25,7 @@ jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index e8d30dbfee..3f9515af58 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -15,6 +15,10 @@ on: only if this workflow is being run from the reactor-rs repository. required: false type: string + all-platforms: + required: false + default: true + type: boolean concurrency: group: ${{ github.workflow }}-${{ github.ref }} @@ -24,7 +28,7 @@ jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} rust: [stable] runs-on: ${{ matrix.platform }} steps: diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 3ca800349c..130a1106ed 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -2,6 +2,11 @@ name: TypeScript tests on: workflow_call: + inputs: + all-platforms: + required: false + default: true + type: boolean concurrency: group: ${{ github.workflow }}-${{ github.ref }} @@ -11,7 +16,7 @@ jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository From a4ce7d812a7c0ecb95f40ee3f2972a952b754340 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 11:42:01 -0700 Subject: [PATCH 463/709] Fix overzealous concurrency limit. --- .github/workflows/build-trace-tools.yml | 4 ---- .github/workflows/build.yml | 4 ---- 2 files changed, 8 deletions(-) diff --git a/.github/workflows/build-trace-tools.yml b/.github/workflows/build-trace-tools.yml index bd69f7be68..2490e9b75e 100644 --- a/.github/workflows/build-trace-tools.yml +++ b/.github/workflows/build-trace-tools.yml @@ -3,10 +3,6 @@ name: Build the tools for processing execution traces on: workflow_call: -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 2417cece56..767df01fa1 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -12,10 +12,6 @@ on: required: false workflow_dispatch: -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: runs-on: ubuntu-latest From c07d598716e1574242d537cd4ca27fa947a4d934 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 11:53:13 -0700 Subject: [PATCH 464/709] More removals of concurrency limits. --- .github/workflows/c-arduino-tests.yml | 4 ---- .github/workflows/c-tests.yml | 4 ---- .github/workflows/c-zephyr-tests.yml | 4 ---- .github/workflows/cli-tests.yml | 4 ---- .github/workflows/cpp-ros2-tests.yml | 4 ---- .github/workflows/cpp-tests.yml | 4 ---- .github/workflows/lsp-tests.yml | 4 ---- .github/workflows/nightly-build.yml | 4 ---- .github/workflows/non-target-specific-extended.yml | 7 ------- .github/workflows/py-tests.yml | 4 ---- .github/workflows/rs-tests.yml | 4 ---- .github/workflows/serialization-tests.yml | 4 ---- .github/workflows/ts-tests.yml | 4 ---- .github/workflows/unit-tests.yml | 4 ---- 14 files changed, 59 deletions(-) diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 348ca06d4c..d2ef2be8e7 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -21,10 +21,6 @@ on: default: true type: boolean -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 8f641e6482..4dd617054d 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -21,10 +21,6 @@ on: default: true type: boolean -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: c-tests: strategy: diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 49f204bb44..3b7a76feee 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -17,10 +17,6 @@ on: required: false type: string -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: runs-on: ubuntu-latest diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 3d23f0bd9f..056e32c04c 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -3,10 +3,6 @@ name: CLI tests on: workflow_call: -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: diff --git a/.github/workflows/cpp-ros2-tests.yml b/.github/workflows/cpp-ros2-tests.yml index c81ca59f02..93054676b5 100644 --- a/.github/workflows/cpp-ros2-tests.yml +++ b/.github/workflows/cpp-ros2-tests.yml @@ -10,10 +10,6 @@ on: required: false type: string -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: runs-on: ubuntu-latest diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index 1f8001cf7d..aaf87185ee 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -14,10 +14,6 @@ on: default: true type: boolean -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index 7418bde69d..bf32254b0f 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -3,10 +3,6 @@ name: Language server tests on: workflow_call: -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: diff --git a/.github/workflows/nightly-build.yml b/.github/workflows/nightly-build.yml index 469e9dc600..9ffb82c581 100644 --- a/.github/workflows/nightly-build.yml +++ b/.github/workflows/nightly-build.yml @@ -6,10 +6,6 @@ on: - cron: '0 5 * * *' workflow_dispatch: -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: build: uses: ./.github/workflows/build.yml diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index 63571ae210..2be9c863c3 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -26,26 +26,19 @@ env: vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 jobs: - # Cancel previous workflow runs. - cancel: - uses: ./.github/workflows/cancel.yml # Test the Gradle build. build: uses: ./.github/workflows/build.yml - needs: cancel # Build the tools used for processing execution traces build-tracing-tools: uses: ./.github/workflows/build-trace-tools.yml - needs: cancel # Run tests for the standalone compiler. cli-tests: uses: ./.github/workflows/cli-tests.yml - needs: cancel # Run language server tests. lsp-tests: uses: ./.github/workflows/lsp-tests.yml - needs: cancel diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index edc5f67e04..bb6dcf5f87 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -17,10 +17,6 @@ on: default: true type: boolean -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index 3f9515af58..01f20899ed 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -20,10 +20,6 @@ on: default: true type: boolean -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 8aadae65b7..89f1ad735c 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -7,10 +7,6 @@ on: required: false type: string -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: runs-on: ubuntu-latest diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 130a1106ed..c97955ff9c 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -8,10 +8,6 @@ on: default: true type: boolean -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 331627e262..1caec5c1ac 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -3,10 +3,6 @@ name: Unit tests on: workflow_call: -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: strategy: From 60f966148a6e6bf4f5835137933a7b9db7320a6f Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 14:22:35 -0700 Subject: [PATCH 465/709] Fix syntax error. --- .github/workflows/c-arduino-tests.yml | 2 +- .github/workflows/c-tests.yml | 2 +- .github/workflows/cpp-tests.yml | 2 +- .github/workflows/py-tests.yml | 2 +- .github/workflows/rs-tests.yml | 2 +- .github/workflows/ts-tests.yml | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index d2ef2be8e7..ceb90159bc 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -25,7 +25,7 @@ jobs: run: strategy: matrix: - platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest"]')) || 'ubuntu-latest' }} + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 4dd617054d..199fb3b8dd 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -25,7 +25,7 @@ jobs: c-tests: strategy: matrix: - platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index aaf87185ee..4b402ed845 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -18,7 +18,7 @@ jobs: run: strategy: matrix: - platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index bb6dcf5f87..e8ea1eac77 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -21,7 +21,7 @@ jobs: run: strategy: matrix: - platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index 01f20899ed..dae04b2dc8 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -24,7 +24,7 @@ jobs: run: strategy: matrix: - platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} rust: [stable] runs-on: ${{ matrix.platform }} steps: diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index c97955ff9c..c70a356a13 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -12,7 +12,7 @@ jobs: run: strategy: matrix: - platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || 'ubuntu-latest' }} + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository From ddcd858da5b129fe7bd190b74fbd98e6dfb7fa0b Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 14:41:49 -0700 Subject: [PATCH 466/709] More "do not run on all platforms." --- .github/workflows/build-trace-tools.yml | 7 ++++++- .github/workflows/cli-tests.yml | 7 ++++++- .github/workflows/lsp-tests.yml | 7 ++++++- .github/workflows/non-target-specific-extended.yml | 6 ++++++ .github/workflows/non-target-specific.yml | 2 ++ .github/workflows/unit-tests.yml | 7 ++++++- 6 files changed, 32 insertions(+), 4 deletions(-) diff --git a/.github/workflows/build-trace-tools.yml b/.github/workflows/build-trace-tools.yml index 2490e9b75e..86d8724481 100644 --- a/.github/workflows/build-trace-tools.yml +++ b/.github/workflows/build-trace-tools.yml @@ -2,12 +2,17 @@ name: Build the tools for processing execution traces on: workflow_call: + inputs: + all-platforms: + required: false + default: true + type: boolean jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 056e32c04c..2a2c3e32e4 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -2,12 +2,17 @@ name: CLI tests on: workflow_call: + inputs: + all-platforms: + required: false + default: true + type: boolean jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: - uses: actions/checkout@v3 diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index bf32254b0f..76ecd3f7eb 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -2,12 +2,17 @@ name: Language server tests on: workflow_call: + inputs: + all-platforms: + required: false + default: true + type: boolean jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: # Uninstall operations are needed because the language server is able to use multiple diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index 2be9c863c3..772101dece 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -34,11 +34,17 @@ jobs: # Build the tools used for processing execution traces build-tracing-tools: uses: ./.github/workflows/build-trace-tools.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Run tests for the standalone compiler. cli-tests: uses: ./.github/workflows/cli-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Run language server tests. lsp-tests: uses: ./.github/workflows/lsp-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index cdf5762eea..8f522afdef 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -18,6 +18,8 @@ jobs: # Run the unit tests. unit-tests: uses: ./.github/workflows/unit-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Run the serialization tests serialization-tests: diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index 1caec5c1ac..dd7613f8af 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -2,12 +2,17 @@ name: Unit tests on: workflow_call: + inputs: + all-platforms: + required: false + default: true + type: boolean jobs: run: strategy: matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} runs-on: ${{ matrix.platform }} steps: - uses: actions/checkout@v3 From 89b3bf7971bffe482213657f53a597f444bc57ed Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 16:36:22 -0700 Subject: [PATCH 467/709] Depend on whether workflow is ready for review. --- .github/workflows/all.yml | 55 +++++++++++++++++++++++ .github/workflows/non-target-specific.yml | 1 + .github/workflows/only-c.yml | 9 +++- .github/workflows/only-cpp.yml | 6 ++- .github/workflows/only-py.yml | 3 +- .github/workflows/only-rs.yml | 4 +- .github/workflows/only-ts.yml | 3 +- 7 files changed, 75 insertions(+), 6 deletions(-) create mode 100644 .github/workflows/all.yml diff --git a/.github/workflows/all.yml b/.github/workflows/all.yml new file mode 100644 index 0000000000..dd36e09ee0 --- /dev/null +++ b/.github/workflows/all.yml @@ -0,0 +1,55 @@ +# Main workflow for testing the Lingua Franca compiler. +name: CI + +on: + workflow_dispatch: + push: + branches: + - master + pull_request: + types: [synchronize, opened, reopened, ready_for_review] + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + + check-format: + if: !github.event.pull_request.draft + uses: ./.github/workflows/check-format.yml + + # Run the non-target-specific tests. + non-target-specific: + if: !github.event.pull_request.draft + uses: ./.github/workflows/non-target-specific.yml + + # Run the non-target-specific tests. + non-target-specific-extended: + if: !github.event.pull_request.draft + uses: ./.github/workflows/non-target-specific-extended.yml + + # Run the C tests. + c-tests: + if: !github.event.pull_request.draft + uses: ./.github/workflows/only-c.yml + + # Run the C++ tests. + cpp-tests: + if: !github.event.pull_request.draft + uses: ./.github/workflows/only-cpp.yml + + # Run the Python tests. + py-tests: + if: !github.event.pull_request.draft + uses: ./.github/workflows/only-py.yml + + # Run the Rust tests. + rs-tests: + if: !github.event.pull_request.draft + uses: ./.github/workflows/only-rs.yml + + # Run the TypeScript tests. + ts-tests: + if: !github.event.pull_request.draft + uses: ./.github/workflows/only-ts.yml diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index 8f522afdef..10be3de7d0 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -2,6 +2,7 @@ name: Non-target-specific tests on: workflow_dispatch: + workflow_call: pull_request: branches-ignore: - 'nightly' diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index f720bb5006..38bb01f86f 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -11,8 +11,10 @@ on: - 'org.lflang/src/lib/c/**' - 'org.lflang/src/lib/platform/**' + + concurrency: - group: ${{ github.workflow }}-${{ github.ref }} + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} env: @@ -22,28 +24,33 @@ env: jobs: # Run the C benchmark tests. c-benchmark-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'C' # Run the C integration tests. c-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Arduino integration tests. c-arduino-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/c-arduino-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Zephyr integration tests. c-zephyr-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/c-zephyr-tests.yml # Run the CCpp integration tests. ccpp-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: use-cpp: true diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index 75b89cadff..e2ac03f499 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -11,7 +11,7 @@ on: - 'org.lflang/src/lib/cpp/**' concurrency: - group: ${{ github.workflow }}-${{ github.ref }} + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} env: @@ -21,19 +21,21 @@ env: jobs: # Run the C++ benchmark tests. cpp-benchmark-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Cpp' - all-platforms: ${{ !github.event.pull_request.draft }} # Run the C++ integration tests. cpp-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C++ integration tests on ROS2. cpp-ros2-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-ros2-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index 71003f0dad..edc9057760 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -11,7 +11,7 @@ on: - 'org.lflang/src/lib/py/**' concurrency: - group: ${{ github.workflow }}-${{ github.ref }} + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} env: @@ -22,5 +22,6 @@ jobs: # Run the Python integration tests. py-tests: uses: ./.github/workflows/py-tests.yml + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} with: all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 7b6dbe7042..a52424b586 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -11,7 +11,7 @@ on: - 'org.lflang/src/lib/rs/**' concurrency: - group: ${{ github.workflow }}-${{ github.ref }} + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} env: @@ -21,12 +21,14 @@ env: jobs: # Run the Rust integration tests. rs-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/rs-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the Rust benchmark tests. rs-benchmark-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Rust' diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index ee5b5444b8..6623eafd11 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -11,7 +11,7 @@ on: - 'org.lflang/src/lib/ts/**' concurrency: - group: ${{ github.workflow }}-${{ github.ref }} + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} env: @@ -21,6 +21,7 @@ env: jobs: # Run the TypeScript integration tests. ts-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/ts-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} From 1ce9e1440cfda888c17311ab6af9fee9457164f5 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 16:46:35 -0700 Subject: [PATCH 468/709] Split the "all" workflow (workaround). This is a workaround for another arbitrary limit. See https://github.com/orgs/community/discussions/32192. --- .github/workflows/all-non-target-specific.yml | 26 +++++++++++++++++++ .../workflows/{all.yml => all-targets.yml} | 14 ---------- .../non-target-specific-extended.yml | 4 +++ 3 files changed, 30 insertions(+), 14 deletions(-) create mode 100644 .github/workflows/all-non-target-specific.yml rename .github/workflows/{all.yml => all-targets.yml} (66%) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml new file mode 100644 index 0000000000..25f1316314 --- /dev/null +++ b/.github/workflows/all-non-target-specific.yml @@ -0,0 +1,26 @@ +# Main workflow for testing the Lingua Franca compiler. +name: CI + +on: + workflow_dispatch: + push: + branches: + - master + pull_request: + types: [synchronize, opened, reopened, ready_for_review] + +env: + # 2020.11 + vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 + +jobs: + + # Run the non-target-specific tests. + non-target-specific: + if: !github.event.pull_request.draft + uses: ./.github/workflows/non-target-specific.yml + + # Run the non-target-specific tests. + non-target-specific-extended: + if: !github.event.pull_request.draft + uses: ./.github/workflows/non-target-specific-extended.yml diff --git a/.github/workflows/all.yml b/.github/workflows/all-targets.yml similarity index 66% rename from .github/workflows/all.yml rename to .github/workflows/all-targets.yml index dd36e09ee0..2041a5c44e 100644 --- a/.github/workflows/all.yml +++ b/.github/workflows/all-targets.yml @@ -15,20 +15,6 @@ env: jobs: - check-format: - if: !github.event.pull_request.draft - uses: ./.github/workflows/check-format.yml - - # Run the non-target-specific tests. - non-target-specific: - if: !github.event.pull_request.draft - uses: ./.github/workflows/non-target-specific.yml - - # Run the non-target-specific tests. - non-target-specific-extended: - if: !github.event.pull_request.draft - uses: ./.github/workflows/non-target-specific-extended.yml - # Run the C tests. c-tests: if: !github.event.pull_request.draft diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index 772101dece..fb4caef58a 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -37,6 +37,10 @@ jobs: with: all-platforms: ${{ !github.event.pull_request.draft }} + check-format: + if: !github.event.pull_request.draft + uses: ./.github/workflows/check-format.yml + # Run tests for the standalone compiler. cli-tests: uses: ./.github/workflows/cli-tests.yml From 25edb0075d01ae4e8154d0795832114050a09c48 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 16:50:32 -0700 Subject: [PATCH 469/709] Fix syntax error. --- .github/workflows/all-non-target-specific.yml | 4 ++-- .github/workflows/all-targets.yml | 10 +++++----- .github/workflows/non-target-specific-extended.yml | 8 ++++---- .github/workflows/non-target-specific.yml | 2 +- .github/workflows/only-c.yml | 6 +++--- .github/workflows/only-cpp.yml | 4 +--- .github/workflows/only-py.yml | 2 +- .github/workflows/only-rs.yml | 3 +-- .github/workflows/only-ts.yml | 2 +- 9 files changed, 19 insertions(+), 22 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 25f1316314..ec3258253a 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -17,10 +17,10 @@ jobs: # Run the non-target-specific tests. non-target-specific: - if: !github.event.pull_request.draft + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/non-target-specific.yml # Run the non-target-specific tests. non-target-specific-extended: - if: !github.event.pull_request.draft + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/non-target-specific-extended.yml diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 2041a5c44e..6c3d31d3f3 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -17,25 +17,25 @@ jobs: # Run the C tests. c-tests: - if: !github.event.pull_request.draft + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-c.yml # Run the C++ tests. cpp-tests: - if: !github.event.pull_request.draft + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-cpp.yml # Run the Python tests. py-tests: - if: !github.event.pull_request.draft + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-py.yml # Run the Rust tests. rs-tests: - if: !github.event.pull_request.draft + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-rs.yml # Run the TypeScript tests. ts-tests: - if: !github.event.pull_request.draft + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-ts.yml diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index fb4caef58a..5353406235 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -35,20 +35,20 @@ jobs: build-tracing-tools: uses: ./.github/workflows/build-trace-tools.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} check-format: - if: !github.event.pull_request.draft + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/check-format.yml # Run tests for the standalone compiler. cli-tests: uses: ./.github/workflows/cli-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} # Run language server tests. lsp-tests: uses: ./.github/workflows/lsp-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index 10be3de7d0..f6f6bcabc2 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -20,7 +20,7 @@ jobs: unit-tests: uses: ./.github/workflows/unit-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} # Run the serialization tests serialization-tests: diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 38bb01f86f..d4ef34820d 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -34,14 +34,14 @@ jobs: if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Arduino integration tests. c-arduino-tests: if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/c-arduino-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Zephyr integration tests. c-zephyr-tests: @@ -54,4 +54,4 @@ jobs: uses: ./.github/workflows/c-tests.yml with: use-cpp: true - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index e2ac03f499..36f5682944 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -31,11 +31,9 @@ jobs: if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} # Run the C++ integration tests on ROS2. cpp-ros2-tests: if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-ros2-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index edc9057760..f43a521e30 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -24,4 +24,4 @@ jobs: uses: ./.github/workflows/py-tests.yml if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index a52424b586..71adaa36ae 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -24,7 +24,7 @@ jobs: if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/rs-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} # Run the Rust benchmark tests. rs-benchmark-tests: @@ -32,4 +32,3 @@ jobs: uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Rust' - all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 6623eafd11..6d7cd0098c 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -24,4 +24,4 @@ jobs: if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/ts-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} From 833d8a3437ce6d7c06d9d283b38fc2c33817d629 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 17:13:47 -0700 Subject: [PATCH 470/709] Update non-target-specific-extended.yml. --- .github/workflows/non-target-specific-extended.yml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index 5353406235..4a486f9ff7 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -29,26 +29,30 @@ jobs: # Test the Gradle build. build: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/build.yml # Build the tools used for processing execution traces build-tracing-tools: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/build-trace-tools.yml with: all-platforms: ${{ !github.event.pull_request.draft }} check-format: - if: ${{ !github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/check-format.yml # Run tests for the standalone compiler. cli-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/cli-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run language server tests. lsp-tests: + if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} uses: ./.github/workflows/lsp-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} From b255db743da07431e6f01021e6390e5bb42970b2 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 17:20:08 -0700 Subject: [PATCH 471/709] Address deadlock reported by GH actions. --- .github/workflows/check-format.yml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/.github/workflows/check-format.yml b/.github/workflows/check-format.yml index 8fc44a98df..8c022f90a5 100644 --- a/.github/workflows/check-format.yml +++ b/.github/workflows/check-format.yml @@ -3,10 +3,6 @@ name: Spotless check on: workflow_call: -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - jobs: run: runs-on: ubuntu-latest From 01a9215b39f16f838798200faa8cdf13853e6a58 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 17:28:37 -0700 Subject: [PATCH 472/709] Try to address unwanted cancellation. --- .github/workflows/all-non-target-specific.yml | 7 +++++-- .github/workflows/all-targets.yml | 7 +++++-- .github/workflows/non-target-specific-extended.yml | 4 ---- .github/workflows/non-target-specific.yml | 4 ---- .github/workflows/only-c.yml | 6 ------ .github/workflows/only-cpp.yml | 4 ---- .github/workflows/only-py.yml | 4 ---- .github/workflows/only-rs.yml | 4 ---- .github/workflows/only-ts.yml | 4 ---- 9 files changed, 10 insertions(+), 34 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index ec3258253a..896ffc71b4 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,5 +1,4 @@ -# Main workflow for testing the Lingua Franca compiler. -name: CI +name: Non-target-specific on: workflow_dispatch: @@ -13,6 +12,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Run the non-target-specific tests. diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 6c3d31d3f3..f0e0b32f42 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -1,5 +1,4 @@ -# Main workflow for testing the Lingua Franca compiler. -name: CI +name: Target-specific on: workflow_dispatch: @@ -13,6 +12,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Run the C tests. diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index 4a486f9ff7..c667a5b9ca 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -17,10 +17,6 @@ on: - 'org.lflang/src/lib/rs/**' - 'org.lflang/src/lib/ts/**' -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index f6f6bcabc2..3e5fb4a341 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -7,10 +7,6 @@ on: branches-ignore: - 'nightly' -concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index d4ef34820d..07f54ff510 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -11,12 +11,6 @@ on: - 'org.lflang/src/lib/c/**' - 'org.lflang/src/lib/platform/**' - - -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index 36f5682944..d95a895ca2 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -10,10 +10,6 @@ on: - 'org.lflang/src/org/lflang/generator/cpp/**' - 'org.lflang/src/lib/cpp/**' -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index f43a521e30..48dd61b92b 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -10,10 +10,6 @@ on: - 'org.lflang/src/org/lflang/generator/python/**' - 'org.lflang/src/lib/py/**' -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 71adaa36ae..6bc206e42c 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -10,10 +10,6 @@ on: - 'org.lflang/src/org/lflang/generator/rust/**' - 'org.lflang/src/lib/rs/**' -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 6d7cd0098c..65ce523413 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -10,10 +10,6 @@ on: - 'org.lflang/src/org/lflang/generator/ts/**' - 'org.lflang/src/lib/ts/**' -concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event.pull_request.draft }} - cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} - env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 From 0de92d2faef21a89fb728bf80fad6acf454601b8 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 17:53:58 -0700 Subject: [PATCH 473/709] Try again to run all tests when ready for review. --- .github/workflows/non-target-specific-extended.yml | 10 +++++----- .github/workflows/only-c.yml | 10 +++++----- .github/workflows/only-cpp.yml | 6 +++--- .github/workflows/only-py.yml | 2 +- .github/workflows/only-rs.yml | 4 ++-- .github/workflows/only-ts.yml | 2 +- 6 files changed, 17 insertions(+), 17 deletions(-) diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index c667a5b9ca..f790d8397d 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -25,30 +25,30 @@ jobs: # Test the Gradle build. build: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/build.yml # Build the tools used for processing execution traces build-tracing-tools: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/build-trace-tools.yml with: all-platforms: ${{ !github.event.pull_request.draft }} check-format: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/check-format.yml # Run tests for the standalone compiler. cli-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/cli-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run language server tests. lsp-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/lsp-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 07f54ff510..a73c76f35a 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -18,33 +18,33 @@ env: jobs: # Run the C benchmark tests. c-benchmark-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'C' # Run the C integration tests. c-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Arduino integration tests. c-arduino-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/c-arduino-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Zephyr integration tests. c-zephyr-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/c-zephyr-tests.yml # Run the CCpp integration tests. ccpp-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: use-cpp: true diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index d95a895ca2..f1ffce2d82 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -17,19 +17,19 @@ env: jobs: # Run the C++ benchmark tests. cpp-benchmark-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Cpp' # Run the C++ integration tests. cpp-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C++ integration tests on ROS2. cpp-ros2-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-ros2-tests.yml diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index 48dd61b92b..c8bc858651 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -18,6 +18,6 @@ jobs: # Run the Python integration tests. py-tests: uses: ./.github/workflows/py-tests.yml - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} with: all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 6bc206e42c..7b009144ab 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -17,14 +17,14 @@ env: jobs: # Run the Rust integration tests. rs-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/rs-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the Rust benchmark tests. rs-benchmark-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Rust' diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 65ce523413..5af88bc471 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -17,7 +17,7 @@ env: jobs: # Run the TypeScript integration tests. ts-tests: - if: ${{ github.event_name == 'workflow_call' || github.event.pull_request.draft }} + if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} uses: ./.github/workflows/ts-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} From c892ab62a7e313d2e7485e4749d31499d7dab6a0 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 18:23:22 -0700 Subject: [PATCH 474/709] Try again to run all tests. --- .github/workflows/all-non-target-specific.yml | 4 ++++ .github/workflows/all-targets.yml | 10 ++++++++++ .github/workflows/non-target-specific-extended.yml | 13 ++++++++----- .github/workflows/non-target-specific.yml | 5 +++++ .github/workflows/only-c.yml | 13 ++++++++----- .github/workflows/only-cpp.yml | 9 ++++++--- .github/workflows/only-py.yml | 5 ++++- .github/workflows/only-rs.yml | 7 +++++-- .github/workflows/only-ts.yml | 5 ++++- 9 files changed, 54 insertions(+), 17 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 896ffc71b4..27f0ba9994 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -22,8 +22,12 @@ jobs: non-target-specific: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/non-target-specific.yml + with: + all: true # Run the non-target-specific tests. non-target-specific-extended: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/non-target-specific-extended.yml + with: + all: true diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index f0e0b32f42..9bba174ed2 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -22,23 +22,33 @@ jobs: c-tests: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-c.yml + with: + all: true # Run the C++ tests. cpp-tests: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-cpp.yml + with: + all: true # Run the Python tests. py-tests: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-py.yml + with: + all: true # Run the Rust tests. rs-tests: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-rs.yml + with: + all: true # Run the TypeScript tests. ts-tests: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-ts.yml + with: + all: true diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index f790d8397d..085bfcd567 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -3,6 +3,9 @@ name: Additional non-target-specific tests on: workflow_dispatch: workflow_call: + inputs: + all: + type: boolean pull_request: paths-ignore: - 'org.lflang/src/org/lflang/generator/c/**' @@ -25,30 +28,30 @@ jobs: # Test the Gradle build. build: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/build.yml # Build the tools used for processing execution traces build-tracing-tools: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/build-trace-tools.yml with: all-platforms: ${{ !github.event.pull_request.draft }} check-format: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/check-format.yml # Run tests for the standalone compiler. cli-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/cli-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run language server tests. lsp-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/lsp-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index 3e5fb4a341..7835f6122b 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -3,6 +3,9 @@ name: Non-target-specific tests on: workflow_dispatch: workflow_call: + inputs: + all: + type: boolean pull_request: branches-ignore: - 'nightly' @@ -14,10 +17,12 @@ env: jobs: # Run the unit tests. unit-tests: + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/unit-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the serialization tests serialization-tests: + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/serialization-tests.yml diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index a73c76f35a..448daff830 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -3,6 +3,9 @@ name: C on: workflow_dispatch: workflow_call: + inputs: + all: + type: boolean pull_request: branches-ignore: - 'nightly' @@ -18,33 +21,33 @@ env: jobs: # Run the C benchmark tests. c-benchmark-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'C' # Run the C integration tests. c-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Arduino integration tests. c-arduino-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-arduino-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Zephyr integration tests. c-zephyr-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-zephyr-tests.yml # Run the CCpp integration tests. ccpp-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: use-cpp: true diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index f1ffce2d82..2a2be6dcb5 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -3,6 +3,9 @@ name: C++ on: workflow_dispatch: workflow_call: + inputs: + all: + type: boolean pull_request: branches-ignore: - 'nightly' @@ -17,19 +20,19 @@ env: jobs: # Run the C++ benchmark tests. cpp-benchmark-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Cpp' # Run the C++ integration tests. cpp-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C++ integration tests on ROS2. cpp-ros2-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-ros2-tests.yml diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index c8bc858651..136b41219c 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -3,6 +3,9 @@ name: Python on: workflow_dispatch: workflow_call: + inputs: + all: + type: boolean pull_request: branches-ignore: - 'nightly' @@ -18,6 +21,6 @@ jobs: # Run the Python integration tests. py-tests: uses: ./.github/workflows/py-tests.yml - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} with: all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 7b009144ab..5387f10785 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -3,6 +3,9 @@ name: Rust on: workflow_dispatch: workflow_call: + inputs: + all: + type: boolean pull_request: branches-ignore: - 'nightly' @@ -17,14 +20,14 @@ env: jobs: # Run the Rust integration tests. rs-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/rs-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the Rust benchmark tests. rs-benchmark-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'Rust' diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 5af88bc471..1d33172d69 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -3,6 +3,9 @@ name: Rust on: workflow_dispatch: workflow_call: + inputs: + all: + type: boolean pull_request: branches-ignore: - 'nightly' @@ -17,7 +20,7 @@ env: jobs: # Run the TypeScript integration tests. ts-tests: - if: ${{ github.event_name == 'workflow_dispatch' || github.event.pull_request.draft }} + if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/ts-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} From 43550582d801dfefa23670dc394e44595c7ccce0 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 18:35:12 -0700 Subject: [PATCH 475/709] Rename main workflows. --- .github/workflows/all-non-target-specific.yml | 2 +- .github/workflows/all-targets.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 27f0ba9994..18102e87be 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,4 +1,4 @@ -name: Non-target-specific +name: CI (non-target-specific) on: workflow_dispatch: diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 9bba174ed2..16df3b7c83 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -1,4 +1,4 @@ -name: Target-specific +name: CI (target-specific) on: workflow_dispatch: From 6b3b9252e89f62988128131cc75605e9ca2a246b Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 24 May 2023 18:41:41 -0700 Subject: [PATCH 476/709] Try again to implement cancellation. In presence of reusable workflows I have found jobs getting canceled due to detected "deadlocks" according to GH actions. It might have something to do with reused workflows inheriting the caller's value for github.workflow? --- .github/workflows/non-target-specific-extended.yml | 4 ++++ .github/workflows/non-target-specific.yml | 4 ++++ .github/workflows/only-c.yml | 4 ++++ .github/workflows/only-cpp.yml | 4 ++++ .github/workflows/only-py.yml | 4 ++++ .github/workflows/only-rs.yml | 4 ++++ .github/workflows/only-ts.yml | 4 ++++ 7 files changed, 28 insertions(+) diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index 085bfcd567..2b3bfe8c12 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -24,6 +24,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: only-non-target-specific-extended-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Test the Gradle build. diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index 7835f6122b..f662451186 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -14,6 +14,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: only-non-target-specific-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Run the unit tests. unit-tests: diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 448daff830..c635aba13c 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -18,6 +18,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: only-c-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Run the C benchmark tests. c-benchmark-tests: diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index 2a2be6dcb5..22bc7fb814 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -17,6 +17,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: only-cpp-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Run the C++ benchmark tests. cpp-benchmark-tests: diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index 136b41219c..5adf989661 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -17,6 +17,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: only-py-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Run the Python integration tests. py-tests: diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 5387f10785..1dd0dfbf56 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -17,6 +17,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: only-rs-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Run the Rust integration tests. rs-tests: diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 1d33172d69..f6afde4b0b 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -17,6 +17,10 @@ env: # 2020.11 vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 +concurrency: + group: only-ts-${{ github.ref }}-${{ github.event_path }} + cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} + jobs: # Run the TypeScript integration tests. ts-tests: From c3a130d2f73c420c03aa7bfa7dc038b624fda172 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 09:15:30 +0200 Subject: [PATCH 477/709] delete unused files --- org.lflang/.antlr-generator-3.2.0-patch.jar | Bin 1484649 -> 0 bytes org.lflang/about.html | 81 -------------------- org.lflang/build.properties | 20 ----- 3 files changed, 101 deletions(-) delete mode 100644 org.lflang/.antlr-generator-3.2.0-patch.jar delete mode 100644 org.lflang/about.html delete mode 100644 org.lflang/build.properties diff --git a/org.lflang/.antlr-generator-3.2.0-patch.jar b/org.lflang/.antlr-generator-3.2.0-patch.jar deleted file mode 100644 index 90516fd7ac76a3ec685e046f91eb762e68e20586..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1484649 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%0AaAH?nu0NxCVyl& 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

    0o!{G>?pE44LUKy|#M%y*oR=c!hc*7_{If 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%0DU}=hy#Jq^`TKJB5lbk_T^f`R<=qC!pt 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

    kDx#JEXxXY5fwD%JuFeuD@(=>Tp`Q&% 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�vzNcGQ{ZSk(dI=VoR^Y)f>1sty&9Wzlprb!by1Ee{+3i zUE4e#8n*K^E8X_w!^C9v`|aZp)eo6V_7KCw!yXqF>S!TMpCnkld**!A3j!osGDP&dswgR)(B1aZ=hTgpvGO!J|8O)F(mnV78ywXB$!HU88w1nEIy z9acWYO3%%DMS^W37MACAImx7@v(l;n$L*yaJ!?k@e3aroc?f+0WU5Ri*`z_>*SUA= ze)5r|<|@k?jl1}$y{3!Oxcxt@R?08KRx7<_Azl!us&utc5d9;D{>YH4Bw|#KjU3v_ z%p7Qqx^(6{G+8Mt0$aVwAw?_8>p&TGkHNc7%-bAZ`zRG9Mn)M4kG*io12)~qd42=WT9 zoT9SjA__#5PU+G?q^Cqc#U9KIu)%g2Ji?F;y89QoMN(011E@|1V8RsrduBqdQ%=;= zP|(>@{vGwMduBd^YpBO)R_?J|&hqF-48bl|!9OAN0N%f!a7+;26R8X%|3+LNKZP#O zpzfp!!jHIkrO~8|P<#vvrq?H9f=L$g8--KnE6V)jH-?F>^s{$Bm)7aLg{oZ*(O{3P z^Z*jEq}!s)#b!7~UT!&7M%G;UWg_XT;~)Lec|oLD2ge*s>chg-27f*+`I$IAoR(4o zW)$U;2tqjje$!k7U**EoX#o6q0T^BUN9hLW%9~2~T~f&b|NGL-@?Y5;EI%ppi$u&S zPU2I>IsOU(3?1ginvN~$J)y|4zyZ!5hWN;+{z^@D=<6`P+ zGP?6$IK;K8yrASim48o1r`l4#bbTUrpu* zFvL>zgf7#=vMEJOqZ%vql7RV;j^eg&RHX`|$q<;1yz8JFgc_hafv6X(ofoCLGkEAe zz@f3C)DSE0G2zXb~8*JSa(Ta8)&SAkNL zv|Z$b`zE199i3yEE0TNv193zQg%BnP_iJ(`EOC}Ef1PP0j>YcM?gMrUV6;4ez@e5Xb$3x$R5X0eBk|1fix zb<2&fPT>k(Zs>~#o=H8Lm}`=lql7*0xSnA9=DqI{?9haRsklD|4u+>DJ)3y3hRlz* z?l5=1JcpulM#1^$y=p^tT-kCvBv(<`>MWpP0hzC05j~tF4K8WMZ=_b@|}{-LC;BUMaTo;nvC&0@+=#QY0ds)`J3rZ*2UsVo(7}pBN~!}flH{=^ zh9)($W-4Rn_cg@7xnmj~fdAy@PFU21WZXPkDk8nRjCm1^Lzc-E zEI-b*0GvUt>ya4%@oztaD_8{G`06i_1I~o2EcI$_yyl|Ge`QAldEhMLqW&fDPy1Wk zB`XWuR-*e6WVg9`?w~J+cDQP?w>C!&%aBE>kMGC+NDN3qO~LF|{FXyaL7HguygML&X1a2Xq*hID(M3zQ6&iR{r zyuZM_eX$6htH|78Zs!*@HP_|&yF0nMe=qe1{iBI7p+V89kmE-kuvDz7*3B4>f>-im z(9|;XZ~K}PCQ2Ddm#xLrB;L2jY;)z9cfp%)?2Q4gqK%ktV~Wnf8)xNYM0=Co0LzQm zjmB(lwCL4F_oMa7T#67*59M{wBzIuL%3TNk!q&8<*k>oCv?n$VvPbV;quYczZc2cA zWBoE&mo~rmhl2F?h&O0dw@^JEJmad^yX~q#52QvaOMNa}LO*jl%L+#5KK{*WwUKp} z;LnOWmr0x*6B;W(S8gy&_l!UohlG#tv}aepF@@_it;K|lZekEQWJ--w;v#% z=ollBDrEj^*^TGO&HoI(^4kO~ashFUKt>2O)~5$mRvBQjzdmI%q02o(NoWgW7YOxm zuQEUh{*RC;^wGd36a9uu?f+Bs@&69le-(ymEpRW*;rZO{W@>eLn$rRHK6Wvz(U?Ry z0O1dS*I%9uV;g7F|s2y)l<+Mo|9bMhb}XM`zr33KvevSRAuV$k4) zz?R1X)?MG7P10(kW3n%wFXfvrS5s4y|8c#rcfID0<`NXVQJmzP9@8H)3E)ifj=CS+ zEu1Dm<4`1zwiy%hW^OIa&YHwp#ZSJH?!}Xi9n+vcj;Wyk%C_r5L5?6=wa)*hg8c}+ zk)9-2)3_Iel8h~6{6CDn19xWMw(eW0 zsA9e`Do({VDzL$FqvIkO{nnEAEE%2tV9>gCm71*m;Ao?6 zh?>@JTq5nnh{lb*zQf<=kKJj_4q*t9Vw|V`4X= z=8XXx*1KuycL&N(%N;(A)+d&fj!gkOH<8v3g{^~l7mreuZ|9eG5eQnhTlQ`_9o?Ed zKk*&Mt?+zlYt|6p3Lb7FCcYAh9&04LR|T*Sh-h9)L+0$;C3p_=yj%N8T-^6*UH}MI z@t`!V>jEa@+%&Dr0!L%RTJ|#nN8@CwFJv!AzfwHc1kguKFu2Z=b)3eJHf}8>w&UAw$9gXw2wq~sTDJ&zYcw%-qX^s$0XaVRGc?{Gqa>f_d7JOA=m-}F zM>^b0BhxWl_k~=+fWO$o1KV1+`2JiUisiI`$pJrZ=;5R&j9Xb2k;@=G)+<({)W-~ma8H$u)KB(>Z4PEADN!<7pd3*CjERyP3t2; zUzQpXewBhzsx=q77%EWzLv#dv;=#26Vl`W-OY{fIewUtq@qzJHXxXsqX_qL~42~(R zFWa2)+36w&hO$}AANWB}vIAl`bf(@^3z*_H!?X=!dVX4kfa6J&Vb-^n!^;F~#8K);6CXxYQzV{Eg7B_Jb*M^ajMNq`Z z2y5^l!a-6y94s7NdUr<7E>^+q{LExrfMtyqvZ`nT>xZLrO@4*7s?M$M??htU>HoY9ig9_gm^qq3Oj>gdsZy6{0XAn!{Tfm315BZ^^PN~8AC}*_3 za`a23bf5Ab13six(-k3itR3fVHf~7z*`R+hHfBNV=JFb%DSa{g(*rp5ASbKMdRJo~UIr`De7a-*Q!?X~2zTltI9wqF)# z@Jj$BpTuqY3Lt|;T?*We#TjGb)qy{Sld=8dAi2F2)ftwGX$GOjuyXTySUQQrc9MGy zinmln+;a_#A?P86)p9=AOV?kwtdu)Y=9qnRzK~RQzAIfdvt>3KlV)_|4~xboshuW> z8tqlICKh}T+%zDE2>9goY95mSX{$CF&hXz`1s;Ws+_akQ`fKNF^YIjif?Tyj^?dRl z)iqggjR3p#Np*w_J}S#ag&kSj#v&wzjr@6MWd*h(K%wfV>cEvt za)z1BqFbNbkJ{y}HMB_ZI_u&rp9oCd=(K$A3Y!Y!x=0j9Hf(%$7l+i1WQSH$jlH_e zZT2%)4-h{TKQ({O2BMW-eH$BN`__4?0!Ln0FoA|Zob67D>I5kV{g&Bf-K&+#rVASv zlL~H+{FUN9B#UeAsY}Dg=laG!MP-0rl1|mq>?}!Is7w%Evql?kIl2ARykSF;i_K@X z1T?nYUtz2lmWA^QG|Big74;N|mgf5#qx0|~)KT~gyEu%s5-acZ@P5z?#>?RA4K7BM z2XwbTUe$MIW|fPdgV7ez{I#%CUf6PT;}0^n7mO`#gVg=0AfX18uLmuCh1Szs?~RuE zAI+heIE;3i9bs7;tA40gooip@MyQf{iH$$x4QS&ILiH@`Qh$5$TL1O-9%Y48VU3V; z9FwcRHQi+y-X2u0p&%e@#^Ozp@DcP zsDxo#*nO#Z=O{VosEi%F1Dd zOb7c|)OKp;d?vm4L_ClC05>Yh6sPuGDFlAc9Y?7#H!ch>mc*mI4P_|}iMn@w*JR-A zjdAqyb?F%*lJ@NKEYzhS@DE*^zcRKv_t~pF_l+d^RzksX^po?V2;;A7@WIrHS4F}t z%rh9$`82SpeBB5o2XzM%r3$aYdAzf;vnKTo?l4D=t-+Ax)*<3~v`@)=69LvCb31xC z4SBD>$(K#ebTY_P8dk#aaaDJz2@$`z3F>)f6IIc#uBKF>Iob?t7#&A`54-D-qebo` z>Ai;<(!yeo!)Z9yl%v~YwW6hGS=V7@%uiaz>yYpWT1&(hAN0$)9r zNabsv)jcrXE~Fz%;v=05#EiX=A+qJ!*d;QSTxlnU#&Fh>M$SdF_(W8uKMGN(Wyl!# zF3k7JLte3D#7W*-mM^08;h#Gp7arlgjv-BVs$RK(vQ%T0Z!s8P~Bh=ASR`i@E8)v z8ab!y18KeXsBsak{@RuWZhL(eG7^r4=dw{HZMQC9n_+1HY=uk-s1_<++Lg~xPcN;E z-7;+|D$VNV>So3`u|oG)?0If~EXj(##7&c;gp=1|K@kSH5{$UTVXFw1`JbJ#VBE0?^bJDhaw!2UKTqaVbYJw zpl8GLn5)|nj?1;#7e{APJ$}(#7?hY$SY6dB<5)c9H3-)6=Tby&q@3|#TNBWQGsJzF z&G$*4Xa1-Ql$AqZrATKMXBWSv1IfvXey=^hcOtBcUirYiSSDk20gfk$U7yCApXYKD z=w)Q?Y1q*|1#V+V+uirlK2R~NKR&aT$>c(%=&?W$Vf_upkfNFt^9y(fuk=<-v|P4H z`Mf?W+CT&{hPp1T!N_gK1~t^`kxtm=obw5`%D6T37Qx^G$}GF(NJK;`{(e_P91sO0^$XI+KV zV+v#-ya;gutb;)A5j}dtK1xL|zX|@nsRhaXy9&FSgX(MLmgKvnRg6;32A(ska#1x* z(J$DXils`fDsY4Tz1Xx4UUv*~sBW3wn+9#>#m~WH;N_B-Z$hn_`v9kOOwlebl#fe3 zWSN;5->Pw{qos*XDed04?L*wn$v5ABg)^t&}c&s6R)5WjeJWcezRPy#s$1kXz_xj6$W~2q z9l1T%2~qcXpOcz@IgF`x;AD|LJt`HwaV{MhXD)N&qKy_#=_go<8!xFit+8UJmq?uf z0gzdW;>8uN!r0HgOE4=MMy=wM_?h!c*O*@3wb+O52UKd*p|Ma3ORH$~jb`{E z%ki-B9V${vD7vknc*>o-(sn5-8-#yQnC^hm8QRQI*&==8NlN3pCl4z~9p)U|SAcD# zYLCH~8h7*HXQ;kH-wLM+6UuSSTQcpNCXUQ)?=jx1>uHboyDpVUL+5V!dfQh@ZEsy0 ztFf#L*gxHNW#-k-5NB!_Q0}G)Zlz<<9myATT-D{yWvkjs1&1w)RVs`0B6fdNCY3UM z7P+d^tAp=QjrH0xxnUH(Foom1>6qmoMmYv+w+Kc4RjG3n+_x>XE4H+)we)&H?Hf0{ zMityLwAKYVZKnp;NlJwNn3mv#-jWXUTJ>Fd2|2S=kUgd0QiD$Wd@fX{f{#SSqN}?& zw4ZXgCDAUwa#WaYm5h6Q&FuZ`W0{WQ3d4!+q(+lz%gUD1~W6aeP8w7dGd;9Hg1pJIo zqRJE>>=!)h@RvzWawh5CEuOY9ZfNG&OYNc%t?#&PjcCo@BA}fEf3A?yr0Zq+o;?^d zNu|HwnO|IFO^kqqgH5Mxa}1KVbY&$(;4lqy4+TVrFm?Y$2Vn?s@tdNSCVzejsW+v` zLW3vi%0XR#hdYuAXt`Z*1QlmR=cA@?;M2j`8RKw<#b)Cq2jy9bnQ%6j!_?w58N1YX zLi=L4?OK_Ts5G3XUh%Qd6-mAJ%3n%H`ElXjKi{gL=tA=}HUo76^StNI66uAD)>DD5K@DY{JgICAm~ zKC1XjKZuWNs0*PdJoc?oU+L-jIvO`NY#LMG3NemO2kq4g$NnEAcgH^wM>^$cf)cmS z>D-}t(pvi~IfCFx2F0b-RD03R-#1&7t2uo|U`GX4Tp4eOby!qzkA;mZl50yH z&ncgSJ~shelomctJNN9Imxy!E>zN>Gh_@}nckhESLiRV)lQFSUr&KUdFS#$@d ztB`H6=?yv7d^9+;C?@uTfWPioHRzRUIzObQ&{bSXnDp?qJnvFxeCmLFuq6y9N^Iem z0*6>1D4}447Ti8t7djbB*pttvzi*~fjg+m)-@lzdOaJuYoFX^?8A3|$U(+f&wp9WDxUk{p8R>9 zOmSjy&n2CwbJYE}1l_k=4`}nf+Z1R6(rpN|0qwQ~s`% zKlyzf&$IgZm;#%9eGGy4pxsu$oNu2CJ-nbFt$y1eA3=WG;NH_c-C*9^J>B0w8vT4g z-!(vezP)pTe&RhNKztxR$3T3bT<5^OqXWCKo{50nn9o-|pLEx}exF7_AJEU?9(;wO zTpYAghd`#9?=}Wvmu> z*FSz|en*(DJlEer@j*IfdPKg{GF;2`h+sb}^hCgQfVr0W#encE^$dgH+vwuk2KZt7 zWx#%g53$(7Tr+?|`pVE<+XHj`H2ef0;6bbDuEl|&eg!@Bpv@pTra+}0GE7(IYb?+l z*mpBfABbmE&}Psab0FKbI;hJx7c4fAj;S84o-?>iFrLYt5>OZH7RZ+69F+%2JxAYiEP!{u)2!FvJ?L1^^*!jA&-%bgh!31=5{NF; zX9iFmc+VieYOt>IZ$8?ZQBUGsoVD4@;b)@3>v z%!-7G&)>H?SmInoJ>#CYeZ9oEDlsLS+(X5kV>hJVZT4L~F`N6y58h|{ixu%GitHP- zHR=--C%+|uL6$i_SW{Hk!o_;Pf9S|X=YZTcT;}P4?!zrE!p~d}k|dGP&K%P->H7+& zOEo$;&yd$(=FVyy(}k#jt1hfrKF*|aGdW{N8JZ)6KFzcY5A4qIVRgI5l2-nqT9pbp zFBZ2>YiX-=hVm6dMtWnUTiIrD%)A<1dp7s(K=_%t0Gk;x~Qs&DoWu$2IE~mqbibZoi<8 znb*`-aUFM3y*V?(!f|bCi977|i$P_bm$!pq4yRs#5aHI^5XRmqHR%zX2Dr?-?P|Bl zZpbY6lU#*VbA$P~30jt9>7&Di;x>q!7pmNRaByA0-H;sL{P>IX7eDU;|M)Xy<=0TS z*32=IX*2HY1v29xyj;}d-pv;IV`%OQrE>VNPzVO5xBeyL?pC*Kj^E>hMZ5G9vbtTJv92ik#!bh_m92dnG5{SURm2JF z#1-ntpYF)|b_7gRXA{aOZrf-~@8OX`(}*Rq>1Ok?n& zngUKzgPHHLrHc_Zm0#IX^;2?3Y{MH=a)X)NiZK|!?DPwzLqx*>ge1bD6BSf19IccR zUpx{H&7-42{r#Z~YN_cBih~Ny}W7;*lg(#WPa09dw5~TSEH< zd(U;uoVNRSX-~k`)_{L!Q2B!wkoD%#c*(7KP7>o2ob8I$H2j%#5|LIu>KSbkK-=rq zEhRBP+3=OsTN1ils?Z^QHt2Gqe*>XK+9i?_fj^_P8{!z^8i5DkEzsIMYEXHP&qlnO zQ`qHx&34V%Lgg)Lo_SKZ?~Lerntigk$&TGk$ya<=k3{T7G8nKKRJ`$1rSK-h8o(Ef zct(_dBO7NYvW+fjcuUGJZrav7r*jWUB|KESB+GrX9REvfOt)#z8??%6(W(PwJ~H?< z)8o(4eFvIl^`!U*D?ER-0HU;VeM+=qL%A+xY{-nQnwcdy(E#HTjY2e{{bT&kzhRwnw1e5|SW=pP8d(LawBY z2Dt*^aBg3;%bd0AxRj0VegzgE+mxC*zBiWjjs!~|1$(ng&y#Ju)9w!G!g^yLOD2^0wCbU+pi|1x=rz6 zN`SP)R?PGr@oLdkB?|U}j59=lF~FFvp1Vmuh|kUg-ln6EGzO?QFYm)D`Q?(X@)H^P z4vnCg`okK-F(HG`xHL+1`OP$>xtuOmtn%gI+|e=e8pigiW&y@8XfB+C8*YA}##8>J z{%$6hPHdn^EyF}Cjl3=LT{p~z5NZYa%Ty9OZXb~p0m9VL?=Z&ey_tH>caR1dAxlY|@Oy>Cg|AUTeK5TtySuR2<$ledCr4tj<{a=;ez z4R=&J(8Pae)G7EV3Z1vHjP6k7W)Fg_7Hpszq%mR*^ZnYBQD7L=?)#;Uhx@F*yr zvm<)Y3}i#9aBm}P7%@(KdFcml*J*D^slm5CuK;XCrQdUczN7Q`MdbAyf>QK2n}B;a z(zZ9(f4^AW(9nHS2pQ`}y`>F!AJ==Lgx7u2iP$zRJJO}HP%{z7Eqp%3`k}sVK3=^k zgxdt&2%dkTXa^^#12elk>*&V4IEEd0vaA>K*@LVT!u|1t$eT_2^UsH_)MtMsVRr~& zDukBVnoleTwGeU>;jo#I^GsVfP1f8}$mzW`qX{~R%dA<)W~OzD$|mSSfR+jEgSaB6 z$ja-J7)K})c43-lv0WC0%^*{=Zn_5j|0NDq7U*9u=&IY-iYqwQJZgvjpdU%K~WWUY*OGCLa7N_f$T!)J0PY{Kap2h(n-62 zJM0StBP^Il4Vlf?BfKklDsDjH%$HElo7_s}H0tF&i~RhM!!Y5Dyu=_+U#C| z^IRj`$k^%&S%Z_Y05?1t@4pgRHZcj-5uMbePV0hYgGoJdN3|{EV&-AlMV)S;49pIV znbRs#g10|{_A&~g)X7LbvZTg0p72ed=%>+=sZt2rO)+f^_ol{K*NYdK$!DiGq)b*} zTr{`(0JR(QGf$Wcywmy;&lHQ}N0C7pB@a~-)R~F$W^k9n%#qOHYgy_9f4IJM(NZ#c|`ja$!NoC@Ab+WY%Q7Xx}9IYVZFmUzjEW!eEKfF&eY6zSe9pziHyW0XC02p zeeEhFq`Sx5_x^@lFwt0$RaefWH=U4^n@rkzx7J(>UbEVdcVkOyWdk(+>-sZT7fP=_ zU>_>09!O5QYhd3$YLC>xi*)b~sXAD7E_f|VNlRbJ<(QR}(NUgB`U?T~Pq19)?FX-# z+c{6w`|5X;QhK`H6&c-w+P8*VL?jdf{W(4jw@jRBOdY?A(gwPCX!E3qI@0czo|r0o zKBY&Bf-1F$LqE9dk^wX>x$0YehDr13EO_@y)CnVK@RiB*9N zjVuA+(Ro#4$u9C6M|H`r{2Nw)%i0V%LQ~c_bYq4B?4PgGR2z zvb^E*D4VK8x&Tduwo0;eh;e;G!+jNI;dtH@U}mD#J4+!~;*4Cz3Q6m5p3VtON(IKO ziDOQ+3ae_IE>lPqlyANfqC-8zC?*8v{>C=Hlb`c=45ZDR_ESWrDZauGJE_#aKAr<> zucB@*W@)eDab{7&%)kF29n?-OynarRUCN^m(guX;c0H4Jpn!N6ymro z{0#Cqc)iRLJIQ8fgZCq7F^&^?Y9GdO(O1cgIK@1FXH2F*iBU?9S`nN}A?r7@x!Y2V z@ZL2WE=w)fp!zTVGb(lgJort`ku1il%>sz_Q^SZqnV)THXQz-+07Vpf*5|n>@DS!k zX@bwzaxxOOkO z6PEPa7E8#@lOHYPkAF4JJz_!HJg}o0)vWULW(+mWjKmxnldty9B=CYSOJvcrgk6r+ zL`Od`=86`<@+1 zzncxJh~>h~oeLUxgO?P#HGjr@LqF4DFs&e?i&l8NBayK5;D}C{iFSeUnXRcDaVbp3 zl(>LcF}i_&a~R;(DBGet=&T`NZKu5KpN5ym8G15-t4LPG^UUZf>jP34T!XF>z&Cca zP~>{p{@5G{sh4*B&H!5GAX@HFrkNEY%9b-!22-P>CE9pOs9s1znzJTZQXx?a`Pa;e zB&+&QKK1FHV@6vrp5pRc{V9jL^k(el^3beU@+jc3BGl*>xqOk7mgFPGU=4}rgx#(1 z;P~J^(8%8TUTD?wrmpLOt=TZF3!5@^mBqri9?s)L!WhdlN& z4ZSkz5loGpmSzH(4L*@_PP3r42*Ojm*T}Y%DaEJR)l!qwAd*W)?Pk)hdyBmoq)P(@lIwB(+M0ptXx{O;*<+f+8BbfE4sM| zmAhS5FSEYS7BPpv4Nb31ZxkvyQr!c~R{fACJBt9FEvXnTxGa3?O2@|;(Z-aaQojAU z64P?`p%!E8f@=3odpqU1<_Bxrt)EsQfAQDFRN&{}J1#cFmSN{;I=qa?su-^p?={HZ zoEJ>p_r$PP#6%G0teGxW#a61Gb}w$SnA~C^ZXO4uKhCd-x3bqpP0CB;l)36dhE8H& zr<5J27Kq*9V6GkZOL=GW_+=Y00xnwPlfzH;(L)qe!Au+3k~jq8-3L}1$O#b_v!Q~*PF+T_w(QWY0_6*dSik9 zG9RG+Z~ti$=2I}TH`B8;b2s{L;Jyl!E9wEJ_vhy1)TJ@99>H(lZ}M=Xq!L`@jZlHX zoLDI4hy&`5qNH}V_1GpZN`jV3mW>aE6vAc775a^hbEGgJ2&RA-_l2gWwWX$|ttYPv zukN%>%jkpaw4=0_n5)m|Cy(yW&!ZQYM;;KMpb}P}SqoRF!VSHf7nd(3|GReCPC4TH z<%BYvN(iDOXHM*ijCl)bAhIT2U*mIPq^G*}vRMmHU=3`DoxnHNv8Q7FjYumj9+W=R z4dlM67AfJT@iS*QF9y$$4r^%O6rwY*ey|0`CFGiYgQ&`5aOfzY1>woU^=ByiidrP( z4Y->XjQu46972d}1Z_BSdKZEYG!W^Ta>Iv}dmK{kIHO z&{MN6ei0dw0;0`UO*IV{iWHP9|7=P!%l`bOAc1`1I@SPCtmjW-Tu8rM)m^KwBFc`$ zEDPkezc~@6MYq^&niYV7R!~QFcF97L89Z-OBt)vv*qM?Y>Fx>FC=(7cQwl*Y*De5R z#2+&ah61KnSy%?xkgdfWF>0BEt;Bdak0r8f=(EFTu~JwYGf*SdQquJ~Qzsr!58+vD z2BKDq3zI4xV$DjO1tKtStfNi{U8P2I@$|8KUW!q&~ zB0gr;Q5kRq;&&bg+L{Cl*`n*XhxQUbc)i)`kH(;JD{kVWl^agjKrfiue`co|6)J?` zEm?HP4U5>)pdUKa%!y`CmoLxy&ksx1D z7f9^oHG$g(x106den$=E{k}{Zus}gTb z$0{guDCQD%z6i3W6rw~LXh;|2v&saIhoojgfHQFyu2PdMS2UK>aQx$6};ZU`gp(rtGmaftBJP+hV*0Y`?S1hI7`yV;>(feMFv6K|=6YFt&ZaY3ZTyX@z;R?AUEZGO<4WRNLiiJX8h;Y2<2a<|N%oCXx0K z1w?wqaJp!=5>4}W1 z+IUrCpK%;!ALmcb41o~v@{EHO?~Riwi+A?A{k~eN4}MzZ0}hjI(^3- zTp0_>W0xaYu+c*{zJei|3QjBRRsS@_XJL`wZIdl#?dZb>AulVv8h9nA`%TS+Wc&e) zF+ck{V`!>aJlqW~l^z3;^2l&M6;@9y*}l+n&Vo5R;+GA^o~tCCOf6NXq2ArB z2+&30Z=U^fkbM}3I7OxPD7dF>TBbxt89$cTB$4s8Jf|t zR8qC5(FX|2X73?)H#^+@W;fBho^G9AhWtO*XGgQmSSGif!JRCw&)iO9r1XsLAhDkZl)kI3_cd+kz z+XZo0IuJrJ@Fz3}Tr+~35qWwibe%;4?h-e0mD8u(%ZnB2Ez)}%(IY(1%NM~czP@{J z_dJq7)mVc(5L6L!hMA|lz|A@3rkGY3cjB?3maNi9R|{tY&raGl1U+a;@)8@Aej`sK zIy1zClU*K3wWG}_d+3W^#jE%Hy8Ppx#lJQpFlX!X`6QpNuWItQbS^2MOy~?QmIxc~ zHdzJdCp;6!>9ent$c?dvkcz?v%t#e%aSY0e21X-2KOz`Ho=0$XVfzdViWP*EIW4^SaB4m9d~gQ3$MDjOde9Nt@r!Xw$Zpj!RII?RjLp1Pp~JGn6xil>*5UhBZK(TwW)YqW>5pc3Stt@4?V-UR&|t(-obUY;{yPa4 z4cLEa4^}g z$WiW4Ry0+H-YmZb@wU@9Yf~-@x(=!9iQ(pvFZYp&`jBNO<)LimC2Zt@U~;q~FdwKV zr|-BK8nt%gUrpgIUwef6DC#{2Dsugo#|w{$u;k4F`cEA)k(8Aebl zR?qdVmhNpdSI(%0JOBaeZ-(aJ0;{2i-Bc6Rh;Eo8D4~b^7Su3tTsppOUU_T`BO4ex zH-Y9|8Jql}yTnRnV>;?)WFu^f(H@$1;ZU4zUh*66ZDc|mj@OV_TBn0VHqW}Mgf4R; zP#yV%BXJL6q9=+iyO9xrH9@=CHe_`Q?#8*eGltn2(gG+wrwd6ls6{-#*@E{3R7QK; zYr%)S{-)g%;EIcI(|xGNjMu(Ecwb=*TdFit3V$w#U8`a>#N!0OQ()Z{TMQ{#;C5B# z_P;2{pJs2^5RW-zUvwidd*YDxlhTJQ`?QZ=|LvR3RLG7!faR1dpu_u#x1Kq+U^+b@ zL~Q?UT#-;^+x(}9SyN$h(mb-g2c3YG$!J6E53~wm7!hZvn0E%_GY?u1`Ry}@Rjn~% z>2Y05lvVLZnydaf^$_7j_Ar22*tIx|Ij%Od3HtfK{;WI$&g7Ms0wzM}fndjo))~pf z(75U-eyzjxsqD^NMjl~OzO{pM<-=+y=`Cs;TL(_(#BBS)=l}HB2*msy&-n5_)PH#& z@c#eahkpW|{@c0lBqt@aL5JvNoB&st=ZQu>BaevOj`KsblbXLuHbQx<&(Hj73kX3p zT!s^pBik5S9`X^dtv=v~-xE{L0p$@opg)>@baa!!n*Qd~?DFlg=CXef1|LTCen)q- zUjktqcG9b?h+EgRVa*HTh>jBlRv~U-w?!1P&vO@4Xu>jaQ1hWR?!Zfw<5BYvR`*An zI*dc9Yc`C2a=`>K!LoANjBy%t46KZTHOmtREJ_K(>;_se>ee!{LfWuiwXE{vbIRXi zf1O)dyR1MhDSMy(5CGAnoI6aC`8q+AFU zAlf@lzRVqZs_tVn{ktd-m}tU2`l)XF3BB$6<%ncCCmI#&c(YJaKdF_P)fd3}_Ig7p{2rbc@-- zqBvSB3U$ff*rX1*RPI7kYwl5d1980x2|;;`zz|5UVW)p_q?V%=(<=mnWhFFt zjX9Sa5B)nanL4i8PW(&Og|8d`Kgde=U+xGeSt*$>bGcVgkXDM4E&z2l0}=@A!`usc z=Bqme2?%ShW0I|F7_}z2F>#w62;l9(H_8->UMuvv$Z)$WzI*t41C<-1fG&i?R@zFQ zdkLHwii?5}xZ$TTqrtqbdQ9!bIxf>C50MXhTeK&P7vTvDyAi;>ah*U(>ufGGI%F{V z7Qm_~P8^V0QuebL^VAT{)@YZQPJOsnsxL(%JM*E<3&N#PMU425k#hff@D#e|G-6~J1MUZozWSBDsP(ws9}v95p8|XTl>s;L$DL$DoIo6y?7gh<4M1XO&V1jcsuR`9D_|sT5WH zpDzgv|MTkl2fE-CH*UQ^hZ^iN9XON_oE*I-KUVddma*RSTbL3|MtBCQ?(FQ(S_g*9 zNKR=@cIl$q?_3Djv8vbK04`gQb_{7Gs<$t@3ERWnG1H%(udqP8HW2{S{!#pk2mZbc__f2CT!^pnZuXP(P1L=L%^|j)`WFG@fFVEV_;!RxHWMQZ@ss zr_`8D!p*7-4vNut4I0*)l(Aqd-uuGG8#9^0MD8RpIy+3?lN`7I zwEJK|h#rTb(sB2sc+CEuf<3ux{j953%RLHlF*jSOnUH2~nUkqFEu=F>x6^qKG`-rx zs(L60%YpeFt3$X#SaydSUxf%Xbxe`7G(7>O!_L`DeS$|{!gVjkOkofzm$&q&r1ITbNH9i^S}Rv*O26< zw-yIYl)sc+BmND?U#U)z7uxP8l>f69o3p?WYaJzO_@^rZULc$(mFqX{Z+1swh{JYh zR6X(2tVd62K2w-J?|(l)eJxsc^THBvO1P-@n1(T<>v4|QrW`bZEBh@YwS%=6`4{>9 zH4P;UMm7u!>sbT=^YcWbHOS?XJT!Bn>3*Te^6GifLJX+FNiY14=Yj{Yy4P1GX-u7h z`>n)AL<`0^p%bK}HR@!&T10b-sgq~zu-ZE4q{%LdW;?W9=jRbe{_tH{gJDxjEZ)Qy zf-#zoUX?&ZP#HlMngP|5z?eG)@H9sC9UDm%L1-2>Ql6?sB-FmT~HKp^9RPEAzxN-yh1kIVTEr2BIi}4 z@JBS#nQBfu&M?GmFI2e2y}M!~7kFhRG%-OM zR>I8hyhI;zCVIpGunJ{S@?900QYlno=RHHw;#%%mS6Kg&9l(n3fIlRV9r5$}N9Y+F z44Urf(;bdZ4!g_y&Qtr-w?DluGd*I_3h<|FlXk&-RKx7icQ|J_=xj9hmbMLSYs{|9 zn);>IWrC|2um{Q>J+ddKafYT~6mbakY>CCReW8iQxgmsDKMHOi_$yb!#4&q-TQbOI zZE>OsVq@yLlPl<9QIR%{(eLfT1GRK#%dD80*;5m;TXL;I?XL5yDAQn8o}8G%97?0E z8f#&Ai?*wSd{m6rqQrZWkwp=d$FUKM3Td$9N}>wK6H^T1vW&N_axAP}i)WC8iE^KV zk;xCi+l;DLzZS&gkIe)!_r!4C=jwM;MqJ_Hv z=#pH|An$AtY*^W8s|744pUXU6TWcR5Z+GavDy~SnXp}e=Am1zPHjZ3-Zek6x_K=1R z@MS!?j8eB$TJ5Vb*D^GQVYmD+MT1*a4{i<8Nah}e@<->wq$uudYs%MTBD1l}{6S!M z-ndd8e@EoU8mdJ_;R+MFtO-wH;Nq&q8TDD8pVNbJE37Hvl~V|@vAekuc0p6Tv&c05 zQsjC6xj6#sX&Ly#E&_|W2s?#lfRU@DhPBh13c2iUdpMDVeC(!>3zX9+RZP(RlnN@~ z3&mZ^Xn$ArZk$xGc>DQkkXp?VCSKxrFO6D|?Fbw3>0F|M5&+WQXRHZn7KczEGa4qj zxwV9DS@0TYK7*~){Bx@~Nw}iv+}X$1iL(l(f!BpoJD?0=9_}5YqgOJ>A>2|gx&bui z9^r&U*)|AQb5B~UY%1DqgQ%%iR)k7F>{u`Do@Uaw!@rHw``^MRt{|C01iq9!`nvza z4*4IZfK%+Gbl<-g_Kdhi6`>N6oC}R_&|(yQF9yo4O*jox3*KpAVq$WG!uEI+DUIhh z{L#`IX`_&>$+Wl497e{g?P{BEkF{2LkxD2Qq~>UcHP*S-x&e8fs6%;N#xvJ=i_W>W~{qvq@he5#BiE;INEriO@j5zqcYgQ;NKiOz2uTRWUAx%3 z->cek)lpKG^b4Pi`laPb)-?Sioxs(aVKUgpuZ8!Lpvi#4(y1@%*2)?XcWq>n++d9K zc&sok%lDaQEy?laNi+plGw=3o%!)7I7U=dNl=m-UTl7OXejXs~s`;Jvmy=JOV6jHi zQDrCgRP~p6u9R%zZA}QE(2B;@(VBaECiR;0l7?2xZkBPCnT1KdWAQi7Z4GpI9rP0TXkz3%wM1oV* zW$k5zu@l)n{oAJ21ZVDu`%8_@|Evhx|2JCn{YLbXfT?OkDhm&Fzx#<(xg|=c9jYTX z8vrpav6>iPN3vcO#ycKCiuVrkLB7{uFK|?2b2vGikyU*aBlFFK%~7_$DGC=`3R3A@ z-BfMGpfqckVF?{}$j)Ry7k(~Gw-mA#)#b&LYJmu!Y`~Qd>(+2UNpnDAZegCy;9GzP zWsz(^ph?=#V%$QC+t!7!Tc>o=kH+0Qb`_CMo`Ad9Lkd(CJNiB?V`<~}w1n#-*aW5s zBPLY$bZM#vE!7&cSy3o@w_k!vG@9pozIhKhumS}b$44B}@7UQ=A)dW6@9mj9-CxYC zD>m{BWE!GRZ!VO)%W8%!CFl~zIV|V`3)DB{KXJ!-7b@8}Z=~ zgiW3c|-XpF}(L);xz5*1N;K$*JY1VKQF@oVJ>p1KsuB z=m^01TIu?VLCuuGmz4~nU=@olwbPLbqg;<_P>Tl}`e7slirzal+LZxFL9+{Pb}E)h z@7vp+BwwoCS1*Y;|3d))u6Zg5&LNcmRKHn`tSG3b33!V=G$;PEs~^}rf+O?7NVX%v zE$E_GXuu|6#nJk3Lk=J3@Y-~?Z{s*^Z!j8_J1Fe2pSof zIhfg4|5yEkzRpViHB%q-2RQ)*g;1jiZgTN9T$fT2e*^~tLHat|6{(Up3pFI)89yLp z{%L(np*@hj11Xa&kFOx2zk3gGJ?xKKhP8XT%e{C4dQ|*rBW(J*S`e)Cni+mO!gM(I z`rJ2ehKZ#6r}S}Q+gD7~USF2*!5uFLI>XY>_;fbqkH*7#%w@rNI?k>G*hZs^wJcI7 zWf~*mNx-i!zb|a7GFS1N1UF{bhbP((?tQ;}@gnpP&8U`Svo7+(i7ZLe^v7vZZPxHW z>tET#{;5Ow{kUG7rr%u&F*qNWhMNmFTQ^RNI z6jL&0eg}VmjQFwq&X&H1wY8+mH7$rx!dBz>zQbYEHR<<$0<*%1%Rr9wXJr>@wd($8V%dfTpBUu6PL7D$KW?@5HL`rLeiQ4j z0(3ET82kiJs3HBl<{Eb2iI5g~ zo;G*#pL)F&eVwx!>o=c{d&?&}shdN)3Oe}FY_#}&+gT$p6MeGhapRQMvl%(Aei=3l zxW`#;-~p?CJ#=}Fbrs6dD zXe_1XaV~P8G`Kb~Wj~JJP^i^HNA`ANdz1Nq$N)C<2z?Bd2>d!uN)LOnt=cem^qcBV zs<7}dXf!U@eoGV}c=1!yAN7TCcwAV61vJ=|@1&hg&Kn{Nt$G|Ga57p%C{{F1e`oj4 z9&;b{>k#&R#Z1paI_j61=h$p?W?Gl!UWE?QkU<=SWB7zL1iUW7(VQq4?8V}6?b`&G z(1a%bPwQj|(bOV>cu-Ta#F!n5RjPPHUZf|JU5?@@GSxnGcR!<3Nw4EpsKEaPX+W00 zk(w(OMrty}yG(OOygQU(PYjVd zUw`^neQH!6Lq4>3aD%)-xitN4TnGCJP)h>@3IG5I2mlyXsYIC;`MK3=006Y<000~S z003`tXD?xHbZl}jbZ>8LFGq4=ZEaz4E@NzAb93yycYIV;_5gnFyYIdGX7bWWU4}n%@t7 zvprS%bdQ;Mek^m)rDJi0)A0_=M z89>QEN{T5NM9E;G4e`TRtM8$d4D(|$oRSefsMJdQn2Z!!DLu2OxC|5Z2SY0tT7@5u z(ne9?X!?8@<;GAlmU=qe4`*uQC>c-51WG3QwIj46g;wc@dFl_CXp;7IvgXkDnB%7ql7ly4~w)Jl*|-bwI7z!%XV!RaO8mB>MjfU1l-7NHB^F@?fZ18^cTtYRL8rm`RaxA?ZN6n8H z+OKG+Wqw$roj~IRslxIMxL#|fq=i0&46RjYE9mn|q#$jIp@j`zWbpomcA`&PrM3CA zcCCY|M*P}p?IfW^{ctg1HHJ?uPDv*Xx`ujROUcPZ59_GQQ~Yd?cB-EZ)lL)I=``pW zhIS^A!&wHOYbe)K_H2U}WWZ+aG($T_Xy;OPy`gNO=Xuo0`5D>;+Jza~McT!bTta1+ zQW^Gj8Fg?uB?$Nxv=CPc?J7S!sQy5sT`07x@kP6al4~iMLanc(}D$)}Eoi7LKK$t#BTs-e9`+1Gt+iuMNOeoL$WJ41U@Xm1fPzxTsW#8y9PZyVYl z2#$Az_O73SmLatF{7li_7upAYrfMHj@<;mekG>Ib`CMp!qn9t}MAa;u2G^Jx^6szTpA$HujlK% zC@G+_LL^(gHzGmrW2j-j9?<*JxJ8EE&(Ql*jRDAH`anZ3HuOP=V|_3c4zZ|6AL?ff z`Y=NuPK6^3y~NN*;u`Cvl%TLXQ!l4n1tp_MLN{ZgkESHUuOFt5p$}u}LyKQOTpvfX zAMe*E=o9I~5q@}GKN2ZJN0FDM`{?T=Dw|AYQ>e;RLqCd!nMO>|Z0J=4{dD5RJN^0$ zeI_-jrm}IApv0@xXB+w)Dz2equA$E(+}0Yrx1rY=dcC2~H}nNQtbH^k4I~N?>ScPP zUvJVj8~Q>+UxZnGoS`o^^d*MA)X+)N>Bka4#~J$Z$o=}SsAL%>C(xilN|w_r$vnN8 zCeT8;kfFB-uJ(%Wdd?NqUYauEV)HRVq7v27?IF&7nj%+K!8 zIPN(Dyn)jJhb`~XP6G-QfK6?Ta{am51M_H+# zN8OxH$py477aICS$UOSR^z9NVxzx~6=FQVDr#e?qawS!`%CD``ucp^)==EC4T}R3F zG=&?8l5Q0G21DQIXTQ^L68g>fL~h2HTj=Ah)EI?lbhQhJHU~9}xP39AN)`0%4n>KSV^cogjPI(07oYnMz+s z(&=4Pyo-`YDA`TPqbTV0JtWST(CcGFO^;LV2}(%T=})1I(4VH@COwVk;vQ*lL zB1ec^zj7QE=J}Oh(KFw#oM3(IB}4&(oZ8^>P+N6ds6EsXUl0sO8JIO49iixqwqPt4 ziZL)|hML2%aHNAle&f>m1r60Rmo+S`tzL$?Sv5--J&wt7i*!?K<}_pPa~ zX{xEJT{g3NMhz7$tF38lTGm)|Of>^mgH+AR5rmrhMOC#mHefaNGpm>I{rDdPzbvV( znqFOtb%8O+XqrE-x;{~)FvzwlQO9mEN8H#olgd@>bH*Hm)Gg5vF^g+zXU?ciQ-N1$FahV%6#fLliRTZ7m_5jx`5Y zhgxQ=3`XrmQ;w}+P~@%SezYp1O(B<$fxe)sp^-8fa+=PYF=Kw+^qTtWnK-Ex(O`Rf zFq%BoqNLJU;kHnHuszh++1eUD8CPIUur1s&Gt?GZ5sV`VA~^P`0Gwx%Nely`^$(&R)spIBQPQ4 zi{e_VwIPhpnbum$Z!Sxz9f$;c#McpyMP#)-`D_c&&Umt!9aY7)S{pGw;)LR~s!+?EU~HwuI)yX@^ws3PeZgWJYHLUD_2Atm0fRnq6 z^d9G#9a$5KM#C*Fp$;2GLsC)Htut!ZyTy`}?t+D)p^j#1-=~ehrBV{Fu^L>D_T@-S zEkrL~h+{-&LsN=+7*3bOK}4}4LD^|o%tKQ+w{S;G=;WqI!m7ygjJ7C5tccadcPs3P zREIh}Ntk>qLTJ1Mv3@cKHzRN2CuGK!&}^p)*3Y5!Yg`>{4$W8@YF-tJreXa0lq#ed z+SgOQ##F^SW72uTYU&qi^R{Yw1XYU@SR*vRcO zQ1uWsE)KS}%^*qI6mAdIbksE>C(K1Vp`){XIg0bv#!x%vnFu9vN2$t03OkX{X1c__U#gkq7lHKCTp z;rL1~to>zUobck6kyyy#d75m?{7w=k%W3j4YKCl2Eop*|#EHpP*gCcl?bt+xkv&Tr zckQs1C2(R^Gs!gAO-oG&eo7uW)P9hW-3kS`Ue45=Wh4&FUfvmQi_eNi+8wJ%j|Drz z@pU9%(-VE8{7yVL8F3n)%3xMWs@y-g!0D#ZMlM1%GDE7dY?NLhYk``A%iBW4r>Lab z76qeWdbbPJ_{wlBS@(M3L8%^`;thaJM4s1t@fSZI9; zN9+#`NYoaqA{EVY`6pwA_pMjS$aI#rz$R7&fnHF2W(0|?SEQqDozt>D;#jB#u2hJM zQS?yVMod;2V+8%8c!*SC&T6u{sybSxop)8LQ znw@W!QHp}z`JP|mezVI6Gdvz6q0!xPb+M?G~=IY(9?N#Q4N9c_)}5_p}x`O8m4 z$&4S>s05#dU2T$pf(#u?ReI&Bz3QXaj2&&c7gUAFSt1214?aL;%Us3UX3Wy|wvsGt z2?g7TCrJ+>@=)T`Nm}+TchoqJ5b2DsCg~xfmhp}>*XpU;3k^@Ce2350wJ(pfk&S8< z*PxJ&q1=^vEG(dp+G?NB#^$9M1m1DzZNLQx@8ImlTqLQ8%Y9!h^hNI_^ zO}!pcgd}reGMkcLWwGk8188-x%+5v@sr6_pM3Cix*c_C2iMiA&JFSVkYIO+qQDa+5 zZR>1>8)}i=de{PM+4P25(kf#p1eEYlB;DnmtuDoT_|u|%X@1x|*vm$Kj6`TdB!W&u z9rl!Y5-PZGYuFOs3`)DrzXuc(68Z&OTB@RPY~CCWw$%mW%_}AM#E8}yEbVE1$jC`G zs8ZjL8F@epNsC(EpVneM8Jd+0p9LONcv;iG!flPD9(8OyX?$B`V!!9KyVIaqP<0*6 zd5Pz$CZ7>}$*FB4xS=mlxb ze%nd2#?PYc^w5fMhirtFP!F!H{7iz78dTFzvN{jP6BES z(Q}sihhQI>9;YNtn<7{pRTugtaZBA;^Yl8QI5)NA7}7d^L_e-zSQ^LuQ|F6dyPt`T zqoEi&`UrJPk6!#t>BZ+c2A0IEJy)Z}btH;Y1X?uOxf+FzmsiB{AUal|X!1DH%bsq1 zA^fz5TUJNHq@ru0>5l<~tI8XESX_A!@W30gX$A z2DoDc62@Xk9q75)=&W5fW|K+>XsEG`|!<+B_5w?&5BSIm6F{AU)i{>TA8+_~`fSl!!Lrsj3iOzg$q_d+1mr6cy09TCQnuHKpw8h;L zj-6;NxS%5G$&WgKy684jQWj>$fnYM^}wFg&)h)@uK*i3isgG*8cV;V`xW6RLYGs856m?ct>nL;O%W7n~wF5J-> zs}HTU4-^o$jOZ?ko+$bKQQD_L`nQKn)H0nFAc#?wR%$y zT=}5u_N&xsAEZSpQVu#mUUylEj8jr`%mElXt;C<1koblaC$c9&B1Go&)*#we#B$C? zS=&0fMTWwvDKgV5vCu^8URa&nih4rt?HJ1>#8s81LzCQ-#_}3TV`S^fa#T2Je7qXz zQpOP;B!hUOy(YJTEG@dmZtu5xvn0UElBCVVG|p`DR``L;m!3aK@TART!;qOYD(Qkq z3)zrSnuXlnGK0|-menp9tB(bAcPoWK)xmA5Bu_S-D{9D{202o8b7wS)?9$-c2}Z(X zDZ~{@Ybh0#jO@`6LSrOtGjwgzx$6fs-g4}%63;HlQ9a71bmh)&m2{9#j!PM)$3pEh z;wRH~(;>8Qy);6J?O8Es{bj50f1@KQaFKBwPlU*%eKm4bu)}igHMv(xiVb12EcIZ5 zi2PRGT1rz^bsa;7Mp56GTqeTrY+Rq3*7``is*P-pbqvbA6Fl%%qQohA1T<)&eSU&A zw&U$uF#5?3cZSbRqMroS%(TvDta^6C02%rzYgY|p8;ucP@JLap{lQx3K;2jONT zZuck8vS@(C=$keNqb=lw+Jh9O`GRJc{WULPL?qx6_5rB7y(gjZw8~Gk@|60BT`7ww z9ptqV$+D|SIY^i!cYv|7Mf2)v8BEiY(j1x^cSFu2jhSt4OD1e%t5-{Q>TNbS4JqIp z_#ihG)*cS@ib5v`+Yt>_ZEe*jhnhR%v~lQa0uk#7TaggnBW`!2;PBD5Rb;E@Npc@z zEP1>Mb&TCq9O5>da|C^O+HH)3wdyZ-T5%%IHWJz;n29;dnU5|>WKAfgG_NE@*GZy` zhFWboEhPGB7bwG8l*qhr8!lSFvLNj>lfBWJTF3IMWR+a>V-qK`R(G}O*yaCj$L1zE z(e_pr0xzY4v@>*klbMVN$`90n@%qkoYlgP{+bapoCP&GQ`DKtwaE3*lek5B-q@V#~ z={;A7rCF-lM2vtuA1+DbhDuGECYB)CT(Q`)B(<#P2!lKcOVa82!7RxC+o!bWSVqiU zDS>JtW-V1XR^7fjzRn_<0SAJG^ra>p2HF8~WV02PQV>kCMcnfIAjNd0mgWQ<@#+?t zK^raBYj!wR6_2!gTtXGCKLQ|bMJ06iXp@HNzkHRHb-w96BWp>Qe) z%VQ*o0&ir|0Zx@_XirDBvOq%;uwFwgi8aZzirjOd!+xQIO9ztSNa83X92s3R-@83) zw05@H`ZL=(yl_X$vQ z)E%`>!vofdTN1(9+%h}ipgAY;g^A+2;K}ah6`ColaQ2yf3*?h4#(D5Yl;?2%6gF8#TC&z@e9R8(t1{P#v^X* znsu;U;Oqxm=SJ?)KxWWe7vC*Z)x;Lj$?`#+K^s7MEWO-~Wbj+3?3U=yuuWPEj@)o; zdTP8&rflhKQ&5zr3wI=x1=Y3gW|_i@!|~- z%t>&2O^nXaEf#BVjy@0jWd@)$N9{%Q5?eYuGVLz7=WuhzFW%-z*GskyO`W@+doWIS zWm1kik;rO$9=(FGSa?N8av&Rn;+~EQEhvah=^QX_2O=e6AcrQO^7V8~mSycJB--`! z^peEaL~nGY8fuo}&Z3?^J=G@2(;qXYU@-X%Bj3~Cba$V6K+kirwu*n5O3xu~Ur+Ijb=cn>A8xEA{Na! zf7nutjnrUv4`C>2LM9I4woxF)awiZ&TVttSG9+*u8P+7dzouU>-T@_K^3;rwyV=y= zL&|gjk4R6Vz)VjJ2FZ;gs&A8@+*gk$I799S9*A5IDst2gxq&}0UA3lYu*2eR^89Ai zG!U6jJBR>2ga`t)cK-Z%be@IIpEp>Xg!DlJ%88MPuv1zNN#cW^V$riahPXUx?BAn0 zw*;w>>_#X0c}X?xYabNGYJJY{7D!8g77^2Q#;wgzvS5hNTt{>SN{mB1ql_nRu6b?( zBrbW4KH#QBx-JjsksXu%kSVq@vew;YG*@GB!c*;&h>l%AA1p^rVxb`I7sQ_If!J}x z0b3@Qob{lyA+frxd{blAIh4_7G;B} zJfv(lm4}rL-Krpwno5^)lc_vH$!<#aP*=TsIOR2!=ar{TWgk`ijdByNQKDj1G#Xq- zn$=WZR9-TbS7_*0mDiAnQ?Fkj)S{26yso@~{CJQH5?EJVVk&Pbzek;V;Hwd)^0x8^ zMDZb>U^4hlMiUp?>rgzIoc^hk{FB42CAQNza;lvvKGk1bJlTG!Jauw7K1$Y}LOB`F zJay9K<2t6EKGlCZJ^hnIXmPhrm7Q5z9oU(bDV}T>Oe&6rRtF`^P8nQYJQ%xhS|tu~ zW99bQYUQaN<-yaYP41XleCp)j)YJVq)@1v@&<4o~`Wz-5&{hRW$DN4jhYEo({*DEVgx^|DqXHb|v z6d&Ou(8`qWlBS$C;N4XIN28T1-;+l{^+qM1W1FIaz76OWzMpjQl$Ljtsa&mGV~WwD z4;u3ai;XqKVYDQDyY=htKQS2AiOP31@_wkLI3_<9hoaF)w73b>I_-&>dS36BHPK-wj4JE&+o~W)e#RM_Y z6i0|7(Z1|aNtmLNP&-N8YAR2m{NpouwJ9bONlXz_O>vZ%M)6WI@ZXVk9>Oq{8%Ur?TI?g3a}kFwUAz#ioVdk%5UVWNiU zZ?38O5Fcs|A!Qzs_~ptKrl=KlG>dw)7?S-XQ_L45k%b%qV~PcYzoP}+%l1eoG~<%? z%S_Rz4l_lQI>}USR5l2)&=iZrVj-58Vks@dJK`8qxs{YhFI$|BI+a9exs;-((-6lZ z|14W(s#lBS9Ny@*UyUEqFBmeQT1{Mdys11#;^s2tECxqe5%HUr8deqyae^s=L{iI% zhMI}`^3%lQo1#U8Owo!0M7dkJCuzoBd$c?4CN3fqKO+U+tK4U*7pRkjKoOLmX1B`} zVR51zkY0?`Tr6V(O|gmuYyYiOXn@QRKI5kj%! zKNQn)uSK0wycVThxTBbE23JI#<2;G>VpDknI};}p%GXi1r=VcxZMwb>mp7**U6 zi5JH@!}7qoxD~}oZEeYzkrhNa?cq~U?x06o?BL(z8~8>-&P}HJh`QSprx1ubRcV=m zX7K^y)e#5Ex28B%oQCz{YaHhNv z<79A9jIV`T*+WUo6jPkdv5`JfqTLkdAdjeTshg9uUs_+w6zAerGsS?YbL zfyDJhz&8+{SS8W@ji%TjHll-fz{q7&eMuk#-K@T7s&A@8(2q*HGIHC1*2Rs~ch)Ao z^s#2IK4ywr2!XeXO+suo#clL*J0*8eawkeK{;=|z5WhCXU8Hfgh`SNV@#wlFHbx{D z2Ui4tks9tHiFq%v!jR@jXIqP8)XPn*V^yT+99wY8E z#a8}GdWvv@p-pi=ae&?&iN&ea1B7N@v9;$}j(zgtc9iZ9;$nzx=--Hk#CB6WOt~G( z8>ZMP`Uufwie2InQ|wmW5aLl&>_NEsyZk*N5KWJZCrth+nap2_Cr$nUnwjbi>W!uv zQCFLMoAR0|o+7tM*q4Y*@ihN4F7+}~JfnOs#IvS&4s{EEm1E84#a>hFQ?EscS6T+6 zdI^e9{sezAaSdsOoYxDa%>5K~?A(gX9zD8vsI=pXW6|c~!KiZw;|!VK6u+VQy-3OP z;w2$o#?lh}cPjon9jl#w6lPFIv*S(mdRpICNShZsmcpo09XF($&d|&4a;e#0HPz45 z&rN~hY)f^oxg9256B~UnZII+4>3`5)jU)Dk;rI7 zdh4TGES4!gqDB3f@bn3pBis1>#1W`bKNWv6#h)qp3+bZ~YKh~ad!rdl@mJ({^(jhP zXw^RxPardfJLJY*F$D@Zs7I1j&QnnIeJ=iHiZ8^MxJJj3jQG2$9*I_&I)Q&|Dm#>& zrua&|g}k4CAUs5Zi;1R&@S&!9Jb^bs{KGLxlF!xYdYa|Cn&O}0UrDI!@drxCLjIae zZ#1>P5#JJKzjGX@?g!nb_?}eJ58~gZ_>t_4pD6hcCI3Z(O8k$KpXuv(Y^rCeXPe5iv|Jm>ZM~V2 zTgU>rlPu>=$nfe~G>4VjX_MnNdR;-la9nEqKzF$vm)cY>GE`H&n37Axai)4DC09{$ zjiH(RL2P2^>Zhh5sPP8%Cetv;@k;e^Q;%>=egZMf@%&flnG#*p8a~tT6S?21BCR}v z>PY#W@}@A*g}lHpg^_8hPa9dL`keZ#X=EEY_)79EKZ%s26^?QsW5i_php?uOFqI3G zvxJdLt@2Hymr-CEg+ztwh~thMAs-_~pu21IHjO?6$`{Jdh};p!b(-okIGFkyR6E!< zU>beV>@$jtex~{!>R$B=^-D_rj#8x(2OV}un`1Ome7j44`5?z7BqrO?_?$BOt$3Tx?H z9&>_VeW89^lA54cR4r=XghtV#p~Np_Sn*T&G5ZY9swtO5-tFqPStL6VEoitRyU}Tcv)i62 zSss;gwS|V#G_ckt`81KWBR zW!zXFBiPb1Vbuc=uY|k#6{9uIR4pA2- zMF)9)IU}!oDb5^uqFx?_CjVlMJDnpBE&MJm+@(FoMs|E63hN%MYLRMJ6ye}W_1^>nMc z-VV&@l`a;It|N!m+9%=zOAdCbZH0BjnxkPin9&o7Ltm?!$>y~Se6d8_kzvI-P`19u zW$Ow4Zog}m_~}EMTG>G~M>2Qj+P6{Z=eX*^^s@r;Qt(^`L(>oMxoa%<+y^w))X%Q1 zUe+|Hp}J~j^~_~hXW5MT^^2+-te<|(TT4GzQlETlxnH^~h6(jp=m}p)1PD-MUfB5w zFtjbwNl6)%<8yzwg2AY?bl}7hq%jH9a7Sx|!T3X2m!w~usF9{oZ!ax3bar$k1mW6X zI8GPk(CP`sLQaHZa_CvsiWH*i7pM7?J7Y%xSJAI&E_Qw|!XJ0h!=O0rPb(xvSoA+& z1^OkKU{or#zCELj!OXNsO^U!clo$;y9IFpoSHa?BqonzDhuFcR@#wNbOK5rL3W_m2 zaA4KJe|kb18}0>nDeifYEWCoWQ8)OtowgK59N0ASi0R6MfY{ToPgo?>l0q)R4t2AF zpRIs5`^QFlzH1&&LCZp4_06%4n@-$T}< z>DGhau*eGLTi6jksWasKP>~i5$*8zok4$yGne9oDfI0SU=%xt0%e``)b|$LgmghGE zC3DPs?Z8v9cii)X(DrA`2Br9=Mk$N45+K(F$wx!xIT;}&@2m!4x4LjIb<$~P!kD-1 z3TZxhj_fFw5DAP{B_kYLi2hh~hLo-%n?E1lf|Ffc+~x zwrBcVR6T~qSN;+%Om#6c!?C1m;d$ZM%ysDfg_}LM!E?f~)SKV|>EBS)vva?ku{)dP_D- zx+zi9A&sYj2MSM=i0&iXI#)208V`2w#kM5w!%CON@j7WO!tS3=5J*qq6?Ey?kmo=( zB*xSK)=rK5f$kJpHiN9@v|gKIHD^g9H1OmCxIcpITN{bC*q1z|E~4n) zP^7IUMt_Kae#bBd0 zwBT-JFD23{FUzF8DB$_wyW%v4#?XbN zClmM(nwa5OP2+qrAELBNSddN{Op>BwPUvJOXnSD#%MhM9W+6dZ)@)Twx-=r@{4~vB zJ#Jg}cnM+VFWo;(7X}W4V7t-`0E;1@tWZ`0Q^N9Zyma9EiHUcp$M;n!?`=xE^R7_+ zi06GZzMtfIkK%jG^B%|dPS5)qd|&H%KN;WGdEQUK_ftLZr{VkQp7%4rN2gYp4=87Q z=5Z6gpObi3&c*ljp6{n&yYrOuG4G=TK-vDn6u2)+f&1bVxGzb8`%=4~%jDBXL5TSM zO8NaNP$}?Ke!td(&-?NHIuBf5VD5T+2YlXu{R6hUQQ08dZB%ZO&ztS%E%x(P`?<-k zx7mKb&3?b#e%@i1-|4~2ud)BT>~XfpdW_=n>W?F4@!n~}(xrF)p-fjglX^MjV=4bF!lyI|-}7)HYmr({H8 zl#)btWFlLd$d)Ct<%w)XB0DOP9Zj7dM#&f~97}KtHaYzX^1D`Ed+6ee1xEEwA1<*$+g#Joz7^?Jv5+wlTO5X$rK!poh zg~I`u`$2L*A1F|MQvL&6f~(@U6A{?|A{Hbsz*MY5)6+}Kc0zS368eLt4DcX9cSq7C zhoL7z7hLSVM$YsE3^6az=N- zth#b~%${1_Up;|}yI@Wi)KsdNAF~k}18UAF{5(Npm3o18GYre|QLRT{?jD$jlw2E7 zyPz(w9+NJZU#V|_%z(-ZH0nby3+P?2U?XJa7-d$gqX`cU2|P@P9Lx^G)fkRokAz&M z6j!4RSD_q6D;02rG72UsqhXqI7}O|ZV7W35+LQ^srm-=cCP#$J+u6fXgB9fhd{ z!cLpoC$U;qw+EV*5*~NK!rDEsh(KCwfrS5-u)6ZSP(ZmYkX4U)LHUX&AHtccFcj&B zXy`Ecv;ZE91OrM9zRkrIsD&J*4z0j?7@*9D!O8;Uhelk9CR~X|7>CbFWwB>6lkCYT za3mMpK+si~$bH^gQCVT{UK}&sw)l-O`ty^GPrD_vs-b$oRi?WGC z1L`9X-U7vm@2k3h$3EK1cR>3F6fRxRu@R+pUZe|FSE>PZAN0wE>q^-pa1s{gMOhcb z79-i`!kwjzTE|HMbv^}aNcrFrtVQ93{rBDr+4RUUy5Qt}kd+J96UfL(50zHnhjm?W zN~OvtXa!n8-3_NQxE+cEYJs*JPE!E8tJJAEvDE47HMV8{yR@*!!U@of5|WKiqQQRxx@XPGDhMfUa2DpzMfdGI zB?6n#-MJH8ob5^{Jc_Q(lge7yr>uiF(cSt`IU7D#&Vhd^=Q34U&$5*BShjKz>#JPK zMk<%FiOS_{8s=vyS4yI3MWGjhB5v|bB!lxXm&LO&_b3eIIXoBD+C=d2JT$d+)*nXl ze96j4EUp1ETltCiBA#JWc>yPp*$ChA-n$-=ixA@q91iPwKg@9ynWypovX>fDgbjR6BG@ z)K)_`*+Oyrb~t|nfiFCUKJD13wsj4a_L*q-r`jzPd?5Vd2CXK~nJc{g^!hJ9!hQ+}h&Yiyf* zy9v{VF1Q&VTHYz9~ckYF`^pMqe!><|C zmhFbS7|wYtX0|XOKH3gdG~uvoK(Z>I}gS5 zbNd|SF47e2lMJux^3J3F#v>sTK{za3CZ-NG)|NtiuLY(i%UpXz4F$7k0DFt@`lDj8dA&k8YL zSC*KJMVk{K6Nnr+XJB#;xm<+;uE7AV!(=Ydv@)OpRr_(M%$K7CU&nLc9F*3M@iiIp z`DmQHjtpJS5973bFaXW4F?_6~(d%r~aJZTuE-fDuF5=^e%8|O)^YK{5U3!<__ykGs z6ZsLAEu=h*efkll3t6RBpl*O((r0_b^4Ti2Es!efq0VXhBH1!z9|q9o-HJ9Mnl-p!x-@9W zo(bq^&|p78S~K`qVm%gF566xP2()4#3Pe^Gy45h7O zwmgY&(3j5L@Dwqo1=K}lmA-(l3!csiY=RuhJwv90Z_EBK13puR{C5bgh9(@>~9Ym>yqFc{aX1eawb7`zk${4f}Si!z>1gz2~_^DuujuY_fM614Hj zZ~^8o9B*(ggv|(p5e3LH+(j{&gZ~;yaqnzbKx^S5B|aHP<_|KPkcV> z$B$+Mc>^2C8`%WDkWJ&quo-+YtL95sEk9P0*^MX}rlW~)B$A3i9v>l11RdJYl&F+t zO=yYAGBywf@kwY(_*gXvKABG;EyEVNro=)%6~8i>J4zBE<)&ed%iI9vNhDj&8hDlR zE|T5t@US#Fbl3s6@#(0D1-u8RNaMqhWLs$Wag_41+uO^CNxAFBQB>0fdRrzGVc&l8 zFYH~5`f?Q372D9tcuqQAz2*9CwiU<(X%C{1C9-nFEafaYTPezkFrTMoHp&7bV37B< zx6)S;@a;xx4Nz3PSdkE0(&*b{)L!rIOZ$oSBc4VqMU>CpBmAlg+idJzw z;&Ki$;e6@B9*y{2z>h{;u7|^T1Lkye`Yz;+xHgK%zAJ$%`CQ&4&8CH}+4LK1M|Mdg zp>`h##Or&M-2v}!pcOzg?}iT;YIXIYJ@DbuQu;_p+68~CEwiZiBlJMg;v@BhR^P`| zL){7Qll3h!(Rf8du>16)#OX~QmY4k zETS<3i{48h=2QIlr^S!JpQ|wQmkH{2`0EB%rIHUU*`Rt2#o3@(Ylg-3w(&pzS;wMghcyWqd1pkxPK@V`nwwhH*M4!N{H zzqAF~^L~B=_U~b^RNuvVdv`{M!?PPx1cs&dWlyzY*PcXwKk0)rmgujLa z`Z^Nmn~=jlK;Hcb?eULM7JdSy{8Jdq{{%DmU!acv6;;BQa54WoT*beFd-*@$e*Q1m z#=n7Q`S2OxCPs zvvxI?#ne1@j@pY|t`@Kx)IzpV?ZfU>`?4;zKii`YVo#_8*;8sUdqEw_UQvg!x6~5$ zt~yeZ^zD$tsu1d9kc54#4&~2rC@1`I6+9}h@?wpH0HsC`yp8A<&%-fl6PdJMkjB7c^Y7Im?Vy7C>&v{<3u&Y~PIBEHgG z${n2`zI>KR+=Hu~g#?(-vhBAVmy83dWEZlND=KVOAzz7V<&q_+p71!!s}$-4qrfQ8 z?|>tbq>L_>Kfy=DWonUN%?Dc+Z{LXqGbs@V%u!^uB zV*|`9@NI-y+gZQvyjmnD+uxn!9yVZUQ9vUu8CdBrEg~lSp)}y%#fk&|ZG=A(1UZD_ zK^wp*@NFO**ak_ZU!9OqfRlRScIc0AW{j;g1O9-ygAKM!iuD-?-N)En7aLNUv4;&^ zx{D2~H2H+gg3LgMZAjMzG72&+OPUR@%u*+07i7yWM`4%QV=Hq4S%DnvvWtz_O?T}# zLUzCmWEEtSSItJQ&&DxcU!RHT{myL6U97Y+6K9htXOl^@$xL`L@1jBh6)h080&>++ z&{rJ|gLIu^j3z+0t=qP3+qP}Hd)m{s{kCn}wr$(?v^8y>Ip@p0$-T)*cKxZJRY@g# zt=j8ZW>zYV1&myXS*pebAh@zrE0^_WT&T56@x#<=RPCF)@@$vQhU{oP7wdq|mH*v0 zYr)u6#@%OaLH@2_2(e!lzvEB+(##n{d(uj+Ac)iJihj~mG)h`Iv8mmhj@8gzH(?)+ zRp#BWenP`gSF|Xrw5b2P!n$F0p*`MWQ9pCReP#E=_Z;sf;B*CkrT!%H9P5SrA=Q)a zTVpWjr@^SE_T)2CXHfO1T&D_A$w@P`95Xyo&G;BxwV-k-baOv2GoL3JuleOb_^@C- zZPw4t1W-)}0OuKNqg}Vbz0%86aHYN-cz()2G{(({ORq-Y-CCpxQy2z6$+c3|W z2#6>cM4544!E@<7r_C4upg&D}5gOMKw8$>aP~v!eYLlg`29#V8PRs68C+bwa{w|Hz ziAoB{%HW_wP>W1r!mrj}f4W%p=S|!kSlqEHBk&LX`!GXA50^R-`MQz*w?S1oG&gv) zFmDIm;@+7#ZGa%C#iz#!JY9y+n;>HmN;0Xxa&FG~;@52L+??b|?L1@ZI>i9!^NmqW zP1dAaeItX0f#&WAO{ocsHONNP;PZm5`6c6R{tW|O?B(WoixUDIem3zV&Y#{-ECX29o>F;Sr4kWU?-s-KVr9EMBLEl>uZm zeECxb4QlTRxU-Z@v?$GS5pBb=_e*uUYRPa4^4C|fZ1!^Zz=GYF*DlES@|QuTCjqPy zI{@L&`hLc403_pN1iz zYlYK@wsoWS8-YN5FQlwt&-Y@>iC;ljk0Idb^+ak<;7o|kAdp)y8~o%`#*Fu2UM*ZU zlhX)md%AA04ktQH_H8A7$rvSju5O?XYi{6Mq z&V@fT6OIPt+}fGx(lRP9G}0`w^Rt;jCYZLh6{(3l)}&w{*u3k_3>q!SjaOGL7FEtc z+D3K(DQeE65cx;LP9$*|A2WEVS_} zBRFkWKh9P}psvxd*JL75bFfZH{Ocmzk0d^{kLZ!}fCpE{!P9XmkA3Cj!~EVboeSS_ zRlxv~CsM3xKREIWN+yjjG{2H>@XVDt;zB>@waTB6t!4Xtzb9S~y)OdlXGpfMA5g=p zA3)wpUPkSWg<0n4sCAJ1Je*ti=`UjXsG3D5t+Lc9g@uRpFP(zoho|_7SV_r$X#wfl zHXM^4n`KjEI!-k$wykJocpJ7bIvy`Fp0mVpJ2WR9FydD{)N|}u(+q9bBgR)Keyp2L zATsNKPmJj|qQS~y)2V>p+Jb(x&tW&{d&#rZThN9jTxL3g^UdE@IgK-C@a}?WKi0n= zcB?hAZRIZ4=rTCJA-ntCUu)Z!`1Q+LtBi@I_|~`Kwk4`?kxM~W z!bjSfbXrbkrLtu^w){n`nFS=iDONro8zQYkKD|IOgaVK6T?3=AXx`tkDfcf`G*q`` z<1T;$GI#!TP*$f#^24*_NZ&~^-AOn89gPe6E4r)X*&C?hk>JDV+rTd`=Fd}mzd-d5 zoXEN!wG3!sRLd1$I$Oy~TZj+DG17rcb}J;d)^!^b3MzAllrF^1L7__ZH)40}cVYeM zmdxx4jFa7zdt-`Ls%Vy#K3z9f6`0aY9u^agL%%vOY5ujTtwxnwR|8~&0y4Wn>w0O8 zMq$lrz_qwZF`QfqpLEFi=~C36oqaW$5wy(O>Ozr zto{t}UHd2&E9CGl@VuX}b1(4piYmCU96#hNVwrVE-O7*(td`(iTVj@>6UN=`xE&Q; z@8^R2Ge;e_I$3@*ax7?L5Nmef8TWzsY^wi5OM+nTg79(x?j_#{x;{ppwMp^MQ;IyX zMcH)>Hb)K-OI&>MO)b|*HFx*9)u&y%W>a$clRCy;j~?VspudY}q|crfN-_8hdJ*L| zCwZ%)TvrcxsuOlwG;Z*I5}4Z%LEId2wiiX3RN6w6gvypGb!(Wwk&(O$h%jsEM(kEq zG{>#a)>KLYtl6nj23W6-yNoo1rYtUx2VTg!>Z5W*^el72-z+h8FaG!?Hz^L!e=*S3 z5tZ_}PJPD_IKfNGitWHxx*#P zKW!d4lstp+mGeW#Sc$s^jh1pmg(!XRkg z_?_D&CLN_}*nrtc`>;In&pYpa8~CwYA&0=NTfS`$5qIpLC1EklE~2qE?8f>Xz_J~zO)HEn zhbS|K0hxDMVbt|KLqlavQ>D6nkg$f`83mh(ncXcwJXbPCC5gkn|7OZ zn(hheyWNMPE8{14SE}hZh`TU&jYN^ch~J%3it4 z7c#i{wm|Izc+~nQl(dWlH)Rb}J1 zWg)S&-Zc>!Ixfqr7$LL>WAN@f7FKE8lf#BX8co>WHrq=}uAg9fy--=+i1sV|vFDH_ zTdvTQ#1;>EUn}uG1~*$4C3I8H!?h~aR_ezHs8Qtj3QZA4Ulh2NGEX7w(;yZ(kbcuy zmSwO^3;QjdC;jhS_(>35XJq|jt@pd9&Id46nP8nf;L;oT*lDM+iNsO}05H|!GEvG? z@0NGY4)2EBkt55R>#Y~U>!X+A8n)dUw%b~7ajjr|mwZ5y+1@BHG@fM^VJ&4|z-9=2s+ZN!X&~@2ywUPgG6QwsqL$HIA^T;=FqvfE4x#?>>B;Pb&p-sLhv{ z*fz~sQJeQ_O&za-;ro|XhiK|S?N;7v-ZgSvi)6Mz>YQC-Ye=cx$b$3K6)0znJ^hGu z%W{e?rP*o`W)2XSI?961KVcly&lex%qN2UHOfuv{DspkxG`;W!@X6(yJaaZnDWjqcw>O~HIAd)zVGEb^T_Iqac7Tp zhmUo?79RVk-tzDl{I}T^<4zje20XUqF@N8C!Lcj&DtLWgx<%ois>eI^X~J2y&h}1$ zSmjZi`TOXHw#G^=eRBriN{%$eZ-33shgc!Vgx>Ne-(Q;>8?9|&ffawL$W`vPtqkVf zTUl-g(vv51^c_@c4snvXROhQb|2YZG2GDGqbk>jev&v!lF##J+w%+*W?lwL8@(GDs zId-4JH#U-ZP(1_S;U%+m0vB(^>xGsWkG4mJi_hrD$`>+kIM*f5(vKz{m>$P9|a+`2~#}=7}bPjLIfcq2MLmZ5ef%>M?eONVE&)_ zHpC6G!3_Gr2LU^GxWg8?;}*H&4B4MD1R7}DA$r{a?91Q=sUU)l9Q*BdAU8T6d@eev zEzO{PC@P&>ojv{zxxfv%&~2{o4L13b#H#oi1J$p9{lB$?gxUFp)=ii5+MpH2;dS_Y z-T2NzYamzB&wS2HD9e4$TbIB9>9pQI!<1v=)v1Xz?^bWPG(7KK_A8)k{AU+77<3e& zwS>?%?_2{N8`x0T&R-59bw?wCs~KAy7a9cKe4wCC$+&%fpQ&I-jM%7?$tV{}sOk(7 znHj0DaD68~6H2mt)i&q+EGUNp6yKWph@thcQld@Q zOd*Y<0@${)pXGJ|W@VE+PUCC~RzWYtGU2q zFZIjbc4IGh{UKev0mX#OvJeeM3>yv&ok=b_$kBwY@QcY3>6bBcFCpXTkPI`h0y^pe zh$GlG5zT=)Gc-rUghN;QVQ#Q|7)Xb4fheesvLAb}+oN%}FX0i$M^ymsRUJg|mBcgpsH_YS}k>oZ4sIOQq0W30IQ}t*DMEFLiV9_QwmVRs!%_ zA+lQFZz_yHY79}v2CxlpYLgSJbc$F2;LyVodCCaD1bgr0DW4ALYy`;HmEhR zh$AO@Ix8u6K96`>(L*Mi2P)7aWcM#r0P-0n%kaAKZN>T@q@pwAPZh{HKw*4N$$N@Q zrSw@Dl*83!;{|UlA-^|}E1C&+zLPFa`ATf%T$|@y0>E+8MQ1BsqDySEa`y42CypPLaF{rOxQ8EhGt z>TqFK6|!>V8PBdkF#*9nB_=yqXSXj(nW`_M)4T@WzxE@S1po||*^XD{0IqN#lRdc7 zZnM^}xcj>fs|4&7hCoqULosvI0 zFTnnminPPX62i>-2mOTZ8PO-;tc-&dCB%i;F{gAXI#VRuIErbxHj8Y*SsQUHOP@X@ zh?}tC>Wa8fa!vQmaq8IdE9VS#hV<#xe13i7=-L{2AlD9#3PVcUA{M<8dUYrH>{415 zIK;LuXV0zC4n1loT}HvZG2ikVF9yEKxs+6$J1SD4pUMzbtf4Cl&GmW{I8$vv z^g^yML!EoIY9q|Cj1#qC2FK|*G#f{$6Djb(hX~&*B=SHl4R=4Fy6+96uGHJFT84q{ z7SiUB`N!i{W7h#OgfhD@c5?Rtf>R!o;upk=Ty9VSW`1&T&F&&K@ih1q<#cKjlpuaA z4o6KAR^YEZyDmT972X}Lm-WsPxjLuiBS2^ z_kFXq|MR)(_WitUoA3b@ab!RvDse}uDbNbuoK0Bvthk|$low3$9a{ATjuusC6#Ys` za{D{(*M<15*aQL$UP*J6gn)JoG<|uwY$OqXzhG#KfKrn#r5^OUPTK9||qhO*Tc}&}Ii2x|g@&t=@XoadCguq^}FV{AQD=HC2vNRSw zHb^yqg=G^ARVU)&m;EfsmiE3GA z3D3#c^VyfLbB*_pK!;B~#&HYHn?04*7)D8>eL$*8GRT+>{mSvgV-l`W|IgA!61arA zsdr`PqQ0v=CEIyOybB0174$h+5ORo+keG(32$U`nh>4Jzgi=BVvbdTLO;98Z10pg~ z%MqbTwd)(*D`lYPRXnjXv?Tpr)s7| z3n*-K;jAhs&Umd-+~V{H5pgrK^RHe_5t9~VENufUD7J($&fH>fRzdQ1;6Muzf?GI# z4}`}fePcR7^wE30^y$AwJhuofd~i)3#M7tZOnEOsfNrdt!=9OK`A}e+`c0;#0z_Wf zm~EeNW6@=wL#*;5lm2_|Eb$=&h6o8~OI?|aU|(w7^pp+)fSsv*Qb_7Y96A z)rJOWr2&bf+~giw3v?c~BbFzEc(e5`@RM3D$)xlkWUD!f57XP{A}@#|HKSb*wML^L znBFX{L?IauRyH->xrtd@@;NL2_&ayXo?6%bFp+cfpj;llo^@TYMqY+lja|$dr&Td`#>vg zsBIBlQcKj5c`Vry@qW$kIr?Z!xmP`PrH~uE)ne||1UJcc1Lu8H67uK^s_pxgJ4d*Z zIOy&+ozSkvju9i*hGp$zJg|I%jX@DJChZo7Bp?3JX^BY~cfcS_CB8~0&`>5>nTGcM zn7%8-o9R-Kh_^559bJ`==0u>b@#y&AJcBRM#E;-dF7Q2kGubx{SJeH|dV`h}V5JKz(e-6WyhXwp4JjbYjETtbIOo84%Ol4NQiO& zY@0B%3EC{vHm#MpPYCe36626oO^Y(CCrj1Glbq-sPcX#RpO-VJL9i#U6Cb~1VW@tA z-iS^X=+A=`^alnH0hOXLa5@LopB}v}>?A|)Q!|~zG2*mTwE82q(#Buy z>IQL>P4OU+EHr^1bGV*$;&D#rVLSIx8q$b2rf&DE6fk*!fi9OuG{1q=~9VLj?@`RMB}P z$u{13GzEVrbPnoY9idDwkM|KQ|7sd0(A5%GQrE5>aZ;c7>5^bgjH-P|3N`-zD!Id z$O;I9!;FqbF;JoQF-_bz4XmGd8dOY;6l>ILCZ!b*sK%HuO@d0SAp!7Ft4uH~1a>nn zPOOmxGGf% zwa2tX#$84@-lwFSv&E{5!gMnpsn^Y$go;`>8(8fToI-|3K3Sxc3$<~?=!`y8M35N{ zA{?1XCOX8L8HNF==%B6;1ta2~LEfQ(I3%hiNX9r}5xS((E#*0p+@^FP-h^#{`kqag zxub=`QVnO&JR=%wWK&p|E#CgPJQrhYUQJVUusj(P3-glxJ>U$_2X}-+8dfO{I?)(8 zT@zzB>aZA+up;>8K)?9S04lWPnJ$N}wPI@Gfar}wq_+!mFB!3N4IYLjS$`TRkBjir zgrYcHdtO;DK-7o$I5H|K7s-!78D79Kddb23OmRQip zHTVdtY6;aYUULvU_G_<1kBT?49i?3h>UxA732p6gumgc7f?SEtE+Ftw0*l5jh}ndC zIb2sS%B)hGPIUv%H<44_Ot|1;Gmno(v*>fP>}E^Cw~}Nh2a^}UjR^w}k=N`({S_#C zLkI!zlu#s~ZbcNPtN(V-naA9t2Gh|F|Hm3Uo8l&!`<2ft^Pm zy2WS~fSOTwA3>-F2)YK0Kc@ID=$8d$9!Q+`5W}CuSkwfgZysQkA<__H1fSF zhws8TU1$~quol62`lZ|DO9jJPO?uX`PNNhu2X9G@UoBz8S58(lgS&GUnrFLd7oMn_ z(&u{(A5KNTi2zmx>4ADinL7FIXVhXk=bTr{QEtJ`$?Tm*jAR_~KVm;4coC6a#ddK= z{cQWIThY4qu*cyw49quZpl@jK86vR;@nU|g8b=OA0v<3^*N;if>u5I#*vxFil4yQz zKKhrq6s+o<8oCUIA8aud&TXQG03T*CD zbCWtJ!sMRlQmLdSRH|h*hVM~7$nHaZJ@nh7N-ikRL(w(0N6zx+xY1}4`_^&QifW#Y zD;$3GsErn!0oHr$I1@$Yu#Q93HS3~Med}>T_Nr?hR8}@^`&>B6rL1Wf%w5ok_L$fz zG@Bby`;yXdM#m$6fa)Xr^QrFIY~*{HHj>fWWlqa*e@6L1F?Yo=8`2D(4(J>3+d6Um zi19xaSWl?17gqpU%()Er5JKoF52NHN3!o?sGYI?mSy+|NAi}r=u~~dNoj#av%a^(;~oEIelj0y&Zp7oFhkXR zh{!l9@3LDF$8K<~sJ%EgeX>inh^75gfLawLnzlI8I1Pt+Dal>a}GS?{TF2M=`q9j1MdUnQ(h>iZU=$x(tt${ zWUH$HShe<#|BqE`=FTlisY18LGRAB|!mJ(q0|{PJl;ia2e!Bjm#I(jTlwEhu1`ex? zBk;gh4X}P_0E48^U*!3qJ@_-=7xr;59u+RXW|S5x70C1@O4VwuR63^8*0f!s z0=3sn@@hpZTfrKuarOS5KG(a4z(Nq0P^gZJT%3fku(l2mIrbUQer-!tkMYwVU0!Bc zsXS?H)^;;B17xfiMa{jOMEF@*V9f%`VEN5R+Uz7AQ%Stqhz9gy&vszAS8bIncMvSJ zX!XjUS^uXv%FV6SpuNZ21-A>7uSq?{^4(}{4Nn~lvabnR>Zc+08|QnERG9Hc>rwvv zM!(tUDyVWreC&Te*NF0V(X8JXf&mpg_N-lQT@VPJ!K~-8&G8N4-?TR4$?#U&50TqM z?P6KmpY#D5r~~h7>5WOjMu)e}Q3$E;6ITUm0S~7b1M$KFULnqxM4I38QLuO+&!lpH-fT(+M>gI^?9 ziWXE4ghRn|EF_nQIP|v|r3}n&2Ew{hGA!%2OXZDbxQS*w(aAME55oP zEY~6zwQ}zYe^=}8;^839PpBSi*~ebG?nRpQp=g@#nkY1HGg6K=uH7E?;xRMsRYDse z&H+*2W9~0O7F0dz#z*j3HXgTXiCJFs?CXn!H#v&ZD<%I1xI&e?Vy$h&N!i5hpMG(= z4E=zw&YAzE5S2+@JUE5FnAsXKwP7^UZE2H5jS6KotO1`#VsPCo&};lMO;HZPOM!(4 z4`{}^v3I`P1hLr)LfZ<3+q!))fXSGEItMWRX2A_P{;t5`_x%1Sb^;=)&aho7Up_N_ zz*P$uq`26y3#$i(>gtIqe216o3q05KksN%)iF`-f+T|!NXoy!qR)Gvje%6goPV^-y z#&<+-DNJ|$WihPJ$ve~Oc&SL4xt;UEJND$gWwy(>L}DWGZNBLkC+91{Ygc;S7(O2z zBm5u^$J*8vI5!JGaO|w*GiP2R{*=M4&=Ywx z=N>AWj&=Oxa(iY}ZGH04C=Ya+Avm5Nhi40Yeu)6o>{%<_JT5rn*`s|v7s~ls+M$CV z+peu_kjERxrm3te{LGC*&o|c^-?X7ehHE>tsBI2f+4N(>*(;KU%|a}JNn}WIJ_r>N zDn+))7uhb0yLNPkA!e=$x}o9zK+74&zhLFfygUL!!ZHqv#&+)akW zir>H-NUp$}O$a{Z)1wZK!oFl);sQjK-&F7oC`&b_+x zi9`miUyU+ck?b{lN>V2NWxQzc9)O<8m7YsBh76i$HON#HwS$Co>h$y+5at}vm?noJ4yt_4r^o$Q)(koZe3&tfECdO_} z2-(KP`f0k9NrxVHA%^4S9MiB9*D=AVXh+zVwZlr?uylcNTpv)A4$P;0f4@hra`F^6M65&o+Emi5iR19e*E8N_`;+4*c z3q3=-G0w4hF*Npd>#pB+pRPCB`9R3e2DuG$C&q~x{w=?H5&xBfW<$K8@pjwMO=KW^v@@CN4=lSAH`2oriNEjdt<(D zs?XZl#6%w^Vf#!7197%+fqx^Y1_dk(vDh~Yk}F0pk7#qMs-IrKt_<~;7gGo&GBzVB zdrGA5(`ss(S$L&%LPmA05-dk}L*FBPcP_Tcr%9T*o?TZ*JEmaFBop9$e{Ij=3%b6BxFKEc{5(F1EPU{NWt-}Zm?I+Wrab{1>bzQ!;gaa z6v&V1+hO-Af=x^lw-kIUiEH*jG@(htnAo1y@XT*j@;@MhPPjB#k0gozM%({ZlX@r< z?(8FVd9V<{^oKZp6^;Kh$1+|@dVgIJKfbWXop71oCEV3Tne-)#Ji~AW=_Zvs*f>Pt zcdZGaiT4EFQ+1GMpZp?MU*Yoms;Wc{auHH*;gpiCs#FHT)>5Adc2QDy1!Bz6UXg-q z3p?7XmS}{P^=V5m=Zx16lm*cM&@sZ2RXX_zl{-lUR5@w%*G*;$#n3o|c2rJ7AFJh? zqSXgIR?}!p!z~h5k_0{4s0-hTs*eyB52=+!Kv~QCh)aVZX&5P+@CPFV4%*}*^rAV4=(Rb@oM(4u_@ zr3Vx@WaELtFboht6bSA^!nGr+sLyi=<&<)N4M!X5lcN3<3q4w`B8!$I7GOytE5v&$ z+HSjo%7JD9n3FtoL+C`MlN)oxa(-L3gmTr)o0TwBxo{h#p}K0V#2YIrECG9F=f$hr*lz>NMBNZEt;Fy4TZ{H zYL!XnOhe-gf<6w!teF-c4U7CMcdw_nQ{}k$(!&4jk7U(8f7HKbrJLlL&!vy(W3ri>xEdIWCSTidL6mW!J-4D1V0 zt+#pE!Y)NWYjyW2Ti`}Rkb0vYh>^MpHRn6qMioX-K+mph#9mk=5@$1xwo?+o)WquJ zv)3kH#fpN#gJZ4ROV<;ornTB#}DCYiIXvxpaoo(Pp{nV_(SES{e|)L+j%sQi^7YcA@To z3JYh>%8a2%8Co?4D2$pUjJn?M&nq$QF76bSV`!JxA^<`g65&R|2IteM75!|$e$ywI z{uxI~D&ky)WWJyeL4|Q=VPnG!T!drximqTfMw7aLpvBGlfh;JeVQf2zN3Z8%#Gt!Asg4yF=G<>nT$WU2 znK@Vwy*1oUSD_TM-6|+(!T$ams0_bB(5XW!Z=x5bCk*&zpR7II>468z}v>xWy65VY*b{va%20;!Y_q&KKvmxTv zG>nfUshLY&UGO~?ncPhD_+(#lny+L12M0Qdmz-Y-U5qmdZ#8)nr=jH~& z#vJV&=mYIBvXn2A9@xdFL%ZfAK!~QYWEaiZpu|DG zz?{5K%}Q-xFC%K?ylD;GI5aCdu4SAKi$)|s6_+P>7w1;WcTskf)khHa$3{!CQ@X53 zF(r=Q1y0OwAe7-iQFI<8t0eZbOL#q*7+;Xtbu1Bt`l-6>MM&#!eMt0sFC??g{_72Q zfw7|&V8dp$Wb2R}cT~l*xA}%vwWr|>$FUJa0Q=TaIMw3B7^|@Z4uqWTSaTI!yc{UE@HOyLA9~3qJwkAW%8XA|kJ9hS5?K|xMFdt11@t)j z5_$7yPMsn}_={J`6jEJmow)+=q*?|v%sn)E0Ho(`)yS#^jZU>9+do{=*F>|+BWCosXU^zl$IJ*W+wS-^ zj=MwIXjZ%IQIuy>R2Tcrfh^nZpf3A6%~#84+G3erw|tRz2%bRycVKVXg5Y8gP7E+4 zJ_^&;8%xZnnU|PboXlS){^EPe`hm2mQE4x@gv1pq_IJ(qhVpM`oG(iLx_fk%cWQ}8 zR4;`id=}qif~7O^PRxWVRBd#*5C`lLHMc0Crwgk|DwUPY#_A4@_-B*BKCfR3rc89Y zDcH?x!$%Dskd@KjN_r2avobX-HA3o~D^+GSzKy1^)X3hD`x4UpBh4lR&;{QF@sEOy zvUQ{C2kWU%C7IalDj5C5v>ED|)TWOAy8n!5S6r9BUcW?#pm-``tyuwL(dhSWTPt zFHt3b%%-+CV*lhDDfK3NClvKHcNiBnB7H1d)N%2Z)sa+@Zn#(S0IvWSyNETRky69m z&nwv=!X?`~Qj}9%qp$o9st^DkrW&00>5y&WbMx}ecB>{bJ`rwFlfpz*hCY!o83`wE zt0XvAe;Nl=?wMEHb9$K?tdPD{`h_jrs`ZFA)?XxaHsB1dOLQ?`lmR;vjGj$KzZs3b zg%8+=7oPcIjaXuNYZ|YHV>@AU`-Vk~EvIm8;% zpYn>ijm_G=B=~0I2@r$2SVU*iV!f*_lGzkuk2hk7 zJ_(M%X~;|TDhO0}@Y(El#C2F-V0;riyi@l$o5%j#h|ywOIo3vkfeIk4_|6W$*^P zDG+r=O2^->?u4mh%Y0feV;=(sZmoQP!WnZC$T31w#p zAy|Mr(fU$PnQ5M$6lpX1V*_W4!)TVG?TzI?mc<{|#jk`g(@+Pms%yFC*QIPbi+Ea} zx015S^NFP*C}#-HGYOwi#{(vxi>W|P5 z9W^!N<&OGw*5~^Ie3bpbJ(oMXKI_GJGhFT9-SNaGtcB7mLhmdSQ9SX) zs({CN=ESL-a9YN$y+Nrn%-x@^Q+=0e&AupB2&O|) z*#ou7kT|bfeCfMz`{-di%UYFbT;(Y zv4zeJQZV>%3Xa)wKiR3{`=^105E_gcYO~OlYtXh+VS?4;@=}G7HqZ{r7l!2?@a!J3 z$L6hf|D4m(wt;**5$E@buJ?nShRJH6? zI*U{jbrYoRpvUQRg0{&zf4TUlhRx^PBRxD+BOZWy95(WW+{h8l93R7$c|es^V~!#& zibB+kK*aknBf(TcTTg~GO@dJFh5W6TCb7Zt>#WP+{T!=U-wU+VhBmn_D%)*19*3Ej z>c$8)kVG&*1hgb%arUoYr|NOH=cthf`FD3NmZa($xWH?QvjcMf}KO9|>}I^a^* zRKF?PhHxP0S{Rkem`Nmr<&{+IF@Niy|GGBmUyqi$EcLl5FzE$jYF&iuMf+~udFY(w zT;bfKk{#J27#k05)&dRZtQdX{fwrl;H=WLVeAB*rgUtZb6{-iP2y~6k^#ZUyIfGxd zfdQy1;aYhl70orq3isrHc$#V4yUVe+gwT^jU)HWDv2vS+6wahU#%rw?~ zME73MSOjZHz`6WP>NP6l9Co0E>-&8hzvS5eLxp}rT1SO^YNOu%oHWHOgYW_Tbt&bK zls~-kQ87I}mR`dgXBP0yBeVxG|4|-qU&ieNx$-v$=d&kMQztXa1qlze|b=^WYjAV z{ed^Vv|UET?~H?BI)4isO9K`(%;!8MqTwkoBuM>Ediqxoh)@_`2a4#>^B61~e%HEX zo56m^{=!xBkN_VK9*-cWS3i#{P$>??B|1N_f=90IM`$MhM4ea2=0HUiUjICXKV{Uz zg2jG*tA+3N)F$gl%$RSVd&zyr6Nb&9^;>W&X>S35F@k&%AMI-U7tueq-)c}PLp$OA zAVzb*>x#y=e~^zDwOn*c*QL}C3;i`CxD>w;IM(?BS@VUee7=jC3rOeBc@<=Ry_)TY z+ok9X^}?92`JXy@NJnT5ActKIg4dXZaeEL2CPXznG_yofW{e*G)cw zq9s9mZ&h3IXU3w1?45^TKa-V*wO=e1GzN~CC+g^RTXkTlf1dD5o|)P3b5a2(2;@2z zqB2zKj(@w99=(ySd`*K9l@5KN%>2O^U(-K1FzK657G$!rbZp;BnSe|p>qn7@3H$TZ z6z4?JCFjg(iD#o^EK~hY;f-sV_53)p@zq6?f%fdPhHqs-J+ix0te!Y4-i=Fryw@Yg z&1ospYC>Ra2xuBoR61;NRyHT;d%3nAM>ZavkGxAqr9eAgIkGP7bp9(IXfF$ znEgk7Nm18TT@w2Dh|q^5i=%-li!lTh7bta;qBjQ->A-A8zQ}Hd;!w(`lev!im#~)1 zzV;U(&c3GM&4u=(QDGV?%s%n%-Q@0ket$T__N)6u7Q!-PTNF%UiSk7{%84cP7vJfl zZ?YHYr%^kIj>>OG9&(h1+$tmwyTB$Ep4CQUPfxaoeJB^-3GL5Hr>EV;7g!B7{N))^ z+H{kFo_UZ9D>nCYh390h!-QL_uTf7(GPUgetrf~S#Z-uwN1*#Fe0oD1#9k3MHMb)9 zZ)eid1BEBgqMI=58rv9>+kUi19$cDnA;MOZEo;M>$NY!~vxQ5vRQcO1DcgIJgz#`l~WOPn^gNY$yc#83< z_0tIhFk>{iPJF038kXFAY4xM`AdKYQhaNG&v7A_^9#QUaww>xswrQ69Rp~rq-ahen z38c{SBDqBY#?ayj_?LKJ`90A;bIeRGx3YWiV#(ypu%Kh|aH8$)wakxf*);$)C&jpT zs2mmPm(!O#$2=6?hvYdz9MgCxB{}*86%*NJs3lIU3KqbrO_NINnFJaLxedMyzcbZS zbUs5$>()(8EoCxadq)&6dySa6vAY)O<##~D4pghZ1qAkJ@(=bpK@gD_uXpAX+ZZWv z!21i(3gf6^{^2g^Ae{b38Z|^>B@b@9m2_%f;{vLR#eVHg37^v`?I4~yg26t|oXmHV z!QJPWwFLM5H=Bnkla!(zX3sVo+2L*?21yO%A87-k-w{_xzFW(zuYW=1@VCUyy7E?K zAJ7KL(51oyMMuONJKJFA!(;>Mpp6#t2|tHM|3JMn(RXJ0AWbwqW|yN{Ob9KF%Ys<>1|!+5?ybN1Zc^aJIb@M_Y9DF3mY zm?OBpO8<+ncM8s=kJ`O6nb@{%J9li`n%K5&O^iFXZQHhOTa%f5soL+!v#Z|yRrNt1 z^+8vyb**0i>-sf?W2_$^CzG5Lx(dI&D^RJgGbN{52o8CdON_xd9jTPsK7?uT2>;oe z>i^z(O6eD(3xk1xTtk6?F#WG}C~9bDZewX@uHs_oV*1}IRM*i!)j<14L59sDD<(Lc zys)5diUK;XU5_I4(=r*QfCKHaI8BOWC_f21E5qVkZZqv)wi`WEch&MJ|65_lN48Ya zK8^3#IRBrIYv-38bN$c9Q3DW$JxXwqHnhRZbhOE1EdD-paFsEtwkXSfAo3EskY2pf z?^r_&XBek9#k&U>db^0@l7Z{4n0T}&Lm{Cb(R@?~sX?1o%-Ob7KApv8s#`^(Q(8g4R;cFn^6N|aC% zFYm9oHCPoKL@vs`QM`OV(}x+##{|HzNKkEb~Z%b=-0Q+jO_Sal2+i`zHH z^5|&OKm>##Kna2GI}SI+6zC&5+#E7motqAlEF98X4suqz^gsDbkd$<<+>wU>7$W1C z^nYFBKC?&PZO)`_=-`C8PL|3PAF*vkC2)QdKJXIXL!hdSz;Y`*eh$*?4C%1kl()r0 zvJh0f!R1cA2@j{`X=9_Ks|jHTX$#4XkfKwloB9+F1eFxTCBxvxMX>|a_k$cD{>d<1 zc6@Y^zHAgvFderXmd(8XQHZ2-uB}Wixa`xM!ls>75J)eLn4pwOo zEksq*(FZu5YQEBE6*Xrl@`Q?|8TiaR`=@Sc({-s_O%4Z;Fyvz{R2u<#O+$dB zx}aE57V-HkWA+OU>&gX+j;o*fn1~_zXmiKfv{&+%@`4%N;ogVEa)|v$t(O8_C};=V zEHXUS%TzpWGk5TbiuQTde4I$3G!jrPj>nT^rv*z8b zZ#TCON;Zn`8?wn_EWb)$JxHrc^F@BQGDM>5v8=87YMYao%#YS*YkDSmHD@-{sf(Et zbeT_*76F%%hftj35FDs zz7pr-^G6qE=cJNjsFejw3XW1aFU&~4kSAg zWyv^p@@8_L*k_>{tJxbgqOlI|tH$~~GQg-}WlV|dbIBwCQZOnJMppPaHq5gCjF48TO% zg3tu8XGnu((#2D8VB5lY+h*o-j>mG2f9DLU_{jn!__?Bh)k_-^^Ml-3f{Br(cOb^P zB2AOVc&LC7aKH4TaoEK}vO-)6sjUyn9i9~?2PjItX&gdf1fvV%I%-KG%ct2q3ZhCoq~ z{cMd-xF0;bCCPGue%7V!;^en=o7^>tZCjYFZ5q!s%*?!8?c`0+~~=X_WEH=6~4BSIyn34Ap8VYa~Ev`73Js~Wh9G6@6f4@I#HIiYh?Mf znKiT}DcLE#4&yQ3K5y$omgf}A%5tmA%H)dA}A^v(v=#{ z3*qNDxXh+Dtapc+Xe;YU5k7=r3l@PsSN?%hA$zVeh-3*=ZOaL=NPt~U^C021K=~bH zq+uu%9JUa>W9#wvkVj`|&O@K>Dyv|R7k;&HTUVnLao!OAq)WbAB3-qTFzEILS8T zSRWP628fYR1yt-a18NSS;S~<3;S~AR{A@ZoO{_|R{yxndC6d?H9` z_!sV&`RDJb`Hk~S_Dc+7WA>bV^7m!%)Es38HQuy`>%x$a*kca3WO8wv=y&4%wzG$d zmYWvg>Rijn>FuM#I+;rjLc)^X#J%{6_a46HK-YehXv)EWCLp|nrsb5wQzrVM>f!d$@&-muF5Z)=5W>$#+Aj4 zkhUI~OJWVnNzSj#xHp!mj{a$tgK$#<4b+BcbZp24`}mX~o~P>jCeEW(MSTKu2CB3g zwaDcH&JiMr`Q3KLA_;iz{~dSH`wlOyczf%}CJ9PJB|~RZe|E0oZ5RIXTAaT zD2tc9*74)ygt<-|OBPjLO1&&`hUUl>R>r&g1oQOjd*Cc4HPo5q4H;_c+r$-<)I&%m8D#-3%i#G*!#^$;$+(6Rw;IQj5% z_&KIYfK2(IC97^h)rLl3nbOS7<)cnZa+O?u13qosL6AOI|G>#uX_ToefQxo_ILlGFeT=g3P4bH zy_#nkX<2G7J1G>p=wKOsSn6n1b?mOn*xYR7F*C0xinCk1ksXNxiYwU#s@gtHCfEp* zLO<4tMjo%OD<15Cnz3dX5i%U)Xr1K#P>d8!)gEsaP;oG@E>j}739izZt2U@5ns(mz zsMg@X^)&paCtZG(6P8SPy{xjQ?r*4ngD{YfZA|$im#H!WG6$}haue!!qtccHgknc$ zWOGtW&fTERUONcA};(rcSn&c9zbz{}HMb^)GikHT178lce?RY*4AB1@dY+nPQ;5 z9&GbO$qUTz8pY>^1m`pq3C5N=5{VL_P|#7xvi*vVU=p6wNBHC^aGIa>gJTuxBfbE~ z0*8Gur4iJ%Lgja`z_sZ%vE8r|zs@t>F5PK(}Px13%h0(IoT9~M5b0%rAQUYGa zY@%4|JmwNiJkND$=KLh&1`B|QA+nRa5A(E~{%o@;8^h&QUc`&NDJ`YILoR%l`XaTu z91X{PwXQYGTvZ^b(`Ee>;U}w*-k~O|sv$*M1k~65)Aksk0K8EQ`W@dH6E^J z?mk2fOyuI;f!Uv=3#;uXDsHJrX)sTZWc#tg2gJAZ95gL>7g}`Yri#|qI&Ki zd@Yd_5kxwgW19x6DWAt@*Hw>8Y_?PpU_MiU#XbtRISGEmo{BU7oO7>2l2zWDLx)pQ zFXwDKYN!<7e17+C5Y-1@hZqCWol4R_ir6A0lMLn3EE}!X)%Cs9+zc!8Ael)i<1XKm zm#XyKoSfG74tG4towp}K*lk7^arlF5aqNcVV0sGnu>qBPl{h_NwbmYS!{&EgLG~7J z6g|cJn`?#pynqje_?~b~G#`UO#JhqZLaX$Cd3Z*{v@pW`Q5?UZTq_UkTB^5W+7 zb(uI$sG~%c_glzLyGNjgaWPla!n4&jRR*kx8xszv8lBoqy(rxHJ2U>F*?> zp^2YDavvPyl6~18Cb|R()Ra&4LiwnGq~We0MFWrAabnY5jBX|@AMGuz46TG2>T_*G zDC{rK#g0^2M&`r{4(7n=`{?FNw+DI+$-+$HU;=viRL>6bo-N(!iGSmyET`}87{;>n zZdT`-9p-pRs`fgyS@zBOwb~7WzWq>kKY5ltH2&%oxW3bn!>DjWHb4joIYnrQ=0bB-W%}AU>jF4v)#phzod=%MIo5j;XI1@Y_-t=iI zl+6ycahvXECrSdkTX$vfRplgmv>UCHdp_?c9z5N`psOce(;CU4&yNlIqAJnIdRwfb zdcqeNtVgPA275NVn%*0M5I;J|{f1-n12urF<$&K<>i;&#b={k z>`L&fy|wG-H7D-yKAD@_<_#ao(F&ol;Q5&%daE(_nc4ep{M3yw{ZB=oI0*;ame?8J z#155T-e1ssnaoZc^! zf!(T5#s^5lhM1WVuXJL@jPJGu?)TRr()n0jk_qb~{NOit3VSnOKmRN65Bwm|Y^We0 ztW+Q%B>$_xE1Noeuc-geW;#~e^B0=f%2)S|REhZlw^YDB-VL502spWJm;<=;FO zm~2@}Y?h2j)+E8MyFOU4@Aq*(q@xN&M07#ZQFYnjS6Ne2Q`y;ZaoU`F)0+F|dZOpz z`(c!*Pq`Nr2HjrI7t5ViiN*r_fA9jzpAvC34*4)!_7LT}Zo^_;(R_${{L!Yv89t#2 z+uOg*K)J)OjG+HSpZMhl4eqsY_(w4d-t8%ST!?iP)Ane=4We&3LEqKs-hrAA0tN5# zY`dLzME`EYx&LXfeIZSMwcr2zN1geFIo&(d;2*scU%)*x31ultRDiG}9q^=%#{G&LCY1H*XR}A>%MEUx=4v7hvHemPDBu2!p_D`CB*`9ZguYOeR4ZFF3tOY{$mBPoYgf+kgtCR=pjoMool<0HW-VP6VFWpc62!fU2nov% zdsVB@B3SgF9Bf#u5!&R4NixEMlPb|;>E(m-xD50SvlpkN6ti1fUrJwEtuoNmYHF%! zk3W1sud7Ycu5O$_t1>iNV%+fy`HJ)rnqbVF)UB+PghB_?3h$p7nGrx?N{HkO-WxfG zy~<@@BYqS*LyJ8AA*In2a!3yKnPO=S;?{6&Vn5sGsV2^g9t^>0?t`Jf!Ze0;5!Lxb z9*FScS~m{R`OR#D~Axa^Aln@M#?2-Owf{(5Ip4`Cp>mNsfa5RP}C(@ z9@J(dLpZfqn*N|ing5P>{)OVvAJ?+bP%{$H%S?foRQmDsVgc)3w0s;wS3OUrsj7{;To7bnMkv}GF%it~ODX}r zNtNPWUY2g<=0UikQAE2o;{>Dc*q~;0O_w~OYV8fJEP_A(g3tqP)r{-mI_Sj@#pu9p z5nDaa#OaeZ?d9TUGxos>AH+WCVW|k~BKDcU;}4vXHCD+03`-!dn3X%r`ei9Ld%379 zFDCfPWp4jqvko>g8wIoEmnki7cD(}ss|l(A<85RHy@7=LxbM@AStu&P>^x(X{&xg0 z2ueSZC_8pbYubNdlE~{b60}6oOMpZ}@H<&LN;GuI5fq!%HD8_YOkkC1;(okEc7&GH zf~ydzX&{1V!iEEh6)^Tr0@r3Og1;~Bo3QKP3*=S6fK%HFa#!670j}pHc|!xo#%Xk< z1lermVJgrD)KfMbIqj*&c$>`hik+$Gs7PqU$_J&gX>9Xifdo zobmM-)$LR)JI}U>>Tu5~D7UK?=#9p!n?#VdN*1n-l6Xa(DdV`$8B%UWm{Z)M`uS+K zWnOvDf20tgp>>Kr{=ExJpZ_ol0Ij~aBY!Vdx9wfPJ z?7CPz2S@W}I(l;hodd7?hbc+7SGLY-f=ya=hh(+NXZ%Ivq|NXc#IP2gF%sXL#pLD|1BME$%?BVDLs3i zvd^$Z&-Th2RBAA4=!6Mm#aBA_G$de*VDBBdteRh_=!n9pHT|nk3-lCAj`gUfn{{fV z19f~@>ZozsRusy{IFUSwU2pG8wjyyx?k)-7O5hFu>R*-?3d2JtWz10N5_%{%tnW@#z@*sa;J*LOlMwhP1CMOz(mbqK zhKH4nLU&<3=%|6b_&L3RJbO~VA7XnBd2T>&2WqoKh*1(}uw$HkVtirppcVV+(94&# zptataSppgMZ){LuEAT8@Nb4p)~mbcXH^B=}7i) zUQ+mn)Cd)bJpG3|1W%D9Uy#ziqo2?=GD+DXeQnZE$S6h%Mc>J5{MmsEjl<*UB?!04 z;WyuwswLwUB1b5S!pJyj1^Y{Bt0P~IsdRSCM%^@4Hj==>bwtG37UBJxXo;`=OkH^q zAZgJo!oBY(Vy6Zhygo@^^&FGr0-je%&u)^(?0p2e&r3!YLw$UBY%G^5o%_i0`r2!5 zwDqlVB0dMj%ffFR+6n9a@$I<+UOiXU33_D0LIxr$uk^gvZ<M2||`9l*J$NF-EyGLC?+?iYpOcC9Hct z94eUE=n}+a&PH?9jaLn=GR7Bd<4J|bXSLLgi+>nK-wVTY zVm!8A>IftA{j)u*#F(AVhZb*81oPtuIX$W?_x{OTlLOE1rfCQxVT3+- z@lvkHr%u32m3We56#As;zNS=vMlyM`c^&dg{Z%ljMOWhd5v;U5_b%uiK*i~}UzOEc zm}#J?tlu!!A>Eb{k1DP|n=_(-xnEYiu|H05ueLIa+i24=XP((y28sKVIDtXz_sLkE z7)ic(FBS2dqk-vX*YWx5J)@u8V&O@pCK+nnHok5D(d;{!V{-1yIbIp9h~ahwc-7A| zsHKs?ZuaI$N)p~K8MYv4=r&-_sg1X7x6A}T^SHnfWRKMr9eCp*GMCzZ zx`T=Z?*HoC5UIesW183hTEc#zhrmCEFFPV4Ajf>{l_;Z2h!EOcpJ}tr4Xf z-HvUtD|>#x^Q@6d(m%N4LLdq*l#Zf224NY_Q4wW~z5_JKDD#zj|6Yv!!QH;)LVC+# z0*AWR=jzNc*>w44U5_8;Zmc-#HaOI`WmNZm|7KQnRE+18R)kZ%DBNB-#;W@O*9st& z%gN_4D>^OKfxR8{nxB-p9r>LIr!YbQ=L=rmso1PVZoCw0*jnFY=KdBl)g?PBUt}jw zs$i8v%hNLsvaSZ{crO3~7o(lI)K;$W|f<$r>l#m8c8vt4qV(JN$ zGF;ApVZ3O$7D^qYY5H-72NPVI4rY6II<)!twV}T%`M)Swlm-kfFvN{HV3;5mnbW)< z>(EN`L5s@(Pz=(F{b)7#!t7&HY8*GfIOuYUN}E-|om!Y)lV7!h-`J`!Fvkb~n#<#)c@zMmXJs zuNL7g#8jyPwwVA zL)_yuUqCpwqi+}#fgzn<5izY6bzFweX}n`%#a=hzsTQ=_gS$tNH_L@q4P`wrX*>FX zq9yt|OWPo&^NuZNe_KC|bZwB2awkQnF3lTeC(ZRG>N*QYAQ`tV-rLTHu6Ee(rg$IK z6CS}q!4%&&(A*K}ysCWn5Xl(3Dx95b%91-t!64|=0Zhy11R(!QCt(_;2T7)cuG6My zD{9BYD|4Svp>XN#WQvpD*N2zGz+&2^uqxi59+7&hXX;vMWtX;UUqfrKSCl!f-p@aD z*n^(oT4RW9Jjc{3am`zv=p3}O2=l_%YE(XI?>ZL& zd4T|!NJQdX@*Dm&cRljPk&a`wvZIojGs4?HfYqc++pyCYHpzF znhM*kX|YFGl`8uwy$3l%D1cvO+GgB0Y`Tm6kG0R~qiln^Z_-?aE4QN=-KUc5cZ4zB zYDps-qi^lo+P%T=+(TdbCg^zL(75XpDWTkzFNUtg0CywKl`BE@d54=UHEUJRUAS4A zHeli4O~Fp=NMkMN*9pA82_tXZkFHfDk{A+b)UiORb2LoKg5 z805ghX`qca3PjysKBFOov^SX`YO@Js0_U@21FEg~M%pNSWD?C2HEw3}>b9{+u?Mz8 z;4y}$gV78Rs_UB4w5ZCJMQ~)v#=JP{G>(0^F9x6=;SwXuJ{%~!W+?%bQ>`zg$A|{w z{=~@YGwuebWU_4jm4=U?S+|MMs^yT0kDy&=6)u92Wf#6l&ozjUYuumV#%0s5<;G>y zzwX9m)z9tLHW&oCwl5Dm(>#bv$2E&!-?SI#);1XgxxVjA?@@=(KO4m7_T~diU=+?+ zx0mnsCJakp7S5@4=fLZe03KgAh^ccY$?Fpd?tOh%i~*QHuy5I$cY9-jB`^+WY~8DO zdxL=`Fb}pJK2^#Zw8immfWb`jw@e<-Cyf@7;1E|qfUy86QDl%W222$OYKjIc4wD}^ zJvfYWg-j0STNE4WzQCV0*nu(RC$vR%t;rYG1y81Bvq2y(YF?E%u1Op^hEVKLrKR?k zfOd(6dgRJX2`q~GNG09j%Z&(>r<-I7+ht0NSm4AKB(=G-WJ@nvLQm&e@r15Cltr2; zQ>M&;vqiTo*mNYE%>89cBPjNC`7K|FS)RO8^!~(&{G_WVv%rEG`v8hO%j{u zWcf`^FIhZa5U%)5Q>LsfqNYr$CUa?-ftJr&EB-{~xQ5=3I zdoHC-eO;=yfUHfAU(CK>e@1t1%cJuVup*tiz;jN!P;^@^^uftKf$%VHSv1+cM21*w z=E>GPCU%roI`8F4(LC`;O_Zhr?1~9`kcJt*EYq_qaXxZ`nZ%_cF_2Vxhq?G&TP*)h zu|c#ehIL!MaHX8JMKQ&mU-^(-g!3I80z{U~|7D zzlR<3P8$ltUk$kClu)TFu(s$rI`zwnl}jz+Kh@@u1hu1AjI6H>uZ#I?Y?pV!bN{U? zT))1WxjB<=2$<~vUpsF(8UMYWn}g5|@EXz$k3Q6a5vHxe8*W7ah1=41>|l$t_mFJ(s<|OX5Am<_ zk#tIk8TDGU8E6tB^{onf$nq1+9*&|C}VXek@nFVuUsW++g4nYY)8$R+2d`C-!Pq%*pLq0^>3NG^_ige-Q%8%EZDJd#2=UJxg@zIXC>!I( z>uE7;7833wWyOUKm-6%oD3Ke?Ze556ta!XROuE)UJn{-X(5VL)AF%~1=X3Pmih&clLi^wj1>2Rl1ozaP6TV%^>bv%{Iy32PW$nOxC9Vi zVPUlX{w=~6UY%w-M%|)BgmsKfmM5^9g=Z{cX>oC22|bB`c;u9BiOCyqLdx}#C5FTE zMfjTKR5cVEdjH~|0?>K4W z&aQcVz+U+RxHO@WbhAoEX8y*CuVhKDP!@>;5Gr*ps9V^VjVWW;ORTO*H=aQqBjO$% zMMpi$mh16og}EvYE%D|R*^((ShZlhvv^;V7>Vr$fg59>G?vm=~Z#+H71FSqfk%z>9 z%0q4+nbF5Lj{DJZCVa}fpt##T7W~V3oB?+c52ex9yTrKLLr5M!sy)JeQ}}t6Yjz&L zm}VZHBlOV{B>nk&)X!ugeyPH_d)9;}XQd-d5B88%mrrH1x0EhF`j69iDlGio{!1Re z=-qP<5t~mwI(+{=AkU6)Yh3HS1irs;Qru;o-e~SU=7{+K(nXto-M^?_Q@omoM&@&@ z>@fQJ_s%$fs7e0=1D+ai%EPIo*k1^J#2oa%7A)wKZ~+=}pERwYa zlr5|3>Y*BW!o`LBc*u&w$C-=GSYH?eQRD8ZP?-S4AFIA~z26iaZ3PQ}6-VO|;FiR}}5;kP72@=({GGsB;|9F-@g%V8*|vo-S^h zEF(!&rd=xM#Q?01k+w}h=v8>>R-|3q3S0T;)cDm}k@a^?0(^4|SqF1f8_(;*qhi!8 zg7OWA8W3e2_zE@2K!#!-q*03Ht+{UAR+z3Z)A^A|yJga|(Q$Tcm^kIa0HbE;d7t>4k={p@=5$>_VU4u336Xu&B$Unu#c%64kScNdjwJJp zki>A^-gAr3>rBI&dBXs;3`;Q5-_e!{ z#Rp^2+tHiM18>pVnS}c%S2YJ2LR1J~fV)OO#EEFBUNT}Sp+YG6#ZV7oITQ?%>5$9J zOP^d?NzM+U@S7#s-c6;}0KrtrQOkuCeWV7n5z8LPuL|?`N@!|58r0s~i%}YE(m1Oh z{rP9K*e)sqz?`g$%Yg{DmY(YP56#Hs;8Z_X2}yq&_LB+ZNgk?_joGJc$v+J7c_XmI zHWbU8D?!B5d%LXwZ%5Rd(P@u#B_9~~U%yKk_vO3dI=S~>9e(WwyPwlW+H+DMGZNai z#XPtreL>im?9=tji@!M?DM};O{F)L$DVK$Ja3`l`Yfjp_E6*0)Rp8sr1INX_q|zT; zZVPkt!)3LYXFp0ChsXRvIp}P^M?QEwIb2?(sY#B=hU@L6(8Q}!hW>}7u7(a7e*i}q zXI#_9mc$&IkR{Do7nm8aVID`@FxnYJmohjU*qxqBO@5LL84t$yQ2_;>H9p;MqpEJi zvWxgwi74g));JgMbY!!II%Z>H0%GSM6nU!tnsj`_2k4_Cy#(z06b|tJ!F>YL9=^)@svY!F;iqZ8xmJryHPO7e8|3Yem3mR3=y^}5 z6?zbnGm9#_j>*-Oj`U;FSeLU95dSsnQOS*y3PVldsi?)ydEfS8rgq>F~mOH@$nPR*uCbkjP)L z@sWwN2waZ)jr2X62;jzk-`N;zy+w}iBH4RQ($sZC#UKXY@Cy~ENP^6~tdQ?`CA8|( zS?>jW39iI}Mkcj@$TT~@X=t+AOs$%-R~kn~n*Dg6zHgHBa*s&2VCMcHa%tA;Mg&K% z!3BQo_{wCIAY}gHA18ATQ&DjmMdqjsn(kbi(IuKMDUkR4de- zLXdw)uI|3=)pY;sLAHvit)ZQZrSX5=)Y+=vVJk(Xe+Y8aO+SiMi-IPyo4{crbiruG znz8JD4mMgsv#)W;IOTKvqT8$PHXgC4Qq92h{RA;VPRv5-4) zK{T)q)kT`3<_5i{g%(SUMPRBrjpa&^V5O&5MVdm4)Bf0JSsJ*uD&}cAn1wFeL|8Vm zB-MKOz^5yjBOOt7CS`{p&?@&9e5AmH4;642lXdL|{qg zi0vT-zgu}8hKC%TP7P+AorZz7PSITdBI89%2D90TxI2w^@$uVkE!YT?wbCsYnEi#I z3zR0Qpbn(i1T@iGwF$~fZ3T7clh~E5E#2sBp_`Ac$mB+4R(to6&KCXL7kS*8xWt8U zZ#)fbiDgZSVSsDUOhq0v#?JO2F$V8u*(u-*QNy;@OsfxkM&dBFF%%WY*ksueN|}!j zL~=8^GEx{pf-r$IHu%-n6ODS-_4A1n?ZUO&mTp0DUiW1Bz%vqp!|9R%Oc;Dy9bZsT zYR-i%sr!QXw!zy{84A?#(XAOJ{;+&M&MLMt5@kW=!~F|fd7@W$MKW9QM|;60EeE&r zsZAW!D{IAe0eSI_j};uz$Cj#&~t2STotY@TQ{ZAyxn+-Zi)vHG=ij{GP=WiUZdN03ntus7XAXlwp}9qu6zZ zIKwTUUuuXl@{J5RK7<{|ytYUv{swkEwrM1B+mV`}OIXCIDN4|(3g#Tqeu>&FBT7ez zmM;sTisuviwQ82|@!go;f9f>e^RsGRr(o-x+;C{}D2ypaKn|h;s=-25U$8?QFn&oc zeC4)G;m+z1tNsGUFt1yz(=IAXuF@keL$fikLH>hb?u3h=ek5)QeWUlIc{(rj2*R{c z%6D6sm+yZMxke@4!^kE5Agq% z8{?=7{d#}w5$LYWg&or5%qa#QF0aKvGXto@N{8;6qRiQ< z`WtC-7W4K)U_^rBP>md&;1_UCsfn3~nW_yT8rjG8iahv=2Nswhb%KLE>tDLCwyY4e z^7qQe%DJlZ7REhcI1qB!t#AdHt^^EHyjJvaeyfzumCD*1ZZna`|5ctdfDUBXCj&`* z2|HI#$eBbfjPy{ko0=^V2f7vY9-afsT|VRG?Vt-PIQJz2h$^Hc=WV6RFGfjE=^F(b znY_kn#TpG(!6vG_F>##lZlh~7WY;j`vk)a)LsJ!(Sp^?zucYuRay`j{{akAhf6Al8 zTC-}N72BG|woOIV;k-E_>iVuRla;~s6N~ChHkt8hfmr1%mE+`StBJayB(GT&`U+$B z;;fHfT~jIHaxKc1$Bn4m81`nt5%R`lFu4-Eev$wjXr~S(d@8#`Fx+!yA(55PRq5{G zuZ%~>kXu058((6u_u-Q=Mt!^}=wqfzNMH1exe2B#xhU5*UyuN8Ay1vE0}CgOV1 zTNmylO$@m=*KJMdnT_d0ISxcb5R=C(fecF zn5&bun6kMe`Dx8?cneXu>a`I0b_)0Y?XJH>xnSV9aC&Ql?1q=5e%Sk68dsJ2qnVL$ zrmBc~;T-kO*zALBwF+0-BO8@vaul_BEq>c5E79R&C>QG78+lGPlyZ2@PaUCt_WQdG z+Ffb-usKEc)JN;Ig@uX&fp%7Eca?6^w}oG?lV?oFpXQL@O+T~HXJSG37%hyng?*KY zw`pYPdm&$|OkHp-)Yex1-hytvcixT$65X7>cN4`#+rAq#hlE*MsMdv)+~y%lP^tKf zOx8NpLila#{top`<{LZx`E*FccMjccw?7*dtc$99KljDOp6FD|MPNi0V&6R#qtGa6 zo4?Cou@cX+!SW9uPQWk>#_(buZNSFl2WYrrtltFT$ppx19FrI|G}>v)^bf^Q*$o)Q z&LJf51qpMX7^w@WYO~0CAXXEsSQ>tXx2!XzJM8P!54YX6?5K`Ur(^*J`c%`X1q09 zN`JpI$*uoV?eKad0G94ETGtr`42WI>T`kk$8tz=5rYx>qJ_8DTt3$ZJI@yaLwAV9olPVB=HvI~UV zMICqzxg#b1TnFLTN4sDp#}TCEg7^#ZmbJi0{T235>+$3}jpT=0(nTIm`bDL?&xOO$ z=i>m6;e16i4^zz5Q~Crs;a~D8vGF$&uQ%j+E^!s%z7C&&cG2(DuJLb;;tOuEj7_Vl z+1UpDM!W!OaHTC9m*Z1hw#?cRF>cSB^q*jkf1>bqA@gXMo6>N{3X1K$agLtZM+VOE zlihKDVgDDGgcxVt1`u|-N9ZYRp?W|3m$W)9C?d(jQ{>N9TrX!1IiuTXU z-7xK1uw6tfdRaZSxK2!mrb*onwkEW=ffkB+#gKPz&eW|FbFsoNwkoH|AWZyYl?|(PMm|g^-JK3dzbqw!@u^+`xzgk8tb(H z0$;3bgr9NUFQ1R7>8Cy*LLRXLaQ2cn8mx~PWK^h7=hshwLPxeXXovSy0Ea(-g|w0P z%a9YH{XPQB+@VY%2rW@@D`{>KTWmIl>b~ki_dr27u!OP^8@l-C;>4n~pbS`;+HpkY z#waT@bm$*;y-B>^iu*d3b6h0-%Sl`X(rbXcb1N=h*8Gx!3DGRtrM5JB@6iftnvRJ?^a zHFO1%8u8`@k%biu`3tKSE7%%O<$`2M3s2N$&LLjsd`0OTqso0V&xDsZDzrrfv7e#F+VI`SERZ+UZ4&BH{$ zaQxKdZG`Bh25g(~%1F%>i2bgp+S9zB+mgIDEkddBlgav+ase9Jb(x zV7Ch1mW6rk6B@QVDUPrXFg{(g9F5k#{}jhMrZW-YW)7zjIoFjP*H!nlYTcVE1sNlU!a7XXMmjPxhS>~j zp4W!x`G`zgd}+=*fhHSceB%_SB_r9!^wsE{I|iUJ|^dvWqCCD5W5!N<}e; zn36jgu?LK!NK`!J>ZPFG2NoL9hJ_iq;1R_l=Qx30<@;WSQYj4U=q-+k0jvA{0EB(` zm;*UL;G|-G02fB&2aNn4Js`N!17YmgR_>j-4#F3<7ZWz#fmPcfynwAI{&D; z`2|$*0UHf4-EP>mV~aAOjpAC-s6?9AT}77!Xklqs~-1vF7w0mm>!>A$~n%eUwA@ z)b>ZLet&Zh34Hp?yM$B?4nTT@kqk&f>>uXBZJ&HOg?d;2@$WQJe5C(i`aSr>@~P~P z@aHiWXA|lu^&ivSLO+$uxz3`c+j*GQ=uG&toN|-l`s4m z6621Pa5-0Niji(#Bj_)@$Xk*>sXuXK@1ywRTF1Q0o*$_luZ{_S|1zNSr`Xs3m28$f zhSS~o4vM{he-DuV|F^#XX?Yrd{Lz-tzvKy~OjxCUiIAky{7^}>(U+vA*^dPi<`9Ad zCspQ^qL}P6bI;Bm1{;cM5o@wa(1!69`2YBN$L`Fcc3U^7q+;8)?Nn^rw(X>1+qP}n zPM+Ad?aIk+r>zg~yV~A=VUDSBjecK!VLes8k+Nio4@K+h;kTdVchEoEooBCW>7U{I z`+EM%?vos^*$=Oo>z=0_HC-@!?tdr)u2~HB4Nz{oh#Iov_hmG>5C)uh$mh-wu?OJ@ z<#Ok*NilMv`VotmYq>1;%Y91VIVlTff@LGjTshSPPOnw|PJ}FDZ*K^;BObW9$i*ij zOVHqacDn)o^cZ1~2L&{#hg;~d-s63#u-+n7eoK8ThvyfLuOa?+Sg$GmcGzK12i)M` z&eEZEXyk{VTbADN^b_|!xcm&aLWp1SH2gIKQf=0|k`Vm;li;Q>#;{WnEBs3iDuH|~ zmZV56mHn5AK4P1arB_WM9cflF((1Og$gRJtA+>}!JQulaT}G>gtGvdXvW2U}go;yn zOv%fBREwpw8O}yqssoXoTe?h`H`_ypSXAx=BNlmd7o=x>Q^O(G7cF9k z1mS*3D+GfEu#tLHHf!K$Iq+uJBN+tQO6fnfpk}Da2=_4 zUxu8Z3hg5Y>YTlrkKjEK4pXnrh{^7z=4zA*%Lh9jg2lM{ULfct9x*5TvXgQvl%0a(aj9DyG5weB%+^=3+nfgndWX@T71;oPrA8 z2)sYF;Q|`26AjotWXA~X_0Zj1zNY&p?n^^oL<*^`?F%l6(uXp`y4JHC4k{U%PX!X^ zGOmf?E4R=@=0Zx))H{GAaZedOx=Tg_3tBQ?O4ZO?0w<1GAjrYmo*2FKS5{Bfzh{)u z2=Ttzybpe|Ajk(u$t}sbu$P?p%w&cf#`|S7c4a&sHPhO3igPB$$qrtMK`&vlupovJM=)45kQv29LtyH^NDemc;~vDO zgiNQ3>!unsa&_uEnmqDF22^4P66qYxE3NqX=F#)X5lv15xz;`_zgd%?FCleFn7udR z7QErNZcn3ZWFAot%m2zq7agL=p@4DahGTpmx$OjxXJ_b`+SC!~@ z8(Trbg(}rX7(z>a%na=?91cnAxZ2+j1{exS7^?`Rl}T|2Q+xEli}uNE%R-5eJoo_j`?R)mUleqLMCseZLOn)hEp6{Jlovi-{3?}>U^7w zk?=G6@k8UYv`AB|)^W7n)Jpb{IuW}0rz#P)iq3@vYEgf52%@ZrjDtR_4 z{w*UQHvS>}C+a;R8(cN{KgpA0i$%DE<=|^$%}I#O-aQ?%bDd9}E8mP2D06t^z>D?wDVrWAg+;SCY*62IcoTcda&9D-z3u2>6>cC)h79{ z%sU*YSuhIaHVMfc__p z6%H;2e;4sx*`hj3ctmQt`Xo9acR$F#qmD5>xQ{1$VJMVHkZxlYmW!3%7s|dB=VHl5 zB;elgov%&2o7GwDMfodDp?0&m6Qw(yScq?9M+KTZQ+!!PUP|iz$mSywP5X$>`zYU? zJXGHbtNF3@lBJXn9Jqc&YLTYSjZ6T9Y;{=j(|?1cf;<_}cOXY3h#y1&1rUTiDcN^> zm{ku4)~XJ!RtHVXo12IC zCX`NeF&112>FaOq=iH&8-n1@1WX5mGv`@46euryT>#$Hv%e_N-qlK^$%FStB;cZ8@ zNjT*%`2XA+WmMnEp#AXqm>+2P{{V&_w$29b|2aXftfhvefbtK{&3=xEnY@{azAvx9 zz8m+m z(E@xa7-^H!Y0Q$0B&ifzGTOnpL`)?*G!v(s`~?m!MafW2i7j?M3eph!nwUl*kYC9Q z0gi?i;7jk>>)6HmWu(#M3#lpr?`SNNbWBA?Ynd3|ZC`dP!|)h9ln3$#rxO;WCZ&o~ z)W6;f4&ILU0qzPfOgv z+Zvs-(R(q@@<~$G_Dp_NsAYcqgA|!$YPYE6cIi(g?F`=%OwI*$--p}N3sbF}(kfgq}k zr(%+QSOAda_-A5beNY8p4Qr@XLD@bA(a%-1xZ;H4UPr+7< zNf3m%^QqZp;zR$;r03c4VFWemRcR!Tsd=JCGEkds=O@)SJT`S_~v{{R>evwp2G25;Zj+2gSC*lRosi}sk(Z{y{sEBe=$Td z9G|j2IBx~e8rS$`vz5P9Zd|3%nb~!O$4l+|MLheS=Gu3Sp~yawsD$l1GJb{M6x`kfK7rPktU3i zHYjCLA4?J&3e7IlIn#FSa(PPzv5WeA41Vq|Q15dfD%aUMkfZP*ih1Ug+%Nt;XPT|V zElpZ>`$0GNArY;n5v=o%CsOTw~h;R#JDkEtMHB$*{lYwY{66c-^Ym|mI^j=4R8UwmuYnhMG zNF|f5k-2tDb=QxCrT)@Tn^kA9M1|Fsy8{`21*)S^>p1Ba(=<+b&;scbyLi!PnWx`;=CmY*HuXLuTj>GZLX%llfYnq*3*AeP zvOSUu7_+MKNHYa7w{A&MqPaGsr34Kv*e(G<&N8MDZ5UXvhV@{*L&KN@BV5%1qe3G} zt@$6~0*sAIOVgR9$TXSJYO}4SsVc2UTT3|HhKW$7gUW`<>3U3E@pLA;C;t9=0Z`P@s@Yfy;Kx@1Z5hNpRFVhoev0VJc?TH9B)jow(IT zYOTP1cN|{#>;nm&;rVDIrtMvKkB}_uK;Puj8#C;sfNE z&etU3h*^wx{8C&DI2*@W%p!5kN8=aW>?wpaJ$XzxyN!qP!`l$7C$w|^t#J>tw2~B! zSxHFZc~0PeENHi*}i|# z3!#eK@3{THicQT+D{H+P=uc9c0x;|ex17yX3Z-Mj#u;1rAQV%+zF8IBY{um?VQEp= zy7}a}b8kU$lMmJA4hox1NN9&=u#vhtx&wPX(D|}L&CDQ35ZEo0ZTM~%zlHqZtm2f|9JzUU1$jjRr$gC_o#@Y zviQOVOZ%xIeD*{8hAb090N#0wVf+tJG;cw;96|tOw=^0Zm6Y?55W5l}AP*$Kf`7t@ zRD=6$>wBOCtso-xOkibtEKt2sKd4su*S>!Xf|xp01%R$;lJqx& zloq>&v-pRa8@!^i2W`^v3R{8t3TYK6xVy2a+Sdg<3)>5w$LNEFA~{wG=?)|F{nA5Y z0M~?vj*aO=>ioW8f2p_2dkPzqtyt{?b@tUOJVny9z!g9iJ=@yDnRmkb65r?4CK#YY zQb2x`IN+Gqil(7U`cpE0A~O6kcHw7JfOPuHY6wMS2A(JsSWi;yu{&x%;oI>?VLcCi#ae z=)(a4VgGNgAYuEXow5HPnsDWXEr$4AZF5%i@FwH9ubagpDXFv;Q@A|Wq#zkyI8q(B zU(|9@P$EAAknH)XQQA3(#y=kCS= znaVcouQK(|9;|Jx?aa*BnYz9>zwOlOg4jd{jm4NXgAICw>$o#yvk`6c(8T7} zQ#a%dJ(jEl7syIAm|lOAiA7JZ>_C&z%&Lcm``}k*y@wnWgRB2)mE2j#>{6u<`IPU$=Ea2Lo4o(~&Fs&4hnv?dqAY z?eHgVlv@jfJdnvXD!y^C(BwS7xQV8t#Ad$U-G7AHbxlGlhH0&;vpe)#_|;}@`kvEFq|06x33$&;T16w|9~9Iw_*=x z#_AQ5&fGnCkfH9`8kZ*X4Q6G!q#-$8LsGN^FC+{d92QlX^%Do3wQHgvWQFAu1QIs& zRtmP)kiS*kb*QpO{2)oRflZ?jL-bU=`UizAT03T}Enft~SZn)8Kd*qWf8x80&aHqw z!dAvi&X>v)Q+)KL0&g8~fRGi~z z@2Kp&O;bQ}XEsQ=db&l+g~{h9S1ujnZ+iZD%CJq%(4Ze*@suyI+_@bs4spP?6r&q^ zI`HJaTu(x7Na(f;b1vtf&b?zdeOSWsB9T%d-q>UnwH+HD&|+Gmt~6I+O0sR(^tgYC z)>BkR^_fo=W8?hM#IwKZh%gsh0qs_k?-*BM=P%wWQs%5dZ{YN7Ihphr)cBX1PUz`x z{a~X^QT;SY(^aFW3fNZ9s4JhKHFW<78PVF@O`Ik&b>c3hC3s@K+&aKJEkX0Q(%I61 z7CjrQs0EtX27PSMcqHqvfC{JQ;vC<2?aDx1^@=uJ zynIL@PqA7y2hUWQYmu~dAX1T%Vsq%kEiO`_s8l`^303KahF$n)CcRPd3Qbn5kw8b zw(%?68meR;Rnh4V1NKKB1Jl8*-tB0uyW)AoYMCnu%&$hZCcbKcs;PC4gK8P&UQ47R za*$b3Z#?kT!S(>-wm7WZ1@C^4aaQPU3~;V+AI+|Ar9n!`EnwcA<(ml`mRUQS(dH~C;bsGESy8vV;l zzkl_DMk^K3J8OA}o+~PNSr5-jk9ga)ayP_d)prQ@0P)cdJv<-;gbp(w zngpD?{^7au*a;E1L-EM|!%eggdC%()2NNz9-tSc&F&Z?f$BPmVN+cy61Awpf8usB3 zjRJ9($01W?{`8Wx9;LYsl-&F$0)u=?65>amBbJYtx-i5ROlRmE@rozLey2$`aw7&` zPrVE34$(bSh>u^i#%EaA-^U|}q829xg881RThj3TU#TIFOF7m`5Fj8DFd!g~|J&Ex z@&BmgNTf~NO&kS`oGt8Z#Y~))?W{~}l|AhL$BwRKBZn-2;G06Ntp%@1O&dng^S7zk z5e#who(P2`8kS5@{BfhjdZNF3*Clp$=eF>BAShKB`M}IC$>I5rFa^mrX=fw%>=X}k zy+Jw~8^JO@|2iXvTvH%=kN&>e;m*Azws#tI{1Xbd?NWBEaO3}uMx*%d^p zLEZTqY+@(iS%%-f_z0r$k~8L{hWbyqKP!gkY<|(n+Hu4zZs(j9QBeesr# z>6bPOr&fa+i5*Am;z@P`GA83bDi}|nNM!iTd&{iD_lbsKDz||yIt`^i{I7+vwI2R@ z=o5blJz{Rs8kpk-XhFBq*y4s{ECt3o%Ma51Pu%khjrGABVL(@UfN`C`kM9yRH$hs5 zeG16h3W;bjP6Y!D_P?dZ^>v?nC@lpBwTnP5X($~$#7|k_QrVfXR6iW7m z`fMyM-@T=_7h6PhQXFqEnW}R!c_T*nvjDW38HF`ZI@tu%DM#1f2@~svEfDUCbmxcm zElaoAs7=cG^sWA0EUnor*H~#4bc0}zrcSnbgRGx{0P|MVk}n}cS4)5*qq4g^ooZ}3VK8nlMMApOlc%K5e2Y{ z16UUC_PIr25pE+DVZYtQt&@I|PS{_A`7dH^LS9+U;AiiDcm9)tq0{(ojEb{7YHZ}FlMsg*kF`&)@V&^WMJ8QWBnnLO*jm8Ld2zCy(gEk8Irs z`EFT)g|MK688^JsC?Zcp`xC&C(9w27EYezU7Sh` zGHXcn;So71x6L^&epsXbIvY?WT!cwBLsR0;B_c8%7yomlbmWzh%Jt@)Z(8|D`ZlBB zQIpE%Se#0C=)t52mgvx&%2IPTXQq8oY)hAX3}bPw{I9|L#LFF+UfCl))$FS8IOIg-0WdfEexB8w_T1o2(*Ry~zi^*`_=}FnFN-fs)I_g4N zQ;Ma6JcB6TSW%9toHtxvPmiLXrJ6P6v>aMQDPCBI3N3Om+iIG|z!7ua-7mtz6i%vu zKZEK0u_ML2f;f3j$Y+;Y(^5EE8FXQPLU3RtnZXV>v5|5amUU7yx@>!SXQh~&OGpPX zDyem3Ab+ewejv`*bS{0}a2JJn#P)Z(CsEGaydb@t@{WN)pRxkytmtniq%27gL24U} z<B~*Y4bl2!CI|l^(J^n6y9)+x+I)&D#G5HcL+IS2y zRJuZ)#~Y$q*t_d~b??l+JiLQE;6Q)-7L{^n&4D3@SqMf*nYYOYdCQ}1nVAxbj#swj zvkxK~1CP0$&i@R`;9a>t7Oiu@M`G;C-+&*SXEID({s%9cz6+{6QVGXP;`V>q_3vHSf z_3vu%W~sHuP@Oj_*9J`@eRQXZKmT*A8!tX&AE=u9I80bm5|nQ)5u0-!_C!A5sZ|Ew zCo^(ooLJb6Cf7));Vmdj$0?M?x;`9@WmAfabyZYb*(H5I)**XzgjKt1nmoJo%40kK z>a82z>DXmmxSB85+~=$cY&mX6$K!XP=eObc(uEg~km z_+)mAPuA_CyJ8&0cBun~?g|I?3o1L+cCiCm>#{DD1Kk+&u(M<=G0qZ)Ecyiwe>&I& zXex5nSEJsMjZ+mZhAYSLk&QF1d85z~Zm{KAXv@xDLzC?q2X^`?wY$`;JrT9buUI{* zM_X8aiM?Qc_~f~k-q{4-Hf$_Cx@Fj}BRuXSv!qxz`JJp>!n2hy_O{2+h?nHKD)KM{ z+Q%gzTb>k1tF}cgzxIix$NOY?Ny&Re4zxrXZ*Fa{c4piNc%V_NiTOTsdXx@2Uu~m* zLs2MG7+HA7rdgoxRNnbCERQH$BBzeLJm?k`DE#9i#%$qn)}jDWjefcFjsN;P0)H=r z#Se2M@PZhPUyRO*hvL^B(rac{ccc->O9uSp6ODgDF25Q(4TsqqOm-&>BfE&skUT8i zS0xCVul(nL{EgBAjvyKA&Mbzf`d%P97g5engvZHqPhSXtx#i}vqN)S16sSyVhf)(L zE^4QIh6kqHntl-<=6K;wFs5b-YHScedRhee$RE+E@9<0yT3CQc@l=kYbo4d~%I!jyHWax|3c>ZQ5}l za!s;lPBo?bdLyR*zM9Z;OXUCs&-=NK8a1H``J)B)#SelTk0u>>HXv1H9MTYM1@~~7 zU(4!M>`fx@E`dr=Z&h6N?xLB@v0igWJ#|pL&r>hji(RYUuA>@e{S&`H;7A1& z$@=3C@Dyd5SKsqh*0>B_biIhvDoev9r=y824?RDtCXnCU$~{K1K)N|7nTbbrj00_? zCL#SC(z5C(O%FL^)r@=FBozdAVy657<5kMUtB&pQQDTDJz?Np#J`@0}0P5K#o+)W=G1AT+R1G*EdLG`h7%qiiDpY4jhV0 z`cPQO#fDZil#?)#ULiK?EvEGZ=A}-i&p{Q*nN%9b))9o^*W!?eEqr_-a<+rYQ%u`w z!e+gx?CFUSC5I$43U;A)veXE@9*oSWl`EprlkZPsGtXUOzOtxG^~fur(uZ@%knKKG zn8d0paM4b_3b4Zm9Yr~s8;*H@7~4n=G=fX5XvG8zpA_my;8_+c zYKo{ClIYVGR-RfCB_`Oc78w(RJ+eAiH^b&a+oB)a)?yKvgk{b69PXFSJ8-}!N)ejy zm(R+_b2_FemlO-)lD-(+6O21*!Cmm(t0jAJ$_(2CDq}gTzGYibVe<y4E*#ZfksW zkk+$NmnBikm^7nWWXN9(CWJRL1C(_?Sd^_x*gAm5)Wvkg_?oViqw0~)^PtX)G%&Ko zF3NN0iiVqh4%$aDr26V1aR_%;gX8g-%%Pw1yQ4gTrGt8cxA7tXZWN{i%YQ_6U*>Gz zOCT?=Fo90yRd02F>zorlZRDX`I>qy(17{1UI1`U#rHx8qIe}0KLVbrlD#&O5W*!Bj z!Kjj5C|Vh(HqIc^!r$Q~22~2NI1dqGp*_XggGDo;@RP5uct(Fy`I+~qD3@7yRESjv z%7c(ZAMC+`+YdAZF5^L`nhAA`bXXPbfc@vlU0uvwmU+z*+cTobcEQNCCEc2aSGZ8E zUYNFMqki;v%C+i~4sKJtvHl;O`>bRJT-Y`EUn>ic=Z;KeEC$?6nbK{c7xlh5Byj`_ zj=;9@1&yW1sjF+&rF6r3<0S>=^TWt4c49!^kL`_L8Wp?ZSFsRFVRc1E3z-bFRp@Eb zyo}`Zm^(tv1A^4|d;^~}n?FXEAsm%lkw6u!WnralB# z2K+SIS8i{^GjP35Q6?vSjNv%}Ch!E;@BkRk6j`yk#W}*ZqX%a=+>k-|OmePS0GU?- z>l$+PxTcfLNCs;h4V$yz1k6GR-53?SjXKM5mzRwVhgB79Y)%vGO{ouNJiEShg1mkj z2zFH(=MzG9O8x#>;2{(j@R;>Dgh|}htZ5MCamNb7JNT&^!vk8wKxYYDB!im&jkxgd zhV@?!ale>E=?cSv%=~iVv+ox&it{h{vTCBn9AstYuIN3ZO$mN&2|X4QW+axhvkED5 z3O~RpB?o@WQe!WBeO|ANCGo#6t(5)Ri{MeKp7ZR*R^5=|$I_tv(mWY_l)MIl^AVl9 z2+iXv%HF5yWtY*bS@FhdxKlivl3NJSA7`N5+@+8IN2KwE+Kar6K!f_la;oN;Hlr+F zL?c?Q=s9%rh>BlQYdChb06?jtze_$Wzhh8|dJHuWkCR$(R;_c6Ba6L%lLRdOm5~fR zwH^&1XuBC5sF*0d10O$xZ(q8;8ax(>I!2as;Z(GIj&mE|}u=rK_~AUtgFEy*t+ov&-h)2 z8xQuhz8py+b#S+c!fZO~^J4#GZZ|_N?M# zJoGC|tQ?oD{g1#{jRJ+!NR=w4l}WaFTuwrxGmQKbgNrSKXZ5PbmIL`r)nW|9>^pD< zzchNrCw2^Agk^ECB63s@%>Lq`KY3mX@W{#?)+iM!u|WV}$Hn}tI($7Xo38g|D|P^_ z2LDnL-kgp5;}iNWLh7zo+?uk^YTbbTfPE z^~i}U48b3};hKi~2*rJ7Lzn;39>sU;==xxsL-md8|K*Lf-mcvr&6B9b(O2!wReP|u z8LSXU%{j2NIm_zJxpHsI7x>#9_~s~>XDsp!==U1}{T^{w(#|2cZ|Ll?-UHLWuuK&4 z+*0X76-lsGN?_e;mRqdi>=mj^_w0uB6>5nd^|j$t3if-lBh?;d%w0MY{?O!5bv3+` z=?N)oirPEXBb^uu{$su)avUYT-L`wmQkwN;`OxCA(=T3{A-gI+1@QPZ| z@Mjb_H23I)Yf~&j@6P#%XGUrjTHS^>^IiO07(zg`LncBEvy@tg0znsQzM zKPqOJu)S3>b7GR!j!Eh1u7nM`3vLdU21hc5QSXCjLUD@_7DOr#KXP&TQ(iUC<#zy?_d@7ekx}K z_}>%Kq@=|wei3@_R7&YIILmah-suSx#J%?8?~3`wIkc!vgE4Y07`vK2r<>(u&%EU7 z^#ZR7?iNH}Fq<0;lR6bfXVTg3waDyP7&HfW!YquJ3Wo>eBjex2@=!%9&;Ow&MIv^2 zPC}S9CYy#1N#1o7|Jn00&fWYP6r^FkE8)S5@Xm!tHThI0*T%ioUT>3SoAQ#N{ivT= z2s0Bsil5gMspnv^6Hz<{yMv=Ls1;GTRgQ~knfD?~)tIP5c@$MdnFW|9kp?MYgluD2 z{3r+=J_Q_zEq8r!75zI)CwUNSi%^^2Z>}?2(nB?>JktCx_VBKm-6hdXPwa!N_xwX$ ztle+tNl}q|qsaV#KTZk|tvA-*%Nbm*TU|4BZu#M_WFd;hPzSnLl5kSkF2ViaJ!u-5 zc?w9&*mgY_>T{%g@s`bnHkw+Z_^=o~;5-^{$7U3oWa@=ZwA;e)PxKAGp|cjC*yLRC zl#KC_#)+xchCoEJ6@Y8>5zBa_tg&C)G#9QFvqfk_&C()1e2G6{PGF|%{9?`$p&zx( z_Zb!VF$?u-&N7|p6pYWfRkoV-{*&A_swSNn{zPmXe5QMDhsd3rW{J{u+o|Ib0rQ$4O(!oG6 zv|rNb$rn@mPygH1akt;>%XUw?-@mU1dZ5(3QHH44jaxKZsPQ3jTgW%z#i}?J!d4^o zLEQN3k-8Yzc(&o^@;F)re&n+p@fVjO(sTb9%6a_rG?XtVT)op*#Zh8hy)%ZRz7`Hg zg-c-r3vx^KVBVcxaI z@0ydyRfQ%=Qf9mAHr;t;G=W(fi#aB&fs)jfxUuU@xv3@_uD8ea=bq#TNQ``|427xE z*8bl1llGmojh0Q!HQLqX$x&*L@L4*J$L3@0kGfO&G-?hozZ^BP(UwzPXSdVqF{blp z1BZ=!HZbKr_0Vn;Pq2AVqoEz@Bo-K!$3Zt8?rzO;nHnk6Uu@}9Sv5yZB7%jald}~# z8x*wQ7FbE3%4Z5hdP6*hht!49tQXE&3`2Iqx(*8Kk8MB=kLI zzf=52Z((TuE?isjS;JD+CK37^~=$G+`zKiZLr0|;6Vv-$a z&(3OYsm!l5xJ_Oe^(nQ{>7K4AZp_hIBH?x)B!7R--+d;PlhdL7Fh>@9(1~TQV(gqk zr8byjnOkgK$CuORy{HpN|~Ig#Nin$P)0_xr7XgLRMA{ z(I($fgn55#*f-xGTN*HKoIh21cLG`hzXc!iBoHMgt-A%eXGgtw4C(Pw9|A)K0YFX74zuWz_2p8}kG zJ&jHz&?2tDr27#LTr)pW^5&SK%;e3FWF`t=m7^*gu95aX`~&jcJuZ)N*Y@bNuCD0a zpCvCwv9XD{JuoX37%7vRFTR5U2_T=qu)q@3Iyc$Gjxdmzu!%=q5`4@M$UGQ|6`NW zfb`Z@Y5(?PZ!~e-D6zze^QZ}3-C#g(ScJi_3yf2oHX?gD}eeblhyOEta-$C|fd0n@kc%OXy z+u`$hrjO-=+l6@(C#4&m9c%-sJ-^%;cm?yt9I73-J=l3VT1n3O5;f~xTJuvbfa_h@ zdwGA)@O=%O(S_gVr&fsmt{B4kbi-)8<>&fTfc&bh`I0cR3-TDxb@~22yZjL$vqo_V zkopoLp-E8<>?8B{N)S*8D8|XlQw^pO8|0)`)U7hfzC^9?B2#fzF0X_el*dbONy8Ot zmIM{6mV_8*@DX=ddCH#;s8c)%q$7@`E9#LlA0<&)#A$F%!A)dIW>J??t+Ah}l%5qk zxu_MwJqQAdCg<~p2Gm2;gpf{@WLFG)#nDb5U?j<)lXFD~Ihje!f{p8YvT+lf1RZU~ zGoGqNZqy5eD&cGdG_Xd>Q3p|q4d1h&)-jcrv5YU8G_02>cR zwz#+zVVW;7hFqyQwRR>=4M~`9x8xr6Nn~myOuj)6F4CTAujv^@QN_ zxv}YBjR29}Sy-p;-ln?e@UwD{ov&C)A3g2&?lh`LG2au$5ZJ=x{HgM$GP!ZXgh2y$ z{MtY(JFBa6)>O0LO^Pm8jg#lwvTzOauv~ak;pUwWDRo5T<2-w0=GKKOyQ{6#rTCQG zL$cbTVmd9YSZx-J5UUt|Va0F9i71sZBqBA;;|&U3pY%gkO9)D=;D+p#KGu}=hJ1hE z(Nl26c5i`c3In{r_Cq)U7he>eWcMs+8e(BLNBt-;l)zDkuMcAq_`?KH>c@ZyoU=Ql znq8e9z@0^Z)_uPzOgUmy!bUs&lA8hDTJAaXp2+Ye`f3g6OZmscc@Vb)Yp3HDl~6o{ ztRpM8vUu@{TgiQJibs@uLSa8C^A|A)69Lu`hCNuKl&o`GB~)94NW_v6RUF~=zDO&<50(@c;OnfuD=EE7b*JXEIlpXj&y!@6C;-%3@$77w z_<&6EvX3Z9HNpeEkm_^YBSVw&_Fv+OYg>(Nt}-4P_X3GGa?i#0-k9}OhtK^3bV6m4 zKF!<`qbzpU^8yV*M)?mXNLv{&s?T(feBW@_Q<2C{OiK8!^Q%3ncziB zfh3ty18@7mY&gJ%<%Z%WB9GM=NKRZfr=W&G9L$Y&AnF0%vtc-tB)e|8Y3C<8RoU zB{jD=6WUF3!E89@BXvO9wKy>UZWrfwp7hjW8xs{U!t}(FPAP4C%hzsDzh7;Tu+Wa( zuwJ7<-vAU2l6tNbzsA$1jvuixjjcO^**4u7eFmv4Lh^`$bpcW;Nf48CGs7GBDI~PO zjU%I5_qn(L^@?pdn-g&kn^ZFF#nx+NslSgbwE%+lOp+hGZCfc-AdD1taFR2o;i8;S zOhsa@zf4MLS0JW2({_^QU+pI8+Lu#W|3>7h9Lv({xleVgFf>kylKZ9U2(-_P=(h7w zu&+82_YZYDCZ;rql}c(UyR6opduMJIJnq;|awnZ=9c54X!R*138L!^cd9Y7EpOVPx zEzA}1E$L6%G-!psFx0RZ|Hi^PS##`^pW;SI;y$8VW?z%`R13Uj+ezhm1Ve1qw8fA{ zX^DAblYP70w(+R#l9Qh$BTBatH){+eHOq(*n*A`n(1w2|OWOQ60%d~>yvH9ZWYg_C z2&%*=-f(IkqJv#(*`&p9x+BSfnh0H-xv4+WZC-|-{O!KSh>bt8MPz&7*-H9>p-Y9e zq+vDLnQfYA+|SMTP$pPfRH?|6h&j}ez%7Qee75|PK18gzFSg1T_UpxVg0#Zlinnz3 z5*_HW?HlS-FcvJjKKi;JwwCxtp$lQV?tKh`m0JQTv~w*At&~3MMvA=DD|nLjE#d;G zUokY>=7|e6>h)jMH}%u_8suf`uw|t%1@QYJyY+Myne4|?tf-%D&=2JoChn{sfy{Gd=zl~Etcpgcu;{i z3BFYpx5dGcHbpCUm`FTq?&~C}L1hK>SapWEk{V+vcYkCkYk@C=HxgT86h0l69&^QR z8KYb5VJCCgIg!?ijPFswq&EiFp{u=^YB_0G(kn>{(ZI%Xm&k&Xi0>ivb(%Tq3y0c3oRP&*ap~&q zE-GXsJROZPN2ZfihF{pZLJ8^SKPq9e)dvxc9MXv_`sGl}7Xr>Ljii@kgEl$wq|?@XkCUeKb3Qw`2vHtWKV&(FBc?`)ZQSGasldr10GpE?m}JF zVMmyo&JaP~N_~NAZ6_S+Cw>@SKyPS+8qS|QrQAV?7SW3r;v)Ka17%Uv^e+gpmly+m z(s+&FarJ5FWrSO}slm4pfAG+z$-mJ`3}NgK`{QX5IQK zQH5U!wh>o@92Z7q3T)1NQFm4^pHC-QvSsS4sD4mOFZ$k}63RD&!oKcwJ@Bl9Y0mH| z9F5~Ih6dIcO5QJp;ndA?13QDYiA6lEt?`&9mGqMvg5XJ9NQ6& zM|~)|{HoM_Wi0h1vX;1AHso#9pF?55i{d$<=2&#nV|LOLn`A{=mIPFHS~#xoz-VHs z5qS+G$JH}RGj^vvt-{@bYFF?F3b`v?%>>_!Q-oI*8Dq6nsHq-L3x0f<+-QmWkeVCN z0(^c==mKb&-Lu%INb$6A+yN^|541{GNru{D!l$(E+>oqwB%`^L|EPS{g@@5Uhs{6n zG&#_Tz1})EjjVr?K?1)8r4PMYvw<2|*D^*~x2VvF$QwCXpb>&$Np?LaH4cn1l z017O*>QN!u9~V#2pu+lUi&zKbpA)K6_n$$cKqKvm8u@RaQ{{y%2}HvNA`G6`1ZE!tSteY>!Ot{ksGhty_Svktpiug?cqd2 zQ{u2@&#>$(qUArAs~`7TS>Vl?nvih?frfFVYlHH55l`u6 zY3LlM4FlE(iPOAbyk0@pUJb)}rEf7Z{v0mh36gyBt>A6P!nYl^cJ>=9CN*ss;-GzG zm`dNl7S_8Dy9*`6!^bLw(0lzGH`-=RqKRr(jbSo&h5R35X`n z&oR|&{7(6M`F0UsAo!Bgmzgn6atkwByI`6tf}2ygo@+Md>EH59G&3Nje8`U3r6)?h z(s2hRG~b#Y)?=iPLGaIvQJT6z;5sYJt9%z>aO>=qVFje90}H?3r>i!G?Vo}X1hYjq zK63~Iw3I!+8IbM{RLoap%38u$1~P0(@tr=1bVyIlD|cJ+wQHT%^=c}LF2g-lzf zH>Rm5kH)>a9KQ)6Fg5&V?=y{Sm9D~@hczEA_2HuOYo=Cid>W^c8tQB1hNh}w}z zA@wo?2L|cPZ$6btZz8M)OmsK z`Iv`KcS+vl0CDg?GO!L&H z?hvzi&Au@!mxV&I1Eq zb<3=jMk*@*ifKgcQpwMl%*Lvxd&&epp$(@BlJQ#!$fX!WW(JwfO93qB$Z?SOz7YFP zJ*}qMq$BMsfx+(Zvu{0+RIxaGhd{sZah)}`uQ@fTKVZJGShu z6=sZT4XZSJQQH}ptuQW&z=~sGtOb&-M5?W*B%B?&MNjI|VdC3(y5AvKLmP*piTI+tM@`qofxhAdoxPw4!|}R z*e1v8FE=T~j_-Mw#vN5VVS3-?1xGi2YM&Op|7SfkcZ}YL0Q^1!oAII}rFz<2Il~Zx zq2mN;gw&<}&s;MCRo^pdm2$)3)IODyqKrtbCzMb2bM|3T?S5`_akW1GM+PJx8vPuf z_1WJc?e{4AXDJOAuWcj!em2o7c{sb+1s+06u?k=y-l)e-lR2=3kAgqtCqOErVF6t4 zgwueJxb!#3knETcOI0i$kL?}{8AIPkks#Qx!a&$u+Bl%fVxDz1M-Lc-XO#6NGxZ?P zyiBXp9|v*E>4-5kD!XuYss$G?&~Rf+%FnCiC$@8zIi^;=fR0BZQ;Df{{5`*B3&xq` zL3N7SJf#@DL@#Kyao2j8o=|~zz#U4yq7L6EuH(`+Eg#Y5f7qT!Dqa#k;iX4vZy{fp zv*Wh+5nnT9Z;TZ+IosQfqJJLCW=^9BQR_EVl0nq5TI#wMYF!)cJZ5OTW85ft55SNj zgI6}ABFGe%14;M7e<}kjhcwv;ceSV7?SX>miESDCl|Bi;T>IIT63=7|K`Y9kM(7mjtA8 zN7XoT?UBKV)@L}^2)GVg(qh+JL&?Lj_5x?_21g^1OS?>qc+jc_q(vHTiL@bK&+m-{ z6z)Im(F|DlXx-h>EGFvqOJb=)1L_1&R-!DcVp&udm$l9eT3K=&tWZ)ns4@lB_DfbG z{Z&QtsDh5Kqa9$iv`KtSPy=x32zwuT%IuD(@ZvJ zvFK3AKgk_w;au6?-XwS}|18!xZe!eAP}JZ%e0f;npz_(Kj5K-iY?=ABq3=A;7*ela zt-)mOgpT#jtU{g&+!3y7VuZDh${r*m9hJ%AI|6rL0G&zHFW#5VA`&ooW)3GJXxPDK zNe8ro#xV1N2#P0~?F`^pC5F(9O9Bu&XTTFC{o{z8?|g=~tx9 z4>ZO1&mdry{f5KfK?SGdj^@xHa&69c)65M+|04$Q2uM|S*VqOsp%%(()`$tOCl;^m z<6o3{rk`raMX9}Pl>vGxcQoipJACus`%(t78|sze>|xC3X?<-Ec*l>#)iLexBu*KXRCvIB^~4V>>Sai zYWD<5;qyc2LncVz>&?+q2kHN!PJxikt$T^__V*mnZfV7}oh>hGkd_4Pg@acVxWfyI ztHH#oHLF{eJ1(oLD_blqKfZQvC;yfd^7(YV#{ApS#r;0`r7le=in%F-PAHFRV-HMp8edz1o5yyc)UHrFe;d98<6cV+ZLaR{N!ecA6e7GEE*}nb zw#Xi?Ukwm%UJn4j6jOj7KB)3PECJu6{kYHih0KSpUJPjACN>8fxCw1zp}t2!&RZQ` z+qS-E0?C9g$&Rln2p&D#eKgyUz9qSdI{C)_rsDHZ1@NYZC^%#V@lD*z8RYUsvb=cS zb)iiT7o{G8u78uD&`sP*;dWj1Q$gjV)U9t=grJP91P#y_o6uuIq>B71WY--&jdKJi zynN^I{+7k5(PPW+V}h!wl&veGD;&aWI$u{utG4x9!Q7E{k}es6t)%JqW@SsMITi91 z(7WRgb2ctl*fM2SRYa>Unn=BwvW~YTYwf) zJtr&Rz-aDQ_+f;rgV14%UX%kfj8l!{si3Pgj&B*HG>d)vH(ZpVuoe=yOEDGB*Y(!( zNZyaa7PXhXM*CSH{ZpfIJB0WX&m_<^f)@^jZ9I)3ezx}FSF*2WCzc^-ZNzG?Zt@Jo ze`a7^V4Pp4M+eo~6e$@QFg>a{|6*qsjbYaMv1WUP&u39$uyi!78tNuJiAf(wWBhD{ zVnq=9M+OcQH@1b7@Zcgy@;SwfIlmTLstOj7{YT!;m|eKE6_JEx3jCg7nqo6#&V;Hg zPQehmFt+H>Cb~(PPJx{m0m|HA1&qoHG_y)v$jrG;143*18K*irA0WIWs2Vo%0t-EF z&@CgDI0GBjnsn1oxNvL~0cw-ahckT~0p(_ZRRv2YQF?y!7%I_2MGF^#B?HjfoyMkC zAEgAQ;SxYBJh=3UCB7#Hn1nnT{yKj@P?jtR!-nGaw#yKcO+)4&O&L;T^M<1v=y6(Y#nDUQ;@rH+@&{41Nt1cuK)!CEs`I}6RD>B`SFzUSfFcGb@fp*` zzzV9&hOC9HcNx!?5zS-dr~_C^I7UIEzlyr)9(vW&o(gd7zBBxf#U5C>%kS|LdJA{Ez;gx7S{OC>Za+DDKx{AK6=~zwe<^@VRbd9QqqU0ocsoI~eaE zDRAx~AMV#`AKHNTm7NZ=9qA0C9S{&0>*T^9r{5P{GzDa?lFsU2P2Gj5UG%HnRG0sK6&m0qjC#1(K5NvaoIc&%ZR+; zyyz%=rcua5@s35-1k;jRvTYe;gS2pFK56-QNCx2&oPrW8iws2ZD@y@Xj&l@qe5`nSS7csPd>Dg zJ7uBPjO|<6#58u`EFZ;$#vH1-C796X93qfYL*-VhAQA3}7a=H~0;N0y#l})dyg-pt zguB=||F2NI6W0T5m*Iu*7nw!}U&CjSh6_I}p?_Au#X$aqV9CsJ+nTc@cdZ$a#Rw$A((X z5NH%3+_nqh^RATFlIPiSTaEqDON8%<=Z#-ziWd<8F}YJ=XhM=#@nXnyT9kPeQ*CXw z*JL7E2#2m1>g}q6%wF?MKZ#v(wF{}s(13f-Sl^|CYJ>)xr3wt`5nx*E`lqEkFAL9z zErpJ9Q+5p&>t+YE2mq8NP4H z$|f}fPw;M^5KPUvU#7lz7M%~a?cf-a5SUE7jS*$#+zn`1SzL;ie#(w4D&tE}Xj5O^ zx&i|pJ`T;p`7BA6cF?vXsrKOfo6O5XzE(t6U12j8r+KgEvDrc_>`o256eSsC&)H1) znLkw%LNWCybWJZF&grSasB|?kxq4K@F`Olr%h$xS1WK9(GN0Z6M~#1- zRUf9ZEy|jZ-Ym4~1{=1oJT}2de1W?~-uP2e_Fzf4J|qQ!)ufA`X!1`98ldR2$Q4?f zRrPD~-v(7g(eI9MW|nxwxlwp|_OtNSn$ab^5W3T8Gqkztdmdz=2~7aHSxCVV79)|R zUWr(+nM}%|Eg*O7sgzM&3w8{!9@!g`WAlp^SC$d4Hlw98M4er^C*Sd6O`{2^{&fhZ z8WmZy3jRArH*N2%Z-h86s?rgD5<_rmm3ndIUSCEWGT#uzp>^M-GZdk372qgSKgdzK zwx6X%b$7_=xkDL2K&M|UgFf1fOvC`ZC@-otEevV$xQk6aqR) zr%$~n-WmtI9^V%5c^$OnPq`(|**Z`5`TqTb5Ho=E%M?`iKa~$WJ(sxe1GDy~iy3r1 zPal4|yMM!_@%h7jq(2btGBGc%L;FC%&qUoLI|v`PUeN6g&HA7c-+|>bL4@nwe}Cp9 zz3@b=!=A&b;6O*P{Z&n|6M4U_PRsX|i#Hgwkzg}Lb3QP{yOXhVS^dkq+%-4Q0+Nf- zm#m4*6nfFOFr96Lgq9VcTun~$MX7e99*H}3>Pb@CEv(By<<_y}4P{JX0@C_ZJJL{0e8pxtWwbMj;WiKj)p+ z1FN$e0;NVqnI*O=8|8`%-9iu<1l5XEBBIv-8WOL#1RHA`IdsTsbYccqO!6t8HP?v^ zrgpDR#CY}x&zmKZ5l^cVyDKipJW%l1t*~eX=PB_y6L%o8x8(l&vqq~pqA3!++?otx62262AzvAJe^5)v9a9r<7?xi_)~s;{m~DWyOwXbCCCMi z0Wk+}FrWi*qOER$q+q7jDHV69javKE%`pPtxP!z=p^D>XI9^e{M+8fLoI#__hu&;f z1kyG)BwSn0^ed+yn=28+9W}z9wQ`U{J;)K`_>`e^))ekvm`<19T`J-OqxKk7J+ztu ze9b_18>XD%>8S>d&e8Q~n}2R5TLsKkk?6ija;U6N_;vxMU8iOQ*AmoLdCVxUaYLEJ z(Uk$WxKD0ab&>_xJ)`K{ehv)W^r{F&B{Lfv-%>04a!CEzP@@#DOSaeF z*+ipf;lDx#>cVWFyxacNyQu974$E}KS1HZ87CW;*_IYxX8R&AU;T>ncAg9!}!80K! zA{tAj2SJr{gC)8eC#h%zcr|OorJOGLnB=Kjhfc7VI6QY92ZX|6R7TJvF9UTwmC?5ey?@zhJpGmSTrIz|`DqtLsHaR`!L9J_$+=34%;jf~4- zPu^uG(Hpd|8iaGh(eE)D*?Y&Arj`v&UV+!rBkCH$yJzzpz>eH!Mzyta(v+ZW!X^uC%E?qITAOvfmoIKBXpCE>aXn&Xhj zp_q5p{Yp)>9sX{YCF~n({J<&igdShs^eedLbM|tFpsb5I?hEuziomcW+w7J@Ru>nw zy%67qQ}GH!u=9$s{!E6Q_Y+UFE0Y*DOAcxp4;30w5YR61ma5w?uMDebotBYyMmAZj zWAoFl0E;5h&VSJwb0yfv?pCyAnJE7Q{_l-B{GJ0o)!)V(<8Nb*_Wx+5*xD!>n>t(R zI|v&an*T?i^1pZJRJGKwRFHpUX{8Z=J(tzOR{842hrr<0Cbk`XMwdpc&VOph|&vl3#m+}SCg&1-Lo?@@1MK7|3K~#eIoSH z*$UlITiw#b38UB1Pw4RmE8U`vF?P03wgr=rBNe)0iqTW`T<=?gn$f}HZ$~(H!u5eO|8!0Mxs_<6+voAWtFcC5_OGupPF1Qn$7HRpsJ}gv zwNRkCh_Oj`T_>fPE5)p7EbrX3)SPeBAezhER(M@XI=v93tZg?!nZ7hua^}g@qieM= zwGDsN|;G9RILK zhglx~)nc0j3Y07uuOcPE>@McCBkj$3bi}opHCR`rLRlsSZiuxy4@ps?@}c0|1I1Ru zp9k50!&Ixh!mOxVhF!fB18eFA)0?WdQlm01BLkUXJx*K3xd~L?dAKTQDRNAw%~9W? zx*|7(xt(-_Lo?DI3JU^fg$f2rls5kM}@vA>h1ZCU~H)PsOXg$#?lxs&@g1MIPDrw|FybJ zftEa||3>6fpuqow|F17BDM3A-80H_o85YTMfUz42CdA+24^p!naUNH~XKba^iRQZM zo#~*3SX9^c{Y4q0l$cH4rsG#UwL+aAQ8s94a=FD1ArOHlOqS`+itB{|ej*zF>G3zP zBknKs=01#RYRnX&`xR~z&l(6afq>Cb`{VifIpTJu zwfTr<4k>6#Fd35?R@1zn2epvlDqGZbKHaQOGg}Eb$d-VLJq!-A6{F5Xl zUHMS=aH*$VcIkhOfDkz}O-S52W;oBqsb16QIi?VF*{J5}?qc!#73048}AdU!( z`%dv+`VA5MDEUG`jpN}$PB{DrwnqT-9TgGkDBGcNYGnTegWPi@a0|#>uhzAO*C{_t z1eLzO?K$DU{QEt{*x8U`LdVJ9ux7x2@tyx7OiMmO5A++vWpN088fPOLvjyO*DVz*3 zfuD3RMpO(uqGea_8ExWzNV_?0=06R<;LolL3{xuDLwP(J?Nm-I+m|XAWE$O})W{bl zJaUR4NceqPAzvwtvx}LCLLtnDM&T2Wsd!Vd{wK6r_nklK0u}%u2onH+;D7H>iuyK2 zw$}1y4*HJ&#hr*&hxXDkb^eE^v56)eNf-9L>6q7w917xF+!5pK7R$7y|5wl24 z^Q76)vOJbR^_Ro`{0vOPzqt;UwFLz1Z+@CHaE7AM?~IAyX41e0qo^+T$Vxw_UZH2* z>)Fq#q>GW7#K$Dv?zhgV@6IXL!(#8pgE>IvaSgteGAlSFAqw%I2uDtTBOo{0 zQ0sl_#4*=#*Rz@c^I>O)mkxz4{ha{UoYIlXCeL% zn6Kp?O7TA~U_Q74&_ysGgT33pwKTO8mF+KZU_Mv_CLfc%Qvs`CzKe0b^DDIDtnL!m zAB|Ao`F-8zr(NYIjqLA*zFzQp;6=c%P@jKFq5l>V|E=^NKkz|4_Husq0{9f~uEOSz zbc&dP--8rIDIbuOy}{foQ8Bp500~f}>d8|M!HAPw6RL13U%EuYHFs1o74hOr0WBcJ z6+<;qhY2}^6Xg3bgXy0)jmI4W=}zHJ#6TS7Zb-V1BxcD6>Bs*NVvn}+69xqs*NZKg-82VCU1E!<4Uz^Sxy_5LtiAa^_&KmoTc1BqEg$YCm(O7}6Qpl2i{Fk>;3RUSHV7j`!Hy`~Vz} z4Q0DgQkYSQETzhy?@@MHWp?@=y5hsagnM)BDhA7(X-GJ5E8V_?zQ z)5<;hw$UWDD1Y0E#zkF1&F|DI(&?CcMlRg@X^s?b|1BA~F4T)%J+iT*Sn{zZ( zEyaA7pYF4RB{BQxjZ;w2hQMKFP-u;NkDbj8j3~jV)u_?A2%T=Nx3@jU zCgzURo2CsWbm`syB4fGrU)NQqlBbxGR`#;FHj{C1TNYice!6J&;kmqBm@{XF$gE%$ zVGn}5mt@h{Vb{cdvEDX+K{k$D#pXxGTWDPCrS!ia^kJ+_cw~fl$ViCW|%ZzDzD-DJ~iGB_o?K8~TTC_g`Vx%_c~VS4IGPqjwpOpp;lAQI%RI zw4~iDt5}P+lcpmzbKb;Kj-nQf%MuURIPa93RhJS!{3+>_6l?w}sX zM_?F2udc*sGlo-A6bwmmbZW-Vk-%asc#9KX2*Z$^@1YR02ztZjH6(fFh+_geaaoBZ zqoH;$p>&hvI$d5@hdih9_(+&m0{ukhSbqd`jnT0kqxh}KOP&!m4F7y`g82MNSS>cq zJ@eIhIX!gSwCxfJ>Pa#CI6aWF?}(8*k4v`rM@0lmxohU9#)_L|MsQ2}E9_Xrr8B7D zh1Bb;U|Vw7jxt^xCmqR>I}-z?%F>6(Ny3JT7Gf4{-;0ir%A5O;x7p|7%*;@;`R=$h zM>XoWJwJ&W{JGt*SVa0uIQ!i-*u5*&r+9v`rFh%k zJKVab>##$T7%g1=sicOF1rw$;r039e@~0w2M*ewMc9r51+ia+EKFY#2rrJx4(G<-c z&NuK>2sxftwV*2LAgg;`*|Kf|-8bmk&v<=)(grQMF*+w}c4=>SL7~f&ofzT1i)vJ4 zj^lNT7W`?1$UQt*p?nI+C7t5Z!*PNdi*VJwJ=gfqmU_Y&w=Fs(uqe z3CHncN%5rfv09IpqOXY9-eg4uApb72>41~D&0uPsafJj}Y9NUdA zU50A5;aITY3K#~)3njj`yzozsgz&>n5*_D1aKGx2v%@bIxKKJ?KiO0rv?ab=@RM-X zBd_YicGz)r)I+k(b#S4>Hae}J zp4ZVW=>IOvH$EU8K3RG07_0w5UH@}5x`&o-`*}yG2;1$;hMbrWbRfhH7ATUHK9Iff z#^t)B-5Op;O1fHQX9`;pKED<8OLK0^Y&sUE9j#3yEaM%v-Q)RirJmV|G_--~3fUdv zdFsaF8~zkm5Y5)@|Kxa7d`!Iu{6alE+Ide?nD}J>%)?T{3;2vIM{rBrn(s|)Zkh8R zt&hk>F|BI|)iImaNBOSnc6NvR<;VM^nWoO{HH4lHI#R5Y2MIJ+lnWCjcSIFbats7j zk05^0@=B{lE1wf}?JKB$AjRxDcp>}7p$&c-64DS{ZPS!`!}ocCSYE6!Qp&a@S)ZHV z+qBz*UAi=9z3j$TpzfxG(H&*>A9tF}d+9whulW9nZZy-cYZdisT(i?d#cE$$!hDb^ zj0U`fes^p$K+S}2k~NeXN*i7QCNRXb4F?hYK>)t0=4`SI(n%jw3BKKg+6_~*T}0px zt_021I|%xcuD>>|518kQ#4&P_*`C4XY}fAY&%VX_HJQ|j5I3CP70vn6mF zoy=v9l3UhVmBFOb-UGXl8?h?q4B-As4s44km6Hc$u9pdXfg4-s6p<<@Ci8v4fJf~U zCrQe*EhsFk%SdNSY;@rQjjx?yo%1(<&W!UnLOR^%JanLzkzNNmuJ}~RlxlnFgJJVA zZOceQGrQ}t;e;(BkG4x6R%Xt*-Kr9hJ>7E#`zfNtyhK*oi}kWQw4hgNJi$YkIl3D4 z=(@88t(Dp=0JrBd3nO!kaBccZd77&r;SZ`ly(L%9)K)wywwiNX8&%KReV(&)U$s|l zL=x~_7>0I7vAy{&2f)*yUJG(G+M+bphOo7#v9(93xB8me63*)q$LD69*uxI1_{hTU z8BQKY)75kJUVIXkULQ|@x!;j_r+wiKBA$;L*(3S-mEM@RBWL$TZoVLN`{eHEeL@o7 zNN|%WkBV>?7s4pe*G;0Rbis4O%1`HDhR*iskQ#M70MT@PDr%_qcK>y>eCGYf5ovJze%d<`i$)ieL4c_yz>%%16@s|$Y^r>wZca}0-l)G@n>NWuW^yw~K9YC))@q^ifO_8)qPlN=ZdrVhw7Q-A;QjX~%Pmu5gyuKO8ix2k z#cuz9B3RDF*ulig*7biSSx9QX0)zJ7BnyAOfMU2}E5Sc*MRgvZJOJMsB1PWfHakcN zn=?I}iL8w7C;BJag$8l;AwSmpOvqPJ?G+b@iofiM;PcAy<$Ck;%A3*m`|$-HAa~Cg z2#*kN6u~5Y%aC!@C};ee9aoRQKU7^>4>I=6D!m=$1b0-T4s-PMjnE%x<*h0WzX5kp z97yiY7-rRdJ4~NiAV*S~)i7;8PuF~H;jWp#=%(G6!me=7V>#=be3QsxqtduX^;pQUvq)M*b?|R>3K|dtMv$}?WSEM-ju({~1MojSu=+;x`pC7V}%lq?lRrDs;9$ocE;d4{n7BgPyNNq7*FEZqJ-;j` zPKM)@BvTF*f2s2+K!i=FiuORIg|l6o(^mNnYA~}9*$>_ODb498aetm0^%m-kW&k5J zU!ERLxOsSD$%SUc=#7ZXYZ?q;>qctpiAzDTY^ao4an$-OkH9YyNt?mSG2_TddN0+U zMXOpvY&mC`!-|+#JDE}Et+`)@J&qyz@?CU{?R|F0t@D>39?MtJp=q2-`ZDE|H4|BV zVSdFS1~qIar%!(q92T4N(w>=}^U{4*c}n#@YMnKx<9rol}YubfR&Y zbv2Sza&i*9cH(4%4URi{Z9{9-PM*I0lCF+sQETuX-%IK-dn-wP*|y^{y0ns%;RFay6-uX{mYi-9aK-}sjNB(EkK0r>F&)|Y0THc1o5ODNPxR0SP z$Imb<-_I~^-_I~DOBQtz9A5~FxDP8=-`jn+6WH59Dn#+QjrOe<+>CEY6zo%*Q1QzY&~f;Ud8MA5>~ zV0+hZEB1amFXjZ-opda+RZ8W?uR*(K_<`9LEJmz*LI;9;k1lt9$iL7kfMe+v{v5N> zWwTn6nlp;M4z*!D2R<$nkwEq-S3W?{AQL~kshr6vl1)IddLrw0eAD~i_ZXn6vV~HmY(pp+ zkBgCIijxNYrecGl{Q}^V>`Lr#LOtE$*cxqr{XBhy?t@#AA~)C=l!nAL;hAzzd#&5k zpC3+$G!7Yvk1FOc8C$)u20IlF4bZQmFtlI3bryD*515Sctf5R{fRPgNVfy3R9eNL*~z(*wSNmTrKu9WqxFiO`bi$ z-ho_FDTGF4oJ2p>mouS0jOiYYNHBl~)=K7~*|PzMgUg*BPJoo5YvXK;*Cq8r%w%~LyEK63s_dtXr=~O zFIz}yS#RTqsav82w6th;YILr9+g7_YwlwdyzfMm|GXgg8o%DR(@Vs7~ZaMCFJ@>}) z2na_;*%NeRTz-2=hQZXpFQ|A`z({?0X@+@u96Mp8Ow8dAGGe4m)(M6rGiL3dG99mz z4^m=ee07Q1)xypb>!1zQ@eWOUsq)I~wLGSFi+0LFuz9V8#18yP? z&7mCFv>3l?V|aXRVHFfR*i>>8F=}J(Sp&v^waM)m5X3n4X8om8|7~;=_DRIw3ht91 zp8~FL;U3_4xkFIjBKPe6IdFaGG$(DpHyz@qA`7dCRKB@x}yx`viee-gs^_cSb9gi zYO^N`QjB5_?Kb8~_zFacJiP(2JSHi5puZu-t)O)#qPPGuO4Z4fF`>#*YqPAypD0aw z_!CFnw~G%Yd^AD&kfq&UnOJkx;u&}*YNK1Vi3g28G#ki|EV<6VkU3C?5;u0GT1ws9 zTeYCR5Q+as=X-?N7>1p|n8X9CGYA20e=6f8+WOvR@1@3ihn$MZaeN6e*0!-_L$%d} zj8DH546#0@#*I&Q23?|>0hGiBLwp?y;O_8)hF-7qD#(#I4Lxk*{GDG>j^I5AW?YL< zLWBxs*JM<)ipB*QfJ6hJ-rD8WgQ{J{lA((T@%p9#aXVXH^@HDjg;2hPP4KT)bZfm_>13h;kPXe@C-({$GRj#*YdI3%tUL1I=8qyim<`F_>_$_Q5BAU+%Xxu?FiUM z%UbwL&WM@hmAQyg_Py->|t&Q{Bk`@ z5Ezu`A`)z&8^1P-Oi4@1u?%O_$yEo6SN)1|vw5;)=9MvDAnam0Tlq{Y@43BTP!BQ&bk7Jq*s&@ea3^$Deh7M z&c+0wE%PIWqHX1Yi;a{QmusczdeQogsCutKl?Hg5GDQa;Y}(X53OA6a@M9w|aQ-YO zyP4_ys*{O%j3sFfaDUvg2SkIK@d!0C-Uf9U=oA48zWiO506P&>6mOC@>d^gk_8s(S z6DBUgn}+GUKOiWn8;;!+*V3XOLuAH&tU^qxl(Z!#a|Yp45Me^b-@ty)6vXN@tJ+56 z3;~d}5Xnmqtfr>jb|P>rE76+V3XCw;%?WTk=!lv^h!lz*c+=BwIpT!r4qY1W{$|QD zLoe%UluF;@AQNStYne->kt7GigHgg<3Qi3K{_cb*^@%eVZhl-@963F_sh7raw}LvC z&4$hiyDRGqqh`tN7gc&2TqIXu2Jw?%*m8~z={xCXML8vIy1Lvar1)(PuA?(OH1>DM zS29Qwv<423KyI&ap%K@U`f~J3j9siKiiK@vIAJA(-vgmZ+^3rJfDCFn!RU?+VCQ}P z)Bx6v&j#O7%@pd3c@_e<&Xi)g%JE8Uil)}9stJmugWnkk^JUdrD#Y>6G5$5y1!dD1 zVH>U5Ps$ zdh#ODCP9oce7J#vl*9~)aHmXSCf{tjXu$~>Zv!Yqw14u|v%HN5t7e+F)$jlPK|2zN zTfGKc%)qW^+c?osbCx}w*fhBnmRzgJX3CnhhRV(<7V^Limb4tWRyK)R5@yw42olYo zPOsI?a=XjtQXEbK&jQfEM_HZH@A%a|DXWAr3oQP@6L(s-Br2HCD|!YMTq_!NBY49$ z888Qz{vh5qTkv)w5;SmYWr(kHk-T6%Z+ucn1UrwDh@G%g|JAm)N~|t8lk(sXPCpSO zA!q<)JmK>gEf6tc=LP!s1eyOxtdNo7?FA0p=Sj#dI{WY%Jrru|J?Q&P6~)eHi<28V zv5{_zxMn!D!n}^z)xzY)?H{7QLGZd`AbD@rlS~eXsmtN#wbDeqmY0#E@dVm`8E*^(&>zmzWedqf6 zo7g)lKpYk1nO=ej+%isg_d1UlgTYPOJH~hS2ru*V=ige<>N!i|OTfd^3P0B?%37q7dYQPg&3dtBfk6G{2qnW zgtS-V#D4>|XBpGY z=%qgZyyuu7^prXTwl;Q6Ux$fq>tqInLi2iP#u6x1GD24G-eG&qL89`^gN#z^GvISi zG`KgJr6DnQqIQAy$`y1uRq^pHiAQVb&EdC=FhRdC0cZus6ABm88pFc%#<8_DVoH=C z8w_oT&JT2-hxt>SAuB|V@=EGED-y5tiG7bu`zBHml^0)*53VY#xVs6(fN+`>)2T#G zo+YQICjIf*+Loh()RLgFpM&7T<%jVtFxYlyCp9jP`>q@5uZQ7PetioUR)V9TxZd>BU?97(b{&RB2`mQ`I7*rsHijU}G-uO-Q- zD!TZ{P+m>F7O~lL>sSKMlip8|+(|lwj(Ia*RZmf|#zsSKRZ<%mIl^96;t+5uFgg%b zu@`ZK6JK*ExItU^y_M(P>Pr8@UQy5X*%q)MZQL^WkwEDQpvgNJHz#B4IdD&Cqf?Ox zw>sLqd2&!{a4=9cWuaK*d@!J_p_E{-GM)*cijy@u%h}$OX{|0fjFDAUSDp8AP}8>2 z=sc)TLW#HNT9a&E`~5`LpsZJ10$YJ}9(aG>7g1)L#1t(j?O^>R{?bMGtFS&5;l3|!yDE}50)wZ6W(~XQ}wDoNHVs7CMrut!TT6Y>o5PlXXr)Ai0@5Q6MP_7SwPEE zt3C6}DWXFxPk#fcTuJe9xL-RIl?{L9T z_6m_K$gv2wpsX?923CI6_5H++T4L%ioti8i2VO@{1Z@;jWfZXG7yLjS=b$kT60WCj zf;uMsyV8gZ*3iIjG$KJVVnsDE^)E}-kJBG~#n*$Z;ewRqLb1^Tb#@)_;-S}q0^0-x z{tLgj1!s6wNYK{Dz|R}ps9S7$Zuvyy5u#IIJ4f|I{q%)>I{&CGynC?zWSt|nd%Sq= z*@bGI!#+f@5oFHRX9cmQKAj_|NWXMtehik_hKt-&vbBft(cuED35sr?Vn4AKY90e< zl!)t8d{1HcPh5d&C9Y;MS}7dn8?{a5un~ZWmMvXt_(%wX&icJQpv45;9z6=-8`+kx z5dS+X;w&{nyq)(3G5rdG0f68ND~(TTmgDFG*I1E-8%RJm7~Pl4T%eZ)tUWzrYl>mKJEYauf9sO}B{z}u^_pR9 zdf~_zaIh(kZ2laAP`^qN$pJ%4a#tv?E~DFzpCPXGbpF*o z@mT*^*_%P69IdPMPx9oc0~D?@Rs<0B34Eqwu=T zuz30)#A2+Y1-X|OY_Oc9(DB@yw3!(yGcy)u1~lxnCp6}Vge+|EA|_NWzfkg=JPNZi zEbOw0`B`z|!d#>{LB?0QEGg44ZE+;L63Jp%-iZi?`;^mthPc3Lx%QpoN3bK03lM2g zx7Lvbj2f)sbE5L1Ly$%OF=+L&kdbQWC7Ag>@52iBnFa-8Y-gy)eVV#zZ|V#h=>+Pe zOa;36U5Xq0BB8VwNzY(YnnHXwVWS5a77MHofzkn9kx~kXk%ylw4HV2mLWrJ>#2tM$ z81RknVY%glyx~^PAMZ-D0LpMEHw;2sj_HGB=Fr(9&@J)OdrHp0Of#O^lIb=E4|^nH zH=gSQla8F(0xSSmrdG=6C;kSxtU9RB~niw7EyB~1lTEZk=Uy!W)Et1sk0mHS+D~7A*0K;0o z;_Ki|Wv*TGm~c&Qs$a<06jG*ipbV*{t5s!BynDU3TK7`1dyRl>h9Xfk@ml^bld z7}|K<{*B5fHL(RtobGBGl>VHy%oN=GVuW^rE~~hdRJetRJ4xv}^MgOULbGJN1X!jA z#&MW<#VYQvlLqGB-$V!YR0j-#RBl*arF24{mVd8nRR$vPeH|MYeX>xlTP=63AGSqI z$DHC+Z;O>wAgTo*U=@nF;A?S;oITB<6qi59%G+gfxhp$dHt@S;(x(Da&3u9xzSZ0aGg>AKs4WF*AS}pXa9qx6$xQg3t@eIv9ULPga2L~ zPj=nY29OuSQRQ}B=(^|<*mxs%zA9d*ut;lCV$|Ew=M=LEI02jW$tYNv#i`dh;NU;S zA)@0OTZ>P7HGYjZ_Lil;rj;m49!xYyejcBN&|NLPfka6#e<)A zL0)JDAkSD_Ls=9MAS*5C;yAuw<@l7|Obn5;c3It_{dqb1KSJI+sj3mPjov5<|+ptzZm# zXYgGrq^6F5Lf4XIFUnTYEgRo*_j{b1^IpzPEUL$~zKGYs%g7o57C5fu+S>j}AAd1U zpZ4Ynx-H8P9xIO>%8xTnixs5%X{uJ~+%_Qn^sb-dOwaK3&G7ZlSn8eX>YeVAP0t7; zuV-Y>a^#w+uH?a3-}&{ZP2_QK4*j_mVlIw*3Hu9BuabvbJm!;;N02?>EZlGLHf{=1 zwg#bC{-+>##7$Elxg%G^NE&=nGUHj0{tHSDBmTe)pySux)ySsaEm*Bw@Y~t?j5-hm;#9f0s3GS}BbM3wM`R-ch zoW1YceP|wd;4ivHSC6jhuAxa4s8-@8dmk;A{0Z}CjUpx%FL}k=fve&3CR$oIn`M16oMnw-`LIxyf{;vqg60{or{h|)SVEq=b=F7dd7G5)UMj}Y88 z-18+aRUmue4!&12B|F1bSkwkeGd`GWet~i6ZkDP9`j-c*ee8>6Yg=SXd$H|2ARVj( zzS$Kpnm4E(9F0TMfyY~T@Rp>~l*g&U*z~%Mis7U3FLJG7uvc*G%PCqX*-jMDNkb`d zRoIlODRD_Nap5DBujtBt;=xv1C@%xw!)zbZ6(?a;9zV3dZ*5-zx@Bj#haD6?uq`+U z6D4&67-lkU(!5sMHu)>#)N0{JMV?igDoEGtJmkJd`f1HAjZe@WbuFr21CI#&w5T@G zNjPh}`iyr)00M}r0wzH`xx}8;gS9Al<0IybW%+eM;zM|vHra9wG13(r+Oz6K5!wWm zWIOn)CRIhq=3R+)MHO7ug%OFJJ(xsBTozY-2}(6;KmFh;DCjn%o|Sc;mG3gv+YY`Z)@u{T z$)k|ievL-8QBIpS97Z65wqgLH{v;_dGT9!JIaHs;xAv>lgH-ug{OZl-pIMyDrFvRb zs$%*%ji2!GZ$-^I^eWO$P+?&MB*;efKWDEMP0cJFG|WFa|5uqIG+|45jTLi9q@_Sf z0zos=Kq)g>X+E-bd&;pBot4|waDd^|#j{RnHwb3C0CgBHbHQT{ z{iok3->}G+tG14wHmDgX8qu#h!rBlEm#f2>aULWD!kJw1o!`tFBAEbVYnmnZL=p`| zc~=a?ay8OwTbY_MK5RPLnTN7@2#afcR+q>gq5@fE{7C8M!|&q9&7IUA z-qLSRZ8O=v7QCy`nIcn7vx{ZK=w_*D_E!I3f96jm{{=zzBH>TR-5~^+yXyujd%LDE z1J^@%0QujCt!Rado%ROhHgkjHPaf=OJ*4AR`g4zqBhUD))ILiOHdPmeasw5u+UkrKdkjieANTaJTIA)vODpQ+ujd` zOZpWZQN}*QTF@+)WxzP&Oak9Hj|jW`Wip&d;RQN+`ue3K-o*JFyh0~1)#-{eqaHBc zQS{aOK^ehE%of!?Zg2x#aRQd3;!IdN&)P7f35{W&Iwb7c^tJGEH$EPW9XjoB?V*P3 zXF?WPp+YbupAW|sKkZ*({#siiyuPk(0J(qU|H=LA|14yLCK`c+_b>rl^UNELj#QXe z2u~HXCAc`M-|Z9;X9p~}hR~TivpmD<`KRJnzU@T*9)L>s+CjOLL7Q@jkgJYp7|qUb zn-ab`?|gZ=K41Y8SgtCF9E3%&3$MjAJr1NU8bJir?)!Y_;dLlpjtV zx)1I{_T+7C7VKGa%)_M4w~j2B5R>WRMAj?|{QzA56NL_z=SYsp0mKk~RPLLX6N~NG z`fM=qx11ky=X41Ni5&J3bwDq~&qL*p^RlCowsC{ z`qR;;qTQ3PeK$#+WyJjzTZe({d=i@qpDpH4PdpZ!fe0xyHL)^Yis_>{wNnRG7MgSi z{m`o+DZg!~8Q&JKR_pfPM@9?H+lA$}4bW|$4~Y7QdI&SdybQ4GUyD+{30fGat8_un zSvxeWXg&5xKYqV+x;)0T4EXA4eKLxoTBcWskSs81LTEKqpdPYKxP$kQIfqy zKjCy~?1|8!JHXL+nay$x<>cz&F)_rLIk@6D;YNa03AJvej`taU*JynYcUyScEmYiW zFhEl0uU;qSrl7h9d7U5B-~2x>dX7K6uKo|N3(co`mP0k-il{=;!!wOEUvA5w4ML-z z*+o+cK60PMo*nbfpDHW8=?UjYpuB^9Nxqt5X8XqF!Xt2S{>J;Tp7Hc_@`3_}bc)3m zrxn{o{!4YIb+T^CC2Ws*7nY^^ba2Fy z1O4&x5=laZ>#8T}V_&*9E@|&i((=!R3|eK@09XI-qw#o4L}$s=IJT@4N;c-So)fgk zqkA)4AG7z@Tquj5Wgn6wBKAufAuup&HTpj=^B1@}C|s(3zCS3Kud$H?WT?WpPQ(-8 z&lw#eK_V57kQkup$wyV=sq-#qZuK$)$G%9L>%KGW&CFSBB&5g3Qj zz7VY^59e&E+KOYlUxJrI@bLU^`$&FzIjM`1mixC_w{5LVD}8x?ekSULVx(=w zgaKM&=}>mz1Gx;-)@=xBSg|DtoJPzIiFwRhL)Wg&#CNH&*45aEWXQobHCQoZ*ip|J zyzs!_Lec~Y0q!IhLsoq_FlSF zG#NWaLIEEwXyGzP8IV*iHT$Xnro~)`Bcp59`0cYr1sF#7zb*~?5Rjlh+Tr%|A>Hsw z3BB4QyfCxQAk113hDFJ(8S3vYJV@4xtQnN;?0@kZv$6S&vJBg_6UVg~GfNh;_Pf0R z=Hh|Btc!Ep@*ERyDs<{OUU}RFz+39#;{;}5qfEp}(~%p`3zKU6O;{Q5xlF6@xtkrO{ur6JPMK_#s zREZRl9Wc$k(Mk)H6a?YOHASf-(8mDo0z|}sz;^L`{Okgb9Rk4;=Z1aVVZFrm4>Ym` zB$s@6(NF7O(4&c?9#zn9iuD85+Gqs2GJZsN8DSE^1Tz7ozveB~D^F}51Bd7j>{qUp zu^r2c=D)6AS~14IMn?L?+>HEAP_v>biuU7l9Upxb1kIz-tSCE{8FY#T}Jy zj-asTZ4b2|<*Y97MqrY@#)TVRnyCl?!cp|QQ?y5FZb?m9O7IkZlx1|Go~J$~2h%2;kG8wfH~i5NNo& z+B*O1PDqS~kv(X)7Md^BYp5w5YHki_#$8+KWa}9an1k-LTNCChJb6OQ zEhuP0yGp@VC2Xl1(S#RbxH1r;eL^YND4p8~dnHb9Ys_A?cujVPEI~Hs-=`W|g6>dB7Mj zq*APPO9)#ii_YW+R7dULHpy|qQN+@m)ICQ(6AVSucTJXAiEq%KLWJi0QBWWpcGbQr z&_Z3RA*jj(o0?aQMJK0xgRMp*k9NQB>F7n zh}+roL!FocJo?e5xP+if#5e_EK)^phT(DX%{Rm0_Vv1^7N-dc2`wbTlcJ(_crj`vy z*tfHLy@>ETJxa8Bt{lUQQ&u)os(uwkC5>GPhc)W2YSrk7)`P+tH?N#9mqIh$l z>x)GHJ#PPr7uG)`wub#5^iD{kg|UMX1rFs3PQ8FBjtRaylGc{fR-F}1T?AKzaYGJo z{XFsL>kx^F-#aeGz#+^Z!pc`u&1m=rmOQ=>r#T%5*=-ykW#yI&Fzh<3zJ4qM?o!2K z2TJF~e#lZLagHuo3Ui7mJq$N$Y~1$6*zz)0#G(>eZ6g-VKzA)nsPoc9GZqyr269Zh z6jQ;CZb}U+R``TzJZO3HeS()JN9LB!v#;zDCFQ$NmMZXX8;bb)$>4~}Y=~`)kRQ9I z=r}gD$(qtBNJb&la3W19jaKiF1$i#}D_(4T({wZ)0_m#nmr#+s5H)DRe+HCG#&pQL zo?{p4Gr_mO+C_lgjrl?Qa;&Cdy{pj1g9%!Xwy~YETK7ofurNLoRqYZ3b;G#RTc_iXdcSAnh3n+rYFKVm z$g-z@nQ<17r;mRP#f<#*#JKTICev&3;Xa(^OQf){P#vs3Rn^c*lI+Q{#?OkG!)wX* z^ry7qO<#JSDT!6wc}Mt`+vPog|J=?;B^J|HnGV7?ton4 zm~++Q#{u|K4yTRT Mfube|eeRtI(QbgoqB+2rqT;bdKSzOXa$t`|!Yip5U%bxrb z4MPsux-7e|OS}@Z5p^+S(Kg)CW>uq?2^B~_EYt6zX8z1Bkiosu_o%0+qiquIUqVNn zLvpR`-X)K99Wdo0Khbtmxm~bEJXoAdFy=bKat?CwN4X@bkcYYPsvy3l_d$unwX+Om zr#WYALUWm*1496`)&(vr>0$P|e{Z(cr|6V_3qoxMNGSY&N9~_i-(ocXNlztOjM^Pa zOwcMxNwHSdX|*Iv!bPE~v0240`yOi>lj>VH9GejWUJ>`K7Y2Gvf*!9-{J7t#_i`Mu zK)6ln@_m@fahnDKck4^Q6Fh0CrHG~^79?sCn$C7#I4hi~^c!w}dS0gm!BB#_Gxh;y zq|yj4%if3J>6HbB1Q&og-#9Zh*F4*4vALeK>tfxVYbJZChsI|s-2T}ix;hVNI&&;u z314NNr)y8!;5GYIfLOv*cFIz;$K;Q}FHE!%g@`7q4W*-J(FI!c+2lI_Eb?!dSC{99 zSR1B?k-wT7iI{9{tk~M>>jrOP75dC?U=V|0P){A_XB7mGma}O%w7*$o*zcobyFoVe znAnIGi9acA(4vkh+C?t;fbUt^*@n9X`KQr;Q~g%?F%W2!ymfu*;u>Vm-sIHzVG)in#} zqN9P|m?g3IB&%mGZghZtio>ykl!Gg-s1|5E^_{hvgWqlo(x%S7CEM@u74=dZWYm6O zp?9!P5Xh)_f17nUHKwxd;HUMSY@eRgTCJ$k+eR@WTxHXX7NmEZ-60Rmv@Zuw7kKjY zh!_a9r<%1rkA8Nl%8IX93v4F?^nOz25>5bWQe{FpITtkWWKP0UVKU_%VDV?|x%2PE z415yZ%vq`0x+eg8bGL>(d^YLJx6!=TKSU}Fp0c3v#<*o6m-pL;(0!%Q-|XO%8GWXO z@d`rKTfD<^-)R+!CqS2Q2lcW^mK zBzE9)pC=iO=j=0H0RLHX{z8z^98Kfd4Q^20sfO28^pDHz$4*g}k7l^vSpiEU+eq4% zKYsE_7y`)lD1B)2bQf_EzT=dIH>4?Rlf*Qm{t!Hxmw1&(9|BXBApbH`P0)w;EU)Q{ zyRq+~t|)Z}XM&DH^_%6dK|Yh_RE-m~TImvxzh#AVWkM_~;ACf9&VfGqC#=NX;8Ic_OsXKgsO?4gQ z`d&=r^@w}{*9A(T?6vL#ftDyZwcBR1!NCj|t&yE^_PVYv8-wf;L#L72@7NMGh3*v5 z#d7X8$@2YQiQ#HvV zbe!W8Wq~5Rn4WwMPg42fu0;k(I$2M%GXD^=qyjErMck5wKfIqZF~-^6I&MjcJ`gYK zY#BSar+T%0Di1DeRRvF{nqbtQ{v^TYpIJfig;0D-(bDpV_tPnFXDTMx<8{XM^6XqJ74xCLL_S zG#1ah1TiHO1npMAOVQpW&Jk$u?kYb;nb!9y!H={5y3oL~1iZ?*CM~DatltmOC09S1 z-kf?6Be(|(wktAbHI)UDT<~C>Nl|CrOHC-2zoiWB5@`GJ`ZAZfvH51umquI#~Gg%#q#e0Zv z5#^{4pQBZyh7OjA1J4Fu#5B8V1iTTZ7}rLk13j`c)q zX3n1rbM3CJ`-?rzhq(5nUGv7Qa6LjDL=Jp->{e*KL2x5Bobb7<{nZDvGkYgtk6Vq*#eL^sD8bKL}{cVTTc(~%rXo(RXQ_^eIcr${sr+g#w3 zd4^NGL|R0N`Y%q@%)%ugVa}>X2)C^xqf^~2R@EbshOt?m_cQe<%wxDFp=oW@ye_AM zuDDNct&qtG=8K6xrF@U+9orj(9N<%Jn7h;IeZ&Wm;p8J=EqI9-9tdub^)3^9*=0Ra zIKRoKQ1waI5Rpk>yfK*${+6irrm*NA14TDE5E=Mik39bhZkh&v1h;p<$J81FIxNfq zgyl#_I!0334?()%S(xGKC&5>ywltQ`9cvCSov-+te%yU_UaZ0|MbXyHTC$AtS-Al( zlWl%(R#Wef-mgf#n7Ps>+s(1G(p>AaXrl5NjqDk)=(rlRl@qP8aOwOmN%*Cl>z1(N zMzgZY?1s#(9~T=5ZGB7Kjn>vvbIV!cL6X!VhGw{m9-eY(xIug^{dhj`{X1DNO+@Ed z)kIn8UVTgko}8>RBkyL%!!yY*z^1FNa(MZ+>#)w2b9g&lsx=jM)!l&4Hp zGY?~6$e1F5p~qPB8mh8K@VHS+q3Mrap>-Z-G$ClSbaULNPfQRfte;H4qo9fD8$&E1 z;xP65IswDbu3ly)SoZF$IR=HMIb{CQbXxl*k0#zJ7IICKcesrr<=-`=T`wOERAg7L zPZspv)FX80wR5f+vx~~UD-(rR>}tL>z!xXSXtzzA!FMFO(XCtGAa3;N0d_Qn-&n}p zE%3c@wwBu3N6rb(XF!tisOp;b(*|o4MC%o54u*pjp^moR>=&Ak0)S17x$2g-eQ)%{ zAo!LxJ7e0E=}M$y(BCECG)m$$&QKOQ%O8&uJb};2W&p_s7u|j^sY`G74QW5bkzi5M z%AP?KVvwGW_JJ-7TBl6%>z zIl|-+RcOTogRGESq)^3WM*??6HH+XAIUxs1!U$m?kr+jo)3a12W$|FV%svBic6nQ< zQ@tDPtfo!+Fe;KXc2s)FitaG`#~D@Hl8n^MX7x~jb4(-P5^>2TxZZZTUr8MN8TsW& zhE{-!*k}Jh&>Hyg@7BP7MchBvKr^FJY7{NccPaX2 zs1@>UB+0t)ADBwT-%y6a3Iyna*NoVSW*(1O*u^>par55PhBy$=3PDU*=;bVf7&fTE zWPx3);7qrx2k!HEySA%uAUU=r=^Z-IhFO@>*jzSMT!r;k%YroboRcS{;uJ49K?v;c;3Gl}$jt@43{;6{jeIGBva%3todZETaZjv><(&5VJ{8`YZb(*_b(ntnA zo!jCI)9eRpT#;0rGe~{z(8?54CprgiV7`1j`PrSb%;I1LC;nNu&njiHn-Jo0z;dFP zxzgd}OatrQHop}S@1e^~6d$1Ow>oe7FcJ)p%XpvTdR^_d3EF2SM!wdt7v$8dugv7# zkl6BwPuzsmF9=Vu3@ip5mhf1?cLX^R)gd za;#fL6of5E)e?H`Iu^H0#0$akMBIh2C{iW4v+`F=o_Nd_w$aa7VC_~AxCPl*cQEs} zn`VCG*yR*@dn!q_2xB1`idg6)G;hpLv491`4;oyZcK&hdaR1)mK`OBy7KS;!FVpXq`18tbpk*3r5HFIMNXVwhxyS|2yujrdu%z92ZXx1rX!yVcm`MoeT|{o9Fxjq*>pj< z2O4R1)z@nD%znQ!Plb50k4UfnyL5RJ5#Oh>zp5p~JUS=V;Q105>Uc`wvMRPMzV=Wm zZ5$mUrDD(Ho|Re{_AUIpLbP^ch#qtvV%+xd;i^Ho0f?%`i0Jen36461K^2qGX<5H$$9m5D zc%)hY0w+IPGg}B65TF*_geR;zU3O^17$D>7$m|`B8F<%^wv0CCCUf}oAiaAFrL$)fYR{{PoBwQ(5R8%V{SIinQ9+K#;GUTV@oU%y=?~M;+ z`y3P`(&jJ$RIm*ATbJ*Qecky=5Ll)DU7Y3m7g+zymXWM6BP?9sBB{I3#X*4^lhR`q z>w|J-QhQ+~0(4Pp8&(2R{XOh`=v-_8_cC}F4g_rVF`P#eIldR!ZdT_Tpt9J>XRwB4 z#X^`C&Ek9pT$NqwdO1nf*$6pBx^(RVQI+2Kn`rrj6-cM?!R$zHP%)%v8}thHbfswm z5h&VsGY&X{ALa=;;2TQ4JUb@0WL&9XO2uP7-l5x*0@zG7@Jgukc|KWn)sMe9x-F5Z zv~Q;L5C-5C8#PwVyyOBFx(@_kNxW zvqXr3VY+!kY67(Oek9em<9yle*WgMsKJSg~0rs6Mt_0j(@*QULZ zxVPxg(%CndYfa~sZ;GaX&rDiffP;c3{jN}8iWkQzID`SkfbZ%x#_Cm}i{Ab-rTt8I z-TIKV9$&kzbO-N;Z3Y+TeqGIW8vut^b+G?Jz7HDcMZl&$WdAa9Tdk}ld4CRJ?Lh5-_hT5fElZoeP0b(*1eUkDsdnXh6K?4(YMr%Vbvs%D`OYKRoq1jW zcN{u;zx^s=#tk8Bx#%LBf@UDN5Xt86v(<~nUEER}3aL04g%XRc#6_{+A8%*FmQ{WT zR+q?3D*Hi?=jQKe#B+$6XS;qShqhh#U@(ZvtiWm5w}{=3R(LyyIyZnK$z4BeG90c< zOmPq80{EorsT?m$L!e4Sa9B)NJv$?+1F=zNxB)&yFi;!J*NMa%metCnY-OSxsq*T)^QgZ2o7w7UvuC0LChln1c^4x2WTfhR_88{}7Uj{=Idl$p39AU@r& zB#lUzpy280^oORkwdcdq#U~N42{W!hVGB*l1g&_5ZE9+*5H_m8MtBGgcq^@egqXe5 z>`%jNGzS86eBZZgf?g2W>KvQqI1quBOO*tr6b{p!arSk<4=)W=%aon}bBf#8=3RZZ`b60AfpvmL;!6@@vg-s4} z`EVuPeyz1o&sCWd=Y(dJO>+rv+}>#i}w#G%4x z-f>0Q;V2BBF`Rgl^y2D3X^tDQfKkJ*Lr!j@D7^^p;S(h<@pQI|l$NKM?OQ>fA}UpW ziobw;7AmRA2Rol1@zl7pkv)U2K~JE?wyiX8^ugpa9OmtcG%fb;BuLNa6K5%nMG*E3 zkDPl;Yz>1+82H-(61?#`#t?+}_ap_)b4B{lt5_uM|kzx#t|$iH8BhcPzi(+ zEr=wVB-K-++3<7LSM`{7Yjk2^yQeqTsnqvDM?JYj% zkaHI&-s1r^>G&*6)5yBMWd)fQGpBfYEU#c#g}bXB3cn)c6A1;#0UkehUAPV_SKY; zW8yW9yw_h4wl-)H45jYal&P0O5cv{v;G-<_1`rz9&$ohmxD;-LH8(-f7N1SY|ptTjO8oYBC5XX^xIoEy9S;9!=4Zp7CyF&4<{O zZ4=o^byGQ5diAk?)L6CEIbOrB4$e%@(a0m%JD& zA4`dQUQOLh`8X4&ms%grM_CjVohQa~OPb^A9R7%lZx*+=z8X(qG5Pr&_nB}wI&lKT zkK@=9#j0LL%=-%pzE=8&Fn1kdPTr*C$vURQ^~EN96chtU-$QQpCcXg_AZ`WcDAz`| zzt-}n2S;X&LX+qWurXtbggtq(9|&fk(`40%QKN-pLG2-CNwO}+h% zY5-UA!~fvLZT}9Hynmun zK@N4W24>kBhJ9+`W4LCfX8XCF8vM0j-eFwY6JVN;dt}#}0_R~;NQ=lFoq9(VshcXF zi3K3*@t1WbF}i{!@l6}p zdcNefPyWS^GhS*5JRot0|S9Vhh4<-hqEQd}`0XbIzl)!Bw-@2RV@%EA**!k%LNG>E40XvpYL`~_cW&#`9xsIF3B)93 zviU`3xzbe4g|&y*A>8B1dBx6 z&z{0PH^O+8P*E8o9D=%2jUAk_({oR%ez6l+agSJaOb zr5Y=V8VZAqYxdFfNO`sIjBy3ohO>LOXWKZPR2o!T2C;_EsnW6zDN3F`51Skh*}ezL zpc_Ex2 z))K}L9Dcs!cGY~S>k@v zfeU$e;xEbs0aja0o)}ZGY<7De&u%n6lLoKOXcjfHK*VU()stw=&0;a2wQZ1rUK6!) zA>@EPnn(fdRF>*^T^szsv+w(of14P!rMbMq3j-PyA++1Z799O+;EevHYJW07-JhX; z_X&xtveIzTZ>hH`)IPnzq+m@PrG_K=J#DKWX}!@I;Rf5uysw`;6_L@PHMj%%8vDFJ z6lSg+3;LYHV%7QZG;WZA#u-#gW)?AFeb=?tx1<#9HHH*dtDc@a%Phk-i7Q#8`|nDD~WKtA(sQcR6(L5%`5e(={4B(V@L!g!QXuxLxoe_z9rd z7A9(C4r$+*RbE9cxYDwPMcq*v+D5?5_VvckgU^aMT2S^F+HsLlKebcGwZ-aAqqAH> zvvpGCT!bG9y)F6mq6-7$>j${QT@W$Y3%#>48$FN@?l#Ek#Sf*~z$1yB&c!18gxz(5Uv|K7dhA2%cZ3FsVM1TRA=taqBY zt`43SxlC@``GaPqwMnNWrOZ;5@?vmG&#Y8#OmXiG>XxH^tIsQ4whI0XAh`=HrhL*M zEw%hmCw**$>vBO%rtm^cF-a-#Efh`6-);}oS-s4dNi1%^CbIcB4ko@#WoNZyfBpWvyjHnq|JWYO^a!Zsk-t$wdrG}^nsaW5g=>`p3hUJy z%V0SzI%mb=6VAlXvf%;ok&nxPWVTLAbp(1ypAXXkpQ5gT?0#jOpCdLeY+4P%NFHoj zb%qTI(SCK{pD(eI$Z!hgn-|Q$cyPk|%gV?eKDcwjy>-Xd&V+e1!oLN^au)%T4D}#R-y;GS$Wwq2MRDoqqXQ z7v_akMoR8!Kg?`vGc1}r#qbR)-DcEHTG7*Y3Y531Y@{cxMo3P~rtWJ$({(&E9vIpp zeJOFIk=#@B<$9=Xk!h=S?X4$Da&4xC{17v2@1ZrPSW+G9)gw@#iXXq1CbKt6W?-rf zE|s%3xlkT7m)@jcx`|sCn9Rp(Q`#@E+E270ln^7ZO8$eHK}wG+f9A41kzk)Q)YE(U#(B#6rcMsy-xFW`+jariv5~IX7YUXAacE$hn-^jqm13Re~Jt zYl?RYU)|mB-K#IO!!g;vfoaDAX<;6|k%2dcwbt+6I(yG`Q_{g+B(_NgNhC2x4w(tj zao`uNZ2VA0hlh;2Av8i3oR@1*>9xx;AgaAbfLEB*RV?5?SS1s{N02GBH4v3&pnu6zC9M-62;k102K=z}KTCQIQmcrbcRbDhtV`HPLd)j=XtCxlu?V@!K zKGwJgjYHN?L}=ky6szLodQ_BBBUYBKxBMWz(xT(CUy+PzuBX*9Sp?m41YSMy* z#9{@%gc3-lNsDEY^XKA%yTqg_2N&14YD3DFs+*)$4d;z!aKW!VcnKy{&jNUxidj`L zEc}*P-f}cR=bco=sOn@rZIwRaVg)uqg%T55${BRchrPDWQP0bIO(u>7*UsV@!DMcj zs+0gYRgpy=f#a;fSgT>=-`L&{({~D?vlBQB+YbWruTv_CZL9Y*0EZq3vz{osFT?n| zc%=u*Yq?Rq?-Fttg`NB+UNp(MR00~1}_9@soWMkbh^!S?4)2;hEl z9eFR&F_P#Yc71~vOX`p0nZ{J6`tE|MfF_XOrcCy2R=sXcYo6`8nT1w256f$VCR)?; z9Kx8uhEX@VMzE&7Sawp4gx1iD|Kc>(hTjg=cqyAM49q4u>m~vRa>hilr3PQ!Fou)q(E2=n?_lrK{M%y-n5D;^2IA9Mdo# zquF!#4DwWpn)N}eF7|1rzw)Rmno?eZVm&$6d}_ES_w`xew? z*;b^Ux_&B5yK6~Ij)HU1=L`5}X|LUUD@YsjsO+&Tid$qISgUq;GaZ%j(K&1BvoopP z94oKK1TNAKnHpx*Td6ltIW=Wf7SUX~VabN$2#hTGwW#h~I&psT9$3oK^%N1q?Or3% zB~g@2#LWxxSN!^$j33y-NHPr`bBu?KwRM%_O423tzVan=;eJCVc{WuGAZTk)9V2Gt zib~wvW|gNXKpeX-5_BgJ#It$f)d>P`=2`#?n15D{f_sh4>)$#f{5D?wx#>kUl$O~d z)FYvxOg#DvBgV>DfIS`4wbuGL0izI@F{?Y6Pe7JDF>Lw4oE?27NrM#Dt|np`O_m&9 zn&_Msp{G~A;7ITmd&SfqqVnejTt0A}n8bFj11PPjGeJUM>-fq$M0(8-qCHr<`t%uw z4UjnbeIa{P#pYW%@z8)QHdj}HsiHp4gqiC_q3HtgSDGk(vb7Gpagfa;EDn8VS}r7Dxz!;NGV#EfVP(q zhWo@agE`qTzcoQqs@pGJ?DtL8dDdUyT2U21y$P(5iSc}~M^WsXP~+|ECOt+>;q7aU zdK*mP!|R3ySh${%pKp4ca9gL>4fU`HTf5g$4K`Q-b>lo%v(&HXX$L}$2t5lwajfbT zAAd57h(uxae|LX^(yKy$hrIUQ`cB>cm0B}DwAQvPjlV83z#xhP*W_SE2Et1~?LqC- z%Htk%Kj47sTX5^pEz~@l`C?|+>2!M;_F5F-Vu7)XF4{+G5=WgahRir&IkWT zRAx7qH$=;Q?P+tvTv@{Eq7Lovxq3n;_>WfFFf~#u-KtHgeFl)`ooN)h`o`LseR9aZ zAZ>~Ee-KI@q(Bm;WKZ;Hu=8?_zY9wqg{|Hgai(fQ-wMGGoB97~1r4De+N6mtS=)9*GNM-q-n~j&a*XzpCD0UTx{( zYXT1I?{+)UX$&kBitRs`G6P^gG4vVfu65b?tUysjXT z>+URjH^NUeR20VnRRa(Mqrn5C5{fM-96Q86g@pTIeUoROa4&9LhBXLm4QNt#lWxC; z%_&Jv|C|}vRLe60sJKPP(X!p(`K5N~aF~gNF&t*-NiH0$FziiHclQ#|mhI=x-uf_E zQhup{BMRhkf0Va@aT)5K!>|rPHV$*P8QRU9#LI4j!Rli#-Rvsgi|;LJKf*s0V}~&@ z)Gxg6cIEu^@L?BipgAs`>yq-*C7m$1%1w73*<7BbyI?4?;KB02!MWCivCiBFv8T*g zT;0824o2O!>+{Y0?7ahTyp^SCaB7Du#V^^f*T6MU??-#tbvpE+u48NkRE zM(%IR7BQWe-|53KI`Fxq8g8RP)Jy0|U4j6(V*NhGT^62@I=Ajtz-e!sEg?(eZsRVq#;S7g0=F;^wnHJ2k?t;n66l8{(L2Ff* z9%GJtQ|M0?Gzfdnc3XAqxbe{%mhR`euzz#(Qg*@j!j`9oJ?)q*t?D1eiuGm-O~1OW zj>$cf$X-NSaHSalE3|fw9k$qxKpX5zi(J?7IsDE6R42WdYYJ#>D_rfd6p6EHZ3nwE z=_~IuP>-cVQe-0ouaC2H*XQ#IM7*kq1ol`<}I|799HkHkWR@*|@RKw29r(Qfl~QCQR_v<@x1K?A51t0GObp-WY-U;Wnnic1XETIDw=W zY^61cg*3<(F_CBe2#D(K+OXDAfz`M}KIcc^ING-S^5L&%N`D%_r%TWxNCCaj z_#a+Lxm!9qJD9p#y0KVTI$JtfFuS>1TdIyK16fhKUKny+?TTjBHI{~5CH%nBY}uIs zUI}}$OyfNq)$rub**u@JY)|k*{qetDhIsFSQ|*ofHjrN4j(zsOjffP8jt;~K3zWDB zF={zZ-^+G7)c&Tue%{lRA{C|)>=xW&_pOl)7|Mwgia(AOx{RiXhNkdK28(=K9^>JqyRTH<+v0^o z$7szLaQ-@BPO@eP4xkAO1r3J(9zFiA3H#*EVruRVk_lt7w6L}W&0GT=vwXA0Op`_} zogAaQ3R9g%xbpZk1Km`Wd=nSvf*P31HM*OIV@mdoLKM43RI)oJdQ{}~cpv@kga@W8 zdXl;urUO>8LocHMRn`P2QZ4AJ$pEI3K)DYpO!*k}R9%DIq{66TLsZkR4`6>aT8)qQ z0~^R#cFxTa zEdNzMsyI&zGC_Hiajr3#-N7**QNTWHp)+}cQ-C=ud0~HIcjC2^G+(i}KomAE7s@0CK7p{OE)d(~mnwxrtFl?K!m(IYs$NwOTDzd9BF*4y6}0GDCUL*BwFQ zKf2TDe{d)LKV4aW2Uq{AUQSMFig9XU8sP&xwgCfX88#(0Rq8&@3jN?d-HOW!W*TK` zv00L=lH4%$$8o5?xz7jb$;$|2hAC)JfyUpu+5UAYy19eG7zkTL<8|;~Nim^jy1sjv z2SSP&9M61`l=zuKoGwi-XKc)wyYpxwnuH`Q6_DSqth%0tQ7l_u?KXfbU$mr3X&AEk zxJn4A$ISXgPUqdPL9WBj7w*&Yu{Y@vNUh%IZ}k!}OUXEQkX?bGLHD2S`{evzHckk@ ze_+Fu-r3YzS0{s|FatHZcSHm!GsLx_x=9f8w)+H627c$0Bec0s)c?sc!AVzPI!Y>$ z`PQwoZXvMDcy*IpOfR76ri~ZshKt81%I@z z<$>X-vD4(U$X^4-`|#F06ex4<2LlEM>J|LIPpzY+o13XMXn(N!?+T%v;I$?lrt7<^aKEpojJHd~q;-{upV3wmIz=YCHu#qWe#3xT#__Bqk?^K`l zk)XG^aHrGzV$#`382U2IXU@4P8Lm;Oq(k2L4Nue|wyb+agfCqa)bnq?%y_%y8nXXz z&zS#fxno}#)9vcalhpWQ{F&In^RdwW8~xn?2d&(s3T6fc@s*o5@7oi;+rW1sD5> z;G?(I(3hxXzzwsZ0`d5o3yJN!2MmQgu7shy|8n`YK{!q$%Z~SODkY73!vqFV+Lt$3 z`9W!ARj0u}3iiGlGWqTX)5g91IzJ+eM#uyQZeP-HM@{2*LK67KV(GA6FYO1C=y_-D zlhX`z?LoRABIxPos+BgJ<9%LyleqT6+1>#Fb!l0_;nbdK^#SHreK$CE<8Lprti1=- zBNtx%=(@rt@nV|g9?aWoEwW~hK$!4)ND-9YZYQWDbXPR6EeDNQK3MWXMHgy`ZM|%4 zxM?Q|U2OPzL$NU)!yUGiFya?~eXu8ZZp8unR}uZ| zwX8(E0k)fui7{S%?0`i07}*rZXaLJ4Dl}OH_bgKq>(fWyOJ%`KLYyGSa02+$L3R2X z_`z-NX^d-3N{r8fR@Vr{d~KaU;_Q?ulJwUlXb?($yrXoK5BHafY-EwuyWXBiC$GeJ z6yvaN7#HTb3HrwZ${oWa@Cll`X@y`D0LHK8tX89ZFA3 z<7U!3*(T?07E8-G%txTMV|9zVjh7YQh(-`dzTg69J|jKC7w*Sm++1;T>tDOjb~;}9 z-1_1Bb;3D03s^rxRS7gT&Qviytj<*fPwMRT^-+kJn0>qbQV7PdSFa^oEISj@7-#m7 z{RPQBrNC#?ws$H2KFfE}ZV?b&7$dZC>;$(NcM?JEpOiVd?`EtytFKTro>%K!bFcDY z$7V6Nuc%)nei7mO;iH3GePe*4(`qd)(C^dN*Uba`Ka{-%aNJt@r)|f~9Wy&-X2zJA znHk#5%nUIzvtzasGcz;WF*7q$?9cb!x$~c$`F3`n3;w@k3 z1^D&rEXjgUwtG%4Tba)64yz2=$WkP?`st;)J}NZA^3s#tFtU+`VU5vCz&)}%_`DrPp$e`$(>?G78f&qMW>XNRM1pe?&T zQZt>O5p@*9;Dm8=yCJ4sRb^q%FID~Fv+D~nD#Yd1b7#OUTmcNnmpTxDdRn*IU;zzQp7MPvX#NsW zE%w8~Y4cg3d3FX(h!!Zzfjrf>@q+X6Eog3LC$=Drv+OSTx5Y?0zX=wP;*$t~UZ$pl2B_A8LMGrTg@6e2ZE3^Z={P0D@B%Ww@HQFlp?;{a>89{#K z19@pdtDyLT0eU&kwuc$`g=mDtOaz+e+bq-8FKg&gMZsh#@uv_erv&%IpBteNvDNy$ z!fgZZ)A7aHe2? zuP9*grZyXnm9CTi1q0Y4(f*;1e0C%Z&8Ygxy^s*~Ls7VXRKshCZ4(Ob0S+{}-)N>` zqGE+J4wKOsUKIXN6m(8Hh!p@ks&?Y2po4}aWTShwyiA_{cJyGy<0o@j6;T~Z|r~3l>HA)aqp)4N#FJb>Kw(WoYDM9MTt8W1K$_>Uo>SH z2S?}9oWkqZ_MP%g`R0zZUDOJv621P~&!S*c>w2|h8$8{ZEE{v)+q$OHqw9H_3Qb@+ z@mlhcXm$a=4EOC-SeprzUH;)c*If+QS%rnGUrGJZpPEwc^A)-0?n6`fXsgc3s>Y{c zsn@L?%5x(7N0-uDERqJ_gj}yhI&@!1*aB{qZTa z<@Y}sC8+Y~;crH1{9qJMCH9rS8D;8s#~+Mx_)kUw{>3QVe=|z`;yIb$#`mvrHTn%^ zY)Pe8tNM5mcBC~Veb>`GO29b+kdA+6l&>{^GK%LPjB@)Iqone1Xaj5>AQN;h9Q7)op?G#T=!~bLyT1dGMMrrwrQIP(HQDpzYDE1$W zQuZgKME%7mJbyBZ%D*zo#vhCV{wJg8*(&}gqoDrDD2xBXD98)aebldbv~DBwfz?gB zR0S4NyU5*S$Pt4g*f2||h6z%;;kPJsJ1pCl$+>Ghz3E-&>fiaR^8Zkj?hi!~|65T$ zpIwCm44wW^lp%y~oV@>{C~3yNXl~GfvBD>Z$r7orCA@Cr_%hLO-3xsP5Tk~KA5|a? z?J^Ev++pLxx$&8wux2u~bp;8r;w6dDo@T=Qzw2l2qQ-lAx_wUt^ow5cv<9j8#5~8D z1T}|0Fiwio-ev7=`|A%wT{uENP=~z#-!Mwb{|}@5r6NwTeaI30&_0w8Kdw;{LKbyRx44rV zm^puj4yb4H)Wop`S*}?@2(t4wS(`}duh&scIzyh zo8s!cvkUelt0S(!z&-U~#J&X8qj%;Jo(bXSGbTb?& zcw^@hF-}h(pg+fJemrG~i{iAgbDYY0hijuR>d%QkFmCC=&bbITS!Hm1l{;BKv86-> zxzB)uBrDc+Gs%4UQLzEp+QK;kb&lUERN2yx(JgeWU9sEUXSYDWO3yFiqREl~5pKqWntsjkp)!QzLGo z^8Lm+3B5V&I#_*FxUf04zol>Xc7kWTz=1efq&Z&bDpmC%pW^AlPzTFUg=WSCTTIx1 zBA@9ql0>s)Ih96OXw73P-DQ4D4ArYRKj~=1AWJ8TeH^`_hdB1@993yF!d35dvb-Yd zsAhVT`lhF)hCnz~K%y{XItIZJu{EU7rkt+wk10S-G4enU*q0e5Vtzknh zDt?;2yvV2m?sbyli0B>&^vH1t!&Lh)PXtV8M8g;&;p$z*U)re3gek14ONBqF3CF2# z3l-(iB+nDOD~5)|B1uT+`9mp1q{asjscjLGjv9wu&L9eJW`(kUw}olzxNm>B?@JG> z)$#(uIAZI1bUY4z9Rnfg^dOaX4S2T=zPqWnh48=h5?WGQjE*wn?_*z^Y6!^tvG$WW zYw5gSK2t_$%OlV3l$yJ5QP6g%&Xs^U$d#^&#@8!+W1M;AXRp@2n@uR4J$ES0_a?UA zQ}}Xtvlxp?@5^vs$oq1Zx|bNws4YJ^uF$!`p0w|U5H+#j6_-z>K^TlN4=RG^P4wMY z+KU^Ws0kauOYtL`Q3P08TFt_pn87J#yqy8kzx_ObT#!@pf+2_qcQ?^h_vbh~u{otc zB91BUa2BZ%*wXhv4|3r^ptav}N2w`=rg?AYZ3sZwax>m@WJI8WW@Qvg&mJ^7X)5&i16BYsWc6qLks`HsJQ4Gnevd;&NR6YM!)JaWr|A**I#7jY;! zMazK0xEkg~J2l~fO`@t3K@6$^5teP`QE}yU=5LPleXQ-lS zXrWxYkb>U6jZUi2L=r~sS2mix603zNk&bv(v&tZ_rhZ58PhB@)&q>a*Bgjd8m>G2Wb}l=_&}Ih> zMtH(|YYb1Q(Sq~~OodmX4zO|73D_r+MFE+6+#@cyb^=;xhx*DVlvSt zXPR%$9UN6jLLoYGy;#$=dWG{K0*`(iR^db@M5={^WisbFTIY)#@p$~duR%qR0X#A( zP~)?q1t?6#G}qbvveS^Wq*o2zbPu)R5cd=#J1b!0reJnN=Oe)S2uTfccH@{?CNkGt zm4KU1K&xJfl77MJBoPh!s{9SnZKK2@eytN0V*6>m7|4+ByE)b@tWY@1$oCB&PCkAH z${Px$(&G8O9NWhF_2RQygBj>x!y_UOZh?&-kjO)yGX{U#5fHBnMYta49I!dprG5P! zks9j1^*th=Pl^xpJ<&3VOMu#g`qP+7>Akc4#&Cy*-M5gJo8)#4_?-*^VhHgeGexBS zY^gdnFO*K8Vl7Nc^uaA;uP#hxX2vHuKApsgv0->#ly+BB$SwFR$B&|W2S^=#hWPf- zRE;Vo0ZkQ>n{Cd+zxjn3A7a$TF6a58c~vJpuBBe@8Qm8=PucXp{R+0#)gctqxfu~W zwVizFjz0as#8p_-_;H* zU?oahe3B~gnIfSTVVp>)e^?ByN8@?&2&td#Tq0jzkqyv{`2TXq&mGQxwULo8s9NK` zHS4m$*VW3KSAldi4B>(ojwhG1Aa?WPe?BuQ!r@E8wnR^V3+|UNdonFidWOInGzkGH zx~C{FXXw~BRh@%^7oynR(lAJ{Q%HCN0NyK^>F}Zqgv3A*C3aT+v{%RRKyD;e4F#{T z^XdKJJ}S{;`8`yRT!B=X0%AzO+@0x#d!7DZx@?nD|Fxi(G%+eup@uxAQ{SvM{ zsbUy@^3h_f_$>|GFZ}W1#X3V1X828K(L^Mc0(tI1BkpwZ=ol zvI&6H6oU13!|yt7Kx0Rz$bQ{)}j`w;tj}7SfqJF!X~|X^{5pX zzz_HVka}*O#i!6Vw^PVZNv$mxmhuX-Mo?_RdgA2>M>+xi;}BM%gAxGay^r$+>3|n(cMV3erj3XLf0nN>P~qfJoQ7C%5V^^w3%LERC>@3Zr&e{ zIZlbKIQCi2U9oPA>2~X91HzT%W1yz#VH$>Ou)ml z#)RU_JcKzBl2JpslT^Ttnuu%+h!qhJJeBL1`)i}-|WF& zJdAtilX!#P&|__PQV!<)NVryW^IRKw7I{$4fEs8hFNwH7V+E;-G5;CTh5%w=DN=qq zd;6lfW6LM8G|g~aUSAo0(yX-jX5IpZjEbkbuq*QBkyYGPoo}9kna1-za7)fSy5)Rx zf8$&$%Iy(3BJyIav~przfxuhZqYks8bw?_)qT@(ceLNCGIochPaX1jtI#M~Ua?wQP9V6`1g$EAO!ac2sS8?`b7)43UzY%$tVQ+)<79bfn`aSX4Tlxl z`f>i&AbapsIZwYm(t?%rAaHaWaSkUp2PAu>g%V4>J{MnkE-0OYm_-aq_!j%kfiAGv zeGWW<=7>bhJ9^$HiH&PGzHzVGlZsNwr(Kfj$yNDT^(2U*(iIyN@>i@Q|1IWTdyBoI>F(=j!yfs-lgtZAIv5-C% zTnv^UHAQc=!@iOG^8*|r@+90F$6gg|kp&8Y%;b%!v8PvTb^aEtre~n3vOH(*Z^O}T zQZ~L@j8%Xylgz3w5w@Y&tP-Aoz zDeCWpyWR?_54#Tac$`%jxz>v(^vH8)V#T#J+ajceyp(Ec>+fr+!^6r%sFT1;E*zRhr)anG{JOG&R4V4M9!)OnglzsUggD8=uO+K zi5@RmSV8iv(A?W42#+5VbhCJLPnJHewl4tzZ6wE5b;mO+zaA_$`8`IWkqBV|`R5|0 z8Y@~#9>BL{+^W+T=PsLsyopGhO8P9kK|Uhq(z){1SUS!u3S&E%u3F2q$%ULwS_b2C zOh#S?GaE9DJ?F{iEOcG_P!vdW%Dh*=)=jED^SCFKWDq;HyF^gyu%4j8RLCk34i9+D zFSA9k@yp(d3c!gWK+x24fbGQZdsZVJ$S$ra5VS1JM%VZk+B{0`J@JZo3ACy&U_vIh zBO+DL68f$LKcqB~w|KUet;LAN9PcaEmg0;kS!q(}Rcl+Q>Q8^m^5>eJ$*3g{0h`W@ z%jXfPVQZ_3P!PTO9m3{xl+~jr!+whVK#OAFv$c@B~m0b!!_2i*v zX6A8m1YZ@>oU2k|3HWqX5UtU8sw7tA?R@s+30_={cVtF!qkM&bH-sC9Snw>YX0N#Y z^d{iFb>YIJr?bzBof7xaPb0__Ph3@y(p{}d z3z1SK*1AqnIYxRQp-PT>iJUx9L@Up4HN}?Otb}F1Wp^17HE1cJDs-){aX1CvTiWM! zOv~G2k%9LR)@!Xg`ueL&6UNfDR3h~U&SmqPWaH?J5dKbK}V^-1Z*DrA!UZJS~pDym*VmX&$r{!DM~;Ie_-~jwlZSs zQEXV81^pWGq#xf`x?3QSDs;wp+nqch&kuI{0t7jbPt&NZr7A)uF!3VOE+PPBjZ`9Y zd)1(D{XYNs4S%{h$!=0cAm_T(%aGLbpr^O{@OIJbcCaK{^i75-e3n-0t~sK+B+Yh+ zs2&DM16!$5orD6Z)!1CmUeniE3*jovhwxag`RH0kGgtlP2TF9O2*>Poz`I2~m&1rgnL!iZ*_6%5umuA#m}x-4c#9|>$CArVy~NaT_oW!G z)v;D_k!7K@O)Nq=1_tviHDAbK5LYUj@ZKZ3KcfXGx+BH+Dm)CL4wfWZ_``L!;Y1TL zlIJOmNATDoh{P++JO*GaYiioseVcjy18~?f5NR0mwCeR+epiSG3q88SlRRgf2zhc{ zG4k*Wkx~mb#p0+5cJU?Z20>8n9q&f8(9vPreo4?pnB6VmuP<4b`xj+=L>Vrf!jRlN zZ}3c=C#}?O?!wiggRhD@thk@)-?H?#4r8)}m%I;r*`%vPI`(m7X)8QWZnk3yo6 z6i=-3a;@-9GJHvotDF+BSXp?^J`2#(Bs;04cSgSNOW=Oig`g2x)J{QGXbq+$wJ4B2 zlGoE4mPL)1L3cg&szJFB6QsDBYGaCZTZ3I3){LfaslN_qQyG^5pL)JLhl<7QJw5uw zSrGC4TwBp=V36Dwe%WDOzHs41UK|-ETI({;sqooh)$!$X>vZFQQV#tuw+q^hD;o+P zl`O2XZ&=1OoQ0&KeuxBi^g!Mz3++MAx{A51r^jr!2g`6eQf?C|2@zLYVtiHo$M;jLGeaCoehJ=sp3TcVzzJ43`H&H2Bf1ncZMwPG&o ztz{%CzHFX)>P52h`xWkA`y;#SqScc;BENG;sVdoj^HVNl47DP^2@fRetx4A zL-WaUkn{2UM`i7AK}}aSX-!tTybQ=I?>QFs^`lb}GoX|Y(KmSE{bk(IFuKH>h95R6 zo?OvZU$exnLd*J)){~Et0*=LPJ5YWhZ5-h8-hKT(B(K3l+2Q#SVK{l$Z}+zpigg`(rRZE3G=Jo&i`Eb_+`Kws*-@Xd}X@mGr8v!L_6GLaS|I*(7*#70F z<@jH0k^kB5-?m0}cK^j5?LX}ufd&r$ZI_Q3$A6sO-(6T3xETCD^oBzww z+T79Tzclsq>+sJVp#S`Dt#~WUO?7nb`f|y!h8BILD032J)i@Pl7-cO)V2( zJFBgIVci2|AsaZ1a54z@)Re#r3?x+crd1=M^8z6laiceXH9wYiFx?+>y-0g{^zwva z80ZQK$4f?(N+~kSv+YJ>H*b9=s`d*`;+Jh|{;AkRf0yJ>(qY zop*FnZ^IX)i=|@FfECday->M#wmV)mD|!YUcU;a&Jr=mxaE6}M6`=lBU=Yn*JJpb- z`s+TNz%2i^D7@AGtXXRLwI2N8fZP!69X!TL1}Y6_W0h^Q?_5y#z2NyCOCB=G zS13*LDxH2I%2N*pl=mXq2gfjyvZ^ctDmhpS^XZ|>Yn62zegxV8(oMSE^Evw2s}Nr~ z+|}KQ`E2?M&Sq^F`SBIYj{R~Q!mOo<~l)hRe;!ClQ!>CY`+ z3k$~y@%D9DVtb+868I8_?EybHBUG1S>xdmyqie?)r)Tec@jSse zov2buZ4AVQ^lC7t(yqgcge+jNDu!BbqM;nJjuMV6F{h1?fn6hQkCA-#pAo?7Og*E= zw@Z8fd9A0bRMApZH;FP5_tQg(GY1~!p|fR6c()_(9`f9~X5ZNvB?`|8y1(9|nF`0K z-`%QwvZ1(me1?VJAkbH)!204&-TZV4M%|8#CcnE7s`Xc^3NgC69r&0TnW!%-0PG77 zBypsDI7&c4tTApNs!_V3$CFbouFG*7+0)fk`8hX+B=BumjEPif*#_5LFCCU zl!4;Q$gAcGX6nw#Zn%LId(r-9$U_n>Cverw>^I*U!A(1pe2y zeTlSZCauJIh^H^FDg zB*D>xveGMsdiL-~Q&a-7Uu4jPsq>=OBzWSuzuz}qg0<)et1B!cD6;=@3Y_CW7Kdh| zd4zZcRsU&>kjc(0(^XXCbm4um?zrB3v35o8>-_-c$Ehu6fN4t_*Yyi^oYQ<_bk7S` zf@bJ2AmSSp-SC)+c~#+$u$oA8<2n+!>Y<*9h(-uuG5x|8OWq%nGNWsh)*jY_YZ|EX z7Hii2L)Hlfvo0FVQ~=B6oL|=dJ1V1h>1Xl3ek^A=k2;^R5&o20p5WEe@3Lyfi$T*; zt+k|9eiQ$q>!Lka4lRA$I6nX0eb5M=Z+b!p6H*p!S?zi;e|j%dzOXxy`UV?R)k*V) zR&>S1p3Iw_U%mfJb+u!oKK<19b_4ff(dDeAF}0I47O0*jnkzniWA%07+tL;Gr{U-` zoiiKT(blk0ACk^hc+^{kkQ!qdi`seX#j}%WtK+`w=kenxG<;;`F^RAc-1TV&e+dLg zSnP<@d4_-;Y*RbUUYN*uzQZ3#^s(n(m1|@yhlJFAR%}s8BV25!hcHII7xMsDY!jJ6 z^;!h{!|_&_E2G=ZTk!@R@t0HvYggVNko!&)+g0oDN@=2wP1pNSL#%~0cx zy(f3PC)tklc5HD!VfoUJ!l2E0$KRv6?&p1x%wa?P68XzpI8v|yYESDNrcIW6`(V(V zJS?jZ@I=z9Jft7XDwuPP1#8UFgD8jyj9yCU%f7asB|QJA{?5I-6Y)08EBu0#ou5VK z7Ghl7Jm?AwGZ6wMhdufE1uJmI#3Ss2@FNU%>??O+#4MN@aHA`O@Kp|Z@UWBaHK-2- z=rl|oMmcGGiD|S!e5J4@mP75}H@A$BtWCB+@t|HLp70{7I_iY9Y&1rJkzX*qs#Jkl zFbxKe>V2}v6B*Io>FXP}NJ>(2^i)RNkMXVGSg%0rc*AIAvjou)-MoP}+Oh2pBGE4H z!WG6uTQu1BD|IB>k05UCc}#ZwZ9ejAIPKn)$j%-rtVw<(+fB!Hzqai%#bg;;yoPuc zs^(KA8sm_w5`*26Gufv+K^0%{aI4r@>)lUV25*gHaTZ{d%dC9UT*_Wu=4+eaYnwOL z42}JKe1#3PF0S8x?;)v-PmeBQ!(}`3x8R4|=Q2q?bRG@Xy~ZOIbEcNoWeUv?oiii9 zgxw*jMA7RNceG}jW?;P`1i=T}l|)N~q=J|K-dX*!MCg{%>i8z6^89Zl!LWlt&8t3A zG>VG;2f|64xS9L|;m$nW^_4}gedkYn(uR$Z$^1e5?Fb}7h*w?x0H44^NXWLJg?nS+ z31g)VnFIi!&29V;w*0$n0iV%G1prqd0y@8(oflu!ZRecT)O1`GuFE|x#*LW*Z}wh@ zzrH_H>QtAvwyYPImmfQKvb#U^Oq+q^e(f;!Cwhz?en5Z3c@+Wg zOPG=Aq&k_*L`k@k@uuDy&wP`xC4-ShP9tIb$$ZpXNT1*%{md+3%H%i9PZpR8Z^{%j zEKk;(3U9_F2*SeVU`>*sK!!WM$SAFt8d=}vglpD)l{#V^05dDiG5v{|VJ#>@n&VfH zQjY#YL#+sG_Ow=b{ z;m=(hD|;e8%$Flo$SNATxNaFr4Qhgds|@mrq>~w&lUI_O`7E%WzLE8MEutEdrs7kV6)dHt11m0coXKO7Z@}wdz{I%ZF_K}-G~K+^NJ0B zj%J-)qayMjZrio+ny3tmpqZF_lf2 ziI^Hu(b=tVDx!5#9d}BeZvq&i;C;)K${aS4b(L_aDlVJTVdA0$6Zo!zs^m&7R=Sd; zp~SbLl5~)%CrW$9;_W_4rISEarXE)?w^QbjOc)eJ>73#*Kvc)>l&nf()HZN z--xI#Tq2}xf#0;Yke=2-#R5_UuvhC~ZW`|Bmf6fhYx#V8JH}I^;9gZQ6_as3SWh`Q zB0EVV?OMpJmztE7@=*rNlv>Wwc<(z@eWla~N|H zca4(cOuc5b!j1tVy2_~IjiTdY`dMn+C{by1GgbmKmhHf;m6)hU6PLnXmhU_X`(AwT zt%(K}@z7ghYp|1hBlk|EZHX_QFjnyLk~7aMEX@tUrF4g+CTSfG%@hl&F!9Qn*w^~S zhf6pXL$V;jZ$d#_27)~jg7WmoxJxUfZS4}pwGYK>DJZGzrYn!+O;fQlPsSBATln5P zP_GBEYh9tQ>i0ycwxQY9Zl5&`!^U*)K(nnWk<;8XImI;g7?hYf^eqlw&CmVvn_?8^ z_%WoUx*F-KekJP`5+DOtk1c1eagAzrCx`^a0OxJl-+F1|V5pN8k`8fuSu9djk*24r zDV*3nqR#CQ~>_J_|W{a(~cRi+@x*E}QD)-hsY|!8e=XX9)_9%RIIY=b?=}$eu;W6VnTyRcxeGx?o|b8N zO_VSzJ;C4}K0GR|Yv7PPOpx{(K5Qwyu78a|=4*0|p5U6+HnntW|hl23gOZJ>H30_xJB zLnI5SA}2RziI_zNnH$(IcEyOoXVWkA7=)G+WJ@XhDMw3{CldGTl72ri3uLwl*w?|h zToUpdd5aY!sES8ae3N@j*QM~Kgz#H&l6b+m%G(RuV0QP@UYb{yjVli17q-TE1)R3Y za+go8#GBewYU!66)O?|nT3esb-(oMqM@uWdI8zTO0I&wiDCn#0EFDd9>D8}D#AYao z>|$;2iLx7d1~0?W`1Ue*VW9wA!K*mxTaJ$bNm)O8Qna}Tcd5zrn4cg!E{hVrzs?1P zrBn|cxj1I{3J%@y?U#Gk_*e@255%P$Zz*TQ3Cl(OU`lE2tCg3E#9Ci1s6^c8kuVqs z)z;Qjlr);_tAkHwN>Y`Z(=s;HoWT{8->q=jQv^xirnAS=f)n(cGb?v-pLuQN9DF1( z#KRbNsRI*l8-g7C%;IWI-OZf$EjK8Fp~qKy;Z?-=dAgfcqFW}>qf8r|H3k`{vLlcU zY(bFM0Ba?2$WJDs^n1J@y_6>;7e*^QB~Bg;AdyQ_pkiI)eO! zIYJOpWbm9)yA+)Tuw_^mKdR$Xs(AuPKASaBl5|N|s@75x`CnotAV~zJ@GMnJQI?=dp(SI*4&+G?$}aNuO3gWvXi1(WZY5TEib8t^8O;;u8fI|S zwHn7(3tUi3ask4{{SUAlLEv&-`fifb3zF1DP9PGGX4!J^*+Jew7L>X{gS0A5R3wDce96mt zDefEmw@rfu$S`i#=P9Ur9i zwUOZ&!qh!x-Dsn;x!?UAfPHlF!^7VM=JfdRj0x(#?*;M>_Vjr71QzM^`1C{){`7eJ zzx`TbSB12a!~d zh-K5T_|ksZnIKXWQ96NA29$WeleYw#&?mbbUcsvhxN(aZVLjC_JGoUrjeVUqofwme zh9}nNLy>>}Knbv;qK26>^Vnjed%GK@t&sX9y2ncunDIdATga3>;zUKNOtD5~?_<kQ+ z`iwJXIYxprCSeMRDGkO9hOiI990+g9%^Zkeioz@eZ%WH7gkTE8+zbCbF>MP{scQ^6 zaM;kauv=Q+G_f1r#I&xPgo$}TpNlEMkU?QAk`>d~G;^X0X)KaGl|EI1HPtmWO`oBf zDZ!Lsl8Jd*KU<${O&@=*r$4y{h3m5RM~wBU?8x{W+b}@A8t(Q1=9V3t4ChlnAA;r$ zYJq!;ZRSFz0SnS>y3zOZIegFAI-oOdh)+Gh7ykQ!W&2#51nD3U=fim4qrRB|uT5R7Iw%US_TcMXOB@7IRanpvis`OTbY4)Y zyS|M$a8zm|nI+a=LhX^csWhWaP-SdRj;vj_)S#`)H}qCzrfgd7(RdZKLB1=$!ER7q^gN6}T_#+^ylOom`>1w==q390 zRFA~i2|QsHT~n6{b~EJVi>NbvR8B4r6UYFDP7~o931dWJ@cv8?@0rM_CyVe;B?-yX ziR|++W@ z7>O-qMW}mkp|yC#KClg<__V_M=c9zd;yvRtSu1stjf>Wzhuwl;(HeS{isUI9oXQaM z!D0{YT0gO?pc*d=4R>DU8v5`jAHzUzL$(4X%QtIZHAOBPf6(1)@0}#PI)Uh7!0@Rn ze8lw~7V4m+5!KI{CQ$9WA6@G)h9yT=+yu*(N-n{@;hXCuXuDx41|>Z}^kk5hE#6jzqjkVCjzGOYssp*SLFKk2IsD5vy_ctaA}v`Q zGlreqQAw<>QTP&Ohrhi+x%F-A3Mttsr`m+?W&z4^A}v08c<3`h>o3b*6EfEiI*Rc?o;{S4qjuZD?=R2f(F2v^ZG{RiJ{)1b8K!z=`aX2cRw+yb?n|>I*PjU`jSPWFaOu%90W24XvpckSsj~38?c2w+0B{ z2u_7S3V1TI)O93!QE7cCbOI7XFN+7Th2$0i>VAS-;|fTT0#O2Tvk(y~i8W|{_E#j! zPLX}CgAZU!%9SAoA_gQ&Ox1jBhe4pt&LyqKtiugRmYOm}uG0XwW)m1C2Rg!N3IOU- zK2AYmO7vs9U;tZ8F52fh!+?DvARP3vV1Oz%_}Sjn)N}D+OjWYKs_4`Rj3%i-YkIEA z=Q@i3RiUY5Z~;$JmOA5rh2s8PT4LZLavd7DHK~A>$W#?M&=Pui`3uk&8le(RK+2pE z$PTE(fmx;nw+0hf5udUl1vaA8$p}p8A|P0Ukj9j2(YUWlOq~+}ACT)_pqJ4D8j^C? zxXP*OH zVsm+Arw~8akwY&hfLCVcvVIsS0fB4KnvLjzE{VB##K1{F9SZoFM!-F;fTw?M7JR_H zCJ^`&{H*1}AU!vW5LgYU`wFO2gIWHtA^+I=u^Jk}7M6Qw%Ludu)O7;t8ljh0z|Zgk z?&$U;+&@cj#L1EtRQa~%Qnat!#{2Kd>*$7p?AuJqhWAS3VqW|-2VZ8#RzCnyYGnDiMp?z2^k&57L*ChRWW=8c55Gi;L)`cV|EM7yd_#nyV4R2A z4E*elNoi_i85d*Sud<}UVIQ9wla`N}0*z6HPU@DU9u)HpmWR0P($37FA#BiLbcDq8Xg@LBV3Tcic`lEYhvoC8tL3UyUzY;KHa)9p!$MqH zqyxIj%hV03DYq+R3u!6zk9SLG(QR>>y9oKX{qEn&U|h7ytm9RG`(g+h<)P6YGS}sj z0|jzI_4>?V{h5Kt)rQpe=tg}fO9E~FS$$d@(rw?&w|U0^7e?WafYClN0l1gwNozG6 z8}2n<1F`RJ#mhvKzE?0Gkq3Uhpw|5#US))EE%?`(63*yXPgP%CgFQ7W#>W0wW$&B_3z?U-r(5*CT{;uHdFU8XEDEf zQ)+q)FWWZ*%oe`y{vb-r94S}cZxdW z={dm5(@D3f>xDC`ROq-rs|oOoxACTNL`&l$SsSaRQh4%*oWdZcL31*}m`ZZ*j=tF? zNkbOn!o%$XD3W>&f^k7D_r$N$6n;oV`v)>XWG5PJrQ#yd4=X>`j`=n2DnClg238k= z^_q~04sT+(6FerDW6*N=((vweYJW#Xgo~hnjWi%@xVdY&8!*?)c`T}|l#^^5@5^~( zfzrmS6?N^>47+NmnAeK#Zh3v&V3P-{ATWt$9t@f9MQ~!A?~StGA47j~BXt}aYBt`* zni7}@pkpG4-^IP&Yi1Ci2>o0G{e1+&_%PUbNl~2~qZ_h0HQ*<1g9Q6&Jer-LE&{oU zN^Ga^A#1K8@bQKE4e}#ZTF2@`q+WMU^pBZGw^}eF@2aN$lZcFTZTsIvPmX6rFE`E@ z?^e6d1RdVA8!$R;Wh-o@3k}qZi){A`MaV9KtAtGwCyU#pJz= zl80n!3Kdl$)O*+z@s^ZyivmS${;T_G;R8gn-M}s&p3qm{M1IWnsm>5R(3y1P~vy#TpLs*IlD>X_oeI=2>g7Bo4n(~ zsd|X)JgJx48Xv^H*z#vL6d4db)hwIr=u<3xU@OfT<46v!Gf%8 zzbsi(9SR+XLwaUI$7q-j&|hqMs_`w$C9f3PwU&!*oEOq^N4?pFQ~x4on8)*t^g5oRkPw3#Dnn3mq`$qIOxe& zOVa$=Tayayt@qV#hc&amNfdjrYJfFuL_E5pD2g+ka0vvUXd*Pc z4323IVpATY8|~O|NQqiM`PkpE9umFuqyCLE6z+2bL|9DbI@Uz>Xp!mhDCz zt-nTw#J5bDxfAFY*q#pT?RnNInRb}xa`s-p9Xjl5RM77QkP5sr64@ z?9|dqvAttM)`YmLX*uCtg9*L-1#x?wfnuXzT?>Lo*+as)BcapA@6M_A1g8t4wN{A- z{F(L?CtozdhxYVy+LXcay*sF57l}W!tVU+qP}nwr$(i_RQ?Y z&g@2<$bUCZ+=zRSZ{~g8frbYaDuA-|-rB-vqq%QKKAU_Z0TKTzx0j`vM)emHD&YmD z)eJu{0!wc+xqjXB9fV;Fd4*EuYc|~NZdJy(*p#N z0IztoJEr1N!S6eSc=_F&pZ}-A8Bo{AE<*R~*Z4o)*8lCX`_C4w|7@Ybbyp|#0k2B{iDQ=)Lt~uWrd5R#adlc zwK`|2j&z@z+;mpqPwa6Wp*A>Shl1g1;}wOiCr}&t)hMn<1NNXg87tUoHtr>2sB5*H=t1`PYpx98GQoDTT zu06qq{C~0tl-Go)JX5J&oknzKgBcS(b~DhFtuG4{_>r*#1}iZv_B z&s<;K0$n@54_hc+n#Z^2*6g3F$F~dap@45tUa6nn{CXv*e8k(7KxLKgNRqszdvXw8 z6U+GvHg_mqIFGssZ(Y;-Q}kTsJt&m8|K>+BhaDD}!6hbZIGJ%XZgt>95OlAt1}yf;chP;d_)4=MLb9S^DS3LF-H0FLsUsj zk+(teR|JlLN<^X{-zBOI>{SGwfK*0Quf9ctu2FVF0~tx29BU{}IxN9JH9=?4f4~eh zT~uCKN>N>zp{ugGg*@%DvtJy_HZH25vgm|;H!;*IauxTmQE=&Fu{BpwDP!+h)H+GC za>knY!`zO#w5Ys~sOn1vNHDZFmRSqemecVTc~Zn>j1W+l@ScK}bG9*0Dv1^t{JcCW zs*ns(PFAJIQ&hhhvN8PfhUR@DrG$M~XPK~|qUJSzLL0q{4KH6GCrY3`uamO-$rC67 z2o&uJ6d?%|#R(KG=FXSq&Y$MaV`dulo>KOS9E#$rDd;Hh`wNJ6>anfzv;oGDV_dC5 z_Tdsu`>ntYL}l7S1Wqo)E#z#3mJDKAN}cRUmjm5-n^?EsrE5}_X_>m4w4u6UV#0vs zG^P}dV2je)iYJw%unI&_!sr2U(a${jKzntPspor(K*~S<$EQ zYq8TPTT#kZ(bD!hr-iLuBZku+9L@QTNw+P8xO@pqt2ja0U)-6*7GgSyunE5YnzJko(CwMjYFN)-YD1%r-_w_m#n17Od01vyB#tRc zdcwDLHuoN)D$IBD>U4f`{SDm4x>gjyd)m?;P_AJ2eg8OrelLko?G`9P(n3a`Ylu<7 zRx5kIFKwrc##vfkN+#qK4(ye-&0LNs!>jrOA$RsJ*TX2@t8vhSv@76RE9+M;~kF zbfcw~f0cxIx#xnYF$IH99t`Gi1JOF)t$?g74rcYL>ZjM=rK_Qc(a~B!>?j=WSX3g= z(nGPVQtcvdUcL}G*^tMOdS{CR#}Dw+JKgo&$DsT)fan2j+fBKj!2NXa0Sm}J<~m-U ztR}S0)YZ6gbq#El-BaUw_3%jwkkLQDvm(a18G$-7nUh+h?SHf$gwA&%={BI%L)E&W zt*UxTEIEVsVeJ|2W8d9;6FrQQF*t)~Lj&qb);rl! z%pz~-gHIOFhxV5?O573LRqbBtYhir67%(lIkb=va%A&B6o?M zL*-^)ZYbVX($U4pkg>6j4agExYR%f&>m3D_*pldBC!O$Ql(3DKwy3A%xhG zz$-y=phv&jb$!r*U&e8)j6HV{_j{S$pVDW>^J4#L2sl!#MsobrwFo7bX-(e=VY9Bb z0EaFuUaz&Z=-TNc*iE7Q6oBvz<-gqZd?h(;bd;o4_$cQ&stXCKwr|l->Kl?F_pa3C(W?*c*$a1rY2`!GD83afbS#AvH9ZJ9TfQJ&(Y9@yTu;C@S4X^h zC9&c`t(tdasGAwtnd>$WQ=IhryJX0n_X$o{Xi-sA*CktEB@$_}JTucN|7NF0CM|h6 zg|;9L+Qis2Jt5BVAymUk#Qg}vXrJkPxLtNSGg(A=CL>A144w)dy{N$I-+84$fkaA8 z&d*KV5Gy(mmUpRz36 z79Rm?BufdE>DyW}O-1bpErDc@tz(D84CAoSAO(CJTGfgV>(PR9!nw+%DqwT21feC{ zh6YLnrHoWcCNGqm+$#yJ3+xPft`W3z1$McHS(WCzwnpv68VA$`yQ3Zmkje6;h7BDB zX%^(Y?ZgcBWF3N7QXec%9zYtOF~s*q7R2?|Trt85@t+o-=3qQ>J3p7CG*PMzo>py5 zOr0n#vnmzDPh9FQfSZvm(Wj0usIC3gj5X+N=feQLNd1WhYp^cXYhBUhve;1shktMz zm{3Cu$Ih7{qm4c%K{es?910W7vB5#&Vn4P?3-?`lzEQabKEM3$Ju`&eKg*{ zVk^#_08QIYN0I6^uLliGI~Oa8mPb7@Bp|V`A@b~@suoM*lsL+=<7B>#4GT$mMqRM+NVa6-%m``@m{===mugb#VqJPl zkUIP1ImpaBZu?ipD@ou)X`dNmt+X~0voX~@MYGREobQtQq6!%THvD*53N(~K$It$3 zKEBf-iL;p!6tQY^VY=!d{3Azp_3Ch=5RDGfdK zQ+}-B`h_h;Ze8oC?qrc!O^-l#1J+lP>bpX__U_&Cp}V6+C%$i1L-D#{g@f`+AqM(e zgyhz`g%ZLj%tr-lKo;>qaA`u^jCydwSaqq8h?D+|A932>HKp(zei8uNqcJ=>e5CVV zy4eJ06WK{uAdgskpjqB<`!|BI_PrSK6`EHZ5q8>Pdi=mYyf>-gi8+FL)*&a$@>B8lXHJDGkC|A%sU4^6(G;wl}`r>n_4ekh!czgx@c_ z-h}*;oAtthyaJ*ekN}!M0iISup!NWqd?F;z-*tWHYr?U92ezg!2ZZG98GrUVp%&2v z+vhT2v-Cs#Q>}>Lg?&mzT*=AU{Fg!7@k}wz7&d#c4EA7$`c64X=H?iY2kb#H{7NxIENs{-gj{6e zSeOn)B^|WQfTu#89aV1@)z4-T_0M^H1HC=SZ(=qmZTX+t$~iKdJcl0VvwTi*Eo{y& zyeg6y6MBMG5Dmp?vGOcRTQ8awbhI{HYEC2;)fl508TtSlSO-+#;HWHoy1ZQqQ>lPq z&<5IGYj4%r)_$pDRYE=+Mw4-bIZ=A;*VGEUMG%7D;y+lwWq~4$MT>xG0Xm#(M5r)G zTkK|Wm3HMazS@A)&MvqTFk7)&TBNdxFgJr4gxjJ-WPtwEkikGsO2#T=3xqvW%?#c~ z5cvZg=_;gY<;PQDCFkCZy2^$J5p5olGA(ONUY!`X;F?FoCXh4SpeGL|3vjE}0|wa& zKoH#7|3W-DUjhAsVDJ0&Y5v#WtZ~s(o>In4;1F_0|D0 z1npF)T;7bD2>e_hxAN~;E%uWuT={+uAqL%0kp={QE3#*G2>9wRwO({LyypImTDa|? ztXsazVCGxG%%G4|*bj9~+$bDB%@q^QRdoC`0 z(h>V@3bsJHfAGKmem`PL9-uvf)EInOG60*hqHX`Pc_4t>t6|e6e|JNJiB&^;y24SE zO}w13i?1xR$}icDVCX8oH^hGH4V;SuiJ>3~bGxCsuhQNGEGx($t`dUL0P z>U)q5Fx42e5#VV#{=K;?ETa@^RJduOJcjM8UO;JVILb#9%;Euu(B>h-(BDG=uX$;L zIc8Utu^{aG^`)>6IBkL>6AKH;RZB-D<%KVkVHgj)u1?^Vbcz!7v=N32NA^DE1Ha;t zgl&8g4Yh9B!sUk35hxdCCXvF%sf`6;gi1ENFs(A>x8(iE^TVFOk3gPFfxIQjm^R7h zWvMS&13XeP5%h_@dBNCVwT0S4JMXh-j*6La=KvD#!N9S7#WvoNT^E^8m3#(u`Sax7 z@OURQ)MEm4ConhrIX1^wR>Sf(bYT~t>mWJ8^47^|kiUcT)?+YposH)z$-zy!7+=pr z{MC5+jbK|v^=nzfNeOK!t;m)SYl&zGgo4(rFsTQYjaw^L>gOt>qX6u6EH2bI6E*`= z#YoogL~LPK#%GtmG9n$*hv6HfpJ_72qludgX(F=zgcIav{X`u(#2wi~Q15oFS#76G z?S)y<5%kgR7p!{m1!v7LuL|-dB;5ixr>4|0b!XD<;jB7rk5avnREF~pTf73PPUIL- zzm-(_`%bIg(XR!4TDsIttwTl6kKci(TH9fzlpaZx!$=CC16OU8d)SDgERyi2Gj@eciNDE6Hqo&6 z`_eW6H9iP+bn>kJ%}ik#7>=GXvJG@iu3sy#tS&44#rTvThm-T2vh~Sus$5n zOjsU;TrgTD7h6e7(HnBp+zg>v-ci-aExf)h>aA~q@N*5n9`H^)gR-&iV>NAw4AS!m zU3C?DoM3x&*1|1sWK&L>WLUYww`^Pal%Zc~iBj0o@}$94w}~Axk7`+2w2UcL#h9#V zNYgZ|ZV^?tSn^WUvfVeu&^A@oLaN_NK!N|od~QRc+544S8$y)L3q58hp~lkGoriAW5{oQ&U>WV^yg2S*BdzgOv}UXj3MJ!nrH%{hyny8rP=*aT(9CdoL0Q-1mjS=GfA}^BG_o;Id~?` zwZ7_K)T@9Z9isVWwsR0A&sT0PGlcU9Sh+U>TQJVNO2V_vN_~*QJjva)j2O_cm|zAz z@Jt@K_PaX7sgVH=KB%)oA+njkGai_5clg9R?b4GsJ0P1--d7s*DbohN&cuI+9-L|F zRkuyTl6xu_<{D$IH_7HKz0vE#lv-XdypJ@!q3>O_f@i$|j~*aaUznJ^jaNjU5SfXR z*Ow$zsfm@Q`FnK6>J}F6$$5+UTZbI9$8Us6eNhr=OD(ndNNdW4T9D0T@Q>yqNA}FJ zD)v}UU>ehsq-&@+8_NPdhNh67hJfeX?$Nu(A6w2V^=WHV-3J{r&VOKpHU!!epTcYt*J$te)PX>3Qsa*V!#E6wzo%wUhp&Rpf@v}cEpZ-KVg5BD#VF)Ygr!9xZb@xI zIgmVBkp?2egoJ!;Ro1>GpA67M?yQem#4#d`3MY?@OP(je0yQ7kue(VQ@_7*FL zCxl?j9ICg2H$O!pb3^Bw3jLnO38I$%rH~34&H%*%V3I~I&JQi=a{`bZLa)jHKI|1F z!Wa)EE=4pEh+@E5hIZUF003!I(ga2cLRlf9_qhO|cqo)t4_T*ryl|>Kdpg-}6oZ@H zQ|8B9Uy?{(=@sBZI)#xe1klg(N@jm~2dcEDR`k(U`Xlvgrc!8!CbR>SH%$*8KK^V; z+x#J`5hJtxLuM;XW-Ca>PLz-lH%2>ph&Ote#YWcfDeYsZGiwX2AHR4_%pf;OC+$s3 zJJHYxOMb}Ij1qCPsXY<*QH_z)m_Nhwh;RDxDVES#i3Iw=V~U8;&&x66NhIO+D;Nr) z-)xTvlb#0_s~=z37xWnFBTty)7k(aAGK}1xE;~dzq-?<|5A166=vxT>= zGw;Q?$%c4SuBrBT8=!A%-xW{lEzI+WygM@=YjP-ezg=_>))0Uz^$GFL1J&lBb%m(i zP-u5KgduMP6L0Z70#Fd?I}s@R$=UGhe>~BObA^K5kip*Is3u!V8Fupey<(srK&U2T zN*R8HgWlMwCJETc96v{%PAU)Hv6E$97^hReEr00j%yO^A>OM&UOHp*;gJf&8L_~Uf$KR?S?ocb(8UA` zQ=z>F=Md?m1?GTz69tndkXgO zxJV}(g=r^BWdQX6_em8xDMPKyoCU-51CB zeRr4YQtw%Po!bQ}m~h8Wb7m73z-+_O`CL6RS@eyA&R=JU?FqyOy{m8R%&3T-`a;+yicRb=T#?(>xcR2nmU5{6HGBM^1>7I z!)Zj(D8&ji|57OeeGQ^9h*Sn^*MZ*;C7DUf2DM^MhqmLH6?1X` z^6RG<`sSx(>aUBAM;kzX|$&gw?$23a&@wsYRPYPtW;%Z#&i3hZIdx%x<*OiNb3 z`e^c4bK11}h~l_C%Nr!*nzk@FYhgSmbP~Rvp@oFQV#+SXYwf-@u=z!T%Tk zV@Okq+n8z-QiDVSZvSX6e^2BvUK3kRnQekCx58B31#2A8)(&g!x;#H{-m!2VmO3ye z<_wfR7J*~p2MpucL~(Co+qSaeceQ#<`>WPB-62*9N2vNz&yf>IP5Td{PQ0N+nZdAc zWtJImXJs&}qyx-1n4O>5c~_Y}NGB5Xy946jShS2iEt-quy}2Y$1UqOqySlqM{KKOY z+at;r&0I0x9dA92*fOTakRj;yu*8rBl7G+s#=?yU<zAj)&j+4IwPChe+%Ew>usN zT_Ubl_#8Y*(N&%F$xo_~qg5LlGNVYCgN$?_V;<2>PSQW7D9=t58*E3aV2|7!)=&|9 zp-7@KB5}H1DnUb!GJsT)S-n1Sf=m+ZA3WAzMbdGV%$%-6hswlN>d304F_Kjx=`vP% zYCE=blalrJdY)=qOLGcB!tz!8%z;l+bEcs%>QnK|qg%J#UypoilwFGbj=NCi6Udy~ zSG_%gpJZ#GCjtA7ztHndZhqiX&AbMY>qQp6*fx^xd`CB1_e#dZEs02T|Cb1)@a&RmraV`1++oJvqY{ zKV`aoIou%j)!1Jp2SWw2j6=(Xi#70+Y%FgK)^Ci~K7lPfk)@xzi4|`|4x7}`tG)&{ z?4XT{mUA?0e&0Szhpvx=CQfiSIEEH7n*a@QV{^(*Zd$7Ggly9a1_)OrYAT zhb#Tc^j>b1IPD?v*BUB+bjK(0dQ?X4x^J}e`%K+Zlxa`BEB(kdZ6=nOhC9#cJ?JTw z++X~A)X)TGBHe6gp+jvhKB12u9;lL~^>|jz>pq$tU36u|YHq zOZyx>4LpFWuto&DmiaLF`8&ind1vzVJoi?R^$}}IBRwrIMB0Cq{{(E+r3$Q0TwXh! zi7Es*>_g ztB%PugV8_JyCJ;)M&9WDQ>_ZoY0!gQdrGf$mIOaPL3IDzZVGaLBFK!|mBQWYi*-_8 zJb>eQkgmxGng5B3n}E=FaSw2l@Z-VUtOw}f9 zjg+}9G}4>#d<1xx(Zgz697q%A2tv4FXWomQg8qPi9nBCae4~qw@AQGbLEtbyd`-BP zz478ju-jZp2YW@lVmA(Qj8xY1;x+v5<(x4d)4Vd`dJF|^Qh?$(J*JuP4WpO?ts`If zBM9;VrLv3hnAy`u^oGDel@nxGiZy};?yI7Gn>P>Ft>V#7FG){EQAeYFHqlN6MI&n8 zAQ1k=`0dq`zIf0sFU-HLo#v)Dc%5Nb3PJwk^F|J2g;N+0tc?Yo&jjpb{F@_5`LsCl zubDB+Af+LpghYVCI0p_pjMt_ae_k{|J6G1q+r`+)Y3ZNW;(Y(0vX~T$E(GlzPnK_J zig{{0gGzAZSW=8PMmU0U-W9@>HD0veWU9qeavyVi9gY8AH;Oo%mXY~X8 zp4P!+Y0IYWnqchj2GburMAIy~snH$s)v;>|Ykuu@NJBwF*DaWoCLY(ZD?Eij&fOpU z2y(6FBfXWtT?BtVc)Prk%13*MGv(0EuIqmxYq;TRmd{v<=SR?_mpX^ZIw z0r>c8BZU8yFbguSW#wN$ke+e*vw@Ejcxl-q7psJa*GhP2DU|axNI^?QGd~BLGBHch zebT{shE#}}13G%#n8bHRm<9hI5C01#B>!fy{*PI9o3xr$grT| z;9q=N^Rbr8W+^VsgBmfaAH{U~Nj(8wI~+ktKVTaKCkEmDjM4kP%xUw-aAmPIez;y1yg8yDMf|K1>k zJNK)aHt6yrXMsS6Eyick`lM_Y%d=~yPy|-QBVR1)B1r7kh1o0?cw6*9d zR3TlTMd#F)yZ#%Rig*_dsyz*S&KhEvSJ+vIWO5Y-M@zZqM7OnBgQmUYfhMl-FWIwKD5PaX9TGUB`PBk** zKAy4#j_8K-m)Kl^IwSX$Try_h&YN_aVQ-gA0 zd*Pc!pmMqB_?-oUdnh((jI!rA%98HAGONh6qS)xeBBNv_mn>Fkw3^}~lw`SPZlr=K zHS?moWE_{CMs+e(lSNv+ica}v8J&_#dD3{7Mbf=ryP~_IP6bbeZZ570y<)cly{eBQ zy$Z?V#G;vV7MJ=~uB?1b16Ux;*WMY@g=Wb*tem%;$d%rKHhp6!Dx9@DC3MiCCnZxX z_RKfwp-@~ql&~|*={fDJMi(0KQq`=|7WmiFhJL6AMx=skudp+@w8Bj=);Zm%(v81? zGdqn6K`@nbjI|AEw}dR*%*X zg0q`-H=~BPdbs^Db|z+7#>Xq%>5X~~x||r(Q%D?=9k^8jK->n>-F6)fWcN zgYX)SRKc<|;>)J5d&v#)KI+WVEaKVLpqcTAWs1Le-aT5b}xgw3rW0;T(`!$OoacbV8)X z3k`M-!=UDkgkDbH@O@4_S=Bu*T3VCG=G#A9k<+041e;OeGgQ9lTWh(Lvug5W+AQ-G zbfxH9t1rt&h5*e*}oYjpCTfnG35y^b)?8KYoHV)<#$)RSY|2{wWR?>e&CP$4EU4EMrzXl9xl~J7bG@tg zu+}xRi*)?hJcx2iw)|Y$)6^_m?pfDWeF|L2dsI3icJi)vI~ub-iLPvXgga7t3b#h| z7Oqcj%n)vs)&oAdt!sK4z1ceGp4M1DfUeTJ_1FKn&}!<@{ku!5X!@jBaje(xG5*-D z+JyN2cI-CqFeqF#=wPTyx(e^}gr;J6D8PK*$o9b^z_Wx<=*brT@_>H2zzSW7{!{-< z6FHk5veSftwW4bPe`S0;&u0|3K4O*o%$}U@J>3;5vS z@2S2D#^Ns>-)U*(6OzYMc#iO zzzVN$H!XJFc?Sgf!0;K1oFW(-vB5l&R*8QtQ?Y&fm3F zIcv>XSp#~vKRNA>aL#)lIePElAFW=F+bs*7B`ks-kO@*y@4{1;z7Q~H4VN{HuHfCn zxFK=FdO(g@{)LY6&PZHm$WBYfp>t?<7hI9E1Nx2l@Q%*piKjZf1s%DfF@6z`6s^iP zaO`K^du&|;+c2v7{=qH3K^i%a2~~RRVq@35_H6;V*y(HC`Xs^d;1#!c zN=;pbb1SVc4b5uiEzgSH#cYPBiyTTu(om;cx|HpMyEAU-Md7Y+tV$Ky13-fUB=4>?V zpAg~POwRu0op~z}y2Kv{^iCsv^y{@s`X3 z_maGm@pI)cEVAViHx)d*a{d=U7Vg;2uiUKn7GwsnS{%)CD?=m?u!+XLy@NKFU(mWV zzX4pd?;5Y58Qt)Pw?gXducqp9WFcU_>5B>9)@m0y zgp&QGiTJHq^9g_t+;gKFW)aW+N*Gmr)#Ml~W6m5fw`CVzJz1KrTnC2NCgbC3t*!A?|0%k@F8Mz~4m zPs(Ab)3`{!ej73?KQIFZZ?J*u}K`ng$=UfZ#D*YlH;jRjTJHzN1RkGBu5;B z<(4q_TDVDW#0Ob<4Ul#YkOX>G8-BkRdsz?YY$|kZISllOYE$S4(v`e^gEi;YT6KFo zN*Yz28FX}R;}u6pw3P=)l@*1+^b4@S_6w0fKy?Ztmo_~Ktm_vTfP959FiWR~(5YQl zWOe8XTQKFqIS{Fu9nr=>4GjAha+gCGf=YK7sj! zLnZXQW&@@20}*cJq`ekQ?X%868)L^Vc|CKSmvv2Zcz1rhc!3y#8S%Jmf)V?3S%kQN zF_Vvzr)MDvX+fC%q<@hBf8Rf^r>kJdCqG15BRPRS2BnD8K_$0akV$36+&(2(B%yhZy+liKo27*DO(%)y97-whany#H|zx(%jO zizZheHwEvE9ji2KrEQ=J@bCbQM7YCf+DT+cqPV;OVMMf3v!f&&QLuf|jk2YNf0D+= zU1cYrO5UeeeHvqxw9pNL>qf$#OzK`LLFLRDvMjJUVNQq`)O(ZXFT)TJsuHiCg-ayC z2d39v{2vT!SiW_-d2Lc>ZfkZ&q?F1Hk__TB;yPNRFsU|!AG;wW5d_XvsF({7HPZ8@ zHo0JL3i6Ir2X9%E_>S3x?kDYoN7wsR_LA*|{Pf8iBBpa6N(E~Jdoh%#1%l&J<@%d$ z3xhfB{Dp1#)wX>57Ll(;kjR>X7&vJFqLA0MK4!urGs7(=nJ!^~ab&B7p((lA+b?em zx-`zf<`6pO1fIYf#BaPHVxR1lcwW%@&d`lZZS=0nZAyr~1MJ&&%-DDol$>d{_pOX} zDS3J@w!W`Nri+B#8QR&8K)Z1||MIFzPQiFOVZncJc~Bjwu_4F1c53T%-)GpkmFep4 z-7s0w^p;r@vejMi_N`YE!=x&+%x{aVzhaOE$p`AYZ#lIOauV!+b_!)sNRFI+g!CoC z;|g-|iB>%pPZ}v*w{1Vc{wFTdb>A?00q)nYUBX|#{?X+AI|ox-?+C z5|`?JX2!@etkBg3`>A|q`aXc<x5_Wejh5U z3b=#Xso;-0zuGHR9-=g2jYL- zLm~i({f;Q#kZ%C=))q}=imFGngXbb9m&LP_tM9bYkigwH!rQqNaTm?yO8@slxLW0F z6k3hu9X64>dvA;6i|U2{(E{W_7M*SH)r|FR+m?q=?$C+#g!NrxyCX&;=&I4S{qsW1 z!hQ6D2_iDIW+$!xTVUMUw3Lpeb{lQ?CX=nDXD-+7icYpWCk7JDPdwdolA}Jm%a#{2kxaQ-?tS$Q?hS|_%urQUIH=rruUW)_Yn(>Tg^Fe% zgjoiEWTZcD<`*CQ^2Qh9t(foTL++V0 zusK?HJubL$8b1E?SFg|)?&eV{_8pxvZI_$-*7XOrubN)pHY5DElmbV`;UFRZvVpn- zoKL020;b%xI_>xFBs*$5s26i9+*nfkvEClL$!Hgal~Hs|ZhiMUL)zuBl#Z)b?Lz86 zoiJyw`+?{>&lCn0=mGGQ6>4vk4@`QOw~f|jNI_Oht*7QtJybI<7Hn;6kEUzugCy+& zZY|*Uog)*ia>La1$3OOu3^~lMgTzy7Guy}Y@rNsGHNn&fBnLF{Bs$3hNxj{hH4y7x zx()bn;bo%B&#K!JNidv#BTbU*Rk)WphN+u{5QplXI{2~_NfVlv7LqJ%@xYde0Zh?j z9(6NY*LRZEbk`S(swSx2rE)<5kWMsBPvT5iY`8m0ULV}xqE{-k-H@UVFpt*|-1u1Waw1!AI@_EIap>S7S0nHupd5Ge&K&g0+uHKPQ$7~0v!?uD9W5AkGx9P2~!&xjsK z<6HL?;Rb^Yd-v5yHHS+Pk|&K!tq5Wg1L5&QEV4Yy8fcCH?La3yLWxY2NXDs4kYoPD zo;?5=NOMVqN55H1NA8t`$+Cnj+D$~ooXlVN_XJX#P-6$)WY;Tz!L`s;XVnJFcvAUqA5)YL&$6^?1Uu+P$n%u-(&~e)f0*vXKw5FL(#fs10Xsw)<9MRK}0pll=4c ziD3pD(x!s6Ze4>ThEC}+dXV+un7DO$Wt&s0Ws@Ru$%qSCEUd%}r7>glXbS%yk z7?f^^2(!1;VttT)R2zohADNr_LPf4?qLS*vUM#~KN@=*LYGiKcW~wZG)jzpzm)|f? zV=`=>oRl?+0BB}QYLT@itvt|#+>AD|>eJs01Ktb(YsDa44HsDrhUN*y<{4}ejIDbm zP1z8`D$4rI_W8SG)bR@U_1k7(;qnVs>&AG(+YRXB4mq27R{F3$bIel^@ktahOP}~% zkR^XCNOOFRXmTyAZP-XC)s=k*xH4EC@$&okUv~M?Lg~TCoN6)wx96qbB(qzTKJUQ>0pgYd-SFedzCz7OnhMx(`__=eCiXH@Bnx40P9w<2?bFb9nj}3Nw#xD}qPrYTN4i=m{8WyGw7D^mV+OpQzC2Uzr z69x7<=!R3+#boQD(5cii-Jfna^tB-{#KoA}cV&$k5q$0b~GUS%xG{U{ot0?NSv<>)$Pe`(D~ zEGHo7QgoP7_@qWujCrQUInvYIBgO=&Bz~JIH4_~-2Mb4*>i{>G2@exfWuET0-dxDU z-iF}~G;P2y_b_~ebem>(6Yc>kQ-|)2)-2=ZHxup+s}#nrY2}$m3MCRH@`My~n1q}& zzT#gC@Wn3EqzaC1MY;3vQ+w=zA1q?Mh|Olv9zv}ejx5;yOMt_G#XQb>*glMG?O1Hq z5tfli#A%qC{l*V_Z}s#BJT=TA>OG%EtbTbXTd{^pdx=2~as!_35jVG*x;i4szrw+2 zF>tJ)hBQQ>J=w2ki#1=_C>z`+Tqa_2`-S&{Qa?Lo*t^_U^`xtw09c$;6YeFvo)A5| zT#xNLI4>uhw^OzQq)P zfiY($UV<6+fj)jUr|@1p{8#w{jTzDM zC6a}_7R0t9lD5yB&R22q z4ow=0;{|eCyMk*mj&77a86Gd(;8!oO>qM|6u8d*ZLhxTmMUUhhX90X;Rbkq=Kt{RklqcH5S(j-=XPppD@v(P&f|(i2L-?W zv>comLPikW?SBPf+!$_`<-`Z^kx+X}2%S<(=GmIDd?gIeGmfhX4@oMdg%^;a$=M{$ zo)CA?C|+clRQa-70IK4g!Ft^Mhy#69auXRIiUy77o`dc<0C3z&2WHA&p9^G39rx}Wdip>zQc2BzZ~`K<^|X*!cL1s8C=`ct-x>EV9EdnMM|m)VV}AG<|QY zicxNvBP>Hs=LPIIFfJ0z#9ygxMR5|GL>jF4={AYVcKh4|RIp@XR7UVH3O*Wxq4q=Y zKa)W`NzB%me=Z(h2>+k%@n6Z{fB)}3O3mB}Wd-d!+sa(@pbn`YNO)k|kJg_kwosX) zkqwhL)_8>p98J-bX1MuJ1j(2ct+gcE`X!Nh2AZk!bNx6ABB6}odZkRtZyC9d3g7n@ zUd}7?8FSB@j5u0bYwzgm&6n-3>#iFcW}g$i8ogigA#$5${rF%KXq0g9g{+#UsgLHZ zSQ>CRaSOL#hiQ+DXQuTj2+wt+KF9D3oTKgCV~1LmyM#A*2G@v=J0{oM(l&s59kLL# z&G8v;X&b}CtI4grU0FC7JK=$sTW>hmJsYwYvsR23#x}h^5bWfA0bSgsTSR=5+yBMZ zJ4Q$TZQa7LZQHidv2CYf+w9mjJGSj~Y}>ZcNjiM<-1Ch0od3D^!>{T?jZvd&@444r zYc5R0?7B}pF|(9F!itxKNC{QGihXAExJnP!;=Fq5t5gREmk*fW$YXPc3t6^!i#%n6hU_4gXERNSog z8M*2zR-G*(c|N{oX;P4TqU+I*r5%$topUKg_{F7A6&2<9CyvXP6DALGYc>?L4q{WH zaas@W1=Sp^xo1+8t1~4Zj*W5H)Jm3TYi1@3U?>htl#(_%zpIou&oE*>wzkaNY{Q9J zDS7vT>XDoV*p!omE>Q(EHTf*q8@O3qqc2 z+UCfY*l{fjN8E&P+x6u8;-IsN(&y<_yoXI{yGqJ=ZjqjXY)xT-S9^oh5No+N*%OE)VBqKPWkrx(%l4@ys$ki{EgTW=eY*Cb0w`_R|oC(}lU zZ(9NZ_-Sh!zb;zE1qJ|Y)m-5j`Zp6FR-I?Fq9OTt@9xJG#?$H0;PTWK- zO1t8gmGNfaZ7{-+j+Yzf>JkKFo=Pr|?^AYEo#f!5;Ap;w*3dA&f%tgmlgXN&CS6e# zXa=!jooSZwgMBJS$}EF}N9NS4gk98%5}O3oUAQ5?Gy$F4J9A1mwqqt!4X|dj$g_xO zr(HWk_NH=})KJT%-!#wNdFs#B+jIz}@|&MMe|;WWSi_+t+NUc`XAQ%;&V!|Tkec+v z$9L}@L5E}%Fm z=Ij;>YD-?O=m8%Nm%4?zgg}jaDLndZQmScURds9y3Ny;4v;3W^nudDRZ`PXD#w7#n zz9_oqX%dT{JxOg+l>Ktx5qg8oPl~&E`}AT8hr8ovquI#uIs#qM^OHD~jWD4Yl`r)`Pu3@pHZKlndps37&5fCM^jCi>NFwCTe{`;0-Z2b{6!|( zcjAIkgvfsd6;T|?>Is!Kh+5MWDG5~G;n3N^(AiOz+0iYp1>*c*dsUlNAXL-k)^`M@ zwo6vh6=p_zk9_gRt8Vxshg-`i{Hi@V$KlkJ<92Fmd{J5Gkv7*jPT1xIMerphD+qc+ z)gzs2SD0rjLB0p};kLRuD+yO2oE?uKkOW`1>ADn?BKa7odRZBiwJ)9I*e ztP#y=hEk>j(xYTF3BV@(JxLu+4%M0!ebwjUl4uz=xGk;_tJ7`ql!nPvxmJtDl%@5{ z39iFr5x8a=HJ_9YF|f!x%HK`T?^_dBY|h>*dU->ZHr-Ew~5=~PozSfpQr z7tn)ayva3LxehW>C#@rI$`Zb26e$`QgF571=V+(L9PbG7eRX2ZUAzSbGBO>eP$^W0 zs3NkE8rT*|89IJdOSi_@o2ig3lD&>Q*6%-ll*|MxK&rCgM0x`=yksv*qztseunRu$IK~i=5 z=ku-?eC^t+pe2VTx;1&jQ|NH&S|cr1n9Lw;?#NNj6TAG8ScB00QfbZj4b8VG5h8TN z8$PjXNWB=3t_8+7J{BVo6{iFwvH4&SKW^AS5f=`1_;1eumobcbzcG&GwbQJP%l$z|%+NbFve}61)gBU14P7|ZuM%TH^4L|Umi$WAd zAdD1wiMD&J=ZaPsME0S%9=;h=diRqJnclOf=zLC{OWr5GaLla@Pf;`0vaZ_P>KO9( z(Ovlr>A0;8zRX3@;sn394}Rx$RYLT#Jw$CV4iF)j!PUg3ebC2`N%7VYGnT(Ox0pQY zrod6@S`jy{c^RQt+FzvG~u7t73nYt1iy#D-6*H*D!{XRNK$K zyfs@{%^RW59PV-_L(vaB(XSYE@r{l+B2luG(2;(9s8Qs2-eM3nom~MoKT47FYqUE7 zNc^rjXS&m=kD}}PdWdqfL^9(EEb){Vli*GX?V=2<8l!4v?6t$Xl=dw43AmFRhxo^O z_XH0D?PESacuWLH2w8u{D`e=Li~Qi7G8g>k`m3JLa<+Y|Q1yR%lmDec_1|l5yS(DI zA^yGQdXEJT5L1%;Q;GSf z$F}?$VJ|N)k;1;4{6>BWhoj$l%fDx$_DV75ZL(7rkq;HE*)%nlCD@8fQ4;)Sp&sf| zslQ^nO@^^u*d6nGQ10XZ*x6 zQ;f=gDbY)FW-VECCW)Q_PfbfP18Q&y1mF2!>|Nv9iH3+*3g-&YL~{4g&;iiAVArAN zW=@)sO5c@K)@WRTm5vj24e01}mnCv46UubyEf!t%L+9RiEzWC;8&oyL} zMd?>!I+m>gK%V8q{8qTOzd8H)0vrMGIwHG_m3btjf{Y`piD=f6doK zEVEtb?KpEp_+?kFYq)1{Yf?FO&dD(!6P3q^bWO?&4EEL4?Kv#=QEt+yDwnA|v?7sf zjVkrUYV)vSWrj%f#3*+gCUWPm{NTAS2>U8%w0VAAc)W{={q1Jm%)5qy^G%?|O1p~e zY3I{7Nf~b`X0uoBFKg?0)$tffHN`}l?c6kTwK%{0Lwu7b((<_Ae#i0z+a6Zsll5hG zO{(n0c>mLHzej2yY_-!6ogUvm_@L+Vf?4`xm#G4&$Ddt6v140Q@CD7%=I^7>Y_nHr z*xcl}b37;G8RRPH#jIb^NwRHYlKMfj7fPWNJY`+?PXU5HAzHiIOL6Z6w5S&la?4M_ zq!)}?7l8H=H6ffW`8*U{&(tk?1vMF(RXk>X8QrP zV|*^NPZYl?-Jpxf&Rg7Lu+PYLV9pGk+m%V`O|$7;ga?B6R8K+y!%v9M)W5th-p7Qy zgc<$?y(IhQ{GUhv6*|g}_)}!gqw~vk*{#P!C z-29{4)$4jkEC;Sm8pRn8Px@@1;e|R@%if%wqC*{B_fn$>NP3m4D0Ro}(9u8t;-9m^pKh>~n!%G|F zuit-I-ily3+is~b?H=<$c(>Z5a(|`nu@WT1+9BJy?KOhDaB~VUrnjQ)t8ac!=oaH5 zFo@qnKuj}8ZZ$~Un_$^I8)ooyPowK0Y3ww8selw&zO=sIzX17w=j@^O+B)cO<@=5_ z+nFx=?Kq!CuRrWAQ%*pI1xYHdlh*wDxQH4dP2CjD5YhJmc!_JI4bNq`JE=p)Auk97 z&%2#it^ip;X1$WZ_8PkMTq)SM{liVKtUWq2x_R69qS>atzG0f4LYIVH>O)(RH z(BdYEX-dLs)ksJgZ6E5fn}o-Y{CN@rwu1T+*8cJsaSsvMlYsH?_(|B27)>XA>w;cE zGeWKezw(KAq6*R(2$HC zDeQ?1Z0fC398As$D7BuYuq>fi4|Ut9Q&4d>>bS)?LS|n_uzu7==s5AJpEnj|GIWi#QVCT{l4R)bJp=DNf9~FMg&?}3 zjJ?@RH5+S+2eSThO}p6DwY42Zu$8r}POvS4rf1rLbzr!6?6LXWE?N{>|M zjG-r$joemdPg-sMN*#yxnUVG-DwnWeh464S5Z69Z4Z!XRr9S`RYIUvx?!`i_@1X7a z1MpdN&Byn^mlM%vB5EHcO-@B@ro$!dZ)ZSNgwqp-53`+ZoF6=wiWU7_#HyF?7D$%N z6rq0JjgbIVviIg8JkTyVK3fi8pI*EbYO+54AvvHvYj%`WHZ{%>(8XhS>e~T*2MRAZ zn8ffdIS^MbGN5p~;0Tn&CeqZ74fN<`z}3RH#<^NM5(8IIp=(@?b$PX9Ih(k2N57}p zG-8dzak_Mimb-k*s&sPVkqE{;Jm-M1-fj!A-tW@BT!+uA`w|jru&;sRM?b*op+4Zu z@-A-UguHCs2820oQwYMw7x!Q~SGfn?MKxir=OLBbyEF@_H^ALrF=}KQ8XB5*#~U&a zoj<)^7m;w?f5YAtD9B_)IRzBbA&cmSAkN`-Iy@{|5_i!kyC+B1o#5aTu$MA91(i_@(M<>=qHEN_~*zoD9$(L@xF;-w6lGGJM zkrt1quU1Y=v2QE&)LFQ7b*DJ3C(c-3_*w!+V;J6cB86L`SMBIpvSau;zOyLEIPyws zO-qm-KnNp_l$(yXWqzZe1U>NvVP$QVZ<*Wq;u)M0ElHQ#~r8GYHI ziiGjI_0C&K@^hgs-GD|$wy2q7o`&S;PKzHpQIH8_25gg#OKy41q12EfHDRAGTY)H` zD-5mQquZYmW`t?VA4zQMEf1NQOFW_78);~Z{f)^MjQr$EJ%86PIh5rYSAyxIi`YX4 z4^nB{7YUuuKueuH5L@U|oXMH6f^bc)2A&I@R?$pmb+QH+XH1NHyvzu_xS~`Sc2yJS zme>!qhSWEml3`f7>ZA>Ls|56v|8v#Prje{YZRP|f!3wRhF(mg7l@(85Ar%zDLx^|s z)4s6>qFG#i(PjEa*;Nl=W7zKDw8Oezb24nzHG}$x7Tsm@X(@S9GD8RvBXA^2P2=BE z3z@y%WLj+jaHG z^WDZ_1J=O5_RuNd$@^}q2MDN4HlVo{pz2V& zd;v68RnW&IDH&|;D3+LfZBZAUa>?*#WMiD3Q;)3KINEqi2$8B+bpaLl?UK*)tj|g% z09B*72(fPb#VxmJgD(z9#&L zqX~KEP)rXzp^BK}Q;okxb2C2ij@S4|Jm<&EQi9Ce-te9c4zo_M^%$Af^+~)8w11yi z!a=`JsC^4&PpZ1}MQ2{W^IIgkXqgntBxNwj<?2wsH++{YmAFs=!a}E>cA^si-6CR1I%@*frj-HR7i;%rr<|HpZ6b>KT8oy_>pN zJb+j3i4g1hS^ay*bKf>Q)?G7y$JEj@&ird=;VTdQD+2LgXE6m+U1x=01KVf~+2^P5 zLfdw{zit&O{Y0*b6h|NiJ6;nVtv`2+j0pzJ(T`lG{=!Jbs?GEgm^~GO;T-V_3m!Iw z#sQ0C4~tks>Z=82F~y1uhcYWJHF)Vo8`W~-7dI80D-a#O-rej?WH@kfC5a*xv~}Dm z{>EXpOy2zbX9I-eWKQ<9)sg<{VsJ zM77ckF?vq$MG_Lu1%fDMnVjF8UD&0hlhThlgN~30TNI&Chn((p^^(%ms5AA0N@q}b z>mjZI(h?6?*&?Tgyfmq5?%{SY9I?!1CYE=c#nABi1#|0Jvm0K~1zfgatu=0C`OogA zqdpYHp*-kf=WN@LL^z3;al9Xoxz$?XccHN zOcq9Dw$ZL`SZt%7X$FzVj-ji%3)qcL1sKeFMMs!SD$oAk(&2>V|*2kOL`~?>s-h>X_AM%U| zVF;K*l65rn)w8y(3<%I+(O<6Tzd-&OZnMZ`kqUfM9fRK?_kWB^R#BC5F?9lb```a7 z_^do;x1fl|&*+#rCMPAc;gSbBo5&*%LKlgpsuT!=Y^zyhq{KWbRlPgDI_ikz17j1p z>XIaeoCFkMN^_@_{E)4vX{g2H?se1UeDmj9f87s=iuji>N|F>=d=gX2Fq;|KWC>Po z!nQ8ngCiXj96PW6#vd>WPWX}5Zl{H2+r~4Ungxd1mDXBVGTj*~tysXrBm6}DJA1&H z&*)tWB#894l?NB+pdYDn&1ILh->_JnB&&AoUby8?`YdJ&W!lF_;XRfy*flym$mcIQ zw;Qp}#7#|hjBKy4_X@r7D&{{3$v47^qEVKtR7{9HsETyvsx^Y1plQHTa|E6MSrhmW zT#=%H9&g!e8h^(1_E96sOjE)7s>KNKn0Rb8;O7i-Rto?OIpx}WJ9 zF!#ZX2I&~#l6VH}(YT}Q$GPE7w-fa9eX9tGOI%}*xgThKUT6xf@lJ5Sw~97(Y{~*V+hXXC3G&Bv4*D=C z{XqW-Iobw`H@9!dkwX3#LD&?}z$ z!RA-+;q6xb zgaRuF+c%Hj1kV{Y6{xu^uwM!d#j3ZF%(YD zdem&x%*FsKwsI2!&0_)G83S6L;Hn}|^x3w*7BAh}s%1JyErz35q4>6ruY2n7SG;Z2 zc`0N0;GW|B-K+}$P>nHFyJZ7?7QiF&j|yIWvr}&Q$Lp(%Ucb{2b(h}q%qO&2Gy5xS zu(x8zEcA!fmTCzq*=!K(mEB;tBWr)BH3c=^nS#!LI4xE`Z>rWv|*Nf&ggxGm)?C$ZmqszckfGFN)^+APoPG_qN=Z-T);(s`;ypN zpH)Ctop;pDnceT`k*?M37${G)RiBf8fpt#>z+!%*ec4AiMXO@>!S0#cWHb`2`w=*s z?ldjTs5CCp_!2_4H^MS&nR&;AZD5pt%SqS@lmq{pUSt8djdoTR$PS+e^XJCT=}I~Y zuBWXL%h@5IO$?U^hF|+doXHQ)8?#41n+R-`PvouVj(hF#gg#(;YDd`6SPz12V0ye0 zInW!D+y4KA>R=4GDBd?zUB9g(>c7cg z6;(xm<^Nhn+k_3fg&#2jOd? z@v%z-DbML8o7Bn&O%ptjw?ST3Vo)sNn|T{q8+SZDKkhCrIDy#tB#Al4*2GHw07yU?3)tgJ50I>XOni3h&LwABsne_E_F1WaZ&`E1lFI59S-8^fyw~3F z-oLL|{{umoL6a(O8}0{K7r67{{QybMW7}2OqQseRlXIpK=is zfUcFBnJjpNr-%~}@+D0kf2kw1@QT!Q8HruF`e5Fi7;cr$Kfo!V zi_JV7N|#87fG{>6@8gr3*mM=?ku9-dH2rro!$gv znWCVfc`?ha4}(jFk*)H=`Nh+~nbN6xCNkIL{?nEA_-DGmb;t_^__381E?qAg=8iq+eL zpoDAKZZnh2_TtPIV%P1fHB-rY1D(i?PjvQhU;tS;0sTZ`x;zgh4~*C$@MzUd516U8 zECobYdsp(;2QN^Jq03WBKS>nw5C;W-~ zPYd;HORJ&odtV;DACmuTf295&8>AL11M{7!60Q6gLJZ84L5#Oa1T`TqLxM74);C<7 zj>n=zlDM;B;QJYdLMaM$CbtkL;p*E{%Lzot3W*A-(yv>;W|^esvs+4BrOP;dBmxn# zNP|=|-UNe7FSUT1C0R<|=Wbjsrvx5$-_P^-xgwtZ*Fyu|))$uv{ivJgPJlMOE}Fwg zCyL|O(NZlT%JNopjfiGbbE5GyB`XP%S6L}1(IYd^C4rF%bYD65@PDO;)L9#r@xJls z_x+ImU;p?2WQY{Z%$!YKr0mS>|Ak1sI0c!3A4o$x9A7q>nMLCKWsrR$St8E2G=bs5 zKQ8l&&6CVfTZiEX2NjOQERgwLfZrAO$8B$NB)G4xv)g8zi2^7_n?qNr>dy9t05dklAOn&1HOCNAlxBRJfZE#@eX zN_()BBI`#z?jVZiti5;?Xb^QA#z{-?q99APVAK_zOA4!ZsWl7GTn+4VKpUfB42rVs zKj4A=^u)>@Mn6oL43z3RjFMZ%8*xbxH+S3RVDoB+ughVAVV3e<%u%jYZ2sV6`ZA1( z^=}KkmnP*2booJ)r_dqCk+qmF_v;+OVIBl{!XUvN{77C-|8vu;^Fi{8WBo70Kf$D> z>N`~Zeb5)ayVtP)y|~6MmiBgHHm0_wb}s)~Qd^ZX(P0eY+vnO0|UviJ3&5J$Zq~J|qK|R&J3r0Jl%G`qrWT*k+RyNm}~={{kh} z0;tS}D=nO_7cr_Bv!vm*lXI4Iye}u6grVamOgdQL?L^7gCkR->e>>JKBmFX#;t|6ap4O)Iw}C0H@!HE&Ma8R&>0PmG$ctF zuB{TUH>kKG#ldd-g$M7>6Cc`}3_Ao^;6N8_S(G{}&4R}Cuz4{@3N&Dq90DA20vF_j zrU-~Ufyi|v&JEB)n)3FQRS61Z@MF3t%82sMV7eFcFWp@RZ=283p#l+*i*;hMj|)^^ z6X=WP2}DJ-Kx{TTp#h{IAkA{nQABe|0};AXyETu_H8_Bzj6K_ z`Q`tEaaAXPo%6p9hpW<@JgN{Hf2+>AtyW7NnxYVWWQQK^tJUxHJm}$~d}v#?dk*@> zsYKIIo7PvI%pX!rccAZ7{W*FhV2?+etnSy@+~&tKM?>~NSr%%0M%97bd>prfzZY0= z)Fut5hC9k<;P_hW0pFn~kb*VsYMx!4e# zW^YTB@;MFw!=htV@3Tn(%mU zb|}~0zl=v#3JQt&n=z9fzUJxT+J8{X1`N-&?Q--D9Vp03wr$V;+67cR- zQU=E&RKtQ({RP)Qn%YICyUq#U-7zoTvlzY_!C5jg5+ZVzhN>{q?~<4p9?s=jAkO=^ zsp_T`p-$ma1NLVw7hwv+ND3!3MMBi{mdQ|Gw2uy&rQa~kdU6X7Q%dWCRM1MwJeIO` zbi3BFG23PL-e0_hs5$#ys2bb6{;MxBDF2Yt=6iFszKz&_Fd8=Be1;vs#nSD6!%J7? ze>LBhw&oAaVt|PvwR_O26cOb`V8N3Vlqe;k5Z+p*695d;i3b99OJBfyUh<%q1|bdP z-l-0F7V5#_4x;osy=FLr zXkW29t-RurkY92SthUk<)2|zHisN%T>bdXF>tWOj2oN>>^T_6WJw$V+Clt zIOW%(d-+N%C9{PM$5d5MNY1?Kel{88Bd!VSWFey7fl5PEYoh>tvWGe(@Cqm;fG(O) zu|KmXw{g&~KL)>F+S@LPUe1yGMOksX!3EH zICQ_*&OQ~S5-saVN}z;@NU9<5@F-BM;yrna+rkuBiNRnz+Rrsimwwt}n7{EmFhndz zx3BKUjXwv~vZq)rr+d-FP#A;LcZ0cS6<1-@FN}Rb38AklEY?#Y;$aeL=BEP2VVTo7 zN1z~PCoLmsMsYTxCdgqWGme>%<(6KN)q;pc4Kt7xELcg_?UH`7lQiRP&HgM(Mlre; zPq!o7d3+~AOYI)98bzDTl)IMSGU`pgi+lqo8Ix@~8|Fk?A|@#*C`Z*ZN7vxiVvmU$ zq8po-B%)y1>cgQo&0Pakv^zK>))f_GR`PTyKHBLMqM{J7YFnunpo@Q@9gxBVFN#f$ zM04&FXL4sUHD=x)>0ZDb(CZsiy0Wy_W%JJm&)t~}ms-0#Wm6u#h{=8Y7eL3$DC|sN zzO4`XKN@HM4Nzeldt>W=U9`oTo<6Ee=%02h-uf7jAaEBy!!yXp&~$_H0PMC%?95Qw zM{>vH*eo(Wtf2eaI!#uz)!NlfR>;*#QOhB4YH0cDRWi0))h)}{&2Ej&&CT>@?%Q2t zNn=$0Xnxt=H|;0c-cJvq<_H1}m_LFlZUO8yw*|<*Fdd42R)Xo$@4|xgQ0?LX>wx=6 z{Z89zTZV*R8Qb#$Hb55Qgt`{z_FIa|s+$U{-Ma|vT#L~G^R3M5RSLaolbhu|^ytKO z_h1IzL31dLQ~hY@oQUb{PLJ^RDf*j=%Nz2f&w2d-KSr^I*o+ zO6c5(xe3n;>sCESCVbjeLi|>y4(%r3yY3S}e2QAV8DByL>7fM4eau@30wu`4=u;u^ z*$FC@VZ_J7d)&oF%>A>=t+WSe>Omm*2%zyh?1Lrfq8jfZlkU3gqb2A%AGU_+u^`E` zyOxzmf(G}$fbcEc##%t#im|n1%{uu_U<5>JKK)<*WJ=X)ejRu1OkRVMm%Hv6zi< zoT`ZIcFvKRN-jO`u#h8fsN)r~4`B)Tm@()y(m>JxX{Tp$jq$u>4D zi5cF1L@<3ZL`f_0?3{&e0Sl#6>NPL)dn`i;X;4WYE$N)4XyBY^T}ggEag&9kFH^P@ z+eGC=Q2=3&K7>Cj>h<3vF>Z3c#^w z3U1*1a^9G_2A1bha~R5ve9ABZ12x)Q`OI(?3PvTK4I`~YI$=3Eh(Jx=@gi)z*x@m} zsKBD(ttadVy2D6qUE=pC80{Biv_I= zom`i={EC^(M(V7l@7m)6zqqw^?b0m+6P3rkqPfjg^AcW%4%g*Ky*tbwc6!2cnFO;7 zNioLJ7)0!5#}A(;Q}fd8HIbsPDiS#K`uqWwLdGo-inX{?UXB(P_W6#nCq`ErZr+?q zvk=942womtZe^G|?bD~CTgw4UfL^;3H}NuNl17(KxIU?}MGGJkMR~_zV3&$|W-2Fc zhT}qVlDCksg{^pf}K_N_MS&b@TgrcRSycmF4_f-qf|)81~)MYSznZI_OMj z_Gjq*SqWG;ey6qaFT4SG*rd=k9!pzQ^OnG`00e72<684|T8Wb8T+>=}9S`ecq0emN zJ!0cU?UfCej_%N_<^}B!MV46TPLJ=xe&`ie>kBuLr3&EW#Z-hm)t@3iRen}3GXu3= z@-;lb+(J`TZh_iXn{$psDgu-Q!lg%E!xXh9;M)oFY(nh%$(!)Yf>6C)S)Oi;6lDzU5qE z_GsV5{)$0$(bREuR7K#z2$@e)R+iC-Lk9j%xJMAL ztkQf$NRc^`-5^EQqhzx7vf8l^i>36{090~8ye0kK-+|c0G1c)ur}L;K;W1jW+X3r* zUsV+|5n211UsxpwhT6VkKqdA{75=v&$Z-lK4s{?CTCTwAy5WJi9s-eSC5J)de%JT{ z$HyJjE^~`}CoRkJQ%1wo&hEskhfrJyhAO}730Yh7`FB^tGUTQ^emY~CnL54*Oxiht z>nilApNI3OH@b1gKCYM`H$({gQHW5%QYiZhnt|(fGI8!s769Y~hog3fZD&OtNU4v( z@j7oKC?vjimvp2plzj$^hUlc2BqlQ44o+)ED;ur8Bk4#jr~yy2~C?g<_gp1 zCutptYe;A0+JcoCcB##u=y>mRn_a7F`bE2=<#rnfb%UcuW)%Q281n}5ue9Oq!S)yl z2FjBD=x4PQ$E-tVl;0nSyjBnDnpui@xw0}(qOiv?WZf9V4=HWTDl@(nR{LfwiNB`o z^y3>JNP~w3xs|<-j8jA%P#t)DT8|q61h-qraus!rv;?2frOE70;s?cs$n2WQ7+Sd2 z@5$7UcnAYZ3Fr9g)kxe<_ZNxRC^3@wdx@^(jY`Ix+kqWzt^I69{s`l z$yt}bGYYac+~>|3woE^nrIVqsfxWVUwZr?;`fJG>lVE6THO~8%ZDfJg=Fxsv;4{$s z=MY~WP9HaUufwHe_YCpw-uj8XUCOl+5U`F`1saO1{K|3{i0VTqtb=w^ki#qUw3Ydo zTidIndGkWA2`|M7^c`dK_i*xYpGOwlE3RR+s|vU6*x0U(pM~q}JH31-z37O>#ljer z8+gJ!psXRo^?skgvXht_MyR%q^#V83y?={*joA?}_ewK2fuAj&er`~}v>_OpeTL9R zEpLXn0BL;fZipZ_in>Ls1D4`pY>**;P4#jQ^_1hDHBgii-9lZMB3_&+iF+}=4IN|$ zzj3`i9f!0>`ePY{3iz_ab3SR@EsqUe5X7J{>=gX+dKUS z5#+11Ax$cTR4q?|nY30F@jPg;44xr7$oIF1ZnS^|jF9cpd&IW?R5nhQr{L=_D3Ii3 z7xG1E|EvWWl@U&5NzHY-yyCj_Bus)tyVL-De0CptZy`7UzoYVtxXj$ zzm1S0Nv6@)z6vcyRiV5#3@^={sD20Sdn{Gmv&3FKW6qonE4g+74)|eRnn0u+Kc4uUO#;Do@+gH>qS*k z#MUQjbtPWepzP{7skEEIj1hi#KGuBK^EYo7rLg#d{zIebeGunh^fPjv7>vXn6E{X@ zz_!u#fo+X-stm)21GNI`E8CdGXXV5Q6{*g8)533Fv)dZWcdhY09_{HD5cECgK^M$b zlmd+6TV(W)Wq#(J_QFMYVO@TkvC(AW(?DJ3K`9ws5jhRL-exz2GldLRtUj>?tpPfn zV+gC*W#5s<3)06(U^-1NbUEuXRf}=y#XW4F;ojoKC0u&zM47sU(+?QEdRViMb;+o} zu^PkHozcnp>>-V6mq@+1vzq>C<1&rSz+sEQDXht`>P(}n{|ZjlIwG<@zN>LrzWKj@ zXS{>~&Za^ts{e{fhBT~Q{wF4pXUS;C4rP*sN{@#EgC=$+2Z4bh21)qA1WcBIRW?f2 z4h@==!Ne*AR+(3ZZa`m#-o)N)<&zg^2(n)(@LQX3>DA(*@sC>C$APx(%K5qWy#0>1 zIR!N6eWf1ln)xr^-bRD(*XgdOkA)fF^l1A{&G4*-z28&9c8+_?#ASW9!hYxC1b!5o z2%NoFXxDCg*GSh0d)H{!@|-2RC;eOGCTa0o_kS3Od3D=#(7sD&88@*)46NETWL;tZ zrocY8D}`r?4%M=6-VB3!D3b9D6U^V%g-Qhbstypq$3+ZFgz(kuL2ET>j0(UjSgqFX z{R}PDJw@006&i$tVCkVf0DzwfPxK~RH{bF=n6dT{T6`BDh`K)_hiB}(gNe1^s@PM5 z?@g(#h5nlpzY@~5*Pq4Eb<}@@j#r&9F#t1Q1-j=!r7ggS#Cp8UIjKAv39+#s}pz;se?7;L==1Mbe(Fb&0s;DW^*vYFCs4T=kLl>eixd$V69p^*d& zVVD-3MTU~Tw68+4k{BWgVC<+N(THpd#TG_22U1x*ZiZIZ17oCVUsu*I2xUx(o`IcUP8&JX+}{~{tjT2HYfRs%i=D4h}Hw8 zN{wW!Tn%Yjy>N(+hWw0A!FxWsuDQRno>bLdv>J_(L#(|e(XgnC87CT7X~FXOJ%(Pq zw0(o2YYP6V*FlR6#bBP=avGPe28NmUv8^{dU#%(lvhlhm&P7Zo`aCb&CT>fOA_|g# zPNW+WvtT)hXOYDblqU`nSogfoiuh(1kpRo$!4O>CYnEXX2aI1ciUQFu*gXWPReIF4 zO*Q|t$Xr|2UXkknEYELbxWA_q2ob|L0#e2iS;p02`oy)l89TTq4sjJBO7Eo*(!c)~ z{|gc!^j}S4ky@hiqM$5fGR~Id(Ru=1%P9)a+X%1+YJtM8;ICj>3Prg?4ulp;`Hzt5 zcCy*Iu@AT8;QixShM-0hUyVT{keq~7I>gV&8NHYOAjY9o)@fs=&eb6LwoDy0K91>v zw7+35kynjvUGpKe{4cosER`+`osmwCTUUMRx(9u(!gfeb{59CSn~BHGvSbtAd=x;9 zoQ6?}R()VbF5EhmY(jB7KZ$*XN6^FtYp?HQxxpmWPMf>a&ap#&t+zg_d&sJV{c2Bg zu?$9%zVr%lk#lq2Oo|~EviRy`kn5rS7|qG5P@2l$hn^RaPrk?$|6aZuRHElNN!Nz(s8`miU=9%=|2$|6LXp663y0k^;sE9EGY z)&y@0=xE?#pwBuRb;s)~D9{@nb3YA>PYKw%MZX$`az3B@&0zBOfZy$K#ET%L!Ua-0 z_4iLf&}b@jXP>OZOnr~)Y3TwcQyNYXZN6TPo(E5s1G=fqtSp*NP9WlWb%kv|)zSUR(|GeZL~vL-FG{PtbV}Dgz7e~&^B$1E z>!ZS!PgES)rT2xn$F<1SbD?tk7Cee|gy5eaSUG_wk^_nh8Clpa`??IB zfm5T}>J}8Cp57>hkoH#KXUB)vg2O!Mpn73StBYX;>y%1$u%Sz98e>1u=L<@o_8+&( zt{CrP?qayZ>yN`M{cgtfqpcrd^Du{E{B}H?CFwEOu#ab>puNGHmhd205S>-o zG0MO-D=-R_mh#l-`*~c6dDQUdG${1G#;-Htl9yiZFHpA3lJUdkWqMFha4Ihtvm}KN zil0gcI~+flQlojdqojfiK^N1C1v(Z^9T4a9OZVxGKYq}QgjSg6aO7#~MXy{W=NpIGq9*NA>fb)luCj9to}rbr@}CC4shTEIWl zrAQN#XXQ4}=bVj!7Tb=siym|K;O%tO)=za;=L|jR^f8ydvt4NLx>e2RT#Q+W>T(3; zLiss{@iQ)d1Gf9h66i?kN7Za+53W~2Yb7o@nCPHkD!4nvt}$I(BP3>eEb=xt5CJZb zAT9KajK>D3dyjP!UX^X;`QOijf&Y)KcZ`lK;I>6$+qP|YYK#VaMn= zom6bwPCET^&Uxd$`7W5epx7ej>S4?Hqna9;u#<1g_-c|XAyWr(!?PM(z$4`vh$(X5p zzr_ow2z?pLwtm0Q%$q=hf3!KXcEFH-Ez?%mjiS#=ErW%{?=$Tk(OuU>v5bHG7noVJ zpQjr;>^CRWXpDB3Bavwv8-^D3)91GP3|eL(StX94=vB>lFJY-=D& zof?ucpGPRnHqu-WxPBRmDdDn%_N*FV;P-nZ`5i(0j=T{M_>J|oNY`_>nlLv(Y{en( z-mGlCU?HBreQ%b!6)xjq8gSRIqk~N|%o?aXO++kBEtH zfd$j9q2}OL-azK5l}G9(-*L9ex%@e_KNi1$Ajx$Jq7U1WCKqUbC$MfVBDAAFARFYG~1lPPK3$wgK;iH>*f^RR8fgfaD9SBzgT(Y`i|X zP&B->?FTtV4B<9Gs?&AO`!U%6WBpIC=yRl$x$^}UgTKHc-v0rM|GmGE_~Gbg;r0LW z1^m^NetePS{8LMv?K8@elhWo|i^`HZ(C*zK$=fuO8Ke%u&iwallO{){>(y^tL}NmR z!JUs}$StS;XvhsL%}mYocykJNiv;?=qW~k1N$O38LL-$>v0Dw=uew$S+ncVuR|foH zQS}qtiQI@^!pee`2T{Y?e#LR-!}xwpMwnVo^e=PA5yf@SF1&;&=Fp2$_EGoAi%is? z>W)=wl4CeiZ#iO0F0hMMP7BcFVSlTlSO2BcQsh!S73810=%kJuQh;U#F9PXa9I@qg!L*TPp^UaN0Q0+}nw5oY6LP_CMFKphb63T?&-aykC zatJoyf`Y0S^rE|g`xb1WK@0_vcpH|ATMZ{P!YO|Fr=N+}WTX)mFnS%z8>)`oJh|Vg z-)hkJW(p@hqi+?airm?Nmv^BVq_CLm{fH#N*U+?Am6g+dZ2Qr_?$eJJa5SKxluH(3%#e;~9oY0Ro(^ zP>6p)=PKV<@{9RGeZ7G*Kh}d@bL?Yg10*!=Y3Y(%k2i5 zidFC%-VZR7?n}_E|C`{ekegLf^OY52|FL5K@2rq=H2;tJfrFYs;vZGCZ@37DB|&;7 zQfMQI*mQ)leikk81YA_{tazjzMm_z=8f)vN^ybS(W$>0Is~4y%q!xLT+7vGw3)%cu zmNOe$|6cuJf#C~SDReZqcx6-=bd2|s;ptojd%6&s#Ix=_#&i0CTxL=FhHS$T=Rj*$ z{4TNX^9YJ0Avc`8x@tGPJ*xz_L06cTU*P_59mlu8g%`!?tyi;wq!wa&;hEkdIN{qO zMlE$e+q{NnLc$y+cwuZmMJ3E45jaR0WvpV8z(d3>kIuZ-WnJ-7m`@?R=;s963?t@+ z)cpcRA@ZRN3cPWOiv6-+Z9euS@wI-tMWn^~ITL)gd2=uclW&0yu+hSEJ&YEg-{ozE z0;Ftp3dIWTQ#*To+02Kk8ZULVU7p`^$z*M6HVYh7*8x_%{~AZCM#oYC~Ge}nCp3^)4jLWy*cTw%b^-u1fbgfeN zQX6f`IphA)%<@4RIQ5eG{4!fadU3FI`o19k8BFPdq(4_%z;9*`$#@ZRU9_^W2W;{N zoa3}4>X3;JcUl*D>RYnC#up;Exy=^r3Xwc{R1^Q3@M5@tx&HnYDfF)%{r}NU#l77u z{=zvvKRc%S8)9+w<*T9rYXLSStMjZ(uB#kV0aDKwgeIGg;D6R ztUX6@+$op1YL3SytU)14v)^d`ZYe7VN)(R}zpr~9sQGPJXA<;R6|vzxiu|t*1HQ0{ z4&A@Z@7}+SLB7NTNe=SV1yY+CbF4jDqEUyFWMrC-csVWiP0Vja7gfRW2(RzGvOh=a zxfU;;#OT^7w{g2{@0<>HT&Bn-n=EVHH`>1+R+@zFqwv_i=QS8O>ZBM7%WCC0X;he4_x=*%bYV zaBTBN`4b|9VV-A*nCz1bLCHVgg55(jlHJ}Ot+3)$XxYR5+C(AB1O^bByq)s$H7u#H zKkjE4LdaLn)s!eIH0}eK);@^*?=YCV#bZ62Y?cxfu-c*oRjkObOm6?zCtZ)R-puwZ zT?qf9uqD*3Oc+c;YNUqq>-&Hpk#37-`QrAltU)VWGO&N%Asy#Y} z)$eL*YRbTrewI+-XWW6o<~ydCCIJj&PjtqCHvL+{Vbt|z8icmJPcVGg%YGN&y(?MpHb%zU$Q%D1-CE_8@#?4Tv5wtos2$rdPa;n2RIKyig)EvUIbYG@x z=8}UUzcfqNQFLR&LSp#HIpdKsoBz8B_ia>-lYW(TB{Ucq>HlfM{}U^TuYgJaaB(nk z`yxL5PydbAP*B1Aj`uAyW5$BW91o3D0=q^u7(o-Alnf5L6(IyiiA$2$sXs>`NdT13 z_>*Qd9}!m=1K07aoIpvx^NzIR=0^v|StoI|T6bgWwez*-Rra-WMPXpiKR6&MuDfJ% z(hBW7D?3?o+6t?)=pJww7$G6xhE1yW)R;iYSKVWVF@!;hG3MTCsxg$+3}2>9$6a4S zjEO;Sp(3wnoAt*@e#jf^-l(ca4N=}55ssR@ z4QN{va4Bixy-NKnpeRX^2D#K(dPo;?A?y1YkzP5)1!+75JzmyGUXbpz`Hm0^-nj8r zKgq@60A`cUlqhYNS5AGu$Jo8=YcN5&{Z6hy&ml`wQil7BwDGX6o@*~5MD)M209CT? z^$*&VCqGXqXSu+(KlWcEZwGtGlU zfe6GsHQ(Vb4l=*1?0&f&D5+c`w5`A6>>(2e+$c<>pAb@kRcLXM-v&gTa;_cxyWe zwBU6>UoO9btyqDc)(|w0C~=M9X7(3QxdOl23oILsqB~}O9nOXOM(v~f++x9}z5IND zm-8DT`?X8=b;EBN)*0JGxPK0|l_Qv$vuNJh2;O0KzOz6rB>Le=N@0b7!9*_!G!>fU z_4wtWu43qL_@&e`MZjq}tsox8m+sD%yQwGtRh8gjRi>l#eSJ5my+;jOdow~|@mt^h zx8ZIeUom#V<>7<;N)g?~8dmILZ>#&s`~O;mV2URT%{qQ@q0j$+YU_u&g^Y#c|1FT5 z@`v@)7{j}&tu)3=l)~i ztOd?^t9wJZ8c%`ip?A|iDz~3HN6*QIeqc0^3$J9q8c^?G_Gigoc(C-2=n8U`VQz({ zevg%k-kQMmqLCx1>{GtTj>x>q3ghM^jvnJFJ}vk$36H(LeERtjundJ;`#;6WmN24 zHk&h;IM;)4ANo>4fSCFA!VwU*$Nf^f^no{>SutS8jI(58m?$Ei!)qO2Pf)cN9~0^9 z0hMuG;|(RZ944Y={Y&j$6E2`Fku=i3ZvNwi%j+9Byl3$dtxZ7lQH6B?L$NmjMGwxT z%Gd#t;>^Qs%ggFT>1Ma5T>whRH|_g-E)k=9M6N#7d-oip($|q3qvBVeY1WY|mW2;e zoky4H+yz<7@y$RmWodwl%Ek#F(pq~}sK*2xbECCfqo+j(v+S?m)P6q1soELhfwRU=fl5Uf^em@F$)k6;)dn*e2=n2Yewn*!)WJ zD9sHf*LL(Qt$!;VXW^d@8^7?;*%z{}wAK10G z3^Wa8x67}D!UA!qa-j!G)Bnm|^>X^+>3a7muOVELz)n2515r7*mp>qF$R7ZgM%gHN+dh8XzeAh0KOF;huvW3xy zA-PVHmD-1K9@bTC7YXBU(4}M`^M`B?<;@sazdF*QX%fym13Mm#DDV%uMDU~}%CAGy zl;izX3Q|HWV~(jY2FW6vp*Fmt5m{zw8+Je}JDH8C2=k~dyK?N`HoOL@WSkLz;#{$0 zY&1ae&mI^vjh!7dyG~%E$=ZNCQV$0V`RyPci z)}-?($8rmIDHA3Bh6m(D8RUm;fTub&<5UEp#qPK9Vc+s8#kQ@yxP3Uo&{$De%nl0A zNI#AD_qZm_9ls5G@A)ya%v=z7CI=M&V>yHyOq%v~?)P23k9J;!FeV=O92) z9cr;PtsQ{ac!2$%Jp$%>(4GKu{jzBb4zKlm@kl&iqjY2%uu(ix2iPbdxddz!jpPG1 z%0@N;8zoXTIC`zt>ZUb`!mL+Pl0Snf(4TFb`*2XLZ-F?dHn)v9>up|=u`+F5Nbi9} zskE&t;M4s~(fMp_x1~5LHn*)fvvjw$i2)(dvqhr**;2 zuIfz+1D-(5g&BX-AIv=Iu3dmBp{_m4{T!sB3q)1zS zy-9w+49KM*7aOcC!Yv&!B!OT}}%RH}}#B1Z-lJV2pyC&nOjkn;@X3=3j zV5{tK6R=fcQInyER>N~ca-hY04RXoNc((EG%Rse$1!kbyyf$X6xA{p<$}EVI1+yjE zymn-$Sa(WH<^zPQ4%Gp|b%&fQLoEQ|ibIh$Kf_7fR=@9)nXP`hliEp=4YscY!bY%v zX|};$Q+|YWrT!Bq+WK?nz`Q+wXTZF@aQBz1OE~~|7zy`4$t*G&Q)vDAgINT0$JuJp z|ESL?;K@bSg}40??EArTiz#zRZXGWlR3?w(1u~ntnJ@g{DXn zGl&$kPYbe@pb|t@_XM(S)RJf=sMbu->I59xq@ymWU>k!>0NA$N`Zef)_(j_^t&%nZ z$i4EX`>G~{{;R~<+bk^dTe1qBDtKY73VF8dsNYnIC_$zyX*sov!D;4U+RHK!>B%`0 zy72?mF*`BF%+#%U7@b@?BHlClFHK1p#3;3JGsyKZs((7^_0{`YTj`15LD_e4YyBz4 z4vp2dJUY0wiBkrfXkk+^W)O@JLw1ml3X!wXT;j2&^351_;&wk>Oar|AkslVyI5f0z zt6BB1ZIBcl^$E&L_4H?IMa_UL7oci5O&Hr_SORjHWohXd)I}cf4VD4T^nnOjrOJS- z=FzzcA9(?(8w+Xc03~BN=0({Cdt3W37AxM}21o4RH(7^$rw?~yhe{XzoefYO`1lM; zM6NA*i>w(NTt5DnmJOMW&8k%?IcIGb7J6`!LI)zgTN|3u4pLOxn%Du1ZY|geDqzOC zS`Wj%l*(ar3jf|RjZ~lkX$%hz_IQy97b-4v*P>{RL9~lYgERrm)=~#)Zzt7BI>epN z46ME{*2AK*oku5n2pP4Z%C3@Fm^2`q02~#Wn4)TEYZyC zHq$I>HWX(Ko&b{#?D@seQQgXp7X@WtdD;#o$4!Zs(9hKE?IMn>xF;#EqkQEj?`2bo za9mPcE_@Q_Q!f!{1gy4A;6wwOD*KlIhE`TYt*?$w)6V4Pi3kE9y`-cR@U!HkP6rvx z(2vge_)4`U8=Lu)skIE|D=}SSGjr=&JZj!5y-Oo1m|S3U&k3pKVsK^5!f=J&mc2_V zFox8G#4iMiokPTz4{PICNM;3JShrJxqq47oL z9C(|d#adaWEV0jAy~5Vs#!6H~abRVzhZj;D6HRhC3+Bpf%@sJx$Q4o*Wdl(Q@G-C) zj^2(8{>%8}l(y<(1cQ@wtE{wQ9eWc%F>inOO1^L?(MbI7qLl>139!>x(@>}Ii}=oJ zS=iNpOSky+3K%C~QZo9bKtKf7A_H{zS50;NOg8fm1K48KpJt`(p;$PWTx~@lFcCXe zvsb&=R-(_->4CuHS?#5lDM3@mEL_74iTFu;+3_`5Wa&Djnld(IYMn?vE{I~pQVJ*t zi`t-Kny2B})Mb9;0eMIoMu4~D{+SoqCJ`t92;Ex{C+E;}klGo1!G}?sEHdQl3(y#d z02?CV+9vA7Vr?n^Mt#_iCpso+3(+QhKx~+mKowKcJIRgNHYfLyJb^L(w&f-^T4qAMjOlhW#e$=`^Az}}*WeMM2h2hI}i3aFZS z9)WhCk%U<#hRzl^oGV1Fd9A-0<^(gfgxcz`Mi-0*)I_LRcD}y6^tBRrITW`r=;5Cd zR}dxzcG28jKgW*bL5o*5Nlpu$EqRG%jJn-Sp2nZTF5Bk=l4BUcb2|J~^ z@pk-9wsHtsvQ8mKJTPZN(rx9#ZLx@qXHlaavo98iKU1ePYG1 zc+=%DnN4w+q+vzk+Nb5lmg=QN^nZdGqhPEpEugrUdfsy6_tl<);G^J;Z5+smJnUVb z^V0sl8zlNEFQ&( z-WDWqOM2oh;!m-|nUJ^tTs^E^wN$bXpVn&DUTa}I$HtgDj;Vdd7D;jUIIDz$;Q+>`1iKm+o`rZouM#8EmhC_H3W4Ymkx zl;nYEm--!ZTAVAS?KxGJ^zM~)mJ(LB2{|>3LVDBM3l43f#4t>`Kt_A_4uExy)ES%} zaaDqvZBt!>CF=SGudD{xm=`ydExaIMSY2;@t0uLm<#h|Hz2=B;RKhPBt{%T~t275} z4NyB^LW{m_N{jmp4^QHbiD*T`Aif-}t#>Ggza3C-%MSim)YU{b9043a1!p2ZTO|kOFiBqhzL6VWr45lnd%{_z}nV!Zk3j0~a42=SOMrf%g37ec3=TmY6Hyv9}xyTZ-WO`6J?oJZSe&@OgDau!`f`Ek7faKJ?S_QX@Rl22cVNs_1_(CH*1p%*f z5neIJ1c4%BBGnjRV~%f}VHi0RJ%8R0Rbet4*qjKy5205lwWk*q=%G&uh8_yb=`5fu zzWt3ro$R}J@BB?$0@Q1!07XKIW^BjW8B&(&6WKZv00!aSBrbpHB@#6fpNWa-;rM9% zg48}-%}V@rZ{ls-l#EW;!5xQ}V+9n{NX_`f%CkiQs_B30VeAP4EUDJw5n*E_*}qpvdnZrQL8e zHoOcAjBK44O}`KxV!OT$9=xmmYXuV5}Ec zvUqOEQ^H4HJsK{Cs2PW35gj9Z+d-oNhJW8bMY((M&%_}cAypAde(=OWdI^fg?dl>4 zJyHGH4uc+b3xZe==3kAajJT`BVh_nyZz;uzb&XB$8iltnKBpFq3OM?E<1KEfQtN&FIpqw09014led4s4j!OBPM2-AiA0xX=KhWQ)EYL@3 zh3>^TJsV_gO}dDrOxsD&$TlicSc2DB!2sBHv3D_AvvOr zCc^>fJrl-wv=Wz2;;?lxK1!_L^tt@*UR!&ALTP4a2oqk)ys3HKGd9n4B80M@>g_PF z^$XN~miY9Q^dihER1Ko1l~|>^TNKn?Ny1*SxbvQj$?n_sy`xqGshwe3kus$ebyCt@ zeq)Kpl&bb?JvSP#>1Yd5338<&)jDat{oO66rprT_tVfY1D=8vhj8dE|FjY|(w+B_X zyV<+ulg(&3*tSf!H}Yh)M~voR11mmE=CrueMN{6&V!wnf%trPtb+S5)uv7b5?n%*q z6m>PpFu;VCUmV<7DID{`_^wiQqL3_IfG@JfISvT=IKkmG6;RW6e{ZzFl?3rQ<6yc* zJJgF;j5xv5nT77}=Wnt-xMjpi8rY;~JV2Z{SZ1{LH$zbEiCAgnZY5mf5Fy1VcEUmQX}W7;3(PK*JkR)Wsr3sxssb|*lJ}~dfR=l z9LCKqD3Wp#GD<|rO92ruD&&viz~j1+hK7|h=ixK>wjoP9G;W0Q3rV-h0;%4b31Urz zJ)8x^&9yqY6+lItw_oN0eyVuKpCeI(DrU0#!o4e*D3J| zmR4rxwY`v4`-=PC_IObElZCP`E7XSGb{Ts#ecX0x&R#z~GAQ_Y0Ud|9Kbi+3;FY!u zK2~2Rn2m2@*Vw-U=9t)b2+mW>%vuT=g^RoP8!v?7acS5V%55LyrbJ$fnkUJIyHFO< ztRYpx_KluNwNKM(6k~j>$}=2wJxPD|Jj%?4v4wS2izpss7KC!O57>=prgi^_FJ3+@ zn^Z3!$t{993JY}7@IWV%i1+A5%xcxVELf@z>Kg7y(RcjHhU*|b%sHpC5rWK;e`mGO z7fsIky;(rg4grh}3B3mATEkjq(|gag(KE4icIS(vE?sdwb<~{8;{PQ+>A%r9>Q(z+`byp244%~BUP;GR7 zvFej5YLJq9(1`xTQ_xnI$!kWyN1u`Ahu}BU@#25j^@>f2|YnYEiPf)xzI&A z>t0^1xLY&AX1a^sw+6#TP%Pf+udpM4z@x(>hh=Yw;ZRM7#v?)fnS0H!rj8XY0+X;L zNxP3hFL<))h6^d4_wqs$C>Jk%K3M+mq}GqBpWr>gLFZs-V8PfdQ5B}9u*%kuSK8nj ztsi#wj|o1@mZW=cyS``88*)z3M(U(9&`!w~+`B~kqTU?2p;DbX+%tT@T2g+0(=biti6%6mGr5?V^FmJ5T1d~pC&7(ZhLUj_w^Y>Vy&DddT;Tzz#=UUpR_U|ST?1@F%(&!llx6lt7tAi+X=+C^f zHC3>^0rYS)gt!)+9e!TX-7`^j2dM5JZ>+$J5#Hz!2kj>RzV+v0E@+Pn}N4>D1|Q_XVo6~nwV z^XpP4)-5@~pXLvSidMF{{3fh3!-hRk@RvPNyA^Ev~!C!KKOBYl~t#myp_HxcND4Pz^} zP8!4YzzLL|2$US{k*IiAhtNuxZ}_ZDF&_kcc)21dR7G^sC!#EK!?P=K68`GM$>5r5 zmQ>HJ98m4!JEtRLyqe~J=is0MUt-ODQMZ(ET>|nH3XYJ zljX3c#T-DfHd+lmT`VpotAKn`+^xovbg_0% zi&fisY9hP!<)0^R18+QcZoDwTJYcnR%(~G#w&EP6SXiV-4|5#%Yw>il0(=>GYxb)y zjr2L4@K+={Og>3+=8Ai3b&LLT#7@sBYwewB0v_B*b*2hItS6-VIaFOH9p3t3FITrw z1+IJaSN)_(EmkZ1lzTF4QlFTv8|fSRdVi|}ASZJ3^GDFLL@m{97Kwp3f?n`vsE-wO zpK9IxeACe+LXq_FS|AMqWouhF9<61b@SH(Qasudf9ypv;J&jh7qdsj)*9Y-Fl22OC*N6kmE0|ij7Hjb_iFo?Tg{zD&A|u-23H}``HBoHygI6yZi1*L(QL^7X z_>k^*i$u}*Hh53PS-V#MDuD88)#5R|johq$iiGAWCF^n+yj^)gxNO0}p#<5^R2Rye zbE-3%!fR5pwVQHnL&Tn@I_+_&I+|ZtBp3~J*)-3FSQ(c&q3Bw*JevfM4?i@gNv|5 z-J_^W29nQ-e1o-=9RYx~n_bJnL3&C!EIgr=OFLUI8IL0kGb5NB-C4O_Cq4Xn_+0|g z0Q+Mu_mdbkDu$Vl?A!07sI$AVa+-{{A0>_c^=ln&jfSRA$(f*=t_G~En!WF(B? zj(;4;D8b*_%9jMAf&~9=@h9z6=Qs_2f9Kvkfe%IsG*HLW?A>;~H}-=;jB~meaSwuR z+;rhw^)N$|FeFQQ%_iI&a~~nV$CU_h8&BbNgQW$9e~MKtx2r>ks#bS*3lY>EpjeV! zu}4l3Nm!yp#cgN#{1e3^?Lvbbpk0Zw^UVj>K^we}2;#r7KKDnzu;+qF2S*CW(N-kU zRSR)VeBbL(Auu}&Yay_FnGCJsqglp7M=?!>v4kd_>EsS>Fuw2F;jF{Rdn*^Px@259 z$YQ>u~F_A>cA*;I)N#j zY*QshgZ+!OAC0P$LuGoR@v;}W#qW)>Kp4tscUI$qvy49>SuxgEvFhZ*)ZeLtBVMC# zk*8`!6Qlnd%)2f@j*EH|qk`t7Q4)z)4|U+))L>0%r!h^Q6WdbxFE~q+fZ9;hdlDDt zdiu##xZp|;Cw2wc*wr-DK`9SK=SsF6KGOkDI*vO7qF~Tk5%t_vr;5-yMBXtGkTXoG z!L$-)n;N&xuV4nYiR(6JT3Onv1dRENZShvP&x*>ygW%|a?xbJ;2)A?%TghO3DIBf_ zj_7LC$wgOI8oApriBza}(!qmm$=!B-D;jPDRj(i5uQG&BWH17`A^U0IP- zXD31~LIf6vkF{rp5A9p3qO!(N5$G-^=zQLnb%;}z1>Ji9&Wr=mv|csB#2@Rb`osl7 zU~2B?K9@v|qoErSr(bBX0y{iy(S{ceV%*9r@y@LW)#^-~JoZ6$Bg{#LK)(blM+d^Q z4n~+IHo}7Jw~3{aM?A{i^b-j&F)_ab-v0OxeJ!MVhNpxTzR-TomKk|btMSpHjM)4k zuenjqE*@WW&>9tHy+)3TEfMN~psoXj;*^WBUiShAnSe#5u z+g{-M`pD?Fl#60WM1-^&M~7Zggan8qXyuU~5UKb@sk=Z;ZuHDxzX&NS9;qZ5?^5)> zBAn6U)e9=~gC;sGfASMMaS{C5K=(iB3PPB7&w7*6~MIN;%V zjF`>-=UxmH0p5C0v||U=WlWtj3U;OcFlueIAc_A{MOY{rz`at(ABJ z83aizW!1vEs@*YR^@5Z+M{^G8@WlN-x>VL-U50ob@)9f(!cU?NCoeBLxE`npD^QGs z8j_64nCBg7$9?DMO@EX^))u4wWIqE-o7yKJW9lv#q<#m<4h;RIqK zEQ9fnMl~fT+KRS1hdX}kJAA`T6y)oMAA-E90!^^7Ght&o{OW{K3gA?>DXmXM?{rfxz-{UiLTv`B1;G$%WJc8IWbnMe5*}Vn~fBIm#^te zvezMg99?)gp!v?SFR5gm;P~MC3`Z4t!9v?Ed#Nk^?$CKKyikd{iH~6RDE2i|RlpFz z6%e9U`yCm+XSz%UHLcQfKIqSk4B`QSDEIgdW!43NnL*}Rtl(3;;OHL@LRW~1!}tG~ za2b)-5X*>go8Noh4j+rsw;U|4iOXHOK5|aF#!|??o}7cT8ahJZVQB}O%EmOx@UHprOm;EbU*?FkbEl_P3wPKxTzPR`=*LgXa#-N9$t$e)si-6tDZ_eA% zgGv6}CPFpbEhPSW*Y`g6-(ecl*lFfF1j~Qi?RC<$2N%5A?O&-+pycs7IG;|@Tf|nR zPt)ao^S+u|jgIu5`fX;Mlk{raN%7Wn#uS8pt4t#s>Fx~saP233oli)~f`!R43vN>d@B5Sfg~)ezAa8Goy#gY8w+!#6ke^xYF>> zExBhP4BVKkAXBDyM7}An8S)Ln*^?JF2D!wMOvwn7CBIlCdQJwfUPEfIw_wGiX;=rg zggkpEWLnfuhR|16p=NT2+1Vx^xHM&hBYl!lA$IYalnv-T@aZ_pmn%8D)UG%smAqF^ zS@jkuxseHYpjqR(J=ijg)3XpcIi9jx&u~wb+EvpKN`JXt68XrO`DG?APKcWICPVd> zR+YC;@X@^wdn-hz&g83Xa;R_k27lMWxW37AdFDxyC29%3MUzZpAvPKTaW{d?KU`o| zOaEe{7ufOhn>Y_=j~iYRN?yl`El;x5osUr)G`3dMWa8vBkd>4`li#zb4&{=Yw)5Zm z5Ls1Qbw?s6vu>VyQ(V?d-zk2tDBGEuLQY@SUgFvPhO%iJf3In1gkEjbMYb6AoZ}vS z){+f!M9B)$4W2k0U~naZwW9ExAE2{>y%wA40)-+ed3?zUM!vZnZ{e6}0f9Yh{Kq>V z1!f*Qw?HL2B6w|{B`(P+9Hb6O&YD{&v4xbz8gqYc=b!BEay>&RNfwVs_j1pEk~Y9k z(VlLa6>A>%w~O7q(#l^k#3o$ZInsNMKSj4(QAB0luMb#2-n`aSYsJv<+zEsrZXIpR z=@$F&Md`UfSQu3Vlux~h;~$2;W@GO( zY^PO@;4ving^qjsbh|#sOdF8b9`e9G*KhHdm-z9%vQF-JiIc1n7Ke1@YLVW147=G4 z3EW=#Bc}J4Hc;0&P5TX+!S?rcG$dsF?Z2l2<&Ozpc>JSXpVxZWIJ~VS?E@+~8cX3< z93Dv=86Hs3*TxIV+KQaiDLt~XL)h70LJ{b&jH&k-4(OA$WamzquGuVO7XZ z%+G?WM+azoN6ttha8A|?jh7oZ8_aa#pzPt4h&%^W5x7+k&UaT9+ow8VV{1hTSY&r( z?ORuNypvywhG1i)Cn%8Bgq#TPJlUn}C*ivW>_M;!;?*N@dGX@ABT6R%hq-)d0?duD zxoU8mHXMy_Y9=t4M+)*H%+HgvDb~ZxkLVENDt#|VRD{+Hj1C_dA?uM&E43jBhUohK zsy7~QFOnm0wYr|Gcb#7f@IJc@a=I_ro#hU8z(zNvdA?`QyGKA$vpAI)y6XNAP|U=g zFc+x7+|sm8sNkl3HT>1%r3Z6^MQj-n323W#Y!wv-l_G9$SG*0qjD$zAR_5D(EZ`uzJp~Gx^ zN{-uf4qi;+kjxNO&xXd_(p_WnsI+UG;W6Ft&#k1>CD7TXwRd*)-Ic#(o-nb+jAMO1 z0gq+M$+0X(g6%5iJD9M$rPRn2G+tyzMSZILfSc=>h9Nc~I%<}nb9!eNu%E_*0^AX2cap}YW6>8i3j!AZV62_u%dR`Jc+dcRA zdOJl&q!|xWr{tD#eUFUOEErb_Jw?y5?x-Rbm%M#G_xuAQ+MMc{`F))kUd!)#CO7o) z1*?NPQt^o(vY=iYV0yKDNjP|W?wNN!Gz8~ zgZsKF#~@?6IUQT@!B`uQrFrh)jS;x1d@)r8eZI97$zKY3#)5_|X!g&_7MX584wr@> zvk9INtcK)ap|z#T*wX_ue0olg5(qho9?CZ@M2~s#`v;lC;eOK)v8IIbCV2kNKDNE5 z@+!&mt~VLWJ%+!!mwfh4c^6vsFW3`SaWAasoNc?hck_twE;#)Zj?H%{IPRErMJDlg z%7tb(J0AKm!4l*dYXBE`z9Mz>*VF@E$luE<)W$R0M&?F<$!jW%C$q&;mbbrwI}9CR zR?b@we%eegDja?&%#7mhiuUfNPSSx~;3+3#>?a!OhjQfh6V8_c6-;auJLw3Ww3HT8 zSzeAHTV5d5B}J}0wcx;-BMM56Tvu8;RefC2g(2xq-XlF$mb_^vFwFd*EoJ7_p%hVg zT~^!By#{vO$~I4eiyzme{t1R1=FS;yvq{lZmOG8t=CeSM3%hYE zi3_g}T0k%d%B*XVffnQGy!2Dm__nl<+8@Qyegz)tb-9L9Xw{AG_y_uNJ4*lCUSq;j ztK^=Ly3#-~!dr=_po~oweo+{Rq*G{?q@u4!j5ET4@?EVt*lmJvNgBqCW7y^yfEX4K zo)1<^bcSNgbBc0`O_i??|3f=Dz?>3aoG01O1$i}5UnXY!QFLj#G;TxE zGCBA6?g5UPoFjGHfwBuzXKpQ79oP>-(G3JlCswpOVTmv$6m%vrD2(6&6utwVRB%ts ztX;pX-4GwvI!KA(6iXDY%VExex`IZj-o^=OcWSa;0&~*p>#8kX%)SqF$IONHL1=MeP znby3~)f^Z!vX>M|o|1&%VoIhb%rr|zV8^gYF`f<4YtD*JxpPRgou$=A7;3ZFU9XWR z)p_#5`$`Tb;#m2y`MB`)k;=5Wj{b9 zAUFDh`CHqK`E{vrn7dxT2i}Ez$J@gi5V12<fOLNRzBeKtwC)5&C7Mw|233 zake?zrQ?pl@nARcPEj*|{kI-Uby+n+eujkmTUwWC)5!Zo2x`mwm9d=#!2o6rn!mpB3rBEYj%5wM06v%|beX0`vceta}R1 zBhbzhoCZw8{qQ5U6Fv@=CLSDw(ueGKuuBcDOxFv~2%w1zwRo zYM&KEA9d+#6#4>@1a0YCqo%aD!^KhL!2g7(k$Ysqsu1yCZlVHv!Gv zs>ZUg2j^qwzndr)4kRd3&4zSZ7s*Y5m?m?swOW@ti2>p@+GX(>`UQ8alOd=5cBPCg z2&tBl)(55VgGn$Z_*wI^QfIxE81^p4jX%0gZ(=cjXosF7vrEe6w!llS$;xej6C8+o zYJyfSIQ%EUl)HCSeU%2osu`kNdT0@fZ*KZtAk-$0p}3tPu%K#9^KjsaUz@TnB@oCH zPl-&Rs|iEr&PXNA;}6bk5DU0WNU~+LPJ!TfePJ;o4 z9!%R(4Eeo_lht-j>*sPD8iS{3E0i9^%>vyM8B(<^$MexEMjhkaDSF1$d8=BZi_*MVu- z?VYwg4C#c%C&Ed@ZW&_hsvit-f7KqBgXgoe1NYh(qoYFmqJunM;iLKBXA1Vkq5P0X zRM@(%cw={j_~&>6-vEhQ(5W@P%`=`BBkryMG1lU7`ir!xZ8*^noq17Z!xa7=Wjn^z zc}qz<6c0$L<=RxkWoE1zt|{@PAI@dx+LoN3bX^{0oN-ig_ZaIe+&kL3i!K>Cx`kj* zRFSUGak`D7&ZU7U}9qY@Z{iZNKp|6bc0LWrq*yGrg*FvuY6YFnT zH18I$kiPTWJ2xaiPTZh#)p8dVp9c9lJ`I&mTD;^5=gX>zC($hLe;acqJr z0Ll?%Tga|NA)e>d$%Mi?-b+ruIH3pL;{a|Wxks*Z(apmCjUP`|05toK32sqANW}}@ zV;|>@^Alg%H;-VBfan=x>~%VTa|+u+iDtB+N;p#UU3-DLb)hOQ*{-^dTl1p2W(7@+ z5nNk9L!?T-TIYg+W_Ij(x<((6ae<+` zqSr$pcecovqMU-i8TbGS>czX>>q*?~dm=^0DaM1GRUjOO5YCnb+aex6zhdFo#ukHX ziWVapwq>U!3u_#r-78uoPmKeUmi`;OW7}ngE=T#YbUr9fK(VUx7s#2*txF2)x zJ3{GeUN&2Td*0}YQ<07&+IxV7C1!&;6VFH@5x=)$)X=7sx>(VeSw*l ze#FS~c!*0Qx}rInL9}x`aNf$W5M zle(WYIw>Wm2Qxj=HLTUforB2CRVd*&&nH}W0_WC#j)7Q#96pc|jQSrq5bVya5^ z`aRV63ZD=U2kDhHtvya5)@AzKYE8G%@J@yh?~hOX9V0?IY}8*`9+_zN#A%>v#1{Xx zLY-h;P2O0IG8VrQUNp{~p7qmzGt(eXl3BGl9=)=DD1U+LnCpV?zS!Z{Wv(m9Ur$f8 zt93D6yCOiTg>0!S#!_8r+0q>U)XF~ZU2Sbq<3fiA_j*u`V^QvcqHDA*tx#`QYOdvm z3E#f`=w8whY5w^`+GZBw&zRSQKDfi);EyS+@DUnR7ezJ)1DaYAdRDrna;EX%zl8*c z;heLM8I+~RF+A0+Vr>38d2~^PH>#{}FeK`PMb++mM@xmHNeo3f!Z4aUL-&e%y{O&G zCDfcL%9keC3I4nw=GHt|#(eNr<`7iPt_jc=RLr{`*h{mGq&9pKYTC1jiB%Y5M=LUi z(if%;>mJ#>hTUR0tvlqkS~u7m+h-HkAc8zmy}q`!IX!Y{Pu{JmbvK?AqVN1-VNZj; zI0e&x_6$d!p^!FW5%V3`)kH~HVY|N$L@fl!eh%XpjC`mMHZ^Xf4c{!tD+&%_6wQBr zxXb*)@54f0r9qHaC$!;68PXARjB^uep72w@^;#lUzS+vv_6ruiCk-w*8pYEQt+(Z% z{RsHMX>Os$TfgL<8u`f*t7gYgFJS6G^%J;OI1Vu{coq!25zzM_>c9m8*j}(M0rn={ zk38)IZ-F}ISHx~C1nUC}<04fkuW>FUxplDja2N8f_1=`G>%SZHnous}oHPYG2yg@= z*9EZ+0xjWiglA2-0K_RWwZ`rM@e~Dnb1(oDdldg5^jW11=VwxMo_>8i0D?W_Yv2i_ z^nl*AwGu4nSGIo^FFxK(xO>cIIL%`(hbKIAN1PX}+jeS^FhJ8;=_3Sq3P8X!hxf$- zHh5eppSpgJbiWF&c!9j!A=*r@?dp33@L?9^@5~tA1KS*@Py2gt03Ruj$2@Uu(#q8m zuq6yHTazv&rE`}D+^7>SU9L@DT+>WrQHcJ*G`a!w)V^u3 zFxGAZ)SgC1n%XF4Lc){4I}Citq9)d3DpPJYX^Ekx(5M;qWDe&{39|@{o?o~I-65b2 z#o~Zq?c!ZJe0_d>+a*gq*C2nHX+KpV&})yAyjd<>xKSE?-et4nMkA*^*_Y9id01B8 zELy)P#o2G1Pi6WrIx9 z^y9U>yDqN^#~ra<+bmIB8Ev>mXSN|2yL1S->d(=pvy#|lN1CDMJ5D06f8<+_^JxYU zz}e$S{lF5)gG_r82>QFSBO||DLXR~E1Sf>ag3vZCVr4sGA>68eZEVHZI}`d5k3(i%njO7&N?*+L8@bR>^K~_*Z?( zZuH`nAIKWn2v4J<$gT>$BoEe*7Ott9;C5yt)kTx`)sRrsUyPsGuxLWm3`}2&-*b0{ zcY(wV*sVy9HnMyC>dcilMwk;>4|E3dOw*gf2a4I8xOU;PYq}@{JjFeNpm$H#L2$lo zoe_~Rg_tS;Vb~f!x9cPwHC(oQsBzb&|L!xM0}pG{KI@q_A^sZRqcT?+`J)80@k*+q z5f|V!=X?vVeB_sX(wDg>n5*{7=T{zgQ8c_QdGe!JPh`_bO zbUxTcr&!*p2QQ5W?83)>Qjm~m>Tx4`KlHyS7GDervpYm2>z+kv-3ssq1b*x4=N z(ZS|>B*%wBoF!5IcO_Gls1X`lqL5^E0lO9~ij`h}oY{j75SOj9u#B@oS)LmnO6C?> z5rwQBMcUTP(6O#0`Hl1kZy@Z!x(WAlqAG9b)`XK3&MXPSgYZ2nfmqIo@mQvpz&!+k z1Q9q|UXMiz~D_a~=5wW%mt z-WeYC&$D2EP!~HlluYB?@f?Ujo!jC#k0gbpKRiUs`~s)cbdgFNc6!s4yQ~ZTV%EcHz26DvN-CiJ4G!D2!o-l2@PyNAX$sVOWaVUF8yW&0OjBTGW&Ur|?;YH_+9n2ct zn=#IR&^Y9c`GYUP9b1?+YINej%0D%=Ac&(2+FqkG;(H(A7H3rM?ievLBZA@Z0gYPM~v2}XqroME=)`}o$w7QTyOxH@nb z+A@|u6w<;#i3UfAMpik|Sgm!vFkKj-oFqmzgn**JCkVH}TJ0P|=P~j&TY#Jh2n$_K zDyzh+quDr};C=Q+`vurh^W>((-`gM!ij{GtV}_45j)l*xe$8d$;b+GUJcgPM*`dI8 z`4`xl_@y02;dY8Gw5X!Y1(FU}ib+XB%FR*SV=dj$I&ts-1~yMCi^AU$pOvlWPLRs> zX7gZA8U28?*^7F_wXZtysH!)@;fqB+{Pip=%h$7)kLkhB{q~PvXU^rHIPlk}r(L8? zd$gWKJaKY0e*Q&<+s%~P=2-_Zo(QPhMuQ7Z_u3rQ{#OTRs;$xA=F6TuJpY2EGH~2g zPps6I`N;@UoXR|Nh;gYGv$zk5_?ea1xajFlf$&G)_A>{b^)>NKIB1-G4{yfVza?UM z_cf=GUu~3L4M=++X|f)sINeqte-YL*Ov{@iJedD9J1L$*A$Wr2aRlhh$)z=C|88Ee z-Z*Wx1$0mE0Q(Y&K3-5% z|Ad$$)Iqw6O{fLHVJ94!Q&$tjx?*Ve9*aUkB|+>7Y1~P;;zP&Jy27(Y)#GGdq#OKe ziC1rz55;|O+XHKXK%9Bq<8lS@Pbd=1U!)Gne3&uwRmR>we&16GM0*XcCgi@H9V+;M zn|{ciADGYEeb{Uy=1PR#!dSxVOGw;BT0rS5ARMGFl6iqtAE?ixye<+EDqRqJXEO!~nutH3 zE*yIXJ2GyXYEBfiT5o-|W*<(f)n8#&v_HfyM8234KU7zedq+I(IM#lBk>gB!4~N{f zu3>)h^F;af#q1L_n0}C;?-MjGf1tP`e@A8a3z(nWF|3(>;IxGMPHMflUAlhpZ4USv z*52!{D||3KQS1&E|3aasyrHAz*I?vV{=+W>$uC98uVT?7Saeqy6kCg;`vN|nY>%A& zVK$$=OXhJ4G0gAPc{-jOVsOGXAK6Re0Ymi`A#W6SN*>a;skn#1MXYcbQBSNdiv(um zPl+lKu4I&sNoPg$j9TBzDHDZ(5lQUOo<>-MhB6#&l+dP)OW6{xd>5CNQ0Mr9=(+Z| z;>rC*;?BFv$$|i)vJ)pw=e~brfRYSjvMW074B(YZ>sWi_nsu|8?$;p8 zcC2+?Z&rr$YMZU*2dcuv1jkKixhLjJhHod5nS;vqG{t?3_}i$n<)rz z##odRU`kAi;4iw5sE1sLIs~8)qy}_Nea6ft~uZeE%z@C!UEIUpHo6Y)bpjt-H)a9{ z{8;YT(T#Umu`Q>Jjy8L-u3*5;nsr3WTI6OBFUk!z8i~`;E4@LXvZwrg?|l~R^Kkp? z9Y2b*KYya^DMpokz%1aeGuF}-oo2?qPDxodC%x5Cf)0>zEGkZAW3u^8lKIU-!=my= zXA}IDuB@5PWUG4a^uY{;vL^@6ej$-FrR#|H&6CemVtF@F{KT{ewWVv$7eSk*r|VXZ zgKuksic)5@VZe_~?M#~%q&;F$4)hjY7 z0$2T5YUWDbN(Z-fDv1ftlOD|CU0H+JxdX8wc zdnX8s=m%sqRu7z7f|M-MN(SykJN;BNiQTktl1tr4d>>ky@hrKBr@lh6wfW-65s} zFqc}Eq*{1lzh92<40>q-oe`b8U=}<$0QSC#GqH(g^R0n!eyYOyOo)N^D=r zI{fcc1)73J~u zj&R@loPAq%#jZieVF;V1mpHWW*fo#od9P{q zF#9#OeQnpsmzZs`9`ol2g7wsWflJRjly|X@DcA7b7r{H8StQ?ErF{i{y^mp;VR}7! z*9Xmn`^BQ+*_0@KO0Hg6>93^UAMWL^nat6>4Bj6w=`+2F?B8Op=sK<_x~3sxN$CZ( zm-LRNDVS8AVV_6*M)_0dKv0Afk=9l-G%YLkEufcTKpodP(m4aOn&? z$zb~|T(Td8FvIqaZEJKAW2{`tuE~W*m|SY;lMW5C*9-{p2S+w9E-4vDljPwIpiAkJ|BwOD*P$9-U(!Qyxn!q{CY1YcVqqTt>*kxNX@`k z(6ZVH+yn^dTb}<#p*f$t><70iz9G{RIswrbO z#?7p-l1O3_rbCG{W_qvTm~2D(lMrtg6Cc}d2)9Y38FOt&A7luWnYXH-Lw{SqDl#*U0-!m zg5ge3+}CGi&H^=<^oy(}2%?{4MztV{Yv%<%5aD;<{_+j#Qja5p$u8te2OL;Hq?+FK zWJ;DSx>5;(tJSFYM6WvQBF!&M=-9K>W>rM zb2yfLWYZ@2CXhK|aH(9ApA6=$(nx>h(>f;qOiWKW2E-Szo@iI2N^~E$UcHuKRM6zMnzzIjS}m}grHb{S z7qFbEi}kE2-i4{PaDl~zW?W>lzg0Jib%#D^t>4RI9=N?&o{~F?@>>_~VqkSY55gy$ z;I6#P^Hmu_=jTO#Q9Qk=;82lVeWv{^AM23xz&%B?2_7u{+!q}hh;=g9nkO-~smeB$kQyLA zGGCWWkf*{fF%;RfP6I<;WavyxpT#ffc!Zb;1WRPB7=BBMzS=i*qgEW2CfH=Fq{*>p z)YZA;=nc6H3}&sYbV8-KwO!q&>lBzh&q(f>&+3L~TOBU+*ArG#=Y2GAk;avdbis`y zn5deWYkgQLE^~sx`Xx|M-=cl|83bM8%RiBRQ$wMvaNIV?U33%DrfUa-Fk#{*Z&ZWc z!KYTJeU7be?qW$!6361RBjtGeIw-$?6B#PI?S!7ERt-y%X9I(`CTuNtgm*~(oVi<2 z6H*^lmd}t3*CtDUevH`W9?0?;vc%FY*)%0W!xEuZvb;?hrM5uTxyeogW43+nKZ)?S zgSRuYd@pB0sN<+KV2(v>xko*5aJtU*pF1T>!ctbO%deQ^XbPV(EGkNKcBXE`?upp8K|y5<1_VUUqM{$=s6yWQ7w-Rn2{F zX7=-1oN2EznK}S`9#Ph|!jUPJ(}!FjoG?`;#vrlw$lzqt7Kps|=|6ZvGnt;?>r6Vs z5S>nO2%*yiy2i!)c*E8r<+4j{9aI8XrQq?%%?#<4A#uT0 zlw4{@@efOkj>XiVJp2JRswCq)Rs#3=*b@Az?}<0dfA1@)3qE( zmrReuo?6`ldTO=x3d@<7){pS-u^zFX`8y}?6|sNw-_kHDXJ7iyoqXEfLPD3Hy^7!B zYgNAYrq3~aT7S%~+OK~M79;xeS-pj5-x{TNwJsQ6i8F_t&TjGLo{{k#wU8G;`_O!% zHcKL6kuylG7dj5LGbpj=UUymahzu8d`xJayAH}0%&U|`iXT<9g7?VUE0k|bHhn##; zGYb%7uN|`Z)urRo-f>lnN6ZBXDHP|>?eYq#spnWfQv&_E#J4H50XFWHIV76^o!6=y zirwXhBZ=F0r*1``%Ge}8fCDdkZatSbUU;Ve{jrGZ-sB`f%knt}Px+y^ zD`o})i||J8=g6$?ys7Mkz=&K^kL$-GK0NT*t8I$DU6jw;)mOsL*e`CvUEEaasZkPTWDeyBw|``4>jPb_ znjj89z&;sF`?WI;y#*0cX-u6az!ZD}+QjY!Lo;$xl;${N*oR1E_AG`oVKL5i_bo(n zs-uzOqK)pE&Gy<0?e$xz$@TmHh9cnWR|kJ8U!323SCcuuh{AdFL%61lq&ZnZmZFd{vqQV(b9h1}a z-)kBX9`%i{C(NNpxb~nstDYtF@kUQCn=^rZmDm&8Uu2F`yusfW_e45+b6izzT7>L~H$Hwg_4@e1FC)y?zcF!(35c1W zpIA2ggs+^Xo=JaVcT4w*)y@;l<2+IT;6JInwS6r$-*_q$zxpSZ1hl#V3M;IinX0AV z9|F~UZds^eE439J<|UPj19khrGRTPJv|My`CPJEOPz`>hNJwN6(0}ob`hpTf=f$Lu zS5T6`+{}d(ZGDkG&o!%}EPVbX-d8lzsj`P?Q$4MJ?DrftmsL}zp} z9=@OIVtxmn4CBE_40%Ix@Lql>+{%?5>?i=_W(%1v__4qtN<15`v+Ci=yWtPek(BN{ zw5$#^UU!21gC(@l-a{x@)3J}s7QbW_soZbbn zZc|NMtxF)#PsXW07o4OSpHcn-tkv?BQNI&8XW^}nx|*SC{;l7mS|G_ee#PM$Fz(VFj@#N0=Q)?ky2N(Uw)1?B-kHvo)XJD(3fV4 z`r%DWZD;AleJYzf))*&WFBas6eQ0t`)eZR#Wz8$R)(thcjM4(Kg?7o3J4Y&(ps_1u zSQ63oW=wFSU^_9#&m1kGAObb%e+`|Tx)e(FXc*@)!6>ylT(p6jcQ@=WjN%NHl8v+f zIMoEnY{{4@*jI7_LpHE2N~(i(Z1EP(z%gsOAvr9H8HH#9skFG@j|IILMWZz4cBOUd zALUO^WX)HjA;wd?Bl`(R^~qjmQB2(PgyYB@&0>imfAg!t^4D`nj6_O?{}c+E$LZmd zL>AjqbPFHrAOgWPl}3f*oZv%#N`05Rdzu^uJ|R)m2`u+SwiGX@_;Q(u+CT_yIo?gEFT zIdUV;3qpt~4Z+8NpRt+#KF%2Q6u}kK!i*0e(xM_&AE|~m*Whj%yF*I!4cQA6kVqtU z#Xn4ujN_JncMc-F1|T&Hc~q;I7g^(u>bJw(=u)^2EaBCO@s24g9SonAi4k(_$(%hx z-7#_dP-7Kw3_-yZk1d(7loKCmi64f(R^l~H+`Eqz@8vdOCt3s>?4CxQl9ys$pdKv5 z`gmn*&Tz>`$;Sn42_&3FDxLMC>))XZX@7v^+L3VW|7t`&l_fFtnT+8^L2oC% z3m~{kh}JPtZ}L|0;;K)WbTkVc25H4$4+V|!-h;pybf2ffn{*h8nN9W)K5;hq_Z#Wt z?h@c=IO9(4`oX3>)YUvl?X-xp&s!S!YWYSNf`wuCToyWkGSo_l_Tcah`FZ5_hH&g(dkC^knt-5Hq$e_R~gZYI4fR_^i@_!$eA;}}tzZB(y9>kv^aUq9u< z;?02(Hy7@`{BFoaT~FX|Rhr-63NDwLn^)|Lu4R2P=gb9{-K3wN`Gk|P)mu3J2>~mr z%aMT67O#>vhP5?=))raG82N61|2&Ao`zx{?d^l?mMkh3S%TK)xYO@`zvmFk?9o(yr zrr$vit7l*6#b4cj_b<8O2l0TrYQe)fX{LE%NEdndtyU3Lt=z^fcM(c&kj^+xT+fFx za~21wv3r{AF_I%sYyuWLCe+wQesoJ^3?Sj*Zt8 zeMmaPcZbOD9WH(NbLfsyG^ldNTpy$^oqQr48G0o&r_HGuZXuFvKZHyvatkjHoRR~* zavY;()ngt;lU2O(?@1VxeNG~O2MZLRe^|05GN@hLlbsiPm1hj5meajBvc(D%x}MN1 zdG#pc^{JN+zBZm)d?C2t`pRbytd=dlYPpd6>go3DE9M?tEIoFKZjY^2YQKWJ@Gz+E z9-5vD;j6^n%AGTPC3qy*tM#5}FFAdf65OhLW!XQ1y;}F!e09{~?_N*t@p#+5(Cg#x zUR{hozd*m}?Jj%e+C%y-y5adwx}o@Py0PruWRC3KP5*=NdcJe>c6v43J@^Q-r~2+| zjUafeJ|f;6>Ab8nR=#V+eXbD{wYYzpdDZv6>Cc?{b=*c@N^UJYt;Hb*!IxNdMk%3_ zuz*H4EEv~k=74HX_y*Uj{gpyg!cZc#QGU4d+}u#`s6b#3VKanos#m4cz)2OpG-;J8@&y>s zqsQ|y=e}Mz#G^{dff!Y?jAi-gP`N5o6r!hO&k`Q6wBC)N&JcM^$I&-5Pb#EWdS$<~ zWff!zMGCUF2pX=FrF(*GfODaFX59(cxs7!1>S^_X!>yb_Vd-DYA_g)w!%R~Ie94wJ zK1wF!3dX!5O&kGrytp(J1XzaAEgL8R8baJ2D6GqZ>UIV&jq5f3q4bohkYHx-e2ickaj44RsT(Y7#58%~EzA%(ce? z(8nWcADD}+Tb4YyS-Gr6^MDtbdC)`nfjBYyv-DXE=Ee??`@Z(<`r-!Ga|wi$)1PdL`!GE=3BHg?;(L&~jFen79c;&`I$wiV!h4w&js16**nD7HLLD z`&ol&-1S>-D?1XCJ?Shkx)1_}ofzS%e&(qixCKqf5T>phKCTdO7@xx=zo`t~5!`m> zwQlmFhwRt$d&&D(gg;6t9fCyH8ChW~^`9fBm|G8RWTmKUhJbU!_CpT|W-5uoXTf^w z_Yuu95_Zls{1Fj&uHMX@A|BdZVpH`-QZHuOf4s}LK9?Ulz~x@Ax)~g}4iN}5r6DlT zQH8#`2DsgEeTe@6a)e7Hv-}@0%8S~gG;H4)bT|`$WcL`y)51Dr+c0~fqg^5RZ+xwL zf;@t6q_>Ag#rE38oq(y+tQCd;{YR^! ziX1tsGd3xeZgk6PePQl%xG~eW;zR0gqMxrA@#+~7v-~Vk;-i^K%T5+=ekt6&BK&|a&4`~8&1 zA3eQnZ!Y%c+#;OYzq5Q}mV5f#kofj_iSsE`T=7+xP%TiPQ!uM0{Ki`x+#`5aB~Sub zB2a%j7n@-Gv@~t%(ZH%@P$IvONyd6(J_7P?zpv`ia#zwX>?#qcy`0xqgg?VcQg~E8 zO42L&$g@|TInPur=&iDPV`nSstze)3E;_a%=dCbgO-*a;xoD z&dfcRI{`SBUEYA$N(g?po`x>ry>*`Bf7W?O`YL=13KZb4##Zc}6O@|+Vwd$F6})~6 z9J2rvyoEkl^jp5#Z;(HW7%F`CtZQ=bUFLe9;1+wIqvw5Z<(7Q!<(6mP%+61|5H5P( zjey^lg>pCk63ub6>*yhDz8EYf-kLykD2q`x-AO?}58-!d^( zKdPf;eRF<>$(6<*-B|yAKwzqPFU4W|K)_u8QWdBB<}PgUO;j57T`D{I-nPJm#Eb?` zL4wk;5d~q3&Jy%4v?R1?0-e~2G{+=2-{y^Tb6?=0ud&!0cCSrO98^t%CLo&{jK$l$ zL23FlS-|z6HGB&`{2V$U9+ULe$w;VOb8i{pJE2BIzhc_^y+%dt)sbXD1?a;NJ)*$l zF2-~m@Zdi6Sc;4w6!^yc3s{QLmsOF}w6uyMzlvfqiDF8TWh9TY91&$6 zY{N=Lx@jc2CVw^zg*Grner4NF!_Y1;)8HN+Hr6ZUIYXxDSR>osmmk?${0c(RU2Ei? zP=MZK*ph(CZBMdAi3eWzF+`yEq4kLv?SlOraDFqD2-_aOkFk8g7e@0KmN0>+VY=;6 z3P|F9PdO-9f`<;78;lKj4Sl9kRZxAor-+ZM`f=tv@~5B8pHRJZZRePE5L~!M{R7Mq= zW-THUcNhtdhsLDZd7(nH(2>dIQ=lnjQT?_#JoA72#}*x|4x~!KTXyd;q?2&@kySdu z$w2J$L|mYbE!rgSdLLPuNWLTQBbQMv^rj7LT?o2DAC|kzcfdER!Yj2}nUA#ah-+am z6^cIsd}_=K4iZiAPwhbJB~vNL>zQ?m30)+-9(IRatpHUE>?F!uO7(zCdGT)!E2|!1 zbhJxRwUY3C)MHWU9WfQ75oP+sc=d?5V`+UjEgO5HFQ)bww=vDSi4BQF)an?+2)uMO zhlQ;%$Cb%tK3`OKQ)_+f6UR=;VAQ8`ltY|6Bm83fh$q0|z&q%vkaIV&{~Bp$bv!Xc zU_qluo;=Kp0`1QTiz0H(o=E^=4XDe0m=STVaddPPWc^TCU|B#JA}Z|e3O%(|7|nB^ zt@P439#J-YMn0>tMuXDnBIJq$aSbnB{EKxC8lqdD3Q8lyS=GXbv6jLumLj^1%&d%+f-sHLhZz_m z94s)K zlVKpq7KpxLGPvoJQu)vfiuAX@>1EfS5uwoVubFgx_ATI(HX!L{^h?Z}LL`lRhiQ0u z)$2&~EIdLCjV!Xvodc|mI91G^eGg^|YX*8iH|ejprWoed3^fWUj$M>Kf2B(Zxzr2lAnD~{>l>_*_tK;X#)p!biwoRQ zf~KYB#=GEdd}d-gZ)n6YgC1s^>QG9;F)1D1FYu(oRm1Gf>VsTzRWOkpWH~LPVUqvW ztbm8BIb!@avy1L5JVc$)VGkuyK0_5Z+5u$T%Xl9<4?Sk*Wx5H?b>V1bJPS)Wk?Yv) z{OH=a=KQ}}(-0<*vi^uUiwvbA&gYWNDHaE$DcB|^$rU|!nou`Af6^+Snx`;W$6P-GaYLf z{R(x-CLreTnc%(0EXUOl6~=-`LpXt{I#Yo`S)Eh{qLD94uV)PAEV2YC@us6+(g5ka zbUmQj71yjh1aju-2dzyT>I5B0M1nnmD!)goeIGuy(@A!IE5#bD;259V&kMB0`?C$Q zOPSas3jG2N;R;QByjo`56TEV4d1{m6@AW_nJ8&{Mtsm#>lNk8Y$`gj8J9Fb#l9`iA zS1{&mzId0@g)NL+mqAvJIT}Hnej|dvFBzaJXR^}phtA?vu$2{33;cJpO_`nQz^c!9 zk0aEq_`qV_SBK)GEF2K{XBjCYWzbwz2-r&c-}UtV*lHqW)@%VX)rdjWludPxdD+XD zA)3>B;FVyqEn5A~m2|u|M+1dwJbx#w5NK|{1gdy1A5q^o8mCYjY@9*w>c?D!O&^su z#Wm#hNbe(!)~i5g{8a-dG`70o^_Ku+Xx0Gmx7e!J&T$yGFj zi|1hLYW7VGJyM6#J}^gBgl~tX$U$x;n%*eZqCo8ckJQCG@vs0!FO&!=3)OU0%`R4K z<2@ZRYGlg&tafyXC^6hf!O43=ea)EoIi3cTs&fm*13LYbeN+2%z!Wv89b8akHPKuj zHZ+knrt?qL;`NH;SgW{*{slOuNp!zv8? zZnh-cDis_Dp}jfvI!&HWNq~*6Or1~(YFg)`^a>f0{7nW(|AiPZmY>U{r!M<_)_SvMIY z8ijTuqm7f_*YzkQ;1O}(3SDD`B&>Fwv(qUrh7IA4o#2kV%h*?PjqpJ?^q)|`hqUJ6 zj&l2A^F*0>UbEt<6MKW%z7zC5v+;|vq7-gaSmpi6kcJacTyf9tHDIv-61WUk%cFE& zXaN~gLnb~xMTq1A%Oo#(4($86N$mg?T_m5(71!6KbencA8t;q-1=M8&%Bn5sDA*~H zX~sSO@1>I9I8Dfi5sPKDJsB&anPDZS_0<+;Gi-$k)zl|Rb7}&`L)~N`3q^91b0mhZ z;yTw^ktw2rO#UPWhS0VRu1bn>7NN_ibWG@Zk|Yy-7bHkQzudr6ilrd_tTIO(d*zWZ zgQZ!kT*i8PJv2`|)0(uji9uW!h2EDwySU^9p;$EkW)6US=mPPB% zzgGa`=|{0YhDqI!O^_Ssb7YgDy5tmEKE{32U~toawy7n!x5AuXkR6B6lQOg&2EL)Z zt5)-JAHj9(uR^F+@Y_~5AZGu4n^y-SHp2ItT`+c;;rZKF72ak)A^}}EA=k^t;aII6|9%$*#x@YMejC?x+FTPpQ_Y#0+nTw{ zlDy67z9wxVc5M=Nr~KM&Eb%p6!=`OG^3Cl%_)dx~TYdP(OMk}AYdEJXV2vL^Oku;@ zAbuNT;?hUaP9HAw66jAKeUQkLK~bjD-BLclc&OXF_Yj3HrWkFb+@q=q`c=AZCY0h*vu^0e>RONO)AD5RvY7Qxy==d&;6rd-e=zLr z{HJTd6CW)*bfeol1FFPqt!HMpD<4%F={^Wcuo;DEkxk z%%YaC`zpC8wmSm0PCe23(ujFLPsFZaHG$^}W6b-B`#wxp7=7(xoY)gY)2>&tWz*Co z7LVj+?dY)V6Pe4H*fKO`rh}#A;hG-!su?U4)qMqHp%f(ARTkPDPhoSH7QAk~p5%|2 zEgczm{$;$(42-i5H=cZfNyWbwjg!vFoBFwed&U50Y3sUUJ)Gs6uGA?mffs}>`fir?=P6V@Hq)TIgD8^le#0r&2u~g znziN?Cjy4sg+UqwG7M7;H1HEaYD;)5_VX+I51v?~nh>Q?i}H|n&lA{owFL}VYuoan zb(1BuHxX?7HQT9qY?HJ)PHO{pnoH^{J5>? zpMY6uLEeSF6|CZDP%bQpFkILNZwS{rs@L``sekA0ZHpvo2AH{Av9yU8(qcWT>bsIa z%#yNX=D+l{g%LHE{`_8M!Wi_@re#BnvvI3hq+>0}lXQW;i=kHs7WoFQ#Faw*Qcy~J zCs69@rV90qdvy%AA>t70VG0(pf_8&upyefYmuZ$JdXl;#6o$GPr~fLgoLTHN?C-^3 zo%{xZ=SOakcLm4!@1^ajQ{sI4Sz6%#(1HIK5B-02U|r=+JLDf77#v-#MH{|lS*;0w zgV=^23xrq^*ON^AfuofaV2i@3CF9Ad1rcOy`C4h$9Ksp62^C z$nkxancLgz1EDy=2h-RV7ZBYg=AdMqs;n_$TCH3E2W^!$gN9s9u1d2`kBGW-DT~`ckHqY}woY5QO1&AQaeX_{`v}-B0PNrAV;k8tmS3$x`xh%Jv0- zX*>Juj%JN*cGYD+p?B&M*b|O?6=+wKabI7WpMFlG&KI#^TRzbd6ithZV`*YjWo-+> zA)93TyUy}}oL$aly)D=lr_~`eJNrp>^HW`%@CH1;mYVxnsH|u+J?tFXjq4hdnVKOE zr`^hfptPs>Ocq6TUyN@@_FH7G%CW6%&>h*H1nX{Qc@*KfDe_`Uw!JMPFW)sl(Y=9z z&YHod=ZO+=S<5Hj*+^<)cuyu-EgYGrX{;60JGhk>+ri-!#<|#u4aH-srTKc#X zWG=V5VysavaX6#d2U>V@jW?M83fNXc=&NfsgJ}p7(~BqK@Xpm=zLN+h2oTuEQ?3H=ZY~HPjF?Oe z7OrX^QLUwAgWms$c&@Kv0#!fJZW06l0Pi0Im9hNs(>1jDhl{<^1&LLXcLSlhu72Q z^Sj&q#dBO9z`REpQ2;enV!9GzOa=s)BWs{_TkSrWS&6aS`fi(kB?iVo3xarfP z<)8`=(IJ8rP`xB@J`uv>$>!s$n-yk}J?5OM{f70pxf@g&8?={@u=>ZTv2cT>7daWx zhAP)|2~-Rsa?BVQf5ST3O~O+u7Gt%Ky_6Fe*>qaGIU#rO=RYH@V(trxcBR_!wq3XAk@>l1~hbn2uq!#{B};e|ng9 zdB>RlwHGL-I|IP{Ab=dN4N@WGLbU1vQ2-#(|1g+$#*!Sd6)75|PQE)2}frCk}7vFBVcX z(v)qmYfqZemA^{Ci^;`H2d;U~()2L6q4`_#fP0_Nn@{%A8a0Q6Q_vco>_4M_+Hb+C zupgM;{X~D%f52SP)ztO>Ea|d8w$UiO3vO?msc3*9ltlPe8C0x_$fQ7jA|WM#kw95| zgDHJd65XUqX&LEU4rUw*Y*yPCe`jL!!{4;FxtsI4YfT6-c|P}e?R1`OdToDv+#g`{ z!PJTw8W2TdkbOe`b=&xkCF^&Pnk40Hqv@nJnn#igGYE;FL!e=iCOxvc;hnGyUz)I2 z(ObHxik;7=z3)<^T2d7jUZiZ3mK&h0;%aoCkZWhGBaGL}-Ois_iljN6NW*QOuSQFL zU!_w?hg|pa8mAl|%GQZ4kF2CB`@MR)n8;kNcfIB`l=qYmq8W5W6~}g5X=SU=OVR0S zxvyArX2*0vkGwvt&{VdnPNXQNNE7$(}NPk!!WC5p}cKP zuRSyvz=XQxo~l!8RdoY4TA3thAM6D&oI8)egYWFszkW6>Kf%-AEnYF?#P{uD+1=t8 zT%<;1AKP1h()XJj>=O|3p*`8t-$H69gWKl2MJdrZCX`SMT5(-)KTkXzc7##rSka8m zA(OFqH7i8YgmFl2`c^H>GpUR3t@;s_Oa11BSm=_7#H+Ucu+@Ude#-TNGN?}t`VI0H z!6j~6AT&sq_yeYwMzUNh&7?y*@dMn-4Z+^`>JP|SfVN85y8A?BwwOx$!DGoa&Y9=8 z&Nwt&{A966;OU!Jp4;k|si{`*(=^Z!8c}L*$cKi>X$eJkl%;xqD-@wbksExwcL`}wcV82$L*p{!&b5(s}Ffj{MlKw zZzfDUi!1blL-ENN0cqjjOLk+Aj5vA|P06EPQm&eZXZ{jRhq3${>#I(m-l0l=*%@oN z6xF1O=sI9zpbcYaxP*a(r-b&b0~Ug?6S>7eGtfO&pSt8S!I~3Db_HoZGM6R0MG2;{ zW(RR`CQ9kvhp^UQ9Y|P$nYwDrPTfy=ftnQWp{vn9r^_^;c_!&!_3BOD*lrk2Tx!dH zXh*qXEadM?^nmquSpNMs<8sJ>KE(Q+I`pt-%dOIABVLC|o4lh@e0o2XGPB=F-IQZQ zn!>p&95hyxhT@KWdyS6|E%q>>gpbzA8$2xf0;XU|H5Nz(>Q3IM z9w-#k&v?Kk#Q3b%@p(+GV`WSa`Dictqs)EL?>uzp`*xSR)6{n6f@h$KI%nLR_O~rJ zQ=^#z(x)c5{vAKLc%QYKWXrrZ1JeR}SfpXKls<2L)vprU^J&Zhp}sb&tkUw1P}>}| zXtN0#8?37yhl=m}?+by5N31Ci679Pv+s>z0{UDQ-i7YG*jL^9VKcq{Md^&iyTKA_Q-1|(1<6Hll9_`?^*8+acc2Bb&1f z&rqG*^ld9o`@Xw+Fg^c|KQ!~r=_Svw;q!6F873mz=<@VnZ%Y33o?KvJ2Omsh6HRZR zghKwAnSKzZq1+IXh-zt_;UAHwaY*rQ;Eb*%aUr~&z@k?}+!Ey{5H;e=it~GU@zZ(4 z84+%bcf!e^A2a$^q28~+;{!KPW3JJO*#yftk`2n~#Z*j#){$3>EZx)04`4G!X|o%} zap9gR=SFRTHhnzOlbDurl;SgtrEUqo5(y~afb~QVh^D{=UxP*QHX+!ta^fO1^K8|em~GWyk>){;z;rN z8T@4=gTpss$~iNV5-Ofw=)p~TingaN?(q2f@_%PY;|pP|1aE@^wO;hM4(^eKzh2mO6m!^at{>5nvQVW)(oQR@P@)= zSKe9Its!G|#apy%%$Oc5qM#nKtnc}=3qtR2?Y^Hoh=p2j`0cOygdS>r z>=O=8H3&XgJ;YVt$cx|TH`Un{OYTSeUJX9A!KXv$N0;pgK6$-*UG;AXIv*OV z-y|aZC3%()_Xssb`Vjr}rjLQuzNA(9)(_Y*zSxB^E@EXnW6#e(UjzcTuSH^h^Jg=r z0$)+#UsYlVn^PqI!d=1AARs2#Ab@F5OVFm(ziXW}At;WxunB8-rE;oF^l2?vxmM0~ z%I=kNE(%!L{kiFrs*VCT%Wt7_vJOi%1t7b|Xc;24g}V|5u=0=#ySt=f)x+9iR>DV} zf20+Ni2BWQrWJEG458dlyYvoVvD~e?5+pYmorJ$zdURzrXH@3$q|9uXEw9;-8_{&6 z2aDmOVLCVfH#*kLtZ=}jh_=>Rjcq(u%5!4L$y=xKcq~fxqBEmCN0HbX7nTPVoXpT( zy3#7v<+e;n#o;zBhAzK?GsXa1U&QX?*D@HAl5)-=4pAAIjbpUNWHw{*8`95D{)Qd2 zq_839FClL?Y#TCLk09r4Oim`-;z?*2lo%#N>_Cz644Q1lw_L8dILR#fGBjvR}*47KDRw-ibtXN3wWt{0XiON;` zbloW%W*Av*9_1)aY?+oNxdKT7R1d|kntEU7Pz-J^=3WZk{$+5D6C0?Ysc z0)F&E)vUGTg@X{KN?;`b5{g)8OywPfESgOqvl$a!ko3Z`43#Z>@j^vYTVG1=L}UqB zLOVor8WGhbD%{tP7=;R}N@@!e=fcm6du=2}u4aOCAVgjvT~v((r5XL{R+uwIcpDv) zJaNYzk+!CnI#lhdBz(9^Lrnzqiy>xZp~_*Tzar*c7Nr$=CGKxUwuGOZXc)ZP90 z8zx@dTY=L*PP?oWl9VPkb3GtWU1Ry`^Hm1j{i_7EGMwGh`Ed(~rKOD~^{3BVL3*-v zjHj>J^u8I9*u(bfmhxM6z>S#JNe=!UcYU2WZbR1BmU@a+B(2LV|9U!cvEiK z&yt@hgOxyT9WVvGdr<3W#rJ_dFKmJ7)9GxJRRL=9%DETS9TBq}P8POt(r+M$`5`!i zZb9VLH4iw(O+!^xETD!;@=)wT1<8eTLk;D-%VtLOXiScqKn*rgs17hnRypt>%avZ% zSH$m2PzAM0p7KdN11>Pydhrxl&1A-d+;B*Ggo5Z)+^T}XFZh7jqswpq;fCo*yISxV z+|BW3Rkjs8b_r1>wd$JKRaDGi!DD{G(xjv9yKuWPAdb7U3)&WZCg!BA*r;VVucyw| z$9Jn#UOv(_v^T%O0|{sVIwt9&Ke+XzQz{9$VoJ}Hl|yN>@VtfIYfF2^^rqD}pC#m~ zzI_DS>3dJe3)yR~kt}A*x`D`c6gWu#gDip5GKdL72c8iAfU*@azJVksaV7L<;LfqU zK|LpuH|N#mO#aLb?H!~wIWh6Ll^G}^@}+Ui!c^w3f{TjLZUpFSNOz27Y$#G(0D3UJ zQC52zUZLp#Ax&mZ+FI;sM8sWGdsKao8orRqgO&{!mQjiSz-4Cp8xzAJ)Zebm$v%fl zKRE$29aZjZ2n|MgBy7tLy~lKTocD58e16-%b`qbHx3g$gwUF@8Flq19XoSY7V4`UG>J^*+6wgUksQam z$B%eZr56NDwt9TSOs~pW8tU|UAub}j1`W@Oi_hEX5mo4$AKKpEgD90mdPRA3)bm+u zC(~&&Q#ylm@o*JLNKr9W3>v}M}&#gP(HJ_u@%6l+A&!f(MZf%`ML00#)w!gGecR>?E!$b6S)^i6s z!vJGN=aR*O9a}{BBLN0jH1mo7p_oy$Y%+;u0sQsgNQKQWTfj**GLHeSJA|VuW?j{w z;v@7q=taBx`Vte1|GKLera%2y-w9Y{rm+#}cVWTmsu0X&iR=rnFLg2pKp|4M(*7$4 ze4O-U+20QqWGS{aue5_xD-&H&l5{*9z_!$?Ln5Jfn=~#^V^lb@s~bWW{j{S%3tsM4 z%JGb?!)0ksx#;T9!@-Lzs`-iOlC1yglSP1NU*X7R74)r~T||1X5a4Tm=}dKBy1 z6a|R2dF3V=>52Pb!l4%`?=Z)}R-`AP2Q`M|EXA<$Ti^32u!g2W@OLCdz;$-qqV@6# z6!$3(%St*gfax)%3C5DY^S8>2SgZWvHMut_o_mVnq*#EPkn;Mn6Bg(-#k>&L9J&Ht zdm|SH6TaD*4`?Y?GT;8at@B&8nOn8ynaNJgdqpZ`YO>-fXeT&cx1PO8G=~#{S^=3E zGk5s9soFXd+PtZ-f2}e~RG&}Ue0OG819-Aa(Nr`DSG-R1HVK;A1R)~7@t(q^mkcwl zPV=G)!9L2v0B$jy6$j`luRL0p;(VwH^lIszuvRop1Gj?HUlw+kii?^uw)Irdr)ECk z1iB6)FB;z3;I*l4avo~;S0_GJ6W^{&pHUQzEAUlud={%_RcjMUdd^*Fy21j-Tfotr z4YPJ6{&?9d5>GTX4cAR@1L7AyqbhbT#{EJ;;8)$OzHo1}YgX1*t<_dAoq`vKX4B+i zuPaFUbuGNaA6(3*7XJ(I4d5vj&7xCoKWJ*5Ml`qBb%VQ)dVTLkl>E#g?V_=%;NZpW zVJPNw=wvB3uS6DZ2~@L#K{_i=(faGj==-l^$6;H8QO)_EJ6sjmhvrK2G+#Nt`MMpkvt3Ad-`2u_X5XC!7kt@q1*}eH1rb}VHAPfi3Jmp!myUUFb zAA7~8yn#!uAk9b6;yHBmdj9=}y#5LU{pdEEGupNJ`40kH2aQ&fv-zSX8hUBCyW>sO z{t-QIGWurJ2*C%`;t%Hd4^@mORxNq`5g2bU#n({zAb9%YE^w$Ebd5#NnQ^~J;o;W3 zuIm?%Z)o1jyKS%>5=>&a&gaAev?=(x`L1}g-)BsDDCBFsQ93VpcjugW!Eqi3cFZ>< zgjk!m3uFgnvTOmKv@?6p!j<_ax3MpXa`?9%4*_+XEdn7uxuty|qd^gUzOOQ%PtRhC zVcMT?FQ7P|(v$V*2>beb$3=PvQ_mzWTlu}@pJ*<<17nW#ThQ-fvw5d}AUu1P9e^~4 zO?M=ZD|)#l0qcLn&!F;B1ZFcT0@EngHyiu2T=J)u9@rLHknEGFP6M8Zx+=>PswzUP z9eyQ#EgdZ#XO;({pN4shIq_O<=2JM$m+73P4UDM!hN_`aI4<#!#?GC8 zg@!9~pNY=jDf(CDfA#1=dd{OVMPEWhV%|Ad;Nsq|CQMjC;z#|13ea2j<$2;jluqX1>58JT(%aX=whqe(Gt6wX^;jz1<20Q%;@RK zG2mY4LAwpbSeGyL!)ocP%X}vLc0mldAJT}5a#YFkxAF~WC0w#Aqu2oqaGyqgX?iZI zRGizr4xTA{{K_3MsC(HU+>R3@$u)v|L1wp#mUsrR@B4T)WOBl z-tOP$M(#)Z6+SR9FkUb{IxsUZIyW#oH!wUgFt)78u1O?rF)&5gyz0RQkfA1f6ujgaF7>IRpa` zp?pGtMA%Vfph#vwOE%iSe_^7r|J+>)Btp|r!Kjb}q3i)PWMFXoxPSnIKmh!%#$hMf^qZZ?qGH0LUl)M-|N8#8lk$C*fe| zV*g)BhZGHHZNnLesu_~Z9*F?}fp;&>j6-y*`) z=6c6&uJPU|KV_bL=>|IS{6B=$dLL%%PFI*d#6q7BcUzf0!VEs-9KMxLKeuJSj|!g8 zdU+qf--@!nNErN54|>~9{dk(fd-Nr~rN7Cm;6e64z{tFrfJ0E(Pf!iq+SVwYdu%#3 zFWsC2;@?WLcnSJK@YcsGVMOV2mHUQt_K%f*1m_B2K0Io(CP1BXqfXFgt@L(}p$cx0 z_f*f0LxkGL2bQ`4?W^R zISK>vsi8R#=c$dB-B$wf1KtFgC^ZPGcpwRv`DvA1~^WdRFWwrBC59p8tD%ueOlT{$_94rQf7HEA$e1s~i} zBw?}eV;xmxj3q3-A<5tvP@Utm!|d#)x3IV*m9Nv|yXa%Ps!CKNl=u#Yo$6PlX$w!e+w2VHDK7YCcssRBu)thh3z_ zMA>)5=CJW#+c#xApi-skL{LJbS;EJ_`41w=oh9La`Z}<5SNmKR&oeCxFp?*V zMV%8M8Mxz zjS0v{YB~^S*n}}RZKROG1(8i)nBR_P5E_sn%_UknXt9|0KYtM!R>ZN)&m*%X`7_c* zL|b~+p3b1UZ4>fRj)vBfx>~25MQ6rIBy&pUXfrc^wvZeYP2np?6NS%N9VgM*s-$gr zHE1JUj7+f`%kB3E(qYd!U!p}@8Sj?^%+IgmJf%C9^@pNKgBS(fZr-H`Qr$Vj;ZREzd);5r7IcnACvQ(RAiYQUI!AVbKP0oI_l^GGCup8E2S&}NeINP|3^^NZ>7uPd0v+~sRNdRdASa$ zl9~Bpsn)TRzf3k|xO7))XR7NpPVix>J@M?F9#P}yw?nJPHB{YXD0*potm}XGrB!;8 z>6Krd0S>F7F$BHX_%nvFY&CIEiFhZ^NbB=XI&JVgia9*vB2p%6`waR+muYTs~Fc zly#;jFKNU;E~X?4r981#-xq{whVDM?!QVJGX55pK7QK?~e`@8?gPl~_I0zjTpR!LQ zw>hjSwR?1qb9;~{!H>ERNk?A z(?UtbCK`fhx^`GwL03&Hv}Q~9M{{WP7( zYUqUMUB*_rum*TNh8;tskiY&)vERj3?TN5gJG*bf9tEY^>2K|aPm)AeqRx>kJE`^t{GR(|!}u9=^Bh?LS7;<-8Tj2rjz%o~RfZz4w?8b71b74KB( z2(48;qn#^j*onNHUYq)PdRM068~%K-FUvV@HCSEBwg6oI!NA|Yh{E3MO)V$q8e;Fl zlko6(#z%WBthT85SA~yY@2OnGRx5v5$H$!Q6Gx!^v}_w zax0XlYS5SHb2Bp=Q~;p(TMTuek`@maA5_bc1aa|57MW?CSQs%Mon-hO$<17mh4><{ z1O-uNCtVYOM_Cg6u+>^@QlxT9wafW&$?V!K@oSyCGo?YL-b%iQjjeP9LE;g=%DKU* zm_-jR*5+= zf)){x^F-RFYDpmds@_TaYP*PyW6BFzF-X0 z{Ym_Q>EuE^)_UG#Dt@^oN`l%S>4KSFc-TQy?PC@9TXNK=k@$Q!KAk>7#O*)9? z6IUkJ@l|C3+?p)R)kRAAQ`r#>#s~(;E#vywa{)re3$^err}`)`q*^RtOdokPCKrtw zBQDNjpo48TJAtS%!~%!Kt1sz`e)uXE5aUNltb(=CYf~p%2NC5jZh;^*AlRe|o*)ex zjCDkOj)b(qkblbSf;MLnvjHa+Y~x`O5b~w!Sb!pJLj7HYGJAB}o`#TmqM%60Vf>TK z*9B1w;j!cy@Ra>S_;IxFpKQgzDa^;!Y<}51M)RhG^s3WeyUbez-^T^mw>}F^*IBnd z6HV9J0q$92GlWy*W^pQ%lc4kS8TVVqT~HjS+Kj$%`nr9hc@j|{^hodbv5EU9MaksU zVLP75*}f}^g^B|Gd7I3agn7VS%7V(vov7hgjt+JhfO{kNit|Jw* ze!)7fluq&qnZkGWWsvzcbQf3kBf%e5yIr#6V^^Dteg`$OL6m$u19j&Y@B2{*(=HVS00In zb!#lS7*Q4l;gLH?;>uryT6TpgS{9_aVU+mk#}QPO$=piCsVCQ*jtV_WDu?oOILIZN zLcfn3ghus)_6m^IH~f{s(*1`Z^xXTdDBuu_&l6IyFA!<+R*g4;lH5zjM4j8 z3=Ql8Vv-n^-PVJ`*THxA0Y<|B+VK(MW`kVf;bx5=KzQZk7tl}bfB(wK9i-mJd_&`f z_Vwah6dzjSlL9;veK{p<^QOnpDt~u49`x?{Ue$9t<~^FxZXdqpKgQ5#U-p}PEw@pn z#c|Nt<9Ab7hQ?K|c4pxm#|3ioKURI8z@>hk7&F0>=Q1dB$CWq5s4FsxrVsi zj&My(-=ra6-zTPDW;$!e>67&Fz(#a?4fq{bztCC%y94+J2jUChRu57$ly<6d9_B>) zlCpmytGMQj>Gpa|`tm#CDL%%HHa*H$H;|2;BH!KAdJC~9Hje5XTXnQO{6@b%6f)F)nLm%O=w58Y?RbXl)J z>L-4MkZLN_CCl7Am5zB8LS{{%UnUfEsR~8qM59Z2i_6Q^$ZUW#W!{Mr<_s}EeLnMV zy{RRXLs7WWFvK>K>A2NM$rkb zPos=Cl$;+8OkeEPPMolY-Xl+~fRfhXuhbpHO4$T`x4kgZ$AF3&^YS+(~UQu61EImcP5Uu!PBMp+6dPUP&Ev>AX#it*7!W*U& z9}r|;jtp!wn`V6m8ichvgE4_u^%lWTy8vib{c(JpLi69xG^R>pt- zRT|Jy)}$e8&q-o9=UBRTi@aq`-qm#>$9s6bC&AslIJ4{th`otX|6_bmQO;1_~_p#E}OAu(`G@nNAm zEH&vAmeO%4{SHHPEBaQ5nLtl80mX**#HQDsQ+QI!dhLGb>(E=)~afl0^B8``I533=XXH%o|`vQNTm@W2Uza-I2(Tn z(HExb&5R}Fcc9!KciP^t>U-^*U#!Zj(+xFhk^O2kL!NHH`>1;_@CtizhsXSikka#? zTA_nfS%Wz73bIIj@Me3|3W{UIt^4^zr1;!*KE)72Yb22ZMsN}+$`M4chZh-7HaW6| z^S{jq>r=$Xs71PR6igBgfA5$qWXj{20;U+&Dp29Vam5BwBKUepD)06?3 zf~u4g*6o*tNa3M+-Ic6U^4-os7{2J2~wzYR4QENj7UW$l4Vt@bo{MfrlPx~ZS`_-&}X|^ zq%aOPPW|R@)Y=Z;FJk9Q!Wv!LA-w5_r}^{M#{vB`**;4AdtuPt(cY-4Xm_OK?uEV) z>Ov+!$>n*D{>sjwdX04^VKc_oJ`eindey*9dP|C+y&d`7u2MJS)`l-L95;}XE_e>!$?9=Ba={eoAYl- zayg=kq*h;u87JAQ(vgR!VxL7Gmvzx-59z7g6sx0lpXVOu-Mx`N)pmX{^=;9=3evw4 zC;4#~KYN4)f1@qYEbuKQ;?M+>V$2mPlB z^5&mSkoLB=_I85GD*uPqVE@wr&#O$Qol4uJp`|U=+_c=S(h~FZM_Q&S0uu5TbpIWV z-Nbc`wVw6d{!S1%Y7X4bpMTuLOru;$f`i%lnEQmAo4NP<;{!B5A_*vRHO(O(`AUL= zW}i+5G8GQE&nss>M-%}fLmXn38W$7n-H&{zkekIg(3#?WvI=g%-mFnuX z#Nh1+`cU3)Q3Bz#>HR+hv8(lzOJL&~to4D30orZ0`LVjNwE?UuFe<+d4X{~(vsULE zCY93WSQ#E&6*o5NodzLoRuzZqob@DAYD7)*TIiJ!YoB&gEb-A`huI9)-kfwa}TF62ko)1*pPI6 zURXZLn06c1=s{Aa0IpWCLB>t-v2sYns+QChB*hojkME2yZR?6MZt#Y!=t>yBZ*hin zESW=n_aAYU3Y9q&1@uoORhAquO#kFoReq2}`hWAQ|BWPd zOBV|XOA`}QI~99tQ#BP&EvR(?YO!ABY=j3e|0RU#lhbY{1B54@>TidYrLf<9t= zjYQh;8b;AMG6NSOIZ$oH(ko z?;ghr?VzPEcG1mwHL1;>kp7Iv&51*yp1#{xAKd;?6vHy)yaIdB*JTk7Jcxlq(kh2z z{wg2ackYjLNPqd>3(;~y;OjVa*Gscdsqc&8AB!-bN)-8S0lzl9?2Gb?-1kYEMdiJO zXonO2vzNo)YBjzuJ7+_Z3#-3L!FX1ld+r+e@D`wb^q-CBVQOPzxwlO6mmuqka(z!C z3TozHmZ!U3oJcZY+O2%t>~*lCG>|CPGz8{`c_O`YMxJslniYpLV^jmoHPp*Lobd@$ z+7^KQY_6`@AnpyB2sgvF9B)qZ}WJx*&Y4|2u$tYKe^oU9MBz3I1VD-j#hk1e%^B!Nt zBic8@Z>P3_)<*$7o!aCX!y`4{%Gp|(4#J_{UFRGlq%L%c3yNUcQt^e?IEnTVvbDJ+ z?bBOS4V{bKt!MfDN5Y*vMhnvC2N0}3fcQxk0~p%5*f`M({|gZRMuPIciVpw6!+*o! zuN06V3U5(WR!4hgUWu92tW^QL0SIYuz=QbNcV?088C|vYjH&{}=PBT?^3!QEqAXHq zbF=Ae=c{gR{5<<>fO8HA;o(|;Uch#Qz)@(5(bY6X6NRhjKmJ+h-WF@w1*>zi<~HnF z%O*w{w$HT}t2%iP)!=q)m_$3F_XPvCp}Q4^Skst6`c>Nu613I=lvX1Qua7qKCvNiB zaS@W%>N#GYiuTd2&WrgX130W9#3eN+MZ{N4>eMMs=fm5JC1>Wjr;EtS%WTEr`{#>U z$X8m-@2UD&M(H2;+a2j5f*_Fqssb{C7=)nO5R52aHIoSX-R_*pr!^+Or0_`+1i2+a z=Ba`rq=GkGsOH8kU>A=KW||7-AO}o9RG5Zz+B@Racgy00tlE<}z4e3xE6H?)Z44=p z>FolW4>&*ce82!rA|i~<3+QRyJp&$^lEHPE#M3pXVLeJjt#~6Auj%v%Jv+-4(8G%5 z>sG+K-iYU|f7-jgvp)ahcZO%*_c8og82kN-;lF0@f6SPx(v}>uAxd^#?}lkX zeG{sPVx>VRN@ae&5&|isrBGJ@M$BztpHSsrI!f)L>%$N-1teK-0Q_+db9c*<#jN`& zPA@Yq=iTQ#{9XW>{q|VL$ufgN5>r8QO%xTm{hnBmW7Z#~9myUVYY&PkVpwV{HPh?g zq2x@zG6%JgP(w6|u2!KcrB2uKctM@th5stoY?gD1AK})iy2mb~6u#RD6Dn44yV?iY z7QAEz(?0ueKCqGMHD`IbS+};V?2@RL>!BiwwJ><(@-%eY?m(ne3HDxej-f;beUQl0 zLHrh4Qs-zlu*k)(rYxptJYrjy4SOjLd&F(sT5r`~9=beD-LUDHu6>_#Lpv&ik=gGE zz^TR55MS=2DTOtOH?8-jre6;WbCV{#qq8>vo`IPpm_d0}5`B}!+MpPVSV7$<#dF;1 z3#O=e20J!!tv>dMQG3Nlh7$fmb7{1lX8b0z7#nAMB2d6`8m=xDz?^Fp3I4XD-og5c z4=RF~6fD9BdDV;TTPHlmt5LS98IIs+l_RWq4wGWo1d{o0j9SSOV0 zJ>}xLyogz-RuQBjPZ-8=;ZYu6V3evmt)2;&l3IbXmvu!srQcwf2$u;jLPkk+Y`^D5 zL6Ax!w8`qAGYINk!=IRf@Po|%QN(j_5VEm1widIr zvvjtwv@@5qGqeA%txNotT))5%7wb;FLNuPgz`syk1K9&0A_7TLB3#d)YqvHTG}2W% zwQ%N0)ObGxepeXN9J`RQV=Q+qC;Qcm>0dErz5HTUL5et}ArY7ql~fhBG!!eS=WgZC zdcqZz!6Lw$$GuGIN7 z-kI%cPT|T6DE2mk@K(8NOe9`EskO^l)DN?Jj=j6-T#w|6rmrX5xRFXR{8#L=o1Q9f zGyCR_JMWVM`OU{b8(_x!jmqUdyaq70c(#1w6#=n`0Nv0`S|EA1uNu?QPnVt?ns(%T z$%{D)FUXF;AgJhd|KCqyR#7e%>=g5-nli@C<60V|F!4g^}J3L9Hpjd<4B-@CJnSif01;feL3Ny>bQm>WS>~uXMcHAo^E5(xi0Q>@e{(`&Rbc+ns zT|MMxe$I04z2~*Ne%9CT0mK-Dh2;&ek|^gWFj5dz8j6oh!jju-0z)=O$zIAQq}$65 zzDJ@fZ!6zVG=ZVUNSJ90p1`6hR*9}`D>RZBYI7+@)lp?AFi^@jCAmKSOctQva!@A7 z-flaAXqq|JC0GB|cIm->c?86pd2ca9$93kqfqWWiW(PmH-HN|47WlW86y1mZx)v7t zlvT}^)`91ZzGAOOH>B&@!>s_VhdI-7)CyYT@n(HrY)spc?4Ie*w99XbR(U%Qc-y=# zK}^9BK^!Ctt)J8g5)Y&_(i`amW%|4$EGF(kx}hz1$cS`RRcx6tnkFQtWNs3-G?0&PZV_9}c1GX@r0?31*bS?{&w4fup_bXM6GY*#MQL$d~eUYW#M=R@nx)I-4 z=V(6mO$9A?t8~fP?W&xA!K|1%QPnty3kP`MEJZvVya;9|_@$U*oR6sbTlM%t9)|e@ zy?3Mf42`6hDv&vYu~aP}2xYF(FL)2>wT}R6nowkmU>DXcjGOq@S!(jwM70ZbS+mB? z%56d?%$(P3D6^#2n273TtuWL)NN1;pY89wjJ%v^uVbL>A;*?_9L{*N#(|!fWQfq{ zY7Oizfa0>oG|dYc?3}`n;OBHz6=w$1W9jml@0uHS4As1)GJv<%f-gr&{H#V_SEXHC zrDCz}7RjFSZj{~JBxkPgXLWV<>-&`6tWJ#=WMt%RI47mI{6; zE<#Kyn=C>Rp)@ZuwwK&wfjD6V*lLxXs3xUm@tY~i)xA+&(MbgDJ&PkTap}QBB~^ns z7R(VwH*U(vbe}^iwyXiUfk9K+o!l%UX>crfoKmw|B3lZyOwoyp_bcRTI{y$wYPuNB z9CUDPAE*CRhjzN?@*Z;dRZAy+NNUIl0e#*TmlQof1HbQz9RUtKs4bX@zJx8!G-6_? z0>s`pwM|H;Vn{U@x1}euc16L7Hk{4M1NX-w=@krtT`4N7sg1LbYKT_z1K>B-U=4vC zup_r>dyxNU3fC%#k#ma$y0*Y(2I&=&dr%wrU^l@Pup@tXZ-58Dpc(>vpa;a@086>J zg~CR|P|-f46yC~y1OT@RPe#a?GC^)>PhLToIi)9^HV?gCeyv{dNZRR@DbRf+TAf*= z*e%vkm)sb(R+l8OXB0sfF2Z%VyI_}ilL!7FxaPjFqpyHB318_UvJ_v5TAt!bUeHUR zmQTfyy5=RuZyx9<*sU+Tz7aqFmrT4b$bD?9dwQv!l0?6t7r4P^0$+ezV%1m3!5`&& zz+39@9f1!xBW?+>#GodDbpp_qltiSE$CBxNY7zoCCV%1-O_g|AP`E8u;5A$m_;^mu zWl{~;#$WTgbfaAWdR_sO;A>g4oEf?A3PnB1DE^n=4g8~kfSd|&K%D8dg7Lx)H&Dq0 z@dX570h^GA4w+}<%{YS5-8|6vxj>vq6_n7BFVF;0rv>Q(X$neEPAH>unoiLm@y3Ez zIDH$A1nz*Gc!#wFle&Bn~K>1Dta16}xWOr%p;mvaU&Bo-OV z5WBU0+zq4fWlw8B+Mx~+AA%d5O;UZZ&LS5aIMN%j4iyPj{CThr8MW}B?>OQ|f_MU~ zs!I+B{dpvFvxg4$O90{~lm&93?pWf>kkyJ!4>2{n(z&>h4>et)y0c|pPyBh%4?Q*S zy!+q0Ib+GLfjY7zBr!>o1oR-Ba7UvAYG?X$*%aK-gStc}q?@~FpdmduM`H-;06af;NHf^%UFKHTePcAfH!+fOoUaG zqr+Yzk|b~=Za{>H3-Xm79f%x|3-C#5$|E}S!ro!-N19WfaK_Ippo;E^#?uFQV;)iy z=!3pujjjmx0N%;Q+Xr}O?e-*@>J#pi2=d^B;*5@PoZVj>=bDnG^7X zzk-g^3;Kd0vC5TvfLGGKvX1%%et;eJ3iv|b?GW?=zw(aa3w%M`k;n4~eSjX;5%>`^ zeaelw)nHKM4zW{1C(Eh>N(Cx~2hNjhZ!`fVV^YEUj{~K|P*8!Zun)?*mWAOZ9}+lK zl5Y{J>lfV3ewFLx-w8f~Es;wF( zN@S)E?$3p=NTd)YhzoLVQ27g@9E*y0t57IE)xQ!{6`U&iSb0hLN=actfOYn-VZH-K zjLQZHl~BBMbL6};bNRs8x{xG{3XTeOIV#1Ebr~0i6)MFd{?hrVzgA7`ycKMD5%4mK zD-7v~Qqh3`F8n!&g0)~yxNi^_5P+LK;GlF4Q@bLR!$eguJ?c2a~jJNiCQwEU!LvCG4VW zel55wa5;9u!jf#h9hfV0xwhbz*y$GBIh?|wZn?sBOPD->F_=H|;&HsWu=T_KJK7&7u zzyUoMSKtqL!(61#_XT~#F5i)Ct}QtfQP>b{q`8ef&ZnJavjEfr8gE+82Xp~&K|8gX z{a*l0K(fCM=x(69gYE%32Xs%+xuEkv_X3>{x;N-PXy-L~3%USwKhXU_4*)$7^dQiK zK?gw(0X-D-Fwi@J9*+I%5uitcE(Bc!x)^i`=u*(5K#vAJ2J~3aJL7ouIHafEh49@# zM7k93NIa^IcPXav|^c2ujLGJ;2PpV%IdN0rw zpr?VZ1U((}4A6Unt^&Oe=zS3yiX?XPDd?G0e-`L!(6d3$p^o-LU7+WJo(Fn9=mntn zr@{0Ey^s((0Q7;N7lB?3`XJB;gFXZ_Nvl2-bO`hk(6t1!4xI)a#)NvQ2fY;ZGSCg6 z4+Fg%bR*~{&=Js4(9HqVCgVUK4!Q+&40IfHE9e!VSAt$eppO83B*vJD*?TY9w}DPcYyvY zT{jWX&7j*sZvlO$)^`Qa8|p)xa<|s^WZ7rvdnvh(lKUz78zm1=vQ_H`>H3h?4}*S0 z>um^LzC+1pgz%$uS5F~OGw8=qmh|J4JfZcIWVyZs`zx?9eVVEq4)!ykpF+c~pT_8m z$b!$$f_@J4^Ppb<{UYd>K)($770|DOehu{Npx*%fCg`_7zYY2w(C>nN5A^$>(W)2e z52?G4Kz|JS6VRV({h8LEbJllSW_-x5lYB`7phq5g&4A9u`^=8q*kxEFCj1-qH|RItkmi#_*=1 zH5QLHnXYmhLrcPq;kwGka8o!EpMOL%HqB4Z#EMi@s(4GN zyk#lk+S8XaC)5&ZiY05!jMj!4_YcvCpfSGl{-MTJ?5{_7Rc*LA-Vlw*vGTU%PN%ek%e)N^Ji5^ro7Lr;4(Mr)Vjh;zIei0s^OthJFai?@Ws z*qMPbE7Xhwb7|EYZ)hAt)Q(dLHttmyu5AqAEMeZ<(~RMHqjvGBZxBg2SsIJPX>ScgcPDMQrEux!TIF*L{FCYpZ)H`qhFHrm)2uBG9| z#xyiFH;&mqOtXx50Cq@IKz&C-P2pH`s5U$=UPla(cq}Ivhzw=Sql^?isuNiVs#|kQ zxGGZH*jg8^Xl_n>-kYAgH%DV}e+7Srsi7t}-~>7 zd&(*F20uT#JRC9gdzuP+heLJYmP9phVKm~cPTmDj=*)1UIK09tYFm&1Hv{>$Db(Vz zx`CUOtUiu7a#^UQDmJZQDG5RE45(KXp%Um_8;z_8x5W3s()m#&v|Gs8$P6tO6=jlT z8@okilR(TJksq)A$)d)1xFr&bH>~i)f=c@(N=;T}q|V=TV4|=BM>Deln}-@Rf~NAh zh*sEN+9y#uGrTI?;!(^cRb@h=V?LVBj)Z5o%!;=7uuBdL6-6u^MzR@+`P^{5zvsb; zGM7pjFdvY{7oAY=mtLF>y?3$@6-Z{FSgB+!Kojdiu5mb#2RE(*6qJCebe z1kzcfGtA|r9ZfGW1Lj+Pr*C(F7ifIB!^+}~xgyOZ!uqUq&)pVj{?@*+!ktQ@LX-UzX*Bq`j zVDb}{=eHc;2SWNW!4Fx6;>J3lhIKudX~t@X-1!=_16(std-;FVA~TF0MkgETkIfIq z5a~f3a&SPXTjC9&MkDGjSIi=M`6j~SnsRiPk`ys@7LXrB*{++`uX8>Db=@ZN;i|Ek z*AH>4>#r2~HQBr)nwCTxCoSqi6uWt?5_IpKsjabcGu(<*krn7vxpP31lr+VeZIai8 zSIc-srqvM*mE=&`FBKd=|oF&I(0BOT(^g4r*?R)}lbTO>vTt zpL{MaXCpFs1DWh2Y7df@3RDyEaKgOq@<-|`BdCd)_~B2Yfvgdq8I3LvEyI~3#`8=3 z$il@5Q<xoWSDJj$BDP5>v-Ruf- zZ#2cN%^nw;7%Gh8r>JRiZKLOwXU&VYw$z5*C@>%G5IN|m6p&8H;G?N4$Ntv-w_`tQ zKjzqv+fO+5lXUkKB~MfG3?(nvk8zflAuw|6_w4r_`vXcow4Xq%k|vMbL8MMoD2`}3 z`V0M~V}E9U?&z=d-yQuA{k5b2slUDCUW8r$&UIo2n5mKvy*XnJ^nt#}G@bo!2MVAcb~}@^Aqha?SZ$~|9Bhaf zkiH&Ken$pL)@V*baRXl*b0Tc}b9T)_Ikyv9_X$TU95XpWO zN&KU&@nEz**g|@R0HBfd!$1*qM;NU2LT3zj40=8HN29i+72S&?f-wxU%dly7Fa;Qu zh@V<%LmPmQ;tjPm7^24~w?<+OOCw>o+SEcUwni3VG82b9gm`5r4AZca1H(0P(Fni_ z-O_A;1BEChPy`IU$g*HXNlCB?1ua+?4ab6!XgnBeZElXX#Dk;i!b@70I#3KH4wS+u z2S&pf4PzbHSrj>9DJC$E#PKKM*In%Qlhf!ojt-1RM8qsn?ZB?0Iw6@2(J@uClb)Lc z6JR$7cDEnXFwucBnB-b9IUD`^zKeBYnl(E60;A#gdNb>VDDm2G_+kVG^Y4-CtZNVu)$9{=! za|=^zF{4|e(Rk4$5?txnzoQ&OC3T$Jp$fJ}gmD_Q$f0x>|;!tv=1 zEwOmTG7PT@i-JR_jTOY%%nt^A@M@{t0L<;w2zwCW#u#eMyo@ad`*K5dD?*XluxU9z zijlKv&etFaq;({QcJkLvxbO~ln=W{@_W5y?xj z2g)9}L-&re{mOz#71Dr`idrbXtRZHU398kG#>QZHRdcwdfzS^%5<*GQE?kkWd{E3+ zBH>{U5o>TgUDt`Q3^buBI_u|`tI4(x|qE=G!;j@V7~M2^N9C5U>r)xj}ikhe#V z9vv(y(J&W_YHB0#8ssOsIxvq!O*BN}ND_O>SdxYsRMO<4*JDqGlO`F7+#BXQumA-a z_9wYsNOuRoff^P$u$Zjv@JKYW6#bgIBZ7t4TTuzA`sPVNT7wJLp$b_RL`pbfzF2@Z z5s^yOH&x;$kkV79?2Mv^xagwb(kNPO90TPc5{c)mNx?NilBeKmM7g8{QMSs+J6sd= z4;G~@!zvG|pRQ@yY-$o6dl4ObxoaeI=OXtWMErj+9D-)IV`$_+4G}<54w-_Sku*|b z!n$xhTKGB#4n;QtdO--Cy^$#;POGWGP=Y6eE!f@>yNaDr5V~0LA+0kdSXhIqYf2E+ zMfHN2GmCaiyqE zz9RJU=7#I>xiHzjh=gqCt{?>cAd+p2;wVkbX<0BFG3&fx3?qYw1Vi;k{Ap%TBVcBP z)~>rxsd3x8>$i>=M?^OvsqqX79Whqy?1(7>UEY2~?O;vZsC5dp=QS*8q)J7TG}OBh zcw#{hC2o+pPxTh8M|A2))LlunU!Y1=!jS)y?SQS{Bm4AP+g ztcIA;%;7pi<)m+7ly-rCqSEZI1BbzK2O6PC1Nt#hXm;RmKowVzLXDcHjSO6HG)=?1 zRvEP2Gis%gQPLazNN=D=ob4M2+C$$M`Xp^*sVH^$4>Y(|9RY>Q%gEXGF8)au) z%SS)DLkQ}?N^)4WrxtLm-dzWlAT=@5-PJ=!b_q!*Dxj8dC%zTCi17}rf+HL_5>|I@ zf88Yp2aX~(?`7QjVA2O~M1rAeTtn1VHFcqQ2#ud!d@$m*8uO1PlhB^w}fjN+?CrJDie&dvxa$j!J){S zqn9-|<8^Q{b8>3i$BmJx25R7~_!M_twKFVBi=ioVu}mkLY${zs7l6iHU*`lHnmt9tfjS2L?lRt6qy~J zUDuSP9U~YSjC#vUR#};2e@VvAX^0sDj6kbMVKI5*vM>@R^;nPzf3GYj#Tn?A6cv>^ zu#V(M!$rt)>4l}V8xl5q_q5OzE39cr+>)&rjAh<(v{xMSJyDIGW;HB{jj=F2Xca86 z&Tn#Zd|2XemK1e00xT+}4c~?(c+rIkg)-2rrp#ML=K!jbuGWYk>56a>)iigdv|1F7 z)HR^LAy-5j>WCU;W$EZRupWjvumLVcBr@z&y51^^cp}7G?7$^Pd`TBNa4AK1j*A(E zPQ?_=mX)Ol=ju!cE+f5^m!=#Nu&tqpDo1Xy)}Tczx6v=oYKkQGCmgsOHacQ2QQ?Rx z3d^ssKX=4nft_DTJa`q=hkDof!`}P4Lu?2&VnBq}!*dHMRCiL3BZ3;PcI+<@7F;8Q z1J^-Zzpl}Nq9%m9?`Kb zGA!OS)OM`cNrR?n>8^xc5*Rq_A%}vYAtu%%jKN8LMMKR;nI4#y({^!u4)b z5Ces72Hod%u4q`>t${P-Mrd70fdkhQn-tQ5)=V-Z{W5B8Z>W7U5W_1P)v>56chalh zzhiyZ`g^5TAr8V0kn-wIftovrLK7JU5}Uv{?>E4Wv|>a$j?V9p?@)%Ycd(P|ZfPYp zg_k3Yo8V>&Fip5by0Rut+QhDjqYAtQ`Z;hb+~&aTa0h1-<|R&m1{95GsqabOcI+SQQvlSQs%GAuD(vFDm2zXxKd z^lO)y36%-o?aJ6Ie-ix>OjFp(ZKqd3oCoHp}3XT*qLeM3t) zA*6E>#IK~l8n1PQX39sK72DAns-g2Xdd}R+X;l^TtEy+<%-$vDIQ9?rkF@$kyf$J4 z2B!OneepKl)J!WlI1i4f6%)y`#Zl4(v;;YzC%%fxuil`T$ z)6^Dq4DOpk%Sk8CMTb5;xQDyRfw+eN6jY)BMGbrtgOh`A;^83<+za<q?Ug2iLVja^1(&>VDlBFJ~as_KdwS`Ne98p?K;bG+;{7uU4wq%P2u);BEm z)J3q9BWUE?uev%_>FB~a@DRCW4-@YDWZ^Kq!x8A0A^mIPuAJ94hGMbcGP9TOx@4im zlToO|4=#aLg(%oUz8HkCyedP}oJ4ZbiNxKog5P-;_`C+CA1||8FsK}jb}$748%U~< zgF?o)ECwFuiMG%kB$a=a1s8}#>{_I&b<#VcxVJ-_cw=QW!t%kjpChi^BMq3(g z3-|PbyU3y8Q3oD_$5C{MBcFhCkz<-$8dl)=alE~Z57o(=(=J%7Fnmcg+K6#}oV577 zFa~s_6;hR5PZ(Qx3u_KMNkLpUzh_HMWJmW9^9JqE<)gKcWC)gYoM;V0OcRyJBWY2j z>!$fVG+KelRK@S!Vl77u5jc(AT&FTPrr2d_ZFrqzp%X9qYhl^Bfs#kiKY?}s z!?y@Z2E#L8-JiN=xj!*ykewYRR^9P-XGJ2upP*Uk)WKVWr-;vPFL!e&y`x zIGtwB%gXSfX8wV5Djj&1wkn<@J*-^eMX4z(^JyY9u-@b%cO+Dm7oj^oqlR8X-wx0* zY8r};gs~h+h#JsacmZCdb0ZiMzC;_X!A0Z{`ycuV`~c?X>!Y3!gRXA98WDYLYEWp z&`BVS;t}x1lxJ?z2Y?9rP&YIV4oRaK(s)GYcJ9Q}T+Z9KYL2TAIUAB>Vm}D8&tVo9 zh*#gD6C9Ih0cB8nrI=SKr9pam@|(5^me_k4vb2LVkVRQ-UY|&fy?e*eX19b_Hbm+Q zYnlvc60@WdlhVJ7NpWYTlqO^u`LK~X6Qa7)QReYEGID)N29d$i=O^rPM+!d&-lh%N z9-U@UB{pG({lPk~TYXT*wb~KE+E{~&w+D^WLP97ST3lMnbx$i zd3ZF=$1IG|LQ8RI#^Xtlo%X!JJKTXJ&S{N!`^|<-v>p5oyz9Vwq)^|74;=e7ipxHv zNH36R{&gq~c=xl{|?5vCqKh&6-sRJ6saui%w(mtFwUQs%hkO=rp zquG#l1L5R?g_GJTrpLU*HfGwU<+x0XCT4{IsoBMXiTx%GP9qbqGBY@YT(TX8);R7o zmRv=w`Wbxgz!&hPk)hh?iZB(F`gRb_i6dF#BHBISh`1ZaIQ*oQal~Yj{(){gvpVmp zWI9h#V>HQ>DX8Hht&NSoe4^cuDJf6D=pBRXAhbhnyEFx#BKOo}1y{?E75md34FTxg z!HT%R$a4G6=8Q!meFY!5Z%U+2sS^jpTj)(bX)J+bze=3_cbb%e4Zl9$e?#j2+t|L4m- z#vds+%RVSyG=oEMe0iM~d<#*s@;bzFv?lK!RGBiB8kxv7=I-&$a#uHLWK)8MOeDXq zGvb~%NO~gOJ2nCGSdqZwA!TA~bMVGp^76lPYDR@sTWILU^c!P9US~HWF3qmO3nVQ@ z7w|`oqJzpri;kG>6zrJ{yYm9#M+OF9yOJDN{kaomwcSfG* z;kx^Y(|P2~y1V5OM4q-@g6`>Q_=Z+-4<(%X&p zv?umG9Z>!Oel!c;K8FiYL!a4!pGfEY3^}w3`HKU;QjGGO*&;_X;#9M94b}QQO??otB;H z9yR(FwmShPgcINxS_Q0t?F2+XIsp~X$v`rb|KkLJ-1L53Z?~foHC8N0r-aNhy6Lzq zx%HUA+i^raF=in7TCo$zf?Ow%9dMF|NvczC7?-5KkM2b`$?%GF6X|YO`vA7sBwL_iEO?amdNHl;yx$Ox?(tc;C}O`Mrk(F(L^_EMSR?~i&+^euMg~8~SjAR_@>@6VzNwyBn%u^JB7TN*NsBeG+lyA$XU$U%B9 zh%AppS0>NndONXw&FXy3f_arS)#bA)=gldvs4R@d>u`wuG8Gw?DN1`s#Q!=Z_auOQrAzje0x8bk8y0u9kI zbLb88g)I#(?s*xqkzu^I-nBRV#(%_|`Jp8-H`jgTuvcNm*M?w8cv)yg10gtIX5zRB zS%S1v0I}2}Ri;uL!!qA%@-g$WdA!5BcM0lt&O(y7(}H2+pL$!*UG1d+EYr(k$p4AX(jZqAYBacTD@7VOp^sat_;0AK?jS*V-NxZEu3MmD z89zR-h_)3YbzT)2b{Qhz`qT!4-i1|}UwhL_6UT&mba*ov{X1f$)C(><_%ej|!XEZr z=b|nPE2@aK^D>ADj>vsghjI;SnLjAdGnGe&DVI`9@X(E!jnuH`Ul$~J&%78`89~3> zechL~Mlu%Qa8a1(<@U-Xlx$l1N}ZG|%*aVS>JmqF65^EYQV>I_ZH`|oDiF-rq5%b zRj-=1gO6t{qSc(xs^t`KnnTFQ`*iX+`9`ogErCc-WE##!Pm&`IB>p`kF zL}HcAv4%$TVmWHcrD5;$I{~~)95O4)sP{9RN1J5k+ciRUE)3Vx$qXaITejxib!ez7 zHxrH2TjG)_v8t5#(#w+8hQ>PMc=qx6%;_^D+=KLa8D96M@Vmo|_aGKX@donVkiw#_ zRCe-XJ~`>F%FSnDs){=E+N5My;mbrE-O1?Jxk2J130Nm$SSml`mqm8;&5=ds9gD;; zQ6|FvuR^5!u=I~bxJo&3kP}JoS8K?}nO^oM4)i{05%2VtcvAg$TiOy`IX{~G!bCUh z$NeIS+f!b`=+Ca-JJeXeFxpb*er_P{x1-7pJzWoNkvj#x4-^mrJtHV9<=$5_8tJ5w zd&J8qYAmR#cfV`kKF>4flxS-^8jHtjTN;|g z*L()0+56&3VvOC=KCwhrj?T6itz8BymK)4i^=4}Vsmp;5TM9y%=paSP6dx`sP zoCPtONQa17(HM=jwoq$Hr>erKl>tAB-EqWNt0II^bOU|)z(FvTDQW1Pp+lqQ9MtSS zOtX^f6cif7qh?8nh+DL{ip(XdZnD%>UD~k>YG2gH$korGRYzCS(2+E{;E%tRgPrPF z;)@{(sZaZ02vtbf_B>kAawW<4wKOM`rcq_BYob(Ln9Lb%k#;a-j_ceeeE*)|#Cf)q zKFXsv&g#Nu$t9KB6KzgiWx9Ubk=^R3^YSueo1oF0izA6oeZLN;t2|QY_Nzjk{Aknx z?)Nk(taA%{r9P8F^6Va!qBC~UCf7viXyW@>J^iN)7NEmT(m(-7^Yj)p)O&?U)$jAC zjOd^ImWg|aYnD-_2_=wUo9Xx!(jnn2pl4+K_T4iu^`8tUwYR8eXh+}SNDh7$vQW~o z&T|)XlHb~K-I947KLPaz7P@N&@PAj3Jo=>90{GyW)?S63Dw_{^xy!Lemvs7WkNIAg zyL~##d`!=KaPcS8I;REId<$uc9%ca`bw~x3#ZrR_9l=fivJ?5b9#(mUnZ|%BDs1Q$ zrcW}~8WPX0PfToKrcat=4r&AF1tyy5hNOloa$)vt|dSj`oON~T?%=ag?d3}~JBilq@PibC8@3G^vw`QNv zA+pg85nMkeIn6nV2)Mi@JlBoJWZ`1tQRKO%z3Oh0=#HuN#6n7e#6yWX`Y*)f0Au8CG=jjc!OOHiI9=%(_D`Bk&4$&M}ZKELMD z&D96gCXHzB*@on%t?w&VKr97$ zXxBvczEHV{4Y41ww=u?sF-G6!!8<{p=P}nOz2~RA>(k!#8Snb6SMNFddAu_EdXKrj z=smyWU0?RDuXxv2z3Xe<^>y$1hIf6_yT0XJ-?rZ|*LS_=_w4u0^#kwvp}}JS?Wo|j z!2TGYx%~;=TlS~;`^^5_+<#%NS@gDQq*!a+gYBdyD8aEmZ`Cv z0c*sZpOWJnkNGsdUf8BrJIh~>$l_gY?{?NFg=Kd}pPp?-C@qLx9DDyc+50SnAn-cG zo?=fOh~4+SlJzbb*v<-avNkfc*5Yez-nRX-0V!nqF@@<$Y`BU!>`2y|t;XT6VuRTl z1pSNss|R`y1Wai6FWJTliVxhx`V}Mm{)cYHn@wy0-VaRSm}{^&5z~|L{uJ!wGz9ir z64+D^SU&{THw8=_YQU9jVS_rtIv3OPSub`0BDW4pez&)Ku;$?a2-Zl1HJrcbdbTSHRVfP9sNB)*Y)t=lHa2%>ydf5*-zGM$ zo$Z1dx#KZuXS=qu2_3tA0s%kCGvohUTitLp*))jVkn$Y`<0S;~ zGS25K)HKN?oth5L(DV&#`X)Ag3!AE>R4%|=lFD7(QI1U;CFb=Lhx&%PdshQ=yLb-= z_W=s}N6ez{aCu$qjJQ#0!2nleb4v!G$ll2&u4h`bq2#2*RT*49!{z~zq^d`BEIZk?rj7y(-cBKA5--_Dx5IGHFr@ zZX{F2tm#Hl7z#IIuaTzku49p?s}1?x>p1Vai+3H5ZArd%^{x}V>u%olAP-Imf0r1` z!PvF180Zv3_2?-~5X@pl{kTJiUJj-H^_N~?{3m;>J3>p21M?%A9y@9vQt z$Gf{Hr<-?odvbtY#>RXJhq^Rm2T-A;!knBt+02}rW$r)9RvoerrA+P5G&zvWIg~n3 zZG4aaYy#SN_hJ`~Eo|0$w!GNw+&q*ekqd01VoUOsx$Z*OV~<|Xl8W&_R~05l zMa>tv&8ypfO@f}Bq1xm`wO{_8sJ3{A)wX%nMs=>`R=8%s1~$a2RG<^ud6Z90SC6_a zp~!w1vw1hRf#~%hXYd)CY#E0lMDxdW$c%e&z?E-yE{L^CfmqUT62>huK4T zqrC@jvMc%F_B`HV@6TK9wS0wr8b8v$kRN4lKv{hBP~2Nck|dailhH zb^WM=+S$P~OYUNaaJHTufHyUqJ-`l~Rl13VT#J$56m+YW(0tV=IFn$}$=C`w6{0=sV|CJ5ro7i4_3)_d^$!7Dr z*n#{W?C@T;gx|*+_*NF@53)7z=xveVo(?r(wNB`_ofx62*V<6`$dPKa=jyN>xqb z+Yz0!ef7`j4EkIj=<_;&t0Qo^=Vt_;dqHNDeGM<9=M-IiCF`&x<@v3^;F0lHSt);w z?ZRJ2HhGK9f1lOy57-L+39`qR>?-~>yN>^p-ORsXxASk=o%}oYD*usN zDD4ja88yN$d_VpxU(A2wA^tmG&bRZ^Fls#C;(UW8_|>QpZm|^KWCaW>b@M#Thf(&( z!9J=>R=TJ&D;4Li_hxnjB^P6(OJ?ECrJfIc>1K9`OMuHzd@r}y)Z!8}AsfpC8eJ^7 zVhg*{B}Q>6R_zdITRm8*mBYqaJ=tznE}LxSvvR99+uQ2H=2-pMA=Us^Zw+M4)?l{6 z8p>8%!_0`fCqo#lP+n?9~|v_0+H*ixsyV+#jBDSzw+u3c!xwm69(y8Sg)N%mAOc7=}+B;_L%(`3SkT~Pn z1Z!8EkKNcpYj?KBn#7K`CbJFJ9_)H+Pj;)d7u#x8uxG4k>?L%wKeT4B&#fx<4{IMo z)Etkf(~$RwsK2HWb*zu5e)~(%V+!_pyG7lBeDAK7)g$lH@c#n{Wf4OU{-H zlQ`hXSw0BQr$Lxioclt$$w=tNGT{L*fYOxXixx8hxtsIS1dZ@s-oQ%n@`{&t6&r+4 zuTsvqcJ>+yzL=osX@YKJz1{jf=sEZGjZ9%#J_i1gH0llZQSS{G=~rB&iFO1%A3fkV z%b+;-t&aBBkm79$3xMw4A@kQkQc7%6?oeC+of^KIsQ#WSWLMDrI=3lV0iTzi`+i1i zy3U7?f%HMDTJDFG7Kk(>av8<()={XWjzJ@GEEux^Nx`!{b?&oo9D?ieDkY8^-!f&^>@sF%0`7hQ}mb9L>vaM&Vq1Llj zq4k0_+IrD2doNF18$5B{73biibaC}b-Ny;3`^1yFPbv8fT~~ zthd<^>m62Xz0by2AF%P(haIFX-<3A|UDuVg`*bO7pJz5}i0~Kf?8^t(SG3-lg){T_ z4Q44Use=FEGTIk3XJ5N*sUiC82=1Tw`=*`!>-N&E?5hq9C;J+H+hs#q4gR-FpYPVQ z3e5g~8=LH^_+5P}{(A!RgU=cKamVVuZ%W<&0Fuy1%WB%}Hw5>Fyx*@H*PoC0X-0>$0bkEoS+(t1;c-4%yzo`z2k~ zk>-x${AUr}9yNOu!gVx$N;(=-2d-zmiu1UguImy_hr1IosKX58ap5O5LM3c}G7E8w zX)TU;*{p}V_tjVl*0T`_FnL^J`#ZQYuyhg@YGcF&%v}zVDUS!tQl*_7e3uwyC7}$= z;HMJ>vr{70&PE|-pQBd!0*&*RY`XOiw$l2Vt+Kvh$5{Vnw^`qzHu(_^^snq0+K#d% zFR(Ghx3l>$+u_A_4?Z5l?694Op>uD3soj@9YY*fv*+Kqy47yM4tHqvToo(-Ft+UImyX^{Vt3Azn*xuWE#;&rSx93;*Qr7uwnO0d`M&vEAD~$OwCH&ozD*wGFvjm!}E)(3G&}aVJCI*v`9Ua-Mj%9XL-& zyzU*GRo)}bS;dST<6!m$Za1+L>}Ga~ z-NMeWTiH5$1-r~%Wd_^F8|>wtYK6&lA5W@Q|6aA0TPtenYqv(IAX_Bm|2eIA={pU;l8FJi}Fr)%wt*{Swr z>^%E&w!yx_47R}Y@FHk)Fy`bRBoHg!#QPeFEO6=C4}Ft7-aqAjZQ=vk`M_;#Qc8iE z9Mfo!8IA{Ga7xkV@n8oCLs0kahv_UxANjNJy_z?gQY$_nC%TR2SKAdRg57D zB0IXBn60N*dg~uLO^WcQ#xqAu9d}9)&oiR57yoOnvJ)= zMJ@OptH6?&{Ucjr|AdqO3%kVrja_B`&hAA|^bsN0#{$^bBEY^E*@mbCJjF2`iHeRc zzoBa_IW>cp%;S5cfmodY>u{zrjawb!25V^4n^$M?cGj`mg)aU2F{yu!qB ze40OwFd(Z*13w|) zif0%_Cn^T9xER8Y5JTCqVi-F`j9}};IJQCT!mbj#vPZ>4_Jk;7FN(?RL$L?@M3l2H z#a`%~R`A|pIv*;kc%j&b&la=zLQ&0Eh&lXNu^&H4%;lGgdHiazKfhiqWP-l2>Iv$7 zXo`rZ$cGkFJ>RrD&hI|!lg|!&$3nVaJG8c9K}h&Jahk z^TcYL>Z4Ev9L+uw$KuqUz=b%OXN%K#zBrxt7k}Zy#927SXYc8 z-Ca52m$`Oq|1wdWTS1nPM5%-fAwRJsU$*mw5AXwMBG4!vm=cji-kL=*RatC^caTXB zCfUK+I>bEHBng_w4=vL+9a$(4ckvJfV`yvdEl~N;&X=rbHzgJ8VL8EkxQdnK1MTeY zf|r9XXQlql$70%|gya@w9{2XN%5)o>owiG9c7GwU`cX2?e{l;NA#P)(;;(F}xSKVKdyx(AM>X&OJ6Al!+Qh@`Idoor z5|5+z^&}r5p5~?E8NRc)m+vNC;CqM{d8K%TuM;<+xW9$GF$5Kf>tNr8yy5P1xGZ4~ z!QpI0N(OrTfPPUrKQz#|2Bx#ZVHrH25qVU^(I=)=zxG zg5on&hF_pme85(Vub4&ub(n|!#a`gH7zMF$J)41-CNv6oiL7T6>4{>1JRUV-9`N>O zQueDf!`w* z=Hbchq-yWX-3WwwI30sCyMNTj;rMGoE=6mr)+C%lbi??gC8Q(ygC(dVXO(W^v2DB^=acS?j9*W8?ySaXR=4uj4Xi(1SFGon zuGJgZcDkN7!sV+ow~wQftJlogbNU<@oCM zPRmNm|L`g1tKXG#}Y_X3deX5_;GEC0h2WRJ~uV_OITl=`~f)m199>Pu{=4L z1?3PnN{(c+{(gPUYC1uCa3W%Ih~iwYThd6@MGj$ zey&`=*USC+-Et9sKn~{HWC-2Jk%>JLI33vtLvwXPiVkQ9`SFGnC%E`-X1mjQ;C?i2 zI*GG;J72pQEvNAYi~+PslH8ILQS?q~=O?Fh!YQswPeMJ_?;V}yUQTx}e{nBoxR*2C z%USN_?Bq^z$n~wyF{|DcZt1z$Xe_4j6Ly>fLxQYpj1B148T z-1`6K7?SLNv0L@FGzZ}J4#T-4g-#|U`2KhCzj8*$jLgZSrcvI>qcXBqHXSe=dO5?G z;C-(;d6%0kRwfJNR=#=t_Qwn41AKFtN@39Md8k`V|95&%ccrh%pa;@vcnP9hnu2wA zhtb^A6<_ju+xdOwKrtfd4rMCc(OCHXCeUGDt>2zH>@(ir^#J>-o&U{%e!z#@{YciW z=`)bWA2d5J{GqP;+b7W<`-=KQxOx2HcK!&hv=k`Y9JTC%|BOxA=AP@iBT0uLU9qdF z{wNZRKUVBNvb>|}kGtH{K}A2|UY;!GXit(xkblqCpb@NNgJhTull5$zY+$>|!`Nim z$jW7uRmsEI92sMA8E30yD?47UV5iEJ>}Nv%jA*l8o8R?Dvv@#xrW^8!fKQbh_$qlZ zKVDwS{~|Br&&!RLmRDFk<&{<+d6hLpwpk_eI%}M~-kKk<9m|%)s|z)2?eg!l}&SGjvN! zt026`O<}Cl^gFUpC%#epIt;1o^OZnMcBl}ZP!YyZ;;rCg*So5QTP~>7TCPG}E|*z` zW0$B=HeJ56IcYu`6j45W>xA!C|6BI(s@kM9t&NvHQInoh>mq}S|I(}&AaGzU)u(cq zA0`tms&itEwIo^`EA`^3@+75FIWciq4t8ckL}oY(*!ZTL=y!4b@#PH|@aT)LH1&L= zzDOGLTcP!Cu>WAcZlc`V^iOaQWR2@P^o|VuoV@zJk|VJqTQq!1ad*I=jq5xA-C@bg zX}!^#1^Whzh<11-=>gb{cb=YI*HB+k9r;SD{ zde+Zu4Bc}pEz+viFFDvF>@_|bMwh{!BX!0)cmi)qZC+h5_8*o}{qrjiEcYMYY;gKC z2}ar~jy``cTXh@VoCbOCJO!Jd_T2{e81?(~T=%(#>^L#rbf&$0Grl(0&g|Uo0DEnG zf~BzUeitQ%$4#-}^eQeQ=3V}~<)16r`?$#lfWI6srGE;P-h|3SrA-9Xk61nDqdOi!rj*Rk(9VGp<_zP|s_vL*#Ann}f1oVos0ltvuPX7_P$1&WU zutbdo<%oq|85e``uY-xx?iuE{Ztv1ppG39n&%OdQ7Y(M;cwIMoWjgI)`Fl+3u4Z{c z80f#ji5NvB_0{0=mhLVg+`xF{bH-+r zshZr*(cQy%a<+~D&Xh?6_($eGq34i=KT(Rw-gyxzK#mKg)$x3SsEbi3c1YXRw_s9iypPygSRts zN=F-99vLo4`E&Jasp@T?t}iM16Iw3D?W(pz_={i66fc~gGjm6_7gH|b`E$PVEgdB_ z@A!HcZ^|t1NxYHrYF-YM`O}CBP9D%6!Tc)?#%5Qb@7=sn`s9d)>Q*9db>05#)TG^h zxYF-bUc935{Ff#1^l9Id98jF54f)PQTTZ4?0B9|}NXJ;EttNYtxzO?pbxRaj;L)vX zSUD@Ik$q$qFvfT!Qu5wt;>Lz4NV9of=v=%1@$e}nv)!3SRUL*PnL0c7Rrmf$sirji z6Enp;)YmaxUFNS?Cqzz?p;}n-X4CA`PZIZ&9_Xpti`|}Zlv#@Qi&6w&3VKL}z_vnz z0LO7WiP(InlJE?8(OZE(0np=>D2{mXro^n4HEcbeRm=T^$uC;&e&&oHpEa$M`Z4fI z$-TRjRz<>Dm|)O~VGgGG_jF?7LIhyX)25aw2s!FeyM%<$#**Y7Qa5-O< zWn&3H39n$6SyGDa9B&=DVAh-q9KM(XxT^i-7?@>J3e`x88||q@`Gzfc@Y%|Y!G=*R zI$6m*zl^cGK39}} z1_kOO7egzNLQ=G_zKS?ZuQ}#&i?ji5rpbe^&LteI9fPNd1&{dAvhc9~R9^}>( z9nxc4A-oU$(v4MZAk0*6Kho#TP z^X!AmeG{W4+ShJP+LzRP(AX#b{pqX}kwKOlD=J}BHL=O=HsbG#?QnpDaIov&#zQg< zCaphC*K#NLF6>=ncn9m?ob`j>5!}wyPG%m134gA?AAMIqo@1^${^9V^{? zdkimX->wpDYwJ`ZM%QQD>F|nYz4v=&YsRAG&&6WL%CU7iUcwFa1(L%DdoPEN&qkf< z9Jv{M;eBDn&nk2 zL{h@R_V!gvs{h(K!4L zz+8B#SAX|+&)trs{3daa@=xz6CNizNp!&{x?&Vd8G|_!kJI$ThTAZYzRTc`((PxRG zt3RBo{UZh{To@c!7zm*pPyB~m**GCTze-ALflexw&Ku-s|F{>kb3QV?;Jh(&AbC8E} zS^r15>@LDN-s>+!B;To}W|z~7ek^LiTMBOm$BYW|oqWe#I3Nv4v;M!+KmSGENDGyb zqvRN`o{&TO{XRR@9T(b>#gs^lsk0PeB~R&ZDOTH5>co6Wmf0s+aPurygNjR<*n=*) zxMQmTGay(0$6M^`D+IT!mE{5_N{1CUHuz+3#=HIFUjTRu~P zQI-`_HT%9ytm_sq?9?=5k z9;bB`wN%}o(q{Q?1t3Fen)~1B;vN%T>%2969=hiw12igG$sz59i+!{OynWQO@^*cm z-`9!Tn8>m>e;j0PB5!1G{u0U955cR@-X%T;d1~{}f0O6HDxKNw@|?NmcRxz!H@cF< zljtKXB?}<4#rMLvrZPYRl6nykQhH&dlWQRe<9iY1l6s-T%7S02ZGm1+{Wi?v`E;tX z=@Y~2x+Sg=WV~Q)X5RQ71_^u$@sF%VIw32r8zqwZ6j|AS6kg`HML3DBEpT_*L;4lr z;hc-mxDW3^a&9tB9S}1{Pm*UW8*&LJ=>BE&x-Bj_4o#6SW_&IG)5IyLeG%yRbI5H& zYJGKHwAv0*9!;-?l_tLF&_he#485ua0cM{}cxR#_EBUyH|9uQv|Ay=_VD=LRwo5_^ z*J#~X>ljWlsT}VhUTAb z_CqYpae61A3>x1$mUy2rH_MD4L@Kl5h?K)YSzQ#mdqXdA#-h*FvDu2+-gK^GJ5 zbmbVFptMY$;x){3hp{!F-LJ&HI(!jut*U&e7F%_*KNtf*)6AHkF;}1j)R#pGP&KI- zc(E8N9*V+Z9YYoT;a8n5Hn405*ugaV?h0ZWZd?r^8HSMryyN^g$S$b*yZ3oHk7T@i z&BS(omL#hN8(c|br6Ac(#ETn-yAjd;5H+645FG6=@it!%&SKKsD8(1tF2y0#-dUZC zW;L+w2zVQ$2R$?SvMCQc@U{LJ8I{fPy{Rv}0 zsyGUHFZY?rhewojvOjr`CYG3I5>*mb+?1`@IX)YYa?jEz=AUYplt;#U1a@EfiRz_q zARaqui|tZ{VGM|s>2Je59of&xY$IJA z5zL8i!}1^LJ4SRz4CrUA+_?+zFl$Wj_4X5ZaqNZ9++UzGrW`|Ov@07#6SuF59#d{| zAz+|tIQ)fTLQCX!kYF>&oWZq59g$z$0#kDgnBabAjKKj&Y*bzdw)~q$ed<3Rm$N}t z=e_nmgzq?km^b!rXCMk@dtp~z zF@Beg%Fu-Tj^YBS8BN}6L4M~Ufx5$#*#1vypH~9)$B6un-!(BH(BNKC$XbKV*ZY(k{P3#oDoVI>DR6nZ zq10#Nlk2d)uZz!kj@Yis6cb}e@^=?g`;kIZT$807uE5@zl`N~3YZA5i3kK8zl*R19TTu5 zhmfl*bFkP+;ojsPAOJ9g?9-|Xix8+IFYRS?qqT(Sc>}DyoD2SkBT^ozROx$RcYY}C zhVUP-W#r+5+5L3#v zL1oE_^!pK*l11+FnGwi1pVL*^pRQmT3z&V5^IyBiw3h~H5MG;3Dm*yqu zc*1Hy0!I{}K}h_c%TQc)Pn=Q7C%5uDY20Um>`>I4hPzIVEG_x$F!G-IO*li|-kgxW zYN|{H0S(Ff=Vq*W z{(6x4hqjv3^PPyikre+Dv=3o2a-5!1@6`~+)c-H)*R2+jDiKylp4hO${+>S^;m=9% zsJ(-Th>tV~_4P7zo%a)CfZKlG_j1I)0QGPF&$J^$xZKAwo}j#a%800Cc$HhS@l2Tk z)qM+nlPJ}n@?q;AbjQUg2bv5vhh5goIBbU$#%)hpnynXfUT2g~!SjQdZM6hUVRt9L zKiwQ;u%D1h97q|gNl!E8bOAz?g#}qCPAy9zzWycW8)l$B;;9Dvj~=LpQdNNY%VFI4s*lW;!x@xR zzW%Yl&2 zCCi@Wu7o#dU?cio5BxKu?sB?lW2%$SQDD1V`q&PP_OIqB!&=6Clx!(clCY;RtF#Y$ zx8W`502;JwUlF^ix`b^k^X>V!6fqfGF-)oWz%Z7#!B#Ej{*!2Fs~7Fj=c;)|5zzdA z->C!-&07vC%tyjhe^OvBM?#@37af*3cWlVu5&6$|AUm#j`K!OAY{KZ)%%x92HlsoG zD^G1Sa%0J9zv|rcuAWDkuSNk?P@O8uutIg1_MGjG%FP>ONfNw}hs>y=3CwMYI|%B0 zQwYt?AeiM?drNw?L&L*lCBVh}GEcROv~%O9((vbMxh_C^<6gGDI8u!n4mLM0UnlvG z<8jr>((l*5hro@W2p(w8OSwu9F*)8zEC=A5pv;YwZ}aXCLCT?EJBCZPrL1yZXydu6 zlCmGJO~u=sls>}rQVElkJ{0Tn5tF7LX0AqFNXa>zr>GyOLM7t>?>Wt@lphX5Wz}9| zCseQIYN47N0Zk2NVdS}YaxFl}ekrCr30I=6Lfk5_6LPBxAnvlHIVa=Bt5b3v>KN;d `oo3-5LX!%4=Slas^aaVBy`ZpRiM;=xH-P=uI=2sG|YFfIi6My{w>w&9GP77 z>+h0A0OjWhU-wl>1VN@rX>J3d#l4Ou0#0xSHaM z=FHN0JNdF{wvg6kIiMu`g0K!8K~YNnL$lg@vpb@GWlAxljrC)^I{|-1N{MBQ^JB0^ zuE7e;T!0nE86yxexK3lj;Qk3lk%9c2pKK(r^_wkvLWT#B$t^yQK7k}{&1YBOF{B$b+Vv(p-T(pr6} zgyR}#9YY4Gut1MiV4BFv)_ch|+D!v)++CkCt_dc5Qd`#9M2=(ULtH{{WbR`3im6s` z!Eptb=}8o#S0L4DXsvWS>RUGQ3s>L)^Y8s3I)dr7PtbCBVyY_Y_XuL-90do80b9Mu zp@AHKdghtV@ZgiWov3^c7{Y5LP@?RlqVS7HD|t95fJ$XLv6}WJoZjFfKDVT+APc-& zvX(hhjDdRJUF{$`jc~I=Cr?s;;tfGoyDSJRUm^*dgGnnli;4N8)5wQv=fj!vBSe+( zK&^pN?FM*|>dnk^DtPb&%}#ULc*y)Muycl4W5fXbAZ+%Bg?Qg70(-JnsAatlrMoz} zSQmKW_+S!u_tU6W4?jI}|86z`RKcQf5qA%5I0Hh74{lV{;-w~(dulqz!3UnJvis81 z1X8WEQC3^@&Hj&=E2a;-0yf=Nwt^{G)9#U7L59y#D#K}=?74jQ zMJm=I<+1qg=DF0|5B6$Z{l#`OjUA09MYUXztuCt4k~Fj+(4Xe%Om%YwcU|BZ;F?2a_PQi(%vu7l~D5*n<+ zdB4S_v|I&@(0YoyJLGhk*Ru_d|F`+4-1>`KZXhhGKiZ($68RhTG~m}AX;41ryA9z_ z6?@UdKT0ARj!}A4(taWnU%IL55?E*>-hg;YyMd>{c4{J#+Q>c%AaKQT=nlUR)jFCv zi@9MnTQy+xI!coBrwY-m z?-yazmH;7b?jMYuNDRf1NC&F3bjCyjgwn^?LrA_YVPg4xW9BcHh(&^(KR#5kfSnjW za$FPQ%D_G%vOOk&78tNI@mFy7pXQHOxyEI&?4vj$@bPMY(td*D1En-}FAgWzQ=XlJ zxJ2JdkmLUzjww-!M9>?#e>|$?4L4Es$rpC}?zivxx9>4igjuNwK!H-?2MbF$hn#kO zb_+^C4jAJ-p6YJ+D%6>5X8p4I>&HBC#{bCYyCv=nV`t(>(E8}+Z%y&8LwofP+6RrI zk{Fhfr4d3>XcvfWSB5}GM1^FXh`v4J(&Do)N7t$tFARON=$r!Y)Xy+&ZB%Buzr){29DsV@^u+A&G0#dk&eW2>kGniI>5!eDb+hd>U0i}Ks(6)lR zd%!r)%(wVe5R6Yxm%{Z&}HSgi0C<&ks{%Ug0e zwdi5qD&Z`syO2L)?!ocXbWjjn(VdI(mi5+l5D!?;g%@+6qW1PF2;CN@E;)h2c;qXn z@NaUA*j8>=?Gwi?@IaNgXoEw0WcbI{Q^h2ELpinTfQEU-A7<{&xJS{`rc}PefPUr| z%I|Hs$L<$+n<}96szF5lS&EE8;a6^T>Jhd4Xl#-zpm$jv_v>c$1_kT%CGze4YrpB8 z`p(?1x!r(>7O*(_*XQwWU)T?9(Ij*JI5%L|QjUEU1dLC~Y0CNxsxM#;Lvq=DUuB3} z$vNmm@ijfTFJ{@*e8syo*)Q!XJUC~HKFFhkB%y`rTaw4)H#$G7-U!Cvt52U|fy>|> z(U4%fF!ddBbm}4m)sFa*H`i9j0PWA%&lmcLprob>N=y33UG+a6Ef#0Dpgq38goDPZe4%vSqY3*Gm()`-9!zuW@V8DrM}S5rT4l*{A-VAA{>{@nMR`{Su_{81+o3 zs!P(6i32kP>1%KMvs;D6YD`(!r$CnzAqk?+6(qEjx7~pkYe>(lQ7*RcGym~`19=Cp z7|%nS=i_zpTg=_HUhCDjaL8L&jmVC3M03wUl`-OC*~d9o7;}E#Rp|u1whDgWP5gWN zUJl2+y$*ueHxJ>zVNL;Ub=F!Z%TOIkH~2sM^Kg=bB3N0l1H7`vFp++&*j1U$O$@D< zRk`G0q^Q|E4eSDiZ!g<^TF z%M!2YU!0HHQ@^o9^B;I$JTPH zsavUDjUs}fni*?lkVt_e-&h3RNT;xdC7GovALFT^WXK1$#0c%gQ-co#z@O&$& zD=xn`PZt}dFkZ@Rq6L>_xDNlrB9rq6y(Z;B6-UZpjv%cz8FK^*K--+U6yypZcb+~J zRDGjAE?|iW`k^4q=LPvZnKMZkBDp+b)GGymrk+76<@X_6Jht2h^%4rqbCMN02v_!E zq|6%%V?5-SDKmcAyOw=3WR~HZ+4t^5Sh zUhEvmeL-&;{=h1(1`IReVq@W=M<9X{v5NUFDBVhiM>68_^qQnZ3B!U0 zW}#Cf1k_I4kT8Q0r9C9mbfzI}l4v#wI7RFiSlMW0ksxLrE!$|6R&3KS{SmIc`n!Bb zU^=xP3n8kTX=J*!9L5FC;t;-R=h{d*i8~7+nh#D~)K|>w$&6`88-aT z`bg3~m}x@$(ioNpj_mN@2+N(kY1nIRg9@L+e^K=;2I!1CmZd$doWSv36!g5Jgl_GY-4rnx`Gzp z;ypKY<-QuFh6gT;l@v6-n=ePJq0+p-`4Y3Tezl6x|5A|o$VBW2yE*{TaY9T2;hiH? zb8}qKZ8#?dWlkvXxOsy@2k_VyzK}0ChJ$hkcuWSvR9Xrx92(j479$COL7J#T9MyPESp9eK?qGWW*InhW7SYz z7H+3@D?tVp`q&m01AZ19avXU52&~Y@8S=&@>-Ze$^n0>Rh8X!VF-_3#)b$UC1hF$9b+}|Xlle+66|v$xlrfGa=#F1g&P0mdYH4p z2#<08@D2@`_c#v8m&4ELC;+#xn%V;Yue&i9u@I+}6w+b{55 z0{fdIVD>&(oS`Bk0~hi*k|9Ah)q8!AXisrL6OWbae?6bW-}zlLIOmwq$OqC#B`~WOm!a(u0SfT6AfW^Hku z@4H+BHC2ZvNi`y5%Odh-!bPV8zf>}u#ca)k&3seoRViD;6as(p<~yK?7^Te^patuYcZn7L$3z)?jUhj*G^OeyDNq#%Tc+$Lm9f_r+v0 z!c*1JECzPQnG(n%Vblxle`uP*TwQ?=EX;R2*>7wU5%1PZ6@!t>-Kl;J+sHz=hR3cv z{T`KT4oipAh?JsjiMn3SdF-+M)6ObW(Vs3O%dyZ1tUDo%#~(_=eBf@=O>=9XFu+Wr zCS%@FvlU1Vv%G)453E`i2BGZ76l(x~*t$mVh^e~0@;Ah8OM@WfX$Ksa$r3LEwP8er z6wr}PB(anjh^q0vUGhw$buV@J;S7&&w{Yg9je`GtES!+t7bat32xPe^F&{)S<0%1@{P6iM zcKeSpAgF#M3!YEd8It0{zVe2P3eM?_INsh=MF;JO3ach7meJ2t78aT@y3V?+0AcJb z#v4)0EJi^g@drr`L;qm!3jeHFx~O$n)ueh9*aPO?pk*ip4gd80a}xekUhe-)~Y%~qg}c8aoO72LVKy7*VM zE8EtDkV~~3daF%-j)r{mYGurfw%fesiagh_&7Vn~7)R48Qh+u4C_%MGd(|@TODk}1 zK*NV`^E^;eyTdcsjWyTKZK$bQ_s*h^|*|$tKqw-+^oL_7R_xjD^vURn) zGCxhl-`S$QaiCF9bLfun_V*ZH0S3NLM;kj5N&+n8LP$dpM%zQg#}@nJk-jHZ*6ceEK@-nnTF2h4NgU)M0Pxr~vImXvV__$^nRDl50Jyu}l~zzXu4zpj#o4U3`@G+XqSRyQxfE2gBjai*iqKwIb2!2qceP;0YRT?(KY{t$VD#_QU?te~L|1BGC}G+5 zu;wRtG5^cL;_Uh=&yb22MFnwh`BN|sfs)mnq)E{7NuW5`ksALUZhw|}n5UU>Uu6fb^v zh^y8Z`CCpXTPBi`inh)T3gUte?=X&Jm*AeNZQy#Wnd2Lit z+Lyqs`Y{;l&j7KNFrEyAYQAedxf)FAK+M1eF*+T%Td;Y7a6SGeVKq!hNQ#kJJqsUp zHC!CzqOm^{L{tb)eehPmZ><<*H)QWDPRb_!gH>T11fm47u~6v|aGYWt1&I*_o_rn5 z7$S^V325l1h43e5!NZeCEQmCzme1}2R7j)Y*C1x zvC1tHhsu|+wc{_cz3oSLWHe+Zx!W+ABy!e>yC5|k3&_oQ860@((K5M8G|-tdN`?j) zh(>QXb62;>+E^^>0TN<}h+y1qJeA-<9R8R#};VHQn%x;#XgQ{thQTOVXkN zICHIt1uM|x$Evw`Z09hfpX29zngFF?>Fq(R1jSNVys>61{I2D66(;^xyIcINZUS`= zGz<(Ll#6Vi&x4=CNrWYpdAA5vhscj+5Nx?H>!lrc+W`BvWt;@y_(vwa1rvLoHM}#F zZbUzsHK{EN$HdIHk0Z(0z;JYPo-ssQsQkzYwpU%K%s^VclOy{fH)%MZ zpFWVe##cl7m?=Maij<+on(fq*0wkjKd z>0&b#20s;2jC^)3vhMGa%TpJb`3sWuC;K%=8ijv)SyV&37KR~ijk7*w@QD!orHSu*^{%H1*Mt`Nef z<-(`W=f-D(d!OZ*#%httuI#WKID@6#k*1nm_MEzKrW&#aRo&sWtlENoyV&hoH-r+l zkXnIPd-Pr4-S#_Erxr@dB+oB;RJak{^m$15TmNLB>Q%A(e^@F1J;2?z2%9Bx!C8{8 z3PJBAP9B?Cc|fgSgQ;Hv=EkmP1h}{o?d5!v5b3H&*kHN4{tm>ms>%F$;A|c>FN;EI z?*yf_cU@VnPM$r0^cf~?^d!^SH{e6-`iXWie5_5igJMn=Nev%op;X&ixYy&z2-z5G z;$OS0RT9fJoo=F{&F0zKOjIrNlbE_mQjCPkAk<*V`4>2Ks5Sm*O2L=}ItbLmvG+Ub z>v*E5o<7N0q3xn5d%F0nDdVN#0?x+o?Hz?p|1xTU&wkN=wk|-P*8jb1RA<0BlFW&`XoK{#cZU(LSV-pN^T^B694SX?=0p zYqo@kqjMO^R@iL#ktT_hne5{4T!ho6LA(ueu=BG~xy=q_%N5DoQZF8GV=zC09}H^k zWx(;nAKN}I*y-8IbBPfC;mS!)EIOj(8A8ik5XScE?``-Oldqj(F#NMxyPaYP(dF4~ z)E9N)C5}{+Wnnx&JbMF?B>klq^=xijCr~ke;}X&;{)@bG)!+~1TGSjHFVS=>R?+e^ zt5shQL{5EL(aV+PeA~0jTD|6O;OvJ=F2PcjcwsfAg{Ed z4_1cN4T%rlA3w1AvLqhXQ!C0TRW7tfVdpD^!6 zKoS3C(WCo^Ja9)qqHJUI4F3ayzJ8~W>N4rk?}Oia#@|rs3K?QUfIhi-7RK!=E_CFX zig=#4h#@wHz!*+%bjl)R&4?@`RpgmPAxGqy**Y-2TbqcHW}QVLXvRnwi}J3kak*cA z^CSW3jq!i-$OkzstP?;%K)S&|K*&KrK#T#dcFv4q<`%|ocCHfEcII-{0CNckXM1B; zS950uQ#)f97dK^HSukO2{-UbdG=PDwTMznBX2G1S(Sm3=u@s{?>SN7w_ibis^yGmy5YAl`hKx{%6asl4ERjVexXqk8c#(w# z)C^n+=hJPFB^wQ@PNUN#9=C|la?J`4Q!o#qYqNK$t5gYU(>nID;98HX)ff?*t;Vlx z=R#ez4N6^;56~hrNh*43!q(v6wfHM#iFJFGs+7!PAG@t`@G8<#;@7}``K=Bqi_(3w zS1`_Fto1q&kmxwRlo-@7ZV^jhq6%&Ji?!b#5TX-X^(Mo0aig2(%=pzXt@xAnfBucn zoPNmc11DZ_?1x+EKB+~z(_ZL_@RIbnJ5e!4oxn zfz3W4Y-g(Zi)tibF5aW7EJ-qj<<%!W@#P!%OKK$)f|5|HxWjc6C4OII@~SOhF$~v` zaGkQy^L;#sFi>|0i;cx~(dnIl4b47+z|c zEl5dVNlV%$F@0+*hRkG5@`SwbuNokQHgUS${&lGeqkWJ61LrIBXFe-swEGC-%xSdX z#GRLiC`<>J9OX&3&$f%-40qSh=f?*Th{Rn__(Qs?lcFg2v5q6s1Maw=mrnd)P&j8p zxry{}BNU=bV)bhS&6_Un_DE(pX0_~=2l;XFKpd$5&pi!Iez7PWPFKY zX=b`KLln}@|N3M3t}5456Vw{>l59U3J>fUFptClNwDPa*gzYEXtlPWoE{Y@gc#7 zFVtzRd9pMXn5(CYo7!60T4a`6J!cvb7P%L$^*2|EE*i{A_42$0sFI|A{}Q*n@O1_^ zch=a{T4-vW8f2g59#@M-HSj>s*^w=cHs`meK7Dpo>FmJMb-_0NkK2qU&3YzBV}%gT zfo(&X#8li>Y)yBvuo2!;>rh5*-GWG^S!qkBl`9JgRls9z1xBdg~@6Gwo-F1>gOWUU5em5AxXfCBzIhkceFOUMAf_|C_tpvJ3^zyQYObO_Y zXjxNDr9YsguIXLQs=DoVwgnjwG{bMZ&J5Y0Z7Mlik`4VxoW@u+UXowKpdOc#XE z2$vaYEErS~EP@w1MMC8Wn+Ey9MfpoiY8NpYUQWsxPg9)_^Ht3P$VS5{zAFS2M0rKX zgZB+$gv{N~=y&m@xMjbte3jVM^`&A8vxd~{_EkiV4W2n*(P({%;nKyp@6Mj!b7T{M zr!4`sXi|(OuoULtDA{Ojv*nlUsaxZSMWT`tX4CRes=6)B*%|jlMH;`mq_vuz%i)yT zUJ5<`sL=@&s&`dR9*2ZkQnF~;uZX5M1gBG#VA-PKr8T`maEvP&@ofC|40$oTZ4eST)5m zpnAIV9c<~+wl5R2U3=14+oAz}_4^RLX>cVgE=}C;2j&Jjd zQZrAoQv?Q;W`>zi$iKlnR226EVC>TLA6%EP3&;59n|+EMDyuHgg0_YY+B2}DKQqqf z(<`O4`d2wvir<(-(doZwaF6n{AZ9g)BI)oN{8HRC$B&K4=d?Rq^ERXwQlVhexto=An-{3{HqKm-=BGfmP zdvZv(eYzgOBO-8NtVpKP2NFW(5~3)EVbJ7baU9zP>5Mr^qgafG8#uU`92h<(gw>|u zaK57C7k7cZqGTFTSFtspB)w(L2V~x@b6tP_BQW(CYMFo8e61y4x{(}>BWgX!PiCZP zmRl`I!EmhAX&c>Su^1b7xU@b$(31M0vq2dx$==3TxURZt**-`xuDoaj%iyl$5#ge{ z3zbaBdo{EU2r*S&pMZL5K673I;*YvNpKAOEhJ}iajHLI}?!T|joOvrNG-1uvyu;^! z)#4x;K7QOKwp`X~qD|GcXn|>rk#`XMhf&S< zuQZCLn%=Nx=rx@#C!QUvcA|D|WSx`z5GPITL3m&bWfs$ZCr+y!?Ev*0`H>b4PAu~a zo2kYc$)1{)kZ^ka{m5gvy|Mv+GMN?@%CdZ#Y-;G$fMaymSybwDgyJyAFSDKdSHON@ zM~wcnT? zXW5ofb_@>wLscDr(oDkMPpNYX0)b=y?kf%IlczB%kKs@QHUX2S?y@HoyxgqmCWrSl zeF*!l)+z|$_9f?tG^y_vgCz`eTp@#`2w=grIqV}B)me6|HUu%;B9rUInD0|PF&n8> zcp8=VZ06~or!f6Rq1ofrBpz#7?l9E3st>Nc2GW;{^nQOr3!-M*A0+zc+3E7h@1nOx--g8oJ4Y0>-CHh@C z+T9wKs1E*QCFCXTgxdD|(i4kTpn`qcm~<+sW=ZD5BA|V|@!9+5NEzeas8dHjDnEy3 z6C`OFMQ9-C)q^7$NhStddft7xzt$ICm-rsq^{&QV*C@y`V>k$s_-V6Crexbt6-@&vi*@AipM*8l9 zip*QX%zuns!h(}4RHsFd#w*K*iYiitF;iL~_L0R&RwxV( zoscS5Ok&k?MikG~(wG!yPpBL7YpahGuvA-;CwXN}g&WJyc34%*oke3~4pEAuJhrUA z>?YrQ_pswACO`)}O;HbRfiWgnSqz{jUHfa}N*W1R+NG`;Qi>zr^9q{lmeVpI`MwA( z5yEx17{tmX_6B}uA{thHAx=^;t9^h>vU-}Jj@pWb;aDL$+e;l56^^TF-GN~Icb)x! z3Y~d$ng9`X(T37@LyAmvy)#e}>*4>y);R@N7Ixh_9ouHdwrwXnwr$(CI=0zyI!=c> z$xg?%ZL`DE=X^Kk`|Gb-@5QQG*YBKjjq!}h0j-5LEBB(s6E|21k1eVj0wYBJP=XTpee#qFk{S@4*93}HYR>IQtFd| zUTmK6nEwmm2it|Lj;?Ljm>GOVru<}rBWTR;0v6?rI&!ke2Qad7!9AXlz78eNk`Q(@ z1M{+eCQjV<%Ih!WkS~A)5Hk9%J)$-}Vmc`9NnCUSqpj3ec?{VRS}@d)Ywk-Tom|r8GJ46u052`VetB4Y zDE!}*$x9#T1c?U**1!t}_Wl2_O#j9$X;%{m2NPE{9|uz>d$<40T${Q+{_2a5!p8u% zdo~}^(Qui_Non&@SI6*@plrnxyAhUK@tB~AV6HtTa$(V7mB0UA12 zdA&=Wyk4f}M)hKsW>agNe9-a6^U)-bV(|L;?fvub=?MGvmfuw8ao}|4ae?1H`}QS2 z7??&$Kiu;k4NRhEXupb%GfJWfTgK=t@&YE|F(eGO+Z!&_$o(}W6-Ks#sVcB6O%^ZJ zl?n^F)*Wc0oerh7dthHROp7eA1SiRpPB8y+&hwcwWgZEU+pk%FB|( zug>SeuyWa!Rj}lDPQ;+v)rVQ)DaMqhF6P)>Q^ zN2m!DIr2vT85i5?5XR%pay9@r(Tes4mifURn?Gu_6aG_qfW#uXi-g|0AT$?CpimEo z#+#J+hzu&IWM>%OuwR_%q(7=C2V!!e#4y4yHCh)2{Y37gDC#TL($E7$#ZtTn2}#uOJh{cW3Y9&q~j!~ z)yv$Yt!6}_scYkKtgEc?_>-ar?R*!_-GNTtT)>AEZ&cM<1}OCM8rZlsk=&^j-w$82 zvKmPgu4eK-7pyio#2!&M!ngsfm_G|LL|D3M z&iwS?yyzHxqn3^K5mGlPQyj7`eqKJjuATLeo-zL*Lf~pW+eCaUG5$WMm?(eYaJHm} zc87kM+AP;wAu}EeYsTUkjfFd&{(gbxnpQ4!&~KD#@F` zARyaT{71rL0+oxk-Qc-hHeCHR8iJ}YXSDHP_!+N==jXUsKEZg`B#)=^U~qXOMQibd zqshnxG>cp%b<1~L#2;ddBvm%HZQgg_fdM*=q^JvZ^&7!?)BDZ7cjCU@l#+gkhQRz1 zhOSKYPh?Mt+`%fH^;0-q(Hf*f3HB9*Y^;{=IZb;q5X(QN$WNh!dgPy@kQz~?q`X9< zRTS|V_*EZkyMxoEwR%_fo$g%>$IG{dU2GzK`5v52r-#%H<_gU zpff4A*KL_(X!#xLVgTUl4>j?*_|BlP`OA`6QKDU0R z(um4;S`40C@MPnfDd(G?3~oi8zbXpqGlH4bhnuTez?hX$E32r~J4igMZopC@8pA4B zHB|^s&fs4rJHS+fQEG1Nyt4r5l&bsWH%0JCKr=dlsRKBwfSCrM;YuaYaitUpSdkow z^{HTUtgxXI3Qekh!4<0C!{8CgAP|5Hv00hU=xf+ZeMyT|+GnQ|iktrVLg2r}rk-QX zwvSNzEa@*hybUx%e$S8XiwdfFVH0ZDqkp0MyNGJ~P{PK%ZwD()$!}#?){}qBOmTsy z$qW;MZN1Dx!GZM^9Hf5hQE>G=m3yV1`<51_w|sB?1)1QL8f!ZON8LZ^2T+*ZhlE6u z#vr+D)`~&<{*_Z_IijVxy1IJmXN8WCv0{)3q|i_jDivj%+^2ddNweU(&s6S?=-R#o z#c|9FkS;K^u=)kB*W9Oqw?0Gtw&8_WEcp~=%hwmkGdzGpM+{^pdf~?UN-RuqoUg$b zD_uIfeSi?Q>H8D@WWNtgkqr+$nZdtbJ_>%iznM+|rcVV5zStC+Q)QS?W93gPnYej1kcsW| zdt%0LjtZ8wL9(*8-E8ZRcr!-Sg>DD;Upaq&7sagvbajr>G`IM1{{#+*s^*x|w5rDb zknw6Ku6+!DfTmrrl#6%)qQ#%kIby??e|etGX(U5^xJQoe8QD?CL8rDInGo4`r5)!) z=V6^awVWyLaxvYOPU1(#gZSNrD>;NRMj`baxHTNfOF=O22Qx^-h3$#}Lp{SOI`BIH zdVEVHgugtE(uK^wh4-R#j=PKLpy?c`9aU@^Im^4O;A(GHm^{OSVS+v#3 zUA_}t4m$6aHM16UrNu6~BukmJYT)QDU-gs|+dP`e={)y|keV8&12}(q0+&#{o5g1| ze{9nhZcZMDF?aws49_C~T|1n|-@MY3?7WQ~h>u43a!>C`!Xh)RDLqvHHoCvHm%L zj*gS;g0(G2opvN!mU6v8h0@;Ucp~AJ;!R7=DqK^0TaUB9gW>MJHn{u=}WggYX&bLiGD20vx+W4+6Zp_z> zw_|r5|0EUcWiOT3^0|Npb{AlF9T@25@C*CiRCY@hkSVn~GrrAu6Ewj**7rjTo-Wyf z6*}8-{(hm!@Whgkf8`2DzN#F;uoT8r29*(a5}2Z}=xqJ4(88W1iKupmtwINyRzOD8 zw)>s@cy1r93?=U{CxGJayN`fSv`kOlG|_*2pW{db-`|>yT!i*dX6nrtE_kTgnn~bJ zQ(q$9Qls9~zPSSaJH4!v6BH#QEoN=e4t-)=rqHK;EeoGz4TgHqmUv?Do7Y4*o<_En)H}yT zT*o}ev{cTZSA>x37%kGo@DB4Gyj_T_W_Uu=DA*vUqlr-krfwK^!oIgy4O~wO?#BwF zy%^zlMNEM$MRiSTPv)I8)&>ezg`^YPf_TxucO(zW&7!}>*>>$$5u$e!0!s8maq@{Y zXNfn%Hkg#D1KctB$X~{aD}Q)fEhE#C_u_TZ`34p%@|fgf@y>BAGpI@Tkwv2Dhcz=K z`d2KgPt&PNN-6jb?XnBf-$u}AFC5MJ zdteC$uW5Q>r7~ZL$j+Y0g4_Htq3{_fMA2T`jdC|e_xioB_7{r2Jsxmg z!fHnMTg8mMv?x=ZDTP8foHF=)5h5TQJ_{*b89}2FH!%V_3!dKEoRd&`&YhgIt_Rn? zXy*EP%u{rLoW-ADA^ln0#Dl8cYe3~{qK8Fn=8nztBC3S*YGQMzzAZP*&x8Vq7`1MA zauTJY0{3Q!%lO^$Na7EfuK>?zl|U7h)?}!u%?4qpBhy3}zBV9|Y&%)8nd^tn>cj8G z&;*r|>hvBKseUdVu7Tj%4;Iga-0uQiYp0&rmXBfBSk6?dY}kYn1pUYfEZ{kC_34m1 zbiW)q8G<>79tFCM*BT*TRDv(8EFf5Nf?iEFz&cLo2kjrlZ_n5+!a`RFnNB~|NJ#(? zNPtRS0ggMeZu2vbaTfBctY`zkg49F%(t{&!PH0`&$@N@w9r>%DH}7UyU`a!Njf*|r z&y^*NfP|Kq;?{^=6jcZy$!Xv6ZV_qlVGAwKgdt04jXw@ys#XgT{zkT+aW|H|fVHo; zZfMlyg$c0*3I9f-m|tEJ(cH*}tJTwBcwHmQtKh9kmb!x%hTEuSmQs(;TX7nfVRoFm z1`AAtR{8EI-C2&pm*Q!ZnV-o}U=~GKKsDM$tr>pm{)XpT%>1UOmlVlFG-D84C((|5 z=x$UCPLKk>D|;I7FQzt5zkdg622c{yP#B7+O$3%Hs(I(wnO|Qr`_y)faalQXRSwUb zAY!`}4z>526Mj9~F+S?vH~XQp_`7e)xIaL#-~OcJQViy^1~-=!ng4NkW5Lw0>SBi} z`soVx%V%H&MMOgYm6`<=4^Cv}_y8VmD289A_D{afD#~KTo*V#{-9ZEbN9y;1di*^Y zo2Pu0M(gtGTqYTi}B` zT(PBwV~1V?xE;Bw^MWk-re%>+4Ib{ke@_n1D%9*C^0je(crjOWbVdTojb>%t=_yZ- zX(J7bf{cpI?~xBv`jksv;yo|9Z|E!s?W%yHgx{QYAiXi@cNp{Fo%Z#;VU7oXcfbn` zdA`6hhb7&*zF;;)P2YIF&~L#M?u$D|*9OuD%>Ct`ZJ%%cNIl^{UG1fMt$eWGMhoC( zBv8E_M45rs1N~gEgJ@jD`^^5J$TRbw^g$PUx1f3v%2G7SuJ8O%ZpMo3T;}AiciS3N z)|>9ZM82mb#;Ik+as|7Lj99`&$P!=BZ&_3RF6<@Y&@Wqo1i^E}LeQ~oei1dSXX5K0 zy`Yt;wg!0I5$~BQZ{!{7Xhdk{z0+LLz#=5czpbZBfN`2)C z$Y%DXLBUiZR&OlKkcq&3+2pP%0Jfd#E@}Uzy~DAXx&B(r3&nSi0_Ssx{8PqtSQNN+!;avgmAge9QGhqXQ9L}yGC5c!P~~9yLmlra1vwM!xFX^ z$eJC!yx2}}!Y&s+z|ejZx>8XChRZk2eX+cRV`Ihw={lnw(~U^^Tdvv>q7Fooek#KL z^cT8%5Q+;@peRm}xOdK4*@@_A94d+>-cdaPtu zgGhU#8x+KY#J3Cuw1y+iL!tu9n!&jalHMV8kj%dn2juOWZ&cUGHca&t{$lJ--vs8Y zAvAn{6@4A@;GFF%vs#yX7<{l_M*E-9-^w z8ctVVgkE_4(MBwlhTFnUNMG29)|pCz;xx@tCNp9am;&741Jf%CKmih8$%gCV5??k= zmlRY>o|=DCe;lgf`;lhai7b!Sr#|=RNUbG2$z_Xbs&`>#2PekJi|D&Q4${_N>%~;! z$f?DD_1AjpSAwi){K}J686XZ@kx9Z3{R#7Uz@&HCS&$1O*!+<*cJ5~qn1R`UG7EwR z`X-?!$fR%i;=1EuVvf#!PhaXWG696G1#^b_Z)^A5-7sUG6ljgvHZ2ZzIeOq{NkAg)obHjQ8Kv!vP5uj0k%<~kRI1$Ee9T!&dwTJ+ZM7*h5fI@2Hu5~-C8Z#@I? z2N0Ql=~+{!nef($aVa&(7+14oEy-2D$I+f@h+v8&;vze;f>XhAD`1hEwBbU?56zlK zlMC_<4^O|fgse=R{ z)mg+!{=jm-P#)KzBjB6)b&d(EP> z!OZ6kFKPB|8tQ+GOta%z*B2MqxJiea()^P|cM<01yITacsOinh zt4wv&&%la<9i#gaq79pGidKsgw=33!S&x-4L!U7KXd*<8#=42O4$T~Us3_n8N5NF_U{XF1_9w`V75TnR7x@aT##lFqdY01Wlr1E`jmdjp z{R`lzDfd({f@BYmh~v1D9%QU^^kjO$rHd(j|E?t}L&^7@lwC7j$*D(I7tNcm(2`yt z{AXZCi9HglMc!19=SdWO3}>lWhPoDBLlpgH_MH+0-12ITnVf!K3&-P_eCM#cBH{cJ zPsQS!$qPQQ@zFoKP(tDOi|nH=w-)=~59j>c@h+n#M*TJYY4cfI-m{A^f|O6ky*6sX z!pOJ+@F;J5P@Gk{91&JEh$;-}_OREhkc7W1P#dMoA-TBW zR`^xF<&O6sAtPU8kOud-u^3s{pF&F-fiE4Bu+d8uwvW%wSj0Y@80-Vum!+3hL5U%x7cB zzy62KNlUGIf$g7VjZ5*rw0#>BD@P|ccN??+ayk7+MCs9m^ZtJ#N;idDsz4i@i4pV< zMhX)&Wgyu%a0!f1ir}5l)B{Sq?1`alI8xpA*d^OVU9Co@MLNxOI(U_qD@NVc*19*% z8V{#MTf3UNoG;$z9`1W8_TtO0x6d!;?dQ8ArsIM~uc@AA!Q00k6flua7lm(AgLQv- za0c(JpH0fZTrV=J1o-Z5&Ev6*2{9s8V%8644+k&jmJPtD3doZFrR@@U=XB>Y5m{mG zWP4`-oyNYJBY?;x1!}N^w;SMBpBX6AsRd5Q`+vPdfY&nn5qJA!KEJhhy$-)9#m@Zh zJb!i@WK170XGYX3dzW()#b0*wNV$c5|EM?8eOd%-MsH6w(7d~yHTmx>Th zGvTJ~<|XmkXM_);_;UL93A|J4)I8>=_Q6XG!(X-CJ5QetQsL)6!TeZT<<1Q(%?)6F zH;xg{G#d>!hS{Elz(U$?qg@EL9ntKYAHXOqp^_Vw2w|-kga{Z+p^6(9yf1kYq1{1h zgdHA#x!s0?uZD=_N~}*QsxQsm>+m^ts22t*{}+9smYsWeBbt8kn}1~_1(=C&gXOQW zYgdxDP4928OM=;3e4`ioZH-?OQ$bHh zyYqy{)}yYHUE(Uqjy0*up*Kq?88z0}IVY$z>n|Ba%cnmJE{PS3Ew@eP!=TwBF^d+P z5qpykTxR1!Wz3wyimkr8RnYxuonEpSTa86TizH23t)gCIt@y1#!6SBQj87V8hOb&{ z;k)n>fz`v)6MPR+EEgT0)GU=`E*6oV$jI!iJtm(hvEG48Ny&G;2>jLfg|aH0 zm6{SRNm5B_+O=vLhBkjWmER@NB~>NJlGOBj-a_GfvFKtoYO`FD2C;4QXPWM@C2Cj! zrNQO=ifHsNh`R`m{^Gi?k|9&w_9@DN?|$=l!BSUdO=UDJ^c!&wx}O=TJG zITXouZrU!LSx1u1y;2g=e_7|r5{q(Id-)Unz;Y24rmT(@#H0ZySJ{XMy%tu zNm!pav1DaaxKLJySLpD(!&yrN6J^1e=@tFZ#Sj(_~|^mPuXgL@tNLp3)7&O?51rCjim8CzBHb$W}~15O+#W z_jMVHye^~Nt7CmURHsR!$=J`2rNR%sx{X_h2uOp#KS!jA({yIqI-3>syG+|ItjU`% z;ecaym9J*__nmipgAf|Vu%)XIh-emd(^isAnIp-iN}wq< zxNEJ|ldg@I5VMz8Uucrs}NcY?+l0bSa8}McB|u zl%&U)eTvA2Xr3ZkMvLRpx$Pjztu1;*uA#+5TrX*c^q6O>)UeW~U<4AF4#;%#&7n{B zng{wdig!2WaCY(_Jbp!Hob6;n=4!q-tR2$ZxUIWC&Q58kwz5$?5jB%x+9yctBf5v` z*3`mAk=V8AN9SsXASmV~MP+;QFd5&kJ|rFpg`jCF`LPUaIn33$=gJCK6uz8PQf&gf zUaXU3z2*#r*6ikl&R9)!k09VzNHpm|LQB=&UxVX&6{l&LW`#apZ%vrVoiof zHF4hG#3Kf3wzME;<~$GzI?W-Ft;Ri|12+-|w8M28U^!YM_Oc_LA3b6%@);RJ z;i@@Mk-2nthpBo1K`f_8z8E3*TO^X*y8)RoaATS`wocg(Z8PPr8TUj!^vGZTTNcTXvjz2h!`CWu2opl5s>@!&K zQ4j-($n>}f9J-A04IvV_Sk`ShKvA9es7A`J)dUC=#iaH9TliF=lB9qKoKzvSUGQJT zR*S-s)Wsd%zIpk zX3TrcCGtfc@RW}Y_J#ufisYhqgbGcR@Ql)GOz@C!;A-JnoAZ^t6^=?twel83uAM$%g0AAQZ^1xb2Iy3i|DG=E zi-W)?jHdbs6UyxW1TUW0#|U7ogtEPO!krvaM9(#2CtOL)%EIitaQ!L^`gwzlqVUpS>+Ct%3;q5orb z*%f4e#?MO>&*nnqU=MF4_XZJZzmFE_oo2iq;T9St5mh;km%p^njyV6vWQW@|LEs7f zHVG_qkB~T-YKpvK7lRp(q6rfW-5~?oULDKb;V^q5 zQIHo^?&d+~qv4nV3$bM_q&g-uS1Ls1gk51C_xoOaL&|HJ*hMyaCndH6N(VX-TWbTN zgJ|(Y92K8gJg+`WCUqSCbzA&nR{XcjwI4sH1Z36LLw5n=9MJIO5QI`2A%nd6oU)Il z%W~CuT6Ar8!R~)xU*bjM6((GSeyvDiG<8xa}DWM)Aq{Jd^d0Svo&AGx*ja) zi_f4pFq7h_UX2#8uX0bcdepthrTP02;))mvjx5tB>4ltrr7K+@ub)?#{+ zp_t5P87puk$bv}q4=5L@z%VkA%;lpUrtdezDFI)aZdEaM;S0ZrZOirJPpZ`h6L-tdgVNNJix(~O$2AcexPrP zBN+{;VNVJ*rbShvM-suU^?VkCCLV(beF1f&PN!vrJ%*~{#HuqIjbm#wiZ|y#8BBCb z6JR{QGH+YJCcGf+r!d!?i+6X7-K{n9@2<#2jdL!|Wi1yzxY`&;SXrV`GAIVG@ywJe zM(j&dNE%nMks55K-)wrDmj$fDJGGpXS&sOWzmDyOxd0vMcKEhS>E-Y<*jt9|$RNq{ z_)7e@&3F@hb_o@6RljSI7WUcM(ce!ZVMuu?37vCwhXxEzdwLLy`ht<@`Ed2F)SeOO z4k6^F4#^@&&(A8`Fp)qY&A^|Owv%``!BfUq|jUmaB;amx-I!(?d#!sPxIBApF zoOZ;=*x!)fCTJpnSRcjCGxeDmv&eePyCPkU-FVz%h)roQNpn@XAO*9G=`06)H;PW2 zB~2~{BLfYRs@k8d3F12GApNja{OmPqsyMj>53DX?H~HHKp%{!?9 z=;(B2FlSWh?t=X&7i0q3rP90stZD}%D3*dRlfUqp7CY3c&1=&fE|C2!LBT0D*oKn| z-F1{QC7Nftk~6h&Lp+!TFO{jtV7uXCVN`ca&xBw3*YH@y@QcU%z$&b74@Lj2IkTA! zuf4LC*v1a;&}_PE99468@C{tco;G|2b{Q)@R=zUvq35?l_`{`d?D+yNaY{{3=s2)- zN{UnZsBzBSM{U4qkn?waRerL%sCKp_s-LmejNYkDXO}%`{$*vI59okbwGrx4jI|76 z2-*pSlolx)(83PXok7r2w?jR?#BuU1)kl!~Tg*FS-L}a)2G8Mj2Bh!gG!wiD)TSS6 z?Ezs*^*ZFyXRB>lfodzlt>{nJ24*u|HEi+YDCw)msPJfhy2iLbLd@{}URr?KZ+UT_ z-Pr{UWEFIoo zl;%|13YzET3#geO$`_7LO(sO7I~vfVD|%AMxg|_MaGU*98U1~%Xya zbrUWh?bR@@VAiQlL?2JbqSTnelY00qdl)JOX8*y)D1Ye z*i}Tl*Z0S*DbuN}L8~!(r)%;(lsBgECEEDY|K|cAqRy0RUXlsds z$`67(IEQK=96iVb31ZSNs^iyH7*`_m5#=KKyOx>#W^qcJlU?jMrWLE?T^mI+@N~6G zTb$&*k=duI4|ydXbR9lroPWbH;-Yw>jDG1>@Asrbu%G89e*F^@)u_}oPHr`*tEov$hAa@tB1pUWF@(y4#}5pcj7y5&9amWf;J;>mpPRV znP1^+LwI(h{~=IzHqTcy>POIj*mGRZy2`MOk$`Q-L7@iX5!bX12k<|{j+?lA^(cV8 z4RzF(ac+(l@VR-gY*nBj<8)PioK6bN{^G`erE}}DvQ777=xI0@9oFIJk>C{`b1>3K ziTyV#SteSJY5_|1XM7qg&+wH@2V*WAk1TgL{IYZEuCUVQ+m#&)>Ldy^r!O5dXkP)z z)Q?TFcS2lso4wVSN!ZI@KNqvpg>Y@|VH3Ew;Kh^*SbL^&6>^pG%%q39(`^B$#GZ#H;xka=}n zYvo5ki(S^ce3G=R?-jzhx*X@?qPHVmm(1;yMDa*M^MBRK+IC%8+;a`f5vV;a6;ISp z^jZp#JB4_?C`7r#>pv=cWV`;mO4Rwjb7vh#9%&lazAkof#!qmSYAXaR$*^P>kxC8l zqu9!g?h?tk+WuKH!YE6GIR07w?YwK&7KzvPk(J;ncXe!v-ip*N^zuSOToni8Dy>5) z4!xFPL=e};Hq#skBc&71*JJaGnXU4fS&4?vt*)_+75kTowTK$^ahy!a)T%qyGrOa4 zl$-uRj!*FOQw|KKZ{V5UeK_MRSYXZdMWd-M1GX&5=M{w+cu9c&QVu6cly)f)N8?czDd`S*te zgVVF+`KuhBz*q(v)YxV|m?5WJAoL88Me%9=bo&tP`8BZD&N^Q0b!II(U^D+VG}U;4 zO8sLxmtJew^0i4J@xtyBN&tiYa+;{Z%60PmW$((0PP{pwoD4$$1xH4=v~Lst$OUOS zN|O+k{@m8~j7#q5=adlWknC|5s(F)mV=4uUPj*0xVVmpCIWm24Z-tt2)a>*NHlK1U zH&oH}@l=>={8!j3hYP~;3tVSx?OAjb@Yh`bflvSx^)%O!2L2FU&6}c_PKImVPp*zd zxeOFZ#jZrfKrQnT_kit^z3uNBUnHZr*b~U zeW>H%fa;2(_&)|ha9_gucYYk#KR75Mf7duZt_n_8=WQBk>r&oJz@#GTaGZPN>glqeNfk^}oL z0@r8JE#fOl{fTLlALG+t2RC{`@!=sXA%$X2vMF0eS%%18Uw~1=n@gxgh`*fdPvYNz z0Bs<11T0F3j^5ZNgs-u&jVuac%JbX@OIA?}Oymu75DMnyMS$woySQJGx7T$TSEq?W zecJ*lcm2QPuechB8`4zIb zA})M63$i5;Gi$ida!?=(0l`>^A!_hn4ELa=Hn^fQWXquH3h0%ONRz!h{YFt63P+?h z;}cf;b-31P?~B~(B7&8l)QLN8pJW|kU#`Q%9|cl%?7@z6QS{rwps{r@TBB&H?%9ts zb4h%$UqiyhFjN`#YY3^XfDM>bIm?F|CO>9{Ed({~Vl_DIq*bWDl%FOVB^mxquxRJ15!%{pfLm>V<0b%-+@ z-x0fN{evGWPwx+dLo(>RI1@&Hl%>IPL=G)yvzoJJL7Q9az1=>odV5WN~_UMivetQY=~Asj*sBOujD1Y@2ngTzWK zWd6mWl^L>rbf+^d-O4EO7i7*wKE#d>A#B61=f1G8T_+yMUMb-tV^-`P7Q*;J7tAk3 z(5!Z%SqBgP$Q5coU0$%=E$YUEAoU)m{eTTF=oEKQ^#a5ukS|^Nc5l00cq_SH$jT7A zx8Nd&k~d~srHFq;;3>yDoa+YQ-)XuyeF~l*O0=TDKxxlAom8+|EuFeZ&6YzE`9{6s zbhUTm99597JKHz7k9#aLk@l<3vq|R{k`Onqchcm+#9Yr!U61pYStBLy?s@^-F*WtY z(k}a7lMdrdPlYw8@+tF%+U;9~UKZZfj77YlS+jy$96wMH_prg75to}7bRI%jM@xQU z)F6XY8y}MxccTNJGo1ZC*%3p%a=lf{?`(_*M^JI$ugk!Q#Tz@RzT?J>WLqS%rDkr9 z9kGpQPH#lV;mNhJMPyq}K8xXZ^e;*P-m~DkOr|BR71L$AKkhIplsDOd2`aQHIi?xL zg!w^!l;^02d7s6E1=s1gpv451VP+SbJf7R(z&I}AAf|m3TYNv=MX;`b&b_m`rJz@O z4``~z*Dh)bkR`WUAf!iGGBM zet8xcqoXRnh|(*KKgmgBgqCZYiqs=_O18Wf@9sE=dmVlGq_2r|6h7SDviBC1ec zYji86JxmbgBOysfU;WrY5DNZrIzInm>8|^|{WCLz3NsBeH?Eo7+!oJmcxNa{lWWbvK)suh9t~;q#EnZXp^3o8G|I!TwF7 z=dK?&=M(~s5I8o5+d}h1qh441SBzbd~*J* zXUg6n6M+X+j?T!>vt-J-fTf$DrSEI!#Hd+gXUy9R#2@XM>IQ45he*$g=_|$EK10t4AEq$-N`jfv#0KuS&>oeX9rbeqvvL|CR}@f8Ft+>Zumf5sY!l zd%@keiPFbjv?Tgq<;nwAc)9=3Lj2zH4Ky!>T!J(@-~OC8-(8b3^^lh@|L(WzqlE7> z0I|Y+b}YZ;|L}|5Wo*nKpQscC48R0})K> z$v=36x?f=p{Qg9OCoB`ywyIb6^^=0wm(#2t3c~D}fO5s8et0zDbFq+l0*EJn` z{?wak+Cm7QJ?lwR0vlgO6JL_5bIF>ekgqIdz>?WENOoo^ePJpskZwhkI@H2X1k#Nk zHk8OZ7Y%O@uMA;Q`fW0VyXgyYaQ+p?$)B{^4RH21XQ&MGLOdC~Cs7s9YD@*oN0Q(- zM$Ly9Jkf`pX*b5thhabQKl%$^wbNVf&RSb?4V3DFY`gg_naLKRDC_n5M;7Mzw`Gu) z@b>)l^W%M3ni`86Ky>$OUhw8P=dH*hweQmLr7?r(rBqdFF-iU-XceaL4~^q1$0e#8 zPCV1?mxkI~ZeULhnV>Brh& zWfAn4nx>y3$o`E3bE*x8eSGQ8b|A5-o3|VmMgkcu1pv@GILs+=HWNP!U9HYBuN zrjXRmGgVrPTE)6c6iCdj5n#~>A8c(Qmv}c|2`7+RvBf(*vCSmrq$7G5^L1{Ck~_N; zZnB%pHH!RuVfWn3EetmN@SPBV()28ZsPO_7i}mJZ7}=R6Cr-$z)=3|!u5fdITw`& z5(47CVkT8gJ7WY){k%YEIVr>~58B0hpu8$-xbdH&=0_T$Mgrn=d~lM(Y;(HaVhlzV z62SW<_>Zwe&w-htB5^{`^O(UZvc0QYV$Pd@SooH3r<4N-iLbwpp;wL(P{xwYes^)- z$9~2=z-i7IOFBSZ6=(Uj>`W4AoTiyWcW4s z>+&wvx%-3J_$&9{lXZlo;EFC*=QO&aN^mMaV(TO*(fS;n6o`2(C$h z?-0s9IZs|r6(u(-)lfpWs5-wiO+SQ9#tK;+ZR-PgBEkb8Z=B+^m49I6s za$zgMTF)E&?ZDMBSZNywST!_9VW|5!5tTR_ty&=9)YRlm)t4|4P{eZ_ z#WJ^b=fjPmI?f)AcONh;MC<{PH>9kVM_u|cW$hJ@)IvT)i+2|raQNne-6WlHX_>aj z65HG=eF|7l?a-Q^wCM$~4|)Jrkx70}S*&WyUCoW$&WO)*RkGp^`o@HszF% z>g@joZ9AEXIXT(=FMgv|zW?htT0Gv!Hs4Y(M8}0imDxdSW6^=eR2D;rl?@ibrbvdZ zdSUaCg{ERRu>_vY>9)3M*0pLhc??3?Ibg-Qv^x%$w_edKc4^hgpU*9I&ADCqHCrlw zUB4laSY7cyZ@5hdPWO-`1$vAKf+^EN>)${g@$R}zSh0i-$iQ?N{IDpI=5=mCz?^U! z_|Wb*jt@1%V+Ra~L5q|1m65OZx-;f5 z26diwZhB&zEQom7aueqgffNS;N#Htupg=O-ERFsfOUs zQ%)M8>&RKWJ~-Xi?|@#W>i`Vw6M2J|0^Ij}1!8X5b{ShCy?k2D>c^qp8{f!9Z6+cS=_(*&%?2aZ)ZFC)zk|gU` z8^t@L-P^SA1=Tw?41c}yUJL{TVfv!1ZjQ4B0y09kwQlT*KSc&e*eXS#rd4jF;R|YZ zeBcWjc9O8VMFt9Kyo*DHHEyin4a@!mcLSi9HExdK{|{T|7~N^JwfT;1+qP}nwrv|7 z+qP}9W7}58=_LQyJvnpEyze~k%!gX*{#vzn-K+Mlx~|`s@W51#>GBj>PjEoJ>Mb>x z2bE`Q@EWCOZSWdZht9wy+DBuqGoww>eGh$DDxdV8x*Q&SlPrr6-w|y}0dBASeZu!A(G;V>!c`NpBGEGB+-(TN} zzzEcDk-!MlZV{lrm>>v-1RBu@EN(-B6{ufQf)&1>S z1$hMqyWIkZ)m|XJ^-H_>FsTYKmhfWB6{eqs6^*2*_7`P%-m!#(9g7*?zBrVa$srv1 zirl)3BS8rc#W{Ec*{Kzyh8}l|hwG+(`S|uvOU`@=iEMNA#8|PvHyRtYm}`;ru~*;U z9~*L<*z6y%Kxip5yBWn-(OEYK=?Wc_T%B6gFAgNB<6oGcHmQp#yiTPWxt2_^NExD( zTtnEg2aJm16>{Z|`N{dQ*kh(;t%_6-Y-Lk9XIqvC&YsQ>u48!W*aiz-Sxl4T%^>3@ z_GP3JB~Tv=zrGX|>xie2jHM_MA?>Ujhgf5u+udWw5%D3pLhiFP!V6(;Ch zOt2-^5BMwit2?Vt_+Yx`WK3OaK?4Ks(ZX4)taaAkFK{SbMn(>t>@Nc~6$ooYQZkog zw(&`%&z`HXk0s+3OWMoEQYakJo^jTRGnI%E1s+XiGxXe$5L#YHxvD32p3=b&UI}!I>F!N{(RDfRo^;fj!jm*vXP&Be7x`Qebt9PFZ{x*uDt<1PvpCd8F&WoTk2VHtr6%rv1yVz2I`?E0L=h|1L`B;E{o4SZ>?v$w zo~$(qSOM|YthZzIe%U8MYE_I!-|wnV)R}6f^Yb^zKZ&>OLdUwg1ACARp;A>E?50Xx z(eKm`oy&YhWm+LBBZ`rn^HGzvkkkDf&@5COfmNy+#JDXLnN|&jfKOU9b7eI{wiL`G zCS9mNozv`@D1g8#l0`eNQ4g&s$+Xrf%%5APvM1=Tt^>8P*NYD32<>B~injQPN8Q2)akSQuE3bGF0tz zg=-c>Su?4jvAxjiqCrn0tM&@3w3Y)%MkKSL z@q;q=Z#D7Lm?AY^?3$JhTP9YxM2u8bV8FpIR78;(S5l`bi59@PNaiaaYDx17glU}H zkPo(8gzCJ5Y?_nc60t0&OxNY86^RvjH|QWFIMNzV2yb3gTui{(J>uD@vs>$>d~Qyf zU~q7(*pQ*=JLu^7sC2Jw%`X&awF>F@nI7BLw>PHxF&1gl@1xdJF$KpsOQqyTC8-84 zLt(b26;E79x2}mIm6oYp{#@u&%-|=td??p;_Y>;fBh(=sZQM|7iH{fJ%EnZ|N@`9V zSl6``wJXV4@bUft>Yr^C?BJadb@vEA4*mBlQ~NhV7| z7Q4KAMsD^*D06eNns0k4_JeHBNH0`zliM9at(w~Js)Ip11Q%dSl#beSzo0%h1 zsX0czsfa7hB~iZ|;dbIpjiIJ+t4?7($=bY_Ktt1x5rWDUCDRrQowjip?1f(fsQM@< zjzsEmtu+TyIANmujE5`NLuQMHad!Wz>4S{sejC@iqfA;^yi-(tW9D3+gKKEhLV(2< zMZQW){>~O>M?%!AG&`+asjHi^uB#h>iXRC=TlgCteG9#;k?}4!@o|z&`oWSEwhKot zcahhyNA_xYGSAOKR`u1;k>5*r#5y==+gX@9uECc@GHColMy$lW{YGo6mcH;xENrQN z1W&`a?;KAQ#p2K0BKXx_M!>cE8q2~AQ`>&xHvjYvkFA1?@K*yBi(owVb+;;?4>G}5 z%G_*yImil|c_j0&RE0{ai*sUq)(0Y4p9+%Gu;|LMxNqWaO7Cs4GUxNV1OahHB}oaW z-fG$a(Ct@Sf38haFDOn27t63bH|c@DPR?baY9&pf>`I;!5yK$2O)$#XddrE1z!A1% z#k_&+nt7KnOez4w7{eJ*XQ5-8;}9}Tvm~dnPbQ?61JTisa|%5+D8%39HZjeHPIsq4 z6JY?sWY+oUtbt357;_UFi!SwG^=Fjtn@Q9^Xoth3VoEI`K`$K3#O}48y@{XaycCg< z>XCT#hTJR^yQ*;rKr_E))K?jq5TeG7z8irmFq`29WcXZk4Dnefs09-RZ(JVFgo2XP zzVVEUy1tl4MKNXO3rOD67q1bpYH(BP&nTshtcroR692?3-&w7Zv9aYAuv6DhDSq4* zYFADc8mqI4Nj*?xc!mmrR0?Z>6NdmVK54Z+IZz3`Mx)Uxn{C*W?bqESOzkpU)+LBv zG;(#1nu_oePVn?Kcn*D&+ev+NBHigI{__(=Tys(e95P$MHo5OWTSo1}2C4$~wG!ME zCmY;NzB)y)@i1-3M-}`)3fh1Wm8d&r_90MoH}b+LY0KBwu?d{n2f<fV|L<&_%ij(|48cEDf89^Ao*(Ki;I#pE1f*)NGOL+BzsouZ zMCC@k!*Ojb4Y|XIR8c(YQ4s1Xd>m)^f(V>E~Ie$yJMzzEE?;#7>!^~;g2)M>;%|e7J zvyHAf3LEXVjWuQdHxj2oT4;R#@*)(9HbYe_@~7*AIbU(e%~k2QN~io+*x1wNK7qxd8&yk$ctZaH~@ez?EA zlk$>DC=9XOJ!@S)f1iK)mwvn^#_#8!+kmZGf-+9H&=ich!$5+wBkTgZ&*dhxo~V!a zf#Lc@fF6Ja9}#8m!y0Qq%2NjO&Kshp42otzK?{Uw#UKO*(!TM1$}2`hHgBjOVF7E{ zDFNsqJ)^=1E%JJQ@f*LTCg_}~hZDBDaI_#7i4xz*ioy|@ON#bIQc{SvipDS^p+G9p zAd$$0RM-6C2fdzU0lnsbXl^3HbaT;t8et6Hr%k$t#DtR=1kC^;W5k#=!uP`iV{>F> z{pD*JO3jIm{>!@}41W;*m+-obOete z$^aUv0n5aiaEE%51KC7-FsY7M3d2~g2NBoYsQkmXnB9-j9CDOBeFy#s(OsAe4jSn? z6hL=Ox*T#xL`mFqNR-iWKX2gqJC7A~^IAmVI&9ngi++fRa)YF}5FA}eG*ehj7=C~a zbS+8oa(qFL5eybONIwJ4Z;>~eP_hhazj*3odHQ;!}(`z(v@1YEw$Bv zX;k?%pBZEsd4(Qw05#`6Yv*CBgRyTLsm~6vO*3YC>YtxhJOk%W3IxGe_)~fzw7qcV zNe0`dg}TmQa^#p@RHHz%#l3Ukx*b1wZ&4;b;G(^HM|d+0uvkb`P8U0fL!HdJl+%B? zI-{_B(D^DV3hyKtuUfAMCyk zHa5`e$h$2$;DG|VZ@v!SA8Mdv)EybMftP}WkN`zM0uNCM-YXrjSElKe4}3s!x0c=X zQ3!jUeozamw3b42u}d`9PovRe$2H!7`*8esP-t(LW2(Q_A?)2Ot5a;6hen&``sZ72 zxc;+hLUoBl-gC_cgv3U-7O6@Ok)`~T#-MCNxEeuHH9xV&XR_`ilP>iYk>xF8C3y!<^-1%|Nhf!LL&W1_Qj9ok8S%+R zMDpR{IYiF^W19g~U_jv`q=&0{6=V-9M4v1%08Di)K{{RKw6Q<<Q<_JoVvF(nDfoCni)wKG|R369B*HBV3tb zCnuzE!l(GwSqFIEHLb z%;A~y=9x$p*h$n($Z1Y3@mPKX!5!xhdCXuGF4WGUk_O#9Wq*PkS1MHH;mfN%UkwIBS_>kx4J)Wx9eNF&F`KRW{57i@8!D9Vl%vt~;R{rf0yYf@T_HcU0VqF+k{@OZ@FOR3Zh))h378kM|ChiJy>C#*Uz9I1 zE(@g2sNCYr!ksy52#4?lIPIEktcGM2cCwO56K~(x>A&2vgB+Hh{gvC<+q-R(_heAD z(x%f4hCF)ERbzN%@jLrzKe4*C&Le8%L=fd@t6I@V?%WcXn|NEHkpbpdEUD;pLz6qM z;and@CAW2XI>JhVt!^JKV)h|nRSDDDxu z9h$$BSN}%3?R%!V`Mpga?Gi_iszbF)b>te!mf%&oo&GKnc8Llpm-fsG*-O0bM$V%@ zcqZi)8Dt^jl^MK|@pQkF7hv?DzTSorkiA0A<{Qh}fe?^JKG21lOTP7m3ZOjzL;eyS zgdzK=3=v4aElSDQk=Fo0EGE>60arr})QJglGNx6HbTXY2ZaVd}L`N}9r3^k2Wy+x> z7jDl0#R&liF=n$UAy%^Jtk1>uIa}{(4PKFcI^P z?QQEgv!*mXJS3^Q$}2h)?kczA9um)da~GEK!a;U1Ov!)=HO7y@kQgFmA}EWru0U*M zl%NfsAWV+kbJB3xId!haa51_&y_Aw_~eRLeAT`-JG8l-eUKp zsj<+@BwS^~!TgH&(MHxvIqG>GojzOw5+RG#I-Z;r-#fwfm`2(ecDPl#GccTK`qVsr zWg(LI0t7aNK*c!=($7gSi!Km$KLXYup$pj_6}?a22y>00F%*4>?WwZ;<0cB{Km>sE zqPrbJX)i8!RXG0_8s2Z{kKQ)?_+OrJ;%Y)-`npd1=UV1Edzng(J62>5rNC{uq+JmA zl9`&c<`L=E{xXm36qO&eC5zzP`=?e$uISh`dWQUSVu=gs!UprApR_A9_tN>| zbL)c9^k1pT$qzYF7J-W1`srpBllA~e{Hn<;!+v6_5dv}*m80i^_e4+XiP7Im*r?_^ zDuQrQM$XK+sF%NK?CzWF?s383i#EZ&SehCMvnzKd=%5xdEao}m=!oeYRd?Y75DDM& zBh}L%C9rUv7h$2ZQhopIXf)8qFFa$x`_D|1Dt*`s&CKU3H*vy>nIfmwBtcZ!fyT7N zhG?}dFwU`qTiclw4zR;(+l9^>(FDuuFu87!2ODLB0%e06ZJDlH(*)tQRXTRrVe8t` zg!Zx{Y@5;ie2;uG%EriRmadP*UipRNJUlM%Eijn;XjlTKNT4T6eCnV1D%XQJpE%b1UJQbWqdR=Fz7q+ z1#JQ{^5Km2!9bBR7C9cWL+x~Xxfq-yVPp?%Iwcegde#Ag!^wWayn3|=VEU76pSj*s z|L45U=EwUXiXVQGFW>rBG|RzA=p0c=v2+3>SBUwa`d$yOSkaP~DN+7l<)4rRDkE60 z{4@X{t6UW){XPga*hyFfbEfv$V$VSBl2+1-`>Aa?inm9LsJpzc`L* zv4B^Yme>zpT_?w9DOAvr^0Q@+CH2023Tft%qsZ*mCdJY5rkK(7mKt3WBZqxe(E$`W zzU~VdY-El0-1)PN&N9fkwtLpjbd`m0;cP7hY6Bf%P_lRadTVI1RvDu)!CG(_PEtcT zysnwPSQ;6o*;n04s}Y(~K4eLb&1JpJnFjjoO~Ck{ZDE*o))7ZpEp;f}#Wo#86T%pQ zVc8iA^KmA?kEKXo_KF4O?H{en)Zrwmle~m9jd?Dytlchm({>SPBxNX_v%9+PmZVEc z(2WSPLM)3UG^p<$RYhrV?~}BOoyHx_=Ip2PJ1n(iK_`l9Kn9`(QJqdlec6mE=$Fux zpeNrZU5iiKQ?-)j%waQ4eDAHT5Y*=cpL(8rCa7zXTPxUE?+R@f++-ocMX+fz2us5R zLHDC{IhEuUm4_^>_HZwFl5R=@_PhtZ8iRH+YMbyckv=3GE?= zZ&T|{j$3d)uoOO2W0UtW`$)nGK|UF_`8o?0xfn+S>C$1$twgN7p5h(AE`#MCzj)^$ z2F2cDoQjfi$YGAQevIO|%{<{hfBd0BcdB63A$`SCd$#AMI27fYL6=HDk%B_yEC(im zt0FXHddM|p>H`T?H0#IfXqrG4YZwX+6j1&gfW@75%cu>K)dY?rw~5-8ccZOt5Z%D% zA9fU+;8T}7Z)+F1EjK3i#lc(eMMBQ8KpKJSeMtBu5H^MR^Zv5p9sGfBf~de4a*8=h zBMM0CQNSFsh%tdl?m6eYxh*)t_~-s%7yv^10rcaC{`bKBul*zDX=3K+YUN=64-|r4 zypY16AY$m=qOctuYLGVz0CHvir$lTd6E*@U0{eFRpJCcGIxFaf{Ntbu&s&I>;+SSc zgbcae>8;PFKeNwsrx<}u!U%Gp^tP_CxLjvkXE3m5Y{h1^(z!i!=i;X-orFP8q8D8i zhb6v5epK^GnMNI*%GxVyz!XD#rgJgoz)yCWE{cpwS!LB?(rUy@!5%&3&T3|^^)XO4 zUwHuu+zb`ibI00mj!d@;!AD0w;(h_>KLu##**tY6KXC=hTqdo7Y&f$HQY>um_TlPq zhjQ(bI-vFGc~?c;F=RD$f1ZI5b8i(Op#Bg%1FQAa6`q12H)uYR((W`3eQVa{rTfFlf*DlMrIv+7?s8zYpoQ0gbFCL5eqJilP}7BY?Y zr$<9c;xJ3Sa7h3m;-sAn6LQqNZ*Mcdw2_mbLQcVRJYgBg0$rI0JtFe}`Uj{oagSbnWY=oTr?Tm*+f1AvAN zLo{@?e`FG!se@11}AO@-DI~up&1Mk10@-J|eh=Zfoe?{ltk>PoCSmOr=2j>IV zrw2C&r*{XpcL&E82WQWo?wLmB5eHX-%dZ)368+2>?s5IxPb!-3akZIY6bDB?{YX(2 z2lvmP?osVu+%8!zN*FG|Er8T;^tV!SuF@foAOSDRxrd?Fqe)VMk!HTXe-JDKFg7qY zFf&I`oTUCnJvXT^GDQU6%FL|4IY+=SQ#3RL=0*a=3_`R7PA~V>mV}B;*X(!oCQW!<0e7{>kh%%U+HT z`TgfT0IVP^2@K?wHHk8VvnfGvS9D>RiHHv~JYJXz3pol8iBh1Zo!7vJ%y4tXJ2B>}g>mstoqbe@YV*yUfuY-2asxv#QOL(=jkfESICdHw3f15_?Q$w^ zL}Wd?r?8QXwXl2Y?=p@gzfz4C6xc7+IHb;d`UxNWQMRESsCv}OQ1lBAKcE|MhNfQr5y&QT+wqu(-g?hDrYw7 z7B04RT>5OdU%>xNKP6Tc_1JID)+*YMA1MEoe*ZD>|98@*YCw7Fs-b;3G*3_cHalmP z%AOb2rk+_uEKzK0DzVxGO=@E=EG^idnwDXnneMqgfg=S&6BSj|{S|91Bvc`jIzkQ> zr6@{CXtMz-YFbSQ+!RR|{nzWBJXzM@@|0sQ$K}TB+lMC4WsdK(*GHi5Rs9D<)n~9~ zv`v&FGCS03XMzFbYiWW3)CTUadbSU8NVv7h4{oA0m`D55V9q*?KAt$l$tJMOi=OhNiIf7j8Y^>aAbG!`4`P>JH$vp7M>| zyEz>Ln0AMCgm>ZhbBVq0>%syeHEzHF4!o5IpFj8^_XVKE#0Mic_|ni+=6QCcny2Fq zi~U)QHp5Idpi_5?)oG0Bry?S$+`y-2X9v6Dd`!#mHwfJmV*bIMiky* zm58!sVY1z9=A>3kDQ%c6$e%Miad>hMOF7q?Kh2Ax)!)oq(2n5EOGVMLheXo;)U*wX z*ViEBGs0+!$S+Gf1_AS+u}nPQ$Ar{sPQ!L1WLF~F=+9_zQ;M`%4WBDUzh~IX>S_?< zr13Fu9J&f$MvqQEI9AbIGavPqaR&4P#p`e&Omp@i_B2A#yZDGk}OsO0y#p5#lan_qW)5^6FYg_+A9#&oH zWhEi0p9>jmH)O=(2My#qF7k&Xch&X>&BeuMTwhcLnLqs^B};Wid^+^$vbJ5KXJ_BRSUU1U{wAzu1o;kgoH#@^X_><+9mO)Hid z@AlNDp)${b;d^)I0^0H;+nn-Z3?n=wqOt`3hf7TgQ$*GLEGRi%d$MgeRKoAtt%0%R z$TetFIEmS9SX_D>i&JH+Ax1o;2E#dRUw)LTr-y$zfwdg1$h;~jL;oum+&s9@x ztXoB+mwNU>%U^z^nlmcRhN)QEMU8U4Ce}**Op8(e_V&Byq?E?#PtSl?D?oLz@(-KM zyO!k!qIE71iIR_^-A<->le)&SH8tGYWk;0%0kIQ(32;|d88DDqVYRecX+wWJ7j|S> zwcsY|mKJC3ir#3!hM)N|6v6}Sy1DbOD8LErbjCW%_?-Ld#bE`Bl@)nzujV7rtImwa z6>4)!!CVB{1V#C5r)ri^{*pB?L9VApI_@Ye`aJzOUKvy=2uhQhl zLSR;1HCBhB#!6L~8*TgjnKeOY{eb5nu6xgLex*6sav!uxu+X!dsj&ExFuR<_L)}s9 zr0!(J%66mihrT4;pLLP&noC4=V_3M%NJ*V(+2ZnDUTgJ8t-94>QnCF1K2`rgZ{MD`-fo zXeCkvvKc;YUO!nuUKi0hC(|b{oY6JXn<+YS{3ef);BBs{7?uFvVc>UO6 z(wl8MKU{A*{{TuTJb1gQ;+x|;eb=+&J$-w}=A0jC3f7bR1mDC2)d~X@0;h1=gxP+_ z8b>AY61~D%qk;)Thk|0a3F%~GP;W-c6CK077H3cwCnQ)g*CK{a zhKVcX3Pe#?$s2T|v3!5ytvYthZQhNmPvef%gpu1HdS5FZ$dve1klP*Q*(eUr)hkaA zvrZp&E+?}CF0T>&Gw~+(gmEK>=HrGILP=h@+8}KlY3Hsu#XCdYwXvQ{V}3J_*5jQP z{Nw|8ejrj9l5lr!a&dCtk!Vj2q25)6(PgY~hWSlYPdp#>yUV#dlnw*Yysq>>r=HDf zyfDumHP?46XmI8~RCoMp=8n#Bpp3aiKU<5%p>hqik?IeF@hd>fb}1-N(*JGKO1fsv zK!qcai)4w>Y1@%EkKM)W!*k*~(+~6Z!E|My?*tarZbTpdTcuse@mFj{x*pf>6Is|h zW0e`(+!@>%PpoPQ4e3%>ZL5V&Mar)^nGQ8 z;?;XSlvt+a)1o4*-{4Qii#P9s)t~$6w><&BK9J7M*7qxC0L##1 z=Qz!s$gZX7fG4OsiI+x#K2nVS#Fr_mjkCp_+j|#)0NIzcbloq7#g`snX=o_#wMXwh z(uSOGuC?M4CVUU91qbVRg;w1)y6jFwsHxhPBO=PdQsK|B2El#PLJ`SPN6R5hbY)k} zzv1x*kk5+_gTW*)q%@DdD*BD6`cBN==v%{ zo_e{_9Lu4eDtf`~%iulLbt66(-aYm9qYxM9z7^NQ64np`E%?S{>l1S|lbym&hvcc4Mz{*D$7< zv#bCV^~pzvlYN$`0qxcvE0``3KHi^j`9167)ozEF>i5t!Rs>Zuu{`_rmRPCxd_5!6>W#a9aSq+*f7_u!#Rx>GXf9CLn{0VbX92){xDXCeygW#^9ASm;Nvam_8 z)3CIH_%s<~;J=$m09=8jBp?(SGhqLtW@6cPg?9aJ9VUMRAu;}+*}6K|{rkLbr)sBy zqlW5F54ADlTu79Lfn*t_elHwZR4d(JR}eZXt{7v0Wy=cvEg#<_f6E|J2HPa=)45^PbpZ#3=<-O2B_Zx2NUT0!V{7y3hkE(Se|cE;w%rvz3&k?O`* ztfOF7UbD9KfS_$CSJSnlZ6l8#U$)_J`g<+4Z`p0tKeWN&l`GR+L6fd|$?hxn9#_@M zcUOLd?YKr{gi}{Y^w6Ke{LH|5h=>TSW^^MqAY{6Kxw;blI#kN_h>>`cjK>=bWDWXL zTyWe8?DEQg;)jDb1KUH{7T9{^_TksMuqbBg9jf6KE|V2LeCa7-jITlJ+(F$Ks0G4< z4ECGsgpme-ZLS4TiD@b68>AP>TqoljSr5ybvOcs1oD3*h<&MXvG6?@GZdi4aw=RE4 zSdP1*Zl7>J$gNJ=H{yXj#l7~d{SlZH5}OoMHp~ydK7+f5*4Gam^US8OM#zX~q(-6G zX9H1-;>IvJK;(I@uIZgabSnJ0-k5u&snV7mzv8b*b#=}!UirZLfDre~lHk`<$a~mn zaPa$!Xr7!W-br?u)7u@vwQ_)mP7Uh&R|OTINQSU_Q|CU>Zlejr*A*sf;c z_@W^C1Sbq$3ooZDGyWT1m_GR(yGG()6k@208Ds|*8}~&2sK#6C?gsxMW|lbK@DG?` z1Or1_pUP-iDpvC@%(YSaCQ$tYpU&vW`;d(W503SS?2JPPFOcdM+WeIVnfNn%_olk{ zTZ9uIDNO2Oq^c{`6iFY_JmU+p_$$}BN*0?9A+4|Fc(BbR3YsN#sNHv^87NbhW~N#C(v@Lxv#; zT9^t!rBHySqW$c^xrH{(IJ7VVQW3H=<$V8lpVFcYM`$seZ_n3a*5f35>g((N9wQL@ zg1w1zdSEay>=av?ebSLll~$Fm2T{|y=jNGytM=Ngea#LkLdALJ*I!I2fv$vIRjd{i z;HkeMGoxD7^&88+uTsTZt0hE+vBF%LZYe6$HgN0IadfDQ zC?lLaSziP6n|YsMp~nZn%O6*M8TGNIGq4zBPH7ljxO1|*NjOc9Efkr9WDiSB$5qNP zo$L@G+8?7+ak#;V{Crgtfa4{%CzkUSkN0zT`n3Xo?v2WWhFp&Fc7~yx!==_wQagjm z^8Au|rcstZB~SBE>D(4kJ6w-g{W>$r%%ntdr;CyqmnGM|XXvY+&_{Z`{oMd8t&iwl zmnjh&RsBHl)tc{R2g|#oWbGy(cpUg2eOeoo^fIFF*4X^_`0qaLf3oM_OvV2skK&Z{ zkRl=W;Lvh8BqUebCZ1xbHyTA=Kv9_VPUM-DYwZ0Ud>%5sUHD^}*yZ3yP9?$cf>vR20syz0X>*f6% z@k0O>47GF{FnZaBLKwi<#w`XP2s#Ufl@dP?%!WaI*#`4jn3W3)&J-024~`0!2h)Q# zXA(Ll&!&iVG=`6JJ)m^8IIzSWlB)w5>mo!Lb7INsywl|bqM**0>j#6+8SYO;Th?Xe z9El9&R2#7RVEQg?IygiIj49FzBnFhf=uC{cIMATgo0cPnf;%Iqow7 zr1tXe$ZNpYYE&JH1J-$J#fEgr=zx7=jMc)ephx+NF>o*(uNyhup5ag#r_A6PXnK!* zDp~7qr}DPO7&PcQ)mv3C4XX9)VfdU$xkMC=;_z%{iaMiB?A`d_Tp_-VS&GM5=lu=(WjPTyuF6w4;UC>vR6}CD_+UO>$NZ}+r^9d^Ofa9A`*VZ{A-L=H z`{ZClA81O9lfXUD@RS`|19Z^#Zb?pURGx9cTWGu*1NW%B1_LmtA5p;uYPZ5*{bl>` zVEwZ(dy2Q&(Ec(5(WpI|12URZ4&ArPJ+cE+uSYy>FmZT1qtd#C`>D|SrTZ(;`o;UL z(E6u?H;3{VT6f;|_WLK|U=GGxyVK^~p;Ya6r@&wiDvlTdd$Tim(EbVoJZRgs`_E_} zLBRskgWb3G?9+VPACd##fX(`UNu{Pl1dK@jxa|9bL2Qgdpz@xPiXn8~^7j}FK%jn9 z1|ygsh{bhN+_g z_Yw=auu2qj0SF~oAn!+F3|=@f{ElzJ3IRL2N_-_GiuQxyGC>__FcSQQ(w_N{u|Y(F z)*qO+qE^VZ!z4Dyr!d9#poFDE7;HO`AbOJRLXX$TL+#at%|+CQ$%CT9G`KhO-o<(d zADXRVBV}u&2}fk8KWxE}-|R5#`8?r)^~0Xs;lqQ;m3NWdSZ7yZTh*kj;GIYn7~`LC ze%>7;5=(9Y+6%mWQOnH85@RFc6ItS(R+>pEZ9<2BQ)TX^`Bm z0F$Osr@~zRfOZW8k8(YyTqO9?ETUvz+G2ZKYy;^yq~QfbXi#Axu4r0`5Hg~EftJ#p z2zsc{4e8bS4ACh#x+D>nG;AS~t9$L3`tCE>@>{Rmd`$&E*A>`Bwhxax?jd2HYB&QY!7-wJ#&}=cRO$?ZedB2ps zjct>2ysbB`_AxTAPBny!-mr6Ok9wq9n;T0=9PedDj|fJJ(QC49Z00%Q)IP!ferGtp z(82S27a`j;G-$U4MZ(Y;ZE08p&qC`v%F^e%i_h6$)wjlV5gm6H)(`F%e#|rM;{#nP357;hW)J zm@Yx1R}UuNra&VMkx=tO$5%Rn<`Ldx9;Tsy3?clXERdj*SK|$4i*vc}5ZioA|)_zFp5e2l+^tWtbZ7>52OLD_-@3f?tNc z@+=zsgW7*OCx5?R^@GE|>d?aWz1gCSJ}eZ!BK3=k}zLZexW{zEB#X2 z!)uRU7DLgwwrRoCI)6;F`~R$hb02BOhtc)P&{oFRmGq9;h3e+?U;WMO;i(Qlt@OM zr%%fGZ19Y8pyO2xqXD-e)OR6@BcM^rOiI6#hh1{1aYHp!l?chXhE3HhjiW?RtBk8M z%A(G%GQX)ZR5^=3*`x}rv#{ktHG<>}f*UHlrH`V*;#z64S$FH(oZb9nTz;x+>T7Lq zl@~TOH5Mx!nJ%BGPv?|Q@TTLeex|0%+1X}ITjO)^$hpNXPgGu8URzpKwO+~P(Hlch zucVUa7Ibti9?sO%87y?9aUZWJ)%jD3dd_}(CJWcnpq7!8lsT#wp0Is<`S*5b7qyf* z=A9>6u78}DvB`SO9xXvuS=6ePA=`6RWL3P)lO))y(xBGoM`MZqoj z8Io8&hy#tf+O~*cWKh3~8zbts5L7V$vp_UdH4)m%CeAr{P!fe@+f);}Sp!DFK$*|y za>6V9Eu!kw`a14S5GtJ^wK}dU(^f-`Mh?HNC`vIRt8T3;Hquh*R$p5zieipJP@<=% zq@dx$ms>T~<}GbuJk~)QWS%Lu!t)DD{WWovGpx(-jAeUfzl7Vh$55Pq0;_nI?%|?* zE44jcB+JChrCew=qclTs@#tkW%RVDBR>pvwYKRDpt({(<9x`I0etB51()Lp12g#z9 zR)`WuT4zMPV#erxJ}^AdB9nbmS&|ZW^NWaDjY(y?NF*ddX4-r@6Qo{+aq+w*6Sp?1 zGY0g2pHFSt;@#{C!S&To9|a@WJ5X2#jlu~&pB7z_SWStYNMlz!Hs-hVQxL2@O&QlT z7YA;UG#ZSTFhy;QQQI*uW>?Y6Q6B}ck`FUcmq1Be7#HuuDFCgbt5DcxDVuf1p zjj*?Z2o>qQcwH)rgjl&nld01pN?H9(Hr?+A-Dil>DvPveHAbk4LMhE)`!~G+ zlZKj1NCHU86&t(5Z$XOO2kIykE@t~2!M(U?u8GCf#^egsBqkft*)rH?IyW~Q!6`sy z1{c@nt0XY5=qrxFN@UnknGUi}Z_L$Ggc7fw6t8I~cOlG4@O_X@@|<6kk>_ksNbG^S z=7bmb8uUvfe#rLdqtZ#H%yO*LCbGN7(#U1(6P_!t+XWMyRuE_FXGXf`DX3viKMnmI#o8_|VHxhXwa~(Y#=@yO>-1Nz*Lxok$@XDaClwkg$ zo);o7`bny%8Y36LQl9I9)!SFVwIl?veqyF=q-U-`!y@H8zBb+|Hy+}mD!zlqu-lie zk2OrTFa3rFhl%upD*oO;BAQG<16lYAs?Y+Y;|i!%-04klyM_6gznS?!K%NFGx%l%+ zhXXdK=t;=?lD&OXOH9_cyPef@B+~~h-v#@T(%zDQ22Xy@{r>AbK>{g21Y(pB&q%nm z&RXE2O$HW)){eVdyhN#>?fF>Y5^Z<;;>m8UnJTR%%X8pU*OPR|B+{s+yO`8KC^s$rlG6TGfz|2W zCo{@o@dAVE1WHz%rAV1za-}<+VM8HX#lleCID)dLMd^EPX>GNkDPeZo=At>Z-c5jH zvgTtG)8V3gJ!{_8I&s?D2!(MOBGLZB9tKmApxsndY9>ZOBJJ{aPBv7x-ZB%|mzp-) z)U+zgGiKhr|2wewB8u|*(dy)+Bq2h0MMw1+j707eDL)@9=5|aR2WsQYv4tgQsK~1W zu2v(HRYuEbp~`{v@RnthX3yX-Uf6uSy*zj^Kx+MnVsySbEYc^o5n26T@}bPGHJU=2 zC0c%}KfZ~aCg5NQ0<-f2$k~itoVlLQx8dY0VR8kyEDy9J@Ydy~06Vf`(&TK;D6IC? zkRI=~!2D|&NR`7&Jc7oYRj8SP+^K=w6VluaS%nF0ABB*7r#P6nM}GfPE+Eb<*p^ev z3VPhtcBd89rarFz}zqVFbUHeB~RHe ze)~`SAc`{&Y{Gt4rFT}pTwwMKAlWC}0+?Pq0Z4mW{A~pHxzB{gryr)*5M%hpLN8dY zD1<7|jYFD_!uT&J;Gg=Q0+gh~8^+ZD*x+jRenX5GzSo}# zY?TMg(jl{+0o$25kAT zW<#I{L9_=EHrqn3Z+AkeH?eI`jYNR0t>_#-W;22_1Qb9TVSqE_+mt95Ajv;rLsuND zK#3C)IV_IDuJ$EuFSlb&2(Kpm*fC7?Ha#ua>p|i6Df}ay3gaxzc23)N$r59_%u{+N z^e3ZR#Mbx4%P%0DXL{~qe7JA{hcxu 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

    I8_nWQmla%we@Iji{1SQ?m*~ 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 QGin|_fqUSNv#iel1NWwaUjP6A diff --git a/org.lflang/about.html b/org.lflang/about.html deleted file mode 100644 index 777f15cf39..0000000000 --- a/org.lflang/about.html +++ /dev/null @@ -1,81 +0,0 @@ - - - - - About - - -

    About This Content

    - -

    License

    - -

    - Lingua Franca is a polyglot coordination language for defining and composing reactors. -

    - -

    - For more information about Lingua-Franca, see https://github.com/icyphy/lingua-franca/wiki -

    - -

    - The Lingua-Franca toolkit is licensed under the BSD 2-Clause License: -

    - -

    - Copyright (c) 2020, The University of California at Berkeley, - The Technical University of Dresden, - and Volkan Yazici . -

    - -

    - 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. -
    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. -
    - -

    - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -

    - -

    - SPDX-License-Identifier: BSD-2-Clause -

    - - - diff --git a/org.lflang/build.properties b/org.lflang/build.properties deleted file mode 100644 index 09be7967da..0000000000 --- a/org.lflang/build.properties +++ /dev/null @@ -1,20 +0,0 @@ -source.. = src/,\ - src-gen/ -bin.includes = model/generated/,\ - .,\ - META-INF/,\ - plugin.xml,\ - about.html -bin.excludes = **/*.mwe2,\ - **/*.xtend \ - src/lib -additional.bundles = org.eclipse.xtext.xbase,\ - org.eclipse.xtext.common.types,\ - org.eclipse.xtext.xtext.generator,\ - org.eclipse.emf.codegen.ecore,\ - org.eclipse.emf.mwe.utils,\ - org.eclipse.emf.mwe2.launch,\ - org.eclipse.emf.mwe2.lib,\ - org.objectweb.asm,\ - org.apache.log4j,\ - com.ibm.icu From 42d867df4175f6e430ae4aa611d4093906f4b0ab Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 09:22:18 +0200 Subject: [PATCH 478/709] update gitignore --- .gitignore | 4 ++++ org.lflang/.gitignore | 1 - 2 files changed, 4 insertions(+), 1 deletion(-) delete mode 100644 org.lflang/.gitignore diff --git a/.gitignore b/.gitignore index bb35405752..b075a77ad5 100644 --- a/.gitignore +++ b/.gitignore @@ -153,3 +153,7 @@ gradle-app.setting **/build/ # End of https://www.toptal.com/developers/gitignore/api/intellij,gradle,eclipse,maven,visualstudiocode + +### xtext artifaccts +*.jar +org/lflang/model/ \ No newline at end of file diff --git a/org.lflang/.gitignore b/org.lflang/.gitignore deleted file mode 100644 index 0447b0d4ac..0000000000 --- a/org.lflang/.gitignore +++ /dev/null @@ -1 +0,0 @@ -model/ From 12f7e2c89d7d58ad93b1982db263e19dc31b4f45 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 11:12:39 +0200 Subject: [PATCH 479/709] gradle like source code layout --- .gitignore | 2 +- lfc/build.gradle | 2 +- org.lflang/{ => core}/build.gradle | 12 ++++++------ .../src/main/java}/org/lflang/AttributeUtils.java | 0 .../src/main/java}/org/lflang/CommonExtensions.kt | 0 .../main/java}/org/lflang/DefaultErrorReporter.java | 0 .../src/main/java}/org/lflang/ErrorReporter.java | 0 .../src/main/java}/org/lflang/FileConfig.java | 0 .../main/java}/org/lflang/FileConfigExtensions.kt | 0 .../main/java}/org/lflang/GenerateLinguaFranca.mwe2 | 6 ++++-- .../src/main/java}/org/lflang/InferredType.java | 0 .../org/lflang/LFResourceDescriptionStrategy.java | 0 .../main/java}/org/lflang/LFResourceProvider.java | 0 .../src/main/java}/org/lflang/LFRuntimeModule.java | 0 .../src/main/java}/org/lflang/LFStandaloneSetup.java | 0 .../org/lflang/LFSyntaxErrorMessageProvider.java | 0 .../src/main/java}/org/lflang/LinguaFranca.xtext | 0 .../src/main/java}/org/lflang/LocalStrings.java | 0 .../main/java}/org/lflang/MainConflictChecker.java | 0 .../src/main/java}/org/lflang/ModelInfo.java | 0 .../main/java}/org/lflang/StringsBundle.properties | 0 .../src/main/java}/org/lflang/Target.java | 0 .../src/main/java}/org/lflang/TargetConfig.java | 0 .../src/main/java}/org/lflang/TargetProperty.java | 0 .../src/main/java}/org/lflang/TimeUnit.java | 0 .../src/main/java}/org/lflang/TimeValue.java | 0 .../src/main/java}/org/lflang/ast/ASTUtils.java | 0 .../src/main/java}/org/lflang/ast/AstExtensions.kt | 0 .../main/java}/org/lflang/ast/AstTransformation.java | 0 .../lflang/ast/DelayedConnectionTransformation.java | 0 .../main/java}/org/lflang/ast/FormattingUtils.java | 0 .../src/main/java}/org/lflang/ast/IsEqual.java | 0 .../main/java}/org/lflang/ast/MalleableString.java | 0 .../src/main/java}/org/lflang/ast/ToLf.java | 0 .../src/main/java}/org/lflang/ast/ToText.java | 0 .../src/main/java}/org/lflang/cli/CliBase.java | 0 .../java}/org/lflang/cli/LFStandaloneModule.java | 0 .../src/main/java}/org/lflang/cli/Lff.java | 0 .../src/main/java}/org/lflang/cli/ReportingUtil.kt | 0 .../org/lflang/cli/StandaloneErrorReporter.java | 0 .../org/lflang/cli/StandaloneIssueAcceptor.java | 0 .../main/java}/org/lflang/cli/VersionProvider.java | 0 .../org/lflang/diagram/lsp/LFLanguageServer.java | 0 .../diagram/lsp/LFLanguageServerExtension.java | 0 .../lflang/diagram/lsp/LanguageDiagramServer.java | 0 .../main/java}/org/lflang/diagram/lsp/Progress.java | 0 .../synthesis/AbstractSynthesisExtensions.java | 0 .../diagram/synthesis/LinguaFrancaSynthesis.java | 0 .../synthesis/ReactorParameterDisplayModes.java | 0 .../diagram/synthesis/SynthesisRegistration.java | 0 .../diagram/synthesis/action/AbstractAction.java | 0 .../synthesis/action/CollapseAllReactorsAction.java | 0 .../synthesis/action/ExpandAllReactorsAction.java | 0 .../diagram/synthesis/action/FilterCycleAction.java | 0 .../action/MemorizingExpandCollapseAction.java | 0 .../diagram/synthesis/action/ShowCycleAction.java | 0 .../postprocessor/ReactionPortAdjustment.java | 0 .../styles/LinguaFrancaShapeExtensions.java | 0 .../styles/LinguaFrancaStyleExtensions.java | 0 .../synthesis/styles/ReactorFigureComponents.java | 0 .../diagram/synthesis/util/CycleVisualization.java | 0 .../util/InterfaceDependenciesVisualization.java | 0 .../diagram/synthesis/util/LayoutPostProcessing.java | 0 .../lflang/diagram/synthesis/util/ModeDiagrams.java | 0 .../diagram/synthesis/util/NamedInstanceUtil.java | 0 .../lflang/diagram/synthesis/util/ReactorIcons.java | 0 .../synthesis/util/SynthesisErrorReporter.java | 0 .../diagram/synthesis/util/UtilityExtensions.java | 0 .../org/lflang/federated/extensions/CExtension.java | 0 .../lflang/federated/extensions/CExtensionUtils.java | 0 .../federated/extensions/FedTargetExtension.java | 0 .../extensions/FedTargetExtensionFactory.java | 0 .../lflang/federated/extensions/PythonExtension.java | 0 .../org/lflang/federated/extensions/TSExtension.java | 0 .../org/lflang/federated/generator/FedASTUtils.java | 0 .../federated/generator/FedConnectionInstance.java | 0 .../org/lflang/federated/generator/FedEmitter.java | 0 .../lflang/federated/generator/FedFileConfig.java | 0 .../org/lflang/federated/generator/FedGenerator.java | 0 .../lflang/federated/generator/FedImportEmitter.java | 0 .../lflang/federated/generator/FedMainEmitter.java | 0 .../federated/generator/FedPreambleEmitter.java | 0 .../federated/generator/FedReactorEmitter.java | 0 .../lflang/federated/generator/FedTargetConfig.java | 0 .../lflang/federated/generator/FedTargetEmitter.java | 0 .../org/lflang/federated/generator/FedUtils.java | 0 .../lflang/federated/generator/FederateInstance.java | 0 .../generator/LineAdjustingErrorReporter.java | 0 .../generator/SynchronizedErrorReporter.java | 0 .../org/lflang/federated/launcher/BuildConfig.java | 0 .../org/lflang/federated/launcher/CBuildConfig.java | 0 .../federated/launcher/FedLauncherGenerator.java | 0 .../org/lflang/federated/launcher/PyBuildConfig.java | 0 .../org/lflang/federated/launcher/RtiConfig.java | 0 .../org/lflang/federated/launcher/TsBuildConfig.java | 0 .../serialization/FedNativePythonSerialization.java | 0 .../serialization/FedROS2CPPSerialization.java | 0 .../federated/serialization/FedSerialization.java | 0 .../serialization/SupportedSerializers.java | 0 .../lflang/federated/validation/FedValidator.java | 0 .../java}/org/lflang/formatting2/LFFormatter.java | 0 .../java}/org/lflang/generator/ActionInstance.java | 0 .../main/java}/org/lflang/generator/CodeBuilder.java | 0 .../src/main/java}/org/lflang/generator/CodeMap.java | 0 .../java}/org/lflang/generator/DeadlineInstance.java | 0 .../org/lflang/generator/DelayBodyGenerator.java | 0 .../org/lflang/generator/DiagnosticReporting.java | 0 .../org/lflang/generator/DockerComposeGenerator.java | 0 .../main/java}/org/lflang/generator/DockerData.java | 0 .../java}/org/lflang/generator/DockerGenerator.java | 0 .../lflang/generator/FedDockerComposeGenerator.java | 0 .../org/lflang/generator/GenerationException.java | 0 .../java}/org/lflang/generator/GeneratorBase.java | 0 .../lflang/generator/GeneratorCommandFactory.java | 0 .../org/lflang/generator/GeneratorExtensions.kt | 0 .../java}/org/lflang/generator/GeneratorResult.java | 0 .../java}/org/lflang/generator/GeneratorUtils.java | 0 .../java}/org/lflang/generator/GeneratorUtils.kt | 0 .../generator/HumanReadableReportingStrategy.java | 0 .../org/lflang/generator/IntegratedBuilder.java | 0 .../lflang/generator/InvalidLfSourceException.java | 0 .../org/lflang/generator/InvalidSourceException.java | 0 .../main/java}/org/lflang/generator/LFGenerator.java | 0 .../org/lflang/generator/LFGeneratorContext.java | 0 .../main/java}/org/lflang/generator/LFResource.java | 0 .../org/lflang/generator/LanguageRuntimeVersions.kt | 0 .../generator/LanguageServerErrorReporter.java | 0 .../org/lflang/generator/LfExpressionVisitor.java | 0 .../main/java}/org/lflang/generator/MainContext.java | 0 .../java}/org/lflang/generator/MixedRadixInt.java | 0 .../java}/org/lflang/generator/ModeInstance.java | 0 .../java}/org/lflang/generator/NamedInstance.java | 0 .../org/lflang/generator/ParameterInstance.java | 0 .../java}/org/lflang/generator/PortInstance.java | 0 .../main/java}/org/lflang/generator/Position.java | 0 .../src/main/java}/org/lflang/generator/Range.java | 0 .../java}/org/lflang/generator/ReactionInstance.java | 0 .../org/lflang/generator/ReactionInstanceGraph.java | 0 .../java}/org/lflang/generator/ReactorInstance.java | 0 .../java}/org/lflang/generator/RuntimeRange.java | 0 .../main/java}/org/lflang/generator/SendRange.java | 0 .../main/java}/org/lflang/generator/SubContext.java | 0 .../main/java}/org/lflang/generator/TargetTypes.java | 0 .../java}/org/lflang/generator/TimerInstance.java | 0 .../java}/org/lflang/generator/TriggerInstance.java | 0 .../UnsupportedGeneratorFeatureException.java | 0 .../org/lflang/generator/ValidationStrategy.java | 0 .../main/java}/org/lflang/generator/Validator.java | 0 .../java}/org/lflang/generator/WatchdogInstance.java | 0 .../org/lflang/generator/c/CActionGenerator.java | 0 .../org/lflang/generator/c/CCmakeGenerator.java | 0 .../main/java}/org/lflang/generator/c/CCompiler.java | 0 .../lflang/generator/c/CConstructorGenerator.java | 0 .../org/lflang/generator/c/CCoreFilesUtils.java | 0 .../org/lflang/generator/c/CDelayBodyGenerator.java | 0 .../org/lflang/generator/c/CDockerGenerator.java | 0 .../java}/org/lflang/generator/c/CFileConfig.java | 0 .../java}/org/lflang/generator/c/CGenerator.java | 0 .../lflang/generator/c/CMainFunctionGenerator.java | 0 .../org/lflang/generator/c/CMethodGenerator.java | 0 .../org/lflang/generator/c/CMixedRadixGenerator.java | 0 .../org/lflang/generator/c/CModesGenerator.java | 0 .../org/lflang/generator/c/CParameterGenerator.java | 0 .../java}/org/lflang/generator/c/CPortGenerator.java | 0 .../org/lflang/generator/c/CPreambleGenerator.java | 0 .../org/lflang/generator/c/CReactionGenerator.java | 0 .../generator/c/CReactorHeaderFileGenerator.java | 0 .../org/lflang/generator/c/CStateGenerator.java | 0 .../org/lflang/generator/c/CTimerGenerator.java | 0 .../org/lflang/generator/c/CTracingGenerator.java | 0 .../lflang/generator/c/CTriggerObjectsGenerator.java | 0 .../main/java}/org/lflang/generator/c/CTypes.java | 0 .../src/main/java}/org/lflang/generator/c/CUtil.java | 0 .../org/lflang/generator/c/CWatchdogGenerator.java | 0 .../generator/c/InteractingContainedReactors.java | 0 .../lflang/generator/c/TypeParameterizedReactor.java | 0 .../org/lflang/generator/cpp/CppActionGenerator.kt | 0 .../generator/cpp/CppAssembleMethodGenerator.kt | 0 .../lflang/generator/cpp/CppConnectionGenerator.kt | 0 .../java}/org/lflang/generator/cpp/CppExtensions.kt | 0 .../java}/org/lflang/generator/cpp/CppFileConfig.kt | 0 .../java}/org/lflang/generator/cpp/CppGenerator.kt | 0 .../org/lflang/generator/cpp/CppInstanceGenerator.kt | 0 .../org/lflang/generator/cpp/CppMethodGenerator.kt | 0 .../lflang/generator/cpp/CppParameterGenerator.kt | 0 .../org/lflang/generator/cpp/CppPlatformGenerator.kt | 0 .../org/lflang/generator/cpp/CppPortGenerator.kt | 0 .../org/lflang/generator/cpp/CppPreambleGenerator.kt | 0 .../org/lflang/generator/cpp/CppReactionGenerator.kt | 0 .../org/lflang/generator/cpp/CppReactorGenerator.kt | 0 .../org/lflang/generator/cpp/CppRos2Generator.kt | 0 .../org/lflang/generator/cpp/CppRos2NodeGenerator.kt | 0 .../lflang/generator/cpp/CppRos2PackageGenerator.kt | 0 .../generator/cpp/CppStandaloneCmakeGenerator.kt | 0 .../lflang/generator/cpp/CppStandaloneGenerator.kt | 0 .../generator/cpp/CppStandaloneMainGenerator.kt | 0 .../org/lflang/generator/cpp/CppStateGenerator.kt | 0 .../org/lflang/generator/cpp/CppTimerGenerator.kt | 0 .../main/java}/org/lflang/generator/cpp/CppTypes.kt | 0 .../java}/org/lflang/generator/cpp/CppValidator.kt | 0 .../org/lflang/generator/python/PyFileConfig.java | 0 .../java}/org/lflang/generator/python/PyUtil.java | 0 .../generator/python/PythonActionGenerator.java | 0 .../generator/python/PythonDelayBodyGenerator.java | 0 .../generator/python/PythonDockerGenerator.java | 0 .../org/lflang/generator/python/PythonGenerator.java | 0 .../lflang/generator/python/PythonInfoGenerator.java | 0 .../python/PythonMainFunctionGenerator.java | 0 .../generator/python/PythonMethodGenerator.java | 0 .../lflang/generator/python/PythonModeGenerator.java | 0 .../generator/python/PythonParameterGenerator.java | 0 .../lflang/generator/python/PythonPortGenerator.java | 0 .../generator/python/PythonPreambleGenerator.java | 0 .../generator/python/PythonReactionGenerator.java | 0 .../generator/python/PythonReactorGenerator.java | 0 .../generator/python/PythonStateGenerator.java | 0 .../org/lflang/generator/python/PythonTypes.java | 0 .../org/lflang/generator/python/PythonValidator.java | 0 .../lflang/generator/rust/CargoDependencySpec.java | 0 .../java}/org/lflang/generator/rust/PortEmitter.kt | 0 .../lflang/generator/rust/RustCargoTomlEmitter.kt | 0 .../java}/org/lflang/generator/rust/RustEmitter.kt | 0 .../org/lflang/generator/rust/RustEmitterBase.kt | 0 .../org/lflang/generator/rust/RustFileConfig.kt | 0 .../java}/org/lflang/generator/rust/RustGenerator.kt | 0 .../org/lflang/generator/rust/RustMainFileEmitter.kt | 0 .../java}/org/lflang/generator/rust/RustModel.kt | 0 .../org/lflang/generator/rust/RustReactorEmitter.kt | 0 .../org/lflang/generator/rust/RustTargetConfig.java | 0 .../java}/org/lflang/generator/rust/RustTypes.kt | 0 .../java}/org/lflang/generator/rust/RustValidator.kt | 0 .../org/lflang/generator/ts/TSActionGenerator.kt | 0 .../org/lflang/generator/ts/TSConnectionGenerator.kt | 0 .../lflang/generator/ts/TSConstructorGenerator.kt | 0 .../org/lflang/generator/ts/TSDelayBodyGenerator.kt | 0 .../org/lflang/generator/ts/TSDockerGenerator.java | 0 .../java}/org/lflang/generator/ts/TSExtensions.kt | 0 .../java}/org/lflang/generator/ts/TSFileConfig.kt | 0 .../java}/org/lflang/generator/ts/TSGenerator.kt | 0 .../lflang/generator/ts/TSImportPreambleGenerator.kt | 0 .../org/lflang/generator/ts/TSInstanceGenerator.kt | 0 .../org/lflang/generator/ts/TSParameterGenerator.kt | 0 .../generator/ts/TSParameterPreambleGenerator.kt | 0 .../java}/org/lflang/generator/ts/TSPortGenerator.kt | 0 .../org/lflang/generator/ts/TSReactionGenerator.kt | 0 .../org/lflang/generator/ts/TSReactorGenerator.kt | 0 .../org/lflang/generator/ts/TSStateGenerator.kt | 0 .../org/lflang/generator/ts/TSTimerGenerator.kt | 0 .../main/java}/org/lflang/generator/ts/TSTypes.java | 0 .../java}/org/lflang/generator/ts/TSValidator.kt | 0 .../main/java}/org/lflang/graph/DirectedGraph.java | 0 .../src/main/java}/org/lflang/graph/Graph.java | 0 .../java}/org/lflang/graph/InstantiationGraph.java | 0 .../main/java}/org/lflang/graph/NodeAnnotation.java | 0 .../main/java}/org/lflang/graph/NodeAnnotations.java | 0 .../main/java}/org/lflang/graph/PrecedenceGraph.java | 0 .../main/java}/org/lflang/graph/TopologyGraph.java | 0 .../src/main/java}/org/lflang/ide/LFIdeModule.java | 0 .../src/main/java}/org/lflang/ide/LFIdeSetup.java | 0 .../org/lflang/scoping/LFGlobalScopeProvider.java | 0 .../java}/org/lflang/scoping/LFScopeProvider.java | 0 .../org/lflang/scoping/LFScopeProviderImpl.java | 0 .../src/main/java}/org/lflang/util/ArduinoUtil.java | 0 .../src/main/java}/org/lflang/util/Averager.java | 0 .../main/java}/org/lflang/util/CollectionUtil.java | 0 .../src/main/java}/org/lflang/util/FileUtil.java | 0 .../src/main/java}/org/lflang/util/IteratorUtil.java | 0 .../src/main/java}/org/lflang/util/LFCommand.java | 0 .../src/main/java}/org/lflang/util/StringUtil.java | 0 .../lflang/util/TargetResourceNotFoundException.java | 0 .../java}/org/lflang/validation/AttributeSpec.java | 0 .../java}/org/lflang/validation/BaseLFValidator.java | 0 .../validation/LFNamesAreUniqueValidationHelper.java | 0 .../java}/org/lflang/validation/LFValidator.java | 0 .../lflang/validation/ValidatorErrorReporter.java | 0 settings.gradle | 2 +- 276 files changed, 13 insertions(+), 11 deletions(-) rename org.lflang/{ => core}/build.gradle (90%) rename org.lflang/{src => core/src/main/java}/org/lflang/AttributeUtils.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/CommonExtensions.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/DefaultErrorReporter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ErrorReporter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/FileConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/FileConfigExtensions.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/GenerateLinguaFranca.mwe2 (94%) rename org.lflang/{src => core/src/main/java}/org/lflang/InferredType.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/LFResourceDescriptionStrategy.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/LFResourceProvider.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/LFRuntimeModule.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/LFStandaloneSetup.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/LFSyntaxErrorMessageProvider.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/LinguaFranca.xtext (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/LocalStrings.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/MainConflictChecker.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ModelInfo.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/StringsBundle.properties (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/Target.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/TargetConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/TargetProperty.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/TimeUnit.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/TimeValue.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/ASTUtils.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/AstExtensions.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/AstTransformation.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/DelayedConnectionTransformation.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/FormattingUtils.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/IsEqual.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/MalleableString.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/ToLf.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ast/ToText.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/cli/CliBase.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/cli/LFStandaloneModule.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/cli/Lff.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/cli/ReportingUtil.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/cli/StandaloneErrorReporter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/cli/StandaloneIssueAcceptor.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/cli/VersionProvider.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/lsp/LFLanguageServer.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/lsp/LFLanguageServerExtension.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/lsp/LanguageDiagramServer.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/lsp/Progress.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/SynthesisRegistration.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/action/AbstractAction.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/action/FilterCycleAction.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/action/ShowCycleAction.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/util/CycleVisualization.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/util/ModeDiagrams.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/util/ReactorIcons.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/diagram/synthesis/util/UtilityExtensions.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/extensions/CExtension.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/extensions/CExtensionUtils.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/extensions/FedTargetExtension.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/extensions/FedTargetExtensionFactory.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/extensions/PythonExtension.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/extensions/TSExtension.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedASTUtils.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedConnectionInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedEmitter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedFileConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedImportEmitter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedMainEmitter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedPreambleEmitter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedReactorEmitter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedTargetConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedTargetEmitter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FedUtils.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/FederateInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/LineAdjustingErrorReporter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/generator/SynchronizedErrorReporter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/launcher/BuildConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/launcher/CBuildConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/launcher/FedLauncherGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/launcher/PyBuildConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/launcher/RtiConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/launcher/TsBuildConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/serialization/FedNativePythonSerialization.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/serialization/FedROS2CPPSerialization.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/serialization/FedSerialization.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/serialization/SupportedSerializers.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/federated/validation/FedValidator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/formatting2/LFFormatter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ActionInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/CodeBuilder.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/CodeMap.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/DeadlineInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/DelayBodyGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/DiagnosticReporting.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/DockerComposeGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/DockerData.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/DockerGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/FedDockerComposeGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/GenerationException.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/GeneratorBase.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/GeneratorCommandFactory.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/GeneratorExtensions.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/GeneratorResult.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/GeneratorUtils.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/GeneratorUtils.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/HumanReadableReportingStrategy.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/IntegratedBuilder.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/InvalidLfSourceException.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/InvalidSourceException.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/LFGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/LFGeneratorContext.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/LFResource.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/LanguageRuntimeVersions.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/LanguageServerErrorReporter.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/LfExpressionVisitor.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/MainContext.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/MixedRadixInt.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ModeInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/NamedInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ParameterInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/PortInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/Position.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/Range.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ReactionInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ReactionInstanceGraph.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ReactorInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/RuntimeRange.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/SendRange.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/SubContext.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/TargetTypes.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/TimerInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/TriggerInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/UnsupportedGeneratorFeatureException.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ValidationStrategy.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/Validator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/WatchdogInstance.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CActionGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CCmakeGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CCompiler.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CConstructorGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CCoreFilesUtils.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CDelayBodyGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CDockerGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CFileConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CMainFunctionGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CMethodGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CMixedRadixGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CModesGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CParameterGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CPortGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CPreambleGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CReactionGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CReactorHeaderFileGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CStateGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CTimerGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CTracingGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CTriggerObjectsGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CTypes.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CUtil.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/CWatchdogGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/InteractingContainedReactors.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/c/TypeParameterizedReactor.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppActionGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppConnectionGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppExtensions.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppFileConfig.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppInstanceGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppMethodGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppParameterGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppPlatformGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppPortGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppPreambleGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppReactionGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppReactorGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppRos2Generator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppRos2NodeGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppRos2PackageGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppStandaloneGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppStateGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppTimerGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppTypes.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/cpp/CppValidator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PyFileConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PyUtil.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonActionGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonDelayBodyGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonDockerGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonInfoGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonMainFunctionGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonMethodGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonModeGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonParameterGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonPortGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonPreambleGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonReactionGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonReactorGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonStateGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonTypes.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/python/PythonValidator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/CargoDependencySpec.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/PortEmitter.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustCargoTomlEmitter.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustEmitter.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustEmitterBase.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustFileConfig.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustMainFileEmitter.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustModel.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustReactorEmitter.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustTargetConfig.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustTypes.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/rust/RustValidator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSActionGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSConnectionGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSConstructorGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSDelayBodyGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSDockerGenerator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSExtensions.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSFileConfig.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSImportPreambleGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSInstanceGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSParameterGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSParameterPreambleGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSPortGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSReactionGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSReactorGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSStateGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSTimerGenerator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSTypes.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/generator/ts/TSValidator.kt (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/graph/DirectedGraph.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/graph/Graph.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/graph/InstantiationGraph.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/graph/NodeAnnotation.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/graph/NodeAnnotations.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/graph/PrecedenceGraph.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/graph/TopologyGraph.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ide/LFIdeModule.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/ide/LFIdeSetup.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/scoping/LFGlobalScopeProvider.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/scoping/LFScopeProvider.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/scoping/LFScopeProviderImpl.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/util/ArduinoUtil.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/util/Averager.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/util/CollectionUtil.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/util/FileUtil.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/util/IteratorUtil.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/util/LFCommand.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/util/StringUtil.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/util/TargetResourceNotFoundException.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/validation/AttributeSpec.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/validation/BaseLFValidator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/validation/LFNamesAreUniqueValidationHelper.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/validation/LFValidator.java (100%) rename org.lflang/{src => core/src/main/java}/org/lflang/validation/ValidatorErrorReporter.java (100%) diff --git a/.gitignore b/.gitignore index b075a77ad5..579afb6154 100644 --- a/.gitignore +++ b/.gitignore @@ -156,4 +156,4 @@ gradle-app.setting ### xtext artifaccts *.jar -org/lflang/model/ \ No newline at end of file +org.lflang/core/model/ \ No newline at end of file diff --git a/lfc/build.gradle b/lfc/build.gradle index 7dd8ee764b..7eb33a7223 100644 --- a/lfc/build.gradle +++ b/lfc/build.gradle @@ -41,7 +41,7 @@ dependencies { exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' } implementation group: 'info.picocli', name: 'picocli', version: picocliVersion - implementation project(':org.lflang') + implementation project(':org.lflang:core') } application { diff --git a/org.lflang/build.gradle b/org.lflang/core/build.gradle similarity index 90% rename from org.lflang/build.gradle rename to org.lflang/core/build.gradle index f93af170ad..92d4fb02aa 100644 --- a/org.lflang/build.gradle +++ b/org.lflang/core/build.gradle @@ -6,13 +6,13 @@ plugins { sourceSets { main { java { - srcDirs = ['src', 'src-gen'] + srcDirs = ['src/main/java', 'src-gen'] } kotlin { - srcDirs = ['src', 'src-gen'] + srcDirs = ['src/main/java', 'src-gen'] } resources { - srcDirs = ['src-gen', 'src'] + srcDirs = ['src-gen', '../src/'] include 'lib/' include 'org/lflang/LF.xtextbin' include 'org/lflang/parser/antlr/internal/InternalLF.tokens' @@ -79,10 +79,10 @@ dependencies { tasks.register('generateXtextLanguage', JavaExec) { main = 'org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher' classpath = configurations.mwe2 - inputs.file "src/org/lflang/GenerateLinguaFranca.mwe2" - inputs.file "src/org/lflang/LinguaFranca.xtext" + inputs.file "src/main/java/org/lflang/GenerateLinguaFranca.mwe2" + inputs.file "src/main/java/org/lflang/LinguaFranca.xtext" outputs.dir "src-gen" - args += "src/org/lflang/GenerateLinguaFranca.mwe2" + args += "src/main/java/org/lflang/GenerateLinguaFranca.mwe2" args += "-p" args += "rootPath=/${projectDir}/.." } diff --git a/org.lflang/src/org/lflang/AttributeUtils.java b/org.lflang/core/src/main/java/org/lflang/AttributeUtils.java similarity index 100% rename from org.lflang/src/org/lflang/AttributeUtils.java rename to org.lflang/core/src/main/java/org/lflang/AttributeUtils.java diff --git a/org.lflang/src/org/lflang/CommonExtensions.kt b/org.lflang/core/src/main/java/org/lflang/CommonExtensions.kt similarity index 100% rename from org.lflang/src/org/lflang/CommonExtensions.kt rename to org.lflang/core/src/main/java/org/lflang/CommonExtensions.kt diff --git a/org.lflang/src/org/lflang/DefaultErrorReporter.java b/org.lflang/core/src/main/java/org/lflang/DefaultErrorReporter.java similarity index 100% rename from org.lflang/src/org/lflang/DefaultErrorReporter.java rename to org.lflang/core/src/main/java/org/lflang/DefaultErrorReporter.java diff --git a/org.lflang/src/org/lflang/ErrorReporter.java b/org.lflang/core/src/main/java/org/lflang/ErrorReporter.java similarity index 100% rename from org.lflang/src/org/lflang/ErrorReporter.java rename to org.lflang/core/src/main/java/org/lflang/ErrorReporter.java diff --git a/org.lflang/src/org/lflang/FileConfig.java b/org.lflang/core/src/main/java/org/lflang/FileConfig.java similarity index 100% rename from org.lflang/src/org/lflang/FileConfig.java rename to org.lflang/core/src/main/java/org/lflang/FileConfig.java diff --git a/org.lflang/src/org/lflang/FileConfigExtensions.kt b/org.lflang/core/src/main/java/org/lflang/FileConfigExtensions.kt similarity index 100% rename from org.lflang/src/org/lflang/FileConfigExtensions.kt rename to org.lflang/core/src/main/java/org/lflang/FileConfigExtensions.kt diff --git a/org.lflang/src/org/lflang/GenerateLinguaFranca.mwe2 b/org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 similarity index 94% rename from org.lflang/src/org/lflang/GenerateLinguaFranca.mwe2 rename to org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 index bc16003991..c2b557c631 100644 --- a/org.lflang/src/org/lflang/GenerateLinguaFranca.mwe2 +++ b/org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 @@ -4,7 +4,7 @@ import org.eclipse.xtext.xtext.generator.* import org.eclipse.xtext.xtext.generator.model.project.* var rootPath = ".." -var coreProject = "org.lflang" +var coreProject = "core" Workflow { component = XtextGenerator { @@ -15,13 +15,15 @@ Workflow { runtime = { enabled = true name = coreProject // generate core project + src = "src/main/java" } genericIde = { enabled = true name = coreProject // add into the core project + src = "src/main/java" } runtimeTest = { - enabled = true + enabled = false name = "org.lflang.tests" // generate into separate test project } // Only generate Eclipse infrastructure for the Epoch build (separate repository). diff --git a/org.lflang/src/org/lflang/InferredType.java b/org.lflang/core/src/main/java/org/lflang/InferredType.java similarity index 100% rename from org.lflang/src/org/lflang/InferredType.java rename to org.lflang/core/src/main/java/org/lflang/InferredType.java diff --git a/org.lflang/src/org/lflang/LFResourceDescriptionStrategy.java b/org.lflang/core/src/main/java/org/lflang/LFResourceDescriptionStrategy.java similarity index 100% rename from org.lflang/src/org/lflang/LFResourceDescriptionStrategy.java rename to org.lflang/core/src/main/java/org/lflang/LFResourceDescriptionStrategy.java diff --git a/org.lflang/src/org/lflang/LFResourceProvider.java b/org.lflang/core/src/main/java/org/lflang/LFResourceProvider.java similarity index 100% rename from org.lflang/src/org/lflang/LFResourceProvider.java rename to org.lflang/core/src/main/java/org/lflang/LFResourceProvider.java diff --git a/org.lflang/src/org/lflang/LFRuntimeModule.java b/org.lflang/core/src/main/java/org/lflang/LFRuntimeModule.java similarity index 100% rename from org.lflang/src/org/lflang/LFRuntimeModule.java rename to org.lflang/core/src/main/java/org/lflang/LFRuntimeModule.java diff --git a/org.lflang/src/org/lflang/LFStandaloneSetup.java b/org.lflang/core/src/main/java/org/lflang/LFStandaloneSetup.java similarity index 100% rename from org.lflang/src/org/lflang/LFStandaloneSetup.java rename to org.lflang/core/src/main/java/org/lflang/LFStandaloneSetup.java diff --git a/org.lflang/src/org/lflang/LFSyntaxErrorMessageProvider.java b/org.lflang/core/src/main/java/org/lflang/LFSyntaxErrorMessageProvider.java similarity index 100% rename from org.lflang/src/org/lflang/LFSyntaxErrorMessageProvider.java rename to org.lflang/core/src/main/java/org/lflang/LFSyntaxErrorMessageProvider.java diff --git a/org.lflang/src/org/lflang/LinguaFranca.xtext b/org.lflang/core/src/main/java/org/lflang/LinguaFranca.xtext similarity index 100% rename from org.lflang/src/org/lflang/LinguaFranca.xtext rename to org.lflang/core/src/main/java/org/lflang/LinguaFranca.xtext diff --git a/org.lflang/src/org/lflang/LocalStrings.java b/org.lflang/core/src/main/java/org/lflang/LocalStrings.java similarity index 100% rename from org.lflang/src/org/lflang/LocalStrings.java rename to org.lflang/core/src/main/java/org/lflang/LocalStrings.java diff --git a/org.lflang/src/org/lflang/MainConflictChecker.java b/org.lflang/core/src/main/java/org/lflang/MainConflictChecker.java similarity index 100% rename from org.lflang/src/org/lflang/MainConflictChecker.java rename to org.lflang/core/src/main/java/org/lflang/MainConflictChecker.java diff --git a/org.lflang/src/org/lflang/ModelInfo.java b/org.lflang/core/src/main/java/org/lflang/ModelInfo.java similarity index 100% rename from org.lflang/src/org/lflang/ModelInfo.java rename to org.lflang/core/src/main/java/org/lflang/ModelInfo.java diff --git a/org.lflang/src/org/lflang/StringsBundle.properties b/org.lflang/core/src/main/java/org/lflang/StringsBundle.properties similarity index 100% rename from org.lflang/src/org/lflang/StringsBundle.properties rename to org.lflang/core/src/main/java/org/lflang/StringsBundle.properties diff --git a/org.lflang/src/org/lflang/Target.java b/org.lflang/core/src/main/java/org/lflang/Target.java similarity index 100% rename from org.lflang/src/org/lflang/Target.java rename to org.lflang/core/src/main/java/org/lflang/Target.java diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/core/src/main/java/org/lflang/TargetConfig.java similarity index 100% rename from org.lflang/src/org/lflang/TargetConfig.java rename to org.lflang/core/src/main/java/org/lflang/TargetConfig.java diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/core/src/main/java/org/lflang/TargetProperty.java similarity index 100% rename from org.lflang/src/org/lflang/TargetProperty.java rename to org.lflang/core/src/main/java/org/lflang/TargetProperty.java diff --git a/org.lflang/src/org/lflang/TimeUnit.java b/org.lflang/core/src/main/java/org/lflang/TimeUnit.java similarity index 100% rename from org.lflang/src/org/lflang/TimeUnit.java rename to org.lflang/core/src/main/java/org/lflang/TimeUnit.java diff --git a/org.lflang/src/org/lflang/TimeValue.java b/org.lflang/core/src/main/java/org/lflang/TimeValue.java similarity index 100% rename from org.lflang/src/org/lflang/TimeValue.java rename to org.lflang/core/src/main/java/org/lflang/TimeValue.java diff --git a/org.lflang/src/org/lflang/ast/ASTUtils.java b/org.lflang/core/src/main/java/org/lflang/ast/ASTUtils.java similarity index 100% rename from org.lflang/src/org/lflang/ast/ASTUtils.java rename to org.lflang/core/src/main/java/org/lflang/ast/ASTUtils.java diff --git a/org.lflang/src/org/lflang/ast/AstExtensions.kt b/org.lflang/core/src/main/java/org/lflang/ast/AstExtensions.kt similarity index 100% rename from org.lflang/src/org/lflang/ast/AstExtensions.kt rename to org.lflang/core/src/main/java/org/lflang/ast/AstExtensions.kt diff --git a/org.lflang/src/org/lflang/ast/AstTransformation.java b/org.lflang/core/src/main/java/org/lflang/ast/AstTransformation.java similarity index 100% rename from org.lflang/src/org/lflang/ast/AstTransformation.java rename to org.lflang/core/src/main/java/org/lflang/ast/AstTransformation.java diff --git a/org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java b/org.lflang/core/src/main/java/org/lflang/ast/DelayedConnectionTransformation.java similarity index 100% rename from org.lflang/src/org/lflang/ast/DelayedConnectionTransformation.java rename to org.lflang/core/src/main/java/org/lflang/ast/DelayedConnectionTransformation.java diff --git a/org.lflang/src/org/lflang/ast/FormattingUtils.java b/org.lflang/core/src/main/java/org/lflang/ast/FormattingUtils.java similarity index 100% rename from org.lflang/src/org/lflang/ast/FormattingUtils.java rename to org.lflang/core/src/main/java/org/lflang/ast/FormattingUtils.java diff --git a/org.lflang/src/org/lflang/ast/IsEqual.java b/org.lflang/core/src/main/java/org/lflang/ast/IsEqual.java similarity index 100% rename from org.lflang/src/org/lflang/ast/IsEqual.java rename to org.lflang/core/src/main/java/org/lflang/ast/IsEqual.java diff --git a/org.lflang/src/org/lflang/ast/MalleableString.java b/org.lflang/core/src/main/java/org/lflang/ast/MalleableString.java similarity index 100% rename from org.lflang/src/org/lflang/ast/MalleableString.java rename to org.lflang/core/src/main/java/org/lflang/ast/MalleableString.java diff --git a/org.lflang/src/org/lflang/ast/ToLf.java b/org.lflang/core/src/main/java/org/lflang/ast/ToLf.java similarity index 100% rename from org.lflang/src/org/lflang/ast/ToLf.java rename to org.lflang/core/src/main/java/org/lflang/ast/ToLf.java diff --git a/org.lflang/src/org/lflang/ast/ToText.java b/org.lflang/core/src/main/java/org/lflang/ast/ToText.java similarity index 100% rename from org.lflang/src/org/lflang/ast/ToText.java rename to org.lflang/core/src/main/java/org/lflang/ast/ToText.java diff --git a/org.lflang/src/org/lflang/cli/CliBase.java b/org.lflang/core/src/main/java/org/lflang/cli/CliBase.java similarity index 100% rename from org.lflang/src/org/lflang/cli/CliBase.java rename to org.lflang/core/src/main/java/org/lflang/cli/CliBase.java diff --git a/org.lflang/src/org/lflang/cli/LFStandaloneModule.java b/org.lflang/core/src/main/java/org/lflang/cli/LFStandaloneModule.java similarity index 100% rename from org.lflang/src/org/lflang/cli/LFStandaloneModule.java rename to org.lflang/core/src/main/java/org/lflang/cli/LFStandaloneModule.java diff --git a/org.lflang/src/org/lflang/cli/Lff.java b/org.lflang/core/src/main/java/org/lflang/cli/Lff.java similarity index 100% rename from org.lflang/src/org/lflang/cli/Lff.java rename to org.lflang/core/src/main/java/org/lflang/cli/Lff.java diff --git a/org.lflang/src/org/lflang/cli/ReportingUtil.kt b/org.lflang/core/src/main/java/org/lflang/cli/ReportingUtil.kt similarity index 100% rename from org.lflang/src/org/lflang/cli/ReportingUtil.kt rename to org.lflang/core/src/main/java/org/lflang/cli/ReportingUtil.kt diff --git a/org.lflang/src/org/lflang/cli/StandaloneErrorReporter.java b/org.lflang/core/src/main/java/org/lflang/cli/StandaloneErrorReporter.java similarity index 100% rename from org.lflang/src/org/lflang/cli/StandaloneErrorReporter.java rename to org.lflang/core/src/main/java/org/lflang/cli/StandaloneErrorReporter.java diff --git a/org.lflang/src/org/lflang/cli/StandaloneIssueAcceptor.java b/org.lflang/core/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java similarity index 100% rename from org.lflang/src/org/lflang/cli/StandaloneIssueAcceptor.java rename to org.lflang/core/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java diff --git a/org.lflang/src/org/lflang/cli/VersionProvider.java b/org.lflang/core/src/main/java/org/lflang/cli/VersionProvider.java similarity index 100% rename from org.lflang/src/org/lflang/cli/VersionProvider.java rename to org.lflang/core/src/main/java/org/lflang/cli/VersionProvider.java diff --git a/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServer.java b/org.lflang/core/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/lsp/LFLanguageServer.java rename to org.lflang/core/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java diff --git a/org.lflang/src/org/lflang/diagram/lsp/LFLanguageServerExtension.java b/org.lflang/core/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/lsp/LFLanguageServerExtension.java rename to org.lflang/core/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java diff --git a/org.lflang/src/org/lflang/diagram/lsp/LanguageDiagramServer.java b/org.lflang/core/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/lsp/LanguageDiagramServer.java rename to org.lflang/core/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java diff --git a/org.lflang/src/org/lflang/diagram/lsp/Progress.java b/org.lflang/core/src/main/java/org/lflang/diagram/lsp/Progress.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/lsp/Progress.java rename to org.lflang/core/src/main/java/org/lflang/diagram/lsp/Progress.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/SynthesisRegistration.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/SynthesisRegistration.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/SynthesisRegistration.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/SynthesisRegistration.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/AbstractAction.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/AbstractAction.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/action/AbstractAction.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/AbstractAction.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/FilterCycleAction.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/FilterCycleAction.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/action/FilterCycleAction.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/FilterCycleAction.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/action/ShowCycleAction.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/ShowCycleAction.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/action/ShowCycleAction.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/ShowCycleAction.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/CycleVisualization.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/CycleVisualization.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/util/CycleVisualization.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/CycleVisualization.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/ModeDiagrams.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/ModeDiagrams.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/util/ModeDiagrams.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/ModeDiagrams.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/ReactorIcons.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/ReactorIcons.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/util/ReactorIcons.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/ReactorIcons.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java diff --git a/org.lflang/src/org/lflang/diagram/synthesis/util/UtilityExtensions.java b/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/UtilityExtensions.java similarity index 100% rename from org.lflang/src/org/lflang/diagram/synthesis/util/UtilityExtensions.java rename to org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/UtilityExtensions.java diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtension.java b/org.lflang/core/src/main/java/org/lflang/federated/extensions/CExtension.java similarity index 100% rename from org.lflang/src/org/lflang/federated/extensions/CExtension.java rename to org.lflang/core/src/main/java/org/lflang/federated/extensions/CExtension.java diff --git a/org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java b/org.lflang/core/src/main/java/org/lflang/federated/extensions/CExtensionUtils.java similarity index 100% rename from org.lflang/src/org/lflang/federated/extensions/CExtensionUtils.java rename to org.lflang/core/src/main/java/org/lflang/federated/extensions/CExtensionUtils.java diff --git a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java b/org.lflang/core/src/main/java/org/lflang/federated/extensions/FedTargetExtension.java similarity index 100% rename from org.lflang/src/org/lflang/federated/extensions/FedTargetExtension.java rename to org.lflang/core/src/main/java/org/lflang/federated/extensions/FedTargetExtension.java diff --git a/org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java b/org.lflang/core/src/main/java/org/lflang/federated/extensions/FedTargetExtensionFactory.java similarity index 100% rename from org.lflang/src/org/lflang/federated/extensions/FedTargetExtensionFactory.java rename to org.lflang/core/src/main/java/org/lflang/federated/extensions/FedTargetExtensionFactory.java diff --git a/org.lflang/src/org/lflang/federated/extensions/PythonExtension.java b/org.lflang/core/src/main/java/org/lflang/federated/extensions/PythonExtension.java similarity index 100% rename from org.lflang/src/org/lflang/federated/extensions/PythonExtension.java rename to org.lflang/core/src/main/java/org/lflang/federated/extensions/PythonExtension.java diff --git a/org.lflang/src/org/lflang/federated/extensions/TSExtension.java b/org.lflang/core/src/main/java/org/lflang/federated/extensions/TSExtension.java similarity index 100% rename from org.lflang/src/org/lflang/federated/extensions/TSExtension.java rename to org.lflang/core/src/main/java/org/lflang/federated/extensions/TSExtension.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedASTUtils.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedASTUtils.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedASTUtils.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedASTUtils.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedConnectionInstance.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedConnectionInstance.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedConnectionInstance.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedConnectionInstance.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedEmitter.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedEmitter.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedEmitter.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedEmitter.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedFileConfig.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedFileConfig.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedFileConfig.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedFileConfig.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedGenerator.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedGenerator.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedImportEmitter.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedImportEmitter.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedImportEmitter.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedMainEmitter.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedMainEmitter.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedMainEmitter.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedPreambleEmitter.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedPreambleEmitter.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedPreambleEmitter.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedReactorEmitter.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedReactorEmitter.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedReactorEmitter.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedTargetConfig.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedTargetConfig.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedTargetEmitter.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedTargetEmitter.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedTargetEmitter.java diff --git a/org.lflang/src/org/lflang/federated/generator/FedUtils.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FedUtils.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FedUtils.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FedUtils.java diff --git a/org.lflang/src/org/lflang/federated/generator/FederateInstance.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/FederateInstance.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/FederateInstance.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/FederateInstance.java diff --git a/org.lflang/src/org/lflang/federated/generator/LineAdjustingErrorReporter.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/LineAdjustingErrorReporter.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/LineAdjustingErrorReporter.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/LineAdjustingErrorReporter.java diff --git a/org.lflang/src/org/lflang/federated/generator/SynchronizedErrorReporter.java b/org.lflang/core/src/main/java/org/lflang/federated/generator/SynchronizedErrorReporter.java similarity index 100% rename from org.lflang/src/org/lflang/federated/generator/SynchronizedErrorReporter.java rename to org.lflang/core/src/main/java/org/lflang/federated/generator/SynchronizedErrorReporter.java diff --git a/org.lflang/src/org/lflang/federated/launcher/BuildConfig.java b/org.lflang/core/src/main/java/org/lflang/federated/launcher/BuildConfig.java similarity index 100% rename from org.lflang/src/org/lflang/federated/launcher/BuildConfig.java rename to org.lflang/core/src/main/java/org/lflang/federated/launcher/BuildConfig.java diff --git a/org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java b/org.lflang/core/src/main/java/org/lflang/federated/launcher/CBuildConfig.java similarity index 100% rename from org.lflang/src/org/lflang/federated/launcher/CBuildConfig.java rename to org.lflang/core/src/main/java/org/lflang/federated/launcher/CBuildConfig.java diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java b/org.lflang/core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java rename to org.lflang/core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java diff --git a/org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java b/org.lflang/core/src/main/java/org/lflang/federated/launcher/PyBuildConfig.java similarity index 100% rename from org.lflang/src/org/lflang/federated/launcher/PyBuildConfig.java rename to org.lflang/core/src/main/java/org/lflang/federated/launcher/PyBuildConfig.java diff --git a/org.lflang/src/org/lflang/federated/launcher/RtiConfig.java b/org.lflang/core/src/main/java/org/lflang/federated/launcher/RtiConfig.java similarity index 100% rename from org.lflang/src/org/lflang/federated/launcher/RtiConfig.java rename to org.lflang/core/src/main/java/org/lflang/federated/launcher/RtiConfig.java diff --git a/org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java b/org.lflang/core/src/main/java/org/lflang/federated/launcher/TsBuildConfig.java similarity index 100% rename from org.lflang/src/org/lflang/federated/launcher/TsBuildConfig.java rename to org.lflang/core/src/main/java/org/lflang/federated/launcher/TsBuildConfig.java diff --git a/org.lflang/src/org/lflang/federated/serialization/FedNativePythonSerialization.java b/org.lflang/core/src/main/java/org/lflang/federated/serialization/FedNativePythonSerialization.java similarity index 100% rename from org.lflang/src/org/lflang/federated/serialization/FedNativePythonSerialization.java rename to org.lflang/core/src/main/java/org/lflang/federated/serialization/FedNativePythonSerialization.java diff --git a/org.lflang/src/org/lflang/federated/serialization/FedROS2CPPSerialization.java b/org.lflang/core/src/main/java/org/lflang/federated/serialization/FedROS2CPPSerialization.java similarity index 100% rename from org.lflang/src/org/lflang/federated/serialization/FedROS2CPPSerialization.java rename to org.lflang/core/src/main/java/org/lflang/federated/serialization/FedROS2CPPSerialization.java diff --git a/org.lflang/src/org/lflang/federated/serialization/FedSerialization.java b/org.lflang/core/src/main/java/org/lflang/federated/serialization/FedSerialization.java similarity index 100% rename from org.lflang/src/org/lflang/federated/serialization/FedSerialization.java rename to org.lflang/core/src/main/java/org/lflang/federated/serialization/FedSerialization.java diff --git a/org.lflang/src/org/lflang/federated/serialization/SupportedSerializers.java b/org.lflang/core/src/main/java/org/lflang/federated/serialization/SupportedSerializers.java similarity index 100% rename from org.lflang/src/org/lflang/federated/serialization/SupportedSerializers.java rename to org.lflang/core/src/main/java/org/lflang/federated/serialization/SupportedSerializers.java diff --git a/org.lflang/src/org/lflang/federated/validation/FedValidator.java b/org.lflang/core/src/main/java/org/lflang/federated/validation/FedValidator.java similarity index 100% rename from org.lflang/src/org/lflang/federated/validation/FedValidator.java rename to org.lflang/core/src/main/java/org/lflang/federated/validation/FedValidator.java diff --git a/org.lflang/src/org/lflang/formatting2/LFFormatter.java b/org.lflang/core/src/main/java/org/lflang/formatting2/LFFormatter.java similarity index 100% rename from org.lflang/src/org/lflang/formatting2/LFFormatter.java rename to org.lflang/core/src/main/java/org/lflang/formatting2/LFFormatter.java diff --git a/org.lflang/src/org/lflang/generator/ActionInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/ActionInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ActionInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/ActionInstance.java diff --git a/org.lflang/src/org/lflang/generator/CodeBuilder.java b/org.lflang/core/src/main/java/org/lflang/generator/CodeBuilder.java similarity index 100% rename from org.lflang/src/org/lflang/generator/CodeBuilder.java rename to org.lflang/core/src/main/java/org/lflang/generator/CodeBuilder.java diff --git a/org.lflang/src/org/lflang/generator/CodeMap.java b/org.lflang/core/src/main/java/org/lflang/generator/CodeMap.java similarity index 100% rename from org.lflang/src/org/lflang/generator/CodeMap.java rename to org.lflang/core/src/main/java/org/lflang/generator/CodeMap.java diff --git a/org.lflang/src/org/lflang/generator/DeadlineInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/DeadlineInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/DeadlineInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/DeadlineInstance.java diff --git a/org.lflang/src/org/lflang/generator/DelayBodyGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/DelayBodyGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/DelayBodyGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/DelayBodyGenerator.java diff --git a/org.lflang/src/org/lflang/generator/DiagnosticReporting.java b/org.lflang/core/src/main/java/org/lflang/generator/DiagnosticReporting.java similarity index 100% rename from org.lflang/src/org/lflang/generator/DiagnosticReporting.java rename to org.lflang/core/src/main/java/org/lflang/generator/DiagnosticReporting.java diff --git a/org.lflang/src/org/lflang/generator/DockerComposeGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/DockerComposeGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/DockerComposeGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/DockerComposeGenerator.java diff --git a/org.lflang/src/org/lflang/generator/DockerData.java b/org.lflang/core/src/main/java/org/lflang/generator/DockerData.java similarity index 100% rename from org.lflang/src/org/lflang/generator/DockerData.java rename to org.lflang/core/src/main/java/org/lflang/generator/DockerData.java diff --git a/org.lflang/src/org/lflang/generator/DockerGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/DockerGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/DockerGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/DockerGenerator.java diff --git a/org.lflang/src/org/lflang/generator/FedDockerComposeGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/FedDockerComposeGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/FedDockerComposeGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/FedDockerComposeGenerator.java diff --git a/org.lflang/src/org/lflang/generator/GenerationException.java b/org.lflang/core/src/main/java/org/lflang/generator/GenerationException.java similarity index 100% rename from org.lflang/src/org/lflang/generator/GenerationException.java rename to org.lflang/core/src/main/java/org/lflang/generator/GenerationException.java diff --git a/org.lflang/src/org/lflang/generator/GeneratorBase.java b/org.lflang/core/src/main/java/org/lflang/generator/GeneratorBase.java similarity index 100% rename from org.lflang/src/org/lflang/generator/GeneratorBase.java rename to org.lflang/core/src/main/java/org/lflang/generator/GeneratorBase.java diff --git a/org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java b/org.lflang/core/src/main/java/org/lflang/generator/GeneratorCommandFactory.java similarity index 100% rename from org.lflang/src/org/lflang/generator/GeneratorCommandFactory.java rename to org.lflang/core/src/main/java/org/lflang/generator/GeneratorCommandFactory.java diff --git a/org.lflang/src/org/lflang/generator/GeneratorExtensions.kt b/org.lflang/core/src/main/java/org/lflang/generator/GeneratorExtensions.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/GeneratorExtensions.kt rename to org.lflang/core/src/main/java/org/lflang/generator/GeneratorExtensions.kt diff --git a/org.lflang/src/org/lflang/generator/GeneratorResult.java b/org.lflang/core/src/main/java/org/lflang/generator/GeneratorResult.java similarity index 100% rename from org.lflang/src/org/lflang/generator/GeneratorResult.java rename to org.lflang/core/src/main/java/org/lflang/generator/GeneratorResult.java diff --git a/org.lflang/src/org/lflang/generator/GeneratorUtils.java b/org.lflang/core/src/main/java/org/lflang/generator/GeneratorUtils.java similarity index 100% rename from org.lflang/src/org/lflang/generator/GeneratorUtils.java rename to org.lflang/core/src/main/java/org/lflang/generator/GeneratorUtils.java diff --git a/org.lflang/src/org/lflang/generator/GeneratorUtils.kt b/org.lflang/core/src/main/java/org/lflang/generator/GeneratorUtils.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/GeneratorUtils.kt rename to org.lflang/core/src/main/java/org/lflang/generator/GeneratorUtils.kt diff --git a/org.lflang/src/org/lflang/generator/HumanReadableReportingStrategy.java b/org.lflang/core/src/main/java/org/lflang/generator/HumanReadableReportingStrategy.java similarity index 100% rename from org.lflang/src/org/lflang/generator/HumanReadableReportingStrategy.java rename to org.lflang/core/src/main/java/org/lflang/generator/HumanReadableReportingStrategy.java diff --git a/org.lflang/src/org/lflang/generator/IntegratedBuilder.java b/org.lflang/core/src/main/java/org/lflang/generator/IntegratedBuilder.java similarity index 100% rename from org.lflang/src/org/lflang/generator/IntegratedBuilder.java rename to org.lflang/core/src/main/java/org/lflang/generator/IntegratedBuilder.java diff --git a/org.lflang/src/org/lflang/generator/InvalidLfSourceException.java b/org.lflang/core/src/main/java/org/lflang/generator/InvalidLfSourceException.java similarity index 100% rename from org.lflang/src/org/lflang/generator/InvalidLfSourceException.java rename to org.lflang/core/src/main/java/org/lflang/generator/InvalidLfSourceException.java diff --git a/org.lflang/src/org/lflang/generator/InvalidSourceException.java b/org.lflang/core/src/main/java/org/lflang/generator/InvalidSourceException.java similarity index 100% rename from org.lflang/src/org/lflang/generator/InvalidSourceException.java rename to org.lflang/core/src/main/java/org/lflang/generator/InvalidSourceException.java diff --git a/org.lflang/src/org/lflang/generator/LFGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/LFGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/LFGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/LFGenerator.java diff --git a/org.lflang/src/org/lflang/generator/LFGeneratorContext.java b/org.lflang/core/src/main/java/org/lflang/generator/LFGeneratorContext.java similarity index 100% rename from org.lflang/src/org/lflang/generator/LFGeneratorContext.java rename to org.lflang/core/src/main/java/org/lflang/generator/LFGeneratorContext.java diff --git a/org.lflang/src/org/lflang/generator/LFResource.java b/org.lflang/core/src/main/java/org/lflang/generator/LFResource.java similarity index 100% rename from org.lflang/src/org/lflang/generator/LFResource.java rename to org.lflang/core/src/main/java/org/lflang/generator/LFResource.java diff --git a/org.lflang/src/org/lflang/generator/LanguageRuntimeVersions.kt b/org.lflang/core/src/main/java/org/lflang/generator/LanguageRuntimeVersions.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/LanguageRuntimeVersions.kt rename to org.lflang/core/src/main/java/org/lflang/generator/LanguageRuntimeVersions.kt diff --git a/org.lflang/src/org/lflang/generator/LanguageServerErrorReporter.java b/org.lflang/core/src/main/java/org/lflang/generator/LanguageServerErrorReporter.java similarity index 100% rename from org.lflang/src/org/lflang/generator/LanguageServerErrorReporter.java rename to org.lflang/core/src/main/java/org/lflang/generator/LanguageServerErrorReporter.java diff --git a/org.lflang/src/org/lflang/generator/LfExpressionVisitor.java b/org.lflang/core/src/main/java/org/lflang/generator/LfExpressionVisitor.java similarity index 100% rename from org.lflang/src/org/lflang/generator/LfExpressionVisitor.java rename to org.lflang/core/src/main/java/org/lflang/generator/LfExpressionVisitor.java diff --git a/org.lflang/src/org/lflang/generator/MainContext.java b/org.lflang/core/src/main/java/org/lflang/generator/MainContext.java similarity index 100% rename from org.lflang/src/org/lflang/generator/MainContext.java rename to org.lflang/core/src/main/java/org/lflang/generator/MainContext.java diff --git a/org.lflang/src/org/lflang/generator/MixedRadixInt.java b/org.lflang/core/src/main/java/org/lflang/generator/MixedRadixInt.java similarity index 100% rename from org.lflang/src/org/lflang/generator/MixedRadixInt.java rename to org.lflang/core/src/main/java/org/lflang/generator/MixedRadixInt.java diff --git a/org.lflang/src/org/lflang/generator/ModeInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/ModeInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ModeInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/ModeInstance.java diff --git a/org.lflang/src/org/lflang/generator/NamedInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/NamedInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/NamedInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/NamedInstance.java diff --git a/org.lflang/src/org/lflang/generator/ParameterInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/ParameterInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ParameterInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/ParameterInstance.java diff --git a/org.lflang/src/org/lflang/generator/PortInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/PortInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/PortInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/PortInstance.java diff --git a/org.lflang/src/org/lflang/generator/Position.java b/org.lflang/core/src/main/java/org/lflang/generator/Position.java similarity index 100% rename from org.lflang/src/org/lflang/generator/Position.java rename to org.lflang/core/src/main/java/org/lflang/generator/Position.java diff --git a/org.lflang/src/org/lflang/generator/Range.java b/org.lflang/core/src/main/java/org/lflang/generator/Range.java similarity index 100% rename from org.lflang/src/org/lflang/generator/Range.java rename to org.lflang/core/src/main/java/org/lflang/generator/Range.java diff --git a/org.lflang/src/org/lflang/generator/ReactionInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/ReactionInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ReactionInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/ReactionInstance.java diff --git a/org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java b/org.lflang/core/src/main/java/org/lflang/generator/ReactionInstanceGraph.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java rename to org.lflang/core/src/main/java/org/lflang/generator/ReactionInstanceGraph.java diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/ReactorInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ReactorInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/ReactorInstance.java diff --git a/org.lflang/src/org/lflang/generator/RuntimeRange.java b/org.lflang/core/src/main/java/org/lflang/generator/RuntimeRange.java similarity index 100% rename from org.lflang/src/org/lflang/generator/RuntimeRange.java rename to org.lflang/core/src/main/java/org/lflang/generator/RuntimeRange.java diff --git a/org.lflang/src/org/lflang/generator/SendRange.java b/org.lflang/core/src/main/java/org/lflang/generator/SendRange.java similarity index 100% rename from org.lflang/src/org/lflang/generator/SendRange.java rename to org.lflang/core/src/main/java/org/lflang/generator/SendRange.java diff --git a/org.lflang/src/org/lflang/generator/SubContext.java b/org.lflang/core/src/main/java/org/lflang/generator/SubContext.java similarity index 100% rename from org.lflang/src/org/lflang/generator/SubContext.java rename to org.lflang/core/src/main/java/org/lflang/generator/SubContext.java diff --git a/org.lflang/src/org/lflang/generator/TargetTypes.java b/org.lflang/core/src/main/java/org/lflang/generator/TargetTypes.java similarity index 100% rename from org.lflang/src/org/lflang/generator/TargetTypes.java rename to org.lflang/core/src/main/java/org/lflang/generator/TargetTypes.java diff --git a/org.lflang/src/org/lflang/generator/TimerInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/TimerInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/TimerInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/TimerInstance.java diff --git a/org.lflang/src/org/lflang/generator/TriggerInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/TriggerInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/TriggerInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/TriggerInstance.java diff --git a/org.lflang/src/org/lflang/generator/UnsupportedGeneratorFeatureException.java b/org.lflang/core/src/main/java/org/lflang/generator/UnsupportedGeneratorFeatureException.java similarity index 100% rename from org.lflang/src/org/lflang/generator/UnsupportedGeneratorFeatureException.java rename to org.lflang/core/src/main/java/org/lflang/generator/UnsupportedGeneratorFeatureException.java diff --git a/org.lflang/src/org/lflang/generator/ValidationStrategy.java b/org.lflang/core/src/main/java/org/lflang/generator/ValidationStrategy.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ValidationStrategy.java rename to org.lflang/core/src/main/java/org/lflang/generator/ValidationStrategy.java diff --git a/org.lflang/src/org/lflang/generator/Validator.java b/org.lflang/core/src/main/java/org/lflang/generator/Validator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/Validator.java rename to org.lflang/core/src/main/java/org/lflang/generator/Validator.java diff --git a/org.lflang/src/org/lflang/generator/WatchdogInstance.java b/org.lflang/core/src/main/java/org/lflang/generator/WatchdogInstance.java similarity index 100% rename from org.lflang/src/org/lflang/generator/WatchdogInstance.java rename to org.lflang/core/src/main/java/org/lflang/generator/WatchdogInstance.java diff --git a/org.lflang/src/org/lflang/generator/c/CActionGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CActionGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CActionGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CActionGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CCmakeGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CCompiler.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CCompiler.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CCompiler.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CCompiler.java diff --git a/org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CConstructorGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CConstructorGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CConstructorGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CCoreFilesUtils.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CCoreFilesUtils.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CCoreFilesUtils.java diff --git a/org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CDelayBodyGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CDelayBodyGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CDelayBodyGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CDockerGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CDockerGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CDockerGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CDockerGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CFileConfig.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CFileConfig.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CFileConfig.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CFileConfig.java diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CMainFunctionGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CMainFunctionGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CMainFunctionGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CMethodGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CMethodGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CMethodGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CMethodGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CMixedRadixGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CMixedRadixGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CMixedRadixGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CMixedRadixGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CModesGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CModesGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CModesGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CModesGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CParameterGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CParameterGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CParameterGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CParameterGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CPortGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CPortGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CPortGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CPortGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CPreambleGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CPreambleGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CPreambleGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CReactionGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CReactionGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CReactionGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CReactorHeaderFileGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CReactorHeaderFileGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CStateGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CStateGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CStateGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CStateGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CTimerGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CTimerGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CTimerGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CTimerGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CTracingGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CTracingGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CTracingGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CTracingGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CTriggerObjectsGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CTriggerObjectsGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/CTypes.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CTypes.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CTypes.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CTypes.java diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CUtil.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CUtil.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CUtil.java diff --git a/org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/c/CWatchdogGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/CWatchdogGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/CWatchdogGenerator.java diff --git a/org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java b/org.lflang/core/src/main/java/org/lflang/generator/c/InteractingContainedReactors.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/InteractingContainedReactors.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/InteractingContainedReactors.java diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java similarity index 100% rename from org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java rename to org.lflang/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java diff --git a/org.lflang/src/org/lflang/generator/cpp/CppActionGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppActionGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppActionGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppActionGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppConnectionGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppConnectionGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppExtensions.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppExtensions.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppFileConfig.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppFileConfig.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppFileConfig.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppFileConfig.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppInstanceGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppInstanceGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppInstanceGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppMethodGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppMethodGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppMethodGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppMethodGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppParameterGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppParameterGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppParameterGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppParameterGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppPlatformGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPlatformGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppPlatformGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPlatformGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPortGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPortGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppPreambleGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPreambleGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppPreambleGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPreambleGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppReactionGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppReactionGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppReactionGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppReactorGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppReactorGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppRos2Generator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2Generator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppRos2Generator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2Generator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppRos2NodeGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2NodeGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppRos2NodeGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2NodeGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppRos2PackageGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2PackageGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppRos2PackageGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2PackageGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppStandaloneGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppStandaloneGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppStateGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStateGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppStateGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStateGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppTimerGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppTimerGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppTimerGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppTimerGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppTypes.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppTypes.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppTypes.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppTypes.kt diff --git a/org.lflang/src/org/lflang/generator/cpp/CppValidator.kt b/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppValidator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/cpp/CppValidator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/cpp/CppValidator.kt diff --git a/org.lflang/src/org/lflang/generator/python/PyFileConfig.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PyFileConfig.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PyFileConfig.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PyFileConfig.java diff --git a/org.lflang/src/org/lflang/generator/python/PyUtil.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PyUtil.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PyUtil.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PyUtil.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonActionGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonActionGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonActionGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonDelayBodyGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonDelayBodyGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonDelayBodyGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonDockerGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonDockerGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonDockerGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonDockerGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonInfoGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonInfoGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonInfoGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonInfoGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonMainFunctionGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonMainFunctionGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonMainFunctionGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonMainFunctionGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonMethodGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonMethodGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonMethodGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonModeGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonModeGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonModeGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonParameterGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonParameterGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonParameterGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonPortGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonPortGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonPortGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonPreambleGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonPreambleGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonPreambleGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonReactionGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonReactionGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonReactionGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonReactorGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonReactorGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonReactorGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonStateGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonStateGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonStateGenerator.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonTypes.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonTypes.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonTypes.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonTypes.java diff --git a/org.lflang/src/org/lflang/generator/python/PythonValidator.java b/org.lflang/core/src/main/java/org/lflang/generator/python/PythonValidator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/python/PythonValidator.java rename to org.lflang/core/src/main/java/org/lflang/generator/python/PythonValidator.java diff --git a/org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java b/org.lflang/core/src/main/java/org/lflang/generator/rust/CargoDependencySpec.java similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/CargoDependencySpec.java rename to org.lflang/core/src/main/java/org/lflang/generator/rust/CargoDependencySpec.java diff --git a/org.lflang/src/org/lflang/generator/rust/PortEmitter.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/PortEmitter.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/PortEmitter.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/PortEmitter.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustCargoTomlEmitter.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustCargoTomlEmitter.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustCargoTomlEmitter.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustCargoTomlEmitter.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustEmitter.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustEmitter.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustEmitter.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustEmitter.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustEmitterBase.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustEmitterBase.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustEmitterBase.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustEmitterBase.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustFileConfig.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustFileConfig.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustFileConfig.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustFileConfig.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustMainFileEmitter.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustMainFileEmitter.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustMainFileEmitter.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustMainFileEmitter.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustModel.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustModel.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustModel.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustModel.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustReactorEmitter.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustReactorEmitter.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustReactorEmitter.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustReactorEmitter.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustTargetConfig.java b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustTargetConfig.java similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustTargetConfig.java rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustTargetConfig.java diff --git a/org.lflang/src/org/lflang/generator/rust/RustTypes.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustTypes.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustTypes.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustTypes.kt diff --git a/org.lflang/src/org/lflang/generator/rust/RustValidator.kt b/org.lflang/core/src/main/java/org/lflang/generator/rust/RustValidator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/rust/RustValidator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/rust/RustValidator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSActionGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSActionGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSActionGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSActionGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSConnectionGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSConnectionGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSConnectionGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSConnectionGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSConstructorGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSConstructorGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSConstructorGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSDelayBodyGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSDelayBodyGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSDelayBodyGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSDockerGenerator.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSDockerGenerator.java rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSDockerGenerator.java diff --git a/org.lflang/src/org/lflang/generator/ts/TSExtensions.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSExtensions.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSExtensions.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSExtensions.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSFileConfig.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSFileConfig.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSFileConfig.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSFileConfig.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSImportPreambleGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSImportPreambleGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSImportPreambleGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSImportPreambleGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSInstanceGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSInstanceGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSInstanceGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSInstanceGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSParameterGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSParameterGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSParameterGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSParameterGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSParameterPreambleGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSParameterPreambleGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSParameterPreambleGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSParameterPreambleGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSPortGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSPortGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSPortGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSPortGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSReactionGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSReactionGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSReactionGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSReactorGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSReactorGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSReactorGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSReactorGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSStateGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSStateGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSStateGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSTimerGenerator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSTimerGenerator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSTimerGenerator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSTimerGenerator.kt diff --git a/org.lflang/src/org/lflang/generator/ts/TSTypes.java b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSTypes.java similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSTypes.java rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSTypes.java diff --git a/org.lflang/src/org/lflang/generator/ts/TSValidator.kt b/org.lflang/core/src/main/java/org/lflang/generator/ts/TSValidator.kt similarity index 100% rename from org.lflang/src/org/lflang/generator/ts/TSValidator.kt rename to org.lflang/core/src/main/java/org/lflang/generator/ts/TSValidator.kt diff --git a/org.lflang/src/org/lflang/graph/DirectedGraph.java b/org.lflang/core/src/main/java/org/lflang/graph/DirectedGraph.java similarity index 100% rename from org.lflang/src/org/lflang/graph/DirectedGraph.java rename to org.lflang/core/src/main/java/org/lflang/graph/DirectedGraph.java diff --git a/org.lflang/src/org/lflang/graph/Graph.java b/org.lflang/core/src/main/java/org/lflang/graph/Graph.java similarity index 100% rename from org.lflang/src/org/lflang/graph/Graph.java rename to org.lflang/core/src/main/java/org/lflang/graph/Graph.java diff --git a/org.lflang/src/org/lflang/graph/InstantiationGraph.java b/org.lflang/core/src/main/java/org/lflang/graph/InstantiationGraph.java similarity index 100% rename from org.lflang/src/org/lflang/graph/InstantiationGraph.java rename to org.lflang/core/src/main/java/org/lflang/graph/InstantiationGraph.java diff --git a/org.lflang/src/org/lflang/graph/NodeAnnotation.java b/org.lflang/core/src/main/java/org/lflang/graph/NodeAnnotation.java similarity index 100% rename from org.lflang/src/org/lflang/graph/NodeAnnotation.java rename to org.lflang/core/src/main/java/org/lflang/graph/NodeAnnotation.java diff --git a/org.lflang/src/org/lflang/graph/NodeAnnotations.java b/org.lflang/core/src/main/java/org/lflang/graph/NodeAnnotations.java similarity index 100% rename from org.lflang/src/org/lflang/graph/NodeAnnotations.java rename to org.lflang/core/src/main/java/org/lflang/graph/NodeAnnotations.java diff --git a/org.lflang/src/org/lflang/graph/PrecedenceGraph.java b/org.lflang/core/src/main/java/org/lflang/graph/PrecedenceGraph.java similarity index 100% rename from org.lflang/src/org/lflang/graph/PrecedenceGraph.java rename to org.lflang/core/src/main/java/org/lflang/graph/PrecedenceGraph.java diff --git a/org.lflang/src/org/lflang/graph/TopologyGraph.java b/org.lflang/core/src/main/java/org/lflang/graph/TopologyGraph.java similarity index 100% rename from org.lflang/src/org/lflang/graph/TopologyGraph.java rename to org.lflang/core/src/main/java/org/lflang/graph/TopologyGraph.java diff --git a/org.lflang/src/org/lflang/ide/LFIdeModule.java b/org.lflang/core/src/main/java/org/lflang/ide/LFIdeModule.java similarity index 100% rename from org.lflang/src/org/lflang/ide/LFIdeModule.java rename to org.lflang/core/src/main/java/org/lflang/ide/LFIdeModule.java diff --git a/org.lflang/src/org/lflang/ide/LFIdeSetup.java b/org.lflang/core/src/main/java/org/lflang/ide/LFIdeSetup.java similarity index 100% rename from org.lflang/src/org/lflang/ide/LFIdeSetup.java rename to org.lflang/core/src/main/java/org/lflang/ide/LFIdeSetup.java diff --git a/org.lflang/src/org/lflang/scoping/LFGlobalScopeProvider.java b/org.lflang/core/src/main/java/org/lflang/scoping/LFGlobalScopeProvider.java similarity index 100% rename from org.lflang/src/org/lflang/scoping/LFGlobalScopeProvider.java rename to org.lflang/core/src/main/java/org/lflang/scoping/LFGlobalScopeProvider.java diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProvider.java b/org.lflang/core/src/main/java/org/lflang/scoping/LFScopeProvider.java similarity index 100% rename from org.lflang/src/org/lflang/scoping/LFScopeProvider.java rename to org.lflang/core/src/main/java/org/lflang/scoping/LFScopeProvider.java diff --git a/org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java b/org.lflang/core/src/main/java/org/lflang/scoping/LFScopeProviderImpl.java similarity index 100% rename from org.lflang/src/org/lflang/scoping/LFScopeProviderImpl.java rename to org.lflang/core/src/main/java/org/lflang/scoping/LFScopeProviderImpl.java diff --git a/org.lflang/src/org/lflang/util/ArduinoUtil.java b/org.lflang/core/src/main/java/org/lflang/util/ArduinoUtil.java similarity index 100% rename from org.lflang/src/org/lflang/util/ArduinoUtil.java rename to org.lflang/core/src/main/java/org/lflang/util/ArduinoUtil.java diff --git a/org.lflang/src/org/lflang/util/Averager.java b/org.lflang/core/src/main/java/org/lflang/util/Averager.java similarity index 100% rename from org.lflang/src/org/lflang/util/Averager.java rename to org.lflang/core/src/main/java/org/lflang/util/Averager.java diff --git a/org.lflang/src/org/lflang/util/CollectionUtil.java b/org.lflang/core/src/main/java/org/lflang/util/CollectionUtil.java similarity index 100% rename from org.lflang/src/org/lflang/util/CollectionUtil.java rename to org.lflang/core/src/main/java/org/lflang/util/CollectionUtil.java diff --git a/org.lflang/src/org/lflang/util/FileUtil.java b/org.lflang/core/src/main/java/org/lflang/util/FileUtil.java similarity index 100% rename from org.lflang/src/org/lflang/util/FileUtil.java rename to org.lflang/core/src/main/java/org/lflang/util/FileUtil.java diff --git a/org.lflang/src/org/lflang/util/IteratorUtil.java b/org.lflang/core/src/main/java/org/lflang/util/IteratorUtil.java similarity index 100% rename from org.lflang/src/org/lflang/util/IteratorUtil.java rename to org.lflang/core/src/main/java/org/lflang/util/IteratorUtil.java diff --git a/org.lflang/src/org/lflang/util/LFCommand.java b/org.lflang/core/src/main/java/org/lflang/util/LFCommand.java similarity index 100% rename from org.lflang/src/org/lflang/util/LFCommand.java rename to org.lflang/core/src/main/java/org/lflang/util/LFCommand.java diff --git a/org.lflang/src/org/lflang/util/StringUtil.java b/org.lflang/core/src/main/java/org/lflang/util/StringUtil.java similarity index 100% rename from org.lflang/src/org/lflang/util/StringUtil.java rename to org.lflang/core/src/main/java/org/lflang/util/StringUtil.java diff --git a/org.lflang/src/org/lflang/util/TargetResourceNotFoundException.java b/org.lflang/core/src/main/java/org/lflang/util/TargetResourceNotFoundException.java similarity index 100% rename from org.lflang/src/org/lflang/util/TargetResourceNotFoundException.java rename to org.lflang/core/src/main/java/org/lflang/util/TargetResourceNotFoundException.java diff --git a/org.lflang/src/org/lflang/validation/AttributeSpec.java b/org.lflang/core/src/main/java/org/lflang/validation/AttributeSpec.java similarity index 100% rename from org.lflang/src/org/lflang/validation/AttributeSpec.java rename to org.lflang/core/src/main/java/org/lflang/validation/AttributeSpec.java diff --git a/org.lflang/src/org/lflang/validation/BaseLFValidator.java b/org.lflang/core/src/main/java/org/lflang/validation/BaseLFValidator.java similarity index 100% rename from org.lflang/src/org/lflang/validation/BaseLFValidator.java rename to org.lflang/core/src/main/java/org/lflang/validation/BaseLFValidator.java diff --git a/org.lflang/src/org/lflang/validation/LFNamesAreUniqueValidationHelper.java b/org.lflang/core/src/main/java/org/lflang/validation/LFNamesAreUniqueValidationHelper.java similarity index 100% rename from org.lflang/src/org/lflang/validation/LFNamesAreUniqueValidationHelper.java rename to org.lflang/core/src/main/java/org/lflang/validation/LFNamesAreUniqueValidationHelper.java diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/core/src/main/java/org/lflang/validation/LFValidator.java similarity index 100% rename from org.lflang/src/org/lflang/validation/LFValidator.java rename to org.lflang/core/src/main/java/org/lflang/validation/LFValidator.java diff --git a/org.lflang/src/org/lflang/validation/ValidatorErrorReporter.java b/org.lflang/core/src/main/java/org/lflang/validation/ValidatorErrorReporter.java similarity index 100% rename from org.lflang/src/org/lflang/validation/ValidatorErrorReporter.java rename to org.lflang/core/src/main/java/org/lflang/validation/ValidatorErrorReporter.java diff --git a/settings.gradle b/settings.gradle index 94d44e8d96..8bfc40a9e1 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,4 +1,4 @@ rootProject.name = 'org.lflang' -include('org.lflang', 'lfc') +include(':org.lflang:core', 'lfc') From e715f412ae7c5551e77909fb1d547f86161a163f Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 11:28:39 +0200 Subject: [PATCH 480/709] separate kotlin files --- org.lflang/core/build.gradle | 3 --- .../src/main/{java => kotlin}/org/lflang/CommonExtensions.kt | 0 .../main/{java => kotlin}/org/lflang/FileConfigExtensions.kt | 0 .../src/main/{java => kotlin}/org/lflang/ast/AstExtensions.kt | 0 .../src/main/{java => kotlin}/org/lflang/cli/ReportingUtil.kt | 0 .../org/lflang/generator/GeneratorExtensions.kt | 0 .../{java => kotlin}/org/lflang/generator/GeneratorUtils.kt | 0 .../org/lflang/generator/LanguageRuntimeVersions.kt | 0 .../org/lflang/generator/cpp/CppActionGenerator.kt | 0 .../org/lflang/generator/cpp/CppAssembleMethodGenerator.kt | 0 .../org/lflang/generator/cpp/CppConnectionGenerator.kt | 0 .../{java => kotlin}/org/lflang/generator/cpp/CppExtensions.kt | 0 .../{java => kotlin}/org/lflang/generator/cpp/CppFileConfig.kt | 0 .../{java => kotlin}/org/lflang/generator/cpp/CppGenerator.kt | 0 .../org/lflang/generator/cpp/CppInstanceGenerator.kt | 0 .../org/lflang/generator/cpp/CppMethodGenerator.kt | 0 .../org/lflang/generator/cpp/CppParameterGenerator.kt | 0 .../org/lflang/generator/cpp/CppPlatformGenerator.kt | 0 .../org/lflang/generator/cpp/CppPortGenerator.kt | 0 .../org/lflang/generator/cpp/CppPreambleGenerator.kt | 0 .../org/lflang/generator/cpp/CppReactionGenerator.kt | 0 .../org/lflang/generator/cpp/CppReactorGenerator.kt | 0 .../org/lflang/generator/cpp/CppRos2Generator.kt | 0 .../org/lflang/generator/cpp/CppRos2NodeGenerator.kt | 0 .../org/lflang/generator/cpp/CppRos2PackageGenerator.kt | 0 .../org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt | 0 .../org/lflang/generator/cpp/CppStandaloneGenerator.kt | 0 .../org/lflang/generator/cpp/CppStandaloneMainGenerator.kt | 0 .../org/lflang/generator/cpp/CppStateGenerator.kt | 0 .../org/lflang/generator/cpp/CppTimerGenerator.kt | 0 .../main/{java => kotlin}/org/lflang/generator/cpp/CppTypes.kt | 0 .../{java => kotlin}/org/lflang/generator/cpp/CppValidator.kt | 0 .../{java => kotlin}/org/lflang/generator/rust/PortEmitter.kt | 0 .../org/lflang/generator/rust/RustCargoTomlEmitter.kt | 0 .../{java => kotlin}/org/lflang/generator/rust/RustEmitter.kt | 0 .../org/lflang/generator/rust/RustEmitterBase.kt | 0 .../org/lflang/generator/rust/RustFileConfig.kt | 0 .../org/lflang/generator/rust/RustGenerator.kt | 0 .../org/lflang/generator/rust/RustMainFileEmitter.kt | 0 .../{java => kotlin}/org/lflang/generator/rust/RustModel.kt | 0 .../org/lflang/generator/rust/RustReactorEmitter.kt | 0 .../{java => kotlin}/org/lflang/generator/rust/RustTypes.kt | 0 .../org/lflang/generator/rust/RustValidator.kt | 0 .../org/lflang/generator/ts/TSActionGenerator.kt | 0 .../org/lflang/generator/ts/TSConnectionGenerator.kt | 0 .../org/lflang/generator/ts/TSConstructorGenerator.kt | 0 .../org/lflang/generator/ts/TSDelayBodyGenerator.kt | 0 .../{java => kotlin}/org/lflang/generator/ts/TSExtensions.kt | 0 .../{java => kotlin}/org/lflang/generator/ts/TSFileConfig.kt | 0 .../{java => kotlin}/org/lflang/generator/ts/TSGenerator.kt | 0 .../org/lflang/generator/ts/TSImportPreambleGenerator.kt | 0 .../org/lflang/generator/ts/TSInstanceGenerator.kt | 0 .../org/lflang/generator/ts/TSParameterGenerator.kt | 0 .../org/lflang/generator/ts/TSParameterPreambleGenerator.kt | 0 .../org/lflang/generator/ts/TSPortGenerator.kt | 0 .../org/lflang/generator/ts/TSReactionGenerator.kt | 0 .../org/lflang/generator/ts/TSReactorGenerator.kt | 0 .../org/lflang/generator/ts/TSStateGenerator.kt | 0 .../org/lflang/generator/ts/TSTimerGenerator.kt | 0 .../{java => kotlin}/org/lflang/generator/ts/TSValidator.kt | 0 60 files changed, 3 deletions(-) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/CommonExtensions.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/FileConfigExtensions.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/ast/AstExtensions.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/cli/ReportingUtil.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/GeneratorExtensions.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/GeneratorUtils.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/LanguageRuntimeVersions.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppActionGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppConnectionGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppExtensions.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppFileConfig.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppInstanceGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppMethodGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppParameterGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppPlatformGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppPortGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppPreambleGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppReactionGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppReactorGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppRos2Generator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppRos2NodeGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppRos2PackageGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppStandaloneGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppStateGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppTimerGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppTypes.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/cpp/CppValidator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/PortEmitter.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustCargoTomlEmitter.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustEmitter.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustEmitterBase.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustFileConfig.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustMainFileEmitter.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustModel.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustReactorEmitter.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustTypes.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/rust/RustValidator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSActionGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSConnectionGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSConstructorGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSDelayBodyGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSExtensions.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSFileConfig.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSImportPreambleGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSInstanceGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSParameterGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSParameterPreambleGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSPortGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSReactionGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSReactorGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSStateGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSTimerGenerator.kt (100%) rename org.lflang/core/src/main/{java => kotlin}/org/lflang/generator/ts/TSValidator.kt (100%) diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index 92d4fb02aa..8a5a487299 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -8,9 +8,6 @@ sourceSets { java { srcDirs = ['src/main/java', 'src-gen'] } - kotlin { - srcDirs = ['src/main/java', 'src-gen'] - } resources { srcDirs = ['src-gen', '../src/'] include 'lib/' diff --git a/org.lflang/core/src/main/java/org/lflang/CommonExtensions.kt b/org.lflang/core/src/main/kotlin/org/lflang/CommonExtensions.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/CommonExtensions.kt rename to org.lflang/core/src/main/kotlin/org/lflang/CommonExtensions.kt diff --git a/org.lflang/core/src/main/java/org/lflang/FileConfigExtensions.kt b/org.lflang/core/src/main/kotlin/org/lflang/FileConfigExtensions.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/FileConfigExtensions.kt rename to org.lflang/core/src/main/kotlin/org/lflang/FileConfigExtensions.kt diff --git a/org.lflang/core/src/main/java/org/lflang/ast/AstExtensions.kt b/org.lflang/core/src/main/kotlin/org/lflang/ast/AstExtensions.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/AstExtensions.kt rename to org.lflang/core/src/main/kotlin/org/lflang/ast/AstExtensions.kt diff --git a/org.lflang/core/src/main/java/org/lflang/cli/ReportingUtil.kt b/org.lflang/core/src/main/kotlin/org/lflang/cli/ReportingUtil.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/cli/ReportingUtil.kt rename to org.lflang/core/src/main/kotlin/org/lflang/cli/ReportingUtil.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/GeneratorExtensions.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/GeneratorExtensions.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/GeneratorExtensions.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/GeneratorExtensions.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/GeneratorUtils.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/GeneratorUtils.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/GeneratorUtils.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/GeneratorUtils.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/LanguageRuntimeVersions.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/LanguageRuntimeVersions.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/LanguageRuntimeVersions.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/LanguageRuntimeVersions.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppActionGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppActionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppActionGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppActionGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppConnectionGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppConnectionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppConnectionGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppConnectionGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppExtensions.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppExtensions.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppExtensions.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppExtensions.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppFileConfig.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppFileConfig.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppFileConfig.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppFileConfig.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppInstanceGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppInstanceGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppInstanceGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppInstanceGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppMethodGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppMethodGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppMethodGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppMethodGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppParameterGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppParameterGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppParameterGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppParameterGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPlatformGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPlatformGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPlatformGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPlatformGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPortGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPortGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPortGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPortGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPreambleGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPreambleGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppPreambleGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPreambleGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppReactionGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppReactionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppReactionGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppReactionGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppReactorGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppReactorGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppReactorGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppReactorGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2Generator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2Generator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2Generator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2Generator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2NodeGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2NodeGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2NodeGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2NodeGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2PackageGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2PackageGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppRos2PackageGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2PackageGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStateGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStateGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppStateGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStateGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppTimerGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppTimerGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppTimerGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppTimerGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppTypes.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppTypes.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppTypes.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppTypes.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/cpp/CppValidator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppValidator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/cpp/CppValidator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppValidator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/PortEmitter.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/PortEmitter.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/PortEmitter.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/PortEmitter.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustCargoTomlEmitter.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustCargoTomlEmitter.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustCargoTomlEmitter.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustCargoTomlEmitter.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustEmitter.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustEmitter.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustEmitter.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustEmitter.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustEmitterBase.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustEmitterBase.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustEmitterBase.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustEmitterBase.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustFileConfig.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustFileConfig.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustFileConfig.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustFileConfig.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustMainFileEmitter.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustMainFileEmitter.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustMainFileEmitter.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustMainFileEmitter.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustModel.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustModel.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustModel.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustModel.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustReactorEmitter.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustReactorEmitter.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustReactorEmitter.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustReactorEmitter.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustTypes.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustTypes.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustTypes.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustTypes.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustValidator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustValidator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustValidator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustValidator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSActionGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSActionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSActionGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSActionGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSConnectionGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSConnectionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSConnectionGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSConnectionGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSConstructorGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSConstructorGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSConstructorGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSConstructorGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSDelayBodyGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSDelayBodyGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSDelayBodyGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSDelayBodyGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSExtensions.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSExtensions.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSExtensions.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSExtensions.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSFileConfig.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSFileConfig.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSFileConfig.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSFileConfig.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSImportPreambleGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSImportPreambleGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSImportPreambleGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSImportPreambleGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSInstanceGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSInstanceGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSInstanceGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSInstanceGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSParameterGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSParameterGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSParameterGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSParameterGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSParameterPreambleGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSParameterPreambleGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSParameterPreambleGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSParameterPreambleGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSPortGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSPortGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSPortGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSPortGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSReactionGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSReactionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSReactionGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSReactionGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSReactorGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSReactorGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSReactorGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSReactorGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSStateGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSStateGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSStateGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSStateGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSTimerGenerator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSTimerGenerator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSTimerGenerator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSTimerGenerator.kt diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSValidator.kt b/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSValidator.kt similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSValidator.kt rename to org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSValidator.kt From 3c0acbc84b3081ad9164df13a19bbc54f749bae7 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 11:51:22 +0200 Subject: [PATCH 481/709] move all resources --- .gitmodules | 8 ++++---- org.lflang/core/build.gradle | 5 +---- .../services/de.cau.cs.kieler.klighd.IKlighdStartupHook | 0 .../{src => core/src/main/resources}/lib/c/reactor-c | 0 .../src/main/resources}/lib/cpp/3rd-party/cxxopts.hpp | 0 .../{src => core/src/main/resources}/lib/cpp/lfutil.hh | 0 .../{src => core/src/main/resources}/lib/cpp/reactor-cpp | 0 .../src/main/resources}/lib/cpp/time_parser.hh | 0 .../src/main/resources/lib/platform}/Kconfig | 0 .../src/main/resources/lib/platform}/boards/esp32.overlay | 0 .../lib/platform}/boards/nrf52dk_nrf52832_lf.conf | 0 .../src/main/resources/lib/platform}/prj_lf.conf | 0 .../resources/lib/py/lf-python-support}/lf-python-support | 0 .../{src => core/src/main/resources}/lib/rs/reactor-rs | 0 .../src/main/resources}/lib/rs/runtime-version.properties | 0 .../src/main/resources}/lib/ts/.eslintrc.json | 0 .../{src => core/src/main/resources}/lib/ts/README.md | 0 .../{src => core/src/main/resources}/lib/ts/package.json | 0 .../{src => core/src/main/resources}/lib/ts/tsconfig.json | 0 org.lflang/{src => todo}/log4j.xml | 0 20 files changed, 5 insertions(+), 8 deletions(-) rename org.lflang/{src => core/src/main/resources}/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook (100%) rename org.lflang/{src => core/src/main/resources}/lib/c/reactor-c (100%) rename org.lflang/{src => core/src/main/resources}/lib/cpp/3rd-party/cxxopts.hpp (100%) rename org.lflang/{src => core/src/main/resources}/lib/cpp/lfutil.hh (100%) rename org.lflang/{src => core/src/main/resources}/lib/cpp/reactor-cpp (100%) rename org.lflang/{src => core/src/main/resources}/lib/cpp/time_parser.hh (100%) rename org.lflang/{src/lib/platform/zephyr => core/src/main/resources/lib/platform}/Kconfig (100%) rename org.lflang/{src/lib/platform/zephyr => core/src/main/resources/lib/platform}/boards/esp32.overlay (100%) rename org.lflang/{src/lib/platform/zephyr => core/src/main/resources/lib/platform}/boards/nrf52dk_nrf52832_lf.conf (100%) rename org.lflang/{src/lib/platform/zephyr => core/src/main/resources/lib/platform}/prj_lf.conf (100%) rename org.lflang/{src/lib/py => core/src/main/resources/lib/py/lf-python-support}/lf-python-support (100%) rename org.lflang/{src => core/src/main/resources}/lib/rs/reactor-rs (100%) rename org.lflang/{src => core/src/main/resources}/lib/rs/runtime-version.properties (100%) rename org.lflang/{src => core/src/main/resources}/lib/ts/.eslintrc.json (100%) rename org.lflang/{src => core/src/main/resources}/lib/ts/README.md (100%) rename org.lflang/{src => core/src/main/resources}/lib/ts/package.json (100%) rename org.lflang/{src => core/src/main/resources}/lib/ts/tsconfig.json (100%) rename org.lflang/{src => todo}/log4j.xml (100%) diff --git a/.gitmodules b/.gitmodules index c66506c2af..0b655fae19 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,12 +1,12 @@ [submodule "org.lflang/src/lib/c/reactor-c"] - path = org.lflang/src/lib/c/reactor-c + path = org.lflang/core/src/main/resources/lib/c/reactor-c url = https://github.com/lf-lang/reactor-c.git [submodule "org.lflang/src/lib/cpp/reactor-cpp"] - path = org.lflang/src/lib/cpp/reactor-cpp + path = org.lflang/core/src/main/resources/lib/cpp/reactor-cpp url = https://github.com/lf-lang/reactor-cpp [submodule "org.lflang/src/lib/rs/reactor-rs"] - path = org.lflang/src/lib/rs/reactor-rs + path = org.lflang/core/src/main/resources/lib/rs/reactor-rs url = https://github.com/lf-lang/reactor-rs [submodule "org.lflang/src/lib/py/lf-python-support"] - path = org.lflang/src/lib/py/lf-python-support + path = org.lflang/core/src/main/resources/lib/py/lf-python-support/lf-python-support url = https://github.com/lf-lang/lf-python-support.git diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index 8a5a487299..d2479c0795 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -9,10 +9,7 @@ sourceSets { srcDirs = ['src/main/java', 'src-gen'] } resources { - srcDirs = ['src-gen', '../src/'] - include 'lib/' - include 'org/lflang/LF.xtextbin' - include 'org/lflang/parser/antlr/internal/InternalLF.tokens' + srcDirs = ['src/main/resources', 'src-gen'] } } } diff --git a/org.lflang/src/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook b/org.lflang/core/src/main/resources/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook similarity index 100% rename from org.lflang/src/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook rename to org.lflang/core/src/main/resources/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/core/src/main/resources/lib/c/reactor-c similarity index 100% rename from org.lflang/src/lib/c/reactor-c rename to org.lflang/core/src/main/resources/lib/c/reactor-c diff --git a/org.lflang/src/lib/cpp/3rd-party/cxxopts.hpp b/org.lflang/core/src/main/resources/lib/cpp/3rd-party/cxxopts.hpp similarity index 100% rename from org.lflang/src/lib/cpp/3rd-party/cxxopts.hpp rename to org.lflang/core/src/main/resources/lib/cpp/3rd-party/cxxopts.hpp diff --git a/org.lflang/src/lib/cpp/lfutil.hh b/org.lflang/core/src/main/resources/lib/cpp/lfutil.hh similarity index 100% rename from org.lflang/src/lib/cpp/lfutil.hh rename to org.lflang/core/src/main/resources/lib/cpp/lfutil.hh diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/core/src/main/resources/lib/cpp/reactor-cpp similarity index 100% rename from org.lflang/src/lib/cpp/reactor-cpp rename to org.lflang/core/src/main/resources/lib/cpp/reactor-cpp diff --git a/org.lflang/src/lib/cpp/time_parser.hh b/org.lflang/core/src/main/resources/lib/cpp/time_parser.hh similarity index 100% rename from org.lflang/src/lib/cpp/time_parser.hh rename to org.lflang/core/src/main/resources/lib/cpp/time_parser.hh diff --git a/org.lflang/src/lib/platform/zephyr/Kconfig b/org.lflang/core/src/main/resources/lib/platform/Kconfig similarity index 100% rename from org.lflang/src/lib/platform/zephyr/Kconfig rename to org.lflang/core/src/main/resources/lib/platform/Kconfig diff --git a/org.lflang/src/lib/platform/zephyr/boards/esp32.overlay b/org.lflang/core/src/main/resources/lib/platform/boards/esp32.overlay similarity index 100% rename from org.lflang/src/lib/platform/zephyr/boards/esp32.overlay rename to org.lflang/core/src/main/resources/lib/platform/boards/esp32.overlay diff --git a/org.lflang/src/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf b/org.lflang/core/src/main/resources/lib/platform/boards/nrf52dk_nrf52832_lf.conf similarity index 100% rename from org.lflang/src/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf rename to org.lflang/core/src/main/resources/lib/platform/boards/nrf52dk_nrf52832_lf.conf diff --git a/org.lflang/src/lib/platform/zephyr/prj_lf.conf b/org.lflang/core/src/main/resources/lib/platform/prj_lf.conf similarity index 100% rename from org.lflang/src/lib/platform/zephyr/prj_lf.conf rename to org.lflang/core/src/main/resources/lib/platform/prj_lf.conf diff --git a/org.lflang/src/lib/py/lf-python-support b/org.lflang/core/src/main/resources/lib/py/lf-python-support/lf-python-support similarity index 100% rename from org.lflang/src/lib/py/lf-python-support rename to org.lflang/core/src/main/resources/lib/py/lf-python-support/lf-python-support diff --git a/org.lflang/src/lib/rs/reactor-rs b/org.lflang/core/src/main/resources/lib/rs/reactor-rs similarity index 100% rename from org.lflang/src/lib/rs/reactor-rs rename to org.lflang/core/src/main/resources/lib/rs/reactor-rs diff --git a/org.lflang/src/lib/rs/runtime-version.properties b/org.lflang/core/src/main/resources/lib/rs/runtime-version.properties similarity index 100% rename from org.lflang/src/lib/rs/runtime-version.properties rename to org.lflang/core/src/main/resources/lib/rs/runtime-version.properties diff --git a/org.lflang/src/lib/ts/.eslintrc.json b/org.lflang/core/src/main/resources/lib/ts/.eslintrc.json similarity index 100% rename from org.lflang/src/lib/ts/.eslintrc.json rename to org.lflang/core/src/main/resources/lib/ts/.eslintrc.json diff --git a/org.lflang/src/lib/ts/README.md b/org.lflang/core/src/main/resources/lib/ts/README.md similarity index 100% rename from org.lflang/src/lib/ts/README.md rename to org.lflang/core/src/main/resources/lib/ts/README.md diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/core/src/main/resources/lib/ts/package.json similarity index 100% rename from org.lflang/src/lib/ts/package.json rename to org.lflang/core/src/main/resources/lib/ts/package.json diff --git a/org.lflang/src/lib/ts/tsconfig.json b/org.lflang/core/src/main/resources/lib/ts/tsconfig.json similarity index 100% rename from org.lflang/src/lib/ts/tsconfig.json rename to org.lflang/core/src/main/resources/lib/ts/tsconfig.json diff --git a/org.lflang/src/log4j.xml b/org.lflang/todo/log4j.xml similarity index 100% rename from org.lflang/src/log4j.xml rename to org.lflang/todo/log4j.xml From 98e2ba76c38e943ab3f52ee625a2235c0a4e6be3 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 11:55:02 +0200 Subject: [PATCH 482/709] be more precise about xtext outputs --- org.lflang/core/build.gradle | 2 ++ 1 file changed, 2 insertions(+) diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index d2479c0795..63b60d43e6 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -76,6 +76,8 @@ tasks.register('generateXtextLanguage', JavaExec) { inputs.file "src/main/java/org/lflang/GenerateLinguaFranca.mwe2" inputs.file "src/main/java/org/lflang/LinguaFranca.xtext" outputs.dir "src-gen" + outputs.dir "model" + outputs.file ".antlr-generator-3.2.0-patch.jar" args += "src/main/java/org/lflang/GenerateLinguaFranca.mwe2" args += "-p" args += "rootPath=/${projectDir}/.." From e7e586ce44122d9276e9c86d098746c8744c6506 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 13:56:14 +0200 Subject: [PATCH 483/709] create cli module --- gradle.properties | 1 + org.lflang/cli/base/build.gradle | 25 +++++++++++++++++ .../src/main/java/org/lflang/cli/CliBase.java | 0 .../org/lflang/cli/LFStandaloneModule.java | 0 .../src/main/java/org/lflang/cli/Lff.java | 0 .../lflang/cli/StandaloneErrorReporter.java | 0 .../lflang/cli/StandaloneIssueAcceptor.java | 0 .../java/org/lflang/cli/VersionProvider.java | 0 .../kotlin/org/lflang/cli/ReportingUtil.kt | 0 org.lflang/core/build.gradle | 28 ++++++++----------- settings.gradle | 4 +-- 11 files changed, 39 insertions(+), 19 deletions(-) create mode 100644 org.lflang/cli/base/build.gradle rename org.lflang/{core => cli/base}/src/main/java/org/lflang/cli/CliBase.java (100%) rename org.lflang/{core => cli/base}/src/main/java/org/lflang/cli/LFStandaloneModule.java (100%) rename org.lflang/{core => cli/base}/src/main/java/org/lflang/cli/Lff.java (100%) rename org.lflang/{core => cli/base}/src/main/java/org/lflang/cli/StandaloneErrorReporter.java (100%) rename org.lflang/{core => cli/base}/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java (100%) rename org.lflang/{core => cli/base}/src/main/java/org/lflang/cli/VersionProvider.java (100%) rename org.lflang/{core => cli/base}/src/main/kotlin/org/lflang/cli/ReportingUtil.kt (100%) diff --git a/gradle.properties b/gradle.properties index 4b1302bdb8..abe6782af7 100644 --- a/gradle.properties +++ b/gradle.properties @@ -3,6 +3,7 @@ group=org.lflang version=0.4.1-SNAPSHOT [versions] +fasterxmlVersion=2.12.4 googleJavaFormatVersion=1.15.0 guiceVersion=5.1.0 gsonVersion=2.10.1 diff --git a/org.lflang/cli/base/build.gradle b/org.lflang/cli/base/build.gradle new file mode 100644 index 0000000000..717a4a6026 --- /dev/null +++ b/org.lflang/cli/base/build.gradle @@ -0,0 +1,25 @@ +plugins { + id 'org.jetbrains.kotlin.jvm' version "${kotlinVersion}" + id 'java-library' +} + +compileKotlin { + kotlinOptions { + jvmTarget = kotlinJvmTarget + } +} +compileTestKotlin { + kotlinOptions { + jvmTarget = kotlinJvmTarget + } +} + +repositories { + mavenCentral() +} + +dependencies { + api "info.picocli:picocli:$picocliVersion" + + api project(':org.lflang:core') +} \ No newline at end of file diff --git a/org.lflang/core/src/main/java/org/lflang/cli/CliBase.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/cli/CliBase.java rename to org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java diff --git a/org.lflang/core/src/main/java/org/lflang/cli/LFStandaloneModule.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/LFStandaloneModule.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/cli/LFStandaloneModule.java rename to org.lflang/cli/base/src/main/java/org/lflang/cli/LFStandaloneModule.java diff --git a/org.lflang/core/src/main/java/org/lflang/cli/Lff.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/Lff.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/cli/Lff.java rename to org.lflang/cli/base/src/main/java/org/lflang/cli/Lff.java diff --git a/org.lflang/core/src/main/java/org/lflang/cli/StandaloneErrorReporter.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/StandaloneErrorReporter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/cli/StandaloneErrorReporter.java rename to org.lflang/cli/base/src/main/java/org/lflang/cli/StandaloneErrorReporter.java diff --git a/org.lflang/core/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java rename to org.lflang/cli/base/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java diff --git a/org.lflang/core/src/main/java/org/lflang/cli/VersionProvider.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/VersionProvider.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/cli/VersionProvider.java rename to org.lflang/cli/base/src/main/java/org/lflang/cli/VersionProvider.java diff --git a/org.lflang/core/src/main/kotlin/org/lflang/cli/ReportingUtil.kt b/org.lflang/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/cli/ReportingUtil.kt rename to org.lflang/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index 63b60d43e6..c8af09ec30 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -15,7 +15,6 @@ sourceSets { } compileKotlin { - destinationDir = compileJava.destinationDir kotlinOptions { jvmTarget = kotlinJvmTarget } @@ -35,27 +34,24 @@ repositories { } dependencies { - implementation "org.eclipse.xtext:org.eclipse.xtext:${xtextVersion}" - implementation "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:${xtextVersion}" - implementation "org.eclipse.xtext:org.eclipse.xtext.ide:${xtextVersion}" - // https://mvnrepository.com/artifact/org.eclipse.platform/org.eclipse.core.resources - implementation group: 'org.eclipse.platform', name: 'org.eclipse.core.resources', version: "${resourcesVersion}" - // https://mvnrepository.com/artifact/org.eclipse.emf/org.eclipse.emf.mwe2.launch - implementation group: 'org.eclipse.emf', name: 'org.eclipse.emf.mwe2.launch', version: "${mwe2LaunchVersion}" - // https://mvnrepository.com/artifact/org.eclipse.lsp4j/org.eclipse.lsp4j - implementation group: 'org.eclipse.lsp4j', name: 'org.eclipse.lsp4j', version: "${lsp4jVersion}" - implementation group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.12.4' - implementation group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: '2.12.4' - implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.12.4' - implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:${klighdVersion}") { + api "org.eclipse.xtext:org.eclipse.xtext:$xtextVersion" + api "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:$xtextVersion" + api "org.eclipse.xtext:org.eclipse.xtext.ide:$xtextVersion" + + implementation "org.eclipse.emf:org.eclipse.emf.mwe2.launch:$mwe2LaunchVersion" + + implementation "com.fasterxml.jackson.core:jackson-core:$fasterxmlVersion" + implementation "com.fasterxml.jackson.core:jackson-annotations:$fasterxmlVersion" + implementation "com.fasterxml.jackson.core:jackson-databind:$fasterxmlVersion" + + implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:$klighdVersion") { exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' } - implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.standalone:${klighdVersion}") { + implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.standalone:$klighdVersion") { exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' } - implementation group: 'info.picocli', name: 'picocli', version: picocliVersion } configurations { diff --git a/settings.gradle b/settings.gradle index 8bfc40a9e1..95c7b74b9e 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,4 +1,2 @@ rootProject.name = 'org.lflang' -include(':org.lflang:core', 'lfc') - - +include(':org.lflang:core', ':org.lflang:cli:base') From 1ed9d725dd150b9513d9a42bdacb4caa30dcf6a3 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 14:04:31 +0200 Subject: [PATCH 484/709] move lfc and lff --- lfc/build.gradle | 52 ------------------- org.lflang/cli/lfc/build.gradle | 23 ++++++++ .../src/main/java}/org/lflang/cli/Lfc.java | 0 org.lflang/cli/lff/build.gradle | 23 ++++++++ .../src/main/java/org/lflang/cli/Lff.java | 0 settings.gradle | 2 +- 6 files changed, 47 insertions(+), 53 deletions(-) delete mode 100644 lfc/build.gradle create mode 100644 org.lflang/cli/lfc/build.gradle rename {lfc/src => org.lflang/cli/lfc/src/main/java}/org/lflang/cli/Lfc.java (100%) create mode 100644 org.lflang/cli/lff/build.gradle rename org.lflang/cli/{base => lff}/src/main/java/org/lflang/cli/Lff.java (100%) diff --git a/lfc/build.gradle b/lfc/build.gradle deleted file mode 100644 index 7eb33a7223..0000000000 --- a/lfc/build.gradle +++ /dev/null @@ -1,52 +0,0 @@ -plugins { - id 'java' - id 'application' -} - -sourceSets { - main { - java { - srcDirs = ['src'] - } - } -} - -repositories { - mavenCentral() - // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. - maven { - url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - } -} - -dependencies { - implementation "org.eclipse.xtext:org.eclipse.xtext:${xtextVersion}" - implementation "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:${xtextVersion}" - implementation "org.eclipse.xtext:org.eclipse.xtext.ide:${xtextVersion}" - // https://mvnrepository.com/artifact/org.eclipse.platform/org.eclipse.core.resources - implementation group: 'org.eclipse.platform', name: 'org.eclipse.core.resources', version: "${resourcesVersion}" - // https://mvnrepository.com/artifact/org.eclipse.emf/org.eclipse.emf.mwe2.launch - implementation group: 'org.eclipse.emf', name: 'org.eclipse.emf.mwe2.launch', version: "${mwe2LaunchVersion}" - // https://mvnrepository.com/artifact/org.eclipse.lsp4j/org.eclipse.lsp4j - implementation group: 'org.eclipse.lsp4j', name: 'org.eclipse.lsp4j', version: "${lsp4jVersion}" - implementation group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.12.4' - implementation group: 'com.fasterxml.jackson.core', name: 'jackson-annotations', version: '2.12.4' - implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.12.4' - implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:${klighdVersion}") { - exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' - exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' - } - implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.standalone:${klighdVersion}") { - exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' - exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' - } - implementation group: 'info.picocli', name: 'picocli', version: picocliVersion - implementation project(':org.lflang:core') -} - -application { - mainClass = 'org.lflang.cli.Lfc' - tasks.run.workingDir = rootProject.projectDir -} - -build.finalizedBy installDist \ No newline at end of file diff --git a/org.lflang/cli/lfc/build.gradle b/org.lflang/cli/lfc/build.gradle new file mode 100644 index 0000000000..405f537fd7 --- /dev/null +++ b/org.lflang/cli/lfc/build.gradle @@ -0,0 +1,23 @@ +plugins { + id 'java' + id 'application' +} + +repositories { + mavenCentral() + // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. + maven { + url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + } +} + +dependencies { + implementation project(':org.lflang:cli:base') +} + +application { + mainClass = 'org.lflang.cli.Lfc' + tasks.run.workingDir = rootProject.projectDir +} + +assemble.finalizedBy installDist \ No newline at end of file diff --git a/lfc/src/org/lflang/cli/Lfc.java b/org.lflang/cli/lfc/src/main/java/org/lflang/cli/Lfc.java similarity index 100% rename from lfc/src/org/lflang/cli/Lfc.java rename to org.lflang/cli/lfc/src/main/java/org/lflang/cli/Lfc.java diff --git a/org.lflang/cli/lff/build.gradle b/org.lflang/cli/lff/build.gradle new file mode 100644 index 0000000000..1d646903fd --- /dev/null +++ b/org.lflang/cli/lff/build.gradle @@ -0,0 +1,23 @@ +plugins { + id 'java' + id 'application' +} + +repositories { + mavenCentral() + // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. + maven { + url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + } +} + +dependencies { + implementation project(':org.lflang:cli:base') +} + +application { + mainClass = 'org.lflang.cli.Lff' + tasks.run.workingDir = rootProject.projectDir +} + +assemble.finalizedBy installDist \ No newline at end of file diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/Lff.java b/org.lflang/cli/lff/src/main/java/org/lflang/cli/Lff.java similarity index 100% rename from org.lflang/cli/base/src/main/java/org/lflang/cli/Lff.java rename to org.lflang/cli/lff/src/main/java/org/lflang/cli/Lff.java diff --git a/settings.gradle b/settings.gradle index 95c7b74b9e..e6670589ce 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,2 +1,2 @@ rootProject.name = 'org.lflang' -include(':org.lflang:core', ':org.lflang:cli:base') +include(':org.lflang:core', ':org.lflang:cli:base', ':org.lflang:cli:lfc') From 7f92b826c4a93ab5d0bbe5e1504c1babbe7f723d Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 15:12:02 +0200 Subject: [PATCH 485/709] use convention plugins --- buildSrc/build.gradle | 20 +++++++++++----- buildSrc/gradle.properties | 1 + .../groovy/org.lflang.java-application.gradle | 6 +++++ .../groovy/org.lflang.java-conventions.gradle | 11 +++++++++ ...org.lflang.java-library-conventions.gradle | 4 ++++ .../org.lflang.kotlin-conventions.gradle | 15 ++++++++++++ gradle.properties | 1 - org.lflang/cli/base/build.gradle | 19 ++------------- org.lflang/cli/lfc/build.gradle | 13 +---------- org.lflang/cli/lff/build.gradle | 11 +-------- org.lflang/core/build.gradle | 23 ++----------------- 11 files changed, 57 insertions(+), 67 deletions(-) create mode 100644 buildSrc/src/main/groovy/org.lflang.java-application.gradle create mode 100644 buildSrc/src/main/groovy/org.lflang.java-conventions.gradle create mode 100644 buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle create mode 100644 buildSrc/src/main/groovy/org.lflang.kotlin-conventions.gradle diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle index d09084a499..162b911e9c 100644 --- a/buildSrc/build.gradle +++ b/buildSrc/build.gradle @@ -1,9 +1,17 @@ +plugins { + id 'groovy-gradle-plugin' +} + repositories { mavenCentral() - dependencies { - // https://mvnrepository.com/artifact/com.diffplug.spotless/spotless-lib - implementation group: 'com.diffplug.spotless', name: 'spotless-lib', version: spotlessLibVersion - // https://mvnrepository.com/artifact/com.diffplug.spotless/spotless-lib-extra - implementation group: 'com.diffplug.spotless', name: 'spotless-lib-extra', version: spotlessLibVersion - } + gradlePluginPortal() } + +dependencies { + // https://mvnrepository.com/artifact/com.diffplug.spotless/spotless-lib + implementation group: 'com.diffplug.spotless', name: 'spotless-lib', version: spotlessLibVersion + // https://mvnrepository.com/artifact/com.diffplug.spotless/spotless-lib-extra + implementation group: 'com.diffplug.spotless', name: 'spotless-lib-extra', version: spotlessLibVersion + + implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion" +} \ No newline at end of file diff --git a/buildSrc/gradle.properties b/buildSrc/gradle.properties index 8591896bc2..ed9731fc68 100644 --- a/buildSrc/gradle.properties +++ b/buildSrc/gradle.properties @@ -1,2 +1,3 @@ [versions] spotlessLibVersion=2.30.0 +kotlinVersion=1.6.21 diff --git a/buildSrc/src/main/groovy/org.lflang.java-application.gradle b/buildSrc/src/main/groovy/org.lflang.java-application.gradle new file mode 100644 index 0000000000..2beb5c887c --- /dev/null +++ b/buildSrc/src/main/groovy/org.lflang.java-application.gradle @@ -0,0 +1,6 @@ +plugins { + id 'org.lflang.java-conventions' + id 'application' +} + +assemble.finalizedBy installDist \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle new file mode 100644 index 0000000000..ced3e9d24e --- /dev/null +++ b/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle @@ -0,0 +1,11 @@ +plugins { + id 'java' +} + +repositories { + mavenCentral() + // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. + maven { + url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + } +} \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle new file mode 100644 index 0000000000..a5c43751ee --- /dev/null +++ b/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle @@ -0,0 +1,4 @@ +plugins { + id 'org.lflang.java-conventions' + id 'java-library' +} \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org.lflang.kotlin-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.kotlin-conventions.gradle new file mode 100644 index 0000000000..d595e14b21 --- /dev/null +++ b/buildSrc/src/main/groovy/org.lflang.kotlin-conventions.gradle @@ -0,0 +1,15 @@ +plugins { + id 'org.jetbrains.kotlin.jvm' +} + +compileKotlin { + kotlinOptions { + jvmTarget = kotlinJvmTarget + } +} + +compileTestKotlin { + kotlinOptions { + jvmTarget = kotlinJvmTarget + } +} \ No newline at end of file diff --git a/gradle.properties b/gradle.properties index abe6782af7..f1290a2281 100644 --- a/gradle.properties +++ b/gradle.properties @@ -12,7 +12,6 @@ jupiterVersion=5.8.2 jUnitPlatformVersion=1.8.2 jUnitVersion=4.13.2 kotlinJvmTarget=17 -kotlinVersion=1.6.20 lsp4jVersion=0.14.0 mwe2LaunchVersion=2.12.2 openTest4jVersion=1.2.0 diff --git a/org.lflang/cli/base/build.gradle b/org.lflang/cli/base/build.gradle index 717a4a6026..3623efd1a2 100644 --- a/org.lflang/cli/base/build.gradle +++ b/org.lflang/cli/base/build.gradle @@ -1,21 +1,6 @@ plugins { - id 'org.jetbrains.kotlin.jvm' version "${kotlinVersion}" - id 'java-library' -} - -compileKotlin { - kotlinOptions { - jvmTarget = kotlinJvmTarget - } -} -compileTestKotlin { - kotlinOptions { - jvmTarget = kotlinJvmTarget - } -} - -repositories { - mavenCentral() + id 'org.lflang.java-library-conventions' + id 'org.lflang.kotlin-conventions' } dependencies { diff --git a/org.lflang/cli/lfc/build.gradle b/org.lflang/cli/lfc/build.gradle index 405f537fd7..44416c2c47 100644 --- a/org.lflang/cli/lfc/build.gradle +++ b/org.lflang/cli/lfc/build.gradle @@ -1,14 +1,5 @@ plugins { - id 'java' - id 'application' -} - -repositories { - mavenCentral() - // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. - maven { - url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - } + id 'org.lflang.java-application' } dependencies { @@ -19,5 +10,3 @@ application { mainClass = 'org.lflang.cli.Lfc' tasks.run.workingDir = rootProject.projectDir } - -assemble.finalizedBy installDist \ No newline at end of file diff --git a/org.lflang/cli/lff/build.gradle b/org.lflang/cli/lff/build.gradle index 1d646903fd..ac8e928f06 100644 --- a/org.lflang/cli/lff/build.gradle +++ b/org.lflang/cli/lff/build.gradle @@ -1,14 +1,5 @@ plugins { - id 'java' - id 'application' -} - -repositories { - mavenCentral() - // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. - maven { - url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - } + id 'org.lflang.java-application' } dependencies { diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index c8af09ec30..f619dd967c 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -1,6 +1,6 @@ plugins { - id 'org.jetbrains.kotlin.jvm' version "${kotlinVersion}" - id 'java-library' + id 'org.lflang.java-library-conventions' + id 'org.lflang.kotlin-conventions' } sourceSets { @@ -14,25 +14,6 @@ sourceSets { } } -compileKotlin { - kotlinOptions { - jvmTarget = kotlinJvmTarget - } -} -compileTestKotlin { - kotlinOptions { - jvmTarget = kotlinJvmTarget - } -} - -repositories { - mavenCentral() - // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. - maven { - url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - } -} - dependencies { api "org.eclipse.xtext:org.eclipse.xtext:$xtextVersion" api "org.eclipse.xtext:org.eclipse.xtext.xbase.lib:$xtextVersion" From 269638d6b62f0bd8ac225cff04f5dc125a8ec1df Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 25 May 2023 07:01:00 -0700 Subject: [PATCH 486/709] Added test of documented STP_offset parameter --- test/C/src/federated/STPParameter.lf | 57 ++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 test/C/src/federated/STPParameter.lf diff --git a/test/C/src/federated/STPParameter.lf b/test/C/src/federated/STPParameter.lf new file mode 100644 index 0000000000..0eb6788bfe --- /dev/null +++ b/test/C/src/federated/STPParameter.lf @@ -0,0 +1,57 @@ +target C { + timeout: 5 sec, + coordination: decentralized +} +import Count from "../lib/Count.lf" + +/* FIXME: inheritance not working! See issue #1733 +import TestCount from "../lib/TestCount.lf" + +reactor PrintTimer(STP_offset:time = 10 msec) extends TestCount { + timer t(0, 1 sec); + reaction(t) {= + lf_print("Timer ticked at (%lld, %d).", + lf_time_logical_elapsed(), lf_tag().microstep + ); + =} +} +* +*/ + +reactor PrintTimer(STP_offset:time = 1 sec, start: int = 1, stride: int = 1, num_inputs: int = 6) { + state count: int = start + state inputs_received: int = 0 + input in: int + + reaction(in) {= + lf_print("Received %d.", in->value); + if (in->value != self->count) { + lf_print_error_and_exit("Expected %d.", self->count); + } + self->count += self->stride; + self->inputs_received++; + =} + + reaction(shutdown) {= + lf_print("Shutdown invoked."); + if (self->inputs_received != self->num_inputs) { + lf_print_error_and_exit("Expected to receive %d inputs, but got %d.", + self->num_inputs, + self->inputs_received + ); + } + =} + + timer t(0, 1 sec); + reaction(t) {= + lf_print("Timer ticked at (%lld, %d).", + lf_time_logical_elapsed(), lf_tag().microstep + ); + =} +} + +federated reactor { + c = new Count(); + p = new PrintTimer(); + c.out -> p.in; +} From 08404b3f752d16c8057da34b845aaaa39fc49f08 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 16:21:52 +0200 Subject: [PATCH 487/709] move unit tests --- .gitignore | 1 + org.lflang/core/build.gradle | 31 +++++++++++++++++-- .../java/org/lflang/GenerateLinguaFranca.mwe2 | 6 ++-- .../java}/org/lflang/tests/Configurators.java | 0 .../java}/org/lflang/tests/LFParsingTest.java | 0 .../test/java}/org/lflang/tests/LFTest.java | 0 .../java}/org/lflang/tests/LfParsingUtil.java | 0 .../test/java}/org/lflang/tests/TestBase.java | 0 .../java}/org/lflang/tests/TestError.java | 0 .../java}/org/lflang/tests/TestRegistry.java | 0 .../tests/compiler/EquivalenceUnitTests.java | 0 .../tests/compiler/FormattingUnitTests.java | 0 .../tests/compiler/LetInferenceTests.java | 0 .../compiler/LinguaFrancaASTUtilsTest.java | 0 .../LinguaFrancaDependencyAnalysisTest.java | 0 .../compiler/LinguaFrancaParsingTest.java | 0 .../compiler/LinguaFrancaScopingTest.java | 0 .../compiler/LinguaFrancaValidationTest.java | 0 .../tests/compiler/MixedRadixIntTest.java | 0 .../tests/compiler/PortInstanceTests.java | 0 .../org/lflang/tests/compiler/RangeTests.java | 0 .../lflang/tests/compiler/RoundTripTests.java | 0 .../tests/compiler/TargetConfigTests.java | 3 +- .../org/lflang/tests/lsp/ErrorInserter.java | 0 .../java}/org/lflang/tests/lsp/LspTests.java | 0 .../lflang/tests/lsp/MockLanguageClient.java | 0 .../lflang/tests/lsp/MockReportProgress.java | 0 .../serialization/SerializationTest.java | 0 .../org/lflang/tests/util/StringUtilTest.java | 0 29 files changed, 36 insertions(+), 5 deletions(-) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/Configurators.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/LFParsingTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/LFTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/LfParsingUtil.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/TestBase.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/TestError.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/TestRegistry.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/EquivalenceUnitTests.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/FormattingUnitTests.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/LetInferenceTests.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/LinguaFrancaParsingTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/LinguaFrancaScopingTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/LinguaFrancaValidationTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/MixedRadixIntTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/PortInstanceTests.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/RangeTests.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/RoundTripTests.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/compiler/TargetConfigTests.java (98%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/lsp/ErrorInserter.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/lsp/LspTests.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/lsp/MockLanguageClient.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/lsp/MockReportProgress.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/serialization/SerializationTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/util/StringUtilTest.java (100%) diff --git a/.gitignore b/.gitignore index 579afb6154..a56607d25f 100644 --- a/.gitignore +++ b/.gitignore @@ -12,6 +12,7 @@ **/build/ **/test-bin/ **/src-gen/ +**/test-gen/ **/fed-gen/ **/xtend-gen/ # Created by https://www.toptal.com/developers/gitignore/api/intellij,gradle,eclipse,maven,visualstudiocode diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index f619dd967c..8a290804a3 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -12,6 +12,11 @@ sourceSets { srcDirs = ['src/main/resources', 'src-gen'] } } + test { + java { + srcDirs = ['src/test/java', 'test-gen'] + } + } } dependencies { @@ -33,6 +38,14 @@ dependencies { exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' } + + testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" + testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" + testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" + testImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" + testImplementation "org.opentest4j:opentest4j:$openTest4jVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" } configurations { @@ -48,7 +61,7 @@ dependencies { } tasks.register('generateXtextLanguage', JavaExec) { - main = 'org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher' + mainClass = 'org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher' classpath = configurations.mwe2 inputs.file "src/main/java/org/lflang/GenerateLinguaFranca.mwe2" inputs.file "src/main/java/org/lflang/LinguaFranca.xtext" @@ -63,4 +76,18 @@ tasks.register('generateXtextLanguage', JavaExec) { compileJava.dependsOn(generateXtextLanguage) compileKotlin.dependsOn(generateXtextLanguage) processResources.dependsOn(generateXtextLanguage) -clean.dependsOn(cleanGenerateXtextLanguage) \ No newline at end of file +clean.dependsOn(cleanGenerateXtextLanguage) + +dependencies { + testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" + testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" + testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" + testImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" + testImplementation "org.opentest4j:opentest4j:$openTest4jVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" +} + +test { + useJUnitPlatform() +} \ No newline at end of file diff --git a/org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 b/org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 index c2b557c631..3958d74d69 100644 --- a/org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 +++ b/org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 @@ -23,8 +23,10 @@ Workflow { src = "src/main/java" } runtimeTest = { - enabled = false - name = "org.lflang.tests" // generate into separate test project + enabled = true + name = coreProject // add into the core project + src = "src/test/java" + srcGen = "test-gen" } // Only generate Eclipse infrastructure for the Epoch build (separate repository). createEclipseMetaData = false diff --git a/org.lflang.tests/src/org/lflang/tests/Configurators.java b/org.lflang/core/src/test/java/org/lflang/tests/Configurators.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/Configurators.java rename to org.lflang/core/src/test/java/org/lflang/tests/Configurators.java diff --git a/org.lflang.tests/src/org/lflang/tests/LFParsingTest.java b/org.lflang/core/src/test/java/org/lflang/tests/LFParsingTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/LFParsingTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/LFParsingTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/LFTest.java b/org.lflang/core/src/test/java/org/lflang/tests/LFTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/LFTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/LFTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/LfParsingUtil.java b/org.lflang/core/src/test/java/org/lflang/tests/LfParsingUtil.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/LfParsingUtil.java rename to org.lflang/core/src/test/java/org/lflang/tests/LfParsingUtil.java diff --git a/org.lflang.tests/src/org/lflang/tests/TestBase.java b/org.lflang/core/src/test/java/org/lflang/tests/TestBase.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/TestBase.java rename to org.lflang/core/src/test/java/org/lflang/tests/TestBase.java diff --git a/org.lflang.tests/src/org/lflang/tests/TestError.java b/org.lflang/core/src/test/java/org/lflang/tests/TestError.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/TestError.java rename to org.lflang/core/src/test/java/org/lflang/tests/TestError.java diff --git a/org.lflang.tests/src/org/lflang/tests/TestRegistry.java b/org.lflang/core/src/test/java/org/lflang/tests/TestRegistry.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/TestRegistry.java rename to org.lflang/core/src/test/java/org/lflang/tests/TestRegistry.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/EquivalenceUnitTests.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/EquivalenceUnitTests.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/EquivalenceUnitTests.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/EquivalenceUnitTests.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/FormattingUnitTests.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/FormattingUnitTests.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/FormattingUnitTests.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/LetInferenceTests.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/LetInferenceTests.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/LetInferenceTests.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaParsingTest.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaParsingTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaParsingTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaParsingTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaScopingTest.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaScopingTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaScopingTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaScopingTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaValidationTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/LinguaFrancaValidationTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaValidationTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/MixedRadixIntTest.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/MixedRadixIntTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/MixedRadixIntTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/MixedRadixIntTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/PortInstanceTests.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/PortInstanceTests.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/PortInstanceTests.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/PortInstanceTests.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/RangeTests.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/RangeTests.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/RangeTests.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/RangeTests.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/RoundTripTests.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/compiler/RoundTripTests.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/RoundTripTests.java diff --git a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java b/org.lflang/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java similarity index 98% rename from org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java rename to org.lflang/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java index e949ab6f9f..51f813befc 100644 --- a/org.lflang.tests/src/org/lflang/tests/compiler/TargetConfigTests.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java @@ -71,7 +71,8 @@ public void testFederation() throws Exception { parser.parse( """ target C { - tracing: true + tracing: true, + no-compile: true } reactor Foo { diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/ErrorInserter.java b/org.lflang/core/src/test/java/org/lflang/tests/lsp/ErrorInserter.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/lsp/ErrorInserter.java rename to org.lflang/core/src/test/java/org/lflang/tests/lsp/ErrorInserter.java diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java b/org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/lsp/LspTests.java rename to org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/MockLanguageClient.java b/org.lflang/core/src/test/java/org/lflang/tests/lsp/MockLanguageClient.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/lsp/MockLanguageClient.java rename to org.lflang/core/src/test/java/org/lflang/tests/lsp/MockLanguageClient.java diff --git a/org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java b/org.lflang/core/src/test/java/org/lflang/tests/lsp/MockReportProgress.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/lsp/MockReportProgress.java rename to org.lflang/core/src/test/java/org/lflang/tests/lsp/MockReportProgress.java diff --git a/org.lflang.tests/src/org/lflang/tests/serialization/SerializationTest.java b/org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/serialization/SerializationTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/util/StringUtilTest.java b/org.lflang/core/src/test/java/org/lflang/tests/util/StringUtilTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/util/StringUtilTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/util/StringUtilTest.java From 5719ab4ea3a3b2496f39e7c2a454205778efdc87 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 25 May 2023 07:45:22 -0700 Subject: [PATCH 488/709] Formatted --- test/C/src/federated/STPParameter.lf | 44 +++++++++++++++------------- 1 file changed, 23 insertions(+), 21 deletions(-) diff --git a/test/C/src/federated/STPParameter.lf b/test/C/src/federated/STPParameter.lf index 0eb6788bfe..701974748d 100644 --- a/test/C/src/federated/STPParameter.lf +++ b/test/C/src/federated/STPParameter.lf @@ -2,27 +2,30 @@ target C { timeout: 5 sec, coordination: decentralized } -import Count from "../lib/Count.lf" - -/* FIXME: inheritance not working! See issue #1733 -import TestCount from "../lib/TestCount.lf" -reactor PrintTimer(STP_offset:time = 10 msec) extends TestCount { - timer t(0, 1 sec); - reaction(t) {= - lf_print("Timer ticked at (%lld, %d).", - lf_time_logical_elapsed(), lf_tag().microstep - ); - =} -} -* -*/ +import Count from "../lib/Count.lf" -reactor PrintTimer(STP_offset:time = 1 sec, start: int = 1, stride: int = 1, num_inputs: int = 6) { +/** + * FIXME: inheritance not working! See issue #1733 import TestCount from + * "../lib/TestCount.lf" + * + * reactor PrintTimer(STP_offset:time = 10 msec) extends TestCount { timer t(0, + * 1 sec); reaction(t) {= lf_print("Timer ticked at (%lld, %d).", + * lf_time_logical_elapsed(), lf_tag().microstep ); + * =} } + */ +reactor PrintTimer( + STP_offset: time = 1 sec, + start: int = 1, + stride: int = 1, + num_inputs: int = 6 +) { state count: int = start state inputs_received: int = 0 input in: int + timer t(0, 1 sec) + reaction(in) {= lf_print("Received %d.", in->value); if (in->value != self->count) { @@ -41,17 +44,16 @@ reactor PrintTimer(STP_offset:time = 1 sec, start: int = 1, stride: int = 1, num ); } =} - - timer t(0, 1 sec); + reaction(t) {= - lf_print("Timer ticked at (%lld, %d).", + lf_print("Timer ticked at (%lld, %d).", lf_time_logical_elapsed(), lf_tag().microstep ); =} } federated reactor { - c = new Count(); - p = new PrintTimer(); - c.out -> p.in; + c = new Count() + p = new PrintTimer() + c.out -> p.in } From 0833859eddfbad5c6fa2e920934a12b45aa06cec Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 17:20:54 +0200 Subject: [PATCH 489/709] fix python submodule --- .gitmodules | 2 +- .../resources/lib/py/{lf-python-support => }/lf-python-support | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename org.lflang/core/src/main/resources/lib/py/{lf-python-support => }/lf-python-support (100%) diff --git a/.gitmodules b/.gitmodules index 0b655fae19..52c3af173b 100644 --- a/.gitmodules +++ b/.gitmodules @@ -8,5 +8,5 @@ path = org.lflang/core/src/main/resources/lib/rs/reactor-rs url = https://github.com/lf-lang/reactor-rs [submodule "org.lflang/src/lib/py/lf-python-support"] - path = org.lflang/core/src/main/resources/lib/py/lf-python-support/lf-python-support + path = org.lflang/core/src/main/resources/lib/py/lf-python-support url = https://github.com/lf-lang/lf-python-support.git diff --git a/org.lflang/core/src/main/resources/lib/py/lf-python-support/lf-python-support b/org.lflang/core/src/main/resources/lib/py/lf-python-support similarity index 100% rename from org.lflang/core/src/main/resources/lib/py/lf-python-support/lf-python-support rename to org.lflang/core/src/main/resources/lib/py/lf-python-support From 306135ac0559e88c12ce302a8f755bed3502aa5e Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 18:20:19 +0200 Subject: [PATCH 490/709] cli tests --- org.lflang/cli/base/build.gradle | 11 +++++++++++ .../org/lflang}/cli/CliToolTestFixture.java | 3 +-- .../java/org/lflang/cli}/TestUtils.java | 2 +- org.lflang/cli/lfc/build.gradle | 18 ++++++++++++++++++ .../test/java/org/lflang}/cli/LfcCliTest.java | 16 +++++++--------- .../org/lflang}/cli/LfcIssueReportingTest.kt | 12 ++++-------- .../test/resources/org/lflang}/cli/colors.lf | 0 .../resources/org/lflang}/cli/colors.stderr | 0 .../resources/org/lflang}/cli/emptyFile.lf | 0 .../resources/org/lflang}/cli/emptyFile.stderr | 0 .../test/resources/org/lflang}/cli/issue490.lf | 0 .../resources/org/lflang}/cli/issue490.stderr | 0 .../org/lflang}/cli/multilineWarning.lf | 0 .../org/lflang}/cli/multilineWarning.stderr | 0 .../org/lflang}/cli/multilineWarningTooBig.lf | 0 .../lflang}/cli/multilineWarningTooBig.stderr | 0 .../resources/org/lflang}/cli/simpleWarning.lf | 0 .../org/lflang}/cli/simpleWarning.stderr | 0 .../src/test/resources/org/lflang}/cli/tabs.lf | 0 .../test/resources/org/lflang}/cli/tabs.stderr | 0 .../org/lflang}/cli/twoLineWarning.lf | 0 .../org/lflang}/cli/twoLineWarning.stderr | 0 org.lflang/cli/lff/build.gradle | 17 ++++++++++++++++- .../test/java/org/lflang}/cli/LffCliTest.java | 10 ++++------ .../org/lflang/StringsBundle.properties | 0 settings.gradle | 2 +- 26 files changed, 63 insertions(+), 28 deletions(-) rename {org.lflang.tests/src/org/lflang/tests => org.lflang/cli/base/src/testFixtures/java/org/lflang}/cli/CliToolTestFixture.java (98%) rename {org.lflang.tests/src/org/lflang/tests => org.lflang/cli/base/src/testFixtures/java/org/lflang/cli}/TestUtils.java (99%) rename {org.lflang.tests/src/org/lflang/tests => org.lflang/cli/lfc/src/test/java/org/lflang}/cli/LfcCliTest.java (96%) rename {org.lflang.tests/src/org/lflang/tests => org.lflang/cli/lfc/src/test/kotlin/org/lflang}/cli/LfcIssueReportingTest.kt (94%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/colors.lf (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/colors.stderr (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/emptyFile.lf (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/emptyFile.stderr (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/issue490.lf (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/issue490.stderr (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/multilineWarning.lf (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/multilineWarning.stderr (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/multilineWarningTooBig.lf (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/multilineWarningTooBig.stderr (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/simpleWarning.lf (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/simpleWarning.stderr (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/tabs.lf (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/tabs.stderr (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/twoLineWarning.lf (100%) rename {org.lflang.tests/resources/org/lflang/tests => org.lflang/cli/lfc/src/test/resources/org/lflang}/cli/twoLineWarning.stderr (100%) rename {org.lflang.tests/src/org/lflang/tests => org.lflang/cli/lff/src/test/java/org/lflang}/cli/LffCliTest.java (94%) rename org.lflang/core/src/main/{java => resources}/org/lflang/StringsBundle.properties (100%) diff --git a/org.lflang/cli/base/build.gradle b/org.lflang/cli/base/build.gradle index 3623efd1a2..e3b04fbf18 100644 --- a/org.lflang/cli/base/build.gradle +++ b/org.lflang/cli/base/build.gradle @@ -1,10 +1,21 @@ plugins { id 'org.lflang.java-library-conventions' id 'org.lflang.kotlin-conventions' + id 'java-test-fixtures' } dependencies { api "info.picocli:picocli:$picocliVersion" api project(':org.lflang:core') +} + +dependencies { + testFixturesImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" + testFixturesImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" + testFixturesImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" + testFixturesImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" + testFixturesImplementation "org.opentest4j:opentest4j:$openTest4jVersion" + testFixturesImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" + testFixturesImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" } \ No newline at end of file diff --git a/org.lflang.tests/src/org/lflang/tests/cli/CliToolTestFixture.java b/org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/CliToolTestFixture.java similarity index 98% rename from org.lflang.tests/src/org/lflang/tests/cli/CliToolTestFixture.java rename to org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/CliToolTestFixture.java index 257da7ad06..eab8f1aa9c 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/CliToolTestFixture.java +++ b/org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/CliToolTestFixture.java @@ -22,7 +22,7 @@ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package org.lflang.tests.cli; +package org.lflang.cli; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.MatcherAssert.assertThat; @@ -33,7 +33,6 @@ import java.io.PrintStream; import java.nio.file.Path; import org.hamcrest.Matcher; -import org.lflang.cli.Io; import org.opentest4j.AssertionFailedError; /** diff --git a/org.lflang.tests/src/org/lflang/tests/TestUtils.java b/org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/TestUtils.java similarity index 99% rename from org.lflang.tests/src/org/lflang/tests/TestUtils.java rename to org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/TestUtils.java index 9e7cb4218a..442742768f 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestUtils.java +++ b/org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/TestUtils.java @@ -22,7 +22,7 @@ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package org.lflang.tests; +package org.lflang.cli; import static org.hamcrest.MatcherAssert.assertThat; diff --git a/org.lflang/cli/lfc/build.gradle b/org.lflang/cli/lfc/build.gradle index 44416c2c47..a1be9d6244 100644 --- a/org.lflang/cli/lfc/build.gradle +++ b/org.lflang/cli/lfc/build.gradle @@ -1,12 +1,30 @@ plugins { id 'org.lflang.java-application' + id 'org.lflang.kotlin-conventions' } dependencies { implementation project(':org.lflang:cli:base') + + testImplementation(testFixtures(project(":org.lflang:cli:base"))) + testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" + testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" + testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" + testImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" + testImplementation "org.opentest4j:opentest4j:$openTest4jVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" } application { mainClass = 'org.lflang.cli.Lfc' tasks.run.workingDir = rootProject.projectDir } + +test { + useJUnitPlatform() + testLogging { + events "passed", "skipped", "failed" + showStandardStreams = true + } +} \ No newline at end of file diff --git a/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java b/org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java similarity index 96% rename from org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java rename to org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java index d9e81a0e68..27d20c6083 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/LfcCliTest.java +++ b/org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java @@ -22,15 +22,15 @@ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package org.lflang.tests.cli; +package org.lflang.cli; import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.equalTo; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.lflang.tests.TestUtils.TempDirBuilder.dirBuilder; -import static org.lflang.tests.TestUtils.TempDirChecker.dirChecker; -import static org.lflang.tests.TestUtils.isDirectory; -import static org.lflang.tests.TestUtils.isRegularFile; +import static org.lflang.cli.TestUtils.TempDirBuilder.dirBuilder; +import static org.lflang.cli.TestUtils.TempDirChecker.dirChecker; +import static org.lflang.cli.TestUtils.isDirectory; +import static org.lflang.cli.TestUtils.isRegularFile; import com.google.inject.Injector; import java.io.File; @@ -39,11 +39,9 @@ import java.util.Properties; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; -import org.lflang.LocalStrings; -import org.lflang.cli.Io; -import org.lflang.cli.Lfc; import org.lflang.generator.LFGeneratorContext.BuildParm; -import org.lflang.tests.TestUtils.TempDirBuilder; +import org.lflang.cli.TestUtils.TempDirBuilder; +import org.lflang.LocalStrings; /** * @author Clément Fournier diff --git a/org.lflang.tests/src/org/lflang/tests/cli/LfcIssueReportingTest.kt b/org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt similarity index 94% rename from org.lflang.tests/src/org/lflang/tests/cli/LfcIssueReportingTest.kt rename to org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt index a71af4581a..d8455bc7e9 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/LfcIssueReportingTest.kt +++ b/org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt @@ -21,17 +21,12 @@ * 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. */ -package org.lflang.tests.cli +package org.lflang.cli import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Test import org.lflang.LFRuntimeModule import org.lflang.LFStandaloneSetup -import org.lflang.cli.AnsiColors -import org.lflang.cli.Io -import org.lflang.cli.LFStandaloneModule -import org.lflang.cli.Lfc -import org.lflang.cli.ReportingBackend import org.opentest4j.AssertionFailedError import java.io.ByteArrayOutputStream import java.io.PrintStream @@ -124,7 +119,8 @@ class LfcIssueReportingTest { val packageName = loader.packageName.replace('.', '/') // relative to root of gradle project - val basePath = "org.lflang.tests/resources/$packageName/" + // TODO This should load the resources and copy them to a temp directory instead of reading directly + val basePath = "src/test/resources/$packageName/" val lfFile = Paths.get("$basePath/$fileBaseName.lf") val expectedPath = Paths.get("$basePath/$fileBaseName.stderr") @@ -155,6 +151,6 @@ class LfcIssueReportingTest { trim().replace(Regex("\\s+\\R"), "\n") // Replace file path with placeholder. File path is not // rendered the same on linux and windows (forward/backward slash) - .replace(lfFile.toString(), "%%%PATH.lf%%%") + .replace("%%%PATH.lf%%%", lfFile.toString()) } diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/colors.lf b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/colors.lf similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/colors.lf rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/colors.lf diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/colors.stderr b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/colors.stderr similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/colors.stderr rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/colors.stderr diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/emptyFile.lf b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.lf similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/emptyFile.lf rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.lf diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/emptyFile.stderr b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.stderr similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/emptyFile.stderr rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.stderr diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/issue490.lf b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/issue490.lf similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/issue490.lf rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/issue490.lf diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/issue490.stderr b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/issue490.stderr similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/issue490.stderr rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/issue490.stderr diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/multilineWarning.lf b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.lf similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/multilineWarning.lf rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.lf diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/multilineWarning.stderr b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.stderr similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/multilineWarning.stderr rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.stderr diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/multilineWarningTooBig.lf b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.lf similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/multilineWarningTooBig.lf rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.lf diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/multilineWarningTooBig.stderr b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.stderr similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/multilineWarningTooBig.stderr rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.stderr diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/simpleWarning.lf b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.lf similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/simpleWarning.lf rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.lf diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/simpleWarning.stderr b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.stderr similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/simpleWarning.stderr rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.stderr diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/tabs.lf b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/tabs.lf similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/tabs.lf rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/tabs.lf diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/tabs.stderr b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/tabs.stderr similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/tabs.stderr rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/tabs.stderr diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/twoLineWarning.lf b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.lf similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/twoLineWarning.lf rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.lf diff --git a/org.lflang.tests/resources/org/lflang/tests/cli/twoLineWarning.stderr b/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.stderr similarity index 100% rename from org.lflang.tests/resources/org/lflang/tests/cli/twoLineWarning.stderr rename to org.lflang/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.stderr diff --git a/org.lflang/cli/lff/build.gradle b/org.lflang/cli/lff/build.gradle index ac8e928f06..7d60a7eb32 100644 --- a/org.lflang/cli/lff/build.gradle +++ b/org.lflang/cli/lff/build.gradle @@ -4,6 +4,15 @@ plugins { dependencies { implementation project(':org.lflang:cli:base') + + testImplementation(testFixtures(project(":org.lflang:cli:base"))) + testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" + testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" + testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" + testImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" + testImplementation "org.opentest4j:opentest4j:$openTest4jVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" } application { @@ -11,4 +20,10 @@ application { tasks.run.workingDir = rootProject.projectDir } -assemble.finalizedBy installDist \ No newline at end of file +test { + useJUnitPlatform() + testLogging { + events "passed", "skipped", "failed" + showStandardStreams = true + } +} \ No newline at end of file diff --git a/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java b/org.lflang/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java similarity index 94% rename from org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java rename to org.lflang/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java index a9da20239f..e7523ce4fe 100644 --- a/org.lflang.tests/src/org/lflang/tests/cli/LffCliTest.java +++ b/org.lflang/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java @@ -22,12 +22,12 @@ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -package org.lflang.tests.cli; +package org.lflang.cli; import static org.hamcrest.CoreMatchers.containsString; import static org.hamcrest.CoreMatchers.equalTo; -import static org.lflang.tests.TestUtils.TempDirBuilder.dirBuilder; -import static org.lflang.tests.TestUtils.TempDirChecker.dirChecker; +import static org.lflang.cli.TestUtils.TempDirBuilder.dirBuilder; +import static org.lflang.cli.TestUtils.TempDirChecker.dirChecker; import java.io.File; import java.io.IOException; @@ -35,9 +35,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; import org.lflang.LocalStrings; -import org.lflang.cli.Io; -import org.lflang.cli.Lff; -import org.lflang.tests.cli.CliToolTestFixture.ExecutionResult; +import org.lflang.cli.CliToolTestFixture.ExecutionResult; /** * @author Clément Fournier diff --git a/org.lflang/core/src/main/java/org/lflang/StringsBundle.properties b/org.lflang/core/src/main/resources/org/lflang/StringsBundle.properties similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/StringsBundle.properties rename to org.lflang/core/src/main/resources/org/lflang/StringsBundle.properties diff --git a/settings.gradle b/settings.gradle index e6670589ce..28c7dbf725 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,2 +1,2 @@ rootProject.name = 'org.lflang' -include(':org.lflang:core', ':org.lflang:cli:base', ':org.lflang:cli:lfc') +include(':org.lflang:core', ':org.lflang:cli:base', ':org.lflang:cli:lfc', ':org.lflang:cli:lff') From 1c1063f6605addcbe5ea6068006e9427d2233da5 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 18:32:32 +0200 Subject: [PATCH 491/709] test conventions --- ...flang.java-application-conventions.gradle} | 1 + ...org.lflang.java-library-conventions.gradle | 1 + .../groovy/org.lflang.test-conventions.gradle | 29 +++++++++++++++++++ org.lflang/cli/base/build.gradle | 11 ------- org.lflang/cli/lfc/build.gradle | 17 +---------- org.lflang/cli/lff/build.gradle | 2 +- org.lflang/core/build.gradle | 16 +--------- 7 files changed, 34 insertions(+), 43 deletions(-) rename buildSrc/src/main/groovy/{org.lflang.java-application.gradle => org.lflang.java-application-conventions.gradle} (73%) create mode 100644 buildSrc/src/main/groovy/org.lflang.test-conventions.gradle diff --git a/buildSrc/src/main/groovy/org.lflang.java-application.gradle b/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle similarity index 73% rename from buildSrc/src/main/groovy/org.lflang.java-application.gradle rename to buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle index 2beb5c887c..d8e3f5f76a 100644 --- a/buildSrc/src/main/groovy/org.lflang.java-application.gradle +++ b/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle @@ -1,6 +1,7 @@ plugins { id 'org.lflang.java-conventions' id 'application' + id 'org.lflang.test-conventions' } assemble.finalizedBy installDist \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle index a5c43751ee..4f3b10c399 100644 --- a/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle @@ -1,4 +1,5 @@ plugins { id 'org.lflang.java-conventions' id 'java-library' + id 'org.lflang.test-conventions' } \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle new file mode 100644 index 0000000000..1055ca0dbc --- /dev/null +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -0,0 +1,29 @@ +plugins { + id 'java-test-fixtures' +} + +dependencies { + testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" + testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" + testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" + testImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" + testImplementation "org.opentest4j:opentest4j:$openTest4jVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" + testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" + + testFixturesImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" + testFixturesImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" + testFixturesImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" + testFixturesImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" + testFixturesImplementation "org.opentest4j:opentest4j:$openTest4jVersion" + testFixturesImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" + testFixturesImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" +} + +test { + useJUnitPlatform() + testLogging { + events "passed", "skipped", "failed" + showStandardStreams = true + } +} \ No newline at end of file diff --git a/org.lflang/cli/base/build.gradle b/org.lflang/cli/base/build.gradle index e3b04fbf18..74939fc8f5 100644 --- a/org.lflang/cli/base/build.gradle +++ b/org.lflang/cli/base/build.gradle @@ -1,7 +1,6 @@ plugins { id 'org.lflang.java-library-conventions' id 'org.lflang.kotlin-conventions' - id 'java-test-fixtures' } dependencies { @@ -9,13 +8,3 @@ dependencies { api project(':org.lflang:core') } - -dependencies { - testFixturesImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" - testFixturesImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" - testFixturesImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" - testFixturesImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" - testFixturesImplementation "org.opentest4j:opentest4j:$openTest4jVersion" - testFixturesImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" - testFixturesImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" -} \ No newline at end of file diff --git a/org.lflang/cli/lfc/build.gradle b/org.lflang/cli/lfc/build.gradle index a1be9d6244..ca59afece9 100644 --- a/org.lflang/cli/lfc/build.gradle +++ b/org.lflang/cli/lfc/build.gradle @@ -1,5 +1,5 @@ plugins { - id 'org.lflang.java-application' + id 'org.lflang.java-application-conventions' id 'org.lflang.kotlin-conventions' } @@ -7,24 +7,9 @@ dependencies { implementation project(':org.lflang:cli:base') testImplementation(testFixtures(project(":org.lflang:cli:base"))) - testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" - testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" - testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" - testImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" - testImplementation "org.opentest4j:opentest4j:$openTest4jVersion" - testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" - testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" } application { mainClass = 'org.lflang.cli.Lfc' tasks.run.workingDir = rootProject.projectDir } - -test { - useJUnitPlatform() - testLogging { - events "passed", "skipped", "failed" - showStandardStreams = true - } -} \ No newline at end of file diff --git a/org.lflang/cli/lff/build.gradle b/org.lflang/cli/lff/build.gradle index 7d60a7eb32..711eadcc46 100644 --- a/org.lflang/cli/lff/build.gradle +++ b/org.lflang/cli/lff/build.gradle @@ -1,5 +1,5 @@ plugins { - id 'org.lflang.java-application' + id 'org.lflang.java-application-conventions' } dependencies { diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index 8a290804a3..06a1770b62 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -76,18 +76,4 @@ tasks.register('generateXtextLanguage', JavaExec) { compileJava.dependsOn(generateXtextLanguage) compileKotlin.dependsOn(generateXtextLanguage) processResources.dependsOn(generateXtextLanguage) -clean.dependsOn(cleanGenerateXtextLanguage) - -dependencies { - testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" - testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" - testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" - testImplementation "org.junit.platform:junit-platform-engine:$jUnitPlatformVersion" - testImplementation "org.opentest4j:opentest4j:$openTest4jVersion" - testImplementation "org.eclipse.xtext:org.eclipse.xtext.testing:$xtextVersion" - testImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" -} - -test { - useJUnitPlatform() -} \ No newline at end of file +clean.dependsOn(cleanGenerateXtextLanguage) \ No newline at end of file From 2f4826b44acbfe5a9d45690119896ba1c2aa1396 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 25 May 2023 19:22:59 +0200 Subject: [PATCH 492/709] spotless --- build.gradle | 26 +++++++++++++++++++ buildSrc/build.gradle | 1 + buildSrc/gradle.properties | 1 + .../groovy/org.lflang.java-conventions.gradle | 14 +++++++++- .../src/main/java/lfformat/LfFormatStep.java | 17 +++++------- gradle.properties | 1 - .../test/java/org/lflang/cli/LfcCliTest.java | 4 +-- org.lflang/cli/lff/build.gradle | 2 +- org.lflang/core/build.gradle | 3 ++- 9 files changed, 52 insertions(+), 17 deletions(-) create mode 100644 build.gradle diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000000..87eaec93ce --- /dev/null +++ b/build.gradle @@ -0,0 +1,26 @@ +import lfformat.LfFormatStep + +plugins { + id "com.diffplug.spotless" +} + +spotless { + format 'misc', { + // define the files to apply `misc` to + target '*.gradle', '*.md', '.gitignore' + + // define the steps to apply to those files + trimTrailingWhitespace() + indentWithSpaces() // or spaces. Takes an integer argument if you don't like 4 + endWithNewline() + } + + format 'linguaFranca', { + addStep(LfFormatStep.create(project.projectDir)) + target 'test/*/src/**/*.lf' // you have to set the target manually + targetExclude 'test/**/failing/**' + } + +} + +spotlessLinguaFranca.dependsOn(":org.lflang:cli:lff:installDist") diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle index 162b911e9c..972fd06a06 100644 --- a/buildSrc/build.gradle +++ b/buildSrc/build.gradle @@ -14,4 +14,5 @@ dependencies { implementation group: 'com.diffplug.spotless', name: 'spotless-lib-extra', version: spotlessLibVersion implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion" + implementation "com.diffplug.spotless:spotless-plugin-gradle:$spotlessVersion" } \ No newline at end of file diff --git a/buildSrc/gradle.properties b/buildSrc/gradle.properties index ed9731fc68..149718da23 100644 --- a/buildSrc/gradle.properties +++ b/buildSrc/gradle.properties @@ -1,3 +1,4 @@ [versions] +spotlessVersion=6.11.0 spotlessLibVersion=2.30.0 kotlinVersion=1.6.21 diff --git a/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle index ced3e9d24e..a600ba4ef8 100644 --- a/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle @@ -1,5 +1,6 @@ plugins { id 'java' + id 'com.diffplug.spotless' } repositories { @@ -8,4 +9,15 @@ repositories { maven { url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" } -} \ No newline at end of file +} + +spotless { + java { + targetExclude 'src-gen/**', 'test-gen/**' + // The following is quoted from https://github.com/google/google-java-format + // "Note: There is no configurability as to the formatter's algorithm for formatting. + // This is a deliberate design decision to unify our code formatting on a single format." + googleJavaFormat(googleJavaFormatVersion).reflowLongStrings() + formatAnnotations() + } +} diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index 4fb6806dc0..5695dc2b1e 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -53,27 +53,22 @@ public String format( /** Run the formatter on the given file and return the resulting process handle. */ private Process runFormatter(File file) throws IOException { - final Path resourcePath = projectRoot.resolve(Path.of("org.lflang", "src", "org", "lflang")); - final ResourceBundle properties = - ResourceBundle.getBundle( - "StringsBundle", - Locale.getDefault(), - new URLClassLoader(new URL[] {resourcePath.toUri().toURL()})); final Path lffPath = Path.of( "org.lflang", + "cli", + "lff", "build", - "libs", - String.format("org.lflang-%s.jar", properties.getString("VERSION"))); + "install", + "lff", + "bin", + "lff"); // It looks silly to invoke Java from Java, but it is necessary in // order to break the circularity of needing the program to be built // in order for it to be built. return new ProcessBuilder( List.of( - "java", - "-cp", lffPath.toString(), - "org.lflang.cli.Lff", "--dry-run", file.getAbsoluteFile().toString())) .start(); diff --git a/gradle.properties b/gradle.properties index f1290a2281..732e9e6c38 100644 --- a/gradle.properties +++ b/gradle.properties @@ -18,7 +18,6 @@ openTest4jVersion=1.2.0 picocliVersion=4.7.0 resourcesVersion=3.16.0 shadowJarVersion=7.1.2 -spotlessVersion=6.11.0 xtextGradleVersion=3.0.0 xtextVersion=2.28.0 klighdVersion=2.2.1-SNAPSHOT diff --git a/org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java b/org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java index 27d20c6083..48946eba55 100644 --- a/org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java +++ b/org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java @@ -39,9 +39,9 @@ import java.util.Properties; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.io.TempDir; -import org.lflang.generator.LFGeneratorContext.BuildParm; -import org.lflang.cli.TestUtils.TempDirBuilder; import org.lflang.LocalStrings; +import org.lflang.cli.TestUtils.TempDirBuilder; +import org.lflang.generator.LFGeneratorContext.BuildParm; /** * @author Clément Fournier diff --git a/org.lflang/cli/lff/build.gradle b/org.lflang/cli/lff/build.gradle index 711eadcc46..b2a597fa05 100644 --- a/org.lflang/cli/lff/build.gradle +++ b/org.lflang/cli/lff/build.gradle @@ -26,4 +26,4 @@ test { events "passed", "skipped", "failed" showStandardStreams = true } -} \ No newline at end of file +} diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index 06a1770b62..21b8e562b8 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -76,4 +76,5 @@ tasks.register('generateXtextLanguage', JavaExec) { compileJava.dependsOn(generateXtextLanguage) compileKotlin.dependsOn(generateXtextLanguage) processResources.dependsOn(generateXtextLanguage) -clean.dependsOn(cleanGenerateXtextLanguage) \ No newline at end of file +clean.dependsOn(cleanGenerateXtextLanguage) +spotlessJava.mustRunAfter(generateXtextLanguage) From 6aefb0e83127b6ddfa25e2dcb82c4616bbc6654d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 25 May 2023 10:25:39 -0700 Subject: [PATCH 493/709] Give jobs descriptive names. --- .github/workflows/build-trace-tools.yml | 2 +- .github/workflows/build.yml | 2 +- .github/workflows/c-arduino-tests.yml | 2 +- .github/workflows/c-zephyr-tests.yml | 2 +- .github/workflows/check-format.yml | 2 +- .github/workflows/cli-tests.yml | 2 +- .github/workflows/cpp-ros2-tests.yml | 4 ++-- .github/workflows/cpp-tests.yml | 2 +- .github/workflows/extract-ref.yml | 2 +- .github/workflows/latest-release.yml | 2 +- .github/workflows/lsp-tests.yml | 2 +- .github/workflows/py-tests.yml | 2 +- .github/workflows/rs-tests.yml | 2 +- .github/workflows/serialization-tests.yml | 2 +- .github/workflows/ts-tests.yml | 2 +- .github/workflows/unit-tests.yml | 2 +- 16 files changed, 17 insertions(+), 17 deletions(-) diff --git a/.github/workflows/build-trace-tools.yml b/.github/workflows/build-trace-tools.yml index 86d8724481..207fe4deb7 100644 --- a/.github/workflows/build-trace-tools.yml +++ b/.github/workflows/build-trace-tools.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - run: + build-trace-tools: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 767df01fa1..145bbbbdac 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -13,7 +13,7 @@ on: workflow_dispatch: jobs: - run: + build-toolchain: runs-on: ubuntu-latest steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index ceb90159bc..873c81b871 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -22,7 +22,7 @@ on: type: boolean jobs: - run: + c-arduino: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 3b7a76feee..288dd54b6d 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -18,7 +18,7 @@ on: type: string jobs: - run: + c-zephyr: runs-on: ubuntu-latest steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/check-format.yml b/.github/workflows/check-format.yml index 8c022f90a5..2ecbb389fa 100644 --- a/.github/workflows/check-format.yml +++ b/.github/workflows/check-format.yml @@ -4,7 +4,7 @@ on: workflow_call: jobs: - run: + check-format: runs-on: ubuntu-latest steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 2a2c3e32e4..452b08faf6 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - run: + cli: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/cpp-ros2-tests.yml b/.github/workflows/cpp-ros2-tests.yml index 93054676b5..e48ea2e360 100644 --- a/.github/workflows/cpp-ros2-tests.yml +++ b/.github/workflows/cpp-ros2-tests.yml @@ -11,10 +11,10 @@ on: type: string jobs: - run: + cpp-ros2: runs-on: ubuntu-latest steps: - - name: Check out lingual-franca repository + - name: Check out lingua-franca repository uses: actions/checkout@v3 with: repository: lf-lang/lingua-franca diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index 4b402ed845..aa138feaaf 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -15,7 +15,7 @@ on: type: boolean jobs: - run: + cpp: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/extract-ref.yml b/.github/workflows/extract-ref.yml index 78b3470ceb..c3c738048f 100644 --- a/.github/workflows/extract-ref.yml +++ b/.github/workflows/extract-ref.yml @@ -13,7 +13,7 @@ on: value: ${{ jobs.run.outputs.ref }} jobs: - run: + extract-ref: runs-on: ubuntu-latest outputs: ref: ${{ steps.read.outputs.ref }} diff --git a/.github/workflows/latest-release.yml b/.github/workflows/latest-release.yml index 2ce4fe03da..d327f8f722 100644 --- a/.github/workflows/latest-release.yml +++ b/.github/workflows/latest-release.yml @@ -18,7 +18,7 @@ on: workflow_dispatch: jobs: - run: + get-latest-release: runs-on: ubuntu-latest outputs: ref: ${{ steps.find.outputs.ref }} diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index 76ecd3f7eb..aa2fcd7f16 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - run: + lsp: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index e8ea1eac77..c4038d27af 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -18,7 +18,7 @@ on: type: boolean jobs: - run: + py: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index dae04b2dc8..f4bc181dda 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -21,7 +21,7 @@ on: type: boolean jobs: - run: + rs: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 89f1ad735c..dffbe83e1f 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -8,7 +8,7 @@ on: type: string jobs: - run: + serialization: runs-on: ubuntu-latest steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index c70a356a13..22379b2f5d 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - run: + ts: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index dd7613f8af..c8cbe1fd1f 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - run: + unit-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} From bf4ac760e074e418e846d2550f232f1594be3cd2 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 25 May 2023 13:41:19 -0700 Subject: [PATCH 494/709] Try qemu_riscv32 instead --- org.lflang.tests/src/org/lflang/tests/Configurators.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/Configurators.java b/org.lflang.tests/src/org/lflang/tests/Configurators.java index a5db8f2abf..9df77e134a 100644 --- a/org.lflang.tests/src/org/lflang/tests/Configurators.java +++ b/org.lflang.tests/src/org/lflang/tests/Configurators.java @@ -77,7 +77,7 @@ public static boolean makeZephyrCompatible(LFTest test) { test.getContext().getArgs().setProperty("tracing", "false"); test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; test.getContext().getTargetConfig().platformOptions.flash = false; - test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; + test.getContext().getTargetConfig().platformOptions.board = "qemu_riscv32"; return true; } /** From 7e34bf104b8eb10d60d9ecbc6165fa4fe5a78922 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 25 May 2023 21:28:09 -0700 Subject: [PATCH 495/709] Fix for #1785 --- .../src/org/lflang/federated/generator/FedGenerator.java | 8 +++++++- org.lflang/src/org/lflang/generator/c/CGenerator.java | 5 ++--- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java index 08a1fcf6e8..392f1f551e 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java +++ b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java @@ -161,6 +161,12 @@ public boolean doGenerate(Resource resource, LFGeneratorContext context) throws subContexts -> { createDockerFiles(context, subContexts); generateLaunchScript(); + // If an error has occurred during codegen of any federate, report it. + subContexts.forEach(c -> { + if (c.getErrorReporter().getErrorsOccurred()) { + context.getErrorReporter().reportError("Failure during code generation of " + c.getFileConfig().srcFile); + } + }); }); context.finish(Status.COMPILED, codeMapMap); @@ -321,7 +327,7 @@ public TargetConfig getTargetConfig() { try { compileThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS); } catch (Exception e) { - Exceptions.sneakyThrow(e); + context.getErrorReporter().reportError("Failure during code generation."); } finally { finalizer.accept(subContexts); } diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index e8606eee9a..cc3ccecc6f 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -416,9 +416,8 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { copyTargetFiles(); generateHeaders(); code.writeToFile(targetFile); - } catch (IOException e) { - //noinspection ThrowableNotThrown,ResultOfMethodCallIgnored - Exceptions.sneakyThrow(e); + } catch (Exception e) { + errorReporter.reportError(e.getMessage()); } // Create docker file. From 55c70ba431ff6e5e2fbe2a5955bbaaff6dfd8412 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 25 May 2023 21:33:26 -0700 Subject: [PATCH 496/709] Apply formatter --- .../lflang/federated/generator/FedGenerator.java | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java index 392f1f551e..b59a390451 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java +++ b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java @@ -26,7 +26,6 @@ import org.eclipse.xtext.resource.XtextResource; import org.eclipse.xtext.resource.XtextResourceSet; import org.eclipse.xtext.util.RuntimeIOException; -import org.eclipse.xtext.xbase.lib.Exceptions; import org.lflang.ErrorReporter; import org.lflang.FileConfig; import org.lflang.LFStandaloneSetup; @@ -162,11 +161,15 @@ public boolean doGenerate(Resource resource, LFGeneratorContext context) throws createDockerFiles(context, subContexts); generateLaunchScript(); // If an error has occurred during codegen of any federate, report it. - subContexts.forEach(c -> { - if (c.getErrorReporter().getErrorsOccurred()) { - context.getErrorReporter().reportError("Failure during code generation of " + c.getFileConfig().srcFile); - } - }); + subContexts.forEach( + c -> { + if (c.getErrorReporter().getErrorsOccurred()) { + context + .getErrorReporter() + .reportError( + "Failure during code generation of " + c.getFileConfig().srcFile); + } + }); }); context.finish(Status.COMPILED, codeMapMap); From f47fe6f8a596b2389476839ba779cb77215d7dee Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 25 May 2023 22:20:35 -0700 Subject: [PATCH 497/709] Add detail to error message. I am not passing the error message through the error reporter, which is messy, but I think that is OK. This fault condition "should never happen" so if we reach it then the compiler is already misbehaving. --- .../src/org/lflang/federated/generator/FedGenerator.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java index b59a390451..6656a489f8 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedGenerator.java +++ b/org.lflang/src/org/lflang/federated/generator/FedGenerator.java @@ -330,7 +330,8 @@ public TargetConfig getTargetConfig() { try { compileThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS); } catch (Exception e) { - context.getErrorReporter().reportError("Failure during code generation."); + context.getErrorReporter().reportError("Failure during code generation: " + e.getMessage()); + e.printStackTrace(); } finally { finalizer.accept(subContexts); } From c0f8ec88a30a91c28eb46f8219bc5c4b5e9820fa Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 25 May 2023 23:14:19 -0700 Subject: [PATCH 498/709] Rethrow RuntimeException --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index cc3ccecc6f..1c8988b86d 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -73,6 +73,7 @@ import org.lflang.generator.ParameterInstance; import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; +import org.lflang.generator.ReactionInstance.Runtime; import org.lflang.generator.ReactorInstance; import org.lflang.generator.TargetTypes; import org.lflang.generator.TimerInstance; @@ -416,8 +417,11 @@ public void doGenerate(Resource resource, LFGeneratorContext context) { copyTargetFiles(); generateHeaders(); code.writeToFile(targetFile); - } catch (Exception e) { + } catch (IOException e) { + errorReporter.reportError(e.getMessage()); + } catch (RuntimeException e) { errorReporter.reportError(e.getMessage()); + throw e; } // Create docker file. From 5121d64173651bb76dd5f9f0bde6564fc362e4d9 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Thu, 25 May 2023 23:39:12 -0700 Subject: [PATCH 499/709] Apply formatter --- org.lflang/src/org/lflang/generator/c/CGenerator.java | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index 1c8988b86d..a8aeb271b5 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -73,7 +73,6 @@ import org.lflang.generator.ParameterInstance; import org.lflang.generator.PortInstance; import org.lflang.generator.ReactionInstance; -import org.lflang.generator.ReactionInstance.Runtime; import org.lflang.generator.ReactorInstance; import org.lflang.generator.TargetTypes; import org.lflang.generator.TimerInstance; From 2be77e07abc636824ee3bd2ff42bb0393857d6db Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 10:27:20 +0200 Subject: [PATCH 500/709] update launch scripts, remove unneeded scripts --- bin/build-lf-cli | 1 - bin/lfc | 2 +- bin/lfc.ps1 | 2 +- bin/lff | 2 +- bin/lff.ps1 | 2 +- bin/measure-lf-time | 196 ------------------ bin/run-lf-tests | 30 --- bin/run-lf-tests.ps1 | 16 -- bin/run-multiple-times | 6 - bin/run-multiple-times.ps1 | 7 - .../src/main/java/lfformat/LfFormatStep.java | 2 +- lib/scripts/build.sh | 117 ----------- lib/scripts/include.sh | 123 ----------- lib/scripts/launch.ps1 | 71 ------- {bin => util/scripts}/bump-versions | 0 {lib => util}/scripts/launch-fedsd.sh | 0 util/scripts/launch.ps1 | 39 ++++ {lib => util}/scripts/launch.sh | 16 +- 18 files changed, 54 insertions(+), 578 deletions(-) delete mode 120000 bin/build-lf-cli delete mode 100755 bin/measure-lf-time delete mode 100755 bin/run-lf-tests delete mode 100644 bin/run-lf-tests.ps1 delete mode 100755 bin/run-multiple-times delete mode 100644 bin/run-multiple-times.ps1 delete mode 100755 lib/scripts/build.sh delete mode 100644 lib/scripts/include.sh delete mode 100644 lib/scripts/launch.ps1 rename {bin => util/scripts}/bump-versions (100%) rename {lib => util}/scripts/launch-fedsd.sh (100%) create mode 100644 util/scripts/launch.ps1 rename {lib => util}/scripts/launch.sh (87%) diff --git a/bin/build-lf-cli b/bin/build-lf-cli deleted file mode 120000 index 55c54a4b7a..0000000000 --- a/bin/build-lf-cli +++ /dev/null @@ -1 +0,0 @@ -../lib/scripts/build.sh \ No newline at end of file diff --git a/bin/lfc b/bin/lfc index c22080b02d..1a3eb8bc0d 120000 --- a/bin/lfc +++ b/bin/lfc @@ -1 +1 @@ -../lib/scripts/launch.sh \ No newline at end of file +../util/scripts/launch.sh \ No newline at end of file diff --git a/bin/lfc.ps1 b/bin/lfc.ps1 index a09c91759c..90e6f9876a 100644 --- a/bin/lfc.ps1 +++ b/bin/lfc.ps1 @@ -4,6 +4,6 @@ # Usage: Usage: lfc [options] files... #========================================================== -$launchScript="$PSScriptRoot\..\lib\scripts\launch.ps1" +$launchScript="$PSScriptRoot\..\util\scripts\launch.ps1" # PS requires spattling: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_Splatting?view=powershell-7.2 . $launchScript @args diff --git a/bin/lff b/bin/lff index c22080b02d..1a3eb8bc0d 120000 --- a/bin/lff +++ b/bin/lff @@ -1 +1 @@ -../lib/scripts/launch.sh \ No newline at end of file +../util/scripts/launch.sh \ No newline at end of file diff --git a/bin/lff.ps1 b/bin/lff.ps1 index d73b7357eb..54ce9397f4 100644 --- a/bin/lff.ps1 +++ b/bin/lff.ps1 @@ -4,6 +4,6 @@ # Usage: Usage: lff [options] files... #========================================================== -$launchScript="$PSScriptRoot\..\lib\scripts\launch.ps1" +$launchScript="$PSScriptRoot\..\util\scripts\launch.ps1" # PS requires spattling: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_Splatting?view=powershell-7.2 . $launchScript @args diff --git a/bin/measure-lf-time b/bin/measure-lf-time deleted file mode 100755 index 2579c99fb1..0000000000 --- a/bin/measure-lf-time +++ /dev/null @@ -1,196 +0,0 @@ -#!/bin/bash - -#========================================================== -# Description: Measure the execution time of a given -# Lingua Franca program. This is achieved -# by running the binary for a number of times -# Author: Soroush Bateni -# Usage: measure-lf-time [options] file... -#========================================================== - -# FIXME: This script currently looks for "Elapsed physical time (in nsec):" -# which are only produced for the C and Python targets. - -# The column number of the time value in an LF program's output line that begins -# with "---- Elapsed physical time (in nsec)". This line is currently only -# printed at the end of the execution of a C or Python target program. -# Currently, the 7th column contains the time value: -# ---- Elapsed physical time (in nsec): xxx -# ^1 ^2 ^3 ^4 ^5 ^6 ^7 -time_col=7; - -set -euo pipefail - -# Print message explaining the arguments -function usage() { - echo "Usage: measure-lf-time [options] [Binary files]" - echo "Binary files: binaries for Lingua Franca programs." - echo "Options:" - echo " -n | --number-of-executions num Run the [generated] binary num times (default is 10)." - echo " -l | --log Store the output of the commands in directory called \"logs\"." - echo " -h | --help Display this information." - echo " -c | --command cmd Run a command a number of times instead of the binary." -} - -# Exit with message and error code 1. -function error_exit() { - 1>&2 echo "compilation terminated." - exit 1 -} - -# Report error. -function error() { - 1>&2 echo -e "\e[1mmeasure-lf-time: \e[31merror: \e[0m$1" -} - -# Report fatal error. -function fatal_error() { - 1>&2 echo -e "\e[1mmeasure-lf-time: \e[31mfatal error: \e[0m$1" -} - -# Report that the given file cannot be found. -function file_not_found() { - error "$1: No such file or directory" - no_files -} - -# Report that a value is missing after a given flag. -function missing_value() { - 1>&2 echo "missing value after flag: '"$1"'" - fatal_error "malformed arguments" -} - -# Process benchmark args -number_of_executions=10 -files=() -log=false -commands=() - -while [[ "$#" -gt 0 ]]; do - case $1 in - -n | --number-of-executions ) - opt=$1 - shift - if [[ $1 == -* ]]; then - missing_value $opt - error_exit - else - number_of_executions=$1 - fi - ;; - -h | --help ) - usage - exit 0 - ;; - -l | --log ) - log=true - ;; - -c | --command ) - opt=$1 - shift - if [[ $1 == -* ]]; then - missing_value $opt - error_exit - else - commands+=( "$1" ) - fi - ;; - -* ) - 1>&2 echo "Unknown parameter passed: $1" - usage - error_exit - ;; - * ) - if [[ -f "$1" ]]; then - files+=( $1 ) - else - file_not_found $1 - usage - error_exit - fi - esac - shift -done - -entries=${#files[@]} -if [ ${#commands[@]} -lt 1 ]; then - # If command is not given by the user - # check if the given binary file exists. - # Exit if no input files are given. - if [[ ${entries} -lt 1 ]]; then - fatal_error "no input files" - usage - error_exit - fi -else - entries=${#commands[@]} -fi - - -# Create a logs directory -mkdir -p logs; - -# Run benchmark for the given file entries. -for (( i=0; i<$entries; i++ )); do \ - command_to_execute="" - if [ ! ${#commands[@]} -lt 1 ]; then - command_to_execute="${commands[$i]}" - else - command_to_execute="${files[$i]}" - fi - benchmark=$(for k in $(eval echo {1..$number_of_executions}); do - $command_to_execute - done) - if [ "$log" = true ] ; then - name_with_spaces=${command_to_execute##*/} - echo "$benchmark" &> "logs/${name_with_spaces//[[:blank:]]/}-`date +"date-%m-%d-%Y-time-%H-%M-%S"`.log" - fi - - # Print the headers - awk 'BEGIN {printf "%-40s %-15s %-15s %-15s %-15s\n", "Benchmark (in nsecs)", "Average", "Minimum", "Maximum", "Median"}' - - results=$(echo "$benchmark" | grep "Elapsed physical time (in nsec):" | - awk -v time_col="$time_col" -v command_to_execute="$command_to_execute" ' - # In the beginning - !i++{ - # Remove the , in the number - gsub(/,/,"", $time_col); - # And set initial values of min and max - min=$time_col+0; - max=$time_col+0; - } - # Then - { - # Remove the , in the number - gsub(/,/,"",$time_col); - # Add numbers in each row to sum - sum+=$time_col; - # Calculate new min - min=($time_col+0<=0+min) ? $time_col:min; - # Calculate new max - max=($time_col+0>=0+max) ? $time_col:max; - } - # Print the results in the output - END { - printf "%-40s %-15s %-15s %-15s", command_to_execute, sum/NR, min, max - } - ') - median=$(echo "$benchmark" | grep "Elapsed physical time (in nsec):" | - awk -v time_col="$time_col" ' - { - # Remove the , in the number - gsub(/,/,"",$time_col); - # Store the physical execution time in result - # for each row - result[NR]=$time_col+0; - } - END { - if (NR % 2) { - printf " %-15s\n", result[(NR + 1) / 2]; - } else { - printf " %-15s\n", (result[(NR / 2)] + result[(NR / 2) + 1]) / 2.0; - } - } - ') - echo -e "$results$median" -done \ No newline at end of file diff --git a/bin/run-lf-tests b/bin/run-lf-tests deleted file mode 100755 index d5f3a501db..0000000000 --- a/bin/run-lf-tests +++ /dev/null @@ -1,30 +0,0 @@ -#!/bin/bash - -#========================================================== -# Description: Run all tests for a given LF target. -# Author: Marten Lohstroh -# Usage: run-lf-tests [TARGET] -#========================================================== - -pushd () { - command pushd "$@" > /dev/null -} - -popd () { - command popd "$@" > /dev/null -} - -if [ "$(dirname "$0")" == '.' ]; then - base="../"; -else - suffix=${0#$(dirname "$(dirname "$0")")/}; - base="${0%$suffix}"; -fi - -if [ "$1" == '' ]; then - echo "Usage: run-lf-tests [target]"; -else - pushd "$base" - ./gradlew clean test --tests org.lflang.tests.runtime."$1"Test - popd -fi diff --git a/bin/run-lf-tests.ps1 b/bin/run-lf-tests.ps1 deleted file mode 100644 index 4cce0aab1b..0000000000 --- a/bin/run-lf-tests.ps1 +++ /dev/null @@ -1,16 +0,0 @@ -#========================================================== -# Description: Run all tests for a given LF target. -# Author: Christian Menard -# Usage: run-lf-tests [TARGET] -#========================================================== - -$base="$PSScriptRoot\.." - -if ($args.count -ne 1) { - Write-Host "Usage: run-lf-tests [target]" -} else { - $old_pwd = $pwd - cd $base - & .\gradlew.bat clean test --tests "org.lflang.tests.runtime.${args[0]}Test" - cd $old_pwd -} \ No newline at end of file diff --git a/bin/run-multiple-times b/bin/run-multiple-times deleted file mode 100755 index e2c08be133..0000000000 --- a/bin/run-multiple-times +++ /dev/null @@ -1,6 +0,0 @@ -#!/bin/bash -# A handy bash script that will run a command multiple times -# Usage: run-multiple-time command number_of_times -for k in $(eval echo {1..$2}); do - $1 -done \ No newline at end of file diff --git a/bin/run-multiple-times.ps1 b/bin/run-multiple-times.ps1 deleted file mode 100644 index ede1ca6ace..0000000000 --- a/bin/run-multiple-times.ps1 +++ /dev/null @@ -1,7 +0,0 @@ -# A handy script that will run a command multiple times -# Usage: run-multiple-times.ps1 command number_of_times -$executable=$args[0] -$number_of_times=$args[1] -for (($k = 0); $k -lt $number_of_times; $k++) { - Invoke-Expression $executable -} diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index 5695dc2b1e..fcc15feaf1 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -46,7 +46,7 @@ public String format( } int returnCode = p.waitFor(); if (returnCode != 0) { - throw new RuntimeException("Failed to reformat file."); + throw new RuntimeException("Failed to reformat file. Exit code: " + returnCode + " Output: " + output.toString()); } return output.toString(); } diff --git a/lib/scripts/build.sh b/lib/scripts/build.sh deleted file mode 100755 index 52cc403851..0000000000 --- a/lib/scripts/build.sh +++ /dev/null @@ -1,117 +0,0 @@ -#!/bin/bash - -#============================================================================ -# Description: Build the Lingua Franca compiler. -# Authors: Marten Lohstroh, Mehrdad Niknami, Christian Menard -# Usage: build-lfc [options] [[-r | --run] [lfc-args]] -#============================================================================ - -#============================================================================ -# Preamble -#============================================================================ - -# Find the directory in which this script resides in a way that is compatible -# with MacOS, which has a `readlink` implementation that does not support the -# necessary `-f` flag to canonicalize by following every symlink in every -# component of the given name recursively. -# This solution, adapted from an example written by Geoff Nixon, ia POSIX- -# compliant and robust to symbolic links. If a chain of more than 1000 links -# is encountered, we return. - -if [[ "$0" == *build-lfc ]]; then - echo -e "\033[33mWarning; buid-lfc is deprecated! Please use build-lf-cli instead.\033[0m" -fi - -find_dir() ( - start_dir=$PWD - cd "$(dirname "$1")" - link=$(readlink "$(basename "$1")") - count=0 - while [ "${link}" ]; do - if [[ "${count}" -lt 1000 ]]; then - cd "$(dirname "${link}")" - link=$(readlink "$(basename "$1")") - ((count++)) - else - return - fi - done - real_path="$PWD/$(basename "$1")" - cd "${start_dir}" - echo `dirname "${real_path}"` -) - -# Report fatal error and exit. -function fatal_error() { - 1>&2 echo -e "\e[1mlfc: \e[31mfatal error: \e[0m$1" - exit 1 -} - -rel_path="/lib/scripts" -abs_path="$(find_dir "$0")" - -if [[ "${abs_path}" ]]; then - base=`dirname $(dirname ${abs_path})` - source "${base}/${rel_path}/include.sh" -else - fatal_error "Unable to determine absolute path to $0." -fi -#============================================================================ - -# Check whether sources are present and exit if they are not. -if [ ! "$(get_src_dir)" ]; then - fatal_error "Cannot find the Lingua Franca sources." -fi - -# Print message explaining the CLI args. -function usage() { - echo "Usage: build-lf-cli [options] [lfc-args]]" - echo "Options:" - echo " -c | --clean Build entirely from scratch." - echo " -h | --help Display this information." - echo " -o | --offline Use cached libraries." - echo " -s | --stacktrace Provide stacktrace of build errors." -} - -flags=" "; -clean=false -run=false -args=() -while [[ "$#" -gt 0 ]]; do - case $1 in - -o | --offline ) - flags=$flags"--offline " - ;; - -s | --stacktrace ) - flags=$flags"--stacktrace " - ;; - -c | --clean ) - clean=true - ;; - -h | --help ) - usage - exit 0 - ;; - *) - usage - exit 1 - ;; - esac - shift -done - -# Perform cleanup up if requested. -if [[ "${clean}" == "true" ]]; then - echo "Performing cleanup..." - "${base}/gradlew" -p "${base}" clean; -fi - -# Check if jar is missing or out-of-date compared to the sources. -find_cmd=find -# Do not use the built-in Windows 'find' command, which is different. -if [ "${OSTYPE}" = "msys" ]; then - find_cmd="/usr/bin/${FIND}" -fi - -jar_path="$(get_jar_path)" -"${base}/gradlew" ${flags} -p "${base}" buildAll diff --git a/lib/scripts/include.sh b/lib/scripts/include.sh deleted file mode 100644 index aa0a6ef065..0000000000 --- a/lib/scripts/include.sh +++ /dev/null @@ -1,123 +0,0 @@ -#!/bin/bash - -#============================================================================ -# Description: Initialize an environment for Lingua Franca helper scripts. -# Authors: Marten Lohstroh, Mehrdad Niknami, Christian Menard -# Usage: Source this file at the beginning of other scripts to access -# the functions and variables defined in this script. -#============================================================================ - -# Set up the environment. - -# -e: Immediately exit if any command has a non-zero exit status. -# -u: Error on referencing unset variables. -# -o pipefail: Prevents errors in a pipeline from being masked. -set -euo pipefail - -[[ $(type -t fatal_error) == function ]] || echo "Warning: function 'fatal_error' is not defined." - -[[ "${base}" ]] || fatal_error "Unable to determine absolute path to $0." - -# Paths (relative to ${base}), which is assumed to have been set. -src_pkg_name="org.lflang" -src_pkg_path="${base}/${src_pkg_name}" -jar_build_path_pattern="${src_pkg_name}/build/libs/${src_pkg_name}-*.jar" -jar_release_path_pattern="lib/jars/${src_pkg_name}-*.jar" - -# Enter directory silently (without printing). -pushd() { - command pushd "$@" > /dev/null -} - -# Leave directory silently (without printing). -popd() { - command popd "$@" > /dev/null -} - -# Check whether the first argument is a directory, and return it if true. -function is_dir() { - if [ -d "${1}" ]; then - echo "${1}" - else - return - fi -} - -# Check whether the source directory exists, and return it if true. -function get_src_dir() { - echo `is_dir "${base}/${src_pkg_name}"` -} - -# If it exists, return a path to the Lingua Franca jar. -function get_jar_path() { - if [ "$(get_src_dir)" ]; then - jar_path_pattern="${jar_build_path_pattern}" - else - jar_path_pattern="${jar_release_path_pattern}" - fi - # echo Jar path pattern: "${base}"/${jar_path_pattern} - # Is there a file that matches our pattern? If so, return it. - if ls "${base}"/${jar_path_pattern} 1> /dev/null 2>&1; then - # Yes. Determine the precise path of the jar. - # Take the newest version if there are multiple jars. - echo "$(ls "${base}"/${jar_path_pattern} | sort -V | tail -n1)" - fi -} - -# Check if the given Java command (argument 1) points to the correct Java version. -# Throw a fatal error upon failure if argument 2 is nonzero. -function check_java_cmd { - semantic_version=$("$1" -version 2>&1 | awk -F '"' '/version/ {print $2}') - java_version=$(echo "$semantic_version" | awk -F. '{printf("%03d%03d",$1,$2);}') - # echo "Semantic version: $semantic_version" - # echo "Java version: $java_version" - if [ $java_version -lt 017000 ]; then - if [ $2 -gt 0 ]; then - fatal_error "JRE $semantic_version found but 1.17 or greater is required." - fi - echo "incorrect" - return - fi - echo "correct" -} - -# Lookup the JRE. -function lookup_jre() { - if [[ $(type -p java) != "" ]]; then - #echo Found java executable in PATH - for JAVA_PATH in $(type -a java); do - if [[ $(check_java_cmd "$JAVA_PATH" 0) == "correct" ]]; then - echo $JAVA_PATH - return - fi - done - echo "java" # This will result in failure - elif [[ -n "$JAVA_HOME" ]] && [[ -x "$JAVA_HOME/bin/java" ]]; then - #echo Found java executable in JAVA_HOME - echo "$JAVA_HOME/bin/java" - else - fatal_error "JRE not found." - fi -} - -# Check whether the JRE version is high enough. Exit with an error if it is not. -function get_java_cmd { - java_cmd="$(lookup_jre)" - check_java_cmd $java_cmd 1 > /dev/null - echo ${java_cmd} -} - -# Find the jar and JRE, run the jar with the provided arguments, and exit. -function run_cli_tool_with_args { - # Find the jar; report error if it was not found. - jar_path="$(get_jar_path)" - - if [[ ! "${jar_path}" ]]; then - fatal_error "Cannot find the Lingua Franca jar." - fi - - # Launch the compiler. - java_cmd="$(get_java_cmd)" - "${java_cmd}" -cp "${jar_path}" "${main_class}" "$@"; - exit $? -} diff --git a/lib/scripts/launch.ps1 b/lib/scripts/launch.ps1 deleted file mode 100644 index 6864ef7c56..0000000000 --- a/lib/scripts/launch.ps1 +++ /dev/null @@ -1,71 +0,0 @@ -#========================================================== -# Description: Launch lfc or lff depending on the invoking script. -# Authors: Christian Menard, Peter Donovan, Ruomu Xu -# Usage: Usage: launch args... -# with invoker with name same as the programme to be invoked. -#========================================================== - -# If the invoker is Z:\nkamihara\lf\bin\lfc.ps1, $invokerName will strip out "lfc.ps1" and then get "lfc". -# See https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_automatic_variables?view=powershell-7.2#myinvocation -$invokerPath = $MyInvocation.PSCommandPath -$invokerName = [System.IO.Path]::GetFileNameWithoutExtension("$(Split-Path -Path $invokerPath -Leaf -Resolve)") - -$mainClassTable = @{"lfc" = "org.lflang.cli.Lfc"; "lff" = "org.lflang.cli.Lff"} -$mainClassName = $null -foreach ($k in $mainClassTable.Keys) { - if ($invokerName.EndsWith($k)) { - $mainClassName = $mainClassTable[$k] - break - } -} -if ($null -eq $mainClassName) { - throw ("$invokerName is not a known lf command. Known commands are [$($mainClassTable.Keys)]. " + - "In case you use a symbolic or hard link to one of the Lingua Franca " + - "command line tools, make sure that the link's name ends with one of [$($mainClassTable.Keys)]") -} - -# This script is in $base\lib\scripts -$base="$PSScriptRoot\..\..\" -$java_home = "$Env:JAVA_HOME" -$java_cmd = "$java_home\bin\java.exe" -$jarpath_dev="$base\org.lflang\build\libs\org.lflang-*.jar" -$jarpath_release="$base\lib\jars\org.lflang-*.jar" - -function Test-Dev { - Test-Path "$base\org.lflang" -PathType container -} - -function Get-JarPath { - if (Test-Dev) { - if (Test-Path $jarpath_dev -PathType leaf) { - $jarpath=$(Get-ChildItem $jarpath_dev).toString() - } else { - throw "Failed to find a copy of the Lingua Franca compiler matching the pattern ""$jarpath_dev"". Did you remember to build?" - } - } else { - if (Test-Path $jarpath_release -PathType leaf) { - $jarpath=$(Get-ChildItem $jarpath_release).toString() - } else { - throw "Failed to find a copy of the Lingua Franca compiler matching the pattern ""$jarpath_release""." - } - } - $jarpath -} - -# check if we can find java executable in $java_home -if (-not (Test-Path $java_cmd)) { - # otherwise, try to run java directly - if (-not (Get-Command java -errorAction SilentlyContinue)) { - throw "JRE not found" - } - $java_cmd = "java" -} - -# check for correct java version -$java_version = (Get-Command java | Select-Object -ExpandProperty Version).toString() -if ([version]$java_version -lt [version]"17.0") { - throw "JRE $java_version found but 17.0 or greater is required." -} - -# invoke lff -& $java_cmd -classpath $(Get-JarPath) $mainClassName $args diff --git a/bin/bump-versions b/util/scripts/bump-versions similarity index 100% rename from bin/bump-versions rename to util/scripts/bump-versions diff --git a/lib/scripts/launch-fedsd.sh b/util/scripts/launch-fedsd.sh similarity index 100% rename from lib/scripts/launch-fedsd.sh rename to util/scripts/launch-fedsd.sh diff --git a/util/scripts/launch.ps1 b/util/scripts/launch.ps1 new file mode 100644 index 0000000000..6e7d50854e --- /dev/null +++ b/util/scripts/launch.ps1 @@ -0,0 +1,39 @@ +#========================================================== +# Description: Launch lfc or lff depending on the invoking script. +# Authors: Christian Menard, Peter Donovan, Ruomu Xu +# Usage: Usage: launch args... +# with invoker with name same as the programme to be invoked. +#========================================================== + +# If the invoker is Z:\nkamihara\lf\bin\lfc.ps1, $invokerName will strip out "lfc.ps1" and then get "lfc". +# See https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_automatic_variables?view=powershell-7.2#myinvocation +$invokerPath = $MyInvocation.PSCommandPath +$invokerName = [System.IO.Path]::GetFileNameWithoutExtension("$(Split-Path -Path $invokerPath -Leaf -Resolve)") + +$mainClassTable = @{"lfc" = "org.lflang.cli.Lfc"; "lff" = "org.lflang.cli.Lff"} +$tool = $null +foreach ($k in $mainClassTable.Keys) { + if ($invokerName.EndsWith($k)) { + tool = $k,,, + break + } +} +if ($null -eq $tool) { + throw ("$invokerName is not a known lf command. Known commands are [$($mainClassTable.Keys)]. " + + "In case you use a symbolic or hard link to one of the Lingua Franca " + + "command line tools, make sure that the link's name ends with one of [$($mainClassTable.Keys)]") +} + +# This script is in $base\util\scripts +$base="$PSScriptRoot\..\..\" +script="${base}/org.lflang/cli/${tool}/build/install/${tool}/bin/${tool}" + + + +# check if we can find the script +if (-not (Test-Path $script)) { + throw "Could not find ${tool}! Did you build the repository? Please run './gradlew.bat assemble' or './gradlew.bat build' and try again." +} + +# invoke script +& $script $args diff --git a/lib/scripts/launch.sh b/util/scripts/launch.sh similarity index 87% rename from lib/scripts/launch.sh rename to util/scripts/launch.sh index 82747c81ef..b30f8c97ac 100755 --- a/lib/scripts/launch.sh +++ b/util/scripts/launch.sh @@ -43,12 +43,10 @@ function fatal_error() { exit 1 } -rel_path="lib/scripts" abs_path="$(find_dir "$0")" if [[ "${abs_path}" ]]; then base=`dirname $(dirname ${abs_path})` - source "${base}/${rel_path}/include.sh" else fatal_error "Unable to determine absolute path to $0." fi @@ -56,9 +54,9 @@ fi if [[ "$0" == *lfc ]]; then - main_class="org.lflang.cli.Lfc" + tool="lfc" elif [[ "$0" == *lff ]]; then - main_class="org.lflang.cli.Lff" + tool="lff" else known_commands="[lfc, lff]" echo \ @@ -69,5 +67,11 @@ else exit 2 fi -# Launch the compiler. -run_cli_tool_with_args "$@" +script="${base}/org.lflang/cli/${tool}/build/install/${tool}/bin/${tool}" + +if [[ ! -f "${script}" ]]; then + fatal_error "Could not find ${tool}! Did you build the repository? Please run './gradlew assemble' or './gradlew build' and try again." +fi + +# Launch the tool. +"$script" "$@" From 74f366c3f553b43a847725d792bc6204c48954a0 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 11:39:48 +0200 Subject: [PATCH 501/709] create a cli tools distribution --- build.gradle | 13 +++++++++++++ .../org.lflang.distribution-conventions.gradle | 8 ++++++++ .../org.lflang.java-application-conventions.gradle | 6 +++++- 3 files changed, 26 insertions(+), 1 deletion(-) create mode 100644 buildSrc/src/main/groovy/org.lflang.distribution-conventions.gradle diff --git a/build.gradle b/build.gradle index 87eaec93ce..873b7c2b55 100644 --- a/build.gradle +++ b/build.gradle @@ -2,6 +2,7 @@ import lfformat.LfFormatStep plugins { id "com.diffplug.spotless" + id "org.lflang.distribution-conventions" } spotless { @@ -24,3 +25,15 @@ spotless { } spotlessLinguaFranca.dependsOn(":org.lflang:cli:lff:installDist") + + +distributions { + clitools { + distributionBaseName.set("lf-cli") + contents { + from tasks.getByPath(':org.lflang:cli:lfc:installDist').outputs + from tasks.getByPath(':org.lflang:cli:lff:installDist').outputs + duplicatesStrategy = DuplicatesStrategy.EXCLUDE + } + } +} diff --git a/buildSrc/src/main/groovy/org.lflang.distribution-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.distribution-conventions.gradle new file mode 100644 index 0000000000..4d25bbb461 --- /dev/null +++ b/buildSrc/src/main/groovy/org.lflang.distribution-conventions.gradle @@ -0,0 +1,8 @@ +plugins { + id 'distribution' +} + +tasks.withType(Tar) { + compression = Compression.GZIP + archiveExtension = 'tar.gz' +} diff --git a/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle index d8e3f5f76a..02cdc18df1 100644 --- a/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle @@ -2,6 +2,10 @@ plugins { id 'org.lflang.java-conventions' id 'application' id 'org.lflang.test-conventions' + id "org.lflang.distribution-conventions" } -assemble.finalizedBy installDist \ No newline at end of file +tasks.withType(Tar) { + compression = Compression.GZIP + archiveExtension = 'tar.gz' +} From 56887f2785d3df0e9e834e76b919a06a30723e21 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 12:18:05 +0200 Subject: [PATCH 502/709] use gradle to run lfc and lff --- org.lflang/cli/lfc/build.gradle | 2 +- org.lflang/cli/lff/build.gradle | 2 +- util/scripts/launch.ps1 | 11 ++--------- util/scripts/launch.sh | 8 ++------ 4 files changed, 6 insertions(+), 17 deletions(-) diff --git a/org.lflang/cli/lfc/build.gradle b/org.lflang/cli/lfc/build.gradle index ca59afece9..9af526e579 100644 --- a/org.lflang/cli/lfc/build.gradle +++ b/org.lflang/cli/lfc/build.gradle @@ -11,5 +11,5 @@ dependencies { application { mainClass = 'org.lflang.cli.Lfc' - tasks.run.workingDir = rootProject.projectDir + tasks.run.workingDir = System.getProperty("user.dir") } diff --git a/org.lflang/cli/lff/build.gradle b/org.lflang/cli/lff/build.gradle index b2a597fa05..65d35a21c2 100644 --- a/org.lflang/cli/lff/build.gradle +++ b/org.lflang/cli/lff/build.gradle @@ -17,7 +17,7 @@ dependencies { application { mainClass = 'org.lflang.cli.Lff' - tasks.run.workingDir = rootProject.projectDir + tasks.run.workingDir = System.getProperty("user.dir") } test { diff --git a/util/scripts/launch.ps1 b/util/scripts/launch.ps1 index 6e7d50854e..839f022999 100644 --- a/util/scripts/launch.ps1 +++ b/util/scripts/launch.ps1 @@ -26,14 +26,7 @@ if ($null -eq $tool) { # This script is in $base\util\scripts $base="$PSScriptRoot\..\..\" -script="${base}/org.lflang/cli/${tool}/build/install/${tool}/bin/${tool}" - - - -# check if we can find the script -if (-not (Test-Path $script)) { - throw "Could not find ${tool}! Did you build the repository? Please run './gradlew.bat assemble' or './gradlew.bat build' and try again." -} +$gradlew="${base}/gradlew.bat" # invoke script -& $script $args +& "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args "$@" \ No newline at end of file diff --git a/util/scripts/launch.sh b/util/scripts/launch.sh index b30f8c97ac..03025c9914 100755 --- a/util/scripts/launch.sh +++ b/util/scripts/launch.sh @@ -67,11 +67,7 @@ else exit 2 fi -script="${base}/org.lflang/cli/${tool}/build/install/${tool}/bin/${tool}" - -if [[ ! -f "${script}" ]]; then - fatal_error "Could not find ${tool}! Did you build the repository? Please run './gradlew assemble' or './gradlew build' and try again." -fi +gradlew="${base}/gradlew" # Launch the tool. -"$script" "$@" +"${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args "$@" From 7a491675d6618f2201dba4841edbbf65761e7ded Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 12:19:29 +0200 Subject: [PATCH 503/709] update packaging workflow --- .github/scripts/package-cli.sh | 40 ---------------------------------- .github/workflows/build.yml | 6 ++--- .github/workflows/ci.yml | 2 +- build.gradle | 7 +++++- 4 files changed, 10 insertions(+), 45 deletions(-) delete mode 100755 .github/scripts/package-cli.sh diff --git a/.github/scripts/package-cli.sh b/.github/scripts/package-cli.sh deleted file mode 100755 index 7e17c1c38d..0000000000 --- a/.github/scripts/package-cli.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env bash - -set -euo pipefail - -# build lf cli tools -./gradlew clean buildAll - -# find the version number -jar_path="org.lflang/build/libs/org.lflang-*.jar" -version="$(ls ${jar_path} | xargs -n 1 basename | sed 's/^org.lflang-\(.*\).jar$/\1/')" - -# use a different naming convention for nightly build artifacts -if [[ "$#" > 0 && "$1" = "nightly" ]]; then - echo "Packaging Lingua Franca Nightly Build" - outname="lf-cli-nightly-$(date '+%Y%m%d-%H%M%S')" -else - echo "Packaging Lingua Franca v${version}" - outname="lf-cli-${version}" -fi - -# assemble the files in a separate directory -mkdir -p "${outname}/bin" -mkdir -p "${outname}/lib/scripts" -mkdir -p "${outname}/lib/jars" - -# move the jar -mv org.lflang/build/libs/org.lflang-*.jar "${outname}/lib/jars" - -# copy the Bash scripts -cp -a lib/scripts "${outname}/lib/" -ln -s "../lib/scripts/launch.sh" "${outname}/bin/lfc" -ln -s "../lib/scripts/launch.sh" "${outname}/bin/lff" -# copy the PowerShell script -cp bin/lfc.ps1 "${outname}/bin/lfc.ps1" -cp bin/lff.ps1 "${outname}/bin/lff.ps1" - -# zip/tar everything - the files will be put into the build_upload directory -mkdir -p build_upload -zip --symlinks -r "build_upload/${outname}.zip" "${outname}" -tar zcvf "build_upload/${outname}.tar.gz" "${outname}" diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 767df01fa1..3e7b49e511 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -24,11 +24,11 @@ jobs: - name: Prepare build environment uses: ./.github/actions/prepare-build-env - name: Build and package lf cli tools (nightly build) - run: .github/scripts/package-cli.sh nightly + run: ./gradlew build -Pnightly shell: bash if: ${{ inputs.nightly == true }} - name: Build and package lf cli tools (regular build) - run: .github/scripts/package-cli.sh + run: ./gradlew build shell: bash if: ${{ inputs.nightly != true }} - name: Deploy nightly release @@ -39,5 +39,5 @@ jobs: prerelease: true title: "Lingua Franca Nightly" files: | - build_upload/* + build/distributions/* if: ${{ inputs.nightly == true }} diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index dc9832cf35..01a49dd0ca 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,7 +22,7 @@ jobs: # Test the Gradle build. build: - uses: lf-lang/lingua-franca/.github/workflows/build.yml@master + uses: lf-lang/lingua-franca/.github/workflows/build.yml@gradle needs: cancel # Build the tools used for processing execution traces diff --git a/build.gradle b/build.gradle index 873b7c2b55..c1130f9e20 100644 --- a/build.gradle +++ b/build.gradle @@ -29,7 +29,12 @@ spotlessLinguaFranca.dependsOn(":org.lflang:cli:lff:installDist") distributions { clitools { - distributionBaseName.set("lf-cli") + distributionBaseName = "lf-cli" + if (project.hasProperty('nightly')) { + def date = new Date() + def formattedDate = date.format('yyyyMMddHHmmss') + distributionClassifier = 'nightly-' + formattedDate + } contents { from tasks.getByPath(':org.lflang:cli:lfc:installDist').outputs from tasks.getByPath(':org.lflang:cli:lff:installDist').outputs From 37ff7d0ce78a7c5760e29710d705802d8d815b10 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 12:19:48 +0200 Subject: [PATCH 504/709] don't format lf files for now --- build.gradle | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/build.gradle b/build.gradle index c1130f9e20..43a28acccf 100644 --- a/build.gradle +++ b/build.gradle @@ -16,15 +16,15 @@ spotless { endWithNewline() } - format 'linguaFranca', { - addStep(LfFormatStep.create(project.projectDir)) - target 'test/*/src/**/*.lf' // you have to set the target manually - targetExclude 'test/**/failing/**' - } +// format 'linguaFranca', { +// addStep(LfFormatStep.create(project.projectDir)) +// target 'test/*/src/**/*.lf' // you have to set the target manually +// targetExclude 'test/**/failing/**' +// } } -spotlessLinguaFranca.dependsOn(":org.lflang:cli:lff:installDist") +//spotlessLinguaFranca.dependsOn(":org.lflang:cli:lff:installDist") distributions { From 2a80a6f9892b105dc4f773679cfd409d45a9db98 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 12:24:34 +0200 Subject: [PATCH 505/709] no need to run unit tests and format checks separately they are included in gradle build --- .github/workflows/check-format.yml | 19 ------------------- .github/workflows/ci.yml | 9 --------- .github/workflows/unit-tests.yml | 27 --------------------------- 3 files changed, 55 deletions(-) delete mode 100644 .github/workflows/check-format.yml delete mode 100644 .github/workflows/unit-tests.yml diff --git a/.github/workflows/check-format.yml b/.github/workflows/check-format.yml deleted file mode 100644 index 8c022f90a5..0000000000 --- a/.github/workflows/check-format.yml +++ /dev/null @@ -1,19 +0,0 @@ -name: Spotless check - -on: - workflow_call: - -jobs: - run: - runs-on: ubuntu-latest - steps: - - name: Check out lingua-franca repository - uses: actions/checkout@v3 - with: - submodules: recursive - fetch-depth: 0 - - name: Prepare build environment - uses: ./.github/actions/prepare-build-env - - name: Run spotlessCheck - run: ./gradlew spotlessCheck - shell: bash diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 01a49dd0ca..75666c5cab 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,15 +30,6 @@ jobs: uses: lf-lang/lingua-franca/.github/workflows/build-trace-tools.yml@master needs: cancel - check-format: - uses: lf-lang/lingua-franca/.github/workflows/check-format.yml@master - needs: cancel - - # Run the unit tests. - unit-tests: - uses: lf-lang/lingua-franca/.github/workflows/unit-tests.yml@master - needs: cancel - # Run tests for the standalone compiler. cli-tests: uses: lf-lang/lingua-franca/.github/workflows/cli-tests.yml@master diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml deleted file mode 100644 index 1caec5c1ac..0000000000 --- a/.github/workflows/unit-tests.yml +++ /dev/null @@ -1,27 +0,0 @@ -name: Unit tests - -on: - workflow_call: - -jobs: - run: - strategy: - matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] - runs-on: ${{ matrix.platform }} - steps: - - uses: actions/checkout@v3 - with: - submodules: true - fetch-depth: 0 - - name: Prepare build environment - uses: ./.github/actions/prepare-build-env - - name: Run compiler tests - run: | - ./gradlew test --tests org.lflang.tests.compiler.* - - name: Report to CodeCov - uses: codecov/codecov-action@v3.1.1 - with: - file: org.lflang.tests/build/reports/xml/jacoco - fail_ci_if_error: false - verbose: true From f55e63dbf6c1fc9d184b6a5da70ef2548dfe8c0b Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 12:33:16 +0200 Subject: [PATCH 506/709] fix tracing utils --- util/tracing/makefile | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/util/tracing/makefile b/util/tracing/makefile index 407b153235..590eaa698f 100644 --- a/util/tracing/makefile +++ b/util/tracing/makefile @@ -3,10 +3,10 @@ # @author: Edward A. Lee CC=gcc -CFLAGS=-I../../org.lflang/src/lib/c/reactor-c/include/core/ \ - -I../../org.lflang/src/lib/c/reactor-c/include/core/modal_models \ - -I../../org.lflang/src/lib/c/reactor-c/include/core/platform \ - -I../../org.lflang/src/lib/c/reactor-c/include/core/utils \ +CFLAGS=-I../../org.lflang/core/src/main/resources/lib/c/reactor-c/include/core/ \ + -I../../org.lflang/core/src/main/resources/lib/c/reactor-c/include/core/modal_models \ + -I../../org.lflang/core/src/main/resources/lib/c/reactor-c/include/core/platform \ + -I../../org.lflang/core/src/main/resources/lib/c/reactor-c/include/core/utils \ -DLF_UNTHREADED=1 \ -Wall DEPS= @@ -28,7 +28,7 @@ install: trace_to_csv trace_to_chrome trace_to_influxdb mv trace_to_csv ../../bin mv trace_to_chrome ../../bin mv trace_to_influxdb ../../bin - ln -f -s ../lib/scripts/launch-fedsd.sh ../../bin/fedsd + ln -f -s ../utils/scripts/launch-fedsd.sh ../../bin/fedsd chmod +x ../../bin/fedsd clean: From c650d324cb00b5541b80447de6ef0cffcc7e7d7d Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 14:10:49 +0200 Subject: [PATCH 507/709] add jacoco support and merge cli tests into build --- .github/scripts/test-build.sh | 25 ---------- .github/workflows/build.yml | 28 +++++++++++ .github/workflows/ci.yml | 5 -- .github/workflows/cli-tests.yml | 46 ------------------- build.gradle | 14 ++++++ .../groovy/org.lflang.test-conventions.gradle | 28 +++++++++++ 6 files changed, 70 insertions(+), 76 deletions(-) delete mode 100755 .github/scripts/test-build.sh delete mode 100644 .github/workflows/cli-tests.yml diff --git a/.github/scripts/test-build.sh b/.github/scripts/test-build.sh deleted file mode 100755 index 36ba4011c1..0000000000 --- a/.github/scripts/test-build.sh +++ /dev/null @@ -1,25 +0,0 @@ -#!/usr/bin/env bash - -# Exit 1 if any command returns with a non-zero exit code. -set -euo pipefail - -cd $GITHUB_WORKSPACE - -function test_with_links() { - rm -rf foo - mkdir -p foo/bar/baz - ln -s ../bin/${1} foo/link-foo - ln -s ../link-foo foo/bar/link-bar - ln -s ../link-bar foo/bar/baz/link-baz - foo/bar/baz/link-baz --help -} - -# Test the build-lf-cli executable and its flags. -bin/build-lf-cli -bin/build-lf-cli --help -bin/build-lf-cli -h -bin/build-lf-cli -c -o -s -bin/build-lf-cli --clean --offline --stacktrace - -# Ensure that build-lf-cli is robust to symbolic links. -test_with_links "build-lf-cli" diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 3e7b49e511..6414b2500f 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -31,6 +31,24 @@ jobs: run: ./gradlew build shell: bash if: ${{ inputs.nightly != true }} + - name: Test lfc bash scripts (Linux or macOS only) + run: | + .github/scripts/test-lfc.sh + if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} + - name: Test lff bash scripts (Linux or macOS only) + run: | + .github/scripts/test-lff.sh + if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} + - name: Test PowerShell lfc script (Windows only) + run: | + ./gradlew buildAll + bin/lfc.ps1 --help + if: ${{ runner.os == 'Windows' }} + - name: Test PowerShell lff script (Windows only) + run: | + ./gradlew buildAll + bin/lfc.ps1 --help + if: ${{ runner.os == 'Windows' }} - name: Deploy nightly release uses: marvinpinto/action-automatic-releases@latest with: @@ -41,3 +59,13 @@ jobs: files: | build/distributions/* if: ${{ inputs.nightly == true }} + - name: Collect code coverage + run: ./gradlew jacocoTestReport + if: ${{ runner.os == 'Linux' }} + - name: Report to CodeCov + uses: codecov/codecov-action@v3.1.1 + with: + files: org.lflang/core/build/reports/xml/jacoco,org.lflang/cli/lfc/build/reports/xml/jacoco,org.lflang/cli/lff/build/reports/xml/jacoco + fail_ci_if_error: false + verbose: true + if: ${{ runner.os == 'Linux' }} diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 75666c5cab..db3dcfd08c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -30,11 +30,6 @@ jobs: uses: lf-lang/lingua-franca/.github/workflows/build-trace-tools.yml@master needs: cancel - # Run tests for the standalone compiler. - cli-tests: - uses: lf-lang/lingua-franca/.github/workflows/cli-tests.yml@master - needs: cancel - # Run the C benchmark tests. c-benchmark-tests: uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml deleted file mode 100644 index 056e32c04c..0000000000 --- a/.github/workflows/cli-tests.yml +++ /dev/null @@ -1,46 +0,0 @@ -name: CLI tests - -on: - workflow_call: - -jobs: - run: - strategy: - matrix: - platform: [ubuntu-latest, macos-latest, windows-latest] - runs-on: ${{ matrix.platform }} - steps: - - uses: actions/checkout@v3 - with: - submodules: true - fetch-depth: 0 - - name: Prepare build environment - uses: ./.github/actions/prepare-build-env - - name: Test build bash scripts (Linux and macOS only) - run: | - .github/scripts/test-build.sh - if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - - name: Test lfc bash scripts (Linux or macOS only) - run: | - .github/scripts/test-lfc.sh - if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - - name: Test lff bash scripts (Linux or macOS only) - run: | - .github/scripts/test-lff.sh - if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - - name: Test PowerShell script (Windows only) - run: | - ./gradlew buildAll - bin/lfc.ps1 --help - if: ${{ runner.os == 'Windows' }} - - name: Run standalone cli tests - run: | - ./gradlew test --tests org.lflang.tests.cli.* --stacktrace -# NOTE: do not put other invocations for gradlew in between these steps, or coverage reporting will break. - - name: Report to CodeCov - uses: codecov/codecov-action@v3.1.1 - with: - file: org.lflang.tests/build/reports/xml/jacoco - fail_ci_if_error: false - verbose: true - if: ${{ runner.os == 'Linux' }} diff --git a/build.gradle b/build.gradle index 43a28acccf..7ac11a7cc1 100644 --- a/build.gradle +++ b/build.gradle @@ -42,3 +42,17 @@ distributions { } } } + +task jacocoRootReport(type: JacocoReport, group: 'Coverage reports') { + description = 'Generates an aggregate report from all subprojects' + dependsOn(subprojects.test) + + additionalSourceDirs.from = files(subprojects.sourceSets.main.allSource.srcDirs) + sourceDirectories.from = files(subprojects.sourceSets.main.allSource.srcDirs) + classDirectories.from = files(subprojects.sourceSets.main.output) + executionData.from = files(subprojects.jacocoTestReport.executionData) + + reports { + html.enabled true + } +} \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 1055ca0dbc..c126c32860 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -1,7 +1,14 @@ plugins { id 'java-test-fixtures' + id 'jacoco' } +jacoco { + toolVersion = jacocoVersion +} + + + dependencies { testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" @@ -26,4 +33,25 @@ test { events "passed", "skipped", "failed" showStandardStreams = true } +} + +jacocoTestReport { + reports { + xml.required = true + csv.required = false + html.destination file("${buildDir}/reports/html/jacoco") + xml.destination file("${buildDir}/reports/xml/jacoco") + } + + afterEvaluate { + classDirectories.setFrom(files(classDirectories.files.collect { + fileTree(dir: it, + exclude: ['**/org/lflang/services/**', + '**/org/lflang/lf/**', + '**/org/lflang/serializer/**', + '**/org/lflang/parser/antlr/**' + ] + ) + })) + } } \ No newline at end of file From 7190c8726d83c77bda2fad95039d8dd530b5eef2 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 14:41:27 +0200 Subject: [PATCH 508/709] add integration tests, but skip them in our test task --- build.gradle | 14 -------------- .../main/groovy/org.lflang.test-conventions.gradle | 6 +++++- .../kotlin/org/lflang/cli/LfcIssueReportingTest.kt | 2 +- .../test/java}/org/lflang/tests/RuntimeTest.java | 14 ++++++++++++++ .../test/java/org/lflang/tests/lsp/LspTests.java | 6 ++++++ .../org/lflang/tests/runtime/CArduinoTest.java | 2 ++ .../java}/org/lflang/tests/runtime/CCppTest.java | 2 ++ .../org/lflang/tests/runtime/CSchedulerTest.java | 2 ++ .../test/java}/org/lflang/tests/runtime/CTest.java | 13 +++++++++++++ .../org/lflang/tests/runtime/CZephyrTest.java | 3 +++ .../org/lflang/tests/runtime/CppRos2Test.java | 2 ++ .../java}/org/lflang/tests/runtime/CppTest.java | 7 +++++++ .../java}/org/lflang/tests/runtime/PythonTest.java | 9 +++++++++ .../java}/org/lflang/tests/runtime/RustTest.java | 0 .../org/lflang/tests/runtime/TypeScriptTest.java | 9 +++++++++ .../tests/serialization/SerializationTest.java | 3 +++ .../EnclaveCommunicationDelayedLocalEvents.lf | 1 + 17 files changed, 79 insertions(+), 16 deletions(-) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/RuntimeTest.java (94%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/CArduinoTest.java (93%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/CCppTest.java (96%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/CSchedulerTest.java (97%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/CTest.java (92%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/CZephyrTest.java (97%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/CppRos2Test.java (94%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/CppTest.java (94%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/PythonTest.java (94%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/RustTest.java (100%) rename {org.lflang.tests/src => org.lflang/core/src/test/java}/org/lflang/tests/runtime/TypeScriptTest.java (88%) diff --git a/build.gradle b/build.gradle index 7ac11a7cc1..43a28acccf 100644 --- a/build.gradle +++ b/build.gradle @@ -42,17 +42,3 @@ distributions { } } } - -task jacocoRootReport(type: JacocoReport, group: 'Coverage reports') { - description = 'Generates an aggregate report from all subprojects' - dependsOn(subprojects.test) - - additionalSourceDirs.from = files(subprojects.sourceSets.main.allSource.srcDirs) - sourceDirectories.from = files(subprojects.sourceSets.main.allSource.srcDirs) - classDirectories.from = files(subprojects.sourceSets.main.output) - executionData.from = files(subprojects.jacocoTestReport.executionData) - - reports { - html.enabled true - } -} \ No newline at end of file diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index c126c32860..345b78cc88 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -28,11 +28,15 @@ dependencies { } test { - useJUnitPlatform() + useJUnitPlatform { + excludeTags 'Integration' + } testLogging { events "passed", "skipped", "failed" showStandardStreams = true } + + workingDir = rootProject.projectDir } jacocoTestReport { diff --git a/org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt b/org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt index d8455bc7e9..44a85a13df 100644 --- a/org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt +++ b/org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt @@ -120,7 +120,7 @@ class LfcIssueReportingTest { val packageName = loader.packageName.replace('.', '/') // relative to root of gradle project // TODO This should load the resources and copy them to a temp directory instead of reading directly - val basePath = "src/test/resources/$packageName/" + val basePath = "org.lflang/cli/lfc/src/test/resources/$packageName/" val lfFile = Paths.get("$basePath/$fileBaseName.lf") val expectedPath = Paths.get("$basePath/$fileBaseName.stderr") diff --git a/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java b/org.lflang/core/src/test/java/org/lflang/tests/RuntimeTest.java similarity index 94% rename from org.lflang.tests/src/org/lflang/tests/RuntimeTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/RuntimeTest.java index 2dfd42d38b..c873dcd427 100644 --- a/org.lflang.tests/src/org/lflang/tests/RuntimeTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/RuntimeTest.java @@ -3,6 +3,7 @@ import java.util.EnumSet; import java.util.List; import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.ast.ASTUtils; @@ -54,6 +55,7 @@ protected boolean supportsDockerOption() { } @Test + @Tag("Integration") public void runGenericTests() { runTestsForTargets( Message.DESC_GENERIC, @@ -64,6 +66,7 @@ public void runGenericTests() { } @Test + @Tag("Integration") public void runTargetSpecificTests() { runTestsForTargets( Message.DESC_TARGET_SPECIFIC, @@ -74,6 +77,7 @@ public void runTargetSpecificTests() { } @Test + @Tag("Integration") public void runMultiportTests() { runTestsForTargets( Message.DESC_MULTIPORT, @@ -84,6 +88,7 @@ public void runMultiportTests() { } @Test + @Tag("Integration") public void runTypeParameterTests() { Assumptions.assumeTrue(supportsGenericTypes(), Message.NO_GENERICS_SUPPORT); runTestsForTargets( @@ -95,6 +100,7 @@ public void runTypeParameterTests() { } @Test + @Tag("Integration") public void runAsFederated() { Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); @@ -116,6 +122,7 @@ public void runAsFederated() { } @Test + @Tag("Integration") public void runConcurrentTests() { runTestsForTargets( Message.DESC_CONCURRENT, @@ -126,6 +133,7 @@ public void runConcurrentTests() { } @Test + @Tag("Integration") public void runFederatedTests() { Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); runTestsForTargets( @@ -138,6 +146,7 @@ public void runFederatedTests() { /** Run the tests for modal reactors. */ @Test + @Tag("Integration") public void runModalTests() { runTestsForTargets( Message.DESC_MODAL, @@ -149,6 +158,7 @@ public void runModalTests() { /** Run the tests for non-inlined reaction bodies. */ @Test + @Tag("Integration") public void runNoInliningTests() { runTestsForTargets( Message.DESC_MODAL, @@ -163,6 +173,7 @@ public void runNoInliningTests() { * platform is not Linux or target does not support Docker. */ @Test + @Tag("Integration") public void runDockerTests() { Assumptions.assumeTrue(isLinux(), Message.NO_DOCKER_TEST_SUPPORT); Assumptions.assumeTrue(supportsDockerOption(), Message.NO_DOCKER_SUPPORT); @@ -180,6 +191,7 @@ public void runDockerTests() { * tests. */ @Test + @Tag("Integration") public void runDockerFederatedTests() { Assumptions.assumeTrue(isLinux(), Message.NO_DOCKER_TEST_SUPPORT); Assumptions.assumeTrue(supportsDockerOption(), Message.NO_DOCKER_SUPPORT); @@ -193,6 +205,7 @@ public void runDockerFederatedTests() { } @Test + @Tag("Integration") public void runWithThreadingOff() { Assumptions.assumeTrue(supportsSingleThreadedExecution(), Message.NO_SINGLE_THREADED_SUPPORT); this.runTestsForTargets( @@ -205,6 +218,7 @@ public void runWithThreadingOff() { /** Run enclave tests if the target supports enclaves. */ @Test + @Tag("Integration") public void runEnclaveTests() { Assumptions.assumeTrue(supportsEnclaves(), Message.NO_ENCLAVE_SUPPORT); runTestsForTargets( diff --git a/org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java b/org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java index fe52d6016c..52339161ea 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java @@ -12,6 +12,7 @@ import org.eclipse.emf.common.util.URI; import org.eclipse.lsp4j.Diagnostic; import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.LFRuntimeModule; import org.lflang.LFStandaloneSetup; @@ -56,30 +57,35 @@ class LspTests { /** Test for false negatives in Python syntax-only validation. */ @Test + @Tag("Integration") void pythonValidationTestSyntaxOnly() throws IOException { targetLanguageValidationTest(Target.Python, ErrorInserter.PYTHON_SYNTAX_ONLY); } /** Test for false negatives in C++ validation. */ @Test + @Tag("Integration") void cppValidationTest() throws IOException { targetLanguageValidationTest(Target.CPP, ErrorInserter.CPP); } /** Test for false negatives in Python validation. */ @Test + @Tag("Integration") void pythonValidationTest() throws IOException { targetLanguageValidationTest(Target.Python, ErrorInserter.PYTHON); } /** Test for false negatives in Rust validation. */ @Test + @Tag("Integration") void rustValidationTest() throws IOException { targetLanguageValidationTest(Target.Rust, ErrorInserter.RUST); } /** Test for false negatives in TypeScript validation. */ @Test + @Tag("Integration") void typescriptValidationTest() throws IOException { targetLanguageValidationTest(Target.TS, ErrorInserter.TYPESCRIPT); } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CArduinoTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CArduinoTest.java similarity index 93% rename from org.lflang.tests/src/org/lflang/tests/runtime/CArduinoTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/CArduinoTest.java index 95363fd30b..4758977143 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CArduinoTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CArduinoTest.java @@ -2,6 +2,7 @@ import java.util.List; import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.Configurators; @@ -20,6 +21,7 @@ public CArduinoTest() { } @Test + @Tag("Integration") public void buildArduinoTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); super.runTestsFor( diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CCppTest.java similarity index 96% rename from org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/CCppTest.java index ba1865e870..04ea680194 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CCppTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CCppTest.java @@ -1,6 +1,7 @@ package org.lflang.tests.runtime; import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.ast.ASTUtils; @@ -26,6 +27,7 @@ public CCppTest() { /** Run C tests with the target CCpp. */ @Test + @Tag("Integration") public void runAsCCpp() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); runTestsForTargets( diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CSchedulerTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CSchedulerTest.java similarity index 97% rename from org.lflang.tests/src/org/lflang/tests/runtime/CSchedulerTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/CSchedulerTest.java index fd2345723f..4730962ee0 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CSchedulerTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CSchedulerTest.java @@ -1,6 +1,7 @@ package org.lflang.tests.runtime; import java.util.EnumSet; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.TargetProperty.SchedulerOption; @@ -21,6 +22,7 @@ public CSchedulerTest() { * (e.g., -Dscheduler=GEDF_NP). */ @Test + @Tag("Integration") public void runWithNonDefaultSchedulers() { EnumSet categories = EnumSet.of(TestCategory.CONCURRENT, TestCategory.MULTIPORT); diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CTest.java similarity index 92% rename from org.lflang.tests/src/org/lflang/tests/runtime/CTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/CTest.java index 4902550661..63122fb4c6 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CTest.java @@ -26,6 +26,7 @@ import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; @@ -46,6 +47,7 @@ public CTest() { } @Override + @Tag("Integration") protected boolean supportsSingleThreadedExecution() { return true; } @@ -61,12 +63,14 @@ protected boolean supportsDockerOption() { } @Test + @Tag("Integration") @Override public void runGenericTests() { super.runGenericTests(); } @Test + @Tag("Integration") @Override public void runTargetSpecificTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -74,18 +78,21 @@ public void runTargetSpecificTests() { } @Test + @Tag("Integration") @Override public void runMultiportTests() { super.runMultiportTests(); } @Test + @Tag("Integration") @Override public void runWithThreadingOff() { super.runWithThreadingOff(); } @Test + @Tag("Integration") @Disabled("TODO only 27/96 tests pass") @Override public void runAsFederated() { @@ -94,12 +101,14 @@ public void runAsFederated() { } @Test + @Tag("Integration") @Override public void runConcurrentTests() { super.runConcurrentTests(); } @Test + @Tag("Integration") @Override public void runFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -107,22 +116,26 @@ public void runFederatedTests() { } @Test + @Tag("Integration") public void runModalTests() { super.runModalTests(); } @Test + @Tag("Integration") public void runNoInliningTests() { super.runNoInliningTests(); } @Test + @Tag("Integration") @Override public void runDockerTests() { super.runDockerTests(); } @Test + @Tag("Integration") @Override public void runDockerFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CZephyrTest.java similarity index 97% rename from org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/CZephyrTest.java index c151c1bb76..777308b221 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CZephyrTest.java @@ -26,6 +26,7 @@ import java.util.List; import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.Configurators; @@ -44,6 +45,7 @@ public CZephyrTest() { } @Test + @Tag("Integration") public void buildZephyrTests() { Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); super.runTestsFor( @@ -56,6 +58,7 @@ public void buildZephyrTests() { } @Test + @Tag("Integration") public void buildGenericTests() { Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); super.runTestsFor( diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CppRos2Test.java similarity index 94% rename from org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/CppRos2Test.java index dc2612c14b..1a333eb145 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CppRos2Test.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CppRos2Test.java @@ -1,6 +1,7 @@ package org.lflang.tests.runtime; import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.ast.ASTUtils; @@ -23,6 +24,7 @@ public CppRos2Test() { /** Run C++ tests with the ros2 target property set */ @Test + @Tag("Integration") public void runWithRos2() { Assumptions.assumeTrue(isLinux(), "Only supported on Linux"); Element trueLiteral = LfFactory.eINSTANCE.createElement(); diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CppTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CppTest.java similarity index 94% rename from org.lflang.tests/src/org/lflang/tests/runtime/CppTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/CppTest.java index 20973189b9..879e6cdc5b 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CppTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/CppTest.java @@ -26,6 +26,7 @@ ***************/ package org.lflang.tests.runtime; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; @@ -50,35 +51,41 @@ protected boolean supportsEnclaves() { } @Test + @Tag("Integration") @Override public void runGenericTests() { super.runGenericTests(); } @Test + @Tag("Integration") @Override public void runTargetSpecificTests() { super.runTargetSpecificTests(); } @Test + @Tag("Integration") @Override public void runMultiportTests() { super.runMultiportTests(); } @Test + @Tag("Integration") @Override public void runConcurrentTests() { super.runConcurrentTests(); } @Test + @Tag("Integration") @Override public void runFederatedTests() { super.runFederatedTests(); } @Test + @Tag("Integration") public void runRos2Tests() {} } diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/PythonTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/PythonTest.java similarity index 94% rename from org.lflang.tests/src/org/lflang/tests/runtime/PythonTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/PythonTest.java index 1c258b7481..e25a3220d2 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/PythonTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/PythonTest.java @@ -27,6 +27,7 @@ import java.util.Properties; import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; @@ -72,24 +73,28 @@ protected boolean supportsDockerOption() { } @Test + @Tag("Integration") @Override public void runGenericTests() { super.runGenericTests(); } @Test + @Tag("Integration") @Override public void runTargetSpecificTests() { super.runTargetSpecificTests(); } @Test + @Tag("Integration") @Override public void runMultiportTests() { super.runMultiportTests(); } @Test + @Tag("Integration") @Disabled("TODO") @Override public void runAsFederated() { @@ -98,12 +103,14 @@ public void runAsFederated() { } @Test + @Tag("Integration") @Override public void runConcurrentTests() { super.runConcurrentTests(); } @Test + @Tag("Integration") @Override public void runFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -111,12 +118,14 @@ public void runFederatedTests() { } @Test + @Tag("Integration") @Override public void runDockerTests() { super.runDockerTests(); } @Test + @Tag("Integration") @Override public void runDockerFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/RustTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/RustTest.java similarity index 100% rename from org.lflang.tests/src/org/lflang/tests/runtime/RustTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/RustTest.java diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/TypeScriptTest.java b/org.lflang/core/src/test/java/org/lflang/tests/runtime/TypeScriptTest.java similarity index 88% rename from org.lflang.tests/src/org/lflang/tests/runtime/TypeScriptTest.java rename to org.lflang/core/src/test/java/org/lflang/tests/runtime/TypeScriptTest.java index 036211607a..0945c3ebe3 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/TypeScriptTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/runtime/TypeScriptTest.java @@ -1,6 +1,7 @@ package org.lflang.tests.runtime; import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; @@ -30,30 +31,35 @@ protected boolean supportsFederatedExecution() { } @Test + @Tag("Integration") @Override public void runGenericTests() { super.runGenericTests(); } @Test + @Tag("Integration") @Override public void runTargetSpecificTests() { super.runTargetSpecificTests(); } @Test + @Tag("Integration") @Override public void runMultiportTests() { super.runMultiportTests(); } @Test + @Tag("Integration") @Override public void runConcurrentTests() { super.runConcurrentTests(); } @Test + @Tag("Integration") @Override public void runFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -61,12 +67,14 @@ public void runFederatedTests() { } @Test + @Tag("Integration") @Override public void runDockerTests() { super.runDockerTests(); } @Test + @Tag("Integration") @Override public void runDockerFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -74,6 +82,7 @@ public void runDockerFederatedTests() { } @Test + @Tag("Integration") @Override public void runAsFederated() {} } diff --git a/org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java b/org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java index 26f3ec37af..25e0983783 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java +++ b/org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java @@ -2,6 +2,7 @@ import java.util.Properties; import org.junit.jupiter.api.Assumptions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.Configurators; @@ -22,6 +23,7 @@ protected void addExtraLfcArgs(Properties args) { } @Test + @Tag("Integration") public void runSerializationTestsWithThreadingOff() { Assumptions.assumeTrue(supportsSingleThreadedExecution(), Message.NO_SINGLE_THREADED_SUPPORT); runTestsForTargets( @@ -33,6 +35,7 @@ public void runSerializationTestsWithThreadingOff() { } @Test + @Tag("Integration") public void runSerializationTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); runTestsForTargets( diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf index fa9c7b25e4..aac8e34712 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf @@ -21,6 +21,7 @@ reactor Sink { auto value = *in.get(); reactor::log::Info() << "Received " << value; auto expected = 100ms * value + 50ms; + 0 = 1; if (get_elapsed_logical_time() != expected) { reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); exit(1); From 8667e9b7573dae6410e58899485a276eb6091d5e Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 15:58:52 +0200 Subject: [PATCH 509/709] update ci wormflows --- .github/workflows/build.yml | 1 - .github/workflows/c-arduino-tests.yml | 8 ++- .github/workflows/c-tests.yml | 14 ++--- .github/workflows/c-zephyr-tests.yml | 8 ++- .github/workflows/ci.yml | 22 +++---- .github/workflows/cpp-ros2-tests.yml | 6 +- .github/workflows/cpp-tests.yml | 8 ++- .github/workflows/lsp-tests.yml | 14 ++--- .github/workflows/py-tests.yml | 9 ++- .github/workflows/rs-tests.yml | 8 ++- .github/workflows/serialization-tests.yml | 6 +- .github/workflows/ts-tests.yml | 7 ++- .../groovy/org.lflang.test-conventions.gradle | 32 +++++++++- org.lflang/core/build.gradle | 60 +++++++++++++++++++ 14 files changed, 150 insertions(+), 53 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 6414b2500f..d5aa64f6da 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -68,4 +68,3 @@ jobs: files: org.lflang/core/build/reports/xml/jacoco,org.lflang/cli/lfc/build/reports/xml/jacoco,org.lflang/cli/lff/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ runner.os == 'Linux' }} diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 167e8f6f1c..cc21b28798 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -59,11 +59,13 @@ jobs: arduino-cli core install arduino:sam arduino-cli core install arduino:mbed - name: Perform Arduino tests for C target with default scheduler - run: ./gradlew test --tests org.lflang.tests.runtime.CArduinoTest.buildArduinoTests + run: ./gradlew integrationCArduino + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.runtime-ref && runner.os == 'Linux' }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 0764128a1b..78b0407c04 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -50,22 +50,22 @@ jobs: uses: ./.github/actions/install-rti if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform tests for C target with default scheduler - run: | - ./gradlew test --tests org.lflang.tests.runtime.CTest.* + run: ./gradlew integrationC if: ${{ !inputs.use-cpp && !inputs.scheduler }} - name: Perform tests for C target with specified scheduler (no LSP tests) run: | echo "Specified scheduler: ${{ inputs.scheduler }}" - ./gradlew test --tests org.lflang.tests.runtime.CSchedulerTest.* -Dscheduler=${{ inputs.scheduler }} + ./gradlew integrationC -Dscheduler=${{ inputs.scheduler }} if: ${{ !inputs.use-cpp && inputs.scheduler }} - name: Perform tests for CCpp target with default scheduler - run: | - ./gradlew test --tests org.lflang.tests.runtime.CCppTest.* + run: ./gradlew integrationCCpp if: ${{ inputs.use-cpp && !inputs.scheduler }} + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 3b7a76feee..490df2c5fa 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -41,12 +41,14 @@ jobs: if: ${{ inputs.runtime-ref }} - name: Perform Zephyr tests for C target with default scheduler run: | - ./gradlew test --tests org.lflang.tests.runtime.CZephyrTest.build* + ./gradlew integrationCZephyr util/RunZephyrTests.sh test/C/src-gen + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.runtime-ref && runner.os == 'Linux' }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index db3dcfd08c..b30e1ae23b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -39,27 +39,27 @@ jobs: # Run language server tests. lsp-tests: - uses: lf-lang/lingua-franca/.github/workflows/lsp-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/lsp-tests.yml@gradle needs: cancel # Run the C integration tests. c-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@gradle needs: cancel # Run the C Arduino integration tests. c-arduino-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-arduino-tests.yml@gradle needs: cancel # Run the C Zephyr integration tests. c-zephyr-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-zephyr-tests.yml@gradle needs: cancel # Run the CCpp integration tests. ccpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/c-tests.yml@gradle with: use-cpp: true needs: cancel @@ -73,22 +73,22 @@ jobs: # Run the C++ integration tests. cpp-tests: - uses: lf-lang/lingua-franca/.github/workflows/cpp-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/cpp-tests.yml@gradle needs: cancel # Run the C++ integration tests on ROS2. cpp-ros2-tests: - uses: lf-lang/lingua-franca/.github/workflows/cpp-ros2-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/cpp-ros2-tests.yml@gradle needs: cancel # Run the Python integration tests. py-tests: - uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/py-tests.yml@gradle needs: cancel # Run the Rust integration tests. rs-tests: - uses: lf-lang/lingua-franca/.github/workflows/rs-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/rs-tests.yml@gradle needs: cancel # Run the Rust benchmark tests. @@ -100,10 +100,10 @@ jobs: # Run the TypeScript integration tests. ts-tests: - uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/ts-tests.yml@gradle needs: cancel # Run the serialization tests serialization-tests: - uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@master + uses: lf-lang/lingua-franca/.github/workflows/serialization-tests.yml@gradle needs: cancel diff --git a/.github/workflows/cpp-ros2-tests.yml b/.github/workflows/cpp-ros2-tests.yml index bfb3e12cb8..6424ce5316 100644 --- a/.github/workflows/cpp-ros2-tests.yml +++ b/.github/workflows/cpp-ros2-tests.yml @@ -34,11 +34,13 @@ jobs: - name: Run C++ tests; run: | source /opt/ros/*/setup.bash - ./gradlew test --tests org.lflang.tests.runtime.CppRos2Test.* + ./gradlew integrationCppRos2 + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index 3fe74ae393..c14a0c5a56 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -43,11 +43,13 @@ jobs: if: ${{ inputs.runtime-ref }} - name: Run C++ tests; run: | - ./gradlew test --tests org.lflang.tests.runtime.CppTest.* - - name: Report Java coverage to CodeCov + ./gradlew integrationCpp + - name: Collect code coverage + run: ./gradlew jacocoTestReport + - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index bf32254b0f..0b5346c0a4 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -64,13 +64,7 @@ jobs: with: python-version: '3.10' - name: Run language server Python tests without PyLint - run: ./gradlew test --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly - - name: Report to CodeCov - uses: codecov/codecov-action@v3.1.1 - with: - file: org.lflang.tests/build/reports/xml/jacoco - fail_ci_if_error: false - verbose: true + run: ./gradlew integration --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly - name: Install pylint run: python3 -m pip install pylint if: ${{ runner.os != 'macOS' }} @@ -78,10 +72,12 @@ jobs: run: brew install pylint if: ${{ runner.os == 'macOS' }} - name: Run language server tests - run: ./gradlew clean test --tests org.lflang.tests.lsp.LspTests.*ValidationTest + run: ./gradlew integration --tests org.lflang.tests.lsp.LspTests.*ValidationTest + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index 3f6e521fd1..33729526b1 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -55,13 +55,12 @@ jobs: path: org.lflang/src/lib/py/reactor-c-py ref: ${{ inputs.reactor-c-py-ref }} if: ${{ inputs.reactor-c-py-ref }} - - name: Run Python tests - run: | - ./gradlew test --tests org.lflang.tests.runtime.PythonTest.* + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index 720efaa29c..ba8ff8923a 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -64,11 +64,13 @@ jobs: # version to the version used at runtime by LF. run: ./gradlew checkRuntimeVersionFileUpToDate - name: Run Rust tests - run: ./gradlew test --tests org.lflang.tests.runtime.RustTest.* + run: ./gradlew integrationRust + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 89f1ad735c..d27ac20b34 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -31,11 +31,13 @@ jobs: - name: Run serialization tests; run: | source /opt/ros/*/setup.bash - ./gradlew test --tests org.lflang.tests.serialization.SerializationTest.* + ./gradlew integrationSerialization + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 4342082868..ae9eb41f78 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -28,10 +28,13 @@ jobs: if: ${{ runner.os == 'macOS' }} - name: Perform TypeScript tests run: | - ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#minor-reorg" + ./gradlew integrationTypeScript -Druntime="git://github.com/lf-lang/reactor-ts.git#minor-reorg" + - name: Collect code coverage + run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - file: org.lflang.tests/build/reports/xml/jacoco + files: org.lflang/core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true + if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 345b78cc88..890bea29f8 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -35,6 +35,9 @@ test { events "passed", "skipped", "failed" showStandardStreams = true } + maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1 + + failFast = true workingDir = rootProject.projectDir } @@ -43,8 +46,8 @@ jacocoTestReport { reports { xml.required = true csv.required = false - html.destination file("${buildDir}/reports/html/jacoco") - xml.destination file("${buildDir}/reports/xml/jacoco") + html.outputLocation = file("${buildDir}/reports/html/jacoco") + xml.outputLocation = file("${buildDir}/reports/xml/jacoco") } afterEvaluate { @@ -58,4 +61,29 @@ jacocoTestReport { ) })) } +} + + + +tasks.register('integration', Test) { + if (System.getProperty('integrationInclude') != null) { + filter { + includeTestsMatching System.getProperty('integrationInclude') + } + } + useJUnitPlatform { + includeTags 'Integration' + + } + testLogging { + events "passed", "skipped", "failed" + showStandardStreams = true + } + // Pass the scheduler and runtime property on to the Java VM + systemProperty 'scheduler', System.getProperty('scheduler') + systemProperty 'runtime', System.getProperty('runtime') + + failFast = true + + workingDir = rootProject.projectDir } \ No newline at end of file diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index 21b8e562b8..c805927df0 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -78,3 +78,63 @@ compileKotlin.dependsOn(generateXtextLanguage) processResources.dependsOn(generateXtextLanguage) clean.dependsOn(cleanGenerateXtextLanguage) spotlessJava.mustRunAfter(generateXtextLanguage) + +tasks.register('integrationLsp') { + System.setProperty('integrationInclude', 'org.lflang.tests.lsp.**') + finalizedBy('integration') +} + +tasks.register('integrationCArduino') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CArduinoTest.*') + finalizedBy('integration') +} + +tasks.register('integrationCCpp') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CCppTest.*') + finalizedBy('integration') +} + +tasks.register('integrationCppRos2') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CppRos2Test.*') + finalizedBy('integration') +} + +tasks.register('integrationCpp') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CppTest.*') + finalizedBy('integration') +} + +tasks.register('integrationCScheduler') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CSchedulerTest.*') + finalizedBy('integration') +} + +tasks.register('integrationC') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CTest.*') + finalizedBy('integration') +} + +tasks.register('integrationCZephyr') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CZephyr.*') + finalizedBy('integration') +} + +tasks.register('integrationPython') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.PythonTest.*') + finalizedBy('integration') +} + +tasks.register('integrationRust') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.RustTest.*') + finalizedBy('integration') +} + +tasks.register('integrationTypeScript') { + System.setProperty('integrationInclude', 'org.lflang.tests.runtime.TypeScriptTest.*') + finalizedBy('integration') +} + +tasks.register('integrationSerialization') { + System.setProperty('integrationInclude', 'org.lflang.tests.serialization.SerializationTest.*') + finalizedBy('integration') +} \ No newline at end of file From df30c1b0c5651b4f0035b103b8b12b6f405bb73f Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 16:06:34 +0200 Subject: [PATCH 510/709] add back cli workflow --- .github/workflows/ci.yml | 4 ++++ .github/workflows/cli-tests.yml | 36 +++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 .github/workflows/cli-tests.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b30e1ae23b..e2d6c432e2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,6 +23,10 @@ jobs: # Test the Gradle build. build: uses: lf-lang/lingua-franca/.github/workflows/build.yml@gradle + needs: cancel- # Run tests for the standalone compiler. + + cli-tests: + uses: lf-lang/lingua-franca/.github/workflows/cli-tests.yml@gradle needs: cancel # Build the tools used for processing execution traces diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml new file mode 100644 index 0000000000..3789d4d800 --- /dev/null +++ b/.github/workflows/cli-tests.yml @@ -0,0 +1,36 @@ +name: CLI tests + +on: + workflow_call: + +jobs: + run: + strategy: + matrix: + platform: [ubuntu-latest, macos-latest, windows-latest] + runs-on: ${{ matrix.platform }} + steps: + - uses: actions/checkout@v3 + with: + submodules: true + fetch-depth: 0 + - name: Prepare build environment + - name: Test lfc bash scripts (Linux or macOS only) + run: | + .github/scripts/test-lfc.sh + if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} + - name: Test lff bash scripts (Linux or macOS only) + run: | + .github/scripts/test-lff.sh + if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} + - name: Test lfc PowerShell script (Windows only) + run: | + ./gradlew buildAll + bin/lfc.ps1 --help + if: ${{ runner.os == 'Windows' }} + - name: Test lff PowerShell script (Windows only) + run: | + ./gradlew buildAll + bin/lff.ps1 --help + if: ${{ runner.os == 'Windows' }} + From 8a176b355fb9cefc58e9d84d88d9dfa12bd0ad4d Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 16:06:52 +0200 Subject: [PATCH 511/709] fix RTI install script --- .github/actions/install-rti/install.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/actions/install-rti/install.sh b/.github/actions/install-rti/install.sh index 05ef9474b7..06ad67bb58 100755 --- a/.github/actions/install-rti/install.sh +++ b/.github/actions/install-rti/install.sh @@ -1,5 +1,5 @@ #!/bin/bash -cd org.lflang/src/lib/c/reactor-c/core/federated/RTI +cd org.lflang/core/src/main/resources/lib/c/reactor-c/core/federated/RTI mkdir build cd build if [[ "$OSTYPE" == "darwin"* ]]; then From f0098d0d39a20735cad7dc32beb0f6d4a33250f2 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 16:14:52 +0200 Subject: [PATCH 512/709] small fixes --- .../src/main/groovy/org.lflang.test-conventions.gradle | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 890bea29f8..336dda5ade 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -34,6 +34,7 @@ test { testLogging { events "passed", "skipped", "failed" showStandardStreams = true + exceptionFormat "full" } maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1 @@ -66,6 +67,9 @@ jacocoTestReport { tasks.register('integration', Test) { + filter { + setFailOnNoMatchingTests(false) + } if (System.getProperty('integrationInclude') != null) { filter { includeTestsMatching System.getProperty('integrationInclude') @@ -78,11 +82,16 @@ tasks.register('integration', Test) { testLogging { events "passed", "skipped", "failed" showStandardStreams = true + exceptionFormat "full" } // Pass the scheduler and runtime property on to the Java VM systemProperty 'scheduler', System.getProperty('scheduler') systemProperty 'runtime', System.getProperty('runtime') + filter { + setFailOnNoMatchingTests(false) + } + failFast = true workingDir = rootProject.projectDir From 540cf3ff0d0c123e344dec2385c6bb75068f7cd3 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 16:16:43 +0200 Subject: [PATCH 513/709] bugfix --- .github/workflows/ci.yml | 3 ++- .github/workflows/cli-tests.yml | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e2d6c432e2..4ad138903f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,8 +23,9 @@ jobs: # Test the Gradle build. build: uses: lf-lang/lingua-franca/.github/workflows/build.yml@gradle - needs: cancel- # Run tests for the standalone compiler. + needs: cancel + # Test our scripts in bin. cli-tests: uses: lf-lang/lingua-franca/.github/workflows/cli-tests.yml@gradle needs: cancel diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 3789d4d800..cddfc54537 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -15,6 +15,7 @@ jobs: submodules: true fetch-depth: 0 - name: Prepare build environment + uses: ./.github/actions/prepare-build-env - name: Test lfc bash scripts (Linux or macOS only) run: | .github/scripts/test-lfc.sh From 0e4d0db324dd19ae59f84f4aab7998ed7ae7551d Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 16:22:24 +0200 Subject: [PATCH 514/709] bugfix in launch script --- util/scripts/launch.ps1 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/scripts/launch.ps1 b/util/scripts/launch.ps1 index 839f022999..6f418a6a60 100644 --- a/util/scripts/launch.ps1 +++ b/util/scripts/launch.ps1 @@ -14,7 +14,7 @@ $mainClassTable = @{"lfc" = "org.lflang.cli.Lfc"; "lff" = "org.lflang.cli.Lff"} $tool = $null foreach ($k in $mainClassTable.Keys) { if ($invokerName.EndsWith($k)) { - tool = $k,,, + $tool = $k break } } From b366efdb527b952416727dca0fb0d3b9ddc81819 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 16:56:59 +0200 Subject: [PATCH 515/709] rust runtime version tasks readded --- .github/workflows/rs-tests.yml | 4 -- org.lflang/core/build.gradle | 76 +++++++++++++++++++++++++++++++++- 2 files changed, 75 insertions(+), 5 deletions(-) diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index ba8ff8923a..d16c556711 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -59,10 +59,6 @@ jobs: with: rust-version: ${{ matrix.rust }} components: clippy - - name: Check runtime-version.properties is up-to-date - # The following task compares the checked out submodule - # version to the version used at runtime by LF. - run: ./gradlew checkRuntimeVersionFileUpToDate - name: Run Rust tests run: ./gradlew integrationRust - name: Collect code coverage diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index c805927df0..615020ec4d 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -137,4 +137,78 @@ tasks.register('integrationTypeScript') { tasks.register('integrationSerialization') { System.setProperty('integrationInclude', 'org.lflang.tests.serialization.SerializationTest.*') finalizedBy('integration') -} \ No newline at end of file +} + +tasks.register('getSubmoduleVersions', Exec) { + description('Run a Git command to get the current status of submodules') + workingDir project.rootDir + // This will make gradle execute git submodule status every time updateRustRuntime is called + outputs.upToDateWhen { false } + + def command = "git submodule status" + if (System.getProperty('os.name').toLowerCase(Locale.ROOT).contains('windows')) { + commandLine 'cmd', '/c', command + } else { + commandLine 'sh', '-c', command + } + standardOutput = new ByteArrayOutputStream() + + ext.outputFile = file("$project.buildDir/submodule-status.properties") + outputs.file(outputFile) + + doLast { + def matcher = standardOutput.toString() =~ ~"(?m)^[-+ ]?([0-9a-f]+) org.lflang/core/src/main/resources/lib/\\w+/reactor-([-a-zA-Z]+)" + def properties = new StringBuilder() + while (matcher.find()) { + def rev = matcher.group(1) + def language = matcher.group(2) + properties << "$language = $rev\n" + } + outputFile.text = properties + } +} + +tasks.register('updateRustRuntime') { + description('Record the VCS revisions of the language runtimes into a properties file available at runtime.') + + dependsOn getSubmoduleVersions + // If the output of the git submodule status did not change (the getSubmoduleVersions task), then this task is considered up to date. + inputs.files(getSubmoduleVersions.outputs) + ext.outputFile = file("$project.projectDir/src/main/resources/lib/rs/runtime-version.properties") + + doLast { + def upToDateProps = new Properties() + getSubmoduleVersions.outputFile.withReader { r -> upToDateProps.load(r) } + outputFile.text = "rs = " + upToDateProps.get("rs") + "\n" + } +} + +tasks.register('checkRuntimeVersionFileUpToDate') { + description('Check that the runtime version recorded in the built Jar for LFC matches the version of the checked out submodule') + dependsOn getSubmoduleVersions + inputs.file "$project.projectDir/src/main/resources/lib/rs/runtime-version.properties" + inputs.dir "$project.projectDir/src/main/resources/lib/rs/reactor-rs" + + doLast { + def rtProps = new Properties() + updateRustRuntime.outputFile.withReader { r -> rtProps.load(r) } + def upToDateProps = new Properties() + getSubmoduleVersions.outputFile.withReader { r -> upToDateProps.load(r) } + + upToDateProps.each { language, rev -> + def actualLanguage = rtProps.get(language) + if (actualLanguage == null) + return + if (actualLanguage != rev) { + logger.error("Runtime for $language is not checked out at correct revision:\n" + + "expected: $rev\n" + + "actual: $actualLanguage\n" + + "You may need to call `./gradlew updateRustRuntime`.") + throw new GradleException("Rust runtime is not up to date") + } else { + logger.info("Success: Runtime for $language is checked out at expected revision $rev") + } + } + } +} +test.dependsOn('checkRuntimeVersionFileUpToDate') \ No newline at end of file From be36edd6d7ba948440e08a6ba9a9ca1cbff17995 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 26 May 2023 17:00:36 +0200 Subject: [PATCH 516/709] bugfix --- test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf | 1 - util/scripts/launch.ps1 | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf index aac8e34712..fa9c7b25e4 100644 --- a/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf +++ b/test/Cpp/src/enclave/EnclaveCommunicationDelayedLocalEvents.lf @@ -21,7 +21,6 @@ reactor Sink { auto value = *in.get(); reactor::log::Info() << "Received " << value; auto expected = 100ms * value + 50ms; - 0 = 1; if (get_elapsed_logical_time() != expected) { reactor::log::Error() << "Expecded value at " << expected << " but received it at " << get_elapsed_logical_time(); exit(1); diff --git a/util/scripts/launch.ps1 b/util/scripts/launch.ps1 index 6f418a6a60..ffeee518ca 100644 --- a/util/scripts/launch.ps1 +++ b/util/scripts/launch.ps1 @@ -29,4 +29,4 @@ $base="$PSScriptRoot\..\..\" $gradlew="${base}/gradlew.bat" # invoke script -& "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args "$@" \ No newline at end of file +& "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args "$args" \ No newline at end of file From 7c6269737011c28ea18aecb19112b6ef0c148bd5 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 26 May 2023 17:34:52 -0700 Subject: [PATCH 517/709] Changes to experiment with the readability of CI results --- .github/workflows/all-non-target-specific.yml | 3 ++- .github/workflows/all-targets.yml | 13 +++++++------ .github/workflows/build-trace-tools.yml | 2 +- .github/workflows/c-tests.yml | 2 +- .github/workflows/only-c.yml | 8 ++++---- .github/workflows/py-tests.yml | 2 +- .github/workflows/rs-tests.yml | 2 +- .github/workflows/ts-tests.yml | 2 +- 8 files changed, 18 insertions(+), 16 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 18102e87be..5e6d27221a 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,4 +1,5 @@ -name: CI (non-target-specific) +# Non-target-specific tests to run on PRs that are ready for review. +name: CI (main) on: workflow_dispatch: diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 16df3b7c83..682e130c44 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -1,4 +1,5 @@ -name: CI (target-specific) +# Target-specific tests to run on PRs that are ready for review. +name: CI (main) on: workflow_dispatch: @@ -19,35 +20,35 @@ concurrency: jobs: # Run the C tests. - c-tests: + c: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-c.yml with: all: true # Run the C++ tests. - cpp-tests: + cpp: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-cpp.yml with: all: true # Run the Python tests. - py-tests: + py: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-py.yml with: all: true # Run the Rust tests. - rs-tests: + rs: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-rs.yml with: all: true # Run the TypeScript tests. - ts-tests: + ts: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-ts.yml with: diff --git a/.github/workflows/build-trace-tools.yml b/.github/workflows/build-trace-tools.yml index 207fe4deb7..d451b3786c 100644 --- a/.github/workflows/build-trace-tools.yml +++ b/.github/workflows/build-trace-tools.yml @@ -1,4 +1,4 @@ -name: Build the tools for processing execution traces +name: Build trace tools on: workflow_call: diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 199fb3b8dd..47eaaf7b80 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -22,7 +22,7 @@ on: type: boolean jobs: - c-tests: + run: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index c635aba13c..7f398f75ac 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -24,28 +24,28 @@ concurrency: jobs: # Run the C benchmark tests. - c-benchmark-tests: + benchmark-tests: if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main with: target: 'C' # Run the C integration tests. - c-tests: + tests: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Arduino integration tests. - c-arduino-tests: + arduino-tests: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-arduino-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Zephyr integration tests. - c-zephyr-tests: + zephyr-tests: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-zephyr-tests.yml diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index c4038d27af..e8ea1eac77 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -18,7 +18,7 @@ on: type: boolean jobs: - py: + run: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index f4bc181dda..dae04b2dc8 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -21,7 +21,7 @@ on: type: boolean jobs: - rs: + run: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 22379b2f5d..c70a356a13 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - ts: + run: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} From eb2b20bf63eba474e94c45c4b84f7eaf1d63fef0 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 26 May 2023 17:44:28 -0700 Subject: [PATCH 518/709] More tweaking of labels --- .github/workflows/c-tests.yml | 2 +- .github/workflows/c-zephyr-tests.yml | 2 +- .github/workflows/only-c.yml | 22 +++++++++++----------- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 47eaaf7b80..bb00466153 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -22,7 +22,7 @@ on: type: boolean jobs: - run: + os-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 288dd54b6d..2af2d2d534 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -18,7 +18,7 @@ on: type: string jobs: - c-zephyr: + zephyr-tests: runs-on: ubuntu-latest steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 7f398f75ac..813913abd3 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -23,34 +23,34 @@ concurrency: cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: - # Run the C benchmark tests. - benchmark-tests: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main - with: - target: 'C' - # Run the C integration tests. - tests: + default: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} + # Run the C benchmark tests. + benchmarking: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + with: + target: 'C' + # Run the C Arduino integration tests. - arduino-tests: + arduino: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-arduino-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Zephyr integration tests. - zephyr-tests: + zephyr: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-zephyr-tests.yml # Run the CCpp integration tests. - ccpp-tests: + ccpp: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: From a9ea2e4d1cd151e5787347a813d9a6d79ba528ed Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 26 May 2023 17:47:28 -0700 Subject: [PATCH 519/709] More label tweaks --- .github/workflows/c-arduino-tests.yml | 2 +- .github/workflows/cpp-ros2-tests.yml | 2 +- .github/workflows/cpp-tests.yml | 2 +- .github/workflows/py-tests.yml | 2 +- .github/workflows/rs-tests.yml | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 873c81b871..c8ba27d144 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -22,7 +22,7 @@ on: type: boolean jobs: - c-arduino: + arduino-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/cpp-ros2-tests.yml b/.github/workflows/cpp-ros2-tests.yml index e48ea2e360..7b3256f130 100644 --- a/.github/workflows/cpp-ros2-tests.yml +++ b/.github/workflows/cpp-ros2-tests.yml @@ -11,7 +11,7 @@ on: type: string jobs: - cpp-ros2: + cpp-ros2-tests: runs-on: ubuntu-latest steps: - name: Check out lingua-franca repository diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index aa138feaaf..2615b76497 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -15,7 +15,7 @@ on: type: boolean jobs: - cpp: + cpp-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index e8ea1eac77..4890d96bc1 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -18,7 +18,7 @@ on: type: boolean jobs: - run: + os-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index dae04b2dc8..26de34e4fe 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -21,7 +21,7 @@ on: type: boolean jobs: - run: + os-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} From cdd0f807fbe1b21f3fcc3e8095c9ad93fb8e2f5d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 26 May 2023 17:53:05 -0700 Subject: [PATCH 520/709] Fix bug introduced by renaming --- .github/workflows/all-non-target-specific.yml | 2 +- .github/workflows/all-targets.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 5e6d27221a..5497de8ceb 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -14,7 +14,7 @@ env: vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_path }} + group: all-non-target-specific-${{ github.ref }}-${{ github.event_path }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 682e130c44..23d21e6dde 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -14,7 +14,7 @@ env: vcpkgGitRef: 0bf3923f9fab4001c00f0f429682a0853b5749e0 concurrency: - group: ${{ github.workflow }}-${{ github.ref }}-${{ github.event_path }} + group: all-targets-${{ github.ref }}-${{ github.event_path }} cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: From e8379d0b2512e0d6853f7aac44c98647360ffb48 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 26 May 2023 18:01:00 -0700 Subject: [PATCH 521/709] More labeling --- .github/workflows/cli-tests.yml | 2 +- .github/workflows/lsp-tests.yml | 2 +- .github/workflows/non-target-specific-extended.yml | 10 +++++----- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 452b08faf6..ce559792f8 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - cli: + cli-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index aa2fcd7f16..7641de9f81 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - lsp: + lsp-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index 2b3bfe8c12..b8d3d5829b 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -31,30 +31,30 @@ concurrency: jobs: # Test the Gradle build. - build: + building: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/build.yml # Build the tools used for processing execution traces - build-tracing-tools: + tracing: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/build-trace-tools.yml with: all-platforms: ${{ !github.event.pull_request.draft }} - check-format: + formatting: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/check-format.yml # Run tests for the standalone compiler. - cli-tests: + cli: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/cli-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run language server tests. - lsp-tests: + lsp: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/lsp-tests.yml with: From aa2790b499e435d76f23fd20e1e4b7d87f7c7a58 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 26 May 2023 22:08:43 -0700 Subject: [PATCH 522/709] Some more label changes --- .github/workflows/all-non-target-specific.yml | 2 +- .github/workflows/all-targets.yml | 2 +- .github/workflows/cli-tests.yml | 2 +- .github/workflows/lsp-tests.yml | 2 +- .github/workflows/non-target-specific-extended.yml | 2 +- .github/workflows/non-target-specific.yml | 6 +++--- 6 files changed, 8 insertions(+), 8 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 5497de8ceb..3d9eb80511 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,5 +1,5 @@ # Non-target-specific tests to run on PRs that are ready for review. -name: CI (main) +name: Catch-all on: workflow_dispatch: diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 23d21e6dde..0e32791c2e 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -1,5 +1,5 @@ # Target-specific tests to run on PRs that are ready for review. -name: CI (main) +name: Catch-all on: workflow_dispatch: diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index ce559792f8..7f643a1be6 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - cli-tests: + test-cli: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index 7641de9f81..bcf1609940 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - lsp-tests: + test-lsp: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index b8d3d5829b..e33902d63e 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -1,4 +1,4 @@ -name: Additional non-target-specific tests +name: Non-target-specific extended on: workflow_dispatch: diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index f662451186..2f7ecedbcd 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -1,4 +1,4 @@ -name: Non-target-specific tests +name: Non-target-specific on: workflow_dispatch: @@ -20,13 +20,13 @@ concurrency: jobs: # Run the unit tests. - unit-tests: + junit: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/unit-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the serialization tests - serialization-tests: + serialization: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/serialization-tests.yml From 3f354bd1d535f3f9a97750bf1af33711e2d1d7a4 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 26 May 2023 22:23:18 -0700 Subject: [PATCH 523/709] Update .github/workflows/only-ts.yml --- .github/workflows/only-ts.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index f6afde4b0b..b8a48bc09e 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -1,4 +1,4 @@ -name: Rust +name: TypeScript on: workflow_dispatch: From 528e7785b78572b0f30d033c47c06ebf3f12f217 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Fri, 26 May 2023 22:23:26 -0700 Subject: [PATCH 524/709] Update .github/workflows/serialization-tests.yml --- .github/workflows/serialization-tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index dffbe83e1f..53a89ffe52 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -8,7 +8,7 @@ on: type: string jobs: - serialization: + serialization-tests: runs-on: ubuntu-latest steps: - name: Check out lingua-franca repository From cc3fe2e2c8478f537bf479428621ca8af4b12c1e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 25 May 2023 22:15:32 -0700 Subject: [PATCH 525/709] First working smoke test. --- .../src/main/java/lfformat/LfFormatStep.java | 67 +++++++++++++------ .../src/main/java/org/lflang/cli/CliBase.java | 31 ++++++++- .../lff/src/main/java/org/lflang/cli/Lff.java | 28 ++++---- 3 files changed, 93 insertions(+), 33 deletions(-) diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index fcc15feaf1..eacb08395a 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -1,11 +1,18 @@ package lfformat; +import com.diffplug.spotless.FormatterFunc; import com.diffplug.spotless.FormatterStep; import java.io.BufferedReader; +import java.io.BufferedWriter; import java.io.File; import java.io.IOException; import java.io.InputStreamReader; +import java.io.OutputStream; +import java.io.OutputStreamWriter; +import java.io.Reader; import java.io.Serializable; +import java.io.Writer; +import java.lang.ProcessBuilder.Redirect; import java.net.URL; import java.net.URLClassLoader; import java.nio.file.Path; @@ -27,32 +34,44 @@ public static FormatterStep create(File projectRoot) { } /** Implement LF-specific formatting functionality. */ - public static class Step implements FormatterStep, Serializable { + public static class Step implements FormatterStep { // The use of the static keyword here is a workaround for serialization difficulties. /** The path to the lingua-franca repository. */ private static Path projectRoot; + private static Process formatter; + private static Writer writer; + + private static BufferedReader reader; + private static BufferedReader error; + @Override public String format( @SuppressWarnings("NullableProblems") String rawUnix, @SuppressWarnings("NullableProblems") File file) throws IOException, InterruptedException { - Process p = runFormatter(file); StringBuilder output = new StringBuilder(); - BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream())); - String line; - while ((line = in.readLine()) != null) { - output.append(line).append("\n"); + getFormatter(); + try { + writer.write(file.getAbsoluteFile().toString().strip() + "\n"); + writer.flush(); + } catch (IOException e) { + getFormatter().waitFor(); + error.lines().forEach(System.out::println); + formatter = null; + throw new RuntimeException("Failed to format " + file + ".\nPlease ensure that this file passes validator checks."); } - int returnCode = p.waitFor(); - if (returnCode != 0) { - throw new RuntimeException("Failed to reformat file. Exit code: " + returnCode + " Output: " + output.toString()); + String line = reader.readLine(); + while (line != null && !line.endsWith("\0")) { + if (!output.isEmpty()) output.append("\n"); + output.append(line); + line = reader.readLine(); } return output.toString(); } - /** Run the formatter on the given file and return the resulting process handle. */ - private Process runFormatter(File file) throws IOException { + private static Process getFormatter() throws IOException { + if (formatter != null) return formatter; final Path lffPath = Path.of( "org.lflang", @@ -63,17 +82,27 @@ private Process runFormatter(File file) throws IOException { "lff", "bin", "lff"); - // It looks silly to invoke Java from Java, but it is necessary in - // order to break the circularity of needing the program to be built - // in order for it to be built. - return new ProcessBuilder( - List.of( - lffPath.toString(), - "--dry-run", - file.getAbsoluteFile().toString())) + formatter = new ProcessBuilder( + List.of( + lffPath.toString(), + "--dry-run", + "--stdin")) .start(); + writer = new BufferedWriter(new OutputStreamWriter(formatter.getOutputStream())); + reader = new BufferedReader(new InputStreamReader(formatter.getInputStream())); + error = new BufferedReader(new InputStreamReader(formatter.getErrorStream())); + return formatter; } +// /** Run the formatter on the given file and return the resulting process handle. */ +// private Process runFormatter(File file) throws IOException { +// // It looks silly to invoke Java from Java, but it is necessary in +// // order to break the circularity of needing the program to be built +// // in order for it to be built. +// var formatter = getFormatter(); +// return formatter; +// } + @SuppressWarnings("NullableProblems") @Override public String getName() { diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java index a6c1c805ed..8a92619193 100644 --- a/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java +++ b/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java @@ -7,8 +7,13 @@ import com.google.inject.Inject; import com.google.inject.Injector; import com.google.inject.Provider; + +import java.io.BufferedInputStream; +import java.io.BufferedReader; import java.io.IOException; +import java.io.InputStreamReader; import java.io.PrintWriter; +import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; @@ -20,6 +25,7 @@ import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.resource.ResourceSet; import org.eclipse.xtext.util.CancelIndicator; +import org.eclipse.xtext.util.RuntimeIOException; import org.eclipse.xtext.validation.CheckMode; import org.eclipse.xtext.validation.IResourceValidator; import org.eclipse.xtext.validation.Issue; @@ -62,6 +68,9 @@ static class MutuallyExclusive { @Option(names = "--json-file", description = "JSON file containing CLI arguments.") private Path jsonFile; + + @Option(names = "--stdin", description = "Read paths to Lingua Franca programs from stdin.") + private boolean stdin; } @ArgGroup(exclusive = true, multiplicity = "1") @@ -164,8 +173,22 @@ protected Path toAbsolutePath(Path other) { * @return Validated input paths. */ protected List getInputPaths() { - List paths = - topLevelArg.files.stream().map(io.getWd()::resolve).collect(Collectors.toList()); + List paths; + if (topLevelArg.stdin) { + var input = new BufferedInputStream(System.in); + var reader = new BufferedReader(new InputStreamReader(input, StandardCharsets.UTF_8)); + String line; + try { + line = reader.readLine(); + } catch (IOException e) { + throw new RuntimeIOException(e); + } + if (line == null) return List.of(); + return List.of(Path.of(line)); + } else { + paths = + topLevelArg.files.stream().map(io.getWd()::resolve).collect(Collectors.toList()); + } for (Path path : paths) { if (!Files.exists(path)) { @@ -176,6 +199,10 @@ protected List getInputPaths() { return paths; } + protected final boolean stdinMode() { + return topLevelArg.stdin; + } + /** * Returns the validated, normalized output path. * diff --git a/org.lflang/cli/lff/src/main/java/org/lflang/cli/Lff.java b/org.lflang/cli/lff/src/main/java/org/lflang/cli/Lff.java index f4f7714119..3626bc1f1c 100644 --- a/org.lflang/cli/lff/src/main/java/org/lflang/cli/Lff.java +++ b/org.lflang/cli/lff/src/main/java/org/lflang/cli/Lff.java @@ -80,20 +80,23 @@ public static void main(Io io, final String... args) { /** Validates all paths and invokes the formatter on the input paths. */ @Override public void doRun() { - List paths = getInputPaths(); - final Path outputRoot = getOutputRoot(); + List paths; + do { + paths = getInputPaths(); + final Path outputRoot = getOutputRoot(); - try { - // Format all files defined by the list of paths. - formatAllFiles(paths, outputRoot); + try { + // Format all files defined by the list of paths. + formatAllFiles(paths, outputRoot); - exitIfCollectedErrors(); - if (!dryRun || verbose) { - reporter.printInfo("Done formatting."); + exitIfCollectedErrors(); + if (!dryRun || verbose) { + reporter.printInfo("Done formatting."); + } + } catch (RuntimeException e) { + reporter.printFatalErrorAndExit("An unexpected error occurred:", e); } - } catch (RuntimeException e) { - reporter.printFatalErrorAndExit("An unexpected error occurred:", e); - } + } while (stdinMode() && !paths.isEmpty()); } /* @@ -155,7 +158,8 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { FormattingUtils.render(resource.getContents().get(0), lineLength); if (dryRun) { - io.getOut().print(formattedFileContents); + io.getOut().println(formattedFileContents); + io.getOut().println("\0"); } else { try { FileUtil.writeToFile(formattedFileContents, outputPath, true); From aea87a0814ccf76fea9b4a74548e7a5aaf582014 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 26 May 2023 12:33:08 -0700 Subject: [PATCH 526/709] Handle shutdown. This terminates the spawned formatter by closing its input stream. The formatter should detect that the stream is closed and understand that it will not receive any more files to format and exit gracefully. This prevents the formatter from outliving its Gradle daemon. If the daemon is terminated forcefully e.g. with a -9 SIGTERM rather than a -15 SIGKILL, then this will not work. Otherwise I believe that this should release the resource (get rid of the spawned formatter) correctly. --- .../src/main/java/lfformat/LfFormatStep.java | 36 ++++++++++++++----- 1 file changed, 28 insertions(+), 8 deletions(-) diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index eacb08395a..8b147accb0 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -9,12 +9,15 @@ import java.io.InputStreamReader; import java.io.OutputStream; import java.io.OutputStreamWriter; +import java.io.PrintWriter; import java.io.Reader; import java.io.Serializable; import java.io.Writer; import java.lang.ProcessBuilder.Redirect; import java.net.URL; import java.net.URLClassLoader; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; import java.nio.file.Path; import java.util.List; import java.util.Locale; @@ -28,16 +31,17 @@ public final class LfFormatStep { private LfFormatStep() {} /** Return a {@code FormatterStep} for LF code. */ - public static FormatterStep create(File projectRoot) { + public static FormatterStep create(File projectRoot) throws IOException { Step.projectRoot = projectRoot.toPath(); - return new Step(); + return Step.getInstance(); } /** Implement LF-specific formatting functionality. */ - public static class Step implements FormatterStep { + private static class Step implements FormatterStep { // The use of the static keyword here is a workaround for serialization difficulties. /** The path to the lingua-franca repository. */ private static Path projectRoot; + private static Step instance; private static Process formatter; private static Writer writer; @@ -45,18 +49,36 @@ public static class Step implements FormatterStep { private static BufferedReader reader; private static BufferedReader error; + public static Step getInstance() throws IOException { + if (instance == null) instance = new Step(); + return instance; + } + + private Step() throws IOException { + initializeFormatter(); + Runtime.getRuntime().addShutdownHook(new Thread(() -> { + try { + writer.close(); + formatter.waitFor(); + reader.close(); + error.close(); + } catch (IOException | InterruptedException e) { + throw new RuntimeException(e); + } + })); + } + @Override public String format( @SuppressWarnings("NullableProblems") String rawUnix, @SuppressWarnings("NullableProblems") File file) throws IOException, InterruptedException { StringBuilder output = new StringBuilder(); - getFormatter(); try { writer.write(file.getAbsoluteFile().toString().strip() + "\n"); writer.flush(); } catch (IOException e) { - getFormatter().waitFor(); + formatter.waitFor(); error.lines().forEach(System.out::println); formatter = null; throw new RuntimeException("Failed to format " + file + ".\nPlease ensure that this file passes validator checks."); @@ -70,8 +92,7 @@ public String format( return output.toString(); } - private static Process getFormatter() throws IOException { - if (formatter != null) return formatter; + private void initializeFormatter() throws IOException { final Path lffPath = Path.of( "org.lflang", @@ -91,7 +112,6 @@ private static Process getFormatter() throws IOException { writer = new BufferedWriter(new OutputStreamWriter(formatter.getOutputStream())); reader = new BufferedReader(new InputStreamReader(formatter.getInputStream())); error = new BufferedReader(new InputStreamReader(formatter.getErrorStream())); - return formatter; } // /** Run the formatter on the given file and return the resulting process handle. */ From 0a733c4319eec54c7f08354c0f937eb0c029c58f Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 26 May 2023 13:45:30 -0700 Subject: [PATCH 527/709] Apply Java formatter. --- .../src/main/java/lfformat/LfFormatStep.java | 48 +++++++++---------- .../src/main/java/org/lflang/cli/CliBase.java | 4 +- 2 files changed, 23 insertions(+), 29 deletions(-) diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index 8b147accb0..24b2df4d25 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -1,23 +1,15 @@ package lfformat; -import com.diffplug.spotless.FormatterFunc; import com.diffplug.spotless.FormatterStep; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.IOException; import java.io.InputStreamReader; -import java.io.OutputStream; import java.io.OutputStreamWriter; -import java.io.PrintWriter; -import java.io.Reader; -import java.io.Serializable; import java.io.Writer; -import java.lang.ProcessBuilder.Redirect; import java.net.URL; import java.net.URLClassLoader; -import java.nio.charset.StandardCharsets; -import java.nio.file.Files; import java.nio.file.Path; import java.util.List; import java.util.Locale; @@ -41,6 +33,7 @@ private static class Step implements FormatterStep { // The use of the static keyword here is a workaround for serialization difficulties. /** The path to the lingua-franca repository. */ private static Path projectRoot; + private static Step instance; private static Process formatter; @@ -56,16 +49,19 @@ public static Step getInstance() throws IOException { private Step() throws IOException { initializeFormatter(); - Runtime.getRuntime().addShutdownHook(new Thread(() -> { - try { - writer.close(); - formatter.waitFor(); - reader.close(); - error.close(); - } catch (IOException | InterruptedException e) { - throw new RuntimeException(e); - } - })); + Runtime.getRuntime() + .addShutdownHook( + new Thread( + () -> { + try { + writer.close(); + formatter.waitFor(); + reader.close(); + error.close(); + } catch (IOException | InterruptedException e) { + throw new RuntimeException(e); + } + })); } @Override @@ -114,14 +110,14 @@ private void initializeFormatter() throws IOException { error = new BufferedReader(new InputStreamReader(formatter.getErrorStream())); } -// /** Run the formatter on the given file and return the resulting process handle. */ -// private Process runFormatter(File file) throws IOException { -// // It looks silly to invoke Java from Java, but it is necessary in -// // order to break the circularity of needing the program to be built -// // in order for it to be built. -// var formatter = getFormatter(); -// return formatter; -// } + // /** Run the formatter on the given file and return the resulting process handle. */ + // private Process runFormatter(File file) throws IOException { + // // It looks silly to invoke Java from Java, but it is necessary in + // // order to break the circularity of needing the program to be built + // // in order for it to be built. + // var formatter = getFormatter(); + // return formatter; + // } @SuppressWarnings("NullableProblems") @Override diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java index 8a92619193..6c7cad18fc 100644 --- a/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java +++ b/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java @@ -7,7 +7,6 @@ import com.google.inject.Inject; import com.google.inject.Injector; import com.google.inject.Provider; - import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.IOException; @@ -186,8 +185,7 @@ protected List getInputPaths() { if (line == null) return List.of(); return List.of(Path.of(line)); } else { - paths = - topLevelArg.files.stream().map(io.getWd()::resolve).collect(Collectors.toList()); + paths = topLevelArg.files.stream().map(io.getWd()::resolve).collect(Collectors.toList()); } for (Path path : paths) { From 9efabae1ca04c541c531ded450d8167c223ea977 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 26 May 2023 13:56:23 -0700 Subject: [PATCH 528/709] Address warnings. --- buildSrc/src/main/java/lfformat/LfFormatStep.java | 11 +---------- .../base/src/main/java/org/lflang/cli/CliBase.java | 3 +-- 2 files changed, 2 insertions(+), 12 deletions(-) diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index 24b2df4d25..9ae518c63f 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -67,7 +67,7 @@ private Step() throws IOException { @Override public String format( @SuppressWarnings("NullableProblems") String rawUnix, - @SuppressWarnings("NullableProblems") File file) + File file) throws IOException, InterruptedException { StringBuilder output = new StringBuilder(); try { @@ -110,15 +110,6 @@ private void initializeFormatter() throws IOException { error = new BufferedReader(new InputStreamReader(formatter.getErrorStream())); } - // /** Run the formatter on the given file and return the resulting process handle. */ - // private Process runFormatter(File file) throws IOException { - // // It looks silly to invoke Java from Java, but it is necessary in - // // order to break the circularity of needing the program to be built - // // in order for it to be built. - // var formatter = getFormatter(); - // return formatter; - // } - @SuppressWarnings("NullableProblems") @Override public String getName() { diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java b/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java index 6c7cad18fc..3a8724f816 100644 --- a/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java +++ b/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java @@ -24,7 +24,6 @@ import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.emf.ecore.resource.ResourceSet; import org.eclipse.xtext.util.CancelIndicator; -import org.eclipse.xtext.util.RuntimeIOException; import org.eclipse.xtext.validation.CheckMode; import org.eclipse.xtext.validation.IResourceValidator; import org.eclipse.xtext.validation.Issue; @@ -180,7 +179,7 @@ protected List getInputPaths() { try { line = reader.readLine(); } catch (IOException e) { - throw new RuntimeIOException(e); + throw new RuntimeException(e); } if (line == null) return List.of(); return List.of(Path.of(line)); From 32e74b54987d0ec106b6d7b012d8e093f4242ce1 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 26 May 2023 14:04:38 -0700 Subject: [PATCH 529/709] Apply Java formatter. --- buildSrc/src/main/java/lfformat/LfFormatStep.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index 9ae518c63f..dfa788562a 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -65,9 +65,7 @@ private Step() throws IOException { } @Override - public String format( - @SuppressWarnings("NullableProblems") String rawUnix, - File file) + public String format(@SuppressWarnings("NullableProblems") String rawUnix, File file) throws IOException, InterruptedException { StringBuilder output = new StringBuilder(); try { From 433b9e66f7c912187783fad6cfcc684c788ead14 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 26 May 2023 16:00:11 -0700 Subject: [PATCH 530/709] Bugfix. --- buildSrc/src/main/java/lfformat/LfFormatStep.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index dfa788562a..18d709a782 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -74,7 +74,7 @@ public String format(@SuppressWarnings("NullableProblems") String rawUnix, File } catch (IOException e) { formatter.waitFor(); error.lines().forEach(System.out::println); - formatter = null; + initializeFormatter(); throw new RuntimeException("Failed to format " + file + ".\nPlease ensure that this file passes validator checks."); } String line = reader.readLine(); From fe8dfb901332f5bd7bde1a748f0fb05b566391f3 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 12:31:48 -0700 Subject: [PATCH 531/709] Work around build dependency issue. The problem was not that Gradle runs any spotlessLinguaFranca tasks as part of its other operations, but that it configures the task before starting any other operation (including clean). The solution is to start the formatter lazily -- to wait until spotlessLinguaFranca actually operates on a file before trying to start up the formatter process. --- build.gradle | 12 ++-- .../src/main/java/lfformat/LfFormatStep.java | 60 +++++++++---------- 2 files changed, 35 insertions(+), 37 deletions(-) diff --git a/build.gradle b/build.gradle index 43a28acccf..9164e447fc 100644 --- a/build.gradle +++ b/build.gradle @@ -16,15 +16,15 @@ spotless { endWithNewline() } -// format 'linguaFranca', { -// addStep(LfFormatStep.create(project.projectDir)) -// target 'test/*/src/**/*.lf' // you have to set the target manually -// targetExclude 'test/**/failing/**' -// } + format 'linguaFranca', { + addStep(LfFormatStep.create()) + target 'test/*/src/**/*.lf' // you have to set the target manually + targetExclude 'test/**/failing/**' + } } -//spotlessLinguaFranca.dependsOn(":org.lflang:cli:lff:installDist") +spotlessLinguaFranca.dependsOn(":org.lflang:cli:lff:installDist") distributions { diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index 18d709a782..92489acbfc 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -8,12 +8,8 @@ import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.Writer; -import java.net.URL; -import java.net.URLClassLoader; import java.nio.file.Path; import java.util.List; -import java.util.Locale; -import java.util.ResourceBundle; /** * {@code LfFormatStep} is used by the Spotless Gradle plugin as a custom formatting step for @@ -23,18 +19,14 @@ public final class LfFormatStep { private LfFormatStep() {} /** Return a {@code FormatterStep} for LF code. */ - public static FormatterStep create(File projectRoot) throws IOException { - Step.projectRoot = projectRoot.toPath(); - return Step.getInstance(); + public static FormatterStep create() throws IOException, InterruptedException { + return new Step(); } /** Implement LF-specific formatting functionality. */ private static class Step implements FormatterStep { // The use of the static keyword here is a workaround for serialization difficulties. /** The path to the lingua-franca repository. */ - private static Path projectRoot; - - private static Step instance; private static Process formatter; private static Writer writer; @@ -42,31 +34,14 @@ private static class Step implements FormatterStep { private static BufferedReader reader; private static BufferedReader error; - public static Step getInstance() throws IOException { - if (instance == null) instance = new Step(); - return instance; - } - - private Step() throws IOException { - initializeFormatter(); - Runtime.getRuntime() - .addShutdownHook( - new Thread( - () -> { - try { - writer.close(); - formatter.waitFor(); - reader.close(); - error.close(); - } catch (IOException | InterruptedException e) { - throw new RuntimeException(e); - } - })); + private Step() throws IOException, InterruptedException { + terminateFormatter(); } @Override public String format(@SuppressWarnings("NullableProblems") String rawUnix, File file) throws IOException, InterruptedException { + initializeFormatter(); StringBuilder output = new StringBuilder(); try { writer.write(file.getAbsoluteFile().toString().strip() + "\n"); @@ -74,6 +49,7 @@ public String format(@SuppressWarnings("NullableProblems") String rawUnix, File } catch (IOException e) { formatter.waitFor(); error.lines().forEach(System.out::println); + formatter = null; initializeFormatter(); throw new RuntimeException("Failed to format " + file + ".\nPlease ensure that this file passes validator checks."); } @@ -86,7 +62,9 @@ public String format(@SuppressWarnings("NullableProblems") String rawUnix, File return output.toString(); } - private void initializeFormatter() throws IOException { + /** Idempotently initialize the formatter. */ + private static void initializeFormatter() throws IOException { + if (formatter != null) return; final Path lffPath = Path.of( "org.lflang", @@ -106,6 +84,26 @@ private void initializeFormatter() throws IOException { writer = new BufferedWriter(new OutputStreamWriter(formatter.getOutputStream())); reader = new BufferedReader(new InputStreamReader(formatter.getInputStream())); error = new BufferedReader(new InputStreamReader(formatter.getErrorStream())); + Runtime.getRuntime() + .addShutdownHook( + new Thread( + () -> { + try { + terminateFormatter(); + } catch (IOException | InterruptedException e) { + throw new RuntimeException(e); + } + })); + } + + /** Idempotently trigger a graceful termination of the formatter. */ + private static void terminateFormatter() throws IOException, InterruptedException { + if (formatter == null) return; + writer.close(); + formatter.waitFor(); + reader.close(); + error.close(); + formatter = null; } @SuppressWarnings("NullableProblems") From 519fb5eda62de7992f5c59bd04c8f6de3040eced Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 14:46:00 -0700 Subject: [PATCH 532/709] Try to put check-diff in reusable workflow. --- .github/scripts/changed.sh | 10 ++++ .github/workflows/all-non-target-specific.yml | 46 +++++++++++++++---- .github/workflows/all-targets.yml | 22 +++++---- .github/workflows/check-diff.yml | 41 +++++++++++++++++ .../non-target-specific-extended.yml | 13 ------ .github/workflows/non-target-specific.yml | 3 -- .github/workflows/only-c.yml | 7 --- .github/workflows/only-cpp.yml | 6 --- .github/workflows/only-py.yml | 6 --- .github/workflows/only-rs.yml | 6 --- .github/workflows/only-ts.yml | 6 --- 11 files changed, 99 insertions(+), 67 deletions(-) create mode 100644 .github/scripts/changed.sh create mode 100644 .github/workflows/check-diff.yml diff --git a/.github/scripts/changed.sh b/.github/scripts/changed.sh new file mode 100644 index 0000000000..9fc3a4388e --- /dev/null +++ b/.github/scripts/changed.sh @@ -0,0 +1,10 @@ +changes() { + git diff --name-only --diff-filter=AMDR --cached origin/master +} + +if changes | grep -q $1; then + echo "::set-output name=CHANGED_$2::1" +else + echo "::set-output name=CHANGED_$2::0" +fi + diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 3d9eb80511..73b63b53e3 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -19,16 +19,42 @@ concurrency: jobs: - # Run the non-target-specific tests. - non-target-specific: - if: ${{ !github.event.pull_request.draft }} - uses: ./.github/workflows/non-target-specific.yml + junit: + uses: ./.github/workflows/unit-tests.yml with: - all: true + all-platforms: ${{ !github.event.pull_request.draft }} - # Run the non-target-specific tests. - non-target-specific-extended: - if: ${{ !github.event.pull_request.draft }} - uses: ./.github/workflows/non-target-specific-extended.yml + # Run the serialization tests + serialization: + if: ${{ github.event.pull_request.draft }} + uses: ./.github/workflows/serialization-tests.yml + + # Test the Gradle build. + building: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/build.yml + + # Build the tools used for processing execution traces + tracing: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/build-trace-tools.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + + formatting: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/check-format.yml + + # Run tests for the standalone compiler. + cli: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/cli-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + + # Run language server tests. + lsp: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/lsp-tests.yml with: - all: true + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 0e32791c2e..5257dc5d82 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -18,38 +18,40 @@ concurrency: cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: + check: + uses: ./.github/workflows/check-diff.yml - # Run the C tests. c: - if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-c.yml with: all: true + needs: check + if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-c == 1 }} - # Run the C++ tests. cpp: - if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-cpp.yml with: all: true + needs: check + if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-cpp == 1 }} - # Run the Python tests. py: - if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-py.yml with: all: true + needs: check + if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-py == 1 }} - # Run the Rust tests. rs: - if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-rs.yml with: all: true + needs: check + if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-rs == 1 }} - # Run the TypeScript tests. ts: - if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/only-ts.yml with: all: true + needs: check + if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-ts == 1 }} diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml new file mode 100644 index 0000000000..9b30be2b1c --- /dev/null +++ b/.github/workflows/check-diff.yml @@ -0,0 +1,41 @@ +name: Check diff from master + +on: + workflow_call: + outputs: + changed-c: + value: ${{ jobs.check.outputs.changed-c }} + changed-cpp: + value: ${{ jobs.check.outputs.changed-cpp }} + changed-py: + value: ${{ jobs.check.outputs.changed-py }} + changed-rs: + value: ${{ jobs.check.outputs.changed-rs }} + changed-ts: + value: ${{ jobs.check.outputs.changed-ts }} + +jobs: + check: + runs-on: ubuntu-latest + outputs: + changed-c: ${{ steps.do.outputs.CHANGED_C }} + changed-cpp: ${{ steps.do.outputs.CHANGED_CPP }} + changed-py: ${{ steps.do.outputs.CHANGED_PY }} + changed-rs: ${{ steps.do.outputs.CHANGED_RS }} + changed-ts: ${{ steps.do.outputs.CHANGED_TS }} + steps: + - name: Check out lingua-franca repository + uses: actions/checkout@v3 + with: + repository: lf-lang/lingua-franca + submodules: true + fetch-depth: 0 + - id: do + run: | + wget https://raw.githubusercontent.com/lf-lang/lingua-franca/reduce-testing/.github/scripts/changed.sh + source changed.sh "org.lflang.generator.c/\|org.lflang/src/lib/c/\|org.lflang/src/lib/platform/" C + source changed.sh "org.lflang/src/org/lflang/generator/cpp/\|org.lflang/src/lib/cpp/" CPP + source changed.sh "org.lflang/src/org/lflang/generator/python/\|org.lflang/src/lib/py/" PY + source changed.sh "org.lflang/src/org/lflang/generator/rust/\|org.lflang/src/lib/rs/" RS + source changed.sh "org.lflang/src/org/lflang/generator/ts/\|org.lflang/src/lib/ts/" TS + shell: bash diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index e33902d63e..bdfc4181aa 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -6,19 +6,6 @@ on: inputs: all: type: boolean - pull_request: - paths-ignore: - - 'org.lflang/src/org/lflang/generator/c/**' - - 'org.lflang/src/org/lflang/generator/cpp/**' - - 'org.lflang/src/org/lflang/generator/python/**' - - 'org.lflang/src/org/lflang/generator/rust/**' - - 'org.lflang/src/org/lflang/generator/ts/**' - - 'org.lflang/src/lib/c/**' - - 'org.lflang/src/lib/platform/**' - - 'org.lflang/src/lib/cpp/**' - - 'org.lflang/src/lib/py/**' - - 'org.lflang/src/lib/rs/**' - - 'org.lflang/src/lib/ts/**' env: # 2020.11 diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index 2f7ecedbcd..2ea4f4499d 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -6,9 +6,6 @@ on: inputs: all: type: boolean - pull_request: - branches-ignore: - - 'nightly' env: # 2020.11 diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 813913abd3..94f588c094 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -6,13 +6,6 @@ on: inputs: all: type: boolean - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/c/**' - - 'org.lflang/src/lib/c/**' - - 'org.lflang/src/lib/platform/**' env: # 2020.11 diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index 22bc7fb814..54bd85a24f 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -6,12 +6,6 @@ on: inputs: all: type: boolean - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/cpp/**' - - 'org.lflang/src/lib/cpp/**' env: # 2020.11 diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index 5adf989661..be3aa2f0f8 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -6,12 +6,6 @@ on: inputs: all: type: boolean - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/python/**' - - 'org.lflang/src/lib/py/**' env: # 2020.11 diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 1dd0dfbf56..d944a5bb2f 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -6,12 +6,6 @@ on: inputs: all: type: boolean - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/rust/**' - - 'org.lflang/src/lib/rs/**' env: # 2020.11 diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index b8a48bc09e..216b5bca9c 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -6,12 +6,6 @@ on: inputs: all: type: boolean - pull_request: - branches-ignore: - - 'nightly' - paths: - - 'org.lflang/src/org/lflang/generator/ts/**' - - 'org.lflang/src/lib/ts/**' env: # 2020.11 From 8cc809dc1e89f4fd9d30d70b1e2a76fc753b0345 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 16:40:32 -0700 Subject: [PATCH 533/709] More increases in selectivity. --- .github/workflows/all-non-target-specific.yml | 27 +++++++++---------- .github/workflows/all-targets.yml | 27 +++++++++++-------- .github/workflows/c-arduino-tests.yml | 2 +- .github/workflows/c-tests.yml | 2 +- .github/workflows/check-diff.yml | 4 +++ .github/workflows/cli-tests.yml | 2 +- .github/workflows/cpp-tests.yml | 4 +-- .github/workflows/lsp-tests.yml | 2 ++ .github/workflows/py-tests.yml | 2 +- .github/workflows/rs-tests.yml | 2 +- .github/workflows/ts-tests.yml | 1 + .github/workflows/unit-tests.yml | 1 + 12 files changed, 44 insertions(+), 32 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 73b63b53e3..166694a51f 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -18,43 +18,42 @@ concurrency: cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: + check-diff: + uses: ./.github/workflows/check-diff.yml junit: uses: ./.github/workflows/unit-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} - - # Run the serialization tests - serialization: - if: ${{ github.event.pull_request.draft }} - uses: ./.github/workflows/serialization-tests.yml + all-platforms: ${{ !github.event.pull_request.draft }} # Test the Gradle build. building: - if: ${{ inputs.all || github.event.pull_request.draft }} + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/build.yml # Build the tools used for processing execution traces tracing: - if: ${{ inputs.all || github.event.pull_request.draft }} + if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-tracing == 1 }} uses: ./.github/workflows/build-trace-tools.yml + needs: + check-diff with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} formatting: - if: ${{ inputs.all || github.event.pull_request.draft }} + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/check-format.yml # Run tests for the standalone compiler. cli: - if: ${{ inputs.all || github.event.pull_request.draft }} + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/cli-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} # Run language server tests. lsp: - if: ${{ inputs.all || github.event.pull_request.draft }} + if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/lsp-tests.yml with: - all-platforms: ${{ !github.event.pull_request.draft }} + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 5257dc5d82..0948665eea 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -18,40 +18,45 @@ concurrency: cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: - check: + check-diff: uses: ./.github/workflows/check-diff.yml c: uses: ./.github/workflows/only-c.yml with: all: true - needs: check - if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-c == 1 }} + needs: check-diff + if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-c == 1 }} cpp: uses: ./.github/workflows/only-cpp.yml with: all: true - needs: check - if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-cpp == 1 }} + needs: check-diff + if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-cpp == 1 }} py: uses: ./.github/workflows/only-py.yml with: all: true - needs: check - if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-py == 1 }} + needs: check-diff + if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-py == 1 }} rs: uses: ./.github/workflows/only-rs.yml with: all: true - needs: check - if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-rs == 1 }} + needs: check-diff + if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-rs == 1 }} ts: uses: ./.github/workflows/only-ts.yml with: all: true - needs: check - if: ${{ !github.event.pull_request.draft || needs.check.outputs.changed-ts == 1 }} + needs: check-diff + if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-ts == 1 }} + + serialization: + if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-c == 1 || needs.check-diff.outputs.changed-py == 1 || needs.check-diff.outputs.changed-ts == 1 }} + needs: check-diff + uses: ./.github/workflows/serialization-tests.yml diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index c8ba27d144..5f5358301a 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -70,4 +70,4 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.runtime-ref && runner.os == 'Linux' }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.runtime-ref && runner.os == 'Linux' && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index bb00466153..072151d219 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -72,4 +72,4 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.compiler-ref && runner.os == 'Linux' && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index 9b30be2b1c..a9d169b9c8 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -13,6 +13,8 @@ on: value: ${{ jobs.check.outputs.changed-rs }} changed-ts: value: ${{ jobs.check.outputs.changed-ts }} + changed-tracing: + value: ${{ jobs.check.outputs.changed-tracing }} jobs: check: @@ -23,6 +25,7 @@ jobs: changed-py: ${{ steps.do.outputs.CHANGED_PY }} changed-rs: ${{ steps.do.outputs.CHANGED_RS }} changed-ts: ${{ steps.do.outputs.CHANGED_TS }} + changed-tracing: ${{ steps.do.outputs.CHANGED_TRACING }} steps: - name: Check out lingua-franca repository uses: actions/checkout@v3 @@ -38,4 +41,5 @@ jobs: source changed.sh "org.lflang/src/org/lflang/generator/python/\|org.lflang/src/lib/py/" PY source changed.sh "org.lflang/src/org/lflang/generator/rust/\|org.lflang/src/lib/rs/" RS source changed.sh "org.lflang/src/org/lflang/generator/ts/\|org.lflang/src/lib/ts/" TS + source changed.sh "util/tracing" TRACING shell: bash diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 7f643a1be6..40cd92ec37 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -48,4 +48,4 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ runner.os == 'Linux' }} + if: ${{ runner.os == 'Linux' && inputs.all-platforms }} diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index 2615b76497..dbee4e2ac5 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -55,7 +55,7 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.runtime-ref && inputs.all-platforms }} # i.e., if this is part of the main repo's CI - name: Collect reactor-cpp coverage data run: | lcov --capture --directory test/Cpp --output-file coverage.info @@ -74,4 +74,4 @@ jobs: file: reactor-cpp.info fail_ci_if_error: false verbose: true - if: matrix.platform == 'ubuntu-latest' + if: ${{ runner.os == 'Linux' && inputs.all-platforms }} diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index bcf1609940..bbba12f03c 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -76,6 +76,7 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true + if: ${{ runner.os == 'Linux' && inputs.all-platforms }} - name: Install pylint run: python3 -m pip install pylint if: ${{ runner.os != 'macOS' }} @@ -90,3 +91,4 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true + if: ${{ runner.os == 'Linux' && inputs.all-platforms }} diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index 4890d96bc1..8dc7641ed2 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -68,4 +68,4 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.compiler-ref && runner.os == 'Linux' && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index 26de34e4fe..e5d0a4681e 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -75,4 +75,4 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true - if: ${{ !inputs.compiler-ref }} # i.e., if this is part of the main repo's CI + if: ${{ !inputs.compiler-ref && runner.os == 'Linux' && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index c70a356a13..5afcbc231d 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -40,3 +40,4 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true + if: ${{ runner.os == 'Linux' && inputs.all-platforms }} diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml index c8cbe1fd1f..75dc336058 100644 --- a/.github/workflows/unit-tests.yml +++ b/.github/workflows/unit-tests.yml @@ -30,3 +30,4 @@ jobs: file: org.lflang.tests/build/reports/xml/jacoco fail_ci_if_error: false verbose: true + if: ${{ runner.os == 'Linux' && inputs.all-platforms }} From eef1f96c3cff4665994979d2a1eef3dbeb2b30ce Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 16:49:56 -0700 Subject: [PATCH 534/709] Check out the same submodule as in master. I had pushed a trivial whitespace change to main because I added yaml files to the formatter configuration, but to keep things simple I think it's better not to account for that in this branch. --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 83b1cef7fd..880fb34310 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 83b1cef7fd4209b3e25b6a310ce8f964277d9692 +Subproject commit 880fb343109d150cd853208c368641863050df4f From b710023c9b24c74d5fc7e0563e64c4e4cae0371d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 16:56:34 -0700 Subject: [PATCH 535/709] Address deprecation warning. --- .github/scripts/changed.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/scripts/changed.sh b/.github/scripts/changed.sh index 9fc3a4388e..8fa9e72b1a 100644 --- a/.github/scripts/changed.sh +++ b/.github/scripts/changed.sh @@ -3,8 +3,8 @@ changes() { } if changes | grep -q $1; then - echo "::set-output name=CHANGED_$2::1" + echo "CHANGED_$2=1" >> $GITHUB_OUTPUT else - echo "::set-output name=CHANGED_$2::0" + echo "CHANGED_$2=0" >> $GITHUB_OUTPUT fi From 129c3b06bcdc410c591c20cf59928225fa672a6b Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 17:53:51 -0700 Subject: [PATCH 536/709] The integration tests are also target-specific. --- .github/workflows/check-diff.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index a9d169b9c8..5848ebdb9e 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -36,10 +36,10 @@ jobs: - id: do run: | wget https://raw.githubusercontent.com/lf-lang/lingua-franca/reduce-testing/.github/scripts/changed.sh - source changed.sh "org.lflang.generator.c/\|org.lflang/src/lib/c/\|org.lflang/src/lib/platform/" C - source changed.sh "org.lflang/src/org/lflang/generator/cpp/\|org.lflang/src/lib/cpp/" CPP - source changed.sh "org.lflang/src/org/lflang/generator/python/\|org.lflang/src/lib/py/" PY - source changed.sh "org.lflang/src/org/lflang/generator/rust/\|org.lflang/src/lib/rs/" RS - source changed.sh "org.lflang/src/org/lflang/generator/ts/\|org.lflang/src/lib/ts/" TS + source changed.sh "org.lflang.generator.c/\|org.lflang/src/lib/c/\|org.lflang/src/lib/platform/\|test/C" C + source changed.sh "org.lflang/src/org/lflang/generator/cpp/\|org.lflang/src/lib/cpp/\|test/Cpp" CPP + source changed.sh "org.lflang/src/org/lflang/generator/python/\|org.lflang/src/lib/py/\|test/Python" PY + source changed.sh "org.lflang/src/org/lflang/generator/rust/\|org.lflang/src/lib/rs/\|test/Rust" RS + source changed.sh "org.lflang/src/org/lflang/generator/ts/\|org.lflang/src/lib/ts/\|test/TypeScript" TS source changed.sh "util/tracing" TRACING shell: bash From 4948a6aa287f84b582336453c110051472a4ea42 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 17:58:19 -0700 Subject: [PATCH 537/709] Rename changed.sh -> check-diff.sh. --- .github/scripts/{changed.sh => check-diff.sh} | 0 .github/workflows/check-diff.yml | 14 +++++++------- 2 files changed, 7 insertions(+), 7 deletions(-) rename .github/scripts/{changed.sh => check-diff.sh} (100%) diff --git a/.github/scripts/changed.sh b/.github/scripts/check-diff.sh similarity index 100% rename from .github/scripts/changed.sh rename to .github/scripts/check-diff.sh diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index 5848ebdb9e..6be192aa02 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -35,11 +35,11 @@ jobs: fetch-depth: 0 - id: do run: | - wget https://raw.githubusercontent.com/lf-lang/lingua-franca/reduce-testing/.github/scripts/changed.sh - source changed.sh "org.lflang.generator.c/\|org.lflang/src/lib/c/\|org.lflang/src/lib/platform/\|test/C" C - source changed.sh "org.lflang/src/org/lflang/generator/cpp/\|org.lflang/src/lib/cpp/\|test/Cpp" CPP - source changed.sh "org.lflang/src/org/lflang/generator/python/\|org.lflang/src/lib/py/\|test/Python" PY - source changed.sh "org.lflang/src/org/lflang/generator/rust/\|org.lflang/src/lib/rs/\|test/Rust" RS - source changed.sh "org.lflang/src/org/lflang/generator/ts/\|org.lflang/src/lib/ts/\|test/TypeScript" TS - source changed.sh "util/tracing" TRACING + wget https://raw.githubusercontent.com/lf-lang/lingua-franca/reduce-testing/.github/scripts/check-diff.sh + source check-diff.sh "org.lflang.generator.c/\|org.lflang/src/lib/c/\|org.lflang/src/lib/platform/\|test/C" C + source check-diff.sh "org.lflang/src/org/lflang/generator/cpp/\|org.lflang/src/lib/cpp/\|test/Cpp" CPP + source check-diff.sh "org.lflang/src/org/lflang/generator/python/\|org.lflang/src/lib/py/\|test/Python" PY + source check-diff.sh "org.lflang/src/org/lflang/generator/rust/\|org.lflang/src/lib/rs/\|test/Rust" RS + source check-diff.sh "org.lflang/src/org/lflang/generator/ts/\|org.lflang/src/lib/ts/\|test/TypeScript" TS + source check-diff.sh "util/tracing" TRACING shell: bash From eb35efebd8b9ad5dcaacc5c28e97e8f75c8b1886 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 18:21:30 -0700 Subject: [PATCH 538/709] Rename again. --- .github/workflows/all-non-target-specific.yml | 4 ++-- .github/workflows/all-targets.yml | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 166694a51f..2960adafa1 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,5 +1,5 @@ -# Non-target-specific tests to run on PRs that are ready for review. -name: Catch-all +# Non-target-specific tests +name: CI (misc) on: workflow_dispatch: diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 0948665eea..cb3f807d46 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -1,5 +1,5 @@ -# Target-specific tests to run on PRs that are ready for review. -name: Catch-all +# Target-specific tests +name: CI (by target) on: workflow_dispatch: From 77359b93424b24dec1d9380d9086455994c11bcc Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 19:06:25 -0700 Subject: [PATCH 539/709] Fix warnings reported on CliBase. The comparison of strings to string literals looks like a critical error which I think would have been caught by sufficient tests. One of these warnings is incorrect, but we might as well silence it with an assertion. The warning about toArray is merely a matter of best practice. A human couldn't be expected to know about this, but the warning emitted by IntelliJ is correct. --- org.lflang/src/org/lflang/cli/CliBase.java | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/org.lflang/src/org/lflang/cli/CliBase.java b/org.lflang/src/org/lflang/cli/CliBase.java index a6c1c805ed..2186b2096b 100644 --- a/org.lflang/src/org/lflang/cli/CliBase.java +++ b/org.lflang/src/org/lflang/cli/CliBase.java @@ -285,6 +285,7 @@ private String[] jsonStringToArgs(String jsonString) { if (src == null) { reporter.printFatalErrorAndExit("JSON Parse Exception: field \"src\" not found."); } + assert src != null; argsList.add(src.getAsString()); // Append output path if given. JsonElement out = jsonObject.get("out"); @@ -306,14 +307,12 @@ private String[] jsonStringToArgs(String jsonString) { // Append option. argsList.add("--" + property); // Append argument for non-boolean options. - if (value != "true" || property == "threading") { + if (!value.equals("true") || property.equals("threading")) { argsList.add(value); } } } - // Return as String[]. - String[] args = argsList.toArray(new String[argsList.size()]); - return args; + return argsList.toArray(new String[0]); } } From ed2630e4f9e083950ca3c0f2abeb7f078956655d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 19:36:17 -0700 Subject: [PATCH 540/709] Fix use of wrong API function name. --- test/Python/src/federated/CycleDetection.lf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Python/src/federated/CycleDetection.lf b/test/Python/src/federated/CycleDetection.lf index cf9b6d6b54..f2ec8622c9 100644 --- a/test/Python/src/federated/CycleDetection.lf +++ b/test/Python/src/federated/CycleDetection.lf @@ -36,7 +36,7 @@ reactor UserInput { self.sys.stderr.write("Did not receive the expected balance. Expected: 200. Got: {}.\n".format(balance.value)) self.sys.exit(1) print("Balance: {}".format(balance.value)) - lf_request_stop() + request_stop() =} reaction(shutdown) {= print("Test passed!") =} From 3a1be9157d611fa35260c1de0c973d854c538cbc Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 27 May 2023 20:30:32 -0700 Subject: [PATCH 541/709] Possibly fix the federated tests on Unix. This might fix the issue where one failing test (that times out) causes all the remaining tests to fail. Timeouts occur when a federate dies because apparently the RTI doesn't quit when one federate dies (maybe it should), but that's a separate issue. --- org.lflang.tests/src/org/lflang/tests/TestBase.java | 2 +- .../org/lflang/federated/launcher/FedLauncherGenerator.java | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/TestBase.java b/org.lflang.tests/src/org/lflang/tests/TestBase.java index 9ae075780a..9d419d5644 100644 --- a/org.lflang.tests/src/org/lflang/tests/TestBase.java +++ b/org.lflang.tests/src/org/lflang/tests/TestBase.java @@ -520,7 +520,7 @@ private void execute(LFTest test) throws TestError { if (!p.waitFor(MAX_EXECUTION_TIME_SECONDS, TimeUnit.SECONDS)) { stdout.interrupt(); stderr.interrupt(); - p.destroyForcibly(); + p.destroy(); throw new TestError(Result.TEST_TIMEOUT); } else { if (stdoutException.get() != null || stderrException.get() != null) { diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java index 0a62e6496c..0f024b6499 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java +++ b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java @@ -296,9 +296,14 @@ private String getSetupCode() { " echo \"#### Received SIGINT signal on line $1. Invoking cleanup().\"", " cleanup", "}", + "cleanup_sigterm() {", + " echo \"#### Received SIGTERM signal on line $1. Invoking cleanup().\"", + " cleanup", + "}", "", "trap 'cleanup_err $LINENO' ERR", "trap 'cleanup_sigint $LINENO' SIGINT", + "trap 'cleanup_sigterm $LINENO' SIGTERM", "", "# Create a random 48-byte text ID for this federation.", "# The likelihood of two federations having the same ID is 1/16,777,216 (1/2^24).", From 6b2019d7852353bcb0aac22b116a928f1d767b2a Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sat, 27 May 2023 22:11:15 -0700 Subject: [PATCH 542/709] Rename `os-tests` to `regular-tests` --- .github/workflows/c-tests.yml | 2 +- .github/workflows/cpp-tests.yml | 2 +- .github/workflows/py-tests.yml | 2 +- .github/workflows/rs-tests.yml | 2 +- .github/workflows/ts-tests.yml | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 072151d219..e8c8b935b6 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -22,7 +22,7 @@ on: type: boolean jobs: - os-tests: + regular-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index dbee4e2ac5..1964e2d9d2 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -15,7 +15,7 @@ on: type: boolean jobs: - cpp-tests: + regular-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index 8dc7641ed2..e68f2682ba 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -18,7 +18,7 @@ on: type: boolean jobs: - os-tests: + regular-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index e5d0a4681e..076ccb901b 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -21,7 +21,7 @@ on: type: boolean jobs: - os-tests: + regular-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 5afcbc231d..a3ccddbb55 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -9,7 +9,7 @@ on: type: boolean jobs: - run: + regular-tests: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} From a8240db9e94c34612adf3628634b4ec5d029eb65 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sat, 27 May 2023 22:48:05 -0700 Subject: [PATCH 543/709] Also reset when converting to draft --- .github/workflows/all-non-target-specific.yml | 4 ++-- .github/workflows/all-targets.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-non-target-specific.yml index 2960adafa1..49e232e749 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-non-target-specific.yml @@ -1,5 +1,5 @@ # Non-target-specific tests -name: CI (misc) +name: CI (misc) on: workflow_dispatch: @@ -7,7 +7,7 @@ on: branches: - master pull_request: - types: [synchronize, opened, reopened, ready_for_review] + types: [synchronize, opened, reopened, ready_for_review, converted_to_draft] env: # 2020.11 diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index cb3f807d46..092f5265a6 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -7,7 +7,7 @@ on: branches: - master pull_request: - types: [synchronize, opened, reopened, ready_for_review] + types: [synchronize, opened, reopened, ready_for_review, converted_to_draft] env: # 2020.11 From a7df998f0cb2ce817bc30053370df722a798d556 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sat, 27 May 2023 22:53:04 -0700 Subject: [PATCH 544/709] Rename workflow --- .github/workflows/{all-non-target-specific.yml => all-misc.yml} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename .github/workflows/{all-non-target-specific.yml => all-misc.yml} (98%) diff --git a/.github/workflows/all-non-target-specific.yml b/.github/workflows/all-misc.yml similarity index 98% rename from .github/workflows/all-non-target-specific.yml rename to .github/workflows/all-misc.yml index 49e232e749..4caa470ba9 100644 --- a/.github/workflows/all-non-target-specific.yml +++ b/.github/workflows/all-misc.yml @@ -1,5 +1,5 @@ # Non-target-specific tests -name: CI (misc) +name: CI (misc) on: workflow_dispatch: From 4983ea96e17ba9eb411e68cf48f144a68f2040b7 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sat, 27 May 2023 23:18:27 -0700 Subject: [PATCH 545/709] Update package.json --- org.lflang/src/lib/ts/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index cdb127813a..fc063d791e 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -2,7 +2,7 @@ "name": "LinguaFrancaDefault", "type": "commonjs", "dependencies": { - "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#fix-federation", + "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#master", "command-line-args": "^5.1.1", "command-line-usage": "^6.1.3" }, From aa170d7982ca83e8472cd1df1d9749d6da99efce Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sun, 28 May 2023 00:07:41 -0700 Subject: [PATCH 546/709] Update package.json --- org.lflang/src/lib/ts/package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/ts/package.json b/org.lflang/src/lib/ts/package.json index 75c880bbc3..fc063d791e 100644 --- a/org.lflang/src/lib/ts/package.json +++ b/org.lflang/src/lib/ts/package.json @@ -2,7 +2,7 @@ "name": "LinguaFrancaDefault", "type": "commonjs", "dependencies": { - "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#minor-reorg", + "@lf-lang/reactor-ts": "git://github.com/lf-lang/reactor-ts.git#master", "command-line-args": "^5.1.1", "command-line-usage": "^6.1.3" }, From 9544c6c48fa4543d7f05facf1ac85f27e8903b7e Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sun, 28 May 2023 00:46:58 -0700 Subject: [PATCH 547/709] Update submodule --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 880fb34310..b9de0d52c0 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 880fb343109d150cd853208c368641863050df4f +Subproject commit b9de0d52c0a2b13e2ffa140c785779c9a71b49d2 From 05922ff4c902e5a20103f87a299a99003ecb731f Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun <78055940+byeong-gil@users.noreply.github.com> Date: Sun, 28 May 2023 19:37:22 +0900 Subject: [PATCH 548/709] Update ts-tests.yml --- .github/workflows/ts-tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 788a0695b7..d474da7056 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -32,7 +32,7 @@ jobs: if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform TypeScript tests run: | - ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#fix-federation" + ./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="git://github.com/lf-lang/reactor-ts.git#master" - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: From 091e7a68646c695eeaac9d741c0850efcf8d89a1 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sun, 28 May 2023 13:48:55 +0200 Subject: [PATCH 549/709] also install the root project --- build.gradle | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/build.gradle b/build.gradle index 43a28acccf..1e7ac576ee 100644 --- a/build.gradle +++ b/build.gradle @@ -1,8 +1,9 @@ import lfformat.LfFormatStep plugins { - id "com.diffplug.spotless" - id "org.lflang.distribution-conventions" + id 'com.diffplug.spotless' + id 'org.lflang.distribution-conventions' + id 'idea' } spotless { @@ -42,3 +43,5 @@ distributions { } } } +installDist.dependsOn('installClitoolsDist') +assemble.dependsOn('installDist') From 4eb228262b1c1a324cad6ef7629e32487bb0a2de Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sun, 28 May 2023 14:11:18 +0200 Subject: [PATCH 550/709] make the LF formatting task depend on the lff distribution files This ensures, that gradle recognizes a change in lff and reformats all lf files accordingly. --- build.gradle | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/build.gradle b/build.gradle index 9164e447fc..bed0f03ce3 100644 --- a/build.gradle +++ b/build.gradle @@ -21,11 +21,11 @@ spotless { target 'test/*/src/**/*.lf' // you have to set the target manually targetExclude 'test/**/failing/**' } - } -spotlessLinguaFranca.dependsOn(":org.lflang:cli:lff:installDist") - +// Make the LF formatting task depend on lff +spotlessLinguaFranca.dependsOn(':org.lflang:cli:lff:installDist') +spotlessLinguaFranca.inputs.files(tasks.getByPath(':org.lflang:cli:lff:installDist').outputs) distributions { clitools { From ee1961e36dc3a04b74c869fa1eaf484802d0a898 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sun, 28 May 2023 14:36:19 +0200 Subject: [PATCH 551/709] clean up versions --- buildSrc/src/main/groovy/org.lflang.test-conventions.gradle | 2 -- gradle.properties | 5 ----- 2 files changed, 7 deletions(-) diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 336dda5ade..a8d4c63909 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -7,8 +7,6 @@ jacoco { toolVersion = jacocoVersion } - - dependencies { testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" diff --git a/gradle.properties b/gradle.properties index 732e9e6c38..50b3771829 100644 --- a/gradle.properties +++ b/gradle.properties @@ -5,20 +5,15 @@ version=0.4.1-SNAPSHOT [versions] fasterxmlVersion=2.12.4 googleJavaFormatVersion=1.15.0 -guiceVersion=5.1.0 -gsonVersion=2.10.1 jacocoVersion=0.8.7 jupiterVersion=5.8.2 jUnitPlatformVersion=1.8.2 -jUnitVersion=4.13.2 kotlinJvmTarget=17 lsp4jVersion=0.14.0 mwe2LaunchVersion=2.12.2 openTest4jVersion=1.2.0 picocliVersion=4.7.0 resourcesVersion=3.16.0 -shadowJarVersion=7.1.2 -xtextGradleVersion=3.0.0 xtextVersion=2.28.0 klighdVersion=2.2.1-SNAPSHOT From 8ec427c2000f2f6d0fa85b344cd2b6f7e52efef9 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Sun, 28 May 2023 14:40:31 +0200 Subject: [PATCH 552/709] add runLfc and runLff tasks --- build.gradle | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/build.gradle b/build.gradle index ff0921756c..fb9378249b 100644 --- a/build.gradle +++ b/build.gradle @@ -45,3 +45,12 @@ distributions { } installDist.dependsOn('installClitoolsDist') assemble.dependsOn('installDist') + + +// Alias tasks for simpler access +tasks.register('runLfc') { + dependsOn('org.lflang:cli:lfc:run') +} +tasks.register('runLff') { + dependsOn('org.lflang:cli:lff:run') +} \ No newline at end of file From e390321f93ffe7acea1065b699e3adfb7c33441a Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sun, 28 May 2023 13:38:05 -0700 Subject: [PATCH 553/709] Update check-diff.yml --- .github/workflows/check-diff.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index 6be192aa02..af5f241cab 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -35,7 +35,7 @@ jobs: fetch-depth: 0 - id: do run: | - wget https://raw.githubusercontent.com/lf-lang/lingua-franca/reduce-testing/.github/scripts/check-diff.sh + wget https://raw.githubusercontent.com/lf-lang/lingua-franca/master/.github/scripts/check-diff.sh source check-diff.sh "org.lflang.generator.c/\|org.lflang/src/lib/c/\|org.lflang/src/lib/platform/\|test/C" C source check-diff.sh "org.lflang/src/org/lflang/generator/cpp/\|org.lflang/src/lib/cpp/\|test/Cpp" CPP source check-diff.sh "org.lflang/src/org/lflang/generator/python/\|org.lflang/src/lib/py/\|test/Python" PY From 597cdd738a912c553379f3bbdd60339bf79f5726 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 25 May 2023 13:41:19 -0700 Subject: [PATCH 554/709] Use qemu_riscv32 with debug logging turned of for Zephyr tests --- .../src/org/lflang/tests/Configurators.java | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/Configurators.java b/org.lflang.tests/src/org/lflang/tests/Configurators.java index a5db8f2abf..bbc9d315ee 100644 --- a/org.lflang.tests/src/org/lflang/tests/Configurators.java +++ b/org.lflang.tests/src/org/lflang/tests/Configurators.java @@ -26,6 +26,7 @@ import org.lflang.TargetProperty; import org.lflang.TargetProperty.Platform; +import org.lflang.TargetProperty.LogLevel; import org.lflang.tests.TestRegistry.TestCategory; /** @@ -69,7 +70,10 @@ public static boolean makeZephyrCompatibleUnthreaded(LFTest test) { test.getContext().getTargetConfig().setByUser.add(TargetProperty.THREADING); test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; test.getContext().getTargetConfig().platformOptions.flash = false; - test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; + test.getContext().getTargetConfig().platformOptions.board = "qemu_riscv32"; + // FIXME: Zephyr qemu emulations fails with debug log-levels. + test.getContext().getTargetConfig().logLevel = LogLevel.WARN; + test.getContext().getArgs().setProperty("logging", "warning"); return true; } @@ -77,7 +81,11 @@ public static boolean makeZephyrCompatible(LFTest test) { test.getContext().getArgs().setProperty("tracing", "false"); test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; test.getContext().getTargetConfig().platformOptions.flash = false; - test.getContext().getTargetConfig().platformOptions.board = "qemu_cortex_a53"; + test.getContext().getTargetConfig().platformOptions.board = "qemu_riscv32"; + // FIXME: Zephyr qemu emulations fails with debug log-levels. + test.getContext().getTargetConfig().logLevel = LogLevel.WARN; + test.getContext().getArgs().setProperty("logging", "warning"); + return true; } /** From ba67c0ef12b87b2fabbc322d77c63af7a314efc5 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 28 May 2023 15:18:04 -0700 Subject: [PATCH 555/709] Relaxed timing to try to reduce flakiness --- test/C/src/concurrent/DeadlineThreaded.lf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/C/src/concurrent/DeadlineThreaded.lf b/test/C/src/concurrent/DeadlineThreaded.lf index ffc1be2701..4be8573c35 100644 --- a/test/C/src/concurrent/DeadlineThreaded.lf +++ b/test/C/src/concurrent/DeadlineThreaded.lf @@ -24,7 +24,7 @@ reactor Source(period: time = 3000 msec) { if (2 * (self->count / 2) != self->count) { // The count variable is odd. // Take time to cause a deadline violation. - lf_sleep(MSEC(210)); + lf_sleep(MSEC(1100)); } printf("Source sends: %d.\n", self->count); lf_set(y, self->count); @@ -57,6 +57,6 @@ reactor Destination(timeout: time = 1 sec) { main reactor { s = new Source() - d = new Destination(timeout = 200 msec) + d = new Destination(timeout = 1s) s.y -> d.x } From e6a4a0628343d433a76223503e6a9a13aa4f000f Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 28 May 2023 16:24:59 -0700 Subject: [PATCH 556/709] Align to reactor-c main after merge --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index b9de0d52c0..c5613560e1 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit b9de0d52c0a2b13e2ffa140c785779c9a71b49d2 +Subproject commit c5613560e160349154785ff5328ab8f1f764e504 From 09151c2ba867de90c0dcb6335f513b54c8ac128a Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sun, 28 May 2023 16:25:27 -0700 Subject: [PATCH 557/709] Format --- test/C/src/concurrent/DeadlineThreaded.lf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/C/src/concurrent/DeadlineThreaded.lf b/test/C/src/concurrent/DeadlineThreaded.lf index 4be8573c35..c23f28266a 100644 --- a/test/C/src/concurrent/DeadlineThreaded.lf +++ b/test/C/src/concurrent/DeadlineThreaded.lf @@ -57,6 +57,6 @@ reactor Destination(timeout: time = 1 sec) { main reactor { s = new Source() - d = new Destination(timeout = 1s) + d = new Destination(timeout = 1 s) s.y -> d.x } From 3128b20430bb6c97ed2f89f5ff8a76c6a6e8ddc5 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Mon, 29 May 2023 06:05:44 +0200 Subject: [PATCH 558/709] Bump reactor-c --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 98f13080c4..d43e973780 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 98f13080c4346a76aec92603509b1c5ac62abb9e +Subproject commit d43e9737804f2d984d52a99cac20d8e57adad543 From fa0fa3efd30a6281e337fb6d1957c7ab6dc483ee Mon Sep 17 00:00:00 2001 From: erlingrj Date: Mon, 29 May 2023 06:08:24 +0200 Subject: [PATCH 559/709] Bump reactor-c again --- .west/config | 4 ++++ org.lflang/src/lib/c/reactor-c | 2 +- org.lflang/src/lib/cpp/reactor-cpp | 2 +- test/C/lib/libapp.a | Bin 0 -> 74484 bytes 4 files changed, 6 insertions(+), 2 deletions(-) create mode 100644 .west/config create mode 100644 test/C/lib/libapp.a diff --git a/.west/config b/.west/config new file mode 100644 index 0000000000..ccd607713e --- /dev/null +++ b/.west/config @@ -0,0 +1,4 @@ +[manifest] +path = /home/erling/dev/lf-west-template/deps/zephyr +file = west.yml + diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index d43e973780..c5613560e1 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit d43e9737804f2d984d52a99cac20d8e57adad543 +Subproject commit c5613560e160349154785ff5328ab8f1f764e504 diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index b607f1f640..e80cd36ce5 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit b607f1f64083ab531e7a676b29de75f076aa1cde +Subproject commit e80cd36ce5bd625a7b167e7dfd65d25f78b0dd01 diff --git a/test/C/lib/libapp.a b/test/C/lib/libapp.a new file mode 100644 index 0000000000000000000000000000000000000000..d710e87c0ec4ba481729cee7abcf33a864b98114 GIT binary patch literal 74484 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 Date: Mon, 29 May 2023 06:53:39 +0200 Subject: [PATCH 560/709] Add ConcurrentTests to Zephyr and exclude the tracing specific concurrent tests --- .../src/org/lflang/tests/runtime/CZephyrTest.java | 12 ++++++++++++ util/RunZephyrTests.sh | 2 +- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java index db5eb46fc3..079c6c18b7 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java @@ -66,4 +66,16 @@ public void buildGenericTests() { TestLevel.BUILD, false); } + @Test + public void buildConcurrentTests() { + Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); + + super.runTestsFor( + List.of(Target.C), + Message.DESC_CONCURRENT, + TestCategory.CONCURRENT::equals, + Configurators::makeZephyrCompatible, + TestLevel.BUILD, + false); + } } diff --git a/util/RunZephyrTests.sh b/util/RunZephyrTests.sh index 742a23ef18..c1079221d5 100755 --- a/util/RunZephyrTests.sh +++ b/util/RunZephyrTests.sh @@ -9,7 +9,7 @@ num_failures=0 failed_tests="" # Skip -skip=("FileReader" "FilePkgReader") +skip=("FileReader" "FilePkgReader" "Tracing" "ThreadedThreaded") find_kconfig_folders() { if [ -f "$folder/CMakeLists.txt" ]; then From 05f404553622c4c43c7c733a786b5cf5d996ae64 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Mon, 29 May 2023 06:59:03 +0200 Subject: [PATCH 561/709] Print all skipped tests in RunZephyrTests.sh --- util/RunZephyrTests.sh | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/util/RunZephyrTests.sh b/util/RunZephyrTests.sh index c1079221d5..ffb15198a9 100755 --- a/util/RunZephyrTests.sh +++ b/util/RunZephyrTests.sh @@ -116,8 +116,7 @@ else fi echo "Number of passes: $num_successes" echo "Number of fails: $num_failures" -echo "Skipped tests: $skip" - +echo "Skipped tests: ${skip[@]}" if [ "$overall_success" = false ]; then echo "Failed tests: $failed_tests" From a4a9feecd535ff7c285541f834cf5d2a0e85869c Mon Sep 17 00:00:00 2001 From: erlingrj Date: Mon, 29 May 2023 07:28:44 +0200 Subject: [PATCH 562/709] spotless --- org.lflang.tests/src/org/lflang/tests/Configurators.java | 6 +++--- .../src/org/lflang/tests/runtime/CZephyrTest.java | 1 + 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/Configurators.java b/org.lflang.tests/src/org/lflang/tests/Configurators.java index bbc9d315ee..85a8465c29 100644 --- a/org.lflang.tests/src/org/lflang/tests/Configurators.java +++ b/org.lflang.tests/src/org/lflang/tests/Configurators.java @@ -25,8 +25,8 @@ package org.lflang.tests; import org.lflang.TargetProperty; -import org.lflang.TargetProperty.Platform; import org.lflang.TargetProperty.LogLevel; +import org.lflang.TargetProperty.Platform; import org.lflang.tests.TestRegistry.TestCategory; /** @@ -71,12 +71,12 @@ public static boolean makeZephyrCompatibleUnthreaded(LFTest test) { test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; test.getContext().getTargetConfig().platformOptions.flash = false; test.getContext().getTargetConfig().platformOptions.board = "qemu_riscv32"; - // FIXME: Zephyr qemu emulations fails with debug log-levels. + // FIXME: Zephyr qemu emulations fails with debug log-levels. test.getContext().getTargetConfig().logLevel = LogLevel.WARN; test.getContext().getArgs().setProperty("logging", "warning"); return true; } - + public static boolean makeZephyrCompatible(LFTest test) { test.getContext().getArgs().setProperty("tracing", "false"); test.getContext().getTargetConfig().platformOptions.platform = Platform.ZEPHYR; diff --git a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java index 079c6c18b7..b29c2755d1 100644 --- a/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java +++ b/org.lflang.tests/src/org/lflang/tests/runtime/CZephyrTest.java @@ -66,6 +66,7 @@ public void buildGenericTests() { TestLevel.BUILD, false); } + @Test public void buildConcurrentTests() { Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); From 0d731fb926b03632cde508cedfd81656bede4de9 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Mon, 29 May 2023 08:14:02 +0200 Subject: [PATCH 563/709] Bump reactor-cpp --- org.lflang/src/lib/cpp/reactor-cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/cpp/reactor-cpp b/org.lflang/src/lib/cpp/reactor-cpp index e80cd36ce5..b607f1f640 160000 --- a/org.lflang/src/lib/cpp/reactor-cpp +++ b/org.lflang/src/lib/cpp/reactor-cpp @@ -1 +1 @@ -Subproject commit e80cd36ce5bd625a7b167e7dfd65d25f78b0dd01 +Subproject commit b607f1f64083ab531e7a676b29de75f076aa1cde From 37fdf50dc98fa7567d46bac8c06af08d7c38e73b Mon Sep 17 00:00:00 2001 From: erling Date: Mon, 29 May 2023 08:59:07 +0200 Subject: [PATCH 564/709] Update extract-ref.yml Use the new label for outputting the ref also --- .github/workflows/extract-ref.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/extract-ref.yml b/.github/workflows/extract-ref.yml index c3c738048f..cb10c29a8b 100644 --- a/.github/workflows/extract-ref.yml +++ b/.github/workflows/extract-ref.yml @@ -10,7 +10,7 @@ on: outputs: ref: description: "The extracted ref" - value: ${{ jobs.run.outputs.ref }} + value: ${{ jobs.extract-ref.outputs.ref }} jobs: extract-ref: From b779115921746ea8051575f0891e072038b45576 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 29 May 2023 12:15:04 +0200 Subject: [PATCH 565/709] correctly pass args to run tasks --- build.gradle | 4 ++-- util/scripts/launch.ps1 | 7 ++++++- util/scripts/launch.sh | 7 ++++++- 3 files changed, 14 insertions(+), 4 deletions(-) diff --git a/build.gradle b/build.gradle index fb9378249b..609bd663c2 100644 --- a/build.gradle +++ b/build.gradle @@ -48,9 +48,9 @@ assemble.dependsOn('installDist') // Alias tasks for simpler access -tasks.register('runLfc') { +tasks.register('runLfc', JavaExec) { dependsOn('org.lflang:cli:lfc:run') } -tasks.register('runLff') { +tasks.register('runLff', JavaExec) { dependsOn('org.lflang:cli:lff:run') } \ No newline at end of file diff --git a/util/scripts/launch.ps1 b/util/scripts/launch.ps1 index ffeee518ca..26e3db1d30 100644 --- a/util/scripts/launch.ps1 +++ b/util/scripts/launch.ps1 @@ -29,4 +29,9 @@ $base="$PSScriptRoot\..\..\" $gradlew="${base}/gradlew.bat" # invoke script -& "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args "$args" \ No newline at end of file +if ($args.Length == 0) { + & "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" +} else { + $argsString = $args -join " " + & "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args="${argsString}" +} \ No newline at end of file diff --git a/util/scripts/launch.sh b/util/scripts/launch.sh index 03025c9914..5c335a6fe8 100755 --- a/util/scripts/launch.sh +++ b/util/scripts/launch.sh @@ -70,4 +70,9 @@ fi gradlew="${base}/gradlew" # Launch the tool. -"${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args "$@" +if [ $# -eq 0 ]; then + "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" +else + "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args="$*" +fi + From 9600d93ffad219adfee96f5127d7ff49a13d42da Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 29 May 2023 12:16:56 +0200 Subject: [PATCH 566/709] also format shell and ps1 scripts --- build.gradle | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/build.gradle b/build.gradle index 609bd663c2..dd25fd5a9d 100644 --- a/build.gradle +++ b/build.gradle @@ -9,7 +9,7 @@ plugins { spotless { format 'misc', { // define the files to apply `misc` to - target '*.gradle', '*.md', '.gitignore' + target '*.gradle', '*.md', '.gitignore', '*.sh', '*.ps1' // define the steps to apply to those files trimTrailingWhitespace() @@ -53,4 +53,4 @@ tasks.register('runLfc', JavaExec) { } tasks.register('runLff', JavaExec) { dependsOn('org.lflang:cli:lff:run') -} \ No newline at end of file +} From d5529b32d6307ef7d3e722027621bb412d4d714a Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 29 May 2023 13:07:52 +0200 Subject: [PATCH 567/709] fix integration tests --- .../groovy/org.lflang.test-conventions.gradle | 52 ++++++---------- org.lflang/core/build.gradle | 60 ------------------- 2 files changed, 18 insertions(+), 94 deletions(-) diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index a8d4c63909..8385720b8d 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -25,10 +25,27 @@ dependencies { testFixturesImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" } +def integrationTest = false +tasks.register('integration') { + integrationTest = true +} +integration.finalizedBy(test) + test { useJUnitPlatform { - excludeTags 'Integration' + if (integrationTest) { + includeTags 'Integration' + } else { + excludeTags 'Integration' + } + } + + if (integrationTest && project.hasProperty('target')) { + filter { + includeTestsMatching "org.lflang.tests.runtime.${project.property('target')}Test.*" + } } + testLogging { events "passed", "skipped", "failed" showStandardStreams = true @@ -61,36 +78,3 @@ jacocoTestReport { })) } } - - - -tasks.register('integration', Test) { - filter { - setFailOnNoMatchingTests(false) - } - if (System.getProperty('integrationInclude') != null) { - filter { - includeTestsMatching System.getProperty('integrationInclude') - } - } - useJUnitPlatform { - includeTags 'Integration' - - } - testLogging { - events "passed", "skipped", "failed" - showStandardStreams = true - exceptionFormat "full" - } - // Pass the scheduler and runtime property on to the Java VM - systemProperty 'scheduler', System.getProperty('scheduler') - systemProperty 'runtime', System.getProperty('runtime') - - filter { - setFailOnNoMatchingTests(false) - } - - failFast = true - - workingDir = rootProject.projectDir -} \ No newline at end of file diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index 615020ec4d..fafadd0191 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -79,66 +79,6 @@ processResources.dependsOn(generateXtextLanguage) clean.dependsOn(cleanGenerateXtextLanguage) spotlessJava.mustRunAfter(generateXtextLanguage) -tasks.register('integrationLsp') { - System.setProperty('integrationInclude', 'org.lflang.tests.lsp.**') - finalizedBy('integration') -} - -tasks.register('integrationCArduino') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CArduinoTest.*') - finalizedBy('integration') -} - -tasks.register('integrationCCpp') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CCppTest.*') - finalizedBy('integration') -} - -tasks.register('integrationCppRos2') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CppRos2Test.*') - finalizedBy('integration') -} - -tasks.register('integrationCpp') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CppTest.*') - finalizedBy('integration') -} - -tasks.register('integrationCScheduler') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CSchedulerTest.*') - finalizedBy('integration') -} - -tasks.register('integrationC') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CTest.*') - finalizedBy('integration') -} - -tasks.register('integrationCZephyr') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.CZephyr.*') - finalizedBy('integration') -} - -tasks.register('integrationPython') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.PythonTest.*') - finalizedBy('integration') -} - -tasks.register('integrationRust') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.RustTest.*') - finalizedBy('integration') -} - -tasks.register('integrationTypeScript') { - System.setProperty('integrationInclude', 'org.lflang.tests.runtime.TypeScriptTest.*') - finalizedBy('integration') -} - -tasks.register('integrationSerialization') { - System.setProperty('integrationInclude', 'org.lflang.tests.serialization.SerializationTest.*') - finalizedBy('integration') -} - tasks.register('getSubmoduleVersions', Exec) { description('Run a Git command to get the current status of submodules') workingDir project.rootDir From 1fe39cc9fd0f61f2f359c5eda33dd1ba0c6e531d Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 29 May 2023 13:18:47 +0200 Subject: [PATCH 568/709] remove deleted workflows --- .github/workflows/all-misc.yml | 9 --------- .github/workflows/non-target-specific-extended.yml | 4 ---- .github/workflows/non-target-specific.yml | 6 ------ 3 files changed, 19 deletions(-) diff --git a/.github/workflows/all-misc.yml b/.github/workflows/all-misc.yml index 4caa470ba9..d606cf31b8 100644 --- a/.github/workflows/all-misc.yml +++ b/.github/workflows/all-misc.yml @@ -21,11 +21,6 @@ jobs: check-diff: uses: ./.github/workflows/check-diff.yml - junit: - uses: ./.github/workflows/unit-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - # Test the Gradle build. building: if: ${{ !github.event.pull_request.draft }} @@ -40,10 +35,6 @@ jobs: with: all-platforms: ${{ !github.event.pull_request.draft }} - formatting: - if: ${{ !github.event.pull_request.draft }} - uses: ./.github/workflows/check-format.yml - # Run tests for the standalone compiler. cli: if: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index bdfc4181aa..065b5dbff8 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -29,10 +29,6 @@ jobs: with: all-platforms: ${{ !github.event.pull_request.draft }} - formatting: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/check-format.yml - # Run tests for the standalone compiler. cli: if: ${{ inputs.all || github.event.pull_request.draft }} diff --git a/.github/workflows/non-target-specific.yml b/.github/workflows/non-target-specific.yml index 2ea4f4499d..179c5ee089 100644 --- a/.github/workflows/non-target-specific.yml +++ b/.github/workflows/non-target-specific.yml @@ -16,12 +16,6 @@ concurrency: cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: - # Run the unit tests. - junit: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/unit-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} # Run the serialization tests serialization: From fdcb2f1a5dc84137c84b822dbdb9979cf4d1beec Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 29 May 2023 13:28:37 +0200 Subject: [PATCH 569/709] update ci integration jobs --- .github/workflows/c-arduino-tests.yml | 2 +- .github/workflows/c-tests.yml | 6 +++--- .github/workflows/c-zephyr-tests.yml | 2 +- .github/workflows/cpp-ros2-tests.yml | 2 +- .github/workflows/cpp-tests.yml | 2 +- .github/workflows/lsp-tests.yml | 4 ++-- .github/workflows/py-tests.yml | 2 ++ .github/workflows/rs-tests.yml | 2 +- .github/workflows/serialization-tests.yml | 2 +- .github/workflows/ts-tests.yml | 2 +- 10 files changed, 14 insertions(+), 12 deletions(-) diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 157fe67c41..6082eaa17d 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -63,7 +63,7 @@ jobs: arduino-cli core install arduino:sam arduino-cli core install arduino:mbed - name: Perform Arduino tests for C target with default scheduler - run: ./gradlew integrationCArduino + run: ./gradlew integration -Ptarget=Arduino - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 8f18c464ce..e498ebe6ad 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -54,15 +54,15 @@ jobs: uses: ./.github/actions/install-rti if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform tests for C target with default scheduler - run: ./gradlew integrationC + run: ./gradlew integration -Ptarget=C if: ${{ !inputs.use-cpp && !inputs.scheduler }} - name: Perform tests for C target with specified scheduler (no LSP tests) run: | echo "Specified scheduler: ${{ inputs.scheduler }}" - ./gradlew integrationC -Dscheduler=${{ inputs.scheduler }} + ./gradlew integration -Ptarget=C -Dscheduler=${{ inputs.scheduler }} if: ${{ !inputs.use-cpp && inputs.scheduler }} - name: Perform tests for CCpp target with default scheduler - run: ./gradlew integrationCCpp + run: ./gradlew integration -Ptarget=CCpp if: ${{ inputs.use-cpp && !inputs.scheduler }} - name: Collect code coverage run: ./gradlew jacocoTestReport diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 3d1e0b95b7..39b225b3ed 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -41,7 +41,7 @@ jobs: if: ${{ inputs.runtime-ref }} - name: Perform Zephyr tests for C target with default scheduler run: | - ./gradlew integrationCZephyr + ./gradlew integration -Ptarget=CZephyr util/RunZephyrTests.sh test/C/src-gen - name: Collect code coverage run: ./gradlew jacocoTestReport diff --git a/.github/workflows/cpp-ros2-tests.yml b/.github/workflows/cpp-ros2-tests.yml index e1492ac329..7c23700794 100644 --- a/.github/workflows/cpp-ros2-tests.yml +++ b/.github/workflows/cpp-ros2-tests.yml @@ -35,7 +35,7 @@ jobs: - name: Run C++ tests; run: | source /opt/ros/*/setup.bash - ./gradlew integrationCppRos2 + ./gradlew integration -Ptarget=CppRos2 - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index 926e704d4c..35b972e6c2 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -48,7 +48,7 @@ jobs: if: ${{ inputs.runtime-ref }} - name: Run C++ tests; run: | - ./gradlew integrationCpp + ./gradlew integration -Ptarget=Cpp - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index 50d3193b86..ca82c3f41c 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -69,7 +69,7 @@ jobs: with: python-version: '3.10' - name: Run language server Python tests without PyLint - run: ./gradlew integration --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly + run: ./gradlew org.lflang:core:integration --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly - name: Install pylint run: python3 -m pip install pylint if: ${{ runner.os != 'macOS' }} @@ -77,7 +77,7 @@ jobs: run: brew install pylint if: ${{ runner.os == 'macOS' }} - name: Run language server tests - run: ./gradlew integration --tests org.lflang.tests.lsp.LspTests.*ValidationTest + run: ./gradlew org.lflang:core:integration --tests org.lflang.tests.lsp.LspTests.*ValidationTest - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index b6b323959f..436885243a 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -59,6 +59,8 @@ jobs: path: org.lflang/src/lib/py/reactor-c-py ref: ${{ inputs.reactor-c-py-ref }} if: ${{ inputs.reactor-c-py-ref }} + - name: Run Python tests + run: ./gradlew integration -Ptarget=Python - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index c3297686c9..c84b5266aa 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -64,7 +64,7 @@ jobs: rust-version: ${{ matrix.rust }} components: clippy - name: Run Rust tests - run: ./gradlew integrationRust + run: ./gradlew integration -Ptarget=Rust - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 29ab00583e..00738e99fa 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -31,7 +31,7 @@ jobs: - name: Run serialization tests; run: | source /opt/ros/*/setup.bash - ./gradlew integrationSerialization + ./gradlew org.lflang:core:integration --test org.lflang.test.serialization.SerializationTest.* - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 5f6631d6be..4b8bd1905f 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -33,7 +33,7 @@ jobs: if: ${{ runner.os == 'macOS' }} - name: Perform TypeScript tests run: | - ./gradlew integrationTypeScript -Druntime="git://github.com/lf-lang/reactor-ts.git#minor-reorg" + ./gradlew integration -Ptarget=TypeScript -Druntime="git://github.com/lf-lang/reactor-ts.git#minor-reorg" - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov From 0d13278e423fbce3ea6b1fa8c838e5b11b8642d1 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 29 May 2023 13:40:14 +0200 Subject: [PATCH 570/709] extended formatting --- .github/scripts/check-diff.sh | 1 - .github/scripts/test-lfc.sh | 2 +- .github/scripts/test-lff.sh | 2 +- .github/workflows/README.md | 2 +- .github/workflows/cli-tests.yml | 1 - build.gradle | 6 +- buildSrc/build.gradle | 2 +- ...org.lflang.java-library-conventions.gradle | 2 +- .../org.lflang.kotlin-conventions.gradle | 2 +- gradle/source-layout.gradle | 68 +++++++++---------- org.lflang/core/build.gradle | 2 +- .../core/src/main/resources/lib/ts/README.md | 2 +- test/Rust/src/README.md | 8 +-- test/TypeScript/README.md | 2 +- util/README.md | 2 +- util/RunZephyrTests.sh | 8 +-- util/scripts/launch-fedsd.sh | 6 +- util/scripts/launch.sh | 1 - util/tracing/README.md | 10 +-- util/tracing/visualization/README.md | 8 +-- 20 files changed, 66 insertions(+), 71 deletions(-) diff --git a/.github/scripts/check-diff.sh b/.github/scripts/check-diff.sh index 8fa9e72b1a..9a84951079 100644 --- a/.github/scripts/check-diff.sh +++ b/.github/scripts/check-diff.sh @@ -7,4 +7,3 @@ if changes | grep -q $1; then else echo "CHANGED_$2=0" >> $GITHUB_OUTPUT fi - diff --git a/.github/scripts/test-lfc.sh b/.github/scripts/test-lfc.sh index 096736f495..fe9b6e3757 100755 --- a/.github/scripts/test-lfc.sh +++ b/.github/scripts/test-lfc.sh @@ -8,7 +8,7 @@ cd $GITHUB_WORKSPACE function test_with_links() { rm -rf foo mkdir -p foo/bar/baz - ln -s ../bin/${1} foo/link-foo + ln -s ../bin/${1} foo/link-foo ln -s ../link-foo foo/bar/link-bar ln -s ../link-bar foo/bar/baz/link-${1} foo/bar/baz/link-${1} --help diff --git a/.github/scripts/test-lff.sh b/.github/scripts/test-lff.sh index b16a5ad46a..d98578a39b 100755 --- a/.github/scripts/test-lff.sh +++ b/.github/scripts/test-lff.sh @@ -8,7 +8,7 @@ cd $GITHUB_WORKSPACE function test_with_links() { rm -rf foo mkdir -p foo/bar/baz - ln -s ../bin/${1} foo/link-foo + ln -s ../bin/${1} foo/link-foo ln -s ../link-foo foo/bar/link-bar ln -s ../link-bar foo/bar/baz/link-${1} foo/bar/baz/link-${1} --help diff --git a/.github/workflows/README.md b/.github/workflows/README.md index d11093c691..a33af6b6a0 100644 --- a/.github/workflows/README.md +++ b/.github/workflows/README.md @@ -12,7 +12,7 @@ The [benchmark-tests.yml](https://github.com/lf-lang/lingua-franca/blob/master/. ### CLI tests The [lfc-tests.yml](https://github.com/lf-lang/lingua-franca/blob/master/.github/workflows/lfc-tests.yml) workflow tests command line access to the Lingua Franca compiler via `lfc`. ### Target-specific tests -Each target has its own [reusable workflow](https://docs.github.com/en/actions/learn-github-actions/reusing-workflows). +Each target has its own [reusable workflow](https://docs.github.com/en/actions/learn-github-actions/reusing-workflows). #### C/CCpp ([c-tests.yml](https://github.com/lf-lang/lingua-franca/blob/master/.github/workflows/c-tests.yml)) This workflow has the following (optional) arguments: - `compiler-ref` to specify which ref of the `lingua-franca` repository to check out; and diff --git a/.github/workflows/cli-tests.yml b/.github/workflows/cli-tests.yml index 079b604fc2..9e56c40d28 100644 --- a/.github/workflows/cli-tests.yml +++ b/.github/workflows/cli-tests.yml @@ -37,4 +37,3 @@ jobs: run: | bin/lff.ps1 --help if: ${{ runner.os == 'Windows' }} - diff --git a/build.gradle b/build.gradle index 940ad39ba9..56b50afb4b 100644 --- a/build.gradle +++ b/build.gradle @@ -8,8 +8,10 @@ plugins { spotless { format 'misc', { - // define the files to apply `misc` to - target '*.gradle', '*.md', '.gitignore', '**/*.yml' + target project.fileTree(project.rootDir) { + include '**/*.gradle', '**/*.md', '.gitignore', '**/*.yml', '**/*.sh', '**/*.psi' + exclude '**/reactor-cpp/**', '**/reactor-c/**', '**/reactor-rs/**', '**/lf-python-support' + } // define the steps to apply to those files trimTrailingWhitespace() diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle index 972fd06a06..09aca9525e 100644 --- a/buildSrc/build.gradle +++ b/buildSrc/build.gradle @@ -15,4 +15,4 @@ dependencies { implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion" implementation "com.diffplug.spotless:spotless-plugin-gradle:$spotlessVersion" -} \ No newline at end of file +} diff --git a/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle index 4f3b10c399..1f30f6a700 100644 --- a/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.java-library-conventions.gradle @@ -2,4 +2,4 @@ plugins { id 'org.lflang.java-conventions' id 'java-library' id 'org.lflang.test-conventions' -} \ No newline at end of file +} diff --git a/buildSrc/src/main/groovy/org.lflang.kotlin-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.kotlin-conventions.gradle index d595e14b21..879412cbb5 100644 --- a/buildSrc/src/main/groovy/org.lflang.kotlin-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.kotlin-conventions.gradle @@ -12,4 +12,4 @@ compileTestKotlin { kotlinOptions { jvmTarget = kotlinJvmTarget } -} \ No newline at end of file +} diff --git a/gradle/source-layout.gradle b/gradle/source-layout.gradle index 4c7d5f74c4..4507a22632 100644 --- a/gradle/source-layout.gradle +++ b/gradle/source-layout.gradle @@ -1,46 +1,46 @@ if (name.endsWith(".tests")) { - sourceSets { - main { - java.srcDirs = [] - kotlin.srcDirs = [] - resources.srcDirs = [] - } - test { - java.srcDirs = ['src', 'src-gen'] - kotlin.srcDirs = ['src', 'src-gen'] - resources.srcDirs = ['src', 'src-gen'] - } - } + sourceSets { + main { + java.srcDirs = [] + kotlin.srcDirs = [] + resources.srcDirs = [] + } + test { + java.srcDirs = ['src', 'src-gen'] + kotlin.srcDirs = ['src', 'src-gen'] + resources.srcDirs = ['src', 'src-gen'] + } + } } else { - sourceSets { - main { - java.srcDirs = ['src', 'src-gen'] - kotlin.srcDirs = ['src', 'src-gen'] - resources { - srcDirs = ['src', 'src-gen'] - exclude 'src/lib/rs/reactor-rust' // rust runtime does not need to be packed here. - } - } - test { - java.srcDirs = [] - resources.srcDirs = [] - } - } + sourceSets { + main { + java.srcDirs = ['src', 'src-gen'] + kotlin.srcDirs = ['src', 'src-gen'] + resources { + srcDirs = ['src', 'src-gen'] + exclude 'src/lib/rs/reactor-rust' // rust runtime does not need to be packed here. + } + } + test { + java.srcDirs = [] + resources.srcDirs = [] + } + } } sourceSets.all { - resources.exclude '**/*.g', '**/*.mwe2', '**/*._trace' + resources.exclude '**/*.g', '**/*.mwe2', '**/*._trace' } jar { - from('model') { - into('model') - } - manifest { - attributes 'Bundle-SymbolicName': project.name - } + from('model') { + into('model') + } + manifest { + attributes 'Bundle-SymbolicName': project.name + } } plugins.withId('war') { - webAppDirName = "WebRoot" + webAppDirName = "WebRoot" } diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index fafadd0191..2589734b8a 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -151,4 +151,4 @@ tasks.register('checkRuntimeVersionFileUpToDate') { } } } -test.dependsOn('checkRuntimeVersionFileUpToDate') \ No newline at end of file +test.dependsOn('checkRuntimeVersionFileUpToDate') diff --git a/org.lflang/core/src/main/resources/lib/ts/README.md b/org.lflang/core/src/main/resources/lib/ts/README.md index 7d273e6743..c414f3e13c 100644 --- a/org.lflang/core/src/main/resources/lib/ts/README.md +++ b/org.lflang/core/src/main/resources/lib/ts/README.md @@ -9,4 +9,4 @@ git://github.com/lf-lang/reactor-ts.git#ref ``` where `ref` could be a SHA1 hash of a particular commit or a branch name such as `my-feature-branch`. -**NOTE**: the `package.json` in this directory is used as a _default_ only; it can be overridden by a `package.json` provided alongside the LF source file. To make sure that all the tests in CI run with a particular version of the runtime, it is safer to leave this file "as is" and instead adapt `.github/workflows/ts-tests.yml` by adding a `-Druntime="git://github.com/lf-lang/reactor-ts.git#ref"` parameter to the `./gradlew test` command. \ No newline at end of file +**NOTE**: the `package.json` in this directory is used as a _default_ only; it can be overridden by a `package.json` provided alongside the LF source file. To make sure that all the tests in CI run with a particular version of the runtime, it is safer to leave this file "as is" and instead adapt `.github/workflows/ts-tests.yml` by adding a `-Druntime="git://github.com/lf-lang/reactor-ts.git#ref"` parameter to the `./gradlew test` command. diff --git a/test/Rust/src/README.md b/test/Rust/src/README.md index 0d1f4d8933..6c50ae069d 100644 --- a/test/Rust/src/README.md +++ b/test/Rust/src/README.md @@ -27,8 +27,8 @@ This is not exhaustive. Ideally each of those bullet points would have a test ca - [x] all test files: trigger dependencies trigger reactions - [x] `ActionIsPresentDouble.lf`: multiple trigger dependencies may be triggered independently - [x] uses-dependencies - - [x] `DependencyUseNonTrigger`: use dependencies do not trigger reactions - - [x] `DependencyUseAccessible`: use dependencies make the port accessible within the reaction, values are observable + - [x] `DependencyUseNonTrigger`: use dependencies do not trigger reactions + - [x] `DependencyUseAccessible`: use dependencies make the port accessible within the reaction, values are observable - [x] `DependencyUseOnLogicalAction.lf`: use dependencies may be declared on actions and timers - [x] effects-dependency - [x] all test files: effects dependencies allow mutation @@ -42,8 +42,8 @@ This is not exhaustive. Ideally each of those bullet points would have a test ca - [x] `Preamble.lf`: preamble within reactor - [ ] top-level preamble - [x] logical actions - - [x] `ActionImplicitDelay.lf`: scheduling an action with no additional delay uses its implicit delay - - [x] `ActionDelay.lf`: + - [x] `ActionImplicitDelay.lf`: scheduling an action with no additional delay uses its implicit delay + - [x] `ActionDelay.lf`: - [x] `ActionScheduleMicrostep.lf`: an action scheduled with a zero delay is only triggered on the next microstep - [x] `ActionValues.lf`: scheduling an action with a value at multiple different tags preserves each value - [x] `ActionValuesCleanup.lf`: action value is cleaned up at the end of a tag diff --git a/test/TypeScript/README.md b/test/TypeScript/README.md index c865f31894..bc01867fbe 100644 --- a/test/TypeScript/README.md +++ b/test/TypeScript/README.md @@ -21,4 +21,4 @@ lfc test/TypeScript/src/Minimal.lf --external-runtime-path ~/lf-lang/reactor-ts - To point `lfc` to a particular ref (e.g. `main`, `v0.1.0` or `f8c6d2379f278e22ad48410bf06cf0909405ecc3`) in the `lf-lang/reactor-ts` repo: ``` lfc test/TypeScript/src/Minimal.lf --runtime-version -``` \ No newline at end of file +``` diff --git a/util/README.md b/util/README.md index 57a89cb629..fd95c322f0 100644 --- a/util/README.md +++ b/util/README.md @@ -1,4 +1,4 @@ ## util This directory is intended for collecting utility programs associated with Lingua Franca -but that run and install independently of the main tool chain. \ No newline at end of file +but that run and install independently of the main tool chain. diff --git a/util/RunZephyrTests.sh b/util/RunZephyrTests.sh index 742a23ef18..2190563351 100755 --- a/util/RunZephyrTests.sh +++ b/util/RunZephyrTests.sh @@ -15,7 +15,7 @@ find_kconfig_folders() { if [ -f "$folder/CMakeLists.txt" ]; then echo "-----------------------------------------------------------------------------------------------------------" test_name=$(basename $folder) - + if [[ " ${skip[*]} " == *" $test_name "* ]]; then echo "Skipping: $test_name" else @@ -49,7 +49,7 @@ run_zephyr_test() { rm -f /tmp/procfifo rm -f res.text mkfifo /tmp/procfifo - + make run | tee res.txt > /tmp/procfifo & PID=$! SECONDS=0 @@ -91,7 +91,7 @@ run_zephyr_test() { echo "----------------------------------------------------------------" return_val=1 fi - + rm -f /tmp/procfifo popd return "$return_val" @@ -124,4 +124,4 @@ if [ "$overall_success" = false ]; then exit 1 fi -exit 0 \ No newline at end of file +exit 0 diff --git a/util/scripts/launch-fedsd.sh b/util/scripts/launch-fedsd.sh index e09c60fc1e..609f9608af 100755 --- a/util/scripts/launch-fedsd.sh +++ b/util/scripts/launch-fedsd.sh @@ -79,8 +79,8 @@ for each_lft_file in $lft_files_list # Get the file name csv=${each_lft_file%.*} if [ $csv == 'rti' ] - then - # Set the rti csv file + then + # Set the rti csv file rti_csv_file='rti.csv' else # Construct the csv file name and add it to the list @@ -97,7 +97,7 @@ if [ $rti_csv_file == '' ] then # FIXME: Support the case where no rti file is given python3 "${base}/util/tracing/visualization/fedsd.py" "-f" $csv_files_list -else +else echo Building the communication diagram for the following trace files: $lft_files_list in trace_svg.html python3 "${base}/util/tracing/visualization/fedsd.py" "-r" "$rti_csv_file" "-f" $csv_files_list fi diff --git a/util/scripts/launch.sh b/util/scripts/launch.sh index 5c335a6fe8..fc6dc83c6c 100755 --- a/util/scripts/launch.sh +++ b/util/scripts/launch.sh @@ -75,4 +75,3 @@ if [ $# -eq 0 ]; then else "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args="$*" fi - diff --git a/util/tracing/README.md b/util/tracing/README.md index 28d8db23d7..e430e47d7e 100644 --- a/util/tracing/README.md +++ b/util/tracing/README.md @@ -1,6 +1,6 @@ ## util/tracing -This directory contains the source code for utilities that are standalone executables +This directory contains the source code for utilities that are standalone executables for post-processing tracing data created by the tracing function in Lingua Franca. Utilities for visualizing the data are contained in the [visualization](visualization/README.md) @@ -8,16 +8,16 @@ directory. * trace\_to\_csv: Creates a comma-separated values text file from a binary trace file. The resulting file is suitable for analyzing in spreadsheet programs such as Excel. - + * trace\_to\_chrome: Creates a JSON file suitable for importing into Chrome's trace visualizer. Point Chrome to chrome://tracing/ and load the resulting file. - + * trace\_to\_influxdb: A preliminary implementation that takes a binary trace file and uploads its data into [InfluxDB](https://en.wikipedia.org/wiki/InfluxDB). - + ## Installing ``` make install ``` -This puts the executables in lingua-franca/bin. \ No newline at end of file +This puts the executables in lingua-franca/bin. diff --git a/util/tracing/visualization/README.md b/util/tracing/visualization/README.md index 82861e9b2a..0121fc15b3 100644 --- a/util/tracing/visualization/README.md +++ b/util/tracing/visualization/README.md @@ -1,6 +1,6 @@ # Trace sequence diagram visualiser -This is a 1st iteration of a prototyping tool for constructing a sequence diagram +This is a 1st iteration of a prototyping tool for constructing a sequence diagram out of the traces. It operates over the csv files generated by `trace_to_csv`. @@ -16,10 +16,6 @@ The output is an html file with the svg in it. # Current problems - The collected traces are not complete. They need to be checked for correcteness as well. -- All arrows are horizontal and can be duplicated. Need further processing to derive the connections +- All arrows are horizontal and can be duplicated. Need further processing to derive the connections for that. - The scale needs exploration - - - - From b7ef452ec1d8e4810c8605e6a2cc15f70547c825 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 29 May 2023 13:41:50 +0200 Subject: [PATCH 571/709] fix ps1 script --- util/scripts/launch.ps1 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/scripts/launch.ps1 b/util/scripts/launch.ps1 index 26e3db1d30..97d0afd3f3 100644 --- a/util/scripts/launch.ps1 +++ b/util/scripts/launch.ps1 @@ -29,7 +29,7 @@ $base="$PSScriptRoot\..\..\" $gradlew="${base}/gradlew.bat" # invoke script -if ($args.Length == 0) { +if ($args.Length -eq 0) { & "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" } else { $argsString = $args -join " " From 1039a0c35a362accabd4c3f71b7ccb57acd99756 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Mon, 29 May 2023 13:52:35 +0200 Subject: [PATCH 572/709] fix serialization and integration tests --- .github/workflows/lsp-tests.yml | 4 ++-- .github/workflows/serialization-tests.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index ca82c3f41c..d3ae1123a5 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -69,7 +69,7 @@ jobs: with: python-version: '3.10' - name: Run language server Python tests without PyLint - run: ./gradlew org.lflang:core:integration --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly + run: ./gradlew org.lflang:core:test --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly - name: Install pylint run: python3 -m pip install pylint if: ${{ runner.os != 'macOS' }} @@ -77,7 +77,7 @@ jobs: run: brew install pylint if: ${{ runner.os == 'macOS' }} - name: Run language server tests - run: ./gradlew org.lflang:core:integration --tests org.lflang.tests.lsp.LspTests.*ValidationTest + run: ./gradlew org.lflang:core:test --tests org.lflang.tests.lsp.LspTests.*ValidationTest - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 00738e99fa..24441ff7d6 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -31,7 +31,7 @@ jobs: - name: Run serialization tests; run: | source /opt/ros/*/setup.bash - ./gradlew org.lflang:core:integration --test org.lflang.test.serialization.SerializationTest.* + ./gradlew org.lflang:core:test --test org.lflang.test.serialization.SerializationTest.* - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov From 4c05b68385f49bf5df1a53421da11cb4cff3b4e6 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 29 May 2023 10:29:13 -0700 Subject: [PATCH 573/709] Update reactor-c. --- org.lflang/src/lib/c/reactor-c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/c/reactor-c b/org.lflang/src/lib/c/reactor-c index 83b1cef7fd..89dcee3c3f 160000 --- a/org.lflang/src/lib/c/reactor-c +++ b/org.lflang/src/lib/c/reactor-c @@ -1 +1 @@ -Subproject commit 83b1cef7fd4209b3e25b6a310ce8f964277d9692 +Subproject commit 89dcee3c3f95bf8227162f630beada8d96f6270d From 5b8129b40ba013d54d13a066fedb9cc4c6306578 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 29 May 2023 11:59:08 -0700 Subject: [PATCH 574/709] Use a flag to indicate successful exit. For some reason, creating a trap for SIGTERM results in SIGTERM not causing the program to exit. In any case, we really do not want the program to exit without killing the RTI and federates under any circumstance unless we are sure that the program terminated successfully. Therefore, it seems safest to require positive confirmation via an EXITED_SUCCESSFULLY flag that the program really did exit successfully. --- .../launcher/FedLauncherGenerator.java | 35 +++++++------------ 1 file changed, 13 insertions(+), 22 deletions(-) diff --git a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java index 0f024b6499..b3be6acad0 100644 --- a/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java +++ b/org.lflang/src/org/lflang/federated/launcher/FedLauncherGenerator.java @@ -205,7 +205,8 @@ public void doGenerate(List federates, RtiConfig rtiConfig) { "do", " wait $pid", "done", - "echo \"All done.\"") + "echo \"All done.\"", + "EXITED_SUCCESSFULLY=true") + "\n"); // Create bin directory for the script. @@ -281,29 +282,19 @@ private String getSetupCode() { "# Set a trap to kill all background jobs on error or control-C", "# Use two distinct traps so we can see which signal causes this.", "cleanup() {", - " printf \"Killing federate %s.\\n\" ${pids[*]}", - " # The || true clause means this is not an error if kill fails.", - " kill ${pids[@]} || true", - " printf \"#### Killing RTI %s.\\n\" ${RTI}", - " kill ${RTI} || true", - " exit 1", - "}", - "cleanup_err() {", - " echo \"#### Received ERR signal on line $1. Invoking cleanup().\"", - " cleanup", - "}", - "cleanup_sigint() {", - " echo \"#### Received SIGINT signal on line $1. Invoking cleanup().\"", - " cleanup", - "}", - "cleanup_sigterm() {", - " echo \"#### Received SIGTERM signal on line $1. Invoking cleanup().\"", - " cleanup", + " if [ \"$EXITED_SUCCESSFULLY\" = true ] ; then", + " exit 0", + " else", + " printf \"Killing federate %s.\\n\" ${pids[*]}", + " # The || true clause means this is not an error if kill fails.", + " kill ${pids[@]} || true", + " printf \"#### Killing RTI %s.\\n\" ${RTI}", + " kill ${RTI} || true", + " exit 1", + " fi", "}", "", - "trap 'cleanup_err $LINENO' ERR", - "trap 'cleanup_sigint $LINENO' SIGINT", - "trap 'cleanup_sigterm $LINENO' SIGTERM", + "trap 'cleanup; exit' EXIT", "", "# Create a random 48-byte text ID for this federation.", "# The likelihood of two federations having the same ID is 1/16,777,216 (1/2^24).", From 98e33df124a8e96f32a15af2f7a8099ff05f3483 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 29 May 2023 12:03:47 -0700 Subject: [PATCH 575/709] Replace lf_request_stop with request_stop. This replaces all instances in the test/Python/src directory. --- test/Python/src/docker/FilesPropertyContainerized.lf | 4 ++-- .../DistributedStopDecentralizedContainerized.lf | 2 +- test/Python/src/federated/DistributedSendClass.lf | 2 +- test/Python/src/federated/DistributedStop.lf | 10 +++++----- .../src/federated/DistributedStopDecentralized.lf | 2 +- test/Python/src/federated/DistributedStopZero.lf | 6 +++--- test/Python/src/federated/HelloDistributed.lf | 2 +- test/Python/src/federated/PingPongDistributed.lf | 4 ++-- test/Python/src/federated/StopAtShutdown.lf | 6 +++--- 9 files changed, 19 insertions(+), 19 deletions(-) diff --git a/test/Python/src/docker/FilesPropertyContainerized.lf b/test/Python/src/docker/FilesPropertyContainerized.lf index c34736af48..26cf706a2b 100644 --- a/test/Python/src/docker/FilesPropertyContainerized.lf +++ b/test/Python/src/docker/FilesPropertyContainerized.lf @@ -7,7 +7,7 @@ preamble {= try: import hello except: - lf_request_stop() + request_stop() =} main reactor { @@ -15,7 +15,7 @@ main reactor { try: import hello except: - lf_request_stop() + request_stop() =} state passed = False timer t(1 msec) diff --git a/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf b/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf index 11e24746cd..98f5189006 100644 --- a/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf +++ b/test/Python/src/docker/federated/DistributedStopDecentralizedContainerized.lf @@ -1,5 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with decentralized + * Test for request_stop() in federated execution with decentralized * coordination. * * @author Soroush Bateni diff --git a/test/Python/src/federated/DistributedSendClass.lf b/test/Python/src/federated/DistributedSendClass.lf index fd056bb0c0..9bc4a52694 100644 --- a/test/Python/src/federated/DistributedSendClass.lf +++ b/test/Python/src/federated/DistributedSendClass.lf @@ -9,7 +9,7 @@ preamble {= reactor A { input o - reaction(o) {= lf_request_stop() =} + reaction(o) {= request_stop() =} } reactor B { diff --git a/test/Python/src/federated/DistributedStop.lf b/test/Python/src/federated/DistributedStop.lf index 06dfe96c36..cb32fc4e84 100644 --- a/test/Python/src/federated/DistributedStop.lf +++ b/test/Python/src/federated/DistributedStop.lf @@ -1,5 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with centralized + * Test for request_stop() in federated execution with centralized * coordination. * * @author Soroush Bateni @@ -23,16 +23,16 @@ reactor Sender { if lf.tag().microstep == 0: # Instead of having a separate reaction # for 'act' like Stop.lf, we trigger the - # same reaction to test lf_request_stop() being + # same reaction to test request_stop() being # called multiple times act.schedule(0) if tag.time == USEC(1): - # Call lf_request_stop() both at (1 usec, 0) and + # Call request_stop() both at (1 usec, 0) and # (1 usec, 1) print("Requesting stop at ({}, {}).".format( lf.time.logical_elapsed(), lf.tag().microstep)) - lf_request_stop() + request_stop() _1usec1 = Tag(time=USEC(1) + get_start_time(), microstep=1) if lf.tag_compare(lf.tag(), _1usec1) == 0: @@ -77,7 +77,7 @@ reactor Receiver( print("Requesting stop at ({}, {}).".format( lf.time.logical_elapsed(), lf.tag().microstep)) - lf_request_stop() + request_stop() # The receiver should receive a message at tag # (1 usec, 1) and trigger this reaction self.reaction_invoked_correctly = True diff --git a/test/Python/src/federated/DistributedStopDecentralized.lf b/test/Python/src/federated/DistributedStopDecentralized.lf index e6afa6384b..f3df5ce9f8 100644 --- a/test/Python/src/federated/DistributedStopDecentralized.lf +++ b/test/Python/src/federated/DistributedStopDecentralized.lf @@ -1,5 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with decentralized + * Test for request_stop() in federated execution with decentralized * coordination. * * @author Soroush Bateni diff --git a/test/Python/src/federated/DistributedStopZero.lf b/test/Python/src/federated/DistributedStopZero.lf index 089a839105..aef9d94f53 100644 --- a/test/Python/src/federated/DistributedStopZero.lf +++ b/test/Python/src/federated/DistributedStopZero.lf @@ -1,5 +1,5 @@ /** - * Test for lf_request_stop() in federated execution with centralized + * Test for request_stop() in federated execution with centralized * coordination at tag (0,0). * * @author Soroush Bateni @@ -29,7 +29,7 @@ reactor Sender { print("Requesting stop at ({}, {}).".format( lf.time.logical_elapsed(), lf.tag().microstep)) - lf_request_stop() + request_stop() =} reaction(shutdown) {= @@ -63,7 +63,7 @@ reactor Receiver { print("Requesting stop at ({}, {}).".format( tag.time, tag.microstep)) - lf_request_stop() + request_stop() =} reaction(shutdown) {= diff --git a/test/Python/src/federated/HelloDistributed.lf b/test/Python/src/federated/HelloDistributed.lf index ef99c3f793..e3ae0e97dc 100644 --- a/test/Python/src/federated/HelloDistributed.lf +++ b/test/Python/src/federated/HelloDistributed.lf @@ -13,7 +13,7 @@ reactor Source { reaction(startup) -> out {= print("Sending 'Hello World!' message from source federate."); out.set("Hello World!") - lf_request_stop() + request_stop() =} } diff --git a/test/Python/src/federated/PingPongDistributed.lf b/test/Python/src/federated/PingPongDistributed.lf index 0f58cbf7db..8de76609c9 100644 --- a/test/Python/src/federated/PingPongDistributed.lf +++ b/test/Python/src/federated/PingPongDistributed.lf @@ -37,7 +37,7 @@ reactor Ping(count = 10) { if self.pingsLeft > 0: serve.schedule(0) else: - lf_request_stop() + request_stop() =} } @@ -53,7 +53,7 @@ reactor Pong(expected = 10) { print("At logical time {}, Pong received {}.\n".format(lf.time.logical_elapsed(), receive.value)) send.set(receive.value) if self.count == self.expected: - lf_request_stop() + request_stop() =} reaction(shutdown) {= diff --git a/test/Python/src/federated/StopAtShutdown.lf b/test/Python/src/federated/StopAtShutdown.lf index 3179c44592..0327623fd9 100644 --- a/test/Python/src/federated/StopAtShutdown.lf +++ b/test/Python/src/federated/StopAtShutdown.lf @@ -1,5 +1,5 @@ /** - * Check that lf_request_stop() doesn't cause any issues at the shutdown tag. + * Check that request_stop() doesn't cause any issues at the shutdown tag. * * Original bug discovered by Steven Wong * @@ -16,7 +16,7 @@ reactor A { reaction(in_) {= print("Got it") =} - reaction(shutdown) {= lf_request_stop() =} + reaction(shutdown) {= request_stop() =} } reactor B { @@ -25,7 +25,7 @@ reactor B { reaction(t) -> out {= out.set(1) =} - reaction(shutdown) {= lf_request_stop() =} + reaction(shutdown) {= request_stop() =} } federated reactor { From 3f5e9443e6668a4066fe10391381bf31ab6e4b55 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 29 May 2023 15:17:24 -0700 Subject: [PATCH 576/709] Fix get_start_time issue. --- test/Python/src/federated/DistributedStop.lf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/Python/src/federated/DistributedStop.lf b/test/Python/src/federated/DistributedStop.lf index cb32fc4e84..174ff53858 100644 --- a/test/Python/src/federated/DistributedStop.lf +++ b/test/Python/src/federated/DistributedStop.lf @@ -34,7 +34,7 @@ reactor Sender { lf.tag().microstep)) request_stop() - _1usec1 = Tag(time=USEC(1) + get_start_time(), microstep=1) + _1usec1 = Tag(time=USEC(1) + lf.time.start(), microstep=1) if lf.tag_compare(lf.tag(), _1usec1) == 0: # The reaction was invoked at (1 usec, 1) as expected self.reaction_invoked_correctly = True @@ -82,7 +82,7 @@ reactor Receiver( # (1 usec, 1) and trigger this reaction self.reaction_invoked_correctly = True - _1usec1 = Tag(time=USEC(1) + get_start_time(), microstep=1) + _1usec1 = Tag(time=USEC(1) + lf.time.start(), microstep=1) if lf.tag_compare(lf.tag(), _1usec1) > 0: self.reaction_invoked_correctly = False =} From 83cd35ab79a3b7a210ce1dfdc54d0d881d03c418 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 29 May 2023 16:20:46 -0700 Subject: [PATCH 577/709] Patch over the files property merging. This is not the right solution. The right solution is not to do the files property merging in the first place. This has been discusssed. I think everyone agrees about this, but probably it will not be fixed until the package manager is more complete. --- org.lflang/src/org/lflang/TargetProperty.java | 28 +++++++++++++++---- .../federated/generator/FedTargetConfig.java | 12 +++++++- test/Python/src/include/hello.py | 2 +- 3 files changed, 34 insertions(+), 8 deletions(-) diff --git a/org.lflang/src/org/lflang/TargetProperty.java b/org.lflang/src/org/lflang/TargetProperty.java index b3abf815a3..e9e3b0273d 100644 --- a/org.lflang/src/org/lflang/TargetProperty.java +++ b/org.lflang/src/org/lflang/TargetProperty.java @@ -31,6 +31,7 @@ import java.util.Arrays; import java.util.LinkedList; import java.util.List; +import java.util.Objects; import java.util.Optional; import java.util.function.Predicate; import java.util.stream.Collectors; @@ -283,10 +284,6 @@ public enum TargetProperty { (config, value, err) -> { config.files = ASTUtils.elementToListOfStrings(value); }, - // FIXME: This merging of lists is potentially dangerous since - // the incoming list of files can belong to a .lf file that is - // located in a different location, and keeping just filename - // strings like this without absolute paths is incorrect. (config, value, err) -> { config.files.addAll(ASTUtils.elementToListOfStrings(value)); }), @@ -995,15 +992,34 @@ public static TargetDecl extractTargetDecl(Target target, TargetConfig config) { * * @param config The configuration object to update. * @param properties AST node that holds all the target properties. + * @param relativePath The path from the main resource to the resource from which the new + * properties originate. */ - public static void update(TargetConfig config, List properties, ErrorReporter err) { + public static void update( + TargetConfig config, List properties, Path relativePath, ErrorReporter err) { properties.forEach( property -> { TargetProperty p = forName(property.getName()); if (p != null) { // Mark the specified target property as set by the user config.setByUser.add(p); - p.updater.parseIntoTargetConfig(config, property.getValue(), err); + var value = property.getValue(); + if (property.getName().equals("files")) { + var array = LfFactory.eINSTANCE.createArray(); + ASTUtils.elementToListOfStrings(property.getValue()).stream() + .map(relativePath::resolve) // assume all paths are relative + .map(Objects::toString) + .map( + s -> { + var element = LfFactory.eINSTANCE.createElement(); + element.setLiteral(s); + return element; + }) + .forEach(array.getElements()::add); + value = LfFactory.eINSTANCE.createElement(); + value.setArray(array); + } + p.updater.parseIntoTargetConfig(config, value, err); } }); } diff --git a/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java b/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java index 3252f31a39..aa0cfccc14 100644 --- a/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java +++ b/org.lflang/src/org/lflang/federated/generator/FedTargetConfig.java @@ -2,6 +2,7 @@ import static org.lflang.ast.ASTUtils.convertToEmptyListIfNull; +import java.nio.file.Path; import org.eclipse.emf.ecore.resource.Resource; import org.lflang.ErrorReporter; import org.lflang.TargetConfig; @@ -57,11 +58,20 @@ private void mergeImportedConfig( if (targetProperties != null) { // Merge properties TargetProperty.update( - this, convertToEmptyListIfNull(targetProperties.getPairs()), errorReporter); + this, + convertToEmptyListIfNull(targetProperties.getPairs()), + getRelativePath(mainResource, federateResource), + errorReporter); } } } + private Path getRelativePath(Resource source, Resource target) { + return Path.of(source.getURI().toFileString()) + .getParent() + .relativize(Path.of(target.getURI().toFileString()).getParent()); + } + /** Method for the removal of things that should not appear in the target config of a federate. */ private void clearPropertiesToIgnore() { this.setByUser.remove(TargetProperty.CLOCK_SYNC); diff --git a/test/Python/src/include/hello.py b/test/Python/src/include/hello.py index 4f92cbbca6..c26b545aad 100644 --- a/test/Python/src/include/hello.py +++ b/test/Python/src/include/hello.py @@ -1,4 +1,4 @@ class hello: def __init__(self, name = "", value = 0): self.name = name - self.value = value + self.value = value From 853e0228ae2009e96625beeab86c70eba713ed93 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 09:15:54 +0200 Subject: [PATCH 578/709] hotfix: fallback to insecure protocol for fetching from kieler repo --- org.lflang/build.gradle | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang/build.gradle b/org.lflang/build.gradle index 8d4f6a41c9..96b16f8771 100644 --- a/org.lflang/build.gradle +++ b/org.lflang/build.gradle @@ -4,7 +4,8 @@ repositories { mavenCentral() // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. maven { - url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + url "http://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + allowInsecureProtocol = true } } dependencies { From 0633098078a7917856347c184d4f5854e7443d02 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 09:58:59 +0200 Subject: [PATCH 579/709] also update testing gradle config --- org.lflang.tests/build.gradle | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang.tests/build.gradle b/org.lflang.tests/build.gradle index 97f664c1a8..e1311fc5b3 100644 --- a/org.lflang.tests/build.gradle +++ b/org.lflang.tests/build.gradle @@ -2,7 +2,8 @@ repositories { mavenCentral() // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. maven { - url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + url "http://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" + allowInsecureProtocol = true } } dependencies { From bb37e1bee1e6b8bef4d232a094ce26096e560d8e Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 12:16:12 +0200 Subject: [PATCH 580/709] be more careful about excluding files from spotlessMisc --- build.gradle | 4 +++- org.lflang/core/build.gradle | 2 ++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 56b50afb4b..63aefb745b 100644 --- a/build.gradle +++ b/build.gradle @@ -10,7 +10,9 @@ spotless { format 'misc', { target project.fileTree(project.rootDir) { include '**/*.gradle', '**/*.md', '.gitignore', '**/*.yml', '**/*.sh', '**/*.psi' - exclude '**/reactor-cpp/**', '**/reactor-c/**', '**/reactor-rs/**', '**/lf-python-support' + exclude '**/reactor-cpp/**', '**/reactor-c/**', '**/reactor-rs/**', '**/lf-python-support/**', + '**/src-gen/**', '**/fed-gen/**', '**/test-gen/**', '**/build/**', + 'test/*/include', 'test/*/bin/', 'test/*/share', 'test/*/lib' } // define the steps to apply to those files diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index 2589734b8a..ca269ace61 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -66,6 +66,7 @@ tasks.register('generateXtextLanguage', JavaExec) { inputs.file "src/main/java/org/lflang/GenerateLinguaFranca.mwe2" inputs.file "src/main/java/org/lflang/LinguaFranca.xtext" outputs.dir "src-gen" + outputs.dir "test-gen" outputs.dir "model" outputs.file ".antlr-generator-3.2.0-patch.jar" args += "src/main/java/org/lflang/GenerateLinguaFranca.mwe2" @@ -78,6 +79,7 @@ compileKotlin.dependsOn(generateXtextLanguage) processResources.dependsOn(generateXtextLanguage) clean.dependsOn(cleanGenerateXtextLanguage) spotlessJava.mustRunAfter(generateXtextLanguage) +rootProject.spotlessMisc.mustRunAfter(generateXtextLanguage) tasks.register('getSubmoduleVersions', Exec) { description('Run a Git command to get the current status of submodules') From 80a12633c75053a086ae86f7f982608bf1610a30 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 13:54:40 +0200 Subject: [PATCH 581/709] use gradle's test suite feature to separate integration tests --- .../groovy/org.lflang.test-conventions.gradle | 40 +++++++++++-------- org.lflang/core/build.gradle | 25 +++++++----- .../java/org/lflang/tests/RuntimeTest.java | 13 ------ .../org/lflang/tests/lsp/ErrorInserter.java | 0 .../java/org/lflang/tests/lsp/LspTests.java | 5 --- .../lflang/tests/lsp/MockLanguageClient.java | 0 .../lflang/tests/lsp/MockReportProgress.java | 0 .../lflang/tests/runtime/CArduinoTest.java | 1 - .../org/lflang/tests/runtime/CCppTest.java | 1 - .../lflang/tests/runtime/CSchedulerTest.java | 1 - .../java/org/lflang/tests/runtime/CTest.java | 12 ------ .../org/lflang/tests/runtime/CZephyrTest.java | 2 - .../org/lflang/tests/runtime/CppRos2Test.java | 1 - .../org/lflang/tests/runtime/CppTest.java | 6 --- .../org/lflang/tests/runtime/PythonTest.java | 9 ----- .../org/lflang/tests/runtime/RustTest.java | 0 .../lflang/tests/runtime/TypeScriptTest.java | 8 ---- .../serialization/SerializationTest.java | 2 - .../java/org/lflang/tests/Configurators.java | 0 .../java/org/lflang/tests/LFTest.java | 0 .../java/org/lflang/tests/TestBase.java | 0 .../java/org/lflang/tests/TestError.java | 0 .../java/org/lflang/tests/TestRegistry.java | 3 +- 23 files changed, 40 insertions(+), 89 deletions(-) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/RuntimeTest.java (95%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/lsp/ErrorInserter.java (100%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/lsp/LspTests.java (98%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/lsp/MockLanguageClient.java (100%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/lsp/MockReportProgress.java (100%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/CArduinoTest.java (97%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/CCppTest.java (98%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/CSchedulerTest.java (98%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/CTest.java (93%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/CZephyrTest.java (98%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/CppRos2Test.java (97%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/CppTest.java (95%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/PythonTest.java (94%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/RustTest.java (100%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/runtime/TypeScriptTest.java (90%) rename org.lflang/core/src/{test => integrationTest}/java/org/lflang/tests/serialization/SerializationTest.java (96%) rename org.lflang/core/src/{test => testFixtures}/java/org/lflang/tests/Configurators.java (100%) rename org.lflang/core/src/{test => testFixtures}/java/org/lflang/tests/LFTest.java (100%) rename org.lflang/core/src/{test => testFixtures}/java/org/lflang/tests/TestBase.java (100%) rename org.lflang/core/src/{test => testFixtures}/java/org/lflang/tests/TestError.java (100%) rename org.lflang/core/src/{test => testFixtures}/java/org/lflang/tests/TestRegistry.java (99%) diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 8385720b8d..ef5a1467e3 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -25,36 +25,42 @@ dependencies { testFixturesImplementation "org.eclipse.xtext:org.eclipse.xtext.xbase.testing:$xtextVersion" } -def integrationTest = false -tasks.register('integration') { - integrationTest = true -} -integration.finalizedBy(test) -test { - useJUnitPlatform { - if (integrationTest) { - includeTags 'Integration' - } else { - excludeTags 'Integration' +testing { + suites { + test { + useJUnitJupiter() } - } - if (integrationTest && project.hasProperty('target')) { - filter { - includeTestsMatching "org.lflang.tests.runtime.${project.property('target')}Test.*" + integrationTest(JvmTestSuite) { + dependencies { + implementation project() + implementation testFixtures(project()) + } } } +} + +test { testLogging { events "passed", "skipped", "failed" showStandardStreams = true exceptionFormat "full" } - maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1 + integrationTest { + testLogging { + events "passed", "skipped", "failed" + showStandardStreams = true + exceptionFormat "full" + } - failFast = true + failFast = true + workingDir = rootProject.projectDir + } + maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1 + failFast = true workingDir = rootProject.projectDir } diff --git a/org.lflang/core/build.gradle b/org.lflang/core/build.gradle index ca269ace61..536bed337d 100644 --- a/org.lflang/core/build.gradle +++ b/org.lflang/core/build.gradle @@ -4,19 +4,24 @@ plugins { } sourceSets { - main { - java { - srcDirs = ['src/main/java', 'src-gen'] + main { + java { + srcDirs = ['src/main/java', 'src-gen'] + } + resources { + srcDirs = ['src/main/resources', 'src-gen'] + } } - resources { - srcDirs = ['src/main/resources', 'src-gen'] + test { + java { + srcDirs = ['src/test/java', 'test-gen'] + } } - } - test { - java { - srcDirs = ['src/test/java', 'test-gen'] + testFixtures { + java { + srcDirs = ['src/testFixtures/java', 'test-gen'] + } } - } } dependencies { diff --git a/org.lflang/core/src/test/java/org/lflang/tests/RuntimeTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java similarity index 95% rename from org.lflang/core/src/test/java/org/lflang/tests/RuntimeTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java index c873dcd427..8b1db46d9e 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/RuntimeTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java @@ -55,7 +55,6 @@ protected boolean supportsDockerOption() { } @Test - @Tag("Integration") public void runGenericTests() { runTestsForTargets( Message.DESC_GENERIC, @@ -66,7 +65,6 @@ public void runGenericTests() { } @Test - @Tag("Integration") public void runTargetSpecificTests() { runTestsForTargets( Message.DESC_TARGET_SPECIFIC, @@ -77,7 +75,6 @@ public void runTargetSpecificTests() { } @Test - @Tag("Integration") public void runMultiportTests() { runTestsForTargets( Message.DESC_MULTIPORT, @@ -88,7 +85,6 @@ public void runMultiportTests() { } @Test - @Tag("Integration") public void runTypeParameterTests() { Assumptions.assumeTrue(supportsGenericTypes(), Message.NO_GENERICS_SUPPORT); runTestsForTargets( @@ -100,7 +96,6 @@ public void runTypeParameterTests() { } @Test - @Tag("Integration") public void runAsFederated() { Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); @@ -122,7 +117,6 @@ public void runAsFederated() { } @Test - @Tag("Integration") public void runConcurrentTests() { runTestsForTargets( Message.DESC_CONCURRENT, @@ -133,7 +127,6 @@ public void runConcurrentTests() { } @Test - @Tag("Integration") public void runFederatedTests() { Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); runTestsForTargets( @@ -146,7 +139,6 @@ public void runFederatedTests() { /** Run the tests for modal reactors. */ @Test - @Tag("Integration") public void runModalTests() { runTestsForTargets( Message.DESC_MODAL, @@ -158,7 +150,6 @@ public void runModalTests() { /** Run the tests for non-inlined reaction bodies. */ @Test - @Tag("Integration") public void runNoInliningTests() { runTestsForTargets( Message.DESC_MODAL, @@ -173,7 +164,6 @@ public void runNoInliningTests() { * platform is not Linux or target does not support Docker. */ @Test - @Tag("Integration") public void runDockerTests() { Assumptions.assumeTrue(isLinux(), Message.NO_DOCKER_TEST_SUPPORT); Assumptions.assumeTrue(supportsDockerOption(), Message.NO_DOCKER_SUPPORT); @@ -191,7 +181,6 @@ public void runDockerTests() { * tests. */ @Test - @Tag("Integration") public void runDockerFederatedTests() { Assumptions.assumeTrue(isLinux(), Message.NO_DOCKER_TEST_SUPPORT); Assumptions.assumeTrue(supportsDockerOption(), Message.NO_DOCKER_SUPPORT); @@ -205,7 +194,6 @@ public void runDockerFederatedTests() { } @Test - @Tag("Integration") public void runWithThreadingOff() { Assumptions.assumeTrue(supportsSingleThreadedExecution(), Message.NO_SINGLE_THREADED_SUPPORT); this.runTestsForTargets( @@ -218,7 +206,6 @@ public void runWithThreadingOff() { /** Run enclave tests if the target supports enclaves. */ @Test - @Tag("Integration") public void runEnclaveTests() { Assumptions.assumeTrue(supportsEnclaves(), Message.NO_ENCLAVE_SUPPORT); runTestsForTargets( diff --git a/org.lflang/core/src/test/java/org/lflang/tests/lsp/ErrorInserter.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/ErrorInserter.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/lsp/ErrorInserter.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/ErrorInserter.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java similarity index 98% rename from org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java index 52339161ea..2e7b7b341a 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/lsp/LspTests.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java @@ -57,35 +57,30 @@ class LspTests { /** Test for false negatives in Python syntax-only validation. */ @Test - @Tag("Integration") void pythonValidationTestSyntaxOnly() throws IOException { targetLanguageValidationTest(Target.Python, ErrorInserter.PYTHON_SYNTAX_ONLY); } /** Test for false negatives in C++ validation. */ @Test - @Tag("Integration") void cppValidationTest() throws IOException { targetLanguageValidationTest(Target.CPP, ErrorInserter.CPP); } /** Test for false negatives in Python validation. */ @Test - @Tag("Integration") void pythonValidationTest() throws IOException { targetLanguageValidationTest(Target.Python, ErrorInserter.PYTHON); } /** Test for false negatives in Rust validation. */ @Test - @Tag("Integration") void rustValidationTest() throws IOException { targetLanguageValidationTest(Target.Rust, ErrorInserter.RUST); } /** Test for false negatives in TypeScript validation. */ @Test - @Tag("Integration") void typescriptValidationTest() throws IOException { targetLanguageValidationTest(Target.TS, ErrorInserter.TYPESCRIPT); } diff --git a/org.lflang/core/src/test/java/org/lflang/tests/lsp/MockLanguageClient.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/MockLanguageClient.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/lsp/MockLanguageClient.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/MockLanguageClient.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/lsp/MockReportProgress.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/MockReportProgress.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/lsp/MockReportProgress.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/MockReportProgress.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CArduinoTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java similarity index 97% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/CArduinoTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java index 4758977143..e621092e51 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CArduinoTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java @@ -21,7 +21,6 @@ public CArduinoTest() { } @Test - @Tag("Integration") public void buildArduinoTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); super.runTestsFor( diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CCppTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java similarity index 98% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/CCppTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java index 04ea680194..82859870ae 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CCppTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java @@ -27,7 +27,6 @@ public CCppTest() { /** Run C tests with the target CCpp. */ @Test - @Tag("Integration") public void runAsCCpp() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); runTestsForTargets( diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CSchedulerTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java similarity index 98% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/CSchedulerTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java index 4730962ee0..8ff3ef9314 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CSchedulerTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java @@ -22,7 +22,6 @@ public CSchedulerTest() { * (e.g., -Dscheduler=GEDF_NP). */ @Test - @Tag("Integration") public void runWithNonDefaultSchedulers() { EnumSet categories = EnumSet.of(TestCategory.CONCURRENT, TestCategory.MULTIPORT); diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java similarity index 93% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/CTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java index 63122fb4c6..dbf173c0d1 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java @@ -47,7 +47,6 @@ public CTest() { } @Override - @Tag("Integration") protected boolean supportsSingleThreadedExecution() { return true; } @@ -63,14 +62,12 @@ protected boolean supportsDockerOption() { } @Test - @Tag("Integration") @Override public void runGenericTests() { super.runGenericTests(); } @Test - @Tag("Integration") @Override public void runTargetSpecificTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -78,21 +75,18 @@ public void runTargetSpecificTests() { } @Test - @Tag("Integration") @Override public void runMultiportTests() { super.runMultiportTests(); } @Test - @Tag("Integration") @Override public void runWithThreadingOff() { super.runWithThreadingOff(); } @Test - @Tag("Integration") @Disabled("TODO only 27/96 tests pass") @Override public void runAsFederated() { @@ -101,14 +95,12 @@ public void runAsFederated() { } @Test - @Tag("Integration") @Override public void runConcurrentTests() { super.runConcurrentTests(); } @Test - @Tag("Integration") @Override public void runFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -116,26 +108,22 @@ public void runFederatedTests() { } @Test - @Tag("Integration") public void runModalTests() { super.runModalTests(); } @Test - @Tag("Integration") public void runNoInliningTests() { super.runNoInliningTests(); } @Test - @Tag("Integration") @Override public void runDockerTests() { super.runDockerTests(); } @Test - @Tag("Integration") @Override public void runDockerFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CZephyrTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java similarity index 98% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/CZephyrTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java index 777308b221..1cf5dc550f 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CZephyrTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java @@ -45,7 +45,6 @@ public CZephyrTest() { } @Test - @Tag("Integration") public void buildZephyrTests() { Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); super.runTestsFor( @@ -58,7 +57,6 @@ public void buildZephyrTests() { } @Test - @Tag("Integration") public void buildGenericTests() { Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); super.runTestsFor( diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CppRos2Test.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java similarity index 97% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/CppRos2Test.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java index 1a333eb145..68c8dfc0d7 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CppRos2Test.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java @@ -24,7 +24,6 @@ public CppRos2Test() { /** Run C++ tests with the ros2 target property set */ @Test - @Tag("Integration") public void runWithRos2() { Assumptions.assumeTrue(isLinux(), "Only supported on Linux"); Element trueLiteral = LfFactory.eINSTANCE.createElement(); diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CppTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java similarity index 95% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/CppTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java index 879e6cdc5b..b5bd36cf14 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/CppTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java @@ -51,41 +51,35 @@ protected boolean supportsEnclaves() { } @Test - @Tag("Integration") @Override public void runGenericTests() { super.runGenericTests(); } @Test - @Tag("Integration") @Override public void runTargetSpecificTests() { super.runTargetSpecificTests(); } @Test - @Tag("Integration") @Override public void runMultiportTests() { super.runMultiportTests(); } @Test - @Tag("Integration") @Override public void runConcurrentTests() { super.runConcurrentTests(); } @Test - @Tag("Integration") @Override public void runFederatedTests() { super.runFederatedTests(); } @Test - @Tag("Integration") public void runRos2Tests() {} } diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/PythonTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java similarity index 94% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/PythonTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java index e25a3220d2..1c258b7481 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/PythonTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java @@ -27,7 +27,6 @@ import java.util.Properties; import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; @@ -73,28 +72,24 @@ protected boolean supportsDockerOption() { } @Test - @Tag("Integration") @Override public void runGenericTests() { super.runGenericTests(); } @Test - @Tag("Integration") @Override public void runTargetSpecificTests() { super.runTargetSpecificTests(); } @Test - @Tag("Integration") @Override public void runMultiportTests() { super.runMultiportTests(); } @Test - @Tag("Integration") @Disabled("TODO") @Override public void runAsFederated() { @@ -103,14 +98,12 @@ public void runAsFederated() { } @Test - @Tag("Integration") @Override public void runConcurrentTests() { super.runConcurrentTests(); } @Test - @Tag("Integration") @Override public void runFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -118,14 +111,12 @@ public void runFederatedTests() { } @Test - @Tag("Integration") @Override public void runDockerTests() { super.runDockerTests(); } @Test - @Tag("Integration") @Override public void runDockerFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/RustTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/RustTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/runtime/TypeScriptTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java similarity index 90% rename from org.lflang/core/src/test/java/org/lflang/tests/runtime/TypeScriptTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java index 0945c3ebe3..8494f2cad9 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/runtime/TypeScriptTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java @@ -31,35 +31,30 @@ protected boolean supportsFederatedExecution() { } @Test - @Tag("Integration") @Override public void runGenericTests() { super.runGenericTests(); } @Test - @Tag("Integration") @Override public void runTargetSpecificTests() { super.runTargetSpecificTests(); } @Test - @Tag("Integration") @Override public void runMultiportTests() { super.runMultiportTests(); } @Test - @Tag("Integration") @Override public void runConcurrentTests() { super.runConcurrentTests(); } @Test - @Tag("Integration") @Override public void runFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -67,14 +62,12 @@ public void runFederatedTests() { } @Test - @Tag("Integration") @Override public void runDockerTests() { super.runDockerTests(); } @Test - @Tag("Integration") @Override public void runDockerFederatedTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); @@ -82,7 +75,6 @@ public void runDockerFederatedTests() { } @Test - @Tag("Integration") @Override public void runAsFederated() {} } diff --git a/org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java similarity index 96% rename from org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java index 25e0983783..01d08adee9 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/serialization/SerializationTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java @@ -23,7 +23,6 @@ protected void addExtraLfcArgs(Properties args) { } @Test - @Tag("Integration") public void runSerializationTestsWithThreadingOff() { Assumptions.assumeTrue(supportsSingleThreadedExecution(), Message.NO_SINGLE_THREADED_SUPPORT); runTestsForTargets( @@ -35,7 +34,6 @@ public void runSerializationTestsWithThreadingOff() { } @Test - @Tag("Integration") public void runSerializationTests() { Assumptions.assumeFalse(isWindows(), Message.NO_WINDOWS_SUPPORT); runTestsForTargets( diff --git a/org.lflang/core/src/test/java/org/lflang/tests/Configurators.java b/org.lflang/core/src/testFixtures/java/org/lflang/tests/Configurators.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/Configurators.java rename to org.lflang/core/src/testFixtures/java/org/lflang/tests/Configurators.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/LFTest.java b/org.lflang/core/src/testFixtures/java/org/lflang/tests/LFTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/LFTest.java rename to org.lflang/core/src/testFixtures/java/org/lflang/tests/LFTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/TestBase.java b/org.lflang/core/src/testFixtures/java/org/lflang/tests/TestBase.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/TestBase.java rename to org.lflang/core/src/testFixtures/java/org/lflang/tests/TestBase.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/TestError.java b/org.lflang/core/src/testFixtures/java/org/lflang/tests/TestError.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/TestError.java rename to org.lflang/core/src/testFixtures/java/org/lflang/tests/TestError.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/TestRegistry.java b/org.lflang/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java similarity index 99% rename from org.lflang/core/src/test/java/org/lflang/tests/TestRegistry.java rename to org.lflang/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java index 2c59740e0a..483448bd8f 100644 --- a/org.lflang/core/src/test/java/org/lflang/tests/TestRegistry.java +++ b/org.lflang/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java @@ -200,10 +200,11 @@ public String getHeader() { // Walk the tree. try { Path dir = LF_TEST_PATH.resolve(target.getDirectoryName()).resolve("src"); + System.out.println(dir.toAbsolutePath()); if (Files.exists(dir)) { new TestDirVisitor(rs, target, dir).walk(); } else { - System.out.println("WARNING: No test directory for target " + target + "\n"); + System.out.println("WARNING: No test directory for target " + target + "\n"); } } catch (IOException e) { From 41769205e26549b0c082f32fd157d08e6a8434a6 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 15:11:11 +0200 Subject: [PATCH 582/709] add a targetTest task to the root project --- build.gradle | 14 +++++++++++--- .../main/groovy/org.lflang.test-conventions.gradle | 7 +++++++ .../java/org/lflang/tests/RuntimeTest.java | 1 - .../java/org/lflang/tests/lsp/LspTests.java | 1 - .../org/lflang/tests/runtime/CArduinoTest.java | 1 - .../java/org/lflang/tests/runtime/CCppTest.java | 1 - .../org/lflang/tests/runtime/CSchedulerTest.java | 1 - .../java/org/lflang/tests/runtime/CTest.java | 1 - .../java/org/lflang/tests/runtime/CZephyrTest.java | 1 - .../java/org/lflang/tests/runtime/CppRos2Test.java | 1 - .../java/org/lflang/tests/runtime/CppTest.java | 1 - .../org/lflang/tests/runtime/TypeScriptTest.java | 1 - .../tests/serialization/SerializationTest.java | 1 - 13 files changed, 18 insertions(+), 14 deletions(-) diff --git a/build.gradle b/build.gradle index 63aefb745b..7130f505d1 100644 --- a/build.gradle +++ b/build.gradle @@ -8,7 +8,7 @@ plugins { spotless { format 'misc', { - target project.fileTree(project.rootDir) { + target rootProject.fileTree(rootProject.rootDir) { include '**/*.gradle', '**/*.md', '.gitignore', '**/*.yml', '**/*.sh', '**/*.psi' exclude '**/reactor-cpp/**', '**/reactor-c/**', '**/reactor-rs/**', '**/lf-python-support/**', '**/src-gen/**', '**/fed-gen/**', '**/test-gen/**', '**/build/**', @@ -29,8 +29,8 @@ spotless { } // Make the LF formatting task depend on lff -spotlessLinguaFranca.dependsOn(':org.lflang:cli:lff:installDist') -spotlessLinguaFranca.inputs.files(tasks.getByPath(':org.lflang:cli:lff:installDist').outputs) +spotlessLinguaFranca.dependsOn('org.lflang:cli:lff:installDist') +spotlessLinguaFranca.inputs.files(tasks.getByPath('org.lflang:cli:lff:installDist').outputs) distributions { clitools { @@ -58,3 +58,11 @@ tasks.register('runLfc', JavaExec) { tasks.register('runLff', JavaExec) { dependsOn('org.lflang:cli:lff:run') } +tasks.register('targetTest') { + if (!project.hasProperty('target')) { + def testFiles = rootProject.fileTree("${rootProject.rootDir}/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime").files + def targets = testFiles.collect {it.getName().substring(0, it.getName().length() - 9);} + throw new GradleException("Please set the \'target\' project property using -Ptarget=<...>. You may chose any of $targets") + } + finalizedBy('org.lflang:core:integrationTest') +} diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index ef5a1467e3..00025fb5f1 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -49,6 +49,13 @@ test { exceptionFormat "full" } integrationTest { + + if (project.hasProperty('target')) { + filter { + includeTestsMatching "org.lflang.tests.runtime.${project.property('target')}Test.*" + } + } + testLogging { events "passed", "skipped", "failed" showStandardStreams = true diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java index 8b1db46d9e..2dfd42d38b 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java @@ -3,7 +3,6 @@ import java.util.EnumSet; import java.util.List; import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.ast.ASTUtils; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java index 2e7b7b341a..fe52d6016c 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java @@ -12,7 +12,6 @@ import org.eclipse.emf.common.util.URI; import org.eclipse.lsp4j.Diagnostic; import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.LFRuntimeModule; import org.lflang.LFStandaloneSetup; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java index e621092e51..95363fd30b 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java @@ -2,7 +2,6 @@ import java.util.List; import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.Configurators; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java index 82859870ae..ba1865e870 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java @@ -1,7 +1,6 @@ package org.lflang.tests.runtime; import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.ast.ASTUtils; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java index 8ff3ef9314..fd2345723f 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java @@ -1,7 +1,6 @@ package org.lflang.tests.runtime; import java.util.EnumSet; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.TargetProperty.SchedulerOption; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java index dbf173c0d1..4902550661 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java @@ -26,7 +26,6 @@ import org.junit.jupiter.api.Assumptions; import org.junit.jupiter.api.Disabled; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java index 1cf5dc550f..c151c1bb76 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java @@ -26,7 +26,6 @@ import java.util.List; import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.Configurators; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java index 68c8dfc0d7..dc2612c14b 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java @@ -1,7 +1,6 @@ package org.lflang.tests.runtime; import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.ast.ASTUtils; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java index b5bd36cf14..20973189b9 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java @@ -26,7 +26,6 @@ ***************/ package org.lflang.tests.runtime; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java index 8494f2cad9..036211607a 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java @@ -1,7 +1,6 @@ package org.lflang.tests.runtime; import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java index 01d08adee9..26f3ec37af 100644 --- a/org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java @@ -2,7 +2,6 @@ import java.util.Properties; import org.junit.jupiter.api.Assumptions; -import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.Configurators; From 07b2563bb10f3acef9d668c46fa97b958b6aa312 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 15:20:30 +0200 Subject: [PATCH 583/709] update CI scripts --- .github/workflows/c-arduino-tests.yml | 2 +- .github/workflows/c-tests.yml | 2 +- .github/workflows/c-zephyr-tests.yml | 2 +- .github/workflows/cpp-ros2-tests.yml | 2 +- .github/workflows/cpp-tests.yml | 2 +- .github/workflows/lsp-tests.yml | 4 ++-- .github/workflows/py-tests.yml | 2 +- .github/workflows/rs-tests.yml | 2 +- .github/workflows/serialization-tests.yml | 2 +- .github/workflows/ts-tests.yml | 2 +- 10 files changed, 11 insertions(+), 11 deletions(-) diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 6082eaa17d..0495a4e2e4 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -63,7 +63,7 @@ jobs: arduino-cli core install arduino:sam arduino-cli core install arduino:mbed - name: Perform Arduino tests for C target with default scheduler - run: ./gradlew integration -Ptarget=Arduino + run: ./gradlew targetTest -Ptarget=Arduino - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index e498ebe6ad..2ab896ebf3 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -62,7 +62,7 @@ jobs: ./gradlew integration -Ptarget=C -Dscheduler=${{ inputs.scheduler }} if: ${{ !inputs.use-cpp && inputs.scheduler }} - name: Perform tests for CCpp target with default scheduler - run: ./gradlew integration -Ptarget=CCpp + run: ./gradlew targetTest -Ptarget=CCpp if: ${{ inputs.use-cpp && !inputs.scheduler }} - name: Collect code coverage run: ./gradlew jacocoTestReport diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index 39b225b3ed..a8854dfa25 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -41,7 +41,7 @@ jobs: if: ${{ inputs.runtime-ref }} - name: Perform Zephyr tests for C target with default scheduler run: | - ./gradlew integration -Ptarget=CZephyr + ./gradlew targetTest -Ptarget=CZephyr util/RunZephyrTests.sh test/C/src-gen - name: Collect code coverage run: ./gradlew jacocoTestReport diff --git a/.github/workflows/cpp-ros2-tests.yml b/.github/workflows/cpp-ros2-tests.yml index 7c23700794..da5d98523d 100644 --- a/.github/workflows/cpp-ros2-tests.yml +++ b/.github/workflows/cpp-ros2-tests.yml @@ -35,7 +35,7 @@ jobs: - name: Run C++ tests; run: | source /opt/ros/*/setup.bash - ./gradlew integration -Ptarget=CppRos2 + ./gradlew targetTest -Ptarget=CppRos2 - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index 35b972e6c2..b4ad00e7f6 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -48,7 +48,7 @@ jobs: if: ${{ inputs.runtime-ref }} - name: Run C++ tests; run: | - ./gradlew integration -Ptarget=Cpp + ./gradlew targetTest -Ptarget=Cpp - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index d3ae1123a5..54d430fd9d 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -69,7 +69,7 @@ jobs: with: python-version: '3.10' - name: Run language server Python tests without PyLint - run: ./gradlew org.lflang:core:test --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly + run: ./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly - name: Install pylint run: python3 -m pip install pylint if: ${{ runner.os != 'macOS' }} @@ -77,7 +77,7 @@ jobs: run: brew install pylint if: ${{ runner.os == 'macOS' }} - name: Run language server tests - run: ./gradlew org.lflang:core:test --tests org.lflang.tests.lsp.LspTests.*ValidationTest + run: ./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.lsp.LspTests.*ValidationTest - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index 436885243a..55a527d57c 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -60,7 +60,7 @@ jobs: ref: ${{ inputs.reactor-c-py-ref }} if: ${{ inputs.reactor-c-py-ref }} - name: Run Python tests - run: ./gradlew integration -Ptarget=Python + run: ./gradlew targetTest -Ptarget=Python - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index c84b5266aa..b444ceaa4e 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -64,7 +64,7 @@ jobs: rust-version: ${{ matrix.rust }} components: clippy - name: Run Rust tests - run: ./gradlew integration -Ptarget=Rust + run: ./gradlew targetTest -Ptarget=Rust - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 24441ff7d6..b6403c6b19 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -31,7 +31,7 @@ jobs: - name: Run serialization tests; run: | source /opt/ros/*/setup.bash - ./gradlew org.lflang:core:test --test org.lflang.test.serialization.SerializationTest.* + ./gradlew org.lflang:core:integrationTest --test org.lflang.test.serialization.SerializationTest.* - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 4b8bd1905f..9253898eeb 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -33,7 +33,7 @@ jobs: if: ${{ runner.os == 'macOS' }} - name: Perform TypeScript tests run: | - ./gradlew integration -Ptarget=TypeScript -Druntime="git://github.com/lf-lang/reactor-ts.git#minor-reorg" + ./gradlew targetTest -Ptarget=TypeScript -Druntime="git://github.com/lf-lang/reactor-ts.git#minor-reorg" - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov From 669a37ee72851d55e64bc1eaad46afe3e9990038 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 15:38:06 +0200 Subject: [PATCH 584/709] update README --- test/C/README.md | 5 ----- test/Cpp/README.md | 2 -- test/Python/README.md | 2 -- test/README.md | 35 +++++++++++++++-------------------- test/TypeScript/README.md | 24 ------------------------ 5 files changed, 15 insertions(+), 53 deletions(-) delete mode 100644 test/C/README.md delete mode 100644 test/Cpp/README.md delete mode 100644 test/Python/README.md delete mode 100644 test/TypeScript/README.md diff --git a/test/C/README.md b/test/C/README.md deleted file mode 100644 index 68d6d4a1b7..0000000000 --- a/test/C/README.md +++ /dev/null @@ -1,5 +0,0 @@ -# Library of C tests -To run the entire C test suite, in the lingua-franca directory, execute: -``` - ./gradlew test --tests "org.lflang.tests.runtime.CTest.*" -``` diff --git a/test/Cpp/README.md b/test/Cpp/README.md deleted file mode 100644 index 6a890d9ec2..0000000000 --- a/test/Cpp/README.md +++ /dev/null @@ -1,2 +0,0 @@ -# Library of C++ tests -To run the entire test suite, execute `./gradlew test --tests org.lflang.tests.runtime.CppTest.*`. diff --git a/test/Python/README.md b/test/Python/README.md deleted file mode 100644 index ceff2c3094..0000000000 --- a/test/Python/README.md +++ /dev/null @@ -1,2 +0,0 @@ -# Library of Python tests -To run the entire test suite, execute `./gradlew test --tests org.lflang.tests.runtime.PythonTest.*`. diff --git a/test/README.md b/test/README.md index d321d8dd7f..ec3ba683fd 100644 --- a/test/README.md +++ b/test/README.md @@ -1,29 +1,20 @@ -# LF system tests +# LF integration tests -**System tests** are complete Lingua Franca programs that are compiled and executed automatically. A test passes if it successfully compiles and runs to completion with normal termination (return code 0). These tests are located in a subdirectory corresponding to their target language. +**Integration tests** are complete Lingua France programs that are compiled and executed automatically. A test passes if it successfully compiles and runs to completion with normal termination (return code 0). These tests are located in a subdirectory corresponding to their target language. ### Running from the command line -The simplest way to run the regression tests is to use a Bash script called `run-lf-tests` in `$LF/bin`, which takes the target language as a parameter: +The simplest way to run integration tests for a specific target is the `targetTest` gradle task. For instance, you can use the following command to run all Rust tests: ``` -run-lf-tests C -run-lf-tests Cpp -run-lf-tests Python -run-lf-tests TypeScript +./gradlew targetTest -Ptarget=Rust ``` +You can specify any valid target. If you run the task without specifying the target property `./gradlew tagetTest` it will produce an error message and list all available targets. -You can also selectively run just some of the tests. For example, to run the system tests for an individual target language, do this: +The `targetTest` task is essentially a convenient shortcut for the following: ``` -./gradlew test --tests org.lflang.tests.runtime.CTest.* -./gradlew test --tests org.lflang.tests.runtime.CppTest.* -./gradlew test --tests org.lflang.tests.runtime.PythonTest.* -./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -``` - -To run a single test case, use the `runSingleTest` gradle task along with the path to the test source file: -``` -./gradlew runSingleTest --args test/C/src/Minimal.lf +./gradew org.lflang:core:integrationTest --test org.lflang.tests.runtime.Test.* ``` +If you prefer have more control over which tests are executed, you can also use this more verbose version. It is also possible to run a subset of the tests. For example, the C tests are organized into the following categories: @@ -32,10 +23,14 @@ It is also possible to run a subset of the tests. For example, the C tests are o * **federated** tests are `.lf` files located in `$LF/test/C/src/federated`. * **multiport** tests are `.lf` files located in `$LF/test/C/src/multiport`. -To invoke only the tests in the `concurrent` category, for example, do this: +To invoke only the C tests in the `concurrent` category, for example, do this: ``` -cd $LF -./gradlew test --tests org.lflang.tests.runtime.CTest.runConcurrentTests +./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.runtime.CTest.runConcurrentTests +``` + +To run a single test case, use the `runSingleTest` gradle task along with the path to the test source file: +``` +./gradlew runSingleTest --args test/C/src/Minimal.lf ``` ### LSP tests diff --git a/test/TypeScript/README.md b/test/TypeScript/README.md deleted file mode 100644 index bc01867fbe..0000000000 --- a/test/TypeScript/README.md +++ /dev/null @@ -1,24 +0,0 @@ -# Library of TypeScript tests -To run the entire test suite, execute `./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.*`. - -## Using an alternative runtime -To run the tests with an alternative runtime, use the `-Druntime` flag to specify where to find it. - -### Examples -- To use a local checkout of `reactor-ts` located in the local file system in the directory `~/lf-lang/reactor-ts`: -``` -./gradlew test --tests org.lflang.tests.runtime.TypeScriptTest.* -Druntime="~/lf-lang/reactor-ts" -``` -- To point to a branch of a remote repository, use: -``` --Druntime="git://github.com/lf-lang/reactor-ts.git#branch-name -``` - -- Note that `lfc` can be pointed to an alternative runtime as well, using the `external-runtime-path` switch: -``` -lfc test/TypeScript/src/Minimal.lf --external-runtime-path ~/lf-lang/reactor-ts -``` -- To point `lfc` to a particular ref (e.g. `main`, `v0.1.0` or `f8c6d2379f278e22ad48410bf06cf0909405ecc3`) in the `lf-lang/reactor-ts` repo: -``` -lfc test/TypeScript/src/Minimal.lf --runtime-version -``` From d347c5869bfde35bb5cf6e40b2c00066478535ef Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 15:39:21 +0200 Subject: [PATCH 585/709] fix ci configs --- .github/workflows/c-tests.yml | 4 ++-- .github/workflows/serialization-tests.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 2ab896ebf3..f072385183 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -54,12 +54,12 @@ jobs: uses: ./.github/actions/install-rti if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform tests for C target with default scheduler - run: ./gradlew integration -Ptarget=C + run: ./gradlew targetTest -Ptarget=C if: ${{ !inputs.use-cpp && !inputs.scheduler }} - name: Perform tests for C target with specified scheduler (no LSP tests) run: | echo "Specified scheduler: ${{ inputs.scheduler }}" - ./gradlew integration -Ptarget=C -Dscheduler=${{ inputs.scheduler }} + ./gradlew targetTest -Ptarget=C -Dscheduler=${{ inputs.scheduler }} if: ${{ !inputs.use-cpp && inputs.scheduler }} - name: Perform tests for CCpp target with default scheduler run: ./gradlew targetTest -Ptarget=CCpp diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index b6403c6b19..0f79c49e74 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -31,7 +31,7 @@ jobs: - name: Run serialization tests; run: | source /opt/ros/*/setup.bash - ./gradlew org.lflang:core:integrationTest --test org.lflang.test.serialization.SerializationTest.* + ./gradlew org.lflang:core:integrationTest --tests org.lflang.test.serialization.SerializationTest.* - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov From eec9cd87278782dfdc9ddc70d6d07416a688503c Mon Sep 17 00:00:00 2001 From: erlingrj Date: Tue, 30 May 2023 16:04:22 +0200 Subject: [PATCH 586/709] Remove mistaken commit --- .west/config | 4 ---- 1 file changed, 4 deletions(-) delete mode 100644 .west/config diff --git a/.west/config b/.west/config deleted file mode 100644 index ccd607713e..0000000000 --- a/.west/config +++ /dev/null @@ -1,4 +0,0 @@ -[manifest] -path = /home/erling/dev/lf-west-template/deps/zephyr -file = west.yml - From 3e0f2ee23e583177c691060fc0aa9b86cf3176ef Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 16:13:24 +0200 Subject: [PATCH 587/709] add singleTest task --- build.gradle | 6 ++ .../groovy/org.lflang.test-conventions.gradle | 10 +++ org.lflang.tests/about.html | 80 ------------------- .../java/org/lflang/tests/RunSingleTest.java | 21 ++--- test/README.md | 4 +- 5 files changed, 30 insertions(+), 91 deletions(-) delete mode 100644 org.lflang.tests/about.html rename org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java => org.lflang/core/src/integrationTest/java/org/lflang/tests/RunSingleTest.java (87%) diff --git a/build.gradle b/build.gradle index 7130f505d1..88a262e1db 100644 --- a/build.gradle +++ b/build.gradle @@ -66,3 +66,9 @@ tasks.register('targetTest') { } finalizedBy('org.lflang:core:integrationTest') } +tasks.register('singleTest') { + if (!project.hasProperty('singleTest')) { + throw new GradleException('Please set the \'singleTest\' project property using -PsingleTest=<...> to specify the LF test file that you would like to run.') + } + finalizedBy('org.lflang:core:integrationTest') +} diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 00025fb5f1..021cb163a4 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -49,11 +49,21 @@ test { exceptionFormat "full" } integrationTest { + // Pass properties on to the Java VM + systemProperty 'scheduler', System.getProperty('scheduler') + systemProperty 'runtime', System.getProperty('runtime') + if (rootProject.hasProperty('singleTest')) { + systemProperty 'singleTest', rootProject.getProperty('singleTest') + } if (project.hasProperty('target')) { filter { includeTestsMatching "org.lflang.tests.runtime.${project.property('target')}Test.*" } + } else if (project.hasProperty('singleTest')) { + filter { + includeTestsMatching "org.lflang.tests.RunSingleTest.runSingleTest" + } } testLogging { diff --git a/org.lflang.tests/about.html b/org.lflang.tests/about.html deleted file mode 100644 index 2b772cc110..0000000000 --- a/org.lflang.tests/about.html +++ /dev/null @@ -1,80 +0,0 @@ - - - - - About - - -

    About This Content

    - -

    October 18, 2019

    -

    License

    - -

    - Lingua Franca is a polyglot coordination language for defining and composing reactors. -

    - -

    - For more information about Lingua-Franca, see https://github.com/icyphy/lingua-franca -

    - -

    - The Lingua-Franca toolkit is licensed under the BSD 2-Clause License: -

    - -

    - Copyright (c) 2019, Industrial Cyberphysical Systems (iCyPhy). 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. -
    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. -
    - -

    - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT HOLDER OR CONTRIBUTORS 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. -

    - -

    - SPDX-License-Identifier: BSD-2-Clause -

    - - - diff --git a/org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java b/org.lflang/core/src/integrationTest/java/org/lflang/tests/RunSingleTest.java similarity index 87% rename from org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java rename to org.lflang/core/src/integrationTest/java/org/lflang/tests/RunSingleTest.java index fdb26de7f5..3746369c89 100644 --- a/org.lflang.tests/src/org/lflang/tests/RunSingleTestMain.java +++ b/org.lflang/core/src/integrationTest/java/org/lflang/tests/RunSingleTest.java @@ -24,11 +24,14 @@ package org.lflang.tests; +import static org.junit.jupiter.api.Assumptions.assumeTrue; + import java.io.FileNotFoundException; import java.nio.file.Files; import java.nio.file.Paths; import java.util.regex.Matcher; import java.util.regex.Pattern; +import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.runtime.CCppTest; import org.lflang.tests.runtime.CTest; @@ -38,26 +41,26 @@ import org.lflang.tests.runtime.TypeScriptTest; /** - * Execute a single test case. Use it with the gradle task {@code gradle runSingleTest --args - * test/Python/src/Minimal.lf} + * Execute a single test case. Use it with the gradle task {@code ./gradlew singleTest -PsingleTest + * test/C/src/Minimal.lf} * * @author Clément Fournier */ -public class RunSingleTestMain { +public class RunSingleTest { private static final Pattern TEST_FILE_PATTERN = Pattern.compile("(test/(\\w+))/src/([^/]++/)*(\\w+.lf)"); - public static void main(String[] args) throws FileNotFoundException { - if (args.length != 1) { - throw new IllegalArgumentException("Expected 1 path to an LF file"); - } - var path = Paths.get(args[0]); + @Test + public void runSingleTest() throws FileNotFoundException { + assumeTrue(System.getProperty("singleTest") != null); + + var path = Paths.get(System.getProperty("singleTest")); if (!Files.exists(path)) { throw new FileNotFoundException("No such test file: " + path); } - Matcher matcher = TEST_FILE_PATTERN.matcher(args[0]); + Matcher matcher = TEST_FILE_PATTERN.matcher(path.toString()); if (!matcher.matches()) { throw new FileNotFoundException("Not a test: " + path); } diff --git a/test/README.md b/test/README.md index ec3ba683fd..ecfdf8e876 100644 --- a/test/README.md +++ b/test/README.md @@ -28,9 +28,9 @@ To invoke only the C tests in the `concurrent` category, for example, do this: ./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.runtime.CTest.runConcurrentTests ``` -To run a single test case, use the `runSingleTest` gradle task along with the path to the test source file: +To run a single test case, use the `singleTest` gradle task along with the path to the test source file: ``` -./gradlew runSingleTest --args test/C/src/Minimal.lf +./gradlew singleTest -PsingleTest test/C/src/Minimal.lf ``` ### LSP tests From 979883d8c365e559d084e6e840969ba2fbb22c69 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 16:16:16 +0200 Subject: [PATCH 588/709] fix ci configs --- .github/workflows/c-arduino-tests.yml | 2 +- .github/workflows/serialization-tests.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 0495a4e2e4..18d1a2962a 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -63,7 +63,7 @@ jobs: arduino-cli core install arduino:sam arduino-cli core install arduino:mbed - name: Perform Arduino tests for C target with default scheduler - run: ./gradlew targetTest -Ptarget=Arduino + run: ./gradlew targetTest -Ptarget=CArduino - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 0f79c49e74..59aea0bb31 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -31,7 +31,7 @@ jobs: - name: Run serialization tests; run: | source /opt/ros/*/setup.bash - ./gradlew org.lflang:core:integrationTest --tests org.lflang.test.serialization.SerializationTest.* + ./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.serialization.SerializationTest.* - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov From 465f0bd8d5069d0fb5c4e088dc76919e4de56f61 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 17:59:17 +0200 Subject: [PATCH 589/709] fix test coverage reporting (hopefully) --- buildSrc/src/main/groovy/org.lflang.test-conventions.gradle | 2 ++ 1 file changed, 2 insertions(+) diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 021cb163a4..2a1ec27275 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -82,6 +82,8 @@ test { } jacocoTestReport { + getExecutionData().setFrom(fileTree(buildDir).include("/jacoco/*.exec")) + reports { xml.required = true csv.required = false From 414a45ba74e4fb4d05e65412bd060386d346ad49 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 18:50:10 +0200 Subject: [PATCH 590/709] fix single test again --- build.gradle | 4 ++-- .../src/main/groovy/org.lflang.test-conventions.gradle | 7 +++---- test/README.md | 2 +- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/build.gradle b/build.gradle index 88a262e1db..e4039064f0 100644 --- a/build.gradle +++ b/build.gradle @@ -67,8 +67,8 @@ tasks.register('targetTest') { finalizedBy('org.lflang:core:integrationTest') } tasks.register('singleTest') { - if (!project.hasProperty('singleTest')) { - throw new GradleException('Please set the \'singleTest\' project property using -PsingleTest=<...> to specify the LF test file that you would like to run.') + if (System.getProperty('singleTest') == null) { + throw new GradleException('Please set the \'singleTest\' system property using -DsingleTest=<...> to specify the LF test file that you would like to run.') } finalizedBy('org.lflang:core:integrationTest') } diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 2a1ec27275..40950e1832 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -52,15 +52,14 @@ test { // Pass properties on to the Java VM systemProperty 'scheduler', System.getProperty('scheduler') systemProperty 'runtime', System.getProperty('runtime') - if (rootProject.hasProperty('singleTest')) { - systemProperty 'singleTest', rootProject.getProperty('singleTest') - } + systemProperty 'singleTest', System.getProperty('singleTest') if (project.hasProperty('target')) { filter { includeTestsMatching "org.lflang.tests.runtime.${project.property('target')}Test.*" } - } else if (project.hasProperty('singleTest')) { + } + if (System.getProperty('singleTest') != null) { filter { includeTestsMatching "org.lflang.tests.RunSingleTest.runSingleTest" } diff --git a/test/README.md b/test/README.md index ecfdf8e876..e06450984d 100644 --- a/test/README.md +++ b/test/README.md @@ -30,7 +30,7 @@ To invoke only the C tests in the `concurrent` category, for example, do this: To run a single test case, use the `singleTest` gradle task along with the path to the test source file: ``` -./gradlew singleTest -PsingleTest test/C/src/Minimal.lf +./gradlew singleTest -DsingleTest test/C/src/Minimal.lf ``` ### LSP tests From 849e7b5a5a2ac04c65aa8568567bc514f212bf94 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 30 May 2023 11:52:58 -0700 Subject: [PATCH 591/709] Pass LOGGING debug option to federates. --- org.lflang/src/org/lflang/TargetConfig.java | 1 + 1 file changed, 1 insertion(+) diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index c4794b4b1a..3535ae01a6 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -97,6 +97,7 @@ public TargetConfig(Properties cliArgs, TargetDecl target, ErrorReporter errorRe } if (cliArgs.containsKey("logging")) { this.logLevel = LogLevel.valueOf(cliArgs.getProperty("logging").toUpperCase()); + this.setByUser.add(TargetProperty.LOGGING); } if (cliArgs.containsKey("workers")) { this.workers = Integer.parseInt(cliArgs.getProperty("workers")); From bc564e25e8a8ea6b0d470a5de6df95e34e06ba5e Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 30 May 2023 11:58:37 -0700 Subject: [PATCH 592/709] Add setByUser for other cliArgs. --- org.lflang/src/org/lflang/TargetConfig.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/org.lflang/src/org/lflang/TargetConfig.java b/org.lflang/src/org/lflang/TargetConfig.java index 3535ae01a6..67175777b6 100644 --- a/org.lflang/src/org/lflang/TargetConfig.java +++ b/org.lflang/src/org/lflang/TargetConfig.java @@ -94,6 +94,7 @@ public TargetConfig(Properties cliArgs, TargetDecl target, ErrorReporter errorRe if (cliArgs.containsKey("build-type")) { this.cmakeBuildType = (BuildType) UnionType.BUILD_TYPE_UNION.forName(cliArgs.getProperty("build-type")); + this.setByUser.add(TargetProperty.BUILD_TYPE); } if (cliArgs.containsKey("logging")) { this.logLevel = LogLevel.valueOf(cliArgs.getProperty("logging").toUpperCase()); @@ -101,15 +102,19 @@ public TargetConfig(Properties cliArgs, TargetDecl target, ErrorReporter errorRe } if (cliArgs.containsKey("workers")) { this.workers = Integer.parseInt(cliArgs.getProperty("workers")); + this.setByUser.add(TargetProperty.WORKERS); } if (cliArgs.containsKey("threading")) { this.threading = Boolean.parseBoolean(cliArgs.getProperty("threading")); + this.setByUser.add(TargetProperty.THREADING); } if (cliArgs.containsKey("target-compiler")) { this.compiler = cliArgs.getProperty("target-compiler"); + this.setByUser.add(TargetProperty.COMPILER); } if (cliArgs.containsKey("tracing")) { this.tracing = new TracingOptions(); + this.setByUser.add(TargetProperty.TRACING); } if (cliArgs.containsKey("scheduler")) { this.schedulerType = SchedulerOption.valueOf(cliArgs.getProperty("scheduler")); @@ -120,19 +125,24 @@ public TargetConfig(Properties cliArgs, TargetDecl target, ErrorReporter errorRe if (!cliArgs.getProperty("target-flags").isEmpty()) { this.compilerFlags.addAll(List.of(cliArgs.getProperty("target-flags").split(" "))); } + this.setByUser.add(TargetProperty.FLAGS); } if (cliArgs.containsKey("runtime-version")) { this.runtimeVersion = cliArgs.getProperty("runtime-version"); + this.setByUser.add(TargetProperty.RUNTIME_VERSION); } if (cliArgs.containsKey("external-runtime-path")) { this.externalRuntimePath = cliArgs.getProperty("external-runtime-path"); + this.setByUser.add(TargetProperty.EXTERNAL_RUNTIME_PATH); } if (cliArgs.containsKey(TargetProperty.KEEPALIVE.description)) { this.keepalive = Boolean.parseBoolean(cliArgs.getProperty(TargetProperty.KEEPALIVE.description)); + this.setByUser.add(TargetProperty.KEEPALIVE); } if (cliArgs.containsKey(BuildParm.PRINT_STATISTICS.getKey())) { this.printStatistics = true; + this.setByUser.add(TargetProperty.PRINT_STATISTICS); } } From 9ca44108e5377b8281b23e14d8bf1719077f8824 Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Wed, 31 May 2023 10:45:17 +0900 Subject: [PATCH 593/709] Compare elapsed logical tag --- test/Python/src/federated/DistributedStop.lf | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/Python/src/federated/DistributedStop.lf b/test/Python/src/federated/DistributedStop.lf index 174ff53858..3aacf893dc 100644 --- a/test/Python/src/federated/DistributedStop.lf +++ b/test/Python/src/federated/DistributedStop.lf @@ -18,15 +18,15 @@ reactor Sender { tag = lf.tag() print("Sending 42 at ({}, {}).".format( lf.time.logical_elapsed(), - lf.tag().microstep)) + tag.microstep)) out.set(42) - if lf.tag().microstep == 0: + if tag.microstep == 0: # Instead of having a separate reaction # for 'act' like Stop.lf, we trigger the # same reaction to test request_stop() being # called multiple times act.schedule(0) - if tag.time == USEC(1): + if lf.time.logical_elapsed() == USEC(1): # Call request_stop() both at (1 usec, 0) and # (1 usec, 1) print("Requesting stop at ({}, {}).".format( From 82c55ceb2f108fbad138cd4b6c6aae9625b5dbc5 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 31 May 2023 11:14:50 +0200 Subject: [PATCH 594/709] switch back to https protocol for fetching kieler --- org.lflang.tests/build.gradle | 3 +-- org.lflang/build.gradle | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/org.lflang.tests/build.gradle b/org.lflang.tests/build.gradle index e1311fc5b3..97f664c1a8 100644 --- a/org.lflang.tests/build.gradle +++ b/org.lflang.tests/build.gradle @@ -2,8 +2,7 @@ repositories { mavenCentral() // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. maven { - url "http://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - allowInsecureProtocol = true + url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" } } dependencies { diff --git a/org.lflang/build.gradle b/org.lflang/build.gradle index 96b16f8771..8d4f6a41c9 100644 --- a/org.lflang/build.gradle +++ b/org.lflang/build.gradle @@ -4,8 +4,7 @@ repositories { mavenCentral() // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. maven { - url "http://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - allowInsecureProtocol = true + url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" } } dependencies { From 0225bfd5fc3d3959a7c22e174569605cb137b7b3 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Tue, 30 May 2023 19:17:08 +0200 Subject: [PATCH 595/709] make the lsp a subproject --- org.lflang/lsp/build.gradle | 16 ++++++++++++++++ .../org/lflang/diagram/lsp/LFLanguageServer.java | 0 .../diagram/lsp/LFLanguageServerExtension.java | 0 .../diagram/lsp/LanguageDiagramServer.java | 0 .../java/org/lflang/diagram/lsp/Progress.java | 0 settings.gradle | 2 +- 6 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 org.lflang/lsp/build.gradle rename org.lflang/{core => lsp}/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java (100%) rename org.lflang/{core => lsp}/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java (100%) rename org.lflang/{core => lsp}/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java (100%) rename org.lflang/{core => lsp}/src/main/java/org/lflang/diagram/lsp/Progress.java (100%) diff --git a/org.lflang/lsp/build.gradle b/org.lflang/lsp/build.gradle new file mode 100644 index 0000000000..4ba85dbff1 --- /dev/null +++ b/org.lflang/lsp/build.gradle @@ -0,0 +1,16 @@ +plugins { + id 'org.lflang.java-application-conventions' +} + +dependencies { + implementation project(':org.lflang:core') + + implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:$klighdVersion") { + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' + exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt' + } +} + +application { + mainClass = 'org.lflang.diagram.lsp.LanguageDiagramServer' +} diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java b/org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java rename to org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java b/org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java rename to org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java b/org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java rename to org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/lsp/Progress.java b/org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/Progress.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/lsp/Progress.java rename to org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/Progress.java diff --git a/settings.gradle b/settings.gradle index 28c7dbf725..5c1d32d3eb 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,2 +1,2 @@ rootProject.name = 'org.lflang' -include(':org.lflang:core', ':org.lflang:cli:base', ':org.lflang:cli:lfc', ':org.lflang:cli:lff') +include(':org.lflang:core', ':org.lflang:lsp', ':org.lflang:cli:base', ':org.lflang:cli:lfc', ':org.lflang:cli:lff') From 7b28b8d9444398de56ebbe9ec346533f7862c0dd Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 31 May 2023 16:24:47 +0200 Subject: [PATCH 596/709] don't test cli scripts in build --- .github/workflows/build.yml | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 669b27e674..bf8932fcc0 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -31,24 +31,6 @@ jobs: run: ./gradlew build shell: bash if: ${{ inputs.nightly != true }} - - name: Test lfc bash scripts (Linux or macOS only) - run: | - .github/scripts/test-lfc.sh - if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - - name: Test lff bash scripts (Linux or macOS only) - run: | - .github/scripts/test-lff.sh - if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - - name: Test PowerShell lfc script (Windows only) - run: | - ./gradlew buildAll - bin/lfc.ps1 --help - if: ${{ runner.os == 'Windows' }} - - name: Test PowerShell lff script (Windows only) - run: | - ./gradlew buildAll - bin/lfc.ps1 --help - if: ${{ runner.os == 'Windows' }} - name: Deploy nightly release uses: marvinpinto/action-automatic-releases@latest with: From 22f0d8a5e079f282cce09d6772355a67971522c1 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Wed, 31 May 2023 19:21:51 +0200 Subject: [PATCH 597/709] Remove mistakenly checked in binary file --- test/C/lib/libapp.a | Bin 74484 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 test/C/lib/libapp.a diff --git a/test/C/lib/libapp.a b/test/C/lib/libapp.a deleted file mode 100644 index d710e87c0ec4ba481729cee7abcf33a864b98114..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 74484 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 Date: Thu, 11 May 2023 16:04:28 -0700 Subject: [PATCH 598/709] Update the federate trace visualizer README file. --- util/tracing/visualization/README.md | 38 +++++++++++++++++----------- 1 file changed, 23 insertions(+), 15 deletions(-) diff --git a/util/tracing/visualization/README.md b/util/tracing/visualization/README.md index 82861e9b2a..9259ec6572 100644 --- a/util/tracing/visualization/README.md +++ b/util/tracing/visualization/README.md @@ -1,25 +1,33 @@ -# Trace sequence diagram visualiser +# Trace sequence diagram visualizer -This is a 1st iteration of a prototyping tool for constructing a sequence diagram -out of the traces. -It operates over the csv files generated by `trace_to_csv`. +`fedsd` is a utility tool that reports the interactions (exchanged messages) +between federates and the RTI in a sequence-diagram-like format. +To enable `fedsd`, `tracing` target property should be set to `true`. + +# Installing + +`fedsd` is installed by calling `make install` under `lingua_franca/util/tracing`. +This utility starts by transforming each `.lft` file into a `.csv` file, by +internally running `trace_to_csv`. It then aggregates the data from all `.csv` +files to do the matching and draw the sequence diagram. # Running -Once the `.lft` files collected and tranformed into `csv` files, run: +In case the federation is launched using the `bash` script under `bin`, an `.lft` trace +file will be generated for each of the federates, in addition to `rti.lft`. This latter +contains the RTI trace. +If, however, the federation is launched manually, then running the `RTI` should +enable tracing, by adding the option `-t`: ``` -$ python3 sd_gen.py -r -f ... +$ RTI -n -t ``` -The output is an html file with the svg in it. - -# Current problems - -- The collected traces are not complete. They need to be checked for correcteness as well. -- All arrows are horizontal and can be duplicated. Need further processing to derive the connections -for that. -- The scale needs exploration - +Once the federation stopped executiong, run `fedsd` on all generated `.lft` files: +``` +$ fedsd *.lft +``` +The output is an html file named `trace_svg.html` that contains the sequence of interactions +between the federates and the RTI. From 0570fcdb4fb3037ea821e31bdb7d0a1fd166e0a0 Mon Sep 17 00:00:00 2001 From: ChadliaJerad Date: Tue, 23 May 2023 16:53:07 -0700 Subject: [PATCH 599/709] Address two remaining reviews. --- util/tracing/visualization/README.md | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/util/tracing/visualization/README.md b/util/tracing/visualization/README.md index 9259ec6572..f339d81da7 100644 --- a/util/tracing/visualization/README.md +++ b/util/tracing/visualization/README.md @@ -4,12 +4,13 @@ between federates and the RTI in a sequence-diagram-like format. To enable `fedsd`, `tracing` target property should be set to `true`. -# Installing - -`fedsd` is installed by calling `make install` under `lingua_franca/util/tracing`. This utility starts by transforming each `.lft` file into a `.csv` file, by internally running `trace_to_csv`. It then aggregates the data from all `.csv` files to do the matching and draw the sequence diagram. +# Installing + +`fedsd` is installed by calling `make install` under `lingua_franca/util/tracing`. + # Running @@ -22,12 +23,15 @@ enable tracing, by adding the option `-t`: $ RTI -n -t ``` -Once the federation stopped executiong, run `fedsd` on all generated `.lft` files: +For convenience, the RTI and all federates should be launched from the same directory. + + +Once the federation stopped executing, run `fedsd` on all generated `.lft` files: ``` $ fedsd *.lft ``` -The output is an html file named `trace_svg.html` that contains the sequence of interactions +The output is an html file named `trace_svg.html` (in the current directory) that contains the sequence of interactions between the federates and the RTI. From 853ecacbcc2dca5771bd614f6438a354d582d640 Mon Sep 17 00:00:00 2001 From: ChadliaJerad Date: Wed, 31 May 2023 12:21:32 -0700 Subject: [PATCH 600/709] Manually add the commit suggestion by Marten. Couldn't be done from github because outdated. --- util/tracing/visualization/README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/util/tracing/visualization/README.md b/util/tracing/visualization/README.md index f339d81da7..3da43d639b 100644 --- a/util/tracing/visualization/README.md +++ b/util/tracing/visualization/README.md @@ -23,7 +23,7 @@ enable tracing, by adding the option `-t`: $ RTI -n -t ``` -For convenience, the RTI and all federates should be launched from the same directory. +It is most convenient to launch the RTI and all federates from the same working directory so that they will all write their trace file to that directory. Once the federation stopped executing, run `fedsd` on all generated `.lft` files: @@ -34,4 +34,3 @@ $ fedsd *.lft The output is an html file named `trace_svg.html` (in the current directory) that contains the sequence of interactions between the federates and the RTI. - From 84494677a1dd32cf43934aa9c6b7d5883979efd9 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 12:58:40 -0700 Subject: [PATCH 601/709] Update paths used to check which CI tests to run. --- .github/workflows/check-diff.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index af5f241cab..29a2bd81b4 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -36,10 +36,10 @@ jobs: - id: do run: | wget https://raw.githubusercontent.com/lf-lang/lingua-franca/master/.github/scripts/check-diff.sh - source check-diff.sh "org.lflang.generator.c/\|org.lflang/src/lib/c/\|org.lflang/src/lib/platform/\|test/C" C - source check-diff.sh "org.lflang/src/org/lflang/generator/cpp/\|org.lflang/src/lib/cpp/\|test/Cpp" CPP - source check-diff.sh "org.lflang/src/org/lflang/generator/python/\|org.lflang/src/lib/py/\|test/Python" PY - source check-diff.sh "org.lflang/src/org/lflang/generator/rust/\|org.lflang/src/lib/rs/\|test/Rust" RS - source check-diff.sh "org.lflang/src/org/lflang/generator/ts/\|org.lflang/src/lib/ts/\|test/TypeScript" TS + source check-diff.sh "org.lflang/core/src/main/java/org/lflang/generator/c\|/home/peter/lingua-franca/org.lflang/core/src/main/resources/lib/c\|org.lflang/core/src/main/resources/lib/platform\|test/C" C + source check-diff.sh "org.lflang/core/src/main/kotlin/org/lflang/generator/cpp\|org.lflang/core/src/main/resources/lib/cpp\|test/Cpp" CPP + source check-diff.sh "org.lflang/core/src/main/java/org/lflang/generator/python\|org.lflang/core/src/main/resources/lib/py\|test/Python" PY + source check-diff.sh "org.lflang/core/src/main/kotlin/org/lflang/generator/rust\|org.lflang/core/src/main/java/org/lflang/generator/rust\|org.lflang/core/src/main/resources/lib/rs\|test/Rust" RS + source check-diff.sh "org.lflang/core/src/main/kotlin/org/lflang/generator/ts\|org.lflang/core/src/main/java/org/lflang/generator/ts\|org.lflang/core/src/main/resources/lib/ts\|test/TypeScript" TS source check-diff.sh "util/tracing" TRACING shell: bash From f3943aff5054b9e12eacaf59e68ff785d9176287 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 25 May 2023 14:30:00 -0700 Subject: [PATCH 602/709] Add test case. --- test/C/src/generics/ParameterAsArgument.lf | 29 ++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 test/C/src/generics/ParameterAsArgument.lf diff --git a/test/C/src/generics/ParameterAsArgument.lf b/test/C/src/generics/ParameterAsArgument.lf new file mode 100644 index 0000000000..7560587723 --- /dev/null +++ b/test/C/src/generics/ParameterAsArgument.lf @@ -0,0 +1,29 @@ +target C; + +// Hash issue +// Header name mismatch +reactor bundle { +} + +reactor Child { + state k: T1 + input in:In; + output out:Out; + reaction(in) {= + int a = in->value; + printf("Got %d\n", a); + =} +} + +reactor Super { + input in:In; + output out:Out; + state t1:T1; + c = new Child(); + in -> c.in; + c.out -> out; +} + +main reactor { + cc = new Super(); +} From 8a942213a372b8d2a5a6e4fd818fd3f24b91437d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 12:48:02 -0700 Subject: [PATCH 603/709] Modify mechanism for resolving type parameters. --- org.lflang/src/org/lflang/ast/ASTUtils.java | 16 -------- .../org/lflang/generator/ReactorInstance.java | 2 +- .../org/lflang/generator/c/CGenerator.java | 40 ++----------------- .../generator/c/CReactionGenerator.java | 12 +++--- .../c/CReactorHeaderFileGenerator.java | 4 +- .../src/org/lflang/generator/c/CUtil.java | 16 +++++++- .../generator/c/TypeParameterizedReactor.java | 16 ++++++-- .../org/lflang/validation/LFValidator.java | 2 +- 8 files changed, 41 insertions(+), 67 deletions(-) diff --git a/org.lflang/src/org/lflang/ast/ASTUtils.java b/org.lflang/src/org/lflang/ast/ASTUtils.java index 91ff7ac69a..078505d958 100644 --- a/org.lflang/src/org/lflang/ast/ASTUtils.java +++ b/org.lflang/src/org/lflang/ast/ASTUtils.java @@ -63,8 +63,6 @@ import org.lflang.generator.CodeMap; import org.lflang.generator.InvalidSourceException; import org.lflang.generator.ReactorInstance; -import org.lflang.generator.c.CUtil; -import org.lflang.generator.c.TypeParameterizedReactor; import org.lflang.lf.Action; import org.lflang.lf.Assignment; import org.lflang.lf.Code; @@ -409,20 +407,6 @@ public static List allInstantiations(Reactor definition) { return ASTUtils.collectElements(definition, featurePackage.getReactor_Instantiations()); } - /** - * Given a reactor Class, return a set of include names for interacting reactors which includes - * all instantiations of base class that it extends. - * - * @param r Reactor Class - */ - public static HashSet allIncludes(Reactor r) { - var set = new HashSet(); - for (var i : allInstantiations(r)) { - set.add(CUtil.getName(new TypeParameterizedReactor(i))); - } - return set; - } - /* * Given a reactor class, return a stream of reactor classes that it instantiates. * @param definition Reactor class definition. diff --git a/org.lflang/src/org/lflang/generator/ReactorInstance.java b/org.lflang/src/org/lflang/generator/ReactorInstance.java index 3bb132ce01..9288744d65 100644 --- a/org.lflang/src/org/lflang/generator/ReactorInstance.java +++ b/org.lflang/src/org/lflang/generator/ReactorInstance.java @@ -795,7 +795,7 @@ public ReactorInstance( this.reporter = reporter; this.reactorDeclaration = definition.getReactorClass(); this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); - this.tpr = new TypeParameterizedReactor(definition); + this.tpr = new TypeParameterizedReactor(definition, parent == null ? null : parent.tpr); // check for recursive instantiation var currentParent = parent; diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index f3accf165a..b515538de1 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -850,46 +850,12 @@ protected void copyUserFiles(TargetConfig targetConfig, FileConfig fileConfig) { private void generateReactorDefinitions() throws IOException { var generatedReactors = new LinkedHashSet(); if (this.main != null) { - resolveTemplatedTypes(this.main, this.main.tpr); generateReactorChildren(this.main, generatedReactors); generateReactorClass(this.main.getTypeParameterizedReactor()); } // do not generate code for reactors that are not instantiated } - /** - * Recursively Resolve all Templated Types of child Reactors to their respective concrete types - * - * @param reactorInstance The Reactor Class - * @param parentTpr {@link TypeParameterizedReactor} of Parent - */ - private void resolveTemplatedTypes( - ReactorInstance reactorInstance, TypeParameterizedReactor parentTpr) { - for (var child : reactorInstance.children) { - if (parentTpr.typeArgs() != null) { - Map copy = new HashMap<>(); - child - .tpr - .typeArgs() - .forEach( - (literal, typename) -> { - var type = typename.getId(); - if (parentTpr.typeArgs().containsKey(type)) { - var basicType = parentTpr.typeArgs().get(type); - copy.put(literal, basicType); - } else { - // Typename is not inherited from Parent Reactor. Keep As Is! - copy.put(literal, typename); - } - }); - if (!copy.isEmpty()) { // If we found some templated-types update the tpr with new map - child.tpr = new TypeParameterizedReactor(child.tpr.reactor(), copy); - } - resolveTemplatedTypes(child, child.tpr); - } - } - } - private record TypeParameterizedReactorWithDecl(TypeParameterizedReactor tpr, ReactorDecl decl) {} /** Generate user-visible header files for all reactors instantiated. */ @@ -910,7 +876,7 @@ private void generateHeaders() throws IOException { .map( it -> new TypeParameterizedReactorWithDecl( - new TypeParameterizedReactor(it), it.getReactorClass())) + new TypeParameterizedReactor(it, rr), it.getReactorClass())) .collect(Collectors.toSet()) .forEach( it -> { @@ -1069,7 +1035,7 @@ protected void generateReactorClassHeaders( src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(tpr) + "\""); src.pr("#include \"" + headerName + "\""); tpr.doDefines(src); - ASTUtils.allIncludes(tpr.reactor()).stream() + CUtil.allIncludes(tpr).stream() .map(name -> "#include \"" + name + ".h\"") .forEach(header::pr); } @@ -1245,7 +1211,7 @@ private void generateInteractingContainedReactors( var contained = new InteractingContainedReactors(tpr.reactor()); // Next generate the relevant code. for (Instantiation containedReactor : contained.containedReactors()) { - var containedTpr = new TypeParameterizedReactor(containedReactor); + var containedTpr = new TypeParameterizedReactor(containedReactor, tpr); // First define an _width variable in case it is a bank. var array = ""; var width = -2; diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index 6fcef92dd6..e83e083191 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -202,7 +202,8 @@ public static String generateInitializationForReaction( reactionInitialization, fieldsForStructsForContainedReactors, effect.getContainer(), - (Input) variable); + (Input) variable, + tpr); } else if (variable instanceof Watchdog) { reactionInitialization.pr(generateWatchdogVariablesInReaction(effect)); } else { @@ -363,14 +364,15 @@ private static void generateVariablesForSendingToContainedReactors( CodeBuilder builder, Map structs, Instantiation definition, - Input input) { + Input input, + TypeParameterizedReactor container) { CodeBuilder structBuilder = structs.get(definition); if (structBuilder == null) { structBuilder = new CodeBuilder(); structs.put(definition, structBuilder); } String inputStructType = - CGenerator.variableStructType(input, new TypeParameterizedReactor(definition), false); + CGenerator.variableStructType(input, new TypeParameterizedReactor(definition, container), false); String defName = definition.getName(); String defWidth = generateWidthVariable(defName); String inputName = input.getName(); @@ -461,7 +463,7 @@ private static void generatePortVariablesInReaction( Output output = (Output) port.getVariable(); String portStructType = CGenerator.variableStructType( - output, new TypeParameterizedReactor(port.getContainer()), false); + output, new TypeParameterizedReactor(port.getContainer(), tpr), false); CodeBuilder structBuilder = structs.get(port.getContainer()); if (structBuilder == null) { @@ -773,7 +775,7 @@ public static String generateOutputVariablesInReaction( (effect.getContainer() == null) ? CGenerator.variableStructType(output, tpr, false) : CGenerator.variableStructType( - output, new TypeParameterizedReactor(effect.getContainer()), false); + output, new TypeParameterizedReactor(effect.getContainer(), tpr), false); if (!ASTUtils.isMultiport(output)) { // Output port is not a multiport. return outputStructType + "* " + outputName + " = &self->_lf_" + outputName + ";"; diff --git a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java index 4f6a29b405..b57a19d8a7 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactorHeaderFileGenerator.java @@ -150,7 +150,7 @@ public static String nonInlineInitialization(Reaction r, TypeParameterizedReacto reactor.reactor().getInstantiations().stream() .filter( instantiation -> - new TypeParameterizedReactor(instantiation) + new TypeParameterizedReactor(instantiation, reactor) .equals(it.r)) .findAny() .orElseThrow(), @@ -184,7 +184,7 @@ private static Stream portVariableStream( ? new PortVariable( tv, it.getContainer() != null - ? new TypeParameterizedReactor(it.getContainer()) + ? new TypeParameterizedReactor(it.getContainer(), reactorOfReaction) : reactorOfReaction, it.getContainer()) : null) diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 3a7f151a2c..875efd61a3 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -28,6 +28,7 @@ import java.nio.file.Path; import java.util.ArrayList; +import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Objects; @@ -36,6 +37,7 @@ import org.lflang.FileConfig; import org.lflang.InferredType; import org.lflang.TargetConfig; +import org.lflang.ast.ASTUtils; import org.lflang.generator.ActionInstance; import org.lflang.generator.GeneratorCommandFactory; import org.lflang.generator.LFGeneratorContext; @@ -554,7 +556,19 @@ public static String triggerRefNested(PortInstance port, String runtimeIndex, St + "_trigger"; } - ////////////////////////////////////////////////////// + /** + * Given a reactor Class, return a set of include names for interacting reactors which includes + * all instantiations of base class that it extends. + */ + public static HashSet allIncludes(TypeParameterizedReactor tpr) { + var set = new HashSet(); + for (var i : ASTUtils.allInstantiations(tpr.reactor())) { + set.add(getName(new TypeParameterizedReactor(i, tpr))); + } + return set; + } + + ////////////////////////////////////////////////////// //// FIXME: Not clear what the strategy is with the following inner interface. // The {@code ReportCommandErrors} interface allows the // method runBuildCommand to call a protected diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index c5e062399b..1b798e90ee 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -18,17 +18,25 @@ */ public record TypeParameterizedReactor(Reactor reactor, Map typeArgs) { - public TypeParameterizedReactor(Instantiation i) { + /** + * Construct the TPR corresponding to the given instantiation which syntactically appears within + * the definition corresponding to {@code parent}. + * @param i An instantiation of the TPR to be constructed. + * @param parent The reactor in which {@code i} appears, or {@code null} if type variables are + * permitted instead of types in this TPR. + */ + public TypeParameterizedReactor(Instantiation i, TypeParameterizedReactor parent) { this( ASTUtils.toDefinition(i.getReactorClass()), - addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()))); + addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()), parent)); } - private static Map addTypeArgs(Instantiation instantiation, Reactor r) { + private static Map addTypeArgs(Instantiation instantiation, Reactor r, TypeParameterizedReactor parent) { HashMap ret = new HashMap<>(); if (instantiation.getTypeArgs() != null) { for (int i = 0; i < r.getTypeParms().size(); i++) { - ret.put(r.getTypeParms().get(i).getLiteral(), instantiation.getTypeArgs().get(i)); + var arg = instantiation.getTypeArgs().get(i); + ret.put(r.getTypeParms().get(i).getLiteral(), parent == null ? arg : parent.resolveType(arg)); } } return ret; diff --git a/org.lflang/src/org/lflang/validation/LFValidator.java b/org.lflang/src/org/lflang/validation/LFValidator.java index 555d6d0da3..7dd7a78f7a 100644 --- a/org.lflang/src/org/lflang/validation/LFValidator.java +++ b/org.lflang/src/org/lflang/validation/LFValidator.java @@ -221,7 +221,7 @@ private Type portTypeIfResolvable(VarRef port) { var portType = ((Port) port.getVariable()).getType(); return port.getContainer() == null ? portType - : new TypeParameterizedReactor(port.getContainer()).resolveType(portType); + : new TypeParameterizedReactor(port.getContainer(), null).resolveType(portType); } @Check(CheckType.FAST) From d5dd302d1c84066efac506c97e6e83104be53077 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 13:49:26 -0700 Subject: [PATCH 604/709] Update test. --- test/C/src/generics/ParameterAsArgument.lf | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/C/src/generics/ParameterAsArgument.lf b/test/C/src/generics/ParameterAsArgument.lf index 7560587723..1f500150fb 100644 --- a/test/C/src/generics/ParameterAsArgument.lf +++ b/test/C/src/generics/ParameterAsArgument.lf @@ -25,5 +25,8 @@ reactor Super { } main reactor { + reaction(startup) -> cc.in {= + lf_set(cc.in, 42); + =} cc = new Super(); } From 7c6c6371326a46c78de05a3168b3b311a756a5e1 Mon Sep 17 00:00:00 2001 From: ChadliaJerad Date: Wed, 31 May 2023 14:08:48 -0700 Subject: [PATCH 605/709] Manually redo the lost commits because of the force push. --- util/tracing/visualization/README.md | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/util/tracing/visualization/README.md b/util/tracing/visualization/README.md index 3da43d639b..507e7ea449 100644 --- a/util/tracing/visualization/README.md +++ b/util/tracing/visualization/README.md @@ -2,23 +2,24 @@ `fedsd` is a utility tool that reports the interactions (exchanged messages) between federates and the RTI in a sequence-diagram-like format. -To enable `fedsd`, `tracing` target property should be set to `true`. + +To use `fedsd`, you need to first obtain an execution trace. To do this, enable the tracing mechanism in your Lingua Franca program by setting the `tracing` target property to `true` and then compile and run the program. This utility starts by transforming each `.lft` file into a `.csv` file, by internally running `trace_to_csv`. It then aggregates the data from all `.csv` files to do the matching and draw the sequence diagram. -# Installing -`fedsd` is installed by calling `make install` under `lingua_franca/util/tracing`. +# Installing +To build `fedsd`, change directory to `./util/tracing` relative to the root of the `lingua-franca` repository and run `make install`. # Running In case the federation is launched using the `bash` script under `bin`, an `.lft` trace -file will be generated for each of the federates, in addition to `rti.lft`. This latter +file will be generated for each of the federates, in addition to `rti.lft`. The latter contains the RTI trace. -If, however, the federation is launched manually, then running the `RTI` should -enable tracing, by adding the option `-t`: + +If, however, the federation is launched manually, then running the `RTI` command should be passed the `-t` flag in order to make sure that it, too, has tracing enabled: ``` $ RTI -n -t ``` From 77edc337d5d25ac379ed8904ea2b072ec9d90a5d Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Wed, 31 May 2023 14:17:54 -0700 Subject: [PATCH 606/709] Update util/tracing/visualization/README.md --- util/tracing/visualization/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/tracing/visualization/README.md b/util/tracing/visualization/README.md index 507e7ea449..8e7a729289 100644 --- a/util/tracing/visualization/README.md +++ b/util/tracing/visualization/README.md @@ -1,6 +1,6 @@ # Trace sequence diagram visualizer -`fedsd` is a utility tool that reports the interactions (exchanged messages) +`fedsd` is a utility that reports the interactions (exchanged messages) between federates and the RTI in a sequence-diagram-like format. To use `fedsd`, you need to first obtain an execution trace. To do this, enable the tracing mechanism in your Lingua Franca program by setting the `tracing` target property to `true` and then compile and run the program. From b92f4f338f34b0e626672c5a136f4df2f0d3d7c3 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 14:21:47 -0700 Subject: [PATCH 607/709] Use something less ugly than hashcodes. --- .../src/org/lflang/generator/c/CUtil.java | 2 +- .../generator/c/TypeParameterizedReactor.java | 18 +++++++++++++++++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 875efd61a3..5f1651e388 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -137,7 +137,7 @@ public static String channelIndexName(PortInstance port) { * (to allow for instantiations that have the same name as the main reactor or the .lf file). */ public static String getName(TypeParameterizedReactor reactor) { - String name = reactor.reactor().getName().toLowerCase() + reactor.hashCode(); + String name = reactor.uniqueName(); if (reactor.reactor().isMain()) { return name + "_main"; } diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 1b798e90ee..4376ed16aa 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -18,6 +18,9 @@ */ public record TypeParameterizedReactor(Reactor reactor, Map typeArgs) { + private static final Map uniqueNames = new HashMap<>(); + private static final Map nameCounts = new HashMap<>(); + /** * Construct the TPR corresponding to the given instantiation which syntactically appears within * the definition corresponding to {@code parent}. @@ -84,9 +87,22 @@ public InferredType resolveType(InferredType t) { return InferredType.fromAST(resolveType(t.astType)); } + public String uniqueName() { + if (uniqueNames.containsKey(this)) return uniqueNames.get(this); + if (nameCounts.containsKey(reactor.getName())) { + int currentCount = nameCounts.get(reactor.getName()); + nameCounts.put(reactor.getName(), currentCount + 1); + uniqueNames.put(this, reactor.getName() + currentCount); + return uniqueName(); + } + nameCounts.put(reactor.getName(), 1); + uniqueNames.put(this, reactor.getName()); + return uniqueName(); + } + @Override public int hashCode() { - return Math.abs(reactor.hashCode() * 31 + typeArgs.hashCode()); + return reactor.hashCode() * 31 + typeArgs.hashCode(); } @Override From 6e3fcd784676c3729b26660c7547f0d4a8147c02 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 14:53:14 -0700 Subject: [PATCH 608/709] Fix name collison. --- .../src/org/lflang/generator/c/TypeParameterizedReactor.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 4376ed16aa..ee40f46e69 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -92,11 +92,11 @@ public String uniqueName() { if (nameCounts.containsKey(reactor.getName())) { int currentCount = nameCounts.get(reactor.getName()); nameCounts.put(reactor.getName(), currentCount + 1); - uniqueNames.put(this, reactor.getName() + currentCount); + uniqueNames.put(this, "_" + reactor.getName() + currentCount); return uniqueName(); } nameCounts.put(reactor.getName(), 1); - uniqueNames.put(this, reactor.getName()); + uniqueNames.put(this, "_" + reactor.getName()); return uniqueName(); } From 3eb376648af674b94b61d98db80bdf906b13a72d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 15:26:12 -0700 Subject: [PATCH 609/709] Avoid collisions with reserved symbols. A single underscore followed by a lowercase letter is unlikely to be used in user code and is not an implementation-reserved pattern. --- org.lflang/src/org/lflang/generator/c/CUtil.java | 4 ++-- .../generator/c/TypeParameterizedReactor.java | 13 +++++++------ 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index 5f1651e388..aacde82f6b 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -498,9 +498,9 @@ public static String runtimeIndex(ReactorInstance reactor) { */ public static String selfType(TypeParameterizedReactor reactor) { if (reactor.reactor().isMain()) { - return "_" + CUtil.getName(reactor) + "_main_self_t"; + return CUtil.getName(reactor) + "_main_self_t"; } - return "_" + CUtil.getName(reactor) + "_self_t"; + return CUtil.getName(reactor) + "_self_t"; } /** Construct a unique type for the "self" struct of the class of the given reactor. */ diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index ee40f46e69..0d0ac91e7f 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -88,15 +88,16 @@ public InferredType resolveType(InferredType t) { } public String uniqueName() { + String name = reactor.getName().toLowerCase(); if (uniqueNames.containsKey(this)) return uniqueNames.get(this); - if (nameCounts.containsKey(reactor.getName())) { - int currentCount = nameCounts.get(reactor.getName()); - nameCounts.put(reactor.getName(), currentCount + 1); - uniqueNames.put(this, "_" + reactor.getName() + currentCount); + if (nameCounts.containsKey(name)) { + int currentCount = nameCounts.get(name); + nameCounts.put(name, currentCount + 1); + uniqueNames.put(this, "_" + name + currentCount); return uniqueName(); } - nameCounts.put(reactor.getName(), 1); - uniqueNames.put(this, "_" + reactor.getName()); + nameCounts.put(name, 1); + uniqueNames.put(this, "_" + name); return uniqueName(); } From 1c38e8d1c8dbe4a0ce8ff8130c2e97eef41f382c Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 15:59:51 -0700 Subject: [PATCH 610/709] Apply formatter. --- .../org/lflang/generator/c/CGenerator.java | 7 +----- .../generator/c/CReactionGenerator.java | 3 ++- .../src/org/lflang/generator/c/CUtil.java | 22 +++++++++---------- .../generator/c/TypeParameterizedReactor.java | 9 +++++--- 4 files changed, 20 insertions(+), 21 deletions(-) diff --git a/org.lflang/src/org/lflang/generator/c/CGenerator.java b/org.lflang/src/org/lflang/generator/c/CGenerator.java index b515538de1..85b755e4a1 100644 --- a/org.lflang/src/org/lflang/generator/c/CGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CGenerator.java @@ -40,10 +40,8 @@ import java.nio.file.Files; import java.nio.file.Path; import java.util.ArrayList; -import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; -import java.util.Map; import java.util.regex.Pattern; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -89,7 +87,6 @@ import org.lflang.lf.Reactor; import org.lflang.lf.ReactorDecl; import org.lflang.lf.StateVar; -import org.lflang.lf.Type; import org.lflang.lf.Variable; import org.lflang.util.ArduinoUtil; import org.lflang.util.FileUtil; @@ -1035,9 +1032,7 @@ protected void generateReactorClassHeaders( src.pr("#include \"include/" + CReactorHeaderFileGenerator.outputPath(tpr) + "\""); src.pr("#include \"" + headerName + "\""); tpr.doDefines(src); - CUtil.allIncludes(tpr).stream() - .map(name -> "#include \"" + name + ".h\"") - .forEach(header::pr); + CUtil.allIncludes(tpr).stream().map(name -> "#include \"" + name + ".h\"").forEach(header::pr); } private void generateReactorClassBody( diff --git a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java index e83e083191..824dc97ee6 100644 --- a/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java +++ b/org.lflang/src/org/lflang/generator/c/CReactionGenerator.java @@ -372,7 +372,8 @@ private static void generateVariablesForSendingToContainedReactors( structs.put(definition, structBuilder); } String inputStructType = - CGenerator.variableStructType(input, new TypeParameterizedReactor(definition, container), false); + CGenerator.variableStructType( + input, new TypeParameterizedReactor(definition, container), false); String defName = definition.getName(); String defWidth = generateWidthVariable(defName); String inputName = input.getName(); diff --git a/org.lflang/src/org/lflang/generator/c/CUtil.java b/org.lflang/src/org/lflang/generator/c/CUtil.java index aacde82f6b..46f998cac0 100644 --- a/org.lflang/src/org/lflang/generator/c/CUtil.java +++ b/org.lflang/src/org/lflang/generator/c/CUtil.java @@ -556,19 +556,19 @@ public static String triggerRefNested(PortInstance port, String runtimeIndex, St + "_trigger"; } - /** - * Given a reactor Class, return a set of include names for interacting reactors which includes - * all instantiations of base class that it extends. - */ - public static HashSet allIncludes(TypeParameterizedReactor tpr) { - var set = new HashSet(); - for (var i : ASTUtils.allInstantiations(tpr.reactor())) { - set.add(getName(new TypeParameterizedReactor(i, tpr))); - } - return set; + /** + * Given a reactor Class, return a set of include names for interacting reactors which includes + * all instantiations of base class that it extends. + */ + public static HashSet allIncludes(TypeParameterizedReactor tpr) { + var set = new HashSet(); + for (var i : ASTUtils.allInstantiations(tpr.reactor())) { + set.add(getName(new TypeParameterizedReactor(i, tpr))); } + return set; + } - ////////////////////////////////////////////////////// + ////////////////////////////////////////////////////// //// FIXME: Not clear what the strategy is with the following inner interface. // The {@code ReportCommandErrors} interface allows the // method runBuildCommand to call a protected diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 0d0ac91e7f..081d57336d 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -24,9 +24,10 @@ public record TypeParameterizedReactor(Reactor reactor, Map typeAr /** * Construct the TPR corresponding to the given instantiation which syntactically appears within * the definition corresponding to {@code parent}. + * * @param i An instantiation of the TPR to be constructed. * @param parent The reactor in which {@code i} appears, or {@code null} if type variables are - * permitted instead of types in this TPR. + * permitted instead of types in this TPR. */ public TypeParameterizedReactor(Instantiation i, TypeParameterizedReactor parent) { this( @@ -34,12 +35,14 @@ public TypeParameterizedReactor(Instantiation i, TypeParameterizedReactor parent addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()), parent)); } - private static Map addTypeArgs(Instantiation instantiation, Reactor r, TypeParameterizedReactor parent) { + private static Map addTypeArgs( + Instantiation instantiation, Reactor r, TypeParameterizedReactor parent) { HashMap ret = new HashMap<>(); if (instantiation.getTypeArgs() != null) { for (int i = 0; i < r.getTypeParms().size(); i++) { var arg = instantiation.getTypeArgs().get(i); - ret.put(r.getTypeParms().get(i).getLiteral(), parent == null ? arg : parent.resolveType(arg)); + ret.put( + r.getTypeParms().get(i).getLiteral(), parent == null ? arg : parent.resolveType(arg)); } } return ret; From 1d0de2aff58c80dbef27c683dbdd65117c4938b5 Mon Sep 17 00:00:00 2001 From: Byeong-gil Jun Date: Thu, 1 Jun 2023 09:21:28 +0900 Subject: [PATCH 611/709] Check whether 5 violations are detected or not --- ...tributedCountDecentralizedLateHierarchy.lf | 43 ++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-) diff --git a/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf b/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf index d806ab5453..9727ed74fe 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf @@ -14,7 +14,48 @@ target Python { } import Count from "../lib/Count.lf" -import ImportantActuator, Print from "DistributedCountDecentralizedLateDownstream.lf" +import Print from "DistributedCountDecentralizedLateDownstream.lf" + +reactor ImportantActuator { + input inp + # Count messages that arrive without STP violation. + state success = 0 + state success_stp_violation = 0 + # Force a timer to be invoked periodically + timer t(0, 10 usec) + # to ensure logical time will advance in the absence of incoming messages. + state c = 0 + + reaction(inp) {= + current_tag = lf.tag() + print(f"ImportantActuator: At tag ({lf.tag().time}, {lf.tag().microstep}) received {inp.value}. " + f"Intended tag is ({inp.intended_tag.time - lf.time.start()}, {inp.intended_tag.microstep}).") + if lf.tag() == Tag((SEC(1) * self.c) + + lf.time.start(), 0): + self.success += 1 # Message was on-time + else: + self.sys.stderr.write("Normal reaction was invoked, but current tag doesn't match expected tag.") + self.sys.exit(1) + self.c += 1 + =} STP(0) {= + current_tag = lf.tag() + print(f"ImportantActuator: At tag ({lf.time.logical_elapsed()}, {lf.tag().microstep}), message has violated the STP offset " + f"by ({lf.tag().time - inp.intended_tag.time}, {lf.tag().microstep - inp.intended_tag.microstep}).") + self.success_stp_violation += 1 + self.c += 1 + =} + + reaction(t) {= + # Do nothing. + =} + + reaction(shutdown) {= + if (self.success + self.success_stp_violation) != 5: + self.sys.stderr.write("Failed to detect STP violation in messages.") + self.sys.exit(1) + else: + print(f"Successfully detected STP violations ({self.success_stp_violation} violations, {self.success} on-time).") + =} +} reactor Receiver { input inp From 5fec4caabe4feca14de9cff010efbdf1ce87c183 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 17:37:27 -0700 Subject: [PATCH 612/709] Delete test output to avoid running out of memory. Only the oldest test output is deleted. --- org.lflang.tests/src/org/lflang/tests/LFTest.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/org.lflang.tests/src/org/lflang/tests/LFTest.java b/org.lflang.tests/src/org/lflang/tests/LFTest.java index 58b3cbf846..61b5dc2edf 100644 --- a/org.lflang.tests/src/org/lflang/tests/LFTest.java +++ b/org.lflang.tests/src/org/lflang/tests/LFTest.java @@ -226,7 +226,7 @@ public static final class ExecutionLogger { /** * String buffer used to record the standard output and error streams from the input process. */ - StringBuffer buffer = new StringBuffer(); + StringBuilder buffer = new StringBuilder(); /** * Return a thread responsible for recording the standard output stream of the given process. A @@ -250,7 +250,7 @@ public Thread recordStdErr(Process process) { * @param builder The builder to append to. * @param inputStream The stream to read from. */ - private Thread recordStream(StringBuffer builder, InputStream inputStream) { + private Thread recordStream(StringBuilder builder, InputStream inputStream) { return new Thread( () -> { try (Reader reader = new InputStreamReader(inputStream)) { @@ -258,6 +258,9 @@ private Thread recordStream(StringBuffer builder, InputStream inputStream) { char[] buf = new char[1024]; while ((len = reader.read(buf)) > 0) { builder.append(buf, 0, len); + if (Runtime.getRuntime().freeMemory() < Runtime.getRuntime().totalMemory() / 2 ) { + builder.delete(0, builder.length() / 2); + } } } catch (IOException e) { throw new RuntimeIOException(e); From adc2ea703b0da9322f57098456d459886f3da844 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 17:40:56 -0700 Subject: [PATCH 613/709] Avoid unnecessarily frequent timer triggering. This makes the test too computationally intensive and more importantly results in too much debugging output. --- .../Python/src/federated/DistributedCountDecentralizedLate.lf | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/Python/src/federated/DistributedCountDecentralizedLate.lf b/test/Python/src/federated/DistributedCountDecentralizedLate.lf index e3a6899e78..33e1c528d2 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLate.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLate.lf @@ -20,8 +20,8 @@ reactor Print { # STP(in, 30 msec); state success = 0 state success_stp_violation = 0 - # Force a timer to be invoke periodically - timer t(0, 10 usec) + # Force a timer to be invoked periodically + timer t(0, 1 msec) # to ensure logical time will advance in the absence of incoming messages. state c = 0 From c0a6194f41944a44c21961f1cef074c24b430f25 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 17:43:44 -0700 Subject: [PATCH 614/709] Apply formatter. --- test/C/src/generics/ParameterAsArgument.lf | 30 ++++++++++------------ 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/test/C/src/generics/ParameterAsArgument.lf b/test/C/src/generics/ParameterAsArgument.lf index 1f500150fb..5be6c0b926 100644 --- a/test/C/src/generics/ParameterAsArgument.lf +++ b/test/C/src/generics/ParameterAsArgument.lf @@ -1,14 +1,13 @@ -target C; +target C -// Hash issue -// Header name mismatch -reactor bundle { +reactor bundle { // Hash issue Header name mismatch } reactor Child { state k: T1 - input in:In; - output out:Out; + input in: In + output out: Out + reaction(in) {= int a = in->value; printf("Got %d\n", a); @@ -16,17 +15,16 @@ reactor Child { } reactor Super { - input in:In; - output out:Out; - state t1:T1; - c = new Child(); - in -> c.in; - c.out -> out; + input in: In + output out: Out + state t1: T1 + c = new Child() + in -> c.in + c.out -> out } main reactor { - reaction(startup) -> cc.in {= - lf_set(cc.in, 42); - =} - cc = new Super(); + cc = new Super() + + reaction(startup) -> cc.in {= lf_set(cc.in, 42); =} } From 3f4679e363bd8f8b3ad8c95ff8ed26b21bec72a2 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 31 May 2023 20:21:43 -0700 Subject: [PATCH 615/709] Fix formatting issue. --- test/C/src/generics/ParameterAsArgument.lf | 3 --- 1 file changed, 3 deletions(-) diff --git a/test/C/src/generics/ParameterAsArgument.lf b/test/C/src/generics/ParameterAsArgument.lf index 5be6c0b926..65f91e0488 100644 --- a/test/C/src/generics/ParameterAsArgument.lf +++ b/test/C/src/generics/ParameterAsArgument.lf @@ -1,8 +1,5 @@ target C -reactor bundle { // Hash issue Header name mismatch -} - reactor Child { state k: T1 input in: In From ad65533631abf6e5464a40aeb689e1165361d4eb Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 09:55:58 +0200 Subject: [PATCH 616/709] move zephyr files like it was done on master --- .../core/src/main/resources/lib/platform/{ => zephyr}/Kconfig | 0 .../main/resources/lib/platform/{ => zephyr}/boards/esp32.overlay | 0 .../lib/platform/{ => zephyr}/boards/nrf52dk_nrf52832_lf.conf | 0 .../core/src/main/resources/lib/platform/{ => zephyr}/prj_lf.conf | 0 4 files changed, 0 insertions(+), 0 deletions(-) rename org.lflang/core/src/main/resources/lib/platform/{ => zephyr}/Kconfig (100%) rename org.lflang/core/src/main/resources/lib/platform/{ => zephyr}/boards/esp32.overlay (100%) rename org.lflang/core/src/main/resources/lib/platform/{ => zephyr}/boards/nrf52dk_nrf52832_lf.conf (100%) rename org.lflang/core/src/main/resources/lib/platform/{ => zephyr}/prj_lf.conf (100%) diff --git a/org.lflang/core/src/main/resources/lib/platform/Kconfig b/org.lflang/core/src/main/resources/lib/platform/zephyr/Kconfig similarity index 100% rename from org.lflang/core/src/main/resources/lib/platform/Kconfig rename to org.lflang/core/src/main/resources/lib/platform/zephyr/Kconfig diff --git a/org.lflang/core/src/main/resources/lib/platform/boards/esp32.overlay b/org.lflang/core/src/main/resources/lib/platform/zephyr/boards/esp32.overlay similarity index 100% rename from org.lflang/core/src/main/resources/lib/platform/boards/esp32.overlay rename to org.lflang/core/src/main/resources/lib/platform/zephyr/boards/esp32.overlay diff --git a/org.lflang/core/src/main/resources/lib/platform/boards/nrf52dk_nrf52832_lf.conf b/org.lflang/core/src/main/resources/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf similarity index 100% rename from org.lflang/core/src/main/resources/lib/platform/boards/nrf52dk_nrf52832_lf.conf rename to org.lflang/core/src/main/resources/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf diff --git a/org.lflang/core/src/main/resources/lib/platform/prj_lf.conf b/org.lflang/core/src/main/resources/lib/platform/zephyr/prj_lf.conf similarity index 100% rename from org.lflang/core/src/main/resources/lib/platform/prj_lf.conf rename to org.lflang/core/src/main/resources/lib/platform/zephyr/prj_lf.conf From ae49145831d31f1be98ecf821569c2faecb4c366 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 10:12:06 +0200 Subject: [PATCH 617/709] eliminate the org.lflang top level directory --- .gitmodules | 8 ++++---- {org.lflang/cli => cli}/base/build.gradle | 0 .../base/src/main/java/org/lflang/cli/CliBase.java | 0 .../src/main/java/org/lflang/cli/LFStandaloneModule.java | 0 .../main/java/org/lflang/cli/StandaloneErrorReporter.java | 0 .../main/java/org/lflang/cli/StandaloneIssueAcceptor.java | 0 .../src/main/java/org/lflang/cli/VersionProvider.java | 0 .../base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt | 0 .../java/org/lflang/cli/CliToolTestFixture.java | 0 .../src/testFixtures/java/org/lflang/cli/TestUtils.java | 0 {org.lflang/cli => cli}/lfc/build.gradle | 0 .../cli => cli}/lfc/src/main/java/org/lflang/cli/Lfc.java | 0 .../lfc/src/test/java/org/lflang/cli/LfcCliTest.java | 0 .../test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt | 0 .../lfc/src/test/resources/org/lflang/cli/colors.lf | 0 .../lfc/src/test/resources/org/lflang/cli/colors.stderr | 0 .../lfc/src/test/resources/org/lflang/cli/emptyFile.lf | 0 .../src/test/resources/org/lflang/cli/emptyFile.stderr | 0 .../lfc/src/test/resources/org/lflang/cli/issue490.lf | 0 .../lfc/src/test/resources/org/lflang/cli/issue490.stderr | 0 .../src/test/resources/org/lflang/cli/multilineWarning.lf | 0 .../test/resources/org/lflang/cli/multilineWarning.stderr | 0 .../resources/org/lflang/cli/multilineWarningTooBig.lf | 0 .../org/lflang/cli/multilineWarningTooBig.stderr | 0 .../src/test/resources/org/lflang/cli/simpleWarning.lf | 0 .../test/resources/org/lflang/cli/simpleWarning.stderr | 0 .../lfc/src/test/resources/org/lflang/cli/tabs.lf | 0 .../lfc/src/test/resources/org/lflang/cli/tabs.stderr | 0 .../src/test/resources/org/lflang/cli/twoLineWarning.lf | 0 .../test/resources/org/lflang/cli/twoLineWarning.stderr | 0 {org.lflang/cli => cli}/lff/build.gradle | 0 .../cli => cli}/lff/src/main/java/org/lflang/cli/Lff.java | 0 .../lff/src/test/java/org/lflang/cli/LffCliTest.java | 0 {org.lflang/core => core}/build.gradle | 0 .../java/org/lflang/tests/RunSingleTest.java | 0 .../java/org/lflang/tests/RuntimeTest.java | 0 .../java/org/lflang/tests/lsp/ErrorInserter.java | 0 .../java/org/lflang/tests/lsp/LspTests.java | 0 .../java/org/lflang/tests/lsp/MockLanguageClient.java | 0 .../java/org/lflang/tests/lsp/MockReportProgress.java | 0 .../java/org/lflang/tests/runtime/CArduinoTest.java | 0 .../java/org/lflang/tests/runtime/CCppTest.java | 0 .../java/org/lflang/tests/runtime/CSchedulerTest.java | 0 .../java/org/lflang/tests/runtime/CTest.java | 0 .../java/org/lflang/tests/runtime/CZephyrTest.java | 0 .../java/org/lflang/tests/runtime/CppRos2Test.java | 0 .../java/org/lflang/tests/runtime/CppTest.java | 0 .../java/org/lflang/tests/runtime/PythonTest.java | 0 .../java/org/lflang/tests/runtime/RustTest.java | 0 .../java/org/lflang/tests/runtime/TypeScriptTest.java | 0 .../org/lflang/tests/serialization/SerializationTest.java | 0 .../src/main/java/org/lflang/AttributeUtils.java | 0 .../src/main/java/org/lflang/DefaultErrorReporter.java | 0 .../src/main/java/org/lflang/ErrorReporter.java | 0 .../src/main/java/org/lflang/FileConfig.java | 0 .../src/main/java/org/lflang/GenerateLinguaFranca.mwe2 | 0 .../src/main/java/org/lflang/InferredType.java | 0 .../java/org/lflang/LFResourceDescriptionStrategy.java | 0 .../src/main/java/org/lflang/LFResourceProvider.java | 0 .../src/main/java/org/lflang/LFRuntimeModule.java | 0 .../src/main/java/org/lflang/LFStandaloneSetup.java | 0 .../java/org/lflang/LFSyntaxErrorMessageProvider.java | 0 .../src/main/java/org/lflang/LinguaFranca.xtext | 0 .../src/main/java/org/lflang/LocalStrings.java | 0 .../src/main/java/org/lflang/MainConflictChecker.java | 0 .../core => core}/src/main/java/org/lflang/ModelInfo.java | 0 .../core => core}/src/main/java/org/lflang/Target.java | 0 .../src/main/java/org/lflang/TargetConfig.java | 0 .../src/main/java/org/lflang/TargetProperty.java | 0 .../core => core}/src/main/java/org/lflang/TimeUnit.java | 0 .../core => core}/src/main/java/org/lflang/TimeValue.java | 0 .../src/main/java/org/lflang/ast/ASTUtils.java | 0 .../src/main/java/org/lflang/ast/AstTransformation.java | 0 .../org/lflang/ast/DelayedConnectionTransformation.java | 0 .../src/main/java/org/lflang/ast/FormattingUtils.java | 0 .../src/main/java/org/lflang/ast/IsEqual.java | 0 .../src/main/java/org/lflang/ast/MalleableString.java | 0 .../core => core}/src/main/java/org/lflang/ast/ToLf.java | 0 .../src/main/java/org/lflang/ast/ToText.java | 0 .../diagram/synthesis/AbstractSynthesisExtensions.java | 0 .../lflang/diagram/synthesis/LinguaFrancaSynthesis.java | 0 .../diagram/synthesis/ReactorParameterDisplayModes.java | 0 .../lflang/diagram/synthesis/SynthesisRegistration.java | 0 .../lflang/diagram/synthesis/action/AbstractAction.java | 0 .../synthesis/action/CollapseAllReactorsAction.java | 0 .../diagram/synthesis/action/ExpandAllReactorsAction.java | 0 .../diagram/synthesis/action/FilterCycleAction.java | 0 .../synthesis/action/MemorizingExpandCollapseAction.java | 0 .../lflang/diagram/synthesis/action/ShowCycleAction.java | 0 .../synthesis/postprocessor/ReactionPortAdjustment.java | 0 .../synthesis/styles/LinguaFrancaShapeExtensions.java | 0 .../synthesis/styles/LinguaFrancaStyleExtensions.java | 0 .../diagram/synthesis/styles/ReactorFigureComponents.java | 0 .../lflang/diagram/synthesis/util/CycleVisualization.java | 0 .../util/InterfaceDependenciesVisualization.java | 0 .../diagram/synthesis/util/LayoutPostProcessing.java | 0 .../org/lflang/diagram/synthesis/util/ModeDiagrams.java | 0 .../lflang/diagram/synthesis/util/NamedInstanceUtil.java | 0 .../org/lflang/diagram/synthesis/util/ReactorIcons.java | 0 .../diagram/synthesis/util/SynthesisErrorReporter.java | 0 .../lflang/diagram/synthesis/util/UtilityExtensions.java | 0 .../java/org/lflang/federated/extensions/CExtension.java | 0 .../org/lflang/federated/extensions/CExtensionUtils.java | 0 .../lflang/federated/extensions/FedTargetExtension.java | 0 .../federated/extensions/FedTargetExtensionFactory.java | 0 .../org/lflang/federated/extensions/PythonExtension.java | 0 .../java/org/lflang/federated/extensions/TSExtension.java | 0 .../java/org/lflang/federated/generator/FedASTUtils.java | 0 .../lflang/federated/generator/FedConnectionInstance.java | 0 .../java/org/lflang/federated/generator/FedEmitter.java | 0 .../org/lflang/federated/generator/FedFileConfig.java | 0 .../java/org/lflang/federated/generator/FedGenerator.java | 0 .../org/lflang/federated/generator/FedImportEmitter.java | 0 .../org/lflang/federated/generator/FedMainEmitter.java | 0 .../lflang/federated/generator/FedPreambleEmitter.java | 0 .../org/lflang/federated/generator/FedReactorEmitter.java | 0 .../org/lflang/federated/generator/FedTargetConfig.java | 0 .../org/lflang/federated/generator/FedTargetEmitter.java | 0 .../java/org/lflang/federated/generator/FedUtils.java | 0 .../org/lflang/federated/generator/FederateInstance.java | 0 .../federated/generator/LineAdjustingErrorReporter.java | 0 .../federated/generator/SynchronizedErrorReporter.java | 0 .../java/org/lflang/federated/launcher/BuildConfig.java | 0 .../java/org/lflang/federated/launcher/CBuildConfig.java | 0 .../lflang/federated/launcher/FedLauncherGenerator.java | 0 .../java/org/lflang/federated/launcher/PyBuildConfig.java | 0 .../java/org/lflang/federated/launcher/RtiConfig.java | 0 .../java/org/lflang/federated/launcher/TsBuildConfig.java | 0 .../serialization/FedNativePythonSerialization.java | 0 .../federated/serialization/FedROS2CPPSerialization.java | 0 .../lflang/federated/serialization/FedSerialization.java | 0 .../federated/serialization/SupportedSerializers.java | 0 .../org/lflang/federated/validation/FedValidator.java | 0 .../src/main/java/org/lflang/formatting2/LFFormatter.java | 0 .../main/java/org/lflang/generator/ActionInstance.java | 0 .../src/main/java/org/lflang/generator/CodeBuilder.java | 0 .../src/main/java/org/lflang/generator/CodeMap.java | 0 .../main/java/org/lflang/generator/DeadlineInstance.java | 0 .../java/org/lflang/generator/DelayBodyGenerator.java | 0 .../java/org/lflang/generator/DiagnosticReporting.java | 0 .../java/org/lflang/generator/DockerComposeGenerator.java | 0 .../src/main/java/org/lflang/generator/DockerData.java | 0 .../main/java/org/lflang/generator/DockerGenerator.java | 0 .../org/lflang/generator/FedDockerComposeGenerator.java | 0 .../java/org/lflang/generator/GenerationException.java | 0 .../src/main/java/org/lflang/generator/GeneratorBase.java | 0 .../org/lflang/generator/GeneratorCommandFactory.java | 0 .../main/java/org/lflang/generator/GeneratorResult.java | 0 .../main/java/org/lflang/generator/GeneratorUtils.java | 0 .../lflang/generator/HumanReadableReportingStrategy.java | 0 .../main/java/org/lflang/generator/IntegratedBuilder.java | 0 .../org/lflang/generator/InvalidLfSourceException.java | 0 .../java/org/lflang/generator/InvalidSourceException.java | 0 .../src/main/java/org/lflang/generator/LFGenerator.java | 0 .../java/org/lflang/generator/LFGeneratorContext.java | 0 .../src/main/java/org/lflang/generator/LFResource.java | 0 .../org/lflang/generator/LanguageServerErrorReporter.java | 0 .../java/org/lflang/generator/LfExpressionVisitor.java | 0 .../src/main/java/org/lflang/generator/MainContext.java | 0 .../src/main/java/org/lflang/generator/MixedRadixInt.java | 0 .../src/main/java/org/lflang/generator/ModeInstance.java | 0 .../src/main/java/org/lflang/generator/NamedInstance.java | 0 .../main/java/org/lflang/generator/ParameterInstance.java | 0 .../src/main/java/org/lflang/generator/PortInstance.java | 0 .../src/main/java/org/lflang/generator/Position.java | 0 .../src/main/java/org/lflang/generator/Range.java | 0 .../main/java/org/lflang/generator/ReactionInstance.java | 0 .../java/org/lflang/generator/ReactionInstanceGraph.java | 0 .../main/java/org/lflang/generator/ReactorInstance.java | 0 .../src/main/java/org/lflang/generator/RuntimeRange.java | 0 .../src/main/java/org/lflang/generator/SendRange.java | 0 .../src/main/java/org/lflang/generator/SubContext.java | 0 .../src/main/java/org/lflang/generator/TargetTypes.java | 0 .../src/main/java/org/lflang/generator/TimerInstance.java | 0 .../main/java/org/lflang/generator/TriggerInstance.java | 0 .../generator/UnsupportedGeneratorFeatureException.java | 0 .../java/org/lflang/generator/ValidationStrategy.java | 0 .../src/main/java/org/lflang/generator/Validator.java | 0 .../main/java/org/lflang/generator/WatchdogInstance.java | 0 .../java/org/lflang/generator/c/CActionGenerator.java | 0 .../main/java/org/lflang/generator/c/CCmakeGenerator.java | 0 .../src/main/java/org/lflang/generator/c/CCompiler.java | 0 .../org/lflang/generator/c/CConstructorGenerator.java | 0 .../main/java/org/lflang/generator/c/CCoreFilesUtils.java | 0 .../java/org/lflang/generator/c/CDelayBodyGenerator.java | 0 .../java/org/lflang/generator/c/CDockerGenerator.java | 0 .../src/main/java/org/lflang/generator/c/CFileConfig.java | 0 .../src/main/java/org/lflang/generator/c/CGenerator.java | 0 .../org/lflang/generator/c/CMainFunctionGenerator.java | 0 .../java/org/lflang/generator/c/CMethodGenerator.java | 0 .../java/org/lflang/generator/c/CMixedRadixGenerator.java | 0 .../main/java/org/lflang/generator/c/CModesGenerator.java | 0 .../java/org/lflang/generator/c/CParameterGenerator.java | 0 .../main/java/org/lflang/generator/c/CPortGenerator.java | 0 .../java/org/lflang/generator/c/CPreambleGenerator.java | 0 .../java/org/lflang/generator/c/CReactionGenerator.java | 0 .../lflang/generator/c/CReactorHeaderFileGenerator.java | 0 .../main/java/org/lflang/generator/c/CStateGenerator.java | 0 .../main/java/org/lflang/generator/c/CTimerGenerator.java | 0 .../java/org/lflang/generator/c/CTracingGenerator.java | 0 .../org/lflang/generator/c/CTriggerObjectsGenerator.java | 0 .../src/main/java/org/lflang/generator/c/CTypes.java | 0 .../src/main/java/org/lflang/generator/c/CUtil.java | 0 .../java/org/lflang/generator/c/CWatchdogGenerator.java | 0 .../lflang/generator/c/InteractingContainedReactors.java | 0 .../org/lflang/generator/c/TypeParameterizedReactor.java | 0 .../java/org/lflang/generator/python/PyFileConfig.java | 0 .../src/main/java/org/lflang/generator/python/PyUtil.java | 0 .../lflang/generator/python/PythonActionGenerator.java | 0 .../lflang/generator/python/PythonDelayBodyGenerator.java | 0 .../lflang/generator/python/PythonDockerGenerator.java | 0 .../java/org/lflang/generator/python/PythonGenerator.java | 0 .../org/lflang/generator/python/PythonInfoGenerator.java | 0 .../generator/python/PythonMainFunctionGenerator.java | 0 .../lflang/generator/python/PythonMethodGenerator.java | 0 .../org/lflang/generator/python/PythonModeGenerator.java | 0 .../lflang/generator/python/PythonParameterGenerator.java | 0 .../org/lflang/generator/python/PythonPortGenerator.java | 0 .../lflang/generator/python/PythonPreambleGenerator.java | 0 .../lflang/generator/python/PythonReactionGenerator.java | 0 .../lflang/generator/python/PythonReactorGenerator.java | 0 .../org/lflang/generator/python/PythonStateGenerator.java | 0 .../java/org/lflang/generator/python/PythonTypes.java | 0 .../java/org/lflang/generator/python/PythonValidator.java | 0 .../org/lflang/generator/rust/CargoDependencySpec.java | 0 .../java/org/lflang/generator/rust/RustTargetConfig.java | 0 .../java/org/lflang/generator/ts/TSDockerGenerator.java | 0 .../src/main/java/org/lflang/generator/ts/TSTypes.java | 0 .../src/main/java/org/lflang/graph/DirectedGraph.java | 0 .../src/main/java/org/lflang/graph/Graph.java | 0 .../main/java/org/lflang/graph/InstantiationGraph.java | 0 .../src/main/java/org/lflang/graph/NodeAnnotation.java | 0 .../src/main/java/org/lflang/graph/NodeAnnotations.java | 0 .../src/main/java/org/lflang/graph/PrecedenceGraph.java | 0 .../src/main/java/org/lflang/graph/TopologyGraph.java | 0 .../src/main/java/org/lflang/ide/LFIdeModule.java | 0 .../src/main/java/org/lflang/ide/LFIdeSetup.java | 0 .../java/org/lflang/scoping/LFGlobalScopeProvider.java | 0 .../src/main/java/org/lflang/scoping/LFScopeProvider.java | 0 .../main/java/org/lflang/scoping/LFScopeProviderImpl.java | 0 .../src/main/java/org/lflang/util/ArduinoUtil.java | 0 .../src/main/java/org/lflang/util/Averager.java | 0 .../src/main/java/org/lflang/util/CollectionUtil.java | 0 .../src/main/java/org/lflang/util/FileUtil.java | 0 .../src/main/java/org/lflang/util/IteratorUtil.java | 0 .../src/main/java/org/lflang/util/LFCommand.java | 0 .../src/main/java/org/lflang/util/StringUtil.java | 0 .../org/lflang/util/TargetResourceNotFoundException.java | 0 .../main/java/org/lflang/validation/AttributeSpec.java | 0 .../main/java/org/lflang/validation/BaseLFValidator.java | 0 .../validation/LFNamesAreUniqueValidationHelper.java | 0 .../src/main/java/org/lflang/validation/LFValidator.java | 0 .../org/lflang/validation/ValidatorErrorReporter.java | 0 .../src/main/kotlin/org/lflang/CommonExtensions.kt | 0 .../src/main/kotlin/org/lflang/FileConfigExtensions.kt | 0 .../src/main/kotlin/org/lflang/ast/AstExtensions.kt | 0 .../kotlin/org/lflang/generator/GeneratorExtensions.kt | 0 .../main/kotlin/org/lflang/generator/GeneratorUtils.kt | 0 .../org/lflang/generator/LanguageRuntimeVersions.kt | 0 .../kotlin/org/lflang/generator/cpp/CppActionGenerator.kt | 0 .../lflang/generator/cpp/CppAssembleMethodGenerator.kt | 0 .../org/lflang/generator/cpp/CppConnectionGenerator.kt | 0 .../main/kotlin/org/lflang/generator/cpp/CppExtensions.kt | 0 .../main/kotlin/org/lflang/generator/cpp/CppFileConfig.kt | 0 .../main/kotlin/org/lflang/generator/cpp/CppGenerator.kt | 0 .../org/lflang/generator/cpp/CppInstanceGenerator.kt | 0 .../kotlin/org/lflang/generator/cpp/CppMethodGenerator.kt | 0 .../org/lflang/generator/cpp/CppParameterGenerator.kt | 0 .../org/lflang/generator/cpp/CppPlatformGenerator.kt | 0 .../kotlin/org/lflang/generator/cpp/CppPortGenerator.kt | 0 .../org/lflang/generator/cpp/CppPreambleGenerator.kt | 0 .../org/lflang/generator/cpp/CppReactionGenerator.kt | 0 .../org/lflang/generator/cpp/CppReactorGenerator.kt | 0 .../kotlin/org/lflang/generator/cpp/CppRos2Generator.kt | 0 .../org/lflang/generator/cpp/CppRos2NodeGenerator.kt | 0 .../org/lflang/generator/cpp/CppRos2PackageGenerator.kt | 0 .../lflang/generator/cpp/CppStandaloneCmakeGenerator.kt | 0 .../org/lflang/generator/cpp/CppStandaloneGenerator.kt | 0 .../lflang/generator/cpp/CppStandaloneMainGenerator.kt | 0 .../kotlin/org/lflang/generator/cpp/CppStateGenerator.kt | 0 .../kotlin/org/lflang/generator/cpp/CppTimerGenerator.kt | 0 .../src/main/kotlin/org/lflang/generator/cpp/CppTypes.kt | 0 .../main/kotlin/org/lflang/generator/cpp/CppValidator.kt | 0 .../main/kotlin/org/lflang/generator/rust/PortEmitter.kt | 0 .../org/lflang/generator/rust/RustCargoTomlEmitter.kt | 0 .../main/kotlin/org/lflang/generator/rust/RustEmitter.kt | 0 .../kotlin/org/lflang/generator/rust/RustEmitterBase.kt | 0 .../kotlin/org/lflang/generator/rust/RustFileConfig.kt | 0 .../kotlin/org/lflang/generator/rust/RustGenerator.kt | 0 .../org/lflang/generator/rust/RustMainFileEmitter.kt | 0 .../main/kotlin/org/lflang/generator/rust/RustModel.kt | 0 .../org/lflang/generator/rust/RustReactorEmitter.kt | 0 .../main/kotlin/org/lflang/generator/rust/RustTypes.kt | 0 .../kotlin/org/lflang/generator/rust/RustValidator.kt | 0 .../kotlin/org/lflang/generator/ts/TSActionGenerator.kt | 0 .../org/lflang/generator/ts/TSConnectionGenerator.kt | 0 .../org/lflang/generator/ts/TSConstructorGenerator.kt | 0 .../org/lflang/generator/ts/TSDelayBodyGenerator.kt | 0 .../main/kotlin/org/lflang/generator/ts/TSExtensions.kt | 0 .../main/kotlin/org/lflang/generator/ts/TSFileConfig.kt | 0 .../main/kotlin/org/lflang/generator/ts/TSGenerator.kt | 0 .../org/lflang/generator/ts/TSImportPreambleGenerator.kt | 0 .../kotlin/org/lflang/generator/ts/TSInstanceGenerator.kt | 0 .../org/lflang/generator/ts/TSParameterGenerator.kt | 0 .../lflang/generator/ts/TSParameterPreambleGenerator.kt | 0 .../kotlin/org/lflang/generator/ts/TSPortGenerator.kt | 0 .../kotlin/org/lflang/generator/ts/TSReactionGenerator.kt | 0 .../kotlin/org/lflang/generator/ts/TSReactorGenerator.kt | 0 .../kotlin/org/lflang/generator/ts/TSStateGenerator.kt | 0 .../kotlin/org/lflang/generator/ts/TSTimerGenerator.kt | 0 .../main/kotlin/org/lflang/generator/ts/TSValidator.kt | 0 .../services/de.cau.cs.kieler.klighd.IKlighdStartupHook | 0 .../core => core}/src/main/resources/lib/c/reactor-c | 0 .../src/main/resources/lib/cpp/3rd-party/cxxopts.hpp | 0 .../core => core}/src/main/resources/lib/cpp/lfutil.hh | 0 .../core => core}/src/main/resources/lib/cpp/reactor-cpp | 0 .../src/main/resources/lib/cpp/time_parser.hh | 0 .../src/main/resources/lib/platform/zephyr/Kconfig | 0 .../resources/lib/platform/zephyr/boards/esp32.overlay | 0 .../lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf | 0 .../src/main/resources/lib/platform/zephyr/prj_lf.conf | 0 .../src/main/resources/lib/py/lf-python-support | 0 .../core => core}/src/main/resources/lib/rs/reactor-rs | 0 .../src/main/resources/lib/rs/runtime-version.properties | 0 .../src/main/resources/lib/ts/.eslintrc.json | 0 .../core => core}/src/main/resources/lib/ts/README.md | 0 .../core => core}/src/main/resources/lib/ts/package.json | 0 .../core => core}/src/main/resources/lib/ts/tsconfig.json | 0 .../main/resources/org/lflang/StringsBundle.properties | 0 .../src/test/java/org/lflang/tests/LFParsingTest.java | 0 .../src/test/java/org/lflang/tests/LfParsingUtil.java | 0 .../org/lflang/tests/compiler/EquivalenceUnitTests.java | 0 .../org/lflang/tests/compiler/FormattingUnitTests.java | 0 .../java/org/lflang/tests/compiler/LetInferenceTests.java | 0 .../lflang/tests/compiler/LinguaFrancaASTUtilsTest.java | 0 .../compiler/LinguaFrancaDependencyAnalysisTest.java | 0 .../lflang/tests/compiler/LinguaFrancaParsingTest.java | 0 .../lflang/tests/compiler/LinguaFrancaScopingTest.java | 0 .../lflang/tests/compiler/LinguaFrancaValidationTest.java | 0 .../java/org/lflang/tests/compiler/MixedRadixIntTest.java | 0 .../java/org/lflang/tests/compiler/PortInstanceTests.java | 0 .../test/java/org/lflang/tests/compiler/RangeTests.java | 0 .../java/org/lflang/tests/compiler/RoundTripTests.java | 0 .../java/org/lflang/tests/compiler/TargetConfigTests.java | 0 .../test/java/org/lflang/tests/util/StringUtilTest.java | 0 .../testFixtures/java/org/lflang/tests/Configurators.java | 0 .../src/testFixtures/java/org/lflang/tests/LFTest.java | 0 .../src/testFixtures/java/org/lflang/tests/TestBase.java | 0 .../src/testFixtures/java/org/lflang/tests/TestError.java | 0 .../testFixtures/java/org/lflang/tests/TestRegistry.java | 0 {org.lflang/lsp => lsp}/build.gradle | 0 .../java/org/lflang/diagram/lsp/LFLanguageServer.java | 0 .../org/lflang/diagram/lsp/LFLanguageServerExtension.java | 0 .../org/lflang/diagram/lsp/LanguageDiagramServer.java | 0 .../src/main/java/org/lflang/diagram/lsp/Progress.java | 0 {org.lflang/todo => todo}/log4j.xml | 0 356 files changed, 4 insertions(+), 4 deletions(-) rename {org.lflang/cli => cli}/base/build.gradle (100%) rename {org.lflang/cli => cli}/base/src/main/java/org/lflang/cli/CliBase.java (100%) rename {org.lflang/cli => cli}/base/src/main/java/org/lflang/cli/LFStandaloneModule.java (100%) rename {org.lflang/cli => cli}/base/src/main/java/org/lflang/cli/StandaloneErrorReporter.java (100%) rename {org.lflang/cli => cli}/base/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java (100%) rename {org.lflang/cli => cli}/base/src/main/java/org/lflang/cli/VersionProvider.java (100%) rename {org.lflang/cli => cli}/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt (100%) rename {org.lflang/cli => cli}/base/src/testFixtures/java/org/lflang/cli/CliToolTestFixture.java (100%) rename {org.lflang/cli => cli}/base/src/testFixtures/java/org/lflang/cli/TestUtils.java (100%) rename {org.lflang/cli => cli}/lfc/build.gradle (100%) rename {org.lflang/cli => cli}/lfc/src/main/java/org/lflang/cli/Lfc.java (100%) rename {org.lflang/cli => cli}/lfc/src/test/java/org/lflang/cli/LfcCliTest.java (100%) rename {org.lflang/cli => cli}/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/colors.lf (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/colors.stderr (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/emptyFile.lf (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/emptyFile.stderr (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/issue490.lf (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/issue490.stderr (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/multilineWarning.lf (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/multilineWarning.stderr (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.lf (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.stderr (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/simpleWarning.lf (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/simpleWarning.stderr (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/tabs.lf (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/tabs.stderr (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/twoLineWarning.lf (100%) rename {org.lflang/cli => cli}/lfc/src/test/resources/org/lflang/cli/twoLineWarning.stderr (100%) rename {org.lflang/cli => cli}/lff/build.gradle (100%) rename {org.lflang/cli => cli}/lff/src/main/java/org/lflang/cli/Lff.java (100%) rename {org.lflang/cli => cli}/lff/src/test/java/org/lflang/cli/LffCliTest.java (100%) rename {org.lflang/core => core}/build.gradle (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/RunSingleTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/RuntimeTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/lsp/ErrorInserter.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/lsp/MockLanguageClient.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/lsp/MockReportProgress.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/CTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java (100%) rename {org.lflang/core => core}/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/AttributeUtils.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/DefaultErrorReporter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ErrorReporter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/FileConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/InferredType.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/LFResourceDescriptionStrategy.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/LFResourceProvider.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/LFRuntimeModule.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/LFStandaloneSetup.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/LFSyntaxErrorMessageProvider.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/LinguaFranca.xtext (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/LocalStrings.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/MainConflictChecker.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ModelInfo.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/Target.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/TargetConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/TargetProperty.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/TimeUnit.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/TimeValue.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ast/ASTUtils.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ast/AstTransformation.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ast/DelayedConnectionTransformation.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ast/FormattingUtils.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ast/IsEqual.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ast/MalleableString.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ast/ToLf.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ast/ToText.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/SynthesisRegistration.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/action/AbstractAction.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/action/FilterCycleAction.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/action/ShowCycleAction.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/util/CycleVisualization.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/util/ModeDiagrams.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/util/ReactorIcons.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/diagram/synthesis/util/UtilityExtensions.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/extensions/CExtension.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/extensions/CExtensionUtils.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/extensions/FedTargetExtension.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/extensions/FedTargetExtensionFactory.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/extensions/PythonExtension.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/extensions/TSExtension.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedASTUtils.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedConnectionInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedEmitter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedFileConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedImportEmitter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedMainEmitter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedPreambleEmitter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedReactorEmitter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedTargetConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedTargetEmitter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FedUtils.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/FederateInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/LineAdjustingErrorReporter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/generator/SynchronizedErrorReporter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/launcher/BuildConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/launcher/CBuildConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/launcher/PyBuildConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/launcher/RtiConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/launcher/TsBuildConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/serialization/FedNativePythonSerialization.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/serialization/FedROS2CPPSerialization.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/serialization/FedSerialization.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/serialization/SupportedSerializers.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/federated/validation/FedValidator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/formatting2/LFFormatter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ActionInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/CodeBuilder.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/CodeMap.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/DeadlineInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/DelayBodyGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/DiagnosticReporting.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/DockerComposeGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/DockerData.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/DockerGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/FedDockerComposeGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/GenerationException.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/GeneratorBase.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/GeneratorCommandFactory.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/GeneratorResult.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/GeneratorUtils.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/HumanReadableReportingStrategy.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/IntegratedBuilder.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/InvalidLfSourceException.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/InvalidSourceException.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/LFGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/LFGeneratorContext.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/LFResource.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/LanguageServerErrorReporter.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/LfExpressionVisitor.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/MainContext.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/MixedRadixInt.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ModeInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/NamedInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ParameterInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/PortInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/Position.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/Range.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ReactionInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ReactionInstanceGraph.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ReactorInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/RuntimeRange.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/SendRange.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/SubContext.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/TargetTypes.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/TimerInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/TriggerInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/UnsupportedGeneratorFeatureException.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ValidationStrategy.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/Validator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/WatchdogInstance.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CActionGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CCmakeGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CCompiler.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CConstructorGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CCoreFilesUtils.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CDelayBodyGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CDockerGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CFileConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CMainFunctionGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CMethodGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CMixedRadixGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CModesGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CParameterGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CPortGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CPreambleGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CReactionGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CReactorHeaderFileGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CStateGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CTimerGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CTracingGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CTriggerObjectsGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CTypes.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CUtil.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/CWatchdogGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/InteractingContainedReactors.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PyFileConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PyUtil.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonActionGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonDelayBodyGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonDockerGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonInfoGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonMainFunctionGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonMethodGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonModeGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonParameterGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonPortGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonPreambleGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonReactionGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonReactorGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonStateGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonTypes.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/python/PythonValidator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/rust/CargoDependencySpec.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/rust/RustTargetConfig.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ts/TSDockerGenerator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/generator/ts/TSTypes.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/graph/DirectedGraph.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/graph/Graph.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/graph/InstantiationGraph.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/graph/NodeAnnotation.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/graph/NodeAnnotations.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/graph/PrecedenceGraph.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/graph/TopologyGraph.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ide/LFIdeModule.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/ide/LFIdeSetup.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/scoping/LFGlobalScopeProvider.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/scoping/LFScopeProvider.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/scoping/LFScopeProviderImpl.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/util/ArduinoUtil.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/util/Averager.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/util/CollectionUtil.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/util/FileUtil.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/util/IteratorUtil.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/util/LFCommand.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/util/StringUtil.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/util/TargetResourceNotFoundException.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/validation/AttributeSpec.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/validation/BaseLFValidator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/validation/LFNamesAreUniqueValidationHelper.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/validation/LFValidator.java (100%) rename {org.lflang/core => core}/src/main/java/org/lflang/validation/ValidatorErrorReporter.java (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/CommonExtensions.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/FileConfigExtensions.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/ast/AstExtensions.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/GeneratorExtensions.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/GeneratorUtils.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/LanguageRuntimeVersions.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppActionGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppConnectionGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppExtensions.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppFileConfig.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppInstanceGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppMethodGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppParameterGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppPlatformGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppPortGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppPreambleGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppReactionGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppReactorGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppRos2Generator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppRos2NodeGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppRos2PackageGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppStateGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppTimerGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppTypes.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/cpp/CppValidator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/PortEmitter.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustCargoTomlEmitter.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustEmitter.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustEmitterBase.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustFileConfig.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustMainFileEmitter.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustModel.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustReactorEmitter.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustTypes.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/rust/RustValidator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSActionGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSConnectionGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSConstructorGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSDelayBodyGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSExtensions.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSFileConfig.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSImportPreambleGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSInstanceGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSParameterGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSParameterPreambleGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSPortGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSReactionGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSReactorGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSStateGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSTimerGenerator.kt (100%) rename {org.lflang/core => core}/src/main/kotlin/org/lflang/generator/ts/TSValidator.kt (100%) rename {org.lflang/core => core}/src/main/resources/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook (100%) rename {org.lflang/core => core}/src/main/resources/lib/c/reactor-c (100%) rename {org.lflang/core => core}/src/main/resources/lib/cpp/3rd-party/cxxopts.hpp (100%) rename {org.lflang/core => core}/src/main/resources/lib/cpp/lfutil.hh (100%) rename {org.lflang/core => core}/src/main/resources/lib/cpp/reactor-cpp (100%) rename {org.lflang/core => core}/src/main/resources/lib/cpp/time_parser.hh (100%) rename {org.lflang/core => core}/src/main/resources/lib/platform/zephyr/Kconfig (100%) rename {org.lflang/core => core}/src/main/resources/lib/platform/zephyr/boards/esp32.overlay (100%) rename {org.lflang/core => core}/src/main/resources/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf (100%) rename {org.lflang/core => core}/src/main/resources/lib/platform/zephyr/prj_lf.conf (100%) rename {org.lflang/core => core}/src/main/resources/lib/py/lf-python-support (100%) rename {org.lflang/core => core}/src/main/resources/lib/rs/reactor-rs (100%) rename {org.lflang/core => core}/src/main/resources/lib/rs/runtime-version.properties (100%) rename {org.lflang/core => core}/src/main/resources/lib/ts/.eslintrc.json (100%) rename {org.lflang/core => core}/src/main/resources/lib/ts/README.md (100%) rename {org.lflang/core => core}/src/main/resources/lib/ts/package.json (100%) rename {org.lflang/core => core}/src/main/resources/lib/ts/tsconfig.json (100%) rename {org.lflang/core => core}/src/main/resources/org/lflang/StringsBundle.properties (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/LFParsingTest.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/LfParsingUtil.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/EquivalenceUnitTests.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/FormattingUnitTests.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/LetInferenceTests.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/LinguaFrancaParsingTest.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/LinguaFrancaScopingTest.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/LinguaFrancaValidationTest.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/MixedRadixIntTest.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/PortInstanceTests.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/RangeTests.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/RoundTripTests.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java (100%) rename {org.lflang/core => core}/src/test/java/org/lflang/tests/util/StringUtilTest.java (100%) rename {org.lflang/core => core}/src/testFixtures/java/org/lflang/tests/Configurators.java (100%) rename {org.lflang/core => core}/src/testFixtures/java/org/lflang/tests/LFTest.java (100%) rename {org.lflang/core => core}/src/testFixtures/java/org/lflang/tests/TestBase.java (100%) rename {org.lflang/core => core}/src/testFixtures/java/org/lflang/tests/TestError.java (100%) rename {org.lflang/core => core}/src/testFixtures/java/org/lflang/tests/TestRegistry.java (100%) rename {org.lflang/lsp => lsp}/build.gradle (100%) rename {org.lflang/lsp => lsp}/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java (100%) rename {org.lflang/lsp => lsp}/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java (100%) rename {org.lflang/lsp => lsp}/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java (100%) rename {org.lflang/lsp => lsp}/src/main/java/org/lflang/diagram/lsp/Progress.java (100%) rename {org.lflang/todo => todo}/log4j.xml (100%) diff --git a/.gitmodules b/.gitmodules index 52c3af173b..9cd89ffe1a 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,12 +1,12 @@ [submodule "org.lflang/src/lib/c/reactor-c"] - path = org.lflang/core/src/main/resources/lib/c/reactor-c + path = core/src/main/resources/lib/c/reactor-c url = https://github.com/lf-lang/reactor-c.git [submodule "org.lflang/src/lib/cpp/reactor-cpp"] - path = org.lflang/core/src/main/resources/lib/cpp/reactor-cpp + path = core/src/main/resources/lib/cpp/reactor-cpp url = https://github.com/lf-lang/reactor-cpp [submodule "org.lflang/src/lib/rs/reactor-rs"] - path = org.lflang/core/src/main/resources/lib/rs/reactor-rs + path = core/src/main/resources/lib/rs/reactor-rs url = https://github.com/lf-lang/reactor-rs [submodule "org.lflang/src/lib/py/lf-python-support"] - path = org.lflang/core/src/main/resources/lib/py/lf-python-support + path = core/src/main/resources/lib/py/lf-python-support url = https://github.com/lf-lang/lf-python-support.git diff --git a/org.lflang/cli/base/build.gradle b/cli/base/build.gradle similarity index 100% rename from org.lflang/cli/base/build.gradle rename to cli/base/build.gradle diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java b/cli/base/src/main/java/org/lflang/cli/CliBase.java similarity index 100% rename from org.lflang/cli/base/src/main/java/org/lflang/cli/CliBase.java rename to cli/base/src/main/java/org/lflang/cli/CliBase.java diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/LFStandaloneModule.java b/cli/base/src/main/java/org/lflang/cli/LFStandaloneModule.java similarity index 100% rename from org.lflang/cli/base/src/main/java/org/lflang/cli/LFStandaloneModule.java rename to cli/base/src/main/java/org/lflang/cli/LFStandaloneModule.java diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/StandaloneErrorReporter.java b/cli/base/src/main/java/org/lflang/cli/StandaloneErrorReporter.java similarity index 100% rename from org.lflang/cli/base/src/main/java/org/lflang/cli/StandaloneErrorReporter.java rename to cli/base/src/main/java/org/lflang/cli/StandaloneErrorReporter.java diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java b/cli/base/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java similarity index 100% rename from org.lflang/cli/base/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java rename to cli/base/src/main/java/org/lflang/cli/StandaloneIssueAcceptor.java diff --git a/org.lflang/cli/base/src/main/java/org/lflang/cli/VersionProvider.java b/cli/base/src/main/java/org/lflang/cli/VersionProvider.java similarity index 100% rename from org.lflang/cli/base/src/main/java/org/lflang/cli/VersionProvider.java rename to cli/base/src/main/java/org/lflang/cli/VersionProvider.java diff --git a/org.lflang/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt b/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt similarity index 100% rename from org.lflang/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt rename to cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt diff --git a/org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/CliToolTestFixture.java b/cli/base/src/testFixtures/java/org/lflang/cli/CliToolTestFixture.java similarity index 100% rename from org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/CliToolTestFixture.java rename to cli/base/src/testFixtures/java/org/lflang/cli/CliToolTestFixture.java diff --git a/org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/TestUtils.java b/cli/base/src/testFixtures/java/org/lflang/cli/TestUtils.java similarity index 100% rename from org.lflang/cli/base/src/testFixtures/java/org/lflang/cli/TestUtils.java rename to cli/base/src/testFixtures/java/org/lflang/cli/TestUtils.java diff --git a/org.lflang/cli/lfc/build.gradle b/cli/lfc/build.gradle similarity index 100% rename from org.lflang/cli/lfc/build.gradle rename to cli/lfc/build.gradle diff --git a/org.lflang/cli/lfc/src/main/java/org/lflang/cli/Lfc.java b/cli/lfc/src/main/java/org/lflang/cli/Lfc.java similarity index 100% rename from org.lflang/cli/lfc/src/main/java/org/lflang/cli/Lfc.java rename to cli/lfc/src/main/java/org/lflang/cli/Lfc.java diff --git a/org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java b/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java similarity index 100% rename from org.lflang/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java rename to cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java diff --git a/org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt b/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt similarity index 100% rename from org.lflang/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt rename to cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/colors.lf b/cli/lfc/src/test/resources/org/lflang/cli/colors.lf similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/colors.lf rename to cli/lfc/src/test/resources/org/lflang/cli/colors.lf diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/colors.stderr b/cli/lfc/src/test/resources/org/lflang/cli/colors.stderr similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/colors.stderr rename to cli/lfc/src/test/resources/org/lflang/cli/colors.stderr diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.lf b/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.lf similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.lf rename to cli/lfc/src/test/resources/org/lflang/cli/emptyFile.lf diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.stderr b/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.stderr similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/emptyFile.stderr rename to cli/lfc/src/test/resources/org/lflang/cli/emptyFile.stderr diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/issue490.lf b/cli/lfc/src/test/resources/org/lflang/cli/issue490.lf similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/issue490.lf rename to cli/lfc/src/test/resources/org/lflang/cli/issue490.lf diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/issue490.stderr b/cli/lfc/src/test/resources/org/lflang/cli/issue490.stderr similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/issue490.stderr rename to cli/lfc/src/test/resources/org/lflang/cli/issue490.stderr diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.lf b/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.lf similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.lf rename to cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.lf diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.stderr b/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.stderr similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.stderr rename to cli/lfc/src/test/resources/org/lflang/cli/multilineWarning.stderr diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.lf b/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.lf similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.lf rename to cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.lf diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.stderr b/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.stderr similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.stderr rename to cli/lfc/src/test/resources/org/lflang/cli/multilineWarningTooBig.stderr diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.lf b/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.lf similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.lf rename to cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.lf diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.stderr b/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.stderr similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.stderr rename to cli/lfc/src/test/resources/org/lflang/cli/simpleWarning.stderr diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/tabs.lf b/cli/lfc/src/test/resources/org/lflang/cli/tabs.lf similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/tabs.lf rename to cli/lfc/src/test/resources/org/lflang/cli/tabs.lf diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/tabs.stderr b/cli/lfc/src/test/resources/org/lflang/cli/tabs.stderr similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/tabs.stderr rename to cli/lfc/src/test/resources/org/lflang/cli/tabs.stderr diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.lf b/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.lf similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.lf rename to cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.lf diff --git a/org.lflang/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.stderr b/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.stderr similarity index 100% rename from org.lflang/cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.stderr rename to cli/lfc/src/test/resources/org/lflang/cli/twoLineWarning.stderr diff --git a/org.lflang/cli/lff/build.gradle b/cli/lff/build.gradle similarity index 100% rename from org.lflang/cli/lff/build.gradle rename to cli/lff/build.gradle diff --git a/org.lflang/cli/lff/src/main/java/org/lflang/cli/Lff.java b/cli/lff/src/main/java/org/lflang/cli/Lff.java similarity index 100% rename from org.lflang/cli/lff/src/main/java/org/lflang/cli/Lff.java rename to cli/lff/src/main/java/org/lflang/cli/Lff.java diff --git a/org.lflang/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java b/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java similarity index 100% rename from org.lflang/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java rename to cli/lff/src/test/java/org/lflang/cli/LffCliTest.java diff --git a/org.lflang/core/build.gradle b/core/build.gradle similarity index 100% rename from org.lflang/core/build.gradle rename to core/build.gradle diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/RunSingleTest.java b/core/src/integrationTest/java/org/lflang/tests/RunSingleTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/RunSingleTest.java rename to core/src/integrationTest/java/org/lflang/tests/RunSingleTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java rename to core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/ErrorInserter.java b/core/src/integrationTest/java/org/lflang/tests/lsp/ErrorInserter.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/ErrorInserter.java rename to core/src/integrationTest/java/org/lflang/tests/lsp/ErrorInserter.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java b/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java rename to core/src/integrationTest/java/org/lflang/tests/lsp/LspTests.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/MockLanguageClient.java b/core/src/integrationTest/java/org/lflang/tests/lsp/MockLanguageClient.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/MockLanguageClient.java rename to core/src/integrationTest/java/org/lflang/tests/lsp/MockLanguageClient.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/MockReportProgress.java b/core/src/integrationTest/java/org/lflang/tests/lsp/MockReportProgress.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/lsp/MockReportProgress.java rename to core/src/integrationTest/java/org/lflang/tests/lsp/MockReportProgress.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/CCppTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/CSchedulerTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/CppRos2Test.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java rename to core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java diff --git a/org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java b/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java similarity index 100% rename from org.lflang/core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java rename to core/src/integrationTest/java/org/lflang/tests/serialization/SerializationTest.java diff --git a/org.lflang/core/src/main/java/org/lflang/AttributeUtils.java b/core/src/main/java/org/lflang/AttributeUtils.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/AttributeUtils.java rename to core/src/main/java/org/lflang/AttributeUtils.java diff --git a/org.lflang/core/src/main/java/org/lflang/DefaultErrorReporter.java b/core/src/main/java/org/lflang/DefaultErrorReporter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/DefaultErrorReporter.java rename to core/src/main/java/org/lflang/DefaultErrorReporter.java diff --git a/org.lflang/core/src/main/java/org/lflang/ErrorReporter.java b/core/src/main/java/org/lflang/ErrorReporter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ErrorReporter.java rename to core/src/main/java/org/lflang/ErrorReporter.java diff --git a/org.lflang/core/src/main/java/org/lflang/FileConfig.java b/core/src/main/java/org/lflang/FileConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/FileConfig.java rename to core/src/main/java/org/lflang/FileConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 b/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 rename to core/src/main/java/org/lflang/GenerateLinguaFranca.mwe2 diff --git a/org.lflang/core/src/main/java/org/lflang/InferredType.java b/core/src/main/java/org/lflang/InferredType.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/InferredType.java rename to core/src/main/java/org/lflang/InferredType.java diff --git a/org.lflang/core/src/main/java/org/lflang/LFResourceDescriptionStrategy.java b/core/src/main/java/org/lflang/LFResourceDescriptionStrategy.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/LFResourceDescriptionStrategy.java rename to core/src/main/java/org/lflang/LFResourceDescriptionStrategy.java diff --git a/org.lflang/core/src/main/java/org/lflang/LFResourceProvider.java b/core/src/main/java/org/lflang/LFResourceProvider.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/LFResourceProvider.java rename to core/src/main/java/org/lflang/LFResourceProvider.java diff --git a/org.lflang/core/src/main/java/org/lflang/LFRuntimeModule.java b/core/src/main/java/org/lflang/LFRuntimeModule.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/LFRuntimeModule.java rename to core/src/main/java/org/lflang/LFRuntimeModule.java diff --git a/org.lflang/core/src/main/java/org/lflang/LFStandaloneSetup.java b/core/src/main/java/org/lflang/LFStandaloneSetup.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/LFStandaloneSetup.java rename to core/src/main/java/org/lflang/LFStandaloneSetup.java diff --git a/org.lflang/core/src/main/java/org/lflang/LFSyntaxErrorMessageProvider.java b/core/src/main/java/org/lflang/LFSyntaxErrorMessageProvider.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/LFSyntaxErrorMessageProvider.java rename to core/src/main/java/org/lflang/LFSyntaxErrorMessageProvider.java diff --git a/org.lflang/core/src/main/java/org/lflang/LinguaFranca.xtext b/core/src/main/java/org/lflang/LinguaFranca.xtext similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/LinguaFranca.xtext rename to core/src/main/java/org/lflang/LinguaFranca.xtext diff --git a/org.lflang/core/src/main/java/org/lflang/LocalStrings.java b/core/src/main/java/org/lflang/LocalStrings.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/LocalStrings.java rename to core/src/main/java/org/lflang/LocalStrings.java diff --git a/org.lflang/core/src/main/java/org/lflang/MainConflictChecker.java b/core/src/main/java/org/lflang/MainConflictChecker.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/MainConflictChecker.java rename to core/src/main/java/org/lflang/MainConflictChecker.java diff --git a/org.lflang/core/src/main/java/org/lflang/ModelInfo.java b/core/src/main/java/org/lflang/ModelInfo.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ModelInfo.java rename to core/src/main/java/org/lflang/ModelInfo.java diff --git a/org.lflang/core/src/main/java/org/lflang/Target.java b/core/src/main/java/org/lflang/Target.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/Target.java rename to core/src/main/java/org/lflang/Target.java diff --git a/org.lflang/core/src/main/java/org/lflang/TargetConfig.java b/core/src/main/java/org/lflang/TargetConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/TargetConfig.java rename to core/src/main/java/org/lflang/TargetConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/TargetProperty.java b/core/src/main/java/org/lflang/TargetProperty.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/TargetProperty.java rename to core/src/main/java/org/lflang/TargetProperty.java diff --git a/org.lflang/core/src/main/java/org/lflang/TimeUnit.java b/core/src/main/java/org/lflang/TimeUnit.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/TimeUnit.java rename to core/src/main/java/org/lflang/TimeUnit.java diff --git a/org.lflang/core/src/main/java/org/lflang/TimeValue.java b/core/src/main/java/org/lflang/TimeValue.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/TimeValue.java rename to core/src/main/java/org/lflang/TimeValue.java diff --git a/org.lflang/core/src/main/java/org/lflang/ast/ASTUtils.java b/core/src/main/java/org/lflang/ast/ASTUtils.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/ASTUtils.java rename to core/src/main/java/org/lflang/ast/ASTUtils.java diff --git a/org.lflang/core/src/main/java/org/lflang/ast/AstTransformation.java b/core/src/main/java/org/lflang/ast/AstTransformation.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/AstTransformation.java rename to core/src/main/java/org/lflang/ast/AstTransformation.java diff --git a/org.lflang/core/src/main/java/org/lflang/ast/DelayedConnectionTransformation.java b/core/src/main/java/org/lflang/ast/DelayedConnectionTransformation.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/DelayedConnectionTransformation.java rename to core/src/main/java/org/lflang/ast/DelayedConnectionTransformation.java diff --git a/org.lflang/core/src/main/java/org/lflang/ast/FormattingUtils.java b/core/src/main/java/org/lflang/ast/FormattingUtils.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/FormattingUtils.java rename to core/src/main/java/org/lflang/ast/FormattingUtils.java diff --git a/org.lflang/core/src/main/java/org/lflang/ast/IsEqual.java b/core/src/main/java/org/lflang/ast/IsEqual.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/IsEqual.java rename to core/src/main/java/org/lflang/ast/IsEqual.java diff --git a/org.lflang/core/src/main/java/org/lflang/ast/MalleableString.java b/core/src/main/java/org/lflang/ast/MalleableString.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/MalleableString.java rename to core/src/main/java/org/lflang/ast/MalleableString.java diff --git a/org.lflang/core/src/main/java/org/lflang/ast/ToLf.java b/core/src/main/java/org/lflang/ast/ToLf.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/ToLf.java rename to core/src/main/java/org/lflang/ast/ToLf.java diff --git a/org.lflang/core/src/main/java/org/lflang/ast/ToText.java b/core/src/main/java/org/lflang/ast/ToText.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ast/ToText.java rename to core/src/main/java/org/lflang/ast/ToText.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java b/core/src/main/java/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java rename to core/src/main/java/org/lflang/diagram/synthesis/AbstractSynthesisExtensions.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java b/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java rename to core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java b/core/src/main/java/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java rename to core/src/main/java/org/lflang/diagram/synthesis/ReactorParameterDisplayModes.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/SynthesisRegistration.java b/core/src/main/java/org/lflang/diagram/synthesis/SynthesisRegistration.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/SynthesisRegistration.java rename to core/src/main/java/org/lflang/diagram/synthesis/SynthesisRegistration.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/AbstractAction.java b/core/src/main/java/org/lflang/diagram/synthesis/action/AbstractAction.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/AbstractAction.java rename to core/src/main/java/org/lflang/diagram/synthesis/action/AbstractAction.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java b/core/src/main/java/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java rename to core/src/main/java/org/lflang/diagram/synthesis/action/CollapseAllReactorsAction.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java b/core/src/main/java/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java rename to core/src/main/java/org/lflang/diagram/synthesis/action/ExpandAllReactorsAction.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/FilterCycleAction.java b/core/src/main/java/org/lflang/diagram/synthesis/action/FilterCycleAction.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/FilterCycleAction.java rename to core/src/main/java/org/lflang/diagram/synthesis/action/FilterCycleAction.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java b/core/src/main/java/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java rename to core/src/main/java/org/lflang/diagram/synthesis/action/MemorizingExpandCollapseAction.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/ShowCycleAction.java b/core/src/main/java/org/lflang/diagram/synthesis/action/ShowCycleAction.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/action/ShowCycleAction.java rename to core/src/main/java/org/lflang/diagram/synthesis/action/ShowCycleAction.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java b/core/src/main/java/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java rename to core/src/main/java/org/lflang/diagram/synthesis/postprocessor/ReactionPortAdjustment.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java b/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java rename to core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaShapeExtensions.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java b/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java rename to core/src/main/java/org/lflang/diagram/synthesis/styles/LinguaFrancaStyleExtensions.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java b/core/src/main/java/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java rename to core/src/main/java/org/lflang/diagram/synthesis/styles/ReactorFigureComponents.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/CycleVisualization.java b/core/src/main/java/org/lflang/diagram/synthesis/util/CycleVisualization.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/CycleVisualization.java rename to core/src/main/java/org/lflang/diagram/synthesis/util/CycleVisualization.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java b/core/src/main/java/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java rename to core/src/main/java/org/lflang/diagram/synthesis/util/InterfaceDependenciesVisualization.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java b/core/src/main/java/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java rename to core/src/main/java/org/lflang/diagram/synthesis/util/LayoutPostProcessing.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/ModeDiagrams.java b/core/src/main/java/org/lflang/diagram/synthesis/util/ModeDiagrams.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/ModeDiagrams.java rename to core/src/main/java/org/lflang/diagram/synthesis/util/ModeDiagrams.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java b/core/src/main/java/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java rename to core/src/main/java/org/lflang/diagram/synthesis/util/NamedInstanceUtil.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/ReactorIcons.java b/core/src/main/java/org/lflang/diagram/synthesis/util/ReactorIcons.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/ReactorIcons.java rename to core/src/main/java/org/lflang/diagram/synthesis/util/ReactorIcons.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java b/core/src/main/java/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java rename to core/src/main/java/org/lflang/diagram/synthesis/util/SynthesisErrorReporter.java diff --git a/org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/UtilityExtensions.java b/core/src/main/java/org/lflang/diagram/synthesis/util/UtilityExtensions.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/diagram/synthesis/util/UtilityExtensions.java rename to core/src/main/java/org/lflang/diagram/synthesis/util/UtilityExtensions.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/extensions/CExtension.java b/core/src/main/java/org/lflang/federated/extensions/CExtension.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/extensions/CExtension.java rename to core/src/main/java/org/lflang/federated/extensions/CExtension.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/extensions/CExtensionUtils.java b/core/src/main/java/org/lflang/federated/extensions/CExtensionUtils.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/extensions/CExtensionUtils.java rename to core/src/main/java/org/lflang/federated/extensions/CExtensionUtils.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/extensions/FedTargetExtension.java b/core/src/main/java/org/lflang/federated/extensions/FedTargetExtension.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/extensions/FedTargetExtension.java rename to core/src/main/java/org/lflang/federated/extensions/FedTargetExtension.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/extensions/FedTargetExtensionFactory.java b/core/src/main/java/org/lflang/federated/extensions/FedTargetExtensionFactory.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/extensions/FedTargetExtensionFactory.java rename to core/src/main/java/org/lflang/federated/extensions/FedTargetExtensionFactory.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/extensions/PythonExtension.java b/core/src/main/java/org/lflang/federated/extensions/PythonExtension.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/extensions/PythonExtension.java rename to core/src/main/java/org/lflang/federated/extensions/PythonExtension.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/extensions/TSExtension.java b/core/src/main/java/org/lflang/federated/extensions/TSExtension.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/extensions/TSExtension.java rename to core/src/main/java/org/lflang/federated/extensions/TSExtension.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedASTUtils.java b/core/src/main/java/org/lflang/federated/generator/FedASTUtils.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedASTUtils.java rename to core/src/main/java/org/lflang/federated/generator/FedASTUtils.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedConnectionInstance.java b/core/src/main/java/org/lflang/federated/generator/FedConnectionInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedConnectionInstance.java rename to core/src/main/java/org/lflang/federated/generator/FedConnectionInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedEmitter.java b/core/src/main/java/org/lflang/federated/generator/FedEmitter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedEmitter.java rename to core/src/main/java/org/lflang/federated/generator/FedEmitter.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedFileConfig.java b/core/src/main/java/org/lflang/federated/generator/FedFileConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedFileConfig.java rename to core/src/main/java/org/lflang/federated/generator/FedFileConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedGenerator.java b/core/src/main/java/org/lflang/federated/generator/FedGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedGenerator.java rename to core/src/main/java/org/lflang/federated/generator/FedGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedImportEmitter.java b/core/src/main/java/org/lflang/federated/generator/FedImportEmitter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedImportEmitter.java rename to core/src/main/java/org/lflang/federated/generator/FedImportEmitter.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedMainEmitter.java b/core/src/main/java/org/lflang/federated/generator/FedMainEmitter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedMainEmitter.java rename to core/src/main/java/org/lflang/federated/generator/FedMainEmitter.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedPreambleEmitter.java b/core/src/main/java/org/lflang/federated/generator/FedPreambleEmitter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedPreambleEmitter.java rename to core/src/main/java/org/lflang/federated/generator/FedPreambleEmitter.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedReactorEmitter.java b/core/src/main/java/org/lflang/federated/generator/FedReactorEmitter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedReactorEmitter.java rename to core/src/main/java/org/lflang/federated/generator/FedReactorEmitter.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedTargetConfig.java b/core/src/main/java/org/lflang/federated/generator/FedTargetConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedTargetConfig.java rename to core/src/main/java/org/lflang/federated/generator/FedTargetConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedTargetEmitter.java b/core/src/main/java/org/lflang/federated/generator/FedTargetEmitter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedTargetEmitter.java rename to core/src/main/java/org/lflang/federated/generator/FedTargetEmitter.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FedUtils.java b/core/src/main/java/org/lflang/federated/generator/FedUtils.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FedUtils.java rename to core/src/main/java/org/lflang/federated/generator/FedUtils.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/FederateInstance.java b/core/src/main/java/org/lflang/federated/generator/FederateInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/FederateInstance.java rename to core/src/main/java/org/lflang/federated/generator/FederateInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/LineAdjustingErrorReporter.java b/core/src/main/java/org/lflang/federated/generator/LineAdjustingErrorReporter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/LineAdjustingErrorReporter.java rename to core/src/main/java/org/lflang/federated/generator/LineAdjustingErrorReporter.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/generator/SynchronizedErrorReporter.java b/core/src/main/java/org/lflang/federated/generator/SynchronizedErrorReporter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/generator/SynchronizedErrorReporter.java rename to core/src/main/java/org/lflang/federated/generator/SynchronizedErrorReporter.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/launcher/BuildConfig.java b/core/src/main/java/org/lflang/federated/launcher/BuildConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/launcher/BuildConfig.java rename to core/src/main/java/org/lflang/federated/launcher/BuildConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/launcher/CBuildConfig.java b/core/src/main/java/org/lflang/federated/launcher/CBuildConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/launcher/CBuildConfig.java rename to core/src/main/java/org/lflang/federated/launcher/CBuildConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java b/core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java rename to core/src/main/java/org/lflang/federated/launcher/FedLauncherGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/launcher/PyBuildConfig.java b/core/src/main/java/org/lflang/federated/launcher/PyBuildConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/launcher/PyBuildConfig.java rename to core/src/main/java/org/lflang/federated/launcher/PyBuildConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/launcher/RtiConfig.java b/core/src/main/java/org/lflang/federated/launcher/RtiConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/launcher/RtiConfig.java rename to core/src/main/java/org/lflang/federated/launcher/RtiConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/launcher/TsBuildConfig.java b/core/src/main/java/org/lflang/federated/launcher/TsBuildConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/launcher/TsBuildConfig.java rename to core/src/main/java/org/lflang/federated/launcher/TsBuildConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/serialization/FedNativePythonSerialization.java b/core/src/main/java/org/lflang/federated/serialization/FedNativePythonSerialization.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/serialization/FedNativePythonSerialization.java rename to core/src/main/java/org/lflang/federated/serialization/FedNativePythonSerialization.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/serialization/FedROS2CPPSerialization.java b/core/src/main/java/org/lflang/federated/serialization/FedROS2CPPSerialization.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/serialization/FedROS2CPPSerialization.java rename to core/src/main/java/org/lflang/federated/serialization/FedROS2CPPSerialization.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/serialization/FedSerialization.java b/core/src/main/java/org/lflang/federated/serialization/FedSerialization.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/serialization/FedSerialization.java rename to core/src/main/java/org/lflang/federated/serialization/FedSerialization.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/serialization/SupportedSerializers.java b/core/src/main/java/org/lflang/federated/serialization/SupportedSerializers.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/serialization/SupportedSerializers.java rename to core/src/main/java/org/lflang/federated/serialization/SupportedSerializers.java diff --git a/org.lflang/core/src/main/java/org/lflang/federated/validation/FedValidator.java b/core/src/main/java/org/lflang/federated/validation/FedValidator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/federated/validation/FedValidator.java rename to core/src/main/java/org/lflang/federated/validation/FedValidator.java diff --git a/org.lflang/core/src/main/java/org/lflang/formatting2/LFFormatter.java b/core/src/main/java/org/lflang/formatting2/LFFormatter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/formatting2/LFFormatter.java rename to core/src/main/java/org/lflang/formatting2/LFFormatter.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ActionInstance.java b/core/src/main/java/org/lflang/generator/ActionInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ActionInstance.java rename to core/src/main/java/org/lflang/generator/ActionInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/CodeBuilder.java b/core/src/main/java/org/lflang/generator/CodeBuilder.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/CodeBuilder.java rename to core/src/main/java/org/lflang/generator/CodeBuilder.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/CodeMap.java b/core/src/main/java/org/lflang/generator/CodeMap.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/CodeMap.java rename to core/src/main/java/org/lflang/generator/CodeMap.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/DeadlineInstance.java b/core/src/main/java/org/lflang/generator/DeadlineInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/DeadlineInstance.java rename to core/src/main/java/org/lflang/generator/DeadlineInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/DelayBodyGenerator.java b/core/src/main/java/org/lflang/generator/DelayBodyGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/DelayBodyGenerator.java rename to core/src/main/java/org/lflang/generator/DelayBodyGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/DiagnosticReporting.java b/core/src/main/java/org/lflang/generator/DiagnosticReporting.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/DiagnosticReporting.java rename to core/src/main/java/org/lflang/generator/DiagnosticReporting.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/DockerComposeGenerator.java b/core/src/main/java/org/lflang/generator/DockerComposeGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/DockerComposeGenerator.java rename to core/src/main/java/org/lflang/generator/DockerComposeGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/DockerData.java b/core/src/main/java/org/lflang/generator/DockerData.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/DockerData.java rename to core/src/main/java/org/lflang/generator/DockerData.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/DockerGenerator.java b/core/src/main/java/org/lflang/generator/DockerGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/DockerGenerator.java rename to core/src/main/java/org/lflang/generator/DockerGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/FedDockerComposeGenerator.java b/core/src/main/java/org/lflang/generator/FedDockerComposeGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/FedDockerComposeGenerator.java rename to core/src/main/java/org/lflang/generator/FedDockerComposeGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/GenerationException.java b/core/src/main/java/org/lflang/generator/GenerationException.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/GenerationException.java rename to core/src/main/java/org/lflang/generator/GenerationException.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/GeneratorBase.java b/core/src/main/java/org/lflang/generator/GeneratorBase.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/GeneratorBase.java rename to core/src/main/java/org/lflang/generator/GeneratorBase.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/GeneratorCommandFactory.java b/core/src/main/java/org/lflang/generator/GeneratorCommandFactory.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/GeneratorCommandFactory.java rename to core/src/main/java/org/lflang/generator/GeneratorCommandFactory.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/GeneratorResult.java b/core/src/main/java/org/lflang/generator/GeneratorResult.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/GeneratorResult.java rename to core/src/main/java/org/lflang/generator/GeneratorResult.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/GeneratorUtils.java b/core/src/main/java/org/lflang/generator/GeneratorUtils.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/GeneratorUtils.java rename to core/src/main/java/org/lflang/generator/GeneratorUtils.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/HumanReadableReportingStrategy.java b/core/src/main/java/org/lflang/generator/HumanReadableReportingStrategy.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/HumanReadableReportingStrategy.java rename to core/src/main/java/org/lflang/generator/HumanReadableReportingStrategy.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/IntegratedBuilder.java b/core/src/main/java/org/lflang/generator/IntegratedBuilder.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/IntegratedBuilder.java rename to core/src/main/java/org/lflang/generator/IntegratedBuilder.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/InvalidLfSourceException.java b/core/src/main/java/org/lflang/generator/InvalidLfSourceException.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/InvalidLfSourceException.java rename to core/src/main/java/org/lflang/generator/InvalidLfSourceException.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/InvalidSourceException.java b/core/src/main/java/org/lflang/generator/InvalidSourceException.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/InvalidSourceException.java rename to core/src/main/java/org/lflang/generator/InvalidSourceException.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/LFGenerator.java b/core/src/main/java/org/lflang/generator/LFGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/LFGenerator.java rename to core/src/main/java/org/lflang/generator/LFGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/LFGeneratorContext.java b/core/src/main/java/org/lflang/generator/LFGeneratorContext.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/LFGeneratorContext.java rename to core/src/main/java/org/lflang/generator/LFGeneratorContext.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/LFResource.java b/core/src/main/java/org/lflang/generator/LFResource.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/LFResource.java rename to core/src/main/java/org/lflang/generator/LFResource.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/LanguageServerErrorReporter.java b/core/src/main/java/org/lflang/generator/LanguageServerErrorReporter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/LanguageServerErrorReporter.java rename to core/src/main/java/org/lflang/generator/LanguageServerErrorReporter.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/LfExpressionVisitor.java b/core/src/main/java/org/lflang/generator/LfExpressionVisitor.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/LfExpressionVisitor.java rename to core/src/main/java/org/lflang/generator/LfExpressionVisitor.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/MainContext.java b/core/src/main/java/org/lflang/generator/MainContext.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/MainContext.java rename to core/src/main/java/org/lflang/generator/MainContext.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/MixedRadixInt.java b/core/src/main/java/org/lflang/generator/MixedRadixInt.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/MixedRadixInt.java rename to core/src/main/java/org/lflang/generator/MixedRadixInt.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ModeInstance.java b/core/src/main/java/org/lflang/generator/ModeInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ModeInstance.java rename to core/src/main/java/org/lflang/generator/ModeInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/NamedInstance.java b/core/src/main/java/org/lflang/generator/NamedInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/NamedInstance.java rename to core/src/main/java/org/lflang/generator/NamedInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ParameterInstance.java b/core/src/main/java/org/lflang/generator/ParameterInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ParameterInstance.java rename to core/src/main/java/org/lflang/generator/ParameterInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/PortInstance.java b/core/src/main/java/org/lflang/generator/PortInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/PortInstance.java rename to core/src/main/java/org/lflang/generator/PortInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/Position.java b/core/src/main/java/org/lflang/generator/Position.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/Position.java rename to core/src/main/java/org/lflang/generator/Position.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/Range.java b/core/src/main/java/org/lflang/generator/Range.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/Range.java rename to core/src/main/java/org/lflang/generator/Range.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ReactionInstance.java b/core/src/main/java/org/lflang/generator/ReactionInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ReactionInstance.java rename to core/src/main/java/org/lflang/generator/ReactionInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ReactionInstanceGraph.java b/core/src/main/java/org/lflang/generator/ReactionInstanceGraph.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ReactionInstanceGraph.java rename to core/src/main/java/org/lflang/generator/ReactionInstanceGraph.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ReactorInstance.java b/core/src/main/java/org/lflang/generator/ReactorInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ReactorInstance.java rename to core/src/main/java/org/lflang/generator/ReactorInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/RuntimeRange.java b/core/src/main/java/org/lflang/generator/RuntimeRange.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/RuntimeRange.java rename to core/src/main/java/org/lflang/generator/RuntimeRange.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/SendRange.java b/core/src/main/java/org/lflang/generator/SendRange.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/SendRange.java rename to core/src/main/java/org/lflang/generator/SendRange.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/SubContext.java b/core/src/main/java/org/lflang/generator/SubContext.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/SubContext.java rename to core/src/main/java/org/lflang/generator/SubContext.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/TargetTypes.java b/core/src/main/java/org/lflang/generator/TargetTypes.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/TargetTypes.java rename to core/src/main/java/org/lflang/generator/TargetTypes.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/TimerInstance.java b/core/src/main/java/org/lflang/generator/TimerInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/TimerInstance.java rename to core/src/main/java/org/lflang/generator/TimerInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/TriggerInstance.java b/core/src/main/java/org/lflang/generator/TriggerInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/TriggerInstance.java rename to core/src/main/java/org/lflang/generator/TriggerInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/UnsupportedGeneratorFeatureException.java b/core/src/main/java/org/lflang/generator/UnsupportedGeneratorFeatureException.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/UnsupportedGeneratorFeatureException.java rename to core/src/main/java/org/lflang/generator/UnsupportedGeneratorFeatureException.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ValidationStrategy.java b/core/src/main/java/org/lflang/generator/ValidationStrategy.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ValidationStrategy.java rename to core/src/main/java/org/lflang/generator/ValidationStrategy.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/Validator.java b/core/src/main/java/org/lflang/generator/Validator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/Validator.java rename to core/src/main/java/org/lflang/generator/Validator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/WatchdogInstance.java b/core/src/main/java/org/lflang/generator/WatchdogInstance.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/WatchdogInstance.java rename to core/src/main/java/org/lflang/generator/WatchdogInstance.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CActionGenerator.java b/core/src/main/java/org/lflang/generator/c/CActionGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CActionGenerator.java rename to core/src/main/java/org/lflang/generator/c/CActionGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java b/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java rename to core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CCompiler.java b/core/src/main/java/org/lflang/generator/c/CCompiler.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CCompiler.java rename to core/src/main/java/org/lflang/generator/c/CCompiler.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CConstructorGenerator.java b/core/src/main/java/org/lflang/generator/c/CConstructorGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CConstructorGenerator.java rename to core/src/main/java/org/lflang/generator/c/CConstructorGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CCoreFilesUtils.java b/core/src/main/java/org/lflang/generator/c/CCoreFilesUtils.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CCoreFilesUtils.java rename to core/src/main/java/org/lflang/generator/c/CCoreFilesUtils.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CDelayBodyGenerator.java b/core/src/main/java/org/lflang/generator/c/CDelayBodyGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CDelayBodyGenerator.java rename to core/src/main/java/org/lflang/generator/c/CDelayBodyGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CDockerGenerator.java b/core/src/main/java/org/lflang/generator/c/CDockerGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CDockerGenerator.java rename to core/src/main/java/org/lflang/generator/c/CDockerGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CFileConfig.java b/core/src/main/java/org/lflang/generator/c/CFileConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CFileConfig.java rename to core/src/main/java/org/lflang/generator/c/CFileConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CGenerator.java b/core/src/main/java/org/lflang/generator/c/CGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CGenerator.java rename to core/src/main/java/org/lflang/generator/c/CGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CMainFunctionGenerator.java b/core/src/main/java/org/lflang/generator/c/CMainFunctionGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CMainFunctionGenerator.java rename to core/src/main/java/org/lflang/generator/c/CMainFunctionGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CMethodGenerator.java b/core/src/main/java/org/lflang/generator/c/CMethodGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CMethodGenerator.java rename to core/src/main/java/org/lflang/generator/c/CMethodGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CMixedRadixGenerator.java b/core/src/main/java/org/lflang/generator/c/CMixedRadixGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CMixedRadixGenerator.java rename to core/src/main/java/org/lflang/generator/c/CMixedRadixGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CModesGenerator.java b/core/src/main/java/org/lflang/generator/c/CModesGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CModesGenerator.java rename to core/src/main/java/org/lflang/generator/c/CModesGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CParameterGenerator.java b/core/src/main/java/org/lflang/generator/c/CParameterGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CParameterGenerator.java rename to core/src/main/java/org/lflang/generator/c/CParameterGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CPortGenerator.java b/core/src/main/java/org/lflang/generator/c/CPortGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CPortGenerator.java rename to core/src/main/java/org/lflang/generator/c/CPortGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CPreambleGenerator.java b/core/src/main/java/org/lflang/generator/c/CPreambleGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CPreambleGenerator.java rename to core/src/main/java/org/lflang/generator/c/CPreambleGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CReactionGenerator.java b/core/src/main/java/org/lflang/generator/c/CReactionGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CReactionGenerator.java rename to core/src/main/java/org/lflang/generator/c/CReactionGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CReactorHeaderFileGenerator.java b/core/src/main/java/org/lflang/generator/c/CReactorHeaderFileGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CReactorHeaderFileGenerator.java rename to core/src/main/java/org/lflang/generator/c/CReactorHeaderFileGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CStateGenerator.java b/core/src/main/java/org/lflang/generator/c/CStateGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CStateGenerator.java rename to core/src/main/java/org/lflang/generator/c/CStateGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CTimerGenerator.java b/core/src/main/java/org/lflang/generator/c/CTimerGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CTimerGenerator.java rename to core/src/main/java/org/lflang/generator/c/CTimerGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CTracingGenerator.java b/core/src/main/java/org/lflang/generator/c/CTracingGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CTracingGenerator.java rename to core/src/main/java/org/lflang/generator/c/CTracingGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CTriggerObjectsGenerator.java b/core/src/main/java/org/lflang/generator/c/CTriggerObjectsGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CTriggerObjectsGenerator.java rename to core/src/main/java/org/lflang/generator/c/CTriggerObjectsGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CTypes.java b/core/src/main/java/org/lflang/generator/c/CTypes.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CTypes.java rename to core/src/main/java/org/lflang/generator/c/CTypes.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CUtil.java b/core/src/main/java/org/lflang/generator/c/CUtil.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CUtil.java rename to core/src/main/java/org/lflang/generator/c/CUtil.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/CWatchdogGenerator.java b/core/src/main/java/org/lflang/generator/c/CWatchdogGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/CWatchdogGenerator.java rename to core/src/main/java/org/lflang/generator/c/CWatchdogGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/InteractingContainedReactors.java b/core/src/main/java/org/lflang/generator/c/InteractingContainedReactors.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/InteractingContainedReactors.java rename to core/src/main/java/org/lflang/generator/c/InteractingContainedReactors.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java rename to core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PyFileConfig.java b/core/src/main/java/org/lflang/generator/python/PyFileConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PyFileConfig.java rename to core/src/main/java/org/lflang/generator/python/PyFileConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PyUtil.java b/core/src/main/java/org/lflang/generator/python/PyUtil.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PyUtil.java rename to core/src/main/java/org/lflang/generator/python/PyUtil.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonActionGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonActionGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonActionGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonActionGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonDelayBodyGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonDelayBodyGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonDelayBodyGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonDelayBodyGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonDockerGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonDockerGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonDockerGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonDockerGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonInfoGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonInfoGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonInfoGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonInfoGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonMainFunctionGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonMainFunctionGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonMainFunctionGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonMainFunctionGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonMethodGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonMethodGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonMethodGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonMethodGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonModeGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonModeGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonModeGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonModeGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonParameterGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonParameterGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonParameterGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonParameterGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonPortGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonPortGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonPortGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonPortGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonPreambleGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonPreambleGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonPreambleGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonPreambleGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonReactionGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonReactionGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonReactionGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonReactionGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonReactorGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonReactorGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonReactorGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonReactorGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonStateGenerator.java b/core/src/main/java/org/lflang/generator/python/PythonStateGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonStateGenerator.java rename to core/src/main/java/org/lflang/generator/python/PythonStateGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonTypes.java b/core/src/main/java/org/lflang/generator/python/PythonTypes.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonTypes.java rename to core/src/main/java/org/lflang/generator/python/PythonTypes.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/python/PythonValidator.java b/core/src/main/java/org/lflang/generator/python/PythonValidator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/python/PythonValidator.java rename to core/src/main/java/org/lflang/generator/python/PythonValidator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/CargoDependencySpec.java b/core/src/main/java/org/lflang/generator/rust/CargoDependencySpec.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/CargoDependencySpec.java rename to core/src/main/java/org/lflang/generator/rust/CargoDependencySpec.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/rust/RustTargetConfig.java b/core/src/main/java/org/lflang/generator/rust/RustTargetConfig.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/rust/RustTargetConfig.java rename to core/src/main/java/org/lflang/generator/rust/RustTargetConfig.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSDockerGenerator.java b/core/src/main/java/org/lflang/generator/ts/TSDockerGenerator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSDockerGenerator.java rename to core/src/main/java/org/lflang/generator/ts/TSDockerGenerator.java diff --git a/org.lflang/core/src/main/java/org/lflang/generator/ts/TSTypes.java b/core/src/main/java/org/lflang/generator/ts/TSTypes.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/generator/ts/TSTypes.java rename to core/src/main/java/org/lflang/generator/ts/TSTypes.java diff --git a/org.lflang/core/src/main/java/org/lflang/graph/DirectedGraph.java b/core/src/main/java/org/lflang/graph/DirectedGraph.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/graph/DirectedGraph.java rename to core/src/main/java/org/lflang/graph/DirectedGraph.java diff --git a/org.lflang/core/src/main/java/org/lflang/graph/Graph.java b/core/src/main/java/org/lflang/graph/Graph.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/graph/Graph.java rename to core/src/main/java/org/lflang/graph/Graph.java diff --git a/org.lflang/core/src/main/java/org/lflang/graph/InstantiationGraph.java b/core/src/main/java/org/lflang/graph/InstantiationGraph.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/graph/InstantiationGraph.java rename to core/src/main/java/org/lflang/graph/InstantiationGraph.java diff --git a/org.lflang/core/src/main/java/org/lflang/graph/NodeAnnotation.java b/core/src/main/java/org/lflang/graph/NodeAnnotation.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/graph/NodeAnnotation.java rename to core/src/main/java/org/lflang/graph/NodeAnnotation.java diff --git a/org.lflang/core/src/main/java/org/lflang/graph/NodeAnnotations.java b/core/src/main/java/org/lflang/graph/NodeAnnotations.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/graph/NodeAnnotations.java rename to core/src/main/java/org/lflang/graph/NodeAnnotations.java diff --git a/org.lflang/core/src/main/java/org/lflang/graph/PrecedenceGraph.java b/core/src/main/java/org/lflang/graph/PrecedenceGraph.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/graph/PrecedenceGraph.java rename to core/src/main/java/org/lflang/graph/PrecedenceGraph.java diff --git a/org.lflang/core/src/main/java/org/lflang/graph/TopologyGraph.java b/core/src/main/java/org/lflang/graph/TopologyGraph.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/graph/TopologyGraph.java rename to core/src/main/java/org/lflang/graph/TopologyGraph.java diff --git a/org.lflang/core/src/main/java/org/lflang/ide/LFIdeModule.java b/core/src/main/java/org/lflang/ide/LFIdeModule.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ide/LFIdeModule.java rename to core/src/main/java/org/lflang/ide/LFIdeModule.java diff --git a/org.lflang/core/src/main/java/org/lflang/ide/LFIdeSetup.java b/core/src/main/java/org/lflang/ide/LFIdeSetup.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/ide/LFIdeSetup.java rename to core/src/main/java/org/lflang/ide/LFIdeSetup.java diff --git a/org.lflang/core/src/main/java/org/lflang/scoping/LFGlobalScopeProvider.java b/core/src/main/java/org/lflang/scoping/LFGlobalScopeProvider.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/scoping/LFGlobalScopeProvider.java rename to core/src/main/java/org/lflang/scoping/LFGlobalScopeProvider.java diff --git a/org.lflang/core/src/main/java/org/lflang/scoping/LFScopeProvider.java b/core/src/main/java/org/lflang/scoping/LFScopeProvider.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/scoping/LFScopeProvider.java rename to core/src/main/java/org/lflang/scoping/LFScopeProvider.java diff --git a/org.lflang/core/src/main/java/org/lflang/scoping/LFScopeProviderImpl.java b/core/src/main/java/org/lflang/scoping/LFScopeProviderImpl.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/scoping/LFScopeProviderImpl.java rename to core/src/main/java/org/lflang/scoping/LFScopeProviderImpl.java diff --git a/org.lflang/core/src/main/java/org/lflang/util/ArduinoUtil.java b/core/src/main/java/org/lflang/util/ArduinoUtil.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/util/ArduinoUtil.java rename to core/src/main/java/org/lflang/util/ArduinoUtil.java diff --git a/org.lflang/core/src/main/java/org/lflang/util/Averager.java b/core/src/main/java/org/lflang/util/Averager.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/util/Averager.java rename to core/src/main/java/org/lflang/util/Averager.java diff --git a/org.lflang/core/src/main/java/org/lflang/util/CollectionUtil.java b/core/src/main/java/org/lflang/util/CollectionUtil.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/util/CollectionUtil.java rename to core/src/main/java/org/lflang/util/CollectionUtil.java diff --git a/org.lflang/core/src/main/java/org/lflang/util/FileUtil.java b/core/src/main/java/org/lflang/util/FileUtil.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/util/FileUtil.java rename to core/src/main/java/org/lflang/util/FileUtil.java diff --git a/org.lflang/core/src/main/java/org/lflang/util/IteratorUtil.java b/core/src/main/java/org/lflang/util/IteratorUtil.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/util/IteratorUtil.java rename to core/src/main/java/org/lflang/util/IteratorUtil.java diff --git a/org.lflang/core/src/main/java/org/lflang/util/LFCommand.java b/core/src/main/java/org/lflang/util/LFCommand.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/util/LFCommand.java rename to core/src/main/java/org/lflang/util/LFCommand.java diff --git a/org.lflang/core/src/main/java/org/lflang/util/StringUtil.java b/core/src/main/java/org/lflang/util/StringUtil.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/util/StringUtil.java rename to core/src/main/java/org/lflang/util/StringUtil.java diff --git a/org.lflang/core/src/main/java/org/lflang/util/TargetResourceNotFoundException.java b/core/src/main/java/org/lflang/util/TargetResourceNotFoundException.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/util/TargetResourceNotFoundException.java rename to core/src/main/java/org/lflang/util/TargetResourceNotFoundException.java diff --git a/org.lflang/core/src/main/java/org/lflang/validation/AttributeSpec.java b/core/src/main/java/org/lflang/validation/AttributeSpec.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/validation/AttributeSpec.java rename to core/src/main/java/org/lflang/validation/AttributeSpec.java diff --git a/org.lflang/core/src/main/java/org/lflang/validation/BaseLFValidator.java b/core/src/main/java/org/lflang/validation/BaseLFValidator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/validation/BaseLFValidator.java rename to core/src/main/java/org/lflang/validation/BaseLFValidator.java diff --git a/org.lflang/core/src/main/java/org/lflang/validation/LFNamesAreUniqueValidationHelper.java b/core/src/main/java/org/lflang/validation/LFNamesAreUniqueValidationHelper.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/validation/LFNamesAreUniqueValidationHelper.java rename to core/src/main/java/org/lflang/validation/LFNamesAreUniqueValidationHelper.java diff --git a/org.lflang/core/src/main/java/org/lflang/validation/LFValidator.java b/core/src/main/java/org/lflang/validation/LFValidator.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/validation/LFValidator.java rename to core/src/main/java/org/lflang/validation/LFValidator.java diff --git a/org.lflang/core/src/main/java/org/lflang/validation/ValidatorErrorReporter.java b/core/src/main/java/org/lflang/validation/ValidatorErrorReporter.java similarity index 100% rename from org.lflang/core/src/main/java/org/lflang/validation/ValidatorErrorReporter.java rename to core/src/main/java/org/lflang/validation/ValidatorErrorReporter.java diff --git a/org.lflang/core/src/main/kotlin/org/lflang/CommonExtensions.kt b/core/src/main/kotlin/org/lflang/CommonExtensions.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/CommonExtensions.kt rename to core/src/main/kotlin/org/lflang/CommonExtensions.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/FileConfigExtensions.kt b/core/src/main/kotlin/org/lflang/FileConfigExtensions.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/FileConfigExtensions.kt rename to core/src/main/kotlin/org/lflang/FileConfigExtensions.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/ast/AstExtensions.kt b/core/src/main/kotlin/org/lflang/ast/AstExtensions.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/ast/AstExtensions.kt rename to core/src/main/kotlin/org/lflang/ast/AstExtensions.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/GeneratorExtensions.kt b/core/src/main/kotlin/org/lflang/generator/GeneratorExtensions.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/GeneratorExtensions.kt rename to core/src/main/kotlin/org/lflang/generator/GeneratorExtensions.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/GeneratorUtils.kt b/core/src/main/kotlin/org/lflang/generator/GeneratorUtils.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/GeneratorUtils.kt rename to core/src/main/kotlin/org/lflang/generator/GeneratorUtils.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/LanguageRuntimeVersions.kt b/core/src/main/kotlin/org/lflang/generator/LanguageRuntimeVersions.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/LanguageRuntimeVersions.kt rename to core/src/main/kotlin/org/lflang/generator/LanguageRuntimeVersions.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppActionGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppActionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppActionGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppActionGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppConnectionGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppConnectionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppConnectionGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppConnectionGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppExtensions.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppExtensions.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppExtensions.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppExtensions.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppFileConfig.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppFileConfig.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppFileConfig.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppFileConfig.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppInstanceGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppInstanceGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppInstanceGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppInstanceGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppMethodGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppMethodGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppMethodGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppMethodGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppParameterGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppParameterGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppParameterGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppParameterGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPlatformGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppPlatformGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPlatformGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppPlatformGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPortGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppPortGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPortGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppPortGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPreambleGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppPreambleGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppPreambleGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppPreambleGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppReactionGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppReactionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppReactionGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppReactionGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppReactorGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppReactorGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppReactorGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppReactorGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2Generator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2Generator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2Generator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppRos2Generator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2NodeGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2NodeGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2NodeGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppRos2NodeGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2PackageGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2PackageGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppRos2PackageGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppRos2PackageGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneCmakeGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppStandaloneMainGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStateGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppStateGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppStateGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppStateGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppTimerGenerator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppTimerGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppTimerGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppTimerGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppTypes.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppTypes.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppTypes.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppTypes.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppValidator.kt b/core/src/main/kotlin/org/lflang/generator/cpp/CppValidator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/cpp/CppValidator.kt rename to core/src/main/kotlin/org/lflang/generator/cpp/CppValidator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/PortEmitter.kt b/core/src/main/kotlin/org/lflang/generator/rust/PortEmitter.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/PortEmitter.kt rename to core/src/main/kotlin/org/lflang/generator/rust/PortEmitter.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustCargoTomlEmitter.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustCargoTomlEmitter.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustCargoTomlEmitter.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustCargoTomlEmitter.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustEmitter.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustEmitter.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustEmitter.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustEmitter.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustEmitterBase.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustEmitterBase.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustEmitterBase.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustEmitterBase.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustFileConfig.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustFileConfig.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustFileConfig.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustFileConfig.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustGenerator.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustMainFileEmitter.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustMainFileEmitter.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustMainFileEmitter.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustMainFileEmitter.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustModel.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustModel.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustModel.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustModel.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustReactorEmitter.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustReactorEmitter.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustReactorEmitter.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustReactorEmitter.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustTypes.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustTypes.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustTypes.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustTypes.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustValidator.kt b/core/src/main/kotlin/org/lflang/generator/rust/RustValidator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/rust/RustValidator.kt rename to core/src/main/kotlin/org/lflang/generator/rust/RustValidator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSActionGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSActionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSActionGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSActionGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSConnectionGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSConnectionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSConnectionGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSConnectionGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSConstructorGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSConstructorGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSConstructorGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSConstructorGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSDelayBodyGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSDelayBodyGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSDelayBodyGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSDelayBodyGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSExtensions.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSExtensions.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSExtensions.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSExtensions.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSFileConfig.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSFileConfig.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSFileConfig.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSFileConfig.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSImportPreambleGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSImportPreambleGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSImportPreambleGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSImportPreambleGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSInstanceGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSInstanceGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSInstanceGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSInstanceGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSParameterGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSParameterGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSParameterGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSParameterGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSParameterPreambleGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSParameterPreambleGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSParameterPreambleGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSParameterPreambleGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSPortGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSPortGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSPortGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSPortGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSReactionGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSReactionGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSReactionGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSReactionGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSReactorGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSReactorGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSReactorGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSReactorGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSStateGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSStateGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSStateGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSStateGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSTimerGenerator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSTimerGenerator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSTimerGenerator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSTimerGenerator.kt diff --git a/org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSValidator.kt b/core/src/main/kotlin/org/lflang/generator/ts/TSValidator.kt similarity index 100% rename from org.lflang/core/src/main/kotlin/org/lflang/generator/ts/TSValidator.kt rename to core/src/main/kotlin/org/lflang/generator/ts/TSValidator.kt diff --git a/org.lflang/core/src/main/resources/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook b/core/src/main/resources/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook similarity index 100% rename from org.lflang/core/src/main/resources/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook rename to core/src/main/resources/META-INF/services/de.cau.cs.kieler.klighd.IKlighdStartupHook diff --git a/org.lflang/core/src/main/resources/lib/c/reactor-c b/core/src/main/resources/lib/c/reactor-c similarity index 100% rename from org.lflang/core/src/main/resources/lib/c/reactor-c rename to core/src/main/resources/lib/c/reactor-c diff --git a/org.lflang/core/src/main/resources/lib/cpp/3rd-party/cxxopts.hpp b/core/src/main/resources/lib/cpp/3rd-party/cxxopts.hpp similarity index 100% rename from org.lflang/core/src/main/resources/lib/cpp/3rd-party/cxxopts.hpp rename to core/src/main/resources/lib/cpp/3rd-party/cxxopts.hpp diff --git a/org.lflang/core/src/main/resources/lib/cpp/lfutil.hh b/core/src/main/resources/lib/cpp/lfutil.hh similarity index 100% rename from org.lflang/core/src/main/resources/lib/cpp/lfutil.hh rename to core/src/main/resources/lib/cpp/lfutil.hh diff --git a/org.lflang/core/src/main/resources/lib/cpp/reactor-cpp b/core/src/main/resources/lib/cpp/reactor-cpp similarity index 100% rename from org.lflang/core/src/main/resources/lib/cpp/reactor-cpp rename to core/src/main/resources/lib/cpp/reactor-cpp diff --git a/org.lflang/core/src/main/resources/lib/cpp/time_parser.hh b/core/src/main/resources/lib/cpp/time_parser.hh similarity index 100% rename from org.lflang/core/src/main/resources/lib/cpp/time_parser.hh rename to core/src/main/resources/lib/cpp/time_parser.hh diff --git a/org.lflang/core/src/main/resources/lib/platform/zephyr/Kconfig b/core/src/main/resources/lib/platform/zephyr/Kconfig similarity index 100% rename from org.lflang/core/src/main/resources/lib/platform/zephyr/Kconfig rename to core/src/main/resources/lib/platform/zephyr/Kconfig diff --git a/org.lflang/core/src/main/resources/lib/platform/zephyr/boards/esp32.overlay b/core/src/main/resources/lib/platform/zephyr/boards/esp32.overlay similarity index 100% rename from org.lflang/core/src/main/resources/lib/platform/zephyr/boards/esp32.overlay rename to core/src/main/resources/lib/platform/zephyr/boards/esp32.overlay diff --git a/org.lflang/core/src/main/resources/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf b/core/src/main/resources/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf similarity index 100% rename from org.lflang/core/src/main/resources/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf rename to core/src/main/resources/lib/platform/zephyr/boards/nrf52dk_nrf52832_lf.conf diff --git a/org.lflang/core/src/main/resources/lib/platform/zephyr/prj_lf.conf b/core/src/main/resources/lib/platform/zephyr/prj_lf.conf similarity index 100% rename from org.lflang/core/src/main/resources/lib/platform/zephyr/prj_lf.conf rename to core/src/main/resources/lib/platform/zephyr/prj_lf.conf diff --git a/org.lflang/core/src/main/resources/lib/py/lf-python-support b/core/src/main/resources/lib/py/lf-python-support similarity index 100% rename from org.lflang/core/src/main/resources/lib/py/lf-python-support rename to core/src/main/resources/lib/py/lf-python-support diff --git a/org.lflang/core/src/main/resources/lib/rs/reactor-rs b/core/src/main/resources/lib/rs/reactor-rs similarity index 100% rename from org.lflang/core/src/main/resources/lib/rs/reactor-rs rename to core/src/main/resources/lib/rs/reactor-rs diff --git a/org.lflang/core/src/main/resources/lib/rs/runtime-version.properties b/core/src/main/resources/lib/rs/runtime-version.properties similarity index 100% rename from org.lflang/core/src/main/resources/lib/rs/runtime-version.properties rename to core/src/main/resources/lib/rs/runtime-version.properties diff --git a/org.lflang/core/src/main/resources/lib/ts/.eslintrc.json b/core/src/main/resources/lib/ts/.eslintrc.json similarity index 100% rename from org.lflang/core/src/main/resources/lib/ts/.eslintrc.json rename to core/src/main/resources/lib/ts/.eslintrc.json diff --git a/org.lflang/core/src/main/resources/lib/ts/README.md b/core/src/main/resources/lib/ts/README.md similarity index 100% rename from org.lflang/core/src/main/resources/lib/ts/README.md rename to core/src/main/resources/lib/ts/README.md diff --git a/org.lflang/core/src/main/resources/lib/ts/package.json b/core/src/main/resources/lib/ts/package.json similarity index 100% rename from org.lflang/core/src/main/resources/lib/ts/package.json rename to core/src/main/resources/lib/ts/package.json diff --git a/org.lflang/core/src/main/resources/lib/ts/tsconfig.json b/core/src/main/resources/lib/ts/tsconfig.json similarity index 100% rename from org.lflang/core/src/main/resources/lib/ts/tsconfig.json rename to core/src/main/resources/lib/ts/tsconfig.json diff --git a/org.lflang/core/src/main/resources/org/lflang/StringsBundle.properties b/core/src/main/resources/org/lflang/StringsBundle.properties similarity index 100% rename from org.lflang/core/src/main/resources/org/lflang/StringsBundle.properties rename to core/src/main/resources/org/lflang/StringsBundle.properties diff --git a/org.lflang/core/src/test/java/org/lflang/tests/LFParsingTest.java b/core/src/test/java/org/lflang/tests/LFParsingTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/LFParsingTest.java rename to core/src/test/java/org/lflang/tests/LFParsingTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/LfParsingUtil.java b/core/src/test/java/org/lflang/tests/LfParsingUtil.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/LfParsingUtil.java rename to core/src/test/java/org/lflang/tests/LfParsingUtil.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/EquivalenceUnitTests.java b/core/src/test/java/org/lflang/tests/compiler/EquivalenceUnitTests.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/EquivalenceUnitTests.java rename to core/src/test/java/org/lflang/tests/compiler/EquivalenceUnitTests.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/FormattingUnitTests.java b/core/src/test/java/org/lflang/tests/compiler/FormattingUnitTests.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/FormattingUnitTests.java rename to core/src/test/java/org/lflang/tests/compiler/FormattingUnitTests.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/LetInferenceTests.java b/core/src/test/java/org/lflang/tests/compiler/LetInferenceTests.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/LetInferenceTests.java rename to core/src/test/java/org/lflang/tests/compiler/LetInferenceTests.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java b/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java rename to core/src/test/java/org/lflang/tests/compiler/LinguaFrancaASTUtilsTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java b/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java rename to core/src/test/java/org/lflang/tests/compiler/LinguaFrancaDependencyAnalysisTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaParsingTest.java b/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaParsingTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaParsingTest.java rename to core/src/test/java/org/lflang/tests/compiler/LinguaFrancaParsingTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaScopingTest.java b/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaScopingTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaScopingTest.java rename to core/src/test/java/org/lflang/tests/compiler/LinguaFrancaScopingTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaValidationTest.java b/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaValidationTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/LinguaFrancaValidationTest.java rename to core/src/test/java/org/lflang/tests/compiler/LinguaFrancaValidationTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/MixedRadixIntTest.java b/core/src/test/java/org/lflang/tests/compiler/MixedRadixIntTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/MixedRadixIntTest.java rename to core/src/test/java/org/lflang/tests/compiler/MixedRadixIntTest.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/PortInstanceTests.java b/core/src/test/java/org/lflang/tests/compiler/PortInstanceTests.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/PortInstanceTests.java rename to core/src/test/java/org/lflang/tests/compiler/PortInstanceTests.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/RangeTests.java b/core/src/test/java/org/lflang/tests/compiler/RangeTests.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/RangeTests.java rename to core/src/test/java/org/lflang/tests/compiler/RangeTests.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/RoundTripTests.java b/core/src/test/java/org/lflang/tests/compiler/RoundTripTests.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/RoundTripTests.java rename to core/src/test/java/org/lflang/tests/compiler/RoundTripTests.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java b/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java rename to core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java diff --git a/org.lflang/core/src/test/java/org/lflang/tests/util/StringUtilTest.java b/core/src/test/java/org/lflang/tests/util/StringUtilTest.java similarity index 100% rename from org.lflang/core/src/test/java/org/lflang/tests/util/StringUtilTest.java rename to core/src/test/java/org/lflang/tests/util/StringUtilTest.java diff --git a/org.lflang/core/src/testFixtures/java/org/lflang/tests/Configurators.java b/core/src/testFixtures/java/org/lflang/tests/Configurators.java similarity index 100% rename from org.lflang/core/src/testFixtures/java/org/lflang/tests/Configurators.java rename to core/src/testFixtures/java/org/lflang/tests/Configurators.java diff --git a/org.lflang/core/src/testFixtures/java/org/lflang/tests/LFTest.java b/core/src/testFixtures/java/org/lflang/tests/LFTest.java similarity index 100% rename from org.lflang/core/src/testFixtures/java/org/lflang/tests/LFTest.java rename to core/src/testFixtures/java/org/lflang/tests/LFTest.java diff --git a/org.lflang/core/src/testFixtures/java/org/lflang/tests/TestBase.java b/core/src/testFixtures/java/org/lflang/tests/TestBase.java similarity index 100% rename from org.lflang/core/src/testFixtures/java/org/lflang/tests/TestBase.java rename to core/src/testFixtures/java/org/lflang/tests/TestBase.java diff --git a/org.lflang/core/src/testFixtures/java/org/lflang/tests/TestError.java b/core/src/testFixtures/java/org/lflang/tests/TestError.java similarity index 100% rename from org.lflang/core/src/testFixtures/java/org/lflang/tests/TestError.java rename to core/src/testFixtures/java/org/lflang/tests/TestError.java diff --git a/org.lflang/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java b/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java similarity index 100% rename from org.lflang/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java rename to core/src/testFixtures/java/org/lflang/tests/TestRegistry.java diff --git a/org.lflang/lsp/build.gradle b/lsp/build.gradle similarity index 100% rename from org.lflang/lsp/build.gradle rename to lsp/build.gradle diff --git a/org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java b/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java similarity index 100% rename from org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java rename to lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServer.java diff --git a/org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java b/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java similarity index 100% rename from org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java rename to lsp/src/main/java/org/lflang/diagram/lsp/LFLanguageServerExtension.java diff --git a/org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java b/lsp/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java similarity index 100% rename from org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java rename to lsp/src/main/java/org/lflang/diagram/lsp/LanguageDiagramServer.java diff --git a/org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/Progress.java b/lsp/src/main/java/org/lflang/diagram/lsp/Progress.java similarity index 100% rename from org.lflang/lsp/src/main/java/org/lflang/diagram/lsp/Progress.java rename to lsp/src/main/java/org/lflang/diagram/lsp/Progress.java diff --git a/org.lflang/todo/log4j.xml b/todo/log4j.xml similarity index 100% rename from org.lflang/todo/log4j.xml rename to todo/log4j.xml From 4f76a43cebb1315ab95fe6695f0c4d95054e5724 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 10:24:21 +0200 Subject: [PATCH 618/709] adjust all path references --- build.gradle | 18 +++++++++--------- .../src/main/java/lfformat/LfFormatStep.java | 1 - cli/base/build.gradle | 2 +- cli/lfc/build.gradle | 4 ++-- .../org/lflang/cli/LfcIssueReportingTest.kt | 2 +- cli/lff/build.gradle | 4 ++-- core/build.gradle | 2 +- lsp/build.gradle | 2 +- settings.gradle | 2 +- test/README.md | 4 ++-- util/scripts/launch.ps1 | 4 ++-- util/scripts/launch.sh | 4 ++-- 12 files changed, 24 insertions(+), 25 deletions(-) diff --git a/build.gradle b/build.gradle index e4039064f0..473bfb60f7 100644 --- a/build.gradle +++ b/build.gradle @@ -29,8 +29,8 @@ spotless { } // Make the LF formatting task depend on lff -spotlessLinguaFranca.dependsOn('org.lflang:cli:lff:installDist') -spotlessLinguaFranca.inputs.files(tasks.getByPath('org.lflang:cli:lff:installDist').outputs) +spotlessLinguaFranca.dependsOn('cli:lff:installDist') +spotlessLinguaFranca.inputs.files(tasks.getByPath('cli:lff:installDist').outputs) distributions { clitools { @@ -41,8 +41,8 @@ distributions { distributionClassifier = 'nightly-' + formattedDate } contents { - from tasks.getByPath(':org.lflang:cli:lfc:installDist').outputs - from tasks.getByPath(':org.lflang:cli:lff:installDist').outputs + from tasks.getByPath('cli:lfc:installDist').outputs + from tasks.getByPath('cli:lff:installDist').outputs duplicatesStrategy = DuplicatesStrategy.EXCLUDE } } @@ -53,22 +53,22 @@ assemble.dependsOn('installDist') // Alias tasks for simpler access tasks.register('runLfc', JavaExec) { - dependsOn('org.lflang:cli:lfc:run') + dependsOn('cli:lfc:run') } tasks.register('runLff', JavaExec) { - dependsOn('org.lflang:cli:lff:run') + dependsOn('cli:lff:run') } tasks.register('targetTest') { if (!project.hasProperty('target')) { - def testFiles = rootProject.fileTree("${rootProject.rootDir}/org.lflang/core/src/integrationTest/java/org/lflang/tests/runtime").files + def testFiles = rootProject.fileTree("${rootProject.rootDir}/core/src/integrationTest/java/org/lflang/tests/runtime").files def targets = testFiles.collect {it.getName().substring(0, it.getName().length() - 9);} throw new GradleException("Please set the \'target\' project property using -Ptarget=<...>. You may chose any of $targets") } - finalizedBy('org.lflang:core:integrationTest') + finalizedBy('core:integrationTest') } tasks.register('singleTest') { if (System.getProperty('singleTest') == null) { throw new GradleException('Please set the \'singleTest\' system property using -DsingleTest=<...> to specify the LF test file that you would like to run.') } - finalizedBy('org.lflang:core:integrationTest') + finalizedBy('core:integrationTest') } diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index 92489acbfc..b466dd702c 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -67,7 +67,6 @@ private static void initializeFormatter() throws IOException { if (formatter != null) return; final Path lffPath = Path.of( - "org.lflang", "cli", "lff", "build", diff --git a/cli/base/build.gradle b/cli/base/build.gradle index 74939fc8f5..895094fcad 100644 --- a/cli/base/build.gradle +++ b/cli/base/build.gradle @@ -6,5 +6,5 @@ plugins { dependencies { api "info.picocli:picocli:$picocliVersion" - api project(':org.lflang:core') + api project('core') } diff --git a/cli/lfc/build.gradle b/cli/lfc/build.gradle index 9af526e579..6a2d65f73c 100644 --- a/cli/lfc/build.gradle +++ b/cli/lfc/build.gradle @@ -4,9 +4,9 @@ plugins { } dependencies { - implementation project(':org.lflang:cli:base') + implementation project('cli:base') - testImplementation(testFixtures(project(":org.lflang:cli:base"))) + testImplementation(testFixtures(project("cli:base"))) } application { diff --git a/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt b/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt index 44a85a13df..c2839673be 100644 --- a/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt +++ b/cli/lfc/src/test/kotlin/org/lflang/cli/LfcIssueReportingTest.kt @@ -120,7 +120,7 @@ class LfcIssueReportingTest { val packageName = loader.packageName.replace('.', '/') // relative to root of gradle project // TODO This should load the resources and copy them to a temp directory instead of reading directly - val basePath = "org.lflang/cli/lfc/src/test/resources/$packageName/" + val basePath = "cli/lfc/src/test/resources/$packageName/" val lfFile = Paths.get("$basePath/$fileBaseName.lf") val expectedPath = Paths.get("$basePath/$fileBaseName.stderr") diff --git a/cli/lff/build.gradle b/cli/lff/build.gradle index 65d35a21c2..ed44366e9b 100644 --- a/cli/lff/build.gradle +++ b/cli/lff/build.gradle @@ -3,9 +3,9 @@ plugins { } dependencies { - implementation project(':org.lflang:cli:base') + implementation project('cli:base') - testImplementation(testFixtures(project(":org.lflang:cli:base"))) + testImplementation(testFixtures(project("cli:base"))) testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" diff --git a/core/build.gradle b/core/build.gradle index 536bed337d..59b91d3674 100644 --- a/core/build.gradle +++ b/core/build.gradle @@ -104,7 +104,7 @@ tasks.register('getSubmoduleVersions', Exec) { outputs.file(outputFile) doLast { - def matcher = standardOutput.toString() =~ ~"(?m)^[-+ ]?([0-9a-f]+) org.lflang/core/src/main/resources/lib/\\w+/reactor-([-a-zA-Z]+)" + def matcher = standardOutput.toString() =~ ~"(?m)^[-+ ]?([0-9a-f]+) core/src/main/resources/lib/\\w+/reactor-([-a-zA-Z]+)" def properties = new StringBuilder() while (matcher.find()) { def rev = matcher.group(1) diff --git a/lsp/build.gradle b/lsp/build.gradle index 4ba85dbff1..8b8d043b1c 100644 --- a/lsp/build.gradle +++ b/lsp/build.gradle @@ -3,7 +3,7 @@ plugins { } dependencies { - implementation project(':org.lflang:core') + implementation project('core') implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:$klighdVersion") { exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' diff --git a/settings.gradle b/settings.gradle index 5c1d32d3eb..b7b8588ae0 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,2 +1,2 @@ rootProject.name = 'org.lflang' -include(':org.lflang:core', ':org.lflang:lsp', ':org.lflang:cli:base', ':org.lflang:cli:lfc', ':org.lflang:cli:lff') +include('core', 'lsp', 'cli:base', 'cli:lfc', 'cli:lff') diff --git a/test/README.md b/test/README.md index e06450984d..ef6ec66001 100644 --- a/test/README.md +++ b/test/README.md @@ -12,7 +12,7 @@ You can specify any valid target. If you run the task without specifying the tar The `targetTest` task is essentially a convenient shortcut for the following: ``` -./gradew org.lflang:core:integrationTest --test org.lflang.tests.runtime.Test.* +./gradew core:integrationTest --test org.lflang.tests.runtime.Test.* ``` If you prefer have more control over which tests are executed, you can also use this more verbose version. @@ -25,7 +25,7 @@ It is also possible to run a subset of the tests. For example, the C tests are o To invoke only the C tests in the `concurrent` category, for example, do this: ``` -./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.runtime.CTest.runConcurrentTests +./gradlew core:integrationTest --tests org.lflang.tests.runtime.CTest.runConcurrentTests ``` To run a single test case, use the `singleTest` gradle task along with the path to the test source file: diff --git a/util/scripts/launch.ps1 b/util/scripts/launch.ps1 index 97d0afd3f3..be874fd26a 100644 --- a/util/scripts/launch.ps1 +++ b/util/scripts/launch.ps1 @@ -30,8 +30,8 @@ $gradlew="${base}/gradlew.bat" # invoke script if ($args.Length -eq 0) { - & "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" + & "${gradlew}" -p "${base}" "cli:${tool}:run" } else { $argsString = $args -join " " - & "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args="${argsString}" + & "${gradlew}" -p "${base}" "cli:${tool}:run" --args="${argsString}" } \ No newline at end of file diff --git a/util/scripts/launch.sh b/util/scripts/launch.sh index fc6dc83c6c..f1e685f288 100755 --- a/util/scripts/launch.sh +++ b/util/scripts/launch.sh @@ -71,7 +71,7 @@ gradlew="${base}/gradlew" # Launch the tool. if [ $# -eq 0 ]; then - "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" + "${gradlew}" -p "${base}" "cli:${tool}:run" else - "${gradlew}" -p "${base}" "org.lflang:cli:${tool}:run" --args="$*" + "${gradlew}" -p "${base}" "cli:${tool}:run" --args="$*" fi From bbff85341b5981900289154e5ac8224cda78320a Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 10:26:33 +0200 Subject: [PATCH 619/709] adjust CI path check again --- .github/workflows/check-diff.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index 29a2bd81b4..af14720136 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -36,10 +36,10 @@ jobs: - id: do run: | wget https://raw.githubusercontent.com/lf-lang/lingua-franca/master/.github/scripts/check-diff.sh - source check-diff.sh "org.lflang/core/src/main/java/org/lflang/generator/c\|/home/peter/lingua-franca/org.lflang/core/src/main/resources/lib/c\|org.lflang/core/src/main/resources/lib/platform\|test/C" C - source check-diff.sh "org.lflang/core/src/main/kotlin/org/lflang/generator/cpp\|org.lflang/core/src/main/resources/lib/cpp\|test/Cpp" CPP - source check-diff.sh "org.lflang/core/src/main/java/org/lflang/generator/python\|org.lflang/core/src/main/resources/lib/py\|test/Python" PY - source check-diff.sh "org.lflang/core/src/main/kotlin/org/lflang/generator/rust\|org.lflang/core/src/main/java/org/lflang/generator/rust\|org.lflang/core/src/main/resources/lib/rs\|test/Rust" RS - source check-diff.sh "org.lflang/core/src/main/kotlin/org/lflang/generator/ts\|org.lflang/core/src/main/java/org/lflang/generator/ts\|org.lflang/core/src/main/resources/lib/ts\|test/TypeScript" TS + source check-diff.sh "core/src/main/java/generator/c\|/home/peter/lingua-franca/core/src/main/resources/lib/c\|core/src/main/resources/lib/platform\|test/C" C + source check-diff.sh "core/src/main/kotlin/generator/cpp\|core/src/main/resources/lib/cpp\|test/Cpp" CPP + source check-diff.sh "core/src/main/java/generator/python\|core/src/main/resources/lib/py\|test/Python" PY + source check-diff.sh "core/src/main/kotlin/generator/rust\|core/src/main/java/generator/rust\|core/src/main/resources/lib/rs\|test/Rust" RS + source check-diff.sh "core/src/main/kotlin/generator/ts\|core/src/main/java/generator/ts\|core/src/main/resources/lib/ts\|test/TypeScript" TS source check-diff.sh "util/tracing" TRACING shell: bash From 695f0318fe0c99ac88f6d67cc2736d58fdd317fb Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 10:54:24 +0200 Subject: [PATCH 620/709] fix project refs --- cli/base/build.gradle | 2 +- cli/lfc/build.gradle | 4 ++-- cli/lff/build.gradle | 4 ++-- lsp/build.gradle | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/cli/base/build.gradle b/cli/base/build.gradle index 895094fcad..8d3df08b02 100644 --- a/cli/base/build.gradle +++ b/cli/base/build.gradle @@ -6,5 +6,5 @@ plugins { dependencies { api "info.picocli:picocli:$picocliVersion" - api project('core') + api project(':core') } diff --git a/cli/lfc/build.gradle b/cli/lfc/build.gradle index 6a2d65f73c..4d2f423584 100644 --- a/cli/lfc/build.gradle +++ b/cli/lfc/build.gradle @@ -4,9 +4,9 @@ plugins { } dependencies { - implementation project('cli:base') + implementation project(':cli:base') - testImplementation(testFixtures(project("cli:base"))) + testImplementation(testFixtures(project(':cli:base'))) } application { diff --git a/cli/lff/build.gradle b/cli/lff/build.gradle index ed44366e9b..9f2269120c 100644 --- a/cli/lff/build.gradle +++ b/cli/lff/build.gradle @@ -3,9 +3,9 @@ plugins { } dependencies { - implementation project('cli:base') + implementation project(':cli:base') - testImplementation(testFixtures(project("cli:base"))) + testImplementation(testFixtures(project(':cli:base'))) testImplementation "org.junit.jupiter:junit-jupiter-api:$jupiterVersion" testImplementation "org.junit.jupiter:junit-jupiter-engine:$jupiterVersion" testImplementation "org.junit.platform:junit-platform-commons:$jUnitPlatformVersion" diff --git a/lsp/build.gradle b/lsp/build.gradle index 8b8d043b1c..8895c7c7ed 100644 --- a/lsp/build.gradle +++ b/lsp/build.gradle @@ -3,7 +3,7 @@ plugins { } dependencies { - implementation project('core') + implementation project(':core') implementation ("de.cau.cs.kieler.klighd:de.cau.cs.kieler.klighd.lsp:$klighdVersion") { exclude group: 'org.eclipse.platform', module: 'org.eclipse.swt.*' From 696bbb73c872f6ceec6c96765e499ba2e0240ea0 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:02:50 +0200 Subject: [PATCH 621/709] update gitignore --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index a56607d25f..dcb7b5f75f 100644 --- a/.gitignore +++ b/.gitignore @@ -157,4 +157,4 @@ gradle-app.setting ### xtext artifaccts *.jar -org.lflang/core/model/ \ No newline at end of file +core/model/ \ No newline at end of file From 49f3dd75e067fe754a795fdf35a4cd10dda50ba3 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:03:05 +0200 Subject: [PATCH 622/709] enable parallel garbage collection --- gradle.properties | 3 +++ 1 file changed, 3 insertions(+) diff --git a/gradle.properties b/gradle.properties index 50b3771829..a1fd131d68 100644 --- a/gradle.properties +++ b/gradle.properties @@ -23,3 +23,6 @@ org.eclipse.lsp4j=lsp4jVersion org.opentest4j=openTest4jVersion org.eclipse.core.resources=resourcesVersion org.junit.jupiter=jupiterVersion + +[gradleProperties] +org.gradle.jvmargs="-XX:+UseParallelGC" \ No newline at end of file From 6ea2af85f47324db0b647263d121c54eccf55e71 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:14:40 +0200 Subject: [PATCH 623/709] fix paths in CI configuration --- .github/actions/build-rti-docker/build-rti-image.sh | 2 +- .github/actions/install-rti/install.sh | 2 +- .github/workflows/build.yml | 2 +- .github/workflows/c-arduino-tests.yml | 4 ++-- .github/workflows/c-tests.yml | 4 ++-- .github/workflows/c-zephyr-tests.yml | 4 ++-- .github/workflows/cpp-ros2-tests.yml | 4 ++-- .github/workflows/cpp-tests.yml | 4 ++-- .github/workflows/lsp-tests.yml | 8 ++++---- .github/workflows/py-tests.yml | 6 +++--- .github/workflows/rs-tests.yml | 4 ++-- .github/workflows/serialization-tests.yml | 4 ++-- .github/workflows/ts-tests.yml | 2 +- 13 files changed, 25 insertions(+), 25 deletions(-) diff --git a/.github/actions/build-rti-docker/build-rti-image.sh b/.github/actions/build-rti-docker/build-rti-image.sh index a0d9d751aa..43933ba754 100755 --- a/.github/actions/build-rti-docker/build-rti-image.sh +++ b/.github/actions/build-rti-docker/build-rti-image.sh @@ -1,3 +1,3 @@ #!/bin/bash -cd org.lflang/src/lib/c/reactor-c/core/federated/RTI +cd src/lib/c/reactor-c/core/federated/RTI docker build -t rti:rti -f rti.Dockerfile ../../../ diff --git a/.github/actions/install-rti/install.sh b/.github/actions/install-rti/install.sh index 06ad67bb58..f3560f0529 100755 --- a/.github/actions/install-rti/install.sh +++ b/.github/actions/install-rti/install.sh @@ -1,5 +1,5 @@ #!/bin/bash -cd org.lflang/core/src/main/resources/lib/c/reactor-c/core/federated/RTI +cd core/src/main/resources/lib/c/reactor-c/core/federated/RTI mkdir build cd build if [[ "$OSTYPE" == "darwin"* ]]; then diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index bf8932fcc0..17bfe6edc4 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -47,6 +47,6 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco,org.lflang/cli/lfc/build/reports/xml/jacoco,org.lflang/cli/lff/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco,cli/lfc/build/reports/xml/jacoco,cli/lff/build/reports/xml/jacoco fail_ci_if_error: false verbose: true diff --git a/.github/workflows/c-arduino-tests.yml b/.github/workflows/c-arduino-tests.yml index 18d1a2962a..5b9e9a6213 100644 --- a/.github/workflows/c-arduino-tests.yml +++ b/.github/workflows/c-arduino-tests.yml @@ -41,7 +41,7 @@ jobs: uses: actions/checkout@v3 with: repository: lf-lang/reactor-c - path: org.lflang/src/lib/c/reactor-c + path: core/src/main/resources/lib/c/reactor-c ref: ${{ inputs.runtime-ref }} if: ${{ inputs.runtime-ref }} - name: Install dependencies OS X @@ -69,7 +69,7 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.runtime-ref && runner.os == 'Linux' && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index f072385183..956fb4c967 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -41,7 +41,7 @@ jobs: uses: actions/checkout@v3 with: repository: lf-lang/reactor-c - path: org.lflang/src/lib/c/reactor-c + path: core/src/main/resources/lib/c/reactor-c ref: ${{ inputs.runtime-ref }} if: ${{ inputs.runtime-ref }} - name: Install dependencies OS X @@ -69,7 +69,7 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.compiler-ref && runner.os == 'Linux' && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/c-zephyr-tests.yml b/.github/workflows/c-zephyr-tests.yml index a8854dfa25..94935ec09d 100644 --- a/.github/workflows/c-zephyr-tests.yml +++ b/.github/workflows/c-zephyr-tests.yml @@ -36,7 +36,7 @@ jobs: uses: actions/checkout@v3 with: repository: lf-lang/reactor-c - path: org.lflang/src/lib/c/reactor-c + path: core/src/main/resources/lib/c/reactor-c ref: ${{ inputs.runtime-ref }} if: ${{ inputs.runtime-ref }} - name: Perform Zephyr tests for C target with default scheduler @@ -48,7 +48,7 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/cpp-ros2-tests.yml b/.github/workflows/cpp-ros2-tests.yml index da5d98523d..416499c832 100644 --- a/.github/workflows/cpp-ros2-tests.yml +++ b/.github/workflows/cpp-ros2-tests.yml @@ -27,7 +27,7 @@ jobs: uses: actions/checkout@v3 with: repository: lf-lang/reactor-cpp - path: org.lflang/src/lib/cpp/reactor-cpp + path: core/src/main/resources/lib/cpp/reactor-cpp ref: ${{ inputs.runtime-ref }} if: ${{ inputs.runtime-ref }} - name: Setup ROS2 @@ -41,7 +41,7 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/cpp-tests.yml b/.github/workflows/cpp-tests.yml index b4ad00e7f6..ef59f3a794 100644 --- a/.github/workflows/cpp-tests.yml +++ b/.github/workflows/cpp-tests.yml @@ -43,7 +43,7 @@ jobs: uses: actions/checkout@v2 with: repository: lf-lang/reactor-cpp - path: org.lflang/src/lib/cpp/reactor-cpp + path: core/src/main/resources/lib/cpp/reactor-cpp ref: ${{ inputs.runtime-ref }} if: ${{ inputs.runtime-ref }} - name: Run C++ tests; @@ -54,7 +54,7 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.runtime-ref && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/lsp-tests.yml b/.github/workflows/lsp-tests.yml index 54d430fd9d..9d6e22e401 100644 --- a/.github/workflows/lsp-tests.yml +++ b/.github/workflows/lsp-tests.yml @@ -49,7 +49,7 @@ jobs: uses: actions/cache@v3.2.5 with: path: ~/.pnpm-store - key: ${{ runner.os }}-node${{ matrix.node-version }}-${{ hashFiles('org.lflang/src/lib/ts/package.json') }} + key: ${{ runner.os }}-node${{ matrix.node-version }}-${{ hashFiles('core/src/main/resources/lib/ts/package.json') }} - name: Setup Rust uses: ATiltedTree/setup-rust@v1 with: @@ -69,7 +69,7 @@ jobs: with: python-version: '3.10' - name: Run language server Python tests without PyLint - run: ./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly + run: ./gradlew core:integrationTest --tests org.lflang.tests.lsp.LspTests.pythonValidationTestSyntaxOnly - name: Install pylint run: python3 -m pip install pylint if: ${{ runner.os != 'macOS' }} @@ -77,13 +77,13 @@ jobs: run: brew install pylint if: ${{ runner.os == 'macOS' }} - name: Run language server tests - run: ./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.lsp.LspTests.*ValidationTest + run: ./gradlew core:integrationTest --tests org.lflang.tests.lsp.LspTests.*ValidationTest - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ runner.os == 'Linux' && inputs.all-platforms }} diff --git a/.github/workflows/py-tests.yml b/.github/workflows/py-tests.yml index 55a527d57c..85094a5c6a 100644 --- a/.github/workflows/py-tests.yml +++ b/.github/workflows/py-tests.yml @@ -49,14 +49,14 @@ jobs: uses: actions/checkout@v2 with: repository: lf-lang/reactor-c - path: org.lflang/src/lib/c/reactor-c + path: core/src/main/resources/lib/c/reactor-c ref: ${{ inputs.reactor-c-ref }} if: ${{ inputs.reactor-c-ref }} - name: Check out specific ref of reactor-c-py uses: actions/checkout@v2 with: repository: lf-lang/reactor-c-py - path: org.lflang/src/lib/py/reactor-c-py + path: core/src/main/resources/lib/py/reactor-c-py ref: ${{ inputs.reactor-c-py-ref }} if: ${{ inputs.reactor-c-py-ref }} - name: Run Python tests @@ -66,7 +66,7 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.compiler-ref && runner.os == 'Linux' && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/rs-tests.yml b/.github/workflows/rs-tests.yml index b444ceaa4e..9f9c7d6a52 100644 --- a/.github/workflows/rs-tests.yml +++ b/.github/workflows/rs-tests.yml @@ -41,7 +41,7 @@ jobs: uses: actions/checkout@v3 with: repository: lf-lang/reactor-rs - path: org.lflang/src/lib/rs/reactor-rs + path: core/src/main/resources/lib/rs/reactor-rs ref: ${{ inputs.runtime-ref }} if: inputs.runtime-ref - name: Update runtime ref if we use a custom runtime version @@ -70,7 +70,7 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.compiler-ref && runner.os == 'Linux' && inputs.all-platforms }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/serialization-tests.yml b/.github/workflows/serialization-tests.yml index 59aea0bb31..ed9cfb237a 100644 --- a/.github/workflows/serialization-tests.yml +++ b/.github/workflows/serialization-tests.yml @@ -31,13 +31,13 @@ jobs: - name: Run serialization tests; run: | source /opt/ros/*/setup.bash - ./gradlew org.lflang:core:integrationTest --tests org.lflang.tests.serialization.SerializationTest.* + ./gradlew core:integrationTest --tests org.lflang.tests.serialization.SerializationTest.* - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ !inputs.runtime-ref }} # i.e., if this is part of the main repo's CI diff --git a/.github/workflows/ts-tests.yml b/.github/workflows/ts-tests.yml index 9253898eeb..863fb34d5e 100644 --- a/.github/workflows/ts-tests.yml +++ b/.github/workflows/ts-tests.yml @@ -39,7 +39,7 @@ jobs: - name: Report to CodeCov uses: codecov/codecov-action@v3.1.1 with: - files: org.lflang/core/build/reports/xml/jacoco + files: core/build/reports/xml/jacoco fail_ci_if_error: false verbose: true if: ${{ runner.os == 'Linux' && inputs.all-platforms }} From 354491987aadf0560fb9cbaedf7b10afa2173871 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:17:24 +0200 Subject: [PATCH 624/709] remove parallel garbage collection again as it does not work in CI --- gradle.properties | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/gradle.properties b/gradle.properties index a1fd131d68..8d2599bdf6 100644 --- a/gradle.properties +++ b/gradle.properties @@ -22,7 +22,4 @@ org.eclipse.xtext=xtextVersion org.eclipse.lsp4j=lsp4jVersion org.opentest4j=openTest4jVersion org.eclipse.core.resources=resourcesVersion -org.junit.jupiter=jupiterVersion - -[gradleProperties] -org.gradle.jvmargs="-XX:+UseParallelGC" \ No newline at end of file +org.junit.jupiter=jupiterVersion \ No newline at end of file From 1527804406789ac78347dd889549b4511026a4ce Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:20:46 +0200 Subject: [PATCH 625/709] move log4j configuration file to lsp resources --- {todo => lsp/src/main/resources}/log4j.xml | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {todo => lsp/src/main/resources}/log4j.xml (100%) diff --git a/todo/log4j.xml b/lsp/src/main/resources/log4j.xml similarity index 100% rename from todo/log4j.xml rename to lsp/src/main/resources/log4j.xml From 479276390ba5f07b73b66225f77407a5bdc9acbe Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:34:55 +0200 Subject: [PATCH 626/709] delete bump version script --- util/scripts/bump-versions | 179 ------------------------------------- 1 file changed, 179 deletions(-) delete mode 100755 util/scripts/bump-versions diff --git a/util/scripts/bump-versions b/util/scripts/bump-versions deleted file mode 100755 index fd0200cc92..0000000000 --- a/util/scripts/bump-versions +++ /dev/null @@ -1,179 +0,0 @@ -#! /bin/python3 - -import os -from os.path import join, dirname, abspath - -# Usage: see below. -# -# @author Steven Wong -def usage(): - return '''bump-versions [-h] [-p PROP] [-t TARGET] [-a] - - update the version number in config.properties. - Then, run `bump-versions --all` to update for all targets (maven and manifest files). - - You can also specify a specific target and a specific property to update using `-t` and/or `-p` - ex. bump-versions -p xtextVersion -t maven - ''' - - -findPrintStyle = '%p:\\n' -replace = '\\n' -to = ' >>> ' -parentDir = dirname(dirname(abspath(__file__))) -manifestFind = parentDir -mavenFind = join(parentDir, 'pom.xml') -excluded = ['target', 'build'] - -class colors: - RED = '\033[31m' - ENDC = '\033[m' - GREEN = '\033[32m' - YELLOW = '\033[33m' - BLUE = '\033[34m' - PURPLE = '\033[35m' - -def main(args): - import configparser - config = configparser.RawConfigParser() - config.optionxform = str - config.read(join(parentDir, 'gradle.properties')) - props = dict(config.items('versions')).keys() - - if args["prop"]: - prop = args["prop"] - if prop not in props: - print(colors.RED + "ERROR" + colors.ENDC + f": property {prop} does not exist") - return - props = [prop] - - if args["all"] and args["target"]: - print(colors.RED + "ERROR" + colors.ENDC + f": --all and --target are mutually exclusive") - return - - targetLower = args["target"].lower() if args["target"] else "" - quiet = args["quiet"] - - if args["all"]: - updateManifestPackages(config, props, quiet) - updateMavenPackages(config, props, quiet) - elif targetLower == "maven": - updateMavenPackages(config, props, quiet) - elif targetLower == "manifest": - updateManifestPackages(config, props, quiet) - -def getInput(): - return input(colors.PURPLE + "The changes are printed to the screen. Enter [Y/y] to accept, [N/n] to reject, [Q/q] to skip: " + colors.ENDC).lower() - -def updateMavenPackages(config, props, quiet): - print(colors.GREEN + "Updating versions for >>> ./pom.xml" + colors.ENDC) - propertyNameToVersion = dict(config.items('versions')) - for prop in props: - print("[MAVEN] Updating version for variable: " + colors.GREEN + prop + colors.ENDC) - os.system(generateMavenViewCommand(prop, propertyNameToVersion[prop])) - c = '' - while c != 'y' and c != 'n': - c = 'y' if quiet else getInput() - print() - if c == 'y': - os.system(generateMavenReplaceCommand(prop, propertyNameToVersion[prop])) - elif c == 'q': - return - - -def updateManifestPackages(config, props, quiet): - print(colors.GREEN + "Updating versions for >>> manifest files" + colors.ENDC) - packageToPropertyName = dict(config.items('manifestPropertyNames')) - propertyNameToVersion = dict(config.items('versions')) - - for prop in props: - manifestPackages = [package for package, propertyName in packageToPropertyName.items() if prop == propertyName] - - if len(manifestPackages) == 0 or prop not in propertyNameToVersion: - print(colors.YELLOW + "WARNING" + colors.ENDC + f": Property '{prop}' does not exist for Manifest files.\n") - - for package in manifestPackages: - print("[MANIFEST] Updating version for package: " + colors.GREEN + package + colors.ENDC) - os.system(generateManifestViewCommand(package, propertyNameToVersion[prop])) - c = '' - while c != 'y' and c != 'n': - c = 'y' if quiet else getInput() - print() - if c == 'y': - os.system(generateManifestReplaceCommand(package, propertyNameToVersion[prop])) - elif c == 'q': - return - - -def excludeFromFind(): - return ' '.join(f'! -path \"**/{it}/**\"' for it in excluded) - - -def generateManifestViewCommand(matchName, version): - return f''' - find {manifestFind} -name *.MF {excludeFromFind()} -type f -printf '{findPrintStyle}' -exec sed -n '/{matchName}.*;bundle-version/{{ - h - s/="[^"][^"]*"/="{version}"/g - H - x - s/{replace}/{to}/ - w /dev/fd/2 - x - }}' {{}} \; - ''' - - -def generateManifestReplaceCommand(matchName, version): - return f''' - find {manifestFind} -name *.MF {excludeFromFind()} -type f -exec sed -i '/{matchName}.*;bundle-version/{{ - h - s/="[^"][^"]*"/="{version}"/g - }}' {{}} \; - ''' - -def generateMavenViewCommand(matchName, version): - return f''' - find {mavenFind} -printf '{findPrintStyle}' -exec sed -n '/<{matchName}>.*<\/{matchName}>/{{ - h - s/<{matchName}>.*<\/{matchName}>/<{matchName}>{version}<\/{matchName}>/g - H - x - s/{replace}/{to}/ - w /dev/fd/2 - x - }}' {{}} \; - ''' - - -def generateMavenReplaceCommand(matchName, version): - return f''' - find {mavenFind} -exec sed -i '/<{matchName}>.*<\/{matchName}>/{{ - h - s/<{matchName}>.*<\/{matchName}>/<{matchName}>{version}<\/{matchName}>/g - }}' {{}} \; - ''' - -if __name__ == '__main__': - import argparse - import sys - - parser = argparse.ArgumentParser(usage=usage()) - targetGroup = parser.add_mutually_exclusive_group(required=True) - - # Adding optional argument - parser.add_argument("-p", "--prop", help="version property to update") - parser.add_argument("-q", "--quiet", help="default accept all of the version changes", action="store_true") - targetGroup.add_argument("-t", "--target", help="target build application to update. Can be one of 'maven' or 'manifest' (case insensitive)") - targetGroup.add_argument("-a", "--all", help="update dependencies for all targets (maven and manifest files)", action="store_true") - - if len(sys.argv) == 1: - parser.print_help() - parser.exit() - - # Read arguments from command line - args = vars(parser.parse_args()) - - if 'all' not in args and 'target' not in args: - parser.print_help() - - main(args) From 379af0496c5acf06bf00771b9bdebf19df56757b Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:35:06 +0200 Subject: [PATCH 627/709] fix typo --- test/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/README.md b/test/README.md index ef6ec66001..6725982dd0 100644 --- a/test/README.md +++ b/test/README.md @@ -30,7 +30,7 @@ To invoke only the C tests in the `concurrent` category, for example, do this: To run a single test case, use the `singleTest` gradle task along with the path to the test source file: ``` -./gradlew singleTest -DsingleTest test/C/src/Minimal.lf +./gradlew singleTest -DsingleTest=test/C/src/Minimal.lf ``` ### LSP tests From 939c77fbec5d6e3247af6d8d2c314f1a8ed14bb5 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:38:45 +0200 Subject: [PATCH 628/709] fix trace tool makefile --- util/tracing/makefile | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/util/tracing/makefile b/util/tracing/makefile index 590eaa698f..03a19e7455 100644 --- a/util/tracing/makefile +++ b/util/tracing/makefile @@ -3,10 +3,10 @@ # @author: Edward A. Lee CC=gcc -CFLAGS=-I../../org.lflang/core/src/main/resources/lib/c/reactor-c/include/core/ \ - -I../../org.lflang/core/src/main/resources/lib/c/reactor-c/include/core/modal_models \ - -I../../org.lflang/core/src/main/resources/lib/c/reactor-c/include/core/platform \ - -I../../org.lflang/core/src/main/resources/lib/c/reactor-c/include/core/utils \ +CFLAGS=-I../../core/src/main/resources/lib/c/reactor-c/include/core/ \ + -I../../core/src/main/resources/lib/c/reactor-c/include/core/modal_models \ + -I../../core/src/main/resources/lib/c/reactor-c/include/core/platform \ + -I../../core/src/main/resources/lib/c/reactor-c/include/core/utils \ -DLF_UNTHREADED=1 \ -Wall DEPS= From b24ed0a1c0be60316ab8a37e2c28c9baf25758f0 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 11:43:35 +0200 Subject: [PATCH 629/709] add legacy gradle task and print informative error message --- build.gradle | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/build.gradle b/build.gradle index 473bfb60f7..39f0eec059 100644 --- a/build.gradle +++ b/build.gradle @@ -72,3 +72,11 @@ tasks.register('singleTest') { } finalizedBy('core:integrationTest') } + +// Old deprecated tasks. +tasks.register('buildAll') { + throw new GradleException('The "buildAll" task was removed. Pleas use "./gradlew build" or "./gradlew assemble instead') +} +tasks.register('runSingleTestl') { + throw new GradleException('The "runSingleTest" task was removed. Pleas use "./gradlew singleTest -DsingleTest=testFile.lf" instead') +} From 2d2cfa7717d6375c7dce9787560e2b7d8a29deed Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 12:30:23 +0200 Subject: [PATCH 630/709] don't error when loading the dummy tasks --- build.gradle | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/build.gradle b/build.gradle index 39f0eec059..fd225f10e2 100644 --- a/build.gradle +++ b/build.gradle @@ -75,8 +75,12 @@ tasks.register('singleTest') { // Old deprecated tasks. tasks.register('buildAll') { - throw new GradleException('The "buildAll" task was removed. Pleas use "./gradlew build" or "./gradlew assemble instead') + doLast { + throw new GradleException('The "buildAll" task was removed. Pleas use "./gradlew build" or "./gradlew assemble instead') + } } tasks.register('runSingleTestl') { - throw new GradleException('The "runSingleTest" task was removed. Pleas use "./gradlew singleTest -DsingleTest=testFile.lf" instead') + doLast { + throw new GradleException('The "runSingleTest" task was removed. Pleas use "./gradlew singleTest -DsingleTest=testFile.lf" instead') + } } From ac5cd70e479a46d14d3b09cd8315c571aad040c1 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 12:30:50 +0200 Subject: [PATCH 631/709] don't create 'tmp' directory in the project root --- .../java/org/lflang/tests/compiler/TargetConfigTests.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java b/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java index 51f813befc..8288d17876 100644 --- a/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java +++ b/core/src/test/java/org/lflang/tests/compiler/TargetConfigTests.java @@ -3,6 +3,7 @@ import com.google.inject.Inject; import com.google.inject.Provider; import java.nio.file.Files; +import java.nio.file.Path; import org.eclipse.emf.common.util.URI; import org.eclipse.emf.ecore.resource.ResourceSet; import org.eclipse.xtext.generator.JavaIoFileSystemAccess; @@ -12,6 +13,7 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.api.io.TempDir; import org.lflang.federated.generator.FedFileConfig; import org.lflang.generator.GeneratorUtils; import org.lflang.generator.LFGenerator; @@ -64,7 +66,7 @@ public void testParsing() throws Exception { * @throws Exception */ @Test - public void testFederation() throws Exception { + public void testFederation(@TempDir Path tempDir) throws Exception { fileAccess.setOutputPath("src-gen"); Model federation = @@ -82,7 +84,7 @@ public void testFederation() throws Exception { b = new Foo() } """, - URI.createFileURI("tmp/src/Federation.lf"), + URI.createURI(tempDir.resolve("src/Federation.lf").toUri().toString()), resourceSetProvider.get()); assertHasTargetProperty(federation, "tracing"); From ca1d42870035f96b2596b83d096e788b8b7a099b Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 12:47:33 +0200 Subject: [PATCH 632/709] use gradle branch for benchmark CI runs --- .github/workflows/only-c.yml | 2 +- .github/workflows/only-cpp.yml | 2 +- .github/workflows/only-rs.yml | 2 +- .github/workflows/only-ts.yml | 7 +++++++ 4 files changed, 10 insertions(+), 3 deletions(-) diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 94f588c094..bb4752471b 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -26,7 +26,7 @@ jobs: # Run the C benchmark tests. benchmarking: if: ${{ inputs.all || github.event.pull_request.draft }} - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: target: 'C' diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index 54bd85a24f..daa8e3e847 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -19,7 +19,7 @@ jobs: # Run the C++ benchmark tests. cpp-benchmark-tests: if: ${{ inputs.all || github.event.pull_request.draft }} - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: target: 'Cpp' diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index d944a5bb2f..8b2173b10a 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -26,6 +26,6 @@ jobs: # Run the Rust benchmark tests. rs-benchmark-tests: if: ${{ inputs.all || github.event.pull_request.draft }} - uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@main + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: target: 'Rust' diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index 216b5bca9c..d3798d0f32 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -16,6 +16,13 @@ concurrency: cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: + # Run the TypeScript benchmark tests. + benchmarking: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle + with: + target: 'TS' + # Run the TypeScript integration tests. ts-tests: if: ${{ inputs.all || github.event.pull_request.draft }} From 5bfca09a54a8780c84628fd9d28f15684f86242f Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 13:05:59 +0200 Subject: [PATCH 633/709] add shadowJar task for lsp --- buildSrc/build.gradle | 2 ++ buildSrc/gradle.properties | 1 + lsp/build.gradle | 11 +++++++++++ 3 files changed, 14 insertions(+) diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle index 09aca9525e..db34ac5c23 100644 --- a/buildSrc/build.gradle +++ b/buildSrc/build.gradle @@ -15,4 +15,6 @@ dependencies { implementation "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion" implementation "com.diffplug.spotless:spotless-plugin-gradle:$spotlessVersion" + + implementation "gradle.plugin.com.github.johnrengelman:shadow:$shadowJarVersion" } diff --git a/buildSrc/gradle.properties b/buildSrc/gradle.properties index 149718da23..217c42b57c 100644 --- a/buildSrc/gradle.properties +++ b/buildSrc/gradle.properties @@ -2,3 +2,4 @@ spotlessVersion=6.11.0 spotlessLibVersion=2.30.0 kotlinVersion=1.6.21 +shadowJarVersion=7.1.2 \ No newline at end of file diff --git a/lsp/build.gradle b/lsp/build.gradle index 8895c7c7ed..772f618db1 100644 --- a/lsp/build.gradle +++ b/lsp/build.gradle @@ -1,5 +1,6 @@ plugins { id 'org.lflang.java-application-conventions' + id 'com.github.johnrengelman.shadow' } dependencies { @@ -14,3 +15,13 @@ dependencies { application { mainClass = 'org.lflang.diagram.lsp.LanguageDiagramServer' } + +shadowJar { + // Handling of service loader registrations via META-INF/services/* + mergeServiceFiles() + + // Merge properties + transform(com.github.jengelman.gradle.plugins.shadow.transformers.AppendingTransformer) { + resource = 'plugin.properties' + } +} From e441ea709abf687143e59e61a4f299d8bea73014 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Thu, 1 Jun 2023 07:45:56 -0700 Subject: [PATCH 634/709] Fixed type for delay parameter --- test/C/src/lib/InternalDelay.lf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/C/src/lib/InternalDelay.lf b/test/C/src/lib/InternalDelay.lf index fbbf2f0cb6..5f49ad121e 100644 --- a/test/C/src/lib/InternalDelay.lf +++ b/test/C/src/lib/InternalDelay.lf @@ -1,6 +1,6 @@ target C -reactor InternalDelay(delay: int = 10 msec) { +reactor InternalDelay(delay: time = 10 msec) { input in: int output out: int logical action d: int From 75a05787135de68580d5186e4c63bd3748defac8 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 17:31:05 +0200 Subject: [PATCH 635/709] platform specific tests should inherit from TestBase If they are based on RuntimeTest, they will inherit all the standard test methods as well. --- .../java/org/lflang/tests/runtime/CArduinoTest.java | 3 ++- .../java/org/lflang/tests/runtime/CZephyrTest.java | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java index 95363fd30b..e9c2e9f4db 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java @@ -6,6 +6,7 @@ import org.lflang.Target; import org.lflang.tests.Configurators; import org.lflang.tests.RuntimeTest; +import org.lflang.tests.TestBase; import org.lflang.tests.TestRegistry.TestCategory; /** @@ -13,7 +14,7 @@ * * @author Anirudh Rengarajan */ -public class CArduinoTest extends RuntimeTest { +public class CArduinoTest extends TestBase { public CArduinoTest() { super(Target.C); diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java index b29c2755d1..ffab2509b0 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java @@ -30,6 +30,7 @@ import org.lflang.Target; import org.lflang.tests.Configurators; import org.lflang.tests.RuntimeTest; +import org.lflang.tests.TestBase; import org.lflang.tests.TestRegistry.TestCategory; /** @@ -37,7 +38,7 @@ * * @author Erling Rennemo Jellum */ -public class CZephyrTest extends RuntimeTest { +public class CZephyrTest extends TestBase { public CZephyrTest() { super(Target.C); From ccb22173fe4677a6185f4c3800110b9d65b09fd4 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 17:34:54 +0200 Subject: [PATCH 636/709] formatting --- .../java/org/lflang/tests/runtime/CArduinoTest.java | 1 - .../java/org/lflang/tests/runtime/CZephyrTest.java | 1 - 2 files changed, 2 deletions(-) diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java index e9c2e9f4db..b8ae804a09 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CArduinoTest.java @@ -5,7 +5,6 @@ import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.Configurators; -import org.lflang.tests.RuntimeTest; import org.lflang.tests.TestBase; import org.lflang.tests.TestRegistry.TestCategory; diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java index ffab2509b0..82dfb4270e 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java @@ -29,7 +29,6 @@ import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.Configurators; -import org.lflang.tests.RuntimeTest; import org.lflang.tests.TestBase; import org.lflang.tests.TestRegistry.TestCategory; From 3481d98512c8a4586603cecf32192188f6d351c1 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Thu, 1 Jun 2023 17:53:54 +0200 Subject: [PATCH 637/709] make sure that integration tests are not run in parallel Fixes https://github.com/lf-lang/lingua-franca/issues/567 --- .../src/main/groovy/org.lflang.test-conventions.gradle | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle index 40950e1832..00be562a02 100644 --- a/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.test-conventions.gradle @@ -48,6 +48,11 @@ test { showStandardStreams = true exceptionFormat "full" } + + maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1 + failFast = true + workingDir = rootProject.projectDir + integrationTest { // Pass properties on to the Java VM systemProperty 'scheduler', System.getProperty('scheduler') @@ -73,11 +78,8 @@ test { failFast = true workingDir = rootProject.projectDir + maxParallelForks = 1 } - - maxParallelForks = Runtime.runtime.availableProcessors().intdiv(2) ?: 1 - failFast = true - workingDir = rootProject.projectDir } jacocoTestReport { From b725fa83b7814cb4692dd3f7a2a1ec650a9e1c30 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 1 Jun 2023 10:26:20 -0700 Subject: [PATCH 638/709] Try again to pass all C tests. --- org.lflang.tests/src/org/lflang/tests/LFTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/LFTest.java b/org.lflang.tests/src/org/lflang/tests/LFTest.java index 61b5dc2edf..a8afe78bc1 100644 --- a/org.lflang.tests/src/org/lflang/tests/LFTest.java +++ b/org.lflang.tests/src/org/lflang/tests/LFTest.java @@ -258,8 +258,9 @@ private Thread recordStream(StringBuilder builder, InputStream inputStream) { char[] buf = new char[1024]; while ((len = reader.read(buf)) > 0) { builder.append(buf, 0, len); - if (Runtime.getRuntime().freeMemory() < Runtime.getRuntime().totalMemory() / 2 ) { + if (Runtime.getRuntime().freeMemory() < Runtime.getRuntime().totalMemory() / 3) { builder.delete(0, builder.length() / 2); + builder.trimToSize(); } } } catch (IOException e) { From 4a4526f206510b83fbf844c1b0eab87fd0f55eb7 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 1 Jun 2023 10:49:39 -0700 Subject: [PATCH 639/709] Update Rust runtime. --- org.lflang/src/lib/rs/reactor-rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang/src/lib/rs/reactor-rs b/org.lflang/src/lib/rs/reactor-rs index 28f9460724..4ac645947b 160000 --- a/org.lflang/src/lib/rs/reactor-rs +++ b/org.lflang/src/lib/rs/reactor-rs @@ -1 +1 @@ -Subproject commit 28f9460724b266c263f4fdf8146b2029f4ff9d30 +Subproject commit 4ac645947bf7916a5e4c967207573b78aa2206f7 From 3b3c51775bacb8edfedf18dd3d8a52b638cd54ab Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 1 Jun 2023 10:56:19 -0700 Subject: [PATCH 640/709] Address errors in LFTest.java. --- org.lflang.tests/src/org/lflang/tests/LFTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/LFTest.java b/org.lflang.tests/src/org/lflang/tests/LFTest.java index a8afe78bc1..6cbadd7d69 100644 --- a/org.lflang.tests/src/org/lflang/tests/LFTest.java +++ b/org.lflang.tests/src/org/lflang/tests/LFTest.java @@ -258,7 +258,7 @@ private Thread recordStream(StringBuilder builder, InputStream inputStream) { char[] buf = new char[1024]; while ((len = reader.read(buf)) > 0) { builder.append(buf, 0, len); - if (Runtime.getRuntime().freeMemory() < Runtime.getRuntime().totalMemory() / 3) { + if (Runtime.getRuntime().freeMemory() < Runtime.getRuntime().totalMemory() * 3 / 4) { builder.delete(0, builder.length() / 2); builder.trimToSize(); } From 4b09250805e050765f8dd8a9b88e025aca03d2db Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 1 Jun 2023 11:02:34 -0700 Subject: [PATCH 641/709] Format Python tests. --- test/Python/src/federated/DistributedStop.lf | 3 +-- test/Python/src/federated/DistributedStopZero.lf | 4 ++-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/test/Python/src/federated/DistributedStop.lf b/test/Python/src/federated/DistributedStop.lf index 3aacf893dc..c793b73e14 100644 --- a/test/Python/src/federated/DistributedStop.lf +++ b/test/Python/src/federated/DistributedStop.lf @@ -1,6 +1,5 @@ /** - * Test for request_stop() in federated execution with centralized - * coordination. + * Test for request_stop() in federated execution with centralized coordination. * * @author Soroush Bateni */ diff --git a/test/Python/src/federated/DistributedStopZero.lf b/test/Python/src/federated/DistributedStopZero.lf index aef9d94f53..8557af9889 100644 --- a/test/Python/src/federated/DistributedStopZero.lf +++ b/test/Python/src/federated/DistributedStopZero.lf @@ -1,6 +1,6 @@ /** - * Test for request_stop() in federated execution with centralized - * coordination at tag (0,0). + * Test for request_stop() in federated execution with centralized coordination + * at tag (0,0). * * @author Soroush Bateni */ From 8a442ee4d79f2282572a96e2eeddafb00b15e8cd Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 1 Jun 2023 11:37:42 -0700 Subject: [PATCH 642/709] Try again to address error in LFTest.java. --- org.lflang.tests/src/org/lflang/tests/LFTest.java | 1 - 1 file changed, 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/LFTest.java b/org.lflang.tests/src/org/lflang/tests/LFTest.java index 6cbadd7d69..fed9974d33 100644 --- a/org.lflang.tests/src/org/lflang/tests/LFTest.java +++ b/org.lflang.tests/src/org/lflang/tests/LFTest.java @@ -260,7 +260,6 @@ private Thread recordStream(StringBuilder builder, InputStream inputStream) { builder.append(buf, 0, len); if (Runtime.getRuntime().freeMemory() < Runtime.getRuntime().totalMemory() * 3 / 4) { builder.delete(0, builder.length() / 2); - builder.trimToSize(); } } } catch (IOException e) { From 627f88a0e1e0525c68ae50d5fc42907adcb50ef2 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 1 Jun 2023 12:16:14 -0700 Subject: [PATCH 643/709] Apply formatter. --- org.lflang.tests/src/org/lflang/tests/LFTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/org.lflang.tests/src/org/lflang/tests/LFTest.java b/org.lflang.tests/src/org/lflang/tests/LFTest.java index fed9974d33..d2a9f255a1 100644 --- a/org.lflang.tests/src/org/lflang/tests/LFTest.java +++ b/org.lflang.tests/src/org/lflang/tests/LFTest.java @@ -258,7 +258,8 @@ private Thread recordStream(StringBuilder builder, InputStream inputStream) { char[] buf = new char[1024]; while ((len = reader.read(buf)) > 0) { builder.append(buf, 0, len); - if (Runtime.getRuntime().freeMemory() < Runtime.getRuntime().totalMemory() * 3 / 4) { + if (Runtime.getRuntime().freeMemory() + < Runtime.getRuntime().totalMemory() * 3 / 4) { builder.delete(0, builder.length() / 2); } } From 1c5f7e5e5d70fc58ae46b494a9278adbfabb5f4b Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Thu, 1 Jun 2023 22:22:00 -0700 Subject: [PATCH 644/709] Add comment. --- .../src/org/lflang/generator/c/TypeParameterizedReactor.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java index 081d57336d..ff4d9d5162 100644 --- a/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/org.lflang/src/org/lflang/generator/c/TypeParameterizedReactor.java @@ -90,6 +90,10 @@ public InferredType resolveType(InferredType t) { return InferredType.fromAST(resolveType(t.astType)); } + /** + * Return a name that is unique to this TypeParameterizedReactor (up to structural equality) and + * that is prefixed with exactly one underscore and that does not contain any upper-case letters. + */ public String uniqueName() { String name = reactor.getName().toLowerCase(); if (uniqueNames.containsKey(this)) return uniqueNames.get(this); From b2c70d2ed199c50ea2be458080b4d7f60f1674ad Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 2 Jun 2023 10:57:20 +0200 Subject: [PATCH 645/709] make sure not to produce errors when just loading the tasks --- build.gradle | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/build.gradle b/build.gradle index fd225f10e2..a6aa3d6eef 100644 --- a/build.gradle +++ b/build.gradle @@ -59,16 +59,20 @@ tasks.register('runLff', JavaExec) { dependsOn('cli:lff:run') } tasks.register('targetTest') { - if (!project.hasProperty('target')) { - def testFiles = rootProject.fileTree("${rootProject.rootDir}/core/src/integrationTest/java/org/lflang/tests/runtime").files - def targets = testFiles.collect {it.getName().substring(0, it.getName().length() - 9);} - throw new GradleException("Please set the \'target\' project property using -Ptarget=<...>. You may chose any of $targets") + doLast { + if (!project.hasProperty('target')) { + def testFiles = rootProject.fileTree("${rootProject.rootDir}/core/src/integrationTest/java/org/lflang/tests/runtime").files + def targets = testFiles.collect { it.getName().substring(0, it.getName().length() - 9); } + throw new GradleException("Please set the \'target\' project property using -Ptarget=<...>. You may chose any of $targets") + } } finalizedBy('core:integrationTest') } tasks.register('singleTest') { - if (System.getProperty('singleTest') == null) { - throw new GradleException('Please set the \'singleTest\' system property using -DsingleTest=<...> to specify the LF test file that you would like to run.') + doLast { + if (System.getProperty('singleTest') == null) { + throw new GradleException('Please set the \'singleTest\' system property using -DsingleTest=<...> to specify the LF test file that you would like to run.') + } } finalizedBy('core:integrationTest') } From 4204deb35e503d069b55adb874064d143eb205a1 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 2 Jun 2023 11:21:27 +0200 Subject: [PATCH 646/709] fix rust runtime version --- core/src/main/resources/lib/rs/runtime-version.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/resources/lib/rs/runtime-version.properties b/core/src/main/resources/lib/rs/runtime-version.properties index 35b335b731..2895d16bf7 100644 --- a/core/src/main/resources/lib/rs/runtime-version.properties +++ b/core/src/main/resources/lib/rs/runtime-version.properties @@ -1 +1 @@ -rs = 28f9460724b266c263f4fdf8146b2029f4ff9d30 +rs = 4ac645947bf7916a5e4c967207573b78aa2206f7 From 514a6848af759662e1ccce1f1d9411eb7b4cb093 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 2 Jun 2023 12:41:57 +0200 Subject: [PATCH 647/709] test the gradle build on all platforms --- .github/workflows/all-misc.yml | 2 ++ .github/workflows/build.yml | 8 +++++++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/.github/workflows/all-misc.yml b/.github/workflows/all-misc.yml index d606cf31b8..1cef721867 100644 --- a/.github/workflows/all-misc.yml +++ b/.github/workflows/all-misc.yml @@ -25,6 +25,8 @@ jobs: building: if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/build.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Build the tools used for processing execution traces tracing: diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 17bfe6edc4..8ecd8d16f3 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -7,6 +7,10 @@ on: required: false type: boolean default: false + all-platforms: + required: false + default: false + type: boolean secrets: envPAT: required: false @@ -14,7 +18,9 @@ on: jobs: build-toolchain: - runs-on: ubuntu-latest + strategy: + matrix: + platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} steps: - name: Check out lingua-franca repository uses: actions/checkout@v3 From e881351ad019c9a81be2439dca55ca7b52f465d5 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 2 Jun 2023 13:44:12 +0200 Subject: [PATCH 648/709] fix build workflow --- .github/workflows/build.yml | 1 + .github/workflows/non-target-specific-extended.yml | 2 ++ 2 files changed, 3 insertions(+) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 8ecd8d16f3..5095a8bef9 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -21,6 +21,7 @@ jobs: strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} + runs-on: ${{ matrix.platform }} steps: - name: Check out lingua-franca repository uses: actions/checkout@v3 diff --git a/.github/workflows/non-target-specific-extended.yml b/.github/workflows/non-target-specific-extended.yml index 065b5dbff8..465681d18d 100644 --- a/.github/workflows/non-target-specific-extended.yml +++ b/.github/workflows/non-target-specific-extended.yml @@ -21,6 +21,8 @@ jobs: building: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/build.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} # Build the tools used for processing execution traces tracing: From d5da5000756ff98224dd9bb465c55a3cc3df2547 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 2 Jun 2023 14:34:17 +0200 Subject: [PATCH 649/709] use lff.bat on Windows --- buildSrc/src/main/java/lfformat/LfFormatStep.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/buildSrc/src/main/java/lfformat/LfFormatStep.java b/buildSrc/src/main/java/lfformat/LfFormatStep.java index b466dd702c..fad30497b8 100644 --- a/buildSrc/src/main/java/lfformat/LfFormatStep.java +++ b/buildSrc/src/main/java/lfformat/LfFormatStep.java @@ -65,6 +65,7 @@ public String format(@SuppressWarnings("NullableProblems") String rawUnix, File /** Idempotently initialize the formatter. */ private static void initializeFormatter() throws IOException { if (formatter != null) return; + String lff = System.getProperty("os.name").startsWith("Windows") ? "lff.bat" : "lff"; final Path lffPath = Path.of( "cli", @@ -73,7 +74,7 @@ private static void initializeFormatter() throws IOException { "install", "lff", "bin", - "lff"); + lff); formatter = new ProcessBuilder( List.of( lffPath.toString(), From b62db0727cc691d577c094f518d2f3b6e640b99f Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 2 Jun 2023 15:24:37 +0200 Subject: [PATCH 650/709] fix strange Windows problem with long paths --- .../groovy/org.lflang.java-application-conventions.gradle | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle index 02cdc18df1..432ebacf1b 100644 --- a/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.java-application-conventions.gradle @@ -9,3 +9,11 @@ tasks.withType(Tar) { compression = Compression.GZIP archiveExtension = 'tar.gz' } + +// Fix long path issue on Windows +// See https://github.com/gradle/gradle/issues/1989 +startScripts { + doLast { + windowsScript.text = windowsScript.text.replaceAll('set CLASSPATH=.*', 'set CLASSPATH=.;%APP_HOME%/lib/*') + } +} From c39b3f8ba8cf9f29e743abbdcbb2b79ccad74c20 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 2 Jun 2023 15:53:32 +0200 Subject: [PATCH 651/709] Deal with Windows CLI formatting in help test --- cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java b/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java index 48946eba55..fd65ffad78 100644 --- a/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java +++ b/cli/lfc/src/test/java/org/lflang/cli/LfcCliTest.java @@ -92,7 +92,8 @@ public void testHelpArg() { result -> { result.checkOk(); result.checkNoErrorOutput(); - result.checkStdOut(containsString("Usage: lfc")); + result.checkStdOut(containsString("Usage:")); + result.checkStdOut(containsString("lfc")); }); } From 15a4140fe1cd1f0428ee2dfc08f1dd81afc500b1 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Fri, 2 Jun 2023 16:09:49 +0200 Subject: [PATCH 652/709] Also fix the Lff test --- cli/lff/src/test/java/org/lflang/cli/LffCliTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java b/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java index e7523ce4fe..9610d5b69c 100644 --- a/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java +++ b/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java @@ -65,7 +65,8 @@ public void testHelpArg() { ExecutionResult result = lffTester.run("--help", "--version"); result.checkOk(); result.checkNoErrorOutput(); - result.checkStdOut(containsString("Usage: lff")); + result.checkStdOut(containsString("Usage:")); + result.checkStdOut(containsString("lff")); } @Test From 451fbc5036566811103981784c24706ad86e8094 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 2 Jun 2023 11:10:24 -0700 Subject: [PATCH 653/709] Update check-diff.sh. This is an attempt to address the issue of changes in master causing diffs to appear for files not touched by the current feature branch. --- .github/scripts/check-diff.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/scripts/check-diff.sh b/.github/scripts/check-diff.sh index 9a84951079..c7bdda6d5f 100644 --- a/.github/scripts/check-diff.sh +++ b/.github/scripts/check-diff.sh @@ -1,5 +1,5 @@ changes() { - git diff --name-only --diff-filter=AMDR --cached origin/master + git diff --name-only HEAD $(git merge-base HEAD origin/master) } if changes | grep -q $1; then From bb76c0eeb47dda5a63b52f5f89a50e511266d9d4 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 2 Jun 2023 16:02:51 -0700 Subject: [PATCH 654/709] Bugfix in CI. --- .github/workflows/check-diff.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index af14720136..f714c3cd3e 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -36,7 +36,7 @@ jobs: - id: do run: | wget https://raw.githubusercontent.com/lf-lang/lingua-franca/master/.github/scripts/check-diff.sh - source check-diff.sh "core/src/main/java/generator/c\|/home/peter/lingua-franca/core/src/main/resources/lib/c\|core/src/main/resources/lib/platform\|test/C" C + source check-diff.sh "core/src/main/java/generator/c\|core/src/main/resources/lib/c\|core/src/main/resources/lib/platform\|test/C" C source check-diff.sh "core/src/main/kotlin/generator/cpp\|core/src/main/resources/lib/cpp\|test/Cpp" CPP source check-diff.sh "core/src/main/java/generator/python\|core/src/main/resources/lib/py\|test/Python" PY source check-diff.sh "core/src/main/kotlin/generator/rust\|core/src/main/java/generator/rust\|core/src/main/resources/lib/rs\|test/Rust" RS From 5334d4af95745342add2f93ebdea139e23694e46 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 2 Jun 2023 17:46:25 -0700 Subject: [PATCH 655/709] Go back to using StringBuffers. StringBuffers differ from StringBuilders mainly in that they are synchronized. It is not entirely clear to me where the concurrent accesses would be coming from since there is only one thread writing to this StringBuffer (right?) but it is one more thing to check. --- core/src/testFixtures/java/org/lflang/tests/LFTest.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/core/src/testFixtures/java/org/lflang/tests/LFTest.java b/core/src/testFixtures/java/org/lflang/tests/LFTest.java index d2a9f255a1..c38160150c 100644 --- a/core/src/testFixtures/java/org/lflang/tests/LFTest.java +++ b/core/src/testFixtures/java/org/lflang/tests/LFTest.java @@ -226,7 +226,7 @@ public static final class ExecutionLogger { /** * String buffer used to record the standard output and error streams from the input process. */ - StringBuilder buffer = new StringBuilder(); + StringBuffer buffer = new StringBuffer(); /** * Return a thread responsible for recording the standard output stream of the given process. A @@ -250,7 +250,7 @@ public Thread recordStdErr(Process process) { * @param builder The builder to append to. * @param inputStream The stream to read from. */ - private Thread recordStream(StringBuilder builder, InputStream inputStream) { + private Thread recordStream(StringBuffer builder, InputStream inputStream) { return new Thread( () -> { try (Reader reader = new InputStreamReader(inputStream)) { From 5d1ed1d22e8f87e942753f5954d90f51c9a351ed Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 3 Jun 2023 09:53:36 -0700 Subject: [PATCH 656/709] Make uniqueName thread-safe. --- .../java/org/lflang/generator/c/TypeParameterizedReactor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index ff4d9d5162..758e1ec6cf 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -94,7 +94,7 @@ public InferredType resolveType(InferredType t) { * Return a name that is unique to this TypeParameterizedReactor (up to structural equality) and * that is prefixed with exactly one underscore and that does not contain any upper-case letters. */ - public String uniqueName() { + public synchronized String uniqueName() { String name = reactor.getName().toLowerCase(); if (uniqueNames.containsKey(this)) return uniqueNames.get(this); if (nameCounts.containsKey(name)) { From 948986db4d6cf4c32575bf0f136d30623844e082 Mon Sep 17 00:00:00 2001 From: "Edward A. Lee" Date: Sat, 3 Jun 2023 06:18:57 -0700 Subject: [PATCH 657/709] Fixed makefile for installing fedsd and added to README. --- util/tracing/README.md | 3 +++ util/tracing/makefile | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/util/tracing/README.md b/util/tracing/README.md index e430e47d7e..900405971a 100644 --- a/util/tracing/README.md +++ b/util/tracing/README.md @@ -14,6 +14,9 @@ directory. * trace\_to\_influxdb: A preliminary implementation that takes a binary trace file and uploads its data into [InfluxDB](https://en.wikipedia.org/wiki/InfluxDB). + +* fedsd: A utility that converts trace files from a federate into sequence diagrams + showing the interactions between federates and the RTI. ## Installing diff --git a/util/tracing/makefile b/util/tracing/makefile index 03a19e7455..f414f05ef3 100644 --- a/util/tracing/makefile +++ b/util/tracing/makefile @@ -28,7 +28,7 @@ install: trace_to_csv trace_to_chrome trace_to_influxdb mv trace_to_csv ../../bin mv trace_to_chrome ../../bin mv trace_to_influxdb ../../bin - ln -f -s ../utils/scripts/launch-fedsd.sh ../../bin/fedsd + ln -f -s ../util/scripts/launch-fedsd.sh ../../bin/fedsd chmod +x ../../bin/fedsd clean: From 59f944dc902e3b8b4a8e91fbdcea61ee9dca51e6 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sat, 3 Jun 2023 12:36:00 -0700 Subject: [PATCH 658/709] Fix formatting --- util/tracing/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/util/tracing/README.md b/util/tracing/README.md index 900405971a..2e6f0cee4a 100644 --- a/util/tracing/README.md +++ b/util/tracing/README.md @@ -14,7 +14,7 @@ directory. * trace\_to\_influxdb: A preliminary implementation that takes a binary trace file and uploads its data into [InfluxDB](https://en.wikipedia.org/wiki/InfluxDB). - + * fedsd: A utility that converts trace files from a federate into sequence diagrams showing the interactions between federates and the RTI. From b9df840ad56b661460d19aa424dc956f52163d95 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sat, 3 Jun 2023 15:57:48 -0700 Subject: [PATCH 659/709] Fix remaining conflict --- test/C/src/concurrent/DeadlineThreaded.lf | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/test/C/src/concurrent/DeadlineThreaded.lf b/test/C/src/concurrent/DeadlineThreaded.lf index 2e7ccc074e..0639d1e709 100644 --- a/test/C/src/concurrent/DeadlineThreaded.lf +++ b/test/C/src/concurrent/DeadlineThreaded.lf @@ -55,13 +55,7 @@ reactor Destination(timeout: time = 1 sec) { } main reactor { -<<<<<<< HEAD s = new Source() - d = new Destination(timeout = 200 msec) + d = new Destination(timeout = 1 s) s.y -> d.x -======= - s = new Source() - d = new Destination(timeout = 1 s) - s.y -> d.x ->>>>>>> master } From 7eee6b967b83e64a8b3a17fef245deae41a95e49 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Sat, 3 Jun 2023 16:37:40 -0700 Subject: [PATCH 660/709] Fix formatting --- test/C/src/federated/STPParameter.lf | 77 +++++++++---------- test/C/src/generics/ParameterAsArgument.lf | 30 ++++---- test/C/src/generics/TypeCheck.lf | 58 +++++++------- test/C/src/zephyr/UserThreads.lf | 58 +++++++------- ...tributedCountDecentralizedLateHierarchy.lf | 67 ++++++++-------- 5 files changed, 140 insertions(+), 150 deletions(-) diff --git a/test/C/src/federated/STPParameter.lf b/test/C/src/federated/STPParameter.lf index 701974748d..97710dec50 100644 --- a/test/C/src/federated/STPParameter.lf +++ b/test/C/src/federated/STPParameter.lf @@ -1,59 +1,52 @@ target C { - timeout: 5 sec, - coordination: decentralized + timeout: 5 sec, + coordination: decentralized } import Count from "../lib/Count.lf" /** - * FIXME: inheritance not working! See issue #1733 import TestCount from - * "../lib/TestCount.lf" + * FIXME: inheritance not working! See issue #1733 import TestCount from "../lib/TestCount.lf" * - * reactor PrintTimer(STP_offset:time = 10 msec) extends TestCount { timer t(0, - * 1 sec); reaction(t) {= lf_print("Timer ticked at (%lld, %d).", - * lf_time_logical_elapsed(), lf_tag().microstep ); + * reactor PrintTimer(STP_offset:time = 10 msec) extends TestCount { timer t(0, 1 sec); reaction(t) + * {= lf_print("Timer ticked at (%lld, %d).", lf_time_logical_elapsed(), lf_tag().microstep ); * =} } */ -reactor PrintTimer( - STP_offset: time = 1 sec, - start: int = 1, - stride: int = 1, - num_inputs: int = 6 -) { - state count: int = start - state inputs_received: int = 0 - input in: int +reactor PrintTimer(STP_offset: time = 1 sec, start: int = 1, stride: int = 1, num_inputs: int = 6) { + state count: int = start + state inputs_received: int = 0 + input in: int - timer t(0, 1 sec) + timer t(0, 1 sec) - reaction(in) {= - lf_print("Received %d.", in->value); - if (in->value != self->count) { - lf_print_error_and_exit("Expected %d.", self->count); - } - self->count += self->stride; - self->inputs_received++; - =} + reaction(in) {= + lf_print("Received %d.", in->value); + if (in->value != self->count) { + lf_print_error_and_exit("Expected %d.", self->count); + } + self->count += self->stride; + self->inputs_received++; + =} - reaction(shutdown) {= - lf_print("Shutdown invoked."); - if (self->inputs_received != self->num_inputs) { - lf_print_error_and_exit("Expected to receive %d inputs, but got %d.", - self->num_inputs, - self->inputs_received - ); - } - =} - - reaction(t) {= - lf_print("Timer ticked at (%lld, %d).", - lf_time_logical_elapsed(), lf_tag().microstep + reaction(shutdown) {= + lf_print("Shutdown invoked."); + if (self->inputs_received != self->num_inputs) { + lf_print_error_and_exit("Expected to receive %d inputs, but got %d.", + self->num_inputs, + self->inputs_received ); - =} + } + =} + + reaction(t) {= + lf_print("Timer ticked at (%lld, %d).", + lf_time_logical_elapsed(), lf_tag().microstep + ); + =} } federated reactor { - c = new Count() - p = new PrintTimer() - c.out -> p.in + c = new Count() + p = new PrintTimer() + c.out -> p.in } diff --git a/test/C/src/generics/ParameterAsArgument.lf b/test/C/src/generics/ParameterAsArgument.lf index 65f91e0488..f6d460279e 100644 --- a/test/C/src/generics/ParameterAsArgument.lf +++ b/test/C/src/generics/ParameterAsArgument.lf @@ -1,27 +1,27 @@ target C reactor Child { - state k: T1 - input in: In - output out: Out + state k: T1 + input in: In + output out: Out - reaction(in) {= - int a = in->value; - printf("Got %d\n", a); - =} + reaction(in) {= + int a = in->value; + printf("Got %d\n", a); + =} } reactor Super { - input in: In - output out: Out - state t1: T1 - c = new Child() - in -> c.in - c.out -> out + input in: In + output out: Out + state t1: T1 + c = new Child() + in -> c.in + c.out -> out } main reactor { - cc = new Super() + cc = new Super() - reaction(startup) -> cc.in {= lf_set(cc.in, 42); =} + reaction(startup) -> cc.in {= lf_set(cc.in, 42); =} } diff --git a/test/C/src/generics/TypeCheck.lf b/test/C/src/generics/TypeCheck.lf index 3080af48ea..168430bbf6 100644 --- a/test/C/src/generics/TypeCheck.lf +++ b/test/C/src/generics/TypeCheck.lf @@ -1,44 +1,44 @@ /** Check that two reactors that use generics can be connected together. */ target C { - timeout: 3 sec, - fast: true + timeout: 3 sec, + fast: true } reactor Count(offset: time = 0, period: time = 1 sec) { - state count: int = 1 - output out: int - timer t(offset, period) + state count: int = 1 + output out: int + timer t(offset, period) - reaction(t) -> out {= lf_set(out, self->count++); =} + reaction(t) -> out {= lf_set(out, self->count++); =} } reactor TestCount(start: int = 1, num_inputs: int = 1) { - state count: int = start - state inputs_received: int = 0 - input in: T + state count: int = start + state inputs_received: int = 0 + input in: T - reaction(in) {= - lf_print("Received %d.", in->value); - if (in->value != self->count) { - lf_print_error_and_exit("Expected %d.", self->count); - } - self->count++; - self->inputs_received++; - =} + reaction(in) {= + lf_print("Received %d.", in->value); + if (in->value != self->count) { + lf_print_error_and_exit("Expected %d.", self->count); + } + self->count++; + self->inputs_received++; + =} - reaction(shutdown) {= - lf_print("Shutdown invoked."); - if (self->inputs_received != self->num_inputs) { - lf_print_error_and_exit("Expected to receive %d inputs, but got %d.", - self->num_inputs, - self->inputs_received - ); - } - =} + reaction(shutdown) {= + lf_print("Shutdown invoked."); + if (self->inputs_received != self->num_inputs) { + lf_print_error_and_exit("Expected to receive %d inputs, but got %d.", + self->num_inputs, + self->inputs_received + ); + } + =} } main reactor { - count = new Count() - testcount = new TestCount(num_inputs = 4) - count.out -> testcount.in + count = new Count() + testcount = new TestCount(num_inputs = 4) + count.out -> testcount.in } diff --git a/test/C/src/zephyr/UserThreads.lf b/test/C/src/zephyr/UserThreads.lf index 115d8114a7..5c19ce6d75 100644 --- a/test/C/src/zephyr/UserThreads.lf +++ b/test/C/src/zephyr/UserThreads.lf @@ -1,39 +1,39 @@ -// Test user threads platform option for Zephyr. The application should be able -// to create exactly three threads. +// Test user threads platform option for Zephyr. The application should be able to create exactly +// three threads. target C { - platform: { - name: Zephyr, - user-threads: 3 - }, - threading: true, - workers: 2 + platform: { + name: Zephyr, + user-threads: 3 + }, + threading: true, + workers: 2 } main reactor { - preamble {= - #include "platform.h" - void func(void* arg) { - lf_print("Hello from user thread"); - } + preamble {= + #include "platform.h" + void func(void* arg) { + lf_print("Hello from user thread"); + } - lf_thread_t thread_ids[4]; - =} + lf_thread_t thread_ids[4]; + =} - reaction(startup) {= - int res; + reaction(startup) {= + int res; - for (int i = 0; i < 3; i++) { - res = lf_thread_create(&thread_ids[i], &func, NULL); - if (res != 0) { - lf_print_error_and_exit("Could not create thread"); - } + for (int i = 0; i < 3; i++) { + res = lf_thread_create(&thread_ids[i], &func, NULL); + if (res != 0) { + lf_print_error_and_exit("Could not create thread"); } + } - res = lf_thread_create(&thread_ids[3], &func, NULL); - if (res == 0) { - lf_print_error_and_exit("Could create more threads than specified."); - } else { - printf("SUCCESS: Created exactly three user threads.\n"); - } - =} + res = lf_thread_create(&thread_ids[3], &func, NULL); + if (res == 0) { + lf_print_error_and_exit("Could create more threads than specified."); + } else { + printf("SUCCESS: Created exactly three user threads.\n"); + } + =} } diff --git a/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf b/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf index 95e6453df0..b0159ceac2 100644 --- a/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf +++ b/test/Python/src/federated/DistributedCountDecentralizedLateHierarchy.lf @@ -16,44 +16,41 @@ import Count from "../lib/Count.lf" import Print from "DistributedCountDecentralizedLateDownstream.lf" reactor ImportantActuator { - input inp - # Count messages that arrive without STP violation. - state success = 0 - state success_stp_violation = 0 - # Force a timer to be invoked periodically - timer t(0, 10 usec) - # to ensure logical time will advance in the absence of incoming messages. - state c = 0 + input inp + state success = 0 # Count messages that arrive without STP violation. + state success_stp_violation = 0 + timer t(0, 10 usec) # Force a timer to be invoked periodically + state c = 0 # to ensure logical time will advance in the absence of incoming messages. - reaction(inp) {= - current_tag = lf.tag() - print(f"ImportantActuator: At tag ({lf.tag().time}, {lf.tag().microstep}) received {inp.value}. " - f"Intended tag is ({inp.intended_tag.time - lf.time.start()}, {inp.intended_tag.microstep}).") - if lf.tag() == Tag((SEC(1) * self.c) + + lf.time.start(), 0): - self.success += 1 # Message was on-time - else: - self.sys.stderr.write("Normal reaction was invoked, but current tag doesn't match expected tag.") - self.sys.exit(1) - self.c += 1 - =} STP(0) {= - current_tag = lf.tag() - print(f"ImportantActuator: At tag ({lf.time.logical_elapsed()}, {lf.tag().microstep}), message has violated the STP offset " - f"by ({lf.tag().time - inp.intended_tag.time}, {lf.tag().microstep - inp.intended_tag.microstep}).") - self.success_stp_violation += 1 - self.c += 1 - =} + reaction(inp) {= + current_tag = lf.tag() + print(f"ImportantActuator: At tag ({lf.tag().time}, {lf.tag().microstep}) received {inp.value}. " + f"Intended tag is ({inp.intended_tag.time - lf.time.start()}, {inp.intended_tag.microstep}).") + if lf.tag() == Tag((SEC(1) * self.c) + + lf.time.start(), 0): + self.success += 1 # Message was on-time + else: + self.sys.stderr.write("Normal reaction was invoked, but current tag doesn't match expected tag.") + self.sys.exit(1) + self.c += 1 + =} STP(0) {= + current_tag = lf.tag() + print(f"ImportantActuator: At tag ({lf.time.logical_elapsed()}, {lf.tag().microstep}), message has violated the STP offset " + f"by ({lf.tag().time - inp.intended_tag.time}, {lf.tag().microstep - inp.intended_tag.microstep}).") + self.success_stp_violation += 1 + self.c += 1 + =} - reaction(t) {= - # Do nothing. - =} + reaction(t) {= + # Do nothing. + =} - reaction(shutdown) {= - if (self.success + self.success_stp_violation) != 5: - self.sys.stderr.write("Failed to detect STP violation in messages.") - self.sys.exit(1) - else: - print(f"Successfully detected STP violations ({self.success_stp_violation} violations, {self.success} on-time).") - =} + reaction(shutdown) {= + if (self.success + self.success_stp_violation) != 5: + self.sys.stderr.write("Failed to detect STP violation in messages.") + self.sys.exit(1) + else: + print(f"Successfully detected STP violations ({self.success_stp_violation} violations, {self.success} on-time).") + =} } reactor Receiver { From c3e69e17645a16d981827f8a8ef07e85d732aac1 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 3 Jun 2023 18:28:37 -0700 Subject: [PATCH 661/709] Make name mangling stateless again. The assignment of mangled names is too complex when compiling several distinct programs in the same JAR execution because it causes them to interact with each other by changing the number of reactors that have the same name. We can patch this up, but it is safer and easier to just eliminate the global variables. It will make the generated code uglier, but maybe life is too short to worry about that. --- .../generator/c/TypeParameterizedReactor.java | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index 758e1ec6cf..a9be5739c5 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -18,9 +18,6 @@ */ public record TypeParameterizedReactor(Reactor reactor, Map typeArgs) { - private static final Map uniqueNames = new HashMap<>(); - private static final Map nameCounts = new HashMap<>(); - /** * Construct the TPR corresponding to the given instantiation which syntactically appears within * the definition corresponding to {@code parent}. @@ -94,18 +91,9 @@ public InferredType resolveType(InferredType t) { * Return a name that is unique to this TypeParameterizedReactor (up to structural equality) and * that is prefixed with exactly one underscore and that does not contain any upper-case letters. */ - public synchronized String uniqueName() { - String name = reactor.getName().toLowerCase(); - if (uniqueNames.containsKey(this)) return uniqueNames.get(this); - if (nameCounts.containsKey(name)) { - int currentCount = nameCounts.get(name); - nameCounts.put(name, currentCount + 1); - uniqueNames.put(this, "_" + name + currentCount); - return uniqueName(); - } - nameCounts.put(name, 1); - uniqueNames.put(this, "_" + name); - return uniqueName(); + public String uniqueName() { + var resolved = ASTUtils.toDefinition(reactor); + return "_" + resolved.getName().toLowerCase() + (typeArgs.hashCode() + resolved.eResource().getURI().hashCode() * 31); } @Override From c69f85ce600d7685d540905b6eb77d5f64fd03d7 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 3 Jun 2023 18:47:42 -0700 Subject: [PATCH 662/709] Bugfix. --- .../java/org/lflang/generator/c/TypeParameterizedReactor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index a9be5739c5..77fee811e9 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -93,7 +93,7 @@ public InferredType resolveType(InferredType t) { */ public String uniqueName() { var resolved = ASTUtils.toDefinition(reactor); - return "_" + resolved.getName().toLowerCase() + (typeArgs.hashCode() + resolved.eResource().getURI().hashCode() * 31); + return ("_" + resolved.getName().toLowerCase() + (typeArgs.hashCode() + resolved.eResource().getURI().hashCode() * 31)).replace('-', '_'); } @Override From 932b8739ab60eea14d77a7a073abecaa05a189b1 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 3 Jun 2023 20:18:36 -0700 Subject: [PATCH 663/709] Change uniqueName mechanism again. --- .../org/lflang/generator/c/CFileConfig.java | 30 ++++++++++++++++ .../org/lflang/generator/c/CGenerator.java | 1 + .../generator/c/TypeParameterizedReactor.java | 36 +++++++++++-------- 3 files changed, 53 insertions(+), 14 deletions(-) diff --git a/core/src/main/java/org/lflang/generator/c/CFileConfig.java b/core/src/main/java/org/lflang/generator/c/CFileConfig.java index db9447a833..4ace643e91 100644 --- a/core/src/main/java/org/lflang/generator/c/CFileConfig.java +++ b/core/src/main/java/org/lflang/generator/c/CFileConfig.java @@ -1,12 +1,20 @@ package org.lflang.generator.c; +import org.eclipse.emf.common.util.URI; import java.io.IOException; import java.nio.file.Path; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import org.eclipse.emf.ecore.resource.Resource; import org.lflang.FileConfig; +import org.lflang.ast.ASTUtils; +import org.lflang.lf.Reactor; +import org.lflang.lf.ReactorDecl; public class CFileConfig extends FileConfig { private final Path includePath; + private Map> nameMap; public CFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) throws IOException { @@ -20,6 +28,28 @@ public CFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchic .resolve(srcFile.getFileName().toString().split("\\.")[0]); } + public void setNameMap(List reactors) { + Map countMap = new HashMap<>(); + assert nameMap == null; + nameMap = new HashMap<>(); + for (var reactor : reactors) { + var def = ASTUtils.toDefinition(reactor); + if (nameMap.containsKey(def.getName())) { + nameMap.get(def.getName()).put(def.eResource().getURI(), countMap.get(def.getName())); + countMap.put(def.getName(), countMap.get(def.getName())); + } else { + nameMap.put(def.getName(), new HashMap<>()); + nameMap.get(def.getName()).put(def.eResource().getURI(), 0); + countMap.put(def.getName(), 1); + } + } + } + + public String uniqueName(ReactorDecl decl) { + var name = decl.getName(); + return name + (nameMap.get(name).get(decl.eResource().getURI()) == 0 ? "" : nameMap.get(name)); + } + public Path getIncludePath() { return includePath; } diff --git a/core/src/main/java/org/lflang/generator/c/CGenerator.java b/core/src/main/java/org/lflang/generator/c/CGenerator.java index 85b755e4a1..2a1562976d 100644 --- a/core/src/main/java/org/lflang/generator/c/CGenerator.java +++ b/core/src/main/java/org/lflang/generator/c/CGenerator.java @@ -319,6 +319,7 @@ protected CGenerator( DelayBodyGenerator delayBodyGenerator) { super(context); this.fileConfig = (CFileConfig) context.getFileConfig(); + fileConfig.setNameMap(reactors); this.CCppMode = CCppMode; this.types = types; this.cmakeGenerator = cmakeGenerator; diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index 77fee811e9..1efaecec90 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -1,6 +1,7 @@ package org.lflang.generator.c; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.stream.Collectors; import org.lflang.InferredType; @@ -9,15 +10,17 @@ import org.lflang.lf.Instantiation; import org.lflang.lf.Reactor; import org.lflang.lf.Type; +import org.lflang.lf.TypeParm; /** * A reactor class combined with concrete type arguments bound to its type parameters. - * - * @param reactor The syntactic reactor class definition - * @param typeArgs The type arguments associated with this particular variant of the reactor class. */ -public record TypeParameterizedReactor(Reactor reactor, Map typeArgs) { - +public class TypeParameterizedReactor { + /** The syntactic reactor class definition. */ + private final Reactor reactor; + /** The type arguments associated with this particular variant of the reactor class. */ + private final Map typeArgs; + private final List typeParams; /** * Construct the TPR corresponding to the given instantiation which syntactically appears within * the definition corresponding to {@code parent}. @@ -27,19 +30,20 @@ public record TypeParameterizedReactor(Reactor reactor, Map typeAr * permitted instead of types in this TPR. */ public TypeParameterizedReactor(Instantiation i, TypeParameterizedReactor parent) { - this( - ASTUtils.toDefinition(i.getReactorClass()), - addTypeArgs(i, ASTUtils.toDefinition(i.getReactorClass()), parent)); + reactor = ASTUtils.toDefinition(i.getReactorClass()); + var definition = ASTUtils.toDefinition(i.getReactorClass()); + typeParams = definition.getTypeParms().stream().map(TypeParm::getLiteral).toList(); + typeArgs = addTypeArgs(i, parent); } - private static Map addTypeArgs( - Instantiation instantiation, Reactor r, TypeParameterizedReactor parent) { + private Map addTypeArgs( + Instantiation instantiation, TypeParameterizedReactor parent) { HashMap ret = new HashMap<>(); if (instantiation.getTypeArgs() != null) { - for (int i = 0; i < r.getTypeParms().size(); i++) { + for (int i = 0; i < typeParams.size(); i++) { var arg = instantiation.getTypeArgs().get(i); ret.put( - r.getTypeParms().get(i).getLiteral(), parent == null ? arg : parent.resolveType(arg)); + typeParams.get(i), parent == null ? arg : parent.resolveType(arg)); } } return ret; @@ -91,9 +95,9 @@ public InferredType resolveType(InferredType t) { * Return a name that is unique to this TypeParameterizedReactor (up to structural equality) and * that is prefixed with exactly one underscore and that does not contain any upper-case letters. */ - public String uniqueName() { + public String uniqueName(CFileConfig fileConfig) { var resolved = ASTUtils.toDefinition(reactor); - return ("_" + resolved.getName().toLowerCase() + (typeArgs.hashCode() + resolved.eResource().getURI().hashCode() * 31)).replace('-', '_'); + return "_" + fileConfig.uniqueName(resolved) + typeParams.stream().map(it -> it + "_" + typeArgs.get(it)).collect(Collectors.joining("_")); } @Override @@ -107,4 +111,8 @@ public boolean equals(Object obj) { && reactor.equals(other.reactor) && typeArgs.equals(other.typeArgs); } + + public Reactor reactor() { + return reactor; + } } From cf8d0577335b2541af2115004330c524207e228d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sat, 3 Jun 2023 21:19:50 -0700 Subject: [PATCH 664/709] Pass around the name assignments. --- core/src/main/java/org/lflang/ModelInfo.java | 4 +- .../synthesis/LinguaFrancaSynthesis.java | 4 +- .../federated/extensions/CExtension.java | 6 +-- .../federated/extensions/TSExtension.java | 4 +- .../federated/generator/FedGenerator.java | 2 +- .../org/lflang/generator/ReactorInstance.java | 24 ++++------ .../org/lflang/generator/c/CFileConfig.java | 23 ---------- .../org/lflang/generator/c/CGenerator.java | 5 +- .../generator/c/TypeParameterizedReactor.java | 46 ++++++++++++++++--- .../org/lflang/validation/LFValidator.java | 2 +- 10 files changed, 62 insertions(+), 58 deletions(-) diff --git a/core/src/main/java/org/lflang/ModelInfo.java b/core/src/main/java/org/lflang/ModelInfo.java index 17ee7cfb76..db487c6308 100644 --- a/core/src/main/java/org/lflang/ModelInfo.java +++ b/core/src/main/java/org/lflang/ModelInfo.java @@ -108,12 +108,12 @@ public void update(Model model, ErrorReporter reporter) { var main = model.getReactors().stream().filter(it -> it.isMain() || it.isFederated()).findFirst(); if (main.isPresent()) { - var inst = new ReactorInstance(main.get(), reporter); + var inst = new ReactorInstance(main.get(), reporter, List.of()); // FIXME: This might work, but it breaks invariants. topLevelReactorInstances.add(inst); } else { model .getReactors() - .forEach(it -> topLevelReactorInstances.add(new ReactorInstance(it, reporter))); + .forEach(it -> topLevelReactorInstances.add(new ReactorInstance(it, reporter, List.of()))); // FIXME: This might work, but it breaks invariants. } // don't store the graph into a field, only the cycles. for (ReactorInstance top : topLevelReactorInstances) { diff --git a/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java b/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java index 45f3342a0a..4858100ced 100644 --- a/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java +++ b/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java @@ -303,7 +303,7 @@ public KNode transform(final Model model) { Reactor main = IterableExtensions.findFirst(model.getReactors(), _utilityExtensions::isMainOrFederated); if (main != null) { - ReactorInstance reactorInstance = new ReactorInstance(main, new SynthesisErrorReporter()); + ReactorInstance reactorInstance = new ReactorInstance(main, new SynthesisErrorReporter(), List.of()); rootNode .getChildren() .addAll(createReactorNode(reactorInstance, true, null, null, new HashMap<>())); @@ -319,7 +319,7 @@ public KNode transform(final Model model) { for (Reactor reactor : model.getReactors()) { if (reactor == main) continue; ReactorInstance reactorInstance = - new ReactorInstance(reactor, new SynthesisErrorReporter()); + new ReactorInstance(reactor, new SynthesisErrorReporter(), List.of()); reactorNodes.addAll( createReactorNode( reactorInstance, diff --git a/core/src/main/java/org/lflang/federated/extensions/CExtension.java b/core/src/main/java/org/lflang/federated/extensions/CExtension.java index 121cf5d817..687316815e 100644 --- a/core/src/main/java/org/lflang/federated/extensions/CExtension.java +++ b/core/src/main/java/org/lflang/federated/extensions/CExtension.java @@ -593,7 +593,7 @@ private String generateInitializeTriggers( var federatedReactor = FedASTUtils.findFederatedReactor(federate.instantiation.eResource()); var oldFederatedReactorName = federatedReactor.getName(); federatedReactor.setName(federate.name); - var main = new ReactorInstance(federatedReactor, errorReporter, 1); + var main = new ReactorInstance(federatedReactor, errorReporter, 1, List.of()); code.pr(CExtensionUtils.initializeTriggersForNetworkActions(federate, main)); code.pr(CExtensionUtils.initializeTriggerForControlReactions(main, main, federate)); federatedReactor.setName(oldFederatedReactorName); @@ -773,8 +773,8 @@ private String generateCodeForPhysicalActions( new ReactorInstance( FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), errorReporter, - 1); - var instance = new ReactorInstance(federateClass, main, errorReporter); + 1, List.of()); + var instance = new ReactorInstance(federateClass, main, errorReporter, List.of()); var outputDelayMap = federate.findOutputsConnectedToPhysicalActions(instance); var minDelay = TimeValue.MAX_VALUE; Output outputFound = null; diff --git a/core/src/main/java/org/lflang/federated/extensions/TSExtension.java b/core/src/main/java/org/lflang/federated/extensions/TSExtension.java index 14df96afb5..57f6dc958d 100644 --- a/core/src/main/java/org/lflang/federated/extensions/TSExtension.java +++ b/core/src/main/java/org/lflang/federated/extensions/TSExtension.java @@ -159,8 +159,8 @@ private TimeValue getMinOutputDelay( new ReactorInstance( FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), errorReporter, - 1); - var instance = new ReactorInstance(federateClass, main, errorReporter); + 1, List.of()); + var instance = new ReactorInstance(federateClass, main, errorReporter, List.of()); var outputDelayMap = federate.findOutputsConnectedToPhysicalActions(instance); var minOutputDelay = TimeValue.MAX_VALUE; Output outputFound = null; diff --git a/core/src/main/java/org/lflang/federated/generator/FedGenerator.java b/core/src/main/java/org/lflang/federated/generator/FedGenerator.java index 6656a489f8..0a83d880a4 100644 --- a/core/src/main/java/org/lflang/federated/generator/FedGenerator.java +++ b/core/src/main/java/org/lflang/federated/generator/FedGenerator.java @@ -481,7 +481,7 @@ private void replaceFederateConnectionsWithProxies(Reactor federation) { // to duplicate the rather complicated logic in that class. We specify a depth of 1, // so it only creates the reactors immediately within the top level, not reactors // that those contain. - ReactorInstance mainInstance = new ReactorInstance(federation, errorReporter); + ReactorInstance mainInstance = new ReactorInstance(federation, errorReporter, List.of()); for (ReactorInstance child : mainInstance.children) { for (PortInstance output : child.outputs) { diff --git a/core/src/main/java/org/lflang/generator/ReactorInstance.java b/core/src/main/java/org/lflang/generator/ReactorInstance.java index 9288744d65..b4a01665d6 100644 --- a/core/src/main/java/org/lflang/generator/ReactorInstance.java +++ b/core/src/main/java/org/lflang/generator/ReactorInstance.java @@ -1,5 +1,3 @@ -/** A data structure for a reactor instance. */ - /************* * Copyright (c) 2019-2022, The University of California at Berkeley. * @@ -91,8 +89,8 @@ public class ReactorInstance extends NamedInstance { * @param reactor The top-level reactor. * @param reporter The error reporter. */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter) { - this(ASTUtils.createInstantiation(reactor), null, reporter, -1); + public ReactorInstance(Reactor reactor, ErrorReporter reporter, List reactors) { + this(ASTUtils.createInstantiation(reactor), null, reporter, -1, reactors); } /** @@ -103,8 +101,8 @@ public ReactorInstance(Reactor reactor, ErrorReporter reporter) { * @param reporter The error reporter. * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth) { - this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth); + public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth, List reactors) { + this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth, reactors); } /** @@ -115,8 +113,8 @@ public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth * @param parent The parent reactor instance. * @param reporter The error reporter. */ - public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter) { - this(ASTUtils.createInstantiation(reactor), parent, reporter, -1); + public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter, List reactors) { + this(ASTUtils.createInstantiation(reactor), parent, reporter, -1, reactors); } ////////////////////////////////////////////////////// @@ -790,12 +788,12 @@ protected void createWatchdogInstances() { * @param desiredDepth The depth to which to expand the hierarchy. */ public ReactorInstance( - Instantiation definition, ReactorInstance parent, ErrorReporter reporter, int desiredDepth) { + Instantiation definition, ReactorInstance parent, ErrorReporter reporter, int desiredDepth, List reactors) { super(definition, parent); this.reporter = reporter; this.reactorDeclaration = definition.getReactorClass(); this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); - this.tpr = new TypeParameterizedReactor(definition, parent == null ? null : parent.tpr); + this.tpr = parent == null ? new TypeParameterizedReactor(definition, reactors) : new TypeParameterizedReactor(definition, parent.tpr); // check for recursive instantiation var currentParent = parent; @@ -845,7 +843,7 @@ public ReactorInstance( // Instantiate children for this reactor instance. // While doing this, assign an index offset to each. for (Instantiation child : ASTUtils.allInstantiations(reactorDefinition)) { - var childInstance = new ReactorInstance(child, this, reporter, desiredDepth); + var childInstance = new ReactorInstance(child, this, reporter, desiredDepth, reactors); this.children.add(childInstance); } @@ -879,10 +877,6 @@ public ReactorInstance( } } - public TypeParameterizedReactor getTypeParameterizedReactor() { - return this.tpr; - } - ////////////////////////////////////////////////////// //// Private methods. diff --git a/core/src/main/java/org/lflang/generator/c/CFileConfig.java b/core/src/main/java/org/lflang/generator/c/CFileConfig.java index 4ace643e91..491c604222 100644 --- a/core/src/main/java/org/lflang/generator/c/CFileConfig.java +++ b/core/src/main/java/org/lflang/generator/c/CFileConfig.java @@ -14,7 +14,6 @@ public class CFileConfig extends FileConfig { private final Path includePath; - private Map> nameMap; public CFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) throws IOException { @@ -28,28 +27,6 @@ public CFileConfig(Resource resource, Path srcGenBasePath, boolean useHierarchic .resolve(srcFile.getFileName().toString().split("\\.")[0]); } - public void setNameMap(List reactors) { - Map countMap = new HashMap<>(); - assert nameMap == null; - nameMap = new HashMap<>(); - for (var reactor : reactors) { - var def = ASTUtils.toDefinition(reactor); - if (nameMap.containsKey(def.getName())) { - nameMap.get(def.getName()).put(def.eResource().getURI(), countMap.get(def.getName())); - countMap.put(def.getName(), countMap.get(def.getName())); - } else { - nameMap.put(def.getName(), new HashMap<>()); - nameMap.get(def.getName()).put(def.eResource().getURI(), 0); - countMap.put(def.getName(), 1); - } - } - } - - public String uniqueName(ReactorDecl decl) { - var name = decl.getName(); - return name + (nameMap.get(name).get(decl.eResource().getURI()) == 0 ? "" : nameMap.get(name)); - } - public Path getIncludePath() { return includePath; } diff --git a/core/src/main/java/org/lflang/generator/c/CGenerator.java b/core/src/main/java/org/lflang/generator/c/CGenerator.java index 2a1562976d..47a65f65bf 100644 --- a/core/src/main/java/org/lflang/generator/c/CGenerator.java +++ b/core/src/main/java/org/lflang/generator/c/CGenerator.java @@ -319,7 +319,6 @@ protected CGenerator( DelayBodyGenerator delayBodyGenerator) { super(context); this.fileConfig = (CFileConfig) context.getFileConfig(); - fileConfig.setNameMap(reactors); this.CCppMode = CCppMode; this.types = types; this.cmakeGenerator = cmakeGenerator; @@ -849,7 +848,7 @@ private void generateReactorDefinitions() throws IOException { var generatedReactors = new LinkedHashSet(); if (this.main != null) { generateReactorChildren(this.main, generatedReactors); - generateReactorClass(this.main.getTypeParameterizedReactor()); + generateReactorClass(new TypeParameterizedReactor(this.mainDef, reactors)); } // do not generate code for reactors that are not instantiated } @@ -2096,7 +2095,7 @@ private void createMainReactorInstance() { if (this.mainDef != null) { if (this.main == null) { // Recursively build instances. - this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter); + this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter, reactors); var reactionInstanceGraph = this.main.assignLevels(); if (reactionInstanceGraph.nodeCount() > 0) { errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index 1efaecec90..6bb7d04b9f 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -3,14 +3,15 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import java.util.stream.Collectors; + +import com.google.common.collect.ImmutableMap; +import org.eclipse.emf.common.util.URI; import org.lflang.InferredType; import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; -import org.lflang.lf.Instantiation; -import org.lflang.lf.Reactor; -import org.lflang.lf.Type; -import org.lflang.lf.TypeParm; +import org.lflang.lf.*; /** * A reactor class combined with concrete type arguments bound to its type parameters. @@ -21,6 +22,8 @@ public class TypeParameterizedReactor { /** The type arguments associated with this particular variant of the reactor class. */ private final Map typeArgs; private final List typeParams; + private final ImmutableMap> nameMap; + /** * Construct the TPR corresponding to the given instantiation which syntactically appears within * the definition corresponding to {@code parent}. @@ -30,10 +33,41 @@ public class TypeParameterizedReactor { * permitted instead of types in this TPR. */ public TypeParameterizedReactor(Instantiation i, TypeParameterizedReactor parent) { + this(i, parent, parent.nameMap); + } + + public TypeParameterizedReactor(Instantiation i, List reactors) { + this(i, null, getNameMap(reactors)); + } + + private static Map> getNameMap(List reactors) { + Map> nameMap = new HashMap<>(); + Map countMap = new HashMap<>(); + for (var reactor : reactors) { + var def = ASTUtils.toDefinition(reactor); + if (nameMap.containsKey(def.getName())) { + nameMap.get(def.getName()).put(def.eResource().getURI(), countMap.get(def.getName())); + countMap.put(def.getName(), countMap.get(def.getName())); + } else { + nameMap.put(def.getName(), new HashMap<>()); + nameMap.get(def.getName()).put(def.eResource().getURI(), 0); + countMap.put(def.getName(), 1); + } + } + return nameMap; + } + + private String uniqueName(ReactorDecl decl) { + var name = decl.getName(); + return name + (Objects.requireNonNull(nameMap.get(name)).get(decl.eResource().getURI()) == 0 ? "" : nameMap.get(name)); + } + + private TypeParameterizedReactor(Instantiation i, TypeParameterizedReactor parent, Map> nameMap) { reactor = ASTUtils.toDefinition(i.getReactorClass()); var definition = ASTUtils.toDefinition(i.getReactorClass()); typeParams = definition.getTypeParms().stream().map(TypeParm::getLiteral).toList(); typeArgs = addTypeArgs(i, parent); + this.nameMap = ImmutableMap.copyOf(nameMap); } private Map addTypeArgs( @@ -95,9 +129,9 @@ public InferredType resolveType(InferredType t) { * Return a name that is unique to this TypeParameterizedReactor (up to structural equality) and * that is prefixed with exactly one underscore and that does not contain any upper-case letters. */ - public String uniqueName(CFileConfig fileConfig) { + public String uniqueName() { var resolved = ASTUtils.toDefinition(reactor); - return "_" + fileConfig.uniqueName(resolved) + typeParams.stream().map(it -> it + "_" + typeArgs.get(it)).collect(Collectors.joining("_")); + return "_" + uniqueName(resolved) + typeParams.stream().map(it -> it + "_" + typeArgs.get(it)).collect(Collectors.joining("_")); } @Override diff --git a/core/src/main/java/org/lflang/validation/LFValidator.java b/core/src/main/java/org/lflang/validation/LFValidator.java index 7dd7a78f7a..d228a2dba6 100644 --- a/core/src/main/java/org/lflang/validation/LFValidator.java +++ b/core/src/main/java/org/lflang/validation/LFValidator.java @@ -221,7 +221,7 @@ private Type portTypeIfResolvable(VarRef port) { var portType = ((Port) port.getVariable()).getType(); return port.getContainer() == null ? portType - : new TypeParameterizedReactor(port.getContainer(), null).resolveType(portType); + : new TypeParameterizedReactor(port.getContainer(), List.of()).resolveType(portType); } @Check(CheckType.FAST) From 99d059239efb2961bc83ed173f6638da31b37de6 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 09:50:56 -0700 Subject: [PATCH 665/709] Fix CI. --- .github/workflows/check-diff.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index af14720136..3633344d5d 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -36,10 +36,10 @@ jobs: - id: do run: | wget https://raw.githubusercontent.com/lf-lang/lingua-franca/master/.github/scripts/check-diff.sh - source check-diff.sh "core/src/main/java/generator/c\|/home/peter/lingua-franca/core/src/main/resources/lib/c\|core/src/main/resources/lib/platform\|test/C" C - source check-diff.sh "core/src/main/kotlin/generator/cpp\|core/src/main/resources/lib/cpp\|test/Cpp" CPP - source check-diff.sh "core/src/main/java/generator/python\|core/src/main/resources/lib/py\|test/Python" PY - source check-diff.sh "core/src/main/kotlin/generator/rust\|core/src/main/java/generator/rust\|core/src/main/resources/lib/rs\|test/Rust" RS - source check-diff.sh "core/src/main/kotlin/generator/ts\|core/src/main/java/generator/ts\|core/src/main/resources/lib/ts\|test/TypeScript" TS + source check-diff.sh "core/src/main/java/org/lflang/generator/c\|core/src/main/resources/lib/c\|core/src/main/resources/lib/platform\|test/C" C + source check-diff.sh "core/src/main/kotlin/org/lflang/generator/cpp\|core/src/main/resources/lib/cpp\|test/Cpp" CPP + source check-diff.sh "core/src/main/java/org/lflang/generator/python\|core/src/main/resources/lib/py\|test/Python" PY + source check-diff.sh "core/src/main/kotlin/org/lflang/generator/rust\|core/src/main/java/org/lflang/generator/rust\|core/src/main/resources/lib/rs\|test/Rust" RS + source check-diff.sh "core/src/main/kotlin/org/lflang/generator/ts\|core/src/main/java/org/lflang/generator/ts\|core/src/main/resources/lib/ts\|test/TypeScript" TS source check-diff.sh "util/tracing" TRACING shell: bash From f30599a424a4205b8d67c6554382aa241ff11f00 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 09:59:25 -0700 Subject: [PATCH 666/709] Bugfix. --- .../java/org/lflang/generator/c/TypeParameterizedReactor.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index 6bb7d04b9f..b0741babea 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -58,7 +58,7 @@ private static Map> getNameMap(List reactors) } private String uniqueName(ReactorDecl decl) { - var name = decl.getName(); + var name = decl.getName().toLowerCase(); return name + (Objects.requireNonNull(nameMap.get(name)).get(decl.eResource().getURI()) == 0 ? "" : nameMap.get(name)); } From 05ba9c5ad29ee370f9b09122bd8bc0efe2f07241 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Fri, 2 Jun 2023 17:16:28 -0700 Subject: [PATCH 667/709] Run all categories of C tests. I do not want to stop running tests when one category fails. I would also like to experiment with increasing the amount of parallelism. --- .github/workflows/c-tests.yml | 19 ++++++-- .github/workflows/only-c.yml | 87 ++++++++++++++++++++++++++++++++++- 2 files changed, 102 insertions(+), 4 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 956fb4c967..2bf7a3a371 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -20,9 +20,14 @@ on: required: false default: true type: boolean + selected-tests: + required: false + default: "" # "" means run all tests until failure + type: string jobs: regular-tests: + name: ${{ inputs.selected-tests }} strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} @@ -55,15 +60,23 @@ jobs: if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform tests for C target with default scheduler run: ./gradlew targetTest -Ptarget=C - if: ${{ !inputs.use-cpp && !inputs.scheduler }} + if: ${{ !inputs.use-cpp && !inputs.scheduler && inputs.selected-tests == '' }} - name: Perform tests for C target with specified scheduler (no LSP tests) run: | echo "Specified scheduler: ${{ inputs.scheduler }}" ./gradlew targetTest -Ptarget=C -Dscheduler=${{ inputs.scheduler }} - if: ${{ !inputs.use-cpp && inputs.scheduler }} + if: ${{ !inputs.use-cpp && inputs.scheduler && inputs.selected-tests == '' }} - name: Perform tests for CCpp target with default scheduler run: ./gradlew targetTest -Ptarget=CCpp - if: ${{ inputs.use-cpp && !inputs.scheduler }} + if: ${{ inputs.use-cpp && !inputs.scheduler && inputs.selected-tests == '' }} + - name: Perform tests for C target with default scheduler + run: ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CTest.${{ inputs.selected-tests }} + if: ${{ !inputs.use-cpp && !inputs.scheduler && inputs.selected-tests != '' }} + - name: Perform tests for C target with specified scheduler (no LSP tests) + run: | + echo "Specified scheduler: ${{ inputs.scheduler }}" + ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CTest.${{ inputs.selected-tests }} -Dscheduler=${{ inputs.scheduler }} + if: ${{ inputs.use-cpp && !inputs.scheduler && inputs.selected-tests != '' }} - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index bb4752471b..195624cedc 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -17,11 +17,96 @@ concurrency: jobs: # Run the C integration tests. - default: + default0: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runGenericTests + + default1: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runTargetSpecificTests + + default2: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runMultiportTests + + default3: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runTypeParameterTests + + default4: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runAsFederated + + default5: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runConcurrentTests + + default6: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runFederatedTests + + default7: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runModalTests + + default8: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runNoInliningTests + + default9: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runDockerTests + + default10: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runDockerFederatedTests + + default11: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runWithThreadingOff + + default12: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runEnclaveTests # Run the C benchmark tests. benchmarking: From 81f4b81e8ca8a10392c805ffcfb17f95fc854731 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 12:18:36 -0700 Subject: [PATCH 668/709] Fix capitalization issue. --- .../generator/c/TypeParameterizedReactor.java | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index b0741babea..ff0e0568bb 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -45,13 +45,14 @@ private static Map> getNameMap(List reactors) Map countMap = new HashMap<>(); for (var reactor : reactors) { var def = ASTUtils.toDefinition(reactor); - if (nameMap.containsKey(def.getName())) { - nameMap.get(def.getName()).put(def.eResource().getURI(), countMap.get(def.getName())); - countMap.put(def.getName(), countMap.get(def.getName())); + var name = def.getName().toLowerCase(); + if (nameMap.containsKey(name)) { + nameMap.get(name).put(def.eResource().getURI(), countMap.get(name)); + countMap.put(name, countMap.get(name)); } else { - nameMap.put(def.getName(), new HashMap<>()); - nameMap.get(def.getName()).put(def.eResource().getURI(), 0); - countMap.put(def.getName(), 1); + nameMap.put(name, new HashMap<>()); + nameMap.get(name).put(def.eResource().getURI(), 0); + countMap.put(name, 1); } } return nameMap; From d907fbc30975c5039da69474e50c841f9208ecb2 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 13:31:47 -0700 Subject: [PATCH 669/709] Bugfix. --- .../java/org/lflang/generator/c/TypeParameterizedReactor.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index ff0e0568bb..9fa76d496d 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -60,7 +60,8 @@ private static Map> getNameMap(List reactors) private String uniqueName(ReactorDecl decl) { var name = decl.getName().toLowerCase(); - return name + (Objects.requireNonNull(nameMap.get(name)).get(decl.eResource().getURI()) == 0 ? "" : nameMap.get(name)); + var number = Objects.requireNonNull(nameMap.get(name)).get(decl.eResource().getURI()); + return name + (number == 0 ? "" : number); } private TypeParameterizedReactor(Instantiation i, TypeParameterizedReactor parent, Map> nameMap) { From e5c178ddfa799b810101d1df5f71ff5de501e9b8 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 13:32:56 -0700 Subject: [PATCH 670/709] Run formatter. --- core/src/main/java/org/lflang/ModelInfo.java | 13 ++++++++++-- .../synthesis/LinguaFrancaSynthesis.java | 3 ++- .../federated/extensions/CExtension.java | 3 ++- .../federated/extensions/TSExtension.java | 3 ++- .../org/lflang/generator/ReactorInstance.java | 17 ++++++++++++---- .../org/lflang/generator/c/CFileConfig.java | 7 ------- .../org/lflang/generator/c/CGenerator.java | 3 ++- .../generator/c/TypeParameterizedReactor.java | 20 ++++++++++--------- 8 files changed, 43 insertions(+), 26 deletions(-) diff --git a/core/src/main/java/org/lflang/ModelInfo.java b/core/src/main/java/org/lflang/ModelInfo.java index db487c6308..fd4e05d6d3 100644 --- a/core/src/main/java/org/lflang/ModelInfo.java +++ b/core/src/main/java/org/lflang/ModelInfo.java @@ -108,12 +108,21 @@ public void update(Model model, ErrorReporter reporter) { var main = model.getReactors().stream().filter(it -> it.isMain() || it.isFederated()).findFirst(); if (main.isPresent()) { - var inst = new ReactorInstance(main.get(), reporter, List.of()); // FIXME: This might work, but it breaks invariants. + var inst = + new ReactorInstance( + main.get(), + reporter, + List.of()); // FIXME: This might work, but it breaks invariants. topLevelReactorInstances.add(inst); } else { model .getReactors() - .forEach(it -> topLevelReactorInstances.add(new ReactorInstance(it, reporter, List.of()))); // FIXME: This might work, but it breaks invariants. + .forEach( + it -> + topLevelReactorInstances.add( + new ReactorInstance( + it, reporter, + List.of()))); // FIXME: This might work, but it breaks invariants. } // don't store the graph into a field, only the cycles. for (ReactorInstance top : topLevelReactorInstances) { diff --git a/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java b/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java index 4858100ced..cbe57a34e6 100644 --- a/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java +++ b/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java @@ -303,7 +303,8 @@ public KNode transform(final Model model) { Reactor main = IterableExtensions.findFirst(model.getReactors(), _utilityExtensions::isMainOrFederated); if (main != null) { - ReactorInstance reactorInstance = new ReactorInstance(main, new SynthesisErrorReporter(), List.of()); + ReactorInstance reactorInstance = + new ReactorInstance(main, new SynthesisErrorReporter(), List.of()); rootNode .getChildren() .addAll(createReactorNode(reactorInstance, true, null, null, new HashMap<>())); diff --git a/core/src/main/java/org/lflang/federated/extensions/CExtension.java b/core/src/main/java/org/lflang/federated/extensions/CExtension.java index 687316815e..d41dc823b3 100644 --- a/core/src/main/java/org/lflang/federated/extensions/CExtension.java +++ b/core/src/main/java/org/lflang/federated/extensions/CExtension.java @@ -773,7 +773,8 @@ private String generateCodeForPhysicalActions( new ReactorInstance( FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), errorReporter, - 1, List.of()); + 1, + List.of()); var instance = new ReactorInstance(federateClass, main, errorReporter, List.of()); var outputDelayMap = federate.findOutputsConnectedToPhysicalActions(instance); var minDelay = TimeValue.MAX_VALUE; diff --git a/core/src/main/java/org/lflang/federated/extensions/TSExtension.java b/core/src/main/java/org/lflang/federated/extensions/TSExtension.java index 57f6dc958d..c04c6672d9 100644 --- a/core/src/main/java/org/lflang/federated/extensions/TSExtension.java +++ b/core/src/main/java/org/lflang/federated/extensions/TSExtension.java @@ -159,7 +159,8 @@ private TimeValue getMinOutputDelay( new ReactorInstance( FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), errorReporter, - 1, List.of()); + 1, + List.of()); var instance = new ReactorInstance(federateClass, main, errorReporter, List.of()); var outputDelayMap = federate.findOutputsConnectedToPhysicalActions(instance); var minOutputDelay = TimeValue.MAX_VALUE; diff --git a/core/src/main/java/org/lflang/generator/ReactorInstance.java b/core/src/main/java/org/lflang/generator/ReactorInstance.java index b4a01665d6..a793f39442 100644 --- a/core/src/main/java/org/lflang/generator/ReactorInstance.java +++ b/core/src/main/java/org/lflang/generator/ReactorInstance.java @@ -101,7 +101,8 @@ public ReactorInstance(Reactor reactor, ErrorReporter reporter, List re * @param reporter The error reporter. * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. */ - public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth, List reactors) { + public ReactorInstance( + Reactor reactor, ErrorReporter reporter, int desiredDepth, List reactors) { this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth, reactors); } @@ -113,7 +114,8 @@ public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth * @param parent The parent reactor instance. * @param reporter The error reporter. */ - public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter, List reactors) { + public ReactorInstance( + Reactor reactor, ReactorInstance parent, ErrorReporter reporter, List reactors) { this(ASTUtils.createInstantiation(reactor), parent, reporter, -1, reactors); } @@ -788,12 +790,19 @@ protected void createWatchdogInstances() { * @param desiredDepth The depth to which to expand the hierarchy. */ public ReactorInstance( - Instantiation definition, ReactorInstance parent, ErrorReporter reporter, int desiredDepth, List reactors) { + Instantiation definition, + ReactorInstance parent, + ErrorReporter reporter, + int desiredDepth, + List reactors) { super(definition, parent); this.reporter = reporter; this.reactorDeclaration = definition.getReactorClass(); this.reactorDefinition = ASTUtils.toDefinition(reactorDeclaration); - this.tpr = parent == null ? new TypeParameterizedReactor(definition, reactors) : new TypeParameterizedReactor(definition, parent.tpr); + this.tpr = + parent == null + ? new TypeParameterizedReactor(definition, reactors) + : new TypeParameterizedReactor(definition, parent.tpr); // check for recursive instantiation var currentParent = parent; diff --git a/core/src/main/java/org/lflang/generator/c/CFileConfig.java b/core/src/main/java/org/lflang/generator/c/CFileConfig.java index 491c604222..db9447a833 100644 --- a/core/src/main/java/org/lflang/generator/c/CFileConfig.java +++ b/core/src/main/java/org/lflang/generator/c/CFileConfig.java @@ -1,16 +1,9 @@ package org.lflang.generator.c; -import org.eclipse.emf.common.util.URI; import java.io.IOException; import java.nio.file.Path; -import java.util.HashMap; -import java.util.List; -import java.util.Map; import org.eclipse.emf.ecore.resource.Resource; import org.lflang.FileConfig; -import org.lflang.ast.ASTUtils; -import org.lflang.lf.Reactor; -import org.lflang.lf.ReactorDecl; public class CFileConfig extends FileConfig { private final Path includePath; diff --git a/core/src/main/java/org/lflang/generator/c/CGenerator.java b/core/src/main/java/org/lflang/generator/c/CGenerator.java index 47a65f65bf..7bed894341 100644 --- a/core/src/main/java/org/lflang/generator/c/CGenerator.java +++ b/core/src/main/java/org/lflang/generator/c/CGenerator.java @@ -2095,7 +2095,8 @@ private void createMainReactorInstance() { if (this.mainDef != null) { if (this.main == null) { // Recursively build instances. - this.main = new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter, reactors); + this.main = + new ReactorInstance(toDefinition(mainDef.getReactorClass()), errorReporter, reactors); var reactionInstanceGraph = this.main.assignLevels(); if (reactionInstanceGraph.nodeCount() > 0) { errorReporter.reportError("Main reactor has causality cycles. Skipping code generation."); diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index 9fa76d496d..ac2ce6572d 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -1,26 +1,24 @@ package org.lflang.generator.c; +import com.google.common.collect.ImmutableMap; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.stream.Collectors; - -import com.google.common.collect.ImmutableMap; import org.eclipse.emf.common.util.URI; import org.lflang.InferredType; import org.lflang.ast.ASTUtils; import org.lflang.generator.CodeBuilder; import org.lflang.lf.*; -/** - * A reactor class combined with concrete type arguments bound to its type parameters. - */ +/** A reactor class combined with concrete type arguments bound to its type parameters. */ public class TypeParameterizedReactor { /** The syntactic reactor class definition. */ private final Reactor reactor; /** The type arguments associated with this particular variant of the reactor class. */ private final Map typeArgs; + private final List typeParams; private final ImmutableMap> nameMap; @@ -64,7 +62,8 @@ private String uniqueName(ReactorDecl decl) { return name + (number == 0 ? "" : number); } - private TypeParameterizedReactor(Instantiation i, TypeParameterizedReactor parent, Map> nameMap) { + private TypeParameterizedReactor( + Instantiation i, TypeParameterizedReactor parent, Map> nameMap) { reactor = ASTUtils.toDefinition(i.getReactorClass()); var definition = ASTUtils.toDefinition(i.getReactorClass()); typeParams = definition.getTypeParms().stream().map(TypeParm::getLiteral).toList(); @@ -78,8 +77,7 @@ private Map addTypeArgs( if (instantiation.getTypeArgs() != null) { for (int i = 0; i < typeParams.size(); i++) { var arg = instantiation.getTypeArgs().get(i); - ret.put( - typeParams.get(i), parent == null ? arg : parent.resolveType(arg)); + ret.put(typeParams.get(i), parent == null ? arg : parent.resolveType(arg)); } } return ret; @@ -133,7 +131,11 @@ public InferredType resolveType(InferredType t) { */ public String uniqueName() { var resolved = ASTUtils.toDefinition(reactor); - return "_" + uniqueName(resolved) + typeParams.stream().map(it -> it + "_" + typeArgs.get(it)).collect(Collectors.joining("_")); + return "_" + + uniqueName(resolved) + + typeParams.stream() + .map(it -> it + "_" + typeArgs.get(it)) + .collect(Collectors.joining("_")); } @Override From 79fe178dd614ff6060fd0dc4c86601a510ea0dd2 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 14:23:34 -0700 Subject: [PATCH 671/709] Dignify the "empty list of all reactors" hack. --- core/src/main/java/org/lflang/ModelInfo.java | 13 ++---------- .../synthesis/LinguaFrancaSynthesis.java | 5 ++--- .../federated/extensions/CExtension.java | 7 +++---- .../federated/extensions/TSExtension.java | 5 ++--- .../federated/generator/FedGenerator.java | 2 +- .../org/lflang/generator/ReactorInstance.java | 21 +++++++++++++------ .../generator/c/TypeParameterizedReactor.java | 2 +- 7 files changed, 26 insertions(+), 29 deletions(-) diff --git a/core/src/main/java/org/lflang/ModelInfo.java b/core/src/main/java/org/lflang/ModelInfo.java index fd4e05d6d3..17ee7cfb76 100644 --- a/core/src/main/java/org/lflang/ModelInfo.java +++ b/core/src/main/java/org/lflang/ModelInfo.java @@ -108,21 +108,12 @@ public void update(Model model, ErrorReporter reporter) { var main = model.getReactors().stream().filter(it -> it.isMain() || it.isFederated()).findFirst(); if (main.isPresent()) { - var inst = - new ReactorInstance( - main.get(), - reporter, - List.of()); // FIXME: This might work, but it breaks invariants. + var inst = new ReactorInstance(main.get(), reporter); topLevelReactorInstances.add(inst); } else { model .getReactors() - .forEach( - it -> - topLevelReactorInstances.add( - new ReactorInstance( - it, reporter, - List.of()))); // FIXME: This might work, but it breaks invariants. + .forEach(it -> topLevelReactorInstances.add(new ReactorInstance(it, reporter))); } // don't store the graph into a field, only the cycles. for (ReactorInstance top : topLevelReactorInstances) { diff --git a/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java b/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java index cbe57a34e6..45f3342a0a 100644 --- a/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java +++ b/core/src/main/java/org/lflang/diagram/synthesis/LinguaFrancaSynthesis.java @@ -303,8 +303,7 @@ public KNode transform(final Model model) { Reactor main = IterableExtensions.findFirst(model.getReactors(), _utilityExtensions::isMainOrFederated); if (main != null) { - ReactorInstance reactorInstance = - new ReactorInstance(main, new SynthesisErrorReporter(), List.of()); + ReactorInstance reactorInstance = new ReactorInstance(main, new SynthesisErrorReporter()); rootNode .getChildren() .addAll(createReactorNode(reactorInstance, true, null, null, new HashMap<>())); @@ -320,7 +319,7 @@ public KNode transform(final Model model) { for (Reactor reactor : model.getReactors()) { if (reactor == main) continue; ReactorInstance reactorInstance = - new ReactorInstance(reactor, new SynthesisErrorReporter(), List.of()); + new ReactorInstance(reactor, new SynthesisErrorReporter()); reactorNodes.addAll( createReactorNode( reactorInstance, diff --git a/core/src/main/java/org/lflang/federated/extensions/CExtension.java b/core/src/main/java/org/lflang/federated/extensions/CExtension.java index d41dc823b3..121cf5d817 100644 --- a/core/src/main/java/org/lflang/federated/extensions/CExtension.java +++ b/core/src/main/java/org/lflang/federated/extensions/CExtension.java @@ -593,7 +593,7 @@ private String generateInitializeTriggers( var federatedReactor = FedASTUtils.findFederatedReactor(federate.instantiation.eResource()); var oldFederatedReactorName = federatedReactor.getName(); federatedReactor.setName(federate.name); - var main = new ReactorInstance(federatedReactor, errorReporter, 1, List.of()); + var main = new ReactorInstance(federatedReactor, errorReporter, 1); code.pr(CExtensionUtils.initializeTriggersForNetworkActions(federate, main)); code.pr(CExtensionUtils.initializeTriggerForControlReactions(main, main, federate)); federatedReactor.setName(oldFederatedReactorName); @@ -773,9 +773,8 @@ private String generateCodeForPhysicalActions( new ReactorInstance( FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), errorReporter, - 1, - List.of()); - var instance = new ReactorInstance(federateClass, main, errorReporter, List.of()); + 1); + var instance = new ReactorInstance(federateClass, main, errorReporter); var outputDelayMap = federate.findOutputsConnectedToPhysicalActions(instance); var minDelay = TimeValue.MAX_VALUE; Output outputFound = null; diff --git a/core/src/main/java/org/lflang/federated/extensions/TSExtension.java b/core/src/main/java/org/lflang/federated/extensions/TSExtension.java index c04c6672d9..14df96afb5 100644 --- a/core/src/main/java/org/lflang/federated/extensions/TSExtension.java +++ b/core/src/main/java/org/lflang/federated/extensions/TSExtension.java @@ -159,9 +159,8 @@ private TimeValue getMinOutputDelay( new ReactorInstance( FedASTUtils.findFederatedReactor(federate.instantiation.eResource()), errorReporter, - 1, - List.of()); - var instance = new ReactorInstance(federateClass, main, errorReporter, List.of()); + 1); + var instance = new ReactorInstance(federateClass, main, errorReporter); var outputDelayMap = federate.findOutputsConnectedToPhysicalActions(instance); var minOutputDelay = TimeValue.MAX_VALUE; Output outputFound = null; diff --git a/core/src/main/java/org/lflang/federated/generator/FedGenerator.java b/core/src/main/java/org/lflang/federated/generator/FedGenerator.java index 0a83d880a4..6656a489f8 100644 --- a/core/src/main/java/org/lflang/federated/generator/FedGenerator.java +++ b/core/src/main/java/org/lflang/federated/generator/FedGenerator.java @@ -481,7 +481,7 @@ private void replaceFederateConnectionsWithProxies(Reactor federation) { // to duplicate the rather complicated logic in that class. We specify a depth of 1, // so it only creates the reactors immediately within the top level, not reactors // that those contain. - ReactorInstance mainInstance = new ReactorInstance(federation, errorReporter, List.of()); + ReactorInstance mainInstance = new ReactorInstance(federation, errorReporter); for (ReactorInstance child : mainInstance.children) { for (PortInstance output : child.outputs) { diff --git a/core/src/main/java/org/lflang/generator/ReactorInstance.java b/core/src/main/java/org/lflang/generator/ReactorInstance.java index a793f39442..5a1fdf4b8d 100644 --- a/core/src/main/java/org/lflang/generator/ReactorInstance.java +++ b/core/src/main/java/org/lflang/generator/ReactorInstance.java @@ -91,6 +91,17 @@ public class ReactorInstance extends NamedInstance { */ public ReactorInstance(Reactor reactor, ErrorReporter reporter, List reactors) { this(ASTUtils.createInstantiation(reactor), null, reporter, -1, reactors); + assert !reactors.isEmpty(); + } + + /** + * Create a new instantiation hierarchy that starts with the given top-level reactor. + * + * @param reactor The top-level reactor. + * @param reporter The error reporter. + */ + public ReactorInstance(Reactor reactor, ErrorReporter reporter) { + this(ASTUtils.createInstantiation(reactor), null, reporter, -1, List.of()); } /** @@ -101,9 +112,8 @@ public ReactorInstance(Reactor reactor, ErrorReporter reporter, List re * @param reporter The error reporter. * @param desiredDepth The depth to which to go, or -1 to construct the full hierarchy. */ - public ReactorInstance( - Reactor reactor, ErrorReporter reporter, int desiredDepth, List reactors) { - this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth, reactors); + public ReactorInstance(Reactor reactor, ErrorReporter reporter, int desiredDepth) { + this(ASTUtils.createInstantiation(reactor), null, reporter, desiredDepth, List.of()); } /** @@ -114,9 +124,8 @@ public ReactorInstance( * @param parent The parent reactor instance. * @param reporter The error reporter. */ - public ReactorInstance( - Reactor reactor, ReactorInstance parent, ErrorReporter reporter, List reactors) { - this(ASTUtils.createInstantiation(reactor), parent, reporter, -1, reactors); + public ReactorInstance(Reactor reactor, ReactorInstance parent, ErrorReporter reporter) { + this(ASTUtils.createInstantiation(reactor), parent, reporter, -1, List.of()); } ////////////////////////////////////////////////////// diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index ac2ce6572d..b026525e82 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -134,7 +134,7 @@ public String uniqueName() { return "_" + uniqueName(resolved) + typeParams.stream() - .map(it -> it + "_" + typeArgs.get(it)) + .map(it -> typeArgs.get(it).getId()) // FIXME: may be more than just an ID .collect(Collectors.joining("_")); } From 1e7313c871f0f12ee4f9ca6d856d6bd6eac24750 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 14:35:26 -0700 Subject: [PATCH 672/709] Add C generics tests to CI. --- .github/workflows/only-c.yml | 7 +++++++ .../java/org/lflang/tests/RuntimeTest.java | 10 ++++++++++ .../java/org/lflang/tests/runtime/CTest.java | 6 ++++++ .../testFixtures/java/org/lflang/tests/TestBase.java | 1 + 4 files changed, 24 insertions(+) diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 195624cedc..f632f43f17 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -108,6 +108,13 @@ jobs: all-platforms: ${{ !github.event.pull_request.draft }} selected-tests: runEnclaveTests + default13: + if: ${{ inputs.all || github.event.pull_request.draft }} + uses: ./.github/workflows/c-tests.yml + with: + all-platforms: ${{ !github.event.pull_request.draft }} + selected-tests: runGenericsTests + # Run the C benchmark tests. benchmarking: if: ${{ inputs.all || github.event.pull_request.draft }} diff --git a/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java index 2dfd42d38b..663294ef43 100644 --- a/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java @@ -63,6 +63,16 @@ public void runGenericTests() { false); } + @Test + public void runGenericsTests() { + runTestsForTargets( + Message.DESC_GENERICS, + TestCategory.GENERICS::equals, + Configurators::noChanges, + TestLevel.EXECUTION, + false); + } + @Test public void runTargetSpecificTests() { runTestsForTargets( diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java index 4902550661..87687e2376 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java @@ -66,6 +66,12 @@ public void runGenericTests() { super.runGenericTests(); } + @Test + @Override + public void runGenericsTests() { + super.runGenericsTests(); + } + @Test @Override public void runTargetSpecificTests() { diff --git a/core/src/testFixtures/java/org/lflang/tests/TestBase.java b/core/src/testFixtures/java/org/lflang/tests/TestBase.java index 9d419d5644..ebdab78b72 100644 --- a/core/src/testFixtures/java/org/lflang/tests/TestBase.java +++ b/core/src/testFixtures/java/org/lflang/tests/TestBase.java @@ -140,6 +140,7 @@ public static class Message { /* Descriptions of collections of tests. */ public static final String DESC_SERIALIZATION = "Run serialization tests."; public static final String DESC_GENERIC = "Run generic tests."; + public static final String DESC_GENERICS = "Run generics tests."; public static final String DESC_TYPE_PARMS = "Run tests for reactors with type parameters."; public static final String DESC_MULTIPORT = "Run multiport tests."; public static final String DESC_AS_FEDERATED = "Run non-federated tests in federated mode."; From e3ea39b2d37b03e9cf613d6fd1537b14ee533521 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 15:20:59 -0700 Subject: [PATCH 673/709] Respond to suggestion that `build` be run always. --- .github/workflows/all-misc.yml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.github/workflows/all-misc.yml b/.github/workflows/all-misc.yml index 1cef721867..c4022d444d 100644 --- a/.github/workflows/all-misc.yml +++ b/.github/workflows/all-misc.yml @@ -23,7 +23,6 @@ jobs: # Test the Gradle build. building: - if: ${{ !github.event.pull_request.draft }} uses: ./.github/workflows/build.yml with: all-platforms: ${{ !github.event.pull_request.draft }} @@ -32,8 +31,7 @@ jobs: tracing: if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-tracing == 1 }} uses: ./.github/workflows/build-trace-tools.yml - needs: - check-diff + needs: check-diff with: all-platforms: ${{ !github.event.pull_request.draft }} From 43073973eae2fe777b907570b65c4bedf4575be4 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 15:28:30 -0700 Subject: [PATCH 674/709] Update CONTRIBUTING.md. --- CONTRIBUTING.md | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 9a6065e254..4a7f948263 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -76,15 +76,50 @@ To address feedback from code review, implement changes and push to your feature ### Code style and formatting The Lingua Franca compiler is implemented in Java and Kotlin. The overarching advice is to use each language's most widely used idioms and conventions, which are fortunately very similar. The code base is shipped with a [Spotless](https://github.com/diffplug/spotless) configuration to check and enforce style compliance. Lingua Franca code (e.g., tests) in this repository is also automatically formatted via Spotless. + +#### Formatting + - To check that modified files are formatted correctly, run: + ``` ./gradlew spotlessCheck ``` + - To apply the changes recommended by the formatter, run: + ``` ./gradlew spotlessApply ``` +_Java code formatting in IntelliJ_ + +There is an [IntelliJ plugin](https://plugins.jetbrains.com/plugin/8527-google-java-format) for enforcing Google's Java +style guide. This plugin can be enabled by going to `File` > `Settings...` > `Plugins` > `MarketPlace` and searching for +`google-java-format`. Do not forget to update your VM options as +explained [here](https://github.com/google/google-java-format/blob/master/README.md#intellij-android-studio-and-other-jetbrains-ides) +and do not forget to enable the plugin by going +to `File` > `Settings...` > `google-java-format Settings` > `Enable google-java-format`. + +You can enable formatting on save by going to `File` > `Settings...` > `Tools` > `Actions on Save` > `Reformat Code`. If +you do this, you may choose to change the files formatted on save from "all file types" to just Java in order to avoid +unnecessary conflicts. + +_Lingua Franca code formatting in VS Code_ + +Formatting is provided by the Lingua Franca VS Code extension. + +You can enable formatting on save by going to `Settings` and searching for "format" and checking the box +`Editor: Format on Save`. This can be either a user-level or workspace-level setting. + +_Checking using Git hooks_ + +If you prefer not to use formatting on save but would still like to avoid committing unformatted code, you can add a +file `.git/hooks/pre-commit` with the contents: + +``` +./gradlew spotlessCheck +``` + #### General guidelines - _Do not copy-paste code._ If you want to reuse code, factor it out into a method and call it. - _Keep methods concise._ As a rule of thumb, a method should fit on your screen so that it can be read without scrolling. We impose no hard limit on method length, but anything above 40 lines should be considered for breaking up. From 4d6c8c83a390a75c4714513fa6244723c9f253e8 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 09:50:56 -0700 Subject: [PATCH 675/709] Fix CI. --- .github/workflows/check-diff.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/check-diff.yml b/.github/workflows/check-diff.yml index f714c3cd3e..3633344d5d 100644 --- a/.github/workflows/check-diff.yml +++ b/.github/workflows/check-diff.yml @@ -36,10 +36,10 @@ jobs: - id: do run: | wget https://raw.githubusercontent.com/lf-lang/lingua-franca/master/.github/scripts/check-diff.sh - source check-diff.sh "core/src/main/java/generator/c\|core/src/main/resources/lib/c\|core/src/main/resources/lib/platform\|test/C" C - source check-diff.sh "core/src/main/kotlin/generator/cpp\|core/src/main/resources/lib/cpp\|test/Cpp" CPP - source check-diff.sh "core/src/main/java/generator/python\|core/src/main/resources/lib/py\|test/Python" PY - source check-diff.sh "core/src/main/kotlin/generator/rust\|core/src/main/java/generator/rust\|core/src/main/resources/lib/rs\|test/Rust" RS - source check-diff.sh "core/src/main/kotlin/generator/ts\|core/src/main/java/generator/ts\|core/src/main/resources/lib/ts\|test/TypeScript" TS + source check-diff.sh "core/src/main/java/org/lflang/generator/c\|core/src/main/resources/lib/c\|core/src/main/resources/lib/platform\|test/C" C + source check-diff.sh "core/src/main/kotlin/org/lflang/generator/cpp\|core/src/main/resources/lib/cpp\|test/Cpp" CPP + source check-diff.sh "core/src/main/java/org/lflang/generator/python\|core/src/main/resources/lib/py\|test/Python" PY + source check-diff.sh "core/src/main/kotlin/org/lflang/generator/rust\|core/src/main/java/org/lflang/generator/rust\|core/src/main/resources/lib/rs\|test/Rust" RS + source check-diff.sh "core/src/main/kotlin/org/lflang/generator/ts\|core/src/main/java/org/lflang/generator/ts\|core/src/main/resources/lib/ts\|test/TypeScript" TS source check-diff.sh "util/tracing" TRACING shell: bash From 3105f2b54f1115bd739d714b9f750127ec1fdacc Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 16:03:04 -0700 Subject: [PATCH 676/709] Give reactor classes well-defined order. --- .../org/lflang/generator/c/TypeParameterizedReactor.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index b026525e82..8938f5d763 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -1,6 +1,7 @@ package org.lflang.generator.c; import com.google.common.collect.ImmutableMap; +import java.util.Comparator; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -41,7 +42,11 @@ public TypeParameterizedReactor(Instantiation i, List reactors) { private static Map> getNameMap(List reactors) { Map> nameMap = new HashMap<>(); Map countMap = new HashMap<>(); - for (var reactor : reactors) { + var sortedReactors = + reactors.stream() + .sorted(Comparator.comparing(a -> a.eResource().getURI().toString())) + .toList(); + for (var reactor : sortedReactors) { var def = ASTUtils.toDefinition(reactor); var name = def.getName().toLowerCase(); if (nameMap.containsKey(name)) { From 010e785f3f8e265f3030dc2d4ab3bb67ab39f77b Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 16:43:43 -0700 Subject: [PATCH 677/709] Update CONTRIBUTING.md. --- CONTRIBUTING.md | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 4a7f948263..761cb6031a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -93,16 +93,11 @@ The Lingua Franca compiler is implemented in Java and Kotlin. The overarching ad _Java code formatting in IntelliJ_ -There is an [IntelliJ plugin](https://plugins.jetbrains.com/plugin/8527-google-java-format) for enforcing Google's Java -style guide. This plugin can be enabled by going to `File` > `Settings...` > `Plugins` > `MarketPlace` and searching for -`google-java-format`. Do not forget to update your VM options as -explained [here](https://github.com/google/google-java-format/blob/master/README.md#intellij-android-studio-and-other-jetbrains-ides) -and do not forget to enable the plugin by going -to `File` > `Settings...` > `google-java-format Settings` > `Enable google-java-format`. - -You can enable formatting on save by going to `File` > `Settings...` > `Tools` > `Actions on Save` > `Reformat Code`. If -you do this, you may choose to change the files formatted on save from "all file types" to just Java in order to avoid -unnecessary conflicts. +Follow the directions here to install the Spotless Gradle plugin. We are not currently aware of a way to run Spotless +automatically on file save, but it is possible to configure a keybinding. + +There is a [plugin](https://github.com/google/google-java-format) specifically for enforcing Google's style guide, but +we have found difficulty getting it to work properly. _Lingua Franca code formatting in VS Code_ From dcf7b4836d1e468881d07a031dfea8d38312cb5a Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Sun, 4 Jun 2023 23:47:38 -0700 Subject: [PATCH 678/709] Revert "Run all categories of C tests." This reverts commit 05ba9c5ad29ee370f9b09122bd8bc0efe2f07241. --- .github/workflows/c-tests.yml | 19 ++------ .github/workflows/only-c.yml | 87 +---------------------------------- 2 files changed, 4 insertions(+), 102 deletions(-) diff --git a/.github/workflows/c-tests.yml b/.github/workflows/c-tests.yml index 2bf7a3a371..956fb4c967 100644 --- a/.github/workflows/c-tests.yml +++ b/.github/workflows/c-tests.yml @@ -20,14 +20,9 @@ on: required: false default: true type: boolean - selected-tests: - required: false - default: "" # "" means run all tests until failure - type: string jobs: regular-tests: - name: ${{ inputs.selected-tests }} strategy: matrix: platform: ${{ (inputs.all-platforms && fromJSON('["ubuntu-latest", "macos-latest", "windows-latest"]')) || fromJSON('["ubuntu-latest"]') }} @@ -60,23 +55,15 @@ jobs: if: ${{ runner.os == 'macOS' || runner.os == 'Linux' }} - name: Perform tests for C target with default scheduler run: ./gradlew targetTest -Ptarget=C - if: ${{ !inputs.use-cpp && !inputs.scheduler && inputs.selected-tests == '' }} + if: ${{ !inputs.use-cpp && !inputs.scheduler }} - name: Perform tests for C target with specified scheduler (no LSP tests) run: | echo "Specified scheduler: ${{ inputs.scheduler }}" ./gradlew targetTest -Ptarget=C -Dscheduler=${{ inputs.scheduler }} - if: ${{ !inputs.use-cpp && inputs.scheduler && inputs.selected-tests == '' }} + if: ${{ !inputs.use-cpp && inputs.scheduler }} - name: Perform tests for CCpp target with default scheduler run: ./gradlew targetTest -Ptarget=CCpp - if: ${{ inputs.use-cpp && !inputs.scheduler && inputs.selected-tests == '' }} - - name: Perform tests for C target with default scheduler - run: ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CTest.${{ inputs.selected-tests }} - if: ${{ !inputs.use-cpp && !inputs.scheduler && inputs.selected-tests != '' }} - - name: Perform tests for C target with specified scheduler (no LSP tests) - run: | - echo "Specified scheduler: ${{ inputs.scheduler }}" - ./gradlew core:integrationTest --tests org.lflang.tests.runtime.CTest.${{ inputs.selected-tests }} -Dscheduler=${{ inputs.scheduler }} - if: ${{ inputs.use-cpp && !inputs.scheduler && inputs.selected-tests != '' }} + if: ${{ inputs.use-cpp && !inputs.scheduler }} - name: Collect code coverage run: ./gradlew jacocoTestReport - name: Report to CodeCov diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index f632f43f17..993afee2b9 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -17,96 +17,11 @@ concurrency: jobs: # Run the C integration tests. - default0: + default: if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runGenericTests - - default1: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runTargetSpecificTests - - default2: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runMultiportTests - - default3: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runTypeParameterTests - - default4: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runAsFederated - - default5: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runConcurrentTests - - default6: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runFederatedTests - - default7: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runModalTests - - default8: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runNoInliningTests - - default9: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runDockerTests - - default10: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runDockerFederatedTests - - default11: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runWithThreadingOff - - default12: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runEnclaveTests default13: if: ${{ inputs.all || github.event.pull_request.draft }} From 65822907f54f109160d840d9be59ae83fb6ab582 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 5 Jun 2023 00:00:03 -0700 Subject: [PATCH 679/709] Revert another CI change. --- .github/workflows/only-c.yml | 7 ------- 1 file changed, 7 deletions(-) diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index 993afee2b9..bb4752471b 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -23,13 +23,6 @@ jobs: with: all-platforms: ${{ !github.event.pull_request.draft }} - default13: - if: ${{ inputs.all || github.event.pull_request.draft }} - uses: ./.github/workflows/c-tests.yml - with: - all-platforms: ${{ !github.event.pull_request.draft }} - selected-tests: runGenericsTests - # Run the C benchmark tests. benchmarking: if: ${{ inputs.all || github.event.pull_request.draft }} From 5b445caee067fd919a426270bef89a1526bbbd6d Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 5 Jun 2023 09:56:08 -0700 Subject: [PATCH 680/709] Add JavaDoc. --- .../generator/c/TypeParameterizedReactor.java | 23 ++++++++++++++----- 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java index 8938f5d763..f514141241 100644 --- a/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java +++ b/core/src/main/java/org/lflang/generator/c/TypeParameterizedReactor.java @@ -39,6 +39,10 @@ public TypeParameterizedReactor(Instantiation i, List reactors) { this(i, null, getNameMap(reactors)); } + /** + * Return a map from reactor names and URIs to integers such that no two reactor names with + * different URIs map to the same integer. + */ private static Map> getNameMap(List reactors) { Map> nameMap = new HashMap<>(); Map countMap = new HashMap<>(); @@ -61,23 +65,30 @@ private static Map> getNameMap(List reactors) return nameMap; } - private String uniqueName(ReactorDecl decl) { - var name = decl.getName().toLowerCase(); - var number = Objects.requireNonNull(nameMap.get(name)).get(decl.eResource().getURI()); + /** Return a name that is unique to the given {@code Reactor}. */ + private String uniqueName(Reactor def) { + var name = def.getName().toLowerCase(); + var number = Objects.requireNonNull(nameMap.get(name)).get(def.eResource().getURI()); return name + (number == 0 ? "" : number); } + /** + * Construct a {@code TypeParameterizedReactor} corresponding to the reactor class of the + * instantiation {@code i} within the parent {@code parent} and with the given mapping of + * definition names and URIs to integers. + */ private TypeParameterizedReactor( Instantiation i, TypeParameterizedReactor parent, Map> nameMap) { reactor = ASTUtils.toDefinition(i.getReactorClass()); var definition = ASTUtils.toDefinition(i.getReactorClass()); typeParams = definition.getTypeParms().stream().map(TypeParm::getLiteral).toList(); - typeArgs = addTypeArgs(i, parent); + typeArgs = addTypeArgs(i, parent, typeParams); this.nameMap = ImmutableMap.copyOf(nameMap); } - private Map addTypeArgs( - Instantiation instantiation, TypeParameterizedReactor parent) { + /** Return a mapping from type parameters to type arguments. */ + private static Map addTypeArgs( + Instantiation instantiation, TypeParameterizedReactor parent, List typeParams) { HashMap ret = new HashMap<>(); if (instantiation.getTypeArgs() != null) { for (int i = 0; i < typeParams.size(); i++) { From ba1268d32c390da278bf179237bef9fa0bce64f8 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 5 Jun 2023 10:08:52 -0700 Subject: [PATCH 681/709] Rename generic -> miscellaneous. The intent is to reduce confusion with the language feature "generics." --- .../java/org/lflang/tests/RuntimeTest.java | 6 +++--- .../java/org/lflang/tests/runtime/CTest.java | 4 ++-- .../java/org/lflang/tests/runtime/CZephyrTest.java | 6 +++--- .../java/org/lflang/tests/runtime/CppTest.java | 4 ++-- .../java/org/lflang/tests/runtime/PythonTest.java | 4 ++-- .../java/org/lflang/tests/runtime/TypeScriptTest.java | 4 ++-- core/src/testFixtures/java/org/lflang/tests/TestBase.java | 2 +- .../testFixtures/java/org/lflang/tests/TestRegistry.java | 8 ++++---- 8 files changed, 19 insertions(+), 19 deletions(-) diff --git a/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java index 663294ef43..3ffe313dc2 100644 --- a/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java @@ -54,10 +54,10 @@ protected boolean supportsDockerOption() { } @Test - public void runGenericTests() { + public void runMiscellaneousTests() { runTestsForTargets( - Message.DESC_GENERIC, - TestCategory.GENERIC::equals, + Message.DESC_MISCELLANEOUS, + TestCategory.MISCELLANEOUS::equals, Configurators::noChanges, TestLevel.EXECUTION, false); diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java index 87687e2376..bdd5ff2a3c 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java @@ -62,8 +62,8 @@ protected boolean supportsDockerOption() { @Test @Override - public void runGenericTests() { - super.runGenericTests(); + public void runMiscellaneousTests() { + super.runMiscellaneousTests(); } @Test diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java index 82dfb4270e..21f05cc8e0 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java @@ -56,12 +56,12 @@ public void buildZephyrTests() { } @Test - public void buildGenericTests() { + public void buildMiscellaneousTests() { Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); super.runTestsFor( List.of(Target.C), - Message.DESC_GENERIC, - TestCategory.GENERIC::equals, + Message.DESC_MISCELLANEOUS, + TestCategory.MISCELLANEOUS::equals, Configurators::makeZephyrCompatibleUnthreaded, TestLevel.BUILD, false); diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java index 20973189b9..e0b9d3cb6d 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java @@ -51,8 +51,8 @@ protected boolean supportsEnclaves() { @Test @Override - public void runGenericTests() { - super.runGenericTests(); + public void runMiscellaneousTests() { + super.runMiscellaneousTests(); } @Test diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java index 1c258b7481..aff34d6919 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java @@ -73,8 +73,8 @@ protected boolean supportsDockerOption() { @Test @Override - public void runGenericTests() { - super.runGenericTests(); + public void runMiscellaneousTests() { + super.runMiscellaneousTests(); } @Test diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java index 036211607a..a31b2a335b 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java @@ -31,8 +31,8 @@ protected boolean supportsFederatedExecution() { @Test @Override - public void runGenericTests() { - super.runGenericTests(); + public void runMiscellaneousTests() { + super.runMiscellaneousTests(); } @Test diff --git a/core/src/testFixtures/java/org/lflang/tests/TestBase.java b/core/src/testFixtures/java/org/lflang/tests/TestBase.java index ebdab78b72..d9062b15db 100644 --- a/core/src/testFixtures/java/org/lflang/tests/TestBase.java +++ b/core/src/testFixtures/java/org/lflang/tests/TestBase.java @@ -139,7 +139,7 @@ public static class Message { /* Descriptions of collections of tests. */ public static final String DESC_SERIALIZATION = "Run serialization tests."; - public static final String DESC_GENERIC = "Run generic tests."; + public static final String DESC_MISCELLANEOUS = "Run miscellaneous tests."; public static final String DESC_GENERICS = "Run generics tests."; public static final String DESC_TYPE_PARMS = "Run tests for reactors with type parameters."; public static final String DESC_MULTIPORT = "Run multiport tests."; diff --git a/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java b/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java index 483448bd8f..3850c8d72f 100644 --- a/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java +++ b/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java @@ -118,9 +118,9 @@ public enum TestCategory { CONCURRENT(true), /** Test about enclaves */ ENCLAVE(false), - /** Generic tests, ie, tests that all targets are supposed to implement. */ - GENERIC(true), - /** Tests about generics, not to confuse with {@link #GENERIC}. */ + /** Miscellaneous tests, ie, tests that all targets are supposed to implement. */ + MISCELLANEOUS(true), + /** Tests about generics. */ GENERICS(true), /** Tests about multiports and banks of reactors. */ MULTIPORT(true), @@ -313,7 +313,7 @@ public static class TestDirVisitor extends SimpleFileVisitor { * @param srcBasePath The test sources directory */ public TestDirVisitor(ResourceSet rs, Target target, Path srcBasePath) { - stack.push(TestCategory.GENERIC); + stack.push(TestCategory.MISCELLANEOUS); this.rs = rs; this.target = target; this.srcBasePath = srcBasePath; From d8fe614e481926602641d1b012b04f95f7eaac30 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 5 Jun 2023 10:43:27 -0700 Subject: [PATCH 682/709] Rename miscellaneous -> basic. --- .../integrationTest/java/org/lflang/tests/RuntimeTest.java | 6 +++--- .../java/org/lflang/tests/runtime/CTest.java | 4 ++-- .../java/org/lflang/tests/runtime/CZephyrTest.java | 6 +++--- .../java/org/lflang/tests/runtime/CppTest.java | 4 ++-- .../java/org/lflang/tests/runtime/PythonTest.java | 4 ++-- .../java/org/lflang/tests/runtime/TypeScriptTest.java | 4 ++-- core/src/testFixtures/java/org/lflang/tests/TestBase.java | 2 +- .../testFixtures/java/org/lflang/tests/TestRegistry.java | 6 +++--- 8 files changed, 18 insertions(+), 18 deletions(-) diff --git a/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java index 3ffe313dc2..c4997293ec 100644 --- a/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java @@ -54,10 +54,10 @@ protected boolean supportsDockerOption() { } @Test - public void runMiscellaneousTests() { + public void runBasicTests() { runTestsForTargets( - Message.DESC_MISCELLANEOUS, - TestCategory.MISCELLANEOUS::equals, + Message.DESC_BASIC, + TestCategory.BASIC::equals, Configurators::noChanges, TestLevel.EXECUTION, false); diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java index bdd5ff2a3c..8da7d6117d 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CTest.java @@ -62,8 +62,8 @@ protected boolean supportsDockerOption() { @Test @Override - public void runMiscellaneousTests() { - super.runMiscellaneousTests(); + public void runBasicTests() { + super.runBasicTests(); } @Test diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java index 21f05cc8e0..03e8b3664d 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CZephyrTest.java @@ -56,12 +56,12 @@ public void buildZephyrTests() { } @Test - public void buildMiscellaneousTests() { + public void buildBasicTests() { Assumptions.assumeTrue(isLinux(), "Zephyr tests only run on Linux"); super.runTestsFor( List.of(Target.C), - Message.DESC_MISCELLANEOUS, - TestCategory.MISCELLANEOUS::equals, + Message.DESC_BASIC, + TestCategory.BASIC::equals, Configurators::makeZephyrCompatibleUnthreaded, TestLevel.BUILD, false); diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java index e0b9d3cb6d..b284e8b7af 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/CppTest.java @@ -51,8 +51,8 @@ protected boolean supportsEnclaves() { @Test @Override - public void runMiscellaneousTests() { - super.runMiscellaneousTests(); + public void runBasicTests() { + super.runBasicTests(); } @Test diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java index aff34d6919..e1ffbd57b8 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/PythonTest.java @@ -73,8 +73,8 @@ protected boolean supportsDockerOption() { @Test @Override - public void runMiscellaneousTests() { - super.runMiscellaneousTests(); + public void runBasicTests() { + super.runBasicTests(); } @Test diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java index a31b2a335b..8fb223fe07 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/TypeScriptTest.java @@ -31,8 +31,8 @@ protected boolean supportsFederatedExecution() { @Test @Override - public void runMiscellaneousTests() { - super.runMiscellaneousTests(); + public void runBasicTests() { + super.runBasicTests(); } @Test diff --git a/core/src/testFixtures/java/org/lflang/tests/TestBase.java b/core/src/testFixtures/java/org/lflang/tests/TestBase.java index d9062b15db..2067f87618 100644 --- a/core/src/testFixtures/java/org/lflang/tests/TestBase.java +++ b/core/src/testFixtures/java/org/lflang/tests/TestBase.java @@ -139,7 +139,7 @@ public static class Message { /* Descriptions of collections of tests. */ public static final String DESC_SERIALIZATION = "Run serialization tests."; - public static final String DESC_MISCELLANEOUS = "Run miscellaneous tests."; + public static final String DESC_BASIC = "Run basic tests."; public static final String DESC_GENERICS = "Run generics tests."; public static final String DESC_TYPE_PARMS = "Run tests for reactors with type parameters."; public static final String DESC_MULTIPORT = "Run multiport tests."; diff --git a/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java b/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java index 3850c8d72f..bda0fabb1c 100644 --- a/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java +++ b/core/src/testFixtures/java/org/lflang/tests/TestRegistry.java @@ -118,8 +118,8 @@ public enum TestCategory { CONCURRENT(true), /** Test about enclaves */ ENCLAVE(false), - /** Miscellaneous tests, ie, tests that all targets are supposed to implement. */ - MISCELLANEOUS(true), + /** Basic tests, i.e., tests that all targets are supposed to implement. */ + BASIC(true), /** Tests about generics. */ GENERICS(true), /** Tests about multiports and banks of reactors. */ @@ -313,7 +313,7 @@ public static class TestDirVisitor extends SimpleFileVisitor { * @param srcBasePath The test sources directory */ public TestDirVisitor(ResourceSet rs, Target target, Path srcBasePath) { - stack.push(TestCategory.MISCELLANEOUS); + stack.push(TestCategory.BASIC); this.rs = rs; this.target = target; this.srcBasePath = srcBasePath; From cae0d1e2ecf01a7a608fb5f2f02e950aea7594d7 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 5 Jun 2023 10:55:11 -0700 Subject: [PATCH 683/709] Try to pass Rust tests. --- .../java/org/lflang/tests/RuntimeTest.java | 13 +------------ .../java/org/lflang/tests/runtime/RustTest.java | 7 +++++++ .../java/org/lflang/tests/TestBase.java | 8 ++++---- 3 files changed, 12 insertions(+), 16 deletions(-) diff --git a/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java index c4997293ec..8f0ccdc8fd 100644 --- a/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/RuntimeTest.java @@ -43,7 +43,7 @@ protected boolean supportsFederatedExecution() { return false; } - /** Whether to enable {@link #runTypeParameterTests()}. */ + /** Whether to enable {@link #runGenericsTests()}. */ protected boolean supportsGenericTypes() { return false; } @@ -93,17 +93,6 @@ public void runMultiportTests() { false); } - @Test - public void runTypeParameterTests() { - Assumptions.assumeTrue(supportsGenericTypes(), Message.NO_GENERICS_SUPPORT); - runTestsForTargets( - Message.DESC_TYPE_PARMS, - TestCategory.GENERICS::equals, - Configurators::noChanges, - TestLevel.EXECUTION, - false); - } - @Test public void runAsFederated() { Assumptions.assumeTrue(supportsFederatedExecution(), Message.NO_FEDERATION_SUPPORT); diff --git a/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java b/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java index e41d358ac0..75c1de4e15 100644 --- a/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java +++ b/core/src/integrationTest/java/org/lflang/tests/runtime/RustTest.java @@ -24,6 +24,7 @@ package org.lflang.tests.runtime; +import org.junit.jupiter.api.Test; import org.lflang.Target; import org.lflang.tests.RuntimeTest; @@ -34,6 +35,12 @@ public RustTest() { super(Target.Rust); } + @Test + @Override + public void runGenericsTests() { + super.runGenericsTests(); + } + @Override protected boolean supportsGenericTypes() { return true; diff --git a/core/src/testFixtures/java/org/lflang/tests/TestBase.java b/core/src/testFixtures/java/org/lflang/tests/TestBase.java index 2067f87618..c149c550c6 100644 --- a/core/src/testFixtures/java/org/lflang/tests/TestBase.java +++ b/core/src/testFixtures/java/org/lflang/tests/TestBase.java @@ -517,10 +517,10 @@ private void execute(LFTest test) throws TestError { stderr.start(); stdout.start(); - - if (!p.waitFor(MAX_EXECUTION_TIME_SECONDS, TimeUnit.SECONDS)) { - stdout.interrupt(); - stderr.interrupt(); + var timeout = !p.waitFor(MAX_EXECUTION_TIME_SECONDS, TimeUnit.SECONDS); + stdout.interrupt(); + stderr.interrupt(); + if (timeout) { p.destroy(); throw new TestError(Result.TEST_TIMEOUT); } else { From e1b507575d808190092dee5a32cc0fa0b674a247 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Mon, 5 Jun 2023 14:00:34 -0700 Subject: [PATCH 684/709] Update CONTRIBUTING.md. --- CONTRIBUTING.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 761cb6031a..67ae3ec689 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -93,7 +93,7 @@ The Lingua Franca compiler is implemented in Java and Kotlin. The overarching ad _Java code formatting in IntelliJ_ -Follow the directions here to install the Spotless Gradle plugin. We are not currently aware of a way to run Spotless +Follow the directions [here](https://github.com/ragurney/spotless-intellij-gradle) to install the Spotless Gradle plugin. We are not currently aware of a way to run Spotless automatically on file save, but it is possible to configure a keybinding. There is a [plugin](https://github.com/google/google-java-format) specifically for enforcing Google's style guide, but From f83b563dcffd3eecbe8d8219787f2b5c0be21286 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 7 Jun 2023 02:19:29 +0200 Subject: [PATCH 685/709] Remove odd mechanism for loading target generators dynamically (#1813) --- .../org/lflang/generator/LFGenerator.java | 128 ++++-------------- 1 file changed, 26 insertions(+), 102 deletions(-) diff --git a/core/src/main/java/org/lflang/generator/LFGenerator.java b/core/src/main/java/org/lflang/generator/LFGenerator.java index f2881c9fb8..8427f165f6 100644 --- a/core/src/main/java/org/lflang/generator/LFGenerator.java +++ b/core/src/main/java/org/lflang/generator/LFGenerator.java @@ -2,8 +2,8 @@ import com.google.inject.Inject; import java.io.IOException; -import java.lang.reflect.Constructor; import java.nio.file.Path; +import java.util.Arrays; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.generator.AbstractGenerator; import org.eclipse.xtext.generator.IFileSystemAccess2; @@ -18,15 +18,17 @@ import org.lflang.federated.generator.FedGenerator; import org.lflang.generator.c.CFileConfig; import org.lflang.generator.c.CGenerator; +import org.lflang.generator.cpp.CppFileConfig; +import org.lflang.generator.cpp.CppGenerator; import org.lflang.generator.python.PyFileConfig; import org.lflang.generator.python.PythonGenerator; +import org.lflang.generator.rust.RustFileConfig; +import org.lflang.generator.rust.RustGenerator; +import org.lflang.generator.ts.TSFileConfig; +import org.lflang.generator.ts.TSGenerator; import org.lflang.scoping.LFGlobalScopeProvider; -/** - * Generates code from your model files on save. - * - *

    See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation - */ +/** Generates code from your model files on save. */ public class LFGenerator extends AbstractGenerator { @Inject private LFGlobalScopeProvider scopeProvider; @@ -35,19 +37,10 @@ public class LFGenerator extends AbstractGenerator { protected boolean generatorErrorsOccurred = false; /** - * Create a target-specific FileConfig object in Kotlin - * - *

    Since the CppFileConfig and TSFileConfig class are implemented in Kotlin, the classes are - * not visible from all contexts. If the RCA is run from within Eclipse via "Run as Eclipse - * Application", the Kotlin classes are unfortunately not available at runtime due to bugs in the - * Eclipse Kotlin plugin. (See - * https://stackoverflow.com/questions/68095816/is-ist-possible-to-build-mixed-kotlin-and-java-applications-with-a-recent-eclips) - * - *

    If the FileConfig class is found, this method returns an instance. Otherwise, it returns an - * Instance of FileConfig. + * Create a target-specific FileConfig object * * @return A FileConfig object in Kotlin if the class can be found. - * @throws IOException If the file config could not be created properly + * @throws RuntimeException If the file config could not be created properly */ public static FileConfig createFileConfig( Resource resource, Path srcGenBasePath, boolean useHierarchicalBin) { @@ -55,51 +48,28 @@ public static FileConfig createFileConfig( final Target target = Target.fromDecl(ASTUtils.targetDecl(resource)); assert target != null; - // Since our Eclipse Plugin uses code injection via guice, we need to - // play a few tricks here so that FileConfig does not appear as an - // import. Instead, we look the class up at runtime and instantiate it if - // found. try { if (FedASTUtils.findFederatedReactor(resource) != null) { return new FedFileConfig(resource, srcGenBasePath, useHierarchicalBin); } - switch (target) { - case CCPP: - case C: - return new CFileConfig(resource, srcGenBasePath, useHierarchicalBin); - case Python: - return new PyFileConfig(resource, srcGenBasePath, useHierarchicalBin); - case CPP: - case Rust: - case TS: - String className = - "org.lflang.generator." - + target.packageName - + "." - + target.classNamePrefix - + "FileConfig"; - try { - return (FileConfig) - Class.forName(className) - .getDeclaredConstructor(Resource.class, Path.class, boolean.class) - .newInstance(resource, srcGenBasePath, useHierarchicalBin); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("Exception instantiating " + className, e.getCause()); - } - default: - throw new RuntimeException( - "Could not find FileConfig implementation for target " + target); - } + + return switch (target) { + case CCPP, C -> new CFileConfig(resource, srcGenBasePath, useHierarchicalBin); + case Python -> new PyFileConfig(resource, srcGenBasePath, useHierarchicalBin); + case CPP -> new CppFileConfig(resource, srcGenBasePath, useHierarchicalBin); + case Rust -> new RustFileConfig(resource, srcGenBasePath, useHierarchicalBin); + case TS -> new TSFileConfig(resource, srcGenBasePath, useHierarchicalBin); + }; } catch (IOException e) { throw new RuntimeException( - "Unable to create FileConfig object for target " + target + ": " + e.getStackTrace()); + "Unable to create FileConfig object for target " + + target + + ": " + + Arrays.toString(e.getStackTrace())); } } - /** - * Create a generator object for the given target. Returns null if the generator could not be - * created. - */ + /** Create a generator object for the given target. */ private GeneratorBase createGenerator(LFGeneratorContext context) { final Target target = Target.fromDecl(ASTUtils.targetDecl(context.getFileConfig().resource)); assert target != null; @@ -107,58 +77,12 @@ private GeneratorBase createGenerator(LFGeneratorContext context) { case C -> new CGenerator(context, false); case CCPP -> new CGenerator(context, true); case Python -> new PythonGenerator(context); - case CPP, TS, Rust -> createKotlinBaseGenerator(target, context); - // If no case matched, then throw a runtime exception. - default -> throw new RuntimeException("Unexpected target!"); + case CPP -> new CppGenerator(context, scopeProvider); + case TS -> new TSGenerator(context, scopeProvider); + case Rust -> new RustGenerator(context, scopeProvider); }; } - /** - * Create a code generator in Kotlin. - * - *

    Since the CppGenerator and TSGenerator class are implemented in Kotlin, the classes are not - * visible from all contexts. If the RCA is run from within Eclipse via "Run as Eclipse - * Application", the Kotlin classes are unfortunately not available at runtime due to bugs in the - * Eclipse Kotlin plugin. (See - * https://stackoverflow.com/questions/68095816/is-ist-possible-to-build-mixed-kotlin-and-java-applications-with-a-recent-eclips) - * In this case, the method returns null - * - * @return A Kotlin Generator object if the class can be found - */ - private GeneratorBase createKotlinBaseGenerator(Target target, LFGeneratorContext context) { - // Since our Eclipse Plugin uses code injection via guice, we need to - // play a few tricks here so that Kotlin FileConfig and - // Kotlin Generator do not appear as an import. Instead, we look the - // class up at runtime and instantiate it if found. - String classPrefix = - "org.lflang.generator." + target.packageName + "." + target.classNamePrefix; - try { - Class generatorClass = Class.forName(classPrefix + "Generator"); - Constructor ctor = - generatorClass.getDeclaredConstructor( - LFGeneratorContext.class, LFGlobalScopeProvider.class); - - return (GeneratorBase) ctor.newInstance(context, scopeProvider); - } catch (ReflectiveOperationException e) { - generatorErrorsOccurred = true; - context - .getErrorReporter() - .reportError( - "The code generator for the " - + target - + " target could not be found. " - + "This is likely because you built Epoch using " - + "Eclipse. The " - + target - + " code generator is written in Kotlin and, unfortunately, the plugin that" - + " Eclipse uses for compiling Kotlin code is broken. Please consider building" - + " Epoch using Maven.\n" - + "For step-by-step instructions, see: " - + "https://github.com/icyphy/lingua-franca/wiki/Running-Lingua-Franca-IDE-%28Epoch%29-with-Kotlin-based-Code-Generators-Enabled-%28without-Eclipse-Environment%29"); - return null; - } - } - @Override public void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) { final LFGeneratorContext lfContext; From ebed89e4f1206658334eabb566383fd4663379a7 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 6 Jun 2023 18:27:35 -0700 Subject: [PATCH 686/709] Fix workflow dispatch. In the version currently in master, these workflows are skipped when manually triggered. --- .github/workflows/only-c.yml | 3 ++- .github/workflows/only-cpp.yml | 3 ++- .github/workflows/only-py.yml | 13 +++++++------ .github/workflows/only-rs.yml | 3 ++- .github/workflows/only-ts.yml | 3 ++- 5 files changed, 15 insertions(+), 10 deletions(-) diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index bb4752471b..b353474e94 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -5,6 +5,7 @@ on: workflow_call: inputs: all: + default: true type: boolean env: @@ -28,7 +29,7 @@ jobs: if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: - target: 'C' + target: "C" # Run the C Arduino integration tests. arduino: diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index daa8e3e847..d7b956742f 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -5,6 +5,7 @@ on: workflow_call: inputs: all: + default: true type: boolean env: @@ -21,7 +22,7 @@ jobs: if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: - target: 'Cpp' + target: "Cpp" # Run the C++ integration tests. cpp-tests: diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index be3aa2f0f8..f07a9ef7a0 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -5,6 +5,7 @@ on: workflow_call: inputs: all: + default: true type: boolean env: @@ -16,9 +17,9 @@ concurrency: cancel-in-progress: ${{ github.ref != 'refs/heads/master' }} jobs: - # Run the Python integration tests. - py-tests: - uses: ./.github/workflows/py-tests.yml - if: ${{ inputs.all || github.event.pull_request.draft }} - with: - all-platforms: ${{ !github.event.pull_request.draft }} + # Run the Python integration tests. + py-tests: + uses: ./.github/workflows/py-tests.yml + if: ${{ inputs.all || github.event.pull_request.draft }} + with: + all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 8b2173b10a..412f1395ba 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -5,6 +5,7 @@ on: workflow_call: inputs: all: + default: true type: boolean env: @@ -28,4 +29,4 @@ jobs: if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: - target: 'Rust' + target: "Rust" diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index d3798d0f32..c842c14023 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -5,6 +5,7 @@ on: workflow_call: inputs: all: + default: true type: boolean env: @@ -21,7 +22,7 @@ jobs: if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: - target: 'TS' + target: "TS" # Run the TypeScript integration tests. ts-tests: From 8ff0b093851e276948da0263b3cb9af2f9d0a489 Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Tue, 6 Jun 2023 18:42:10 -0700 Subject: [PATCH 687/709] Fix workflow dispatch. The current behavior in master is that workflows are skipped when manually triggered. --- .github/workflows/all-targets.yml | 10 ---------- .github/workflows/only-c.yml | 9 --------- .github/workflows/only-cpp.yml | 7 ------- .github/workflows/only-py.yml | 5 ----- .github/workflows/only-rs.yml | 6 ------ .github/workflows/only-ts.yml | 6 ------ 6 files changed, 43 deletions(-) diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 092f5265a6..3768b37c50 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -23,36 +23,26 @@ jobs: c: uses: ./.github/workflows/only-c.yml - with: - all: true needs: check-diff if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-c == 1 }} cpp: uses: ./.github/workflows/only-cpp.yml - with: - all: true needs: check-diff if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-cpp == 1 }} py: uses: ./.github/workflows/only-py.yml - with: - all: true needs: check-diff if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-py == 1 }} rs: uses: ./.github/workflows/only-rs.yml - with: - all: true needs: check-diff if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-rs == 1 }} ts: uses: ./.github/workflows/only-ts.yml - with: - all: true needs: check-diff if: ${{ !github.event.pull_request.draft || needs.check-diff.outputs.changed-ts == 1 }} diff --git a/.github/workflows/only-c.yml b/.github/workflows/only-c.yml index b353474e94..2d12dd9da8 100644 --- a/.github/workflows/only-c.yml +++ b/.github/workflows/only-c.yml @@ -3,10 +3,6 @@ name: C on: workflow_dispatch: workflow_call: - inputs: - all: - default: true - type: boolean env: # 2020.11 @@ -19,33 +15,28 @@ concurrency: jobs: # Run the C integration tests. default: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C benchmark tests. benchmarking: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: target: "C" # Run the C Arduino integration tests. arduino: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-arduino-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C Zephyr integration tests. zephyr: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-zephyr-tests.yml # Run the CCpp integration tests. ccpp: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/c-tests.yml with: use-cpp: true diff --git a/.github/workflows/only-cpp.yml b/.github/workflows/only-cpp.yml index d7b956742f..fdac226930 100644 --- a/.github/workflows/only-cpp.yml +++ b/.github/workflows/only-cpp.yml @@ -3,10 +3,6 @@ name: C++ on: workflow_dispatch: workflow_call: - inputs: - all: - default: true - type: boolean env: # 2020.11 @@ -19,19 +15,16 @@ concurrency: jobs: # Run the C++ benchmark tests. cpp-benchmark-tests: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: target: "Cpp" # Run the C++ integration tests. cpp-tests: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the C++ integration tests on ROS2. cpp-ros2-tests: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/cpp-ros2-tests.yml diff --git a/.github/workflows/only-py.yml b/.github/workflows/only-py.yml index f07a9ef7a0..921b1cbae5 100644 --- a/.github/workflows/only-py.yml +++ b/.github/workflows/only-py.yml @@ -3,10 +3,6 @@ name: Python on: workflow_dispatch: workflow_call: - inputs: - all: - default: true - type: boolean env: # 2020.11 @@ -20,6 +16,5 @@ jobs: # Run the Python integration tests. py-tests: uses: ./.github/workflows/py-tests.yml - if: ${{ inputs.all || github.event.pull_request.draft }} with: all-platforms: ${{ !github.event.pull_request.draft }} diff --git a/.github/workflows/only-rs.yml b/.github/workflows/only-rs.yml index 412f1395ba..ef3f31e7d9 100644 --- a/.github/workflows/only-rs.yml +++ b/.github/workflows/only-rs.yml @@ -3,10 +3,6 @@ name: Rust on: workflow_dispatch: workflow_call: - inputs: - all: - default: true - type: boolean env: # 2020.11 @@ -19,14 +15,12 @@ concurrency: jobs: # Run the Rust integration tests. rs-tests: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/rs-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} # Run the Rust benchmark tests. rs-benchmark-tests: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: target: "Rust" diff --git a/.github/workflows/only-ts.yml b/.github/workflows/only-ts.yml index c842c14023..131c06ab17 100644 --- a/.github/workflows/only-ts.yml +++ b/.github/workflows/only-ts.yml @@ -3,10 +3,6 @@ name: TypeScript on: workflow_dispatch: workflow_call: - inputs: - all: - default: true - type: boolean env: # 2020.11 @@ -19,14 +15,12 @@ concurrency: jobs: # Run the TypeScript benchmark tests. benchmarking: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: lf-lang/benchmarks-lingua-franca/.github/workflows/benchmark-tests.yml@gradle with: target: "TS" # Run the TypeScript integration tests. ts-tests: - if: ${{ inputs.all || github.event.pull_request.draft }} uses: ./.github/workflows/ts-tests.yml with: all-platforms: ${{ !github.event.pull_request.draft }} From e6b5f5822e8d473d56590234cd78ae6aee91bf7c Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 6 Jun 2023 22:18:04 -0700 Subject: [PATCH 688/709] Update all-misc.yml --- .github/workflows/all-misc.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/all-misc.yml b/.github/workflows/all-misc.yml index c4022d444d..7efaee5131 100644 --- a/.github/workflows/all-misc.yml +++ b/.github/workflows/all-misc.yml @@ -8,6 +8,7 @@ on: - master pull_request: types: [synchronize, opened, reopened, ready_for_review, converted_to_draft] + merge_group: env: # 2020.11 From 1be54f08cc6121a94c04b19f416d30736808c812 Mon Sep 17 00:00:00 2001 From: Marten Lohstroh Date: Tue, 6 Jun 2023 22:18:17 -0700 Subject: [PATCH 689/709] Update all-targets.yml --- .github/workflows/all-targets.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/all-targets.yml b/.github/workflows/all-targets.yml index 3768b37c50..bc740a36b9 100644 --- a/.github/workflows/all-targets.yml +++ b/.github/workflows/all-targets.yml @@ -8,6 +8,7 @@ on: - master pull_request: types: [synchronize, opened, reopened, ready_for_review, converted_to_draft] + merge_group: env: # 2020.11 From 4caa7e46c9a234cb69af2bc1b39da14a90b1a999 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 7 Jun 2023 11:06:24 +0200 Subject: [PATCH 690/709] fix lff exception handling --- cli/lff/src/main/java/org/lflang/cli/Lff.java | 34 ++++++++++--------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/cli/lff/src/main/java/org/lflang/cli/Lff.java b/cli/lff/src/main/java/org/lflang/cli/Lff.java index 3626bc1f1c..d7ef31e85c 100644 --- a/cli/lff/src/main/java/org/lflang/cli/Lff.java +++ b/cli/lff/src/main/java/org/lflang/cli/Lff.java @@ -157,24 +157,26 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { final String formattedFileContents = FormattingUtils.render(resource.getContents().get(0), lineLength); - if (dryRun) { - io.getOut().println(formattedFileContents); - io.getOut().println("\0"); - } else { - try { + try { + if (dryRun) { + io.getOut().println(formattedFileContents); + io.getOut().println("\0"); + } else { FileUtil.writeToFile(formattedFileContents, outputPath, true); - } catch (IOException e) { - if (e instanceof FileAlreadyExistsException) { - // Only happens if a subdirectory is named with - // ".lf" at the end. - reporter.printFatalErrorAndExit( - "Error writing to " - + outputPath - + ": file already exists. Make sure that no file or" - + " directory within provided input paths have the" - + " same relative paths."); - } } + } catch (FileAlreadyExistsException e) { + // Only happens if a subdirectory is named with + // ".lf" at the end. + reporter.printFatalErrorAndExit( + "Error writing to " + + outputPath + + ": file already exists. Make sure that no file or" + + " directory within provided input paths have the" + + " same relative paths."); + } catch (IOException e) { + reporter.printFatalErrorAndExit( + "An unknown I/O exception occurred while processing " + outputPath); + e.printStackTrace(); } if (!ignoreErrors) { From 50da8ec65521351c6db8e8609426a75b4a71d2c4 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 7 Jun 2023 11:06:52 +0200 Subject: [PATCH 691/709] add method for comparing strings with file content --- .../main/java/org/lflang/util/FileUtil.java | 25 +++++++++++++------ 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/core/src/main/java/org/lflang/util/FileUtil.java b/core/src/main/java/org/lflang/util/FileUtil.java index e46a30d501..23108c7375 100644 --- a/core/src/main/java/org/lflang/util/FileUtil.java +++ b/core/src/main/java/org/lflang/util/FileUtil.java @@ -869,6 +869,21 @@ public static IResource getIResource(java.net.URI uri) { return null; } + /** + * Check if the content of a file is equal to a given string. + * + * @param text The text to compare with. + * @param path The file to compare with. + * @return true, if the given text is identical to the file content. + */ + public static boolean isSame(String text, Path path) throws IOException { + if (Files.isRegularFile(path)) { + final byte[] bytes = text.getBytes(); + return Arrays.equals(bytes, Files.readAllBytes(path)); + } + return false; + } + /** * Write text to a file. * @@ -879,14 +894,10 @@ public static IResource getIResource(java.net.URI uri) { */ public static void writeToFile(String text, Path path, boolean skipIfUnchanged) throws IOException { - Files.createDirectories(path.getParent()); - final byte[] bytes = text.getBytes(); - if (skipIfUnchanged && Files.isRegularFile(path)) { - if (Arrays.equals(bytes, Files.readAllBytes(path))) { - return; - } + if (!skipIfUnchanged || !isSame(text, path)) { + Files.createDirectories(path.getParent()); + Files.write(path, text.getBytes()); } - Files.write(path, text.getBytes()); } /** From f41fefb1ef348145bd5a28495739df30c2249a06 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 7 Jun 2023 11:52:09 +0200 Subject: [PATCH 692/709] keep track of errors in reporting util --- .../main/kotlin/org/lflang/cli/ReportingUtil.kt | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt b/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt index eb700afd58..efdd0e731f 100644 --- a/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt +++ b/cli/base/src/main/kotlin/org/lflang/cli/ReportingUtil.kt @@ -204,6 +204,8 @@ class ReportingBackend constructor( /** *Absolute* path to lines. */ private val fileCache = mutableMapOf?>() + private var errorsOccurred = false + private fun getLines(path: Path?): List? = if (path == null) null else fileCache.computeIfAbsent(path.toAbsolutePath()) { @@ -225,16 +227,18 @@ class ReportingBackend constructor( io.callSystemExit(1) } - /** Print a fatal error message to [Io.err] and exit with code 1. */ + /** Print a fatal error message to [Io.err]. */ @JvmOverloads fun printFatalError(message: String, cause: Throwable? = null) { io.err.println(header + colors.redAndBold("fatal error: ") + colors.bold(message)) cause?.printStackTrace(io.err) + errorsOccurred = true } /** Print an error message to [Io.err]. */ fun printError(message: String) { io.err.println(header + colors.redAndBold("error: ") + message) + errorsOccurred = true } /** Print a warning message to [Io.err]. */ @@ -418,6 +422,16 @@ class ReportingBackend constructor( } } + + /** Exit and return an error code if any errors were reported. */ + fun exit() { + if (errorsOccurred) { + io.callSystemExit(1) + } else { + io.callSystemExit(0) + } + } + companion object { const val TAB_REPLACEMENT = " " const val FENCE_WIDTH = 14 From 9e46b80e3fe7ca4ac336b9f7385bcbfdc3ed956d Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 7 Jun 2023 11:54:05 +0200 Subject: [PATCH 693/709] add --check option --- cli/lff/src/main/java/org/lflang/cli/Lff.java | 26 ++++++++++++++++--- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/cli/lff/src/main/java/org/lflang/cli/Lff.java b/cli/lff/src/main/java/org/lflang/cli/Lff.java index d7ef31e85c..0812680254 100644 --- a/cli/lff/src/main/java/org/lflang/cli/Lff.java +++ b/cli/lff/src/main/java/org/lflang/cli/Lff.java @@ -30,6 +30,12 @@ public class Lff extends CliBase { /** Supported CLI options for Lff. */ + @Option( + names = {"-c", "--check"}, + description = + "Check mode. Exit with an error code if any files would change when applying formatting.") + private boolean check = false; + @Option( names = {"-d", "--dry-run"}, description = @@ -80,6 +86,12 @@ public static void main(Io io, final String... args) { /** Validates all paths and invokes the formatter on the input paths. */ @Override public void doRun() { + if (check && dryRun) { + reporter.printFatalErrorAndExit( + "The options --check (-c) and --dry-run (-d) are mutually exclusive. Please use only one" + + " at a time."); + } + List paths; do { paths = getInputPaths(); @@ -97,6 +109,9 @@ public void doRun() { reporter.printFatalErrorAndExit("An unexpected error occurred:", e); } } while (stdinMode() && !paths.isEmpty()); + + // return an error code if any errors were reported + reporter.exit(); } /* @@ -122,7 +137,7 @@ public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) { } }); } catch (IOException e) { - reporter.printError("IO error: " + e); + reporter.printFatalErrorAndExit("An unknown I/O exception occurred.", e); } } else { // Simple file. @@ -158,7 +173,11 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { FormattingUtils.render(resource.getContents().get(0), lineLength); try { - if (dryRun) { + if (check) { + if (!FileUtil.isSame(formattedFileContents, outputPath)) { + reporter.printError("Would reformat " + outputPath); + } + } else if (dryRun) { io.getOut().println(formattedFileContents); io.getOut().println("\0"); } else { @@ -175,8 +194,7 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { + " same relative paths."); } catch (IOException e) { reporter.printFatalErrorAndExit( - "An unknown I/O exception occurred while processing " + outputPath); - e.printStackTrace(); + "An unknown I/O exception occurred while processing " + outputPath, e); } if (!ignoreErrors) { From a63644082c044ecd49d55d28d3d4000bd76dc156 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 7 Jun 2023 11:57:11 +0200 Subject: [PATCH 694/709] unify log output --- cli/lff/src/main/java/org/lflang/cli/Lff.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/cli/lff/src/main/java/org/lflang/cli/Lff.java b/cli/lff/src/main/java/org/lflang/cli/Lff.java index 0812680254..21a72fad16 100644 --- a/cli/lff/src/main/java/org/lflang/cli/Lff.java +++ b/cli/lff/src/main/java/org/lflang/cli/Lff.java @@ -156,11 +156,13 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { ? path // Format in place. : outputRoot.resolve(inputRoot.relativize(path)).normalize(); + Path relativePath = io.getWd().relativize(path); + final Resource resource = getResource(path); // Skip file if not an LF file. if (resource == null) { if (verbose) { - reporter.printInfo("Skipped " + path + ": not an LF file"); + reporter.printInfo("Skipped " + relativePath + ": not an LF file"); } return; } @@ -205,7 +207,7 @@ private void formatSingleFile(Path path, Path inputRoot, Path outputRoot) { // the position of the issue may be wrong in the formatted file. // issueCollector.getAllIssues().forEach(reporter::printIssue); if (verbose) { - String msg = "Formatted " + io.getWd().relativize(path); + String msg = "Formatted " + relativePath; if (path != outputPath) { msg += " -> " + io.getWd().relativize(outputPath); } From 9f24abc7f9317f306c1484a0887aa6d526a890b1 Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 7 Jun 2023 12:05:45 +0200 Subject: [PATCH 695/709] add unit tests --- .../test/java/org/lflang/cli/LffCliTest.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java b/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java index 9610d5b69c..444486344d 100644 --- a/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java +++ b/cli/lff/src/test/java/org/lflang/cli/LffCliTest.java @@ -150,6 +150,26 @@ public void testOutputPathWithFileArg(@TempDir Path tempDir) throws IOException dirChecker(tempDir).checkContentsOf("out/File.lf", equalTo(FILE_AFTER_REFORMAT)); } + @Test + public void testCheckAndDryRun(@TempDir Path tempDir) { + lffTester.run(tempDir, "foo.lf", "--check", "--dry-run").checkFailed(); + lffTester.run(tempDir, "foo.lf", "-c", "-d").checkFailed(); + } + + @Test + public void testCheck(@TempDir Path tempDir) throws IOException { + dirBuilder(tempDir).file("src/a/File.lf", FILE_BEFORE_REFORMAT); + dirBuilder(tempDir).file("src/b/File.lf", FILE_AFTER_REFORMAT); + + lffTester.run(tempDir, "src/a/File.lf", "--check").checkFailed(); + lffTester.run(tempDir, "src/a/File.lf", "-c").checkFailed(); + lffTester.run(tempDir, "src/b/File.lf", "--check").checkOk(); + lffTester.run(tempDir, "src/b/File.lf", "-c").checkOk(); + + dirChecker(tempDir).checkContentsOf("src/a/File.lf", equalTo(FILE_BEFORE_REFORMAT)); + dirChecker(tempDir).checkContentsOf("src/b/File.lf", equalTo(FILE_AFTER_REFORMAT)); + } + static class LffTestFixture extends CliToolTestFixture { @Override From eccfc5cabf8d47985a32cdaa0d4af18bc963dc7e Mon Sep 17 00:00:00 2001 From: Erling Rennemo Jellum Date: Wed, 7 Jun 2023 16:28:57 +0200 Subject: [PATCH 696/709] Update CI to use Zephyr v3.3.0 and SDK v0.16.1 --- .github/actions/setup-zephyr/action.yml | 16 ++++++++++------ .../org/lflang/generator/c/CCmakeGenerator.java | 4 ++-- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index e77ac6c0e4..079692d180 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -3,6 +3,10 @@ description: Install Zephyr and dependencies (Linux only) runs: using: "composite" steps: + - name: Setup environment variables + run: | + echo "SDK_VERSION=0.16.1" >> $GITHUB_ENV + echo "ZEPHYR_VERSION=3.3.0" >> $GITHUB_ENV - name: Dependencies run: | sudo apt-get update && sudo apt-get upgrade @@ -16,20 +20,20 @@ runs: shell: bash - name: Install Zephyr SDK run : | - wget -q https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.15.2/zephyr-sdk-0.15.2_linux-x86_64.tar.gz - wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.15.2/sha256.sum | shasum --check --ignore-missing - sudo tar xf zephyr-sdk-0.15.2_linux-x86_64.tar.gz --directory /opt/ - cd /opt/zephyr-sdk-0.15.2 + wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${SDK_VERSION}/zephyr-sdk-${SDK_VERSION}_linux-x86_64.tar.gz" + wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${SDK_VERSION}/sha256.sum | shasum --check --ignore-missing + sudo tar xf zephyr-sdk-${SDK_VERSION}_linux-x86_64.tar.gz --directory /opt/ + cd /opt/zephyr-sdk-${SDK_VERSION} sudo ./setup.sh -t all -h -c shell: bash - name: Download and install Zephyr RTOS run: | cd $HOME - west init zephyrproject --mr v3.2.0 + west init zephyrproject --mr v${ZEPHYR_VERSION} cd zephyrproject west update west zephyr-export pip install -r zephyr/scripts/requirements.txt echo "ZEPHYR_BASE=$HOME/zephyrproject/zephyr" >> $GITHUB_ENV - echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-0.15.2/" >> $GITHUB_ENV + echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-${SDK_VERSION}/" >> $GITHUB_ENV shell: bash diff --git a/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java b/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java index 860c85a75d..fd818b45a5 100644 --- a/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java +++ b/core/src/main/java/org/lflang/generator/c/CCmakeGenerator.java @@ -128,8 +128,8 @@ CodeBuilder generateCMakeCode( cMakeCode.pr("# Selecting default board"); cMakeCode.pr("set(BOARD qemu_cortex_m3)"); } - cMakeCode.pr("# We require Zephyr version 3.2.0"); - cMakeCode.pr("find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE} 3.2.0)"); + cMakeCode.pr("# We recommend Zephyr v3.3.0 but we are compatible with older versions also"); + cMakeCode.pr("find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE} 3.3.0)"); cMakeCode.newLine(); } From b12bbb407b6ba7a9cf3ee78d68e2a8e00ac6592d Mon Sep 17 00:00:00 2001 From: Christian Menard Date: Wed, 7 Jun 2023 12:56:29 +0200 Subject: [PATCH 697/709] Bumped klighd version and removed unofficial repo Fix https://github.com/lf-lang/lingua-franca/issues/1615 --- buildSrc/src/main/groovy/org.lflang.java-conventions.gradle | 4 ---- gradle.properties | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle b/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle index a600ba4ef8..4cbea8bf20 100644 --- a/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle +++ b/buildSrc/src/main/groovy/org.lflang.java-conventions.gradle @@ -5,10 +5,6 @@ plugins { repositories { mavenCentral() - // TODO Replace this unofficial maven repository as soon as Klighd is released to maven central in the future. - maven { - url "https://rtsys.informatik.uni-kiel.de/~kieler/files/repo/" - } } spotless { diff --git a/gradle.properties b/gradle.properties index 8d2599bdf6..e294dedf05 100644 --- a/gradle.properties +++ b/gradle.properties @@ -15,7 +15,7 @@ openTest4jVersion=1.2.0 picocliVersion=4.7.0 resourcesVersion=3.16.0 xtextVersion=2.28.0 -klighdVersion=2.2.1-SNAPSHOT +klighdVersion=2.3.0.v20230606 [manifestPropertyNames] org.eclipse.xtext=xtextVersion From ec70b77bf738b06b2074d91ffe71a40b96f0c0fd Mon Sep 17 00:00:00 2001 From: erlingrj Date: Wed, 7 Jun 2023 17:31:29 +0200 Subject: [PATCH 698/709] Fix setup-zephyr action --- .github/actions/setup-zephyr/action.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 079692d180..1c0505adce 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -21,15 +21,15 @@ runs: - name: Install Zephyr SDK run : | wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${SDK_VERSION}/zephyr-sdk-${SDK_VERSION}_linux-x86_64.tar.gz" - wget -O - https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${SDK_VERSION}/sha256.sum | shasum --check --ignore-missing - sudo tar xf zephyr-sdk-${SDK_VERSION}_linux-x86_64.tar.gz --directory /opt/ - cd /opt/zephyr-sdk-${SDK_VERSION} + wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${SDK_VERSION}/sha256.sum" | shasum --check --ignore-missing + sudo tar xf "zephyr-sdk-${SDK_VERSION}_linux-x86_64.tar.gz" --directory /opt/ + cd "/opt/zephyr-sdk-${SDK_VERSION}" sudo ./setup.sh -t all -h -c shell: bash - name: Download and install Zephyr RTOS run: | cd $HOME - west init zephyrproject --mr v${ZEPHYR_VERSION} + west init zephyrproject --mr "v${ZEPHYR_VERSION}"" cd zephyrproject west update west zephyr-export From c990231496a88fc7356c5d7bc4c2f3852dabe163 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Wed, 7 Jun 2023 18:47:31 +0200 Subject: [PATCH 699/709] Set shell --- .github/actions/setup-zephyr/action.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 1c0505adce..6a9d9053c3 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -7,6 +7,7 @@ runs: run: | echo "SDK_VERSION=0.16.1" >> $GITHUB_ENV echo "ZEPHYR_VERSION=3.3.0" >> $GITHUB_ENV + shell: bash - name: Dependencies run: | sudo apt-get update && sudo apt-get upgrade From 22be739671960ab9bb0584d887df0920ce7b385d Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 00:18:25 +0200 Subject: [PATCH 700/709] Try to use environment variable --- .github/actions/setup-zephyr/action.yml | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 6a9d9053c3..14f213050b 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -1,13 +1,11 @@ name: Install Zephyr and dependencies (Linux only) description: Install Zephyr and dependencies (Linux only) +env: + SDK_VERSION: 0.16.1 + ZEPHYR_VERSION: 3.3.0 runs: using: "composite" steps: - - name: Setup environment variables - run: | - echo "SDK_VERSION=0.16.1" >> $GITHUB_ENV - echo "ZEPHYR_VERSION=3.3.0" >> $GITHUB_ENV - shell: bash - name: Dependencies run: | sudo apt-get update && sudo apt-get upgrade @@ -21,20 +19,20 @@ runs: shell: bash - name: Install Zephyr SDK run : | - wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${SDK_VERSION}/zephyr-sdk-${SDK_VERSION}_linux-x86_64.tar.gz" - wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${SDK_VERSION}/sha256.sum" | shasum --check --ignore-missing - sudo tar xf "zephyr-sdk-${SDK_VERSION}_linux-x86_64.tar.gz" --directory /opt/ - cd "/opt/zephyr-sdk-${SDK_VERSION}" + wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" + wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/sha256.sum" | shasum --check --ignore-missing + sudo tar xf "zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" --directory /opt/ + cd "/opt/zephyr-sdk-$SDK_VERSION" sudo ./setup.sh -t all -h -c shell: bash - name: Download and install Zephyr RTOS run: | cd $HOME - west init zephyrproject --mr "v${ZEPHYR_VERSION}"" + west init zephyrproject --mr "v$ZEPHYR_VERSION" cd zephyrproject west update west zephyr-export pip install -r zephyr/scripts/requirements.txt echo "ZEPHYR_BASE=$HOME/zephyrproject/zephyr" >> $GITHUB_ENV - echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-${SDK_VERSION}/" >> $GITHUB_ENV + echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-$SDK_VERSION/" >> $GITHUB_ENV shell: bash From ccecb6d636183df4e129347c9aec4eae24c4e8e2 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 00:27:13 +0200 Subject: [PATCH 701/709] CI --- .github/actions/setup-zephyr/action.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 14f213050b..4cb1a235d2 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -1,9 +1,9 @@ name: Install Zephyr and dependencies (Linux only) description: Install Zephyr and dependencies (Linux only) -env: - SDK_VERSION: 0.16.1 - ZEPHYR_VERSION: 3.3.0 runs: + env: + SDK_VERSION: 0.16.1 + ZEPHYR_VERSION: 3.3.0 using: "composite" steps: - name: Dependencies From b4f897d34b7b26403b2ce293e8113c69dc4743a1 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 00:31:15 +0200 Subject: [PATCH 702/709] CI --- .github/actions/setup-zephyr/action.yml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 4cb1a235d2..cd3fac8492 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -1,9 +1,9 @@ name: Install Zephyr and dependencies (Linux only) description: Install Zephyr and dependencies (Linux only) +env: + SDK_VERSION: 0.16.1 + ZEPHYR_VERSION: 3.3.0 runs: - env: - SDK_VERSION: 0.16.1 - ZEPHYR_VERSION: 3.3.0 using: "composite" steps: - name: Dependencies @@ -19,20 +19,20 @@ runs: shell: bash - name: Install Zephyr SDK run : | - wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" - wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/sha256.sum" | shasum --check --ignore-missing - sudo tar xf "zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" --directory /opt/ - cd "/opt/zephyr-sdk-$SDK_VERSION" + wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.gz" + wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/sha256.sum" | shasum --check --ignore-missing + sudo tar xf "zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.gz" --directory /opt/ + cd "/opt/zephyr-sdk-${{env.SDK_VERSION}}" sudo ./setup.sh -t all -h -c shell: bash - name: Download and install Zephyr RTOS run: | cd $HOME - west init zephyrproject --mr "v$ZEPHYR_VERSION" + west init zephyrproject --mr "v${{env.ZEPHYR_VERSION}}" cd zephyrproject west update west zephyr-export pip install -r zephyr/scripts/requirements.txt echo "ZEPHYR_BASE=$HOME/zephyrproject/zephyr" >> $GITHUB_ENV - echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-$SDK_VERSION/" >> $GITHUB_ENV + echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-${{env.SDK_VERSION}}/" >> $GITHUB_ENV shell: bash From 53cac26efcc7c5134dc6d0d6846a048e00c8fd0a Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 00:39:24 +0200 Subject: [PATCH 703/709] More CI --- .github/actions/setup-zephyr/action.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index cd3fac8492..8105162409 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -19,20 +19,20 @@ runs: shell: bash - name: Install Zephyr SDK run : | - wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.gz" - wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/sha256.sum" | shasum --check --ignore-missing - sudo tar xf "zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.gz" --directory /opt/ - cd "/opt/zephyr-sdk-${{env.SDK_VERSION}}" + wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{SDK_VERSION}}/zephyr-sdk-${{SDK_VERSION}}_linux-x86_64.tar.gz" + wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{SDK_VERSION}}/sha256.sum" | shasum --check --ignore-missing + sudo tar xf "zephyr-sdk-${{SDK_VERSION}}_linux-x86_64.tar.gz" --directory /opt/ + cd "/opt/zephyr-sdk-${{SDK_VERSION}}" sudo ./setup.sh -t all -h -c shell: bash - name: Download and install Zephyr RTOS run: | cd $HOME - west init zephyrproject --mr "v${{env.ZEPHYR_VERSION}}" + west init zephyrproject --mr "v${{ZEPHYR_VERSION}}" cd zephyrproject west update west zephyr-export pip install -r zephyr/scripts/requirements.txt echo "ZEPHYR_BASE=$HOME/zephyrproject/zephyr" >> $GITHUB_ENV - echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-${{env.SDK_VERSION}}/" >> $GITHUB_ENV + echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-${{SDK_VERSION}}/" >> $GITHUB_ENV shell: bash From 3ad09d616c434f65b6e656c2bf22a1e7d4282a47 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 00:44:52 +0200 Subject: [PATCH 704/709] Go back to using GITHUB_ENV --- .github/actions/setup-zephyr/action.yml | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 8105162409..aa486e2f27 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -1,11 +1,13 @@ name: Install Zephyr and dependencies (Linux only) description: Install Zephyr and dependencies (Linux only) -env: - SDK_VERSION: 0.16.1 - ZEPHYR_VERSION: 3.3.0 runs: using: "composite" steps: + - name: Setup environment variables + run: | + echo "SDK_VERSION=0.16.1" >> $GITHUB_ENV + echo "ZEPHYR_VERSION=3.3.0" >> $GITHUB_ENV + shell: vash - name: Dependencies run: | sudo apt-get update && sudo apt-get upgrade @@ -19,20 +21,20 @@ runs: shell: bash - name: Install Zephyr SDK run : | - wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{SDK_VERSION}}/zephyr-sdk-${{SDK_VERSION}}_linux-x86_64.tar.gz" - wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{SDK_VERSION}}/sha256.sum" | shasum --check --ignore-missing - sudo tar xf "zephyr-sdk-${{SDK_VERSION}}_linux-x86_64.tar.gz" --directory /opt/ - cd "/opt/zephyr-sdk-${{SDK_VERSION}}" + wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" + wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/sha256.sum" | shasum --check --ignore-missing + sudo tar xf "zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" --directory /opt/ + cd "/opt/zephyr-sdk-$(SDK_VERSION)" sudo ./setup.sh -t all -h -c shell: bash - name: Download and install Zephyr RTOS run: | cd $HOME - west init zephyrproject --mr "v${{ZEPHYR_VERSION}}" + west init zephyrproject --mr "v$ZEPHYR_VERSION" cd zephyrproject west update west zephyr-export pip install -r zephyr/scripts/requirements.txt echo "ZEPHYR_BASE=$HOME/zephyrproject/zephyr" >> $GITHUB_ENV - echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-${{SDK_VERSION}}/" >> $GITHUB_ENV + echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-$SDK_VERSION/" >> $GITHUB_ENV shell: bash From 265cf0298f66e8eaf29318a89f09b7717d56ddaa Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 00:48:28 +0200 Subject: [PATCH 705/709] CI --- .github/actions/setup-zephyr/action.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index aa486e2f27..4f43e09c55 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -7,7 +7,7 @@ runs: run: | echo "SDK_VERSION=0.16.1" >> $GITHUB_ENV echo "ZEPHYR_VERSION=3.3.0" >> $GITHUB_ENV - shell: vash + shell: bash - name: Dependencies run: | sudo apt-get update && sudo apt-get upgrade From f806f4237c92cb51ed160c77d5ba1075d2250888 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 00:52:19 +0200 Subject: [PATCH 706/709] CI --- .github/actions/setup-zephyr/action.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 4f43e09c55..dfb69eede5 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -21,7 +21,7 @@ runs: shell: bash - name: Install Zephyr SDK run : | - wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" + wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/zephyr-sdk-${{SDK_VERSION}}_linux-x86_64.tar.gz" wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/sha256.sum" | shasum --check --ignore-missing sudo tar xf "zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" --directory /opt/ cd "/opt/zephyr-sdk-$(SDK_VERSION)" From 24f6cde52421f5d0d04246d9b172262344d28205 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 00:56:02 +0200 Subject: [PATCH 707/709] CI --- .github/actions/setup-zephyr/action.yml | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index dfb69eede5..68c57680a0 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -21,20 +21,20 @@ runs: shell: bash - name: Install Zephyr SDK run : | - wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/zephyr-sdk-${{SDK_VERSION}}_linux-x86_64.tar.gz" - wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v$SDK_VERSION/sha256.sum" | shasum --check --ignore-missing - sudo tar xf "zephyr-sdk-$SDK_VERSION_linux-x86_64.tar.gz" --directory /opt/ - cd "/opt/zephyr-sdk-$(SDK_VERSION)" + wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.gz" + wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/sha256.sum" | shasum --check --ignore-missing + sudo tar xf "zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.gz" --directory /opt/ + cd "/opt/zephyr-sdk-${{env.SDK_VERSION}}" sudo ./setup.sh -t all -h -c shell: bash - name: Download and install Zephyr RTOS run: | cd $HOME - west init zephyrproject --mr "v$ZEPHYR_VERSION" + west init zephyrproject --mr "v${{env.ZEPHYR_VERSION}}" cd zephyrproject west update west zephyr-export pip install -r zephyr/scripts/requirements.txt echo "ZEPHYR_BASE=$HOME/zephyrproject/zephyr" >> $GITHUB_ENV - echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-$SDK_VERSION/" >> $GITHUB_ENV + echo "ZEPHYR_SDK_INSTALL_DIR=/opt/zephyr-sdk-${{env.SDK_VERSION}}/" >> $GITHUB_ENV shell: bash From 225293c8c39bd088f5dbc28e9b5af4c3725c8215 Mon Sep 17 00:00:00 2001 From: erlingrj Date: Thu, 8 Jun 2023 01:02:26 +0200 Subject: [PATCH 708/709] CI --- .github/actions/setup-zephyr/action.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/actions/setup-zephyr/action.yml b/.github/actions/setup-zephyr/action.yml index 68c57680a0..32cd307172 100644 --- a/.github/actions/setup-zephyr/action.yml +++ b/.github/actions/setup-zephyr/action.yml @@ -21,9 +21,9 @@ runs: shell: bash - name: Install Zephyr SDK run : | - wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.gz" + wget -q "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.xz" wget -O - "https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v${{env.SDK_VERSION}}/sha256.sum" | shasum --check --ignore-missing - sudo tar xf "zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.gz" --directory /opt/ + sudo tar xvf "zephyr-sdk-${{env.SDK_VERSION}}_linux-x86_64.tar.xz" --directory /opt/ cd "/opt/zephyr-sdk-${{env.SDK_VERSION}}" sudo ./setup.sh -t all -h -c shell: bash From d1b278e63250e4fef0c5c96a5e0a96849c6491ba Mon Sep 17 00:00:00 2001 From: Peter Donovan Date: Wed, 7 Jun 2023 17:49:27 -0700 Subject: [PATCH 709/709] Fix error in programs with no main reactor. This error only occurs when using generics. It is possibly a sign that `ReactorInstance` is being used to do too many different things. It is a little problematic to have to put in a dummy value in order to get things to work. --- core/src/main/java/org/lflang/ast/ASTUtils.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/core/src/main/java/org/lflang/ast/ASTUtils.java b/core/src/main/java/org/lflang/ast/ASTUtils.java index 078505d958..60b5538372 100644 --- a/core/src/main/java/org/lflang/ast/ASTUtils.java +++ b/core/src/main/java/org/lflang/ast/ASTUtils.java @@ -1711,10 +1711,14 @@ public static Instantiation createInstantiation(Reactor reactor) { } else { inst.setName(""); } - } else { inst.setName(reactor.getName()); } + for (int i = 0; i < reactor.getTypeParms().size(); i++) { + Type t = LfFactory.eINSTANCE.createType(); + t.setId("UNSPECIFIED_TYPE"); + inst.getTypeArgs().add(t); + } return inst; }